DIRECTORY
AdobeP75V2,
AdobeP75V2Aux,
Basics USING [ ],
Commander USING [CommandProc, Handle, Register],
CrRPC USING [BulkDataSink, CreateClientHandle, DestroyClientHandle, Handle],
IO,
Rope USING [ROPE],
XNS USING [Address, unknownAddress],
XNSAdobeClientOps,
XNSCH USING [LookupAddressFromRope],
XNSCHName USING [Name, RopeFromName];

XNSAdobeTestImpl: CEDAR MONITOR
IMPORTS AdobeP75V2, AdobeP75V2Aux, Commander, CrRPC, IO, XNSCH, XNSCHName
EXPORTS XNSAdobeClientOps ~ {
OPEN Adobe2: AdobeP75V2;
ROPE: TYPE ~ Rope.ROPE;

crAtom: ATOM ~ IF ( BYTES[WORD] = 2 ) THEN $SPP ELSE $CMUX;
UnknownAddress: PUBLIC ERROR ~ CODE;
StubError: PUBLIC ERROR [whatsUp: ROPE] ~ CODE;

RemoteOperation: TYPE ~ PROC [crH: CrRPC.Handle];
Guarded: PROC [server: ROPE, op: RemoteOperation] ~ {
ENABLE {
UNWIND => { NULL };
Adobe2.Error => {
whatsUp: ROPE ~ IO.PutFR1["Adobe2.Error[code: (%g)]", IO.card[why.ORD] ];
ERROR StubError[whatsUp];
};
};
qualified: XNSCHName.Name; add: XNS.Address;
[qualified, add] ¬ XNSCH.LookupAddressFromRope[server];
IF ( add = XNS.unknownAddress ) THEN ERROR UnknownAddress;
{
name: ROPE ~ XNSCHName.RopeFromName[qualified];
address: REF XNS.Address ~ NEW[XNS.Address ¬ add];
crH: CrRPC.Handle ~ CrRPC.CreateClientHandle[crAtom, address];
op[crH];
CrRPC.DestroyClientHandle[crH];
};
};
ListDatabases: PUBLIC PROC [server: ROPE]
RETURNS [systems: Adobe2.DatabaseSequence] ~ {
ListDatabasesOp: RemoteOperation ~ {
systems ¬ Adobe2.GetResidentSystems[crH];
};
Guarded[server, ListDatabasesOp];
};
GetDatabaseDescription: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
RETURNS [description: Adobe2.Description] ~ {
GetDatabaseDescriptionOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
description ¬ Adobe2.GetSystemDescription[crH, target];
};
Guarded[server, GetDatabaseDescriptionOp];
};

GetLocationOfARs: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
RETURNS [referenceToARs: Adobe2.NSName] ~ {
GetLocationOfARsOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
referenceToARs ¬ Adobe2.GetLocationOfARs[crH, target];
};
Guarded[server, GetLocationOfARsOp];
};

GetVersion: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
RETURNS [version: Adobe2.ARVersion ¬ 0]~ {
GetVersionOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
version ¬ Adobe2.GetVersion[crH, target];
};
Guarded[server, GetVersionOp];
};

LookupARs: PUBLIC PROC [server: ROPE, system: Adobe2.Database, 
version: Adobe2.ARVersion, fieldName: ROPE, value: Adobe2.FieldItemQueryValue, 
set: Adobe2.SetOfARs] RETURNS [s: Adobe2.SetOfARs] ~ {
LookupARsOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
instance: Adobe2.StaticTarget ~ [target, version];
query: Adobe2.QueryItem ¬ [fieldName, value];
boundSet: Adobe2.SetOfARs ¬ set;
s ¬ Adobe2.LookupARs[crH, instance, query, boundSet];
};
Guarded[server, LookupARsOp];
};

ReadLastARNumber: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
RETURNS [lastAR: Adobe2.ARNumber ¬ 0] ~ {
ReadLastARNumberOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
lastAR ¬ Adobe2.ReadLastARNumber[crH, target];
};
Guarded[server, ReadLastARNumberOp];
};

GetAcceleratorInfo: PUBLIC PROC [server: ROPE, system: Adobe2.Database, version: CARD32, arSet: Adobe2.SetOfARs, fieldList: Adobe2.FieldList, to: CrRPC.BulkDataSink] ~ {
GetAcceleratorInfoOp: RemoteOperation ~ {
instance: Adobe2.StaticTarget ~ [[system], version];
Adobe2.GetAcceleratorInfo[crH, instance, arSet, fieldList, to];
};
Guarded[server, GetAcceleratorInfoOp];
};

GetSystemDefaultUserFile: PUBLIC PROC [server: ROPE, system: Adobe2.Database, to: CrRPC.BulkDataSink] ~ {
GetSystemDefaultUserFileOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
Adobe2.GetSystemDefaultUserFile[crH, target, to];
};
Guarded[server, GetSystemDefaultUserFileOp];
};
AboutToStore: PUBLIC PROC [server: ROPE, system: Adobe2.Database, version: CARD32, arNumber: CARD32] ~ {
AboutToStoreOp: RemoteOperation ~ {
instance: Adobe2.StaticTarget ~ [[system], version];
Adobe2.AboutToStore[crH, instance, arNumber];
};
Guarded[server, AboutToStoreOp];
};

SubmitFailed: PUBLIC PROC [server: ROPE, system: Adobe2.Database, version: CARD32, arNumber: CARD32] ~ {
SubmitFailedOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
Adobe2.SubmitFailed[crH, target, version, arNumber];
};
Guarded[server, SubmitFailedOp];
};

UpdateAcceleratorField: PUBLIC PROC [server: ROPE, system: Adobe2.Database, version: CARD32, arNumber: CARD32, field: Adobe2.FieldItemValue, fieldName: ROPE] ~ {
UpdateAcceleratorFieldOp: RemoteOperation ~ {
instance: Adobe2.StaticTarget ~ [[system], version];
Adobe2.UpdateAcceleratorField[crH, instance, arNumber, field, fieldName];
};
Guarded[server, UpdateAcceleratorFieldOp];
};

GetNextSubmitNumber: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
RETURNS [submitNumber: Adobe2.SubmitNumber ¬ 0] ~ {
GetNextSubmitNumberOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
submitNumber ¬ Adobe2.GetNextSubmitNumber[crH, target];
};
Guarded[server, GetNextSubmitNumberOp];
};

PutSubmitNumber: PUBLIC PROC [server: ROPE, system: Adobe2.Database,
submitNumber: Adobe2.SubmitNumber] ~ {
PutSubmitNumberOp: RemoteOperation ~ {
target: Adobe2.Target ~ [system];
Adobe2.PutSubmitNumber[crH, target, submitNumber];
};
Guarded[server, PutSubmitNumberOp];
};
server: PUBLIC ROPE ¬ "PCAService:OSBU North:Xerox";
system: PUBLIC Adobe2.Database ¬ "AdobePortTest";
version: PUBLIC Adobe2.ARVersion ¬ 1;
ListDatabasesCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
systems: Adobe2.DatabaseSequence ¬ ListDatabases[server];
cmd.out.PutF1[" systems:\n", IO.rope[server] ];
FOR i: CARDINAL IN [0..systems.length] DO
cmd.out.PutF1["  %g\n", IO.rope[systems.body[i]] ];
ENDLOOP;
};
EXITS Failed => { result ¬ $Failure };
};
FieldTypeName: ARRAY Adobe2.FieldType OF ROPE ¬
["ar(0)", "time(1)", "numeric(2)", "bounded(3)", "enumerated(4)", "string(5)"];

PrintFieldList: PROC [out: IO.STREAM, fieldList: Adobe2.FieldList] ~ {
FOR i: CARDINAL IN [0..fieldList.length) DO
item: Adobe2.FieldItemObject ~ fieldList.flSeq[i];
type: Adobe2.FieldType ~ item.type;
rope: ROPE ~ AdobeP75V2Aux.ExposeFieldItem[item, 1];
out.PutF["(%g) [%g]\n", IO.card[i], IO.rope[rope] ];
ENDLOOP;
};

GetDatabaseDescriptionCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
description: Adobe2.Description ¬ GetDatabaseDescription[server, system];
cmd.out.PutRope[" Description:\n"];
cmd.out.PutF1["  name:\t%g\n", IO.rope[description.name] ];
cmd.out.PutF1["  host:\t%g\n", IO.rope[description.host] ];
cmd.out.PutF1["  directory:\t%g\n", IO.rope[description.directory] ];
cmd.out.PutF1["  version:\t%g\n", IO.card[description.version] ];
cmd.out.PutF1["  fieldList:\t(%g) [\n", IO.card[description.fieldList.length] ];
PrintFieldList[cmd.out, description.fieldList];
cmd.out.PutRope["\t]\n"];
};
EXITS Failed => { result ¬ $Failure };
};

GetLocationOfARsCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
referenceToARs: Adobe2.NSName ¬ GetLocationOfARs[server, system];
cmd.out.PutF[" Location of ARs:  %g:%g:%g\n", IO.rope[referenceToARs.local], IO.rope[referenceToARs.domain], IO.rope[referenceToARs.org]];
};
EXITS Failed => { result ¬ $Failure };
};

GetVersionCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
version: Adobe2.ARVersion ¬ GetVersion[server, system];
cmd.out.PutF1[" version: %g\n", IO.card[version] ];
};
EXITS Failed => { result ¬ $Failure };
};

ReadLastARNumberCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
lastAR: Adobe2.ARNumber ¬ ReadLastARNumber[server, system];
cmd.out.PutF1[" lastAR: %g\n", IO.card[lastAR] ];
};
EXITS Failed => { result ¬ $Failure };
};
currentAR: Adobe2.SubmitNumber ¬ 11;

GetNextSubmitNumberCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
target: Adobe2.Target ~ [system];
submitNumber: Adobe2.SubmitNumber ¬ GetNextSubmitNumber[server, target];
cmd.out.PutF1[" NextSubmitNumber: %g\n", IO.card[submitNumber] ];
currentAR ¬ submitNumber;
};
EXITS Failed => { result ¬ $Failure };
};

PutSubmitNumberCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
submitNumber: Adobe2.SubmitNumber ¬ currentAR;
PutSubmitNumber[server, system, submitNumber];
cmd.out.PutF1[" PutSubmitNumber: %g\n", IO.card[submitNumber] ];
};
currentAR ¬ currentAR.PRED; -- why?
EXITS Failed => { result ¬ $Failure };
};

NumQueryCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
value: Adobe2.FieldItemQueryValue ¬ [greaterThanOrEqual, 
NEW[Adobe2.FieldItemValueRec.numeric ¬ [numeric[35]]]];
arSet: Adobe2.SetOfARs ¬ NEW[Adobe2.SetOfARsObject[1]];
arSet[0] ¬ [1,5];
arSet ¬ LookupARs[server, system, version, "Age", value, arSet];
cmd.out.PutRope[" result: \n"];
FOR i: CARD IN [0..arSet.len) DO
cmd.out.PutF["   %g-%g\n", IO.card[arSet[i].startValue], IO.card[arSet[i].startValue + arSet[i].runLength - 1] ];
ENDLOOP;
};
EXITS Failed => { result ¬ $Failure };
};

ARQueryCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
value: Adobe2.FieldItemQueryValue ¬ [greaterThanOrEqual, 
NEW[Adobe2.FieldItemValueRec.arId ¬ [arId[3]]]];
arSet: Adobe2.SetOfARs ¬ NEW[Adobe2.SetOfARsObject[1]];
arSet[0] ¬ [1,5];
arSet ¬ LookupARs[server, system, version, "Number", value, arSet];
cmd.out.PutRope[" result: \n"];
FOR i: CARD IN [0..arSet.len) DO
cmd.out.PutF["   %g-%g\n", IO.card[arSet[i].startValue], IO.card[arSet[i].startValue + arSet[i].runLength - 1] ];
ENDLOOP;
};
EXITS Failed => { result ¬ $Failure };
};

EnumQueryCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
value: Adobe2.FieldItemQueryValue ¬ [equal, 
NEW[Adobe2.FieldItemValueRec.enumerated ¬ [enumerated[2]]]];
arSet: Adobe2.SetOfARs ¬ NEW[Adobe2.SetOfARsObject[1]];
arSet[0] ¬ [1,5];
arSet ¬ LookupARs[server, system, version, "System", value, arSet];
cmd.out.PutRope[" result: \n"];
FOR i: CARD IN [0..arSet.len) DO
cmd.out.PutF["   %g-%g\n", IO.card[arSet[i].startValue], IO.card[arSet[i].startValue + arSet[i].runLength - 1] ];
ENDLOOP;
};
EXITS Failed => { result ¬ $Failure };
};

FixQueryCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
value: Adobe2.FieldItemQueryValue ¬ [in, 
NEW[Adobe2.FieldItemValueRec.fixedLengthString ¬ [fixedLengthString["pj", 60]]]];
arSet: Adobe2.SetOfARs ¬ NEW[Adobe2.SetOfARsObject[1]];
arSet[0] ¬ [1,5];
arSet ¬ LookupARs[server, system, version, "Assigned To", value, arSet];
cmd.out.PutRope[" result: \n"];
FOR i: CARD IN [0..arSet.len) DO
cmd.out.PutF["   %g-%g\n", IO.card[arSet[i].startValue], IO.card[arSet[i].startValue + arSet[i].runLength - 1] ];
ENDLOOP;
};
EXITS Failed => { result ¬ $Failure };
};

PutC: PROCEDURE [c: CHAR] ~ {
SELECT c FROM
IN['A..'Z], 
IN['a..'z],
IN['0..'9] => globalCmd.out.PutF1["%g ", IO.char[c]];
ENDCASE => globalCmd.out.PutF1["/%gD ", IO.card[ORD[c]]];
};

To: CrRPC.BulkDataSink ~ {
len, line, field: CARD ¬ 0;
b1, b2: CARD ¬ 0;
IF checkAbort[h] THEN {
globalCmd.out.PutRope["Instant Abort.\n"];
RETURN[FALSE];
};
IF IO.EndOf[s] THEN  {
globalCmd.out.PutRope["Empty stream.\n"];
RETURN[FALSE];
};
line ¬ 1;
WHILE NOT IO.EndOf[s] DO
IF field > 3 THEN {
field ¬ 0;
line ¬ line + 1;
IO.PutF1[globalCmd.out, "line: %g\n", IO.card[line]];
};
IO.PutF1[globalCmd.out, "\tfield: %g ", IO.card[field]];
b1 ¬ ORD[IO.GetByte[s]];
b2 ¬ ORD[IO.GetByte[s]];
IO.PutF[globalCmd.out, "\b1: %g b2: %g", IO.card[b1], IO.card[b2]];
len ¬ (b1 * (ORD[LAST[CHAR]] + 1)) + b2;
IO.PutF1[globalCmd.out, "(len = %g)\n", IO.card[len]];
FOR i: CARD IN  [0..len) DO
PutC[IO.GetChar[s]];
ENDLOOP;
IO.PutRope[globalCmd.out, "\n"];
IF (len MOD 2) = 1 THEN
[] ¬ IO.GetChar[s];
ENDLOOP;
RETURN[FALSE];
};

globalCmd: Commander.Handle ¬ NIL;

GetAccInfoCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
arSet: Adobe2.SetOfARs ¬ NEW[Adobe2.SetOfARsObject[1]];
fieldList: Adobe2.FieldList ¬ NEW[Adobe2.FieldListArray[4]];
globalCmd ¬ cmd;
fieldList[0]¬ NEW[Adobe2.FieldItemObjectRec.arId];
fieldList[0].name ¬ "Number";
fieldList[1]¬ NEW[Adobe2.FieldItemObjectRec.arId];
fieldList[1].name ¬ "System";
fieldList[2]¬ NEW[Adobe2.FieldItemObjectRec.arId];
fieldList[2].name ¬ "Subsystem";
fieldList[3]¬ NEW[Adobe2.FieldItemObjectRec.arId];
fieldList[3].name ¬ "Subject";
arSet[0] ¬ [1,5];

GetAcceleratorInfo[server, system, version, arSet, fieldList, To];
};
EXITS Failed => { result ¬ $Failure };
};

GetDefaultUserFileCommand: Commander.CommandProc ~ {
cmd.out.PutF1["server: %g\n", IO.rope[server] ];
cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
{
ENABLE {
StubError=> { msg ¬ whatsUp; GOTO Failed };
UnknownAddress => { msg ¬ "UnknownAddress"; GOTO Failed };
};
GDUSink: CrRPC.BulkDataSink = {
IF checkAbort[h] THEN {
cmd.out.PutRope["Instant Abort.\n"];
RETURN[FALSE];
};
IF IO.EndOf[s] THEN  {
cmd.out.PutRope["Empty stream.\n"];
RETURN[FALSE];
};
WHILE NOT IO.EndOf[s] DO
cmd.out.PutF1["%g ", IO.char[IO.GetChar[s]]];
ENDLOOP;
RETURN[FALSE];
};

GetSystemDefaultUserFile[server, system, GDUSink];
};
EXITS Failed => { result ¬ $Failure };
};

Init: PROC ~ {
Commander.Register["XNSAdobe.GetDatabaseDescription", GetDatabaseDescriptionCommand];
Commander.Register["XNSAdobe.GetDefaultUserFile", GetDefaultUserFileCommand];
Commander.Register["XNSAdobe.GetLocationOfARs", GetLocationOfARsCommand];
Commander.Register["XNSAdobe.GetNextSubmitNumber", GetNextSubmitNumberCommand];
Commander.Register["XNSAdobe.GetVersion", GetVersionCommand];
Commander.Register["XNSAdobe.ListDatabases", ListDatabasesCommand];
Commander.Register["XNSAdobe.PutSubmitNumber", PutSubmitNumberCommand];
Commander.Register["XNSAdobe.ReadLastARNumber", ReadLastARNumberCommand];
Commander.Register["XNSAdobe.NumQuery", NumQueryCommand];
Commander.Register["XNSAdobe.ARQuery", ARQueryCommand];
Commander.Register["XNSAdobe.EnumQuery", EnumQueryCommand];
Commander.Register["XNSAdobe.FixQuery", FixQueryCommand];
Commander.Register["XNSAdobe.GetAccInfo", GetAccInfoCommand];
};

Init[];
}.

ξ
XNSAdobeTestImpl.mesa
Copyright Σ 1990, 1992 by Xerox Corporation.  All rights reserved.
Bill Jackson (bj), March 28, 1990 5:45 pm PST
Philip James, March 20, 1991 9:25 am PST
Christian Jacobi, April 7, 1992 4:57 pm PDT

 USING [ARVersion, Database, DatabaseSequence, GetResidentSystems, GetVersion, Target],
Errors
realId: XNSAuth.Identity ~ UserCredentials.GetIdentity[];
conversation: XNSAuth.Conversation ~ XNSAuth.Initiate[realId, qualified];
credentials: XNSAuth.Credentials ~ XNSAuth.GetCredentials[conversation];
verifier: XNSAuth.Verifier;
XNSAuth.SetRecipientHostNumber[conversation, address.host];
verifier _ XNSAuth.GetNextVerifier[conversation];
Remote Operations (simple)
Remote Operations (system)
Remote Operations (more complex)
Some manifest constants/values
Commander Operations (simple ops)
Commander Operations (system)
Commander Operations (using state)
cmd.out.PutF[" target/database: %g(%g)\n", IO.rope[system], IO.card[version] ];
instance: Adobe2.StaticTarget ~ [target, version];
accInfo: Adobe2.AcceleratorInfo _ NIL;
FOR i: CARD IN [0..accInfo.len) DO
IO.PutF[cmd.out, "AR #%g\n", IO.card[i]];
FOR j: CARD IN [0..accInfo[i].len) DO
IO.PutF[cmd.out, "\tField #%g: %g\n", IO.card[j], IO.rope[accInfo[i][j]]];
ENDLOOP;
ENDLOOP;
Κί–
(cedarcode) style•NewlineDelimiter

™š
œ™Jšœ
Οe
œ7™BJ™-J™(J™+J™—
codeš
Οk	˜	š
œ˜Kšœ
žœQ™W—Kš
œ˜Kšœžœ˜Kšœ
žœ!˜0KšœžœA˜LKšžœ
˜Kšœžœžœ˜Kšžœ
žœ˜$Kš
œ˜Kšžœ
žœ˜$Kšœ
žœ˜%K˜—šΟnœžœ
ž˜Kšžœ.žœžœ˜IKšžœ˜Kšžœ
Ÿœ
˜Kšžœžœžœ
˜K˜Kš
œžœžœžœ
žœžœžœ˜;
headš
Οz™KšŸœžœ
žœžœ
˜$Kš
Ÿ	œžœ
žœžœžœ
˜/K˜Kšœžœžœ˜1šŸœžœ
žœ˜5šžœ˜Kšžœžœ˜š
œ˜Kš	œ	žœžœ$žœ
žœ˜IKšžœ˜Kš
œ˜—K˜—Kšœ žœ	˜,Kšœžœ˜7Kšžœ	žœžœ
žœ˜:š
œ
˜
Kšœžœ%˜/Kš	œ	žœ
žœžœ
žœ˜2š
œ>˜>Kš
œ9™9Kš
œI™IKš
œH™HKš
œ™Kš
œ;™;Kš
œ1™1—Kš
œ˜Kš
œ˜K˜—Kš
œ˜——š
 ™š
Ÿ
œžœ
žœ
žœžœ'˜XšŸœ˜$K˜)Kš
œ˜—Kš
œ!˜!Kš
œ˜——š
 ™š
Ÿœžœ
žœ
žœžœ&˜yšŸœ˜-Kš
œ!˜!K˜7K˜—Kš
œ*˜*K˜K˜—š
Ÿœžœ
žœ
žœžœ$˜qšŸœ˜'Kš
œ!˜!K˜6K˜—Kš
œ$˜$K˜K˜—š
Ÿ
œžœ
žœ
žœžœ#˜jšŸœ˜!Kš
œ!˜!K˜)K˜—Kš
œ˜K˜K˜—šŸ	œžœ
žœ
žœBžœ<žœ˜Ζ
šŸœ˜ K˜!K˜2K˜-K˜ K˜5K˜—Kš
œ˜K˜K˜—š
Ÿœžœ
žœ
žœžœ"˜ošŸœ˜'Kš
œ!˜!K˜.K˜—Kš
œ$˜$K˜K˜—š
Ÿœžœ
žœ
žœ$žœR˜©
šŸœ˜)Kš
œ4˜4Kš
œ?˜?K˜—Kš
œ&˜&K˜K˜—šŸœžœ
žœ
žœ6˜išŸœ˜/Kš
œ!˜!Kš
œ1˜1K˜—Kš
œ,˜,K˜——š
  ™ šŸœžœ
žœ
žœ$žœžœ˜hšŸœ˜#K˜4Kš
œ-˜-K˜—Kš
œ ˜ ˜K˜——šŸœžœ
žœ
žœ$žœžœ˜hšŸœ˜#Kš
œ!˜!Kš
œ4˜4K˜—Kš
œ ˜ ˜K˜——šŸœžœ
žœ
žœ$žœžœ+žœ˜‘
šŸœ˜-K˜4Kš
œI˜IK˜—Kš
œ*˜*˜K˜——š
Ÿœžœ
žœ
žœžœ,˜|šŸœ˜*Kš
œ!˜!K˜7K˜—Kš
œ'˜'K˜—šŸœžœ
žœ
žœA˜kšŸœ˜&Kš
œ!˜!Kš
œ2˜2K˜—Kš
œ#˜#K˜——š
 ™Kšœžœ
žœ!˜4Kšœžœ#˜1Kšœ	žœ˜%—š
 !™!šŸœ˜/Kšœžœ˜0š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—K˜9Kšœžœ˜/šžœžœ
žœž˜)Kšœžœ˜3Kšžœ
˜—Kš
œ˜—Kšžœ!˜&Kš
œ˜——š
 ™KšŸ
œžœžœ
žœR˜K˜šŸœžœžœ
žœ"˜Fšžœžœ
žœž˜+Kš
œ2˜2Kš
œ#˜#Kšœžœ*˜4Kšœžœ
žœ˜4Kšžœ
˜—K˜K˜—šŸœ˜8Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—K˜IK˜#Kšœžœ˜;Kšœžœ˜;Kšœ$žœ˜EKšœ"žœ˜Ašœ(žœ&˜PKš
œ/˜/K˜—Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœ˜2Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—K˜AKšœ.žœžœžœ˜Š
Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœ˜,Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—K˜7Kšœ žœ˜3Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœ˜2Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—K˜;Kšœžœ˜1Kš
œ˜—Kšžœ!˜&Kš
œ˜——š
 "™"K˜$K˜Jšœ+žœžœ™OKš
œ2™2šŸœ˜5Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—Kš
œ!˜!K˜HKšœ)žœ˜AK˜Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœ˜1Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—K˜.Kš
œ.˜.Kšœ(žœ˜@Kš
œ˜—KšœžœΟc˜#Kšžœ!˜&Kš
œ˜K˜—šŸœ˜*Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—˜9Kšžœ4˜7—Kšœžœ˜7K˜K˜@K˜šžœžœ
žœž˜ Kšœžœžœ6˜qKšžœ
˜—Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœ˜)Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—˜9Kšžœ-˜0—Kšœžœ˜7K˜K˜CK˜šžœžœ
žœž˜ Kšœžœžœ6˜qKšžœ
˜—Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœ˜+Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—˜,Kšžœ9˜<—Kšœžœ˜7K˜K˜CK˜šžœžœ
žœž˜ Kšœžœžœ6˜qKšžœ
˜—Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœ˜*Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—˜)KšžœN˜Q—Kšœžœ˜7K˜K˜HK˜šžœžœ
žœž˜ Kšœžœžœ6˜qKšžœ
˜—Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœž	œžœ˜šžœž˜
Kšžœ
˜Kšžœ	˜Kšžœ'žœ
˜5Kšžœ!žœžœ˜9—K˜K˜—šŸœ˜Kšœžœ˜Kšœžœ˜šžœžœ
ž
˜K˜*Kšžœ
žœ˜K˜—šžœ
žœ
žœ˜K˜)Kšžœ
žœ˜K˜—K˜	šžœ
žœ
žœ
ž˜šžœžœ˜K˜
K˜Kšžœ$žœ
˜5K˜—Kšžœ&žœ˜8Kšœžœ
žœ
˜Kšœžœ
žœ
˜Kšžœ'žœžœ˜CKšœ
žœ
žœ
žœ˜(Kšžœ&žœ˜6šžœžœ
žœž˜Kšœžœ
˜Kšžœ
˜—Kšžœ˜ šžœžœž˜Kšœžœ˜—Kšžœ
˜—Kšžœ
žœ˜Kš
œ˜K˜—Kšœžœ
˜"K˜šŸœ˜,Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—Jšœ"žœ
™&Kšœžœ˜7Kšœžœ˜<K˜Kšœžœ!˜2K˜Kšœžœ!˜2K˜Kšœžœ!˜2K˜ Kšœžœ!˜2K˜K˜K˜Kš
œB˜Bšžœžœ
žœž™"Jšžœžœ
™)šžœžœ
žœž™%Jšžœ$žœ
žœ™JJšžœ
™—Jšžœ
™—Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜—šŸœ˜4Kšœžœ˜0Kšœ(žœ˜:š
œ
˜
šžœ˜Kšœžœ
˜+Kšœ,žœ
˜:Kš
œ˜—šŸœ˜šžœžœ
ž
˜K˜$Kšžœ
žœ˜K˜—šžœ
žœ
žœ˜K˜#Kšžœ
žœ˜K˜—šžœ
žœ
žœ
ž˜Kšœžœžœ˜-Kšžœ
˜—Kšžœ
žœ˜š
œ˜K˜——Kš
œ2˜2Kš
œ˜—Kšžœ!˜&Kš
œ˜K˜——šŸœžœ˜Kš
œU˜UKš
œM˜MKš
œI˜IKš
œO˜OKš
œ=˜=Kš
œC˜CKš
œG˜GKš
œI˜IKš
œ9˜9Kš
œ7˜7Kš
œ;˜;Kš
œ9˜9Kš
œ=˜=K˜K˜—K˜K˜K˜——…—?,Uω