DIRECTORY
AlpineEnvironment,
Atom,
DB,
DBCommon,
DBDefs,
DBModel,
DBStats,
Rope;

DBImpl: CEDAR MONITOR
IMPORTS DBModel, DBStats, DB
EXPORTS DB =

BEGIN OPEN DBCommon, DBDefs;

ROPE: TYPE = Rope.ROPE;
Initialize: PUBLIC ENTRY PROC[nCachePages: NAT, cacheFileName: ROPE] =
{ ENABLE UNWIND => NULL;
DBModel.Initialize[nCachePages, cacheFileName];
RETURN};

OpenTransaction: PUBLIC ENTRY PROC[segment: Segment, useTrans: TransactionHandle] RETURNS[trans: TransactionHandle, schemaInvalid: BOOL] =
{ ENABLE UNWIND => DBStats.Stopping[OpenTransaction];
DBStats.Starting[OpenTransaction];
[trans, schemaInvalid] _ DBModel.OpenTransaction[segment, useTrans];
DBStats.Stopping[OpenTransaction] };

MarkTransaction: PUBLIC ENTRY PROC[trans: TransactionHandle] = {
ENABLE UNWIND => DBStats.Stopping[MarkTransaction];
DBModel.MarkTransaction[trans];
DBStats.Stopping[MarkTransaction] };

AbortTransaction: PUBLIC ENTRY PROC[trans: TransactionHandle] = {
ENABLE UNWIND => DBStats.Stopping[AbortTransaction];
DBModel.AbortTransaction[trans];
DBStats.Stopping[AbortTransaction] };

CloseTransaction: PUBLIC ENTRY PROC[trans: TransactionHandle] = {
ENABLE UNWIND => DBStats.Stopping[CloseTransaction];
DBModel.CloseTransaction[trans];
DBStats.Stopping[CloseTransaction] };

DeclareSegment: PUBLIC ENTRY PROC[filePath: ROPE, segment: Segment, number: SegmentIndex, lock: AlpineEnvironment.LockOption, readonly: BOOL, createIfNotFound: BOOL, nPagesInitial, nPagesPerExtent: INT] =
{ ENABLE UNWIND => NULL;
DBModel.DeclareSegment[filePath, segment, number, lock, readonly, createIfNotFound, nPagesInitial, nPagesPerExtent] };

EraseSegment: PUBLIC ENTRY PROC[segment: Segment, useTrans: TransactionHandle] RETURNS [trans: TransactionHandle] =
{ ENABLE UNWIND => NULL;
RETURN[DBModel.OpenTransaction[segment: segment, useTrans: useTrans, eraseAfterOpen: TRUE].trans] };

GetSegmentInfo: PUBLIC ENTRY PROC[segment: Segment] RETURNS [filePath: ROPE, readOnly: BOOL] =
{ ENABLE UNWIND => NULL;
[filePath, readOnly] _ DBModel.GetSegmentInfo[segment] };

SegmentsForTransaction: PUBLIC PROC[trans: TransactionHandle] RETURNS [segments: SegmentList] =
{ segments _ IF trans = NIL THEN NIL ELSE trans.segments };
DeclareDomain: PUBLIC ENTRY PROC [name: ROPE, segment: Segment] RETURNS [d: Domain] = {
ENABLE UNWIND => DBStats.Stopping[DeclareDomain];
IF NOT DBModel.initialized THEN ERROR Error[DatabaseNotInitialized];
d _ DBModel.DeclareDomain[name, segment];
DBStats.Stopping[DeclareDomain] };

LookupDomain: PUBLIC ENTRY PROC [name: ROPE, segment: Segment] RETURNS [d: Domain] = {
ENABLE UNWIND => DBStats.Stopping[LookupDomain];
IF NOT DBModel.initialized THEN ERROR Error[DatabaseNotInitialized];
d _ DBModel.LookupDomain[name, segment];
DBStats.Stopping[LookupDomain] };

DestroyDomain: PUBLIC ENTRY PROC [d: Domain] = {
ENABLE UNWIND => DBStats.Stopping[DestroyDomain];
DBModel.DestroyDomain[d];
DBStats.Stopping[DestroyDomain] };

DomainInfo: PUBLIC ENTRY PROC[d: Domain] RETURNS[name: ROPE, segment: DBCommon.Segment] = TRUSTED {
ENABLE UNWIND => NULL;
IF d.key # DBModel.CacheKey[d.segment] THEN ERROR Error[IllegalDomain];
segment _ d.segment;
name _ d.name };

DomainsByName: PUBLIC ENTRY PROC [segment: Segment, lowName, highName: ROPE, start: FirstLast] RETURNS[ds: DomainSet] = {
ENABLE UNWIND => NULL;
ds _ DBModel.DomainsByName[segment, lowName, highName, start] };

NextDomain: PUBLIC ENTRY PROC [ds: DomainSet] RETURNS [d: Domain] = {
ENABLE UNWIND => NULL;
d _ DBModel.NextDomain[ds] };

PrevDomain: PUBLIC ENTRY PROC [ds: DomainSet] RETURNS [d: Domain] = {
ENABLE UNWIND => NULL;
d _ DBModel.PrevDomain[ds] };

ReleaseDomainSet: PUBLIC ENTRY PROC [ds: DomainSet] =
{ ENABLE UNWIND => NULL; DBModel.ReleaseDomainSet[ds] };

DeclareSubType: PUBLIC ENTRY PROC [of, is: Domain] =
{ ENABLE UNWIND => NULL; DBModel.DeclareSubType[of, is] };

DestroySubType: PUBLIC ENTRY PROC [of, is: Domain] =
{ ENABLE UNWIND => NULL; DBModel.DestroySubType[of, is] };

SuperType: PUBLIC ENTRY PROC [d: Domain] RETURNS[super: Domain] =
{ ENABLE UNWIND => NULL; RETURN[DBModel.SuperType[d]] };

SubTypes: PUBLIC ENTRY PROC [d: Domain] RETURNS[subs: DomainSet] =
{ ENABLE UNWIND => NULL; RETURN[DBModel.SubTypes[d]] };

TypeForDomain: PUBLIC ENTRY PROC[d: Domain] RETURNS[type: TypeCode] = 
{ ENABLE UNWIND => NULL; RETURN[DBModel.TypeForDomain[d]] };

DeclareRelation: PUBLIC ENTRY PROC [name: ROPE, segment: Segment, fields: DB.FieldSpec, keys: LIST OF Index] RETURNS [r: Relation] = {
ENABLE UNWIND => DBStats.Stopping[DeclareRelation];
DBStats.Starting[DeclareRelation];
r _ DBModel.DeclareRelation[name, segment, fields, keys];
DBStats.Stopping[DeclareRelation] };

LookupRelation: PUBLIC ENTRY PROC [name: ROPE, segment: Segment] RETURNS [r: Relation] = {
ENABLE UNWIND => DBStats.Stopping[LookupRelation];
DBStats.Starting[LookupRelation];
r _ DBModel.LookupRelation[name, segment];
DBStats.Stopping[LookupRelation] };

DestroyRelation: PUBLIC ENTRY PROC [r: Relation] = {
ENABLE UNWIND => DBStats.Stopping[DestroyRelation];
DBStats.Starting[DestroyRelation];
DBModel.DestroyRelation[r];
DBStats.Stopping[DestroyRelation] };

RelationInfo: PUBLIC ENTRY PROC [r: Relation] RETURNS[name: ROPE, segment: DBCommon.Segment] = TRUSTED {
ENABLE UNWIND => NULL;
IF r.key # DBModel.CacheKey[r.segment] THEN ERROR Error[IllegalRelation];
segment _ r.segment;
name _ r.name };

RelationsByName: PUBLIC ENTRY PROC [segment: Segment, lowName, highName: ROPE, start: FirstLast] RETURNS[rs: RelationSet] = {
ENABLE UNWIND => NULL;
rs _ DBModel.RelationsByName[segment, lowName, highName, start] };

NextRelation: PUBLIC ENTRY PROC [rs: RelationSet] RETURNS [r: Relation] = {
ENABLE UNWIND => NULL;
r _ DBModel.NextRelation[rs] };

PrevRelation: PUBLIC ENTRY PROC [rs: RelationSet] RETURNS [r: Relation] = {
ENABLE UNWIND => NULL;
r _ DBModel.PrevRelation[rs] };

ReleaseRelationSet: PUBLIC ENTRY PROC [rs: RelationSet] =
{ ENABLE UNWIND => NULL; DBModel.ReleaseRelationSet[rs] };

NameToField: PUBLIC ENTRY PROC [r: Relation, name: ROPE] RETURNS[exists: BOOL, pos: CARDINAL] =
{ ENABLE UNWIND => NULL; [exists, pos] _ DBModel.NameToField[r: r, name: name] };

FieldCount: PUBLIC ENTRY PROC[r: Relation] RETURNS[count: CARDINAL] = {
ENABLE UNWIND => NULL; count _ DBModel.FieldCount [r: r] };

FieldInfo: PUBLIC ENTRY PROC [r: Relation, pos: CARDINAL] RETURNS [field: DB.Field] = {
ENABLE UNWIND => NULL;
field _ DBModel.FieldInfo[r, pos] };

DeclareIndex: PUBLIC ENTRY PROC [r: Relation, index: Index] = {
ENABLE UNWIND => DBStats.Stopping[DeclareIndex];
DBStats.Starting[DeclareIndex];
DBModel.DeclareIndex[r, index];
DBStats.Stopping[DeclareIndex] };

DestroyIndex: PUBLIC ENTRY PROC [r: Relation, index: Index] = {
ENABLE UNWIND => DBStats.Stopping[DestroyIndex];
DBStats.Starting[DestroyIndex];
DBModel.DestroyIndex[r, index];
DBStats.Stopping[DestroyIndex] };

Keys: PUBLIC ENTRY PROC[r: Relation] RETURNS[keys: LIST OF Index] = {
keys _ DBModel.Keys[r] };

Indices: PUBLIC ENTRY PROC[r: Relation] RETURNS[indices: LIST OF Index] = {
indices _ DBModel.Indices[r] };
DeclareEntity: PUBLIC ENTRY PROC[d: Domain, name: ROPE] RETURNS[e: Entity] =
{ ENABLE UNWIND => DBStats.Stopping[DeclareEntity];
DBStats.Starting[DeclareEntity];
e _ DBModel.DeclareEntity[d, name];
DBStats.Stopping[DeclareEntity]};

LookupEntity: PUBLIC ENTRY PROC[d: Domain, name: ROPE] RETURNS[e: Entity] =
{ ENABLE UNWIND => DBStats.Stopping[LookupEntity];
DBStats.Starting[LookupEntity];
e _ DBModel.LookupEntity[d, name];
DBStats.Stopping[LookupEntity] };

CreateRelship: PUBLIC ENTRY PROC[r: Relation, init: ValueSequence] RETURNS[t: Relship] =
{ ENABLE UNWIND => DBStats.Stopping[CreateRelship];
DBStats.Starting[CreateRelship];
t _ DBModel.CreateRelship[r, init];
DBStats.Stopping[CreateRelship] };

LookupRelship: PUBLIC ENTRY PROC[r: Relation, key: Index, val: ValueSequence] RETURNS[t: Relship] =
{ ENABLE UNWIND => DBStats.Stopping[LookupRelship];
DBStats.Starting[LookupRelship];
t _ DBModel.LookupRelship[r, key, val];
DBStats.Stopping[LookupRelship] };

oneLittleValueSequence: ValueSequence _ NEW[ValueSequenceObject[1]];

LookupWithSimpleKey: PUBLIC ENTRY PROC[r: Relation, key: Index, val: Value] RETURNS[t: Relship] = TRUSTED {
ENABLE UNWIND => DBStats.Stopping[LookupRelship];
DBStats.Starting[LookupRelship];
IF key.fields.count # 1 THEN ERROR DB.Error[MismatchedAttributeValueType];
oneLittleValueSequence[0] _ val;
t _ DBModel.LookupRelship[r, key, oneLittleValueSequence];
DBStats.Stopping[LookupRelship] };

DestroyEntity: PUBLIC ENTRY PROC[e: Entity] = {
ENABLE UNWIND => DBStats.Stopping[DestroyEntity];
DBStats.Starting[DestroyEntity];
DBModel.DestroyEntity[e];
DBStats.Stopping[DestroyEntity] };

DestroyRelship: PUBLIC ENTRY PROC[t: Relship] = {
ENABLE UNWIND => DBStats.Stopping[DestroyRelship];
DBStats.Starting[DestroyRelship];
DBModel.DestroyRelship[t];
DBStats.Stopping[DestroyRelship] };

SetF: PUBLIC ENTRY PROC[t: Relship, field: CARDINAL, v: Value] = {
ENABLE UNWIND => DBStats.Stopping[SetF];
DBStats.Starting[SetF];
DBModel.SetF[t, field, v];
DBStats.Stopping[SetF] };

GetF: PUBLIC ENTRY PROC[t: Relship, field: CARDINAL] RETURNS [v: Value _ [null[]]] = TRUSTED {
ENABLE UNWIND => DBStats.Stopping[GetF];
DBStats.Starting[GetF];
v _ DBModel.GetF[t, field];
DBStats.Stopping[GetF] };

SetP: PUBLIC ENTRY PROC[e: Entity, r: Relation, field: CARDINAL, v: Value] = {
ENABLE UNWIND => DBStats.Stopping[SetP];
DBStats.Starting[SetP];
DBModel.SetP[e, r, field, v];
DBStats.Stopping[SetP] };

GetP: PUBLIC ENTRY PROC[e: Entity, r: Relation, field: CARDINAL] RETURNS[v: Value_ [null[]]] = TRUSTED {
ENABLE UNWIND => DBStats.Stopping[GetP];
DBStats.Starting[GetP];
v _ DBModel.GetP[e, r, field];
DBStats.Stopping[GetP] };

DomainEq: PUBLIC PROC [d1, d2: Domain] RETURNS[BOOL] = {
RETURN[DBModel.DomainEq[d1, d2]] };

RelationEq: PUBLIC PROC [r1, r2: Relation] RETURNS[BOOL] = {
RETURN[DBModel.RelationEq[r1, r2]] };

AttributeEq: PUBLIC PROC [a1, a2: Attribute] RETURNS[BOOL] = {
RETURN[DBModel.AttributeEq[a1, a2]] };

NullDomain: PUBLIC PROC [d: Domain] RETURNS[BOOLEAN] = {
RETURN[DBModel.NullDomain[d]] };

NullRelation: PUBLIC PROC [r: Relation] RETURNS[BOOLEAN] = {
RETURN[DBModel.NullRelation[r]] };

EntityInfo: PUBLIC ENTRY PROC [e: Entity] RETURNS [name: ROPE, domain: Domain] =
{ ENABLE UNWIND => NULL;
[name, domain] _ DBModel.EntityInfo[e] };

RelationOf: PUBLIC ENTRY PROC[t: Relship] RETURNS [Relation] =
{ ENABLE UNWIND => NULL;
RETURN[DBModel.RelationOf[t]] };
RelationSubset: PUBLIC ENTRY PROC[r: Relation, index: Index, constraint: Constraint, start: FirstLast] RETURNS [rs: RelshipSet] = {
ENABLE UNWIND => DBStats.Stopping[RelationSubset];
DBStats.Starting[RelationSubset];
rs _ DBModel.RelationSubset[r, index, constraint, start];
DBStats.Stopping[RelationSubset] };

NextRelship: PUBLIC ENTRY PROC[rs: RelshipSet] RETURNS [t: Relship] =
{ ENABLE UNWIND => DBStats.Stopping[NextRelship]; 
DBStats.Starting[NextRelship];
t _ DBModel.NextRelship[rs];
DBStats.Stopping[NextRelship] };

PrevRelship: PUBLIC ENTRY PROC[rs: RelshipSet] RETURNS [t: Relship] =
{ ENABLE UNWIND => DBStats.Stopping[PrevRelship]; 
DBStats.Starting[PrevRelship];
t _ DBModel.PrevRelship[rs];
DBStats.Stopping[PrevRelship] };

ReleaseRelshipSet: PUBLIC ENTRY PROC [rs: RelshipSet] =
{ENABLE UNWIND => NULL; DBModel.ReleaseRelshipSet[rs]};

DomainSubset: PUBLIC ENTRY PROC[d: Domain, lowName, highName: ROPE, start: FirstLast] RETURNS [es: EntitySet] = {
ENABLE UNWIND => DBStats.Stopping[DomainSubset];
DBStats.Starting[DomainSubset];
es _ DBModel.DomainSubset[d, lowName, highName, start];
DBStats.Stopping[DomainSubset];
RETURN[es] };

NextEntity: PUBLIC ENTRY PROC[es: EntitySet] RETURNS [e: Entity] =
{ ENABLE UNWIND => DBStats.Stopping[NextEntity]; 
DBStats.Starting[NextEntity];
e _ DBModel.NextEntity[es];
DBStats.Stopping[NextEntity];
};

PrevEntity: PUBLIC ENTRY PROC[es: EntitySet] RETURNS [e: Entity] =
{ ENABLE UNWIND => DBStats.Stopping[PrevEntity]; 
DBStats.Starting[PrevEntity];
e _ DBModel.PrevEntity[es];
DBStats.Stopping[PrevEntity];
};

ReleaseEntitySet: PUBLIC ENTRY PROC[es: EntitySet] =
{ ENABLE UNWIND => NULL; DBModel.ReleaseEntitySet[es]};

RelshipsForEntity: PUBLIC ENTRY PROC [e: Entity] RETURNS [rs: RelshipSet] =
{ ENABLE UNWIND => NULL; RETURN[DBModel.RelshipsForEntity[e]] };

RelshipsWithEntityField: PUBLIC ENTRY PROC[r: Relation, field: CARDINAL, val: Entity] RETURNS[rs: RelshipSet] = {
ENABLE UNWIND => NULL; RETURN[DBModel.RelshipsWithEntityField[r, field, val]] };

RelationsOf: PUBLIC ENTRY PROC[d: Domain] RETURNS[rs: RelationSet] =
{ ENABLE UNWIND => NULL; rs _ DBModel.RelationsOf[d] };
L2VS: PUBLIC PROC[vals: LIST OF Value] RETURNS[seq: ValueSequence] = TRUSTED {
length: CARDINAL _ 0;
IF vals = NIL THEN RETURN[NIL];
FOR vL: LIST OF Value _ vals, vL.rest UNTIL vL = NIL DO
length _ length + 1
ENDLOOP;
seq _ NEW[ValueSequenceObject[length]];
length _ 0;
FOR vL: LIST OF Value _ vals, vL.rest UNTIL vL = NIL DO
seq[length] _ vL.first;
length _ length + 1
ENDLOOP
};

L2FS: PUBLIC PROC[vals: LIST OF DB.Field] RETURNS[seq: DB.FieldSpec] = TRUSTED {
length: CARDINAL _ 0;
IF vals = NIL THEN RETURN[NIL];
FOR vL: LIST OF DB.Field _ vals, vL.rest UNTIL vL = NIL DO
length _ length + 1
ENDLOOP;
seq _ NEW[DB.FieldSpecObject[length]];
length _ 0;
FOR vL: LIST OF DB.Field _ vals, vL.rest UNTIL vL = NIL DO
seq[length] _ vL.first;
length _ length + 1
ENDLOOP
};

L2F: PUBLIC PROC[vals: LIST OF CARDINAL] RETURNS[seq: FieldSequence] = TRUSTED {
length: CARDINAL _ 0;
IF vals = NIL THEN RETURN[NIL];
FOR vL: LIST OF CARDINAL _ vals, vL.rest UNTIL vL = NIL DO
length _ length + 1
ENDLOOP;
seq _ NEW[FieldSequenceObject[length]];
length _ 0;
FOR vL: LIST OF CARDINAL _ vals, vL.rest UNTIL vL = NIL DO
seq[length] _ vL.first;
length _ length + 1
ENDLOOP
};

L2C: PUBLIC PROC[vals: LIST OF ValueConstraint] RETURNS[seq: Constraint] = TRUSTED {
length: CARDINAL _ 0;
IF vals = NIL THEN RETURN[NIL];
FOR vL: LIST OF DBDefs.ValueConstraint _ vals, vL.rest UNTIL vL = NIL DO
length _ length + 1
ENDLOOP;
seq _ NEW[ConstraintObject[length]];
length _ 0;
FOR vL: LIST OF ValueConstraint _ vals, vL.rest UNTIL vL = NIL DO
seq[length] _ vL.first;
length _ length + 1
ENDLOOP
};
Error: PUBLIC SIGNAL [code: DB.ErrorCode] = CODE;
Aborted: PUBLIC ERROR = CODE;
Failure: PUBLIC ERROR [what: ATOM, info: ROPE] = CODE;
InternalError: PUBLIC ERROR = CODE;
{ DBStats.Initialize[] }

END.


 File: DBImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Purpose: Monitored interface to DB, to keep only one client in database system at a time.  Contains one ENTRY per DB procedure (except those that need not be monitored, like Eq).  The procs simply call the internal procs in the DBModel*Impls.
Created by Haugeland and Cattell, April 1982
Last edited by:
Rick Cattell on November 2, 1983 10:13 am
Willie-Sue, February 22, 1985 9:20:26 am PST
Donahue, March 10, 1986 8:49:40 am PST
Widom, September 13, 1985 2:56:52 pm PDT
Part 1: Global top-level operations
Open a new transaction onto an empty database 
Part 2: Schema-definition and -interrogation operations
Part 3: Primitive operations
Part 4: Aggregate operations
Miscellaneous operations
Errors
Initialization
Κƒ˜š
œ™Jšœ
Οm
œ1™<—Jšœ ΟkœFžœžœ~™ς
Jš
œ,™,š
œ™Jš
œ)™)Jš
œ,™,Icode™&Jš
œ(™(—J˜š
ž	˜	Jš
œ˜Jš
œ˜Jšžœ
˜J˜	J˜J˜Jš
œ˜Jš
œ˜J˜—šœžœ
ž˜Jšžœ˜Jšžœ
žœ˜J˜—Jšžœ
žœ˜J˜Jšžœžœžœ
˜
head1š
œ#™#šΟn
œžœ
žœ
žœžœžœ˜Fšœžœ
žœžœ
˜J˜/Jšžœ˜J˜——šŸœžœ
žœ
žœ0žœ*žœ˜Š
šœžœ
žœ&˜5Jš
œ"˜"Jš
œD˜DJš
œ$˜$J˜——šŸœžœ
žœ
žœ˜@Jšžœ
žœ&˜3Jš
œ˜Jš
œ$˜$J˜—šŸœžœ
žœ
žœ˜AJšžœ
žœ'˜4Jš
œ ˜ Jš
œ%˜%J˜—šŸœžœ
žœ
žœ˜AJšžœ
žœ'˜4J˜ š
œ%˜%J˜——šŸœžœ
žœ
žœžœXžœžœ"žœ˜Μ
šœžœ
žœžœ
˜š
œv˜vJ˜———š
Ÿœžœ
žœ
žœ0žœ˜sJš
œ.™.šœžœ
žœžœ
˜JšžœOžœ˜dJ˜——šŸœžœ
žœ
žœžœžœžœ˜^šœžœ
žœžœ
˜Jš
œ9˜9——J˜šŸœžœ
žœžœ˜_Jšœ
žœ	žœ
žœ
žœ
žœ˜;——š
œ7™7šŸ
œžœ
žœ
žœžœžœ˜WJšžœ
žœ$˜1Jšžœ
žœžœ
žœ˜DJš
œ)˜)Jš
œ"˜"—J˜šŸœžœ
žœ
žœžœžœ˜VJšžœ
žœ#˜0Jšžœ
žœžœ
žœ˜DJš
œ(˜(Jš
œ!˜!—J˜šŸ
œžœ
žœ
žœ˜0Jšžœ
žœ$˜1Jš
œ˜Jš
œ"˜"J˜—šŸ
œžœ
žœ
žœžœžœžœ˜cJšžœ
žœžœ
˜Jšžœ%žœ
žœ˜GJ˜Jš
œ˜J˜—šŸ
œžœ
žœ
žœ'žœžœ˜yJšžœ
žœžœ
˜Jš
œ@˜@J˜—š
Ÿ
œžœ
žœ
žœžœ˜EJšžœ
žœžœ
˜Jš
œ˜J˜—š
Ÿ
œžœ
žœ
žœžœ˜EJšžœ
žœžœ
˜Jš
œ˜J˜—šŸœžœ
žœ
žœ˜5Jšœžœ
žœžœ!˜8J˜—šŸœžœ
žœ
žœ˜4Jšœžœ
žœžœ#˜:J˜—šŸœžœ
žœ
žœ˜4Jšœžœ
žœžœ#˜:J˜—š
Ÿ	œžœ
žœ
žœ
žœ˜AJš	œžœ
žœžœžœ˜8J˜—š
Ÿœžœ
žœ
žœ
žœ˜BJš	œžœ
žœžœžœ˜7J˜—š
Ÿ
œžœ
žœ
žœžœ˜FJš	œžœ
žœžœžœ˜<—J˜šŸœžœ
žœ
žœžœžœžœ
žœžœ˜†
Jšžœ
žœ&˜3Jš
œ"˜"Jš
œ9˜9š
œ$˜$J˜——šŸœžœ
žœ
žœžœžœ˜ZJšžœ
žœ%˜2Jš
œ!˜!Jš
œ*˜*Jš
œ#˜#—J˜šŸœžœ
žœ
žœ˜4Jšžœ
žœ&˜3Jš
œ"˜"Jš
œ˜Jš
œ$˜$J˜—šŸœžœ
žœ
žœžœžœžœ˜hJšžœ
žœžœ
˜Jšžœ%žœ
žœ˜IJ˜Jš
œ˜J˜—šŸœžœ
žœ
žœ'žœžœ˜}Jšžœ
žœžœ
˜Jš
œB˜BJ˜—š
Ÿœžœ
žœ
žœžœ˜KJšžœ
žœžœ
˜Jš
œ˜J˜—š
Ÿœžœ
žœ
žœžœ˜KJšžœ
žœžœ
˜Jš
œ˜J˜—šŸœžœ
žœ
žœ˜9Jšœžœ
žœžœ#˜:J˜—šŸœžœ
žœ
žœžœ
žœ	žœžœ˜_Jšœžœ
žœžœ:˜Q—J˜šŸ
œžœ
žœ
žœžœžœ˜GJšžœ
žœžœ&˜;—J˜šŸ	œžœ
žœ
žœžœžœ˜WJšžœ
žœžœ
˜Jš
œ$˜$——˜šŸœžœ
žœ
žœ ˜?Jšžœ
žœ#˜0Jš
œ˜Jš
œ˜Jš
œ!˜!—J˜šŸœžœ
žœ
žœ ˜?Jšžœ
žœ#˜0Jš
œ˜Jš
œ˜Jš
œ!˜!—J˜šŸœžœ
žœ
žœžœžœ
žœ˜EJš
œ˜—J˜šŸœžœ
žœ
žœžœ
žœ
žœ˜KJš
œ˜——š
œ™šŸ
œžœ
žœ
žœžœ
žœ
˜Lšœžœ
žœ$˜3Jš
œ ˜ J˜#J˜!J˜——šŸœžœ
žœ
žœžœ
žœ
˜Kšœžœ
žœ#˜2Jš
œ˜J˜"Jš
œ!˜!J˜——š
Ÿ
œžœ
žœ
žœ"žœ˜Xšœžœ
žœ$˜3Jš
œ ˜ J˜#Jš
œ"˜"J˜——š
Ÿ
œžœ
žœ
žœ-žœ˜cšœžœ
žœ$˜3Jš
œ ˜ Jš
œ'˜'Jš
œ"˜"J˜——Jšœ(žœ˜DJ˜šŸœžœ
žœ
žœ%žœžœ˜kJšžœ
žœ$˜1Jš
œ ˜ Jšžœžœ
žœ
žœ%˜JJš
œ ˜ Jš
œ:˜:Jš
œ"˜"—J˜šŸ
œžœ
žœ
žœ˜/Jšžœ
žœ$˜1Jš
œ ˜ Jš
œ˜Jš
œ"˜"J˜—šŸœžœ
žœ
žœ˜1Jšžœ
žœ%˜2Jš
œ!˜!Jš
œ˜Jš
œ#˜#J˜—š
Ÿœžœ
žœ
žœžœ˜BJšžœ
žœ˜(Jš
œ˜Jš
œ˜Jš
œ˜J˜—šŸœžœ
žœ
žœžœžœžœ˜^Jšžœ
žœ˜(Jš
œ˜Jš
œ˜Jš
œ˜—J˜š
Ÿœžœ
žœ
žœ žœ˜NJšžœ
žœ˜(Jš
œ˜Jš
œ˜Jš
œ˜—J˜šŸœžœ
žœ
žœ žœžœžœ˜hJšžœ
žœ˜(Jš
œ˜Jš
œ˜Jš
œ˜—J˜š
Ÿœžœ
žœžœ
žœ˜8Jšžœ˜#J˜—š
Ÿ
œžœ
žœžœ
žœ˜<Jšžœ˜%J˜—š
Ÿœžœ
žœžœ
žœ˜>Jšžœ ˜&J˜—š
Ÿ
œžœ
žœ
žœ
žœ˜8Jšžœ˜ —J˜š
Ÿœžœ
žœžœ
žœ˜<Jšžœ˜"J˜—šŸ
œžœ
žœ
žœ
žœžœ˜Pšœžœ
žœžœ
˜Jš
œ)˜)—J˜—Jš
Ÿ
œžœ
žœ
žœ
žœ
˜>šœžœ
žœžœ
˜Jšžœ˜ ——š
œ™š
Ÿœžœ
žœ
žœEžœ˜ƒ
šžœ
žœ%˜2Jš
œ!˜!Jš
œ9˜9˜#J˜———š
Ÿœžœ
žœ
žœžœ˜Ešœžœ
žœ#˜2J˜J˜J˜ J˜——š
Ÿœžœ
žœ
žœžœ˜Ešœžœ
žœ#˜2J˜J˜J˜ J˜——šŸœžœ
žœ
žœ˜7Jšœ
žœ
žœžœ!˜7J˜—šŸœžœ
žœ
žœžœžœ˜qJšžœ
žœ#˜0J˜Jš
œ7˜7J˜Jšžœ˜
J˜—š
Ÿ
œžœ
žœ
žœžœ˜Bšœžœ
žœ"˜1J˜J˜J˜J˜J˜——š
Ÿ
œžœ
žœ
žœžœ˜Bšœžœ
žœ"˜1J˜J˜J˜J˜J˜——šŸœžœ
žœ
žœ˜4Jšœžœ
žœžœ ˜7J˜—š
Ÿœžœ
žœ
žœ
žœ˜KJš	œžœ
žœžœžœ!˜@—J˜šŸœžœ
žœ
žœžœžœ˜qJšžœ
žœžœžœ3˜P—J˜š
Ÿœžœ
žœ
žœžœ˜DJšœžœ
žœžœ ˜7——
headš
œ™šŸœžœ
žœžœ
žœžœžœ˜NJšœžœ˜Jš
žœžœ
žœ
žœ
žœ˜šžœžœ
žœžœžœ
ž˜7Jš
œ˜Jšžœ
˜—Jšœžœ˜'Jš
œ˜šžœžœ
žœžœžœ
ž˜7Jš
œ˜Jš
œ˜Jš
ž˜—Jš
œ˜—J˜šŸœžœ
žœžœ
žœ
žœžœžœžœ˜PJšœžœ˜Jš
žœžœ
žœ
žœ
žœ˜š
žœžœ
žœ
žœžœžœ
ž˜:Jš
œ˜Jšžœ
˜—Jšœžœ
žœ˜&Jš
œ˜š
žœžœ
žœ
žœžœžœ
ž˜:Jš
œ˜Jš
œ˜Jš
ž˜—Jš
œ˜—J˜šŸœžœžœ
žœ
žœžœžœ˜PJšœžœ˜Jš
žœžœ
žœ
žœ
žœ˜š
žœžœ
žœ
žœžœžœ
ž˜:Jš
œ˜Jšžœ
˜—Jšœžœ˜'Jš
œ˜š
žœžœ
žœ
žœžœžœ
ž˜:Jš
œ˜Jš
œ˜Jš
ž˜—Jš
œ˜—J˜šŸœžœ
žœžœ
žœžœžœ˜TJšœžœ˜Jš
žœžœ
žœ
žœ
žœ˜šžœžœ
žœ(žœžœ
ž˜HJš
œ˜Jšžœ
˜—Jšœžœ˜$Jš
œ˜šžœžœ
žœ!žœžœ
ž˜AJš
œ˜Jš
œ˜Jš
ž˜—Jš
œ˜——™Jšœžœ
žœžœ
˜1Jšœ	žœ
žœžœ
˜Jšœ	žœ
žœžœžœžœ
˜6Jšœžœ
žœžœ
˜#—™J˜—J˜Jšžœ
˜J˜J˜—…—8 NΓ