DIRECTORY
Handwriting,
IO,
PFS,
Rope,
Xl USING [Point];

HandwritingImpl: CEDAR MONITOR
IMPORTS PFS, IO
EXPORTS Handwriting ~ 
BEGIN OPEN Handwriting;
IsTrainingDB: PUBLIC PROC [x: REF] RETURNS [BOOL] = {
RETURN [ISTYPE[x, LIST OF NormalizedStrokes]];
};

NarrowTrainingDB: PUBLIC PROC [x: REF] RETURNS [TrainingDB] = {
RETURN [NARROW[x, LIST OF NormalizedStrokes]];
};

IsNormalized: PUBLIC PROC [x: REF] RETURNS [BOOL] = {
RETURN [ISTYPE[x, NormalizedStrokes]];
};

NarrowNormalized: PUBLIC PROC [x: REF] RETURNS [Normalized] = {
RETURN [NARROW[x, NormalizedStrokes]];
};

MCopyStroke: PROC [s: Stroke, dx: INT, dy: INT, f: INT] RETURNS [copy: Stroke м NIL] = {
IF s#NIL THEN {
lag: Stroke м copy м LIST[[(s.first.x+dx)*f, (s.first.y+dy)*f]];
FOR seg: Stroke м s.rest, seg.rest WHILE seg#NIL DO
lag.rest  м LIST[[(seg.first.x+dx)*f, (seg.first.y+dy)*f]];
lag м lag.rest
ENDLOOP
}
};

MCopyStrokes: PROC [strokes: Strokes, dx: INT, dy: INT, f: INT] RETURNS [copy: Strokes м NIL] = {
IF strokes#NIL THEN {
lag: Strokes м copy м LIST[MCopyStroke[strokes.first, dx, dy, f]];
FOR sl: Strokes м strokes.rest, sl.rest WHILE sl#NIL DO
lag.rest  м LIST[MCopyStroke[sl.first, dx, dy, f]];
lag м lag.rest
ENDLOOP
}
};

normalPoints: NAT = 16;
EachPoint: TYPE = RECORD [x, y: INT];
NormalizedSingleStroke: TYPE = ARRAY [0..normalPoints) OF EachPoint;
NormalizedStrokes: TYPE = REF NormalizedStrokesRec;
NormalizedStrokesRec: TYPE = RECORD [
key: INT м 0,
strokes: Strokes м NIL,
dx, dy, f: INT,
included: BOOL м FALSE,
data: SEQUENCE strokeCnt: NAT OF NormalizedSingleStroke
];
idxForLeng: NAT = 1;
normalizedLengthConst: INT = 010000H;

CopyNormalizedStrokes: PROC [ns: NormalizedStrokes] RETURNS [copy: NormalizedStrokes] = {
copy м NEW[NormalizedStrokesRec[ns.strokeCnt]];
copy.key м ns.key;
copy.strokes м ns.strokes;  --pointer copy because is readonly
copy.dx м ns.dx;
copy.dy м ns.dy;
copy.f м ns.f;
copy.included м FALSE;
FOR i: NAT IN [0..ns.strokeCnt) DO
copy.data[i] м ns.data[i];
ENDLOOP;
};

CountStrokes: PROC [strokes: Strokes] RETURNS [cnt: INT м 0] = {
FOR ss: Strokes м strokes, ss.rest WHILE ss#NIL DO
cnt м cnt+1;
ENDLOOP;
};

NormalizeStrokes: PROC [strokes: Strokes] RETURNS [ns: NormalizedStrokes] = {
factor: INT;
totalLeng: INT м 0;
strokeCnt, strokeIdx: INT м 0;
min: Xl.Point м [INT.LAST, INT.LAST];
max: Xl.Point м [INT.FIRST, INT.FIRST];
av: Xl.Point м [0, 0];
strokeCnt м CountStrokes[strokes];
IF strokeCnt=0 THEN ERROR;
ns м NEW[NormalizedStrokesRec[strokeCnt]];
strokeIdx м 0;
FOR sl: Strokes м strokes, sl.rest WHILE sl#NIL DO
strokeLeng: INT м 0;
lastP: Xl.Point м sl.first.first;
FOR seg: Stroke м sl.first, seg.rest WHILE seg#NIL DO
nextP: Xl.Point ~ seg.first;
min.x м MIN[min.x, nextP.x]; min.y м MIN[min.y, nextP.y];
max.x м MAX[max.x, nextP.x]; max.y м MAX[max.y, nextP.y];
strokeLeng м strokeLeng + ABS[lastP.x-nextP.x] + ABS[lastP.y-nextP.y];
lastP м nextP;
ENDLOOP;
ns.data[strokeIdx][idxForLeng].x м strokeLeng;
totalLeng м totalLeng+strokeLeng;
strokeIdx м strokeIdx+1;
ENDLOOP;
ns.dx м -(max.x+min.x)/2;
ns.dy м-(max.y+min.y)/2;
IF (max.x-min.x)<=3 AND (max.y-min.y)<=3 THEN {
ns.f м 1;
ns.strokes м MCopyStrokes[strokes: strokes, dx: ns.dx, dy: ns.dy, f: 1];
FOR si: NAT IN [1..strokeCnt) DO
ns.data[si] м ALL[[0, 0]];
ENDLOOP;
RETURN;
};
factor м ns.f м MAX[(normalizedLengthConst / MAX[totalLeng, 1]), 1];
strokes м ns.strokes м MCopyStrokes[strokes: strokes, dx: ns.dx, dy: ns.dy, f: factor];
strokeIdx м 0;
FOR ss: Strokes м strokes, ss.rest WHILE ss#NIL DO
seg: Stroke м ss.first;
next: Stroke;
actualStrokeLeng: INT м ns.data[strokeIdx][idxForLeng].x*factor;
desiredPieceLeng: INT м actualStrokeLeng/(normalPoints-1);
sofarLeng: INT м 0;
goalLeng: INT м 0;
lastP: Xl.Point м seg.first;
ns.data[strokeIdx][0].x м lastP.x;
ns.data[strokeIdx][0].y м lastP.y;
FOR i: NAT IN [1..normalPoints) DO
dx, dy, dl: INT м 0;
goalLeng м sofarLeng+desiredPieceLeng; 
DO --eventually skip some segments
next м seg.rest;
IF next=NIL THEN {
dl м 0;
EXIT;
};
dx м next.first.x-lastP.x;
dy м next.first.y-lastP.y;
dl м ABS[dx] + ABS[dy];  
IF sofarLeng+dl>=goalLeng 
THEN EXIT --found the right segment
ELSE {
sofarLeng м sofarLeng+dl;
seg м next;
lastP м next.first;
};
ENDLOOP;
IF sofarLeng+dl<=goalLeng OR dl<=0 
THEN {
IF next#NIL THEN lastP м next.first;
}
ELSE {
desiredSegLeng: INT м (goalLeng-sofarLeng);
lastP.x м lastP.x+(desiredSegLeng*dx)/dl;
lastP.y м lastP.y+(desiredSegLeng*dy)/dl;
};
sofarLeng м goalLeng;
ns.data[strokeIdx][i].x м lastP.x;
ns.data[strokeIdx][i].y м lastP.y;
ENDLOOP;
strokeIdx м strokeIdx+1;
ENDLOOP;
IF strokeCnt>0 THEN {
tx, ty: INT м 0;
FOR si: INT IN [0..strokeCnt) DO
FOR pi: INT IN [0..normalPoints) DO
tx м tx + ns.data[si][pi].x;  ty м ty + ns.data[si][pi].y;
ENDLOOP; 
ENDLOOP; 
tx м tx/(normalPoints*strokeCnt);
ty м ty/(normalPoints*strokeCnt);
FOR si: INT IN [0..strokeCnt) DO
FOR pi: INT IN [0..normalPoints) DO
ns.data[si][pi].x м ns.data[si][pi].x - tx;  
ns.data[si][pi].y м ns.data[si][pi].y - ty;
ENDLOOP; 
ENDLOOP; 
};
};  

Normalize: PUBLIC PROC [strokes: Strokes, ch: INT м -1] RETURNS [REF] = {
ns: NormalizedStrokes м NormalizeStrokes[strokes];
ns.key м ch;
RETURN [ns];
};

ToStrokes: PROC [ns: NormalizedStrokes, sizemax: INT м 40] RETURNS [strokes: Strokes м NIL] = {
normalize: INT;
min: Xl.Point м [INT.LAST, INT.LAST];
max: Xl.Point м [INT.FIRST, INT.FIRST];
FOR si: INT DECREASING IN [0..ns.strokeCnt) DO
FOR pi: INT DECREASING IN [0..normalPoints) DO
p: Xl.Point м [ ns.data[si][pi].x, ns.data[si][pi].y ];
min.x м MIN[min.x, p.x];
min.y м MIN[min.y, p.y];
max.x м MAX[max.x, p.x];
max.y м MAX[max.y, p.y];
ENDLOOP;
ENDLOOP;
normalize м MAX[ABS[max.x], ABS[max.y], ABS[min.x], ABS[min.y], 1];
FOR si: INT DECREASING IN [0..ns.strokeCnt) DO
s: Stroke м NIL;
FOR pi: INT DECREASING IN [0..normalPoints) DO
p: Xl.Point м [ ns.data[si][pi].x, ns.data[si][pi].y ];
p.x м (p.x*sizemax)/normalize; 
p.y м (p.y*sizemax)/normalize; 
s м CONS[p, s];
ENDLOOP;
strokes м CONS[s, strokes];
ENDLOOP;
};

UnNormalize: PUBLIC PROC [x: REF, sizemax: INT м 40] RETURNS [strokes: Strokes] = {
ns: NormalizedStrokes м NARROW[x];
strokes м ToStrokes[ns, sizemax];
};

CompareFine: PROC [ns1, ns2: NormalizedStrokes, limit: INT м LAST[INT]] RETURNS [b: INT м 0] = {
CompI: PROC [n1, n2: NormalizedStrokes, sidx: NAT, pidx: [0..normalPoints)] RETURNS [INT] = INLINE {
RETURN [ABS[n1.data[sidx][pidx].x-n2.data[sidx][pidx].x] + ABS[n1.data[sidx][pidx].y-n2.data[sidx][pidx].y]]
};
IF ns1.strokeCnt#ns2.strokeCnt THEN RETURN [LAST[INT]];
FOR si: INT IN [0..ns1.strokeCnt) DO
FOR pi: NAT IN [0..normalPoints) DO
d: INT ~ CompI[ns1, ns2, si, pi];
b м b + d * (1 + d / 256);
IF b>limit THEN RETURN [b];
ENDLOOP;
ENDLOOP;
};

Evaluation: TYPE = RECORD [
b: INT м INT.LAST,
ns: NormalizedStrokes м NIL
];

Search: PROC [ns: NormalizedStrokes, list: LIST OF NormalizedStrokes] RETURNS [best, secondBest: Evaluation] = {
considerCount: NAT = 2;
cache: ARRAY [0..considerCount) OF Evaluation;
next: INT м 0;
Insert1: PROC [e: Evaluation] = INLINE {
FOR i: NAT IN [0..considerCount) DO
IF e.b<cache[i].b THEN {
next м MIN[next+1, considerCount];
FOR n: NAT DECREASING IN (i..next) DO
cache[n] м cache[n-1];
ENDLOOP;
cache[i] м e;
RETURN;
}
ENDLOOP
};
FOR l1: LIST OF NormalizedStrokes м list, l1.rest WHILE l1#NIL DO
b: INT м CompareFine[ns, l1.first];
Insert1[[ns: l1.first, b: b]];
ENDLOOP;
best м cache[0];
secondBest м cache[1];
};

RecognizeNormalized: PUBLIC PROC [db: TrainingDB, x: Normalized] RETURNS [list: LIST OF Handwriting.Report м NIL] = {
best, secondBest: Evaluation;
dbList: LIST OF NormalizedStrokes ~ NARROW[db];
ns: NormalizedStrokes ~ NARROW[x];
[best, secondBest] м Search[ns, dbList];
IF secondBest.ns#NIL THEN
list м CONS[[ch: secondBest.ns.key, x: secondBest.ns, badness: secondBest.b], list];
IF best.ns#NIL THEN
list м CONS[[ch: best.ns.key, x: best.ns, badness: best.b], list];
};

Recognize: PUBLIC PROC [db: TrainingDB, strokes: Strokes] RETURNS [list: LIST OF Handwriting.Report м NIL] = {
ns: NormalizedStrokes ~ NormalizeStrokes[strokes];
RETURN [RecognizeNormalized[db, ns]];
};

GetChar: PUBLIC PROC [x: Normalized] RETURNS [ch: INT м -1] = {
ns: NormalizedStrokes м NARROW[x];
IF ns#NIL THEN ch м ns.key;
};

SetChar: PUBLIC PROC [x: Normalized, ch: INT м -1] = {
ns: NormalizedStrokes м NARROW[x];
IF ns.included THEN ERROR;
ns.key м ch;
};

SetIncludeFlag: ENTRY PROC [ns: NormalizedStrokes] RETURNS [mustRaise: BOOL м TRUE] = {
IF ns=NIL OR ns.included 
THEN RETURN [TRUE]
ELSE {ns.included м TRUE; RETURN [FALSE]}
};

AddToDB: PROC [db: LIST OF NormalizedStrokes, ns: NormalizedStrokes] RETURNS [LIST OF NormalizedStrokes] = {
IF SetIncludeFlag[ns].mustRaise THEN ERROR;
RETURN  [CONS[ns, db]];
};

TrainDB: PUBLIC PROC [db: TrainingDB, strokes: Strokes, ch: INT] RETURNS [TrainingDB] = {
list: LIST OF NormalizedStrokes м NARROW[db];
ns: NormalizedStrokes м NormalizeStrokes[strokes];
ns.key м ch;
RETURN [AddToDB[list, ns]];
};

TrainDBNormalized: PUBLIC PROC [db: TrainingDB, x: Normalized] RETURNS [TrainingDB] = {
list: LIST OF NormalizedStrokes м NARROW[db];
RETURN [AddToDB[list, NARROW[x]]]
};

NextNormalized: PUBLIC PROC [db: TrainingDB, x: Normalized] RETURNS [Normalized м NIL] = {
list: LIST OF NormalizedStrokes м NARROW[db];
ns: NormalizedStrokes м NARROW[x];
IF ns=NIL THEN RETURN [list.first];
FOR l: LIST OF NormalizedStrokes м list, l.rest WHILE l#NIL DO
IF l.first=ns AND l.rest#NIL THEN {
RETURN [l.rest.first];
}
ENDLOOP;
};

UnTrainDB: PUBLIC PROC [db: TrainingDB, x: REF] RETURNS [TrainingDB] = {
RemoveNext: ENTRY PROC [lag: LIST OF NormalizedStrokes, x: NormalizedStrokes] = {
IF lag#NIL THEN {
lr: LIST OF NormalizedStrokes ~ lag.rest;
IF lr#NIL AND lr.first=x THEN lag.rest м lr.rest
};
};
list: LIST OF NormalizedStrokes м NARROW[db];
ns: NormalizedStrokes м NARROW[x];
IF list=NIL THEN RETURN [NIL];
IF list.first=ns THEN RETURN [list.rest];
FOR l: LIST OF NormalizedStrokes м list, l.rest WHILE l#NIL DO
IF l.rest#NIL AND l.rest.first = ns THEN {
RemoveNext[l, ns];
RETURN [list];
}
ENDLOOP;
RETURN [list]
};


dbStartKey: INT ~ -1208567;
dbFinishKey: INT ~ -999;
nsStartKey: INT ~ -9;
strokeEndKey: INT ~ -8;

PutInt: PROC [stream: IO.STREAM, i: INT] = {
IO.Put1[stream, IO.int[i]];
IO.PutChar[stream, ' ];
};

GetInt: PROC [stream: IO.STREAM] RETURNS [INT] = {
RETURN [IO.GetInt[stream]];
};

PutSingleStroke: PROC [stream: IO.STREAM, stroke: Stroke, dx, dy, f: INT] = {
f м MAX[f, 1];
FOR l: Stroke м stroke, l.rest WHILE l#NIL DO
PutInt[stream, MAX[l.first.x/f-dx+1, 0]];
PutInt[stream, MAX[l.first.y/f-dy+1, 0]];
ENDLOOP;
PutInt[stream, strokeEndKey];
};

GetSingleStroke: PROC [stream: IO.STREAM] RETURNS [stroke: Stroke м NIL] = {
x, y: INT; lag, list: Stroke; 
DO
x м GetInt[stream];
IF x=strokeEndKey THEN EXIT;
y м GetInt[stream];
list м LIST[[x, y]];
IF lag=NIL THEN stroke м list ELSE lag.rest м list;
lag м  list;
ENDLOOP;
};

PutNormalizedStrokes: PROC [stream: IO.STREAM, ns: NormalizedStrokes] = {
strokes: Strokes м ns.strokes;
PutInt[stream, ns.key];
PutInt[stream, 0];
PutInt[stream, ns.strokeCnt];
FOR i: INT IN [0..ns.strokeCnt) DO
PutSingleStroke[stream, strokes.first, ns.dx, ns.dy, ns.f];
strokes м strokes.rest
ENDLOOP
};

GetNormalizedStrokes: PROC [stream: IO.STREAM] RETURNS [ns: NormalizedStrokes] = {
strokes, lag: Strokes м NIL;
key: INT м GetInt[stream];
unused: INT м GetInt[stream];
strokeCnt: INT м GetInt[stream];
FOR i: INT IN [0..strokeCnt) DO
stroke: Stroke м GetSingleStroke[stream];
IF stroke#NIL THEN {
list: Strokes м LIST[stroke];
IF lag=NIL THEN strokes м list ELSE lag.rest м list;
lag м list;
};
ENDLOOP;
ns м NormalizeStrokes[strokes];
ns.key м key
};

PutDB: PROC [stream: IO.STREAM, list: LIST OF NormalizedStrokes] = {
PutInt[stream, dbStartKey];
FOR l: LIST OF NormalizedStrokes м list, l.rest WHILE l#NIL DO
ns: NormalizedStrokes ~ l.first;
IF ns#NIL AND ns.strokeCnt>0 THEN {
PutInt[stream, nsStartKey];
PutNormalizedStrokes[stream, l.first];
};
ENDLOOP;
PutInt[stream, dbFinishKey];
};

GetDB: PROC [stream: IO.STREAM] RETURNS [list: LIST OF NormalizedStrokes м NIL] = {
lag: LIST OF NormalizedStrokes м NIL;
i: INT м GetInt[stream];
IF i#dbStartKey THEN ERROR;
i м GetInt[stream];
WHILE i=nsStartKey DO
ns: NormalizedStrokes м GetNormalizedStrokes[stream];
IF ns#NIL THEN list м CONS[ns, list];
i м GetInt[stream];
ENDLOOP;
};

ReadDB: PUBLIC PROC [name: Rope.ROPE] RETURNS [TrainingDB] = {
stream: IO.STREAM м PFS.StreamOpen[PFS.PathFromRope[name]];
list: LIST OF NormalizedStrokes м GetDB[stream];
IO.Close[stream];
RETURN [list]
};

WriteDB: PUBLIC PROC [name: Rope.ROPE, db: TrainingDB] = {
list: LIST OF NormalizedStrokes ~ NARROW[db];
stream: IO.STREAM м PFS.StreamOpen[PFS.PathFromRope[name], create];
PutDB[stream, list];
IO.Close[stream];
};

MergeDB: PUBLIC PROC [into: TrainingDB м NIL, db: TrainingDB] RETURNS [TrainingDB] = {
inDB: LIST OF NormalizedStrokes м NARROW[into];
list: LIST OF NormalizedStrokes ~ NARROW[db];
FOR l: LIST OF NormalizedStrokes м list, l.rest WHILE l#NIL DO
ns: NormalizedStrokes ~ CopyNormalizedStrokes[l.first];
inDB м AddToDB[inDB, ns];
ENDLOOP;
RETURN [inDB];
};

END.

  H  
HandwritingImpl.mesa
Copyright ╙ 1992 by Xerox Corporation.  All rights reserved.
Christian Jacobi, September 8, 1992 4:05 pm PDT
Christian Jacobi, May 6, 1993 8:55 pm PDT

Handwriting recognition engine

Generic utilities
Normalization
--Count strokes and allocate memory
--Find total bounding box and length
--Copy with normalized size and position of original segments
--Special case for a dot
--Interpolate points
--Find each interpolated point
--reset offsets to move the origin to the mass center
Recognition
Training
--Monitor protects the structure, but not the contents
Input output
File format
Ascii because I can edit it (good only while no good data base software available)
Also shorter then 4 byte integers
Use original points so internal format can be changed
Design rationale for copying db: prevents circular db's

 Э╩И  ХNewlineDelimiter
Щ codeЩKЪЬ
╧eЬ1Щ<KЩ/KЩ)KЩ KЩKЩ ЧЪ╧k	Ш	KШKШKШKШKЪЬЮЬ	ШKШ ЧЪ╧nЬЮЬЮШKЪЮЬШKЪЮЬШЧKЪЮЬЮШheadЩЪЯЬЮЬЮЬЮЬЮЬЮЬШ5JЪЮЬЮЬЮЬЮЬШ.JШЧJШ Ъ
ЯЬЮЬЮЬЮЬЮЬШ?JЪЮЬЮЬЮЬЮЬШ.JШЧJШ ЪЯЬЮЬЮЬЮЬЮЬЮЬШ5JЪЮЬЮЬШ&JШЧJШ Ъ
ЯЬЮЬЮЬЮЬЮЬШ?JЪЮЬЮЬШ&JШЧJШ ЪЯЬЮЬЮЬЮЬЮЬЮЬЮЬШXЪЮЬЮЬЮЬШKЪЬЮЬ'Ш@ЪЮЬ ЮЬЮЬЮШ3KЪЬЮЬ+Ш;KШKЪЮШЧKШЧKШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬЮЬШaЪЮЬ	ЮЬЮЬШKЪЬЮЬ(ШBЪЮЬ%ЮЬЮЬЮШ7KЪЬЮЬ#Ш3KШKЪЮШЧKШЧKШЧЧLЩШ JЪЬЮЬШJЪЬЮЬЮЬЮЬШ%KЪЬЮЬЮЬЮЬШDJЪЬЮЬЮЬШ3ЪЬЮЬЮЬШ%KЪЬЮЬШKЪЬЮЬШKЪЬЮЬШKЪЬ
ЮЬЮЬШKЪЬЮЬЮЬЮЬШ7KЪЬШЧJЪЬ
ЯЮЬШJЪЬЮЬШ%JШ ЪЯЬЮЬЮЬШYKЪЬЮЬ%Ш/KШKЪЬ╧c"Ш>KШKШKШKЪЬЮЬШЪЮЬЮЬЮЬЮШ"KШKЪЮЬШЧKШЧKШ ЪЯЬЮЬЮЬЮЬ	Ш@ЪЮЬ ЮЬЮЬЮШ2JШJЪЮЬШЧJШKШ ЧЪЯЬЮЬЮЬШMJЪЬЮЬШJЪЬЮЬШJЪЬЮЬШJЪ	ЬЮЬЮЬЮЬЮЬШ%JЪ	ЬЮЬЮЬЮЬЮЬШ'JШKЩ#KШ"JЪЮЬЮЬЮЬШJЪЬЮЬ"Ш*KЩ$JШЪЮЬ ЮЬЮЬЮШ2JЪЬЮЬШJШ!ЪЮЬ"ЮЬЮЬЮШ5JШJЪЬЮЬЮЬШ9JЪЬЮЬЮЬШ9KЪЬЮЬЮЬШFJШJЪЮЬШЧJШ.JШ!JШJЪЮЬШЧJЩ=KШKШЪЮЬЮЬЮЬШ/JЩJШ	JШHЪЮЬЮЬЮЬЮШ JЪЬЮЬ	ШJЪЮЬШЧJЪЮЬШJШЧKЪЬЮЬЮЬШDKШWJЩJШЪЮЬ ЮЬЮЬЮШ2JШJШKЪЬЮЬ+Ш@KЪЬЮЬ%Ш:JЪЬЮЬШJЪЬ
ЮЬШJШJШ"JШ"JЩЪЮЬЮЬЮЬЮШ"JЪЬЮЬШKШ'ЪЮЬаШ"JШЪЮЬЮЬЮЬШJШJЪЮЬШJШЧKШKШKЪЬЮЬЮЬШЪЮЬШJЪЮЬЮЬаШ#ЪЮЬШJШJШJШJШЧЧJЪЮЬШЧЪЮЬЮЬШ#ЪЮЬШJЪЮЬЮЬЮЬШ$JШЧЪЮЬШJЪЬЮЬШ+KШ)KШ)JШЧЧJШJШ"JШ"JЪЮЬШЧJШJЪЮЬШЧJЩ5ЪЮЬЮЬШJЪЬЮЬШЪЮЬЮЬЮЬЮШ ЪЮЬЮЬЮЬЮШ#JШ:JЪЮЬШ	ЧJЪЮЬШ	ЧJШ!JШ!ЪЮЬЮЬЮЬЮШ ЪЮЬЮЬЮЬЮШ#JШ-JШ+JЪЮЬШ	ЧJЪЮЬШ	ЧJШЧJШЧJШ ЪЯ	ЬЮЬЮЬЮЬЮЬЮЬШIKШ2KШKЪЮЬШKШЧJШ Ъ
Я	ЬЮЬ"ЮЬЮЬЮЬШ_JЪЬЮЬШJЪ	ЬЮЬЮЬЮЬЮЬШ%JЪ	ЬЮЬЮЬЮЬЮЬШ'Ъ	ЮЬЮЬЮ
ЬЮЬЮШ.Ъ	ЮЬЮЬЮ
ЬЮЬЮШ.JШ7JЪЬЮЬШJЪЬЮЬШJЪЬЮЬШJЪЬЮЬШJЪЮЬШЧJЪЮЬШЧJЪЬЮЬЮЬ	ЮЬ	ЮЬ	ЮЬШCЪ	ЮЬЮЬЮ
ЬЮЬЮШ.JЪЬЮЬШЪ	ЮЬЮЬЮ
ЬЮЬЮШ.JШ7JШJШJЪЬЮЬШJЪЮЬШЧJЪЬ
ЮЬШJЪЮЬШЧJШJШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬШSKЪЬЮЬШ"KШ!KШKШ ЧЧЩЪЯЬЮЬ&ЮЬЮЬЮЬЮЬЮЬ	Ш`ЪЯЬЮЬ#ЮЬЮЬЮЬЮЬШdKЪЮЬЮЬ0ЮЬ.ШlJШЧKЪ
ЮЬЮЬЮЬЮЬЮЬШ7ЪЮЬЮЬЮЬЮШ$ЪЮЬЮЬЮЬЮШ#KЪЬЮЬШ!JШJЪЮЬ	ЮЬЮЬШJЪЮЬШЧJЪЮЬШЧJШЧJШ ЪЬЮЬЮЬШKЪЬЮЬЮЬЮЬШKЪЬЮШKШKШ ЧЪ
ЯЬЮЬЮЬЮЬЮЬ#ШpJЪЬЮЬШJЪЬЮЬЮЬШ.JЪЬЮЬШЪЯЬЮЬЮЬШ(ЪЮЬЮЬЮЬЮШ#ЪЮЬЮЬШJЪЬЮЬШ"Ъ	ЮЬЮЬЮ
ЬЮЬЮШ%JШJЪЮЬШЧJШJЪЮЬШJШЧJЪЮШЧJШЧЪЮЬЮЬЮЬ#ЮЬЮЬЮШAJЪЬЮЬШ#JШJЪЮЬШЧJШJШJШJШ ЧЪЯЬЮЬЮЬ!ЮЬЮЬЮЬЮЬШuJШJЪЬЮЬЮЬЮЬШ/JЪЬЮЬШ"JШ(ЪЮЬЮЬЮШKЪЬЮЬIШTЧЪЮЬ	ЮЬЮШKЪЬЮЬ7ШBЧJШJШ ЧЪЯ	ЬЮЬЮЬ$ЮЬЮЬЮЬЮЬШnJШ2KЪЮЬШ%JШЧKШ ЧЩЪ
ЯЬЮЬЮЬЮЬЮЬ
Ш?KЪЬЮЬШ"KЪЮЬЮЬЮЬШKШKШ ЧЪЯЬЮЬЮЬЮЬ
Ш6KЪЬЮЬШ"KЪЮЬЮЬЮЬШKШKШJШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬШWЪЮЬЮЬЮЬШKЪЮЬЮЬЮЬШKЪЮЬЮЬЮЬЮЬШ)ЧKШЧKШ ЪЯЬЮЬЮЬЮЬ+ЮЬЮЬЮЬШlKЪЮЬЮЬЮЬШ+KЪЮЬЮЬ
ШJШJШ ЧЪ
ЯЬЮЬЮЬ(ЮЬЮЬШYJЪЬЮЬЮЬЮЬШ-KШ2KШKЪЮЬШKШЧKШ ЪЯЬЮЬЮЬ!ЮЬШWJЪЬЮЬЮЬЮЬШ-KЪЮЬЮЬШ!KШKШ ЧЪ
ЯЬЮЬЮЬ!ЮЬЮЬШZJЪЬЮЬЮЬЮЬШ-JЪЬЮЬШ"JЪЮЬЮЬЮЬЮЬШ#ЪЮЬЮЬЮЬ"ЮЬЮЬЮШ>ЪЮЬЮЬЮЬЮЬШ#JЪЮЬШJШЧJЪЮЬШЧJШKШ ЧЪ
Я	ЬЮЬЮЬЮЬЮЬШHЪ
Я
ЬЮЬЮЬЮЬЮЬ-ШQJЩ6ЪЮЬЮЬЮЬШJЪЬЮЬЮЬШ)JЪЮЬЮЬЮЬЮЬШ0JШЧJШЧJЪЬЮЬЮЬЮЬШ-JЪЬЮЬШ"JЪ
ЮЬЮЬЮЬЮЬЮЬШJЪЮЬЮЬЮЬШ)ЪЮЬЮЬЮЬ"ЮЬЮЬЮШ>ЪЮЬЮЬЮЬЮЬШ*JШJЪЮЬШJШЧJЪЮЬШЧKЪЮЬШKШKШ ЧЧЩЩJЩRJЩ!JЩ5ЧJШ JЪЬЮЬШJЪЬЮЬШJЪЬЮЬШJЪЬЮЬШJШ Ъ
ЯЬЮЬ
ЮЬЮЬЮЬШ,JЪЮЬЮЬ	ШJЪЮЬШJШJШ ЧЪЯЬЮЬ
ЮЬЮЬЮЬЮЬШ2JЪЮЬШJШJШ ЧЪ
ЯЬЮЬ
ЮЬЮЬЮЬШMJЪЬЮЬШЪЮЬЮЬЮЬЮШ-JЪЬЮЬШ)JЪЬЮЬШ)JЪЮЬШЧJШJШJШ ЧЪЯЬЮЬ
ЮЬЮЬЮЬЮЬШLJЪЬЮЬШЪЮШJШJЪЮЬЮЬЮЬШJШJЪЬЮЬ	ШJЪЮЬЮЬЮЬЮЬШ3JШJЪЮЬШЧJШJШ ЧЪЯЬЮЬ
ЮЬЮЬШIJШJШJШJШЪЮЬЮЬЮЬЮШ"JШ;JШJЪЮШЧJШJШ ЧЪ
ЯЬЮЬ
ЮЬЮЬЮЬШRJЪЬЮЬШJЪЬЮЬШJЪЬЮЬШJЪЬЮЬШ ЪЮЬЮЬЮЬЮШJШ)ЪЮЬЮЬЮЬШJЪЬЮЬ	ШJЪЮЬЮЬЮЬЮЬШ4JШJШЧJЪЮШЧJШJШJШЧJШ ЪЯЬЮЬ
ЮЬЮЬЮЬЮЬШDJШЪЮЬЮЬЮЬ"ЮЬЮЬЮШ>JШ ЪЮЬЮЬЮЬЮЬШ#JШJШ&JШЧJЪЮЬШЧJШJШJШ ЧЪЯЬЮЬ
ЮЬЮЬЮЬЮЬЮЬЮЬШSJЪЬЮЬЮЬЮЬШ%JЪЬЮЬШJЪЮЬЮЬЮЬШJШЪЮЬЮШJШ5JЪЮЬЮЬЮЬЮЬШ%JШJЪЮЬШЧJШЧJШ Ъ
ЯЬЮЬЮЬЮЬЮЬШ>JЪ	ЬЮЬЮЬЮЬЮЬШ;JЪЬЮЬЮЬ#Ш0JЪЮЬШJЪЮЬШJШJШ ЧЪЯЬЮЬЮЬЮЬШ:JЪЬЮЬЮЬЮЬШ-JЪ	ЬЮЬЮЬЮЬЮЬШCJШJЪЮЬШJШЧJШ ЪЯЬЮЬЮЬЮЬШVJЩ7JЪЬЮЬЮЬЮЬШ/JЪЬЮЬЮЬЮЬШ-ЪЮЬЮЬЮЬ"ЮЬЮЬЮШ>JШ7JШJЪЮЬШЧJЪЮЬШJШJШ ЧЧЪЮЬШJЩ ЧKШ Ч ЕЧ    3(  I°  