DIRECTORY
Imager USING [Context, VEC, MaskStrokeTrajectory, SetGray, MaskFillTrajectory, SetXY, ShowRope],
ImagerPath USING [Trajectory, MoveTo, LineToX, LineToY, LastPoint],
IO,
Rope USING [Equal, Cat, ROPE],
SymTab,
CDOrient,
Misc USING [Rect, RectCreate],
IP,
IPConstants,
IPParams,
IPBasicOps,
IPCTG,
IPTypeTab,
IPNetTab,
IPToolBox,
IPChipRose,
IPPinNets,
IPCoTab;

IPCoTabImpl: CEDAR PROGRAM
IMPORTS  IO, Imager, ImagerPath, Rope, SymTab, CDOrient, Misc, IP, IPParams, IPBasicOps, IPToolBox, IPNetTab, IPTypeTab, IPCTG, IPChipRose, IPPinNets
EXPORTS  IPCoTab = BEGIN OPEN BO: IPBasicOps, TB: IPToolBox, IPCoTab;


Create: PUBLIC PROC[chipRose: IPChipRose.Ref, typeTab: IPTypeTab.Ref, netTab: IPNetTab.Ref] RETURNS[Ref] = {
coTab: Ref _ NEW[Rep _ [SymTab.Create[]]];
eachInstProc: IPChipRose.EachInstanceAction ={
type: IPTypeTab.CoType _ typeTab.FetchCoType[val.type];
orient: IP.Orientation _ val.orient;
origin: IntVector _ IF val.origin = NIL 
THEN [IPParams.CoDefaultPosition, IPParams.CoDefaultPosition] 
ELSE val.origin^;
active: BOOL _ (val.origin # NIL);
pinNets: IPPinNets.PinNets _ NIL;
convertPinNet: PROC [netRec: IPChipRose.PinNetRec] RETURNS [IPPinNets.PinNet] = {
pin: IPTypeTab.Pin _ IPTypeTab.GetPin[type, netRec.pin];
phyPins: LIST OF REF IP.PhysicalPinRep _ IPTypeTab.MakePhysicalPins[type, pin, orient];
RETURN [NEW [IPPinNets.PinNetRep _ [netRec.pin, netTab.FetchNet[netRec.net], NIL, phyPins]]];
}; --convertPinNet

FOR l: LIST OF IPChipRose.PinNetRec _ val.pinNets, l.rest UNTIL l = NIL DO
pinNets _ CONS[convertPinNet[l.first], pinNets]
ENDLOOP;
[] _ CreateComponent[coTab, instance, type, orient, pinNets, origin, active];
}; --eachInstProc

chipRose.Instances[eachInstProc];
RETURN[coTab]
}; -- Create-- 

DestroySelf: PUBLIC PROC[coTab: Ref] ={
eachComp: EachComponentAction ={
co.type _ NIL;  --Break circularity 1: type -> type.instances -> co
IPPinNets.NilPinNetsNet[co.pinNets]; --Break circularity 2:  pinNet.net -> net.pinNets
co.pinNets _ NIL; -- Break circularity 3 : pinNets -> pinNet -> pinNet.owner 
}; --eachComp
Components[coTab, eachComp] 
};--DestroySelf

DescribeSelf: PUBLIC PROC[coTab: Ref, stream: IO.STREAM] = {
pCC: PROC [cc: CornerChannels] ={
IF cc = NIL 
THEN stream.PutF[" ()"]
ELSE stream.PutF[" (%g %g)", IO.rope[cc.hor.name], IO.rope[cc.ver.name]];
}; --pCC
pPN: PROC[pN: IPPinNets.PinNet] ={
stream.PutF[" %g: %g  ", IO.rope[pN.name], IO.refAny[pN.net.name]]; --name, "netName"
TB.PutPhysicalPins[stream, pN.physicalPins];
}; --pPN
pComp: EachComponentAction ={
OPEN pChs: co.prinChannels, cChs: co.cornerChannels;
stream.PutF["%g:\t (%g %g) %g ", IO.rope[co.name], IO.int[co.origin.x], IO.int[co.origin.y], IO.bool[co.active]];
stream.PutF["%g %g ",  IO.rope[IF co.type = NIL THEN "NIL" ELSE co.type.name], IO.int[co.orient]];

stream.PutF["{"];
FOR l: IPPinNets.PinNets _ co.pinNets, l.rest UNTIL l = NIL DO
pPN[l.first]
ENDLOOP;
stream.PutF["}"];
IF co.type = NIL THEN IPToolBox.PutShape[stream, NEW[IP.ShapeRep _ co.shape]];


IF pChs.south = NIL OR co.active = FALSE --This means ReconstructSelf cannot recover state of undo stack: ??
THEN {stream.PutF["\n"]; RETURN}
ELSE stream.PutF[";\n"];
stream.PutF["\t\t%g %g %g %g", IO.rope[pChs.south.name], IO.rope[pChs.east.name], IO.rope[pChs.north.name], IO.rope[pChs.west.name]];
pCC[cChs.sw]; pCC[cChs.se]; pCC[cChs.ne]; pCC[cChs.nw];
stream.PutF["\n"]
}; --pComp--
stream.PutF["\nBeginCoTab"];
stream.PutF["\n%g \t--Number of components\n", IO.int[Size[coTab]]];
AllComponents[coTab, pComp];
stream.PutF["EndCoTab\n"];
}; --DescribeSelf--

ReconstructSelf: PUBLIC PROC[stream: IO.STREAM, typeTab: IPTypeTab.Ref, netTab: IPNetTab.Ref, ctg: IPCTG.Ref _ NIL] RETURNS [coTab: Ref] ={
getPinNet: PROC RETURNS [pN: IPPinNets.PinNet] ={
name: Rope.ROPE _ TB.GetIdRope[stream];
net: IPPinNets.Net _ netTab.FetchNet[IO.GetRopeLiteral[stream]];
phyPins: LIST OF REF IP.PhysicalPinRep _ TB.GetPhysicalPins[stream]; --Get phyPins
RETURN [NEW[IPPinNets.PinNetRep _ [name, net, NIL, phyPins]]];
}; --getPinNet

getCC: PROC RETURNS [cC: CornerChannels] ={
[] _ stream.GetCedarTokenRope;
IF stream.PeekChar = ') 
THEN cC _ NIL
ELSE cC _ NEW[CornerChannelsRep _ [ctg.GetChannel[stream.GetID], ctg.GetChannel[stream.GetID]]];
[] _ stream.GetCedarTokenRope;
}; --getCC--
makeCo: PROC RETURNS [Component] ={
name: Rope.ROPE _ TB.GetIdRope[stream];
origin: IntVector _ TB.GetIntVector[stream]^;
active: BOOL _ stream.GetBool;
type: IPTypeTab.CoType _ typeTab.FetchCoType[stream.GetID, FALSE];
orient: CDOrient.Orientation _ stream.GetInt;
pinNets: IPPinNets.PinNets _ NIL;

TB.EnterBlock[stream];
UNTIL TB.ExitBlock[stream] DO
pinNets _ CONS [getPinNet[], pinNets];
ENDLOOP;

IF type = NIL 
THEN {
shape: IP.ShapeRep _ IPToolBox.GetShape[stream]^;
RETURN [CreateComponent2[coTab, name, shape, active, orient, origin, NIL]]}
ELSE RETURN [CreateComponent[coTab, name, type, orient, pinNets, origin, active]];
}; --makeCo--
insertCo: PROC[co: Component] ={
south: Channel _ ctg.GetChannel[stream.GetID];
east: Channel _ ctg.GetChannel[stream.GetID];
north: Channel _ ctg.GetChannel[stream.GetID];
west: Channel _ ctg.GetChannel[stream.GetID];
swCh: CornerChannels _ getCC[];
seCh: CornerChannels _ getCC[];
neCh: CornerChannels _ getCC[];
nwCh: CornerChannels _ getCC[];
InsertComponent[co, south, east, north, west, swCh, seCh, neCh, nwCh]
}; --insertCo--
coTab _ NEW[Rep _ [SymTab.Create[]]];
THROUGH [0..stream.GetInt) DO
comp: Component _ makeCo[];
IF stream.PeekChar = '; 
THEN {[] _ stream.GetLineRope}
ELSE LOOP;
IF ctg = NIL THEN {[] _ stream.GetLineRope; LOOP};
insertCo[comp];
ENDLOOP;
IF NOT Rope.Equal[stream.GetID, "EndCoTab"] THEN ERROR;
};--ReconstructSelf--

CheckSelf: PUBLIC PROC[coTab: Ref] ={
pCo: EachComponentAction ={
OPEN cP: co.prinChannels, cC: co.cornerChannels, cS: co.shape.cornerSpaces;
IF GetComponent[coTab, co.name] # co THEN ERROR; --Name Conclict--
IF NOT co.active THEN RETURN; -- No need further checking--
IF NOT IPCTG.ComponentOn[cP.south, co, pos] THEN ERROR;
IF NOT IPCTG.ComponentOn[cP.east, co, neg] THEN ERROR;
IF NOT IPCTG.ComponentOn[cP.north, co, neg] THEN ERROR;
IF NOT IPCTG.ComponentOn[cP.west, co, pos] THEN ERROR;
IF cC.sw # NIL THEN {
IF cS.sw = NIL THEN ERROR;
IF IPCTG.NthComponent[cC.sw.hor, pos, -1] # co THEN ERROR;
IF IPCTG.NthComponent[cC.sw.ver, pos, -1] # co THEN ERROR;
IF IPCTG.NthComponent[cC.sw.hor, neg, -1] # IPCTG.NthComponent[cC.sw.ver, neg, -1] THEN ERROR;};
IF cC.se # NIL THEN {
IF cS.se = NIL THEN ERROR;
IF IPCTG.NthComponent[cC.se.hor, pos, 1] # co THEN ERROR;
IF IPCTG.NthComponent[cC.se.ver, neg, -1] # co THEN ERROR;
IF IPCTG.NthComponent[cC.se.hor, neg, 1] # IPCTG.NthComponent[cC.se.ver, pos, -1] THEN ERROR;};
IF cC.ne # NIL THEN {
IF cS.ne = NIL THEN ERROR;
IF IPCTG.NthComponent[cC.ne.hor, neg, 1] # co THEN ERROR;
IF IPCTG.NthComponent[cC.ne.ver, neg, 1] # co THEN ERROR;
IF IPCTG.NthComponent[cC.ne.hor, pos, 1] # IPCTG.NthComponent[cC.ne.ver, pos, 1] THEN ERROR;};
IF cC.nw # NIL THEN {
IF cS.nw = NIL THEN ERROR;
IF IPCTG.NthComponent[cC.nw.hor, neg, -1] # co THEN ERROR;
IF IPCTG.NthComponent[cC.nw.ver, pos, 1] # co THEN ERROR;
IF IPCTG.NthComponent[cC.nw.hor, pos, -1] # IPCTG.NthComponent[cC.nw.ver, neg, 1] THEN ERROR;};
};--pCo--
AllComponents[coTab, pCo]
}; --CheckSelf--

PaintSelf: PUBLIC PROC [coTab: Ref, context: Imager.Context, xOffset, yOffset: REAL _ 0.0, scaleFactor: REAL _ 1.0, coStipple: CARDINAL _ IPConstants.White, showCoNames, showPhyPinNames: BOOL _ TRUE] ={

p: EachComponentAction ={
PaintComponent[co, context, xOffset, yOffset, scaleFactor, coStipple, showCoNames];
IPPinNets.PaintPinNets[co, context, xOffset, yOffset, scaleFactor, showPhyPinNames];
}; --p--
Components[coTab, p];
}; --PaintSelf--

CreateComponent: PUBLIC PROC[coTab: Ref, name: Rope.ROPE, type: IPTypeTab.CoType, orient: CDOrient.Orientation, pinNets: IPPinNets.PinNets _ NIL, origin: IntVector _ [IPParams.CoDefaultPosition, IPParams.CoDefaultPosition], active: BOOL _ TRUE] RETURNS[co: Component] = {
shape: IP.ShapeRep _ TB.CopyShape[IPTypeTab.GetShape[type], orient]^;
co _ NEW[ComponentRep _ [name: name, origin: origin, active: active, shape: shape, type: type, orient: orient, pinNets: pinNets]];
IF coTab.comps.Insert[name, co] THEN NULL ELSE ERROR IP.Error[doubleRegistration, name];
IPTypeTab.AddInstance[type, co]; --Set up circular pointer: co.type -> type -> type.instances
IPPinNets.SetPinNetsOwner[pinNets, co]; --Set up circular pointer: co.pinNets-> pinNet.owner
IF active THEN IPPinNets.AddPinNetsToNets[pinNets]; --Set up circular pointer: pinNet.net -> net.pinNets
}; -- CreateComponent-- 
CreateComponent2: PUBLIC PROC[coTab: Ref, name: Rope.ROPE, shape: IP.ShapeRep, active: BOOL, orient: CDOrient.Orientation, origin: IntVector, from: Component _ NIL] RETURNS[co: Component] ={
IF from = NIL 
THEN co _ NEW[ComponentRep _ [name: name, origin: origin, active: active, shape: shape, orient: orient]]
ELSE co _ from;
IF co.type # NIL THEN IPTypeTab.AddInstance[co.type, co]; 
IF coTab.comps.Insert[co.name, co] THEN NULL ELSE ERROR IP.Error[doubleRegistration, name];
}; --CreateComponent2

DestroyComponent2: PUBLIC PROC[coTab: Ref, co: Component] = {
IF co.type # NIL THEN IPTypeTab.RemInstance[co.type, co];
IF co.pinNets # NIL THEN {
IPPinNets.RemPinNetsFromNets[co.pinNets];
co.pinNets _ NIL}; 
[] _ coTab.comps.Delete[co.name];
}; --DestroyComponent --

Size: PUBLIC PROC[coTab: Ref] RETURNS[NAT]= {
RETURN[coTab.comps.GetSize]}; --Size--

CountComponents: PUBLIC PROC[coTab: Ref] RETURNS [active, nonActive: INT _ 0] ={
action: EachComponentAction ={
IF co.active 
THEN active _ active.SUCC
ELSE nonActive _ nonActive.SUCC;
}; --action
AllComponents[coTab, action];
}; --CountComponents


GetComponent: PUBLIC PROC[coTab: Ref, name: Rope.ROPE, raiseError: BOOL _ TRUE] RETURNS[component: Component _ NIL] ={
findName: EachComponentAction = {
IF Rope.Equal[name, co.name]  THEN {component _ co; quit _ TRUE}}; -- findName-- 
AllComponents[coTab, findName];
IF component = NIL AND raiseError THEN ERROR IP.Error[missingRegistration, Rope.Cat[name, " is not a component name"]];
}; --GetComponent--

Components: PUBLIC PROC[coTab: Ref,  p: EachComponentAction] = {
p1: SymTab.EachPairAction -- [key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL] --  = {co: Component _ NARROW[val]; RETURN[IF co.active THEN p[co] ELSE FALSE]};-- p1-- 
[] _ coTab.comps.Pairs[p1];
}; -- Components--

AllComponents: PUBLIC PROC[coTab: Ref,  p: EachComponentAction] = {
p1: SymTab.EachPairAction -- [key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL] --  = {RETURN[p[NARROW[val, Component]]]};-- p1-- 
[] _ coTab.comps.Pairs[p1];
}; -- AllComponents--

SetName: PUBLIC PROC[coTab: Ref, co: Component, name: Rope.ROPE] = {
IF co.name = name THEN RETURN;
IF coTab.comps.Fetch[name].found THEN ERROR IP.Error[doubleRegistration, Rope.Cat[name, " has already been used"]];
[] _ coTab.comps.Delete[co.name]; --Remove old name--
co.name _name;
[] _ coTab.comps.Store[name, co];
}; --SetName --
GetDim: PUBLIC PROC[co: Component] RETURNS[x, y: NAT] ={
IF CDOrient.IncludesOddRot90[co.orient] 
THEN [y, x] _ co.shape.dim^
ELSE [x, y] _ co.shape.dim^;
}; --GetDim

DeActivateComponent: PUBLIC PROC[co: Component] =  {
co.active _ FALSE;
IPPinNets.RemPinNetsFromNets[co.pinNets];
}; --DeActivateComponent
ReActivateComponent: PUBLIC PROC[co: Component] =  {
co.active _ TRUE;
IPPinNets.AddPinNetsToNets[co.pinNets]; 
};--ReActivateComponent

GetBRect: PUBLIC PROC[co: Component] RETURNS[Misc.Rect] ={
dimX, dimY: NAT;
[dimX, dimY] _ GetDim[co];
RETURN[Misc.RectCreate[co.origin.x, co.origin.y, co.origin.x + dimX, co.origin.y + dimY]]
}; --GetBRect--
GetCornerRects: PUBLIC PROC[co: Component, crop: INT _ 1] RETURNS[sw, se, ne, nw: Misc.Rect _ NIL] ={
swCS, seCS, neCS, nwCS: CornerSpace;
origin: IntVector _ co.origin;
dimX, dimY: NAT;
[dimX, dimY] _ GetDim[co];
[swCS, seCS, neCS, nwCS] _ GetCornerSps[co];
IF swCS # NIL THEN sw _ Misc.RectCreate[origin.x, origin.y, origin.x + swCS.x - crop, origin.y + swCS.y - crop];
IF seCS # NIL THEN se _ Misc.RectCreate[origin.x + dimX - seCS.x + crop, origin.y, origin.x + dimX, origin.y + seCS.y - crop];
IF neCS # NIL THEN ne _ Misc.RectCreate[origin.x+ dimX - neCS.x + crop, origin.y+dimY - neCS.y + crop, origin.x+ dimX, origin.y+dimY];
IF nwCS# NIL THEN nw _ Misc.RectCreate[origin.x, origin.y + dimY - nwCS.y + crop, origin.x + nwCS.x - crop, origin.y + dimY]; 
}; --GetCornerRect--
FindEdgeType: PUBLIC PROC[co: Component, ch: IPCTG.Channel] RETURNS [EdgeTypes] ={
et: EdgeTypes _ south;
THROUGH [0..4) DO
IF GetPrinCh[co, et] = ch THEN RETURN [et];
et _ BO.ETRotate[et];
ENDLOOP;
ERROR IP.Error[callingError, Rope.Cat[IPCTG.GetName[ch], " is not a principal channel of ", co.name]];
}; --FindEdgeType--
GetPrinCh: PUBLIC PROC[co: Component, et: EdgeTypes] RETURNS [Channel] ={
OPEN cPC: co.prinChannels;
SELECT et FROM
south => RETURN [cPC.south];
east => RETURN [cPC.east];
north => RETURN [cPC.north];
west => RETURN [cPC.west];
ENDCASE => ERROR;}; -- GetPrinCh--
SetPrinCh: PUBLIC PROC[co: Component, et: EdgeTypes, ch: Channel] ={
OPEN cPC: co.prinChannels;
SELECT et FROM
south => cPC.south _ ch;
east => cPC.east _ ch;
north => cPC.north _ ch;
west => cPC.west _ ch;
ENDCASE => ERROR;}; -- SetPrinCh--

FindCornerType: PUBLIC PROC[co: Component, ch: IPCTG.Channel] RETURNS [CornerTypes] ={
ct: CornerTypes _ sw;
THROUGH [0..4) DO
IF GetCornerChFor[co, ct, ch.type] = ch THEN RETURN [ct];
ct _ BO.CTRotate[ct];
ENDLOOP;
ERROR IP.Error[callingError, Rope.Cat[IPCTG.GetName[ch], " is not a corner channel of ", co.name]];
}; --FindCornerType--

GetCornerChs: PUBLIC PROC[co: Component, ct: CornerTypes] RETURNS [CornerChannels] ={
OPEN cCC: co.cornerChannels;
SELECT ct FROM
sw => RETURN [cCC.sw];
se => RETURN [cCC.se];
ne => RETURN [cCC.ne];
nw => RETURN [cCC.nw];
ENDCASE => ERROR;}; -- GetCornerChs--
SetCornerChs: PUBLIC PROC[co: Component, ct: CornerTypes, cc: CornerChannels] ={
OPEN cCC: co.cornerChannels;
SELECT ct FROM
sw => cCC.sw _ cc;
se => cCC.se _ cc;
ne => cCC.ne _ cc;
nw => cCC.nw _ cc;
ENDCASE => ERROR;}; -- SetCornerChs--
GetCornerChFor: PUBLIC PROC[co: Component, ct: CornerTypes, ot: BO.OrientationTypes] RETURNS [IPCTG.Channel] = {RETURN [CCGetCh[GetCornerChs[co, ct], ot]]}; --GetCornerChFor--

SetCornerChs2: PUBLIC PROC[co: Component, ct: CornerTypes, horCh, verCh: IPCTG.Channel] ={
cornerChs: CornerChannels;
IF (cornerChs _ GetCornerChs[co, ct]) = NIL 
THEN SetCornerChs[co, ct, NEW[CornerChannelsRep _ [horCh, verCh]]]
ELSE {cornerChs.hor _ horCh; cornerChs.ver _ verCh};
}; --SetCornerChs2--

GetCornerSp: PUBLIC PROC[co: Component, ct: CornerTypes] RETURNS [cs: CornerSpace] ={
OPEN coS: co.shape.cornerSpaces;
cs _ SELECT ct FROM 
sw => coS.sw,
se => coS.se,
ne => coS.ne,
nw => coS.nw,
ENDCASE => ERROR;
IF cs # NIL AND CDOrient.IncludesOddRot90[co.orient]  
THEN cs _ NEW [NatVector _ [cs.y, cs.x]]; --else RETURN[cs]
}; --GetCornerSp --

GetCornerSps: PUBLIC PROC[co: Component] RETURNS [sw, se, ne, nw: CornerSpace] ={
OPEN coS: co.shape.cornerSpaces;
flipXY: BOOL _ CDOrient.IncludesOddRot90[co.orient];
IF (sw _ coS.sw) # NIL AND flipXY 
THEN sw _ NEW [NatVector _ [sw.y, sw.x]]; --else just sw
IF (se _ coS.se) # NIL AND flipXY 
THEN se _ NEW [NatVector _ [se.y, se.x]]; --else just se
IF (ne _ coS.ne) # NIL AND flipXY 
THEN ne _ NEW [NatVector _ [ne.y, ne.x]]; --else just ne
IF (nw _ coS.nw) # NIL AND flipXY 
THEN nw _ NEW [NatVector _ [nw.y, nw.x]]; --else just nw

}; --GetCornerSps

GetChOnSide: PUBLIC PROC[co: Component, side: IP.PinSideType, useParrallel: BOOL] RETURNS [IPCTG.Channel] ={
OPEN coP: co.prinChannels, coC: co.cornerChannels;
SELECT side FROM
south => RETURN [coP.south];
east => RETURN [coP.east];
north => RETURN [coP.north];
west => RETURN [coP.west];
swHor => IF coC.sw = NIL 
THEN RETURN [IF useParrallel THEN coP.south ELSE coP.west]
ELSE RETURN [coC.sw.hor];
seHor => IF coC.se = NIL 
THEN RETURN [IF useParrallel THEN coP.south ELSE coP.east]
ELSE RETURN [coC.se.hor];
neHor => IF coC.ne = NIL 
THEN RETURN [IF useParrallel THEN coP.north ELSE coP.east]
ELSE RETURN [coC.ne.hor];
nwHor => IF coC.nw = NIL 
THEN RETURN [IF useParrallel THEN coP.north ELSE coP.west]
ELSE RETURN [coC.nw.hor];
swVer => IF coC.sw = NIL 
THEN RETURN [IF useParrallel THEN coP.west ELSE coP.south]
ELSE RETURN [coC.sw.ver];
seVer => IF coC.se = NIL 
THEN RETURN [IF useParrallel THEN coP.east ELSE coP.south]
ELSE RETURN [coC.se.ver];
neVer => IF coC.ne = NIL 
THEN RETURN [IF useParrallel THEN coP.east ELSE coP.north]
ELSE RETURN [coC.ne.ver];
nwVer => IF coC.nw = NIL 
THEN RETURN [IF useParrallel THEN coP.west ELSE coP.north]
ELSE RETURN [coC.nw.ver];
interior, unknown => RETURN [NIL];
ENDCASE => ERROR;
};  --GetChOnSide

PaintComponent: PUBLIC PROC [co: Component, context: Imager.Context, xOffset, yOffset: REAL _ 0.0, scaleFactor: REAL _ 1.0, stipple: CARDINAL _ IPConstants.Black, showName: BOOL _ TRUE] ={
path: ImagerPath.Trajectory;
sw, se, ne, nw: CornerSpace;
originX, originY: REAL;
dimX, dimY: REAL;
[originX, originY] _ co.origin;
originX _ xOffset + (originX * scaleFactor); 
originY _ yOffset + (originY *scaleFactor);
[dimX, dimY] _ GetDim[co];
dimX _ dimX * scaleFactor; 
dimY _ dimY * scaleFactor;
[sw, se, ne, nw] _ GetCornerSps[co];
IF sw # NIL  THEN {
path _ ImagerPath.MoveTo[[originX, originY + sw.y * scaleFactor]]; 
path _ ImagerPath.LineToX[path, originX + sw.x * scaleFactor];
path _ ImagerPath.LineToY[path, originY]} ELSE { 
path _ ImagerPath.MoveTo[[originX, originY]]};
IF se # NIL THEN {
path _ ImagerPath.LineToX[path, originX+ dimX - se.x * scaleFactor];
path _ ImagerPath.LineToY[path, originY + se.y * scaleFactor];
path _ ImagerPath.LineToX[path, originX + dimX];} ELSE{
path _ ImagerPath.LineToX[path, originX + dimX];};
IF ne # NIL THEN {
path _ ImagerPath.LineToY[path, originY +dimY - ne.y * scaleFactor];
path _ ImagerPath.LineToX[path, originX + dimX - ne.x * scaleFactor];
path _ ImagerPath.LineToY[path, originY + dimY];} ELSE {
path _ ImagerPath.LineToY[path, originY + dimY]};
IF nw # NIL THEN {
path _ ImagerPath.LineToX[path, originX + nw.x * scaleFactor];
path _ ImagerPath.LineToY[path, originY + dimY - nw.y * scaleFactor];
path _ ImagerPath.LineToX[path, originX];} ELSE {
path _ ImagerPath.LineToX[path, originX]};
IF sw # NIL THEN {
path _ ImagerPath.LineToY[path, originY + sw.y * scaleFactor];} ELSE {
path _ ImagerPath.LineToY[path, originY]};
IF stipple = IPConstants.White 
THEN Imager.MaskStrokeTrajectory[context, path]
ELSE {Imager.SetGray[context, stipple]; Imager.MaskFillTrajectory[context, path];};
IF showName THEN {
offSet: REAL _ (IPParams.PinMaxDistFromEdge + scaleFactor * IPParams.PhyPinRectSize);
v: Imager.VEC;
v _ ImagerPath.LastPoint[path];
Imager.SetXY[context, [v.x + offSet, v.y + offSet]];
Imager.ShowRope[context, co.name]};
}; --PaintComponent--
InsertComponent:  PUBLIC PROC [co: Component, south, east, north, west: Channel, sw, se, ne,nw: CornerChannels _ NIL] = {
negBnd, posBnd: Channel;
co.prinChannels _ [south, east, north, west];
co.cornerChannels _ [sw, se, ne, nw];

negBnd _ IF sw # NIL THEN sw.ver ELSE west;
posBnd _ IF se # NIL THEN se.ver ELSE east; 
IPCTG.InsertCoBetween[south, co, negBnd, posBnd, pos];

negBnd _ IF se # NIL THEN se.hor ELSE south;
posBnd _ IF ne # NIL THEN ne.hor ELSE north; 
IPCTG.InsertCoBetween[east, co, negBnd, posBnd, neg];

negBnd _ IF nw # NIL THEN nw.ver ELSE west;
posBnd _ IF ne # NIL THEN ne.ver ELSE east; 
IPCTG.InsertCoBetween[north, co, negBnd, posBnd, neg];

negBnd _ IF sw # NIL THEN sw.hor ELSE south;
posBnd _ IF nw # NIL THEN nw.hor ELSE north; 
IPCTG.InsertCoBetween[west, co, negBnd, posBnd, pos];

IF sw # NIL THEN {IPCTG.InsertCoAt[sw.hor, co, pos, pos]; IPCTG.InsertCoAt[sw.ver, co, pos, pos]};
IF se # NIL THEN {IPCTG.InsertCoAt[se.hor, co, pos, neg]; IPCTG.InsertCoAt[se.ver, co, neg, pos]};
IF ne # NIL THEN {IPCTG.InsertCoAt[ne.hor, co, neg, neg]; IPCTG.InsertCoAt[ne.ver, co, neg, neg]};
IF nw # NIL THEN {IPCTG.InsertCoAt[nw.hor, co, neg, pos]; IPCTG.InsertCoAt[nw.ver, co, pos, neg]};
}; --InsertComponent --

PositionComponent: PUBLIC PROC[co: Component, southCoeff, eastCoeff, northCoeff, westCoeff: NAT _ 0] = {
OPEN cPC: co.prinChannels, cCC: co.cornerChannels;
xMin, yMin, xMax, yMax, xP, yP: INT;
IF (southCoeff + northCoeff) = 0 THEN {southCoeff _ northCoeff _ 1};
IF (eastCoeff + westCoeff) = 0 THEN {eastCoeff _ westCoeff _ 1};
yMin _ FromEdge[co, south, cPC.south.coord + cPC.south.width/2];
xMax _ FromEdge[co, east, cPC.east.coord - cPC.east.width/2];
yMax _ FromEdge[co, north, cPC.north.coord - cPC.north.width/2];
xMin _ FromEdge[co, west, cPC.west.coord + cPC.west.width/2];

IF cCC.sw # NIL THEN {
[xP, yP] _ FromCorner[co, sw, cCC.sw.ver.coord + cCC.sw.ver.width/2, cCC.sw.hor.coord + cCC.sw.hor.width/2];
xMin _ MAX[xP, xMin];
yMin _ MAX[yP, yMin]};
IF cCC.se # NIL THEN {
[xP, yP] _ FromCorner[co, se, cCC.se.ver.coord - cCC.se.ver.width/2, cCC.se.hor.coord + cCC.se.hor.width/2];
xMax _ MIN[xP, xMax];
yMin _ MAX[yP, yMin]};
IF cCC.ne # NIL THEN {
[xP, yP] _ FromCorner[co, ne, cCC.ne.ver.coord - cCC.ne.ver.width/2, cCC.ne.hor.coord - cCC.ne.hor.width/2];
xMax _ MIN[xP, xMax];
yMax _ MIN[yP, yMax]};
IF cCC.nw # NIL THEN {
[xP, yP] _ FromCorner[co, nw, cCC.nw.ver.coord + cCC.nw.ver.width/2, cCC.nw.hor.coord - cCC.nw.hor.width/2];
xMin _ MAX[xP, xMin];
yMax _ MIN[yP, yMax]};
IF eastCoeff = westCoeff
THEN xP _ (xMin+xMax)/2
ELSE xP _ (eastCoeff * xMin + westCoeff * xMax)/ (eastCoeff + westCoeff);
IF southCoeff = northCoeff
THEN yP _ (yMin+yMax)/2
ELSE yP _ (southCoeff * yMin + northCoeff * yMax)/ (southCoeff + northCoeff);
co.origin _ IntVector[xP, yP];
}; -- PositionComponent--
ConstrainChannels: PUBLIC PROC[co: Component, chs: IPCTG.Ref]  = {
south, east, north, west: Channel;
dimX, dimY: NAT;
[dimX, dimY] _ GetDim[co];
[south, east, north, west] _ co.prinChannels;
IPCTG.ConstrainChannels[chs, south, north, dimY];
IPCTG.ConstrainChannels[chs, west, east, dimX];
{OPEN co.cornerChannels;
swCS, seCS, neCS, nwCS: CornerSpace;
[swCS, seCS, neCS, nwCS] _ GetCornerSps[co];
IF  sw # NIL THEN{ 
IF ne # NIL THEN {
IPCTG.ConstrainChannels[chs, sw.hor, ne.hor, dimY - swCS.y - neCS.y];
IPCTG.ConstrainChannels[chs, sw.ver, ne.ver, dimX - swCS.x - neCS.x]};
IF se # NIL THEN IPCTG.ConstrainChannels[chs, sw.ver, se.ver, dimX - swCS.x - seCS.x]; 
IF nw # NIL THEN IPCTG.ConstrainChannels[chs, sw.hor, nw.hor, dimY - swCS.y - nwCS.y];
IPCTG.ConstrainChannels[chs, sw.ver, east, dimX - swCS.x];
IPCTG.ConstrainChannels[chs, sw.hor, north, dimY - swCS.y]};
IF  se # NIL THEN{ 
IF nw # NIL THEN {
IPCTG.ConstrainChannels[chs, se.hor, nw.hor, dimY - seCS.y - nwCS.y]}; 
IF ne # NIL THEN IPCTG.ConstrainChannels[chs, se.hor, ne.hor, dimY - seCS.y - neCS.y]; 
IPCTG.ConstrainChannels[chs, se.hor, north, dimY - seCS.y];
IPCTG.ConstrainChannels[chs, west, se.ver, dimX - seCS.x];
};
IF  nw # NIL THEN{ 
IF se # NIL THEN {
IPCTG.ConstrainChannels[chs, nw.ver, se.ver, dimX - nwCS.x - seCS.x]};
IF ne # NIL THEN IPCTG.ConstrainChannels[chs, nw.ver, ne.ver, dimX - nwCS.x - neCS.x]; 
IPCTG.ConstrainChannels[chs, south, nw.hor, dimY - nwCS.y];
IPCTG.ConstrainChannels[chs, nw.ver, east, dimX - nwCS.x];
};
IF  ne # NIL THEN{ 
IPCTG.ConstrainChannels[chs, south, ne.hor, dimY - neCS.y];
IPCTG.ConstrainChannels[chs, west, ne.ver, dimX - neCS.x]};
}
}; -- ConstrainChannels--
FromEdge: PUBLIC PROC[co: Component, edge: EdgeTypes, edgeAt: INT] RETURNS [coord: INT] ={
SELECT edge FROM
south => RETURN [edgeAt];
east => RETURN [edgeAt - GetDim[co].x];
north => RETURN [edgeAt - GetDim[co].y];
west => RETURN [edgeAt];
ENDCASE => ERROR;
};--FromEdge--

FromCorner: PUBLIC PROC[co: Component, corner: CornerTypes, CornerAtX, CornerAtY: INT] RETURNS [xCoord, yCoord: INT] ={
cornerX, cornerY: NAT;
[cornerX, cornerY] _ GetCornerSp[co, corner]^;
SELECT corner FROM
sw => {xCoord _ CornerAtX - cornerX; yCoord _ CornerAtY - cornerY;};
se => {xCoord _ CornerAtX - GetDim[co].x + cornerX; yCoord _ CornerAtY - cornerY;};
ne => {xCoord _ CornerAtX - GetDim[co].x + cornerX; yCoord _ CornerAtY - GetDim[co].y +  cornerY;};
nw => {xCoord _ CornerAtX - cornerX; yCoord _ CornerAtY - GetDim[co].y + cornerY;};
ENDCASE => ERROR;
}; --FromCorner--

CCGetCh: PUBLIC PROC[cc: CornerChannels, ot: BO.OrientationTypes] RETURNS [IPCTG.Channel] = {IF cc = NIL THEN RETURN [NIL] ELSE RETURN [IF ot = hor THEN cc.hor ELSE cc.ver];}; --CCGetCh--

OrientCoShapeChk: PUBLIC PROC[co: REF IP.ComponentRep, operation: IP.Orientation] RETURNS [BOOL] ={
IF (operation = CDOrient.original) OR ~ co.active THEN RETURN [TRUE]; 
-- (ii)Can always rotate a non-placed component

FOR corner: CornerTypes IN [sw..nw] DO
IF GetCornerChs[co, corner] #NIL AND GetCornerSp[co, BO.CTOrient[corner, operation]] = NIL THEN RETURN [FALSE]
ENDLOOP;
RETURN [TRUE]
}; --OrientCoShapeChk

OrientCoShape: PUBLIC PROC[co: REF IP.ComponentRep, operation: IP.Orientation] ={
OPEN cSC: co.shape.cornerSpaces;
sw, se, ne, nw: REF IP.NatVector;
[sw, se, ne, nw] _ co.shape.cornerSpaces;
SELECT (operation/2) MOD 4 FROM
0 => NULL;
1, -3 => {cSC.sw _ nw; cSC.se _ sw; cSC.ne _ se; cSC.nw _ ne};
2, -2 => {cSC.sw _ ne; cSC.se _ nw; cSC.ne _ sw; cSC.nw _ se};
3, -1  => {cSC.nw _ sw; cSC.sw _ se; cSC.se _ ne; cSC.ne _ nw};
ENDCASE => ERROR;

IF CDOrient.IncludesMirrorX[operation] THEN {
sw, se, ne, nw: REF IP.NatVector;
[sw, se, ne, nw] _ co.shape.cornerSpaces;
cSC.sw _ se;
cSC.se _ sw;
cSC.nw _ ne;
cSC.ne _ nw;
}; --endIF
}; --OrientCoShape

END.
-- File: IPCoTabImpl.mesa
-- Last Edited by: CSChow, January 27, 1985 6:20:42 am PST
Preas, August 2, 1986 8:41:04 pm PDT
--Note: IPCoTab = ComponentTable

--Documentation will come later after consolidating the design --

--These are the top level global operations on IPCTG--
--Now make pinNets

-- Now Create Component

--(1a) Print name, origin, active, 
--(1b) Print type.name orient
--(2a) Print pinNets

--(2b) Print shape?
--(3) Print surrounding channes
--Get pinNets
--Get shape?
--assumed pinNets are already properly oriened and coord updated
--This always has be done before setting circular pointer, ow. may mess up



--These are operations on individual component --



-- (i) do nothing
--(1) Do Rotate90
-- (2) Do MirrorX

--(a) Swap bottom

--(b) Swap top

ส9
˜Jš
œ™š
œ:™:Icode™$—J˜Jš
œ ™ J™J™AJ™š
ฯk	˜	K–

"Cedar" stylešœœT˜`K–

"Cedar" stylešœœ3˜CK–

"Cedar" stylešœ
˜K–

"Cedar" stylešœœœ˜K–

"Cedar" styleš
œ˜K–

"Cedar" style˜	K–

"Cedar" stylešœœ˜K–

"Cedar" stylešœ
˜K–

"Cedar" styleš
œ˜K–

"Cedar" style˜	K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœ
˜K–

"Cedar" style˜
K–

"Cedar" style˜	K–

"Cedar" style˜
K–

"Cedar" styleš
œ˜K–

"Cedar" style˜
K–

"Cedar" styleš
œ˜—J˜šœ
œ
˜Idefaultšœœ4œ8œ˜•
Lš
œœ
œ
œœ˜E—˜J˜K–

"Cedar" style™6–

"Cedar" stylešฯnœœ
œIœ	˜lK–

"Cedar" stylešœ
œ˜*–

"Cedar" styleš
œ.˜.K–

"Cedar" styleš
œ7˜7K–

"Cedar" styleš
œ$˜$–

"Cedar" stylešœœœ
˜(K–

"Cedar" stylešœ:˜>K–

"Cedar" stylešœ
˜—K–

"Cedar" stylešœœ
œ
œ
˜"K–

"Cedar" stylešœœ
˜!–

"Cedar" stylešœœ œ˜QK–

"Cedar" styleš
œ8˜8K–

"Cedar" styleš	œ	œ
œ
œ
œ@˜WK–

"Cedar" stylešœœBœ˜]Kšœฯc˜—K–

"Cedar" style˜K–

"Cedar" styleš
œ™šœœ
œ,œœ
˜JKšœ
œ!˜/Kšœ
˜—K™K™K–

"Cedar" styleš
œM˜MK–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜K–

"Cedar" styleš
œ!˜!K–

"Cedar" stylešœ˜
K–

"Cedar" stylešœŸœ
˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ˜'–

"Cedar" styleš
œ ˜ K–

"Cedar" stylešœ
œŸ1˜CKšœ%Ÿ1˜VKšœ
œŸ;˜MK–

"Cedar" stylešœŸ
˜
—K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ
˜—K–

"Cedar" style˜–

"Cedar" styleš
žœœ
œœ
œ˜<–

"Cedar" stylešœœ˜!–

"Cedar" stylešœœ
˜K–

"Cedar" stylešœ˜K–

"Cedar" stylešœœœ˜I—K–

"Cedar" stylešœŸ˜—–

"Cedar" stylešœœ˜"K–

"Cedar" stylešœœœŸ˜UK–

"Cedar" stylešœ*˜,K–

"Cedar" stylešœŸ˜—–

"Cedar" styleš
œ˜–

"Cedar" stylešœ0˜4K–

"Cedar" style™K–

"Cedar" styleš
œ#™#K–

"Cedar" stylešœ!œœœ'˜qK–

"Cedar" styleš
œ™K–

"Cedar" styleš
œœœœ
œœœ˜bK–

"Cedar" style˜K–

"Cedar" style™K–

"Cedar" style˜–

"Cedar" stylešœ+œœ
˜>Kš
œ˜Kš
˜—K–

"Cedar" style˜K–

"Cedar" style™K–

"Cedar" style™K–

"Cedar" styleš
œœ
œœ
œ˜NK–

"Cedar" style˜K–

"Cedar" style˜K–

"Cedar" style™–

"Cedar" styleš	œœ
œ
œ
ŸC˜lK–

"Cedar" stylešœœ
˜ K–

"Cedar" stylešœ˜—K–

"Cedar" styleš	œœœœœ˜…
K–

"Cedar" styleš
œ7˜7K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ	˜——K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœ/œ˜DK–

"Cedar" styleš
œ˜K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ	œ
œ5œœœ˜‹
–

"Cedar" stylešœœ
œ˜1K–

"Cedar" stylešœœ˜'K–

"Cedar" stylešœ%œ˜@K–

"Cedar" stylešœ	œ
œ
œ
œœŸ
˜RK–

"Cedar" stylešœœ#œ
˜>K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešœœ
œ˜+K–

"Cedar" styleš
œ˜–

"Cedar" stylešœ˜K–

"Cedar" stylešœ˜
K–

"Cedar" stylešœœS˜`—K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ	˜—–

"Cedar" stylešœœ
œ˜#K–

"Cedar" stylešœœœ˜'K–

"Cedar" stylešœœ˜-K–

"Cedar" stylešœœ˜K–

"Cedar" stylešœ;œ˜BK–

"Cedar" style˜-K–

"Cedar" stylešœœ
˜!K–

"Cedar" style˜K–

"Cedar" styleš
œ
™
K–

"Cedar" stylešœ˜–

"Cedar" stylešœ
œ˜Kšœ
œ˜&Kšœ
˜—K–

"Cedar" style˜K–

"Cedar" style™–

"Cedar" style•StartOfExpansion[]šœœ
˜–

"Cedar" stylešœ˜K–

"Cedar" stylešœœ(˜1K–

"Cedar" stylešœ?œ˜K—K–

"Cedar" stylešœ
œG˜R—K–

"Cedar" stylešœŸ
˜
—–

"Cedar" stylešœ
œ˜ K–

"Cedar" styleš
œ.˜.K–

"Cedar" styleš
œ-˜-K–

"Cedar" styleš
œ.˜.K–

"Cedar" styleš
œ-˜-K–

"Cedar" styleš
œ˜K–

"Cedar" styleš
œ˜K–

"Cedar" styleš
œ˜K–

"Cedar" styleš
œ˜K–

"Cedar" styleš
œE˜EK–

"Cedar" stylešœŸ˜—K–

"Cedar" stylešœœ˜%–

"Cedar" stylešœ˜K–

"Cedar" style˜–

"Cedar" stylešœ˜K–

"Cedar" stylešœ˜K–

"Cedar" stylešœ
œ
˜
—K–

"Cedar" stylešœœ
œœ˜2K–

"Cedar" style˜K–

"Cedar" stylešœ
˜—K–

"Cedar" stylešœ
œ&œ
œ
˜7K–

"Cedar" stylešœŸœ˜—K–

"Cedar" style˜–

"Cedar" stylešž	œœ
œ˜%–

"Cedar" styleš
œ˜–

"Cedar" stylešœG˜KK–

"Cedar" stylešœ#œ
œŸ˜BK–

"Cedar" styleš	œ
œœ
œŸ˜;K–

"Cedar" styleš
œ
œ
œ œ
œ
˜7K–

"Cedar" styleš
œ
œ
œœ
œ
˜6K–

"Cedar" styleš
œ
œ
œ œ
œ
˜7K–

"Cedar" styleš
œ
œ
œœ
œ
˜6–

"Cedar" stylešœ	œ
œ˜K–

"Cedar" stylešœ	œ
œ
œ
˜K–

"Cedar" stylešœ
œ'œ
œ
˜:K–

"Cedar" stylešœ
œ'œ
œ
˜:K–

"Cedar" styleš
œ
œ$œ"œ
œ˜`—–

"Cedar" stylešœ	œ
œ˜K–

"Cedar" stylešœ	œ
œ
œ
˜K–

"Cedar" stylešœ
œ&œ
œ
˜9K–

"Cedar" stylešœ
œ'œ
œ
˜:K–

"Cedar" styleš
œ
œ#œ"œ
œ˜_—–

"Cedar" stylešœ	œ
œ˜K–

"Cedar" stylešœ	œ
œ
œ
˜K–

"Cedar" stylešœ
œ&œ
œ
˜9K–

"Cedar" stylešœ
œ&œ
œ
˜9K–

"Cedar" styleš
œ
œ#œ!œ
œ˜^—–

"Cedar" stylešœ	œ
œ˜K–

"Cedar" stylešœ	œ
œ
œ
˜K–

"Cedar" stylešœ
œ'œ
œ
˜:K–

"Cedar" stylešœ
œ&œ
œ
˜9K–

"Cedar" styleš
œ
œ$œ!œ
œ˜_——K–

"Cedar" stylešœŸ˜	—K–

"Cedar" style˜K–

"Cedar" stylešœŸœ˜—K–

"Cedar" style˜–

"Cedar" stylešž	œœ
œ9œœœ4œœ˜ส
K–

"Cedar" style˜–

"Cedar" styleš
œ˜K–

"Cedar" styleš
œS˜SK–

"Cedar" styleš
œT˜TK–

"Cedar" stylešœŸ˜—K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ
˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œœUœXœœœ˜K–

"Cedar" style™@K–

"Cedar" stylešœœœ.˜EK–

"Cedar" stylešœœz˜‚
–

"Cedar" stylešœœ
œ
œ
œ
œ!˜XK–

"Cedar" stylešœ)Ÿœ™J—K–

"Cedar" stylešœ!Ÿ<˜]K–

"Cedar" stylešœ(Ÿ4˜\Kšœœ&Ÿ4˜hK–

"Cedar" stylešœŸœ
˜—K–

"Cedar" style™–

"Cedar" stylešžœœ
œœ	œœEœœ˜พ
–

"Cedar" stylešœœ
˜K–

"Cedar" stylešœœ[˜hK–

"Cedar" stylešœ˜—K–

"Cedar" stylešœœ
œ%˜:K–

"Cedar" stylešœ!œ
œ
œ
œ
œ!˜[K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ˜=Kšœœ
œ$˜9šœœ
œ˜Kš
œ)˜)Kšœ
œ˜—K–

"Cedar" styleš
œ!˜!K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" styleš
žœœ
œ
œ
œ˜-K–

"Cedar" stylešœŸ˜&—K–

"Cedar" style˜–

"Cedar" styleš
žœœ
œ
œœ˜P–

"Cedar" styleš
œ˜–

"Cedar" stylešœ˜
K–

"Cedar" stylešœ˜K–

"Cedar" stylešœœ
˜ —K–

"Cedar" stylešœŸ˜—K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜K–

"Cedar" style˜–

"Cedar" stylešžœœ
œœœœœœ˜v–

"Cedar" styleš
œ!˜!K–

"Cedar" stylešœœœŸ
œ
˜Q—K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœ
œ
œœ
œ
œH˜wK–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešž
œœ
œ)˜@K–

"Cedar" style–? -- [key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL] -- šœะck>œœœ
œœœ
œŸœ
˜ญ
K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešž
œœ
œ)˜CK–? -- [key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL] -- –

"Cedar" styleš	œ >œœœŸœ
˜‡
K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ'œ˜DK–

"Cedar" stylešœœ
œ
˜K–

"Cedar" stylešœœ
œ
œE˜sK–

"Cedar" stylešœ"Ÿ˜5K–

"Cedar" style˜K–

"Cedar" style˜!K–

"Cedar" stylešœŸ˜—K–

"Cedar" style™K–

"Cedar" style™K–

"Cedar" style™1–

"Cedar" styleš
žœœ
œœœ˜8–

"Cedar" stylešœ&˜(K–

"Cedar" stylešœ˜K–

"Cedar" stylešœ˜—K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ˜4K–

"Cedar" stylešœ˜K–

"Cedar" styleš
œ)˜)K–

"Cedar" stylešœŸ˜—–

"Cedar" stylešžœœ
œ˜4K–

"Cedar" stylešœ˜K–

"Cedar" styleš
œ(˜(K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œœ˜:K–

"Cedar" stylešœœ
˜K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœS˜YK–

"Cedar" stylešœŸ˜—–

"Cedar" stylešžœœ
œœœœ˜eK–

"Cedar" styleš
œ$˜$K–

"Cedar" style˜K–

"Cedar" stylešœœ
˜K–

"Cedar" styleš
œ˜K–

"Cedar" styleš
œ,˜,K–

"Cedar" stylešœœ
œ^˜pK–

"Cedar" stylešœœ
œl˜~K–

"Cedar" stylešœœ
œt˜†
K–

"Cedar" style–[]šœœ
œm˜~K–

"Cedar" stylešœŸ˜—K–

"Cedar" style™–

"Cedar" styleš
žœœ
œœ
œ˜RK–

"Cedar" style˜–

"Cedar" stylešœ˜Kšœœ
œ˜+Kšœœ˜Kšœ
˜—Kšœ
œœ;˜fK–

"Cedar" stylešœŸž˜—–

"Cedar" stylešž	œœ
œœ
˜I–

"Cedar" stylešœ˜–

"Cedar" stylešœ˜Kšœ	œ
˜Kšœœ˜Kšœ	œ
˜Kšœœ˜KšœœŸ˜"———–

"Cedar" stylešž	œœ
œ.˜D–

"Cedar" stylešœ˜–

"Cedar" stylešœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜KšœœŸ˜"———K–

"Cedar" style˜–

"Cedar" styleš
žœœ
œœ
œ˜VK–

"Cedar" style˜–

"Cedar" stylešœ˜Kšœ&œ
œ˜9Kšœœ˜Kšœ
˜—Kšœ
œœ8˜cK–

"Cedar" stylešœŸœ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ!œ˜U–

"Cedar" stylešœ˜–

"Cedar" stylešœ˜Kšœœ
˜Kšœœ
˜Kšœœ
˜Kšœœ
˜KšœœŸ˜%———–

"Cedar" stylešžœœ
œ7˜P–

"Cedar" stylešœ˜–

"Cedar" stylešœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜KšœœŸ˜%———K–

"Cedar" stylešžœœ
œ%œœœ
œ'Ÿ˜ฏ
K–

"Cedar" style˜–

"Cedar" stylešž
œœ
œ/œ˜ZK–

"Cedar" styleš
œ˜–

"Cedar" stylešœ&œ
˜,K–

"Cedar" stylešœœ%˜BK–

"Cedar" stylešœ0˜4—K–

"Cedar" stylešœŸœ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ!œ˜U–

"Cedar" stylešœ˜ –

"Cedar" stylešœ	œœ
˜K–

"Cedar" styleš
œ
˜
Kš
œ
˜
Kš
œ
˜
Kš
œ
˜
Kšœœ
˜—šœœ
œ'˜6KšœœŸ˜;—KšœŸ˜——K–

"Cedar" style˜–

"Cedar" stylešžœœœ!˜Q–

"Cedar" stylešœ˜ K–

"Cedar" stylešœœ(˜4–

"Cedar" stylešœœ
œ˜"K–

"Cedar" stylešœœŸ˜8—–

"Cedar" stylešœœ
œ˜"K–

"Cedar" stylešœœŸ˜8—–

"Cedar" stylešœœ
œ˜"K–

"Cedar" stylešœœŸ˜8—–

"Cedar" stylešœœ
œ˜"K–

"Cedar" stylešœœŸ˜8—K–

"Cedar" style˜—K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œœœœœ˜lK–

"Cedar" stylešœ.˜2–

"Cedar" stylešœ˜Kšœ	œ
˜Kšœœ˜Kšœ	œ
˜Kšœœ˜šœ	œ
œ
˜Kš
œ
œœœœ
˜:Kšœ
œ˜—šœ	œ
œ
˜Kš
œ
œœœœ
˜:Kšœ
œ˜—šœ	œ
œ
˜Kš
œ
œœœœ
˜:Kšœ
œ˜—šœ	œ
œ
˜Kš
œ
œœœœ
˜:Kšœ
œ˜—šœ	œ
œ
˜Kš
œ
œœœ
œ˜:Kšœ
œ˜—šœ	œ
œ
˜Kš
œ
œœœ
œ˜:Kšœ
œ˜—šœ	œ
œ
˜Kš
œ
œœœ
œ˜:Kšœ
œ˜—šœ	œ
œ
˜Kš
œ
œœœ
œ˜:Kšœ
œ˜—Kšœœœ˜"Kšœœ
˜—K–

"Cedar" stylešœŸ
˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ<œœœ œœ˜ผ
K–

"Cedar" styleš
œ˜Kš
œ˜Kšœœ
˜Kšœœ
˜Kš
œ˜Kš
œ-˜-Kš
œ+˜+K˜Kš
œ˜Kš
œ˜Kš
œ$˜$šœœœ˜Kš
œC˜CKš
œ>˜>Kšœ*œ˜1Kš
œ.˜.—šœœ
œ˜Kš
œD˜DKš
œ>˜>Kšœ2œ
˜7Kš
œ2˜2—šœœ
œ˜Kš
œD˜DKš
œE˜EKšœ2œ˜8Kš
œ1˜1—šœœ
œ˜Kš
œ>˜>Kš
œE˜EKšœ+œ˜1Kš
œ*˜*—šœœ
œ˜Kšœ@œ˜FKš
œ*˜*—šœ
˜Kšœ+˜/KšœL
œ˜S—šœ
œ˜KšœœI˜UKšœ	œ
˜Kš
œ˜Kš
œ4˜4Kš
œ#˜#—K–

"Cedar" stylešœŸ˜—–

"Cedar" stylešžœœ
œTœ˜yK–

"Cedar" style˜K–

"Cedar" styleš
œ-˜-K–

"Cedar" styleš
œ%˜%K–

"Cedar" style˜K–

"Cedar" styleš	œ	œœ
œœ˜+K–

"Cedar" styleš	œ	œœ
œœ˜,K–

"Cedar" stylešœ1˜6K–

"Cedar" style˜K–

"Cedar" styleš	œ	œœ
œœ˜,K–

"Cedar" styleš	œ	œœ
œœ˜-K–

"Cedar" stylešœ0˜5K–

"Cedar" style˜K–

"Cedar" styleš	œ	œœ
œœ˜+K–

"Cedar" styleš	œ	œœ
œœ˜,K–

"Cedar" stylešœ1˜6K–

"Cedar" style˜K–

"Cedar" styleš	œ	œœ
œœ˜,K–

"Cedar" styleš	œ	œœ
œœ˜-K–

"Cedar" stylešœ0˜5K–

"Cedar" style˜K–

"Cedar" styleš
œœ
œœ#œ#˜bK–

"Cedar" styleš
œœ
œœ#œ#˜bK–

"Cedar" styleš
œœ
œœ#œ#˜bK–

"Cedar" styleš
œœ
œœ#œ#˜bK–

"Cedar" stylešœŸ˜K–

"Cedar" style˜—–

"Cedar" stylešžœœ
œ>œ	˜h–

"Cedar" stylešœ.˜2K–

"Cedar" stylešœ œ
˜$K–

"Cedar" stylešœœ˜DK–

"Cedar" stylešœœ˜@K–

"Cedar" styleš
œ@˜@K–

"Cedar" styleš
œ=˜=K–

"Cedar" styleš
œ@˜@K–

"Cedar" styleš
œ=˜=K–

"Cedar" style˜–

"Cedar" stylešœ
œ
œ˜K–

"Cedar" styleš
œl˜lK–

"Cedar" stylešœœ˜K–

"Cedar" stylešœœ˜—–

"Cedar" stylešœ
œ
œ˜K–

"Cedar" styleš
œl˜lK–

"Cedar" stylešœœ˜K–

"Cedar" stylešœœ˜—–

"Cedar" stylešœ
œ
œ˜K–

"Cedar" styleš
œl˜lK–

"Cedar" stylešœœ˜K–

"Cedar" stylešœœ˜—–

"Cedar" stylešœ
œ
œ˜K–

"Cedar" styleš
œl˜lK–

"Cedar" stylešœœ˜K–

"Cedar" stylešœœ˜—–

"Cedar" stylešœ˜K–

"Cedar" stylešœ˜K–

"Cedar" stylešœE˜I—–

"Cedar" stylešœ˜K–

"Cedar" stylešœ˜K–

"Cedar" stylešœI˜M—K–

"Cedar" style˜K–

"Cedar" stylešœŸ˜——K–

"Cedar" style™–

"Cedar" stylešžœœ
œœ
˜BK–

"Cedar" style˜"K–

"Cedar" stylešœ˜K–

"Cedar" styleš
œ˜K–

"Cedar" style˜-K–

"Cedar" stylešœ,˜1Lšœ*˜/šœ
œ˜L˜$Lš
œ,˜,šœœ
œ˜šœœ
œ˜Lšœ@˜ELšœA˜F—Lšœœ
œ
œA˜WLšœœ
œ
œ@˜VLšœ5˜:Lšœ7˜<—šœœ
œ˜šœœ
œ˜LšœB˜G—Lšœœ
œ
œA˜WLšœ6˜;Lšœ5˜:Lš
œ˜—šœœ
œ˜šœœ
œ˜KšœA˜F—Lšœœ
œ
œA˜WLšœ6˜;Lšœ5˜:Lš
œ˜—šœœ
œ˜Lšœ6˜;Lšœ6˜;—Lš
œ
˜
—LšœŸ˜—K–

"Cedar" style™–

"Cedar" stylešžœœ
œ)œœ	œ˜Z–

"Cedar" stylešœ˜Kšœ	œ
˜Kšœœ˜'Kšœ	œ˜(Kšœœ
˜Kšœœ
˜—K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešž
œœ
œ;œœœ˜wK–

"Cedar" style–[]šœœ
˜K–

"Cedar" styleš
œ.˜.–

"Cedar" stylešœ˜Kš
œD˜DKš
œS˜SKš
œc˜cKš
œS˜SKšœœ
˜—K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜K–

"Cedar" styleš!žœœ
œœœœ
œœ
œ
œœœ
œœ
œœŸ˜ป
K–

"Cedar" style˜šžœœ
œœ
œœœœ˜cš
œ!œ
œ
œœ˜FK™Kš
Ÿ/˜/—K˜šœœ
˜&Kšœœ
œœ œ
œ
œœ
˜nKšœ
˜—Kšœœ
˜
KšœŸ˜—K˜š
ž
œœœ
œœ˜Qšœ˜ K™Kšœœ
œ˜!Jš
œ)˜)šœœ˜Kšœœ
˜
Kš
œ>˜>Kš
œ>˜>Kš
œ?˜?Kšœœ
˜—J˜K™šœ%œ˜-Kšœœ
œ˜!Jš
œ)˜)J™Jš
œ™Jš
œ˜Jš
œ˜J™Jš
œ™Jš
œ˜Jš
œ˜JšœŸ˜
——KšœŸ˜—K–

"Cedar" style˜K–

"Cedar" stylešœ
˜K–

"Cedar" style™——…—cnŸ†