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; }; }; 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] 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 1, 1987 3:04:41 pm PDT Contents: General Purpose routines for use by Gargoyle. Templates for List Operations Destructive Delete DeleteTypeFromList: 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] _ FindTypeAndNeighbors[entity, entityList]; IF notFound THEN RETURN[entityList]; IF beforeEnt = NIL THEN smallerList _ afterEnt ELSE { beforeEnt.rest _ afterEnt; smallerList _ entityList; }; }; -- end of DeleteTypeFromList FindTypeAndNeighbors: 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 REF ANY Two Finger List Constructor Operations on Assorted LIST Types Non-destructive (copies the first list). Two Finger List Construction StartTypeList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF Type] = { ptr _ entityList _ NIL; }; AddType: 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šŸ™š œžœžœžœžœžœžœžœ˜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šžœ˜—…—0üQ¬