DIRECTORY
Basics USING [BITSHIFT, BoundsCheck, NonNegative],
ImagerPixelArray USING [ErrorDesc, maxCount, maxVec, PixelArray, PixelArrayRep, zeroVec],
ImagerPixelArrayPrivate USING [CopyProc, GetProc, GetSamplesProc, MaxSampleValueProc, PixelArrayClass, PixelArrayClassRep, TransferProc],
ImagerSample USING [CopyMap, DoWithScratchMap, DoWithScratchSamples, Function, Get, GetSamples, maxBitsPerSample, nullFunction, PixelBuffer, PixelMap, PixelMapRep, Put, PutSamples, Sample, SampleBuffer, SampleMap, Transfer],
ImagerTransformation USING [Equal, ScanMode, SFToXY, Transformation],
SF USING [Min, Sub, Vec];

ImagerPixelArrayImpl: CEDAR PROGRAM
IMPORTS Basics, ImagerSample, ImagerTransformation, SF
EXPORTS ImagerPixelArray, ImagerPixelArrayPrivate
~ BEGIN OPEN ImagerPixelArrayPrivate, ImagerPixelArray;

Vec: TYPE ~ SF.Vec;
Transformation: TYPE ~ ImagerTransformation.Transformation;
ScanMode: TYPE ~ ImagerTransformation.ScanMode;
Sample: TYPE ~ ImagerSample.Sample;
SampleBuffer: TYPE ~ ImagerSample.SampleBuffer;
PixelBuffer: TYPE ~ ImagerSample.PixelBuffer;
SampleMap: TYPE ~ ImagerSample.SampleMap;
PixelMap: TYPE ~ ImagerSample.PixelMap;
PixelMapRep: TYPE ~ ImagerSample.PixelMapRep;
Function: TYPE ~ ImagerSample.Function;
nullFunction: Function ~ ImagerSample.nullFunction;

PixelArrayClass: TYPE ~ ImagerPixelArrayPrivate.PixelArrayClass;
PixelArrayClassRep: PUBLIC TYPE ~ ImagerPixelArrayPrivate.PixelArrayClassRep;

Error: PUBLIC ERROR [error: ErrorDesc] ~ CODE;

GetClass: PUBLIC PROC [self: PixelArray] RETURNS [ATOM] ~ {
class: PixelArrayClass ~ self.class;
RETURN[class.type];
};

MaxSampleValue: PUBLIC PROC [self: PixelArray, i: NAT] RETURNS [Sample] ~ {
class: PixelArrayClass ~ self.class;
RETURN class.MaxSampleValue[self: self, i: Basics.BoundsCheck[i, self.samplesPerPixel]];
};

Get: PUBLIC PROC [self: PixelArray, i: NAT, s, f: INT] RETURNS [Sample] ~ {
class: PixelArrayClass ~ self.class;
iCheck: NAT ~ Basics.BoundsCheck[i, self.samplesPerPixel];
sRem: INT ~ Basics.NonNegative[self.sSize-Basics.NonNegative[s]];
fRem: INT ~ Basics.NonNegative[self.fSize-Basics.NonNegative[f]];
[] _ Basics.NonNegative[sRem-1];
[] _ Basics.NonNegative[fRem-1];
RETURN class.Get[self: self, i: i, s: s, f: f];
};

GetSamples: PUBLIC PROC [self: PixelArray, i: NAT _ 0, s, f: INT _ 0, 
samples: SampleBuffer, start: NAT _ 0, count: NAT _ maxCount] ~ {
class: PixelArrayClass ~ self.class;
iCheck: NAT ~ Basics.BoundsCheck[i, self.samplesPerPixel];
sRem: INT ~ Basics.NonNegative[self.sSize-Basics.NonNegative[s]];
fRem: INT ~ Basics.NonNegative[self.fSize-Basics.NonNegative[f]];
actualCount: NAT ~ MIN[samples.length-start, count];
[] _ Basics.NonNegative[sRem-1];
[] _ Basics.NonNegative[fRem-actualCount];
class.GetSamples[self: self, i: i, s: s, f: f, samples: samples, start: start, count: actualCount];
};

GetPixels: PUBLIC PROC [self: PixelArray, s, f: INT _ 0, 
pixels: PixelBuffer, start: NAT _ 0, count: NAT _ maxCount] ~ {
FOR i: NAT IN[0..self.samplesPerPixel) DO
GetSamples[self, i, s, f, pixels[i], start, count]
ENDLOOP
};

Transfer: PUBLIC PROC [self: PixelArray, i: NAT _ 0, s, f: INT _ 0, 
dst: SampleMap, dstMin: Vec _ zeroVec, size: Vec _ maxVec,
function: Function _ nullFunction] ~ {
class: PixelArrayClass ~ self.class;
iCheck: NAT ~ Basics.BoundsCheck[i, self.samplesPerPixel];
sRem: INT ~ Basics.NonNegative[self.sSize-Basics.NonNegative[s]];
fRem: INT ~ Basics.NonNegative[self.fSize-Basics.NonNegative[f]];
actualSize: Vec _ dst.size.Sub[dstMin].Min[size];
IF sRem<actualSize.s THEN actualSize.s _ sRem;
IF fRem<actualSize.f THEN actualSize.f _ fRem;
class.Transfer[self: self, i: i, s: s, f: f, 
dst: dst, dstMin: dstMin, size: actualSize, function: function];
};

Copy: PUBLIC PROC [self: PixelArray] RETURNS [PixelArray] ~ {
IF self.immutable THEN RETURN[self]
ELSE {
class: PixelArrayClass ~ self.class;
IF class.Copy#NIL THEN RETURN[class.Copy[self]]
ELSE ERROR Error[[code: $unimplemented, explanation: "Copy is unimplemented"]];
};
}; 


GetViaGetSamples: PROC [self: PixelArray, i: NAT, s, f: INT] RETURNS [Sample] ~ {
class: PixelArrayClass ~ self.class;
value: Sample _ 0;
action: PROC [samples: SampleBuffer] ~ {
class.GetSamples[self: self, i: i, s: s, f: f, samples: samples, start: 0, count: 1];
value _ samples[0];
};
ImagerSample.DoWithScratchSamples[1, action];
RETURN[value];
};

GetViaTransfer: PROC [self: PixelArray, i: NAT, s, f: INT] RETURNS [Sample] ~ {
class: PixelArrayClass ~ self.class;
value: Sample _ 0;
action: PROC [map: SampleMap] ~ {
class.Transfer[self: self, i: i, s: s, f: f, dst: map, dstMin: [0, 0], size: [1, 1], 
function: [null, null]];
value _ ImagerSample.Get[self: map, index: [0, 0]];
};
ImagerSample.DoWithScratchMap[[1, 1], ImagerSample.maxBitsPerSample, action];
RETURN[value];
};

GetSamplesViaGet: PROC [self: PixelArray, i: NAT, s, f: INT, 
samples: SampleBuffer, start: NAT, count: NAT] ~ {
class: PixelArrayClass ~ self.class;
FOR k: NAT IN[0..count) DO
samples[start+k] _ class.Get[self: self, i: i, s: s, f: f+k];
ENDLOOP;
};

GetSamplesViaTransfer: PROC [self: PixelArray, i: NAT, s, f: INT, 
samples: SampleBuffer, start: NAT, count: NAT] ~ {
class: PixelArrayClass ~ self.class;
action: PROC [map: SampleMap] ~ {
class.Transfer[self: self, i: i, s: s, f: f, dst: map, dstMin: [0, 0], size: map.size, 
function: [null, null]];
map.GetSamples[samples: samples, start: start, count: count];
};
ImagerSample.DoWithScratchMap[[s: 1, f: count], ImagerSample.maxBitsPerSample, action];
};

TransferViaGet: PROC [self: PixelArray, i: NAT, s, f: INT, 
dst: SampleMap, dstMin: Vec, size: Vec, function: Function] ~ {
class: PixelArrayClass ~ self.class;
FOR ks: NAT IN[0..size.s) DO
FOR kf: NAT IN[0..size.f) DO
value: Sample ~ class.Get[self: self, i: i, s: s+ks, f: f+kf];
dst.Put[index: [s: dstMin.s+ks, f: dstMin.f+kf], value: value, function: function];
ENDLOOP;
ENDLOOP;
};

TransferViaGetSamples: PROC [self: PixelArray, i: NAT, s, f: INT, 
dst: SampleMap, dstMin: Vec, size: Vec, function: Function] ~ {
class: PixelArrayClass ~ self.class;
action: PROC [samples: SampleBuffer] ~ {
FOR k: NAT IN[0..size.s) DO
class.GetSamples[self: self, i: i, s: s+k, f: f, samples: samples, start: 0, count: size.f];
dst.PutSamples[min: [s: dstMin.s+k, f: dstMin.f], delta: [s: 0, f: 1],
samples: samples, function: function];
ENDLOOP;
};
ImagerSample.DoWithScratchSamples[size.f, action];
};

NewClass: PUBLIC PROC [type: ATOM, 
MaxSampleValue: MaxSampleValueProc, 
Get: GetProc _ NIL, 
GetSamples: GetSamplesProc _ NIL, 
Transfer: TransferProc _ NIL, 
Copy: CopyProc _ NIL
] RETURNS [PixelArrayClass] ~ {
class: PixelArrayClass ~ NEW[PixelArrayClassRep _ [
type: type,
MaxSampleValue: MaxSampleValue,
Get: Get,
GetSamples: GetSamples,
Transfer: Transfer,
Copy: Copy
]];
IF Get=NIL THEN SELECT TRUE FROM
GetSamples#NIL => class.Get _ GetViaGetSamples;
Transfer#NIL => class.Get _ GetViaTransfer;
ENDCASE;
IF GetSamples=NIL THEN SELECT TRUE FROM
Transfer#NIL => class.GetSamples _ GetSamplesViaTransfer;
Get#NIL => class.GetSamples _ GetSamplesViaGet;
ENDCASE;
IF Transfer=NIL THEN SELECT TRUE FROM
GetSamples#NIL => class.Transfer _ TransferViaGetSamples;
Get#NIL => class.Transfer _ TransferViaGet;
ENDCASE;
RETURN[class];
};

New: PUBLIC PROC [class: PixelArrayClass, data: REF, immutable: BOOL,
samplesPerPixel: NAT, sSize, fSize: INT, m: Transformation
] RETURNS [PixelArray] ~ {
RETURN[NEW[PixelArrayRep _ [immutable: immutable, samplesPerPixel: samplesPerPixel, 
sSize: Basics.NonNegative[sSize], fSize: Basics.NonNegative[fSize], 
m: m, class: class, data: data]]];
};


Layer: TYPE ~ RECORD [base: PixelArray, i: NAT];

extractedClass: PixelArrayClass ~ NewClass[
type: $Extracted, 
MaxSampleValue: ExtractedMaxSampleValue, 
Get: ExtractedGet,
GetSamples: ExtractedGetSamples,
Transfer: ExtractedTransfer
];

ExtractedData: TYPE ~ REF ExtractedDataRep;
ExtractedDataRep: TYPE ~ RECORD [
base: PixelArray,
select: SEQUENCE samplesPerPixel: NAT OF NAT
];

ExtractedLayer: PROC [data: ExtractedData, i: NAT] RETURNS [Layer] ~ {
RETURN[[base: data.base, i: data.select[i]]];
}; 

ExtractedMaxSampleValue: MaxSampleValueProc ~ {
data: ExtractedData ~ NARROW[self.data];
layer: Layer ~ ExtractedLayer[data, i];
class: PixelArrayClass ~ layer.base.class;
RETURN class.MaxSampleValue[self: layer.base, i: layer.i];
};

ExtractedGet: GetProc ~ {
data: ExtractedData ~ NARROW[self.data];
layer: Layer ~ ExtractedLayer[data, i];
class: PixelArrayClass ~ layer.base.class;
RETURN class.Get[self: layer.base, i: layer.i, s: s, f: f];
};

ExtractedGetSamples: GetSamplesProc ~ {
data: ExtractedData ~ NARROW[self.data];
layer: Layer ~ ExtractedLayer[data, i];
class: PixelArrayClass ~ layer.base.class;
class.GetSamples[self: layer.base, i: layer.i, 
s: s, f: f, samples: samples, start: start, count: count];
};

ExtractedTransfer: TransferProc ~ {
data: ExtractedData ~ NARROW[self.data];
layer: Layer ~ ExtractedLayer[data, i];
class: PixelArrayClass ~ layer.base.class;
class.Transfer[self: layer.base, i: layer.i, 
s: s, f: f, dst: dst, dstMin: dstMin, size: size, function: function];
};

Extract: PUBLIC PROC [old: PixelArray, samplesPerPixel: NAT, select: PROC [NAT] RETURNS [NAT]] 
RETURNS [new: PixelArray] ~ {
data: ExtractedData ~ NEW[ExtractedDataRep[samplesPerPixel] _ [base: old, select: ]];
FOR i: NAT IN [0..data.samplesPerPixel) DO
data.select[i] _ Basics.BoundsCheck[select[i], old.samplesPerPixel];
ENDLOOP;
RETURN[New[class: extractedClass, data: data, immutable: old.immutable,
samplesPerPixel: samplesPerPixel, sSize: old.sSize, fSize: old.fSize, m: old.m]];
};


joinedClass: PixelArrayClass ~ NewClass[
type: $Joined, 
MaxSampleValue: JoinedMaxSampleValue, 
Get: JoinedGet,
GetSamples: JoinedGetSamples,
Transfer: JoinedTransfer
];

JoinedData: TYPE ~ LIST OF PixelArray;

JoinedLayer: PROC [data: JoinedData, i: NAT] RETURNS [Layer] ~ {
FOR each: LIST OF PixelArray _ data, each.rest UNTIL each=NIL DO
base: PixelArray ~ each.first;
IF i<base.samplesPerPixel THEN RETURN[[base: base, i: i]]
ELSE i _ i-base.samplesPerPixel;
ENDLOOP;
ERROR; -- pa.samplesPerPixel was wrong?
}; 

JoinedMaxSampleValue: MaxSampleValueProc ~ {
data: JoinedData ~ NARROW[self.data];
layer: Layer ~ JoinedLayer[data, i];
class: PixelArrayClass ~ layer.base.class;
RETURN class.MaxSampleValue[self: layer.base, i: layer.i];
};

JoinedGet: GetProc ~ {
data: JoinedData ~ NARROW[self.data];
layer: Layer ~ JoinedLayer[data, i];
class: PixelArrayClass ~ layer.base.class;
RETURN class.Get[self: layer.base, i: layer.i, s: s, f: f];
};

JoinedGetSamples: GetSamplesProc ~ {
data: JoinedData ~ NARROW[self.data];
layer: Layer ~ JoinedLayer[data, i];
class: PixelArrayClass ~ layer.base.class;
class.GetSamples[self: layer.base, i: layer.i, 
s: s, f: f, samples: samples, start: start, count: count];
};

JoinedTransfer: TransferProc ~ {
data: JoinedData ~ NARROW[self.data];
layer: Layer ~ JoinedLayer[data, i];
class: PixelArrayClass ~ layer.base.class;
class.Transfer[self: layer.base, i: layer.i, 
s: s, f: f, dst: dst, dstMin: dstMin, size: size, function: function];
};

Join: PUBLIC PROC [list: LIST OF PixelArray] RETURNS [PixelArray] ~ {
immutable: BOOL _ TRUE;
samplesPerPixel: NAT _ 0;
sSize, fSize: INT _ 0;
m: Transformation _ NIL;
FOR each: LIST OF PixelArray _ list, each.rest UNTIL each=NIL DO
pa: PixelArray ~ each.first;
immutable _ immutable AND pa.immutable;
samplesPerPixel _ samplesPerPixel+pa.samplesPerPixel;
IF each=list THEN { sSize _ pa.sSize; fSize _ pa.fSize; m _ pa.m } -- first one
ELSE {
IF NOT(pa.sSize=sSize AND pa.fSize=fSize) THEN ERROR Error[[
code: $incompatibleJoin, explanation: "Sizes do not match"]];
IF NOT pa.m.Equal[m] THEN ERROR Error[[
code: $incompatibleJoin, explanation: "Transformations do not match"]];
};
ENDLOOP;
RETURN[New[class: joinedClass, data: list, immutable: immutable,
samplesPerPixel: samplesPerPixel, sSize: sSize, fSize: fSize, m: m]];
};
Join3: PUBLIC PROC [pa1, pa2, pa3: PixelArray] RETURNS [PixelArray] ~ {
RETURN[Join[LIST[pa1, pa2, pa3]]];
};


pixelMapClass: PixelArrayClass ~ NewClass[
type: $PixelMap, 
MaxSampleValue: PixelMapMaxSampleValue, 
Get: PixelMapGet,
GetSamples: PixelMapGetSamples,
Transfer: PixelMapTransfer,
Copy: PixelMapCopy
];

PixelMapData: TYPE ~ PixelMap;

PixelMapMaxSampleValue: MaxSampleValueProc ~ {
data: PixelMapData ~ NARROW[self.data];
map: SampleMap ~ data[i];
RETURN[Basics.BITSHIFT[1, map.bitsPerSample]-1];
};

PixelMapGet: GetProc ~ {
data: PixelMapData ~ NARROW[self.data];
map: SampleMap ~ data[i];
index: Vec ~ [s: s, f: f];
RETURN[map.Get[index]];
};

PixelMapGetSamples: GetSamplesProc ~ {
data: PixelMapData ~ NARROW[self.data];
map: SampleMap ~ data[i];
index: Vec ~ [s: s, f: f];
map.GetSamples[min: index, samples: samples, start: start, count: count];
};

PixelMapTransfer: TransferProc ~ {
data: PixelMapData ~ NARROW[self.data];
map: SampleMap ~ data[i];
index: Vec ~ [s: s, f: f];
dst.Transfer[src: map, dstMin: dstMin, srcMin: index, size: size, function: function];
};

PixelMapCopy: CopyProc ~ {
data0: PixelMapData ~ NARROW[self.data];
data1: PixelMapData ~ NEW[PixelMapRep[data0.samplesPerPixel]];
FOR i: NAT IN[0..data1.samplesPerPixel) DO data1[i] _ data0[i].CopyMap[] ENDLOOP;
RETURN[New[class: pixelMapClass, data: data1, immutable: TRUE,
samplesPerPixel: self.samplesPerPixel, sSize: self.sSize, fSize: self.fSize, m: self.m]];
};

FromPixelMap: PUBLIC PROC [map: PixelMap, scanMode: ScanMode, immutable: BOOL] 
RETURNS [PixelArray] ~ {
samplesPerPixel: NAT ~ map.samplesPerPixel;
sSize: NAT ~ map.size.s;
fSize: NAT ~ map.size.f;
RETURN[New[class: pixelMapClass, data: map, immutable: immutable,
samplesPerPixel: samplesPerPixel, sSize: sSize, fSize: fSize, 
m: ImagerTransformation.SFToXY[scanMode: scanMode, sSize: sSize, fSize: fSize]]];
};


END.
ΐImagerPixelArrayImpl.mesa
Copyright c 1984, 1985, 1986 by Xerox Corporation.  All rights reserved.
Michael Plass, June 3, 1985 12:40:17 pm PDT
Doug Wyatt, March 7, 1986 4:20:36 pm PST


Κμ˜
codeš
œ™Kšœ
Οm
œ=™HK™+K™(—K˜š
Οk	˜	Kšœžœžœ˜2KšœžœC˜YKšœžœl˜‰
Kšœ
žœΞ
˜ΰ
Kšœžœ+˜EKšžœ
žœ˜—K˜KšΠblœž
˜#Kšžœ-ž˜6Kšžœ*˜1Kšœžœ
žœ+˜7K˜Kšœžœžœ˜Kšœžœ'˜;Kšœ
žœ!˜/Kšœžœ˜#Kšœžœ˜/Kšœ
žœ˜-Kšœžœ˜)Kšœ
žœ˜'Kšœ
žœ˜-Kšœ
žœ˜'Kš
œ3˜3K˜Kšœžœ+˜@Kšœžœ
žœ.˜MK˜Kšœžœ
žœžœ
˜.K˜š
Οnœžœ
žœžœžœ˜;K˜$Kšžœ
˜K˜K˜—š
 œžœ
žœžœžœ
˜KK˜$KšžœR˜XK˜K˜—š œžœ
žœžœžœžœ
˜KK˜$Kšœžœ/˜:Kšœžœ8˜AKšœžœ8˜AK˜ Kš
œ ˜ Kšžœ)˜/K˜K˜—š 
œžœ
žœžœžœ%žœ
žœ˜ˆ
K˜$Kšœžœ/˜:Kšœžœ8˜AKšœžœ8˜AKšœ
žœžœ˜4K˜ Kš
œ*˜*Kš
œc˜cK˜K˜—š 	œžœ
žœžœ#žœ
žœ˜yšžœžœ
žœž˜)K˜2Kš
ž˜—K˜K˜—š
 œžœ
žœžœžœh˜¦
K˜$Kšœžœ/˜:Kšœžœ8˜AKšœžœ8˜AKš
œ1˜1Kšžœžœ˜.Kšžœžœ˜.Kš
œn˜nK˜K˜—š œžœ
žœžœ˜=Kšžœžœ
žœ˜#šžœ˜K˜$Kšžœžœ
žœ
žœ˜/Kšžœ
žœE˜OK˜—Kš
œ˜K˜—K˜š
 œžœžœžœžœ
˜QK˜$K˜šœžœ˜(Kš
œU˜UK˜K˜—K˜-Kšžœ˜K˜K˜—š
 œžœžœžœžœ
˜OK˜$K˜šœžœ˜!Kš
œn˜nK˜3K˜—K˜MKšžœ˜K˜K˜—š œžœžœžœ!žœ	žœ˜pK˜$šžœžœ
žœž˜Kš
œ=˜=Kšžœ
˜—K˜K˜—š œžœžœžœ!žœ	žœ˜uK˜$šœžœ˜!Kš
œp˜pK˜=K˜—K˜WK˜K˜—š œžœžœžœB˜{K˜$šžœžœ
žœž˜šžœžœ
žœž˜K˜>Kš
œS˜SKšžœ
˜—Kšžœ
˜—K˜K˜—š œžœžœžœB˜‚
K˜$šœžœ˜(šžœžœ
žœž˜Kš
œ\˜\Kš
œm˜mKšžœ
˜—K˜—Kš
œ2˜2K˜K˜—K™š œžœ
žœžœ7žœ žœžœžœžœ˜Τ
šœžœ˜3Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜—šžœžœ
žœ
žœ
žœ
ž˜ Kšœžœ!˜/Kšœ	žœ˜+Kšžœ
˜—šžœžœ
žœ
žœ
žœ
ž˜'Kšœ	žœ-˜9Kšœžœ(˜/Kšžœ
˜—šžœ
žœ
žœ
žœ
žœ
ž˜%Kšœžœ+˜9Kšœžœ$˜+Kšžœ
˜—Kšžœ˜K˜K˜—š œžœ
žœ žœ
žœžœžœžœ˜›
Kšžœ
žœ²
˜Ό
K˜K˜—K˜Kšœžœžœžœ˜0K˜š
œ+˜+Kš
œ˜Kš
œ)˜)Kš
œ˜Kš
œ ˜ Kš
œ˜K˜K˜—Kšœžœžœ˜+šœžœžœ˜!Kš
œ˜Kšœžœžœ
žœ
ž˜,Kš
œ˜K˜—š œžœžœžœ˜FKšžœ'˜-Kš
œ˜K˜—š œ˜/Kšœžœ˜(J˜'K˜*Kšžœ4˜:K˜K˜—š œ
˜Kšœžœ˜(J˜'K˜*Kšžœ5˜;K˜K˜—š œ˜'Kšœžœ˜(J˜'K˜*Kš
œj˜jK˜K˜—š œ˜#Kšœžœ˜(J˜'K˜*Kš
œt˜tK˜K˜—š œžœ
žœ$žœ
žœžœžœžœžœ˜}Kšœžœ<˜Ušžœžœ
žœž˜*Kš
œD˜DKšžœ
˜—šžœA˜GKš
œQ˜Q—Kš
œ˜K˜—K˜š
œ(˜(Kš
œ˜Kš
œ&˜&Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜—šœžœžœ
žœ˜&K˜—š œžœžœžœ˜@šžœžœ
žœžœžœ
ž˜@K˜Kšžœžœ
žœ˜9Kšžœ˜ Kšžœ
˜—KšžœΟc ˜'Kš
œ˜K˜—š œ˜,Kšœžœ˜%J˜$K˜*Kšžœ4˜:K˜K˜—š 	œ
˜Kšœžœ˜%J˜$K˜*Kšžœ5˜;K˜K˜—š œ˜$Kšœžœ˜%J˜$K˜*Kš
œj˜jK˜K˜—š œ˜ Kšœžœ˜%J˜$K˜*Kš
œt˜tK˜K˜—š œžœ
žœžœ
žœ
žœ˜EKšœžœžœ
˜Kšœžœ˜Kšœžœ˜Kšœžœ
˜šžœžœ
žœžœžœ
ž˜@K˜Kšœžœ˜'K˜5Kšžœžœ2‘˜Ošžœ˜Kš
žœ
žœžœžœ
žœF˜zKšžœ
žœžœ
žœP˜oK˜—Kšžœ
˜—šžœ:˜@Kš
œE˜E—K˜K™—š œžœ
žœžœ˜GKšžœžœ˜"K˜K˜—K˜š
œ*˜*Kš
œ˜Kš
œ(˜(Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜—šœžœ˜K˜—š œ˜.Kšœžœ˜'Kš
œ˜Kšžœžœ˜0K˜K˜—š œ
˜Kšœžœ˜'Kš
œ˜K˜Kšžœ˜K˜K˜—š œ˜&Kšœžœ˜'Kš
œ˜K˜K˜IK˜K˜—š œ˜"Kšœžœ˜'Kš
œ˜K˜Kš
œV˜VK˜K˜—š œ˜Kšœžœ˜(Kšœžœ%˜>Kš
žœžœ
žœžœžœ
˜Qšžœ3žœ
˜>Kš
œY˜Y—K˜K˜—š
 œžœ
žœ0žœžœ˜hKšœžœ˜+Kšœžœ˜Kšœžœ˜šžœ;˜AKš
œ>˜>Kš
œQ˜Q—Kš
œ˜K˜—K˜Kšžœ
˜—…—5ΒCn