DIRECTORY
Atom,
Environment,
FileIO,
Inline,
IO,
PDFileFormat,
PDFileWriter,
Rope,
ImagerPixelMaps,
Mopcodes
;

PDFileWriterImpl: CEDAR PROGRAM
IMPORTS Atom, FileIO, Inline, ImagerPixelMaps, IO, Rope
EXPORTS PDFileWriter
= BEGIN

BlockTransfer: UNSAFE PROC [source: LONG POINTER, count: CARDINAL, dest: LONG POINTER]
~ UNCHECKED MACHINE CODE {Mopcodes.zBLTL};

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;
BlockTransfer[source: source, count: count, dest: dest];
};

bytesPerWord: CARDINAL = Environment.bytesPerWord;
bitsPerWord: CARDINAL = Environment.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;
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.
length: CARDINAL _ 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,
firstToner: Toner,
lastToner: Toner,
bands: ARRAY Toner OF Bands,
selectedBands: Bands _ NIL,
selectedBandNum: NAT _ 0,
sMinPage: CARDINAL,
sMaxPage: CARDINAL,
fMinPage: CARDINAL,
fMaxPage: CARDINAL,
currentPage: CARDINAL _ 1,
currentLoadLocation: INT _ 0,
loadWrittenLength: INT _ 0,
loadSizeInWords: INT,
leftOverMode: BOOLEAN,
priorityImportant: BOOLEAN,
loadDescription: LoadDescription,
overflowStream: IO.STREAM _ NIL,
overflowFileName: ROPE _ NIL
];

Create: PUBLIC PROC [fileName: ROPE, deviceCode: PDFileFormat.DeviceCode, sResolution, fResolution, imageSSize, imageFSize: CARDINAL, nColors: NAT, 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.firstToner _ SELECT nColors FROM
1, 4 => black,
3 => cyan,
ENDCASE => ERROR;
pdState.lastToner _ SELECT nColors FROM
1 => black,
3, 4 => yellow,
ENDCASE => ERROR;
nBands _ (pdState.herald.imageSSize+pdState.herald.bandSSize-1)/pdState.herald.bandSSize;
FOR t: Toner IN [pdState.firstToner..pdState.lastToner] DO
pdState.bands[t] _ NEW [BandsRec[nBands]];
ENDLOOP;
pdState.stream _ FileIO.Open[fileName, overwrite];
WriteHerald[pdState];
};

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

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

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

SetColorTile: PUBLIC PROC [pdState: PDState, toner: Toner, tileRef: LoadReference, tFlag: TFlag] = TRUSTED {
loadEntry: LoadEntryDescription _ pdState.loadDescription[tileRef];
reference: Environment.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;
pdState.colorDescriptor[toner] _ [
colorId: colorId,
length: SIZE[PDFileFormat.Command] + SIZE[PDFileFormat.SetColorTile],
command: [control[setColorTile, tBit]],
setColorTile: [addr: reference.lc]
];
};

DoForEachToner: PUBLIC PROC [pdState: PDState, proc: PROC[Toner]] = {
FOR toner: Toner IN [pdState.firstToner..pdState.lastToner] DO
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
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
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: Environment.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
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
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: Environment.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
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
currentToner _ toner;
deliverProc[CaptureRun];
PutBuffer[];
ENDLOOP;
};

ColorSamples: PUBLIC PROC [pdState: PDState, toner: Toner, sMin, fMin: CARDINAL, sSize, fSize: CARDINAL, deliverProc: DeliverSampleArrayProc, tFlag: TFlag] = TRUSTED {
tBit: [0..1] = IF tFlag = opaque THEN PDFileFormat.opaqueFlag ELSE PDFileFormat.transparentFlag;
colorCommand: PDFileFormat.Command _ [imaging[colorSamples, tBit]];
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;
};
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]];
rows: NAT _ pdState.loadSizeInWords/200;
columns: NAT _ (pdState.loadSizeInWords+rows-1)/rows;
temp: ImagerPixelMaps.PixelMap _ ImagerPixelMaps.Create[4, [0,0,rows,columns]];
loadDescription.storageRef _ temp.refRep.ref;
loadDescription.pointer _ temp.refRep.pointer;
loadDescription.words _ temp.refRep.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, 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: Inline.HighHalf[origin],
offsetLowBits: Inline.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 _ Inline.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: Inline.HighHalf[startOffset],
offsetLowBits: Inline.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 _ Inline.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: Inline.HighHalf[startOffset],
offsetLowBits: Inline.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];
WriteStartImage[
pdState: pdState,
feed: t = pdState.firstToner,
strip: t = pdState.lastToner,
toner: t,
passBands: startBand,
nBands: nBands,
fMinPage: pdState.fMinPage,
fSizePage: fSizePage
];
WriteBands[pdState, bands, startBand, nBands];
ENDLOOP;
pdState.sMinPage _ pdState.herald.imageSSize;
pdState.fMinPage _ pdState.herald.imageFSize;
pdState.sMaxPage _ pdState.fMaxPage _ 0;
pdState.currentPage _ pdState.currentPage + 1;
IF pdState.overflowStream # NIL THEN pdState.overflowStream.SetIndex[0];
};

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

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

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: Environment.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.overflowFileName _ Atom.GetPName[Atom.Gensym['A]].Concat["$"];
pdState.overflowStream _ FileIO.Open[pdState.overflowFileName, overwrite];
};
bandBuffer.overflowIndices _ CONS[
IO.GetIndex[pdState.overflowStream],
bandBuffer.overflowIndices
];
pdState.overflowStream.UnsafePutBlock[[base: bandDataPtr, startIndex: 0, stopIndexPlusOne: 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: IO.UnsafeBlock = [base: loadDescription.pointer+pdState.loadWrittenLength, startIndex: 0, stopIndexPlusOne: 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 {
unsafeBlock: IO.UnsafeBlock = [base: @lc, startIndex: 0, stopIndexPlusOne: SIZE[LONG CARDINAL]*bytesPerWord];
pdState.stream.UnsafePutBlock[unsafeBlock];
};

WriteCardinal: PROC [pdState: PDState, c: CARDINAL] = TRUSTED {
unsafeBlock: IO.UnsafeBlock = [base: @c, startIndex: 0, stopIndexPlusOne: SIZE[CARDINAL]*bytesPerWord];
pdState.stream.UnsafePutBlock[unsafeBlock];
};

WriteHerald: PROC [pdState: PDState] = TRUSTED {
unsafeBlock: IO.UnsafeBlock = [base: @pdState.herald, startIndex: 0, stopIndexPlusOne: SIZE[PDFileFormat.Herald]*bytesPerWord];
pdState.stream.UnsafePutBlock[unsafeBlock];
};

WriteControlCommand: PROC [pdState: PDState, controlCom: PDFileFormat.ControlCom] = TRUSTED {
command: PDFileFormat.Command _ [control[controlCom]];
unsafeBlock: IO.UnsafeBlock = [base: @command, startIndex: 0, stopIndexPlusOne: SIZE[PDFileFormat.Command]*bytesPerWord];
pdState.stream.UnsafePutBlock[unsafeBlock];
};

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]
];
unsafeBlock: IO.UnsafeBlock = [base: @startImageBuf, startIndex: 0, stopIndexPlusOne: SIZE[StartImageBuf]*bytesPerWord];
pdState.stream.UnsafePutBlock[unsafeBlock];
};

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;
pdState.overflowStream.SetIndex[overflowIndices.first];
IF bandBufferSize*bytesPerWord #
pdState.overflowStream.UnsafeGetBlock[[
base: @overflowBuf,
startIndex: 0,
stopIndexPlusOne: bandBufferSize*bytesPerWord
]]
THEN ERROR;
pdState.stream.UnsafePutBlock[[base: @overflowBuf, startIndex: 0, stopIndexPlusOne: bandBufferSize*bytesPerWord]];
overflowIndices _ overflowIndices.rest;
ENDLOOP;
pdState.stream.UnsafePutBlock[[base: @(bandBuffer.word), startIndex: 0, stopIndexPlusOne: bandBuffer.length*bytesPerWord]];
bandBuffer.length _ 0;
};
WriteControlCommand[pdState, endBand];
ENDLOOP;
};

END.

æPDFileWriterImpl.mesa
Michael Plass, November 22, 1983 2:53 pm
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.
Writes out any additions to the font load
Writes out the bands, resetting them along the way.
Reverse the list of overflow indices.
�Ê È˜Jš
œ™J™(š
Ïk	˜	J˜J˜J˜J˜J˜Jš
œ
˜
Jš
œ
˜
J˜J˜J˜J˜
J˜—šœ�œ
�˜Jš�œ(�œ˜7Jš�œ
˜šœ�˜J˜—šÏn
œ�œ
�œ
�œ
�œ	�œ�œ
�œ
˜VJšœ�	œ
�œ
�œ˜*J˜—šžœ�œ
�œ
�œ
�œ	�œ�œ
�œ�	œ˜cš�œ	�œ
�œ�˜Jšœ%�œ
�œ˜AJšœ�œ
�œ˜!Jšœ�œ
�œ˜Jšœ�œ
�œ˜Jš�œ
˜—Jš
œ8˜8Jš
œ˜J˜—Jšœ�œ˜2Jšœ
�œ˜0Jš�œ�œ�œ
˜Jšœ�œ�œ
˜Jšžœ�œ$˜=Jšžœ�œ˜3Jšžœ�œ'˜CJšžœ�œ$˜=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šœ�œŸ(˜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˜—šžœ�œ
�œ�œY�œ�œ
�œ
�œ�œ�œ�œ˜ƒJšœ�œ
˜Jšœ
�œ˜Jš
œ˜Jš
œ'˜'Jš
œ)˜)Jš
œ)˜)Jš
œ:˜:Jš
œ:˜:Jš
œ%˜%Jš
œ˜Jš
œ˜Jšœ�œ
˜'Jš
œ$˜$Jšœ�œ
˜"Jš
œ(˜(šœ�œ	�˜(J˜Jš
œ
˜
Jš�œ�œ
˜—šœ�œ	�˜'J˜Jš
œ˜Jš�œ�œ
˜—Jš
œY˜Yš�œ
�œ)�˜:Jšœ�œ˜*Jš�œ
˜—Jš
œ2˜2š
œ˜J™=—Jš
œ˜J˜—šžœ�œ
�œ'�œ�œ�œ˜uJš
œ*˜*Jš
œ.˜.Jš
œ˜J˜—šžœ�œ
�œ%˜=Jš
œT˜TJšœ(�œ˜CJš
œ@˜@Jš
œ˜J˜—šž
œ�œ
�œ%˜?Jš
œT˜TJšœ(�œ˜CJš
œB˜BJš
œ˜J˜—šžœ�œ
�œJ�œ˜lJš
œC˜CJš
œp˜pJšœ	�œ.˜:Jšœ�œ�œ�œ˜`Jš�œ �œ
�œ
˜-š
œ"˜"Jš
œ˜Jšœ�œ�œ˜EJš
œ'˜'Jš
œ"˜"Jš
œ˜—Jš
œ˜J˜—šžœ�œ
�œ�œ˜Eš�œ�œ)�˜>Jš
œ˜Jš�œ
˜—Jš
œ˜J˜—š
ž	œ�œ
�œ�œ�œ˜LJš
œ!˜!Jš
œ!˜!Jš
œ˜J˜—šž
œ�œ
�œ �œ�œ�œ˜gJš	œ�œ�œ�œ�œ˜GJšœ�œ˜/Jš
œ<˜<Jš
œX˜XJš
œ˜Jš
œ.˜.š�œ�œ)�˜>Jšœ�œ�œ
˜DJš
œ!˜!Jšœ!�œ˜=Jšœ"�œ˜Dš�œ�œ �œ�˜>Jš
œ˜Jšœ!�œ˜=Jšœ"�œ˜DJš�œ
˜—Jš�œ
˜—Jš
œ˜J˜—šž
œ�œ
�œ!�œ�œ�œ�œ˜†
Jš	œ�œ�œ�œ�œ˜GJšœ�œ˜/Jš
œ<˜<Jš
œ€
˜€
Jšœ�œ˜-Jšœ �œ&˜Iš�œ�œ)�˜>Jšœ�œ�œ
˜DJš
œ!˜!Jšœ!�œ˜=Jšœ"�œ˜Dš�œ�œ �œ�˜>Jš
œ˜Jšœ!�œ˜=Jšœ"�œ˜DJš�œ
˜—Jš�œ
˜—Jš
œ˜J˜—šžœ�œ
�œ5�œ�œ�œ˜uJš
œF˜FJš
œp˜pJš
œT˜Tš
œ%˜%Jš
œ%˜%Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœ�œ
�œ
�œK˜jJš	œ�œ�œ�œ�œ˜WJšœ�œ˜/Jš�œ#�œ
�œ
˜0Jš
œ˜Jš
œN˜Nš�œ�œ)�˜>Jšœ�œ�œ
˜DJš
œ!˜!Jšœ!�œ˜=Jšœ�œ˜Aš�œ�œ �œ�˜>Jš
œ˜Jšœ!�œ˜=Jšœ�œ˜AJš�œ
˜—Jš�œ
˜—Jš
œ˜J˜—šžœ�œ
�œ�œ�œ	�œ	�œ)�œ˜ž
Jš
œ:˜:Jšœ�œ˜/Jšœ�œ'˜8Jš
œ˜Jš
œ.˜.š�œ�œ)�˜>Jšœ�œ˜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˜—šžœ�œ
�œ6�œ�œ�œ˜wJš
œG˜GJš
œp˜pJš
œU˜Uš
œ&˜&Jš
œ%˜%Jš
œ˜Jš
œ
˜
Jš
œ˜—Jš	œ
�œ
�œ
�œ
�œ6˜XJš	œ
�œ
�œ
�œ
�œ2˜TJš	œ�œ�œ�œ�œ˜KJšœ�œ˜/Jš�œ$�œ
�œ
˜1Jš
œ˜Jš
œ6˜6š�œ�œ)�˜>Jšœ�œ�œ
˜DJš
œ!˜!Jšœ!�œ˜=Jšœ�œ ˜Bš�œ�œ �œ�˜>Jš
œ˜Jšœ!�œ˜=Jšœ�œ ˜BJš�œ
˜—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š
œ˜—š�œ�œ)�˜>Jš
œ˜Jš
œ˜Jš
œ˜Jš�œ
˜—Jš
œ˜J˜—šžœ�œ
�œ&�œ�œ�œ7�œ˜§
Jšœ�œ�œ�œ˜`Jš
œC˜CJšœ�œ˜/Jšœ�œ'˜8Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜š
žœ�œ�œ
�œ�œ˜Eš�œ�œ˜š
œ"˜"Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœ�œ�œ�œ
˜Fš
œ)˜)Jš
œ-˜-Jš
œ˜Jš
œ˜—Jš
œ˜Jšœ&�œ˜BJšœ�œ˜>Jšœ%�œ˜EJš
œ˜—Jš
œ:˜:Jš
œ(˜(J˜
Jš
œ˜—Jš
œ˜Jš
œ.˜.Jš
œ˜Jš�œ�œ
�œ
˜#Jš�œ
�œ
�œ
˜Jš
œ˜J˜—š
žœ�œ
�œ�œ	�œ˜JJš
œ>˜>Jš�œ�œ
�œB�œ˜uJš
œ˜J˜—šžœ�œ�œ˜Iš�œ�œ
�œ˜'Jšœ#�œ#˜IJšœ�œ˜(Jšœ	�œ)˜5Jš
œO˜OJš
œ-˜-Jš
œ.˜.Jš
œ*˜*Jš
œ˜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š�œ
˜—Jš
œ-˜-Jš
œ-˜-Jš
œ(˜(Jš
œ.˜.Jš�œ�œ
�œ$˜HJš
œ˜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˜—šžœ�œ�œ�œ˜?Jšœ�œ˜,Jšœ�œ˜,Jšœ�œ˜,Jšœ�œ˜,Jš
œ˜J˜—šžœ�œ�œ�œ˜TJšœ	�œ!˜-Jš
œ$˜$Jš�œ�œ
�œ�œ˜WJš
œ˜Jš
œ"˜"Jš
œ˜J˜—šž
œ�œ�œ�œ˜MJšœ	�œ*˜6Jš
œ5˜5Jš
œ3˜3Jšœ�œ˜1Jš
œQ˜QJšœ	�œ!˜-Jš
œ$˜$Jš�œ�œ
�œ�œ˜WJš
œ˜Jš
œ"˜"š�œ!�œ˜*Jš
œ!˜!š�œ�œ˜#Jšœ)�œ˜EJšœ)�œ
�œ˜9J˜—Jš
œi˜iJš
œ˜—Jš
œ˜J˜—šžœ�œ.�œ˜NJšœ
�œ
�œ˜/š�œ�œ
�œ˜&Jš
œF˜FJš
œJ˜JJš
œ˜—šœ�œ
˜"Jš�œ"˜$Jš
œ˜Jš
œ˜—Jš
œy˜yJš
œ˜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š	œ
�œ<�œ
�œ
�œ˜mJš
œ+˜+Jš
œ˜J˜—šž
œ�œ�œ�œ˜?Jšœ
�œ;�œ
�œ˜gJš
œ+˜+Jš
œ˜J˜—šžœ�œ�œ˜0Jšœ
�œH�œ$˜Jš
œ+˜+Jš
œ˜J˜—šžœ�œ;�œ˜]Jš
œ6˜6Jšœ
�œA�œ%˜yJš
œ+˜+Jš
œ˜J˜—šžœ�œ˜Jš
œ˜Jšœ�œ
˜Jšœ�œ
˜Jš
œ
˜
Jšœ�œ
˜Jšœ�œ
˜Jšœ
�œ
˜Jšœ�˜Jšœ�œ˜
š	œ�œ�œ
�	œ
�œ˜0Jš
œ˜Jš
œ˜Jš
œ˜—š
œ ˜ Jš
œ$˜$Jš
Ϣ
˜¢
Jš
œ˜—Jšœ
�œG�œ˜xJš
œ+˜+Jš
œ˜J˜—šž
œ�œ5�œ�œ˜UJ™3š�œ
�œ
�œ�˜4Jš
œ3˜3š�œ�œ
�œ˜Jš	œ�œ
�œ
�œ�œ
˜#J™%š�œ�œ
�˜)Jšœ�œ
�œ
�œ˜,Jš
œ=˜=Jš
œ˜Jš
œ˜Jš�œ
˜—š�œ�œ
�˜Jšœ
�œ�œ
�œ
˜3Jš
œ7˜7š�œ˜ š
œ'˜'Jš
œ˜Jš
œ˜Jš
œ-˜-Jš
œ˜——Jš�œ
�œ
˜Jš
œr˜rJš
œ'˜'Jš�œ
˜—Jš
œ{˜{Jš
œ˜Jš
œ˜—Jš
œ&˜&Jš�œ
˜—Jš
œ˜J˜—Jš�œ
˜——…—u—¶