DIRECTORY
Basics USING [bitsPerWord, bytesPerWord, HighHalf, LongMult, LongNumber, LowHalf, UnsafeBlock],
CountedVM USING [Allocate, Handle, Pointer, Words],
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 = MACHINE DEPENDENT 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 _ [black: TRUE],
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;
pdState.herald.imageSSize _ pdState.sMinPage _ imageSSize;
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 _ [black: TRUE];
pdState.feed _ pdState.strip _ TRUE;
nBands _ (pdState.herald.imageSSize+pdState.herald.bandSSize-1)/pdState.herald.bandSSize;
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 _ [black: TRUE], 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, fSize: CARDINAL] = {
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;
};

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;
TRUSTED {loadDescription.pointer _ CountedVM.Pointer[countedVM]};
loadDescription.words _ CountedVM.Words[countedVM];
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, fSize: CARDINAL] = TRUSTED {
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];
};

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;
};

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 Xerox Corporation.  All rights reserved.
Michael Plass, April 30, 1984 4:54:01 pm PDT
Doug Wyatt, October 15, 1984 5:06:29 pm PDT
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.
�Ê#z˜š
œ™Jšœ
Ïm
œ.™9J™,J™+—J˜š
Ïk	˜	JšœžœS˜_Jšœ
žœ$˜3Jšžœ
žœ˜Jšžœ
žœ(žœ"˜XJšœ
žœÍ
˜ß
Jšœ
žœe˜wJšœžœ˜Jšœžœžœ˜J˜—šœžœ
ž˜Jšžœžœžœ˜0Jšžœ
˜šœž˜J˜—šÏn
œžœ
žœ
žœ
žœ	žœžœ
žœ
˜VJšœž	œ
žœA˜SJ˜—šŸœžœ
žœ
žœ
žœ	žœžœ
žœž	œ˜cšžœ	žœ
žœž˜Jšœ%žœ
žœ˜AJšœžœ
žœ˜!Jšœžœ
žœ˜Jšœžœ
žœ˜Jšžœ
˜—Jšžœžœ9˜JJš
œ˜J˜—Jšœžœ˜-Jšœ
žœ˜+Jšžœžœžœ
˜Jšœžœžœ
˜JšŸœžœ$˜=JšŸœžœ˜3JšŸœžœ'˜CJšŸœžœ$˜=Jšœžœ˜!Jšœ
žœ˜'Jšœžœ˜!J˜Jšœžœžœ
˜šœ
žœžœ˜Jšœžœžœ
žœ˜%Jš
œ˜J˜—šœžœžœ˜Jšœ	žœ
˜
Jš
œ˜Jš
œ˜J˜—Jšœžœ˜Jšœžœžœ˜%šœžœžœ˜Jšœžœ˜Jš	œžœ
žœ
žœžœ
˜#Jšœžœžœ
ž˜'Jš
œ˜J˜—š	œžœžœ
ž	œ
žœ˜2Jšœ	žœÏc%˜7Jšœ	žœžœ
˜Jšœžœ˜Jš
œ?˜?Jš
œ'˜'Jš
œ˜J˜—Jšœžœ˜Jšœžœžœ˜/šœžœžœ˜#Jšœžœ (˜9Jšœ	žœ
žœ
˜Jšœžœ %˜2Jšœžœ˜Jšœ	žœžœ
žœ˜7Jš
œ˜J˜—Jšœžœ#˜6šœžœžœ˜%Jš
œ˜Jš
œ˜Jšœžœ
˜Jšœžœ
˜Jšœž˜Jš
œ˜J˜—Jšœ	žœ
žœžœ˜&šœžœ
žœžœ˜"Jšœ
žœ
˜Jš
œ˜Jšœžœžœ˜0Jšœžœ
žœ
˜Jšœžœ˜!Jš
œ%˜%Jšœžœžœ
˜Jšœžœžœ
˜Jšœžœžœ˜Jšœžœ
˜Jšœžœ˜Jšœ
žœ
˜Jšœ
žœ
˜Jšœ
žœ
˜Jšœ
žœ
˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jš
œ!˜!Jšœžœ
žœž˜Jš
œ˜J˜—šŸœžœ
žœžœYžœ
žœ
žœžœžœžœ˜õ
Jšœžœ
˜Jšœ
žœ˜Jš
œ˜Jš
œ'˜'Jš
œ)˜)Jš
œ)˜)Jš
œ:˜:Jš
œ:˜:Jš
œ%˜%Jš
œ˜Jš
œ˜Jšœžœ
˜'Jš
œ$˜$Jšœžœ
˜"Jš
œ(˜(Jšœžœ˜Jšœžœ
˜$Jš
œY˜YJšœžœ˜.Jš
œ2˜2š
œ˜J™=—Jš
œ˜J˜—šŸœžœ
žœ'žœžœžœ˜uJš
œ*˜*Jš
œ.˜.Jš
œ˜J˜—šŸ
œžœ
žœ/žœžœžœ˜mJš
œ˜Jš
œ˜Jš
œ˜Jšœžœ
˜ Jšœžœ
˜ š	žœ
žœžœžœž˜,šžœžœ˜šžœžœ
žœ˜ Jšœžœ+˜AJš
œ˜—Jšžœžœ
žœ˜?Jš
œ˜Jš
œ˜—š
œ˜Jš
œ˜Jš
œ
˜
Jš
œ ˜ Jš
œ˜Jš
œ˜Jš
œ˜—Jš
ž˜—Jš
œ˜J˜—šŸœžœ
žœ%˜=Jšžœ
žœžœ
žœ
˜(Jš
œT˜TJšœ(žœ˜CJš
œ@˜@Jšœ)žœ
˜.Jš
œ˜J˜—šŸ
œžœ
žœ%˜?Jšžœ
žœžœ
žœ
˜(Jš
œT˜TJšœ(žœ˜CJš
œB˜BJšœ)žœ
˜.Jš
œ˜J˜—šŸœžœ
žœ%˜=Jšœ)žœ
˜/Jš
œ˜J˜—šŸœžœ
žœJžœ˜lJš
œC˜CJš
œk˜kJšœ	žœ.˜:Jšœžœžœžœ˜`Jšžœ žœ
žœ
˜-Jšžœ
žœžœ
žœ
˜(š
œ"˜"Jš
œ˜Jšœžœžœ˜EJš
œ'˜'Jš
œ#˜#Jšœ	ž˜
Jš
œ˜—Jš
œ˜J˜—šŸœžœ
žœžœ˜Ešžœžœ)ž˜>Jšžœžœ
˜*Jšžœ
˜—Jš
œ˜J˜—š
Ÿ	œžœ
žœžœžœ˜LJš
œ!˜!Jš
œ!˜!Jš
œ˜J˜—šŸ
œžœ
žœ žœžœžœ˜gJš	œžœžœžœžœ˜GJšœžœ˜/Jš
œ<˜<Jš
œX˜XJš
œ˜Jš
œ.˜.šžœžœ)ž˜>šžœ(žœ˜0Jšœžœžœ
˜DJš
œ!˜!Jšœ!žœ˜=Jšœ"žœ˜Dšžœžœ žœž˜>Jš
œ˜Jšœ!žœ˜=Jšœ"žœ˜DJšžœ
˜—Jš
œ˜—Jšžœ
˜—Jš
œ˜J˜—šŸ
œžœ
žœ!žœžœžœžœ˜†
Jš	œžœžœžœžœ˜GJšœžœ˜/Jš
œ<˜<Jš
œ€
˜€
Jšœžœ˜-Jšœ žœ&˜Išžœžœ)ž˜>šžœ(žœ˜0Jšœžœžœ
˜DJš
œ!˜!Jšœ!žœ˜=Jšœ"žœ˜Dšžœžœ žœž˜>Jš
œ˜Jšœ!žœ˜=Jšœ"žœ˜DJšžœ
˜—Jš
œ˜—Jšžœ
˜—Jš
œ˜J˜—šŸœžœ
žœ5žœžœžœ˜uJš
œF˜FJš
œk˜kJš
œT˜Tš
œ%˜%Jš
œ%˜%Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœžœ
žœ
žœK˜jJš	œžœžœžœžœ˜WJšœžœ˜/Jšžœ#žœ
žœ
˜0Jš
œ˜Jš
œN˜Nšžœžœ)ž˜>šžœ(žœ˜0Jšœžœžœ
˜DJš
œ!˜!Jšœ!žœ˜=Jšœžœ˜Ašžœžœ žœž˜>Jš
œ˜Jšœ!žœ˜=Jšœžœ˜AJšžœ
˜—Jš
œ˜—Jšžœ
˜—Jš
œ˜J˜—šŸœžœ
žœžœžœ	žœ	žœ)žœ˜ž
Jš
œ:˜:Jšœžœ˜/Jšœžœ'˜8Jš
œ˜Jš
œ.˜.šžœžœ)ž˜>šžœ(žœ˜0Jšœžœ˜Jšœžœ˜Jšœžœ˜š	œžœžœ
žœžœ˜Bšžœžœ˜š
œ"˜"Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœžœžœžœ˜Hš
œ)˜)Jš
œ-˜-Jš
œ˜Jš
œ˜—Jš
œ˜Jšœ!žœ˜=Jšœžœ˜>Jšœ%žœ˜EJš
œ˜—Jš
œ:˜:Jš
œ(˜(J˜
Jš
œ˜—Jš
œ˜Jšžœžœ
žœ
˜#Jšžœ
žœ
žœ
˜Jš
œ˜—Jšžœ
˜—Jš
œ˜J˜—šŸœžœ
žœ6žœžœžœ˜wJš
œG˜GJš
œk˜kJš
œU˜Uš
œ&˜&Jš
œ%˜%Jš
œ˜Jš
œ
˜
Jš
œ˜—Jš	œ
žœ
žœ
žœ
žœ6˜XJš	œ
žœ
žœ
žœ
žœ2˜TJš	œžœžœžœžœ˜KJšœžœ˜/Jšžœ$žœ
žœ
˜1Jš
œ˜Jš
œ6˜6šžœžœ)ž˜>šžœ(žœ˜0Jšœžœžœ
˜DJš
œ!˜!Jšœ!žœ˜=Jšœžœ ˜Bšžœžœ žœž˜>Jš
œ˜Jšœ!žœ˜=Jšœžœ ˜BJšžœ
˜—Jš
œ˜—Jšžœ
˜—Jš
œ˜J˜—šŸœžœ
žœ9˜RJšœ	žœžœ˜5Jšœžœ˜/šœžœ
ž	œ
žœ˜"Jš
œ8˜8Jšœžœ
˜Jšœžœ
˜Jšœžœžœ
ž
œ˜+J˜—Jšœžœ˜Jšœžœ
˜Jšœ	žœ
˜Jš
œ˜šŸ	œžœžœ˜šžœžœ˜šžœ
žœžœ˜+Jš
œ ˜ Jšœ žœ
˜%Jš
œ˜—Jš
œ/˜/Jš
œ žœžœ
žœžœ
žœžœ˜Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜—šŸ
œžœžœ˜%Jš
œ$˜$Jš
œ˜Jšœžœ˜0Jš
œ˜—šŸ	œžœžœžœ˜2Jšžœžœ
˜$Jšœ8žœ˜?Jš
œ˜Jš
œ˜—šŸœžœžœ˜Jš
œ ˜ Jšœ žœ
˜%Jš
œ$˜$Jš
œ˜—šŸ
œžœžœ˜2Jšžœžœ˜"Jšžœ
žœžœ
žœžœ%žœžœ!˜„
Jšžœžœ˜)Jšžœžœ
žœ
˜$Jšžœ
žœ	žœ
žœ
žœ
žœžœ
žœ
žœ
˜UJš
œ˜šžœ	žœ
žœžœ˜Jšœžœ
žœ˜Jš	œžœ
žœžœ
žœ˜3Jš
œ˜—Jš
œ˜Jš
œ*˜*Jš
œ˜—šžœžœ)ž˜>šžœ(žœ˜0Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jšžœ
˜—Jš
œ˜J˜—šŸœžœ
žœ&žœžœžœ7žœ˜§
Jšœ.žœžœžœ˜eJšœžœ˜/Jšœžœ'˜8Jšœžœ˜Jšœžœ˜Jšœžœ˜š
Ÿœžœžœ
žœžœ˜Ešžœžœ˜š
œ"˜"Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœžœžœžœ
˜Fš
œ)˜)Jš
œ-˜-Jš
œ˜Jš
œ˜—Jš
œ˜Jšœ&žœ˜BJšœžœ˜>Jšœ%žœ˜EJš
œ˜—Jš
œ:˜:Jš
œ(˜(J˜
Jš
œ˜—šžœ(žœ˜0Jš
œ˜Jš
œ.˜.Jš
œ˜Jšžœžœ
žœ
˜#Jšžœ
žœ
žœ
˜J˜—Jš
œ˜J˜—š
Ÿœžœ
žœžœ	žœ˜JJš
œ>˜>Jšžœžœ
žœBžœ˜uJš
œ˜J˜—šŸœžœžœ˜Išžœžœ
žœ˜'Jšœ#žœ#˜IJš
œJ˜JJš
œ'˜'Jšžœ:˜AJš
œ3˜3Jš
œ˜Jš
œ*˜*Jš
œ˜—Jšžœ˜ Jš
œ˜J˜—Jšœžœžœ
žœ˜!Jšœžœ˜šŸ	œžœžœ˜%šžœž˜$J™5Jš
œ$˜$—Jš
œ˜J˜—š
Ÿœžœ
žœ6žœ"žœ˜�
Jš	œ	žœžœ
žœ
žœ˜,Jš
œ?˜?Jšœžœ˜Jšœžœ˜&Jšœžœ˜'Jš	œžœ
žœ
žœ
žœ˜9Jšœžœ˜Jšœžœžœ
˜šŸ
œžœžœžœ˜:Jšžœžœ
žœ .˜Qšžœž˜Jšžœžœ
žœ
˜Jšžœžœ8˜MJšžœ+˜/Jš
œ"˜"Jšœžœ
˜Jšžœ
˜—Jšœžœ
˜Jšžœ
žœ	žœ
žœ
žœ
žœžœ
žœ
žœ
˜Ušžœ	žœ
žœžœ˜Jšžœžœ
žœ
˜Jšœ$žœ
žœ˜;Jš	œžœ
žœžœ
žœ˜3Jš
œ˜—Jšžœžœ
žœ
˜Jš
œ7˜7Jšœžœ˜Jš
œ˜—šœžœ	˜Jš
œ$™$—˜J™ —Jšžœžœ
žœ
˜Jš
œ˜Jšžœ
žœžœN˜gš
œ˜Jš
œ
™
—š
œ ˜ J™—Jš
œ"˜"Jšœžœ"˜BJš
œ&˜&Jš
œ2˜2š
œ"˜"Jš
œ˜Jš
œ(˜(Jš
œ&˜&Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ˜J˜—šŸœžœ
žœ"žœžœ
žœžœ"žœ˜›
Jš
œ?˜?Jš	œžœ
žœ
žœ
žœ˜'Jšœžœ'˜8Jšœžœ(˜2Jšœ
žœ˜/Jšœžœžœ˜?Jšœžœ˜$Jšœ
žœ
žœ
žœB˜^Jš	œ
žœ
žœ
žœ
žœ(˜FJšžœ%žœ
žœ
˜2Jš
œ˜Jš
œ˜Jš
œ@˜@Jš
œ&˜&Jš
œ2˜2š
œ"˜"Jš
œ˜Jš
œ-˜-Jš
œ+˜+Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ(˜(Jšœžœ(˜HJš
œ˜Jš
œ˜J˜—šŸœžœ
žœžœžœžœžœ
žœžœ"žœ˜À
Jš
œ?˜?Jš	œžœ
žœ
žœ
žœ˜'Jšœžœ'˜8Jšœžœ(˜2Jšœ
žœ˜/Jšœžœžœ˜8Jšœžœ˜$Jšœžœ
žœ
žœ;˜PJš	œ
žœ
žœ
žœ
žœ(˜FJšžœ%žœ
žœ
˜2Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ@˜@Jš
œ&˜&Jš
œ2˜2š
œ"˜"Jš
œ˜Jš
œ-˜-Jš
œ+˜+Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ(˜(Jšœžœ(˜HJš
œ˜Jš
œ˜J˜—šŸœžœ
žœ˜+Jšœžœ-˜;Jšœ	žœJ˜VJšœžœžœžœ˜1Jšœžœžœ
žœ(˜EJšžœžœ˜!Jšžœžœ˜+Jš
œ˜šžœ
žœ)ž˜:Jš
œ ˜ šžœžœ˜š
œ˜Jš
œ˜Jšœžœ˜.Jšœžœ˜/Jš
œ	˜	Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ.˜.Jš
œ0˜0J˜—Jšžœ
˜—Jš
œ-˜-Jš
œ-˜-Jš
œ(˜(Jšžœžœ
žœ$˜HJš
œ˜Jš
œ˜J˜—šŸ	œžœ
žœ˜-J™EJšœžœ-˜;Jšœ	žœJ˜VJšœžœžœžœ˜1Jšœžœžœ
žœ(˜Ešžœ
žœ)ž˜:Jš
œ ˜ šžœžœ
žœž˜.Jš
œ˜Jš
œ˜Jšœ&žœ
˜*Jš
ž˜—Jšžœ
˜—šžœžœ
žœ˜&J˜#Jš
œ˜—Jš
œ-˜-Jš
œ-˜-Jš
œ(˜(Jš
œ˜J˜—šŸœžœ
žœ˜)Jš
œ*˜*Jš
œ˜Jš
œ˜Jšžœ˜šžœžœ
žœ˜&J˜#Jš
œ$˜$Jšœ$žœ˜*Jš
œ˜—Jš
œ˜J˜—šœ(žœžœ
˜5J˜—šŸœžœžœžœ˜?Jšœžœ˜,Jšœžœ˜,Jšœžœ˜,Jšœžœ˜,Jšžœ.žœ
žœ(˜bJšžœ.žœ
žœ(˜bJš
œ˜J˜—šŸœžœžœžœ˜TJšœ	žœ!˜-Jš
œ$˜$Jšžœžœ
žœžœ˜WJš
œ˜Jš
œ"˜"Jš
œ˜J˜—šŸ
œžœžœžœ˜MJšœ	žœ*˜6Jš
œ0˜0Jš
œ3˜3Jšœžœ˜1Jš
œQ˜QJšœ	žœ!˜-Jš
œ$˜$Jšžœžœ
žœžœ˜WJš
œ˜Jš
œ"˜"šžœ!žœ˜*Jš
œ!˜!šžœžœ˜#Jšœ)žœ˜EJšœ)žœ
žœ˜9J˜—Jš
œi˜iJš
œ˜—Jš
œ˜J˜—šŸœžœ.žœ˜NJšœ
žœ
žœ˜/šžœžœ
žœ˜&Jš
œT˜TJ™¡
Jš
œ˜—šœžœ
˜"Jšžœ"˜$Jš
œ˜Jš
œ˜—Jš
œn˜nJš
œ˜Jš
œ˜J˜—šŸ
œžœžœ
žœ
žœžœ˜ZJš	œžœ
žœ
žœ
žœ˜(Jš
œS˜Sšžœž˜šžœ1žœ˜9Jš
œ_˜_Jš
œ ˜ Jš
œ2˜2Jš
œ˜Jš
œ
˜
—šžœ˜Jšœžœ&˜0Jšœžœ
žœ˜*Jš
œN˜NJš
œ˜Jš
œ.˜.Jš
œ˜Jš
œ'˜'Jš
œ˜—Jš
ž˜—Jš
œ˜J˜—šŸœžœžœ˜7J™)šžœ9ž˜@Jš
œ?˜?Jšœžœ9˜OJšœžœžœ˜4Jš
œŽ
˜Ž
Jš
œ(˜(Jš
œ6˜6Jš
œ&˜&Jš
œ+˜+Jš
œF˜FJšžœ
˜—Jš
œ˜J˜—š
Ÿœžœžœ
žœžœ˜IJšœžœ
žœ˜JšœAžœ
žœ
žœ˜dJš
œ˜J˜—šŸ
œžœžœžœ˜?Jšœžœ
žœ˜JšœAžœ
žœ˜_Jš
œ˜J˜—šŸœžœžœ˜0Jšœžœ
žœ˜%JšœAžœ%˜jJš
œ˜J˜—šŸœžœ;žœ˜]Jš
œ6˜6Jšœžœ
žœ˜JšœAžœ&˜kJš
œ˜J˜—šŸœžœ˜Jš
œ˜Jšœžœ
˜Jšœžœ
˜Jš
œ
˜
Jšœžœ
˜Jšœžœ
˜Jšœ
žœ
˜Jšœž˜Jšœžœ˜
š	œžœžœ
ž	œ
žœ˜0Jš
œ˜Jš
œ˜Jš
œ˜—š
œ ˜ Jš
œ$˜$Jš
Ϣ
˜¢
Jš
œ˜—Jšœžœ
žœ˜$JšœAžœ˜dJš
œ˜J˜—šŸ
œžœ5žœžœ˜UJ™3šžœ
žœ
žœž˜4Jš
œ3˜3šžœžœ
žœ˜Jš	œžœ
žœ
žœžœ
˜#J™%šžœžœ
ž˜)Jšœžœ
žœ
žœ˜,Jš
œ=˜=Jš
œ˜Jš
œ˜Jšžœ
˜—šžœžœ
ž˜Jšœ
žœžœ
žœ
˜3Jšœžœ
žœ˜"Jš
œ7˜7šžœ˜ š
œ'˜'Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜——Jšžœ
žœ
˜Jš
œ_˜_Jš	œžœ
žœ
žœ7žœ˜KJšžœ
˜—Jšœ%žœM˜zJš
œ˜Jš
œ˜—Jš
œ&˜&Jš
œ˜Jšžœ
˜—Jš
œ˜J˜—Jšžœ
˜——…—| £