DIRECTORY
Basics,
ImagerSample,
ImagerTransformation,
PrincOps,
PrincOpsUtils,
Process,
Real;

ImagerSampleImpl: CEDAR MONITOR
IMPORTS Basics, ImagerSample, ImagerTransformation, PrincOpsUtils, Process, Real
EXPORTS ImagerSample
~ BEGIN OPEN ImagerSample;

assertSampleSizeMatchesWordSize: BOOL[TRUE..TRUE] ~ SIZE[Sample]=SIZE[WORD];

bitsPerWord: NAT ~ Basics.bitsPerWord;
lgBitsPerWord: NAT ~ Basics.logBitsPerWord;

NewBuffer: PUBLIC PROC [iSize, jSize: NAT, scratch: SampleBuffer _ NIL] 
RETURNS [SampleBuffer] ~ {
size: NAT ~ Basics.LongMult[iSize, jSize];
new: SampleBuffer _ scratch;
IF new=NIL OR new.size<size THEN new _ NEW[SampleBufferRep[size]];
new.iSize _ iSize; new.jSize _ jSize;
RETURN[new];
};
nScratchSlots: NAT ~ 2;
nScratchAvail: NAT _ 0;
scratch: ARRAY [0..nScratchSlots) OF SampleBuffer _ ALL[NIL];
rover: NAT _ 0;

ObtainScratchBuffer: PUBLIC ENTRY PROC [iSize, jSize: NAT] 
RETURNS [buffer: SampleBuffer _ NIL] ~ {
ENABLE UNWIND => NULL;
size: NAT ~ Basics.LongMult[iSize, jSize];
FOR i: NAT DECREASING IN [0..nScratchAvail) DO
IF scratch[i].size >= size THEN {
buffer _ scratch[i];
IF i # nScratchAvail-1 THEN scratch[i] _ scratch[nScratchAvail-1];
nScratchAvail _ nScratchAvail - 1;
scratch[nScratchAvail] _ NIL;
EXIT;
};
ENDLOOP;
buffer _ NewBuffer[iSize: iSize, jSize: jSize, scratch: buffer];
};

ReleaseScratchBuffer: PUBLIC ENTRY PROC [buffer: SampleBuffer] ~ {
IF nScratchAvail < nScratchSlots THEN {
scratch[nScratchAvail] _ buffer;
nScratchAvail _ nScratchAvail + 1;
}
ELSE {
scratch[rover] _ buffer;
rover _ (rover + 1) MOD nScratchSlots;
};
};
DoWithScratchBuffer: PUBLIC PROC [iSize, jSize: NAT, action: PROC [SampleBuffer]] ~ {
buffer: SampleBuffer ~ ObtainScratchBuffer[iSize, jSize];
action[buffer ! UNWIND => ReleaseScratchBuffer[buffer]];
ReleaseScratchBuffer[buffer];
};

GetSample: PUBLIC PROC [buffer: SampleBuffer, i, j: NAT] RETURNS [Sample] ~ {
k: NAT ~ Basics.BoundsCheck[i, buffer.iSize]*buffer.jSize+Basics.BoundsCheck[j, buffer.jSize];
RETURN[buffer[k]];
};

PutSample: PUBLIC PROC [buffer: SampleBuffer, i, j: NAT, sample: Sample] ~ {
k: NAT ~ Basics.BoundsCheck[i, buffer.iSize]*buffer.jSize+Basics.BoundsCheck[j, buffer.jSize];
buffer[k] _ sample;
};

GetPointer: PUBLIC PROC [buffer: SampleBuffer, i, j, count: NAT] RETURNS [UnsafeSamples] ~ {
k: NAT ~ Basics.BoundsCheck[i, buffer.iSize]*buffer.jSize+Basics.BoundsCheck[j, buffer.jSize];
IF count#0 THEN [] _ Basics.BoundsCheck[j+count-1, buffer.jSize];
TRUSTED { RETURN[LOOPHOLE[@buffer[k]]] };
};


UnsafeAdd: PUBLIC UNSAFE PROC [src1, src2, dst: UnsafeSamples, count: NAT] ~ UNCHECKED {
THROUGH [0..count/8) DO
dst[0] _ src1[0]+src2[0];
dst[1] _ src1[1]+src2[1];
dst[2] _ src1[2]+src2[2];
dst[3] _ src1[3]+src2[3];
dst[4] _ src1[4]+src2[4];
dst[5] _ src1[5]+src2[5];
dst[6] _ src1[6]+src2[6];
dst[7] _ src1[7]+src2[7];
src1 _ src1+8;
src2 _ src2+8;
dst _ dst+8;
ENDLOOP;
FOR k: NAT IN[0..count MOD 8) DO dst[k] _ src1[k]+src2[k] ENDLOOP;
};
UnsafeSub: PUBLIC UNSAFE PROC [src1, src2, dst: UnsafeSamples, count: NAT] ~ UNCHECKED {
THROUGH [0..count/8) DO
dst[0] _ src1[0]-src2[0];
dst[1] _ src1[1]-src2[1];
dst[2] _ src1[2]-src2[2];
dst[3] _ src1[3]-src2[3];
dst[4] _ src1[4]-src2[4];
dst[5] _ src1[5]-src2[5];
dst[6] _ src1[6]-src2[6];
dst[7] _ src1[7]-src2[7];
src1 _ src1+8;
src2 _ src2+8;
dst _ dst+8;
ENDLOOP;
FOR k: NAT IN[0..count MOD 8) DO dst[k] _ src1[k]-src2[k] ENDLOOP;
};
UnsafeLookup: PUBLIC UNSAFE PROC [tbl, src, dst: UnsafeSamples, count: NAT] ~ UNCHECKED {
THROUGH [0..count/8) DO
dst[0] _ tbl[src[0]];
dst[1] _ tbl[src[1]];
dst[2] _ tbl[src[2]];
dst[3] _ tbl[src[3]];
dst[4] _ tbl[src[4]];
dst[5] _ tbl[src[5]];
dst[6] _ tbl[src[6]];
dst[7] _ tbl[src[7]];
src _ src+8;
dst _ dst+8;
ENDLOOP;
FOR k: NAT IN[0..count) DO dst[k] _ tbl[src[k]] ENDLOOP;
};
AddSamples: PUBLIC PROC [samples: SampleBuffer, si, sj: NAT _ 0, 
buffer: SampleBuffer, bi, bj: NAT _ 0, count: NAT] ~ {
src: UnsafeSamples ~ GetPointer[samples, si, sj, count];
dst: UnsafeSamples ~ GetPointer[buffer, bi, bj, count];
TRUSTED { UnsafeAdd[src1: dst, src2: src, dst: dst, count: count] };
};
SubSamples: PUBLIC PROC [samples: SampleBuffer, si, sj: NAT _ 0, 
buffer: SampleBuffer, bi, bj: NAT _ 0, count: NAT] ~ {
src: UnsafeSamples ~ GetPointer[samples, si, sj, count];
dst: UnsafeSamples ~ GetPointer[buffer, bi, bj, count];
TRUSTED { UnsafeSub[src1: dst, src2: src, dst: dst, count: count] };
};
LookupSamples: PUBLIC PROC [table: SampleBuffer, samples: SampleBuffer, si, sj: NAT _ 0, 
buffer: SampleBuffer, bi, bj: NAT _ 0, count: NAT] ~ {
tbl: UnsafeSamples ~ GetPointer[table, 0, 0, 0];
src: UnsafeSamples ~ GetPointer[samples, si, sj, count];
dst: UnsafeSamples ~ GetPointer[buffer, bi, bj, count];
TRUSTED { FOR k: NAT IN[0..count) DO dst[k] _ table[src[k]] ENDLOOP };
};
LookupPixels: PUBLIC PROC [tables: SampleBuffer, pixels: SampleBuffer, pj: NAT _ 0,
buffer: SampleBuffer, bi, bj: NAT _ 0, count: NAT] ~ {
dst: UnsafeSamples ~ GetPointer[buffer, bi, bj, count];
SELECT tables.iSize FROM
0 => NULL;
1 => {
tbl0: UnsafeSamples ~ GetPointer[tables, 0, 0, 0];
src0: UnsafeSamples ~ GetPointer[pixels, 0, pj, count];
TRUSTED { FOR k: NAT IN[0..count) DO dst[k] _ tbl0[src0[k]] ENDLOOP };
};
2 => {
tbl0: UnsafeSamples ~ GetPointer[tables, 0, 0, 0];
tbl1: UnsafeSamples ~ GetPointer[tables, 1, 0, 0];
src0: UnsafeSamples ~ GetPointer[pixels, 0, pj, count];
src1: UnsafeSamples ~ GetPointer[pixels, 1, pj, count];
TRUSTED { FOR k: NAT IN[0..count) DO dst[k] _ tbl0[src0[k]]+tbl1[src1[k]] ENDLOOP };
};
3 => {
tbl0: UnsafeSamples ~ GetPointer[tables, 0, 0, 0];
tbl1: UnsafeSamples ~ GetPointer[tables, 1, 0, 0];
tbl2: UnsafeSamples ~ GetPointer[tables, 2, 0, 0];
src0: UnsafeSamples ~ GetPointer[pixels, 0, pj, count];
src1: UnsafeSamples ~ GetPointer[pixels, 1, pj, count];
src2: UnsafeSamples ~ GetPointer[pixels, 2, pj, count];
TRUSTED { FOR k: NAT IN[0..count) DO dst[k] _ tbl0[src0[k]]+tbl1[src1[k]]+tbl2[src2[k]] ENDLOOP };
};
ENDCASE => FOR k: NAT IN[0..count) DO
sum: Sample _ 0;
FOR i: NAT IN[0..tables.iSize) DO
sum _ sum+tables.GetSample[i, pixels.GetSample[i, pj+k]];
ENDLOOP;
buffer.PutSample[bi, bj+k, sum];
ENDLOOP;
};

LgEntry: TYPE ~ RECORD[powerOfTwo: BOOL, lg: NAT _ 0];
LgArray: TYPE ~ ARRAY BitsPerSample OF LgEntry;
lgArray: REF LgArray ~ InitLgArray[];

InitLgArray: PROC RETURNS [REF LgArray] ~ {
lgArray: REF LgArray ~ NEW[LgArray _ ALL[[powerOfTwo: FALSE]]];
FOR lg: NAT IN[0..lgBitsPerWord] DO
lgArray[Basics.BITSHIFT[1, lg]] _ [powerOfTwo: TRUE, lg: lg];
ENDLOOP;
RETURN[lgArray];
};

nullBitBltTable: PrincOps.BitBltTable ~ [
dst: [word: NIL, bit: 0], dstBpl: 0,
src: [word: NIL, bit: 0], srcDesc: [srcBpl[0]],
width: 0, height: 0, flags: []
];

UnsafeGetF: PUBLIC UNSAFE PROC [samples: UnsafeSamples, count: NAT, s, f: NAT _ 0,
base: LONG POINTER, wordsPerLine: NAT, bitsPerSample: BitsPerSample] ~ UNCHECKED {
lgEntry: LgEntry ~ lgArray[bitsPerSample];
line: LONG POINTER ~ base+Basics.LongMult[s, wordsPerLine];
bbTableSpace: PrincOps.BBTableSpace;
bb: PrincOps.BBptr ~ PrincOpsUtils.AlignedBBTable[@bbTableSpace];
bb^ _ nullBitBltTable;
bb.flags _ [disjoint: TRUE, gray: FALSE];
PrincOpsUtils.LongZero[where: samples, nwords: count];
IF lgEntry.powerOfTwo THEN {
lgBitsPerItem: NAT ~ lgEntry.lg;
bitsPerItem: NAT ~ Basics.BITSHIFT[1, lgBitsPerItem];
lgItemsPerWord: NAT ~ lgBitsPerWord-lgBitsPerItem;
itemsPerWord: NAT ~ Basics.BITSHIFT[1, lgItemsPerWord];
bb.dst.bit _ bitsPerWord-bitsPerItem;
bb.dstBpl _ Basics.BITSHIFT[bitsPerWord, lgItemsPerWord];
bb.srcDesc.srcBpl _ bitsPerWord;
bb.width _ bitsPerItem;
FOR k: NAT IN [0..MIN[itemsPerWord, count]) DO
x: CARDINAL ~ f+k;
bb.dst.word _ @samples[k];
bb.src.word _ line+Basics.BITSHIFT[x, -lgItemsPerWord];
bb.src.bit _ Basics.BITSHIFT[Basics.BITAND[x, itemsPerWord-1], lgBitsPerItem];
bb.height _ Basics.BITSHIFT[(count-k)+(itemsPerWord-1), -lgItemsPerWord];
PrincOpsUtils.BITBLT[bb];
ENDLOOP;
}
ELSE {
bit: LONG CARDINAL ~ Basics.LongMult[f, bitsPerSample];
bb.dst.word _ samples;
bb.dst.bit _ bitsPerWord-bitsPerSample;
bb.dstBpl _ bitsPerWord;
bb.src.word _ line+bit/bitsPerWord;
bb.src.bit _ bit MOD bitsPerWord;
bb.srcDesc.srcBpl _ bitsPerSample;
bb.width _ bitsPerSample;
bb.height _ count;
PrincOpsUtils.BITBLT[bb];
};
};
UnsafePutF: PUBLIC UNSAFE PROC [samples: UnsafeSamples, count: NAT, s, f: NAT _ 0,
base: LONG POINTER, wordsPerLine: NAT, bitsPerSample: BitsPerSample, srcFunc: PrincOps.SrcFunc _ null, dstFunc: PrincOps.DstFunc _ null] ~ UNCHECKED {
lgEntry: LgEntry ~ lgArray[bitsPerSample];
line: LONG POINTER ~ base+Basics.LongMult[s, wordsPerLine];
bbTableSpace: PrincOps.BBTableSpace;
bb: PrincOps.BBptr ~ PrincOpsUtils.AlignedBBTable[@bbTableSpace];
bb^ _ nullBitBltTable;
bb.flags _ [disjoint: TRUE, gray: FALSE, srcFunc: srcFunc, dstFunc: dstFunc];
IF lgEntry.powerOfTwo THEN {
lgBitsPerItem: NAT ~ lgEntry.lg;
bitsPerItem: NAT ~ Basics.BITSHIFT[1, lgBitsPerItem];
lgItemsPerWord: NAT ~ lgBitsPerWord-lgBitsPerItem;
itemsPerWord: NAT ~ Basics.BITSHIFT[1, lgItemsPerWord];
bb.src.bit _ bitsPerWord-bitsPerItem;
bb.srcDesc.srcBpl _ Basics.BITSHIFT[bitsPerWord, lgItemsPerWord];
bb.dstBpl _ bitsPerWord;
bb.width _ bitsPerItem;
FOR k: NAT IN [0..MIN[itemsPerWord, count]) DO
x: CARDINAL ~ f+k;
bb.src.word _ @samples[k];
bb.dst.word _ line+Basics.BITSHIFT[x, -lgItemsPerWord];
bb.dst.bit _ Basics.BITSHIFT[Basics.BITAND[x, itemsPerWord-1], lgBitsPerItem];
bb.height _ Basics.BITSHIFT[(count-k)+(itemsPerWord-1), -lgItemsPerWord];
PrincOpsUtils.BITBLT[bb];
ENDLOOP;
}
ELSE {
bit: LONG CARDINAL ~ Basics.LongMult[f, bitsPerSample];
bb.src.word _ samples;
bb.src.bit _ bitsPerWord-bitsPerSample;
bb.srcDesc.srcBpl _ bitsPerWord;
bb.dst.word _ line+bit/bitsPerWord;
bb.dst.bit _ bit MOD bitsPerWord;
bb.dstBpl _ bitsPerSample;
bb.width _ bitsPerSample;
bb.height _ count;
PrincOpsUtils.BITBLT[bb];
};

};

UnsafePutFSign: PUBLIC UNSAFE PROC [samples: UnsafeSamples, count: NAT, s, f: NAT _ 0, 
base: LONG POINTER, wordsPerLine: NAT] ~ UNCHECKED {
line: LONG POINTER ~ base+Basics.LongMult[s, wordsPerLine];
bbTableSpace: PrincOps.BBTableSpace;
bb: PrincOps.BBptr ~ PrincOpsUtils.AlignedBBTable[@bbTableSpace];
bb^ _ nullBitBltTable;
bb.flags _ [disjoint: TRUE, gray: FALSE];
bb.srcDesc.srcBpl _ bitsPerWord*bitsPerWord;
bb.dstBpl _ bitsPerWord;
bb.width _ 1;
FOR k: NAT IN [0..MIN[bitsPerWord, count]) DO
x: CARDINAL ~ f+k;
bb.src.word _ @samples[k];
bb.dst.word _ line+x/bitsPerWord;
bb.dst.bit _ x MOD bitsPerWord;
bb.height _ (CARDINAL[count-k]+bitsPerWord-1)/bitsPerWord;
PrincOpsUtils.BITBLT[bb];
ENDLOOP;
};

UnsafeGetS: PUBLIC UNSAFE PROC [samples: UnsafeSamples, count: NAT, s, f: NAT _ 0,
base: LONG POINTER, wordsPerLine: NAT, bitsPerSample: BitsPerSample] ~ UNCHECKED {
lgEntry: LgEntry ~ lgArray[bitsPerSample];
bbTableSpace: PrincOps.BBTableSpace;
bb: PrincOps.BBptr ~ PrincOpsUtils.AlignedBBTable[@bbTableSpace];
bb^ _ nullBitBltTable;
bb.flags _ [disjoint: TRUE, gray: FALSE];
PrincOpsUtils.LongZero[where: samples, nwords: count];
bb.dst.word _ samples;
bb.dst.bit _ bitsPerWord-bitsPerSample;
bb.dstBpl _ bitsPerWord;
bb.srcDesc.srcBpl _ wordsPerLine*bitsPerWord;
bb.width _ bitsPerSample;
bb.height _ count;
IF lgEntry.powerOfTwo THEN {
lgBitsPerItem: NAT ~ lgEntry.lg;
lgItemsPerWord: NAT ~ lgBitsPerWord-lgBitsPerItem;
itemsPerWord: NAT ~ Basics.BITSHIFT[1, lgItemsPerWord];
bb.src.word _ base+Basics.LongMult[s, wordsPerLine]+Basics.BITSHIFT[f, -lgItemsPerWord];
bb.src.bit _ Basics.BITSHIFT[Basics.BITAND[f, itemsPerWord-1], lgBitsPerItem];
PrincOpsUtils.BITBLT[bb];
}
ELSE {
x: LONG CARDINAL ~ Basics.LongMult[bitsPerSample, f];
bb.src.word _ base+Basics.LongMult[wordsPerLine, s]+x/bitsPerWord;
bb.src.bit _ x MOD bitsPerWord;
PrincOpsUtils.BITBLT[bb];
};
};

UnsafePutS: PUBLIC UNSAFE PROC [samples: UnsafeSamples, count: NAT, s, f: NAT _ 0,
base: LONG POINTER, wordsPerLine: NAT, bitsPerSample: BitsPerSample, srcFunc: PrincOps.SrcFunc _ null, dstFunc: PrincOps.DstFunc _ null] ~ UNCHECKED {
lgEntry: LgEntry ~ lgArray[bitsPerSample];
bbTableSpace: PrincOps.BBTableSpace;
bb: PrincOps.BBptr ~ PrincOpsUtils.AlignedBBTable[@bbTableSpace];
bb^ _ nullBitBltTable;
bb.flags _ [disjoint: TRUE, gray: FALSE, srcFunc: srcFunc, dstFunc: dstFunc];
bb.dstBpl _ wordsPerLine*bitsPerWord;
bb.src.word _ samples;
bb.src.bit _ bitsPerWord-bitsPerSample;
bb.srcDesc.srcBpl _ bitsPerWord;
bb.width _ bitsPerSample;
bb.height _ count;
IF lgEntry.powerOfTwo THEN {
lgBitsPerItem: NAT ~ lgEntry.lg;
lgItemsPerWord: NAT ~ lgBitsPerWord-lgBitsPerItem;
itemsPerWord: NAT ~ Basics.BITSHIFT[1, lgItemsPerWord];
bb.dst.word _ base+Basics.LongMult[s, wordsPerLine]+Basics.BITSHIFT[f, -lgItemsPerWord];
bb.dst.bit _ Basics.BITSHIFT[Basics.BITAND[f, itemsPerWord-1], lgBitsPerItem];
PrincOpsUtils.BITBLT[bb];
}
ELSE {
x: LONG CARDINAL ~ Basics.LongMult[bitsPerSample, f];
bb.dst.word _ base+Basics.LongMult[wordsPerLine, s]+x/bitsPerWord;
bb.dst.bit _ x MOD bitsPerWord;
PrincOpsUtils.BITBLT[bb];
};
};


realLastInt: REAL _ REAL[LAST[INT]];

Floor: PROC[a: REAL] RETURNS[c: REAL] ~ {
IF ABS[a] >= realLastInt THEN RETURN [a];
c _ REAL[Real.Fix[a]];
IF c>a THEN RETURN[c-1] ELSE RETURN[c]
};

ScaledFromRealMod: PROC [d: REAL, m: CARDINAL] RETURNS [INT] ~ {
s: Basics.LongNumber _ [li[0]];
IF m # 0 THEN {
modulus: REAL ~ m;
residue: REAL _ IF d IN [0..modulus) THEN d ELSE (d-modulus*Floor[d/modulus]);
s.li _ Real.Round[Real.FScale[residue, Basics.bitsPerWord]];
IF s.li < 0 THEN {s.hi _ s.hi + m};
IF s.hi >= m THEN {s.hi _ s.hi - m};
IF s.hi >= m THEN ERROR;
};
RETURN [s.li];
};

SetSamplerIncrements: PUBLIC PROC [sampler: Sampler, m: Transformation] ~ {
sSize: NAT ~ sampler.sSize;
fSize: NAT ~ sampler.fSize;
s, f: REAL _ 0.0;
[[s, f]] _ m.InverseTransformVec[[0, 1] ! Real.RealException => CONTINUE];
sampler.sfDelta.li _ ScaledFromRealMod[s, sSize];
sampler.ffDelta.li _ ScaledFromRealMod[f, fSize];
s _ f _ 0.0;
[[s, f]] _ m.InverseTransformVec[[1, 0] ! Real.RealException => CONTINUE];
sampler.ssDelta.li _ ScaledFromRealMod[s, sSize];
sampler.fsDelta.li _ ScaledFromRealMod[f, fSize];
};

SetSamplerPosition: PUBLIC PROC [sampler: Sampler, m: Transformation, s, f: CARDINAL] ~ {
sSource, fSource: REAL _ 0.0;
sSize: NAT ~ sampler.sSize;
fSize: NAT ~ sampler.fSize;
[[sSource, fSource]] _ m.InverseTransform[[s+0.5, f+0.5] ! Real.RealException => CONTINUE];
sampler.sSource.li _ ScaledFromRealMod[sSource, sSize];
sampler.fSource.li _ ScaledFromRealMod[fSource, fSize];
sampler.sDest _ s;
sampler.fDest _ f;
};


Sample0: TYPE ~ CARDINAL[0..000001B]; -- 1 bit
Sample1: TYPE ~ CARDINAL[0..000003B]; -- 2 bits
Sample2: TYPE ~ CARDINAL[0..000017B]; -- 4 bits
Sample3: TYPE ~ CARDINAL[0..000377B]; -- 8 bits
Sample4: TYPE ~ CARDINAL[0..177777B]; -- 16 bits

Sequence0: TYPE ~ RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF Sample0];
Sequence1: TYPE ~ RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF Sample1];
Sequence2: TYPE ~ RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF Sample2];
Sequence3: TYPE ~ RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF Sample3];
Sequence4: TYPE ~ RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF Sample4];

Pointer0: TYPE ~ LONG POINTER TO Sequence0;
Pointer1: TYPE ~ LONG POINTER TO Sequence1;
Pointer2: TYPE ~ LONG POINTER TO Sequence2;
Pointer3: TYPE ~ LONG POINTER TO Sequence3;
Pointer4: TYPE ~ LONG POINTER TO Sequence4;

GetPointSamples: PUBLIC PROC [sampler: Sampler, s, f: CARDINAL, 
buffer: SampleBuffer, bi, bj: NAT _ 0, count: NAT] ~ TRUSTED {
lgEntry: LgEntry ~ lgArray[sampler.bitsPerSample];
samples: UnsafeSamples ~ buffer.GetPointer[bi, bj, count];
base: LONG POINTER ~ sampler.base;
wordsPerLine: CARDINAL ~ sampler.wordsPerLine;
line: LONG POINTER _ base;
sLine: CARDINAL _ 0;
sSize: CARDINAL ~ sampler.sSize;
fSize: CARDINAL ~ sampler.fSize;
sMin: CARDINAL ~ sampler.sMin;
fMin: CARDINAL ~ sampler.fMin;
sMax: CARDINAL ~ sMin+sSize;
fMax: CARDINAL ~ fMin+fSize;
ssDelta: Basics.LongNumber ~ sampler.ssDelta;
fsDelta: Basics.LongNumber ~ sampler.fsDelta;
sfDelta: Basics.LongNumber ~ sampler.sfDelta;
ffDelta: Basics.LongNumber ~ sampler.ffDelta;
sSource: Basics.LongNumber _ sampler.sSource;
fSource: Basics.LongNumber _ sampler.fSource;
sDest: CARDINAL _ sampler.sDest;
fDest: CARDINAL _ sampler.fDest;
Process.CheckForAbort[];
WHILE sDest<s DO
sSource.lc _ sSource.lc+ssDelta.lc;
fSource.lc _ fSource.lc+fsDelta.lc;
IF NOT sSource.hi<sSize THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fSize THEN fSource.hi _ fSource.hi-fSize;
sDest _ sDest+1;
ENDLOOP;
sampler.sSource _ sSource;
sampler.fSource _ fSource;
sampler.sDest _ sDest;
WHILE fDest<f DO
sSource.lc _ sSource.lc+sfDelta.lc;
fSource.lc _ fSource.lc+ffDelta.lc;
IF NOT sSource.hi<sSize THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fSize THEN fSource.hi _ fSource.hi-fSize;
fDest _ fDest+1;
ENDLOOP;
IF s#sDest OR f#fDest THEN ERROR;
sSource.hi _ sSource.hi+sMin;
fSource.hi _ fSource.hi+fMin;
IF lgEntry.powerOfTwo THEN SELECT lgEntry.lg FROM
0 => FOR k: NAT IN[0..count) DO
IF sLine#sSource.hi THEN line _ base+Basics.LongMult[sLine _ sSource.hi, wordsPerLine];
samples[k] _ LOOPHOLE[line, Pointer0][fSource.hi];
sSource.lc _ sSource.lc+sfDelta.lc; fSource.lc _ fSource.lc+ffDelta.lc;
IF NOT sSource.hi<sMax THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fMax THEN fSource.hi _ fSource.hi-fSize;
ENDLOOP;
1 => FOR k: NAT IN[0..count) DO
IF sLine#sSource.hi THEN line _ base+Basics.LongMult[sLine _ sSource.hi, wordsPerLine];
samples[k] _ LOOPHOLE[line, Pointer1][fSource.hi];
sSource.lc _ sSource.lc+sfDelta.lc; fSource.lc _ fSource.lc+ffDelta.lc;
IF NOT sSource.hi<sMax THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fMax THEN fSource.hi _ fSource.hi-fSize;
ENDLOOP;
2 => FOR k: NAT IN[0..count) DO
IF sLine#sSource.hi THEN line _ base+Basics.LongMult[sLine _ sSource.hi, wordsPerLine];
samples[k] _ LOOPHOLE[line, Pointer2][fSource.hi];
sSource.lc _ sSource.lc+sfDelta.lc; fSource.lc _ fSource.lc+ffDelta.lc;
IF NOT sSource.hi<sMax THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fMax THEN fSource.hi _ fSource.hi-fSize;
ENDLOOP;
3 => FOR k: NAT IN[0..count) DO
IF sLine#sSource.hi THEN line _ base+Basics.LongMult[sLine _ sSource.hi, wordsPerLine];
samples[k] _ LOOPHOLE[line, Pointer3][fSource.hi];
sSource.lc _ sSource.lc+sfDelta.lc; fSource.lc _ fSource.lc+ffDelta.lc;
IF NOT sSource.hi<sMax THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fMax THEN fSource.hi _ fSource.hi-fSize;
ENDLOOP;
4 => FOR k: NAT IN[0..count) DO
IF sLine#sSource.hi THEN line _ base+Basics.LongMult[sLine _ sSource.hi, wordsPerLine];
samples[k] _ LOOPHOLE[line, Pointer4][fSource.hi];
sSource.lc _ sSource.lc+sfDelta.lc; fSource.lc _ fSource.lc+ffDelta.lc;
IF NOT sSource.hi<sMax THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fMax THEN fSource.hi _ fSource.hi-fSize;
ENDLOOP;
ENDCASE => ERROR
ELSE ERROR;
};


Hi: PROC [a: CARDINAL] RETURNS [CARDINAL]
~ INLINE {RETURN[Basics.BITSHIFT[a, 1-bitsPerWord]]};

Shift: PROC [a: CARDINAL, amt: INTEGER] RETURNS [CARDINAL]
~ INLINE {RETURN[Basics.BITSHIFT[a, amt]]};

SixteenWords: TYPE ~ MACHINE DEPENDENT RECORD [
w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15: CARDINAL
];

UnsafeHalftone: PUBLIC UNSAFE PROC [
samples, thresholds: UnsafeSamples, count: NAT,
base: LONG POINTER, wordsPerLine: NAT, s, f: NAT _ 0, 
invertOutput: BOOL _ FALSE, transparent: BOOL _ FALSE
] ~ UNCHECKED {
linePointer: LONG POINTER ~ base+Basics.LongMult[s, wordsPerLine];
bitOffset: CARDINAL ~ f;
p: LONG POINTER TO SixteenWords _ LOOPHOLE[@samples[0]];
q: LONG POINTER TO SixteenWords _ LOOPHOLE[@thresholds[0]];
allInvert: CARDINAL _ IF invertOutput THEN LAST[CARDINAL] ELSE 0;
GetN: UNSAFE PROC [n: [0..16)] RETURNS [CARDINAL] ~ UNCHECKED {
w: CARDINAL _ 0;
THROUGH [0..n) DO
w _ w*2 + Hi[p^.w0-q^.w0];
p _ p + 1;
q _ q + 1;
ENDLOOP;
RETURN [Basics.BITXOR[w, Basics.BITSHIFT[allInvert, n-16]]];
}; -- GetFirst
Get16: UNSAFE PROC RETURNS [CARDINAL] ~ UNCHECKED {
s, h: SixteenWords;
s _ p^; p _ p + SIZE[SixteenWords];
h _ q^; q _ q + SIZE[SixteenWords];
RETURN [Basics.BITXOR[allInvert, ((((((((((((((Hi[s.w0-h.w0]*2+Hi[s.w1-h.w1])*2+Hi[s.w2-h.w2])*2+Hi[s.w3-h.w3])*2+Hi[s.w4-h.w4])*2+Hi[s.w5-h.w5])*2+Hi[s.w6-h.w6])*2+Hi[s.w7-h.w7])*2+Hi[s.w8-h.w8])*2+Hi[s.w9-h.w9])*2+Hi[s.w10-h.w10])*2+Hi[s.w11-h.w11])*2+Hi[s.w12-h.w12])*2+Hi[s.w13-h.w13])*2+Hi[s.w14-h.w14])*2+Hi[s.w15-h.w15]]]
}; -- Get16
d: LONG POINTER TO CARDINAL _ LOOPHOLE[linePointer + bitOffset/16];
IF transparent THEN {
IF bitOffset MOD 16 # 0 THEN {
firstBits: INTEGER _ 16-(bitOffset MOD 16);
z: INTEGER _ MAX[firstBits-INTEGER[count], 0];
d^ _ Basics.BITOR[d^, Shift[GetN[firstBits-z], z]];
d _ d + 1;
count _ count - (firstBits-z);
};
WHILE count >= 16 DO
d^ _ Basics.BITOR[d^, Get16[]];
d _ d + 1;
count _ count - 16;
ENDLOOP;
IF count > 0 THEN {
d^ _ Basics.BITOR[d^, Shift[GetN[count], 16-count]];
};
}
ELSE {
IF bitOffset MOD 16 # 0 THEN {
firstBits: INTEGER _ 16-(bitOffset MOD 16);
z: INTEGER _ MAX[firstBits-INTEGER[count], 0];
m: CARDINAL _ Shift[1, firstBits] - Shift[1, z];
d^ _ Basics.BITOR[Basics.BITAND[d^, Basics.BITNOT[m]], Shift[GetN[firstBits-z], z]];
d _ d + 1;
count _ count - (firstBits-z);
};
WHILE count >= 16 DO
d^ _ Get16[];
d _ d + 1;
count _ count - 16;
ENDLOOP;
IF count > 0 THEN {
d^ _ Basics.BITOR[Basics.BITAND[d^, Shift[1, 16-count]-1], Shift[GetN[count], 16-count]];
};
};
};


END.
 ImagerSampleImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Michael Plass, November 1, 1985 9:19:12 am PST
Doug Wyatt, May 28, 1985 7:04:18 pm PDT










bb.src.word _ line+x/itemsPerWord;
bb.src.bit _ (x MOD itemsPerWord)*bitsPerItem;
bb.height _ Ceiling[(count-k)/itemsPerWord];

bb.dst.word _ line+x/itemsPerWord;
bb.dst.bit _ (x MOD itemsPerWord)*bitsPerItem;
bb.height _ Ceiling[(count-k)/itemsPerWord];
bb.src.word _ base+s*wordsPerLine+f/itemsPerWord;
bb.src.bit _ (f MOD itemsPerWord)*bitsPerItem;
bb.dst.word _ base+s*wordsPerLine+f/itemsPerWord;
bb.dst.bit _ (f MOD itemsPerWord)*bitsPerItem;
Now some paranoia about floating-point fuzz
A singular transformation means the image can't be shown anyway.
GetInterpolatedSamples: PUBLIC PROC [sampler: Sampler, sDest, fDest: CARDINAL, 
samples: Samples, startIndex: NAT _ 0, count: NAT] ~ TRUSTED {
lgEntry: LgEntry ~ lgArray[sampler.bitsPerSample];
base: LONG POINTER ~ sampler.base;
wordsPerLine: CARDINAL ~ sampler.wordsPerLine;
line: LONG POINTER _ base;
sLine: CARDINAL _ 0;
sSize: CARDINAL ~ sampler.sSize;
fSize: CARDINAL ~ sampler.fSize;
sfDelta: Basics.LongNumber ~ sampler.sfDelta;
ffDelta: Basics.LongNumber ~ sampler.ffDelta;
sSource: Basics.LongNumber _ sampler.sSource0;
fSource: Basics.LongNumber _ sampler.fSource0;
sDest0: CARDINAL _ sampler.sDest;
fDest0: CARDINAL _ sampler.fDest0;
IF sDest0=sDest THEN {
sSource _ sampler.sSource1;
fSource _ sampler.fSource1;
fDest0 _ sampler.fDest1;
}
ELSE {
ssDelta: Basics.LongNumber ~ sampler.ssDelta;
fsDelta: Basics.LongNumber ~ sampler.fsDelta;
WHILE sDest0<sDest DO
sSource.lc _ sSource.lc+ssDelta.lc;
fSource.lc _ fSource.lc+fsDelta.lc;
IF NOT sSource.hi<sSize THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fSize THEN fSource.hi _ fSource.hi-fSize;
sDest0 _ sDest0+1;
ENDLOOP;
sampler.sSource0 _ sSource;
sampler.fSource0 _ fSource;
sampler.sDest _ sDest0;
};
WHILE fDest0<fDest DO
sSource.lc _ sSource.lc+sfDelta.lc;
fSource.lc _ fSource.lc+ffDelta.lc;
IF NOT sSource.hi<sSize THEN sSource.hi _ sSource.hi-sSize;
IF NOT fSource.hi<fSize THEN fSource.hi _ fSource.hi-fSize;
fDest0 _ fDest0+1;
ENDLOOP;
IF sDest<sDest0 OR fDest<fDest0 THEN ERROR;
IF lgEntry.powerOfTwo THEN {
lgBitsPerSample: [0..4] ~ lgEntry.lg;
s: Scaled.Value _ LOOPHOLE[sSource];
f: Scaled.Value _ LOOPHOLE[fSource];
sDelta: Scaled.Value _ LOOPHOLE[ffDelta];
fDelta: Scaled.Value _ LOOPHOLE[ffDelta];
normalDelta: INT _ INT[sDelta.Floor]*wordsPerLine;
j: CARDINAL _ 0;
WHILE j < pixelSeq.fSize DO
IF NOT s.LESS[sMin] AND s.LESS[sMax] AND NOT f.LESS[fMin] AND f.LESS[fMax] THEN TRUSTED {
ss: Scaled.Value _ s.MINUS[Scaled.half];
ff: Scaled.Value _ f.MINUS[Scaled.half];
ssFloor: INTEGER _ ss.Floor;
lineOffset: INT _ INT[ss.Floor - source.sOrigin]*wordsPerLine;
toGo: INT _ pixelSeq.fSize-j;
IF sDelta.GREATER[Scaled.zero] THEN {
toGo _ MIN[toGo, TruncDiv[sMax.MINUS[s], sDelta]];
};
IF sDelta.LESS[Scaled.zero] THEN {
toGo _ MIN[toGo, TruncDiv[s.MINUS[sMin], sDelta.UMINUS]];
};
IF fDelta.GREATER[Scaled.zero] THEN {
toGo _ MIN[toGo, TruncDiv[fMax.MINUS[f], fDelta]];
};
IF fDelta.LESS[Scaled.zero] THEN {
toGo _ MIN[toGo, TruncDiv[f.MINUS[fMin], fDelta.UMINUS]];
};
THROUGH [0..INTEGER[toGo]) DO
k: INTEGER _ ff.Floor - source.fOrigin;
a: CARDINAL _ ss.fraction;
b: CARDINAL _ ff.fraction;
ab: CARDINAL _ Basics.HighHalf[Basics.LongMult[a, b]];
v00, v01, v10, v11: CARDINAL;
SELECT lgBitsPerPixel FROM
0 => {
p: LONG POINTER TO RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF [0..2)] _ LOOPHOLE[base + lineOffset];
v00 _ p[k]; v01 _ p[k + 1];
p _ p + wordsPerLine; v10 _ p[k]; v11 _ p[k + 1];
};
1 => {
p: LONG POINTER TO RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF [0..4)] _ LOOPHOLE[base + lineOffset];
v00 _ p[k]; v01 _ p[k + 1];
p _ p + wordsPerLine; v10 _ p[k]; v11 _ p[k + 1];
};
2 => {
p: LONG POINTER TO RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF [0..16)] _ LOOPHOLE[base + lineOffset];
v00 _ p[k]; v01 _ p[k + 1];
p _ p + wordsPerLine; v10 _ p[k]; v11 _ p[k + 1];
};
3 => {
p: LONG POINTER TO RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF [0..256)] _ LOOPHOLE[base + lineOffset];
v00 _ p[k]; v01 _ p[k + 1];
p _ p + wordsPerLine; v10 _ p[k]; v11 _ p[k + 1];
};
4 => {
p: LONG POINTER TO RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF CARDINAL] _ LOOPHOLE[base + lineOffset];
v00 _ p[k]; v01 _ p[k + 1];
p _ p + wordsPerLine; v10 _ p[k]; v11 _ p[k + 1];
};
ENDCASE => ERROR;
IF multiplier # 1 OR lgScale # 0 THEN {
v00 _ Basics.BITSHIFT[v00*multiplier, lgScale];
v01 _ Basics.BITSHIFT[v01*multiplier, lgScale];
v10 _ Basics.BITSHIFT[v10*multiplier, lgScale];
v11 _ Basics.BITSHIFT[v11*multiplier, lgScale];
};
pixelSeq[j] _ IF a=0 AND b=0 THEN v00 ELSE Basics.HighHalf[
Basics.LongMult[CARDINAL.LAST-a+ab-b+1, v00] +
Basics.LongMult[b-ab, v01] +
Basics.LongMult[a-ab, v10] +
Basics.LongMult[ab, v11]
];
ss _ LOOPHOLE[LOOPHOLE[ss, INT]+LOOPHOLE[sDelta, INT]];
ff _ LOOPHOLE[LOOPHOLE[ff, INT]+LOOPHOLE[fDelta, INT]];
lineOffset _ lineOffset + normalDelta;
ssFloor _ ssFloor + sDelta.Floor;
IF ssFloor < ss.Floor THEN {
ssFloor _ ssFloor + 1;
lineOffset _ lineOffset + wordsPerLine;
};
j _ j + 1;
ENDLOOP;
s _ ss.PLUS[Scaled.half];
f _ ff.PLUS[Scaled.half];
IF ssFloor # ss.Floor THEN ERROR;
};
IF j < pixelSeq.fSize THEN {
WHILE s.Floor < 0 DO s _ s.PLUS[Scaled.FromInt[sPixels]] ENDLOOP;
WHILE s.Floor >= sPixels DO s _ s.MINUS[Scaled.FromInt[sPixels]] ENDLOOP;
WHILE f.Floor < 0 DO f _ f.PLUS[Scaled.FromInt[fPixels]] ENDLOOP;
WHILE f.Floor >= fPixels DO f _ f.MINUS[Scaled.FromInt[fPixels]] ENDLOOP;
IF s.Floor IN [rect.sMin..rect.sMin+rect.sSize) AND f.Floor IN [rect.fMin..rect.fMin+rect.fSize) THEN {
pix: CARDINAL _ source.GetPixel[s.Floor, f.Floor];
pixelSeq[j] _ Basics.BITSHIFT[pix*multiplier, lgScale];
};
s _ s.PLUS[sDelta];
f _ f.PLUS[fDelta];
j _ j + 1;
};
ENDLOOP;
}
ELSE ERROR;
sampler.sSource1 _ sSource;
sampler.fSource1 _ fSource;
sampler.fDest1 _ fDest0+count;
};

Κ °˜
codeš
œ™Kšœ
Οm
œ7™BK™.K™'—K˜š
Οk	˜	Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ	˜	Kš
œ˜K˜Kš
œ˜—K˜KšΠblœžœ
ž˜KšžœI˜PKšžœ
˜Kšœžœ
žœ˜K˜Kš
œ!žœ
žœžœžœ	žœ
žœ˜LK˜Kšœ
žœ˜&Kšœžœ˜+K˜šΟn	œžœ
žœžœžœžœ˜cKšœžœ!˜*Kš
œ˜Kš
žœžœ
žœžœžœ˜BKš
œ%˜%Kšžœ˜K˜K™—Kšœžœ˜Kšœžœ˜Kš	œ	žœžœžœ
žœ˜=šœžœ˜K˜—š œžœ
žœ
žœžœžœžœ˜dKšžœ
žœžœ
˜Kšœžœ!˜*š	žœžœ
ž
œ
žœž˜.šžœžœ˜!Kš
œ˜Kšžœžœ'˜BKš
œ"˜"Kšœžœ
˜Kšžœ
˜Kš
œ˜—Kšžœ
˜—Kš
œ@˜@K˜K˜—š œžœ
žœ
žœ˜Bšžœžœ˜'Kš
œ ˜ Kš
œ"˜"Kš
œ
˜
—šžœ˜Kš
œ˜Kšœžœ˜&Kš
œ˜—K˜K™—š
 œžœ
žœžœ
žœ˜UKš
œ9˜9Kšœžœ"˜8Kš
œ˜K˜K™—K˜š
 	œžœ
žœžœžœ
˜MKšœžœX˜^Kšžœ˜K˜K˜—š 	œžœ
žœžœ˜LKšœžœX˜^Kš
œ˜K˜K˜—š
 
œžœ
žœ%žœžœ˜\KšœžœX˜^Kšžœ	žœ2˜AKšžœžœ
žœ˜)K˜K˜—K˜š 	œžœ
žœ
žœ)žœž	œ˜Xšžœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšžœ
˜—Kšžœžœ
žœ
žœžœžœ
˜BK˜K™—š 	œžœ
žœ
žœ)žœž	œ˜Xšžœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšžœ
˜—Kšžœžœ
žœ
žœžœžœ
˜BK˜K™—š œžœ
žœ
žœ'žœž	œ˜Yšžœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšžœ
˜—Kš
žœžœ
žœžœžœ
˜8K˜K™—š 
œžœ
žœ!žœ%žœ
žœ˜xKš
œ8˜8Kš
œ7˜7Kšžœ=˜DK˜K™—š 
œžœ
žœ!žœ%žœ
žœ˜xKš
œ8˜8Kš
œ7˜7Kšžœ=˜DK˜K™—š 
œžœ
žœ6žœ%žœ
žœ˜
Kš
œ0˜0Kš
œ8˜8Kš
œ7˜7Kšžœžœžœ
žœžœžœ˜FK˜K™—š œžœ
žœ2žœ$žœ
žœ˜Š
Kš
œ7˜7šžœž˜Kšœžœ
˜
˜Kš
œ2˜2Kš
œ7˜7Kšžœžœžœ
žœžœžœ˜FK˜—˜Kš
œ2˜2Kš
œ2˜2Kš
œ7˜7Kš
œ7˜7Kšžœžœžœ
žœžœ&žœ˜TK˜—˜Kš
œ2˜2Kš
œ2˜2Kš
œ2˜2Kš
œ7˜7Kš
œ7˜7Kš
œ7˜7Kšžœžœžœ
žœžœ4žœ˜bK˜—š	žœžœžœ
žœž˜%K˜šžœžœ
žœž˜!Jš
œ9˜9Jšžœ
˜—K˜ Kšžœ
˜——K˜K™—K˜Kš	œ	žœžœ
žœžœ˜6Kšœ	žœžœžœ	˜/šœ	žœ˜%K˜—š œžœ
žœžœ
˜+Kš	œ	žœžœžœžœ˜?šžœžœ
žœž˜#Kšœžœžœ
˜=Kšžœ
˜—Jšžœ
˜K˜K˜—š
œ)˜)Kšœžœ˜$Kšœžœ ˜/Kš
œ˜Kš
œ˜K˜—š 
œžœ
žœ
žœ!žœžœžœ
žœžœ"ž	œ˜₯
Kš
œ*˜*Kšœžœ
žœ)˜;K˜$Kš
œA˜AK˜Kšœžœžœ˜)Kš
œ6˜6šžœžœ˜Kšœžœ˜ Kšœ
žœ
žœ˜5Kšœžœ˜2Kšœžœ
žœ˜7Kš
œ%˜%Kšœžœ˜9Kš
œ ˜ Kš
œ˜š	žœžœ
žœžœž˜.Kšœžœ˜Kš
œ˜Kšœžœ˜7Kšœžœžœ$˜Nšœžœ.˜IKš
œ"™"Kšœžœ™.Kš
œ,™,—Kšœžœ˜Kšžœ
˜—K˜
—šžœ˜Kšœžœ
žœ%˜7Kš
œ˜Kš
œ'˜'Kš
œ˜Kš
œ#˜#Kšœžœ
˜!Kš
œ"˜"Kš
œ˜Kš
œ˜Kšœžœ˜K˜—K˜K™—š 
œžœ
žœ
žœ!žœžœžœ
žœžœfž	œ˜ι
Kš
œ*˜*Kšœžœ
žœ)˜;K˜$Kš
œA˜AK˜Kšœžœžœ&˜Mšžœžœ˜Kšœžœ˜ Kšœ
žœ
žœ˜5Kšœžœ˜2Kšœžœ
žœ˜7Kš
œ%˜%Kšœžœ˜AKš
œ˜Kš
œ˜š	žœžœ
žœžœž˜.Kšœžœ˜Kš
œ˜Kšœžœ˜7Kšœžœžœ$˜Nšœžœ.˜IKš
œ"™"Kšœžœ™.Kš
œ,™,—Kšœžœ˜Kšžœ
˜—K˜
—šžœ˜Kšœžœ
žœ%˜7Kš
œ˜Kš
œ'˜'Kš
œ ˜ Kš
œ#˜#Kšœžœ
˜!Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ˜K˜—K˜K˜K˜—š œžœ
žœ
žœ!žœžœ
žœ
žœžœž	œ˜Œ
Kšœžœ
žœ)˜;K˜$Kš
œA˜AK˜Kšœžœžœ˜)Kš
œ,˜,Kš
œ˜Kš
œ
˜
š	žœžœ
žœžœž˜-Kšœžœ˜Kš
œ˜Kš
œ!˜!Kšœžœ
˜Kšœ
žœ%˜:Kšœžœ˜Kšžœ
˜—K˜K˜—š 
œžœ
žœ
žœ!žœžœžœ
žœžœ"ž	œ˜₯
Kš
œ*˜*K˜$Kš
œA˜AK˜Kšœžœžœ˜)Kš
œ6˜6Kš
œ˜Kš
œ'˜'Kš
œ˜Kš
œ-˜-Kš
œ˜Kš
œ˜šžœžœ˜Kšœžœ˜ Kšœžœ˜2Kšœžœ
žœ˜7Kšœ;žœ˜Xšœžœžœ$˜NKš
œ1™1Kšœžœ™.—Kšœžœ˜K˜
—šžœ˜Kšœžœ
žœ%˜5Kš
œB˜BKšœžœ
˜Kšœžœ˜K˜—K˜K˜—š 
œžœ
žœ
žœ!žœžœžœ
žœžœfž	œ˜ι
Kš
œ*˜*K˜$Kš
œA˜AK˜Kšœžœžœ&˜MKš
œ%˜%Kš
œ˜Kš
œ'˜'Kš
œ ˜ Kš
œ˜Kš
œ˜šžœžœ˜Kšœžœ˜ Kšœžœ˜2Kšœžœ
žœ˜7Kšœ;žœ˜Xšœžœžœ$˜NKš
œ1™1Kšœžœ™.—Kšœžœ˜K˜
—šžœ˜Kšœžœ
žœ%˜5Kš
œB˜BKšœžœ
˜Kšœžœ˜K˜—K˜K˜—K˜š	œ
žœžœ
žœ
žœ˜$K˜—š
 œžœžœžœžœ˜)Kšžœ
žœžœ
žœ˜)Kšœžœ˜Kš
žœžœ
žœžœ
žœ˜&K˜K˜—š œžœžœžœžœžœ˜@Kš
œ˜šžœžœ˜Kšœ	žœ˜Kšœ	žœžœžœžœžœ˜NKš
œ<˜<K™+Kšžœ
žœ˜#Kšžœžœ˜$Kšžœžœ
žœ
˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š œžœ
žœ*˜KKšœžœ˜Kšœžœ˜Kšœžœ˜šœ@žœ˜JK™@—Kš
œ1˜1Kš
œ1˜1K˜Kšœ@žœ˜JKš
œ1˜1Kš
œ1˜1K˜K˜—š œžœ
žœ-žœ˜YKšœžœ˜Kšœžœ˜Kšœžœ˜KšœQžœ˜[Kš
œ7˜7Kš
œ7˜7Kš
œ˜Kš
œ˜K˜K˜—K˜Kšœ	žœžœΟc˜.Kšœ	žœžœ‘	˜/Kšœ	žœžœ‘	˜/Kšœ	žœžœ‘	˜/Kšœ	žœžœ‘
˜0K˜Kšœžœžœ
žœ
žœ
žœ
žœ
žœ
˜GKšœžœžœ
žœ
žœ
žœ
žœ
žœ
˜GKšœžœžœ
žœ
žœ
žœ
žœ
žœ
˜GKšœžœžœ
žœ
žœ
žœ
žœ
žœ
˜GKšœžœžœ
žœ
žœ
žœ
žœ
žœ
˜GK˜Kš	œ
žœžœ
žœ
žœ˜+Kš	œ
žœžœ
žœ
žœ˜+Kš	œ
žœžœ
žœ
žœ˜+Kš	œ
žœžœ
žœ
žœ˜+Kš	œ
žœžœ
žœ
žœ˜+K˜š œžœ
žœžœ!žœ
žœžœ˜Kš
œ2˜2Kš
œ:˜:Kšœžœ
žœ˜"Kšœžœ˜.Kšœžœ
žœ˜Kšœžœ˜Kšœžœ˜ Kšœžœ˜ Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kš
œ-˜-Kš
œ-˜-Kš
œ-˜-Kš
œ-˜-Kš
œ-˜-Kš
œ-˜-Kšœžœ˜ Kšœžœ˜ K˜šžœ	ž˜Kš
œ#˜#Kš
œ#˜#Kšžœ
žœžœ˜;Kšžœ
žœžœ˜;Kš
œ˜Kšžœ
˜—Kš
œ˜Kš
œ˜Kš
œ˜šžœ	ž˜Kš
œ#˜#Kš
œ#˜#Kšžœ
žœžœ˜;Kšžœ
žœžœ˜;K˜Kšžœ
˜—Kšžœ	žœ	žœ
žœ
˜!Kš
œ˜Kš
œ˜šžœžœ
žœž˜1šœžœžœ
žœž˜Kšžœžœ?˜WKšœ
žœ˜2Kš
œG˜GKšžœ
žœžœ˜:Kšžœ
žœžœ˜:Kšžœ
˜—šœžœžœ
žœž˜Kšžœžœ?˜WKšœ
žœ˜2Kš
œG˜GKšžœ
žœžœ˜:Kšžœ
žœžœ˜:Kšžœ
˜—šœžœžœ
žœž˜Kšžœžœ?˜WKšœ
žœ˜2Kš
œG˜GKšžœ
žœžœ˜:Kšžœ
žœžœ˜:Kšžœ
˜—šœžœžœ
žœž˜Kšžœžœ?˜WKšœ
žœ˜2Kš
œG˜GKšžœ
žœžœ˜:Kšžœ
žœžœ˜:Kšžœ
˜—šœžœžœ
žœž˜Kšžœžœ?˜WKšœ
žœ˜2Kš
œG˜GKšžœ
žœžœ˜:Kšžœ
žœžœ˜:Kšžœ
˜—Kšžœž˜—Kšžœ
žœ
˜Kš
œ˜K˜—š œžœ
žœ"žœ!žœ
žœžœ™Ž
Kš
œ2™2Kšœžœ
žœ™"Kšœžœ™.Kšœžœ
žœ™Kšœžœ™Kšœžœ™ Kšœžœ™ Kš
œ-™-Kš
œ-™-Kš
œ.™.Kš
œ.™.Kšœžœ™!Kšœžœ™"šžœžœ™Kš
œ™Kš
œ™Kš
œ™K™
—šžœ™Kš
œ-™-Kš
œ-™-šžœž™Kš
œ#™#Kš
œ#™#Kšžœ
žœžœ™;Kšžœ
žœžœ™;Kš
œ™Kšžœ
™—Kš
œ™Kš
œ™Kš
œ™K™—šžœž™Kš
œ#™#Kš
œ#™#Kšžœ
žœžœ™;Kšžœ
žœžœ™;K™Kšžœ
™—Kšžœžœžœ
žœ
™+šžœžœ™Kš
œ%™%Kšœžœ
™$Kšœžœ
™$Kšœžœ
™)Kšœžœ
™)Kšœ
žœžœ™2Kšœžœ™šžœž™šžœ
žœžœžœžœžœ
žœžœžœžœžœ
žœ™YKšœžœ™(Kšœžœ™(Kšœ	žœ™Kšœžœžœ)™>Kšœžœ™šžœžœžœ™%Kšœžœžœ™2Kš
œ™—šžœžœžœ™"Kšœžœžœžœ™9Kš
œ™—šžœžœžœ™%Kšœžœžœ™2Kš
œ™—šžœžœžœ™"Kšœžœžœžœ™9Kš
œ™—šžœžœž™Kšœžœ™'Kšœžœ™Kšœžœ™Kšœžœ*™6Kšœžœ
™šžœž™š
œ™Kšœžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœžœ™eKš
œ™Kš
œ1™1Kš
œ™—š
œ™Kšœžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœžœ™eKš
œ™Kš
œ1™1Kš
œ™—š
œ™Kšœžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœžœ™fKš
œ™Kš
œ1™1Kš
œ™—š
œ™Kšœžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ™gKš
œ™Kš
œ1™1Kš
œ™—š
œ™Kšœžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœžœ™gKš
œ™Kš
œ1™1Kš
œ™—Kšžœžœ
™—šžœžœ
žœ™'Kšœ
žœ™/Kšœ
žœ™/Kšœ
žœ™/Kšœ
žœ™/Kš
œ™—š	œžœžœžœžœ™;Kšœžœ
žœ™.Kš
œ™Kš
œ™Kš
œ™Kš
œ™—Kšœžœ
žœžœžœ	žœ™7Kšœžœ
žœžœžœ	žœ™7Kš
œ&™&Kš
œ!™!šžœžœ™Kš
œ™Kš
œ'™'Kš
œ™—K™
Kšžœ
™—Kšœžœ™Kšœžœ™Kšžœžœ
žœ
™!Kš
œ™—šžœžœ™Kšžœ
žœžœžœ
™AKšžœžœžœžœ
™IKšžœ
žœžœžœ
™AKšžœžœžœžœ
™Iš
žœ	žœ#žœ	žœ#žœ™gKšœžœ%™2Kšœžœ™7Kš
œ™—Kšœžœ	™Kšœžœ	™K™
Kš
œ™—Kšžœ
™—K™
—Kšžœ
žœ
™Kš
œ™Kš
œ™Kš
œ™Kš
œ™K™—K˜š
 œžœžœžœžœ
˜)Kšœžœžœžœ˜5K˜—š œžœžœžœžœžœ
˜:Kšœžœžœžœ˜+K˜—š	œžœžœ
ž	œ
žœ˜/KšœFž˜NKš
œ˜K˜—š œžœ
žœ
žœ.žœžœ
žœžœžœžœžœžœžœž	œ˜Ρ
Kšœ
žœ
žœ)˜BKšœžœ˜Kš	œžœ
žœ
žœžœ˜8Kš	œžœ
žœ
žœžœ˜;Kš
œžœžœžœ
žœ
žœžœ˜Aš œžœ
žœžœžœž	œ˜?Kšœžœ˜šžœž˜Kš
œ˜K˜
K˜
Kšžœ
˜—Kšžœ	žœžœ˜<Kšœ‘˜—š œžœ
žœ
žœžœž	œ˜3Kš
œ˜Kšœžœ˜#Kšœžœ˜#Kšžœ	žœ³˜ΘKšœ‘˜—Kšœžœ
žœ
žœ
žœžœ˜Cšžœ
žœ˜šžœžœžœ˜Kšœžœžœ˜+Kšœžœžœžœ˜.Kšœžœ"˜3K˜
Kš
œ˜Kš
œ˜—šžœ
ž˜Kšœžœ˜K˜
Kš
œ˜Kšžœ
˜—šžœžœ˜Kšœžœ#˜4Kš
œ˜—Kš
œ
˜
—šžœ˜šžœžœžœ˜Kšœžœžœ˜+Kšœžœžœžœ˜.Kšœžœ%˜0Kšœžœžœžœ#˜TK˜
Kš
œ˜K˜—šžœ
ž˜K˜
K˜
Kš
œ˜Kšžœ
˜—šžœžœ˜Kšœžœžœ:˜YKš
œ˜—Kš
œ˜—Kš
œ˜K˜—K˜Kšžœ
˜—…—SŠβ