[Pixel]<DragonWare0.1>DragGen>GenDFN.mesa!1

GenDFN.mesa

Peter Kessler, February 20, 1986 5:39:19 pm PST

static char sccsid[] = "@(#)dfn.c 5.1 (Berkeley) 6/4/85";

Russ Atkinson (RRA) September 15, 1986 11:42:16 pm PDT

DIRECTORY

CmdIO USING [Out],

Rope USING [ROPE, Equal];

DIRECTORY

HandCoding, HandCodingPseudos, HandCodingSupport, HandCodingComforts, DragOpsCross, DragOpsCrossUtils, LizardHeart, LizardTweaker,

IO, ViewerIO;

dfnImpl: -- CEDAR -- PROGRAM

GenDFN: CEDAR PROGRAM

IMPORTS CmdIO, Rope EXPORTS dfn

IMPORTS

HandCoding, HandCodingPseudos, HandCodingSupport, HandCodingComforts, DragOpsCrossUtils, LizardHeart, LizardTweaker,

IO, ViewerIO

= {

fdfnImpl: HandCodingComforts.DataLabel;

this is the label for the global frame (in data space).

nlType: TYPE = -- a node (an entry in the namelist)

RECORD[

name, -- for identification

oname: INT = 0;

cSIZEname: INT = HandCodingComforts.SizeOfINT;

children: arcTypeRef, -- list of arcs to children

ochildren: INT = oname + cSIZEname;

cSIZEchildren: INT = HandCodingComforts.SizeOfLongPointer;

cyclehead: nlTypeRef, -- pointer to the head of this cycle, or pointer to self

ocyclehead: INT = ochildren + cSIZEchildren;

cSIZEcyclehead: INT = HandCodingComforts.SizeOfLongPointer;

cnext: nlTypeRef, -- pointer to next member of cycle

ocnext: INT = ocyclehead + cSIZEcyclehead;

cSIZEcnext: INT = HandCodingComforts.SizeOfLongPointer;

nlnext: nlTypeRef, -- chain of all the nl entries

onlnext: INT = ocnext + cSIZEcnext;

cSIZEnlnext: INT = HandCodingComforts.SizeOfLongPointer;

toporder: dfnNumber -- topological ordering number

otoporder: INT = onlnext + cSIZEnlnext;

cSIZEtoporder: INT = HandCodingComforts.SizeOfINT;

];

cSIZEnlType: INT = otoporder + cSIZEtoporder;

nlTypeRef: TYPE = LONG POINTER TO nlType;

cSIZEnlTypeRef: INT = HandCodingComforts.SizeOfLongPointer;

arcType: TYPE = -- an arc

RECORD[

arcChildp: nlTypeRef, -- pointer to the child of this arc

oarcChildp: INT = 0;

cSIZEarcChildp: INT = HandCodingComforts.SizeOfLongPointer;

arcChildlist: arcTypeRef -- chain of children of this parent

oarcChildlist: INT = oarcChildp + cSIZEarcChildp;

cSIZEarcChildlist: INT = HandCodingComforts.SizeOfLongPointer;

];

cSIZEarcType: INT = oarcChildlist + cSIZEarcChildlist;

arcTypeRef: TYPE = LONG POINTER TO arcType;

cSIZEarcTypeRef: INT = HandCodingComforts.SizeOfLongPointer;

dfnNumber: TYPE = INT ← DFNNaN;

DFNNaN: dfnNumber = 0; -- used to mark depth first numbers that aren't set yet.

cDFNNaN: INT = 0;

DFNBusy: dfn.dfnNumber = -1; -- used to mark depth-first numbers that are being set.

cDFNBusy: INT = -1;

dfnstruct: TYPE = RECORD[ -- elements of the depth first numbering stack.

nlentryp: dfn.nlTypeRef,

onlentryp: INT = 0;

cSIZEnlentryp: INT = HandCodingComforts.SizeOfLongPointer;

cycletop: INT

ocycletop: INT = onlentryp + cSIZEnlentryp;

cSIZEcycletop: INT = HandCodingComforts.SizeOfINT;

];

cSIZEdfnstruct: INT = ocycletop + cSIZEcycletop;

dfntype: TYPE = dfnstruct;

-- what is it about C that requires this separate type declaration?

-- not wanting to type `struct dfnstruct' as a type.

cSIZEdfntype: INT = cSIZEdfnstruct;

DFNMaxDepth: INT = 100; -- the maximum depth of the depth first numbering stack.

cDFNMaxDepth: INT = 100;

nlMax: INT = 101;

cnlMax: INT = 101;

arcMax: INT = 600;

carcMax: INT = 600;

I have sorted the entries in the global frame to put the long ones out past what can be accessed with AlphaZ offsets. This code still assumes that procedures that access things in the global frame load the address of the global frame into a register and use LRI with an AlphaZ offset to fetch the datum. That is

LIQB @GlobalFrame

SR rGlobalFramePointer

...

LRI rGlobalFramePointer, oVariableOffset

If the offset doesn't fit in an AlphaZ, the fetch becomes

LR rGlobalFramePointer

LIQB oVariableOffset

An alternative is to have the loader be smart enough to fill in LIQB's with relative addresses, not just absolutes, and then one could use

LIQB @GlobalFrame+oVariableOffset

RB 0

As it turns out, all the offsets that don't fit in AlphaZ's are offsets of arrays, which get added to the address of the global frame (this could be avoided by the smarter loader) and so can just use ADDDB's instead of ADDB's. If frames get bigger than 65K, ADDDB won't work either, and we'll have to fall back on LIQB;ADD. The point is to track that the register with the address of the global frame is a (load time) constant, and have the loader do the add at load time.

oFirst: INT = 0;

dfnCounter: dfn.dfnNumber ← dfn.DFNNaN;

odfnCounter: INT = oFirst;

cSIZEdfnCounter: INT = HandCodingComforts.SizeOfINT;

dfnDepth: INT ← 0;

odfnDepth: INT = odfnCounter + cSIZEdfnCounter;

cSIZEdfnDepth: INT = HandCodingComforts.SizeOfINT;

nlAvail: INT [0 .. nlMax) ← 0;

onlAvail: INT = odfnDepth + cSIZEdfnDepth;

cSIZEnlAvail: INT = HandCodingComforts.SizeOfINT;

arcAvail: INT [0 .. arcMax) ← 0;

oarcAvail: INT = onlAvail + cSIZEnlAvail;

cSIZEarcAvail: INT = HandCodingComforts.SizeOfINT;

nodeWorld: dfn.nlTypeRef ← NIL;

onodeWorld: INT = oarcAvail + cSIZEarcAvail;

cSIZEnodeWorld: INT = HandCodingComforts.SizeOfLongPointer;

dfnStack: ARRAY [0 .. DFNMaxDepth) OF dfntype;

odfnStack: INT = onodeWorld + cSIZEnodeWorld;

cSIZEdfnStack: INT = cDFNMaxDepth * cSIZEdfntype;

nlZone: ARRAY [0 .. nlMax) OF dfn.nlType;

onlZone: INT = odfnStack + cSIZEdfnStack;

cSIZEnlZone: INT = cnlMax * cSIZEnlType;

arcZone: ARRAY [0 .. arcMax) OF dfn.arcType;

oarcZone: INT = onlZone + cSIZEnlZone;

cSIZEarcZone: INT = carcMax * cSIZEarcType;

oLast: INT = oarcZone + cSIZEarcZone;

out: ViewerIO.STREAM ← NIL;

DepthFirstNumber: PROC [parentp: dfn.nlTypeRef] RETURNS [BOOL] = {

lDepthFirstNumber: HandCodingPseudos.Label;

DepthFirstNumber: HandCodingComforts.Proc = {

rparentp: HandCoding.RegSpec = HandCoding.reg0;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.DepthFirstNumber", lDepthFirstNumber, 1];

IF dfnNumbered[childp: parentp] THEN {

-- if we're already numbered, no need to look any furthur.

RETURN [TRUE];

};

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRn [rparentp];

HandCodingComforts.iLFC [ldfnNumbered];

HandCodingComforts.iJNEj [HandCodingComforts.TRUEByte, lcontinue];

HandCodingComforts.LoadConstant [HandCodingComforts.TRUEValue];

previous two instructions could be

RJNE Stack[S], Constants[TRUE], continue

HandCodingComforts.iJB [lreturn];

HandCodingPseudos.SetLabel[lcontinue];

};

IF dfnBusy[childp: parentp] THEN {

-- if we're already busy, must be a cycle

RETURN [dfnFindcycle[parentp]];

};

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRn [rparentp];

HandCodingComforts.iLFC [ldfnBusy];

HandCodingComforts.iJNEj [HandCodingComforts.TRUEByte, lcontinue];

HandCoding.drLRn [rparentp];

HandCodingComforts.iLFC [ldfnFindcycle];

HandCodingComforts.iJB [lreturn];

HandCodingPseudos.SetLabel[lcontinue];

};

-- visit yourself before your children

IF NOT dfnPreVisit[parentp: parentp] THEN {

RETURN [FALSE];

};

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRn [rparentp];

HandCodingComforts.iLFC [ldfnPreVisit];

HandCodingComforts.iJEQj [HandCodingComforts.TRUEByte, lcontinue];

HandCodingComforts.LoadConstant [HandCodingComforts.FALSEValue];

previous two instructions could be

RJNE Stack[S], Constants[TRUE], continue

HandCodingComforts.iJB [lreturn];

HandCodingPseudos.SetLabel[lcontinue];

};

-- visit children

FOR arcp: dfn.arcTypeRef ← parentp^.children, arcp^.arcChildlist WHILE arcp # NIL DO

IF NOT DepthFirstNumber[parentp: arcp^.arcChildp] THEN {

RETURN [FALSE];

};

ENDLOOP;

{

rarcp: HandCoding.RegSpec = HandCoding.reg1;

lagain: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

ltest: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rparentp, ochildren];

-- HandCoding.drMove [rarcp, HandCoding.popSrc];

HandCodingComforts.iJB [ltest];

HandCodingPseudos.SetLabel[lagain];

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rarcp, oarcChildp];

HandCodingComforts.iLFC [lDepthFirstNumber];

HandCodingComforts.iJEQj [HandCodingComforts.TRUEByte, lcontinue];

HandCodingComforts.LoadConstant [HandCodingComforts.FALSEValue];

HandCodingComforts.iJB [lreturn];

HandCodingPseudos.SetLabel[lcontinue];

};

HandCoding.drRRI [rarcp, rarcp, oarcChildlist];

HandCodingPseudos.SetLabel[ltest];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortNIL, rarcp, lagain];

HandCoding.drDIS [];

};

-- visit yourself after your children

IF NOT dfnPostVisit[parentp: parentp] THEN {

RETURN [FALSE];

};

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRn [rparentp];

HandCodingComforts.iLFC [ldfnPostVisit];

HandCodingComforts.iJEQj [HandCodingComforts.TRUEByte, lcontinue];

HandCodingComforts.LoadConstant [HandCodingComforts.FALSEValue];

HandCodingComforts.iJB [lreturn];

HandCodingPseudos.SetLabel[lcontinue];

};

RETURN [TRUE];

HandCodingComforts.LoadConstant [HandCodingComforts.TRUEValue];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

dfnPreVisit: PROC [parentp: dfn.nlTypeRef] RETURNS [BOOL] = {

ldfnPreVisit: HandCodingPseudos.Label;

dfnPreVisit: HandCodingComforts.Proc = {

rparentp: HandCoding.RegSpec = HandCoding.reg0;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.dfnPreVisit", ldfnPreVisit, 1];

{

rdfnImpl: HandCoding.RegSpec = HandCoding.reg1;

HandCoding.drLIQB [fdfnImpl];

-- HandCoding.drMove [rdfnImpl, HandCoding.popSrc];

-- push a parent onto the stack and mark it busy

dfnDepth ← dfnDepth + 1;

HandCoding.drLRIn [rdfnImpl, odfnDepth];

HandCoding.drADDB [1];

HandCoding.drSRIn [rdfnImpl, odfnDepth];

IF dfnDepth >= DFNMaxDepth THEN {

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLIB [cDFNMaxDepth];

HandCoding.drLRIn [rdfnImpl, odfnDepth];

HandCodingComforts.iRJLTj [HandCodingComforts.ShortpopSrc, HandCoding.belowSrcPop, lcontinue];

CmdIO.Out["[dfn] out of my depth [dfnStack overflow]\n"];

-- HandCoding.drLRIn [rdfnImpl, oformat1];

-- HandCodingComforts.LoadConstant [HandCodingComforts.ConstantNIL];

-- HandCodingComforts.iDFC [lCmdIOOut];

RETURN [FALSE];

HandCodingComforts.LoadConstant [HandCodingComforts.FALSEValue];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lcontinue];

};

dfnStack[dfnDepth].nlentryp ← parentp;

HandCoding.drLRn [rdfnImpl];

HandCoding.drADDB [odfnStack];

HandCoding.drLRIn [rdfnImpl, odfnDepth];

HandCoding.drQADD [topAtop, HandCoding.topSrc];

replace a call to Basics.MixedMultiply

HandCoding.drLIB [cSIZEdfntype];

HandCodingComforts.iDFC [HandCodingPseudos.GetGlobalLabel["Basics.MixedMultiply"]];

HandCoding.drADD [];

HandCoding.drLRn [rparentp];

HandCoding.drWSB [onlentryp];

dfnStack[dfnDepth].cycletop ← dfnDepth;

HandCoding.drLRn [rdfnImpl];

HandCoding.drADDB [odfnStack];

HandCoding.drLRIn [rdfnImpl, odfnDepth];

HandCoding.drQADD [topAtop, HandCoding.topSrc];

replace a call to Basics.MixedMultiply

HandCoding.drLIB [cSIZEdfntype];

HandCodingComforts.iDFC [HandCodingPseudos.GetGlobalLabel["Basics.MixedMultiply"]];

HandCoding.drADD [];

HandCoding.drLRIn [rdfnImpl, odfnDepth];

HandCoding.drWSB [ocycletop];

parentp^.toporder ← DFNBusy;

HandCoding.drLRn [rparentp];

HandCodingComforts.LoadConstant [cDFNBusy];

HandCoding.drWSB [otoporder];

RETURN [TRUE];

HandCodingComforts.LoadConstant [HandCodingComforts.TRUEValue];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

dfnNumbered: PROC [childp: dfn.nlTypeRef] RETURNS [BOOL] = {

-- are we already numbered?

ldfnNumbered: HandCodingPseudos.Label;

dfnNumbered: HandCodingComforts.Proc = {

rchildp: HandCoding.RegSpec = HandCoding.reg0;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.dfnNumbered", ldfnNumbered, 1];

RETURN [childp^.toporder # dfn.DFNNaN AND childp^.toporder # DFNBusy];

{

lelse: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rchildp, otoporder];

HandCodingComforts.iJEQj [cDFNNaN, lelse];

HandCoding.drLRIn [rchildp, otoporder];

HandCodingComforts.iRJEQj [HandCodingComforts.ShortpopSrc, HandCodingComforts.ConstantMinus1, lelse];

HandCodingComforts.LoadConstant [HandCodingComforts.TRUEValue];

HandCodingComforts.iJB [lreturn];

HandCodingPseudos.SetLabel[lelse];

HandCodingComforts.LoadConstant [HandCodingComforts.FALSEValue];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

dfnBusy: PROC [childp: dfn.nlTypeRef] RETURNS [BOOL] = {

-- are we already busy?

ldfnBusy: HandCodingPseudos.Label;

dfnBusy: HandCodingComforts.Proc = {

rchildp: HandCoding.RegSpec = HandCoding.reg0;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.dfnBusy", ldfnBusy, 1];

RETURN [childp^.toporder # dfn.DFNNaN];

{

lequalDFNNaN: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rchildp, otoporder];

HandCodingComforts.iJEQj [cDFNNaN, lequalDFNNaN];

HandCodingComforts.LoadConstant [HandCodingComforts.TRUEValue];

HandCodingComforts.iJB [lreturn];

HandCodingPseudos.SetLabel[lequalDFNNaN];

HandCodingComforts.LoadConstant [HandCodingComforts.FALSEValue];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

dfnFindcycle: PROC [childp: dfn.nlTypeRef] RETURNS [result: BOOL] = {

ldfnFindcycle: HandCodingPseudos.Label;

dfnFindcycle: HandCodingComforts.Proc = {

rchildp: HandCoding.RegSpec = HandCoding.reg0;

rresult: HandCoding.RegSpec = HandCoding.reg1;

result is computed into rresult and at lreturn it is copied to Locals[0].

rdfnImpl: HandCoding.RegSpec = HandCoding.reg2;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.dfnFindcycle", ldfnFindcycle, 1];

HandCodingComforts.LoadConstant [HandCodingComforts.FALSEValue];

-- HandCoding.drMove [rresult, HandCoding.popSrc];

HandCoding.drLIQB [fdfnImpl];

-- HandCoding.drMove [rdfnImpl, HandCoding.popSrc];

{

cycletop: INT;

rcycletop: HandCoding.RegSpec = HandCoding.reg3;

cycleheadp: dfn.nlTypeRef;

rcycleheadp: HandCoding.RegSpec = HandCoding.reg4;

tailp: dfn.nlTypeRef;

rtailp: HandCoding.RegSpec = HandCoding.reg5;

HandCodingComforts.LoadConstant [0];

-- HandCoding.drMove [rcycletop, HandCoding.popSrc];

HandCodingComforts.LoadConstant [HandCodingComforts.NILValue];

-- HandCoding.drMove [rcycleheadp, HandCoding.popSrc];

HandCodingComforts.LoadConstant [HandCodingComforts.NILValue];

-- HandCoding.drMove [tailp, HandCoding.popSrc];

FOR cycletop DECREASING IN (0 .. dfnDepth] DO

{

lafter: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lagain: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

rinitial: HandCoding.RegSpec = HandCoding.reg6;

HandCoding.drLRIn [rdfnImpl, odfnDepth];

-- HandCoding.drMove [rinitial, HandCoding.popSrc];

HandCodingComforts.iRJGTj [HandCodingComforts.Short0, rinitial, lafter];

HandCoding.drROR [rcycletop, rinitial, HandCodingComforts.Constant0];

HandCodingPseudos.SetLabel[lagain];

cycleheadp ← dfnStack[cycletop].nlentryp;

HandCoding.drLRn [rdfnImpl];

HandCoding.drADDB [odfnStack];

HandCoding.drLRn [rcycletop];

HandCoding.drQADD [topAtop, HandCoding.topSrc];

replace a call to Basics.MixedMultiply

HandCoding.drLIB [cSIZEdfntype];

HandCodingComforts.iDFC [HandCodingPseudos.GetGlobalLabel["Basics.MixedMultiply"]];

HandCoding.drADD [];

HandCoding.drRB [onlentryp];

HandCoding.drSRn [rcycleheadp];

IF childp = cycleheadp THEN EXIT;

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRn [rchildp];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortpopSrc, rcycleheadp, lcontinue];

HandCodingComforts.iJB [lafter];

HandCodingPseudos.SetLabel[lcontinue];

};

IF childp^.cyclehead # childp AND childp^.cyclehead = cycleheadp THEN EXIT;

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rchildp, ocyclehead];

HandCodingComforts.iRJEQj [HandCodingComforts.ShortpopSrc, rchildp, lcontinue];

HandCoding.drLRIn [rchildp, ocyclehead];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortpopSrc, rcycleheadp, lcontinue];

HandCodingComforts.iJB [lafter];

HandCodingPseudos.SetLabel[lcontinue];

};

ENDLOOP;

HandCodingComforts.iRJGEj [HandCodingComforts.Short0, rcycletop, lafter];

HandCoding.drRSUB [rcycletop, rcycletop, HandCodingComforts.Constant1];

HandCodingComforts.iJB [lagain];

HandCodingPseudos.SetLabel[lafter];

HandCoding.drDIS [];

};

IF cycletop <= 0 THEN {

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.iRJLTj [HandCodingComforts.Short0, rcycletop, lcontinue];

-- CmdIO.Out["[dfnFindcycle] couldn't find head of cycle\n"];

RETURN [FALSE];

HandCoding.drROR [rresult, HandCodingComforts.ConstantFALSE, HandCodingComforts.Constant0];

this is longer, but faster than,

HandCodingComforts.LoadConstant [HandCodingComforts.FALSEValue];

HandCoding.drSRn [rresult];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lcontinue];

};

IF cycletop = dfnDepth

{

lelse: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rdfnImpl, odfnDepth];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortpopSrc, rcycletop, lelse];

THEN {

-- this is previous function, e.g. this calls itself: sort of boring

result ← dfnSelfCycle[childp];

HandCoding.drLRn [rchildp];

HandCodingComforts.iLFC [ldfnSelfCycle];

HandCoding.drSRn [rresult];

HandCodingComforts.iJB [lcontinue];

};

ELSE {

HandCodingPseudos.SetLabel[lelse];

-- glom intervening functions that aren't already glommed into this cycle.

-- things have been glommed when their cyclehead field points to the head of the cycle they are glommed into.

FOR tailp ← cycleheadp, tailp^.cnext WHILE tailp^.cnext # NIL DO

{

ltest: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lagain: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drROR [rtailp, rcycleheadp, HandCodingComforts.Constant0];

HandCodingComforts.iJB [ltest];

HandCodingPseudos.SetLabel[lagain];

NULL;

ENDLOOP;

HandCoding.drRRI [rtailp, rtailp, ocnext];

HandCodingPseudos.SetLabel[ltest];

HandCoding.drLRIn [rtailp, ocnext];

HandCodingComforts.iJNEj [HandCodingComforts.NILValue, lagain];

};

-- if what we think is the top of the cycle has a cyclehead field, then it's not really the head of the cycle, which is really what we want

IF cycleheadp^.cyclehead # cycleheadp THEN {

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rcycleheadp, ocyclehead];

HandCodingComforts.iRJEQj [HandCodingComforts.ShortpopSrc, rcycleheadp, lcontinue];

cycleheadp ← cycleheadp^.cyclehead;

HandCoding.drRRI [rcycleheadp, rcycleheadp, ocyclehead];

};

HandCodingPseudos.SetLabel[lcontinue];

};

FOR index: INT IN [cycletop + 1 .. dfnDepth] DO

{

lafter: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lagain: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

rinitial: HandCoding.RegSpec = HandCoding.reg6;

ritermination: HandCoding.RegSpec = HandCoding.reg7;

rindex: HandCoding.RegSpec = HandCoding.reg8;

HandCoding.drLRn [rcycletop];

HandCoding.drADDB [1];

-- HandCoding.drMove [rinitial, HandCoding.popSrc];

HandCoding.drLRIn [rdfnImpl, odfnDepth];

-- HandCoding.drMove [ritermination, HandCoding.popSrc];

HandCoding.drLRn [rinitial];

HandCodingComforts.iRJGTj [HandCodingComforts.ShortpopSrc, ritermination, lafter];

HandCoding.drLRn [rinitial];

-- HandCoding.drMove [rindex, HandCoding.popSrc];

HandCodingPseudos.SetLabel[lagain];

childp ← dfnStack[index].nlentryp;

HandCoding.drLRn [rdfnImpl];

HandCoding.drADDB [odfnStack];

HandCoding.drRADD [HandCoding.pushDst, rindex, rindex];

replace a call to Basics.MixedMultiply

HandCoding.drLRn [rindex];

HandCoding.drLIB [cSIZEdfntype];

HandCodingComforts.iDFC [HandCodingPseudos.GetGlobalLabel["Basics.MixedMultiply"]];

HandCoding.drADD [];

HandCoding.drRB [onlentryp];

HandCoding.drSRn [rchildp];

IF childp^.cyclehead = childp

{

lelse: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rchildp, ocyclehead];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortpopSrc, rchildp, lelse];

THEN {

-- not yet glommed anywhere, glom it

-- and fix any children it has glommed

tailp^.cnext ← childp;

HandCodingComforts.iWRI [rtailp, ocnext, rchildp];

childp^.cyclehead ← cycleheadp;

HandCodingComforts.iWRI [rchildp, ocyclehead, rcycleheadp];

FOR tailp ← childp, tailp^.cnext WHILE tailp^.cnext # NIL DO

{

ltest: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lagain: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drROR [rtailp, rchildp, HandCodingComforts.Constant0];

HandCodingComforts.iJB [ltest];

HandCodingPseudos.SetLabel[lagain];

tailp^.cnext^.cyclehead ← cycleheadp;

HandCoding.drLRIn [rtailp, ocnext];

HandCoding.drLRn [rcycleheadp];

HandCoding.drWSB [ocyclehead];

ENDLOOP;

HandCoding.drRRI [rtailp, rtailp, ocnext];

HandCodingPseudos.SetLabel[ltest];

HandCoding.drLRIn [rtailp, ocnext];

HandCodingComforts.iJNEj [HandCodingComforts.NILByte, lagain];

};

HandCodingComforts.iJB [lcontinue];

ELSE {

HandCodingPseudos.SetLabel[lelse];

IF childp^.cyclehead # cycleheadp -- firewall -- THEN {

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rchildp, ocyclehead];

HandCodingComforts.iRJEQj [HandCodingComforts.ShortpopSrc, rcycleheadp, lcontinue];

-- CmdIO.Out["[dfnBusy] glommed, but not to cyclehead\n"];

NULL;

};

HandCodingPseudos.SetLabel[lcontinue];

};

HandCodingPseudos.SetLabel[lcontinue];

};

ENDLOOP;

HandCoding.drLRn [rindex];

HandCodingComforts.iRJGEj [HandCodingComforts.ShortpopSrc, ritermination, lafter];

HandCoding.drRADD [rindex, rindex, HandCodingComforts.Constant1];

HandCodingComforts.iJB [lagain];

HandCodingPseudos.SetLabel[lafter];

};

result ← TRUE;

HandCoding.drROR [rresult,HandCodingComforts.ConstantTRUE,HandCodingComforts.Constant0];

};

HandCodingPseudos.SetLabel[lcontinue];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drROR [HandCoding.reg0, rresult, HandCodingComforts.Constant0];

HandCodingPseudos.ProcedureExit[1];

};

dfnSelfCycle: PROC [parentp: dfn.nlTypeRef] RETURNS [BOOL] = {

-- deal with self-cycles

-- since we are taking out self-cycles elsewhere no need for the special case, here.

ldfnSelfCycle: HandCodingPseudos.Label;

dfnSelfCycle: HandCodingComforts.Proc = {

rparentp: HandCoding.RegSpec = HandCoding.reg0;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.dfnSelfCycle", ldfnSelfCycle, 1];

NULL;

RETURN [TRUE];

HandCodingComforts.LoadConstant [HandCodingComforts.TRUEByte];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

dfnPostVisit: PROC [parentp: dfn.nlTypeRef] RETURNS [BOOL] = {

-- visit a node after all its children and pop it off the stack

ldfnPostVisit: HandCodingPseudos.Label;

dfnPostVisit: HandCodingComforts.Proc = {

rparentp: HandCoding.RegSpec = HandCoding.reg0;

rdfnImpl: HandCoding.RegSpec = HandCoding.reg1;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.dfnPostVisit", ldfnPostVisit, 1];

HandCoding.drLIQB [fdfnImpl];

-- HandCoding.drMove [rdfnImpl, HandCoding.popSrc];

-- number functions and things in their cycles unless the function is itself part of a cycle

IF parentp^.cyclehead = parentp

{

lelse: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rparentp, ocyclehead];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortpopSrc, rparentp, lelse];

THEN {

dfnCounter ← dfnCounter + 1;

HandCoding.drLRIn [rdfnImpl, odfnCounter];

HandCoding.drADDB [1];

HandCoding.drSRIn [rdfnImpl, odfnCounter];

FOR memberp: dfn.nlTypeRef ← parentp, memberp^.cnext WHILE memberp # NIL DO

{

rmemberp: HandCoding.RegSpec = HandCoding.reg2;

ltest: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lagain: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRn [rparentp];

-- HandCoding.drMove [rmemberp, HandCoding.popSrc];

HandCodingPseudos.SetLabel[lagain];

memberp^.toporder ← dfnCounter;

HandCoding.drLRIn [rdfnImpl, odfnCounter];

HandCoding.drSRIn [rmemberp, otoporder];

ENDLOOP;

HandCoding.drRRI [rmemberp, rmemberp, ocnext];

HandCodingPseudos.SetLabel[ltest];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortNIL, rmemberp, lagain];

HandCoding.drDIS [];

};

HandCodingComforts.iJB [lcontinue];

ELSE {

HandCodingPseudos.SetLabel[lelse];

NULL;

};

HandCodingPseudos.SetLabel[lcontinue];

};

dfnDepth ← dfnDepth - 1;

HandCoding.drLRIn [rdfnImpl, odfnDepth];

HandCoding.drSUBB [1];

HandCoding.drSRIn [rdfnImpl, odfnDepth];

RETURN [TRUE];

HandCodingComforts.LoadConstant [HandCodingComforts.TRUEByte];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

printname: PROC [nlentryp: dfn.nlTypeRef] RETURNS [Rope.ROPE] = {

-- pretend this guy returns INTs

lprintname: HandCodingPseudos.Label;

printname: HandCodingComforts.Proc = {

rnlentryp: HandCoding.RegSpec = HandCoding.reg0;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.printname", lprintname, 1];

RETURN [nlentryp^.name];

HandCoding.drLRIn [rnlentryp, oname];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

-- *** stuff for using the interpreter to run this ***

AddNode: PROC [name: Rope.ROPE] RETURNS [dfn.nlTypeRef] = {

lAddNode: HandCodingPseudos.Label;

AddNode: HandCodingComforts.Proc = {

rname: HandCoding.RegSpec = HandCoding.reg0;

rdfnImpl: HandCoding.RegSpec = HandCoding.reg1;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.AddNode", lAddNode, 1];

HandCoding.drLIQB [fdfnImpl];

-- HandCoding.drMove [rdfnImpl, HandCoding.popSrc];

node: dfn.nlTypeRef ← @nlZone[nlAvail];

{

rnode: HandCoding.RegSpec = HandCoding.reg2;

HandCoding.drLRn [rdfnImpl];

HandCoding.drADDDB [onlZone];

HandCoding.drLRIn [rdfnImpl, onlAvail];

HandCoding.drLIB [cSIZEnlType];

HandCodingComforts.iDFC [HandCodingPseudos.GetGlobalLabel["Basics.MixedMultiply"]];

HandCoding.drADD [];

-- HandCoding.drMove [rnode, HandCoding.popSrc];

nlAvail ← nlAvail + 1;

HandCoding.drLRIn [rdfnImpl, onlAvail];

HandCoding.drADDB [1];

HandCoding.drSRIn [rdfnImpl, onlAvail];

node^.name ← name;

HandCodingComforts.iWRI [rnode, oname, rname];

node^.children ← NIL;

HandCodingComforts.LoadConstant [HandCodingComforts.NILValue];

HandCoding.drSRIn [rnode, ochildren];

node^.cyclehead ← node;

HandCodingComforts.iWRI [rnode, ocyclehead, rnode];

node^.cnext ← NIL;

HandCodingComforts.LoadConstant [HandCodingComforts.NILValue];

HandCoding.drSRIn [rnode, ocnext];

node^.nlnext ← nodeWorld;

HandCoding.drLRIn [rdfnImpl, onodeWorld];

HandCoding.drSRIn [rnode, onlnext];

node^.toporder ← DFNNaN;

HandCodingComforts.LoadConstant [0];

HandCoding.drSRIn [rnode, otoporder];

nodeWorld ← node;

HandCodingComforts.iWRI [rdfnImpl, onodeWorld, rnode];

RETURN [node];

HandCoding.drLRn [rnode];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

NodeLookup: PROC [name: Rope.ROPE] RETURNS [dfn.nlTypeRef] = {

lNodeLookup: HandCodingPseudos.Label;

NodeLookup: HandCodingComforts.Proc = {

rname: HandCoding.RegSpec = HandCoding.reg0;

rdfnImpl: HandCoding.RegSpec = HandCoding.reg1;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.NodeLookup", lNodeLookup, 1];

HandCoding.drLIQB [fdfnImpl];

-- HandCoding.drMove [rdfnImpl, HandCoding.popSrc];

FOR nodep: dfn.nlTypeRef ← nodeWorld, nodep^.nlnext WHILE nodep # NIL DO

{

rnodep: HandCoding.RegSpec = HandCoding.reg2;

lagain: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

ltest: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rdfnImpl, onodeWorld];

-- HandCoding.drMove [rnodep, HandCoding.popSrc];

HandCodingComforts.iJB [ltest];

HandCodingPseudos.SetLabel[lagain];

IF name.Equal[nodep^.name] THEN

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rnodep, oname];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortpopSrc, rname, lcontinue];

RETURN [nodep];

HandCoding.drLRn [rnodep];

HandCodingComforts.iJB [lreturn];

what about the DIScard of rnodep? don't really need it.

HandCodingPseudos.SetLabel[lcontinue];

};

ENDLOOP;

HandCoding.drRRI [rnodep, rnodep, onlnext];

HandCodingPseudos.SetLabel[ltest];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortNIL, rnodep, lagain];

HandCoding.drDIS [];

};

RETURN [NIL];

HandCodingComforts.LoadConstant [HandCodingComforts.NILValue];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

AddArc: PROC [from: Rope.ROPE, to: Rope.ROPE] RETURNS [dfn.arcTypeRef] = {

lAddArc: HandCodingPseudos.Label;

AddArc: HandCodingComforts.Proc = {

rfrom: HandCoding.RegSpec = HandCoding.reg0;

rto: HandCoding.RegSpec = HandCoding.reg1;

rdfnImpl: HandCoding.RegSpec = HandCoding.reg2;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.AddArc", lAddArc, 2];

HandCoding.drLIQB [fdfnImpl];

-- HandCoding.drMove [rdfnImpl, HandCoding.popSrc];

{

rfromNode: HandCoding.RegSpec = HandCoding.reg3;

rtoNode: HandCoding.RegSpec = HandCoding.reg4;

fromNode: dfn.nlTypeRef ← NodeLookup[from];

HandCoding.drLRn [rfrom];

HandCodingComforts.iLFC [lNodeLookup];

-- HandCoding.drMove [rfromNode, HandCoding.popSrc];

toNode: dfn.nlTypeRef ← NodeLookup[to];

HandCoding.drLRn [rto];

HandCodingComforts.iLFC [lNodeLookup];

-- HandCoding.drMove [rtoNode, HandCoding.popSrc];

IF fromNode # NIL AND toNode # NIL THEN {

{

lcontinue: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.iRJEQj [HandCodingComforts.ShortNIL, rfromNode, lcontinue];

HandCodingComforts.iRJEQj [HandCodingComforts.ShortNIL, rtoNode, lcontinue];

arcp: dfn.arcTypeRef ← @arcZone[arcAvail];

{

rarcp: HandCoding.RegSpec = HandCoding.reg5;

HandCoding.drLRn [rdfnImpl];

HandCoding.drADDDB [oarcZone];

HandCoding.drLRIn [rdfnImpl, oarcAvail];

HandCoding.drQADD [topAtop, HandCoding.topSrc];

replace a call to Basics.MixedMultiply

HandCoding.drLIB [cSIZEarcType];

HandCodingComforts.iDFC [HandCodingPseudos.GetGlobalLabel["Basics.MixedMultiply"]];

HandCoding.drADD [];

-- HandCoding.drMove [rarcp, HandCoding.popSrc];

arcAvail ← arcAvail + 1;

HandCoding.drLRIn [rdfnImpl, oarcAvail];

HandCoding.drADDB [1];

HandCoding.drSRIn [rdfnImpl, oarcAvail];

arcp^.arcChildp ← toNode;

HandCodingComforts.iWRI [rarcp, oarcChildp, rtoNode];

arcp^.arcChildlist ← fromNode^.children;

HandCoding.drLRIn [rfromNode, ochildren];

HandCoding.drSRIn [rarcp, oarcChildlist];

fromNode^.children ← arcp;

HandCodingComforts.iWRI [rfromNode, ochildren, rarcp];

RETURN [arcp];

HandCoding.drLRn [rarcp];

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lcontinue];

};

RETURN [NIL];

HandCodingComforts.LoadConstant [HandCodingComforts.NILValue];

the existence of LC[0..7] implies that constants that can be loaded with LIB, LIDB, and LIQB should be in Constants[8..11]. Except that there is the tiny operand mode, which references Constants[0] and Constants[1].

HandCodingComforts.iJB [lreturn];

};

HandCodingPseudos.SetLabel[lreturn];

HandCoding.drSRn [HandCoding.reg0];

HandCodingPseudos.ProcedureExit[1];

};

PrintNode: PROC [nodep: dfn.nlTypeRef] RETURNS [] = {

lPrintNode: HandCodingPseudos.Label;

PrintNode: HandCodingComforts.Proc = {

rnodep: HandCoding.RegSpec = HandCoding.reg0;

HandCodingComforts.Prologue["dfnImpl.PrintNode", lPrintNode, 1];

CmdIO.Out["%g: %g\n", [rope[nodep^.name]], [integer[nodep^.toporder]]];

HandCoding.drLRIn [rnodep, oname];

HandCodingSupport.OQBcommon[x060b, DragOpsCrossUtils.IntToWord[1]];

print an INT from the top of the stack without a \n

HandCoding.drDIS [];

HandCoding.drLRIn [rnodep, otoporder];

HandCodingSupport.OQBcommon[x060b, DragOpsCrossUtils.IntToWord[0]];

print an INT from the top of the stack with a \n

HandCoding.drDIS [];

};

HandCodingPseudos.ProcedureExit[0];

};

PrintArc: PROC [arcp: dfn.arcTypeRef] RETURNS [] = {

lPrintArc: HandCodingPseudos.Label;

PrintArc: HandCodingComforts.Proc = {

rarcp: HandCoding.RegSpec = HandCoding.reg0;

HandCodingComforts.Prologue["dfnImpl.PrintArc", lPrintArc, 1];

PrintNode[arcp^.arcChildp];

HandCoding.drLRIn [rarcp, oarcChildp];

HandCodingComforts.iLFC [lPrintNode];

};

HandCodingPseudos.ProcedureExit[0];

};

PrintNodeWorld: PROC [] RETURNS [] = {

lPrintNodeWorld: HandCodingPseudos.Label;

PrintNodeWorld: HandCodingComforts.Proc = {

rdfnImpl: HandCoding.RegSpec = HandCoding.reg0;

HandCodingComforts.Prologue["dfnImpl.PrintNodeWorld", lPrintNodeWorld, 0];

HandCoding.drLIQB [fdfnImpl];

-- HandCoding.drMove [rdfnImpl, HandCoding.popSrc];

FOR nodep: dfn.nlTypeRef ← nodeWorld, nodep^.nlnext WHILE nodep # NIL DO

{

rnodep: HandCoding.RegSpec = HandCoding.reg1;

lagain: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

ltest: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCoding.drLRIn [rdfnImpl, onodeWorld];

-- HandCoding.drMove [rnodep, HandCoding.popSrc];

HandCodingComforts.iJB [ltest];

HandCodingPseudos.SetLabel[lagain];

PrintNode[nodep];

HandCoding.drLRn [rnodep];

HandCodingComforts.iLFC [lPrintNode];

ENDLOOP;

HandCoding.drRRI [rnodep, rnodep, onlnext];

HandCodingPseudos.SetLabel[ltest];

HandCodingComforts.iRJNEj [HandCodingComforts.ShortNIL, rnodep, lagain];

HandCoding.drDIS [];

};

HandCodingPseudos.ProcedureExit[0];

};

DoIt: PROC [] RETURNS [result: BOOL] = {

lDoIt: HandCodingPseudos.Label;

DoIt: HandCodingComforts.Proc = {

rresult: HandCoding.RegSpec = HandCoding.reg0;

lreturn: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lStartHere: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

lStopHere: HandCodingPseudos.Label = HandCodingPseudos.GenLabel[];

HandCodingComforts.Prologue["dfnImpl.DoIt", lDoIt, 0];

-- Build the world

HandCoding.drLIB [ 1];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 2];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 3];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 4];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 5];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 6];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 7];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 8];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 9];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 10];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 11];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 12];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 13];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 14];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 15];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 16];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 17];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 18];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 19];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 20];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 21];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 22];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 23];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 24];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 25];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 26];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 27];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 28];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 29];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 30];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 31];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 32];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 33];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 34];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 35];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 36];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 37];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 38];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 39];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 40];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 41];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 42];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 43];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 44];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 45];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 46];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 47];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 48];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 49];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 50];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 51];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 52];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 53];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 54];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 55];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 56];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 57];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 58];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 59];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 60];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 61];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 62];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 63];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 64];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 65];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 66];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 67];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 68];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 69];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 70];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 71];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 72];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 73];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 74];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 75];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 76];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 77];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 78];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 79];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 80];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 81];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 82];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 83];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 84];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 85];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 86];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 87];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 88];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 89];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 90];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 91];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 92];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 93];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 94];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 95];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 96];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 97];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 98];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 99];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [100];

HandCodingComforts.iLFC [lAddNode];

HandCoding.drDIS [];

HandCoding.drLIB [ 1];

HandCoding.drLIB [ 2];