DIRECTORY
Basics USING [bitsPerWord],
Imager,
ImagerColor USING [],
ImagerColorDefs USING [Color, ConstantColor, ColorOperator, ColorOperatorRep],
ImagerColorOperator USING [ColorFromPixel, GrayLinearColorModel, GrayVisualColorModel, MapColorModel, PixelProc, RGBLinearColorModel],
ImagerFont,
ImagerPixelArrayDefs USING [PixelArray, PixelArrayClassRep, PixelArrayRep],
ImagerPixelArrayPrivate USING [PixelArrayClass, PixelArrayClassRep],
ImagerSample USING [Sample, UnsafeSamples],
ImagerTransformation USING [Transformation],
IPImager USING [],
IPInterpreter,
PrincOps USING [BitAddress, DstFunc, SrcFunc],
Rope USING [Equal, ROPE],
RuntimeError USING [BoundsFault];

IPImagerImpl: CEDAR PROGRAM
IMPORTS ImagerColorOperator, ImagerFont, IPInterpreter, Rope, RuntimeError
EXPORTS IPImager, ImagerPixelArrayDefs
= BEGIN OPEN IPInterpreter;
ROPE: TYPE ~ Rope.ROPE;
Font: TYPE ~ ImagerFont.Font;
XChar: TYPE ~ ImagerFont.XChar;
XCharProc: TYPE ~ ImagerFont.XCharProc;
XStringProc: TYPE ~ ImagerFont.XStringProc;
Transformation: TYPE ~ ImagerTransformation.Transformation;


MaskChar: PUBLIC PROC [self: Ref, fd: Vector, i: Cardinal] ~ {
characterMasks: Vector ~ VectorFromAny[GetPR[fd, "characterMasks"]];
found: BOOL; value: Any;
[found, value] _ GetPropC[characterMasks, i];
IF found THEN {
maskOp: PROC ~ { Do[self, OperatorFromAny[value]] };
Mark[self, 0];
PushVector[self, fd];
DoSaveAll[self, maskOp];
WHILE Count[self]>0 DO Pop[self] ENDLOOP;
Unmark[self, 0];
};
};

FindFont: PUBLIC PROC [self: Ref, v: Vector] RETURNS [Font] ~ {
name: ROPE ~ NameFromVector[v];
font: Font ~ ImagerFont.Find[name];
RETURN[font];
};


PixelArray: TYPE ~ ImagerPixelArrayDefs.PixelArray;
PixelArrayRep: TYPE ~ ImagerPixelArrayDefs.PixelArrayRep;
Sample: TYPE ~ ImagerSample.Sample;
UnsafeSamples: TYPE ~ ImagerSample.UnsafeSamples;

PixelArrayData: TYPE ~ REF PixelArrayDataRep;
PixelArrayDataRep: TYPE ~ RECORD[
samplesPerLayer: INT,
maxSampleValue: Vector,
maxSampleValueI: Cardinal,
sampleVector: Vector
];

MakePixelArray: PUBLIC PROC [
xPixels, yPixels: Cardinal, -- number of pixels in slow and fast directions
samplesPerPixel: Cardinal, -- number of sample values for each pixel
maxSampleValue: Vector, -- maximum sample value; if NIL, use maxSampleValueI
maxSampleValueI: Cardinal, -- constant maximum sample value, if maxSampleValue=NIL
samplesInterleaved: BOOL, -- if true, samples for one pixel are contiguous
m: Transformation, -- transformation from pixel coordinates to master coordinates
samples: Vector -- the actual samples
] RETURNS [PixelArray] ~ {
sampleShape: VectorShape ~ Shape[samples];
data: PixelArrayData ~ NEW[PixelArrayDataRep];
IF maxSampleValue#NIL THEN {
shape: VectorShape ~ Shape[maxSampleValue];
IF shape.lowerBound#0 OR shape.size#samplesPerPixel THEN ERROR;
maxSampleValueI _ 0;
FOR i: Cardinal IN[0..samplesPerPixel) DO
maxSampleValueI _ MAX[GetCardinal[maxSampleValue, i], maxSampleValueI];
ENDLOOP;
};
IF samplesInterleaved AND samplesPerPixel>1 THEN {
MasterError[$unimplemented, "Not implemented: interleaved samples"];
};
IF sampleShape.lowerBound#0 OR (samplesPerPixel*xPixels*yPixels)#sampleShape.size THEN {
MasterError[$wrongShape, "samples vector has wrong shape for MAKEPIXELARRAY"];
};
data^ _ [
samplesPerLayer: xPixels*yPixels,
maxSampleValue: maxSampleValue,
maxSampleValueI: maxSampleValueI,
sampleVector: samples
];
RETURN[NEW[PixelArrayRep _ [class: IF samples.class.type = $PackedBits THEN pixelArrayBitmapClass ELSE pixelArrayClass, data: data,
sSize: xPixels, fSize: yPixels, samplesPerPixel: samplesPerPixel, m: m]]];
};

PixelArrayClass: TYPE ~ ImagerPixelArrayPrivate.PixelArrayClass;
PixelArrayClassRep: PUBLIC TYPE ~ ImagerPixelArrayPrivate.PixelArrayClassRep;
pixelArrayBitmapClass: PixelArrayClass ~ NEW[PixelArrayClassRep _ [
type: $InterpressBits,
MaxSampleValue: IPMaxSampleValue,
UnsafeGetSamples: IPUnsafeGetSamples,
UnsafeGetBits: IPUnsafeGetBits
]];

pixelArrayClass: PixelArrayClass ~ NEW[PixelArrayClassRep _ [
type: $Interpress,
MaxSampleValue: IPMaxSampleValue,
UnsafeGetSamples: IPUnsafeGetSamples
]];

IPMaxSampleValue: PROC [pa: PixelArray, i: NAT] RETURNS [Sample] ~ {
data: PixelArrayData ~ NARROW[pa.data];
IF i IN[0..pa.samplesPerPixel) THEN {
IF data.maxSampleValue = NIL THEN RETURN [data.maxSampleValueI]
ELSE RETURN [GetCardinal[data.maxSampleValue, i]];
}
ELSE ERROR RuntimeError.BoundsFault;
};

IPUnsafeGetSamples: UNSAFE PROC [pa: PixelArray, i: NAT _ 0, s, f: INT, 
samples: UnsafeSamples, count: NAT] ~ UNCHECKED {
data: PixelArrayData ~ NARROW[pa.data];
layerOffset: INT ~ data.samplesPerLayer*i;
IF i NOT IN[0..pa.samplesPerPixel) THEN ERROR RuntimeError.BoundsFault;
IF s NOT IN[0..pa.sSize) THEN ERROR RuntimeError.BoundsFault;
IF f NOT IN[0..pa.fSize) THEN ERROR RuntimeError.BoundsFault;
IF f+count NOT IN[0..pa.fSize] THEN ERROR RuntimeError.BoundsFault;
UnsafeGetElements[vector: data.sampleVector, buffer: samples, start: layerOffset+s*pa.fSize+f, count: count];
};

bitsPerWord: NAT ~ Basics.bitsPerWord;
IPUnsafeGetBits: UNSAFE PROC [pa: PixelArray, i: NAT _ 0, s, f: INT, 
dst: PrincOps.BitAddress, dstBpl: INTEGER, width, height: CARDINAL, 
srcFunc: PrincOps.SrcFunc _ null, dstFunc: PrincOps.DstFunc _ null] ~ UNCHECKED {
data: PixelArrayData ~ NARROW[pa.data];
layerOffset: INT ~ data.samplesPerLayer*i;
lineIndex: INT _ layerOffset+s*pa.fSize+f;
dstBase: LONG POINTER _ dst.word;
dstBit: NAT _ dst.bit;
delta: NAT ~ dstBpl;
IF i NOT IN[0..pa.samplesPerPixel) THEN ERROR RuntimeError.BoundsFault;
IF s NOT IN[0..pa.sSize) THEN ERROR RuntimeError.BoundsFault;
IF s+height NOT IN[0..pa.sSize] THEN ERROR RuntimeError.BoundsFault;
IF f NOT IN[0..pa.fSize) THEN ERROR RuntimeError.BoundsFault;
IF f+width NOT IN[0..pa.fSize] THEN ERROR RuntimeError.BoundsFault;
THROUGH [0..height) DO
IPInterpreter.UnsafeGetBits[vector: data.sampleVector, dst: [word: dstBase, bit: dstBit], start: lineIndex, count: width, srcFunc: srcFunc, dstFunc: dstFunc];
lineIndex _ lineIndex + pa.fSize;
dstBase _ dstBase + NAT[dstBit + delta] / bitsPerWord;
dstBit _ NAT[dstBit + delta] MOD bitsPerWord;
ENDLOOP;
};

FindDecompressor: PUBLIC PROC [self: Ref, v: Vector] RETURNS [Operator] ~ {
name: ROPE ~ NameFromVector[v];
ERROR;
};

Color: TYPE ~ ImagerColorDefs.Color;
ConstantColor: TYPE ~ ImagerColorDefs.ConstantColor;
ColorOperator: TYPE ~ ImagerColorDefs.ColorOperator;
ColorOperatorRep: TYPE ~ ImagerColorDefs.ColorOperatorRep;

FindColor: PUBLIC PROC [self: Ref, v: Vector] RETURNS [Color] ~ {
name: ROPE ~ NameFromVector[v];
ERROR;
};


ColorOperatorDo: PROC [op: Operator, state: Ref] ~ {
colorOperator: ColorOperator ~ NARROW[op.data];
coords: Vector ~ PopVector[state];
pixel: ImagerColorOperator.PixelProc ~ { RETURN[GetCardinal[coords, i]] };
PushAny[state, ImagerColorOperator.ColorFromPixel[colorOperator, pixel]];
};

colorOperatorClass: OperatorClass ~ NEW[OperatorClassRep _ [
type: $ColorOperator, do: ColorOperatorDo]];


OperatorFromColorOperator: PUBLIC PROC [colorOperator: ColorOperator] 
RETURNS [Operator] ~ {
RETURN[NEW[OperatorRep _ [class: colorOperatorClass, data: colorOperator]]];
};

ColorOperatorFromOperator: PUBLIC PROC [op: Operator] RETURNS [ColorOperator] ~ {
IF op.class.type=$ColorOperator THEN WITH op.data SELECT FROM
colorOp: ColorOperator => RETURN[colorOp]; ENDCASE;
RETURN[NIL];
};

FindColorOperator: PUBLIC PROC [self: Ref, v: Vector] RETURNS [Operator] ~ {
name: ROPE ~ NameFromVector[v];
ERROR;
};



ColorModelOperator: TYPE ~ PROC [parameters: Vector] RETURNS [colorOperator: Operator];

ColorModelOperatorData: TYPE ~ REF ColorModelOperatorDataRep;
ColorModelOperatorDataRep: TYPE ~ RECORD[
name: ROPE,
operator: ColorModelOperator
];

ColorModelOperatorDo: PROC [op: Operator, state: Ref] ~ {
data: ColorModelOperatorData ~ NARROW[op.data];
parameters: Vector ~ PopVector[state];
PushOperator[state, data.operator[parameters]];
};

colorModelOperatorClass: OperatorClass ~ NEW[OperatorClassRep _ [
type: $ColorModelOperator, do: ColorModelOperatorDo]];

FindColorModelOperator: PUBLIC PROC [self: Ref, v: Vector] RETURNS [Operator] ~ {
name: ROPE ~ NameFromVector[v];
data: ColorModelOperatorData ~ NEW[ColorModelOperatorDataRep _ [
name: name, operator: NIL]];
SELECT TRUE FROM
Rope.Equal[name, "Xerox/grayLinear", FALSE] => data.operator _ XeroxGrayLinear;
Rope.Equal[name, "Xerox/grayVisual", FALSE] => data.operator _ XeroxGrayVisual;
Rope.Equal[name, "Xerox/Research/RGBLinear", FALSE] => data.operator _ XeroxResearchRGBLinear;
Rope.Equal[name, "Xerox/Map", FALSE] => data.operator _ XeroxMap;
ENDCASE;
IF data.operator=NIL THEN ERROR;
RETURN[NEW[OperatorRep _ [class: colorModelOperatorClass, data: data]]];
};

CheckSize: PROC [v: Vector, size: Cardinal] ~ {
shape: VectorShape ~ Shape[v];
IF shape.lowerBound=0 AND shape.size=size THEN RETURN;
ERROR;
};

GetPixelMap: PROC [parameters: Vector, i: Cardinal] RETURNS [Vector] ~ {
x: Any ~ Get[parameters, i];
IF Type[x]=number AND RealFromAny[x]=0 THEN RETURN[NIL]
ELSE {
pixelMap: Vector ~ VectorFromAny[x];
shape: VectorShape ~ Shape[pixelMap];
IF shape.lowerBound#0 THEN ERROR;
RETURN[pixelMap];
};
};

XeroxGrayLinear: PROC [parameters: Vector] RETURNS [Operator] ~ {
colorOp: ColorOperator _ NIL;
sWhite: REAL ~ GetReal[parameters, 0];
sBlack: REAL ~ GetReal[parameters, 1];
pixelMap: Vector ~ GetPixelMap[parameters, 2];
mapSize: CARDINAL ~ IF pixelMap#NIL THEN Shape[pixelMap].size-1 ELSE 0;
mapProc: PROC [i: CARDINAL] RETURNS [REAL] ~ { RETURN[GetReal[pixelMap, i]] };
CheckSize[parameters, 3];
colorOp _ ImagerColorOperator.GrayLinearColorModel[sWhite: sWhite, sBlack: sBlack,
maxSampleValue: mapSize, sampleMap: mapProc];
RETURN[OperatorFromColorOperator[colorOp]];
};

XeroxGrayVisual: PROC [parameters: Vector] RETURNS [Operator] ~ {
colorOp: ColorOperator _ NIL;
sWhite: REAL ~ GetReal[parameters, 0];
sBlack: REAL ~ GetReal[parameters, 1];
pixelMap: Vector ~ GetPixelMap[parameters, 2];
mapSize: CARDINAL ~ IF pixelMap#NIL THEN Shape[pixelMap].size-1 ELSE 0;
mapProc: PROC [i: CARDINAL] RETURNS [REAL] ~ { RETURN[GetReal[pixelMap, i]] };
CheckSize[parameters, 3];
colorOp _ ImagerColorOperator.GrayVisualColorModel[sWhite: sWhite, sBlack: sBlack,
maxSampleValue: mapSize, sampleMap: mapProc];
RETURN[OperatorFromColorOperator[colorOp]];
};

XeroxResearchRGBLinear: PROC [parameters: Vector] RETURNS [Operator] ~ {
maxSampleValue: Cardinal ~ GetCardinal[parameters, 0];
colorOp: ColorOperator _ ImagerColorOperator.RGBLinearColorModel[maxSampleValue];
RETURN[OperatorFromColorOperator[colorOp]];
};

XeroxMap: PROC [parameters: Vector] RETURNS [Operator] ~ {
maxSampleValue: Cardinal ~ Shape[parameters].size-1;
map: PROC [s: CARDINAL] RETURNS [ConstantColor] ~ {RETURN [NARROW[Get[parameters, s]]]};
colorOp: ColorOperator ~ ImagerColorOperator.MapColorModel[maxSampleValue, map];
RETURN[OperatorFromColorOperator[colorOp]];
};


END.
ϊIPImagerImpl.mesa
Copyright c 1984, 1985, 1986 by Xerox Corporation.  All rights reserved.
Michael Plass, July 23, 1985 2:15:57 pm PDT
Doug Wyatt, November 6, 1986 6:44:14 pm PST


I did not find these until after I implemented them in another way - mfp
LargeVectorData: TYPE ~ REF LargeVectorDataRep;
LargeVectorDataRep: TYPE ~ RECORD[
file: FS.OpenFile,
start, length: INT,
bytesPerElement: NAT,
elements: INT
];

largeVectorClass: VectorClass ~ NEW[VectorClassRep _ [type: $LargeVector, 
shape: LargeVectorShape, get: LargeVectorGet]];

LargeVectorShape: PROC [v: Vector] RETURNS [VectorShape] ~ {
data: LargeVectorData ~ NARROW[v.data];
RETURN[[lowerBound: 0, size: data.elements]];
};

LargeVectorGet: PROC [v: Vector, i: Cardinal] RETURNS [x: Any _ NIL] ~ {
data: LargeVectorData ~ NARROW[v.data];
MasterError[$unimplemented, "Get is unimplemented for a largeVector"];
RETURN[NIL];
IF i IN[0..data.elements) THEN {
bytesPerElement: NAT ~ data.bytesPerElement;
stream: STREAM ~ FS.StreamFromOpenFile[data.file];
IO.SetIndex[stream, data.start+i*bytesPerElement];
IF bytesPerElement<=4 THEN {
value: INT ~ IPMaster.GetSigned[stream, bytesPerElement];
x _ NumberFromInt[value];
}
ELSE {
value: REAL ~ IPMaster.GetCardinal[stream, bytesPerElement];
x _ NumberFromReal[value];
};
IO.Close[stream];
}
ELSE ERROR RuntimeError.BoundsFault;
};

MakeLargeVector: PUBLIC PROC [
stream: STREAM, 
length: INT, 
bytesPerElement: NAT
] RETURNS [Vector] ~ {
start: INT ~ IO.GetIndex[stream];
IPMaster.SkipBytes[stream, length];
IF bytesPerElement#0 AND (length MOD bytesPerElement)=0 THEN {
file: FS.OpenFile ~ FS.OpenFileFromStream[stream];
data: LargeVectorData ~ NEW[LargeVectorDataRep _ [file: file, 
start: start, length: length, bytesPerElement: bytesPerElement, 
elements: length/bytesPerElement]];
RETURN[NEW[VectorRep _ [class: largeVectorClass, data: data]]];
}
ELSE ERROR;
};

constant maximum sample value, if maxSampleValue=NIL, or max, maxSampleValue#NIL

Colors, Color Operators

Color Model Operators
Rope.Equal[name, "Xerox/grayDensity", FALSE] => data.operator _ XeroxGrayDensity;
Rope.Equal[name, "standard/buildMap", FALSE] => op _ xxx;
Rope.Equal[name, "standard/separations", FALSE] => op _ xxx;
XeroxGrayDensity: PROC [parameters: Vector] RETURNS [Operator] ~ {
colorOp: ImagerColor.ColorOperator _ NIL;
sWhite: REAL ~ GetReal[parameters, 0];
sBlack: REAL ~ GetReal[parameters, 1];
dBlack: REAL ~ GetReal[parameters, 2];
pixelMap: Vector ~ GetPixelMap[parameters, 3];
mapSize: CARDINAL ~ IF pixelMap#NIL THEN Shape[pixelMap].size ELSE 0;
mapProc: PROC [i: CARDINAL] RETURNS [REAL] ~ { RETURN[GetReal[pixelMap, i]] };
CheckSize[parameters, 4];
colorOp _ ImagerColor.GrayDensityOp[
sWhite: sWhite, sBlack: sBlack, dWhite: dWhite, dBlack: dBlack];
RETURN[OperatorFromColorOperator[colorOp]];
};

MapColorModelOperator: PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
shape: VectorShape ~ Shape[v];
IF shape.lowerBound=0 AND shape.size=1 THEN {
map: Vector ~ VectorFromAny[Get[v, 0]];
PushOperator[self, OperatorFromColorOperator[colorOp]];
};
ERROR;
};

SeparationsColorModelOperator: PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
shape: VectorShape ~ Shape[v];
IF shape.lowerBound=0 THEN {
samplesPerPixel: Cardinal ~ shape.size;
op: REF ColorOperatorRep.separations ~ NEW[ColorOperatorRep.separations[samplesPerPixel]];
FOR i: Cardinal IN[0..samplesPerPixel) DO
s: Vector ~ VectorFromAny[Get[v, i]];
sh: VectorShape ~ Shape[s];
IF sh.lowerBound=0 AND sh.size=6 THEN {
X: REAL ~ GetReal[s, 0];
Y: REAL ~ GetReal[s, 1];
Z: REAL ~ GetReal[s, 2];
sMax: REAL ~ GetReal[s, 3];
sMin: REAL ~ GetReal[s, 4];
map: SampleMap ~ GetSampleMap[s, 5];
op[i] _ NEW[SeparationRep _ [cie: [X, Y, Z], sMax: sMax, sMin: sMin, map: map]];
}
ELSE ERROR;
ENDLOOP;
PushOperator[self, OperatorFromColorOperator[op]];
}
ELSE ERROR;
};

ΚŸ˜
codeš
œ™Kšœ
Οm
œ=™HK™+Kš
œ+™+—K™š
Οk	˜	Kšœžœ˜Kš
œ˜Kšœžœ˜Kšœžœ9˜NKšœžœm˜†
Kš
œ˜Kšœžœ1˜KKšœžœ'˜DKšœ
žœ˜+Kšœžœ˜,Kšœ	žœ˜Kš
œ˜Kšœ	žœ ˜.Kšœžœ	žœ˜Kšœ
žœ˜!—K˜KšΠblœžœ
ž˜KšžœC˜JKšžœ˜&Kšœžœ
žœ˜K™Kšžœžœžœ
˜Kšœžœ˜Kšœžœ˜Kšœžœ˜'Kšœ
žœ˜+Kšœžœ'˜;K˜K˜šΟnœžœ
žœ)˜>K˜DKšœžœ
˜K˜-šžœžœ˜Kšœžœ(˜4K˜K˜Kš
œ˜Kšžœžœžœ
˜)K˜K˜—K˜K˜—š œžœ
žœžœ˜?Kšœžœ˜Kš
œ#˜#Kšžœ˜
K˜K˜—K˜™HKš
Οs/™/š
‘"™"Kš
‘™Kš
‘™Kš
‘™Kš
‘
™
Kš
‘™—K™Kš
‘z™zK™š
‘<™<Kš
‘'™'Kš
‘-™-Kš
‘™K™—š
‘H™HKš
‘'™'Kš
‘F™FKš
‘™š
‘ ™ Kš
‘,™,Kš
‘2™2Kš
‘2™2š
‘™Kš
‘9™9Kš
‘™Kš
‘
™
—š
‘™Kš
‘<™<Kš
‘™Kš
‘™—Kš
‘™Kš
‘
™
—Kš
‘$™$Kš
‘™K™—š
‘i™iKš
‘!™!Kš
‘#™#š
‘>™>Kš
‘2™2Kš
‘£
™£
Kš
‘?™?Kš
‘
™
—Kš
‘™Kš
‘™K™——Kšœžœ#˜3Kšœžœ&˜9Kšœžœ˜#Kšœžœ˜1K˜Kšœžœžœ˜-šœžœžœ
˜!Kšœžœ
˜Kš
œ˜š
œ˜Kšœ1žœž™P—Kš
œ˜K˜K˜—š œžœ
žœΟc0œ’*œ’5œ’8œžœ’1œ’?œ’œžœ˜¬Kš
œ*˜*Kšœžœ˜.šžœžœ
žœ˜Kš
œ+˜+Kšžœžœžœ
žœ
˜?Kš
œ˜šžœ
žœž˜)Kšœžœ2˜GKšžœ
˜—Kš
œ˜—šžœžœžœ˜2Kš
œD˜DKš
œ˜—šžœžœ4žœ˜XKš
œN˜NKš
œ˜—š
œ	˜	Kš
œ!˜!Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ˜—Kš
žœ
žœžœ"žœžœh˜Ξ
K˜K˜—Kšœžœ+˜@Kšœžœ
žœ.˜Mšœ)žœ˜CK˜Kš
œ!˜!Kš
œ%˜%Kš
œ˜Kš
œ˜K˜—šœ#žœ˜=K˜Kš
œ!˜!Kš
œ$˜$Kš
œ˜K˜—š œžœžœžœ
˜DJšœžœ
˜'šžœžœžœ˜%Kšžœžœ
žœ
žœ˜?Kšžœ
žœ'˜2K˜
—Kšžœ
žœ˜$K˜K˜—š œžœ
žœžœžœ"žœž	œ˜zJšœžœ
˜'Kšœ
žœ˜*Kš
žœžœ
žœžœ
žœ˜GKš
žœžœ
žœžœ
žœ˜=Kš
žœžœ
žœžœ
žœ˜=Kš
žœ	žœ
žœžœ
žœ˜CKš
œm˜mK˜K˜—Kšœ
žœ˜&š œžœ
žœžœžœ%žœžœIž	œ˜ά
Kšœžœ
˜'Kšœ
žœ˜*Kšœžœ˜*Kšœ	žœ
žœ˜!Kšœžœ˜Kšœžœ
˜Kš
žœžœ
žœžœ
žœ˜GKš
žœžœ
žœžœ
žœ˜=Kš
žœ
žœ
žœžœ
žœ˜DKš
žœžœ
žœžœ
žœ˜=Kš
žœ	žœ
žœžœ
žœ˜Cšžœ
ž˜Kš
œž
˜ž
Kš
œ!˜!Kšœžœ˜6Kšœ	žœžœ
˜-Kšžœ
˜—K˜K˜—š œžœ
žœžœ˜KKšœžœ˜Kšžœ
˜Kš
œ˜K˜—K™K™K™Kšœžœ˜$Kšœžœ!˜4Kšœžœ!˜4Kšœžœ$˜:K˜š 	œžœ
žœžœ˜AKšœžœ˜Kšžœ
˜K˜K˜—K˜š œžœ˜4Kšœžœ
˜/K˜"Kšœ)žœ˜JKš
œI˜IK˜K˜—šœ$žœB˜iK˜—K˜š œžœ
žœ žœ˜]Kšžœ
žœB˜LK˜K˜—š œžœ
žœžœ˜Qš	žœžœ
žœ	žœ
ž˜=Kšœžœžœ
˜3—Kšžœ
žœ˜K˜K˜—š œžœ
žœžœ˜LKšœžœ˜Kšžœ
˜K˜K˜—K˜K™K˜Kšœžœžœžœ˜WK˜Kšœžœžœ˜=šœžœžœ
˜)Kšœžœ
˜Kš
œ˜K˜K˜—š œžœ˜9Kšœžœ
˜/K˜&Kš
œ/˜/K˜K˜—šœ)žœL˜xK˜—š œžœ
žœžœ˜QKšœžœ˜Kšœžœ5žœ˜]šžœ
žœ
ž˜Kšœ%žœ%˜OKšœ&žœ&™QKšœ%žœ%˜OKšœ-žœ,˜^Kš
œA˜AKš
œ9™9Kš
œ<™<Kšžœ
˜—Kšžœžœ
žœ
žœ
˜ Kšžœ
žœ>˜HK˜K˜—š 	œžœ ˜/K˜Kšžœžœžœ
žœ
˜6Kšžœ
˜K˜K˜—š œžœ#žœ
˜HK˜Kš
žœžœžœ
žœ
žœ
˜7šžœ˜K˜$K˜%Kšžœžœ
žœ
˜!Kšžœ˜K˜—K˜K˜—š œžœžœ˜AKšœžœ
˜Kšœžœ˜&Kšœžœ˜&Kš
œ.˜.Kšœ	žœžœ
žœ
žœžœ˜GKšœ	žœžœžœžœžœ˜NKš
œ˜Kš
œ€
˜€
Kšžœ%˜+K˜K˜—š œžœžœ™BKšœ%žœ
™)Kšœžœ™&Kšœžœ™&Kšœžœ™&Kš
œ.™.Kšœ	žœžœ
žœ
žœžœ™EKšœ	žœžœžœžœžœ™NKš
œ™Kš
œe™eKšžœ%™+K™K™—š œžœžœ˜AKšœžœ
˜Kšœžœ˜&Kšœžœ˜&Kš
œ.˜.Kšœ	žœžœ
žœ
žœžœ˜GKšœ	žœžœžœžœžœ˜NKš
œ˜Kš
œ€
˜€
Kšžœ%˜+K˜K˜—š œžœžœ˜HKš
œ6˜6Kš
œQ˜QKšžœ%˜+K˜K˜—š œžœžœ˜:Kš
œ4˜4Kšœžœžœžœžœžœ˜XKš
œP˜PKšžœ%˜+K˜K˜—š œžœ™+Kš
œ™K™šžœžœžœ™-Kš
œ'™'Kš
œ7™7K™—Kšžœ
™K™K™—š œžœ™3Kš
œ™K™šžœžœ™K™'Kšœžœ žœ0™Zšžœ
žœž™)Kš
œ%™%K™šžœžœžœ™'Kšž
œžœ™Kšž
œžœ™Kšž
œžœ™Kšœžœ™Kšœžœ™K™$Kš	œžœž
œž
œž
œ&™PK™
—Kšžœ
žœ
™Kšžœ
™—Kš
œ2™2K™
—Kšžœ
žœ
™K™K™—K˜Kšžœ
˜—…—*RGλ