DIRECTORY
Basics USING [BITAND, LowHalf],
BasicTime USING [Now],
Buttons USING [ReLabel],
IO,
Labels USING [Set],
LarkControl,
LarkPrograms USING [AddOrReplaceProgram, FetchProgram, FindVariable, PatchItem, Program, ReadProgramFromDisk, ReadProgramFromMBFile, STObject],
NamesGV USING [GVIsAuthenticated, GVGetAttribute],
ProcessExtras USING [CheckForAbort],
Rope USING [Concat, Fetch, Find, FromChar, Length, ROPE, Substr],
TeleLoad USING [Advice, Call, CallPkt, CallPktObject, CoreAddress, CoreBlock, CoreBlockObject, EventRecordObject, Failed, Fetch, FetchState, FlushWrites, GetEventData, Go, GoFromBreak, GoToDebugger, Handle, ReadWord, Registers8086, ResetCache, SetCacheSize, SingleStep, SlaveFetch, SlaveStore, State8086, State8086Object, Store, SwabState, TeleLoadProc, Write, WriteWord];

LarkCommImpl: CEDAR PROGRAM
IMPORTS Buttons, Basics, BasicTime, IO, Labels, LarkControl, LarkPrograms, NamesGV, ProcessExtras, Rope, TeleLoad
EXPORTS LarkControl =
{

loadWindowLow: PUBLIC TeleLoad.CoreAddress _ 0;
loadWindowHigh: PUBLIC TeleLoad.CoreAddress _ 57344;	-- 0E000H

LoadProgram: PUBLIC PROC [lark: LarkControl.LarkData, go: BOOL, main: BOOL] = {
ENABLE TeleLoad.Failed => GOTO BadComm;
ok: BOOL;
tries: NAT;
h: TeleLoad.Handle _ lark.h;
log: IO.STREAM _ h.log;
program: LarkPrograms.Program _ IF main THEN lark.program ELSE lark.slaveProgram;
IF program = NIL THEN {
log.PutRope["No program specified\n"];
RETURN;
};
TeleLoad.FlushWrites[h];
TeleLoad.SetCacheSize[h, 0];
IF lark.breakList # NIL THEN {
LarkControl.LogEntry[lark: lark, rope: "Clearing breakpoints\n"];
lark.breakList _ NIL;
};
LarkControl.LogEntry[lark: lark, rope: IO.PutFR["Loading %g: ", IO.rope[program.programName]]];
IF NOT FetchState[h].ok THEN {
log.PutRope["\n"];
RETURN;
};
FOR l: LIST OF TeleLoad.CoreBlock _ program.program, l.rest WHILE l # NIL DO
IF l.first.address >= LarkControl.loadWindowLow AND (l.first.address + l.first.count) < LarkControl.loadWindowHigh THEN {
l.first.advice _ [FALSE, FALSE, 0];
[ok, tries] _ IF program.addressSpace = main THEN TeleLoad.Store[h, l.first] ELSE TeleLoad.SlaveStore[h, l.first];
IF ok THEN log.PutChar[IF tries = 1 THEN '! ELSE ('0 + MIN[tries, 9])]
ELSE {
log.PutRope["\nTeleload Error\n"];
EXIT;
};
}
ELSE {
FOR partial: TeleLoad.CoreAddress IN [0..l.first.count) DO
IF (l.first.address + partial) >= LarkControl.loadWindowLow AND (l.first.address + partial) < LarkControl.loadWindowHigh THEN TeleLoad.Write[h: h, addr: l.first.address + partial, value: l.first[partial], addressSpace: program.addressSpace];
ENDLOOP;
TeleLoad.FlushWrites[h];
log.PutChar['s];
};
ENDLOOP;
FOR pl: LIST OF LarkPrograms.PatchItem _ program.patchList, pl.rest WHILE pl # NIL DO
TeleLoad.WriteWord[h: h, addr: pl.first.address, value: pl.first.wordValue, addressSpace: program.addressSpace];
log.PutChar['p];
ENDLOOP;
TeleLoad.FlushWrites[h];
lark.state _ program.startState;
IF go THEN {
[] _ SetState[h: h, state: lark.state, tp: TeleLoad.Go];
Labels.Set[lark.status, LarkControl.PollLark[lark, FALSE, FALSE]];
lark.lastBoot _ BasicTime.Now[];
lark.lastBootTimeValid _ TRUE;
};
log.PutRope["\n"];
EXITS
BadComm => NULL;
};

PaintMode: PUBLIC PROC [lark: LarkControl.LarkData] = {
Buttons.ReLabel[button: lark.mode, newName: Rope.Concat["Mode ", Rope.FromChar[lark.larkMode]]];
};

SetState: PUBLIC PROC [h: TeleLoad.Handle, state: TeleLoad.State8086Object, tp: TeleLoad.TeleLoadProc, print: BOOL _ TRUE] RETURNS [ok: BOOL] = TRUSTED {
cb: TeleLoad.CoreBlock;
tries: NAT;
pp: TeleLoad.State8086;
size: CARDINAL = SIZE[TeleLoad.State8086Object]*2;
IF h = NIL THEN ERROR;
cb _ NEW[TeleLoad.CoreBlockObject[size]];
cb.address _ 1;
cb.advice _ [FALSE, FALSE, 0];
pp _ LOOPHOLE[BASE[DESCRIPTOR[cb.data]], TeleLoad.State8086];
pp^ _ TeleLoad.SwabState[state];
pp _ NIL;
[ok, tries] _ tp[h, cb];
IF NOT ok AND print THEN {
reason: Rope.ROPE _ SELECT tp FROM
TeleLoad.Store => "Store",
TeleLoad.Fetch => "Fetch",
TeleLoad.Go => "Go",
TeleLoad.FetchState => "FetchState",
TeleLoad.SingleStep => "SingleStep",
TeleLoad.GoFromBreak => "GoFromBreak",
TeleLoad.GoToDebugger => "GoToDebugger",
TeleLoad.SlaveStore => "SlaveStore",
TeleLoad.SlaveFetch => "SlaveFetch",
TeleLoad.Call => "Call"
ENDCASE => "SetState";
IF h.log # NIL THEN h.log.PutF["%g: %g failed (%d attempts)\n", IO.rope[h.host], IO.rope[reason], IO.int[tries]];
};
};

FetchState: PUBLIC PROC[h: TeleLoad.Handle, adv: TeleLoad.Advice _ [FALSE, FALSE, 0], print: BOOL _ TRUE] RETURNS [ok: BOOL, state: TeleLoad.State8086Object] = TRUSTED {
cb: TeleLoad.CoreBlock;
tries: NAT;
pp: TeleLoad.State8086;
size: CARDINAL = SIZE[TeleLoad.State8086Object]*2;
IF h = NIL THEN ERROR;
cb _ NEW[TeleLoad.CoreBlockObject[size]];
cb.address _ 1;
cb.advice _ adv;
[ok, tries] _ TeleLoad.FetchState[h, cb];
IF NOT ok AND print THEN {
IF h.log # NIL THEN h.log.PutF["%g: FetchState failed (%d attempts)\n", IO.rope[h.host], IO.int[tries]];
state _ [ALL[0]];
RETURN;
};
pp _ LOOPHOLE[BASE[DESCRIPTOR[cb.data]], TeleLoad.State8086];
state _ TeleLoad.SwabState[pp^];
pp _ NIL;
};

SetValue: PUBLIC PROC [lark: LarkControl.LarkData, name: Rope.ROPE, value: CARDINAL, offset: NAT _ 0, print: BOOL _ TRUE] RETURNS [ok: BOOL] = {{
ENABLE TeleLoad.Failed => GOTO BadComm;
ob: LarkPrograms.STObject;
address: TeleLoad.CoreAddress;
found: BOOL;
oldValue: CARDINAL;
out: IO.STREAM;
IF lark = NIL OR lark.h = NIL THEN RETURN[FALSE];
out _ lark.h.log;
TeleLoad.ResetCache[lark.h];
[item: ob, found: found] _ LarkPrograms.FindVariable[lark.program, name];
IF NOT found THEN {
IF print THEN out.PutF["  %g: not found\n", IO.rope[name]];
RETURN[FALSE];
}
ELSE {	-- fetch data and print it
address _ ob.addr;
IF print THEN out.PutF["  %g + %04xH (%04xH^): ", IO.rope[name], IO.card[offset], IO.card[address]];
oldValue _ TeleLoad.ReadWord[lark.h, address + offset];
IF ob.type = variable THEN {
TeleLoad.SetCacheSize[lark.h, 2];  -- one word at a time!
TeleLoad.WriteWord[h: lark.h, addr: address + offset, value: value];
TeleLoad.FlushWrites[lark.h];
TeleLoad.SetCacheSize[lark.h, 0];
IF print THEN out.PutF["%04xH _ %04xH\n", IO.card[oldValue], IO.card[value]];
}
ELSE {
IF print THEN out.PutF["%04xH . . . not a variable\n", IO.card[oldValue]];
RETURN[FALSE];
};
};
};
RETURN[TRUE];
EXITS
BadComm => RETURN[FALSE];
};

DisplayState: PUBLIC PROC[s: IO.STREAM, state: TeleLoad.State8086Object, indent: NAT _ 0] = { 
THROUGH [0..indent) DO s.PutChar[' ]; ENDLOOP;
FOR i: TeleLoad.Registers8086 IN [AX..SI] DO PutReg[s, i, state.Regs[i]]; ENDLOOP;
s.PutChar['\n];
THROUGH [0..indent) DO s.PutChar[' ]; ENDLOOP;
FOR i: TeleLoad.Registers8086 IN [DI..FL] DO PutReg[s, i, state.Regs[i]]; ENDLOOP;
s.PutChar['\n];
};

PutReg: PROC [s: IO.STREAM, i: TeleLoad.Registers8086, v: CARDINAL] = {
s.PutF[" %2s=%04xH", IO.rope[RegNames[i]], IO.card[v]];
};

RegNames: ARRAY TeleLoad.Registers8086 OF Rope.ROPE = [
"AX", "BX", "CX", "DX", "SP", "BP", "SI", "DI", "CS", "DS", "SS", "ES", "IP", "FL"];

LocalGo: PUBLIC PROC [lark: LarkControl.LarkData] = {
found: BOOL _ FALSE;
breakpoint: LarkControl.Breakpoint;
FOR l: LIST OF LarkControl.Breakpoint _ lark.breakList, l.rest WHILE l # NIL DO
IF l.first.address = lark.state.Regs[IP] THEN {
found _ TRUE;
breakpoint _ l.first;
EXIT;
};
ENDLOOP;
IF found THEN {
RepairBreakpoint[lark.h, breakpoint];
[] _ LarkControl.SetState[h: lark.h, state: lark.state, tp: TeleLoad.GoFromBreak, print: TRUE];
}
ELSE [] _ LarkControl.SetState[h: lark.h, state: lark.state, tp: TeleLoad.Go, print: TRUE];
IF lark.status # NIL THEN Labels.Set[lark.status, LarkControl.PollLark[lark, FALSE, FALSE]];
};

PollLark: PUBLIC PROC [lark: LarkControl.LarkData, print: BOOL _ FALSE, setPointers: BOOL _ TRUE] RETURNS [reason: Rope.ROPE] = {
event: TeleLoad.EventRecordObject;
ok: BOOL;
[event: event, ok: ok] _ TeleLoad.GetEventData[h: lark.h, setPointers: setPointers];
IF NOT ok THEN {
reason _ "Down";
lark.event.reason _ LarkControl.cDown;
}
ELSE {
reason _ LarkControl.BootReason[reason: event.reason, BX: event.regs.Regs[BX]];
IF lark.lastBootTimeValid THEN reason _ IO.PutFR["%-20g booted: %g", IO.rope[reason], IO.time[lark.lastBoot]];
lark.event _ event;
};
IF print THEN {
IF ok THEN LarkControl.DisplayEvent[lark: lark, event: event, out: lark.h.log, reasonRope: reason, preRope: "Status of", short: TRUE]
ELSE LogEntry[lark: lark, rope: reason, endWithCR: TRUE];
};
};

RepairBreakpoint: PUBLIC PROC [h: TeleLoad.Handle, breakpoint: LarkControl.Breakpoint] = {
TeleLoad.FlushWrites[h];
TeleLoad.ResetCache[h];
TeleLoad.SetCacheSize[h, 1];
TeleLoad.Write[h, breakpoint.address, breakpoint.codeByte];
TeleLoad.FlushWrites[h];
TeleLoad.SetCacheSize[h, 0];
};

BootLark: PUBLIC PROC [lark: LarkControl.LarkData] = TRUSTED {
ok: BOOL;
cb: TeleLoad.CoreBlock _ NEW[TeleLoad.CoreBlockObject[SIZE[TeleLoad.CallPktObject]*2]];
cp: TeleLoad.CallPkt _ LOOPHOLE[BASE[DESCRIPTOR[cb.data]]];
sym: LarkPrograms.STObject;
tries: NAT;
cb.address _ 0;
cb.advice _ [FALSE, FALSE, 0];
[item: sym, found: ok] _ LarkPrograms.FindVariable[lark.program, "Boot"];
IF NOT ok THEN RETURN;
cp.proc _ Basics.LowHalf[sym.addr];
cp.args _ ALL[0];
cp.nargs _ 0;
cp.returnArg _ 0;
[ok, tries] _ TeleLoad.Call[lark.h, cb, 1];
};

LarkGVSet: PUBLIC PROC [lark: LarkControl.LarkData, setMode: BOOL, setProgram: BOOL] = {
programName: Rope.ROPE_NIL;
found: BOOL_FALSE;
IF lark.larkMode = 'd THEN {
lark.h.log.PutF["%g: local mode override\n", IO.rope[lark.rName]];
RETURN;
};
SELECT NamesGV.GVIsAuthenticated[lark.rName] FROM
authentic, perhaps => found_TRUE;
bogus, nonexistent => lark.h.log.PutF["%g: Not known\n", IO.rope[lark.rName]];
unknown => lark.h.log.PutF["%g: Grapevine failure\n", IO.rope[lark.rName]];
ENDCASE => ERROR;
IF found THEN {
larkPos: INT;
programName _ NamesGV.GVGetAttribute[lark.rName, $program, "Lark"];
lark.h.log.PutF["%g program: %g\n", IO.rope[lark.rName], IO.rope[programName]];
lark.userRName _ NamesGV.GVGetAttribute[lark.rName, $connect, "Unknown"];
larkPos _ Rope.Find[s1: lark.userRName, s2: ".lark", case: FALSE];
IF larkPos >= 0 THEN lark.userRName _ Rope.Substr[base: lark.userRName, len: larkPos];
};
Labels.Set[lark.userRNameViewer, lark.userRName];
IF setMode THEN {
larkMode: Rope.ROPE;
larkMode _ NamesGV.GVGetAttribute[lark.rName, $mode, "U"];
IF larkMode.Length[]=0 THEN larkMode_"U";
lark.larkMode _ larkMode.Fetch[0];
};
IF setProgram THEN {
program: LarkPrograms.Program;
IF programName.Length[] > 0 THEN {
program _ LarkPrograms.FetchProgram[programName];
IF program = NIL THEN {
program _ LarkPrograms.ReadProgramFromDisk[objectFileName: programName, log: lark.h.log, addressSpace: main];
IF program # NIL THEN LarkPrograms.AddOrReplaceProgram[program];
};
IF program # NIL THEN {
lark.program _ program;
LarkControl.LogEntry[lark: lark];
lark.h.log.PutF["setting program to %g\n", IO.rope[lark.program.programName]];
}
ELSE LarkControl.LogEntry[lark: lark, rope: "setting program to NIL.\n"];
programName _ Rope.Concat[programName, "SlaveRam.mb"];
program _ LarkPrograms.FetchProgram[programName];
IF program = NIL THEN {
program _ LarkPrograms.ReadProgramFromMBFile[mbFileName: programName, baseAddress: 02000H, log: NIL, addressSpace: slave];
IF program # NIL THEN LarkPrograms.AddOrReplaceProgram[program];
};
IF program # NIL THEN {
lark.slaveProgram _ program;
LarkControl.LogEntry[lark: lark];
lark.h.log.PutF["  setting slave program to %g\n", IO.rope[lark.slaveProgram.programName]];
};
};
};
};

LogEntry: PUBLIC PROC [lark: LarkControl.LarkData, rope: Rope.ROPE _ NIL, endWithCR: BOOL _ FALSE] = {
lark.h.log.PutF["%g, %g", IO.time[], IO.rope[lark.nameRope]];
IF rope # NIL THEN {
lark.h.log.PutRope[": "];
lark.h.log.PutRope[rope];
}
ELSE lark.h.log.PutChar[' ];
IF endWithCR THEN lark.h.log.PutRope["\n"];
};

DisplayEvent: PUBLIC PROC [lark: LarkControl.LarkData, event: TeleLoad.EventRecordObject, out: IO.STREAM, reasonRope: Rope.ROPE, preRope: Rope.ROPE, short: BOOL _ FALSE] = {
longClock: LONG CARDINAL;
relays: Rope.ROPE;
LogEntry[lark: lark, rope: preRope];
out.PutF[" %04xH (%g)\n", IO.card[event.reason], IO.rope[reasonRope]];
longClock _ event.clockHigh;
longClock _ longClock * 65536;
longClock _ longClock + event.clockLow;
out.PutF["      clock %08x, switches: %04xH, advice: %04xH\n", IO.card[longClock], IO.card[event.bootSwitches], IO.card[event.advice]];
SELECT Basics.BITAND[event.monRelays, 9] FROM
0 => relays _ "TeleSet and Hookswitch active ";
1 => relays _ "TeleSet active ";
8 => relays _ "Hookswitch active ";
ENDCASE => relays _ NIL;
SELECT Basics.BITAND[event.monRelays, 6] FROM
2 => relays _ relays.Concat["A relay active "];
4 => relays _ relays.Concat["Off hook "];
6 => relays _ relays.Concat["Off hook and A relay active "];
ENDCASE => NULL;
out.PutRope["      "];
IF relays.Length[] > 0 THEN {
out.PutRope["Previously "];
out.PutRope[relays];
out.PutRope[",  "];
};
out.PutF["TeleLoad Host: %b#%b# via %b\n", IO.card[event.tlNet], IO.card[event.tlHost], IO.card[event.tlImHost]];
IF NOT short THEN LarkControl.DisplayState[s: out, state: event.regs, indent: 6];
out.PutRope["% "];
IF lark.status # NIL THEN Labels.Set[lark.status, reasonRope];
};

VerifyInternal: PUBLIC PROC [lark: LarkControl.LarkData, program: LarkPrograms.Program, startAddress, stopAddress: TeleLoad.CoreAddress] = {
ENABLE TeleLoad.Failed => GOTO BadComm;
log: IO.STREAM _ lark.h.log;
h: TeleLoad.Handle _ lark.h;
blockCount: NAT;
blockAddress: TeleLoad.CoreAddress;
tries: NAT;
tcb: TeleLoad.CoreBlock _ NIL;
ok: BOOL;
endCode: TeleLoad.CoreAddress;
item: LarkPrograms.STObject;
found: BOOL;
IF stopAddress <= startAddress THEN {
[item: item, found: found] _ LarkPrograms.FindVariable[program, "endCode", FALSE];
endCode _ item.addr;
IF NOT found THEN {
[item: item, found: found] _ LarkPrograms.FindVariable[program, "monEndCode", FALSE];
endCode _ item.addr;
IF found THEN {
startAddress _ program.startState.Regs[IP];
stopAddress _ endCode;
}
ELSE {
log.PutRope["Can't find endCode symbol.\n"];
log.PutRope["Checking entire image\n"];
startAddress _ LAST[TeleLoad.CoreAddress];
stopAddress _ FIRST[TeleLoad.CoreAddress];
FOR l: LIST OF TeleLoad.CoreBlock _ program.program, l.rest WHILE l # NIL DO
IF l.first.address < startAddress THEN startAddress _ l.first.address;
IF l.first.address + l.first.count > stopAddress THEN stopAddress _ l.first.address + l.first.count;
ENDLOOP;
};
}
ELSE {
startAddress _ program.startState.Regs[IP];
stopAddress _ endCode;
};
};
log.PutF["%g: Checking %s between %04x and %04x:  ", IO.rope[lark.nameRope], IO.rope[program.programName], IO.card[startAddress], IO.card[stopAddress]];
TeleLoad.FlushWrites[h];
FOR l: LIST OF TeleLoad.CoreBlock _ program.program, l.rest WHILE l # NIL DO
IF lark.world.pleaseStop THEN EXIT;
blockCount _ l.first.count;
blockAddress _ l.first.address;
IF l.first.address < startAddress THEN {
IF l.first.address + blockCount < startAddress THEN LOOP;
blockCount _ blockCount - (startAddress - l.first.address);
blockAddress _ startAddress;
};
IF l.first.address + blockCount > stopAddress THEN {
IF l.first.address > stopAddress THEN LOOP;
blockCount _ stopAddress - l.first.address;
};
IF tcb = NIL OR tcb.count # blockCount THEN tcb _ NEW[TeleLoad.CoreBlockObject[blockCount]];
tcb.address _ blockAddress;
tcb.advice _ [FALSE, FALSE, 0];
[ok, tries] _ IF program.addressSpace = main THEN TeleLoad.Fetch[h, tcb] ELSE TeleLoad.SlaveFetch[h, tcb];
IF ok THEN {
log.PutChar[IF tries # 1 THEN ('0 + MIN[tries, 9]) ELSE IF program.addressSpace = main THEN '! ELSE 's];
}
ELSE {
log.PutRope["\nTeleload Read Error\r"];
EXIT;
};
FOR i: CARDINAL IN [0..tcb.count) DO
IF lark.world.pleaseStop THEN EXIT;
IF tcb[i] # l.first[tcb.address + i - l.first.address] THEN {
log.PutF["addr: %04x is: %02x was %02x\n", IO.card[tcb.address+i], IO.card[tcb[i]], IO.card[l.first[tcb.address + i - l.first.address]]];
ProcessExtras.CheckForAbort[];
};
ENDLOOP;
ENDLOOP;
lark.world.pleaseStop _ FALSE;
log.PutRope["\n"];
EXITS
BadComm => NULL;
};

}.
April 25, 1983 12:13 pm, LCS, created from old LarkPrograms.mesa
April 29, 1983 12:06 pm, LCS, new Event stuff
December 21, 1983 4:08 pm, LCS, new Cedar 5

$LarkCommImpl.mesa
Stewart, December 21, 1983 4:08 pm
Last Edited by: Swinehart, June 15, 1984 1:46:31 am PDT
changes the word at offset from an identifier, use for patch decks
Force a GV lookup next time.
Peel off the .lark, if there is one
Now install a standard slave program, if any
�ÊɘJš
œ™Jš
œ"™"J™7J˜š
Ïk	˜	Jšœ�œ�œ˜Jšœ
�œ˜Jšœ�œ˜Jš�œ
˜Jšœ�œ˜J˜Jšœ
�œ}˜�
Jšœ�œ%˜2Jšœ�œ˜$Jšœ�œ)�œ
˜AJšœ	�œæ˜ôJ˜—Jšœ�œ
�˜Jš�œ�œK˜qJš�œ˜J˜
J˜Jšœ�œ˜/Jšœ�œÏc	˜>J˜š
Ïnœ�œ
�œ"�œ�œ˜OJš�œ�œ	˜'Jšœ�œ
˜	Jšœ�œ
˜J˜Jšœ�œ
�œ	˜Jšœ �œ�œ�œ˜Qš�œ�œ
�œ˜J˜&Jš�œ
˜J˜—Jš
œ˜Jš
œ˜š�œ�œ
�œ˜Jš
œA˜AJšœ�œ
˜J˜—Jšœ'�œ�œ˜_š�œ
�œ�œ˜Jš
œ˜Jš�œ
˜J˜—š�œ�œ
�œ.�œ�œ
�˜Lš�œ.�œ@�œ˜yJšœ�œ�œ˜#Jšœ�œ�œ�œ!˜rJš�œ�œ
�œ�œ�œ�œ˜Fš�œ˜J˜"Jš�œ
˜J˜—J˜
—š�œ˜š�œ�œ�˜:Jš�œ:�œ:�œt˜ñ
Jš�œ
˜—Jš
œ˜J˜J˜—Jš�œ
˜—š�œ�œ
�œ5�œ�œ
�˜UJš
œp˜pJ˜Jš�œ
˜—Jš
œ˜J˜ š�œ�œ˜Jš
œ8˜8Jšœ3�œ�œ˜BJ˜ Jšœ�œ
˜J˜—Jš
œ˜Jš
�˜Jšœ�œ
˜J˜—J˜šŸ	œ�œ
�œ!˜7Jš
œ`˜`J˜—J˜šŸœ�œ
�œY�œ�œ�œ�œ�œ˜™
J˜Jšœ�œ
˜J˜Jšœ�œ�œ˜2Jš�œ�œ
�œ
�œ
˜Jšœ�œ!˜)J˜Jšœ
�œ�œ˜Jšœ�œ
�œ
�
œ ˜=J˜ Jšœ�œ
˜	J˜š�œ
�œ�œ�œ˜šœ
�œ�œ�˜"J˜J˜J˜J˜$J˜$J˜&J˜(J˜$J˜$J˜Jš�œ˜—Jš�œ	�œ
�œ-�œ�œ�œ
˜qJ˜—J˜—J˜šŸ
œ�œ
�œ-�œ�œ
�œ�œ�œ�œ%�œ˜©
J˜Jšœ�œ
˜J˜Jšœ�œ�œ˜2Jš�œ�œ
�œ
�œ
˜Jšœ�œ!˜)J˜J˜J˜)š�œ
�œ�œ�œ˜Jš
�œ	�œ
�œ5�œ�œ
˜hJšœ	�œ˜Jš�œ
˜J˜—Jšœ�œ
�œ
�
œ ˜=J˜ Jšœ�œ
˜	J˜—J˜Jš
œB™BšŸœ�œ
�œ)�œ	�œ
�œ
�œ�œ�œ�œ˜‘
Jš�œ�œ	˜'J˜J˜Jšœ�œ
˜Jšœ
�œ
˜Jšœ�œ
�œ
˜Jš�œ�œ
�œ
�œ
�œ
�œ
�œ˜1Jš
œ˜J˜J˜Iš�œ
�œ�œ˜Jš�œ�œ�œ
˜;Jš�œ
�œ˜J˜
—š�œž˜!J˜Jš
�œ�œ%�œ
�œ�œ˜dJ˜7š�œ�œ˜Jšœ#ž˜9J˜DJ˜J˜!Jš�œ�œ�œ�œ˜MJ˜
—š�œ˜Jš�œ�œ*�œ˜JJš�œ
�œ˜J˜—J˜—J˜Jš�œ
�œ˜
Jš
�˜Jšœ�œ
�œ˜J˜—J˜šŸœ�œ
�œ�œ
�œ+�œ
˜^Jš�œ
�œ�œ
˜.Jš�œ�œ�œ�œ�œ�œ
˜RJ˜Jš�œ
�œ�œ
˜.Jš�œ�œ�œ�œ�œ�œ
˜RJ˜J˜—J˜š
Ÿœ�œ�œ
�œ �œ˜GJšœ�œ�œ
˜7J˜J˜—šœ
�œ�œ�œ˜7J˜T—J˜šŸœ�œ
�œ!˜5Jšœ�œ�œ
˜J˜#š�œ�œ
�œ1�œ�œ
�˜Oš�œ#�œ�œ˜/Jšœ�œ
˜
Jš
œ˜Jš�œ
˜J˜—Jš�œ
˜—š�œ�œ˜Jš
œ%˜%JšœY�œ˜_J˜
—Jš�œQ�œ˜[Jš
�œ�œ
�œ4�œ�œ˜\J˜—J˜šŸœ�œ
�œ%�œ�œ�œ�œ�œ�œ˜�
Jš
œ"˜"Jšœ�œ
˜	Jš
œT˜Tš�œ
�œ�œ˜Jš
œ˜Jš
œ&˜&J˜
—š�œ˜Jšœ6�œ�œ˜OJš
�œ�œ
�œ�œ�œ˜nJ˜J˜—š�œ�œ˜Jš�œ�œv�œ
˜…
Jš�œ/�œ˜9J˜—J˜—J˜šŸœ�œ
�œ=˜ZJš
œ˜Jš
œ˜Jš
œ˜Jš
œ;˜;Jš
œ˜Jš
œ˜J˜—J˜šŸœ�œ
�œ �œ˜>Jšœ�œ
˜	Jšœ�œ�œ˜WJšœ�œ
�œ
�
œ˜;J˜Jšœ�œ
˜J˜Jšœ
�œ�œ˜J˜IJš�œ
�œ�œ
�œ
˜Jš
œ#˜#Jšœ
�œ˜Jš
œ
˜
Jš
œ˜J˜+J˜—J˜š
Ÿ	œ�œ
�œ'�œ�œ˜XJšœ�œ
�œ
˜Jšœ�œ
�œ
˜š�œ�œ˜Jšœ-�œ˜BJ™Jš�œ
˜Jš
œ˜—š�œ'�˜1Jšœ�œ
˜!Jšœ9�œ˜NJšœ6�œ˜KJš�œ�œ
˜—š�œ�œ˜Jšœ	�œ
˜
Jš
œC˜CJšœ$�œ�œ˜OJ™#Jš
œI˜IJ•StartOfExpansion>[s1: 
ROPE, s2: 
ROPE, pos1: 
INT _ 0, case: 
BOOL _ TRUE]šœ;�œ˜BJš�œ�œB˜VJ˜—Jš
œ1˜1š�œ	�œ˜Jšœ�œ
˜Jš
œ:˜:Jš�œ�œ˜)Jš
œ"˜"J˜—š�œ�œ˜J˜š�œ�œ˜"Jš
œ1˜1š�œ�œ
�œ˜Jš
œm˜mJš�œ�œ
�œ+˜@J˜—š�œ�œ
�œ˜Jš
œ˜Jš
œ!˜!Jšœ+�œ!˜NJ˜
—Jš�œE˜IJš
œ,™,Jš
œ6˜6Jš
œ1˜1š�œ�œ
�œ˜Jšœ`�œ˜zJš�œ�œ
�œ+˜@J˜—š�œ�œ
�œ˜Jš
œ˜Jš
œ!˜!Jšœ3�œ&˜[J˜—J˜—J˜—J˜—J˜šŸœ�œ
�œ)�œ�œ
�œ�œ˜fJšœ�œ	�œ˜=š�œ�œ
�œ˜Jš
œ˜Jš
œ˜J˜
—Jš�œ˜Jš�œ�œ˜+J˜—J˜šŸœ�œ
�œF�œ
�œ�œ�œ	�œ�œ˜­
Jšœ�œ
�œ
˜Jšœ
�œ
˜Jš
œ$˜$Jšœ�œ�œ˜FJš
œ˜J˜Jš
œ'˜'Jšœ?�œ�œ�œ˜‡
š�œ�œ�˜-J˜/J˜ J˜#Jš�œ
�œ
˜—š�œ�œ�˜-J˜/J˜)J˜<Jš�œ�œ
˜—J˜š�œ�œ˜J˜J˜J˜J˜—Jšœ+�œ�œ�œ˜qJš�œ
�œ�œ@˜QJš
œ˜Jš�œ�œ
�œ%˜>J˜—J˜šŸœ�œ
�œq˜Œ
Jš�œ�œ	˜'Jšœ�œ
�œ˜Jš
œ˜Jšœ�œ
˜J˜#Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜	Jš
œ˜Jš
œ˜Jšœ�œ
˜š�œ�œ˜%JšœK�œ˜RJ˜š�œ
�œ�œ˜JšœN�œ˜UJ˜š�œ�œ˜Jšœ'�œ˜+Jš
œ˜J˜
—š�œ˜Jš
œ,˜,Jš
œ'˜'Jšœ�œ˜*Jšœ�œ˜*š�œ�œ
�œ.�œ�œ
�˜LJš�œ �œ ˜FJš�œ/�œ/˜dJš�œ
˜—J˜—J˜
—š�œ˜Jšœ'�œ˜+Jš
œ˜J˜—J˜—Jš	œ5�œ�œ�œ�œ˜˜
Jš
œ˜š�œ�œ
�œ.�œ�œ
�˜LJš�œ�œ
�œ
˜#Jš
œ˜Jš
œ˜š�œ �œ˜(Jš�œ-�œ
�œ
˜9Jš
œ;˜;Jš
œ˜J˜—š�œ,�œ˜4Jš�œ�œ
�œ
˜+Jš
œ+˜+J˜—Jš
�œ�œ
�œ�œ�œ'˜\Jš
œ˜Jšœ�œ�œ˜Jšœ�œ�œ�œ˜jš�œ�œ˜Jšœ�œ�œ�œ�œ
�œ�œ�œ˜hJ˜
—š�œ˜Jš
œ'˜'Jš�œ
˜J˜—š�œ�œ
�œ�˜$Jš�œ�œ
�œ
˜#š�œ5�œ˜=Jšœ+�œ�œ�œ3˜‰
Jš
œ˜J˜—Jš�œ
˜—Jš�œ
˜—Jšœ�œ
˜Jš
œ˜Jš
�˜Jšœ�œ
˜J˜—J˜J˜Jšœ�œ$˜@Jšœ�œ˜-Jšœ�œ
˜+—…—>ªQ—