DIRECTORY
Feedback, GGBasicTypes, GGCoreTypes, GGInterfaceTypes, GGModelTypes, GGParent, GGSegmentTypes, GGSequence, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, Rope;

GGSequenceImpl: CEDAR PROGRAM
IMPORTS Feedback, GGParent, GGSequence, GGSlice, GGSliceOps, GGTraj, GGUtility
EXPORTS GGSequence = BEGIN

BezierDragRecord: TYPE = GGInterfaceTypes.BezierDragRecord;
BitMatrix: TYPE = GGBasicTypes.BitMatrix;
BitMatrixObj: TYPE = GGBasicTypes.BitMatrixObj;
BitVector: TYPE = GGBasicTypes.BitVector;
BitVectorObj: TYPE = GGBasicTypes.BitVectorObj;
Color: TYPE = Imager.Color;
ControlPointGenerator: TYPE = GGModelTypes.ControlPointGenerator;
ControlPointGeneratorObj: TYPE = GGModelTypes.ControlPointGeneratorObj;
EditConstraints: TYPE = GGModelTypes.EditConstraints;
Joint: TYPE = GGModelTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
JointGeneratorObj: TYPE = GGModelTypes.JointGeneratorObj;
JointWalkProc: TYPE = GGSequence.JointWalkProc;
Point: TYPE = GGBasicTypes.Point;
PointAndDone: TYPE = GGModelTypes.PointAndDone;
PointWalkProc: TYPE = GGModelTypes.PointWalkProc;
SegAndIndex: TYPE = GGSequence.SegAndIndex;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SegmentGeneratorObj: TYPE = GGModelTypes.SegmentGeneratorObj;
SegmentWalkProc: TYPE = GGSequence.SegmentWalkProc;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
SequenceGenerator: TYPE = GGSequence.SequenceGenerator;
SequenceGeneratorObj: TYPE = GGSequence.SequenceGeneratorObj;
SequenceOfReal: TYPE = GGCoreTypes.SequenceOfReal;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceParts: TYPE = GGModelTypes.SliceParts;
StrokeEnd: TYPE = Imager.StrokeEnd;
Traj: TYPE = GGModelTypes.Traj;
TrajData: TYPE = GGModelTypes.TrajData;
TrajEnd: TYPE = GGModelTypes.TrajEnd;
TrajParts: TYPE = GGModelTypes.TrajParts;
TrajPartsObj: TYPE = GGModelTypes.TrajPartsObj;
TrajPartType: TYPE = GGModelTypes.TrajPartType;

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


CreateFromSegments: PUBLIC PROC [traj: TrajData, startSeg, endSeg: NAT] RETURNS [seq: TrajParts] = {
segCount, temp: NAT;
IF startSeg >= traj.segCount OR endSeg >= traj.segCount THEN ERROR;
IF startSeg = endSeg THEN {seq _ CreateFromSegment[traj, startSeg]; RETURN};
IF traj.role = open THEN {
IF startSeg > endSeg THEN {temp _ startSeg; startSeg _ endSeg; endSeg _ temp};
segCount _ endSeg - startSeg + 1;
}
ELSE {
IF startSeg = (endSeg + 1) MOD traj.segCount THEN {seq _ CreateComplete[traj]; RETURN};
segCount _ ((endSeg - startSeg + traj.segCount) MOD traj.segCount) + 1;
};
seq _ NEW[TrajPartsObj _ [
segments: NewBitVector[traj.segCount],
joints: NewBitVector[GGTraj.HiJointTraj[traj] + 1],
controlPoints: NewBitMatrix[traj],
segCount: segCount,
controlPointCount: 0, -- will be updated by FillInControlPoints
jointCount: 0 -- will be updated by FillInJoints
]];
IF startSeg < endSeg THEN {
FOR i: NAT IN [startSeg..endSeg] DO
seq.segments[i] _ TRUE;
ENDLOOP;
FillInJoints[seq];
FillInControlPoints[seq];
}
ELSE {
FOR i: NAT IN [startSeg..traj.segCount) DO
seq.segments[i] _ TRUE;
ENDLOOP;
FOR i: NAT IN [0..endSeg] DO
seq.segments[i] _ TRUE;
ENDLOOP;
FillInJoints[seq];
FillInControlPoints[seq];
};
};

CreateJointToJoint: PUBLIC PROC [traj: TrajData, startJoint, endJoint: NAT] RETURNS [seq: TrajParts] = {
temp, hiJoint: NAT;
hiJoint _ GGTraj.HiJointTraj[traj];
IF traj.role = open AND startJoint = 0 AND endJoint = hiJoint THEN {
seq _ CreateComplete[traj]; RETURN};
IF traj.role = open OR startJoint < endJoint THEN {
IF startJoint > endJoint THEN {temp _ startJoint; startJoint _ endJoint; endJoint _ temp};
IF startJoint < 0 OR endJoint > hiJoint THEN ERROR;
seq _ NEW[TrajPartsObj _ [
segments: NewBitVector[traj.segCount],
joints: NewBitVector[hiJoint+1],
controlPoints: NewBitMatrix[traj],
segCount: endJoint - startJoint,
controlPointCount: 0, -- initialized by FillInControlPoints
jointCount: endJoint - startJoint + 1
]];
FOR i: NAT IN [startJoint..endJoint) DO
seq.segments[i] _ TRUE;
seq.joints[i] _ TRUE;
ENDLOOP;
seq.joints[endJoint] _ TRUE;
}
ELSE {
IF startJoint = endJoint THEN {seq _ CreateFromJoint[traj, startJoint]; RETURN};
seq _ NEW[TrajPartsObj _ [
segments: NewBitVector[traj.segCount],
joints: NewBitVector[hiJoint+1],
controlPoints: NewBitMatrix[traj],
segCount: traj.segCount - startJoint + endJoint,
controlPointCount: 0,
jointCount: traj.segCount - startJoint + endJoint + 1
]];
FOR i: NAT IN [startJoint..traj.segCount) DO
seq.segments[i] _ TRUE;
seq.joints[i] _ TRUE;
ENDLOOP;
FOR i: NAT IN [0..endJoint) DO
seq.segments[i] _ TRUE;
seq.joints[i] _ TRUE;
ENDLOOP;
seq.joints[endJoint] _ TRUE;
};
FillInControlPoints[seq]; -- after all is said and done
};

CreateEmpty: PUBLIC PROC [traj: TrajData] RETURNS [seq: TrajParts] = {
seq _ NEW[TrajPartsObj _ [
segments: NewBitVector[traj.segCount],
joints: NewBitVector[GGTraj.HiJointTraj[traj]+1],
controlPoints: NewBitMatrix[traj],
segCount: 0,
controlPointCount: 0,
jointCount: 0
]];
};

CreateComplete: PUBLIC PROC [traj: TrajData] RETURNS [seq: TrajParts] = {
jointCount: NAT _ GGTraj.HiJointTraj[traj] + 1;
seq _ NEW[TrajPartsObj _ [
segments: NewBitVector[traj.segCount],
joints: NewBitVector[jointCount],
controlPoints: NewBitMatrix[traj],
segCount: traj.segCount,
controlPointCount: 0, -- set by FillInControlPoints
jointCount: jointCount
]];
FOR i: NAT IN [0..GGTraj.HiSegmentTraj[traj]] DO
seq.segments[i] _ TRUE;
seq.joints[i] _ TRUE;
ENDLOOP;
seq.joints[jointCount-1] _ TRUE; -- will be redundant for open trajectories
FillInControlPoints[seq]; -- after all is said and done
};

CreateFromJoint: PUBLIC PROC [traj: TrajData, jointNum: NAT] RETURNS [seq: TrajParts] = {
seq _ CreateEmpty[traj];
seq.joints[jointNum] _ TRUE;
seq.jointCount _ 1;
};

CreateFromSegment: PUBLIC PROC [traj: TrajData, segNum: NAT] RETURNS [seq: TrajParts] = {
seq _ CreateEmpty[traj];
seq.segments[segNum] _ TRUE;
seq.segCount _ 1;
FillInJoints[seq];
FillInControlPoints[seq]; -- after all is said and done
};

CreateSimpleFromSegment: PUBLIC PROC [traj: TrajData, segNum: NAT] RETURNS [seq: TrajParts] = {
seq _ CreateEmpty[traj];
seq.segments[segNum] _ TRUE;
seq.segCount _ 1;
};

CreateFromControlPoint: PUBLIC PROC [traj: TrajData, segNum: NAT, controlPointNum: NAT] RETURNS [seq: TrajParts] = {
seq _ CreateEmpty[traj];
seq.controlPoints[segNum][controlPointNum] _ TRUE;
seq.controlPointCount _ 1;
};

Copy: PUBLIC PROC [seq: TrajParts] RETURNS [copy: TrajParts] = {
IF seq=NIL THEN RETURN[NIL];
copy _ NEW[TrajPartsObj _ [
segments: NewBitVector[seq.segments.len],
joints: NewBitVector[seq.joints.len],
controlPoints: NewBitMatrixFromSeq[seq],
segCount: seq.segCount,
controlPointCount: seq.controlPointCount,
jointCount: seq.jointCount
]];
FOR i: NAT IN [0..seq.segments.len) DO copy.segments[i] _ seq.segments[i]; ENDLOOP;
FOR i: NAT IN [0..seq.joints.len) DO copy.joints[i] _ seq.joints[i]; ENDLOOP;
FOR i: NAT IN [0..seq.controlPoints.len) DO
cpCount: NAT _ seq.controlPoints[i].len;
FOR j: NAT IN [0..cpCount) DO
copy.controlPoints[i][j] _ seq.controlPoints[i][j];
ENDLOOP;
ENDLOOP;
};

CreateEmptySeq: PRIVATE PROC [seq: TrajParts] RETURNS [copy: TrajParts] = {
IF seq=NIL THEN RETURN[NIL];
copy _ NEW[TrajPartsObj _ [
segments: NewBitVector[seq.segments.len],
joints: NewBitVector[seq.joints.len],
controlPoints: NewBitMatrixFromSeq[seq],
segCount: 0,
controlPointCount: 0,
jointCount: 0
]];
};



CopyInto: PUBLIC PROC [to: TrajParts, from: TrajParts] = {
FOR i: NAT IN [0..from.segments.len) DO
cpCount: NAT _ from.controlPoints[i].len;
to.segments[i] _ from.segments[i];
FOR j: NAT IN [0..cpCount) DO
to.controlPoints[i][j] _ from.controlPoints[i][j]; -- KAP. April 4, 1986
ENDLOOP;
ENDLOOP;
FOR i: NAT IN [0..from.joints.len) DO
to.joints[i] _ from.joints[i];
ENDLOOP;
to.segCount _ from.segCount;
to.controlPointCount _ from.controlPointCount;
to.jointCount _ from.jointCount;
};

FillInJoints: PUBLIC PROC [seq: TrajParts] = {
jointCount: NAT _ 0;
IF seq.segCount=0 THEN RETURN; -- can't do anything. seq may have a single joint or CP
IF seq.joints.len=seq.segments.len THEN { -- closed trajectory
FOR i: NAT IN [0..seq.segments.len) DO
IF seq.segments[i] THEN {seq.joints[i] _ TRUE; seq.joints[(i+1) MOD seq.segments.len] _ TRUE;};
ENDLOOP;
}
ELSE IF seq.joints.len=seq.segments.len+1 THEN { -- open trajectory
FOR i: NAT IN [0..seq.segments.len) DO
IF seq.segments[i] THEN {seq.joints[i] _ TRUE; seq.joints[i+1] _ TRUE};
ENDLOOP;
}
ELSE ERROR; -- KAP. November 20, 1987 4:42:37 pm PST
FOR i: NAT IN [0..seq.joints.len) DO
IF seq.joints[i] THEN jointCount _ jointCount + 1;
ENDLOOP;
seq.jointCount _ jointCount;
};

FillInControlPoints: PUBLIC PROC [seq: TrajParts] = { -- a sequence with segs and joints filled in. IF there are segments then fill in all the control points for each segment in the sequence, and calculate the new control point count.
cpCount: NAT;
IF seq.segCount=0 THEN RETURN; -- can't do anything. seq may have a single joint or CP.
seq.controlPointCount _ 0;
FOR i: NAT IN [0..seq.segments.len) DO
cpCount _ seq.controlPoints[i].len;
IF seq.segments[i] THEN {
FOR j: NAT IN [0..cpCount) DO -- fill them all in
seq.controlPoints[i][j] _ TRUE;
seq.controlPointCount _ seq.controlPointCount + 1;
ENDLOOP;
}
ELSE {
FOR j: NAT IN [0..cpCount) DO -- count the ones already there
IF seq.controlPoints[i][j] THEN seq.controlPointCount _ seq.controlPointCount + 1;
ENDLOOP;
};
ENDLOOP;
};

TrimSelectedParts: PUBLIC PROC [trimDescriptor: SliceDescriptor, selectedList: LIST OF SliceDescriptor] = {
seq: TrajParts _ NARROW[trimDescriptor.parts];
selSeq: TrajParts _ FindPartsInList[trimDescriptor.slice, selectedList];
IF selSeq = NIL THEN RETURN; -- no selected parts, so nothing to trim
FOR i: NAT IN [0..seq.segments.len) DO
FOR j: NAT IN [0..seq.controlPoints[i].len) DO
IF selSeq.controlPoints[i][j] AND seq.controlPoints[i][j] THEN {
seq.controlPoints[i][j] _ FALSE;
seq.controlPointCount _ seq.controlPointCount - 1;
};
ENDLOOP;
IF selSeq.segments[i] AND seq.segments[i] THEN {
seq.segments[i] _ FALSE;
seq.segCount _ seq.segCount - 1;
};
ENDLOOP;
FOR i: NAT IN [0..seq.joints.len) DO
IF selSeq.joints[i] AND seq.joints[i] THEN {
seq.joints[i] _ FALSE;
seq.jointCount _ seq.jointCount -1;
};
ENDLOOP;
};

TrimSelectedJointSegments: PUBLIC PROC [trimDescriptor: SliceDescriptor, selectedList: LIST OF SliceDescriptor] = {
SomeSelectedJoint: PROC [i: NAT] RETURNS [BOOL] = {
RETURN[
selSeq.joints[i] OR selSeq.joints[GGTraj.FollowingJoint[trimDescriptor.slice, i]]
];
};
seq: TrajParts _ NARROW[trimDescriptor.parts];
selSeq: TrajParts _ FindPartsInList[trimDescriptor.slice, selectedList];
IF selSeq = NIL THEN RETURN; -- no joints selected, so nothing to trim
FOR i: NAT IN [0..seq.segments.len) DO
IF seq.segments[i] AND SomeSelectedJoint[i] THEN {
seq.segments[i] _ FALSE;
seq.segCount _ seq.segCount - 1;
};
ENDLOOP;
};

TrimSelectedControlPointSegments: PUBLIC PROC [trimDescriptor: SliceDescriptor, selectedList: LIST OF SliceDescriptor] = {
SomeSelectedCP: PROC [i: NAT] RETURNS [BOOL] = {
FOR j: NAT IN [0..selSeq.controlPoints[i].len) DO
IF selSeq.controlPoints[i][j] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};
seq: TrajParts _ NARROW[trimDescriptor.parts];
selSeq: TrajParts _ FindPartsInList[trimDescriptor.slice, selectedList];
IF selSeq = NIL THEN RETURN; -- no CPs selected, so nothing to trim
FOR i: NAT IN [0..seq.segments.len) DO
IF seq.segments[i] AND SomeSelectedCP[i] THEN {
seq.segments[i] _ FALSE;
seq.segCount _ seq.segCount - 1;
};
ENDLOOP;
};

AddNonSelectedJointSegments: PROC [descriptor: SliceDescriptor, selected: TrajParts] = {
SomeSelectedJoint: PROC [i: NAT] RETURNS [BOOL] = {
RETURN[
selected.joints[i] OR selected.joints[GGTraj.FollowingJoint[descriptor.slice, i]]
];
};
seq: TrajParts _ NARROW[descriptor.parts];
IF selected = NIL THEN RETURN; -- no joints selected, so nothing to add
FOR i: NAT IN [0..seq.segments.len) DO
IF NOT seq.segments[i] AND NOT selected.segments[i] AND SomeSelectedJoint[i] THEN {
seq.segments[i] _ TRUE;
seq.segCount _ seq.segCount + 1;
};
ENDLOOP;
};

AddNonSelectedControlPointSegments: PROC [descriptor: SliceDescriptor, selected: TrajParts] = {
SomeSelectedCP: PROC [i: NAT] RETURNS [BOOL] = {
FOR j: NAT IN [0..selected.controlPoints[i].len) DO
IF selected.controlPoints[i][j] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};
seq: TrajParts _ NARROW[descriptor.parts];
IF selected = NIL THEN RETURN; -- no CPs selected, so nothing to add
FOR i: NAT IN [0..seq.segments.len) DO
IF NOT seq.segments[i] AND NOT selected.segments[i] AND SomeSelectedCP[i] THEN {
seq.segments[i] _ TRUE;
seq.segCount _ seq.segCount + 1;
};
ENDLOOP;
};

AddConstrained: PROC [descriptor: SliceDescriptor, selected: TrajParts] = {
SomeSelectedConstrainer: PROC [i: NAT] RETURNS [BOOL] = {
previous, following: INT;
previous _ GGTraj.PreviousSegmentNum[descriptor.slice, i];
following _ GGTraj.FollowingSegmentNum[descriptor.slice, i];
IF previous # -1 AND GGTraj.FetchSegment[descriptor.slice, previous].class.type = $Bezier AND selected.controlPoints[previous][1] THEN RETURN[TRUE];
IF following # -1 AND GGTraj.FetchSegment[descriptor.slice, following].class.type = $Bezier AND selected.controlPoints[following][0] THEN RETURN[TRUE];
RETURN[FALSE];
};
seq: TrajParts _ NARROW[descriptor.parts];
IF selected = NIL THEN RETURN; --  nothing to add
FOR i: NAT IN [0..seq.segments.len) DO
IF GGTraj.FetchSegment[descriptor.slice, i].class.type = $Bezier AND NOT seq.segments[i] AND NOT selected.segments[i] AND SomeSelectedConstrainer[i] THEN {
seq.segments[i] _ TRUE;
seq.segCount _ seq.segCount + 1;
};
ENDLOOP;
};

AddNewBezier: PROC [seq: TrajParts, selected: TrajParts, segNum: NAT] = {
IF selected = NIL THEN RETURN; --  nothing to add
IF NOT seq.segments[segNum] AND NOT selected.segments[segNum] THEN {
seq.segments[segNum] _ TRUE;
seq.segCount _ seq.segCount + 1;
};
};

DDifference: PUBLIC PROC [mutable, negative: SliceDescriptor] = {
IF mutable.slice.data # negative.slice.data THEN ERROR; -- different trajectories
DDifferenceSeq[NARROW[mutable.parts, TrajParts], NARROW[negative.parts, TrajParts]] ;
};

DDifferenceSeq: PRIVATE PROC [mutSeq, negSeq: TrajParts] = {
hiJoint: NAT;
FOR i: NAT IN [0..mutSeq.segments.len) DO
cpCount: NAT _ mutSeq.controlPoints[i].len;
mutSeq.segments[i] _ mutSeq.segments[i] AND NOT negSeq.segments[i];
FOR j: NAT IN [0..cpCount) DO
mutSeq.controlPoints[i][j] _ mutSeq.controlPoints[i][j] AND NOT negSeq.controlPoints[i][j];
ENDLOOP;
mutSeq.joints[i] _ mutSeq.joints[i] AND NOT negSeq.joints[i];
ENDLOOP;
hiJoint _ mutSeq.joints.len-1;
mutSeq.joints[hiJoint] _ mutSeq.joints[hiJoint] AND NOT negSeq.joints[hiJoint];
mutSeq.segCount _ CountSegments[mutSeq];
mutSeq.jointCount _ CountJoints[mutSeq];
mutSeq.controlPointCount _ CountControlPoints[mutSeq];
};

FindPartsInList: PUBLIC PROC [traj: Traj, selectedList: LIST OF SliceDescriptor] RETURNS [trajParts: TrajParts] = {
trajD: SliceDescriptor;
FOR sliceDList: LIST OF SliceDescriptor _ selectedList, sliceDList.rest UNTIL sliceDList = NIL DO
sliceD: SliceDescriptor _ sliceDList.first;
trajD _ IF GGSliceOps.GetType[sliceD.slice]=$Traj THEN sliceD ELSE IF GGSliceOps.GetType[sliceD.slice]=$Outline THEN GGParent.ChildDescriptorFromDescriptor[sliceD, traj] 
ELSE NIL;
IF trajD#NIL THEN RETURN[NARROW[trajD.parts]];
ENDLOOP;
RETURN[NIL];
};

NewBitMatrixFromSeq: PROC [seq: TrajParts] RETURNS [bitMatrix: BitMatrix] = {
bitMatrix _ NEW[BitMatrixObj[seq.controlPoints.len]];
FOR j: NAT IN [0..seq.controlPoints.len) DO -- for each possible segment
bitMatrix[j] _ NewBitVector[seq.controlPoints[j].len];  -- for all possible CPs in segment
ENDLOOP;
};

NewBitMatrix: PROC [traj: TrajData] RETURNS [bitMatrix: BitMatrix] = {
j: NAT _ 0;
segGen: SegmentGenerator _ GGSequence.SegmentsInTraj[traj];
bitMatrix _ NEW[BitMatrixObj[traj.segCount]];
FOR seg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
bitMatrix[j] _ NewBitVector[seg.class.controlPointCount[seg]];
j _ j+1;
ENDLOOP;
};

NewBitVector: PROC [length: NAT] RETURNS [bitVec: BitVector] = {
bitVec _ NEW[BitVectorObj[length]];
SetAllBits[bitVec, FALSE];
};
SetAllBits: PROC [bitVec: BitVector, bool: BOOL] = {
FOR i: NAT IN [0..bitVec.len) DO
bitVec[i] _ bool;
ENDLOOP;
};

SomeSegCPInSeq: PROC [segNum: NAT, seq: TrajParts] RETURNS [BOOL] = {
cpCount: NAT _ seq.controlPoints[segNum].len;
FOR j: NAT IN [0..cpCount) DO
IF seq.controlPoints[segNum][j] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};

Union: PUBLIC PROC [a, b: SliceDescriptor] RETURNS [union: SliceDescriptor] = {
hiJoint: NAT;
uSeq: TrajParts;
aSeq: TrajParts _ NARROW[a.parts];
aTraj: TrajData _ NARROW[a.slice.data];
bSeq: TrajParts _ NARROW[b.parts];
bTraj: TrajData _ NARROW[b.slice.data];
IF aTraj # bTraj THEN ERROR;
IF aSeq = NIL THEN RETURN[b]; -- copy needed ??
IF bSeq = NIL THEN RETURN[a]; -- copy needed ??
IF IsEmpty[aSeq] THEN RETURN[b]; -- copy needed ??
IF IsEmpty[bSeq] THEN RETURN[a]; -- copy needed ??
IF IsComplete[aSeq] THEN RETURN[a]; -- copy needed ??
IF IsComplete[bSeq] THEN RETURN[b]; -- copy needed ??
uSeq _ CreateEmpty[aTraj];
FOR i: NAT IN [0..uSeq.segments.len) DO
cpCount: NAT _ aSeq.controlPoints[i].len;
uSeq.segments[i] _ aSeq.segments[i] OR bSeq.segments[i];
FOR j: NAT IN [0..cpCount) DO
uSeq.controlPoints[i][j] _ aSeq.controlPoints[i][j] OR bSeq.controlPoints[i][j];
ENDLOOP;
uSeq.joints[i] _ aSeq.joints[i] OR bSeq.joints[i];
ENDLOOP;
hiJoint _ uSeq.joints.len-1;
uSeq.joints[hiJoint] _ aSeq.joints[hiJoint] OR bSeq.joints[hiJoint];
uSeq.segCount _ CountSegments[uSeq];
uSeq.jointCount _ CountJoints[uSeq];
uSeq.controlPointCount _ CountControlPoints[uSeq];
union _ GGSlice.DescriptorFromParts[a.slice, uSeq];
};

Difference: PUBLIC PROC [a, b: SliceDescriptor] RETURNS [aMinusB: SliceDescriptor] = {
hiJoint: NAT;
dSeq: TrajParts;
aSeq: TrajParts _ NARROW[a.parts];
aTraj: TrajData _ NARROW[a.slice.data];
bSeq: TrajParts _ NARROW[b.parts];
bTraj: TrajData _ NARROW[b.slice.data];
dSeq _ CreateEmpty[aTraj];
FOR i: NAT IN [0..aSeq.segments.len) DO
cpCount: NAT _ aSeq.controlPoints[i].len;
dSeq.segments[i] _ aSeq.segments[i] AND NOT bSeq.segments[i];
FOR j: NAT IN [0..cpCount) DO
dSeq.controlPoints[i][j] _ aSeq.controlPoints[i][j] AND NOT bSeq.controlPoints[i][j];
ENDLOOP;
dSeq.joints[i] _ aSeq.joints[i] AND NOT bSeq.joints[i];
ENDLOOP;
hiJoint _ dSeq.joints.len-1;
dSeq.joints[hiJoint] _ aSeq.joints[hiJoint] AND NOT bSeq.joints[hiJoint];
dSeq.segCount _ CountSegments[dSeq];
dSeq.jointCount _ CountJoints[dSeq];
dSeq.controlPointCount _ CountControlPoints[dSeq];
aMinusB _ GGSlice.DescriptorFromParts[a.slice, dSeq];
};

Intersection: PUBLIC PROC [a, b: SliceDescriptor] RETURNS [intersection: SliceDescriptor] = {
hiJoint: NAT;
iSeq: TrajParts;
aSeq: TrajParts _ NARROW[a.parts];
aTraj: TrajData _ NARROW[a.slice.data];
bSeq: TrajParts _ NARROW[b.parts];
bTraj: TrajData _ NARROW[b.slice.data];
IF aTraj # bTraj THEN ERROR;
iSeq _ CreateEmpty[aTraj];
IF aSeq = NIL OR IsEmpty[aSeq] THEN RETURN[GGSlice.DescriptorFromParts[a.slice, iSeq]];
IF bSeq = NIL OR IsEmpty[bSeq] THEN RETURN[GGSlice.DescriptorFromParts[a.slice, iSeq]];
IF IsComplete[aSeq] AND IsComplete[bSeq] THEN RETURN[a]; -- copy needed ??
FOR i: NAT IN [0..aSeq.segments.len) DO
cpCount: NAT _ aSeq.controlPoints[i].len;
iSeq.segments[i] _ aSeq.segments[i] AND bSeq.segments[i];
FOR j: NAT IN [0..cpCount) DO
iSeq.controlPoints[i][j]_ aSeq.controlPoints[i][j] AND bSeq.controlPoints[i][j];
ENDLOOP;
iSeq.joints[i] _ aSeq.joints[i] AND bSeq.joints[i];
ENDLOOP;
hiJoint _ iSeq.joints.len-1;
iSeq.joints[hiJoint] _ aSeq.joints[hiJoint] AND bSeq.joints[hiJoint];
iSeq.segCount _ CountSegments[iSeq];
iSeq.jointCount _ CountJoints[iSeq];
iSeq.controlPointCount _ CountControlPoints[iSeq];
intersection _ GGSlice.DescriptorFromParts[a.slice, iSeq];
};

TrajMovingParts: PUBLIC PROC [slice: Slice, parts: SliceParts, editConstraints: EditConstraints, bezierDrag: BezierDragRecord] RETURNS [background, overlay, rubber, drag: TrajParts] = {
seq: TrajParts _ NARROW[parts];
traj: TrajData _ NARROW[slice.data];
background _ NIL;
drag _ Copy[seq];
rubber _ FindRubberFromSelected[slice, parts, editConstraints, bezierDrag];
overlay _ CreateComplete[traj];
DDifferenceSeq[overlay, drag];
DDifferenceSeq[overlay, rubber];
};

FindRubberFromSelected: PROC [slice: Slice, parts: SliceParts, editConstraints: EditConstraints, bezierDrag: BezierDragRecord] RETURNS [rubber: TrajParts] = {
rubberBabbyBuggyBumper: SliceDescriptor;
trajParts: TrajParts _ NARROW[parts];
trajData: TrajData _ NARROW[slice.data];
rubber _ CreateEmpty[trajData];
rubberBabbyBuggyBumper _ GGSlice.DescriptorFromParts[slice, rubber];
AddNonSelectedControlPointSegments[rubberBabbyBuggyBumper, trajParts];
AddNonSelectedJointSegments[rubberBabbyBuggyBumper, trajParts];
IF editConstraints # none THEN AddConstrained[rubberBabbyBuggyBumper, trajParts];
IF bezierDrag.draggingBezier AND trajData = bezierDrag.traj.data THEN AddNewBezier[rubber, trajParts, bezierDrag.bezierNum]; -- For now until more general.
};

Augment: PUBLIC PROC [descriptor: SliceDescriptor, trajEnd: TrajEnd, extend: BOOL] RETURNS [bigger: TrajParts] = {
seq: TrajParts _ NARROW[descriptor.parts];
traj: TrajData _ NARROW[descriptor.slice.data];
IF traj.role = hole OR traj.role = fence THEN {
bigger _ AugmentClosed[descriptor, extend];
RETURN;
};
bigger _ CreateEmpty[traj];
bigger.segCount _ seq.segCount;
bigger.controlPointCount _ seq.controlPointCount;
bigger.jointCount _ seq.jointCount;
IF trajEnd = hi THEN {
FOR i: NAT IN [0..seq.segments.len) DO
cpCount: NAT _ seq.controlPoints[i].len;
bigger.segments[i] _ seq.segments[i];
bigger.joints[i] _ seq.joints[i];
FOR j: NAT IN [0..cpCount) DO
bigger.controlPoints[i][j] _ seq.controlPoints[i][j];
ENDLOOP;
ENDLOOP;
IF seq.joints[seq.joints.len - 1] THEN { -- final joint included ??
bigger.joints[seq.joints.len - 1] _ TRUE; -- yes, so include it in bigger
IF extend THEN {
bigger.segments[seq.segments.len] _ TRUE;
bigger.joints[seq.joints.len] _ TRUE;
SetAllBits[bigger.controlPoints[seq.segments.len], TRUE];
bigger.segCount _ bigger.segCount + 1;
bigger.jointCount _ bigger.jointCount + 1;
bigger.controlPointCount _ bigger.controlPointCount + bigger.controlPoints[seq.segments.len].len
};
};
}
ELSE {
FOR i: NAT IN [0..seq.segments.len) DO
cpCount: NAT _ seq.controlPoints[i].len;
bigger.segments[i+1] _ seq.segments[i];
bigger.joints[i+2] _ seq.joints[i+1];
FOR j: NAT IN [0..cpCount) DO
bigger.controlPoints[i+1][j] _ seq.controlPoints[i][j];
ENDLOOP;
ENDLOOP;
IF seq.joints[0] THEN { -- first joint included ??
bigger.joints[1] _ TRUE; -- yes, so include it in bigger
IF extend THEN {
bigger.segments[0] _ TRUE;
bigger.joints[0] _ TRUE;
SetAllBits[bigger.controlPoints[0], TRUE];
bigger.segCount _ bigger.segCount + 1;
bigger.jointCount _ bigger.jointCount + 1;
bigger.controlPointCount _ bigger.controlPointCount + bigger.controlPoints[0].len
};
};
};
};

AugmentClosed: PROC [descriptor: SliceDescriptor, extend: BOOL] RETURNS [bigger: TrajParts] = {
seq: TrajParts _ NARROW[descriptor.parts];
traj: TrajData _ NARROW[descriptor.slice.data];
bigger _ NEW[TrajPartsObj _ [
segments: NewBitVector[seq.segments.len+1],
joints: NewBitVector[seq.joints.len],
controlPoints: NewBitMatrix[traj], -- new BitMatrix one segment bigger
segCount: seq.segCount,
controlPointCount: seq.controlPointCount,
jointCount: seq.jointCount
]];
FOR i: NAT IN [0..seq.segments.len) DO
cpCount: NAT _ seq.controlPoints[i].len;
bigger.segments[i] _ seq.segments[i];
bigger.joints[i] _ seq.joints[i];
FOR j: NAT IN [0..cpCount) DO
bigger.controlPoints[i][j] _ seq.controlPoints[i][j]; -- KAP. April 4, 1986
ENDLOOP;
ENDLOOP;
IF seq.joints[seq.joints.len - 1] THEN { -- final joint included ??
bigger.joints[seq.joints.len - 1] _ TRUE; -- yes, so include it in bigger
IF extend THEN {
bigger.segments[seq.segments.len] _ TRUE;
SetAllBits[bigger.controlPoints[seq.segments.len], TRUE];
bigger.segCount _ bigger.segCount + 1;
bigger.controlPointCount _ bigger.controlPointCount + bigger.controlPoints[seq.segments.len].len;
};
};
};


IsObsolete: PUBLIC PROC [seq: TrajParts] RETURNS [BOOL] = {
ERROR;

};

IsEmpty: PUBLIC PROC [seq: TrajParts] RETURNS [BOOL] = {
RETURN[seq=NIL OR (seq.jointCount = 0 AND seq.segCount = 0 AND seq.controlPointCount = 0)];
};

IsComplete: PUBLIC PROC [seq: TrajParts] RETURNS [BOOL] = {
RETURN[seq#NIL AND seq.segCount = seq.segments.len AND
(seq.jointCount = seq.joints.len)];
};

IsConstrained: PUBLIC PROC [descriptor: SliceDescriptor, segNum, cPNum: NAT, editConstraints: EditConstraints] RETURNS [BOOL] = {
seq: TrajParts _ NARROW[descriptor.parts];
previous, following: INT;
IF GGTraj.FetchSegment[descriptor.slice, segNum].class.type = $Bezier AND editConstraints # none THEN {
IF cPNum = 0 THEN {
previous _ GGTraj.PreviousSegmentNum[descriptor.slice, segNum];
IF previous # -1 AND GGTraj.FetchSegment[descriptor.slice, previous].class.type = $Bezier AND seq.controlPoints[previous][1] THEN RETURN[TRUE]
}
ELSE {
following _ GGTraj.FollowingSegmentNum[descriptor.slice, segNum];
IF following # -1 AND GGTraj.FetchSegment[descriptor.slice, following].class.type = $Bezier AND seq.controlPoints[following][0] THEN RETURN[TRUE];
};
};
RETURN[FALSE];
};

Overlap: PUBLIC PROC [descriptor1, descriptor2: SliceDescriptor] RETURNS [BOOL] = {
hiSegment, hiJoint: NAT;
seq1: TrajParts _ NARROW[descriptor1.parts];
traj1: TrajData _ NARROW[descriptor1.slice.data];
seq2: TrajParts _ NARROW[descriptor2.parts];
traj2: TrajData _ NARROW[descriptor2.slice.data];
IF traj1 # traj2 THEN ERROR;
hiSegment _ seq1.segments.len;
FOR i: NAT IN [0..hiSegment) DO
IF seq1.segments[i] AND seq2.segments[i] THEN RETURN[TRUE];
ENDLOOP;
hiJoint _ seq1.joints.len;
FOR i: NAT IN [0..hiJoint) DO
IF seq1.joints[i] AND seq2.joints[i] THEN RETURN[TRUE];
ENDLOOP;
FOR i: NAT IN [0..hiSegment) DO
cpCount: NAT _ seq1.controlPoints[i].len;
FOR j: NAT IN [0..cpCount) DO
IF seq1.controlPoints[i][j] AND seq2.controlPoints[i][j] THEN RETURN[TRUE];
ENDLOOP;
ENDLOOP;
RETURN[FALSE];
};

CountSegments: PROC [seq: TrajParts] RETURNS [segCount: NAT _ 0] = {
hiSegment: NAT _ seq.segments.len;
FOR i: NAT IN [0..hiSegment) DO
IF seq.segments[i] THEN segCount _ segCount + 1;
ENDLOOP;
};

CountJoints: PROC [seq: TrajParts] RETURNS [jointCount: NAT _ 0] = {
hiJoint: NAT _ seq.joints.len;
FOR i: NAT IN [0..hiJoint) DO
IF seq.joints[i] THEN jointCount _ jointCount + 1;
ENDLOOP;
};

CountControlPoints: PROC [seq: TrajParts] RETURNS [count: NAT _ 0] = {
hiSegment: NAT _ seq.segments.len;
FOR i: NAT IN [0..hiSegment) DO
cpCount: NAT _ seq.controlPoints[i].len;
FOR j: NAT IN [0..cpCount) DO
IF seq.controlPoints[i][j] THEN count _ count + 1;
ENDLOOP;
ENDLOOP;
};

ContainsSegment: PUBLIC PROC [seq: TrajParts, segNum: NAT] RETURNS [BOOL] = {
RETURN[seq.segments[segNum]];
};

ContainsSomeSegment: PUBLIC PROC [seq: TrajParts] RETURNS [BOOL] = {
RETURN[seq.segCount > 0];
};

ContainsSegmentParts: PUBLIC PROC [seq: TrajParts, segNum: NAT] RETURNS [BOOL] = {
RETURN [seq#NIL AND (seq.segments[segNum] OR
NOT GGUtility.AllFalse[seq.controlPoints[segNum]] OR
seq.joints[segNum] OR
seq.joints[IF --seq.traj.role=open-- seq.segments.len#seq.joints.len THEN segNum+1 ELSE (segNum+1) MOD --seq.traj.segCount-- seq.segments.len]) ];
};

FirstSegment: PROC [seq: TrajParts] RETURNS [index: NAT] ~ {
hiSegment: NAT _ seq.segments.len;
IF --seq.traj.role = open-- seq.segments.len#seq.joints.len THEN {
FOR i: NAT IN [0..hiSegment) DO
IF seq.segments[i] THEN GOTO Found;
REPEAT
Found => index _ i;
FINISHED => SIGNAL Problem[msg: "the first run begins with a segment."];
ENDLOOP;
}
ELSE {
FOR i: NAT IN [0..hiSegment) DO
IF NOT seq.segments[(i - 1 + hiSegment) MOD hiSegment] AND seq.joints[i] THEN GOTO Found;
IF NOT seq.joints[i] AND seq.segments[i] THEN GOTO Found;
REPEAT
Found => index _ i;
FINISHED => SIGNAL Problem[msg: "there is no break in the sequence."];
ENDLOOP;
};
};

FirstSegNum: PUBLIC PROC [run: TrajParts] RETURNS [INT] = {
IF run.segCount = 0 THEN RETURN[-1];
IF GGSequence.IsComplete[run] THEN RETURN[0];  --DJK, to make work with complete, closed sequences
RETURN[FirstTransitionInRun[run]];
};

LastSegNum: PUBLIC PROC [run: TrajParts, firstSegNum: INT] RETURNS [lastNum: INT] = {
IF firstSegNum = -1 THEN RETURN[-1];
IF run.segments.len#run.joints.len THEN lastNum _ firstSegNum + run.segCount  - 1
ELSE lastNum _ (firstSegNum + run.segCount - 1 + run.segments.len) MOD run.segments.len;
};

ContainsJoint: PUBLIC PROC [seq: TrajParts, jointNum: NAT] RETURNS [BOOL] = {
RETURN[seq.joints[jointNum]];
};

FirstJointNum: PUBLIC PROC [run: TrajParts] RETURNS [INT] = {
firstSeg, nextJoint: NAT;
IF run.jointCount = 0 THEN RETURN[-1];
firstSeg _ FirstTransitionInRun[run];
IF run.joints[firstSeg] THEN RETURN[firstSeg] ELSE {
IF --run.traj.role = open--  run.segments.len#run.joints.len THEN {
IF run.joints[firstSeg + 1] THEN RETURN[firstSeg + 1]
ELSE ERROR Problem[msg: "Broken invariant."];
}
ELSE {
nextJoint _ FollowingJoint[run, firstSeg];
IF run.joints[nextJoint] THEN RETURN[nextJoint]
ELSE ERROR Problem[msg: "Broken invariant."];
};
};
};

LastJointNum: PUBLIC PROC [run: TrajParts, firstJointNum: INT] RETURNS [lastNum: INT] = {
IF firstJointNum = -1 THEN RETURN[-1];
IF --run.traj.role = open-- run.segments.len#run.joints.len THEN lastNum _ firstJointNum + run.jointCount - 1
ELSE lastNum _ (firstJointNum + run.jointCount - 1 + run.segments.len) MOD run.segments.len;
};

LastSegAndJoint: PUBLIC PROC [traj: TrajData, trajEnd: TrajEnd] RETURNS [segAndJoint: TrajParts] = {
segAndJoint _ CreateEmpty[traj];
IF traj.role = open THEN {
segAndJoint.jointCount _ 1;
segAndJoint.segCount _ 1;
IF trajEnd = lo THEN {
segAndJoint.segments[0] _ TRUE;
segAndJoint.joints[0] _ TRUE;
}
ELSE {
hiSegment: NAT _ --GGTraj.HiSegment[traj]-- segAndJoint.segments.len-1;
segAndJoint.segments[hiSegment] _ TRUE;
segAndJoint.joints[hiSegment+1] _ TRUE;
};
}
ELSE ERROR;
};

FollowingJoint: PRIVATE PROC [seq: TrajParts, index: NAT] RETURNS [nextIndex: INT] =  {
open: BOOL _ seq.segments.len#seq.joints.len;
segCount: NAT _ seq.segments.len;
IF open THEN nextIndex _ IF index = segCount THEN -1 ELSE index + 1
ELSE nextIndex _ (index + 1) MOD segCount;
};

UnpackOnePointSequence: PUBLIC PROC [seq: TrajParts] RETURNS [isACP: BOOL, segNum, cpNum, jointNum: NAT] = {
hiSegment: NAT _ seq.segments.len;
hiJoint: NAT _ seq.joints.len;
FOR i: NAT IN [0..hiJoint) DO
IF seq.joints[i] THEN {
isACP _ FALSE;
segNum _ 999;
cpNum _ 999;
jointNum _ i;
RETURN;
}
ENDLOOP;
FOR i: NAT IN [0..hiSegment) DO
FOR j: NAT IN [0..seq.controlPoints[i].len) DO
IF seq.controlPoints[i][j] THEN {
isACP _ TRUE;
segNum _ i;
cpNum _ j;
jointNum _ 999;
RETURN;
}
ENDLOOP;
ENDLOOP;
ERROR;
};

UnpackOneSegmentSequence: PUBLIC PROC [seq: TrajParts] RETURNS [segNum: NAT] = {
hiSegment: NAT _ seq.segments.len;
FOR i: NAT IN [0..hiSegment) DO
IF seq.segments[i] THEN {
segNum _ i;
RETURN;
}
ENDLOOP;
ERROR;
};

UnpackSimpleSequence: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [success: BOOL _ FALSE, partType: TrajPartType _ none, traj: TrajData, joint: Joint _ NIL, jointNum: NAT _ 999, cp: Point _ [0,0], cpNum: NAT _ 999, seg: Segment _ NIL, segNum: NAT _ 999] = {
jointFound, cpFound, segFound: BOOL _ FALSE;
seq: TrajParts _ NARROW[parts];
seqTraj: TrajData _ NARROW[slice.data];
hiSegment: NAT _ seq.segments.len;
hiJoint: NAT _ seq.joints.len;
traj _ seqTraj;
FOR i: NAT IN [0..hiJoint) DO
IF seq.joints[i] THEN {
IF jointFound THEN {success _ FALSE; RETURN};
jointNum _ i;
joint _ GGTraj.FetchJoint[slice, i];
jointFound _ TRUE;
partType _ joint;
}
ENDLOOP;
FOR i: NAT IN [0..hiSegment) DO
thisSeg: Segment _ GGTraj.FetchSegment[slice, i];
cpCount: NAT _ seq.controlPoints[i].len;
FOR j: NAT IN [0..cpCount) DO
IF seq.controlPoints[i][j] THEN {
IF cpFound THEN {success _ FALSE; RETURN};
segNum _ i;
seg _ thisSeg;
cpNum _ j;
cp _ thisSeg.class.controlPointGet[thisSeg, cpNum];
cpFound _ TRUE;
partType _ controlPoint;
}
ENDLOOP;
ENDLOOP;
IF jointFound AND cpFound THEN {success _ FALSE; RETURN};
FOR i: NAT IN [0..hiSegment) DO
IF seq.segments[i] THEN {
IF segFound THEN {success _ FALSE; RETURN};
segNum _ i;
seg _ GGTraj.FetchSegment[slice, i];
segFound _ TRUE;
partType _ segment;
}
ENDLOOP;
IF (jointFound AND segFound) OR (cpFound AND segFound) THEN {success _ FALSE; RETURN};
IF NOT jointFound AND NOT cpFound AND NOT segFound THEN ERROR;
success _ TRUE;
};
RunsInSequence: PUBLIC PROC [seq: TrajParts] RETURNS [seqGen: SequenceGenerator, runCount: NAT] = {
IF --seq.traj.role = open--  seq.segments.len#seq.joints.len
THEN [seqGen, runCount] _ RunsInSequenceOpen[seq]
ELSE [seqGen, runCount] _ RunsInSequenceClosed[seq];
};

RunsInSequenceOpen: PROC [seq: TrajParts] RETURNS [seqGen: SequenceGenerator, runCount: NAT] = {
in: BOOL _ FALSE;
thisSeq: TrajParts;
hiSegment: NAT _ seq.segments.len-1; -- GGTraj.HiSegment[seq.traj]
hiJoint: NAT _ hiSegment + 1;
seqGen _ NEW[SequenceGeneratorObj _ [NIL]];
runCount _ 0;
IF IsEmpty[seq] THEN RETURN;
FOR i: NAT IN [0..hiSegment] DO
[in, seqGen.list, thisSeq, runCount] _ ConsiderJoint[in, seqGen.list, seq, thisSeq, runCount, i];
[in, seqGen.list, thisSeq, runCount] _ ConsiderSegment[in, seqGen.list, seq, thisSeq, runCount, i];
ENDLOOP;
[in, seqGen.list, thisSeq, runCount] _ ConsiderJoint[in, seqGen.list, seq, thisSeq, runCount, hiJoint];
IF in THEN seqGen.list _ AppendToList[seqGen.list, CONS[thisSeq, NIL]];
};

RunsInSequenceClosed: PROC [seq: TrajParts] RETURNS [seqGen: SequenceGenerator, runCount: NAT] = {
segCount: NAT _ seq.segments.len;
in: BOOL _ FALSE;
thisSeq: TrajParts;
start: NAT;
natGen: NATGenerator;
seqGen _ NEW[SequenceGeneratorObj _ [NIL]];
runCount _ 0;
IF ControlPointsOnly[seq] THEN RETURN;
start _ FirstTransitionInRun[seq];
in _ FALSE;
natGen _ NATsInInterval[start, segCount, segCount];
FOR i: INT _ NextNAT[natGen], NextNAT[natGen] UNTIL i = -1 DO 
[in, seqGen.list, thisSeq, runCount] _ ConsiderJoint[in, seqGen.list, seq, thisSeq, runCount, i];
[in, seqGen.list, thisSeq, runCount] _ ConsiderSegment[in, seqGen.list, seq, thisSeq, runCount, i];
ENDLOOP;
IF in THEN seqGen.list _ AppendToList[seqGen.list, CONS[thisSeq, NIL]];
};

ControlPointsOnly: PROC [seq: TrajParts] RETURNS [BOOL] = {
RETURN[seq#NIL AND seq.jointCount = 0 AND seq.segCount = 0];
};

NextSequence: PUBLIC PROC [seqGen: SequenceGenerator] RETURNS [seq: TrajParts] = {
IF seqGen.list = NIL THEN RETURN[NIL];
seq _ seqGen.list.first;
seqGen.list _ seqGen.list.rest;
};

FirstRun: PUBLIC PROC [seq: TrajParts] RETURNS [runParts: TrajParts] = {
runCount: NAT;
seqGen: SequenceGenerator;
[seqGen, runCount] _ RunsInSequence[seq];
runParts _ IF runCount = 0 THEN NIL ELSE NextSequence[seqGen];
};

FirstTransitionInRun: PROC [seq: TrajParts] RETURNS [transitionNum: NAT] = {
hiSegment: NAT _ seq.segments.len-1; -- GGTraj.HiSegment[seq.traj];
IF --seq.traj.role = open-- seq.segments.len#seq.joints.len THEN {
FOR i: NAT IN [0..hiSegment] DO
IF seq.joints[i] THEN RETURN[i];
IF seq.segments[i] THEN RETURN[i];
ENDLOOP;
IF seq.joints[hiSegment+1] THEN RETURN[hiSegment+1];
SIGNAL Problem[msg: "there is no break in the sequence."];
}
ELSE {
FOR i: NAT IN [0..hiSegment] DO
IF NOT seq.segments[(i -1 + seq.segments.len) MOD seq.segments.len] AND seq.joints[i] THEN GOTO FoundStart;
IF NOT seq.joints[i] AND seq.segments[i] THEN GOTO FoundStart;
REPEAT
FoundStart => transitionNum _ i;
FINISHED => SIGNAL Problem[msg: "there is no break in the sequence."];
ENDLOOP;
};
};

AppendToList: PROC [list1, list2: LIST OF TrajParts] RETURNS [result: LIST OF TrajParts] = {
pos: LIST OF TrajParts;
newCell: LIST OF TrajParts;
IF list1 = NIL THEN RETURN[list2];
result _ CONS[list1.first, NIL];
pos _ result;
FOR l: LIST OF TrajParts _ list1.rest, l.rest UNTIL l = NIL DO
newCell _ CONS[l.first, NIL];
pos.rest _ newCell;
pos _ newCell;
ENDLOOP;
pos.rest  _ list2;
};

ConsiderJoint: PROC [in: BOOL, list: LIST OF TrajParts, seq: TrajParts, thisSeq: TrajParts, runCount: NAT, i: NAT] RETURNS [newIn: BOOL, newList: LIST OF TrajParts, newThisSeq: TrajParts, newCount: NAT] = {
newIn _ in;
newList _ list;
newThisSeq _ thisSeq;
newCount _ runCount;
SELECT TRUE FROM
NOT seq.joints[i] AND NOT in => {};
NOT seq.joints[i] AND in => {
newIn _ FALSE;
newList _ AppendToList[list, CONS[thisSeq, NIL]];
newThisSeq _ NIL};
seq.joints[i] AND NOT in => {
newIn _ TRUE;
newThisSeq _ CreateEmptySeq[seq];
newCount _ newCount + 1;
newThisSeq.joints[i] _ TRUE;
newThisSeq.jointCount _ newThisSeq.jointCount + 1;
};
seq.joints[i] AND in => {
newThisSeq.joints[i] _ TRUE;
newThisSeq.jointCount _ newThisSeq.jointCount + 1;
};
ENDCASE => ERROR;
};

ConsiderSegment: PROC [in: BOOL, list: LIST OF TrajParts, seq: TrajParts, thisSeq: TrajParts, runCount: NAT, i: NAT] RETURNS [newIn: BOOL, newList: LIST OF TrajParts, newThisSeq: TrajParts, newCount: NAT] = {
newIn _ in;
newList _ list;
newThisSeq _ thisSeq;
newCount _ runCount;
SELECT TRUE FROM
NOT seq.segments[i] AND NOT in => {};
NOT seq.segments[i] AND in => {
newIn _ FALSE;
newList _ AppendToList[list, CONS[thisSeq, NIL]];
newThisSeq _ NIL};
seq.segments[i] AND NOT in => {
newIn _ TRUE;
newThisSeq _ CreateEmptySeq[seq];
newCount _ newCount + 1;
newThisSeq.segments[i] _ TRUE;
newThisSeq.segCount _ newThisSeq.segCount + 1;
ControlPointsTrue[newThisSeq, i];
};
seq.segments[i] AND in => {
newThisSeq.segments[i] _ TRUE;
newThisSeq.segCount _ newThisSeq.segCount + 1;
ControlPointsTrue[newThisSeq, i];
};
ENDCASE => ERROR;
};

ControlPointsTrue: PROC [seq: TrajParts, segNum: NAT] = {
cpCount: NAT _ seq.controlPoints[segNum].len;
FOR j: NAT IN [0..cpCount) DO
IF NOT seq.controlPoints[segNum][j] THEN {
seq.controlPoints[segNum][j] _ TRUE;
seq.controlPointCount _ seq.controlPointCount + 1;
};
ENDLOOP;
};

NATGenerator: TYPE = REF NATGeneratorObj;
NATGeneratorObj: TYPE = RECORD [
toGo: NAT,
next: NAT,
mod: NAT
];

NATsInInterval: PROC [start, length, mod: NAT] RETURNS [natGen: NATGenerator] = {
natGen _ NEW[NATGeneratorObj _ [
toGo: length,
next: start,
mod: mod]];
};

NextNAT: PROC [natGen: NATGenerator] RETURNS [nextNAT: INT] = {
IF natGen.toGo = 0 THEN RETURN[-1];
natGen.toGo _ natGen.toGo - 1;
nextNAT _ natGen.next;
natGen.next _ (natGen.next + 1) MOD natGen.mod;
};

SegmentsInTraj: PUBLIC PROC [traj: TrajData] RETURNS [segGen: SegmentGenerator] =  {
segGen _ NEW[SegmentGeneratorObj _ [
traj: traj,
toGo: traj.segCount,
index: 0,
seq: NIL,
completeSeq: TRUE
]];
};

WalkSegmentsInTraj: PUBLIC PROC [traj: TrajData, walkProc: SegmentWalkProc] RETURNS [aborted: BOOL _ FALSE] = {
seg: Segment;
FOR i: NAT IN [0..GGTraj.HiSegmentTraj[traj]] DO
seg _ GGTraj.FetchSegmentTraj[traj, i];
aborted _ walkProc[traj, seg, i];
IF aborted THEN RETURN;
ENDLOOP;
};
WalkSegmentsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts, walkProc: SegmentWalkProc] RETURNS [aborted: BOOL _ FALSE] = {
seg: Segment;
done: BOOL _ FALSE;
toGo: NAT _ IF seq = NIL THEN 0 ELSE seq.segCount;
segCount: NAT _ traj.segCount;
index, touched: NAT _ 0;
FOR i: NAT IN [1..toGo] DO
UNTIL seq.segments[index] DO
index _ (index + 1) MOD segCount;
touched _ touched + 1;
IF touched >= segCount THEN SIGNAL Problem[msg: "Broken invariant"];
ENDLOOP;
seg _ GGTraj.FetchSegmentTraj[traj, index];
aborted _ walkProc[traj, seg, index];
IF aborted THEN RETURN;
index _ (index + 1) MOD segCount;
ENDLOOP;
};

CountSegmentsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts] RETURNS [count: NAT] = {
AddEmUp: PROC [traj: TrajData, seg: Segment, index: NAT] RETURNS [done: BOOL _ FALSE] = {
count _ count + 1;
};
count _ 0;
[] _ WalkSegmentsInSequence[traj, seq, AddEmUp];
};

NextSegmentAndIndex: PUBLIC PROC [segGen: SegmentGenerator] RETURNS [next: SegAndIndex] = {
segCount: NAT;
seq: TrajParts _ segGen.seq;
IF segGen.toGo = 0 THEN RETURN[[NIL, 999]];
segCount _ GGTraj.HiSegmentTraj[segGen.traj] + 1;
IF NOT segGen.completeSeq THEN { -- If we are stepping through a complete traj, seq = NIL
UNTIL seq.segments[segGen.index] DO
segGen.index _ (segGen.index + 1) MOD segCount;
segGen.touched _ segGen.touched + 1;
IF segGen.touched >= segCount THEN SIGNAL Problem[msg: "Broken invariant"];
ENDLOOP;
};
next.seg _ GGTraj.FetchSegmentTraj[segGen.traj, segGen.index];
next.index _ segGen.index;
segGen.index _ (segGen.index + 1) MOD segCount;
segGen.touched _ segGen.touched + 1;
segGen.toGo _ segGen.toGo - 1;
};

SegmentsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts] RETURNS [segGen: SegmentGenerator] = {
IF IsComplete[seq] THEN {
segGen _ SegmentsInTraj[traj];
RETURN;
};
segGen _ NEW[SegmentGeneratorObj _ [
traj: IF seq=NIL THEN NIL ELSE traj,
toGo: IF seq=NIL THEN 0 ELSE seq.segCount,
index: 0,
seq: seq, -- should we copy it? Bier January 27, 1986 5:37:01 pm PST
completeSeq: FALSE
]];
};

OrderedSegmentsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts] RETURNS [segGen: SegmentGenerator] = {
IF IsComplete[seq] THEN RETURN[SegmentsInTraj[traj]];
segGen _ NEW[SegmentGeneratorObj _ [
traj: traj,
toGo: seq.segCount,
index: IF seq.segCount=0 THEN 0 ELSE FirstSegment[seq], -- KAP December 22, 1986
seq: seq, -- should we copy it? Bier January 27, 1986
completeSeq: FALSE
]];
};

NextSegment: PUBLIC PROC [segGen: SegmentGenerator] RETURNS [next: Segment] = {
segCount: NAT;
seq: TrajParts _ segGen.seq;
IF segGen.toGo = 0 THEN RETURN[NIL];
segCount _ GGTraj.HiSegmentTraj[segGen.traj] + 1;
IF NOT segGen.completeSeq THEN { -- If we are stepping through a complete traj, seq = NIL
UNTIL seq.segments[segGen.index] DO
segGen.index _ (segGen.index + 1) MOD segCount;
segGen.touched _ segGen.touched + 1;
IF segGen.touched >= segCount THEN SIGNAL Problem[msg: "Broken invariant"];
ENDLOOP;
};
next _ GGTraj.FetchSegmentTraj[segGen.traj, segGen.index];
segGen.index _ (segGen.index + 1) MOD segCount;
segGen.touched _ segGen.touched + 1;
segGen.toGo _ segGen.toGo - 1;
};

ControlPointsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts] RETURNS [cpGen: ControlPointGenerator] = {
cpGen _ NEW[ControlPointGeneratorObj _ [
traj: traj,
seq: seq,
toGo: IF seq=NIL THEN 0 ELSE seq.controlPointCount,
segIndex: 0,
cpIndex: 0
]];
};

WalkControlPointsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts, walkProc: PointWalkProc] = {
hiSegment: NAT _ seq.segments.len-1;
seg: Segment;
done: BOOL _ FALSE;
FOR i: NAT IN [0..hiSegment] DO
FOR j: NAT IN [0..seq.controlPoints[i].len) DO
IF seq.controlPoints[i][j] THEN {
seg _ GGTraj.FetchSegmentTraj[traj, i];
done _ walkProc[seg.class.controlPointGet[seg, j]];
IF done THEN RETURN;
};
ENDLOOP;
ENDLOOP;
};

NextControlPoint: PUBLIC PROC [cpGen: ControlPointGenerator] RETURNS [next: PointAndDone] = {
IF cpGen.toGo = 0 THEN RETURN[[[0,0], TRUE]] ELSE {
trajParts: TrajParts _ cpGen.seq;
seg: Segment;
segIndex: NAT _ cpGen.segIndex;
cpIndex: NAT _ cpGen.cpIndex;
hiSegment: NAT _ trajParts.segments.len;
FOR i: NAT IN [segIndex..hiSegment) DO
FOR j: NAT IN [cpIndex..trajParts.controlPoints[i].len) DO
IF trajParts.controlPoints[i][j] THEN {
segIndex _ i;
cpIndex _ j;
GOTO Found;
};
ENDLOOP;
cpIndex _ 0;
REPEAT
Found => {
seg _ GGTraj.FetchSegmentTraj[cpGen.traj, segIndex];
next.point _ seg.class.controlPointGet[seg, cpIndex];
next.done _ FALSE;
};
FINISHED => ERROR;
ENDLOOP;
cpGen.segIndex _ segIndex;
cpGen.cpIndex _ cpIndex + 1;
cpGen.toGo _ cpGen.toGo - 1;
};
};

NextSegNumAndCPNum: PUBLIC PROC [cpGen: ControlPointGenerator] RETURNS [segNum, cpNum: NAT, done: BOOL] = {
IF cpGen.toGo = 0 THEN RETURN[0, 0, TRUE] ELSE {
seq: TrajParts _ cpGen.seq;
segIndex: NAT _ cpGen.segIndex;
cpIndex: NAT _ cpGen.cpIndex;
hiSegment: NAT _ seq.segments.len;
FOR i: NAT IN [segIndex..hiSegment) DO
FOR j: NAT IN [cpIndex..seq.controlPoints[i].len) DO
IF seq.controlPoints[i][j] THEN {
segIndex _ i;
cpIndex _ j;
GOTO Found;
};
ENDLOOP;
cpIndex _ 0;
REPEAT
Found => {
segNum _ segIndex;
cpNum _ cpIndex;
done _ FALSE;
};
FINISHED => ERROR;
ENDLOOP;
cpGen.segIndex _ segIndex;
cpGen.cpIndex _ cpIndex + 1;
cpGen.toGo _ cpGen.toGo - 1;
};
};

JointsInSequence: PUBLIC PROC [seq: TrajParts] RETURNS [jointGen: JointGenerator] = {
jointGen _ NEW[JointGeneratorObj _ [ -- this allocate is expensive too.
traj: NIL, -- shouldn't be needed
toGo: IF seq=NIL THEN 0 ELSE seq.jointCount,
index: 0,
seq: seq,
completeSeq: FALSE -- for optimization.
]];
};

WalkJointPositionsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts, walkProc: JointWalkProc] = {
jointPos: Point;
done: BOOL _ FALSE;
toGo: NAT _ IF seq = NIL THEN 0 ELSE seq.jointCount;
hiJoint: NAT _ seq.joints.len;
index: NAT _ 0;
FOR i: NAT IN [1..toGo] DO
UNTIL seq.joints[index] OR index > hiJoint DO
index _ index + 1;
ENDLOOP;
IF index > hiJoint THEN ERROR;
jointPos _ GGTraj.FetchJointPosTraj[traj, index];
done _ walkProc[traj, jointPos, index];
IF done THEN RETURN;
index _ index + 1;
ENDLOOP;
};

WalkJointsInSequence: PUBLIC PROC [traj: TrajData, seq: TrajParts, walkProc: PointWalkProc] = {
jointPos: Point;
done: BOOL _ FALSE;
toGo: NAT _ IF seq = NIL THEN 0 ELSE seq.jointCount;
hiJoint: NAT _ seq.joints.len;
index: NAT _ 0;
FOR i: NAT IN [1..toGo] DO
UNTIL seq.joints[index] OR index > hiJoint DO
index _ index + 1;
ENDLOOP;
IF index > hiJoint THEN ERROR;
jointPos _ GGTraj.FetchJointPosTraj[traj, index];
done _ walkProc[jointPos];
IF done THEN RETURN;
index _ index + 1;
ENDLOOP;
};

JointsInTraj: PUBLIC PROC [traj: TrajData] RETURNS [jointGen: JointGenerator] = {
jointGen _ NEW[JointGeneratorObj _ [
traj: NIL, -- shouldn't be needed
toGo: GGTraj.HiJointTraj[traj] + 1,
index: 0,
seq: NIL,
completeSeq: TRUE
]];
};

NextJoint: PUBLIC PROC [jointGen: JointGenerator] RETURNS [next: INT] = {
seq: TrajParts _ jointGen.seq;
index: NAT _ jointGen.index;
IF jointGen.toGo = 0 THEN RETURN[-1];
IF jointGen.completeSeq THEN {
next _ index;
}
ELSE {
hiJoint: NAT _ seq.joints.len;
UNTIL seq.joints[index] OR index > hiJoint DO
index _ index + 1;
ENDLOOP;
IF index > hiJoint THEN ERROR;
next _ index;
};
jointGen.index _ index + 1;
jointGen.toGo _ jointGen.toGo - 1;
};

END.
F†GGSequenceImpl.mesa
Copyright Ó 1986, 1987, 1988, 1989 by Xerox Corporation.  All rights reserved.
Last edited by Bier on July 16, 1987 2:25:24 pm PDT
Pier, November 17, 1989 4:01:59 pm PST
Kurlander July 28, 1986 2:41:32 pm PDT
Eisenman, October 5, 1987 9:53:39 am PDT
Bier, June 1, 1992 6:08 pm PDT
Doug Wyatt, December 18, 1989 3:22:34 pm PST

Contents:  Sequences are a way to describe some part of a trajectory without actually pulling the trajectory apart.  The new definition of sequence is that it is ANY subset of the parts of a trajectory (joints and/or segments).  Procedures are provided which make sequences, perform boolean operations on them, and step through them.

BoundBox: TYPE = GGCoreTypes.BoundBox;
TrajParts Creation
The sequence created will include all of the segments from startSeg to endSeg inclusive, and all of the joints which they touch.  startSeg and endSeg must be legal TrajParts numbers for this trajectory.  If the trajectory is closed, then startSeg > endSeg is allowed, in which case the segment sequence wraps around.
If startSeg = endSeg, then one segment is added.
If startSeg = endSeg + 1 (modulo the number of segments in traj), then the whole trajectory is selected.
IF the traj is open, then select all segments in the interval [startJoint..endJoint].  If the traj is closed, there are three cases:  1)  IF startJoint < endJoint then proceed as for an open traj (but there is no way to select the whole trajectory.  2)  IF startJoint = endJoint then select a single joint.  3)  IF endJoint < startJoint, wrap around, selecting all segments above startJoint, all segments below endJoint, all joints above startJoint including startJoint, all joints below endJoint, including endJoint.
Closed trajectory with endJoint < startJoint (Case 3).
Returns a sequence which represents the entire trajectory.
IF IsObsolete[seq] THEN ERROR;

Fundamentals

ComputeBoundBox: PUBLIC PROC [seq: TrajParts] RETURNS [box: BoundBox] = {
IF seq=NIL THEN RETURN[NIL];
UpdateBoundBox[seq];
box _ seq.boundBox;
};

UpdateBoundBox:  PUBLIC PROC [seq: TrajParts] = {
halfJointSize: REAL = GGModelTypes.halfJointSize + 1;
Algorithm:
ForAllJointsInSeq, if joint does not touch a segmentInSeq then update bound box with joint bound box. 
ForAllCPInSeq, update bound box with cp bound box. 
ForAllSegsInSeq, update bound box with segment bound box.

Sequences often arrives here with seq.boundBox = copy of their traj.boundBox (and thus too big), or with seq.boundBox=NIL. We ignore the current contents and calculate the update from scratch.
traj: TrajData;
box: BoundBox;
IF seq=NIL THEN RETURN;
traj _ seq.traj;
box _ seq.boundBox;
box.null _ TRUE;

ForAllJointsInSeq, if joint does not touch a segmentInSeq then update bound box with joint bound box. 
IF seq.jointCount#0 THEN { -- ForAllJointsInTraj
IF traj.role = open THEN { -- ForAllJointsInOpenTraj
IF seq.joints[0] AND NOT seq.segments[0] THEN UpdateBySquare[box, GGTraj.FetchJointPos[traj, 0], halfJointSize]; -- boundary case for joint 0
FOR i: NAT IN [1..traj.segCount) DO -- loop for inner joints
IF seq.joints[i] AND NOT seq.segments[i] AND NOT seq.segments[i-1] THEN UpdateBySquare[box, GGTraj.FetchJointPos[traj, i], halfJointSize];
ENDLOOP;
IF seq.joints[traj.segCount] AND NOT seq.segments[traj.segCount-1] THEN UpdateBySquare[box, GGTraj.FetchJointPos[traj, traj.segCount], halfJointSize]; -- boundary case for last joint
}
ELSE { -- ForAllJointsInClosedTraj
FOR i: NAT IN [0..seq.traj.segCount) DO 
IF seq.joints[i] AND NOT seq.segments[i] AND NOT seq.segments[(i -1 + seq.traj.segCount) MOD seq.traj.segCount] THEN UpdateBySquare[box, GGTraj.FetchJointPos[traj, i], halfJointSize];
ENDLOOP;
};
};
ForAllCPInSeq, update bound box with cp bound box. 
IF seq.controlPointCount#0 THEN { -- if some control point is in the sequence then ...
FOR i: NAT IN [0..seq.traj.segCount) DO  -- for each segment in the traj
IF NOT seq.segments[i] AND SomeSegCPInSeq[i, seq] THEN { -- if this segment is not already in the sequence and any control point of this segment is selected then ...
seg: Segment _ GGTraj.FetchSegment[traj, i]; -- get the segment
cpCount: NAT _ seq.controlPoints[i].len;
FOR j: NAT IN [0..cpCount) DO -- for all control points in the segment
IF seq.controlPoints[i][j] THEN { -- if this cp is in the sequence
point: Point _ seg.class.controlPointGet[seg, j];
UpdateBySquare[box, point, halfJointSize]; -- update the bounding box with the control point
};
ENDLOOP;
};
ENDLOOP;
};
ForAllSegsInSeq, update bound box with segment bound box.
IF seq.segCount#0 THEN { -- if some segment is in the sequence
FOR s: NAT IN [0..seq.traj.segCount) DO  -- for each segment in the traj
IF seq.segments[s] THEN { -- if this segment is in the sequence
seg: Segment _ GGTraj.FetchSegment[traj, s]; -- get the segment
GGBoundBox.EnlargeByBox[bBox: box, by: seg.class.boundBox[seg]]; -- update the bounding box with the segment
};
ENDLOOP;
};
};

ComputeTightBox: PUBLIC PROC [seq: TrajParts] RETURNS [box: BoundBox] = {
halfJointSize: REAL = GGModelTypes.halfJointSize + 1;
Algorithm:
ForAllSegsInSeq, update bound box with segment tight box.

traj: TrajData;
IF seq=NIL THEN RETURN[NIL];
traj _ seq.traj;
box _ GGBoundBox.NullBoundBox[];

ForAllSegsInSeq, update bound box with segment bound box.
IF seq.segCount#0 THEN {
FOR s: NAT IN [0..seq.traj.segCount) DO  -- for each segment in the traj
IF seq.segments[s] THEN { -- if this segment is in the sequence
seg: Segment _ GGTraj.FetchSegment[traj, s];
GGBoundBox.EnlargeByBox[bBox: box, by: seg.class.tightBox[seg]];
};
ENDLOOP;
};
seq.boundBox _ box;  -- and, finally, store the new result
};

UpdateBySquare: PROC [bBox: BoundBox, p: Point, halfSquareSide: REAL]  ~ { -- updates the accumulating bBox by a joint or CP
pHalf: REAL _ halfSquareSide+1;
loX, loY, hiX, hiY: REAL;
IF bBox.infinite THEN RETURN;
loX _ p.x-pHalf;  loY _ p.y-pHalf; hiX _ p.x+pHalf;  hiY _ p.y+pHalf;
IF bBox.null THEN {
bBox.loX _ loX;
bBox.hiX _ hiX;
bBox.loY _ loY;
bBox.hiY _ hiY;
bBox.null _ FALSE;
RETURN;
};
IF loX < bBox.loX THEN bBox.loX _ loX;
IF hiX > bBox.hiX THEN bBox.hiX _ hiX;
IF loY < bBox.loY THEN bBox.loY _ loY;
IF hiY > bBox.hiY THEN bBox.hiY _ hiY;
};

Textual Description

Describe: PUBLIC PROC [seq: TrajParts] RETURNS [rope: Rope.ROPE] = {
IF seq=NIL THEN RETURN[NIL] ELSE {
segNum, cpNum: NAT;
segCount: NAT _ seq.segCount;
jointCount: NAT _ seq.jointCount;
cpCount: NAT _ seq.controlPointCount;
SELECT TRUE FROM
segCount=1 => { -- single segment selected. Describe it
segGen: SegmentGenerator _ GGSequence.SegmentsInSequence[seq];
rope _ GGDescribe.DescribeSegment[seq.traj,
GGSequence.NextSegmentAndIndex[segGen].index];
};
segCount=0 AND cpCount=1 => { -- single CP selected. Describe it
cpGen: ControlPointGenerator _ GGSequence.ControlPointsInSequence[seq];
[segNum, cpNum] _ GGSequence.NextSegNumAndCPNum[cpGen];
rope _ GGDescribe.DescribeControlPoint[seq.traj, segNum, cpNum];
};
segCount=0 AND cpCount=0 AND jointCount=1 => { -- single joint selected. Describe it
jointGen: JointGenerator _ GGSequence.JointsInSequence[seq];
rope _ GGDescribe.DescribeJoint[seq.traj, GGSequence.NextJoint[jointGen]];
};
ENDCASE => rope _ GGDescribe.DescribeSequence[seq];
};
};

Procedures which mutate Segments (use with caution)
IF IsObsolete[from] THEN ERROR;
a sequence with segments filled in. Fill in all the joints for each segment in the sequence, and calculate the new joint count.  Leave in all isolated joints as well.
Modifies, mutes, and munges trimDescriptor, so that it no longer includes any parts mentioned in selectedList.  Used by GGAlign.RemoveMoving.
Modifies, mutes, and munges seq, so that it no longer includes any segments whose joints are mentioned in selectedList.  Used by GGAlign.RemoveMoving.
TrimDanglingSegments: PUBLIC PROC [trimDescriptor: SliceDescriptor] = {
For all runs in seq, if either end of the run is a segment (not a joint), remove that segment.
seq: TrajParts _ NARROW[trimDescriptor.parts];
runGen: SequenceGenerator;
runCount: NAT;
haveTrimmed: BOOL;
firstSegNum, firstJointNum, lastSegNum, lastJointNum: INT;

IF IsComplete[seq] THEN RETURN; -- nothing is dangling if all joints are included
[runGen, runCount] _ RunsInSequence[seq];
FOR run: TrajParts _ NextSequence[runGen], NextSequence[runGen] UNTIL run = NIL DO
haveTrimmed _ FALSE;
firstSegNum _ FirstSegNum[run];
firstJointNum _ FirstJointNum[run];
lastSegNum _ LastSegNum[run, firstSegNum];
lastJointNum _ LastJointNum[run, firstJointNum];
IF firstJointNum = -1 THEN {
there are no joints in the run.  It only has one segment.  Remove that segment.
IF firstSegNum = -1 THEN ERROR; -- there must be something in the run
IF NOT seq.segments[firstSegNum] THEN ERROR;
seq.segments[firstSegNum] _ FALSE;
seq.segCount _ seq.segCount - 1;
LOOP;
};
IF lastJointNum = -1 THEN ERROR; -- if there was a first joint, there must be a last one (it is equal to the first joint if there is only one).
IF firstSegNum = -1 THEN LOOP; -- there are no segments so there is nothing to trim
IF lastSegNum = -1 THEN ERROR; -- if there was a first segment, there must be a last.
Assert: If we reach this point, there is at least one joint and at least one segment.
IF firstJointNum # firstSegNum THEN {
IF NOT seq.segments[lastSegNum] THEN ERROR;
seq.segments[firstSegNum] _ FALSE;
seq.segCount _ seq.segCount - 1;
haveTrimmed _ TRUE;
};
IF ((seq.traj.role = open AND lastSegNum + 1 # lastJointNum) OR
(seq.traj.role # open AND ((lastSegNum + 1) MOD seq.traj.segCount) # lastJointNum))
AND (NOT haveTrimmed OR lastSegNum # firstSegNum) THEN {
IF NOT seq.segments[lastSegNum] THEN ERROR;
seq.segments[lastSegNum] _ FALSE;
seq.segCount _ seq.segCount - 1;
};
ENDLOOP;
};

TrimControlPointSegments: PUBLIC PROC [seq: TrajParts, controlPointOn: BOOL] = {
trim segments with any included control points
SomeIncludedCP: PROC [i: NAT] RETURNS [BOOL] = {
FOR j: NAT IN [0..seq.controlPoints[i].len) DO
IF seq.controlPoints[i][j] = controlPointOn THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};
IF IsObsolete[seq] THEN ERROR;
FOR i: NAT IN [0..GGTraj.HiSegment[seq.traj]] DO
IF seq.segments[i] AND SomeIncludedCP[i] THEN {
seq.segments[i] _ FALSE;
seq.segCount _ seq.segCount - 1;
};
ENDLOOP;
};

TrimJointSegments: PUBLIC PROC [seq: TrajParts, jointOn: BOOL] = {
If jointOn then for all segments in seq, remove those that have a joint mentioned in seq.  Otherwise, remove those segments that do NOT have a joint mentioned.
SomeSelectedJoint: PROC [i: NAT] RETURNS [BOOL] = {
RETURN[
seq.joints[i] = jointOn OR seq.joints[GGTraj.FollowingJoint[seq.traj, i]] = jointOn
];
};
FOR i: NAT IN [0..GGTraj.HiSegment[seq.traj]] DO
IF seq.segments[i] AND SomeSelectedJoint[i] THEN {
seq.segments[i] _ FALSE;
seq.segCount _ seq.segCount - 1;
};
ENDLOOP;
};

Modifies, mutes, and munges seq, so that it no longer includes any segments whose control points are mentioned in selectedList.  Used by GGAlign.RemoveMoving.
Adds to descriptor those segments whose joints are mentioned in selected, but who are not mentioned in selected themselves.
Adds to descriptor those segments whose control points are mentioned in selected, but who are not mentioned in selected themselves.
Adds to descriptor those segments whose control points are constrained to move, but who are not mentioned in selected themselves.
May want to add specific control points to rubber.
Adds to the seq a new bezier that is being dragged into shape.
This is a destructive form of the Difference operation.  mutable _ mutable - negative.
IF IsObsolete[mutable] OR IsObsolete[negative] THEN ERROR;

Utility Routines

Boolean Operations on Sequences

IF IsObsolete[a] OR IsObsolete[b] THEN ERROR;
IF IsObsolete[a] OR IsObsolete[b] THEN ERROR;
IF IsObsolete[a] OR IsObsolete[b] THEN ERROR;
A trajectory doesn't know whether or not it is filled, so it cannot know the difference between background parts and overlay parts.  My convention will be that background is NIL.  Here is the algorithm for the rest:
All selected joints, control points and segments are "drag";
All unselected segments with selected joints or control points are "rubber".
All unselected segments with constrained control points are "rubber".
Everything else is overlay.
A segment (and joint) have been added to one end (the trajEnd end) of traj, making seq obsolete.  Create a new sequence bigger which refers to the same joints and segments that seq did, but for the new trajectory.  If extend is TRUE, then bigger will include the newly added segment if seq included the old joint which it was attached to.
Copy the old information.
At this point the counts and bit vectors are consistent.
At this point the counts and bit vectors are consistent.
A segment has been added to one end (the high end) of seq.traj, making seq obsolete.  Create a new sequence bigger which refers to the same joints and segments that seq did, but for the new trajectory.  If extend is TRUE, then bigger will include the newly added segment if seq included the old joint which it was attached to.
At this point bigger.segCount, bigger.jointCount, bigger.controlPointCount are consistent with the segments, joints, and controlPoints bit vectors.
Queries
TEST if this sequence cannot possibly encode its trajectory, probably because the trajectory has been modified. Not a guarantee that it accurately encodes anything.
j: NAT _ 0;
segGen: SegmentGenerator;
IF seq.segments.len # seq.traj.segCount THEN RETURN[TRUE];
IF seq.joints.len # (GGTraj.HiJoint[seq.traj] + 1) THEN RETURN[TRUE];
segGen _ SegmentsInTraj[seq.traj];
FOR nextSeg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL nextSeg=NIL DO
IF nextSeg.class.controlPointCount[nextSeg]#seq.controlPoints[j].len THEN RETURN[TRUE];
j _ j+1;
ENDLOOP;
RETURN[FALSE];
THE ABOVE CODE IS ITSELF OBSOLETE

IF IsObsolete[seq1] OR IsObsolete[seq2] THEN ERROR;
Compare the segment bit vectors.
Compare the joint bit vectors.
Returns TRUE if the sequence contains any part of a segment, including its end joints, its control points, or the segment proper.
IF IsObsolete[seq] THEN ERROR;
run had better be a run (a single non-empty contiguous sequence).
LastSegNum: PUBLIC PROC [run: TrajParts, firstSegNum: INT] RETURNS [lastNum: INT] = {
run had better be a run (a single non-empty contiguous sequence).
IF firstSegNum = -1 THEN RETURN[-1];
IF run.traj.role = open THEN lastNum _ firstSegNum + run.segCount - 1
ELSE lastNum _ (firstSegNum + run.segCount - 1 + run.traj.segCount) MOD run.traj.segCount;
};

run had better be a run (a single non-empty contiguous sequence).
run had better be a run (a single non-empty contiguous sequence).
seq is asserted to be either a single joint or a single control point.  Return the [segNum, cpNum] pair or the jointNum as appropriate.
seg _ GGTraj.FetchSegment[seq.traj, i];
FOR j: NAT IN [0..seg.class.controlPointCount[seg] - 1] DO
Look for a joint.

Generators

A run is a sequence with only one contiguous piece.   In other words, each joint in the run touches at least one segment in the run (unless the run is a single joint), and each segment in the run touches at least one joint in the run (unless the run is a single segment).  The run whose lowest joint has the lowest index will be returned first by NextSequence.  The other runs will follow in ascending order.
IF IsObsolete[seq] THEN ERROR;
This is done in two parts.  First we find the first joint or segment that is preceded by a segment or joint that is not in the sequence.  Then we proceed as for open but mod traj.segCount.
Interim implementation.  Clearly, we don't really need to generate all of them just to get the first.
Finds the first transition from a joint that's not in the sequence to a segment in the sequence, or from a segment that's not in the sequence to a joint that's in the sequence.  For example, with sequence 0 (0) 1 (1) 2 (2) 3 (3) 4, transition segment (1) ->  joint 2 returns 2.  joint 1 -> segment (2) returns 2.  Hence, if the first run has any segments at all, transitionNum will be the number of the first segment.
Non-destructive (copies the first list).
runCount _ runCount + 1; -- BUG! KAP March 11, 1986
We special case the complete trajectory case to reduce allocations.
Calls walkProc for each segment in traj, until walkProc returns done=TRUE.

Calls walkProc for each segment mentioned in seq, until walkProc returns done=TRUE.
Termination:  segGen.toGo is always decremented.
Invariants:
1)  When this procedure is called, seq.segments[segGen.index] has not yet been looked at OR segGen.toGo = 0.
2)  touched < segCount OR segGen.toGo = 0.
3)  At this point in the procedure, seq.segments[segGen.index] is TRUE.
4)  At this point, touched < segCount.
NIL TrajParts now legal in outline descriptors !!. KAP. September 16, 1987
Returns a generator for all segments in seq, beginning with the lowest numbered one (in the case of open trajectories), or the first segment that follows a segment that is not in seq (for closed trajectories).  If seq.traj is complete, then begins with segment 0.
IF IsEmpty[seq] THEN ERROR; -- why an error?? KAP December 22, 1986
IF IsObsolete[seq] THEN ERROR;
Termination:  segGen.toGo is always decremented.
Invariants:
1)  When this procedure is called, seq.segments[segGen.index] has not yet been looked at OR segGen.toGo = 0.
2)  touched < segCount OR segGen.toGo = 0.
segCount _ seq.segments.len + 1; -- can't do this because seq=NIL for complete guys
3)  At this point in the procedure, seq.segments[segGen.index] is TRUE.
4)  At this point, touched < segCount.
NIL TrajParts now legal in outline descriptors !!. KAP. September 16, 1987
IF IsObsolete[seq] THEN ERROR; -- expensive. KAP. September 16, 1987
It would be nice to have a hiJoint field in the JointGeneratorObj, Bier, January 7, 1987
IF IsObsolete[seq] THEN ERROR; -- expensive (HorizontalBench.script).  Bier, April 7, 1987
Calls walkProc on each joint position in seq until walkProc returns done=TRUE.
Calls walkProc on each joint position in seq until walkProc returns done=TRUE.
hiJoint: NAT _ GGTraj.HiJoint[jointGen.traj];
�ÊGÖ˜
codeš
œ™Kš
œN™NKš
œ3™3Kš
œ&™&Kšœ#Ïk™&K™(K™K™,—K™KšÏnœš
�œ¨
™ÍK™š
�	˜	Jš
œ 
˜ 
—K˜šžœ�œ
�˜Jš�œG˜NKš�œ�˜—˜Kšœ�œ%˜;Kšœ�œ˜)Kšœ�œ˜/Kšœ�œ˜)Kšœ�œ˜/Kšœ
�œ™&Kšœ�œ˜Kšœ�œ&˜AKšœ�œ)˜GKšœ�œ ˜5Kšœ�œ˜!Kšœ�œ˜3Kšœ�œ"˜9Kšœ�œ˜/Kšœ�œ˜!Kšœ�œ˜/Kšœ�œ˜1Kšœ
�œ˜+Kšœ	�œ˜'Kšœ�œ!˜7Kšœ�œ$˜=Kšœ�œ˜3Kšœ�œ!˜5Kšœ�œ ˜7Kšœ�œ#˜=Kšœ�œ˜2Kšœ�œ˜!Kšœ�œ ˜5Kšœ�œ˜+Kšœ�œ˜#Kšœ�œ˜Kšœ
�œ˜'Kšœ	�œ˜%Kšœ�œ˜)Kšœ�œ˜/Kšœ�œ˜/K˜—šžœ�œ
�œ�œ˜;K˜—Kš
œ™K˜š
žœ�œ
�œ$�œ�œ˜dKš
œ¼™¼Kš
œ0™0Kš
œh™hKšœ�œ
˜Kš�œ�œ�œ
�œ
˜CKš�œ�œ+�œ˜Lš�œ�œ˜Kš�œ�œ5˜NKš
œ!˜!K˜
—š�œ˜Kš�œ�œ�œ�œ˜WKšœ0�œ˜GK˜—šœ�œ˜Kš
œ&˜&Kš
œ3˜3Kš
œ"˜"Kš
œ˜KšœÏc)˜?KšœŸ"˜0Kš
œ˜—š�œ�œ˜š�œ�œ
�œ�˜#Kšœ�œ
˜Kš�œ
˜—Kš
œ˜Kš
œ˜K˜
—š�œ˜š�œ�œ
�œ�˜*Kšœ�œ
˜Kš�œ
˜—š�œ�œ
�œ
�˜Kšœ�œ
˜Kš�œ
˜—Kš
œ˜Kš
œ˜K˜—K˜K˜—š
žœ�œ
�œ(�œ�œ˜hKš�œˆ
�œr�œ8�œË
™…Kšœ�œ
˜Kš
œ#˜#š�œ�œ�œ�œ˜DKšœ�œ˜$—š�œ�œ�œ˜3Kš�œ�œ=˜ZKš�œ�œ�œ
�œ
˜3šœ�œ˜Kš
œ&˜&Kš
œ ˜ Kš
œ"˜"Kš
œ ˜ KšœŸ%˜;Kš
œ%˜%Kš
œ˜—š�œ�œ
�œ�˜'Kšœ�œ
˜Kšœ�œ
˜Kš�œ
˜—Kšœ�œ
˜K˜
—š�œ˜Kš�œ�œ+�œ˜PKš
œ6™6šœ�œ˜Kš
œ&˜&Kš
œ ˜ Kš
œ"˜"Kš
œ0˜0Kš
œ˜Kš
œ5˜5Kš
œ˜—š�œ�œ
�œ�˜,Kšœ�œ
˜Kšœ�œ
˜Kš�œ
˜—š�œ�œ
�œ�˜Kšœ�œ
˜Kšœ�œ
˜Kš�œ
˜—Kšœ�œ
˜K˜—KšœŸ˜7K˜K˜—šžœ�œ
�œ�œ˜Fšœ�œ˜Kš
œ&˜&Kš
œ1˜1Kš
œ"˜"K˜Kš
œ˜K˜
Kš
œ˜—K˜K˜—šžœ�œ
�œ�œ˜IK™:Kšœ�œ ˜/šœ�œ˜Kš
œ&˜&Kš
œ!˜!Kš
œ"˜"Kš
œ˜KšœŸ˜3Kš
œ˜Kš
œ˜—š�œ�œ
�œ!�˜0Kšœ�œ
˜Kšœ�œ
˜Kš�œ
˜—Kšœ�œŸ*˜KKšœŸ˜7K˜K˜—š
žœ�œ
�œ�œ�œ˜YKš
œ˜Kšœ�œ
˜Kš
œ˜K˜K˜—š
žœ�œ
�œ�œ�œ˜YKš
œ˜Kšœ�œ
˜Kš
œ˜Kš
œ˜KšœŸ˜7K˜K˜—š
žœ�œ
�œ�œ�œ˜_Kš
œ˜Kšœ�œ
˜Kš
œ˜K˜K˜—šžœ�œ
�œ�œ�œ�œ˜tKš
œ˜Kšœ-�œ
˜2Kš
œ˜K˜K˜—šžœ�œ
�œ�œ˜@Kš
�œ�œ
�œ
�œ
�œ˜Kš�œ�œ
�œ
™šœ�œ˜Kš
œ)˜)Kš
œ%˜%Kš
œ(˜(Kš
œ˜Kš
œ)˜)Kš
œ˜Kš
œ˜—Kš
�œ�œ
�œ�œ%�œ
˜SKš
�œ�œ
�œ�œ!�œ
˜Mš�œ�œ
�œ�˜+Kšœ	�œ˜(š�œ�œ
�œ�˜Kš
œ3˜3Kš�œ
˜—Kš�œ
˜—˜K˜——šžœ�œ
�œ�œ˜KKš
�œ�œ
�œ
�œ
�œ˜šœ�œ˜Kš
œ)˜)Kš
œ%˜%Kš
œ(˜(Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜—˜K˜——K™K™K™šžœ�œ
�œ�œ™IKš
�œ�œ
�œ
�œ
�œ™Kš
œ™Kš
œ™K™K™—šžœ�œ
�œ™1Kšœ�œ"™5™
K™fK™3K™9—K™Kšœv�œG™À
Kš
œ™Kš
œ™Kš�œ�œ
�œ
�œ
™K™Kš
œ™Kšœ�œ
™K™K™fš�œ�œŸ™0š�œ�œŸ™4Kš	�œ�œ
�œ�œDŸ™�
š	�œ�œ
�œ�œ
Ÿ™<Kš�œ�œ
�œ�œ
�œ�œC™Š
Kš�œ
™—Kš	�œ�œ
�œ�œPŸ™¶
K™
—š�œŸ™"š�œ�œ
�œ�œ
™(Kš�œ�œ
�œ�œ
�œ)�œ�œC™·
Kš�œ
™—K™—K™—Kš
œ3™3š�œ�œŸ4™Vš	�œ�œ
�œ�œŸ™Hš	�œ
�œ�œ�œŸl™¥
Kšœ-Ÿ™?Kšœ	�œ™(š	�œ�œ
�œ�œ
Ÿ(™Fš�œ�œŸ ™BKš
œ1™1šœ+Ÿ1™\K™——Kš�œ
™—K™—Kš�œ
™—K™—K™9š�œ�œŸ%™>š	�œ�œ
�œ�œŸ™Hš�œ�œŸ%™?Kšœ-Ÿ™?KšœAŸ+™lK™—Kš�œ
™—K™—K™K™—šžœ�œ
�œ�œ™IKšœ�œ"™5™
K™9—K™Kš
œ™Kš
�œ�œ
�œ
�œ
�œ™K™Kš
œ ™ K™K™9š�œ�œ™š	�œ�œ
�œ�œŸ™Hš�œ�œŸ%™?Kš
œ,™,Kšœ'Ïbœ™@K™—Kš�œ
™—K™—KšœŸ%™:K™K™—šžœ�œ,�œŸ1™|Kšœ�œ™Kšœ�œ
™Kš�œ�œ
�œ
™Kš
œE™Eš�œ�œ™Kš
œ™Kš
œ™Kš
œ™Kš
œ™Kšœ�œ
™Kš�œ
™K™—Kš�œ�œ™&Kš�œ�œ™&Kš�œ�œ™&Kš�œ�œ™&K™—K™Kš
œ™K™š
žœ�œ
�œ�œ
�œ™Dš�œ�œ
�œ
�œ
�œ�œ™"Kšœ�œ
™Kšœ
�œ™Kšœ�œ™!Kšœ	�œ™%š�œ
�œ
�™šœŸ'™7Kš
œ>™>šœ œ
™+Kš
œ.™.—K™—šœ�œŸ"™@Kš
œG™GKš
œ7™7Kšœ œ™@K™—šœ�œ�œŸ%™TKš
œ<™<Kšœ 
œ+™JK™—Kš�œ,™3—K™—K™K™—K˜K™3K˜šžœ�œ
�œ%˜:Kš�œ�œ
�œ
™š�œ�œ
�œ�˜'Kšœ	�œ˜)Kš
œ"˜"š�œ�œ
�œ�˜Kšœ3Ÿ˜HKš�œ
˜—Kš�œ
˜—š�œ�œ
�œ�˜%Kš
œ˜Kš�œ
˜—Kš
œ˜Kš
œ.˜.Kš
œ ˜ ˜K˜——šžœ�œ
�œ˜.Kš
œ¦
™¦
Kšœ�œ˜Kš�œ�œ
�œŸ7˜Vš�œ!�œŸ˜>š�œ�œ
�œ�˜&Kš
�œ�œ�œ�œ�œ˜_Kš�œ
˜—K˜
—š�œ
�œ#�œŸ˜Cš�œ�œ
�œ�˜&Kš�œ�œ�œ�œ˜GKš�œ
˜—K˜
—Kš�œ
�œŸ(˜4š�œ�œ
�œ�˜$Kš�œ�œ˜2Kš�œ
˜—Kš
œ˜˜K˜——šžœ�œ
�œŸ´
˜ê
Kšœ	�œ
˜
Kš�œ�œ
�œŸ8˜WKš
œ˜š�œ�œ
�œ�˜&Kš
œ#˜#š�œ�œ˜š	�œ�œ
�œ�œ
Ÿ˜1Kšœ�œ
˜Kš
œ2˜2Kš�œ
˜—K˜
—š�œ˜š	�œ�œ
�œ�œ
Ÿ˜=Kš�œ�œ3˜RKš�œ
˜—K˜—Kš�œ
˜—K˜K˜—š
žœ�œ
�œ1�œ
�œ˜kKšœx œ
™�
Kšœ�œ˜.Kš
œH˜HKš	�œ
�œ
�œ
�œŸ(˜Eš�œ�œ
�œ�˜&š�œ�œ
�œ�˜.š�œ�œ�œ˜@Kšœ�œ
˜ Kš
œ2˜2K˜—Kš�œ
˜—š�œ�œ�œ˜0Kšœ�œ
˜Kš
œ ˜ K˜—Kš�œ
˜—š�œ�œ
�œ�˜$š�œ�œ�œ˜,Kšœ�œ
˜Kš
œ#˜#K˜—Kš�œ
˜—K˜K˜—š
žœ�œ
�œ1�œ
�œ˜sKšœ�
 œ
™–
š
žœ�œ�œ�œ�œ˜3š�œ
˜Kšœ�œ>˜QK˜—K˜—Kšœ�œ˜.Kš
œH˜HKš	�œ
�œ
�œ
�œŸ)˜Fš�œ�œ
�œ�˜&š�œ�œ�œ˜2Kšœ�œ
˜Kš
œ ˜ K˜—Kš�œ
˜—K˜K˜—šžœ�œ
�œ&™GK™^Kšœ�œ™.Kš
œ™Kšœ
�œ
™Kšœ
�œ
™Kšœ6�œ
™:K™Kš�œ�œ
�œŸ1™QKš
œ)™)š�œ=�œ�œ
�™RKšœ�œ
™Kš
œ™K™#Kš
œ*™*K™0š�œ�œ™K™OKš�œ�œ
�œŸ%™EKš�œ
�œ�œ
�œ
™,Kšœ�œ
™"Kš
œ ™ Kš�œ
™K™—Kš�œ�œ
�œŸn™�
Kš�œ�œ
�œŸ4™SKš�œ�œ
�œŸ6™UKšÐbn O™Uš�œ�œ™%Kš�œ
�œ�œ
�œ
™+Kšœ�œ
™"Kš
œ ™ Kšœ�œ
™K™—š�œ�œ �™?Kšœ�œ�œ$™Sš�œ�œ
�œ�œ™8Kš�œ
�œ�œ
�œ
™+Kšœ�œ
™!Kš
œ ™ K™——Kš�œ
™—K™K™—šžœ�œ
�œ"�œ™PK™.š
žœ�œ�œ�œ�œ™0š�œ�œ
�œ�™.Kš�œ*�œ
�œ
�œ™>Kš�œ
™—Kš�œ
�œ™K™—Kš�œ�œ
�œ
™š�œ�œ
�œ!�™0š�œ�œ�œ™/Kšœ�œ
™Kš
œ ™ K™—Kš�œ
™—K™K™—šžœ�œ
�œ�œ™BKšœ„
�œ™Ÿ
š
žœ�œ�œ�œ�œ™3š�œ
™Kšœ�œ9™SK™—K™—š�œ�œ
�œ!�™0š�œ�œ�œ™2Kšœ�œ
™Kš
œ ™ K™—Kš�œ
™—K™K™—š
ž œ�œ
�œ1�œ
�œ˜zKšœ‰
 œ
™ž
š
žœ�œ�œ�œ�œ˜0š�œ�œ
�œ"�˜1Kš�œ�œ
�œ
�œ˜0Kš�œ
˜—Kš�œ
�œ˜K˜—Jšœ�œ˜.Jš
œH˜HKš	�œ
�œ
�œ
�œŸ&˜Cš�œ�œ
�œ�˜&š�œ�œ�œ˜/Kšœ�œ
˜Kš
œ ˜ K˜—Kš�œ
˜—K˜K˜—šžœ�œ7˜XKš
œ{™{š
žœ�œ�œ�œ�œ˜3š�œ
˜Kšœ�œ<˜QK˜—K˜—Kšœ�œ˜*Kš	�œ�œ
�œ
�œŸ(˜Gš�œ�œ
�œ�˜&š�œ
�œ�œ
�œ�œ�œ˜SKšœ�œ
˜Kš
œ ˜ K˜—Kš�œ
˜—K˜K˜—šž"œ�œ7˜_Kš
œƒ
™ƒ
š
žœ�œ�œ�œ�œ˜0š�œ�œ
�œ$�˜3Kš�œ�œ
�œ
�œ˜2Kš�œ
˜—Kš�œ
�œ˜K˜—Kšœ�œ˜*Kš	�œ�œ
�œ
�œŸ%˜Dš�œ�œ
�œ�˜&š�œ
�œ�œ
�œ�œ�œ˜PKšœ�œ
˜Kš
œ ˜ K˜—Kš�œ
˜—K˜K˜—šžœ�œ7˜KKš
œ�
™�
š
žœ�œ�œ�œ�œ˜9Kšœ�œ
˜Kš
œ:˜:Kš
œ<˜<Kš�œ�œF�œ%�œ
�œ
�œ˜”
Kš�œ�œG�œ&�œ
�œ
�œ˜—
Kš�œ
�œ˜Kš
œ˜—Kšœ�œ˜*Kš	�œ�œ
�œ
�œŸ˜1š�œ�œ
�œ�˜&š�œ?�œ
�œ�œ
�œ�œ�œ˜›
Kšœ�œ
˜Kš
œ ˜ K™2Kš
œ˜—Kš�œ
˜—Kš
œ˜K˜—šžœ�œ/�œ˜IKš
œ>™>Kš	�œ�œ
�œ
�œŸ˜1š
�œ
�œ�œ
�œ�œ˜DKšœ�œ
˜Kš
œ ˜ Kš
œ˜—Kš
œ˜K˜—šžœ�œ
�œ)˜AKš�œ*�œ
�œŸ˜QKšœ�œ�œ˜UK˜K˜—šžœ�œ
�œ ˜<Kš
œV™VKšœ	�œ
˜
Kš�œ�œ�œ
�œ
™:š�œ�œ
�œ�˜)Kšœ	�œ˜+Kšœ(�œ
�œ˜Cš�œ�œ
�œ�˜Kšœ8�œ
�œ˜[Kš�œ
˜—Kšœ$�œ
�œ˜=Kš�œ
˜—Kš
œ˜Kšœ0�œ
�œ˜OKš
œ(˜(Kš
œ(˜(Kš
œ6˜6K˜—K™K™K˜šžœ�œ
�œ�œ
�œ�œ˜sK˜š�œ
�œ
�œ1�œ�œ
�˜aKš
œ+˜+šœ�œ(�œ�œ
�œ+�œ6˜ª
Kš�œ
�œ
˜	—Kš
�œ�œ
�œ
�œ
�œ˜.Kš�œ
˜—Kš�œ
�œ˜K˜K˜—šžœ�œ�œ˜MKšœ�œ&˜5š	�œ�œ
�œ�œ
Ÿ˜HKšœ8Ÿ"˜ZKš�œ
˜—K˜K˜—šžœ�œ�œ˜FKšœ�œ˜Kš
œ;˜;Kšœ�œ˜-š�œO�œ�œ
�˜dKš
œ>˜>K˜Kš�œ
˜—K˜K˜—šžœ�œ
�œ�œ˜@Kšœ	�œ˜#Kšœ�œ˜K˜K™—šž
œ�œ�œ˜4š�œ�œ
�œ�˜ Kš
œ˜Kš�œ
˜—K˜K˜—š
žœ�œ
�œ�œ�œ˜EKšœ	�œ!˜-š�œ�œ
�œ�˜Kš�œ�œ
�œ
�œ˜2Kš�œ
˜—Kš�œ
�œ˜K˜—K˜K™K™šžœ�œ
�œ�œ˜OKšœ	�œ
˜
Kš
œ˜Kšœ�œ
˜"Kšœ�œ˜'Kšœ�œ
˜"Kšœ�œ˜'Kš�œ�œ�œ
�œ
™-Kš�œ�œ
�œ
˜Kš	�œ�œ
�œ
�œŸ˜/Kš	�œ�œ
�œ
�œŸ˜/Kš�œ�œ
�œŸ˜2Kš�œ�œ
�œŸ˜2Kš�œ�œ
�œŸ˜5Kš�œ�œ
�œŸ˜5Kš
œ˜š�œ�œ
�œ�˜'Kšœ	�œ˜)Kšœ$�œ˜8š�œ�œ
�œ�˜Kšœ4�œ˜PKš�œ
˜—Kšœ �œ˜2Kš�œ
˜—K˜Kšœ,�œ˜DKš
œ$˜$Kš
œ$˜$Kš
œ2˜2K˜3K˜K˜—šž
œ�œ
�œ�œ˜VKšœ	�œ
˜
Kš�œ�œ�œ
�œ
™-Kš
œ˜Kšœ�œ
˜"Kšœ�œ˜'Kšœ�œ
˜"Kšœ�œ˜'Kš
œ˜š�œ�œ
�œ�˜'Kšœ	�œ˜)Kšœ$�œ
�œ˜=š�œ�œ
�œ�˜Kšœ4�œ
�œ˜UKš�œ
˜—Kšœ �œ
�œ˜7Kš�œ
˜—Kš
œ˜Kšœ,�œ
�œ˜IKš
œ$˜$Kš
œ$˜$Kš
œ2˜2Kš
œ5˜5K˜K˜—šžœ�œ
�œ�œ$˜]Kšœ	�œ
˜
Kš�œ�œ�œ
�œ
™-Kš
œ˜Kšœ�œ
˜"Kšœ�œ˜'Kšœ�œ
˜"Kšœ�œ˜'Kš�œ�œ
�œ
˜Kš
œ˜Kš
�œ�œ
�œ�œ
�œ-˜WKš
�œ�œ
�œ�œ
�œ-˜WKš	�œ�œ�œ
�œŸ˜Jš�œ�œ
�œ�˜'Kšœ	�œ˜)Kšœ$�œ˜9š�œ�œ
�œ�˜Kšœ3�œ˜PKš�œ
˜—Kšœ �œ˜3Kš�œ
˜—Kš
œ˜Kšœ,�œ˜EKš
œ$˜$Kš
œ$˜$Kš
œ2˜2Kš
œ:˜:K˜K˜—šžœ�œ
�œc�œ3˜¹
Kšœ®
�œ&™×
K™<K™LK™EKš
œ™Kšœ�œ˜Kšœ�œ
˜$Kšœ
�œ
˜Kš
œ˜Kš
œK˜KKš
œ˜Kš
œ˜Kš
œ ˜ K˜K˜—šžœ�œc�œ˜ž
Kš
œ(˜(Kšœ�œ˜%Kšœ�œ
˜(Kš
œ˜Kš
œD˜DKš
œF˜FKš
œ?˜?Kš�œ�œ3˜QKš�œ�œ!�œ8Ÿ˜›
K˜K˜—š
žœ�œ
�œ9�œ�œ˜rKšœä
�œj™ÒKšœ�œ˜*Kšœ�œ˜/š�œ�œ�œ˜/Kš
œ+˜+Kš�œ
˜K˜Kš
 ™—Kš
œ˜Kš
œ˜Kš
œ1˜1Kš
œ#˜#š�œ�œ˜š�œ�œ
�œ�˜&Kšœ	�œ˜(Kšœ œ˜%Kš
œ!˜!š�œ�œ
�œ�˜Kš
œ5˜5Kš�œ
˜—Kš�œ
˜—Kš
 8™8š�œ �œŸ˜CKšœ$�œŸ˜Iš�œ�œ˜Kšœ$�œ
˜)Kšœ �œ
˜%Kšœ3�œ˜9Kš
œ&˜&Kš
œ*˜*Kš
œ`˜`K˜—K˜—K˜
—š�œ˜š�œ�œ
�œ�˜&Kšœ	�œ˜(Kšœ 
œ˜'Kš
œ%˜%š�œ�œ
�œ�˜Kš
œ7˜7Kš�œ
˜—Kš�œ
˜—Kš
 8™8š�œ�œŸ˜2Kšœ�œŸ˜8š�œ�œ˜Kšœ�œ
˜Kšœ�œ
˜Kšœ$�œ˜*Kš
œ&˜&Kš
œ*˜*Kš
œQ˜QK˜—K˜—K˜—K˜K˜—šž
œ�œ'�œ�œ˜_KšœØ
�œj™ÆKšœ�œ˜*Kšœ�œ˜/šœ	�œ˜Kš
œ+˜+Kš
œ%˜%Kšœ#Ÿ#˜FKš
œ˜Kš
œ)˜)Kš
œ˜Kš
œ˜—š�œ�œ
�œ�˜&Kšœ	�œ˜(Kš
œ%˜%Kš
œ!˜!š�œ�œ
�œ�˜Kšœ6Ÿ˜KKš�œ
˜—Kš�œ
˜—š�œ �œŸ˜CKšœ$�œŸ˜IKš
 “
™“
š�œ�œ˜Kšœ$�œ
˜)Kšœ3�œ˜9Kš
œ&˜&Kš
œa˜aK˜—K˜—K˜—K˜™K˜—š
ž
œ�œ
�œ�œ�œ˜;Kš�œ 
™¤
Kšœ�œ™K™Kš�œ&�œ
�œ
�œ™:Kš�œ1�œ
�œ
�œ™EK™"š�œS�œ	�œ
�™jKš�œC�œ
�œ
�œ™WK™Kš�œ
™—Kš�œ
�œ™K™!K™Kš
 ˜K˜K˜K˜—š
žœ�œ
�œ�œ�œ˜8Kš
�œ�œ
�œ�œ�œ˜[K˜K˜—š
ž
œ�œ
�œ�œ�œ˜;š�œ�œ
�œ!�˜6Kš
œ#˜#—K˜K˜—š
ž
œ�œ.�œ$�œ�œ˜�
Kšœ�œ˜*Kšœ�œ
˜š�œD�œ�œ˜gš�œ
�œ˜Kš
œ?˜?Kš�œ�œF�œ �œ
�œ
�œ
˜Ž
K˜
—š�œ˜Kš
œA˜AKš�œ�œG�œ!�œ
�œ
�œ˜’
K˜—K˜—Kš�œ
�œ˜K˜K˜—š
žœ�œ
�œ-�œ�œ˜SKš�œ�œ�œ
�œ
™3Kšœ�œ
˜Kš
œ,˜,Kš
œ1˜1Kš
œ,˜,Kš
œ1˜1Kš�œ�œ
�œ
˜K™ Kš
œ˜š�œ�œ
�œ�˜Kš
�œ�œ�œ
�œ
�œ˜;Kš�œ
˜K™—Kš
œ˜š�œ�œ
�œ�˜Kš
�œ�œ�œ
�œ
�œ˜7Kš�œ
˜—š�œ�œ
�œ�˜Kšœ	�œ˜)š�œ�œ
�œ�˜Kš
�œ�œ�œ
�œ
�œ˜KKš�œ
˜—Kš�œ
˜—Kš�œ
�œ˜K˜K˜—šž
œ�œ�œ�œ	˜DKšœ�œ˜"š�œ�œ
�œ�˜Kš�œ�œ˜0Kš�œ
˜—K˜K˜—šžœ�œ�œ�œ	˜DKšœ	�œ˜š�œ�œ
�œ�˜Kš�œ�œ˜2Kš�œ
˜—K˜K˜—šžœ�œ�œ	�œ	˜FKšœ�œ˜"š�œ�œ
�œ�˜Kšœ	�œ˜(š�œ�œ
�œ�˜Kš�œ�œ˜2Kš�œ
˜—Kš�œ
˜—K˜K˜—šžœ�œ
�œ�œ�œ�œ˜MKš�œ˜K˜K˜—š
žœ�œ
�œ�œ�œ˜DKš�œ˜K˜K˜—šžœ�œ
�œ�œ�œ�œ˜RKšœ�œu™�
š�œ�œ
�œ�˜,Kš�œ/�˜4Kšœ�˜Kš
œ�œ
Ÿœ!�œ
�œ�œ
Ÿœ˜’
—K˜K˜—šžœ�œ�œ	�œ˜<Kšœ�œ˜"Kš�œ�œ
�œ
™š�œ
Ÿœ!�œ˜Bš�œ�œ
�œ�˜Kš�œ�œ
�œ˜#š
�˜Kš
œ˜Kš�œ�œ6˜H—Kš�œ
˜—K˜
—š�œ˜š�œ�œ
�œ�˜Kš�œ
�œ"�œ�œ�œ
�œ˜YKš
�œ
�œ�œ�œ
�œ˜9š
�˜Kš
œ˜Kš�œ�œ4˜F—Kš�œ
˜—K˜—K˜K˜—š
žœ�œ
�œ�œ�œ˜;K™AKš�œ�œ
�œ˜$Kš�œ�œ
�œŸ3˜bKš�œ˜"K˜K˜—šž
œ�œ
�œ�œ�œ�œ™UK™AKš�œ�œ
�œ™$Kš�œ�œ)™EKš�œ@�œ™ZK™K™—šž
œ�œ
�œ�œ�œ�œ˜UK™AKš�œ�œ
�œ˜$Kš�œ �œ*˜QKš�œ?�œ˜XK˜K˜—šž
œ�œ
�œ�œ�œ�œ˜MKš�œ˜K˜K˜—š
ž
œ�œ
�œ�œ�œ˜=K™AKšœ�œ
˜Kš�œ�œ
�œ˜&Kš
œ%˜%š�œ�œ
�œ�œ˜4š�œ
Ÿœ"�œ˜CKš�œ�œ
�œ˜5Kš�œ
�œ#˜-K˜
—š�œ˜Kš
œ*˜*Kš�œ�œ
�œ˜/Kš�œ
�œ#˜-Kš
œ˜—K˜—K˜K˜—šžœ�œ
�œ!�œ�œ�œ˜YKš�œ�œ
�œ˜&Kš�œ
Ÿœ!�œ-˜mKš�œC�œ˜\K˜K˜—šžœ�œ
�œ$�œ˜dKš
œ ˜ š�œ�œ˜Kš
œ˜Kš
œ˜š�œ�œ˜Kšœ�œ
˜Kšœ�œ
˜K˜
—š�œ˜Kšœ�œŸœ˜GKšœ"�œ
˜'Kšœ"�œ
˜'K˜—K˜
—Kš�œ
�œ
˜K˜—K˜šžœ�œ
�œ�œ�œ
�œ˜WKšœ�œ#˜-Kšœ
�œ˜!š
�œ�œ
�œ�œ�œ
˜CKš�œ�œ
˜*—K˜K˜—šžœ�œ
�œ�œ	�œ�œ˜lKš
œ‡
™‡
Kšœ�œ˜"Kšœ	�œ˜š�œ�œ
�œ�˜š�œ�œ˜Kšœ�œ
˜Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš�œ
˜K˜
—Kš�œ
˜—š�œ�œ
�œ�˜Kš
œ'™'Kš�œ�œ
�œ+�™:š�œ�œ
�œ�˜.š�œ�œ˜!Kšœ�œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ˜Kš�œ
˜K˜
—Kš�œ
˜—Kš�œ
˜—Kš�œ
˜K˜K˜—š
žœ�œ
�œ�œ
�œ˜PKšœ�œ˜"š�œ�œ
�œ�˜š�œ�œ˜Kš
œ˜Kš�œ
˜K˜
—Kš�œ
˜—Kš�œ
˜K˜K˜—šžœ�œ
�œ#�œ�œ@�œ�œ"�œ�œ
�œ˜‹Kšœ�œ�œ
˜,Kšœ�œ˜Kšœ�œ
˜'Kšœ�œ˜"Kšœ	�œ˜˜K™—š�œ�œ
�œ�˜š�œ�œ˜Kš�œ�œ�œ�œ˜-Kš
œ
˜
Kš
œ$˜$Kšœ
�œ
˜Kš
œ˜K˜
—Kš�œ
˜—š�œ�œ
�œ�˜Kš
œ1˜1Kšœ	�œ˜(š�œ�œ
�œ�˜š�œ�œ˜!Kš�œ	�œ�œ�œ˜*Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ3˜3Kšœ
�œ
˜Kš
œ˜K˜
—Kš�œ
˜—Kš�œ
˜—Kš
�œ�œ	�œ�œ�œ˜9š�œ�œ
�œ�˜š�œ�œ˜Kš�œ
�œ�œ�œ˜+Kš
œ˜Kš
œ$˜$Kšœ�œ
˜Kš
œ˜K˜
—Kš�œ
˜—Kš�œ
�œ�œ
�œ�œ�œ�œ˜VKš�œ
�œ�œ
�œ	�œ
�œ
�œ
�œ
˜>Kšœ
�œ
˜K˜—K™K™
K™š
žœ�œ
�œ�œ'�œ˜cKš
œ˜™˜Kš�œ�œ
�œ
™š�œ�
œ˜<Kš�œ-˜1—Kš�œ0˜4K˜K˜—šžœ�œ�œ'�œ˜`Kšœ�œ�œ
˜Kš
œ˜Kšœ�œŸ˜BKšœ	�œ˜Kšœ	�œ�œ˜+Kš
œ
˜
Kš�œ�œ
�œ
˜š�œ�œ
�œ�˜Kš
œa˜aKš
œc˜cKš�œ
˜—Kš
œg˜gKš�œ�œ)�œ
�œ˜GK˜K˜—šžœ�œ�œ'�œ˜bK™¼
Kšœ
�œ˜!Kšœ�œ�œ
˜Kš
œ˜Kšœ�œ
˜Kš
œ˜Kšœ	�œ�œ˜+Kš
œ
˜
Kš�œ�œ
�œ
˜&Kš
œ"˜"Kšœ�œ
˜Kš
œ3˜3š�œ�œ$�œ�œ
˜>Kš
œa˜aKš
œc˜cKš�œ
˜—Kš�œ�œ)�œ
�œ˜GK˜—K˜šžœ�œ�œ�œ˜;Kš�œ�œ
�œ�œ˜<K˜K˜—šžœ�œ
�œ�œ˜RKš
�œ�œ
�œ
�œ
�œ˜&Kš
œ˜Kš
œ˜K˜K˜—šžœ�œ
�œ�œ˜HK™eKšœ
�œ
˜Kš
œ˜Kš
œ)˜)Kš	œ�œ�œ
�œ
�œ˜>K˜K˜—šžœ�œ�œ�œ˜LKš
œ¡™¡Kšœ�œŸ˜Cš�œ:�œ˜Bš�œ�œ
�œ�˜Kš�œ�œ
�œ˜ Kš�œ�œ
�œ˜"Kš�œ
˜—Kš�œ�œ
�œ˜4Kš�œ4˜:K˜
—š�œ˜š�œ�œ
�œ�˜Kš�œ
�œ(�œ�œ�œ
�œ˜kKš
�œ
�œ�œ�œ
�œ˜>š
�˜Kš
œ ˜ Kš�œ�œ4˜F—Kš�œ
˜—K˜—K˜K˜—šžœ�œ�œ
�œ�œ
�œ
�œ˜\Kšœ�œ
�œ˜Kšœ	�œ
�œ˜K™(Kš�œ	�œ
�œ
�œ˜"Kšœ	�œ�œ˜ Kš
œ
˜
š�œ�œ
�œ �œ�œ
�˜>Kšœ
�œ
�œ˜Kš
œ˜Kš
œ˜Kš�œ
˜—Kš
œ˜K˜K˜—šž
œ�œ�œ�œ
�œ:�œ�œ�œ	�œ�œ
�œ-�œ˜Î
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜š�œ
�œ
�˜Kš�œ�œ
�œ
˜#š�œ�œ˜Kšœ�œ
˜Kšœ�œ
�œ˜1Kšœ
�œ˜—šœ�œ
�œ˜Kšœ�œ
˜
Kš
œ!˜!KšœŸ™3Kš
œ˜Kšœ�œ
˜Kš
œ2˜2K˜—šœ�œ˜Kšœ�œ
˜Kš
œ2˜2Kš
œ˜—Kš�œ�œ
˜—K˜K˜—šžœ�œ�œ�œ
�œ:�œ�œ�œ	�œ�œ
�œ-�œ˜Ð
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜š�œ
�œ
�˜Kš�œ�œ
�œ
˜%š�œ�œ˜Kšœ�œ
˜Kšœ�œ
�œ˜1Kšœ
�œ˜—šœ�œ
�œ˜Kšœ�œ
˜
Kš
œ!˜!Kš
œ˜Kšœ�œ
˜Kš
œ.˜.Kš
œ!˜!K˜—šœ�œ˜Kšœ�œ
˜Kš
œ.˜.Kš
œ!˜!Kš
œ˜—Kš�œ�œ
˜—K˜—K˜šžœ�œ�œ˜9Kšœ	�œ!˜-š�œ�œ
�œ�˜š�œ
�œ�œ˜*Kšœ�œ
˜$Kš
œ2˜2K˜—Kš�œ
˜—K˜—K˜Kšœ�œ�œ˜)šœ�œ�œ˜ Kšœ�œ
˜
Kšœ�œ
˜
Kšœ�˜K˜K˜—šžœ�œ�œ�œ˜Qšœ	�œ˜ K˜
K˜K˜—K˜K˜—šžœ�œ�œ�œ˜?Kš�œ�œ
�œ˜#K˜K˜Kšœ �œ˜/K˜—K˜šžœ�œ
�œ�œ ˜TK™Cšœ	�œ˜$Kš
œ˜Kš
œ˜Kš
œ	˜	Kšœ�œ
˜	Kšœ
�˜K˜—˜K˜——šžœ�œ
�œ-�œ�œ�œ˜oKšœE�œ
™JK˜
š�œ�œ
�œ!�˜0Kš
œ'˜'Kš
œ!˜!Kš�œ	�œ
�œ
˜Kš�œ
˜—K˜K™—šžœ�œ
�œ=�œ�œ�œ˜ƒ
Kš
œS™SK˜
Kšœ�œ�œ
˜Kšœ�œ�œ�œ
�œ�œ˜2Kšœ
�œ˜Kšœ�œ˜š�œ�œ
�œ�˜š�œ�˜Kšœ�œ
˜!Kš
œ˜Kš�œ�œ
�œ"˜DKš�œ
˜—Kš
œ+˜+Kš
œ%˜%Kš�œ	�œ
�œ
˜Kšœ�œ
˜!Kš�œ
˜—K˜K˜—š
žœ�œ
�œ"�œ	�œ˜^šžœ�œ'�œ�œ�œ�œ˜YJ˜J˜—Kš
œ
˜
Kš
œ0˜0K˜K˜—šžœ�œ
�œ�œ˜[Kš
œ0™0Kš
œ™KšœY�œ™lKšœ�œ™*Kšœ
�œ
˜Kš
œ˜Kš�œ�œ
�œ�œ˜+Kš
œ1˜1š�œ
�œ�œŸ8˜Yš�œ�˜#Kšœ"�œ
˜/Kš
œ$˜$Kš�œ�œ
�œ"˜KKš�œ
˜—K˜—KšœB�œ
™GKš
œ&™&Kš
œ>˜>Kš
œ˜Kšœ"�œ
˜/Kš
œ$˜$Kš
œ˜K˜K˜—šžœ�œ
�œ"�œ˜gKš
œJ™Jš�œ�œ
�
˜Kš
œ˜Kš�œ
˜K˜—šœ	�œ˜$Kšœ�œ�œ
�œ
�œ
�œ˜$Kš	œ�œ�œ
�œ�œ˜*Kš
œ	˜	Kšœ
Ÿ:˜DKšœ
�˜Kš
œ˜—K˜K˜—šžœ�œ
�œ"�œ˜nKš
œ‡™‡Kš�œ�œ
�œŸ'™CKš�œ�œ
�œ
™Kš�œ�œ
�œ˜5šœ	�œ˜$Kš
œ˜Kš
œ˜Kšœ�œ�œ�œŸ˜PKšœ
Ÿ+˜5Kšœ
�˜Kš
œ˜—K˜K˜—šžœ�œ
�œ�œ˜OKš
œ0™0š
œ™KšœY�œ™lKšœ�œ™*—Kšœ
�œ
˜Kš
œ˜Kš�œ�œ
�œ
�œ˜$Kš
œ1˜1Kš
œS™Sš�œ
�œ�œŸ8˜Yš�œ�˜#Kšœ"�œ
˜/Kš
œ$˜$Kš�œ�œ
�œ"˜KKš�œ
˜—˜KšœB�œ
™GKš
œ&™&——Kš
œ:˜:Kšœ"�œ
˜/Kš
œ$˜$Kš
œ˜K˜K˜—šžœ�œ
�œ"�œ#˜pKš
œJ™JKš�œ�œ
�œ'™Dšœ�œ˜(Kš
œ˜Kš
œ	˜	Kš	œ�œ�œ
�œ�œ˜3Kš
œ˜K˜
Kš
œ˜—K˜K˜—šžœ�œ
�œ>˜fKšœ�œ˜$K˜
Kšœ�œ�œ
˜š�œ�œ
�œ�˜š�œ�œ
�œ�˜.š�œ�œ˜!Kš
œ'˜'Kš
œ3˜3Kš�œ�œ
�œ
˜K˜—Kš�œ
˜—Kš�œ
˜—K˜K˜—šžœ�œ
�œ �œ˜]š
�œ�œ
�œ	�œ�œ˜3Kš
œ!˜!K˜
Kšœ
�œ˜Kšœ	�œ˜Kšœ�œ˜(š�œ�œ
�œ�˜&š�œ�œ
�œ+�˜:š�œ�œ˜'Kš
œ
˜
Kš
œ˜Kš�œ˜K˜—Kš�œ
˜—Kš
œ˜š
�˜˜
Kš
œ4˜4Kš
œ5˜5Kšœ�œ
˜K˜—Kš�œ�œ
˜—Kš�œ
˜—Kš
œ˜Kš
œ˜Kš
œ˜K˜—K˜K˜—šžœ�œ
�œ �œ�œ�œ˜kš
�œ�œ
�œ�œ�œ˜0Kš
œ˜Kšœ
�œ˜Kšœ	�œ˜Kšœ�œ˜"š�œ�œ
�œ�˜&š�œ�œ
�œ%�˜4š�œ�œ˜!Kš
œ
˜
Kš
œ˜Kš�œ˜K˜—Kš�œ
˜—Kš
œ˜š
�˜˜
Kš
œ˜Kš
œ˜Kšœ�œ
˜
K˜—Kš�œ�œ
˜—Kš�œ
˜—Kš
œ˜Kš
œ˜Kš
œ˜K˜—K˜K˜—šžœ�œ
�œ�œ˜UKš
œX™XKš�œ�œ
�œŸ;™Zšœ�œŸ"˜GKšœ�œŸ˜!Kš	œ�œ�œ
�œ�œ˜,K˜	Kš
œ	˜	Kšœ
�œ
Ÿ˜'K˜—K˜K˜—šžœ�œ
�œ>˜gKš
œN™NK˜Kšœ�œ�œ
˜Kšœ�œ�œ�œ
�œ�œ˜4Kšœ	�œ˜Kšœ�œ˜š�œ�œ
�œ�˜š�œ�œ�˜-Kš
œ˜Kš�œ
˜—Kš�œ�œ
�œ
˜Kš
œ1˜1Kš
œ'˜'Kš�œ�œ
�œ
˜Kš
œ˜Kš�œ
˜—K˜K˜—šžœ�œ
�œ>˜_Kš
œN™NK˜Kšœ�œ�œ
˜Kšœ�œ�œ�œ
�œ�œ˜4Kšœ	�œ˜Kšœ�œ˜š�œ�œ
�œ�˜š�œ�œ�˜-Kš
œ˜Kš�œ
˜—Kš�œ�œ
�œ
˜Kš
œ1˜1Kš
œ˜Kš�œ�œ
�œ
˜Kš
œ˜Kš�œ
˜—K˜K˜—šžœ�œ
�œ�œ˜Qšœ�œ˜$Kšœ�œŸ˜!Kš
œ#˜#K˜	Kšœ�œ
˜	Kšœ
�˜K˜—Kš
œ˜K˜—š
ž	œ�œ
�œ�œ�œ˜IKš
œ˜Kšœ�œ˜Kš�œ�œ
�œ˜%š�œ�œ˜Kš
œ
˜
K˜
—š�œ˜Kšœ	�œ!™-Kšœ	�œ˜š�œ�œ�˜-Kš
œ˜Kš�œ
˜—Kš�œ�œ
�œ
˜Kš
œ
˜
K˜—Kš
œ˜Kš
œ"˜"K˜—K˜Kš�œ
˜—…—³VA²