DIRECTORY
Basics USING [LowHalf],
DBCommon,
DBStorage,
DBDefs,
DB,
DBModelPrivate,
Rope USING [ROPE, Concat];

DBModelSystemImpl: CEDAR PROGRAM
IMPORTS DB, DBStorage, DBModelPrivate, Basics, Rope
EXPORTS DBDefs, DBModelPrivate =

BEGIN OPEN DBStorage, DBCommon, DBDefs, DBModelPrivate; 

ROPE: TYPE = Rope.ROPE;

MaxVTID: CARDINAL = DBStorage.MaxSystemTupleID;

Property: TYPE = Attribute;
AnyDomainType,
BoolType,
IntType,
TimeType,
RopeType: PUBLIC DataType;

RecordType: PUBLIC DataType;
DomainTSID: LONG CARDINAL = 1;
RelationTSID: LONG CARDINAL = 2;
AttributeTSID: LONG CARDINAL = 3;
DataTypeTSID: LONG CARDINAL = 4;
IndexTSID: LONG CARDINAL = 5;
IndexFactorTSID: LONG CARDINAL = 6;

aRelationTSID: LONG CARDINAL = 7;
aTypeTSID: LONG CARDINAL = 8;
aUniquenessTSID: LONG CARDINAL = 9;
aLengthTSID: LONG CARDINAL = 10;
aLinkTSID: LONG CARDINAL = 11;
aDomainTSID: LONG CARDINAL = 12;
aUnlinkedTSID: LONG CARDINAL = 13;
ifIndexTSID: LONG CARDINAL = 14;
ifOrdinalPositionTSID: LONG CARDINAL = 15;
ifAttributeTSID: LONG CARDINAL = 16;
dSubTypeTSID: LONG CARDINAL = 17;

DummyID: LONG CARDINAL = 19; -- used for one fake relation

RopeTypeID: LONG CARDINAL = 20;
IntTypeID: LONG CARDINAL = 21;
TimeTypeID: LONG CARDINAL = 22;
BoolTypeID: LONG CARDINAL = 23;
RecordTypeID: LONG CARDINAL = 24;
AnyDomainTypeID: LONG CARDINAL = 25;
STSVecType: TYPE = ARRAY[1..MaxVTID] OF TupleHandle;
systemTupleVec: PUBLIC REF STSVecType _ NEW[STSVecType_ ALL[NIL]];
attributeIDCount: LONG CARDINAL_ 0;

DomainDomain: PUBLIC Domain; -- one element per client-defined domain

dHandleProp: PUBLIC Property;  -- the storage level tupleset handle
dIndexProp: PUBLIC Property;  -- the storage level index handle for this domain

dSubType: PUBLIC Relation; -- one element per direct sub-super type relationship
dSubTypeOf: PUBLIC Attribute; -- domain: the super-type
dSubTypeIs: PUBLIC Attribute; -- domain: the sub-type

RelationDomain: PUBLIC Domain; -- one element per client-defined relation

rHandleProp: PUBLIC Property;  -- the storage level tupleset handle
r1to1Prop: PUBLIC Property;  -- TRUE iff this relation is a surrogate relation

AttributeDomain: PUBLIC Domain; -- one element per client-defined attribute

aHandleProp: PUBLIC Property;  -- the storage level handle for this field
aTypeCodeProp: PUBLIC Property;  -- tid of the type entity, or zero if domain-valued
aTypeEntityProp: PUBLIC Property;  -- the domain this attribute refs, or NIL if datum-valued

aRelation: PUBLIC Relation; -- one element per client-defined attribute
aRelationOf: PUBLIC Attribute; -- the attribute
aRelationIs: PUBLIC Attribute; -- relation of the attribute

aType: PUBLIC Relation; -- one element per client-defined attribute
aTypeOf: PUBLIC Attribute; -- the attribute
aTypeIs: PUBLIC Attribute; -- domain or datatype of the attribute

aUniqueness: PUBLIC Relation; -- one element per client-defined attribute
aUniquenessOf: PUBLIC Attribute; -- the attribute
aUniquenessIs: PUBLIC Attribute; -- INT corresponding to its uniqueness

aLength: PUBLIC Relation; -- one element per client-defined attribute
aLengthOf: PUBLIC Attribute; -- the attribute
aLengthIs: PUBLIC Attribute;  -- INT corresponding to attribute's length

aLink: PUBLIC Relation; -- one element per client-defined attribute
aLinkOf: PUBLIC Attribute; -- the attribute
aLinkIs: PUBLIC Attribute;  -- INT corresponding to its LinkType.

aDomain: PUBLIC Relation; -- exported to DBModelPrivate: one elt per client-defined attribute
aDomainOf: PUBLIC Attribute; -- the attribute
aDomainIs: PUBLIC Attribute;  -- non-NIL only if this is the first (targetted) attribute of

aUnlinked: PUBLIC Relation; -- exported to DBModelPrivate: one elt per client-defined attribute
aUnlinkedOf: PUBLIC Attribute; -- the attribute
aUnlinkedIs: PUBLIC Attribute;  -- non-NIL only if this attribute is NOT linked, in which

DataTypeDomain: PUBLIC Domain;  -- RopeTypeEntity, BoolTypeEntity, etc. are of this domain

RopeTypeEntity, IntTypeEntity, TimeTypeEntity, BoolTypeEntity, RecordTypeEntity, AnyDomainTypeEntity: PUBLIC Entity;

IndexDomain: PUBLIC Domain;  -- one element per client-defined index
iHandleProp: PUBLIC Property;  -- index handle, set by storage level

IndexFactorDomain: PUBLIC Domain;  -- one element per attribute in an index

ifIndex: PUBLIC Relation;  -- one element per attribute in an index (an "index factor")
ifIndexOf: PUBLIC Attribute;  -- the index factor
ifIndexIs: PUBLIC Attribute;  -- the index this index factor belongs to

ifOrdinalPosition: PUBLIC Relation; -- one element per index factor
ifOrdinalPositionOf: PUBLIC Attribute;  -- the index factor
ifOrdinalPositionIs: PUBLIC Attribute;  -- the position of this index factor in the ordering

ifAttribute: PUBLIC Relation; -- one element per index factor
ifAttributeOf: PUBLIC Attribute;  -- the index factor
ifAttributeIs: PUBLIC Attribute;  -- the attribute this index factor indexes
defaultNameHandle, attributeNameHandle, tupleSetNameHandle: PUBLIC DBStorage.FieldHandle;
defaultNameAttribute: PUBLIC Attribute;

DefaultNameSize: CARDINAL = 20;

minfString: ROPE _ ""; -- less than any other string
infString: ROPE _ "\177"; -- greater than any other string

InitializeSystemTuples: PUBLIC PROC = TRUSTED
BEGIN dNameProp, rNameProp, aNameProp: Property; -- only need temporarily

DBStorage.SetSystemTupleTable[systemTupleVec];

DomainDomain_ DefineSystemDomain[DomainTSID, "Domain"];
RelationDomain_ DefineSystemDomain[RelationTSID, "Relation"];
AttributeDomain_ DefineSystemDomain[AttributeTSID, "Attribute"];
DataTypeDomain_ DefineSystemDomain[DataTypeTSID, "DataType"];
IndexDomain_ DefineSystemDomain[IndexTSID, "Index"];
IndexFactorDomain_ DefineSystemDomain[IndexFactorTSID, "IndexFactor"];

RopeType_ $ROPE;
IntType_ $INT;
TimeType_ $GMT;
BoolType_ $BOOL;
AnyDomainType_ $ANY;
RecordType_ $RECORD;

RopeTypeEntity _ DefineSystemEntity[RopeTypeID, DataTypeDomain, "ROPE"];
IntTypeEntity _ DefineSystemEntity[IntTypeID, DataTypeDomain, "INT"];
TimeTypeEntity _ DefineSystemEntity[TimeTypeID, DataTypeDomain, "GMT"];
BoolTypeEntity _ DefineSystemEntity[BoolTypeID, DataTypeDomain, "BOOL"];
RecordTypeEntity _ DefineSystemEntity[RecordTypeID, DataTypeDomain, "RECORD"];
AnyDomainTypeEntity _ DefineSystemEntity[AnyDomainTypeID, DataTypeDomain, "ANY"];

FakeTheNameHandle[]; -- must call after RopeType defined but before any real entities


dHandleProp_ DefinePrivateProperty[
DomainDomain, "dHandleProp", RecordType, DBStorage.TuplesetObjectSize];
dNameProp_ DefinePrivateProperty[DomainDomain, "dName", RopeType, DefaultNameSize];
tupleSetNameHandle_ dNameProp.fh;
dIndexProp_ DefinePrivateProperty[DomainDomain, "dIndexProp", $IndexDomain];

rHandleProp_ DefinePrivateProperty[
RelationDomain, "rHandleProp", RecordType, DBStorage.TuplesetObjectSize];
rNameProp_ DefinePrivateProperty[
RelationDomain, "rNameProp", RopeType, DefaultNameSize];
r1to1Prop_ DefinePrivateProperty[RelationDomain, "r1to1", BoolType];

aHandleProp_ DefinePrivateProperty[
AttributeDomain, "aHandleProp", RecordType, DBStorage.FieldObjectSize];
aNameProp_ DefinePrivateProperty[AttributeDomain, "aName", RopeType];
attributeNameHandle_ aNameProp.fh;
aTypeCodeProp_ DefinePrivateProperty[
AttributeDomain, "aTypeCodeProp", IntType];
aTypeEntityProp_ DefinePrivateProperty[
AttributeDomain, "aTypeEntityProp", $DataTypeDomain];

iHandleProp_ DefinePrivateProperty[
IndexDomain, "iHandleProp", RecordType, DBStorage.IndexObjectSize];


FakeTheTypeAndLinkRelations[];
[aRelation, aRelationOf, aRelationIs]_ DefineSystemBinary[
id: aRelationTSID, name: "aRelation", of: $AttributeDomain, is: $RelationDomain];
[aUniqueness, aUniquenessOf, aUniquenessIs]_ DefineSystemBinary[
id: aUniquenessTSID, name: "aUniqueness", of: $AttributeDomain, is: IntType];
[aLength, aLengthOf, aLengthIs]_ DefineSystemBinary[
id: aLengthTSID, name: "aLength", of: $AttributeDomain, is: IntType];
[aDomain, aDomainOf, aDomainIs]_ DefineSystemBinary[
id: aDomainTSID, name: "aDomain", of: $AttributeDomain, is: $DomainDomain];
[aUnlinked, aUnlinkedOf, aUnlinkedIs]_ DefineSystemBinary[
id: aUnlinkedTSID, name: "aUnlinked", of: $AttributeDomain, is: $DomainDomain];
[ifIndex, ifIndexOf, ifIndexIs]_ DefineSystemBinary[
id: ifIndexTSID, name: "ifIndex", of: $IndexFactorDomain, is: $IndexDomain];
[ifOrdinalPosition, ifOrdinalPositionOf, ifOrdinalPositionIs]_ DefineSystemBinary[
id: ifOrdinalPositionTSID, name: "ifOrdinalPosition", of: $IndexFactorDomain, is: IntType];
[ifAttribute, ifAttributeOf, ifAttributeIs]_ DefineSystemBinary[
id: ifAttributeTSID, name: "ifAttribute", of: $IndexFactorDomain, is: $AttributeDomain];
[dSubType, dSubTypeOf, dSubTypeIs]_ DefineSystemBinary[
id: dSubTypeTSID, name: "dSubType", of: $DomainDomain, is: $DomainDomain, is1to1: FALSE];

END;

FakeTheNameHandle: PROC =
BEGIN
fakeReln: Relation_ DefineSystemRelation[DummyID, "fakeReln", FALSE];
defaultNameAttribute_ DefineSystemField[fakeReln.systemTupleSet, "defaultNameAttribute", RopeType];
defaultNameAttribute.relation _ fakeReln;
defaultNameHandle_ defaultNameAttribute.fh;
END;

FakeTheTypeAndLinkRelations: PROC =
BEGIN
aType_ DefineSystemRelation[
id: aTypeTSID, name: "aType", is1to1: TRUE];
aTypeOf_ DefineSystemFieldObject["aTypeOf", $AttributeDomain].a;
aTypeOf.relation _ aType;
aTypeIs_ DefineSystemField[aType.systemTupleSet, "aTypeIs", $DataTypeDomain];
aTypeIs.relation _ aType;
aTypeIs.fh_ aTypeEntityProp.fh; -- so group scans work on type
aTypeOf.relation_ aTypeIs.relation_ aType;
aType.attributes_ LIST[aTypeOf, aTypeIs];
aLink_ DefineSystemRelation[
id: aLinkTSID, name: "aLink", is1to1: TRUE];
aLinkOf_ DefineSystemFieldObject["aLinkOf", $AttributeDomain].a;
aLinkOf.relation _ aLink;
aLinkIs_ DefineSystemField[aLink.systemTupleSet, "aLinkIs", IntType];
aLinkIs.relation _ aLink;
aLink.attributes_ LIST[aLinkOf, aLinkIs];
aLinkOf.relation_ aLinkIs.relation_ aLink;
END;

DefineSystemBinary: PROC [
id: LONG CARDINAL, name: ROPE, of: DataType, is: DataType, is1to1: BOOL_ TRUE]
RETURNS [r: Relation, rOf, rIs: Attribute] =
BEGIN
r_ DefineSystemRelation[id, name, is1to1];
IF is1to1 THEN
BEGIN
ofDomain: Domain _ SystemDataTypeToDomain[of];
rOf_ DefineSystemFieldObject[Rope.Concat[name, "Of"], of].a;
rOf.relation _ r;
rIs_ DefineSystemField[ofDomain.systemTupleSet, Rope.Concat[name, "Is"], is, DefaultNameLength];
rIs.relation _ r;
END
ELSE
BEGIN
rOf_ DefineSystemField[r.systemTupleSet, Rope.Concat[name, "Of"], of];
rOf.relation _ r;
rIs_ DefineSystemField[r.systemTupleSet, Rope.Concat[name, "Is"], is, DefaultNameLength];
rIs.relation _ r;
END;
r.attributes_ LIST[rOf, rIs];
rOf.relation_ rIs.relation_ r;
END;

SystemDataTypeToDomain: PROC[type: DataType] RETURNS [d: Domain] =
BEGIN
SELECT type FROM
$DomainDomain => RETURN[DomainDomain];
$RelationDomain => RETURN[RelationDomain];
$AttributeDomain => RETURN[AttributeDomain];
$DataTypeDomain => RETURN[DataTypeDomain];
$IndexDomain => RETURN[IndexDomain];
$IndexFactorDomain => RETURN[IndexFactorDomain];
ENDCASE => ERROR DB.InternalError;
END;

DefineSystemRelation: PROC[id: LONG CARDINAL, name: ROPE, is1to1: BOOL] RETURNS[Relation] = TRUSTED
BEGIN
r: Relation _ NEW[RelationObject];
t: TupleHandle _ DBStorage.ConsSystemTupleObject[];
IF id>MaxVTID THEN ERROR DB.InternalError;
t.tid_ id;
t.name _ name;
r.name _ name;
r.isSystem _ TRUE;
r.is1to1 _ is1to1;
r.systemTupleSet _ DBStorage.CreateSystemTupleset[id];
systemTupleVec[Basics.LowHalf[id]]_ t;
r.tuple _ t;
RETURN[r];
END;

DefineSystemDomain: PROC[id: LONG CARDINAL, name: ROPE] RETURNS[Domain] = TRUSTED
BEGIN
d: Domain _ NEW[DomainObject];
t: TupleHandle _ DBStorage.ConsSystemTupleObject[];
IF id>MaxVTID THEN ERROR DB.InternalError;
t.tid_ id;
t.name _ name;
d.isSystem _ TRUE;
d.name _ name;
d.systemTupleSet _ DBStorage.CreateSystemTupleset[id];
systemTupleVec[Basics.LowHalf[id]]_ t;
d.tuple _ t;
RETURN[d];
END;

DefineSystemField: PROC[
ts: DBStorage.SystemTuplesetHandle, name: ROPE, type: DataType, length: CARDINAL_ 0] RETURNS[Attribute] = TRUSTED
BEGIN
f: Attribute; t: TupleHandle;
[f, t] _ DefineSystemFieldObject[name, type];
f.fh_ DBStorage.AddSystemField[ts, MakeFD[type, length,, t]];
RETURN[f]
END;

DefineSystemFieldObject: PROC[
name: ROPE, type: DataType] RETURNS[a: Attribute, t: TupleHandle] = TRUSTED
BEGIN
a _ NEW[AttributeObject];
t _ DBStorage.ConsSystemTupleObject[];
t.tid_ FirstAttributeID + attributeIDCount;
t.name _ name;
a.isSystem _ TRUE;
a.name _ name;
a.type _ type;
attributeIDCount_ attributeIDCount+1;
IF FirstAttributeID+attributeIDCount>MaxVTID THEN ERROR DB.InternalError;
systemTupleVec[Basics.LowHalf[attributeIDCount+FirstAttributeID-1]]_ t;
a.tuple _ t;
RETURN[a, t]
END;

DefineSystemEntity: PROC[
id: LONG CARDINAL, d: Domain, name: ROPE] RETURNS [Entity] = TRUSTED
BEGIN
t: TupleHandle _ DBStorage.ConsSystemTupleObject[];
t.tid_ id;
t.name _ name;
systemTupleVec[Basics.LowHalf[id]]_ t;
RETURN[t]
END;

DefinePrivateProperty: PROC [
d: Domain, name: ROPE, type: DataType, length: INT_ 0] RETURNS [Property] =
BEGIN fakeAttribute: Attribute;
fakeAttribute_ DefineSystemField[d.systemTupleSet, name, type, length];
fakeAttribute.domain _ d;
d.attributes_ CONS[fakeAttribute, d.attributes];
fakeAttribute.domain_ d;
RETURN[fakeAttribute]
END;
SystemDomainSubset: PUBLIC PROC[d: Domain, lowName, highName: ROPE, segment: SegmentHandle, es: EntitySet] RETURNS [EntitySet] = TRUSTED
BEGIN
MakeIndexScan: PROC[indexToScan: DBStorage.IndexHandle] RETURNS[EntitySet] = TRUSTED
BEGIN
tsScan: DBStorage.IndexScanHandle;
[lowName, highName]_ NCodeAndDefaultLimits[lowName, highName];
tsScan_ DBStorage.OpenScanIndex[indexToScan, [lowName, highName, TRUE, TRUE], First ];
es.scan _ index;
es.indexScanHandle _ tsScan;
RETURN[es];
END;
SELECT d FROM
DomainDomain =>
es_ MakeIndexScan[GetDomainIndex[segment]];
RelationDomain =>
es_ MakeIndexScan[GetRelationIndex[segment]];
ENDCASE => ERROR DB.Error[NotImplemented];
RETURN[es];
END;

NCodeAndDefaultLimits: PROC [low, high: ROPE] RETURNS [newLow, newHigh: ROPE] = TRUSTED
BEGIN
IF high=NIL THEN 
IF low=NIL THEN {low_ minfString; high_ infString}
ELSE {low_ NCode[DB.S2V[low]]; high_ low}
ELSE
{low_ NCode[DB.S2V[low]]; high_ NCode[DB.S2V[high]]};
RETURN[low, high]
END;

END.

ΞFile DBModelSystemImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Contents: Initialization of and operations on system tuples
Last modified by:
Eric Bier on: 18-Aug-81 14:48:57
Rick Cattell on: September 14, 1983 4:19 pm
Willie-Sue on February 15, 1985 5:21:28 pm PST
Donahue, September 5, 1985 5:44:56 pm PDT
Widom, September 9, 1985 5:06:58 pm PDT
Value Types
Definitions of system tuple (virtual) tids
The System tuple abstraction
passed to storage level so that proper tuple can be returned when a GetF is done and the tid is < SL.MaxSystemTupleID.
used in DefineSystemRelation and DefineSystemAttribute.
The system-defined domains, relations, and attributes: grouped by domains
Items declared to be Properties are attributes with no relation; we don't need the relation
because it is an internal private binary surrogate relation.  The [binary] relations that the 
client may access require both attributes and the relation entity itself, so that the client
may perform RelationSubset and do a GetP in both directions.
a surrogate relation, equals domain where actually
stored (i.e., equals aTypeEntityProp when non-NIL)
case it equals aTypeProp (i.e., the domain referenced)
The DataType entities
Other global variables, exported to DBModelPrivate:
The following shouldn't go into DB because they might get used before initialized
Define the system domains
Define the DataType atoms
Define the DataType entities
Define (private) properties of domain, relation, attribute, and index entities
dHandle must be first field for proper storage level operation!
rHandle must be first field for proper DBStorage operation!
don't need handle because assume identical pos&size as tupleChangeNameHandle above
handle need not be first field, but make it that way anyway like other system tuples 
iHandle must be first field of Index entity for proper DBStorage operation!
Define the system relations and their attributes
Sets up fake relation so that defaultNameHandle will work.
Must be called after RopeType defined. 
The aType and aLink relations are tricky, to achieve better performance than the
obvious implementation.  They are actually defined on two underlying properties,
the aTypeCodeProp and the aTypeEntityProp, which are surrogate attributes of the
attribute entities.  When we do operations on aType or aLink, we must trap them,
interpreting aTypeCodeProp and aTypeEntityProp as follows:
(1) If aTypeEntityProp=NIL, then we have a non-entity-valued attribute, and the
aTypeCodeProp is the tid of the system DataType entity (e.g., RopeType, IntType).
(2) If aTypeEntityProp#NIL, then it references the domain that is the type of the
attribute, and aTypeCodeProp= 0 or -1 depending on whether it is linked or not linked. 
Operations fetching or setting aType and aLink are trapped in the low-level procedures
GetValFromHandle and SetValFromHandle, so that they do not need to be checked
separately in GetF, SurrogateGetF, GetP, SetF, etc.  The low level procedures have
only the handle for the attribute available, not the attribute itself; they thus must
do equality comparison to the aTypeIs.vHandle or aLinkIs.vHandle; so the handle is needed
merely for its unique pointer value, not for the DBStorage.FieldHandleObject it points to. 
Defines a binary system relation and attributes with types specified by of and is.
The system relation entity is given the tuple id specified, and attributes are allocated ids.
The attributes types are "of" and "is" respectively.  The relation is given the specified name,
and the attributes are given the specified name postfixed by the strings "Of" and "Is".
If is1to1=TRUE, then relation is a "surrogate" relation, and the values are actually stored
as fields of the domain type of "of".
The "is" attribute is actually a field of of's domain, not of the relation
Normal attributes: fields of r.
Defines a system relation. 
Defines a system domain or relation, according to the value of isDomain.  
Used as a subroutine to DefineSystemBinary and DefinePrivateProperty, to define a
field of domain or relation ts with the given name, type, and length if applicable.
add a field to ts to hold values of this type:
Used as a subroutine to DefineSystemField and DefineSystemBinary.
Defines the storage level object for a system field, though doesn't actually create the field.
Use only for DataTypes; creates a system entity object.
Adds an "invisible" new system relation which is actually a surrogate relation stored
as a field of the domain d.  We use this instead of DefineSystemBinary when the client
doesn't actually need access to the relation, so we can just define the field alone.
This proc turns out to be implemented by calling DefineSystemField, but is logically
quite different since we are defining an "attribute" of a domain, not a relation.  We fake
the call by pretending the domain is a relation (they are both TupleSets, the same type).
We add the fake attribute to the vAttributes list on the domain, so it can be used to
optimize SafeGetP and other operations.
Operations on system tuples
Domain d must be DomainDomain or RelationDomain.  We implement an index scan on the
domain or relation index in the given segment, with names in the given range.
Note that there is no tuple set scan possible through domains or relations, because
the storage level provides no links through the system tuples. 
Scans on the AttributeDomain, IndexDomain, and IndexFactorDomain are not currently
implemented.  They must be accessed via system relations instead.
Used by DomainSubset and RelationSubset to default limits on an index search.  The
rules are: (1) if both high and low limits are NIL, the whole index is searched.
(2) if just the high limit is NIL, it defaults to the low limit, (3) any any case, we
must call NCode to convert to all upper case.
Κζ˜š
œ™Jšœ
Οm
œ1™<—Jš
œ;™;š
œ™Jš
œ ™ Jš
œ+™+Jš
œ.™.Icode™)J™'—J˜š
Οk	˜	Jšœžœ˜J˜	J˜
J˜Jšžœ
˜J˜Jšœžœžœ
˜J˜—šœžœ
ž˜ Jšžœ
žœ)˜3Jšžœ˜ J˜—Jšžœ
žœ.˜8˜Jšžœžœžœ
˜J˜Jšœ	žœ˜/J˜Jšœ
žœ
˜—
head1š
œ™J˜J˜	J˜J˜	Jšœ
žœ
˜J˜Jšœžœ
˜—š
œ*™*Jšœžœ
žœ˜Jšœžœ
žœ˜ Jšœžœ
žœ˜!Jšœžœ
žœ˜ Jšœžœ
žœ˜Jšœžœ
žœ˜#J˜Jšœžœ
žœ˜!Jšœžœ
žœ˜Jšœžœ
žœ˜#Jšœ
žœ
žœ˜ Jšœžœ
žœ˜Jšœ
žœ
žœ˜ Jšœžœ
žœ˜"Jšœ
žœ
žœ˜ Jšœžœ
žœ˜*Jšœžœ
žœ˜$Jšœžœ
žœ˜!J˜Jšœ	žœ
žœΟc˜:J˜Jšœžœ
žœ˜Jšœžœ
žœ˜Jšœžœ
žœ˜Jšœžœ
žœ˜Jšœžœ
žœ˜!Jšœžœ
žœ˜$—š
œ™šœžœžœ
žœ
˜4Jš
œv™v—Jšœžœ
žœžœ
žœ
žœ˜Bšœžœ
žœ˜#Jš
œ7™7—Ihead2š
œI™IJš
œ[™[Jš
œ^™^Jš
œ\™\Jš
œ<™<J˜Jšœžœ	Ÿ(˜E˜Jšœ
žœŸ$˜CJšœžœŸ1˜OJ˜šœ
žœŸ5˜PJšœžœŸ˜7JšœžœŸ˜5—J˜—Jšœžœ	Ÿ*˜I˜Jšœ
žœŸ$˜CJšœžœŸ1˜N—J˜Jšœžœ	Ÿ+˜K˜Jšœ
žœŸ*˜IJšœžœŸ3˜TJšœžœŸ9˜\J˜šœžœŸ+˜GJšœ
žœŸ˜/Jšœ
žœŸ˜;J˜—šœžœŸ+˜CJšœ	žœŸ˜+Jšœ	žœŸ&˜AJ˜—šœ
žœŸ+˜IJšœžœŸ˜1JšœžœŸ&˜GJ˜—šœ	žœŸ+˜EJšœžœŸ˜-Jšœžœ
Ÿ*˜HJ˜—šœžœŸ+˜CJšœ	žœŸ˜+Jšœ	žœ
Ÿ%˜AJ˜—šœ	žœŸC˜]JšœžœŸ˜-šœžœ
Ÿ=˜[Jš
œ2™2Jš
œ2™2J˜——šœžœŸC˜_Jšœ
žœŸ˜/šœ
žœ
Ÿ9˜YJš
œ6™6———J˜Jšœžœ
Ÿ:˜ZJ˜J™Jšœfžœ˜tJ˜šœ
žœ
Ÿ'˜DJšœ
žœŸ%˜DJ˜—Jšœžœ
Ÿ(˜K˜šœ	žœŸ<˜WJšœžœ
Ÿ˜1Jšœžœ
Ÿ)˜GJ˜—šœžœŸ˜CJšœžœ
Ÿ˜;Jšœžœ
Ÿ4˜\J˜—šœ
žœŸ˜=Jšœžœ
Ÿ˜5Jšœžœ
Ÿ*˜L——Mš
œ3™3Jšœ<žœ˜YJšœžœ˜'J˜Jšœžœ˜—˜Jš
œQ™QJšœžœŸ˜4JšœžœŸ ˜:—˜šΟnœžœ
žœž˜-Jšžœ,Ÿ˜I˜J˜.J˜Jš
œ™J˜7J˜=J˜@J˜=J˜4J˜FJ˜Jš
œ™Jš
œ˜J˜Jš
œ˜J˜J˜J˜J˜Jš
œ™J˜HJ˜EJš
œG˜GJ˜HJ˜NJ˜QJ˜JšœŸ@˜UJ˜Jš
œN™NJ˜˜#J˜GJš
œ?™?—˜SJ˜!—J˜LJ˜˜#J˜IJš
œ;™;—˜!J˜8Jš
œR™R—J˜DJ˜˜#J˜GJš
œU™U—J˜EJ˜"˜%J˜+—˜'J˜5J˜—˜#J˜CJš
œK™KJ˜—Jš
œ0™0J˜J˜˜:J˜Q—˜@J˜M—˜4J˜E—˜4J˜K—˜:J˜O—˜4J˜L—˜RJ˜[—˜@J˜X—˜7JšœRžœ˜YJ˜——Jšžœ
˜J˜—š œžœ˜Jš
œ:™:Jš
œ'™'Jš
ž˜Jšœ>žœ˜EJ˜cJ˜)J˜+Jšžœ
˜J˜—š œžœ˜#Jš
œP™PJš
œP™PJš
œP™PJš
œP™PJš
œ:™:Jš
œO™OJš
œQ™QJš
œQ™QJš
œW™WJš
œV™VJš
œM™MJš
œR™RJš
œU™UJš
œY™YJš
œ[™[Jš
ž˜˜Jšœ&žœ˜,—Jš
œ@˜@Jš
œ˜Jš
œM˜MJš
œ˜Jšœ Ÿ˜>Jš
œ*˜*Jšœžœ˜)š
œ˜Jšœ&žœ˜,—J˜@Jš
œ˜Jš
œE˜EJš
œ˜Jšœžœ˜)Jš
œ*˜*Jšžœ
˜J˜—š œžœ˜Jšœžœ
žœžœ&žœžœ
˜NJšžœ%˜,Jš
œR™RJš
œ]™]Jš
œ_™_Jš
œW™WJš
œ[™[Jš
œ%™%Jš
ž˜Jš
œ*˜*šžœž˜Jš
œJ™JJš
ž˜Jš
œ.˜.J˜<J˜J˜`J˜Jš
ž˜—š
ž˜Jš
œ™Jš
ž˜J˜FJ˜J˜YJ˜Jšžœ
˜—Jšœžœ˜J˜Jšžœ
˜J˜—š œžœžœ˜BJš
ž˜šžœž˜Jšœžœ˜&Jšœžœ˜*Jšœžœ˜,Jšœžœ˜*Jšœžœ˜$Jšœžœ˜0Jšžœžœ˜"—Jšžœ
˜J˜—š œžœžœ
žœžœ
žœžœ
ž˜cJš
œ™Jš
ž˜Jšœžœ˜"Jš
œ3˜3Jšžœžœ
žœ˜*J˜
J˜J˜Jšœ
žœ
˜J˜Jš
œ6˜6J˜&J˜Jšžœ˜
Jšžœ
˜J˜—š
 œžœžœ
žœžœžœž˜QJš
œJ™JJš
ž˜Jšœžœ˜Jš
œ3˜3Jšžœžœ
žœ˜*J˜
J˜Jšœ
žœ
˜J˜Jš
œ6˜6J˜&J˜Jšžœ˜
Jšžœ
˜J˜—š œžœ
˜Jšœ*žœžœžœž˜qJš
œQ™QJš
œS™SJš
ž˜Jš
œ˜J˜-Jš
œ.™.J˜=Jšžœ˜	Jšžœ
˜J˜—š œžœ
˜Jšœžœžœ!ž˜KJš
œA™AJš
œ^™^Jš
ž˜Jšœžœ˜J˜&J˜+J˜Jšœ
žœ
˜J˜J˜J˜%Jšžœ+žœ
žœ˜IJ˜GJ˜Jšžœ˜Jšžœ
˜J˜—š œžœ
˜Jš
œžœ
žœžœžœž˜DJš
œ7™7Jš
ž˜J˜3J˜
J˜J˜&Jšžœ˜	Jšžœ
˜J˜—š œžœ˜Jšœžœžœžœ
˜KJš
œU™UJš
œV™VJš
œT™TJš
œT™TJš
œZ™ZJš
œY™YJš
œU™UJš
œ'™'Jšžœ˜Jš
œG˜GJš
œ˜Jšœžœ˜0J˜Jšžœ˜Jšžœ
˜——š
œ™š œžœ
žœžœ)žœž˜ˆ
Jš
œS™SJš
œM™MJš
œS™SJš
œ?™?Jš
œR™RJš
œA™Aš
ž˜š 
œžœ%žœž˜TJš
ž˜J˜"J˜>JšœAžœžœ˜VJš
œ˜Jš
œ˜Jšžœ˜Jšžœ
˜—šžœž˜
˜Jš
œ+˜+—˜Jš
œ-˜-—Jšžœžœ˜*—Jšžœ˜Jšžœ
˜—J˜—š œžœ
žœžœžœž˜WJš
œR™RJš
œP™PJš
œU™UJš
œ-™-Jš
ž˜šžœžœ
žœ
˜Jšžœžœ
žœ#˜2Jšžœ%˜)—š
ž˜J˜5—Jšžœ˜Jšžœ
˜——J˜Jšžœ
˜J˜—…—7Z]