DIRECTORY
AtomButtonsTypes, CodeTimer, ColorTool, Feedback, FS, GGBasicTypes, GGModelTypes, GGUtility, Imager, ImagerColor, ImagerColorMap, ImagerColorPrivate, ImagerDitherContext, ImagerTransformation, Interpress, IO, --IPMaster,-- Real, Rope, Terminal, ViewerClasses, ViewerOps;

GGUtilityImpl: CEDAR PROGRAM
IMPORTS CodeTimer, ColorTool, Feedback, FS, Imager, ImagerColor, ImagerColorMap, ImagerColorPrivate, ImagerDitherContext, Interpress, IO, --IPMaster, --Real, Rope, Terminal, ViewerOps
EXPORTS GGUtility = BEGIN

ROPE: TYPE = Rope.ROPE;
BitVector: TYPE = GGBasicTypes.BitVector;
FeatureData: TYPE = GGModelTypes.FeatureData;
FeedbackData: TYPE = AtomButtonsTypes.FeedbackData;
Outline: TYPE = GGModelTypes.Outline;
Sequence: TYPE = GGModelTypes.Sequence;
SequenceOfReal: TYPE = GGBasicTypes.SequenceOfReal;
SequenceOfRealObj: TYPE = GGBasicTypes.SequenceOfRealObj;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
Traj: TYPE = GGModelTypes.Traj;
Viewer: TYPE = ViewerClasses.Viewer;

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


StartFeatureDataList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF FeatureData] = {
ptr _ entityList _ NIL;
};

AddFeatureData: PUBLIC PROC [entity: FeatureData, entityList, ptr: LIST OF FeatureData] RETURNS [newList, newPtr: LIST OF FeatureData] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};


DeleteSequenceFromList: PUBLIC PROC [seq: Sequence, seqList: LIST OF Sequence] RETURNS [smallerList: LIST OF Sequence] = {
beforeEnt, ent, afterEnt: LIST OF Sequence;
found: BOOL _ FALSE;
[beforeEnt, ent, afterEnt, found] _ FindSequenceAndNeighbors[seq, seqList];
IF NOT found THEN RETURN[seqList];
IF beforeEnt = NIL THEN smallerList _ afterEnt
ELSE {
beforeEnt.rest _ afterEnt;
smallerList _ seqList;
};
}; -- end of DeleteSequenceFromList

FindSequenceAndNeighbors: PROC [entity: Sequence, entityList: LIST OF Sequence] RETURNS [beforeEnt, ent, afterEnt: LIST OF Sequence, found: BOOL _ FALSE] = {
lastE: LIST OF Sequence _ NIL;
eList: LIST OF Sequence _ entityList;
IF eList = NIL THEN ERROR EntityNotFound;
UNTIL eList = NIL DO
IF eList.first = entity THEN {
beforeEnt _ lastE;
ent _ eList;
afterEnt _ eList.rest;
found _ TRUE;
RETURN;
};
lastE _ eList;
eList _ eList.rest;
ENDLOOP;
};

AppendSequenceList: PUBLIC PROC [list1, list2: LIST OF Sequence] RETURNS [result: LIST OF Sequence] = {
pos: LIST OF Sequence;
newCell: LIST OF Sequence;
IF list1 = NIL THEN RETURN[list2];
result _ CONS[list1.first, NIL];
pos _ result;
FOR l: LIST OF Sequence _ list1.rest, l.rest UNTIL l = NIL DO
newCell _ CONS[l.first, NIL];
pos.rest _ newCell;
pos _ newCell;
ENDLOOP;
pos.rest  _ list2;
}; -- end of AppendSequenceList

StartSequenceList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF Sequence] = {
ptr _ entityList _ NIL;
};

AddSequence: PUBLIC PROC [entity: Sequence, entityList, ptr: LIST OF Sequence] RETURNS [newList, newPtr: LIST OF Sequence] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};


StartSliceDescriptorList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF SliceDescriptor] = {
ptr _ entityList _ NIL;
};

AddSliceDescriptor: PUBLIC PROC [entity: SliceDescriptor, entityList, ptr: LIST OF SliceDescriptor] RETURNS [newList, newPtr: LIST OF SliceDescriptor] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};
DeleteSliceDescriptorFromList: PUBLIC PROC [sliceD: SliceDescriptor, sliceDList: LIST OF SliceDescriptor] RETURNS [smallerList: LIST OF SliceDescriptor] = {
beforeEnt, ent, afterEnt: LIST OF SliceDescriptor;
found: BOOL _ FALSE;
[beforeEnt, ent, afterEnt, found] _ FindSliceDescriptorAndNeighbors[sliceD, sliceDList];
IF NOT found THEN RETURN[sliceDList];
IF beforeEnt = NIL THEN smallerList _ afterEnt
ELSE {
beforeEnt.rest _ afterEnt;
smallerList _ sliceDList;
};
};


FindSliceDescriptorAndNeighbors: PROC [sliceD: SliceDescriptor, sliceDList: LIST OF SliceDescriptor] RETURNS [beforeEnt, ent, afterEnt: LIST OF SliceDescriptor, found: BOOL _ FALSE] = {
lastE: LIST OF SliceDescriptor _ NIL;
eList: LIST OF SliceDescriptor _ sliceDList;
IF eList = NIL THEN ERROR EntityNotFound;
UNTIL eList = NIL DO
IF eList.first = sliceD THEN {
beforeEnt _ lastE;
ent _ eList;
afterEnt _ eList.rest;
found _ TRUE;
RETURN;
};
lastE _ eList;
eList _ eList.rest;
ENDLOOP;
};

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

StartList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF REF ANY] = {
ptr _ entityList _ NIL;
};

AddEntity: PUBLIC PROC [entity: REF ANY, entityList, ptr: LIST OF REF ANY] RETURNS [newList, newPtr: LIST OF REF ANY] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};

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

StartNATList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF NAT] = {
ptr _ entityList _ NIL;
};

StartTrajList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF Traj] = {
ptr _ entityList _ NIL;
};

StartSDList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF SliceDescriptor] = {
ptr _ entityList _ NIL;
};

StartOutlineList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF Outline] = {
ptr _ entityList _ NIL;
};

StartSliceList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF Slice] = {
ptr _ entityList _ NIL;
};

AddOutline: PUBLIC PROC [entity: Outline, entityList, ptr: LIST OF Outline] RETURNS [newList, newPtr: LIST OF Outline] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};

AddSlice: PUBLIC PROC [entity: Slice, entityList, ptr: LIST OF Slice] RETURNS [newList, newPtr: LIST OF Slice] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};

AddNAT: PUBLIC PROC [entity: NAT, entityList, ptr: LIST OF NAT] RETURNS [newList, newPtr: LIST OF NAT] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};

AddTraj: PUBLIC PROC [entity: Traj, entityList, ptr: LIST OF Traj] RETURNS [newList, newPtr: LIST OF Traj] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};

AddSD: PUBLIC PROC [entity: SliceDescriptor, entityList, ptr: LIST OF SliceDescriptor] RETURNS [newList, newPtr: LIST OF SliceDescriptor] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};

BreakIntervalMOD: PUBLIC PROC [start, end, mod: NAT] RETURNS [s1, e1, s2, e2: INT] = {
IF start >= mod OR end >= mod THEN ERROR;
IF start <= end THEN RETURN[start, end, -1, -1];
RETURN[0, end, start, mod-1];
};

BreakIntervalMODLen: PUBLIC PROC [start, len, mod: NAT] RETURNS [s1, len1, s2, len2: INT] = {
IF start >= mod OR len > mod + 1 THEN ERROR;
IF start + len -1 < mod THEN RETURN[start, len, -1, -1];
RETURN[0, start+len-mod, start, mod-start];
};

InMODRegion: PUBLIC PROC [test: NAT, start, end, mod: NAT] RETURNS [BOOL] =  {
IF start = end THEN RETURN [test = start];
IF start < end THEN RETURN [test IN [start..end]];
RETURN [test IN [start..mod) OR test IN [0..end]];
};

AllFalse: PUBLIC PROC [bitvec: BitVector] RETURNS [BOOL] = {
FOR i: NAT IN [0..bitvec.len) DO
IF bitvec[i] = TRUE THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

AllTrue: PUBLIC PROC [bitvec: BitVector] RETURNS [BOOL] = {
FOR i: NAT IN [0..bitvec.len) DO
IF bitvec[i] = FALSE THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

GetGenericFileName: PROC [fileName, wDir, defaultExt: Rope.ROPE, illegalExts: LIST OF Rope.ROPE, feedback: FeedbackData, emergency: BOOL _ FALSE] RETURNS [fullName: Rope.ROPE _ NIL, success: BOOL _ TRUE, versionSpecified: BOOL _ FALSE] = {
cp: FS.ComponentPositions;
extRope: Rope.ROPE;
versionSpecified _ Rope.SkipTo[s: fileName, skip: "!"]#Rope.Length[fileName];
IF Rope.Length[fileName]=0 OR Rope.Equal[fileName, ""] THEN {
IF NOT emergency THEN {
Feedback.PutF[feedback, oneLiner, "No filename specified"];
Feedback.Blink[feedback];
};
RETURN[NIL, FALSE];
};
[fullName, cp, ] _ FS.ExpandName[fileName, wDir ! FS.Error => {
success _ FALSE;
IF NOT emergency THEN {
Feedback.PutF[feedback, oneLiner, "FS Error during name expansion of %g", [rope[fileName]]];
Feedback.Blink[feedback];
};
CONTINUE;
}
];
IF NOT success THEN RETURN;
extRope _ Rope.Substr[base: fullName, start: cp.ext.start, len: cp.ext.length];
FOR ropeList: LIST OF Rope.ROPE _ illegalExts, ropeList.rest UNTIL ropeList=NIL DO
IF Rope.Equal[ropeList.first, extRope, FALSE] THEN {
IF NOT emergency THEN {
Feedback.PutF[feedback, oneLiner, "%g extension for %g files not allowed", [rope[extRope]], [rope[defaultExt]] ];
Feedback.Blink[feedback];
};
success _ FALSE;  RETURN;
};
ENDLOOP;
IF cp.ext.length=0 THEN fullName _ Rope.Cat[fullName, ".", defaultExt];
};

GetGargoyleFileName: PUBLIC PROC [ggName: Rope.ROPE, currentWDir: Rope.ROPE, feedback: FeedbackData, emergency: BOOL _ FALSE] RETURNS [fullName: Rope.ROPE _ NIL, success: BOOL _ TRUE, versionSpecified: BOOL _ FALSE] = {
[fullName, success, versionSpecified] _ GetGenericFileName[ggName, currentWDir, "gargoyle", LIST["IP", "interpress", "script", "mesa", "tioga"], feedback, emergency];
};

GetInterpressFileName: PUBLIC PROC [ipName: Rope.ROPE, currentWDir: Rope.ROPE, feedback: FeedbackData] RETURNS [fullName: Rope.ROPE _ NIL, success: BOOL _ TRUE] = {
[fullName, success, ----] _ GetGenericFileName[ipName, currentWDir, "IP", LIST["gargoyle", "script", "mesa", "tioga"], feedback];
};

GetScriptFileName: PUBLIC PROC [scriptName: Rope.ROPE, currentWDir: Rope.ROPE, feedback: FeedbackData] RETURNS [fullName: Rope.ROPE _ NIL, success: BOOL _ TRUE] = {
[fullName, success, ----] _ GetGenericFileName[scriptName, currentWDir, "script", LIST["gargoyle", "IP", "interpress", "mesa", "tioga"], feedback];
};

OpenInterpressOrComplain: PUBLIC PROC [feedback: FeedbackData, fullName: Rope.ROPE] RETURNS [ipMaster: Interpress.Master, success: BOOL] = {
LogIt: Interpress.LogProc = {
Feedback.Append[feedback, explanation, oneLiner];
};

success _ TRUE;
ipMaster _ Interpress.Open[fileName: fullName, log: LogIt !
FS.Error => {
Feedback.Append[feedback, error.explanation, oneLiner];
GOTO Quit; 
};
Imager.Error => { --ErrorDesc: TYPE = RECORD [code: ATOM, explanation: ROPE]
Feedback.Append[feedback, Rope.Cat[error.explanation, " for ", fullName], oneLiner];
GOTO Quit;
};
IO.Error, IO.EndOfStream => {
Feedback.Append[feedback, Rope.Cat["IO Stream Error for ", fullName], oneLiner];
GOTO Quit;
};
];
IF ipMaster.pages=0 THEN {
Feedback.Append[feedback, Rope.Concat["Zero pages in ", fullName], oneLiner];
GOTO Quit;
};
EXITS
Quit => {
Feedback.Blink[feedback];
success _ FALSE;
};
};

CopyPattern: PUBLIC PROC [pattern: SequenceOfReal] RETURNS [new: SequenceOfReal] = {
IF pattern=NIL THEN RETURN[NIL];
new _ NEW[SequenceOfRealObj[pattern.len]];
FOR index: NAT IN [0..pattern.len) DO
new[index] _ pattern[index];
ENDLOOP;
};

ExtractRGB: PUBLIC PROC [color: Imager.Color] RETURNS [r,g,b: REAL] = {
rgb: ImagerColor.RGB;
rgb _  ImagerColorPrivate.RGBFromColor[NARROW[color]];
r _ rgb.R;  g _ rgb.G;  b _ rgb.B;
};

EquivalentColors: PUBLIC PROC [color1, color2: Imager.Color] RETURNS [BOOL] = {
r1, g1, b1, r2, g2, b2: REAL;
epsilon: REAL _ 1.0E-2;
IF color1=color2 THEN RETURN[TRUE];
[r1, g1, b1] _ ExtractRGB[color1];
[r2, g2, b2] _ ExtractRGB[color2];
RETURN[(r1=r2 AND g1=g2 AND b1=b2) OR (ABS[r1-r2]<epsilon AND ABS[g1-g2]<epsilon AND ABS[b1-b2]<epsilon ) ];
};

GetSpecialColor: PUBLIC PROC RETURNS [color: Imager.Color] = {
zeroByte: Terminal.ColorValue = 0;
channel: Terminal.ChannelValue _ 102;
mapEntry: REF ImagerColorMap.MapEntry;
tool: ViewerClasses.Viewer _ ViewerOps.FindViewer["ColorTool"];
IF tool=NIL THEN RETURN[NIL];
mapEntry _ NEW[ImagerColorMap.MapEntry _ [channel, zeroByte, zeroByte, zeroByte] ];
color _ ImagerDitherContext.MakeSpecialColor[ specialPixel: [value: mapEntry.mapIndex, dstFunc: null], ordinaryColor: ImagerColor.ColorFromRGB[ColorTool.GetRGBValue[tool]]];
ColorTool.RegisterNotifyProc[$GG, TrackPatch, mapEntry, tool];
};

TrackPatch: PROC[rgb: ImagerColor.RGB, clientData: REF] = { -- ColorTool.NotifyProc
ToByte: PROC[v: REAL] RETURNS[Terminal.ColorValue] = { RETURN[Real.Round[v*255]] };
mapEntry: REF ImagerColorMap.MapEntry _ NARROW[clientData];
mapEntry.red _ ToByte[rgb.R];
mapEntry.green _ ToByte[rgb.G];
mapEntry.blue _ ToByte[rgb.B];
ImagerColorMap.LoadEntries[vt: Terminal.Current[],
mapEntries: LIST[mapEntry^], shared: FALSE];
};

BoolToRope: PUBLIC PROC [bool: BOOL] RETURNS [rope: Rope.ROPE] = {
rope _ IF bool THEN "T" ELSE "F";
};

RopeToBool: PUBLIC PROC [rope: Rope.ROPE] RETURNS [bool: BOOL] = {
SELECT TRUE FROM
Rope.Equal[rope, "F", FALSE] => bool _ FALSE;
Rope.Equal[rope, "T", FALSE] => bool _ TRUE;
ENDCASE => ERROR;
};
Init: PROC [] = {
[] _ CodeTimer.CreateTable[$Gargoyle];
};

Init[];
END.
	:GGUtilityImpl.mesa
Last edited by Bier on April 9, 1987 11:33:45 pm PDT.
Pier, May 12, 1987 4:12:40 pm PDT
Contents:  General Purpose routines for use by Gargoyle.
Templates for List Operations


Destructive Delete
Delete
TypeFromList: PUBLIC PROC [entity: 
Type, entityList: LIST OF 
Type] RETURNS [smallerList: LIST OF 
Type] = {
beforeEnt, ent, afterEnt: LIST OF 
Type;
notFound: BOOL _ FALSE;
[beforeEnt, ent, afterEnt] _ Find
TypeAndNeighbors[entity, entityList];
IF notFound THEN RETURN[entityList];
IF beforeEnt = NIL THEN smallerList _ afterEnt
ELSE {
beforeEnt.rest _ afterEnt;
smallerList _ entityList;
};
}; -- end of Delete
TypeFromList
Find
TypeAndNeighbors: PROC [entity: 
Type, entityList: LIST OF 
Type] RETURNS [beforeEnt, ent, afterEnt: LIST OF 
Type] = {
lastE: LIST OF 
Type _ NIL;
eList: LIST OF 
Type  _ entityList;
IF eList = NIL THEN SIGNAL Problem[msg: "
msg"];
UNTIL eList = NIL DO
IF eList.first = entity THEN {
beforeEnt _ lastE; ent _ eList; afterEnt _ eList.rest; RETURN};
lastE _ eList;
eList _ eList.rest;
ENDLOOP;
SIGNAL Problem[msg: "
msg"];
};
Operations on LIST OF FeatureData

Operations on LIST OF Sequence
Non-destructive (copies the first list).
Operations on LIST OF SliceDescriptor
Non-destructive (copies the first list).
Operations on LIST OF REF ANY

Two Finger List Constructor

Operations on Assorted LIST Types

Non-destructive (copies the first list).

Two Finger List Construction
Start
TypeList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF 
Type] = {
ptr _ entityList _ NIL;
};
Add
Type: PUBLIC PROC [entity: 
Type, entityList, ptr: LIST OF 
Type] RETURNS [newList, newPtr: LIST OF 
Type] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};
Modular Arithmetic

Example: BreakIntervalMODLen[6, 4, 7] => [0, 3, 6, 1].
BreakIntervalMODLen[2, 5, 7] => [2, 5, -1, -1].
BreakIntervalMODLen[6, 8, 7] => [0, 7, 6, 1]. -- repeats 6 twice
Operations on Bit Vectors

File Names

IPMaster.Error => { --ErrorDesc: TYPE = RECORD[code: ATOM, explanation: ROPE]
Feedback.Append[feedback, Rope.Cat[error.explanation, " for ", fullName], oneLiner];
GOTO Quit;
};
Conversions
Returns "T" or "F".
Takes "T" or "F".  Raises an Error if rope is anything else.

�Êј
code™Kš
œ5™5Kš
œ!™!KšÏnœ0™8—š
Ïk	˜	Jšœ2žœ™
žœ?˜Ž—K˜š�
œžœ
ž˜Jšžœ!žœ\žœ/˜·
Kšžœ
ž˜—˜Kšžœžœžœ
˜Kšœžœ˜)Kšœ
žœ˜-Jšœžœ!˜3Kšœ	žœ˜%Kšœ
žœ˜'Kšœžœ˜3Kšœžœ"˜9Kšœžœ˜!Kšœžœ ˜5Kšœžœ˜Kšœžœ˜$—K˜Kš
�œžœ
žœžœžœ
˜/Kš�œžœ
žœžœ
˜%K˜Kš
œ™™K™—Kš
Ïb™šŸœ�œžœ
žœžœ
žœ	žœžœ
žœ™xKšœžœ
žœ™)Kšœ
žœžœ
™Kš
œH™HKšžœ
žœ
žœ
™$Kšžœ
žœ
žœ™.šžœ™Kš
œ™Kš
œ™K™—KšœÏc™!—šœ
�œžœžœ
žœ	žœžœ
žœ™€
Kšœžœ
žœ
žœ
™Kšœžœ
žœ™$Kšžœ	žœ
žœ
žœ™1šžœ	žœ
ž™Kšžœžœ™Kšœ7žœ™?Kš
œ™Kš
œ™—Kšžœ
™Kšžœ™Kš
œ™—K˜Kšœžœ
žœ™!K™š�œžœ
žœžœžœ
žœ˜WKšœžœ
˜K˜K˜—š�œžœ
žœ(žœ
žœžœžœ
žœ˜Š
šžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜K˜—Kšœžœ
žœ	™K˜š�œžœ
žœžœ
žœžœžœ
žœ˜zKšœžœ
žœ
˜+Kšœžœžœ
˜Kš
œK˜KKšžœ
žœžœ
žœ
˜"Kšžœ
žœ
žœ˜.šžœ˜Kš
œ˜Kš
œ˜K˜—Kšœ  ˜#K˜—š�œžœ žœ
žœžœžœ
žœžœžœ˜�
Kšœžœ
žœžœ
˜Kšœžœ
žœ˜%Kšžœ	žœ
žœ
žœ˜)šžœ	žœ
ž˜šžœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ
˜
Kšžœ
˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kšžœ
˜Kš
œ˜K˜—š�œžœ
žœžœ
žœžœ
žœ
žœ˜gKšœžœ
žœ
˜Kšœ	žœ
žœ
˜K™(Kšžœ	žœ
žœ
žœ˜"Kšœ	žœžœ˜ Kš
œ
˜
šžœžœ
žœžœžœ
ž˜=Kšœ
žœ
žœ˜Kš
œ˜Kš
œ˜—Kšžœ
˜Kš
œ˜Kšœ ˜K˜—š�œžœ
žœžœžœ
žœ˜QKšœžœ
˜K˜K˜—š�œžœ
žœ%žœ
žœžœžœ
žœ˜~šžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜—K˜Kšœžœ
žœ™%K˜š�œžœ
žœžœžœ
žœ˜_Kšœžœ
˜K˜K˜—š�œžœ
žœ,žœ
žœžœžœ
žœ˜š
šžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜—š�œžœ
žœ'žœ
žœžœžœ
žœ˜œ
Kšœžœ
žœ˜2Kšœžœžœ
˜Kš
œX˜XKšžœ
žœžœ
žœ
˜%Kšžœ
žœ
žœ˜.šžœ˜Kš
œ˜Kš
œ˜K˜—Kš
œ˜K˜K˜—š�œžœ'žœ
žœžœžœ
žœžœžœ˜¹
Kšœžœ
žœžœ
˜%Kšœžœ
žœ˜,Kšžœ	žœ
žœ
žœ˜)šžœ	žœ
ž˜šžœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ
˜
Kšžœ
˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kšžœ
˜Kš
œ˜K˜—š�œžœ
žœžœ
žœžœ
žœ
žœ˜|Kšœžœ
žœ˜Kšœ	žœ
žœ˜!K™(Kšžœ	žœ
žœ
žœ˜"Kšœ	žœžœ˜ Kš
œ
˜
šžœžœ
žœ&žœžœ
ž˜DKšœ
žœ
žœ˜Kš
œ˜Kš
œ˜—Kšžœ
˜Kš
œ˜Kš
œ˜—K˜Kšœžœ
žœ
žœ
ž™K™Kš
Ÿ™š�	œžœ
žœžœžœ
žœ
žœ
žœ˜HKšœžœ
˜K˜K˜—š�	œžœ
žœ
žœ
žœžœ
žœ
žœ
žœžœžœ
žœ
žœ
žœ˜yšžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜K˜—K™Kšœžœ™!K™š�
œžœ
žœžœ
žœ
žœžœ
žœ
žœ
žœ˜UKšœžœ
žœ
žœ
˜Kšœ	žœ
žœ
žœ
˜K™(Kšžœ	žœ
žœ
žœ˜"Kšœ	žœžœ˜ Kš
œ
˜
š
žœžœ
žœ
žœžœžœ
ž˜8Kšœ
žœ
žœ˜Kš
œ˜Kš
œ˜—Kšžœ
˜Kš
œ˜Kš
œ˜K˜—š�œžœ
žœžœžœ
žœ
žœ˜GKšœžœ
˜K˜K˜—š�
œžœ
žœžœžœ
žœ
˜IKšœžœ
˜K˜K˜—š�œžœ
žœžœžœ
žœ˜RKšœžœ
˜K˜K˜—š�œžœ
žœžœžœ
žœ
˜OKšœžœ
˜K˜K˜—š�œžœ
žœžœžœ
žœ˜KKšœžœ
˜K˜—K™Kš
Ÿ™š
œ�œžœ
žœžœžœ
žœ™MKšœžœ
™K™—šœžœ
žœ#žœ
žœ	žœžœ
žœ™všžœžœ
žœ™Kš
žœ
žœžœ
žœ
žœ
™#Kšœžœ	žœ™%Kšžœ
™K™
—šžœ™Kš
œ™Kšœžœ	žœ™Kš
œ™K™—K™—K˜š�
œžœ
žœ$žœ
žœ
žœžœ
žœ
˜zšžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜K˜—š�œžœ
žœ"žœ
žœžœžœ
žœ˜ršžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜K˜—š�œžœ
žœ
žœžœ
žœ
žœžœžœ
žœ
žœ˜jšžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜K˜—š�œžœ
žœ!žœ
žœžœžœ
žœ
˜nšžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜K˜—š�œžœ
žœ,žœ
žœžœžœ
žœ˜�
šžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜—K˜Kš
œ™K™š�œžœ
žœžœžœžœ˜VKšžœžœžœ
žœ
˜)Kšžœžœ
žœ˜0Kšžœ˜K˜K˜—š�œžœ
žœžœžœžœ˜]Kš�œ/™6Kš
œ/™/Kšœ. ™@Kšžœžœžœ
žœ
˜,Kšžœžœ
žœ˜8Kšžœ%˜+K˜K˜—š�œžœ
žœžœžœžœžœ˜NKšžœ
žœ
žœ˜*Kšžœ
žœ
žœžœ˜2Kšžœžœžœžœ˜2Kš
œ˜—K˜š
œ™K™—š
�œžœ
žœžœžœ˜<šžœžœ
žœž˜ Jš
žœ
žœ
žœ
žœ
žœ˜'—Jšžœ
˜Jšžœ
žœ˜
K˜K˜—š
�œžœ
žœžœžœ˜;šžœžœ
žœž˜ Jš
žœ
žœ
žœ
žœ
žœ˜(—Jšžœ
˜Jšžœ
žœ˜
K˜—K˜™
K™—š�œžœ#žœžœ
žœžœ%žœžœžœžœžœžœžœžœžœ˜ï
Kšœžœ˜Kšœžœ
˜Kš
œM˜Mšžœžœžœ˜=•StartOfExpansionÒ
[gargoyleData: 
REF ANY, msgType: 
GGError.MsgType, format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]šžœ
žœžœ˜Kš
œ;˜;Kš
œ˜K˜—Kšžœ
žœžœ˜Kš
œ˜—šœžœžœ˜?Kšœ
žœ
˜–Ò
[gargoyleData: 
REF ANY, msgType: 
GGError.MsgType, format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]šžœ
žœžœ˜Kš
œ\˜\Kš
œ˜K˜—Kšžœ
˜	K˜
Kš
œ˜—Kšžœ
žœ	žœ
žœ
˜K–9[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]š
œO˜Oš
žœžœ
žœžœžœ
žœ
ž˜Ršžœ%žœžœ˜4šžœ
žœžœ˜Kš
œq˜qKš
œ˜K˜—Kšœ
žœžœ
˜K˜—Kšžœ
˜—Kšžœžœ0˜GK˜K˜—š�œžœ
žœžœžœ%žœžœžœžœžœžœžœžœžœ˜Û
Kšœ\žœF˜¦
K˜K˜—š�œžœ
žœžœžœžœžœžœžœžœ˜¤
Kšœ œ2žœ3˜�
K˜K˜—š�œžœ
žœžœžœžœžœžœžœžœ˜¤
Kšœ œ:žœ=˜“
K˜K˜—š�œžœ
žœ)žœžœ(žœ˜Œ
š�œ˜Kš
œ1˜1K˜—K˜Kšœ
žœ
˜š
œ;˜;šžœ˜
Kš
œ7˜7Kšžœ˜Kš
œ˜—šœ 9™MKš
œT™TKšžœ™
Kš
œ™—šœ :˜LKš
œT˜TKšžœ˜
Kš
œ˜—šžœžœ˜Kš
œP˜PKšžœ˜
Kš
œ˜—Kš
œ˜—šžœžœ˜Kš
œM˜MKšžœ˜
Kš
œ˜—š
ž˜š
œ	˜	Kš
œ˜Kšœ
žœ
˜K˜——K˜—K˜š�œžœžœ˜TKš
žœ	žœ
žœ
žœ
žœ˜ Kšœžœ!˜*šžœžœ
žœž˜%Kš
œ˜Kšžœ
˜—Kš
œ˜K˜—
procš
�
œžœ
žœžœ	žœ˜GLšœžœ
˜Lšœ'žœ	˜6Lš
œ"˜"L˜L˜—š
�œžœ
žœ žœžœ˜OKšœžœ
˜Kšœ	žœ
˜Kšžœžœ
žœ
žœ˜#Kš
œ"˜"Kš
œ"˜"Kšžœžœžœžœžœžœ
žœžœ
žœ˜lL˜L˜—š�œžœ
žœ˜>Lš
œ"˜"Lš
œ%˜%Lšœ
žœ˜&Lš
œ?˜?Kš
žœžœ
žœ
žœ
žœ˜Lšœ
žœE˜SLš
œ­
˜­
Lš
œ>˜>L˜K˜—š	�
œžœžœžœ ˜SKš
�œžœžœžœžœ˜SKšœ
žœžœ
˜;Kš
œ˜Kš
œ˜Kš
œ˜š
œ2˜2Kšœžœžœ˜,—Lš
œ˜—L˜K™š�
œžœ
žœžœžœ
žœ˜BL™Lšœžœžœžœ˜!L˜L˜—š�
œžœ
žœ
žœžœžœ˜BL™<šžœ
žœ
ž˜Lšœžœžœ
˜-Lšœžœžœ
˜,Lšžœžœ
˜—L˜—K™š�œžœ˜K˜&K˜K˜—Kš
œ˜Kšžœ
˜—…—8H\S