DIRECTORY
Alloc: TYPE USING [Notifier, AddNotify, DropNotify],
BcdDefs: TYPE USING [Link, ProcIndex, NullModule],
ComData: TYPE USING [bodyIndex, idANY, idATOM, idBOOL, idCARDINAL, idCHAR, idINT, idLOCK, idREAL, idSTRING, idTEXT, idUNWIND, nErrors, outerCtx, seAnon, sourceTokens, table, textIndex, tC0, tC1, typeATOM, typeAtomRecord, typeBOOL, typeCARDINAL, typeCHAR, typeCONDITION, typeINT, typeLOCK, typeREAL, typeRefANY, typeListANY, typeSTRING, typeStringBody],
ComDataExtras: TYPE USING [],
CompilerUtil: TYPE USING [AcquireStream, ReleaseStream],
ConvertUnsafe: TYPE USING [SubString],
IO: TYPE USING [STREAM],
LiteralOps: TYPE USING [Find],
SourceMap: TYPE USING [Cons],
P1: TYPE USING [InstallParseTable, Parse],
Symbols: TYPE USING [Base, BitAddress, ByteLength, WordLength, SERecord, Name, Type, ISEIndex, CSEIndex, RecordSEIndex, CTXIndex, codeANY, codeINT, codeCHAR, typeANY, typeTYPE, nullName, ISENull, RecordSENull, CTXNull, CBTNull, lZ, ctxType, seType],
SymbolOps: TYPE USING [EnterExtension, EnterString, FillCtxSe, NewCtx, MakeNonCtxSe, MakeSeChain, NextSe, SetSeLink],
Tree: TYPE USING [Link, NullIndex];

Pass1: PROGRAM
IMPORTS Alloc, CompilerUtil, LiteralOps, P1, SourceMap, SymbolOps, dataPtr: ComData
EXPORTS ComDataExtras, CompilerUtil, P1 = {
OPEN SymbolOps, Symbols;


idNAT: PUBLIC Type;
typeNAT: PUBLIC Type;
idINT32: PUBLIC Type;
typeINT32: PUBLIC Type;
idCARD32: PUBLIC Type;
typeCARD32: PUBLIC Type;


seb: Symbols.Base;	-- semantic entry base
ctxb: Symbols.Base;	-- context table base

P1Notify: Alloc.Notifier = {seb _ base[seType]; ctxb _ base[ctxType]};


InstallParseTables: PUBLIC PROC[table: LONG POINTER] = {
P1.InstallParseTable[table];
};


SubString: TYPE = ConvertUnsafe.SubString;

MakeBasicType: PROC[code: [0..16), ordered: BOOL, nBits: CARDINAL]
RETURNS [sei: CSEIndex] = {
sei _ MakeNonCtxSe[SERecord.cons.basic.SIZE];
seb[sei] _ [mark3: TRUE, mark4: TRUE,
body: cons[basic[ordered:ordered, code:code, length:nBits]]];
};

MakeRecordType: PROC[nBits: CARDINAL, default, refField: BOOL_FALSE]
RETURNS [rSei: RecordSEIndex] = {
rSei _ LOOPHOLE[MakeNonCtxSe[SERecord.cons.record.notLinked.SIZE]];
seb[rSei] _ [mark3: TRUE, mark4: TRUE,
body: cons[record[
machineDep: TRUE,
argument: FALSE,  monitored: FALSE, painted: TRUE,
hints: [
comparable: FALSE, assignable: FALSE,
variant: FALSE, unifield: FALSE, privateFields: FALSE,
refField: refField, default: default, voidable: ~refField AND ~default],
fieldCtx: NewCtx[lZ],
length: nBits,
linkPart: notLinked[]]]];
};

MakeRefType: PROC[refType: Type, counted, list: BOOL_FALSE]
RETURNS [sei: CSEIndex] = {
sei _ MakeNonCtxSe[SERecord.cons.ref.SIZE];
seb[sei] _ [mark3: TRUE, mark4: TRUE,
body: cons[ref[
counted: counted,
var: FALSE,
readOnly: FALSE, ordered: FALSE, list: list, basing: FALSE,
refType: refType]]];
};

MakeLongType: PROC[rangeType: Type] RETURNS[sei: CSEIndex] = {
sei _ MakeNonCtxSe[SERecord.cons.long.SIZE];
seb[sei] _ [mark3: TRUE, mark4: TRUE, body: cons[long[rangeType: rangeType]]];
};

MakeSubrangeType: PROC[origin: INTEGER, range: CARDINAL, empty: BOOL]
RETURNS [sei: CSEIndex] = {
sei _ MakeNonCtxSe[SERecord.cons.subrange.SIZE];
seb[sei] _ [mark3: TRUE, mark4: TRUE,
body: cons[subrange[
filled: TRUE, empty: empty,
rangeType: dataPtr.idINT,
origin: origin,  range: range]]];
};

SetIdAttr: PROC[sei: ISEIndex, const: BOOL] = {
seb[sei].immutable _ seb[sei].constant _ const;
seb[sei].extended _ seb[sei].public _ seb[sei].linkSpace _ FALSE;
seb[sei].mark3 _ seb[sei].mark4 _ TRUE};

FillVariable: PROC[
sei: ISEIndex, name: STRING, type: Type, offset: BitAddress, nBits: CARDINAL] = {
desc: SubString;
hash: Name;
IF name # NIL THEN {
desc _ [base:name, offset:0, length:name.length]; hash _ EnterString[desc]}
ELSE hash _ nullName;
FillCtxSe[sei, hash, FALSE];
seb[sei].idType _ type;  seb[sei].idValue _ offset;  seb[sei].idInfo _ nBits;
SetIdAttr[sei, FALSE]};

FillConstant: PROC[sei: ISEIndex, name: STRING, type: Type, value: WORD] = {
desc: SubString _ [base:name, offset:0, length:name.length];
FillCtxSe[sei, EnterString[desc], FALSE];
seb[sei].idType _ type;  seb[sei].idInfo _ 0;  seb[sei].idValue _ value;
SetIdAttr[sei, TRUE]};

FillXferConstant: PROC[
  sei: ISEIndex, name: STRING, type: Type, epN: BcdDefs.ProcIndex] = {
desc: SubString _ [base:name, offset:0, length:name.length];
FillCtxSe[sei, EnterString[desc], FALSE];
seb[sei].idType _ type;  seb[sei].idInfo _ CBTNull;
seb[sei].idValue _ BcdDefs.Link[procedure[gfi: BcdDefs.NullModule, ep: epN, tag: TRUE]];
SetIdAttr[sei, TRUE]};

FillNamedType: PROC[sei: ISEIndex, s: STRING, type: Type] = {
desc: SubString _ [base:s, offset:0, length:s.length];
FillCtxSe[sei, EnterString[desc], FALSE];  SetIdAttr[sei, TRUE];
seb[sei].idType _ typeTYPE;  seb[sei].idInfo _ type;  seb[sei].idValue _ Tree.NullIndex;
SetIdAttr[sei, TRUE]};

MakeTreeLiteral: PROC[val: WORD] RETURNS[Tree.Link] = {
RETURN[[literal[LiteralOps.Find[val]]]]};


nOuterSymbols: NAT = 20;
nMimosaSymbols: NAT = 7;
nExtraSymbols: NAT = 4+nMimosaSymbols;


PrefillSymbols: PUBLIC PROC = { 
OPEN dataPtr;
tSei: CSEIndex;
rSei: RecordSEIndex;
tCtx: CTXIndex;
sei, seChain: ISEIndex;

outerChain: ISEIndex;
NextOuterSe: PROC RETURNS [next: ISEIndex] = {
IF outerChain = ISENull THEN ERROR;
next _ outerChain;  outerChain _ NextSe[outerChain];  RETURN};

(dataPtr.table).AddNotify[P1Notify];
tSei _ MakeBasicType[codeANY, TRUE, WordLength];	-- guaranteed position
outerCtx _ NewCtx[lZ];
outerChain _ ctxb[outerCtx].seList _ MakeSeChain[outerCtx, nOuterSymbols, FALSE];
{tC0 _ MakeTreeLiteral[0]; tC1 _ MakeTreeLiteral[1]};

idANY _ NextOuterSe[];
FillNamedType[idANY, "UNSPECIFIED"L, tSei];
IF tSei # typeANY THEN ERROR;
idINT _ NextOuterSe[];
typeINT _ MakeBasicType[codeINT, TRUE, WordLength];
FillNamedType[idINT, "INTEGER"L, typeINT];
idCHAR _ NextOuterSe[];
typeCHAR _ MakeBasicType[codeCHAR, TRUE, ByteLength];
FillNamedType[idCHAR, "CHARACTER"L, typeCHAR];
idBOOL _ NextOuterSe[];
typeBOOL _ MakeNonCtxSe[SERecord.cons.enumerated.SIZE];
tCtx _ NewCtx[lZ];
seb[typeBOOL] _ [mark3: TRUE, mark4: TRUE,
body: cons[enumerated[
ordered: TRUE, machineDep: TRUE, sparse: FALSE, unpainted: FALSE,
valueCtx: tCtx, empty: FALSE, nValues: 2]]];
ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 2, FALSE];
FillConstant[seChain, "FALSE"L, idBOOL, 0];  seChain _ NextSe[seChain];
FillConstant[seChain, "TRUE"L, idBOOL, 1];
FillNamedType[idBOOL, "BOOLEAN"L, typeBOOL];
idCARDINAL _ NextOuterSe[];
typeCARDINAL _ MakeSubrangeType[0, 177777b, FALSE];
FillNamedType[idCARDINAL, "CARDINAL"L, typeCARDINAL];
FillNamedType[NextOuterSe[], "WORD"L, typeCARDINAL];
idREAL _ NextOuterSe[];
typeREAL _ MakeNonCtxSe[SERecord.cons.real.SIZE];
seb[typeREAL] _ [mark3:TRUE, mark4:TRUE, body:cons[real[rangeType:idINT]]];
FillNamedType[idREAL, "REAL"L, typeREAL];
idNAT _ sei _ NextOuterSe[];	-- NAT
FillNamedType[sei, "NAT"L, typeNAT _ MakeSubrangeType[0, 77777b, FALSE]];
idTEXT _ NextOuterSe[];
rSei _ MakeRecordType[nBits:2*WordLength, default:TRUE];
seb[rSei].hints.variant _ TRUE;
tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 2, FALSE];
FillVariable[seChain, "length"L, idNAT, [wd:0, bd:0], WordLength];
EnterExtension[seChain, default, tC0];
seChain _ NextSe[seChain];
BEGIN
tag: ISEIndex = MakeSeChain[CTXNull, 1, FALSE];
seqSei: CSEIndex = MakeNonCtxSe[SERecord.cons.sequence.SIZE];
FillVariable[tag, "maxLength"L, idNAT, [wd:1, bd:0], WordLength];
seb[tag].immutable _ TRUE;
seb[seqSei] _ [mark3: TRUE, mark4: TRUE,
body: cons[sequence[
packed: TRUE, machineDep: TRUE,
controlled: TRUE, tagSei: tag,
componentType: idCHAR]]];
FillVariable[seChain, "text"L, seqSei, [wd:1, bd:0], WordLength];
END;
FillNamedType[idTEXT, "TEXT"L, rSei];
idSTRING _ NextOuterSe[];
sei _ NextOuterSe[];	-- StringBody
typeStringBody _ rSei _ MakeRecordType[nBits:2*WordLength, default:TRUE];
seb[rSei].hints.assignable _ seb[rSei].hints.voidable _ TRUE;   -- compatibility
tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 3, FALSE];
FillVariable[seChain, "length"L, idCARDINAL, [wd:0, bd:0], WordLength];
EnterExtension[seChain, default, tC0];
seChain _ NextSe[seChain];
FillVariable[seChain, "maxlength"L, idCARDINAL, [wd:1, bd:0], WordLength];
seb[seChain].immutable _ TRUE;
seChain _ NextSe[seChain];
tSei _ MakeNonCtxSe[SERecord.cons.array.SIZE];
seb[tSei] _ [mark3: TRUE, mark4: TRUE,
body: cons[array[
packed: TRUE,
indexType: MakeSubrangeType[0, 0, TRUE],
componentType: idCHAR]]];
FillVariable[seChain, "text"L, tSei, [wd:2, bd:0], 0];
FillNamedType[sei, "StringBody"L, rSei];  typeSTRING _ MakeRefType[sei];
FillNamedType[idSTRING, "STRING"L, typeSTRING];
idLOCK _ NextOuterSe[];
rSei _ MakeRecordType[nBits:WordLength, default:TRUE];
tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 1, FALSE];
FillVariable[seChain, NIL, idANY, [wd:0, bd:0], WordLength];
EnterExtension[seChain, default, MakeTreeLiteral[100000b]];
FillNamedType[idLOCK, "MONITORLOCK"L, rSei];  typeLOCK _ rSei;
sei _ NextOuterSe[];	-- CONDITION
rSei _ MakeRecordType[nBits:2*WordLength, default:TRUE];
typeCONDITION _ rSei;
tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 2, FALSE];
FillVariable[seChain, "timeout"L, idCARDINAL, [wd:1, bd:0], WordLength];
EnterExtension[seChain, default, tC0];
seChain _ NextSe[seChain];
FillVariable[seChain, NIL, idANY, [wd:0, bd:0], WordLength];
EnterExtension[seChain, default, tC0];
FillNamedType[sei, "CONDITION"L, rSei];  typeCONDITION _ rSei;
sei _ NextOuterSe[];	-- MDSZone
tSei _ MakeNonCtxSe[SERecord.cons.zone.SIZE];
seb[tSei] _ [mark3:TRUE, mark4:TRUE, body:cons[zone[counted:FALSE, mds:TRUE]]];
FillNamedType[sei, "MDSZone"L, tSei];
idATOM _ sei _ NextOuterSe[];
typeAtomRecord _ tSei _ MakeNonCtxSe[SERecord.cons.opaque.SIZE];
seb[tSei] _ [mark3: TRUE, mark4: TRUE,
body: cons[opaque[
id: NextSe[sei],
length: 0, lengthKnown: FALSE]]];
tSei _ MakeRefType[refType: tSei, counted: TRUE];
typeATOM _ MakeLongType[tSei];
FillNamedType[idATOM, "ATOM"L, typeATOM];
seAnon _ NextOuterSe[];
FillVariable[seAnon, "?"L,  typeANY, [wd:0, bd:0], WordLength];
FillConstant[NextOuterSe[], "TRUE"L, idBOOL, 1];	-- TRUE
FillConstant[NextOuterSe[], "FALSE"L, idBOOL, 0];	-- FALSE
idUNWIND _ NextOuterSe[];
tSei _ MakeNonCtxSe[SERecord.cons.transfer.SIZE];
seb[tSei] _ [mark3: TRUE, mark4: TRUE,
body: cons[transfer[
mode: error, safe: FALSE,
typeIn: RecordSENull, typeOut: RecordSENull]]];
FillXferConstant[idUNWIND, "UNWIND"L, tSei, 1];
FillXferConstant[NextOuterSe[], "ABORTED"L, tSei, 2];
IF outerChain # ISENull THEN ERROR;

tSei _ MakeNonCtxSe[SERecord.cons.any.SIZE];
seb[tSei] _ [mark3: TRUE, mark4: TRUE, body: cons[any[]]];
typeRefANY _ MakeLongType[MakeRefType[refType: tSei, counted: TRUE]];
rSei _ MakeRecordType[nBits: 2*(2*WordLength), refField: TRUE, default: TRUE];
typeListANY _ MakeLongType[MakeRefType[refType: rSei, counted: TRUE, list: TRUE]];
seb[rSei].painted _ FALSE;
seb[rSei].hints.comparable _ seb[rSei].hints.assignable _ TRUE;
seb[rSei].hints.refField _ TRUE;
tCtx _ seb[rSei].fieldCtx; ctxb[tCtx].seList _ seChain _ MakeSeChain[tCtx, 2, FALSE];
FillVariable[seChain, "first"L, typeRefANY, [wd:0, bd:0], 2*WordLength];
seChain _ NextSe[seChain];
FillVariable[seChain, "rest"L, typeListANY, [wd:2, bd:0], 2*WordLength];

outerChain _ ctxb[outerCtx].seList _ MakeSeChain[outerCtx, nExtraSymbols, TRUE];
FillNamedType[NextOuterSe[], "BOOL"L, idBOOL];
FillNamedType[NextOuterSe[], "CHAR"L, idCHAR];
idINT32 _ sei _ NextOuterSe[];	-- INT
typeINT32 _ MakeLongType[idINT];
FillNamedType[sei, "INT"L, typeINT32];
idCARD32 _ sei _ NextOuterSe[];	-- CARD
typeCARD32 _ MakeLongType[idCARDINAL];
FillNamedType[sei, "CARD"L, typeCARD32];
sei _ NextOuterSe[];	-- INT16
FillNamedType[sei, "INT16"L, typeINT];
sei _ NextOuterSe[];	-- INT32
FillNamedType[sei, "INT32"L, typeINT32];
sei _ NextOuterSe[];	-- CARD16
FillNamedType[sei, "CARD16"L, idCARDINAL];
sei _ NextOuterSe[];	-- CARD32
FillNamedType[sei, "CARD32"L, typeCARD32];
sei _ NextOuterSe[];	-- NAT15
FillNamedType[sei, "NAT15"L, typeNAT];
sei _ NextOuterSe[];	-- NATURAL
FillNamedType[sei, "NATURAL"L, typeNAT];
sei _ NextOuterSe[];	-- BYTE
FillNamedType[sei, "BYTE"L, MakeSubrangeType[0, 377b, FALSE]];

SetSeLink[sei, idANY];
IF outerChain # ISENull THEN ERROR;

(dataPtr.table).DropNotify[P1Notify]};


IdOfFirst: PUBLIC PROC RETURNS[Name] = {RETURN[HashForId["first"L]]};

IdOfLock: PUBLIC PROC RETURNS[Name] = {RETURN[HashForId["LOCK"L]]};

IdOfRest: PUBLIC PROC RETURNS[Name] = {RETURN[HashForId["rest"L]]};

HashForId: PROC[id: STRING] RETURNS[Name] = {
desc: SubString _ [base:id, offset:0, length:id.length];
RETURN[EnterString[desc]]};



P1Unit: PUBLIC PROC RETURNS[success: BOOL] = {
source: IO.STREAM _ CompilerUtil.AcquireStream[$source];
dataPtr.textIndex _ SourceMap.Cons[0];  dataPtr.bodyIndex _ CBTNull;
[complete:success, nTokens:dataPtr.sourceTokens, nErrors:dataPtr.nErrors] _
P1.Parse[source, Logger, TRUE];
EnterHashMark[];
CompilerUtil.ReleaseStream[$source]};

Logger: PROC[inner: PROC[log: IO.STREAM]] = {
log: IO.STREAM _ CompilerUtil.AcquireStream[$log];
inner[log];
CompilerUtil.ReleaseStream[$log]};

EnterHashMark: PROC = INLINE {
desc: SubString _ [base:"  "L, offset:1, length:0];
[] _ EnterString[desc]};

}.

zPass1.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Satterthwaite, June 2, 1986 3:49:57 pm PDT
Russ Atkinson (RRA) December 3, 1986 5:11:53 pm PST
special exported variables (to ComDataExtras)
symbol table bases
initialization of parsing tables
construction of predeclared symbols
number of predeclared ids (outer level only)
number of predeclared ids for Mimosa
number of new predeclared ids
make some constants
REF ANY
LIST OF REF ANY
predeclared types added for Cedar

predeclared types added for Mimosa compatibility
cleanup stuff
pass 1 control
marks end of symbols from source file in hash table
Κ˜
codeš
œ
™
Kšœ
Οm
œ7™BKš
œ*™*K™3—˜š
Οk	˜	Kšœžœ
žœ#˜4Kšœ	žœ
žœ˜2Kšœ	žœ
žœΝ˜ΰKšœžœ
žœ˜Kšœžœ
žœ ˜8Kšœžœ
žœ
˜&Kšžœžœ
žœžœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜*Kšœ	žœ
žœζ
˜ω
Kšœžœ
žœ`˜uKšœžœ
žœ˜#K˜——šΟnœž˜KšžœL˜SKšžœ$˜+Kšžœ˜K˜™-K˜Kšœžœ˜Kšœ	žœ˜Kšœ	žœ˜Kšœžœ˜Kšœ
žœ˜Kšœžœ˜K˜—š
œ™K˜KšœΟc˜)Kšœ ˜)K˜K˜FK˜—Kš
œ ™ ˜š
Ÿœžœ
žœžœ
žœ˜8K˜K˜K˜——Kš
œ#™#˜Kšœžœ˜*K˜šŸ
œžœžœ	žœ
˜BKšžœ˜Kšœ'žœ˜-šœžœ	žœ
˜%K˜=—Kš
œ˜K˜—š
Ÿœžœžœžœ
žœ
˜DKšžœ˜!Kšœžœ-žœ˜Cšœžœ	žœ
˜&˜Kšœžœ
˜Kšœ
žœžœžœ
˜2˜Kšœžœžœ
˜%Kšœ	žœžœžœ
˜6Kšœ:žœ˜H—K˜K˜K˜——Kš
œ˜K˜—šŸœžœžœ
žœ
˜;Kšžœ˜Kšœ%žœ˜+šœžœ	žœ
˜%˜K˜Kšœžœ
˜Kšœ
žœžœžœ
˜;K˜——Kš
œ˜K˜—šŸœžœžœ˜>Kšœ&žœ˜,Kšœžœ	žœ*˜NKš
œ˜K˜—š
Ÿœžœ	žœ	žœ	žœ
˜EKšžœ˜Kšœ*žœ˜0šœžœ	žœ
˜%˜Kšœžœ˜K˜K˜!——Kš
œ˜K˜—šŸ	œžœžœ˜/K˜/Kšœ;žœ
˜AKšœ"žœ˜(K˜—šŸœžœ
˜Kšœžœ)žœ˜QKš
œ˜K˜šžœžœ
žœ˜K˜K—Kšžœ˜Kšœžœ˜K˜MKšœžœ˜K˜—šŸœžœžœžœ˜LKš
œ<˜<Kšœ"žœ˜)K˜HKšœžœ˜K˜—šŸœžœ
˜Kšœžœ)˜FKš
œ<˜<Kšœ"žœ˜)K˜3KšœPžœ˜XKšœžœ˜K˜—šŸ
œžœžœ˜=Kš
œ6˜6Kšœ"žœžœ˜@K˜XKšœžœ˜K˜—šŸœžœžœžœ˜7Kšžœ#˜)K˜K˜—šœžœ˜Kš
œ,™,—šœžœ˜Kš
œ$™$—šœžœ˜&Kš
œ™—K˜K˜šŸœžœ
žœ˜ Kšžœ	˜
K˜K˜K˜K˜K˜K˜šŸœžœ
žœ˜.Kšžœžœ
žœ
˜#Kšœ6žœ˜>K˜—K˜$Kšœžœ ˜GK˜KšœJžœ˜Qš
œ™K˜5K˜—˜K˜+Kšžœžœ
žœ
˜—š
œ˜Kšœ!žœ˜3K˜*—š
œ˜Kšœ#žœ˜5K˜.—˜Kšœ1žœ˜7K˜šœžœ	žœ
˜*˜Kš	œ	žœžœ
žœ
žœ
˜AKšœžœ˜,——Kšœ3žœ˜:K˜GK˜*K˜,—˜Kšœ,žœ˜3K˜5—K˜4˜Kšœ+žœ˜1Kšœžœžœ$˜KK˜)—šœ ˜#KšœAžœ˜I—˜Kšœ2žœ˜8Kšœžœ
˜KšœNžœ˜U˜BK˜&—˜Kš
ž˜Kšœ(žœ˜/Kšœ7žœ˜=˜AKšœžœ
˜—šœžœ	žœ
˜(˜Kšœžœžœ
˜Kšœžœ˜K˜——K˜AKšžœ
˜—K˜%—K˜šœ 
˜"KšœCžœ˜IKšœ8žœ ˜PKšœNžœ˜U˜GK˜&—K˜˜JKšœžœ
˜—K˜Kšœ(žœ˜.šœžœ	žœ
˜&˜Kšœžœ
˜
Kšœ"žœ˜(K˜——K˜6K˜HK˜/—˜Kšœ0žœ˜6KšœNžœ˜Ušœžœ#˜<K˜;—K˜>—šœ ˜!Kšœ2žœ˜8K˜KšœNžœ˜U˜HK˜&—K˜šœžœ#˜<K˜&—K˜>—šœ 
˜Kšœ'žœ˜-Kš	œžœžœžœžœ˜OK˜%—˜Kšœ:žœ˜@šœžœ	žœ
˜&˜K˜Kšœžœ˜!——Kšœ+žœ˜1K˜K˜)—˜K˜?—Kšœ1 ˜8Kšœ2 ˜:˜Kšœ+žœ˜1šœžœ	žœ
˜&˜Kšœžœ
˜K˜/——K˜/—K˜5Kšžœžœ
žœ
˜#K˜š
œ™Kšœ&žœ˜,Kšœžœ	žœ˜:Kšœ>žœ˜E—š
œ™Kšœ9žœžœ˜NKšœ?žœžœ˜RKšœžœ
˜Kšœ:žœ
˜?Kšœžœ
˜ KšœNžœ˜UK˜HK˜K˜HK˜—š
œ!™!KšœJžœ˜PK˜.K˜.šœ ˜%K˜ K˜&—šœ  ˜'K˜&K˜(—K™—š
œ0™0šœ ˜K˜&—šœ ˜K˜(—šœ 	˜K˜*—šœ 	˜K˜*—šœ ˜Kš
œ&˜&—šœ 
˜Kš
œ(˜(—šœ ˜Kšœ6žœ˜>—K˜—™
K˜Kšžœžœ
žœ
˜#K˜K˜&K˜K˜——Kš
Ÿ	œžœ
žœ
žœ
žœ˜EK˜Kš
Ÿœžœ
žœ
žœ
žœ˜CK˜Kš
Ÿœžœ
žœ
žœ
žœ˜CK˜šŸ	œžœžœžœ
˜-Kš
œ8˜8Kšžœ˜K˜K˜——Kš
œ™˜š
Ÿœžœ
žœ
žœ
žœ˜.Kšœžœ
žœ'˜8K˜D˜KKšœžœ˜—K˜K˜%K˜—š
Ÿœžœžœžœ
žœ˜-Kšœžœ
žœ$˜2K˜K˜"K˜—šŸ
œžœžœ˜Kš
œ3™3Kš
œ3˜3K˜K˜——˜K˜———…—3ΔBC