DIRECTORY AbSets, AMBridge, AMTypes, BasicTime, BiRels, IntStuff, IO, LichenDataOps, LichenDataStructure, LichenIntBasics, PrintTV, Rope, SetBasics;

LichenDataImpl2: CEDAR PROGRAM
IMPORTS AbSets, AMBridge, BiRels, IntStuff, IO, LichenDataOps, LichenDataStructure, PrintTV, SetBasics
EXPORTS LichenDataOps
=

BEGIN OPEN IB:LichenIntBasics, IB, LichenDataStructure, LichenDataOps, Sets:AbSets;

startInheriting: BOOL _ FALSE;

CreateDesign: PUBLIC PROC [names: Set--of ROPE--] RETURNS [d: Design] ~ {
IF names.SpaceOf[] # SetBasics.ropes[TRUE] THEN ERROR;
IF names.Empty[] THEN ERROR;
d _ NEW [DesignPrivate];
d.names _ Sets.CreateHashCopy[names];
d.eSpace _ CreateEntitySpace[d];
d.cellTypes _ Sets.CreateHashSet[d.eSpace];
d.sub _ BiRels.CreateHashFn[spaces: [d.eSpace, SetBasics.refs], invable: FALSE];
d.parent _ BiRels.CreateHashFn[spaces: ALL[d.eSpace], invable: TRUE];
d.ancest _ d.parent.TransitiveFnClosure[TRUE];
d.cct _ [
p: BiRels.CreateHashFn[spaces: [d.eSpace, d.eSpace], invable: TRUE],
w: BiRels.CreateHashFn[spaces: [d.eSpace, d.eSpace], invable: TRUE],
i: BiRels.CreateHashFn[spaces: [d.eSpace, d.eSpace], invable: TRUE]];
d.partses _ [d.cct[p].SetOn[left], d.cct[w].SetOn[left], d.cct[i].SetOn[left]];
d.pws _ d.partses[p].Union[d.partses[w]];
d.parts _ d.pws.Union[d.partses[i]];
d.isntTop _ d.parent.SetOn[left];
d.isComposite _ d.sub.SetOn[left];
d.isTop _ d.pws.Difference[d.isntTop];
d.isAtomic _ d.pws.Difference[d.isComposite];
d.ciType _ BiRels.CreateHashFn[spaces: [d.eSpace, d.eSpace], invable: TRUE];
d.ctName _ BiRels.CreateHashReln[spaces: [d.eSpace, SetBasics.ropes[TRUE]]];
d.arrayElt _ BiRels.CreateHashFn[spaces: ALL[d.eSpace], invable: TRUE];
RETURN};

CreateEntitySpace: PROC [d: Design] RETURNS [Sets.Space] ~ {
RETURN [NEW [SetBasics.SpacePrivate _ [
Contains: EntityContains,
Equal: SetBasics.refs.Equal,
AHash: SetBasics.refs.AHash,
ACompare: SetBasics.refs.ACompare,
Print: EntityPrint,
name: IO.PutFR["entities of %g", [rope[NARROW[d.names.AnElt[].MA] ]] ],
data: d
]]]};

EntityContains: PROC [data: REF ANY, v: Sets.Value] RETURNS [BOOL] ~ {
d: Design ~ NARROW[data];
IF v.i#0 THEN RETURN [FALSE];
WITH v.ra SELECT FROM
ct: CellType => RETURN [TRUE];
v: Vertex => RETURN [TRUE];
p: Port => RETURN [TRUE];
ENDCASE => RETURN [FALSE]};

EntityPrint: PROC [data: REF ANY, v: Sets.Value, to: IO.STREAM, depth, length: INT, verbose: BOOL] ~ {
d: Design ~ NARROW[data];
ra: REF ANY ~ v.VA;
WITH ra SELECT FROM
ct: CellType => {
name: ROPE ~ ct.ACtName[];
to.PutRope[name];
};
ENDCASE => {
class: PartClass ~ WITH ra SELECT FROM
p: Port => p,
w: Wire => w,
ci: CellInstance => i,
ENDCASE => ERROR;
cct: CellType ~ NARROW[d.cct[class].Apply[v].MA];
mv: Sets.MaybeValue ~ cct.fullName[class].Lookup[goal: v, side: left];
IF mv.found
THEN to.PutRope[UnparseSteppyName[VSn[mv.it]]]
ELSE PrintTV.Print[RaTv[ra], to, depth, length, verbose];
RETURN};
};

namingHints: BiRels.HintPair ~ [
leftToRight: [
fn: [$Hash],
set: [$List, LIST[[$RelOrder, $fwd]]]
],
rightToLeft: [
fn: [$Hash],
set: [$Hash]
]];

CreateCellType: PUBLIC PROC [d: Design, flavor: CellFlavor, names: Set--of ROPE--] RETURNS [ct: CellType] ~ {
ct _ NEW [CellTypePrivate _ [
d: d,
fullName: [
p: BiRels.GenCreate[spaces: [d.eSpace, steppyNameSpace], hints: namingHints],
w: nilBiRel,
i: nilBiRel],
inheritNames: startInheriting
]];
IF flavor=unorganized THEN {
exports: BiRel ~ BiRels.CreateHashFn[[d.eSpace, d.eSpace]];
wires: Set ~ ct.CTParts[w];
ct.fullName[w] _ BiRels.GenCreate[spaces: [d.eSpace, steppyNameSpace], hints: namingHints];
ct.fullName[i] _ BiRels.GenCreate[spaces: [d.eSpace, steppyNameSpace], hints: namingHints];
ct.asu _ NEW [UnorganizedPrivate _ [
exports: exports,
publics: exports.SetOn[right]
]];
ct.asu.exportable _ wires.Intersection[Sets.CreateFilter[[TestExportable, d.eSpace, ct]]];
ct.asu.publicOrExportable _ ct.asu.publics.Union[ct.asu.exportable];
ct.asu.stuck _ wires.Difference[ct.asu.publicOrExportable];
};
IF NOT d.cellTypes.AddA[ct] THEN ERROR;
[] _ d.ctName.AddSet[BiRels.CreateProduct[[Sets.CreateSingleA[ct, d.eSpace], names]]];
RETURN};

TestExportable: PROC [val: Sets.Value, data: REF ANY _ NIL] RETURNS [BOOL] ~ {
ct: CellType ~ NARROW[data];
w: Wire ~ NARROW[val.VA];
IF ct.asu.publics.HasMember[val] THEN RETURN [FALSE];
{kids: Seq ~ BiRels.DeRef[ct.d.sub.ApplyA[w].MDA];
IF kids=nilBiRel THEN RETURN [TRUE];
RETURN ct.ExportableKids[kids]}};

CreatePort: PUBLIC PROC [ct: CellType, fullNames: Set--of SteppyName--, addum, fixExpConns, fixInstConns, fixWExpConns, fixWInstConns: BOOL, children: Seq--of Port-- _ nilBiRel] RETURNS [p: Port] ~ {
d: Design ~ ct.d;
atomic: BOOL ~ children = nilBiRel;
FixUse: PROC [use: CellUse] ~ {WITH use SELECT FROM
ci: CellInstance => {
cct: CellType ~ d.CiCct[ci];
kidWires: Seq _ nilBiRel;
w: Wire _ NIL;
{IF NOT atomic THEN {
kidWires _ children.Compose[ci.conns];
IF kidWires.Size#children.Size THEN GOTO DontConnect;
{ssi: SubsIndex ~ d.SubseqIndex[kidWires];
IF ssi.multiparents THEN GOTO DontConnect;
IF ssi.full THEN {w _ NARROW[ssi.parent]; GOTO Connect};
IF NOT addum THEN GOTO DontConnect;
IF ssi.parent#NIL THEN GOTO DontConnect;
kidWires _ kidWires.CreateVectorCopy}}
ELSE IF NOT addum THEN GOTO DontConnect;
w _ CreateWire[cct, IF cct.inheritNames THEN ActualNames[cct.INames[ci], fullNames] ELSE emptySteppySet, fixWExpConns, fixWInstConns, kidWires];
EXITS Connect => use _ use};
Connect[d, w, p, ci];
RETURN
EXITS DontConnect => ct _ ct};
act: CellType => NoteNewEltPort[act, p];
ENDCASE => ERROR};
p _ NEW [PortPrivate _ []];
d.cct[p].AddNewAA[p, ct];
KnowPortNames[d, p, fullNames];
IF children # nilBiRel THEN {
d.sub.AddNewAA[p, children.Refify];
[]_ d.parent.AddSet[BiRels.CreateProduct[[children.SetOn[right], Sets.CreateSingleA[p, d.eSpace]]]];
IF fixExpConns THEN {
IF ct.asu#NIL THEN ClosePortsConnectivity[d, p, children, ct.asu.exports, ct];
IF ct.asArray#NIL THEN NoteNewArrayPort[ct, p]};
};
IF addum OR (fixInstConns AND NOT atomic) THEN ct.EnumerateUses[FixUse];
RETURN};

ClosePortsConnectivity: PROC [d: Design, parent: Port, kidPorts: Seq--of Port--, conns: Fn--Port _ Wire--, site: Cell] ~ {
kidWires: Seq--of Wire-- ~ kidPorts.Compose[conns];
IF kidWires.Size#kidPorts.Size THEN RETURN;
{si: SubsIndex ~ d.SubseqIndex[kidWires];
IF NOT si.full THEN RETURN;
IF si.parent=NIL THEN ERROR;
Connect[d, NARROW[si.parent], parent, site];
RETURN}};

CreateWire: PUBLIC PROC [ct: CellType, fullNames: Set--of SteppyName--, fixExpConns, fixInstConns: BOOL, children: Seq--of Wire-- _ nilBiRel] RETURNS [w: Wire] ~ {
d: Design ~ ct.d;
FixConn: PROC [porta: REF ANY, site: Cell] ~ {
p0: Port ~ NARROW[porta];
pp: Port ~ d.PParent[p0];
IF pp=NIL THEN RETURN;
IF NOT ((fixExpConns AND fixInstConns) OR (WITH site SELECT FROM ci: CellInstance => fixInstConns, ct: CellType => fixExpConns, ENDCASE => ERROR)) THEN RETURN;
{kidPorts: Seq ~ BiRels.DeRef[d.sub.ApplyA[pp].MA];
kidWires: Seq ~ kidPorts.Compose[SiteConns[site]];
IF kidWires.Equal[children] THEN Connect[d, w, pp, site];
RETURN}};
w _ NEW [VertexPrivate[w] _ [variant: w[conns: BiRels.CreateHashReln[spaces: [d.eSpace, d.eSpace]]] ]];
d.cct[w].AddNewAA[w, ct];
KnowVertexNames[d, w, fullNames];
IF children # nilBiRel THEN {
d.sub.AddNewAA[w, children.Refify];
[]_ d.parent.AddSet[BiRels.CreateProduct[[children.SetOn[right], Sets.CreateSingleA[w, d.eSpace]]]];
IF fixExpConns OR fixInstConns THEN {
c0: Wire ~ NARROW[children.ApplyI[0].MA];
c0.conns.EnumAA[FixConn];
w _ w};
w _ w};
RETURN};

Instantiate: PUBLIC PROC [ict, cct: CellType, addum: BOOL, names: Set--of SteppyName--] RETURNS [ci: CellInstance] ~ {
d: Design ~ ict.d;
ci _ NEW [VertexPrivate.i _ [variant: i[BiRels.CreateHashFn[[d.eSpace, d.eSpace]] ]]];
d.cct[i].AddNewAA[ci, cct];
d.ciType.AddNewAA[ci, ict];
KnowVertexNames[d, ci, names];
IF addum THEN {
do: Set--of Port-- _ ict.CTParts[p];
UNTIL do.Empty DO
wait: Set--of Port-- ~ Sets.CreateHashSet[d.eSpace];
DumPort: PROC [pval: Sets.Value] RETURNS [BOOL] ~ {
p: Port ~ NARROW[pval.VA];
kidPorts: Seq--of Port-- ~ BiRels.DeRef[d.sub.Apply[pval].MDA];
kidWires: Seq--of Wire-- ~ IF kidPorts#nilBiRel THEN kidPorts.Compose[ci.conns] ELSE nilBiRel;
IF kidPorts#nilBiRel AND kidPorts.Size # kidWires.Size THEN {
IF NOT wait.AddElt[pval] THEN ERROR;
RETURN [FALSE]};
{w: Wire ~ CreateWire[cct, IF cct.inheritNames THEN ActualNames[names, ict.PNames[p]] ELSE emptySteppySet, FALSE--don't bother, we know it's private--, FALSE--don't bother, it's taken care of by me--, kidWires];
Connect[d, w, p, ci];
RETURN [FALSE]}};
IF do.Scan[DumPort].found THEN ERROR;
do _ wait;
ENDLOOP;
ci _ ci};
RETURN};

KnowVertexNames: PUBLIC PROC [d: Design, v: Vertex, fullNames: Set--of SteppyName--] ~ {
bestNewM: Sets.MaybeValue ~ fullNames.AnElt[Sets.fwd];
IF NOT bestNewM.found THEN RETURN;
{bestNew: SteppyName ~ VSn[bestNewM.it];
ct: CellType ~ NARROW[d.cct[v.class].ApplyA[v].MA];
bestOldM: Sets.MaybeValue ~ ct.fullName[v.class].Lookup[goal: AV[v], side: left];
IF bestOldM.found THEN {
bestOld: SteppyName ~ VSn[bestOldM.it];
IF SteppyNameGradeCompare[bestOld.grade, bestNew.grade] < equal THEN RETURN};
[] _ ct.fullName[v.class].AddSet[BiRels.CreateProduct[[Sets.CreateSingleA[v, d.eSpace], fullNames]]];
RETURN}};

ForgetVertexName: PUBLIC PROC [d: Design, v: Vertex, fullName: SteppyName] ~ {
ct: CellType ~ NARROW[d.cct[v.class].ApplyA[v].MA];
[] _ ct.fullName[v.class].RemPair[[AV[v], SnV[fullName]]];
RETURN};

KnowPortNames: PUBLIC PROC [d: Design, p: Port, fullNames: Set--of SteppyName--] ~ {
ct: CellType ~ d.PCct[p];
[] _ ct.fullName[p].AddSet[BiRels.CreateProduct[[Sets.CreateSingleA[p, d.eSpace], fullNames]]];
RETURN};

ForgetPortName: PUBLIC PROC [d: Design, p: Port, fullName: SteppyName] ~ {
ct: CellType ~ NARROW[d.cct[p].ApplyA[p].MA];
[] _ ct.fullName[p].RemPair[[AV[p], SnV[fullName]]];
RETURN};

PortForWire: PUBLIC PROC [ct: CellType, internal: Wire, mayAdd: BOOL] RETURNS [port: Port] ~ {
mv: Sets.MaybeValue _ ct.asu.exports.Lookup[goal: AV[internal], order: Sets.alleq];
IF NOT mv.found THEN {
FullySfwdlyExportWires[ct, NonPublicDescendants[ct, internal]];
mv _ ct.asu.exports.Lookup[goal: AV[internal], order: Sets.alleq]};
IF NOT mv.found THEN ERROR;
RETURN [NARROW[mv.MA]]};

FullySfwdlyExportWires: PUBLIC PROC [ct: CellType, wires: Set] ~ {
d: Design ~ ct.d;
childWires: Set ~ d.parent.Image[wires, rightToLeft];
badKids: Set ~ childWires.Difference[wires.Union[ct.asu.publics]];
newPorts: Seq--of Port-- ~ CreateSeq[dense: TRUE];
DoWire: PROC [w: Wire] RETURNS [p: Port] ~ {
p _ AConndPort[ct, w];
IF p#NIL THEN RETURN;
{kidWires: Seq--of Wire-- ~ BiRels.DeRef[d.sub.ApplyA[w].MDA];
kidPorts: Seq--of Port-- _ nilBiRel;
IF kidWires#nilBiRel THEN {
kidPorts _ BiRels.CreateVector[rightSpace: d.eSpace];
FOR i: LNAT IN [0 .. kidWires.Size.EN) DO
kidWire: Wire ~ NARROW[kidWires.ApplyI[i].MA];
kidPort: Port ~ DoWire[kidWire];
kidPorts.AddNewIA[i, kidPort];
w _ w; ENDLOOP;
w _ w};
p _ CreatePort[ct, IF ct.inheritNames THEN WNames[ct, w] ELSE emptySteppySet, FALSE, FALSE, FALSE, FALSE, FALSE, kidPorts];
Connect[d, w, p, ct];
newPorts.AppendA[p];
RETURN}};
StartExport: PROC [val: Sets.Value] RETURNS [BOOL] ~ {
[] _ DoWire[NARROW[val.VA]];
RETURN [FALSE]};
FixUse: PROC [use: CellUse] ~ {WITH use SELECT FROM
ci: CellInstance => {
cct: CellType ~ d.CiCct[ci];
FOR i: LNAT IN [0 .. newPorts.Size.EN) DO{
p: Port ~ NARROW[newPorts.ApplyI[i].MA];
kidPorts: Seq--of Port-- ~ BiRels.DeRef[d.sub.ApplyA[p].MDA];
kidWires: Seq--of Wire-- _ nilBiRel;
w: Wire;
{IF kidPorts#nilBiRel THEN {
kidWires _ kidPorts.Compose[ci.conns];
IF kidWires.Size # kidPorts.Size THEN GOTO DontDoit;
{ssi: SubsIndex ~ d.SubseqIndex[kidWires];
IF ssi.multiparents THEN GOTO DontDoit;
IF ssi.full THEN {w _ NARROW[ssi.parent]; GOTO GotIt};
IF ssi.parent#NIL THEN GOTO DontDoit;
IF NOT cct.ExportableKids[kidWires] THEN GOTO DontDoit;
}};
w _ CreateWire[cct, IF ct.inheritNames THEN ActualNames[cct.INames[ci], ct.PNames[p]] ELSE emptySteppySet, TRUE, TRUE, kidWires];
w _ w;
EXITS GotIt => use _ use};
Connect[d, w, p, ci];
w _ w;
EXITS DontDoit => ct _ ct
}ENDLOOP;
RETURN};
act: CellType => {
FOR i: LNAT IN [0 .. newPorts.Size.EN) DO
p: Port ~ NARROW[newPorts.ApplyI[i].MA];
NoteNewEltPort[act, p];
ct _ ct; ENDLOOP;
RETURN};
ENDCASE => ERROR};
IF NOT badKids.Empty THEN ERROR;
IF NOT wires.Intersection[ct.asu.publics].Empty THEN ERROR;
IF wires.Scan[StartExport].found THEN ERROR;
ct.EnumerateUses[FixUse];
RETURN};

Connect: PUBLIC PROC [d: Design, wire: Wire, port: Port, site: Cell] ~ {
conns: Fn--Port _ Wire-- ~ WITH site SELECT FROM
ci: CellInstance => ci.conns,
ct: CellType => ct.asu.exports,
ENDCASE => ERROR;
[] _ conns.AddAA[port, wire];
[] _ wire.conns.AddAA[port, site];
RETURN};

MergeNets: PUBLIC PROC [d: Design, w1, w2: Wire] RETURNS [merged, deleted: Wire] ~ {
ct: CellType ~ d.WCct[w1];
SwitchConn: PROC [cell: REF ANY] ~ {
WITH cell SELECT FROM
ci: CellInstance => ci.conns.SubstituteA[deleted, merged, right];
cct: CellType => IF ct # cct THEN ERROR;
ENDCASE => ERROR};
IF w1=w2 THEN ERROR;
IF ct # d.WCct[w2] THEN ERROR;
IF ct.asu.publics.HasMemA[w1] OR ct.asu.publics.HasMemA[w2] THEN ERROR;
IF d.isntTop.HasMemA[w1] OR d.isntTop.HasMemA[w2] THEN ERROR;
IF NOT (d.Atomic[w1] AND d.Atomic[w2]) THEN ERROR;
merged _ w1;
deleted _ w2;
IF NOT d.cct[w].DeleteA[deleted] THEN ERROR;
ct.asu.exports.SubstituteA[deleted, merged, right];
deleted.conns.SetOn[right].EnumA[SwitchConn];
[] _ merged.conns.AddSet[deleted.conns];
ct.fullName[w].SubstituteA[deleted, merged, left];
RETURN};

RaTv: PROC [ra: REF ANY] RETURNS [AMTypes.TV] ~ TRUSTED {
RETURN AMBridge.TVForReferent[NEW [REF ANY _ ra], const]};

Start: PROC ~ {
RETURN};

Start[];

END.
ZLichenDataImpl2.Mesa
Last tweaked by Mike Spreitzer on May 6, 1988 10:05:46 am PDT
Κ–

"cedar" style˜
code™K™=—K˜KšΟk	œ9œP˜”
K˜šΟnœœ
˜Kšœ%œ8˜fKšœ˜K˜
—K˜Kš
œ
œ
œœ&žœ˜SK˜Kšœœœ
˜K˜š
žœœ
œΟcœœ˜IKšœ#œœ
œ
˜6Kšœœ
œ
˜Kšœœ˜K˜%K˜ Kš
œ+˜+KšœIœ˜PKšœ'œœ˜EKšœ(œ˜.˜	Kšœ>œ˜DKšœ>œ˜DKšœ>œ˜E—K˜OK˜)K˜$K˜!Kš
œ"˜"Kš
œ&˜&Kš
œ-˜-KšœFœ˜LKšœDœ˜LKšœ)œœ˜GKšœ˜—K˜šžœœ
œ˜<šœœ˜'Kšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜"Kšžœ˜Kšœœœœ˜GKš
œ˜K˜——K˜šžœœœ
œœœ˜FKšœœ˜Kšœœ
œœ˜šœœ
˜Kšœœœ˜Kšœ
œœ˜Kšœœœ˜Kšœœœ˜——K˜šžœœœ
œœ
œœœ˜fKšœœ˜Kšœœ
œœ
˜šœœ
˜˜Kšœœ˜K˜K˜—šœ˜šœœœ
˜&Kš
œ
˜
K˜
K˜Kšœœ
˜—Kšœœœ˜1K˜Fšœ	˜Kšœ*˜.Kšœ5˜9—Kšœ˜——K˜—K˜š
œ ˜ ˜K˜Kšœ
œ˜%K˜—˜K˜K˜K˜——K˜š
žœœ
œ+Ÿœœ˜mšœœ˜K˜˜Kš
œM˜MK˜K˜
—Kš
œ˜K˜—šœœ˜Kš
œ;˜;K˜Kš
œ[˜[Kš
œ[˜[šœ	œ˜$K˜K˜K˜—Kš
œZ˜ZKš
œD˜DKš
œ;˜;K˜—Kšœ
œœ
œ
˜'Kš
œV˜VKšœ˜—K˜šžœœœ
œœœœ˜NKšœœ˜Kšœ
œœ˜Kšœœ
œœ˜5Kšœ-œ˜2Kšœœ
œœ˜$Kšœ˜!—K˜šž
œœ
œŸœAœŸœ
œ˜Η
K˜Kšœœ˜#š	žœœœœ
˜3š
œ˜K˜K˜Kšœ
œ
˜šœ
œ
œœ˜Kš
œ&˜&Kšœœ
œ
˜5Kš
œ*˜*Kšœœ
œ
˜*Kšœ
œœœ
˜8Kšœ
œœ
œ
˜#Kšœœ
œ
œ
˜(Kš
œ&˜&—Kš
œ
œ
œœ
œ
˜(Kšœœœ(œ8˜
Kšœ˜Kš
œ˜Kš
˜Kšœ˜—K˜(Kšœœ˜—Kšœœ˜Kš
œ˜Kš
œ˜šœœ˜Kš
œ#˜#Kš
œd˜dšœ
œ˜Kšœœ
œ<˜NKšœœ
œ˜0—K˜—Kš
œœœ
œ	œ˜HKšœ˜—K˜š
žœœ(ŸœŸΠcm
Ÿœ˜zKšœ
Ÿœ˜3Kšœœ
œ
˜+Kš
œ)˜)Kšœ
œ	œ
œ
˜Kšœœ
œ
œ
˜Kšœœ˜,Kšœ˜	—K˜šž
œœ
œŸœœŸœ
œ˜£
K˜šžœœ	œ
œ˜.Kšœœ˜Kš
œ˜Kšœœ
œ
œ
˜Kšœ
œœœœœ
œ@œœœ
œ
˜Ÿ
Kšœ/œ˜3Kš
œ2˜2Kšœœ˜9Kšœ˜	—Kšœœ`˜gKš
œ˜Kš
œ!˜!šœœ˜Kš
œ#˜#Kš
œd˜dšœ
œœ˜%Kšœœœ˜)K˜K˜—K˜—Kšœ˜—K˜šžœœ
œœŸœœ˜vK˜KšœœN˜VKš
œ˜Kš
œ˜Kš
œ˜šœœ˜KšœŸœ˜$šœ
˜Kšœ	Ÿœ ˜4šžœœœœ˜3Kšœ
œœ˜Kšœ
Ÿœ"œ˜?Kš	œ
Ÿœœœœ
˜^šœœœ˜=Kšœ
œœ
œ
˜$Kšœœ˜—Kš
œœœ#œŸ&œŸ*œ˜Σ
Kš
œ˜Kšœœ˜—Kšœœ
œ
˜%K˜
Kšœ
˜—Kš
œ	˜	—Kšœ˜—K˜šžœœ
œ&Ÿœ˜XK˜6Kšœ
œœ
œ
˜"Kš
œ(˜(Kšœœœ˜3Kšœ>œ˜Qšœœ˜K˜'Kšœ>œ
œ˜M—K˜eKšœ˜	—K˜šžœœ
œ1˜NKšœœœ˜3Kšœ#œ˜:Kšœ˜—K˜šž
œœ
œ$Ÿœ˜TKš
œ˜Kš
œ_˜_Kšœ˜—K˜šžœœ
œ/˜JKšœœœ˜-Kšœœ˜4Kšœ˜—K˜š
žœœ
œ(œœ˜^Kšœ2œ˜Sšœ
œ
œ˜Kš
œ?˜?Kšœ!œ ˜C—Kšœ
œ
œ
œ
˜Kšœœœ˜—K˜šžœœ
œ˜BK˜K˜5Kš
œB˜BKšœ
Ÿœœ˜2šžœœœ˜,Kš
œ˜Kšœœ
œ
œ
˜KšœŸœ œ˜>Kšœ
Ÿœ˜$šœœ˜Kš
œ5˜5š	œœ
œœ˜)Kšœœœ˜.K˜ K˜Kšœœ
˜—K˜—Kšœœœœœœœœœ˜{K˜Kš
œ˜Kšœ˜	—šžœœœœ˜6Kšœœœ˜Kšœœ˜—š	žœœœœ
˜3˜K˜š
œœ
œœœ
˜*Kšœ
œœ˜(Kšœ
Ÿœ œ˜=Kšœ
Ÿœ˜$K˜šœ
œœ˜Kš
œ&˜&Kšœœ
œ
˜4Kš
œ*˜*Kšœœ
œ
˜'Kšœ
œœœ˜6Kšœœ
œ
œ
˜%Kšœ
œœ
œ
˜7K˜—Kšœœœ+œœœ˜
K˜Kšœ˜K˜K˜Kšœ˜Kšœ
œ
˜	—Kšœ˜—š
œ˜š	œœ
œœ˜)Kšœ
œœ˜(Kš
œ˜Kšœ	œ
˜—Kšœ˜—Kšœœ˜—Kšœ
œœ
œ
˜ Kšœ
œ*œ
œ
˜;Kšœœ
œ
˜,Kš
œ˜Kšœ˜—K˜šžœœ
œ4˜Hš
œ	Ÿ 
Ÿœœœ
˜0K˜K˜Kšœœ
˜—Kš
œ˜Kš
œ"˜"Kšœ˜—K˜šž	œœ
œœ˜TK˜šž
œœœ
œ˜$šœœ
˜Kš
œA˜AKšœœ
œ
œ
˜(Kšœœ˜——Kšœœ
œ
˜Kšœœ
œ
˜Kšœœœ
œ
˜GKšœœœ
œ
˜=Kš
œ
œœœ
œ
˜2Kš
œ˜Kš
œ
˜
Kšœ
œœ
œ
˜,Kš
œ3˜3Kš
œ-˜-K˜(Kš
œ2˜2Kšœ˜—K˜šžœœœ
œœ
œœ˜9Kšœœœ
œ˜:—K˜šžœœ˜Kšœ˜—K˜K˜K˜Kšœ
˜—…—5LEΌ