DIRECTORY
CStrings USING [CString],
ImagerClipper USING [Clipper],
ImagerDevice USING [EasyMetrics],
ImagerFont USING [XChar],
ImagerError USING [ErrorCode],
ImagerBox USING [Rectangle],
Scaled USING [Value],
Vector2 USING [VEC];

CII: DEFINITIONS
= BEGIN

CProc: TYPE = RECORD [CARD];
CString: TYPE = CStrings.CString;

ScaledValue: TYPE = RECORD [Scaled.Value];

RES: TYPE = MACHINE DEPENDENT {ok(0), base(1000), last(1255)};
RESFromErrorCode: SAFE PROC [code: ImagerError.ErrorCode] RETURNS [RES] = CHECKED INLINE {
RETURN [IF code = $ok THEN $ok ELSE VAL[ORD[RES.base] + ORD[code]]]
};

Handle: TYPE = REF ObjectRep;
Rectangle: TYPE = ImagerBox.Rectangle;
VEC: TYPE = Vector2.VEC;
Color: TYPE = REF ColorRep;
ColorRep: TYPE;
ColorOperator: TYPE = REF ColorOperatorRep;
ColorOperatorRep: TYPE;

Matrix: TYPE = ARRAY [0..6) OF REAL;

SetMatrix: SetMatrixProc;
SetMatrixProc: TYPE = PROC [h: Handle, matrix: POINTER TO Matrix] RETURNS [RES];

GetMatrix: GetMatrixProc;
GetMatrixProc: TYPE = PROC [h: Handle, matrixResult: POINTER TO Matrix] RETURNS [RES];

SetInitialMatrix: SetInitialMatrixProc;
SetInitialMatrixProc: TYPE =  PROC [h: Handle, matrix: POINTER TO Matrix] RETURNS [RES];

GetInitialMatrix: GetInitialMatrixProc;
GetInitialMatrixProc: TYPE =  PROC [h: Handle, matrixResult: POINTER TO Matrix] RETURNS [RES];

SampleRange: TYPE = RECORD [sWhite: REAL, sBlack: REAL];

MakeGrayColorOperator: MakeGrayColorOperatorProc;
MakeGrayColorOperatorProc: TYPE = PROC [h: Handle, sampleRange: POINTER TO SampleRange, sampleTableSize: CARD, sampleTable: POINTER TO ARRAY [0..0) OF REAL, colorOperatorResult: POINTER TO ColorOperator] RETURNS [RES];

MakeRGBColorOperator: MakeRGBColorOperatorProc;
MakeRGBColorOperatorProc: TYPE = PROC [h: Handle, sampleRange: POINTER TO SampleRange, sampleTableSize: CARD, sampleTableR: POINTER TO ARRAY [0..0) OF REAL, sampleTableG: POINTER TO ARRAY [0..0) OF REAL, sampleTableB: POINTER TO ARRAY [0..0) OF REAL, colorOperatorResult: POINTER TO ColorOperator] RETURNS [RES];

MakeCMYKColorOperator: MakeCMYKColorOperatorProc;
MakeCMYKColorOperatorProc: TYPE = PROC [h: Handle, sampleRange: POINTER TO SampleRange, sampleTableSize: CARD, sampleTableC: POINTER TO ARRAY [0..0) OF REAL, sampleTableM: POINTER TO ARRAY [0..0) OF REAL, sampleTableY: POINTER TO ARRAY [0..0) OF REAL, sampleTableK: POINTER TO ARRAY [0..0) OF REAL, colorOperatorResult: POINTER TO ColorOperator] RETURNS [RES];

MakeHighlightColorOperator: MakeHighlightColorOperatorProc;
MakeHighlightColorOperatorProc: TYPE = PROC [h: Handle, sampleRange: POINTER TO SampleRange, baseColor: Color, highlightColor: Color, sampleTableSize: CARD, sampleTableBaseColor: POINTER TO ARRAY [0..0) OF REAL, sampleTableHighlightColor: POINTER TO ARRAY [0..0) OF REAL, colorOperatorResult: POINTER TO ColorOperator] RETURNS [RES];

MakeColor: MakeColorProc;
MakeColorProc: TYPE = PROC [h: Handle, colorOperator: ColorOperator, samplesPerPixel: CARD, pixel: POINTER TO ARRAY [0..0) OF REAL, colorResult: POINTER TO Color] RETURNS [RES];

MakeSampledBlack: MakeSampledBlackProc;
MakeSampledBlackProc: TYPE = PROC [h: Handle, bitmap: POINTER TO RasterRep, pixelToDevice: POINTER TO Matrix, clear: BOOL, colorResult: POINTER TO Color] RETURNS [RES];

SetColor: SetColorProc;
SetColorProc: TYPE = PROC [h: Handle, color: Color] RETURNS [RES];

SetGray: SetGrayProc;
SetGrayProc: TYPE = PROC [h: Handle, gray: POINTER TO REAL] RETURNS [RES];

SetRGB: SetRGBProc;
SetRGBProc: TYPE = PROC [h: Handle, rgb: POINTER TO ARRAY [0..3) OF REAL] RETURNS [RES];

SetHSV: SetHSVProc;
SetHSVProc: TYPE = PROC [h: Handle, hsv: POINTER TO ARRAY [0..3) OF REAL] RETURNS [RES];

SetCMYK: SetCMYKProc;
SetCMYKProc: TYPE = PROC [h: Handle, cmyk: POINTER TO ARRAY [0..4) OF REAL] RETURNS [RES];

GetColor: GetColorProc;
GetColorProc: TYPE = PROC [h: Handle, colorResult: POINTER TO Color] RETURNS [RES];


LookupTable: TYPE = REF LookupTableRep;
LookupTableRep: TYPE;

MakeLookupTable: MakeLookupTableProc;
MakeLookupTableProc: TYPE = PROC [h: Handle, tableSize: CARD, table: POINTER TO ARRAY [0..0) OF REAL, lookupTableResult: POINTER TO LookupTable] RETURNS [RES];

DestroyLookupTable: DestroyLookupTableProc;
DestroyLookupTableProc: TYPE = PROC [h: Handle, lookupTable: LookupTable] RETURNS [RES];

ColorLookupTableType: TYPE = MACHINE DEPENDENT { redTransfer, greenTransfer, blueTransfer, grayTransfer, blackGeneration, undercolorRemoval };
SetColorLookupTable: SetColorLookupTableProc;
SetColorLookupTableProc: TYPE = PROC [h: Handle, which: ColorLookupTableType, lookupTable: LookupTable] RETURNS [RES];

GetColorLookupTable: GetColorLookupTableProc;
GetColorLookupTableProc: TYPE = PROC [h: Handle, which: ColorLookupTableType, lookupTableResult: POINTER TO LookupTable] RETURNS [RES];


FillType: TYPE = MACHINE DEPENDENT { nonZero, eo };

PathGenerator: TYPE = POINTER TO PathGeneratorObjectRep;
PathGeneratorObjectRep: TYPE = RECORD [
data: POINTER,
proc: CProc
];

GeneratePathProc: TYPE = PROC [self: PathGenerator, sink: PathSink] RETURNS [RES];

PathSink: TYPE = POINTER TO PathSinkObjectRep;
PathSinkObjectRep: TYPE = RECORD [
data: POINTER,
moveTo: CProc,
lineTo: CProc,
curveTo: CProc,
conicTo: CProc
];

PathGeneratorProc: TYPE = PROC [self: PathGenerator, p: PathSink] RETURNS [RES];

MoveToProc: TYPE = PROC [sink: PathSink, p: POINTER TO <<READONLY>> VEC] RETURNS [RES];

LineToProc: TYPE = PROC [sink: PathSink, p: POINTER TO <<READONLY>> VEC] RETURNS [RES];

CurveToProc: TYPE = PROC [sink: PathSink, p: POINTER TO <<READONLY>> ARRAY[0..3) OF VEC] RETURNS [RES];

ConicControlRep: TYPE = RECORD [
p1, p2: VEC,
s: REAL
];

ConicToProc: TYPE = PROC [sink: PathSink, c: POINTER TO <<READONLY>> ConicControlRep] RETURNS [RES];

Clip: ClipProc;
ClipProc: TYPE = PROC [h: Handle, pathGenerator: PathGenerator, fillType: FillType] RETURNS [RES];

Clipper: TYPE = ImagerClipper.Clipper;

GetClipper: GetClipperProc;
GetClipperProc: TYPE = PROC [h: Handle, clipperResult: POINTER TO Clipper] RETURNS [RES];

SetClipper: SetClipperProc;
SetClipperProc: TYPE = PROC [h: Handle, clipper: Clipper] RETURNS [RES];

MaskFill: MaskFillProc;
MaskFillProc: TYPE = PROC [h: Handle, pathGenerator: PathGenerator, fillType: FillType] RETURNS [RES];

MaskRectangle: MaskRectangleProc;
MaskRectangleProc: TYPE = PROC [h: Handle, rect: POINTER TO <<READONLY>> Rectangle] RETURNS [RES];

CIIEndType: TYPE = MACHINE DEPENDENT {squareEnd, buttEnd, roundEnd, triangularEnd};
CIIJointType: TYPE = MACHINE DEPENDENT {miterJoint, bevelJoint, roundJoint, triangularJoint, noJoint, miterclipJoint, miterbevelJoint};

StrokeControlRep: TYPE = RECORD [
closed: BOOL,
end: CIIEndType,
joint: CIIJointType,
miterLimit: REAL,
strokeWidth: REAL,
dashCount: INT,
dashArray: POINTER TO ARRAY [0..0) OF REAL,
dashOffset: REAL,
dashCorrectLength: REAL,
strokeAdjust: BOOL,
thickening: VEC,
minThickness: VEC,
stamp: INT
];

MaskStroke: MaskStrokeProc;
MaskStrokeProc: TYPE = PROC [h: Handle, pathGenerator: PathGenerator, s: POINTER TO <<READONLY>> StrokeControlRep] RETURNS [RES];

VectorEndpoints: TYPE = RECORD [
p1, p2: VEC
];

MaskVector: MaskVectorProc;
MaskVectorProc: TYPE = PROC [h: Handle, endpoints: POINTER TO VectorEndpoints, s: POINTER TO <<READONLY>> StrokeControlRep] RETURNS [RES];

RasterRep: TYPE = MACHINE DEPENDENT RECORD [
sMinBox: INT,
fMinBox: INT,
sMaxBox: INT,
fMaxBox: INT,
bitsPerSample: CARDINAL,
bitsPerLine: CARDINAL,
basePointer: POINTER,
bitIndex: CARDINAL,
ref: REF
];

MaskBitmap: MaskBitmapProc;
MaskBitmapProc: TYPE = PROC [h: Handle, raster: POINTER TO <<READONLY>> RasterRep, background: Color] RETURNS [RES];

MaskDeviceTrapezoid: MaskDeviceTrapezoidProc;
MaskDeviceTrapezoidProc: TYPE = PROC [h: Handle, sMin, fMin, sMax, fMax: INT, f0, df0, f1, df1: ScaledValue] RETURNS [RES];

RunRep: TYPE = RECORD [fMin: INT, fSize: CARD];
LineRunsRep: TYPE = RECORD [numOfRuns: CARD, run: POINTER TO ARRAY [0..0) OF RunRep];
MaskRuns: MaskRunsProc;
MaskRunsProc: TYPE = PROC [h: Handle, sMin: INT, numOfLines: CARD, lineRuns: POINTER TO ARRAY [0..0) OF LineRunsRep] RETURNS [RES];

MaskProgram: TYPE = REF MaskProgramRep;
MaskProgramRep: TYPE;
MakeMaskProgram: MakeMaskProgramProc;
MakeMaskProgramProc: TYPE = PROC [h: Handle, codeVersion: INT, bigEndian: BOOL, codeString: CString, maskProgramResult: POINTER TO MaskProgram] RETURNS [RES];

MaskDeviceBoxes: MaskDeviceBoxesProc;
MaskDeviceBoxesProc: TYPE = PROC [h: Handle, sMin, fMin, sMax, fMax: INT, boxOrder: INT, maskProgram: MaskProgram, maskDataByteCount: INT, maskData: POINTER] RETURNS [RES];

BuildClipperBegin: BuildClipperBeginProc; 
BuildClipperBeginProc: TYPE = PROC [h: Handle] RETURNS [RES];

BuildClipperEnd: BuildClipperEndProc;
BuildClipperEndProc: TYPE = PROC [h: Handle] RETURNS [RES];

Font: TYPE = REF FontRep;
FontRep: TYPE;

FindFont: FindFontProc;
FindFontProc: TYPE = PROC [h: Handle, fontName: CString, fontResult: POINTER TO Font] RETURNS [RES];

ModifyFont: ModifyFontProc;
ModifyFontProc: TYPE = PROC [h: Handle, font: Font, mp: POINTER TO <<READONLY>> Matrix, fontResult: POINTER TO Font] RETURNS [RES];

MakeFontAtom: ModifyFontProc;

XChar: TYPE = ImagerFont.XChar;
XChars: TYPE = RECORD [
SEQUENCE COMPUTED CARDINAL OF XChar
];

ShowArgs: TYPE = RECORD [
fontAtom: Font,
easyMetrics: ImagerDevice.EasyMetrics,
noImage: BOOL,
hardChar: CProc, -- a DoHardCharProc
hardMetrics: CProc, -- a DoHardMetricsProc
cp: VEC,
start: INT,
end: INT,
characters: POINTER TO XChars,
clientData: POINTER
];

Show: ShowProc;
ShowProc: TYPE = PROC [h: Handle, s: POINTER TO ShowArgs] RETURNS [RES];

DoHardChar: DoHardCharProc;
DoHardCharProc: TYPE = PROC [h: Handle, s: POINTER TO ShowArgs] RETURNS [RES];

MaskInfo: TYPE = RECORD [
fontAtom: Font,
charCode: XChar,
deltaX: ScaledValue,
deltaY: ScaledValue,
minX, minY, maxX, maxY: INT
];

DoHardMetrics: DoHardMetricsProc;
DoHardMetricsProc: TYPE = PROC [h: Handle, s: POINTER TO ShowArgs, maskInfo: POINTER TO MaskInfo] RETURNS [RES];

BufferedSeparationImage: BufferedSeparationImageProc;
BufferedSeparationImageProc: TYPE = PROC [h: Handle, buffers: POINTER TO ARRAY[0..0) OF POINTER TO RasterRep, samplesPerPixel: CARD, sMin, sMax: INT, colorOperator: ColorOperator, interpolate: BOOL] RETURNS [RES];

BufferedInterleavedImage: BufferedInterleavedImageProc;
BufferedInterleavedImageProc: TYPE = PROC [h: Handle, buffer: POINTER TO RasterRep, samplesPerPixel: CARD, sMin, sMax: INT, colorOperator: ColorOperator, interpolate: BOOL] RETURNS [RES];

ImageSourceReadProc: TYPE = PROC [self: ImageSource, buf: POINTER, nbytes: CARD, nbytesResult: POINTER TO CARD] RETURNS [RES];

ImageSourceDestroyProc: TYPE = PROC [self: ImageSource] RETURNS [RES];

ImageSource: TYPE = POINTER TO ImageSourceObjectRep;
ImageSourceObjectRep: TYPE = RECORD [
data: POINTER,
read: CProc,
destroy: CProc
];

StreamImage: StreamImageProc;
StreamImageProc: TYPE = PROC [h: Handle, sSize: CARD, fSize: CARD, bitsPerSample: CARD, samplesPerPixel: CARD, padMod: CARD, co: ColorOperator, interpolate: BOOL, source: ImageSource] RETURNS [RES];

MaskStreamBits: MaskStreamBitsProc;
MaskStreamBitsProc: TYPE = PROC [h: Handle, sSize: CARD, fSize: CARD, padMod: CARD, source: ImageSource, background: Color] RETURNS [RES];

ApplyCCITTFacsimileDecompressionFilter: ApplyCCITTFacsimileDecompressionFilterProc;
ApplyCCITTFacsimileDecompressionFilterProc: TYPE = PROC [h: Handle, input: ImageSource, k: INT, requireEOL: BOOL, padMod: CARD, sSize: CARD, fSize: CARD, endOfBlock: BOOL, blackIs1: BOOL, msbFirst: BOOL, damagedRowsBeforeError: INT, filteredResult: POINTER TO ImageSource] RETURNS [RES];

Destroy: DestroyProc;
DestroyProc: TYPE = PROC [h: Handle] RETURNS [RES];

RegisterCleanupObject: RegisterCleanupObjectProc;
UnRegisterCleanupObject: RegisterCleanupObjectProc;
RegisterCleanupObjectProc: TYPE = PROC [h: Handle, cleanupObject: CleanupObject]  RETURNS [RES];

CleanupProc: TYPE = PROC [self: CleanupObject, h: Handle] RETURNS [RES];
CleanupObject: TYPE = POINTER TO CleanupObjectRep;
CleanupObjectRep: TYPE = RECORD [
data: POINTER,
Cleanup: CProc
];

DestroyColor: DestroyColorProc;
DestroyColorProc: TYPE = PROC [h: Handle, color: Color] RETURNS [RES];

DestroyColorOperator: DestroyColorOperatorProc;
DestroyColorOperatorProc: TYPE = PROC [h: Handle, colorOperator: ColorOperator] RETURNS [RES];

DestroyClipper: DestroyClipperProc;
DestroyClipperProc: TYPE = PROC [h: Handle, clipper: Clipper] RETURNS [RES];

DestroyMaskProgram: DestroyMaskProgramProc;
DestroyMaskProgramProc: TYPE = PROC [h: Handle, maskProgram: MaskProgram] RETURNS [RES];

DestroyFont: DestroyFontProc;
DestroyFontProc: TYPE = PROC [h: Handle, font: Font] RETURNS [RES];

Toner: TYPE = MACHINE DEPENDENT {black, cyan, magenta, yellow, white, red, green, blue, (255)};
HalftonePropertiesForSeparation: TYPE = RECORD [
type: CString,
toner: Toner,
maxSample: CARDINAL,
thresholds: RasterRep,
phase: NAT,
reserved: POINTER
];

HalftoneProperties: TYPE = REF HalftonePropertiesRep;
HalftonePropertiesRep: TYPE;

MakeHalftoneProperties: MakeHalftonePropertiesProc;
MakeHalftonePropertiesProc: TYPE = PROC [h: Handle, separationCount: INT, halftonePropertiesForSeparation: POINTER TO ARRAY [0..0) OF HalftonePropertiesForSeparation, halftonePropertiesResult: POINTER TO HalftoneProperties] RETURNS [RES];

SetHalftoneProperties: SetHalftonePropertiesProc;
SetHalftonePropertiesProc: TYPE = PROC [h: Handle, halftoneProperties: HalftoneProperties] RETURNS [RES];

GetHalftoneProperties: GetHalftonePropertiesProc;
GetHalftonePropertiesProc: TYPE = PROC [h: Handle, halftonePropertiesResult: POINTER TO HalftoneProperties] RETURNS [RES];

DestroyHalftoneProperties: DestroyHalftonePropertiesProc;
DestroyHalftonePropertiesProc: TYPE = PROC [h: Handle, halftoneProperties: HalftoneProperties] RETURNS [RES];

DefaultSetOutputBuffers: SetOutputBuffersProc;
SetOutputBuffersProc: TYPE = PROC [h: Handle, nBuffers: INT, outputBuffers: POINTER TO ARRAY [0..0) OF RasterRep] RETURNS [RES];

DefaultSetSeparation: SetSeparationProc;
SetSeparationProc: TYPE = PROC [h: Handle, toner: Toner] RETURNS [RES];

DefaultSetColorTable: SetColorTableProc;
SetColorTableProc: TYPE = PROC [h: Handle, name: CString, identification: CString, format: CString, tableBase: POINTER, tableByteLength: CARD, replacementHint: CARD, stampValueResult: POINTER TO CARD] RETURNS [RES];

DefaultSync: SyncProc;
SyncProc: TYPE = PROC [h: Handle, operationName: CString, format: CString, dataPointer: POINTER, dataByteLength: CARD] RETURNS [RES];

ObjectRep: TYPE = RECORD [
data: REF,
procs: SEQUENCE COMPUTED CARDINAL OF CProc
];

MakeHandle: PROC [
data: REF,
SetOutputBuffers: SetOutputBuffersProc ¬ DefaultSetOutputBuffers,
SetSeparation: SetSeparationProc ¬ DefaultSetSeparation,
SetColorTable: SetColorTableProc ¬ DefaultSetColorTable,
Sync: SyncProc ¬ DefaultSync
] RETURNS [Handle];

END.
H
CII.mesa
Copyright Σ 1993 by Xerox Corporation.  All rights reserved.
Michael Plass, October 28, 1993 12:12 pm PDT
GrayColorOperatorParameters: TYPE = RECORD [
sWhite: REAL,
sBlack: REAL,
sampleTableSize: CARD,
sampleTable: POINTER TO ARRAY [0..0) OF REAL
];

RGBColorOperatorParameters: TYPE = RECORD [
sWhite: REAL,
sBlack: REAL,
sampleTableSize: CARD,
sampleTableR: POINTER TO ARRAY [0..0) OF REAL,
sampleTableG: POINTER TO ARRAY [0..0) OF REAL,
sampleTableB: POINTER TO ARRAY [0..0) OF REAL
];

CMYKColorOperatorParameters: TYPE = RECORD [
sWhite: REAL,
sBlack: REAL,
sampleTableSize: CARD,
sampleTableC: POINTER TO ARRAY [0..0) OF REAL,
sampleTableM: POINTER TO ARRAY [0..0) OF REAL,
sampleTableY: POINTER TO ARRAY [0..0) OF REAL,
sampleTableK: POINTER TO ARRAY [0..0) OF REAL
];

HighlightColorOperatorParameters: TYPE = RECORD [
sWhite: REAL,
sBlack: REAL,
baseColor: Color,
highlightColor: Color,
sampleTableSize: CARD,
sampleTableBaseColor: POINTER TO ARRAY [0..0) OF REAL,
sampleTableHighlightColor: POINTER TO ARRAY [0..0) OF REAL
];

For this, data must be a CIIPrivate.State
Κe–
"cedarcode" style•NewlineDelimiter

™™Jšœ
Οe
œ1™<J™,—Icode˜š
Οk	˜	Kšœ	žœ˜Kšœžœ˜Kšœ
žœ˜!Kšœžœ	˜Kšœžœ
˜Kšœ
žœ
˜Kšœžœ	˜Kšœžœžœ˜—K˜Kšžœž˜šœž˜K˜Kšœžœžœžœ˜šœ	žœ˜!K˜—šœ
žœžœ˜*K˜—Kšžœžœžœ
ž	œ!˜>šΟnœžœ
žœžœžœžœ
žœ˜ZKšžœžœžœžœ
žœ
žœ
žœ	žœ˜CKš
œ˜K˜—Kšœžœžœ˜Kšœžœ˜&Kšžœžœžœ
˜Kšœžœžœ
˜Kšœ
žœ
˜Kšœžœžœ˜+šœžœ
˜K˜—š	œžœžœžœ
žœ
˜$K˜—KšŸ	œ˜š
œžœžœžœ
žœ	žœžœ˜PK˜—KšŸ	œ˜š
œžœžœžœ
žœ	žœžœ˜VK˜—KšŸœ˜'šœœžœžœžœ
žœ	žœžœ˜XK˜—KšŸœ˜'š
œžœžœžœ
žœ	žœžœ˜^K˜—š	œ
žœžœ
žœ
žœ˜8K˜—šœžœžœ™,Kšœžœ
™
Kšœžœ
™
Kšœžœ
™Kš
œ
žœ
žœ
žœžœ
ž™,Kš
œ™K™—KšŸœ˜1šœžœžœžœ
žœžœžœ
žœ
žœžœ
žœžœ
žœžœžœ˜Ϊ
K˜—šœžœžœ™+Kšœžœ
™
Kšœžœ
™
Kšœžœ
™Kšœžœ
žœ
žœžœ
žœ
™.Kšœžœ
žœ
žœžœ
žœ
™.Kš
œžœ
žœ
žœžœ
ž™-Kš
œ™K™—KšŸœ˜/š1œžœžœžœ
žœžœžœ
žœ
žœžœ
žœžœ
žœ
žœžœ
žœžœ
žœ
žœžœ
žœžœ
žœžœžœ˜ΈK˜—šœžœžœ™,Kšœžœ
™
Kšœžœ
™
Kšœžœ
™Kšœžœ
žœ
žœžœ
žœ
™.Kšœžœ
žœ
žœžœ
žœ
™.Kšœžœ
žœ
žœžœ
žœ
™.Kš
œžœ
žœ
žœžœ
ž™-Kš
œ™K™—KšŸœ˜1š;œžœžœžœ
žœžœžœ
žœ
žœžœ
žœžœ
žœ
žœžœ
žœžœ
žœ
žœžœ
žœžœ
žœ
žœžœ
žœžœ
žœžœžœ˜θK˜—šœ"žœžœ™1Kšœžœ
™
Kšœžœ
™
K™K™Kšœžœ
™Kšœžœ
žœ
žœžœ
žœ
™6Kš
œžœ
žœ
žœžœ
ž™:Kš
œ™K™—KšŸœ!˜;š'œ žœžœžœ
žœHžœžœ
žœ
žœžœ
žœžœ
žœ
žœžœ
žœžœ
žœžœžœ˜ΝK˜—KšŸ	œ˜šœžœžœ<žœ	žœ
žœ
žœžœ
žœžœ
žœžœžœ˜±
K˜—KšŸœ˜'šœžœžœžœ
žœžœ
žœžœžœ
žœžœžœ˜¨
K˜—KšŸœ˜š	œžœžœžœžœ˜BK˜—KšŸœ˜šœ
žœžœžœ
žœ
žœžœžœ˜JK˜—KšŸœ
˜šœžœžœžœ
žœ
žœžœ
žœžœžœ˜XK˜—KšŸœ
˜šœžœžœžœ
žœ
žœžœ
žœžœžœ˜XK˜—KšŸœ˜šœ
žœžœžœ
žœ
žœžœ
žœžœžœ˜ZK˜—KšŸœ˜š
œžœžœžœ
žœžœžœ˜SK˜—K˜Kšœ
žœžœ˜'šœžœ
˜K˜—KšŸœ˜%šœžœžœžœ	žœ
žœ
žœžœ
žœžœ
žœžœžœ˜Ÿ
K˜—KšŸœ˜+š	œžœžœ'žœžœ˜XK˜—Kšœžœžœ
ž	œ`˜Ž
KšŸœ˜-š	œžœžœDžœžœ˜vK˜—KšŸœ˜-š
œžœžœ=žœ
žœžœžœ˜‡
K˜—K˜šœ
žœžœ
ž	œ˜3K˜—Kšœžœžœ
žœ˜8šœžœžœ˜'Kšœžœ
˜K˜K˜K˜—š	œžœžœ'žœžœ˜RK˜—Kšœ
žœžœ
žœ˜.šœžœžœ˜"Kšœžœ
˜K˜K˜K˜K˜K˜K˜—š	œžœžœ$žœžœ˜PK˜—šœžœžœžœ
žœžœžœžœ˜WK˜—šœžœžœžœ
žœžœžœžœ˜WK˜—šœ
žœžœžœ
žœžœžœ
žœžœžœ˜gK˜—šœžœžœ˜ Kšœžœ
˜Kšœž˜Kš
œ˜K˜—š
œ
žœžœžœ
žœžœžœ˜dK˜—KšŸœ˜š	œ
žœžœ?žœžœ˜bK˜—šœ	žœ˜&K˜—KšŸ
œ˜š
œžœžœžœ
žœ
žœžœ˜YK˜—KšŸ
œ˜š	œžœžœžœžœ˜HK˜—KšŸœ˜š	œžœžœ?žœžœ˜fK˜—KšŸ
œ˜!š
œžœžœžœ
žœžœžœ˜bK˜—Kšœžœžœ
ž	œ/˜Sšœžœžœ
ž	œa˜‡
K˜—šœžœžœ˜!Kšœžœ
˜
K˜K˜Kšœžœ
˜Kšœ
žœ
˜Kšœžœ
˜Kšœžœ
žœ
žœžœ
žœ
˜+Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœž˜
Kš
œ˜K˜—KšŸ
œ˜š
œžœžœ.žœ
žœ žœžœ˜
K˜—šœžœžœ˜ Kšœž˜Kš
œ˜K˜—KšŸ
œ˜Kšœžœžœžœ
žœžœ
žœ žœžœ˜Š
K˜š	œžœžœ
ž	œ
žœ˜,Kšœ	žœ
˜
Kšœ	žœ
˜
Kšœ	žœ
˜
Kšœ	žœ
˜
Kšœžœ
˜Kšœ
žœ
˜Kšœ
žœ
˜Kšœ
žœ
˜Kšœž˜K˜K˜—KšŸ
œ˜š
œžœžœžœ
žœ,žœžœ˜tK˜—KšŸœ˜-šœžœžœ%žœ!žœžœ˜{K˜—Kš	œžœžœžœ	žœ˜/Kšœ
žœžœ
žœžœ
žœ
žœžœ	˜UKšŸœ˜šœžœžœžœžœžœ
žœ
žœžœžœžœ˜ƒ
K˜—Kšœ
žœžœ˜'Kšœžœ
˜KšŸœ˜%šœžœžœžœ
žœ*žœ
žœžœžœ˜ž
K˜—KšŸœ˜%Kšœžœžœ%žœžœ/žœžœžœžœ˜¬
K˜KšŸœ˜*š	œžœžœ
žœžœ˜=K˜—KšŸœ˜%š	œžœžœ
žœžœ˜;K˜—Kšœžœžœ	˜šœ	žœ
˜K˜—KšŸœ˜š
œžœžœ,žœ
žœžœžœ˜dK˜—KšŸ
œ˜šœžœžœžœ
žœ"žœ
žœžœžœ˜ƒ
K˜—šŸœ˜K˜—Kšœžœ˜šœžœžœ˜Kšžœ
žœ
žœ
žœ˜#Kš
œ˜K˜—šœ
žœžœ˜K˜K˜&Kšœ	žœ
˜KšœΟc˜$Kšœ ˜*Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜	Kšœžœ
žœ˜Kšœž˜Kš
œ˜K˜—KšŸœ˜š
œ
žœžœžœ
žœžœžœ˜HK˜—KšŸ
œ˜š
œžœžœžœ
žœžœžœ˜NK˜—šœ
žœžœ˜K˜K˜K˜K˜Kšœž˜Kš
œ˜K˜—KšŸ
œ˜!šœžœžœžœ
žœžœ
žœžœžœ˜pK˜—KšŸœ˜5šœžœžœžœ
žœ
žœžœ
žœ
žœžœžœ-žœžœžœ˜Υ
K˜—KšŸœ˜7šœžœžœžœ
žœžœžœ-žœžœžœ˜»
K˜—šœžœžœžœ
žœžœ
žœ
žœžœžœ˜~K˜—š	œžœžœžœžœ˜FK˜—Kšœ
žœžœ
žœ˜4šœžœžœ˜%Kšœžœ
˜K˜K˜K˜K˜—KšŸœ˜šœžœžœžœ	žœžœžœ
žœ"žœžœžœ˜Ζ
K˜—KšŸœ˜#šœžœžœžœ	žœ
žœ*žœžœ˜Š
K˜—KšŸ&œ-˜Sšœ,žœžœ$žœžœ
žœ	žœ	žœžœžœžœžœžœ
žœžœžœ˜ŸK˜—KšŸœ˜š	œ
žœžœ
žœžœ˜3K˜—KšŸœ˜1KšŸœ˜3š	œžœžœ,žœžœ˜`K˜—Kš	œ
žœžœ"žœžœ˜HKšœžœžœ
žœ˜2šœžœžœ˜!Kšœžœ
˜K˜K˜K˜—KšŸœ˜š	œžœžœžœžœ˜FK˜—KšŸœ˜/š	œžœžœ+žœžœ˜^K˜—KšŸœ˜#š	œžœžœžœžœ˜LK˜—KšŸœ˜+š	œžœžœ'žœžœ˜XK˜—KšŸœ˜š	œžœžœžœžœ˜CK˜—Kšœžœžœ
ž	œ@˜_šœ!žœžœ˜0K˜K˜
Kšœžœ
˜K˜Kšœžœ
˜Kšœ
ž˜Kš
œ˜K˜—Kšœžœžœ˜5šœžœ
˜K˜—KšŸœ˜3šœžœžœžœ#žœ
žœ
žœžœ<žœ
žœžœžœ˜ξ
K˜—KšŸœ˜1š	œžœžœ5žœžœ˜iK˜—KšŸœ˜1š
œžœžœ'žœ
žœžœžœ˜zK˜—KšŸœ ˜9š	œžœžœ5žœžœ˜mK˜—KšŸœ˜.šœžœžœžœžœ
žœ
žœžœžœžœ˜€
K˜—KšŸœ˜(š	œžœžœžœžœ˜GK˜—KšŸœ˜(šœžœžœQžœžœžœžœ
žœ
žœžœžœ˜Χ
K˜—KšŸœ˜š
œ
žœžœCžœžœžœžœ˜…
K˜—šœžœžœ˜Kšœžœ
˜
Kš	œžœ
žœ
žœ
žœ˜*K˜K˜—šŸ
œžœ˜Kšœžœ
˜
KšŸœ1˜AKšŸ
œ+˜8KšŸ
œ+˜8KšŸœ˜Kšœžœ
˜K™)——K˜Kšžœ
˜—…—9ΪT‡