DIRECTORY
Basics USING [bitsPerWord, bytesPerWord, HighHalf, LongMult, LongNumber, LowHalf, UnsafeBlock],
CountedVM USING [Allocate, Handle],
FS USING [StreamOpen],
IO USING [Close, GetIndex, SetIndex, SetLength, STREAM, UnsafeGetBlock, UnsafePutBlock],
PDFileFormat USING [Command, ControlCom, DeviceCode, Herald, MaskRectangle, MaskRunGroupRef, MaskSamples, MaskSamplesRef, MaskTrapezoid, opaqueFlag, Run, SampleArray, SetColorTile, StartImage, Tile, Toner, transparentFlag],
PDFileWriter USING [CaptureRunProc, CaptureScanLineProc, DeliverRunGroupProc, DeliverSampleArrayProc, TFlag, TonerSet],
PrincOpsUtils USING [LongCopy],
Rope USING [ROPE];

PDFileWriterImpl: CEDAR PROGRAM
IMPORTS Basics, CountedVM, FS, IO, PrincOpsUtils
EXPORTS PDFileWriter
= BEGIN

BlockTransfer: UNSAFE PROC [source: LONG POINTER, count: CARDINAL, dest: LONG POINTER]
~ UNCHECKED INLINE {PrincOpsUtils.LongCopy[from: source, nwords: count, to: dest]};

LongBlockTransfer: UNSAFE PROC [source: LONG POINTER, count: INT, dest: LONG POINTER] ~ UNCHECKED {
WHILE count > LAST[CARDINAL] DO
BlockTransfer[source: source, count: LAST[CARDINAL], dest: dest];
source _ source + LAST[CARDINAL];
dest _ dest + LAST[CARDINAL];
count _ count - LAST[CARDINAL];
ENDLOOP;
IF count > 0 THEN BlockTransfer[source: source, count: count, dest: dest];
};

bytesPerWord: CARDINAL = Basics.bytesPerWord;
bitsPerWord: CARDINAL = Basics.bitsPerWord;
ROPE: TYPE = Rope.ROPE;
LoadReference: TYPE = NAT;
DeliverRunGroupProc: TYPE = PDFileWriter.DeliverRunGroupProc;
CaptureRunProc: TYPE = PDFileWriter.CaptureRunProc;
DeliverSampleArrayProc: TYPE = PDFileWriter.DeliverSampleArrayProc;
CaptureScanLineProc: TYPE = PDFileWriter.CaptureScanLineProc;
TFlag: TYPE = PDFileWriter.TFlag;
TonerSet: TYPE = PDFileWriter.TonerSet;
Toner: TYPE = PDFileFormat.Toner;

Bands: TYPE = REF BandsRec;
BandsRec: TYPE = RECORD [
bands: SEQUENCE maxBands: NAT OF Band
];

Band: TYPE = RECORD [
colorId: INT,
bandBuffer: BandBuffer
];

bandBufferSize: NAT = 200;
BandBuffer: TYPE = REF BandBufferRec;
BandBufferRec: TYPE = RECORD [
length: NAT _ 0,
overflowIndices: LIST OF INT _ NIL,
word: ARRAY [0..bandBufferSize) OF WORD
];

ColorDescriptor: TYPE = RECORD [
colorId: INT _ 0, -- bumped whenever the color changes.
enabled: BOOLEAN _ TRUE,
length: NAT _ 1,
command: PDFileFormat.Command.control _ [control[setColorInk]],
setColorTile: PDFileFormat.SetColorTile
];

maxLoadItems: CARDINAL _ 2000;
LoadDescription: TYPE = REF LoadDescriptionRep;
LoadDescriptionRep: TYPE = RECORD [
storageRef: REF, -- to protect against garbage collection
pointer: LONG POINTER,
words: INT,  -- at least as big as loadSizeInWords
count: NAT _ 0,
entries: SEQUENCE maxCount: NAT OF LoadEntryDescription
];

LoadEntryType: TYPE = {none, samples, runGroup, tile};
LoadEntryDescription: TYPE = RECORD [
loadEntryType: LoadEntryType,
offsetHighBits: [0..256),
offsetLowBits: CARDINAL,
pageOfMostRecentUse: CARDINAL,
numberOfPagesUsedIn: CARDINAL
];

PDState: PUBLIC TYPE = REF PDStateRec;
PDStateRec: PUBLIC TYPE = RECORD [
fileName: ROPE,
herald: PDFileFormat.Herald,
colorDescriptor: ARRAY Toner OF ColorDescriptor,
stream: IO.STREAM,
toners: TonerSet _ ALL[FALSE],
firstToner, lastToner: Toner _ black,
feed: BOOLEAN _ TRUE,
strip: BOOLEAN _ TRUE,
bands: ARRAY Toner OF Bands,
selectedBands: Bands _ NIL,
selectedBandNum: NAT _ 0,
sMinPage: CARDINAL,
sMaxPage: CARDINAL,
fMinPage: CARDINAL,
fMaxPage: CARDINAL,
currentImage: CARDINAL _ 1,
currentLoadLocation: INT _ 0,
loadWrittenLength: INT _ 0,
loadSizeInWords: INT,
leftOverMode: BOOLEAN,
priorityImportant: BOOLEAN,
loadDescription: LoadDescription,
overflowStream: IO.STREAM _ NIL
];

Create: PUBLIC PROC [fileName: ROPE, deviceCode: PDFileFormat.DeviceCode, sResolution, fResolution, imageSSize, imageFSize: CARDINAL, bandSSize: CARDINAL, copies: CARDINAL, leftOverMode: BOOLEAN, maxLoadWords: INT] RETURNS [pdState: PDState] = {
nBands: NAT;
pdState _ NEW [PDStateRec];
pdState.fileName _ fileName;
pdState.herald.deviceCode _ deviceCode;
pdState.herald.sResolution _ sResolution;
pdState.herald.fResolution _ fResolution;
nBands _ (imageSSize+bandSSize-1)/bandSSize;
pdState.herald.imageSSize _ pdState.sMinPage _ nBands*bandSSize;
pdState.herald.imageFSize _ pdState.fMinPage _ imageFSize;
pdState.herald.bandSSize _ bandSSize;
pdState.herald.maxLoadWord _ 0;
pdState.herald.copies _ copies;
pdState.loadSizeInWords _ maxLoadWords;
pdState.leftOverMode _ leftOverMode;
pdState.priorityImportant _ FALSE;
pdState.sMaxPage _ pdState.fMaxPage _ 0;
pdState.toners _ ALL[FALSE];
pdState.toners[black] _ TRUE;
pdState.feed _ pdState.strip _ TRUE;
pdState.bands[black] _ NEW [BandsRec[nBands]];
pdState.stream _ FS.StreamOpen[fileName, $create];
WriteHerald[pdState];
};

SetPriorityImportant: PUBLIC PROC [pdState: PDState, priorityImportant: BOOLEAN] RETURNS [previousValue: BOOLEAN] = {
previousValue _ pdState.priorityImportant;
pdState.priorityImportant _ priorityImportant;
};

StartImage: PUBLIC PROC [pdState: PDState, toners: TonerSet, feed, strip: BOOLEAN _ TRUE] ~ {
pdState.feed _ feed;
pdState.strip _ strip;
pdState.toners _ toners;
pdState.firstToner _ Toner.LAST;
pdState.lastToner _ Toner.FIRST;
FOR t: Toner IN [Toner.FIRST..Toner.LAST] DO
IF toners[t] THEN {
IF pdState.bands[t] = NIL THEN {
pdState.bands[t] _ NEW [BandsRec[pdState.bands[black].maxBands]];
};
IF pdState.firstToner = Toner.LAST THEN pdState.firstToner _ t;
pdState.lastToner _ t;
};
pdState.colorDescriptor[t] _ [
colorId: 0,
length: 1,
command: [control[setColorInk]],
setColorTile: [addr: 0],
enabled: toners[t]
];
ENDLOOP;
};

SetColorInk: PUBLIC PROC [pdState: PDState, toner: Toner] = {
IF NOT pdState.toners[toner] THEN ERROR;
pdState.colorDescriptor[toner].colorId _ pdState.colorDescriptor[toner].colorId + 1;
pdState.colorDescriptor[toner].length _ SIZE[PDFileFormat.Command];
pdState.colorDescriptor[toner].command _ [control[setColorInk]];
pdState.colorDescriptor[toner].enabled _ TRUE;
};

SetColorClear: PUBLIC PROC [pdState: PDState, toner: Toner] = {
IF NOT pdState.toners[toner] THEN ERROR;
pdState.colorDescriptor[toner].colorId _ pdState.colorDescriptor[toner].colorId + 1;
pdState.colorDescriptor[toner].length _ SIZE[PDFileFormat.Command];
pdState.colorDescriptor[toner].command _ [control[setColorClear]];
pdState.colorDescriptor[toner].enabled _ TRUE;
};

SetColorOff: PUBLIC PROC [pdState: PDState, toner: Toner] = {
pdState.colorDescriptor[toner].enabled _ FALSE;
};

SetColorTile: PUBLIC PROC [pdState: PDState, toner: Toner, tileRef: LoadReference, tFlag: TFlag] = TRUSTED {
loadEntry: LoadEntryDescription _ pdState.loadDescription[tileRef];
reference: Basics.LongNumber _ [num[lowbits: loadEntry.offsetLowBits, highbits: loadEntry.offsetHighBits]];
colorId: INT _ pdState.colorDescriptor[toner].colorId + 1;
tBit: [0..1] = IF tFlag = opaque THEN PDFileFormat.opaqueFlag ELSE PDFileFormat.transparentFlag;
IF loadEntry.loadEntryType # tile THEN ERROR;
IF NOT pdState.toners[toner] THEN ERROR;
pdState.colorDescriptor[toner] _ [
colorId: colorId,
length: SIZE[PDFileFormat.Command] + SIZE[PDFileFormat.SetColorTile],
command: [control[setColorTile, tBit]],
setColorTile: [addr: reference.lc],
enabled: TRUE
];
};

DoForEachToner: PUBLIC PROC [pdState: PDState, proc: PROC[Toner]] = {
FOR toner: Toner IN [pdState.firstToner..pdState.lastToner] DO
IF pdState.toners[toner] THEN proc[toner];
ENDLOOP;
};

GetBounds: PUBLIC PROC [pdState: PDState] RETURNS [sMax, fMax: CARDINAL] = {
sMax _ pdState.herald.imageSSize;
fMax _ pdState.herald.imageFSize;
};

MaskRectangle: PUBLIC PROC [pdState: PDState, sMin, fMin: CARDINAL, sSize, fSize: CARDINAL] = TRUSTED {
sEnd: CARDINAL _ IF pdState.leftOverMode THEN sMin+1 ELSE sMin + sSize;
bandSSize: CARDINAL _ pdState.herald.bandSSize;
command: PDFileFormat.Command _ [imaging[maskRectangle, 0]];
maskArgs: PDFileFormat.MaskRectangle _ [sMin:sMin, sSize:sSize, fMin:fMin, fSize:fSize];
ExtendBB[pdState, sMin, fMin];
ExtendBB[pdState, sMin + sSize, fMin + fSize];
FOR toner: Toner IN [pdState.firstToner..pdState.lastToner] DO
IF pdState.colorDescriptor[toner].enabled THEN {
nextBandStart: CARDINAL _ sMin + (bandSSize - (sMin MOD bandSSize));
SelectBand[pdState, sMin, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @maskArgs, SIZE[PDFileFormat.MaskRectangle]];
FOR s: CARDINAL _ nextBandStart, s + bandSSize WHILE s<sEnd DO
SelectBand[pdState, s, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @maskArgs, SIZE[PDFileFormat.MaskRectangle]];
ENDLOOP;
};
ENDLOOP;
};

MaskTrapezoid: PUBLIC PROC [pdState: PDState, sMin, sSize: CARDINAL, fMin, fSize: CARDINAL, fMinLast, fSizeLast: CARDINAL] = TRUSTED {
sEnd: CARDINAL _ IF pdState.leftOverMode THEN sMin+1 ELSE sMin + sSize;
bandSSize: CARDINAL _ pdState.herald.bandSSize;
command: PDFileFormat.Command _ [imaging[maskTrapezoid, 0]];
maskArgs: PDFileFormat.MaskTrapezoid _ [sMin:sMin, sSize:sSize, fMin:fMin, fSize:fSize, fMinLast:fMinLast, fSizeLast:fSizeLast];
ExtendBB[pdState, sMin, MIN[fMin, fMinLast]];
ExtendBB[pdState, sMin + sSize, MAX[fMin + fSize, fMinLast + fSizeLast]];
FOR toner: Toner IN [pdState.firstToner..pdState.lastToner] DO
IF pdState.colorDescriptor[toner].enabled THEN {
nextBandStart: CARDINAL _ sMin + (bandSSize - (sMin MOD bandSSize));
SelectBand[pdState, sMin, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @maskArgs, SIZE[PDFileFormat.MaskTrapezoid]];
FOR s: CARDINAL _ nextBandStart, s + bandSSize WHILE s<sEnd DO
SelectBand[pdState, s, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @maskArgs, SIZE[PDFileFormat.MaskTrapezoid]];
ENDLOOP;
};
ENDLOOP;
};

MaskSamplesRef: PUBLIC PROC [pdState: PDState, samplesRef: LoadReference, sMin: CARDINAL, fMin: CARDINAL] = TRUSTED {
loadEntry: LoadEntryDescription _ pdState.loadDescription[samplesRef];
reference: Basics.LongNumber _ [num[lowbits: loadEntry.offsetLowBits, highbits: loadEntry.offsetHighBits]];
command: PDFileFormat.Command _ [imaging[maskSamplesRef, loadEntry.offsetHighBits]];
args: PDFileFormat.MaskSamplesRef _ [
addrLowBits: loadEntry.offsetLowBits,
sMin: sMin,
fMin: fMin
];
sampleArrayPtr: LONG POINTER TO PDFileFormat.SampleArray _ pdState.loadDescription.pointer + reference.lc;
sEnd: CARDINAL _ IF pdState.leftOverMode THEN sMin+1 ELSE sMin + sampleArrayPtr^.sSize;
bandSSize: CARDINAL _ pdState.herald.bandSSize;
IF loadEntry.loadEntryType # samples THEN ERROR;
ExtendBB[pdState, sMin, fMin];
ExtendBB[pdState, sMin + sampleArrayPtr^.sSize, fMin + sampleArrayPtr^.fSize];
FOR toner: Toner IN [pdState.firstToner..pdState.lastToner] DO
IF pdState.colorDescriptor[toner].enabled THEN {
nextBandStart: CARDINAL _ sMin + (bandSSize - (sMin MOD bandSSize));
SelectBand[pdState, sMin, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @args, SIZE[PDFileFormat.MaskSamplesRef]];
FOR s: CARDINAL _ nextBandStart, s + bandSSize WHILE s<sEnd DO
SelectBand[pdState, s, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @args, SIZE[PDFileFormat.MaskSamplesRef]];
ENDLOOP;
};
ENDLOOP;
};

MaskSamples: PUBLIC PROC [pdState: PDState, sMin: CARDINAL, fMin: CARDINAL, sSize: CARDINAL, fSize: CARDINAL, deliverProc: DeliverSampleArrayProc] = TRUSTED {
command: PDFileFormat.Command _ [imaging[maskSamples, 0]];
bandSSize: CARDINAL = pdState.herald.bandSSize;
wordsPerLine: NAT _ (fSize+(bitsPerWord-1))/bitsPerWord;
ExtendBB[pdState, sMin, fMin];
ExtendBB[pdState, sMin + sSize, fMin + fSize];
FOR toner: Toner IN [pdState.firstToner..pdState.lastToner] DO
IF pdState.colorDescriptor[toner].enabled THEN {
s: CARDINAL _ sMin;
sEnd: CARDINAL _ sMin + sSize;
residualThisBand: NAT _ 0;
scanLineProc: PROC [scanLineDataPointer: LONG POINTER] = TRUSTED {
IF residualThisBand = 0 THEN {
args: PDFileFormat.MaskSamples _ [
sMin: s,
fMin: fMin
];
truncatedEnd: CARDINAL _ MIN[sEnd, s + (bandSSize - (s MOD bandSSize))];
sampleArray: PDFileFormat.SampleArray _ [
sSize: (residualThisBand _ truncatedEnd - s),
fSize: fSize
];
SelectBand[pdState, s, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @args, SIZE[PDFileFormat.MaskSamples]];
EnterBandData[pdState, @sampleArray, SIZE[PDFileFormat.SampleArray]];
};
EnterBandData[pdState, scanLineDataPointer, wordsPerLine];
residualThisBand _ residualThisBand - 1;
s _ s + 1;
};
deliverProc[scanLineProc];
IF residualThisBand # 0 THEN ERROR;
IF s # sEnd THEN ERROR;
};
ENDLOOP;
};

MaskRunGroupRef: PUBLIC PROC [pdState: PDState, runGroupRef: LoadReference, sMin: CARDINAL, fMin: CARDINAL] = TRUSTED {
loadEntry: LoadEntryDescription _ pdState.loadDescription[runGroupRef];
reference: Basics.LongNumber _ [num[lowbits: loadEntry.offsetLowBits, highbits: loadEntry.offsetHighBits]];
command: PDFileFormat.Command _ [imaging[maskRunGroupRef, loadEntry.offsetHighBits]];
args: PDFileFormat.MaskRunGroupRef _ [
addrLowBits: loadEntry.offsetLowBits,
sMin: sMin,
fMin: fMin
];
fSizePtr: LONG POINTER TO CARDINAL _ pdState.loadDescription.pointer + reference.lc - 1;
sSizePtr: LONG POINTER TO CARDINAL _ pdState.loadDescription.pointer + reference.lc;
sEnd: CARDINAL _ IF pdState.leftOverMode THEN sMin+1 ELSE sMin + sSizePtr^;
bandSSize: CARDINAL _ pdState.herald.bandSSize;
IF loadEntry.loadEntryType # runGroup THEN ERROR;
ExtendBB[pdState, sMin, fMin];
ExtendBB[pdState, sMin + sSizePtr^, fMin + fSizePtr^];
FOR toner: Toner IN [pdState.firstToner..pdState.lastToner] DO
IF pdState.colorDescriptor[toner].enabled THEN {
nextBandStart: CARDINAL _ sMin + (bandSSize - (sMin MOD bandSSize));
SelectBand[pdState, sMin, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @args, SIZE[PDFileFormat.MaskRunGroupRef]];
FOR s: CARDINAL _ nextBandStart, s + bandSSize WHILE s<sEnd DO
SelectBand[pdState, s, toner];
EnterBandData[pdState, @command, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @args, SIZE[PDFileFormat.MaskRunGroupRef]];
ENDLOOP;
};
ENDLOOP;
};

MaskRunGroup: PUBLIC PROC [pdState: PDState, deliverProc: DeliverRunGroupProc] = {
maxRuns: NAT = bandBufferSize/SIZE[PDFileFormat.Run];
bandSSize: CARDINAL = pdState.herald.bandSSize;
buffer: MACHINE DEPENDENT RECORD [
command: PDFileFormat.Command _ [imaging[maskRunGroup]],
sMin: CARDINAL,
sSize: CARDINAL,
run: ARRAY [0..maxRuns) OF PDFileFormat.Run
];
nRuns: NAT _ 0;
scanLineNumber: CARDINAL;
bandEnd: CARDINAL;
currentToner: Toner;
PutBuffer: PROC = TRUSTED {
IF nRuns > 0 THEN {
IF NOT buffer.run[nRuns - 1].lastRun THEN {
buffer.sSize _ buffer.sSize + 1;
buffer.run[nRuns - 1].lastRun _ TRUE;
};
SelectBand[pdState, buffer.sMin, currentToner];
EnterBandData[pdState, @buffer, SIZE[PDFileFormat.Command] + SIZE[CARDINAL] + SIZE[CARDINAL] + nRuns * SIZE[PDFileFormat.Run]];
nRuns _ 0;
buffer.sMin _ scanLineNumber;
buffer.sSize _ 0;
};
};
InitBuffer: PROC [sMin: CARDINAL] = {
buffer.sMin _ scanLineNumber _ sMin;
buffer.sSize _ 0;
bandEnd _ sMin - sMin MOD bandSSize + bandSSize;
};
BufferRun: PROC [fMin, fSize: CARDINAL] = INLINE {
IF nRuns = maxRuns THEN PutBuffer[];
buffer.run[nRuns] _ [fMin: fMin, fSize: fSize, lastRun: FALSE];
nRuns _ nRuns + 1;
};
NextLine: PROC = INLINE {
buffer.sSize _ buffer.sSize + 1;
buffer.run[nRuns - 1].lastRun _ TRUE;
scanLineNumber _ scanLineNumber + 1;
};
CaptureRun: PROC [sMin, fMin: INTEGER, fSize: NAT] = {
CaptureCardinalRun[sMin, fMin, fSize];
};
CaptureCardinalRun: PROC [sMin, fMin, fSize: CARDINAL] = INLINE {
IF nRuns = 0 THEN InitBuffer[sMin]
ELSE IF sMin >= bandEnd OR NOT (sMin IN [scanLineNumber..scanLineNumber+1]) OR nRuns = maxRuns THEN {PutBuffer[]; InitBuffer[sMin]};
IF sMin > scanLineNumber THEN NextLine[];
IF sMin # scanLineNumber THEN ERROR;
IF INT[fMin] + INT[fSize] > INT[LAST[CARDINAL]] THEN {fSize _ LAST[CARDINAL] - fMin};
ExtendBB[pdState, sMin, fMin];
IF fSize > LAST[NAT] THEN {
BufferRun[fMin, LAST[NAT]];
fMin _ fMin + LAST[NAT]; fSize _ fSize - LAST[NAT];
};
BufferRun[fMin, fSize];
ExtendBB[pdState, sMin + 1, fMin + fSize];
};
FOR toner: Toner IN [pdState.firstToner..pdState.lastToner] DO
IF pdState.colorDescriptor[toner].enabled THEN {
currentToner _ toner;
deliverProc[CaptureRun];
PutBuffer[];
};
ENDLOOP;
};

NewPriorityLevel: PUBLIC PROC [pdState: PDState, toner: Toner] = {
IF NOT pdState.toners[toner] THEN ERROR;
pdState.colorDescriptor[toner].colorId _ pdState.colorDescriptor[toner].colorId + 1;
pdState.colorDescriptor[toner].length _ 0;
pdState.colorDescriptor[toner].enabled _ TRUE;
};

ColorSamples: PUBLIC PROC [pdState: PDState, toner: Toner, sMin, fMin: CARDINAL, sSize, fSize: CARDINAL, deliverProc: DeliverSampleArrayProc, tFlag: TFlag] = TRUSTED {
colorCommand: PDFileFormat.Command _ [imaging[IF tFlag = opaque THEN colorSamples ELSE maskSamples]];
bandSSize: CARDINAL = pdState.herald.bandSSize;
wordsPerLine: NAT _ (fSize+(bitsPerWord-1))/bitsPerWord;
s: CARDINAL _ sMin;
sEnd: CARDINAL _ sMin + sSize;
residualThisBand: NAT _ 0;
CaptureScanLine: PROC [scanLineDataPointer: LONG POINTER] = TRUSTED {
IF residualThisBand = 0 THEN {
args: PDFileFormat.MaskSamples _ [
sMin: s,
fMin: fMin
];
truncatedEnd: CARDINAL _ MIN[sEnd, s + bandSSize - (s MOD bandSSize)];
sampleArray: PDFileFormat.SampleArray _ [
sSize: (residualThisBand _ truncatedEnd - s),
fSize: fSize
];
SelectBand[pdState, s, toner];
EnterBandData[pdState, @colorCommand, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @args, SIZE[PDFileFormat.MaskSamples]];
EnterBandData[pdState, @sampleArray, SIZE[PDFileFormat.SampleArray]];
};
EnterBandData[pdState, scanLineDataPointer, wordsPerLine];
residualThisBand _ residualThisBand - 1;
s _ s + 1;
};
IF pdState.colorDescriptor[toner].enabled THEN {
ExtendBB[pdState, sMin, fMin];
ExtendBB[pdState, sMin + sSize, fMin + fSize];
deliverProc[CaptureScanLine];
IF residualThisBand # 0 THEN ERROR;
IF s # sEnd THEN ERROR;
};
};

RemainingLoadSize: PUBLIC PROC [pdState: PDState] RETURNS [words: INT] = {
words _ pdState.loadSizeInWords - pdState.currentLoadLocation;
IF pdState.loadDescription # NIL AND pdState.loadDescription.count = pdState.loadDescription.maxCount THEN words _ 0;
};

GetLoadDescription: PROC [pdState: PDState] RETURNS [LoadDescription] = {
IF pdState.loadDescription = NIL THEN {
loadDescription: LoadDescription _ NEW[LoadDescriptionRep[maxLoadItems]];
countedVM: CountedVM.Handle _ CountedVM.Allocate[pdState.loadSizeInWords];
loadDescription.storageRef _ countedVM;
loadDescription.pointer _ countedVM.pointer;
loadDescription.words _ countedVM.words;
loadDescription.count _ 0;
pdState.loadDescription _ loadDescription;
};
RETURN [pdState.loadDescription]
};

loadBreakOffset: INT _ LAST[INT];
loadBreakCount: INT _ 0;
DebugLoad: PROC [loadOffset: INT] ~ {
IF loadOffset = loadBreakOffset THEN
loadBreakCount _ loadBreakCount + 1;
};

LoadRunGroup: PUBLIC PROC [pdState: PDState, deliverProc: DeliverRunGroupProc] RETURNS [loadReference: LoadReference] = TRUSTED {
highBit: CARDINAL = CARDINAL[LAST[NAT]] + 1;
loadDescription: LoadDescription _ GetLoadDescription[pdState];
scanLineNumber: CARDINAL _ 0;
maxLoc: INT _ pdState.loadSizeInWords;
loc: INT _ pdState.currentLoadLocation;
base: LONG POINTER TO CARDINAL _ loadDescription.pointer;
fMax: CARDINAL _ 0;
scanLineEmpty: BOOLEAN _ TRUE;
CaptureRun: PROC [sMin, fMin: INTEGER, fSize: NAT] = CHECKED {
CaptureCardinalRun[sMin, fMin, fSize];
};
CaptureCardinalRun: PROC [sMin, fMin, fSize: CARDINAL] = TRUSTED INLINE {
IF sMin<scanLineNumber THEN ERROR; -- scan lines must come in increasing s order.
WHILE sMin#scanLineNumber DO
IF loc+2 > maxLoc THEN ERROR;
IF scanLineEmpty THEN {(base+loc)^ _ 0; (base+loc+1)^ _ highBit; loc _ loc+2}
ELSE {(base+loc-1)^ _ (base+loc-1)^ + highBit};
scanLineNumber _ scanLineNumber+1;
scanLineEmpty _ TRUE;
ENDLOOP;
scanLineEmpty _ FALSE;
IF INT[fMin] + INT[fSize] > INT[LAST[CARDINAL]] THEN {fSize _ LAST[CARDINAL] - fMin};
IF fSize > LAST[NAT] THEN {
IF loc+2 > maxLoc THEN ERROR;
(base+loc)^ _ fMin; (base+loc+1)^ _ LAST[NAT]; loc _ loc+2;
fMin _ fMin + LAST[NAT]; fSize _ fSize - LAST[NAT];
};
IF loc+2 > maxLoc THEN ERROR;
(base+loc)^ _ fMin; (base+loc+1)^ _ fSize; loc _ loc+2;
fMax _ MAX[fMax, fMin+fSize];
};
origin: INT _ loc+1;
loc _ loc + 2;
IF loc > maxLoc THEN ERROR;
deliverProc[CaptureRun];
IF NOT scanLineEmpty THEN {(base+loc-1)^ _ (base+loc-1)^ + highBit; scanLineNumber _ scanLineNumber+1};
(base+origin-1)^ _ fMax;
(base+origin)^ _ scanLineNumber;
pdState.currentLoadLocation _ loc;
pdState.herald.maxLoadWord _ MAX[pdState.herald.maxLoadWord, loc];
loadReference _ loadDescription.count;
loadDescription.count _ loadDescription.count + 1;
loadDescription[loadReference] _ [
loadEntryType: runGroup,
offsetHighBits: Basics.HighHalf[origin],
offsetLowBits: Basics.LowHalf[origin],
pageOfMostRecentUse: 0,
numberOfPagesUsedIn: 0
];
DebugLoad[origin];
};

LoadContiguousSampleArray: PUBLIC PROC [pdState: PDState, sSize, fSize: CARDINAL, bitsPtr: LONG POINTER] RETURNS [loadReference: LoadReference] = TRUSTED {
loadDescription: LoadDescription _ GetLoadDescription[pdState];
source: LONG POINTER TO WORD _ bitsPtr;
wordsPerLine: NAT _ (fSize+(bitsPerWord-1))/bitsPerWord;
words: INT _ Basics.LongMult[sSize, wordsPerLine];
startOffset: INT _ pdState.currentLoadLocation;
destOffset: INT _ startOffset + SIZE[PDFileFormat.SampleArray];
endOffset: INT _ destOffset + words;
sampleArray: LONG POINTER TO PDFileFormat.SampleArray _ loadDescription.pointer + startOffset;
destBase: LONG POINTER TO WORD _ loadDescription.pointer + destOffset;
IF endOffset > pdState.loadSizeInWords THEN ERROR;
sampleArray.sSize _ sSize;
sampleArray.fSize _ fSize;
LongBlockTransfer[source: source, count: words, dest: destBase];
loadReference _ loadDescription.count;
loadDescription.count _ loadDescription.count + 1;
loadDescription[loadReference] _ [
loadEntryType: samples,
offsetHighBits: Basics.HighHalf[startOffset],
offsetLowBits: Basics.LowHalf[startOffset],
pageOfMostRecentUse: 0,
numberOfPagesUsedIn: 0
];
pdState.currentLoadLocation _ endOffset;
pdState.herald.maxLoadWord _ MAX[pdState.herald.maxLoadWord, endOffset];
DebugLoad[startOffset];
};

LoadContiguousColorTile: PUBLIC PROC [pdState: PDState, phase: CARDINAL, sMin, fMin: CARDINAL, sSize, fSize: CARDINAL, bitsPtr: LONG POINTER] RETURNS [loadReference: LoadReference] = TRUSTED {
loadDescription: LoadDescription _ GetLoadDescription[pdState];
source: LONG POINTER TO WORD _ bitsPtr;
wordsPerLine: NAT _ (fSize+(bitsPerWord-1))/bitsPerWord;
words: INT _ Basics.LongMult[sSize, wordsPerLine];
startOffset: INT _ pdState.currentLoadLocation;
destOffset: INT _ startOffset + SIZE[PDFileFormat.Tile];
endOffset: INT _ destOffset + words;
tile: LONG POINTER TO PDFileFormat.Tile _ loadDescription.pointer + startOffset;
destBase: LONG POINTER TO WORD _ loadDescription.pointer + destOffset;
IF endOffset > pdState.loadSizeInWords THEN ERROR;
tile.phase _ phase;
tile.sMin _ sMin;
tile.fMin _ fMin;
tile.sSize _ sSize;
tile.fSize _ fSize;
LongBlockTransfer[source: source, count: words, dest: destBase];
loadReference _ loadDescription.count;
loadDescription.count _ loadDescription.count + 1;
loadDescription[loadReference] _ [
loadEntryType: tile,
offsetHighBits: Basics.HighHalf[startOffset],
offsetLowBits: Basics.LowHalf[startOffset],
pageOfMostRecentUse: 0,
numberOfPagesUsedIn: 0
];
pdState.currentLoadLocation _ endOffset;
pdState.herald.maxLoadWord _ MAX[pdState.herald.maxLoadWord, endOffset];
DebugLoad[startOffset];
};

EndPage: PUBLIC PROC [pdState: PDState] = {
startBand: NAT _ pdState.sMinPage/pdState.herald.bandSSize;
endBand: NAT _ (pdState.sMaxPage+pdState.herald.bandSSize-1)/pdState.herald.bandSSize;
nBands: NAT _ MAX[0, INTEGER[endBand]-startBand];
fSizePage: CARDINAL _ MAX[INT[pdState.fMaxPage]-pdState.fMinPage, 0];
IF nBands = 0 THEN startBand _ 0;
IF fSizePage = 0 THEN pdState.fMinPage _ 0;
WriteLoadAdditions[pdState];
FOR t: Toner IN [pdState.firstToner..pdState.lastToner] DO
bands: Bands _ pdState.bands[t];
IF pdState.toners[t] THEN {
WriteStartImage[
pdState: pdState,
feed: t = pdState.firstToner AND pdState.feed,
strip: t = pdState.lastToner AND pdState.strip,
toner: t,
passBands: startBand,
nBands: nBands,
fMinPage: pdState.fMinPage,
fSizePage: fSizePage
];
WriteBands[pdState, bands, startBand, nBands];
pdState.currentImage _ pdState.currentImage + 1;
};
ENDLOOP;
pdState.sMinPage _ pdState.herald.imageSSize;
pdState.fMinPage _ pdState.herald.imageFSize;
pdState.sMaxPage _ pdState.fMaxPage _ 0;
IF pdState.overflowStream # NIL THEN pdState.overflowStream.SetIndex[0];
StartImage[pdState, defaultToners];
};

defaultToners: TonerSet ~ DefaultToners[];
DefaultToners: PROC RETURNS [t: TonerSet] ~ {t[black] _ TRUE};

FlushPage: PUBLIC PROC [pdState: PDState] = {
startBand: NAT _ pdState.sMinPage/pdState.herald.bandSSize;
endBand: NAT _ (pdState.sMaxPage+pdState.herald.bandSSize-1)/pdState.herald.bandSSize;
nBands: NAT _ MAX[0, INTEGER[endBand]-startBand];
fSizePage: CARDINAL _ MAX[INT[pdState.fMaxPage]-pdState.fMinPage, 0];
FOR t: Toner IN [pdState.firstToner..pdState.lastToner] DO
bands: Bands _ pdState.bands[t];
FOR i: NAT IN [startBand..startBand+nBands) DO
bands[i].colorId _ 0;
bands[i].bandBuffer.length _ 0;
bands[i].bandBuffer.overflowIndices _ NIL;
ENDLOOP
ENDLOOP;
IF pdState.overflowStream # NIL THEN {
pdState.overflowStream.SetIndex[0];
};
pdState.sMinPage _ pdState.herald.imageSSize;
pdState.fMinPage _ pdState.herald.imageFSize;
pdState.sMaxPage _ pdState.fMaxPage _ 0;
StartImage[pdState, defaultToners];
};

Close: PUBLIC PROC [pdState: PDState] = {
WriteControlCommand[pdState, endDocument];
pdState.stream.SetIndex[0];
WriteHerald[pdState];
IO.Close[pdState.stream];
IF pdState.overflowStream # NIL THEN {
pdState.overflowStream.SetIndex[0];
pdState.overflowStream.SetLength[0];
pdState.overflowStream.Close[abort: TRUE];
};
};

ObjectFallsOutsideOfDeclaredPageBounds: ERROR ~ CODE;

ExtendBB: PROC [pdState: PDState, s: CARDINAL, f: CARDINAL] = {
pdState.sMinPage _ MIN[s, pdState.sMinPage];
pdState.sMaxPage _ MAX[s, pdState.sMaxPage];
pdState.fMinPage _ MIN[f, pdState.fMinPage];
pdState.fMaxPage _ MAX[f, pdState.fMaxPage];
IF pdState.sMaxPage > pdState.herald.imageSSize THEN ERROR ObjectFallsOutsideOfDeclaredPageBounds;
IF pdState.fMaxPage > pdState.herald.imageFSize THEN ERROR ObjectFallsOutsideOfDeclaredPageBounds;
};

SelectBandNoColor: PROC [pdState: PDState, sMin: CARDINAL, toner: Toner] = TRUSTED {
bandNum: NAT _ sMin/pdState.herald.bandSSize;
bands: Bands _ pdState.bands[toner];
IF bands[bandNum].bandBuffer = NIL THEN bands[bandNum].bandBuffer _ NEW[BandBufferRec];
pdState.selectedBands _ bands;
pdState.selectedBandNum _ bandNum;
};

SelectBand: PROC [pdState: PDState, sMin: CARDINAL, toner: Toner] = TRUSTED {
colorId: INT _ pdState.colorDescriptor[toner].colorId;
longPriority: Basics.LongNumber _ [lc[colorId]];
priorityHighbits: [0..256) _ longPriority.highbits;
priorityLowbits: CARDINAL _ longPriority.lowbits;
priorityCommand: PDFileFormat.Command _ [control[setPriority, priorityHighbits]];
bandNum: NAT _ sMin/pdState.herald.bandSSize;
bands: Bands _ pdState.bands[toner];
IF bands[bandNum].bandBuffer = NIL THEN bands[bandNum].bandBuffer _ NEW[BandBufferRec];
pdState.selectedBands _ bands;
pdState.selectedBandNum _ bandNum;
IF colorId # bands[bandNum].colorId THEN {
bands[bandNum].colorId _ colorId;
IF pdState.priorityImportant THEN {
EnterBandData[pdState, @priorityCommand, SIZE[PDFileFormat.Command]];
EnterBandData[pdState, @priorityLowbits, SIZE[CARDINAL]];
};
EnterBandData[pdState, @(pdState.colorDescriptor[toner].command), pdState.colorDescriptor[toner].length];
};
};

WriteOverflowBand: PROC [pdState: PDState, bandBuffer: BandBuffer] = TRUSTED {
bandDataPtr: LONG POINTER _ @(bandBuffer.word);
IF pdState.overflowStream = NIL THEN {
pdState.overflowStream _ FS.StreamOpen[fileName: "PDTemp$", accessOptions: $create];
};
bandBuffer.overflowIndices _ CONS[
IO.GetIndex[pdState.overflowStream],
bandBuffer.overflowIndices
];
pdState.overflowStream.UnsafePutBlock[[base: bandDataPtr, startIndex: 0, count: bandBufferSize*bytesPerWord]];
bandBuffer.length _ 0;
};

EnterBandData: PROC [pdState: PDState, startPtr: LONG POINTER, wordCount: NAT] = TRUSTED {
source: LONG POINTER TO WORD _ startPtr;
bandBuffer: BandBuffer _ pdState.selectedBands[pdState.selectedBandNum].bandBuffer;
WHILE wordCount > 0 DO
IF wordCount <= bandBufferSize - bandBuffer.length THEN {
BlockTransfer[source: startPtr, count: wordCount, dest: @(bandBuffer.word[bandBuffer.length])];
startPtr _ startPtr + wordCount;
bandBuffer.length _ bandBuffer.length + wordCount;
wordCount _ 0;
}
ELSE {
count: NAT _ bandBufferSize - bandBuffer.length;
bufPtr: LONG POINTER _ @(bandBuffer.word);
BlockTransfer[source: startPtr, count: count, dest: bufPtr+bandBuffer.length];
startPtr _ startPtr + count;
bandBuffer.length _ bandBuffer.length + count;
wordCount _ wordCount - count;
WriteOverflowBand[pdState, bandBuffer];
};
ENDLOOP;
};

WriteLoadAdditions: PROC [pdState: PDState] = TRUSTED {
WHILE pdState.loadWrittenLength < pdState.currentLoadLocation DO
loadDescription: LoadDescription _ GetLoadDescription[pdState];
lengthOfAdditions: INT _ pdState.currentLoadLocation-pdState.loadWrittenLength;
lengthOfChunk: INT _ MIN[lengthOfAdditions, 8*1024];
unsafeBlock: Basics.UnsafeBlock = [base: loadDescription.pointer+pdState.loadWrittenLength, startIndex: 0, count: lengthOfChunk*bytesPerWord];
WriteControlCommand[pdState, storeLoad];
WriteLongCardinal[pdState, pdState.loadWrittenLength];
WriteCardinal[pdState, lengthOfChunk];
pdState.stream.UnsafePutBlock[unsafeBlock];
pdState.loadWrittenLength _ pdState.loadWrittenLength + lengthOfChunk;
ENDLOOP;
};

WriteLongCardinal: PROC [pdState: PDState, lc: LONG CARDINAL] = TRUSTED {
base: LONG POINTER ~ @lc;
pdState.stream.UnsafePutBlock[[base: base, startIndex: 0, count: SIZE[LONG CARDINAL]*bytesPerWord]];
};

WriteCardinal: PROC [pdState: PDState, c: CARDINAL] = TRUSTED {
base: LONG POINTER ~ @c;
pdState.stream.UnsafePutBlock[[base: base, startIndex: 0, count: SIZE[CARDINAL]*bytesPerWord]];
};

WriteHerald: PROC [pdState: PDState] = TRUSTED {
base: LONG POINTER ~ @pdState.herald;
pdState.stream.UnsafePutBlock[[base: base, startIndex: 0, count: SIZE[PDFileFormat.Herald]*bytesPerWord]];
};

WriteControlCommand: PROC [pdState: PDState, controlCom: PDFileFormat.ControlCom] = TRUSTED {
command: PDFileFormat.Command _ [control[controlCom]];
base: LONG POINTER ~ @command;
pdState.stream.UnsafePutBlock[[base: base, startIndex: 0, count: SIZE[PDFileFormat.Command]*bytesPerWord]];
};

WriteStartImage: PROC [
pdState: PDState,
feed: BOOLEAN,
strip: BOOLEAN,
toner: Toner,
passBands: NAT,
nBands: NAT,
fMinPage: CARDINAL,
fSizePage: CARDINAL
] = TRUSTED {
StartImageBuf: TYPE = MACHINE DEPENDENT RECORD [
command: PDFileFormat.Command,
args: PDFileFormat.StartImage
];
startImageBuf: StartImageBuf _ [
command: [control[com: startImage]],
args: [leftOverMode: pdState.leftOverMode, feed: feed, strip: strip, toner: toner, passBands: passBands, nBands: nBands, fMinPage: fMinPage, fSizePage: fSizePage]
];
base: LONG POINTER ~ @startImageBuf;
pdState.stream.UnsafePutBlock[[base: base, startIndex: 0, count: SIZE[StartImageBuf]*bytesPerWord]];
};

WriteBands: PROC [pdState: PDState, bands: Bands, startBand, nBands: NAT] = TRUSTED {
FOR bandNum: NAT IN [startBand..startBand+nBands) DO
bandBuffer: BandBuffer _ bands[bandNum].bandBuffer;
IF bandBuffer # NIL THEN {
overflowIndices: LIST OF INT _ NIL;
WHILE bandBuffer.overflowIndices # NIL DO
t: LIST OF INT _ bandBuffer.overflowIndices;
bandBuffer.overflowIndices _ bandBuffer.overflowIndices.rest;
t.rest _ overflowIndices;
overflowIndices _ t;
ENDLOOP;
WHILE overflowIndices # NIL DO
overflowBuf: ARRAY [0..bandBufferSize) OF CARDINAL;
base: LONG POINTER ~ @overflowBuf;
pdState.overflowStream.SetIndex[overflowIndices.first];
IF bandBufferSize*bytesPerWord #
pdState.overflowStream.UnsafeGetBlock[[
base: base,
startIndex: 0,
count: bandBufferSize*bytesPerWord
]]
THEN ERROR;
pdState.stream.UnsafePutBlock[[base: base, startIndex: 0, count: bandBufferSize*bytesPerWord]];
{t: LIST OF INT _ overflowIndices; overflowIndices _ t.rest; t.rest _ NIL};
ENDLOOP;
pdState.stream.UnsafePutBlock[[base: LOOPHOLE[@(bandBuffer.word)], startIndex: 0, count: bandBuffer.length*bytesPerWord]];
bandBuffer.length _ 0;
};
WriteControlCommand[pdState, endBand];
bands[bandNum].colorId _ 0;
ENDLOOP;
};

END.
τPDFileWriterImpl.mesa
Copyright c 1984, 1985 Xerox Corporation.  All rights reserved.
Michael Plass, July 8, 1985 9:28:49 am PDT
Doug Wyatt, March 7, 1985 6:27:30 pm PST
We will come back and overwrite this when the file is closed.
set a breakpoint here to debug strange load contents.
Reserve a word in the load for fMax.
Will come back to fill in sSize.
Fill in fMax.
Fill in sSize.
In case the client decides it didn't really want this page after all.
Note - this relys on FS to do the right thing when multiple instances of the file writer are around.  The version number mechanism should keep us out of trouble.
Writes out any additions to the font load
Writes out the bands, resetting them along the way.
Reverse the list of overflow indices.
Κ$I˜
codeš
œ™Kšœ
Οm
œ4™?K™*K™(—K˜š
Οk	˜	KšœžœS˜_Kšœ
žœ˜#Kšžœ
žœ˜Kšžœ
žœ(žœ"˜XKšœ
žœΝ
˜ί
Kšœ
žœe˜wKšœžœ˜Kšœžœžœ˜K˜—šœžœ
ž˜Kšžœžœžœ˜0Kšžœ
˜šœž˜K˜—šΟn
œžœ
žœ
žœ
žœ	žœžœ
žœ
˜VKšœž	œ
žœA˜SK˜—šŸœžœ
žœ
žœ
žœ	žœžœ
žœž	œ˜cšžœ	žœ
žœž˜Kšœ%žœ
žœ˜AKšœžœ
žœ˜!Kšœžœ
žœ˜Kšœžœ
žœ˜Kšžœ
˜—Kšžœžœ9˜JKš
œ˜K˜—Kšœžœ˜-Kšœ
žœ˜+Kšžœžœžœ
˜Kšœžœžœ
˜KšŸœžœ$˜=KšŸœžœ˜3KšŸœžœ'˜CKšŸœžœ$˜=Kšœžœ˜!Kšœ
žœ˜'Kšœžœ˜!K˜Kšœžœžœ
˜šœ
žœžœ˜Kšœžœžœ
žœ˜%Kš
œ˜K˜—šœžœžœ˜Kšœ	žœ
˜
Kš
œ˜Kš
œ˜K˜—Kšœžœ˜Kšœžœžœ˜%šœžœžœ˜Kšœžœ˜Kš	œžœ
žœ
žœžœ
˜#Kšœžœžœ
ž˜'Kš
œ˜K˜—šœžœžœ˜ Kšœ	žœΟc%˜7Kšœ	žœžœ
˜Kšœžœ˜Kš
œ?˜?Kš
œ'˜'Kš
œ˜K˜—Kšœžœ˜Kšœžœžœ˜/šœžœžœ˜#Kšœžœ (˜9Kšœ	žœ
žœ
˜Kšœžœ %˜2Kšœžœ˜Kšœ	žœžœ
žœ˜7Kš
œ˜K˜—Kšœžœ#˜6šœžœžœ˜%Kš
œ˜Kš
œ˜Kšœžœ
˜Kšœžœ
˜Kšœž˜Kš
œ˜K˜—Kšœ	žœ
žœžœ˜&šœžœ
žœžœ˜"Kšœ
žœ
˜Kš
œ˜Kšœžœžœ˜0Kšœžœ
žœ
˜Kšœžœ
žœ˜Kš
œ%˜%Kšœžœžœ
˜Kšœžœžœ
˜Kšœžœžœ˜Kšœžœ
˜Kšœžœ˜Kšœ
žœ
˜Kšœ
žœ
˜Kšœ
žœ
˜Kšœ
žœ
˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ!˜!Kšœžœ
žœž˜Kš
œ˜K˜—šŸœžœ
žœžœYžœ
žœ
žœžœžœžœ˜υ
Kšœžœ
˜Kšœ
žœ˜Kš
œ˜Kš
œ'˜'Kš
œ)˜)Kš
œ)˜)Kš
œ,˜,Kš
œ@˜@Kš
œ:˜:Kš
œ%˜%Kš
œ˜Kš
œ˜Kšœžœ
˜'Kš
œ$˜$Kšœžœ
˜"Kš
œ(˜(Kšœžœ
žœ˜Kšœžœ
˜Kšœžœ
˜$Kšœžœ˜.Kš
œ2˜2š
œ˜K™=—Kš
œ˜K˜—šŸœžœ
žœ'žœžœžœ˜uKš
œ*˜*Kš
œ.˜.Kš
œ˜K˜—š
Ÿ
œžœ
žœ3žœžœ˜]Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ
˜ Kšœžœ
˜ š	žœ
žœžœžœž˜,šžœžœ˜šžœžœ
žœ˜ Kšœžœ+˜AKš
œ˜—Kšžœžœ
žœ˜?Kš
œ˜Kš
œ˜—š
œ˜Kš
œ˜Kš
œ
˜
Kš
œ ˜ Kš
œ˜Kš
œ˜Kš
œ˜—Kš
ž˜—Kš
œ˜K˜—šŸœžœ
žœ%˜=Kšžœ
žœžœ
žœ
˜(Kš
œT˜TKšœ(žœ˜CKš
œ@˜@Kšœ)žœ
˜.Kš
œ˜K˜—šŸ
œžœ
žœ%˜?Kšžœ
žœžœ
žœ
˜(Kš
œT˜TKšœ(žœ˜CKš
œB˜BKšœ)žœ
˜.Kš
œ˜K˜—šŸœžœ
žœ%˜=Kšœ)žœ
˜/Kš
œ˜K˜—šŸœžœ
žœJžœ˜lKš
œC˜CKš
œk˜kKšœ	žœ.˜:Kšœžœžœžœ˜`Kšžœ žœ
žœ
˜-Kšžœ
žœžœ
žœ
˜(š
œ"˜"Kš
œ˜Kšœžœžœ˜EKš
œ'˜'Kš
œ#˜#Kšœ	ž˜
Kš
œ˜—Kš
œ˜K˜—šŸœžœ
žœžœ˜Ešžœžœ)ž˜>Kšžœžœ
˜*Kšžœ
˜—Kš
œ˜K˜—š
Ÿ	œžœ
žœžœžœ˜LKš
œ!˜!Kš
œ!˜!Kš
œ˜K˜—šŸ
œžœ
žœ žœžœžœ˜gKš	œžœžœžœžœ˜GKšœžœ˜/Kš
œ<˜<Kš
œX˜XKš
œ˜Kš
œ.˜.šžœžœ)ž˜>šžœ(žœ˜0Kšœžœžœ
˜DKš
œ!˜!Kšœ!žœ˜=Kšœ"žœ˜Dšžœžœ žœž˜>Kš
œ˜Kšœ!žœ˜=Kšœ"žœ˜DKšžœ
˜—Kš
œ˜—Kšžœ
˜—Kš
œ˜K˜—šŸ
œžœ
žœ!žœžœžœžœ˜†
Kš	œžœžœžœžœ˜GKšœžœ˜/Kš
œ<˜<Kš
œ€
˜€
Kšœžœ˜-Kšœ žœ&˜Išžœžœ)ž˜>šžœ(žœ˜0Kšœžœžœ
˜DKš
œ!˜!Kšœ!žœ˜=Kšœ"žœ˜Dšžœžœ žœž˜>Kš
œ˜Kšœ!žœ˜=Kšœ"žœ˜DKšžœ
˜—Kš
œ˜—Kšžœ
˜—Kš
œ˜K˜—šŸœžœ
žœ5žœžœžœ˜uKš
œF˜FKš
œk˜kKš
œT˜Tš
œ%˜%Kš
œ%˜%Kš
œ˜Kš
œ
˜
Kš
œ˜—Kšœžœ
žœ
žœK˜jKš	œžœžœžœžœ˜WKšœžœ˜/Kšžœ#žœ
žœ
˜0Kš
œ˜Kš
œN˜Nšžœžœ)ž˜>šžœ(žœ˜0Kšœžœžœ
˜DKš
œ!˜!Kšœ!žœ˜=Kšœžœ˜Ašžœžœ žœž˜>Kš
œ˜Kšœ!žœ˜=Kšœžœ˜AKšžœ
˜—Kš
œ˜—Kšžœ
˜—Kš
œ˜K˜—šŸœžœ
žœžœžœ	žœ	žœ)žœ˜ž
Kš
œ:˜:Kšœžœ˜/Kšœžœ'˜8Kš
œ˜Kš
œ.˜.šžœžœ)ž˜>šžœ(žœ˜0Kšœžœ˜Kšœžœ˜Kšœžœ˜š	œžœžœ
žœžœ˜Bšžœžœ˜š
œ"˜"Kš
œ˜Kš
œ
˜
Kš
œ˜—Kšœžœžœžœ˜Hš
œ)˜)Kš
œ-˜-Kš
œ˜Kš
œ˜—Kš
œ˜Kšœ!žœ˜=Kšœžœ˜>Kšœ%žœ˜EKš
œ˜—Kš
œ:˜:Kš
œ(˜(K˜
Kš
œ˜—Kš
œ˜Kšžœžœ
žœ
˜#Kšžœ
žœ
žœ
˜Kš
œ˜—Kšžœ
˜—Kš
œ˜K˜—šŸœžœ
žœ6žœžœžœ˜wKš
œG˜GKš
œk˜kKš
œU˜Uš
œ&˜&Kš
œ%˜%Kš
œ˜Kš
œ
˜
Kš
œ˜—Kš	œ
žœ
žœ
žœ
žœ6˜XKš	œ
žœ
žœ
žœ
žœ2˜TKš	œžœžœžœžœ˜KKšœžœ˜/Kšžœ$žœ
žœ
˜1Kš
œ˜Kš
œ6˜6šžœžœ)ž˜>šžœ(žœ˜0Kšœžœžœ
˜DKš
œ!˜!Kšœ!žœ˜=Kšœžœ ˜Bšžœžœ žœž˜>Kš
œ˜Kšœ!žœ˜=Kšœžœ ˜BKšžœ
˜—Kš
œ˜—Kšžœ
˜—Kš
œ˜K˜—šŸœžœ
žœ9˜RKšœ	žœžœ˜5Kšœžœ˜/šœžœ
ž	œ
žœ˜"Kš
œ8˜8Kšœžœ
˜Kšœžœ
˜Kšœžœžœ
ž
œ˜+K˜—Kšœžœ˜Kšœžœ
˜Kšœ	žœ
˜Kš
œ˜šŸ	œžœžœ˜šžœžœ˜šžœ
žœžœ˜+Kš
œ ˜ Kšœ žœ
˜%Kš
œ˜—Kš
œ/˜/Kš
œ žœžœ
žœžœ
žœžœ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜—šŸ
œžœžœ˜%Kš
œ$˜$Kš
œ˜Kšœžœ˜0Kš
œ˜—šŸ	œžœžœžœ˜2Kšžœžœ
˜$Kšœ8žœ˜?Kš
œ˜Kš
œ˜—šŸœžœžœ˜Kš
œ ˜ Kšœ žœ
˜%Kš
œ$˜$Kš
œ˜—šŸ
œžœžœ	žœ˜6Kš
œ&˜&Kš
œ˜—šŸœžœžœžœ˜AKšžœžœ˜"Kšžœ
žœžœ
žœžœ%žœžœ!˜„
Kšžœžœ˜)Kšžœžœ
žœ
˜$Kšžœ
žœ	žœ
žœ
žœ
žœžœ
žœ
žœ
˜UKš
œ˜šžœ	žœ
žœžœ˜Kšœžœ
žœ˜Kš	œžœ
žœžœ
žœ˜3Kš
œ˜—Kš
œ˜Kš
œ*˜*Kš
œ˜—šžœžœ)ž˜>šžœ(žœ˜0Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kšžœ
˜—Kš
œ˜K˜—šŸœžœ
žœ%˜BKšžœ
žœžœ
žœ
˜(Kš
œT˜TKš
œ*˜*Kšœ)žœ
˜.Kš
œ˜K˜—šŸœžœ
žœ&žœžœžœ7žœ˜§
Kšœ.žœžœžœ˜eKšœžœ˜/Kšœžœ'˜8Kšœžœ˜Kšœžœ˜Kšœžœ˜š
Ÿœžœžœ
žœžœ˜Ešžœžœ˜š
œ"˜"Kš
œ˜Kš
œ
˜
Kš
œ˜—Kšœžœžœžœ
˜Fš
œ)˜)Kš
œ-˜-Kš
œ˜Kš
œ˜—Kš
œ˜Kšœ&žœ˜BKšœžœ˜>Kšœ%žœ˜EKš
œ˜—Kš
œ:˜:Kš
œ(˜(K˜
Kš
œ˜—šžœ(žœ˜0Kš
œ˜Kš
œ.˜.Kš
œ˜Kšžœžœ
žœ
˜#Kšžœ
žœ
žœ
˜K˜—Kš
œ˜K˜—š
Ÿœžœ
žœžœ	žœ˜JKš
œ>˜>Kšžœžœ
žœBžœ˜uKš
œ˜K˜—šŸœžœžœ˜Išžœžœ
žœ˜'Kšœ#žœ#˜IKš
œJ˜JKš
œ'˜'Kš
œ,˜,Kš
œ(˜(Kš
œ˜Kš
œ*˜*Kš
œ˜—Kšžœ˜ Kš
œ˜K˜—Kšœžœžœ
žœ˜!Kšœžœ˜šŸ	œžœžœ˜%šžœž˜$K™5Kš
œ$˜$—Kš
œ˜K˜—š
Ÿœžœ
žœ6žœ"žœ˜
Kš	œ	žœžœ
žœ
žœ˜,Kš
œ?˜?Kšœžœ˜Kšœžœ˜&Kšœžœ˜'Kš	œžœ
žœ
žœ
žœ˜9Kšœžœ˜Kšœžœžœ
˜š
Ÿ
œžœžœ	žœžœ˜>Kš
œ&˜&Kš
œ˜—š
Ÿœžœžœžœ
žœ˜IKšžœžœ
žœ .˜Qšžœž˜Kšžœžœ
žœ
˜Kšžœžœ8˜MKšžœ+˜/Kš
œ"˜"Kšœžœ
˜Kšžœ
˜—Kšœžœ
˜Kšžœ
žœ	žœ
žœ
žœ
žœžœ
žœ
žœ
˜Ušžœ	žœ
žœžœ˜Kšžœžœ
žœ
˜Kšœ$žœ
žœ˜;Kš	œžœ
žœžœ
žœ˜3Kš
œ˜—Kšžœžœ
žœ
˜Kš
œ7˜7Kšœžœ˜Kš
œ˜—šœžœ	˜Kš
œ$™$—˜K™ —Kšžœžœ
žœ
˜Kš
œ˜Kšžœ
žœžœN˜gš
œ˜Kš
œ
™
—š
œ ˜ K™—Kš
œ"˜"Kšœžœ"˜BKš
œ&˜&Kš
œ2˜2š
œ"˜"Kš
œ˜Kš
œ(˜(Kš
œ&˜&Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜K˜—šŸœžœ
žœ"žœžœ
žœžœ"žœ˜›
Kš
œ?˜?Kš	œžœ
žœ
žœ
žœ˜'Kšœžœ'˜8Kšœžœ(˜2Kšœ
žœ˜/Kšœžœžœ˜?Kšœžœ˜$Kšœ
žœ
žœ
žœB˜^Kš	œ
žœ
žœ
žœ
žœ(˜FKšžœ%žœ
žœ
˜2Kš
œ˜Kš
œ˜Kš
œ@˜@Kš
œ&˜&Kš
œ2˜2š
œ"˜"Kš
œ˜Kš
œ-˜-Kš
œ+˜+Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ(˜(Kšœžœ(˜HKš
œ˜Kš
œ˜K˜—šŸœžœ
žœžœžœžœžœ
žœžœ"žœ˜ΐ
Kš
œ?˜?Kš	œžœ
žœ
žœ
žœ˜'Kšœžœ'˜8Kšœžœ(˜2Kšœ
žœ˜/Kšœžœžœ˜8Kšœžœ˜$Kšœžœ
žœ
žœ;˜PKš	œ
žœ
žœ
žœ
žœ(˜FKšžœ%žœ
žœ
˜2Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ@˜@Kš
œ&˜&Kš
œ2˜2š
œ"˜"Kš
œ˜Kš
œ-˜-Kš
œ+˜+Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ(˜(Kšœžœ(˜HKš
œ˜Kš
œ˜K˜—šŸœžœ
žœ˜+Kšœžœ-˜;Kšœ	žœJ˜VKšœžœžœžœ˜1Kšœžœžœ
žœ(˜EKšžœžœ˜!Kšžœžœ˜+Kš
œ˜šžœ
žœ)ž˜:Kš
œ ˜ šžœžœ˜š
œ˜Kš
œ˜Kšœžœ˜.Kšœžœ˜/Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ.˜.Kš
œ0˜0K˜—Kšžœ
˜—Kš
œ-˜-Kš
œ-˜-Kš
œ(˜(Kšžœžœ
žœ$˜HKš
œ#˜#Kš
œ˜K˜—š
œ*˜*KšŸ
œžœ
žœžœ˜>K˜—šŸ	œžœ
žœ˜-K™EKšœžœ-˜;Kšœ	žœJ˜VKšœžœžœžœ˜1Kšœžœžœ
žœ(˜Ešžœ
žœ)ž˜:Kš
œ ˜ šžœžœ
žœž˜.Kš
œ˜Kš
œ˜Kšœ&žœ
˜*Kš
ž˜—Kšžœ
˜—šžœžœ
žœ˜&K˜#Kš
œ˜—Kš
œ-˜-Kš
œ-˜-Kš
œ(˜(Kš
œ#˜#Kš
œ˜K˜—šŸœžœ
žœ˜)Kš
œ*˜*Kš
œ˜Kš
œ˜Kšžœ˜šžœžœ
žœ˜&K˜#Kš
œ$˜$Kšœ$žœ˜*Kš
œ˜—Kš
œ˜K˜—šœ(žœžœ
˜5K˜—šŸœžœžœžœ˜?Kšœžœ˜,Kšœžœ˜,Kšœžœ˜,Kšœžœ˜,Kšžœ.žœ
žœ(˜bKšžœ.žœ
žœ(˜bKš
œ˜K˜—šŸœžœžœžœ˜TKšœ	žœ!˜-Kš
œ$˜$Kšžœžœ
žœžœ˜WKš
œ˜Kš
œ"˜"Kš
œ˜K˜—šŸ
œžœžœžœ˜MKšœ	žœ*˜6Kš
œ0˜0Kš
œ3˜3Kšœžœ˜1Kš
œQ˜QKšœ	žœ!˜-Kš
œ$˜$Kšžœžœ
žœžœ˜WKš
œ˜Kš
œ"˜"šžœ!žœ˜*Kš
œ!˜!šžœžœ˜#Kšœ)žœ˜EKšœ)žœ
žœ˜9K˜—Kš
œi˜iKš
œ˜—Kš
œ˜K˜—šŸœžœ.žœ˜NKšœ
žœ
žœ˜/šžœžœ
žœ˜&Kš
œT˜TK™‘
Kš
œ˜—šœžœ
˜"Kšžœ"˜$Kš
œ˜Kš
œ˜—Kš
œn˜nKš
œ˜Kš
œ˜K˜—šŸ
œžœžœ
žœ
žœžœ˜ZKš	œžœ
žœ
žœ
žœ˜(Kš
œS˜Sšžœž˜šžœ1žœ˜9Kš
œ_˜_Kš
œ ˜ Kš
œ2˜2Kš
œ˜Kš
œ
˜
—šžœ˜Kšœžœ&˜0Kšœžœ
žœ˜*Kš
œN˜NKš
œ˜Kš
œ.˜.Kš
œ˜Kš
œ'˜'Kš
œ˜—Kš
ž˜—Kš
œ˜K˜—šŸœžœžœ˜7K™)šžœ9ž˜@Kš
œ?˜?Kšœžœ9˜OKšœžœžœ˜4Kš
œŽ
˜Ž
Kš
œ(˜(Kš
œ6˜6Kš
œ&˜&Kš
œ+˜+Kš
œF˜FKšžœ
˜—Kš
œ˜K˜—š
Ÿœžœžœ
žœžœ˜IKšœžœ
žœ˜KšœAžœ
žœ
žœ˜dKš
œ˜K˜—šŸ
œžœžœžœ˜?Kšœžœ
žœ˜KšœAžœ
žœ˜_Kš
œ˜K˜—šŸœžœžœ˜0Kšœžœ
žœ˜%KšœAžœ%˜jKš
œ˜K˜—šŸœžœ;žœ˜]Kš
œ6˜6Kšœžœ
žœ˜KšœAžœ&˜kKš
œ˜K˜—šŸœžœ˜Kš
œ˜Kšœžœ
˜Kšœžœ
˜Kš
œ
˜
Kšœžœ
˜Kšœžœ
˜Kšœ
žœ
˜Kšœž˜Kšœžœ˜
š	œžœžœ
ž	œ
žœ˜0Kš
œ˜Kš
œ˜Kš
œ˜—š
œ ˜ Kš
œ$˜$Kš
œ’
˜’
Kš
œ˜—Kšœžœ
žœ˜$KšœAžœ˜dKš
œ˜K˜—šŸ
œžœ5žœžœ˜UK™3šžœ
žœ
žœž˜4Kš
œ3˜3šžœžœ
žœ˜Kš	œžœ
žœ
žœžœ
˜#K™%šžœžœ
ž˜)Kšœžœ
žœ
žœ˜,Kš
œ=˜=Kš
œ˜Kš
œ˜Kšžœ
˜—šžœžœ
ž˜Kšœ
žœžœ
žœ
˜3Kšœžœ
žœ˜"Kš
œ7˜7šžœ˜ š
œ'˜'Kš
œ˜Kš
œ˜Kš
œ"˜"Kš
œ˜——Kšžœ
žœ
˜Kš
œ_˜_Kš	œžœ
žœ
žœ7žœ˜KKšžœ
˜—Kšœ%žœM˜zKš
œ˜Kš
œ˜—Kš
œ&˜&Kš
œ˜Kšžœ
˜—Kš
œ˜K˜—Kšžœ
˜——…—~δ¦!