co♻e: unittest framework for CODESYS

405 lines (405 with data), 45.0 kB

Gx_l
╡╞!0┘jЭoЫ┬*1┬⌡▒&█иі	

System.StringL{f8a58466-d7f6-439f-bbb8-d4600e41d099}ImplementationL{3b83b776-fb25-43b8-99f2-3c507c9143fc}TextDocumentL{f3878285-8e4f-490b-bb1b-9acbb7eb04db}TextLinesL{a5de0b0b-1cb5-4913-ac21-9d70293ec00d}	Id
longTagText
░
IF GVL_CfUnit.IgnoreCurrentTest OR GVL_CfUnit.CurrentTestIsFinished THEN    RETURN;END_IF(*√
    This compares two instances of any object type and returns whether they═
    are the same type, size and value or not. This is necessary for two reasons:═
    1. So that we can know exactly what differs between the two input parameters╗
    2. It's not possible to do a comparison (= or <>) between two instances of ANY. *)d(* Check whether the type of the inputs differs *)\IF Expected.TypeClass <> Actual.TypeClass THEN>    DataTypesNotEquals := TRUE;(* V	For STRING & WSTRING we make an exception,└
	we skip checking them on size and start comparing them on content√
IF    UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_STRING╒
   OR UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_WSTRING THEN    	(* STRING *)!°
	IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_STRING THEN"ж
		MEMCPY(destAddr := ADR(stringExpected), srcAddr := Expected.pValue, n := DINT_TO_UDINT(Expected.diSize));#й
		MEMCPY(destAddr := ADR(stringActual), srcAddr := Actual.pValue, n := DINT_TO_UDINT(Actual.diSize));$╪
		AssertEquals_STRING(Expected := stringExpected, Actual := stringActual, Message := Message);%		RETURN;&	END_IF'	(	(* WSTRING *))·
	IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_WSTRING THEN*ь
		MEMCPY(destAddr := ADR(wstringExpected), srcAddr := Expected.pValue, n := DINT_TO_UDINT(Expected.diSize));+л
		MEMCPY(destAddr := ADR(wstringActual), srcAddr := Actual.pValue, n := DINT_TO_UDINT(Actual.diSize));,б
		AssertEquals_WSTRING(Expected := wstringExpected, Actual := wstringActual, Message := Message);-ELSE.f	(* Check whether the size of the inputs differs *)/>	IF NOT DataTypesNotEquals THEN0X		IF (Expected.diSize <> Actual.diSize) THEN1:			DataSizeNotEquals := TRUE;2		END_IF3є
(* Even though the data type and size are equals, the contents may still differ *)4pIF NOT DataTypesNotEquals AND NOT DataSizeNotEquals THEN5R    // Compare each byte in the ANY-types6v    FOR IteratorCounter := 0 TO Expected.diSize - 1 BY 1 DO7є
        IF Expected.pValue[IteratorCounter] <> Actual.pValue[IteratorCounter] THEN8R            DataContentNotEquals := TRUE;9"            EXIT;:        END_IF;    END_FOR<л
(* First check whether the input data are any of the standard data types that are supported by TcUnit.=т
   In this case call the standard Assert-methods for that data. But before doing that we need to make sure>J   that both the expected and actual:?B   - Have both the same data type@B   - Both have the same data sizeA    (* BOOL *)B·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_BOOL THENC╝
		MEMCPY(destAddr := ADR(boolExpected), srcAddr := Expected.pValue, n := SIZEOF(BOOL));D╡
        MEMCPY(destAddr := ADR(boolActual), srcAddr := Actual.pValue, n := SIZEOF(BOOL));E╪
        AssertEquals_BOOL(Expected := boolExpected, Actual := boolActual, Message := Message);F        RETURN;G    END_IFH    (* BYTE *)I·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_BYTE THENJ╨
        MEMCPY(destAddr := ADR(byteExpected), srcAddr := Expected.pValue, n := SIZEOF(BYTE));K╡
        MEMCPY(destAddr := ADR(byteActual), srcAddr := Actual.pValue, n := SIZEOF(BYTE));L╪
        AssertEquals_BYTE(Expected := byteExpected, Actual := byteActual, Message := Message);M    (* DATE *)N·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_DATE THENO╨
        MEMCPY(destAddr := ADR(dateExpected), srcAddr := Expected.pValue, n := SIZEOF(DATE));P╡
        MEMCPY(destAddr := ADR(dateActual), srcAddr := Actual.pValue, n := SIZEOF(DATE));Q╪
        AssertEquals_DATE(Expected := dateExpected, Actual := dateActual, Message := Message);R.    (* DATE_AND_TIME *)S╛
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_DATEANDTIME THENTз
        MEMCPY(destAddr := ADR(dateAndTimeExpected), srcAddr := Expected.pValue, n := SIZEOF(DATE_AND_TIME));Uр
        MEMCPY(destAddr := ADR(dateAndTimeActual), srcAddr := Actual.pValue, n := SIZEOF(DATE_AND_TIME));VЙ
        AssertEquals_DATE_AND_TIME(Expected := dateAndTimeExpected, Actual := dateAndTimeActual, Message := Message);W    (* DINT *)X·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_DINT THENY╨
        MEMCPY(destAddr := ADR(dintExpected), srcAddr := Expected.pValue, n := SIZEOF(DINT));Z╡
        MEMCPY(destAddr := ADR(dintActual), srcAddr := Actual.pValue, n := SIZEOF(DINT));[╪
        AssertEquals_DINT(Expected := dintExpected, Actual := dintActual, Message := Message);\    (* DWORD *)]═
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_DWORD THEN^╬
        MEMCPY(destAddr := ADR(dwordExpected), srcAddr := Expected.pValue, n := SIZEOF(DWORD));_І
        MEMCPY(destAddr := ADR(dwordActual), srcAddr := Actual.pValue, n := SIZEOF(DWORD));`б
        AssertEquals_DWORD(Expected := dwordExpected, Actual := dwordActual, Message := Message);a    (* INT *)b°
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_INT THENcІ
        MEMCPY(destAddr := ADR(intExpected), srcAddr := Expected.pValue, n := SIZEOF(INT));d╝
        MEMCPY(destAddr := ADR(intActual), srcAddr := Actual.pValue, n := SIZEOF(INT));eІ
        AssertEquals_INT(Expected := intExpected, Actual := intActual, Message := Message);f    (* LINT *)g·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_LINT THENh╨
        MEMCPY(destAddr := ADR(lintExpected), srcAddr := Expected.pValue, n := SIZEOF(LINT));i╡
        MEMCPY(destAddr := ADR(lintActual), srcAddr := Actual.pValue, n := SIZEOF(LINT));j╪
        AssertEquals_LINT(Expected := lintExpected, Actual := lintActual, Message := Message);k    (* LREAL *)l═
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_LREAL THENm╬
        MEMCPY(destAddr := ADR(lrealExpected), srcAddr := Expected.pValue, n := SIZEOF(LREAL));nІ
        MEMCPY(destAddr := ADR(lrealActual), srcAddr := Actual.pValue, n := SIZEOF(LREAL));oч
        AssertEquals_LREAL(Expected := lrealExpected, Actual := lrealActual, Delta := 0.0, Message := Message);p    (* LTIME *)q═
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_LTIME THENr╬
        MEMCPY(destAddr := ADR(ltimeExpected), srcAddr := Expected.pValue, n := SIZEOF(LTIME));sІ
        MEMCPY(destAddr := ADR(ltimeActual), srcAddr := Actual.pValue, n := SIZEOF(LTIME));tб
        AssertEquals_LTIME(Expected := ltimeExpected, Actual := ltimeActual, Message := Message);u    (* LWORD *)v═
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_LWORD THENw╬
        MEMCPY(destAddr := ADR(lwordExpected), srcAddr := Expected.pValue, n := SIZEOF(LWORD));xІ
        MEMCPY(destAddr := ADR(lwordActual), srcAddr := Actual.pValue, n := SIZEOF(LWORD));yб
        AssertEquals_LWORD(Expected := lwordExpected, Actual := lwordActual, Message := Message);z    (* REAL *){·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_REAL THEN|╨
        MEMCPY(destAddr := ADR(realExpected), srcAddr := Expected.pValue, n := SIZEOF(REAL));}╡
        MEMCPY(destAddr := ADR(realActual), srcAddr := Actual.pValue, n := SIZEOF(REAL));~ь
        AssertEquals_REAL(Expected := realExpected, Actual := realActual, Delta := 0.0, Message := Message);    (* SINT *)─
·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_SINT THEN│
╨
        MEMCPY(destAddr := ADR(sintExpected), srcAddr := Expected.pValue, n := SIZEOF(SINT));┌
╡
        MEMCPY(destAddr := ADR(sintActual), srcAddr := Actual.pValue, n := SIZEOF(SINT));┐
╪
        AssertEquals_SINT(Expected := sintExpected, Actual := sintActual, Message := Message);└
$   // (* STRING *)┘
і
   // IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_STRING THEN├
Ф
   //     MEMCPY(destAddr := ADR(stringExpected), srcAddr := Expected.pValue, n := DINT_TO_UDINT(Expected.diSize));┤
з
   //     MEMCPY(destAddr := ADR(stringActual), srcAddr := Actual.pValue, n := DINT_TO_UDINT(Actual.diSize));┬
л
   //     AssertEquals_STRING(Expected := stringExpected, Actual := stringActual, Message := Message);┴
"   //     RETURN;┼
   // END_IF▀
	//▄
 	//(* WSTRING *)█
╗
   // IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_WSTRING THEN▌
Х
   //     MEMCPY(destAddr := ADR(wstringExpected), srcAddr := Expected.pValue, n := DINT_TO_UDINT(Expected.diSize));▐
э
   //     MEMCPY(destAddr := ADR(wstringActual), srcAddr := Actual.pValue, n := DINT_TO_UDINT(Actual.diSize));░
р
   //     AssertEquals_WSTRING(Expected := wstringExpected, Actual := wstringActual, Message := Message);▒
    (* TIME *)▓
·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_TIME THEN⌠
╨
        MEMCPY(destAddr := ADR(timeExpected), srcAddr := Expected.pValue, n := SIZEOF(TIME));■
╡
        MEMCPY(destAddr := ADR(timeActual), srcAddr := Actual.pValue, n := SIZEOF(TIME));∙
╪
        AssertEquals_TIME(Expected := timeExpected, Actual := timeActual, Message := Message);√
*    (* TIME_OF_DAY *)≈
╗
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_TIMEOFDAY THEN≤
р
        MEMCPY(destAddr := ADR(timeOfDayExpected), srcAddr := Expected.pValue, n := SIZEOF(TIME_OF_DAY));≥
й
        MEMCPY(destAddr := ADR(timeOfDayActual), srcAddr := Actual.pValue, n := SIZEOF(TIME_OF_DAY)); 
ч
        AssertEquals_TIME_OF_DAY(Expected := timeOfDayExpected, Actual := timeOfDayActual, Message := Message);⌡
    (* UDINT *)°
═
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_UDINT THEN²
╬
        MEMCPY(destAddr := ADR(udintExpected), srcAddr := Expected.pValue, n := SIZEOF(UDINT));·
І
        MEMCPY(destAddr := ADR(udintActual), srcAddr := Actual.pValue, n := SIZEOF(UDINT));÷
б
        AssertEquals_UDINT(Expected := udintExpected, Actual := udintActual, Message := Message);═
    (* UINT *)║
·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_UINT THEN╒
╨
        MEMCPY(destAddr := ADR(uintExpected), srcAddr := Expected.pValue, n := SIZEOF(UINT));ё
╡
        MEMCPY(destAddr := ADR(uintActual), srcAddr := Actual.pValue, n := SIZEOF(UINT));є
╪
        AssertEquals_UINT(Expected := uintExpected, Actual := uintActual, Message := Message);╔
    (* ULINT *)і
═
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_ULINT THENї
╬
        MEMCPY(destAddr := ADR(ulintExpected), srcAddr := Expected.pValue, n := SIZEOF(ULINT));╗
І
        MEMCPY(destAddr := ADR(ulintActual), srcAddr := Actual.pValue, n := SIZEOF(ULINT));╘
б
        AssertEquals_ULINT(Expected := ulintExpected, Actual := ulintActual, Message := Message);╙
    (* USINT *)╚
═
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_USINT THEN╛
╬
        MEMCPY(destAddr := ADR(usintExpected), srcAddr := Expected.pValue, n := SIZEOF(USINT));ґ
І
        MEMCPY(destAddr := ADR(usintActual), srcAddr := Actual.pValue, n := SIZEOF(USINT));╝
б
        AssertEquals_USINT(Expected := usintExpected, Actual := usintActual, Message := Message);╞
    (* WORD *)╟
·
    IF UDINT_TO_INT(Expected.TypeClass) = IBaseLibrary.TypeClass.TYPE_WORD THEN╠
╨
        MEMCPY(destAddr := ADR(wordExpected), srcAddr := Expected.pValue, n := SIZEOF(WORD));╡
╡
        MEMCPY(destAddr := ADR(wordActual), srcAddr := Actual.pValue, n := SIZEOF(WORD));Ё
╪
        AssertEquals_WORD(Expected := wordExpected, Actual := wordActual, Message := Message);Є
Х
(* If we've come to this row, it means that the data input is not any of the standard primitive data types, and thus╣
H   we need to do special handling *)І
╬
TestInstancePath := AddTestNameToInstancePath(TestInstancePath := FINDTestSuiteInstancePath());Ї
4IF DataTypesNotEquals THEN╦
Б
    ExpectedDataString := CONCAT(STR1 := '(Type class = ', STR2 := F_AnyTypeClassToString((Expected.TypeClass)));╧
■
    ExpectedDataString := CONCAT(STR1 := ExpectedDataString, STR2 := ')');╨
ж
    ActualDataString := CONCAT(STR1 := '(Type class = ', STR2 := F_AnyTypeClassToString(Actual.TypeClass));╩
▄
    ActualDataString := CONCAT(STR1 := ActualDataString, STR2 := ')');╪
8ELSIF DataSizeNotEquals THENҐ
д
    ExpectedDataString := CONCAT(STR1 := 'Data size = ', STR2 := DINT_TO_STRING(Expected.diSize));╬
╪
    ActualDataString := CONCAT(STR1 := 'Data size = ', STR2 := DINT_TO_STRING(Actual.diSize));©
>ELSIF DataContentNotEquals THENю
Э
    FOR Count := 0 TO MIN(Expected.diSize-1, 38) BY 1 DO // One byte will equal two characters (example: 255 = 0xff, 1 = 0x01)а
─
        ExpectedDataString := CONCAT(STR1 := ExpectedDataString,б
л
                                                  STR2 := BYTE_TO_HEXSTR(in := Expected.pValue[Count],ц
н
                                                                                       iPrecision := 2,д
т
                                                                                       bLoCase := FALSE));е
√
    ExpectedDataString := CONCAT(STR1 := '0x', STR2 := ExpectedDataString);ф
Ь
    FOR Count := 0 TO MIN(Actual.diSize-1, 38) BY 1 DO // One byte will equal two characters (example: 255 = 0xff, 1 = 0x01)г
x        ActualDataString := CONCAT(STR1 := ActualDataString,х
д
                                                STR2 := BYTE_TO_HEXSTR(in := Actual.pValue[Count],и
й
                                                                                     iPrecision := 2,й
п
                                                                                     bLoCase := FALSE));к
▌
    ActualDataString := CONCAT(STR1 := '0x', STR2 := ActualDataString);л
■
AssertResults.ReportResult(ExpectedSize := DINT_TO_UDINT(Expected.diSize),м
╒
                           ExpectedTypeClass := UDINT_TO_INT(Expected.TypeClass),н
x                           ExpectedValue := Expected.pValue,о
▄
                           ActualSize := DINT_TO_UDINT(Actual.diSize),п
 
                           ActualTypeClass := UDINT_TO_INT(Actual.TypeClass),я
p                           ActualValue := Actual.pValue,р
\                           Message := Message,с
─
                           TestInstancePath := TestInstancePath,т
~                           AlreadyReported => AlreadyReported);у
б
IF NOT AlreadyReported AND (DataTypesNotEquals OR DataSizeNotEquals OR DataContentNotEquals) THENж
x    SetTestFailed(AssertionType := E_AssertionType.Type_ANY,в
^                  AssertionMessage := Message);ь
√
    AssertMessageFormatter.LogAssertFailure(Expected := ExpectedDataString,ы
▌
                                            Actual := ActualDataString,з
~                                            Message := Message,ш
є
                                            TestInstancePath := TestInstancePath);э
Interfaceщ
L{a9ed5b7e-75c5-4651-af16-d2c27e98cb94}ч
л
(* | Asserts that two objects (of any type) are equal. If they are not, an assertion error is created.ъ
╟
 | STRING/WSTRING's a treated different, they are only compared textual and on datatype.Ю
н
 | For REAL and LREAL it s recommended to use the AssertEquals_REAL or AssertEquals_LREAL respectively А
Є
 | as these give the possibility to specify a delta between the expected and actual value.Б
 Parameters:Ц
@     | Expected   Expected valueД
8     | Actual   Actual valueЕ
─
     | Message   The identifying message for the assertion errorФ
$ Positive example:Г
0 .. code-block:: codesysХ
     VARИ
,         a : INT := 5;Й
,         b : INT := 5;К
     END_VARЛ
:     TEST('Test_ANY_Equals');М
@     AssertEquals(Expected := a,Н
<                  Actual := b,О
\                  Message := 'Values differ');П
*     TEST_FINISHED();Я
" Failing example:Р
.         b : UINT := 5;С
L     TEST('Test_ANY_Differ_DataType');Т
4METHOD PUBLIC AssertEqualsУ
VAR_INPUTЖ
J    Expected : ANY; // Expected valueВ
p    Actual : ANY; // The value to check against expectedЬ
 
    Message : T_MaxString; // The identifying message for the assertion errorЫ
END_VARЗ
VARШ
"    Count : DINT;Э
H    ExpectedDataString : STRING(80);Щ
D    ActualDataString : STRING(80);Ч
F    TestInstancePath : T_MaxString;Ъ
6    AlreadyReported : BOOL;─0    boolExpected : BOOL;│,    boolActual : BOOL;┌0    byteExpected : BYTE;┐,    byteActual : BYTE;└0    dateExpected : DATE;┘,    dateActual : DATE;├P    dateAndTimeExpected : DATE_AND_TIME;┤L    dateAndTimeActual : DATE_AND_TIME;┬0    dintExpected : DINT;┴,    dintActual : DINT;┼4    dwordExpected : DWORD;▀0    dwordActual : DWORD;▄,    intExpected : INT;█(    intActual : INT;▌0    lintExpected : LINT;▐,    lintActual : LINT;░4    lrealExpected : LREAL;▒0    lrealActual : LREAL;▓4    ltimeExpected : LTIME;⌠0    ltimeActual : LTIME;■4    lwordExpected : LWORD;∙0    lwordActual : LWORD;√0    realExpected : REAL;≈,    realActual : REAL;≤0    sintExpected : SINT;≥,    sintActual : SINT; B    stringExpected : T_MaxString;⌡>    stringActual : T_MaxString;°@	wstringExpected : WSTRING(255);²B    wstringActual : WSTRING(255);·0    timeExpected : TIME;÷,    timeActual : TIME;═H    timeOfDayExpected : TIME_OF_DAY;║D    timeOfDayActual : TIME_OF_DAY;╒4    udintExpected : UDINT;ё0    udintActual : UDINT;є0    uintExpected : UINT;╔,    uintActual : UINT;і4    ulintExpected : ULINT;ї0    ulintActual : ULINT;╗4    usintExpected : USINT;╘0    usintActual : USINT;╙0    wordExpected : WORD;╚,    wordActual : WORD;╛    ґD    (* ANY comparison variables *)╝╨
    DataTypesNotEquals : BOOL; // The data type of the two ANY input parameters are not equal╞╦
    DataSizeNotEquals : BOOL; // The data size of the two ANY input parameters are not equal╟д
    DataContentNotEquals : BOOL; // The data content of the two ANY input parameters are not equal╠6    IteratorCounter : DINT;пп
п
E╙пп	
ґэ
зп
-
пп	
ґщ
зп
-пп	
ґч
зп
-пп	
ґъ
зп
-пп	
ґЮ
зп
-пп	
ґА
зп
-пп	
ґБ
зп
-пп	
ґЦ
зп
-пп	
ґД
зп
-пп	
ґЕ
зп
-пп	
ґзп
-пп	
ґФ
зп
-пп	
ґГ
зп
-пп	
ґХ
зп
-пп	
ґИ
зп
-пп	
ґЙ
зп
-пп	
ґК
зп
-пп	
ґзп
-пп	
ґзп
-пп	
ґзп
-пп	
ґЛ
зп
-пп	
ґМ
зп
-пп	
ґН
зп
-пп	
ґО
зп
- пп	
ґП
зп
-!пп	
ґЯ
зп
-"пп	
ґР
зп
-#пп	
ґС
зп
-$пп	
ґТ
зп
-%пп	
ґУ
зп
-&пп	
ґЖ
зп
-'пп	
ґВ
зп
-(пп	
ґЬ
зп
-)пп	
ґЫ
зп
-*пп	
ґЗ
зп
-+пп	
ґШ
зп
-,пп	
ґЭ
зп
-%пп	
ґЩ
зп
-&пп	
ґЧ
зп
-'пп	
ґЪ
зп
--пп	
ґзп
-.пп	
ґ
зп
-/пп	
ґзп
-0пп	
ґзп
-1пп	
ґзп
-2пп	
ґзп
-&пп	
ґзп
-пп	
ґзп
-пп	
ґзп
-пп	
ґ	зп
-3пп	
ґ
зп
-4пп	
ґзп
-5пп	
ґзп
-6пп	
ґ
зп
-7пп	
ґзп
-8пп	
ґзп
-9пп	
ґзп
-:пп	
ґзп
-;пп	
ґзп
-пп	
ґзп
-пп	
ґзп
-<пп	
ґзп
-=пп	
ґзп
->пп	
ґзп
-?пп	
ґзп
-@пп	
ґзп
-пп	
ґзп
-4пп	
ґзп
-пп	
ґзп
-Aпп	
ґзп
-Bпп	
ґзп
-Cпп	
ґзп
-пп	
ґ зп
-Dпп	
ґ!зп
-Eпп	
ґ"зп
-Fпп	
ґ#зп
-Gпп	
ґ$зп
-пп	
ґ%зп
-Hпп	
ґ&зп
-Iпп	
ґ'зп
-Jпп	
ґ(зп
-Kпп	
ґ)зп
-Lпп	
ґ*зп
-Fпп	
ґ+зп
-Gпп	
ґ,зп
-пп	
ґ-зп
-Mпп	
ґ.зп
-Nпп	
ґ/зп
-Oпп	
ґ0зп
-Pпп	
ґ1зп
-Qпп	
ґ2зп
-Fпп	
ґ3зп
-Gпп	
ґ4зп
-пп	
ґ5зп
-Rпп	
ґ6зп
-Sпп	
ґ7зп
-Tпп	
ґ8зп
-Uпп	
ґ9зп
-Vпп	
ґ:зп
-Fпп	
ґ;зп
-Gпп	
ґ<зп
-пп	
ґ=зп
-Wпп	
ґ>зп
-Xпп	
ґ?зп
-Yпп	
ґ@зп
-Zпп	
ґAзп
-[пп	
ґBзп
-Fпп	
ґCзп
-Gпп	
ґDзп
-пп	
ґEзп
-\пп	
ґFзп
-]пп	
ґGзп
-^пп	
ґHзп
-_пп	
ґIзп
-`пп	
ґJзп
-Fпп	
ґKзп
-Gпп	
ґLзп
-пп	
ґMзп
-aпп	
ґNзп
-bпп	
ґOзп
-cпп	
ґPзп
-dпп	
ґQзп
-eпп	
ґRзп
-Fпп	
ґSзп
-Gпп	
ґTзп
-пп	
ґUзп
-fпп	
ґVзп
-gпп	
ґWзп
-hпп	
ґXзп
-iпп	
ґYзп
-jпп	
ґZзп
-Fпп	
ґ[зп
-Gпп	
ґ\зп
-пп	
ґ]зп
-kпп	
ґ^зп
-lпп	
ґ_зп
-mпп	
ґ`зп
-nпп	
ґaзп
-oпп	
ґbзп
-Fпп	
ґcзп
-Gпп	
ґdзп
-пп	
ґeзп
-pпп	
ґfзп
-qпп	
ґgзп
-rпп	
ґhзп
-sпп	
ґiзп
-tпп	
ґjзп
-Fпп	
ґkзп
-Gпп	
ґlзп
-пп	
ґmзп
-uпп	
ґnзп
-vпп	
ґoзп
-wпп	
ґpзп
-xпп	
ґqзп
-yпп	
ґrзп
-Fпп	
ґsзп
-Gпп	
ґtзп
-пп	
ґuзп
-zпп	
ґvзп
-{пп	
ґwзп
-|пп	
ґxзп
-}пп	
ґyзп
-~пп	
ґzзп
-Fпп	
ґ{зп
-Gпп	
ґ|зп
-пп	
ґ}зп
-пп	
ґ~зп
-─
пп	
ґзп
-│
пп	
ґ─зп
-┌
пп	
ґ│зп
-┐
пп	
ґ┌зп
-Fпп	
ґ┐зп
-Gпп	
ґ└зп
-пп	
ґ┘зп
-└
пп	
ґ├зп
-┘
пп	
ґ┤зп
-├
пп	
ґ┬зп
-┤
пп	
ґ┴зп
-┬
пп	
ґ┼зп
-┴
пп	
ґ▀зп
-┼
пп	
ґ▄зп
-▀
пп	
ґ█зп
-▄
пп	
ґ▌зп
-█
пп	
ґ▐зп
-▌
пп	
ґ░зп
-▐
пп	
ґ▒зп
-░
пп	
ґ▓зп
-┴
пп	
ґ⌠зп
-┼
пп	
ґ■зп
-пп	
ґ∙зп
-▒
пп	
ґ√зп
-▓
пп	
ґ≈зп
-⌠
пп	
ґ≤зп
-■
пп	
ґ≥зп
-∙
пп	
ґ зп
-Fпп	
ґ⌡зп
-Gпп	
ґ°зп
-пп	
ґ²зп
-√
пп	
ґ·зп
-≈
пп	
ґ÷зп
-≤
пп	
ґ═зп
-≥
пп	
ґ║зп
- 
пп	
ґ╒зп
-Fпп	
ґёзп
-Gпп	
ґєзп
-пп	
ґ╔зп
-⌡
пп	
ґізп
-°
пп	
ґїзп
-²
пп	
ґ╗зп
-·
пп	
ґ╘зп
-÷
пп	
ґ╙зп
-Fпп	
ґ╚зп
-Gпп	
ґ╛зп
-пп	
ґґзп
-═
пп	
ґ╝зп
-║
пп	
ґ╞зп
-╒
пп	
ґ╟зп
-ё
пп	
ґ╠зп
-є
пп	
ґ╡зп
-Fпп	
ґЁзп
-Gпп	
ґЄзп
-пп	
ґ╣зп
-╔
пп	
ґІзп
-і
пп	
ґЇзп
-ї
пп	
ґ╦зп
-╗
пп	
ґ╧зп
-╘
пп	
ґ╨зп
-Fпп	
ґ╩зп
-Gпп	
ґ╪зп
-пп	
ґҐзп
-╙
пп	
ґ╬зп
-╚
пп	
ґ©зп
-╛
пп	
ґюзп
-ґ
пп	
ґазп
-╝
пп	
ґбзп
-Fпп	
ґцзп
-Gпп	
ґдзп
-пп	
ґезп
-╞
пп	
ґфзп
-╟
пп	
ґгзп
-╠
пп	
ґхзп
-╡
пп	
ґизп
-Ё
пп	
ґйзп
-Fпп	
ґкзп
-Gпп	
ґлзп
-пп	
ґмзп
-пп	
ґнзп
-пп	
ґозп
-Є
пп	
ґпзп
-╣
пп	
ґязп
-І
пп	
ґрзп
-пп	
ґсзп
-Ї
пп	
ґтзп
-╦
пп	
ґузп
-╧
пп	
ґжзп
-╨
пп	
ґвзп
-╩
пп	
ґьзп
-╪
пп	
ґызп
-Ґ
пп	
ґззп
-╧
пп	
ґшзп
-╬
пп	
ґэзп
-╩
пп	
ґщзп
-©
пп	
ґчзп
-ю
пп	
ґъзп
-а
пп	
ґЮзп
-б
пп	
ґАзп
-ц
пп	
ґБзп
-д
пп	
ґЦзп
-;пп	
ґДзп
-е
пп	
ґЕзп
-пп	
ґФзп
-ф
пп	
ґГзп
-г
пп	
ґХзп
-х
пп	
ґИзп
-и
пп	
ґЙзп
-й
пп	
ґКзп
-;пп	
ґЛзп
-к
пп	
ґМзп
-пп	
ґНзп
-пп	
ґОзп
-л
пп	
ґПзп
-м
пп	
ґЯзп
-н
пп	
ґРзп
-о
пп	
ґСзп
-п
пп	
ґТзп
-я
пп	
ґУзп
-р
пп	
ґЖзп
-с
пп	
ґВзп
-т
пп	
ґЬзп
-пп	
ґЫзп
-у
пп	
ґЗзп
-ж
пп	
ґШзп
-в
пп	
ґЭзп
-пп	
ґЩзп
-ь
пп	
ґЧзп
-ы
пп	
ґЪзп
-з
пп	
ґзп
-ш
пп	
ґзп
-пэ
щ

п
Ehпп	
ґ=
зп
-ч
пп	
ґзп
-ъ
пп	
ґ>
зп
-Ю
пп	
ґ?
зп
-А
пп	
ґ@
зп
-пп	
ґA
зп
-Б
пп	
ґB
зп
-Ц
пп	
ґC
зп
-Д
пп	
ґD
зп
-Е
пп	
ґE
зп
-пп	
ґF
зп
-Ф
пп	
ґG
зп
-пп	
ґH
зп
-Г
пп	
ґI
зп
-пп	
ґJ
зп
-Х
пп	
ґK
зп
-И
пп	
ґL
зп
-Й
пп	
ґM
зп
-К
пп	
ґN
зп
-пп	
ґO
зп
-Л
пп	
ґP
зп
-М
пп	
ґQ
зп
-Н
пп	
ґR
зп
-О
пп	
ґS
зп
-П
пп	
ґT
зп
-пп	
ґU
зп
-Я
пп	
ґV
зп
-пп	
ґW
зп
-Г
пп	
ґX
зп
-пп	
ґY
зп
-Х
пп	
ґZ
зп
-И
пп	
ґ[
зп
-Р
пп	
ґ\
зп
-К
пп	
ґ]
зп
-пп	
ґ^
зп
-С
пп	
ґ_
зп
-М
пп	
ґ`
зп
-Н
пп	
ґa
зп
-О
пп	
ґ<
зп
-П
пп	
ґb
зп
-пп	
ґf
зп
-Т
пп	
ґg
зп
-У
пп	
ґh
зп
-Ж
пп	
ґi
зп
-В
пп	
ґj
зп
-Ь
пп	
ґk
зп
-Ы
пп	
ґl
зп
-З
пп	
ґm
зп
-Ш
пп	
ґn
зп
-Э
пп	
ґo
зп
-Щ
пп	
ґp
зп
-Ч
пп	
ґq
зп
-Ъ
пп	
ґr
зп
-пп	
ґs
зп
-─пп	
ґt
зп
-│пп	
ґu
зп
-┌пп	
ґv
зп
-┐пп	
ґw
зп
-└пп	
ґx
зп
-┘пп	
ґy
зп
-├пп	
ґz
зп
-┤пп	
ґ{
зп
-┬пп	
ґ|
зп
-┴пп	
ґ}
зп
-┼пп	
ґ~
зп
-▀пп	
ґ
зп
-▄пп	
ґ─
зп
-█пп	
ґ│
зп
-▌пп	
ґ┌
зп
-▐пп	
ґ┐
зп
-░пп	
ґ└
зп
-▒пп	
ґ┘
зп
-▓пп	
ґ├
зп
-⌠пп	
ґ┤
зп
-■пп	
ґ┬
зп
-∙пп	
ґ┴
зп
-√пп	
ґ┼
зп
-≈пп	
ґ▀
зп
-≤пп	
ґ▄
зп
-≥пп	
ґ█
зп
- пп	
ґ▌
зп
-⌡пп	
ґж
зп
-°пп	
ґв
зп
-²пп	
ґ▐
зп
-·пп	
ґ░
зп
-÷пп	
ґ▒
зп
-═пп	
ґ▓
зп
-║пп	
ґ⌠
зп
-╒пп	
ґ■
зп
-ёпп	
ґ∙
зп
-єпп	
ґ√
зп
-╔пп	
ґ≈
зп
-іпп	
ґ≤
зп
-їпп	
ґ≥
зп
-╗пп	
ґ 
зп
-╘пп	
ґ⌡
зп
-╙пп	
ґ°
зп
-╚пп	
ґ²
зп
-╛пп	
ґ·
зп
-ґпп	
ґ÷
зп
-╝пп	
ґ═
зп
-╞пп	
ґ║
зп
-╟пп	
ґ╒
зп
-╠пп	
ґ
зп
-Ы