DIRECTORY
JaMBasic,
TextNode,
TextLooks,
NameSymbolTable;

NodeStyle: CEDAR DEFINITIONS =
BEGIN


Ref: TYPE = REF StyleBody;
StyleBody: TYPE = RECORD [
fontFace: FontFace _ Regular, -- 2 bits
fontAlphabets: FontAlphabets _ CapsAndLower, -- 2 bits
strikeout: FontUnderlining _ None, -- 2 bits
underlining: FontUnderlining _ None, -- 2 bits
lineFormatting: LineFormatting _ FlushLeft, -- 2 bits
pathType: PathType _ Filled, -- 2 bits
print: BOOL _ FALSE, -- true if using the hardcopy style rules
isComment: BOOL _ FALSE, -- set to node.comment; readonly for style rules
fixedTabs: BOOL _ FALSE, -- true if stops at fixed locations. else relative to left margin
nestingLevel: [0..MaxNestingLevel] _ 0, -- node level in tree; readonly for style rules
numTabStops: [0..64) _ 0, -- length of the tabStops list
name: ARRAY NameParam OF Name,
real: PACKED ARRAY RealParam OF RealCode,
defaultTabStops: TabStop, -- if NIL, use 0.5 in flushLeft blank defaultTabStops
tabStops: LIST OF TabStop, -- kept sorted by decreasing location, i.e., from right to left on page
dataList: DataList -- for special parameters
];

MaxNestingLevel: INTEGER = 31; -- 5 bits

NameParam: TYPE = {
style, -- name of the style, such as "TechicalNote"
fontFamily -- name of the font family, such as "Helvetica"
};

DataList: TYPE = REF DataEntry;
OfEntry: TYPE = { object, real, tab };
DataEntry: TYPE = RECORD [
next: DataList, 
data: SELECT kind:OfEntry FROM
object => [
name: Name, -- name of the parameter
object: NameSymbolTable.Object ], -- value of the parameter
real => [ -- for real values which overflow the table of common values
param: RealParam, -- which one it is
value: Real, -- the value
valueI: INTEGER -- the value rounded to an integer -- ],
tab => [ -- for real values from tabspecs which overflow the table of common values
tabStop: TabStop, -- which tab stop it is
which: TabRealParam, -- which value for the tab stop it is
value: Real, -- the value
valueI: INTEGER -- the value rounded to an integer -- ]
ENDCASE];

TabRealParam: TYPE = { loc, spacing, weight, vshift };

TabStop: TYPE = REF TabStopRec;
LeaderTabStop: TYPE = REF leaders TabStopRec;
RuleTabStop: TYPE = REF rule TabStopRec;
RulesTabStop: TYPE = REF rules TabStopRec;

TabStopRec: TYPE = RECORD [
looks: TextLooks.Looks, -- the default looks for the stop
loc: RealCode, -- the location of the stop
alignment: TabAlign _ FlushLeft, -- how the tab is aligned
alignmentChar: CHAR _ 0C, -- only of interest if alignment=Character
breakIfPast: BOOL _ FALSE, -- what to do if you are already beyond the tab stop
fill: SELECT fillKind:OfTabFill FROM
blank => [],
leaders => [
congruent: BOOL _ TRUE, -- otherwise, centered
char: CHAR _ 0C, -- the character to be repeated
spacing: RealCode -- the distance between repetitions
],
rule => [
weight: RealCode, -- the thickness of the rule
vshift: RealCode -- the distance up from the baseline to the bottom of the rule
],
rules => [
array: JaMArrayObject -- array[0] holds real for first weight, array[1] holds real for first vshift
],
ENDCASE
];

TabAlign: TYPE = { FlushLeft, FlushRight, Centered, Character };
OfTabFill: TYPE = { blank, leaders, rule, rules };
JaMArrayObject: TYPE = array JaMBasic.Object _ [X, array[0, NIL]];

FontFace: TYPE = { Regular, Bold, Italic, BoldItalic };
FontAlphabets: TYPE = { CapsAndLower, CapsAndSmallCaps, LowerOnly, CapsOnly };
FontUnderlining: TYPE = { None, LettersAndDigits, Visible, All };
LineFormatting: TYPE = { FlushLeft, FlushRight, Justified, Centered };
PathType: TYPE = { Filled, Outlined, FilledAndOutlined };

Name: TYPE = NameSymbolTable.Name _ NameSymbolTable.nullName;
Real: TYPE = REAL _ 0.0;

RealParam: TYPE = {
fontSize, -- in points
vshift, -- distance to raise text above baseline (can be negative)
tabStops, -- number of spaces equivalent to one tab
minLineGap, -- min distance between line top and previous bottom (can be negative)
freeVar, -- for use by extensions
leftIndent, -- all lines indent this much on left
rightIndent, -- all lines indent this much on right
firstIndent, -- first line indent this much more on left
restIndent, -- other lines indent this much more on left
topIndent, -- top line at least this much down from top of viewer/page
bottomIndent, -- bottom baseline at least this up from bottom of page
leading, -- distance between baselines
leadingStretch,
leadingShrink,
topLeading, -- min distance from first baseline to previous
topLeadingStretch,
topLeadingShrink,
bottomLeading, -- min distance from last baseline to next
bottomLeadingStretch,
bottomLeadingShrink,
areaHue, -- color for filled areas
areaSaturation,
areaBrightness,
outlineHue, -- color for outlines
outlineSaturation,
outlineBrightness,
textHue, -- color for text
textSaturation,
textBrightness,
textRotation,
lineWeight, -- width of graphics lines
pageWidth, 
pageLength,
leftMargin,
rightMargin,
topMargin,
bottomMargin,
headerMargin,
footerMargin,
bindingMargin,
lineLength,
column, -- number of columns
pageBreakPenalty, -- penalty for breaking inside node
pageBreakAfterFirstLinePenalty, -- penalty for breaking node after its first line
pageBreakBeforeLastLinePenalty, -- penalty for breaking node before its last line
pageBreakBeforeFirstLinePenalty, -- penalty for breaking before first line of node
pageBreakAfterLastLinePenalty -- penalty for breaking after last line of node
};

RealCode: TYPE = [0..255] _ 0;
zero: RealCode = 0;

PointsPerPica: REAL;
PointsPerInch: REAL;
PointsPerCentimeter: REAL;
PointsPerMillimeter: REAL;
PointsPerDidot: REAL;
PointsPerFil: REAL;
PointsPerFill: REAL;


RegisterStyleFreeVar: PROC [
name: Name, eval: PROC [node: TextNode.Ref] RETURNS [REAL]];

RegisterStyleFreeObjVar: PROC [
name: Name, eval: PROC [node: TextNode.Ref] RETURNS [JaMBasic.Object]];

RemoveNodeFromApplyAllCache: PROC [node: TextNode.Ref];

RemoveAllFromApplyAllCache: PROC;

UnregisterStyleFreeVar: PROC [name: Name];



DefineSpecial: PROC [name: Name, initialValue: Real];

GetSpecial: PROC [s:Ref, name: Name] RETURNS [Real];

GetSpecialI: PROC [s:Ref, name: Name] RETURNS [INTEGER];

nonNumeric: ERROR; -- raised if call GetSpecial or GetSpecialI for nonnumeric variable

DefineSpecialObj: PROC [name: Name, initialValue: JaMBasic.Object];

GetSpecialObj: PROC [s:Ref, name: Name] RETURNS [JaMBasic.Object];


GetStyleName: PROC [s:Ref] RETURNS [Name] = INLINE {
RETURN [s.name[style]] };

GetFontFamily: PROC [s:Ref] RETURNS [Name] = INLINE {
RETURN [s.name[fontFamily]] };

GetFontFace: PROC [s:Ref] RETURNS [FontFace] = INLINE {
RETURN [s.fontFace] };

GetFontAlphabets: PROC [s:Ref] RETURNS [FontAlphabets] = INLINE {
RETURN [s.fontAlphabets] };

GetUnderlining: PROC [s:Ref] RETURNS [FontUnderlining] = INLINE {
RETURN [s.underlining] };

GetStrikeout: PROC [s:Ref] RETURNS [FontUnderlining] = INLINE {
RETURN [s.strikeout] };

GetLineFormatting: PROC [s:Ref] RETURNS [LineFormatting] = INLINE {
RETURN [s.lineFormatting] };

GetPathType: PROC [s:Ref] RETURNS [PathType] = INLINE {
RETURN [s.pathType] };



GetFontSize: PROC [s:Ref] RETURNS [Real] = INLINE { -- in points
RETURN [GetReal[s,fontSize]] };
GetFontSizeI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,fontSize]] };

GetVShift: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,vshift]] };
GetVShiftI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,vshift]] };

GetTabStops: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,tabStops]] };
GetTabStopsI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,tabStops]] };

GetMinLineGap: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,minLineGap]] };
GetMinLineGapI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,minLineGap]] };

GetTextRotation: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,textRotation]] };

GetLineWeight: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,lineWeight]] };


GetLeftIndent: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,leftIndent]] };
GetLeftIndentI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,leftIndent]] };

GetRightIndent: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,rightIndent]] };
GetRightIndentI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,rightIndent]] };

GetFirstIndent: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,firstIndent]] };
GetFirstIndentI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,firstIndent]] };

GetBodyIndent, GetRestIndent: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,restIndent]] };
GetBodyIndentI, GetRestIndentI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,restIndent]] };

GetTopIndent: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,topIndent]] };
GetTopIndentI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,topIndent]] };

GetBottomIndent: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,bottomIndent]] };
GetBottomIndentI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,bottomIndent]] };



GetLeading: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,leading]] };
GetLeadingI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,leading]] };

GetLeadingStretch: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,leadingStretch]] };

GetLeadingShrink: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,leadingShrink]] };

GetTopLeading: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,topLeading]] };
GetTopLeadingI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,topLeading]] };

GetTopLeadingStretch: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,topLeadingStretch]] };

GetTopLeadingShrink: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,topLeadingShrink]] };

GetBottomLeading: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,bottomLeading]] };
GetBottomLeadingI: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,bottomLeading]] };

GetBottomLeadingStretch: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,bottomLeadingStretch]] };

GetBottomLeadingShrink: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,bottomLeadingShrink]] };



GetPageWidth: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,pageWidth]] };

GetPageLength: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,pageLength]] };

GetLeftMargin: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,leftMargin]] };

GetRightMargin: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,rightMargin]] };

GetTopMargin: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,topMargin]] };

GetBottomMargin: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,bottomMargin]] };

GetHeaderMargin: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,headerMargin]] };

GetFooterMargin: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,footerMargin]] };

GetBindingMargin: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,bindingMargin]] };

GetLineLength: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,lineLength]] };

GetColumns: PROC [s:Ref] RETURNS [INTEGER] = INLINE {
RETURN [GetInt[s,column]] };



GetPageBreakPenalty: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,pageBreakPenalty]] };

GetPageBreakAfterFirstLinePenalty: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,pageBreakAfterFirstLinePenalty]] };

GetPageBreakBeforeLastLinePenalty: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,pageBreakBeforeLastLinePenalty]] };

GetPageBreakBeforeFirstLinePenalty: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,pageBreakBeforeFirstLinePenalty]] };

GetPageBreakAfterLastLinePenalty: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,pageBreakAfterLastLinePenalty]] };



GetAreaHue: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,areaHue]] };

GetAreaSaturation: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,areaSaturation]] };

GetAreaBrightness: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,areaBrightness]] };

GetOutlineHue: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,outlineHue]] };

GetOutlineSaturation: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,outlineSaturation]] };

GetOutlineBrightness: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,outlineBrightness]] };

GetTextHue: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,textHue]] };

GetTextSaturation: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,textSaturation]] };

GetTextBrightness: PROC [s:Ref] RETURNS [Real] = INLINE {
RETURN [GetReal[s,textBrightness]] };



GetTabLoc: PROC [stop: TabStop, s:Ref] RETURNS [Real] = INLINE {
code: RealCode;
IF (code _ stop.loc) # overflow THEN RETURN [realArray[code]];
RETURN [GetTabOverflow[s,stop,loc]] };

GetTabLocI: PROC [stop: TabStop, s:Ref] RETURNS [INTEGER] = INLINE {
code: RealCode;
IF (code _ stop.loc) # overflow THEN RETURN [intArray[code]];
RETURN [GetTabIntOverflow[s,stop,loc]] };

GetTabLeaderSpacing: PROC [stop: LeaderTabStop, s:Ref] RETURNS [Real] = INLINE {
code: RealCode;
IF (code _ stop.spacing) # overflow THEN RETURN [realArray[code]];
RETURN [GetTabOverflow[s,stop,spacing]] };
GetTabLeaderSpacingI: PROC [stop: LeaderTabStop, s:Ref] RETURNS [INTEGER] = INLINE {
code: RealCode;
IF (code _ stop.spacing) # overflow THEN RETURN [intArray[code]];
RETURN [GetTabIntOverflow[s,stop,spacing]] };
GetTabRuleWeight: PROC [stop: RuleTabStop, s:Ref] RETURNS [Real] = INLINE {
code: RealCode;
IF (code _ stop.weight) # overflow THEN RETURN [realArray[code]];
RETURN [GetTabOverflow[s,stop,weight]] };
GetTabRuleWeightI: PROC [stop: RuleTabStop, s:Ref] RETURNS [INTEGER] = INLINE {
code: RealCode;
IF (code _ stop.weight) # overflow THEN RETURN [intArray[code]];
RETURN [GetTabIntOverflow[s,stop,weight]] };
GetTabRuleVShift: PROC [stop: RuleTabStop, s:Ref] RETURNS [Real] = INLINE {
code: RealCode;
IF (code _ stop.vshift) # overflow THEN RETURN [realArray[code]];
RETURN [GetTabOverflow[s,stop,vshift]] };
GetTabRuleVShiftI: PROC [stop: RuleTabStop, s:Ref] RETURNS [INTEGER] = INLINE {
code: RealCode;
IF (code _ stop.vshift) # overflow THEN RETURN [intArray[code]];
RETURN [GetTabIntOverflow[s,stop,vshift]] };
RulesTabCount: PROC [stop: RulesTabStop] RETURNS [count: INTEGER]; -- number of rules

RulesTabInfo: PROC [stop: RulesTabStop, num: INTEGER] RETURNS [weight, vshift: REAL];

RulesTabInfoI: PROC [stop: RulesTabStop, num: INTEGER] RETURNS [weight, vshift: INTEGER];

GetTabOverflow: PRIVATE PROC [ref: Ref, stop: TabStop, which: TabRealParam]
RETURNS [value: Real];

GetTabIntOverflow: PRIVATE PROC [ref: Ref, stop: TabStop, which: TabRealParam]
RETURNS [value: INTEGER];


realArray: REF ARRAY RealCode OF Real; -- array of distances
intArray: REF ARRAY RealCode OF INTEGER;
overflow: RealCode = LAST[RealCode];

GetReal: PROC [ref: Ref, param: RealParam] RETURNS [value: Real] = INLINE {
code: RealCode;
IF (code _ ref.real[param]) # overflow THEN RETURN [realArray[code]];
RETURN [GetRealOverflow[ref,param]] };

GetInt: PROC [ref: Ref, param: RealParam] RETURNS [value: INTEGER] = INLINE {
code: RealCode;
IF (code _ ref.real[param]) # overflow THEN RETURN [intArray[code]];
RETURN [GetIntOverflow[ref,param]] };

GetRealOverflow: PRIVATE PROC [ref: Ref, param: RealParam] RETURNS [value: Real];

GetIntOverflow: PRIVATE PROC [ref: Ref, param: RealParam] RETURNS [value: INTEGER];



ApplyAll: PROC [ref: Ref, node: TextNode.Ref, kind: OfStyle _ screen];

ApplyForNode: PROC [ref: Ref, node: TextNode.Ref, alt: Name, kind: OfStyle _ screen];

ApplyType: PROC [ref: Ref, name, alt: Name, kind: OfStyle _ screen];

ApplyLooks: PROC [ref: Ref, looks: TextLooks.Looks, kind: OfStyle _ screen];

ApplyObject: PROC [ref: Ref, object: NameSymbolTable.Object, kind: OfStyle _ screen];

OfStyle: TYPE = { screen, print, base };

StyleNameForNode: PROC [TextNode.Ref] RETURNS [Name];

FlushCaches: PROC;



Create: PROC RETURNS [Ref]; -- create a body

Copy: PROC [dest, source: Ref]; -- copy a body

Alloc: PROC RETURNS [Ref]; -- get from a small cache 

Free: PROC [Ref]; -- don't free more than once or disaster!

LoadStyle: PROC [name: Name] RETURNS [ok: BOOLEAN];

ReloadStyle: PROC [name: Name] RETURNS [ok: BOOLEAN];



Start: PROC;


END.


dNodeStyle.mesa
Written by Bill Paxton, January 1981
Last changed by Bill Paxton, December 1, 1982 8:37 am
***** Declarations
this order substantially reduces allocations during the creation of the list since styles tend to define tab stops in increasing order, so can add to start of list and list additions must be non-destructive of the previous list.  since length of list is given, can easily find the nth stop.
miscellaneous 
indent parameters
leading parameters
parameters for graphics
page layout parameters
penalty parameters for page layout
**** Style free variables

These are used for style extensions that need free variables similar to node level or node comment property.  Once the name is registered, style rules may use the name to get access to the value for the current node.  The registered eval proc's are called to get the current value whenever the style for the node is computed.
The first REAL valued free variable is very efficiently implemented.  After that, free var's start costing more.  Use them to check out new ideas, then get the variable "blessed" and incorporated in the system in a more effiecient manner.
Whenever something happens to the node that might cause the value of the free variable eval proc to change, call this routine.
Whenever something happens that might change values for free variable eval procs to change, call this routine.
**** Special extension style parameters

These are for use in extensions to the basic style variables.  DefineSpecial and DefineSpecialObj make the name available in all styles.  Style rules can read and set the new variable just like any other style variable.  Formatting programs can get at the value by calling GetSpecial, GetSpecialI, or GetSpecialObj.
**** Non-numeric style parameters
enumerated type given above
enumerated type given above
enumerated type given above
enumerated type given above
enumerated type given above
enumerated type given above
**** Miscellaneous real value parameters
distance to raise text above baseline
number of spaces equivalent to one tab
**** Indents
all lines indent at least this much on left
all lines indent at least this much on right
first line indent this much more on left
other lines indent this much more on left
top line at least this much down from top
bottom baseline at least this up from bottom
**** Leadings
distance between baselines
min distance from first baseline to previous
min distance from last baseline to next
**** Page layout parameters for typesetter
**** Penalties
**** Colors
**** Tab stop info






For num in [0..RulesTabCount), returns the weight and vshift values for that rule.
**** Support routines; not for clients to use directly
**** Apply operations
ApplyAll[ref,NIL] sets ref to default values
including setting style name to "default"
ApplyAll[ref,node] for node # NIL
1. ApplyAll[ref, Parent[node]]
2. ApplyForNode[ref, node, alt]
where alt is "root" if parent=NIL
or "default" otherwise
1. ApplyObject[ref, node prefix object]
2. ApplyType[ref, node type, alt]
3. ApplyObject[ref, node postfix object]
executes the name to modify the body
if name is null or undefined, applies alt instead
executes the looks to modify the body
executes the object to modify the body
does an ApplyAll and then returns the style name
**** Other Operations
make sure that named style is loaded
fast return if is already loaded
forces rereading of definition
**** Initialization
Κ©–
"Mesa" style˜Jš
Οc™Jš
$™$Jš
5™5J˜š
Οk	˜	J˜	J˜	J˜
J˜J˜—Jšœžœ˜Jš
ž˜J˜Jš
™J˜Jšœžœžœ˜šœžœžœ˜Jšœ	˜'Jšœ-	˜6Jšœ#	˜,Jšœ%	˜.Jšœ,	˜5Jšœ	˜&Jšœžœžœ)˜>Jšœžœžœ0˜IJšœžœžœA˜ZJšœ(/˜WJšœ˜8Jšœžœžœ˜Jšœžœ
žœžœ
˜)Jšœ5˜Ošœ
žœ
žœ
G˜bJš
’™’—Jšœ˜,J˜J˜—Jšœžœ	˜(J˜šœžœ˜Jšœ,˜3Jšœ/˜:J˜J˜—Jšœ
žœžœ˜Jšœ	žœ˜&šœžœžœ˜J˜šœžœž˜˜Jšœ˜$Jšœ"˜;—šœ
<˜FJšœ˜$Jšœ
˜Jšœžœ
%œ˜8—šœ	J˜SJšœ˜)Jšœ%˜:Jšœ
˜Jšœžœ
%œ˜7—Jšžœ˜	J˜——Jšœžœ$˜6J˜Jšœ	žœžœ˜Jšœžœžœ˜-Jšœ
žœžœ˜(Jšœžœžœ˜*J˜šœžœžœ˜Jšœ!˜9Jšœ˜*Jšœ!˜:Jšœžœ*˜DJšœ
žœžœ4˜Ošœžœž˜$J˜˜Jšœžœžœ˜.Jšœžœ˜0Jšœ#˜5J˜—˜	Jšœ˜.Jšœ>˜OJ˜—˜
JšœM˜cJ˜—Jš
ž˜—J˜J˜—Jšœ
žœ2˜@Jšœžœ#˜2Jšœžœž
œžœ˜BJ˜Jšœ
žœ)˜7Jšœžœ;˜NJšœžœ,˜AJšœžœ2˜FJšœ
žœ+˜9J˜Jšœžœ3˜=Jšœžœžœ˜J˜šœžœ˜š
™Jšœ
˜Jšœ:˜BJšœ
)˜3JšœF˜RJšœ	˜!—š
™Jšœ%˜1Jšœ
&˜3Jšœ
+˜8Jšœ,˜8Jšœ;˜FJšœ7˜E—š
™Jšœ	˜&J˜J˜Jšœ/˜;J˜J˜Jšœ*˜9J˜J˜—š
™Jšœ	˜"J˜J˜Jšœ˜!J˜J˜Jšœ	˜J˜J˜J˜
Jšœ˜&—š
™J˜J˜J˜J˜J˜
J˜
J˜
J˜
J˜J˜Jšœ˜—š
"™"Jšœ#˜5Jšœ 1˜QJšœ 1˜QJšœ!1˜RJšœ/˜M—J˜J˜—Jšœ
žœ˜J˜J˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜J˜š
™J™J™ΕJ˜šΟnœžœ˜šœžœžœžœ˜<J™ξ
——J˜šŸœžœ˜Jšœžœžœ˜GJ˜—šŸœžœ˜7J™~—J˜šŸœžœ
˜!J™n—J˜šŸœžœ˜*J˜—J˜—š
'™'J™J™»J˜JšŸ
œžœ"˜5J˜JšŸ
œžœžœ˜4J˜JšŸœžœžœžœ˜8J˜JšœžœC˜VJ˜JšŸœžœ-˜CJ˜šŸ
œžœžœ˜BJ˜——š
!™!J˜šŸœžœ	žœ
žœ˜4Jšžœ˜J˜—šŸ
œžœ	žœ
žœ˜5Jšžœ˜J˜—šŸœžœ	žœžœ˜7Jš
™Jšžœ˜J˜—šŸœžœ	žœžœ˜AJš
™Jšžœ˜J˜—šŸœžœ	žœžœ˜AJš
™Jšžœ˜J˜—šŸœžœ	žœžœ˜?Jš
™Jšžœ˜J˜—šŸœžœ	žœžœ˜CJš
™Jšžœ˜J˜—JšŸœžœ	žœžœ˜7Jš
™Jšžœ˜J˜J˜—š
(™(J˜š	Ÿœžœ	žœ
žœ˜@Jšžœ˜—š
Ÿœžœ	žœžœžœ˜7Jšžœ˜J˜—šŸ	œžœ	žœ
žœ˜1Jš
%™%Jšžœ˜—š
Ÿ
œžœ	žœžœžœ˜5Jšžœ˜J˜—šŸœžœ	žœ
žœ˜3Jš
&™&Jšžœ˜—š
Ÿœžœ	žœžœžœ˜7Jšžœ˜J˜—šŸ
œžœ	žœ
žœ˜5Jšžœ˜!—š
Ÿœžœ	žœžœžœ˜9Jšžœ˜ J˜—šŸœžœ	žœ
žœ˜7Jšžœ˜#J˜—JšŸ
œžœ	žœ
žœ˜5Jšžœ˜!J˜—š
™J˜šŸ
œžœ	žœ
žœ˜5Jš
+™+Jšžœ˜!—š
Ÿœžœ	žœžœžœ˜9Jšžœ˜ J˜—šŸœžœ	žœ
žœ˜6Jš
,™,Jšžœ˜"—š
Ÿœžœ	žœžœžœ˜:Jšžœ˜!J˜—šŸœžœ	žœ
žœ˜6Jš
(™(Jšžœ˜"—š
Ÿœžœ	žœžœžœ˜:Jšžœ˜!J˜—š	œŸ
œžœ	žœ
žœ˜DJš
)™)Jšžœ˜!—šœŸœžœ	žœžœžœ˜IJšžœ˜ J˜—šŸœžœ	žœ
žœ˜4Jš
)™)Jšžœ˜ —š
Ÿ
œžœ	žœžœžœ˜8Jšžœ˜J˜—šŸœžœ	žœ
žœ˜7Jš
,™,Jšžœ˜#—Jš
Ÿœžœ	žœžœžœ˜;Jšžœ˜"J˜J˜—š

™
J˜šŸ
œžœ	žœ
žœ˜2Jš
™Jšžœ˜—š
Ÿœžœ	žœžœžœ˜6Jšžœ˜J˜—šŸœžœ	žœ
žœ˜9Jšžœ˜%J˜—šŸœžœ	žœ
žœ˜8Jšžœ˜$J˜—šŸ
œžœ	žœ
žœ˜5Jš
,™,Jšžœ˜!—š
Ÿœžœ	žœžœžœ˜9Jšžœ˜ J˜—šŸœžœ	žœ
žœ˜<Jšžœ"˜(J˜—šŸœžœ	žœ
žœ˜;Jšžœ!˜'J˜—šŸœžœ	žœ
žœ˜8Jš
'™'Jšžœ˜$—š
Ÿœžœ	žœžœžœ˜<Jšžœ˜#J˜—šŸœžœ	žœ
žœ˜?Jšžœ%˜+J˜—JšŸœžœ	žœ
žœ˜>Jšžœ$˜*J˜J˜—š
*™*J˜šŸœžœ	žœ
žœ˜4Jšžœ˜ J˜—šŸ
œžœ	žœ
žœ˜5Jšžœ˜!J˜—šŸ
œžœ	žœ
žœ˜5Jšžœ˜!J˜—šŸœžœ	žœ
žœ˜6Jšžœ˜"J˜—šŸœžœ	žœ
žœ˜4Jšžœ˜ J˜—šŸœžœ	žœ
žœ˜7Jšžœ˜#J˜—šŸœžœ	žœ
žœ˜7Jšžœ˜#J˜—šŸœžœ	žœ
žœ˜7Jšžœ˜#J˜—šŸœžœ	žœ
žœ˜8Jšžœ˜$J˜—šŸ
œžœ	žœ
žœ˜5Jšžœ˜!J˜—Jš
Ÿ
œžœ	žœžœžœ˜5Jšžœ˜J˜J˜—š
™J˜šŸœžœ	žœ
žœ˜;Jšžœ!˜'J˜—šŸ!œžœ	žœ
žœ˜IJšžœ/˜5J˜—šŸ!œžœ	žœ
žœ˜IJšžœ/˜5J˜—šŸ"œžœ	žœ
žœ˜JJšžœ0˜6J˜—JšŸ œžœ	žœ
žœ˜HJšžœ.˜4J˜J˜—š
™J˜šŸ
œžœ	žœ
žœ˜2Jšžœ˜J˜—šŸœžœ	žœ
žœ˜9Jšžœ˜%J˜—šŸœžœ	žœ
žœ˜9Jšžœ˜%J˜—šŸ
œžœ	žœ
žœ˜5Jšžœ˜!J˜—šŸœžœ	žœ
žœ˜<Jšžœ"˜(J˜—šŸœžœ	žœ
žœ˜<Jšžœ"˜(J˜—šŸ
œžœ	žœ
žœ˜2Jšžœ˜J˜—šŸœžœ	žœ
žœ˜9Jšžœ˜%J˜—JšŸœžœ	žœ
žœ˜9Jšžœ˜%J˜J˜—š
™J˜šŸ	œžœžœ
žœ˜@J˜Jšžœžœ
žœ˜>Jšžœ ˜&J˜—š
Ÿ
œžœžœžœžœ˜DJ˜Jšžœžœ
žœ˜=Jšžœ#˜)J˜—šŸœžœžœ
žœ˜PJ˜Jšžœ"žœ
žœ˜BJšžœ$˜*J™—š
Ÿœžœžœžœžœ˜TJ˜Jšžœ"žœ
žœ˜AJšžœ'˜-J™—šŸœžœžœ
žœ˜KJ˜Jšžœ!žœ
žœ˜AJšžœ#˜)J™—š
Ÿœžœžœžœžœ˜OJ˜Jšžœ!žœ
žœ˜@Jšžœ&˜,J™—šŸœžœžœ
žœ˜KJ˜Jšžœ!žœ
žœ˜AJšžœ#˜)J™—š
Ÿœžœžœžœžœ˜OJ˜Jšžœ!žœ
žœ˜@Jšžœ&˜,J™—Jš	Ÿ
œžœžœ	žœ˜UJ˜š
Ÿœžœžœžœžœ˜UJ™R—J˜Jš
Ÿ
œžœžœžœžœ˜YJ˜šŸœžœ
žœ/˜KJšžœ˜—J˜šŸœžœ
žœ/˜NJšžœ	žœ˜—J˜—š
6™6J˜Jšœžœ
žœ
žœ˜<Jš	œ
žœ
žœ
žœ
žœ
˜(Jšœžœ˜$J˜šŸœžœžœžœ˜KJ˜Jšžœ%žœ
žœ˜EJšžœ ˜&J˜—š
Ÿœžœžœ	žœžœ˜MJ˜Jšžœ%žœ
žœ˜DJšžœ˜%J˜—JšŸœžœ
žœžœ˜QJ˜Jš
Ÿœžœ
žœžœ	žœ˜SJ˜J˜—š
™J˜šŸœžœ8˜Fš
,™,Jš
)™)—š
!™!Jš
™š
™Jš
!™!Jš
™J˜———šŸœžœC˜UJš
'™'Jš
!™!Jš
(™(J˜—šŸ	œžœ5˜DJš
$™$Jš
1™1J˜—šŸ
œžœ<˜LJš
%™%J˜—šŸœžœD˜UJš
&™&J˜—Jšœ	žœ˜(J˜šŸœžœžœ˜5Jš
0™0J˜—JšŸœžœ
˜J˜J˜—š
™J˜JšŸœžœ
žœ˜,J˜JšŸœžœ˜.J˜JšŸœžœ
žœ˜5J˜JšŸœžœ)˜;J˜šŸ	œžœžœžœ˜3Jš
$™$Jš
 ™ J˜—JšŸœžœžœžœ˜5Jš
™J˜J˜—š
™J˜JšŸœžœ
˜J˜—J˜Jšžœ
˜J˜—…—?„b‘