DIRECTORY
GGBasicTypes, Feedback, GGInterfaceTypes, GGModelTypes, GGOutline, GGScene, GGSelect, GGSegmentTypes, GGSequence, GGTraj, GGUtility, GList, Imager, Rope;

GGOutlineImplB: CEDAR PROGRAM
IMPORTS Feedback, GGScene, GGOutline, GGSelect, GGSequence, GGTraj, GGUtility, GList
EXPORTS GGOutline = BEGIN
OPEN GGOutline;

BitVector: TYPE = GGBasicTypes.BitVector;
BoundBox: TYPE = GGBasicTypes.BoundBox;
CameraData: TYPE = GGModelTypes.CameraData;
Circle: TYPE = GGBasicTypes.Circle;
Color: TYPE = Imager.Color;
ControlPointGenerator: TYPE = GGModelTypes.ControlPointGenerator;
FeatureData: TYPE = GGInterfaceTypes.FeatureData;
GGData: TYPE = GGInterfaceTypes.GGData;
Joint: TYPE = GGSegmentTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
Line: TYPE = GGBasicTypes.Line;
AlignBag: TYPE = GGInterfaceTypes.AlignBag;
Outline: TYPE = REF OutlineObj;
OutlineObj: TYPE = GGModelTypes.OutlineObj;
OutlineClass: TYPE = REF OutlineClassObj;
OutlineClassObj: TYPE = GGModelTypes.OutlineClassObj;
OutlineDescriptor: TYPE = GGModelTypes.OutlineDescriptor;
OutlineDescriptorObj: TYPE = GGModelTypes.OutlineDescriptorObj;
OutlineParts: TYPE = REF OutlinePartsObj;
OutlinePartsObj: TYPE = GGOutline.OutlinePartsObj;
OutlineSequence: TYPE = GGSelect.OutlineSequence;
OutlineSequenceGenerator: TYPE = GGSelect.OutlineSequenceGenerator;
Point: TYPE = GGBasicTypes.Point;
PointGenerator: TYPE = GGModelTypes.PointGenerator;
PointPairGenerator: TYPE = GGModelTypes.PointPairGenerator;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SelectMode: TYPE = GGModelTypes.SelectMode;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
Sequence: TYPE = GGModelTypes.Sequence;
SliceClass: TYPE = REF SliceClassObj;
SliceClassObj: TYPE = GGModelTypes.SliceClassObj;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceParts: TYPE = GGModelTypes.SliceParts;
Traj: TYPE = REF TrajObj;
TrajEnd: TYPE = GGModelTypes.TrajEnd;
TrajGenerator: TYPE = REF TrajGeneratorObj;
TrajGeneratorObj: TYPE = GGModelTypes.TrajGeneratorObj;
TrajObj: TYPE = GGModelTypes.TrajObj;
TrajPartType: TYPE = GGModelTypes.TrajPartType;
TriggerBag: TYPE = GGInterfaceTypes.TriggerBag;
Vector: TYPE = GGBasicTypes.Vector;

OutlineDescribeProc: TYPE = GGModelTypes.OutlineDescribeProc;
OutlineFileoutProc: TYPE = GGModelTypes.OutlineFileoutProc;
OutlineFileinProc: TYPE = GGModelTypes.OutlineFileinProc;
OutlineUnionPartsProc: TYPE = GGModelTypes.OutlineUnionPartsProc;
OutlineDifferencePartsProc: TYPE = GGModelTypes.OutlineDifferencePartsProc;
OutlineAugmentPartsProc: TYPE = GGModelTypes.OutlineAugmentPartsProc;
OutlinePointsInDescriptorProc: TYPE = GGModelTypes.OutlinePointsInDescriptorProc;
OutlinePointPairsInDescriptorProc: TYPE = GGModelTypes.OutlinePointPairsInDescriptorProc;
OutlineNextPointProc: TYPE = GGModelTypes.OutlineNextPointProc;
OutlineNextPointPairProc: TYPE = GGModelTypes.OutlineNextPointPairProc;
OutlineClosestPointProc: TYPE = GGModelTypes.OutlineClosestPointProc;
OutlineClosestPointAndTangentProc: TYPE = GGModelTypes.OutlineClosestPointAndTangentProc;
OutlineClosestSegmentProc: TYPE = GGModelTypes.OutlineClosestSegmentProc;
OutlineSetArrowsProc: TYPE = GGModelTypes.OutlineSetArrowsProc;
OutlineGetArrowsProc: TYPE = GGModelTypes.OutlineGetArrowsProc;

Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = Feedback.Problem;

UnpackOnePointDescriptorOld: PUBLIC PROC [outlineD: OutlineDescriptor] RETURNS [traj: Traj, isACP: BOOL, segNum, cpNum, jointNum: NAT] = {
parts: OutlineParts;
theSeq: Sequence;
IF outlineD = NIL THEN RETURN[NIL, FALSE, 999, 999, 999];
parts _ NARROW[outlineD.parts];
traj _ NIL;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
IF traj # NIL THEN RETURN[NIL, FALSE, 999, 999, 999]
ELSE {
theSeq _ list.first;
traj _ theSeq.traj;
[isACP, segNum, cpNum, jointNum] _ GGSequence.UnpackOnePointSequence[theSeq];
};
};
ENDLOOP;
};

UnpackSimpleDescriptorOld: PUBLIC PROC [outlineD: OutlineDescriptor] RETURNS [success: BOOL, partType: TrajPartType, traj: Traj, joint: Joint _ NIL, jointNum: NAT _ 999, cp: Point, cpNum: NAT _ 999, seg: Segment _ NIL, segNum: NAT _ 999] = {
parts: OutlineParts;
theSeq: Sequence;
IF outlineD = NIL THEN RETURN[FALSE, joint, NIL, NIL, 999, [0,0]];
parts _ NARROW[outlineD.parts];
traj _ NIL;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
IF traj # NIL THEN RETURN[FALSE, joint, NIL, NIL, 999, [0,0]]
ELSE {
theSeq _ list.first;
traj _ theSeq.traj;
[success, partType, traj, joint, jointNum, cp, cpNum, seg, segNum] _ GGSequence.UnpackSimpleSequence[theSeq];
};
};
ENDLOOP;
};

UnpackSimpleDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [success: BOOL, partType: TrajPartType, traj: Traj, joint: Joint _ NIL, jointNum: NAT _ 999, cp: Point, cpNum: NAT _ 999, seg: Segment _ NIL, segNum: NAT _ 999] = {
ERROR Problem[msg: "Outlines are not slices yet"];
};

UnpackOnePointDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [traj: Traj, isACP: BOOL, segNum, cpNum, jointNum: NAT] = {
ERROR Problem[msg: "Outlines are not slices yet"];
};

UnpackOneSegmentDescriptorOld: PUBLIC PROC [outlineD: OutlineDescriptor] RETURNS [traj: Traj, segNum: NAT] = {
parts: OutlineParts;
theSeq: Sequence;
IF outlineD = NIL THEN RETURN[NIL, 999];
parts _ NARROW[outlineD.parts];
traj _ NIL;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
IF traj # NIL THEN RETURN[NIL, 999]
ELSE {
theSeq _ list.first;
traj _ theSeq.traj;
[segNum] _ GGSequence.UnpackOneSegmentSequence[theSeq];
};
};
ENDLOOP;
};


UnpackOneSegmentDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [traj: Traj, segNum: NAT] = {
ERROR Problem[msg: "Outlines are not slices yet"];
};

FindTrajInDescriptor: PUBLIC PROC [outlineD: OutlineDescriptor, traj: Traj] RETURNS [seq: Sequence] = {
outlineParts: OutlineParts;
outlineParts _ NARROW[outlineD.parts];
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL AND list.first.traj = traj THEN RETURN[list.first];
ENDLOOP;
RETURN[NIL];
};

PartsFromSequence: PUBLIC PROC [outline: Outline, seq: Sequence] RETURNS [sliceParts: SliceParts] = {
realParts: OutlineParts;
ptr: LIST OF Sequence;
trajGen: GGModelTypes.TrajGenerator;
sliceParts _ realParts _ NEW[OutlinePartsObj];
[realParts.seqs, ptr] _ GGUtility.StartSequenceList[];
trajGen _ TrajsInOutline[outline];
FOR traj: Traj _ GGScene.NextTraj[trajGen], GGScene.NextTraj[trajGen] UNTIL traj = NIL DO
IF traj = seq.traj THEN [realParts.seqs, ptr] _ GGUtility.AddSequence[seq, realParts.seqs, ptr]
ELSE [realParts.seqs, ptr] _ GGUtility.AddSequence[NIL, realParts.seqs, ptr];
ENDLOOP;
};

DescriptorFromSequence: PUBLIC PROC [outline: Outline, seq: Sequence] RETURNS [sliceD: OutlineDescriptor] = {
outlineParts: SliceParts;
outlineParts _ PartsFromSequence[outline, seq];
sliceD _ GGOutline.DescriptorFromParts[outline, outlineParts];
};

DescriptorFromParts: PUBLIC PROC [outline: Outline, sliceParts: SliceParts] RETURNS [sliceD: OutlineDescriptor] = {
sliceD _ NEW[OutlineDescriptorObj _ [outline, sliceParts]];
};
CopyParts: PUBLIC PROC [outline: Outline, parts: SliceParts] RETURNS [copy: SliceParts] = {
realParts, realCopyParts: OutlineParts;
copySeq: Sequence;
ptr: LIST OF Sequence;
realParts _ NARROW[parts];
copy _ realCopyParts _ NEW[OutlinePartsObj];
[realCopyParts.seqs, ptr] _ GGUtility.StartSequenceList[];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first = NIL THEN [realCopyParts.seqs, ptr] _ GGUtility.AddSequence[NIL, realCopyParts.seqs, ptr]
ELSE {
copySeq _ GGSequence.Copy[list.first];
[realCopyParts.seqs, ptr] _ GGUtility.AddSequence[copySeq, realCopyParts.seqs, ptr]
};
ENDLOOP;
};

AddHole: PUBLIC PROC [outline: Outline, hole: Traj] RETURNS [holier: Outline] = {
holier _ outline.class.copy[outline];
holier.children _ AppendTrajList[holier.children, LIST[hole]];
hole.parent _ holier;
hole.role _ hole;
UpdateBoundBox[holier];
};

ReplaceFence: PUBLIC PROC [outline: Outline, newFence: Traj] RETURNS [newOutline: Outline] = {
holeGen: TrajGenerator;
newTraj: Traj;
newOutline _ CreateOutline[newFence, outline.fillColor];
holeGen _ HolesOfOutline[outline];
FOR hole: Traj _ GGScene.NextTraj[holeGen], GGScene.NextTraj[holeGen] UNTIL hole = NIL DO
newTraj _ GGTraj.CopyTraj[hole];
newOutline.children _ AppendTrajList[newOutline.children, LIST[newTraj]];
newTraj.parent _ newOutline;
ENDLOOP;
UpdateBoundBox[newOutline];
};


ReplaceHole: PUBLIC PROC [outline: Outline, oldHole, newHole: Traj] RETURNS [newOutline: Outline] = {
holeGen: TrajGenerator;
newTraj, fence: Traj;
fence _ FenceOfOutline[outline];
newTraj _ GGTraj.CopyTraj[fence];
newOutline _ CreateOutline[newTraj, outline.fillColor];
holeGen _ HolesOfOutline[outline];
FOR hole: Traj _ GGScene.NextTraj[holeGen], GGScene.NextTraj[holeGen] UNTIL hole = NIL DO
IF hole = oldHole THEN {
newOutline.children _ AppendTrajList[newOutline.children, LIST[newHole]];
newHole.parent _ newOutline;
}
ELSE {
newTraj _ GGTraj.CopyTraj[hole];
newOutline.children _ AppendTrajList[newOutline.children, LIST[newTraj]];
newTraj.parent _ newOutline;
};
ENDLOOP;
UpdateBoundBox[newOutline];
};

OutlineOfTraj: PUBLIC PROC [traj: Traj] RETURNS [outline: Outline] = {
outline _ traj.parent;
};

SaveSelectionsInOutline: PUBLIC PROC [outline: Outline, scene: Scene] = {
outlineD: OutlineDescriptor;
outlineParts: OutlineParts;
outlineD _ GGSelect.FindSelectedOutline[outline, scene, hot];
ClearSelectionInOutline[outline, hot];
IF outlineD # NIL THEN {
outlineParts _ NARROW[outlineD.parts];
FOR seqList: LIST OF Sequence _ outlineParts.seqs, seqList.rest UNTIL seqList = NIL DO
IF seqList.first#NIL THEN GGTraj.SaveSelectionInSequence[seqList.first, hot];
ENDLOOP;
};
outlineD _ GGSelect.FindSelectedOutline[outline, scene, normal];
ClearSelectionInOutline[outline, normal];
IF outlineD # NIL THEN {
outlineParts _ NARROW[outlineD.parts];
FOR seqList: LIST OF Sequence _ outlineParts.seqs, seqList.rest UNTIL seqList = NIL DO
IF seqList.first#NIL THEN GGTraj.SaveSelectionInSequence[seqList.first, normal];
ENDLOOP;
};
outlineD _ GGSelect.FindSelectedOutline[outline, scene, active];
ClearSelectionInOutline[outline, active];
IF outlineD # NIL THEN {
outlineParts _ NARROW[outlineD.parts];
FOR seqList: LIST OF Sequence _ outlineParts.seqs, seqList.rest UNTIL seqList = NIL DO
IF seqList.first#NIL THEN GGTraj.SaveSelectionInSequence[seqList.first, active];
ENDLOOP;
};
};

ClearSelectionInOutline: PROC [outline: Outline, selectClass: SelectionClass] = {
trajGen: GGModelTypes.TrajGenerator;
trajGen _ TrajsInOutline[outline];
FOR traj: Traj _ GGScene.NextTraj[trajGen], GGScene.NextTraj[trajGen] UNTIL traj = NIL DO
GGTraj.ClearSelection[traj, selectClass];
ENDLOOP;
};

RemakeSelectionsFromOutline: PUBLIC PROC [outline: Outline, scene: Scene] = {
trajGen: GGModelTypes.TrajGenerator;
trajGen _ TrajsInOutline[outline];
FOR traj: Traj _ GGScene.NextTraj[trajGen], GGScene.NextTraj[trajGen] UNTIL traj = NIL DO
GGTraj.RemakeSelection[traj, scene, hot];
GGTraj.RemakeSelection[traj, scene, normal];
GGTraj.RemakeSelection[traj, scene, active];
ENDLOOP;
};

SequencesOfOutline: PUBLIC PROC [outlineD: OutlineDescriptor] RETURNS [seqList: LIST OF Sequence] = {
outlineParts: OutlineParts _ NARROW[outlineD.parts];
ptr: LIST OF Sequence;
[seqList, ptr] _ GGUtility.StartSequenceList[];
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN [seqList, ptr] _ GGUtility.AddSequence[list.first, seqList, ptr];
ENDLOOP;
};

RemoveTraj: PUBLIC PROC [outlineD: OutlineDescriptor, traj: Traj] RETURNS [newD: OutlineDescriptor] = {
outlineParts: OutlineParts _ NARROW[outlineD.parts];
seq: Sequence;
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first#NIL AND list.first.traj = traj THEN {
seq _ list.first;
GOTO Done;
};
REPEAT
Done => {
newSeqs: LIST OF Sequence _ NARROW[GList.Subst[NIL, seq, outlineParts.seqs]];
newParts: SliceParts _ NEW[OutlinePartsObj _ [newSeqs]];
newD _ DescriptorFromParts[outlineD.slice, newParts];
};
FINISHED => newD _ outlineD;
ENDLOOP;
};
UnpackHitData: PUBLIC PROC [hitData: REF ANY] RETURNS [traj: Traj, hitType: TrajPartType, segNum, cpNum, jointNum: INT, hitPoint: Point] = {
outlineHitData: OutlineHitData _ NARROW[hitData];
traj _ outlineHitData.traj;
hitType _ outlineHitData.hitType;
segNum _ outlineHitData.segNum;
cpNum _ outlineHitData.cpNum;
jointNum _ outlineHitData.jointNum;
hitPoint _ outlineHitData.hitPoint;
};

UpdateDescriptorBoundBoxes: PUBLIC PROC [outlineD: OutlineDescriptor] = {
parts: OutlineParts _ NARROW[outlineD.parts];
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN GGSequence.UpdateBoundBox[list.first];
ENDLOOP;
};
HasHoles: PUBLIC PROC [outline: Outline] RETURNS [BOOL] =  {
RETURN[outline.children.rest # NIL];
};

FenceOfOutline: PUBLIC PROC [outline: Outline] RETURNS [fence: Traj] =  {
fence _ outline.children.first;
};

HolesOfOutline: PUBLIC PROC [outline: Outline] RETURNS [trajGen: TrajGenerator] =  {
list: LIST OF Traj _ outline.children.rest;
trajGen _ NEW[TrajGeneratorObj _ [
list: list
]];
};

TrajsInOutline: PUBLIC PROC [outline: Outline] RETURNS [trajGen: TrajGenerator] =  {
list: LIST OF Traj _ outline.children;
trajGen _ NEW[TrajGeneratorObj _ [
list: list
]];
};

END.

ŠGGOutlineImplB.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last edited by Bier on January 22, 1987
Contents:  Procedures to implement the Outline Slice Class in Gargoyle.  Outlines consist of Trajectories which in turn consist of Segments.  Outline is the most important slice class.

Outline-Only operations.

outlineD describes either a single control point or a single joint.  Return the [segNum, cpNum] pair or the jointNum as appropriate.
outlineD describes either a single control point or a single joint.  Return the [segNum, cpNum] pair or the jointNum as appropriate.
Holes can be removed using DeleteSequence.
Should check for duplicates. -- Bier, February 20
Like CopyOutline except in one place.
Like CopyOutline except in one place.
Finds the unique outline to which traj belongs.
hotness.
normal selection.
active selection.
This outline has just been created by copying parts from an existing outline.  The selection information was copied as well.  Make sequences from the selection bits, and select these sequences.
hotness.
normal selection.
active selection.
Used by GGSelect to do a DeselectTraj.

This will go away when the Caret machinery is revised.
Update the bound boxes of all contained sequences.

Queries about Outlines.
Returns the unique fence trajectory of outline.
Generates all of the holes of outline.
Generates the fence and all of the holes of outline.
Κ4˜J˜Icodeš
œ™Kšœ
Οm
œ1™<Kš
œ'™'Kš
œΈ
™Έ
K™š
Οk	˜	Kš
Ϫ
˜™
K˜—šΟnœžœ
ž˜KšžœM˜TKšžœž˜—Kšžœ˜˜Kšœžœ˜)Kšœ
žœ˜'Kšœžœ˜+Kšœžœ˜#Kšœžœ˜Kšœžœ&˜AKšœ
žœ ˜1Kšœžœ˜'Kšœžœ˜#Kšœžœ˜3Kšœžœ˜Kšœ
žœ˜+Kšœ	žœžœ˜Kšœžœ˜+Kšœžœžœ˜)Kšœžœ ˜5Kšœžœ"˜9Kšœžœ%˜?Kšœžœžœ˜)Kšœžœ˜2Kšœžœ˜1Kšœžœ%˜CKšœžœ˜!Kšœžœ˜3Kšœžœ#˜;Kšœžœ˜!Kšœ	žœ˜'Kšœžœ!˜7Kšœžœ˜+Kšœžœ!˜5Kšœ
žœ˜'Kšœžœžœ˜%Kšœžœ˜1Kšœžœ ˜5Kšœžœ˜+Kšœžœžœ	˜Kšœ	žœ˜%Kšœžœžœ˜+Kšœžœ!˜7Kšœ	žœ˜%Kšœžœ˜/Kšœžœ˜/Kšœžœ˜#K˜Kšœžœ$˜=Kšœžœ#˜;Kšœžœ"˜9Kšœžœ&˜AKšœžœ+˜KKšœžœ(˜EKšœžœ.˜QKšœ#žœ2˜YKšœžœ%˜?Kšœžœ)˜GKšœžœ(˜EKšœ#žœ2˜YKšœžœ*˜IKšœžœ%˜?Kšœžœ%˜?K˜KšŸœžœ
žœžœ˜;—K˜K™K™šŸœžœ
žœžœžœžœ˜Š
Kš
œ„
™„
Kš
œ˜K˜Kšžœžœ
žœ
žœ
žœžœ˜9Kšœžœ˜Kšœžœ
˜šžœžœ
žœ"žœžœ
ž˜Fšžœžœ
žœ˜Jšžœžœ
žœ
žœ
žœžœ˜4šžœ˜Jš
œ˜Jš
œ˜Jš
œM˜MJ˜—J˜—Jšžœ
˜—K˜K˜—šŸœžœ
žœžœžœ5žœžœžœžœ
žœ˜ρ
Kš
œ˜K˜Kšžœžœ
žœ
žœ
žœ	žœžœ˜BKšœžœ˜Kšœžœ
˜šžœžœ
žœ"žœžœ
ž˜Fšžœžœ
žœ˜Jšžœžœ
žœ
žœ
žœ	žœžœ
˜=šžœ˜Jš
œ˜Jš
œ˜Jš
œm˜mJ˜—J˜—Jšžœ
˜—K˜K˜—šŸœžœ
žœžœžœ5žœžœžœžœ
žœ˜κ
Kšžœ-˜2K˜K˜—šŸœžœ
žœžœžœžœ˜ƒ
Kšžœ-˜2K˜K˜—š
Ÿœžœ
žœžœžœ˜nKš
œ„
™„
Kš
œ˜Kš
œ˜Kš
žœžœ
žœ
žœ
žœ˜(Kšœžœ˜Kšœžœ
˜šžœžœ
žœ"žœžœ
ž˜Fšžœžœ
žœ˜Jš
žœžœ
žœ
žœ
žœ˜#šžœ˜Jš
œ˜Jš
œ˜Jš
œ7˜7J˜—J˜—Jšžœ
˜—K˜K˜K˜—š
Ÿœžœ
žœžœžœ˜gKšžœ-˜2K˜K˜—šŸœžœ
žœ+žœ˜gKš
œ˜Kšœžœ˜&šžœžœ
žœ)žœžœ
ž˜MKš
žœžœ
žœžœ
žœ
˜GKšžœ
˜—Kšžœ
žœ˜K˜K˜—šŸœžœ#žœ˜eK˜Kšœžœ
žœ
˜Jš
œ$˜$Kš
œ.˜.Kš
œ6˜6Jš
œ"˜"šžœCžœžœ
ž˜YJš
œ_˜_Jšžœ/žœ˜MJšžœ
˜—J˜J˜—šŸœžœ
žœ#žœ ˜mK˜Kš
œ/˜/Kš
œ>˜>K˜K˜—šŸœžœ
žœ,žœ ˜sKšœ	žœ/˜;K˜—šŸ	œžœ
žœ'žœ˜[K˜'Kš
œ˜Kšœžœ
žœ
˜Kš
œ˜Kš
œ,˜,Kš
œ:˜:šžœžœ
žœ&žœžœ
ž˜JJšžœžœ
žœ3žœ˜hšžœ˜Jš
œ&˜&Jš
œS˜SJ˜—Jšžœ
˜—K˜K˜—šŸœžœ
žœ žœ˜QK™*K™1Kš
œ%˜%Kšœ2žœ˜>Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœžœ$žœ˜^K™%K˜Kš
œ˜Kš
œ8˜8Kš
œ"˜"šžœCžœžœ
ž˜YKš
œ ˜ Kšœ:žœ˜IKš
œ˜Kšžœ
˜—Kš
œ˜K˜K˜K˜—šŸœžœ,žœ˜eK™%K˜Kš
œ˜Kš
œ ˜ Kš
œ!˜!Kš
œ7˜7Kš
œ"˜"šžœCžœžœ
ž˜Yšžœžœ˜Kšœ:žœ˜IKš
œ˜K˜
—šžœ˜Kš
œ ˜ Kšœ:žœ˜IKš
œ˜K˜—Kšžœ
˜—Kš
œ˜K˜K˜—šŸ
œžœ
žœžœ˜FKš
œ/™/Kš
œ˜K˜K˜—šŸœžœ
žœ%˜IKš
œ˜˜Jš
Οb™—Kšœ8 œ˜=Jšœ! œ˜&šžœžœ
žœ˜Kšœžœ˜&šžœ=žœžœ
ž˜VJšžœžœ
žœ/ œ˜MJšžœ
˜—J˜Jš
 ™—Kšœ8 œ˜@Jšœ! œ˜)šžœžœ
žœ˜Kšœžœ˜&šžœ=žœžœ
ž˜VJšžœžœ
žœ7˜PJšžœ
˜—J˜Jš
 ™—Kšœ8 œ˜@Jšœ! œ˜)šžœžœ
žœ˜Kšœžœ˜&šžœ
žœ
žœ,žœžœ
ž˜VJšžœžœ
žœ/ œ˜PJšžœ
˜—J˜—J˜K˜—šŸœžœ4˜QJš
œ$˜$Jš
œ"˜"šžœCžœžœ
ž˜YJš
œ)˜)Jšžœ
˜—Jš
œ˜J˜—šŸœžœ
žœ%˜MK™Α
Jš
œ$˜$Jš
œ"˜"šžœCžœžœ
ž˜YJš
 ™Jšœ$ œ˜)Jš
 ™Jšœ$ œ˜,Jš
 ™Jšœ$ œ˜,Jšžœ
˜—K˜K˜—šŸœžœ
žœžœžœ
žœ˜eKšœžœ˜4Kšœžœ
žœ
˜Kš
œ/˜/šžœžœ
žœ)žœžœ
ž˜MJšžœžœ
žœB˜ZJšžœ
˜—K˜K˜—šŸ
œžœ
žœ+žœ˜gK™&Kšœžœ˜4K˜šžœžœ
žœ)žœžœ
ž˜Mšžœžœ
žœžœ˜3J˜Jšžœ˜
J˜—š
ž˜˜	Jš	œ	žœ
žœžœ
žœ˜MJšœžœ˜8Jš
œ5˜5J˜—Jšžœ˜—Jšžœ
˜—K˜—K™šŸ
œžœ
žœžœ
žœžœ>žœ˜Œ
K™6Kšœ!žœ
˜1Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ#˜#K˜K˜—šŸœžœ
žœ"˜IK™2Kšœžœ˜-šžœžœ
žœ"žœžœ
ž˜FJšžœžœ
žœ'˜?Jšžœ
˜—K˜—K™Kšœ œ
™š
Ÿœžœ
žœžœžœ˜<Kšžœžœ˜$K˜K˜—šŸœžœ
žœžœ˜IKš
œ/™/Kš
œ˜K˜K˜—šŸœžœ
žœžœ˜TKš
œ&™&Kšœžœ
žœ˜+šœ
žœ˜"Kš
œ
˜
K˜—K˜K˜—šŸœžœ
žœžœ˜TKš
œ4™4Kšœžœ
žœ˜&šœ
žœ˜"Kš
œ
˜
K˜—K˜K˜—Kšžœ
˜K˜—…—4²Ip