DIRECTORY
IO USING [ bool, card, rope, PutF, refAny, STREAM ],
Rope USING [ ROPE, Equal ],
SiroccoCGDef USING [ Generic, ItemKind, ValueKind ],
SymTab USING [ EachPairAction, Pairs, Ref ],
ThreeC4Support USING [ GetReportStream ],
SiroccoBaseDef USING [ ],
SiroccoPrivate,
SiroccoPrivateTypes;

SiroccoExternalImpl: CEDAR PROGRAM
IMPORTS IO, Rope, SymTab, ThreeC4Support
EXPORTS SiroccoPrivate ~ {
OPEN SiroccoCGDef, SiroccoPrivate, SiroccoPrivateTypes;
ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;
DumpTypeGraph: PUBLIC PROC [ graph: TypeGraph ] ~ {
s: STREAM ~ ThreeC4Support.GetReportStream[];
DumpItemTable: SymTab.EachPairAction ~ {
item: ITEM ~ NARROW[val]; -- guaranteed to be indirect!
name: ROPE ~ item.name;
position: CARD ~ item.position;
kind: SiroccoCGDef.ItemKind ~ item.kind;
node: TypeGraphNode ~ item.type;
value: AbstractValue ~ item.value;
SELECT kind FROM
type => {
IO.PutF[s, "\t{ type %g, %g, %g, %g }\n",
IO.rope[name],
IO.card[position],
IO.card[LOOPHOLE[node]],
IO.card[0]
];
};
const => {
IO.PutF[s, "\t{ const %g, %g, %g, %g }\n",
IO.rope[name],
IO.card[position],
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[value]]
];
};
ENDCASE => { NULL };
};
DumpItemTG: SymTab.EachPairAction ~ {
item: ITEM ~ NARROW[val]; -- guaranteed to be indirect!
name: ROPE ~ item.name;
position: CARD ~ item.position;
kind: SiroccoCGDef.ItemKind ~ item.kind;
node: TypeGraphNode ~ item.type;
value: AbstractValue ~ item.value;
SELECT kind FROM
type => {
DumpTGN[s, node];
};
const => {
DumpTGN[s, node];
DumpAVN[s, value];
};
ENDCASE => { ERROR };
};
context: CONTEXT ~ graph.context;
scope: SCOPE ~ context.scope;
id: ROPE ~ scope.id;
pgm: CARD ~ scope.pgm;
version: CARD ~ scope.version;
items: SymTab.Ref ~ scope.items;

IO.PutF[s, "\n"];
IO.PutF[s, "{ %g, %g, %g }\n",
IO.rope[id],
IO.card[pgm],
IO.card[version]
];

IO.PutF[s, "\n"];
IO.PutF[s, "{ Items\n"];
[] _ SymTab.Pairs[items, DumpItemTable];
IO.PutF[s, "\t}\n"];

IO.PutF[s, "\n"];
IO.PutF[s, "{ TypeGraph\n"];
[] _ SymTab.Pairs[items, DumpItemTG];
IO.PutF[s, "\t}\n"];
IO.PutF[s, "\n"];
};
MarkTypeGraphNode: PROC [node: TypeGraphNode] ~ {
};

DumpTGN: PUBLIC TGNDumpProc ~ {
IF ( node = NIL ) THEN RETURN;
MarkTypeGraphNode[node]; -- unneccessary?
WITH node SELECT FROM
tgn: REF NodeRep	=> { DumpIndirectTGN[s, tgn, n]; };
tgn: HackTGN	=> { DumpHackTGN[s, tgn, n]; };

tgn: ArrayTGN	=> { DumpArrayTGN[s, tgn, n]; };
tgn: BaseTypeTGN	=> { DumpBaseTypeTGN [s, tgn, n]; };
tgn: ChoiceTGN	=> { DumpChoiceTGN [s, tgn, n]; };
tgn: DerefTGN	=> { DumpDerefTGN [s, tgn, n]; };
tgn: EnumTGN	=> { DumpEnumTGN [s, tgn, n]; };
tgn: ErrorTGN	=> { DumpErrorTGN [s, tgn, n]; };
tgn: LinkTGN	=> { DumpLinkTGN [s, tgn, n]; };
tgn: ProcTGN	=> { DumpProcTGN [s, tgn, n]; };
tgn: RecordTGN	=> { DumpRecordTGN [s, tgn, n]; };
tgn: SequenceTGN	=> { DumpSequenceTGN [s, tgn, n]; };
tgn: FieldListTGN	=> { DumpFieldListTGN [s, tgn, n]; };
tgn: UnionTGN	=> { DumpUnionTGN [s, tgn, n]; };
tgn: FieldTGN	=> { DumpFieldTGN [s, tgn, n]; };
ENDCASE => { ERROR };
};

DumpIndirectTGN: PUBLIC TGNDumpProc ~ {
tgn: REF NodeRep ~ NARROW[node];
DumpTGN[s, tgn.specifics, n];
IO.PutF[s, "\t{ %g: $indirecttgn %g }\n", IO.card[LOOPHOLE[node]], IO.card[LOOPHOLE[tgn.specifics]] ];
};

DumpHackTGN: PUBLIC TGNDumpProc ~ {
tgn: HackTGN ~ NARROW[node];
DumpTGN[s, tgn.value, n];
DumpTGN[s, tgn.next, n];
IO.PutF[s, "\t{ %g: $hacktgn %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[tgn.value]],
IO.card[LOOPHOLE[tgn.next]]
];
};
DumpEmptyTGN: PUBLIC TGNDumpProc ~ {
IF TRUE THEN IO.PutF[s, "$empty %g", IO.refAny[node] ];
};
DumpPrimitiveTGN: PUBLIC TGNDumpProc ~ {
IF TRUE THEN IO.PutF[s, "$primitive %g", IO.refAny[node] ];
};
DumpArrayTGN: PUBLIC TGNDumpProc ~ {
atgn: ArrayTGN ~ NARROW[node];
DumpAVN[s, atgn.length];
DumpTGN[s, atgn.itemType, n];
IO.PutF[s, "\t{ %g: $array %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[atgn.length]],
IO.card[LOOPHOLE[atgn.itemType]]
];
};
DumpBaseTypeTGN: PUBLIC TGNDumpProc ~ {
btgn: BaseTypeTGN ~ NARROW[node];
IO.PutF[s, "\t{ %g: $basetype %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[btgn.type.ORD],
IO.refAny[node]
]; -- fix me!
};
DumpChoiceTGN: PUBLIC TGNDumpProc ~ {
ctgn: ChoiceTGN ~ NARROW[node];
DumpTGN[s, ctgn.ktype, n];
DumpTGN[s, ctgn.union, n];
IO.PutF[s, "\t{ %g: $choice %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[ctgn.ktype]],
IO.card[LOOPHOLE[ctgn.union]]
];
};
DumpDerefTGN: PUBLIC TGNDumpProc ~ {
tgn: DerefTGN ~ NARROW[node];
IO.PutF[s, "\t{ %g: $derefTGN %g }\n",
IO.card[LOOPHOLE[node]],
IO.rope[tgn.item]
];
};
DumpEnumTGN: PUBLIC TGNDumpProc ~ {
etgn: EnumTGN ~ NARROW[node];
DumpTGN[s, etgn.enum, n];
IO.PutF[s, "\t{ %g: $enum %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[etgn.enum]]
];
};
DumpErrorTGN: PUBLIC TGNDumpProc ~ {
etgn: ErrorTGN ~ NARROW[node];
DumpTGN[s, etgn.fieldlist, n];
IO.PutF[s, "\t{ %g: $error %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[etgn.fieldlist]]
];
};
DumpLinkTGN: PUBLIC TGNDumpProc ~ {
tgn: LinkTGN ~ NARROW[node];
IO.PutF[s, "\t{ %g: $derefTGN %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.rope[tgn.interface],
IO.rope[tgn.item]
];
};
DumpProcTGN: PUBLIC TGNDumpProc ~ {
tgn: ProcTGN ~ NARROW[node];
DumpTGN[s, tgn.args, n];
DumpTGN[s, tgn.results, n];
DumpTGN[s, tgn.errors, n];
IO.PutF[s, "\t{ %g: $proc %g %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[tgn.args]],
IO.card[LOOPHOLE[tgn.results]],
IO.card[LOOPHOLE[tgn.errors]]
];
};
DumpRecordTGN: PUBLIC TGNDumpProc ~ {
tgn: RecordTGN ~ NARROW[node];
DumpTGN[s, tgn.fieldlist, n];
IO.PutF[s, "\t{ %g: $record %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[tgn.fieldlist]]
];
};
DumpSequenceTGN: PUBLIC TGNDumpProc ~ {
tgn: SequenceTGN ~ NARROW[node];
DumpAVN[s, tgn.maxlength];
DumpTGN[s, tgn.subtype, n];
IO.PutF[s, "\t{ %g: $sequence %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[tgn.maxlength]],
IO.card[LOOPHOLE[tgn.subtype]]
];
};
DumpFieldListTGN: PUBLIC TGNDumpProc ~ {
tgn: FieldListTGN ~ NARROW[node];
DumpAVN[s, tgn.ordinal];
IO.PutF[s, "\t{ %g: $fieldlist %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.rope[tgn.tag],
IO.card[LOOPHOLE[tgn.ordinal]]
];
};
DumpUnionTGN: PUBLIC TGNDumpProc ~ {
tgn: UnionTGN ~ NARROW[node];
DumpTGN[s, tgn.namelist, n];
DumpTGN[s, tgn.type, n];
IO.PutF[s, "\t{ %g: $union %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[tgn.namelist]],
IO.card[LOOPHOLE[tgn.type]]
];
};
DumpFieldTGN: PUBLIC TGNDumpProc ~ {
tgn: FieldTGN ~ NARROW[node];
DumpTGN[s, tgn.namelist, n];
DumpTGN[s, tgn.type, n];
IO.PutF[s, "\t{ %g: $field %g %g }\n",
IO.card[LOOPHOLE[node]],
IO.card[LOOPHOLE[tgn.namelist]],
IO.card[LOOPHOLE[tgn.type]]
];
};
DumpEmptyFieldTGN: PUBLIC TGNDumpProc ~ {
tgn: FieldTGN ~ NARROW[node];
IO.PutF[s, "\t{ %g: $emptyfield }\n", IO.card[LOOPHOLE[node]] ];
};
DumpGenericAVN: PUBLIC AVNDumpProc ~ {
IO.PutF[s, "\t\t{ %g }\n",
IO.refAny[value]
];
};
MarkAbstractValue: PROC [value: AbstractValue] ~ {
};

DumpAVN: PUBLIC AVNDumpProc ~ {
IF ( value = NIL ) THEN RETURN;
MarkAbstractValue[value]; -- unneccessary?
WITH value SELECT FROM
avn: REF AbstractValueObject	=> { DumpIndirectAVN[s, avn, n]; };
avn: HackAVN	=> { DumpHackAVN[s, avn, n]; };

avn: LogicalAVN	=> { DumpLogicalAVN [s, avn, n]; };
avn: NumericalAVN	=> { DumpNumericalAVN [s, avn, n]; };
avn: RopeAVN	=> { DumpRopeAVN [s, avn, n]; };

avn: BindingAVN	=> { DumpBindingAVN [s, avn, n]; };
avn: ConstructorAVN	=> { DumpConstructorAVN [s, avn, n]; };
avn: DerefAVN	=> { DumpDerefAVN [s, avn, n]; };
avn: GroupingAVN	=> { DumpGroupingAVN [s, avn, n]; };
avn: LinkAVN	=> { DumpLinkAVN [s, avn, n]; };
avn: VariantAVN	=> { DumpVariantAVN [s, avn, n]; };
ENDCASE => { ERROR };
};

DumpIndirectAVN: PUBLIC AVNDumpProc ~ {
avn: REF AbstractValueObject ~ NARROW[value];
DumpAVN[s, avn.specifics, n];
IO.PutF[s, "\t{ %g: $indirectavn %g }\n", IO.card[LOOPHOLE[value]], IO.card[LOOPHOLE[avn.specifics]] ];
};

DumpHackAVN: PUBLIC AVNDumpProc ~ {
avn: HackAVN ~ NARROW[value];
DumpAVN[s, avn.value, n];
DumpAVN[s, avn.next, n];
IO.PutF[s, "\t{ %g: $hackavn %g %g }\n",
IO.card[LOOPHOLE[value]],
IO.card[LOOPHOLE[avn.value]],
IO.card[LOOPHOLE[avn.next]]
];
};
DumpNullAVN: PUBLIC AVNDumpProc ~ {
IF TRUE THEN IO.PutF[s, "$null %g", IO.refAny[value] ];
};

DumpLogicalAVN: PUBLIC AVNDumpProc ~ {
avn: LogicalAVN ~ NARROW[value];
IO.PutF[s, "\t{ %g: $logical %g }\n",
IO.card[LOOPHOLE[value]],
IO.bool[avn.value]
];
};
DumpNumericalAVN: PUBLIC AVNDumpProc ~ {
avn: NumericalAVN ~ NARROW[value];
IO.PutF[s, "\t{ %g: $number %g %g }\n",
IO.card[LOOPHOLE[value]],
IO.bool[avn.inverted],
IO.card[avn.value]
];
};
DumpRopeAVN: PUBLIC AVNDumpProc ~ {
avn: RopeAVN ~ NARROW[value];
IO.PutF[s, "\t{ %g: $rope %g }\n",
IO.card[LOOPHOLE[value]],
IO.rope[avn.value]
];
};
DumpBindingAVN: PUBLIC AVNDumpProc ~ {
avn: BindingAVN ~ NARROW[value];
DumpTGN[s, avn.tgn, n];
DumpAVN[s, avn.node, n];
IO.PutF[s, "\t{ %g: $binding %g %g }\n",
IO.card[LOOPHOLE[value]],
IO.card[LOOPHOLE[avn.tgn]],
IO.card[LOOPHOLE[avn.node]]
];
};
DumpConstructorAVN: PUBLIC AVNDumpProc ~ {
avn: ConstructorAVN ~ NARROW[value];
DumpAVN[s, avn.node, n];
IO.PutF[s, "\t{ %g: $constructor %g }\n",
IO.card[LOOPHOLE[value]],
IO.card[LOOPHOLE[avn.node]]
];
};
DumpDerefAVN: PUBLIC AVNDumpProc ~ {
avn: DerefAVN ~ NARROW[value];
IO.PutF[s, "\t{ %g: $deref %g }\n",
IO.card[LOOPHOLE[value]],
IO.rope[avn.item]
];
};
DumpGroupingAVN: PUBLIC AVNDumpProc ~ {
avn: GroupingAVN ~ NARROW[value];
IO.PutF[s, "\t{ %g: $grouping %g }\n",
IO.card[LOOPHOLE[value]],
IO.card[LOOPHOLE[avn.node]]
];
};
DumpLinkAVN: PUBLIC AVNDumpProc ~ {
avn: LinkAVN ~ NARROW[value];
DumpAVN[s, avn.avn, n];
IO.PutF[s, "\t{ %g: $linkavn %g %g %g }\n",
IO.card[LOOPHOLE[value]],
IO.rope[avn.interface],
IO.rope[avn.item],
IO.card[LOOPHOLE[avn.avn]]
];
};
DumpVariantAVN: PUBLIC AVNDumpProc ~ {
avn: VariantAVN ~ NARROW[value];
DumpAVN[s, avn.node, n];
IO.PutF[s, "\t{ %g: $variant %g %g }\n",
IO.card[LOOPHOLE[value]],
IO.rope[avn.id],
IO.card[LOOPHOLE[avn.node]]
];
};
KindToRope: PROC [ kind: TGNKind ] RETURNS [ rope: ROPE ] ~ {
SELECT kind FROM
indirect => { rope _ "$indirect" };
generic => { rope _ "$generic" };
internal => { rope _ "$internal" };
ENDCASE => ERROR;
};
RopeToKind: PROC [ rope: ROPE ] RETURNS [ kind: TGNKind ] ~ {
SELECT TRUE FROM
Rope.Equal[rope, "$indirect"] => { kind _ indirect };
Rope.Equal[rope, "$generic"] => { kind _ generic };
Rope.Equal[rope, "$internal"] => { kind _ internal };
ENDCASE => ERROR;
};
ValueKindToRope: PROC [ kind: ValueKind ] RETURNS [ rope: ROPE ] ~ {
SELECT kind FROM
bool => { rope _ "$bool" };
constructor => { rope _ "$constructor" };
grouping => { rope _ "$grouping" };
negation => { rope _ "$negation" };
null => { rope _ "$null" };
number => { rope _ "$number" };
string => { rope _ "$string" };
variant => { rope _ "$indirect" };
ENDCASE => ERROR;
};
RopeToValueKind: PROC [ rope: ROPE ] RETURNS [ kind: ValueKind ] ~ {
SELECT TRUE FROM
Rope.Equal[rope, "$bool"] => { kind _ bool };
Rope.Equal[rope, "$constructor"] => { kind _ constructor };
Rope.Equal[rope, "$grouping"] => { kind _ grouping };
Rope.Equal[rope, "$negation"] => { kind _ negation };
Rope.Equal[rope, "$null"] => { kind _ null };
Rope.Equal[rope, "$number"] => { kind _ number };
Rope.Equal[rope, "$string"] => { kind _ string };
Rope.Equal[rope, "$variant"] => { kind _ variant };
ENDCASE => ERROR;
};
ClassToRope: PROC [ class: Generic ] RETURNS [ rope: ROPE ] ~ {
SELECT class FROM
array => rope _ "$array";
bool => rope _ "$bool";
card16 => rope _ "$card16";
card32 => rope _ "$card32";
choice => rope _ "$choice";
enum => rope _ "$enum";
error => rope _ "$error";
int16 => rope _ "$int16";
int32 => rope _ "$int32";
proc => rope _ "$proc";
record => rope _ "$record";
seq => rope _ "$seq";
sink => rope _ "$sink";
source => rope _ "$source";
string => rope _ "$string";
unspec => rope _ "$unspec";
ENDCASE => ERROR;
};
RopeToClass: PROC [ rope: ROPE ] RETURNS [ class: Generic ] ~ {
SELECT TRUE FROM
Rope.Equal[rope, "$array"] => class _ array;
Rope.Equal[rope, "$bool"] => class _ bool;
Rope.Equal[rope, "$card16"] => class _ card16;
Rope.Equal[rope, "$choice"] => class _ choice;
Rope.Equal[rope, "$enum"] => class _ enum;
Rope.Equal[rope, "$error"] => class _ error;
Rope.Equal[rope, "$int16"] => class _ int16;
Rope.Equal[rope, "$card32"] => class _ card32;
Rope.Equal[rope, "$int32"] => class _ int32;
Rope.Equal[rope, "$proc"] => class _ proc;
Rope.Equal[rope, "$record"]=> class _ record;
Rope.Equal[rope, "$seq"] => class _ seq;
Rope.Equal[rope, "$sink"] => class _ sink;
Rope.Equal[rope, "$source"] => class _ source;
Rope.Equal[rope, "$string"] => class _ string;
Rope.Equal[rope, "$unspec"] => class _ unspec;
ENDCASE => ERROR;
};
}.

zSiroccoExternalImpl.Mesa
Copyright ำ 1986, 1987 by Xerox Corporation.  All rights reserved.
Bill Jackson (bj) August 27, 1987 0:20:01 am PDT
Dump/Snarf Object files
Type Graph/Node Creators
internal for now!
Primitive Creators
Primary Creators
DumpTGN[s, tgn.type, n]; -- recursion cut point!
DumpTGN[s, tgn.tgn, n]; -- recursion cut point!
Secondary Creators
Abstract Value Node Creators
internal for now!
avn: NullAVN	=> { DumpNullAVN [s, avn, n]; };
Primary Creators
Secondary Creators
DumpAVN[s, avn.value, n]; -- recursion cut point!
DumpAVN[s, avn.value, n]; -- recursion cut point!
internal/external conversion routines
สุ˜
codeš
œ™Kš
œB™BKš
œ0™0—K˜š
ฯk	˜	Kšœ
œ#œ˜4Kšœœœ
˜Kšœ
œ"˜4Kšœœ ˜,Kšœœ˜)Kšœœ˜Kš
œ˜Kš
œ˜—K˜šฯnœœ
˜"Kšœ
œ˜(Kšœ˜Kšœ3˜7Kšœœœ
˜Kšœœœ
œ
˜
headš
ฯz™šž
œœ
œ˜3Kšœœ$˜-šž
œ˜(Kšœœœฯc˜7Jšœœ
˜Kšœ
œ˜Jš
œ(˜(Jš
œ ˜ Jš
œ"˜"šœ˜š
œ	˜	Kšœ(œ
œœœ	œ˜rKš
œ˜—š
œ
˜
Kšœ)œ
œœœ	œœ˜
Kš
œ˜—Kšœœ˜—Kš
œ˜—šž
œ˜%Kšœœœ ˜7Jšœœ
˜Kšœ
œ˜Jš
œ(˜(Jš
œ ˜ Jš
œ"˜"šœ˜š
œ	˜	Kš
œ˜Kš
œ˜—š
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜—Kšœœ˜—Kš
œ˜—Jšœ	œ˜!Kšœœ˜Kšœœ˜Kšœœ
˜Kšœ	œ˜Kš
œ ˜ K˜Kšœ˜Kšœœœœ˜MK˜Kšœ˜Kšœ˜Kš
œ(˜(Kšœ˜K˜Kšœ˜Kšœ˜Kš
œ%˜%Kšœ˜Kšœ˜Kš
œ˜——š
Ÿ™K™šžœœ˜1Kš
œ˜K˜—šžœœ˜Kšœ
œœ
œ
˜Kšœ ˜)šœœ
˜Kšœœ,˜4Kš
œ,˜,K˜Kš
œ.˜.Kš
œ5˜5Kš
œ1˜1Kš
œ/˜/Kš
œ-˜-Kš
œ/˜/Kš
œ-˜-Kš
œ-˜-Kš
œ1˜1Kš
œ5˜5Kš
œ7˜7Kš
œ/˜/Kš
œ/˜/Kšœœ˜—Kš
œ˜K˜—šžœœ˜'Kšœœœ˜ Jš
œ˜Kš
œ(œœ	œœ˜fKš
œ˜K˜—šžœœ˜#Kšœœ˜Jš
œ˜Jš
œ˜Kšœ'œœ	œœœœ˜~Kš
œ˜—Lš
Ÿ™šžœœ˜$Kš
œ
œ
œ
œœ˜7Kš
œ˜—šžœœ˜(Kš
œ
œ
œ
œœ˜;Kš
œ˜—Lš
Ÿ™šžœœ˜$Kšœœ˜Jš
œ˜Jš
œ˜Kšœ%œœ	œœœœ˜ƒ
Kš
œ˜—šžœœ˜'Kšœœ˜!Kš
œ(œœ	œœœ 
˜xKš
œ˜—šž
œœ˜%Kšœœ˜Jš
œ˜Jš
œ˜Kšœ&œœ	œœœœ˜€
Kš
œ˜—šžœœ˜$Kšœœ˜Jšœ ™0Kšœ%œœ	œ˜TKš
œ˜—šžœœ˜#Kšœœ˜Jš
œ˜Kš
œ!œœ	œœ˜[Kš
œ˜—šžœœ˜$Kšœœ˜Jš
œ˜Kš
œ"œœ	œœ˜aKš
œ˜—šžœœ˜#Kšœœ˜Jšœ ™/Kš
œ(œœ	œœ˜oKš
œ˜—šžœœ˜#Kšœœ˜Jš
œ˜Jš
œ˜Jš
œ˜Kšœ'œœ	œœ
œœœœ˜Ÿ
Kš
œ˜—šž
œœ˜%Kšœœ˜Jš
œ˜Kš
œ#œœ	œœ˜aKš
œ˜—šžœœ˜'Kšœœ˜ Jš
œ˜Jš
œ˜Kšœ(œœ	œœœœ˜†
Kš
œ˜—Lš
Ÿ™šะbnœœ˜(Kšœœ˜!Jš
œ˜Kšœ)œœ	œœœ˜wKš
œ˜—šกœœ˜$Kšœœ˜Jš
œ˜Jš
œ˜Kšœ%œœ	œœœœ˜Kš
œ˜—šกœœ˜$Kšœœ˜Jš
œ˜Jš
œ˜Kšœ%œœ	œœœœ˜Kš
œ˜—šกœœ˜)Kšœœ˜Kšœ$œœ
˜@Kš
œ˜——š
Ÿ™K™šžœœ˜&Kšœœ˜.Kš
œ˜—šžœœ˜2Kš
œ˜K˜—šžœœ˜Kšœœœ
œ
˜Kšœ ˜*šœœ
˜Kšœœ8˜@Kš
œ,˜,K˜Kš
œ-™-Kš
œ3˜3Kš
œ7˜7Kš
œ-˜-K˜Kš
œ3˜3Kš
œ;˜;Kš
œ/˜/Kš
œ5˜5Kš
œ-˜-Kš
œ3˜3Kšœœ˜—Kš
œ˜K˜—šžœœ˜'Kšœœœ˜-Jš
œ˜Kš
œ(œœ
œœ˜gKš
œ˜K˜—šžœœ˜#Kšœœ˜Jš
œ˜Jš
œ˜Kšœ'œœ
œœœœ˜Kš
œ˜—Lš
Ÿ™šžœœ˜#Kš
œ
œ
œ
œœ˜7Kš
œ˜K˜—šกž
œœ˜&Kšœœ˜ Kšœ$œœ
œ˜UKš
œ˜—šกžœœ˜(Kšœœ˜"Kš
œ&œœ
œœ˜nKš
œ˜—šกžœœ˜#Kšœœ˜Kšœ!œœ
œ˜RKš
œ˜—Lš
Ÿ™šžœœ˜&Kšœœ˜ Jš
œ˜Jš
œ˜Kšœ'œœ
œœœœ˜}Kš
œ˜—šžœœ˜*Kšœœ˜$Jš
œ˜Kš
œ(œœ
œœ˜bKš
œ˜—šžœœ˜$Kšœœ˜Jšœ ™1Kšœ"œœ
œ˜RKš
œ˜—šžœœ˜'Kšœœ˜!Jšœ ™1Kš
œ%œœ
œœ˜_Kš
œ˜—šžœœ˜#Kšœœ˜Jš
œ˜Kšœ*œœ
œœœœ
˜Ž
Kš
œ˜—šžœœ˜&Kšœœ˜ Jš
œ˜Kšœ'œœ
œœœ˜rKš
œ˜——š
Ÿ%™%šž
œœœ	œ˜=šœ˜Kš
œ#˜#Kš
œ!˜!Kš
œ#˜#Kšœœ
˜—K˜—šž
œœ	œœ˜=šœ
œ
˜Kš
œ5˜5Kš
œ3˜3Kš
œ5˜5Kšœœ
˜—K˜—šžœœœ	œ˜Dšœ˜Kš
œ˜Kš
œ)˜)Kš
œ#˜#Kš
œ#˜#Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ"˜"Kšœœ
˜—K˜—šžœœ	œœ˜Dšœ
œ
˜Kš
œ-˜-Kš
œ;˜;Kš
œ5˜5Kš
œ5˜5Kš
œ-˜-Kš
œ1˜1Kš
œ1˜1Kš
œ3˜3Kšœœ
˜—K˜—šžœœœ	œ˜?šœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ
˜—K˜—šžœœ	œœ˜?šœ
œ
˜Kš
œ,˜,Kš
œ*˜*Kš
œ.˜.Kš
œ.˜.Kš
œ*˜*Kš
œ,˜,Kš
œ,˜,Kš
œ.˜.Kš
œ,˜,Kš
œ*˜*Kš
œ-˜-Kš
œ(˜(Kš
œ*˜*Kš
œ.˜.Kš
œ.˜.Kš
œ.˜.Kšœœ
˜—K˜——Kš
œ˜K˜——…—1\Cฎ