DIRECTORY
CoordSys, SVRay, Convert, DisplayListToTree, Imager, IO, PriorityQueue, Rope, SV3d, SVModelTypes, SVSceneTypes, SVSelect;

DisplayListToTreeImpl: CEDAR PROGRAM
IMPORTS Convert, CoordSys, SVRay, SVSelect, Imager, IO, PriorityQueue, Rope
EXPORTS DisplayListToTree =
BEGIN

Slice: TYPE = SVSceneTypes.Slice;
SliceDescriptor: TYPE = SVSceneTypes.SliceDescriptor;
SliceList: TYPE = SVSceneTypes.SliceList;
Camera: TYPE = SVModelTypes.Camera;
Composite: TYPE = REF CompositeObj;
CompositeObj: TYPE = SVSceneTypes.CompositeObj;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
CoordSysList: TYPE = SVModelTypes.CoordSysList;
CSGTree: TYPE = SVSceneTypes.CSGTree;
MasterObject: TYPE = SVSceneTypes.MasterObject;
Matrix4by4: TYPE = SV3d.Matrix4by4;
PointSetOp: TYPE = SVSceneTypes.PointSetOp; -- {union, intersection, difference}
Primitive: TYPE = REF PrimitiveObj;
PrimitiveObj: TYPE = SVSceneTypes.PrimitiveObj;
Scene: TYPE = SVSceneTypes.Scene;
Shape: TYPE = SVSceneTypes.Shape;
Surface: TYPE = REF ANY; -- may be RectSurface, TubeSurface, DiskSurface, or ShellSurface (of BasicObject3d), etc.
SurfaceArray: TYPE = SVSceneTypes.SurfaceArray;


CreateEmptyTree: PUBLIC PROC [] RETURNS [tree: CSGTree] = {
tree _ SVRay.MakeCSGTree[NIL, Imager.white, FALSE];
};
AssemblyToTree: PUBLIC PROC [assembly: Slice, scene: Scene, camera: Camera, oldTree: CSGTree _ NIL, ignoreMoving: BOOL _ FALSE] RETURNS [tree: CSGTree] = {
topAssembly: Slice;
topNode: REF ANY;
topAssembly _ assembly;
topNode _ AssemblyToNode[topAssembly, scene, FALSE, ignoreMoving]; -- Make the tree.
IF oldTree # NIL THEN  {
oldTree.son _ topNode;
tree _ oldTree;
}
ELSE tree _ SVRay.MakeCSGTree[topNode, scene.backgroundColor, scene.shadows];
};

AssemblyToNode: PROC [assembly: Slice, scene: Scene, inverted, ignoreMoving: BOOL] RETURNS [node: REF ANY] = {
IF assembly = NIL THEN RETURN[ NIL ];
WITH assembly.shape SELECT FROM
shape: Shape => {
newPrim: Primitive;
newPrim _ PrimitiveFromAssembly[assembly, scene, inverted, ignoreMoving];
node _ newPrim;
RETURN};
alist: SliceList => {
node _ AssemblyListToNode[alist, scene, assembly.name, ignoreMoving];
RETURN};
ENDCASE => ERROR;
}; -- end of AssemblyToNode

AssemblyListToNode: PROC [assemblyList: SliceList, scene: Scene, name: Rope.ROPE, ignoreMoving: BOOL] RETURNS [node: REF ANY] = {
list: LIST OF Slice _ assemblyList.list;
treeList: LIST OF REF ANY;
treeList _ AssemblyListToTreeList[list, scene, assemblyList.pointSetOp, ignoreMoving];
IF treeList = NIL THEN RETURN[ NIL ];
IF treeList.rest = NIL THEN {
node _ treeList.first;
RETURN}
ELSE { -- Inspect the treeList more carefully.
IF AllAreNil[treeList] THEN RETURN[NIL];
IF assemblyList.pointSetOp = intersection AND AnyAreNIL[treeList] THEN RETURN[ NIL ];
IF treeList.first = NIL AND assemblyList.pointSetOp = difference THEN RETURN[ NIL ];
treeList _ SpliceOutNILs[treeList];

IF treeList = NIL THEN RETURN[NIL];
IF treeList.rest = NIL THEN {
node _ treeList.first;
RETURN}
ELSE {
SELECT assemblyList.pointSetOp FROM
union => node _ MakeUnionNode[treeList, name, 1];
intersection => node _ MakeIntersectionNode[treeList, name, 1];
difference => node _ MakeDifferenceNode[treeList, name, 1];
ENDCASE => ERROR;
}; -- end ELSE
}; -- end of ELSE
}; -- end of AssemblyListToNode


MakeUnionNode: PROC [treeList: LIST OF REF ANY, name: Rope.ROPE, level: NAT] RETURNS [node: REF ANY] = {
leftNode, rightNode: REF ANY;
intermediateName: Rope.ROPE;
IF treeList = NIL THEN RETURN[ NIL];
IF treeList.rest = NIL THEN RETURN [treeList.first];
leftNode _ treeList.first;
rightNode _ MakeUnionNode[treeList.rest, name, level + 1];
intermediateName _ Rope.Concat [name, Convert.RopeFromInt[level]];
node _ NEW[CompositeObj _ [intermediateName, union, leftNode, rightNode]];
}; -- end of MakeUnionNode

MakeIntersectionNode: PROC [treeList: LIST OF REF ANY, name: Rope.ROPE, level: NAT] RETURNS [node: REF ANY] = {
leftNode, rightNode: REF ANY;
intermediateName: Rope.ROPE;
IF treeList = NIL THEN RETURN[ NIL];
IF treeList.rest = NIL THEN RETURN [treeList.first];
leftNode _ treeList.first;
rightNode _ MakeIntersectionNode[treeList.rest, name, level + 1];
intermediateName _ Rope.Concat [name, Convert.RopeFromInt[level]];
node _ NEW[CompositeObj _ [intermediateName, intersection, leftNode, rightNode]];
}; -- end of MakeIntersectionNode

MakeDifferenceNode: PROC [treeList: LIST OF REF ANY, name: Rope.ROPE, level: NAT] RETURNS [node: REF ANY] = {
leftNode, rightNode: REF ANY;
intermediateName: Rope.ROPE;
leftNode _ treeList.first;
rightNode _ MakeUnionNode[treeList.rest, name, level + 1];
intermediateName _ Rope.Concat [name, Convert.RopeFromInt[level]];
node _ NEW[CompositeObj _ [intermediateName, difference, leftNode, rightNode]];
}; -- end of MakeDifferenceNode

AssemblyListToTreeList: PROC [list: LIST OF Slice, scene: Scene, op: PointSetOp, ignoreMoving: BOOL] RETURNS [treeList: LIST OF REF ANY] = {
IF list = NIL THEN RETURN[ NIL ];
IF op = difference THEN 
treeList _ CONS[AssemblyToNode[assembly: list.first, scene: scene, inverted: FALSE, ignoreMoving: ignoreMoving], AssemblyListToTreeList2[list: list.rest, scene: scene, inverted: TRUE, ignoreMoving: ignoreMoving]]
ELSE
treeList _ CONS[AssemblyToNode[assembly: list.first, scene: scene, inverted: FALSE, ignoreMoving: ignoreMoving], AssemblyListToTreeList2[list: list.rest, scene: scene, inverted: FALSE, ignoreMoving: ignoreMoving]];
}; -- end of AssemblyListToTreeList

AssemblyListToTreeList2: PROC [list: LIST OF Slice, scene: Scene, inverted: BOOL, ignoreMoving: BOOL] RETURNS [treeList: LIST OF REF ANY] = {
IF list = NIL THEN RETURN[ NIL ];
treeList _ CONS[AssemblyToNode[list.first, scene, inverted, ignoreMoving], AssemblyListToTreeList2[list.rest, scene, inverted, ignoreMoving]]; 
}; -- end of AssemblyListToTreeList2


AllAreNil: PRIVATE PROC [list: LIST OF REF ANY] RETURNS [BOOL] = {
FOR l: LIST OF REF ANY _ list, l.rest UNTIL l = NIL DO
IF l.first # NIL THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

AnyAreNIL: PRIVATE PROC [list: LIST OF REF ANY] RETURNS [BOOL] = {
FOR l: LIST OF REF ANY _ list, l.rest UNTIL l = NIL DO
IF l.first = NIL THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};

SpliceOutNILs: PRIVATE PROC [list: LIST OF REF ANY] RETURNS [compressed: LIST OF REF ANY] = {
IF list = NIL THEN RETURN[ NIL];
IF list.first # NIL THEN compressed _ CONS[list.first, SpliceOutNILs[list.rest]]
ELSE compressed _ SpliceOutNILs[list.rest];
};

PrimitiveFromAssembly: PUBLIC PROC [slice: Slice, scene: Scene, inverted, ignoreMoving: BOOL] RETURNS [prim: Primitive] = {
mo: MasterObject;
shape: Shape;
sliceD, stillD: SliceDescriptor;
prim _ NEW[PrimitiveObj];
IF NOT ISTYPE[slice.shape, Shape] THEN ERROR PrimitiveAssemblyWithoutMO;
shape _ NARROW[slice.shape];
mo _ shape.mo;

IF ignoreMoving THEN {
sliceD _ SVSelect.FindSelectedSlice[slice, scene, normal];
IF sliceD = NIL THEN stillD _ mo.class.newParts[slice, NIL, [0,0,0], slice]
ELSE {
background, overlay, rubber, drag: SliceDescriptor;
[background, overlay, rubber, drag] _ mo.class.movingParts[sliceD.slice, sliceD.parts];
stillD _ mo.class.unionParts[background, overlay];
};
}
ELSE stillD _ mo.class.newParts[slice, NIL, [0,0,0], slice];
prim.name _ slice.name;
prim.artwork _ slice.artwork;
prim.assembly _ slice;
prim.mo _ mo;
prim.sliceD _ stillD;
prim.rayCast _ mo.class.rayCast;
prim.rayCastNoBBoxes _ mo.class.rayCastNoBBoxes;
prim.rayCastBoundingSpheres _ mo.class.rayCastBoundingSpheres;

prim.localCS _ shape.coordSys;
prim.scalars _ CoordSys.GetScalars[shape.coordSys];
prim.primWRTWorld _ CoordSys.WRTWorld[shape.coordSys];
prim.worldWRTPrim _ CoordSys.FindWorldInTermsOf[shape.coordSys];
prim.boundBox _ NIL; -- will be filled in at tree preprocess time
prim.boundHedron _ mo.class.getHedron[mo];
prim.inverted _ inverted;
prim.currentRay _ NIL;
prim.rayStepX _ NIL;
};
PrimitiveAssemblyWithoutMO: PUBLIC ERROR = CODE;
 
CoordSysListFromScene: PUBLIC PROC [scene: Scene] RETURNS [csl: CoordSysList] = {
csl _ CoordSysListFromAssembly[scene.assembly];
csl _ SortCoordSysListByBreadth[csl];
csl _ CONS[scene.coordSysRoot, csl]; -- add WORLD
};
CoordSysListFromAssembly: PROC [assem: Slice] RETURNS [csl: CoordSysList] = {
end: CoordSysList;
alist, apos, aend: LIST OF Slice;
root: CoordSystem _ assem.coordSys;
i: NAT _ 0;
end _ csl _ CONS[root, NIL];
aend _ alist _ CONS[assem, NIL];
FOR apos _ alist, apos.rest UNTIL apos = NIL DO
WITH apos.first.shape SELECT FROM
assemList: SliceList => {
FOR children: LIST OF Slice _ assemList.list, children.rest UNTIL children = NIL DO
end.rest _ CONS[children.first.coordSys, NIL];
aend.rest _ CONS[children.first, NIL];
end _ end.rest;
aend _ aend.rest;
i _ i+1;
IF i > 300 THEN ERROR;
ENDLOOP;
};
ENDCASE => {}; -- we have no children and are already on the list.
ENDLOOP;
};

SortCoordSysListByBreadth: PRIVATE PROC [csl: CoordSysList] RETURNS [sortedCsl: CoordSysList] = {
q: PriorityQueue.Ref;
thisRec, lastRec: CoordSysSortRec;
len: NAT _ ListLength[csl];
q _ PriorityQueue.Predict[len, SortProc];
FOR list: CoordSysList _ csl, list.rest UNTIL list = NIL DO
thisRec _ NEW[CoordSysSortRecObj _ [Depth[list.first], list]];
PriorityQueue.Insert[q, thisRec];
ENDLOOP;
lastRec _ NARROW[PriorityQueue.Remove[q]];
lastRec.coordSysCell.rest _ NIL;
FOR i: NAT IN [1..len-1] DO
thisRec _ NARROW[PriorityQueue.Remove[q]];
thisRec.coordSysCell.rest _ lastRec.coordSysCell;
lastRec _ thisRec;
ENDLOOP;
sortedCsl _ thisRec.coordSysCell;
}; -- end of SortCoordSysListByBreadth

CoordSysSortRec: TYPE = REF CoordSysSortRecObj;
CoordSysSortRecObj: TYPE = RECORD[
index: NAT,
coordSysCell: CoordSysList];

SortProc: SAFE PROC [x, y: PriorityQueue.Item, data: REF _ NIL] RETURNS [BOOL] = {
xRec: CoordSysSortRec _ NARROW[x];
yRec: CoordSysSortRec _ NARROW[y];
RETURN[xRec.index > yRec.index];
};

ListLength: PRIVATE PROC [csl: CoordSysList] RETURNS [len: NAT] = {
len _ 0;
FOR list: CoordSysList _ csl, list.rest UNTIL list = NIL DO
len _ len + 1;
ENDLOOP;
};

Depth: PRIVATE PROC [cs: CoordSystem] RETURNS [index: NAT] = {
thisCS: CoordSystem;
index _ 0;
thisCS _ cs;
UNTIL thisCS = NIL DO
index _ index + 1;
thisCS _ CoordSys.Parent[thisCS];
ENDLOOP;
};
ListTree: PUBLIC PROC [outHandle: IO.STREAM, tree: CSGTree] = {
indent: NAT _ 0;
node: REF ANY _ tree.son;
ListNode[outHandle, node, indent];
};

ListNode: PROC [outHandle: IO.STREAM, node: REF ANY, indent: NAT] = {
WITH node SELECT FROM
prim: Primitive => ListPrimitive[outHandle, prim, indent];
comp: Composite => ListComposite[outHandle, comp, indent];
ENDCASE => ERROR;
};

ListPrimitive: PROC [outHandle: IO.STREAM, prim: Primitive, indent: NAT] = {
FOR i: NAT IN[1..indent] DO outHandle.PutChar[IO.TAB] ENDLOOP;
outHandle.PutF["Primitive: %g\n",[rope[prim.name]]];
};

ListComposite: PROC [outHandle: IO.STREAM, comp: Composite, indent: NAT] = {
op: Rope.ROPE;
FOR i: NAT IN[1..indent] DO outHandle.PutChar[IO.TAB] ENDLOOP;
op _ SVRay.PointSetOpToRope[comp.operation];
outHandle.PutF["Composite: %g op: %g\n",[rope[comp.name]], [rope[op]]];
ListNode[outHandle, comp.leftSolid, indent + 1];
ListNode[outHandle, comp.rightSolid, indent + 1];
};

FindNodeFromName: PUBLIC PROC [tree: REF ANY, name: Rope.ROPE] RETURNS [node: REF ANY, success: BOOL] = {
WITH tree SELECT FROM
c: Composite => {[node, success] _ FindNodeFromNameInComposite[c, name]; RETURN};
p: Primitive => {[node, success] _ FindNodeFromNameInPrimitive[p, name]; RETURN};
ENDCASE => ERROR;
};

FindNodeFromNameInComposite: PROC [c: Composite, name: Rope.ROPE] RETURNS [node: REF ANY, success: BOOL] = {
IF Rope.Equal[c.name, name, TRUE] THEN RETURN[c, TRUE];
[node, success] _ FindNodeFromName[c.leftSolid, name];
IF success THEN RETURN;
[node, success] _ FindNodeFromName[c.rightSolid, name];
IF success THEN RETURN
ELSE RETURN[NIL, FALSE];
};

FindNodeFromNameInPrimitive: PROC [p: Primitive, name: Rope.ROPE] RETURNS [node: REF ANY, success: BOOL] = {
IF p.name = name THEN RETURN[p, TRUE]
ELSE RETURN[NIL, FALSE];
};

CommonAncestor: PUBLIC PROC [red: Slice, blue: Slice, root: Slice] RETURNS [gramps: Slice] = {
IF red = NIL THEN RETURN[blue];
IF blue = NIL THEN RETURN[red];
WITH root.shape SELECT FROM
shape: Shape => {
IF red = root AND blue = root THEN RETURN[root]
ELSE RETURN[NIL];
};
alist: SliceList => {
FOR sons: LIST OF Slice _ alist.list, sons.rest UNTIL sons = NIL DO
IF ContainsBoth[red, blue, sons.first] THEN RETURN[CommonAncestor[red, blue, sons.first]];
ENDLOOP;
IF ContainsBoth[red, blue, root] THEN RETURN[root]
ELSE RETURN[NIL];
};
ENDCASE => ERROR;
};

ContainsBoth: PRIVATE PROC [red: Slice, blue: Slice, root: Slice] RETURNS [BOOL] = {
RETURN[IsSuccessorOf[red, root] AND IsSuccessorOf[blue, root]];
};
IsSuccessorOf: PUBLIC PROC [testChild: Slice, testAncestor: Slice] RETURNS [BOOL] = {
WITH testAncestor.shape SELECT FROM
shape: Shape => {
IF testAncestor = testChild THEN RETURN[TRUE]
ELSE RETURN[FALSE];
};
alist: SliceList => {
IF testAncestor = testChild THEN RETURN[TRUE];
FOR list: LIST OF Slice _ alist.list, list.rest UNTIL list = NIL DO
IF IsSuccessorOf[testChild, list.first] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};
ENDCASE => ERROR;
};

AncestorAtLevel: PUBLIC PROC [child: Slice, root: Slice, level: NAT] RETURNS [gramps: Slice] = {
IF level = 0 THEN {
IF IsSuccessorOf[child, root] THEN RETURN[root]
ELSE RETURN[NIL];
}
ELSE {
WITH root.shape SELECT FROM
shape: Shape => RETURN[NIL]; -- level >0 and we have no children.
alist: SliceList => {
FOR list: LIST OF Slice _ alist.list, list.rest UNTIL list = NIL DO
gramps _ AncestorAtLevel[child, list.first, level-1];
IF gramps # NIL THEN RETURN;
ENDLOOP;
RETURN[NIL];
};
ENDCASE => ERROR;
};
};





END.

File: DisplayListToTreeImpl.mesa
Author: Eric Bier on January 1, 1983 11:43 pm
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Last edited by Bier on June 2, 1987 2:04:09 pm PDT
Contents: Code to extract a SVRay Tree from the recursive assemblylist-of-assemblylist DisplayList structure.
Here's the plan:  Each assembly list has an associated PointSetOp.  If this op is null, it defaults to "union".  Intersection means the intersection of all objects on the assembly list.  Union is the union of all of them.  Difference is the first one minus all of the others.
Adds background color, and shadow information and packages up into a CSGTree record.
If assembly is a primitive assembly, return a primitive SVRay node.  Otherwise, call AssemblyListToNode on its children and return the resulting tree.
We have a list of composite assemblies and/or primitive assemblies.  Turn this into a list of Composites, Primitives and NILs:
Now we will inspect our list in order to combine the trees we have made.
If there are no children, then this node is NIL.  It has no effect on the ray tracing.
If there is only one item in the list then the node for this assembly is the node produced for its son.
If all of the children are NIL, so is this node.
If the operation is intersection and any are NIL then so is the node.
IF the first is NIL and the operation is difference then the node is NIL.
We have handled all cases which involve NILs.  For all other cases, we should ignore them, so we will remove them now:
At this point, we must reconsider the possibility that we may have a null list or single member list.
Since it is now clear that this node has more than one child, we make n-1 Composite nodes for it (if there are n children remaining).
In the top level call to MakeUnionNode, treeList should have at least 2 members and none of its members should be NIL.
In the top level call to MakeIntersectionNode, treeList should have at least 2 members and none of its members should be NIL.
In the top level call to MakeDifferenceNode, treeList should have at least 2 members and none of its members should be NIL.
If there are no children, then this node is NIL.  It has no effect on the ray tracing.
Go down the list turning each primitive or composite assembly into a Composite or Primitive.
If there are no children, then this node is NIL.  It has no effect on the ray tracing.
Go down the list turning each primitive or composite assembly into a Composite or Primitive.
A Kludge for Now
prim.hints will be filled in at preprocess time
Returns a list of all of the assembly coordinate systems (not including the scalars-only shape coordinate systems).  The list is in breadth-first order.

Because the coordinate system and assembly trees need not be isomorphic, we must be careful to
1)  Put into the list only those coordinate systems belonging to assemblies, but
2) Sort the list by depth order of the coordinate systems.
One unreasonable way to do this is to tree walk the assemblies to make the list and then sort by depth (which we uncover in NlogN fashion by looking up the tree every bloody time).  A better solution is to have a "depth" field in coordinate systems, but that will come later.

We do not currently store a node's depth in that node.  We recover this information stupidly in an NlogN sort of way by walking to the root from each node.  Then we sort these depth numbers.  This sorting is used to fileout scene trees.  Of course, sorting is NlogN as well.  Maybe I will use a bucket sort someday.
We sort deep to shallow so we can put the list together backwards
Index is distance from WORLD coordsys

Here's where it hurts that assemblys don't point to their parents.  For now, I will try a brute force approach.  Starting at the root, I will walk down the tree until I find a node which contatins red and blue but none of whose children contains both.  Returns NIL if no such node exists  (perhaps root is below the real gramps, etc.).
If root is a Primitive then root can only be gramps if red = blue = root;
Could any of root's sons be gramps?
None of the sons contain both.  If I contain both, I am gramps.
A Composite assembly contains if
1) It is lookFor.
2) It has a son which contains lookFor.
Returns the ancestor of child which is level levels below root.  If level is 0, should return root.  If level = 1, an immediate child of root and so on.  Works recursively as follows:  If level is 0 then if root contains child, return root, else return NIL.  If level > 0 then return the first non-NIL value returned by one of the children, or NIL if there are none.
Κέ–

"cedar" style˜IheadšΟnœ™ Iprocšœ'™-Jšœ
Οm
œ1™<Lš
œ2™2Lšœe™mL˜š
Οk	˜	Lšœ5ŸœB˜yL˜—LšœŸœ
Ÿ˜$LšŸœ-Ÿœ˜KLšŸœ˜Lš
Ÿ˜˜LšœŸœ˜!LšœŸœ ˜5LšœŸœ˜)LšœŸœ˜#LšœŸœŸœ˜#LšœŸœ˜/Lšœ
Ÿœ˜-LšœŸœ˜/Lšœ	Ÿœ˜%LšœŸœ˜/LšœŸœ˜#LšœŸœΟc$˜PLšœŸœŸœ˜#LšœŸœ˜/LšœŸœ˜!LšœŸœ˜!Lšœ	ŸœŸœ
Ÿœ Y˜rLšœŸœ˜/L˜L˜—šœŸœ
ŸœŸœ˜;LšœŸœŸœ˜3L˜—šœŸœ
ŸœDŸœŸœŸœŸœ˜›
Lš
œ“™“Lš
œ˜Lšœ	Ÿœ
Ÿœ
˜Lš
œ˜Lšœ-Ÿœ ˜TšŸœŸœ
Ÿœ˜Lš
œ˜Lš
œ˜L˜
—LšŸœI˜MLš
ΟbT™TLš
œ˜L˜—šœŸœ9ŸœŸœŸœ
Ÿœ˜nLš
œ–
™–
Lš
ŸœŸœ
Ÿœ
ŸœŸœ˜%šŸœŸœ
Ÿ˜š
œ˜Lš
œ˜Lš
œI˜ILš
œ˜LšŸœ˜—š
œ˜Lš
œE˜ELšŸœ˜—LšŸœŸœ
˜—Lšœ ˜L˜—šœŸœ4ŸœŸœŸœŸœ
Ÿœ˜
LšœŸœ
Ÿœ˜(Lš	œ
Ÿœ
Ÿœ
Ÿœ
Ÿœ
˜L™~Lš
œV˜VL™HLšœ,Ÿœ'™VLš
ŸœŸœ
Ÿœ
ŸœŸœ˜%Lš
œg™gšŸœŸœ
Ÿœ˜Lš
œ˜LšŸœ
˜—šŸœ '˜.LšœŸœ™0LšŸœŸœ
Ÿœ
Ÿœ˜(Lšœ-Ÿœ™ELš
Ÿœ(ŸœŸœ
ŸœŸœ˜ULšŸœŸœ2Ÿœ
™ILšŸœŸœ
Ÿœ&Ÿœ
ŸœŸœ˜TL™vLš
œ#˜#L˜L™eLš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜#šŸœŸœ
Ÿœ˜Lš
œ˜LšŸœ
˜—LšŸœ˜L™…
šŸœŸ˜#Lš
œ1˜1Lš
œ?˜?Lš
œ;˜;LšŸœŸœ
˜Lšœ ˜—Lšœ ˜—Lšœ œ
˜ —L˜š
œŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ	ŸœŸœŸœ
Ÿœ˜hLšœrŸœ
™vLšœŸœ
Ÿœ
˜LšœŸœ
˜Lš
ŸœŸœ
Ÿœ
ŸœŸœ˜$LšŸœŸœ
Ÿœ
Ÿœ˜4Lš
œ˜Lš
œ:˜:Lš
œB˜BLšœŸœ@˜JLšœ œ
˜—šœŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ	ŸœŸœŸœ
Ÿœ˜oLšœyŸœ
™}LšœŸœ
Ÿœ
˜LšœŸœ
˜Lš
ŸœŸœ
Ÿœ
ŸœŸœ˜$LšŸœŸœ
Ÿœ
Ÿœ˜4Lš
œ˜Lš
œA˜ALš
œB˜BLšœŸœG˜QLšœ œ
˜"—šœŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ	ŸœŸœŸœ
Ÿœ˜mLšœwŸœ
™{LšœŸœ
Ÿœ
˜LšœŸœ
˜Lš
œ˜Lš
œ:˜:Lš
œB˜BLšœŸœE˜OLšœ ˜—L˜šœŸœŸœ
Ÿœ4ŸœŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜Œ
Lšœ,Ÿœ'™VLš
ŸœŸœ
Ÿœ
ŸœŸœ˜!Lš
œ\™\šŸœŸœ
˜LšœŸœ>Ÿœ`Ÿœ˜Τ
—š
Ÿ˜LšœŸœ>Ÿœ`Ÿœ˜Φ
—Lšœ  œ
˜$—šœŸœŸœ
Ÿœ ŸœŸœŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜
Lšœ,Ÿœ'™VLš
ŸœŸœ
Ÿœ
ŸœŸœ˜!Lš
œ\™\LšœŸœ€
˜
Lšœ !œ
˜%—L˜š	œŸœ
ŸœŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ˜BšŸœŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ
Ÿ˜6Lš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜$—LšŸœ
˜LšŸœ
Ÿœ˜
L˜—š	œŸœ
ŸœŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ˜BšŸœŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ
Ÿ˜6Lš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜#—LšŸœ
˜LšŸœ
Ÿœ˜L˜—š
œŸœ
ŸœŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜]š
ŸœŸœ
Ÿœ
ŸœŸœ˜ LšŸœŸœ
ŸœŸœ&˜PLšŸœ'˜+L˜——J˜š
œŸœ
Ÿœ6ŸœŸœ˜{Jš
œ˜Jš
œ
˜
J˜ JšœŸœ˜Jš
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ˜HJšœŸœ˜Jš
œ˜J˜J™šŸœŸœ˜Jš
œ:˜:JšŸœ
Ÿœ
Ÿœ#Ÿœ˜KšŸœ˜Jš
œ3˜3Jš
œW˜WJš
œ2˜2J˜—J˜
—JšŸœ#Ÿœ˜<Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
Jš
œ˜Jš
œ ˜ Jš
œ0˜0Jš
œ>˜>J˜Jš
œ˜Jš
œ3˜3Jš
œ6˜6Jš
œ@˜@Jš
œ/™/JšœŸœ ,˜AJš
œ*˜*Jš
œ˜JšœŸœ
˜JšœŸœ
˜Jš
œ˜—JšœŸœ
ŸœŸœ
˜0L˜
šœŸœ
ŸœŸœ˜QL™˜
Lš
œ/˜/Lš
œ%˜%LšœŸœ ˜1L˜L™—šœŸœŸœ˜ML˜LšœŸœ
Ÿœ˜!Lš
œ#˜#LšœŸœ˜LšœŸœŸœ˜LšœŸœŸœ˜ šŸœŸœŸœ
Ÿ˜/LšŸœŸœ
Ÿ˜!š
œ˜šŸœŸœ
Ÿœ'ŸœŸœ
Ÿ˜SLšœŸœŸœ˜.LšœŸœŸœ˜&L˜Lš
œ˜L˜LšŸœ	Ÿœ
Ÿœ
˜—LšŸœ
˜L˜—LšŸœ 3˜B—LšŸœ
˜L˜L˜—L™^L™PL™:L™“L™šœŸœ
ŸœŸœ˜aLš
œ»™»Lš
œ˜Lš
œ"˜"LšœŸœ‘
œ˜Lš
œ)˜)šŸœ%ŸœŸœ
Ÿ˜;Lšœ
Ÿœ‘œ˜>Lš‘œ
˜!—šŸœ
˜Lš
œA™A—Lšœ
Ÿœ
‘œ˜*LšœŸœ
˜ šŸœŸœ
ŸœŸ˜Lšœ
Ÿœ
‘œ˜*Lš
œ1˜1Lš
œ˜—LšŸœ
˜Lš
œ!˜!Lšœ #˜&L˜—LšœŸœŸœ˜/šœŸœŸœ
˜"LšœŸœ
˜Lš
œ˜L˜—šœŸœ
Ÿœ"ŸœŸœŸœŸœ˜RLšœŸœ˜"LšœŸœ˜"LšŸœ˜ Lš
œ˜L˜—š

œŸœ
ŸœŸœŸœ˜CLš
œ˜šŸœ%ŸœŸœ
Ÿ˜;Lš
œ˜—LšŸœ
˜Lš
œ˜L˜—š
œŸœ
ŸœŸœ	Ÿœ˜>LšœŸœ	™%Lš
œ˜Lš
œ
˜
Lš
œ˜šŸœ
Ÿœ
Ÿ˜Lš
œ˜Lš
œ!˜!LšŸœ
˜—Lš
œ˜L™—š
œŸœ
Ÿœ
Ÿœ
Ÿœ˜?LšœŸœ˜LšœŸœ
Ÿœ˜Lš
œ"˜"Lš
œ˜L˜—šœŸœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ˜EšŸœŸœ
Ÿ˜Lš
œ:˜:Lš
œ:˜:LšŸœŸœ
˜—Lš
œ˜L˜—š

œŸœ
Ÿœ
ŸœŸœ˜LLšŸœŸœ
ŸœŸœŸœ
ŸœŸœ
˜>Lš
œ4˜4Lš
œ˜L˜—š

œŸœ
Ÿœ
ŸœŸœ˜LLšœ	Ÿœ
˜LšŸœŸœ
ŸœŸœŸœ
ŸœŸœ
˜>Lš
œ,˜,Lš
œG˜GLš
œ0˜0Lš
œ1˜1Lš
œ˜—L˜šœŸœ
ŸœŸœ
Ÿœ
ŸœŸœŸœ
ŸœŸœ˜išŸœŸœ
Ÿ˜LšœIŸœ˜QLšœIŸœ˜QLšŸœŸœ
˜—Lš
œ˜L˜—šœŸœŸœŸœŸœ
ŸœŸœ˜lLš
ŸœŸœŸœ
ŸœŸœ˜7Lš
œ6˜6LšŸœ	Ÿœ
Ÿœ
˜Lš
œ7˜7LšŸœ	Ÿœ
Ÿ˜LšŸœ
Ÿœ
ŸœŸœ˜Lš
œ˜L˜—šœŸœŸœŸœŸœ
ŸœŸœ˜lšŸœŸœ
ŸœŸœ
˜%LšŸœ
Ÿœ
ŸœŸœ˜Lš
œ˜——L˜šœŸœ
Ÿœ(Ÿœ˜^Lšœ…ŸœG™ΟLšŸœŸœ
Ÿœ
Ÿœ˜LšŸœŸœ
Ÿœ
Ÿœ˜LšŸœŸœ
Ÿ˜˜L™ILšŸœŸœ
Ÿœ
Ÿœ˜/LšŸœ
Ÿœ
Ÿœ˜L˜—š
œ˜L™#šŸœŸœ
ŸœŸœŸœ
Ÿ˜CLšŸœ%Ÿœ
Ÿœ(˜Z—LšŸœ
˜L™?LšŸœŸœ
Ÿœ˜2LšŸœ
Ÿœ
Ÿœ˜L˜—LšŸœŸœ
˜L˜L˜—š
œŸœ
Ÿœ(ŸœŸœ˜TLšŸœŸœ˜?L˜—–

"Cedar" styleš

œŸœ
Ÿœ)ŸœŸœ˜ULšŸœŸœ
Ÿ˜#˜LšŸœŸœ
Ÿœ
Ÿœ
˜-LšŸœ
Ÿœ
Ÿœ˜L˜—š
œ˜Lš
œ ™ Lš
œ™L™'J–

"Cedar" stylešŸœŸœ
Ÿœ
Ÿœ˜.–

"Cedar" stylešŸœŸœ
ŸœŸœŸœ
Ÿ˜CJ–

"Cedar" stylešŸœ&Ÿœ
Ÿœ
Ÿœ˜:—J–

"Cedar" stylešŸœ
˜J–

"Cedar" stylešŸœ
Ÿœ˜J–

"Cedar" style˜—J–

"Cedar" stylešŸœŸœ
˜J–

"Cedar" style˜J–

"Cedar" style˜—–

"Cedar" styleš
œŸœ
Ÿœ$ŸœŸœ˜`J–

"Cedar" styleš	œ'‘œΡ
Ÿœ*Ÿœ+Ÿœ™ξ–

"Cedar" stylešŸœŸœ˜J–

"Cedar" stylešŸœŸœ
Ÿœ˜/J–

"Cedar" stylešŸœ
Ÿœ
Ÿœ˜J–

"Cedar" style˜
—–

"Cedar" stylešŸœ˜J–

"Cedar" stylešŸœŸœ
Ÿ˜J–

"Cedar" stylešœŸœ
Ÿœ $˜A–

"Cedar" styleš
œ˜–

"Cedar" stylešŸœŸœ
ŸœŸœŸœ
Ÿ˜CJ–

"Cedar" styleš
œ5˜5J–

"Cedar" stylešŸœ
Ÿœ
Ÿœ
Ÿœ
˜—J–

"Cedar" stylešŸœ
˜J–

"Cedar" stylešŸœ
Ÿœ˜J–

"Cedar" style˜—J–

"Cedar" stylešŸœŸœ
˜J–

"Cedar" style˜—–

"Cedar" style˜J–

"Cedar" style˜—J–

"Cedar" style˜—–

"Cedar" style˜J–

"Cedar" style˜—L˜LšŸœ
˜L˜—…—5\ο