DIRECTORY
Rope USING [ROPE, Concat, Equal, Cat],
Convert USING[RopeFromInt],
RefTab  USING [Create, Pairs, EachPairAction, Fetch, Store, Delete, GetSize],
IO,
Imager USING[Context, MaskStroke, PathProc, SetXY, ShowRope, SetGray],
List USING [AList, Assoc, PutAssoc],
CCG,
IP,
IPCB,
IPConstants USING[Black],
IPParams USING[ChDefaultWidth, ChMinLSeparation, ChMinLength],
IPCTG;

IPCTGImpl: CEDAR PROGRAM
IMPORTS RefTab, Imager, IO, Rope, Convert, List, CCG, IP, IPParams, IPCB
EXPORTS IPCTG = BEGIN OPEN IPCTG;

HorChPrefix: Rope.ROPE = "h";
VerChPrefix: Rope.ROPE = "v";

ChannelTypeMismatch: PUBLIC ERROR = CODE;
CyclicConstraints: PUBLIC ERROR [negCh, posCh: Channel] = CODE;


Create: PUBLIC PROC[] RETURNS[Ref] ={
RETURN[NEW[Rep _ [horCCG: CCG.Create[], verCCG: CCG.Create[], extConstraintsTable: RefTab.Create[]]]]
}; --Create-- 

DescribeSelf: PUBLIC PROC[ctg: Ref, stream: IO.STREAM] ={
pI: EachIntersectionAction ={stream.PutF[" %g %g", IO.rope[i.ch.name], IO.int[i.type]]}; --pI--
pCh1: EachChannelAction ={
stream.PutF["%g\t%g %g %g\n", IO.rope[ch.name], IO.rope[SELECT ch.type FROM hor => "hor", ver => "ver", ENDCASE => ERROR], IO.int[ch.coord], IO.int[ch.width]];
}; --pCh1--
pCh2: EachChannelAction ={
stream.PutF["%g\t", IO.rope[ch.name]];
[] _ pI[End[ch, neg]];
[] _ pI[End[ch, pos]];
stream.PutF[" ("];
[] _ Intersections[ch, neg, pI];
stream.PutF[") "];
stream.PutF["("];
[] _ Intersections[ch, pos, pI];
stream.PutF[")\n"];}; --pCh2--
pCon: RefTab.EachPairAction -- [key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOLEAN] --  = {
quit _ FALSE;
stream.PutF["\n%g\t[", IO.rope[NARROW[key, Channel].name]];
FOR l: List.AList _ NARROW[val], l.rest UNTIL l = NIL DO
stream.PutF[" %g %g", IO.rope[NARROW[l.first.key, Channel].name], IO.int[NARROW[l.first.val, REF INT]^]];
ENDLOOP;
stream.PutF["]"];
}; -- pCon--
stream.PutF["\nBeginCTG"];
stream.PutF["\n%g \t--Number of channels\n", IO.int[ctg.horCCG.Size + ctg.verCCG.Size]];
stream.PutF["%g %g\t--Horzontal & Vertical channel name counters\n", IO.int[ctg.horChNameCounter], IO.int[ctg.verChNameCounter]];
[] _ Channels[ctg, pCh1];
[] _ Channels[ctg, pCh2];
stream.PutF["\n%g \t--Number of external constraints", IO.int[ctg.extConstraintsTable.GetSize]];
[] _ ctg.extConstraintsTable.Pairs[pCon];
stream.PutF["\nEndCTG\n"];
}; --DescribeSelf--

ReconstructSelf: PUBLIC PROC[stream: IO.STREAM] RETURNS [ctg: Ref] ={
makeCh: PROC ={
name: Rope.ROPE _ stream.GetID;
type: ChType _ IF Rope.Equal[stream.GetID, "ver"] THEN ver ELSE hor;
coord: INT _ stream.GetInt;
width: NAT _ stream.GetInt;
[] _ CreateChannel[ctg, type, width, coord, name]}; --makeCh--
makeI: PROC RETURNS [Intersection] ={
RETURN [NEW[IntersectionRep _ [GetChannel[ctg, stream.GetID], stream.GetInt]]]}; --makeI--
makeIs: PROC RETURNS [LIST OF Intersection] ={
lHd, lTl: LIST OF Intersection;
lHd_ lTl _ CONS[NIL, NIL];
[] _ stream.GetCedarTokenRope;
WHILE stream.PeekChar # ') DO
lTl.rest _ CONS[NEW[IntersectionRep _ [GetChannel[ctg, stream.GetID], stream.GetInt]], NIL];
lTl _ lTl.rest;
ENDLOOP;
[] _ stream.GetCedarTokenRope;
RETURN [lHd.rest]}; --makeIs--
chCount: NAT _ stream.GetInt;
ctg _ Create[];
ctg.horChNameCounter _ stream.GetInt;
ctg.verChNameCounter _ stream.GetInt;
THROUGH [0..chCount) DO
makeCh
ENDLOOP;
THROUGH [0..chCount) DO
ch: Channel _ GetChannel[ctg, stream.GetID];
negEnd: Intersection _ makeI[];
posEnd: Intersection _ makeI[];
negSide: LIST OF Intersection _ makeIs[];
posSide: LIST OF Intersection _ makeIs[];
IPCB.SetBoundary[ch.boundary, negEnd, posEnd, negSide, posSide];
ENDLOOP;

THROUGH [0..stream.GetInt) DO
ch: Channel _ GetChannel[ctg, stream.GetID];
[] _ stream.GetCedarTokenRope;
WHILE stream.PeekChar # '] DO
nCh: Channel _ GetChannel[ctg, stream.GetID];
wt: NAT _ stream.GetInt;
SetExternalConstraint[ctg, ch,  nCh, wt]
ENDLOOP;
[] _ stream.GetChar;
ENDLOOP;
IF NOT Rope.Equal[stream.GetID, "EndCTG"] THEN ERROR;
};--ReconstructSelf--

CheckSelf: PUBLIC PROC[ctg: Ref] ={
pCh: EachChannelAction ={
cbRef: IPCB.Ref _ ch.boundary;
IF NOT ch.chNode IN [1..Size[ctg, ch.type]] THEN ERROR;
IF GetChannel[ctg, ch.name] # ch THEN ERROR;
IF cbRef.owner # ch THEN ERROR;
IPCB.CheckSelf[cbRef];
BEGIN
negIs: LIST OF IPCB.IntersectionNode _ NIL;
pI: IPCB.EachINodeAction ={negIs _ CONS[iNd, negIs]};
IPCB.IntersectionNodes[cbRef, pI, neg];
FOR l: LIST OF IPCB.IntersectionNode _ negIs, l.rest UNTIL l = NIL DO
i: Intersection _ l.first.intersection;
iNd: IPCB.IntersectionNode;
SELECT i.type FROM
IPCB.TNeg => IF IPCB.GetINode[cbRef, i.ch, pos] # NIL THEN ERROR;
IPCB.Cross => IF (iNd _ IPCB.GetINode[cbRef, i.ch, pos]) = NIL THEN ERROR ELSE {
IF iNd.dual = l.first.dual OR iNd.intersection = i THEN ERROR}; --Different copies--
ENDCASE => ERROR;
ENDLOOP;
END;
BEGIN
pCo: EachComponentAction ={IF co = NIL OR co.active THEN NULL ELSE ERROR}; --pCo--
[] _ IPCB.Components[ch.boundary, neg, pCo];
[] _ IPCB.Components[ch.boundary, pos, pCo];
END;
}; --pCh--

[] _ Channels[ctg, pCh];}; --CheckSelf--

DestroySelf: PUBLIC PROC[ctg: Ref] ={
p: EachChannelAction ={IPCB.Destroy[ch.boundary]; ch.boundary _ NIL}; --p--
[] _ Channels[ctg, p]
}; -- DestroySelf--

PaintSelf: PUBLIC PROC[ctg: Ref, context: Imager.Context, xOffset, yOffset: REAL _ 0.0, scaleFactor: REAL _ 1.0, showChName: BOOL _ TRUE] ={
p: EachChannelAction ={PaintChannel[ch, context, xOffset, yOffset, scaleFactor, showChName]}; --p--
[] _ Channels[ctg, p];
}; --PaintSelf--

CreateChannel: PUBLIC PROC[ctg: Ref, type: ChType, width: NAT _ IPParams.ChDefaultWidth, coord: INT _ 0, name: Rope.ROPE _ NIL] RETURNS[ch: Channel] ={
SELECT type FROM
hor => {
ch _ NEW[ChannelRep _ [type: type, name: name, slack:, width: width, coord: coord]];
ch.chNode _ ctg.horCCG.CreateNode[ch];
IF name = NIL THEN {ch.name _ Rope.Concat[HorChPrefix, Convert.RopeFromInt[ctg.horChNameCounter _ ctg.horChNameCounter.SUCC]]}
};
ver => {
ch _ NEW[ChannelRep _ [type: type, name: name, slack:, width: width, coord: coord]];
ch.chNode _ ctg.verCCG.CreateNode[ch];
IF name = NIL THEN {ch.name _ Rope.Concat[VerChPrefix, Convert.RopeFromInt[ctg.verChNameCounter _ ctg.verChNameCounter.SUCC]]};
};
ENDCASE => ERROR;
ch.boundary _ IPCB.Create[ch];
RETURN[ch]}; --CreateChannel-- 

DeActivateChannel: PUBLIC PROC[ctg: Ref, ch: Channel] ={
p: CCG.CleanUpChsProc ={NARROW[chToMove, Channel].chNode _ ch.chNode}; --p--
SELECT ch.type FROM
hor => ctg.horCCG.DestroyNode[ch.chNode, p];
ver => ctg.verCCG.DestroyNode[ch.chNode, p];
ENDCASE => ERROR;
ch.chNode _ 0;
ch.boundary _ NIL;
}; --DeActivateChannel--

ReActivateChannel: PUBLIC PROC[ctg: Ref, ch: Channel] ={
ch.boundary _ IPCB.Create[ch];
SELECT ch.type FROM
hor => ch.chNode _ ctg.horCCG.CreateNode[ch];
ver => ch.chNode _ ctg.verCCG.CreateNode[ch];
ENDCASE => ERROR;
}; --ReActivateChannel--

Size: PUBLIC PROC[ctg: Ref, type: ChType] RETURNS[NAT] ={
SELECT type FROM
hor => {RETURN [ctg.horCCG.Size]};
ver => {RETURN [ctg.verCCG.Size]};
ENDCASE => ERROR;}; --Size--

GetChannel: PUBLIC PROC[ctg: Ref, name: Rope.ROPE, raiseError: BOOL _ TRUE] RETURNS[channel: Channel _ NIL] ={
findName: EachChannelAction = {
IF Rope.Equal[name, ch.name]  THEN {channel _ ch; quit _ TRUE}}; -- findName-- 
[] _ Channels[ctg, findName];
IF channel = NIL AND raiseError THEN ERROR IP.Error[missingRegistration, Rope.Cat[name, " is not a channel name"]];
}; --GetChannel--

DirectedChannels: PUBLIC PROC[ctg: Ref, p: EachChannelAction, chType: ChType] RETURNS[BOOL] = {
-- Enumerate all channels of chType (hor or ver) or until p returns true. Returns TRUE <=> p returns FALSE ON ALL Channels.
p1: CCG.EachChAction ={RETURN[p[NARROW[ch]]]}; --p1--
SELECT chType FROM
hor => {RETURN[ctg.horCCG.Chs[p1]]};
ver => {RETURN[ctg.verCCG.Chs[p1]]};
ENDCASE => ERROR;
};

Channels: PUBLIC PROC[ctg: Ref, p: EachChannelAction, horChsFirst: BOOL _ TRUE] RETURNS[BOOL] ={
p1: CCG.EachChAction ={RETURN[p[NARROW[ch]]]}; --p1--
IF horChsFirst 
THEN {IF ctg.horCCG.Chs[p1] THEN RETURN[ctg.verCCG.Chs[p1]]}
ELSE {IF ctg.verCCG.Chs[p1] THEN RETURN[ctg.horCCG.Chs[p1]]};
RETURN [FALSE]
}; --Channels--

ConstrainChannels: PUBLIC PROC[ctg: Ref, negCh, posCh: Channel, wt: INT] = {
ConstrainChannels0[ctg, negCh, posCh, wt + negCh.width/2 + posCh.width/2]}; --ConstrainChannels--

ConstrainChannels0: PUBLIC PROC [ctg: Ref, negCh, posCh: Channel, wt: INT] ={
IF negCh.type # posCh.type THEN ERROR ChannelTypeMismatch;
SELECT negCh.type FROM
hor => {ctg.horCCG.ConstrainNodes[negCh.chNode, posCh.chNode, wt]};
ver => {ctg.verCCG.ConstrainNodes[negCh.chNode, posCh.chNode, wt]};
ENDCASE => ERROR;}; --ConstrainChannels0--


SetExternalConstraint: PUBLIC PROC[ctg: Ref, negCh, posCh: Channel, wt: INT] ={
found: BOOL; 
val: REF;
alist: List.AList;
IF negCh.type # posCh.type THEN ERROR ChannelTypeMismatch;
SELECT negCh.type FROM
hor => {IF ctg.horCCG.CyclicConstrainp[negCh.chNode, posCh.chNode] THEN ERROR CyclicConstraints[negCh, posCh]};
ver => {IF ctg.verCCG.CyclicConstrainp[negCh.chNode, posCh.chNode] THEN ERROR CyclicConstraints[negCh, posCh]};
ENDCASE => ERROR;
[found, val] _ ctg.extConstraintsTable.Fetch[negCh];
IF found THEN {
refWt: REF;
alist _ NARROW[val];
IF (refWt _ List.Assoc[posCh, alist]) # NIL AND NARROW[refWt, REF INT]^ >= wt THEN RETURN};
[] _ ctg.extConstraintsTable.Store[negCh, List.PutAssoc[posCh, NEW[INT_wt], alist]];
}; --SetExternalConstraint--


ClearExternalConstraints: PUBLIC PROC[ctg: Ref, negCh: Channel, posCh: Channel _ NIL] ={
found: BOOL;
val: REF;
alist: List.AList;
IF posCh = NIL THEN {[] _ ctg.extConstraintsTable.Delete[negCh]; RETURN};
IF negCh.type # posCh.type THEN ERROR ChannelTypeMismatch;
[found, val] _ ctg.extConstraintsTable.Fetch[negCh];
IF found THEN {
alist _ NARROW[val];
[]_ ctg.extConstraintsTable.Store[negCh, List.PutAssoc[posCh, NIL, alist]];
}
}; --ClearExternalConstraints -- 

ClearAllExternalConstraints: PUBLIC PROC[ctg: Ref] ={
ctg.extConstraintsTable _ RefTab.Create[];
}; -- ClearAllExternalConstraints-- 

AddTopologicalConstraints: PUBLIC PROC[ctg: Ref] ={
p: EachChannelAction ={
IF End[ch, pos].type # IPCB.TEnd OR End[ch, neg].type # IPCB.TEnd THEN {
IF End[ch, pos].type * End[ch, neg].type = IPCB.LNeg AND NoIntersection[ch, pos] AND NoIntersection[ch, neg] THEN{
ConstrainChannels0[ctg, End[ch, neg].ch, End[ch, pos].ch, IPParams.ChMinLength]} ELSE {
SELECT End[ch, pos].type FROM
IPCB.Cross => NULL;
IPCB.LNeg => IF NthIntersection[ch, pos, -1] # NIL AND NthIntersection[ch, pos, -1].type # IPCB.Cross THEN ConstrainChannels0[ctg, NthIntersection[ch, pos, -1].ch, End[ch, pos].ch, IPParams.ChMinLSeparation];
IPCB.LPos => IF NthIntersection[ch, neg, -1] # NIL AND NthIntersection[ch, neg, -1].type # IPCB.Cross THEN ConstrainChannels0[ctg, NthIntersection[ch, neg, -1].ch, End[ch, pos].ch, IPParams.ChMinLSeparation];
ENDCASE => ERROR;
SELECT End[ch, neg].type FROM
IPCB.Cross => NULL;
IPCB.LNeg => IF NthIntersection[ch, pos, 1] # NIL AND NthIntersection[ch, pos, 1].type # IPCB.Cross THEN ConstrainChannels0[ctg, End[ch, neg].ch, NthIntersection[ch, pos, 1].ch, IPParams.ChMinLSeparation];
IPCB.LPos => IF NthIntersection[ch, neg, 1] # NIL AND NthIntersection[ch, neg, 1].type # IPCB.Cross THEN ConstrainChannels0[ctg, End[ch, neg].ch, NthIntersection[ch, neg, 1].ch, IPParams.ChMinLSeparation];
ENDCASE => ERROR;}
}}; --p-- 

[] _ Channels[ctg, p];

}; --AddTopologicalConstraints --


AddExternalConstraints: PUBLIC PROC[ctg: Ref] = {
EachConstraintIter: RefTab.EachPairAction -- [key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOLEAN] --  = {
negCh: Channel _ NARROW[key];
quit _ FALSE;
FOR alist: List.AList _ NARROW[val], alist.rest UNTIL alist = NIL DO
posCh: Channel _ NARROW[alist.first.key];
wt: INT _ NARROW[alist.first.val, REF INT]^;
ConstrainChannels0[ctg, negCh, posCh, wt];
ENDLOOP;
}; --EachConstraintIter --

[] _ ctg.extConstraintsTable.Pairs[EachConstraintIter];
}; -- AddExternalConstraints-- 

RefreshAllConstraints: PUBLIC PROC [ctg: Ref] ={
ctg.verCCG.ResetAllNodes;
ctg.horCCG.ResetAllNodes;
}; --RefreshAllConstraints--

ComputeGeometry: PUBLIC PROC[ctg: Ref, xPosition, yPosition: INT, horPosSense, verPosSense: BOOL _ TRUE]={
AssignCoordAndComputeSlack: EachChannelAction = {
posSense: BOOL _ SELECT ch.type FROM 
hor => horPosSense,
ver => verPosSense,
ENDCASE => ERROR;
chGraph: CCG.Ref _ SELECT ch.type FROM 
hor => ctg.horCCG,
ver => ctg.verCCG,
ENDCASE => ERROR;
ch.slack.neg _ chGraph.NodePosition[ch.chNode, pos]; --ch.slack.neg <= ch.slack.pos
ch.slack.pos _ chGraph.NodePosition[ch.chNode, neg];
ch.coord _ chGraph.NodePosition[ch.chNode, IF posSense THEN pos ELSE neg];
chGraph.ResetNode[ch.chNode];
}; --AssignCoordAndComputeSlack --

hCCG: CCG.Ref = ctg.horCCG;
vCCG: CCG.Ref = ctg.verCCG;
hRoot, vRoot: CCG.NodeIndex;
hRoot _ hCCG.FindRoot[pos];
vRoot _ vCCG.FindRoot[pos];
hCCG.SetNodePosition[hRoot, pos, yPosition];
vCCG.SetNodePosition[vRoot, pos, xPosition];
hCCG.PosAssignNodePosition[hRoot];
vCCG.PosAssignNodePosition[vRoot];

hRoot _ hCCG.FindRoot[neg];
vRoot _ vCCG.FindRoot[neg];
hCCG.SetNodePosition[hRoot, neg, hCCG.NodePosition[hRoot, pos]];
vCCG.SetNodePosition[vRoot, neg, vCCG.NodePosition[vRoot, pos]];
hCCG.NegAssignNodePosition[hRoot];
vCCG.NegAssignNodePosition[vRoot];
[] _ Channels[ctg, AssignCoordAndComputeSlack];
}; --ComputeGeometry -- 


GetBoundingChannels: PUBLIC PROC[ctg: Ref] RETURNS [southMost, eastMost, northMost, westMost: Channel] ={
hCCG: CCG.Ref = ctg.horCCG;
vCCG: CCG.Ref = ctg.verCCG;
hRoot, vRoot: CCG.NodeIndex;
hRoot _ hCCG.FindRoot[pos];
vRoot _ vCCG.FindRoot[pos];
southMost _ NARROW[hCCG.GetCh[hRoot]];
westMost _ NARROW[vCCG.GetCh[vRoot]];
hRoot _ hCCG.FindRoot[neg];
vRoot _ vCCG.FindRoot[neg];
northMost _ NARROW[hCCG.GetCh[hRoot]];
eastMost _ NARROW[vCCG.GetCh[vRoot]];
}; --GetBoundingChannels--

PaintChannel: PUBLIC PROC [ch: Channel, context: Imager.Context, xOffset, yOffset: REAL _ 0.0, scaleFactor: REAL _ 1.0, showName: BOOL _ TRUE] ={
negCh: Channel _ End[ch, neg].ch;
posCh: Channel _ End[ch, pos].ch;
Imager.SetGray[context, IPConstants.Black];
SELECT ch.type FROM
ver => {x: REAL _ xOffset + (ch.coord * scaleFactor);
-- Imager.SetXYI[context, x, yOffset + (negCh.coord * scaleFactor)];
-- Imager.DrawTo[context, x, yOffset + (posCh.coord * scaleFactor)];
path: Imager.PathProc ~ {
moveTo[[x, yOffset + (negCh.coord * scaleFactor)]];
lineTo[[x, yOffset + (posCh.coord * scaleFactor)]];
};
Imager.MaskStroke[context, path];
Imager.SetXY[context, [x, yOffset + (negCh.coord + posCh.coord) *scaleFactor/2]];
IF showName THEN Imager.ShowRope[context, ch.name]; 
};
hor => {y: REAL _ yOffset + (ch.coord * scaleFactor);
-- Imager.SetXYI[context, xOffset +  (negCh.coord * scaleFactor), y];
-- Graphics.DrawTo[context, xOffset + (posCh.coord * scaleFactor), y];
path: Imager.PathProc ~ {
moveTo[[xOffset +  (negCh.coord * scaleFactor), y]];
lineTo[[xOffset + (posCh.coord * scaleFactor), y]];
};
Imager.MaskStroke[context, path];
Imager.SetXY[context, [xOffset + (negCh.coord + posCh.coord) *scaleFactor/ 2, y]];
IF showName THEN Imager.ShowRope[context, ch.name];
};
ENDCASE => ERROR};--PaintChannel--

End: PUBLIC PROC[ch:  Channel, which: Side] RETURNS[Intersection] = {
 RETURN[IPCB.End[ch.boundary, which]]}; --End -- 

NthComponent: PUBLIC PROC [ch: Channel, which: Side, n: INT] RETURNS[Component] =  {RETURN[IPCB.NthComponent[ch.boundary, which, n]]};

NthIntersection: PUBLIC PROC[ch:  Channel, which: Side, n: INT] RETURNS[Intersection] = {
RETURN[IPCB.NthIntersection[ch.boundary, which, n]]
}; -- NthIntersection-- 

NoIntersection: PUBLIC PROC[ch:  Channel, which: Side] RETURNS[BOOL] = {
RETURN[IPCB.NoIntersection[ch.boundary, which]]
}; -- NoIntersection-- 

NoComponent: PUBLIC PROC[ch:  Channel, which: Side] RETURNS[BOOL] = {
RETURN[IPCB.NoComponent[ch.boundary, which]]
}; -- NoComponent-- 

Components: PUBLIC PROC[ch:  Channel, which: Side, p: EachComponentAction] RETURNS[BOOL] = {RETURN[IPCB.Components[ch.boundary, which, p]]}; -- Components--

Intersections: PUBLIC PROC[ch:  Channel, which: Side, p: EachIntersectionAction] RETURNS[BOOL] = {RETURN[IPCB.Intersections[ch.boundary, which, p]];}; -- Intersections--
 

END.

-- File: IPCTGImpl.mesa
-- Last Edited by: CSChow, February 2, 1985 2:13:12 am PST
Preas, August 1, 1986 6:50:27 pm PDT
-- Note: IPCTG = ChannelTopologyGraph


--Create the channels--
--Create the external constraints--
--##################--
##################--

ส'˜Jš
œ™š
œ:™:Icode™$—J˜Jš
œ%™%J™J˜š
ฯk	˜	Jšœœœ˜&Jšœœ˜K–

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

"Cedar" stylešœ
˜K–

"Cedar" stylešœœ:˜FK–

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

"Cedar" stylešœ
˜K–

"Cedar" styleš
˜K–

"Cedar" stylešœ
˜K–

"Cedar" stylešœœ˜K–

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

"Cedar" stylešœ
˜—J˜šœœ
˜Jš	œœœœ
˜HJš
œ
œœ
œ
œ
˜!J˜Jšœœ˜Jšœœ˜J˜Jšœœ
œœ
˜)Jšœœ
œœ
˜?J˜J˜K–

"Cedar" style™šฯnœœ
œœ˜%Jšœ
œœœ2˜eJšœฯc
œ
˜—K–

"Cedar" style˜–

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

"Cedar" stylešœ3œœŸ˜_–

"Cedar" styleš
œ˜K–

"Cedar" stylešœœœœ	œœœœœ˜Ÿ
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šœŸœŸ˜—–

"Cedar" stylešœะckAœ˜aK–

"Cedar" stylešœœ
˜
K–

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

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

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

"Cedar" style˜K–

"Cedar" stylešœ-œ)˜XK–

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

"Cedar" styleš
œ˜K–

"Cedar" styleš
œ˜K–

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

"Cedar" styleš
œ)˜)K–

"Cedar" style˜K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

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

"Cedar" stylešœœ˜K–

"Cedar" stylešœœ˜K–

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

"Cedar" stylešœœ˜K–

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

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

"Cedar" stylešœœFŸ	˜Z—–

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

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

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

"Cedar" styleš
œ˜–

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

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

"Cedar" stylešœ	œ˜K–

"Cedar" style˜K–

"Cedar" styleš
œ%˜%K–

"Cedar" styleš
œ%˜%K–

"Cedar" styleš
œ™–

"Cedar" stylešœ˜K–

"Cedar" style˜K–

"Cedar" stylešœ
˜—–

"Cedar" stylešœ˜K–

"Cedar" style˜,K–

"Cedar" style˜K–

"Cedar" style˜K–

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

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

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

"Cedar" style˜K–

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

"Cedar" style˜,K–

"Cedar" style˜–

"Cedar" stylešœ˜K–

"Cedar" style˜-K–

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

"Cedar" stylešœ
˜—K–

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

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

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

"Cedar" styleš
œ˜K–

"Cedar" stylešœœ˜K–

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

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

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

"Cedar" stylešœ˜–

"Cedar" styleš
˜K–

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

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

"Cedar" stylešœ#˜'–

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

"Cedar" styleš
œ'˜'K–

"Cedar" stylešœœ˜•StartOfExpansion[]šœ˜Kšœ	œ
œœ
œ
œ
˜Ašœ
œœœ
œ
œ
œ˜PKšœœœ
œ˜T—Kšœœ
˜—Kšœ
˜—K–

"Cedar" stylešœ
˜—–

"Cedar" styleš
˜K–

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

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

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

"Cedar" stylešœ
˜—K–

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

"Cedar" style˜K–

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

"Cedar" style˜–

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

"Cedar" stylešœœ%œŸ˜KK–

"Cedar" style˜K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

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

"Cedar" stylešœ^Ÿ˜cK–

"Cedar" style˜K–

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

"Cedar" style˜–

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

"Cedar" stylešœ˜–

"Cedar" styleš
œ˜K–

"Cedar" stylešœœL˜TK–

"Cedar" styleš
œ&˜&K–

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

"Cedar" styleš
œ˜—–

"Cedar" styleš
œ˜K–

"Cedar" stylešœœL˜TK–

"Cedar" styleš
œ&˜&K–

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

"Cedar" style˜—K–

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

"Cedar" stylešœœ˜K–

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

"Cedar" style˜–

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

"Cedar" stylešœœœ)Ÿ˜L–

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

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

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

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

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

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

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

"Cedar" style˜–

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

"Cedar" styleš
œ˜K–

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

"Cedar" styleš
œ˜K–

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

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ1œ
œ˜_K–

"Cedar" styleš
Ÿ{˜{K–

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

"Cedar" stylešœ˜K–

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

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

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

"Cedar" style˜K–

"Cedar" style˜—–

"Cedar" stylešžœœ
œ.œœœ
œ˜`K–

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

"Cedar" stylešœ
˜K–

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

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

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

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ&œ˜LK–

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

"Cedar" style˜–

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

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

"Cedar" stylešœ˜K–

"Cedar" styleš
œC˜CK–

"Cedar" styleš
œC˜CK–

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

"Cedar" style˜—K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ&œ˜OK–

"Cedar" stylešœœ˜
K–

"Cedar" stylešœœ
˜	K–

"Cedar" styleš
œ˜K–

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

"Cedar" stylešœ˜K–

"Cedar" stylešœœ9œ
œ"˜oK–

"Cedar" stylešœœ9œ
œ"˜oK–

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

"Cedar" style˜4–

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

"Cedar" stylešœœ
˜K–

"Cedar" stylešœœ˜K–

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

"Cedar" stylešœ?œ
œ˜TK–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜K–

"Cedar" style˜–

"Cedar" stylešžœœ
œ,œ˜XK–

"Cedar" stylešœœ
˜K–

"Cedar" stylešœœ
˜	K–

"Cedar" styleš
œ˜K–

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

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

"Cedar" styleš
œ4˜4–

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

"Cedar" stylešœœ˜K–

"Cedar" stylešœ>œ
˜KK–

"Cedar" styleš
œ
˜
—K–

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

"Cedar" style˜–

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

"Cedar" styleš
œ*˜*K–

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

"Cedar" style˜–

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

"Cedar" styleš
œ˜–

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

"Cedar" styleš
œ)œœœœ
˜rK–

"Cedar" stylešœQœ˜W–

"Cedar" stylešœ˜K–

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

"Cedar" stylešœ	œ œ
œ%œœf˜ะ
K–

"Cedar" stylešœ	œ œ
œ%œœf˜ะ
K–

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

"Cedar" stylešœ˜K–

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

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

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

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

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

"Cedar" style˜—–

"Cedar" styleš
œ˜K–

"Cedar" style˜——K–

"Cedar" stylešœŸ˜!K–

"Cedar" style˜—K–

"Cedar" style˜–

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

"Cedar" stylešœ) Aœ˜oK–

"Cedar" stylešœœ˜K–

"Cedar" stylešœœ
˜
–

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

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

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

"Cedar" styleš
œ*˜*K–

"Cedar" stylešœ
˜—K–

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

"Cedar" style˜—K–

"Cedar" styleš
œ7˜7K–

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

"Cedar" style˜–

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

"Cedar" styleš
œ˜K–

"Cedar" styleš
œ˜K–

"Cedar" stylešœŸ˜—K–

"Cedar" style˜–

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

"Cedar" style–[]š
œ1˜1–

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

"Cedar" styleš
œ˜K–

"Cedar" styleš
œ˜K–

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

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

"Cedar" style˜K–

"Cedar" style˜K–

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

"Cedar" stylešœ5Ÿ˜SK–

"Cedar" styleš
œ4˜4K–

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

"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š
œ@˜@K–

"Cedar" styleš
œ@˜@K–

"Cedar" styleš
œ"˜"K–

"Cedar" styleš
œ"˜"K–

"Cedar" styleš
œ/˜/K–

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

"Cedar" style˜K–

"Cedar" style˜–

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

"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˜–

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

"Cedar" styleš
œ!˜!Iprocš
œ!˜!Lš
œ+˜+šœ	˜šœœ&˜5Lš
œD˜DLš
œD˜Dš
œ˜Kš
œ3˜3Kš
œ3˜3Kš
œ˜—Lš
œ!˜!Lš
œQ˜QKšœ
œ$˜4Lš
œ˜—šœœ&˜5Lš
œE˜EšœFฯb
œ˜`Kš
œ4˜4Kš
œ3˜3Kš
œ˜—Lš
œ!˜!Lš
œR˜RKšœ
œ#˜3Lš
œ˜—LšœœŸ˜"——K–

"Cedar" style˜K–

"Cedar" styleš
Ÿ™–

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

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

"Cedar" style˜K–

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

"Cedar" style˜–

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

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

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

"Cedar" style˜—–

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

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

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

"Cedar" style˜–

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

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

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

"Cedar" style˜K–

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

"Cedar" style˜K–

"Cedar" stylešž
œœ
œ7œ
œœ
œ*Ÿ˜ฉ
K–

"Cedar" styleš
œ
˜
K–

"Cedar" styleš
œ™K–

"Cedar" style˜K–

"Cedar" style™K–

"Cedar" stylešœ
˜——…—>บgZ