📜

ᨶᨾᩮᩣ ᨲᩔ ᨽᨣᩅᨲᩮᩣ ᩋᩁᩉᨲᩮᩣ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩔ

ᨡᩩᨴ᩠ᨴᨠᨶᩥᨠᩣᨿᩮ

ᨩᩣᨲᨠᨸᩣᩊᩥ

(ᨴᩩᨲᩥᨿᩮᩣ ᨽᩣᨣᩮᩣ)

᪑᪗. ᨧᨲ᩠ᨲᩣᩃᩦᩈᨶᩥᨸᩣᨲᩮᩣ

᪕᪒᪑. ᨲᩮᩈᨠᩩᨱᨩᩣᨲᨠᩴ (᪑)

᪑.

‘‘ᩅᩮᩔᨶ᩠ᨲᩁᩴ ¶ ¶ ¶ ᨲᩴ ᨸᩩᨧ᩠ᨨᩣᨾᩥ, ᩈᨠᩩᨱ ᨽᨴ᩠ᨴᨾᨲ᩠ᨳᩩ ᨲᩮ;

ᩁᨩ᩠ᨩᩴ ᨠᩣᩁᩮᨲᩩᨠᩣᨾᩮᨶ, ᨠᩥᩴ ᩈᩩ ᨠᩥᨧ᩠ᨧᩴ ᨠᨲᩴ ᩅᩁᩴ’’.

᪒.

‘‘ᨧᩥᩁᩔᩴ ᩅᨲ ᨾᩴ ᨲᩣᨲᩮᩣ, ᨠᩴᩈᩮᩣ ᨻᩣᩁᩣᨱᩈᩥᨣ᩠ᨣᩉᩮᩣ;

ᨸᨾᨲ᩠ᨲᩮᩣ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩴ ᨾᩴ, ᨸᩥᨲᩣ ᨸᩩᨲ᩠ᨲᩴ ᩋᨧᩮᩣᨴᨿᩥ.

᪓.

‘‘ᨸᨮᨾᩮᨶᩮᩅ ᩅᩥᨲᨳᩴ, ᨠᩮᩣᨵᩴ ᩉᩣᩈᩴ ᨶᩥᩅᩣᩁᨿᩮ;

ᨲᨲᩮᩣ ᨠᩥᨧ᩠ᨧᩣᨶᩥ ᨠᩣᩁᩮᨿ᩠ᨿ, ᨲᩴ ᩅᨲᩴ ᩌᩉᩩ ᨡᨲ᩠ᨲᩥᨿ.

᪔.

‘‘ᨿᩴ ¶ ᨲ᩠ᩅᩴ ᨲᩣᨲ ᨲᨸᩮᩣᨠᨾ᩠ᨾᩴ [ᨲᨸᩮ ᨠᨾ᩠ᨾᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨸᩩᨻ᩠ᨻᩮ ᨠᨲᨾᩈᩴᩈᨿᩴ;

ᩁᨲ᩠ᨲᩮᩣ ᨴᩩᨭ᩠ᨮᩮᩣ ᨧ ᨿᩴ ᨠᨿᩥᩁᩣ, ᨶ ᨲᩴ ᨠᨿᩥᩁᩣ ᨲᨲᩮᩣ ᨸᩩᨶ [ᨸᩩᨶᩴ (ᨸᩦ.)].

᪕.

‘‘ᨡᨲ᩠ᨲᩥᨿᩔ ᨸᨾᨲ᩠ᨲᩔ, ᩁᨭ᩠ᨮᩈ᩠ᨾᩥᩴ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶ;

ᩈᨻ᩠ᨻᩮ ᨽᩮᩣᨣᩣ ᩅᩥᨶᩔᨶ᩠ᨲᩥ, ᩁᨬ᩠ᨬᩮᩣ ᨲᩴ ᩅᩩᨧ᩠ᨧᨲᩮ ᩋᨥᩴ.

᪖.

‘‘ᩈᩥᩁᩦ ᨲᩣᨲ ᩋᩃᨠ᩠ᨡᩦ ᨧ [ᩈᩥᩁᩦ ᨧ ᨲᩣᨲ ᩃᨠ᩠ᨡᩦ ᨧ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨸᩩᨧ᩠ᨨᩥᨲᩣ ᩑᨲᨴᨻᩕᩅᩩᩴ;

ᩏᨭ᩠ᨮᩣᨶ [ᩏᨭ᩠ᨮᩣᨶᩮ (ᩈ᩠ᨿᩣ.)] ᩅᩦᩁᩥᨿᩮ ᨸᩮᩣᩈᩮ, ᩁᨾᩣᩉᩴ ᩋᨶᩩᩈᩪᨿᨠᩮ.

᪗.

‘‘ᩏᩈᩪᨿᨠᩮ ¶ ᨴᩩᩉᨴᨿᩮ, ᨸᩩᩁᩥᩈᩮ ᨠᨾ᩠ᨾᨴᩩᩔᨠᩮ;

ᨠᩣᩃᨠᨱ᩠ᨱᩦ ᨾᩉᩣᩁᩣᨩ, ᩁᨾᨲᩥ [ᩁᨾᩣᨲᩥ (ᨠ.)] ᨧᨠ᩠ᨠᨽᨬ᩠ᨩᨶᩦ.

᪘.

‘‘ᩈᩮᩣ ᨲ᩠ᩅᩴ ᩈᨻ᩠ᨻᩮᩈᩩ ᩈᩩᩉᨴᨿᩮᩣ [ᩈᩮᩣ ᨲ᩠ᩅᩴ ᩈᨻ᩠ᨻᩮᩈᩴ ᩈᩩᩉᨴᨿᩮᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.), ᩈᩮᩣ ᨲ᩠ᩅᩴ ᩈᨻ᩠ᨻᩮ ᩈᩩᩉᨴᨿᩮᩣ (ᨠ.)], ᩈᨻ᩠ᨻᩮᩈᩴ ᩁᨠ᩠ᨡᩥᨲᩮᩣ ᨽᩅ;

ᩋᩃᨠ᩠ᨡᩥᩴ ᨶᩩᨴ ᨾᩉᩣᩁᩣᨩ, ᩃᨠ᩠ᨡ᩠ᨿᩣ ᨽᩅ ᨶᩥᩅᩮᩈᨶᩴ.

᪙.

‘‘ᩈ ¶ ᩃᨠ᩠ᨡᩦᨵᩥᨲᩥᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᨸᩩᩁᩥᩈᩮᩣ ᩉᩥ ᨾᩉᨣ᩠ᨣᨲᩮᩣ;

ᩋᨾᩥᨲ᩠ᨲᩣᨶᩴ ᨠᩣᩈᩥᨸᨲᩥ, ᨾᩪᩃᩴ ᩋᨣ᩠ᨣᨬ᩠ᨧ ᨨᩥᨶ᩠ᨴᨲᩥ.

᪑᪐.

‘‘ᩈᨠ᩠ᨠᩮᩣᨸᩥ ᩉᩥ ᨽᩪᨲᨸᨲᩥ, ᩏᨭ᩠ᨮᩣᨶᩮ ᨶᨸ᩠ᨸᨾᨩ᩠ᨩᨲᩥ;

ᩈ ᨠᩃ᩠ᨿᩣᨱᩮ ᨵᩥᨲᩥᩴ ᨠᨲ᩠ᩅᩣ, ᩏᨭ᩠ᨮᩣᨶᩮ ᨠᩩᩁᩩᨲᩮ ᨾᨶᩮᩣ.

᪑᪑.

‘‘ᨣᨶ᩠ᨵᨻ᩠ᨻᩣ ᨸᩥᨲᩁᩮᩣ ᨴᩮᩅᩣ, ᩈᩣᨩᩦᩅᩣ [ᩈᨬ᩠ᨩᩦᩅᩣ (ᨸᩦ.)] ᩉᩮᩣᨶ᩠ᨲᩥ ᨲᩣᨴᩥᨶᩮᩣ;

ᩏᨭ᩠ᨮᩣᩉᨲᩮᩣ [ᩏᨭ᩠ᨮᩉᨲᩮᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩋᨸ᩠ᨸᨾᨩ᩠ᨩᨲᩮᩣ [ᨾᨸ᩠ᨸᨾᨩ᩠ᨩᨲᩮᩣ (ᨠ.)], ᩋᨶᩩᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᨴᩮᩅᨲᩣ.

᪑᪒.

‘‘ᩈᩮᩣ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ ᩋᨠ᩠ᨠᩩᨴ᩠ᨵᩮᩣ [ᩋᨠ᩠ᨠᩩᨭ᩠ᨮᩮᩣ (ᨸᩦ.)], ᨲᩣᨲ ᨠᩥᨧ᩠ᨧᩣᨶᩥ ᨠᩣᩁᨿ;

ᩅᩣᨿᨾᩔᩩ ᨧ ᨠᩥᨧ᩠ᨧᩮᩈᩩ, ᨶᩣᩃᩈᩮᩣ ᩅᩥᨶ᩠ᨴᨲᩮ ᩈᩩᨡᩴ.

᪑᪓.

‘‘ᨲᨲ᩠ᨳᩮᩅ ᨲᩮ ᩅᨲ᩠ᨲᨸᨴᩣ, ᩑᩈᩣᩅ [ᩑᩈᩣ ᨧ (ᨸᩦ.)] ᩋᨶᩩᩈᩣᩈᨶᩦ;

ᩋᩃᩴ ᨾᩥᨲ᩠ᨲᩮ ᩈᩩᨡᩣᨸᩮᨲᩩᩴ, ᩋᨾᩥᨲ᩠ᨲᩣᨶᩴ ᨴᩩᨡᩣᨿ [ᨴᩩᨠ᩠ᨡᩣᨿ (ᨸᩦ.)] ᨧ’’.

᪑᪔.

‘‘ᩈᨠ᩠ᨡᩥᩈᩥ ᨲ᩠ᩅᩴ [ᩈᨠ᩠ᨡᩦ ᨲᩩᩅᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨠᩩᨱ᩠ᨯᩃᩥᨶᩥ, ᨾᨬ᩠ᨬᩈᩥ ᨡᨲ᩠ᨲᨻᨶ᩠ᨵᩩᨶᩥ [ᨡᨲ᩠ᨲᩥᨿᨻᨶ᩠ᨵᩩᨶᩦ (ᨸᩦ.)];

ᩁᨩ᩠ᨩᩴ ᨠᩣᩁᩮᨲᩩᨠᩣᨾᩮᨶ, ᨠᩥᩴ ᩈᩩ ᨠᩥᨧ᩠ᨧᩴ ᨠᨲᩴ ᩅᩁᩴ’’.

᪑᪕.

‘‘ᨴ᩠ᩅᩮᩅ ᨲᩣᨲ ᨸᨴᨠᩣᨶᩥ, ᨿᨲ᩠ᨳ [ᨿᩮᩈᩩ (ᨸᩦ.)] ᩈᨻ᩠ᨻᩴ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩴ;

ᩋᩃᨴ᩠ᨵᩔ ᨧ ᨿᩮᩣ ᩃᩣᨽᩮᩣ, ᩃᨴ᩠ᨵᩔ ᨧᩣᨶᩩᩁᨠ᩠ᨡᨱᩣ.

᪑᪖.

‘‘ᩋᨾᨧ᩠ᨧᩮ ᨲᩣᨲ ᨩᩣᨶᩣᩉᩥ, ᨵᩦᩁᩮ ᩋᨲ᩠ᨳᩔ ᨠᩮᩣᩅᩥᨴᩮ;

ᩋᨶᨠ᩠ᨡᩣ ᨠᩥᨲᩅᩮ ᨲᩣᨲ, ᩋᩈᩮᩣᨱ᩠ᨯᩮ ᩋᩅᩥᨶᩣᩈᨠᩮ.

᪑᪗.

‘‘ᨿᩮᩣ ᨧ ᨲᩴ ᨲᩣᨲ ᩁᨠ᩠ᨡᩮᨿ᩠ᨿ, ᨵᨶᩴ ᨿᨬ᩠ᨧᩮᩅ ᨲᩮ ᩈᩥᨿᩣ;

ᩈᩪᨲᩮᩣᩅ ᩁᨳᩴ ᩈᨦ᩠ᨣᨱ᩠ᩉᩮ, ᩈᩮᩣ ᨲᩮ ᨠᩥᨧ᩠ᨧᩣᨶᩥ ᨠᩣᩁᨿᩮ.

᪑᪘.

‘‘ᩈᩩᩈᨦ᩠ᨣᩉᩥᨲᨶ᩠ᨲᨩᨶᩮᩣ, ᩈᨿᩴ ᩅᩥᨲ᩠ᨲᩴ ᩋᩅᩮᨠ᩠ᨡᩥᨿ;

ᨶᩥᨵᩥᨬ᩠ᨧ ᩍᨱᨴᩣᨶᨬ᩠ᨧ, ᨶ ᨠᩁᩮ ᨸᩁᨸᨲ᩠ᨲᩥᨿᩣ.

᪑᪙.

‘‘ᩈᨿᩴ ¶ ¶ ᩌᨿᩴ ¶ ᩅᨿᩴ [ᩌᨿᩅᨿᩴ (ᨸᩦ.)] ᨩᨬ᩠ᨬᩣ, ᩈᨿᩴ ᨩᨬ᩠ᨬᩣ ᨠᨲᩣᨠᨲᩴ;

ᨶᩥᨣ᩠ᨣᨱ᩠ᩉᩮ ᨶᩥᨣ᩠ᨣᩉᩣᩁᩉᩴ, ᨸᨣ᩠ᨣᨱ᩠ᩉᩮ ᨸᨣ᩠ᨣᩉᩣᩁᩉᩴ.

᪒᪐.

‘‘ᩈᨿᩴ ᨩᩣᨶᨸᨴᩴ ᩋᨲ᩠ᨳᩴ, ᩋᨶᩩᩈᩣᩈ ᩁᨳᩮᩈᨽ;

ᨾᩣ ᨲᩮ ᩋᨵᨾ᩠ᨾᩥᨠᩣ ᨿᩩᨲ᩠ᨲᩣ, ᨵᨶᩴ ᩁᨭ᩠ᨮᨬ᩠ᨧ ᨶᩣᩈᨿᩩᩴ.

᪒᪑.

‘‘ᨾᩣ ᨧ ᩅᩮᨣᩮᨶ ᨠᩥᨧ᩠ᨧᩣᨶᩥ, ᨠᩁᩮᩣᩈᩥ [ᨠᩣᩁᩮᩈᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨠᩣᩁᨿᩮᩈᩥ ᩅᩣ;

ᩅᩮᨣᩈᩣ ᩉᩥ ᨠᨲᩴ ᨠᨾ᩠ᨾᩴ, ᨾᨶ᩠ᨴᩮᩣ ᨸᨧ᩠ᨨᩣᨶᩩᨲᨸ᩠ᨸᨲᩥ.

᪒᪒.

‘‘ᨾᩣ ᨲᩮ ᩋᨵᩥᩈᩁᩮ ᨾᩩᨬ᩠ᨧ, ᩈᩩᨻᩣᩊ᩠ᩉᨾᨵᩥᨠᩮᩣᨵᩥᨲᩴ [ᨠᩮᩣᨸᩥᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

ᨠᩮᩣᨵᩈᩣ ᩉᩥ ᨻᩉᩪ ᨹᩦᨲᩣ, ᨠᩩᩃᩣ ᩋᨠᩩᩃᨲᩴ ᨣᨲᩣ.

᪒᪓.

‘‘ᨾᩣ ᨲᩣᨲ ᩍᩔᩁᩮᩣᨾ᩠ᩉᩦᨲᩥ, ᩋᨶᨲ᩠ᨳᩣᨿ ᨸᨲᩣᩁᨿᩥ;

ᩍᨲ᩠ᨳᩦᨶᩴ ᨸᩩᩁᩥᩈᩣᨶᨬ᩠ᨧ, ᨾᩣ ᨲᩮ ᩌᩈᩥ ᨴᩩᨡᩩᨴᩕᨿᩮᩣ.

᪒᪔.

‘‘ᩋᨸᩮᨲᩃᩮᩣᨾᩉᩴᩈᩔ, ᩁᨬ᩠ᨬᩮᩣ ᨠᩣᨾᩣᨶᩩᩈᩣᩁᩥᨶᩮᩣ;

ᩈᨻ᩠ᨻᩮ ᨽᩮᩣᨣᩣ ᩅᩥᨶᩔᨶ᩠ᨲᩥ, ᩁᨬ᩠ᨬᩮᩣ ᨲᩴ ᩅᩩᨧ᩠ᨧᨲᩮ ᩋᨥᩴ.

᪒᪕.

‘‘ᨲᨲ᩠ᨳᩮᩅ ᨲᩮ ᩅᨲ᩠ᨲᨸᨴᩣ, ᩑᩈᩣᩅ ᩋᨶᩩᩈᩣᩈᨶᩦ;

ᨴᨠ᩠ᨡᩔᩩᨴᩣᨶᩥ ᨸᩩᨬ᩠ᨬᨠᩁᩮᩣ, ᩋᩈᩮᩣᨱ᩠ᨯᩮᩣ ᩋᩅᩥᨶᩣᩈᨠᩮᩣ;

ᩈᩦᩃᩅᩣᩔᩩ [ᩈᩦᩃᩅᩣᩔ (ᨭᩦᨠᩣ)] ᨾᩉᩣᩁᩣᨩ, ᨴᩩᩔᩦᩃᩮᩣ ᩅᩥᨶᩥᨸᩣᨲᩥᨠᩮᩣ’’ [ᩅᩥᨶᩥᨸᩣᨲᨠᩮᩣ (ᨸᩦ.)].

᪒᪖.

‘‘ᩋᨸᩩᨧ᩠ᨨᩥᨾ᩠ᩉ ᨠᩮᩣᩈᩥᨿᨣᩮᩣᨲ᩠ᨲᩴ [ᩋᨸᩩᨧ᩠ᨨᩥᨾ᩠ᩉᩣ ᨠᩮᩣᩈᩥᨿᨣᩮᩣᨲ᩠ᨲᩴ (ᩈ᩠ᨿᩣ.), ᩋᨸᩩᨧ᩠ᨨᨾ᩠ᩉᩣᨸᩥ ᨠᩮᩣᩈᩥᨠᩴ (ᨸᩦ.)], ᨠᩩᨱ᩠ᨯᩃᩥᨶᩥᩴ ᨲᨳᩮᩅ ᨧ;

ᨲ᩠ᩅᩴ ᨴᩣᨶᩥ ᩅᨴᩮᩉᩥ ᨩᨾ᩠ᨻᩩᨠ [ᨩᨾ᩠ᨻᩩᨠ ᨲ᩠ᩅᩴ ᨴᩣᨶᩥ ᩅᨴᩮᩉᩥ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨻᩃᩣᨶᩴ ᨻᩃᨾᩩᨲ᩠ᨲᨾᩴ’’.

᪒᪗.

‘‘ᨻᩃᩴ ᨸᨬ᩠ᨧᩅᩥᨵᩴ ᩃᩮᩣᨠᩮ, ᨸᩩᩁᩥᩈᩈ᩠ᨾᩥᩴ ᨾᩉᨣ᩠ᨣᨲᩮ;

ᨲᨲ᩠ᨳ ᨻᩣᩉᩩᨻᩃᩴ ᨶᩣᨾ, ᨧᩁᩥᨾᩴ ᩅᩩᨧ᩠ᨧᨲᩮ ᨻᩃᩴ.

᪒᪘.

‘‘ᨽᩮᩣᨣᨻᩃᨬ᩠ᨧ ᨴᩦᨥᩣᩅᩩ, ᨴᩩᨲᩥᨿᩴ ᩅᩩᨧ᩠ᨧᨲᩮ ᨻᩃᩴ;

ᩋᨾᨧ᩠ᨧᨻᩃᨬ᩠ᨧ ¶ ᨴᩦᨥᩣᩅᩩ, ᨲᨲᩥᨿᩴ ᩅᩩᨧ᩠ᨧᨲᩮ ᨻᩃᩴ.

᪒᪙.

‘‘ᩋᨽᩥᨩᨧ᩠ᨧᨻᩃᩴ ᨧᩮᩅ, ᨲᩴ ᨧᨲᩩᨲ᩠ᨳᩴ ᩋᩈᩴᩈᨿᩴ;

ᨿᩣᨶᩥ ᨧᩮᨲᩣᨶᩥ ᩈᨻ᩠ᨻᩣᨶᩥ, ᩋᨵᩥᨣᨱ᩠ᩉᩣᨲᩥ ᨸᨱ᩠ᨯᩥᨲᩮᩣ.

᪓᪐.

‘‘ᨲᩴ ᨻᩃᩣᨶᩴ ᨻᩃᩴ ᩈᩮᨭ᩠ᨮᩴ, ᩋᨣ᩠ᨣᩴ ᨸᨬ᩠ᨬᩣᨻᩴ ᨻᩃᩴ [ᩅᩁᩴ (ᩈᩦ.)];

ᨸᨬ᩠ᨬᩣᨻᩃᩮᨶᩩᨸᨲ᩠ᨳᨴ᩠ᨵᩮᩣ, ᩋᨲ᩠ᨳᩴ ᩅᩥᨶ᩠ᨴᨲᩥ ᨸᨱ᩠ᨯᩥᨲᩮᩣ.

᪓᪑.

‘‘ᩋᨸᩥ ¶ ᨧᩮ ᩃᨽᨲᩥ ᨾᨶ᩠ᨴᩮᩣ, ᨹᩦᨲᩴ ᨵᩁᨱᩥᨾᩩᨲ᩠ᨲᨾᩴ;

ᩋᨠᩣᨾᩔ ᨸᩈᨿ᩠ᩉᩴ ᩅᩣ, ᩋᨬ᩠ᨬᩮᩣ ᨲᩴ ᨸᨭᩥᨸᨩ᩠ᨩᨲᩥ.

᪓᪒.

‘‘ᩋᨽᩥᨩᩣᨲᩮᩣᨸᩥ ᨧᩮ ᩉᩮᩣᨲᩥ, ᩁᨩ᩠ᨩᩴ ᩃᨴ᩠ᨵᩣᨶ ᨡᨲ᩠ᨲᩥᨿᩮᩣ;

ᨴᩩᨸ᩠ᨸᨬ᩠ᨬᩮᩣ ᩉᩥ ᨠᩣᩈᩥᨸᨲᩥ, ᩈᨻ᩠ᨻᩮᨶᨸᩥ ᨶ ᨩᩦᩅᨲᩥ.

᪓᪓.

‘‘ᨸᨬ᩠ᨬᩣᩅ ¶ ᩈᩩᨲᩴ ᩅᩥᨶᩥᨧ᩠ᨨᩥᨶᩦ [ᨸᨬ᩠ᨬᩣ ᩈᩩᨲᩅᩥᨶᩥᨧ᩠ᨨᩥᨶᩦ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨸᨬ᩠ᨬᩣ ᨠᩥᨲ᩠ᨲᩥ ᩈᩥᩃᩮᩣᨠᩅᨯ᩠ᨰᨶᩦ [ᩅᨴ᩠ᨵᨶᩦ (ᨸᩦ.)];

ᨸᨬ᩠ᨬᩣᩈᩉᩥᨲᩮᩣ ᨶᩁᩮᩣ ᩍᨵ, ᩋᨸᩥ ᨴᩩᨠ᩠ᨡᩮ ᩈᩩᨡᩣᨶᩥ ᩅᩥᨶ᩠ᨴᨲᩥ.

᪓᪔.

‘‘ᨸᨬ᩠ᨬᨬ᩠ᨧ ᨡᩮᩣ ᩋᩈᩩᩔᩪᩈᩴ, ᨶ ᨠᩮᩣᨧᩥ ᩋᨵᩥᨣᨧ᩠ᨨᨲᩥ;

ᨻᩉᩩᩔᩩᨲᩴ ᩋᨶᩣᨣᨾ᩠ᨾ, ᨵᨾ᩠ᨾᨭ᩠ᨮᩴ ᩋᩅᩥᨶᩥᨻ᩠ᨽᩩᨩᩴ.

᪓᪕.

‘‘ᨿᩮᩣ ᨧ ᨵᨾ᩠ᨾᩅᩥᨽᨦ᩠ᨣᨬ᩠ᨬᩪ [ᨿᩮᩣ ᨵᨾ᩠ᨾᨬ᩠ᨧ ᩅᩥᨽᩣᨣᨬ᩠ᨬᩪ (ᨸᩦ.)], ᨠᩣᩃᩩᨭ᩠ᨮᩣᨿᩦ ᨾᨲᨶ᩠ᨴᩥᨲᩮᩣ;

ᩋᨶᩩᨭ᩠ᨮᩉᨲᩥ ᨠᩣᩃᩮᨶ, ᨠᨾ᩠ᨾᨹᩃᩴ ᨲᩔ ᩍᨩ᩠ᨫᨲᩥ [ᨠᨾ᩠ᨾᨹᩃᩴ ᨲᩔᩥᨩ᩠ᨫᨲᩥ, ᨹᩃᩴ ᨲᩔ ᩈᨾᩥᨩ᩠ᨫᨲᩥ (ᨠ.)].

᪓᪖.

‘‘ᩋᨶᩣᨿᨲᨶ [ᨶᩣ’ᨶᩣᨿᨲᨶ (ᨸᩦ.)] ᩈᩦᩃᩔ, ᩋᨶᩣᨿᨲᨶ [ᨶᩣ’ᨶᩣᨿᨲᨶ (ᨸᩦ.)] ᩈᩮᩅᩥᨶᩮᩣ;

ᨶ ᨶᩥᨻ᩠ᨻᩥᨶ᩠ᨴᩥᨿᨠᩣᩁᩥᩔ, ᩈᨾ᩠ᨾᨴᨲ᩠ᨳᩮᩣ ᩅᩥᨸᨧ᩠ᨧᨲᩥ.

᪓᪗.

‘‘ᩋᨩ᩠ᨫᨲ᩠ᨲᨬ᩠ᨧ ᨸᨿᩩᨲ᩠ᨲᩔ, ᨲᨳᩣᨿᨲᨶᩈᩮᩅᩥᨶᩮᩣ;

ᩋᨶᩥᨻ᩠ᨻᩥᨶ᩠ᨴᩥᨿᨠᩣᩁᩥᩔ, ᩈᨾ᩠ᨾᨴᨲ᩠ᨳᩮᩣ ᩅᩥᨸᨧ᩠ᨧᨲᩥ.

᪓᪘.

‘‘ᨿᩮᩣᨣᨸ᩠ᨸᨿᩮᩣᨣᩈᨦ᩠ᨡᩣᨲᩴ, ᩈᨾ᩠ᨽᨲᩔᩣᨶᩩᩁᨠ᩠ᨡᨱᩴ;

ᨲᩣᨶᩥ ¶ ᨲ᩠ᩅᩴ ᨲᩣᨲ ᩈᩮᩅᩔᩩ, ᨾᩣ ᩋᨠᨾ᩠ᨾᩣᨿ ᩁᨶ᩠ᨵᨿᩥ;

ᩋᨠᨾ᩠ᨾᩩᨶᩣ ᩉᩥ ᨴᩩᨾ᩠ᨾᩮᨵᩮᩣ, ᨶᩊᩣᨣᩣᩁᩴᩅ ᩈᩦᨴᨲᩥ’’.

᪓᪙.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨾᩣᨲᩣᨸᩥᨲᩪᩈᩩ ᨡᨲ᩠ᨲᩥᨿ;

ᩍᨵ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩁᩣᨩ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ.

᪔᪐.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨸᩩᨲ᩠ᨲᨴᩣᩁᩮᩈᩩ ᨡᨲ᩠ᨲᩥᨿ;

ᩍᨵ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩁᩣᨩ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ.

᪔᪑.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨾᩥᨲ᩠ᨲᩣᨾᨧ᩠ᨧᩮᩈᩩ ᨡᨲ᩠ᨲᩥᨿ;

ᩍᨵ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩁᩣᨩ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ.

᪔᪒.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᩅᩣᩉᨶᩮᩈᩩ ᨻᩃᩮᩈᩩ ᨧ;

ᩍᨵ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩁᩣᨩ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ.

᪔᪓.

‘‘ᨵᨾ᩠ᨾᩴ ¶ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨣᩣᨾᩮᩈᩩ ᨶᩥᨣᨾᩮᩈᩩ ᨧ…ᨸᩮ….

᪔᪔.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᩁᨭ᩠ᨮᩮᩈᩩ [ᩁᨭ᩠ᨮᩮ (ᨸᩦ.)] ᨩᨶᨸᨴᩮᩈᩩ ᨧ…ᨸᩮ….

᪔᪕.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᩈᨾᨱ [ᩈᨾᨱᩮ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ᨧ…ᨸᩮ….

᪔᪖.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨾᩥᨣᨸᨠ᩠ᨡᩦᩈᩩ ᨡᨲ᩠ᨲᩥᨿ;

ᩍᨵ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩁᩣᨩ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ.

᪔᪗.

‘‘ᨵᨾ᩠ᨾᩴ ¶ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨵᨾ᩠ᨾᩮᩣ ᨧᩥᨱ᩠ᨱᩮᩣ ᩈᩩᨡᩣᩅᩉᩮᩣ [ᨵᨾ᩠ᨾᩮᩣ ᩈᩩᨧᩥᨱ᩠ᨱᩮᩣ ᩈᩩᨡᨾᩣᩅᩉᨲᩥ (ᨠ.)];

ᩍᨵ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩁᩣᨩ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ.

᪔᪘.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᩈᩍᨶ᩠ᨴᩣ [ᩍᨶ᩠ᨴᩮᩣ (ᨸᩦ.), ᩈᩥᨶ᩠ᨴᩣ (ᨠ.)] ᨴᩮᩅᩣ ᩈᨻᩕᩉ᩠ᨾᨠᩣ;

ᩈᩩᨧᩥᨱ᩠ᨱᩮᨶ ᨴᩥᩅᩴ ᨸᨲ᩠ᨲᩣ, ᨾᩣ ᨵᨾ᩠ᨾᩴ ᩁᩣᨩ ᨸᩣᨾᨴᩮᩣ [ᨸᨾᩣᨴᩮᩣ (ᨸᩦ. ᨠ.)].

᪔᪙.

‘‘ᨲᨲ᩠ᨳᩮᩅ ¶ ᨲᩮ [ᩅᩮᨲᩮ (ᨸᩦ.)] ᩅᨲ᩠ᨲᨸᨴᩣ, ᩑᩈᩣᩅ [ᩑᩈᩣ ᨧ (ᨸᩦ.)] ᩋᨶᩩᩈᩣᩈᨶᩦ;

ᩈᨸ᩠ᨸᨬ᩠ᨬᩈᩮᩅᩦ ᨠᩃ᩠ᨿᩣᨱᩦ, ᩈᨾᨲ᩠ᨲᩴ ᩈᩣᨾ [ᩈᩣᨾᩴ (ᨠ.)] ᨲᩴ ᩅᩥᨴᩪ’’ᨲᩥ.

ᨲᩮᩈᨠᩩᨱᨩᩣᨲᨠᩴ ᨸᨮᨾᩴ.

᪕᪒᪒. ᩈᩁᨽᨦ᩠ᨣᨩᩣᨲᨠᩴ (᪒)

᪕᪐.

‘‘ᩋᩃᨦ᩠ᨠᨲᩣ ᨠᩩᨱ᩠ᨯᩃᩥᨶᩮᩣ ᩈᩩᩅᨲ᩠ᨳᩣ, ᩅᩮᩊᩩᩁᩥᨿᨾᩩᨲ᩠ᨲᩣᨳᩁᩩᨡᨣ᩠ᨣᨻᨶ᩠ᨵᩣ [ᨻᨴ᩠ᨵᩣ (ᨸᩦ.)];

ᩁᨳᩮᩈᨽᩣ ᨲᩥᨭ᩠ᨮᨳ ᨠᩮ ᨶᩩ ᨲᩩᨾ᩠ᩉᩮ, ᨠᨳᩴ ᩅᩮᩣ ᨩᩣᨶᨶ᩠ᨲᩥ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ’’.

᪕᪑.

‘‘ᩋᩉᨾᨭ᩠ᨮᨠᩮᩣ ᨽᩦᨾᩁᨳᩮᩣ ᨸᨶᩣᨿᩴ, ᨠᩣᩃᩥᨦ᩠ᨣᩁᩣᨩᩣ ᨸᨶ ᩏᨣ᩠ᨣᨲᩮᩣᨿᩴ [ᩏᨣ᩠ᨣᨲᩮᩣ ᩋᨿᩴ (ᨸᩦ.), ᩏᨣ᩠ᨣᨲᩣᨿᩴ (ᨠ.)];

ᩈᩩᩈᨬ᩠ᨬᨲᩣᨶᩴ ᩍᩈᩦᨶᩴ [ᩈᩩᩈᨬ᩠ᨬᨲᩣᨶᩥᩈᩥᨶᩴ (ᨸᩦ.)] ᨴᩔᨶᩣᨿ, ᩍᨵᩣᨣᨲᩣ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨿᩮᨾ᩠ᩉ ᨸᨬ᩠ᩉᩮ’’.

᪕᪒.

‘‘ᩅᩮᩉᩣᨿᩈᩴ ¶ ᨲᩥᨭ᩠ᨮᩈᩥ [ᨲᩥᨭ᩠ᨮᨲᩥ (ᨸᩦ.)] ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ, ᨸᨳᨴ᩠ᨵᩩᨶᩮᩣ ᨸᨶ᩠ᨶᩁᩈᩮᩅ ᨧᨶ᩠ᨴᩮᩣ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨿᨠ᩠ᨡ ᨾᩉᩣᨶᩩᨽᩣᩅ, ᨠᨳᩴ ᨲᩴ ᨩᩣᨶᨶ᩠ᨲᩥ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ’’.

᪕᪓.

‘‘ᨿᨾᩣᩉᩩ ᨴᩮᩅᩮᩈᩩ ᩈᩩᨩᨾ᩠ᨸᨲᩦᨲᩥ, ᨾᨥᩅᩣᨲᩥ ¶ ᨲᩴ ᩌᩉᩩ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ;

ᩈ ᨴᩮᩅᩁᩣᨩᩣ ᩍᨴᨾᨩ᩠ᨩ ᨸᨲ᩠ᨲᩮᩣ, ᩈᩩᩈᨬ᩠ᨬᨲᩣᨶᩴ ᩍᩈᩦᨶᩴ ᨴᩔᨶᩣᨿ’’.

᪕᪔.

‘‘ᨴᩪᩁᩮ ᩈᩩᨲᩣ ᨶᩮᩣ ᩍᩈᨿᩮᩣ ᩈᨾᩣᨣᨲᩣ, ᨾᩉᩥᨴ᩠ᨵᩥᨠᩣ ᩍᨴ᩠ᨵᩥᨣᩩᨱᩪᨸᨸᨶ᩠ᨶᩣ;

ᩅᨶ᩠ᨴᩣᨾᩥ ᨲᩮ ᩋᨿᩥᩁᩮ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᨿᩮ ᨩᩦᩅᩃᩮᩣᨠᩮᨲ᩠ᨳ ᨾᨶᩩᩔᩈᩮᨭ᩠ᨮᩣ’’.

᪕᪕.

ᨣᨶ᩠ᨵᩮᩣ ᩍᩈᩦᨶᩴ ᨧᩥᩁᨴᩥᨠ᩠ᨡᩥᨲᩣᨶᩴ [ᨴᨠ᩠ᨡᩥᨲᩣᨶᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨠᩣᨿᩣ ᨧᩩᨲᩮᩣ ᨣᨧ᩠ᨨᨲᩥ ᨾᩣᩃᩩᨲᩮᨶ;

ᩍᨲᩮᩣ ᨸᨭᩥᨠ᩠ᨠᨾ᩠ᨾ ᩈᩉᩔᨶᩮᨲ᩠ᨲ, ᨣᨶ᩠ᨵᩮᩣ ᩍᩈᩦᨶᩴ ᩋᩈᩩᨧᩥ ᨴᩮᩅᩁᩣᨩ’’.

᪕᪖.

‘‘ᨣᨶ᩠ᨵᩮᩣ ᩍᩈᩦᨶᩴ ᨧᩥᩁᨴᩥᨠ᩠ᨡᩥᨲᩣᨶᩴ, ᨠᩣᨿᩣ ᨧᩩᨲᩮᩣ ᨣᨧ᩠ᨨᨲᩩ ᨾᩣᩃᩩᨲᩮᨶ;

ᩅᩥᨧᩥᨲᩕᨸᩩᨸ᩠ᨹᩴ ᩈᩩᩁᨽᩥᩴᩅ ᨾᩣᩃᩴ, ᨣᨶ᩠ᨵᨬ᩠ᨧ ᩑᨲᩴ ᨸᩣᨭᩥᨠᨦ᩠ᨡᩣᨾ ᨽᨶ᩠ᨲᩮ;

ᨶ ᩉᩮᨲ᩠ᨳ ᨴᩮᩅᩣ ᨸᨭᩥᨠ᩠ᨠᩪᩃᩈᨬ᩠ᨬᩥᨶᩮᩣ’’.

᪕᪗.

‘‘ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ ᨽᩪᨲᨸᨲᩦ ᨿᩈᩔᩦ, ᨴᩮᩅᩣᨶᨾᩥᨶ᩠ᨴᩮᩣ ᩈᨠ᩠ᨠᩮᩣ [ᩍᨴᩴ ᨸᨴᩴ ᨶᨲ᩠ᨳᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ)] ᨾᨥᩅᩣ ᩈᩩᨩᨾ᩠ᨸᨲᩥ;

ᩈ ᨴᩮᩅᩁᩣᨩᩣ ᩋᩈᩩᩁᨣᨱᨸ᩠ᨸᨾᨴ᩠ᨴᨶᩮᩣ, ᩒᨠᩣᩈᨾᩣᨠᨦ᩠ᨡᨲᩥ ᨸᨬ᩠ᩉ ᨸᩩᨧ᩠ᨨᩥᨲᩩᩴ.

᪕᪘.

‘‘ᨠᩮᩣ ¶ ᨶᩮᩅᩥᨾᩮᩈᩴ ᩍᨵ ᨸᨱ᩠ᨯᩥᨲᩣᨶᩴ, ᨸᨬ᩠ᩉᩮ ᨸᩩᨭ᩠ᨮᩮᩣ ᨶᩥᨸᩩᨱᩮ ᨻ᩠ᨿᩣᨠᩁᩥᩔᨲᩥ;

ᨲᩥᨱ᩠ᨱᨬ᩠ᨧ ᩁᨬ᩠ᨬᩴ ᨾᨶᩩᨩᩣᨵᩥᨸᩣᨶᩴ, ᨴᩮᩅᩣᨶᨾᩥᨶ᩠ᨴᩔ ᨧ ᩅᩣᩈᩅᩔ’’.

᪕᪙.

‘‘ᩋᨿᩴ ¶ ᩍᩈᩥ [ᩍᩈᩦ (ᩈᩦ. ᨸᩦ.)] ᩈᩁᨽᨦ᩠ᨣᩮᩣ ᨲᨸᩔᩦ [ᨿᩈᩔᩦ (ᩈᩦ.)], ᨿᨲᩮᩣ ᨩᩣᨲᩮᩣ ᩅᩥᩁᨲᩮᩣ ᨾᩮᨳᩩᨶᩈ᩠ᨾᩣ;

ᩌᨧᩮᩁᨸᩩᨲ᩠ᨲᩮᩣ [ᩌᨧᩁᩥᨿᨸᩩᨲ᩠ᨲᩮᩣ (ᨸᩦ. ᨠ.)] ᩈᩩᩅᩥᨶᩦᨲᩁᩪᨸᩮᩣ, ᩈᩮᩣ ᨶᩮᩈᩴ ᨸᨬ᩠ᩉᩣᨶᩥ ᩅᩥᨿᩣᨠᩁᩥᩔᨲᩥ’’.

᪖᪐.

‘‘ᨠᩮᩣᨱ᩠ᨯᨬ᩠ᨬ ᨸᨬ᩠ᩉᩣᨶᩥ ᩅᩥᨿᩣᨠᩁᩮᩣᩉᩥ, ᨿᩣᨧᨶ᩠ᨲᩥ ᨲᩴ ᩍᩈᨿᩮᩣ ᩈᩣᨵᩩᩁᩪᨸᩣ;

ᨠᩮᩣᨱ᩠ᨯᨬ᩠ᨬ ᩑᩈᩮᩣ ᨾᨶᩩᨩᩮᩈᩩ ᨵᨾ᩠ᨾᩮᩣ, ᨿᩴ ᩅᩩᨴ᩠ᨵ [ᩅᨴ᩠ᨵ (ᨸᩦ.), ᨻᩩᨴ᩠ᨵ (ᨠ.)] ᨾᩣᨣᨧ᩠ᨨᨲᩥ ᩑᩈ ᨽᩣᩁᩮᩣ’’.

᪖᪑.

‘‘ᨠᨲᩣᩅᨠᩣᩈᩣ ¶ ᨸᩩᨧ᩠ᨨᨶ᩠ᨲᩩ ᨽᩮᩣᨶ᩠ᨲᩮᩣ, ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨸᨬ᩠ᩉᩴ ᨾᨶᩈᩣᨽᩥᨸᨲ᩠ᨳᩥᨲᩴ;

ᩋᩉᨬ᩠ᩉᩥ ᨲᩴ ᨲᩴ ᩅᩮᩣ ᩅᩥᨿᩣᨠᩁᩥᩔᩴ, ᨬᨲ᩠ᩅᩣ ᩈᨿᩴ ᩃᩮᩣᨠᨾᩥᨾᩴ ᨸᩁᨬ᩠ᨧ’’.

᪖᪒.

‘‘ᨲᨲᩮᩣ ᨧ ᨾᨥᩅᩣ ᩈᨠ᩠ᨠᩮᩣ, ᩋᨲ᩠ᨳᨴᩔᩦ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ;

ᩋᨸᩩᨧ᩠ᨨᩥ ᨸᨮᨾᩴ ᨸᨬ᩠ᩉᩴ, ᨿᨬ᩠ᨧᩣᩈᩥ ᩋᨽᩥᨸᨲ᩠ᨳᩥᨲᩴ’’.

᪖᪓.

‘‘ᨠᩥᩴ ᩈᩪ ᩅᨵᩥᨲ᩠ᩅᩣ ᨶ ᨠᨴᩣᨧᩥ ᩈᩮᩣᨧᨲᩥ, ᨠᩥᩔᨸ᩠ᨸᩉᩣᨶᩴ ᩍᩈᨿᩮᩣ ᩅᨱ᩠ᨱᨿᨶ᩠ᨲᩥ;

ᨠᩔᩦᨵ ¶ ᩅᩩᨲ᩠ᨲᩴ ᨹᩁᩩᩈᩴ ᨡᨾᩮᨳ, ᩋᨠ᩠ᨡᩣᩉᩥ ᨾᩮ ᨠᩮᩣᨱ᩠ᨯᨬ᩠ᨬ ᩑᨲᨾᨲ᩠ᨳᩴ’’.

᪖᪔.

‘‘ᨠᩮᩣᨵᩴ ᩅᨵᩥᨲ᩠ᩅᩣ ᨶ ᨠᨴᩣᨧᩥ ᩈᩮᩣᨧᨲᩥ, ᨾᨠ᩠ᨡᨸ᩠ᨸᩉᩣᨶᩴ ᩍᩈᨿᩮᩣ ᩅᨱ᩠ᨱᨿᨶ᩠ᨲᩥ;

ᩈᨻ᩠ᨻᩮᩈᩴ ᩅᩩᨲ᩠ᨲᩴ ᨹᩁᩩᩈᩴ ᨡᨾᩮᨳ, ᩑᨲᩴ ᨡᨶ᩠ᨲᩥᩴ ᩏᨲ᩠ᨲᨾᨾᩣᩉᩩ ᩈᨶ᩠ᨲᩮᩣ’’.

᪖᪕.

‘‘ᩈᨠ᩠ᨠᩣ ᩏᨽᩥᨶ᩠ᨶᩴ [ᩉᩥ ᨴ᩠ᩅᩥᨶ᩠ᨶᩴ (ᨸᩦ.)] ᩅᨧᨶᩴ ᨲᩥᨲᩥᨠ᩠ᨡᩥᨲᩩᩴ, ᩈᨴᩥᩈᩔ ᩅᩣ ᩈᩮᨭ᩠ᨮᨲᩁᩔ [ᩈᩮᨭ᩠ᨮᨶᩁᩔ (ᨸᩦ.)] ᩅᩣᨸᩥ;

ᨠᨳᩴ ᨶᩩ ᩉᩦᨶᩔ ᩅᨧᩮᩣ ᨡᨾᩮᨳ, ᩋᨠ᩠ᨡᩣᩉᩥ ᨾᩮ ᨠᩮᩣᨱ᩠ᨯᨬ᩠ᨬ ᩑᨲᨾᨲ᩠ᨳᩴ’’.

᪖᪖.

‘‘ᨽᨿᩣ ¶ ᩉᩥ ᩈᩮᨭ᩠ᨮᩔ ᩅᨧᩮᩣ ᨡᨾᩮᨳ, ᩈᩣᩁᨾ᩠ᨽᩉᩮᨲᩪ ᨸᨶ ᩈᩣᨴᩥᩈᩔ;

ᨿᩮᩣ ᨧᩦᨵ ᩉᩦᨶᩔ ᩅᨧᩮᩣ ᨡᨾᩮᨳ, ᩑᨲᩴ ᨡᨶ᩠ᨲᩥᩴ ᩏᨲ᩠ᨲᨾᨾᩣᩉᩩ ᩈᨶ᩠ᨲᩮᩣ’’.

᪖᪗.

‘‘ᨠᨳᩴ ᩅᩥᨩᨬ᩠ᨬᩣ ᨧᨲᩩᨸᨲ᩠ᨳᩁᩪᨸᩴ [ᨧᨲᩩᨾᨭ᩠ᨮᩁᩪᨸᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩈᩮᨭ᩠ᨮᩴ ᩈᩁᩥᨠ᩠ᨡᩴ ᩋᨳᩅᩣᨸᩥ ᩉᩦᨶᩴ;

ᩅᩥᩁᩪᨸᩁᩪᨸᩮᨶ ᨧᩁᨶ᩠ᨲᩥ ᩈᨶ᩠ᨲᩮᩣ, ᨲᩈ᩠ᨾᩣ ᩉᩥ ᩈᨻ᩠ᨻᩮᩈᩴ ᩅᨧᩮᩣ ᨡᨾᩮᨳ’’.

᪖᪘.

‘‘ᨶ ᩉᩮᨲᨾᨲ᩠ᨳᩴ ᨾᩉᨲᩦᨸᩥ ᩈᩮᨶᩣ, ᩈᩁᩣᨩᩥᨠᩣ ᨿᩩᨩ᩠ᨫᨾᩣᨶᩣ ᩃᨽᩮᨳ;

ᨿᩴ ¶ ᨡᨶ᩠ᨲᩥᨾᩣ ᩈᨸ᩠ᨸᩩᩁᩥᩈᩮᩣ ᩃᨽᩮᨳ, ᨡᨶ᩠ᨲᩦ ᨻᩃᩔᩪᨸᩈᨾᨶ᩠ᨲᩥ ᩅᩮᩁᩣ’’.

᪖᪙.

‘‘ᩈᩩᨽᩣᩈᩥᨲᩴ ᨲᩮ ᩋᨶᩩᨾᩮᩣᨴᩥᨿᩣᨶ, ᩋᨬ᩠ᨬᩴ ᨲᩴ ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᨴᩥᨦ᩠ᨥ ᨻᩕᩪᩉᩥ;

ᨿᨳᩣ ᩋᩉᩩᩴ [ᩋᩉᩪ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨴᨱ᩠ᨯᨠᩦ ᨶᩣᩊᩥᨠᩮᩁᩮᩣ [ᨶᩣᩊᩥᨠᩦᩁᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩋᨳᨩ᩠ᨩᩩᨶᩮᩣ ᨠᩃᩣᨻᩩ ᨧᩣᨸᩥ ᩁᩣᨩᩣ;

ᨲᩮᩈᩴ ᨣᨲᩥᩴ ᨻᩕᩪᩉᩥ ᩈᩩᨸᩣᨸᨠᨾ᩠ᨾᩥᨶᩴ, ᨠᨲ᩠ᨳᩪᨸᨸᨶ᩠ᨶᩣ ᩍᩈᩥᨶᩴ ᩅᩥᩉᩮᨮᨠᩣ’’.

᪗᪐.

‘‘ᨠᩥᩈᨬ᩠ᩉᩥ [ᨠᩥᩈᩴᨸᩥ (ᨸᩦ.)] ᩅᨧ᩠ᨨᩴ ᩋᩅᨠᩥᩁᩥᨿ ᨴᨱ᩠ᨯᨠᩦ, ᩏᨧ᩠ᨨᩥᨶ᩠ᨶᨾᩪᩃᩮᩣ ᩈᨩᨶᩮᩣ ᩈᩁᨭ᩠ᨮᩮᩣ;

ᨠᩩᨠ᩠ᨠᩩᩊᨶᩣᨾᩮ ᨶᩥᩁᨿᨾ᩠ᩉᩥ ᨸᨧ᩠ᨧᨲᩥ, ᨲᩔ ᨹᩩᩃᩥᨦ᩠ᨣᩣᨶᩥ ᨸᨲᨶ᩠ᨲᩥ ᨠᩣᨿᩮ.

᪗᪑.

‘‘ᨿᩮᩣ ᩈᨬ᩠ᨬᨲᩮ ᨸᨻ᩠ᨻᨩᩥᨲᩮ ᩋᩉᩮᨮᨿᩥ [ᩋᩅᨬ᩠ᨧᩈᩥ (ᨸᩦ.)], ᨵᨾ᩠ᨾᩴ ᨽᨱᨶ᩠ᨲᩮ ᩈᨾᨱᩮ ᩋᨴᩪᩈᨠᩮ;

ᨲᩴ ᨶᩣᩊᩥᨠᩮᩁᩴ ᩈᩩᨶᨡᩣ ᨸᩁᨲ᩠ᨳ, ᩈᨦ᩠ᨣᨾ᩠ᨾ ᨡᩣᨴᨶ᩠ᨲᩥ ᩅᩥᨹᨶ᩠ᨴᨾᩣᨶᩴ.

᪗᪒.

‘‘ᩋᨳᨩ᩠ᨩᩩᨶᩮᩣ ¶ ᨶᩥᩁᨿᩮ ᩈᨲ᩠ᨲᩥᩈᩪᩃᩮ, ᩋᩅᩴᩈᩥᩁᩮᩣ ᨸᨲᩥᨲᩮᩣ ᩏᨴ᩠ᨵᩴᨸᩣᨴᩮᩣ [ᩏᨴ᩠ᨵᨸᩣᨴᩮᩣ (ᩈ᩠ᨿᩣ.), ᩋᨴ᩠ᨵᨸᩣᨴᩮᩣ (ᨸᩦ.)];

ᩋᨦ᩠ᨣᩦᩁᩈᩴ ᨣᩮᩣᨲᨾᩴ ᩉᩮᨮᨿᩥᨲ᩠ᩅᩣ, ᨡᨶ᩠ᨲᩥᩴ ᨲᨸᩔᩥᩴ ᨧᩥᩁᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᩴ.

᪗᪓.

‘‘ᨿᩮᩣ ¶ ᨡᨱ᩠ᨯᩈᩮᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩴ ᩋᨨᩮᨴᨿᩥ, ᨡᨶ᩠ᨲᩥᩴ ᩅᨴᨶ᩠ᨲᩴ ᩈᨾᨱᩴ ᩋᨴᩪᩈᨠᩴ;

ᨠᩃᩣᨻᩩᩅᩦᨧᩥᩴ ᩏᨸᨸᨩ᩠ᨩ ᨸᨧ᩠ᨧᨲᩥ, ᨾᩉᩣᨸᨲᩣᨸᩴ [ᨾᩉᩣᨽᩥᨲᩣᨸᩴ (ᨸᩦ.)] ᨠᨭᩩᨠᩴ ᨽᨿᩣᨶᨠᩴ.

᪗᪔.

‘‘ᩑᨲᩣᨶᩥ ᩈᩩᨲ᩠ᩅᩣ ᨶᩥᩁᨿᩣᨶᩥ ᨸᨱ᩠ᨯᩥᨲᩮᩣ, ᩋᨬ᩠ᨬᩣᨶᩥ ᨸᩣᨸᩥᨭ᩠ᨮᨲᩁᩣᨶᩥ ᨧᩮᨲ᩠ᨳ;

ᨵᨾ᩠ᨾᩴ ᨧᩁᩮ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ, ᩑᩅᨦ᩠ᨠᩁᩮᩣ ᩈᨣ᩠ᨣᨾᩩᨸᩮᨲᩥ ᨮᩣᨶᩴ’’.

᪗᪕.

‘‘ᩈᩩᨽᩣᩈᩥᨲᩴ ¶ ᨲᩮ ᩋᨶᩩᨾᩮᩣᨴᩥᨿᩣᨶ, ᩋᨬ᩠ᨬᩴ ᨲᩴ ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᨴᩥᨦ᩠ᨥ ᨻᩕᩪᩉᩥ;

ᨠᨳᩴᩅᩥᨵᩴ ᩈᩦᩃᩅᨶ᩠ᨲᩴ ᩅᨴᨶ᩠ᨲᩥ, ᨠᨳᩴᩅᩥᨵᩴ ᨸᨬ᩠ᨬᩅᨶ᩠ᨲᩴ ᩅᨴᨶ᩠ᨲᩥ;

ᨠᨳᩴᩅᩥᨵᩴ ᩈᨸ᩠ᨸᩩᩁᩥᩈᩴ ᩅᨴᨶ᩠ᨲᩥ, ᨠᨳᩴᩅᩥᨵᩴ ᨶᩮᩣ ᩈᩥᩁᩥ ᨶᩮᩣ ᨩᩉᩣᨲᩥ’’.

᪗᪖.

‘‘ᨠᩣᨿᩮᨶ ᩅᩣᨧᩣᨿ ᨧ ᨿᩮᩣ’ᨵ [ᨿᩮᩣ ᨧ (ᨸᩦ.)] ᩈᨬ᩠ᨬᨲᩮᩣ, ᨾᨶᩈᩣ ᨧ ᨠᩥᨬ᩠ᨧᩥ ᨶ ᨠᩁᩮᩣᨲᩥ ᨸᩣᨸᩴ;

ᨶ ᩋᨲ᩠ᨲᩉᩮᨲᩪ ᩋᩃᩥᨠᩴ ᨽᨱᩮᨲᩥ [ᨽᨱᩣᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨲᨳᩣᩅᩥᨵᩴ ᩈᩦᩃᩅᨶ᩠ᨲᩴ ᩅᨴᨶ᩠ᨲᩥ.

᪗᪗.

‘‘ᨣᨾ᩠ᨽᩦᩁᨸᨬ᩠ᩉᩴ ᨾᨶᩈᩣᨽᩥᨧᩥᨶ᩠ᨲᨿᩴ [ᨾᨶᩈᩣ ᩅᩥᨧᩥᨶ᩠ᨲᨿᩴ (ᩈᩦ.)], ᨶᩣᨧ᩠ᨧᩣᩉᩥᨲᩴ ᨠᨾ᩠ᨾ ᨠᩁᩮᩣᨲᩥ ᩃᩩᨴ᩠ᨴᩴ;

ᨠᩣᩃᩣᨣᨲᩴ ¶ [ᨠᩣᩃᩣᨽᨲᩴ (ᨸᩦ.)] ᩋᨲ᩠ᨳᨸᨴᩴ ᨶ ᩁᩥᨬ᩠ᨧᨲᩥ, ᨲᨳᩣᩅᩥᨵᩴ ᨸᨬ᩠ᨬᩅᨶ᩠ᨲᩴ ᩅᨴᨶ᩠ᨲᩥ.

᪗᪘.

‘‘ᨿᩮᩣ ¶ ᩅᩮ ᨠᨲᨬ᩠ᨬᩪ ᨠᨲᩅᩮᨴᩥ ᨵᩦᩁᩮᩣ, ᨠᩃ᩠ᨿᩣᨱᨾᩥᨲ᩠ᨲᩮᩣ ᨴᩊ᩠ᩉᨽᨲ᩠ᨲᩥ ᨧ ᩉᩮᩣᨲᩥ;

ᨴᩩᨡᩥᨲᩔ ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨠᩁᩮᩣᨲᩥ ᨠᩥᨧ᩠ᨧᩴ, ᨲᨳᩣᩅᩥᨵᩴ ᩈᨸ᩠ᨸᩩᩁᩥᩈᩴ ᩅᨴᨶ᩠ᨲᩥ.

᪗᪙.

‘‘ᩑᨲᩮᩉᩥ ᩈᨻ᩠ᨻᩮᩉᩥ ᨣᩩᨱᩮᩉᩩᨸᩮᨲᩮᩣ, ᩈᨴ᩠ᨵᩮᩣ ᨾᩩᨴᩪ ᩈᩴᩅᩥᨽᩣᨣᩦ ᩅᨴᨬ᩠ᨬᩪ;

ᩈᨦ᩠ᨣᩣᩉᨠᩴ ᩈᨡᩥᩃᩴ ᩈᨱ᩠ᩉᩅᩣᨧᩴ, ᨲᨳᩣᩅᩥᨵᩴ ᨶᩮᩣ ᩈᩥᩁᩥ ᨶᩮᩣ ᨩᩉᩣᨲᩥ’’.

᪘᪐.

‘‘ᩈᩩᨽᩣᩈᩥᨲᩴ ᨲᩮ ᩋᨶᩩᨾᩮᩣᨴᩥᨿᩣᨶ, ᩋᨬ᩠ᨬᩴ ᨲᩴ ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᨴᩥᨦ᩠ᨥ ᨻᩕᩪᩉᩥ;

ᩈᩦᩃᩴ ᩈᩥᩁᩥᨬ᩠ᨧᩣᨸᩥ ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩴ, ᨸᨬ᩠ᨬᨬ᩠ᨧ ᨠᩴ ᩈᩮᨭ᩠ᨮᨲᩁᩴ ᩅᨴᨶ᩠ᨲᩥ’’.

᪘᪑.

‘‘ᨸᨬ᩠ᨬᩣ ᩉᩥ ᩈᩮᨭ᩠ᨮᩣ ᨠᩩᩈᩃᩣ ᩅᨴᨶ᩠ᨲᩥ, ᨶᨠ᩠ᨡᨲ᩠ᨲᩁᩣᨩᩣᩁᩥᩅ ᨲᩣᩁᨠᩣᨶᩴ;

ᩈᩦᩃᩴ ᩈᩦᩁᩦ ᨧᩣᨸᩥ ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩮᩣ [ᨵᨾ᩠ᨾᩣ (ᨸᩦ.)], ᩋᨶ᩠ᩅᩣᨿᩥᨠᩣ ᨸᨬ᩠ᨬᩅᨲᩮᩣ ᨽᩅᨶ᩠ᨲᩥ’’.

᪘᪒.

‘‘ᩈᩩᨽᩣᩈᩥᨲᩴ ᨲᩮ ᩋᨶᩩᨾᩮᩣᨴᩥᨿᩣᨶ, ᩋᨬ᩠ᨬᩴ ᨲᩴ ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᨴᩥᨦ᩠ᨥ ᨻᩕᩪᩉᩥ;

ᨠᨳᩴᨠᩁᩮᩣ ¶ ᨠᩥᨶ᩠ᨲᩥᨠᩁᩮᩣ ᨠᩥᨾᩣᨧᩁᩴ, ᨠᩥᩴ ᩈᩮᩅᨾᩣᨶᩮᩣ ᩃᨽᨲᩦᨵ ᨸᨬ᩠ᨬᩴ;

ᨸᨬ᩠ᨬᩣᨿ ᨴᩣᨶᩥᨸ᩠ᨸᨭᩥᨸᩴ [ᨴᩣᨶᩥ ᨸᨭᩥᨸᨴᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩅᨴᩮᩉᩥ, ᨠᨳᩴᨠᩁᩮᩣ ᨸᨬ᩠ᨬᩅᩣ ᩉᩮᩣᨲᩥ ᨾᨧ᩠ᨧᩮᩣ’’.

᪘᪓.

‘‘ᩈᩮᩅᩮᨳ ᩅᩩᨴ᩠ᨵᩮ ᨶᩥᨸᩩᨱᩮ ᨻᩉᩩᩔᩩᨲᩮ, ᩏᨣ᩠ᨣᩣᩉᨠᩮᩣ ᨧ ᨸᩁᩥᨸᩩᨧ᩠ᨨᨠᩮᩣ ᩈᩥᨿᩣ;

ᩈᩩᨱᩮᨿ᩠ᨿ ᩈᨠ᩠ᨠᨧ᩠ᨧ ᩈᩩᨽᩣᩈᩥᨲᩣᨶᩥ, ᩑᩅᩴᨠᩁᩮᩣ ᨸᨬ᩠ᨬᩅᩣ ᩉᩮᩣᨲᩥ ᨾᨧ᩠ᨧᩮᩣ.

᪘᪔.

‘‘ ¶ ᨸᨬ᩠ᨬᩅᩣ ᨠᩣᨾᨣᩩᨱᩮ ᩋᩅᩮᨠ᩠ᨡᨲᩥ, ᩋᨶᩥᨧ᩠ᨧᨲᩮᩣ ᨴᩩᨠ᩠ᨡᨲᩮᩣ ᩁᩮᩣᨣᨲᩮᩣ ᨧ;

ᩑᩅᩴ ᩅᩥᨸᩔᩦ ᨸᨩᩉᩣᨲᩥ ᨨᨶ᩠ᨴᩴ, ᨴᩩᨠ᩠ᨡᩮᩈᩩ ᨠᩣᨾᩮᩈᩩ ᨾᩉᨻ᩠ᨽᨿᩮᩈᩩ.

᪘᪕.

‘‘ᩈ ᩅᩦᨲᩁᩣᨣᩮᩣ ᨸᩅᩥᨶᩮᨿ᩠ᨿ ᨴᩮᩣᩈᩴ, ᨾᩮᨲ᩠ᨲᩴ [ᨾᩮᨲ᩠ᨲ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨧᩥᨲ᩠ᨲᩴ ᨽᩣᩅᨿᩮ [ᨽᩣᩅᩮᨿ᩠ᨿ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)] ᩋᨸ᩠ᨸᨾᩣᨱᩴ;

ᩈᨻ᩠ᨻᩮᩈᩩ ᨽᩪᨲᩮᩈᩩ ᨶᩥᨵᩣᨿ ᨴᨱ᩠ᨯᩴ, ᩋᨶᩥᨶ᩠ᨴᩥᨲᩮᩣ ᨻᩕᩉ᩠ᨾᨾᩩᨸᩮᨲᩥ ᨮᩣᨶᩴ’’.

᪘᪖.

‘‘ᨾᩉᨲ᩠ᨳᩥᨿᩴ [ᨾᩉᩥᨴ᩠ᨵᩥᨿᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩌᨣᨾᨶᩴ ᩋᩉᩮᩣᩈᩥ, ᨲᩅᨾᨭ᩠ᨮᨠᩣ [ᨾᨭ᩠ᨮᨠ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)] ᨽᩦᨾᩁᨳᩔ ᨧᩣᨸᩥ;

ᨠᩣᩃᩥᨦ᩠ᨣᩁᩣᨩᩔ ᨧ ᩏᨣ᩠ᨣᨲᩔ, ᩈᨻ᩠ᨻᩮᩈ ¶ ᩅᩮᩣ ᨠᩣᨾᩁᩣᨣᩮᩣ ᨸᩉᩦᨶᩮᩣ’’.

᪘᪗.

‘‘ᩑᩅᨾᩮᨲᩴ ᨸᩁᨧᩥᨲ᩠ᨲᩅᩮᨴᩥ, ᩈᨻ᩠ᨻᩮᩈ ᨶᩮᩣ ᨠᩣᨾᩁᩣᨣᩮᩣ ᨸᩉᩦᨶᩮᩣ;

ᨠᩁᩮᩣᩉᩥ ᩒᨠᩣᩈᨾᨶᩩᨣ᩠ᨣᩉᩣᨿ, ᨿᨳᩣ ᨣᨲᩥᩴ ᨲᩮ ᩋᨽᩥᩈᨾ᩠ᨽᩅᩮᨾ’’.

᪘᪘.

‘‘ᨠᩁᩮᩣᨾᩥ ᩒᨠᩣᩈᨾᨶᩩᨣ᩠ᨣᩉᩣᨿ, ᨲᨳᩣ ᩉᩥ ᩅᩮᩣ ᨠᩣᨾᩁᩣᨣᩮᩣ ᨸᩉᩦᨶᩮᩣ;

ᨹᩁᩣᨳ ᨠᩣᨿᩴ ᩅᩥᨸᩩᩃᩣᨿ ᨸᩦᨲᩥᨿᩣ, ᨿᨳᩣ ᨣᨲᩥᩴ ᨾᩮ ᩋᨽᩥᩈᨾ᩠ᨽᩅᩮᨳ’’.

᪘᪙.

‘‘ᩈᨻ᩠ᨻᩴ ¶ ᨠᩁᩥᩔᩣᨾ ᨲᩅᩣᨶᩩᩈᩣᩈᨶᩥᩴ, ᨿᩴ ᨿᩴ ᨲᩩᩅᩴ ᩅᨠ᩠ᨡᩈᩥ ᨽᩪᩁᩥᨸᨬ᩠ᨬ;

ᨹᩁᩣᨾ ᨠᩣᨿᩴ ᩅᩥᨸᩩᩃᩣᨿ ᨸᩦᨲᩥᨿᩣ, ᨿᨳᩣ ᨣᨲᩥᩴ ᨲᩮ ᩋᨽᩥᩈᨾ᩠ᨽᩅᩮᨾ’’.

᪙᪐.

‘‘ᨠᨲᩣᨿ [ᨠᨲᩣᨿᩴ (ᩈᩦ. ᨸᩦ.)] ᩅᨧ᩠ᨨᩔ ᨠᩥᩈᩔ ᨸᩪᨩᩣ, ᨣᨧ᩠ᨨᨶ᩠ᨲᩩ ᨽᩮᩣᨶ᩠ᨲᩮᩣ ᩍᩈᨿᩮᩣ ᩈᩣᨵᩩᩁᩪᨸᩣ;

ᨫᩣᨶᩮ ᩁᨲᩣ ᩉᩮᩣᨳ ᩈᨴᩣ ᩈᨾᩣᩉᩥᨲᩣ, ᩑᩈᩣ ᩁᨲᩦ ᨸᨻ᩠ᨻᨩᩥᨲᩔ ᩈᩮᨭ᩠ᨮᩣ’’.

᪙᪑.

‘‘ᩈᩩᨲ᩠ᩅᩣᨶ ¶ ᨣᩣᨳᩣ ᨸᩁᨾᨲ᩠ᨳᩈᩴᩉᩥᨲᩣ, ᩈᩩᨽᩣᩈᩥᨲᩣ ᩍᩈᩥᨶᩣ ᨸᨱ᩠ᨯᩥᨲᩮᨶ;

ᨲᩮ ᩅᩮᨴᨩᩣᨲᩣ ᩋᨶᩩᨾᩮᩣᨴᨾᩣᨶᩣ, ᨸᨠ᩠ᨠᩣᨾᩩ ¶ [ᨸᨠ᩠ᨠᨾᩩ (ᨠ.)] ᨴᩮᩅᩣ ᨴᩮᩅᨸᩩᩁᩴ ᨿᩈᩔᩥᨶᩮᩣ.

᪙᪒.

‘‘ᨣᩣᨳᩣ ᩍᨾᩣ ᩋᨲ᩠ᨳᩅᨲᩦ ᩈᩩᨻ᩠ᨿᨬ᩠ᨩᨶᩣ, ᩈᩩᨽᩣᩈᩥᨲᩣ ᩍᩈᩥᨶᩣ ᨸᨱ᩠ᨯᩥᨲᩮᨶ;

ᨿᩮᩣ ᨠᩮᩣᨧᩥᨾᩣ ᩋᨭ᩠ᨮᩥᨠᨲ᩠ᩅᩣ [ᩋᨭ᩠ᨮᩥᩴ ᨠᨲ᩠ᩅᩣ (ᨠ.)] ᩈᩩᨱᩮᨿ᩠ᨿ, ᩃᨽᩮᨳ ᨸᩩᨻ᩠ᨻᩣᨸᩁᩥᨿᩴ ᩅᩥᩈᩮᩈᩴ;

ᩃᨴ᩠ᨵᩣᨶ ᨸᩩᨻ᩠ᨻᩣᨸᩁᩥᨿᩴ ᩅᩥᩈᩮᩈᩴ, ᩋᨴᩔᨶᩴ ᨾᨧ᩠ᨧᩩᩁᩣᨩᩔ ᨣᨧ᩠ᨨᩮ’’.

᪙᪓.

‘‘ᩈᩣᩃᩥᩔᩁᩮᩣ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᩣ, ᨾᩮᨱ᩠ᨯᩥᩔᩁᩮᩣ ᨧ ᨠᩔᨸᩮᩣ;

ᨸᨻ᩠ᨻᨲᩮᩣ ᩋᨶᩩᩁᩩᨴ᩠ᨵᩮᩣ ᨧ, ᨠᨧ᩠ᨧᩣᨿᨶᩮᩣ ᨧ ᨴᩮᩅᩃᩮᩣ [ᨴᩮᩅᩥᩃᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)].

᪙᪔.

‘‘ᩋᨶᩩᩈᩥᩔᩮᩣ ᨧ ᩌᨶᨶ᩠ᨴᩮᩣ, ᨠᩥᩈᩅᨧ᩠ᨨᩮᩣ ᨧ ᨠᩮᩣᩃᩥᨲᩮᩣ;

ᨶᩣᩁᨴᩮᩣ ᩏᨴᩣᨿᩦ ᨳᩮᩁᩮᩣ [ᨶᩣᩁᨴᩮᩣ ᨸᩩᨱ᩠ᨱᩮᩣ ᨾᨶ᩠ᨲᩣᨶᩦᨸᩩᨲ᩠ᨲᩮᩣ (ᩈᩦ.)], ᨸᩁᩥᩈᩣ ᨻᩩᨴ᩠ᨵᨸᩁᩥᩈᩣ;

ᩈᩁᨽᨦ᩠ᨣᩮᩣ ᩃᩮᩣᨠᨶᩣᨳᩮᩣ, ᩑᩅᩴ ᨵᩣᩁᩮᨳ ᨩᩣᨲᨠ’’ᨶ᩠ᨲᩥ.

ᩈᩁᨽᨦ᩠ᨣᨩᩣᨲᨠᩴ ᨴᩩᨲᩥᨿᩴ.

᪕᪒᪓. ᩋᩃᨾ᩠ᨻᩩᩈᩣᨩᩣᨲᨠᩴ (᪓)

᪙᪕.

‘‘ᩋᨳ ᨻᩕᩅᩥ ᨻᩕᩉᩣ ᩍᨶ᩠ᨴᩮᩣ, ᩅᨲᩕᨽᩪ ᨩᨿᨲᩴ ᨸᩥᨲᩣ;

ᨴᩮᩅᨠᨬ᩠ᨬᩴ ᨸᩁᩣᨽᩮᨲ᩠ᩅᩣ, ᩈᩩᨵᨾ᩠ᨾᩣᨿᩴ ᩋᩃᨾ᩠ᨻᩩᩈᩴ.

᪙᪖.

‘‘ᨾᩥᩔᩮ ᨴᩮᩅᩣ ᨲᩴ ᨿᩣᨧᨶ᩠ᨲᩥ, ᨲᩣᩅᨲᩥᩴᩈᩣ ᩈᩍᨶ᩠ᨴᨠᩣ;

ᩍᩈᩥᨸ᩠ᨸᩃᩮᩣᨽᨶᩮ ¶ [ᩍᩈᩥᨸᩃᩮᩣᨽᩥᨠᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩍᩈᩥᩴ ᨸᩃᩮᩣᨽᩥᨠᩮ (ᨸᩦ.)] ᨣᨧ᩠ᨨ, ᩍᩈᩥᩈᩥᨦ᩠ᨣᩴ ᩋᩃᨾ᩠ᨻᩩᩈᩮ.

᪙᪗.

‘‘ᨸᩩᩁᩣᨿᩴ ᩋᨾ᩠ᩉᩮ ᩋᨧ᩠ᨧᩮᨲᩥ [ᨶᩣᨧ᩠ᨧᩮᨲᩥ (ᩈ᩠ᨿᩣ. ᨠ.)], ᩅᨲ᩠ᨲᩅᩣ [ᩅᨲᩅᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩅᩣ;

ᨶᩥᨻ᩠ᨻᩣᨶᩣᨽᩥᩁᨲᩮᩣ ᩅᩩᨴ᩠ᨵᩮᩣ [ᩅᨴ᩠ᨵᩮᩣ (ᨸᩦ.), ᨻᩩᨴ᩠ᨵᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨲᩔ ᨾᨣ᩠ᨣᩣᨶᩥ ᩌᩅᩁ’’.

᪙᪘.

‘‘ᨴᩮᩅᩁᩣᨩ ᨠᩥᨾᩮᩅ ᨲ᩠ᩅᩴ, ᨾᨾᩮᩅ ᨲᩩᩅᩴ ᩈᩥᨠ᩠ᨡᩈᩥ;

ᩍᩈᩥᨸ᩠ᨸᩃᩮᩣᨽᨶᩮ [ᩍᩈᩥᨸᩃᩮᩣᨽᩥᨠᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩍᩈᩥᩴ ᨸᩃᩮᩣᨽᩥᨠᩮ (ᨸᩦ.)] ᨣᨧ᩠ᨨ, ᩈᨶ᩠ᨲᩥ ᩋᨬ᩠ᨬᩣᨸᩥ ᩋᨧ᩠ᨨᩁᩣ.

᪙᪙.

‘‘ᨾᩣᨴᩥᩈᩥᨿᩮᩣ ¶ ᨸᩅᩁᩣ ᨧᩮᩅ, ᩋᩈᩮᩣᨠᩮ ᨶᨶ᩠ᨴᨶᩮ ᩅᨶᩮ;

ᨲᩣᩈᨾ᩠ᨸᩥ ᩉᩮᩣᨲᩩ ᨸᩁᩥᨿᩣᨿᩮᩣ, ᨲᩣᨸᩥ ᨿᨶ᩠ᨲᩩ ᨸᩃᩮᩣᨽᨶᩣ’’ [ᨸᩃᩮᩣᨽᩥᨠᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪑᪐᪐.

‘‘ᩋᨴ᩠ᨵᩣ ¶ ᩉᩥ ᩈᨧ᩠ᨧᩴ ᨽᨱᩈᩥ, ᩈᨶ᩠ᨲᩥ ᩋᨬ᩠ᨬᩣᨸᩥ ᩋᨧ᩠ᨨᩁᩣ;

ᨲᩣᨴᩥᩈᩥᨿᩮᩣ ᨸᩅᩁᩣ ᨧᩮᩅ, ᩋᩈᩮᩣᨠᩮ ᨶᨶ᩠ᨴᨶᩮ ᩅᨶᩮ.

᪑᪐᪑.

‘‘ᨶ ᨲᩣ ᩑᩅᩴ ᨸᨩᩣᨶᨶ᩠ᨲᩥ, ᨸᩣᩁᩥᨧᩁᩥᨿᩴ ᨸᩩᨾᩴ ᨣᨲᩣ;

ᨿᩣᨴᩥᩈᩴ ᨲ᩠ᩅᩴ ᨸᨩᩣᨶᩣᩈᩥ, ᨶᩣᩁᩥ ᩈᨻ᩠ᨻᨦ᩠ᨣᩈᩮᩣᨽᨶᩮ.

᪑᪐᪒.

‘‘ᨲ᩠ᩅᨾᩮᩅ ᨣᨧ᩠ᨨ ᨠᩃ᩠ᨿᩣᨱᩥ, ᩍᨲ᩠ᨳᩦᨶᩴ ᨸᩅᩁᩣ ᨧᩈᩥ;

ᨲᩅᩮᩅ ᩅᨱ᩠ᨱᩁᩪᨸᩮᨶ, ᩈᩅᩈᨾᩣᨶᨿᩥᩔᩈᩥ’’ [ᩅᩈᨾᩣᨶᩣᨸᨿᩥᩔᩈᩥ (ᩈ᩠ᨿᩣ.), ᩅᩈᨾᩣᨶᩣᨾᨿᩥᩔᩈᩥ (ᨸᩦ.), ᨲᩴ ᩅᩈᨾᩣᨶᨿᩥᩔᩈᩥ (ᨠ.)].

᪑᪐᪓.

‘‘ᨶ ᩅᩣᩉᩴ ᨶ ᨣᨾᩥᩔᩣᨾᩥ, ᨴᩮᩅᩁᩣᨩᩮᨶ ᨸᩮᩈᩥᨲᩣ;

ᩅᩥᨽᩮᨾᩥ ᨧᩮᨲᩴ ᩌᩈᩣᨴᩩᩴ, ᩏᨣ᩠ᨣᨲᩮᨩᩮᩣ ᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

᪑᪐᪔.

‘‘ᩋᨶᩮᨠᩮ ᨶᩥᩁᨿᩴ ᨸᨲ᩠ᨲᩣ, ᩍᩈᩥᨾᩣᩈᩣᨴᩥᨿᩣ ᨩᨶᩣ;

ᩌᨸᨶ᩠ᨶᩣ ᨾᩮᩣᩉᩈᩴᩈᩣᩁᩴ, ᨲᩈ᩠ᨾᩣ ᩃᩮᩣᨾᩣᨶᩥ ᩉᩴᩈᨿᩮ’’.

᪑᪐᪕.

‘‘ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᨸᨠ᩠ᨠᩣᨾᩥ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦ;

ᨾᩥᩔᩣ ᨾᩥᩔᩥᨲᩩ [ᨾᩥᩔᩮᨲᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩥᨧ᩠ᨨᨶ᩠ᨲᩦ, ᩍᩈᩥᩈᩥᨦ᩠ᨣᩴ ᩋᩃᨾ᩠ᨻᩩᩈᩣ.

᪑᪐᪖.

‘‘ᩈᩣ ᨧ ᨲᩴ ᩅᨶᨾᩮᩣᨣᨿ᩠ᩉ, ᩍᩈᩥᩈᩥᨦ᩠ᨣᩮᨶ ᩁᨠ᩠ᨡᩥᨲᩴ;

ᨻᩥᨾ᩠ᨻᨩᩣᩃᨠᩈᨬ᩠ᨨᨶ᩠ᨶᩴ ¶ , ᩈᨾᨶ᩠ᨲᩣ ᩋᨯ᩠ᨰᨿᩮᩣᨩᨶᩴ.

᪑᪐᪗.

‘‘ᨸᩣᨲᩮᩣᩅ ᨸᩣᨲᩁᩣᩈᨾ᩠ᩉᩥ, ᩏᨴᨱ᩠ᩉᩈᨾᨿᩴ [ᩏᨴᨿᩈᨾᨿᩴ (ᩈ᩠ᨿᩣ.), ᩏᨴᨶ᩠ᨲᩈᨾᨿᩴ (ᨠ.)] ᨸᨲᩥ;

ᩋᨣ᩠ᨣᩥᨭ᩠ᨮᩴ ᨸᩁᩥᨾᨩ᩠ᨩᨶ᩠ᨲᩴ, ᩍᩈᩥᩈᩥᨦ᩠ᨣᩴ ᩏᨸᩣᨣᨾᩥ’’.

᪑᪐᪘.

‘‘ᨠᩣ ᨶᩩ ᩅᩥᨩ᩠ᨩᩩᩁᩥᩅᩣᨽᩣᩈᩥ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ;

ᩅᩥᨧᩥᨲ᩠ᨲᩉᨲ᩠ᨳᩣᨽᩁᨱᩣ [ᩅᩥᨧᩥᨲ᩠ᨲᩅᨲ᩠ᨳᩣᨽᩁᨱᩣ (ᩈᩦ.)], ᩌᨾᩩᨲ᩠ᨲᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᩣ [ᩌᨾᩩᨠ᩠ᨠᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᩣ (?)].

᪑᪐᪙.

‘‘ᩌᨴᩥᨧ᩠ᨧᩅᨱ᩠ᨱᩈᨦ᩠ᨠᩣᩈᩣ, ᩉᩮᨾᨧᨶ᩠ᨴᨶᨣᨶ᩠ᨵᩥᨶᩦ;

ᩈᨬ᩠ᨬᨲᩪᩁᩪ ᨾᩉᩣᨾᩣᨿᩣ, ᨠᩩᨾᩣᩁᩦ ᨧᩣᩁᩩᨴᩔᨶᩣ.

᪑᪑᪐.

‘‘ᩅᩥᩃᨣ᩠ᨣᩣ [ᩅᩥᩃᩣᨠᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩩᨴᩩᨠᩣ ᩈᩩᨴ᩠ᨵᩣ, ᨸᩣᨴᩣ ᨲᩮ ᩈᩩᨸ᩠ᨸᨲᩥᨭ᩠ᨮᩥᨲᩣ;

ᨣᨾᨶᩣ ᨠᩣᨾᨶᩦᨿᩣ [ᨠᨾᨶᩣ ᨠᨾᨶᩦᨿᩣ (ᩈᩦ. ᨸᩦ.)] ᨲᩮ, ᩉᩁᨶ᩠ᨲᩥᨿᩮᩅ ᨾᩮ ᨾᨶᩮᩣ.

᪑᪑᪑.

‘‘ᩋᨶᩩᨸᩩᨻ᩠ᨻᩣᩅ ¶ ᨲᩮ ᩐᩁᩪ, ᨶᩣᨣᨶᩣᩈᩈᨾᩪᨸᨾᩣ;

ᩅᩥᨾᨭ᩠ᨮᩣ ᨲᩩᨿ᩠ᩉᩴ ᩈᩩᩔᩮᩣᨱᩦ, ᩋᨠ᩠ᨡᩔ ᨹᩃᨠᩴ ᨿᨳᩣ.

᪑᪑᪒.

‘‘ᩏᨸ᩠ᨸᩃᩔᩮᩅ ᨠᩥᨬ᩠ᨩᨠ᩠ᨡᩣ, ᨶᩣᨽᩥ ᨲᩮ ᩈᩣᨵᩩ ᩈᨱ᩠ᨮᩥᨲᩣ;

ᨸᩪᩁᩣ ᨠᨱ᩠ᩉᨬ᩠ᨩᨶᩔᩮᩅ, ᨴᩪᩁᨲᩮᩣ ᨸᨭᩥᨴᩥᩔᨲᩥ.

᪑᪑᪓.

‘‘ᨴᩩᩅᩥᨵᩣ ᨩᩣᨲᩣ ᩏᩁᨩᩣ, ᩋᩅᨱ᩠ᨭᩣ ᩈᩣᨵᩩ ᨸᨧ᩠ᨧᩩᨴᩣ;

ᨸᨿᩮᩣᨵᩁᩣ ᩋᨸᨲᩥᨲᩣ [ᩋᨸ᩠ᨸᨲᩦᨲᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩋᨯ᩠ᨰᩃᩣᨻᩩᩈᨾᩣ ᨳᨶᩣ.

᪑᪑᪔.

‘‘ᨴᩦᨥᩣ ᨠᨾ᩠ᨻᩩᨲᩃᩣᨽᩣᩈᩣ, ᨣᩦᩅᩣ ᩑᨱᩮᨿ᩠ᨿᨠᩣ ᨿᨳᩣ;

ᨸᨱ᩠ᨯᩁᩣᩅᩁᨱᩣ ᩅᨣ᩠ᨣᩩ, ᨧᨲᩩᨲ᩠ᨳᨾᨶᩈᨶ᩠ᨶᩥᨽᩣ.

᪑᪑᪕.

‘‘ᩏᨴ᩠ᨵᨣ᩠ᨣᩣ ¶ ᨧ ᩋᨵᨣ᩠ᨣᩣ ᨧ, ᨴᩩᨾᨣ᩠ᨣᨸᩁᩥᨾᨩ᩠ᨩᩥᨲᩣ;

ᨴᩩᩅᩥᨩᩣ ᨶᩮᩃᩈᨾ᩠ᨽᩪᨲᩣ, ᨴᨶ᩠ᨲᩣ ᨲᩅ ᩈᩩᨴᩔᨶᩣ.

᪑᪑᪖.

‘‘ᩋᨸᨱ᩠ᨯᩁᩣ ᩃᩮᩣᩉᩥᨲᨶ᩠ᨲᩣ, ᨩᩥᨬ᩠ᨩᩪᨠ [ᨩᩥᨬ᩠ᨩᩩᨠ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨹᩃᩈᨶ᩠ᨶᩥᨽᩣ;

ᩌᨿᨲᩣ ¶ ᨧ ᩅᩥᩈᩣᩃᩣ ᨧ, ᨶᩮᨲ᩠ᨲᩣ ᨲᩅ ᩈᩩᨴᩔᨶᩣ.

᪑᪑᪗.

‘‘ᨶᩣᨲᩥᨴᩦᨥᩣ ᩈᩩᩈᨾ᩠ᨾᨭ᩠ᨮᩣ, ᨠᨶᨠᨻ᩠ᨿᩣ [ᨠᨶᨠᨣ᩠ᨣᩣ (ᨸᩦ.)] ᩈᨾᩮᩣᨧᩥᨲᩣ;

ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᩁᩩᩉᩣ ᨲᩩᨿ᩠ᩉᩴ, ᨠᩮᩈᩣ ᨧᨶ᩠ᨴᨶᨣᨶ᩠ᨵᩥᨠᩣ.

᪑᪑᪘.

‘‘ᨿᩣᩅᨲᩣ ᨠᩈᩥᨣᩮᩣᩁᨠ᩠ᨡᩣ, ᩅᩣᨱᩥᨩᩣᨶᩴ [ᩅᨱᩥᨩᩣᨶᩴ (ᨸᩦ.)] ᨧ ᨿᩣ ᨣᨲᩥ;

ᩍᩈᩦᨶᨬ᩠ᨧ ᨸᩁᨠ᩠ᨠᨶ᩠ᨲᩴ, ᩈᨬ᩠ᨬᨲᩣᨶᩴ ᨲᨸᩔᩥᨶᩴ.

᪑᪑᪙.

‘‘ᨶ ᨲᩮ ᩈᨾᩈᨾᩴ ᨸᩔᩮ, ᩋᩈ᩠ᨾᩥᩴ ᨸᨳᩅᩥ [ᨸᩩᨳᩩᩅᩥ (ᨸᩦ.)] ᨾᨱ᩠ᨯᩃᩮ;

ᨠᩮᩣ ᩅᩣ ᨲ᩠ᩅᩴ ᨠᩔ ᩅᩣ ᨸᩩᨲ᩠ᨲᩮᩣ, ᨠᨳᩴ ᨩᩣᨶᩮᨾᩩ ᨲᩴ ᨾᨿᩴ’’.

᪑᪒᪐.

‘‘ᨶ ᨸᨬ᩠ᩉᨠᩣᩃᩮᩣ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨠᩔᨸᩮᩅᩴ ᨣᨲᩮ ᩈᨲᩥ;

ᩑᩉᩥ ᩈᨾ᩠ᨾ ᩁᨾᩥᩔᩣᨾ, ᩏᨽᩮᩣ ᩋᩈ᩠ᨾᩣᨠᨾᩔᨾᩮ;

ᩑᩉᩥ ᨲᩴ ᩏᨸᨣᩪᩉᩥᩔᩴ [ᩏᨸᨣᩩᨿ᩠ᩉᩥᩔᩴ (ᩈ᩠ᨿᩣ.)], ᩁᨲᩦᨶᩴ ᨠᩩᩈᩃᩮᩣ ᨽᩅ’’.

᪑᪒᪑.

‘‘ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᨸᨠ᩠ᨠᩣᨾᩥ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦ;

ᨾᩥᩔᩣ ᨾᩥᩔᩥᨲᩩᨾᩥᨧ᩠ᨨᨶ᩠ᨲᩦ, ᩍᩈᩥᩈᩥᨦ᩠ᨣᩴ ᩋᩃᨾ᩠ᨻᩩᩈᩣ’’.

᪑᪒᪒.

‘‘ᩈᩮᩣ ᨧ ᩅᩮᨣᩮᨶ ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ, ᨨᩮᨲ᩠ᩅᩣ ᨴᨶ᩠ᨵᨸᩁᨠ᩠ᨠᨾᩴ [ᨴᨶ᩠ᨵᨸᨴᨠ᩠ᨠᨾᩴ (ᨠ.)];

ᨲᨾᩩᨲ᩠ᨲᨾᩣᩈᩩ ᩅᩮᨱᩦᩈᩩ, ᩋᨩ᩠ᨫᨸ᩠ᨸᨲ᩠ᨲᩮᩣ [ᩋᨩ᩠ᨫᩣᨸᨲ᩠ᨲᩮᩣ (ᨸᩦ.)] ᨸᩁᩣᨾᩈᩥ;

᪑᪒᪓.

‘‘ᨲᨾᩩᨴᩣᩅᨲ᩠ᨲ ¶ ᨠᩃ᩠ᨿᩣᨱᩦ, ᨸᩃᩥᩔᨩᩥ ᩈᩩᩈᩮᩣᨽᨶᩣ [ᩈᩩᩈᩮᩣᨽᨱᩦ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᨧᩅᩥᨲᨾ᩠ᩉᩥ [ᨧᩅᩥ ᨲᨾ᩠ᩉᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩣ, ᨿᨳᩣ ᨲᩴ ᩋᨳ ᨲᩮᩣᩈᩥᨲᩣ.

᪑᪒᪔.

‘‘ᨾᨶᩈᩣ ᩋᨣᨾᩣ ᩍᨶ᩠ᨴᩴ, ᩅᩈᨶ᩠ᨲᩴ ᨶᨶ᩠ᨴᨶᩮ ᩅᨶᩮ;

ᨲᩔᩣ ᩈᨦ᩠ᨠᨸ᩠ᨸᨾᨬ᩠ᨬᩣᨿ, ᨾᨥᩅᩣ ᨴᩮᩅᨠᩩᨬ᩠ᨩᩁᩮᩣ.

᪑᪒᪕.

‘‘ᨸᩃ᩠ᩃᨦ᩠ᨠᩴ ᨸᩉᩥᨱᩦ ᨡᩥᨸ᩠ᨸᩴ, ᩈᩮᩣᩅᨱ᩠ᨱᩴ ᩈᩮᩣᨸᩅᩣᩉᨶᩴ;

ᩈᩏᨲ᩠ᨲᩁᨧ᩠ᨨᨴᨸᨬ᩠ᨬᩣᩈᩴ, ᩈᩉᩔᨸᨭᩥᨿᨲ᩠ᨳᨲᩴ [ᨸᨭᩥᨠᨲ᩠ᨳᨲᩴ (ᩈᩦ.)].

᪑᪒᪖.

‘‘ᨲᨾᩮᨶᩴ ¶ ᨲᨲ᩠ᨳ ᨵᩣᩁᩮᩈᩥ, ᩏᩁᩮ ᨠᨲ᩠ᩅᩣᨶ ᩈᩮᩣᨽᨶᩣ;

ᨿᨳᩣ ᩑᨠᨾᩩᩉᩩᨲ᩠ᨲᩴᩅ, ᨲᩦᨱᩥ ᩅᩔᩣᨶᩥ ᨵᩣᩁᨿᩥ.

᪑᪒᪗.

‘‘ᩅᩥᨾᨴᩮᩣ ᨲᩦᩉᩥ ᩅᩔᩮᩉᩥ, ᨸᨻᩩᨩ᩠ᨫᩥᨲ᩠ᩅᩣᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᩋᨴ᩠ᨴᩈᩣᩈᩥ ᩉᩁᩥᨲ [ᩉᩁᩦ (ᨸᩦ.)] ᩁᩩᨠ᩠ᨡᩮ, ᩈᨾᨶ᩠ᨲᩣ ᩋᨣ᩠ᨣᩥᨿᩣᨿᨶᩴ.

᪑᪒᪘.

‘‘ᨶᩅᨸᨲ᩠ᨲᩅᨶᩴ ᨹᩩᩃ᩠ᩃᩴ, ᨠᩮᩣᨠᩥᩃᨣ᩠ᨣᨱᨥᩮᩣᩈᩥᨲᩴ;

ᩈᨾᨶ᩠ᨲᩣ ᨸᩅᩥᩃᩮᩣᨠᩮᨲ᩠ᩅᩣ, ᩁᩩᨴᩴ ᩋᩔᩪᨶᩥ ᩅᨲ᩠ᨲᨿᩥ.

᪑᪒᪙.

‘‘ᨶ ¶ ᨩᩩᩉᩮ ᨶ ᨩᨸᩮ [ᨩᨸ᩠ᨸᩮ (ᨠ.)] ᨾᨶ᩠ᨲᩮ, ᩋᨣ᩠ᨣᩥᩉᩩᨲ᩠ᨲᩴ ᨸᩉᩣᨸᩥᨲᩴ;

ᨠᩮᩣ ᨶᩩ ᨾᩮ ᨸᩣᩁᩥᨧᩁᩥᨿᩣᨿ, ᨸᩩᨻ᩠ᨻᩮ ᨧᩥᨲ᩠ᨲᩴ ᨸᩃᩮᩣᨽᨿᩥ.

᪑᪓᪐.

‘‘ᩋᩁᨬ᩠ᨬᩮ ᨾᩮ ᩅᩥᩉᩁᨲᩮᩣ, ᨿᩮᩣ ᨾᩮ ᨲᩮᨩᩣ ᩉ ᩈᨾ᩠ᨽᩩᨲᩴ [ᩈᨾ᩠ᨽᨲᩴ (ᨸᩦ.)];

ᨶᩣᨶᩣᩁᨲ᩠ᨶᨸᩁᩥᨸᩪᩁᩴ, ᨶᩣᩅᩴᩅ ᨣᨱ᩠ᩉᩥ ᩋᨱ᩠ᨱᩅᩮ’’.

᪑᪓᪑.

‘‘ᩋᩉᩴ ᨲᩮ ᨸᩣᩁᩥᨧᩁᩥᨿᩣᨿ, ᨴᩮᩅᩁᩣᨩᩮᨶ ᨸᩮᩈᩥᨲᩣ;

ᩋᩅᨵᩥᩴ [ᩋᩅᨵᩦ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᨧᩥᨲ᩠ᨲᩴ ᨧᩥᨲ᩠ᨲᩮᨶ, ᨸᨾᩣᨴᩮᩣ [ᨸᨾᩣᨴᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨲ᩠ᩅᩴ ᨶ ᨻᩩᨩ᩠ᨫᩈᩥ’’.

᪑᪓᪒.

‘‘ᩍᨾᩣᨶᩥ ᨠᩥᩁ ᨾᩴ ᨲᩣᨲᩮᩣ, ᨠᩔᨸᩮᩣ ᩋᨶᩩᩈᩣᩈᨲᩥ;

ᨠᨾᩃᩣᩈᨴᩥᩈᩥᨲ᩠ᨳᩥᨿᩮᩣ [ᩈᩁᩥᩈᩥᨲ᩠ᨳᩥᨿᩮᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨲᩣᨿᩮᩣ ᨻᩩᨩ᩠ᨫᩮᩈᩥ ᨾᩣᨱᩅ.

᪑᪓᪓.

‘‘ᩏᩁᩮ ᨣᨱ᩠ᨯᩣᨿᩮᩣ ᨻᩩᨩ᩠ᨫᩮᩈᩥ, ᨲᩣᨿᩮᩣ ᨻᩩᨩ᩠ᨫᩮᩈᩥ ᨾᩣᨱᩅ;

ᩍᨧ᩠ᨧᩣᨶᩩᩈᩣᩈᩥ ᨾᩴ ᨲᩣᨲᩮᩣ, ᨿᨳᩣ ᨾᩴ ᩋᨶᩩᨠᨾ᩠ᨸᨠᩮᩣ.

᪑᪓᪔.

‘‘ᨲᩔᩣᩉᩴ ᩅᨧᨶᩴ ᨶᩣᨠᩴ, ᨸᩥᨲᩩ ᩅᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶᩴ;

ᩋᩁᨬ᩠ᨬᩮ ᨶᩥᨾ᩠ᨾᨶᩩᩔᨾ᩠ᩉᩥ, ᩈ᩠ᩅᨩ᩠ᨩ ᨫᩣᨿᩣᨾᩥ [ᩈ᩠ᩅᩣᨩ᩠ᨩᨩ᩠ᨫᩣᨿᩣᨾᩥ (ᩈᩦ. ᨸᩦ.)] ᩑᨠᨠᩮᩣ.

᪑᪓᪕.

‘‘ᩈᩮᩣᩉᩴ ¶ ᨲᨳᩣ ᨠᩁᩥᩔᩣᨾᩥ, ᨵᩥᩁᨲ᩠ᨳᩩ ᨩᩦᩅᩥᨲᩮᨶ ᨾᩮ;

ᨸᩩᨶ ᩅᩣ ᨲᩣᨴᩥᩈᩮᩣ ᩉᩮᩔᩴ, ᨾᩁᨱᩴ ᨾᩮ ᨽᩅᩥᩔᨲᩥ’’.

᪑᪓᪖.

‘‘ᨲᩔ ¶ ᨲᩮᨩᩴ [ᨲᩮᨩᨬ᩠ᨧ (ᩈᩦ. ᨸᩦ.)] ᩅᩦᩁᩥᨿᨬ᩠ᨧ, ᨵᩥᨲᩥᩴ [ᨵᩥᨲᩥᨬ᩠ᨧ (ᨸᩦ.)] ᨬᨲ᩠ᩅᩣ ᩋᩅᨭ᩠ᨮᩥᨲᩴ [ᩈᩩᩅᨯ᩠ᨰᩥᨲᩴ (ᩈᩦ.)];

ᩈᩥᩁᩈᩣ ᩋᨣ᩠ᨣᩉᩦ ᨸᩣᨴᩮ, ᩍᩈᩥᩈᩥᨦ᩠ᨣᩴ ᩋᩃᨾ᩠ᨻᩩᩈᩣ.

᪑᪓᪗.

‘‘ᨾᩣ ᨾᩮ ᨠᩩᨩ᩠ᨫ [ᨠᩩᨩ᩠ᨫᩥ (ᨸᩦ.)] ᨾᩉᩣᩅᩦᩁ, ᨾᩣ ᨾᩮ ᨠᩩᨩ᩠ᨫ [ᨠᩩᨩ᩠ᨫᩥ (ᨸᩦ.)] ᨾᩉᩣᩍᩈᩮ;

ᨾᩉᩣ ᩋᨲ᩠ᨳᩮᩣ ᨾᨿᩣ ᨧᩥᨱ᩠ᨱᩮᩣ, ᨲᩥᨴᩈᩣᨶᩴ ᨿᩈᩔᩥᨶᩴ;

ᨲᨿᩣ ᩈᩴᨠᨾ᩠ᨸᩥᨲᩴ ᩌᩈᩥ, ᩈᨻ᩠ᨻᩴ ᨴᩮᩅᨸᩩᩁᩴ ᨲᨴᩣ’’.

᪑᪓᪘.

‘‘ᨲᩣᩅᨲᩥᩴᩈᩣ ᨧ ᨿᩮ ᨴᩮᩅᩣ, ᨲᩥᨴᩈᩣᨶᨬ᩠ᨧ ᩅᩣᩈᩅᩮᩣ;

ᨲ᩠ᩅᨬ᩠ᨧ ᨽᨴ᩠ᨴᩮ ᩈᩩᨡᩦ ᩉᩮᩣᩉᩥ, ᨣᨧ᩠ᨨ ᨠᨬ᩠ᨬᩮ ᨿᨳᩣᩈᩩᨡᩴ’’.

᪑᪓᪙.

‘‘ᨲᩔ ᨸᩣᨴᩮ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᨠᨲ᩠ᩅᩣ ᨧ ᨶᩴ ᨸᨴᨠ᩠ᨡᩥᨱᩴ;

ᩋᨬ᩠ᨩᩃᩥᩴ ᨸᨣ᩠ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᨲᨾ᩠ᩉᩣ ᨮᩣᨶᩣ ᩋᨸᨠ᩠ᨠᨾᩥ.

᪑᪔᪐.

‘‘ᨿᩮᩣ ᨧ ᨲᩔᩣᩈᩥ ᨸᩃ᩠ᩃᨦ᩠ᨠᩮᩣ, ᩈᩮᩣᩅᨱ᩠ᨱᩮᩣ ᩈᩮᩣᨸᩅᩣᩉᨶᩮᩣ;

ᩈᩏᨲ᩠ᨲᩁᨧ᩠ᨨᨴᨸᨬ᩠ᨬᩣᩈᩮᩣ, ᩈᩉᩔᨸᨭᩥᨿᨲ᩠ᨳᨲᩮᩣ;

ᨲᨾᩮᩅ ᨸᩃ᩠ᩃᨦ᩠ᨠᨾᩣᩁᩩᨿ᩠ᩉ, ᩋᨣᩣ ᨴᩮᩅᩣᨶ ᩈᨶ᩠ᨲᩥᨠᩮ.

᪑᪔᪑.

‘‘ᨲᨾᩮᩣᨠ᩠ᨠᨾᩥᩅ ᩌᨿᨶ᩠ᨲᩥᩴ, ᨩᩃᨶ᩠ᨲᩥᩴ ᩅᩥᨩ᩠ᨩᩩᨲᩴ ᨿᨳᩣ;

ᨸᨲᩦᨲᩮᩣ ᩈᩩᨾᨶᩮᩣ ᩅᩥᨲ᩠ᨲᩮᩣ, ᨴᩮᩅᩥᨶ᩠ᨴᩮᩣ ᩋᨴᨴᩣ ᩅᩁᩴ’’.

᪑᪔᪒.

‘‘ᩅᩁᨬ᩠ᨧᩮ ¶ ᨾᩮ ᩋᨴᩮᩣ ᩈᨠ᩠ᨠ, ᩈᨻ᩠ᨻᨽᩪᨲᩣᨶᨾᩥᩔᩁ;

ᨶᩥᩈᩥᨸ᩠ᨸᩃᩮᩣᨽᩥᨠᩣ [ᨶ ᩍᩈᩥᨸᩃᩮᩣᨽᩥᨠᩣ (ᩈ᩠ᨿᩣ.), ᨶ ᩍᩈᩥᨸᩃᩮᩣᨽᩥᨿᩴ (ᨸᩦ.)] ᨣᨧ᩠ᨨᩮ, ᩑᨲᩴ ᩈᨠ᩠ᨠ ᩅᩁᩴ ᩅᩁᩮ’’ᨲᩥ.

ᩋᩃᨾ᩠ᨻᩩᩈᩣᨩᩣᨲᨠᩴ ᨲᨲᩥᨿᩴ.

᪕᪒᪔. ᩈᨦ᩠ᨡᨸᩣᩃᨩᩣᨲᨠᩴ (᪔)

᪑᪔᪓.

‘‘ᩋᩁᩥᨿᩣᩅᨠᩣᩈᩮᩣᩈᩥ ᨸᩈᨶ᩠ᨶᨶᩮᨲ᩠ᨲᩮᩣ, ᨾᨬ᩠ᨬᩮ ¶ ᨽᩅᩴ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ ᨠᩩᩃᨾ᩠ᩉᩣ;

ᨠᨳᩴ ᨶᩩ ᩅᩥᨲ᩠ᨲᩣᨶᩥ ᨸᩉᩣᨿ ᨽᩮᩣᨣᩮ, ᨸᨻ᩠ᨻᨩᩥ ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ ᨥᩁᩣ ᩈᨸᨬ᩠ᨬ’’ [ᩈᨸᨬ᩠ᨬᩮᩣ (ᩈ᩠ᨿᩣ.), ᩈᨸᨬ᩠ᨬᩣ (ᨸᩦ.)].

᪑᪔᪔.

‘‘ᩈᨿᩴ ¶ ᩅᩥᨾᩣᨶᩴ ᨶᩁᨴᩮᩅ ᨴᩥᩈ᩠ᩅᩣ, ᨾᩉᩣᨶᩩᨽᩣᩅᩔ ᨾᩉᩮᩣᩁᨣᩔ;

ᨴᩥᩈ᩠ᩅᩣᨶ ᨸᩩᨬ᩠ᨬᩣᨶ ᨾᩉᩣᩅᩥᨸᩣᨠᩴ, ᩈᨴ᩠ᨵᩣᨿᩉᩴ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣᨾ᩠ᩉᩥ ᩁᩣᨩ’’.

᪑᪔᪕.

‘‘ᨶ ᨠᩣᨾᨠᩣᨾᩣ ᨶ ᨽᨿᩣ ᨶ ᨴᩮᩣᩈᩣ, ᩅᩣᨧᩴ ᨾᩩᩈᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩣ ᨽᨱᨶ᩠ᨲᩥ;

ᩋᨠ᩠ᨡᩣᩉᩥ ᨾᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᩑᨲᨾᨲ᩠ᨳᩴ, ᩈᩩᨲ᩠ᩅᩣᨶ ᨾᩮ ᨩᩣᨿᩥᩉᩥᨲᩥᨸ᩠ᨸᩈᩣᨴᩮᩣ’’.

᪑᪔᪖.

‘‘ᩅᩣᨱᩥᨩ᩠ᨩ [ᩅᨱᩥᨩ᩠ᨩ (ᨸᩦ.)] ᩁᨭ᩠ᨮᩣᨵᩥᨸ ᨣᨧ᩠ᨨᨾᩣᨶᩮᩣ, ᨸᨳᩮ ᩋᨴ᩠ᨴᩈᩣᩈᩥᨾ᩠ᩉᩥ ᨽᩮᩣᨩᨸᩩᨲ᩠ᨲᩮ [ᨾᩥᩃᩣᨧᨸᩩᨲ᩠ᨲᩮ (ᩈᩦ. ᨸᩦ.)];

ᨸᩅᨴ᩠ᨵᨠᩣᨿᩴ ᩏᩁᨣᩴ ᨾᩉᨶ᩠ᨲᩴ, ᩌᨴᩣᨿ ᨣᨧ᩠ᨨᨶ᩠ᨲᩮ ᨸᨾᩮᩣᨴᨾᩣᨶᩮ’’.

᪑᪔᪗.

‘‘ᩈᩮᩣᩉᩴ ᩈᨾᩣᨣᨾ᩠ᨾ ᨩᨶᩥᨶ᩠ᨴ ᨲᩮᩉᩥ, ᨸᩉᨭ᩠ᨮᩃᩮᩣᨾᩮᩣ ᩋᩅᨧᨾ᩠ᩉᩥ ᨽᩦᨲᩮᩣ;

ᨠᩩᩉᩥᩴ ᩋᨿᩴ ᨶᩦᨿᨲᩥ [ᨶᩥᨿ᩠ᨿᨲᩥ (ᨠ.)] ᨽᩦᨾᨠᩣᨿᩮᩣ, ᨶᩣᨣᩮᨶ ᨠᩥᩴ ᨠᩣᩉᨳ ᨽᩮᩣᨩᨸᩩᨲ᩠ᨲᩣ.

᪑᪔᪘.

‘‘ᨶᩣᨣᩮᩣ ᩋᨿᩴ ᨶᩦᨿᨲᩥ ᨽᩮᩣᨩᨶᨲ᩠ᨳᩣ [ᨽᩮᩣᨩᨶᨲ᩠ᨳᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨸᩅᨴ᩠ᨵᨠᩣᨿᩮᩣ ¶ ᩏᩁᨣᩮᩣ ᨾᩉᨶ᩠ᨲᩮᩣ;

ᩈᩣᨴᩩᨬ᩠ᨧ ᨳᩪᩃᨬ᩠ᨧ ᨾᩩᨴᩩᨬ᩠ᨧ ᨾᩴᩈᩴ, ᨶ ᨲ᩠ᩅᩴ ᩁᩈᨬ᩠ᨬᩣᩈᩥ ᩅᩥᨴᩮᩉᨸᩩᨲ᩠ᨲ.

᪑᪔᪙.

‘‘ᩍᨲᩮᩣ ᨾᨿᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᩈᨠᩴ ᨶᩥᨠᩮᨲᩴ [ᨶᩥᨠᩮᨲᨶᩴ (ᨸᩦ.)], ᩌᨴᩣᨿ ᩈᨲ᩠ᨳᩣᨶᩥ ᩅᩥᨠᩮᩣᨸᨿᩥᨲ᩠ᩅᩣ;

ᨾᩴᩈᩣᨶᩥ ᨽᩮᩣᨠ᩠ᨡᩣᨾ [ᨽᨠ᩠ᨡᩣᨾ (ᩈ᩠ᨿᩣ.)] ᨸᨾᩮᩣᨴᨾᩣᨶᩣ, ᨾᨿᨬ᩠ᩉᩥ ᩅᩮ ᩈᨲ᩠ᨲᩅᩮᩣ ᨸᨶ᩠ᨶᨣᩣᨶᩴ.

᪑᪕᪐.

‘‘ᩈᨧᩮ ᩋᨿᩴ ᨶᩦᨿᨲᩥ ᨽᩮᩣᨩᨶᨲ᩠ᨳᩣ, ᨸᩅᨴ᩠ᨵᨠᩣᨿᩮᩣ ᩏᩁᨣᩮᩣ ᨾᩉᨶ᩠ᨲᩮᩣ;

ᨴᨴᩣᨾᩥ ᩅᩮᩣ ᨻᩃᩥᨻᨴ᩠ᨴᩣᨶᩥ [ᨻᩃᩥᩅᨴ᩠ᨴᩣᨶᩥ (ᨸᩦ.)] ᩈᩮᩣᩊᩈ, ᨶᩣᨣᩴ ᩍᨾᩴ ᨾᩩᨬ᩠ᨧᨳ ᨻᨶ᩠ᨵᨶᩈ᩠ᨾᩣ.

᪑᪕᪑.

‘‘ᩋᨴ᩠ᨵᩣ ¶ ᩉᩥ ᨶᩮᩣ ᨽᨠ᩠ᨡᩮᩣ ᩋᨿᩴ ᨾᨶᩣᨸᩮᩣ, ᨻᩉᩪ ᨧ ᨶᩮᩣ ᩏᩁᨣᩣ ᨽᩩᨲ᩠ᨲᨸᩩᨻ᩠ᨻᩣ [ᨻᩉᩩᩴ ᨧ ᨶᩮᩣ ᩏᩁᨣᩮᩣ ᨽᩩᨲ᩠ᨲᨸᩩᨻ᩠ᨻᩮᩣ (ᨠ.)];

ᨠᩁᩮᩣᨾ ᨲᩮ ᨲᩴ ᩅᨧᨶᩴ ᩋᩊᩣᩁ [ᩌᩊᩣᩁ (ᨠ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ], ᨾᩥᨲ᩠ᨲᨬ᩠ᨧ ᨶᩮᩣ ᩉᩮᩣᩉᩥ ᩅᩥᨴᩮᩉᨸᩩᨲ᩠ᨲ.

᪑᪕᪒.

‘‘ᨲᨴᩔᩩ ᨲᩮ ᨻᨶ᩠ᨵᨶᩣ ᨾᩮᩣᨧᨿᩥᩴᩈᩩ, ᨿᩴ ᨶᨲ᩠ᨳᩩᨲᩮᩣ ᨸᨭᩥᨾᩮᩣᨠ᩠ᨠᩔ ᨸᩣᩈᩮ;

ᨾᩩᨲ᩠ᨲᩮᩣ ᨧ ᩈᩮᩣ ᨻᨶ᩠ᨵᨶᩣ ᨶᩣᨣᩁᩣᨩᩣ, ᨸᨠ᩠ᨠᩣᨾᩥ ᨸᩣᨧᩦᨶᨾᩩᨡᩮᩣ ᨾᩩᩉᩩᨲ᩠ᨲᩴ.

᪑᪕᪓.

‘‘ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨸᩣᨧᩦᨶᨾᩩᨡᩮᩣ ᨾᩩᩉᩩᨲ᩠ᨲᩴ, ᨸᩩᨱ᩠ᨱᩮᩉᩥ ¶ ᨶᩮᨲ᩠ᨲᩮᩉᩥ ᨸᩃᩮᩣᨠᨿᩦ ᨾᩴ;

ᨲᨴᩣᩔᩉᩴ ᨸᩥᨭ᩠ᨮᩥᨲᩮᩣ ᩋᨶ᩠ᩅᨣᨧ᩠ᨨᩥᩴ, ᨴᩈᨦ᩠ᨣᩩᩃᩥᩴ ᩋᨬ᩠ᨩᩃᩥᩴ ᨸᨣ᩠ᨣᩉᩮᨲ᩠ᩅᩣ.

᪑᪕᪔.

‘‘ᨣᨧ᩠ᨨᩮᩅ ¶ ᨡᩮᩣ ᨲ᩠ᩅᩴ ᨲᩁᨾᩣᨶᩁᩪᨸᩮᩣ, ᨾᩣ ᨲᩴ ᩋᨾᩥᨲ᩠ᨲᩣ ᨸᩩᨶᩁᨣ᩠ᨣᩉᩮᩈᩩᩴ;

ᨴᩩᨠ᩠ᨡᩮᩣ ᩉᩥ ᩃᩩᨴ᩠ᨴᩮᩉᩥ ᨸᩩᨶᩣ ᩈᨾᩣᨣᨾᩮᩣ, ᩋᨴᩔᨶᩴ ᨽᩮᩣᨩᨸᩩᨲ᩠ᨲᩣᨶ ᨣᨧ᩠ᨨ.

᪑᪕᪕.

‘‘ᩋᨣᨾᩣᩈᩥ ᩈᩮᩣ ᩁᩉᨴᩴ ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩴ, ᨶᩦᩃᩮᩣᨽᩣᩈᩴ ᩁᨾᨱᩦᨿᩴ ᩈᩩᨲᩥᨲ᩠ᨳᩴ;

ᩈᨾᩮᩣᨲᨲᩴ [ᩈᨾᩮᩣᨶᨲᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨩᨾ᩠ᨻᩩᩉᩥ ᩅᩮᨲᩈᩣᩉᩥ, ᨸᩣᩅᩮᨠ᩠ᨡᩥ ᨶᩥᨲ᩠ᨲᩥᨱ᩠ᨱᨽᨿᩮᩣ ᨸᨲᩦᨲᩮᩣ.

᪑᪕᪖.

‘‘ᩈᩮᩣ ᨲᩴ ᨸᩅᩥᩔ ᨶ ᨧᩥᩁᩔ ᨶᩣᨣᩮᩣ, ᨴᩥᨻ᩠ᨻᩮᨶ ᨾᩮ ᨸᩣᨲᩩᩁᩉᩩᩴ ᨩᨶᩥᨶ᩠ᨴ;

ᩏᨸᨭ᩠ᨮᩉᩦ ᨾᩴ ᨸᩥᨲᩁᩴᩅ ᨸᩩᨲ᩠ᨲᩮᩣ, ᩉᨴᨿᨦ᩠ᨣᨾᩴ ᨠᨱ᩠ᨱᩈᩩᨡᩴ ᨽᨱᨶ᩠ᨲᩮᩣ.

᪑᪕᪗.

‘‘ᨲ᩠ᩅᩴ ¶ ᨾᩮᩈᩥ ᨾᩣᨲᩣ ᨧ ᨸᩥᨲᩣ [ᨸᩥᨲᩣ ᨧ (ᨸᩦ.)] ᩋᩊᩣᩁ, ᩋᨻ᩠ᨽᨶ᩠ᨲᩁᩮᩣ ᨸᩣᨱᨴᨴᩮᩣ ᩈᩉᩣᨿᩮᩣ;

ᩈᨠᨬ᩠ᨧ ᩍᨴ᩠ᨵᩥᩴ ᨸᨭᩥᩃᩣᨽᨠᩮᩣᩈ᩠ᨾᩥ [ᨸᨭᩥᩃᩣᨽᩥᨲᩮᩣᩈ᩠ᨾᩥ (ᨸᩦ.)], ᩋᩊᩣᩁ ᨸᩔ ᨾᩮ ᨶᩥᩅᩮᩈᨶᩣᨶᩥ;

ᨸᩉᩪᨲᨽᨠ᩠ᨡᩴ ᨻᩉᩩᩋᨶ᩠ᨶᨸᩣᨶᩴ, ᨾᩈᨠ᩠ᨠᩈᩣᩁᩴ ¶ ᩅᩥᨿ ᩅᩣᩈᩅᩔ’’.

᪑᪕᪘.

‘‘ᨲᩴ ᨽᩪᨾᩥᨽᩣᨣᩮᩉᩥ ᩏᨸᩮᨲᩁᩪᨸᩴ, ᩋᩈᨠ᩠ᨡᩁᩣ ᨧᩮᩅ ᨾᩩᨴᩪ ᩈᩩᨽᩣ ᨧ;

ᨶᩦᨧᨲ᩠ᨲᩥᨱᩣ [ᨶᩦᨧᩣ ᨲᩥᨱᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩋᨸ᩠ᨸᩁᨩᩣ ᨧ ᨽᩪᨾᩥ, ᨸᩣᩈᩣᨴᩥᨠᩣ ᨿᨲ᩠ᨳ ᨩᩉᨶ᩠ᨲᩥ ᩈᩮᩣᨠᩴ.

᪑᪕᪙.

‘‘ᩋᨶᩣᩅᨠᩩᩃᩣ ᩅᩮᩊᩩᩁᩥᨿᩪᨸᨶᩦᩃᩣ, ᨧᨲᩩᨴ᩠ᨴᩥᩈᩴ ᩋᨾ᩠ᨻᩅᨶᩴ ᩈᩩᩁᨾ᩠ᨾᩴ;

ᨸᨠ᩠ᨠᩣ ᨧ ᨸᩮᩈᩦ ᨧ ᨹᩃᩣ ᩈᩩᨹᩩᩃ᩠ᩃᩣ, ᨶᩥᨧ᩠ᨧᩮᩣᨲᩩᨠᩣ ᨵᩣᩁᨿᨶ᩠ᨲᩦ ᨹᩃᩣᨶᩥ.

᪑᪖᪐.

‘‘ᨲᩮᩈᩴ ᩅᨶᩣᨶᩴ ᨶᩁᨴᩮᩅ ᨾᨩ᩠ᨫᩮ, ᨶᩥᩅᩮᩈᨶᩴ ᨽᩔᩁᩈᨶ᩠ᨶᩥᨠᩣᩈᩴ;

ᩁᨩᨲᨣ᩠ᨣᩊᩴ ᩈᩮᩣᩅᨱ᩠ᨱᨾᨿᩴ ᩏᩊᩣᩁᩴ, ᩒᨽᩣᩈᨲᩦ ᩅᩥᨩ᩠ᨩᩩᩁᩥᩅᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ.

᪑᪖᪑.

‘‘ᨾᨱᩦᨾᨿᩣ ᩈᩮᩣᨱ᩠ᨱᨾᨿᩣ [ᩈᩮᩣᩅᨱ᩠ᨱᨾᨿᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩏᩊᩣᩁᩣ, ᩋᨶᩮᨠᨧᩥᨲ᩠ᨲᩣ ᩈᨲᨲᩴ ᩈᩩᨶᩥᨾ᩠ᨾᩥᨲᩣ;

ᨸᩁᩥᨸᩪᩁᩣ ᨠᨬ᩠ᨬᩣᩉᩥ ᩋᩃᨦ᩠ᨠᨲᩣᨽᩥ, ᩈᩩᩅᨱ᩠ᨱᨠᩣᨿᩪᩁᨵᩁᩣᩉᩥ ᩁᩣᨩ.

᪑᪖᪒.

‘‘ᩈᩮᩣ ᩈᨦ᩠ᨡᨸᩣᩃᩮᩣ ᨲᩁᨾᩣᨶᩁᩪᨸᩮᩣ, ᨸᩣᩈᩣᨴᨾᩣᩁᩩᨿ᩠ᩉ ᩋᨶᩮᩣᨾᩅᨱ᩠ᨱᩮᩣ;

ᩈᩉᩔᨳᨾ᩠ᨽᩴ ᩋᨲᩩᩃᩣᨶᩩᨽᩣᩅᩴ, ᨿᨲ᩠ᨳᩔ ¶ ᨽᩁᩥᨿᩣ ᨾᩉᩮᩈᩦ ᩋᩉᩮᩣᩈᩥ.

᪑᪖᪓.

‘‘ᩑᨠᩣ ¶ ᨧ ᨶᩣᩁᩦ ᨲᩁᨾᩣᨶᩁᩪᨸᩣ, ᩌᨴᩣᨿ ᩅᩮᩊᩩᩁᩥᨿᨾᨿᩴ ᨾᩉᨣ᩠ᨥᩴ;

ᩈᩩᨽᩴ ᨾᨱᩥᩴ ᨩᩣᨲᩥᨾᨶ᩠ᨲᩪᨸᨸᨶ᩠ᨶᩴ, ᩋᨧᩮᩣᨴᩥᨲᩣ ᩌᩈᨶᨾᨻ᩠ᨽᩥᩉᩣᩈᩥ.

᪑᪖᪔.

‘‘ᨲᨲᩮᩣ ᨾᩴ ᩏᩁᨣᩮᩣ ᩉᨲ᩠ᨳᩮ ᨣᩉᩮᨲ᩠ᩅᩣ, ᨶᩥᩈᩦᨴᨿᩦ ᨸᩣᨾᩩᨡᩌᩈᨶᩈ᩠ᨾᩥᩴ;

ᩍᨴᨾᩣᩈᨶᩴ ᩋᨲᩕ ᨽᩅᩴ ᨶᩥᩈᩦᨴᨲᩩ, ᨽᩅᨬ᩠ᩉᩥ ᨾᩮ ᩋᨬ᩠ᨬᨲᩁᩮᩣ ᨣᩁᩪᨶᩴ.

᪑᪖᪕.

‘‘ᩋᨬ᩠ᨬᩣ ᨧ ᨶᩣᩁᩦ ᨲᩁᨾᩣᨶᩁᩪᨸᩣ, ᩌᨴᩣᨿ ᩅᩣᩁᩥᩴ ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ;

ᨸᩣᨴᩣᨶᩥ ᨸᨠ᩠ᨡᩣᩃᨿᩦ ᨾᩮ ᨩᨶᩥᨶ᩠ᨴ, ᨽᩁᩥᨿᩣᩅ [ᨽᩁᩥᨿᩣ ᨧ (ᨸᩦ.)] ᨽᨲ᩠ᨲᩪ ᨸᨲᩥᨶᩮᩣ ᨸᩥᨿᩔ.

᪑᪖᪖.

‘‘ᩋᨸᩁᩣ ᨧ ᨶᩣᩁᩦ ᨲᩁᨾᩣᨶᩁᩪᨸᩣ, ᨸᨣ᩠ᨣᨿ᩠ᩉ ᩈᩮᩣᩅᨱ᩠ᨱᨾᨿᩣᨿ [ᩈᩮᩣᩅᨱ᩠ᨱᨾᨿᩣ (ᨸᩦ.)] ᨸᩣᨲᩥᨿᩣ;

ᩋᨶᩮᨠᩈᩪᨸᩴ ᩅᩥᩅᩥᨵᩴ ᩅᩥᨿᨬ᩠ᨩᨶᩴ, ᩏᨸᨶᩣᨾᨿᩦ ᨽᨲ᩠ᨲ ᨾᨶᩩᨬ᩠ᨬᩁᩪᨸᩴ.

᪑᪖᪗.

‘‘ᨲᩩᩁᩥᨿᩮᩉᩥ [ᨲᩪᩁᩥᨿᩮᩉᩥ (ᨠ.)] ᨾᩴ ᨽᩣᩁᨲ ᨽᩩᨲ᩠ᨲᩅᨶ᩠ᨲᩴ, ᩏᨸᨭ᩠ᨮᩉᩩᩴ ᨽᨲ᩠ᨲᩩ ᨾᨶᩮᩣ ᩅᩥᨴᩥᨲ᩠ᩅᩣ;

ᨲᨲᩩᨲ᩠ᨲᩁᩥᩴ [ᨲᨴᩩᨲ᩠ᨲᩁᩥᩴ (ᨠ.)] ᨾᩴ ᨶᩥᨸᨲᩦ ᨾᩉᨶ᩠ᨲᩴ, ᨴᩥᨻ᩠ᨻᩮᩉᩥ ¶ ᨠᩣᨾᩮᩉᩥ ᩋᨶᨸ᩠ᨸᨠᩮᩉᩥ.

᪑᪖᪘.

‘‘ᨽᩁᩥᨿᩣ ¶ ᨾᨾᩮᨲᩣ ᨲᩥᩈᨲᩣ ᩋᩊᩣᩁ, ᩈᨻ᩠ᨻᨲ᩠ᨲᨾᨩ᩠ᨫᩣ ᨸᨴᩩᨾᩩᨲ᩠ᨲᩁᩣᨽᩣ;

ᩋᩊᩣᩁ ᩑᨲᩣᩔᩩ ᨲᩮ ᨠᩣᨾᨠᩣᩁᩣ, ᨴᨴᩣᨾᩥ ᨲᩮ ᨲᩣ ᨸᩁᩥᨧᩣᩁᨿᩔᩩ.

᪑᪖᪙.

‘‘ᩈᩴᩅᨧ᩠ᨨᩁᩴ ᨴᩥᨻ᩠ᨻᩁᩈᩣᨶᩩᨽᩩᨲ᩠ᩅᩣ, ᨲᨴᩣᩔᩩᩉᩴ [ᨲᨴᩔᩉᩴ (ᨸᩦ.)] ᩏᨲ᩠ᨲᩁᩥᨾᨩ᩠ᨫᨽᩣᩈᩥᩴ [ᩏᨲ᩠ᨲᩁᩥ ᨸᨧ᩠ᨧᨽᩣᩈᩥᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩏᨲ᩠ᨲᩁᩥᩴ ᨸᨧ᩠ᨧᨽᩣᩈᩥᩴ (ᨸᩦ.)];

ᨶᩣᨣᩔᩥᨴᩴ ᨠᩥᨶ᩠ᨲᩥ ᨠᨳᨬ᩠ᨧ ᩃᨴ᩠ᨵᩴ, ᨠᨳᨩ᩠ᨫᨣᨾᩣᩈᩥ ᩅᩥᨾᩣᨶᩈᩮᨭ᩠ᨮᩴ’’.

᪑᪗᪐.

‘‘ᩋᨵᩥᨧ᩠ᨧ ¶ ᩃᨴ᩠ᨵᩴ ᨸᩁᩥᨱᩣᨾᨩᩴ ᨲᩮ, ᩈᨿᩴᨠᨲᩴ ᩏᨴᩣᩉᩩ ᨴᩮᩅᩮᩉᩥ ᨴᩥᨶ᩠ᨶᩴ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ [ᨲᩮ (ᨸᩦ.)] ᨶᩣᨣᩁᩣᨩᩮᨲᨾᨲ᩠ᨳᩴ, ᨠᨳᨩ᩠ᨫᨣᨾᩣᩈᩥ ᩅᩥᨾᩣᨶᩈᩮᨭ᩠ᨮᩴ’’.

᪑᪗᪑.

‘‘ᨶᩣᨵᩥᨧ᩠ᨧ ᩃᨴ᩠ᨵᩴ ᨶ ᨸᩁᩥᨱᩣᨾᨩᩴ ᨾᩮ, ᨶ ᩈᨿᩴᨠᨲᩴ ᨶᩣᨸᩥ ᨴᩮᩅᩮᩉᩥ ᨴᩥᨶ᩠ᨶᩴ;

ᩈᨠᩮᩉᩥ ᨠᨾ᩠ᨾᩮᩉᩥ ᩋᨸᩣᨸᨠᩮᩉᩥ, ᨸᩩᨬ᩠ᨬᩮᩉᩥ ᨾᩮ ᩃᨴ᩠ᨵᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ’’.

᪑᪗᪒.

‘‘ᨠᩥᩴ ᨲᩮ ᩅᨲᩴ ᨠᩥᩴ ᨸᨶ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᨠᩥᩔ ᩈᩩᨧᩥᨱ᩠ᨱᩔ ᩋᨿᩴ ᩅᩥᨸᩣᨠᩮᩣ;

ᩋᨠ᩠ᨡᩣᩉᩥ ᨾᩮ ᨶᩣᨣᩁᩣᨩᩮᨲᨾᨲ᩠ᨳᩴ, ᨠᨳᩴ ¶ ᨶᩩ ᨲᩮ ᩃᨴ᩠ᨵᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ’’.

᪑᪗᪓.

‘‘ᩁᩣᨩᩣ ᩋᩉᩮᩣᩈᩥᩴ ᨾᨣᨵᩣᨶᨾᩥᩔᩁᩮᩣ, ᨴᩩᨿ᩠ᨿᩮᩣᨵᨶᩮᩣ ᨶᩣᨾ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ;

ᩈᩮᩣ ᩍᨲ᩠ᨲᩁᩴ ᨩᩦᩅᩥᨲᩴ ᩈᩴᩅᩥᨴᩥᨲ᩠ᩅᩣ, ᩋᩈᩔᨲᩴ ᩅᩥᨸᩁᩥᨱᩣᨾᨵᨾ᩠ᨾᩴ.

᪑᪗᪔.

‘‘ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᩣᩈᩥᩴ [ᩋᨴᩣᩈᩥ (ᨸᩦ.)];

ᩒᨸᩣᨶᨽᩪᨲᩴ ᨾᩮ ᨥᩁᩴ ᨲᨴᩣᩈᩥ, ᩈᨶ᩠ᨲᨸ᩠ᨸᩥᨲᩣ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨧ.

᪑᪗᪕.

[ᩋᨿᩴ ᨣᩣᨳᩣ ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮ ᨶᨲ᩠ᨳᩥ] ‘‘ᨾᩣᩃᨬ᩠ᨧ ᨣᨶ᩠ᨵᨬ᩠ᨧ ᩅᩥᩃᩮᨸᨶᨬ᩠ᨧ, ᨸᨴᩦᨸᩥᨿᩴ [ᨸᨴᩦᨸᨿᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨿᩣᨶᨾᩩᨸᩔᨿᨬ᩠ᨧ;

ᩋᨧ᩠ᨨᩣᨴᨶᩴ ᩈᩮᨿ᩠ᨿᨾᨳᨶ᩠ᨶᨸᩣᨶᩴ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩣᨶᩥ ᩋᨴᨾ᩠ᩉ ᨲᨲ᩠ᨳ [ᩋᨿᩴ ᨣᩣᨳᩣ ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮ ᨶᨲ᩠ᨳᩥ].

᪑᪗᪖.

‘‘ᨲᩴ ¶ ᨾᩮ ᩅᨲᩴ ᨲᩴ ᨸᨶ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᨲᩔ ᩈᩩᨧᩥᨱ᩠ᨱᩔ ᩋᨿᩴ ᩅᩥᨸᩣᨠᩮᩣ;

ᨲᩮᨶᩮᩅ ᨾᩮ ᩃᨴ᩠ᨵᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᨸᩉᩪᨲᨽᨠ᩠ᨡᩴ ᨻᩉᩩᩋᨶ᩠ᨶᨸᩣᨶᩴ’’;

‘‘ᨶᨧ᩠ᨧᩮᩉᩥ ᨣᩦᨲᩮᩉᩥ ᨧᩩᨸᩮᨲᩁᩪᨸᩴ, ᨧᩥᩁᨭ᩠ᨮᩥᨲᩥᨠᩴ ᨶ ᨧ ᩈᩔᨲᩣᨿᩴ.

᪑᪗᪗.

‘‘ᩋᨸ᩠ᨸᩣᨶᩩᨽᩣᩅᩣ ᨲᩴ ᨾᩉᩣᨶᩩᨽᩣᩅᩴ, ᨲᩮᨩᩔᩥᨶᩴ ¶ ᩉᨶ᩠ᨲᩥ ᩋᨲᩮᨩᩅᨶ᩠ᨲᩮᩣ;

ᨠᩥᨾᩮᩅ ᨴᩣᨮᩣᩅᩩᨵ ᨠᩥᩴ ᨸᨭᩥᨧ᩠ᨧ, ᩉᨲ᩠ᨳᨲ᩠ᨲ [ᩉᨲ᩠ᨳᨲ᩠ᨳ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩣᨣᨧ᩠ᨨᩥ ᩅᨶᩥᨻ᩠ᨻᨠᩣᨶᩴ [ᩅᨱᩥᨻ᩠ᨻᨠᩣᨶᩴ (ᩈᩦ.)].

᪑᪗᪘.

‘‘ᨽᨿᩴ ᨶᩩ ᨲᩮ ᩋᨶ᩠ᩅᨣᨲᩴ ᨾᩉᨶ᩠ᨲᩴ, ᨲᩮᨩᩮᩣ ᨶᩩ ᨲᩮ ᨶᩣᨶ᩠ᩅᨣᩴ ᨴᨶ᩠ᨲᨾᩪᩃᩴ;

ᨠᩥᨾᩮᩅ ᨴᩣᨮᩣᩅᩩᨵ ᨠᩥᩴ ᨸᨭᩥᨧ᩠ᨧ, ᨠᩥᩃᩮᩈᨾᩣᨸᨩ᩠ᨩᩥ ᩅᨶᩥᨻ᩠ᨻᨠᩣᨶᩴ’’.

᪑᪗᪙.

‘‘ᨶ ᨾᩮ ᨽᨿᩴ ᩋᨶ᩠ᩅᨣᨲᩴ ᨾᩉᨶ᩠ᨲᩴ, ᨲᩮᨩᩮᩣ ᨶ ᩈᨠ᩠ᨠᩣ ᨾᨾ ᨲᩮᩉᩥ ᩉᨶ᩠ᨲᩩᩴ [ᨲᩮᨽᩥᩉᨶ᩠ᨲᩩᩴ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩣᨶᩥ ᩈᩩᨠᩥᨲ᩠ᨲᩥᨲᩣᨶᩥ, ᩈᨾᩩᨴ᩠ᨴᩅᩮᩃᩣᩅ ᨴᩩᩁᨧ᩠ᨧᨿᩣᨶᩥ.

᪑᪘᪐.

‘‘ᨧᩣᨲᩩᨴ᩠ᨴᩈᩥᩴ ᨸᨬ᩠ᨧᨴᩈᩥᩴ ᩋᩊᩣᩁ, ᩏᨸᩮᩣᩈᨳᩴ ᨶᩥᨧ᩠ᨧᨾᩩᨸᩣᩅᩈᩣᨾᩥ;

ᩋᨳᩣᨣᨾᩩᩴ ᩈᩮᩣᩊᩈ ᨽᩮᩣᨩᨸᩩᨲ᩠ᨲᩣ, ᩁᨩ᩠ᨩᩩᩴ ᨣᩉᩮᨲ᩠ᩅᩣᨶ ᨴᩊ᩠ᩉᨬ᩠ᨧ ᨸᩣᩈᩴ.

᪑᪘᪑.

‘‘ᨽᩮᨲ᩠ᩅᩣᨶ ᨶᩣᩈᩴ ᩋᨲᩥᨠᩔ [ᩋᨶ᩠ᨲᨠᩔ (ᨠ.)] ᩁᨩ᩠ᨩᩩᩴ, ᨶᨿᩥᩴᩈᩩ ᨾᩴ ᩈᨾ᩠ᨸᩁᩥᨣᨿ᩠ᩉ ᩃᩩᨴ᩠ᨴᩣ;

ᩑᨲᩣᨴᩥᩈᩴ ᨴᩩᨠ᩠ᨡᨾᩉᩴ ᨲᩥᨲᩥᨠ᩠ᨡᩴ [ᨲᩥᨲᩥᨠ᩠ᨡᩥᩴ (ᨸᩦ.)], ᩏᨸᩮᩣᩈᨳᩴ ᩋᨸ᩠ᨸᨭᩥᨠᩮᩣᨸᨿᨶ᩠ᨲᩮᩣ’’.

᪑᪘᪒.

‘‘ᩑᨠᩣᨿᨶᩮ ¶ ¶ ᨲᩴ ᨸᨳᩮ ᩋᨴ᩠ᨴᩈᩴᩈᩩ, ᨻᩃᩮᨶ ¶ ᩅᨱ᩠ᨱᩮᨶ ᨧᩩᨸᩮᨲᩁᩪᨸᩴ;

ᩈᩥᩁᩥᨿᩣ ᨸᨬ᩠ᨬᩣᨿ ᨧ ᨽᩣᩅᩥᨲᩮᩣᩈᩥ, ᨠᩥᩴ ᨸᨲ᩠ᨳᨿᩴ [ᨠᩥᨾᨲ᩠ᨳᩥᨿᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨶᩣᨣ ᨲᨸᩮᩣ ᨠᩁᩮᩣᩈᩥ.

᪑᪘᪓.

‘‘ᨶ ᨸᩩᨲ᩠ᨲᩉᩮᨲᩪ ᨶ ᨵᨶᩔ ᩉᩮᨲᩩ, ᨶ ᩌᨿᩩᨶᩮᩣ ᨧᩣᨸᩥ ᩋᩊᩣᩁ ᩉᩮᨲᩩ;

ᨾᨶᩩᩔᨿᩮᩣᨶᩥᩴ ᩋᨽᩥᨸᨲ᩠ᨳᨿᩣᨶᩮᩣ, ᨲᩈ᩠ᨾᩣ ᨸᩁᨠ᩠ᨠᨾ᩠ᨾ ᨲᨸᩮᩣ ᨠᩁᩮᩣᨾᩥ’’.

᪑᪘᪔.

‘‘ᨲ᩠ᩅᩴ ᩃᩮᩣᩉᩥᨲᨠ᩠ᨡᩮᩣ ᩅᩥᩉᨲᨶ᩠ᨲᩁᩴᩈᩮᩣ, ᩋᩃᨦ᩠ᨠᨲᩮᩣ ᨠᨸ᩠ᨸᩥᨲᨠᩮᩈᨾᩔᩩ;

ᩈᩩᩁᩮᩣᩈᩥᨲᩮᩣ ᩃᩮᩣᩉᩥᨲᨧᨶ᩠ᨴᨶᩮᨶ, ᨣᨶ᩠ᨵᨻ᩠ᨻᩁᩣᨩᩣᩅ ᨴᩥᩈᩣ ᨸᨽᩣᩈᩈᩥ [ᨸᨽᩣᩈᩥ (ᨠ.)].

᪑᪘᪕.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᩈᨻ᩠ᨻᩮᩉᩥ ᨠᩣᨾᩮᩉᩥ ᩈᨾᨦ᩠ᨣᩥᨽᩪᨲᩮᩣ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨶᩣᨣᩁᩣᨩᩮᨲᨾᨲ᩠ᨳᩴ, ᩈᩮᨿ᩠ᨿᩮᩣ ᩍᨲᩮᩣ ᨠᩮᨶ ᨾᨶᩩᩔᩃᩮᩣᨠᩮᩣ’’.

᪑᪘᪖.

‘‘ᩋᩊᩣᩁ ᨶᩣᨬ᩠ᨬᨲᩕ ᨾᨶᩩᩔᩃᩮᩣᨠᩣ, ᩈᩩᨴ᩠ᨵᩦ ᩅ ᩈᩴᩅᩥᨩ᩠ᨩᨲᩥ ᩈᩴᨿᨾᩮᩣ ᩅᩣ;

ᩋᩉᨬ᩠ᨧ ᩃᨴ᩠ᨵᩣᨶ ᨾᨶᩩᩔᨿᩮᩣᨶᩥᩴ, ᨠᩣᩉᩣᨾᩥ ᨩᩣᨲᩥᨾᩁᨱᩔ ᩋᨶ᩠ᨲᩴ’’.

᪑᪘᪗.

‘‘ᩈᩴᩅᨧ᩠ᨨᩁᩮᩣ ¶ ᨾᩮ ᩅᩈᨲᩮᩣ [ᩅᩩᩈᩥᨲᩮᩣ (ᨸᩦ.)] ᨲᩅᨶ᩠ᨲᩥᨠᩮ, ᩋᨶ᩠ᨶᩮᨶ ᨸᩣᨶᩮᨶ ᩏᨸᨭ᩠ᨮᩥᨲᩮᩣᩈ᩠ᨾᩥ;

ᩌᨾᨶ᩠ᨲᨿᩥᨲ᩠ᩅᩣᨶ ᨸᩃᩮᨾᩥ ᨶᩣᨣ, ᨧᩥᩁᨸ᩠ᨸᩅᩩᨭ᩠ᨮᩮᩣᩈ᩠ᨾᩥ [ᨧᩥᩁᨸ᩠ᨸᩅᩩᨲ᩠ᨳᩮᩣ ᩋᩈ᩠ᨾᩥ (ᨸᩦ.)] ᩋᩉᩴ ᨩᨶᩥᨶ᩠ᨴ’’.

᪑᪘᪘.

‘‘ᨸᩩᨲ᩠ᨲᩣ ᨧ ᨴᩣᩁᩣ ᩋᨶᩩᨩᩦᩅᩥᨶᩮᩣ ᨧ [ᨧ’ᨶᩩᨩᩦᩅᩥᨶᩮᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨶᩥᨧ᩠ᨧᩣᨶᩩᩈᩥᨭ᩠ᨮᩣ ᩏᨸᨲᩥᨭ᩠ᨮᨲᩮ ᨲᩴ;

ᨠᨧ᩠ᨧᩥᨶ᩠ᨶᩩ ᨲᩴ ᨶᩣᨽᩥᩈᨸᩥᨲ᩠ᨳ [ᨶᩣᨽᩥᩈᩴᩈᩥᨲ᩠ᨳ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨠᩮᩣᨧᩥ, ᨸᩥᨿᨬ᩠ᩉᩥ ᨾᩮ ᨴᩔᨶᩴ ᨲᩩᨿ᩠ᩉᩴ [ᨲᩩᨿ᩠ᩉ (ᨸᩦ.)] ᩋᩊᩣᩁ’’.

᪑᪘᪙.

‘‘ᨿᨳᩣᨸᩥ ¶ ᨾᩣᨲᩪ ᨧ ᨸᩥᨲᩪ ᩋᨣᩣᩁᩮ, ᨸᩩᨲ᩠ᨲᩮᩣ ᨸᩥᨿᩮᩣ ᨸᨭᩥᩅᩥᩉᩥᨲᩮᩣ ᩅᩈᩮᨿ᩠ᨿ [ᩈᩮᨿ᩠ᨿᩮᩣ (ᨸᩦ.)];

ᨲᨲᩮᩣᨸᩥ ᨾᨿ᩠ᩉᩴ ᩍᨵᨾᩮᩅ ᩈᩮᨿ᩠ᨿᩮᩣ, ᨧᩥᨲ᩠ᨲᨬ᩠ᩉᩥ ᨲᩮ ᨶᩣᨣ ᨾᨿᩦ ᨸᩈᨶ᩠ᨶᩴ’’.

᪑᪙᪐.

‘‘ᨾᨱᩦ ᨾᨾᩴ ᩅᩥᨩ᩠ᨩᨲᩥ ᩃᩮᩣᩉᩥᨲᨦ᩠ᨠᩮᩣ [ᩃᩮᩣᩉᩥᨲᨦ᩠ᨣᩮᩣ (ᨠ.)], ᨵᨶᩣᩉᩁᩮᩣ ᨾᨱᩥᩁᨲᨶᩴ ᩏᩊᩣᩁᩴ;

ᩌᨴᩣᨿ ᨲ᩠ᩅᩴ [ᨲᩴ (ᨸᩦ.)] ᨣᨧ᩠ᨨ ᩈᨠᩴ ᨶᩥᨠᩮᨲᩴ, ᩃᨴ᩠ᨵᩣ ᨵᨶᩴ ᨲᩴ ᨾᨱᩥᨾᩮᩣᩔᨩᩔᩩ’’.

᪑᪙᪑.

‘‘ᨴᩥᨭ᩠ᨮᩣ ᨾᨿᩣ ᨾᩣᨶᩩᩈᨠᩣᨸᩥ ᨠᩣᨾᩣ, ᩋᩈᩔᨲᩣ ᩅᩥᨸᩁᩥᨱᩣᨾᨵᨾ᩠ᨾᩣ;

ᩌᨴᩦᨶᩅᩴ ᨠᩣᨾᨣᩩᨱᩮᩈᩩ ᨴᩥᩈ᩠ᩅᩣ, ᩈᨴ᩠ᨵᩣᨿᩉᩴ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣᨾ᩠ᩉᩥ ᩁᩣᨩ.

᪑᪙᪒.

‘‘ᨴᩩᨾᨸ᩠ᨹᩃᩣᨶᩦᩅ ¶ ᨸᨲᨶ᩠ᨲᩥ ᨾᩣᨱᩅᩣ, ᨴᩉᩁᩣ ᨧ ᩅᩩᨴ᩠ᨵᩣ ᨧ ᩈᩁᩦᩁᨽᩮᨴᩣ;

ᩑᨲᨾ᩠ᨸᩥ ᨴᩥᩈ᩠ᩅᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣᨾ᩠ᩉᩥ ᩁᩣᨩ, ᩋᨸᨱ᩠ᨱᨠᩴ ᩈᩣᨾᨬ᩠ᨬᨾᩮᩅ ᩈᩮᨿ᩠ᨿᩮᩣ’’.

᪑᪙᪓.

‘‘ᩋᨴ᩠ᨵᩣ ᩉᩅᩮ ᩈᩮᩅᩥᨲᨻ᩠ᨻᩣ ᩈᨸᨬ᩠ᨬᩣ, ᨻᩉᩩᩔᩩᨲᩣ ᨿᩮ ᨻᩉᩩᨮᩣᨶᨧᩥᨶ᩠ᨲᩥᨶᩮᩣ;

ᨶᩣᨣᨬ᩠ᨧ ᩈᩩᨲ᩠ᩅᩣᨶ ᨲᩅᨬ᩠ᨧᩊᩣᩁ, ᨠᩣᩉᩣᨾᩥ ᨸᩩᨬ᩠ᨬᩣᨶᩥ ᩋᨶᨸ᩠ᨸᨠᩣᨶᩥ’’.

᪑᪙᪔.

‘‘ᩋᨴ᩠ᨵᩣ ᩉᩅᩮ ᩈᩮᩅᩥᨲᨻ᩠ᨻᩣ ᩈᨸᨬ᩠ᨬᩣ, ᨻᩉᩩᩔᩩᨲᩣ ᨿᩮ ᨻᩉᩩᨮᩣᨶᨧᩥᨶ᩠ᨲᩥᨶᩮᩣ;

ᨶᩣᨣᨬ᩠ᨧ ᩈᩩᨲ᩠ᩅᩣᨶ ᨾᨾᨬ᩠ᨧ ᩁᩣᨩ, ᨠᩁᩮᩣᩉᩥ ᨸᩩᨬ᩠ᨬᩣᨶᩥ ᩋᨶᨸ᩠ᨸᨠᩣᨶᩦ’’ᨲᩥ.

ᩈᨦ᩠ᨡᨸᩣᩃᨩᩣᨲᨠᩴ ᨧᨲᩩᨲ᩠ᨳᩴ.

᪕᪒᪕. ᨧᩪᩊᩈᩩᨲᩈᩮᩣᨾᨩᩣᨲᨠᩴ (᪕)

᪑᪙᪕.

‘‘ᩌᨾᨶ᩠ᨲᨿᩣᨾᩥ ¶ ¶ ᨶᩥᨣᨾᩴ, ᨾᩥᨲ᩠ᨲᩣᨾᨧ᩠ᨧᩮ ᨸᩁᩥᩔᨩᩮ [ᨸᩣᩁᩥᩈᨩ᩠ᨩᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

ᩈᩥᩁᩈ᩠ᨾᩥᩴ ᨸᩃᩥᨲᩴ ᨩᩣᨲᩴ, ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ ᨴᩣᨶᩥ ᩁᩮᩣᨧᩉᩴ’’.

᪑᪙᪖.

‘‘ᩋᨽᩩᨾ᩠ᨾᩮ ᨠᨳᩴ ᨶᩩ ᨽᨱᩈᩥ, ᩈᩃ᩠ᩃᩴ ᨾᩮ ᨴᩮᩅ ᩏᩁᩈᩥ ᨠᨸ᩠ᨸᩮᩈᩥ [ᨠᨾ᩠ᨸᩮᩈᩥ (ᨸᩦ.)];

ᩈᨲ᩠ᨲᩈᨲᩣ ᨲᩮ ᨽᩁᩥᨿᩣ, ᨠᨳᩴ ¶ ᨶᩩ ᨲᩮ ᨲᩣ ᨽᩅᩥᩔᨶ᩠ᨲᩥ’’.

᪑᪙᪗.

‘‘ᨸᨬ᩠ᨬᩣᨿᩥᩉᩥᨶ᩠ᨲᩥ ᩑᨲᩣ, ᨴᩉᩁᩣ ᩋᨬ᩠ᨬᨾ᩠ᨸᩥ ᨲᩣ ᨣᨾᩥᩔᨶ᩠ᨲᩥ;

ᩈᨣ᩠ᨣᨬ᩠ᨧᩔ ᨸᨲ᩠ᨳᨿᩣᨶᩮᩣ, ᨲᩮᨶ ᩋᩉᩴ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ’’.

᪑᪙᪘.

‘‘ᨴᩩᩃ᩠ᩃᨴ᩠ᨵᩴ ᨾᩮ ᩌᩈᩥ ᩈᩩᨲᩈᩮᩣᨾ, ᨿᩔ ᨲᩮ ᩉᩮᩣᨾᩉᩴ ᨾᩣᨲᩣ;

ᨿᩴ ᨾᩮ ᩅᩥᩃᨸᨶ᩠ᨲᩥᨿᩣ, ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ᨸᨻ᩠ᨻᨩᩈᩥ ᨴᩮᩅ.

᪑᪙᪙.

‘‘ᨴᩩᩃ᩠ᩃᨴ᩠ᨵᩴ ᨾᩮ ᩌᩈᩥ ᩈᩩᨲᩈᩮᩣᨾ, ᨿᩴ ᨲᩴ ᩋᩉᩴ ᩅᩥᨩᩣᨿᩥᩔᩴ;

ᨿᩴ ᨾᩮ ᩅᩥᩃᨸᨶ᩠ᨲᩥᨿᩣ, ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ᨸᨻ᩠ᨻᨩᩈᩥ ᨴᩮᩅ’’.

᪒᪐᪐.

‘‘ᨠᩮᩣ ᨶᩣᨾᩮᩈᩮᩣ ᨵᨾ᩠ᨾᩮᩣ, ᩈᩩᨲᩈᩮᩣᨾ ᨠᩣ ᨧ ᨶᩣᨾ ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ;

ᨿᩴ ᨶᩮᩣ ᩋᨾ᩠ᩉᩮ ᨩᩥᨱ᩠ᨱᩮ, ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ᨸᨻ᩠ᨻᨩᩈᩥ ᨴᩮᩅ.

᪒᪐᪑.

‘‘ᨸᩩᨲ᩠ᨲᩣᨸᩥ ᨲᩩᨿ᩠ᩉᩴ ᨻᩉᩅᩮᩣ, ᨴᩉᩁᩣ ᩋᨸ᩠ᨸᨲ᩠ᨲᨿᩮᩣᨻ᩠ᨻᨶᩣ;

ᨾᨬ᩠ᨩᩪ ᨲᩮᨸᩥ [ᨲᩮ (ᩈᩦ. ᨸᩦ.)] ᨲᩴ ᩋᨸᩔᨶ᩠ᨲᩣ, ᨾᨬ᩠ᨬᩮ ¶ ᨴᩩᨠ᩠ᨡᩴ ᨶᩥᨣᨧ᩠ᨨᨶ᩠ᨲᩥ’’.

᪒᪐᪒.

‘‘ᨸᩩᨲ᩠ᨲᩮᩉᩥ ᨧ ᨾᩮ ᩑᨲᩮᩉᩥ, ᨴᩉᩁᩮᩉᩥ ᩋᨸ᩠ᨸᨲ᩠ᨲᨿᩮᩣᨻ᩠ᨻᨶᩮᩉᩥ;

ᨾᨬ᩠ᨩᩪᩉᩥ ᩈᨻ᩠ᨻᩮᩉᩥᨸᩥ ᨲᩩᨾ᩠ᩉᩮᩉᩥ, ᨧᩥᩁᨾ᩠ᨸᩥ ᨮᨲ᩠ᩅᩣ ᩅᩥᨶᩣᩈᨽᩣᩅᩮᩣ’’ [ᩅᩥᨶᩣᨽᩣᩅᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪒᪐᪓.

‘‘ᨨᩥᨶ᩠ᨶᩴ ¶ ᨶᩩ ᨲᩩᨿ᩠ᩉᩴ ᩉᨴᨿᩴ, ᩋᨴᩩ ᨲᩮ [ᩌᨴᩩ (ᩈᩦ. ᨸᩦ.), ᩌᨴᩪ (ᩈ᩠ᨿᩣ.)] ᨠᩁᩩᨱᩣ ᨧ ᨶᨲ᩠ᨳᩥ ᩋᨾ᩠ᩉᩮᩈᩩ;

ᨿᩴ ᨶᩮᩣ ᩅᩥᨠᨶ᩠ᨴᨶ᩠ᨲᩥᨿᩮᩣ [ᩅᩥᨠ᩠ᨠᨶ᩠ᨴᨶ᩠ᨲᩥᨿᩮᩣ (ᩈᩦ.)], ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ᨸᨻ᩠ᨻᨩᩈᩥ ᨴᩮᩅ’’.

᪒᪐᪔.

‘‘ᨶ ᨧ ᨾᨿ᩠ᩉᩴ ᨨᩥᨶ᩠ᨶᩴ ᩉᨴᨿᩴ, ᩋᨲ᩠ᨳᩥ ᨠᩁᩩᨱᩣᨸᩥ ᨾᨿ᩠ᩉᩴ ᨲᩩᨾ᩠ᩉᩮᩈᩩ;

ᩈᨣ᩠ᨣᨬ᩠ᨧ ᨸᨲ᩠ᨳᨿᩣᨶᩮᩣ, ᨲᩮᨶ ᩋᩉᩴ [ᨲᩮᨶᩣᩉᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨲᩮᨶᨾᩉᩴ (ᨸᩦ.)] ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ’’.

᪒᪐᪕.

‘‘ᨴᩩᩃ᩠ᩃᨴ᩠ᨵᩴ ᨾᩮ ᩌᩈᩥ, ᩈᩩᨲᩈᩮᩣᨾ ᨿᩔ ᨲᩮ ᩋᩉᩴ ᨽᩁᩥᨿᩣ;

ᨿᩴ ᨾᩮ ᩅᩥᩃᨸᨶ᩠ᨲᩥᨿᩣ, ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ᨸᨻ᩠ᨻᨩᩈᩥ ᨴᩮᩅ.

᪒᪐᪖.

‘‘ᨴᩩᩃ᩠ᩃᨴ᩠ᨵᩴ ᨾᩮ ᩌᩈᩥ, ᩈᩩᨲᩈᩮᩣᨾ ᨿᩔ ᨲᩮ ᩋᩉᩴ ᨽᩁᩥᨿᩣ;

ᨿᩴ ᨾᩮ ᨠᩩᨧ᩠ᨨᩥᨸᨭᩥᩈᨶ᩠ᨵᩥᩴ [ᨾᩴ ᨠᩩᨧ᩠ᨨᩥᨾᨲᩥᩴ ᩈᨶ᩠ᨲᩥᩴ (ᨸᩦ.)], ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ¶ ᨸᨻ᩠ᨻᨩᩈᩥ ᨴᩮᩅ.

᪒᪐᪗.

‘‘ᨸᩁᩥᨸᨠ᩠ᨠᩮᩣ ᨾᩮ ᨣᨻ᩠ᨽᩮᩣ, ᨠᩩᨧ᩠ᨨᩥᨣᨲᩮᩣ ᨿᩣᩅ ᨶᩴ ᩅᩥᨩᩣᨿᩣᨾᩥ;

ᨾᩣᩉᩴ ᩑᨠᩣ ᩅᩥᨵᩅᩣ, ᨸᨧ᩠ᨨᩣ ᨴᩩᨠ᩠ᨡᩣᨶᩥ ᩋᨴ᩠ᨴᨠ᩠ᨡᩥᩴ’’.

᪒᪐᪘.

‘‘ᨸᩁᩥᨸᨠ᩠ᨠᩮᩣ ᨲᩮ ᨣᨻ᩠ᨽᩮᩣ, ᨠᩩᨧ᩠ᨨᩥᨣᨲᩮᩣ ᩍᨦ᩠ᨥ ᨲ᩠ᩅᩴ [ᨲ᩠ᩅ (ᩈᩦ.), ᨶᩴ (ᨸᩦ.)] ᩅᩥᨩᩣᨿᩔᩩ;

ᨸᩩᨲ᩠ᨲᩴ ᩋᨶᩮᩣᨾᩅᨱ᩠ᨱᩴ, ᨲᩴ ᩉᩥᨲ᩠ᩅᩣ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ’’.

᪒᪐᪙.

‘‘ᨾᩣ ¶ ᨲ᩠ᩅᩴ ᨧᨶ᩠ᨴᩮ ᩁᩩᨴᩥ, ᨾᩣ ᩈᩮᩣᨧᩥ ᩅᨶᨲᩥᨾᩥᩁᨾᨲ᩠ᨲᨠ᩠ᨡᩥ;

ᩌᩁᩮᩣᩉ ᩅᩁᨸᩣᩈᩣᨴᩴ [ᨧ ᨸᩣᩈᩣᨴᩴ (ᨸᩦ.)], ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ᩋᩉᩴ ᨣᨾᩥᩔᩣᨾᩥ’’.

᪒᪑᪐.

‘‘ᨠᩮᩣ ¶ ᨲᩴ ᩋᨾ᩠ᨾ ᨠᩮᩣᨸᩮᩈᩥ, ᨠᩥᩴ ᩁᩮᩣᨴᩈᩥ ᨸᩮᨠ᩠ᨡᩈᩥ ᨧ ᨾᩴ ᨻᩣᩊ᩠ᩉᩴ;

ᨠᩴ ᩋᩅᨩ᩠ᨫᩴ ᨥᩣᨲᩮᨾᩥ [ᨥᩣᨲᩮᨾᩥ ᨠᩴ ᩋᩅᨩ᩠ᨫᩴ (ᨸᩦ.), ᨲᩴ ᩋᩅᨩ᩠ᨫᩴ ᨥᩣᨲᩮᨾᩥ (ᨠ.)], ᨬᩣᨲᩦᨶᩴ ᩏᨴᩥᨠ᩠ᨡᨾᩣᨶᩣᨶᩴ’’.

᪒᪑᪑.

‘‘ᨶ ᩉᩥ ᩈᩮᩣ ᩈᨠ᩠ᨠᩣ ᩉᨶ᩠ᨲᩩᩴ, ᩅᩥᨩᩥᨲᩣᩅᩦ [ᨩᩦᩅᩥᨲᩣᩅᩦ (ᨸᩦ.)] ᨿᩮᩣ ᨾᩴ ᨲᩣᨲ ᨠᩮᩣᨸᩮᩈᩥ;

ᨸᩥᨲᩣ ᨲᩮ ᨾᩴ ᨲᩣᨲ ᩋᩅᨧ, ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ¶ ᩋᩉᩴ ᨣᨾᩥᩔᩣᨾᩥ’’.

᪒᪑᪒.

‘‘ᨿᩮᩣᩉᩴ ᨸᩩᨻ᩠ᨻᩮ ᨶᩥᨿ᩠ᨿᩣᨾᩥ, ᩏᨿ᩠ᨿᩣᨶᩴ ᨾᨲ᩠ᨲᨠᩩᨬ᩠ᨩᩁᩮ ᨧ ᨿᩮᩣᨵᩮᨾᩥ;

ᩈᩩᨲᩈᩮᩣᨾᩮ ᨸᨻ᩠ᨻᨩᩥᨲᩮ, ᨠᨳᩴ ᨶᩩ ᨴᩣᨶᩥ ᨠᩁᩥᩔᩣᨾᩥ’’.

᪒᪑᪓.

‘‘ᨾᩣᨲᩩᨧ᩠ᨧ [ᨾᩣᨲᩩ ᨧ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨾᩮ ᩁᩩᨴᨶ᩠ᨲ᩠ᨿᩣ [ᩁᩩᨴᨲ᩠ᨿᩣ (ᨸᩦ.)], ᨩᩮᨭ᩠ᨮᩔ ᨧ ᨽᩣᨲᩩᨶᩮᩣ ᩋᨠᩣᨾᩔ;

ᩉᨲ᩠ᨳᩮᨸᩥ ᨲᩮ ᨣᩉᩮᩔᩴ, ᨶ ᩉᩥ ᨣᨧ᩠ᨨᩈᩥ [ᨣᨬ᩠ᨨᩥᩈᩥ (ᨸᩦ.)] ᨶᩮᩣ ᩋᨠᩣᨾᩣᨶᩴ’’.

᪒᪑᪔.

‘‘ᩏᨭ᩠ᨮᩮᩉᩥ ᨲ᩠ᩅᩴ ᨵᩣᨲᩥ, ᩍᨾᩴ ᨠᩩᨾᩣᩁᩴ ᩁᨾᩮᩉᩥ ᩋᨬ᩠ᨬᨲ᩠ᨳ;

ᨾᩣ ᨾᩮ ᨸᩁᩥᨸᨶ᩠ᨳᨾᨠᩣᩈᩥ [ᨾᨠᩣ (ᩈᩦ. ᨸᩦ.)], ᩈᨣ᩠ᨣᩴ ᨾᨾ ᨸᨲ᩠ᨳᨿᩣᨶᩔ’’.

᪒᪑᪕.

‘‘ᨿᩴ ᨶᩪᨶᩥᨾᩴ ᨴᨴᩮᨿ᩠ᨿᩴ [ᨩᩉᩮᨿ᩠ᨿᩴ (ᨸᩦ.)] ᨸᨽᨦ᩠ᨠᩁᩴ, ᨠᩮᩣ ᨶᩩ ᨾᩮ ᩍᨾᩥᨶᩣᨲ᩠ᨳᩮᩣ [ᨠᩮᩣ ᨶᩩ ᨾᩮ ᩍᨾᩥᨶᩣ ᩋᨲ᩠ᨳᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨠᩮᩣ ᨶᩩ ᨾᩮ ᨶᨲ᩠ᨳᩮᩣ (ᨸᩦ.)];

ᩈᩩᨲᩈᩮᩣᨾᩮ ᨸᨻ᩠ᨻᨩᩥᨲᩮ, ᨠᩥᩴ ᨶᩩ ᨾᩮᨶᩴ ᨠᩁᩥᩔᩣᨾᩥ’’.

᪒᪑᪖.

‘‘ᨠᩮᩣᩈᩮᩣ ¶ ᨧ ᨲᩩᨿ᩠ᩉᩴ ᩅᩥᨸᩩᩃᩮᩣ, ᨠᩮᩣᨭ᩠ᨮᩣᨣᩣᩁᨬ᩠ᨧ ᨲᩩᨿ᩠ᩉᩴ ᨸᩁᩥᨸᩪᩁᩴ;

ᨸᨳᩅᩦ ᨧ ᨲᩩᨿ᩠ᩉᩴ ᩅᩥᨩᩥᨲᩣ, ᩁᨾᩔᩩ ¶ ᨾᩣ ᨸᨻ᩠ᨻᨩᩥ [ᨸᨻ᩠ᨻᨩᩔᩩ (ᩈᩦ.), ᨸᨻ᩠ᨻᨩ (ᨸᩦ.)] ᨴᩮᩅ’’.

᪒᪑᪗.

‘‘ᨠᩮᩣᩈᩮᩣ ᨧ ᨾᨿ᩠ᩉᩴ ᩅᩥᨸᩩᩃᩮᩣ, ᨠᩮᩣᨭ᩠ᨮᩣᨣᩣᩁᨬ᩠ᨧ ᨾᨿ᩠ᩉᩴ ᨸᩁᩥᨸᩪᩁᩴ;

ᨸᨳᩅᩦ ᨧ ᨾᨿ᩠ᩉᩴ ᩅᩥᨩᩥᨲᩣ, ᨲᩴ ᩉᩥᨲ᩠ᩅᩣ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ’’.

᪒᪑᪘.

‘‘ᨾᨿ᩠ᩉᨾ᩠ᨸᩥ ᨵᨶᩴ ᨸᩉᩪᨲᩴ, ᩈᨦ᩠ᨡᩣᨲᩩᩴ [ᩈᨦ᩠ᨡ᩠ᨿᩣᨲᩩᩴ (ᩈᩦ.)] ᨶᩮᩣᨸᩥ ᨴᩮᩅ ᩈᨠ᩠ᨠᩮᩣᨾᩥ;

ᨲᩴ ᨲᩮ ᨴᨴᩣᨾᩥ ᩈᨻ᩠ᨻᨾ᩠ᨸᩥ [ᨲᩴ ᨴᩮᩅ ᨲᩮ ᨴᨴᩣᨾᩥ ᩈᨻ᩠ᨻᨾ᩠ᨸᩥ (ᩈᩦ.), ᨲᩴ ᨲᩮ ᨴᨴᩣᨾᩥ ᩈᨻ᩠ᨻᩴ (ᨸᩦ.)], ᩁᨾᩔᩩ ᨾᩣ ᨸᨻ᩠ᨻᨩᩥ ᨴᩮᩅ’’.

᪒᪑᪙.

‘‘ᨩᩣᨶᩣᨾᩥ [ᨩᩣᨶᩣᨾᩥ ᨲᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨵᨶᩴ ᨸᩉᩪᨲᩴ, ᨠᩩᩃᩅᨴ᩠ᨵᨶ ᨸᩪᨩᩥᨲᩮᩣ ᨲᨿᩣ ᨧᩈ᩠ᨾᩥ;

ᩈᨣ᩠ᨣᨬ᩠ᨧ ᨸᨲ᩠ᨳᨿᩣᨶᩮᩣ, ᨲᩮᨶ ᩋᩉᩴ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ’’.

᪒᪒᪐.

‘‘ᩏᨠ᩠ᨠᨱ᩠ᨮᩥᨲᩮᩣᩈ᩠ᨾᩥ ᨻᩣᩊ᩠ᩉᩴ, ᩋᩁᨲᩥ ᨾᩴ ᩈᩮᩣᨾᨴᨲ᩠ᨲ ᩌᩅᩥᩈᨲᩥ [ᩌᩅᩦᩈᨲᩥ (ᨠ.)];

ᨻᩉᩩᨠᩣᨸᩥ [ᨻᩉᩩᨠᩣ ᩉᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨾᩮ ᩋᨶ᩠ᨲᩁᩣᨿᩣ, ᩋᨩ᩠ᨩᩮᩅᩣᩉᩴ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ’’.

᪒᪒᪑.

‘‘ᩍᨴᨬ᩠ᨧ ᨲᩩᨿ᩠ᩉᩴ ᩁᩩᨧᩥᨲᩴ, ᩈᩩᨲᩈᩮᩣᨾ ᩋᨩ᩠ᨩᩮᩅ ᨴᩣᨶᩥ ᨲ᩠ᩅᩴ ᨸᨻ᩠ᨻᨩ;

ᩋᩉᨾ᩠ᨸᩥ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨶ ¶ ᩏᩔᩉᩮ ᨲᨿᩣ ᩅᩥᨶᩣ ᩋᩉᩴ ᨮᩣᨲᩩᩴ’’.

᪒᪒᪒.

‘‘ᨶ ᩉᩥ ᩈᨠ᩠ᨠᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩩᩴ, ᨶᨣᩁᩮ ᨶ ᩉᩥ ᨸᨧ᩠ᨧᨲᩥ ᨩᨶᨸᨴᩮ ᨧ’’;

‘‘ᩈᩩᨲᩈᩮᩣᨾᩮ ᨸᨻ᩠ᨻᨩᩥᨲᩮ, ᨠᨳᩴ ᨶᩩ ᨴᩣᨶᩥ ᨠᩁᩥᩔᩣᨾ’’.

᪒᪒᪓.

‘‘ᩏᨸᨶᩦᨿᨲᩥᨴᩴ ᨾᨬ᩠ᨬᩮ, ᨸᩁᩥᨲ᩠ᨲᩴ ᩏᨴᨠᩴᩅ ᨧᨦ᩠ᨠᩅᩣᩁᨾ᩠ᩉᩥ;

ᩑᩅᩴ ᩈᩩᨸᩁᩥᨲ᩠ᨲᨠᩮ ᨩᩦᩅᩥᨲᩮ, ᨶ ᨧ ᨸᨾᨩ᩠ᨩᩥᨲᩩᩴ ᨠᩣᩃᩮᩣ.

᪒᪒᪔.

‘‘ᩏᨸᨶᩦᨿᨲᩥᨴᩴ ¶ ᨾᨬ᩠ᨬᩮ, ᨸᩁᩥᨲ᩠ᨲᩴ ᩏᨴᨠᩴᩅ ᨧᨦ᩠ᨠᩅᩣᩁᨾ᩠ᩉᩥ;

ᩑᩅᩴ ᩈᩩᨸᩁᩥᨲ᩠ᨲᨠᩮ ᨩᩦᩅᩥᨲᩮ, ᩋᨶ᩠ᨵᨻᩣᩃᩣ [ᩋᨳ ᨻᩣᩃᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᨾᨩ᩠ᨩᨶ᩠ᨲᩥ.

᪒᪒᪕.

‘‘ᨲᩮ ᩅᨯ᩠ᨰᨿᨶ᩠ᨲᩥ ᨶᩥᩁᨿᩴ, ᨲᩥᩁᨧ᩠ᨨᩣᨶᨿᩮᩣᨶᩥᨬ᩠ᨧ ᨸᩮᨲ᩠ᨲᩥᩅᩥᩈᨿᨬ᩠ᨧ;

ᨲᨱ᩠ᩉᩣᨿ ᨻᨶ᩠ᨵᨶᨻᨴ᩠ᨵᩣ, ᩅᨯ᩠ᨰᩮᨶ᩠ᨲᩥ ᩋᩈᩩᩁᨠᩣᨿᩴ’’.

᪒᪒᪖.

‘‘ᩐᩉᨬ᩠ᨬᨲᩮ ¶ ᩁᨩᨣ᩠ᨣᩴ, ᩋᩅᩥᨴᩪᩁᩮ ᨸᩩᨻ᩠ᨻᨠᨾ᩠ᩉᩥ ᨧ [ᨸᩩᨸ᩠ᨹᨠᨾ᩠ᩉᩥ ᨧ (ᩈᩦ. ᨸᩦ.)] ᨸᩣᩈᩣᨴᩮ;

ᨾᨬ᩠ᨬᩮ ᨶᩮᩣ ᨠᩮᩈᩣ ᨨᩥᨶ᩠ᨶᩣ, ᨿᩈᩔᩥᨶᩮᩣ ¶ ᨵᨾ᩠ᨾᩁᩣᨩᩔ’’.

᪒᪒᪗.

‘‘ᩋᨿᨾᩔ ᨸᩣᩈᩣᨴᩮᩣ, ᩈᩮᩣᩅᨱ᩠ᨱ [ᩈᩮᩣᩅᨱ᩠ᨱᩮᩣ (ᨸᩦ.)] ᨸᩩᨸ᩠ᨹᨾᩣᩃ᩠ᨿᩅᩦᨲᩥᨠᩥᨱ᩠ᨱᩮᩣ;

ᨿᩉᩥ [ᨿᨾ᩠ᩉᩥ (ᨸᩦ.)] ᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᩍᨲ᩠ᨳᩣᨣᩣᩁᩮᩉᩥ.

᪒᪒᪘.

‘‘ᩋᨿᨾᩔ ᨸᩣᩈᩣᨴᩮᩣ, ᩈᩮᩣᩅᨱ᩠ᨱᨸᩩᨸ᩠ᨹᨾᩣᩃ᩠ᨿᩅᩦᨲᩥᨠᩥᨱ᩠ᨱᩮᩣ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᨶ.

᪒᪒᪙.

‘‘ᩍᨴᨾᩔ ᨠᩪᨭᩣᨣᩣᩁᩴ, ᩈᩮᩣᩅᨱ᩠ᨱᨸᩩᨸ᩠ᨹᨾᩣᩃ᩠ᨿᩅᩦᨲᩥᨠᩥᨱ᩠ᨱᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᩍᨲ᩠ᨳᩣᨣᩣᩁᩮᩉᩥ.

᪒᪓᪐.

‘‘ᩍᨴᨾᩔ ᨠᩪᨭᩣᨣᩣᩁᩴ, ᩈᩮᩣᩅᨱ᩠ᨱ [ᩈᩮᩣᩅᨱ᩠ᨱᩴ (ᨸᩦ.)] ᨸᩩᨸ᩠ᨹᨾᩣᩃ᩠ᨿᩅᩦᨲᩥᨠᩥᨱ᩠ᨱᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᨶ.

᪒᪓᪑.

‘‘ᩋᨿᨾᩔ ᩋᩈᩮᩣᨠᩅᨶᩥᨠᩣ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩣ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩣ ᩁᨾ᩠ᨾᩣ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ¶ ᩍᨲ᩠ᨳᩣᨣᩣᩁᩮᩉᩥ.

᪒᪓᪒.

‘‘ᩋᨿᨾᩔ ᩋᩈᩮᩣᨠᩅᨶᩥᨠᩣ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩣ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩣ ᩁᨾ᩠ᨾᩣ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᨶ.

᪒᪓᪓.

‘‘ᩍᨴᨾᩔ ᩏᨿ᩠ᨿᩣᨶᩴ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ ᩁᨾ᩠ᨾᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᩍᨲ᩠ᨳᩣᨣᩣᩁᩮᩉᩥ.

᪒᪓᪔.

‘‘ᩍᨴᨾᩔ ᩏᨿ᩠ᨿᩣᨶᩴ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ ᩁᨾ᩠ᨾᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᨶ.

᪒᪓᪕.

‘‘ᩍᨴᨾᩔ ᨠᨱᩥᨠᩣᩁᩅᨶᩴ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ ᩁᨾ᩠ᨾᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᩍᨲ᩠ᨳᩣᨣᩣᩁᩮᩉᩥ.

᪒᪓᪖.

‘‘ᩍᨴᨾᩔ ᨠᨱᩥᨠᩣᩁᩅᨶᩴ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ ᩁᨾ᩠ᨾᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ¶ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᨶ.

᪒᪓᪗.

‘‘ᩍᨴᨾᩔ ᨸᩣᨭᩃᩥᩅᨶᩴ [ᨸᩣᨭᩃᩦᩅᨶᩴ (ᩈᩦ.)], ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ ᩁᨾ᩠ᨾᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᩍᨲ᩠ᨳᩣᨣᩣᩁᩮᩉᩥ.

᪒᪓᪘.

‘‘ᩍᨴᨾᩔ ᨸᩣᨭᩃᩥᩅᨶᩴ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ ᩁᨾ᩠ᨾᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᨶ.

᪒᪓᪙.

‘‘ᩍᨴᨾᩔ ¶ ¶ ᩋᨾ᩠ᨻᩅᨶᩴ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ ᩁᨾ᩠ᨾᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᩍᨲ᩠ᨳᩣᨣᩣᩁᩮᩉᩥ.

᪒᪔᪐.

‘‘ᩍᨴᨾᩔ ᩋᨾ᩠ᨻᩅᨶᩴ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ ᩁᨾ᩠ᨾᩴ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᨶ.

᪒᪔᪑.

‘‘ᩋᨿᨾᩔ ᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ, ᩈᨬ᩠ᨨᨶ᩠ᨶᩣ ᩋᨱ᩠ᨯᨩᩮᩉᩥ ᩅᩦᨲᩥᨠᩥᨱ᩠ᨱᩣ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ¶ ᩍᨲ᩠ᨳᩣᨣᩣᩁᩮᩉᩥ.

᪒᪔᪒.

‘‘ᩋᨿᨾᩔ ᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ, ᩈᨬ᩠ᨨᨶ᩠ᨶᩣ ᩋᨱ᩠ᨯᨩᩮᩉᩥ ᩅᩦᨲᩥᨠᩥᨱ᩠ᨱᩣ;

ᨿᩉᩥᨾᨶᩩᩅᩥᨧᩁᩥ ᩁᩣᨩᩣ, ᨸᩁᩥᨠᩥᨱ᩠ᨱᩮᩣ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᨶ’’.

᪒᪔᪓.

‘‘ᩁᩣᨩᩣ ᩅᩮᩣ ᨡᩮᩣ [ᩁᩣᨩᩣ ᨡᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ, ᩈᩩᨲᩈᩮᩣᨾᩮᩣ ᩁᨩ᩠ᨩᩴ ᩍᨾᩴ ᨸᩉᨲ᩠ᩅᩣᨶ [ᨸᩉᨶ᩠ᨲ᩠ᩅᩣᨶ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᨠᩣᩈᩣᨿᩅᨲ᩠ᨳᩅᩈᨶᩮᩣ, ᨶᩣᨣᩮᩣᩅ ᩑᨠᨠᩮᩣ [ᩑᨠᨠᩮᩣᩅ (ᩈᩦ.)] ᨧᩁᨲᩥ’’.

᪒᪔᪔.

‘‘ᨾᩣᩔᩩ ᨸᩩᨻ᩠ᨻᩮ ᩁᨲᩥᨠᩦᩊᩥᨲᩣᨶᩥ, ᩉᩈᩥᨲᩣᨶᩥ ᨧ ᩋᨶᩩᩔᩁᩥᨲ᩠ᨳ [ᩋᨶᩩᩔᩁᩥᨲ᩠ᨳᩮᩣ (ᨸᩦ.)];

ᨾᩣ ᩅᩮᩣ ᨠᩣᨾᩣ ᩉᨶᩥᩴᩈᩩ, ᩁᨾ᩠ᨾᩴ ᩉᩥ [ᩈᩩᩁᨾ᩠ᨾᨬ᩠ᩉᩥ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩈᩩᨴᩔᨶᩴ [ᩈᩩᨴᩔᨶᩴ ᨶᩣᨾ (ᩈᩦ.)] ᨶᨣᩁᩴ.

᪒᪔᪕.

‘‘ᨾᩮᨲ᩠ᨲᨧᩥᨲ᩠ᨲᨬ᩠ᨧ [ᨾᩮᨲ᩠ᨲᨬ᩠ᨧ (ᨸᩦ.)] ᨽᩣᩅᩮᨳ, ᩋᨸ᩠ᨸᨾᩣᨱᩴ ᨴᩥᩅᩣ ᨧ ᩁᨲ᩠ᨲᩮᩣ ᨧ;

ᩋᨣᨧ᩠ᨨᩥᨲ᩠ᨳ [ᩋᨳ ᨣᨬ᩠ᨨᩥᨲ᩠ᨳ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨴᩮᩅᨸᩩᩁ, ᩌᩅᩣᩈᩴ ᨸᩩᨬ᩠ᨬᨠᨾ᩠ᨾᩥᨶ’’ᨶ᩠ᨲᩥ [ᨸᩩᨬ᩠ᨬᨠᨾ᩠ᨾᩣᨶᨶ᩠ᨲᩥ (ᨸᩦ.)].

ᨧᩪᩊᩈᩩᨲᩈᩮᩣᨾᨩᩣᨲᨠᩴ ᨸᨬ᩠ᨧᨾᩴ.

ᨧᨲ᩠ᨲᩣᩃᩦᩈᨶᩥᨸᩣᨲᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨲᩔᩩᨴ᩠ᨴᩣᨶᩴ –

ᩈᩩᩅᨸᨱ᩠ᨯᩥᨲᨩᨾ᩠ᨻᩩᨠᨠᩩᨱ᩠ᨯᩃᩥᨶᩮᩣ ¶ , ᩅᩁᨠᨬ᩠ᨬᨾᩃᨾ᩠ᨻᩩᩈᨩᩣᨲᨠᨬ᩠ᨧ;

ᨸᩅᩁᩩᨲ᩠ᨲᨾᩈᨦ᩠ᨡᩈᩥᩁᩦᩅ᩠ᩉᨿᨠᩮᩣ, ᩈᩩᨲᩈᩮᩣᨾᩋᩁᩥᨶ᩠ᨵᨾᩁᩣᨩᩅᩁᩮᩣ.

᪑᪘. ᨸᨱ᩠ᨱᩣᩈᨶᩥᨸᩣᨲᩮᩣ

᪕᪒᪖. ᨶᩥᩊᩥᨶᩥᨠᩣᨩᩣᨲᨠᩴ (᪑)

᪑.

‘‘ᩏᨴ᩠ᨴᨿ᩠ᩉᨲᩮ ¶ ¶ ¶ [ᩏᨯ᩠ᨯᨿ᩠ᩉᨲᩮ (ᩈᩦ. ᨸᩦ.)] ᨩᨶᨸᨴᩮᩣ, ᩁᨭ᩠ᨮᨬ᩠ᨧᩣᨸᩥ ᩅᩥᨶᩔᨲᩥ;

ᩑᩉᩥ ᨶᩥᩊᩥᨶᩥᨠᩮ [ᨶᩥᩊᩥᨠᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.), ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ᨣᨧ᩠ᨨ, ᨲᩴ ᨾᩮ ᨻᩕᩣᩉ᩠ᨾᨱᨾᩣᨶᨿ’’.

᪒.

‘‘ᨶᩣᩉᩴ ᨴᩩᨠ᩠ᨡᨠ᩠ᨡᨾᩣ ᩁᩣᨩ, ᨶᩣᩉᩴ ᩋᨴ᩠ᨵᩣᨶᨠᩮᩣᩅᩥᨴᩣ;

ᨠᨳᩴ ᩋᩉᩴ ᨣᨾᩥᩔᩣᨾᩥ, ᩅᨶᩴ ᨠᩩᨬ᩠ᨩᩁᩈᩮᩅᩥᨲᩴ’’.

᪓.

‘‘ᨹᩦᨲᩴ ᨩᨶᨸᨴᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩉᨲ᩠ᨳᩥᨶᩣ ᨧ ᩁᨳᩮᨶ ᨧ;

ᨴᩣᩁᩩᩈᨦ᩠ᨥᩣᨭᨿᩣᨶᩮᨶ, ᩑᩅᩴ ᨣᨧ᩠ᨨ ᨶᩥᩊᩥᨶᩥᨠᩮ.

᪔.

‘‘ᩉᨲ᩠ᨳᩥᩋᩔᩁᨳᩮ ᨸᨲ᩠ᨲᩦ, ᨣᨧ᩠ᨨᩮᩅᩣᨴᩣᨿ ᨡᨲ᩠ᨲᩥᨿᩮ;

ᨲᩅᩮᩅ ᩅᨱ᩠ᨱᩁᩪᨸᩮᨶ, ᩅᩈᩴ ᨲᨾᩣᨶᨿᩥᩔᩈᩥ’’.

᪕.

‘‘ᨠᨴᩃᩦᨵᨩᨸᨬ᩠ᨬᩣᨱᩮᩣ, ᩌᨽᩩᨩᩦᨸᩁᩥᩅᩣᩁᩥᨲᩮᩣ;

ᩑᩈᩮᩣ ᨸᨴᩥᩔᨲᩥ ᩁᨾ᩠ᨾᩮᩣ, ᩍᩈᩥᩈᩥᨦ᩠ᨣᩔ ᩋᩔᨾᩮᩣ.

᪖.

‘‘ᩑᩈᩮᩣ ᩋᨣ᩠ᨣᩥᩔ ᩈᨦ᩠ᨡᩣᨲᩮᩣ, ᩑᩈᩮᩣ ᨵᩪᨾᩮᩣ ᨸᨴᩥᩔᨲᩥ;

ᨾᨬ᩠ᨬᩮ ᨶᩮᩣ ᩋᨣ᩠ᨣᩥᩴ ᩉᩣᨸᩮᨲᩥ, ᩍᩈᩥᩈᩥᨦ᩠ᨣᩮᩣ ᨾᩉᩥᨴ᩠ᨵᩥᨠᩮᩣ’’.

᪗.

‘‘ᨲᨬ᩠ᨧ ¶ ᨴᩥᩈ᩠ᩅᩣᨶ ᩌᨿᨶ᩠ᨲᩥᩴ, ᩌᨾᩩᨲ᩠ᨲᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᩴ;

ᩍᩈᩥᩈᩥᨦ᩠ᨣᩮᩣ ᨸᩣᩅᩥᩈᩥ ᨽᩦᨲᩮᩣ, ᩋᩔᨾᩴ ᨸᨱ᩠ᨱᨨᩣᨴᨶᩴ.

᪘.

‘‘ᩋᩔᨾᩔ ᨧ ᩈᩣ ᨴ᩠ᩅᩣᩁᩮ, ᨣᩮᨱ᩠ᨯᩩᨠᩮᨶᩔ [ᨽᩮᨱ᩠ᨯᩩᨠᩮᨶᩔ (ᩈᩦ. ᨸᩦ.)] ᨠᩦᩊᨲᩥ;

ᩅᩥᨴᩴᩈᨿᨶ᩠ᨲᩦ ᩋᨦ᩠ᨣᩣᨶᩥ, ᨣᩩᨿ᩠ᩉᩴ ᨸᨠᩣᩈᩥᨲᩣᨶᩥ ᨧ.

᪙.

‘‘ᨲᨬ᩠ᨧ ᨴᩥᩈ᩠ᩅᩣᨶ ᨠᩦᩊᨶ᩠ᨲᩥᩴ, ᨸᨱ᩠ᨱᩈᩣᩃᨣᨲᩮᩣ ᨩᨭᩦ;

ᩋᩔᨾᩣ ᨶᩥᨠ᩠ᨡᨾᩥᨲ᩠ᩅᩣᨶ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥ.

᪑᪐.

‘‘ᩋᨾ᩠ᨽᩮᩣ ᨠᩮᩣ ᨶᩣᨾ ᩈᩮᩣ ᩁᩩᨠ᩠ᨡᩮᩣ, ᨿᩔ ᨲᩮᩅᩴᨣᨲᩴ ᨹᩃᩴ;

ᨴᩪᩁᩮᨸᩥ ᨡᩥᨲ᩠ᨲᩴ ᨸᨧ᩠ᨧᩮᨲᩥ, ᨶ ᨲᩴ ᩒᩉᩣᨿ ᨣᨧ᩠ᨨᨲᩥ’’.

᪑᪑.

‘‘ᩋᩔᨾᩔ ¶ ᨾᨾ [ᨾᩴ (ᩈᩦ.)] ᨻᩕᩉ᩠ᨾᩮ, ᩈᨾᩦᨸᩮ ᨣᨶ᩠ᨵᨾᩣᨴᨶᩮ;

ᨻᩉᩅᩮᩣ [ᨸᨻ᩠ᨻᨲᩮ (ᩈᩦ.)] ᨲᩣᨴᩥᩈᩣ ᩁᩩᨠ᩠ᨡᩣ, ᨿᩔ ᨲᩮᩅᩴᨣᨲᩴ ᨹᩃᩴ;

ᨴᩪᩁᩮᨸᩥ ᨡᩥᨲ᩠ᨲᩴ ᨸᨧ᩠ᨧᩮᨲᩥ, ᨶ ᨾᩴ ᩒᩉᩣᨿ ᨣᨧ᩠ᨨᨲᩥ’’.

᪑᪒.

‘‘ᩑᨲᩪ ¶ [ᩑᨲᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)] ᨽᩅᩴ ᩋᩔᨾᩥᨾᩴ ᩋᨴᩮᨲᩩ, ᨸᨩ᩠ᨩᨬ᩠ᨧ ᨽᨠ᩠ᨡᨬ᩠ᨧ ᨸᨭᩥᨧ᩠ᨨ ᨴᨾ᩠ᨾᩥ;

ᩍᨴᨾᩣᩈᨶᩴ ᩋᨲᩕ ᨽᩅᩴ ᨶᩥᩈᩦᨴᨲᩩ, ᩍᨲᩮᩣ ᨽᩅᩴ ᨾᩪᩃᨹᩃᩣᨶᩥ ᨽᩩᨬ᩠ᨩᨲᩩ’’ [ᨡᩣᨴᨲᩩ (ᩈᩦ.)].

᪑᪓.

‘‘ᨠᩥᩴ ᨲᩮ ᩍᨴᩴ ᩐᩁᩪᨶᨾᨶ᩠ᨲᩁᩈ᩠ᨾᩥᩴ, ᩈᩩᨸᩥᨧ᩠ᨨᩥᨲᩴ ᨠᨱ᩠ᩉᩁᩥᩅᨸ᩠ᨸᨠᩣᩈᨲᩥ;

ᩋᨠ᩠ᨡᩣᩉᩥ ᨾᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᩑᨲᨾᨲ᩠ᨳᩴ, ᨠᩮᩣᩈᩮ ᨶᩩ ᨲᩮ ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᩴ ᨸᩅᩥᨭ᩠ᨮᩴ’’.

᪑᪔.

‘‘ᩋᩉᩴ ᩅᨶᩮ ᨾᩪᩃᨹᩃᩮᩈᨶᩴ ᨧᩁᩴ, ᩌᩈᩣᨴᨿᩥᩴ ¶ [ᩋᩔᩣᨴᨿᩥᩴ (ᨠ.)] ᩋᨧ᩠ᨨᩴ ᩈᩩᨥᩮᩣᩁᩁᩪᨸᩴ;

ᩈᩮᩣ ᨾᩴ ᨸᨲᩥᨲ᩠ᩅᩣ ᩈᩉᩈᩣᨩ᩠ᨫᨸᨲ᩠ᨲᩮᩣ, ᨸᨶᩩᨩ᩠ᨩ ᨾᩴ ᩋᨻ᩠ᨻᩉᩥ [ᩋᨻ᩠ᨻᩩᩉᩥ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᩴ.

᪑᪕.

‘‘ᩈ᩠ᩅᩣᨿᩴ ᩅᨱᩮᩣ ᨡᨩ᩠ᨩᨲᩥ ᨠᨱ᩠ᨯᩩᩅᩣᨿᨲᩥ, ᩈᨻ᩠ᨻᨬ᩠ᨧ ᨠᩣᩃᩴ ᨶ ᩃᨽᩣᨾᩥ ᩈᩣᨲᩴ;

ᨸᩉᩮᩣ ᨽᩅᩴ ᨠᨱ᩠ᨯᩩᨾᩥᨾᩴ ᩅᩥᨶᩮᨲᩩᩴ, ᨠᩩᩁᩩᨲᩴ ᨽᩅᩴ ᨿᩣᨧᩥᨲᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᨲ᩠ᨳᩴ’’.

᪑᪖.

‘‘ᨣᨾ᩠ᨽᩦᩁᩁᩪᨸᩮᩣ ᨲᩮ ᩅᨱᩮᩣ ᩈᩃᩮᩣᩉᩥᨲᩮᩣ, ᩋᨸᩪᨲᩥᨠᩮᩣ ᩅᨱᨣᨶ᩠ᨵᩮᩣ [ᨸᨠ᩠ᨠᨣᨶ᩠ᨵᩮᩣ (ᩈᩦ.), ᨸᨶ᩠ᨶᨣᨶ᩠ᨵᩮᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩉᩣ ᨧ;

ᨠᩁᩮᩣᨾᩥ ᨲᩮ ᨠᩥᨬ᩠ᨧᩥ ᨠᩈᩣᨿᨿᩮᩣᨣᩴ, ᨿᨳᩣ ᨽᩅᩴ ᨸᩁᨾᩈᩩᨡᩦ ᨽᩅᩮᨿ᩠ᨿ’’.

᪑᪗.

‘‘ᨶ ¶ ᨾᨶ᩠ᨲᨿᩮᩣᨣᩣ ᨶ ᨠᩈᩣᨿᨿᩮᩣᨣᩣ, ᨶ ᩒᩈᨵᩣ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥ [ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨠᨾᨶ᩠ᨲᩥ;

ᨥᨭ᩠ᨭᩮ ᨾᩩᨴᩩᨠᩮᨶ [ᨿᩴ ᨲᩮ ᨾᩩᨴᩩ ᨲᩮᨶ (ᩈᩦ.), ᨿᩴ ᨲᩮ ᨾᩩᨴᩪ ᨲᩮᨶ (ᨸᩦ.)] ᩅᩥᨶᩮᩉᩥ ᨠᨱ᩠ᨯᩩᩴ [ᨠᨱ᩠ᨯᩩᨠᩴ (ᨸᩦ.)], ᨿᨳᩣ ᩋᩉᩴ ᨸᩁᨾᩈᩩᨡᩦ ᨽᩅᩮᨿ᩠ᨿᩴ’’.

᪑᪘.

‘‘ᩍᨲᩮᩣ ᨶᩩ ᨽᩮᩣᨲᩮᩣ ᨠᨲᨾᩮᨶ ᩋᩔᨾᩮᩣ, ᨠᨧ᩠ᨧᩥ ᨽᩅᩴ ᩋᨽᩥᩁᨾᩈᩥ [ᩋᨽᩥᩁᨾᩈᩦ (ᨸᩦ.)] ᩋᩁᨬ᩠ᨬᩮ;

ᨠᨧ᩠ᨧᩥ ᨶᩩ ᨲᩮ [ᨠᨧ᩠ᨧᩥ ᨲᩮ (ᨸᩦ.)] ᨾᩪᩃᨹᩃᩴ ᨸᩉᩪᨲᩴ, ᨠᨧ᩠ᨧᩥ ᨽᩅᨶ᩠ᨲᩴ ᨶ ᩅᩥᩉᩥᩴᩈᨶ᩠ᨲᩥ ᩅᩣᩊᩣ’’.

᪑᪙.

‘‘ᩍᨲᩮᩣ ¶ ᩏᨩᩩᩴ ᩏᨲ᩠ᨲᩁᩣᨿᩴ ᨴᩥᩈᩣᨿᩴ, ᨡᩮᨾᩣᨶᨴᩦ ᩉᩥᨾᩅᨲᩣ ᨸᨽᩣᩅᩦ [ᨸᨽᩣᨲᩥ (ᩈᩦ. ᨸᩦ.)];

ᨲᩔᩣ ᨲᩦᩁᩮ ᩋᩔᨾᩮᩣ ᨾᨿ᩠ᩉ ᩁᨾ᩠ᨾᩮᩣ, ᩋᩉᩮᩣ ᨽᩅᩴ ᩋᩔᨾᩴ ᨾᨿ᩠ᩉᩴ ᨸᩔᩮ.

᪒᪐.

‘‘ᩋᨾ᩠ᨻᩣ ᨧ ᩈᩣᩃᩣ ᨲᩥᩃᨠᩣ ᨧ ᨩᨾ᩠ᨻᩩᨿᩮᩣ, ᩏᨴ᩠ᨴᩣᩃᨠᩣ ᨸᩣᨭᩃᩥᨿᩮᩣ ᨧ ᨹᩩᩃ᩠ᩃᩣ;

ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨠᩥᨾ᩠ᨸᩩᩁᩥᩈᩣᨽᩥᨣᩦᨲᩴ, ᩋᩉᩮᩣ ᨽᩅᩴ ᩋᩔᨾᩴ ᨾᨿ᩠ᩉᩴ ᨸᩔᩮ.

᪒᪑.

‘‘ᨲᩣᩃᩣ ᨧ ᨾᩪᩃᩣ ᨧ ᨹᩃᩣ ᨧ ᨾᩮᨲ᩠ᨳ, ᩅᨱ᩠ᨱᩮᨶ ᨣᨶ᩠ᨵᩮᨶ ᩏᨸᩮᨲᩁᩪᨸᩴ;

ᨲᩴ ᨽᩪᨾᩥᨽᩣᨣᩮᩉᩥ ᩏᨸᩮᨲᩁᩪᨸᩴ, ᩋᩉᩮᩣ ᨽᩅᩴ ᩋᩔᨾᩴ ᨾᨿ᩠ᩉᩴ ᨸᩔᩮ.

᪒᪑.

‘‘ᨹᩃᩣ ᨧ ᨾᩪᩃᩣ ᨧ ᨸᩉᩪᨲᨾᩮᨲ᩠ᨳ, ᩅᨱ᩠ᨱᩮᨶ ᨣᨶ᩠ᨵᩮᨶ ᩁᩈᩮᨶᩩᨸᩮᨲᩣ;

ᩌᨿᨶ᩠ᨲᩥ ᨧ ᩃᩩᨴ᩠ᨴᨠᩣ ᨲᩴ ᨸᨴᩮᩈᩴ, ᨾᩣ ᨾᩮ ᨲᨲᩮᩣ ᨾᩪᩃᨹᩃᩴ ᩋᩉᩣᩈᩩᩴ’’.

᪒᪓.

‘‘ᨸᩥᨲᩣ ᨾᨾᩴ ᨾᩪᩃᨹᩃᩮᩈᨶᩴ ᨣᨲᩮᩣ, ᩍᨴᩣᨶᩥ ᩌᨣᨧ᩠ᨨᨲᩥ ᩈᩣᨿᨠᩣᩃᩮ;

ᩏᨽᩮᩣᩅ ᨣᨧ᩠ᨨᩣᨾᩈᩮ ᩋᩔᨾᩴ ᨲᩴ, ᨿᩣᩅ ¶ ᨸᩥᨲᩣ ᨾᩪᩃᨹᩃᨲᩮᩣ ᩑᨲᩩ’’.

᪒᪔.

‘‘ᩋᨬ᩠ᨬᩮ ¶ ᨻᩉᩪ ᩍᩈᨿᩮᩣ ᩈᩣᨵᩩᩁᩪᨸᩣ, ᩁᩣᨩᩦᩈᨿᩮᩣ ᩋᨶᩩᨾᨣ᩠ᨣᩮ ᩅᩈᨶ᩠ᨲᩥ;

ᨲᩮ ᨿᩮᩅ ᨸᩩᨧ᩠ᨨᩮᩈᩥ ᨾᨾᩔᨾᩴ ᨲᩴ, ᨲᩮ ᨲᩴ ᨶᨿᩥᩔᨶ᩠ᨲᩥ ᨾᨾᩴ ᩈᨠᩣᩈᩮ’’.

᪒᪕.

‘‘ᨶ ᨲᩮ ᨠᨭ᩠ᨮᩣᨶᩥ ᨽᩥᨶ᩠ᨶᩣᨶᩥ, ᨶ ᨲᩮ ᩏᨴᨠᨾᩣᨽᨲᩴ;

ᩋᨣ᩠ᨣᩦᨸᩥ ᨲᩮ ᨶ ᩉᩣᨸᩥᨲᩮᩣ [ᩉᩣᩈᩥᨲᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᨠᩥᩴ ᨶᩩ ᨾᨶ᩠ᨴᩮᩣᩅ ᨫᩣᨿᩈᩥ.

᪒᪖.

‘‘ᨽᩥᨶ᩠ᨶᩣᨶᩥ ᨠᨭ᩠ᨮᩣᨶᩥ ᩉᩩᨲᩮᩣ ᨧ ᩋᨣ᩠ᨣᩥ, ᨲᨸᨶᩦᨸᩥ ᨲᩮ ᩈᨾᩥᨲᩣ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ [ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥ (?)];

ᨸᩦᨮᨬ᩠ᨧ ᨾᨿ᩠ᩉᩴ ᩏᨴᨠᨬ᩠ᨧ ᩉᩮᩣᨲᩥ, ᩁᨾᩈᩥ ᨲᩩᩅᩴ [ᨲ᩠ᩅᩴ (ᩈᩦ.)] ᨻᩕᩉ᩠ᨾᨽᩪᨲᩮᩣ ᨸᩩᩁᨲ᩠ᨳᩣ.

᪒᪗.

‘‘ᩋᨽᩥᨶ᩠ᨶᨠᨭ᩠ᨮᩮᩣᩈᩥ ¶ ᩋᨶᩣᨽᨲᩮᩣᨴᨠᩮᩣ, ᩋᩉᩣᨸᩥᨲᨣ᩠ᨣᩦᩈᩥ [ᩋᩉᩣᨸᩥᨲᨣ᩠ᨣᩦᨸᩥ (ᨠ.)] ᩋᩈᩥᨴ᩠ᨵᨽᩮᩣᨩᨶᩮᩣ [ᩋᩈᩥᨭ᩠ᨮᨽᩮᩣᨩᨶᩮᩣ (ᨠ.)];

ᨶ ᨾᩮ ᨲᩩᩅᩴ ᩌᩃᨸᩈᩦ ᨾᨾᨩ᩠ᨩ, ᨶᨭ᩠ᨮᩴ ᨶᩩ ᨠᩥᩴ ᨧᩮᨲᩈᩥᨠᨬ᩠ᨧ ᨴᩩᨠ᩠ᨡᩴ’’.

᪒᪘.

‘‘ᩍᨵᩣᨣᨾᩣ ᨩᨭᩥᩃᩮᩣ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ, ᩈᩩᨴᩔᨶᩮᨿ᩠ᨿᩮᩣ ᩈᩩᨲᨶᩪ ᩅᩥᨶᩮᨲᩥ;

ᨶᩮᩅᩣᨲᩥᨴᩦᨥᩮᩣ ᨶ ᨸᨶᩣᨲᩥᩁᩔᩮᩣ, ᩈᩩᨠᨱ᩠ᩉᨠᨱ᩠ᩉᨧ᩠ᨨᨴᨶᩮᩉᩥ ᨽᩮᩣᨲᩮᩣ.

᪒᪙.

‘‘ᩋᨾᩔᩩᨩᩣᨲᩮᩣ ¶ ᩋᨸᩩᩁᩣᨱᩅᨱ᩠ᨱᩦ, ᩌᨵᩣᩁᩁᩪᨸᨬ᩠ᨧ ᨸᨶᩔ ᨠᨱ᩠ᨮᩮ;

ᨴ᩠ᩅᩮ ᨿᨾᩣ [ᨴ᩠ᩅᩮ ᨸᩔ (ᩈᩦ.), ᨴ᩠ᩅᩣᩔ (ᨸᩦ.)] ᨣᨱ᩠ᨯᩣ ᩏᩁᩮᩈᩩ ᨩᩣᨲᩣ, ᩈᩩᩅᨱ᩠ᨱᨲᩥᨶ᩠ᨴᩩᨠᨶᩥᨽᩣ [ᩈᩩᩅᨱ᩠ᨱᨸᩥᨶ᩠ᨴᩪᨸᨶᩥᨽᩣ (ᩈᩦ.), ᩈᩩᩅᨱ᩠ᨱᨲᩥᨱ᩠ᨯᩩᩈᨶ᩠ᨶᩥᨽᩣ (ᩈ᩠ᨿᩣ.), ᩈᩮᩣᩅᨶ᩠ᨶᨸᩥᨱ᩠ᨯᩪᨸᨶᩥᨽᩣ (ᨸᩦ.)] ᨸᨽᩔᩁᩣ.

᪓᪐.

‘‘ᨾᩩᨡᨬ᩠ᨧ ᨲᩔ ᨽᩩᩈᨴᩔᨶᩮᨿ᩠ᨿᩴ, ᨠᨱ᩠ᨱᩮᩈᩩ ᩃᨾ᩠ᨻᨶ᩠ᨲᩥ ᨧ ᨠᩩᨬ᩠ᨧᩥᨲᨣ᩠ᨣᩣ;

ᨲᩮ ᨩᩮᩣᨲᩁᩮ ᨧᩁᨲᩮᩣ ᨾᩣᨱᩅᩔ, ᩈᩩᨲ᩠ᨲᨬ᩠ᨧ ᨿᩴ ᩈᩴᨿᨾᨶᩴ ᨩᨭᩣᨶᩴ.

᪓᪑.

‘‘ᩋᨬ᩠ᨬᩣ ¶ ᨧ ᨲᩔ ᩈᩴᨿᨾᩣᨶᩥ [ᩈᩴᨿᨾᨶᩦ (ᩈᩦ. ᨸᩦ.)] ᨧᨲᩔᩮᩣ, ᨶᩦᩃᩣ ᨸᩦᨲᩣ [ᨶᩦᩃᩣᨸᩥ ᨲᩣ (ᨸᩦ.)] ᩃᩮᩣᩉᩥᨲᩥᨠᩣ [ᩃᩮᩣᩉᩥᨲᨠᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᨧ ᩈᩮᨲᩣ;

ᨲᩣ ᨸᩥᩴᩈᩁᩮ [ᩈᩴᩈᩁᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨧᩁᨲᩮᩣ ᨾᩣᨱᩅᩔ, ᨲᩥᩁᩥᨭᩥ [ᨧᩥᩁᩦᨭᩥ (ᩈᩦ. ᨸᩦ.)] ᩈᨦ᩠ᨥᩣᩁᩥᩅ ᨸᩣᩅᩩᩈᨾ᩠ᩉᩥ.

᪓᪒.

‘‘ᨶ ᨾᩥᨡᩃᩴ ᨾᩩᨬ᩠ᨩᨾᨿᩴ ᨵᩣᩁᩮᨲᩥ, ᨶ ᩈᨶ᩠ᨳᩁᩮ [ᩈᨶ᩠ᨲᨧᩮ (ᩈᩦ.), ᩈᨶ᩠ᨲᨧᩴ (ᨸᩦ.), ᩈᨶ᩠ᨲᩁᩮ (ᨠ.)] ᨶᩮᩣ ᨸᨶ ᨸᨻ᩠ᨻᨩᩔ;

ᨲᩣ ᨩᩮᩣᨲᩁᩮ ᨩᨥᨶᨶ᩠ᨲᩁᩮ [ᨩᨥᨶᩅᩁᩮ (ᩈᩦ. ᨸᩦ.)] ᩅᩥᩃᨣ᩠ᨣᩣ, ᩈᨲᩮᩁᨲᩣ ᩅᩥᨩ᩠ᨩᩩᩁᩥᩅᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ.

᪓᪓.

‘‘ᩋᨡᩦᩃᨠᩣᨶᩥ ᨧ ᩋᩅᨱ᩠ᨭᨠᩣᨶᩥ, ᩉᩮᨭ᩠ᨮᩣ ᨶᨽ᩠ᨿᩣ ᨠᨭᩥᩈᨾᩮᩣᩉᩥᨲᩣᨶᩥ;

ᩋᨥᨭ᩠ᨭᩥᨲᩣ ᨶᩥᨧ᩠ᨧᨠᩦᩊᩴ ᨠᩁᩮᩣᨶ᩠ᨲᩥ, ᩉᩴ ᨲᩣᨲ ᨠᩥᩴᩁᩩᨠ᩠ᨡᨹᩃᩣᨶᩥ ᨲᩣᨶᩥ.

᪓᪔.

‘‘ᨩᨭᩣ ¶ ᨧ ᨲᩔ ᨽᩩᩈᨴᩔᨶᩮᨿ᩠ᨿᩣ, ᨸᩁᩮᩣᩈᨲᩴ ᩅᩮᩃ᩠ᩃᩥᨲᨣ᩠ᨣᩣ ᩈᩩᨣᨶ᩠ᨵᩣ;

ᨴ᩠ᩅᩮᨵᩣ ᩈᩥᩁᩮᩣ ᩈᩣᨵᩩ ᩅᩥᨽᨲ᩠ᨲᩁᩪᨸᩮᩣ, ᩋᩉᩮᩣ ᨶᩩ ᨡᩮᩣ ᨾᨿ᩠ᩉ ᨲᨳᩣ ᨩᨭᩣᩔᩩ.

᪓᪕.

‘‘ᨿᨴᩣ ᨧ ᩈᩮᩣ ᨸᨠᩥᩁᨲᩥ ᨲᩣ ᨩᨭᩣᨿᩮᩣ, ᩅᨱ᩠ᨱᩮᨶ ᨣᨶ᩠ᨵᩮᨶ ᩏᨸᩮᨲᩁᩪᨸᩣ;

ᨶᩦᩃᩩᨸ᩠ᨸᩃᩴ ᩅᩣᨲᩈᨾᩮᩁᩥᨲᩴᩅ, ᨲᨳᩮᩅ ᩈᩴᩅᩣᨲᩥ ᨸᨶᩔᨾᩮᩣ ᩋᨿᩴ.

᪓᪖.

‘‘ᨸᨦ᩠ᨠᩮᩣ ᨧ ᨲᩔ ᨽᩩᩈᨴᩔᨶᩮᨿ᩠ᨿᩮᩣ, ᨶᩮᨲᩣᨴᩥᩈᩮᩣ ᨿᩣᨴᩥᩈᩮᩣ ᨾᨿ᩠ᩉᩴ ᨠᩣᨿᩮ [ᨠᩣᨿᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᩈᩮᩣ ᩅᩣᨿᨲᩦ ᩑᩁᩥᨲᩮᩣ ᨾᩣᩃᩩᨲᩮᨶ, ᩅᨶᩴ ᨿᨳᩣ ᩋᨣ᩠ᨣᨣᩥᨾ᩠ᩉᩮ ᩈᩩᨹᩩᩃ᩠ᩃᩴ.

᪓᪗.

‘‘ᨶᩥᩉᨶ᩠ᨲᩥ ¶ ᩈᩮᩣ ᩁᩩᨠ᩠ᨡᨹᩃᩴ ᨸᨳᨻ᩠ᨿᩣ, ᩈᩩᨧᩥᨲ᩠ᨲᩁᩪᨸᩴ ᩁᩩᨧᩥᩁᩴ ᨴᩔᨶᩮᨿ᩠ᨿᩴ;

ᨡᩥᨲ᩠ᨲᨬ᩠ᨧ ᨲᩔ ᨸᩩᨶᩁᩮᨲᩥ ᩉᨲ᩠ᨳᩴ, ᩉᩴ ᨲᩣᨲ ᨠᩥᩴᩁᩩᨠ᩠ᨡᨹᩃᩴ ᨶᩩ ᨡᩮᩣ ᨲᩴ.

᪓᪘.

‘‘ᨴᨶ᩠ᨲᩣ ᨧ ᨲᩔ ᨽᩩᩈᨴᩔᨶᩮᨿ᩠ᨿᩣ, ᩈᩩᨴ᩠ᨵᩣ ᩈᨾᩣ ᩈᨦ᩠ᨡᩅᩁᩪᨸᨸᨶ᩠ᨶᩣ;

ᨾᨶᩮᩣ ᨸᩈᩣᨴᩮᨶ᩠ᨲᩥ ᩅᩥᩅᩁᩥᨿᨾᩣᨶᩣ, ᨶ ᩉᩥ [ᨶ ᩉ (ᩈᩦ. ᨸᩦ.)] ᨶᩪᨶ ᩈᩮᩣ ᩈᩣᨠᨾᨡᩣᨴᩥ ᨲᩮᩉᩥ.

᪓᪙.

‘‘ᩋᨠᨠ᩠ᨠᩈᩴ ¶ ᩋᨣ᩠ᨣᩊᩥᨲᩴ ᨾᩩᩉᩩᩴ ᨾᩩᨴᩩᩴ, ᩏᨩᩩᩴ ᩋᨶᩩᨴ᩠ᨵᨲᩴ ᩋᨧᨸᩃᨾᩔ ᨽᩣᩈᩥᨲᩴ;

ᩁᩩᨴᩴ ᨾᨶᩩᨬ᩠ᨬᩴ ᨠᩁᩅᩦᨠᩈᩩᩔᩁᩴ, ᩉᨴᨿᨦ᩠ᨣᨾᩴ ᩁᨬ᩠ᨩᨿᨲᩮᩅ ᨾᩮ ᨾᨶᩮᩣ.

᪔᪐.

‘‘ᨻᩥᨶ᩠ᨴᩩᩔᩁᩮᩣ ᨶᩣᨲᩥᩅᩥᩈᨭ᩠ᨮᩅᩣᨠ᩠ᨿᩮᩣ [ᨶᩣᨲᩥᩅᩥᩔᨭ᩠ᨮᩅᩣᨠ᩠ᨿᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨶ ᨶᩪᨶ ᩈᨩ᩠ᨫᩣᨿᨾᨲᩥᨸ᩠ᨸᨿᩩᨲ᩠ᨲᩮᩣ;

ᩍᨧ᩠ᨨᩣᨾᩥ ᨽᩮᩣ [ᨡᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨲᩴ ᨸᩩᨶᨴᩮᩅ ᨴᨭ᩠ᨮᩩᩴ, ᨾᩥᨲ᩠ᨲᩮᩣ ᩉᩥ [ᨾᩥᨲ᩠ᨲᩴ ᩉᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩮ ᨾᩣᨱᩅᩮᩣᩉᩩ [ᨾᩣᨱᩅᩣᩉᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨾᩣᨱᩅᩣᩉᩪ (ᨸᩦ.)] ᨸᩩᩁᨲ᩠ᨳᩣ.

᪔᪑.

‘‘ᩈᩩᩈᨶ᩠ᨵᩥ ¶ ᩈᨻ᩠ᨻᨲ᩠ᨳ ᩅᩥᨾᨭ᩠ᨮᩥᨾᩴ ᩅᨱᩴ, ᨸᩩᨳᩪ [ᨸᩩᨳᩩᩴ (ᨸᩦ.), ᨸᩩᨳᩩ (ᨠ.)] ᩈᩩᨩᩣᨲᩴ ᨡᩁᨸᨲ᩠ᨲᩈᨶ᩠ᨶᩥᨽᩴ;

ᨲᩮᨶᩮᩅ ᨾᩴ ᩏᨲ᩠ᨲᩁᩥᨿᩣᨶ ᨾᩣᨱᩅᩮᩣ, ᩅᩥᩅᩁᩥᨲᩴ ᩐᩁᩩᩴ ᨩᨥᨶᩮᨶ ᨸᩦᩊᨿᩥ.

᪔᪒.

‘‘ᨲᨸᨶ᩠ᨲᩥ ᩌᨽᨶ᩠ᨲᩥ ᩅᩥᩁᩮᩣᨧᩁᩮ ᨧ, ᩈᨲᩮᩁᨲᩣ ᩅᩥᨩ᩠ᨩᩩᩁᩥᩅᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ;

ᨻᩣᩉᩣ ᨾᩩᨴᩪ ᩋᨬ᩠ᨩᨶᩃᩮᩣᨾᩈᩣᨴᩥᩈᩣ, ᩅᩥᨧᩥᨲᩕᩅᨭ᩠ᨭᨦ᩠ᨣᩩᩃᩥᨠᩣᩔ ᩈᩮᩣᨽᩁᩮ.

᪔᪓.

‘‘ᩋᨠᨠ᩠ᨠᩈᨦ᩠ᨣᩮᩣ ¶ ᨶ ᨧ ᨴᩦᨥᩃᩮᩣᨾᩮᩣ, ᨶᨡᩣᩔ ᨴᩦᨥᩣ ᩋᨸᩥ ᩃᩮᩣᩉᩥᨲᨣ᩠ᨣᩣ;

ᨾᩩᨴᩪᩉᩥ ᨻᩣᩉᩣᩉᩥ ᨸᩃᩥᩔᨩᨶ᩠ᨲᩮᩣ, ᨠᩃ᩠ᨿᩣᨱᩁᩪᨸᩮᩣ ᩁᨾᨿᩴ [ᩁᨾᨿ᩠ᩉᩴ (ᨠ.)] ᩏᨸᨭ᩠ᨮᩉᩥ.

᪔᪔.

‘‘ᨴᩩᨾᩔ ¶ ᨲᩪᩃᩪᨸᨶᩥᨽᩣ ᨸᨽᩔᩁᩣ, ᩈᩩᩅᨱ᩠ᨱᨠᨾ᩠ᨻᩩᨲᩃᩅᨭ᩠ᨭᩈᩩᨧ᩠ᨨᩅᩦ;

ᩉᨲ᩠ᨳᩣ ᨾᩩᨴᩪ ᨲᩮᩉᩥ ᨾᩴ ᩈᩴᨹᩩᩈᩥᨲ᩠ᩅᩣ, ᩍᨲᩮᩣ ᨣᨲᩮᩣ ᨲᩮᨶ ᨾᩴ ᨴᩉᨶ᩠ᨲᩥ ᨲᩣᨲ.

᪔᪕.

‘‘ᨶ ᨶᩪᨶ [ᨶ ᩉ ᨶᩪᨶ (ᩈᩦ. ᨸᩦ.)] ᩈᩮᩣ ᨡᩣᩁᩥᩅᩥᨵᩴ ᩋᩉᩣᩈᩥ, ᨶ ᨶᩪᨶ ᩈᩮᩣ ᨠᨭ᩠ᨮᩣᨶᩥ ᩈᨿᩴ ᩋᨽᨬ᩠ᨩᩥ;

ᨶ ᨶᩪᨶ ᩈᩮᩣ ᩉᨶ᩠ᨲᩥ ᨴᩩᨾᩮ ᨠᩩᨮᩣᩁᩥᨿᩣ [ᨠᩩᨵᩣᩁᩥᨿᩣ (ᨠ.)], ᨶ ᩉᩥᩔ [ᨶ ᨸᩥᩔ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩉᨲ᩠ᨳᩮᩈᩩ ᨡᩥᩃᩣᨶᩥ ᩋᨲ᩠ᨳᩥ.

᪔᪖.

‘‘ᩋᨧ᩠ᨨᩮᩣ ᨧ ᨡᩮᩣ ᨲᩔ ᩅᨱᩴ ᩋᨠᩣᩈᩥ, ᩈᩮᩣ ᨾᩴᨻᩕᩅᩥ ᩈᩩᨡᩥᨲᩴ ᨾᩴ ᨠᩁᩮᩣᩉᩥ;

ᨲᩣᩉᩴ ᨠᩁᩥᩴ ᨲᩮᨶ ᨾᨾᩣᩈᩥ ᩈᩮᩣᨡ᩠ᨿᩴ, ᩈᩮᩣ ᨧᨻᩕᩅᩥ ᩈᩩᨡᩥᨲᩮᩣᩈ᩠ᨾᩦᨲᩥ ᨻᩕᩉ᩠ᨾᩮ.

᪔᪗.

‘‘ᩋᨿᨬ᩠ᨧ ᨲᩮ ᨾᩣᩃᩩᩅᨸᨱ᩠ᨱᩈᨶ᩠ᨳᨲᩣ, ᩅᩥᨠᩥᨱ᩠ᨱᩁᩪᨸᩣᩅ ᨾᨿᩣ ᨧ ᨲᩮᨶ ᨧ;

ᨠᩥᩃᨶ᩠ᨲᩁᩪᨸᩣ ᩏᨴᨠᩮ ᩁᨾᩥᨲ᩠ᩅᩣ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ ᨸᨱ᩠ᨱᨠᩩᨭᩥᩴ ᩅᨩᩣᨾ.

᪔᪘.

‘‘ᨶ ᨾᨩ᩠ᨩ ᨾᨶ᩠ᨲᩣ ᨸᨭᩥᨽᨶ᩠ᨲᩥ ᨲᩣᨲ, ᨶ ᩋᨣ᩠ᨣᩥᩉᩩᨲ᩠ᨲᩴ ᨶᨸᩥ ᨿᨬ᩠ᨬᨲᨶ᩠ᨲᩴ [ᨿᨬ᩠ᨬᨲᨶ᩠ᨲᩕᩴ (ᩈᩦ.), ᨿᨬ᩠ᨬᩴ ᨲᨲᩕ (ᨸᩦ. ᨠ.), ᨿᨬ᩠ᨬᨲᨲᩕ (ᩈ᩠ᨿᩣ.)];

ᨶ ᨧᩣᨸᩥ ᨲᩮ ᨾᩪᩃᨹᩃᩣᨶᩥ ᨽᩩᨬ᩠ᨩᩮ, ᨿᩣᩅ ¶ ᨶ ᨸᩔᩣᨾᩥ ᨲᩴ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᩴ.

᪔᪙.

‘‘ᩋᨴ᩠ᨵᩣ ¶ ᨸᨩᩣᨶᩣᩈᩥ ᨲᩩᩅᨾ᩠ᨸᩥ ᨲᩣᨲ, ᨿᩔᩴ ᨴᩥᩈᩴ [ᨴᩥᩈᩣᨿᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᩅᩈᨲᩮ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ;

ᨲᩴ ᨾᩴ ᨴᩥᩈᩴ ᨸᩣᨸᨿ ᨲᩣᨲ ᨡᩥᨸ᩠ᨸᩴ, ᨾᩣ ᨲᩮ ᩋᩉᩴ ᩋᨾᩁᩥᨾᩔᨾᨾ᩠ᩉᩥ.

᪕᪐.

‘‘ᩅᩥᨧᩥᨲᩕᨹᩩᩃ᩠ᩃᩴ [ᩅᩥᨧᩥᨲᩕᨸᩩᨸ᩠ᨹᩴ (ᩈᩦ. ᨸᩦ.)] ᩉᩥ ᩅᨶᩴ ᩈᩩᨲᩴ ᨾᨿᩣ, ᨴᩥᨩᩣᨽᩥᨥᩩᨭ᩠ᨮᩴ ᨴᩥᨩᩈᨦ᩠ᨥᩈᩮᩅᩥᨲᩴ;

ᨲᩴ ᨾᩴ ᩅᨶᩴ ᨸᩣᨸᨿ ᨲᩣᨲ ᨡᩥᨸ᩠ᨸᩴ, ᨸᩩᩁᩣ ᨲᩮ ᨸᩣᨱᩴ ᩅᩥᨩᩉᩣᨾᩥ ᩋᩔᨾᩮ’’.

᪕᪑.

‘‘ᩍᨾᩈ᩠ᨾᩣᩉᩴ ᨩᩮᩣᨲᩥᩁᩈᩮ ᩅᨶᨾ᩠ᩉᩥ, ᨣᨶ᩠ᨵᨻ᩠ᨻᨴᩮᩅᨧ᩠ᨨᩁᩈᨦ᩠ᨥᩈᩮᩅᩥᨲᩮ;

ᩍᩈᩦᨶᨾᩣᩅᩣᩈᩮ ᩈᨶᨶ᩠ᨲᨶᨾ᩠ᩉᩥ, ᨶᩮᨲᩣᨴᩥᩈᩴ ᩋᩁᨲᩥᩴ ᨸᩣᨸᩩᨱᩮᨳ.

᪕᪒.

‘‘ᨽᩅᨶ᩠ᨲᩥ ᨾᩥᨲ᩠ᨲᩣᨶᩥ ᩋᨳᩮᩣ ᨶ ᩉᩮᩣᨶ᩠ᨲᩥ, ᨬᩣᨲᩦᩈᩩ ᨾᩥᨲ᩠ᨲᩮᩈᩩ ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᨸᩮᨾᩴ;

ᩋᨿᨬ᩠ᨧ ᨩᨾ᩠ᨾᩮᩣ ᨠᩥᩔ ᩅᩣ ᨶᩥᩅᩥᨭ᩠ᨮᩮᩣ, ᨿᩮᩣ ᨶᩮᩅ ᨩᩣᨶᩣᨲᩥ ᨠᩩᨲᩮᩣᨾ᩠ᩉᩥ ᩌᨣᨲᩮᩣ.

᪕᪓.

‘‘ᩈᩴᩅᩣᩈᩮᨶ ᩉᩥ ᨾᩥᨲ᩠ᨲᩣᨶᩥ, ᩈᨶ᩠ᨵᩥᨿᨶ᩠ᨲᩥ [ᩈᨶ᩠ᨵᩦᨿᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ;

ᩈ᩠ᩅᩮᩅ ᨾᩥᨲ᩠ᨲᩮᩣ [ᩈᩣ ᨧ ᨾᩮᨲ᩠ᨲᩥ (ᨸᩦ.)] ᩋᩈᩴᨣᨶ᩠ᨲᩩ, ᩋᩈᩴᩅᩣᩈᩮᨶ ᨩᩦᩁᨲᩥ.

᪕᪔.

‘‘ᩈᨧᩮ ¶ ᨲᩩᩅᩴ ᨴᨠ᩠ᨡᩈᩥ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᩴ, ᩈᨧᩮ ᨲᩩᩅᩴ ᩈᩃ᩠ᩃᨸᩮ [ᩈᩃ᩠ᩃᨸᩥ (ᩈᩦ.)] ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩣ;

ᩈᨾ᩠ᨸᨶ᩠ᨶᩈᩔᩴᩅ ᨾᩉᩮᩣᨴᨠᩮᨶ, ᨲᨸᩮᩣᨣᩩᨱᩴ ᨡᩥᨸ᩠ᨸᨾᩥᨾᩴ ᨸᩉᩥᩔᩈᩥ [ᨸᩉᩔᩈᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪕᪕.

‘‘ᨸᩩᨶᨸᩥ ¶ [ᨸᩩᨶᨸ᩠ᨸᩥ (ᨸᩦ.)] ᨧᩮ ᨴᨠ᩠ᨡᩈᩥ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᩴ, ᨸᩩᨶᨸᩥ [ᨸᩩᨶᨸ᩠ᨸᩥ (ᨸᩦ.)] ᨧᩮ ᩈᩃ᩠ᩃᨸᩮ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩣ;

ᩈᨾ᩠ᨸᨶ᩠ᨶᩈᩔᩴᩅ ᨾᩉᩮᩣᨴᨠᩮᨶ, ᩏᩈ᩠ᨾᩣᨣᨲᩴ ᨡᩥᨸ᩠ᨸᨾᩥᨾᩴ ᨸᩉᩥᩔᩈᩥ.

᪕᪖.

‘‘ᨽᩪᨲᩣᨶᩥ ¶ ᩉᩮᨲᩣᨶᩥ [ᩑᨲᩣᨶᩥ (ᨸᩦ.)] ᨧᩁᨶ᩠ᨲᩥ ᨲᩣᨲ, ᩅᩥᩁᩪᨸᩁᩪᨸᩮᨶ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ;

ᨶ ᨲᩣᨶᩥ ᩈᩮᩅᩮᨳ ᨶᩁᩮᩣ ᩈᨸᨬ᩠ᨬᩮᩣ, ᩌᩈᨩ᩠ᨩ ᨶᩴ ᨶᩔᨲᩥ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ’’ᨲᩥ.

ᨶᩥᩊᩥᨶᩥᨠᩣᨩᩣᨲᨠᩴ [ᨶᩊᩥᨶᩦᨩᩣᨲᨠᩴ (ᩈᩦ.), ᨶᩊᩥᨶᩥᨩᩣᨲᨠᩴ (ᨸᩦ.)] ᨸᨮᨾᩴ.

᪕᪒᪗. ᩏᨾ᩠ᨾᩣᨴᨶ᩠ᨲᩦᨩᩣᨲᨠᩴ (᪒)

᪕᪗.

‘‘ᨶᩥᩅᩮᩈᨶᩴ ᨠᩔ ᨶᩩᨴᩴ ᩈᩩᨶᨶ᩠ᨴ, ᨸᩣᨠᩣᩁᩮᨶ ᨸᨱ᩠ᨯᩩᨾᨿᩮᨶ ᨣᩩᨲ᩠ᨲᩴ;

ᨠᩣ ᨴᩥᩔᨲᩥ ᩋᨣ᩠ᨣᩥᩈᩥᨡᩣᩅ ᨴᩪᩁᩮ, ᩅᩮᩉᩣᨿᩈᩴ [ᩅᩮᩉᩣᩈᨿᩴ (ᩈᩦ. ᨸᩦ.)] ᨸᨻ᩠ᨻᨲᨣ᩠ᨣᩮᩅ ᩋᨧ᩠ᨧᩥ.

᪕᪘.

‘‘ᨵᩦᨲᩣ ¶ ᨶ᩠ᩅᨿᩴ [ᨶᨿᩴ (ᩈᩦ. ᨸᩦ.), ᨶ᩠ᩅᩣᨿᩴ (ᩈ᩠ᨿᩣ.)] ᨠᩔ ᩈᩩᨶᨶ᩠ᨴ ᩉᩮᩣᨲᩥ, ᩈᩩᨱᩥᩈᩣ ᨶ᩠ᩅᨿᩴ [ᨶᨿᩴ (ᩈᩦ. ᨸᩦ.), ᨶ᩠ᩅᩣᨿᩴ (ᩈ᩠ᨿᩣ.)] ᨠᩔ ᩋᨳᩮᩣᨸᩥ ᨽᩁᩥᨿᩣ;

ᩋᨠ᩠ᨡᩣᩉᩥ ᨾᩮ ᨡᩥᨸ᩠ᨸᨾᩥᨵᩮᩅ ᨸᩩᨭ᩠ᨮᩮᩣ, ᩋᩅᩣᩅᨭᩣ ᨿᨴᩥ ᩅᩣ ᩋᨲ᩠ᨳᩥ ᨽᨲ᩠ᨲᩣ’’.

᪕᪙.

‘‘ᩋᩉᨬ᩠ᩉᩥ ᨩᩣᨶᩣᨾᩥ ᨩᨶᩥᨶ᩠ᨴ ᩑᨲᩴ, ᨾᨲ᩠ᨿᩣ ᨧ ᨸᩮᨲ᩠ᨿᩣ ᨧ ᩋᨳᩮᩣᨸᩥ ᩋᩔᩣ;

ᨲᩅᩮᩅ ᩈᩮᩣ ᨸᩩᩁᩥᩈᩮᩣ ᨽᩪᨾᩥᨸᩣᩃ, ᩁᨲ᩠ᨲᩥᨶ᩠ᨴᩥᩅᩴ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ ᨲᩅᨲ᩠ᨳᩮ.

᪖᪐.

‘‘ᩍᨴ᩠ᨵᩮᩣ ᨧ ᨹᩦᨲᩮᩣ ᨧ ᩈᩩᩅᨯ᩠ᨰᩥᨲᩮᩣ [ᩈᩩᨻᩣᩊ᩠ᩉᩥᨠᩮᩣ (ᨸᩦ.)] ᨧ, ᩋᨾᨧ᩠ᨧᩮᩣ ᨧ ᨲᩮ ᩋᨬ᩠ᨬᨲᩁᩮᩣ ᨩᨶᩥᨶ᩠ᨴ;

ᨲᩔᩮᩈᩣ ᨽᩁᩥᨿᩣᨽᩥᨸᩣᩁᨠᩔ [ᩋᩉᩥᨸᩣᩁᨠᩔ (ᩈᩦ. ᨸᩦ.), ᩋᨽᩥᨸᩣᨴᨠᩔ (ᨠ.)], ᩏᨾ᩠ᨾᩣᨴᨶ᩠ᨲᩦ [ᩏᨾ᩠ᨾᩣᨴᨶ᩠ᨲᩦᨲᩥ (ᨠ.)] ᨶᩣᨾᨵᩮᨿ᩠ᨿᩮᨶ ᩁᩣᨩ’’.

᪖᪑.

‘‘ᩋᨾ᩠ᨽᩮᩣ ¶ ᩋᨾ᩠ᨽᩮᩣ ᨶᩣᨾᨾᩥᨴᩴ ᩍᨾᩥᩔᩣ, ᨾᨲ᩠ᨿᩣ ᨧ ᨸᩮᨲ᩠ᨿᩣ ᨧ ᨠᨲᩴ ᩈᩩᩈᩣᨵᩩ;

ᨲᨴᩣ [ᨲᨳᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩉᩥ ᨾᨿ᩠ᩉᩴ ᩋᩅᩃᩮᩣᨠᨿᨶ᩠ᨲᩦ, ᩏᨾ᩠ᨾᨲ᩠ᨲᨠᩴ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩦ ᩋᨠᩣᩈᩥ’’.

᪖᪒.

‘‘ᨿᩣ ᨸᩩᨱ᩠ᨱᨾᩣᩈᩮ [ᨸᩩᨱ᩠ᨱᨾᩣᨿᩮ (ᨠ.)] ᨾᩥᨣᨾᨶ᩠ᨴᩃᩮᩣᨧᨶᩣ, ᩏᨸᩣᩅᩥᩈᩥ ᨸᩩᨱ᩠ᨯᩁᩦᨠᨲ᩠ᨲᨧᨦ᩠ᨣᩦ;

ᨴ᩠ᩅᩮ ᨸᩩᨱ᩠ᨱᨾᩣᨿᩮᩣ ᨲᨴᩉᩪ ᩋᨾᨬ᩠ᨬᩉᩴ, ᨴᩥᩈ᩠ᩅᩣᨶ ᨸᩣᩁᩣᩅᨲᩁᨲ᩠ᨲᩅᩣᩈᩥᨶᩥᩴ.

᪖᪓.

‘‘ᩋᩊᩣᩁᨸᨾ᩠ᩉᩮᩉᩥ ¶ ᩈᩩᨽᩮᩉᩥ ᩅᨣ᩠ᨣᩩᨽᩥ, ᨸᩃᩮᩣᨽᨿᨶ᩠ᨲᩦ ᨾᩴ ᨿᨴᩣ ᩏᨴᩥᨠ᩠ᨡᨲᩥ;

ᩅᩥᨩᨾ᩠ᨽᨾᩣᨶᩣ ᩉᩁᨲᩮᩅ ᨾᩮ ᨾᨶᩮᩣ, ᨩᩣᨲᩣ ᩅᨶᩮ ᨠᩥᨾ᩠ᨸᩩᩁᩥᩈᩦᩅ ᨸᨻ᩠ᨻᨲᩮ.

᪖᪔.

‘‘ᨲᨴᩣ ᩉᩥ ᨻᩕᩉᨲᩦ ᩈᩣᨾᩣ, ᩌᨾᩩᨲ᩠ᨲᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᩣ;

ᩑᨠᨧ᩠ᨧᩅᩈᨶᩣ ᨶᩣᩁᩦ, ᨾᩥᨣᩦ ᨽᨶ᩠ᨲᩣᩅᩩᨴᩥᨠ᩠ᨡᨲᩥ.

᪖᪕.

‘‘ᨠᨴᩣᩔᩩ ᨾᩴ ᨲᨾ᩠ᨻᨶᨡᩣ ᩈᩩᩃᩮᩣᨾᩣ, ᨻᩣᩉᩣᨾᩩᨴᩪ ᨧᨶ᩠ᨴᨶᩈᩣᩁᩃᩥᨲ᩠ᨲᩣ;

ᩅᨭ᩠ᨭᨦ᩠ᨣᩩᩃᩦ ᩈᨶ᩠ᨶᨲᨵᩦᩁᨠᩩᨲ᩠ᨲᩥᨿᩣ, ᨶᩣᩁᩦ ᩏᨸᨬ᩠ᨬᩥᩔᨲᩥ ᩈᩦᩈᨲᩮᩣ ᩈᩩᨽᩣ.

᪖᪖.

‘‘ᨠᨴᩣᩔᩩ ᨾᩴ ᨠᨬ᩠ᨧᨶᨩᩣᩃᩩᩁᨧ᩠ᨨᨴᩣ, ᨵᩦᨲᩣ ᨲᩥᩁᩦᨭᩥᩔ ᩅᩥᩃᨣ᩠ᨣᨾᨩ᩠ᨫᩣ;

ᨾᩩᨴᩪᩉᩥ ᨻᩣᩉᩣᩉᩥ ᨸᩃᩥᩔᨩᩥᩔᨲᩥ, ᨻᩕᩉᩣᩅᨶᩮ ᨩᩣᨲᨴᩩᨾᩴᩅ ᨾᩣᩃᩩᩅᩣ.

᪖᪗.

‘‘ᨠᨴᩣᩔᩩ ¶ [ᨠᨴᩣᩔᩩ ᨾᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩃᩣᨡᩣᩁᩈᩁᨲ᩠ᨲᩈᩩᨧ᩠ᨨᩅᩦ, ᨻᩥᨶ᩠ᨴᩩᨲ᩠ᨳᨶᩦ ᨸᩩᨱ᩠ᨯᩁᩦᨠᨲ᩠ᨲᨧᨦ᩠ᨣᩦ;

ᨾᩩᨡᩴ ᨾᩩᨡᩮᨶ ᩏᨸᨶᩣᨾᨿᩥᩔᨲᩥ, ᩈᩮᩣᨱ᩠ᨯᩮᩣᩅ ᩈᩮᩣᨱ᩠ᨯᩔ ᩈᩩᩁᩣᨿ ᨳᩣᩃᩴ.

᪖᪘.

‘‘ᨿᨴᩣᨴ᩠ᨴᩈᩴ [ᨿᨳᩣᨴ᩠ᨴᩈᩴ (ᨸᩦ.)] ᨲᩴ ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥᩴ, ᩈᨻ᩠ᨻᨽᨴ᩠ᨴᩴ [ᩈᨻ᩠ᨻᨣᨲ᩠ᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᨶᩮᩣᩁᨾᩴ;

ᨲᨲᩮᩣ ¶ ᩈᨠᩔ ᨧᩥᨲ᩠ᨲᩔ, ᨶᩣᩅᨻᩮᩣᨵᩣᨾᩥ ᨠᨬ᩠ᨧᩥᨶᩴ [ᨠᩥᨬ᩠ᨧᩥᨶᩴ (ᨠ.), ᨠᩥᨬ᩠ᨧᨶᩴ (ᨸᩦ.)].

᪖᪙.

‘‘ᩏᨾ᩠ᨾᩣᨴᨶ᩠ᨲᩥᨾᩉᩴ ¶ ᨴᨭ᩠ᨮᩣ [ᨴᩥᨭ᩠ᨮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)], ᩌᨾᩩᨲ᩠ᨲᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᩴ;

ᨶ ᩈᩩᨸᩣᨾᩥ ᨴᩥᩅᩣᩁᨲ᩠ᨲᩥᩴ, ᩈᩉᩔᩴᩅ ᨸᩁᩣᨩᩥᨲᩮᩣ.

᪗᪐.

‘‘ᩈᨠ᩠ᨠᩮᩣ ᨧᩮ [ᨧ (ᩈᩦ. ᨸᩦ.)] ᨾᩮ ᩅᩁᩴ ᨴᨩ᩠ᨩᩣ, ᩈᩮᩣ ᨧ ᩃᨻ᩠ᨽᩮᨳ ᨾᩮ ᩅᩁᩮᩣ;

ᩑᨠᩁᨲ᩠ᨲᩴ ᨴ᩠ᩅᩥᩁᨲ᩠ᨲᩴ [ᨴᩥᩁᨲ᩠ᨲᩴ (ᨸᩦ.)] ᩅᩣ, ᨽᩅᩮᨿ᩠ᨿᩴ ᩋᨽᩥᨸᩣᩁᨠᩮᩣ;

ᩏᨾ᩠ᨾᩣᨴᨶ᩠ᨲ᩠ᨿᩣ ᩁᨾᩥᨲ᩠ᩅᩣᨶ, ᩈᩥᩅᩥᩁᩣᨩᩣ ᨲᨲᩮᩣ ᩈᩥᨿᩴ’’ [ᩈᩥᨿᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪗᪑.

‘‘ᨽᩪᨲᩣᨶᩥ ᨾᩮ ᨽᩪᨲᨸᨲᩦ ᨶᨾᩔᨲᩮᩣ, ᩌᨣᨾ᩠ᨾ ᨿᨠ᩠ᨡᩮᩣ ᩍᨴᨾᩮᨲᨴᨻᩕᩅᩥ;

ᩁᨬ᩠ᨬᩮᩣ ᨾᨶᩮᩣ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲ᩠ᨿᩣ ᨶᩥᩅᩥᨭ᩠ᨮᩮᩣ, ᨴᨴᩣᨾᩥ ᨲᩮ ᨲᩴ ᨸᩁᩥᨧᩣᩁᨿᩔᩩ’’.

᪗᪒.

‘‘ᨸᩩᨬ᩠ᨬᩣ ᩅᩥᨵᩴᩈᩮ ᩋᨾᩁᩮᩣ ᨶ ᨧᨾ᩠ᩉᩥ, ᨩᨶᩮᩣ ᨧ ᨾᩮ ᨸᩣᨸᨾᩥᨴᨬ᩠ᨧ [ᨸᩣᨸᨾᩥᨴᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᨩᨬ᩠ᨬᩣ;

ᨽᩩᩈᩮᩣ ᨧ ᨲ᩠ᨿᩔ ᨾᨶᩈᩮᩣ ᩅᩥᨥᩣᨲᩮᩣ, ᨴᨲ᩠ᩅᩣ ᨸᩥᨿᩴ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩥᩴ ᩋᨴᨭ᩠ᨮᩣ’’.

᪗᪓.

‘‘ᨩᨶᩥᨶ᩠ᨴ ᨶᩣᨬ᩠ᨬᨲᩕ ᨲᨿᩣ ᨾᨿᩣ ᩅᩣ, ᩈᨻ᩠ᨻᩣᨸᩥ ᨠᨾ᩠ᨾᩔ ᨠᨲᩔ ᨩᨬ᩠ᨬᩣ;

ᨿᩴ ᨲᩮ ᨾᨿᩣ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩦ ᨸᨴᩥᨶ᩠ᨶᩣ, ᨽᩩᩈᩮᩉᩥ ᩁᩣᨩᩣ ᩅᨶᨳᩴ ᩈᨩᩣᩉᩥ’’.

᪗᪔.

‘‘ᨿᩮᩣ ᨸᩣᨸᨠᩴ ᨠᨾ᩠ᨾ ᨠᩁᩴ ᨾᨶᩩᩔᩮᩣ, ᩈᩮᩣ ¶ ᨾᨬ᩠ᨬᨲᩥ ᨾᩣᨿᩥᨴ [ᨾᩣᨿᩥᨵ (ᨠ.)] ᨾᨬ᩠ᨬᩥᩴᩈᩩ ᩋᨬ᩠ᨬᩮ;

ᨸᩔᨶ᩠ᨲᩥ ᨽᩪᨲᩣᨶᩥ ᨠᩁᩮᩣᨶ᩠ᨲᨾᩮᨲᩴ, ᨿᩩᨲ᩠ᨲᩣ ᨧ ᨿᩮ ᩉᩮᩣᨶ᩠ᨲᩥ ᨶᩁᩣ ᨸᨳᨻ᩠ᨿᩣ.

᪗᪕.

‘‘ᩋᨬ᩠ᨬᩮᩣ ᨶᩩ ᨲᩮ ᨠᩮᩣᨧᩥ [ᨠᩮᩣᨵ (ᨸᩦ.)] ᨶᩁᩮᩣ ᨸᨳᨻ᩠ᨿᩣ, ᩈᨴ᩠ᨵᩮᨿ᩠ᨿ [ᩈᨴ᩠ᨴᩉᩮᨿ᩠ᨿ (ᩈᩦ.)] ᩃᩮᩣᨠᩈ᩠ᨾᩥ ᨶ ᨾᩮ ᨸᩥᨿᩣᨲᩥ;

ᨽᩩᩈᩮᩣ ᨧ ᨲ᩠ᨿᩔ ᨾᨶᩈᩮᩣ ᩅᩥᨥᩣᨲᩮᩣ, ᨴᨲ᩠ᩅᩣ ᨸᩥᨿᩴ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩥᩴ ᩋᨴᨭ᩠ᨮᩣ’’.

᪗᪖.

‘‘ᩋᨴ᩠ᨵᩣ ¶ ᨸᩥᨿᩣ ᨾᨿ᩠ᩉ ᨩᨶᩥᨶ᩠ᨴ ᩑᩈᩣ, ᨶ ᩈᩣ ᨾᨾᩴ ᩋᨸ᩠ᨸᩥᨿᩣ ᨽᩪᨾᩥᨸᩣᩃ;

ᨣᨧ᩠ᨨᩮᩅ ᨲ᩠ᩅᩴ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩥᩴ ᨽᨴᨶ᩠ᨲᩮ, ᩈᩦᩉᩮᩣᩅ ᩈᩮᩃᩔ ᨣᩩᩉᩴ ᩏᨸᩮᨲᩥ’’.

᪗᪗.

‘‘ᨶ ᨸᩦᩊᩥᨲᩣ ᩋᨲ᩠ᨲᨴᩩᨡᩮᨶ ᨵᩦᩁᩣ, ᩈᩩᨡᨸ᩠ᨹᩃᩴ ᨠᨾ᩠ᨾ ᨸᩁᩥᨧ᩠ᨧᨩᨶ᩠ᨲᩥ;

ᩈᨾ᩠ᨾᩮᩣᩉᩥᨲᩣ ᩅᩣᨸᩥ ᩈᩩᨡᩮᨶ ᨾᨲ᩠ᨲᩣ, ᨶ ᨸᩣᨸᨠᨾ᩠ᨾᨬ᩠ᨧ [ᨸᩣᨸᨠᩴ ᨠᨾ᩠ᨾ (ᨸᩦ.)] ᩈᨾᩣᨧᩁᨶ᩠ᨲᩥ’’.

᪗᪘.

‘‘ᨲᩩᩅᨬ᩠ᩉᩥ ᨾᩣᨲᩣ ᨧ ᨸᩥᨲᩣ ᨧ ᨾᨿ᩠ᩉᩴ, ᨽᨲ᩠ᨲᩣ ᨸᨲᩦ ᨸᩮᩣᩈᨠᩮᩣ ᨴᩮᩅᨲᩣ ᨧ;

ᨴᩣᩈᩮᩣ ᩋᩉᩴ ᨲᩩᨿ᩠ᩉ ᩈᨸᩩᨲ᩠ᨲᨴᩣᩁᩮᩣ, ᨿᨳᩣᩈᩩᨡᩴ ᩈᩣᨾᩥ [ᩈᩥᨻ᩠ᨻ (ᩈᩦ.), ᩈᩦᩅᩥ (ᩈ᩠ᨿᩣ.)] ᨠᩁᩮᩣᩉᩥ ᨠᩣᨾᩴ’’.

᪗᪙.

‘‘ᨿᩮᩣ ᩍᩔᩁᩮᩣᨾ᩠ᩉᩦᨲᩥ ᨠᩁᩮᩣᨲᩥ ᨸᩣᨸᩴ, ᨠᨲ᩠ᩅᩣ ¶ ᨧ ᩈᩮᩣ ᨶᩩᨲ᩠ᨲᩈᨲᩮ [ᨶᩩᨲ᩠ᨲᨸᨲᩮ (ᨸᩦ.)] ᨸᩁᩮᩈᩴ;

ᨶ ᨲᩮᨶ ᩈᩮᩣ ᨩᩦᩅᨲᩥ ᨴᩦᨥᨾᩣᨿᩩ [ᨴᩦᨥᨾᩣᨿᩩᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᨴᩮᩅᩣᨸᩥ ᨸᩣᨸᩮᨶ ᩈᨾᩮᨠ᩠ᨡᩁᩮ ᨶᩴ.

᪘᪐.

‘‘ᩋᨬ᩠ᨬᩣᨲᨠᩴ ᩈᩣᨾᩥᨠᩮᩉᩦ ᨸᨴᩥᨶ᩠ᨶᩴ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩣ ᨿᩮ ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨲᩥ ᨴᩣᨶᩴ;

ᨸᨭᩥᨧ᩠ᨨᨠᩣ ᨴᩣᨿᨠᩣ ᨧᩣᨸᩥ ᨲᨲ᩠ᨳ, ᩈᩩᨡᨸ᩠ᨹᩃᨬ᩠ᨬᩮᩅ ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᨠᨾ᩠ᨾᩴ’’.

᪘᪑.

‘‘ᩋᨬ᩠ᨬᩮᩣ ¶ ᨶᩩ ᨲᩮ ᨠᩮᩣᨧᩥ ᨶᩁᩮᩣ ᨸᨳᨻ᩠ᨿᩣ, ᩈᨴ᩠ᨵᩮᨿ᩠ᨿ ᩃᩮᩣᨠᩈ᩠ᨾᩥ ᨶ ᨾᩮ ᨸᩥᨿᩣᨲᩥ;

ᨽᩩᩈᩮᩣ ᨧ ᨲ᩠ᨿᩔ ᨾᨶᩈᩮᩣ ᩅᩥᨥᩣᨲᩮᩣ, ᨴᨲ᩠ᩅᩣ ᨸᩥᨿᩴ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩥᩴ ᩋᨴᨭ᩠ᨮᩣ’’.

᪘᪒.

‘‘ᩋᨴ᩠ᨵᩣ ᨸᩥᨿᩣ ᨾᨿ᩠ᩉ ᨩᨶᩥᨶ᩠ᨴ ᩑᩈᩣ, ᨶ ᩈᩣ ᨾᨾᩴ ᩋᨸ᩠ᨸᩥᨿᩣ ᨽᩪᨾᩥᨸᩣᩃ;

ᨿᩴ ᨲᩮ ᨾᨿᩣ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩦ ᨸᨴᩥᨶ᩠ᨶᩣ, ᨽᩩᩈᩮᩉᩥ ᩁᩣᨩᩣ ᩅᨶᨳᩴ ᩈᨩᩣᩉᩥ’’.

᪘᪓.

‘‘ᨿᩮᩣ ¶ ᩋᨲ᩠ᨲᨴᩩᨠ᩠ᨡᩮᨶ ᨸᩁᩔ ᨴᩩᨠ᩠ᨡᩴ, ᩈᩩᨡᩮᨶ ᩅᩣ ᩋᨲ᩠ᨲᩈᩩᨡᩴ ᨴᩉᩣᨲᩥ;

ᨿᨳᩮᩅᩥᨴᩴ ᨾᨿ᩠ᩉ ᨲᨳᩣ ᨸᩁᩮᩈᩴ, ᨿᩮᩣ [ᩈᩮᩣ (ᨸᩦ.)] ᩑᩅᩴ ᨩᩣᨶᩣᨲᩥ [ᨸᨩᩣᨶᩣᨲᩥ (ᨠ.)] ᩈ ᩅᩮᨴᩥ ᨵᨾ᩠ᨾᩴ.

᪘᪔.

‘‘ᩋᨬ᩠ᨬᩮᩣ ᨶᩩ ᨲᩮ ᨠᩮᩣᨧᩥ ᨶᩁᩮᩣ ᨸᨳᨻ᩠ᨿᩣ, ᩈᨴ᩠ᨵᩮᨿ᩠ᨿ ¶ ᩃᩮᩣᨠᩈ᩠ᨾᩥ ᨶ ᨾᩮ ᨸᩥᨿᩣᨲᩥ;

ᨽᩩᩈᩮᩣ ᨧ ᨲ᩠ᨿᩔ ᨾᨶᩈᩮᩣ ᩅᩥᨥᩣᨲᩮᩣ, ᨴᨲ᩠ᩅᩣ ᨸᩥᨿᩴ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩥᩴ ᩋᨴᨭ᩠ᨮᩣ’’.

᪘᪕.

‘‘ᨩᨶᩥᨶ᩠ᨴ ᨩᩣᨶᩣᩈᩥ ᨸᩥᨿᩣ ᨾᨾᩮᩈᩣ, ᨶ ᩈᩣ ᨾᨾᩴ ᩋᨸ᩠ᨸᩥᨿᩣ ᨽᩪᨾᩥᨸᩣᩃ;

ᨸᩥᨿᩮᨶ ᨲᩮ ᨴᨾ᩠ᨾᩥ ᨸᩥᨿᩴ ᨩᨶᩥᨶ᩠ᨴ, ᨸᩥᨿᨴᩣᨿᩥᨶᩮᩣ ᨴᩮᩅ ᨸᩥᨿᩴ ᩃᨽᨶ᩠ᨲᩥ’’.

᪘᪖.

‘‘ᩈᩮᩣ ᨶᩪᨶᩣᩉᩴ ᩅᨵᩥᩔᩣᨾᩥ, ᩋᨲ᩠ᨲᩣᨶᩴ ᨠᩣᨾᩉᩮᨲᩩᨠᩴ;

ᨶ ᩉᩥ ᨵᨾ᩠ᨾᩴ ᩋᨵᨾ᩠ᨾᩮᨶ, ᩋᩉᩴ ᩅᨵᩥᨲᩩᨾᩩᩔᩉᩮ’’.

᪘᪗.

‘‘ᩈᨧᩮ ᨲᩩᩅᩴ ᨾᨿ᩠ᩉ ᩈᨲᩥᩴ [ᩈᨶ᩠ᨲᩥ (ᨠ.)] ᨩᨶᩥᨶ᩠ᨴ, ᨶ ᨠᩣᨾᨿᩣᩈᩥ ᨶᩁᩅᩦᩁ ᩈᩮᨭ᩠ᨮ;

ᨧᨩᩣᨾᩥ ᨶᩴ ᩈᨻ᩠ᨻᨩᨶᩔ ᩈᩥᨻ᩠ᨿᩣ [ᩈᩥᨻ᩠ᨻ (ᩈᩦ. ᨸᩦ.), ᨾᨩ᩠ᨫᩮ (ᩈ᩠ᨿᩣ.)], ᨾᨿᩣ ᨸᨾᩩᨲ᩠ᨲᩴ ᨲᨲᩮᩣ ᩋᩅ᩠ᩉᨿᩮᩈᩥ [ᩋᩅ᩠ᩉᨿᩣᩈᩥ (ᨠ.)] ᨶᩴ’’.

᪘᪘.

‘‘ᩋᨴᩪᩈᩥᨿᩴ ᨧᩮ ᩋᨽᩥᨸᩣᩁᨠ ᨲ᩠ᩅᩴ, ᨧᨩᩣᩈᩥ ᨠᨲ᩠ᨲᩮ ᩋᩉᩥᨲᩣᨿ ᨲ᩠ᨿᩔ;

ᨾᩉᩣ ᨧ ᨲᩮ ᩏᨸᩅᩣᨴᩮᩣᨸᩥ ᩋᩔ, ᨶ ᨧᩣᨸᩥ ᨲ᩠ᨿᩔ ᨶᨣᩁᨾ᩠ᩉᩥ ᨸᨠ᩠ᨡᩮᩣ’’.

᪘᪙.

‘‘ᩋᩉᩴ ᩈᩉᩥᩔᩴ ᩏᨸᩅᩣᨴᨾᩮᨲᩴ, ᨶᩥᨶ᩠ᨴᩴ ᨸᩈᩴᩈᩴ ᨣᩁᩉᨬ᩠ᨧ ᩈᨻ᩠ᨻᩴ;

ᨾᨾᩮᨲᨾᩣᨣᨧ᩠ᨨᨲᩩ ᨽᩪᨾᩥᨸᩣᩃ, ᨿᨳᩣᩈᩩᨡᩴ ¶ ᩈᩥᩅᩥ [ᩈᩥᨻ᩠ᨻ (ᩈᩦ. ᨸᩦ.)] ᨠᩁᩮᩣᩉᩥ ᨠᩣᨾᩴ’’.

᪙᪐.

‘‘ᨿᩮᩣ ¶ ᨶᩮᩅ ᨶᩥᨶ᩠ᨴᩴ ᨶ ᨸᨶᨸ᩠ᨸᩈᩴᩈᩴ, ᩌᨴᩥᨿᨲᩥ ᨣᩁᩉᩴ ᨶᩮᩣᨸᩥ ᨸᩪᨩᩴ;

ᩈᩥᩁᩦ ᨧ ᩃᨠ᩠ᨡᩦ ᨧ ᩋᨸᩮᨲᩥ ᨲᨾ᩠ᩉᩣ, ᩌᨸᩮᩣ ᩈᩩᩅᩩᨭ᩠ᨮᩦᩅ ᨿᨳᩣ ᨳᩃᨾ᩠ᩉᩣ’’.

᪙᪑.

‘‘ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᨬ᩠ᨧ ᩈᩩᨡᨬ᩠ᨧ ᩑᨲ᩠ᨲᩮᩣ, ᨵᨾ᩠ᨾᩣᨲᩥᩈᩣᩁᨬ᩠ᨧ ᨾᨶᩮᩣᩅᩥᨥᩣᨲᩴ;

ᩏᩁᩈᩣ ᩋᩉᩴ ᨸᨧ᩠ᨧᩩᨲ᩠ᨲᩁᩥᩔᩣᨾᩥ [ᨸᨭᩥᨧ᩠ᨨᩥᩔᩣᨾᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨸᨧ᩠ᨧᩩᨸᨴᩥᩔᩣᨾᩥ (ᨸᩦ.)] ᩈᨻ᩠ᨻᩴ, ᨸᨳᩅᩦ ᨿᨳᩣ ᨳᩣᩅᩁᩣᨶᩴ ᨲᩈᩣᨶᩴ’’.

᪙᪒.

‘‘ᨵᨾ᩠ᨾᩣᨲᩥᩈᩣᩁᨬ᩠ᨧ ᨾᨶᩮᩣᩅᩥᨥᩣᨲᩴ, ᨴᩩᨠ᩠ᨡᨬ᩠ᨧ ᨶᩥᨧ᩠ᨨᩣᨾᩥ ᩋᩉᩴ ᨸᩁᩮᩈᩴ;

ᩑᨠᩮᩣᩅᩥᨾᩴ ᩉᩣᩁᨿᩥᩔᩣᨾᩥ ᨽᩣᩁᩴ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩮᩣ ᨠᩥᨬ᩠ᨧᩥ ᩋᩉᩣᨸᨿᨶ᩠ᨲᩮᩣ’’.

᪙᪓.

‘‘ᩈᨣ᩠ᨣᩪᨸᨣᩴ ᨸᩩᨬ᩠ᨬᨠᨾ᩠ᨾᩴ ᨩᨶᩥᨶ᩠ᨴ, ᨾᩣ ᨾᩮ ᨲᩩᩅᩴ ᩋᨶ᩠ᨲᩁᩣᨿᩴ ᩋᨠᩣᩈᩥ;

ᨴᨴᩣᨾᩥ ᨲᩮ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩥᩴ ᨸᩈᨶ᩠ᨶᩮᩣ, ᩁᩣᨩᩣᩅ ᨿᨬ᩠ᨬᩮ ᨵᨶᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ’’.

᪙᪔.

‘‘ᩋᨴ᩠ᨵᩣ ᨲᩩᩅᩴ ᨠᨲ᩠ᨲᩮ ᩉᩥᨲᩮᩈᩥ ᨾᨿ᩠ᩉᩴ, ᩈᨡᩣ ᨾᨾᩴ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩦ ᨲᩩᩅᨬ᩠ᨧ;

ᨶᩥᨶ᩠ᨴᩮᨿ᩠ᨿᩩ ᨴᩮᩅᩣ ᨸᩥᨲᩁᩮᩣ ᨧ ᩈᨻ᩠ᨻᩮ, ᨸᩣᨸᨬ᩠ᨧ ¶ ᨸᩔᩴ ᩋᨽᩥᩈᨾ᩠ᨸᩁᩣᨿᩴ’’.

᪙᪕.

‘‘ᨶ ᩉᩮᨲᨵᨾ᩠ᨾᩴ ᩈᩥᩅᩥᩁᩣᨩ ᩅᨩ᩠ᨩᩩᩴ, ᩈᨶᩮᨣᨾᩣ ᨩᩣᨶᨸᨴᩣ ᨧ ᩈᨻ᩠ᨻᩮ;

ᨿᩴ ᨲᩮ ᨾᨿᩣ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩦ ᨸᨴᩥᨶ᩠ᨶᩣ, ᨽᩩᩈᩮᩉᩥ ᩁᩣᨩᩣ ᩅᨶᨳᩴ ᩈᨩᩣᩉᩥ’’.

᪙᪖.

‘‘ᩋᨴ᩠ᨵᩣ ¶ ᨲᩩᩅᩴ ᨠᨲ᩠ᨲᩮ ᩉᩥᨲᩮᩈᩥ ᨾᨿ᩠ᩉᩴ, ᩈᨡᩣ ᨾᨾᩴ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩦ ᨲᩩᩅᨬ᩠ᨧ;

ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩣᨶᩥ ᩈᩩᨠᩥᨲ᩠ᨲᩥᨲᩣᨶᩥ, ᩈᨾᩩᨴ᩠ᨴᩅᩮᩃᩣᩅ ᨴᩩᩁᨧ᩠ᨧᨿᩣᨶᩥ’’.

᪙᪗.

‘‘ᩌᩉᩩᨶᩮᨿ᩠ᨿᩮᩣ ¶ ᨾᩮᩈᩥ ᩉᩥᨲᩣᨶᩩᨠᨾ᩠ᨸᩦ, ᨵᩣᨲᩣ ᩅᩥᨵᩣᨲᩣ ᨧᩈᩥ ᨠᩣᨾᨸᩣᩃᩮᩣ;

ᨲᨿᩦ ᩉᩩᨲᩣ ᩁᩣᨩ ᨾᩉᨸ᩠ᨹᩃᩣ ᩉᩥ [ᨾᩉᨸ᩠ᨹᩃᩣ ᩉᩥ ᨾᩮ (ᨸᩦ.)], ᨠᩣᨾᩮᨶ ᨾᩮ ᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩥᩴ ᨸᨭᩥᨧ᩠ᨨ’’.

᪙᪘.

‘‘ᩋᨴ᩠ᨵᩣ ᩉᩥ ᩈᨻ᩠ᨻᩴ ᩋᨽᩥᨸᩣᩁᨠ ᨲ᩠ᩅᩴ, ᨵᨾ᩠ᨾᩴ ᩋᨧᩣᩁᩦ ᨾᨾ ᨠᨲ᩠ᨲᩩᨸᩩᨲ᩠ᨲ;

ᩋᨬ᩠ᨬᩮᩣ ᨶᩩ ᨲᩮ ᨠᩮᩣ ᩍᨵ ᩈᩮᩣᨲ᩠ᨳᩥᨠᨲ᩠ᨲᩣ, ᨴ᩠ᩅᩥᨸᨴᩮᩣ ᨶᩁᩮᩣ ᩋᩁᩩᨱᩮ ᨩᩦᩅᩃᩮᩣᨠᩮ’’.

᪙᪙.

‘‘ᨲᩩᩅᩴ ᨶᩩ ᩈᩮᨭ᩠ᨮᩮᩣ ᨲ᩠ᩅᨾᨶᩩᨲ᩠ᨲᩁᩮᩣᩈᩥ, ᨲ᩠ᩅᩴ ᨵᨾ᩠ᨾᨣᩪ [ᨵᨾ᩠ᨾᨣᩩᨲ᩠ᨲᩮᩣ (ᩈᩦ.)] ᨵᨾ᩠ᨾᩅᩥᨴᩪ ᩈᩩᨾᩮᨵᩮᩣ;

ᩈᩮᩣ ᨵᨾ᩠ᨾᨣᩩᨲ᩠ᨲᩮᩣ ᨧᩥᩁᨾᩮᩅ ᨩᩦᩅ, ᨵᨾ᩠ᨾᨬ᩠ᨧ ¶ ᨾᩮ ᨴᩮᩈᨿ ᨵᨾ᩠ᨾᨸᩣᩃ’’.

᪑᪐᪐.

‘‘ᨲᨴᩥᨦ᩠ᨥ ᩋᨽᩥᨸᩣᩁᨠ, ᩈᩩᨱᩮᩣᩉᩥ ᩅᨧᨶᩴ ᨾᨾ;

ᨵᨾ᩠ᨾᩴ ᨲᩮ ᨴᩮᩈᨿᩥᩔᩣᨾᩥ, ᩈᨲᩴ ᩌᩈᩮᩅᩥᨲᩴ ᩋᩉᩴ.

᪑᪐᪑.

‘‘ᩈᩣᨵᩩ ᨵᨾ᩠ᨾᩁᩩᨧᩥ ᩁᩣᨩᩣ, ᩈᩣᨵᩩ ᨸᨬ᩠ᨬᩣᨱᩅᩣ ᨶᩁᩮᩣ;

ᩈᩣᨵᩩ ᨾᩥᨲ᩠ᨲᩣᨶᨾᨴ᩠ᨴᩩᨻ᩠ᨽᩮᩣ, ᨸᩣᨸᩔᩣᨠᩁᨱᩴ ᩈᩩᨡᩴ.

᪑᪐᪒.

‘‘ᩋᨠ᩠ᨠᩮᩣᨵᨶᩔ ᩅᩥᨩᩥᨲᩮ, ᨮᩥᨲᨵᨾ᩠ᨾᩔ ᩁᩣᨩᩥᨶᩮᩣ;

ᩈᩩᨡᩴ ᨾᨶᩩᩔᩣ ᩌᩈᩮᨳ, ᩈᩦᨲᨧ᩠ᨨᩣᨿᩣᨿ ᩈᨦ᩠ᨥᩁᩮ.

᪑᪐᪓.

‘‘ᨶ ᨧᩣᩉᨾᩮᨲᩴ ᩋᨽᩥᩁᩮᩣᨧᨿᩣᨾᩥ, ᨠᨾ᩠ᨾᩴ ᩋᩈᨾᩮᨠ᩠ᨡᨠᨲᩴ ᩋᩈᩣᨵᩩ;

ᨿᩮ ᩅᩣᨸᩥ ᨬᨲ᩠ᩅᩣᨶ ᩈᨿᩴ ᨠᩁᩮᩣᨶ᩠ᨲᩥ, ᩏᨸᨾᩣ ᩍᨾᩣ ᨾᨿ᩠ᩉᩴ ᨲᩩᩅᩴ ᩈᩩᨱᩮᩣᩉᩥ.

᪑᪐᪔.

‘‘ᨣᩅᩴ ᨧᩮ ᨲᩁᨾᩣᨶᩣᨶᩴ, ᨩᩥᨾ᩠ᩉᩴ ᨣᨧ᩠ᨨᨲᩥ ᨸᩩᨦ᩠ᨣᩅᩮᩣ;

ᩈᨻ᩠ᨻᩣ ᨲᩣ ᨩᩥᨾ᩠ᩉᩴ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨶᩮᨲ᩠ᨲᩮ ᨩᩥᨾ᩠ᩉᩴ ᨣᨲᩮ ᩈᨲᩥ.

᪑᪐᪕.

‘‘ᩑᩅᨾᩮᩅ [ᩑᩅᨾᩮᩅᩴ (ᨸᩦ.)] ᨾᨶᩩᩔᩮᩈᩩ, ᨿᩮᩣ ᩉᩮᩣᨲᩥ ᩈᩮᨭ᩠ᨮᩈᨾ᩠ᨾᨲᩮᩣ;

ᩈᩮᩣ ᨧᩮ ᩋᨵᨾ᩠ᨾᩴ ᨧᩁᨲᩥ, ᨸᨣᩮᩅ ᩍᨲᩁᩣ ᨸᨩᩣ;

ᩈᨻ᩠ᨻᩴ ¶ ᩁᨭ᩠ᨮᩴ ᨴᩩᨡᩴ ᩈᩮᨲᩥ, ᩁᩣᨩᩣ ᨧᩮ ᩉᩮᩣᨲᩥ ᩋᨵᨾ᩠ᨾᩥᨠᩮᩣ.

᪑᪐᪖.

‘‘ᨣᩅᩴ ¶ ᨧᩮ ᨲᩁᨾᩣᨶᩣᨶᩴ, ᩏᨩᩩᩴ ᨣᨧ᩠ᨨᨲᩥ ᨸᩩᨦ᩠ᨣᩅᩮᩣ;

ᩈᨻ᩠ᨻᩣ ᨣᩣᩅᩦ ᩏᨩᩩᩴ ᨿᨶ᩠ᨲᩥ, ᨶᩮᨲ᩠ᨲᩮ ᩏᨩᩩᩴ ᨣᨲᩮ ᩈᨲᩥ.

᪑᪐᪗.

‘‘ᩑᩅᨾᩮᩅ ᨾᨶᩩᩔᩮᩈᩩ, ᨿᩮᩣ ᩉᩮᩣᨲᩥ ᩈᩮᨭ᩠ᨮᩈᨾ᩠ᨾᨲᩮᩣ;

ᩈᩮᩣ ᩈᨧᩮ ᨵᨾ᩠ᨾᩴ ᨧᩁᨲᩥ, ᨸᨣᩮᩅ ᩍᨲᩁᩣ ᨸᨩᩣ;

ᩈᨻ᩠ᨻᩴ ᩁᨭ᩠ᨮᩴ ᩈᩩᨡᩴ ᩈᩮᨲᩥ, ᩁᩣᨩᩣ ᨧᩮ ᩉᩮᩣᨲᩥ ᨵᨾ᩠ᨾᩥᨠᩮᩣ.

᪑᪐᪘.

‘‘ᨶ ᨧᩣᨸᩣᩉᩴ ᩋᨵᨾ᩠ᨾᩮᨶ, ᩋᨾᩁᨲ᩠ᨲᨾᨽᩥᨸᨲ᩠ᨳᨿᩮ;

ᩍᨾᩴ ᩅᩣ ᨸᨳᩅᩥᩴ ᩈᨻ᩠ᨻᩴ, ᩅᩥᨩᩮᨲᩩᩴ ᩋᨽᩥᨸᩣᩁᨠ.

᪑᪐᪙.

‘‘ᨿᨬ᩠ᩉᩥ ᨠᩥᨬ᩠ᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᩁᨲᨶᩴ ᩍᨵ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᨣᩣᩅᩮᩣ ᨴᩣᩈᩮᩣ ᩉᩥᩁᨬ᩠ᨬᨬ᩠ᨧ, ᩅᨲ᩠ᨳᩥᨿᩴ ᩉᩁᩥᨧᨶ᩠ᨴᨶᩴ.

᪑᪑᪐.

‘‘ᩋᩔᩥᨲ᩠ᨳᩥᨿᩮᩣ ¶ [ᩋᩔᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨧ (ᩈᩦ.)] ᩁᨲᨶᩴ ᨾᨱᩥᨠᨬ᩠ᨧ, ᨿᨬ᩠ᨧᩣᨸᩥ ᨾᩮ ᨧᨶ᩠ᨴᩈᩪᩁᩥᨿᩣ ᩋᨽᩥᨸᩣᩃᨿᨶ᩠ᨲᩥ;

ᨶ ᨲᩔ ᩉᩮᨲᩩ ᩅᩥᩈᨾᩴ ᨧᩁᩮᨿ᩠ᨿᩴ, ᨾᨩ᩠ᨫᩮ ᩈᩥᩅᩦᨶᩴ ᩏᩈᨽᩮᩣᨾ᩠ᩉᩥ ᨩᩣᨲᩮᩣ.

᪑᪑᪑.

‘‘ᨶᩮᨲᩣ ᩉᩥᨲᩣ [ᨶᩮᨲᩣᨽᩥ ᨲᩣ (ᩈᩦ.)] ᩏᨣ᩠ᨣᨲᩮᩣ ᩁᨭ᩠ᨮᨸᩣᩃᩮᩣ, ᨵᨾ᩠ᨾᩴ ᩈᩥᩅᩦᨶᩴ ᩋᨸᨧᩣᨿᨾᩣᨶᩮᩣ;

ᩈᩮᩣ ᨵᨾ᩠ᨾᨾᩮᩅᩣᨶᩩᩅᩥᨧᩥᨶ᩠ᨲᨿᨶ᩠ᨲᩮᩣ, ᨲᩈ᩠ᨾᩣ ᩈᨠᩮ ᨧᩥᨲ᩠ᨲᩅᩈᩮ ᨶ ᩅᨲ᩠ᨲᩮᩣ’’.

᪑᪑᪒.

‘‘ᩋᨴ᩠ᨵᩣ ᨲᩩᩅᩴ ᨾᩉᩣᩁᩣᨩ, ᨶᩥᨧ᩠ᨧᩴ ᩋᨻ᩠ᨿᩈᨶᩴ ᩈᩥᩅᩴ;

ᨠᩁᩥᩔᩈᩥ ᨧᩥᩁᩴ ᩁᨩ᩠ᨩᩴ, ᨸᨬ᩠ᨬᩣ ᩉᩥ ᨲᩅ ᨲᩣᨴᩥᩈᩦ.

᪑᪑᪓.

‘‘ᩑᨲᩴ ᨲᩮ ᩋᨶᩩᨾᩮᩣᨴᩣᨾ, ᨿᩴ ᨵᨾ᩠ᨾᩴ ᨶᨸ᩠ᨸᨾᨩ᩠ᨩᩈᩥ;

ᨵᨾ᩠ᨾᩴ ᨸᨾᨩ᩠ᨩ ᨡᨲ᩠ᨲᩥᨿᩮᩣ, ᩁᨭ᩠ᨮᩣ [ᨮᩣᨶᩣ (ᩈᩦ.)] ᨧᩅᨲᩥ ᩍᩔᩁᩮᩣ.

᪑᪑᪔.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨾᩣᨲᩣᨸᩥᨲᩪᩈᩩ ᨡᨲ᩠ᨲᩥᨿ;

ᩍᨵ ¶ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩁᩣᨩ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ.

᪑᪑᪕.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨸᩩᨲ᩠ᨲᨴᩣᩁᩮᩈᩩ ᨡᨲ᩠ᨲᩥᨿ…ᨸᩮ….

᪑᪑᪖.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨾᩥᨲ᩠ᨲᩣᨾᨧ᩠ᨧᩮᩈᩩ ᨡᨲ᩠ᨲᩥᨿ…ᨸᩮ….

᪑᪑᪗.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᩅᩣᩉᨶᩮᩈᩩ ᨻᩃᩮᩈᩩ ᨧ…ᨸᩮ….

᪑᪑᪘.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨣᩣᨾᩮᩈᩩ ᨶᩥᨣᨾᩮᩈᩩ ᨧ…ᨸᩮ….

᪑᪑᪙.

‘‘ᨵᨾ᩠ᨾᩴ ¶ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᩁᨭ᩠ᨮᩮᩈᩩ ᨩᨶᨸᨴᩮᩈᩩ ᨧ…ᨸᩮ….

᪑᪒᪐.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ᨧ…ᨸᩮ….

᪑᪒᪑.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨾᩥᨣᨸᨠ᩠ᨡᩦᩈᩩ ᨡᨲ᩠ᨲᩥᨿ…ᨸᩮ….

᪑᪒᪒.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᨵᨾ᩠ᨾᩮᩣ ᨧᩥᨱ᩠ᨱᩮᩣ ᩈᩩᨡᩣᩅᩉᩮᩣ;

ᩍᨵ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩁᩣᨩ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ.

᪑᪒᪓.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁ ᨾᩉᩣᩁᩣᨩ, ᩈᩍᨶ᩠ᨴᩣ ᨴᩮᩅᩣ ᩈᨻᩕᩉ᩠ᨾᨠᩣ;

ᩈᩩᨧᩥᨱ᩠ᨱᩮᨶ ᨴᩥᩅᩴ ᨸᨲ᩠ᨲᩣ, ᨾᩣ ᨵᨾ᩠ᨾᩴ ᩁᩣᨩ ᨸᩣᨾᨴᩮᩣ’’ᨲᩥ.

ᩏᨾ᩠ᨾᩣᨴᨶ᩠ᨲᩦᨩᩣᨲᨠᩴ ᨴᩩᨲᩥᨿᩴ.

᪕᪒᪘. ᨾᩉᩣᨻᩮᩣᨵᩥᨩᩣᨲᨠᩴ (᪓)

᪑᪒᪔.

‘‘ᨠᩥᩴ ¶ ᨶᩩ ᨴᨱ᩠ᨯᩴ ᨠᩥᨾᨩᩥᨶᩴ, ᨠᩥᩴ ᨨᨲ᩠ᨲᩴ ᨠᩥᨾᩩᨸᩣᩉᨶᩴ;

ᨠᩥᨾᨦ᩠ᨠᩩᩈᨬ᩠ᨧ ᨸᨲ᩠ᨲᨬ᩠ᨧ, ᩈᨦ᩠ᨥᩣᨭᩥᨬ᩠ᨧᩣᨸᩥ ᨻᩕᩣᩉ᩠ᨾᨱ;

ᨲᩁᨾᩣᨶᩁᩪᨸᩮᩣᩉᩣᩈᩥ [ᨣᨱ᩠ᩉᩣᩈᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨠᩥᩴ ᨶᩩ ᨸᨲ᩠ᨳᨿᩈᩮ ᨴᩥᩈᩴ’’.

᪑᪒᪕.

‘‘ᨴ᩠ᩅᩣᨴᩈᩮᨲᩣᨶᩥ ¶ ᩅᩔᩣᨶᩥ, ᩅᩩᩈᩥᨲᩣᨶᩥ ᨲᩅᨶ᩠ᨲᩥᨠᩮ;

ᨶᩣᨽᩥᨩᩣᨶᩣᨾᩥ ᩈᩮᩣᨱᩮᨶ, ᨸᩥᨦ᩠ᨣᩃᩮᨶᩣᨽᩥᨠᩪᨩᩥᨲᩴ.

᪑᪒᪖.

‘‘ᩈ᩠ᩅᩣᨿᩴ ᨴᩥᨲ᩠ᨲᩮᩣᩅ ᨶᨴᨲᩥ, ᩈᩩᨠ᩠ᨠᨴᩣᨮᩴ ᩅᩥᨴᩴᩈᨿᩴ;

ᨲᩅ ᩈᩩᨲ᩠ᩅᩣ ᩈᨽᩁᩥᨿᩔ, ᩅᩦᨲᩈᨴ᩠ᨵᩔ ᨾᩴ ᨸᨲᩥ’’.

᪑᪒᪗.

‘‘ᩋᩉᩩ ᩑᩈ ᨠᨲᩮᩣ ᨴᩮᩣᩈᩮᩣ, ᨿᨳᩣ ᨽᩣᩈᩈᩥ ᨻᩕᩣᩉ᩠ᨾᨱ;

ᩑᩈ ᨽᩥᨿ᩠ᨿᩮᩣ ᨸᩈᩦᨴᩣᨾᩥ, ᩅᩈ ᨻᩕᩣᩉ᩠ᨾᨱ ᨾᩣᨣᨾᩣ’’.

᪑᪒᪘.

‘‘ᩈᨻ᩠ᨻᩈᩮᨲᩮᩣ ᨸᩩᩁᩮ ᩌᩈᩥ, ᨲᨲᩮᩣᨸᩥ ᩈᨻᩃᩮᩣ ᩋᩉᩩ;

ᩈᨻ᩠ᨻᩃᩮᩣᩉᩥᨲᨠᩮᩣ ᨴᩣᨶᩥ, ᨠᩣᩃᩮᩣ ᨸᨠ᩠ᨠᨾᩥᨲᩩᩴ ᨾᨾ.

᪑᪒᪙.

‘‘ᩋᨻ᩠ᨽᨶ᩠ᨲᩁᩴ ᨸᩩᩁᩮ ᩌᩈᩥ, ᨲᨲᩮᩣ ᨾᨩ᩠ᨫᩮ ᨲᨲᩮᩣ ᨻᩉᩥ;

ᨸᩩᩁᩣ ᨶᩥᨴ᩠ᨵᨾᨶᩣ ᩉᩮᩣᨲᩥ, ᩈᨿᨾᩮᩅ ᩅᨩᩣᨾᩉᩴ.

᪑᪓᪐.

‘‘ᩅᩦᨲᩈᨴ᩠ᨵᩴ ᨶ ᩈᩮᩅᩮᨿ᩠ᨿ, ᩏᨴᨸᩣᨶᩴᩅᨶᩮᩣᨴᨠᩴ;

ᩈᨧᩮᨸᩥ ᨶᩴ ᩋᨶᩩᨡᨱᩮ, ᩅᩣᩁᩥ ᨠᨴ᩠ᨴᨾᨣᨶ᩠ᨵᩥᨠᩴ.

᪑᪓᪑.

‘‘ᨸᩈᨶ᩠ᨶᨾᩮᩅ ᩈᩮᩅᩮᨿ᩠ᨿ, ᩋᨸ᩠ᨸᩈᨶ᩠ᨶᩴ ᩅᩥᩅᨩ᩠ᨩᨿᩮ;

ᨸᩈᨶ᩠ᨶᩴ ᨸᨿᩥᩁᩩᨸᩣᩈᩮᨿ᩠ᨿ, ᩁᩉᨴᩴ ᩅᩩᨴᨠᨲ᩠ᨳᩥᨠᩮᩣ.

᪑᪓᪒.

‘‘ᨽᨩᩮ ¶ ᨽᨩᨶ᩠ᨲᩴ ᨸᩩᩁᩥᩈᩴ, ᩋᨽᨩᨶ᩠ᨲᩴ ᨶ ᨽᨩ᩠ᨩᨿᩮ [ᨽᩣᨩᨿᩮ (ᨸᩦ.)];

ᩋᩈᨸ᩠ᨸᩩᩁᩥᩈᨵᨾ᩠ᨾᩮᩣ ᩈᩮᩣ, ᨿᩮᩣ ᨽᨩᨶ᩠ᨲᩴ ᨶ ᨽᨩ᩠ᨩᨲᩥ [ᨽᩣᨩᨲᩥ (ᨸᩦ.)].

᪑᪓᪓.

‘‘ᨿᩮᩣ ¶ ᨽᨩᨶ᩠ᨲᩴ ᨶ ᨽᨩᨲᩥ, ᩈᩮᩅᨾᩣᨶᩴ ᨶ ᩈᩮᩅᨲᩥ;

ᩈ ᩅᩮ ᨾᨶᩩᩔᨸᩣᨸᩥᨭ᩠ᨮᩮᩣ, ᨾᩥᨣᩮᩣ ᩈᩣᨡᩔᩥᨲᩮᩣ ᨿᨳᩣ.

᪑᪓᪔.

‘‘ᩋᨧ᩠ᨧᩣᨽᩥᨠ᩠ᨡᨱᩈᩴᩈᨣ᩠ᨣᩣ, ᩋᩈᨾᩮᩣᩈᩁᨱᩮᨶ ᨧ;

ᩑᨲᩮᨶ ᨾᩥᨲ᩠ᨲᩣ ᨩᩦᩁᨶ᩠ᨲᩥ, ᩋᨠᩣᩃᩮ ᨿᩣᨧᨶᩣᨿ ᨧ.

᪑᪓᪕.

‘‘ᨲᩈ᩠ᨾᩣ ᨶᩣᨽᩥᨠ᩠ᨡᨱᩴ ᨣᨧ᩠ᨨᩮ, ᨶ ᨧ ᨣᨧ᩠ᨨᩮ ᨧᩥᩁᩣᨧᩥᩁᩴ;

ᨠᩣᩃᩮᨶ ᨿᩣᨧᩴ ᨿᩣᨧᩮᨿ᩠ᨿ, ᩑᩅᩴ ᨾᩥᨲ᩠ᨲᩣ ᨶ ᨩᩦᨿᩁᩮ [ᨩᩦᩁᩁᩮ (ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪑᪓᪖.

‘‘ᩋᨲᩥᨧᩥᩁᩴ ᨶᩥᩅᩣᩈᩮᨶ, ᨸᩥᨿᩮᩣ ᨽᩅᨲᩥ ᩋᨸ᩠ᨸᩥᨿᩮᩣ;

ᩌᨾᨶ᩠ᨲ ᨡᩮᩣ ᨲᩴ ᨣᨧ᩠ᨨᩣᨾ, ᨸᩩᩁᩣ ᨲᩮ ᩉᩮᩣᨾ ᩋᨸ᩠ᨸᩥᨿᩣ’’.

᪑᪓᪗.

‘‘ᩑᩅᩴ ᨧᩮ ᨿᩣᨧᨾᩣᨶᩣᨶᩴ, ᩋᨬ᩠ᨩᩃᩥᩴ ᨶᩣᩅᨻᩩᨩ᩠ᨫᩈᩥ;

ᨸᩁᩥᨧᩣᩁᨠᩣᨶᩴ ᩈᨲᩴ [ᨸᩁᩥᨧᩣᩁᩥᨠᩣᨶᩴ ᩈᨲ᩠ᨲᩣᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩅᨧᨶᩴ ᨶ ᨠᩁᩮᩣᩈᩥ ᨶᩮᩣ;

ᩑᩅᩴ ᨲᩴ ᩋᨽᩥᨿᩣᨧᩣᨾ, ᨸᩩᨶ ᨠᨿᩥᩁᩣᩈᩥ ᨸᩁᩥᨿᩣᨿᩴ’’.

᪑᪓᪘.

‘‘ᩑᩅᩴ ᨧᩮ ᨶᩮᩣ ᩅᩥᩉᩁᨲᩴ, ᩋᨶ᩠ᨲᩁᩣᨿᩮᩣ ᨶ ᩉᩮᩔᨲᩥ;

ᨲᩩᨿ᩠ᩉᩴ ᩅᩣᨸᩥ [ᨲᩩᨾ᩠ᩉᨬ᩠ᨧᩣᨸᩥ (ᩈᩦ.), ᨲᩩᨿ᩠ᩉᨬ᩠ᨧᩣᨸᩥ (ᨸᩦ.)] ᨾᩉᩣᩁᩣᨩ, ᨾᨿ᩠ᩉᩴ ᩅᩣ [ᩋᨾ᩠ᩉᩴ ᩅᩣ (ᩈᩦ.), ᨾᨿ᩠ᩉᨬ᩠ᨧ (ᨸᩦ.)] ᩁᨭ᩠ᨮᩅᨴ᩠ᨵᨶ;

ᩋᨸ᩠ᨸᩮᩅ ᨶᩣᨾ ᨸᩔᩮᨾ, ᩋᩉᩮᩣᩁᨲ᩠ᨲᩣᨶᨾᨧ᩠ᨧᨿᩮ’’.

᪑᪓᪙.

‘‘ᩏᨴᩦᩁᨱᩣ ¶ ᨧᩮ ᩈᩴᨣᨲ᩠ᨿᩣ, ᨽᩣᩅᩣᨿ ᨾᨶᩩᩅᨲ᩠ᨲᨲᩥ;

ᩋᨠᩣᨾᩣ ᩋᨠᩁᨱᩦᨿᩴ ᩅᩣ, ᨠᩁᨱᩦᨿᩴ ᩅᩣᨸᩥ ᨠᩩᨻ᩠ᨻᨲᩥ;

ᩌᨠᩣᨾᩣᨠᩁᨱᩦᨿᨾ᩠ᩉᩥ, ᨠ᩠ᩅᩥᨵ ᨸᩣᨸᩮᨶ ᩃᩥᨸ᩠ᨸᨲᩥ [ᩃᩥᨾ᩠ᨸᨲᩥ (ᩈ᩠ᨿᩣ. ᨠ.)].

᪑᪔᪐.

‘‘ᩈᩮᩣ ᨧᩮ ᩋᨲ᩠ᨳᩮᩣ ᨧ ᨵᨾ᩠ᨾᩮᩣ ᨧ, ᨠᩃ᩠ᨿᩣᨱᩮᩣ ᨶ ᨧ ᨸᩣᨸᨠᩮᩣ;

ᨽᩮᩣᨲᩮᩣ ᨧᩮ ᩅᨧᨶᩴ ᩈᨧ᩠ᨧᩴ, ᩈᩩᩉᨲᩮᩣ ᩅᩣᨶᩁᩮᩣ ᨾᨿᩣ.

᪑᪔᪑.

‘‘ᩋᨲ᩠ᨲᨶᩮᩣ ᨧᩮ ᩉᩥ ᩅᩣᨴᩔ, ᩋᨸᩁᩣᨵᩴ ᩅᩥᨩᩣᨶᩥᨿᩣ [ᩅᩥᨩᩣᨶᩥᨿ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᨶ ¶ ᨾᩴ ᨲ᩠ᩅᩴ ᨣᩁᩉᩮᨿ᩠ᨿᩣᩈᩥ, ᨽᩮᩣᨲᩮᩣ ᩅᩣᨴᩮᩣ ᩉᩥ ᨲᩣᨴᩥᩈᩮᩣ’’.

᪑᪔᪒.

‘‘ᩍᩔᩁᩮᩣ ¶ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩔ, ᩈᨧᩮ ᨠᨸ᩠ᨸᩮᨲᩥ ᨩᩦᩅᩥᨲᩴ;

ᩍᨴ᩠ᨵᩥᩴ [ᩍᨴ᩠ᨵᩥ (ᨸᩦ. ᨠ.)] ᨻ᩠ᨿᩈᨶᨽᩣᩅᨬ᩠ᨧ, ᨠᨾ᩠ᨾᩴ ᨠᩃ᩠ᨿᩣᨱᨸᩣᨸᨠᩴ;

ᨶᩥᨴ᩠ᨴᩮᩈᨠᩣᩁᩦ ᨸᩩᩁᩥᩈᩮᩣ, ᩍᩔᩁᩮᩣ ᨲᩮᨶ ᩃᩥᨸ᩠ᨸᨲᩥ.

᪑᪔᪓.

‘‘ᩈᩮᩣ ᨧᩮ ᩋᨲ᩠ᨳᩮᩣ ᨧ ᨵᨾ᩠ᨾᩮᩣ ᨧ, ᨠᩃ᩠ᨿᩣᨱᩮᩣ ᨶ ᨧ ᨸᩣᨸᨠᩮᩣ;

ᨽᩮᩣᨲᩮᩣ ᨧᩮ ᩅᨧᨶᩴ ᩈᨧ᩠ᨧᩴ, ᩈᩩᩉᨲᩮᩣ ᩅᩣᨶᩁᩮᩣ ᨾᨿᩣ.

᪑᪔᪔.

‘‘ᩋᨲ᩠ᨲᨶᩮᩣ ᨧᩮ ᩉᩥ ᩅᩣᨴᩔ, ᩋᨸᩁᩣᨵᩴ ᩅᩥᨩᩣᨶᩥᨿᩣ;

ᨶ ᨾᩴ ᨲ᩠ᩅᩴ ᨣᩁᩉᩮᨿ᩠ᨿᩣᩈᩥ, ᨽᩮᩣᨲᩮᩣ ᩅᩣᨴᩮᩣ ᩉᩥ ᨲᩣᨴᩥᩈᩮᩣ’’.

᪑᪔᪕.

‘‘ᩈᨧᩮ ᨸᩩᨻ᩠ᨻᩮᨠᨲᩉᩮᨲᩩ, ᩈᩩᨡᨴᩩᨠ᩠ᨡᩴ ᨶᩥᨣᨧ᩠ᨨᨲᩥ;

ᨸᩮᩣᩁᩣᨱᨠᩴ ᨠᨲᩴ ᨸᩣᨸᩴ, ᨲᨾᩮᩈᩮᩣ ᨾᩩᨧ᩠ᨧᨲᩮ [ᨾᩩᨬ᩠ᨧᨲᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩍᨱᩴ;

ᨸᩮᩣᩁᩣᨱᨠᩍᨱᨾᩮᩣᨠ᩠ᨡᩮᩣ, ᨠ᩠ᩅᩥᨵ ᨸᩣᨸᩮᨶ ᩃᩥᨸ᩠ᨸᨲᩥ.

᪑᪔᪖.

‘‘ᩈᩮᩣ ᨧᩮ ᩋᨲ᩠ᨳᩮᩣ ᨧ ᨵᨾ᩠ᨾᩮᩣ ᨧ, ᨠᩃ᩠ᨿᩣᨱᩮᩣ ᨶ ᨧ ᨸᩣᨸᨠᩮᩣ;

ᨽᩮᩣᨲᩮᩣ ᨧᩮ ᩅᨧᨶᩴ ᩈᨧ᩠ᨧᩴ, ᩈᩩᩉᨲᩮᩣ ᩅᩣᨶᩁᩮᩣ ᨾᨿᩣ.

᪑᪔᪗.

‘‘ᩋᨲ᩠ᨲᨶᩮᩣ ᨧᩮ ᩉᩥ ᩅᩣᨴᩔ, ᩋᨸᩁᩣᨵᩴ ᩅᩥᨩᩣᨶᩥᨿᩣ;

ᨶ ᨾᩴ ᨲ᩠ᩅᩴ ᨣᩁᩉᩮᨿ᩠ᨿᩣᩈᩥ, ᨽᩮᩣᨲᩮᩣ ᩅᩣᨴᩮᩣ ᩉᩥ ᨲᩣᨴᩥᩈᩮᩣ’’.

᪑᪔᪘.

‘‘ᨧᨲᩩᨶ᩠ᨶᩴᨿᩮᩅᩩᨸᩣᨴᩣᨿ, ᩁᩪᨸᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᨸᩣᨱᩥᨶᩴ;

ᨿᨲᩮᩣ ᨧ ᩁᩪᨸᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ, ᨲᨲ᩠ᨳᩮᩅᩣᨶᩩᨸᨣᨧ᩠ᨨᨲᩥ;

ᩍᨵᩮᩅ ᨩᩦᩅᨲᩥ ᨩᩦᩅᩮᩣ, ᨸᩮᨧ᩠ᨧ ᨸᩮᨧ᩠ᨧ ᩅᩥᨶᩔᨲᩥ.

᪑᪔᪙.

ᩏᨧ᩠ᨨᩥᨩ᩠ᨩᨲᩥ ᩋᨿᩴ ᩃᩮᩣᨠᩮᩣ, ᨿᩮ ᨻᩣᩃᩣ ᨿᩮ ᨧ ᨸᨱ᩠ᨯᩥᨲᩣ;

ᩏᨧ᩠ᨨᩥᨩ᩠ᨩᨾᩣᨶᩮ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ, ᨠ᩠ᩅᩥᨵ ᨸᩣᨸᩮᨶ ᩃᩥᨸ᩠ᨸᨲᩥ.

᪑᪕᪐.

‘‘ᩈᩮᩣ ¶ ᨧᩮ ᩋᨲ᩠ᨳᩮᩣ ᨧ ᨵᨾ᩠ᨾᩮᩣ ᨧ, ᨠᩃ᩠ᨿᩣᨱᩮᩣ ᨶ ᨧ ᨸᩣᨸᨠᩮᩣ;

ᨽᩮᩣᨲᩮᩣ ᨧᩮ ᩅᨧᨶᩴ ᩈᨧ᩠ᨧᩴ, ᩈᩩᩉᨲᩮᩣ ᩅᩣᨶᩁᩮᩣ ᨾᨿᩣ.

᪑᪕᪑.

‘‘ᩋᨲ᩠ᨲᨶᩮᩣ ᨧᩮ ᩉᩥ ᩅᩣᨴᩔ, ᩋᨸᩁᩣᨵᩴ ᩅᩥᨩᩣᨶᩥᨿᩣ;

ᨶ ᨾᩴ ᨲ᩠ᩅᩴ ᨣᩁᩉᩮᨿ᩠ᨿᩣᩈᩥ, ᨽᩮᩣᨲᩮᩣ ᩅᩣᨴᩮᩣ ᩉᩥ ᨲᩣᨴᩥᩈᩮᩣ’’.

᪑᪕᪒.

‘‘ᩌᩉᩩ ¶ ᨡᨲ᩠ᨲᩅᩥᨴᩣ [ᨡᨲ᩠ᨲᩅᩥᨵᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩃᩮᩣᨠᩮ, ᨻᩣᩃᩣ ᨸᨱ᩠ᨯᩥᨲᨾᩣᨶᩥᨶᩮᩣ.

ᨾᩣᨲᩁᩴ ᨸᩥᨲᩁᩴ ᩉᨬ᩠ᨬᩮ, ᩋᨳᩮᩣ ᨩᩮᨭ᩠ᨮᨾ᩠ᨸᩥ ᨽᩣᨲᩁᩴ;

ᩉᨶᩮᨿ᩠ᨿ ᨸᩩᨲ᩠ᨲ [ᨸᩩᨲ᩠ᨲᩮ ᨧ (ᨸᩦ.)] ᨴᩣᩁᩮ ᨧ, ᩋᨲ᩠ᨳᩮᩣ ᨧᩮ ᨲᩣᨴᩥᩈᩮᩣ ᩈᩥᨿᩣ.

᪑᪕᪓.

‘‘ᨿᩔ ¶ ᩁᩩᨠ᩠ᨡᩔ ᨨᩣᨿᩣᨿ, ᨶᩥᩈᩦᨴᩮᨿ᩠ᨿ ᩈᨿᩮᨿ᩠ᨿ ᩅᩣ;

ᨶ ᨲᩔ ᩈᩣᨡᩴ ᨽᨬ᩠ᨩᩮᨿ᩠ᨿ, ᨾᩥᨲ᩠ᨲᨴᩩᨻ᩠ᨽᩮᩣ [ᨾᩥᨲ᩠ᨲᨴᩪᨽᩦ (ᨸᩦ.)] ᩉᩥ ᨸᩣᨸᨠᩮᩣ.

᪑᪕᪔.

‘‘ᩋᨳ ᩋᨲ᩠ᨳᩮ ᩈᨾᩩᨸ᩠ᨸᨶ᩠ᨶᩮ, ᩈᨾᩪᩃᨾᨸᩥ ᩋᨻ᩠ᨻᩉᩮ [ᩋᨻ᩠ᨽᩉᩮ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᩋᨲ᩠ᨳᩮᩣ ᨾᩮ ᩈᨾ᩠ᨻᩃᩮᨶᩣᨸᩥ, ᩈᩩᩉᨲᩮᩣ ᩅᩣᨶᩁᩮᩣ ᨾᨿᩣ.

᪑᪕᪕.

[ᩋᨿᩴ ᨣᩣᨳᩣ ᩈᩦᩉᩊᨸᩮᩣᨲ᩠ᨳᨠᩮ ᨶᨲ᩠ᨳᩥ] ‘‘ᩈᩮᩣ ᨧᩮ ᩋᨲ᩠ᨳᩮᩣ ᨧ ᨵᨾ᩠ᨾᩮᩣ ᨧ, ᨠᩃ᩠ᨿᩣᨱᩮᩣ ᨶ ᨧ ᨸᩣᨸᨠᩮᩣ;

ᨽᩮᩣᨲᩮᩣ ᨧᩮ ᩅᨧᨶᩴ ᩈᨧ᩠ᨧᩴ, ᩈᩩᩉᨲᩮᩣ ᩅᩣᨶᩁᩮᩣ ᨾᨿᩣ [ᩋᨿᩴ ᨣᩣᨳᩣ ᩈᩦᩉᩊᨸᩮᩣᨲ᩠ᨳᨠᩮ ᨶᨲ᩠ᨳᩥ].

᪑᪕᪖.

‘‘ᩋᨲ᩠ᨲᨶᩮᩣ ᨧᩮ ᩉᩥ ᩅᩣᨴᩔ, ᩋᨸᩁᩣᨵᩴ ᩅᩥᨩᩣᨶᩥᨿᩣ;

ᨶ ᨾᩴ ᨲ᩠ᩅᩴ ᨣᩁᩉᩮᨿ᩠ᨿᩣᩈᩥ, ᨽᩮᩣᨲᩮᩣ ᩅᩣᨴᩮᩣ ᩉᩥ ᨲᩣᨴᩥᩈᩮᩣ.

᪑᪕᪗.

‘‘ᩋᩉᩮᨲᩩᩅᩣᨴᩮᩣ ᨸᩩᩁᩥᩈᩮᩣ, ᨿᩮᩣ ᨧ ᩍᩔᩁᨠᩩᨲ᩠ᨲᩥᨠᩮᩣ;

ᨸᩩᨻ᩠ᨻᩮᨠᨲᩦ ᨧ ᩏᨧ᩠ᨨᩮᨴᩦ, ᨿᩮᩣ ᨧ ᨡᨲ᩠ᨲᩅᩥᨴᩮᩣ ᨶᩁᩮᩣ.

᪑᪕᪘.

‘‘ᩑᨲᩮ ᩋᩈᨸ᩠ᨸᩩᩁᩥᩈᩣ ᩃᩮᩣᨠᩮ, ᨻᩣᩃᩣ ᨸᨱ᩠ᨯᩥᨲᨾᩣᨶᩥᨶᩮᩣ;

ᨠᩁᩮᨿ᩠ᨿ ᨲᩣᨴᩥᩈᩮᩣ ᨸᩣᨸᩴ, ᩋᨳᩮᩣ ᩋᨬ᩠ᨬᨾ᩠ᨸᩥ ᨠᩣᩁᨿᩮ;

ᩋᩈᨸ᩠ᨸᩩᩁᩥᩈᩈᩴᩈᨣ᩠ᨣᩮᩣ ¶ , ᨴᩩᨠ᩠ᨡᨶ᩠ᨲᩮᩣ [ᨴᩩᨠ᩠ᨠᨭᩮᩣ (ᩈᩦ.)] ᨠᨭᩩᨠᩩᨴᩕᨿᩮᩣ.

᪑᪕᪙.

‘‘ᩏᩁᨻ᩠ᨽᩁᩪᨸᩮᨶ ᩅᨠᩔᩩ [ᨻᨠᩣᩈᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩅᨠᩣᩈᩩ (ᨸᩦ.)] ᨸᩩᨻ᩠ᨻᩮ, ᩋᩈᩴᨠᩥᨲᩮᩣ ᩋᨩᨿᩪᨳᩴ ᩏᨸᩮᨲᩥ;

ᩉᨶ᩠ᨲ᩠ᩅᩣ ᩏᩁᨱᩥᩴ ᩋᨩᩥᨠᩴ [ᩋᨩᩥᨿᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩋᨩᨬ᩠ᨧ, ᩏᨲᩕᩣᩈᨿᩥᨲ᩠ᩅᩣ [ᨧᩥᨲᩕᩣᩈᨿᩥᨲ᩠ᩅᩣ (ᩈᩦ. ᨸᩦ.)] ᨿᩮᨶ ᨠᩣᨾᩴ ᨸᩃᩮᨲᩥ.

᪑᪖᪐.

‘‘ᨲᨳᩣᩅᩥᨵᩮᨠᩮ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣᩈᩮ, ᨨᨴᨶᩴ ᨠᨲ᩠ᩅᩣ ᩅᨬ᩠ᨧᨿᨶ᩠ᨲᩥ ᨾᨶᩩᩔᩮ;

ᩋᨶᩣᩈᨠᩣ ᨳᨱ᩠ᨯᩥᩃᩈᩮᨿ᩠ᨿᨠᩣ ᨧ, ᩁᨩᩮᩣᨩᩃ᩠ᩃᩴ ᩏᨠ᩠ᨠᩩᨭᩥᨠᨸ᩠ᨸᨵᩣᨶᩴ;

ᨸᩁᩥᨿᩣᨿᨽᨲ᩠ᨲᨬ᩠ᨧ ᩋᨸᩣᨶᨠᨲ᩠ᨲᩣ, ᨸᩣᨸᩣᨧᩣᩁᩣ ᩋᩁᩉᨶ᩠ᨲᩮᩣ ᩅᨴᩣᨶᩣ.

᪑᪖᪑.

‘‘ᩑᨲᩮ ᩋᩈᨸ᩠ᨸᩩᩁᩥᩈᩣ ᩃᩮᩣᨠᩮ, ᨻᩣᩃᩣ ᨸᨱ᩠ᨯᩥᨲᨾᩣᨶᩥᨶᩮᩣ;

ᨠᩁᩮᨿ᩠ᨿ ᨲᩣᨴᩥᩈᩮᩣ ᨸᩣᨸᩴ, ᩋᨳᩮᩣ ᩋᨬ᩠ᨬᨾ᩠ᨸᩥ ᨠᩣᩁᨿᩮ;

ᩋᩈᨸ᩠ᨸᩩᩁᩥᩈᩈᩴᩈᨣ᩠ᨣᩮᩣ, ᨴᩩᨠ᩠ᨡᨶ᩠ᨲᩮᩣ ᨠᨭᩩᨠᩩᨴᩕᨿᩮᩣ.

᪑᪖᪒.

‘‘ᨿᨾᩣᩉᩩ ¶ ᨶᨲ᩠ᨳᩥ ᩅᩦᩁᩥᨿᨶ᩠ᨲᩥ, ᩋᩉᩮᨲᩩᨬ᩠ᨧ ᨸᩅᨴᨶ᩠ᨲᩥ [ᩉᩮᨲᩩᨬ᩠ᨧ ᩋᨸᩅᨴᨶ᩠ᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨿᩮ;

ᨸᩁᨠᩣᩁᩴ ᩋᨲ᩠ᨲᨠᩣᩁᨬ᩠ᨧ, ᨿᩮ ᨲᩩᨧ᩠ᨨᩴ ᩈᨾᩅᨱ᩠ᨱᨿᩩᩴ.

᪑᪖᪓.

‘‘ᩑᨲᩮ ᩋᩈᨸ᩠ᨸᩩᩁᩥᩈᩣ ᩃᩮᩣᨠᩮ, ᨻᩣᩃᩣ ᨸᨱ᩠ᨯᩥᨲᨾᩣᨶᩥᨶᩮᩣ;

ᨠᩁᩮᨿ᩠ᨿ ᨲᩣᨴᩥᩈᩮᩣ ᨸᩣᨸᩴ, ᩋᨳᩮᩣ ᩋᨬ᩠ᨬᨾ᩠ᨸᩥ ᨠᩣᩁᨿᩮ;

ᩋᩈᨸ᩠ᨸᩩᩁᩥᩈᩈᩴᩈᨣ᩠ᨣᩮᩣ, ᨴᩩᨠ᩠ᨡᨶ᩠ᨲᩮᩣ ᨠᨭᩩᨠᩩᨴᩕᨿᩮᩣ.

᪑᪖᪔.

‘‘ᩈᨧᩮ ¶ ᩉᩥ ᩅᩦᩁᩥᨿᩴ ᨶᩣᩔ, ᨠᨾ᩠ᨾᩴ ᨠᩃ᩠ᨿᩣᨱᨸᩣᨸᨠᩴ;

ᨶ ¶ ᨽᩁᩮ ᩅᨯ᩠ᨰᨠᩥᩴ ᩁᩣᨩᩣ, ᨶᨸᩥ ᨿᨶ᩠ᨲᩣᨶᩥ ᨠᩣᩁᨿᩮ.

᪑᪖᪕.

‘‘ᨿᩈ᩠ᨾᩣ ᨧ ᩅᩦᩁᩥᨿᩴ ᩋᨲ᩠ᨳᩥ, ᨠᨾ᩠ᨾᩴ ᨠᩃ᩠ᨿᩣᨱᨸᩣᨸᨠᩴ;

ᨲᩈ᩠ᨾᩣ ᨿᨶ᩠ᨲᩣᨶᩥ ᨠᩣᩁᩮᨲᩥ, ᩁᩣᨩᩣ ᨽᩁᨲᩥ ᩅᨯ᩠ᨰᨠᩥᩴ.

᪑᪖᪖.

‘‘ᨿᨴᩥ ᩅᩔᩈᨲᩴ ᨴᩮᩅᩮᩣ, ᨶ ᩅᩔᩮ ᨶ ᩉᩥᨾᩴ ᨸᨲᩮ;

ᩏᨧ᩠ᨨᩥᨩ᩠ᨩᩮᨿ᩠ᨿ ᩋᨿᩴ ᩃᩮᩣᨠᩮᩣ, ᩅᩥᨶᩔᩮᨿ᩠ᨿ ᩋᨿᩴ ᨸᨩᩣ.

᪑᪖᪗.

‘‘ᨿᩈ᩠ᨾᩣ ᨧ ᩅᩔᨲᩦ ᨴᩮᩅᩮᩣ, ᩉᩥᨾᨬ᩠ᨧᩣᨶᩩᨹᩩᩈᩣᨿᨲᩥ;

ᨲᩈ᩠ᨾᩣ ᩈᩔᩣᨶᩥ ᨸᨧ᩠ᨧᨶ᩠ᨲᩥ, ᩁᨭ᩠ᨮᨬ᩠ᨧ ᨸᩣᩃᩥᨲᩮ [ᨸᩃ᩠ᩃᨲᩮ (ᩈᩦ. ᨸᩦ.), ᨸᩮᩣᩃᨿᨲᩮ (ᩈ᩠ᨿᩣ.)] ᨧᩥᩁᩴ.

᪑᪖᪘.

‘‘ᨣᩅᩴ ᨧᩮ ᨲᩁᨾᩣᨶᩣᨶᩴ, ᨩᩥᨾ᩠ᩉᩴ ᨣᨧ᩠ᨨᨲᩥ ᨸᩩᨦ᩠ᨣᩅᩮᩣ;

ᩈᨻ᩠ᨻᩣ ᨲᩣ ᨩᩥᨾ᩠ᩉᩴ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨶᩮᨲ᩠ᨲᩮ ᨩᩥᨾ᩠ᩉᩴ [ᨩᩥᨾ᩠ᩉ (ᨸᩦ.)] ᨣᨲᩮ ᩈᨲᩥ.

᪑᪖᪙.

‘‘ᩑᩅᨾᩮᩅ [ᩑᩅᨾᩮᩅᩴ (ᨸᩦ.)] ᨾᨶᩩᩔᩮᩈᩩ, ᨿᩮᩣ ᩉᩮᩣᨲᩥ ᩈᩮᨭ᩠ᨮᩈᨾ᩠ᨾᨲᩮᩣ;

ᩈᩮᩣ ᨧᩮ ᩋᨵᨾ᩠ᨾᩴ ᨧᩁᨲᩥ, ᨸᨣᩮᩅ ᩍᨲᩁᩣ ᨸᨩᩣ;

ᩈᨻ᩠ᨻᩴ ᩁᨭ᩠ᨮᩴ ᨴᩩᨡᩴ ᩈᩮᨲᩥ, ᩁᩣᨩᩣ ᨧᩮ ᩉᩮᩣᨲᩥ ᩋᨵᨾ᩠ᨾᩥᨠᩮᩣ.

᪑᪗᪐.

‘‘ᨣᩅᩴ ᨧᩮ ᨲᩁᨾᩣᨶᩣᨶᩴ, ᩏᨩᩩᩴ ᨣᨧ᩠ᨨᨲᩥ ᨸᩩᨦ᩠ᨣᩅᩮᩣ;

ᩈᨻ᩠ᨻᩣ ᨣᩣᩅᩦ ᩏᨩᩩᩴ ᨿᨶ᩠ᨲᩥ, ᨶᩮᨲ᩠ᨲᩮ ᩏᨩᩩᩴ [ᩏᨩᩪ (ᨸᩦ.)] ᨣᨲᩮ ᩈᨲᩥ.

᪑᪗᪑.

‘‘ᩑᩅᨾᩮᩅ ᨾᨶᩩᩔᩮᩈᩩ, ᨿᩮᩣ ᩉᩮᩣᨲᩥ ᩈᩮᨭ᩠ᨮᩈᨾ᩠ᨾᨲᩮᩣ;

ᩈᩮᩣ ᩈᨧᩮ [ᨧᩮᩅ (ᩈᩦ.), ᨧᩮᨸᩥ (ᨠ.)] ᨵᨾ᩠ᨾᩴ ᨧᩁᨲᩥ, ᨸᨣᩮᩅ ᩍᨲᩁᩣ ᨸᨩᩣ;

ᩈᨻ᩠ᨻᩴ ᩁᨭ᩠ᨮᩴ ᩈᩩᨡᩴ ᩈᩮᨲᩥ, ᩁᩣᨩᩣ ᨧᩮ ᩉᩮᩣᨲᩥ ᨵᨾ᩠ᨾᩥᨠᩮᩣ.

᪑᪗᪒.

‘‘ᨾᩉᩣᩁᩩᨠ᩠ᨡᩔ ᨹᩃᩥᨶᩮᩣ, ᩌᨾᩴ ᨨᩥᨶ᩠ᨴᨲᩥ ᨿᩮᩣ ᨹᩃᩴ;

ᩁᩈᨬ᩠ᨧᩔ ᨶ ᨩᩣᨶᩣᨲᩥ, ᨻᩦᨩᨬ᩠ᨧᩔ ᩅᩥᨶᩔᨲᩥ.

᪑᪗᪓.

‘‘ᨾᩉᩣᩁᩩᨠ᩠ᨡᩪᨸᨾᩴ ¶ ᩁᨭ᩠ᨮᩴ, ᩋᨵᨾ᩠ᨾᩮᨶ ᨸᩈᩣᩈᨲᩥ;

ᩁᩈᨬ᩠ᨧᩔ ᨶ ᨩᩣᨶᩣᨲᩥ, ᩁᨭ᩠ᨮᨬ᩠ᨧᩔ ᩅᩥᨶᩔᨲᩥ.

᪑᪗᪔.

‘‘ᨾᩉᩣᩁᩩᨠ᩠ᨡᩔ ¶ ᨹᩃᩥᨶᩮᩣ, ᨸᨠ᩠ᨠᩴ ᨨᩥᨶ᩠ᨴᨲᩥ ᨿᩮᩣ ᨹᩃᩴ;

ᩁᩈᨬ᩠ᨧᩔ ᩅᩥᨩᩣᨶᩣᨲᩥ, ᨻᩦᨩᨬ᩠ᨧᩔ ᨶ ᨶᩔᨲᩥ.

᪑᪗᪕.

‘‘ᨾᩉᩣᩁᩩᨠ᩠ᨡᩪᨸᨾᩴ ᩁᨭ᩠ᨮᩴ, ᨵᨾ᩠ᨾᩮᨶ ᨿᩮᩣ ᨸᩈᩣᩈᨲᩥ;

ᩁᩈᨬ᩠ᨧᩔ ᩅᩥᨩᩣᨶᩣᨲᩥ, ᩁᨭ᩠ᨮᨬ᩠ᨧᩔ ᨶ ᨶᩔᨲᩥ.

᪑᪗᪖.

‘‘ᨿᩮᩣ ᨧ ᩁᩣᨩᩣ ᨩᨶᨸᨴᩴ, ᩋᨵᨾ᩠ᨾᩮᨶ ᨸᩈᩣᩈᨲᩥ;

ᩈᨻ᩠ᨻᩮᩣᩈᨵᩦᩉᩥ ᩈᩮᩣ ᩁᩣᨩᩣ, ᩅᩥᩁᩩᨴ᩠ᨵᩮᩣ ᩉᩮᩣᨲᩥ ᨡᨲ᩠ᨲᩥᨿᩮᩣ.

᪑᪗᪗.

‘‘ᨲᨳᩮᩅ ᨶᩮᨣᨾᩮ ᩉᩥᩴᩈᩴ, ᨿᩮ ᨿᩩᨲ᩠ᨲᩣ ᨠᨿᩅᩥᨠ᩠ᨠᨿᩮ;

ᩒᨩᨴᩣᨶᨻᩃᩦᨠᩣᩁᩮ, ᩈ ᨠᩮᩣᩈᩮᨶ ᩅᩥᩁᩩᨩ᩠ᨫᨲᩥ.

᪑᪗᪘.

‘‘ᨸᩉᩣᩁᩅᩁᨡᩮᨲ᩠ᨲᨬ᩠ᨬᩪ ¶ , ᩈᨦ᩠ᨣᩣᨾᩮ ᨠᨲᨶᩥᩔᨾᩮ [ᨠᨲᨶᩥᨿᨾᩮ (ᨠ.)];

ᩏᩔᩥᨲᩮ ᩉᩥᩴᩈᨿᩴ ᩁᩣᨩᩣ, ᩈ ᨻᩃᩮᨶ ᩅᩥᩁᩩᨩ᩠ᨫᨲᩥ.

᪑᪗᪙.

‘‘ᨲᨳᩮᩅ ᩍᩈᨿᩮᩣ ᩉᩥᩴᩈᩴ, ᩈᨬ᩠ᨬᨲᩮ [ᩈᩴᨿᨾᩮ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨿᩮᩣ [ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩮᩣ (ᩈᩦ.)];

ᩋᨵᨾ᩠ᨾᨧᩣᩁᩦ ᨡᨲ᩠ᨲᩥᨿᩮᩣ, ᩈᩮᩣ ᩈᨣ᩠ᨣᩮᨶ ᩅᩥᩁᩩᨩ᩠ᨫᨲᩥ.

᪑᪘᪐.

‘‘ᨿᩮᩣ ᨧ ᩁᩣᨩᩣ ᩋᨵᨾ᩠ᨾᨭ᩠ᨮᩮᩣ, ᨽᩁᩥᨿᩴ ᩉᨶ᩠ᨲᩥ ᩋᨴᩪᩈᩥᨠᩴ;

ᩃᩩᨴ᩠ᨴᩴ ᨸᩈᩅᨲᩮ ᨮᩣᨶᩴ [ᨸᩣᨸᩴ (ᩈᩦ.)], ᨸᩩᨲ᩠ᨲᩮᩉᩥ ᨧ ᩅᩥᩁᩩᨩ᩠ᨫᨲᩥ.

᪑᪘᪑.

‘‘ᨵᨾ᩠ᨾᩴ ᨧᩁᩮ ᨩᩣᨶᨸᨴᩮ, ᨶᩮᨣᨾᩮᩈᩩ [ᨶᩥᨣᨾᩮᩈᩩ (ᩈᩦ.)] ᨻᩃᩮᩈᩩ ᨧ;

ᩍᩈᨿᩮᩣ ᨧ ᨶ ᩉᩥᩴᩈᩮᨿ᩠ᨿ, ᨸᩩᨲ᩠ᨲᨴᩣᩁᩮ ᩈᨾᩴ ᨧᩁᩮ.

᪑᪘᪒.

‘‘ᩈ ᨲᩣᨴᩥᩈᩮᩣ ᨽᩪᨾᩥᨸᨲᩥ, ᩁᨭ᩠ᨮᨸᩣᩃᩮᩣ ᩋᨠᩮᩣᨵᨶᩮᩣ;

ᩈᨸᨲ᩠ᨲᩮ ¶ [ᩈᩣᨾᨶ᩠ᨲᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩈᨾ᩠ᨸᨠᨾ᩠ᨸᩮᨲᩥ, ᩍᨶ᩠ᨴᩮᩣᩅ ᩋᩈᩩᩁᩣᨵᩥᨸᩮᩣ’’ᨲᩥ.

ᨾᩉᩣᨻᩮᩣᨵᩥᨩᩣᨲᨠᩴ ᨲᨲᩥᨿᩴ.

ᨸᨱ᩠ᨱᩣᩈᨶᩥᨸᩣᨲᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨲᩔᩩᨴ᩠ᨴᩣᨶᩴ –

ᩈᨶᩥᩊᩦᨶᩥᨠᨾᩅ᩠ᩉᨿᨶᩮᩣ ᨸᨮᨾᩮᩣ, ᨴᩩᨲᩥᨿᩮᩣ ᨸᨶ ᩈᩏᨾ᩠ᨾᨴᨶ᩠ᨲᩥᩅᩁᩮᩣ;

ᨲᨲᩥᨿᩮᩣ ᨸᨶ ᨻᩮᩣᨵᩥᩈᩥᩁᩦᩅ᩠ᩉᨿᨶᩮᩣ, ᨠᨳᩥᨲᩣ ᨸᨶ ᨲᩦᨱᩥ ᨩᩥᨶᩮᨶ ᩈᩩᨽᩣᨲᩥ.

᪑᪙. ᩈᨭ᩠ᨮᩥᨶᩥᨸᩣᨲᩮᩣ

᪕᪒᪙. ᩈᩮᩣᨱᨠᨩᩣᨲᨠᩴ (᪑)

᪑.

‘‘ᨲᩔ ¶ ¶ ¶ ᩈᩩᨲ᩠ᩅᩣ ᩈᨲᩴ ᨴᨾ᩠ᨾᩥ, ᩈᩉᩔᩴ ᨴᩥᨭ᩠ᨮ [ᨴᨭ᩠ᨮᩩ (ᩈᩦ. ᨸᩦ.)] ᩈᩮᩣᨱᨠᩴ;

ᨠᩮᩣ ᨾᩮ ᩈᩮᩣᨱᨠᨾᨠ᩠ᨡᩣᨲᩥ, ᩈᩉᩣᨿᩴ ᨸᩴᩈᩩᨠᩦᩊᩥᨲᩴ’’.

᪒.

‘‘ᩋᨳᨻᩕᩅᩦ ᨾᩣᨱᩅᨠᩮᩣ, ᨴᩉᩁᩮᩣ ᨸᨬ᩠ᨧᨧᩪᩊᨠᩮᩣ;

ᨾᨿ᩠ᩉᩴ ᩈᩩᨲ᩠ᩅᩣ ᩈᨲᩴ ᨴᩮᩉᩥ, ᩈᩉᩔᩴ ᨴᩥᨭ᩠ᨮ [ᨴᨭ᩠ᨮᩩ (ᩈᩦ. ᨸᩦ.)] ᩈᩮᩣᨱᨠᩴ;

ᩋᩉᩴ ᨲᩮ ᩈᩮᩣᨱᨠᨠ᩠ᨡᩥᩔᩴ [ᩋᩉᩴ ᩈᩮᩣᨱᨠᨾᨠ᩠ᨡᩥᩔᩴ (ᩈᩦ. ᨸᩦ.), ᩋᩉᩴ ᨲᩮ ᩈᩮᩣᨱᨠᨾᨠ᩠ᨡᩥᩔᩴ (ᩈ᩠ᨿᩣ.)], ᩈᩉᩣᨿᩴ ᨸᩴᩈᩩᨠᩦᩊᩥᨲᩴ’’.

᪓.

‘‘ᨠᨲᨾᩈ᩠ᨾᩥᩴ [ᨠᨲᩁᩈ᩠ᨾᩥᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩈᩮᩣ ᨩᨶᨸᨴᩮ, ᩁᨭ᩠ᨮᩮᩈᩩ ᨶᩥᨣᨾᩮᩈᩩ ᨧ;

ᨠᨲ᩠ᨳ ᩈᩮᩣᨱᨠᨾᨴ᩠ᨴᨠ᩠ᨡᩥ [ᨠᨲ᩠ᨳ ᨲᩮ ᩈᩮᩣᨱᨠᩮᩣ ᨴᩥᨭ᩠ᨮᩮᩣ (ᩈᩦ. ᨸᩦ.)], ᨲᩴ ᨾᩮ ᩋᨠ᩠ᨡᩣᩉᩥ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ’’.

᪔.

‘‘ᨲᩅᩮᩅ ᨴᩮᩅ ᩅᩥᨩᩥᨲᩮ, ᨲᩅᩮᩅᩩᨿ᩠ᨿᩣᨶᨽᩪᨾᩥᨿᩣ;

ᩏᨩᩩᩅᩴᩈᩣ ᨾᩉᩣᩈᩣᩃᩣ, ᨶᩦᩃᩮᩣᨽᩣᩈᩣ ᨾᨶᩮᩣᩁᨾᩣ.

᪕.

‘‘ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᨾᩮᨥᩈᨾᩣᨶᩣ, ᩁᨾ᩠ᨾᩣ ᩋᨬ᩠ᨬᩮᩣᨬ᩠ᨬᨶᩥᩔᩥᨲᩣ;

ᨲᩮᩈᩴ ᨾᩪᩃᨾ᩠ᩉᩥ [ᨾᩪᩃᩈ᩠ᨾᩥᩴ (ᩈᩦ. ᨸᩦ.), ᨾᩪᩃᩈ᩠ᨾᩥ (ᩈ᩠ᨿᩣ.)] ᩈᩮᩣᨱᨠᩮᩣ, ᨫᩣᨿᨲᩦ ᩋᨶᩩᨸᩣᨴᨶᩮᩣ [ᩋᨶᩩᨸᩣᨴᩥᨶᩮᩣ (ᩈ᩠ᨿᩣ.), ᩋᨶᩩᨸᩣᨴᩣᨶᩮᩣ (ᨸᩦ.)];

ᩏᨸᩣᨴᩣᨶᩮᩈᩩ ᩃᩮᩣᨠᩮᩈᩩ, ᨯᨿ᩠ᩉᨾᩣᨶᩮᩈᩩ ᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ.

᪖.

‘‘ᨲᨲᩮᩣ ᨧ ᩁᩣᨩᩣ ᨸᩣᨿᩣᩈᩥ, ᩈᩮᨶᩣᨿ ᨧᨲᩩᩁᨦ᩠ᨣᩥᨿᩣ;

ᨠᩣᩁᩣᨸᩮᨲ᩠ᩅᩣ ᩈᨾᩴ ᨾᨣ᩠ᨣᩴ, ᩋᨣᨾᩣ ᨿᩮᨶ ᩈᩮᩣᨱᨠᩮᩣ.

᪗.

‘‘ᩏᨿ᩠ᨿᩣᨶᨽᩪᨾᩥᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ, ᩅᩥᨧᩁᨶ᩠ᨲᩮᩣ ᨻᩕᩉᩣᩅᨶᩮ;

ᩌᩈᩦᨶᩴ ¶ ᩈᩮᩣᨱᨠᩴ ᨴᨠ᩠ᨡᩥ, ᨯᨿ᩠ᩉᨾᩣᨶᩮᩈᩩ ᨶᩥᨻ᩠ᨻᩩᨲᩴ’’.

᪘.

‘‘ᨠᨸᨱᩮᩣ ᩅᨲᨿᩴ ᨽᩥᨠ᩠ᨡᩩ, ᨾᩩᨱ᩠ᨯᩮᩣ ᩈᨦ᩠ᨥᩣᨭᩥᨸᩣᩁᩩᨲᩮᩣ;

ᩋᨾᩣᨲᩥᨠᩮᩣ ᩋᨸᩥᨲᩥᨠᩮᩣ, ᩁᩩᨠ᩠ᨡᨾᩪᩃᩈ᩠ᨾᩥ ᨫᩣᨿᨲᩥ’’.

᪙.

‘‘ᩍᨾᩴ ᩅᩣᨠ᩠ᨿᩴ ᨶᩥᩈᩣᨾᩮᨲ᩠ᩅᩣ, ᩈᩮᩣᨱᨠᩮᩣ ᩑᨲᨴᨻᩕᩅᩥ;

‘ᨶ ᩁᩣᨩ ᨠᨸᨱᩮᩣ ᩉᩮᩣᨲᩥ, ᨵᨾ᩠ᨾᩴ ᨠᩣᨿᩮᨶ ᨹᩔᨿᩴ [ᨹᩩᩈᨿᩴ (ᨠ.)].

᪑᪐.

‘ᨿᩮᩣ ¶ ᨧ [ᨿᩮᩣᨵ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨵᨾ᩠ᨾᩴ ᨶᩥᩁᩴᨠᨲ᩠ᩅᩣ [ᨶᩥᩁᩣᨠᨲ᩠ᩅᩣ (?)], ᩋᨵᨾ᩠ᨾᨾᨶᩩᩅᨲ᩠ᨲᨲᩥ;

ᩈ ᩁᩣᨩ ᨠᨸᨱᩮᩣ ᩉᩮᩣᨲᩥ, ᨸᩣᨸᩮᩣ ᨸᩣᨸᨸᩁᩣᨿᨶᩮᩣ’’’.

᪑᪑.

‘‘‘ᩋᩁᩥᨶ᩠ᨴᨾᩮᩣᨲᩥ ¶ ᨾᩮ ᨶᩣᨾᩴ, ᨠᩣᩈᩥᩁᩣᨩᩣᨲᩥ ᨾᩴ ᩅᩥᨴᩪ;

ᨠᨧ᩠ᨧᩥ ᨽᩮᩣᨲᩮᩣ ᩈᩩᨡᩔᩮᨿ᩠ᨿᩣ [ᩈᩩᨡᩣ ᩈᩮᨿ᩠ᨿᩣ (ᨸᩦ.), ᩈᩩᨡᩈᩮᨿ᩠ᨿᩮᩣ (ᨠ.)], ᩍᨵ ᨸᨲ᩠ᨲᩔ ᩈᩮᩣᨱᨠ’’’.

᪑᪒.

‘‘ᩈᨴᩣᨸᩥ ᨽᨴᩕᨾᨵᨶᩔ, ᩋᨶᩣᨣᩣᩁᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᨶ ᨲᩮᩈᩴ ᨠᩮᩣᨭ᩠ᨮᩮ ᩒᨸᩮᨶ᩠ᨲᩥ, ᨶ ᨠᩩᨾ᩠ᨽᩥᩴ ᨶ ᨡᩊᩮᩣᨸᩥᨿᩴ [ᨶ ᨠᩩᨾ᩠ᨽᩮ ᨶ ᨠᩊᩮᩣᨸᩥᨿᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᨸᩁᨶᩥᨭ᩠ᨮᩥᨲᨾᩮᩈᩣᨶᩣ, ᨲᩮᨶ ᨿᩣᨸᩮᨶ᩠ᨲᩥ ᩈᩩᨻ᩠ᨻᨲᩣ.

᪑᪓.

‘‘ᨴᩩᨲᩥᨿᨾ᩠ᨸᩥ ᨽᨴᩕᨾᨵᨶᩔ, ᩋᨶᩣᨣᩣᩁᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᩋᨶᩅᨩ᩠ᨩᨸᩥᨱ᩠ᨯᩮᩣ [ᩋᨶᩅᨩ᩠ᨩᩮᩣ ᨸᩥᨱ᩠ᨯᩣ (ᨸᩦ.)] ᨽᩮᩣᨲ᩠ᨲᨻ᩠ᨻᩮᩣ, ᨶ ᨧ ᨠᩮᩣᨧᩪᨸᩁᩮᩣᨵᨲᩥ.

᪑᪔.

‘‘ᨲᨲᩥᨿᨾ᩠ᨸᩥ ᨽᨴᩕᨾᨵᨶᩔ, ᩋᨶᩣᨣᩣᩁᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ ᨸᩥᨱ᩠ᨯᩮᩣ ᨽᩮᩣᨲ᩠ᨲᨻ᩠ᨻᩮᩣ, ᨶ ᨧ ᨠᩮᩣᨧᩪᨸᩁᩮᩣᨵᨲᩥ.

᪑᪕.

‘‘ᨧᨲᩩᨲ᩠ᨳᨾ᩠ᨸᩥ [ᨧᨲᩩᨲ᩠ᨳᩴ (ᨸᩦ.)] ᨽᨴᩕᨾᨵᨶᩔ, ᩋᨶᩣᨣᩣᩁᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᨾᩩᨲ᩠ᨲᩔ ᩁᨭ᩠ᨮᩮ ᨧᩁᨲᩮᩣ, ᩈᨦ᩠ᨣᩮᩣ ᨿᩔ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ.

᪑᪖.

‘‘ᨸᨬ᩠ᨧᨾᨾ᩠ᨸᩥ [ᨸᨬ᩠ᨧᨾᩴ (ᨸᩦ.)] ᨽᨴᩕᨾᨵᨶᩔ, ᩋᨶᩣᨣᩣᩁᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᨶᨣᩁᨾ᩠ᩉᩥ ᨯᨿ᩠ᩉᨾᩣᨶᨾ᩠ᩉᩥ, ᨶᩣᩔ ᨠᩥᨬ᩠ᨧᩥ ᩋᨯᨿ᩠ᩉᨳ.

᪑᪗.

‘‘ᨨᨭ᩠ᨮᨾ᩠ᨸᩥ ¶ [ᨨᨭ᩠ᨮᩴ (ᨸᩦ.)] ᨽᨴᩕᨾᨵᨶᩔ, ᩋᨶᩣᨣᩣᩁᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᩁᨭ᩠ᨮᩮ ᩅᩥᩃᩩᨾ᩠ᨸᨾᩣᨶᨾ᩠ᩉᩥ [ᩅᩥᩃᩩᨸ᩠ᨸᨾᩣᨶᨾ᩠ᩉᩥ (ᨠ.)], ᨶᩣᩔ ᨠᩥᨬ᩠ᨧᩥ ᩋᩉᩦᩁᨳ [ᩋᩉᩣᩁᨳ (ᩈᩦ. ᩈ᩠ᨿᩣ.)].

᪑᪘.

‘‘ᩈᨲ᩠ᨲᨾᨾ᩠ᨸᩥ [ᩈᨲ᩠ᨲᨾᩴ (ᨸᩦ.)] ᨽᨴᩕᨾᨵᨶᩔ, ᩋᨶᩣᨣᩣᩁᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᨧᩮᩣᩁᩮᩉᩥ ᩁᨠ᩠ᨡᩥᨲᩴ ᨾᨣ᩠ᨣᩴ, ᨿᩮ ᨧᨬ᩠ᨬᩮ ᨸᩁᩥᨸᨶ᩠ᨳᩥᨠᩣ;

ᨸᨲ᩠ᨲᨧᩦᩅᩁᨾᩣᨴᩣᨿ, ᩈᩮᩣᨲ᩠ᨳᩥᩴ ᨣᨧ᩠ᨨᨲᩥ ᩈᩩᨻ᩠ᨻᨲᩮᩣ.

᪑᪙.

‘‘ᩋᨭ᩠ᨮᨾᨾ᩠ᨸᩥ [ᩋᨭ᩠ᨮᨾᩴ (ᨸᩦ.)] ᨽᨴᩕᨾᨵᨶᩔ, ᩋᨶᩣᨣᩣᩁᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᨿᩴ ᨿᩴ ᨴᩥᩈᩴ ᨸᨠ᩠ᨠᨾᨲᩥ, ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣᩅ ᨣᨧ᩠ᨨᨲᩥ’’.

᪒᪐.

‘‘ᨻᩉᩪᨸᩥ ᨽᨴᩕᩣ [ᨻᩉᩪᨶᩥ ᩈᨾᨱᨽᨴᩕᩣᨶᩥ (ᩈᩦ.), ᨻᩉᩪᨸᩥ ᨽᨴᩕᨠᩣ ᩑᨲᩮ (ᨸᩦ.)] ᩑᨲᩮᩈᩴ, ᨿᩮᩣ ᨲ᩠ᩅᩴ ᨽᩥᨠ᩠ᨡᩩ ᨸᩈᩴᩈᩈᩥ;

ᩋᩉᨬ᩠ᨧ ᨣᩥᨴ᩠ᨵᩮᩣ ᨠᩣᨾᩮᩈᩩ, ᨠᨳᩴ ᨠᩣᩉᩣᨾᩥ ᩈᩮᩣᨱᨠ.

᪒᪑.

‘‘ᨸᩥᨿᩣ ¶ ᨾᩮ ᨾᩣᨶᩩᩈᩣ ᨠᩣᨾᩣ, ᩋᨳᩮᩣ ᨴᩥᨻ᩠ᨿᩣᨸᩥ ᨾᩮ ᨸᩥᨿᩣ;

ᩋᨳ ᨠᩮᨶ ᨶᩩ ᩅᨱ᩠ᨱᩮᨶ, ᩏᨽᩮᩣ ᩃᩮᩣᨠᩮ ᩃᨽᩣᨾᩈᩮ’’.

᪒᪒.

‘‘ᨠᩣᨾᩮ ᨣᩥᨴ᩠ᨵᩣ [ᨠᩣᨾᩮᩈᩩ ᨣᩥᨴ᩠ᨵᩣ (ᩈᩦ. ᨸᩦ.)] ᨠᩣᨾᩁᨲᩣ, ᨠᩣᨾᩮᩈᩩ ᩋᨵᩥᨾᩩᨧ᩠ᨨᩥᨲᩣ;

ᨶᩁᩣ ᨸᩣᨸᩣᨶᩥ ᨠᨲ᩠ᩅᩣᨶ, ᩏᨸᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨴᩩᨣ᩠ᨣᨲᩥᩴ.

᪒᪓.

‘‘ᨿᩮ ᨧ ᨠᩣᨾᩮ ᨸᩉᨶ᩠ᨲ᩠ᩅᩣᨶ [ᨸᩉᨲ᩠ᩅᩣᨶ (ᩈᩦ. ᨸᩦ.)], ᨶᩥᨠ᩠ᨡᨶ᩠ᨲᩣ ᩋᨠᩩᨲᩮᩣᨽᨿᩣ;

ᩑᨠᩮᩣᨴᩥᨽᩣᩅᩣᨵᩥᨣᨲᩣ, ᨶ ᨲᩮ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ ᨴᩩᨣ᩠ᨣᨲᩥᩴ.

᪒᪔.

‘‘ᩏᨸᨾᩴ ᨲᩮ ᨠᩁᩥᩔᩣᨾᩥ, ᨲᩴ ᩈᩩᨱᩮᩣᩉᩥ ᩋᩁᩥᨶ᩠ᨴᨾ;

ᩏᨸᨾᩣᨿ ᨾᩥᨵᩮᨠᨧ᩠ᨧᩮ [ᨸᩥᨵᩮᨠᨧ᩠ᨧᩮ (ᩈᩦ. ᨸᩦ.)], ᩋᨲ᩠ᨳᩴ ᨩᩣᨶᨶ᩠ᨲᩥ ᨸᨱ᩠ᨯᩥᨲᩣ.

᪒᪕.

‘‘ᨣᨦ᩠ᨣᩣᨿ ¶ ᨠᩩᨱᨸᩴ ᨴᩥᩈ᩠ᩅᩣ, ᩅᩩᨿ᩠ᩉᨾᩣᨶᩴ ᨾᩉᨱ᩠ᨱᩅᩮ;

ᩅᩣᨿᩈᩮᩣ ᩈᨾᨧᩥᨶ᩠ᨲᩮᩈᩥ, ᩋᨸ᩠ᨸᨸᨬ᩠ᨬᩮᩣ ᩋᨧᩮᨲᩈᩮᩣ.

᪒᪖.

‘‘‘ᨿᩣᨶᨬ᩠ᨧ ¶ ᩅᨲᩥᨴᩴ ᩃᨴ᩠ᨵᩴ, ᨽᨠ᩠ᨡᩮᩣ ᨧᩣᨿᩴ ᩋᨶᨸ᩠ᨸᨠᩮᩣ’;

ᨲᨲ᩠ᨳ ᩁᨲ᩠ᨲᩥᩴ ᨲᨲ᩠ᨳ ᨴᩥᩅᩣ, ᨲᨲ᩠ᨳᩮᩅ ᨶᩥᩁᨲᩮᩣ ᨾᨶᩮᩣ.

᪒᪗.

‘‘ᨡᩣᨴᩴ ᨶᩣᨣᩔ ᨾᩴᩈᩣᨶᩥ, ᨸᩥᩅᩴ ᨽᩣᨣᩦᩁᨳᩮᩣᨴᨠᩴ [ᨽᩣᨣᩥᩁᩈᩮᩣᨴᨠᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)];

ᩈᨾ᩠ᨸᩔᩴ ᩅᨶᨧᩮᨲ᩠ᨿᩣᨶᩥ, ᨶ ᨸᩃᩮᨲ᩠ᨳ [ᨸᩃᩮᨲ᩠ᩅᩣ (ᨠ.)] ᩅᩥᩉᨦ᩠ᨣᨾᩮᩣ.

᪒᪘.

‘‘ᨲᨬ᩠ᨧ [ᨲᩴᩅ (ᨸᩦ.)] ᩒᨲᩁᨱᩦ ᨣᨦ᩠ᨣᩣ, ᨸᨾᨲ᩠ᨲᩴ ᨠᩩᨱᨸᩮ ᩁᨲᩴ;

ᩈᨾᩩᨴ᩠ᨴᩴ ᩋᨩ᩠ᨫᨣᩣᩉᩣᩈᩥ [ᩋᨩ᩠ᨫᨣᩣᩉᨿᩥ (ᨸᩦ.)], ᩋᨣᨲᩦ ᨿᨲ᩠ᨳ ᨸᨠ᩠ᨡᩥᨶᩴ.

᪒᪙.

‘‘ᩈᩮᩣ ᨧ ᨽᨠ᩠ᨡᨸᩁᩥᨠ᩠ᨡᩦᨱᩮᩣ, ᩏᨴᨸᨲ᩠ᩅᩣ [ᩏᨸ᩠ᨸᨲᩥᨲ᩠ᩅᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩏᨴᩣᨸᨲ᩠ᩅᩣ (ᨸᩦ.)] ᩅᩥᩉᨦ᩠ᨣᨾᩮᩣ.

ᨶ ᨸᨧ᩠ᨨᨲᩮᩣ ᨶ ᨸᩩᩁᨲᩮᩣ, ᨶᩩᨲ᩠ᨲᩁᩴ ᨶᩮᩣᨸᩥ ᨴᨠ᩠ᨡᩥᨱᩴ.

᪓᪐.

‘‘ᨴᩦᨸᩴ ᩈᩮᩣ ᨶᨩ᩠ᨫᨣᩣᨣᨬ᩠ᨨᩥ [ᨶ ᩋᨩ᩠ᨫᨣᨬ᩠ᨨᩥ (ᩈᩦ.), ᨶ ᩋᨩ᩠ᨫᨣᨧ᩠ᨨᩥ (ᨸᩦ.)], ᩋᨣᨲᩦ ᨿᨲ᩠ᨳ ᨸᨠ᩠ᨡᩥᨶᩴ;

ᩈᩮᩣ ᨧ ᨲᨲ᩠ᨳᩮᩅ ᨸᩣᨸᨲ᩠ᨳ, ᨿᨳᩣ ᨴᩩᨻ᩠ᨻᩃᨠᩮᩣ ᨲᨳᩣ.

᪓᪑.

‘‘ᨲᨬ᩠ᨧ ᩈᩣᨾᩩᨴ᩠ᨴᩥᨠᩣ ᨾᨧ᩠ᨨᩣ, ᨠᩩᨾ᩠ᨽᩦᩃᩣ ᨾᨠᩁᩣ ᩈᩩᩈᩪ;

ᨸᩈᨿ᩠ᩉᨠᩣᩁᩣ ᨡᩣᨴᩥᩴᩈᩩ, ᨹᨶ᩠ᨴᨾᩣᨶᩴ ᩅᩥᨸᨠ᩠ᨡᨠᩴ [ᩅᩥᨸᨠ᩠ᨡᩥᨶᩴ (ᩈᩦ. ᨸᩦ.), ᩅᩥᨸᨠ᩠ᨡᩥᨠᩴ (ᩈ᩠ᨿᩣ.)].

᪓᪒.

‘‘ᩑᩅᨾᩮᩅ ¶ ᨲᩩᩅᩴ ᩁᩣᨩ, ᨿᩮ ᨧᨬ᩠ᨬᩮ ᨠᩣᨾᨽᩮᩣᨣᩥᨶᩮᩣ;

ᨣᩥᨴ᩠ᨵᩣ ᨧᩮ ᨶ ᩅᨾᩥᩔᨶ᩠ᨲᩥ, ᨠᩣᨠᨸᨬ᩠ᨬᩣᩅ [ᨠᩣᨠᨸᨬ᩠ᨬᩣᨿ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨲᩮ ᩅᩥᨴᩪ.

᪓᪓.

‘‘ᩑᩈᩣ ᨲᩮ ᩏᨸᨾᩣ ᩁᩣᨩ, ᩋᨲ᩠ᨳᩈᨶ᩠ᨴᩔᨶᩦ ᨠᨲᩣ;

ᨲ᩠ᩅᨬ᩠ᨧ ᨸᨬ᩠ᨬᩣᨿᩈᩮ ᨲᩮᨶ, ᨿᨴᩥ ᨠᩣᩉᩈᩥ ᩅᩣ ᨶ ᩅᩣ.

᪓᪔.

‘‘ᩑᨠᩅᩣᨧᨾ᩠ᨸᩥ ᨴ᩠ᩅᩥᩅᩣᨧᩴ, ᨽᨱᩮᨿ᩠ᨿ ᩋᨶᩩᨠᨾ᩠ᨸᨠᩮᩣ;

ᨲᨲᩩᨲ᩠ᨲᩁᩥᩴ ᨶ ᨽᩣᩈᩮᨿ᩠ᨿ, ᨴᩣᩈᩮᩣᩅᨿ᩠ᨿᩔ [ᨴᩣᩈᩮᩣ ᩋᨿ᩠ᨿᩔ (ᩈᩦ.), ᨴᩣᩈᩮᩣ ᩋᨿᩥᩁᩔ (ᨸᩦ.)] ᩈᨶ᩠ᨲᩥᨠᩮ’’.

᪓᪕.

‘‘ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᨸᨠ᩠ᨠᩣᨾᩥ, ᩈᩮᩣᨱᨠᩮᩣ ᩋᨾᩥᨲᨻᩩᨴ᩠ᨵᩥᨾᩣ [ᩈᩮᩣᨱᨠᩮᩣ’ᨾᩥᨲᨻᩩᨴ᩠ᨵᩥᨾᩣ (?)];

ᩅᩮᩉᩣᩈᩮ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩈ᩠ᨾᩥᩴ, ᩋᨶᩩᩈᩣᩈᩥᨲ᩠ᩅᩣᨶ ᨡᨲ᩠ᨲᩥᨿᩴ’’.

᪓᪖.

‘‘ᨠᩮᩣ ¶ ᨶᩩᨾᩮ ᩁᩣᨩᨠᨲ᩠ᨲᩣᩁᩮᩣ, ᩈᩩᨴ᩠ᨴᩣ ᩅᩮᨿ᩠ᨿᨲ᩠ᨲᨾᩣᨣᨲᩣ [ᩈᩪᨲᩣ ᩅᩮᨿ᩠ᨿᨲ᩠ᨲᩥᨾᩣᨣᨲᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᩁᨩ᩠ᨩᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩥᩔᩣᨾᩥ, ᨶᩣᩉᩴ ᩁᨩ᩠ᨩᩮᨶ ᨾᨲ᩠ᨳᩥᨠᩮᩣ.

᪓᪗.

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨠᩮᩣ ᨩᨬ᩠ᨬᩣ ᨾᩁᨱᩴ ᩈᩩᩅᩮ;

ᨾᩣᩉᩴ ᨠᩣᨠᩮᩣᩅ ᨴᩩᨾ᩠ᨾᩮᨵᩮᩣ, ᨠᩣᨾᩣᨶᩴ ᩅᩈᨾᨶ᩠ᩅᨣᩴ’’ [ᩅᩈᨾᨶ᩠ᨶᨣᩣ (ᨸᩦ.)].

᪓᪘.

‘‘ᩋᨲ᩠ᨳᩥ ᨲᩮ ᨴᩉᩁᩮᩣ ᨸᩩᨲ᩠ᨲᩮᩣ, ᨴᩦᨥᩣᩅᩩ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶᩮᩣ;

ᨲᩴ ᩁᨩ᩠ᨩᩮ ᩋᨽᩥᩈᩥᨬ᩠ᨧᩔᩩ, ᩈᩮᩣ ᨶᩮᩣ ᩁᩣᨩᩣ ᨽᩅᩥᩔᨲᩥ’’.

᪓᪙.

‘‘ᨡᩥᨸ᩠ᨸᩴ ᨠᩩᨾᩣᩁᨾᩣᨶᩮᨳ, ᨴᩦᨥᩣᩅᩩᩴ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶᩴ;

ᨲᩴ ᩁᨩ᩠ᨩᩮ ᩋᨽᩥᩈᩥᨬ᩠ᨧᩥᩔᩴ, ᩈᩮᩣ ᩅᩮᩣ ᩁᩣᨩᩣ ᨽᩅᩥᩔᨲᩥ’’.

᪔᪐.

‘‘ᨲᨲᩮᩣ ¶ ᨠᩩᨾᩣᩁᨾᩣᨶᩮᩈᩩᩴ, ᨴᩦᨥᩣᩅᩩᩴ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶᩴ;

ᨲᩴ ᨴᩥᩈ᩠ᩅᩣ ᩌᩃᨸᩦ ᩁᩣᨩᩣ, ᩑᨠᨸᩩᨲ᩠ᨲᩴ ᨾᨶᩮᩣᩁᨾᩴ.

᪔᪑.

‘‘ᩈᨭ᩠ᨮᩥ ᨣᩣᨾᩈᩉᩔᩣᨶᩥ, ᨸᩁᩥᨸᩩᨱ᩠ᨱᩣᨶᩥ ᩈᨻ᩠ᨻᩈᩮᩣ;

ᨲᩮ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩᩔᩩ, ᩁᨩ᩠ᨩᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩣᨾᩥ ᨲᩮ.

᪔᪒.

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨠᩮᩣ ᨩᨬ᩠ᨬᩣ ᨾᩁᨱᩴ ᩈᩩᩅᩮ;

ᨾᩣᩉᩴ ᨠᩣᨠᩮᩣᩅ ᨴᩩᨾ᩠ᨾᩮᨵᩮᩣ, ᨠᩣᨾᩣᨶᩴ ᩅᩈᨾᨶ᩠ᩅᨣᩴ [ᩅᩈᨾᨶ᩠ᨶᨣᩣ (ᨸᩦ.)].

᪔᪓.

‘‘ᩈᨭ᩠ᨮᩥ ᨶᩣᨣᩈᩉᩔᩣᨶᩥ, ᩈᨻ᩠ᨻᩣᩃᨦ᩠ᨠᩣᩁᨽᩪᩈᩥᨲᩣ;

ᩈᩩᩅᨱ᩠ᨱᨠᨧ᩠ᨨᩣ ᨾᩣᨲᨦ᩠ᨣᩣ, ᩉᩮᨾᨠᨸ᩠ᨸᨶᩅᩣᩈᩈᩣ.

᪔᪔.

‘‘ᩌᩁᩪᩊ᩠ᩉᩣ ¶ ᨣᩣᨾᨱᩦᨿᩮᩉᩥ, ᨲᩮᩣᨾᩁᨦ᩠ᨠᩩᩈᨸᩣᨱᩥᨽᩥ;

ᨲᩮ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩᩔᩩ, ᩁᨩ᩠ᨩᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩣᨾᩥ ᨲᩮ.

᪔᪕.

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨠᩮᩣ ᨩᨬ᩠ᨬᩣ ᨾᩁᨱᩴ ᩈᩩᩅᩮ;

ᨾᩣᩉᩴ ᨠᩣᨠᩮᩣᩅ ᨴᩩᨾ᩠ᨾᩮᨵᩮᩣ, ᨠᩣᨾᩣᨶᩴ ᩅᩈᨾᨶ᩠ᩅᨣᩴ.

᪔᪖.

‘‘ᩈᨭ᩠ᨮᩥ ¶ ᩋᩔᩈᩉᩔᩣᨶᩥ, ᩈᨻ᩠ᨻᩣᩃᨦ᩠ᨠᩣᩁᨽᩪᩈᩥᨲᩣ;

ᩌᨩᩣᨶᩦᨿᩣᩅ ᨩᩣᨲᩥᨿᩣ, ᩈᩥᨶ᩠ᨵᩅᩣ ᩈᩦᨥᩅᩣᩉᩥᨶᩮᩣ.

᪔᪗.

‘‘ᩌᩁᩪᩊ᩠ᩉᩣ ᨣᩣᨾᨱᩦᨿᩮᩉᩥ, ᩍᩃ᩠ᩃᩥᨿᩣᨧᩣᨸᨵᩣᩁᩥᨽᩥ [ᩍᨶ᩠ᨴᩥᨿᩣᨧᩣᨸᨵᩣᩁᩥᨽᩥ (ᨠ.)];

ᨲᩮ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩᩔᩩ, ᩁᨩ᩠ᨩᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩣᨾᩥ ᨲᩮ.

᪔᪘.

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨠᩮᩣ ᨩᨬ᩠ᨬᩣ ᨾᩁᨱᩴ ᩈᩩᩅᩮ;

ᨾᩣᩉᩴ ᨠᩣᨠᩮᩣᩅ ᨴᩩᨾ᩠ᨾᩮᨵᩮᩣ, ᨠᩣᨾᩣᨶᩴ ᩅᩈᨾᨶ᩠ᩅᨣᩴ.

᪔᪙.

‘‘ᩈᨭ᩠ᨮᩥ ᩁᨳᩈᩉᩔᩣᨶᩥ, ᩈᨶ᩠ᨶᨴ᩠ᨵᩣ ᩏᩔᩥᨲᨴ᩠ᨵᨩᩣ;

ᨴᩦᨸᩣ ᩋᨳᩮᩣᨸᩥ ᩅᩮᨿ᩠ᨿᨣ᩠ᨥᩣ, ᩈᨻ᩠ᨻᩣᩃᨦ᩠ᨠᩣᩁᨽᩪᩈᩥᨲᩣ.

᪕᪐.

‘‘ᩌᩁᩪᩊ᩠ᩉᩣ ᨣᩣᨾᨱᩦᨿᩮᩉᩥ, ᨧᩣᨸᩉᨲ᩠ᨳᩮᩉᩥ ᩅᨾ᩠ᨾᩥᨽᩥ;

ᨲᩮ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩᩔᩩ, ᩁᨩ᩠ᨩᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩣᨾᩥ ᨲᩮ.

᪕᪑.

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨠᩮᩣ ᨩᨬ᩠ᨬᩣ ᨾᩁᨱᩴ ᩈᩩᩅᩮ;

ᨾᩣᩉᩴ ᨠᩣᨠᩮᩣᩅ ᨴᩩᨾ᩠ᨾᩮᨵᩮᩣ, ᨠᩣᨾᩣᨶᩴ ᩅᩈᨾᨶ᩠ᩅᨣᩴ.

᪕᪒.

‘‘ᩈᨭ᩠ᨮᩥ ᨵᩮᨶᩩᩈᩉᩔᩣᨶᩥ, ᩁᩮᩣᩉᨬ᩠ᨬᩣ ᨸᩩᨦ᩠ᨣᩅᩪᩈᨽᩣ;

ᨲᩣ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩᩔᩩ, ᩁᨩ᩠ᨩᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩣᨾᩥ ᨲᩮ.

᪕᪓.

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨠᩮᩣ ᨩᨬ᩠ᨬᩣ ᨾᩁᨱᩴ ᩈᩩᩅᩮ;

ᨾᩣᩉᩴ ᨠᩣᨠᩮᩣᩅ ᨴᩩᨾ᩠ᨾᩮᨵᩮᩣ, ᨠᩣᨾᩣᨶᩴ ᩅᩈᨾᨶ᩠ᩅᨣᩴ.

᪕᪔.

‘‘ᩈᩮᩣᩊᩈᩥᨲ᩠ᨳᩥᩈᩉᩔᩣᨶᩥ ¶ , ᩈᨻ᩠ᨻᩣᩃᨦ᩠ᨠᩣᩁᨽᩪᩈᩥᨲᩣ;

ᩅᩥᨧᩥᨲᩕᩅᨲ᩠ᨳᩣᨽᩁᨱᩣ, ᩌᨾᩩᨲ᩠ᨲᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᩣ;

ᨲᩣ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩᩔᩩ, ᩁᨩ᩠ᨩᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩣᨾᩥ ᨲᩮ.

᪕᪕.

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨠᩮᩣ ᨩᨬ᩠ᨬᩣ ᨾᩁᨱᩴ ᩈᩩᩅᩮ;

ᨾᩣᩉᩴ ¶ ᨠᩣᨠᩮᩣᩅ ᨴᩩᨾ᩠ᨾᩮᨵᩮᩣ, ᨠᩣᨾᩣᨶᩴ ᩅᩈᨾᨶ᩠ᩅᨣᩴ’’.

᪕᪖.

‘‘ᨴᩉᩁᩔᩮᩅ ¶ ᨾᩮ ᨲᩣᨲ, ᨾᩣᨲᩣ ᨾᨲᩣᨲᩥ ᨾᩮ ᩈᩩᨲᩴ;

ᨲᨿᩣ ᩅᩥᨶᩣ ᩋᩉᩴ ᨲᩣᨲ, ᨩᩦᩅᩥᨲᩩᨾ᩠ᨸᩥ ᨶ ᩏᩔᩉᩮ.

᪕᪗.

‘‘ᨿᨳᩣ ᩌᩁᨬ᩠ᨬᨠᩴ ᨶᩣᨣᩴ, ᨸᩮᩣᨲᩮᩣ ᩋᨶ᩠ᩅᩮᨲᩥ ᨸᨧ᩠ᨨᨲᩮᩣ;

ᨩᩮᩔᨶ᩠ᨲᩴ ᨣᩥᩁᩥᨴᩩᨣ᩠ᨣᩮᩈᩩ, ᩈᨾᩮᩈᩩ ᩅᩥᩈᨾᩮᩈᩩ ᨧ.

᪕᪘.

‘‘ᩑᩅᩴ ᨲᩴ ᩋᨶᩩᨣᨧ᩠ᨨᩣᨾᩥ, ᨸᩩᨲ᩠ᨲᨾᩣᨴᩣᨿ [ᨸᨲ᩠ᨲᨾᩣᨴᩣᨿ (ᨸᩦ.)] ᨸᨧ᩠ᨨᨲᩮᩣ;

ᩈᩩᨽᩁᩮᩣ ᨲᩮ ᨽᩅᩥᩔᩣᨾᩥ, ᨶ ᨲᩮ ᩉᩮᩔᩣᨾᩥ ᨴᩩᨻ᩠ᨽᩁᩮᩣ’’.

᪕᪙.

‘‘ᨿᨳᩣ ᩈᩣᨾᩩᨴ᩠ᨴᩥᨠᩴ ᨶᩣᩅᩴ, ᩅᩣᨱᩥᨩᩣᨶᩴ ᨵᨶᩮᩈᩥᨶᩴ;

ᩅᩮᩣᩉᩣᩁᩮᩣ ᨲᨲ᩠ᨳ ᨣᨱ᩠ᩉᩮᨿ᩠ᨿ, ᩅᩣᨱᩥᨩᩣ ᨻ᩠ᨿᩈᨶᩦ [ᨻ᩠ᨿᩈᨶᩴ (ᨠ.)] ᩈᩥᨿᩣ.

᪖᪐.

‘‘ᩑᩅᨾᩮᩅᩣᨿᩴ ᨸᩩᨲ᩠ᨲᨠᩃᩥ [ᨸᩩᨲ᩠ᨲᨠ (ᩈ᩠ᨿᩣ.)], ᩋᨶ᩠ᨲᩁᩣᨿᨠᩁᩮᩣ ᨾᨾ [ᨾᨾᩴ (ᨸᩦ.)];

ᩍᨾᩴ ᨠᩩᨾᩣᩁᩴ ᨸᩣᨸᩮᨳ, ᨸᩣᩈᩣᨴᩴ ᩁᨲᩥᩅᨯ᩠ᨰᨶᩴ.

᪖᪑.

‘‘ᨲᨲ᩠ᨳ ᨠᨾ᩠ᨻᩩᩈᩉᨲ᩠ᨳᩣᨿᩮᩣ, ᨿᨳᩣ ᩈᨠ᩠ᨠᩴᩅ ᩋᨧ᩠ᨨᩁᩣ;

ᨲᩣ ᨶᩴ ᨲᨲ᩠ᨳ ᩁᨾᩮᩔᨶ᩠ᨲᩥ [ᩁᨾᩥᩔᨶ᩠ᨲᩥ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨲᩣᩉᩥ ᨧᩮᩈᩮᩣ [ᨾᩮᩈᩮᩣ (ᨸᩦ.)] ᩁᨾᩥᩔᨲᩥ.

᪖᪒.

‘‘ᨲᨲᩮᩣ ᨠᩩᨾᩣᩁᩴ ᨸᩣᨸᩮᩈᩩᩴ, ᨸᩣᩈᩣᨴᩴ ᩁᨲᩥᩅᨯ᩠ᨰᨶᩴ;

ᨲᩴ ᨴᩥᩈ᩠ᩅᩣ ᩋᩅᨧᩩᩴ ᨠᨬ᩠ᨬᩣ, ᨴᩦᨥᩣᩅᩩᩴ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶᩴ.

᪖᪓.

‘‘ᨴᩮᩅᨲᩣ ᨶᩩᩈᩥ ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ, ᩋᨴᩩ [ᩌᨴᩩ (ᩈᩦ. ᨸᩦ.)] ᩈᨠ᩠ᨠᩮᩣ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ;

ᨠᩮᩣ ᩅᩣ ᨲ᩠ᩅᩴ ᨠᩔ ᩅᩣ ᨸᩩᨲ᩠ᨲᩮᩣ, ᨠᨳᩴ ᨩᩣᨶᩮᨾᩩ ᨲᩴ ᨾᨿᩴ’’.

᪖᪔.

‘‘ᨶᨾ᩠ᩉᩥ ᨴᩮᩅᩮᩣ ᨶ ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ, ᨶᩣᨸᩥ [ᨶᨾ᩠ᩉᩥ (ᨠ.)] ᩈᨠ᩠ᨠᩮᩣ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ;

ᨠᩣᩈᩥᩁᨬ᩠ᨬᩮᩣ ᩋᩉᩴ ᨸᩩᨲ᩠ᨲᩮᩣ, ᨴᩦᨥᩣᩅᩩ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶᩮᩣ;

ᨾᨾᩴ [ᨾᨾ (ᨸᩦ.)] ᨽᩁᨳ ᨽᨴ᩠ᨴᩴ ᩅᩮᩣ [ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ (ᨠ.)], ᩋᩉᩴ ᨽᨲ᩠ᨲᩣ ᨽᩅᩣᨾᩥ ᩅᩮᩣ’’.

᪖᪕.

‘‘ᨲᩴ ¶ ᨲᨲ᩠ᨳ ᩋᩅᨧᩩᩴ ᨠᨬ᩠ᨬᩣ, ᨴᩦᨥᩣᩅᩩᩴ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶᩴ;

‘ᨠᩩᩉᩥᩴ ᩁᩣᨩᩣ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᩍᨲᩮᩣ ᩁᩣᨩᩣ ᨠᩩᩉᩥᩴ ᨣᨲᩮᩣ’’’.

᪖᪖.

‘‘ᨸᨦ᩠ᨠᩴ ᩁᩣᨩᩣ ᩋᨲᩥᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᨳᩃᩮ ᩁᩣᨩᩣ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩮᩣ;

ᩋᨠᨱ᩠ᨭᨠᩴ ᩋᨣᩉᨶᩴ, ᨸᨭᩥᨸᨶ᩠ᨶᩮᩣ ᨾᩉᩣᨸᨳᩴ.

᪖᪗.

‘‘ᩋᩉᨬ᩠ᨧ ᨸᨭᩥᨸᨶ᩠ᨶᩮᩣᩈ᩠ᨾᩥ, ᨾᨣ᩠ᨣᩴ ᨴᩩᨣ᩠ᨣᨲᩥᨣᩣᨾᩥᨶᩴ;

ᩈᨠᨱ᩠ᨭᨠᩴ ᩈᨣᩉᨶᩴ, ᨿᩮᨶ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ ᨴᩩᨣ᩠ᨣᨲᩥᩴ’’.

᪖᪘.

‘‘ᨲᩔ ¶ ¶ ᨲᩮ ᩈ᩠ᩅᩣᨣᨲᩴ ᩁᩣᨩ, ᩈᩦᩉᩔᩮᩅ ᨣᩥᩁᩥᨻ᩠ᨻᨩᩴ;

ᩋᨶᩩᩈᩣᩈ ᨾᩉᩣᩁᩣᨩ, ᨲ᩠ᩅᩴ ᨶᩮᩣ ᩈᨻ᩠ᨻᩣᩈᨾᩥᩔᩁᩮᩣ’’ᨲᩥ.

ᩈᩮᩣᨱᨠᨩᩣᨲᨠᩴ ᨸᨮᨾᩴ.

᪕᪓᪐. ᩈᩴᨠᩥᨧ᩠ᨧᨩᩣᨲᨠᩴ (᪒)

᪖᪙.

‘‘ᨴᩥᩈ᩠ᩅᩣ ᨶᩥᩈᩥᨶ᩠ᨶᩴ ᩁᩣᨩᩣᨶᩴ, ᨻᩕᩉ᩠ᨾᨴᨲ᩠ᨲᩴ ᩁᨳᩮᩈᨽᩴ;

ᩋᨳᩔ ᨸᨭᩥᩅᩮᨴᩮᩈᩥ, ᨿᩔᩣᩈᩥ ᩋᨶᩩᨠᨾ᩠ᨸᨠᩮᩣ.

᪗᪐.

‘‘ᩈᩴᨠᩥᨧ᩠ᨧᩣᨿᩴ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᩍᩈᩦᨶᩴ ᩈᩣᨵᩩᩈᨾ᩠ᨾᨲᩮᩣ;

ᨲᩁᨾᩣᨶᩁᩪᨸᩮᩣ ᨶᩥᨿ᩠ᨿᩣᩉᩥ, ᨡᩥᨸ᩠ᨸᩴ ᨸᩔ ᨾᩉᩮᩈᩥᨶᩴ.

᪗᪑.

‘‘ᨲᨲᩮᩣ ᨧ ᩁᩣᨩᩣ ᨲᩁᨾᩣᨶᩮᩣ, ᨿᩩᨲ᩠ᨲᨾᩣᩁᩩᨿ᩠ᩉ ᩈᨶ᩠ᨴᨶᩴ;

ᨾᩥᨲ᩠ᨲᩣᨾᨧ᩠ᨧᨸᩁᩥᨻ᩠ᨿᩪᩊ᩠ᩉᩮᩣ [ᨸᩁᩥᨻ᩠ᨻᩪᩊ᩠ᩉᩮᩣ (ᩈᩦ. ᨸᩦ.)], ᩋᨣᨾᩣᩈᩥ ᩁᨳᩮᩈᨽᩮᩣ.

᪗᪒.

‘‘ᨶᩥᨠ᩠ᨡᩥᨸ᩠ᨸ ᨸᨬ᩠ᨧ ᨠᨠᩩᨵᩣᨶᩥ, ᨠᩣᩈᩦᨶᩴ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶᩮᩣ;

ᩅᩣᩊᨻᩦᨩᨶᩥ [ᩅᩣ ᩊᩅᩦᨩᨶᩦ (ᩈᩦ. ᨸᩦ.)] ᨾᩩᨱ᩠ᩉᩦᩈᩴ, ᨡᨣ᩠ᨣᩴ ᨨᨲ᩠ᨲᨬ᩠ᨧᩩᨸᩣᩉᨶᩴ;

᪗᪓.

‘‘ᩒᩁᩩᨿ᩠ᩉ ᩁᩣᨩᩣ ᨿᩣᨶᨾ᩠ᩉᩣ, ᨮᨸᨿᩥᨲ᩠ᩅᩣ ᨸᨭᩥᨧ᩠ᨨᨴᩴ;

ᩌᩈᩦᨶᩴ ¶ ᨴᩣᨿᨸᩔᩈ᩠ᨾᩥᩴ, ᩈᩴᨠᩥᨧ᩠ᨧᨾᩩᨸᩈᨦ᩠ᨠᨾᩥ.

᪗᪔.

‘‘ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᩈᩮᩣ ᩁᩣᨩᩣ, ᩈᨾ᩠ᨾᩮᩣᨴᩥ ᩍᩈᩥᨶᩣ ᩈᩉ;

ᨲᩴ ᨠᨳᩴ ᩅᩦᨲᩥᩈᩣᩁᩮᨲ᩠ᩅᩣ, ᩑᨠᨾᨶ᩠ᨲᩴ ᩏᨸᩣᩅᩥᩈᩥ.

᪗᪕.

‘‘ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣᩅ, ᩋᨳ ᨠᩣᩃᩴ ᩋᨾᨬ᩠ᨬᨳ;

ᨲᨲᩮᩣ ᨸᩣᨸᩣᨶᩥ ᨠᨾ᩠ᨾᩣᨶᩥ, ᨸᩩᨧ᩠ᨨᩥᨲᩩᩴ ᨸᨭᩥᨸᨩ᩠ᨩᨳ.

᪗᪖.

‘‘ᩍᩈᩥᩴ ᨸᩩᨧ᩠ᨨᩣᨾ [ᨸᩩᨧ᩠ᨨᩣᨾᩥ (ᩈᩦ. ᨸᩦ.)] ᩈᩴᨠᩥᨧ᩠ᨧᩴ, ᩍᩈᩦᨶᩴ ᩈᩣᨵᩩᩈᨾ᩠ᨾᨲᩴ;

ᩌᩈᩦᨶᩴ ᨴᩣᨿᨸᩔᩈ᩠ᨾᩥᩴ, ᩍᩈᩥᩈᨦ᩠ᨥᨸᩩᩁᨠ᩠ᨡᨲᩴ [ᨸᩩᩁᨠ᩠ᨡᩥᨲᩴ (ᨠ.)].

᪗᪗.

‘‘ᨠᩴ ᨣᨲᩥᩴ ᨸᩮᨧ᩠ᨧ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨶᩁᩣ ᨵᨾ᩠ᨾᩣᨲᩥᨧᩣᩁᩥᨶᩮᩣ;

ᩋᨲᩥᨧᩥᨱ᩠ᨱᩮᩣ ᨾᨿᩣ ᨵᨾ᩠ᨾᩮᩣ, ᨲᩴ ᨾᩮ ᩋᨠ᩠ᨡᩣᩉᩥ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ.

᪗᪘.

‘‘ᩍᩈᩦ ᩋᩅᨧ ᩈᩴᨠᩥᨧ᩠ᨧᩮᩣ, ᨠᩣᩈᩦᨶᩴ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶᩴ;

ᩌᩈᩦᨶᩴ ᨴᩣᨿᨸᩔᩈ᩠ᨾᩥᩴ, ᨾᩉᩣᩁᩣᨩ ᩈᩩᨱᩮᩣᩉᩥ ᨾᩮ.

᪗᪙.

‘‘ᩏᨸ᩠ᨸᨳᩮᨶ ¶ ᩅᨩᨶ᩠ᨲᩔ, ᨿᩮᩣ ᨾᨣ᩠ᨣᨾᨶᩩᩈᩣᩈᨲᩥ;

ᨲᩔ ᨧᩮ ᩅᨧᨶᩴ ᨠᨿᩥᩁᩣ, ᨶᩣᩔ ᨾᨣ᩠ᨣᩮᨿ᩠ᨿ ᨠᨱ᩠ᨭᨠᩮᩣ.

᪘᪐.

‘‘ᩋᨵᨾ᩠ᨾᩴ ¶ ᨸᨭᩥᨸᨶ᩠ᨶᩔ, ᨿᩮᩣ ᨵᨾ᩠ᨾᨾᨶᩩᩈᩣᩈᨲᩥ;

ᨲᩔ ᨧᩮ ᩅᨧᨶᩴ ᨠᨿᩥᩁᩣ, ᨶ ᩈᩮᩣ ᨣᨧ᩠ᨨᩮᨿ᩠ᨿ ᨴᩩᨣ᩠ᨣᨲᩥᩴ.

᪘᪑.

‘‘ᨵᨾ᩠ᨾᩮᩣ ᨸᨳᩮᩣ ᨾᩉᩣᩁᩣᨩ, ᩋᨵᨾ᩠ᨾᩮᩣ ᨸᨶ ᩏᨸ᩠ᨸᨳᩮᩣ;

ᩋᨵᨾ᩠ᨾᩮᩣ ᨶᩥᩁᨿᩴ ᨶᩮᨲᩥ, ᨵᨾ᩠ᨾᩮᩣ ᨸᩣᨸᩮᨲᩥ ᩈᩩᨣ᩠ᨣᨲᩥᩴ.

᪘᪒.

‘‘ᩋᨵᨾ᩠ᨾᨧᩣᩁᩥᨶᩮᩣ ᩁᩣᨩ, ᨶᩁᩣ ᩅᩥᩈᨾᨩᩦᩅᩥᨶᩮᩣ;

ᨿᩴ ᨣᨲᩥᩴ ᨸᩮᨧ᩠ᨧ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨶᩥᩁᨿᩮ ᨲᩮ ᩈᩩᨱᩮᩣᩉᩥ ᨾᩮ.

᪘᪓.

‘‘ᩈᨬ᩠ᨩᩦᩅᩮᩣ ᨠᩣᩊᩈᩩᨲ᩠ᨲᩮᩣ ᨧ, ᩈᨦ᩠ᨥᩣᨲᩮᩣ [ᩈᨦ᩠ᨡᩣᨭᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨴ᩠ᩅᩮ ᨧ ᩁᩮᩣᩁᩩᩅᩣ;

ᩋᨳᩣᨸᩁᩮᩣ ¶ ᨾᩉᩣᩅᩦᨧᩥ, ᨲᩣᨸᨶᩮᩣ [ᨲᨸᨶᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᨧ ᨸᨲᩣᨸᨶᩮᩣ.

᪘᪔.

‘‘ᩍᨧ᩠ᨧᩮᨲᩮ ᩋᨭ᩠ᨮ ᨶᩥᩁᨿᩣ, ᩋᨠ᩠ᨡᩣᨲᩣ ᨴᩩᩁᨲᩥᨠ᩠ᨠᨾᩣ;

ᩌᨠᩥᨱ᩠ᨱᩣ ᩃᩩᨴ᩠ᨴᨠᨾ᩠ᨾᩮᩉᩥ, ᨸᨧ᩠ᨧᩮᨠᩣ ᩈᩮᩣᩊᩈᩩᩔᨴᩣ.

᪘᪕.

‘‘ᨠᨴᩁᩥᨿᨲᩣᨸᨶᩣ [ᨠᨴᩁᩥᨿᨲᨸᨶᩣ (ᩈᩦ. ᨸᩦ.)] ᨥᩮᩣᩁᩣ, ᩋᨧ᩠ᨧᩥᨾᨶ᩠ᨲᩮᩣ [ᩋᨧ᩠ᨧᩥᨾᨶ᩠ᨲᩣ (ᨸᩦ.)] ᨾᩉᨻ᩠ᨽᨿᩣ;

ᩃᩮᩣᨾᩉᩴᩈᨶᩁᩪᨸᩣ ᨧ, ᨽᩮᩈ᩠ᨾᩣ ᨸᨭᩥᨽᨿᩣ ᨴᩩᨡᩣ.

᪘᪖.

‘‘ᨧᨲᩩᨠ᩠ᨠᨱ᩠ᨱᩣ ᨧᨲᩩᨴ᩠ᩅᩣᩁᩣ, ᩅᩥᨽᨲ᩠ᨲᩣ ᨽᩣᨣᩈᩮᩣ ᨾᩥᨲᩣ;

ᩋᨿᩮᩣᨸᩣᨠᩣᩁᨸᩁᩥᨿᨶ᩠ᨲᩣ, ᩋᨿᩈᩣ ᨸᨭᩥᨠᩩᨩ᩠ᨩᩥᨲᩣ.

᪘᪗.

‘‘ᨲᩮᩈᩴ ᩋᨿᩮᩣᨾᨿᩣ ᨽᩪᨾᩥ, ᨩᩃᩥᨲᩣ ᨲᩮᨩᩈᩣ ᨿᩩᨲᩣ;

ᩈᨾᨶ᩠ᨲᩣ ᨿᩮᩣᨩᨶᩈᨲᩴ, ᨹᩩᨭᩣ [ᨹᩁᩥᨲ᩠ᩅᩣ (ᩋ. ᨶᩥ. ᪓.᪓᪖; ᨸᩮ. ᩅ. ᪗᪑)] ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᩈᨻ᩠ᨻᨴᩣ.

᪘᪘.

‘‘ᩑᨲᩮ ᨸᨲᨶ᩠ᨲᩥ ᨶᩥᩁᨿᩮ, ᩏᨴ᩠ᨵᩴᨸᩣᨴᩣ ᩋᩅᩴᩈᩥᩁᩣ;

ᩍᩈᩦᨶᩴ ᩋᨲᩥᩅᨲ᩠ᨲᩣᩁᩮᩣ, ᩈᨬ᩠ᨬᨲᩣᨶᩴ ᨲᨸᩔᩥᨶᩴ.

᪘᪙.

‘‘ᨲᩮ ᨽᩪᨶᩉᩩᨶᩮᩣ ᨸᨧ᩠ᨧᨶ᩠ᨲᩥ, ᨾᨧ᩠ᨨᩣ ᨻᩥᩃᨠᨲᩣ ᨿᨳᩣ;

ᩈᩴᩅᨧ᩠ᨨᩁᩮ ᩋᩈᨦ᩠ᨡᩮᨿ᩠ᨿᩮ, ᨶᩁᩣ ᨠᩥᨻ᩠ᨻᩥᩈᨠᩣᩁᩥᨶᩮᩣ.

᪙᪐.

‘‘ᨯᨿ᩠ᩉᨾᩣᨶᩮᨶ ᨣᨲ᩠ᨲᩮᨶ, ᨶᩥᨧ᩠ᨧᩴ ᩈᨶ᩠ᨲᩁᨻᩣᩉᩥᩁᩴ;

ᨶᩥᩁᨿᩣ ᨶᩣᨵᩥᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨴ᩠ᩅᩣᩁᩴ ᨶᩥᨠ᩠ᨡᨾᨶᩮᩈᩥᨶᩮᩣ.

᪙᪑.

‘‘ᨸᩩᩁᨲ᩠ᨳᩥᨾᩮᨶ ¶ ᨵᩣᩅᨶ᩠ᨲᩥ, ᨲᨲᩮᩣ ᨵᩣᩅᨶ᩠ᨲᩥ ᨸᨧ᩠ᨨᨲᩮᩣ;

ᩏᨲ᩠ᨲᩁᩮᨶᨸᩥ ᨵᩣᩅᨶ᩠ᨲᩥ, ᨲᨲᩮᩣ ᨵᩣᩅᨶ᩠ᨲᩥ ᨴᨠ᩠ᨡᩥᨱᩴ;

ᨿᩴ ᨿᨬ᩠ᩉᩥ ᨴ᩠ᩅᩣᩁᩴ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨲᩴ ᨲᨴᩮᩅ ᨸᩥᨵᩦᨿᩁᩮ [ᨸᩥᨳᩥᨿ᩠ᨿᨲᩥ (ᩈᩦ.), ᨸᩥᨳᩥᨿ᩠ᨿᩁᩮ (ᩈ᩠ᨿᩣ.), ᨸᩥᨳᩦᨿᩁᩮ (ᨸᩦ.)].

᪙᪒.

‘‘ᨻᩉᩪᨶᩥ ᩅᩔᩈᩉᩔᩣᨶᩥ, ᨩᨶᩣ ᨶᩥᩁᨿᨣᩣᨾᩥᨶᩮᩣ;

ᨻᩣᩉᩣ ᨸᨣ᩠ᨣᨿ᩠ᩉ ᨠᨶ᩠ᨴᨶ᩠ᨲᩥ, ᨸᨲ᩠ᩅᩣ ᨴᩩᨠ᩠ᨡᩴ ᩋᨶᨸ᩠ᨸᨠᩴ.

᪙᪓.

‘‘ᩌᩈᩦᩅᩥᩈᩴᩅ ¶ ᨠᩩᨸᩥᨲᩴ, ᨲᩮᨩᩔᩥᩴ ᨴᩩᩁᨲᩥᨠ᩠ᨠᨾᩴ;

ᨶ ᩈᩣᨵᩩᩁᩪᨸᩮ ᩌᩈᩦᨴᩮ, ᩈᨬ᩠ᨬᨲᩣᨶᩴ ᨲᨸᩔᩥᨶᩴ.

᪙᪔.

‘‘ᩋᨲᩥᨠᩣᨿᩮᩣ ¶ ᨾᩉᩥᩔᩣᩈᩮᩣ, ᩋᨩ᩠ᨩᩩᨶᩮᩣ ᨠᩮᨠᨠᩣᨵᩥᨸᩮᩣ;

ᩈᩉᩔᨻᩣᩉᩩ ᩏᨧ᩠ᨨᩥᨶ᩠ᨶᩮᩣ, ᩍᩈᩥᨾᩣᩈᨩ᩠ᨩ ᨣᩮᩣᨲᨾᩴ.

᪙᪕.

‘‘ᩋᩁᨩᩴ ᩁᨩᩈᩣ ᩅᨧ᩠ᨨᩴ, ᨠᩥᩈᩴ ᩋᩅᨠᩥᩁᩥᨿ ᨴᨱ᩠ᨯᨠᩦ;

ᨲᩣᩃᩮᩣᩅ ᨾᩪᩃᨲᩮᩣ [ᩈᨾᩪᩃᩮᩣ (ᨠ.)] ᨨᩥᨶ᩠ᨶᩮᩣ, ᩈ ᩁᩣᨩᩣ ᩅᩥᨽᩅᨦ᩠ᨣᨲᩮᩣ.

᪙᪖.

‘‘ᩏᨸᩉᨧ᩠ᨧ ᨾᨶᩴ ᨾᨩ᩠ᨫᩮᩣ [ᨾᩮᨩ᩠ᨫᩮᩣ (ᨠ.)], ᨾᩣᨲᨦ᩠ᨣᩈ᩠ᨾᩥᩴ ᨿᩈᩔᩥᨶᩮ;

ᩈᨸᩣᩁᩥᩈᨩ᩠ᨩᩮᩣ ᩏᨧ᩠ᨨᩥᨶ᩠ᨶᩮᩣ, ᨾᨩ᩠ᨫᩣᩁᨬ᩠ᨬᩴ ᨲᨴᩣ ᩋᩉᩩ.

᪙᪗.

‘‘ᨠᨱ᩠ᩉᨴᩦᨸᩣᨿᨶᩣᩈᨩ᩠ᨩ, ᩍᩈᩥᩴ ᩋᨶ᩠ᨵᨠᩅᩮᨱ᩠ᨯᨿᩮᩣ [ᩅᩮᨱ᩠ᩉᩩᨿᩮᩣ (ᩈᩦ. ᨸᩦ.), ᨸᩥᨱ᩠ᩉᨿᩮᩣ (?)];

ᩋᨬ᩠ᨬᩮᩣᨬ᩠ᨬᩴ [ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩴ (ᩈᩦ. ᨸᩦ.)] ᨾᩩᩈᩃᩣ [ᨾᩩᩈᩃᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩉᨶ᩠ᨲ᩠ᩅᩣ, ᩈᨾ᩠ᨸᨲ᩠ᨲᩣ ᨿᨾᩈᩣᨵᨶᩴ [ᨿᨾᩈᩣᨴᨶᩴ (ᨸᩦ.)].

᪙᪘.

‘‘ᩋᨳᩣᨿᩴ ᩍᩈᩥᨶᩣ ᩈᨲ᩠ᨲᩮᩣ, ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᨧᩁᩮᩣ ᨸᩩᩁᩮ;

ᨸᩣᩅᩮᨠ᩠ᨡᩥ ᨸᨳᩅᩥᩴ [ᨸᨮᩅᩥᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨧᩮᨧ᩠ᨧᩮᩣ, ᩉᩦᨶᨲ᩠ᨲᩮᩣ ᨸᨲ᩠ᨲᨸᩁᩥᨿᩣᨿᩴ.

᪙᪙.

‘‘ᨲᩈ᩠ᨾᩣ ᩉᩥ ᨨᨶ᩠ᨴᩣᨣᨾᨶᩴ, ᨶᨸ᩠ᨸᩈᩴᩈᨶ᩠ᨲᩥ ᨸᨱ᩠ᨯᩥᨲᩣ;

ᩋᨴᩩᨭ᩠ᨮᨧᩥᨲ᩠ᨲᩮᩣ ᨽᩣᩈᩮᨿ᩠ᨿ, ᨣᩥᩁᩴ ᩈᨧ᩠ᨧᩪᨸᩈᩴᩉᩥᨲᩴ.

᪑᪐᪐.

‘‘ᨾᨶᩈᩣ ᨧᩮ ᨸᨴᩩᨭ᩠ᨮᩮᨶ, ᨿᩮᩣ ᨶᩁᩮᩣ ᨸᩮᨠ᩠ᨡᨲᩮ ᨾᩩᨶᩥᩴ;

ᩅᩥᨩ᩠ᨩᩣᨧᩁᨱᩈᨾ᩠ᨸᨶ᩠ᨶᩴ, ᨣᨶ᩠ᨲᩣ ᩈᩮᩣ ᨶᩥᩁᨿᩴ ᩋᨵᩮᩣ.

᪑᪐᪑.

‘‘ᨿᩮ ᩅᩩᨯ᩠ᨰᩮ [ᩅᨴ᩠ᨵᩮ (ᨠ.)] ᨸᩁᩥᨽᩣᩈᨶ᩠ᨲᩥ, ᨹᩁᩩᩈᩪᨸᨠ᩠ᨠᨾᩣ ᨩᨶᩣ;

ᩋᨶᨸᨧ᩠ᨧᩣ ᩋᨴᩣᨿᩣᨴᩣ, ᨲᩣᩃᩅᨲ᩠ᨳᩩ [ᨲᩣᩃᩅᨲ᩠ᨳᩪ (ᩈ᩠ᨿᩣ.), ᨲᩣᩃᩣᩅᨲ᩠ᨳᩩ (ᨸᩦ.)] ᨽᩅᨶ᩠ᨲᩥ ᨲᩮ.

᪑᪐᪒.

‘‘ᨿᩮᩣ ¶ ᨧ ᨸᨻ᩠ᨻᨩᩥᨲᩴ ᩉᨶ᩠ᨲᩥ, ᨠᨲᨠᩥᨧ᩠ᨧᩴ ᨾᩉᩮᩈᩥᨶᩴ;

ᩈ ᨠᩣᩊᩈᩩᨲ᩠ᨲᩮ ᨶᩥᩁᨿᩮ, ᨧᩥᩁᩁᨲ᩠ᨲᩣᨿ ᨸᨧ᩠ᨧᨲᩥ.

᪑᪐᪓.

‘‘ᨿᩮᩣ ¶ ᨧ ᩁᩣᨩᩣ ᩋᨵᨾ᩠ᨾᨭ᩠ᨮᩮᩣ, ᩁᨭ᩠ᨮᩅᩥᨴ᩠ᨵᩴᩈᨶᩮᩣ ᨾᨣᩮᩣ [ᨧᩩᨲᩮᩣ (ᩈᩦ.)];

ᨲᩣᨸᨿᩥᨲ᩠ᩅᩣ ᨩᨶᨸᨴᩴ, ᨲᩣᨸᨶᩮ ᨸᩮᨧ᩠ᨧ ᨸᨧ᩠ᨧᨲᩥ.

᪑᪐᪔.

‘‘ᩈᩮᩣ ᨧ ᩅᩔᩈᩉᩔᩣᨶᩥ [ᩅᩔᩈᩉᩔᩣᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᩈᨲᩴ ᨴᩥᨻ᩠ᨻᩣᨶᩥ ᨸᨧ᩠ᨧᨲᩥ;

ᩋᨧ᩠ᨧᩥᩈᨦ᩠ᨥᨸᩁᩮᨲᩮᩣ ᩈᩮᩣ, ᨴᩩᨠ᩠ᨡᩴ ᩅᩮᨴᩮᨲᩥ ᩅᩮᨴᨶᩴ.

᪑᪐᪕.

‘‘ᨲᩔ ᩋᨣ᩠ᨣᩥᩈᩥᨡᩣ ᨠᩣᨿᩣ, ᨶᩥᨧ᩠ᨨᩁᨶ᩠ᨲᩥ ᨸᨽᩔᩁᩣ;

ᨲᩮᨩᩮᩣᨽᨠ᩠ᨡᩔ ᨣᨲ᩠ᨲᩣᨶᩥ, ᩃᩮᩣᨾᩮᩉᩥ ᨧ [ᩃᩮᩣᨾᨣ᩠ᨣᩮᩉᩥ ᨧ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨶᨡᩮᩉᩥ ᨧ.

᪑᪐᪖.

‘‘ᨯᨿ᩠ᩉᨾᩣᨶᩮᨶ ᨣᨲ᩠ᨲᩮᨶ, ᨶᩥᨧ᩠ᨧᩴ ᩈᨶ᩠ᨲᩁᨻᩣᩉᩥᩁᩴ;

ᨴᩩᨠ᩠ᨡᩣᨽᩥᨲᩩᨶ᩠ᨶᩮᩣ ᨶᨴᨲᩥ, ᨶᩣᨣᩮᩣ ᨲᩩᨲ᩠ᨲᨭ᩠ᨭᩥᨲᩮᩣ [ᨲᩩᨲ᩠ᨲᨴ᩠ᨴᩥᨲᩮᩣ (ᩈᩦ.)] ᨿᨳᩣ.

᪑᪐᪗.

‘‘ᨿᩮᩣ ᩃᩮᩣᨽᩣ ᨸᩥᨲᩁᩴ ᩉᨶ᩠ᨲᩥ, ᨴᩮᩣᩈᩣ ᩅᩣ ᨸᩩᩁᩥᩈᩣᨵᨾᩮᩣ;

ᩈ ᨠᩣᩊᩈᩩᨲ᩠ᨲᩮ ᨶᩥᩁᨿᩮ, ᨧᩥᩁᩁᨲ᩠ᨲᩣᨿ ᨸᨧ᩠ᨧᨲᩥ.

᪑᪐᪘.

‘‘ᩈ ¶ ᨲᩣᨴᩥᩈᩮᩣ ᨸᨧ᩠ᨧᨲᩥ ᩃᩮᩣᩉᨠᩩᨾ᩠ᨽᩥᨿᩴ, ᨸᨠ᩠ᨠᨬ᩠ᨧ ᩈᨲ᩠ᨲᩦᩉᩥ ᩉᨶᨶ᩠ᨲᩥ ᨶᩥᨲ᩠ᨲᨧᩴ;

ᩋᨶ᩠ᨵᩴ ᨠᩁᩥᨲ᩠ᩅᩣ ᨾᩩᨲ᩠ᨲᨠᩁᩦᩈᨽᨠ᩠ᨡᩴ, ᨡᩣᩁᩮ ᨶᩥᨾᩩᨩ᩠ᨩᨶ᩠ᨲᩥ ᨲᨳᩣᩅᩥᨵᩴ ᨶᩁᩴ.

᪑᪐᪙.

‘‘ᨲᨲ᩠ᨲᩴ ᨸᨠ᩠ᨠᩩᨳᩥᨲᨾᨿᩮᩣᨣᩩᩊᨬ᩠ᨧ [ᨸᨠ᩠ᨠᩩᨵᩥᨲᨾᨿᩮᩣᨣᩩᩊᨬ᩠ᨧ (ᨠ.)], ᨴᩦᨥᩮ ᨧ ᨹᩣᩃᩮ ᨧᩥᩁᩁᨲ᩠ᨲᨲᩣᨸᩥᨲᩮ;

ᩅᩥᨠ᩠ᨡᨾ᩠ᨽᨾᩣᨴᩣᨿ ᩅᩥᨻᨶ᩠ᨵ [ᩅᩥᨻᨴ᩠ᨵ (ᩈᩦ.), ᩅᩥᨽᨩ᩠ᨩ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩁᨩ᩠ᨩᩩᨽᩥ, ᩅᩥᩅᨭᩮ ᨾᩩᨡᩮ ᩈᨾ᩠ᨸᩅᩥᩈᨶ᩠ᨲᩥ [ᩈᩴᨧᩅᨶ᩠ᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩁᨠ᩠ᨡᩈᩣ.

᪑᪑᪐.

‘‘ᩈᩣᨾᩣ ᨧ ᩈᩮᩣᨱᩣ ᩈᨻᩃᩣ ᨧ ᨣᩥᨩ᩠ᨫᩣ, ᨠᩣᨠᩮᩣᩊᩈᨦ᩠ᨥᩣ ᨧ ᨴᩥᨩᩣ ᩋᨿᩮᩣᨾᩩᨡᩣ;

ᩈᨦ᩠ᨣᨾ᩠ᨾ ¶ ᨡᩣᨴᨶ᩠ᨲᩥ ᩅᩥᨸ᩠ᨹᨶ᩠ᨴᨾᩣᨶᩴ, ᨩᩥᩅ᩠ᩉᩴ ᩅᩥᨽᨩ᩠ᨩ ᩅᩥᨥᩣᩈᩴ ᩈᩃᩮᩣᩉᩥᨲᩴ.

᪑᪑᪑.

‘‘ᨲᩴ ¶ ᨴᨯ᩠ᨰᨲᩣᩃᩴ ᨸᩁᩥᨽᩥᨶ᩠ᨶᨣᨲ᩠ᨲᩴ, ᨶᩥᨸ᩠ᨸᩮᩣᨳᨿᨶ᩠ᨲᩣ ᩋᨶᩩᩅᩥᨧᩁᨶ᩠ᨲᩥ ᩁᨠ᩠ᨡᩈᩣ;

ᩁᨲᩦ ᩉᩥ ᨶᩮᩈᩴ ᨴᩩᨡᩥᨶᩮᩣ ᨸᨶᩦᨲᩁᩮ, ᩑᨲᩣᨴᩥᩈᩈ᩠ᨾᩥᩴ ᨶᩥᩁᨿᩮ ᩅᩈᨶ᩠ᨲᩥ;

ᨿᩮ ᨠᩮᨧᩥ ᩃᩮᩣᨠᩮ ᩍᨵ ᨸᩮᨲ᩠ᨲᩥᨥᩣᨲᩥᨶᩮᩣ.

᪑᪑᪒.

‘‘ᨸᩩᨲ᩠ᨲᩮᩣ ᨧ ᨾᩣᨲᩁᩴ ᩉᨶ᩠ᨲ᩠ᩅᩣ, ᩍᨲᩮᩣ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᨿᨾᨠ᩠ᨡᨿᩴ;

ᨽᩩᩈᨾᩣᨸᨩ᩠ᨩᨲᩮ ᨴᩩᨠ᩠ᨡᩴ, ᩋᨲ᩠ᨲᨠᨾ᩠ᨾᨹᩃᩪᨸᨣᩮᩣ.

᪑᪑᪓.

‘‘ᩋᨾᨶᩩᩔᩣ ᩋᨲᩥᨻᩃᩣ, ᩉᨶ᩠ᨲᩣᩁᩴ ᨩᨶᨿᨶ᩠ᨲᩥᨿᩣ;

ᩋᨿᩮᩣᨾᨿᩮᩉᩥ ᩅᩣᩊᩮᩉᩥ [ᨹᩣᩃᩮᩉᩥ (ᨸᩦ.)], ᨸᩦᩊᨿᨶ᩠ᨲᩥ ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ.

᪑᪑᪔.

‘‘ᨲᨾᩔᩅᩴ [ᨲᩴ ᨸᩔᩅᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨲᩴ ᨸᩔᩩᨲᩴ (ᨸᩦ.)] ᩈᨠᩣ ᨣᨲ᩠ᨲᩣ, ᩁᩩᩉᩥᩁᩴ [ᩁᩩᨵᩥᩁᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩋᨲ᩠ᨲᩈᨾ᩠ᨽᩅᩴ;

ᨲᨾ᩠ᨻᩃᩮᩣᩉᩅᩥᩃᩦᨶᩴᩅ, ᨲᨲ᩠ᨲᩴ ᨸᩣᨿᩮᨶ᩠ᨲᩥ ᨾᨲ᩠ᨲᩥᨥᩴ [ᨾᨲ᩠ᨲᩥᨿᩴ (ᩈᩦ.)].

᪑᪑᪕.

‘‘ᨩᩥᨣᩩᨧ᩠ᨨᩴ ᨠᩩᨱᨸᩴ ᨸᩪᨲᩥᩴ, ᨴᩩᨣ᩠ᨣᨶ᩠ᨵᩴ ᨣᩪᨳᨠᨴ᩠ᨴᨾᩴ;

ᨸᩩᨻ᩠ᨻᩃᩮᩣᩉᩥᨲᩈᨦ᩠ᨠᩣᩈᩴ, ᩁᩉᨴᨾᩮᩣᨣᨿ᩠ᩉ [ᩁᩉᨴᩮᩣᨣ᩠ᨣᨿ᩠ᩉ (ᨠ.)] ᨲᩥᨭ᩠ᨮᨲᩥ.

᪑᪑᪖.

‘‘ᨲᨾᩮᨶᩴ ᨠᩥᨾᨿᩮᩣ ᨲᨲ᩠ᨳ, ᩋᨲᩥᨠᩣᨿᩣ ᩋᨿᩮᩣᨾᩩᨡᩣ;

ᨨᩅᩥᩴ ᨽᩮᨲ᩠ᩅᩣᨶ [ᨨᩮᨲ᩠ᩅᩣᨶ (ᩈᩦ. ᨸᩦ.)] ᨡᩣᨴᨶ᩠ᨲᩥ, ᩈᩴᨣᩥᨴ᩠ᨵᩣ [ᨸᨣᩥᨴ᩠ᨵᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩴᩈᩃᩮᩣᩉᩥᨲᩮ.

᪑᪑᪗.

‘‘ᩈᩮᩣ ᨧ ᨲᩴ ᨶᩥᩁᨿᩴ ᨸᨲ᩠ᨲᩮᩣ, ᨶᩥᨾᩩᨣ᩠ᨣᩮᩣ ᩈᨲᨸᩮᩣᩁᩥᩈᩴ;

ᨸᩪᨲᩥᨠᩴ ᨠᩩᨱᨸᩴ ᩅᩣᨲᩥ, ᩈᨾᨶ᩠ᨲᩣ ᩈᨲᨿᩮᩣᨩᨶᩴ.

᪑᪑᪘.

‘‘ᨧᨠ᩠ᨡᩩᨾᩣᨸᩥ ᩉᩥ ᨧᨠ᩠ᨡᩪᩉᩥ, ᨲᩮᨶ ᨣᨶ᩠ᨵᩮᨶ ᨩᩦᨿᨲᩥ;

ᩑᨲᩣᨴᩥᩈᩴ ¶ ᨻᩕᩉ᩠ᨾᨴᨲ᩠ᨲ, ᨾᩣᨲᩩᨥᩮᩣ ᩃᨽᨲᩮ ᨴᩩᨡᩴ.

᪑᪑᪙.

‘‘ᨡᩩᩁᨵᩣᩁᨾᨶᩩᨠ᩠ᨠᨾ᩠ᨾ, ᨲᩥᨠ᩠ᨡᩴ ᨴᩩᩁᨽᩥᩈᨾ᩠ᨽᩅᩴ;

ᨸᨲᨶ᩠ᨲᩥ ᨣᨻ᩠ᨽᨸᩣᨲᩥᨿᩮᩣ [ᨣᨻ᩠ᨽᨸᩣᨲᩥᨶᩥᨿᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨴᩩᨣ᩠ᨣᩴ ᩅᩮᨲᩁᨱᩥᩴ [ᩅᩮᨲ᩠ᨲᩁᨱᩥᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨶᨴᩥᩴ.

᪑᪒᪐.

‘‘ᩋᨿᩮᩣᨾᨿᩣ ᩈᩥᨾ᩠ᨻᩃᩥᨿᩮᩣ, ᩈᩮᩣᩊᩈᨦ᩠ᨣᩩᩃᨠᨱ᩠ᨭᨠᩣ;

ᩏᨽᨲᩮᩣ ᩋᨽᩥᩃᨾ᩠ᨻᨶ᩠ᨲᩥ, ᨴᩩᨣ᩠ᨣᩴ ᩅᩮᨲᩁᨱᩥᩴ [ᩅᩮᨲ᩠ᨲᩁᨱᩥᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨶᨴᩥᩴ.

᪑᪒᪑.

‘‘ᨲᩮ ¶ ᩋᨧ᩠ᨧᩥᨾᨶ᩠ᨲᩮᩣ ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ, ᩋᨣ᩠ᨣᩥᨠ᩠ᨡᨶ᩠ᨵᩣᩅ ᩌᩁᨠᩣ;

ᩌᨴᩥᨲ᩠ᨲᩣ ᨩᩣᨲᩅᩮᨴᩮᨶ, ᩏᨴ᩠ᨵᩴ ᨿᩮᩣᨩᨶᨾᩩᨣ᩠ᨣᨲᩣ.

᪑᪒᪒.

‘‘ᩑᨲᩮ ¶ ᩅᨩᨶ᩠ᨲᩥ [ᩈᨩᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.), ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ (ᩈ᩠ᨿᩣ.)] ᨶᩥᩁᨿᩮ, ᨲᨲ᩠ᨲᩮ ᨲᩥᨡᩥᨱᨠᨱ᩠ᨭᨠᩮ;

ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᩋᨲᩥᨧᩣᩁᩣ [ᩋᨲᩥᨧᩣᩁᩥᨶᩥᨿᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨶᩁᩣ ᨧ ᨸᩁᨴᩣᩁᨣᩪ.

᪑᪒᪓.

‘‘ᨲᩮ ᨸᨲᨶ᩠ᨲᩥ ᩋᨵᩮᩣᨠ᩠ᨡᨶ᩠ᨵᩣ, ᩅᩥᩅᨲ᩠ᨲᩣ ᩅᩥᩉᨲᩣ ᨸᩩᨳᩪ;

ᩈᨿᨶ᩠ᨲᩥ ᩅᩥᨶᩥᩅᩥᨴ᩠ᨵᨦ᩠ᨣᩣ, ᨴᩦᨥᩴ ᨩᨣ᩠ᨣᨶ᩠ᨲᩥ ᩈᨻ᩠ᨻᨴᩣ [ᩈᩴᩅᩁᩥᩴ (ᩈᩦ. ᨸᩦ.)].

᪑᪒᪔.

‘‘ᨲᨲᩮᩣ ᩁᨲ᩠ᨿᩣ ᩅᩥᩅᩈᩣᨶᩮ [ᩅᩥᩅᩈᨶᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨾᩉᨲᩥᩴ ᨸᨻ᩠ᨻᨲᩪᨸᨾᩴ;

ᩃᩮᩣᩉᨠᩩᨾ᩠ᨽᩥᩴ ᨸᩅᨩ᩠ᨩᨶ᩠ᨲᩥ, ᨲᨲ᩠ᨲᩴ ᩋᨣ᩠ᨣᩥᩈᨾᩪᨴᨠᩴ.

᪑᪒᪕.

‘‘ᩑᩅᩴ ᨴᩥᩅᩣ ᨧ ᩁᨲ᩠ᨲᩮᩣ ᨧ, ᨴᩩᩔᩦᩃᩣ ᨾᩮᩣᩉᨸᩣᩁᩩᨲᩣ;

ᩋᨶᩩᨽᩮᩣᨶ᩠ᨲᩥ ᩈᨠᩴ ᨠᨾ᩠ᨾᩴ, ᨸᩩᨻ᩠ᨻᩮ ᨴᩩᨠ᩠ᨠᨭᨾᨲ᩠ᨲᨶᩮᩣ.

᪑᪒᪖.

‘‘ᨿᩣ ᨧ ᨽᩁᩥᨿᩣ ᨵᨶᨠ᩠ᨠᩦᨲᩣ, ᩈᩣᨾᩥᨠᩴ ᩋᨲᩥᨾᨬ᩠ᨬᨲᩥ;

ᩈᩔᩩᩴ ᩅᩣ ᩈᩈᩩᩁᩴ ᩅᩣᨸᩥ, ᨩᩮᨭ᩠ᨮᩴ ᩅᩣᨸᩥ ᨶᨶᨶ᩠ᨴᩁᩴ [ᨶᨶᨶ᩠ᨴᨶᩴ (ᩈ᩠ᨿᩣ. ᨠ.)].

᪑᪒᪗.

‘‘ᨲᩔᩣ ᩅᨦ᩠ᨠᩮᨶ ᨩᩥᩅ᩠ᩉᨣ᩠ᨣᩴ, ᨶᩥᨻ᩠ᨻᩉᨶ᩠ᨲᩥ ᩈᨻᨶ᩠ᨵᨶᩴ;

ᩈ ᨻ᩠ᨿᩣᨾᨾᨲ᩠ᨲᩴ ᨠᩥᨾᩥᨶᩴ, ᨩᩥᩅ᩠ᩉᩴ ᨸᩔᨲᩥ ᩋᨲ᩠ᨲᨶᩥ [ᩋᨲ᩠ᨲᨶᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

ᩅᩥᨬ᩠ᨬᩣᨸᩮᨲᩩᩴ ¶ ᨶ ᩈᨠ᩠ᨠᩮᩣᨲᩥ, ᨲᩣᨸᨶᩮ ᨸᩮᨧ᩠ᨧ ᨸᨧ᩠ᨧᨲᩥ.

᪑᪒᪘.

‘‘ᩒᩁᨻ᩠ᨽᩥᨠᩣ ᩈᩪᨠᩁᩥᨠᩣ, ᨾᨧ᩠ᨨᩥᨠᩣ ᨾᩥᨣᨻᨶ᩠ᨵᨠᩣ;

ᨧᩮᩣᩁᩣ ᨣᩮᩣᨥᩣᨲᨠᩣ ᩃᩩᨴ᩠ᨴᩣ, ᩋᩅᨱ᩠ᨱᩮ ᩅᨱ᩠ᨱᨠᩣᩁᨠᩣ.

᪑᪒᪙.

‘‘ᩈᨲ᩠ᨲᩦᩉᩥ ᩃᩮᩣᩉᨠᩪᨭᩮᩉᩥ, ᨶᩮᨲ᩠ᨲᩥᩴᩈᩮᩉᩥ ᩏᩈᩪᩉᩥ ᨧ;

ᩉᨬ᩠ᨬᨾᩣᨶᩣ ᨡᩣᩁᨶᨴᩥᩴ, ᨸᨸᨲᨶ᩠ᨲᩥ [ᩈᨾ᩠ᨸᨲᨶ᩠ᨲᩥ (ᨠ.)] ᩋᩅᩴᩈᩥᩁᩣ.

᪑᪓᪐.

‘‘ᩈᩣᨿᩴ ᨸᩣᨲᩮᩣ ᨠᩪᨭᨠᩣᩁᩦ, ᩋᨿᩮᩣᨠᩪᨭᩮᩉᩥ ᩉᨬ᩠ᨬᨲᩥ;

ᨲᨲᩮᩣ ᩅᨶ᩠ᨲᩴ ᨴᩩᩁᨲ᩠ᨲᩣᨶᩴ, ᨸᩁᩮᩈᩴ ᨽᩩᨬ᩠ᨩᩁᩮ [ᨽᩩᨬ᩠ᨩᨲᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩈᨴᩣ.

᪑᪓᪑.

‘‘ᨵᨦ᩠ᨠᩣ ᨽᩮᩁᨱ᩠ᨯᨠᩣ [ᨽᩮᨴᨱ᩠ᨯᨠᩣ (ᨠ.)] ᨣᩥᨩ᩠ᨫᩣ, ᨠᩣᨠᩮᩣᩊᩣ ᨧ ᩋᨿᩮᩣᨾᩩᨡᩣ;

ᩅᩥᨸ᩠ᨹᨶ᩠ᨴᨾᩣᨶᩴ ᨡᩣᨴᨶ᩠ᨲᩥ, ᨶᩁᩴ ᨠᩥᨻ᩠ᨻᩥᩈᨠᩣᩁᨠᩴ [ᨠᩥᨻ᩠ᨻᩥᩈᨠᩣᩁᩥᨶᩴ (ᨸᩦ.)].

᪑᪓᪒.

‘‘ᨿᩮ ᨾᩥᨣᩮᨶ ᨾᩥᨣᩴ ᩉᨶ᩠ᨲᩥ, ᨸᨠ᩠ᨡᩥᩴ ᩅᩣ ᨸᨶ ᨸᨠ᩠ᨡᩥᨶᩣ;

ᩋᩈᨶ᩠ᨲᩮᩣ ᩁᨩᩈᩣ ᨨᨶ᩠ᨶᩣ, ᨣᨶ᩠ᨲᩣ [ᨣᨲᩣ (ᨠ.)] ᨲᩮ ᨶᩥᩁᨿᩩᩔᨴᩴ [ᨶᩥᩁᨿᩴ ᩋᨵᩮᩣ (ᨸᩦ.)].

᪑᪓᪓.

‘‘ᩈᨶ᩠ᨲᩮᩣ ¶ ᨧ [ᩈᨶ᩠ᨲᩮᩣᩅ (ᩈ᩠ᨿᩣ.)] ᩏᨴ᩠ᨵᩴ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᩈᩩᨧᩥᨱ᩠ᨱᩮᨶᩥᨵ ᨠᨾ᩠ᨾᩩᨶᩣ;

ᩈᩩᨧᩥᨱ᩠ᨱᩔ ᨹᩃᩴ ᨸᩔ, ᩈᩍᨶ᩠ᨴᩣ [ᩈᩉᩥᨶ᩠ᨴᩣ (ᩈᩦ.)] ᨴᩮᩅᩣ ᩈᨻᩕᩉ᩠ᨾᨠᩣ.

᪑᪓᪔.

‘‘ᨲᩴ ¶ ᨲᩴ ᨻᩕᩪᨾᩥ ᨾᩉᩣᩁᩣᨩ, ᨵᨾ᩠ᨾᩴ ᩁᨭ᩠ᨮᨸᨲᩦ ᨧᩁ;

ᨲᨳᩣ [ᨲᨳᩣ ᨲᨳᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩁᩣᨩ ᨧᩁᩣᩉᩥ ᨵᨾ᩠ᨾᩴ, ᨿᨳᩣ ᨲᩴ ᩈᩩᨧᩥᨱ᩠ᨱᩴ ᨶᩣᨶᩩᨲᨸ᩠ᨸᩮᨿ᩠ᨿ ᨸᨧ᩠ᨨᩣ’’ᨲᩥ.

ᩈᩴᨠᩥᨧ᩠ᨧᨩᩣᨲᨠᩴ ᨴᩩᨲᩥᨿᩴ.

ᩈᨭ᩠ᨮᩥᨶᩥᨸᩣᨲᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨲᩔᩩᨴ᩠ᨴᩣᨶᩴ –

ᩋᨳ ᩈᨭ᩠ᨮᩥᨶᩥᨸᩣᨲᨾ᩠ᩉᩥ, ᩈᩩᨱᩣᨳ ᨾᨾ ᨽᩣᩈᩥᨲᩴ;

ᨩᩣᨲᨠᩈᩅ᩠ᩉᨿᨶᩮᩣ ¶ ᨸᩅᩁᩮᩣ, ᩈᩮᩣᨱᨠᩋᩁᩥᨶ᩠ᨴᨾᩈᩅ᩠ᩉᨿᨶᩮᩣ;

ᨲᨳᩣ ᩅᩩᨲ᩠ᨲᩁᨳᩮᩈᨽᨠᩥᨧ᩠ᨧᩅᩁᩮᩣᨲᩥ.

᪒᪐. ᩈᨲ᩠ᨲᨲᩥᨶᩥᨸᩣᨲᩮᩣ

᪕᪓᪑. ᨠᩩᩈᨩᩣᨲᨠᩴ (᪑)

᪑.

‘‘ᩍᨴᩴ ¶ ¶ ¶ ᨲᩮ ᩁᨭ᩠ᨮᩴ ᩈᨵᨶᩴ ᩈᨿᩮᩣᨣ᩠ᨣᩴ, ᩈᨠᩣᨿᩩᩁᩴ ᩈᨻ᩠ᨻᨠᩣᨾᩪᨸᨸᨶ᩠ᨶᩴ;

ᩍᨴᩴ ᨲᩮ ᩁᨩ᩠ᨩᩴ [ᩁᨭ᩠ᨮᩴ (ᨠ.)] ᩋᨶᩩᩈᩣᩈ ᩋᨾ᩠ᨾ, ᨣᨧ᩠ᨨᩣᨾᩉᩴ ᨿᨲ᩠ᨳ ᨸᩥᨿᩣ ᨸᨽᩣᩅᨲᩦ’’.

᪒.

‘‘ᩋᨶᩩᨩ᩠ᨩᩩᨽᩪᨲᩮᨶ ᩉᩁᩴ ᨾᩉᨶ᩠ᨲᩴ, ᨴᩥᩅᩣ ᨧ ᩁᨲ᩠ᨲᩮᩣ ᨧ ᨶᩥᩈᩦᨳᨠᩣᩃᩮ [ᨶᩥᩈᩦᨴ ᨠᩣᩃᩮ (ᨠ.)];

ᨸᨭᩥᨣᨧ᩠ᨨ ᨲ᩠ᩅᩴ ᨡᩥᨸ᩠ᨸᩴ ᨠᩩᩈᩣᩅᨲᩥᩴ ᨠᩩᩈ [ᨠᩩᩈᩣᩅᨲᩥᩴ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨶᩥᨧ᩠ᨨᩣᨾᩥ ᨴᩩᨻ᩠ᨻᨱ᩠ᨱᨾᩉᩴ ᩅᩈᨶ᩠ᨲᩴ’’.

᪓.

‘‘ᨶᩣᩉᩴ ᨣᨾᩥᩔᩣᨾᩥ ᩍᨲᩮᩣ ᨠᩩᩈᩣᩅᨲᩥᩴ, ᨸᨽᩣᩅᨲᩦ ᩅᨱ᩠ᨱᨸᩃᩮᩣᨽᩥᨲᩮᩣ ᨲᩅ;

ᩁᨾᩣᨾᩥ ᨾᨴ᩠ᨴᩔ ᨶᩥᨠᩮᨲᩁᨾ᩠ᨾᩮ, ᩉᩥᨲ᩠ᩅᩣᨶ ᩁᨭ᩠ᨮᩴ ᨲᩅ ᨴᩔᨶᩮ ᩁᨲᩮᩣ.

᪔.

‘‘ᨸᨽᩣᩅᨲᩦ ᩅᨱ᩠ᨱᨸᩃᩮᩣᨽᩥᨲᩮᩣ ᨲᩅ, ᩈᨾ᩠ᨾᩪᩊ᩠ᩉᩁᩪᨸᩮᩣ ᩅᩥᨧᩁᩣᨾᩥ ᨾᩮᨴᩥᨶᩥᩴ [ᨾᩮᨴᨶᩥᩴ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᨴᩥᩈᩴ ᨶ ᨩᩣᨶᩣᨾᩥ ᨠᩩᨲᩮᩣᨾ᩠ᩉᩥ ᩌᨣᨲᩮᩣ, ᨲᨿᨾ᩠ᩉᩥ ᨾᨲ᩠ᨲᩮᩣ ᨾᩥᨣᨾᨶ᩠ᨴᩃᩮᩣᨧᨶᩮ.

᪕.

‘‘ᩈᩩᩅᨱ᩠ᨱᨧᩦᩁᩅᩈᨶᩮ, ᨩᩣᨲᩁᩪᨸᩈᩩᨾᩮᨡᩃᩮ;

ᩈᩩᩔᩮᩣᨱᩥ ¶ ᨲᩅ ᨠᩣᨾᩣ ᩉᩥ [ᨠᩣᨾᩮᩉᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨶᩣᩉᩴ ᩁᨩ᩠ᨩᩮᨶ ᨾᨲ᩠ᨳᩥᨠᩮᩣ’’.

᪖.

‘‘ᩋᨻ᩠ᨽᩪᨲᩥ [ᩋᨻ᩠ᨽᩪ ᩉᩥ (ᩈᩦ.), ᩋᨽᩪᨲᩥ (ᩈ᩠ᨿᩣ.), ᩋᨻ᩠ᨽᩩ ᩉᩥ (ᨸᩦ.)] ᨲᩔ ᨽᩮᩣ ᩉᩮᩣᨲᩥ, ᨿᩮᩣ ᩋᨶᩥᨧ᩠ᨨᨶ᩠ᨲᨾᩥᨧ᩠ᨨᨲᩥ;

ᩋᨠᩣᨾᩴ ᩁᩣᨩ ᨠᩣᨾᩮᩈᩥ [ᨠᩣᨾᩮᩉᩥ (ᩈᩦ. ᨸᩦ.)], ᩋᨠᨶ᩠ᨲᩴ ᨠᨶ᩠ᨲᩩ [ᩋᨠᨶ᩠ᨲᩮᩣ ᨠᨶ᩠ᨲ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩥᨧ᩠ᨨᩈᩥ’’.

᪗.

‘‘ᩋᨠᩣᨾᩴ ᩅᩣ ᩈᨠᩣᨾᩴ ᩅᩣ, ᨿᩮᩣ ᨶᩁᩮᩣ ᩃᨽᨲᩮ ᨸᩥᨿᩴ;

ᩃᩣᨽᨾᩮᨲ᩠ᨳ ᨸᩈᩴᩈᩣᨾ, ᩋᩃᩣᨽᩮᩣ ᨲᨲ᩠ᨳ ᨸᩣᨸᨠᩮᩣ’’.

᪘.

‘‘ᨸᩣᩈᩣᨱᩈᩣᩁᩴ ¶ ᨡᨱᩈᩥ, ᨠᨱᩥᨠᩣᩁᩔ ᨴᩣᩁᩩᨶᩣ;

ᩅᩣᨲᩴ ᨩᩣᩃᩮᨶ ᨻᩣᨵᩮᩈᩥ, ᨿᩮᩣ ᩋᨶᩥᨧ᩠ᨨᨶ᩠ᨲᨾᩥᨧ᩠ᨨᩈᩥ’’.

᪙.

‘‘ᨸᩣᩈᩣᨱᩮᩣ ᨶᩪᨶ ᨲᩮ ᩉᨴᨿᩮ, ᩒᩉᩥᨲᩮᩣ ᨾᩩᨴᩩᩃᨠ᩠ᨡᨱᩮ;

ᨿᩮᩣ ᨲᩮ ᩈᩣᨲᩴ ᨶ ᩅᩥᨶ᩠ᨴᩣᨾᩥ, ᨲᩥᩁᩮᩣᨩᨶᨸᨴᩣᨣᨲᩮᩣ.

᪑᪐.

‘‘ᨿᨴᩣ ᨾᩴ ᨽᨠᩩᨭᩥᩴ [ᨽᩪᨠᩩᨭᩥᩴ (ᩈᩦ. ᨸᩦ.)] ᨠᨲ᩠ᩅᩣ, ᩁᩣᨩᨸᩩᨲ᩠ᨲᩦ ᩏᨴᩥᨠ᩠ᨡᨲᩥ [ᩁᩣᨩᨸᩩᨲ᩠ᨲᩥ ᩏᨴᩥᨠ᩠ᨡᩈᩥ (ᩈᩦ. ᨸᩦ.)];

ᩌᩊᩣᩁᩥᨠᩮᩣ ᨲᨴᩣ ᩉᩮᩣᨾᩥ, ᩁᨬ᩠ᨬᩮᩣ ᨾᨴ᩠ᨴᩔᨶ᩠ᨲᩮᨸᩩᩁᩮ [ᨾᨴ᩠ᨴᩔ ᨳᩦᨸᩩᩁᩮ (ᩈᩦ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ].

᪑᪑.

‘‘ᨿᨴᩣ ᩏᨾ᩠ᩉᨿᨾᩣᨶᩣ ᨾᩴ, ᩁᩣᨩᨸᩩᨲ᩠ᨲᩦ ᩏᨴᩥᨠ᩠ᨡᨲᩥ [ᩁᩣᨩᨸᩩᨲ᩠ᨲᩥ ᩏᨴᩥᨠ᩠ᨡᩈᩥ (ᩈᩦ. ᨸᩦ.)];

ᨶᩣᩊᩣᩁᩥᨠᩮᩣ ᨲᨴᩣ ᩉᩮᩣᨾᩥ, ᩁᩣᨩᩣ ᩉᩮᩣᨾᩥ ᨲᨴᩣ ᨠᩩᩈᩮᩣ’’.

᪑᪒.

‘‘ᩈᨧᩮ ¶ ᩉᩥ ᩅᨧᨶᩴ ᩈᨧ᩠ᨧᩴ, ᨶᩮᨾᩥᨲ᩠ᨲᩣᨶᩴ ᨽᩅᩥᩔᨲᩥ;

ᨶᩮᩅ ᨾᩮ ᨲ᩠ᩅᩴ ᨸᨲᩦ ᩋᩔ, ᨠᩣᨾᩴ ᨨᩥᨶ᩠ᨴᨶ᩠ᨲᩩ ᩈᨲ᩠ᨲᨵᩣ’’.

᪑᪓.

‘‘ᩈᨧᩮ ᩉᩥ ᩅᨧᨶᩴ ᩈᨧ᩠ᨧᩴ, ᩋᨬ᩠ᨬᩮᩈᩴ ᨿᨴᩥ ᩅᩣ ᨾᨾᩴ;

ᨶᩮᩅ ᨲᩩᨿ᩠ᩉᩴ ᨸᨲᩦ ᩋᨲ᩠ᨳᩥ, ᩋᨬ᩠ᨬᩮᩣ ᩈᩦᩉᩔᩁᩣ ᨠᩩᩈᩣ’’.

᪑᪔.

‘‘ᨶᩮᨠ᩠ᨡᩴ ᨣᩦᩅᩴ ᨲᩮ ᨠᩣᩁᩮᩔᩴ, ᨸᨲ᩠ᩅᩣ ᨡᩩᨩ᩠ᨩᩮ ᨠᩩᩈᩣᩅᨲᩥᩴ;

ᩈᨧᩮ ᨾᩴ ᨶᩣᨣᨶᩣᩈᩪᩁᩪ, ᩒᩃᩮᩣᨠᩮᨿ᩠ᨿ ᨸᨽᩣᩅᨲᩦ.

᪑᪕.

‘‘ᨶᩮᨠ᩠ᨡᩴ ¶ ᨣᩦᩅᩴ ᨲᩮ ᨠᩣᩁᩮᩔᩴ, ᨸᨲ᩠ᩅᩣ ᨡᩩᨩ᩠ᨩᩮ ᨠᩩᩈᩣᩅᨲᩥᩴ;

ᩈᨧᩮ ᨾᩴ ᨶᩣᨣᨶᩣᩈᩪᩁᩪ, ᩌᩃᨸᩮᨿ᩠ᨿ ᨸᨽᩣᩅᨲᩦ.

᪑᪖.

‘‘ᨶᩮᨠ᩠ᨡᩴ ᨣᩦᩅᩴ ᨲᩮ ᨠᩣᩁᩮᩔᩴ, ᨸᨲ᩠ᩅᩣ ᨡᩩᨩ᩠ᨩᩮ ᨠᩩᩈᩣᩅᨲᩥᩴ;

ᩈᨧᩮ ᨾᩴ ᨶᩣᨣᨶᩣᩈᩪᩁᩪ, ᩏᨾ᩠ᩉᩣᨿᩮᨿ᩠ᨿ ᨸᨽᩣᩅᨲᩦ.

᪑᪗.

‘‘ᨶᩮᨠ᩠ᨡᩴ ᨣᩦᩅᩴ ᨲᩮ ᨠᩣᩁᩮᩔᩴ, ᨸᨲ᩠ᩅᩣ ᨡᩩᨩ᩠ᨩᩮ ᨠᩩᩈᩣᩅᨲᩥᩴ;

ᩈᨧᩮ ᨾᩴ ᨶᩣᨣᨶᩣᩈᩪᩁᩪ, ᨸᨾ᩠ᩉᩣᨿᩮᨿ᩠ᨿ ᨸᨽᩣᩅᨲᩦ.

᪑᪘.

‘‘ᨶᩮᨠ᩠ᨡᩴ ᨣᩦᩅᩴ ᨲᩮ ᨠᩣᩁᩮᩔᩴ, ᨸᨲ᩠ᩅᩣ ᨡᩩᨩ᩠ᨩᩮ ᨠᩩᩈᩣᩅᨲᩥᩴ;

ᩈᨧᩮ ᨾᩮ ᨶᩣᨣᨶᩣᩈᩪᩁᩪ, ᨸᩣᨱᩦᩉᩥ ᩏᨸᩈᨾ᩠ᨹᩩᩈᩮ’’.

᪑᪙.

‘‘ᨶ ᩉᩥ ᨶᩪᨶᩣᨿᩴ ᩁᩣᨩᨸᩩᨲ᩠ᨲᩦ, ᨠᩩᩈᩮ ᩈᩣᨲᨾ᩠ᨸᩥ ᩅᩥᨶ᩠ᨴᨲᩥ;

ᩌᩊᩣᩁᩥᨠᩮ ᨽᨲᩮ ᨸᩮᩣᩈᩮ, ᩅᩮᨲᨶᩮᨶ ᩋᨶᨲ᩠ᨳᩥᨠᩮ’’.

᪒᪐.

‘‘ᨶ ᩉᩥ ᨶᩪᨶᩣᨿᩴ ᩈᩣ [ᨶᩪᨶ ᩋᨿᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨡᩩᨩ᩠ᨩᩣ, ᩃᨽᨲᩥ ᨩᩥᩅ᩠ᩉᩣᨿ ᨨᩮᨴᨶᩴ;

ᩈᩩᨶᩥᩈᩥᨲᩮᨶ ᩈᨲ᩠ᨳᩮᨶ, ᩑᩅᩴ ᨴᩩᨻ᩠ᨽᩣᩈᩥᨲᩴ ᨽᨱᩴ’’.

᪒᪑.

‘‘ᨾᩣ ¶ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨾᩉᩣᨿᩈᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪒᪒.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨾᩉᨴ᩠ᨵᨶᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪒᪓.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨾᩉᨻ᩠ᨻᩃᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪒᪔.

‘‘ᨾᩣ ¶ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨾᩉᩣᩁᨭ᩠ᨮᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪒᪕.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨾᩉᩣᩁᩣᨩᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪒᪖.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᩈᩦᩉᩔᩁᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪒᪗.

‘‘ᨾᩣ ¶ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᩅᨣ᩠ᨣᩩᩔᩁᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪒᪘.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨻᩥᨶ᩠ᨴᩩᩔᩁᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪒᪙.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨾᨬ᩠ᨩᩩᩔᩁᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪓᪐.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨾᨵᩩᩔᩁᩮᩣᨲᩥ [ᨾᨵᩩᩁᩔᩁᩮᩣᨲᩥ (ᩈᩦ.)] ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪓᪑.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᩈᨲᩈᩥᨸ᩠ᨸᩮᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪓᪒.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨡᨲ᩠ᨲᩥᨿᩮᩣᨲᩥᨸᩥ ᨠᨲ᩠ᩅᩣᨶ [ᨠᩁᩥᨲ᩠ᩅᩣᨶ (ᩈᩦ.)], ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ.

᪓᪓.

‘‘ᨾᩣ ᨶᩴ ᩁᩪᨸᩮᨶ ᨸᩣᨾᩮᩈᩥ, ᩌᩁᩮᩣᩉᩮᨶ ᨸᨽᩣᩅᨲᩥ;

ᨠᩩᩈᩁᩣᨩᩣᨲᩥ ᨠᨲ᩠ᩅᩣᨶ, ᨠᩁᩔᩩ ᩁᩩᨧᩥᩁᩮ ᨸᩥᨿᩴ’’.

᪓᪔.

‘‘ᩑᨲᩮ ¶ ᨶᩣᨣᩣ ᩏᨸᨲ᩠ᨳᨴ᩠ᨵᩣ, ᩈᨻ᩠ᨻᩮ ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᩅᨾ᩠ᨾᩥᨲᩣ [ᩅᨾ᩠ᨾᩥᨠᩣ (ᩈ᩠ᨿᩣ.)];

ᨸᩩᩁᩣ ᨾᨴ᩠ᨴᨶ᩠ᨲᩥ ᨸᩣᨠᩣᩁᩴ, ᩌᨶᩮᨶ᩠ᨲᩮᨲᩴ ᨸᨽᩣᩅᨲᩥᩴ’’.

᪓᪕.

‘‘ᩈᨲ᩠ᨲ ¶ ᨻᩥᩃᩮ [ᨡᨱ᩠ᨯᩮ (ᩈᩦ. ᨸᩦ.)] ᨠᩁᩥᨲ᩠ᩅᩣᨶ, ᩋᩉᨾᩮᨲᩴ ᨸᨽᩣᩅᨲᩥᩴ;

ᨡᨲ᩠ᨲᩥᨿᩣᨶᩴ ᨸᨴᩔᩣᨾᩥ, ᨿᩮ ᨾᩴ ᩉᨶ᩠ᨲᩩᩴ ᩍᨵᩣᨣᨲᩣ’’.

᪓᪖.

‘‘ᩋᩅᩩᨭ᩠ᨮᩉᩥ ᩁᩣᨩᨸᩩᨲ᩠ᨲᩦ, ᩈᩣᨾᩣ ᨠᩮᩣᩈᩮᨿ᩠ᨿᩅᩣᩈᩥᨶᩦ;

ᩋᩔᩩᨸᩩᨱ᩠ᨱᩮᩉᩥ ᨶᩮᨲ᩠ᨲᩮᩉᩥ, ᨴᩣᩈᩦᨣᨱᨸᩩᩁᨠ᩠ᨡᨲᩣ’’.

᪓᪗.

‘‘ᨲᩴ ᨶᩪᨶ ᨠᨠ᩠ᨠᩪᨸᨶᩥᩈᩮᩅᩥᨲᩴ ᨾᩩᨡᩴ, ᩌᨴᩣᩈᨴᨶ᩠ᨲᩣᨳᩁᩩᨸᨧ᩠ᨧᩅᩮᨠ᩠ᨡᩥᨲᩴ;

ᩈᩩᨽᩴ ᩈᩩᨶᩮᨲ᩠ᨲᩴ ᩅᩥᩁᨩᩴ ᩋᨶᨦ᩠ᨣᨱᩴ, ᨨᩩᨴ᩠ᨵᩴ ᩅᨶᩮ ᨮᩔᨲᩥ ᨡᨲ᩠ᨲᩥᨿᩮᩉᩥ.

᪓᪘.

‘‘ᨲᩮ ᨶᩪᨶ ᨾᩮ ᩋᩈᩥᨲᩮ ᩅᩮᩃ᩠ᩃᩥᨲᨣ᩠ᨣᩮ, ᨠᩮᩈᩮ ᨾᩩᨴᩪ ᨧᨶ᩠ᨴᨶᩈᩣᩁᩃᩥᨲ᩠ᨲᩮ;

ᩈᨾᩣᨠᩩᩃᩮ ᩈᩦᩅᨳᩥᨠᩣᨿ ᨾᨩ᩠ᨫᩮ, ᨸᩣᨴᩮᩉᩥ ᨣᩥᨩ᩠ᨫᩣ ᨸᩁᩥᨠᨯ᩠ᨰᩥᩔᨶ᩠ᨲᩥ [ᨸᩁᩥᨠᨯ᩠ᨰᨿᨶ᩠ᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪓᪙.

‘‘ᨲᩣ ᨶᩪᨶ ᨾᩮ ᨲᨾ᩠ᨻᨶᨡᩣ ᩈᩩᩃᩮᩣᨾᩣ, ᨻᩣᩉᩣ ᨾᩩᨴᩪ ᨧᨶ᩠ᨴᨶᩈᩣᩁᩃᩥᨲ᩠ᨲᩣ;

ᨨᩥᨶ᩠ᨶᩣ ᩅᨶᩮ ᩏᨩ᩠ᨫᩥᨲᩣ ᨡᨲ᩠ᨲᩥᨿᩮᩉᩥ, ᨣᨿ᩠ᩉ ᨵᨦ᩠ᨠᩮᩣ [ᩅᨠᩮᩣ (ᨸᩦ.)] ᨣᨧ᩠ᨨᨲᩥ ᨿᩮᨶ ᨠᩣᨾᩴ.

᪔᪐.

‘‘ᨲᩮ ᨶᩪᨶ ᨲᩣᩃᩪᨸᨶᩥᨽᩮ ᩋᩃᨾ᩠ᨻᩮ, ᨶᩥᩈᩮᩅᩥᨲᩮ ᨠᩣᩈᩥᨠᨧᨶ᩠ᨴᨶᩮᨶ;

ᨳᨶᩮᩈᩩ ᨾᩮ ᩃᨾ᩠ᨻᩥᩔᨲᩥ [ᩃᨾ᩠ᨻᩉᩦᨲᩥ (ᨸᩦ.)] ᩈᩥᨦ᩠ᨣᩣᩃᩮᩣ [ᩈᩥᨣᩣᩃᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨾᩣᨲᩪᩅ ᨸᩩᨲ᩠ᨲᩮᩣ ᨲᩁᩩᨱᩮᩣ ᨲᨶᩪᨩᩮᩣ.

᪔᪑.

‘‘ᨲᩴ ¶ ᨶᩪᨶ ᩈᩮᩣᨱᩥᩴ ᨸᩩᨳᩩᩃᩴ ᩈᩩᨠᩮᩣᨭ᩠ᨭᩥᨲᩴ, ᨶᩥᩈᩮᩅᩥᨲᩴ ᨠᨬ᩠ᨧᨶᨾᩮᨡᩃᩣᩉᩥ;

ᨨᩥᨶ᩠ᨶᩴ ᩅᨶᩮ ᨡᨲ᩠ᨲᩥᨿᩮᩉᩦ ᩋᩅᨲ᩠ᨳᩴ, ᩈᩥᨦ᩠ᨣᩣᩃᩈᨦ᩠ᨥᩣ ᨸᩁᩥᨠᨯ᩠ᨰᩥᩔᨶ᩠ᨲᩥ [ᨣᨿ᩠ᩉᩣ ᩅᨠᩮᩣ ᨣᨧ᩠ᨨᨲᩥ ᨿᩮᨶᨠᩣᨾᩴ (ᨸᩦ.)].

᪔᪒.

‘‘ᩈᩮᩣᨱᩣ ¶ ¶ ᨵᨦ᩠ᨠᩣ [ᩅᨠᩣ (ᨸᩦ.)] ᩈᩥᨦ᩠ᨣᩣᩃᩣ ᨧ, ᨿᩮ ᨧᨬ᩠ᨬᩮ ᩈᨶ᩠ᨲᩥ ᨴᩣᨮᩥᨶᩮᩣ;

ᩋᨩᩁᩣ ᨶᩪᨶ ᩉᩮᩔᨶ᩠ᨲᩥ, ᨽᨠ᩠ᨡᨿᩥᨲ᩠ᩅᩣ ᨸᨽᩣᩅᨲᩥᩴ.

᪔᪓.

‘‘ᩈᨧᩮ ᨾᩴᩈᩣᨶᩥ ᩉᩁᩥᩴᩈᩩ, ᨡᨲ᩠ᨲᩥᨿᩣ ᨴᩪᩁᨣᩣᨾᩥᨶᩮᩣ;

ᩋᨭ᩠ᨮᩦᨶᩥ ᩋᨾ᩠ᨾ ᨿᩣᨧᩥᨲ᩠ᩅᩣ, ᩋᨶᩩᨸᨳᩮ ᨴᩉᩣᨳ ᨶᩴ.

᪔᪔.

‘‘ᨡᩮᨲ᩠ᨲᩣᨶᩥ ᩋᨾ᩠ᨾ ᨠᩣᩁᩮᨲ᩠ᩅᩣ, ᨠᨱᩥᨠᩣᩁᩮᨲ᩠ᨳ ᩁᩮᩣᨸᨿ [ᩁᩮᩣᨸᨿᩮ (ᨠ.)];

ᨿᨴᩣ ᨲᩮ ᨸᩩᨸ᩠ᨹᩥᨲᩣ ᩋᩔᩩ, ᩉᩮᨾᨶ᩠ᨲᩣᨶᩴ ᩉᩥᨾᨧ᩠ᨧᨿᩮ;

ᩈᩁᩮᨿ᩠ᨿᩣᨳ ᨾᨾᩴ [ᨾᨾ (ᨸᩦ.)] ᩋᨾ᩠ᨾ, ᩑᩅᩴᩅᨱ᩠ᨱᩣ ᨸᨽᩣᩅᨲᩦ’’.

᪔᪕.

‘‘ᨲᩔᩣ ᨾᩣᨲᩣ ᩏᨴᨭ᩠ᨮᩣᩈᩥ, ᨡᨲ᩠ᨲᩥᨿᩣ ᨴᩮᩅᩅᨱ᩠ᨱᩥᨶᩦ;

ᨴᩥᩈ᩠ᩅᩣ ᩋᩈᩥᨬ᩠ᨧ ᩈᩪᨶᨬ᩠ᨧ, ᩁᨬ᩠ᨬᩮᩣ ᨾᨴ᩠ᨴᩔᨶ᩠ᨲᩮᨸᩩᩁᩮ’’.

᪔᪖.

‘‘ᩍᨾᩥᨶᩣ ᨶᩪᨶ ᩋᩈᩥᨶᩣ, ᩈᩩᩈᨬ᩠ᨬᩴ ᨲᨶᩩᨾᨩ᩠ᨫᩥᨾᩴ;

ᨵᩦᨲᩁᩴ ᨾᨴ᩠ᨴ [ᨾᨾ (ᩈᩦ.), ᨾᨴ᩠ᨴᩮᩣ (ᨸᩦ.)] ᩉᨶ᩠ᨲ᩠ᩅᩣᨶ, ᨡᨲ᩠ᨲᩥᨿᩣᨶᩴ ᨸᨴᩔᩈᩥ’’ [ᨸᨴᩔᨲᩥ (ᨸᩦ. ᨠ.)].

᪔᪗.

‘‘ᨶ ᨾᩮ ᩋᨠᩣᩈᩥ ᩅᨧᨶᩴ, ᩋᨲ᩠ᨳᨠᩣᨾᩣᨿ ᨸᩩᨲ᩠ᨲᩥᨠᩮ;

ᩈᩣᨩ᩠ᨩ ᩃᩮᩣᩉᩥᨲᩈᨬ᩠ᨨᨶ᩠ᨶᩣ, ᨣᨧ᩠ᨨᩈᩥ [ᨣᨬ᩠ᨨᩥᩈᩥ (ᩈᩦ. ᨸᩦ.)] ᨿᨾᩈᩣᨵᨶᩴ.

᪔᪘.

‘‘ᩑᩅᨾᩣᨸᨩ᩠ᨩᨲᩦ ᨸᩮᩣᩈᩮᩣ, ᨸᩣᨸᩥᨿᨬ᩠ᨧ ᨶᩥᨣᨧ᩠ᨨᨲᩥ;

ᨿᩮᩣ ᩅᩮ ᩉᩥᨲᩣᨶᩴ ᩅᨧᨶᩴ, ᨶ ᨠᩁᩮᩣᨲᩥ [ᨶ ᨠᩁᩴ (ᩈᩦ.)] ᩋᨲ᩠ᨳᨴᩔᩥᨶᩴ.

᪔᪙.

‘‘ᩈᨧᩮ ᨧ ᩋᨩ᩠ᨩ [ᨲ᩠ᩅᩴ ᩋᨾ᩠ᨾ (ᩈᩦ.)] ᨵᩣᩁᩮᩈᩥ [ᩅᩣᩁᩮᩈᩥ (ᨸᩦ.)], ᨠᩩᨾᩣᩁᩴ ᨧᩣᩁᩩᨴᩔᨶᩴ;

ᨠᩩᩈᩮᨶ ¶ ᨩᩣᨲᩴ ᨡᨲ᩠ᨲᩥᨿᩴ, ᩈᩩᩅᨱ᩠ᨱᨾᨱᩥᨾᩮᨡᩃᩴ;

ᨸᩪᨩᩥᨲᩴ [ᨸᩪᨩᩥᨲᩣ (ᨸᩦ.)] ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᩉᩥ, ᨶ ᨣᨧ᩠ᨨᩈᩥ [ᨣᨬ᩠ᨨᩥᩈᩥ (ᩈᩦ. ᨸᩦ.)] ᨿᨾᨠ᩠ᨡᨿᩴ.

᪕᪐.

‘‘ᨿᨲ᩠ᨳᩔᩩ ᨽᩮᩁᩦ ᨶᨴᨲᩥ, ᨠᩩᨬ᩠ᨩᩁᩮᩣ ᨧ ᨶᩥᨠᩪᨩᨲᩥ [ᨶᩥᨠᩩᨬ᩠ᨩᨲᩥ (ᨸᩦ.)];

ᨡᨲ᩠ᨲᩥᨿᩣᨶᩴ ᨠᩩᩃᩮ ᨽᨴ᩠ᨴᩮ, ᨠᩥᩴ ᨶᩩ ᩈᩩᨡᨲᩁᩴ ᨲᨲᩮᩣ.

᪕᪑.

‘‘ᩋᩔᩮᩣ ᨧ ᩈᩥᩈᨲᩥ [ᩋᩔᩮᩣ ᩉᩈᩥᩈᨲᩥ (ᩈᩦ.), ᩋᩔᩮᩣ ᩉᩈᩥᨿᨲᩥ (ᩈ᩠ᨿᩣ.), ᩋᩔᩮᩣ ᨧ ᩈᩥᩴᩈᨲᩥ (ᨸᩦ.)] ᨴ᩠ᩅᩣᩁᩮ, ᨠᩩᨾᩣᩁᩮᩣ ᩏᨸᩁᩮᩣᨴᨲᩥ;

ᨡᨲ᩠ᨲᩥᨿᩣᨶᩴ ᨠᩩᩃᩮ ᨽᨴ᩠ᨴᩮ, ᨠᩥᩴ ᨶᩩ ᩈᩩᨡᨲᩁᩴ ᨲᨲᩮᩣ.

᪕᪒.

‘‘ᨾᨿᩪᩁᨠᩮᩣᨬ᩠ᨧᩣᨽᩥᩁᩩᨴᩮ, ᨠᩮᩣᨠᩥᩃᩣᨽᩥᨶᩥᨠᩪᨩᩥᨲᩮ;

ᨡᨲ᩠ᨲᩥᨿᩣᨶᩴ ᨠᩩᩃᩮ ᨽᨴ᩠ᨴᩮ, ᨠᩥᩴ ᨶᩩ ᩈᩩᨡᨲᩁᩴ ᨲᨲᩮᩣ’’.

᪕᪓.

‘‘ᨠᩉᩴ ¶ ᨶᩩ ᩈᩮᩣ ᩈᨲ᩠ᨲᩩᨾᨴ᩠ᨴᨶᩮᩣ, ᨸᩁᩁᨭ᩠ᨮᨸ᩠ᨸᨾᨴ᩠ᨴᨶᩮᩣ;

ᨠᩩᩈᩮᩣ ᩈᩮᩣᩊᩣᩁᨸᨬ᩠ᨬᩣᨱᩮᩣ, ᨿᩮᩣ ᨶᩮᩣ ᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩮᩣᨧᨿᩮ’’.

᪕᪔.

‘‘ᩍᨵᩮᩅ ᩈᩮᩣ ᩈᨲ᩠ᨲᩩᨾᨴ᩠ᨴᨶᩮᩣ, ᨸᩁᩁᨭ᩠ᨮᨸ᩠ᨸᨾᨴ᩠ᨴᨶᩮᩣ;

ᨠᩩᩈᩮᩣ ᩈᩮᩣᩊᩣᩁᨸᨬ᩠ᨬᩣᨱᩮᩣ, ᨿᩮᩣ ᨲᩮ ᩈᨻ᩠ᨻᩮ ᩅᨵᩥᩔᨲᩥ’’ [ᨿᩮᩣ ᨶᩮᩣ ᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩮᩣᨧᨿᩮ (ᩈᩦ.), ᩈᩮᩣ ᨶᩮᩣ ᩈᨻ᩠ᨻᩮ ᩅᨵᩥᩔᨲᩥ (ᨸᩦ.)].

᪕᪕.

‘‘ᩏᨾ᩠ᨾᨲ᩠ᨲᩥᨠᩣ ᨶᩩ ᨽᨱᩈᩥ, ᩋᨶ᩠ᨵᨻᩣᩃᩣ ᨸᨽᩣᩈᩈᩥ [ᩌᨴᩩ ᨻᩣᩃᩣᩅ ᨽᩣᩈᩈᩥ (ᩈᩦ. ᨸᩦ.)];

ᨠᩩᩈᩮᩣ ᨧᩮ ᩌᨣᨲᩮᩣ ᩋᩔ, ᨠᩥᩴ ᨶ [ᨠᩥᨶ᩠ᨶᩩ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨩᩣᨶᩮᨾᩩ ᨲᩴ ᨾᨿᩴ’’.

᪕᪖.

‘‘ᩑᩈᩮᩣ ¶ ᩌᩊᩣᩁᩥᨠᩮᩣ ᨸᩮᩣᩈᩮᩣ, ᨠᩩᨾᩣᩁᩦᨸᩩᩁᨾᨶ᩠ᨲᩁᩮ;

ᨴᩊ᩠ᩉᩴ ᨠᨲ᩠ᩅᩣᨶ ᩈᩴᩅᩮᩃ᩠ᩃᩥᩴ, ᨠᩩᨾ᩠ᨽᩥᩴ ᨵᩮᩣᩅᨲᩥ ᩒᨱᨲᩮᩣ’’.

᪕᪗.

‘‘ᩅᩮᨱᩦ ᨲ᩠ᩅᨾᩈᩥ ᨧᨱ᩠ᨯᩣᩃᩦ, ᩋᨴᩪᩈᩥ ᨠᩩᩃᨣᨶ᩠ᨵᩥᨶᩦ;

ᨠᨳᩴ ᨾᨴ᩠ᨴᨠᩩᩃᩮ ᨩᩣᨲᩣ, ᨴᩣᩈᩴ ᨠᨿᩥᩁᩣᩈᩥ ᨠᩣᨾᩩᨠᩴ’’.

᪕᪘.

‘‘ᨶᨾ᩠ᩉᩥ ᩅᩮᨱᩦ ᨶ ᨧᨱ᩠ᨯᩣᩃᩦ, ᨶ ᨧᨾ᩠ᩉᩥ ᨠᩩᩃᨣᨶ᩠ᨵᩥᨶᩦ;

ᩒᨠ᩠ᨠᩣᨠᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨲ᩠ᩅᩴ ᨶᩩ ᨴᩣᩈᩮᩣᨲᩥ ᨾᨬ᩠ᨬᩈᩥ’’.

᪕᪙.

‘‘ᨿᩮᩣ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩈᩉᩔᩣᨶᩥ, ᩈᨴᩣ ᨽᩮᩣᨩᩮᨲᩥ ᩅᩦᩈᨲᩥᩴ;

ᩒᨠ᩠ᨠᩣᨠᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨲ᩠ᩅᩴ ᨶᩩ ᨴᩣᩈᩮᩣᨲᩥ ᨾᨬ᩠ᨬᩈᩥ’’.

᪖᪐.

‘‘ᨿᩔ ᨶᩣᨣᩈᩉᩔᩣᨶᩥ, ᩈᨴᩣ ᨿᩮᩣᨩᩮᨶ᩠ᨲᩥ ᩅᩦᩈᨲᩥᩴ;

ᩒᨠ᩠ᨠᩣᨠᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨲ᩠ᩅᩴ ᨶᩩ ᨴᩣᩈᩮᩣᨲᩥ ᨾᨬ᩠ᨬᩈᩥ.

᪖᪑.

‘‘ᨿᩔ ᩋᩔᩈᩉᩔᩣᨶᩥ, ᩈᨴᩣ ᨿᩮᩣᨩᩮᨶ᩠ᨲᩥ ᩅᩦᩈᨲᩥᩴ;

ᩒᨠ᩠ᨠᩣᨠᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨲ᩠ᩅᩴ ᨶᩩ ᨴᩣᩈᩮᩣᨲᩥ ᨾᨬ᩠ᨬᩈᩥ.

᪖᪒.

‘‘ᨿᩔ ᩁᨳᩈᩉᩔᩣᨶᩥ, ᩈᨴᩣ ᨿᩮᩣᨩᩮᨶ᩠ᨲᩥ ᩅᩦᩈᨲᩥᩴ;

ᩒᨠ᩠ᨠᩣᨠᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨲ᩠ᩅᩴ ᨶᩩ ᨴᩣᩈᩮᩣᨲᩥ ᨾᨬ᩠ᨬᩈᩥ.

[( ) ᩋᨿᩴ ᨣᩣᨳᩣ ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩᨿᩮᩅ ᨴᩥᩔᨲᩥ] (‘‘ᨿᩔ ᩏᩈᨽᩈᩉᩔᩣᨶᩥ, ᩈᨴᩣ ᨿᩮᩣᨩᩮᨶ᩠ᨲᩥ ᩅᩦᩈᨲᩥᩴ;

ᩒᨠ᩠ᨠᩣᨠᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨲ᩠ᩅᩴ ᨶᩩ ᨴᩣᩈᩮᩣᨲᩥ ᨾᨬ᩠ᨬᩈᩥ) [( ) ᩋᨿᩴ ᨣᩣᨳᩣ ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩᨿᩮᩅ ᨴᩥᩔᨲᩥ].

᪖᪓.

‘‘ᨿᩔ ᨵᩮᨶᩩᩈᩉᩔᩣᨶᩥ, ᩈᨴᩣ ᨴᩩᩉᨶ᩠ᨲᩥ ᩅᩦᩈᨲᩥᩴ [ᨴᩩᨿ᩠ᩉᨶ᩠ᨲᩥ ᩅᩦᩈᨲᩥ (ᩈᩦ. ᨸᩦ.)];

ᩒᨠ᩠ᨠᩣᨠᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨲ᩠ᩅᩴ ᨶᩩ ᨴᩣᩈᩮᩣᨲᩥ ᨾᨬ᩠ᨬᩈᩥ’’.

᪖᪔.

‘‘ᨲᨣ᩠ᨥ ¶ ᨲᩮ ᨴᩩᨠ᩠ᨠᨭᩴ ᨻᩣᩃᩮ, ᨿᩴ ᨡᨲ᩠ᨲᩥᨿᩴ ᨾᩉᨻ᩠ᨻᩃᩴ;

ᨶᩣᨣᩴ ᨾᨱ᩠ᨯᩪᨠᩅᨱ᩠ᨱᩮᨶ, ᨶ ᨶᩴ [ᨶ ᨲᩴ (ᩈᩦ. ᨸᩦ.)] ᩋᨠ᩠ᨡᩣᩈᩥᨵᩣᨣᨲᩴ’’ [ᩋᨠ᩠ᨡᩣᩈᩥ ᩌᨣᨲᩴ (ᩈᩦ.)].

᪖᪕.

‘‘ᩋᨸᩁᩣᨵᩴ ᨾᩉᩣᩁᩣᨩ, ᨲ᩠ᩅᩴ ᨶᩮᩣ ᨡᨾ ᩁᨳᩮᩈᨽ;

ᨿᩴ ᨲᩴ ᩋᨬ᩠ᨬᩣᨲᩅᩮᩈᩮᨶ, ᨶᩣᨬ᩠ᨬᩣᩈᩥᨾ᩠ᩉᩣ ᩍᨵᩣᨣᨲᩴ’’.

᪖᪖.

‘‘ᨾᩣᨴᩥᩈᩔ ᨶ ᨲᩴ ᨨᨶ᩠ᨶᩴ, ᨿᩮᩣᩉᩴ ᩌᩊᩣᩁᩥᨠᩮᩣ ᨽᩅᩮ;

ᨲ᩠ᩅᨬ᩠ᨬᩮᩅ ᨾᩮ ᨸᩈᩦᨴᩔᩩ, ᨶᨲ᩠ᨳᩥ ᨲᩮ ᨴᩮᩅ ᨴᩩᨠ᩠ᨠᨭᩴ’’.

᪖᪗.

‘‘ᨣᨧ᩠ᨨ ᨻᩣᩃᩮ ᨡᨾᩣᨸᩮᩉᩥ, ᨠᩩᩈᩁᩣᨩᩴ ᨾᩉᨻ᩠ᨻᩃᩴ;

ᨡᨾᩣᨸᩥᨲᩮᩣ ᨠᩩᩈᩮᩣ ᩁᩣᨩᩣ [ᨠᩩᩈᩁᩣᨩᩣ (ᩈᨻ᩠ᨻᨲ᩠ᨳ)], ᩈᩮᩣ ᨲᩮ ᨴᩔᨲᩥ ᨩᩦᩅᩥᨲᩴ’’.

᪖᪘.

‘‘ᨸᩥᨲᩩᩔ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨴᩮᩅᩅᨱ᩠ᨱᩦ ᨸᨽᩣᩅᨲᩦ;

ᩈᩥᩁᩈᩣ ᩋᨣ᩠ᨣᩉᩦ ᨸᩣᨴᩮ, ᨠᩩᩈᩁᩣᨩᩴ ᨾᩉᨻ᩠ᨻᩃᩴ’’.

᪖᪙.

‘‘ᨿᩣᨾᩣ ¶ ᩁᨲ᩠ᨿᩮᩣ ᩋᨲᩥᨠ᩠ᨠᨶ᩠ᨲᩣ, ᨲᩣᨾᩣ ᨴᩮᩅ ᨲᨿᩣ ᩅᩥᨶᩣ;

ᩅᨶ᩠ᨴᩮ ᨲᩮ ᩈᩥᩁᩈᩣ ᨸᩣᨴᩮ, ᨾᩣ ᨾᩮ ᨠᩩᨩ᩠ᨫᩴ ᩁᨳᩮᩈᨽ.

᪗᪐.

‘‘ᩈᨻ᩠ᨻᩴ ¶ [ᩈᨧ᩠ᨧᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨲᩮ ᨸᨭᩥᨩᩣᨶᩣᨾᩥ, ᨾᩉᩣᩁᩣᨩ ᩈᩩᨱᩮᩣᩉᩥ ᨾᩮ;

ᨶ ᨧᩣᨸᩥ ᩋᨸ᩠ᨸᩥᨿᩴ ᨲᩩᨿ᩠ᩉᩴ, ᨠᩁᩮᨿ᩠ᨿᩣᨾᩥ ᩋᩉᩴ ᨸᩩᨶ.

᪗᪑.

‘‘ᩑᩅᩴ ᨧᩮ ᨿᩣᨧᨾᩣᨶᩣᨿ, ᩅᨧᨶᩴ ᨾᩮ ᨶ ᨠᩣᩉᩈᩥ;

ᩍᨴᩣᨶᩥ ᨾᩴ ᨲᩣᨲᩮᩣ ᩉᨶ᩠ᨲ᩠ᩅᩣ, ᨡᨲ᩠ᨲᩥᨿᩣᨶᩴ ᨸᨴᩔᨲᩥ’’.

᪗᪒.

‘‘ᩑᩅᩴ ᨲᩮ ᨿᩣᨧᨾᩣᨶᩣᨿ, ᨠᩥᩴ ᨶ ᨠᩣᩉᩣᨾᩥ ᨲᩮ ᩅᨧᩮᩣ;

ᩅᩥᨠᩩᨴ᩠ᨵᩮᩣ ᨲ᩠ᨿᩈ᩠ᨾᩥ ᨠᩃ᩠ᨿᩣᨱᩥ, ᨾᩣ ᨲ᩠ᩅᩴ ᨽᩣᨿᩥ ᨸᨽᩣᩅᨲᩥ.

᪗᪓.

‘‘ᩈᨻ᩠ᨻᩴ ᨲᩮ ᨸᨭᩥᨩᩣᨶᩣᨾᩥ, ᩁᩣᨩᨸᩩᨲ᩠ᨲᩥ ᩈᩩᨱᩮᩣᩉᩥ ᨾᩮ;

ᨶ ᨧᩣᨸᩥ ᩋᨸ᩠ᨸᩥᨿᩴ ᨲᩩᨿ᩠ᩉᩴ, ᨠᩁᩮᨿ᩠ᨿᩣᨾᩥ ᩋᩉᩴ ᨸᩩᨶ.

᪗᪔.

‘‘ᨲᩅ ᨠᩣᨾᩣ ᩉᩥ ᩈᩩᩔᩮᩣᨱᩥ, ᨸᩉᩩ [ᨻᩉᩩ (ᩈ᩠ᨿᩣ.), ᨻᩉᩪ (ᨸᩦ.), ᨻᩉᩩᩴ (ᨠ.)] ᨴᩩᨠ᩠ᨡᩴ ᨲᩥᨲᩥᨠ᩠ᨡᩥᩈᩴ [ᨲᩥᨲᩥᨠ᩠ᨡᩥᩔᩴ (ᩈᩦ. ᨸᩦ.)];

ᨻᩉᩩᩴ ᨾᨴ᩠ᨴᨠᩩᩃᩴ ᩉᨶ᩠ᨲ᩠ᩅᩣ, ᨶᨿᩥᨲᩩᩴ ᨲᩴ ᨸᨽᩣᩅᨲᩥ’’.

᪗᪕.

‘‘ᨿᩮᩣᨩᨿᨶ᩠ᨲᩩ ᩁᨳᩮ ᩋᩔᩮ, ᨶᩣᨶᩣᨧᩥᨲ᩠ᨲᩮ ᩈᨾᩣᩉᩥᨲᩮ;

ᩋᨳ ᨴᨠ᩠ᨡᨳ ᨾᩮ ᩅᩮᨣᩴ, ᩅᩥᨵᨾᨶ᩠ᨲᩔ [ᩅᩥᨵᨾᩮᨶ᩠ᨲᩔ (ᩈᨻ᩠ᨻᨲ᩠ᨳ)] ᩈᨲ᩠ᨲᩅᩮᩣ’’.

᪗᪖.

‘‘ᨲᨬ᩠ᨧ ᨲᨲ᩠ᨳ ᩏᨴᩥᨠ᩠ᨡᩥᩴᩈᩩ, ᩁᨬ᩠ᨬᩮᩣ ᨾᨴ᩠ᨴᩔᨶ᩠ᨲᩮᨸᩩᩁᩮ;

ᩅᩥᨩᨾ᩠ᨽᨾᩣᨶᩴ ᩈᩦᩉᩴᩅ, ᨹᩮᩣᨭᩮᨶ᩠ᨲᩴ ᨴᩥᨣᩩᨱᩴ ᨽᩩᨩᩴ.

᪗᪗.

‘‘ᩉᨲ᩠ᨳᩥᨠ᩠ᨡᨶ᩠ᨵᨬ᩠ᨧ ¶ ᩌᩁᩩᨿ᩠ᩉ, ᩌᩁᩮᩣᨸᩮᨲ᩠ᩅᩣ ᨸᨽᩣᩅᨲᩥᩴ;

ᩈᨦ᩠ᨣᩣᨾᩴ ᩒᨲᩁᩥᨲ᩠ᩅᩣᨶ, ᩈᩦᩉᨶᩣᨴᩴ ᨶᨴᩦ ᨠᩩᩈᩮᩣ.

᪗᪘.

‘‘ᨲᩔ ᨲᩴ ᨶᨴᨲᩮᩣ ᩈᩩᨲ᩠ᩅᩣ, ᩈᩦᩉᩔᩮᩅᩥᨲᩁᩮ ᨾᩥᨣᩣ;

ᨡᨲ᩠ᨲᩥᨿᩣ ¶ ᩅᩥᨸᩃᩣᨿᩥᩴᩈᩩ, ᨠᩩᩈᩈᨴ᩠ᨴᨽᨿᨭ᩠ᨭᩥᨲᩣ [ᨠᩩᩈᩈᨴ᩠ᨴᨽᨿᨭ᩠ᨮᩥᨲᩣ (ᨸᩦ.)].

᪗᪙.

‘‘ᩉᨲ᩠ᨳᩣᩁᩮᩣᩉᩣ ᩋᨶᩦᨠᨭ᩠ᨮᩣ, ᩁᨳᩥᨠᩣ ᨸᨲ᩠ᨲᩥᨠᩣᩁᨠᩣ;

ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩔ ᨨᩥᨶ᩠ᨴᨶ᩠ᨲᩥ, ᨠᩩᩈᩈᨴ᩠ᨴᨽᨿᨭ᩠ᨭᩥᨲᩣ.

᪘᪐.

‘‘ᨲᩈ᩠ᨾᩥᩴ ᩈᨦ᩠ᨣᩣᨾᩈᩦᩈᩈ᩠ᨾᩥᩴ, ᨸᩔᩥᨲ᩠ᩅᩣ ᩉᨭ᩠ᨮ [ᨲᩩᨭ᩠ᨮ (ᩈᩦ.)] ᨾᩣᨶᩈᩮᩣ;

ᨠᩩᩈᩔ ᩁᨬ᩠ᨬᩮᩣ ᨴᩮᩅᩥᨶ᩠ᨴᩮᩣ, ᩋᨴᩣ ᩅᩮᩁᩮᩣᨧᨶᩴ ᨾᨱᩥᩴ.

᪘᪑.

‘‘ᩈᩮᩣ ᨲᩴ ᩅᩥᨩᩥᨲ᩠ᩅᩣ ᩈᨦ᩠ᨣᩣᨾᩴ, ᩃᨴ᩠ᨵᩣ ᩅᩮᩁᩮᩣᨧᨶᩴ ᨾᨱᩥᩴ;

ᩉᨲ᩠ᨳᩥᨠ᩠ᨡᨶ᩠ᨵᨣᨲᩮᩣ ᩁᩣᨩᩣ, ᨸᩣᩅᩮᨠ᩠ᨡᩥ ᨶᨣᩁᩴ ᨸᩩᩁᩴ.

᪘᪒.

‘‘ᨩᩦᩅᨣ᩠ᨣᩣᩉᩴ [ᨩᩦᩅᨣᩣᩉᩴ (ᩈᩦ. ᨸᩦ.)] ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᨻᨶ᩠ᨵᩥᨲ᩠ᩅᩣ ᩈᨲ᩠ᨲ ᨡᨲ᩠ᨲᩥᨿᩮ;

ᩈᩈᩩᩁᩔᩩᨸᨶᩣᨾᩮᩈᩥ, ᩍᨾᩮ ᨲᩮ ᨴᩮᩅ ᩈᨲ᩠ᨲᩅᩮᩣ.

᪘᪓.

‘‘ᩈᨻ᩠ᨻᩮᩅ ᨲᩮ ᩅᩈᩴ ᨣᨲᩣ, ᩋᨾᩥᨲ᩠ᨲᩣ ᩅᩥᩉᨲᩣ ᨲᩅ;

ᨠᩣᨾᩴ ᨠᩁᩮᩣᩉᩥ ᨲᩮ ᨲᨿᩣ, ᨾᩩᨬ᩠ᨧ ᩅᩣ ᨲᩮ ᩉᨶᩔᩩ ᩅᩣ’’.

᪘᪔.

‘‘ᨲᩩᨿ᩠ᩉᩮᩅ ᩈᨲ᩠ᨲᩅᩮᩣ ᩑᨲᩮ, ᨶ ᩉᩥ ᨲᩮ ᨾᨿ᩠ᩉ ᩈᨲ᩠ᨲᩅᩮᩣ;

ᨲ᩠ᩅᨬ᩠ᨬᩮᩅ ᨶᩮᩣ ᨾᩉᩣᩁᩣᨩ, ᨾᩩᨬ᩠ᨧ ᩅᩣ ᨲᩮ ᩉᨶᩔᩩ ᩅᩣ’’.

᪘᪕.

‘‘ᩍᨾᩣ ¶ ᨲᩮ ᨵᩦᨲᩁᩮᩣ ᩈᨲ᩠ᨲ, ᨴᩮᩅᨠᨬ᩠ᨬᩪᨸᨾᩣ ᩈᩩᨽᩣ;

ᨴᨴᩣᩉᩥ ᨶᩮᩈᩴ ᩑᨠᩮᨠᩴ, ᩉᩮᩣᨶ᩠ᨲᩩ ᨩᩣᨾᩣᨲᩁᩮᩣ ᨲᩅ’’.

᪘᪖.

‘‘ᩋᨾ᩠ᩉᩣᨠᨬ᩠ᨧᩮᩅ ᨲᩣᩈᨬ᩠ᨧ, ᨲ᩠ᩅᩴ ᨶᩮᩣ ᩈᨻ᩠ᨻᩮᩈᨾᩥᩔᩁᩮᩣ;

ᨲ᩠ᩅᨬ᩠ᨬᩮᩅ ᨶᩮᩣ ᨾᩉᩣᩁᩣᨩ, ᨴᩮᩉᩥ ᨶᩮᩈᩴ ᨿᨴᩥᨧ᩠ᨨᩈᩥ’’.

᪘᪗.

‘‘ᩑᨠᨾᩮᨠᩔ ᩑᨠᩮᨠᩴ, ᩋᨴᩣ ᩈᩦᩉᩔᩁᩮᩣ ᨠᩩᩈᩮᩣ;

ᨡᨲ᩠ᨲᩥᨿᩣᨶᩴ ᨲᨴᩣ ᨲᩮᩈᩴ, ᩁᨬ᩠ᨬᩮᩣ ᨾᨴ᩠ᨴᩔ ᨵᩦᨲᩁᩮᩣ.

᪘᪘.

‘‘ᨸᩦᨱᩥᨲᩣ ᨲᩮᨶ ᩃᩣᨽᩮᨶ, ᨲᩩᨭ᩠ᨮᩣ ᩈᩦᩉᩔᩁᩮ ᨠᩩᩈᩮ;

ᩈᨠᩁᨭ᩠ᨮᩣᨶᩥ ¶ ᨸᩣᨿᩥᩴᩈᩩ, ᨡᨲ᩠ᨲᩥᨿᩣ ᩈᨲ᩠ᨲ ᨲᩣᩅᨴᩮ.

᪘᪙.

‘‘ᨸᨽᩣᩅᨲᩥᨬ᩠ᨧ ᩌᨴᩣᨿ, ᨾᨱᩥᩴ ᩅᩮᩁᩮᩣᨧᨶᩴ ᩈᩩᨽᩴ [ᨲᨴᩣ (ᨸᩦ.)];

ᨠᩩᩈᩣᩅᨲᩥᩴ ᨠᩩᩈᩮᩣ ᩁᩣᨩᩣ, ᩋᨣᨾᩣᩈᩥ ᨾᩉᨻ᩠ᨻᩃᩮᩣ.

᪙᪐.

‘‘ᨲ᩠ᨿᩔᩩ ¶ ᩑᨠᩁᨳᩮ ᨿᨶ᩠ᨲᩣ, ᨸᩅᩥᩈᨶ᩠ᨲᩣ ᨠᩩᩈᩣᩅᨲᩥᩴ;

ᩈᨾᩣᨶᩣ ᩅᨱ᩠ᨱᩁᩪᨸᩮᨶ, ᨶᩣᨬ᩠ᨬᨾᨬ᩠ᨬᩣᨲᩥᩁᩮᩣᨧᩥᩈᩩᩴ [ᨶᩣᨬ᩠ᨬᨾᨬ᩠ᨬᨾᨲᩥᩁᩮᩣᨧᨿᩩᩴ (ᩈᩦ.)].

᪙᪑.

‘‘ᨾᩣᨲᩣ ᨸᩩᨲ᩠ᨲᩮᨶ ᩈᨦ᩠ᨣᨧ᩠ᨨᩥ [ᩈᨦ᩠ᨣᨬ᩠ᨨᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩏᨽᨿᩮᩣ ᨧ ᨩᨿᨾ᩠ᨸᨲᩦ;

ᩈᨾᨣ᩠ᨣᩣ ᨲᩮ ᨲᨴᩣ ᩌᩈᩩᩴ, ᨹᩦᨲᩴ ᨵᩁᨱᩥᨾᩣᩅᩈᩩ’’ᨶ᩠ᨲᩥ.

ᨠᩩᩈᨩᩣᨲᨠᩴ ᨸᨮᨾᩴ.

᪕᪓᪒. ᩈᩮᩣᨱᨶᨶ᩠ᨴᨩᩣᨲᨠᩴ (᪒)

᪙᪒.

‘‘ᨴᩮᩅᨲᩣ ᨶᩩᩈᩥ ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ, ᩋᨴᩩ [ᩌᨴᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩈᨠ᩠ᨠᩮᩣ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ;

ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᩍᨴ᩠ᨵᩥᨾᩣ, ᨠᨳᩴ ᨩᩣᨶᩮᨾᩩ ᨲᩴ ᨾᨿᩴ’’.

᪙᪓.

‘‘ᨶᩣᨸᩥ ᨴᩮᩅᩮᩣ ᨶ ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ, ᨶᩣᨸᩥ ᩈᨠ᩠ᨠᩮᩣ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ;

ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᩍᨴ᩠ᨵᩥᨾᩣ, ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨽᩣᩁᨵ’’ [ᨽᩣᩁᨽ (ᨠ.)].

᪙᪔.

‘‘ᨠᨲᩁᩪᨸᨾᩥᨴᩴ ᨽᩮᩣᨲᩮᩣ [ᨽᩮᩣᨲᩮᩣ (ᩈᩦ. ᨸᩦ.)], ᩅᩮᨿ᩠ᨿᩣᩅᨧ᩠ᨧᩴ ᩋᨶᨸ᩠ᨸᨠᩴ;

ᨴᩮᩅᨾ᩠ᩉᩥ ᩅᩔᨾᩣᨶᨾ᩠ᩉᩥ, ᩋᨶᩮᩣᩅᩔᩴ ᨽᩅᩴ ᩋᨠᩣ.

᪙᪕.

‘‘ᨲᨲᩮᩣ ᩅᩣᨲᩣᨲᨸᩮ ᨥᩮᩣᩁᩮ, ᩈᩦᨲᨧ᩠ᨨᩣᨿᩴ ᨽᩅᩴ ᩋᨠᩣ;

ᨲᨲᩮᩣ ᩋᨾᩥᨲ᩠ᨲᨾᨩ᩠ᨫᩮᩈᩩ [ᩋᨾᩥᨲ᩠ᨲᨾᨩ᩠ᨫᩮ ᨧ (ᩈᩦ.)], ᩈᩁᨲᩣᨱᩴ ᨽᩅᩴ ᩋᨠᩣ.

᪙᪖.

‘‘ᨲᨲᩮᩣ ᨹᩦᨲᩣᨶᩥ ᩁᨭ᩠ᨮᩣᨶᩥ, ᩅᩈᩥᨶᩮᩣ ᨲᩮ ᨽᩅᩴ ᩋᨠᩣ;

ᨲᨲᩮᩣ ᩑᨠᩈᨲᩴ ᨡᨲ᩠ᨿᩮ, ᩋᨶᩩᨿᨶ᩠ᨲᩮ [ᩋᨶᩩᨿᩩᨲ᩠ᨲᩮ (ᨸᩦ.)] ᨽᩅᩴ ᩋᨠᩣ.

᪙᪗.

‘‘ᨸᨲᩦᨲᩣᩔᩩ ¶ ¶ ᨾᨿᩴ ᨽᩮᩣᨲᩮᩣ, ᩅᨴ ᨲᩴ [ᩅᩁ ᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨽᨬ᩠ᨩ [ᨽᨬ᩠ᨬ (ᩈᩦ. ᨸᩦ.), ᨽᩩᨬ᩠ᨩ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨾᩥᨧ᩠ᨨᩈᩥ;

ᩉᨲ᩠ᨳᩥᨿᩣᨶᩴ ᩋᩔᩁᨳᩴ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᩋᩃᨦ᩠ᨠᨲᩣ;

ᨶᩥᩅᩮᩈᨶᩣᨶᩥ ᩁᨾ᩠ᨾᩣᨶᩥ, ᨾᨿᩴ ᨽᩮᩣᨲᩮᩣ ᨴᨴᩣᨾᩈᩮ.

᪙᪘.

‘‘ᩋᨳ ᩅᨦ᩠ᨣᩮ [ᩋᨳ ᩅᩣ ᩈᨦ᩠ᨣᩮ (ᩈᩦ. ᨸᩦ.)] ᩅᩣ ᨾᨣᨵᩮ, ᨾᨿᩴ ᨽᩮᩣᨲᩮᩣ ᨴᨴᩣᨾᩈᩮ;

ᩋᨳ ᩅᩣ ᩋᩔᨠᩣᩅᨶ᩠ᨲᩦ [ᩋᩔᨠᩣᩅᨶ᩠ᨲᩥᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩈᩩᨾᨶᩣ ᨴᨾ᩠ᨾ ᨲᩮ ᨾᨿᩴ.

᪙᪙.

‘‘ᩏᨸᨯ᩠ᨰᩴ ᩅᩣᨸᩥ ᩁᨩ᩠ᨩᩔ, ᨾᨿᩴ ᨽᩮᩣᨲᩮᩣ ᨴᨴᩣᨾᩈᩮ;

ᩈᨧᩮ ᨲᩮ ᩋᨲ᩠ᨳᩮᩣ ᩁᨩ᩠ᨩᩮᨶ, ᩋᨶᩩᩈᩣᩈ ᨿᨴᩥᨧ᩠ᨨᩈᩥ’’.

᪑᪐᪐.

‘‘ᨶ ¶ ᨾᩮ ᩋᨲ᩠ᨳᩮᩣᨸᩥ ᩁᨩ᩠ᨩᩮᨶ, ᨶᨣᩁᩮᨶ ᨵᨶᩮᨶ ᩅᩣ;

ᩋᨳᩮᩣᨸᩥ ᨩᨶᨸᨴᩮᨶ, ᩋᨲ᩠ᨳᩮᩣ ᨾᨿ᩠ᩉᩴ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ.

᪑᪐᪑.

‘‘ᨽᩮᩣᨲᩮᩣᩅ ᩁᨭ᩠ᨮᩮ ᩅᩥᨩᩥᨲᩮ, ᩋᩁᨬ᩠ᨬᩮ ᩋᨲ᩠ᨳᩥ ᩋᩔᨾᩮᩣ;

ᨸᩥᨲᩣ ᨾᨿ᩠ᩉᩴ ᨩᨶᩮᨲ᩠ᨲᩦ ᨧ, ᩏᨽᩮᩣ ᩈᨾ᩠ᨾᨶ᩠ᨲᩥ ᩋᩔᨾᩮ.

᪑᪐᪒.

‘‘ᨲᩮᩈᩣᩉᩴ [ᨲᩮᩈ᩠ᩅᩉᩴ (ᨠ.)] ᨸᩩᨻ᩠ᨻᩣᨧᩁᩥᨿᩮᩈᩩ, ᨸᩩᨬ᩠ᨬᩴ ᨶ ᩃᨽᩣᨾᩥ ᨠᩣᨲᩅᩮ;

ᨽᩅᨶ᩠ᨲᩴ ᩋᨩ᩠ᨫᩣᩅᩁᩴ ᨠᨲ᩠ᩅᩣ, ᩈᩮᩣᨱᩴ [ᩈᩮᩣᨶᩴ (ᨸᩦ.)] ᨿᩣᨧᩮᨾᩩ ᩈᩴᩅᩁᩴ’’.

᪑᪐᪓.

‘‘ᨠᩁᩮᩣᨾᩥ ᨲᩮ ᨲᩴ ᩅᨧᨶᩴ, ᨿᩴ ᨾᩴ ᨽᨱᩈᩥ ᨻᩕᩣᩉ᩠ᨾᨱ;

ᩑᨲᨬ᩠ᨧ ᨡᩮᩣ ᨶᩮᩣ ᩋᨠ᩠ᨡᩣᩉᩥ, ᨠᩦᩅᨶ᩠ᨲᩮᩣ ᩉᩮᩣᨶ᩠ᨲᩩ ᨿᩣᨧᨠᩣ’’.

᪑᪐᪔.

‘‘ᨸᩁᩮᩣᩈᨲᩴ ᨩᩣᨶᨸᨴᩣ, ᨾᩉᩣᩈᩣᩃᩣ ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᩣ;

ᩍᨾᩮ ᨧ ᨡᨲ᩠ᨲᩥᨿᩣ ᩈᨻ᩠ᨻᩮ, ᩋᨽᩥᨩᩣᨲᩣ ᨿᩈᩔᩥᨶᩮᩣ;

ᨽᩅᨬ᩠ᨧ ᩁᩣᨩᩣ ᨾᨶᩮᩣᨩᩮᩣ, ᩋᩃᩴ ᩉᩮᩔᨶ᩠ᨲᩥ ᨿᩣᨧᨠᩣ’’.

᪑᪐᪕.

‘‘ᩉᨲ᩠ᨳᩦ ᩋᩔᩮ ᨧ ᨿᩮᩣᨩᩮᨶ᩠ᨲᩩ, ᩁᨳᩴ ᩈᨶ᩠ᨶᨿ᩠ᩉ ᩈᩣᩁᨳᩥ [ᨶᩴ ᩁᨳᩥ (ᨸᩦ.)];

ᩌᨻᨶ᩠ᨵᨶᩣᨶᩥ ᨣᨱ᩠ᩉᩣᨳ, ᨸᩣᨴᩣᩈᩩᩔᩣᩁᨿᨴ᩠ᨵᨩᩮ [ᨸᩣᨴᩮᩈᩩᩔᩣᩁᨿᩴ ᨵᨩᩮ (ᩈᩦ.), ᨸᩣᨴᩣᩈᩩᩔᩣᩁᨿᩴ ᨵᨩᩮ (ᨸᩦ.)];

ᩋᩔᨾᩴ ¶ ᨲᩴ ᨣᨾᩥᩔᩣᨾᩥ, ᨿᨲ᩠ᨳ ᩈᨾ᩠ᨾᨲᩥ ᨠᩮᩣᩈᩥᨿᩮᩣ’’.

᪑᪐᪖.

‘‘ᨲᨲᩮᩣ ᨧ ᩁᩣᨩᩣ ᨸᩣᨿᩣᩈᩥ, ᩈᩮᨶᩣᨿ ᨧᨲᩩᩁᨦ᩠ᨣᩥᨶᩦ;

ᩋᨣᨾᩣ ᩋᩔᨾᩴ ᩁᨾ᩠ᨾᩴ, ᨿᨲ᩠ᨳ ᩈᨾ᩠ᨾᨲᩥ ᨠᩮᩣᩈᩥᨿᩮᩣ’’.

᪑᪐᪗.

‘‘ᨠᩔ ᨠᩣᨴᨾ᩠ᨻᨿᩮᩣ [ᨠᩔ ᨠᩣᨴᨾ᩠ᨻᨾᨿᩮᩣ (ᨠ.)] ᨠᩣᨩᩮᩣ, ᩅᩮᩉᩣᩈᩴ ᨧᨲᩩᩁᨦ᩠ᨣᩩᩃᩴ;

ᩋᩴᩈᩴ ᩋᩈᨾ᩠ᨹᩩᩈᩴ ᩑᨲᩥ, ᩏᨴᩉᩣᩁᩣᨿ [ᩏᨴᩉᩣᩁᩔ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨣᨧ᩠ᨨᨲᩮᩣ’’.

᪑᪐᪘.

‘‘ᩋᩉᩴ ᩈᩮᩣᨱᩮᩣ ᨾᩉᩣᩁᩣᨩ, ᨲᩣᨸᩈᩮᩣ ᩈᩉᩥᨲᨻ᩠ᨻᨲᩮᩣ [ᩈᩉᩥᨲᩴ ᩅᨲᩮᩣ (ᨸᩦ.)];

ᨽᩁᩣᨾᩥ ᨾᩣᨲᩣᨸᩥᨲᩁᩮᩣ, ᩁᨲ᩠ᨲᩥᨶ᩠ᨴᩥᩅᨾᨲᨶ᩠ᨴᩥᨲᩮᩣ.

᪑᪐᪙.

‘‘ᩅᨶᩮ ᨹᩃᨬ᩠ᨧ ᨾᩪᩃᨬ᩠ᨧ, ᩌᩉᩁᩥᨲ᩠ᩅᩣ ᨴᩥᩈᨾ᩠ᨸᨲᩥ;

ᨸᩮᩣᩈᩮᨾᩥ ᨾᩣᨲᩣᨸᩥᨲᩁᩮᩣ, ᨸᩩᨻ᩠ᨻᩮ ᨠᨲᨾᨶᩩᩔᩁᩴ’’.

᪑᪑᪐.

‘‘ᩍᨧ᩠ᨨᩣᨾ ¶ ᩋᩔᨾᩴ ᨣᨶ᩠ᨲᩩᩴ, ᨿᨲ᩠ᨳ ᩈᨾ᩠ᨾᨲᩥ ᨠᩮᩣᩈᩥᨿᩮᩣ;

ᨾᨣ᩠ᨣᩴ ᨶᩮᩣ ᩈᩮᩣᨱ ᩋᨠ᩠ᨡᩣᩉᩥ, ᨿᩮᨶ ᨣᨧ᩠ᨨᩮᨾᩩ [ᨣᨧ᩠ᨨᩣᨾ (ᩈᩦ.)] ᩋᩔᨾᩴ’’.

᪑᪑᪑.

‘‘ᩋᨿᩴ ¶ ᩑᨠᨸᨴᩦ ᩁᩣᨩ, ᨿᩮᨶᩮᨲᩴ [ᨿᩮᨶ ᨲᩴ (ᨠ.)] ᨾᩮᨥᩈᨶ᩠ᨶᩥᨽᩴ;

ᨠᩮᩣᩅᩥᩊᩣᩁᩮᩉᩥ ᩈᨬ᩠ᨨᨶ᩠ᨶᩴ, ᩑᨲ᩠ᨳ ᩈᨾ᩠ᨾᨲᩥ ᨠᩮᩣᩈᩥᨿᩮᩣ’’.

᪑᪑᪒.

‘‘ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᨸᨠ᩠ᨠᩣᨾᩥ, ᨲᩁᨾᩣᨶᩮᩣ ᨾᩉᩣᩍᩈᩥ;

ᩅᩮᩉᩣᩈᩮ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩈ᩠ᨾᩥᩴ, ᩋᨶᩩᩈᩣᩈᩥᨲ᩠ᩅᩣᨶ ᨡᨲ᩠ᨲᩥᨿᩮ.

᪑᪑᪓.

‘‘ᩋᩔᨾᩴ ᨸᩁᩥᨾᨩ᩠ᨩᩥᨲ᩠ᩅᩣ, ᨸᨬ᩠ᨬᨸᩮᨲ᩠ᩅᩣᨶ [ᨸᨬ᩠ᨬᨸᩮᨲ᩠ᩅᩣᨶ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩌᩈᨶᩴ;

ᨸᨱ᩠ᨱᩈᩣᩃᩴ ᨸᩅᩥᩈᩥᨲ᩠ᩅᩣ, ᨸᩥᨲᩁᩴ ᨸᨭᩥᨻᩮᩣᨵᨿᩥ.

᪑᪑᪔.

‘‘ᩍᨾᩮ ᩌᨿᨶ᩠ᨲᩥ ᩁᩣᨩᩣᨶᩮᩣ, ᩋᨽᩥᨩᩣᨲᩣ ᨿᩈᩔᩥᨶᩮᩣ;

ᩋᩔᨾᩣ ᨶᩥᨠ᩠ᨡᨾᩥᨲ᩠ᩅᩣᨶ, ᨶᩥᩈᩦᨴ ᨲ᩠ᩅᩴ [ᨶᩥᩈᩦᨴᩣᩉᩥ (ᩈᩦ.)] ᨾᩉᩣᩍᩈᩮ.

᪑᪑᪕.

‘‘ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨲᩁᨾᩣᨶᩮᩣ ᨾᩉᩣᩍᩈᩥ;

ᩋᩔᨾᩣ ¶ ᨶᩥᨠ᩠ᨡᨾᩥᨲ᩠ᩅᩣᨶ, ᩈᨴ᩠ᩅᩣᩁᨾ᩠ᩉᩥ ᩏᨸᩣᩅᩥᩈᩥ’’.

᪑᪑᪖.

‘‘ᨲᨬ᩠ᨧ ᨴᩥᩈ᩠ᩅᩣᨶ ᩌᨿᨶ᩠ᨲᩴ, ᨩᩃᨶ᩠ᨲᩴᩁᩥᩅ ᨲᩮᨩᩈᩣ;

ᨡᨲ᩠ᨿᩈᨦ᩠ᨥᨸᩁᩥᨻ᩠ᨿᩪᩊ᩠ᩉᩴ, ᨠᩮᩣᩈᩥᨿᩮᩣ ᩑᨲᨴᨻᩕᩅᩥ.

᪑᪑᪗.

‘‘ᨠᩔ ᨽᩮᩁᩦ ᨾᩩᨴᩥᨦ᩠ᨣᩣ ᨧ [ᨾᩩᨲᩥᨦ᩠ᨣᩣ ᨧ (ᨸᩦ.)], ᩈᨦ᩠ᨡᩣ ᨸᨱᩅᨴᩥᨶ᩠ᨴᩥᨾᩣ [ᨴᩮᨱ᩠ᨯᩥᨾᩣ (ᩈᩦ. ᨸᩦ.)];

ᨸᩩᩁᨲᩮᩣ ᨸᨭᩥᨸᨶ᩠ᨶᩣᨶᩥ, ᩉᩣᩈᨿᨶ᩠ᨲᩣ ᩁᨳᩮᩈᨽᩴ.

᪑᪑᪘.

‘‘ᨠᩔ ᨠᨬ᩠ᨧᨶᨸᨭ᩠ᨭᩮᨶ, ᨸᩩᨳᩩᨶᩣ ᩅᩥᨩ᩠ᨩᩩᩅᨱ᩠ᨱᩥᨶᩣ;

ᨿᩩᩅᩣ ᨠᩃᩣᨸᩈᨶ᩠ᨶᨴ᩠ᨵᩮᩣ, ᨠᩮᩣ ᩑᨲᩥ ᩈᩥᩁᩥᨿᩣ ᨩᩃᩴ.

᪑᪑᪙.

‘‘ᩏᨠ᩠ᨠᩣᨾᩩᨡᨸᩉᨭ᩠ᨮᩴᩅ, ᨡᨴᩥᩁᨦ᩠ᨣᩣᩁᩈᨶ᩠ᨶᩥᨽᩴ;

ᨾᩩᨡᨬ᩠ᨧ ᩁᩩᨧᩥᩁᩣ ᨽᩣᨲᩥ, ᨠᩮᩣ ᩑᨲᩥ ᩈᩥᩁᩥᨿᩣ ᨩᩃᩴ.

᪑᪒᪐.

‘‘ᨠᩔ ᨸᨣ᩠ᨣᩉᩥᨲᩴ ᨨᨲ᩠ᨲᩴ, ᩈᩈᩃᩣᨠᩴ ᨾᨶᩮᩣᩁᨾᩴ;

ᩌᨴᩥᨧ᩠ᨧᩁᩴᩈᩣᩅᩁᨱᩴ, ᨠᩮᩣ ᩑᨲᩥ ᩈᩥᩁᩥᨿᩣ ᨩᩃᩴ.

᪑᪒᪑.

‘‘ᨠᩔ ᩋᨦ᩠ᨣᩴ ᨸᩁᩥᨣ᩠ᨣᨿ᩠ᩉ, ᩅᩣᩊᨻᩦᨩᨶᩥᨾᩩᨲ᩠ᨲᨾᩴ;

ᨧᩁᨶ᩠ᨲᩥ ᩅᩁᨸᩩᨬ᩠ᨬᩔ [ᩅᩁᨸᨬ᩠ᨬᩔ (ᩈᩦ. ᨸᩦ.)], ᩉᨲ᩠ᨳᩥᨠ᩠ᨡᨶ᩠ᨵᩮᨶ ᩌᨿᨲᩮᩣ.

᪑᪒᪒.

‘‘ᨠᩔ ᩈᩮᨲᩣᨶᩥ ᨨᨲ᩠ᨲᩣᨶᩥ, ᩌᨩᩣᨶᩦᨿᩣ ᨧ ᩅᨾ᩠ᨾᩥᨲᩣ;

ᩈᨾᨶ᩠ᨲᩣ ᨸᩁᩥᨠᩥᩁᩮᨶ᩠ᨲᩥ [ᨸᩁᩥᨠᩥᩁᨶ᩠ᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨠᩮᩣ ᩑᨲᩥ ᩈᩥᩁᩥᨿᩣ ᨩᩃᩴ.

᪑᪒᪓.

‘‘ᨠᩔ ¶ ᩑᨠᩈᨲᩴ ᨡᨲ᩠ᨿᩣ, ᩋᨶᩩᨿᨶ᩠ᨲᩣ [ᩋᨶᩩᨿᩩᨲ᩠ᨲᩣ (ᨸᩦ.)] ᨿᩈᩔᩥᨶᩮᩣ;

ᩈᨾᨶ᩠ᨲᩣᨶᩩᨸᩁᩥᨿᨶ᩠ᨲᩥ, ᨠᩮᩣ ᩑᨲᩥ ᩈᩥᩁᩥᨿᩣ ᨩᩃᩴ.

᪑᪒᪔.

‘‘ᩉᨲ᩠ᨳᩥ ᩋᩔᩁᨳ ᨸᨲ᩠ᨲᩥ [ᩉᨲ᩠ᨳᩦ ᩋᩔᩣ ᩁᨳᩣ ᨸᨲ᩠ᨲᩦ (ᩈᩦ.)], ᩈᩮᨶᩣ ᨧ ᨧᨲᩩᩁᨦ᩠ᨣᩥᨶᩦ;

ᩈᨾᨶ᩠ᨲᩣᨶᩩᨸᩁᩥᨿᨶ᩠ᨲᩥ [ᩈᨾᨶ᩠ᨲᩣ ᩋᨶᩩᨸᩁᩥᨿᩣᨲᩥ (ᨸᩦ.)], ᨠᩮᩣ ᩑᨲᩥ ᩈᩥᩁᩥᨿᩣ ᨩᩃᩴ.

᪑᪒᪕.

‘‘ᨠᩔᩮᩈᩣ ¶ ᨾᩉᨲᩦ ᩈᩮᨶᩣ, ᨸᩥᨭ᩠ᨮᩥᨲᩮᩣ ᩋᨶᩩᩅᨲ᩠ᨲᨲᩥ;

ᩋᨠ᩠ᨡᩮᩣᨽᨱᩦ ¶ [ᩋᨠ᩠ᨡᩣᨽᨶᩦ (ᩈᩦ.), ᩋᨠ᩠ᨡᩮᩣᨽᩥᨶᩦ (ᩈ᩠ᨿᩣ.)] ᩋᨸᩁᩥᨿᨶ᩠ᨲᩣ, ᩈᩣᨣᩁᩔᩮᩅ ᩐᨾᩥᨿᩮᩣ’’.

᪑᪒᪖.

‘‘ᩁᩣᨩᩣᨽᩥᩁᩣᨩᩣ [ᩁᩣᨩᩣᨵᩥᩁᩣᨩᩣ (ᨠ.)] ᨾᨶᩮᩣᨩᩮᩣ, ᩍᨶ᩠ᨴᩮᩣᩅ ᨩᨿᨲᩴ ᨸᨲᩥ;

ᨶᨶ᩠ᨴᩔᨩ᩠ᨫᩣᩅᩁᩴ ᩑᨲᩥ, ᩋᩔᨾᩴ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩴ.

᪑᪒᪗.

‘‘ᨲᩔᩮᩈᩣ ᨾᩉᨲᩦ ᩈᩮᨶᩣ, ᨸᩥᨭ᩠ᨮᩥᨲᩮᩣ ᩋᨶᩩᩅᨲ᩠ᨲᨲᩥ;

ᩋᨠ᩠ᨡᩮᩣᨽᨱᩦ ᩋᨸᩁᩥᨿᨶ᩠ᨲᩣ, ᩈᩣᨣᩁᩔᩮᩅ ᩐᨾᩥᨿᩮᩣ’’.

᪑᪒᪘.

‘‘ᩋᨶᩩᩃᩥᨲ᩠ᨲᩣ ᨧᨶ᩠ᨴᨶᩮᨶ, ᨠᩣᩈᩥᨠᩩᨲ᩠ᨲᨾᨵᩣᩁᩥᨶᩮᩣ [ᨠᩣᩈᩥᨠᩅᨲ᩠ᨳᨵᩣᩁᩥᨶᩮᩣ (ᨸᩦ.)];

ᩈᨻ᩠ᨻᩮ ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᩉᩩᨲ᩠ᩅᩣ, ᩍᩈᩦᨶᩴ ᩋᨩ᩠ᨫᩩᨸᩣᨣᨾᩩᩴ’’.

᪑᪒᪙.

‘‘ᨠᨧ᩠ᨧᩥ ᨶᩩ ᨽᩮᩣᨲᩮᩣ ᨠᩩᩈᩃᩴ, ᨠᨧ᩠ᨧᩥ ᨽᩮᩣᨲᩮᩣ ᩋᨶᩣᨾᨿᩴ;

ᨠᨧ᩠ᨧᩥ ᩏᨬ᩠ᨨᩮᨶ ᨿᩣᨸᩮᨳ, ᨠᨧ᩠ᨧᩥ ᨾᩪᩃᨹᩃᩣ ᨻᩉᩪ.

᪑᪓᪐.

‘‘ᨠᨧ᩠ᨧᩥ ᨯᩴᩈᩣ ᨾᨠᩈᩣ ᨧ, ᩋᨸ᩠ᨸᨾᩮᩅ ᩈᩁᩦᩈᨸᩣ [ᩈᩥᩁᩥᩴᩈᨸᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᩅᨶᩮ ᩅᩣᩊᨾᩥᨣᩣᨠᩥᨱ᩠ᨱᩮ, ᨠᨧ᩠ᨧᩥ ᩉᩥᩴᩈᩣ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ’’.

᪑᪓᪑.

‘‘ᨠᩩᩈᩃᨬ᩠ᨧᩮᩅ ᨶᩮᩣ ᩁᩣᨩ, ᩋᨳᩮᩣ ᩁᩣᨩ ᩋᨶᩣᨾᨿᩴ;

ᩋᨳᩮᩣ ᩏᨬ᩠ᨨᩮᨶ ᨿᩣᨸᩮᨾ, ᩋᨳᩮᩣ ᨾᩪᩃᨹᩃᩣ ᨻᩉᩪ.

᪑᪓᪒.

‘‘ᩋᨳᩮᩣ ᨯᩴᩈᩣ ᨾᨠᩈᩣ ᨧ [ᨯᩴᩈᩣ ᨧ ᨾᨠᩈᩣ (ᩈᩦ.), ᨯᩴᩈᩣ ᨧ ᨾᨠᩈᩣ ᨧ (ᨸᩦ.)], ᩋᨸ᩠ᨸᨾᩮᩅ ᩈᩁᩦᩈᨸᩣ [ᩈᩥᩁᩥᩴᩈᨸᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᩅᨶᩮ ᩅᩣᩊᨾᩥᨣᩣᨠᩥᨱ᩠ᨱᩮ, ᩉᩥᩴᩈᩣ ᨾᨿ᩠ᩉᩴ [ᩋ ᨾ᩠ᩉᩴ (ᩈᩦ. ᨸᩦ.)] ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ.

᪑᪓᪓.

‘‘ᨻᩉᩪᨶᩥ ᩅᩔᨸᩪᨣᩣᨶᩥ, ᩋᩔᨾᩮ ᩈᨾ᩠ᨾᨲᩴ [ᩅᩈᨲᩮᩣ (ᩈᩦ.)] ᩍᨵ;

ᨶᩣᨽᩥᨩᩣᨶᩣᨾᩥ ᩏᨸ᩠ᨸᨶ᩠ᨶᩴ, ᩌᨻᩣᨵᩴ ᩋᨾᨶᩮᩣᩁᨾᩴ.

᪑᪓᪔.

‘‘ᩈ᩠ᩅᩣᨣᨲᩴ ᨲᩮ ᨾᩉᩣᩁᩣᨩ, ᩋᨳᩮᩣ ᨲᩮ ᩋᨴᩩᩁᩣᨣᨲᩴ;

ᩍᩔᩁᩮᩣᩈᩥ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᨿᩴ ᩍᨵᨲ᩠ᨳᩥ ᨸᩅᩮᨴᨿ.

᪑᪓᪕.

‘‘ᨲᩥᨶ᩠ᨴᩩᨠᩣᨶᩥ ¶ ᨸᩥᨿᩣᩃᩣᨶᩥ, ᨾᨵᩩᨠᩮ ᨠᩣᩈᩩᨾᩣᩁᩥᨿᩮᩣ [ᨠᩣᩈᨾᩣᩁᩥᨿᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

ᨹᩃᩣᨶᩥ ¶ ᨡᩩᨴ᩠ᨴᨠᨸ᩠ᨸᩣᨶᩥ, ᨽᩩᨬ᩠ᨩ ᩁᩣᨩ ᩅᩁᩴ ᩅᩁᩴ.

᪑᪓᪖.

‘‘ᩍᨴᨾ᩠ᨸᩥ ᨸᩣᨶᩦᨿᩴ ᩈᩦᨲᩴ, ᩌᨽᨲᩴ ᨣᩥᩁᩥᨣᨻ᩠ᨽᩁᩣ;

ᨲᨲᩮᩣ ᨸᩥᩅ ᨾᩉᩣᩁᩣᨩ, ᩈᨧᩮ ᨲ᩠ᩅᩴ ᩋᨽᩥᨠᨦ᩠ᨡᩈᩥ’’.

᪑᪓᪗.

‘‘ᨸᨭᩥᨣ᩠ᨣᩉᩥᨲᩴ ᨿᩴ ᨴᩥᨶ᩠ᨶᩴ, ᩈᨻ᩠ᨻᩔ ᩋᨣ᩠ᨥᩥᨿᩴ ᨠᨲᩴ;

ᨶᨶ᩠ᨴᩔᩣᨸᩥ ᨶᩥᩈᩣᨾᩮᨳ, ᩅᨧᨶᩴ ᩈᩮᩣ [ᨿᩴ (ᩈᩦ.), ᨿᩴ ᩈᩮᩣ (ᨸᩦ.)] ᨸᩅᨠ᩠ᨡᨲᩥ.

᪑᪓᪘.

‘‘ᩋᨩ᩠ᨫᩣᩅᩁᨾ᩠ᩉᩣ ᨶᨶ᩠ᨴᩔ, ᨽᩮᩣᨲᩮᩣ ᩈᨶ᩠ᨲᩥᨠᨾᩣᨣᨲᩣ;

ᩈᩩᨱᩣᨲᩩ [ᩈᩩᨱᩣᨲᩩ ᨾᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨽᩅᩴ ᩅᨧᨶᩴ, ᨶᨶ᩠ᨴᩔ ᨸᩁᩥᩈᩣᨿ ᨧ’’.

᪑᪓᪙.

‘‘ᨸᩁᩮᩣᩈᨲᩴ ¶ ᨩᩣᨶᨸᨴᩣ [ᨩᨶᨸᨴᩣ (ᨸᩦ.)], ᨾᩉᩣᩈᩣᩃᩣ ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᩣ;

ᩍᨾᩮ ᨧ ᨡᨲ᩠ᨲᩥᨿᩣ ᩈᨻ᩠ᨻᩮ, ᩋᨽᩥᨩᩣᨲᩣ ᨿᩈᩔᩥᨶᩮᩣ;

ᨽᩅᨬ᩠ᨧ ᩁᩣᨩᩣ ᨾᨶᩮᩣᨩᩮᩣ, ᩋᨶᩩᨾᨬ᩠ᨬᨶ᩠ᨲᩩ ᨾᩮ ᩅᨧᩮᩣ.

᪑᪔᪐.

‘‘ᨿᩮ ᨧ ᩈᨶ᩠ᨲᩥ [ᨿᩮ ᩅᩈᨶ᩠ᨲᩥ (ᩈᩦ.), ᨿᩮ ᩉᩥ ᩈᨶ᩠ᨲᩥ (ᨸᩦ.)] ᩈᨾᩦᨲᩣᩁᩮᩣ, ᨿᨠ᩠ᨡᩣᨶᩥ ᩍᨵ ᨾᩔᨾᩮ;

ᩋᩁᨬ᩠ᨬᩮ ᨽᩪᨲᨽᨻ᩠ᨿᩣᨶᩥ, ᩈᩩᨱᨶ᩠ᨲᩩ ᩅᨧᨶᩴ ᨾᨾ.

᪑᪔᪑.

‘‘ᨶᨾᩮᩣ ᨠᨲ᩠ᩅᩣᨶ ᨽᩪᨲᩣᨶᩴ, ᩍᩈᩥᩴ ᩅᨠ᩠ᨡᩣᨾᩥ ᩈᩩᨻ᩠ᨻᨲᩴ;

ᩈᩮᩣ ᨲ᩠ᨿᩣᩉᩴ ᨴᨠ᩠ᨡᩥᨱᩣ ᨻᩣᩉᩩ, ᨲᩅ ᨠᩮᩣᩈᩥᨿ ᩈᨾ᩠ᨾᨲᩮᩣ.

᪑᪔᪒.

‘‘ᨸᩥᨲᩁᩴ ᨾᩮ ᨩᨶᩮᨲ᩠ᨲᩥᨬ᩠ᨧ, ᨽᨲ᩠ᨲᩩᨠᩣᨾᩔ ᨾᩮ ᩈᨲᩮᩣ;

ᩅᩦᩁ ᨸᩩᨬ᩠ᨬᨾᩥᨴᩴ ᨮᩣᨶᩴ, ᨾᩣ ᨾᩴ ᨠᩮᩣᩈᩥᨿ ᩅᩣᩁᨿ.

᪑᪔᪓.

‘‘ᩈᨻ᩠ᨽᩥ ᩉᩮᨲᩴ ᩏᨸᨬ᩠ᨬᩣᨲᩴ, ᨾᨾᩮᨲᩴ ᩏᨸᨶᩥᩔᨩ;

ᩏᨭ᩠ᨮᩣᨶᨸᩣᩁᩥᨧᩁᩥᨿᩣᨿ, ᨴᩦᨥᩁᨲ᩠ᨲᩴ ᨲᨿᩣ ᨠᨲᩴ;

ᨾᩣᨲᩣᨸᩥᨲᩪᩈᩩ ᨸᩩᨬ᩠ᨬᩣᨶᩥ, ᨾᨾ ᩃᩮᩣᨠᨴᨴᩮᩣ ᨽᩅ.

᪑᪔᪔.

‘‘ᨲᨳᩮᩅ ᩈᨶ᩠ᨲᩥ ᨾᨶᩩᨩᩣ, ᨵᨾ᩠ᨾᩮ ᨵᨾ᩠ᨾᨸᨴᩴ ᩅᩥᨴᩪ;

ᨾᨣ᩠ᨣᩮᩣ ¶ ᩈᨣ᩠ᨣᩔ ᩃᩮᩣᨠᩔ, ᨿᨳᩣ ᨩᩣᨶᩣᩈᩥ ᨲ᩠ᩅᩴ ᩍᩈᩮ.

᪑᪔᪕.

‘‘ᩏᨭ᩠ᨮᩣᨶᨸᩣᩁᩥᨧᩁᩥᨿᩣᨿ, ᨾᩣᨲᩣᨸᩥᨲᩩᩈᩩᨡᩣᩅᩉᩴ;

ᨲᩴ ᨾᩴ ᨸᩩᨬ᩠ᨬᩣ ᨶᩥᩅᩣᩁᩮᨲᩥ, ᩋᩁᩥᨿᨾᨣ᩠ᨣᩣᩅᩁᩮᩣ ᨶᩁᩮᩣ’’.

᪑᪔᪖.

‘‘ᩈᩩᨱᨶ᩠ᨲᩩ ¶ ᨽᩮᩣᨶ᩠ᨲᩮᩣ ᩅᨧᨶᩴ, ᨽᩣᨲᩩᩁᨩ᩠ᨫᩣᩅᩁᩣ ᨾᨾ;

ᨠᩩᩃᩅᩴᩈᩴ ᨾᩉᩣᩁᩣᨩ, ᨸᩮᩣᩁᩣᨱᩴ ᨸᩁᩥᩉᩣᨸᨿᩴ;

ᩋᨵᨾ᩠ᨾᨧᩣᩁᩦ ᨩᩮᨭ᩠ᨮᩮᩈᩩ [ᨿᩮᩣ ᨩᩮᨭ᩠ᨮᩮᩣ (ᩈᩦ.)], ᨶᩥᩁᨿᩴ ᩈᩮᩣᨸᨸᨩ᩠ᨩᨲᩥ [ᩈᩮᩣ ᩏᨸᨸᨩ᩠ᨩᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪑᪔᪗.

‘‘ᨿᩮ ᨧ ᨵᨾ᩠ᨾᩔ ᨠᩩᩈᩃᩣ, ᨸᩮᩣᩁᩣᨱᩔ ᨴᩥᩈᨾ᩠ᨸᨲᩥ;

ᨧᩣᩁᩥᨲ᩠ᨲᩮᨶ ᨧ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᨶ ᨲᩮ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ ᨴᩩᨣ᩠ᨣᨲᩥᩴ.

᪑᪔᪘.

‘‘ᨾᩣᨲᩣᨸᩥᨲᩣ ᨧ ᨽᩣᨲᩣ ᨧ, ᨽᨣᩥᨶᩦ ᨬᩣᨲᩥᨻᨶ᩠ᨵᩅᩣ;

ᩈᨻ᩠ᨻᩮ ᨩᩮᨭ᩠ᨮᩔ ᨲᩮ ᨽᩣᩁᩣ, ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨽᩣᩁᨵ [ᨽᩣᩁᨳ (ᩈ᩠ᨿᩣ.)].

᪑᪔᪙.

‘‘ᩌᨴᩥᨿᩥᨲ᩠ᩅᩣ ᨣᩁᩩᩴ ᨽᩣᩁᩴ, ᨶᩣᩅᩥᨠᩮᩣ ᩅᩥᨿ ᩏᩔᩉᩮ;

ᨵᨾ᩠ᨾᨬ᩠ᨧ ᨶᨸ᩠ᨸᨾᨩ᩠ᨩᩣᨾᩥ, ᨩᩮᨭ᩠ᨮᩮᩣ ᨧᩈ᩠ᨾᩥ ᩁᨳᩮᩈᨽ’’.

᪑᪕᪐.

‘‘ᩋᨵᩥᨣᨾᩣ [ᩋᨵᩥᨣᨲᨾ᩠ᩉᩣ (ᩈᩦ.), ᩋᨵᩥᨣᨾ᩠ᩉᩣ (ᩈ᩠ᨿᩣ.), ᩋᨵᩥᨣᨲᨾ᩠ᩉ (ᨸᩦ.)] ᨲᨾᩮ ᨬᩣᨱᩴ, ᨩᩣᩃᩴᩅ ᨩᩣᨲᩅᩮᨴᨲᩮᩣ;

ᩑᩅᨾᩮᩅ ᨶᩮᩣ ᨽᩅᩴ ᨵᨾ᩠ᨾᩴ, ᨠᩮᩣᩈᩥᨿᩮᩣ ᨸᩅᩥᨴᩴᩈᨿᩥ.

᪑᪕᪑.

‘‘ᨿᨳᩣ ᩏᨴᨿᨾᩣᨴᩥᨧ᩠ᨧᩮᩣ, ᩅᩣᩈᩩᨴᩮᩅᩮᩣ ᨸᨽᨦ᩠ᨠᩁᩮᩣ;

ᨸᩣᨱᩦᨶᩴ ᨸᩅᩥᨴᩴᩈᩮᨲᩥ, ᩁᩪᨸᩴ ᨠᩃ᩠ᨿᩣᨱᨸᩣᨸᨠᩴ;

ᩑᩅᨾᩮᩅ ᨶᩮᩣ ᨽᩅᩴ ᨵᨾ᩠ᨾᩴ, ᨠᩮᩣᩈᩥᨿᩮᩣ ᨸᩅᩥᨴᩴᩈᨿᩥ’’.

᪑᪕᪒.

‘‘ᩑᩅᩴ ¶ ᨾᩮ ᨿᩣᨧᨾᩣᨶᩔ, ᩋᨬ᩠ᨩᩃᩥᩴ ᨶᩣᩅᨻᩩᨩ᩠ᨫᨳ;

ᨲᩅ ᨸᨴ᩠ᨵᨧᩁᩮᩣ [ᨲᩅ ᨸᨭ᩠ᨮᨧᩁᩮᩣ (ᩈ᩠ᨿᩣ.), ᨲᩅ ᨻᨴ᩠ᨵᨬ᩠ᨧᩁᩮᩣ (ᨸᩦ.), ᨲᩅᩩᨸᨭ᩠ᨮᨧᩁᩮᩣ (ᨠ.)] ᩉᩮᩔᩴ, ᩅᩩᨭ᩠ᨮᩥᨲᩮᩣ ᨸᩁᩥᨧᩣᩁᨠᩮᩣ’’.

᪑᪕᪓.

‘‘ᩋᨴ᩠ᨵᩣ ᨶᨶ᩠ᨴ ᩅᩥᨩᩣᨶᩣᩈᩥ [ᨸᨩᩣᨶᩣᩈᩥ (ᩈᩦ.)], ᩈᨴ᩠ᨵᨾ᩠ᨾᩴ ᩈᨻ᩠ᨽᩥ ᨴᩮᩈᩥᨲᩴ;

ᩋᩁᩥᨿᩮᩣ ¶ ᩋᩁᩥᨿᩈᨾᩣᨧᩣᩁᩮᩣ, ᨻᩣᩊ᩠ᩉᩴ ᨲ᩠ᩅᩴ ᨾᨾ ᩁᩩᨧ᩠ᨧᩈᩥ.

᪑᪕᪔.

‘‘ᨽᩅᨶ᩠ᨲᩴ ᩅᨴᩣᨾᩥ ᨽᩮᩣᨲᩥᨬ᩠ᨧ, ᩈᩩᨱᩣᨳ ᩅᨧᨶᩴ ᨾᨾ;

ᨶᩣᨿᩴ ᨽᩣᩁᩮᩣ ᨽᩣᩁᨾᨲᩮᩣ [ᨽᩣᩁᨾᨲ᩠ᨲᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᩋᩉᩩ ᨾᨿ᩠ᩉᩴ ᨠᩩᨴᩣᨧᨶᩴ.

᪑᪕᪕.

‘‘ᨲᩴ ᨾᩴ ᩏᨸᨭ᩠ᨮᩥᨲᩴ ᩈᨶ᩠ᨲᩴ, ᨾᩣᨲᩣᨸᩥᨲᩩᩈᩩᨡᩣᩅᩉᩴ;

ᨶᨶ᩠ᨴᩮᩣ ᩋᨩ᩠ᨫᩣᩅᩁᩴ ᨠᨲ᩠ᩅᩣ, ᩏᨸᨭ᩠ᨮᩣᨶᩣᨿ ᨿᩣᨧᨲᩥ.

᪑᪕᪖.

‘‘ᨿᩮᩣ ᩅᩮ ᩍᨧ᩠ᨨᨲᩥ ᨠᩣᨾᩮᨶ, ᩈᨶ᩠ᨲᩣᨶᩴ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩴ;

ᨶᨶ᩠ᨴᩴ ᩅᩮᩣ ᩅᩁᨳ ᩑᨠᩮᩣ [ᨶᨶ᩠ᨴᩴ ᩅᨴᨳ ᩑᨠᩮ (ᨸᩦ.)], ᨠᩴ ᨶᨶ᩠ᨴᩮᩣ ᩏᨸᨲᩥᨭ᩠ᨮᨲᩩ’’.

᪑᪕᪗.

‘‘ᨲᨿᩣ ¶ ᨲᩣᨲ ᩋᨶᩩᨬ᩠ᨬᩣᨲᩣ, ᩈᩮᩣᨱ ᨲᩴ ᨶᩥᩔᩥᨲᩣ ᨾᨿᩴ;

ᩏᨸᨥᩣᨲᩩᩴ [ᩏᨸᨥᩣᨿᩥᨲᩩᩴ (ᩈᩦ.)] ᩃᨽᩮ ᨶᨶ᩠ᨴᩴ, ᨾᩩᨴ᩠ᨵᨶᩥ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩴ’’.

᪑᪕᪘.

‘‘ᩋᩔᨲ᩠ᨳᩔᩮᩅ ᨲᩁᩩᨱᩴ, ᨸᩅᩣᩊᩴ ᨾᩣᩃᩩᨲᩮᩁᩥᨲᩴ;

ᨧᩥᩁᩔᩴ ᨶᨶ᩠ᨴᩴ ᨴᩥᩈ᩠ᩅᩣᨶ, ᩉᨴᨿᩴ ᨾᩮ ᨸᩅᩮᨵᨲᩥ.

᪑᪕᪙.

‘‘ᨿᨴᩣ ᩈᩩᨲ᩠ᨲᩣᨸᩥ ᩈᩩᨸᩥᨶᩮ [ᩈᩩᨸ᩠ᨸᨶ᩠ᨲᩮ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨶᨶ᩠ᨴᩴ ᨸᩔᩣᨾᩥ ᩌᨣᨲᩴ;

ᩏᨴᨣ᩠ᨣᩣ ᩈᩩᨾᨶᩣ ᩉᩮᩣᨾᩥ, ᨶᨶ᩠ᨴᩮᩣ ᨶᩮᩣ ᩌᨣᨲᩮᩣ ᩋᨿᩴ.

᪑᪖᪐.

‘‘ᨿᨴᩣ ᨧ ᨸᨭᩥᨻᩩᨩ᩠ᨫᩥᨲ᩠ᩅᩣ, ᨶᨶ᩠ᨴᩴ ᨸᩔᩣᨾᩥ ᨶᩣᨣᨲᩴ;

ᨽᩥᨿ᩠ᨿᩮᩣ ᩌᩅᩥᩈᨲᩦ ᩈᩮᩣᨠᩮᩣ, ᨴᩮᩣᨾᨶᩔᨬ᩠ᨧᨶᨸ᩠ᨸᨠᩴ.

᪑᪖᪑.

‘‘ᩈᩣᩉᩴ ᩋᨩ᩠ᨩ ᨧᩥᩁᩔᨾ᩠ᨸᩥ, ᨶᨶ᩠ᨴᩴ ᨸᩔᩣᨾᩥ ᩌᨣᨲᩴ;

ᨽᨲ᩠ᨲᩩᨧ᩠ᨧ [ᨽᨲ᩠ᨲᩩᨬ᩠ᨧ (ᨠ.)] ᨾᨿ᩠ᩉᨬ᩠ᨧ ᨸᩥᨿᩮᩣ, ᨶᨶ᩠ᨴᩮᩣ ᨶᩮᩣ ᨸᩣᩅᩥᩈᩦ ᨥᩁᩴ.

᪑᪖᪒.

‘‘ᨸᩥᨲᩩᨸᩥ ᨶᨶ᩠ᨴᩮᩣ ᩈᩩᨸ᩠ᨸᩥᨿᩮᩣ, ᨿᩴ ᨶᨶ᩠ᨴᩮᩣ ᨶᨸ᩠ᨸᩅᩈᩮ [ᨸᩣᩅᩥᩈᩦ (ᨸᩦ.)] ᨥᩁᩣ [ᨥᩁᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)];

ᩃᨽᨲᩪ ᨲᩣᨲ ᨶᨶ᩠ᨴᩮᩣ ᨲᩴ, ᨾᩴ ᨶᨶ᩠ᨴᩮᩣ ᩏᨸᨲᩥᨭ᩠ᨮᨲᩩ’’.

᪑᪖᪓.

‘‘ᩋᨶᩩᨠᨾ᩠ᨸᩥᨠᩣ ¶ ᨸᨲᩥᨭ᩠ᨮᩣ ᨧ, ᨸᩩᨻ᩠ᨻᩮ ᩁᩈᨴᨴᩦ ᨧ ᨶᩮᩣ;

ᨾᨣ᩠ᨣᩮᩣ ᩈᨣ᩠ᨣᩔ ᩃᩮᩣᨠᩔ, ᨾᩣᨲᩣ ᨲᩴ ᩅᩁᨲᩮ ᩍᩈᩮ.

᪑᪖᪔.

‘‘ᨸᩩᨻ᩠ᨻᩮ ᩁᩈᨴᨴᩦ ᨣᩮᩣᨲ᩠ᨲᩦ, ᨾᩣᨲᩣ ᨸᩩᨬ᩠ᨬᩪᨸᩈᩴᩉᩥᨲᩣ;

ᨾᨣ᩠ᨣᩮᩣ ᩈᨣ᩠ᨣᩔ ᩃᩮᩣᨠᩔ, ᨾᩣᨲᩣ ᨲᩴ ᩅᩁᨲᩮ ᩍᩈᩮ’’.

᪑᪖᪕.

‘‘ᩌᨠᨦ᩠ᨡᨾᩣᨶᩣ ᨸᩩᨲ᩠ᨲᨹᩃᩴ, ᨴᩮᩅᨲᩣᨿ ᨶᨾᩔᨲᩥ;

ᨶᨠ᩠ᨡᨲ᩠ᨲᩣᨶᩥ ᨧ ᨸᩩᨧ᩠ᨨᨲᩥ, ᩏᨲᩩᩈᩴᩅᨧ᩠ᨨᩁᩣᨶᩥ ᨧ.

᪑᪖᪖.

‘‘ᨲᩔᩣ ᩏᨲᩩᨾ᩠ᩉᩥ ᨶ᩠ᩉᩣᨲᩣᨿ [ᩏᨲᩩᩈᩥᨶᩣᨲᩣᨿ (ᨸᩦ.)], ᩉᩮᩣᨲᩥ ᨣᨻ᩠ᨽᩔ ᩅᩮᩣᨠ᩠ᨠᨾᩮᩣ [ᨣᨻ᩠ᨽᩔ’ᩅᨠ᩠ᨠᨾᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᨲᩮᨶ ᨴᩮᩣᩉᩊᩥᨶᩦ ᩉᩮᩣᨲᩥ, ᩈᩩᩉᨴᩣ ᨲᩮᨶ ᩅᩩᨧ᩠ᨧᨲᩥ.

᪑᪖᪗.

‘‘ᩈᩴᩅᨧ᩠ᨨᩁᩴ ¶ ᩅᩣ ᩐᨶᩴ ᩅᩣ, ᨸᩁᩥᩉᩁᩥᨲ᩠ᩅᩣ ᩅᩥᨩᩣᨿᨲᩥ;

ᨲᩮᨶ ᩈᩣ ᨩᨶᨿᨶ᩠ᨲᩦᨲᩥ, ᨩᨶᩮᨲ᩠ᨲᩥ [ᨩᨶᩮᨲ᩠ᨲᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨲᩮᨶ ᩅᩩᨧ᩠ᨧᨲᩥ.

᪑᪖᪘.

‘‘ᨳᨶᨡᩦᩁᩮᨶ [ᨳᨶᨠ᩠ᨡᩦᩁᩮᨶ (ᩈᩦ.)] ᨣᩦᨲᩮᨶ, ᩋᨦ᩠ᨣᨸᩣᩅᩩᩁᨱᩮᨶ [ᩋᨦ᩠ᨣᨸᩣᨸᩩᩁᨱᩮᨶ (ᨸᩦ.)] ᨧ;

ᩁᩮᩣᨴᨶ᩠ᨲᩴ ᨸᩩᨲ᩠ᨲᩴ [ᩑᩅ (ᨸᩦ.)] ᨲᩮᩣᩈᩮᨲᩥ, ᨲᩮᩣᩈᩮᨶ᩠ᨲᩦ ᨲᩮᨶ ᩅᩩᨧ᩠ᨧᨲᩥ.

᪑᪖᪙.

‘‘ᨲᨲᩮᩣ ¶ ᩅᩣᨲᩣᨲᨸᩮ ᨥᩮᩣᩁᩮ, ᨾᨾᩴ ᨠᨲ᩠ᩅᩣ ᩏᨴᩥᨠ᩠ᨡᨲᩥ;

ᨴᩣᩁᨠᩴ ᩋᨸ᩠ᨸᨩᩣᨶᨶ᩠ᨲᩴ, ᨸᩮᩣᩈᩮᨶ᩠ᨲᩦ ᨲᩮᨶ ᩅᩩᨧ᩠ᨧᨲᩥ.

᪑᪗᪐.

‘‘ᨿᨬ᩠ᨧ ᨾᩣᨲᩩᨵᨶᩴ ᩉᩮᩣᨲᩥ, ᨿᨬ᩠ᨧ ᩉᩮᩣᨲᩥ ᨸᩥᨲᩩᨴ᩠ᨵᨶᩴ;

ᩏᨽᨿᨾ᩠ᨸᩮᨲᩔ ᨣᩮᩣᨸᩮᨲᩥ, ᩋᨸᩥ ᨸᩩᨲ᩠ᨲᩔ ᨶᩮᩣ ᩈᩥᨿᩣ.

᪑᪗᪑.

‘‘ᩑᩅᩴ ᨸᩩᨲ᩠ᨲ ᩋᨴᩩᩴ ᨸᩩᨲ᩠ᨲ, ᩍᨲᩥ ᨾᩣᨲᩣ ᩅᩥᩉᨬ᩠ᨬᨲᩥ;

ᨸᨾᨲ᩠ᨲᩴ ᨸᩁᨴᩣᩁᩮᩈᩩ, ᨶᩥᩈᩦᨳᩮ ᨸᨲ᩠ᨲᨿᩮᩣᨻ᩠ᨻᨶᩮ;

ᩈᩣᨿᩴ ᨸᩩᨲ᩠ᨲᩴ ᩋᨶᩣᨿᨶ᩠ᨲᩴ, ᩍᨲᩥ ᨾᩣᨲᩣ ᩅᩥᩉᨬ᩠ᨬᨲᩥ.

᪑᪗᪒.

‘‘ᩑᩅᩴ ᨠᩥᨧ᩠ᨨᩣ ᨽᨲᩮᩣ ᨸᩮᩣᩈᩮᩣ, ᨾᩣᨲᩩ ᩋᨸᩁᩥᨧᩣᩁᨠᩮᩣ;

ᨾᩣᨲᩁᩥ ᨾᩥᨧ᩠ᨨᩣ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᨶᩥᩁᨿᩴ ᩈᩮᩣᨸᨸᨩ᩠ᨩᨲᩥ.

᪑᪗᪓.

‘‘ᩑᩅᩴ ¶ ᨠᩥᨧ᩠ᨨᩣ ᨽᨲᩮᩣ ᨸᩮᩣᩈᩮᩣ, ᨸᩥᨲᩩ ᩋᨸᩁᩥᨧᩣᩁᨠᩮᩣ;

ᨸᩥᨲᩁᩥ ᨾᩥᨧ᩠ᨨᩣ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᨶᩥᩁᨿᩴ ᩈᩮᩣᨸᨸᨩ᩠ᨩᨲᩥ.

᪑᪗᪔.

‘‘ᨵᨶᩣᨸᩥ ᨵᨶᨠᩣᨾᩣᨶᩴ, ᨶᩔᨲᩥ ᩍᨲᩥ ᨾᩮ ᩈᩩᨲᩴ;

ᨾᩣᨲᩁᩴ ᩋᨸᩁᩥᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᨠᩥᨧ᩠ᨨᩴ ᩅᩣ ᩈᩮᩣ ᨶᩥᨣᨧ᩠ᨨᨲᩥ.

᪑᪗᪕.

‘‘ᨵᨶᩣᨸᩥ ᨵᨶᨠᩣᨾᩣᨶᩴ, ᨶᩔᨲᩥ ᩍᨲᩥ ᨾᩮ ᩈᩩᨲᩴ;

ᨸᩥᨲᩁᩴ ᩋᨸᩁᩥᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᨠᩥᨧ᩠ᨨᩴ ᩅᩣ ᩈᩮᩣ ᨶᩥᨣᨧ᩠ᨨᨲᩥ.

᪑᪗᪖.

‘‘ᩌᨶᨶ᩠ᨴᩮᩣ ᨧ ᨸᨾᩮᩣᨴᩮᩣ ᨧ, ᩈᨴᩣ ᩉᩈᩥᨲᨠᩦᩊᩥᨲᩴ;

ᨾᩣᨲᩁᩴ ᨸᩁᩥᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩃᨻ᩠ᨽᨾᩮᨲᩴ ᩅᩥᨩᩣᨶᨲᩮᩣ.

᪑᪗᪗.

‘‘ᩌᨶᨶ᩠ᨴᩮᩣ ᨧ ᨸᨾᩮᩣᨴᩮᩣ ᨧ, ᩈᨴᩣ ᩉᩈᩥᨲᨠᩦᩊᩥᨲᩴ;

ᨸᩥᨲᩁᩴ ᨸᩁᩥᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩃᨻ᩠ᨽᨾᩮᨲᩴ ᩅᩥᨩᩣᨶᨲᩮᩣ.

᪑᪗᪘.

‘‘ᨴᩣᨶᨬ᩠ᨧ ᨸᩮᨿ᩠ᨿᩅᨩ᩠ᨩᨬ᩠ᨧ [ᨸᩥᨿᩅᩣᨧᩣ ᨧ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)], ᩋᨲ᩠ᨳᨧᩁᩥᨿᩣ ᨧ ᨿᩣ ᩍᨵ;

ᩈᨾᩣᨶᨲ᩠ᨲᨲᩣ [ᩈᨾᩣᨶᨲ᩠ᨲᩣ (ᨸᩦ.)] ᨧ ᨵᨾ᩠ᨾᩮᩈᩩ, ᨲᨲ᩠ᨳ ᨲᨲ᩠ᨳ ᨿᨳᩣᩁᩉᩴ;

ᩑᨲᩮ ᨡᩮᩣ ᩈᨦ᩠ᨣᩉᩣ ᩃᩮᩣᨠᩮ, ᩁᨳᩔᩣᨱᩦᩅ ᨿᩣᨿᨲᩮᩣ.

᪑᪗᪙.

ᩑᨲᩮ ᨧ ᩈᨦ᩠ᨣᩉᩣ ᨶᩣᩔᩩ, ᨶ ᨾᩣᨲᩣ ᨸᩩᨲ᩠ᨲᨠᩣᩁᨱᩣ;

ᩃᨽᩮᨳ ᨾᩣᨶᩴ ᨸᩪᨩᩴ ᩅᩣ [ᨸᩪᨩᨬ᩠ᨧ (ᨸᩦ.)], ᨸᩥᨲᩣ ᩅᩣ ᨸᩩᨲ᩠ᨲᨠᩣᩁᨱᩣ.

᪑᪘᪐.

‘‘ᨿᩈ᩠ᨾᩣ ᨧ ᩈᨦ᩠ᨣᩉᩣ [ᩈᨦ᩠ᨣᩉᩮ (ᨴᩦ. ᨶᩥ. ᪓.᪒᪗᪓; ᩋ. ᨶᩥ. ᪔.᪓᪒) ᨲᨴᨭ᩠ᨮᨠᨳᩣᨿᩮᩣ ᩒᩃᩮᩣᨠᩮᨲᨻ᩠ᨻᩣ] ᩑᨲᩮ, ᩈᨾ᩠ᨾᨸᩮᨠ᩠ᨡᨶ᩠ᨲᩥ [ᩈᨾᩅᩮᨠ᩠ᨡᨶ᩠ᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.) ᩋ. ᨶᩥ. ᪔.᪓᪒] ᨸᨱ᩠ᨯᩥᨲᩣ;

ᨲᩈ᩠ᨾᩣ ᨾᩉᨲ᩠ᨲᩴ ᨸᨸ᩠ᨸᩮᩣᨶ᩠ᨲᩥ, ᨸᩣᩈᩴᩈᩣ ᨧ ᨽᩅᨶ᩠ᨲᩥ ᨲᩮ.

᪑᪘᪑.

‘‘ᨻᩕᩉ᩠ᨾᩣᨲᩥ ¶ ¶ [ᨻᩕᩉ᩠ᨾᩣ ᩉᩥ (ᨸᩦ.)] ᨾᩣᨲᩣᨸᩥᨲᩁᩮᩣ, ᨸᩩᨻ᩠ᨻᩣᨧᩁᩥᨿᩣᨲᩥ ᩅᩩᨧ᩠ᨧᩁᩮ;

ᩌᩉᩩᨶᩮᨿ᩠ᨿᩣ ¶ ᨧ ᨸᩩᨲ᩠ᨲᩣᨶᩴ, ᨸᨩᩣᨿ ᩋᨶᩩᨠᨾ᩠ᨸᨠᩣ.

᪑᪘᪒.

‘‘ᨲᩈ᩠ᨾᩣ ᩉᩥ ᨶᩮ ᨶᨾᩔᩮᨿ᩠ᨿ, ᩈᨠ᩠ᨠᩁᩮᨿ᩠ᨿ ᨧ ᨸᨱ᩠ᨯᩥᨲᩮᩣ;

ᩋᨶ᩠ᨶᩮᨶ ᩋᨳᩮᩣ [ᨾᨳᩮᩣ (ᨸᩦ.), ᩋᨳ (ᩋ. ᨶᩥ. ᪔.᪖᪓; ᩍᨲᩥᩅᩩ. ᪑᪐᪖)] ᨸᩣᨶᩮᨶ, ᩅᨲ᩠ᨳᩮᨶ ᩈᨿᨶᩮᨶ ᨧ;

ᩏᨧ᩠ᨨᩣᨴᨶᩮᨶ ᨶ᩠ᩉᩣᨸᨶᩮᨶ [ᨶᩉᩣᨸᨶᩮᨶ (ᩈᩦ. ᨸᩦ.)], ᨸᩣᨴᩣᨶᩴ ᨵᩮᩣᩅᨶᩮᨶ ᨧ.

᪑᪘᪓.

‘‘ᨲᩣᨿ ᨶᩴ ᨸᩣᩁᩥᨧᩁᩥᨿᩣᨿ [ᨸᩁᩥᨧᩁᩥᨿᩣᨿ (ᨸᩦ.)], ᨾᩣᨲᩣᨸᩥᨲᩪᩈᩩ ᨸᨱ᩠ᨯᩥᨲᩣ;

ᩍᨵᩮᩅ ᨶᩴ ᨸᩈᩴᩈᨶ᩠ᨲᩥ, ᨸᩮᨧ᩠ᨧ ᩈᨣ᩠ᨣᩮ ᨸᨾᩮᩣᨴᨲᩦ’’ᨲᩥ.

ᩈᩮᩣᨱᨶᨶ᩠ᨴᨩᩣᨲᨠᩴ ᨴᩩᨲᩥᨿᩴ.

ᩈᨲ᩠ᨲᨲᩥᨶᩥᨸᩣᨲᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨲᩔᩩᨴ᩠ᨴᩣᨶᩴ –

ᩋᨳ ᩈᨲ᩠ᨲᨲᩥᨾᨾ᩠ᩉᩥ ᨶᩥᨸᩣᨲᩅᩁᩮ, ᩈᨽᩣᩅᨶ᩠ᨲᩩ ᨠᩩᩈᩣᩅᨲᩥᩁᩣᨩᩅᩁᩮᩣ;

ᩋᨳ ᩈᩮᩣᨱᩈᩩᨶᨶ᩠ᨴᩅᩁᩮᩣ ᨧ ᨸᩩᨶ, ᩋᨽᩥᩅᩣᩈᩥᨲᩈᨲ᩠ᨲᨲᩥᨾᨾ᩠ᩉᩥ ᩈᩩᨲᩮᨲᩥ.

᪒᪑. ᩋᩈᩦᨲᩥᨶᩥᨸᩣᨲᩮᩣ

᪕᪓᪓. ᨧᩪᩊᩉᩴᩈᨩᩣᨲᨠᩴ (᪑)

᪑.

‘‘ᩈᩩᨾᩩᨡ ¶ ¶ ¶ ᩋᨶᩩᨸᨧᩥᨶᨶ᩠ᨲᩣ, ᨸᨠ᩠ᨠᨾᨶ᩠ᨲᩥ ᩅᩥᩉᨦ᩠ᨣᨾᩣ;

ᨣᨧ᩠ᨨ ᨲᩩᩅᨾ᩠ᨸᩥ ᨾᩣ ᨠᨦ᩠ᨡᩥ, ᨶᨲ᩠ᨳᩥ ᨻᨴ᩠ᨵᩮ [ᨻᨶ᩠ᨵᩮ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩈᩉᩣᨿᨲᩣ’’.

᪒.

‘‘ᨣᨧ᩠ᨨᩮ ᩅᩣᩉᩴ ᨶ ᩅᩣ ᨣᨧ᩠ᨨᩮ, ᨶ ᨲᩮᨶ ᩋᨾᩁᩮᩣ ᩈᩥᨿᩴ;

ᩈᩩᨡᩥᨲᩴ ᨲᩴ ᩏᨸᩣᩈᩥᨲ᩠ᩅᩣ, ᨴᩩᨠ᩠ᨡᩥᨲᩴ ᨲᩴ ᨠᨳᩴ ᨩᩉᩮ.

᪓.

‘‘ᨾᩁᨱᩴ ᩅᩣ ᨲᨿᩣ ᩈᨴ᩠ᨵᩥᩴ, ᨩᩦᩅᩥᨲᩴ ᩅᩣ ᨲᨿᩣ ᩅᩥᨶᩣ;

ᨲᨴᩮᩅ ᨾᩁᨱᩴ ᩈᩮᨿ᩠ᨿᩮᩣ, ᨿᨬ᩠ᨧᩮ ᨩᩦᩅᩮ ᨲᨿᩣ ᩅᩥᨶᩣ.

᪔.

‘‘ᨶᩮᩈ ᨵᨾ᩠ᨾᩮᩣ ᨾᩉᩣᩁᩣᨩ, ᨿᩴ ᨲᩴ ᩑᩅᩴ ᨣᨲᩴ ᨩᩉᩮ;

ᨿᩣ ᨣᨲᩥ ᨲᩩᨿ᩠ᩉᩴ ᩈᩣ ᨾᨿ᩠ᩉᩴ, ᩁᩩᨧ᩠ᨧᨲᩮ ᩅᩥᩉᨣᩣᨵᩥᨸ.

᪕.

‘‘ᨠᩣ ᨶᩩ ᨸᩣᩈᩮᨶ ᨻᨴ᩠ᨵᩔ [ᨻᨶ᩠ᨵᩔ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨣᨲᩥ ᩋᨬ᩠ᨬᩣ ᨾᩉᩣᨶᩈᩣ;

ᩈᩣ ᨠᨳᩴ ᨧᩮᨲᨿᩣᨶᩔ, ᨾᩩᨲ᩠ᨲᩔ ᨲᩅ ᩁᩩᨧ᩠ᨧᨲᩥ.

᪖.

‘‘ᨠᩴ ᩅᩣ ᨲ᩠ᩅᩴ ᨸᩔᩈᩮ ᩋᨲ᩠ᨳᩴ, ᨾᨾ ᨲᩩᨿ᩠ᩉᨬ᩠ᨧ ᨸᨠ᩠ᨡᩥᨾ;

ᨬᩣᨲᩦᨶᩴ ᩅᩣᩅᩈᩥᨭ᩠ᨮᩣᨶᩴ, ᩏᨽᩥᨶ᩠ᨶᩴ ᨩᩦᩅᩥᨲᨠ᩠ᨡᨿᩮ.

᪗.

‘‘ᨿᩴ ᨶ ᨠᨬ᩠ᨧᨶᨴᩮᨸᩥᨬ᩠ᨨ [ᨴᩮᨸᩥᨧ᩠ᨨ (ᩈᩦ. ᨸᩦ.), ᨴ᩠ᩅᩮᨸᩥᨧ᩠ᨨ (ᩈ᩠ᨿᩣ.)], ᩋᨶ᩠ᨵᩮᨶ ᨲᨾᩈᩣ ᨣᨲᩴ;

ᨲᩣᨴᩥᩈᩮ ᩈᨬ᩠ᨧᨩᩴ ᨸᩣᨱᩴ, ᨠᨾᨲ᩠ᨳᨾᨽᩥᨩᩮᩣᨲᨿᩮ’’.

᪘.

‘‘ᨠᨳᩴ ᨶᩩ ᨸᨲᨲᩴ ᩈᩮᨭ᩠ᨮ, ᨵᨾ᩠ᨾᩮ ᩋᨲ᩠ᨳᩴ ᨶ ᨻᩩᨩ᩠ᨫᩈᩥ [ᨻᩩᨩ᩠ᨫᩈᩮ (ᩈᩦ.)];

ᨵᨾ᩠ᨾᩮᩣ ᩋᨸᨧᩥᨲᩮᩣ ᩈᨶ᩠ᨲᩮᩣ, ᩋᨲ᩠ᨳᩴ ᨴᩔᩮᨲᩥ ᨸᩣᨱᩥᨶᩴ.

᪙.

‘‘ᩈᩮᩣᩉᩴ ᨵᨾ᩠ᨾᩴ ᩋᨸᩮᨠ᩠ᨡᩣᨶᩮᩣ, ᨵᨾ᩠ᨾᩣ ᨧᨲ᩠ᨳᩴ ᩈᨾᩩᨭ᩠ᨮᩥᨲᩴ;

ᨽᨲ᩠ᨲᩥᨬ᩠ᨧ ¶ ᨲᨿᩥ ᩈᨾ᩠ᨸᩔᩴ, ᨶᩣᩅᨠᨦ᩠ᨡᩣᨾᩥ ᨩᩦᩅᩥᨲᩴ’’.

᪑᪐.

‘‘ᩋᨴ᩠ᨵᩣ ᩑᩈᩮᩣ ᩈᨲᩴ ᨵᨾ᩠ᨾᩮᩣ, ᨿᩮᩣ ᨾᩥᨲ᩠ᨲᩮᩣ ᨾᩥᨲ᩠ᨲᨾᩣᨸᨴᩮ;

ᨶ ᨧᨩᩮ ᨩᩦᩅᩥᨲᩔᩣᨸᩥ, ᩉᩮᨲᩩᨵᨾ᩠ᨾᨾᨶᩩᩔᩁᩴ.

᪑᪑.

‘‘ᩈ᩠ᩅᩣᨿᩴ ᨵᨾ᩠ᨾᩮᩣ ᨧ ᨲᩮ ᨧᩥᨱ᩠ᨱᩮᩣ, ᨽᨲ᩠ᨲᩥ ᨧ ᩅᩥᨴᩥᨲᩣ ᨾᨿᩥ;

ᨠᩣᨾᩴ ᨠᩁᩔᩩ ᨾᨿ᩠ᩉᩮᨲᩴ, ᨣᨧ᩠ᨨᩮᩅᩣᨶᩩᨾᨲᩮᩣ ᨾᨿᩣ’’.

᪑᪒.

‘‘ᩋᨸᩥ ¶ ¶ ᨲ᩠ᩅᩮᩅᩴ ᨣᨲᩮ ᨠᩣᩃᩮ, ᨿᩴ ᨡᨱ᩠ᨯᩴ [ᨻᨴ᩠ᨵᩴ (ᩈᩦ.), ᨻᨶ᩠ᨵᩴ (ᨸᩦ.)] ᨬᩣᨲᩥᨶᩴ ᨾᨿᩣ;

ᨲᨿᩣ ᨲᩴ ᨻᩩᨴ᩠ᨵᩥᩈᨾ᩠ᨸᨶ᩠ᨶᩴ [ᨻᩩᨴ᩠ᨵᩥᩈᨾ᩠ᨸᨶ᩠ᨶ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩋᩔ ᨸᩁᨾᩈᩴᩅᩩᨲᩴ.

᪑᪓.

‘‘ᩍᨧ᩠ᨧᩮᩅᩴ [ᩍᨧ᩠ᨧᩮᩅ (ᩈᩦ. ᨸᩦ.)] ᨾᨶ᩠ᨲᨿᨶ᩠ᨲᩣᨶᩴ, ᩋᩁᩥᨿᩣᨶᩴ ᩋᩁᩥᨿᩅᩩᨲ᩠ᨲᩥᨶᩴ;

ᨸᨧ᩠ᨧᨴᩥᩔᨳ ᨶᩮᩈᩣᨴᩮᩣ, ᩌᨲᩩᩁᩣᨶᨾᩥᩅᨶ᩠ᨲᨠᩮᩣ.

᪑᪔.

‘‘ᨲᩮ ᩈᨲ᩠ᨲᩩᨾᨽᩥᩈᨬ᩠ᨧᩥᨠ᩠ᨡ, ᨴᩦᨥᩁᨲ᩠ᨲᩴ ᩉᩥᨲᩣ ᨴᩥᨩᩣ;

ᨲᩩᨱ᩠ᩉᩦᨾᩣᩈᩥᨲ᩠ᨳ ᩏᨽᨿᩮᩣ, ᨶ ᩈᨬ᩠ᨧᩃᩮᩈᩩᨾᩣᩈᨶᩣ [ᨶ ᨧ ᩈᨬ᩠ᨧᩮᩈᩩ’ᨾᩣᩈᨶᩣ (ᩈᩦ. ᨸᩦ.)].

᪑᪕.

‘‘ᨵᨲᩁᨭ᩠ᨮᩮ ᨧ ᨴᩥᩈ᩠ᩅᩣᨶ, ᩈᨾᩩᨯ᩠ᨯᩮᨶ᩠ᨲᩮ ᨲᨲᩮᩣ ᨲᨲᩮᩣ;

ᩋᨽᩥᨠ᩠ᨠᨾᨳ ᩅᩮᨣᩮᨶ, ᨴᩥᨩᩈᨲ᩠ᨲᩩ ᨴᩥᨩᩣᨵᩥᨸᩮ.

᪑᪖.

‘‘ᩈᩮᩣ ᨧ ᩅᩮᨣᩮᨶᨽᩥᨠ᩠ᨠᨾ᩠ᨾ, ᩌᩈᨩ᩠ᨩ ᨸᩁᨾᩮ ᨴᩥᨩᩮ;

ᨸᨧ᩠ᨧᨠᨾᩥᨲ᩠ᨳ [ᨸᨧ᩠ᨧᨠᨾ᩠ᨸᩥᨲ᩠ᨳ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨶᩮᩈᩣᨴᩮᩣ, ᨻᨴ᩠ᨵᩣ ᩍᨲᩥ ᩅᩥᨧᩥᨶ᩠ᨲᨿᩴ.

᪑᪗.

‘‘ᩑᨠᩴᩅ ᨻᨴ᩠ᨵᨾᩣᩈᩦᨶᩴ, ᩋᨻᨴ᩠ᨵᨬ᩠ᨧ ᨸᩩᨶᩣᨸᩁᩴ;

ᩌᩈᨩ᩠ᨩ ᨻᨴ᩠ᨵᨾᩣᩈᩦᨶᩴ, ᨸᩮᨠ᩠ᨡᨾᩣᨶᨾᨴᩦᨶᩅᩴ.

᪑᪘.

‘‘ᨲᨲᩮᩣ ᩈᩮᩣ ᩅᩥᨾᨲᩮᩣᨿᩮᩅ, ᨸᨱ᩠ᨯᩁᩮ ᩋᨩ᩠ᨫᨽᩣᩈᨳ;

ᨸᩅᨯ᩠ᨰᨠᩣᨿᩮ ᩌᩈᩦᨶᩮ, ᨴᩥᨩᩈᨦ᩠ᨥᨣᨱᩣᨵᩥᨸᩮ.

᪑᪙.

‘‘ᨿᩴ ᨶᩩ ᨸᩣᩈᩮᨶ ᨾᩉᨲᩣ, ᨻᨴ᩠ᨵᩮᩣ ᨶ ᨠᩩᩁᩩᨲᩮ ᨴᩥᩈᩴ;

ᩋᨳ ¶ ᨠᩈ᩠ᨾᩣ ᩋᨻᨴ᩠ᨵᩮᩣ ᨲ᩠ᩅᩴ, ᨻᩃᩦ ᨸᨠ᩠ᨡᩥ ᨶ ᨣᨧ᩠ᨨᩈᩥ.

᪒᪐.

‘‘ᨠᩥᨶ᩠ᨶᩩ ᨲ᩠ᨿᩣᨿᩴ [ᨲᩣ’ᨿᩴ (ᩈᩦ. ᨸᩦ. ᨠ.)] ᨴᩥᨩᩮᩣ ᩉᩮᩣᨲᩥ, ᨾᩩᨲ᩠ᨲᩮᩣ ᨻᨴ᩠ᨵᩴ ᩏᨸᩣᩈᩈᩥ;

ᩒᩉᩣᨿ ᩈᨠᩩᨱᩣ ᨿᨶ᩠ᨲᩥ, ᨠᩥᩴ ᩑᨠᩮᩣ ᩋᩅᩉᩦᨿᩈᩥ’’.

᪒᪑.

‘‘ᩁᩣᨩᩣ ᨾᩮ ᩈᩮᩣ ᨴᩥᨩᩣᨾᩥᨲ᩠ᨲ, ᩈᨡᩣ ᨸᩣᨱᩈᨾᩮᩣ ᨧ ᨾᩮ;

ᨶᩮᩅ ᨶᩴ ᩅᩥᨩᩉᩥᩔᩣᨾᩥ, ᨿᩣᩅ ᨠᩣᩃᩔ ᨸᩁᩥᨿᩣᨿᩴ.

᪒᪒.

‘‘ᨠᨳᩴ ᨸᨶᩣᨿᩴ ᩅᩥᩉᨦ᩠ᨣᩮᩣ, ᨶᩣᨴ᩠ᨴᩈ ᨸᩣᩈᨾᩮᩣᨯ᩠ᨯᩥᨲᩴ;

ᨸᨴᨬ᩠ᩉᩮᨲᩴ ᨾᩉᨶ᩠ᨲᩣᨶᩴ, ᨻᩮᩣᨴ᩠ᨵᩩᨾᩁᩉᨶ᩠ᨲᩥ ᩌᨸᨴᩴ.

᪒᪓.

‘‘ᨿᨴᩣ ᨸᩁᩣᨽᩅᩮᩣ ᩉᩮᩣᨲᩥ, ᨸᩮᩣᩈᩮᩣ ᨩᩦᩅᩥᨲᩈᨦ᩠ᨡᨿᩮ;

ᩋᨳ ᨩᩣᩃᨬ᩠ᨧ ᨸᩣᩈᨬ᩠ᨧ, ᩌᩈᨩ᩠ᨩᩣᨸᩥ ᨶ ᨻᩩᨩ᩠ᨫᨲᩥ.

᪒᪔.

‘‘ᩋᨸᩥ ¶ ᨲ᩠ᩅᩮᩅ ᨾᩉᩣᨸᨬ᩠ᨬ, ᨸᩣᩈᩣ ᨻᩉᩩᩅᩥᨵᩣ ᨲᨲᩣ [ᨲᨲᩣ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᨣᩩᨿ᩠ᩉᨾᩣᩈᨩ᩠ᨩ [ᨣᩪᩊ᩠ᩉᨾᩣᩈᨩ᩠ᨩ (ᩈᩦ. ᨸᩦ.)] ᨻᨩ᩠ᨫᨶ᩠ᨲᩥ, ᩋᨳᩮᩅᩴ ᨩᩦᩅᩥᨲᨠ᩠ᨡᨿᩮ’’.

᪒᪕.

‘‘ᩋᨸᩥ ᨶᩣᨿᩴ ᨲᨿᩣ ᩈᨴ᩠ᨵᩥᩴ, ᩈᩴᩅᩣᩈᩔ [ᩈᨾ᩠ᨽᩣᩈᩔ (ᩈᩦ. ᨸᩦ.)] ᩈᩩᨡᩩᨴᩕᨿᩮᩣ;

ᩋᨸᩥ ᨶᩮᩣ ᩋᨶᩩᨾᨬ᩠ᨬᩣᩈᩥ, ᩋᨸᩥ ᨶᩮᩣ ᨩᩦᩅᩥᨲᩴ ᨴᨴᩮ’’.

᪒᪖.

‘‘ᨶ ᨧᩮᩅ ᨾᩮ ᨲ᩠ᩅᩴ ᨻᨴ᩠ᨵᩮᩣᩈᩥ, ᨶᨸᩥ ᩍᨧ᩠ᨨᩣᨾᩥ ᨲᩮ ᩅᨵᩴ;

ᨠᩣᨾᩴ ᨡᩥᨸ᩠ᨸᨾᩥᨲᩮᩣ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᨩᩦᩅ ᨲ᩠ᩅᩴ ᩋᨶᩥᨥᩮᩣ ᨧᩥᩁᩴ’’.

᪒᪗.

‘‘ᨶᩮᩅᩣᩉᨾᩮᨲᨾᩥᨧ᩠ᨨᩣᨾᩥ ¶ , ᩋᨬ᩠ᨬᨲᩕᩮᨲᩔ ᨩᩦᩅᩥᨲᩣ;

ᩈᨧᩮ ᩑᨠᩮᨶ ᨲᩩᨭ᩠ᨮᩮᩣᩈᩥ, ᨾᩩᨬ᩠ᨧᩮᨲᩴ ᨾᨬ᩠ᨧ ᨽᨠ᩠ᨡᨿ.

᪒᪘.

‘‘ᩌᩁᩮᩣᩉᨸᩁᩥᨱᩣᩉᩮᨶ, ᨲᩩᩃ᩠ᨿᩣᩈ᩠ᨾᩣ [ᨲᩩᩃ᩠ᨿᩣᨾ᩠ᩉᩣ (ᨠ.)] ᩅᨿᩈᩣ ᩏᨽᩮᩣ;

ᨶ ᨲᩮ ᩃᩣᨽᩮᨶ ᨩᩦᩅᨲ᩠ᨳᩥ [ᨩᩦᨶᨲ᩠ᨳᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩑᨲᩮᨶ ᨶᩥᨾᩥᨶᩣ ᨲᩩᩅᩴ.

᪒᪙.

‘‘ᨲᨴᩥᨦ᩠ᨥ ¶ ᩈᨾᨸᩮᨠ᩠ᨡᩔᩩ [ᩈᨾᩅᩮᨠ᩠ᨡᩈᩩ (ᩈᩦ. ᨸᩦ.)], ᩉᩮᩣᨲᩩ ᨣᩥᨴ᩠ᨵᩥ ᨲᩅᨾ᩠ᩉᩈᩩ [ᨲᩅᩈ᩠ᨾᩈᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

ᨾᩴ ᨸᩩᨻ᩠ᨻᩮ ᨻᨶ᩠ᨵ ᨸᩣᩈᩮᨶ, ᨸᨧ᩠ᨨᩣ ᨾᩩᨬ᩠ᨧ ᨴᩥᨩᩣᨵᩥᨸᩴ.

᪓᪐.

‘‘ᨲᩣᩅᨴᩮᩅ ᨧ ᨲᩮ ᩃᩣᨽᩮᩣ, ᨠᨲᩣᩔ [ᨠᨲᩔᩣ (ᩈᩦ. ᨸᩦ.)] ᨿᩣᨧᨶᩣᨿ ᨧ;

ᨾᩥᨲ᩠ᨲᩥ ᨧ ᨵᨲᩁᨭ᩠ᨮᩮᩉᩥ, ᨿᩣᩅᨩᩦᩅᩣᨿ ᨲᩮ ᩈᩥᨿᩣ’’.

᪓᪑.

‘‘ᨸᩔᨶ᩠ᨲᩩ ᨶᩮᩣ ᨾᩉᩣᩈᨦ᩠ᨥᩣ, ᨲᨿᩣ ᨾᩩᨲ᩠ᨲᩴ ᩍᨲᩮᩣ ᨣᨲᩴ;

ᨾᩥᨲ᩠ᨲᩣᨾᨧ᩠ᨧᩣ ᨧ ᨽᨧ᩠ᨧᩣ ᨧ, ᨸᩩᨲ᩠ᨲᨴᩣᩁᩣ ᨧ ᨻᨶ᩠ᨵᩅᩣ.

᪓᪒.

‘‘ᨶ ᨧ ᨲᩮ ᨲᩣᨴᩥᩈᩣ ᨾᩥᨲ᩠ᨲᩣ, ᨻᩉᩪᨶᩴ [ᨻᩉᩩᨶ᩠ᨶᩴ (ᩈᩦ. ᨸᩦ.)] ᩍᨵ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᨿᨳᩣ ᨲ᩠ᩅᩴ ᨵᨲᩁᨭ᩠ᨮᩔ, ᨸᩣᨱᩈᩣᨵᩣᩁᨱᩮᩣ ᩈᨡᩣ.

᪓᪓.

‘‘ᩈᩮᩣ ᨲᩮ ᩈᩉᩣᨿᩴ ᨾᩩᨬ᩠ᨧᩣᨾᩥ, ᩉᩮᩣᨲᩩ ᩁᩣᨩᩣ ᨲᩅᩣᨶᩩᨣᩮᩣ;

ᨠᩣᨾᩴ ᨡᩥᨸ᩠ᨸᨾᩥᨲᩮᩣ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᨬᩣᨲᩥᨾᨩ᩠ᨫᩮ ᩅᩥᩁᩮᩣᨧᨳ’’.

᪓᪔.

‘‘ᩈᩮᩣ ᨸᨲᩦᨲᩮᩣ ᨸᨾᩩᨲ᩠ᨲᩮᨶ, ᨽᨲ᩠ᨲᩩᨶᩣ [ᨽᨲ᩠ᨲᩩᨶᩮᩣ (ᩈ᩠ᨿᩣ.)] ᨽᨲ᩠ᨲᩩᨣᩣᩁᩅᩮᩣ;

ᩋᨩ᩠ᨫᨽᩣᩈᨳ ᩅᨠ᩠ᨠᨦ᩠ᨣᩮᩣ [ᩅᨦ᩠ᨠᨦ᩠ᨣᩮᩣ (ᩈ᩠ᨿᩣ.)], ᩅᩣᨧᩴ ᨠᨱ᩠ᨱᩈᩩᨡᩴ ᨽᨱᩴ.

᪓᪕.

‘‘ᩑᩅᩴ ᩃᩩᨴ᩠ᨴᨠ ᨶᨶ᩠ᨴᩔᩩ, ᩈᩉ ᩈᨻ᩠ᨻᩮᩉᩥ ᨬᩣᨲᩥᨽᩥ;

ᨿᨳᩣᩉᨾᨩ᩠ᨩ ᨶᨶ᩠ᨴᩣᨾᩥ, ᨾᩩᨲ᩠ᨲᩴ ᨴᩥᩈ᩠ᩅᩣ ᨴᩥᨩᩣᨵᩥᨸᩴ’’.

᪓᪖.

‘‘ᩑᩉᩥ ¶ ᨲᩴ ᩋᨶᩩᩈᩥᨠ᩠ᨡᩣᨾᩥ, ᨿᨳᩣ ᨲ᩠ᩅᨾᨸᩥ ᩃᨧ᩠ᨨᩈᩮ;

ᩃᩣᨽᩴ ᨲᩅᩣᨿᩴ [ᨿᨳᩣᨿᩴ (ᩈᩦ. ᨸᩦ.)] ᨵᨲᩁᨭ᩠ᨮᩮᩣ, ᨸᩣᨸᩴ ᨠᩥᨬ᩠ᨧᩥ [ᨠᨬ᩠ᨧᩥ (ᩈᩦ.)] ᨶ ᨴᨠ᩠ᨡᨲᩥ.

᪓᪗.

‘‘ᨡᩥᨸ᩠ᨸᨾᨶ᩠ᨲᩮᨸᩩᩁᩴ ᨶᩮᨲ᩠ᩅᩣ [ᨣᨶ᩠ᨲ᩠ᩅᩣ (ᩈ᩠ᨿᩣ. ᨠ.)], ᩁᨬ᩠ᨬᩮᩣ ᨴᩔᩮᩉᩥ ᨶᩮᩣ ᩏᨽᩮᩣ;

ᩋᨻᨴ᩠ᨵᩮ ᨸᨠᨲᩥᨽᩪᨲᩮ, ᨠᩣᨩᩮ [ᨠᩣᨧᩮ (ᨸᩦ.)] ᩏᨽᨿᨲᩮᩣ ᨮᩥᨲᩮ.

᪓᪘.

‘‘ᨵᨲᩁᨭ᩠ᨮᩣ ᨾᩉᩣᩁᩣᨩ, ᩉᩴᩈᩣᨵᩥᨸᨲᩥᨶᩮᩣ ᩍᨾᩮ;

ᩋᨿᨬ᩠ᩉᩥ ¶ ᩁᩣᨩᩣ ᩉᩴᩈᩣᨶᩴ, ᩋᨿᩴ ᩈᩮᨶᩣᨸᨲᩦᨲᩁᩮᩣ.

᪓᪙.

‘‘ᩋᩈᩴᩈᨿᩴ ᩍᨾᩴ ᨴᩥᩈ᩠ᩅᩣ, ᩉᩴᩈᩁᩣᨩᩴ ᨶᩁᩣᨵᩥᨸᩮᩣ;

ᨸᨲᩦᨲᩮᩣ ᩈᩩᨾᨶᩮᩣ ᩅᩥᨲ᩠ᨲᩮᩣ [ᨧᩥᨲ᩠ᨲᩮᩣ (ᨠ.)], ᨻᩉᩩᩴ ᨴᩔᨲᩥ ᨲᩮ ᨵᨶᩴ’’.

᪔᪐.

‘‘ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨠᨾ᩠ᨾᩩᨶᩣ ᩏᨸᨸᩣᨴᨿᩥ;

ᨡᩥᨸ᩠ᨸᨾᨶ᩠ᨲᩮᨸᩩᩁᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩁᨬ᩠ᨬᩮᩣ ᩉᩴᩈᩮ ᩋᨴᩔᨿᩥ;

ᩋᨻᨴ᩠ᨵᩮ ᨸᨠᨲᩥᨽᩪᨲᩮ, ᨠᩣᨩᩮ ᩏᨽᨿᨲᩮᩣ ᨮᩥᨲᩮ.

᪔᪑.

‘‘ᨵᨲᩁᨭ᩠ᨮᩣ ¶ ᨾᩉᩣᩁᩣᨩ, ᩉᩴᩈᩣᨵᩥᨸᨲᩥᨶᩮᩣ ᩍᨾᩮ;

ᩋᨿᨬ᩠ᩉᩥ ᩁᩣᨩᩣ ᩉᩴᩈᩣᨶᩴ, ᩋᨿᩴ ᩈᩮᨶᩣᨸᨲᩦᨲᩁᩮᩣ’’.

᪔᪒.

‘‘ᨠᨳᩴ ᨸᨶᩥᨾᩮ ᩅᩥᩉᨦ᩠ᨣᩣ [ᩅᩥᩉᨣᩣ (ᩈᩦ. ᨸᩦ.)], ᨲᩅ ᩉᨲ᩠ᨳᨲ᩠ᨲᨾᩣᨣᨲᩣ [ᩉᨲ᩠ᨳᨲ᩠ᨳ’ᨾᩣᨣᨲᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᨠᨳᩴ ᩃᩩᨴ᩠ᨴᩮᩣ ᨾᩉᨶ᩠ᨲᩣᨶᩴ, ᩍᩔᩁᩮ ᩍᨵ ᩋᨩ᩠ᨫᨣᩣ’’.

᪔᪓.

‘‘ᩅᩥᩉᩥᨲᩣ ᩈᨶ᩠ᨲᩥᨾᩮ ᨸᩣᩈᩣ, ᨸᩃ᩠ᩃᩃᩮᩈᩩ ᨩᨶᩣᨵᩥᨸ;

ᨿᩴ ᨿᨴᩣᨿᨲᨶᩴ ᨾᨬ᩠ᨬᩮ, ᨴᩥᨩᩣᨶᩴ ᨸᩣᨱᩁᩮᩣᨵᨶᩴ.

᪔᪔.

‘‘ᨲᩣᨴᩥᩈᩴ ᨸᩣᩈᨾᩣᩈᨩ᩠ᨩ, ᩉᩴᩈᩁᩣᨩᩣ ᩋᨻᨩ᩠ᨫᨳ;

ᨲᩴ ᩋᨻᨴ᩠ᨵᩮᩣ ᩏᨸᩣᩈᩦᨶᩮᩣ, ᨾᨾᩣᨿᩴ ᩋᨩ᩠ᨫᨽᩣᩈᨳ.

᪔᪕.

‘‘ᩈᩩᨴᩩᨠ᩠ᨠᩁᩴ ᩋᨶᩁᩥᨿᩮᩉᩥ, ᨴᩉᨲᩮ ᨽᩣᩅᨾᩩᨲ᩠ᨲᨾᩴ;

ᨽᨲ᩠ᨲᩩᩁᨲ᩠ᨳᩮ ᨸᩁᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᨵᨾ᩠ᨾᨿᩩᨲ᩠ᨲᩮᩣ [ᨵᨾ᩠ᨾᩮ ᨿᩩᨲ᩠ᨲᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᩅᩥᩉᨦ᩠ᨣᨾᩮᩣ.

᪔᪖.

‘‘ᩋᨲ᩠ᨲᨶᩣᨿᩴ [ᩋᨲ᩠ᨲᨶᩮᩣ ᨿᩴ (ᩈ᩠ᨿᩣ.)] ᨧᨩᩥᨲ᩠ᩅᩣᨶ, ᨩᩦᩅᩥᨲᩴ ᨩᩦᩅᩥᨲᩣᩁᩉᩮᩣ;

ᩋᨶᩩᨲ᩠ᨳᩩᨶᨶ᩠ᨲᩮᩣ ᩌᩈᩦᨶᩮᩣ, ᨽᨲ᩠ᨲᩩ ᨿᩣᨧᩥᨲ᩠ᨳ ᨩᩦᩅᩥᨲᩴ.

᪔᪗.

‘‘ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨸᩈᩣᨴᨾᩉᨾᨩ᩠ᨫᨣᩣ;

ᨲᨲᩮᩣ ᨶᩴ ᨸᩣᨾᩩᨧᩥᩴ [ᨸᩣᨾᩩᨬ᩠ᨧᩥᩴ (ᨸᩦ. ᨠ.)] ᨸᩣᩈᩣ, ᩋᨶᩩᨬ᩠ᨬᩣᩈᩥᩴ ᩈᩩᨡᩮᨶ ᨧ.

᪔᪘.

‘‘‘ᩈᩮᩣ ¶ ¶ ᨸᨲᩦᨲᩮᩣ ᨸᨾᩩᨲ᩠ᨲᩮᨶ, ᨽᨲ᩠ᨲᩩᨶᩣ ᨽᨲ᩠ᨲᩩᨣᩣᩁᩅᩮᩣ;

ᩋᨩ᩠ᨫᨽᩣᩈᨳ ᩅᨠ᩠ᨠᨦ᩠ᨣᩮᩣ, ᩅᩣᨧᩴ ᨠᨱ᩠ᨱᩈᩩᨡᩴ ᨽᨱᩴ.

᪔᪙.

‘‘‘ᩑᩅᩴ ᩃᩩᨴ᩠ᨴᨠ ᨶᨶ᩠ᨴᩔᩩ, ᩈᩉ ᩈᨻ᩠ᨻᩮᩉᩥ ᨬᩣᨲᩥᨽᩥ;

ᨿᨳᩣᩉᨾᨩ᩠ᨩ ᨶᨶ᩠ᨴᩣᨾᩥ, ᨾᩩᨲ᩠ᨲᩴ ᨴᩥᩈ᩠ᩅᩣ ᨴᩥᨩᩣᨵᩥᨸᩴ.

᪕᪐.

‘‘‘ᩑᩉᩥ ᨲᩴ ᩋᨶᩩᩈᩥᨠ᩠ᨡᩣᨾᩥ, ᨿᨳᩣ ᨲ᩠ᩅᨾᨸᩥ ᩃᨧ᩠ᨨᩈᩮ;

ᩃᩣᨽᩴ ᨲᩅᩣᨿᩴ ᨵᨲᩁᨭ᩠ᨮᩮᩣ, ᨸᩣᨸᩴ ᨠᩥᨬ᩠ᨧᩥ ᨶ ᨴᨠ᩠ᨡᨲᩥ.

᪕᪑.

‘‘‘ᨡᩥᨸ᩠ᨸᨾᨶ᩠ᨲᩮᨸᩩᩁᩴ ᨶᩮᨲ᩠ᩅᩣ [ᨣᨶ᩠ᨲ᩠ᩅᩣ (ᩈᨻ᩠ᨻᨲ᩠ᨳ)], ᩁᨬ᩠ᨬᩮᩣ ᨴᩔᩮᩉᩥ ᨶᩮᩣ ᩏᨽᩮᩣ;

ᩋᨻᨴ᩠ᨵᩮ ᨸᨠᨲᩥᨽᩪᨲᩮ, ᨠᩣᨩᩮ ᩏᨽᨿᨲᩮᩣ ᨮᩥᨲᩮ.

᪕᪒.

‘‘‘ᨵᨲᩁᨭ᩠ᨮᩣ ᨾᩉᩣᩁᩣᨩ, ᩉᩴᩈᩣᨵᩥᨸᨲᩥᨶᩮᩣ ᩍᨾᩮ;

ᩋᨿᨬ᩠ᩉᩥ ᩁᩣᨩᩣ ᩉᩴᩈᩣᨶᩴ, ᩋᨿᩴ ᩈᩮᨶᩣᨸᨲᩦᨲᩁᩮᩣ.

᪕᪓.

‘‘‘ᩋᩈᩴᩈᨿᩴ ᩍᨾᩴ ᨴᩥᩈ᩠ᩅᩣ, ᩉᩴᩈᩁᩣᨩᩴ ᨶᩁᩣᨵᩥᨸᩮᩣ;

ᨸᨲᩦᨲᩮᩣ ᩈᩩᨾᨶᩮᩣ ᩅᩥᨲ᩠ᨲᩮᩣ, ᨻᩉᩩᩴ ᨴᩔᨲᩥ ᨲᩮ ᨵᨶᩴ’.

᪕᪔.

‘‘ᩑᩅᨾᩮᨲᩔ ᩅᨧᨶᩣ, ᩌᨶᩦᨲᩣᨾᩮ ᩏᨽᩮᩣ ᨾᨿᩣ;

ᩑᨲ᩠ᨳᩮᩅ ᩉᩥ ᩍᨾᩮ ᩌᩈᩩᩴ [ᩋᩔᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩏᨽᩮᩣ ᩋᨶᩩᨾᨲᩣ ᨾᨿᩣ.

᪕᪕.

‘‘ᩈᩮᩣᨿᩴ ᩑᩅᩴ ᨣᨲᩮᩣ ᨸᨠ᩠ᨡᩦ, ᨴᩥᨩᩮᩣ ᨸᩁᨾᨵᨾ᩠ᨾᩥᨠᩮᩣ;

ᨾᩣᨴᩥᩈᩔ ᩉᩥ ᩃᩩᨴ᩠ᨴᩔ, ᨩᨶᨿᩮᨿ᩠ᨿᩣᨳ ᨾᨴ᩠ᨴᩅᩴ.

᪕᪖.

‘‘ᩏᨸᩣᨿᨶᨬ᩠ᨧ ¶ ᨲᩮ ᨴᩮᩅ, ᨶᩣᨬ᩠ᨬᩴ ᨸᩔᩣᨾᩥ ᩑᨴᩥᩈᩴ;

ᩈᨻ᩠ᨻᩈᩣᨠᩩᨱᩥᨠᩣᨣᩣᨾᩮ, ᨲᩴ ᨸᩔ ᨾᨶᩩᨩᩣᨵᩥᨸ’’.

᪕᪗.

‘‘ᨴᩥᩈ᩠ᩅᩣ ᨶᩥᩈᩥᨶ᩠ᨶᩴ ᩁᩣᨩᩣᨶᩴ, ᨸᩦᨮᩮ ᩈᩮᩣᩅᨱ᩠ᨱᨿᩮ ᩈᩩᨽᩮ;

ᩋᨩ᩠ᨫᨽᩣᩈᨳ ᩅᨠ᩠ᨠᨦ᩠ᨣᩮᩣ, ᩅᩣᨧᩴ ᨠᨱ᩠ᨱᩈᩩᨡᩴ ᨽᨱᩴ.

᪕᪘.

‘‘ᨠᨧ᩠ᨧᩥᨶ᩠ᨶᩩ ¶ ᨽᩮᩣᨲᩮᩣ ᨠᩩᩈᩃᩴ, ᨠᨧ᩠ᨧᩥ ᨽᩮᩣᨲᩮᩣ ᩋᨶᩣᨾᨿᩴ;

ᨠᨧ᩠ᨧᩥ ᩁᨭ᩠ᨮᨾᩥᨴᩴ ᨹᩦᨲᩴ, ᨵᨾ᩠ᨾᩮᨶ ᨾᨶᩩᩈᩣᩈᩈᩥ’’.

᪕᪙.

‘‘ᨠᩩᩈᩃᨬ᩠ᨧᩮᩅ ᨾᩮ ᩉᩴᩈ, ᩋᨳᩮᩣ ᩉᩴᩈ ᩋᨶᩣᨾᨿᩴ;

ᩋᨳᩮᩣ ᩁᨭ᩠ᨮᨾᩥᨴᩴ ᨹᩦᨲᩴ, ᨵᨾ᩠ᨾᩮᨶ ᨾᨶᩩᩈᩣᩈᩉᩴ’’ [ᨾᨶᩩᩈᩥᩔᨲᩥ (ᩈᩦ. ᨸᩦ.)].

᪖᪐.

‘‘ᨠᨧ᩠ᨧᩥ ᨽᩮᩣᨲᩮᩣ ᩋᨾᨧ᩠ᨧᩮᩈᩩ, ᨴᩮᩣᩈᩮᩣ ᨠᩮᩣᨧᩥ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᨠᨧ᩠ᨧᩥ ᨧ [ᨠᨧ᩠ᨧᩥᨶ᩠ᨶᩩ (ᩈᩦ. ᨸᩦ.)] ᨲᩮ ᨲᩅᨲ᩠ᨳᩮᩈᩩ, ᨶᩣᩅᨠᨦ᩠ᨡᨶ᩠ᨲᩥ ᨩᩦᩅᩥᨲᩴ’’.

᪖᪑.

‘‘ᩋᨳᩮᩣᨸᩥ ¶ ᨾᩮ ᩋᨾᨧ᩠ᨧᩮᩈᩩ, ᨴᩮᩣᩈᩮᩣ ᨠᩮᩣᨧᩥ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᩋᨳᩮᩣᨸᩥ ᨲᩮ [ᩋᨳᩮᩣᨸᩥᨾᩮ (ᩈᩦ. ᨸᩦ.)] ᨾᨾᨲ᩠ᨳᩮᩈᩩ, ᨶᩣᩅᨠᨦ᩠ᨡᨶ᩠ᨲᩥ ᨩᩦᩅᩥᨲᩴ’’.

᪖᪒.

‘‘ᨠᨧ᩠ᨧᩥ ᨲᩮ ᩈᩣᨴᩥᩈᩦ ᨽᩁᩥᨿᩣ, ᩋᩔᩅᩣ ᨸᩥᨿᨽᩣᨱᩥᨶᩦ;

ᨸᩩᨲ᩠ᨲᩁᩪᨸᨿᩈᩪᨸᩮᨲᩣ, ᨲᩅ ᨨᨶ᩠ᨴᩅᩈᩣᨶᩩᨣᩣ’’.

᪖᪓.

‘‘ᩋᨳᩮᩣ ᨾᩮ ᩈᩣᨴᩥᩈᩦ ᨽᩁᩥᨿᩣ, ᩋᩔᩅᩣ ᨸᩥᨿᨽᩣᨱᩥᨶᩦ;

ᨸᩩᨲ᩠ᨲᩁᩪᨸᨿᩈᩪᨸᩮᨲᩣ, ᨾᨾ ᨨᨶ᩠ᨴᩅᩈᩣᨶᩩᨣᩣ’’.

᪖᪔.

‘‘ᨽᩅᨶ᩠ᨲᩴ [ᨽᩅᩴ ᨲᩩ (ᩈᩦ. ᨸᩦ.), ᨽᩅᨶ᩠ᨶᩩ (ᩈ᩠ᨿᩣ.)] ᨠᨧ᩠ᨧᩥ ᨶᩩ ᨾᩉᩣ-ᩈᨲ᩠ᨲᩩᩉᨲ᩠ᨳᨲ᩠ᨲᨲᩴ [ᩉᨲ᩠ᨳᨲ᩠ᨳᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨣᨲᩮᩣ;

ᨴᩩᨠ᩠ᨡᨾᩣᨸᨩ᩠ᨩᩥ ᩅᩥᨸᩩᩃᩴ, ᨲᩈ᩠ᨾᩥᩴ ᨸᨮᨾᨾᩣᨸᨴᩮ.

᪖᪕.

‘‘ᨠᨧ᩠ᨧᩥ ᨿᨶ᩠ᨲᩣᨸᨲᩥᨲ᩠ᩅᩣᨶ, ᨴᨱ᩠ᨯᩮᨶ ᩈᨾᨸᩮᩣᨳᨿᩥ;

ᩑᩅᨾᩮᨲᩮᩈᩴ ᨩᨾ᩠ᨾᩣᨶᩴ, ᨸᩣᨲᩥᨠᩴ [ᨸᩣᨠᨲᩥᨠᩴ (ᩈᩦ. ᨸᩦ.)] ᨽᩅᨲᩥ ᨲᩣᩅᨴᩮ’’.

᪖᪖.

‘‘ᨡᩮᨾᨾᩣᩈᩥ ᨾᩉᩣᩁᩣᨩ, ᩑᩅᨾᩣᨸᨴᩥᨿᩣ ᩈᨲᩥ [ᩑᩅᨾᩣᨸᨴᩥ ᩈᩴᩈᨲᩥ (ᩈᩦ. ᨸᩦ.)];

ᨶ ᨧᩣᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᩁᩈ᩠ᨾᩣᩈᩩ, ᩈᨲ᩠ᨲᩪᩅ ᩈᨾᨸᨩ᩠ᨩᨳ.

᪖᪗.

‘‘ᨸᨧ᩠ᨧᨣᨾᩥᨲ᩠ᨳ ᨶᩮᩈᩣᨴᩮᩣ, ᨸᩩᨻ᩠ᨻᩮᩅ ᩋᨩ᩠ᨫᨽᩣᩈᨳ;

ᨲᨴᩣᨿᩴ ᩈᩩᨾᩩᨡᩮᩣᨿᩮᩅ, ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᨸᨧ᩠ᨧᨽᩣᩈᨳ.

᪖᪘.

‘‘ᨲᩔ ¶ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨸᩈᩣᨴᨾᨿᨾᨩ᩠ᨫᨣᩣ;

ᨲᨲᩮᩣ ᨾᩴ ᨸᩣᨾᩩᨧᩦ ᨸᩣᩈᩣ, ᩋᨶᩩᨬ᩠ᨬᩣᩈᩥ ᩈᩩᨡᩮᨶ ᨧ.

᪖᪙.

‘‘ᩍᨴᨬ᩠ᨧ ᩈᩩᨾᩩᨡᩮᨶᩮᩅ, ᩑᨲᨴᨲ᩠ᨳᩣᨿ ᨧᩥᨶ᩠ᨲᩥᨲᩴ;

ᨽᩮᩣᨲᩮᩣ ᩈᨠᩣᩈᩮᨣᨾᨶᩴ [ᩈᨠᩣᩈᩮ + ᩌᨣᨾᨶᩴ], ᩑᨲᩔ ᨵᨶᨾᩥᨧ᩠ᨨᨲᩣ’’.

᪗᪐.

‘‘ᩈ᩠ᩅᩣᨣᨲᨬ᩠ᨧᩮᩅᩥᨴᩴ ᨽᩅᨲᩴ, ᨸᨲᩦᨲᩮᩣ ᨧᩈ᩠ᨾᩥ ᨴᩔᨶᩣ;

ᩑᩈᩮᩣ ᨧᩣᨸᩥ ᨻᩉᩩᩴ ᩅᩥᨲ᩠ᨲᩴ, ᩃᨽᨲᩴ ᨿᩣᩅᨴᩥᨧ᩠ᨨᨲᩥ’’ [ᨿᩣᩅᨲᩥᨧ᩠ᨨᨲᩥ (ᩈᩦ. ᨸᩦ.)].

᪗᪑.

‘‘ᩈᨶ᩠ᨲᨸ᩠ᨸᨿᩥᨲ᩠ᩅᩣ ¶ ᨶᩮᩈᩣᨴᩴ, ᨽᩮᩣᨣᩮᩉᩥ ᨾᨶᩩᨩᩣᨵᩥᨸᩮᩣ;

ᩋᨩ᩠ᨫᨽᩣᩈᨳ ᩅᨠ᩠ᨠᨦ᩠ᨣᩴ, ᩅᩣᨧᩴ ᨠᨱ᩠ᨱᩈᩩᨡᩴ ᨽᨱᩴ’’.

᪗᪒.

‘‘ᨿᩴ ᨡᩃᩩ ᨵᨾ᩠ᨾᨾᩣᨵᩦᨶᩴ, ᩅᩈᩮᩣ ᩅᨲ᩠ᨲᨲᩥ ᨠᩥᨬ᩠ᨧᨶᩴ;

ᩈᨻ᩠ᨻᨲ᩠ᨳᩥᩔᩁᩥᨿᩴ ᨲᩅ [ᩈᨻ᩠ᨻᨲ᩠ᨳᩥᩔᩁᩥᨿᩴ ᨽᩅᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.), ᩈᨻ᩠ᨻᩥᩔᩁᩥᨿᩴ ᨽᩅᨲᩴ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨲᩴ ᨸᩈᩣᩈ [ᨸᩈᩣᩈᨳ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨿᨴᩥᨧ᩠ᨨᨳ.

᪗᪓.

‘‘ᨴᩣᨶᨲ᩠ᨳᩴ ¶ ᩏᨸᨽᩮᩣᨲ᩠ᨲᩩᩴ ᩅᩣ, ᨿᩴ ᨧᨬ᩠ᨬᩴ ᩏᨸᨠᨸ᩠ᨸᨲᩥ;

ᩑᨲᩴ ᨴᨴᩣᨾᩥ ᩅᩮᩣ ᩅᩥᨲ᩠ᨲᩴ, ᩍᩔᩁᩥᨿᩴ [ᩍᩔᩮᩁᩴ (ᩈᩦ.), ᩍᩔᩁᩴ (ᨸᩦ.)] ᩅᩥᩔᨩᩣᨾᩥ ᩅᩮᩣ’’.

᪗᪔.

‘‘ᨿᨳᩣ ᨧ ᨾ᩠ᨿᩣᨿᩴ ᩈᩩᨾᩩᨡᩮᩣ, ᩋᨩ᩠ᨫᨽᩣᩈᩮᨿ᩠ᨿ ᨸᨱ᩠ᨯᩥᨲᩮᩣ;

ᨠᩣᨾᩈᩣ ᨻᩩᨴ᩠ᨵᩥᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᨲᩴ ᨾ᩠ᨿᩣᩔ ᨸᩁᨾᨸ᩠ᨸᩥᨿᩴ’’.

᪗᪕.

‘‘ᩋᩉᩴ ᨡᩃᩩ ᨾᩉᩣᩁᩣᨩ, ᨶᩣᨣᩁᩣᨩᩣᩁᩥᩅᨶ᩠ᨲᩁᩴ;

ᨸᨭᩥᩅᨲ᩠ᨲᩩᩴ ᨶ ᩈᨠ᩠ᨠᩮᩣᨾᩥ, ᨶ ᨾᩮ ᩈᩮᩣ ᩅᩥᨶᨿᩮᩣ ᩈᩥᨿᩣ.

᪗᪖.

‘‘ᩋᨾ᩠ᩉᩣᨠᨬ᩠ᨧᩮᩅ ᩈᩮᩣ [ᨿᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᩈᩮᨭ᩠ᨮᩮᩣ, ᨲ᩠ᩅᨬ᩠ᨧ ᩏᨲ᩠ᨲᨾᩈᨲ᩠ᨲᩅᩮᩣ;

ᨽᩪᨾᩥᨸᩣᩃᩮᩣ ᨾᨶᩩᩔᩥᨶ᩠ᨴᩮᩣ, ᨸᩪᨩᩣ ᨻᩉᩪᩉᩥ ᩉᩮᨲᩩᩉᩥ.

᪗᪗.

‘‘ᨲᩮᩈᩴ ᩏᨽᩥᨶ᩠ᨶᩴ ᨽᨱᨲᩴ, ᩅᨲ᩠ᨲᨾᩣᨶᩮ ᩅᩥᨶᩥᨧ᩠ᨨᨿᩮ;

ᨶᨶ᩠ᨲᩁᩴ [ᨶᩣᨶ᩠ᨲᩁᩴ (ᩈᩦ. ᨸᩦ.)] ᨸᨭᩥᩅᨲ᩠ᨲᨻ᩠ᨻᩴ, ᨸᩮᩔᩮᨶ [ᨸᩮᩈᩮᨶ (ᨠ.)] ᨾᨶᩩᨩᩣᨵᩥᨸ’’.

᪗᪘.

‘‘ᨵᨾ᩠ᨾᩮᨶ ¶ ᨠᩥᩁ ᨶᩮᩈᩣᨴᩮᩣ, ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᩋᨱ᩠ᨯᨩᩮᩣ ᩍᨲᩥ;

ᨶ ᩉᩮᩅ ᩋᨠᨲᨲ᩠ᨲᩔ, ᨶᨿᩮᩣ ᩑᨲᩣᨴᩥᩈᩮᩣ ᩈᩥᨿᩣ.

᪗᪙.

‘‘ᩑᩅᩴ ᩋᨣ᩠ᨣᨸᨠᨲᩥᨾᩣ, ᩑᩅᩴ ᩏᨲ᩠ᨲᨾᩈᨲ᩠ᨲᩅᩮᩣ;

ᨿᩣᩅᨲᨲ᩠ᨳᩥ ᨾᨿᩣ ᨴᩥᨭ᩠ᨮᩣ, ᨶᩣᨬ᩠ᨬᩴ ᨸᩔᩣᨾᩥ ᩑᨴᩥᩈᩴ.

᪘᪐.

‘‘ᨲᩩᨭ᩠ᨮᩮᩣᩈ᩠ᨾᩥ ᩅᩮᩣ ᨸᨠᨲᩥᨿᩣ, ᩅᩣᨠ᩠ᨿᩮᨶ ᨾᨵᩩᩁᩮᨶ ᨧ;

ᩑᩈᩮᩣ ᨧᩣᨸᩥ ᨾᨾᨧ᩠ᨨᨶ᩠ᨴᩮᩣ, ᨧᩥᩁᩴ ᨸᩔᩮᨿ᩠ᨿ ᩅᩮᩣ ᩏᨽᩮᩣ’’.

᪘᪑.

‘‘ᨿᩴ ᨠᩥᨧ᩠ᨧᩴ [ᨿᩴᨠᩥᨬ᩠ᨧᩥ (ᨸᩦ.)] ᨸᩁᨾᩮ ᨾᩥᨲ᩠ᨲᩮ, ᨠᨲᨾᩈ᩠ᨾᩣᩈᩩ [ᩁᩈ᩠ᨾᩣᩈᩩ (ᩈᩦ. ᨸᩦ.)] ᨲᩴ ᨲᨿᩣ;

ᨸᨲ᩠ᨲᩣ ᨶᩥᩔᩴᩈᨿᩴ ᨲ᩠ᨿᩣᨾ᩠ᩉᩣ [ᨲ᩠ᨿᨾ᩠ᩉᩣ (ᨸᩦ.)], ᨽᨲ᩠ᨲᩥᩁᩈ᩠ᨾᩣᩈᩩ ᨿᩣ ᨲᩅ.

᪘᪒.

‘‘ᩋᨴᩩᨬ᩠ᨧ ᨶᩪᨶ ᩈᩩᨾᩉᩣ, ᨬᩣᨲᩥᩈᨦ᩠ᨥᩔ ᨾᨶ᩠ᨲᩁᩴ;

ᩋᨴᩔᨶᩮᨶ ᩋᩈ᩠ᨾᩣᨠᩴ [ᩋᨾ᩠ᩉᩣᨠᩴ (ᩈᩦ. ᨸᩦ.)], ᨴᩩᨠ᩠ᨡᩴ ᨻᩉᩪᩈᩩ ᨸᨠ᩠ᨡᩥᩈᩩ.

᪘᪓.

‘‘ᨲᩮᩈᩴ ᩈᩮᩣᨠᩅᩥᨥᩣᨲᩣᨿ, ᨲᨿᩣ ᩋᨶᩩᨾᨲᩣ ᨾᨿᩴ;

ᨲᩴ ᨸᨴᨠ᩠ᨡᩥᨱᨲᩮᩣ ᨠᨲ᩠ᩅᩣ, ᨬᩣᨲᩥᩴ [ᨬᩣᨲᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᩔᩮᨾᩩᩁᩥᨶ᩠ᨴᨾ [ᨸᩔᩮᨾᩁᩥᨶ᩠ᨴᨾ (ᩈᩦ. ᨸᩦ.)].

᪘᪔.

‘‘ᩋᨴ᩠ᨵᩣᩉᩴ ᩅᩥᨸᩩᩃᩴ ᨸᩦᨲᩥᩴ, ᨽᩅᨲᩴ ᩅᩥᨶ᩠ᨴᩣᨾᩥ ᨴᩔᨶᩣ;

ᩑᩈᩮᩣ ᨧᩣᨸᩥ ᨾᩉᩣ ᩋᨲ᩠ᨳᩮᩣ, ᨬᩣᨲᩥᩅᩥᩔᩣᩈᨶᩣ ᩈᩥᨿᩣ’’.

᪘᪕.

‘‘ᩍᨴᩴ ¶ ᩅᨲ᩠ᩅᩣ ᨵᨲᩁᨭ᩠ᨮᩮᩣ [ᨵᨲᩁᨭ᩠ᨮᩣ (ᩈᩦ.)], ᩉᩴᩈᩁᩣᨩᩣ ᨶᩁᩣᨵᩥᨸᩴ;

ᩏᨲ᩠ᨲᨾᩴ ᨩᩅᨾᨶ᩠ᩅᩣᨿ [ᩏᨲ᩠ᨲᨾᨩᩅᨾᨲ᩠ᨲᩣᨿ (ᩈᩦ. ᨸᩦ.)], ᨬᩣᨲᩥᩈᨦ᩠ᨥᩴ ᩏᨸᩣᨣᨾᩩᩴ.

᪘᪖.

‘‘ᨲᩮ ¶ ᩋᩁᩮᩣᨣᩮ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮ, ᨴᩥᩈ᩠ᩅᩣᨶ ᨸᩁᨾᩮ ᨴᩥᨩᩮ;

ᨠᩮᨠᩣᨲᩥ ᨾᨠᩁᩩᩴ ᩉᩴᩈᩣ, ᨸᩩᨳᩩᩈᨴ᩠ᨴᩮᩣ ᩋᨩᩣᨿᨳ.

᪘᪗.

‘‘ᨲᩮ ᨸᨲᩦᨲᩣ ᨸᨾᩩᨲ᩠ᨲᩮᨶ, ᨽᨲ᩠ᨲᩩᨶᩣ ᨽᨲ᩠ᨲᩩᨣᩣᩁᩅᩣ;

ᩈᨾᨶ᩠ᨲᩣ ᨸᩁᩥᨠᩥᩁᩥᩴᩈᩩ [ᨸᩁᩥᨠᩁᩥᩴᩈᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩋᨱ᩠ᨯᨩᩣ ᩃᨴ᩠ᨵᨸᨧ᩠ᨧᨿᩣ’’.

᪘᪘.

‘‘ᩑᩅᩴ ¶ ᨾᩥᨲ᩠ᨲᩅᨲᩴ ᩋᨲ᩠ᨳᩣ, ᩈᨻ᩠ᨻᩮ ᩉᩮᩣᨶ᩠ᨲᩥ ᨸᨴᨠ᩠ᨡᩥᨱᩣ;

ᩉᩴᩈᩣ ᨿᨳᩣ ᨵᨲᩁᨭ᩠ᨮᩣ, ᨬᩣᨲᩥᩈᨦ᩠ᨥᩴ ᩏᨸᩣᨣᨾᩩ’’ᨶ᩠ᨲᩥ.

ᨧᩪᩊ [ᨧᩩᩃ᩠ᩃ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩉᩴᩈᨩᩣᨲᨠᩴ ᨸᨮᨾᩴ.

᪕᪓᪔. ᨾᩉᩣᩉᩴᩈᨩᩣᨲᨠᩴ (᪒)

᪘᪙.

‘‘ᩑᨲᩮ ᩉᩴᩈᩣ ᨸᨠ᩠ᨠᨾᨶ᩠ᨲᩥ, ᩅᨠ᩠ᨠᨦ᩠ᨣᩣ ᨽᨿᨾᩮᩁᩥᨲᩣ;

ᩉᩁᩥᨲ᩠ᨲᨧ ᩉᩮᨾᩅᨱ᩠ᨱ, ᨠᩣᨾᩴ ᩈᩩᨾᩩᨡ ᨸᨠ᩠ᨠᨾ.

᪙᪐.

‘‘ᩒᩉᩣᨿ ᨾᩴ ᨬᩣᨲᩥᨣᨱᩣ, ᩑᨠᩴ ᨸᩣᩈᩅᩈᩴ ᨣᨲᩴ;

ᩋᨶᨸᩮᨠ᩠ᨡᨾᩣᨶᩣ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨠᩥᩴ ᩑᨠᩮᩣ ᩋᩅᩉᩦᨿᩈᩥ.

᪙᪑.

‘‘ᨸᨲᩮᩅ ᨸᨲᨲᩴ ᩈᩮᨭ᩠ᨮ, ᨶᨲ᩠ᨳᩥ ᨻᨴ᩠ᨵᩮ ᩈᩉᩣᨿᨲᩣ;

ᨾᩣ ᩋᨶᩦᨥᩣᨿ ᩉᩣᨸᩮᩈᩥ, ᨠᩣᨾᩴ ᩈᩩᨾᩩᨡ ᨸᨠ᩠ᨠᨾ’’.

᪙᪒.

‘‘ᨶᩣᩉᩴ ᨴᩩᨠ᩠ᨡᨸᩁᩮᨲᩮᩣᨸᩥ [ᨴᩩᨠ᩠ᨡᨸᩁᩮᨲᩮᩣ’’ᨲᩥ (ᨩᩣ. ᪑.᪑᪕.᪑᪓᪖) ᩋᨭ᩠ᨮᨠᨳᩣᨿᩮᩣ ᩒᩃᩮᩣᨠᩮᨲᨻ᩠ᨻᩣ], ᨵᨲᩁᨭ᩠ᨮ ᨲᩩᩅᩴ [ᨲᩅᩴ (ᩈᩦ. ᨸᩦ.)] ᨩᩉᩮ;

ᨩᩦᩅᩥᨲᩴ ᨾᩁᨱᩴ ᩅᩣ ᨾᩮ, ᨲᨿᩣ ᩈᨴ᩠ᨵᩥᩴ ᨽᩅᩥᩔᨲᩥ.

᪙᪓.

‘‘ᨶᩣᩉᩴ ᨴᩩᨠ᩠ᨡᨸᩁᩮᨲᩮᩣᨸᩥ, ᨵᨲᩁᨭ᩠ᨮ ᨲᩩᩅᩴ ᨩᩉᩮ;

ᨶ ᨾᩴ ᩋᨶᩁᩥᨿᩈᩴᨿᩩᨲ᩠ᨲᩮ, ᨠᨾ᩠ᨾᩮ ᨿᩮᩣᨩᩮᨲᩩᨾᩁᩉᩈᩥ.

᪙᪔.

‘‘ᩈᨠᩩᨾᩣᩁᩮᩣ ᩈᨡᩣ ᨲ᩠ᨿᩈ᩠ᨾᩥ, ᩈᨧᩥᨲ᩠ᨲᩮ ᨧᩈ᩠ᨾᩥ ᨲᩮ [ᩈᨾᩥᨲᩮ (ᨸᩦ.), ᨲ᩠ᨿᩈ᩠ᨾᩥ ᨲᩮ (ᨠ.)] ᨮᩥᨲᩮᩣ;

ᨬᩣᨲᩮᩣ ᩈᩮᨶᩣᨸᨲᩥ ᨲ᩠ᨿᩣᩉᩴ, ᩉᩴᩈᩣᨶᩴ ᨸᩅᩁᩩᨲ᩠ᨲᨾ.

᪙᪕.

‘‘ᨠᨳᩴ ¶ ᩋᩉᩴ ᩅᩥᨠᨲ᩠ᨳᩥᩔᩴ [ᩅᩥᨠᨲ᩠ᨲᩥᩔᩴ (ᨸᩦ.)], ᨬᩣᨲᩥᨾᨩ᩠ᨫᩮ ᩍᨲᩮᩣ ᨣᨲᩮᩣ;

ᨲᩴ ᩉᩥᨲ᩠ᩅᩣ ᨸᨲᨲᩴ ᩈᩮᨭ᩠ᨮ, ᨠᩥᩴ ᨲᩮ ᩅᨠ᩠ᨡᩣᨾᩥᨲᩮᩣ ᨣᨲᩮᩣ;

ᩍᨵ ᨸᩣᨱᩴ ᨧᨩᩥᩔᩣᨾᩥ, ᨶᩣᨶᩁᩥᨿᩴ [ᨶ ᩋᨶᩁᩥᨿᩴ (ᨸᩦ.)] ᨠᨲ᩠ᨲᩩᨾᩩᩔᩉᩮ’’.

᪙᪖.

‘‘ᩑᩈᩮᩣ ¶ ᩉᩥ ᨵᨾ᩠ᨾᩮᩣ ᩈᩩᨾᩩᨡ, ᨿᩴ ᨲ᩠ᩅᩴ ᩋᩁᩥᨿᨸᨳᩮ ᨮᩥᨲᩮᩣ;

ᨿᩮᩣ ᨽᨲ᩠ᨲᩣᩁᩴ ᩈᨡᩣᩁᩴ ᨾᩴ, ᨶ ᨸᩁᩥᨧ᩠ᨧᨲ᩠ᨲᩩᨾᩩᩔᩉᩮ.

᪙᪗.

‘‘ᨲᨬ᩠ᩉᩥ ᨾᩮ ᨸᩮᨠ᩠ᨡᨾᩣᨶᩔ, ᨽᨿᩴ ᨶᨲ᩠ᩅᩮᩅ ᨩᩣᨿᨲᩥ;

ᩋᨵᩥᨣᨧ᩠ᨨᩈᩥ ᨲ᩠ᩅᩴ ᨾᨿ᩠ᩉᩴ, ᩑᩅᩴ ᨽᩪᨲᩔ ᨩᩦᩅᩥᨲᩴ’’.

᪙᪘.

‘‘ᩍᨧ᩠ᨧᩮᩅᩴ ¶ [ᩍᨧ᩠ᨧᩮᩅ (ᩈᩦ. ᨸᩦ.)] ᨾᨶ᩠ᨲᨿᨶ᩠ᨲᩣᨶᩴ, ᩋᩁᩥᨿᩣᨶᩴ ᩋᩁᩥᨿᩅᩩᨲ᩠ᨲᩥᨶᩴ;

ᨴᨱ᩠ᨯᨾᩣᨴᩣᨿ ᨶᩮᩈᩣᨴᩮᩣ, ᩌᨸᨲᩦ [ᩌᨸᨴᩦ (ᨠ.)] ᨲᩩᩁᩥᨲᩮᩣ ᨽᩩᩈᩴ.

᪙᪙.

‘‘ᨲᨾᩣᨸᨲᨶ᩠ᨲᩴ ᨴᩥᩈ᩠ᩅᩣᨶ, ᩈᩩᨾᩩᨡᩮᩣ ᩋᨲᩥᨻᩕᩪᩉᨿᩥ [ᩋᨸᩁᩥᨻᩕᩪᩉᨿᩥ (ᩈᩦ. ᨸᩦ.)];

ᩋᨭ᩠ᨮᩣᩈᩥ ᨸᩩᩁᨲᩮᩣ ᩁᨬ᩠ᨬᩮᩣ, ᩉᩴᩈᩮᩣ ᩅᩥᩔᩣᩈᨿᩴ ᨻ᩠ᨿᨵᩴ [ᨻ᩠ᨿᨳᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪑᪐᪐.

‘‘ᨾᩣ ᨽᩣᨿᩥ ᨸᨲᨲᩴ ᩈᩮᨭ᩠ᨮ, ᨶ ᩉᩥ ᨽᩣᨿᨶ᩠ᨲᩥ ᨲᩣᨴᩥᩈᩣ;

ᩋᩉᩴ ᨿᩮᩣᨣᩴ ᨸᨿᩩᨬ᩠ᨩᩥᩔᩴ, ᨿᩩᨲ᩠ᨲᩴ ᨵᨾ᩠ᨾᩪᨸᩈᩴᩉᩥᨲᩴ;

ᨲᩮᨶ ᨸᩁᩥᨿᩣᨸᨴᩣᨶᩮᨶ [ᨸᩁᩥᨿᩣᨴᩣᨶᩮᨶ (ᨠ.)], ᨡᩥᨸ᩠ᨸᩴ ᨸᩣᩈᩣ ᨸᨾᩮᩣᨠ᩠ᨡᩈᩥ’’.

᪑᪐᪑.

‘‘ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩈᩩᨾᩩᨡᩔ ᩈᩩᨽᩣᩈᩥᨲᩴ;

ᨸᩉᨭ᩠ᨮᩃᩮᩣᨾᩮᩣ ᨶᩮᩈᩣᨴᩮᩣ, ᩋᨬ᩠ᨩᩃᩥᩔ ᨸᨱᩣᨾᨿᩥ.

᪑᪐᪒.

‘‘ᨶ ᨾᩮ ᩈᩩᨲᩴ ᩅᩣ ᨴᩥᨭ᩠ᨮᩴ ᩅᩣ, ᨽᩣᩈᨶ᩠ᨲᩮᩣ ᨾᩣᨶᩩᩈᩥᩴ ᨴᩥᨩᩮᩣ;

ᩋᩁᩥᨿᩴ ᨻᩕᩩᩅᩣᨶᩮᩣ [ᨻᩕᩪᩉᨶ᩠ᨲᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩅᨠ᩠ᨠᨦ᩠ᨣᩮᩣ, ᨧᨩᨶ᩠ᨲᩮᩣ ᨾᩣᨶᩩᩈᩥᩴ ᨣᩥᩁᩴ.

᪑᪐᪓.

‘‘ᨠᩥᨶ᩠ᨶᩩ ᨲᩣᨿᩴ ᨴᩥᨩᩮᩣ ᩉᩮᩣᨲᩥ, ᨾᩩᨲ᩠ᨲᩮᩣ ᨻᨴ᩠ᨵᩴ ᩏᨸᩣᩈᩈᩥ;

ᩒᩉᩣᨿ ᩈᨠᩩᨱᩣ ᨿᨶ᩠ᨲᩥ, ᨠᩥᩴ ᩑᨠᩮᩣ ᩋᩅᩉᩦᨿᩈᩥ’’.

᪑᪐᪔.

‘‘ᩁᩣᨩᩣ ᨾᩮ ᩈᩮᩣ ᨴᩥᨩᩣᨾᩥᨲ᩠ᨲ, ᩈᩮᨶᩣᨸᨧ᩠ᨧᩔ ᨠᩣᩁᨿᩥᩴ;

ᨲᨾᩣᨸᨴᩮ ᨸᩁᩥᨧ᩠ᨧᨲ᩠ᨲᩩᩴ, ᨶᩩᩔᩉᩮ ᩅᩥᩉᨣᩣᨵᩥᨸᩴ.

᪑᪐᪕.

‘‘ᨾᩉᩣᨣᨱᩣᨿ ᨽᨲ᩠ᨲᩣ ᨾᩮ, ᨾᩣ ᩑᨠᩮᩣ ᨻ᩠ᨿᩈᨶᩴ ᩋᨣᩣ;

ᨲᨳᩣ ¶ ᨲᩴ ᩈᨾ᩠ᨾ ᨶᩮᩈᩣᨴ, ᨽᨲ᩠ᨲᩣᨿᩴ ᩋᨽᩥᨲᩮᩣ ᩁᨾᩮ’’.

᪑᪐᪖.

‘‘ᩋᩁᩥᨿᩅᨲ᩠ᨲᩈᩥ ¶ ᩅᨠ᩠ᨠᨦ᩠ᨣ, ᨿᩮᩣ ᨸᩥᨱ᩠ᨯᨾᨸᨧᩣᨿᩈᩥ;

ᨧᨩᩣᨾᩥ ᨲᩮ ᨲᩴ ᨽᨲ᩠ᨲᩣᩁᩴ, ᨣᨧ᩠ᨨᨳᩪᨽᩮᩣ [ᨣᨧ᩠ᨨᨲᩩ ᨽᩮᩣ (ᨸᩦ.)] ᨿᨳᩣᩈᩩᨡᩴ’’.

᪑᪐᪗.

‘‘ᩈᨧᩮ ᩋᨲ᩠ᨲᨸ᩠ᨸᨿᩮᩣᨣᩮᨶ, ᩒᩉᩥᨲᩮᩣ ᩉᩴᩈᨸᨠ᩠ᨡᩥᨶᩴ;

ᨸᨭᩥᨣᨱ᩠ᩉᩣᨾ ᨲᩮ ᩈᨾ᩠ᨾ, ᩑᨲᩴ ᩋᨽᨿᨴᨠ᩠ᨡᩥᨱᩴ.

᪑᪐᪘.

‘‘ᨶᩮᩣ ᨧᩮ ᩋᨲ᩠ᨲᨸ᩠ᨸᨿᩮᩣᨣᩮᨶ, ᩒᩉᩥᨲᩮᩣ ᩉᩴᩈᨸᨠ᩠ᨡᩥᨶᩴ;

ᩋᨶᩥᩔᩁᩮᩣ ᨾᩩᨬ᩠ᨧᨾᨾ᩠ᩉᩮ, ᨳᩮᨿ᩠ᨿᩴ ᨠᨿᩥᩁᩣᩈᩥ ᩃᩩᨴ᩠ᨴᨠ’’.

᪑᪐᪙.

‘‘ᨿᩔ ᨲ᩠ᩅᩴ ᨽᨲᨠᩮᩣ [ᨽᨭᨠᩮᩣ (ᨠ.)] ᩁᨬ᩠ᨬᩮᩣ, ᨠᩣᨾᩴ ᨲᩔᩮᩅ ᨸᩣᨸᨿ;

ᨲᨲ᩠ᨳ ᩈᩴᨿᨾᨶᩮᩣ [ᩈᩴᨿᨾᩣᨶᩮᩣ (ᨸᩦ.)] ᩁᩣᨩᩣ, ᨿᨳᩣᨽᩥᨬ᩠ᨬᩴ ᨠᩁᩥᩔᨲᩥ’’.

᪑᪑᪐.

‘‘ᩍᨧ᩠ᨧᩮᩅᩴ ᩅᩩᨲ᩠ᨲᩮᩣ ᨶᩮᩈᩣᨴᩮᩣ, ᩉᩮᨾᩅᨱ᩠ᨱᩮ ᩉᩁᩥᨲ᩠ᨲᨧᩮ;

ᩏᨽᩮᩣ ᩉᨲ᩠ᨳᩮᩉᩥ ᩈᨦ᩠ᨣᨿ᩠ᩉ [ᨸᨣ᩠ᨣᨿ᩠ᩉ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨸᨬ᩠ᨩᩁᩮ ᩋᨩ᩠ᨫᩅᩮᩣᨴᩉᩥ.

᪑᪑᪑.

‘‘ᨲᩮ ᨸᨬ᩠ᨩᩁᨣᨲᩮ ᨸᨠ᩠ᨡᩦ, ᩏᨽᩮᩣ ᨽᩔᩁᩅᨱ᩠ᨱᩥᨶᩮ;

ᩈᩩᨾᩩᨡᩴ ᨵᨲᩁᨭ᩠ᨮᨬ᩠ᨧ, ᩃᩩᨴ᩠ᨴᩮᩣ ᩌᨴᩣᨿ ᨸᨠ᩠ᨠᨾᩥ’’.

᪑᪑᪒.

‘‘ᩉᩁᩦᨿᨾᩣᨶᩮᩣ ¶ ᨵᨲᩁᨭ᩠ᨮᩮᩣ, ᩈᩩᨾᩩᨡᩴ ᩑᨲᨴᨻᩕᩅᩥ;

ᨻᩣᩊ᩠ᩉᩴ ᨽᩣᨿᩣᨾᩥ ᩈᩩᨾᩩᨡ, ᩈᩣᨾᩣᨿ ᩃᨠ᩠ᨡᨱᩪᩁᩩᨿᩣ;

ᩋᩈ᩠ᨾᩣᨠᩴ ᩅᨵᨾᨬ᩠ᨬᩣᨿ, ᩋᨳᨲ᩠ᨲᩣᨶᩴ ᩅᨵᩥᩔᨲᩥ.

᪑᪑᪓.

‘‘ᨸᩣᨠᩉᩴᩈᩣ ᨧ ᩈᩩᨾᩩᨡ, ᩈᩩᩉᩮᨾᩣ ᩉᩮᨾᩈᩩᨲ᩠ᨲᨧᩣ;

ᨠᩮᩣᨬ᩠ᨧᩦ ᩈᨾᩩᨴ᩠ᨴᨲᩦᩁᩮᩅ, ᨠᨸᨱᩣ ᨶᩪᨶ ᩁᩩᨧ᩠ᨨᨲᩥ’’.

᪑᪑᪔.

‘‘ᩑᩅᩴ ᨾᩉᨶ᩠ᨲᩮᩣ ᩃᩮᩣᨠᩔ, ᩋᨸ᩠ᨸᨾᩮᨿ᩠ᨿᩮᩣ ᨾᩉᩣᨣᨱᩦ;

ᩑᨠᩥᨲ᩠ᨳᩥᨾᨶᩩᩈᩮᩣᨧᩮᨿ᩠ᨿ, ᨶᨿᩥᨴᩴ ᨸᨬ᩠ᨬᩅᨲᩣᨾᩥᩅ.

᪑᪑᪕.

‘‘ᩅᩣᨲᩮᩣᩅ ¶ ᨣᨶ᩠ᨵᨾᩣᨴᩮᨲᩥ, ᩏᨽᨿᩴ ᨨᩮᨠᨸᩣᨸᨠᩴ;

ᨻᩣᩃᩮᩣ ᩌᨾᨠᨸᨠ᩠ᨠᩴᩅ, ᩃᩮᩣᩃᩮᩣ ᩋᨶ᩠ᨵᩮᩣᩅ ᩌᨾᩥᩈᩴ.

᪑᪑᪖.

‘‘ᩋᩅᩥᨶᩥᨧ᩠ᨨᨿᨬ᩠ᨬᩩ ᩋᨲ᩠ᨳᩮᩈᩩ, ᨾᨶ᩠ᨴᩮᩣᩅ ᨸᨭᩥᨽᩣᩈᩥ [ᨸᨭᩥᨽᩣᨲᩥ (ᨠ.)] ᨾᩴ;

ᨠᩥᨧ᩠ᨧᩣᨠᩥᨧ᩠ᨧᩴ ᨶ ᨩᩣᨶᩣᩈᩥ, ᩈᨾ᩠ᨸᨲ᩠ᨲᩮᩣ ᨠᩣᩃᨸᩁᩥᨿᩣᨿᩴ.

᪑᪑᪗.

‘‘ᩋᨯ᩠ᨰᩩᨾ᩠ᨾᨲ᩠ᨲᩮᩣ ᩏᨴᩦᩁᩮᩈᩥ, ᨿᩮᩣ ᩈᩮᨿ᩠ᨿᩣ ᨾᨬ᩠ᨬᩈᩥᨲ᩠ᨳᩥᨿᩮᩣ;

ᨻᩉᩩᩈᩣᨵᩣᩁᨱᩣ ᩉᩮᨲᩣ, ᩈᩮᩣᨱ᩠ᨯᩣᨶᩴᩅ ᩈᩩᩁᩣᨥᩁᩴ.

᪑᪑᪘.

‘‘ᨾᩣᨿᩣ ¶ ᨧᩮᩈᩣ ᨾᩁᩦᨧᩦ ᨧ, ᩈᩮᩣᨠᩮᩣ ᩁᩮᩣᨣᩮᩣ ᨧᩩᨸᨴ᩠ᨴᩅᩮᩣ;

ᨡᩁᩣ ᨧ ᨻᨶ᩠ᨵᨶᩣ ᨧᩮᨲᩣ, ᨾᨧ᩠ᨧᩩᨸᩣᩈᩣ ᨣᩩᩉᩣᩈᨿᩣ [ᨸᨧ᩠ᨧᩩᨸᩣᩈᩮᩣ ᨣᩩᩉᩣᩈᨿᩮᩣ (ᩈᩦ. ᨸᩦ.)];

ᨲᩣᩈᩩ ᨿᩮᩣ ᩅᩥᩔᩈᩮ ᨸᩮᩣᩈᩮᩣ, ᩈᩮᩣ ᨶᩁᩮᩈᩩ ᨶᩁᩣᨵᨾᩮᩣ’’.

᪑᪑᪙.

‘‘ᨿᩴ ᩅᩩᨴ᩠ᨵᩮᩉᩥ ᩏᨸᨬ᩠ᨬᩣᨲᩴ, ᨠᩮᩣ ᨲᩴ ᨶᩥᨶ᩠ᨴᩥᨲᩩᨾᩁᩉᨲᩥ;

ᨾᩉᩣᨽᩪᨲᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨶᩣᨾ, ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ ᩏᨴᨸᨩ᩠ᨩᩥᩈᩩᩴ.

᪑᪒᪐.

‘‘ᨡᩥᨯ᩠ᨯᩣ ᨸᨱᩥᩉᩥᨲᩣ ᨲ᩠ᨿᩣᩈᩩ, ᩁᨲᩥ ᨲ᩠ᨿᩣᩈᩩ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩣ;

ᨻᩦᨩᩣᨶᩥ ᨲ᩠ᨿᩣᩈᩩ ᩁᩪᩉᨶ᩠ᨲᩥ, ᨿᨴᩥᨴᩴ ᩈᨲ᩠ᨲᩣ ᨸᨩᩣᨿᩁᩮ;

ᨲᩣᩈᩩ ᨠᩮᩣ ᨶᩥᨻ᩠ᨻᩥᨴᩮ [ᨶᩥᨻ᩠ᨻᩥᨩᩮ (ᨠ.)] ᨸᩮᩣᩈᩮᩣ, ᨸᩣᨱᨾᩣᩈᨩ᩠ᨩ ᨸᩣᨱᩥᨽᩥ [ᨸᩣᨱᩉᩥ (ᩈᩦ.)].

᪑᪒᪑.

‘‘ᨲ᩠ᩅᨾᩮᩅ ᨶᨬ᩠ᨬᩮᩣ ᩈᩩᨾᩩᨡ, ᨳᩦᨶᩴ ᩋᨲ᩠ᨳᩮᩈᩩ ᨿᩩᨬ᩠ᨩᩈᩥ;

ᨲᩔ ᨲ᩠ᨿᨩ᩠ᨩ ᨽᨿᩮ ᨩᩣᨲᩮ, ᨽᩦᨲᩮᨶ ᨩᩣᨿᨲᩮ ᨾᨲᩥ.

᪑᪒᪒.

‘‘ᩈᨻ᩠ᨻᩮᩣ ᩉᩥ ᩈᩴᩈᨿᩴ ᨸᨲ᩠ᨲᩮᩣ, ᨽᨿᩴ ᨽᩦᩁᩩ ᨲᩥᨲᩥᨠ᩠ᨡᨲᩥ;

ᨸᨱ᩠ᨯᩥᨲᩣ ᨧ ᨾᩉᨶ᩠ᨲᩣᨶᩮᩣ [ᨾᩉᨲ᩠ᨲᩣᨶᩮᩣ (ᩈᩦ.)], ᩋᨲ᩠ᨳᩮ ᨿᩩᨬ᩠ᨩᨶ᩠ᨲᩥ ᨴᩩᨿ᩠ᨿᩩᨩᩮ.

᪑᪒᪓.

‘‘ᩑᨲᨴᨲ᩠ᨳᩣᨿ ᩁᩣᨩᩣᨶᩮᩣ, ᩈᩪᩁᨾᩥᨧ᩠ᨨᨶ᩠ᨲᩥ ᨾᨶ᩠ᨲᩥᨶᩴ;

ᨸᨭᩥᨻᩣᩉᨲᩥ ᨿᩴ ᩈᩪᩁᩮᩣ, ᩌᨸᨴᩴ ᩋᨲ᩠ᨲᨸᩁᩥᨿᩣᨿᩴ.

᪑᪒᪔.

‘‘ᨾᩣ ¶ ᨶᩮᩣ ᩋᨩ᩠ᨩ ᩅᩥᨠᨶ᩠ᨲᩥᩴᩈᩩ, ᩁᨬ᩠ᨬᩮᩣ ᩈᩪᨴᩣ ᨾᩉᩣᨶᩈᩮ;

ᨲᨳᩣ ᩉᩥ ᩅᨱ᩠ᨱᩮᩣ ᨸᨲ᩠ᨲᩣᨶᩴ, ᨹᩃᩴ ᩅᩮᩊᩩᩴᩅ ᨲᩴ ᩅᨵᩥ.

᪑᪒᪕.

‘‘ᨾᩩᨲ᩠ᨲᩮᩣᨸᩥ ¶ ᨶ ᩍᨧ᩠ᨨᩥ [ᨶᩥᨧ᩠ᨨᩈᩥ (ᨠ.)] ᩏᨯ᩠ᨯᩮᨲᩩᩴ [ᩒᨯ᩠ᨯᩮᨲᩩᩴ (ᩈᩦ.)], ᩈᨿᩴ ᨻᨶ᩠ᨵᩴ ᩏᨸᩣᨣᨾᩥ;

ᩈᩮᩣᨸᨩ᩠ᨩ ᩈᩴᩈᨿᩴ ᨸᨲ᩠ᨲᩮᩣ, ᩋᨲ᩠ᨳᩴ ᨣᨱ᩠ᩉᩣᩉᩥ ᨾᩣ ᨾᩩᨡᩴ’’.

᪑᪒᪖.

‘‘ᩈᩮᩣ ᨲᩴ [ᨲ᩠ᩅᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨿᩮᩣᨣᩴ ᨸᨿᩩᨬ᩠ᨩᩔᩩ, ᨿᩩᨲ᩠ᨲᩴ ᨵᨾ᩠ᨾᩪᨸᩈᩴᩉᩥᨲᩴ [ᨵᨾ᩠ᨾᩮᩣᨸᩈᨬ᩠ᩉᩥᨲᩴ (ᨠ.)];

ᨲᩅ ᨸᩁᩥᨿᩣᨸᨴᩣᨶᩮᨶ, ᨾᨾ ᨸᩣᨱᩮᩈᨶᩴ ᨧᩁ’’.

᪑᪒᪗.

‘‘ᨾᩣ ᨽᩣᨿᩥ ᨸᨲᨲᩴ ᩈᩮᨭ᩠ᨮ, ᨶ ᩉᩥ ᨽᩣᨿᨶ᩠ᨲᩥ ᨲᩣᨴᩥᩈᩣ;

ᩋᩉᩴ ᨿᩮᩣᨣᩴ ᨸᨿᩩᨬ᩠ᨩᩥᩔᩴ, ᨿᩩᨲ᩠ᨲᩴ ᨵᨾ᩠ᨾᩪᨸᩈᩴᩉᩥᨲᩴ [ᨵᨾ᩠ᨾᩮᩣᨸᩈᨬ᩠ᩉᩥᨲᩴ (ᨠ.)];

ᨾᨾ ᨸᩁᩥᨿᩣᨸᨴᩣᨶᩮᨶ, ᨡᩥᨸ᩠ᨸᩴ ᨸᩣᩈᩣ ᨸᨾᩮᩣᨠ᩠ᨡᩈᩥ’’.

᪑᪒᪘.

‘‘ᩈᩮᩣ [ᩈ (ᩈᩦ.)] ᩃᩩᨴ᩠ᨴᩮᩣ ᩉᩴᩈᨠᩣᨩᩮᨶ [ᩉᩴᩈᨠᩣᨧᩮᨶ (ᨸᩦ.)], ᩁᩣᨩᨴ᩠ᩅᩣᩁᩴ ᩏᨸᩣᨣᨾᩥ;

ᨸᨭᩥᩅᩮᨴᩮᨳ ᨾᩴ ᩁᨬ᩠ᨬᩮᩣ, ᨵᨲᩁᨭ᩠ᨮᩣᨿᨾᩣᨣᨲᩮᩣ’’.

᪑᪒᪙.

‘‘ᨲᩮ ¶ ᨴᩥᩈ᩠ᩅᩣ ᨸᩩᨬ᩠ᨬᩈᩴᨠᩣᩈᩮ, ᩏᨽᩮᩣ ᩃᨠ᩠ᨡᨱᩈᨾ᩠ᨾᨲᩮ [ᩃᨠ᩠ᨡᨬ᩠ᨬᩣᩈᨾ᩠ᨾᨲᩮ (ᩈᩦ. ᨸᩦ.)];

ᨡᩃᩩ ᩈᩴᨿᨾᨶᩮᩣ ᩁᩣᨩᩣ, ᩋᨾᨧ᩠ᨧᩮ ᩋᨩ᩠ᨫᨽᩣᩈᨳ.

᪑᪓᪐.

‘‘ᨴᩮᨳ ᩃᩩᨴ᩠ᨴᩔ ᩅᨲ᩠ᨳᩣᨶᩥ, ᩋᨶ᩠ᨶᩴ ᨸᩣᨶᨬ᩠ᨧ ᨽᩮᩣᨩᨶᩴ;

ᨠᩣᨾᩴ ᨠᩁᩮᩣ ᩉᩥᩁᨬ᩠ᨬᩔ, ᨿᩣᩅᨶ᩠ᨲᩮᩣ ᩑᩈ ᩍᨧ᩠ᨨᨲᩥ’’.

᪑᪓᪑.

‘‘ᨴᩥᩈ᩠ᩅᩣ ᩃᩩᨴ᩠ᨴᩴ ᨸᩈᨶ᩠ᨶᨲ᩠ᨲᩴ, ᨠᩣᩈᩥᩁᩣᨩᩣ ᨲᨴᨻᩕᩅᩥ;

ᨿᨴ᩠ᨿᩣᨿᩴ [ᨿᨴᩣᨿᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩈᨾ᩠ᨾ ᨡᩮᨾᨠ, ᨸᩩᨱ᩠ᨱᩣ ᩉᩴᩈᩮᩉᩥ ᨲᩥᨭ᩠ᨮᨲᩥ.

᪑᪓᪒.

‘‘ᨠᨳᩴ ᩁᩩᨧᩥᨾᨩ᩠ᨫᨣᨲᩴ, ᨸᩣᩈᩉᨲ᩠ᨳᩮᩣ ᩏᨸᩣᨣᨾᩥ;

ᩒᨠᩥᨱ᩠ᨱᩴ ᨬᩣᨲᩥᩈᨦ᩠ᨥᩮᩉᩥ, ᨶᩥᨾ᩠ᨾᨩ᩠ᨫᩥᨾᩴ [ᨶᩥᨾᨩ᩠ᨫᩥᨾᩴ (ᩈᩦ. ᨸᩦ. ᨠ.)] ᨠᨳᩴ ᨣᩉᩥ’’.

᪑᪓᪓.

‘‘ᩋᨩ᩠ᨩ ᨾᩮ ᩈᨲ᩠ᨲᨾᩣ ᩁᨲ᩠ᨲᩥ, ᩋᨴᨶᩣᨶᩥ [ᩌᨴᩣᨶᩣᨶᩥ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᩏᨸᩣᩈᨲᩮᩣ [ᩏᨸᩣᨣᨲᩮᩣ (ᨠ.)];

ᨸᨴᨾᩮᨲᩔ ¶ ᩋᨶ᩠ᩅᩮᩈᩴ, ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ ᨥᨭᩔᩥᨲᩮᩣ.

᪑᪓᪔.

‘‘ᩋᨳᩔ ᨸᨴᨾᨴ᩠ᨴᨠ᩠ᨡᩥᩴ, ᨧᩁᨲᩮᩣ ᩋᨴᨶᩮᩈᨶᩴ;

ᨲᨲ᩠ᨳᩣᩉᩴ ᩒᨴᩉᩥᩴ ᨸᩣᩈᩴ, ᩑᩅᩴ ᨲᩴ [ᩑᩅᩮᨲᩴ (ᩈᩦ. ᨸᩦ.)] ᨴᩥᨩᨾᨣ᩠ᨣᩉᩥᩴ’’.

᪑᪓᪕.

‘‘ᩃᩩᨴ᩠ᨴ ᨴ᩠ᩅᩮ ᩍᨾᩮ ᩈᨠᩩᨱᩣ, ᩋᨳ ᩑᨠᩮᩣᨲᩥ ᨽᩣᩈᩈᩥ;

ᨧᩥᨲ᩠ᨲᩴ ᨶᩩ ᨲᩮ ᩅᩥᨸᩁᩥᨿᨲ᩠ᨲᩴ [ᩅᩥᨸᩁᩥᨿᨲ᩠ᨳᩴ (ᨸᩦ.)], ᩋᨴᩩ ᨠᩥᨶ᩠ᨶᩩ ᨩᩥᨣᩦᩈᩈᩥ’’ [ᨩᩥᨣᩥᩴᩈᩈᩥ (ᩈᩦ. ᨸᩦ.)].

᪑᪓᪖.

‘‘ᨿᩔ ᩃᩮᩣᩉᩥᨲᨠᩣ ᨲᩣᩃᩣ, ᨲᨸᨶᩦᨿᨶᩥᨽᩣ ᩈᩩᨽᩣ;

ᩏᩁᩴ ᩈᩴᩉᨧ᩠ᨧ ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ, ᩈᩮᩣ ᨾᩮ ᨻᨶ᩠ᨵᩴ ᩏᨸᩣᨣᨾᩥ.

᪑᪓᪗.

‘‘ᩋᨳᩣᨿᩴ ᨽᩔᩁᩮᩣ ᨸᨠ᩠ᨡᩦ, ᩋᨻᨴ᩠ᨵᩮᩣ ᨻᨴ᩠ᨵᨾᩣᨲᩩᩁᩴ;

ᩋᩁᩥᨿᩴ ᨻᩕᩩᩅᩣᨶᩮᩣ ᩋᨭ᩠ᨮᩣᩈᩥ, ᨧᨩᨶ᩠ᨲᩮᩣ ᨾᩣᨶᩩᩈᩥᩴ ᨣᩥᩁᩴ’’.

᪑᪓᪘.

‘‘ᩋᨳ ᨠᩥᩴ [ᩋᨳ ᨠᩥᨶ᩠ᨶᩩ (ᩈᩦ. ᨸᩦ.), ᨠᨳᩴ ᨶᩩ (ᩈ᩠ᨿᩣ.)] ᨴᩣᨶᩥ ᩈᩩᨾᩩᨡ, ᩉᨶᩩᩴ ᩈᩴᩉᨧ᩠ᨧ ᨲᩥᨭ᩠ᨮᩈᩥ;

ᩋᨴᩩ ᨾᩮ ᨸᩁᩥᩈᩴ ᨸᨲ᩠ᨲᩮᩣ, ᨽᨿᩣ ᨽᩦᨲᩮᩣ ᨶ ᨽᩣᩈᩈᩥ’’.

᪑᪓᪙.

‘‘ᨶᩣᩉᩴ ¶ ᨠᩣᩈᩥᨸᨲᩥ ᨽᩦᨲᩮᩣ, ᩒᨣᨿ᩠ᩉ ᨸᩁᩥᩈᩴ ᨲᩅ;

ᨶᩣᩉᩴ ᨽᨿᩣ ᨶ ᨽᩣᩈᩥᩔᩴ, ᩅᩣᨠ᩠ᨿᩴ ᩋᨲ᩠ᨳᨾ᩠ᩉᩥ ᨲᩣᨴᩥᩈᩮ’’.

᪑᪔᪐.

‘‘ᨶ ᨲᩮ ᩋᨽᩥᩈᩁᩴ ᨸᩔᩮ, ᨶ ᩁᨳᩮ ᨶᨸᩥ ᨸᨲ᩠ᨲᩥᨠᩮ;

ᨶᩣᩔ ᨧᨾ᩠ᨾᩴ ᩅ ᨠᩦᨭᩴ ᩅᩣ, ᩅᨾ᩠ᨾᩥᨲᩮ ᨧ ᨵᨶᩩᨣ᩠ᨣᩉᩮ.

᪑᪔᪑.

‘‘ᨶ ¶ ᩉᩥᩁᨬ᩠ᨬᩴ ᩈᩩᩅᨱ᩠ᨱᩴ ᩅᩣ, ᨶᨣᩁᩴ ᩅᩣ ᩈᩩᨾᩣᨸᩥᨲᩴ;

ᩒᨠᩥᨱ᩠ᨱᨸᩁᩥᨡᩴ ᨴᩩᨣ᩠ᨣᩴ, ᨴᩊ᩠ᩉᨾᨭ᩠ᨭᩣᩃᨠᩮᩣᨭ᩠ᨮᨠᩴ;

ᨿᨲ᩠ᨳ ᨸᩅᩥᨭ᩠ᨮᩮᩣ ᩈᩩᨾᩩᨡ, ᨽᩣᨿᩥᨲᨻ᩠ᨻᩴ ᨶ ᨽᩣᨿᩈᩥ’’.

᪑᪔᪒.

‘‘ᨶ ᨾᩮ ᩋᨽᩥᩈᩁᩮᨶᨲ᩠ᨳᩮᩣ, ᨶᨣᩁᩮᨶ ᨵᨶᩮᨶ ᩅᩣ;

ᩋᨸᨳᩮᨶ ᨸᨳᩴ ᨿᩣᨾ, ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮᨧᩁᩣ ᨾᨿᩴ.

᪑᪔᪓.

‘‘ᩈᩩᨲᩣ ¶ ᨧ ᨸᨱ᩠ᨯᩥᨲᩣ ᨲ᩠ᨿᨾ᩠ᩉᩣ, ᨶᩥᨸᩩᨱᩣ ᩋᨲ᩠ᨳᨧᩥᨶ᩠ᨲᨠᩣ [ᨧᨲ᩠ᨳᨧᩥᨶ᩠ᨲᨠᩣ (ᨠ.)];

ᨽᩣᩈᩮᨾᨲ᩠ᨳᩅᨲᩥᩴ ᩅᩣᨧᩴ, ᩈᨧ᩠ᨧᩮ ᨧᩔ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩮᩣ.

᪑᪔᪔.

‘‘ᨠᩥᨬ᩠ᨧ ᨲᩩᨿ᩠ᩉᩴ ᩋᩈᨧ᩠ᨧᩔ, ᩋᨶᩁᩥᨿᩔ ᨠᩁᩥᩔᨲᩥ;

ᨾᩩᩈᩣᩅᩣᨴᩥᩔ ᩃᩩᨴ᩠ᨴᩔ, ᨽᨱᩥᨲᨾ᩠ᨸᩥ ᩈᩩᨽᩣᩈᩥᨲᩴ’’.

᪑᪔᪕.

‘‘ᨲᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᩅᨧᨶᩣ, ᩍᨾᩴ ᨡᩮᨾᨾᨠᩣᩁᨿᩥ [ᨡᩮᨾᩥᨠᩣᩁᨿᩥ (ᩈᩦ. ᨸᩦ.)];

ᩋᨽᨿᨬ᩠ᨧ ᨲᨿᩣ ᨥᩩᨭ᩠ᨮᩴ, ᩍᨾᩣᨿᩮᩣ ᨴᩈᨵᩣ ᨴᩥᩈᩣ.

᪑᪔᪖.

‘‘ᩒᨣᨿ᩠ᩉ ᨲᩮ ᨸᩮᩣᨠ᩠ᨡᩁᨱᩥᩴ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᩣᨴᨠᩴ ᩈᩩᨧᩥᩴ;

ᨸᩉᩪᨲᩴ ᨧᩣᨴᨶᩴ ᨲᨲ᩠ᨳ, ᩋᩉᩥᩴᩈᩣ ᨧᩮᨲ᩠ᨳ ᨸᨠ᩠ᨡᩥᨶᩴ.

᪑᪔᪗.

‘‘ᩍᨴᩴ ᩈᩩᨲ᩠ᩅᩣᨶ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩴ, ᩌᨣᨲᨾ᩠ᩉ ᨲᩅᨶ᩠ᨲᩥᨠᩮ;

ᨲᩮ ᨲᩮ ᨻᨶ᩠ᨵᩈ᩠ᨾ ᨸᩣᩈᩮᨶ, ᩑᨲᩴ ᨲᩮ ᨽᩣᩈᩥᨲᩴ ᨾᩩᩈᩣ.

᪑᪔᪘.

‘‘ᨾᩩᩈᩣᩅᩣᨴᩴ ᨸᩩᩁᨠ᩠ᨡᨲ᩠ᩅᩣ, ᩍᨧ᩠ᨨᩣᩃᩮᩣᨽᨬ᩠ᨧ ᨸᩣᨸᨠᩴ;

ᩏᨽᩮᩣ ᩈᨶ᩠ᨵᩥᨾᨲᩥᨠ᩠ᨠᨾ᩠ᨾ, ᩋᩈᩣᨲᩴ ᩏᨸᨸᨩ᩠ᨩᨲᩥ’’.

᪑᪔᪙.

‘‘ᨶᩣᨸᩁᨩ᩠ᨫᩣᨾ ᩈᩩᨾᩩᨡ, ᨶᨸᩥ ᩃᩮᩣᨽᩣᩅ ᨾᨣ᩠ᨣᩉᩥᩴ;

ᩈᩩᨲᩣ ᨧ ᨸᨱ᩠ᨯᩥᨲᩣᨲ᩠ᨿᨲ᩠ᨳ, ᨶᩥᨸᩩᨱᩣ ᩋᨲ᩠ᨳᨧᩥᨶ᩠ᨲᨠᩣ.

᪑᪕᪐.

‘‘ᩋᨸ᩠ᨸᩮᩅᨲ᩠ᨳᩅᨲᩥᩴ ᩅᩣᨧᩴ, ᨻ᩠ᨿᩣᩉᩁᩮᨿ᩠ᨿᩩᩴ [ᨻ᩠ᨿᩣᨠᩁᩮᨿ᩠ᨿᩩᩴ (ᩈᩦ. ᨸᩦ.)] ᩍᨵᩣᨣᨲᩣ;

ᨲᨳᩣ ᨲᩴ ᩈᨾ᩠ᨾ ᨶᩮᩈᩣᨴᩮᩣ, ᩅᩩᨲ᩠ᨲᩮᩣ ᩈᩩᨾᩩᨡ ᨾᨣ᩠ᨣᩉᩥ’’.

᪑᪕᪑.

‘‘ᨶᩮᩅ ᨽᩦᨲᩣ [ᨽᩪᨲᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨠᩣᩈᩥᨸᨲᩥ, ᩏᨸᨶᩦᨲᩈ᩠ᨾᩥ ᨩᩦᩅᩥᨲᩮ;

ᨽᩣᩈᩮᨾᨲ᩠ᨳᩅᨲᩥᩴ ᩅᩣᨧᩴ, ᩈᨾ᩠ᨸᨲ᩠ᨲᩣ ᨠᩣᩃᨸᩁᩥᨿᩣᨿᩴ.

᪑᪕᪒.

‘‘ᨿᩮᩣ ᨾᩥᨣᩮᨶ ᨾᩥᨣᩴ ᩉᨶ᩠ᨲᩥ, ᨸᨠ᩠ᨡᩥᩴ ᩅᩣ ᨸᨶ ᨸᨠ᩠ᨡᩥᨶᩣ;

ᩈᩩᨲᩮᨶ ᩅᩣ ᩈᩩᨲᩴ ᨠᩥᨱ᩠ᨿᩣ [ᨠᩥᨱᩮ (ᩈᩦ. ᨸᩦ.)], ᨠᩥᩴ ᩋᨶᩁᩥᨿᨲᩁᩴ ᨲᨲᩮᩣ.

᪑᪕᪓.

‘‘ᨿᩮᩣ ¶ ¶ ¶ ᨧᩣᩁᩥᨿᩁᩩᨴᩴ [ᨧ ᩋᩁᩥᨿᩁᩩᨴᩴ (ᩈᩦ. ᨸᩦ.)] ᨽᩣᩈᩮ, ᩋᨶᩁᩥᨿᨵᨾ᩠ᨾᩅᩔᩥᨲᩮᩣ [ᩋᨶᩁᩥᨿᨵᨾ᩠ᨾᨾᩅᩔᩥᨲᩮᩣ (ᩈᩦ.)];

ᩏᨽᩮᩣ ᩈᩮᩣ ᨵᩴᩈᨲᩮ ᩃᩮᩣᨠᩣ, ᩍᨵ ᨧᩮᩅ ᨸᩁᨲ᩠ᨳ ᨧ.

᪑᪕᪔.

‘‘ᨶ ᨾᨩ᩠ᨩᩮᨳ ᨿᩈᩴ ᨸᨲ᩠ᨲᩮᩣ, ᨶ ᨻ᩠ᨿᩣᨵᩮ [ᨻ᩠ᨿᨳᩮ (ᩈᩦ. ᨸᩦ.)] ᨸᨲ᩠ᨲᩈᩴᩈᨿᩴ;

ᩅᩣᨿᨾᩮᨳᩮᩅ ᨠᩥᨧ᩠ᨧᩮᩈᩩ, ᩈᩴᩅᩁᩮ ᩅᩥᩅᩁᩣᨶᩥ ᨧ.

᪑᪕᪕.

‘‘ᨿᩮ ᩅᩩᨴ᩠ᨵᩣ ᩋᨻ᩠ᨽᨲᩥᨠ᩠ᨠᨶ᩠ᨲᩣ [ᨶᩣᨻ᩠ᨽᨧᩥᨠ᩠ᨡᨶ᩠ᨲᩣ (ᨠ.)], ᩈᨾ᩠ᨸᨲ᩠ᨲᩣ ᨠᩣᩃᨸᩁᩥᨿᩣᨿᩴ;

ᩍᨵ ᨵᨾ᩠ᨾᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᩑᩅᩴᨲᩮ [ᩑᩅᩮᨲᩮ (ᩈᩦ. ᨸᩦ.)] ᨲᩥᨴᩥᩅᩴ ᨣᨲᩣ.

᪑᪕᪖.

‘‘ᩍᨴᩴ ᩈᩩᨲ᩠ᩅᩣ ᨠᩣᩈᩥᨸᨲᩥ, ᨵᨾ᩠ᨾᨾᨲ᩠ᨲᨶᩥ ᨸᩣᩃᨿ;

ᨵᨲᩁᨭ᩠ᨮᨬ᩠ᨧ ᨾᩩᨬ᩠ᨧᩣᩉᩥ, ᩉᩴᩈᩣᨶᩴ ᨸᩅᩁᩩᨲ᩠ᨲᨾᩴ’’.

᪑᪕᪗.

‘‘ᩌᩉᩁᨶ᩠ᨲᩩᨴᨠᩴ ᨸᨩ᩠ᨩᩴ, ᩌᩈᨶᨬ᩠ᨧ ᨾᩉᩣᩁᩉᩴ;

ᨸᨬ᩠ᨩᩁᨲᩮᩣ ᨸᨾᩮᩣᨠ᩠ᨡᩣᨾᩥ, ᨵᨲᩁᨭ᩠ᨮᩴ ᨿᩈᩔᩥᨶᩴ.

᪑᪕᪘.

‘‘ᨲᨬ᩠ᨧ ᩈᩮᨶᩣᨸᨲᩥᩴ ᨵᩦᩁᩴ, ᨶᩥᨸᩩᨱᩴ ᩋᨲ᩠ᨳᨧᩥᨶ᩠ᨲᨠᩴ;

ᨿᩮᩣ ᩈᩩᨡᩮ ᩈᩩᨡᩥᨲᩮᩣ ᩁᨬ᩠ᨬᩮ [ᩁᨬ᩠ᨬᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)], ᨴᩩᨠ᩠ᨡᩥᨲᩮ ᩉᩮᩣᨲᩥ ᨴᩩᨠ᩠ᨡᩥᨲᩮᩣ.

᪑᪕᪙.

‘‘ᩑᨴᩥᩈᩮᩣ ᨡᩮᩣ ᩋᩁᩉᨲᩥ, ᨸᩥᨱ᩠ᨯᨾᩈ᩠ᨶᩣᨲᩩ ᨽᨲ᩠ᨲᩩᨶᩮᩣ;

ᨿᨳᩣᨿᩴ ᩈᩩᨾᩩᨡᩮᩣ ᩁᨬ᩠ᨬᩮᩣ, ᨸᩣᨱᩈᩣᨵᩣᩁᨱᩮᩣ ᩈᨡᩣ’’.

᪑᪖᪐.

‘‘ᨸᩦᨮᨬ᩠ᨧ ᩈᨻ᩠ᨻᩈᩮᩣᩅᨱ᩠ᨱᩴ, ᩋᨭ᩠ᨮᨸᩣᨴᩴ ᨾᨶᩮᩣᩁᨾᩴ;

ᨾᨭ᩠ᨮᩴ ᨠᩣᩈᩥᨠᨾᨲ᩠ᨳᨶ᩠ᨶᩴ [ᨠᩣᩈᩥᨠᨸᨲ᩠ᨳᩥᨱ᩠ᨱᩴ (ᩈᩦ.), ᨠᩣᩈᩥᨠᩅᨲ᩠ᨳᩥᨶᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨵᨲᩁᨭ᩠ᨮᩮᩣ ᩏᨸᩣᩅᩥᩈᩥ.

᪑᪖᪑.

‘‘ᨠᩮᩣᨧ᩠ᨨᨬ᩠ᨧ ᩈᨻ᩠ᨻᩈᩮᩣᩅᨱ᩠ᨱᩴ, ᩅᩮᨿ᩠ᨿᨣ᩠ᨥᨸᩁᩥᩈᩥᨻ᩠ᨻᩥᨲᩴ;

ᩈᩩᨾᩩᨡᩮᩣ ᩋᨩ᩠ᨫᩩᨸᩣᩅᩮᨠ᩠ᨡᩥ, ᨵᨲᩁᨭ᩠ᨮᩔᨶᨶ᩠ᨲᩁᩣ [ᩋᨶᨶ᩠ᨲᩁᩴ (ᩈᩦ.)].

᪑᪖᪒.

‘‘ᨲᩮᩈᩴ ᨠᨬ᩠ᨧᨶᨸᨲ᩠ᨲᩮᩉᩥ, ᨸᩩᨳᩪ ᩌᨴᩣᨿ ᨠᩣᩈᩥᨿᩮᩣ;

ᩉᩴᩈᩣᨶᩴ ᩋᨽᩥᩉᩣᩁᩮᩈᩩᩴ, ᩋᨣ᩠ᨣᩁᨬ᩠ᨬᩮᩣ ᨸᩅᩣᩈᩥᨲᩴ’’.

᪑᪖᪓.

‘‘ᨴᩥᩈ᩠ᩅᩣ ¶ ᩋᨽᩥᩉᨭᩴ ᩋᨣ᩠ᨣᩴ, ᨠᩣᩈᩥᩁᩣᨩᩮᨶ ᨸᩮᩈᩥᨲᩴ;

ᨠᩩᩈᩃᩮᩣ ᨡᨲ᩠ᨲᨵᨾ᩠ᨾᩣᨶᩴ, ᨲᨲᩮᩣ ᨸᩩᨧ᩠ᨨᩥ ᩋᨶᨶ᩠ᨲᩁᩣ.

᪑᪖᪔.

‘‘ᨠᨧ᩠ᨧᩥᨶ᩠ᨶᩩ ᨽᩮᩣᨲᩮᩣ ᨠᩩᩈᩃᩴ, ᨠᨧ᩠ᨧᩥ ᨽᩮᩣᨲᩮᩣ ᩋᨶᩣᨾᨿᩴ;

ᨠᨧ᩠ᨧᩥ ᩁᨭ᩠ᨮᨾᩥᨴᩴ ᨹᩦᨲᩴ, ᨵᨾ᩠ᨾᩮᨶ ᨾᨶᩩᩈᩣᩈᩈᩥ’’.

᪑᪖᪕.

‘‘ᨠᩩᩈᩃᨬ᩠ᨧᩮᩅ ¶ ᨾᩮ ᩉᩴᩈ, ᩋᨳᩮᩣ ᩉᩴᩈ ᩋᨶᩣᨾᨿᩴ;

ᩋᨳᩮᩣ ᩁᨭ᩠ᨮᨾᩥᨴᩴ ᨹᩦᨲᩴ, ᨵᨾ᩠ᨾᩮᨶᩴ ᨾᨶᩩᩈᩣᩈᩉᩴ.

᪑᪖᪖.

‘‘ᨠᨧ᩠ᨧᩥ ᨽᩮᩣᨲᩮᩣ ᩋᨾᨧ᩠ᨧᩮᩈᩩ, ᨴᩮᩣᩈᩮᩣ ᨠᩮᩣᨧᩥ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᨠᨧ᩠ᨧᩥ ᨧ ᨲᩮ ᨲᩅᨲ᩠ᨳᩮᩈᩩ, ᨶᩣᩅᨠᨦ᩠ᨡᨶ᩠ᨲᩥ ᨩᩦᩅᩥᨲᩴ’’.

᪑᪖᪗.

‘‘ᩋᨳᩮᩣᨸᩥ ᨾᩮ ᩋᨾᨧ᩠ᨧᩮᩈᩩ, ᨴᩮᩣᩈᩮᩣ ᨠᩮᩣᨧᩥ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᩋᨳᩮᩣᨸᩥ ᨲᩮ ᨾᨾᨲ᩠ᨳᩮᩈᩩ, ᨶᩣᩅᨠᨦ᩠ᨡᨶ᩠ᨲᩥ ᨩᩦᩅᩥᨲᩴ’’.

᪑᪖᪘.

‘‘ᨠᨧ᩠ᨧᩥ ¶ ᨲᩮ ᩈᩣᨴᩥᩈᩦ ᨽᩁᩥᨿᩣ, ᩋᩔᩅᩣ ᨸᩥᨿᨽᩣᨱᩥᨶᩦ;

ᨸᩩᨲ᩠ᨲᩁᩪᨸᨿᩈᩪᨸᩮᨲᩣ, ᨲᩅ ᨨᨶ᩠ᨴᩅᩈᩣᨶᩩᨣᩣ’’.

᪑᪖᪙.

‘‘ᩋᨳᩮᩣ ᨾᩮ ᩈᩣᨴᩥᩈᩦ ᨽᩁᩥᨿᩣ, ᩋᩔᩅᩣ ᨸᩥᨿᨽᩣᨱᩥᨶᩦ;

ᨸᩩᨲ᩠ᨲᩁᩪᨸᨿᩈᩪᨸᩮᨲᩣ, ᨾᨾ ᨨᨶ᩠ᨴᩅᩈᩣᨶᩩᨣᩣ’’.

᪑᪗᪐.

‘‘ᨠᨧ᩠ᨧᩥ ᩁᨭ᩠ᨮᩴ ᩋᨶᩩᨸ᩠ᨸᩦᩊᩴ, ᩋᨠᩩᨲᩮᩣᨧᩥᩏᨸᨴ᩠ᨴᩅᩴ;

ᩋᩈᩣᩉᩈᩮᨶ ᨵᨾ᩠ᨾᩮᨶ, ᩈᨾᩮᨶ ᨾᨶᩩᩈᩣᩈᩈᩥ’’.

᪑᪗᪑.

‘‘ᩋᨳᩮᩣ ᩁᨭ᩠ᨮᩴ ᩋᨶᩩᨸ᩠ᨸᩦᩊᩴ, ᩋᨠᩩᨲᩮᩣᨧᩥᩏᨸᨴ᩠ᨴᩅᩴ;

ᩋᩈᩣᩉᩈᩮᨶ ᨵᨾ᩠ᨾᩮᨶ, ᩈᨾᩮᨶ ᨾᨶᩩᩈᩣᩈᩉᩴ’’.

᪑᪗᪒.

‘‘ᨠᨧ᩠ᨧᩥ ᩈᨶ᩠ᨲᩮᩣ ᩋᨸᨧᩥᨲᩣ, ᩋᩈᨶ᩠ᨲᩮᩣ ᨸᩁᩥᩅᨩ᩠ᨩᩥᨲᩣ;

ᨶᩮᩣ ᨧᩮ [ᨧ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨵᨾ᩠ᨾᩴ ᨶᩥᩁᩴᨠᨲ᩠ᩅᩣ, ᩋᨵᨾ᩠ᨾᨾᨶᩩᩅᨲ᩠ᨲᩈᩥ’’.

᪑᪗᪓.

‘‘ᩈᨶ᩠ᨲᩮᩣ ¶ ᨧ ᨾᩮ ᩋᨸᨧᩥᨲᩣ, ᩋᩈᨶ᩠ᨲᩮᩣ ᨸᩁᩥᩅᨩ᩠ᨩᩥᨲᩣ;

ᨵᨾ᩠ᨾᨾᩮᩅᩣᨶᩩᩅᨲ᩠ᨲᩣᨾᩥ, ᩋᨵᨾ᩠ᨾᩮᩣ ᨾᩮ ᨶᩥᩁᨦ᩠ᨠᨲᩮᩣ’’.

᪑᪗᪔.

‘‘ᨠᨧ᩠ᨧᩥ ᨶᩣᨶᩣᨣᨲᩴ [ᨠᨧ᩠ᨧᩥ ᨶᩩᨶᩣᨣᨲᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨴᩦᨥᩴ, ᩈᨾᩅᩮᨠ᩠ᨡᩈᩥ ᨡᨲ᩠ᨲᩥᨿ;

ᨠᨧ᩠ᨧᩥ ᨾᨲ᩠ᨲᩮᩣ [ᨶ ᨾᨲ᩠ᨲᩮᩣ (ᩈᩦ.)] ᨾᨴᨶᩦᨿᩮ, ᨸᩁᩃᩮᩣᨠᩴ ᨶ ᩈᨶ᩠ᨲᩈᩥ’’.

᪑᪗᪕.

‘‘ᨶᩣᩉᩴ ᩋᨶᩣᨣᨲᩴ [ᩋᩉᩴ ᩋᨶᩣᨣᨲᩴ (ᩈ᩠ᨿᩣ.)] ᨴᩦᨥᩴ, ᩈᨾᩅᩮᨠ᩠ᨡᩣᨾᩥ ᨸᨠ᩠ᨡᩥᨾ;

ᨮᩥᨲᩮᩣ ᨴᩈᩈᩩ ᨵᨾ᩠ᨾᩮᩈᩩ, ᨸᩁᩃᩮᩣᨠᩴ ᨶ ᩈᨶ᩠ᨲᩈᩮ [ᩈᨶ᩠ᨲᩈᩥᩴ (ᩈ᩠ᨿᩣ.)].

᪑᪗᪖.

‘‘ᨴᩣᨶᩴ ᩈᩦᩃᩴ ᨸᩁᩥᨧ᩠ᨧᩣᨣᩴ, ᩋᨩ᩠ᨩᩅᩴ ᨾᨴ᩠ᨴᩅᩴ ᨲᨸᩴ;

ᩋᨠ᩠ᨠᩮᩣᨵᩴ ᩋᩅᩥᩉᩥᩴᩈᨬ᩠ᨧ, ᨡᨶ᩠ᨲᩥᨬ᩠ᨧ [ᨡᨶ᩠ᨲᩦ ᨧ (ᨠ.)] ᩋᩅᩥᩁᩮᩣᨵᨶᩴ.

᪑᪗᪗.

‘‘ᩍᨧ᩠ᨧᩮᨲᩮ ᨠᩩᩈᩃᩮ ᨵᨾ᩠ᨾᩮ, ᨮᩥᨲᩮ ᨸᩔᩣᨾᩥ ᩋᨲ᩠ᨲᨶᩥ;

ᨲᨲᩮᩣ ᨾᩮ ᨩᩣᨿᨲᩮ ᨸᩦᨲᩥ, ᩈᩮᩣᨾᨶᩔᨬ᩠ᨧᨶᨸ᩠ᨸᨠᩴ.

᪑᪗᪘.

‘‘ᩈᩩᨾᩩᨡᩮᩣ ¶ ᨧ ᩋᨧᩥᨶ᩠ᨲᩮᨲ᩠ᩅᩣ, ᩅᩥᩈᨩ᩠ᨩᩥ [ᩅᩥᩔᨩᩥ (ᩈᩦ. ᨸᩦ.)] ᨹᩁᩩᩈᩴ ᨣᩥᩁᩴ;

ᨽᩣᩅᨴᩮᩣᩈᨾᨶᨬ᩠ᨬᩣᨿ, ᩋᩈ᩠ᨾᩣᨠᩣᨿᩴ ᩅᩥᩉᨦ᩠ᨣᨾᩮᩣ.

᪑᪗᪙.

‘‘ᩈᩮᩣ ᨠᩩᨴ᩠ᨵᩮᩣ ᨹᩁᩩᩈᩴ ᩅᩣᨧᩴ, ᨶᩥᨧ᩠ᨨᩣᩁᩮᩈᩥ ᩋᨿᩮᩣᨶᩥᩈᩮᩣ;

ᨿᩣᨶᩈ᩠ᨾᩣᩈᩩ [ᨿᩣᨶᩈ᩠ᨾᩣᩈᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ ᨸᩦ.)] ᨶ ᩅᩥᨩ᩠ᨩᨶ᩠ᨲᩥ, ᨶᨿᩥᨴᩴ [ᨶ ᩍᨴᩴ (ᩈᩦ. ᨸᩦ.)] ᨸᨬ᩠ᨬᩅᨲᩣᨾᩥᩅ’’.

᪑᪘᪐.

‘‘ᩋᨲ᩠ᨳᩥ ᨾᩮ ᨲᩴ ᩋᨲᩥᩈᩣᩁᩴ, ᩅᩮᨣᩮᨶ ᨾᨶᩩᨩᩣᨵᩥᨸ;

ᨵᨲᩁᨭ᩠ᨮᩮ ᨧ ᨻᨴ᩠ᨵᩈ᩠ᨾᩥᩴ, ᨴᩩᨠ᩠ᨡᩴ ᨾᩮ ᩅᩥᨸᩩᩃᩴ ᩋᩉᩩ.

᪑᪘᪑.

‘‘ᨲ᩠ᩅᩴ ᨶᩮᩣ ᨸᩥᨲᩣᩅ ᨸᩩᨲ᩠ᨲᩣᨶᩴ, ᨽᩪᨲᩣᨶᩴ ᨵᩁᨱᩦᩁᩥᩅ;

ᩋᩈ᩠ᨾᩣᨠᩴ ᩋᨵᩥᨸᨶ᩠ᨶᩣᨶᩴ, ᨡᨾᩔᩩ ᩁᩣᨩᨠᩩᨬ᩠ᨩᩁ’’.

᪑᪘᪒.

‘‘ᩑᨲᩴ [ᩑᩅᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨲᩮ ᩋᨶᩩᨾᩮᩣᨴᩣᨾ, ᨿᩴ ᨽᩣᩅᩴ ᨶ ᨶᩥᨣᩪᩉᩈᩥ;

ᨡᩥᩃᩴ ᨸᨽᩥᨶ᩠ᨴᩈᩥ ᨸᨠ᩠ᨡᩥ, ᩏᨩᩩᨠᩮᩣᩈᩥ ᩅᩥᩉᨦ᩠ᨣᨾ’’.

᪑᪘᪓.

‘‘ᨿᩴ ¶ ¶ ᨠᩥᨬ᩠ᨧᩥ ᩁᨲᨶᩴ ᩋᨲ᩠ᨳᩥ, ᨠᩣᩈᩥᩁᩣᨩ ᨶᩥᩅᩮᩈᨶᩮ;

ᩁᨩᨲᩴ ᨩᩣᨲᩁᩪᨸᨬ᩠ᨧ, ᨾᩩᨲ᩠ᨲᩣ ᩅᩮᩊᩩᩁᩥᨿᩣ ᨻᩉᩪ.

᪑᪘᪔.

‘‘ᨾᨱᨿᩮᩣ ᩈᨦ᩠ᨡᨾᩩᨲ᩠ᨲᨬ᩠ᨧ, ᩅᨲ᩠ᨳᨠᩴ ᩉᩁᩥᨧᨶ᩠ᨴᨶᩴ;

ᩋᨩᩥᨶᩴ ᨴᨶ᩠ᨲᨽᨱ᩠ᨯᨬ᩠ᨧ, ᩃᩮᩣᩉᩴ ᨠᩣᩊᩣᨿᩈᩴ ᨻᩉᩩᩴ;

ᩑᨲᩴ ᨴᨴᩣᨾᩥ ᩅᩮᩣ ᩅᩥᨲ᩠ᨲᩴ, ᩍᩔᩁᩥᨿᩴ [ᩍᩔᩮᩁᩴ (ᩈᩦ.), ᩍᩔᩁᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᩅᩥᩔᨩᩣᨾᩥ ᩅᩮᩣ’’.

᪑᪘᪕.

‘‘ᩋᨴ᩠ᨵᩣ ᩋᨸᨧᩥᨲᩣ ᨲ᩠ᨿᨾ᩠ᩉᩣ, ᩈᨠ᩠ᨠᨲᩣ ᨧ ᩁᨳᩮᩈᨽ;

ᨵᨾ᩠ᨾᩮᩈᩩ ᩅᨲ᩠ᨲᨾᩣᨶᩣᨶᩴ, ᨲ᩠ᩅᩴ ᨶᩮᩣ ᩌᨧᩁᩥᨿᩮᩣ ᨽᩅ.

᪑᪘᪖.

‘‘ᩌᨧᩁᩥᨿ ᩈᨾᨶᩩᨬ᩠ᨬᩣᨲᩣ, ᨲᨿᩣ ᩋᨶᩩᨾᨲᩣ ᨾᨿᩴ;

ᨲᩴ ᨸᨴᨠ᩠ᨡᩥᨱᨲᩮᩣ ᨠᨲ᩠ᩅᩣ, ᨬᩣᨲᩥᩴ [ᨬᩣᨲᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᩔᩮᨾᩩᩁᩥᨶ᩠ᨴᨾ’’ [ᨸᩔᩮᨾᩁᩥᨶ᩠ᨴᨾ (ᩈᩦ. ᨸᩦ.)].

᪑᪘᪗.

‘‘ᩈᨻ᩠ᨻᩁᨲ᩠ᨲᩥᩴ ᨧᩥᨶ᩠ᨲᨿᩥᨲ᩠ᩅᩣ, ᨾᨶ᩠ᨲᨿᩥᨲ᩠ᩅᩣ ᨿᨳᩣᨲᨳᩴ;

ᨠᩣᩈᩥᩁᩣᨩᩣ ᩋᨶᩩᨬ᩠ᨬᩣᩈᩥ, ᩉᩴᩈᩣᨶᩴ ᨸᩅᩁᩩᨲ᩠ᨲᨾᩴ’’.

᪑᪘᪘.

‘‘ᨲᨲᩮᩣ ᩁᨲ᩠ᨿᩣ ᩅᩥᩅᩈᩣᨶᩮ, ᩈᩪᩁᩥᨿᩩᨣ᩠ᨣᨾᨶᩴ [ᩈᩩᩁᩥᨿᩔᩩᨣ᩠ᨣᨾᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩈᩩᩁᩥᨿᩩᨣ᩠ᨣᨾᨶᩴ (ᨸᩦ.)] ᨸᨲᩥ;

ᨸᩮᨠ᩠ᨡᨲᩮᩣ ᨠᩣᩈᩥᩁᩣᨩᩔ, ᨽᩅᨶᩣ ᨲᩮ [ᨽᩅᨶᨲᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩅᩥᨣᩣᩉᩥᩈᩩᩴ’’.

᪑᪘᪙.

‘‘ᨲᩮ ᩋᩁᩮᩣᨣᩮ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮ, ᨴᩥᩈ᩠ᩅᩣᨶ ᨸᩁᨾᩮ ᨴᩥᨩᩮ;

ᨠᩮᨠᩣᨲᩥ ᨾᨠᩁᩩᩴ ᩉᩴᩈᩣ, ᨸᩩᨳᩩᩈᨴ᩠ᨴᩮᩣ ᩋᨩᩣᨿᨳ.

᪑᪙᪐.

‘‘ᨲᩮ ¶ ᨸᨲᩦᨲᩣ ᨸᨾᩩᨲ᩠ᨲᩮᨶ, ᨽᨲ᩠ᨲᩩᨶᩣ ᨽᨲ᩠ᨲᩩᨣᩣᩁᩅᩣ;

ᩈᨾᨶ᩠ᨲᩣ ᨸᩁᩥᨠᩥᩁᩥᩴᩈᩩ, ᩋᨱ᩠ᨯᨩᩣ ᩃᨴ᩠ᨵᨸᨧ᩠ᨧᨿᩣ’’.

᪑᪙᪑.

‘‘ᩑᩅᩴ ᨾᩥᨲ᩠ᨲᩅᨲᩴ ᩋᨲ᩠ᨳᩣ, ᩈᨻ᩠ᨻᩮ ᩉᩮᩣᨶ᩠ᨲᩥ ᨸᨴᨠ᩠ᨡᩥᨱᩣ;

ᩉᩴᩈᩣ ᨿᨳᩣ ᨵᨲᩁᨭ᩠ᨮᩣ, ᨬᩣᨲᩥᩈᨦ᩠ᨥᩴ ᩏᨸᩣᨣᨾᩩ’’ᨶ᩠ᨲᩥ.

ᨾᩉᩣᩉᩴᩈᨩᩣᨲᨠᩴ ᨴᩩᨲᩥᨿᩴ.

᪕᪓᪕. ᩈᩩᨵᩣᨽᩮᩣᨩᨶᨩᩣᨲᨠᩴ (᪓)

᪑᪙᪒.

‘‘ᨶᩮᩅ ¶ ᨠᩥᨱᩣᨾᩥ ᨶᨸᩥ ᩅᩥᨠ᩠ᨠᩥᨱᩣᨾᩥ, ᨶ ᨧᩣᨸᩥ ᨾᩮ ᩈᨶ᩠ᨶᩥᨧᨿᩮᩣ ᨧ ᩋᨲ᩠ᨳᩥ [ᩍᨵᨲ᩠ᨳᩥ (ᩈ᩠ᨿᩣ.)];

ᩈᩩᨠᩥᨧ᩠ᨨᩁᩪᨸᩴ ᩅᨲᩥᨴᩴ ᨸᩁᩥᨲ᩠ᨲᩴ, ᨸᨲ᩠ᨳᩮᩣᨴᨶᩮᩣ ᨶᩣᩃᨾᨿᩴ ᨴᩩᩅᩥᨶ᩠ᨶᩴ’’.

᪑᪙᪓.

‘‘ᩋᨸ᩠ᨸᨾ᩠ᩉᩣ ᩋᨸ᩠ᨸᨠᩴ ᨴᨩ᩠ᨩᩣ, ᩋᨶᩩᨾᨩ᩠ᨫᨲᩮᩣ ᨾᨩ᩠ᨫᨠᩴ;

ᨻᩉᩩᨾ᩠ᩉᩣ ᨻᩉᩩᨠᩴ ᨴᨩ᩠ᨩᩣ, ᩋᨴᩣᨶᩴ ᨶᩩᨸᨸᨩ᩠ᨩᨲᩥ [ᨶ ᩏᨸᨸᨩ᩠ᨩᨲᩥ (ᩈᩦ. ᨸᩦ.)].

᪑᪙᪔.

‘‘ᨲᩴ ᨲᩴ ᩅᨴᩣᨾᩥ ᨠᩮᩣᩈᩥᨿ, ᨴᩮᩉᩥ ᨴᩣᨶᩣᨶᩥ ᨽᩩᨬ᩠ᨩ ᨧ;

ᩋᩁᩥᨿᨾᨣ᩠ᨣᩴ ᩈᨾᩣᩁᩪᩉ [ᩋᩁᩥᨿᩴ ᨾᨣ᩠ᨣᩴ ᩈᨾᩣᩁᩩᩉ (ᩈᩦ. ᨸᩦ.)], ᨶᩮᨠᩣᩈᩦ ᩃᨽᨲᩮ ᩈᩩᨡᩴ’’.

᪑᪙᪕.

‘‘ᨾᩮᩣᨥᨬ᩠ᨧᩔ ¶ ᩉᩩᨲᩴ ᩉᩮᩣᨲᩥ, ᨾᩮᩣᨥᨬ᩠ᨧᩣᨸᩥ ᩈᨾᩦᩉᩥᨲᩴ;

ᩋᨲᩥᨳᩥᩈ᩠ᨾᩥᩴ ᨿᩮᩣ ᨶᩥᩈᩥᨶ᩠ᨶᩈ᩠ᨾᩥᩴ, ᩑᨠᩮᩣ ᨽᩩᨬ᩠ᨩᨲᩥ ᨽᩮᩣᨩᨶᩴ.

᪑᪙᪖.

‘‘ᨲᩴ ᨲᩴ ᩅᨴᩣᨾᩥ ᨠᩮᩣᩈᩥᨿ, ᨴᩮᩉᩥ ᨴᩣᨶᩣᨶᩥ ᨽᩩᨬ᩠ᨩ ᨧ;

ᩋᩁᩥᨿᨾᨣ᩠ᨣᩴ ᩈᨾᩣᩁᩪᩉ, ᨶᩮᨠᩣᩈᩦ ᩃᨽᨲᩮ ᩈᩩᨡᩴ’’.

᪑᪙᪗.

‘‘ᩈᨧ᩠ᨧᨬ᩠ᨧᩔ ᩉᩩᨲᩴ ᩉᩮᩣᨲᩥ, ᩈᨧ᩠ᨧᨬ᩠ᨧᩣᨸᩥ ᩈᨾᩦᩉᩥᨲᩴ;

ᩋᨲᩥᨳᩥᩈ᩠ᨾᩥᩴ ᨿᩮᩣ ᨶᩥᩈᩥᨶ᩠ᨶᩈ᩠ᨾᩥᩴ, ᨶᩮᨠᩮᩣ ᨽᩩᨬ᩠ᨩᨲᩥ ᨽᩮᩣᨩᨶᩴ.

᪑᪙᪘.

‘‘ᨲᩴ ᨲᩴ ᩅᨴᩣᨾᩥ ᨠᩮᩣᩈᩥᨿ, ᨴᩮᩉᩥ ᨴᩣᨶᩣᨶᩥ ᨽᩩᨬ᩠ᨩ ᨧ;

ᩋᩁᩥᨿᨾᨣ᩠ᨣᩴ ᩈᨾᩣᩁᩪᩉ, ᨶᩮᨠᩣᩈᩦ ᩃᨽᨲᩮ ᩈᩩᨡᩴ’’.

᪑᪙᪙.

‘‘ᩈᩁᨬ᩠ᨧ ᨩᩩᩉᨲᩥ ᨸᩮᩣᩈᩮᩣ, ᨻᩉᩩᨠᩣᨿ ᨣᨿᩣᨿ ᨧ;

ᨴᩮᩣᨱᩮ ᨲᩥᨾ᩠ᨻᩁᩩᨲᩥᨲ᩠ᨳᩈ᩠ᨾᩥᩴ, ᩈᩦᨥᩈᩮᩣᨲᩮ ᨾᩉᩣᩅᩉᩮ.

᪒᪐᪐.

‘‘ᩋᨲᩕ ᨧᩔ ᩉᩩᨲᩴ ᩉᩮᩣᨲᩥ, ᩋᨲᩕ ᨧᩔ ᩈᨾᩦᩉᩥᨲᩴ;

ᩋᨲᩥᨳᩥᩈ᩠ᨾᩥᩴ ¶ ᨿᩮᩣ ᨶᩥᩈᩥᨶ᩠ᨶᩈ᩠ᨾᩥᩴ, ᨶᩮᨠᩮᩣ ᨽᩩᨬ᩠ᨩᨲᩥ ᨽᩮᩣᨩᨶᩴ.

᪒᪐᪑.

‘‘ᨲᩴ ¶ ᨲᩴ ᩅᨴᩣᨾᩥ ᨠᩮᩣᩈᩥᨿ, ᨴᩮᩉᩥ ᨴᩣᨶᩣᨶᩥ ᨽᩩᨬ᩠ᨩ ᨧ;

ᩋᩁᩥᨿᨾᨣ᩠ᨣᩴ ᩈᨾᩣᩁᩪᩉ, ᨶᩮᨠᩣᩈᩦ ᩃᨽᨲᩮ ᩈᩩᨡᩴ’’.

᪒᪐᪒.

‘‘ᨻᩊᩥᩈᨬ᩠ᩉᩥ ᩈᩮᩣ ᨶᩥᨣᩥᩃᨲᩥ [ᨶᩥᨣ᩠ᨣᩥᩃᨲᩥ (ᩈᩦ. ᨸᩦ.)], ᨴᩦᨥᩈᩩᨲ᩠ᨲᩴ ᩈᨻᨶ᩠ᨵᨶᩴ;

ᩋᨲᩥᨳᩥᩈ᩠ᨾᩥᩴ ᨿᩮᩣ ᨶᩥᩈᩥᨶ᩠ᨶᩈ᩠ᨾᩥᩴ, ᩑᨠᩮᩣ ᨽᩩᨬ᩠ᨩᨲᩥ ᨽᩮᩣᨩᨶᩴ.

᪒᪐᪓.

‘‘ᨲᩴ ᨲᩴ ᩅᨴᩣᨾᩥ ᨠᩮᩣᩈᩥᨿ, ᨴᩮᩉᩥ ᨴᩣᨶᩣᨶᩥ ᨽᩩᨬ᩠ᨩ ᨧ;

ᩋᩁᩥᨿᨾᨣ᩠ᨣᩴ ᩈᨾᩣᩁᩪᩉ, ᨶᩮᨠᩣᩈᩦ ᩃᨽᨲᩮ ᩈᩩᨡᩴ’’.

᪒᪐᪔.

‘‘ᩏᩊᩣᩁᩅᨱ᩠ᨱᩣ ᩅᨲ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩍᨾᩮ, ᩋᨿᨬ᩠ᨧ ᩅᩮᩣ ᩈᩩᨶᨡᩮᩣ ᨠᩥᩔ ᩉᩮᨲᩩ;

ᩏᨧ᩠ᨧᩣᩅᨧᩴ ᩅᨱ᩠ᨱᨶᩥᨽᩴ ᩅᩥᨠᩩᨻ᩠ᨻᨲᩥ, ᩋᨠ᩠ᨡᩣᨳ ᨶᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨠᩮ ᨶᩩ ᨲᩩᨾ᩠ᩉᩮ’’.

᪒᪐᪕.

‘‘ᨧᨶ᩠ᨴᩮᩣ ᨧ ᩈᩪᩁᩥᨿᩮᩣ ᨧ [ᩈᩪᩁᩥᨿᩮᩣ ᨧ (ᨠ.)] ᩏᨽᩮᩣ ᩍᨵᩣᨣᨲᩣ, ᩋᨿᩴ ᨸᨶ ᨾᩣᨲᩃᩥ ᨴᩮᩅᩈᩣᩁᨳᩥ;

ᩈᨠ᩠ᨠᩮᩣᩉᨾᩈ᩠ᨾᩥ ᨲᩥᨴᩈᩣᨶᨾᩥᨶ᩠ᨴᩮᩣ, ᩑᩈᩮᩣ ᨧ ᨡᩮᩣ ᨸᨬ᩠ᨧᩈᩥᨡᩮᩣᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩥ.

᪒᪐᪖.

‘‘ᨸᩣᨱᩥᩔᩁᩣ ᨾᩩᨴᩥᨦ᩠ᨣᩣ ᨧ [ᨾᩩᨲᩥᨦ᩠ᨣᩣ ᨧ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨾᩩᩁᨩᩣᩃᨾ᩠ᨻᩁᩣᨶᩥ ᨧ;

ᩈᩩᨲ᩠ᨲᨾᩮᨶᩴ ᨸᨻᩮᩣᨵᩮᨶ᩠ᨲᩥ, ᨸᨭᩥᨻᩩᨴ᩠ᨵᩮᩣ ᨧ ᨶᨶ᩠ᨴᨲᩥ’’.

᪒᪐᪗.

‘‘ᨿᩮ ᨠᩮᨧᩥᨾᩮ ᨾᨧ᩠ᨨᩁᩥᨶᩮᩣ ᨠᨴᩁᩥᨿᩣ, ᨸᩁᩥᨽᩣᩈᨠᩣ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ;

ᩍᨵᩮᩅ ᨶᩥᨠ᩠ᨡᩥᨸ᩠ᨸ ᩈᩁᩦᩁᨴᩮᩉᩴ, ᨠᩣᨿᩔ ¶ ᨽᩮᨴᩣ ᨶᩥᩁᨿᩴ ᩅᨩᨶ᩠ᨲᩥ’’.

᪒᪐᪘.

‘‘ᨿᩮ ᨠᩮᨧᩥᨾᩮ ᩈᩩᨣ᩠ᨣᨲᩥᨾᩣᩈᨾᩣᨶᩣ [ᩈᩩᨣ᩠ᨣᨲᩥᨾᩣᩈᩈᩣᨶᩣ (ᩈᩦ. ᨸᩦ.), ᩈᩩᨣ᩠ᨣᨲᩣᩈᩥᩈᨾᩣᨶᩣ (ᨠ.)], ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩣ ᩈᩴᨿᨾᩮ ᩈᩴᩅᩥᨽᩣᨣᩮ;

ᩍᨵᩮᩅ ᨶᩥᨠ᩠ᨡᩥᨸ᩠ᨸ ᩈᩁᩦᩁᨴᩮᩉᩴ, ᨠᩣᨿᩔ ᨽᩮᨴᩣ ᩈᩩᨣᨲᩥᩴ ᩅᨩᨶ᩠ᨲᩥ’’.

᪒᪐᪙.

‘‘ᨲ᩠ᩅᩴ ¶ ᨶᩮᩣᩈᩥ ᨬᩣᨲᩥ ᨸᩩᩁᩥᨾᩣᩈᩩ ᨩᩣᨲᩥᩈᩩ, ᩈᩮᩣ ᨾᨧ᩠ᨨᩁᩦ ᩁᩮᩣᩈᨠᩮᩣ [ᨠᩮᩣᩈᩥᨿᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨸᩣᨸᨵᨾ᩠ᨾᩮᩣ;

ᨲᩅᩮᩅ ᩋᨲ᩠ᨳᩣᨿ ᩍᨵᩣᨣᨲᨾ᩠ᩉᩣ, ᨾᩣ ᨸᩣᨸᨵᨾ᩠ᨾᩮᩣ ᨶᩥᩁᨿᩴ ᨣᨾᩥᨲ᩠ᨳ’’ [ᩋᨸᨲ᩠ᨳ (ᨠ. ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)].

᪒᪑᪐.

‘‘ᩋᨴ᩠ᨵᩣ ¶ ᩉᩥ ᨾᩴ ᩅᩮᩣ ᩉᩥᨲᨠᩣᨾᩣ, ᨿᩴ ᨾᩴ ᩈᨾᨶᩩᩈᩣᩈᨳ;

ᩈᩮᩣᩉᩴ ᨲᨳᩣ ᨠᩁᩥᩔᩣᨾᩥ, ᩈᨻ᩠ᨻᩴ ᩅᩩᨲ᩠ᨲᩴ ᩉᩥᨲᩮᩈᩥᨽᩥ.

᪒᪑᪑.

‘‘ᩑᩈᩣᩉᨾᨩ᩠ᨩᩮᩅ ᩏᨸᩣᩁᨾᩣᨾᩥ, ᨶ ᨧᩣᨸᩥᩉᩴ [ᨶ ᨧᩣᨸᩉᩴ (ᩈᩦ. ᨸᩦ.)] ᨠᩥᨬ᩠ᨧᩥ ᨠᩁᩮᨿ᩠ᨿ ᨸᩣᨸᩴ;

ᨶ ᨧᩣᨸᩥ ᨾᩮ ᨠᩥᨬ᩠ᨧᩥ ᩋᨴᩮᨿ᩠ᨿᨾᨲ᩠ᨳᩥ, ᨶ ᨧᩣᨸᩥᨴᨲ᩠ᩅᩣ ᩏᨴᨠᩴ ᨸᩥᩅᩣᨾᩥ [ᩏᨴᨠᨾ᩠ᨸᩉᩴ ᨸᩥᨻᩮ (ᩈᩦ.)].

᪒᪑᪒.

‘‘ᩑᩅᨬ᩠ᨧ ᨾᩮ ᨴᨴᨲᩮᩣ ᩈᨻ᩠ᨻᨠᩣᩃᩴ [ᩈᨻ᩠ᨻᨠᩣᩃᩮ (ᨠ.)], ᨽᩮᩣᨣᩣ ᩍᨾᩮ ᩅᩣᩈᩅ ᨡᩦᨿᩥᩔᨶ᩠ᨲᩥ;

ᨲᨲᩮᩣ ᩋᩉᩴ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ ᩈᨠ᩠ᨠ, ᩉᩥᨲ᩠ᩅᩣᨶ ᨠᩣᨾᩣᨶᩥ ᨿᨳᩮᩣᨵᩥᨠᩣᨶᩥ’’.

᪒᪑᪓.

‘‘ᨶᨣᩩᨲ᩠ᨲᨾᩮ ᨣᩥᩁᩥᩅᩁᩮ ᨣᨶ᩠ᨵᨾᩣᨴᨶᩮ, ᨾᩮᩣᨴᨶ᩠ᨲᩥ ¶ ᨲᩣ ᨴᩮᩅᩅᩁᩣᨽᩥᨸᩣᩃᩥᨲᩣ;

ᩋᨳᩣᨣᨾᩣ ᩍᩈᩥᩅᩁᩮᩣ ᩈᨻ᩠ᨻᩃᩮᩣᨠᨣᩪ, ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩴ ᨴᩩᨾᩅᩁᩈᩣᨡᨾᩣᨴᩥᨿ.

᪒᪑᪔.

‘‘ᩈᩩᨧᩥᩴ ᩈᩩᨣᨶ᩠ᨵᩴ ᨲᩥᨴᩈᩮᩉᩥ ᩈᨠ᩠ᨠᨲᩴ, ᨸᩩᨸ᩠ᨹᩩᨲ᩠ᨲᨾᩴ ᩋᨾᩁᩅᩁᩮᩉᩥ ᩈᩮᩅᩥᨲᩴ;

ᩋᩃᨴ᩠ᨵ ᨾᨧ᩠ᨧᩮᩉᩥ ᩅ ᨴᩣᨶᩅᩮᩉᩥ ᩅᩣ, ᩋᨬ᩠ᨬᨲᩕ ᨴᩮᩅᩮᩉᩥ ᨲᨴᩣᩁᩉᩴ ᩉᩥᨴᩴ [ᩉᩥᨲᩴ (ᩈ᩠ᨿᩣ.)].

᪒᪑᪕.

‘‘ᨲᨲᩮᩣ ᨧᨲᩔᩮᩣ ᨠᨶᨠᨲ᩠ᨲᨧᩪᨸᨾᩣ, ᩏᨭ᩠ᨮᩣᨿ ᨶᩣᩁᩥᨿᩮᩣ ᨸᨾᨴᩣᨵᩥᨸᩣ ᨾᩩᨶᩥᩴ;

ᩌᩈᩣ ᨧ ᩈᨴ᩠ᨵᩣ ᨧ ᩈᩥᩁᩦ ᨲᨲᩮᩣ ᩉᩥᩁᩦ, ᩍᨧ᩠ᨧᨻᩕᩅᩩᩴ ᨶᩣᩁᨴᨴᩮᩅ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

᪒᪑᪖.

‘‘ᩈᨧᩮ ¶ ᩋᨶᩩᨴ᩠ᨴᩥᨭ᩠ᨮᩴ ᨲᨿᩣ ᨾᩉᩣᨾᩩᨶᩥ, ᨸᩩᨸ᩠ᨹᩴ ᩍᨾᩴ ᨸᩣᩁᩥᨨᨲ᩠ᨲᩔ ᨻᩕᩉ᩠ᨾᩮ;

ᨴᨴᩣᩉᩥ ᨶᩮᩣ ᩈᨻ᩠ᨻᩣ ᨣᨲᩥ ᨲᩮ ᩍᨩ᩠ᨫᨲᩩ, ᨲᩩᩅᨾ᩠ᨸᩥ ᨶᩮᩣ ᩉᩮᩣᩉᩥ ᨿᨳᩮᩅ ᩅᩣᩈᩅᩮᩣ.

᪒᪑᪗.

‘‘ᨲᩴ ᨿᩣᨧᨾᩣᨶᩣᨽᩥᩈᨾᩮᨠ᩠ᨡ ᨶᩣᩁᨴᩮᩣ, ᩍᨧ᩠ᨧᨻᩕᩅᩦ ᩈᩴᨠᩃᩉᩴ ᩏᨴᩦᩁᨿᩥ;

ᨶ ᨾᨿ᩠ᩉᨾᨲ᩠ᨳᨲ᩠ᨳᩥ ᩍᨾᩮᩉᩥ ᨠᩮᩣᨧᩥ ᨶᩴ, ᨿᩣᨿᩮᩅ ᩅᩮᩣ ᩈᩮᨿ᩠ᨿᩈᩥ ᩈᩣ ᨸᩥᩊᨶ᩠ᨵᨳ’’ [ᨸᩥᩊᨿ᩠ᩉᨳ (ᩈᩦ. ᨸᩦ.)].

᪒᪑᪘.

‘‘ᨲ᩠ᩅᩴ ᨶᩮᩣᨲ᩠ᨲᨾᩮᩅᩣᨽᩥᩈᨾᩮᨠ᩠ᨡ ᨶᩣᩁᨴ, ᨿᩔᩥᨧ᩠ᨨᩈᩥ ¶ ᨲᩔᩣ ᩋᨶᩩᨸ᩠ᨸᩅᩮᨧ᩠ᨨᩈᩩ;

ᨿᩔᩣ ᩉᩥ ᨶᩮᩣ ᨶᩣᩁᨴ ᨲ᩠ᩅᩴ ᨸᨴᩔᩈᩥ, ᩈᩣᨿᩮᩅ ᨶᩮᩣ ᩉᩮᩉᩥᨲᩥ ᩈᩮᨭ᩠ᨮᩈᨾ᩠ᨾᨲᩣ’’.

᪒᪑᪙.

‘‘ᩋᨠᩃ᩠ᩃᨾᩮᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨣᨲ᩠ᨲᩮ, ᨠᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩈᩴᨠᩃᩉᩴ ᩏᨴᩦᩁᨿᩮ;

ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨽᩪᨲᩣᨵᩥᨸᨾᩮᩅ ᨸᩩᨧ᩠ᨨᨳ, ᩈᨧᩮ ᨶ ᨩᩣᨶᩣᨳ ᩍᨵᩩᨲ᩠ᨲᨾᩣᨵᨾᩴ’’.

᪒᪒᪐.

‘‘ᨲᩣ ᨶᩣᩁᨴᩮᨶ ᨸᩁᨾᨸ᩠ᨸᨠᩮᩣᨸᩥᨲᩣ, ᩏᨴᩦᩁᩥᨲᩣ ᩅᨱ᩠ᨱᨾᨴᩮᨶ ᨾᨲ᩠ᨲᩣ;

ᩈᨠᩣᩈᩮ [ᩈᨠᩣᩈᩴ (ᨠ.)] ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᩈᩉᩔᨧᨠ᩠ᨡᩩᨶᩮᩣ, ᨸᩩᨧ᩠ᨨᩥᩴᩈᩩ ᨽᩪᨲᩣᨵᩥᨸᩴ ᨠᩣ ᨶᩩ ᩈᩮᨿ᩠ᨿᩈᩥ’’.

᪒᪒᪑.

‘‘ᨲᩣ ᨴᩥᩈ᩠ᩅᩣ ᩌᨿᨲ᩠ᨲᨾᨶᩣ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ, ᩍᨧ᩠ᨧᨻᩕᩅᩦ ᨴᩮᩅᩅᩁᩮᩣ ᨠᨲᨬ᩠ᨩᩃᩦ;

ᩈᨻ᩠ᨻᩣᩅ ᩅᩮᩣ ᩉᩮᩣᨳ ᩈᩩᨣᨲ᩠ᨲᩮ ᩈᩣᨴᩥᩈᩦ, ᨠᩮᩣ ᨶᩮᩅ ᨽᨴ᩠ᨴᩮ ᨠᩃᩉᩴ ᩏᨴᩦᩁᨿᩥ’’.

᪒᪒᪒.

‘‘ᨿᩮᩣ ¶ ᩈᨻ᩠ᨻᩃᩮᩣᨠᨧ᩠ᨧᩁᩥᨲᩮᩣ [ᩈᨻ᩠ᨻᩃᩮᩣᨠᩴ ᨧᩁᨠᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩉᩣᨾᩩᨶᩥ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩮᩣ ᨶᩣᩁᨴᩮᩣ [ᨶᩣᩁᨴ (ᩈ᩠ᨿᩣ.)] ᩈᨧ᩠ᨧᨶᩥᨠ᩠ᨠᨾᩮᩣ;

ᩈᩮᩣ ᨶᩮᩣᨻᩕᩅᩥ [ᨻᩕᩅᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨣᩥᩁᩥᩅᩁᩮ ᨣᨶ᩠ᨵᨾᩣᨴᨶᩮ, ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨽᩪᨲᩣᨵᩥᨸᨾᩮᩅ ᨸᩩᨧ᩠ᨨᨳ;

ᩈᨧᩮ ᨶ ᨩᩣᨶᩣᨳ ᩍᨵᩩᨲ᩠ᨲᨾᩣᨵᨾᩴ’’.

᪒᪒᪓.

‘‘ᩋᩈᩩ ¶ [ᩋᩈᩪ (ᩈ᩠ᨿᩣ.)] ᨻᩕᩉᩣᩁᨬ᩠ᨬᨧᩁᩮᩣ ᨾᩉᩣᨾᩩᨶᩥ, ᨶᩣᨴᨲ᩠ᩅᩣ ᨽᨲ᩠ᨲᩴ ᩅᩁᨣᨲ᩠ᨲᩮ ᨽᩩᨬ᩠ᨩᨲᩥ;

ᩅᩥᨧᩮᨿ᩠ᨿ ᨴᩣᨶᩣᨶᩥ ᨴᨴᩣᨲᩥ ᨠᩮᩣᩈᩥᨿᩮᩣ, ᨿᩔᩣ ᩉᩥ ᩈᩮᩣ ᨴᩔᨲᩥ ᩈᩣᩅ ᩈᩮᨿ᩠ᨿᩈᩥ’’.

᪒᪒᪔.

‘‘ᩋᩈᩪ ¶ ᩉᩥ ᨿᩮᩣ ᩈᨾ᩠ᨾᨲᩥ ᨴᨠ᩠ᨡᩥᨱᩴ ᨴᩥᩈᩴ, ᨣᨦ᩠ᨣᩣᨿ ᨲᩦᩁᩮ ᩉᩥᨾᩅᨶ᩠ᨲᨸᩔᨶᩥ [ᩉᩥᨾᩅᨶ᩠ᨲᨸᩈ᩠ᨾᨶᩥ (ᩈᩦ. ᨸᩦ. ᨠ.)];

ᩈ ᨠᩮᩣᩈᩥᨿᩮᩣ ᨴᩩᩃ᩠ᩃᨽᨸᩣᨶᨽᩮᩣᨩᨶᩮᩣ, ᨲᩔ ᩈᩩᨵᩴ ᨸᩣᨸᨿ ᨴᩮᩅᩈᩣᩁᨳᩥ’’.

᪒᪒᪕.

‘‘ᩈ [ᩈᩮᩣ (ᩈ᩠ᨿᩣ.)] ᨾᩣᨲᩃᩦ ᨴᩮᩅᩅᩁᩮᨶ ᨸᩮᩈᩥᨲᩮᩣ, ᩈᩉᩔᨿᩩᨲ᩠ᨲᩴ ᩋᨽᩥᩁᩩᨿ᩠ᩉ ᩈᨶ᩠ᨴᨶᩴ;

ᩈᩩᨡᩥᨸ᩠ᨸᨾᩮᩅ [ᩈ ᨡᩥᨸ᩠ᨸᨾᩮᩅ (ᩈᩦ. ᨸᩦ.)] ᩏᨸᨣᨾ᩠ᨾ ᩋᩔᨾᩴ, ᩋᨴᩥᩔᨾᩣᨶᩮᩣ ᨾᩩᨶᩥᨶᩮᩣ ᩈᩩᨵᩴ ᩋᨴᩣ’’.

᪒᪒᪖.

‘‘ᩏᨴᨣ᩠ᨣᩥᩉᩩᨲ᩠ᨲᩴ ᩏᨸᨲᩥᨭ᩠ᨮᨲᩮᩣ ᩉᩥ ᨾᩮ, ᨸᨽᨦ᩠ᨠᩁᩴ ᩃᩮᩣᨠᨲᨾᩮᩣᨶᩩᨴᩩᨲ᩠ᨲᨾᩴ;

ᩈᨻ᩠ᨻᩣᨶᩥ ᨽᩪᨲᩣᨶᩥ ᩋᨵᩥᨧ᩠ᨧ [ᩋᨲᩥᨧ᩠ᨧ (ᩈᩦ. ᨸᩦ.)] ᩅᩣᩈᩅᩮᩣ, ᨠᩮᩣ ᨶᩮᩅ ᨾᩮ ᨸᩣᨱᩥᩈᩩ ᨠᩥᩴ ᩈᩩᨵᩮᩣᨴᩉᩥ.

᪒᪒᪗.

‘‘ᩈᨦ᩠ᨡᩪᨸᨾᩴ ᩈᩮᨲᨾᨲᩩᩃ᩠ᨿᨴᩔᨶᩴ, ᩈᩩᨧᩥᩴ ᩈᩩᨣᨶ᩠ᨵᩴ ᨸᩥᨿᩁᩪᨸᨾᨻ᩠ᨽᩩᨲᩴ;

ᩋᨴᩥᨭ᩠ᨮᨸᩩᨻ᩠ᨻᩴ ᨾᨾ ᨩᩣᨲᩩ ᨧᨠ᩠ᨡᩩᨽᩥ [ᨩᩣᨲᨧᨠ᩠ᨡᩩᩉᩥ (ᩈᩦ. ᨸᩦ.)], ᨠᩣ ᨴᩮᩅᨲᩣ ᨸᩣᨱᩥᩈᩩ ᨠᩥᩴ ᩈᩩᨵᩮᩣᨴᩉᩥ’’.

᪒᪒᪘.

‘‘ᩋᩉᩴ ¶ ¶ ᨾᩉᩥᨶ᩠ᨴᩮᨶ ᨾᩉᩮᩈᩥ ᨸᩮᩈᩥᨲᩮᩣ, ᩈᩩᨵᩣᨽᩥᩉᩣᩈᩥᩴ ᨲᩩᩁᩥᨲᩮᩣ ᨾᩉᩣᨾᩩᨶᩥ;

ᨩᩣᨶᩣᩈᩥ ᨾᩴ ᨾᩣᨲᩃᩥ ᨴᩮᩅᩈᩣᩁᨳᩥ, ᨽᩩᨬ᩠ᨩᩔᩩ ᨽᨲ᩠ᨲᩩᨲ᩠ᨲᨾ ᨾᩣᨽᩥᩅᩣᩁᨿᩥ [ᨾᩣ ᩅᩥᨧᩣᩁᨿᩥ (ᩈᩦ. ᨸᩦ.)].

᪒᪒᪙.

‘‘ᨽᩩᨲ᩠ᨲᩣ ᨧ ᩈᩣ ᨴ᩠ᩅᩣᨴᩈ ᩉᨶ᩠ᨲᩥ ᨸᩣᨸᨠᩮ, ᨡᩩᨴᩴ ᨸᩥᨸᩣᩈᩴ ᩋᩁᨲᩥᩴ ᨴᩁᨠ᩠ᩃᨾᩴ [ᨴᩁᨳᩴ ᨠᩥᩃᩴ (ᩈ᩠ᨿᩣ.), ᨴᩁᨳᨠ᩠ᨡᨾᩴ (ᨠ.)];

ᨠᩮᩣᨵᩪᨸᨶᩣᩉᨬ᩠ᨧ ᩅᩥᩅᩣᨴᨸᩮᩈᩩᨱᩴ, ᩈᩦᨲᩩᨱ᩠ᩉᨲᨶ᩠ᨴᩥᨬ᩠ᨧ ᩁᩈᩩᨲ᩠ᨲᨾᩴ ᩍᨴᩴ’’.

᪒᪓᪐.

‘‘ᨶ ᨠᨸ᩠ᨸᨲᩦ ᨾᩣᨲᩃᩥ ᨾᨿ᩠ᩉ ᨽᩩᨬ᩠ᨩᩥᨲᩩᩴ, ᨸᩩᨻ᩠ᨻᩮ ᩋᨴᨲ᩠ᩅᩣ ᩍᨲᩥ ᨾᩮ ᩅᨲᩩᨲ᩠ᨲᨾᩴ;

ᨶ ᨧᩣᨸᩥ ᩑᨠᩣᩈ᩠ᨶᨾᩁᩦᨿᨸᩪᨩᩥᨲᩴ [ᩑᨠᩣᩈᨶᩴ ᩋᩁᩥᨿᨸᩪᨩᩥᨲᩴ (ᩈᩦ. ᨸᩦ.)], ᩋᩈᩴᩅᩥᨽᩣᨣᩦ ᨧ ᩈᩩᨡᩴ ᨶ ᩅᩥᨶ᩠ᨴᨲᩥ’’.

᪒᪓᪑.

‘‘ᨳᩦᨥᩣᨲᨠᩣ ᨿᩮ ᨧᩥᨾᩮ ᨸᩣᩁᨴᩣᩁᩥᨠᩣ, ᨾᩥᨲ᩠ᨲᨴ᩠ᨴᩩᨶᩮᩣ ᨿᩮ ᨧ ᩈᨸᨶ᩠ᨲᩥ ᩈᩩᨻ᩠ᨻᨲᩮ;

ᩈᨻ᩠ᨻᩮ ᨧ ᨲᩮ ᨾᨧ᩠ᨨᩁᩥᨸᨬ᩠ᨧᨾᩣᨵᨾᩣ, ᨲᩈ᩠ᨾᩣ ᩋᨴᨲ᩠ᩅᩣ ᩏᨴᨠᨾ᩠ᨸᩥ ᨶᩣᩈ᩠ᨶᩥᨿᩮ [ᨶᩣᩈ᩠ᨾᩥᨿᩮ (ᩈᩦ. ᨸᩦ.)].

᪒᪓᪒.

‘‘ᩈᩮᩣ ᩉᩥᨲ᩠ᨳᩥᨿᩣ ᩅᩣ ᨸᩩᩁᩥᩈᩔ ᩅᩣ ᨸᨶ, ᨴᩔᩣᨾᩥ ᨴᩣᨶᩴ ᩅᩥᨴᩩᩈᨾ᩠ᨸᩅᨱ᩠ᨱᩥᨲᩴ;

ᩈᨴ᩠ᨵᩣ ᩅᨴᨬ᩠ᨬᩪ ᩍᨵ ᩅᩦᨲᨾᨧ᩠ᨨᩁᩣ, ᨽᩅᨶ᩠ᨲᩥ ¶ ᩉᩮᨲᩮ ᩈᩩᨧᩥᩈᨧ᩠ᨧᩈᨾ᩠ᨾᨲᩣ’’ [ᩈᨾ᩠ᨾᩈᨾ᩠ᨾᨲᩣ (ᩈᩦ.)].

᪒᪓᪓.

‘‘ᩋᨲᩮᩣ ᨾᨲᩣ [ᨾᩩᨲᩣ (ᩈᩦ. ᨸᩦ.)] ᨴᩮᩅᩅᩁᩮᨶ ᨸᩮᩈᩥᨲᩣ, ᨠᨬ᩠ᨬᩣ ᨧᨲᩔᩮᩣ ᨠᨶᨠᨲ᩠ᨲᨧᩪᨸᨾᩣ;

ᩌᩈᩣ ᨧ ᩈᨴ᩠ᨵᩣ ᨧ ᩈᩥᩁᩦ ᨲᨲᩮᩣ ᩉᩥᩁᩦ [ᩈᩥᩁᩦ ᩉᩥᩁᩦ ᨲᨲᩮᩣ (ᨸᩦ.)], ᨲᩴ ᩋᩔᨾᩴ ᩌᨣᨾᩩ [ᩌᨣᨾᩩᩴ (ᩈᩦ. ᨸᩦ. ᨠ.)] ᨿᨲ᩠ᨳ ᨠᩮᩣᩈᩥᨿᩮᩣ.

᪒᪓᪔.

‘‘ᨲᩣ ¶ ᨴᩥᩈ᩠ᩅᩣ ᩈᨻ᩠ᨻᩮᩣ ᨸᩁᨾᨸ᩠ᨸᨾᩮᩣᨴᩥᨲᩮᩣ [ᩈᨻ᩠ᨻᩣ ᨸᩁᨾᨸ᩠ᨸᨾᩮᩣᨴᩥᨲᩣ (ᩈ᩠ᨿᩣ.)], ᩈᩩᨽᩮᨶ ᩅᨱ᩠ᨱᩮᨶ ᩈᩥᨡᩣᩁᩥᩅᨣ᩠ᨣᩥᨶᩮᩣ;

ᨠᨬ᩠ᨬᩣ ᨧᨲᩔᩮᩣ ᨧᨲᩩᩁᩮᩣ ᨧᨲᩩᨴ᩠ᨴᩥᩈᩣ, ᩍᨧ᩠ᨧᨻᩕᩅᩦ ᨾᩣᨲᩃᩥᨶᩮᩣ ᨧ ᩈᨾ᩠ᨾᩩᨡᩣ.

᪒᪓᪕.

‘‘ᨸᩩᩁᩥᨾᩴ ᨴᩥᩈᩴ ᨠᩣ ᨲ᩠ᩅᩴ ᨸᨽᩣᩈᩥ ᨴᩮᩅᨲᩮ, ᩋᩃᨦ᩠ᨠᨲᩣ ᨲᩣᩁᩅᩁᩣᩅ ᩒᩈᨵᩦ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨠᨬ᩠ᨧᨶᩅᩮᩃ᩠ᩃᩥᩅᩥᨣ᩠ᨣᩉᩮ, ᩌᨧᩥᨠ᩠ᨡ ᨾᩮ ᨲ᩠ᩅᩴ ᨠᨲᨾᩣᩈᩥ ᨴᩮᩅᨲᩣ.

᪒᪓᪖.

‘‘ᩈᩥᩁᩣᩉ ᨴᩮᩅᩦᨾᨶᩩᨩᩮᨽᩥ [ᨾᨶᩩᨩᩮᩈᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᩪᨩᩥᨲᩣ, ᩋᨸᩣᨸᩈᨲ᩠ᨲᩪᨸᨶᩥᩈᩮᩅᩥᨶᩦ ᩈᨴᩣ;

ᩈᩩᨵᩣᩅᩥᩅᩣᨴᩮᨶ ᨲᩅᨶ᩠ᨲᩥᨾᩣᨣᨲᩣ, ᨲᩴ ¶ ᨾᩴ ᩈᩩᨵᩣᨿ ᩅᩁᨸᨬ᩠ᨬ ᨽᩣᨩᨿ.

᪒᪓᪗.

‘‘ᨿᩔᩣᩉᨾᩥᨧ᩠ᨨᩣᨾᩥ ᩈᩩᨵᩴ [ᩈᩩᨡᩴ (ᨸᩦ.)] ᨾᩉᩣᨾᩩᨶᩥ, ᩈᩮᩣ [ᩈ (ᩈᩦ. ᨸᩦ.)] ᩈᨻ᩠ᨻᨠᩣᨾᩮᩉᩥ ᨶᩁᩮᩣ ᨸᨾᩮᩣᨴᨲᩥ;

ᩈᩥᩁᩦᨲᩥ ᨾᩴ ᨩᩣᨶᩉᩥ ᨩᩪᩉᨲᩩᨲ᩠ᨲᨾ, ᨲᩴ ᨾᩴ ᩈᩩᨵᩣᨿ ᩅᩁᨸᨬ᩠ᨬ ᨽᩣᨩᨿ’’.

᪒᪓᪘.

‘‘ᩈᩥᨸ᩠ᨸᩮᨶ ᩅᩥᨩ᩠ᨩᩣᨧᩁᨱᩮᨶ ᨻᩩᨴ᩠ᨵᩥᨿᩣ, ᨶᩁᩣ ᩏᨸᩮᨲᩣ ᨸᨣᩩᨱᩣ ᩈᨠᨾ᩠ᨾᩩᨶᩣ [ᩈᨠᨾ᩠ᨾᨶᩣ (ᩈᩦ. ᨸᩦ.)];

ᨲᨿᩣ ᩅᩥᩉᩦᨶᩣ ᨶ ᩃᨽᨶ᩠ᨲᩥ ᨠᩥᨬ᩠ᨧᨶᩴ [ᨠᩥᨬ᩠ᨧᩥᨶᩴ (ᨠ.)], ᨲᨿᩥᨴᩴ ᨶ ᩈᩣᨵᩩ ᨿᨴᩥᨴᩴ ᨲᨿᩣ ᨠᨲᩴ.

᪒᪓᪙.

‘‘ᨸᩔᩣᨾᩥ ¶ ᨸᩮᩣᩈᩴ ᩋᩃᩈᩴ ᨾᩉᨣ᩠ᨥᩈᩴ, ᩈᩩᨴᩩᨠ᩠ᨠᩩᩃᩦᨶᨾ᩠ᨸᩥ ᩋᩁᩪᨸᩥᨾᩴ ᨶᩁᩴ;

ᨲᨿᩣᨶᩩᨣᩩᨲ᩠ᨲᩮᩣ ᩈᩥᩁᩥ ᨩᩣᨲᩥᨾᩣᨾᨸᩥ [ᨩᩣᨲᩥᨾᩴ ᩋᨸᩥ (ᩈᩦ.)], ᨸᩮᩈᩮᨲᩥ ᨴᩣᩈᩴ ᩅᩥᨿ ᨽᩮᩣᨣᩅᩣ ᩈᩩᨡᩦ.

᪒᪔᪐.

‘‘ᨲᩴ ᨲᩴ ᩋᩈᨧ᩠ᨧᩴ ᩋᩅᩥᨽᨩ᩠ᨩᩈᩮᩅᩥᨶᩥᩴ, ᨩᩣᨶᩣᨾᩥ ᨾᩪᩊ᩠ᩉᩴ ᩅᩥᨴᩩᩁᩣᨶᩩᨸᩣᨲᩥᨶᩥᩴ;

ᨶ ᨲᩣᨴᩥᩈᩦ ᩋᩁᩉᨲᩥ ᩌᩈᨶᩪᨴᨠᩴ, ᨠᩩᨲᩮᩣ ᩈᩩᨵᩣ ᨣᨧ᩠ᨨ ᨶ ᨾᨿ᩠ᩉ ᩁᩩᨧ᩠ᨧᩈᩥ’’.

᪒᪔᪑.

‘‘ᨠᩣ ¶ ᩈᩩᨠ᩠ᨠᨴᩣᨮᩣ ᨸᨭᩥᨾᩩᨠ᩠ᨠᨠᩩᨱ᩠ᨯᩃᩣ, ᨧᩥᨲ᩠ᨲᨦ᩠ᨣᨴᩣ ᨠᨾ᩠ᨻᩩᩅᩥᨾᨭ᩠ᨮᨵᩣᩁᩥᨶᩦ;

ᩒᩈᩥᨲ᩠ᨲᩅᨱ᩠ᨱᩴ ᨸᩁᩥᨴᨿ᩠ᩉ ᩈᩮᩣᨽᩈᩥ, ᨠᩩᩈᨣ᩠ᨣᩥᩁᨲ᩠ᨲᩴ ᩋᨸᩥᩊᨿ᩠ᩉ ᨾᨬ᩠ᨩᩁᩥᩴ.

᪒᪔᪒.

‘‘ᨾᩥᨣᩦᩅ ᨽᨶ᩠ᨲᩣ ᩈᩁᨧᩣᨸᨵᩣᩁᩥᨶᩣ, ᩅᩥᩁᩣᨵᩥᨲᩣ ᨾᨶ᩠ᨴᨾᩥᩅ ᩏᨴᩥᨠ᩠ᨡᩈᩥ;

ᨠᩮᩣ ᨲᩮ ᨴᩩᨲᩦᨿᩮᩣ ᩍᨵ ᨾᨶ᩠ᨴᩃᩮᩣᨧᨶᩮ, ᨶ ¶ ᨽᩣᨿᩈᩥ ᩑᨠᩥᨠᩣ ᨠᩣᨶᨶᩮ ᩅᨶᩮ’’.

᪒᪔᪓.

‘‘ᨶ ᨾᩮ ᨴᩩᨲᩦᨿᩮᩣ ᩍᨵ ᨾᨲ᩠ᨳᩥ ᨠᩮᩣᩈᩥᨿ, ᨾᩈᨠ᩠ᨠᩈᩣᩁᨸ᩠ᨸᨽᩅᨾ᩠ᩉᩥ ᨴᩮᩅᨲᩣ;

ᩌᩈᩣ ᩈᩩᨵᩣᩈᩣᨿ ᨲᩅᨶ᩠ᨲᩥᨾᩣᨣᨲᩣ, ᨲᩴ ᨾᩴ ᩈᩩᨵᩣᨿ ᩅᩁᨸᨬ᩠ᨬ ᨽᩣᨩᨿ’’.

᪒᪔᪔.

‘‘ᩌᩈᩣᨿ ᨿᨶ᩠ᨲᩥ ᩅᩣᨱᩥᨩᩣ ᨵᨶᩮᩈᩥᨶᩮᩣ, ᨶᩣᩅᩴ ᩈᨾᩣᩁᩩᨿ᩠ᩉ ᨸᩁᩮᨶ᩠ᨲᩥ ᩋᨱ᩠ᨱᩅᩮ;

ᨲᩮ ᨲᨲ᩠ᨳ ᩈᩦᨴᨶ᩠ᨲᩥ ᩋᨳᩮᩣᨸᩥ ᩑᨠᨴᩣ, ᨩᩦᨶᩣᨵᨶᩣ ᩑᨶ᩠ᨲᩥ ᩅᩥᨶᨭ᩠ᨮᨸᩣᨽᨲᩣ.

᪒᪔᪕.

‘‘ᩌᩈᩣᨿ ᨡᩮᨲ᩠ᨲᩣᨶᩥ ᨠᩈᨶ᩠ᨲᩥ ᨠᩔᨠᩣ, ᩅᨸᨶ᩠ᨲᩥ ᨻᩦᨩᩣᨶᩥ ᨠᩁᩮᩣᨶ᩠ᨲᩩᨸᩣᨿᩈᩮᩣ;

ᩎᨲᩦᨶᩥᨸᩣᨲᩮᨶ ᩋᩅᩩᨭ᩠ᨮᩥᨲᩣᨿ [ᩋᩅᩩᨭ᩠ᨮᩥᨠᩣᨿ (ᩈᩦ. ᨸᩦ.)] ᩅᩣ, ᨶ ᨠᩥᨬ᩠ᨧᩥ ᩅᩥᨶ᩠ᨴᨶ᩠ᨲᩥ ᨲᨲᩮᩣ ᨹᩃᩣᨣᨾᩴ.

᪒᪔᪖.

‘‘ᩋᨳᨲ᩠ᨲᨠᩣᩁᩣᨶᩥ ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᨽᨲ᩠ᨲᩩᩈᩩ, ᩌᩈᩴ ᨸᩩᩁᨠ᩠ᨡᨲ᩠ᩅᩣ ᨶᩁᩣ ᩈᩩᨡᩮᩈᩥᨶᩮᩣ;

ᨲᩮ ᨽᨲ᩠ᨲᩩᩁᨲ᩠ᨳᩣ ᩋᨲᩥᨣᩣᩊ᩠ᩉᩥᨲᩣ ᨸᩩᨶ, ᨴᩥᩈᩣ ᨸᨶᩔᨶ᩠ᨲᩥ ᩋᩃᨴ᩠ᨵ ᨠᩥᨬ᩠ᨧᨶᩴ.

᪒᪔᪗.

‘‘ᩉᩥᨲ᩠ᩅᩣᨶ [ᨩᩉᩥᨲ᩠ᩅ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨵᨬ᩠ᨬᨬ᩠ᨧ ᨵᨶᨬ᩠ᨧ ᨬᩣᨲᨠᩮ, ᩌᩈᩣᨿ ᩈᨣ᩠ᨣᩣᨵᩥᨾᨶᩣ ᩈᩩᨡᩮᩈᩥᨶᩮᩣ;

ᨲᨸᨶ᩠ᨲᩥ ¶ ᩃᩪᨡᨾ᩠ᨸᩥ ᨲᨸᩴ ᨧᩥᩁᨶ᩠ᨲᩁᩴ, ᨠᩩᨾᨣ᩠ᨣᨾᩣᩁᩩᨿ᩠ᩉ [ᨠᩩᨾ᩠ᨾᨣ᩠ᨣᨾᩣᩁᩩᨿ᩠ᩉ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᩁᩮᨶ᩠ᨲᩥ ᨴᩩᨣ᩠ᨣᨲᩥᩴ.

᪒᪔᪘.

‘‘ᩌᩈᩣ ¶ ᩅᩥᩈᩴᩅᩣᨴᩥᨠᩈᨾ᩠ᨾᨲᩣ ᩍᨾᩮ, ᩌᩈᩮ ᩈᩩᨵᩣᩈᩴ [ᩈᩩᨵᩣᨿ (ᩈ᩠ᨿᩣ ᨸᩦ. ᨠ.)] ᩅᩥᨶᨿᩔᩩ ᩋᨲ᩠ᨲᨶᩥ;

ᨶ ᨲᩣᨴᩥᩈᩦ ᩋᩁᩉᨲᩥ ᩌᩈᨶᩪᨴᨠᩴ, ᨠᩩᨲᩮᩣ ᩈᩩᨵᩣ ᨣᨧ᩠ᨨ ᨶ ᨾᨿ᩠ᩉ ᩁᩩᨧ᩠ᨧᩈᩥ’’.

᪒᪔᪙.

‘‘ᨴᨴ᩠ᨴᩃ᩠ᩃᨾᩣᨶᩣ ᨿᩈᩈᩣ ᨿᩈᩔᩥᨶᩦ, ᨩᩥᨥᨬ᩠ᨬᨶᩣᨾᩅ᩠ᩉᨿᨶᩴ ᨴᩥᩈᩴ ᨸᨲᩥ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨠᨬ᩠ᨧᨶᩅᩮᩃ᩠ᩃᩥᩅᩥᨣ᩠ᨣᩉᩮ, ᩌᨧᩥᨠ᩠ᨡ ᨾᩮ ᨲ᩠ᩅᩴ ᨠᨲᨾᩣᩈᩥ ᨴᩮᩅᨲᩣ’’.

᪒᪕᪐.

‘‘ᩈᨴ᩠ᨵᩣᩉ ᨴᩮᩅᩦᨾᨶᩩᨩᩮᩉᩥ [ᨴᩮᩅᩦᨾᨶᩩᨩᩮᩈᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᩪᨩᩥᨲᩣ, ᩋᨸᩣᨸᩈᨲ᩠ᨲᩪᨸᨶᩥᩈᩮᩅᩥᨶᩦ ᩈᨴᩣ;

ᩈᩩᨵᩣᩅᩥᩅᩣᨴᩮᨶ ᨲᩅᨶ᩠ᨲᩥᨾᩣᨣᨲᩣ, ᨲᩴ ᨾᩴ ᩈᩩᨵᩣᨿ ᩅᩁᨸᨬ᩠ᨬ ᨽᩣᨩᨿ’’.

᪒᪕᪑.

‘‘ᨴᩣᨶᩴ ᨴᨾᩴ ᨧᩣᨣᨾᨳᩮᩣᨸᩥ ᩈᩴᨿᨾᩴ, ᩌᨴᩣᨿ ᩈᨴ᩠ᨵᩣᨿ ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᩉᩮᨠᨴᩣ;

ᨳᩮᨿ᩠ᨿᩴ ᨾᩩᩈᩣ ᨠᩪᨭᨾᨳᩮᩣᨸᩥ ᨸᩮᩈᩩᨱᩴ, ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᩉᩮᨠᩮ ᨸᩩᨶ ᩅᩥᨧ᩠ᨧᩩᨲᩣ ᨲᨿᩣ.

᪒᪕᪒.

‘‘ᨽᩁᩥᨿᩣᩈᩩ ᨸᩮᩣᩈᩮᩣ ᩈᨴᩥᩈᩦᩈᩩ ᨸᩮᨠ᩠ᨡᩅᩣ [ᨸᩮᨡᩅᩣ (ᨸᩦ.)], ᩈᩦᩃᩪᨸᨸᨶ᩠ᨶᩣᩈᩩ ᨸᨲᩥᨻ᩠ᨻᨲᩣᩈᩩᨸᩥ;

ᩅᩥᨶᩮᨲ᩠ᩅᩣᨶ ¶ [ᩅᩥᨶᩮᨲ᩠ᩅᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨨᨶ᩠ᨴᩴ ᨠᩩᩃᩥᨲ᩠ᨳᩥᨿᩣᩈᩩᨸᩥ [ᨠᩩᩃᨵᩦᨲᩥᨿᩣᩈᩩᨸᩥ (ᩈᩦ. ᨸᩦ.)], ᨠᩁᩮᩣᨲᩥ ᩈᨴ᩠ᨵᩴ ᨸᩩᨶ [ᨸᨶ (ᩈᩦ. ᨸᩦ.)] ᨠᩩᨾ᩠ᨽᨴᩣᩈᩥᨿᩣ.

᪒᪕᪓.

‘‘ᨲ᩠ᩅᨾᩮᩅ ᩈᨴ᩠ᨵᩮ ᨸᩁᨴᩣᩁᩈᩮᩅᩥᨶᩦ, ᨸᩣᨸᩴ ᨠᩁᩮᩣᩈᩥ ᨠᩩᩈᩃᨾ᩠ᨸᩥ ᩁᩥᨬ᩠ᨧᩈᩥ;

ᨶ ᨲᩣᨴᩥᩈᩦ ᩋᩁᩉᨲᩥ ᩌᩈᨶᩪᨴᨠᩴ, ᨠᩩᨲᩮᩣ ᩈᩩᨵᩣ ᨣᨧ᩠ᨨ ᨶ ᨾᨿ᩠ᩉ ᩁᩩᨧ᩠ᨧᩈᩥ’’.

᪒᪕᪔.

‘‘ᨩᩥᨥᨬ᩠ᨬᩁᨲ᩠ᨲᩥᩴ ¶ ᩋᩁᩩᨱᩈ᩠ᨾᩥᨾᩪᩉᨲᩮ, ᨿᩣ ᨴᩥᩔᨲᩥ ᩏᨲ᩠ᨲᨾᩁᩪᨸᩅᨱ᩠ᨱᩥᨶᩦ;

ᨲᨳᩪᨸᨾᩣ ᨾᩴ ᨸᨭᩥᨽᩣᩈᩥ ᨴᩮᩅᨲᩮ, ᩌᨧᩥᨠ᩠ᨡ ᨾᩮ ᨲ᩠ᩅᩴ ᨠᨲᨾᩣᩈᩥ ᩋᨧ᩠ᨨᩁᩣ.

᪒᪕᪕.

‘‘ᨠᩣᩃᩣ ¶ ᨶᩥᨴᩣᨥᩮᩁᩥᩅ ᩋᨣ᩠ᨣᩥᨩᩣᩁᩥᩅ [ᩋᨣ᩠ᨣᨩᩣᨲᩥᩅ (ᩈᩦ.), ᩋᨣ᩠ᨣᩥᨩᩣᨲᩥᩅ (ᨸᩦ.)], ᩋᨶᩥᩃᩮᩁᩥᨲᩣ ᩃᩮᩣᩉᩥᨲᨸᨲ᩠ᨲᨾᩣᩃᩥᨶᩦ;

ᨠᩣ ᨲᩥᨭ᩠ᨮᩈᩥ ᨾᨶ᩠ᨴᨾᩥᨣᩣᩅᩃᩮᩣᨠᨿᩴ [ᨾᨶ᩠ᨴᨾᩥᩅᩣᩅᩃᩮᩣᨠᨿᩴ (ᩈᩦ. ᨸᩦ.)], ᨽᩣᩈᩮᩈᨾᩣᨶᩣᩅ ᨣᩥᩁᩴ ᨶ ᨾᩩᨬ᩠ᨧᩈᩥ’’.

᪒᪕᪖.

‘‘ᩉᩥᩁᩣᩉ ᨴᩮᩅᩦᨾᨶᩩᨩᩮᩉᩥ ᨸᩪᨩᩥᨲᩣ, ᩋᨸᩣᨸᩈᨲ᩠ᨲᩪᨸᨶᩥᩈᩮᩅᩥᨶᩦ ᩈᨴᩣ;

ᩈᩩᨵᩣᩅᩥᩅᩣᨴᩮᨶ ᨲᩅᨶ᩠ᨲᩥᨾᩣᨣᨲᩣ, ᩈᩣᩉᩴ ᨶ ᩈᨠ᩠ᨠᩮᩣᨾᩥ ᩈᩩᨵᨾ᩠ᨸᩥ ᨿᩣᨧᩥᨲᩩᩴ;

ᨠᩮᩣᨸᩦᨶᩁᩪᨸᩣ ᩅᩥᨿ ᨿᩣᨧᨶᩥᨲ᩠ᨳᩥᨿᩣ’’.

᪒᪕᪗.

‘‘ᨵᨾ᩠ᨾᩮᨶ ᨬᩣᨿᩮᨶ ᩈᩩᨣᨲ᩠ᨲᩮ ᩃᨧ᩠ᨨᩈᩥ, ᩑᩈᩮᩣ ¶ ᩉᩥ ᨵᨾ᩠ᨾᩮᩣ ᨶ ᩉᩥ ᨿᩣᨧᨶᩣ ᩈᩩᨵᩣ;

ᨲᩴ ᨲᩴ ᩋᨿᩣᨧᨶ᩠ᨲᩥᨾᩉᩴ ᨶᩥᨾᨶ᩠ᨲᨿᩮ, ᩈᩩᨵᩣᨿ ᨿᨬ᩠ᨧᩥᨧ᩠ᨨᩈᩥ ᨲᨾ᩠ᨸᩥ ᨴᨾ᩠ᨾᩥ ᨲᩮ.

᪒᪕᪘.

‘‘ᩈᩣ ᨲ᩠ᩅᩴ ᨾᨿᩣ ᩋᨩ᩠ᨩ ᩈᨠᨾ᩠ᩉᩥ ᩋᩔᨾᩮ, ᨶᩥᨾᨶ᩠ᨲᩥᨲᩣ ᨠᨬ᩠ᨧᨶᩅᩮᩃ᩠ᩃᩥᩅᩥᨣ᩠ᨣᩉᩮ;

ᨲᩩᩅᨬ᩠ᩉᩥ ᨾᩮ ᩈᨻ᩠ᨻᩁᩈᩮᩉᩥ ᨸᩪᨩᩥᨿᩣ, ᨲᩴ ᨸᩪᨩᨿᩥᨲ᩠ᩅᩣᨶ ᩈᩩᨵᨾ᩠ᨸᩥ ᩋᩈ᩠ᨶᩥᨿᩮ’’.

᪒᪕᪙.

‘‘ᩈᩣ ᨠᩮᩣᩈᩥᨿᩮᨶᩣᨶᩩᨾᨲᩣ ᨩᩩᨲᩦᨾᨲᩣ, ᩋᨴ᩠ᨵᩣ ᩉᩥᩁᩥ ᩁᨾ᩠ᨾᩴ ᨸᩣᩅᩥᩈᩥ ᨿᩔᨾᩴ;

ᩏᨴᨠᩅᨶ᩠ᨲᩴ [ᩏᨴᨬ᩠ᨬᩅᨶ᩠ᨲᩴ (ᩈᩦ. ᨸᩦ.)] ᨹᩃᨾᩁᩥᨿᨸᩪᨩᩥᨲᩴ, ᩋᨸᩣᨸᩈᨲ᩠ᨲᩪᨸᨶᩥᩈᩮᩅᩥᨲᩴ ᩈᨴᩣ.

᪒᪖᪐.

‘‘ᩁᩩᨠ᩠ᨡᨣ᩠ᨣᩉᩣᨶᩣ ᨻᩉᩩᨠᩮᨲ᩠ᨳ ᨸᩩᨸ᩠ᨹᩥᨲᩣ, ᩋᨾ᩠ᨻᩣ ᨸᩥᨿᩣᩃᩣ ᨸᨶᩈᩣ ᨧ ᨠᩥᩴᩈᩩᨠᩣ;

ᩈᩮᩣᨽᨬ᩠ᨩᨶᩣ ᩃᩮᩣᨴ᩠ᨴᨾᨳᩮᩣᨸᩥ ᨸᨴ᩠ᨾᨠᩣ, ᨠᩮᨠᩣ ᨧ ᨽᨦ᩠ᨣᩣ ᨲᩥᩃᨠᩣ ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩣ.

᪒᪖᪑.

‘‘ᩈᩣᩃᩣ ¶ ᨠᩁᩮᩁᩦ ᨻᩉᩩᨠᩮᨲ᩠ᨳ ᨩᨾ᩠ᨻᩩᨿᩮᩣ, ᩋᩔᨲ᩠ᨳᨶᩥᨣᩕᩮᩣᨵᨾᨵᩩᨠᩅᩮᨲᩈᩣ [ᩅᩮᨴᩥᩈᩣ (ᨠ.)];

ᩏᨴ᩠ᨴᩣᩃᨠᩣ ᨸᩣᨭᩃᩥ ᩈᩥᨶ᩠ᨴᩩᩅᩣᩁᨠᩣ [ᩈᩥᨶ᩠ᨴᩩᩅᩣᩁᩥᨲᩣ (ᨻᩉᩪᩈᩩ)], ᨾᨶᩩᨬ᩠ᨬᨣᨶ᩠ᨵᩣ ᨾᩩᨧᩃᩥᨶ᩠ᨴᨠᩮᨲᨠᩣ.

᪒᪖᪒.

‘‘ᩉᩁᩮᨱᩩᨠᩣ ᩅᩮᩊᩩᨠᩣ ᨠᩮᨱᩩ [ᩅᩮᨱᩩ (ᩈᩦ. ᨸᩦ.)] ᨲᩥᨶ᩠ᨴᩩᨠᩣ, ᩈᩣᨾᩣᨠᨶᩦᩅᩣᩁᨾᨳᩮᩣᨸᩥ ¶ ᨧᩦᨶᨠᩣ;

ᨾᩮᩣᨧᩣ ᨠᨴᩃᩦ ᨻᩉᩩᨠᩮᨲ᩠ᨳ ᩈᩣᩃᩥᨿᩮᩣ, ᨸᩅᩦᩉᨿᩮᩣ ᩌᨽᩪᨩᩥᨶᩮᩣ ᨧ [ᩌᨽᩩᨩᩥᨶᩮᩣᨸᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨲᨱ᩠ᨯᩩᩃᩣ.

᪒᪖᪓.

‘‘ᨲᩔᩮᩅᩩᨲ᩠ᨲᩁᨸᩔᩮᨶ [ᨲᩔ ᨧ ᩏᨲ᩠ᨲᩁᩮ ᨸᩔᩮ (ᩈᩦ. ᨸᩦ.), ᨲᩔ ᨧ ᩏᨲ᩠ᨲᩁᨸᩔᩮᨶ (ᩈ᩠ᨿᩣ.)], ᨩᩣᨲᩣ ᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ ᩈᩥᩅᩣ;

ᩋᨠᨠ᩠ᨠᩈᩣ ᩋᨸᨻ᩠ᨽᩣᩁᩣ, ᩈᩣᨵᩩ ᩋᨸ᩠ᨸᨭᩥᨣᨶ᩠ᨵᩥᨠᩣ.

᪒᪖᪔.

‘‘ᨲᨲ᩠ᨳ ᨾᨧ᩠ᨨᩣ ᩈᨶ᩠ᨶᩥᩁᨲᩣ, ᨡᩮᨾᩥᨶᩮᩣ ᨻᩉᩩᨽᩮᩣᨩᨶᩣ;

ᩈᩥᨦ᩠ᨣᩪ ᩈᩅᨦ᩠ᨠᩣ ᩈᩴᨠᩩᩃᩣ [ᩈᨠᩩᩃᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩈᨲᩅᨦ᩠ᨠᩣ ᨧ ᩁᩮᩣᩉᩥᨲᩣ;

ᩌᩊᩥᨣᨣ᩠ᨣᩁᨠᩣᨠᩥᨱ᩠ᨱᩣ, ᨸᩣᨮᩦᨶᩣ ᨠᩣᨠᨾᨧ᩠ᨨᨠᩣ.

᪒᪖᪕.

‘‘ᨲᨲ᩠ᨳ ᨸᨠ᩠ᨡᩦ ᩈᨶ᩠ᨶᩥᩁᨲᩣ, ᨡᩮᨾᩥᨶᩮᩣ ᨻᩉᩩᨽᩮᩣᨩᨶᩣ;

ᩉᩴᩈᩣ ᨠᩮᩣᨬ᩠ᨧᩣ ᨾᨿᩪᩁᩣ ᨧ, ᨧᨠ᩠ᨠᩅᩣᨠᩣ ᨧ ᨠᩩᨠ᩠ᨠᩩᩉᩣ;

ᨠᩩᨱᩣᩃᨠᩣ ᨻᩉᩪ ᨧᩥᨲᩕᩣ, ᩈᩥᨡᨱ᩠ᨯᩦ ᨩᩦᩅᨩᩦᩅᨠᩣ.

᪒᪖᪖.

‘‘ᨲᨲ᩠ᨳ ᨸᩣᨶᩣᨿ ᨾᩣᨿᨶ᩠ᨲᩥ, ᨶᩣᨶᩣ ᨾᩥᨣᨣᨱᩣ ᨻᩉᩪ;

ᩈᩦᩉᩣ ᨻ᩠ᨿᨣ᩠ᨥᩣ ᩅᩁᩣᩉᩣ ᨧ, ᩋᨧ᩠ᨨᨠᩮᩣᨠᨲᩁᨧ᩠ᨨᨿᩮᩣ.

᪒᪖᪗.

‘‘ᨸᩃᩣᩈᩣᨴᩣ ¶ ᨣᩅᨩᩣ ᨧ, ᨾᩉᩥᩴᩈᩣ [ᨾᩉᩥᩈᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩁᩮᩣᩉᩥᨲᩣ ᩁᩩᩁᩪ;

ᩑᨱᩮᨿ᩠ᨿᩣ ᨧ ᩅᩁᩣᩉᩣ ᨧ, ᨣᨱᩥᨶᩮᩣ ᨶᩦᨠᩈᩪᨠᩁᩣ;

ᨠᨴᩃᩥᨾᩥᨣᩣ ᨻᩉᩩᨠᩮᨲ᩠ᨳ, ᨻᩥᩊᩣᩁᩣ ᩈᩈᨠᨱ᩠ᨱᩥᨠᩣ [ᩈᩈᨠᨱ᩠ᨱᨠᩣ (ᩈᩦ.)].

᪒᪖᪘.

‘‘ᨨᨾᩣᨣᩥᩁᩦ ᨸᩩᨸ᩠ᨹᩅᩥᨧᩥᨲᩕᩈᨶ᩠ᨳᨲᩣ, ᨴᩥᨩᩣᨽᩥᨥᩩᨭ᩠ᨮᩣ ᨴᩥᨩᩈᨦ᩠ᨥᩈᩮᩅᩥᨲᩣ’’.

᪒᪖᪙.

‘‘ᩈᩣ ¶ ᩈᩩᨲ᩠ᨲᨧᩣ ᨶᩦᩃᨴᩩᨾᩣᨽᩥᩃᨾ᩠ᨻᩥᨲᩣ, ᩅᩥᨩ᩠ᨩᩩ ᨾᩉᩣᨾᩮᨥᩁᩥᩅᩣᨶᩩᨸᨩ᩠ᨩᨳ;

ᨲᩔᩣ ¶ ᩈᩩᩈᨾ᩠ᨻᨶ᩠ᨵᩈᩥᩁᩴ ᨠᩩᩈᩣᨾᨿᩴ, ᩈᩩᨧᩥᩴ ᩈᩩᨣᨶ᩠ᨵᩴ ᩋᨩᩥᨶᩪᨸᩈᩮᩅᩥᨲᩴ;

ᩋᨲᩕᩥᨧ᩠ᨧ [ᩋᨲᩕᩥᨧ᩠ᨨ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨠᩮᩣᨧ᩠ᨨᩴ ᩉᩥᩁᩥᨾᩮᨲᨴᨻᩕᩅᩥ, ‘ᨶᩥᩈᩦᨴ ᨠᩃ᩠ᨿᩣᨱᩥ ᩈᩩᨡᨿᩥᨴᨾᩣᩈᨶᩴ’.

᪒᪗᪐.

‘‘ᨲᩔᩣ ᨲᨴᩣ ᨠᩮᩣᨧ᩠ᨨᨣᨲᩣᨿ ᨠᩮᩣᩈᩥᨿᩮᩣ, ᨿᨴᩥᨧ᩠ᨨᨾᩣᨶᩣᨿ ᨩᨭᩣᨩᩥᨶᨶ᩠ᨵᩁᩮᩣ [ᨩᨭᩣᨩᩩᨲᩥᨶ᩠ᨵᩁᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᨶᩅᩮᩉᩥ ᨸᨲ᩠ᨲᩮᩉᩥ ᩈᨿᩴ ᩈᩉᩪᨴᨠᩴ, ᩈᩩᨵᩣᨽᩥᩉᩣᩈᩦ ᨲᩩᩁᩥᨲᩮᩣ ᨾᩉᩣᨾᩩᨶᩥ.

᪒᪗᪑.

‘‘ᩈᩣ ᨲᩴ ᨸᨭᩥᨣ᩠ᨣᨿ᩠ᩉ ᩏᨽᩮᩣᩉᩥ ᨸᩣᨱᩥᨽᩥ, ᩍᨧ᩠ᨧᨻᩕᩅᩥ ᩋᨲ᩠ᨲᨾᨶᩣ ᨩᨭᩣᨵᩁᩴ;

‘ᩉᨶ᩠ᨴᩣᩉᩴ ᩑᨲᩁᩉᩥ ᨸᩪᨩᩥᨲᩣ ᨲᨿᩣ, ᨣᨧ᩠ᨨᩮᨿ᩠ᨿᩴ ᨻᩕᩉ᩠ᨾᩮ ᨲᩥᨴᩥᩅᩴ ᨩᩥᨲᩣᩅᩥᨶᩦ’.

᪒᪗᪒.

‘‘ᩈᩣ ᨠᩮᩣᩈᩥᨿᩮᨶᩣᨶᩩᨾᨲᩣ ᨩᩩᨲᩦᨾᨲᩣ, ᩏᨴᩦᩁᩥᨲᩣ [ᩏᨴᩥᩁᨿᩥ (ᨠ.)] ᩅᨱ᩠ᨱᨾᨴᩮᨶ ᨾᨲ᩠ᨲᩣ;

ᩈᨠᩣᩈᩮ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᩈᩉᩔᨧᨠ᩠ᨡᩩᨶᩮᩣ, ᩋᨿᩴ ᩈᩩᨵᩣ ᩅᩣᩈᩅ ᨴᩮᩉᩥ ᨾᩮ ᨩᨿᩴ.

᪒᪗᪓.

‘‘ᨲᨾᩮᨶ [ᨲᨾᩮᨶᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩈᨠ᩠ᨠᩮᩣᨸᩥ ᨲᨴᩣ ᩋᨸᩪᨩᨿᩥ, ᩈᩉᩥᨶ᩠ᨴᨴᩮᩅᩣ [ᩈᩉᩥᨶ᩠ᨴᩣ ᨧ ᨴᩮᩅᩣ (ᩈᩦ. ᨸᩦ.)] ᩈᩩᩁᨠᨬ᩠ᨬᨾᩩᨲ᩠ᨲᨾᩴ;

ᩈᩣ ᨸᨬ᩠ᨩᩃᩦ ᨴᩮᩅᨾᨶᩩᩔᨸᩪᨩᩥᨲᩣ, ᨶᩅᨾ᩠ᩉᩥ ᨠᩮᩣᨧ᩠ᨨᨾ᩠ᩉᩥ ᨿᨴᩣ ᩏᨸᩣᩅᩥᩈᩥ’’.

᪒᪗᪔.

‘‘ᨲᨾᩮᩅ ¶ ᩈᩴᩈᩦ [ᨲᨾᩮᩅ ᩋᩈᩴᩈᩦ (ᩈ᩠ᨿᩣ.)] ᨸᩩᨶᨴᩮᩅ ᨾᩣᨲᩃᩥᩴ, ᩈᩉᩔᨶᩮᨲ᩠ᨲᩮᩣ ᨲᩥᨴᩈᩣᨶᨾᩥᨶ᩠ᨴᩮᩣ;

ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᩅᩣᨠ᩠ᨿᩴ ᨾᨾ ᨻᩕᩪᩉᩥ ᨠᩮᩣᩈᩥᨿᩴ, ᩌᩈᩣᨿ ᩈᨴ᩠ᨵᩣ [ᩈᨴ᩠ᨵ (ᨸᩦ.)] ᩈᩥᩁᩥᨿᩣ ᨧ ᨠᩮᩣᩈᩥᨿ;

ᩉᩥᩁᩦ ᩈᩩᨵᩴ ᨠᩮᨶ ᨾᩃᨲ᩠ᨳ ᩉᩮᨲᩩᨶᩣ.

᪒᪗᪕.

‘‘ᨲᩴ ¶ ᩈᩩ ᩅᨲ᩠ᨳᩴ ᩏᨴᨲᩣᩁᨿᩦ ᩁᨳᩴ, ᨴᨴ᩠ᨴᩃ᩠ᩃᨾᩣᨶᩴ ᩏᨸᨠᩣᩁᩥᨿᩈᩣᨴᩥᩈᩴ [ᩏᨸᨠᩥᩁᩥᨿᩈᩣᨴᩥᩈᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)].

ᨩᨾ᩠ᨻᩮᩣᨶᨴᩦᩈᩴ ᨲᨸᨶᩮᨿ᩠ᨿᩈᨶ᩠ᨶᩥᨽᩴ [ᩈᨶ᩠ᨲᩥᨠᩴ (ᩈᩦ.ᨸᩦ.)], ᩋᩃᨦ᩠ᨠᨲᩴ ᨠᨬ᩠ᨧᨶᨧᩥᨲ᩠ᨲᩈᨶ᩠ᨶᩥᨽᩴ.

᪒᪗᪖.

‘‘ᩈᩩᩅᨱ᩠ᨱᨧᨶ᩠ᨴᩮᨲ᩠ᨳ ᨻᩉᩪ ᨶᩥᨸᩣᨲᩥᨲᩣ, ᩉᨲ᩠ᨳᩦ ᨣᩅᩔᩣ ᨠᩥᨠᩥᨻ᩠ᨿᨣ᩠ᨥᨴᩦᨸᩥᨿᩮᩣ [ᨠᩥᨾ᩠ᨸᩩᩁᩥᩈᨻ᩠ᨿᨣ᩠ᨥᨴᩦᨸᩥᨿᩮᩣ (ᨠ.)];

ᩑᨱᩮᨿ᩠ᨿᨠᩣ ᩃᨦ᩠ᨥᨾᨿᩮᨲ᩠ᨳ ᨸᨠ᩠ᨡᩥᨶᩮᩣ [ᨸᨠ᩠ᨡᩥᨿᩮᩣ (ᩈᩦ. ᨸᩦ.)], ᨾᩥᨣᩮᨲ᩠ᨳ ᩅᩮᩊᩩᩁᩥᨿᨾᨿᩣ ᨿᩩᨵᩣ ᨿᩩᨲᩣ.

᪒᪗᪗.

‘‘ᨲᨲ᩠ᨳᩔᩁᩣᨩᩉᩁᨿᩮᩣ ᩋᨿᩮᩣᨩᨿᩩᩴ, ᨴᩈᩈᨲᩣᨶᩥ ᩈᩩᩈᩩᨶᩣᨣᩈᩣᨴᩥᩈᩮ;

ᩋᩃᨦ᩠ᨠᨲᩮ ᨠᨬ᩠ᨧᨶᨩᩣᩃᩩᩁᨧ᩠ᨨᨴᩮ, ᩌᩅᩮᩊᩥᨶᩮ ᩈᨴ᩠ᨴᨣᨾᩮ ᩋᩈᨦ᩠ᨣᩥᨲᩮ.

᪒᪗᪘.

‘‘ᨲᩴ ᨿᩣᨶᩈᩮᨭ᩠ᨮᩴ ᩋᨽᩥᩁᩩᨿ᩠ᩉ ᨾᩣᨲᩃᩥ, ᨴᩥᩈᩣ ᩍᨾᩣᨿᩮᩣ [ᨴᩈ ᨴᩥᩈᩣ ᩍᨾᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩋᨽᩥᨶᩣᨴᨿᩥᨲ᩠ᨳ;

ᨶᨽᨬ᩠ᨧ ᩈᩮᩃᨬ᩠ᨧ ᩅᨶᨸ᩠ᨸᨲᩥᨶᩥᨬ᩠ᨧ [ᩅᨶᩈ᩠ᨸᨲᩦᨶᩥ ᨧ (ᩈᩦ. ᨸᩦ.), ᩅᨶᨸ᩠ᨸᨲᩥᨬ᩠ᨧ (ᩈ᩠ᨿᩣ. ᨠ.)], ᩈᩈᩣᨣᩁᩴ ¶ ᨸᨻ᩠ᨿᨵᨿᩥᨲ᩠ᨳ [ᨸᨻ᩠ᨿᩣᨳᨿᩥᨲ᩠ᨳ (ᩈᩦ. ᨸᩦ.)] ᨾᩮᨴᩥᨶᩥᩴ.

᪒᪗᪙.

‘‘ᩈ ᨡᩥᨸ᩠ᨸᨾᩮᩅ ᩏᨸᨣᨾ᩠ᨾ ᩋᩔᨾᩴ, ᨸᩣᩅᩣᩁᨾᩮᨠᩴᩈᨠᨲᩮᩣ ᨠᨲᨬ᩠ᨩᩃᩦ;

ᨻᩉᩩᩔᩩᨲᩴ ᩅᩩᨴ᩠ᨵᩴ ᩅᩥᨶᩦᨲᩅᨶ᩠ᨲᩴ, ᩍᨧ᩠ᨧᨻᩕᩅᩦ ᨾᩣᨲᩃᩥ ᨴᩮᩅᨻᩕᩣᩉ᩠ᨾᨱᩴ.

᪒᪘᪐.

‘‘ᩍᨶ᩠ᨴᩔ ᩅᩣᨠ᩠ᨿᩴ ᨶᩥᩈᩣᨾᩮᩉᩥ ᨠᩮᩣᩈᩥᨿ, ᨴᩪᨲᩮᩣ ᩋᩉᩴ ᨸᩩᨧ᩠ᨨᨲᩥ ᨲᩴ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ;

ᩌᩈᩣᨿ ᩈᨴ᩠ᨵᩣ ᩈᩥᩁᩥᨿᩣ ᨧ ᨠᩮᩣᩈᩥᨿ, ᩉᩥᩁᩦ ᩈᩩᨵᩴ ᨠᩮᨶ ᨾᩃᨲ᩠ᨳ ᩉᩮᨲᩩᨶᩣ’’.

᪒᪘᪑.

‘‘ᩋᨶ᩠ᨵᩣ ¶ ¶ ᩈᩥᩁᩦ ᨾᩴ ᨸᨭᩥᨽᩣᨲᩥ ᨾᩣᨲᩃᩥ, ᩈᨴ᩠ᨵᩣ ᩋᨶᩥᨧ᩠ᨧᩣ ᨸᨶ ᨴᩮᩅᩈᩣᩁᨳᩥ;

ᩌᩈᩣ ᩅᩥᩈᩴᩅᩣᨴᩥᨠᩈᨾ᩠ᨾᨲᩣ ᩉᩥ ᨾᩮ, ᩉᩥᩁᩦ ᨧ ᩋᩁᩥᨿᨾ᩠ᩉᩥ ᨣᩩᨱᩮ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩣ’’.

᪒᪘᪒.

‘‘ᨠᩩᨾᩣᩁᩥᨿᩮᩣ ᨿᩣᨧᩥᨾᩣ ᨣᩮᩣᨲ᩠ᨲᩁᨠ᩠ᨡᩥᨲᩣ, ᨩᩥᨱ᩠ᨱᩣ ᨧ ᨿᩣ ᨿᩣ ᨧ ᩈᨽᨲ᩠ᨲᩩᩍᨲ᩠ᨳᩥᨿᩮᩣ;

ᨲᩣ ᨨᨶ᩠ᨴᩁᩣᨣᩴ ᨸᩩᩁᩥᩈᩮᩈᩩ ᩏᨣ᩠ᨣᨲᩴ, ᩉᩥᩁᩥᨿᩣ ᨶᩥᩅᩣᩁᩮᨶ᩠ᨲᩥ ᩈᨧᩥᨲ᩠ᨲᨾᨲ᩠ᨲᨶᩮᩣ.

᪒᪘᪓.

‘‘ᩈᨦ᩠ᨣᩣᨾᩈᩦᩈᩮ ᩈᩁᩈᨲ᩠ᨲᩥᩈᩴᨿᩩᨲᩮ, ᨸᩁᩣᨩᩥᨲᩣᨶᩴ ᨸᨲᨲᩴ ᨸᩃᩣᨿᩥᨶᩴ;

ᩉᩥᩁᩥᨿᩣ ᨶᩥᩅᨲ᩠ᨲᨶ᩠ᨲᩥ ᨩᩉᩥᨲ᩠ᩅ [ᨩᩉᩥᨲ᩠ᩅᩣᨶ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨩᩦᩅᩥᨲᩴ, ᨲᩮ ¶ ᩈᨾ᩠ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨲᩥ ᨸᩩᨶᩣ ᩉᩥᩁᩦᨾᨶᩣ.

᪒᪘᪔.

‘‘ᩅᩮᩃᩣ ᨿᨳᩣ ᩈᩣᨣᩁᩅᩮᨣᩅᩣᩁᩥᨶᩦ, ᩉᩥᩁᩣᨿ ᩉᩥ ᨸᩣᨸᨩᨶᩴ ᨶᩥᩅᩣᩁᩥᨶᩦ;

ᨲᩴ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩮ ᩉᩥᩁᩥᨾᩁᩥᨿᨸᩪᨩᩥᨲᩴ, ᩍᨶ᩠ᨴᩔ ᨲᩴ ᩅᩮᨴᨿ ᨴᩮᩅᩈᩣᩁᨳᩥ’’.

᪒᪘᪕.

‘‘ᨠᩮᩣ ᨲᩮ ᩍᨾᩴ ᨠᩮᩣᩈᩥᨿ ᨴᩥᨭ᩠ᨮᩥᨾᩮᩣᨴᩉᩥ, ᨻᩕᩉ᩠ᨾᩣ ᨾᩉᩥᨶ᩠ᨴᩮᩣ ᩋᨳ ᩅᩣ ᨸᨩᩣᨸᨲᩥ;

ᩉᩥᩁᩣᨿ ᨴᩮᩅᩮᩈᩩ ᩉᩥ ᩈᩮᨭ᩠ᨮᩈᨾ᩠ᨾᨲᩣ, ᨵᩦᨲᩣ ᨾᩉᩥᨶ᩠ᨴᩔ ᨾᩉᩮᩈᩥ ᨩᩣᨿᨳ’’.

᪒᪘᪖.

‘‘ᩉᨶ᩠ᨴᩮᩉᩥ ᨴᩣᨶᩥ ᨲᩥᨴᩥᩅᩴ ᩋᨸᨠ᩠ᨠᨾ [ᩈᨾᨠ᩠ᨠᨾ (ᩈᩦ. ᨸᩦ.)], ᩁᨳᩴ ᩈᨾᩣᩁᩩᨿ᩠ᩉ ᨾᨾᩣᨿᩥᨲᩴ ᩍᨾᩴ [ᩍᨴᩴ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᩍᨶ᩠ᨴᩮᩣ ᨧ ᨲᩴ ᩍᨶ᩠ᨴᩈᨣᩮᩣᨲ᩠ᨲ ᨠᨦ᩠ᨡᨲᩥ, ᩋᨩ᩠ᨩᩮᩅ ᨲ᩠ᩅᩴ ᩍᨶ᩠ᨴᩈᩉᨻ᩠ᨿᨲᩴ ᩅᨩ’’.

᪒᪘᪗.

‘‘ᩑᩅᩴ ᩅᩥᩈᩩᨩ᩠ᨫᨶ᩠ᨲᩥ [ᩈᨾᩥᨩ᩠ᨫᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᩋᨸᩣᨸᨠᨾ᩠ᨾᩥᨶᩮᩣ, ᩋᨳᩮᩣ ᩈᩩᨧᩥᨱ᩠ᨱᩔ ᨹᩃᩴ ᨶ ᨶᩔᨲᩥ;

ᨿᩮ ᨠᩮᨧᩥ ᨾᨴ᩠ᨴᨠ᩠ᨡᩩ ᩈᩩᨵᩣᨿ ᨽᩮᩣᨩᨶᩴ, ᩈᨻ᩠ᨻᩮᩅ ᨲᩮ ᩍᨶ᩠ᨴᩈᩉᨻ᩠ᨿᨲᩴ ᨣᨲᩣ’’.

᪒᪘᪘.

‘‘ᩉᩥᩁᩦ ¶ ᩏᨸ᩠ᨸᩃᩅᨱ᩠ᨱᩣᩈᩥ, ᨠᩮᩣᩈᩥᨿᩮᩣ ᨴᩣᨶᨸᨲᩥ ᨽᩥᨠ᩠ᨡᩩ;

ᩋᨶᩩᩁᩩᨴ᩠ᨵᩮᩣ ᨸᨬ᩠ᨧᩈᩥᨡᩮᩣ, ᩌᨶᨶ᩠ᨴᩮᩣ ᩌᩈᩥ ᨾᩣᨲᩃᩥ.

᪒᪘᪙.

‘‘ᩈᩪᩁᩥᨿᩮᩣ ᨠᩔᨸᩮᩣ ᨽᩥᨠ᩠ᨡᩩ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᩣᩈᩥ ᨧᨶ᩠ᨴᩥᨾᩣ;

ᨶᩣᩁᨴᩮᩣ ¶ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᩣᩈᩥ, ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ ᩌᩈᩥ ᩅᩣᩈᩅᩮᩣ’’ᨲᩥ.

ᩈᩩᨵᩣᨽᩮᩣᨩᨶᨩᩣᨲᨠᩴ ᨲᨲᩥᨿᩴ.

᪕᪓᪖. ᨠᩩᨱᩣᩃᨩᩣᨲᨠᩴ (᪔)

ᩑᩅᨾᨠ᩠ᨡᩣᨿᨲᩥ, ᩑᩅᨾᨶᩩᩈᩪᨿᨲᩥ [ᩈᩩᨿ᩠ᨿᨲᩥ (ᨠ.)]. ᩈᨻ᩠ᨻᩮᩣᩈᨵᨵᩁᨱᩥᨵᩁᩮ ᨶᩮᨠᨸᩩᨸ᩠ᨹᨾᩣᩃ᩠ᨿᩅᩥᨲᨲᩮ ᨣᨩ-ᨣᩅᨩ ᨾᩉᩥᩴᩈ-ᩁᩩᩁᩩ-ᨧᨾᩁ-ᨸᩈᨴ-ᨡᨣ᩠ᨣ-ᨣᩮᩣᨠᨱ᩠ᨱ-ᩈᩦᩉ-ᨻ᩠ᨿᨣ᩠ᨥ-ᨴᩦᨸᩥ-ᩋᨧ᩠ᨨ-ᨠᩮᩣᨠ-ᨲᩁᨧ᩠ᨨ-ᩏᨴ᩠ᨴᩣᩁ-ᨠᨴᩃᩥᨾᩥᨣ- ᨻᩥᩊᩣᩁ-ᩈᩈ-ᨠᨱ᩠ᨱᩥᨠᩣᨶᩩᨧᩁᩥᨲᩮᩌᨠᩥᨱ᩠ᨱᨶᩮᩃᨾᨱ᩠ᨯᩃᨾᩉᩣᩅᩁᩣᩉᨶᩣᨣᨠᩩᩃᨠᩁᩮᨱᩩ [ᨠᨱᩮᩁᩩ (ᩈᩦ. ᨸᩦ.)] -ᩈᨦ᩠ᨥᩣᨵᩥᩅᩩᨭ᩠ᨮᩮ [ᩅᩩᨲ᩠ᨳᩮ (ᩈᩦ. ᨸᩦ.)] ᩍᩔᨾᩥᨣ- ᩈᩣᨡᨾᩥᨣ-ᩈᩁᨽᨾᩥᨣ-ᩑᨱᩦᨾᩥᨣ-ᩅᩣᨲᨾᩥᨣ-ᨸᩈᨴᨾᩥᨣ-ᨸᩩᩁᩥᩈᩣᩃᩩ [ᨸᩩᩁᩥᩈᩃ᩠ᩃᩩ (ᩈᩦ. ᨸᩦ.)] -ᨠᩥᨾ᩠ᨸᩩᩁᩥᩈ-ᨿᨠ᩠ᨡ-ᩁᨠ᩠ᨡᩈᨶᩥᩈᩮᩅᩥᨲᩮ ᩋᨾᨩ᩠ᨩᩅᨾᨬ᩠ᨩᩁᩦᨵᩁ-ᨸᩉᨭ᩠ᨮ [ᨻᩕᩉᨭ᩠ᨮ (ᩈᩦ. ᨸᩦ.)] -ᨸᩩᨸ᩠ᨹᨹᩩᩈᩥᨲᨣ᩠ᨣᩣ [ᨸᩩᨸ᩠ᨹᩥᨲᨣ᩠ᨣ (ᩈᩦ. ᨸᩦ.)] ᨶᩮᨠᨸᩣᨴᨸᨣᨱᩅᩥᨲᨲᩮᨠᩩᩁᩁ-ᨧᨠᩮᩣᩁ-ᩅᩣᩁᨱ-ᨾᨿᩪᩁ-ᨸᩁᨽᨲ- ᨩᩦᩅᨬ᩠ᨩᩦᩅᨠ-ᨧᩮᩃᩣᩅᨠᩣ-ᨽᩥᨦ᩠ᨠᩣᩁ-ᨠᩁᩅᩦᨠᨾᨲ᩠ᨲᩅᩥᩉᨦ᩠ᨣᨣᨱ-ᩈᨲᨲ [ᩅᩥᩉᨦ᩠ᨣᩈᨲ (ᩈᩦ. ᨸᩦ.)] ᩈᨾ᩠ᨸᨥᩩᨭ᩠ᨮᩮᩋᨬ᩠ᨩᨶ-ᨾᨶᩮᩣᩈᩥᩃᩣ-ᩉᩁᩥᨲᩣᩃ- ᩉᩥᨦ᩠ᨣᩩᩃᨠᩉᩮᨾ-ᩁᨩᨲᨠᨶᨠᩣᨶᩮᨠᨵᩣᨲᩩᩈᨲᩅᩥᨶᨴ᩠ᨵᨸᨭᩥᨾᨱ᩠ᨯᩥᨲᨸ᩠ᨸᨴᩮᩈᩮ ¶ ᩑᩅᩁᩪᨸᩮ ᨡᩃᩩ, ᨽᩮᩣ, ᩁᨾ᩠ᨾᩮ ᩅᨶᩈᨱ᩠ᨯᩮ ᨠᩩᨱᩣᩃᩮᩣ ᨶᩣᨾ ᩈᨠᩩᨱᩮᩣ ᨸᨭᩥᩅᩈᨲᩥ ᩋᨲᩥᩅᩥᨿ ᨧᩥᨲ᩠ᨲᩮᩣ ᩋᨲᩥᩅᩥᨿ ᨧᩥᨲ᩠ᨲᨸᨲ᩠ᨲᨧ᩠ᨨᨴᨶᩮᩣ.

ᨲᩔᩮᩅ ᨡᩃᩩ, ᨽᩮᩣ, ᨠᩩᨱᩣᩃᩔ ᩈᨠᩩᨱᩔ ᩋᨯ᩠ᨰᩩᨯ᩠ᨰᩣᨶᩥ ᩍᨲ᩠ᨳᩥᩈᩉᩔᩣᨶᩥ ᨸᩁᩥᨧᩣᩁᩥᨠᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ. ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨴ᩠ᩅᩮ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨠᨭ᩠ᨮᩴ ᨾᩩᨡᩮᨶ ᨯᩴᩈᩥᨲ᩠ᩅᩣ [ᨯᩈᩥᨲ᩠ᩅᩣ (ᩈᩦ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ᨲᩴ ᨠᩩᨱᩣᩃᩴ ᩈᨠᩩᨱᩴ ᨾᨩ᩠ᨫᩮ ᨶᩥᩈᩦᨴᩣᨸᩮᨲ᩠ᩅᩣ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ [ᨯᩮᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] – ‘‘ᨾᩣ ᨶᩴ ᨠᩩᨱᩣᩃᩴ ᩈᨠᩩᨱᩴ ᩋᨴ᩠ᨵᩣᨶᨸᩁᩥᨿᩣᨿᨸᨳᩮ ᨠᩥᩃᨾᨳᩮᩣ ᩏᨻ᩠ᨻᩣᩉᩮᨲ᩠ᨳᩣ’’ᨲᩥ [ᩏᨻ᩠ᨻᩣᩉᩮᨳᩣᨲᩥ (ᩈ᩠ᨿᩣ. ᨠ.)].

ᨸᨬ᩠ᨧᩈᨲᩣ [ᨸᨬ᩠ᨧᩈᨲ (ᨸᩦ.)] ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᩉᩮᨭ᩠ᨮᨲᩮᩣ ᩉᩮᨭ᩠ᨮᨲᩮᩣ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ – [ᨯᩮᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ‘‘ᩈᨧᩣᨿᩴ ᨠᩩᨱᩣᩃᩮᩣ ¶ ᩈᨠᩩᨱᩮᩣ ᩌᩈᨶᩣ ᨸᩁᩥᨸᨲᩥᩔᨲᩥ, ᨾᨿᩴ ᨲᩴ ᨸᨠ᩠ᨡᩮᩉᩥ ᨸᨭᩥᨣ᩠ᨣᩉᩮᩔᩣᨾᩣᨲᩥ.

ᨸᨬ᩠ᨧᩈᨲᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᩏᨸᩁᩪᨸᩁᩥ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ – [ᨯᩮᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ‘‘ᨾᩣ ᨶᩴ ᨠᩩᨱᩣᩃᩴ ᩈᨠᩩᨱᩴ ᩌᨲᨸᩮᩣ ᨸᩁᩥᨲᩣᨸᩮᩈᩦ’’ᨲᩥ [ᨸᩁᩥᨠᩣᨸᩦᨲᩥ (ᩈᩦ. ᨸᩦ.)].

ᨸᨬ᩠ᨧᩈᨲᩣ ¶ ᨸᨬ᩠ᨧᩈᨲᩣ [ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ ‘‘ᨸᨬ᩠ᨧᩈᨲᩣ’’ᨲᩥ ᩈᨠᩥᨴᩮᩅ ᩌᨣᨲᩴ] ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᩏᨽᨲᩮᩣᨸᩔᩮᨶ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ – [ᨯᩮᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ‘‘ᨾᩣ ᨶᩴ ᨠᩩᨱᩣᩃᩴ ᩈᨠᩩᨱᩴ ᩈᩦᨲᩴ ᩅᩣ ᩏᨱ᩠ᩉᩴ ᩅᩣ ᨲᩥᨱᩴ ᩅᩣ ᩁᨩᩮᩣ ᩅᩣ ᩅᩣᨲᩮᩣ ᩅᩣ ᩏᩔᩣᩅᩮᩣ ᩅᩣ ᩏᨸᨸ᩠ᨹᩩᩈᩦ’’ᨲᩥ.

ᨸᨬ᩠ᨧᩈᨲᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨸᩩᩁᨲᩮᩣ ᨸᩩᩁᨲᩮᩣ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ – ‘‘ᨾᩣ ᨶᩴ ᨠᩩᨱᩣᩃᩴ ᩈᨠᩩᨱᩴ ᨣᩮᩣᨸᩣᩃᨠᩣ ᩅᩣ ᨸᩈᩩᨸᩣᩃᨠᩣ ᩅᩣ ᨲᩥᨱᩉᩣᩁᨠᩣ ᩅᩣ ᨠᨭ᩠ᨮᩉᩣᩁᨠᩣ ᩅᩣ ᩅᨶᨠᨾ᩠ᨾᩥᨠᩣ ᩅᩣ ᨠᨭ᩠ᨮᩮᨶ ᩅᩣ ᨠᨮᩃᩮᨶ ᩅᩣ [ᨠᨳᩃᩣᨿ ᩅᩣ (ᨠ.)] ᨸᩣᨱᩥᨶᩣ ᩅᩣ ( ) [(ᨸᩣᩈᩣᨱᩮᨶ ᩅᩣ) (ᩈ᩠ᨿᩣ.)] ᩃᩮᨯ᩠ᨯᩩᨶᩣ ᩅᩣ ᨴᨱ᩠ᨯᩮᨶ ᩅᩣ ᩈᨲ᩠ᨳᩮᨶ ᩅᩣ ᩈᨠ᩠ᨡᩁᩣᩉᩥ ᩅᩣ [ᩈᨠ᩠ᨡᩁᩣᨿ ᩅᩣ (ᩈᩦ.)] ᨸᩉᩣᩁᩴ ᩋᨴᩴᩈᩩ. ᨾᩣᨿᩴ ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨣᨧ᩠ᨨᩮᩉᩥ ᩅᩣ ᩃᨲᩣᩉᩥ ᩅᩣ ᩁᩩᨠ᩠ᨡᩮᩉᩥ ᩅᩣ ᩈᩣᨡᩣᩉᩥ ᩅᩣ [ᩍᨴᩴ ᨸᨴᨴ᩠ᩅᨿᩴ ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ ᨶᨲ᩠ᨳᩥ] ᨳᨾ᩠ᨽᩮᩉᩥ ᩅᩣ ᨸᩣᩈᩣᨱᩮᩉᩥ ᩅᩣ ᨻᩃᩅᨶ᩠ᨲᩮᩉᩥ ᩅᩣ ᨸᨠ᩠ᨡᩦᩉᩥ ᩈᨦ᩠ᨣᨾᩮᩈᩦ’’ᨲᩥ [ᩈᨦ᩠ᨣᩣᨾᩮᩈᩦᨲᩥ (ᩈᩦ. ᨸᩦ.)].

ᨸᨬ᩠ᨧᩈᨲᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨸᨧ᩠ᨨᨲᩮᩣ ᨸᨧ᩠ᨨᨲᩮᩣ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ ᩈᨱ᩠ᩉᩣᩉᩥ ᩈᨡᩥᩃᩣᩉᩥ ᨾᨬ᩠ᨩᩪᩉᩥ ᨾᨵᩩᩁᩣᩉᩥ ᩅᩣᨧᩣᩉᩥ ᩈᨾᩩᨴᩣᨧᩁᨶ᩠ᨲᩥᨿᩮᩣ – ‘‘ᨾᩣᨿᩴ ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᩌᩈᨶᩮ ᨸᩁᩥᨿᩩᨠ᩠ᨠᨱ᩠ᨮᩦ’’ᨲᩥ.

ᨸᨬ᩠ᨧᩈᨲᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨴᩥᩈᩮᩣᨴᩥᩈᩴ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ ᩋᨶᩮᨠᩁᩩᨠ᩠ᨡᩅᩥᩅᩥᨵᩅᩥᨠᨲᩥᨹᩃᨾᩣᩉᩁᨶ᩠ᨲᩥᨿᩮᩣ – ‘‘ᨾᩣᨿᩴ ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨡᩩᨴᩣᨿ ᨸᩁᩥᨠᩥᩃᨾᩥᨲ᩠ᨳᩣ’’ᨲᩥ.

ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨲᩣ [ᨶᨲ᩠ᨳᩥ ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ] ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨲᩴ ᨠᩩᨱᩣᩃᩴ ᩈᨠᩩᨱᩴ ᩌᩁᩣᨾᩮᨶᩮᩅ ᩌᩁᩣᨾᩴ ᩏᨿ᩠ᨿᩣᨶᩮᨶᩮᩅ ᩏᨿ᩠ᨿᩣᨶᩴ ¶ ᨶᨴᩦᨲᩥᨲ᩠ᨳᩮᨶᩮᩅ ᨶᨴᩦᨲᩥᨲ᩠ᨳᩴ ᨸᨻ᩠ᨻᨲᩈᩥᨡᩁᩮᨶᩮᩅ ᨸᨻ᩠ᨻᨲᩈᩥᨡᩁᩴ ᩋᨾ᩠ᨻᩅᨶᩮᨶᩮᩅ ᩋᨾ᩠ᨻᩅᨶᩴ ᨩᨾ᩠ᨻᩩᩅᨶᩮᨶᩮᩅ ᨩᨾ᩠ᨻᩩᩅᨶᩴ ᩃᨻᩩᨩᩅᨶᩮᨶᩮᩅ ᩃᨻᩩᨩᩅᨶᩴ ᨶᩣᩊᩥᨠᩮᩁᩈᨬ᩠ᨧᩣᩁᩥᨿᩮᨶᩮᩅ [ᩈᨬ᩠ᨩᩣᨴᩥᨿᩮᨶᩮᩅ (ᨸᩦ.)] ᨶᩣᩊᩥᨠᩮᩁᩈᨬ᩠ᨧᩣᩁᩥᨿᩴ ᨡᩥᨸ᩠ᨸᨾᩮᩅ ᩋᨽᩥᩈᨾ᩠ᨽᩮᩣᨶ᩠ᨲᩥ ¶ ᩁᨲᩥᨲ᩠ᨳᩣᨿ [ᩁᨲᨲ᩠ᨳᩣᨿ (ᩈᩦ. ᨸᩦ.)].

ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩣᩉᩥ ᨴᩥᨩᨠᨬ᩠ᨬᩣᩉᩥ ᨴᩥᩅᩈᩴ ᨸᩁᩥᨻ᩠ᨿᩪᩊ᩠ᩉᩮᩣ ᩑᩅᩴ ᩋᨸᩈᩣᨴᩮᨲᩥ – ‘‘ᨶᩔᨳ ᨲᩩᨾ᩠ᩉᩮ ᩅᩈᩃᩥᨿᩮᩣ, ᩅᩥᨶᩔᨳ ᨲᩩᨾ᩠ᩉᩮ ᩅᩈᩃᩥᨿᩮᩣ, ᨧᩮᩣᩁᩥᨿᩮᩣ ᨵᩩᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩈᨲᩥᨿᩮᩣ ᩃᩉᩩᨧᩥᨲ᩠ᨲᩣᨿᩮᩣ ᨠᨲᩔ ᩋᨸ᩠ᨸᨭᩥᨠᩣᩁᩥᨠᩣᨿᩮᩣ ᩋᨶᩥᩃᩮᩣ ᩅᩥᨿ ᨿᩮᨶᨠᩣᨾᩴᨣᨾᩣᨿᩮᩣ’’ᨲᩥ.

ᨲᩔᩮᩅ ᨡᩃᩩ, ᨽᩮᩣ, ᩉᩥᨾᩅᨲᩮᩣ ᨸᨻ᩠ᨻᨲᩁᩣᨩᩔ ᨸᩩᩁᨲ᩠ᨳᩥᨾᨴᩥᩈᩣᨽᩣᨣᩮ ᩈᩩᩈᩩᨡᩩᨾᩈᩩᨶᩥᨸᩩᨱᨣᩥᩁᩥᨸ᩠ᨸᨽᩅ [ᨸ᩠ᨸᨽᩅᩣ (ᩈᩦ. ᨸᩦ.)] – ᩉᩁᩥᨲᩩᨸᨿᨶ᩠ᨲᩥᨿᩮᩣ.

ᩏᨸ᩠ᨸᩃ ¶ ᨸᨴᩩᨾ ᨠᩩᨾᩩᨴ ᨶᩊᩥᨶ ᩈᨲᨸᨲ᩠ᨲ ᩈᩮᩣᨣᨶ᩠ᨵᩥᨠ ᨾᨶ᩠ᨴᩣᩃᨠ [ᨾᨶ᩠ᨴᩣᩃᩅ (ᩈᩦ. ᨸᩦ.), ᨾᨶ᩠ᨴᩣᩁᩅ (ᨠ.)] ᩈᨾ᩠ᨸᨲᩥᩅᩥᩁᩪᩊ᩠ᩉᩈᩩᨧᩥᨣᨶ᩠ᨵ ᨾᨶᩩᨬ᩠ᨬᨾᩣᩅᨠᨸ᩠ᨸᨴᩮᩈᩮ [ᨸᩣᩅᨠᨸ᩠ᨸᨴᩮᩈᩮ (ᩈᩦ. ᨸᩦ.)].

ᨠᩩᩁᩅᨠ-ᨾᩩᨧᩃᩥᨶ᩠ᨴ-ᨠᩮᨲᨠ-ᩅᩮᨴᩥᩈ-ᩅᨬ᩠ᨩᩩᩃ [ᩅᩮᨲᩈᨾᨬ᩠ᨩᩩᩃ (ᩈᩦ.)] -ᨸᩩᨶ᩠ᨶᩣᨣᨻᨠᩩᩃ-ᨲᩥᩃᨠ-ᨸᩥᨿᨠ-ᩉᩈᨶᩈᩣᩃ-ᩈᩊᩃᨧᨾ᩠ᨸᨠ ᩋᩈᩮᩣᨠ-ᨶᩣᨣᩁᩩᨠ᩠ᨡ-ᨲᩥᩁᩦᨭᩥ-ᨽᩩᨩᨸᨲ᩠ᨲ-ᩃᩮᩣᨴ᩠ᨴ-ᨧᨶ᩠ᨴᨶᩮᩣᨥᩅᨶᩮᨠᩣᩊᩣᨣᩁᩩ-ᨸᨴ᩠ᨾᨠ-ᨸᩥᨿᨦ᩠ᨣᩩ-ᨴᩮᩅᨴᩣᩁᩩᨠᨧᩮᩣᨧᨣᩉᨶᩮ ᨠᨠᩩᨵᨠᩩᨭᨩᩋᨦ᩠ᨠᩮᩣᩃ-ᨠᨧ᩠ᨧᩥᨠᩣᩁ [ᨠᨧ᩠ᨨᩥᨠᩣᩁ (ᨠ.)] -ᨠᨱᩥᨠᩣᩁ-ᨠᨱ᩠ᨱᩥᨠᩣᩁ-ᨠᨶᩅᩮᩁ-ᨠᩮᩣᩁᨱ᩠ᨯᨠ-ᨠᩮᩣᩅᩥᩊᩣᩁ-ᨠᩥᩴᩈᩩᨠ-ᨿᩮᩣᨵᩥᨠ ᩅᨶᨾᩃ᩠ᩃᩥᨠ [ᨶᩅᨾᩃ᩠ᩃᩥᨠ (ᩈᩦ. ᨸᩦ.)] -ᨾᨶᨦ᩠ᨣᨱ-ᨾᨶᩅᨩ᩠ᨩ-ᨽᨱ᩠ᨯᩥ-ᩈᩩᩁᩩᨧᩥᩁ-ᨽᨣᩥᨶᩥᨾᩣᩃᩣᨾᩃ᩠ᨿᨵᩁᩮ ᨩᩣᨲᩥᩈᩩᨾᨶᨾᨵᩩᨣᨶ᩠ᨵᩥᨠ- [ᨾᨵᩩᨠᨻᨶ᩠ᨵᩩᨠ (ᨠ.)] ᨵᨶᩩᨲᨠ᩠ᨠᩣᩁᩥ [ᨵᨶᩩᨠᩣᩁᩥ (ᩈᩦ.), ᨵᨶᩩᨠᩣᩁᩥᨠ (ᨸᩦ.)] ᨲᩣᩃᩦᩈ-ᨲᨣᩁᨾᩩᩈᩦᩁᨠᩮᩣᨭ᩠ᨮ-ᨠᨧ᩠ᨨᩅᩥᨲᨲᩮ ᩋᨲᩥᨾᩩᨲ᩠ᨲᨠᩈᩴᨠᩩᩈᩩᨾᩥᨲᩃᨲᩣᩅᩥᨲᨲᨸᨭᩥᨾᨱ᩠ᨯᩥᨲᨸ᩠ᨸᨴᩮᩈᩮ ᩉᩴᩈ-ᨸᩥᩃᩅ-ᨠᩣᨴᨾ᩠ᨻ-ᨠᩣᩁᨱ᩠ᨯᩅᩣᨽᩥᨶᨴᩥᨲᩮ ᩅᩥᨩ᩠ᨩᩣᨵᩁ-ᩈᩥᨴ᩠ᨵ [ᩈᩥᨶ᩠ᨵᩅ (ᩈᩦ. ᨸᩦ.)] -ᩈᨾᨱ-ᨲᩣᨸᩈᨣᨱᩣᨵᩥᩅᩩᨭ᩠ᨮᩮ ᩅᩁᨴᩮᩅ-ᨿᨠ᩠ᨡ-ᩁᨠ᩠ᨡᩈ-ᨴᩣᨶᩅ-ᨣᨶ᩠ᨵᨻ᩠ᨻ-ᨠᩥᨶ᩠ᨶᩁᨾᩉᩮᩣᩁᨣᩣᨶᩩᨧᩥᨱ᩠ᨱᨸ᩠ᨸᨴᩮᩈᩮ ᩑᩅᩁᩪᨸᩮ ᨡᩃᩩ, ᨽᩮᩣ, ᩁᨾ᩠ᨾᩮ ᩅᨶᩈᨱ᩠ᨯᩮ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨶᩣᨾ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨸᨭᩥᩅᩈᨲᩥ ᩋᨲᩥᩅᩥᨿ ᨾᨵᩩᩁᨣᩥᩁᩮᩣ ᩅᩥᩃᩣᩈᩥᨲᨶᨿᨶᩮᩣ ᨾᨲ᩠ᨲᨠ᩠ᨡᩮᩣ [ᩈᩅᩥᩃᩣᩈᩥᨲᨶᨿᨶᨾᨲ᩠ᨲᨠ᩠ᨡᩮᩣ (ᨠ.)].

ᨲᩔᩮᩅ ᨡᩃᩩ, ᨽᩮᩣ, ᨸᩩᨱ᩠ᨱᨾᩩᨡᩔ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩔ ᩋᨯ᩠ᨰᩩᨯ᩠ᨰᩣᨶᩥ ᩍᨲ᩠ᨳᩥᩈᨲᩣᨶᩥ ᨸᩁᩥᨧᩣᩁᩥᨠᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ. ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨴ᩠ᩅᩮ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨠᨭ᩠ᨮᩴ ᨾᩩᨡᩮᨶ ᨯᩴᩈᩥᨲ᩠ᩅᩣ ᨲᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᨾᨩ᩠ᨫᩮ ᨶᩥᩈᩦᨴᩣᨸᩮᨲ᩠ᩅᩣ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ ¶ – ‘‘ᨾᩣ ᨶᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᩋᨴ᩠ᨵᩣᨶᨸᩁᩥᨿᩣᨿᨸᨳᩮ ᨠᩥᩃᨾᨳᩮᩣ ᩏᨻ᩠ᨻᩣᩉᩮᨲ᩠ᨳᩣ’’ᨲᩥ.

ᨸᨬ᩠ᨬᩣᩈ ¶ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᩉᩮᨭ᩠ᨮᨲᩮᩣ ᩉᩮᨭ᩠ᨮᨲᩮᩣ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ – ‘‘ᩈᨧᩣᨿᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᩌᩈᨶᩣ ᨸᩁᩥᨸᨲᩥᩔᨲᩥ, ᨾᨿᩴ ᨲᩴ ᨸᨠ᩠ᨡᩮᩉᩥ ᨸᨭᩥᨣ᩠ᨣᩉᩮᩔᩣᨾᩣ’’ᨲᩥ.

ᨸᨬ᩠ᨬᩣᩈ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᩏᨸᩁᩪᨸᩁᩥ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ – ‘‘ᨾᩣ ᨶᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᩌᨲᨸᩮᩣ ᨸᩁᩥᨲᩣᨸᩮᩈᩦ’’ᨲᩥ.

ᨸᨬ᩠ᨬᩣᩈ ᨸᨬ᩠ᨬᩣᩈ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᩏᨽᨲᩮᩣᨸᩔᩮᨶ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ – ‘‘ᨾᩣ ᨶᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᩈᩦᨲᩴ ᩅᩣ ᩏᨱ᩠ᩉᩴ ᩅᩣ ᨲᩥᨱᩴ ᩅᩣ ᩁᨩᩮᩣ ᩅᩣ ᩅᩣᨲᩮᩣ ᩅᩣ ᩏᩔᩣᩅᩮᩣ ᩅᩣ ᩏᨸᨸ᩠ᨹᩩᩈᩦ’’ᨲᩥ.

ᨸᨬ᩠ᨬᩣᩈ ¶ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨸᩩᩁᨲᩮᩣ ᨸᩩᩁᨲᩮᩣ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ – ‘‘ᨾᩣ ᨶᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᨣᩮᩣᨸᩣᩃᨠᩣ ᩅᩣ ᨸᩈᩩᨸᩣᩃᨠᩣ ᩅᩣ ᨲᩥᨱᩉᩣᩁᨠᩣ ᩅᩣ ᨠᨭ᩠ᨮᩉᩣᩁᨠᩣ ᩅᩣ ᩅᨶᨠᨾ᩠ᨾᩥᨠᩣ ᩅᩣ ᨠᨭ᩠ᨮᩮᨶ ᩅᩣ ᨠᨳᩃᩣᨿ ᩅᩣ ᨸᩣᨱᩥᨶᩣ ᩅᩣ ᩃᩮᨯ᩠ᨯᩩᨶᩣ ᩅᩣ ᨴᨱ᩠ᨯᩮᨶ ᩅᩣ ᩈᨲ᩠ᨳᩮᨶ ᩅᩣ ᩈᨠ᩠ᨡᩁᩣᩉᩥ ᩅᩣ ᨸᩉᩣᩁᩴ ᩋᨴᩴᩈᩩ. ᨾᩣᨿᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨣᨧ᩠ᨨᩮᩉᩥ ᩅᩣ ᩃᨲᩣᩉᩥ ᩅᩣ ᩁᩩᨠ᩠ᨡᩮᩉᩥ ᩅᩣ ᩈᩣᨡᩣᩉᩥ ᩅᩣ ᨳᨾ᩠ᨽᩮᩉᩥ ᩅᩣ ᨸᩣᩈᩣᨱᩮᩉᩥ ᩅᩣ ᨻᩃᩅᨶ᩠ᨲᩮᩉᩥ ᩅᩣ ᨸᨠ᩠ᨡᩦᩉᩥ ᩈᨦ᩠ᨣᩣᨾᩮᩈᩦ’’ᨲᩥ.

ᨸᨬ᩠ᨬᩣᩈ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨸᨧ᩠ᨨᨲᩮᩣ ᨸᨧ᩠ᨨᨲᩮᩣ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ ᩈᨱ᩠ᩉᩣᩉᩥ ᩈᨡᩥᩃᩣᩉᩥ ᨾᨬ᩠ᨩᩪᩉᩥ ᨾᨵᩩᩁᩣᩉᩥ ᩅᩣᨧᩣᩉᩥ ᩈᨾᩩᨴᩣᨧᩁᨶ᩠ᨲᩥᨿᩮᩣ – ‘‘ᨾᩣᨿᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᩌᩈᨶᩮ ᨸᩁᩥᨿᩩᨠ᩠ᨠᨱ᩠ᨮᩦ’’ᨲᩥ.

ᨸᨬ᩠ᨬᩣᩈ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨴᩥᩈᩮᩣᨴᩥᩈᩴ ᩏᨯ᩠ᨯᩮᨶ᩠ᨲᩥ ᩋᨶᩮᨠᩁᩩᨠ᩠ᨡᩅᩥᩅᩥᨵᩅᩥᨠᨲᩥᨹᩃᨾᩣᩉᩁᨶ᩠ᨲᩥᨿᩮᩣ – ‘‘ᨾᩣᨿᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨡᩩᨴᩣᨿ ᨸᩁᩥᨠᩥᩃᨾᩥᨲ᩠ᨳᩣ’’ᨲᩥ.

ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨲᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨲᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ¶ ᩌᩁᩣᨾᩮᨶᩮᩅ ᩌᩁᩣᨾᩴ ᩏᨿ᩠ᨿᩣᨶᩮᨶᩮᩅ ᩏᨿ᩠ᨿᩣᨶᩴ ᨶᨴᩦᨲᩥᨲ᩠ᨳᩮᨶᩮᩅ ᨶᨴᩦᨲᩥᨲ᩠ᨳᩴ ᨸᨻ᩠ᨻᨲᩈᩥᨡᩁᩮᨶᩮᩅ ᨸᨻ᩠ᨻᨲᩈᩥᨡᩁᩴ ᩋᨾ᩠ᨻᩅᨶᩮᨶᩮᩅ ᩋᨾ᩠ᨻᩅᨶᩴ ᨩᨾ᩠ᨻᩩᩅᨶᩮᨶᩮᩅ ᨩᨾ᩠ᨻᩩᩅᨶᩴ ᩃᨻᩩᨩᩅᨶᩮᨶᩮᩅ ᩃᨻᩩᨩᩅᨶᩴ ᨶᩣᩊᩥᨠᩮᩁᩈᨬ᩠ᨧᩣᩁᩥᨿᩮᨶᩮᩅ ᨶᩣᩊᩥᨠᩮᩁᩈᨬ᩠ᨧᩣᩁᩥᨿᩴ ᨡᩥᨸ᩠ᨸᨾᩮᩅ ᩋᨽᩥᩈᨾ᩠ᨽᩮᩣᨶ᩠ᨲᩥ ᩁᨲᩥᨲ᩠ᨳᩣᨿ.

ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨲᩣᩉᩥ ᨴᩥᨩᨠᨬ᩠ᨬᩣᩉᩥ ᨴᩥᩅᩈᩴ ᨸᩁᩥᨻ᩠ᨿᩪᩊ᩠ᩉᩮᩣ ᩑᩅᩴ ᨸᩈᩴᩈᨲᩥ – ‘‘ᩈᩣᨵᩩ, ᩈᩣᨵᩩ, ᨽᨣᩥᨶᩥᨿᩮᩣ, ᩑᨲᩴ ᨡᩮᩣ, ᨽᨣᩥᨶᩥᨿᩮᩣ, ᨲᩩᨾ᩠ᩉᩣᨠᩴ ᨸᨲᩥᩁᩪᨸᩴ ᨠᩩᩃᨵᩦᨲᩣᨶᩴ, ᨿᩴ ᨲᩩᨾ᩠ᩉᩮ ᨽᨲ᩠ᨲᩣᩁᩴ ᨸᩁᩥᨧᩁᩮᨿ᩠ᨿᩣᨳᩣ’’ᨲᩥ.

ᩋᨳ ¶ ᨡᩃᩩ, ᨽᩮᩣ, ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨿᩮᨶ ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ. ᩋᨴ᩠ᨴᩈᩴᩈᩩ ᨡᩮᩣ ᨠᩩᨱᩣᩃᩔ ᩈᨠᩩᨱᩔ ᨸᩁᩥᨧᩣᩁᩥᨠᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨲᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᨴᩪᩁᨲᩮᩣᩅ ᩌᨣᨧ᩠ᨨᨶ᩠ᨲᩴ; ᨴᩥᩈ᩠ᩅᩣᨶ ᨿᩮᨶ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥᩴᩈᩩ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨲᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᩑᨲᨴᩅᩮᩣᨧᩩᩴ – ‘‘ᩋᨿᩴ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᩋᨲᩥᩅᩥᨿ ᨹᩁᩩᩈᩮᩣ ᩋᨲᩥᩅᩥᨿ ᨹᩁᩩᩈᩅᩣᨧᩮᩣ, ᩋᨸ᩠ᨸᩮᩅᨶᩣᨾ ᨲᩅᨾ᩠ᨸᩥ ᩌᨣᨾ᩠ᨾ ᨸᩥᨿᩅᩣᨧᩴ ᩃᨽᩮᨿ᩠ᨿᩣᨾᩣ’’ᨲᩥ. ‘‘ᩋᨸ᩠ᨸᩮᩅᨶᩣᨾ, ᨽᨣᩥᨶᩥᨿᩮᩣ’’ᨲᩥ ᩅᨲ᩠ᩅᩣ ᨿᩮᨶ ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨠᩩᨱᩣᩃᩮᨶ ¶ ᩈᨠᩩᨱᩮᨶ ᩈᨴ᩠ᨵᩥᩴ ᨸᨭᩥᩈᨾ᩠ᨾᩮᩣᨴᩥᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨲᩴ ᨠᩩᨱᩣᩃᩴ ᩈᨠᩩᨱᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩥᩔ ᨲ᩠ᩅᩴ, ᩈᨾ᩠ᨾ ᨠᩩᨱᩣᩃ, ᩍᨲ᩠ᨳᩦᨶᩴ ᩈᩩᨩᩣᨲᩣᨶᩴ ᨠᩩᩃᨵᩦᨲᩣᨶᩴ ᩈᨾ᩠ᨾᩣᨸᨭᩥᨸᨶ᩠ᨶᩣᨶᩴ ᨾᩥᨧ᩠ᨨᩣᨸᨭᩥᨸᨶ᩠ᨶᩮᩣ’ᩈᩥ [ᨸᨭᩥᨸᨶ᩠ᨶᩮᩣ (ᩈᩦ. ᨸᩦ.)]? ᩋᨾᨶᩣᨸᨽᩣᨱᩦᨶᨾ᩠ᨸᩥ ᨠᩥᩁ, ᩈᨾ᩠ᨾ ᨠᩩᨱᩣᩃ, ᩍᨲ᩠ᨳᩦᨶᩴ ᨾᨶᩣᨸᨽᩣᨱᩥᨶᩣ ᨽᩅᩥᨲᨻ᩠ᨻᩴ, ᨠᩥᨾᨦ᩠ᨣ ᨸᨶ ᨾᨶᩣᨸᨽᩣᨱᩦᨶ’’ᨶ᩠ᨲᩥ!

ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᩑᩅᩴ ᩋᨸᩈᩣᨴᩮᩈᩥ – ‘‘ᨶᩔ ᨲ᩠ᩅᩴ, ᩈᨾ᩠ᨾ ᨩᨾ᩠ᨾ ᩅᩈᩃ, ᩅᩥᨶᩔ ᨲ᩠ᩅᩴ, ᩈᨾ᩠ᨾ ᨩᨾ᩠ᨾ ᩅᩈᩃ, ᨠᩮᩣ ᨶᩩ ᨲᨿᩣ ᩅᩥᨿᨲ᩠ᨲᩮᩣ ᨩᩣᨿᩣᨩᩥᨶᩮᨶᩣ’’ᨲᩥ. ᩑᩅᩴ ᩋᨸᩈᩣᨴᩥᨲᩮᩣ ᨧ ᨸᨶ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨲᨲᩮᩣᨿᩮᩅ [ᨲᨲᩮᩣ ᩉᩮᩅ (ᩈᩦ. ᨸᩦ.)] ᨸᨭᩥᨶᩥᩅᨲ᩠ᨲᩥ.

ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨸᩩᨱ᩠ᨱᨾᩩᨡᩔ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩔ ᩋᨸᩁᩮᨶ ᩈᨾᨿᩮᨶ ᨶᨧᩥᩁᩔᩮᩅ [ᩋᨧᩥᩁᩔᩮᩅ ᩋᨧ᩠ᨧᨿᩮᨶ (ᨠ.)] ᨡᩁᩮᩣ ᩌᨻᩣᨵᩮᩣ ᩏᨸ᩠ᨸᨩ᩠ᨩᩥ ᩃᩮᩣᩉᩥᨲᨸᨠ᩠ᨡᨶ᩠ᨴᩥᨠᩣ. ᨻᩣᩊ᩠ᩉᩣ ᩅᩮᨴᨶᩣ ᩅᨲ᩠ᨲᨶ᩠ᨲᩥ ᨾᩣᩁᨱᨶ᩠ᨲᩥᨠᩣ [ᨾᩁᨱᨶ᩠ᨲᩥᨠᩣ (ᩈ᩠ᨿᩣ.)]. ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨸᩩᨱ᩠ᨱᨾᩩᨡᩔ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩔ ᨸᩁᩥᨧᩣᩁᩥᨠᩣᨶᩴ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨶᩴ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᩌᨻᩣᨵᩥᨠᩮᩣ ᨡᩮᩣ ᩋᨿᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ, ᩋᨸ᩠ᨸᩮᩅᨶᩣᨾ ᩍᨾᨾ᩠ᩉᩣ ᩌᨻᩣᨵᩣ ᩅᩩᨭ᩠ᨮᩉᩮᨿ᩠ᨿᩣ’’ᨲᩥ ᩑᨠᩴ ᩋᨴᩩᨲᩥᨿᩴ ᩒᩉᩣᨿ ᨿᩮᨶ ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥᩴᩈᩩ. ᩋᨴ᩠ᨴᩈᩣ ᨡᩮᩣ ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᨴᩪᩁᨲᩮᩣᩅ ᩌᨣᨧ᩠ᨨᨶ᩠ᨲᩥᨿᩮᩣ, ᨴᩥᩈ᩠ᩅᩣᨶ ᨲᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩉᩴ ᨸᨶ ᨲᩩᨾ᩠ᩉᩴ ᩅᩈᩃᩥᨿᩮᩣ ᨽᨲ᩠ᨲᩣ’’ᨲᩥ? ‘‘ᩌᨻᩣᨵᩥᨠᩮᩣ ᨡᩮᩣ, ᩈᨾ᩠ᨾ ᨠᩩᨱᩣᩃ, ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᩋᨸ᩠ᨸᩮᩅᨶᩣᨾ ᨲᨾ᩠ᩉᩣ ᩌᨻᩣᨵᩣ ᩅᩩᨭ᩠ᨮᩉᩮᨿ᩠ᨿᩣ’’ᨲᩥ. ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩣ ᨴᩥᨩᨠᨬ᩠ᨬᩣᨿᩮᩣ ᩑᩅᩴ ᩋᨸᩈᩣᨴᩮᩈᩥ – ‘‘ᨶᩔᨳ ᨲᩩᨾ᩠ᩉᩮ ᩅᩈᩃᩥᨿᩮᩣ, ᩅᩥᨶᩔᨳ ᨲᩩᨾ᩠ᩉᩮ ᩅᩈᩃᩥᨿᩮᩣ, ᨧᩮᩣᩁᩥᨿᩮᩣ ᨵᩩᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩈᨲᩥᨿᩮᩣ ᩃᩉᩩᨧᩥᨲ᩠ᨲᩣᨿᩮᩣ ᨠᨲᩔ ᩋᨸ᩠ᨸᨭᩥᨠᩣᩁᩥᨠᩣᨿᩮᩣ ᩋᨶᩥᩃᩮᩣ ᩅᩥᨿ ᨿᩮᨶᨠᩣᨾᩴᨣᨾᩣᨿᩮᩣ’’ᨲᩥ; ᩅᨲ᩠ᩅᩣ ᨿᩮᨶ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩮᩣ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨲᩴ ¶ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩉᩴ, ᩈᨾ᩠ᨾ, ᨸᩩᨱ᩠ᨱᨾᩩᨡᩣ’’ᨲᩥ. ‘‘ᩉᩴ, ᩈᨾ᩠ᨾ, ᨠᩩᨱᩣᩃᩣ’’ᨲᩥ.

ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᨸᨠ᩠ᨡᩮᩉᩥ ᨧ ᨾᩩᨡᨲᩩᨱ᩠ᨯᨠᩮᨶ ¶ ᨧ ᨸᩁᩥᨣ᩠ᨣᩉᩮᨲ᩠ᩅᩣ ᩅᩩᨭ᩠ᨮᩣᨸᩮᨲ᩠ᩅᩣ ᨶᩣᨶᩣᨽᩮᩈᨩ᩠ᨩᩣᨶᩥ ᨸᩣᨿᩣᨸᩮᩈᩥ. ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨸᩩᨱ᩠ᨱᨾᩩᨡᩔ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩔ ᩈᩮᩣ ᩌᨻᩣᨵᩮᩣ ᨸᨭᩥᨸ᩠ᨸᩔᨾ᩠ᨽᩦᨲᩥ. ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨲᩴ ᨸᩩᨱ᩠ᨱᨾᩩᨡᩴ ¶ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩴ ᨣᩥᩃᩣᨶᩅᩩᨭ᩠ᨮᩥᨲᩴ [ᨣᩥᩃᩣᨶᩣᩅᩩᨭ᩠ᨮᩥᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩋᨧᩥᩁᩅᩩᨭ᩠ᨮᩥᨲᩴ ᨣᩮᩃᨬ᩠ᨬᩣ ᩑᨲᨴᩅᩮᩣᨧ –

‘‘ᨴᩥᨭ᩠ᨮᩣ ᨾᨿᩣ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨠᨱ᩠ᩉᩣ ᨴ᩠ᩅᩮᨸᩥᨲᩥᨠᩣ ᨸᨬ᩠ᨧᨸᨲᩥᨠᩣᨿ ᨨᨭ᩠ᨮᩮ ᨸᩩᩁᩥᩈᩮ ᨧᩥᨲ᩠ᨲᩴ ᨸᨭᩥᨻᨶ᩠ᨵᨶ᩠ᨲᩥᨿᩣ, ᨿᨴᩥᨴᩴ ᨠᨻᨶ᩠ᨵᩮ [ᨠᩅᨶ᩠ᨵᩮ (ᩈᩦ. ᨸᩦ.)] ᨸᩦᨮᩈᨸ᩠ᨸᩥᨾ᩠ᩉᩦᨲᩥ. ᨽᩅᨲᩥ ᨧ ᨸᨶᩩᨲ᩠ᨲᩁᩮᨲ᩠ᨳ [ᨸᩩᨶᩩᨲ᩠ᨲᨧᩮᨲ᩠ᨳ (ᨠ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ᩅᩣᨠ᩠ᨿᩴ –

᪒᪙᪐.

‘‘ᩋᨳᨩ᩠ᨩᩩᨶᩮᩣ ᨶᨠᩩᩃᩮᩣ ᨽᩦᨾᩈᩮᨶᩮᩣ [ᨽᩥᨾ᩠ᨾᩈᩮᨶᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨿᩩᨵᩥᨭ᩠ᨮᩥᩃᩮᩣ ᩈᩉᨴᩮᩅᩮᩣ [ᩈᩦᩉᨴᩮᩅᩮᩣ (ᨠ.)] ᨧ ᩁᩣᨩᩣ;

ᩑᨲᩮ ᨸᨲᩦ ᨸᨬ᩠ᨧ ᨾᨲ᩠ᨲᩥᨧ᩠ᨧ ᨶᩣᩁᩦ, ᩋᨠᩣᩈᩥ ᨡᩩᨩ᩠ᨩᩅᩣᨾᨶᨠᩮᨶ [ᨡᩩᨩ᩠ᨩᩅᩣᨾᨶᩮᨶ (ᨸᩦ.)] ᨸᩣᨸ’’ᨶ᩠ᨲᩥ.

‘‘ᨴᩥᨭ᩠ᨮᩣ ᨾᨿᩣ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᩈᨧ᩠ᨧᨲᨸᩣᨸᩦ [ᩈᨧ᩠ᨧᨲᨸᩣᩅᩦ (ᩈᩦ. ᨸᩦ.), ᨸᨬ᩠ᨧᨲᨸᩣᩅᩦ (ᩈ᩠ᨿᩣ.)] ᨶᩣᨾ ᩈᨾᨱᩦ ᩈᩩᩈᩣᨶᨾᨩ᩠ᨫᩮ ᩅᩈᨶ᩠ᨲᩦ ᨧᨲᩩᨲ᩠ᨳᨽᨲ᩠ᨲᩴ ᨸᩁᩥᨱᩣᨾᨿᨾᩣᨶᩣ ᩈᩩᩁᩣᨵᩩᨲ᩠ᨲᨠᩮᨶ [ᨲᩩᩃᩣᨸᩩᨲ᩠ᨲᨠᩮᨶ (ᩈᩦ. ᨸᩦ.), ᩈᩣ ᩈᩩᩁᩣᨵᩩᨲ᩠ᨲᨠᩮᨶ (ᨠ.)] ᨸᩣᨸᨾᨠᩣᩈᩥ.

‘‘ᨴᩥᨭ᩠ᨮᩣ ᨾᨿᩣ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨠᩣᨠᩅᨲᩦ [ᨠᩣᨠᩣᨲᩦ (ᩈᩦ.), ᨠᩣᨠᩣᨲᩥ (ᨸᩦ.)] ᨶᩣᨾ ᨴᩮᩅᩦ ᩈᨾᩩᨴ᩠ᨴᨾᨩ᩠ᨫᩮ ᩅᩈᨶ᩠ᨲᩦ ᨽᩁᩥᨿᩣ ᩅᩮᨶᨲᩮᨿ᩠ᨿᩔ ᨶᨭᨠᩩᩅᩮᩁᩮᨶ ᨸᩣᨸᨾᨠᩣᩈᩥ.

ᨴᩥᨭ᩠ᨮᩣ ᨾᨿᩣ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨠᩩᩁᩩᨦ᩠ᨣᨴᩮᩅᩦ [ᨠᩩᩁᨦ᩠ᨣᩅᩦ (ᩈᩦ. ᨸᩦ.)] ᨶᩣᨾ ᩃᩮᩣᨾᩈᩩᨴ᩠ᨴᩁᩦ [ᩃᩮᩣᨾᩈᩩᨶ᩠ᨴᩁᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩑᩊᩥᨠᨠᩩᨾᩣᩁᩴ [ᩑᩊᨾᩣᩁᨠᩴ (ᩈᩦ.), ᩑᩊᨠᨠᩩᨾᩣᩁᩴ (ᩈ᩠ᨿᩣ.), ᩑᩊᨠᨾᩣᩁᩴ (ᨸᩦ.)] ᨠᩣᨾᨿᨾᩣᨶᩣ ᨨᩊᨦ᩠ᨣᨠᩩᨾᩣᩁᨵᨶᨶ᩠ᨲᩮᩅᩣᩈᩥᨶᩣ ᨸᩣᨸᨾᨠᩣᩈᩥ.

ᩑᩅᨬ᩠ᩉᩮᨲᩴ ¶ ᨾᨿᩣ ᨬᩣᨲᩴ, ᨻᩕᩉ᩠ᨾᨴᨲ᩠ᨲᩔ ᨾᩣᨲᩁᩴ [ᨾᩣᨲᩩᨠᩣ (ᩈ᩠ᨿᩣ.)] ᩒᩉᩣᨿ ᨠᩮᩣᩈᩃᩁᩣᨩᩴ ᨸᨬ᩠ᨧᩣᩃᨧᨱ᩠ᨯᩮᨶ ᨸᩣᨸᨾᨠᩣᩈᩥ.

᪒᪙᪑.

‘‘ᩑᨲᩣ ᨧ ᩋᨬ᩠ᨬᩣ ᨧ ᩋᨠᩴᩈᩩ ᨸᩣᨸᩴ, ᨲᩈ᩠ᨾᩣᩉᨾᩥᨲ᩠ᨳᩦᨶᩴ ᨶ ᩅᩥᩔᩈᩮ ᨶᨸ᩠ᨸᩈᩴᩈᩮ;

ᨾᩉᩦ ᨿᨳᩣ ᨩᨣᨲᩥ ᩈᨾᩣᨶᩁᨲ᩠ᨲᩣ, ᩅᩈᩩᨶ᩠ᨵᩁᩣ ᩍᨲᩁᩦᨲᩁᩣᨸᨲᩥᨭ᩠ᨮᩣ [ᩍᨲᩁᩦᨲᩁᩣᨶᩴ ᨸᨲᩥᨭ᩠ᨮᩣ (ᩈ᩠ᨿᩣ.), ᩍᨲ᩠ᨲᩁᩦᨲᩁᨸ᩠ᨸᨲᩥᨭ᩠ᨮᩣ (?)];

ᩈᨻ᩠ᨻᩈᩉᩣ ᩋᨹᨶ᩠ᨴᨶᩣ ᩋᨠᩩᨸ᩠ᨸᩣ, ᨲᨳᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨲᩣᨿᩮᩣ ᨶ ᩅᩥᩔᩈᩮ ᨶᩁᩮᩣ.

᪒᪙᪒.

‘‘ᩈᩦᩉᩮᩣ ¶ ᨿᨳᩣ ᩃᩮᩣᩉᩥᨲᨾᩴᩈᨽᩮᩣᨩᨶᩮᩣ, ᩅᩣᩊᨾᩥᨣᩮᩣ ᨸᨬ᩠ᨧᩣᩅᩩᨵᩮᩣ [ᨸᨬ᩠ᨧᩉᨲ᩠ᨳᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᩈᩩᩁᩩᨴ᩠ᨵᩮᩣ;

ᨸᩈᨿ᩠ᩉᨡᩣᨴᩦ ᨸᩁᩉᩥᩴᩈᨶᩮ ᩁᨲᩮᩣ, ᨲᨳᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨲᩣᨿᩮᩣ ᨶ ᩅᩥᩔᩈᩮ ᨶᩁᩮᩣ.

‘‘ᨶ ᨡᩃᩩ [ᨶ ᨡᩃᩩ ᨽᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)], ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᩅᩮᩈᩥᨿᩮᩣ ᨶᩣᩁᩥᨿᩮᩣ ᨣᨾᨶᩥᨿᩮᩣ, ᨶ ᩉᩮᨲᩣ ᨻᨶ᩠ᨵᨠᩥᨿᩮᩣ ᨶᩣᨾ, ᩅᨵᩥᨠᩣᨿᩮᩣ ᨶᩣᨾ ᩑᨲᩣᨿᩮᩣ, ᨿᨴᩥᨴᩴ ᩅᩮᩈᩥᨿᩮᩣ ᨶᩣᩁᩥᨿᩮᩣ ᨣᨾᨶᩥᨿᩮᩣ’’ᨲᩥ.

‘‘ᨧᩮᩣᩁᩮᩣ ¶ [ᨧᩮᩣᩁᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩅᩥᨿ ᩅᩮᨱᩥᨠᨲᩣ, ᨾᨴᩥᩁᩣᩅ [ᨾᨴᩥᩁᩣ ᩅᩥᨿ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨾᨴᩥᩁᩥᩅ (ᨸᩦ.)] ᨴᩥᨴ᩠ᨵᩣ [ᨴᩥᨭ᩠ᨮᩣ (ᨠ.), ᩅᩥᩈᨴᩩᨭ᩠ᨮᩣ (ᩈ᩠ᨿᩣ.)] ᩅᩣᨱᩥᨩᩮᩣ [ᩅᩣᨱᩥᨩᩣ (ᨸᩦ.)] ᩅᩥᨿ ᩅᩣᨧᩣᩈᨶ᩠ᨳᩩᨲᩥᨿᩮᩣ, ᩍᩔᩈᩥᨦ᩠ᨥᨾᩥᩅ ᩅᩥᨸᩁᩥᩅᨲ᩠ᨲᩣᨿᩮᩣ [ᨸᩁᩥᩅᨲ᩠ᨲᩣᨿᩮᩣ (ᨸᩦ.), ᩅᩥᨸᩁᩥᩅᨲ᩠ᨲᩣᩁᩮᩣ (ᨠ.)], ᩏᩁᨣᩣᨾᩥᩅ ᨴᩩᨩᩥᩅ᩠ᩉᩣᨿᩮᩣ, ᩈᩮᩣᨻ᩠ᨽᨾᩥᩅ ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᩣ, ᨸᩣᨲᩣᩃᨾᩥᩅ ᨴᩩᨸ᩠ᨸᩪᩁᩣ ᩁᨠ᩠ᨡᩈᩦ ᩅᩥᨿ ᨴᩩᨲ᩠ᨲᩮᩣᩈᩣ, ᨿᨾᩮᩣᩅᩮᨠᨶ᩠ᨲᩉᩣᩁᩥᨿᩮᩣ, ᩈᩥᨡᩦᩁᩥᩅ ᩈᨻ᩠ᨻᨽᨠ᩠ᨡᩣ, ᨶᨴᩦᩁᩥᩅ ᩈᨻ᩠ᨻᩅᩣᩉᩦ, ᩋᨶᩥᩃᩮᩣ ᩅᩥᨿ ᨿᩮᨶᨠᩣᨾᩴᨧᩁᩣ, ᨶᩮᩁᩩ ᩅᩥᨿ ᩋᩅᩥᩈᩮᩈᨠᩁᩣ, ᩅᩥᩈᩁᩩᨠ᩠ᨡᩮᩣ ᩅᩥᨿ ᨶᩥᨧ᩠ᨧᨹᩃᩥᨲᩣᨿᩮᩣ’’ᨲᩥ. ᨽᩅᨲᩥ ᨧ ᨸᨶᩩᨲ᩠ᨲᩁᩮᨲ᩠ᨳ ᩅᩣᨠ᩠ᨿᩴ –

᪒᪙᪓.

‘‘ᨿᨳᩣ ¶ ᨧᩮᩣᩁᩮᩣ ᨿᨳᩣ ᨴᩥᨴ᩠ᨵᩮᩣ, ᩅᩣᨱᩥᨩᩮᩣᩅ ᩅᩥᨠᨲ᩠ᨳᨶᩦ;

ᩍᩔᩈᩥᨦ᩠ᨥᨾᩥᩅ ᨸᩁᩥᩅᨲ᩠ᨲᩣ [ᨾᩥᩅᩣᩅᨭ᩠ᨭᩮᩣ (ᩈᩦ.), ᨾᩥᩅᩣᩅᨲ᩠ᨲᩣ (ᨸᩦ.)], ᨴᩩᨩᩥᩅ᩠ᩉᩣ [ᨴᩩᨩ᩠ᨩᩥᩅ᩠ᩉ (ᨸᩦ.)] ᩏᩁᨣᩮᩣ ᩅᩥᨿ.

᪒᪙᪔.

‘‘ᩈᩮᩣᨻ᩠ᨽᨾᩥᩅ ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᩣ, ᨸᩣᨲᩣᩃᨾᩥᩅ ᨴᩩᨸ᩠ᨸᩩᩁᩣ;

ᩁᨠ᩠ᨡᩈᩦ ᩅᩥᨿ ᨴᩩᨲ᩠ᨲᩮᩣᩈᩣ, ᨿᨾᩮᩣᩅᩮᨠᨶ᩠ᨲᩉᩣᩁᩥᨿᩮᩣ.

᪒᪙᪕.

[ᨿᨳᩣ ᩈᩥᨡᩦ ᨶᨴᩦᩅᩣᩉᩮᩣ, ᩋᨶᩥᩃᩮᩣ ᨠᩣᨾᨧᩣᩁᩅᩣ;§ᨶᩮᩁᩪᩅ ᩋᩅᩥᩈᩮᩈᩣ ᨧ, ᩅᩥᩈᩁᩩᨠ᩠ᨡᩮᩣ ᩅᩥᨿ ᨶᩥᨧ᩠ᨧᨹᩃᩣ;§ᨶᩣᩈᨿᨶ᩠ᨲᩥ ᨥᩁᩮ ᨽᩮᩣᨣᩴ, ᩁᨲᨶᩣᨶᨶ᩠ᨲᨠᩁᩥᨲ᩠ᨳᩥ ᨿᩮᩣᨲᩥ; (ᩈᩦ. ᩈ᩠ᨿᩣ.)]

‘‘ᨿᨳᩣ ᩈᩥᨡᩦ ᨶᨴᩦ ᩅᩣᨲᩮᩣ, ᨶᩮᩁᩩᨶᩣᩅ ᩈᨾᩣᨣᨲᩣ.

ᩅᩥᩈᩁᩩᨠ᩠ᨡᩮᩣ ᩅᩥᨿ ᨶᩥᨧ᩠ᨧᨹᩃᩣ, ᨶᩣᩈᨿᨶ᩠ᨲᩥ ᨥᩁᩮ ᨽᩮᩣᨣᩴ;

ᩁᨲᨶᨶ᩠ᨲᨠᩁᩥᨲ᩠ᨳᩥᨿᩮᩣ’’ᨲᩥ [ᨿᨳᩣ ᩈᩥᨡᩦ ᨶᨴᩦᩅᩣᩉᩮᩣ, ᩋᨶᩥᩃᩮᩣ ᨠᩣᨾᨧᩣᩁᩅᩣ;§ᨶᩮᩁᩪᩅ ᩋᩅᩥᩈᩮᩈᩣ ᨧ, ᩅᩥᩈᩁᩩᨠ᩠ᨡᩮᩣ ᩅᩥᨿ ᨶᩥᨧ᩠ᨧᨹᩃᩣ;§ᨶᩣᩈᨿᨶ᩠ᨲᩥ ᨥᩁᩮ ᨽᩮᩣᨣᩴ, ᩁᨲᨶᩣᨶᨶ᩠ᨲᨠᩁᩥᨲ᩠ᨳᩥ ᨿᩮᩣᨲᩥ; (ᩈᩦ. ᩈ᩠ᨿᩣ.)].

‘‘ᨧᨲ᩠ᨲᩣᩁᩥᨾᩣᨶᩥ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨿᩣᨶᩥ (ᩅᨲ᩠ᨳᩪᨶᩥ ᨠᩥᨧ᩠ᨧᩮ ᨩᩣᨲᩮ ᩋᨶᨲ᩠ᨳᨧᩁᩣᨶᩥ ᨽᩅᨶ᩠ᨲᩥ; ᨲᩣᨶᩥ) [( ) ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ ᨶ ᨴᩥᩔᨲᩥ] ᨸᩁᨠᩩᩃᩮ ᨶ ᩅᩣᩈᩮᨲᨻ᩠ᨻᩣᨶᩥ – ᨣᩮᩣᨱᩴ ᨵᩮᨶᩩᩴ ᨿᩣᨶᩴ ᨽᩁᩥᨿᩣ. ᨧᨲ᩠ᨲᩣᩁᩥ ᩑᨲᩣᨶᩥ ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᨵᨶᩣᨶᩥ [ᨿᩣᨶᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨥᩁᩣ ᨶ ᩅᩥᨸ᩠ᨸᩅᩣᩈᨿᩮ.

᪒᪙᪖.

‘ᨣᩮᩣᨱᩴ ¶ ᨵᩮᨶᩩᨬ᩠ᨧ ᨿᩣᨶᨬ᩠ᨧ, ᨽᩁᩥᨿᩴ ᨬᩣᨲᩥᨠᩩᩃᩮ ᨶ ᩅᩣᩈᨿᩮ;

ᨽᨬ᩠ᨩᨶ᩠ᨲᩥ ᩁᨳᩴ ᩋᨿᩣᨶᨠᩣ, ᩋᨲᩥᩅᩣᩉᩮᨶ ᩉᨶᨶ᩠ᨲᩥ ᨸᩩᨦ᩠ᨣᩅᩴ;

ᨴᩮᩣᩉᩮᨶ ᩉᨶᨶ᩠ᨲᩥ ᩅᨧ᩠ᨨᨠᩴ, ᨽᩁᩥᨿᩣ ᨬᩣᨲᩥᨠᩩᩃᩮ ᨸᨴᩩᩔᨲᩦ’’’ᨲᩥ.

‘‘ᨨ ᩍᨾᩣᨶᩥ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨿᩣᨶᩥ (ᩅᨲ᩠ᨳᩪᨶᩥ) [( ) ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ ᨶᩩ ᨴᩥᩔᨲᩥ] ᨠᩥᨧ᩠ᨧᩮ ᨩᩣᨲᩮ ᩋᨶᨲ᩠ᨳᨧᩁᩣᨶᩥ ᨽᩅᨶ᩠ᨲᩥ –

᪒᪙᪗.

‘ᩋᨣᩩᨱᩴ ᨵᨶᩩ ᨬᩣᨲᩥᨠᩩᩃᩮ ᨧ ᨽᩁᩥᨿᩣ, ᨸᩣᩁᩴ ᨶᩣᩅᩣ ᩋᨠ᩠ᨡᨽᨣ᩠ᨣᨬ᩠ᨧ ᨿᩣᨶᩴ;

ᨴᩪᩁᩮ ¶ ᨾᩥᨲ᩠ᨲᩮᩣ ᨸᩣᨸᩈᩉᩣᨿᨠᩮᩣ ᨧ, ᨠᩥᨧ᩠ᨧᩮ ᨩᩣᨲᩮ ᩋᨶᨲ᩠ᨳᨧᩁᩣᨶᩥ ᨽᩅ’’’ᨶ᩠ᨲᩥ.

‘‘ᩋᨭ᩠ᨮᩉᩥ ᨡᩃᩩ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨮᩣᨶᩮᩉᩥ ᩍᨲ᩠ᨳᩦ ᩈᩣᨾᩥᨠᩴ ᩋᩅᨩᩣᨶᩣᨲᩥ. ᨴᩃᩥᨴ᩠ᨴᨲᩣ, ᩌᨲᩩᩁᨲᩣ, ᨩᩥᨱ᩠ᨱᨲᩣ, ᩈᩩᩁᩣᩈᩮᩣᨱ᩠ᨯᨲᩣ, ᨾᩩᨴ᩠ᨵᨲᩣ, ᨸᨾᨲ᩠ᨲᨲᩣ, ᩈᨻ᩠ᨻᨠᩥᨧ᩠ᨧᩮᩈᩩ ᩋᨶᩩᩅᨲ᩠ᨲᨶᨲᩣ, ᩈᨻ᩠ᨻᨵᨶᩋᨶᩩᨸ᩠ᨸᨴᩣᨶᩮᨶ ¶ – ᩍᨾᩮᩉᩥ ᨡᩃᩩ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᩋᨭ᩠ᨮᩉᩥ ᨮᩣᨶᩮᩉᩥ ᩍᨲ᩠ᨳᩦ ᩈᩣᨾᩥᨠᩴ ᩋᩅᨩᩣᨶᩣᨲᩥ. ᨽᩅᨲᩥ ᨧ ᨸᨶᩩᨲ᩠ᨲᩁᩮᨲ᩠ᨳ ᩅᩣᨠ᩠ᨿᩴ –

᪒᪙᪘.

‘ᨴᩃᩥᨴ᩠ᨴᩴ ᩌᨲᩩᩁᨬ᩠ᨧᩣᨸᩥ, ᨩᩥᨱ᩠ᨱᨠᩴ ᩈᩩᩁᩈᩮᩣᨱ᩠ᨯᨠᩴ;

ᨸᨾᨲ᩠ᨲᩴ ᨾᩩᨴ᩠ᨵᨸᨲ᩠ᨲᨬ᩠ᨧ, ᩈᨻ᩠ᨻᨠᩥᨧ᩠ᨧᩮᩈᩩ [ᩁᨲ᩠ᨲᩴ ᨠᩥᨧ᩠ᨧᩮᩈᩩ (ᩈᩦ. ᨸᩦ.)] ᩉᩣᨸᨶᩴ;

ᩈᨻ᩠ᨻᨠᩣᨾᨸ᩠ᨸᨴᩣᨶᩮᨶ [ᩈᨻ᩠ᨻᨠᩣᨾᨸᨱᩥᨵᩣᨶᩮᨶ (ᩈ᩠ᨿᩣ)], ᩋᩅᨩᩣᨶᩣᨲᩥ [ᩋᩅᨩᩣᨶᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᩈᩣᨾᩥᨠ’’’ᨶ᩠ᨲᩥ.

‘‘ᨶᩅᩉᩥ ᨡᩃᩩ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨮᩣᨶᩮᩉᩥ ᩍᨲ᩠ᨳᩦ ᨸᨴᩮᩣᩈᨾᩣᩉᩁᨲᩥ. ᩌᩁᩣᨾᨣᨾᨶᩈᩦᩃᩣ ᨧ ᩉᩮᩣᨲᩥ, ᩏᨿ᩠ᨿᩣᨶᨣᨾᨶᩈᩦᩃᩣ ᨧ ᩉᩮᩣᨲᩥ, ᨶᨴᩦᨲᩥᨲ᩠ᨳᨣᨾᨶᩈᩦᩃᩣ ᨧ ᩉᩮᩣᨲᩥ, ᨬᩣᨲᩥᨠᩩᩃᨣᨾᨶᩈᩦᩃᩣ ᨧ ᩉᩮᩣᨲᩥ, ᨸᩁᨠᩩᩃᨣᨾᨶᩈᩦᩃᩣ ᨧ ᩉᩮᩣᨲᩥ, ᩌᨴᩣᩈᨴᩩᩔᨾᨱ᩠ᨯᨶᩣᨶᩩᨿᩮᩣᨣᨾᨶᩩᨿᩩᨲ᩠ᨲᩈᩦᩃᩣ ᨧ ᩉᩮᩣᨲᩥ, ᨾᨩ᩠ᨩᨸᩣᨿᩥᨶᩦ ᨧ ᩉᩮᩣᨲᩥ, ᨶᩥᩃ᩠ᩃᩮᩣᨠᨶᩈᩦᩃᩣ ᨧ ᩉᩮᩣᨲᩥ, ᩈᨴ᩠ᩅᩣᩁᨮᩣᨿᩥᨶᩦ [ᨸᨴ᩠ᩅᩣᩁᨭ᩠ᨮᩣᨿᩥᨶᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨧ ᩉᩮᩣᨲᩥ – ᩍᨾᩮᩉᩥ ᨡᩃᩩ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨶᩅᩉᩥ ᨮᩣᨶᩮᩉᩥ ᩍᨲ᩠ᨳᩦ ᨸᨴᩮᩣᩈᨾᩣᩉᩁᨲᩦᨲᩥ. ᨽᩅᨲᩥ ᨧ ᨸᨶᩩᨲ᩠ᨲᩁᩮᨲ᩠ᨳ ᩅᩣᨠ᩠ᨿᩴ –

᪒᪙᪙.

‘ᩌᩁᩣᨾᩈᩦᩃᩣ ᨧ [ᩌᩁᩣᨾᩈᩦᩃᩣ (ᩈᩦ. ᨸᩦ.)] ᩏᨿ᩠ᨿᩣᨶᩴ, ᨶᨴᩦ ᨬᩣᨲᩥ ᨸᩁᨠᩩᩃᩴ;

ᩌᨴᩣᩈᨴᩩᩔᨾᨱ᩠ᨯᨶᨾᨶᩩᨿᩩᨲ᩠ᨲᩣ, ᨿᩣ ¶ ᨧᩥᨲ᩠ᨳᩦ ᨾᨩ᩠ᨩᨸᩣᨿᩥᨶᩦ.

᪓᪐᪐.

‘ᨿᩣ ¶ ᨧ ᨶᩥᩃ᩠ᩃᩮᩣᨠᨶᩈᩦᩃᩣ, ᨿᩣ ᨧ ᩈᨴ᩠ᩅᩣᩁᨮᩣᨿᩥᨶᩦ;

ᨶᩅᩉᩮᨲᩮᩉᩥ ᨮᩣᨶᩮᩉᩥ, ᨸᨴᩮᩣᩈᨾᩣᩉᩁᨶ᩠ᨲᩥ ᩍᨲ᩠ᨳᩥᨿᩮᩣ’’’ᨲᩥ.

‘‘ᨧᨲ᩠ᨲᩣᩃᩦᩈᩣᨿ [ᨧᨲ᩠ᨲᩣᩃᩦᩈᩣᨿᩥ (ᨸᩦ. ᨠ.)] ᨡᩃᩩ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨮᩣᨶᩮᩉᩥ ᩍᨲ᩠ᨳᩦ ᨸᩩᩁᩥᩈᩴ ᩋᨧ᩠ᨧᩣᨧᩁᨲᩥ [ᩋᨧ᩠ᨧᩣᩅᨴᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)]. ᩅᩥᨩᨾ᩠ᨽᨲᩥ, ᩅᩥᨶᨾᨲᩥ, ᩅᩥᩃᩈᨲᩥ, ᩅᩥᩃᨩ᩠ᨩᨲᩥ, ᨶᨡᩮᨶ ᨶᨡᩴ ᨥᨭ᩠ᨭᩮᨲᩥ, ᨸᩣᨴᩮᨶ ᨸᩣᨴᩴ ᩋᨠ᩠ᨠᨾᨲᩥ, ᨠᨭ᩠ᨮᩮᨶ ᨸᨳᩅᩥᩴ ᩅᩥᩃᩥᨡᨲᩥ [ᩃᩥᨡᨲᩥ (ᩈᩦ. ᨸᩦ.)], ᨴᩣᩁᨠᩴ ᩏᩃ᩠ᩃᨦ᩠ᨥᨲᩥ ᩏᩃ᩠ᩃᨦ᩠ᨥᩣᨸᩮᨲᩥ [ᨴᩣᩁᨠᩴ ᩏᩃ᩠ᩃᨦ᩠ᨥᩮᨲᩥ ᩒᩃᨦ᩠ᨥᩮᨲᩥ (ᩈᩦ. ᨸᩦ.)], ᨠᩦᩊᨲᩥ ᨠᩦᩊᩣᨸᩮᨲᩥ, ᨧᩩᨾ᩠ᨻᨲᩥ ᨧᩩᨾ᩠ᨻᩣᨸᩮᨲᩥ, ᨽᩩᨬ᩠ᨩᨲᩥ ᨽᩩᨬ᩠ᨩᩣᨸᩮᨲᩥ, ᨴᨴᩣᨲᩥ, ᨿᩣᨧᨲᩥ, ᨠᨲᨾᨶᩩᨠᩁᩮᩣᨲᩥ, ᩏᨧ᩠ᨧᩴ ᨽᩣᩈᨲᩥ, ᨶᩦᨧᩴ ᨽᩣᩈᨲᩥ, ᩋᩅᩥᨧ᩠ᨧᩴ ᨽᩣᩈᨲᩥ, ᩅᩥᩅᩥᨧ᩠ᨧᩴ ᨽᩣᩈᨲᩥ, ᨶᨧ᩠ᨧᩮᨶ ᨣᩦᨲᩮᨶ ᩅᩣᨴᩥᨲᩮᨶ ᩁᩮᩣᨴᨶᩮᨶ [ᩁᩮᩣᨴᩥᨲᩮᨶ (ᩈᩦ. ᨸᩦ.)] ᩅᩥᩃᩈᩥᨲᩮᨶ ᩅᩥᨽᩪᩈᩥᨲᩮᨶ ᨩᨣ᩠ᨥᨲᩥ, ᨸᩮᨠ᩠ᨡᨲᩥ, ᨠᨭᩥᩴ ᨧᩣᩃᩮᨲᩥ, ᨣᩩᨿ᩠ᩉᨽᨱ᩠ᨯᨠᩴ ᩈᨬ᩠ᨧᩣᩃᩮᨲᩥ, ᩐᩁᩩᩴ ᩅᩥᩅᩁᨲᩥ, ᩐᩁᩩᩴ ᨸᩥᨴᩉᨲᩥ, ᨳᨶᩴ ᨴᩔᩮᨲᩥ, ᨠᨧ᩠ᨨᩴ ᨴᩔᩮᨲᩥ, ᨶᩣᨽᩥᩴ ᨴᩔᩮᨲᩥ, ᩋᨠ᩠ᨡᩥᩴ ᨶᩥᨡᨶᨲᩥ, ᨽᨾᩩᨠᩴ ᩏᨠ᩠ᨡᩥᨸᨲᩥ, ᩒᨭ᩠ᨮᩴ ᩏᨸᩃᩥᨡᨲᩥ [ᩒᨭ᩠ᨮᩴ ᨸᩃᩥᨡᨲᩥ ᨩᩥᩅ᩠ᩉᩴ ᨸᩃᩥᨡᨲᩥ (ᩈᩦ. ᨸᩦ.)], ᨩᩥᩅ᩠ᩉᩴ ᨶᩥᩃ᩠ᩃᩣᩃᩮᨲᩥ, ᨴᩩᩔᩴ ᨾᩩᨬ᩠ᨧᨲᩥ, ᨴᩩᩔᩴ ᨸᨭᩥᨻᨶ᩠ᨵᨲᩥ, ᩈᩥᩁᩈᩴ ᨾᩩᨬ᩠ᨧᨲᩥ, ᩈᩥᩁᩈᩴ ᨻᨶ᩠ᨵᨲᩥ – ᩍᨾᩮᩉᩥ ᨡᩃᩩ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨧᨲ᩠ᨲᩣᩃᩦᩈᩣᨿ ᨮᩣᨶᩮᩉᩥ ᩍᨲ᩠ᨳᩦ ᨸᩩᩁᩥᩈᩴ ᩋᨧ᩠ᨧᩣᨧᩁᨲᩥ.

‘‘ᨸᨬ᩠ᨧᩅᩦᩈᩣᨿ [ᨸᨬ᩠ᨧᩅᩦᩈᩣᩉᩥ (ᨸᩦ. ᨠ.)] ᨡᩃᩩ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨮᩣᨶᩮᩉᩥ ᩍᨲ᩠ᨳᩦ ᨸᨴᩩᨭ᩠ᨮᩣ ᩅᩮᨴᩥᨲᨻ᩠ᨻᩣ ᨽᩅᨲᩥ. ᩈᩣᨾᩥᨠᩔ ᨸᩅᩣᩈᩴ ᩅᨱ᩠ᨱᩮᨲᩥ, ᨸᩅᩩᨭ᩠ᨮᩴ ᨶ ¶ ᩈᩁᨲᩥ, ᩌᨣᨲᩴ ᨶᩣᨽᩥᨶᨶ᩠ᨴᨲᩥ, ᩋᩅᨱ᩠ᨱᩴ ᨲᩔ ᨽᨱᨲᩥ, ᩅᨱ᩠ᨱᩴ ¶ ᨲᩔ ᨶ ᨽᨱᨲᩥ, ᩋᨶᨲ᩠ᨳᩴ ᨲᩔ ᨧᩁᨲᩥ, ᩋᨲ᩠ᨳᩴ ᨲᩔ ᨶ ᨧᩁᨲᩥ, ᩋᨠᩥᨧ᩠ᨧᩴ ᨲᩔ ᨠᩁᩮᩣᨲᩥ, ᨠᩥᨧ᩠ᨧᩴ ᨲᩔ ᨶ ᨠᩁᩮᩣᨲᩥ, ᨸᩁᩥᨴᩉᩥᨲ᩠ᩅᩣ ᩈᨿᨲᩥ, ᨸᩁᨾ᩠ᨾᩩᨡᩦ ᨶᩥᨸᨩ᩠ᨩᨲᩥ, ᨸᩁᩥᩅᨲ᩠ᨲᨠᨩᩣᨲᩣ ᨡᩮᩣ ᨸᨶ ᩉᩮᩣᨲᩥ ᨠᩩᨦ᩠ᨠᩩᨾᩥᨿᨩᩣᨲᩣ, ᨴᩦᨥᩴ ᩋᩔᩈᨲᩥ, ᨴᩩᨠ᩠ᨡᩴ ᩅᩮᨴᨿᨲᩥ, ᩏᨧ᩠ᨧᩣᩁᨸᩔᩣᩅᩴ ᩋᨽᩥᨱ᩠ᩉᩴ ᨣᨧ᩠ᨨᨲᩥ, ᩅᩥᩃᩮᩣᨾᨾᩣᨧᩁᨲᩥ, ᨸᩁᨸᩩᩁᩥᩈᩈᨴ᩠ᨴᩴ ᩈᩩᨲ᩠ᩅᩣ ᨠᨱ᩠ᨱᩈᩮᩣᨲᩴ ᩅᩥᩅᩁᨾᩮᩣᨴᩉᨲᩥ [ᩅᩥᩅᩁᨲᩥ ᨠᨾᩮᩣᨴᩉᨲᩥ (ᨸᩦ.)], ᨶᩥᩉᨲᨽᩮᩣᨣᩣ ᨡᩮᩣ ᨸᨶ ᩉᩮᩣᨲᩥ, ᨸᨭᩥᩅᩥᩔᨠᩮᩉᩥ ᩈᨶ᩠ᨳᩅᩴ ᨠᩁᩮᩣᨲᩥ, ᨶᩥᨠ᩠ᨡᨶ᩠ᨲᨸᩣᨴᩣ ᨡᩮᩣ ᨸᨶ ᩉᩮᩣᨲᩥ, ᩅᩥᩈᩥᨡᩣᨶᩩᨧᩣᩁᩥᨶᩦ ᩋᨲᩥᨧᩣᩁᩥᨶᩦ ᨡᩮᩣ ᨸᨶ ᩉᩮᩣᨲᩥ, ᨶᩥᨧ᩠ᨧᩴ [ᨶᨲ᩠ᨳᩥ ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ] ᩈᩣᨾᩥᨠᩮ ᩋᨣᩣᩁᩅᩣ ᨸᨴᩩᨭ᩠ᨮᨾᨶᩈᨦ᩠ᨠᨸ᩠ᨸᩣ, ᩋᨽᩥᨱ᩠ᩉᩴ ᨴ᩠ᩅᩣᩁᩮ ᨲᩥᨭ᩠ᨮᨲᩥ, ᨠᨧ᩠ᨨᩣᨶᩥ ᩋᨦ᩠ᨣᩣᨶᩥ ᨳᨶᩣᨶᩥ ᨴᩔᩮᨲᩥ, ᨴᩥᩈᩮᩣᨴᩥᩈᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᨸᩮᨠ᩠ᨡᨲᩥ – ᩍᨾᩮᩉᩥ ᨡᩃᩩ, ᩈᨾ᩠ᨾ ᨸᩩᨱ᩠ᨱᨾᩩᨡ, ᨸᨬ᩠ᨧᩅᩦᩈᩣᨿ [ᨸᨬ᩠ᨧᩅᩦᩈᩣᩉᩥ (ᨠ.)] ᨮᩣᨶᩮᩉᩥ ᩍᨲ᩠ᨳᩦ ᨸᨴᩩᨭ᩠ᨮᩣ ᩅᩮᨴᩥᨲᨻ᩠ᨻᩣ ᨽᩅᨲᩥ. ᨽᩅᨲᩥ ᨧ ᨸᨶᩩᨲ᩠ᨲᩁᩮᨲ᩠ᨳ ᩅᩣᨠ᩠ᨿᩴ –

᪓᪐᪑.

‘ᨸᩅᩣᩈᩴ ¶ ᨲᩔ ᩅᨱ᩠ᨱᩮᨲᩥ, ᨣᨲᩴ ᨲᩔ ᨶ ᩈᩮᩣᨧᨲᩥ [ᨸᩅᩣᩈ’ᨾᩔ ᩅᨱ᩠ᨱᩮᨲᩥ ᨣᨲᩥᩴ ᨶᩣᨶᩩᩈᩮᩣᨧᨲᩥ (ᩈᩦ. ᨸᩦ.)];

ᨴᩥᩈ᩠ᩅᩣᨶ ᨸᨲᩥᨾᩣᨣᨲᩴ [ᨴᩥᩈ᩠ᩅᩣᨸᨲᩥᩴ ᩌᨣᨲᩴ (ᩈᩦ. ᨸᩦ.)] ᨶᩣᨽᩥᨶᨶ᩠ᨴᨲᩥ;

ᨽᨲ᩠ᨲᩣᩁᩅᨱ᩠ᨱᩴ ᨶ ᨠᨴᩣᨧᩥ ᨽᩣᩈᨲᩥ, ᩑᨲᩮ ᨸᨴᩩᨭ᩠ᨮᩣᨿ ᨽᩅᨶ᩠ᨲᩥ ᩃᨠ᩠ᨡᨱᩣ.

᪓᪐᪒.

‘ᩋᨶᨲ᩠ᨳᩴ ᨲᩔ ᨧᩁᨲᩥ ᩋᩈᨬ᩠ᨬᨲᩣ, ᩋᨲ᩠ᨳᨬ᩠ᨧ ᩉᩣᨸᩮᨲᩥ ᩋᨠᩥᨧ᩠ᨧᨠᩣᩁᩥᨶᩦ;

ᨸᩁᩥᨴᩉᩥᨲ᩠ᩅᩣ ¶ ᩈᨿᨲᩥ ᨸᩁᨾ᩠ᨾᩩᨡᩦ, ᩑᨲᩮ ᨸᨴᩩᨭ᩠ᨮᩣᨿ ᨽᩅᨶ᩠ᨲᩥ ᩃᨠ᩠ᨡᨱᩣ.

᪓᪐᪓.

‘ᨸᩁᩥᩅᨲ᩠ᨲᨩᩣᨲᩣ ᨧ [ᨸᩁᩣᩅᨲ᩠ᨲᨠᨩᩣᨲᩣ ᨧ (ᩈᩦ.)] ᨽᩅᨲᩥ ᨠᩩᨦ᩠ᨠᩩᨾᩦ, ᨴᩦᨥᨬ᩠ᨧ ᩋᩔᩈᨲᩥ ᨴᩩᨠ᩠ᨡᩅᩮᨴᩥᨶᩦ;

ᩏᨧ᩠ᨧᩣᩁᨸᩔᩣᩅᨾᨽᩥᨱ᩠ᩉᩴ ᨣᨧ᩠ᨨᨲᩥ, ᩑᨲᩮ ᨸᨴᩩᨭ᩠ᨮᩣᨿ ᨽᩅᨶ᩠ᨲᩥ ᩃᨠ᩠ᨡᨱᩣ.

᪓᪐᪔.

‘‘ᩅᩥᩃᩮᩣᨾᨾᩣᨧᩁᨲᩥ ᩋᨠᩥᨧ᩠ᨧᨠᩣᩁᩥᨶᩦ, ᩈᨴ᩠ᨴᩴ ᨶᩥᩈᩣᨾᩮᨲᩥ ᨸᩁᩔ ᨽᩣᩈᨲᩮᩣ;

ᨶᩥᩉᨲᨽᩮᩣᨣᩣ ᨧ ᨠᩁᩮᩣᨲᩥ ᩈᨶ᩠ᨳᩅᩴ, ᩑᨲᩮ ᨸᨴᩩᨭ᩠ᨮᩣᨿ ᨽᩅᨶ᩠ᨲᩥ ᩃᨠ᩠ᨡᨱᩣ.

᪓᪐᪕.

‘ᨠᩥᨧ᩠ᨨᩮᨶ ᩃᨴ᩠ᨵᩴ ᨠᩈᩥᩁᩣᨽᨲᩴ [ᨠᩈᩥᩁᩮᨶᩣᨽᨲᩴ (ᩈᩦ.)] ᨵᨶᩴ, ᩅᩥᨲ᩠ᨲᩴ ᩅᩥᨶᩣᩈᩮᨲᩥ ᨴᩩᨠ᩠ᨡᩮᨶ ᩈᨾ᩠ᨽᨲᩴ;

ᨸᨭᩥᩅᩥᩔᨠᩮᩉᩥ ᨧ ᨠᩁᩮᩣᨲᩥ ᩈᨶ᩠ᨳᩅᩴ, ᩑᨲᩮ ᨸᨴᩩᨭ᩠ᨮᩣᨿ ᨽᩅᨶ᩠ᨲᩥ ᩃᨠ᩠ᨡᨱᩣ.

᪓᪐᪖.

‘ᨶᩥᨠ᩠ᨡᨶ᩠ᨲᨸᩣᨴᩣ ᩅᩥᩈᩥᨡᩣᨶᩩᨧᩣᩁᩥᨶᩦ, ᨶᩥᨧ᩠ᨧᨬ᩠ᨧ ᩈᩣᨾᩥᨾ᩠ᩉᩥ [ᨶᩥᨧ᩠ᨧᩴ ᩈᩈᩣᨾᩥᨾ᩠ᩉᩥ (ᨸᩦ. ᨠ.)] ᨸᨴᩩᨭ᩠ᨮᨾᩣᨶᩈᩣ;

ᩋᨲᩥᨧᩣᩁᩥᨶᩦ ᩉᩮᩣᨲᩥ ᩋᨸᩮᨲᨣᩣᩁᩅᩣ [ᨲᨳᩮᩅ’ᨣᩣᩁᩅᩣ (ᩈᩦ. ᨸᩦ.)], ᩑᨲᩮ ᨸᨴᩩᨭ᩠ᨮᩣᨿ ᨽᩅᨶ᩠ᨲᩥ ᩃᨠ᩠ᨡᨱᩣ.

᪓᪐᪗.

‘ᩋᨽᩥᨠ᩠ᨡᨱᩴ ¶ ᨲᩥᨭ᩠ᨮᨲᩥ ᨴ᩠ᩅᩣᩁᨾᩪᩃᩮ, ᨳᨶᩣᨶᩥ ᨠᨧ᩠ᨨᩣᨶᩥ ᨧ ᨴᩔᨿᨶ᩠ᨲᩦ;

ᨴᩥᩈᩮᩣᨴᩥᩈᩴ ¶ ᨸᩮᨠ᩠ᨡᨲᩥ ᨽᨶ᩠ᨲᨧᩥᨲ᩠ᨲᩣ, ᩑᨲᩮ ᨸᨴᩩᨭ᩠ᨮᩣᨿ ᨽᩅᨶ᩠ᨲᩥ ᩃᨠ᩠ᨡᨱᩣ.

᪓᪐᪘.

‘ᩈᨻ᩠ᨻᩣ ᨶᨴᩦ ᩅᨦ᩠ᨠᨣᨲᩦ [ᩅᨦ᩠ᨠᨶᨴᩦ (ᨠ.)], ᩈᨻ᩠ᨻᩮ ᨠᨭ᩠ᨮᨾᨿᩣ ᩅᨶᩣ;

ᩈᨻ᩠ᨻᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨠᩁᩮ ᨸᩣᨸᩴ, ᩃᨽᨾᩣᨶᩮ ᨶᩥᩅᩣᨲᨠᩮ.

᪓᪐᪙.

‘ᩈᨧᩮ ᩃᨽᩮᨳ ᨡᨱᩴ ᩅᩣ ᩁᩉᩮᩣ ᩅᩣ, ᨶᩥᩅᩣᨲᨠᩴ ᩅᩣᨸᩥ ᩃᨽᩮᨳ ᨲᩣᨴᩥᩈᩴ;

ᩈᨻ᩠ᨻᩣᩅ ᩍᨲ᩠ᨳᩦ ᨠᨿᩥᩁᩩᩴ ᨶᩩ [ᨠᩁᩮᨿ᩠ᨿᩩ ᨶᩮᩣ (ᩈᩦ.), ᨠᩁᩮᨿ᩠ᨿᩩᩴ ᨶᩮᩣ (ᨸᩦ.)] ᨸᩣᨸᩴ, ᩋᨬ᩠ᨬᩴ ᩋᩃᨲ᩠ᨳ [ᩋᩃᨴ᩠ᨵᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᨸᩦᨮᩈᨸ᩠ᨸᩥᨶᩣᨸᩥ ᩈᨴ᩠ᨵᩥᩴ.

᪓᪑᪐.

‘‘ᨶᩁᩣᨶᨾᩣᩁᩣᨾᨠᩁᩣᩈᩩ ¶ ᨶᩣᩁᩥᩈᩩ, ᩋᨶᩮᨠᨧᩥᨲ᩠ᨲᩣᩈᩩ ᩋᨶᩥᨣ᩠ᨣᩉᩣᩈᩩ ᨧ;

ᩈᨻ᩠ᨻᨲ᩠ᨳ ᨶᩣᨸᩦᨲᩥᨠᩁᩣᨸᩥ [ᩈᨻ᩠ᨻ’ᨲ᩠ᨲᨶᩣ’ᨸᩦᨲᩥᨠᩣᩁᩣᨸᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨧᩮ ᩈᩥᨿᩣ [ᩈᩥᨿᩩᩴ (ᩈ᩠ᨿᩣ.)], ᨶ ᩅᩥᩔᩈᩮ ᨲᩥᨲ᩠ᨳᩈᨾᩣ ᩉᩥ ᨶᩣᩁᩥᨿᩮᩣ’’ᨲᩥ.

᪓᪑᪑.

‘ᨿᩴ ᩅᩮ [ᨿᨬ᩠ᨧ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨴᩥᩈ᩠ᩅᩣ ᨠᨱ᩠ᨯᩁᩦᨠᩥᨶ᩠ᨶᩁᩣᨶᩴ [ᨠᩥᨶ᩠ᨶᩁᨠᩥᨶ᩠ᨶᩁᩦᨶᩴ (ᩈ᩠ᨿᩣ.), ᨠᩥᨶ᩠ᨶᩁᩦᨠᩥᨶ᩠ᨶᩁᩣᨶᩴ (ᨠ.)], ᩈᨻ᩠ᨻᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨶ ᩁᨾᨶ᩠ᨲᩥ ᩋᨣᩣᩁᩮ;

ᨲᩴ ᨲᩣᨴᩥᩈᩴ ᨾᨧ᩠ᨧᩴ ᨧᨩᩥᨲ᩠ᩅᩣ ᨽᩁᩥᨿᩣ, ᩋᨬ᩠ᨬᩴ ᨴᩥᩈ᩠ᩅᩣ ᨸᩩᩁᩥᩈᩴ ᨸᩦᨮᩈᨸ᩠ᨸᩥᩴ.

᪓᪑᪒.

‘ᨻᨠᩔ ᨧ ᨻᩣᩅᩁᩥᨠᩔ [ᨸᩣᩅᩣᩁᩥᨠᩔ (ᩈᩦ.), ᨻᩣᩅᩁᩥᨿᩔ (ᩈ᩠ᨿᩣ.)] ᩁᨬ᩠ᨬᩮᩣ, ᩋᨧ᩠ᨧᨶ᩠ᨲᨠᩣᨾᩣᨶᩩᨣᨲᩔ ᨽᩁᩥᨿᩣ;

ᩋᩅᩣᨧᩁᩦ [ᩋᨧ᩠ᨧᩣᨧᩁᩥ (ᩈ᩠ᨿᩣ.), ᩋᨶᩣᨧᩁᩥ (ᨠ.)] ᨸᨭ᩠ᨮᩅᩈᩣᨶᩩᨣᩔ [ᨻᨴ᩠ᨵᩅᩈᩣᨶᩩᨣᩔ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨸᨲ᩠ᨲᩅᩈᩣᨶᩩᨣᨲᩔ (ᨠ.)], ᨠᩴ ᩅᩣᨸᩥ ᩍᨲ᩠ᨳᩦ ᨶᩣᨲᩥᨧᩁᩮ ᨲᨴᨬ᩠ᨬᩴ.

᪓᪑᪓.

‘ᨸᩥᨦ᩠ᨣᩥᨿᩣᨶᩦ ¶ ¶ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩥᩔᩁᩔ, ᩁᨬ᩠ᨬᩮᩣ ᨸᩥᨿᩣ ᨻᩕᩉ᩠ᨾᨴᨲ᩠ᨲᩔ ᨽᩁᩥᨿᩣ;

ᩋᩅᩣᨧᩁᩦ ᨸᨭ᩠ᨮᩅᩈᩣᨶᩩᨣᩔ, ᨲᩴ ᩅᩣᨸᩥ ᩈᩣ ᨶᩣᨩ᩠ᨫᨣᩣ ᨠᩣᨾᨠᩣᨾᩥᨶᩦ.

᪓᪑᪔.

‘ᩃᩩᨴ᩠ᨵᩣᨶᩴ [ᨡᩩᨴ᩠ᨴᩣᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩃᩉᩩᨧᩥᨲ᩠ᨲᩣᨶᩴ, ᩋᨠᨲᨬ᩠ᨬᩪᨶ ᨴᩩᨻ᩠ᨽᩥᨶᩴ;

ᨶᩣᨴᩮᩅᩈᨲ᩠ᨲᩮᩣ ᨸᩩᩁᩥᩈᩮᩣ, ᨳᩦᨶᩴ ᩈᨴ᩠ᨵᩣᨲᩩᨾᩁᩉᨲᩥ.

᪓᪑᪕.

‘ᨶ ᨲᩣ ᨸᨩᩣᨶᨶ᩠ᨲᩥ ᨠᨲᩴ ᨶ ᨠᩥᨧ᩠ᨧᩴ, ᨶ ᨾᩣᨲᩁᩴ ᨸᩥᨲᩁᩴ ᨽᩣᨲᩁᩴ ᩅᩣ;

ᩋᨶᩁᩥᨿᩣ ᩈᨾᨲᩥᨠ᩠ᨠᨶ᩠ᨲᨵᨾ᩠ᨾᩣ, ᩈᩔᩮᩅ ᨧᩥᨲ᩠ᨲᩔ ᩅᩈᩴ ᩅᨩᨶ᩠ᨲᩥ.

᪓᪑᪖.

‘ᨧᩥᩁᩣᨶᩩᩅᩩᨭ᩠ᨮᨾ᩠ᨸᩥ [ᨧᩥᩁᩣᨶᩩᩅᩩᨲ᩠ᨳᨾ᩠ᨸᩥ (ᩈᩦ. ᨸᩦ.)] ᨸᩥᨿᩴ ᨾᨶᩣᨸᩴ, ᩋᨶᩩᨠᨾ᩠ᨸᨠᩴ ᨸᩣᨱᩈᨾᨾ᩠ᨸᩥ ᨽᨲ᩠ᨲᩩᩴ [ᩈᨶ᩠ᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᩌᩅᩣᩈᩩ ᨠᩥᨧ᩠ᨧᩮᩈᩩ ᨧ ᨶᩴ ᨩᩉᨶ᩠ᨲᩥ, ᨲᩈ᩠ᨾᩣᩉᨾᩥᨲ᩠ᨳᩦᨶᩴ ᨶ ᩅᩥᩔᩈᩣᨾᩥ.

᪓᪑᪗.

‘ᨳᩦᨶᨬ᩠ᩉᩥ ᨧᩥᨲ᩠ᨲᩴ ᨿᨳᩣ ᩅᩣᨶᩁᩔ, ᨠᨶ᩠ᨶᨸ᩠ᨸᨠᨶ᩠ᨶᩴ ᨿᨳᩣ ᩁᩩᨠ᩠ᨡᨨᩣᨿᩣ;

ᨧᩃᩣᨧᩃᩴ ᩉᨴᨿᨾᩥᨲ᩠ᨳᩥᨿᩣᨶᩴ, ᨧᨠ᩠ᨠᩔ ᨶᩮᨾᩥ ᩅᩥᨿ ᨸᩁᩥᩅᨲ᩠ᨲᨲᩥ.

᪓᪑᪘.

‘ᨿᨴᩣ ᨲᩣ ᨸᩔᨶ᩠ᨲᩥ ᩈᨾᩮᨠ᩠ᨡᨾᩣᨶᩣ, ᩌᨴᩮᨿ᩠ᨿᩁᩪᨸᩴ ᨸᩩᩁᩥᩈᩔ ᩅᩥᨲ᩠ᨲᩴ;

ᩈᨱ᩠ᩉᩣᩉᩥ ¶ ᩅᩣᨧᩣᩉᩥ ᨶᨿᨶ᩠ᨲᩥ ᨾᩮᨶᩴ, ᨠᨾ᩠ᨻᩮᩣᨩᨠᩣ ᨩᩃᨩᩮᨶᩮᩅ ᩋᩔᩴ.

᪓᪑᪙.

‘ᨿᨴᩣ ᨶ ᨸᩔᨶ᩠ᨲᩥ ᩈᨾᩮᨠ᩠ᨡᨾᩣᨶᩣ, ᩌᨴᩮᨿ᩠ᨿᩁᩪᨸᩴ ᨸᩩᩁᩥᩈᩔ ᩅᩥᨲ᩠ᨲᩴ;

ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨶᩴ ᨸᩁᩥᩅᨩ᩠ᨩᨿᨶ᩠ᨲᩥ, ᨲᩥᨱ᩠ᨱᩮᩣ ᨶᨴᩦᨸᩣᩁᨣᨲᩮᩣᩅ ᨠᩩᩃ᩠ᩃᩴ.

᪓᪒᪐.

‘ᩈᩥᩃᩮᩈᩪᨸᨾᩣᩴ ¶ ᩈᩥᨡᩥᩁᩥᩅ ᩈᨻ᩠ᨻᨽᨠ᩠ᨡᩣ, ᨲᩥᨠ᩠ᨡᨾᩣᨿᩣ ᨶᨴᩦᩁᩥᩅ ᩈᩦᨥᩈᩮᩣᨲᩣ;

ᩈᩮᩅᨶ᩠ᨲᩥ ᩉᩮᨲᩣ ᨸᩥᨿᨾᨸ᩠ᨸᩥᨿᨬ᩠ᨧ, ᨶᩣᩅᩣ ᨿᨳᩣ ᩒᩁᨠᩪᩃᩴ [ᩒᩁᨠᩩᩃᩴ (ᩈᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ᨸᩁᨬ᩠ᨧ.

᪓᪒᪑.

‘ᨶ ᨲᩣ ᩑᨠᩔ ᨶ ᨴ᩠ᩅᩥᨶ᩠ᨶᩴ, ᩌᨸᨱᩮᩣᩅ ᨸᩈᩣᩁᩥᨲᩮᩣ;

ᨿᩮᩣ ᨲᩣ ᨾᨿ᩠ᩉᨶ᩠ᨲᩥ ᨾᨬ᩠ᨬᩮᨿ᩠ᨿ, ᩅᩣᨲᩴ ᨩᩣᩃᩮᨶ ᨻᩣᨵᨿᩮ [ᨻᨶ᩠ᨵᨿᩮ (ᩈ᩠ᨿᩣ. ᨠ.)].

᪓᪒᪒.

‘ᨿᨳᩣ ᨶᨴᩦ ᨧ ᨸᨶ᩠ᨳᩮᩣ ᨧ, ᨸᩣᨶᩣᨣᩣᩁᩴ ᩈᨽᩣ ᨸᨸᩣ;

ᩑᩅᩴ ᩃᩮᩣᨠᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨶᩣᨾ, ᩅᩮᩃᩣ ᨲᩣᩈᩴ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ [ᨠᩮᩈᩩᨧᩥ ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ ᩍᨾᩥᩔᩣ ᨣᩣᨳᩣᨿ ᨸᩩᨻ᩠ᨻᨴ᩠ᨵᩣᨸᩁᨴ᩠ᨵᩴ ᩅᩥᨸᩁᩥᨿᩣᨿᩮᨶ ᨴᩥᩔᨲᩥ].

᪓᪒᪓.

‘ᨥᨲᩣᩈᨶᩈᨾᩣ ᩑᨲᩣ, ᨠᨱ᩠ᩉᩈᨸ᩠ᨸᩈᩥᩁᩪᨸᨾᩣ;

ᨣᩣᩅᩮᩣ ᨻᩉᩥᨲᩥᨱᩔᩮᩅ, ᩒᨾᩈᨶ᩠ᨲᩥ ᩅᩁᩴ ᩅᩁᩴ.

᪓᪒᪔.

‘ᨥᨲᩣᩈᨶᩴ ᨠᩩᨬ᩠ᨩᩁᩴ ᨠᨱ᩠ᩉᩈᨸ᩠ᨸᩴ, ᨾᩩᨴ᩠ᨵᩣᨽᩥᩈᩥᨲ᩠ᨲᩴ ᨸᨾᨴᩣ ᨧ ᩈᨻ᩠ᨻᩣ;

ᩑᨲᩮ ᨶᩁᩮᩣ [ᩑᨲᩮᨶ ᩈᩮᩣ (ᨸᩦ.)] ᨶᩥᨧ᩠ᨧᨿᨲᩮᩣ [ᨶᩥᨧ᩠ᨧᨿᨲ᩠ᨲᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᨽᨩᩮᨳ, ᨲᩮᩈᩴ ᩉᩅᩮ ᨴᩩᨻ᩠ᨻᩥᨴᩩ ᩈᨻ᩠ᨻᨽᩣᩅᩮᩣ [ᩈᨧ᩠ᨧᨽᩣᩅᩮᩣ (ᩈ᩠ᨿᩣ.)].

᪓᪒᪕.

‘ᨶᨧ᩠ᨧᨶ᩠ᨲᩅᨱ᩠ᨱᩣ ¶ ¶ ᨶ ᨻᩉᩪᨶᩴ ᨠᨶ᩠ᨲᩣ, ᨶ ᨴᨠ᩠ᨡᩥᨱᩣ ᨸᨾᨴᩣ ᩈᩮᩅᩥᨲᨻ᩠ᨻᩣ;

ᨶ ᨸᩁᩔ ᨽᩁᩥᨿᩣ ᨶ ᨵᨶᩔ ᩉᩮᨲᩩ, ᩑᨲᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨸᨬ᩠ᨧ ᨶ ᩈᩮᩅᩥᨲᨻ᩠ᨻᩣ’’’.

ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᩌᨶᨶ᩠ᨴᩮᩣ ᨣᩥᨩ᩠ᨫᩁᩣᨩᩣ ᨠᩩᨱᩣᩃᩔ ᩈᨠᩩᨱᩔ ᩌᨴᩥᨾᨩ᩠ᨫᨠᨳᩣᨸᩁᩥᨿᩮᩣᩈᩣᨶᩴ [ᩌᨴᩥᨾᨩ᩠ᨫᨣᩣᨳᩣᨸᩁᩥᨿᩮᩣᩈᩣᨶᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᨲᩣᨿᩴ ᩅᩮᩃᩣᨿᩴ ᩍᨾᩣ ᨣᩣᨳᩣᨿᩮᩣ ᩋᨽᩣᩈᩥ –

᪓᪒᪖.

‘‘ᨸᩩᨱ᩠ᨱᨾ᩠ᨸᩥ ᨧᩮᨾᩴ ᨸᨳᩅᩥᩴ ᨵᨶᩮᨶ, ᨴᨩ᩠ᨩᩥᨲ᩠ᨳᩥᨿᩣ ᨸᩩᩁᩥᩈᩮᩣ ᩈᨾ᩠ᨾᨲᩣᨿ;

ᩃᨴ᩠ᨵᩣ ᨡᨱᩴ ᩋᨲᩥᨾᨬ᩠ᨬᩮᨿ᩠ᨿ ᨲᨾ᩠ᨸᩥ, ᨲᩣᩈᩴ ᩅᩈᩴ ᩋᩈᨲᩦᨶᩴ ᨶ ᨣᨧ᩠ᨨᩮ.

᪓᪒᪗.

‘‘ᩏᨭ᩠ᨮᩣᩉᨠᩴ ¶ ᨧᩮᨸᩥ ᩋᩃᩦᨶᩅᩩᨲ᩠ᨲᩥᩴ, ᨠᩮᩣᨾᩣᩁᨽᨲ᩠ᨲᩣᩁᩴ ᨸᩥᨿᩴ ᨾᨶᩣᨸᩴ;

ᩌᩅᩣᩈᩩ ᨠᩥᨧ᩠ᨧᩮᩈᩩ ᨧ ᨶᩴ ᨩᩉᨶ᩠ᨲᩥ, ᨲᩈ᩠ᨾᩣᩉᨾᩥᨲ᩠ᨳᩦᨶᩴ [ᨲᩈ᩠ᨾᩣ ᩉᩥ ᩍᨲ᩠ᨳᩦᨶᩴ (ᩈᩦ. ᨸᩦ.)] ᨶ ᩅᩥᩔᩈᩣᨾᩥ.

᪓᪒᪘.

‘‘ᨶ ᩅᩥᩔᩈᩮ ᩍᨧ᩠ᨨᨲᩥ ᨾᨶ᩠ᨲᩥ ᨸᩮᩣᩈᩮᩣ, ᨶ ᩅᩥᩔᩈᩮ ᩁᩮᩣᨴᨲᩥ ᨾᩮ ᩈᨠᩣᩈᩮ;

ᩈᩮᩅᨶ᩠ᨲᩥ ᩉᩮᨲᩣ ᨸᩥᨿᨾᨸ᩠ᨸᩥᨿᨬ᩠ᨧ, ᨶᩣᩅᩣ ᨿᨳᩣ ᩒᩁᨠᩪᩃᩴ ᨸᩁᨬ᩠ᨧ.

᪓᪒᪙.

‘‘ᨶ ᩅᩥᩔᩈᩮ ᩈᩣᨡᨸᩩᩁᩣᨱᩈᨶ᩠ᨳᨲᩴ, ᨶ ¶ ᩅᩥᩔᩈᩮ ᨾᩥᨲ᩠ᨲᨸᩩᩁᩣᨱᨧᩮᩣᩁᩴ;

ᨶ ᩅᩥᩔᩈᩮ ᩁᩣᨩᩣᨶᩴ ᩈᨡᩣ [ᩁᩣᨩᩣ ᩈᨡᩣ (ᩈᩦ. ᨸᩦ.)] ᨾᨾᨶ᩠ᨲᩥ, ᨶ ᩅᩥᩔᩈᩮ ᩍᨲ᩠ᨳᩥ ᨴᩈᨶ᩠ᨶ ᨾᩣᨲᩁᩴ.

᪓᪓᪐.

‘‘ᨶ ᩅᩥᩔᩈᩮ ᩁᩣᨾᨠᩁᩣᩈᩩ ᨶᩣᩁᩥᩈᩩ, ᩋᨧ᩠ᨧᨶ᩠ᨲᩈᩦᩃᩣᩈᩩ ᩋᩈᨬ᩠ᨬᨲᩣᩈᩩ;

ᩋᨧ᩠ᨧᨶ᩠ᨲᨸᩮᨾᩣᨶᩩᨣᨲᩔ ᨽᩁᩥᨿᩣ, ᨶ ᩅᩥᩔᩈᩮ ᨲᩥᨲ᩠ᨳᩈᨾᩣ ᩉᩥ ᨶᩣᩁᩥᨿᩮᩣ.

᪓᪓᪑.

‘‘ᩉᨶᩮᨿ᩠ᨿᩩᩴ ᨨᩥᨶ᩠ᨴᩮᨿ᩠ᨿᩩᩴ ᨨᩮᨴᩣᨸᩮᨿ᩠ᨿᩩᨾ᩠ᨸᩥ [ᩉᨶᩮᨿ᩠ᨿᩩ ᨨᩥᨶ᩠ᨴᩮᨿ᩠ᨿᩩᩴᨸᩥ ᨨᨴᨿᩮᨿ᩠ᨿᩩᩴ (ᩈᩦ. ᨸᩦ.), ᩉᨶᩮᨿ᩠ᨿᩩᩴᨸᩥ ᨨᩥᨶ᩠ᨴᩮᨿ᩠ᨿᩩᩴᨸᩥ ᨨᩮᨴᩣᨸᩮᨿ᩠ᨿᩩᩴᨸᩥ (ᩈ᩠ᨿᩣ.)], ᨠᨱ᩠ᨮᩮᨸᩥ [ᨠᨱ᩠ᨮᨾ᩠ᨸᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨨᩮᨲ᩠ᩅᩣ ᩁᩩᨵᩥᩁᩴ ᨸᩥᩅᩮᨿ᩠ᨿᩩᩴ;

ᨾᩣ ᨴᩦᨶᨠᩣᨾᩣᩈᩩ ᩋᩈᨬ᩠ᨬᨲᩣᩈᩩ, ᨽᩣᩅᩴ ᨠᩁᩮ ᨣᨦ᩠ᨣᨲᩥᨲ᩠ᨳᩪᨸᨾᩣᩈᩩ.

᪓᪓᪒.

‘‘ᨾᩩᩈᩣ ᨲᩣᩈᩴ ᨿᨳᩣ ᩈᨧ᩠ᨧᩴ, ᩈᨧ᩠ᨧᩴ ᨲᩣᩈᩴ ᨿᨳᩣ ᨾᩩᩈᩣ;

ᨣᩣᩅᩮᩣ ᨻᩉᩥᨲᩥᨱᩔᩮᩅ, ᩒᨾᩈᨶ᩠ᨲᩥ ᩅᩁᩴ ᩅᩁᩴ.

᪓᪓᪓.

‘‘ᨣᨲᩮᨶᩮᨲᩣ ᨸᩃᩮᩣᨽᩮᨶ᩠ᨲᩥ, ᨸᩮᨠ᩠ᨡᩥᨲᩮᨶ ᨾ᩠ᩉᩥᨲᩮᨶ ᨧ;

ᩋᨳᩮᩣᨸᩥ ᨴᩩᨶ᩠ᨶᩥᩅᨲ᩠ᨳᩮᨶ, ᨾᨬ᩠ᨩᩩᨶᩣ ᨽᨱᩥᨲᩮᨶ ᨧ.

᪓᪓᪔.

‘‘ᨧᩮᩣᩁᩥᨿᩮᩣ ᨠᨳᩥᨶᩣ [ᨠᨮᩥᨶᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩉᩮᨲᩣ, ᩅᩣᩊᩣ ᨧ ᩃᨸᩈᨠ᩠ᨡᩁᩣ;

ᨶ ᨲᩣ ᨠᩥᨬ᩠ᨧᩥ ᨶ ᨩᩣᨶᨶ᩠ᨲᩥ, ᨿᩴ ᨾᨶᩩᩔᩮᩈᩩ ᩅᨬ᩠ᨧᨶᩴ.

᪓᪓᪕.

‘‘ᩋᩈᩣ ¶ ᩃᩮᩣᨠᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨶᩣᨾ, ᩅᩮᩃᩣ ᨲᩣᩈᩴ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᩈᩣᩁᨲ᩠ᨲᩣ ᨧ ᨸᨣᨻ᩠ᨽᩣ ᨧ, ᩈᩥᨡᩦ ᩈᨻ᩠ᨻᨥᩈᩮᩣ ᨿᨳᩣ.

᪓᪓᪖.

‘‘ᨶᨲ᩠ᨳᩥᨲ᩠ᨳᩦᨶᩴ ¶ ᨸᩥᨿᩮᩣ ᨶᩣᨾ, ᩋᨸ᩠ᨸᩥᨿᩮᩣᨸᩥ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᩈᩮᩅᨶ᩠ᨲᩥ ᩉᩮᨲᩣ ᨸᩥᨿᨾᨸ᩠ᨸᩥᨿᨬ᩠ᨧ, ᨶᩣᩅᩣ ᨿᨳᩣ ᩒᩁᨠᩪᩃᩴ ᨸᩁᨬ᩠ᨧ.

᪓᪓᪗.

‘‘ᨶᨲ᩠ᨳᩥᨲ᩠ᨳᩦᨶᩴ ᨸᩥᨿᩮᩣ ᨶᩣᨾ, ᩋᨸ᩠ᨸᩥᨿᩮᩣᨸᩥ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᨵᨶᨲ᩠ᨲᩣ [ᨵᨶᨲ᩠ᨳᩣ (ᩈ᩠ᨿᩣ.)] ᨸᨭᩥᩅᩃ᩠ᩃᨶ᩠ᨲᩥ, ᩃᨲᩣᩅ ᨴᩩᨾᨶᩥᩔᩥᨲᩣ.

᪓᪓᪘.

‘‘ᩉᨲ᩠ᨳᩥᨻᨶ᩠ᨵᩴ ¶ ᩋᩔᨻᨶ᩠ᨵᩴ, ᨣᩮᩣᨸᩩᩁᩥᩈᨬ᩠ᨧ ᨾᨱ᩠ᨯᩃᩴ [ᨧᨱ᩠ᨯᩃᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᨨᩅᨯᩣᩉᨠᩴ ᨸᩩᨸ᩠ᨹᨨᨯ᩠ᨯᨠᩴ, ᩈᨵᨶᨾᨶᩩᨸᨲᨶ᩠ᨲᩥ ᨶᩣᩁᩥᨿᩮᩣ.

᪓᪓᪙.

‘‘ᨠᩩᩃᨸᩩᨲ᩠ᨲᨾ᩠ᨸᩥ ᨩᩉᨶ᩠ᨲᩥ ᩋᨠᩥᨬ᩠ᨧᨶᩴ, ᨨᩅᨠᩈᨾᩈᨴᩥᩈᨾ᩠ᨸᩥ [ᨨᩅᨠᩈᨾᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᩋᨶᩩᨣᨧ᩠ᨨᨶ᩠ᨲᩥ [ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ (ᨸᩦ.)] ᩋᨶᩩᨸᨲᨶ᩠ᨲᩥ, ᨵᨶᩉᩮᨲᩩ ᩉᩥ ᨶᩣᩁᩥᨿᩮᩣ’’ᨲᩥ [ᨵᨶᩉᩮᨲᩩ ᨧ ᨶᩣᩁᩥᨿᩮᩣ (ᩈ᩠ᨿᩣ.), ᨵᨶᩉᩮᨲᩩ ᨶᩣᩁᩥᨿᩮᩣ (ᨸᩦ.)].

ᩋᨳ ᨡᩃᩩ, ᨽᩮᩣ, ᨶᩣᩁᨴᩮᩣ ᨴᩮᩅᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩌᨶᨶ᩠ᨴᩔ ᨣᩥᨩ᩠ᨫᩁᩣᨩᩔ ᩌᨴᩥᨾᨩ᩠ᨫᨠᨳᩣᨸᩁᩥᨿᩮᩣᩈᩣᨶᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᨲᩣᨿᩴ ᩅᩮᩃᩣᨿᩴ ᩍᨾᩣ ᨣᩣᨳᩣᨿᩮᩣ ᩋᨽᩣᩈᩥ –

᪓᪔᪐.

‘‘ᨧᨲ᩠ᨲᩣᩁᩮᩣᨾᩮ ᨶ ᨸᩪᩁᩮᨶ᩠ᨲᩥ, ᨲᩮ ᨾᩮ ᩈᩩᨱᩣᨳ ᨽᩣᩈᨲᩮᩣ;

ᩈᨾᩩᨴ᩠ᨴᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩁᩣᨩᩣ, ᩍᨲ᩠ᨳᩦ ᨧᩣᨸᩥ ᨴᩥᨩᨾ᩠ᨸᨲᩥ.

᪓᪔᪑.

‘‘ᩈᩁᩥᨲᩣ ᩈᩣᨣᩁᩴ ᨿᨶ᩠ᨲᩥ, ᨿᩣ ᨠᩣᨧᩥ ᨸᨳᩅᩥᩔᩥᨲᩣ;

ᨲᩣ ᩈᨾᩩᨴ᩠ᨴᩴ ᨶ ᨸᩪᩁᩮᨶ᩠ᨲᩥ, ᩐᨶᨲ᩠ᨲᩣ ᩉᩥ ᨶ ᨸᩪᩁᨲᩥ.

᪓᪔᪒.

‘‘ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨧ ᩋᨵᩦᨿᩣᨶ, ᩅᩮᨴᨾᨠ᩠ᨡᩣᨶᨸᨬ᩠ᨧᨾᩴ;

ᨽᩥᨿ᩠ᨿᩮᩣᨸᩥ ᩈᩩᨲᨾᩥᨧ᩠ᨨᩮᨿ᩠ᨿ, ᩐᨶᨲ᩠ᨲᩣ ᩉᩥ ᨶ ᨸᩪᩁᨲᩥ.

᪓᪔᪓.

‘‘ᩁᩣᨩᩣ ᨧ ᨸᨳᩅᩥᩴ ᩈᨻ᩠ᨻᩴ, ᩈᩈᨾᩩᨴ᩠ᨴᩴ ᩈᨸᨻ᩠ᨻᨲᩴ;

ᩋᨩ᩠ᨫᩣᩅᩈᩴ ᩅᩥᨩᩥᨶᩥᨲ᩠ᩅᩣ, ᩋᨶᨶ᩠ᨲᩁᨲᨶᩮᩣᨧᩥᨲᩴ;

ᨸᩣᩁᩴ ¶ ᩈᨾᩩᨴ᩠ᨴᩴ ᨸᨲ᩠ᨳᩮᨲᩥ, ᩐᨶᨲ᩠ᨲᩣ ᩉᩥ ᨶ ᨸᩪᩁᨲᩥ.

᪓᪔᪔.

‘‘ᩑᨠᨾᩮᨠᩣᨿ ᩍᨲ᩠ᨳᩥᨿᩣ, ᩋᨭ᩠ᨮᨭ᩠ᨮ ᨸᨲᩥᨶᩮᩣ ᩈᩥᨿᩣ;

ᩈᩪᩁᩣ ᨧ ᨻᩃᩅᨶ᩠ᨲᩮᩣ ᨧ, ᩈᨻ᩠ᨻᨠᩣᨾᩁᩈᩣᩉᩁᩣ;

ᨠᩁᩮᨿ᩠ᨿ ᨶᩅᨾᩮ ᨨᨶ᩠ᨴᩴ, ᩐᨶᨲ᩠ᨲᩣ ᩉᩥ ᨶ ᨸᩪᩁᨲᩥ.

᪓᪔᪕.

‘‘ᩈᨻ᩠ᨻᩥᨲ᩠ᨳᩥᨿᩮᩣ ¶ ᩈᩥᨡᩥᩁᩥᩅ ᩈᨻ᩠ᨻᨽᨠ᩠ᨡᩣ, ᩈᨻ᩠ᨻᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨶᨴᩦᩁᩥᩅ ᩈᨻ᩠ᨻᩅᩣᩉᩦ;

ᩈᨻ᩠ᨻᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨠᨱ᩠ᨭᨠᩣᨶᩴᩅ ᩈᩣᨡᩣ, ᩈᨻ᩠ᨻᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨵᨶᩉᩮᨲᩩ ᩅᨩᨶ᩠ᨲᩥ.

᪓᪔᪖.

‘‘ᩅᩣᨲᨬ᩠ᨧ ᨩᩣᩃᩮᨶ ᨶᩁᩮᩣ ᨸᩁᩣᨾᩈᩮ, ᩒᩈᩥᨬ᩠ᨧᨿᩮ [ᩒᩈᨬ᩠ᨧᩥᨿᩣ (ᩈᩦ. ᨸᩦ.)] ᩈᩣᨣᩁᨾᩮᨠᨸᩣᨱᩥᨶᩣ;

ᩈᨠᩮᨶ ᩉᨲ᩠ᨳᩮᨶ ᨠᩁᩮᨿ᩠ᨿ ᨥᩮᩣᩈᩴ [ᩈᨠᩮᨶ ᨠᩣᩃᩮᨶ ᩉᨶᩮᨿ᩠ᨿ ᨥᩮᩣᩈᨶᩴ (ᨸᩦ.)], ᨿᩮᩣ ᩈᨻ᩠ᨻᨽᩣᩅᩴ ᨸᨾᨴᩣᩈᩩ ᩒᩈᨩᩮ.

᪓᪔᪗.

‘‘ᨧᩮᩣᩁᩦᨶᩴ ᨻᩉᩩᨻᩩᨴ᩠ᨵᩦᨶᩴ, ᨿᩣᩈᩩ ᩈᨧ᩠ᨧᩴ ᩈᩩᨴᩩᩃ᩠ᩃᨽᩴ;

ᨳᩦᨶᩴ ᨽᩣᩅᩮᩣ ᨴᩩᩁᩣᨩᩣᨶᩮᩣ, ᨾᨧ᩠ᨨᩔᩮᩅᩮᩣᨴᨠᩮ ᨣᨲᩴ.

᪓᪔᪘.

‘‘ᩋᨶᩃᩣ ᨾᩩᨴᩩᩈᨾ᩠ᨽᩣᩈᩣ, ᨴᩩᨸ᩠ᨸᩪᩁᩣ ᨲᩣ ᨶᨴᩦᩈᨾᩣ;

ᩈᩦᨴᨶ᩠ᨲᩥ ᨶᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣᨶ, ᩌᩁᨠᩣ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩮ.

᪓᪔᪙.

‘‘ᩌᩅᨭ᩠ᨭᨶᩦ ᨾᩉᩣᨾᩣᨿᩣ, ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩅᩥᨠᩮᩣᨸᨶᩣ;

ᩈᩦᨴᨶ᩠ᨲᩥ ᨶᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣᨶ, ᩌᩁᨠᩣ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩮ.

᪓᪕᪐.

‘‘ᨿᩴ ¶ ᩑᨲᩣ [ᨿᨬ᩠ᨧᩮᨲᩣ (ᩈ᩠ᨿᩣ.)] ᩏᨸᩈᩮᩅᨶ᩠ᨲᩥ, ᨨᨶ᩠ᨴᩈᩣ ᩅᩣ ᨵᨶᩮᨶ ᩅᩣ;

ᨩᩣᨲᩅᩮᨴᩮᩣᩅ ᩈᨱ᩠ᨮᩣᨶᩴ, ᨡᩥᨸ᩠ᨸᩴ ᩋᨶᩩᨴᩉᨶ᩠ᨲᩥ ᨶ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ¶ ᨡᩃᩩ, ᨽᩮᩣ, ᨠᩩᨱᩣᩃᩮᩣ ᩈᨠᩩᨱᩮᩣ ᨶᩣᩁᨴᩔ ᨴᩮᩅᨻᩕᩣᩉ᩠ᨾᨱᩔ ᩌᨴᩥᨾᨩ᩠ᨫᨠᨳᩣᨸᩁᩥᨿᩮᩣᩈᩣᨶᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᨲᩣᨿᩴ ᩅᩮᩃᩣᨿᩴ ᩍᨾᩣ ᨣᩣᨳᩣᨿᩮᩣ ᩋᨽᩣᩈᩥ –

᪓᪕᪑.

‘‘ᩈᩃ᩠ᩃᨸᩮ ᨶᩥᩈᩥᨲᨡᨣ᩠ᨣᨸᩣᨱᩥᨶᩣ, ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᩋᨸᩥ ᨸᩥᩈᩣᨧᨴᩮᩣᩈᩥᨶᩣ;

ᩏᨣ᩠ᨣᨲᩮᨩᨾᩩᩁᨣᨾ᩠ᨸᩥ ᩌᩈᩥᨴᩮ, ᩑᨠᩮᩣ ᩑᨠᩣᨿ ᨸᨾᨴᩣᨿ ᨶᩣᩃᨸᩮ [ᩑᨠᩮᩣ ᩑᨠᨸᨾᨴᩴ ᩉᩥ ᨶᩣᩃᨸᩮ (ᨸᩦ.) ᩑᨠᩮᩣ ᩑᨠᨸᨾᩣᨴᩣᨿ ᨶᩣᩃᨸᩮ (?)].

᪓᪕᪒.

‘‘ᩃᩮᩣᨠᨧᩥᨲ᩠ᨲᨾᨳᨶᩣ ᩉᩥ ᨶᩣᩁᩥᨿᩮᩣ, ᨶᨧ᩠ᨧᨣᩦᨲᨽᨱᩥᨲᨾ᩠ᩉᩥᨲᩣᩅᩩᨵᩣ;

ᨻᩣᨵᨿᨶ᩠ᨲᩥ ᩋᨶᩩᨸᨭ᩠ᨮᩥᨲᩔᨲᩥᩴ [ᩋᨶᩩᨸᨭ᩠ᨮᩥᨲᩣᩈᨲᩦ (ᨸᩦ.)], ᨴᩦᨸᩮ ᩁᨠ᩠ᨡᩈᩥᨣᨱᩮᩣᩅ [ᨴᩦᨸᩁᨠ᩠ᨡᩈᩥᨣᨱᩣᩅ (ᩈᩦ.)] ᩅᩣᨱᩥᨩᩮ.

᪓᪕᪓.

‘‘ᨶᨲ᩠ᨳᩥ ¶ ᨲᩣᩈᩴ ᩅᩥᨶᨿᩮᩣ ᨶ ᩈᩴᩅᩁᩮᩣ, ᨾᨩ᩠ᨩᨾᩴᩈᨶᩥᩁᨲᩣ [ᨾᨩ᩠ᨩᨾᩴᩈᩣᨽᩥᩁᨲᩣ (ᨠ.)] ᩋᩈᨬ᩠ᨬᨲᩣ;

ᨲᩣ ᨣᩥᩃᨶ᩠ᨲᩥ ᨸᩩᩁᩥᩈᩔ ᨸᩣᨽᨲᩴ, ᩈᩣᨣᩁᩮᩅ ᨾᨠᩁᩴ ᨲᩥᨾᩥᨦ᩠ᨣᩃᩮᩣ [ᨲᩥᨾᩥᨦ᩠ᨣᩥᩃᩮᩣ (ᩈᩦ. ᨸᩦ.)].

᪓᪕᪔.

‘‘ᨸᨬ᩠ᨧᨠᩣᨾᨣᩩᨱᩈᩣᨲᨣᩮᩣᨧᩁᩣ, ᩏᨴ᩠ᨵᨲᩣ ᩋᨶᩥᨿᨲᩣ ᩋᩈᨬ᩠ᨬᨲᩣ;

ᩒᩈᩁᨶ᩠ᨲᩥ ᨸᨾᨴᩣ ᨸᨾᩣᨴᩥᨶᩴ, ᩃᩮᩣᨱᨲᩮᩣᨿᩅᨲᩥᨿᩴᩅ ᩌᨸᨠᩣ.

᪓᪕᪕.

‘‘ᨿᩴ ᨶᩁᩴ ᩏᨸᩃᨸᩮᨶ᩠ᨲᩥ [ᩏᨸᩁᨾᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.), ᨸᩃᩣᨸᩮᨶ᩠ᨲᩥ (ᨠ.)] ᨶᩣᩁᩥᨿᩮᩣ, ᨨᨶ᩠ᨴᩈᩣ ᩅ ¶ ᩁᨲᩥᨿᩣ ᨵᨶᩮᨶ ᩅᩣ;

ᨩᩣᨲᩅᩮᨴᩈᨴᩥᩈᨾ᩠ᨸᩥ ᨲᩣᨴᩥᩈᩴ, ᩁᩣᨣᨴᩮᩣᩈᩅᨵᩥᨿᩮᩣ [ᩁᩣᨣᨴᩮᩣᩈᩅᨲᩥᨿᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᨴᩉᨶ᩠ᨲᩥ ᨶᩴ.

᪓᪕᪖.

‘‘ᩋᨯ᩠ᨰᩴ ᨬᨲ᩠ᩅᩣ ᨸᩩᩁᩥᩈᩴ ᨾᩉᨴ᩠ᨵᨶᩴ, ᩒᩈᩁᨶ᩠ᨲᩥ ᩈᨵᨶᩣ ᩈᩉᨲ᩠ᨲᨶᩣ;

ᩁᨲ᩠ᨲᨧᩥᨲ᩠ᨲᨾᨲᩥᩅᩮᨮᨿᨶ᩠ᨲᩥ ᨶᩴ, ᩈᩣᩃ ᨾᩣᩃᩩᩅᩃᨲᩣᩅ ᨠᩣᨶᨶᩮ.

᪓᪕᪗.

‘‘ᨲᩣ ᩏᨸᩮᨶ᩠ᨲᩥ ᩅᩥᩅᩥᨵᩮᨶ ᨨᨶ᩠ᨴᩈᩣ, ᨧᩥᨲᩕᨻᩥᨾ᩠ᨻᨾᩩᨡᩥᨿᩮᩣ ᩋᩃᨦ᩠ᨠᨲᩣ;

ᩏᩉᩈᨶ᩠ᨲᩥ [ᩐᩉᩈᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.), ᩒᩉᩈᨶ᩠ᨲᩥ (ᩈ᩠ᨿᩣ.)] ᨸᩉᩈᨶ᩠ᨲᩥ ᨶᩣᩁᩥᨿᩮᩣ, ᩈᨾ᩠ᨻᩁᩮᩣᩅ [ᩈᩴᩅᩁᩮᩣᩅ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᩈᨲᨾᩣᨿᨠᩮᩣᩅᩥᨴᩣ.

᪓᪕᪘.

‘‘ᨩᩣᨲᩁᩪᨸᨾᨱᩥᨾᩩᨲ᩠ᨲᨽᩪᩈᩥᨲᩣ, ᩈᨠ᩠ᨠᨲᩣ ᨸᨲᩥᨠᩩᩃᩮᩈᩩ ᨶᩣᩁᩥᨿᩮᩣ;

ᩁᨠ᩠ᨡᩥᨲᩣ ᩋᨲᩥᨧᩁᨶ᩠ᨲᩥ ᩈᩣᨾᩥᨠᩴ, ᨴᩣᨶᩅᩴᩅ ᩉᨴᨿᨶ᩠ᨲᩁᩔᩥᨲᩣ [ᩉᨴᨿᨶ᩠ᨲᨶᩥᩔᩥᨲᩣ (ᨠ.), ᩉᨴᨿᨶ᩠ᨲᩁᨶᩥᩔᩥᨲᩣ (ᩈ᩠ᨿᩣ.)].

᪓᪕᪙.

‘‘ᨲᩮᨩᩅᩣᨸᩥ ¶ ᩉᩥ ᨶᩁᩮᩣ ᩅᩥᨧᨠ᩠ᨡᨱᩮᩣ, ᩈᨠ᩠ᨠᨲᩮᩣ ᨻᩉᩩᨩᨶᩔ ᨸᩪᨩᩥᨲᩮᩣ;

ᨶᩣᩁᩥᨶᩴ ᩅᩈᨣᨲᩮᩣ ᨶ ᨽᩣᩈᨲᩥ, ᩁᩣᩉᩩᨶᩣ ᩏᨸᩉᨲᩮᩣᩅ ᨧᨶ᩠ᨴᩥᨾᩣ.

᪓᪖᪐.

‘‘ᨿᩴ ᨠᩁᩮᨿ᩠ᨿ ᨠᩩᨸᩥᨲᩮᩣ ᨴᩥᩈᩮᩣ ᨴᩥᩈᩴ, ᨴᩩᨭ᩠ᨮᨧᩥᨲ᩠ᨲᩮᩣ ¶ ᩅᩈᨾᩣᨣᨲᩴ ᩋᩁᩥᩴ [ᩋᩁᩥ (ᩈᩦ. ᨸᩦ.)];

ᨲᩮᨶ ᨽᩥᨿ᩠ᨿᩮᩣ ᨻ᩠ᨿᩈᨶᩴ ᨶᩥᨣᨧ᩠ᨨᨲᩥ, ᨶᩣᩁᩥᨶᩴ ᩅᩈᨣᨲᩮᩣ ᩋᨸᩮᨠ᩠ᨡᩅᩣ.

᪓᪖᪑.

‘‘ᨠᩮᩈᩃᩪᨶᨶᨡᨨᩥᨶ᩠ᨶᨲᨩ᩠ᨩᩥᨲᩣ, ᨸᩣᨴᨸᩣᨱᩥᨠᩈᨴᨱ᩠ᨯᨲᩣᩊᩥᨲᩣ;

ᩉᩦᨶᨾᩮᩅᩩᨸᨣᨲᩣ ᩉᩥ ᨶᩣᩁᩥᨿᩮᩣ, ᨲᩣ ᩁᨾᨶ᩠ᨲᩥ ᨠᩩᨱᨸᩮᩅ ᨾᨠ᩠ᨡᩥᨠᩣ.

᪓᪖᪒.

‘‘ᨲᩣ ᨠᩩᩃᩮᩈᩩ ᩅᩥᩈᩥᨡᨶ᩠ᨲᩁᩮᩈᩩ ᩅᩣ, ᩁᩣᨩᨵᩣᨶᩥᨶᩥᨣᨾᩮᩈᩩ ᩅᩣ ᨸᩩᨶ [ᩅᩣ ᨸᨶ (ᩈ᩠ᨿᩣ.)];

ᩒᨯ᩠ᨯᩥᨲᩴ ᨶᨾᩩᨧᩥᨸᩣᩈᩅᩣᨠᩁᩴ [ᩅᩣᨣᩩᩁᩴ (ᩈ᩠ᨿᩣ.)], ᨧᨠ᩠ᨡᩩᨾᩣ ᨸᩁᩥᩅᨩ᩠ᨩᩮ ᩈᩩᨡᨲ᩠ᨳᩥᨠᩮᩣ.

᪓᪖᪓.

‘‘ᩒᩔᨩᩥᨲ᩠ᩅ ¶ ᨠᩩᩈᩃᩴ ᨲᨸᩮᩣᨣᩩᨱᩴ, ᨿᩮᩣ ᩋᨶᩁᩥᨿᨧᩁᩥᨲᩣᨶᩥ ᨾᩣᨧᩁᩥ;

ᨴᩮᩅᨲᩣᩉᩥ ᨶᩥᩁᨿᩴ ᨶᩥᨾᩥᩔᨲᩥ, ᨨᩮᨴᨣᩣᨾᩥᨾᨱᩥᨿᩴᩅ ᩅᩣᨱᩥᨩᩮᩣ.

᪓᪖᪔.

‘‘ᩈᩮᩣ ᩍᨵ ᨣᩁᩉᩥᨲᩮᩣ ᨸᩁᨲ᩠ᨳ ᨧ, ᨴᩩᨾ᩠ᨾᨲᩦ ᩏᨸᩉᨲᩮᩣ [ᩏᨸᨣᨲᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᩈᨠᨾ᩠ᨾᩩᨶᩣ;

ᨣᨧ᩠ᨨᨲᩦ ᩋᨶᩥᨿᨲᩮᩣ ᨣᩊᩣᨣᩊᩴ, ᨴᩩᨭ᩠ᨮᨣᨴᩕᨽᩁᨳᩮᩣᩅ ᩏᨸ᩠ᨸᨳᩮ.

᪓᪖᪕.

‘‘ᩈᩮᩣ ᩏᨸᩮᨲᩥ ᨶᩥᩁᨿᩴ ᨸᨲᩣᨸᨶᩴ, ᩈᨲ᩠ᨲᩥᩈᩥᨾ᩠ᨻᩃᩥᩅᨶᨬ᩠ᨧ ¶ ᩌᨿᩈᩴ;

ᩌᩅᩈᩥᨲ᩠ᩅᩣ ᨲᩥᩁᨧ᩠ᨨᩣᨶᨿᩮᩣᨶᩥᨿᩴ, ᨸᩮᨲᩁᩣᨩᩅᩥᩈᨿᩴ ᨶ ᨾᩩᨬ᩠ᨧᨲᩥ [ᨾᩩᨧ᩠ᨧᨲᩥ (ᨠ.)].

᪓᪖᪖.

‘‘ᨴᩥᨻ᩠ᨿᨡᩥᨯ᩠ᨯᩁᨲᩥᨿᩮᩣᩴ ¶ ᨧ ᨶᨶ᩠ᨴᨶᩮ, ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩥᨧᩁᩥᨲᨬ᩠ᨧ ᨾᩣᨶᩩᩈᩮ;

ᨶᩣᩈᨿᨶ᩠ᨲᩥ ᨸᨾᨴᩣ ᨸᨾᩣᨴᩥᨶᩴ, ᨴᩩᨣ᩠ᨣᨲᩥᨬ᩠ᨧ ᨸᨭᩥᨸᩣᨴᨿᨶ᩠ᨲᩥ ᨶᩴ.

᪓᪖᪗.

‘‘ᨴᩥᨻ᩠ᨿᨡᩥᨯ᩠ᨯᩁᨲᩥᨿᩮᩣ ᨶ ᨴᩩᩃ᩠ᩃᨽᩣ, ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩥᨧᩁᩥᨲᨬ᩠ᨧ ᨾᩣᨶᩩᩈᩮ;

ᩈᩮᩣᨱ᩠ᨱᨻ᩠ᨿᨾ᩠ᩉᨶᩥᩃᨿᩣ [ᩈᩩᩅᨱ᩠ᨱᨻ᩠ᨿᨾ᩠ᩉᨶᩥᩃᨿᩣ (ᩈ᩠ᨿᩣ. ᨠ.), ᩈᩮᩣᩅᨱ᩠ᨱᨻ᩠ᨿᨾ᩠ᩉᨶᩥᩃᨿᩣ (ᨸᩦ.)] ᨧ ᩋᨧ᩠ᨨᩁᩣ, ᨿᩮ ᨧᩁᨶ᩠ᨲᩥ ᨸᨾᨴᩣᩉᨶᨲ᩠ᨳᩥᨠᩣ.

᪓᪖᪘.

‘‘ᨠᩣᨾᨵᩣᨲᩩᩈᨾᨲᩥᨠ᩠ᨠᨾᩣ ᨣᨲᩥ, ᩁᩪᨸᨵᩣᨲᩩᨿᩣ ᨽᩣᩅᩮᩣ [ᩁᩪᨸᨵᩣᨲᩩᨿᩣ ᨽᩅᩮᩣ (ᩈᩦ.), ᩁᩪᨸᨵᩣᨲᩩᩈᨾ᩠ᨽᩅᩮᩣ (ᩈ᩠ᨿᩣ.)] ᨶ ᨴᩩᩃ᩠ᩃᨽᩮᩣ;

ᩅᩦᨲᩁᩣᨣᩅᩥᩈᨿᩪᨸᨸᨲ᩠ᨲᩥᨿᩣ, ᨿᩮ ᨧᩁᨶ᩠ᨲᩥ ᨸᨾᨴᩣᩉᨶᨲ᩠ᨳᩥᨠᩣ.

᪓᪖᪙.

‘‘ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᩈᨾᨲᩥᨠ᩠ᨠᨾᩴ ᩈᩥᩅᩴ, ᩋᨧ᩠ᨧᨶ᩠ᨲᨾᨧᩃᩥᨲᩴ ᩋᩈᨦ᩠ᨡᨲᩴ;

ᨶᩥᨻ᩠ᨻᩩᨲᩮᩉᩥ ᩈᩩᨧᩥᩉᩦ ᨶ ᨴᩩᩃ᩠ᩃᨽᩴ, ᨿᩮ ᨧᩁᨶ᩠ᨲᩥ ᨸᨾᨴᩣᩉᨶᨲ᩠ᨳᩥᨠᩣ’’ᨲᩥ.

᪓᪗᪐.

‘‘ᨠᩩᨱᩣᩃᩮᩣᩉᩴ ᨲᨴᩣ ᩌᩈᩥᩴ, ᩏᨴᩣᨿᩦ ᨹᩩᩔᨠᩮᩣᨠᩥᩃᩮᩣ;

ᩌᨶᨶ᩠ᨴᩮᩣ ¶ ᨣᩥᨩ᩠ᨫᩁᩣᨩᩣᩈᩥ, ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᩣ ᨧ ᨶᩣᩁᨴᩮᩣ;

ᨸᩁᩥᩈᩣ ᨻᩩᨴ᩠ᨵᨸᩁᩥᩈᩣ, ᩑᩅᩴ ᨵᩣᩁᩮᨳ ᨩᩣᨲᨠ’’ᨶ᩠ᨲᩥ.

ᨠᩩᨱᩣᩃᨩᩣᨲᨠᩴ ᨧᨲᩩᨲ᩠ᨳᩴ.

᪕᪓᪗. ᨾᩉᩣᩈᩩᨲᩈᩮᩣᨾᨩᩣᨲᨠᩴ (᪕)

᪓᪗᪑.

‘‘ᨠᩈ᩠ᨾᩣ ᨲᩩᩅᩴ ᩁᩈᨠ ᩑᨴᩥᩈᩣᨶᩥ, ᨠᩁᩮᩣᩈᩥ ᨠᨾ᩠ᨾᩣᨶᩥ ᩈᩩᨴᩣᩁᩩᨱᩣᨶᩥ;

ᩉᨶᩣᩈᩥ ᩍᨲ᩠ᨳᩦ ᨸᩩᩁᩥᩈᩮ ᨧ ᨾᩪᩊ᩠ᩉᩮᩣ, ᨾᩴᩈᩔ ᩉᩮᨲᩩ ᩋᨴᩩ [ᩌᨴᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨵᨶᩔ ᨠᩣᩁᨱᩣ’’.

᪓᪗᪒.

‘‘ᨶᩴ ¶ ᩋᨲ᩠ᨲᩉᩮᨲᩪ ᨶ ᨵᨶᩔ ᨠᩣᩁᨱᩣ, ᨶ ᨸᩩᨲ᩠ᨲᨴᩣᩁᩔ ᩈᩉᩣᨿᨬᩣᨲᩥᨶᩴ;

ᨽᨲ᩠ᨲᩣ ᨧ ᨾᩮ ᨽᨣᩅᩣ ᨽᩪᨾᩥᨸᩣᩃᩮᩣ, ᩈᩮᩣ ᨡᩣᨴᨲᩥ ᨾᩴᩈᩴ ᨽᨴᨶ᩠ᨲᩮᨴᩥᩈᩴ’’.

᪓᪗᪓.

‘‘ᩈᨧᩮ ᨲᩩᩅᩴ ᨽᨲ᩠ᨲᩩᩁᨲ᩠ᨳᩮ ᨸᨿᩩᨲ᩠ᨲᩮᩣ, ᨠᩁᩮᩣᩈᩥ ᨠᨾ᩠ᨾᩣᨶᩥ ᩈᩩᨴᩣᩁᩩᨱᩣᨶᩥ;

ᨸᩣᨲᩮᩣᩅ ᩋᨶ᩠ᨲᩮᨸᩩᩁᩴ ᨸᩣᨸᩩᨱᩥᨲ᩠ᩅᩣ, ᩃᨸᩮᨿ᩠ᨿᩣᩈᩥ ᨾᩮ ᩁᩣᨩᩥᨶᩮᩣ ᩈᨾ᩠ᨾᩩᨡᩮ ᨲᩴ’’.

᪓᪗᪔.

‘‘ᨲᨳᩣ ᨠᩁᩥᩔᩣᨾᩥ ᩋᩉᩴ ᨽᨴᨶ᩠ᨲᩮ, ᨿᨳᩣ ᨲᩩᩅᩴ [ᨿᨾᩮᩅ ᨲ᩠ᩅᩴ (ᩈᩦ.)] ᨽᩣᩈᩈᩥ ᨠᩣᩊᩉᨲ᩠ᨳᩥ;

ᨸᩣᨲᩮᩣᩅ ᩋᨶ᩠ᨲᩮᨸᩩᩁᩴ ᨸᩣᨸᩩᨱᩥᨲ᩠ᩅᩣ, ᩅᨠ᩠ᨡᩣᨾᩥ ¶ ᨲᩮ ᩁᩣᨩᩥᨶᩮᩣ ᩈᨾ᩠ᨾᩩᨡᩮ ᨲᩴ’’.

᪓᪗᪕.

ᨲᨲᩮᩣ ¶ ᩁᨲ᩠ᨿᩣ ᩅᩥᩅᩈᩣᨶᩮ [ᩅᩥᩅᩈᨶᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩈᩪᩁᩥᨿᩩᨣ᩠ᨣᨾᨶᩴ ᨸᨲᩥ;

ᨠᩣᩊᩮᩣ ᩁᩈᨠᨾᩣᨴᩣᨿ, ᩁᩣᨩᩣᨶᩴ ᩏᨸᩈᨦ᩠ᨠᨾᩥ;

ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ [ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩁᩣᨩᩣᨶᩴ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥ.

᪓᪗᪖.

‘‘ᩈᨧ᩠ᨧᩴ ᨠᩥᩁ ᨾᩉᩣᩁᩣᨩ, ᩁᩈᨠᩮᩣ ᨸᩮᩈᩥᨲᩮᩣ ᨲᨿᩣ;

ᩉᨶᨲᩥ ᩍᨲ᩠ᨳᩥᨸᩩᩁᩥᩈᩮ, ᨲᩩᩅᩴ ᨾᩴᩈᩣᨶᩥ ᨡᩣᨴᩈᩥ’’.

᪓᪗᪗.

‘‘ᩑᩅᨾᩮᩅ ᨲᨳᩣ ᨠᩣᩊ, ᩁᩈᨠᩮᩣ ᨸᩮᩈᩥᨲᩮᩣ ᨾᨿᩣ;

ᨾᨾ ᩋᨲ᩠ᨳᩴ ᨠᩁᩮᩣᨶ᩠ᨲᩔ, ᨠᩥᨾᩮᨲᩴ ᨸᩁᩥᨽᩣᩈᩈᩥ’’.

᪓᪗᪘.

‘‘ᩌᨶᨶ᩠ᨴᩮᩣ ᩈᨻ᩠ᨻᨾᨧ᩠ᨨᩣᨶᩴ, ᨡᩣᨴᩥᨲ᩠ᩅᩣ ᩁᩈᨣᩥᨴ᩠ᨵᩥᨾᩣ;

ᨸᩁᩥᨠ᩠ᨡᩦᨱᩣᨿ ᨸᩁᩥᩈᩣᨿ, ᩋᨲ᩠ᨲᩣᨶᩴ ᨡᩣᨴᩥᨿᩣ ᨾᨲᩮᩣ.

᪓᪗᪙.

‘‘ᩑᩅᩴ ᨸᨾᨲ᩠ᨲᩮᩣ ᩁᩈᨣᩣᩁᩅᩮ ᩁᨲ᩠ᨲᩮᩣ [ᩁᨲᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨻᩣᩃᩮᩣ ᨿᨴᩦ ᩌᨿᨲᩥ ᨶᩣᩅᨻᩩᨩ᩠ᨫᨲᩥ;

ᩅᩥᨵᨾ᩠ᨾ ᨸᩩᨲ᩠ᨲᩮ ᨧᨩᩥ [ᨧᨩᩥᨲ᩠ᩅᩣ (ᨠ.)] ᨬᩣᨲᨠᩮ ᨧ, ᨸᩁᩥᩅᨲ᩠ᨲᩥᨿ ᩋᨲ᩠ᨲᩣᨶᨬ᩠ᨬᩮᩅ [ᩋᨲ᩠ᨲᩣᨶᨾᩮᩅ (ᩈᩦ. ᨸᩦ.)] ᨡᩣᨴᨲᩥ.

᪓᪘᪐.

‘‘ᩍᨴᩴ ¶ ᨲᩮ ᩈᩩᨲ᩠ᩅᩣᨶ ᩅᩥᨣᩮᨲᩩ [ᩅᩥᩉᩮᨲᩩ (ᩈᩦ. ᨸᩦ.)] ᨨᨶ᩠ᨴᩮᩣ, ᨾᩣ ᨽᨠ᩠ᨡᨿᩦ [ᨾᩣ ᨽᨠ᩠ᨡᩈᩦ (ᩈᩦ. ᨸᩦ.)] ᩁᩣᨩ ᨾᨶᩩᩔᨾᩴᩈᩴ;

ᨾᩣ ᨲ᩠ᩅᩴ ᩍᨾᩴ ᨠᩮᩅᩃᩴ ᩅᩣᩁᩥᨩᩮᩣᩅ, ᨴ᩠ᩅᩥᨸᨴᩣᨵᩥᨸ [ᨴᩥᨸᨴᩣᨴᩥᨸ (ᩈᩦ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ᩈᩩᨬ᩠ᨬᨾᨠᩣᩈᩥ ᩁᨭ᩠ᨮᩴ’’.

᪓᪘᪑.

‘‘ᩈᩩᨩᩣᨲᩮᩣ ᨶᩣᨾ ᨶᩣᨾᩮᨶ, ᩒᩁᩈᩮᩣ ᨲᩔ ᩋᨲᩕᨩᩮᩣ [ᨲᩔ ᩒᩁᩈ ᩋᨲᩕᨩᩮᩣ (ᩈᩦ.), ᨲᩔ ᩋᨲᩕᨩ ᩒᩁᩈᩮᩣ (ᨸᩦ.)];

ᨩᨾ᩠ᨻᩩᨸᩮᩈᩥᨾᩃᨴ᩠ᨵᩣᨶ, ᨾᨲᩮᩣ ᩈᩮᩣ ᨲᩔ ᩈᨦ᩠ᨡᨿᩮ.

᪓᪘᪒.

‘‘ᩑᩅᨾᩮᩅ ¶ ᩋᩉᩴ ᨠᩣᩊ, ᨽᩩᨲ᩠ᩅᩣ ᨽᨠ᩠ᨡᩴ ᩁᩈᩩᨲ᩠ᨲᨾᩴ;

ᩋᩃᨴ᩠ᨵᩣ ᨾᩣᨶᩩᩈᩴ ᨾᩴᩈᩴ, ᨾᨬ᩠ᨬᩮ ᩉᩥᩔᩣᨾᩥ [ᩉᩮᩔᩣᨾᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩉᩔᩣᨾᩥ (ᨸᩦ.)] ᨩᩦᩅᩥᨲᩴ’’.

᪓᪘᪓.

‘‘ᨾᩣᨱᩅ ᩋᨽᩥᩁᩪᨸᩮᩣᩈᩥ, ᨠᩩᩃᩮ ᨩᩣᨲᩮᩣᩈᩥ ᩈᩮᩣᨲ᩠ᨳᩥᨿᩮ;

ᨶ ᨲ᩠ᩅᩴ ᩋᩁᩉᩈᩥ ᨲᩣᨲ, ᩋᨽᨠ᩠ᨡᩴ ᨽᨠ᩠ᨡᨿᩮᨲᩅᩮ’’.

᪓᪘᪔.

‘‘ᩁᩈᩣᨶᩴ ᩋᨬ᩠ᨬᨲᩁᩴ ᩑᨲᩴ, ᨠᩈ᩠ᨾᩣ [ᨿᩈ᩠ᨾᩣ (ᩈᩦ. ᨸᩦ.)] ᨾᩴ ᨲ᩠ᩅᩴ ᨶᩥᩅᩣᩁᨿᩮ;

ᩈᩮᩣᩉᩴ ᨲᨲ᩠ᨳ ᨣᨾᩥᩔᩣᨾᩥ, ᨿᨲ᩠ᨳ ᩃᨧ᩠ᨨᩣᨾᩥ ᩑᨴᩥᩈᩴ.

᪓᪘᪕.

‘‘ᩈᩮᩣᩅᩣᩉᩴ ᨶᩥᨸ᩠ᨸᨲᩥᩔᩣᨾᩥ, ᨶ ᨲᩮ ᩅᨧ᩠ᨨᩣᨾᩥ ᩈᨶ᩠ᨲᩥᨠᩮ;

ᨿᩔ ᨾᩮ ᨴᩔᨶᩮᨶ ᨲ᩠ᩅᩴ, ᨶᩣᨽᩥᨶᨶ᩠ᨴᩈᩥ ᨻᩕᩣᩉ᩠ᨾᨱ’’.

᪓᪘᪖.

‘‘ᩋᨴ᩠ᨵᩣ ᩋᨬ᩠ᨬᩮᨸᩥ ᨴᩣᨿᩣᨴᩮ, ᨸᩩᨲ᩠ᨲᩮ ᩃᨧ᩠ᨨᩣᨾ ᨾᩣᨱᩅ;

ᨲ᩠ᩅᨬ᩠ᨧ ᨩᨾ᩠ᨾ ᩅᩥᨶᩔᩔᩩ, ᨿᨲ᩠ᨳ ᨸᨲ᩠ᨲᩴ ᨶ ᨲᩴ ᩈᩩᨱᩮ’’.

᪓᪘᪗.

‘‘ᩑᩅᨾᩮᩅ ᨲᩩᩅᩴ ᩁᩣᨩ, ᨴ᩠ᩅᩥᨸᨴᩥᨶ᩠ᨴ ᩈᩩᨱᩮᩣᩉᩥ ᨾᩮ;

ᨸᨻ᩠ᨻᩣᨩᩮᩔᨶ᩠ᨲᩥ ᨲᩴ ᩁᨭ᩠ᨮᩣ, ᩈᩮᩣᨱ᩠ᨯᩴ ᨾᩣᨱᩅᨠᩴ ᨿᨳᩣ’’.

᪓᪘᪘.

‘‘ᩈᩩᨩᩣᨲᩮᩣ ᨶᩣᨾ ᨶᩣᨾᩮᨶ, ᨽᩣᩅᩥᨲᨲ᩠ᨲᩣᨶ ᩈᩣᩅᨠᩮᩣ;

ᩋᨧ᩠ᨨᩁᩴ ᨠᩣᨾᨿᨶ᩠ᨲᩮᩣᩅ, ᨶ ᩈᩮᩣ ᨽᩩᨬ᩠ᨩᩥ ᨶ ᩈᩮᩣ ᨸᩥᩅᩥ.

᪓᪘᪙.

‘‘ᨠᩩᩈᨣ᩠ᨣᩮᨶᩩᨴᨠᨾᩣᨴᩣᨿ ¶ [ᨠᩩᩈᨣ᩠ᨣᩮ ᩏᨴᨠᨾᩣᨴᩣᨿ (ᩈᩦ. ᨸᩦ.)], ᩈᨾᩩᨴ᩠ᨴᩮ ᩏᨴᨠᩴ ᨾᩥᨶᩮ;

ᩑᩅᩴ ᨾᩣᨶᩩᩈᨠᩣ ᨠᩣᨾᩣ, ᨴᩥᨻ᩠ᨻᨠᩣᨾᩣᨶ ᩈᨶ᩠ᨲᩥᨠᩮ.

᪓᪙᪐.

‘‘ᩑᩅᨾᩮᩅ ᩋᩉᩴ ᨠᩣᩊ, ᨽᩩᨲ᩠ᩅᩣ ᨽᨠ᩠ᨡᩴ ᩁᩈᩩᨲ᩠ᨲᨾᩴ;

ᩋᩃᨴ᩠ᨵᩣ ᨾᩣᨶᩩᩈᩴ ᨾᩴᩈᩴ, ᨾᨬ᩠ᨬᩮ ᩉᩥᩔᩣᨾᩥ ᨩᩦᩅᩥᨲᩴ’’.

᪓᪙᪑.

‘‘ᨿᨳᩣᨸᩥ ¶ ᨲᩮ ᨵᨲᩁᨭ᩠ᨮᩣ, ᩉᩴᩈᩣ ᩅᩮᩉᩣᨿᩈᨦ᩠ᨣᨾᩣ;

ᩋᨽᩩᨲ᩠ᨲᨸᩁᩥᨽᩮᩣᨣᩮᨶ [ᩋᩅᩩᨲ᩠ᨲᩥᨸᩁᩥᨽᩮᩣᨣᩮᨶ (ᩈᩦ. ᨸᩦ.), ᩋᨿᩩᨲ᩠ᨲᨸᩁᩥᨽᩮᩣᨣᩮᨶ (ᩈ᩠ᨿᩣ.)], ᩈᨻ᩠ᨻᩮ ᩋᨻ᩠ᨽᨲ᩠ᨳᨲᩴ ᨣᨲᩣ.

᪓᪙᪒.

‘‘ᩑᩅᨾᩮᩅ ¶ ᨲᩩᩅᩴ ᩁᩣᨩ, ᨴ᩠ᩅᩥᨸᨴᩥᨶ᩠ᨴ ᩈᩩᨱᩮᩣᩉᩥ ᨾᩮ;

ᩋᨽᨠ᩠ᨡᩴ ᩁᩣᨩ ᨽᨠ᩠ᨡᩮᩈᩥ, ᨲᩈ᩠ᨾᩣ ᨸᨻ᩠ᨻᩣᨩᨿᨶ᩠ᨲᩥ ᨲᩴ’’.

᪓᪙᪓.

‘‘ᨲᩥᨭ᩠ᨮᩣᩉᩦᨲᩥ ᨾᨿᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩈᩮᩣ ᨲ᩠ᩅᩴ ᨣᨧ᩠ᨨᩈᩥ ᨸᨾ᩠ᨾᩩᨡᩮᩣ [ᨸᩣᨾᩩᨡᩮᩣ (ᨠ.)];

ᩋᨭ᩠ᨮᩥᨲᩮᩣ ᨲ᩠ᩅᩴ ᨮᩥᨲᩮᩣᨾ᩠ᩉᩦᨲᩥ, ᩃᨸᩈᩥ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩥ;

ᩍᨴᩴ ᨲᩮ ᩈᨾᨱᩣᨿᩩᨲ᩠ᨲᩴ, ᩋᩈᩥᨬ᩠ᨧ ᨾᩮ ᨾᨬ᩠ᨬᩈᩥ ᨠᨦ᩠ᨠᨸᨲ᩠ᨲᩴ’’ [ᨠᨦ᩠ᨡᨸᨲ᩠ᨲᩴ (ᩈ᩠ᨿᩣ. ᨠ.)].

᪓᪙᪔.

‘‘ᨮᩥᨲᩮᩣᩉᨾᩈ᩠ᨾᩦ ᩈᨵᨾ᩠ᨾᩮᩈᩩ ᩁᩣᨩ, ᨶ ᨶᩣᨾᨣᩮᩣᨲ᩠ᨲᩴ ᨸᩁᩥᩅᨲ᩠ᨲᨿᩣᨾᩥ;

ᨧᩮᩣᩁᨬ᩠ᨧ ᩃᩮᩣᨠᩮ ᩋᨮᩥᨲᩴ ᩅᨴᨶ᩠ᨲᩥ, ᩌᨸᩣᨿᩥᨠᩴ ᨶᩮᩁᨿᩥᨠᩴ ᩍᨲᩮᩣ ᨧᩩᨲᩴ.

᪓᪙᪕.

‘‘ᩈᨧᩮ ᨲ᩠ᩅᩴ ᩈᨴ᩠ᨴᩉᩈᩥ [ᩈᨧᩮᨸᩥ ᩈᩉᩈᩥ (ᩈᩦ. ᨸᩦ.)] ᩁᩣᨩ, ᩈᩩᨲᩴ ᨣᨱ᩠ᩉᩣᩉᩥ ᨡᨲ᩠ᨲᩥᨿ [ᨡᨲ᩠ᨲᩥᨿᩴ (ᩈ᩠ᨿᩣ.)];

ᨲᩮᨶ ᨿᨬ᩠ᨬᩴ ᨿᨩᩥᨲ᩠ᩅᩣᨶ, ᩑᩅᩴ ᩈᨣ᩠ᨣᩴ ᨣᨾᩥᩔᩈᩥ’’.

᪓᪙᪖.

‘‘ᨠᩥᩈ᩠ᨾᩥᩴ ᨶᩩ ᩁᨭ᩠ᨮᩮ ᨲᩅ ᨩᩣᨲᩥᨽᩪᨾᩥ [ᨩᩣᨲᨽᩪᨾᩥ (ᩈᩦ.)], ᩋᨳ ᨠᩮᨶ ᩋᨲ᩠ᨳᩮᨶ ᩍᨵᩣᨶᩩᨸᨲ᩠ᨲᩮᩣ;

ᩋᨠ᩠ᨡᩣᩉᩥ ᨾᩮ ᨻᩕᩣᩉ᩠ᨾᨱ ᩑᨲᨾᨲ᩠ᨳᩴ, ᨠᩥᨾᩥᨧ᩠ᨨᩈᩦ ᨴᩮᨾᩥ ᨲᨿᨩ᩠ᨩ ᨸᨲ᩠ᨳᩥᨲᩴ’’.

᪓᪙᪗.

‘‘ᨣᩣᨳᩣ ᨧᨲᩔᩮᩣ ᨵᩁᨱᩦᨾᩉᩥᩔᩁ, ᩈᩩᨣᨾ᩠ᨽᩥᩁᨲ᩠ᨳᩣ ᩅᩁᩈᩣᨣᩁᩪᨸᨾᩣ;

ᨲᩅᩮᩅ ᩋᨲ᩠ᨳᩣᨿ ᩍᨵᩣᨣᨲᩮᩣᩈ᩠ᨾᩥ, ᩈᩩᨱᩮᩣᩉᩥ ᨣᩣᨳᩣ ᨸᩁᨾᨲ᩠ᨳᩈᩴᩉᩥᨲᩣ’’.

᪓᪙᪘.

‘‘ᨶ ᩅᩮ ᩁᩩᨴᨶ᩠ᨲᩥ ᨾᨲᩥᨾᨶ᩠ᨲᩮᩣ ᩈᨸᨬ᩠ᨬᩣ, ᨻᩉᩩᩔᩩᨲᩣ ¶ ᨿᩮ ᨻᩉᩩᨭ᩠ᨮᩣᨶᨧᩥᨶ᩠ᨲᩥᨶᩮᩣ;

ᨴᩦᨸᨬ᩠ᩉᩥ ᩑᨲᩴ ᨸᩁᨾᩴ ᨶᩁᩣᨶᩴ, ᨿᩴ ᨸᨱ᩠ᨯᩥᨲᩣ ᩈᩮᩣᨠᨶᩩᨴᩣ ᨽᩅᨶ᩠ᨲᩥ.

᪓᪙᪙.

‘‘ᩋᨲ᩠ᨲᩣᨶᩴ ¶ ᨬᩣᨲᩦ ᩏᨴᩣᩉᩩ [ᩏᨴ (ᩈᩦ. ᨸᩦ.)] ᨸᩩᨲ᩠ᨲᨴᩣᩁᩴ, ᨵᨬ᩠ᨬᩴ ᨵᨶᩴ ᩁᨩᨲᩴ ᨩᩣᨲᩁᩪᨸᩴ;

ᨠᩥᨾᩮᩅ ᨲ᩠ᩅᩴ [ᨠᩥᨾᩮᩣ ᨶᩩ ᨲ᩠ᩅᩴ (ᩈᩦ. ᨸᩦ.)] ᩈᩩᨲᩈᩮᩣᨾᩣᨶᩩᨲᨸ᩠ᨸᩮ, ᨠᩮᩣᩁᨻ᩠ᨿᩈᩮᨭ᩠ᨮ ᩅᨧᨶᩴ ᩈᩩᨱᩮᩣᨾ ᨲᩮᨲᩴ’.

᪔᪐᪐.

‘‘ᨶᩮᩅᩣᩉᨾᨲ᩠ᨲᩣᨶᨾᨶᩩᨲ᩠ᨳᩩᨶᩣᨾᩥ, ᨶ ᨸᩩᨲ᩠ᨲᨴᩣᩁᩴ ᨶ ᨵᨶᩴ ᨶ ᩁᨭ᩠ᨮᩴ;

ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩮᩣ ᨧᩁᩥᨲᩮᩣ ᨸᩩᩁᩣᨱᩮᩣ, ᨲᩴ ᩈᨦ᩠ᨠᩁᩴ [ᩈᨦ᩠ᨣᩁᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ᨻᩕᩣᩉ᩠ᨾᨱᩔᩣᨶᩩᨲᨸ᩠ᨸᩮ.

᪔᪐᪑.

‘‘ᨠᨲᩮᩣ ᨾᨿᩣ ᩈᨦ᩠ᨠᩁᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᨶ, ᩁᨭ᩠ᨮᩮ ᩈᨠᩮ ᩍᩔᩁᩥᨿᩮ ᨮᩥᨲᩮᨶ;

ᨲᩴ ᩈᨦ᩠ᨠᩁᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩈᨸ᩠ᨸᨴᩣᨿ, ᩈᨧ᩠ᨧᩣᨶᩩᩁᨠ᩠ᨡᩦ ᨸᩩᨶᩁᩣᩅᨩᩥᩔᩴ’’.

᪔᪐᪒.

‘‘ᨶᩮᩅᩣᩉᨾᩮᨲᩴ ᩋᨽᩥᩈᨴ᩠ᨴᩉᩣᨾᩥ, ᩈᩩᨡᩦ ᨶᩁᩮᩣ ᨾᨧ᩠ᨧᩩᨾᩩᨡᩣ ᨸᨾᩩᨲ᩠ᨲᩮᩣ;

ᩋᨾᩥᨲ᩠ᨲᩉᨲ᩠ᨳᩴ ᨸᩩᨶᩁᩣᩅᨩᩮᨿ᩠ᨿ, ᨠᩮᩣᩁᨻ᩠ᨿᩈᩮᨭ᩠ᨮ ᨶ ᩉᩥ ᨾᩴ ᩏᨸᩮᩈᩥ.

᪔᪐᪓.

‘‘ᨾᩩᨲ᩠ᨲᩮᩣ ¶ ᨲᩩᩅᩴ ᨸᩮᩣᩁᩥᩈᩣᨴᩔ ᩉᨲ᩠ᨳᩣ, ᨣᨶ᩠ᨲ᩠ᩅᩣ ¶ ᩈᨠᩴ ᨾᨶ᩠ᨴᩥᩁᩴ ᨠᩣᨾᨠᩣᨾᩦ;

ᨾᨵᩩᩁᩴ ᨸᩥᨿᩴ ᨩᩦᩅᩥᨲᩴ ᩃᨴ᩠ᨵ ᩁᩣᨩ, ᨠᩩᨲᩮᩣ ᨲᩩᩅᩴ ᩑᩉᩥᩈᩥ ᨾᩮ ᩈᨠᩣᩈᩴ’’.

᪔᪐᪔.

‘‘ᨾᨲᩴ ᩅᩁᩮᨿ᩠ᨿ ᨸᩁᩥᩈᩩᨴ᩠ᨵᩈᩦᩃᩮᩣ, ᨶ ᨩᩦᩅᩥᨲᩴ [ᨶ ᩉᩥ ᨩᩦᩅᩥᨲᩴ (ᩈᩦ.)] ᨣᩁᩉᩥᨲᩮᩣ ᨸᩣᨸᨵᨾ᩠ᨾᩮᩣ;

ᨶ ᩉᩥ ᨲᩴ ᨶᩁᩴ ᨲᩣᨿᨲᩥ [ᨲᩣᨿᨲᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᨴᩩᨣ᩠ᨣᨲᩦᩉᩥ, ᨿᩔᩣᨸᩥ ᩉᩮᨲᩩ ᩋᩃᩥᨠᩴ ᨽᨱᩮᨿ᩠ᨿ.

᪔᪐᪕.

‘‘ᩈᨧᩮᨸᩥ ᩅᩣᨲᩮᩣ ᨣᩥᩁᩥᨾᩣᩅᩉᩮᨿ᩠ᨿ, ᨧᨶ᩠ᨴᩮᩣ ᨧ ᩈᩪᩁᩥᨿᩮᩣ ᨧ ᨨᨾᩣ ᨸᨲᩮᨿ᩠ᨿᩩᩴ;

ᩈᨻ᩠ᨻᩣ ᨧ ᨶᨩ᩠ᨩᩮᩣ ᨸᨭᩥᩈᩮᩣᨲᩴ ᩅᨩᩮᨿ᩠ᨿᩩᩴ, ᨶ ᨲ᩠ᩅᩮᩅᩉᩴ ᩁᩣᨩ ᨾᩩᩈᩣ ᨽᨱᩮᨿ᩠ᨿᩴ.

᪔᪐᪖.

[ᩋᨿᩴ ᨣᩣᨳᩣ ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ ᨶ ᨴᩥᩔᨲᩥ] ‘‘ᨶᨽᩴ ¶ ᨹᩃᩮᨿ᩠ᨿ ᩏᨴᨵᩦᨸᩥ ᩈᩩᩔᩮ, ᩈᩴᩅᨭ᩠ᨭᨿᩮ ᨽᩪᨲᨵᩁᩣ ᩅᩈᩩᨶ᩠ᨵᩁᩣ;

ᩈᩥᩃᩩᨧ᩠ᨧᨿᩮᩣ ᨾᩮᩁᩩ ᩈᨾᩪᩃᨾᩩᨸ᩠ᨸᨲᩮ, ᨶ ᨲ᩠ᩅᩮᩅᩉᩴ ᩁᩣᨩ ᨾᩩᩈᩣ ᨽᨱᩮᨿ᩠ᨿᩴ’’ [ᩋᨿᩴ ᨣᩣᨳᩣ ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ ᨶ ᨴᩥᩔᨲᩥ].

᪔᪐᪗.

‘‘ᩋᩈᩥᨬ᩠ᨧ ᩈᨲ᩠ᨲᩥᨬ᩠ᨧ ᨸᩁᩣᨾᩈᩣᨾᩥ, ᩈᨸᨳᨾ᩠ᨸᩥ ᨲᩮ ᩈᨾ᩠ᨾ ᩋᩉᩴ ᨠᩁᩮᩣᨾᩥ;

ᨲᨿᩣ ᨸᨾᩩᨲ᩠ᨲᩮᩣ ᩋᨶᨱᩮᩣ ᨽᩅᩥᨲ᩠ᩅᩣ, ᩈᨧ᩠ᨧᩣᨶᩩᩁᨠ᩠ᨡᩦ ᨸᩩᨶᩁᩣᩅᨩᩥᩔᩴ’’.

᪔᪐᪘.

‘‘ᨿᩮᩣ ᨲᩮ ᨠᨲᩮᩣ ᩈᨦ᩠ᨠᩁᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᨶ, ᩁᨭ᩠ᨮᩮ ᩈᨠᩮ ᩍᩔᩁᩥᨿᩮ ᨮᩥᨲᩮᨶ;

ᨲᩴ ᩈᨦ᩠ᨠᩁᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩈᨸ᩠ᨸᨴᩣᨿ, ᩈᨧ᩠ᨧᩣᨶᩩᩁᨠ᩠ᨡᩦ ᨸᩩᨶᩁᩣᩅᨩᩔᩩ’’.

᪔᪐᪙.

‘‘ᨿᩮᩣ ᨾᩮ ᨠᨲᩮᩣ ᩈᨦ᩠ᨠᩁᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᨶ, ᩁᨭ᩠ᨮᩮ ¶ ᩈᨠᩮ ᩍᩔᩁᩥᨿᩮ ᨮᩥᨲᩮᨶ;

ᨲᩴ ᩈᨦ᩠ᨠᩁᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩈᨸ᩠ᨸᨴᩣᨿ, ᩈᨧ᩠ᨧᩣᨶᩩᩁᨠ᩠ᨡᩦ ᨸᩩᨶᩁᩣᩅᨩᩥᩔᩴ’’.

᪔᪑᪐.

‘‘ᨾᩩᨲ᩠ᨲᩮᩣ ᨧ ᩈᩮᩣ ᨸᩮᩣᩁᩥᩈᩣᨴᩔ ᩉᨲ᩠ᨳᩣ, ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨲᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᩑᨲᨴᩅᩮᩣᨧ;

ᩈᩩᨱᩮᩣᨾ [ᩈᩩᨱᩮᩣᨾᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨣᩣᨳᩣᨿᩮᩣ ᩈᨲᩣᩁᩉᩣᨿᩮᩣ, ᨿᩣ ᨾᩮ ᩈᩩᨲᩣ ᩋᩔᩩ ᩉᩥᨲᩣᨿ ᨻᩕᩉ᩠ᨾᩮ’’.

᪔᪑᪑.

‘‘ᩈᨠᩥᨴᩮᩅ ᩈᩩᨲᩈᩮᩣᨾ, ᩈᨻ᩠ᨽᩥ ᩉᩮᩣᨲᩥ [ᩉᩮᩣᨲᩩ (ᨸᩦ.)] ᩈᨾᩣᨣᨾᩮᩣ;

ᩈᩣ ᨶᩴ ᩈᨦ᩠ᨣᨲᩥ ᨸᩣᩃᩮᨲᩥ, ᨶᩣᩈᨻ᩠ᨽᩥ ᨻᩉᩩᩈᨦ᩠ᨣᨾᩮᩣ.

᪔᪑᪒.

‘‘ᩈᨻ᩠ᨽᩥᩁᩮᩅ ᩈᨾᩣᩈᩮᨳ, ᩈᨻ᩠ᨽᩥ ᨠᩩᨻ᩠ᨻᩮᨳ ᩈᨶ᩠ᨳᩅᩴ;

ᩈᨲᩴ ᩈᨴ᩠ᨵᨾ᩠ᨾᨾᨬ᩠ᨬᩣᨿ, ᩈᩮᨿ᩠ᨿᩮᩣ ᩉᩮᩣᨲᩥ ᨶ ᨸᩣᨸᩥᨿᩮᩣ.

᪔᪑᪓.

‘‘ᨩᩦᩁᨶ᩠ᨲᩥ ᩅᩮ ᩁᩣᨩᩁᨳᩣ ᩈᩩᨧᩥᨲ᩠ᨲᩣ, ᩋᨳᩮᩣ ᩈᩁᩦᩁᨾ᩠ᨸᩥ ᨩᩁᩴ ᩏᨸᩮᨲᩥ;

ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩮᩣ ᨶ ᨩᩁᩴ ᩏᨸᩮᨲᩥ, ᩈᨶ᩠ᨲᩮᩣ ᩉᩅᩮ ᩈᨻ᩠ᨽᩥ ᨸᩅᩮᨴᨿᨶ᩠ᨲᩥ.

᪔᪑᪔.

‘‘ᨶᨽᨬ᩠ᨧᩴ ¶ ᨴᩪᩁᩮ ᨸᨳᩅᩦ ᨧ ᨴᩪᩁᩮ, ᨸᩣᩁᩴ ¶ ᩈᨾᩩᨴ᩠ᨴᩔ ᨲᨴᩣᩉᩩ ᨴᩪᩁᩮ;

ᨲᨲᩮᩣ ᩉᩅᩮ ᨴᩪᩁᨲᩁᩴ ᩅᨴᨶ᩠ᨲᩥ, ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩮᩣ [ᨵᨾ᩠ᨾᩴ (ᩈᩦ. ᨸᩦ.)] ᩋᩈᨲᨬ᩠ᨧ ᩁᩣᨩ’’.

᪔᪑᪕.

‘‘ᩈᩉᩔᩥᨿᩣ [ᩈᩉᩔᩥᨿᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᩍᨾᩣ ᨣᩣᨳᩣ, ᨶᩉᩥᨾᩣ [ᨶ ᩍᨾᩣ, (ᩈᩦ. ᨸᩦ.) ᨶᨿᩥᨾᩣ (ᩈ᩠ᨿᩣ.)] ᨣᩣᨳᩣ ᩈᨲᩣᩁᩉᩣ;

ᨧᨲ᩠ᨲᩣᩁᩥ ᨲ᩠ᩅᩴ ᩈᩉᩔᩣᨶᩥ, ᨡᩥᨸ᩠ᨸᩴ ᨣᨱ᩠ᩉᩣᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱ’’.

᪔᪑᪖.

‘‘ᩌᩈᩦᨲᩥᨿᩣ ᨶᩣᩅᩩᨲᩥᨿᩣ [ᩋᩈᩦᨲᩥᨿᩣ ᨶᩅᩩᨲᩥᨿᩣ (ᨸᩦ.)] ᨧ ᨣᩣᨳᩣ, ᩈᨲᩣᩁᩉᩣ ᨧᩣᨸᩥ ᨽᩅᩮᨿ᩠ᨿ [ᨽᩅᩮᨿ᩠ᨿᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨣᩣᨳᩣ;

ᨸᨧ᩠ᨧᨲ᩠ᨲᨾᩮᩅ ᩈᩩᨲᩈᩮᩣᨾ ᨩᩣᨶᩉᩥ, ᩈᩉᩔᩥᨿᩣ ᨶᩣᨾ ᨠᩣ ᩋᨲ᩠ᨳᩥ [ᩈᩉᩔᩥᨿᩮᩣ ᨶᩣᨾ ᩍᨵᨲ᩠ᨳᩥ (ᩈᩦ.)] ᨣᩣᨳᩣ’’.

᪔᪑᪗.

‘‘ᩍᨧ᩠ᨨᩣᨾᩥ ᩅᩮᩣᩉᩴ ᩈᩩᨲᩅᩩᨴ᩠ᨵᩥᨾᨲ᩠ᨲᨶᩮᩣ, ᩈᨶ᩠ᨲᩮᩣᨲᩥ ᨾᩴ [ᩈᨶ᩠ᨲᩮᩣ ᨾᨾᩴ (ᩈ᩠ᨿᩣ.), ᩈᨶ᩠ᨲᩮᩣ ᨧ ᨾᩴ (ᩈᩦ. ᨸᩦ. ᨠ.)] ᩈᨸ᩠ᨸᩩᩁᩥᩈᩣ ᨽᨩᩮᨿ᩠ᨿᩩᩴ;

ᩋᩉᩴ ᩈᩅᨶ᩠ᨲᩦᩉᩥ ᨾᩉᩮᩣᨴᨵᩦᩅ, ᨶ ᩉᩥ ᨲᩣᨲ ᨲᨸ᩠ᨸᩣᨾᩥ ᩈᩩᨽᩣᩈᩥᨲᩮᨶ.

᪔᪑᪘.

‘‘ᩋᨣ᩠ᨣᩥ ¶ ᨿᨳᩣ ᨲᩥᨱᨠᨭ᩠ᨮᩴ ᨴᩉᨶ᩠ᨲᩮᩣ, ᨶ ᨲᨸ᩠ᨸᨲᩦ ᩈᩣᨣᩁᩮᩣᩅ [ᩈᩣᨣᩁᩮᩣ ᩅᩣ (ᩈᩦ. ᨸᩦ.)] ᨶᨴᩦᩉᩥ;

ᩑᩅᨾ᩠ᨸᩥ ᨲᩮ ᨸᨱ᩠ᨯᩥᨲᩣ ᩁᩣᨩᩈᩮᨭ᩠ᨮ, ᩈᩩᨲ᩠ᩅᩣ ᨶ ᨲᨸ᩠ᨸᨶ᩠ᨲᩥ ᩈᩩᨽᩣᩈᩥᨲᩮᨶ.

᪔᪑᪙.

‘‘ᩈᨠᩔ ᨴᩣᩈᩔ ᨿᨴᩣ ᩈᩩᨱᩮᩣᨾᩥ, ᨣᩣᨳᩴ ᩋᩉᩴ ᩋᨲ᩠ᨳᩅᨲᩥᩴ [ᨣᩣᨳᩣ ᩋᩉᩴ ᩋᨲ᩠ᨳᩅᨲᩦ (ᩈᩦ. ᨸᩦ.)] ᨩᨶᩥᨶ᩠ᨴ;

ᨲᨾᩮᩅ ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨶᩥᩈᩣᨾᨿᩣᨾᩥ, ᨶ ¶ ᩉᩥ ᨲᩣᨲ ᨵᨾ᩠ᨾᩮᩈᩩ ᨾᨾᨲ᩠ᨳᩥ ᨲᩥᨲ᩠ᨲᩥ’’.

᪔᪒᪐.

‘‘ᩍᨴᩴ ¶ ᨲᩮ ᩁᨭ᩠ᨮᩴ ᩈᨵᨶᩴ ᩈᨿᩮᩣᨣ᩠ᨣᩴ, ᩈᨠᩣᨿᩩᩁᩴ ᩈᨻ᩠ᨻᨠᩣᨾᩪᨸᨸᨶ᩠ᨶᩴ;

ᨠᩥᩴ ᨠᩣᨾᩉᩮᨲᩩ ᨸᩁᩥᨽᩣᩈᩈᩥᨾᩴ [ᨽᩣᩈᩈᩮ ᨾᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨣᨧ᩠ᨨᩣᨾᩉᩴ ᨸᩮᩣᩁᩥᩈᩣᨴᩔ ᨬᨲ᩠ᨲᩮ’’ [ᨸᩮᩣᩁᩥᩈᩣᨴᩔ ᨠᨶ᩠ᨲᩮ (ᩈᩦ. ᨸᩦ.), ᨸᩮᩣᩁᩥᩈᩣᨴᩔᩩᨸᨶ᩠ᨲᩮ (ᨠ.)].

᪔᪒᪑.

‘‘ᩋᨲ᩠ᨲᩣᨶᩩᩁᨠ᩠ᨡᩣᨿ ᨽᩅᨶ᩠ᨲᩥ ᩉᩮᨲᩮ, ᩉᨲ᩠ᨳᩣᩁᩮᩣᩉᩣ ᩁᨳᩥᨠᩣ ᨸᨲ᩠ᨲᩥᨠᩣ ᨧ;

ᩋᩔᩣᩁᩩᩉᩣ [ᩋᩔᩣᩁᩮᩣᩉᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨿᩮ ᨧ ᨵᨶᩩᨣ᩠ᨣᩉᩣᩈᩮ, ᩈᩮᨶᩴ ᨸᨿᩩᨬ᩠ᨩᩣᨾ ᩉᨶᩣᨾ ᩈᨲ᩠ᨲᩩᩴ’’.

᪔᪒᪒.

‘‘ᩈᩩᨴᩩᨠ᩠ᨠᩁᩴ ᨸᩮᩣᩁᩥᩈᩣᨴᩮᩣ ᩋᨠᩣᩈᩥ, ᨩᩦᩅᩴ ᨣᩉᩮᨲ᩠ᩅᩣᨶ ᩋᩅᩔᨩᩦ ᨾᩴ;

ᨲᩴ ᨲᩣᨴᩥᩈᩴ ᨸᩩᨻ᩠ᨻᨠᩥᨧ᩠ᨧᩴ ᩈᩁᨶ᩠ᨲᩮᩣ, ᨴᩩᨻ᩠ᨽᩮ ᩋᩉᩴ ᨲᩔ ᨠᨳᩴ ᨩᨶᩥᨶ᩠ᨴ’’.

᪔᪒᪓.

‘‘ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ ᩈᩮᩣ ᨸᩥᨲᩁᩴ ᨾᩣᨲᩁᨬ᩠ᨧ, ᩋᨶᩩᩈᩣᩈᩮᨲ᩠ᩅᩣ ᨶᩮᨣᨾᨬ᩠ᨧ ᨻᩃᨬ᩠ᨧ;

ᩈᨧ᩠ᨧᩅᩣᨴᩦ ᩈᨧ᩠ᨧᩣᨶᩩᩁᨠ᩠ᨡᨾᩣᨶᩮᩣ, ᩋᨣᨾᩣᩈᩥ ᩈᩮᩣ ᨿᨲ᩠ᨳ ᨸᩮᩣᩁᩥᩈᩣᨴᩮᩣ’’.

᪔᪒᪔.

‘‘ᨠᨲᩮᩣ ᨾᨿᩣ ᩈᨦ᩠ᨠᩁᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᨶ, ᩁᨭ᩠ᨮᩮ ᩈᨠᩮ ᩍᩔᩁᩥᨿᩮ ᨮᩥᨲᩮᨶ;

ᨲᩴ ᩈᨦ᩠ᨠᩁᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩈᨸ᩠ᨸᨴᩣᨿ, ᩈᨧ᩠ᨧᩣᨶᩩᩁᨠ᩠ᨡᩦ ¶ ᨸᩩᨶᩁᩣᨣᨲᩮᩣᩈ᩠ᨾᩥ;

ᨿᨩᩔᩩ ᨿᨬ᩠ᨬᩴ ᨡᩣᨴ ᨾᩴ ᨸᩮᩣᩁᩥᩈᩣᨴ’’.

᪔᪒᪕.

‘‘ᨶ ᩉᩣᨿᨲᩮ ᨡᩣᨴᩥᨲᩴ [ᨡᩣᨴᩥᨲᩩᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᨿ᩠ᩉᩴ ᨸᨧ᩠ᨨᩣ, ᨧᩥᨲᨠᩣ ᩋᨿᩴ ᨲᩣᩅ ᩈᨵᩪᨾᩥᨠᩣᩅ [ᩈᨵᩪᨾᨠᩣ ᨧ (ᩈ᩠ᨿᩣ.)];

ᨶᩥᨴ᩠ᨵᩪᨾᨠᩮ ᨸᨧᩥᨲᩴ ᩈᩣᨵᩩᨸᨠ᩠ᨠᩴ, ᩈᩩᨱᩮᩣᨾ [ᩈᩩᨱᩮᩣᨾᩥ (ᩈᩦ.), ᩈᩩᨱᩣᨾ (ᨸᩦ.)] ᨣᩣᨳᩣᨿᩮᩣ ᩈᨲᩣᩁᩉᩣᨿᩮᩣ’’.

᪔᪒᪖.

‘‘ᩋᨵᨾ᩠ᨾᩥᨠᩮᩣ ¶ ᨲ᩠ᩅᩴ ᨸᩮᩣᩁᩥᩈᩣᨴᨠᩣᩈᩥ [ᨸᩮᩣᩁᩥᩈᩣᨴᨾᨠᩣᩈᩥ (ᨠ.)], ᩁᨭ᩠ᨮᩣ ᨧ ᨽᨭ᩠ᨮᩮᩣ ᩏᨴᩁᩔ ᩉᩮᨲᩩ;

ᨵᨾ᩠ᨾᨬ᩠ᨧᩥᨾᩣ ᩋᨽᩥᩅᨴᨶ᩠ᨲᩥ ᨣᩣᨳᩣ, ᨵᨾ᩠ᨾᩮᩣ ᨧ ᩋᨵᨾ᩠ᨾᩮᩣ ᨧ ᨠᩩᩉᩥᩴ ᩈᨾᩮᨲᩥ.

᪔᪒᪗.

‘‘ᩋᨵᨾ᩠ᨾᩥᨠᩔ ᩃᩩᨴ᩠ᨴᩔ, ᨶᩥᨧ᩠ᨧᩴ ᩃᩮᩣᩉᩥᨲᨸᩣᨱᩥᨶᩮᩣ;

ᨶᨲ᩠ᨳᩥ ᩈᨧ᩠ᨧᩴ ᨠᩩᨲᩮᩣ ᨵᨾ᩠ᨾᩮᩣ, ᨠᩥᩴ ᩈᩩᨲᩮᨶ ᨠᩁᩥᩔᩈᩥ’’.

᪔᪒᪘.

‘‘ᨿᩮᩣ ᨾᩴᩈᩉᩮᨲᩩ ᨾᩥᨣᩅᩴ ᨧᩁᩮᨿ᩠ᨿ, ᨿᩮᩣ ᩅᩣ ᩉᨶᩮ ᨸᩩᩁᩥᩈᨾᨲ᩠ᨲᩉᩮᨲᩩ;

ᩏᨽᩮᩣᨸᩥ ᨲᩮ ᨸᩮᨧ᩠ᨧ ᩈᨾᩣ ᨽᩅᨶ᩠ᨲᩥ, ᨠᩈ᩠ᨾᩣ ᨶᩮᩣ [ᨠᩈ᩠ᨾᩣ ᨶᩩ (ᨠ.)] ᩋᨵᨾ᩠ᨾᩥᨠᩴ ᨻᩕᩪᩈᩥ ᨾᩴ ᨲ᩠ᩅᩴ’’.

᪔᪒᪙.

‘‘ᨸᨬ᩠ᨧ ᨸᨬ᩠ᨧᨶᨡᩣ ᨽᨠ᩠ᨡᩣ, ᨡᨲ᩠ᨲᩥᨿᩮᨶ ᨸᨩᩣᨶᨲᩣ;

ᩋᨽᨠ᩠ᨡᩴ ᩁᩣᨩ ᨽᨠ᩠ᨡᩮᩈᩥ, ᨲᩈ᩠ᨾᩣ ᩋᨵᨾ᩠ᨾᩥᨠᩮᩣ ᨲᩩᩅᩴ’’.

᪔᪓᪐.

‘‘ᨾᩩᨲ᩠ᨲᩮᩣ ᨲᩩᩅᩴ ᨸᩮᩣᩁᩥᩈᩣᨴᩔ ᩉᨲ᩠ᨳᩣ, ᨣᨶ᩠ᨲ᩠ᩅᩣ ᩈᨠᩴ ᨾᨶ᩠ᨴᩥᩁᩴ ᨠᩣᨾᨠᩣᨾᩦ;

ᩋᨾᩥᨲ᩠ᨲᩉᨲ᩠ᨳᩴ ¶ ᨸᩩᨶᩁᩣᨣᨲᩮᩣᩈᩥ, ᨶ ᨡᨲ᩠ᨲᨵᨾ᩠ᨾᩮ ᨠᩩᩈᩃᩮᩣᩈᩥ ᩁᩣᨩ’’.

᪔᪓᪑.

‘‘ᨿᩮ ¶ ᨡᨲ᩠ᨲᨵᨾ᩠ᨾᩮ ᨠᩩᩈᩃᩣ ᨽᩅᨶ᩠ᨲᩥ, ᨸᩣᨿᩮᨶ ᨲᩮ ᨶᩮᩁᨿᩥᨠᩣ ᨽᩅᨶ᩠ᨲᩥ;

ᨲᩈ᩠ᨾᩣ ᩋᩉᩴ ᨡᨲ᩠ᨲᨵᨾ᩠ᨾᩴ ᨸᩉᩣᨿ, ᩈᨧ᩠ᨧᩣᨶᩩᩁᨠ᩠ᨡᩦ ᨸᩩᨶᩁᩣᨣᨲᩮᩣᩈ᩠ᨾᩥ;

ᨿᨩᩔᩩ ᨿᨬ᩠ᨬᩴ ᨡᩣᨴ ᨾᩴ ᨸᩮᩣᩁᩥᩈᩣᨴ’’.

᪔᪓᪒.

‘‘ᨸᩣᩈᩣᨴᩅᩣᩈᩣ ᨸᨳᩅᩦᨣᩅᩔᩣ, ᨠᩣᨾᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨠᩣᩈᩥᨠᨧᨶ᩠ᨴᨶᨬ᩠ᨧ;

ᩈᨻ᩠ᨻᩴ ᨲᩉᩥᩴ ᩃᨽᩈᩥ [ᩃᨻ᩠ᨽᨲᩥ (ᨸᩦ.)] ᩈᩣᨾᩥᨲᩣᨿ, ᩈᨧ᩠ᨧᩮᨶ ᨠᩥᩴ ᨸᩔᩈᩥ ᩌᨶᩥᩈᩴᩈᩴ’’.

᪔᪓᪓.

‘‘ᨿᩮ ¶ ᨠᩮᨧᩥᨾᩮ ᩋᨲ᩠ᨳᩥ ᩁᩈᩣ ᨸᨳᨻ᩠ᨿᩣ, ᩈᨧ᩠ᨧᩴ ᨲᩮᩈᩴ ᩈᩣᨵᩩᨲᩁᩴ ᩁᩈᩣᨶᩴ;

ᩈᨧ᩠ᨧᩮ ᨮᩥᨲᩣ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨧ, ᨲᩁᨶ᩠ᨲᩥ ᨩᩣᨲᩥᨾᩁᨱᩔ ᨸᩣᩁᩴ’’.

᪔᪓᪔.

‘‘ᨾᩩᨲ᩠ᨲᩮᩣ ᨲᩩᩅᩴ ᨸᩮᩣᩁᩥᩈᩣᨴᩔ ᩉᨲ᩠ᨳᩣ, ᨣᨶ᩠ᨲ᩠ᩅᩣ ᩈᨠᩴ ᨾᨶ᩠ᨴᩥᩁᩴ ᨠᩣᨾᨠᩣᨾᩦ;

ᩋᨾᩥᨲ᩠ᨲᩉᨲ᩠ᨳᩴ ᨸᩩᨶᩁᩣᨣᨲᩮᩣᩈᩥ, ᨶ ᩉᩥ ᨶᩪᨶ ᨲᩮ ᨾᩁᨱᨽᨿᩴ ᨩᨶᩥᨶ᩠ᨴ;

ᩋᩃᩦᨶᨧᩥᨲ᩠ᨲᩮᩣ ᩋᩈᩥ [ᨧ’ᩈᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩈᨧ᩠ᨧᩅᩣᨴᩦ’’.

᪔᪓᪕.

‘‘ᨠᨲᩣ ¶ ᨾᩮ ᨠᩃ᩠ᨿᩣᨱᩣ ᩋᨶᩮᨠᩁᩪᨸᩣ, ᨿᨬ᩠ᨬᩣ ᨿᩥᨭ᩠ᨮᩣ ᨿᩮ ᩅᩥᨸᩩᩃᩣ ᨸᩈᨲ᩠ᨳᩣ;

ᩅᩥᩈᩮᩣᨵᩥᨲᩮᩣ ᨸᩁᩃᩮᩣᨠᩔ ᨾᨣ᩠ᨣᩮᩣ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩮᩣ ᨠᩮᩣ ᨾᩁᨱᩔ ᨽᩣᨿᩮ.

᪔᪓᪖.

‘‘ᨠᨲᩣ ᨾᩮ ᨠᩃ᩠ᨿᩣᨱᩣ ᩋᨶᩮᨠᩁᩪᨸᩣ, ᨿᨬ᩠ᨬᩣ ᨿᩥᨭ᩠ᨮᩣ ᨿᩮ ᩅᩥᨸᩩᩃᩣ ᨸᩈᨲ᩠ᨳᩣ;

ᩋᨶᩣᨶᩩᨲᨸ᩠ᨸᩴ ᨸᩁᩃᩮᩣᨠᩴ ᨣᨾᩥᩔᩴ, ᨿᨩᩔᩩ ᨿᨬ᩠ᨬᩴ ᩋᨴ [ᨡᩣᨴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩴ ᨸᩮᩣᩁᩥᩈᩣᨴ.

᪔᪓᪗.

‘‘ᨸᩥᨲᩣ ᨧ ᨾᩣᨲᩣ ᨧ ᩏᨸᨭ᩠ᨮᩥᨲᩣ ᨾᩮ, ᨵᨾ᩠ᨾᩮᨶ ᨾᩮ ᩍᩔᩁᩥᨿᩴ ᨸᩈᨲ᩠ᨳᩴ;

ᩅᩥᩈᩮᩣᨵᩥᨲᩮᩣ ᨸᩁᩃᩮᩣᨠᩔ ᨾᨣ᩠ᨣᩮᩣ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩮᩣ ᨠᩮᩣ ᨾᩁᨱᩔ ᨽᩣᨿᩮ.

᪔᪓᪘.

‘‘ᨸᩥᨲᩣ ᨧ ᨾᩣᨲᩣ ᨧ ᩏᨸᨭ᩠ᨮᩥᨲᩣ ᨾᩮ, ᨵᨾ᩠ᨾᩮᨶ ᨾᩮ ᩍᩔᩁᩥᨿᩴ ᨸᩈᨲ᩠ᨳᩴ;

ᩋᨶᩣᨶᩩᨲᨸ᩠ᨸᩴ ᨸᩁᩃᩮᩣᨠᩴ ᨣᨾᩥᩔᩴ, ᨿᨩᩔᩩ ᨿᨬ᩠ᨬᩴ ᩋᨴ ᨾᩴ ᨸᩮᩣᩁᩥᩈᩣᨴ.

᪔᪓᪙.

‘‘ᨬᩣᨲᩦᩈᩩ ¶ ᨾᩥᨲ᩠ᨲᩮᩈᩩ ᨠᨲᩣ ᨾᩮ ᨠᩣᩁᩣ [ᨠᨲᩪᨸᨠᩣᩁᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨵᨾ᩠ᨾᩮᨶ ᨾᩮ ᩍᩔᩁᩥᨿᩴ ᨸᩈᨲ᩠ᨳᩴ;

ᩅᩥᩈᩮᩣᨵᩥᨲᩮᩣ ᨸᩁᩃᩮᩣᨠᩔ ᨾᨣ᩠ᨣᩮᩣ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩮᩣ ᨠᩮᩣ ᨾᩁᨱᩔ ᨽᩣᨿᩮ.

᪔᪔᪐.

‘‘ᨬᩣᨲᩦᩈᩩᩴ ¶ ᨾᩥᨲ᩠ᨲᩮᩈᩩ ᨠᨲᩣ ᨾᩮ ᨠᩣᩁᩣ, ᨵᨾ᩠ᨾᩮᨶ ᨾᩮ ᩍᩔᩁᩥᨿᩴ ᨸᩈᨲ᩠ᨳᩴ;

ᩋᨶᩣᨶᩩᨲᨸ᩠ᨸᩴ ᨸᩁᩃᩮᩣᨠᩴ ᨣᨾᩥᩔᩴ, ᨿᨩᩔᩩ ᨿᨬ᩠ᨬᩴ ᩋᨴ ᨾᩴ ᨸᩮᩣᩁᩥᩈᩣᨴ.

᪔᪔᪑.

‘‘ᨴᩥᨶ᩠ᨶᩴ ᨾᩮ ᨴᩣᨶᩴ ᨻᩉᩩᨵᩣ ᨻᩉᩪᨶᩴ, ᩈᨶ᩠ᨲᨸ᩠ᨸᩥᨲᩣ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨧ;

ᩅᩥᩈᩮᩣᨵᩥᨲᩮᩣ ᨸᩁᩃᩮᩣᨠᩔ ᨾᨣ᩠ᨣᩮᩣ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩮᩣ ᨠᩮᩣ ᨾᩁᨱᩔ ᨽᩣᨿᩮ.

᪔᪔᪒.

‘‘ᨴᩥᨶ᩠ᨶᩴ ᨾᩮ ᨴᩣᨶᩴ ᨻᩉᩩᨵᩣ ᨻᩉᩪᨶᩴ, ᩈᨶ᩠ᨲᨸ᩠ᨸᩥᨲᩣ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨧ;

ᩋᨶᩣᨶᩩᨲᨸ᩠ᨸᩴ ᨸᩁᩃᩮᩣᨠᩴ ᨣᨾᩥᩔᩴ, ᨿᨩᩔᩩ ᨿᨬ᩠ᨬᩴ ᩋᨴ ᨾᩴ ᨸᩮᩣᩁᩥᩈᩣᨴ’’.

᪔᪔᪓.

‘‘ᩅᩥᩈᩴ ᨸᨩᩣᨶᩴ ᨸᩩᩁᩥᩈᩮᩣ ᩋᨴᩮᨿ᩠ᨿ, ᩌᩈᩦᩅᩥᩈᩴ ᨩᩃᩥᨲᨾᩩᨣ᩠ᨣᨲᩮᨩᩴ;

ᨾᩩᨴ᩠ᨵᩣᨸᩥ ᨲᩔ ᩅᩥᨹᩃᩮᨿ᩠ᨿ [ᩅᩥᨸᨲᩮᨿ᩠ᨿ (ᩈᩦ. ᨸᩦ.)] ᩈᨲ᩠ᨲᨵᩣ, ᨿᩮᩣ ᨲᩣᨴᩥᩈᩴ ᩈᨧ᩠ᨧᩅᩣᨴᩥᩴ ᩋᨴᩮᨿ᩠ᨿ’’.

᪔᪔᪔.

‘‘ᩈᩩᨲ᩠ᩅᩣ ᨵᨾ᩠ᨾᩴ ᩅᩥᨩᩣᨶᨶ᩠ᨲᩥ, ᨶᩁᩣ ᨠᩃ᩠ᨿᩣᨱᨸᩣᨸᨠᩴ;

ᩋᨸᩥ ᨣᩣᨳᩣ ᩈᩩᨱᩥᨲ᩠ᩅᩣᨶ, ᨵᨾ᩠ᨾᩮ ᨾᩮ ᩁᨾᨲᩮ [ᩁᨾᨲᩦ (ᩈᩦ. ᨸᩦ.)] ᨾᨶᩮᩣ’’.

᪔᪔᪕.

‘‘ᩈᨠᩥᨴᩮᩅ ¶ ᨾᩉᩣᩁᩣᨩ [ᩈᩩᨲᩈᩮᩣᨾ (ᩈᩦ. ᨸᩦ.)], ᩈᨻ᩠ᨽᩥ ᩉᩮᩣᨲᩥ ᩈᨾᩣᨣᨾᩮᩣ;

ᩈᩣ ᨶᩴ ᩈᨦ᩠ᨣᨲᩥ ᨸᩣᩃᩮᨲᩥ, ᨶᩣᩈᨻ᩠ᨽᩥ ᨻᩉᩩᩈᨦ᩠ᨣᨾᩮᩣ.

᪔᪔᪖.

‘‘ᩈᨻ᩠ᨽᩥᩁᩮᩅ ¶ ᩈᨾᩣᩈᩮᨳ, ᩈᨻ᩠ᨽᩥ ᨠᩩᨻ᩠ᨻᩮᨳ ᩈᨶ᩠ᨳᩅᩴ;

ᩈᨲᩴ ᩈᨴ᩠ᨵᨾ᩠ᨾᨾᨬ᩠ᨬᩣᨿ, ᩈᩮᨿ᩠ᨿᩮᩣ ᩉᩮᩣᨲᩥ ᨶ ᨸᩣᨸᩥᨿᩮᩣ.

᪔᪔᪗.

‘‘ᨩᩦᩁᨶ᩠ᨲᩥ ᩅᩮ ᩁᩣᨩᩁᨳᩣ ᩈᩩᨧᩥᨲ᩠ᨲᩣ, ᩋᨳᩮᩣ ᩈᩁᩦᩁᨾ᩠ᨸᩥ ᨩᩁᩴ ᩏᨸᩮᨲᩥ;

ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩮᩣ ᨶ ᨩᩁᩴ ᩏᨸᩮᨲᩥ, ᩈᨶ᩠ᨲᩮᩣ ᩉᩅᩮ ᩈᨻ᩠ᨽᩥ ᨸᩅᩮᨴᨿᨶ᩠ᨲᩥ.

᪔᪔᪘.

‘‘ᨶᨽᨬ᩠ᨧᩴ ¶ ᨴᩪᩁᩮ ᨸᨳᩅᩦ ᨧ ᨴᩪᩁᩮ, ᨸᩣᩁᩴ ᩈᨾᩩᨴ᩠ᨴᩔ ᨲᨴᩣᩉᩩ ᨴᩪᩁᩮ;

ᨲᨲᩮᩣ ᩉᩅᩮ ᨴᩪᩁᨲᩁᩴ ᩅᨴᨶ᩠ᨲᩥ, ᩈᨲᨬ᩠ᨧ ᨵᨾ᩠ᨾᩮᩣ [ᨵᨾ᩠ᨾᩴ (ᩈᩦ. ᨸᩦ.)] ᩋᩈᨲᨬ᩠ᨧ ᩁᩣᨩ’’.

᪔᪔᪙.

‘‘ᨣᩣᨳᩣ ᩍᨾᩣ ᩋᨲ᩠ᨳᩅᨲᩦ ᩈᩩᨻ᩠ᨿᨬ᩠ᨩᨶᩣ, ᩈᩩᨽᩣᩈᩥᨲᩣ ᨲᩩᨿ᩠ᩉ ᨩᨶᩥᨶ᩠ᨴ ᩈᩩᨲ᩠ᩅᩣ;

ᩌᨶᨶ᩠ᨴᩥ ᩅᩥᨲ᩠ᨲᩮᩣ ᩈᩩᨾᨶᩮᩣ ᨸᨲᩦᨲᩮᩣ, ᨧᨲ᩠ᨲᩣᩁᩥ ᨲᩮ ᩈᨾ᩠ᨾ ᩅᩁᩮ ᨴᨴᩣᨾᩥ’’.

᪔᪕᪐.

‘‘ᨿᩮᩣ ᨶᨲ᩠ᨲᨶᩮᩣ ᨾᩁᨱᩴ ᨻᩩᨩ᩠ᨫᩈᩥ ᨲᩩᩅᩴ [ᨻᩩᨩ᩠ᨫᩈᩮ ᨲ᩠ᩅᩴ (ᩈᩦ. ᨸᩦ.), ᨻᩩᨩ᩠ᨫᩈᩮ ᨲᩩᩅᩴ (ᩈ᩠ᨿᩣ.)], ᩉᩥᨲᩣᩉᩥᨲᩴ ᩅᩥᨶᩥᨸᩣᨲᨬ᩠ᨧ ᩈᨣ᩠ᨣᩴ;

ᨣᩥᨴ᩠ᨵᩮᩣ ᩁᩈᩮ ᨴᩩᨧ᩠ᨧᩁᩥᨲᩮ ᨶᩥᩅᩥᨭ᩠ᨮᩮᩣ, ᨠᩥᩴ ᨲ᩠ᩅᩴ ᩅᩁᩴ ᨴᩔᩈᩥ ᨸᩣᨸᨵᨾ᩠ᨾ.

᪔᪕᪑.

‘‘ᩋᩉᨬ᩠ᨧ ᨲᩴ ᨴᩮᩉᩥ ᩅᩁᨶ᩠ᨲᩥ ᩅᨩ᩠ᨩᩴ, ᨲ᩠ᩅᨬ᩠ᨧᩣᨸᩥ ᨴᨲ᩠ᩅᩣᨶ ᩋᩅᩣᨠᩁᩮᨿ᩠ᨿ;

ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨠᩴ ¶ ᨠᩃᩉᨾᩥᨾᩴ ᩅᩥᩅᩣᨴᩴ, ᨠᩮᩣ ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᨩᩣᨶᨾᩩᨸᨻ᩠ᨻᨩᩮᨿ᩠ᨿ’’.

᪔᪕᪒.

‘‘ᨶ ᨲᩴ ᩅᩁᩴ ᩋᩁᩉᨲᩥ ᨩᨶ᩠ᨲᩩ ᨴᩣᨲᩩᩴ, ᨿᩴ ᩅᩣᨸᩥ ᨴᨲ᩠ᩅᩣᨶ ᩋᩅᩣᨠᩁᩮᨿ᩠ᨿ;

ᩅᩁᩔᩩ ᩈᨾ᩠ᨾ ᩋᩅᩥᨠᨾ᩠ᨸᨾᩣᨶᩮᩣ, ᨸᩣᨱᩴ ᨧᨩᩥᨲ᩠ᩅᩣᨶᨸᩥ ᨴᩔᨾᩮᩅ’’.

᪔᪕᪓.

‘‘ᩋᩁᩥᨿᩔ ᩋᩁᩥᨿᩮᨶ ᩈᨾᩮᨲᩥ ᩈᨡ᩠ᨿᩴ [ᩈᨠ᩠ᨡᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨸᨬ᩠ᨬᩔ ᨸᨬ᩠ᨬᩣᨱᩅᨲᩣ ᩈᨾᩮᨲᩥ;

ᨸᩔᩮᨿ᩠ᨿ ᨲᩴ ᩅᩔᩈᨲᩴ ᩋᩁᩮᩣᨣᩴ [ᩌᩁᩮᩣᨣ᩠ᨿᩴ (ᨠ.)], ᩑᨲᩴ ᩅᩁᩣᨶᩴ ᨸᨮᨾᩴ ᩅᩁᩣᨾᩥ’’.

᪔᪕᪔.

‘‘ᩋᩁᩥᨿᩔ ᩋᩁᩥᨿᩮᨶ ᩈᨾᩮᨲᩥ ᩈᨡ᩠ᨿᩴ, ᨸᨬ᩠ᨬᩔ ᨸᨬ᩠ᨬᩣᨱᩅᨲᩣ ᩈᨾᩮᨲᩥ;

ᨸᩔᩣᩈᩥ ᨾᩴ ᩅᩔᩈᨲᩴ ᩋᩁᩮᩣᨣᩴ, ᩑᨲᩴ ᩅᩁᩣᨶᩴ ᨸᨮᨾᩴ ᨴᨴᩣᨾᩥ’’.

᪔᪕᪕.

‘‘ᨿᩮ ¶ ᨡᨲ᩠ᨲᩥᨿᩣᩈᩮ ᩍᨵ ᨽᩪᨾᩥᨸᩣᩃᩣ, ᨾᩩᨴ᩠ᨵᩣᨽᩥᩈᩥᨲ᩠ᨲᩣ ᨠᨲᨶᩣᨾᨵᩮᨿ᩠ᨿᩣ;

ᨶ ᨲᩣᨴᩥᩈᩮ ᨽᩪᨾᩥᨸᨲᩦ ᩋᨴᩮᩈᩥ, ᩑᨲᩴ ᩅᩁᩣᨶᩴ ᨴᩩᨲᩥᨿᩴ ᩅᩁᩣᨾᩥ’’.

᪔᪕᪖.

‘‘ᨿᩮ ᨡᨲ᩠ᨲᩥᨿᩣᩈᩮ ᩍᨵ ᨽᩪᨾᩥᨸᩣᩃᩣ, ᨾᩩᨴ᩠ᨵᩣᨽᩥᩈᩥᨲ᩠ᨲᩣ ᨠᨲᨶᩣᨾᨵᩮᨿ᩠ᨿᩣ;

ᨶ ¶ ᨲᩣᨴᩥᩈᩮ ᨽᩪᨾᩥᨸᨲᩦ ᩋᨴᩮᨾᩥ, ᩑᨲᩴ ᩅᩁᩣᨶᩴ ᨴᩩᨲᩥᨿᩴ ᨴᨴᩣᨾᩥ’’.

᪔᪕᪗.

‘‘ᨸᩁᩮᩣᩈᨲᩴ ᨡᨲ᩠ᨲᩥᨿᩣ ᨲᩮ ᨣᩉᩥᨲᩣ, ᨲᩃᩣᩅᩩᨲᩣ ᩋᩔᩩᨾᩩᨡᩣ ᩁᩩᨴᨶ᩠ᨲᩣ;

ᩈᨠᩮ ᨲᩮ ᩁᨭ᩠ᨮᩮ ᨸᨭᩥᨸᩣᨴᨿᩣᩉᩥ, ᩑᨲᩴ ᩅᩁᩣᨶᩴ ᨲᨲᩥᨿᩴ ᩅᩁᩣᨾᩥ’’.

᪔᪕᪘.

‘‘ᨸᩁᩮᩣᩈᨲᩴ ᨡᨲ᩠ᨲᩥᨿᩣ ᨾᩮ ᨣᩉᩥᨲᩣ, ᨲᩃᩣᩅᩩᨲᩣ ᩋᩔᩩᨾᩩᨡᩣ ᩁᩩᨴᨶ᩠ᨲᩣ;

ᩈᨠᩮ ᨲᩮ ᩁᨭ᩠ᨮᩮ ᨸᨭᩥᨸᩣᨴᨿᩣᨾᩥ [ᩈᨠᩮᨶ ᩁᨭ᩠ᨮᩮᨶ ᨸᨭᩥᨸᩣᨴᨿᩣᨾᩥ ᨲᩮ (ᩈᩦ.)], ᩑᨲᩴ ᩅᩁᩣᨶᩴ ᨲᨲᩥᨿᩴ ᨴᨴᩣᨾᩥ’’.

᪔᪕᪙.

‘‘ᨨᩥᨴ᩠ᨴᩴ ᨲᩮ ᩁᨭ᩠ᨮᩴ ᨻ᩠ᨿᨳᩥᨲᩣ [ᨻ᩠ᨿᨳᩥᨲᩴ (ᩈᩦ.), ᨻ᩠ᨿᩣᨵᩥᨲᩴ (ᨸᩦ.)] ᨽᨿᩣ ᩉᩥ, ᨸᩩᨳᩪ ᨶᩁᩣ ᩃᩮᨱᨾᨶᩩᨸ᩠ᨸᩅᩥᨭ᩠ᨮᩣ;

ᨾᨶᩩᩔᨾᩴᩈᩴ ᩅᩥᩁᨾᩮᩉᩥ [ᩅᩥᩁᨾᩣᩉᩥ (ᩈ᩠ᨿᩣ.)] ᩁᩣᨩ, ᩑᨲᩴ ᩅᩁᩣᨶᩴ ᨧᨲᩩᨲ᩠ᨳᩴ ᩅᩁᩣᨾᩥ’’.

᪔᪖᪐.

‘‘ᩋᨴ᩠ᨵᩣ ¶ ᩉᩥ ᩈᩮᩣ ᨽᨠ᩠ᨡᩮᩣ ᨾᨾ [ᨾᨾᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᨶᩣᨸᩮᩣ, ᩑᨲᩔ ᩉᩮᨲᩩᨾ᩠ᩉᩥ [ᩉᩮᨲᩩᨾ᩠ᨸᩥ (ᨸᩦ.)] ᩅᨶᩴ ᨸᩅᩥᨭ᩠ᨮᩮᩣ;

ᩈᩮᩣᩉᩴ ᨠᨳᩴ ᩑᨲ᩠ᨲᩮᩣ ᩏᨸᩣᩁᨾᩮᨿ᩠ᨿᩴ, ᩋᨬ᩠ᨬᩴ ᩅᩁᩣᨶᩴ ᨧᨲᩩᨲ᩠ᨳᩴ ᩅᩁᩔᩩ’’.

᪔᪖᪑.

‘‘ᨶᩴ ¶ ᩅᩮ ᨸᩥᨿᩴ ᨾᩮᨲᩥ ᨩᨶᩥᨶ᩠ᨴ ᨲᩣᨴᩥᩈᩮᩣ, ᩋᨲ᩠ᨲᩴ ᨶᩥᩁᩴᨠᨧ᩠ᨧ [ᨶᩥᩁᩴᨠᨲ᩠ᩅᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᩥᨿᩣᨶᩥ ᩈᩮᩅᨲᩥ;

ᩋᨲ᩠ᨲᩣᩅ ¶ ᩈᩮᨿ᩠ᨿᩮᩣ ᨸᩁᨾᩣ ᨧ [ᨸᩁᨾᩣᩅ (ᨻᩉᩪᩈᩩ) ᨩᩣ. ᪑.᪖.᪘᪑ ᩈᩴᩈᨶ᩠ᨴᩮᨲᨻ᩠ᨻᩴ] ᩈᩮᨿ᩠ᨿᩮᩣ, ᩃᨻ᩠ᨽᩣ ᨸᩥᨿᩣ ᩒᨧᩥᨲᨲ᩠ᨳᩮᨶ [ᩒᨧᩥᨲᨲ᩠ᨲᩮᨶ (ᨠ.)] ᨸᨧ᩠ᨨᩣ’’.

᪔᪖᪒.

‘‘ᨸᩥᨿᩴ ᨾᩮ ᨾᩣᨶᩩᩈᩴ ᨾᩴᩈᩴ, ᩈᩩᨲᩈᩮᩣᨾ ᩅᩥᨩᩣᨶᩉᩥ;

ᨶᨾ᩠ᩉᩥ ᩈᨠ᩠ᨠᩣ [ᨶᨾ᩠ᩉᩥ ᩈᨠ᩠ᨠᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᨶᩥᩅᩣᩁᩮᨲᩩᩴ, ᩋᨬ᩠ᨬᩴ [ᩋᨬ᩠ᨬᩴ ᨲᩩᩅᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩅᩁᩴ ᩈᨾ᩠ᨾ ᩅᩁᩔᩩ’’.

᪔᪖᪓.

‘‘ᨿᩮᩣ ᩅᩮ ᨸᩥᨿᩴ ᨾᩮᨲᩥ ᨸᩥᨿᩣᨶᩩᩁᨠ᩠ᨡᩦ [ᨸᩥᨿᩣᨶᩩᨠᨦ᩠ᨡᩦ (ᩈᩦ. ᨸᩦ.)], ᩋᨲ᩠ᨲᩴ ᨶᩥᩁᩴᨠᨧ᩠ᨧ ᨸᩥᨿᩣᨶᩥ ᩈᩮᩅᨲᩥ;

ᩈᩮᩣᨱ᩠ᨯᩮᩣᩅ ᨸᩥᨲ᩠ᩅᩣ ᩅᩥᩈᨾᩥᩔᨸᩣᨶᩴ [ᨸᩦᨲ᩠ᩅᨶ ᩅᩥᩈᩔ ᨳᩣᩃᩴ (ᩈᩦ. ᨸᩦ.), ᨸᩥᨲ᩠ᩅᩣ ᩅᩥᩈᨾᩥᩔᨳᩣᩃᩴ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨲᩮᨶᩮᩅ ᩈᩮᩣ ᩉᩮᩣᨲᩥ ᨴᩩᨠ᩠ᨡᩦ ᨸᩁᨲ᩠ᨳ.

᪔᪖᪔.

‘‘ᨿᩮᩣ ᨧᩦᨵ ᩈᨦ᩠ᨡᩣᨿ ᨸᩥᨿᩣᨶᩥ ᩉᩥᨲ᩠ᩅᩣ, ᨠᩥᨧ᩠ᨨᩮᨶᨸᩥ ᩈᩮᩅᨲᩥ ᩋᩁᩥᨿᨵᨾ᩠ᨾᩮ [ᩋᩁᩥᨿᨵᨾ᩠ᨾᩴ (ᩈᩦ. ᨸᩦ.)];

ᨴᩩᨠ᩠ᨡᩥᨲᩮᩣᩅ ᨸᩥᨲ᩠ᩅᩣᨶ ᨿᨳᩮᩣᩈᨵᩣᨶᩥ, ᨲᩮᨶᩮᩅ ᩈᩮᩣ ᩉᩮᩣᨲᩥ ᩈᩩᨡᩦ ᨸᩁᨲ᩠ᨳ’’.

᪔᪖᪕.

‘‘ᩒᩉᩣᨿᩉᩴ ᨸᩥᨲᩁᩴ ᨾᩣᨲᩁᨬ᩠ᨧ, ᨾᨶᩣᨸᩥᨿᩮ ᨠᩣᨾᨣᩩᨱᩮ ᨧ [ᨠᩣᨾᨣᩩᨱᩮᨸᩥ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨸᨬ᩠ᨧ;

ᩑᨲᩔ ᩉᩮᨲᩩᨾ᩠ᩉᩥ ᩅᨶᩴ ᨸᩅᩥᨭ᩠ᨮᩮᩣ, ᨲᩴ ᨲᩮ ᩅᩁᩴ ᨠᩥᨶ᩠ᨲᩥ ᨾᩉᩴ ᨴᨴᩣᨾᩥ’’.

᪔᪖᪖.

‘‘ᨶ ᨸᨱ᩠ᨯᩥᨲᩣ ᨴᩥᨣᩩᨱᨾᩣᩉᩩ ᩅᩣᨠ᩠ᨿᩴ, ᩈᨧ᩠ᨧᨸ᩠ᨸᨭᩥᨬ᩠ᨬᩣᩅ ᨽᩅᨶ᩠ᨲᩥ ᩈᨶ᩠ᨲᩮᩣ;

ᩅᩁᩔᩩ ᩈᨾ᩠ᨾ ᩍᨲᩥ ᨾᩴ ᩋᩅᩮᩣᨧ, ᩍᨧ᩠ᨧᨻᩕᩅᩦ ᨲ᩠ᩅᩴ ᨶ ᩉᩥ ᨲᩮ ᩈᨾᩮᨲᩥ’’.

᪔᪖᪗.

‘‘ᩋᨸᩩᨬ᩠ᨬᩃᩣᨽᩴ ¶ ᩋᨿᩈᩴ ᩋᨠᩥᨲ᩠ᨲᩥᩴ, ᨸᩣᨸᩴ ᨻᩉᩩᩴ ᨴᩩᨧ᩠ᨧᩁᩥᨲᩴ ᨠᩥᩃᩮᩈᩴ;

ᨾᨶᩩᩔᨾᩴᩈᩔ ᨠᨲᩮ [ᨽᩅᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩏᨸᩣᨣᩣ, ᨲᩴ ᨲᩮ ᩅᩁᩴ ᨠᩥᨶ᩠ᨲᩥ ᨾᩉᩴ ᨴᨴᩮᨿ᩠ᨿᩴ.

᪔᪖᪘.

‘‘ᨶᩴ ¶ ᨲᩴ ᩅᩁᩴ ᩋᩁᩉᨲᩥ ᨩᨶ᩠ᨲᩩ ᨴᩣᨲᩩᩴ, ᨿᩴ ᩅᩣᨸᩥ ᨴᨲ᩠ᩅᩣᨶ ᩋᩅᩣᨠᩁᩮᨿ᩠ᨿ;

ᩅᩁᩔᩩ ᩈᨾ᩠ᨾ ᩋᩅᩥᨠᨾ᩠ᨸᨾᩣᨶᩮᩣ, ᨸᩣᨱᩴ ᨧᨩᩥᨲ᩠ᩅᩣᨶᨸᩥ ᨴᩔᨾᩮᩅ’’.

᪔᪖᪙.

‘‘ᨸᩣᨱᩴ ᨧᨩᨶ᩠ᨲᩥ ᩈᨶ᩠ᨲᩮᩣ ᨶᩣᨸᩥ ᨵᨾ᩠ᨾᩴ, ᩈᨧ᩠ᨧᨸ᩠ᨸᨭᩥᨬ᩠ᨬᩣᩅ ᨽᩅᨶ᩠ᨲᩥ ᩈᨶ᩠ᨲᩮᩣ;

ᨴᨲ᩠ᩅᩣ ᩅᩁᩴ ᨡᩥᨸ᩠ᨸᨾᩅᩣᨠᩁᩮᩣᩉᩥ, ᩑᨲᩮᨶ ᩈᨾ᩠ᨸᨩ᩠ᨩ ᩈᩩᩁᩣᨩᩈᩮᨭ᩠ᨮ.

᪔᪗᪐.

‘‘ᨧᨩᩮ ᨵᨶᩴ [ᨵᨶᩴ ᨧᨩᩮ (ᩈᩦ.)] ᩋᨦ᩠ᨣᩅᩁᩔ ᩉᩮᨲᩩ [ᨿᩮᩣ ᨸᨶ ᩋᨦ᩠ᨣᩉᩮᨲᩩ (ᩈᩦ. ᨸᩦ.)], ᩋᨦ᩠ᨣᩴ ᨧᨩᩮ ᨩᩦᩅᩥᨲᩴ ᩁᨠ᩠ᨡᨾᩣᨶᩮᩣ;

ᩋᨦ᩠ᨣᩴ ᨵᨶᩴ ᨩᩦᩅᩥᨲᨬ᩠ᨧᩣᨸᩥ ᩈᨻ᩠ᨻᩴ, ᨧᨩᩮ ᨶᩁᩮᩣ ᨵᨾ᩠ᨾᨾᨶᩩᩔᩁᨶ᩠ᨲᩮᩣ’’.

᪔᪗᪑.

‘‘ᨿᩈ᩠ᨾᩣ ᩉᩥ ᨵᨾ᩠ᨾᩴ ᨸᩩᩁᩥᩈᩮᩣ ᩅᩥᨩᨬ᩠ᨬᩣ, ᨿᩮ ᨧᩔ ᨠᨦ᩠ᨡᩴ ᩅᩥᨶᨿᨶ᩠ᨲᩥ ᩈᨶ᩠ᨲᩮᩣ;

ᨲᩴ ᩉᩥᩔ ᨴᩦᨸᨬ᩠ᨧ ᨸᩁᩣᨿᨱᨬ᩠ᨧ, ᨶ ¶ ᨲᩮᨶ ᨾᩥᨲ᩠ᨲᩥᩴ ᨩᩥᩁᨿᩮᨳ [ᨩᩁᨿᩮᨳ (ᩈᩦ. ᨸᩦ.)] ᨸᨬ᩠ᨬᩮᩣ.

᪔᪗᪒.

‘‘ᩋᨴ᩠ᨵᩣ ᩉᩥ ᩈᩮᩣ ᨽᨠ᩠ᨡᩮᩣ ᨾᨾ ᨾᨶᩣᨸᩮᩣ, ᩑᨲᩔ ᩉᩮᨲᩩᨾ᩠ᩉᩥ ᩅᨶᩴ ᨸᩅᩥᨭ᩠ᨮᩮᩣ;

ᩈᨧᩮ ᨧ ᨾᩴ ᨿᩣᨧᩈᩥ ᩑᨲᨾᨲ᩠ᨳᩴ, ᩑᨲᨾ᩠ᨸᩥ ᨲᩮ ᩈᨾ᩠ᨾ ᩅᩁᩴ ᨴᨴᩣᨾᩥ.

᪔᪗᪓.

‘‘ᩈᨲ᩠ᨳᩣ ᨧ ᨾᩮ ᩉᩮᩣᩈᩥ ᩈᨡᩣ ᨧ ᨾᩮᩈᩥ, ᩅᨧᨶᨾ᩠ᨸᩥ ᨲᩮ ᩈᨾ᩠ᨾ ᩋᩉᩴ ᩋᨠᩣᩈᩥᩴ;

ᨲᩩᩅᨾ᩠ᨸᩥ [ᨲ᩠ᩅᩴᨸᩥ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨾᩮ ᩈᨾ᩠ᨾ ᨠᩁᩮᩣᩉᩥ ᩅᩣᨠ᩠ᨿᩴ, ᩏᨽᩮᩣᨸᩥ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨸᨾᩮᩣᨧᨿᩣᨾ’’.

᪔᪗᪔.

‘‘ᩈᨲ᩠ᨳᩣ ᨧ ᨲᩮ ᩉᩮᩣᨾᩥ ᩈᨡᩣ ᨧ ᨲ᩠ᨿᨾ᩠ᩉᩥ, ᩅᨧᨶᨾ᩠ᨸᩥ ᨾᩮ ᩈᨾ᩠ᨾ ᨲᩩᩅᩴ ᩋᨠᩣᩈᩥ;

ᩋᩉᨾ᩠ᨸᩥ ᨲᩮ ᩈᨾ᩠ᨾ ᨠᩁᩮᩣᨾᩥ ᩅᩣᨠ᩠ᨿᩴ, ᩏᨽᩮᩣᨸᩥ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨸᨾᩮᩣᨧᨿᩣᨾ’’.

᪔᪗᪕.

‘‘ᨠᨾ᩠ᨾᩣᩈᨸᩣᨴᩮᨶᩴ ¶ ¶ ᩅᩥᩉᩮᨮᩥᨲᨲ᩠ᨳ [ᩅᩥᩉᩮᨮᩥᨲᨾ᩠ᩉᩣ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨲᩃᩣᩅᩩᨲᩣ ᩋᩔᩩᨾᩩᨡᩣ ᩁᩩᨴᨶ᩠ᨲᩣ;

ᨶ ᨩᩣᨲᩩ ᨴᩩᨻ᩠ᨽᩮᨳ ᩍᨾᩔ ᩁᨬ᩠ᨬᩮᩣ, ᩈᨧ᩠ᨧᨸ᩠ᨸᨭᩥᨬ᩠ᨬᩴ ¶ ᨾᩮ ᨸᨭᩥᩔᩩᨱᩣᨳ’’.

᪔᪗᪖.

‘‘ᨠᨾ᩠ᨾᩣᩈᨸᩣᨴᩮᨶ ᩅᩥᩉᩮᨮᩥᨲᨾ᩠ᩉᩣ, ᨲᩃᩣᩅᩩᨲᩣ ᩋᩔᩩᨾᩩᨡᩣ ᩁᩩᨴᨶ᩠ᨲᩣ;

ᨶ ᨩᩣᨲᩩ ᨴᩩᨻ᩠ᨽᩮᨾ ᩍᨾᩔ ᩁᨬ᩠ᨬᩮᩣ, ᩈᨧ᩠ᨧᨸ᩠ᨸᨭᩥᨬ᩠ᨬᩴ ᨲᩮ ᨸᨭᩥᩔᩩᨱᩣᨾ’’.

᪔᪗᪗.

‘‘ᨿᨳᩣ ᨸᩥᨲᩣ ᩅᩣ ᩋᨳ ᩅᩣᨸᩥ ᨾᩣᨲᩣ, ᩋᨶᩩᨠᨾ᩠ᨸᨠᩣ ᩋᨲ᩠ᨳᨠᩣᨾᩣ ᨸᨩᩣᨶᩴ;

ᩑᩅᨾᩮᩅ ᩅᩮᩣ [ᩑᩅᨾᩮᩅ (ᩈᩦ.), ᩑᩅᨾ᩠ᨸᩥ ᩅᩮᩣ (ᩈ᩠ᨿᩣ.)] ᩉᩮᩣᨲᩩ ᩋᨿᨬ᩠ᨧ ᩁᩣᨩᩣ, ᨲᩩᨾ᩠ᩉᩮ ᨧ ᩅᩮᩣ ᩉᩮᩣᨳ ᨿᨳᩮᩅ ᨸᩩᨲ᩠ᨲᩣ’’.

᪔᪗᪘.

‘‘ᨿᨳᩣ ᨸᩥᨲᩣ ᩅᩣ ᩋᨳ ᩅᩣᨸᩥ ᨾᩣᨲᩣ, ᩋᨶᩩᨠᨾ᩠ᨸᨠᩣ ᩋᨲ᩠ᨳᨠᩣᨾᩣ ᨸᨩᩣᨶᩴ;

ᩑᩅᨾᩮᩅ ᨶᩮᩣ ᩉᩮᩣᨲᩩ [ᩑᩅᨾ᩠ᨸᩥ ᨶᩮᩣ (ᩈ᩠ᨿᩣ.)] ᩋᨿᨬ᩠ᨧ ᩁᩣᨩᩣ, ᨾᨿᨾ᩠ᨸᩥ ᩉᩮᩔᩣᨾ ᨿᨳᩮᩅ [ᨲᨳᩮᩅ (ᨸᩦ.)] ᨸᩩᨲ᩠ᨲᩣ’’.

᪔᪗᪙.

‘‘ᨧᨲᩩᨸ᩠ᨸᨴᩴ ᩈᨠᩩᨱᨬ᩠ᨧᩣᨸᩥ ᨾᩴᩈᩴ, ᩈᩪᨴᩮᩉᩥ ᩁᨶ᩠ᨵᩴ ᩈᩩᨠᨲᩴ ᩈᩩᨶᩥᨭ᩠ᨮᩥᨲᩴ;

ᩈᩩᨵᩴᩅ ᩍᨶ᩠ᨴᩮᩣ ᨸᩁᩥᨽᩩᨬ᩠ᨩᩥᨿᩣᨶ, ᩉᩥᨲ᩠ᩅᩣ ᨠᨳᩮᨠᩮᩣ ᩁᨾᩈᩦ ᩋᩁᨬ᩠ᨬᩮ.

᪔᪘᪐.

‘‘ᨲᩣ ᨡᨲ᩠ᨲᩥᨿᩣ ᩅᩃ᩠ᩃᩥᩅᩥᩃᩣᨠᨾᨩ᩠ᨫᩣ, ᩋᩃᨦ᩠ᨠᨲᩣ ᩈᨾ᩠ᨸᩁᩥᩅᩣᩁᨿᩥᨲ᩠ᩅᩣ;

ᩍᨶ᩠ᨴᩴᩅ ᨴᩮᩅᩮᩈᩩ ᨸᨾᩮᩣᨴᨿᩥᩴᩈᩩ, ᩉᩥᨲ᩠ᩅᩣ ¶ ᨠᨳᩮᨠᩮᩣ ᩁᨾᩈᩦ ᩋᩁᨬ᩠ᨬᩮ.

᪔᪘᪑.

‘‘ᨲᨾ᩠ᨻᩪᨸᨵᩣᨶᩮ ᨻᩉᩩᨣᩮᩣᨱᨠᨾ᩠ᩉᩥ, ᩈᩩᨽᨾ᩠ᩉᩥ [ᩈᩩᨧᩥᨾ᩠ᩉᩥ (ᩈᩦ. ᨸᩦ.)] ᩈᨻ᩠ᨻᩔᨿᨶᨾ᩠ᩉᩥ ᩈᨦ᩠ᨣᩮ [ᩈᨬ᩠ᨬᨲᩮ (ᩈᩦ. ᨸᩦ.), ᩃᨦ᩠ᨣᨲᩮ (ᩈ᩠ᨿᩣ.)];

ᩈᩮᨿ᩠ᨿᩔ [ᩈᨿᨶᩔ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᨾᨩ᩠ᨫᨾ᩠ᩉᩥ ᩈᩩᨡᩴ ᩈᨿᩥᨲ᩠ᩅᩣ, ᩉᩥᨲ᩠ᩅᩣ ᨠᨳᩮᨠᩮᩣ ᩁᨾᩈᩦ ᩋᩁᨬ᩠ᨬᩮ.

᪔᪘᪒.

‘‘ᨸᩣᨱᩥᩔᩁᩴ ¶ ᨠᩩᨾ᩠ᨽᨳᩪᨱᩴ ᨶᩥᩈᩦᨳᩮ, ᩋᨳᩮᩣᨸᩥ ᩅᩮ ᨶᩥᨸ᩠ᨸᩩᩁᩥᩈᨾ᩠ᨸᩥ ᨲᩪᩁᩥᨿᩴ;

ᨻᩉᩩᩴ ᩈᩩᨣᩦᨲᨬ᩠ᨧ ᩈᩩᩅᩣᨴᩥᨲᨬ᩠ᨧ, ᩉᩥᨲ᩠ᩅᩣ ᨠᨳᩮᨠᩮᩣ ᩁᨾᩈᩦ ᩋᩁᨬ᩠ᨬᩮ.

᪔᪘᪓.

‘‘ᩏᨿ᩠ᨿᩣᨶᩈᨾ᩠ᨸᨶ᩠ᨶᩴ ᨸᩉᩪᨲᨾᩣᩃ᩠ᨿᩴ, ᨾᩥᨣᩣᨩᩥᨶᩪᨸᩮᨲᨸᩩᩁᩴ [ᨾᩥᨣᩣᨧᩥᩁᩪᨸᩮᨲᨸᩩᩁᩴ (ᩈᩦ. ᨸᩦ.)] ᩈᩩᩁᨾ᩠ᨾᩴ;

ᩉᨿᩮᩉᩥ ᨶᩣᨣᩮᩉᩥ ᩁᨳᩮᩉᩩᨸᩮᨲᩴ, ᩉᩥᨲ᩠ᩅᩣ ᨠᨳᩮᨠᩮᩣ ᩁᨾᩈᩦ ᩋᩁᨬ᩠ᨬᩮ’’.

᪔᪘᪔.

‘‘ᨠᩣᩊᨸᨠ᩠ᨡᩮ ᨿᨳᩣ ᨧᨶ᩠ᨴᩮᩣ, ᩉᩣᨿᨲᩮᩅ ᩈᩩᩅᩮ ᩈᩩᩅᩮ;

ᨠᩣᩊᨸᨠ᩠ᨡᩪᨸᨾᩮᩣ ᩁᩣᨩ, ᩋᩈᨲᩴ ᩉᩮᩣᨲᩥ ᩈᨾᩣᨣᨾᩮᩣ.

᪔᪘᪕.

‘‘ᨿᨳᩣᩉᩴ [ᨿᨳᩣ (ᩈᩦ.)] ᩁᩈᨠᨾᩣᨣᨾ᩠ᨾ, ᩈᩪᨴᩴ ᨠᩣᨸᩩᩁᩥᩈᩣᨵᨾᩴ [ᩈᩪᨴᨠᩴ ᨸᩩᩁᩥᩈᩣᨵᨾᩴ (ᩈᩦ. ᨸᩦ.)];

ᩋᨠᩣᩈᩥᩴ ᨸᩣᨸᨠᩴ ᨠᨾ᩠ᨾᩴ, ᨿᩮᨶ ᨣᨧ᩠ᨨᩣᨾᩥ ᨴᩩᨣ᩠ᨣᨲᩥᩴ.

᪔᪘᪖.

‘‘ᩈᩩᨠ᩠ᨠᨸᨠ᩠ᨡᩮ ᨿᨳᩣ ᨧᨶ᩠ᨴᩮᩣ, ᩅᨯ᩠ᨰᨲᩮᩅ ᩈᩩᩅᩮ ᩈᩩᩅᩮ;

ᩈᩩᨠ᩠ᨠᨸᨠ᩠ᨡᩪᨸᨾᩮᩣ ᩁᩣᨩ, ᩈᨲᩴ ᩉᩮᩣᨲᩥ ᩈᨾᩣᨣᨾᩮᩣ.

᪔᪘᪗.

‘‘ᨿᨳᩣᩉᩴ ᨲᩩᩅᨾᩣᨣᨾ᩠ᨾ, ᩈᩩᨲᩈᩮᩣᨾ ᩅᩥᨩᩣᨶᩉᩥ;

ᨠᩣᩉᩣᨾᩥ ᨠᩩᩈᩃᩴ ᨠᨾ᩠ᨾᩴ, ᨿᩮᨶ ᨣᨧ᩠ᨨᩣᨾᩥ ᩈᩩᨣ᩠ᨣᨲᩥᩴ.

᪔᪘᪘.

‘‘ᨳᩃᩮ ᨿᨳᩣ ᩅᩣᩁᩥ ᨩᨶᩥᨶ᩠ᨴ ᩅᩩᨭ᩠ᨮᩴ [ᩅᨭ᩠ᨭᩴ (ᩈᩦ. ᨸᩦ.)], ᩋᨶᨴ᩠ᨵᨶᩮᨿ᩠ᨿᩴ ᨶ ᨧᩥᩁᨭ᩠ᨮᩥᨲᩦᨠᩴ;

ᩑᩅᨾ᩠ᨸᩥ ¶ ᩉᩮᩣᨲᩥ ᩋᩈᨲᩴ ᩈᨾᩣᨣᨾᩮᩣ, ᩋᨶᨴ᩠ᨵᨶᩮᨿ᩠ᨿᩮᩣ ᩏᨴᨠᩴ ᨳᩃᩮᩅ.

᪔᪘᪙.

‘‘ᩈᩁᩮ ᨿᨳᩣ ᩅᩣᩁᩥ ᨩᨶᩥᨶ᩠ᨴ ᩅᩩᨭ᩠ᨮᩴ, ᨧᩥᩁᨭ᩠ᨮᩥᨲᩦᨠᩴ ᨶᩁᩅᩦᩁᩈᩮᨭ᩠ᨮ [ᨶᩁᩅᩥᩁᩥᨿᩈᩮᨭ᩠ᨮ (ᩈᩦ. ᨸᩦ.)];

ᩑᩅᨾ᩠ᨸᩥ ᩅᩮ [ᩑᩅᨾ᩠ᨸᩥ ᨾᩮ (ᩈ᩠ᨿᩣ.), ᩑᩅᨾ᩠ᨸᩥ ᨧᩮ (ᨸᩦ. ᨠ.)] ᩉᩮᩣᨲᩥ ᩈᨲᩴ ᩈᨾᩣᨣᨾᩮᩣ, ᨧᩥᩁᨭ᩠ᨮᩥᨲᩦᨠᩮᩣ [ᨧᩥᩁᨭ᩠ᨮᩥᨲᩥᨠᩴ (ᨠ.)] ᩏᨴᨠᩴ ᩈᩁᩮᩅ.

᪔᪙᪐.

‘‘ᩋᨻ᩠ᨿᩣᨿᩥᨠᩮᩣ ¶ ¶ ᩉᩮᩣᨲᩥ ᩈᨲᩴ ᩈᨾᩣᨣᨾᩮᩣ, ᨿᩣᩅᨾ᩠ᨸᩥ ᨲᩥᨭ᩠ᨮᩮᨿ᩠ᨿ ᨲᨳᩮᩅ ᩉᩮᩣᨲᩥ;

ᨡᩥᨸ᩠ᨸᨬ᩠ᩉᩥ ᩅᩮᨲᩥ ᩋᩈᨲᩴ ᩈᨾᩣᨣᨾᩮᩣ, ᨲᩈ᩠ᨾᩣ ᩈᨲᩴ ᨵᨾ᩠ᨾᩮᩣ ᩋᩈᨻ᩠ᨽᩥ ᩌᩁᨠᩣ’’.

᪔᪙᪑.

‘‘ᨶ ᩈᩮᩣ ᩁᩣᨩᩣ ᨿᩮᩣ [ᩁᩣᨩᩣ ᨶ ᩈᩮᩣ ᨿᩮᩣ (ᨠ.)] ᩋᨩᩮᨿ᩠ᨿᩴ ᨩᩥᨶᩣᨲᩥ, ᨶ ᩈᩮᩣ ᩈᨡᩣ ᨿᩮᩣ ᩈᨡᩣᩁᩴ ᨩᩥᨶᩣᨲᩥ;

ᨶ ᩈᩣ ᨽᩁᩥᨿᩣ ᨿᩣ ᨸᨲᩥᨶᩮᩣ ᨶ ᩅᩥᨽᩮᨲᩥ, ᨶ ᨲᩮ ᨸᩩᨲ᩠ᨲᩣ [ᨸᩩᨲ᩠ᨲᩣ ᨶ ᨲᩮ (ᨠ.)] ᨿᩮ ᨶ ᨽᩁᨶ᩠ᨲᩥ ᨩᩥᨱ᩠ᨱᩴ.

᪔᪙᪒.

‘‘ᨶ ᩈᩣ ᩈᨽᩣ ᨿᨲ᩠ᨳ ᨶ ᩈᨶ᩠ᨲᩥ ᩈᨶ᩠ᨲᩮᩣ, ᨶ ᨲᩮ ᩈᨶ᩠ᨲᩮᩣ [ᩈᨶ᩠ᨲᩮᩣ ᨶ ᨲᩮ (ᨠ.)] ᨿᩮ ᨶ ᨽᨱᨶ᩠ᨲᩥ ᨵᨾ᩠ᨾᩴ;

ᩁᩣᨣᨬ᩠ᨧ ᨴᩮᩣᩈᨬ᩠ᨧ ᨸᩉᩣᨿ ᨾᩮᩣᩉᩴ, ᨵᨾ᩠ᨾᩴ ᨽᨱᨶ᩠ᨲᩣᩅ ᨽᩅᨶ᩠ᨲᩥ ᩈᨶ᩠ᨲᩮᩣ.

᪔᪙᪓.

‘‘ᨶᩣᨽᩣᩈᨾᩣᨶᩴ ᨩᩣᨶᨶ᩠ᨲᩥ, ᨾᩥᩔᩴ ᨻᩣᩃᩮᩉᩥ ᨸᨱ᩠ᨯᩥᨲᩴ;

ᨽᩣᩈᨾᩣᨶᨬ᩠ᨧ ᨩᩣᨶᨶ᩠ᨲᩥ, ᨴᩮᩈᩮᨶ᩠ᨲᩴ ᩋᨾᨲᩴ ᨸᨴᩴ.

᪔᪙᪔.

‘‘ᨽᩣᩈᨿᩮ ¶ ᨩᩮᩣᨲᨿᩮ ᨵᨾ᩠ᨾᩴ, ᨸᨣ᩠ᨣᨱ᩠ᩉᩮ ᩍᩈᩥᨶᩴ ᨵᨩᩴ;

ᩈᩩᨽᩣᩈᩥᨲᨴ᩠ᨵᨩᩣ ᩍᩈᨿᩮᩣ, ᨵᨾ᩠ᨾᩮᩣ ᩉᩥ ᩍᩈᩥᨶᩴ ᨵᨩᩮᩣ’’ᨲᩥ.

ᨾᩉᩣᩈᩩᨲᩈᩮᩣᨾᨩᩣᨲᨠᩴ ᨸᨬ᩠ᨧᨾᩴ.

ᩋᩈᩦᨲᩥᨶᩥᨸᩣᨲᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨲᩔᩩᨴ᩠ᨴᩣᨶᩴ –

ᩈᩩᨾᩩᨡᩮᩣ ᨸᨶ ᩉᩴᩈᩅᩁᩮᩣ ᨧ ᨾᩉᩣ, ᩈᩩᨵᨽᩮᩣᨩᨶᩥᨠᩮᩣ ᨧ ᨸᩁᩮᩣ ᨸᩅᩁᩮᩣ;

ᩈᨠᩩᨱᩣᩃᨴᩥᨩᩣᨵᩥᨸᨲᩥᩅ᩠ᩉᨿᨶᩮᩣ, ᩈᩩᨲᩈᩮᩣᨾᩅᩁᩩᨲ᩠ᨲᨾᩈᩅ᩠ᩉᨿᨶᩮᩣᨲᩥ.

᪒᪒. ᨾᩉᩣᨶᩥᨸᩣᨲᩮᩣ

᪕᪓᪘. ᨾᩪᨣᨸᨠ᩠ᨡᨩᩣᨲᨠᩴ (᪑)

᪑.

‘‘ᨾᩣ ¶ ¶ ¶ ᨸᨱ᩠ᨯᩥᨧ᩠ᨧᨿᩴ [ᨸᨱ᩠ᨯᩥᨲᩥᨿᩴ (ᩈᩦ.), ᨸᨱ᩠ᨯᩥᨧ᩠ᨧᩥᨿᩴ (ᨸᩦ.)] ᩅᩥᨽᩣᩅᨿ, ᨻᩣᩃᨾᨲᩮᩣ ᨽᩅ ᩈᨻ᩠ᨻᨸᩣᨱᩥᨶᩴ;

ᩈᨻ᩠ᨻᩮᩣ ᨲᩴ ᨩᨶᩮᩣ ᩒᨧᩥᨶᩣᨿᨲᩩ, ᩑᩅᩴ ᨲᩅ ᩋᨲ᩠ᨳᩮᩣ ᨽᩅᩥᩔᨲᩥ’’.

᪒.

‘‘ᨠᩁᩮᩣᨾᩥ ᨲᩮ ᨲᩴ ᩅᨧᨶᩴ, ᨿᩴ ᨾᩴ ᨽᨱᩈᩥ ᨴᩮᩅᨲᩮ;

ᩋᨲ᩠ᨳᨠᩣᨾᩣᩈᩥ ᨾᩮ ᩋᨾ᩠ᨾ, ᩉᩥᨲᨠᩣᨾᩣᩈᩥ ᨴᩮᩅᨲᩮ’’.

᪓.

‘‘ᨠᩥᩴ ᨶᩩ ᩈᨶ᩠ᨲᩁᨾᩣᨶᩮᩣᩅ, ᨠᩣᩈᩩᩴ ᨡᨱᩈᩥ ᩈᩣᩁᨳᩥ;

ᨸᩩᨭ᩠ᨮᩮᩣ ᨾᩮ ᩈᨾ᩠ᨾ ᩋᨠ᩠ᨡᩣᩉᩥ, ᨠᩥᩴ ᨠᩣᩈᩩᨿᩣ ᨠᩁᩥᩔᩈᩥ’’.

᪔.

‘‘ᩁᨬ᩠ᨬᩮᩣ ᨾᩪᨣᩮᩣ ᨧ ᨸᨠ᩠ᨡᩮᩣ ᨧ, ᨸᩩᨲ᩠ᨲᩮᩣ ᨩᩣᨲᩮᩣ ᩋᨧᩮᨲᩈᩮᩣ;

ᩈᩮᩣᨾ᩠ᩉᩥ ᩁᨬ᩠ᨬᩣ ᩈᨾᨩ᩠ᨫᩥᨭ᩠ᨮᩮᩣ, ᨸᩩᨲ᩠ᨲᩴ ᨾᩮ ᨶᩥᨡᨱᩴ ᩅᨶᩮ’’.

᪕.

‘‘ᨶ ᨻᨵᩥᩁᩮᩣ ᨶ ᨾᩪᨣᩮᩣᩈ᩠ᨾᩥ, ᨶ ᨸᨠ᩠ᨡᩮᩣ ᨶ ᨧ ᩅᩦᨠᩃᩮᩣ [ᨶᨸᩥ ᨸᨦ᩠ᨣᩩᩃᩮᩣ (ᩈᩦ. ᨸᩦ.), ᨶ ᨧ ᨸᩥᨦ᩠ᨣᩃᩮᩣ (ᩈ᩠ᨿᩣ.)];

ᩋᨵᨾ᩠ᨾᩴ ᩈᩣᩁᨳᩥ ᨠᨿᩥᩁᩣ, ᨾᩴ ᨧᩮ ᨲ᩠ᩅᩴ ᨶᩥᨡᨱᩴ ᩅᨶᩮ’’.

᪖.

‘‘ᩐᩁᩪ ᨻᩣᩉᩩᩴ [ᨻᩣᩉᩪ (ᩈᩦ. ᨠ.)] ᨧ ᨾᩮ ᨸᩔ, ᨽᩣᩈᩥᨲᨬ᩠ᨧ ᩈᩩᨱᩮᩣᩉᩥ ᨾᩮ;

ᩋᨵᨾ᩠ᨾᩴ ᩈᩣᩁᨳᩥ ᨠᨿᩥᩁᩣ, ᨾᩴ ᨧᩮ ᨲ᩠ᩅᩴ ᨶᩥᨡᨱᩴ ᩅᨶᩮ’’.