DIRECTORY
FS USING [Error, StreamOpen],
Booting USING [CheckpointProc, RegisterProcs, RollbackProc],
Convert USING [RopeFromCard],
DB,
IO,
Basics USING[LowHalf],
IOClasses USING [CreateCommentFilterStream ],
DBIcons USING [Failure],
DBNames USING[ Separator ],
Icons USING [NewIconFromFile, IconFlavor],
List USING[ DotCons, DottedPair, AList ],
MessageWindow USING [Append, Blink],
Process USING[Ticks, SecondsToTicks, Detach, Pause],
VM USING [AddressFault],
Rope USING [Cat, Equal, ROPE],
UserProfile USING [ Token ]
;


DBIconsImpl: CEDAR MONITOR

IMPORTS Basics, Booting, FS, Convert, IO, MessageWindow, VM, Process, Rope, Icons, DB, List, UserProfile, DBNames, IOClasses  

EXPORTS DBIcons 

= BEGIN 
OPEN DB, Rope;
Failed: PUBLIC ERROR [why: DBIcons.Failure, reason: Rope.ROPE] = CODE;
RegisterArgs: TYPE = RECORD[ iconName: ROPE, fileName: ROPE, index: CARDINAL ];
IconDomain: DB.Domain;  -- the domain of icons
IconRelation: DB.Relation;  -- the relation giving the properties of an icon
IconFileAttr: DB.Attribute;  -- the name of the file for an icon
IconIndexAttr: DB.Attribute;  -- the index in the file
IconIsAttr: DB.Attribute; -- the icon itself (the other attributes are treated as properties)

iconCache: List.AList _ NIL;  -- the internal cache of mappings from icon names to flavors

IconDB: PUBLIC ROPE _ NIL;

readOnly: PUBLIC BOOLEAN _ TRUE;  -- true if the segment is readonly

activity: PUBLIC BOOLEAN _ FALSE;  -- true if a database operation has been performed recently

ticksToWait: Process.Ticks _ Process.SecondsToTicks[5*60];

schemaSet: CONDITION;

EstablishIconDB: PUBLIC PROC [file: Rope.ROPE _ NIL] = {
IconDB _ IF file = NIL THEN
UserProfile.Token[key: "Icons.Segment", default: "[Luther.Alpine]<CedarDoc>Icons.Segment"] ELSE file;
ResetSchema[];
iconCache _ NIL }; 

WatchDBActivity: PROC[] = {
WHILE TRUE DO
Process.Pause[ticksToWait];
CheckConnection[]
ENDLOOP
 };

CheckConnection: ENTRY PROC[] = {
IF NOT activity THEN
{ trans: DB.Transaction = DB.TransactionOf[$Icons];
IF trans # NIL THEN DB.CloseTransaction[trans]
}; -- don't keep the connection open too long
activity _ FALSE;
 };
RegisterIcon: PUBLIC ENTRY PROC [iconName: Rope.ROPE, fileName: Rope.ROPE, index: CARDINAL] = { 
[] _ InternalRegisterIcon[iconName, fileName, index]
}; 

GetIcon: PUBLIC ENTRY PROC [iconName: Rope.ROPE, default: Icons.IconFlavor _ unInit] RETURNS [Icons.IconFlavor] = {
ENABLE UNWIND => NULL;
cachedFlavor: REF ANY = CheckCache[iconName, iconCache];
flavor: Icons.IconFlavor _ unInit;
success: BOOL;
DoGetIcon: PROC[] = {
icon: Entity = DeclareEntity[IconDomain, iconName, OldOnly];
IF icon = NIL THEN {flavor _ default; RETURN};
{ fileName: ROPE = V2S[ GetP[ icon, IconFileAttr, IconIsAttr ] ];
  index: CARDINAL = Basics.LowHalf[LOOPHOLE[V2I[GetP[icon, IconIndexAttr, IconIsAttr]]]];
  flavor _ Icons.NewIconFromFile[fileName, index !
   				FS.Error =>
					IF default # unInit THEN flavor _ default
					ELSE ERROR Failed[fileNotFound, fileName];
			VM.AddressFault =>
					IF default # unInit THEN flavor _ default
					ELSE ERROR
					Failed[invalidIndex, Convert.RopeFromCard[index]]]; -- NewIconFromFile raises this if given badindex.
   } };
IF cachedFlavor # NIL THEN RETURN[NARROW[cachedFlavor, REF Icons.IconFlavor]^];
IF IconDB = NIL THEN RETURN[default];
success _ CarefullyApply[DoGetIcon];
IF NOT success THEN RETURN[default];
IF flavor # unInit THEN
{ iconCache _ Cache[ List.DotCons[iconName, NEW[Icons.IconFlavor _ flavor]],
						   iconCache ];
RETURN[flavor] };
IF default # unInit THEN RETURN[default];
ERROR Failed[noSuchIcon, iconName]
 };

Cache: INTERNAL PROC[ pair: List.DottedPair, aList: List.AList ] RETURNS[ List.AList ] = { 
x, x1: List.AList _ NIL;
x _ aList;
UNTIL x = NIL DO
IF Rope.Equal[NARROW[x.first.key, ROPE], NARROW[pair.key, ROPE]] THEN
BEGIN
x.first.val _ pair.val;
RETURN[aList];
END;
x1_x;
x _ x.rest;
ENDLOOP;
x _ CONS[pair, NIL];
IF x1 = NIL THEN RETURN[x]
ELSE IF x1.rest = NIL THEN x1.rest _ x -- add at end
ELSE ERROR ; -- defensive programming
RETURN[aList];
};

CheckCache: INTERNAL PROC[ name: Rope.ROPE, in: List.AList ] RETURNS[ val: REF ANY ] = { 
UNTIL in = NIL DO
IF Rope.Equal[NARROW[in.first.key, Rope.ROPE], name] THEN RETURN[in.first.val];
in _ in.rest;
ENDLOOP;
RETURN[NIL]};

IsRegistered: PUBLIC ENTRY PROC[iconName: Rope.ROPE _ NIL, fileName: Rope.ROPE _ NIL, index: CARDINAL _ LAST[CARDINAL]] RETURNS[name: Rope.ROPE, file: Rope.ROPE, i: CARDINAL] = {
DoRegisterCheck: PROC[] = 
{ IF iconName # NIL THEN
 { icon: Entity = DeclareEntity[IconDomain, iconName, OldOnly];
IF icon = NIL THEN
{ file _ NIL; name _ NIL; i _ 0 }
ELSE
{ file _ V2S[ GetP[ icon, IconFileAttr, IconIsAttr ] ];
   i _ Basics.LowHalf[LOOPHOLE[V2I[GetP[icon, IconIndexAttr, IconIsAttr]]]] } }
 ELSE
{iconRels: RelshipSet = RelationSubset[IconRelation,
							LIST[AttributeValue[IconFileAttr, S2V[fileName]],
								  AttributeValue[IconIndexAttr, U2V[index]]]];
  iconRel: Relship = NextRelship[iconRels];
  IF iconRel = NIL THEN
{ ReleaseRelshipSet[iconRels];
  file _ NIL; name _ NIL; i _ 0 }
  ELSE
{ name _ DB.NameOf[V2E[GetF[iconRel, IconIsAttr]]];
     file _ fileName;
     i _ index;
     ReleaseRelshipSet[iconRels] } } };
IF NOT CarefullyApply[DoRegisterCheck] THEN RETURN[NIL, NIL, 0]
};

InvalidateCache: PUBLIC ENTRY PROC [iconName: Rope.ROPE _ NIL] = {
IF iconName = NIL THEN iconCache _ NIL
ELSE iconCache _ Cache[ List.DotCons[iconName, NIL], iconCache ]
};

InternalRegisterIcon: INTERNAL PROC[iconName: Rope.ROPE, fileName: Rope.ROPE, index: CARDINAL] RETURNS[success: BOOLEAN] = {
DoRegisterIcon: PROC[] = { 
icon: DB.Entity = DeclareEntity[IconDomain, iconName];
iconRel: Relship = DeclareRelship[ IconRelation, LIST[AttributeValue[IconIsAttr, icon]] ];
SetF[iconRel, IconFileAttr, S2V[fileName]];
SetF[iconRel, IconIndexAttr, U2V[index]] };
IF readOnly OR IconDB = NIL THEN RETURN;  -- can't register things in this segment
ResetSchema[];
success _ CarefullyApply[DoRegisterIcon]  
};
Parse: INTERNAL PROCEDURE[ stream: IO.STREAM, errlog: IO.STREAM ]  = {
OPEN IO;
error: BOOLEAN _ FALSE;
{ ENABLE IO.EndOfStream => GOTO Out;
DO
sepCount: INT;
DBNameProc: IO.BreakProc = {
IF char = DBNames.Separator THEN
{ sepCount _ sepCount+1; RETURN[other] };
IF char = ': AND (sepCount = 2 OR sepCount = 0) THEN
RETURN[sepr];
RETURN[other] };
whiteSpace: IO.BreakProc = {
RETURN[
SELECT char FROM
 CR => break,
 IO.SP, IO.ESC, IO.LF, IO.TAB, ',, ':, '; => sepr,
 ENDCASE => other ]
};
isACR: IO.BreakProc = {
RETURN[IF char = CR THEN break ELSE other]
};
tokenProc: IO.BreakProc = {
RETURN[SELECT char FROM
IO.SP, IO.TAB, ', => sepr,
IO.CR => break,
ENDCASE => other
];
};
iconName, fileName: Rope.ROPE;
index: CARDINAL;
position: INT;
[] _ IO.SkipWhitespace[stream];
position _ stream.GetIndex[];
sepCount _ 0;
iconName _ IO.GetTokenRope[stream, DBNameProc].token;
fileName _ IO.GetTokenRope[stream, whiteSpace].token;
index _ IO.GetCard[stream];
IF NOT InternalRegisterIcon[iconName, fileName, index] THEN
{ error _ TRUE;
  Report[msg: Rope.Cat["Transaction Aborted at: ",
Convert.RopeFromCard[position]], errLog: errlog];
  GOTO Out }
ENDLOOP;
EXITS
Out => NULL;
};
IF error THEN {
MessageWindow.Append["problems encountered in reading icon file."];
MessageWindow.Blink[];
IF errlog # NIL THEN errlog.Close[];
};
};

WriteCatalogue: PUBLIC ENTRY PROC [file: Rope.ROPE] = {
stream: IO.STREAM;
InternalWrite: PROC[] = {
OPEN IO;
icons: EntitySet = DomainSubset[IconDomain];
FOR e: Entity _ NextEntity[icons], NextEntity[icons] UNTIL e = NIL DO
fileName: ROPE = V2S[ GetP[e, IconFileAttr, IconIsAttr] ];
index: CARDINAL = Basics.LowHalf[LOOPHOLE[V2I[GetP[e, IconIndexAttr, IconIsAttr]]]];
stream.PutF["\n%g: %g %d", rope[DB.NameOf[e]], rope[fileName], int[index]];
ENDLOOP;
stream.Close[] };
stream _ FS.StreamOpen[file, $append ! FS.Error => {stream _ NIL; CONTINUE}];
IF stream # NIL THEN [] _ CarefullyApply[InternalWrite]
};

Report: INTERNAL PROCEDURE [msg: Rope.ROPE, errLog: IO.STREAM] = {
OPEN IO;
IF errLog # NIL THEN errLog.PutF["\n\n%g", rope[msg]]; 
};

OpenUp: Booting.RollbackProc = {
DB.Initialize[nCachePages: 256];
InvalidateCache[] };

CloseTrans: Booting.CheckpointProc = {
DB.CloseTransaction[trans: DB.TransactionOf[segment: $Icons]] };

ResetSchema: ENTRY PROC[] = {
success: BOOLEAN;
activity _ TRUE;
IF DB.TransactionOf[$Icons] # NIL THEN RETURN;
[success, readOnly] _ SetUpSegment[];
IF NOT success THEN RETURN;
IF NOT DB.Null[IconDomain] THEN
{ BROADCAST schemaSet; RETURN }; -- all is well, don't bother flushing cache
IconDomain _ DeclareDomain["Icon", $Icons];
IconRelation _ DeclareRelation[ "IconInfo", $Icons ];
IconFileAttr _ DeclareAttribute[IconRelation, "file", RopeType];
IconIndexAttr _ DeclareAttribute[IconRelation, "index", IntType];
IconIsAttr _ DeclareAttribute[IconRelation, "of", IconDomain, Key];
iconCache _ NIL;
BROADCAST schemaSet };

ReadCatalogue: PUBLIC ENTRY PROC[file: Rope.ROPE, errlog: IO.STREAM _ NIL] = TRUSTED {
stream: IO.STREAM;
stream _ FS.StreamOpen[file ! FS.Error => { stream _ NIL; CONTINUE }];
IF stream = NIL THEN RETURN;
stream _ IOClasses.CreateCommentFilterStream[stream];
Parse[ stream, errlog ];
DB.MarkTransaction[DB.TransactionOf[$Icons]] };

CarefullyApply: INTERNAL PROC [proc: PROC[]] RETURNS [succeeded: BOOL] ~ {
ENABLE DB.Error, DB.Failure, DB.Aborted => {succeeded _ FALSE; CONTINUE};
p: SAFE PROCESS _ NIL;
succeeded _ TRUE;
proc[ ! DB.Aborted =>
TRUSTED { DB.AbortTransaction[trans]; p _ FORK ResetSchema[]; CONTINUE };
 DB.Error =>
TRUSTED {IF code # TransactionNotOpen THEN REJECT; p _ FORK ResetSchema[]; CONTINUE} ];
IF p = NIL THEN RETURN; -- no aborted occurred, things either succeeded or failed
WAIT schemaSet; -- ResetSchema is doing its job since we forked it
TRUSTED {JOIN p};  -- and throw away the process that reset the schema
proc[] -- don't bother trying to restart here --
};

SetUpSegment: INTERNAL PROC [] RETURNS [success: BOOL, readOnly: BOOL] ~ {
ENABLE DB.Aborted, DB.Failure, DB.Error => {success _ FALSE; CONTINUE};
segment: ATOM = $Icons;
readOnly _ FALSE;
success _ TRUE;
IF DB.TransactionOf[segment] # NIL THEN
{readOnly_ DB.GetSegmentInfo[segment].readOnly; RETURN};
DB.DeclareSegment[IconDB, segment, 140B, FALSE];
IF NOT success THEN GOTO AlreadyDone; -- no chance for making progress
DB.OpenTransaction[segment !
DB.Error => TRUSTED {
success_ FALSE;
  SELECT code FROM
ProtectionViolation => {readOnly _ TRUE; CONTINUE};
ENDCASE => GOTO AlreadyDone} ];
IF success THEN GOTO AlreadyDone;
DB.CloseTransaction[DB.TransactionOf[segment]];
DB.DeclareSegment[IconDB, segment, 140B, TRUE];
DB.OpenTransaction[segment];
IF NOT success THEN DB.CloseTransaction[DB.TransactionOf[segment]]
EXITS
AlreadyDone => NULL
};
TRUSTED {
Booting.RegisterProcs[c: CloseTrans, r: OpenUp];
EstablishIconDB[];
Process.Detach[ FORK WatchDBActivity[] ] };


END.

<DBIconsImpl.mesa;
Edited by Teitelman on April 12, 1983 4:53 pm
Last Edited by: Donahue, August 11, 1983 2:28 pm
Types
Global variables for accessing the database
The tuples in the relation have the structure
IconRelation[ IconIsAttr: IconDomain, IconFileAttr: ROPE, IconIndexAttr: INT, IconFlavorAttr: Icons.IconFlavor ] (where the flavor is stored as an UNSPECIFIED)
Establishing the database
Accessing Icons
Changes RegisteredIcons.Catalogue to reflect the indicated association. This definition will replace any previous definition. comments are for inclusion in the catalogue to help the user figure out what the icon looks like. 
Obtain an icon flavor for the icon associated with iconName. Create a new icon flavor if one has not previously been created.
If for some reason it could not obtain the icon, and default # unInit, returns the default. Otherwise, raises Error (defined below) with appropriate parameters.
key not found on x
Can be called with either iconName, or fileName and index; does not force creation of icon flavor (only GetIcon does that).
If an iconFlavor was previous created for this icon, discard the flavor, i.e. the next call to GetIcon will create a new flavor. If iconName = NIL, do this for all registered icons. For use by iconeditor. 
Parsing Icon Catalogues
find a colon after seeing zero or two separators (one for the domain,
one for the segment
Reporting errors
Opening, closing segment, making/reading catalogue
wait for the reset to finish and then try again
readOnly must be true to get here; try opening the segment for reading
Initialization

Κα–

"Cedar" style˜Jš
Οc™Jšœ™-Jš
Οn0™0š
Οk	˜	JšŸœ
Ÿœ˜JšœŸœ/˜<JšœŸœ˜JšŸœ
˜JšŸœ
˜JšœŸœ
˜Jšœ
Ÿœ˜-JšœŸœ˜JšœŸœ˜JšœŸœ˜*JšœŸœ˜)JšœŸœ˜$JšœŸœ'˜4JšŸœ
Ÿœ˜JšœŸœŸœ˜JšœŸœ
˜J˜
J˜—J˜JšΠblœŸœ
Ÿ˜J˜Jš
ŸœŸœŸœŸœŸœ)˜~J˜JšŸœ	˜J˜šœŸœ
˜JšŸœ
Ÿœ˜—
headš
œ™Jš	œŸœ
Ÿœ%ŸœŸœ
˜FJšœŸœŸœŸœŸœ	Ÿœ˜O—™+JšœŸœ
˜.šœŸœ0˜LJšœ:œ‘
™Ν
—JšœŸœ
#˜@JšœŸœ
˜6JšœŸœC˜]J˜JšœŸœ<˜ZJ˜J•StartOfExpansion$[key: 
ROPE, default: 
ROPE _ NIL]šœŸœ
ŸœŸœ
˜J˜Jšœ
Ÿœ
ŸœŸœ"˜DJ˜Jšœ
Ÿœ
ŸœŸœ;˜^J˜Jš
œ:˜:J˜JšœŸ	œ
˜—™J˜š
žœŸœ
Ÿœ
ŸœŸœ˜8šœ	ŸœŸœ
Ÿ˜Jšœ[Ÿœ˜e—J–Y[segmentFile: 
ROPE, seg: 
DB.Segment, number: 
NAT _ 0, makeReadOnly: 
BOOL _ FALSE]š
œ˜JšœŸœ˜J˜—šžœŸœ˜šŸœ
Ÿœ
Ÿ˜
Jš
œ˜Jš
œ˜Jš
Ÿ˜—Jš
œ˜J˜—šžœŸ
œ˜!šŸœ
Ÿœ
Ÿ˜šœ	ŸœŸœ˜3JšŸœ	Ÿœ
Ÿœ
Ÿœ˜.Jšœ*˜-——JšœŸœ
˜J˜——™šžœŸœ
Ÿ
œŸœŸœ	Ÿœ˜`J™ΰ
Jš
œ4˜4J˜—J˜š
žœŸœ
Ÿ
œŸœ&Ÿœ˜sJš
}™}J™ 
JšŸœ
ŸœŸœ
˜JšœŸœ
Ÿœ#˜8Jš
œ"˜"Jšœ	Ÿœ
˜šž	œŸœ˜Jš
œ<˜<JšŸœŸœ
ŸœŸœ˜.JšœŸœ1˜AJšœ	ŸœŸœ.˜YJš
œ2˜2šœŸœ	˜JšœŸœŸœ˜.JšœŸœ
Ÿœ ˜/—šœŸœ˜JšœŸœŸœ˜.JšœŸœ
Ÿœ:1˜z—Jš
œ˜—JšŸœŸœ
Ÿœ
Ÿœ
ŸœŸœ˜OJšŸœ
Ÿœ
Ÿœ
Ÿœ
˜%Jš
œ$˜$JšŸœ
Ÿœ	Ÿœ
Ÿœ
˜$šŸœŸ˜šœ,Ÿœ3˜bJšŸœ˜——JšŸœŸœ
Ÿœ
˜)JšŸœ˜"—˜J˜—šžœŸœ
Ÿœ-Ÿœ˜[JšœŸœ
˜J˜
šŸœŸœ
Ÿ˜šŸœŸœŸœŸœŸœŸ˜EJš
Ÿ˜J˜JšŸœ˜JšŸœ
˜—J˜J˜—JšŸœ
˜Jš
™JšœŸœŸœ˜šŸœŸœ
Ÿœ
Ÿœ˜Jš	Ÿœ
ŸœŸœ
Ÿœ

˜4JšŸœ
Ÿœ˜%—JšŸœ˜J˜J˜—šž
œŸ
œ
ŸœŸœŸœ
Ÿœ˜YšŸœŸœ
Ÿ˜Jš
ŸœŸœŸœ	Ÿœ
Ÿœ˜OJ˜
JšŸœ
˜—JšŸœ
Ÿœ˜
—J˜šžœŸœ
Ÿ
œŸœŸœŸœŸœ	ŸœŸœ
ŸœŸœŸœ
ŸœŸœ˜²
J™{šžœŸœ˜šœŸœŸœ
Ÿ˜š
œ?˜?šŸœŸœ
Ÿ˜Jšœ	Ÿœ	Ÿœ	˜!—Jš
Ÿ˜Jš
œ7˜7JšœŸ
œŸœ1˜O——šœ
Ÿ˜Jš
œ4˜4JšœŸœ-˜8Jš
œ6˜6Jš
œ+˜+šœŸœŸœ
Ÿ˜Jš
œ˜Jšœ	Ÿœ	Ÿœ	˜!—šœŸ˜Jšœ	Ÿœ(˜3—Jš
œ˜J˜Jš
œ'˜'—šŸœ
Ÿœ!Ÿœ
Ÿœ
ŸœŸœ˜?Jš
œ˜——J˜—š
žœŸœ
Ÿ
œŸœŸœ˜BJ™Ν
JšŸœŸœ
Ÿœ
Ÿ˜&JšŸœ+Ÿœ˜@J˜—J˜šžœŸ
œŸœŸœ	ŸœŸœ
Ÿœ˜|šžœŸœ˜JšœŸœ.˜6Jšœ1Ÿœ%˜ZJš
œ+˜+Jš
œ+˜+—JšŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ(˜RJš
œ˜Jš
œ*˜*Jš
œ˜——™
procšžœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜FJšŸœ
Ÿœ
˜JšœŸœŸœ
˜šœŸœ
ŸœŸœ˜$Jš
Ÿ˜šœ
Ÿœ
˜šœŸœ˜Jš
œE™EJš
œ™šŸœŸ˜ JšœŸœ
˜)—šŸœŸœŸœŸ˜4JšŸœ˜
—JšŸœ
˜—šœŸœ˜JšŸœŸœŸœŸœŸœ
ŸœŸœ
ŸœŸœ
ŸœŸœ
ŸœŸœ˜mJ˜—šœŸœ˜Jš
Ÿœ
ŸœŸœ
ŸœŸœ˜*J˜—šœŸœ˜šŸœ
ŸœŸ˜JšŸœ
ŸœŸœ
Ÿœ
˜JšŸœ
Ÿœ
˜JšŸœ	˜J˜—Jš
œ˜—JšœŸœ
˜JšœŸœ
˜Jšœ
Ÿœ
˜JšœŸœ˜Jš
œ˜J˜
JšœŸœ(˜5JšœŸœ(˜5JšœŸœ˜šŸœ
Ÿœ1Ÿ˜;Jšœ
Ÿœ
˜š
œ2˜2Jš
œ1˜1—JšœŸœ˜—JšŸœ
˜—š
Ÿ˜JšœŸœ
˜—J˜—šŸœŸœ˜Jš
œC˜CJš
œ˜JšŸœ
Ÿœ
Ÿœ˜$J˜—Jš
œ˜—J˜šžœŸœ
Ÿ
œ
Ÿœ˜7JšœŸœ
Ÿœ
˜šž
œŸœ˜JšŸœ
Ÿœ
˜Jš
œ,˜,šŸœ2ŸœŸœ
Ÿ˜EJšœ
Ÿœ,˜:JšœŸœŸœ+˜TJšœ Ÿœ)˜KJšŸœ
˜—J˜—Jš	œ	ŸœŸœŸœŸœ˜MJšŸœ
Ÿœ
Ÿœ#˜7J˜——™J˜š
žœŸœŸœ
Ÿœ
Ÿœ˜BJšŸœ
Ÿœ
˜JšŸœ
Ÿœ
Ÿœ#˜7Jš
œ˜—J˜—™2š
œ ˜ J–j[nCachePages: 
NAT _ 512, nFreeTuples: 
NAT _ 32, cacheFileName: 
ROPE _ NIL, augments: 
BOOL _ FALSE]šŸœ˜ Jš
œ˜J˜—š
œ&˜&J–[segment: 
DB.Segment]šŸœŸœ$˜A—šžœŸ
œ˜Jšœ	Ÿœ
˜JšœŸœ
˜Jš
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
˜.J–([segmentFile: 
ROPE, seg: 
DB.Segment]š
œ%˜%JšŸœ
Ÿœ	Ÿœ
Ÿœ
˜šŸœ
Ÿœ
ŸœŸ˜Jšœ
Ÿ
œŸœ+˜L—J˜+J˜5J˜@J˜AJš
œC˜CJšœŸ˜JšŸ	œ
˜—J˜šž
œŸœ
Ÿ
œŸœ
Ÿœ
ŸœŸœŸœ˜VJšœŸœ
Ÿœ
˜Jš	œ	ŸœŸœŸœŸœ˜FJšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Jš
œ5˜5Jš
œ˜JšŸœŸœ˜/J˜—šžœŸœ
ŸœŸœŸœ
Ÿœ˜JJšŸœ
ŸœŸœ
ŸœŸœŸœ˜IJšœŸœ
ŸœŸœ
˜JšœŸœ
˜šœŸœ˜JšŸœŸœŸœŸ	œ˜IJšœ
Ÿœ	˜JšŸœŸœŸœ
ŸœŸœŸœ˜W—Jš	ŸœŸœ
Ÿœ
Ÿœ9˜QJš
œ/™/JšŸœ2˜BJšŸœŸœ3˜FJšœΟb
)˜0Jš
œ˜J˜—š
ΠbnœŸ
œŸœŸœŸœ˜JJšŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ˜GJšœ	Ÿœ
˜JšœŸœ
˜Jšœ
Ÿœ
˜šŸœ
ŸœŸœ
Ÿ˜'JšœŸœ#Ÿœ˜8—JšŸœ'Ÿœ˜0Jš	Ÿœ
Ÿœ	Ÿœ
Ÿœ ˜FšŸœ˜šŸœ
Ÿœ˜Jšœ	Ÿœ
˜—šœŸœŸ˜Jšœ#ŸœŸœ˜3JšŸœŸœ˜——JšŸœ	Ÿœ
Ÿœ
˜!Jš
œF™FJšŸœŸœ˜/JšŸœ'Ÿœ˜/JšŸœ˜Jš
Ÿœ
Ÿœ	Ÿœ
ŸœŸœ˜Bš
Ÿ˜JšœŸ˜—J˜——š
œ™šŸœ˜	Jš
œ0˜0Jš
œ˜JšœŸœ˜+—J˜J˜—JšŸœ
˜J˜J™—…—*RAo