DIRECTORY
FS, GGBasicTypes, GGError, GGModelTypes, GGUtility, Imager, ImagerTransformation, Interpress, IO, IPMaster, Rope, ViewerClasses;

GGUtilityImpl: CEDAR PROGRAM
IMPORTS GGError, FS, Imager, Interpress, IO, IPMaster, Rope
EXPORTS GGUtility = BEGIN

ROPE: TYPE = Rope.ROPE;
BitVector: TYPE = GGBasicTypes.BitVector;
FeatureData: TYPE = GGModelTypes.FeatureData;
Outline: TYPE = GGModelTypes.Outline;
Sequence: TYPE = GGModelTypes.Sequence;
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;
notFound: BOOL _ FALSE;
[beforeEnt, ent, afterEnt] _ FindSequenceAndNeighbors[seq, seqList];
IF notFound 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] = {
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; RETURN};
lastE _ eList;
eList _ eList.rest;
ENDLOOP;
SIGNAL Problem[msg: "sequence not found."];
};

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: Viewer, 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 {
GGError.PutF[feedback, oneLiner, "No filename specified"];
GGError.Blink[feedback];
};
RETURN[NIL, FALSE];
};
[fullName, cp, ] _ FS.ExpandName[fileName, wDir ! FS.Error => {
success _ FALSE;
IF NOT emergency THEN {
GGError.PutF[feedback, oneLiner, "FS Error during name expansion of %g", [rope[fileName]]];
GGError.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 {
GGError.PutF[feedback, oneLiner, "%g extension for %g files not allowed", [rope[extRope]], [rope[defaultExt]] ];
GGError.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: Viewer, 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: Viewer] 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: Viewer] 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: Viewer, fullName: Rope.ROPE] RETURNS [ipMaster: Interpress.Master, success: BOOL] = {
success _ TRUE;
ipMaster _ Interpress.Open[fileName: fullName, log: NIL !
FS.Error => {
GGError.Append[feedback, error.explanation, oneLiner];
GOTO Quit; 
};
IPMaster.Error => { --ErrorDesc: TYPE = RECORD[code: ATOM, explanation: ROPE]
GGError.Append[feedback, Rope.Cat[error.explanation, " for ", fullName], oneLiner];
GOTO Quit;
};
Imager.Error => { --ErrorDesc: TYPE = RECORD [code: ATOM, explanation: ROPE]
GGError.Append[feedback, Rope.Cat[error.explanation, " for ", fullName], oneLiner];
GOTO Quit;
};
IO.Error, IO.EndOfStream => {
GGError.Append[feedback, Rope.Cat["IO Stream Error for ", fullName], oneLiner];
GOTO Quit;
};
];
IF ipMaster.pages=0 THEN {
GGError.Append[feedback, Rope.Concat["Zero pages in ", fullName], oneLiner];
GOTO Quit;
};
EXITS
Quit => {
GGError.Blink[feedback];
success _ FALSE;
};
};

END.
ไGGUtilityImpl.mesa
Last edited by Bier on January 30, 1987 8:33:49 pm PST.
Contents:  General Purpose routines for use by Gargoyle.
Pier, February 12, 1987 9:35:01 pm PST
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 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

สข˜Icode™Kšœ3ฯkœ
™7šฯnœ0™8Kš
œ&™&—š
	˜	Kšœ\œ ˜€
—K˜šž
œœ
˜Kšœ
œœ˜;Kšœ
˜—˜Kšœœœ
˜Kšœœ˜)Kšœ
œ˜-Kšœ	œ˜%Kšœ
œ˜'Kšœœ˜!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š
œD˜DKšœ
œ
œ
˜!Kšœ
œ
œ˜.šœ˜Kš
œ˜Kš
œ˜K˜—Kšœ  ˜#K˜—šžœœ œ
œœœ
œ˜ˆ
Kšœœ
œœ
˜Kšœœ
œ˜%Kšœ	œ
œ
œ˜)šœ	œ
˜Kšœœ˜Kšœ7œ˜?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š
œp˜pKš
œ˜K˜—Kšœ
œœ
˜K˜—Kšœ
˜—Kšœœ0˜GK˜K˜—šžœœ
œœœœœœœœœœœœ˜ี
Kšœ\œF˜ฆ
K˜K˜—šžœœ
œœœœœœœœ˜ž
Kšœ œ2œ3˜
K˜K˜—šžœœ
œœœœœœœœ˜ž
Kšœ œ:œ=˜“
K˜K˜—šžœœ
œ#œœ(œ˜†
Kšœ
œ
˜šœ4œ˜9šœ˜
Kš
œ6˜6Kšœ˜Kš
œ˜—šœ 9˜MKš
œS˜SKšœ˜
Kš
œ˜—šœ :˜LKš
œS˜SKšœ˜
Kš
œ˜—šœœ˜Kš
œO˜OKšœ˜
Kš
œ˜—Kš
œ˜—šœœ˜Kš
œL˜LKšœ˜
Kš
œ˜—š
˜š
œ	˜	Kš
œ˜Kšœ
œ
˜K˜——K˜—K˜Kšœ
˜—…—'C’