DIRECTORY
Basics,
ImagerFont USING [BYTE, MapRope, XChar, XCharProc, XStringProc],
ImagerSample,
IO USING [PutChar, RopeFromROS, ROS, STREAM],
IPInterpreter USING [Any, Array, ArrayRep, BoundsCheckInteger, Bug, EqName, Even, Integer, IntegerFromAny, MasterError, maxInteger, NumberRep, RealFromAny, Vector, VectorClass, VectorClassRep, VectorRep, VectorShape],
PrincOps,
PrincOpsUtils,
Rope;

IPVectorImpl: CEDAR MONITOR
IMPORTS Basics, IO, IPInterpreter, ImagerFont, ImagerSample, PrincOpsUtils, Rope
EXPORTS IPInterpreter
~ BEGIN OPEN IPInterpreter;

ROPE: TYPE ~ Rope.ROPE;
BYTE: TYPE ~ ImagerFont.BYTE;
XChar: TYPE ~ ImagerFont.XChar;
XCharProc: TYPE ~ ImagerFont.XCharProc;
XStringProc: TYPE ~ ImagerFont.XStringProc;

Shape: PUBLIC PROC [v: Vector] RETURNS [VectorShape] ~ {
shape: VectorShape ~ v.class.shape[v];
[] _ BoundsCheckInteger[shape.lowerBound];
IF shape.size=0 THEN NULL
ELSE [] _ BoundsCheckInteger[shape.lowerBound+BoundsCheckInteger[shape.size-1]];
RETURN[shape];
};

Get: PUBLIC PROC [v: Vector, i: Integer] RETURNS [Any] ~ {
IF v.class.get # NIL THEN RETURN[v.class.get[v, BoundsCheckInteger[i]]]
ELSE {
val: INT _ v.class.getInteger[v, BoundsCheckInteger[i]];
RETURN[IF val=0 THEN zeroObj ELSE IF val=1 THEN oneObj ELSE NEW[NumberRep _ [int[val]]]];
};
};
zeroObj: Any ~ NEW[NumberRep _ [zero[0]]];
oneObj: Any ~ NEW[NumberRep _ [int[1]]];

GetInteger: PUBLIC PROC [v: Vector, i: Integer] RETURNS [Integer] ~ {
IF v.class.getInteger # NIL THEN RETURN[v.class.getInteger[v, BoundsCheckInteger[i]]];
RETURN[IntegerFromAny[v.class.get[v, BoundsCheckInteger[i]]]];
};

GetReal: PUBLIC PROC [v: Vector, i: Integer] RETURNS [REAL] ~ {
RETURN[RealFromAny[v.class.get[v, BoundsCheckInteger[i]]]];
};

GetProp: PUBLIC PROC [v: Vector, propName: Any] RETURNS [found: BOOL, value: Any] ~ {
IF v.class.getProp#NIL THEN [found, value] _ v.class.getProp[v, propName]
ELSE {
shape: VectorShape ~ Shape[v];
IF NOT Even[shape.size] THEN MasterError[$invalidPropVec, 
"Property vector has odd length"];
FOR i: INT _ 0, i+2 WHILE i<shape.size DO
j: Integer ~ BoundsCheckInteger[shape.lowerBound+i];
IF EqName[propName, Get[v, j]] THEN RETURN[found: TRUE, value: Get[v, j+1]];
ENDLOOP;
RETURN[found: FALSE, value: NIL];
};
};

GetP: PUBLIC PROC [v: Vector, propName: Any] RETURNS [value: Any] ~ {
found: BOOL _ FALSE;
[found, value] _ GetProp[v, propName];
IF NOT found THEN MasterError[$undefinedProperty, "Property not found"];
};

OutOfBounds: PROC ~ { MasterError[$boundsFault, "Vector index out of bounds"] };

RunSize: PUBLIC PROC [r: Vector] RETURNS [Integer] ~ {
shape: VectorShape ~ Shape[r];
sum: Integer _ 0; -- sum of the run lengths
IF shape.lowerBound#0 OR NOT Even[shape.size] THEN MasterError[$invalidRunVec, 
"Run vector has nonzero lower bound or odd length"];
FOR i: Integer _ 0, i+2 WHILE i<shape.size DO
run: Integer ~ GetInteger[r, i];
IF run>(maxInteger-sum) THEN MasterError[$boundsFault, 
"Sum of run sizes exceeds maxInteger"];
sum _ BoundsCheckInteger[sum+run];
ENDLOOP;
RETURN[sum];
};

RunGet: PUBLIC PROC [r: Vector, i: Integer] RETURNS [Any] ~ {
shape: VectorShape ~ Shape[r];
sum: Integer _ 0; -- sum of the run lengths
IF shape.lowerBound#0 OR NOT Even[shape.size] THEN MasterError[$invalidRunVec, 
"Run vector has nonzero lower bound or odd length"];
IF BoundsCheckInteger[i]=0 THEN OutOfBounds[];
FOR i: Integer _ 0, i+2 WHILE i<shape.size DO
run: Integer ~ GetInteger[r, i];
IF run>(maxInteger-sum) THEN MasterError[$boundsFault, 
"Sum of run sizes exceeds maxInteger"];
sum _ BoundsCheckInteger[sum+run];
IF i<=sum THEN RETURN[Get[r, i+1]];
ENDLOOP;
OutOfBounds[];
RETURN[NIL];
};

arrayClass: VectorClass ~ NEW[VectorClassRep _ [type: $Array,
shape: ArrayShape, get: ArrayGet]];

ArrayShape: PROC [v: Vector] RETURNS [VectorShape] ~ {
array: Array ~ NARROW[v.data];
RETURN[[lowerBound: BoundsCheckInteger[array.lowerBound], size: array.size]];
};

ArrayGet: PROC [v: Vector, i: Integer] RETURNS [Any] ~ {
array: Array ~ NARROW[v.data];
RETURN[array[BoundsCheckInteger[i]-BoundsCheckInteger[array.lowerBound]]];
};

MakeVecLU: PUBLIC PROC [l, u: Integer, pop: PROC RETURNS [Any]] RETURNS [Vector] ~ {
array: Array ~ NEW[ArrayRep[BoundsCheckInteger[u]-BoundsCheckInteger[l]+1] _ [lowerBound: l, array: ]];
FOR i: NAT DECREASING IN[0..array.size) DO array[i] _ pop[] ENDLOOP;
RETURN[NEW[VectorRep _ [class: arrayClass, data: array]]];
};

MakeVec: PUBLIC PROC [n: Integer, pop: PROC RETURNS [Any]] RETURNS [Vector] ~ {
array: Array ~ NEW[ArrayRep[n] _ [lowerBound: 0, array: ]];
FOR i: NAT DECREASING IN[0..array.size) DO array[i] _ pop[] ENDLOOP;
RETURN[NEW[VectorRep _ [class: arrayClass, data: array]]];
};

CopyArray: PROC [old: Array] RETURNS [new: Array] ~ {
new _ NEW[ArrayRep[old.size] _ [lowerBound: BoundsCheckInteger[old.lowerBound], array: ]];
FOR i: NAT IN[0..new.size) DO new[i] _ old[i] ENDLOOP;
};

VectorFromArray: PUBLIC PROC [array: Array] RETURNS [Vector] ~ {
RETURN[NEW[VectorRep _ [class: arrayClass, data: CopyArray[array]]]];
};

ArrayFromVector: PUBLIC PROC [v: Vector] RETURNS [Array] ~ {
IF v.class.type=$Array THEN {
array: Array ~ NARROW[v.data];
RETURN[CopyArray[array]];
}
ELSE {
shape: VectorShape ~ Shape[v];
array: Array ~ NEW[ArrayRep[shape.size] _ [lowerBound: BoundsCheckInteger[shape.lowerBound], array: ]];
FOR i: NAT IN[0..array.size) DO array[i] _ Get[v, array.lowerBound+i] ENDLOOP;
RETURN[array];
};
};


ZeroData: TYPE ~ REF ZeroDataRep;
ZeroDataRep: TYPE ~ RECORD[n: Integer];
zeroClass: VectorClass ~ NEW[VectorClassRep _ [type: $Zero,
shape: ZeroShape, get: ZeroGet]];

ZeroShape: PROC [v: Vector] RETURNS [VectorShape] ~ {
data: ZeroData ~ NARROW[v.data];
RETURN[[lowerBound: 0, size: data.n]];
};

ZeroGet: PROC [v: Vector, i: Integer] RETURNS [Any] ~ {
data: ZeroData ~ NARROW[v.data];
IF NOT i IN[0..data.n) THEN OutOfBounds[];
RETURN[NIL];
};

ZeroVec: PUBLIC PROC [n: Integer] RETURNS [Vector] ~ {
data: ZeroData ~ NEW[ZeroDataRep _ [n: BoundsCheckInteger[n]]];
RETURN[NEW[VectorRep _ [class: zeroClass, data: data]]];
};


MergedData: TYPE ~ REF MergedDataRep;
MergedDataRep: TYPE ~ RECORD[v1, v2: Vector];
mergedClass: VectorClass ~ NEW[VectorClassRep _ [type: $Merged,
shape: MergedShape, get: MergedGet, getProp: MergedGetProp]];

MergedShape: PROC [v: Vector] RETURNS [VectorShape] ~ {
data: MergedData ~ NARROW[v.data];
MasterError[$undefinedOperation, "SHAPE is undefined for merged property vector"];
RETURN[[0, 0]];
};

MergedGet: PROC [v: Vector, i: Integer] RETURNS [Any] ~ {
data: MergedData ~ NARROW[v.data];
MasterError[$undefinedOperation, "GET is undefined for merged property vector"];
RETURN[NIL];
};

MergedGetProp: PROC [v: Vector, propName: Any] RETURNS [found: BOOL, value: Any] ~ {
data: MergedData ~ NARROW[v.data];
[found, value] _ GetProp[data.v2, propName];
IF NOT found THEN [found, value] _ GetProp[data.v1, propName];
};

MergeProp: PUBLIC PROC [v1, v2: Vector] RETURNS [Vector] ~ {
data: MergedData ~ NEW[MergedDataRep _ [v1: v1, v2: v2]];
RETURN[NEW[VectorRep _ [class: mergedClass, data: data]]];
};


StringData: TYPE ~ REF StringDataRep;
StringDataRep: TYPE ~ RECORD[SEQUENCE size: NAT OF XChar];
stringClass: VectorClass ~ NEW[VectorClassRep _ [type: $String,
shape: StringShape, get: StringGet]];

StringShape: PROC [v: Vector] RETURNS [VectorShape] ~ {
s: StringData ~ NARROW[v.data];
RETURN[[lowerBound: 0, size: s.size]];
};

StringGet: PROC [v: Vector, i: Integer] RETURNS [Any] ~ {
s: StringData ~ NARROW[v.data];
char: XChar ~ s[i];
RETURN[NEW[NumberRep _ [int[LOOPHOLE[char, CARDINAL]]]]];
};

VectorFromString: PUBLIC PROC [string: XStringProc] RETURNS [Vector] ~ {
size, i: NAT _ 0;
s: StringData _ NIL;
count: XCharProc ~ { size _ size+1 };
store: XCharProc ~ { s[i] _ char; i _ i+1 };
string[count]; -- determine size
s _ NEW[StringDataRep[size]];
string[store]; -- store the characters
IF i#size THEN ERROR Bug;
RETURN[NEW[VectorRep _ [class: stringClass, data: s]]];
};

VectorFromRope: PUBLIC PROC [rope: ROPE] RETURNS [Vector] ~ {
xStringProc: XStringProc ~ {ImagerFont.MapRope[rope: rope, charAction: charAction]};
RETURN [VectorFromString[xStringProc]]
};

StringFromVector: PUBLIC PROC [v: Vector, charAction: XCharProc] ~ {
IF v.class.type=$String THEN {
s: StringData ~ NARROW[v.data];
FOR i: NAT IN[0..s.size) DO charAction[s[i]] ENDLOOP;
}
ELSE {
shape: VectorShape ~ Shape[v];
FOR i: INT IN[0..shape.size) DO
char: CARDINAL ~ GetInteger[v, shape.lowerBound+i];
charAction[LOOPHOLE[char]];
ENDLOOP;
};
};

RopeFromVector: PUBLIC PROC [v: Vector] RETURNS [ROPE] ~ {
stream: IO.STREAM ~ IO.ROS[];
set: BYTE _ 0;
charAction: PROC [char: XChar] ~ {
IF char.set#set THEN {
IO.PutChar[stream, VAL[255]];
IO.PutChar[stream, VAL[set _ char.set]];
};
IO.PutChar[stream, VAL[char.code]];
};
StringFromVector[v, charAction];
RETURN[IO.RopeFromROS[stream]];
};

packedByteClass: VectorClass ~ NEW[VectorClassRep _ [type: $PackedByte,
shape: PackedByteShape, getInteger: PackedByteGetInteger]];

PackedByteData: TYPE ~ REF PackedByteDataRep;
PackedByteDataRep: TYPE ~ RECORD [
bytes: ROPE,
size: INT,
bytesPerElement: NAT,
signed: BOOL
];

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

PackedByteGetInteger: PROC [v: Vector, i: Integer] RETURNS [Integer] ~ {
data: PackedByteData ~ NARROW[v.data];
start: INT ~ BoundsCheckInteger[i]*data.bytesPerElement;
char: CHAR _ Rope.Fetch[data.bytes, start];
val: INT _ ORD[char];
IF data.signed AND val >= 128 THEN val _ val - 256;
FOR i: INT IN [1..data.bytesPerElement) DO
char _ Rope.Fetch[data.bytes, start+i];
val _ Basics.DoubleShiftLeft[[li[val]], 8].li + ORD[char];
ENDLOOP;
RETURN[val];
};

VectorFromBytes: PUBLIC PROC [bytes: ROPE, bytesPerElement: NAT, signed: BOOL] RETURNS [Vector] ~ {
ropeSize: INT ~ Rope.Size[bytes];
bpe: [1..4] ~ bytesPerElement;
data: PackedByteData _ NEW[PackedByteDataRep _ [bytes: bytes, size: ropeSize/bpe, bytesPerElement: bytesPerElement, signed: signed]];
IF data.size*bpe # ropeSize THEN ERROR;
RETURN[NEW[VectorRep _ [class: packedByteClass, data: data]]];
};

packedBitClass: VectorClass ~ NEW[VectorClassRep _ [type: $PackedBits,
shape: PackedBitShape, getInteger: PackedBitGetInteger]];

PackedBitData: TYPE ~ REF PackedBitDataRep;
PackedBitDataRep: TYPE ~ RECORD [
bytes: ROPE,
size: INT,
dataBitsPerLine: NAT,
bytesPerLine: NAT
];

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

PackedBitGetInteger: PROC [v: Vector, i: Integer] RETURNS [Integer] ~ {
data: PackedBitData ~ NARROW[v.data];
index: LONG CARDINAL ~ BoundsCheckInteger[i];
line, dot, val: CARDINAL;
char: CHAR;
[quotient: line, remainder: dot] _ Basics.LongDivMod[index, data.dataBitsPerLine];
char _ Rope.Fetch[data.bytes, Basics.LongMult[line, data.bytesPerLine]+dot/8];
val _ Basics.BITSHIFT[ORD[char], INTEGER[dot MOD 8]-7] MOD 2;
RETURN[val];
};

VectorFromBits: PUBLIC PROC [bytes: ROPE, dataBitsPerLine, padBitsPerLine: NAT] RETURNS [Vector] ~ {
ropeSize: INT ~ Rope.Size[bytes];
totalBitsPerLine: NAT ~ dataBitsPerLine+padBitsPerLine;
bytesPerLine: NAT ~ totalBitsPerLine/8;
slop: [0..0] ~ totalBitsPerLine MOD 8;
lines: INT ~ ropeSize/bytesPerLine;
data: PackedBitData ~ NEW[PackedBitDataRep _ [bytes: bytes, size: lines*dataBitsPerLine, dataBitsPerLine: dataBitsPerLine, bytesPerLine: bytesPerLine]];
RETURN [NEW[VectorRep _ [class: packedBitClass, data: data]]]
};

scratchText: REF TEXT _ NIL;
ObtainScratch: ENTRY PROC [size: NAT] RETURNS [text: REF TEXT _ NIL] ~ {
ENABLE UNWIND => NULL;
IF scratchText#NIL AND scratchText.maxLength >= size THEN {text _ scratchText; text.length _ 0; scratchText _ NIL}
ELSE text _ NEW[TEXT[size]];
};

ReleaseScratch: ENTRY PROC [text: REF TEXT] ~ {
scratchText _ text;
};

UnsafeGetElements: PUBLIC UNSAFE PROC [vector: Vector, buffer: LONG POINTER TO Basics.RawWords, start: INT, count: NAT] ~ UNCHECKED {
IF vector.class = packedByteClass THEN {
data: PackedByteData ~ NARROW[vector.data];
byteCount: NAT ~ Basics.LongMult[count, data.bytesPerElement];
text: REF TEXT ~ ObtainScratch[byteCount];
startByte: INT ~ BoundsCheckInteger[start]*data.bytesPerElement;
zero: [0..0] ~ Rope.AppendChars[buffer: text, rope: data.bytes, start: startByte, len: byteCount]-byteCount;
bytePtr: LONG POINTER ~ LOOPHOLE[text, LONG POINTER] + SIZE[TEXT[0]];
ImagerSample.UnsafeGetF[samples: buffer, count: count, s: 0, f: 0, base: bytePtr, wordsPerLine: LAST[NAT], bitsPerSample: data.bytesPerElement*8];
ReleaseScratch[text];
}
ELSE {
FOR i: INT IN [0..count) DO
buffer[i] _ GetInteger[vector, start+i];
ENDLOOP;
};
};

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

UnsafeGetBits: PUBLIC UNSAFE PROC [vector: Vector, dst: PrincOps.BitAddress, start: INT, count: NAT, srcFunc: PrincOps.SrcFunc, dstFunc: PrincOps.DstFunc] ~ UNCHECKED {
IF vector.class = packedBitClass THEN {
data: PackedBitData ~ NARROW[vector.data];
text: REF TEXT ~ ObtainScratch[(CARDINAL[count]+7)/8];
index: INT _ BoundsCheckInteger[start];
residual: CARDINAL _ count;
dstBase: LONG POINTER _ dst.word;
dstBit: CARDINAL _ dst.bit;
bbTableSpace: PrincOps.BBTableSpace;
bb: PrincOps.BBptr ~ PrincOpsUtils.AlignedBBTable[@bbTableSpace];
bb^ _ nullBitBltTable;
bb.flags _ [disjoint: TRUE, gray: FALSE, srcFunc: srcFunc, dstFunc: dstFunc];
bb.height _ 1;
bb.src.word _ LOOPHOLE[text, LONG POINTER] + SIZE[TEXT[0]];
UNTIL residual = 0 DO
zero: [0..0];
line, dot, delta, byteCount: CARDINAL;
[quotient: line, remainder: dot] _ Basics.LongDivMod[index, data.dataBitsPerLine];
bb.width _ delta _ MIN[residual, NAT[data.dataBitsPerLine-dot]];
byteCount _ (delta+7)/8;
text.length _ 0;
zero _ Rope.AppendChars[buffer: text, rope: data.bytes, start: Basics.LongMult[line, data.bytesPerLine]+dot/8, len: byteCount]-byteCount;
bb.dst _ [word: dstBase, bit: dstBit];
bb.src.bit _ dot MOD 8;
PrincOpsUtils.BITBLT[bb];
dstBase _ dstBase + NAT[dstBit + delta] / bitsPerWord;
dstBit _ NAT[dstBit + delta] MOD bitsPerWord;
index _ index + delta;
residual _ residual - delta;
ENDLOOP;
ReleaseScratch[text];
}
ELSE ERROR; -- could do it, but it would be slow; avoid at a higher level.
};


END.
.IPVectorImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Doug Wyatt, May 30, 1985 6:01:25 pm PDT
Michael Plass, January 28, 1986 1:35:51 pm PST


We hope this does not happen very often.
InputVectorStreamData: TYPE ~ REF InputVectorStreamRecord; 
InputVectorStreamRecord: TYPE ~ RECORD [
v: Vector,
length: INT,
index: INT
];

InputVectorStreamProcs: REF StreamProcs ~ IO.CreateStreamProcs[
variety: $input, class: $InterpressVector,
getChar: InputVectorStreamGetChar,
endOf: InputVectorStreamEndOf,
getIndex: InputVectorStreamGetIndex,
setIndex: InputVectorStreamSetIndex,
getLength: InputVectorStreamGetLength
];
StreamFromVector: PUBLIC PROC [v: Vector, xxx: Xxx]
RETURNS [stream: STREAM] ~ {
RETURN[IO.CreateStream[InputVectorStreamProcs,
NEW[InputVectorStreamRecord _ [v: v, length: rope.Length[], index: 0]]]];
};
InputVectorStreamGetChar: PROC [self: STREAM] RETURNS [char: CHAR] ~ {
data: InputVectorStreamData ~ NARROW[self.streamData];
IF data.index >= data.length THEN ERROR IO.EndOfStream[self]
ELSE {
i: Integer ~ data.index/data.bytesPerElement;
char _ data.rope.InlineFetch[data.index];
data.index _ data.index + 1;
};
};
InputVectorStreamEndOf: PROC [self: STREAM] RETURNS [BOOL] ~ {
data: InputVectorStreamData ~ NARROW[self.streamData];
RETURN[data.index >= data.length];
};
InputVectorStreamGetIndex: PROC [self: STREAM] RETURNS [INT] ~ {
data: InputVectorStreamData ~ NARROW[self.streamData];
RETURN[data.index];
};
InputVectorStreamSetIndex: PROC [self: STREAM, index: INT] ~ {
data: InputVectorStreamData ~ NARROW[self.streamData];
IF index NOT IN [0 .. data.length] THEN ERROR IO.Error[$BadIndex, self];
data.index _ index;
};
InputVectorStreamGetLength: PROC [self: STREAM] RETURNS [length: INT] ~ {
data: InputVectorStreamData ~ NARROW[self.streamData];
RETURN[data.length];
};
Κ*˜
codeš
œ™Kšœ
Οm
œ7™BKš
œ'™'K™.—K™š
Οk	˜	K˜Kšœžœžœ*˜@K˜
Kšžœ
žœžœžœ˜-KšœžœΖ
˜Ω
Kš
œ	˜	Kš
œ˜Kš
œ˜—K˜KšΠblœžœ
ž˜Kšžœžœ>˜PKšžœ˜Kšœžœ
žœ˜K˜Kšžœžœžœ
˜Kšžœžœžœ
˜Kšœžœ˜Kšœžœ˜'Kšœ
žœ˜+K˜šΟnœžœ
žœ
žœ˜8Kš
œ&˜&Kš
œ*˜*Kšžœžœ
ž˜KšžœL˜PKšžœ˜Kš
œ˜K˜—š œžœ
žœžœ
˜:Kšžœžœ
žœ
žœ'˜Gšžœ˜Kšœžœ0˜8Kšžœ
žœžœ	žœ
žœžœžœ
žœ˜YKš
œ˜—Kš
œ˜—Kšœžœ˜*Kšœžœ˜(K˜š 
œžœ
žœžœ˜EKšžœžœ
žœ
žœ/˜VKšžœ8˜>K˜K˜—š
 œžœ
žœžœžœ˜?Kšžœ5˜;K˜K˜—š
 œžœ
žœžœ	žœ˜UKšžœžœ
žœ.˜Išžœ˜K˜Kšžœ
žœžœA˜]šžœžœ
žœž˜)Kš
œ4˜4Kšžœžœ
žœžœ˜LKšžœ
˜—Kšžœžœ	žœ˜!K˜—K˜K˜—š œžœ
žœžœ˜EKšœžœžœ
˜Kš
œ&˜&Kšžœ
žœžœ7˜HK˜K˜—š œžœ?˜PK˜—š œžœ
žœ
žœ˜6K˜KšœΟc˜+Kšžœžœ
žœžœR˜„
šžœžœž˜-Kš
œ ˜ KšžœžœC˜_Kš
œ"˜"Kšžœ
˜—Kšžœ˜K˜K˜—š œžœ
žœžœ
˜=K˜Kšœ‘˜+Kšžœžœ
žœžœR˜„
Kšžœžœ˜.šžœžœž˜-Kš
œ ˜ KšžœžœC˜_Kš
œ"˜"Kšžœžœ
žœ˜#Kšžœ
˜—Kš
œ˜Kšžœ
žœ˜K˜K˜—K™šœžœ ˜=Kš
œ#˜#K˜—š 
œžœ
žœ˜6Kšœžœ	˜KšžœG˜MK˜K˜—š œžœžœ
˜8Kšœžœ	˜KšžœD˜JKš
œ˜K˜—š 	œžœ
žœžœ
žœžœ
˜TKšœžœU˜gKšžœžœ
ž
œ
žœžœžœ
˜DKšžœ
žœ0˜:K˜K˜—š œžœ
žœžœ
žœžœ
˜OKšœžœ)˜;Kšžœžœ
ž
œ
žœžœžœ
˜DKšžœ
žœ0˜:K˜K˜—š 	œžœžœ˜5KšœžœQ˜ZKš
žœžœ
žœžœžœ
˜6K˜K˜—š œžœ
žœžœ
˜@Kšžœ
žœ;˜EK˜K˜—š œžœ
žœ
žœ˜<šžœžœ˜Kšœžœ	˜Kšžœ˜K˜
—šžœ˜K˜KšœžœU˜gKš
žœžœ
žœžœ'žœ
˜NKšžœ˜K˜—K˜K˜—K˜Kšœ
žœžœ
˜!Kšœ
žœžœ
˜'šœžœ˜;Kš
œ!˜!K˜—š 	œžœ
žœ˜5Kšœžœ	˜ Kšžœ ˜&K˜K˜—š œžœžœ
˜7Kšœžœ	˜ Kšžœ
žœžœžœ˜*Kšžœ
žœ˜Kš
œ˜K˜—š œžœ
žœžœ
˜6Kšœžœ+˜?Kšžœ
žœ.˜8K˜K˜—K˜Kšœžœžœ˜%Kšœžœžœ˜-šœžœ!˜?Kš
œ=˜=K˜—š œžœ
žœ˜7Kšœžœ	˜"Kš
œR˜RKšžœ	˜K˜K˜—š 	œžœžœ
˜9Kšœžœ	˜"Kš
œP˜PKšžœ
žœ˜Kš
œ˜K˜—š 
œžœžœ	žœ˜TKšœžœ	˜"K˜,Kšžœ
žœžœ-˜>Kš
œ˜K˜—š 	œžœ
žœžœ
˜<Kšœžœ#˜9Kšžœ
žœ0˜:K˜K˜—K˜Kšœžœžœ˜%Kšœžœžœ
žœžœ
žœ˜:šœžœ!˜?Kš
œ%˜%K˜—š œžœ
žœ˜7Kšœžœ	˜Kšžœ ˜&K˜K˜—š 	œžœžœ
˜9Kšœžœ	˜Kš
œ˜Kšžœ
žœžœžœ˜9Kš
œ˜K˜—š œžœ
žœžœ
˜HKšœ	žœ˜Kšœžœ
˜Kš
œ%˜%Kš
œ,˜,Kšœ‘˜ Kšœžœ˜Kšœ‘˜&Kšžœžœ
žœ˜Kšžœ
žœ-˜7K˜K˜—š
 œžœ
žœžœžœ
˜=Kš
œT˜TKšžœ ˜&K˜K˜—š œžœ
žœ'˜Dšžœžœ˜Kšœžœ	˜Kš
žœžœ
žœžœžœ
˜5K˜
—šžœ˜Kš
œ˜šžœžœ
žœž˜Kšœžœ%˜3Kšœžœ˜Kšžœ
˜—K˜—K˜K˜—š
 œžœ
žœ
žœžœ˜:Kš	œžœ
žœžœ
žœ˜Kšœžœ˜šœžœ˜"šžœžœ˜Kšžœžœ˜Kšžœžœ˜(K˜—Kšžœžœ
˜#Kš
œ˜—Kš
œ ˜ Kšžœ
žœ˜K˜K˜—šœžœ%˜GKš
œ;˜;K˜—Kšœžœžœ˜-šœžœžœ˜"Kšœžœ
˜Kšœžœ
˜
Kšœžœ
˜Kšœž˜Kš
œ˜K˜—š œžœ
žœ˜;Kšœžœ	˜&Kšžœ#˜)K˜K˜—š œžœžœ˜HKšœžœ	˜&Kšœžœ.˜8Kšœžœ!˜+Kšœžœžœ˜Kšžœ
žœžœ˜3šžœžœ
žœž˜*Kš
œ'˜'Kšœ0žœ˜:Kšžœ
˜—Kšžœ˜Kš
œ˜K˜—š œžœ
žœ	žœžœ
žœžœ
˜cKšœ
žœ˜!Kš
œ˜Kšœžœk˜…
Kšžœžœ
žœ
˜'Kšžœ
žœ4˜>Kš
œ˜K˜—šœžœ%˜FKš
œ9˜9K˜—Kšœžœžœ˜+šœžœžœ˜!Kšœžœ
˜Kšœžœ
˜
Kšœžœ
˜Kšœž˜Kš
œ˜K˜—š œžœ
žœ˜:Kšœžœ	˜%Kšžœ#˜)K˜K˜—š œžœžœ˜GKšœžœ	˜%Kšœžœ
žœ˜-Kšœžœ
˜Kšœžœ
˜Kš
œR˜RKš
œN˜NKšœ
žœ
žœžœžœžœ˜=Kšžœ˜Kš
œ˜K˜—š œžœ
žœ	žœ#žœžœ
˜dKšœ
žœ˜!Kšœžœ"˜7Kšœžœ˜'Kšœ žœ˜&Kšœžœ˜#Kšœžœ˜˜
Kšžœžœ2˜=Kš
œ˜K˜—Kšœ
žœ
žœžœ
˜š 
œžœ
žœžœžœžœ
žœžœ˜HKšžœ
žœžœ
˜Kš
žœ
žœ
žœžœ5žœ
˜rKšžœžœ
žœ˜Kš
œ˜K˜—š
 œžœ
žœžœ
žœ˜/Kš
œ˜Kš
œ˜K˜—š œžœ
žœ
žœžœ
žœ
žœžœ	žœž	œ˜…
šžœ žœ˜(Kšœžœ˜+Kšœžœ0˜>Kšœžœ
žœ˜*Kšœžœ2˜@Kš
œl˜lK•StartOfExpansion©
[samples: 
ImagerSample.UnsafeSamples, count: 
NAT, s: 
NAT _ 0, f: 
NAT _ 0, base: 
LONG POINTER, wordsPerLine: 
NAT, bitsPerSample: 
ImagerSample.BitsPerSample]šœ	žœ
žœžœžœ
žœžœ
žœ˜EKšœ`žœ
žœ*˜’
Kš
œ˜Kš
œ
˜
—šžœ˜K™(šžœžœ
žœž˜Kš
œ(˜(Kšžœ
˜—Kš
œ˜—Kš
œ˜K˜—Kšœ
žœ˜&š
œ)˜)Kšœžœ˜$Kšœžœ ˜/Kš
œ˜Kš
œ˜K˜—š 
œžœ
žœ
žœ3žœ	žœ:ž	œ˜¨
šžœžœ˜'Kšœžœ˜*Kšœžœ
žœžœ˜6Kšœžœ˜'Kšœ
žœ	˜Kšœ	žœ
žœ˜!Kšœžœ˜Kš
œ$˜$Kš
œA˜AK˜Kšœžœžœ&˜MKš
œ˜Kšœžœžœ
žœžœ
žœ˜;šžœž˜K˜
Kšœžœ
˜&Kš
œR˜RKšœžœžœ˜@Kš
œ˜Kš
œ˜Kš
œ‰
˜‰
Jš
œ&˜&Jšœžœ˜Jšœžœ˜Kšœžœ˜6Kšœ	žœžœ
˜-Kš
œ˜Kš
œ˜Kšžœ
˜—Kš
œ˜Kš
œ
˜
—Kšžœ
žœ‘>˜JKš
œ˜—K˜Kšœžœžœ™;šœžœžœ
™(Kš
œ
™
Kšœžœ
™Kšœž™
K™—K™šœžœ$™?Kš
œ*™*Kš
œ"™"Kš
œ™Kš
œ$™$Kš
œ$™$Kš
œ%™%K™—š œžœ
žœ™3Kšžœ
žœ™šžœ
žœ%™.KšžœF™I—Kš
œ™—š
 œžœžœžœžœ™FKšœžœ™6Kšžœžœ
žœ
žœ™<šžœ™K™-K™)K™K™—Kš
œ™—š
 œžœžœžœžœ™>Kšœžœ™6Kšžœ™"Kš
œ™—š
 œžœžœžœ
žœ™@Kšœžœ™6Kšžœ
™Kš
œ™—š œžœžœ	žœ™>Kšœžœ™6Kšžœžœ
žœžœ
žœ
žœ™HK™Kš
œ™—š
 œžœžœžœ	žœ™IKšœžœ™6Kšžœ™Kš
œ™—K˜Kšžœ
˜—…—7ςSJ