ᨾᩪᩃ > ᩈᩩᨲ᩠ᨲᨸᩥᨭᨠ > ᨡᩩᨴ᩠ᨴᨠᨶᩥᨠᩣᨿ

ᩑᩅᩴ ¶ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᨾᨣᨵᩮᩈᩩ ᩅᩥᩉᩁᨲᩥ ᨴᨠ᩠ᨡᩥᨱᩣᨣᩥᩁᩥᩈ᩠ᨾᩥᩴ ¶ [ᨴᨠ᩠ᨡᩥᨱᨣᩥᩁᩥᩈ᩠ᨾᩥᩴ (ᨠ.)] ᩑᨠᨶᩣᩊᩣᨿᩴ ᨻᩕᩣᩉ᩠ᨾᨱᨣᩣᨾᩮ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨸᨬ᩠ᨧᨾᨲ᩠ᨲᩣᨶᩥ ᨶᨦ᩠ᨣᩃᩈᨲᩣᨶᩥ ᨸᨿᩩᨲ᩠ᨲᩣᨶᩥ ᩉᩮᩣᨶ᩠ᨲᩥ ᩅᨸ᩠ᨸᨠᩣᩃᩮ. ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨸᩩᨻ᩠ᨻᨱ᩠ᩉᩈᨾᨿᩴ ᨶᩥᩅᩣᩈᩮᨲ᩠ᩅᩣ ᨸᨲ᩠ᨲᨧᩦᩅᩁᨾᩣᨴᩣᨿ ᨿᩮᨶ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨠᨾ᩠ᨾᨶ᩠ᨲᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨸᩁᩥᩅᩮᩈᨶᩣ ᩅᨲ᩠ᨲᨲᩥ. ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨿᩮᨶ ᨸᩁᩥᩅᩮᩈᨶᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᩋᨭ᩠ᨮᩣᩈᩥ.

ᩋᨴ᩠ᨴᩈᩣ ᨡᩮᩣ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨸᩥᨱ᩠ᨯᩣᨿ ᨮᩥᨲᩴ. ᨴᩥᩈ᩠ᩅᩣᨶ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩋᩉᩴ ᨡᩮᩣ, ᩈᨾᨱ, ᨠᩈᩣᨾᩥ ᨧ ᩅᨸᩣᨾᩥ ᨧ; ᨠᩈᩥᨲ᩠ᩅᩣ ᨧ ᩅᨸᩥᨲ᩠ᩅᩣ ᨧ ᨽᩩᨬ᩠ᨩᩣᨾᩥ. ᨲ᩠ᩅᨾ᩠ᨸᩥ, ᩈᨾᨱ, ᨠᩈᩔᩩ ᨧ ᩅᨸᩔᩩ ᨧ; ᨠᩈᩥᨲ᩠ᩅᩣ ᨧ ᩅᨸᩥᨲ᩠ᩅᩣ ᨧ ᨽᩩᨬ᩠ᨩᩔᩪ’’ᨲᩥ.

‘‘ᩋᩉᨾ᩠ᨸᩥ ᨡᩮᩣ, ᨻᩕᩣᩉ᩠ᨾᨱ, ᨠᩈᩣᨾᩥ ᨧ ᩅᨸᩣᨾᩥ ᨧ; ᨠᩈᩥᨲ᩠ᩅᩣ ᨧ ᩅᨸᩥᨲ᩠ᩅᩣ ᨧ ᨽᩩᨬ᩠ᨩᩣᨾᩦ’’ᨲᩥ. ‘‘ᨶ ᨡᩮᩣ ᨸᨶ ᨾᨿᩴ [ᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨱ (ᩈ᩠ᨿᩣ.)] ᨸᩔᩣᨾ ᨽᩮᩣᨲᩮᩣ ᨣᩮᩣᨲᨾᩔ ᨿᩩᨣᩴ ᩅᩣ ᨶᨦ᩠ᨣᩃᩴ ᩅᩣ ᨹᩣᩃᩴ ᩅᩣ ᨸᩣᨧᨶᩴ ᩅᩣ ᨻᩃᩥᨻᨴ᩠ᨴᩮ [ᨻᩃᩥᩅᨴ᩠ᨴᩮ (ᩈᩦ. ᨸᩦ.), ᨻᩃᩦᨻᨴ᩠ᨴᩮ (?)] ᩅᩣ. ᩋᨳ ᨧ ᨸᨶ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᩑᩅᨾᩣᩉ – ‘ᩋᩉᨾ᩠ᨸᩥ ᨡᩮᩣ, ᨻᩕᩣᩉ᩠ᨾᨱ, ᨠᩈᩣᨾᩥ ᨧ ᩅᨸᩣᨾᩥ ¶ ᨧ; ᨠᩈᩥᨲ᩠ᩅᩣ ᨧ ᩅᨸᩥᨲ᩠ᩅᩣ ᨧ ᨽᩩᨬ᩠ᨩᩣᨾᩦ’’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨠᩔᨠᩮᩣ ¶ ᨸᨭᩥᨩᩣᨶᩣᩈᩥ, ᨶ ᨧ ᨸᩔᩣᨾ ᨲᩮ ᨠᩈᩥᩴ;

ᨠᩈᩥᩴ ᨶᩮᩣ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᨻᩕᩪᩉᩥ, ᨿᨳᩣ ᨩᩣᨶᩮᨾᩩ ᨲᩮ ᨠᩈᩥᩴ’’.

‘‘ᩈᨴ᩠ᨵᩣ ᨻᩦᨩᩴ ᨲᨸᩮᩣ ᩅᩩᨭ᩠ᨮᩥ, ᨸᨬ᩠ᨬᩣ ᨾᩮ ᨿᩩᨣᨶᨦ᩠ᨣᩃᩴ;

ᩉᩥᩁᩦ ᩎᩈᩣ ᨾᨶᩮᩣ ᨿᩮᩣᨲ᩠ᨲᩴ, ᩈᨲᩥ ᨾᩮ ᨹᩣᩃᨸᩣᨧᨶᩴ.

‘‘ᨠᩣᨿᨣᩩᨲ᩠ᨲᩮᩣ ¶ ᩅᨧᩦᨣᩩᨲ᩠ᨲᩮᩣ, ᩌᩉᩣᩁᩮ ᩏᨴᩁᩮ ᨿᨲᩮᩣ;

ᩈᨧ᩠ᨧᩴ ᨠᩁᩮᩣᨾᩥ ᨶᩥᨴ᩠ᨴᩣᨶᩴ, ᩈᩮᩣᩁᨧ᩠ᨧᩴ ᨾᩮ ᨸᨾᩮᩣᨧᨶᩴ.

‘‘ᩅᩦᩁᩥᨿᩴ ᨾᩮ ᨵᩩᩁᨵᩮᩣᩁᨿ᩠ᩉᩴ, ᨿᩮᩣᨣᨠ᩠ᨡᩮᨾᩣᨵᩥᩅᩣᩉᨶᩴ;

ᨣᨧ᩠ᨨᨲᩥ ᩋᨶᩥᩅᨲ᩠ᨲᨶ᩠ᨲᩴ, ᨿᨲ᩠ᨳ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᨶ ᩈᩮᩣᨧᨲᩥ.

‘‘ᩑᩅᨾᩮᩈᩣ ¶ ᨠᩈᩦ ᨠᨭ᩠ᨮᩣ, ᩈᩣ ᩉᩮᩣᨲᩥ ᩋᨾᨲᨸ᩠ᨹᩃᩣ;

ᩑᨲᩴ ᨠᩈᩥᩴ ᨠᩈᩥᨲ᩠ᩅᩣᨶ, ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩩᨧ᩠ᨧᨲᩦ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨾᩉᨲᩥᨿᩣ ᨠᩴᩈᨸᩣᨲᩥᨿᩣ ᨸᩣᨿᩈᩴ [ᨸᩣᨿᩣᩈᩴ (ᩈᨻ᩠ᨻᨲ᩠ᨳ)] ᩅᨯ᩠ᨰᩮᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩮᩣ ᩏᨸᨶᩣᨾᩮᩈᩥ – ‘‘ᨽᩩᨬ᩠ᨩᨲᩩ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᨸᩣᨿᩈᩴ. ᨠᩔᨠᩮᩣ ᨽᩅᩴ; ᨿᩴ ᩉᩥ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᩋᨾᨲᨸ᩠ᨹᩃᩴ [ᩋᨾᨲᨸ᩠ᨹᩃᨾ᩠ᨸᩥ (ᩈᩴ. ᨶᩥ. ᪑.᪑᪙᪗)] ᨠᩈᩥᩴ ᨠᩈᨲᩦ’’ᨲᩥ.

‘‘ᨣᩣᨳᩣᨽᩥᨣᩦᨲᩴ ᨾᩮ ᩋᨽᩮᩣᨩᨶᩮᨿ᩠ᨿᩴ, ᩈᨾ᩠ᨸᩔᨲᩴ ᨻᩕᩣᩉ᩠ᨾᨱ ᨶᩮᩈ ᨵᨾ᩠ᨾᩮᩣ;

ᨣᩣᨳᩣᨽᩥᨣᩦᨲᩴ ᨸᨶᩩᨴᨶ᩠ᨲᩥ ᨻᩩᨴ᩠ᨵᩣ, ᨵᨾ᩠ᨾᩮ ᩈᨲᩦ ᨻᩕᩣᩉ᩠ᨾᨱ ᩅᩩᨲ᩠ᨲᩥᩁᩮᩈᩣ.

‘‘ᩋᨬ᩠ᨬᩮᨶ ¶ ᨧ ᨠᩮᩅᩃᩥᨶᩴ ᨾᩉᩮᩈᩥᩴ, ᨡᩦᨱᩣᩈᩅᩴ ᨠᩩᨠ᩠ᨠᩩᨧ᩠ᨧᩅᩪᨸᩈᨶ᩠ᨲᩴ;

ᩋᨶ᩠ᨶᩮᨶ ᨸᩣᨶᩮᨶ ᩏᨸᨭ᩠ᨮᩉᩔᩩ, ᨡᩮᨲ᩠ᨲᩴ ᩉᩥ ᨲᩴ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩔ ᩉᩮᩣᨲᩦ’’ᨲᩥ.

‘‘ᩋᨳ ¶ ᨠᩔ ᨧᩣᩉᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᩍᨾᩴ ᨸᩣᨿᩈᩴ ᨴᨾ᩠ᨾᩦ’’ᨲᩥ? ‘‘ᨶ ᨡ᩠ᩅᩣᩉᩴ ᨲᩴ, ᨻᩕᩣᩉ᩠ᨾᨱ, ᨸᩔᩣᨾᩥ ᩈᨴᩮᩅᨠᩮ ᩃᩮᩣᨠᩮ ᩈᨾᩣᩁᨠᩮ ᩈᨻᩕᩉ᩠ᨾᨠᩮ ᩈᩔᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩥᨿᩣ ᨸᨩᩣᨿ ᩈᨴᩮᩅᨾᨶᩩᩔᩣᨿ, ᨿᩔ ᩈᩮᩣ ᨸᩣᨿᩈᩮᩣ ᨽᩩᨲ᩠ᨲᩮᩣ ᩈᨾ᩠ᨾᩣ ᨸᩁᩥᨱᩣᨾᩴ ᨣᨧ᩠ᨨᩮᨿ᩠ᨿ, ᩋᨬ᩠ᨬᨲᩕ ᨲᨳᩣᨣᨲᩔ ᩅᩣ ᨲᨳᩣᨣᨲᩈᩣᩅᨠᩔ ᩅᩣ. ᨲᩮᨶ ᩉᩥ ᨲ᩠ᩅᩴ, ᨻᩕᩣᩉ᩠ᨾᨱ, ᨲᩴ ᨸᩣᨿᩈᩴ ᩋᨸ᩠ᨸᩉᩁᩥᨲᩮ ᩅᩣ ᨨᨯ᩠ᨯᩮᩉᩥ ᩋᨸ᩠ᨸᩣᨱᨠᩮ ᩅᩣ ᩏᨴᨠᩮ ᩒᨸᩥᩃᩣᨸᩮᩉᩦ’’ᨲᩥ.

ᩋᨳ ¶ ᨡᩮᩣ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨲᩴ ᨸᩣᨿᩈᩴ ᩋᨸ᩠ᨸᩣᨱᨠᩮ ᩏᨴᨠᩮ ᩒᨸᩥᩃᩣᨸᩮᩈᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩮᩣ ᨸᩣᨿᩈᩮᩣ ᩏᨴᨠᩮ ᨸᨠ᩠ᨡᩥᨲ᩠ᨲᩮᩣ ᨧᩥᨧ᩠ᨧᩥᨭᩣᨿᨲᩥ ᨧᩥᨭᩥᨧᩥᨭᩣᨿᨲᩥ ᩈᨶ᩠ᨵᩪᨸᩣᨿᨲᩥ ᩈᨾ᩠ᨸᨵᩪᨸᩣᨿᨲᩥ [ᩈᨶ᩠ᨵᩪᨾᩣᨿᨲᩥ ᩈᨾ᩠ᨸᨵᩪᨾᩣᨿᨲᩥ (ᩈ᩠ᨿᩣ.)]. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ ᨶᩣᨾ ᨹᩣᩃᩮᩣ ᨴᩥᩅᩈᩴ ᩈᨶ᩠ᨲᨲ᩠ᨲᩮᩣ [ᨴᩥᩅᩈᩈᨶ᩠ᨲᨲ᩠ᨲᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᩏᨴᨠᩮ ᨸᨠ᩠ᨡᩥᨲ᩠ᨲᩮᩣ ᨧᩥᨧ᩠ᨧᩥᨭᩣᨿᨲᩥ ᨧᩥᨭᩥᨧᩥᨭᩣᨿᨲᩥ ᩈᨶ᩠ᨵᩪᨸᩣᨿᨲᩥ ᩈᨾ᩠ᨸᨵᩪᨸᩣᨿᨲᩥ; ᩑᩅᨾᩮᩅ ᩈᩮᩣ ᨸᩣᨿᩈᩮᩣ ᩏᨴᨠᩮ ᨸᨠ᩠ᨡᩥᨲ᩠ᨲᩮᩣ ᨧᩥᨧ᩠ᨧᩥᨭᩣᨿᨲᩥ ᨧᩥᨭᩥᨧᩥᨭᩣᨿᨲᩥ ᩈᨶ᩠ᨵᩪᨸᩣᨿᨲᩥ ᩈᨾ᩠ᨸᨵᩪᨸᩣᨿᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩈᩴᩅᩥᨣ᩠ᨣᩮᩣ ᩃᩮᩣᨾᩉᨭ᩠ᨮᨩᩣᨲᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩮᩣ ᨸᩣᨴᩮᩈᩩ ᩈᩥᩁᩈᩣ ᨶᩥᨸᨲᩥᨲ᩠ᩅᩣ ¶ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ ¶ , ᨽᩮᩣ ᨣᩮᩣᨲᨾ! ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᨶᩥᨠ᩠ᨠᩩᨩ᩠ᨩᩥᨲᩴ ᩅᩣ ᩏᨠ᩠ᨠᩩᨩ᩠ᨩᩮᨿ᩠ᨿ, ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᩴ ᩅᩣ ᩅᩥᩅᩁᩮᨿ᩠ᨿ, ᨾᩪᩊ᩠ᩉᩔ ᩅᩣ ᨾᨣ᩠ᨣᩴ ᩌᨧᩥᨠ᩠ᨡᩮᨿ᩠ᨿ, ᩋᨶ᩠ᨵᨠᩣᩁᩮ ᩅᩣ ᨲᩮᩃᨸᨩ᩠ᨩᩮᩣᨲᩴ ᨵᩣᩁᩮᨿ᩠ᨿ, ᨧᨠ᩠ᨡᩩᨾᨶ᩠ᨲᩮᩣ ᩁᩪᨸᩣᨶᩥ ᨴᨠ᩠ᨡᨶ᩠ᨲᩦᨲᩥ [ᨴᨠ᩠ᨡᩥᨶ᩠ᨲᩦᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)]; ᩑᩅᨾᩮᩅᩴ ᨽᩮᩣᨲᩣ ᨣᩮᩣᨲᨾᩮᨶ ᩋᨶᩮᨠᨸᩁᩥᨿᩣᨿᩮᨶ ᨵᨾ᩠ᨾᩮᩣ ᨸᨠᩣᩈᩥᨲᩮᩣ. ᩑᩈᩣᩉᩴ ᨽᩅᨶ᩠ᨲᩴ ᨣᩮᩣᨲᨾᩴ ᩈᩁᨱᩴ ᨣᨧ᩠ᨨᩣᨾᩥ ¶ ᨵᨾ᩠ᨾᨬ᩠ᨧ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᨬ᩠ᨧ, ᩃᨽᩮᨿ᩠ᨿᩣᩉᩴ ᨽᩮᩣᨲᩮᩣ ᨣᩮᩣᨲᨾᩔ ᩈᨶ᩠ᨲᩥᨠᩮ ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ, ᩃᨽᩮᨿ᩠ᨿᩴ ᩏᨸᩈᨾ᩠ᨸᨴ’’ᨶ᩠ᨲᩥ.

ᩋᩃᨲ᩠ᨳ ᨡᩮᩣ ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨲᩮᩣ ᩈᨶ᩠ᨲᩥᨠᩮ ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ, ᩋᩃᨲ᩠ᨳ ᩏᨸᩈᨾ᩠ᨸᨴᩴ. ᩋᨧᩥᩁᩪᨸᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᨸᨶᩣᨿᩈ᩠ᨾᩣ ᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᩑᨠᩮᩣ ᩅᩪᨸᨠᨭ᩠ᨮᩮᩣ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ ᩌᨲᩣᨸᩦ ᨸᩉᩥᨲᨲ᩠ᨲᩮᩣ ᩅᩥᩉᩁᨶ᩠ᨲᩮᩣ ᨶᨧᩥᩁᩔᩮᩅ – ᨿᩔᨲ᩠ᨳᩣᨿ ᨠᩩᩃᨸᩩᨲ᩠ᨲᩣ ᩈᨾ᩠ᨾᨴᩮᩅ ᩋᨣᩣᩁᩈ᩠ᨾᩣ ᩋᨶᨣᩣᩁᩥᨿᩴ ᨸᨻ᩠ᨻᨩᨶ᩠ᨲᩥ, ᨲᨴᨶᩩᨲ᩠ᨲᩁᩴ – ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᨸᩁᩥᨿᩮᩣᩈᩣᨶᩴ ᨴᩥᨭ᩠ᨮᩮᩅ ᨵᨾ᩠ᨾᩮ ᩈᨿᩴ ᩋᨽᩥᨬ᩠ᨬᩣ ᩈᨧ᩠ᨨᩥᨠᨲ᩠ᩅᩣ ᩏᨸᩈᨾ᩠ᨸᨩ᩠ᨩ ᩅᩥᩉᩣᩈᩥ. ‘‘ᨡᩦᨱᩣ ᨩᩣᨲᩥ, ᩅᩩᩈᩥᨲᩴ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᨠᨲᩴ ᨠᩁᨱᩦᨿᩴ, ᨶᩣᨸᩁᩴ ᩍᨲ᩠ᨳᨲ᩠ᨲᩣᨿᩣ’’ᨲᩥ ᩋᨻ᩠ᨽᨬ᩠ᨬᩣᩈᩥ. ᩋᨬ᩠ᨬᨲᩁᩮᩣ ᨧ [ᩋᨬ᩠ᨬᨲᩁᩮᩣ ᨧ ᨡᩮᩣ (ᩈᩦ. ᨸᩦ.), ᩋᨬ᩠ᨬᨲᩁᩮᩣ ᨡᩮᩣ (ᩈ᩠ᨿᩣ. ᨠᩴ. ᨠ.)] ᨸᨶᩣᨿᩈ᩠ᨾᩣ ᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᩋᩁᩉᨲᩴ ᩋᩉᩮᩣᩈᩦᨲᩥ.

ᨠᩈᩥᨽᩣᩁᨴ᩠ᩅᩣᨩᩈᩩᨲ᩠ᨲᩴ ᨧᨲᩩᨲ᩠ᨳᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ¶ ᨾᩩᨶᩥᩴ ᨸᩉᩪᨲᨸᨬ᩠ᨬᩴ, (ᩍᨲᩥ ᨧᩩᨶ᩠ᨴᩮᩣ ᨠᨾ᩠ᨾᩣᩁᨸᩩᨲ᩠ᨲᩮᩣ)

ᨴ᩠ᩅᩥᨸᨴᩩᨲ᩠ᨲᨾᩴ [ᨴᩥᨸᨴᩩᨲ᩠ᨲᨾᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᩈᩣᩁᨳᩦᨶᩴ ᨸᩅᩁᩴ, ᨠᨲᩥ ᩃᩮᩣᨠᩮ ᩈᨾᨱᩣ ᨲᨴᩥᨦ᩠ᨥ ᨻᩕᩪᩉᩥ’’.

‘‘ᨧᨲᩩᩁᩮᩣ ¶ ᩈᨾᨱᩣ ᨶ ᨸᨬ᩠ᨧᨾᨲ᩠ᨳᩥ, (ᨧᩩᨶ᩠ᨴᩣᨲᩥ ᨽᨣᩅᩣ)

ᨲᩮ ¶ ᨲᩮ ᩌᩅᩥᨠᩁᩮᩣᨾᩥ ᩈᨠ᩠ᨡᩥᨸᩩᨭ᩠ᨮᩮᩣ;

ᨾᨣ᩠ᨣᨩᩥᨶᩮᩣ ᨾᨣ᩠ᨣᨴᩮᩈᨠᩮᩣ ᨧ, ᨾᨣ᩠ᨣᩮ ᨩᩦᩅᨲᩥ ᨿᩮᩣ ᨧ ᨾᨣ᩠ᨣᨴᩪᩈᩦ’’.

‘‘ᨠᩴ ¶ ᨾᨣ᩠ᨣᨩᩥᨶᩴ ᩅᨴᨶ᩠ᨲᩥ ᨻᩩᨴ᩠ᨵᩣ, (ᩍᨲᩥ ᨧᩩᨶ᩠ᨴᩮᩣ ᨠᨾ᩠ᨾᩣᩁᨸᩩᨲ᩠ᨲᩮᩣ)

ᨾᨣ᩠ᨣᨠ᩠ᨡᩣᨿᩦ ᨠᨳᩴ ᩋᨲᩩᩃ᩠ᨿᩮᩣ ᩉᩮᩣᨲᩥ;

ᨾᨣ᩠ᨣᩮ ᨩᩦᩅᨲᩥ ᨾᩮ ᨻᩕᩪᩉᩥ ᨸᩩᨭ᩠ᨮᩮᩣ, ᩋᨳ ᨾᩮ ᩌᩅᩥᨠᩁᩮᩣᩉᩥ ᨾᨣ᩠ᨣᨴᩪᩈᩥᩴ’’ [ᨾᨣ᩠ᨣᨴᩪᩈᩦ (ᨠ.)].

‘‘ᨿᩮᩣ ᨲᩥᨱ᩠ᨱᨠᨳᩴᨠᨳᩮᩣ ᩅᩥᩈᩃ᩠ᩃᩮᩣ, ᨶᩥᨻ᩠ᨻᩣᨶᩣᨽᩥᩁᨲᩮᩣ ᩋᨶᩣᨶᩩᨣᩥᨴ᩠ᨵᩮᩣ;

ᩃᩮᩣᨠᩔ ᩈᨴᩮᩅᨠᩔ ᨶᩮᨲᩣ, ᨲᩣᨴᩥᩴ ᨾᨣ᩠ᨣᨩᩥᨶᩴ ᩅᨴᨶ᩠ᨲᩥ ᨻᩩᨴ᩠ᨵᩣ.

‘‘ᨸᩁᨾᩴ ᨸᩁᨾᨶ᩠ᨲᩥ ᨿᩮᩣᨵ ᨬᨲ᩠ᩅᩣ, ᩋᨠ᩠ᨡᩣᨲᩥ ¶ ᩅᩥᨽᨩᨲᩮ ᩍᨵᩮᩅ ᨵᨾ᩠ᨾᩴ;

ᨲᩴ ᨠᨦ᩠ᨡᨨᩥᨴᩴ ᨾᩩᨶᩥᩴ ᩋᨶᩮᨩᩴ, ᨴᩩᨲᩥᨿᩴ ᨽᩥᨠ᩠ᨡᩩᨶᨾᩣᩉᩩ ᨾᨣ᩠ᨣᨴᩮᩈᩥᩴ.

‘‘ᨿᩮᩣ ᨵᨾ᩠ᨾᨸᨴᩮ ᩈᩩᨴᩮᩈᩥᨲᩮ, ᨾᨣ᩠ᨣᩮ ᨩᩦᩅᨲᩥ ᩈᨬ᩠ᨬᨲᩮᩣ ᩈᨲᩦᨾᩣ;

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

‘‘ᨨᨴᨶᩴ ᨠᨲ᩠ᩅᩣᨶ ᩈᩩᨻ᩠ᨻᨲᩣᨶᩴ, ᨸᨠ᩠ᨡᨶ᩠ᨴᩦ ᨠᩩᩃᨴᩪᩈᨠᩮᩣ ᨸᨣᨻ᩠ᨽᩮᩣ;

ᨾᩣᨿᩣᩅᩦ ᩋᩈᨬ᩠ᨬᨲᩮᩣ ᨸᩃᩣᨸᩮᩣ, ᨸᨲᩥᩁᩪᨸᩮᨶ ᨧᩁᩴ ᩈ ᨾᨣ᩠ᨣᨴᩪᩈᩦ.

‘‘ᩑᨲᩮ ᨧ ᨸᨭᩥᩅᩥᨩ᩠ᨫᩥ ᨿᩮᩣ ᨣᩉᨭ᩠ᨮᩮᩣ, ᩈᩩᨲᩅᩣ ᩋᩁᩥᨿᩈᩣᩅᨠᩮᩣ ᩈᨸᨬ᩠ᨬᩮᩣ;

ᩈᨻ᩠ᨻᩮ ¶ ᨶᩮᨲᩣᨴᩥᩈᩣᨲᩥ [ᩈᨻ᩠ᨻᩮ ᨶᩮ ᨲᩣᨴᩥᩈᩣᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨬᨲ᩠ᩅᩣ, ᩍᨲᩥ ᨴᩥᩈ᩠ᩅᩣ ᨶ ᩉᩣᨸᩮᨲᩥ ᨲᩔ ᩈᨴ᩠ᨵᩣ;

ᨠᨳᩴ ᩉᩥ ᨴᩩᨭ᩠ᨮᩮᨶ ᩋᩈᨾ᩠ᨸᨴᩩᨭ᩠ᨮᩴ, ᩈᩩᨴ᩠ᨵᩴ ᩋᩈᩩᨴ᩠ᨵᩮᨶ ᩈᨾᩴ ᨠᩁᩮᨿ᩠ᨿᩣ’’ᨲᩥ.

ᩑᩅᩴ ¶ ¶ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨩᩮᨲᩅᨶᩮ ᩋᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩔ ᩌᩁᩣᨾᩮ. ᩋᨳ ᨡᩮᩣ ᩋᨬ᩠ᨬᨲᩁᩣ ᨴᩮᩅᨲᩣ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩣᨿ ᩁᨲ᩠ᨲᩥᨿᩣ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩅᨱ᩠ᨱᩣ ᨠᩮᩅᩃᨠᨸ᩠ᨸᩴ ᨩᩮᨲᩅᨶᩴ ᩒᨽᩣᩈᩮᨲ᩠ᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᩋᨭ᩠ᨮᩣᩈᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨮᩥᨲᩣ ᨡᩮᩣ ᩈᩣ ᨴᩮᩅᨲᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

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

ᨽᨣᩅᨶ᩠ᨲᩴ [ᨽᩅᨶ᩠ᨲᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨸᩩᨭ᩠ᨮᩩᨾᩣᨣᨾ᩠ᨾ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

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

ᨵᨾ᩠ᨾᨠᩣᨾᩮᩣ ᨽᩅᩴ ᩉᩮᩣᨲᩥ, ᨵᨾ᩠ᨾᨴᩮᩔᩦ ᨸᩁᩣᨽᩅᩮᩣ’’.

‘‘ᩍᨲᩥ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᨸᨮᨾᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᨴᩩᨲᩥᨿᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

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

ᩋᩈᨲᩴ ᨵᨾ᩠ᨾᩴ ᩁᩮᩣᨧᩮᨲᩥ, ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲᩥ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᨴᩩᨲᩥᨿᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᨲᨲᩥᨿᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᨶᩥᨴ᩠ᨴᩣᩈᩦᩃᩦ ¶ ᩈᨽᩣᩈᩦᩃᩦ, ᩋᨶᩩᨭ᩠ᨮᩣᨲᩣ ᨧ ᨿᩮᩣ ᨶᩁᩮᩣ;

ᩋᩃᩈᩮᩣ ᨠᩮᩣᨵᨸᨬ᩠ᨬᩣᨱᩮᩣ, ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲᩥ ¶ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᨲᨲᩥᨿᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᨧᨲᩩᨲ᩠ᨳᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

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

ᨸᩉᩩ ᩈᨶ᩠ᨲᩮᩣ ᨶ ᨽᩁᨲᩥ, ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲᩥ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᨧᨲᩩᨲ᩠ᨳᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᨸᨬ᩠ᨧᨾᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

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

ᨾᩩᩈᩣᩅᩣᨴᩮᨶ ᩅᨬ᩠ᨧᩮᨲᩥ, ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲᩥ ¶ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᨸᨬ᩠ᨧᨾᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᨨᨭ᩠ᨮᨾᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᨸᩉᩪᨲᩅᩥᨲ᩠ᨲᩮᩣ ᨸᩩᩁᩥᩈᩮᩣ, ᩈᩉᩥᩁᨬ᩠ᨬᩮᩣ ᩈᨽᩮᩣᨩᨶᩮᩣ;

ᩑᨠᩮᩣ ᨽᩩᨬ᩠ᨩᨲᩥ ᩈᩣᨴᩪᨶᩥ, ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲᩥ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᨨᨭ᩠ᨮᨾᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᩈᨲ᩠ᨲᨾᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᨩᩣᨲᩥᨲ᩠ᨳᨴ᩠ᨵᩮᩣ ᨵᨶᨲ᩠ᨳᨴ᩠ᨵᩮᩣ, ᨣᩮᩣᨲ᩠ᨲᨲ᩠ᨳᨴ᩠ᨵᩮᩣ ᨧ ᨿᩮᩣ ᨶᩁᩮᩣ;

ᩈᨬ᩠ᨬᩣᨲᩥᩴ ᩋᨲᩥᨾᨬ᩠ᨬᩮᨲᩥ, ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲᩥ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᩈᨲ᩠ᨲᨾᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᩋᨭ᩠ᨮᨾᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲ᩠ᨳᩥᨵᩩᨲ᩠ᨲᩮᩣ ᩈᩩᩁᩣᨵᩩᨲ᩠ᨲᩮᩣ, ᩋᨠ᩠ᨡᨵᩩᨲ᩠ᨲᩮᩣ ᨧ ᨿᩮᩣ ᨶᩁᩮᩣ;

ᩃᨴ᩠ᨵᩴ ᩃᨴ᩠ᨵᩴ ᩅᩥᨶᩣᩈᩮᨲᩥ, ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲᩥ ¶ ¶ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᩋᨭ᩠ᨮᨾᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᨶᩅᨾᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

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

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

‘‘ᩍᨲᩥ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᨶᩅᨾᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᨴᩈᨾᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩋᨲᩦᨲᨿᩮᩣᨻ᩠ᨻᨶᩮᩣ ᨸᩮᩣᩈᩮᩣ, ᩌᨶᩮᨲᩥ ᨲᩥᨾ᩠ᨻᩁᩩᨲ᩠ᨳᨶᩥᩴ;

ᨲᩔᩣ ᩍᩔᩣ ᨶ ᩈᩩᨸᨲᩥ, ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

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

ᩑᨠᩣᨴᩈᨾᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲ᩠ᨳᩥᩴ ᩈᩮᩣᨱ᩠ᨯᩥᩴ ᩅᩥᨠᩥᩁᨱᩥᩴ, ᨸᩩᩁᩥᩈᩴ ᩅᩣᨸᩥ ᨲᩣᨴᩥᩈᩴ;

ᩍᩔᩁᩥᨿᩈ᩠ᨾᩥᩴ ᨮᨸᩮᨲᩥ [ᨮᩣᨸᩮᨲᩥ (ᩈᩦ. ᨸᩦ.), ᨳᨸᩮᨲᩥ (ᨠ.)], ᨲᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩍᨲᩥ ¶ ᩉᩮᨲᩴ ᩅᩥᨩᩣᨶᩣᨾ, ᩑᨠᩣᨴᩈᨾᩮᩣ ᩈᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ;

ᨴ᩠ᩅᩣᨴᩈᨾᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ, ᨠᩥᩴ ᨸᩁᩣᨽᩅᨲᩮᩣ ᨾᩩᨡᩴ’’.

‘‘ᩋᨸ᩠ᨸᨽᩮᩣᨣᩮᩣ ᨾᩉᩣᨲᨱ᩠ᩉᩮᩣ, ᨡᨲ᩠ᨲᩥᨿᩮ ᨩᩣᨿᨲᩮ ᨠᩩᩃᩮ;

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

‘‘ᩑᨲᩮ ᨸᩁᩣᨽᩅᩮ ᩃᩮᩣᨠᩮ, ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᩈᨾᩅᩮᨠ᩠ᨡᩥᨿ;

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

ᩑᩅᩴ ¶ ¶ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨩᩮᨲᩅᨶᩮ ᩋᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩔ ᩌᩁᩣᨾᩮ. ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨸᩩᨻ᩠ᨻᨱ᩠ᩉᩈᨾᨿᩴ ᨶᩥᩅᩣᩈᩮᨲ᩠ᩅᩣ ᨸᨲ᩠ᨲᨧᩦᩅᩁᨾᩣᨴᩣᨿ ᩈᩣᩅᨲ᩠ᨳᩥᩴ ᨸᩥᨱ᩠ᨯᩣᨿ ᨸᩣᩅᩥᩈᩥ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᩋᨣ᩠ᨣᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨶᩥᩅᩮᩈᨶᩮ ᩋᨣ᩠ᨣᩥ ᨸᨩ᩠ᨩᩃᩥᨲᩮᩣ ᩉᩮᩣᨲᩥ ᩌᩉᩩᨲᩥ ᨸᨣ᩠ᨣᩉᩥᨲᩣ. ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩈᨸᨴᩣᨶᩴ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨾᩣᨶᩮᩣ ᨿᩮᨶ ᩋᨣ᩠ᨣᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨶᩥᩅᩮᩈᨶᩴ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ.

ᩋᨴ᩠ᨴᩈᩣ ᨡᩮᩣ ᩋᨣ᩠ᨣᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨴᩪᩁᨲᩮᩣᩅ ᩌᨣᨧ᩠ᨨᨶ᩠ᨲᩴ. ᨴᩥᩈ᩠ᩅᩣᨶ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨲᨲᩕᩮᩅ [ᩋᨲᩕᩮᩅ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨾᩩᨱ᩠ᨯᨠ; ᨲᨲᩕᩮᩅ, ᩈᨾᨱᨠ; ᨲᨲᩕᩮᩅ, ᩅᩈᩃᨠ ᨲᩥᨭ᩠ᨮᩣᩉᩦ’’ᨲᩥ.

ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᨽᨣᩅᩣ ᩋᨣ᩠ᨣᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨩᩣᨶᩣᩈᩥ ᨸᨶ ᨲ᩠ᩅᩴ, ᨻᩕᩣᩉ᩠ᨾᨱ, ᩅᩈᩃᩴ ᩅᩣ ᩅᩈᩃᨠᩁᨱᩮ ᩅᩣ ᨵᨾ᩠ᨾᩮ’’ᨲᩥ? ‘‘ᨶ ᨡ᩠ᩅᩣᩉᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᨩᩣᨶᩣᨾᩥ ᩅᩈᩃᩴ ᩅᩣ ᩅᩈᩃᨠᩁᨱᩮ ᩅᩣ ᨵᨾ᩠ᨾᩮ; ᩈᩣᨵᩩ ᨾᩮ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᨲᨳᩣ ᨵᨾ᩠ᨾᩴ ᨴᩮᩈᩮᨲᩩ, ᨿᨳᩣᩉᩴ ᨩᩣᨶᩮᨿ᩠ᨿᩴ ᩅᩈᩃᩴ ᩅᩣ ᩅᩈᩃᨠᩁᨱᩮ ᩅᩣ ᨵᨾ᩠ᨾᩮ’’ᨲᩥ. ‘‘ᨲᩮᨶ ᩉᩥ, ᨻᩕᩣᩉ᩠ᨾᨱ, ᩈᩩᨱᩣᩉᩥ, ᩈᩣᨵᩩᨠᩴ ᨾᨶᩈᩥ ᨠᩁᩮᩣᩉᩥ; ᨽᩣᩈᩥᩔᩣᨾᩦ’’ᨲᩥ. ‘‘ᩑᩅᩴ, ᨽᩮᩣ’’ᨲᩥ ᨡᩮᩣ ᩋᨣ᩠ᨣᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨲᩮᩣ ᨸᨧ᩠ᨧᩔᩮᩣᩈᩥ. ᨽᨣᩅᩣ ᩑᨲᨴᩅᩮᩣᨧ –

‘‘ᨠᩮᩣᨵᨶᩮᩣ ¶ ᩏᨸᨶᩣᩉᩦ ᨧ, ᨸᩣᨸᨾᨠ᩠ᨡᩦ ᨧ ᨿᩮᩣ ᨶᩁᩮᩣ;

ᩅᩥᨸᨶ᩠ᨶᨴᩥᨭ᩠ᨮᩥ ¶ ᨾᩣᨿᩣᩅᩦ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᩑᨠᨩᩴ ᩅᩣ ᨴ᩠ᩅᩥᨩᩴ [ᨴᩥᨩᩴ (ᨸᩦ.)] ᩅᩣᨸᩥ, ᨿᩮᩣᨵ ᨸᩣᨱᩴ ᩅᩥᩉᩥᩴᩈᨲᩥ;

ᨿᩔ ᨸᩣᨱᩮ ᨴᨿᩣ ᨶᨲ᩠ᨳᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

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

ᨶᩥᨣ᩠ᨣᩣᩉᨠᩮᩣ [ᨶᩥᨣ᩠ᨥᩣᨲᨠᩮᩣ (?)] ᩈᨾᨬ᩠ᨬᩣᨲᩮᩣ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨣᩣᨾᩮ ᩅᩣ ᨿᨴᩥ ᩅᩣ ᩁᨬ᩠ᨬᩮ, ᨿᩴ ᨸᩁᩮᩈᩴ ᨾᨾᩣᨿᩥᨲᩴ;

ᨳᩮᨿ᩠ᨿᩣ ᩋᨴᩥᨶ᩠ᨶᨾᩣᨴᩮᨲᩥ [ᩋᨴᩥᨶ᩠ᨶᩴ ᩌᨴᩥᨿᨲᩥ (ᩈᩦ. ᨸᩦ.)], ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ¶ ᩉᩅᩮ ᩍᨱᨾᩣᨴᩣᨿ, ᨧᩩᨩ᩠ᨩᨾᩣᨶᩮᩣ [ᨽᩩᨬ᩠ᨩᨾᩣᨶᩮᩣ (?)] ᨸᩃᩣᨿᨲᩥ;

ᨶ ᩉᩥ ᨲᩮ ᩍᨱᨾᨲ᩠ᨳᩦᨲᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᩅᩮ ᨠᩥᨬ᩠ᨧᩥᨠ᩠ᨡᨠᨾ᩠ᨿᨲᩣ, ᨸᨶ᩠ᨳᩈ᩠ᨾᩥᩴ ᩅᨩᨶ᩠ᨲᩴ ᨩᨶᩴ;

ᩉᨶ᩠ᨲ᩠ᩅᩣ ᨠᩥᨬ᩠ᨧᩥᨠ᩠ᨡᨾᩣᨴᩮᨲᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᩋᨲ᩠ᨲᩉᩮᨲᩩ ᨸᩁᩉᩮᨲᩩ, ᨵᨶᩉᩮᨲᩩ ᨧ [ᨵᨶᩉᩮᨲᩩ ᩅ (ᨠ.)] ᨿᩮᩣ ᨶᩁᩮᩣ;

ᩈᨠ᩠ᨡᩥᨸᩩᨭ᩠ᨮᩮᩣ ᨾᩩᩈᩣ ᨻᩕᩪᨲᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᨬᩣᨲᩦᨶᩴ ᩈᨡᩦᨶᩴ ᩅᩣ, ᨴᩣᩁᩮᩈᩩ ᨸᨭᩥᨴᩥᩔᨲᩥ;

ᩈᩣᩉᩈᩣ [ᩈᩉᩈᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩈᨾ᩠ᨸᩥᨿᩮᨶ ᩅᩣ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᨾᩣᨲᩁᩴ ᨸᩥᨲᩁᩴ ᩅᩣ, ᨩᩥᨱ᩠ᨱᨠᩴ ᨣᨲᨿᩮᩣᨻ᩠ᨻᨶᩴ;

ᨸᩉᩩ ᩈᨶ᩠ᨲᩮᩣ ᨶ ᨽᩁᨲᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᨾᩣᨲᩁᩴ ᨸᩥᨲᩁᩴ ᩅᩣ, ᨽᩣᨲᩁᩴ ᨽᨣᩥᨶᩥᩴ ᩈᩈᩩᩴ;

ᩉᨶ᩠ᨲᩥ ᩁᩮᩣᩈᩮᨲᩥ ᩅᩣᨧᩣᨿ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᩋᨲ᩠ᨳᩴ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᩈᨶ᩠ᨲᩮᩣ, ᩋᨶᨲ᩠ᨳᨾᨶᩩᩈᩣᩈᨲᩥ;

ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᩮᨶ ¶ ᨾᨶ᩠ᨲᩮᨲᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᨠᨲ᩠ᩅᩣ ᨸᩣᨸᨠᩴ ᨠᨾ᩠ᨾᩴ, ᨾᩣ ᨾᩴ ᨩᨬ᩠ᨬᩣᨲᩥ ᩍᨧ᩠ᨨᨲᩥ [ᩅᩥᨽ. ᪘᪙᪔ ᨸᩔᩥᨲᨻ᩠ᨻᩴ];

ᨿᩮᩣ ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᨠᨾ᩠ᨾᨶ᩠ᨲᩮᩣ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ¶ ᩅᩮ ᨸᩁᨠᩩᩃᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᨽᩩᨲ᩠ᩅᩣᨶ [ᩈᩩᨲ᩠ᩅᩣ ᨧ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩈᩩᨧᩥᨽᩮᩣᨩᨶᩴ;

ᩌᨣᨲᩴ ᨶᨸ᩠ᨸᨭᩥᨸᩪᨩᩮᨲᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᩈᨾᨱᩴ ᩅᩣ, ᩋᨬ᩠ᨬᩴ ᩅᩣᨸᩥ ᩅᨶᩥᨻ᩠ᨻᨠᩴ;

ᨾᩩᩈᩣᩅᩣᨴᩮᨶ ᩅᨬ᩠ᨧᩮᨲᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ¶ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᩈᨾᨱᩴ ᩅᩣ, ᨽᨲ᩠ᨲᨠᩣᩃᩮ ᩏᨸᨭ᩠ᨮᩥᨲᩮ;

ᩁᩮᩣᩈᩮᨲᩥ ᩅᩣᨧᩣ ᨶ ᨧ ᨴᩮᨲᩥ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᩋᩈᨲᩴ ᨿᩮᩣᨵ ᨸᨻᩕᩪᨲᩥ, ᨾᩮᩣᩉᩮᨶ ᨸᩃᩥᨣᩩᨱ᩠ᨮᩥᨲᩮᩣ;

ᨠᩥᨬ᩠ᨧᩥᨠ᩠ᨡᩴ ᨶᩥᨩᩥᨣᩦᩈᩣᨶᩮᩣ [ᨶᩥᨩᩥᨣᩥᩴᩈᩣᨶᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)], ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

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

ᨶᩥᩉᩦᨶᩮᩣ ᩈᩮᨶ ᨾᩣᨶᩮᨶ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᩁᩮᩣᩈᨠᩮᩣ ᨠᨴᩁᩥᨿᩮᩣ ᨧ, ᨸᩣᨸᩥᨧ᩠ᨨᩮᩣ ᨾᨧ᩠ᨨᩁᩦ ᩈᨮᩮᩣ;

ᩋᩉᩥᩁᩥᨠᩮᩣ ᩋᨶᩮᩣᨲ᩠ᨲᨸ᩠ᨸᩦ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᨻᩩᨴ᩠ᨵᩴ ᨸᩁᩥᨽᩣᩈᨲᩥ, ᩋᨳ ᩅᩣ ᨲᩔ ᩈᩣᩅᨠᩴ;

ᨸᩁᩥᨻ᩠ᨻᩣᨩᩴ [ᨸᩁᩥᨻ᩠ᨻᨩᩴ (ᨠ.), ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩴ (ᩈ᩠ᨿᩣ. ᨠᩴ.)] ᨣᩉᨭ᩠ᨮᩴ ᩅᩣ, ᨲᩴ ᨩᨬ᩠ᨬᩣ ᩅᩈᩃᩮᩣ ᩍᨲᩥ.

‘‘ᨿᩮᩣ ᩅᩮ ᩋᨶᩁᩉᩴ [ᩋᨶᩁᩉᩣ (ᩈᩦ. ᨸᩦ.)] ᩈᨶ᩠ᨲᩮᩣ, ᩋᩁᩉᩴ ᨸᨭᩥᨩᩣᨶᩣᨲᩥ [ᨸᨭᩥᨩᩣᨶᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᨧᩮᩣᩁᩮᩣ ᩈᨻᩕᩉ᩠ᨾᨠᩮ ᩃᩮᩣᨠᩮ, ᩑᩈᩮᩣ ᨡᩮᩣ ᩅᩈᩃᩣᨵᨾᩮᩣ.

‘‘ᩑᨲᩮ ᨡᩮᩣ ᩅᩈᩃᩣ ᩅᩩᨲ᩠ᨲᩣ, ᨾᨿᩣ ᨿᩮᨲᩮ ᨸᨠᩣᩈᩥᨲᩣ;

ᨶ ¶ ᨩᨧ᩠ᨧᩣ ᩅᩈᩃᩮᩣ ᩉᩮᩣᨲᩥ, ᨶ ᨩᨧ᩠ᨧᩣ ᩉᩮᩣᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᨠᨾ᩠ᨾᩩᨶᩣ [ᨠᨾ᩠ᨾᨶᩣ (ᩈᩦ. ᨸᩦ.)] ᩅᩈᩃᩮᩣ ᩉᩮᩣᨲᩥ, ᨠᨾ᩠ᨾᩩᨶᩣ ᩉᩮᩣᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨲᨴᨾᩥᨶᩣᨸᩥ ᨩᩣᨶᩣᨳ, ᨿᨳᩣᨾᩮᨴᩴ [ᨿᨳᩣᨸᩮᨴᩴ (ᨠ.)] ᨶᩥᨴᩔᨶᩴ;

ᨧᨱ᩠ᨯᩣᩃᨸᩩᨲ᩠ᨲᩮᩣ ᩈᩮᩣᨸᩣᨠᩮᩣ [ᩈᨸᩣᨠᩮᩣ (?)], ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᩍᨲᩥ ᩅᩥᩔᩩᨲᩮᩣ.

‘‘ᩈᩮᩣ ¶ ¶ ᨿᩈᩴ ᨸᩁᨾᩴ ᨸᨲ᩠ᨲᩮᩣ [ᩈᩮᩣ ᨿᩈᨸ᩠ᨸᩁᨾᨸ᩠ᨸᨲ᩠ᨲᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᨿᩴ ᩈᩩᨴᩩᩃ᩠ᩃᨽᩴ;

ᩌᨣᨧ᩠ᨨᩩᩴ ᨲᩔᩩᨸᨭ᩠ᨮᩣᨶᩴ, ᨡᨲ᩠ᨲᩥᨿᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨻᩉᩪ.

‘‘ᨴᩮᩅᨿᩣᨶᩴ ¶ ᩋᨽᩥᩁᩩᨿ᩠ᩉ, ᩅᩥᩁᨩᩴ ᩈᩮᩣ ᨾᩉᩣᨸᨳᩴ;

ᨠᩣᨾᩁᩣᨣᩴ ᩅᩥᩁᩣᨩᩮᨲ᩠ᩅᩣ, ᨻᩕᩉ᩠ᨾᩃᩮᩣᨠᩪᨸᨣᩮᩣ ᩋᩉᩩ;

ᨶ ᨶᩴ ᨩᩣᨲᩥ ᨶᩥᩅᩣᩁᩮᩈᩥ, ᨻᩕᩉ᩠ᨾᩃᩮᩣᨠᩪᨸᨸᨲ᩠ᨲᩥᨿᩣ.

‘‘ᩋᨩ᩠ᨫᩣᨿᨠᨠᩩᩃᩮ ᨩᩣᨲᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨾᨶ᩠ᨲᨻᨶ᩠ᨵᩅᩣ;

ᨲᩮ ᨧ ᨸᩣᨸᩮᩈᩩ ᨠᨾ᩠ᨾᩮᩈᩩ, ᩋᨽᩥᨱ᩠ᩉᨾᩩᨸᨴᩥᩔᩁᩮ.

‘‘ᨴᩥᨭ᩠ᨮᩮᩅ ᨵᨾ᩠ᨾᩮ ᨣᩣᩁᨿ᩠ᩉᩣ, ᩈᨾ᩠ᨸᩁᩣᨿᩮ ᨧ ᨴᩩᨣ᩠ᨣᨲᩥ;

ᨶ ᨶᩮ ᨩᩣᨲᩥ ᨶᩥᩅᩣᩁᩮᨲᩥ, ᨴᩩᨣ᩠ᨣᨲ᩠ᨿᩣ [ᨴᩩᨣ᩠ᨣᨧ᩠ᨧᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᨣᩁᩉᩣᨿ ᩅᩣ.

‘‘ᨶ ᨩᨧ᩠ᨧᩣ ᩅᩈᩃᩮᩣ ᩉᩮᩣᨲᩥ, ᨶ ᨩᨧ᩠ᨧᩣ ᩉᩮᩣᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᨠᨾ᩠ᨾᩩᨶᩣ ᩅᩈᩃᩮᩣ ᩉᩮᩣᨲᩥ, ᨠᨾ᩠ᨾᩩᨶᩣ ᩉᩮᩣᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ’’ᨲᩥ.

ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᩋᨣ᩠ᨣᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ…ᨸᩮ… ¶ ¶ ᩏᨸᩣᩈᨠᩴ ᨾᩴ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᨵᩣᩁᩮᨲᩩ ᩋᨩ᩠ᨩᨲᨣ᩠ᨣᩮ ᨸᩣᨱᩩᨸᩮᨲᩴ ᩈᩁᨱᩴ ᨣᨲ’’ᨶ᩠ᨲᩥ.

ᨠᩁᨱᩦᨿᨾᨲ᩠ᨳᨠᩩᩈᩃᩮᨶ, ᨿᨶ᩠ᨲ ᩈᨶ᩠ᨲᩴ ᨸᨴᩴ ᩋᨽᩥᩈᨾᩮᨧ᩠ᨧ;

ᩈᨠ᩠ᨠᩮᩣ ᩏᨩᩪ ᨧ ᩈᩩᩉᩩᨩᩪ [ᩈᩪᨩᩪ (ᩈᩦ.)] ᨧ, ᩈᩪᩅᨧᩮᩣ ᨧᩔ ᨾᩩᨴᩩ ᩋᨶᨲᩥᨾᩣᨶᩦ.

ᩈᨶ᩠ᨲᩩᩔᨠᩮᩣ ᨧ ᩈᩩᨽᩁᩮᩣ ᨧ, ᩋᨸ᩠ᨸᨠᩥᨧ᩠ᨧᩮᩣ ᨧ ᩈᩃ᩠ᩃᩉᩩᨠᩅᩩᨲ᩠ᨲᩥ;

ᩈᨶ᩠ᨲᩥᨶ᩠ᨴᩕᩥᨿᩮᩣ ᨧ ᨶᩥᨸᨠᩮᩣ ᨧ, ᩋᨸ᩠ᨸᨣᨻ᩠ᨽᩮᩣ ᨠᩩᩃᩮᩈ᩠ᩅᨶᨶᩩᨣᩥᨴ᩠ᨵᩮᩣ.

ᨶ ¶ ᨧ ᨡᩩᨴ᩠ᨴᨾᩣᨧᩁᩮ ᨠᩥᨬ᩠ᨧᩥ, ᨿᩮᨶ ᩅᩥᨬ᩠ᨬᩪ ᨸᩁᩮ ᩏᨸᩅᨴᩮᨿ᩠ᨿᩩᩴ;

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

ᨿᩮ ¶ ᨠᩮᨧᩥ ᨸᩣᨱᨽᩪᨲᨲ᩠ᨳᩥ, ᨲᩈᩣ ¶ ᩅᩣ ᨳᩣᩅᩁᩣ ᩅᨶᩅᩈᩮᩈᩣ;

ᨴᩦᨥᩣ ᩅᩣ ᨿᩮ ᩅ ᨾᩉᨶ᩠ᨲᩣ [ᨾᩉᨶ᩠ᨲ (?)], ᨾᨩ᩠ᨫᩥᨾᩣ ᩁᩔᨠᩣ ᩋᨱᩩᨠᨳᩪᩃᩣ.

ᨴᩥᨭ᩠ᨮᩣ ¶ ᩅᩣ ᨿᩮ ᩅ ᩋᨴᩥᨭ᩠ᨮᩣ [ᩋᨴᩥᨭ᩠ᨮ (?)], ᨿᩮ ᩅ [ᨿᩮ ᨧ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᨴᩪᩁᩮ ᩅᩈᨶ᩠ᨲᩥ ᩋᩅᩥᨴᩪᩁᩮ;

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

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

ᨻ᩠ᨿᩣᩁᩮᩣᩈᨶᩣ ᨸᨭᩥᨥᩈᨬ᩠ᨬᩣ, ᨶᩣᨬ᩠ᨬᨾᨬ᩠ᨬᩔ ᨴᩩᨠ᩠ᨡᨾᩥᨧ᩠ᨨᩮᨿ᩠ᨿ.

ᨾᩣᨲᩣ ᨿᨳᩣ ᨶᩥᨿᩴ ᨸᩩᨲ᩠ᨲᨾᩣᨿᩩᩈᩣ ᩑᨠᨸᩩᨲ᩠ᨲᨾᨶᩩᩁᨠ᩠ᨡᩮ;

ᩑᩅᨾ᩠ᨸᩥ ᩈᨻ᩠ᨻᨽᩪᨲᩮᩈᩩ, ᨾᩣᨶᩈᩴ ᨽᩣᩅᨿᩮ ᩋᨸᩁᩥᨾᩣᨱᩴ.

ᨾᩮᨲ᩠ᨲᨬ᩠ᨧ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩈ᩠ᨾᩥ, ᨾᩣᨶᩈᩴ ᨽᩣᩅᨿᩮ ᩋᨸᩁᩥᨾᩣᨱᩴ;

ᩏᨴ᩠ᨵᩴ ᩋᨵᩮᩣ ᨧ ᨲᩥᩁᩥᨿᨬ᩠ᨧ, ᩋᩈᨾ᩠ᨻᩣᨵᩴ ᩋᩅᩮᩁᨾᩈᨸᨲ᩠ᨲᩴ.

ᨲᩥᨭ᩠ᨮᩴ ¶ ᨧᩁᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᩅ [ᩅᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)], ᩈᨿᩣᨶᩮᩣ ¶ ᨿᩣᩅᨲᩣᩔ ᩅᩥᨲᨾᩥᨴ᩠ᨵᩮᩣ [ᩅᩥᨣᨲᨾᩥᨴ᩠ᨵᩮᩣ (ᨻᩉᩪᩈᩩ)];

ᩑᨲᩴ ᩈᨲᩥᩴ ᩋᨵᩥᨭ᩠ᨮᩮᨿ᩠ᨿ, ᨻᩕᩉ᩠ᨾᨾᩮᨲᩴ ᩅᩥᩉᩣᩁᨾᩥᨵᨾᩣᩉᩩ.

ᨴᩥᨭ᩠ᨮᩥᨬ᩠ᨧ ᩋᨶᩩᨸᨣ᩠ᨣᨾ᩠ᨾ, ᩈᩦᩃᩅᩣ ᨴᩔᨶᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ;

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

‘‘ᩋᨩ᩠ᨩ ¶ ᨸᨶ᩠ᨶᩁᩈᩮᩣ ᩏᨸᩮᩣᩈᨳᩮᩣ, (ᩍᨲᩥ ᩈᩣᨲᩣᨣᩥᩁᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᨴᩥᨻ᩠ᨻᩣ [ᨴᩥᨻ᩠ᨿᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᩁᨲ᩠ᨲᩥ ᩏᨸᨭ᩠ᨮᩥᨲᩣ;

ᩋᨶᩮᩣᨾᨶᩣᨾᩴ ᩈᨲ᩠ᨳᩣᩁᩴ, ᩉᨶ᩠ᨴ ᨸᩔᩣᨾ ᨣᩮᩣᨲᨾᩴ’’.

‘‘ᨠᨧ᩠ᨧᩥ ¶ ᨾᨶᩮᩣ ᩈᩩᨸᨱᩥᩉᩥᨲᩮᩣ, (ᩍᨲᩥ ᩉᩮᨾᩅᨲᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᨠᨧ᩠ᨧᩥ ᩍᨭ᩠ᨮᩮ ᩋᨶᩥᨭ᩠ᨮᩮ ᨧ, ᩈᨦ᩠ᨠᨸ᩠ᨸᩔ ᩅᩈᩦᨠᨲᩣ’’.

‘‘ᨾᨶᩮᩣ ᨧᩔ ᩈᩩᨸᨱᩥᩉᩥᨲᩮᩣ, (ᩍᨲᩥ ᩈᩣᨲᩣᨣᩥᩁᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᩋᨳᩮᩣ ᩍᨭ᩠ᨮᩮ ᩋᨶᩥᨭ᩠ᨮᩮ ᨧ, ᩈᨦ᩠ᨠᨸ᩠ᨸᩔ ᩅᩈᩦᨠᨲᩣ’’.

‘‘ᨠᨧ᩠ᨧᩥ ¶ ᩋᨴᩥᨶ᩠ᨶᩴ ᨶᩣᨴᩥᨿᨲᩥ, (ᩍᨲᩥ ᩉᩮᨾᩅᨲᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᨠᨧ᩠ᨧᩥ ᩌᩁᩣ ᨸᨾᩣᨴᨾ᩠ᩉᩣ, ᨠᨧ᩠ᨧᩥ ᨫᩣᨶᩴ ᨶ ᩁᩥᨬ᩠ᨧᨲᩥ’’.

‘‘ᨶ ¶ ᩈᩮᩣ ᩋᨴᩥᨶ᩠ᨶᩴ ᩌᨴᩥᨿᨲᩥ, (ᩍᨲᩥ ᩈᩣᨲᩣᨣᩥᩁᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᩋᨳᩮᩣ ᩌᩁᩣ ᨸᨾᩣᨴᨾ᩠ᩉᩣ, ᨻᩩᨴ᩠ᨵᩮᩣ ᨫᩣᨶᩴ ᨶ ᩁᩥᨬ᩠ᨧᨲᩥ’’.

‘‘ᨠᨧ᩠ᨧᩥ ᨾᩩᩈᩣ ᨶ ᨽᨱᨲᩥ, (ᩍᨲᩥ ᩉᩮᨾᩅᨲᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᨠᨧ᩠ᨧᩥ ¶ ᩅᩮᨽᩪᨲᩥᨿᩴ ᨶᩣᩉ, ᨠᨧ᩠ᨧᩥ ᩈᨾ᩠ᨹᩴ ᨶ ᨽᩣᩈᨲᩥ’’.

‘‘ᨾᩩᩈᩣ ᨧ ᩈᩮᩣ ᨶ ᨽᨱᨲᩥ, (ᩍᨲᩥ ᩈᩣᨲᩣᨣᩥᩁᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

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

‘‘ᨠᨧ᩠ᨧᩥ ᨶ ᩁᨩ᩠ᨩᨲᩥ ᨠᩣᨾᩮᩈᩩ, (ᩍᨲᩥ ᩉᩮᨾᩅᨲᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᨠᨧ᩠ᨧᩥ ᨾᩮᩣᩉᩴ ᩋᨲᩥᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᨠᨧ᩠ᨧᩥ ᨵᨾ᩠ᨾᩮᩈᩩ ᨧᨠ᩠ᨡᩩᨾᩣ’’.

‘‘ᨶ ¶ ᩈᩮᩣ ᩁᨩ᩠ᨩᨲᩥ ᨠᩣᨾᩮᩈᩩ, (ᩍᨲᩥ ᩈᩣᨲᩣᨣᩥᩁᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᩈᨻ᩠ᨻᨾᩮᩣᩉᩴ ᩋᨲᩥᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᨻᩩᨴ᩠ᨵᩮᩣ ᨵᨾ᩠ᨾᩮᩈᩩ ᨧᨠ᩠ᨡᩩᨾᩣ’’.

‘‘ᨠᨧ᩠ᨧᩥ ᩅᩥᨩ᩠ᨩᩣᨿ ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, (ᩍᨲᩥ ᩉᩮᨾᩅᨲᩮᩣ ᨿᨠ᩠ᨡᩮᩣ )

ᨠᨧ᩠ᨧᩥᩔ ¶ ᩌᩈᩅᩣ ᨡᩦᨱᩣ, ᨠᨧ᩠ᨧᩥ ᨶᨲ᩠ᨳᩥ ᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ’’.

‘‘ᩅᩥᨩ᩠ᨩᩣᨿ ¶ ᨧᩮᩅ ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, (ᩍᨲᩥ ᩈᩣᨲᩣᨣᩥᩁᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᩈᨻ᩠ᨻᩔ ᩌᩈᩅᩣ ᨡᩦᨱᩣ, ᨶᨲ᩠ᨳᩥ ᨲᩔ ᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ’’.

‘‘ᩈᨾ᩠ᨸᨶ᩠ᨶᩴ ¶ ᨾᩩᨶᩥᨶᩮᩣ ᨧᩥᨲ᩠ᨲᩴ, ᨠᨾ᩠ᨾᩩᨶᩣ ᨻ᩠ᨿᨸ᩠ᨸᨳᩮᨶ ᨧ;

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

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

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

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

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

‘‘ᩑᨱᩥᨩᨦ᩠ᨥᩴ ᨠᩥᩈᩴ ᩅᩦᩁᩴ [ᨵᩦᩁᩴ (ᩈ᩠ᨿᩣ.)], ᩋᨸ᩠ᨸᩣᩉᩣᩁᩴ ᩋᩃᩮᩣᩃᩩᨸᩴ;

ᨾᩩᨶᩥᩴ ᩅᨶᩈ᩠ᨾᩥᩴ ᨫᩣᨿᨶ᩠ᨲᩴ, ᩑᩉᩥ ᨸᩔᩣᨾ ᨣᩮᩣᨲᨾᩴ.

‘‘ᩈᩦᩉᩴᩅᩮᨠᨧᩁᩴ ᨶᩣᨣᩴ, ᨠᩣᨾᩮᩈᩩ ᩋᨶᨸᩮᨠ᩠ᨡᩥᨶᩴ;

ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ ᨸᩩᨧ᩠ᨨᩣᨾ, ᨾᨧ᩠ᨧᩩᨸᩣᩈᨸ᩠ᨸᨾᩮᩣᨧᨶᩴ.

‘‘ᩋᨠ᩠ᨡᩣᨲᩣᩁᩴ ᨸᩅᨲ᩠ᨲᩣᩁᩴ, ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩣᨶ ᨸᩣᩁᨣᩩᩴ;

ᨻᩩᨴ᩠ᨵᩴ ᩅᩮᩁᨽᨿᩣᨲᩦᨲᩴ, ᨾᨿᩴ ᨸᩩᨧ᩠ᨨᩣᨾ ᨣᩮᩣᨲᨾᩴ’’.

‘‘ᨠᩥᩈ᩠ᨾᩥᩴ ¶ ᩃᩮᩣᨠᩮᩣ ᩈᨾᩩᨸ᩠ᨸᨶ᩠ᨶᩮᩣ, (ᩍᨲᩥ ᩉᩮᨾᩅᨲᩮᩣ ᨿᨠ᩠ᨡᩮᩣ)

ᨠᩥᩈ᩠ᨾᩥᩴ ᨠᩩᨻ᩠ᨻᨲᩥ ᩈᨶ᩠ᨳᩅᩴ [ᩈᨶ᩠ᨵᩅᩴ (ᨠ.)];

ᨠᩥᩔ ᩃᩮᩣᨠᩮᩣ ᩏᨸᩣᨴᩣᨿ, ᨠᩥᩈ᩠ᨾᩥᩴ ᩃᩮᩣᨠᩮᩣ ᩅᩥᩉᨬ᩠ᨬᨲᩥ’’.

‘‘ᨨᩈᩩ ¶ ¶ [ᨨᩔᩩ (ᩈᩦ. ᨸᩦ.)] ᩃᩮᩣᨠᩮᩣ ᩈᨾᩩᨸ᩠ᨸᨶ᩠ᨶᩮᩣ, (ᩉᩮᨾᩅᨲᩣᨲᩥ ᨽᨣᩅᩣ)

ᨨᨶ᩠ᨶᨾᩮᩅ ᩏᨸᩣᨴᩣᨿ, ᨨᩈᩩ ᩃᩮᩣᨠᩮᩣ ᩅᩥᩉᨬ᩠ᨬᨲᩥ’’.

‘‘ᨠᨲᨾᩴ ᨲᩴ ᩏᨸᩣᨴᩣᨶᩴ, ᨿᨲ᩠ᨳ ᩃᩮᩣᨠᩮᩣ ᩅᩥᩉᨬ᩠ᨬᨲᩥ;

ᨶᩥᨿ᩠ᨿᩣᨶᩴ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᨻᩕᩪᩉᩥ, ᨠᨳᩴ ᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩩᨧ᩠ᨧᨲᩥ’’ [ᨸᨾᩩᨬ᩠ᨧᨲᩥ (ᩈ᩠ᨿᩣ.)].

‘‘ᨸᨬ᩠ᨧ ᨠᩣᨾᨣᩩᨱᩣ ᩃᩮᩣᨠᩮ, ᨾᨶᩮᩣᨨᨭ᩠ᨮᩣ ᨸᩅᩮᨴᩥᨲᩣ;

ᩑᨲ᩠ᨳ ᨨᨶ᩠ᨴᩴ ᩅᩥᩁᩣᨩᩮᨲ᩠ᩅᩣ, ᩑᩅᩴ ᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩩᨧ᩠ᨧᨲᩥ.

‘‘ᩑᨲᩴ ᩃᩮᩣᨠᩔ ᨶᩥᨿ᩠ᨿᩣᨶᩴ, ᩋᨠ᩠ᨡᩣᨲᩴ ᩅᩮᩣ ᨿᨳᩣᨲᨳᩴ;

ᩑᨲᩴ ᩅᩮᩣ ᩋᩉᨾᨠ᩠ᨡᩣᨾᩥ, ᩑᩅᩴ ᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩩᨧ᩠ᨧᨲᩥ’’.

‘‘ᨠᩮᩣ ¶ ᩈᩪᨵ ᨲᩁᨲᩥ ᩒᨥᩴ, ᨠᩮᩣᨵ ᨲᩁᨲᩥ ᩋᨱ᩠ᨱᩅᩴ;

ᩋᨸ᩠ᨸᨲᩥᨭ᩠ᨮᩮ ᩋᨶᩣᩃᨾ᩠ᨻᩮ, ᨠᩮᩣ ᨣᨾ᩠ᨽᩦᩁᩮ ᨶ ᩈᩦᨴᨲᩥ’’.

‘‘ᩈᨻ᩠ᨻᨴᩣ ᩈᩦᩃᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᨸᨬ᩠ᨬᩅᩣ ᩈᩩᩈᨾᩣᩉᩥᨲᩮᩣ;

ᩋᨩ᩠ᨫᨲ᩠ᨲᨧᩥᨶ᩠ᨲᩦ [ᩋᨩ᩠ᨫᨲ᩠ᨲᩈᨬ᩠ᨬᩦ (ᩈ᩠ᨿᩣ. ᨠᩴ. ᨠ.)] ᩈᨲᩥᨾᩣ, ᩒᨥᩴ ᨲᩁᨲᩥ ᨴᩩᨲ᩠ᨲᩁᩴ.

‘‘ᩅᩥᩁᨲᩮᩣ ᨠᩣᨾᩈᨬ᩠ᨬᩣᨿ, ᩈᨻ᩠ᨻᩈᩴᨿᩮᩣᨩᨶᩣᨲᩥᨣᩮᩣ;

ᨶᨶ᩠ᨴᩦᨽᩅᨸᩁᩥᨠ᩠ᨡᩦᨱᩮᩣ, ᩈᩮᩣ ᨣᨾ᩠ᨽᩦᩁᩮ ᨶ ᩈᩦᨴᨲᩥ’’.

‘‘ᨣᨻ᩠ᨽᩦᩁᨸᨬ᩠ᨬᩴ ᨶᩥᨸᩩᨱᨲ᩠ᨳᨴᩔᩥᩴ, ᩋᨠᩥᨬ᩠ᨧᨶᩴ ᨠᩣᨾᨽᩅᩮ ᩋᩈᨲ᩠ᨲᩴ;

ᨲᩴ ᨸᩔᨳ ᩈᨻ᩠ᨻᨵᩥ ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩴ, ᨴᩥᨻ᩠ᨻᩮ ᨸᨳᩮ ᨠᨾᨾᩣᨶᩴ ᨾᩉᩮᩈᩥᩴ.

‘‘ᩋᨶᩮᩣᨾᨶᩣᨾᩴ ¶ ᨶᩥᨸᩩᨱᨲ᩠ᨳᨴᩔᩥᩴ, ᨸᨬ᩠ᨬᩣᨴᨴᩴ ¶ ᨠᩣᨾᩣᩃᨿᩮ ᩋᩈᨲ᩠ᨲᩴ;

ᨲᩴ ¶ ᨸᩔᨳ ᩈᨻ᩠ᨻᩅᩥᨴᩩᩴ ᩈᩩᨾᩮᨵᩴ, ᩋᩁᩥᨿᩮ ᨸᨳᩮ ᨠᨾᨾᩣᨶᩴ ᨾᩉᩮᩈᩥᩴ.

‘‘ᩈᩩᨴᩥᨭ᩠ᨮᩴ ᩅᨲ ᨶᩮᩣ ᩋᨩ᩠ᨩ, ᩈᩩᨸ᩠ᨸᨽᩣᨲᩴ ᩈᩩᩉᩩᨭ᩠ᨮᩥᨲᩴ;

ᨿᩴ ᩋᨴ᩠ᨴᩈᩣᨾ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩴ, ᩒᨥᨲᩥᨱ᩠ᨱᨾᨶᩣᩈᩅᩴ.

‘‘ᩍᨾᩮ ᨴᩈᩈᨲᩣ ᨿᨠ᩠ᨡᩣ, ᩍᨴ᩠ᨵᩥᨾᨶ᩠ᨲᩮᩣ ᨿᩈᩔᩥᨶᩮᩣ;

ᩈᨻ᩠ᨻᩮ ᨲᩴ ᩈᩁᨱᩴ ᨿᨶ᩠ᨲᩥ, ᨲ᩠ᩅᩴ ᨶᩮᩣ ᩈᨲ᩠ᨳᩣ ᩋᨶᩩᨲ᩠ᨲᩁᩮᩣ.

‘‘ᨲᩮ ᨾᨿᩴ ᩅᩥᨧᩁᩥᩔᩣᨾ, ᨣᩣᨾᩣ ᨣᩣᨾᩴ ᨶᨣᩣ ᨶᨣᩴ;

ᨶᨾᩔᨾᩣᨶᩣ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩴ, ᨵᨾ᩠ᨾᩔ ᨧ ᩈᩩᨵᨾ᩠ᨾᨲ’’ᨶ᩠ᨲᩥ.

ᩑᩅᩴ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩌᩊᩅᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᩌᩊᩅᨠᩔ ᨿᨠ᩠ᨡᩔ ᨽᩅᨶᩮ. ᩋᨳ ᨡᩮᩣ ᩌᩊᩅᨠᩮᩣ ᨿᨠ᩠ᨡᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨶᩥᨠ᩠ᨡᨾ, ᩈᨾᨱᩣ’’ᨲᩥ. ‘‘ᩈᩣᨵᩣᩅᩩᩈᩮᩣ’’ᨲᩥ ¶ ᨽᨣᩅᩣ ᨶᩥᨠ᩠ᨡᨾᩥ. ‘‘ᨸᩅᩥᩈ, ᩈᨾᨱᩣ’’ᨲᩥ. ‘‘ᩈᩣᨵᩣᩅᩩᩈᩮᩣ’’ᨲᩥ ᨽᨣᩅᩣ ᨸᩣᩅᩥᩈᩥ.

ᨴᩩᨲᩥᨿᨾ᩠ᨸᩥ ᨡᩮᩣ…ᨸᩮ… ᨲᨲᩥᨿᨾ᩠ᨸᩥ ᨡᩮᩣ ᩌᩊᩅᨠᩮᩣ ᨿᨠ᩠ᨡᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨶᩥᨠ᩠ᨡᨾ, ᩈᨾᨱᩣ’’ᨲᩥ. ‘‘ᩈᩣᨵᩣᩅᩩᩈᩮᩣ’’ᨲᩥ ¶ ᨽᨣᩅᩣ ᨶᩥᨠ᩠ᨡᨾᩥ. ‘‘ᨸᩅᩥᩈ, ᩈᨾᨱᩣ’’ᨲᩥ. ‘‘ᩈᩣᨵᩣᩅᩩᩈᩮᩣ’’ᨲᩥ ᨽᨣᩅᩣ ᨸᩣᩅᩥᩈᩥ.

ᨧᨲᩩᨲ᩠ᨳᨾ᩠ᨸᩥ ᨡᩮᩣ ᩌᩊᩅᨠᩮᩣ ᨿᨠ᩠ᨡᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨶᩥᨠ᩠ᨡᨾ, ᩈᨾᨱᩣ’’ᨲᩥ. ‘‘ᨶ ᨡ᩠ᩅᩣᩉᩴ ᨲᩴ ¶ , ᩌᩅᩩᩈᩮᩣ, ᨶᩥᨠ᩠ᨡᨾᩥᩔᩣᨾᩥ. ᨿᩴ ᨲᩮ ᨠᩁᨱᩦᨿᩴ, ᨲᩴ ᨠᩁᩮᩣᩉᩦ’’ᨲᩥ.

‘‘ᨸᨬ᩠ᩉᩴ ¶ ᨲᩴ, ᩈᨾᨱ, ᨸᩩᨧ᩠ᨨᩥᩔᩣᨾᩥ. ᩈᨧᩮ ᨾᩮ ᨶ ᨻ᩠ᨿᩣᨠᩁᩥᩔᩈᩥ, ᨧᩥᨲ᩠ᨲᩴ ᩅᩣ ᨲᩮ ᨡᩥᨸᩥᩔᩣᨾᩥ, ᩉᨴᨿᩴ ᩅᩣ ᨲᩮ ᨹᩣᩃᩮᩔᩣᨾᩥ, ᨸᩣᨴᩮᩈᩩ ᩅᩣ ᨣᩉᩮᨲ᩠ᩅᩣ ᨸᩣᩁᨣᨦ᩠ᨣᩣᨿ ᨡᩥᨸᩥᩔᩣᨾᩦ’’ᨲᩥ.

‘‘ᨶ ᨡ᩠ᩅᩣᩉᩴ ᨲᩴ, ᩌᩅᩩᩈᩮᩣ, ᨸᩔᩣᨾᩥ ᩈᨴᩮᩅᨠᩮ ᩃᩮᩣᨠᩮ ᩈᨾᩣᩁᨠᩮ ᩈᨻᩕᩉ᩠ᨾᨠᩮ ᩈᩔᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩥᨿᩣ ᨸᨩᩣᨿ ᩈᨴᩮᩅᨾᨶᩩᩔᩣᨿ ᨿᩮᩣ ᨾᩮ ᨧᩥᨲ᩠ᨲᩴ ᩅᩣ ᨡᩥᨸᩮᨿ᩠ᨿ ᩉᨴᨿᩴ ᩅᩣ ᨹᩣᩃᩮᨿ᩠ᨿ ᨸᩣᨴᩮᩈᩩ ᩅᩣ ᨣᩉᩮᨲ᩠ᩅᩣ ᨸᩣᩁᨣᨦ᩠ᨣᩣᨿ ᨡᩥᨸᩮᨿ᩠ᨿ. ᩋᨸᩥ ᨧ ᨲ᩠ᩅᩴ, ᩌᩅᩩᩈᩮᩣ, ᨸᩩᨧ᩠ᨨ ᨿᨴᩣᨠᨦ᩠ᨡᩈᩦ’’ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩌᩊᩅᨠᩮᩣ ᨿᨠ᩠ᨡᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨠᩥᩴ ᩈᩪᨵ ᩅᩥᨲ᩠ᨲᩴ ᨸᩩᩁᩥᩈᩔ ᩈᩮᨭ᩠ᨮᩴ, ᨠᩥᩴ ᩈᩩ ᩈᩩᨧᩥᨱ᩠ᨱᩴ ᩈᩩᨡᨾᩣᩅᩉᩣᨲᩥ;

ᨠᩥᩴ ᩈᩩ [ᨠᩥᩴ ᩈᩪ (ᩈᩦ.)] ᩉᩅᩮ ᩈᩣᨴᩩᨲᩁᩴ ᩁᩈᩣᨶᩴ, ᨠᨳᩴ ᨩᩦᩅᩥᩴ ᨩᩦᩅᩥᨲᨾᩣᩉᩩ ᩈᩮᨭ᩠ᨮᩴ’’.

‘‘ᩈᨴ᩠ᨵᩦᨵ ᩅᩥᨲ᩠ᨲᩴ ᨸᩩᩁᩥᩈᩔ ᩈᩮᨭ᩠ᨮᩴ, ᨵᨾ᩠ᨾᩮᩣ ᩈᩩᨧᩥᨱ᩠ᨱᩮᩣ ᩈᩩᨡᨾᩣᩅᩉᩣᨲᩥ;

ᩈᨧ᩠ᨧᩴ ᩉᩅᩮ ᩈᩣᨴᩩᨲᩁᩴ ᩁᩈᩣᨶᩴ, ᨸᨬ᩠ᨬᩣᨩᩦᩅᩥᩴ ᨩᩦᩅᩥᨲᨾᩣᩉᩩ ᩈᩮᨭ᩠ᨮᩴ’’.

‘‘ᨠᨳᩴ ᩈᩩ ᨲᩁᨲᩥ ᩒᨥᩴ, ᨠᨳᩴ ᩈᩩ ᨲᩁᨲᩥ ᩋᨱ᩠ᨱᩅᩴ;

ᨠᨳᩴ ¶ ᩈᩩ ᨴᩩᨠ᩠ᨡᨾᨧ᩠ᨧᩮᨲᩥ, ᨠᨳᩴ ᩈᩩ ᨸᩁᩥᩈᩩᨩ᩠ᨫᨲᩥ’’.

‘‘ᩈᨴ᩠ᨵᩣ ¶ ᨲᩁᨲᩥ ᩒᨥᩴ, ᩋᨸ᩠ᨸᨾᩣᨴᩮᨶ ᩋᨱ᩠ᨱᩅᩴ;

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

‘‘ᨠᨳᩴ ¶ ᩈᩩ ᩃᨽᨲᩮ ᨸᨬ᩠ᨬᩴ, ᨠᨳᩴ ᩈᩩ ᩅᩥᨶ᩠ᨴᨲᩮ ᨵᨶᩴ;

ᨠᨳᩴ ᩈᩩ ᨠᩥᨲ᩠ᨲᩥᩴ ᨸᨸ᩠ᨸᩮᩣᨲᩥ, ᨠᨳᩴ ᨾᩥᨲ᩠ᨲᩣᨶᩥ ᨣᨶ᩠ᨳᨲᩥ;

ᩋᩈ᩠ᨾᩣ ᩃᩮᩣᨠᩣ ᨸᩁᩴ ᩃᩮᩣᨠᩴ, ᨠᨳᩴ ᨸᩮᨧ᩠ᨧ ᨶ ᩈᩮᩣᨧᨲᩥ’’.

‘‘ᩈᨴ᩠ᨴᩉᩣᨶᩮᩣ ᩋᩁᩉᨲᩴ, ᨵᨾ᩠ᨾᩴ ᨶᩥᨻ᩠ᨻᩣᨶᨸᨲ᩠ᨲᩥᨿᩣ;

ᩈᩩᩔᩪᩈᩴ [ᩈᩩᩔᩪᩈᩣ (ᩈᩦ. ᨸᩦ.)] ᩃᨽᨲᩮ ᨸᨬ᩠ᨬᩴ, ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ ᩅᩥᨧᨠ᩠ᨡᨱᩮᩣ.

‘‘ᨸᨲᩥᩁᩪᨸᨠᩣᩁᩦ ᨵᩩᩁᩅᩣ, ᩏᨭ᩠ᨮᩣᨲᩣ ᩅᩥᨶ᩠ᨴᨲᩮ ᨵᨶᩴ;

ᩈᨧ᩠ᨧᩮᨶ ᨠᩥᨲ᩠ᨲᩥᩴ ᨸᨸ᩠ᨸᩮᩣᨲᩥ, ᨴᨴᩴ ᨾᩥᨲ᩠ᨲᩣᨶᩥ ᨣᨶ᩠ᨳᨲᩥ.

‘‘ᨿᩔᩮᨲᩮ ¶ ᨧᨲᩩᩁᩮᩣ ᨵᨾ᩠ᨾᩣ, ᩈᨴ᩠ᨵᩔ ᨥᩁᨾᩮᩈᩥᨶᩮᩣ;

ᩈᨧ᩠ᨧᩴ ᨵᨾ᩠ᨾᩮᩣ [ᨴᨾᩮᩣ (?)] ᨵᩥᨲᩥ ᨧᩣᨣᩮᩣ, ᩈ ᩅᩮ ᨸᩮᨧ᩠ᨧ ᨶ ᩈᩮᩣᨧᨲᩥ.

‘‘ᩍᨦ᩠ᨥ ᩋᨬ᩠ᨬᩮᨸᩥ ᨸᩩᨧ᩠ᨨᩔᩩ, ᨸᩩᨳᩪ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩮ;

ᨿᨴᩥ ᩈᨧ᩠ᨧᩣ ᨴᨾᩣ ᨧᩣᨣᩣ, ᨡᨶ᩠ᨲ᩠ᨿᩣ ᨽᩥᨿ᩠ᨿᩮᩣᨵ ᩅᩥᨩ᩠ᨩᨲᩥ’’.

‘‘ᨠᨳᩴ ᨶᩩ ᨴᩣᨶᩥ ᨸᩩᨧ᩠ᨨᩮᨿ᩠ᨿᩴ, ᨸᩩᨳᩪ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩮ;

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

‘‘ᩋᨲ᩠ᨳᩣᨿ ᩅᨲ ᨾᩮ ᨻᩩᨴ᩠ᨵᩮᩣ, ᩅᩣᩈᩣᨿᩣᩊᩅᩥᨾᩣᨣᨾᩣ;

ᨿᩮᩣᩉᩴ [ᩋᨭ᩠ᨮᩥᨶ᩠ᩉᩣᩁᩪᩉᩥ ᩈᩴᨿᩩᨲ᩠ᨲᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩋᨩ᩠ᨩ ᨸᨩᩣᨶᩣᨾᩥ, ᨿᨲ᩠ᨳ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ.

‘‘ᩈᩮᩣ ᩋᩉᩴ ᩅᩥᨧᩁᩥᩔᩣᨾᩥ, ᨣᩣᨾᩣ ᨣᩣᨾᩴ ᨸᩩᩁᩣ ᨸᩩᩁᩴ;

ᨶᨾᩔᨾᩣᨶᩮᩣ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩴ, ᨵᨾ᩠ᨾᩔ ᨧ ᩈᩩᨵᨾ᩠ᨾᨲ’’ᨶ᩠ᨲᩥ.

ᨧᩁᩴ ¶ ¶ ᩅᩣ ᨿᨴᩥ ᩅᩣ ᨲᩥᨭ᩠ᨮᩴ, ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᩏᨴ ᩅᩣ ᩈᨿᩴ;

ᩈᨾᩥᨬ᩠ᨩᩮᨲᩥ ᨸᩈᩣᩁᩮᨲᩥ, ᩑᩈᩣ ᨠᩣᨿᩔ ᩍᨬ᩠ᨩᨶᩣ.

ᩋᨭ᩠ᨮᩥᨶᩉᩣᩁᩩᩈᩴᨿᩩᨲ᩠ᨲᩮᩣ, ᨲᨧᨾᩴᩈᩣᩅᩃᩮᨸᨶᩮᩣ;

ᨨᩅᩥᨿᩣ ᨠᩣᨿᩮᩣ ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᩮᩣ, ᨿᨳᩣᨽᩪᨲᩴ ᨶ ᨴᩥᩔᨲᩥ.

ᩋᨶ᩠ᨲᨸᩪᩁᩮᩣ ¶ ᩏᨴᩁᨸᩪᩁᩮᩣ, ᨿᨠᨶᨸᩮᩊᩔ [ᨿᨠᨸᩮᩊᩔ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩅᨲ᩠ᨳᩥᨶᩮᩣ;

ᩈᩥᨦ᩠ᨥᩣᨱᩥᨠᩣᨿ ¶ ᨡᩮᩊᩔ, ᩈᩮᨴᩔ ᨧ ᨾᩮᨴᩔ ᨧ;

ᩃᩮᩣᩉᩥᨲᩔ ᩃᩈᩥᨠᩣᨿ, ᨸᩥᨲ᩠ᨲᩔ ᨧ ᩅᩈᩣᨿ ᨧ.

ᩋᨳᩔ ᨶᩅᩉᩥ ᩈᩮᩣᨲᩮᩉᩥ, ᩋᩈᩩᨧᩦ ᩈᩅᨲᩥ ᩈᨻ᩠ᨻᨴᩣ;

ᩋᨠ᩠ᨡᩥᨾ᩠ᩉᩣ ᩋᨠ᩠ᨡᩥᨣᩪᨳᨠᩮᩣ, ᨠᨱ᩠ᨱᨾ᩠ᩉᩣ ᨠᨱ᩠ᨱᨣᩪᨳᨠᩮᩣ.

ᩈᩥᨦ᩠ᨥᩣᨱᩥᨠᩣ ᨧ ᨶᩣᩈᨲᩮᩣ, ᨾᩩᨡᩮᨶ ᩅᨾᨲᩮᨠᨴᩣ;

ᨸᩥᨲ᩠ᨲᩴ ᩈᩮᨾ᩠ᩉᨬ᩠ᨧ ᩅᨾᨲᩥ, ᨠᩣᨿᨾ᩠ᩉᩣ ᩈᩮᨴᨩᩃ᩠ᩃᩥᨠᩣ.

ᩋᨳᩔ ᩈᩩᩈᩥᩁᩴ ᩈᩦᩈᩴ, ᨾᨲ᩠ᨳᩃᩩᨦ᩠ᨣᩔ ᨸᩪᩁᩥᨲᩴ;

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

ᨿᨴᩣ ᨧ ᩈᩮᩣ ᨾᨲᩮᩣ ᩈᩮᨲᩥ, ᩏᨴ᩠ᨵᩩᨾᩣᨲᩮᩣ ᩅᩥᨶᩦᩃᨠᩮᩣ;

ᩋᨸᩅᩥᨴ᩠ᨵᩮᩣ ᩈᩩᩈᩣᨶᩈ᩠ᨾᩥᩴ, ᩋᨶᨸᩮᨠ᩠ᨡᩣ ᩉᩮᩣᨶ᩠ᨲᩥ ᨬᩣᨲᨿᩮᩣ.

ᨡᩣᨴᨶ᩠ᨲᩥ ᨶᩴ ᩈᩩᩅᩣᨶᩣ [ᩈᩩᨸᩣᨱᩣ (ᨸᩦ.)] ᨧ, ᩈᩥᨦ᩠ᨣᩣᩃᩣ [ᩈᩥᨣᩣᩃᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᩅᨠᩣ ᨠᩥᨾᩦ;

ᨠᩣᨠᩣ ¶ ᨣᩥᨩ᩠ᨫᩣ ᨧ ᨡᩣᨴᨶ᩠ᨲᩥ, ᨿᩮ ᨧᨬ᩠ᨬᩮ ᩈᨶ᩠ᨲᩥ ᨸᩣᨱᩥᨶᩮᩣ.

ᩈᩩᨲ᩠ᩅᩣᨶ ¶ ᨻᩩᨴ᩠ᨵᩅᨧᨶᩴ, ᨽᩥᨠ᩠ᨡᩩ ᨸᨬ᩠ᨬᩣᨱᩅᩣ ᩍᨵ;

ᩈᩮᩣ ᨡᩮᩣ ᨶᩴ ᨸᩁᩥᨩᩣᨶᩣᨲᩥ, ᨿᨳᩣᨽᩪᨲᨬ᩠ᩉᩥ ᨸᩔᨲᩥ.

ᨿᨳᩣ ᩍᨴᩴ ᨲᨳᩣ ᩑᨲᩴ, ᨿᨳᩣ ᩑᨲᩴ ᨲᨳᩣ ᩍᨴᩴ;

ᩋᨩ᩠ᨫᨲ᩠ᨲᨬ᩠ᨧ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ, ᨠᩣᨿᩮ ᨨᨶ᩠ᨴᩴ ᩅᩥᩁᩣᨩᨿᩮ.

ᨨᨶ᩠ᨴᩁᩣᨣᩅᩥᩁᨲ᩠ᨲᩮᩣ ᩈᩮᩣ, ᨽᩥᨠ᩠ᨡᩩ ᨸᨬ᩠ᨬᩣᨱᩅᩣ ᩍᨵ;

ᩋᨩ᩠ᨫᨣᩣ ᩋᨾᨲᩴ ᩈᨶ᩠ᨲᩥᩴ, ᨶᩥᨻ᩠ᨻᩣᨶᩴ ᨸᨴᨾᨧ᩠ᨧᩩᨲᩴ.

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

ᨶᩣᨶᩣᨠᩩᨱᨸᨸᩁᩥᨸᩪᩁᩮᩣ, ᩅᩥᩔᩅᨶ᩠ᨲᩮᩣ ᨲᨲᩮᩣ ᨲᨲᩮᩣ.

ᩑᨲᩣᨴᩥᩈᩮᨶ ¶ ᨠᩣᨿᩮᨶ, ᨿᩮᩣ ᨾᨬ᩠ᨬᩮ ᩏᨱ᩠ᨱᨾᩮᨲᩅᩮ [ᩏᨶ᩠ᨶᨾᩮᨲᩅᩮ (?)];

ᨸᩁᩴ ᩅᩣ ᩋᩅᨩᩣᨶᩮᨿ᩠ᨿ, ᨠᩥᨾᨬ᩠ᨬᨲᩕ ᩋᨴᩔᨶᩣᨲᩥ.

ᩈᨶ᩠ᨳᩅᩣᨲᩮᩣ ¶ [ᩈᨶ᩠ᨵᩅᨲᩮᩣ (ᨠ.)] ᨽᨿᩴ ᨩᩣᨲᩴ, ᨶᩥᨠᩮᨲᩣ ᨩᩣᨿᨲᩮ ᩁᨩᩮᩣ;

ᩋᨶᩥᨠᩮᨲᨾᩈᨶ᩠ᨳᩅᩴ, ᩑᨲᩴ ᩅᩮ ᨾᩩᨶᩥᨴᩔᨶᩴ.

ᨿᩮᩣ ᨩᩣᨲᨾᩩᨧ᩠ᨨᩥᨩ᩠ᨩ ᨶ ᩁᩮᩣᨸᨿᩮᨿ᩠ᨿ, ᨩᩣᨿᨶ᩠ᨲᨾᩔ ᨶᩣᨶᩩᨸ᩠ᨸᩅᩮᨧ᩠ᨨᩮ;

ᨲᨾᩣᩉᩩ ᩑᨠᩴ ᨾᩩᨶᩥᨶᩴ ᨧᩁᨶ᩠ᨲᩴ, ᩋᨴ᩠ᨴᨠ᩠ᨡᩥ ¶ ᩈᩮᩣ ᩈᨶ᩠ᨲᩥᨸᨴᩴ ᨾᩉᩮᩈᩥ.

ᩈᨦ᩠ᨡᩣᨿ ¶ ᩅᨲ᩠ᨳᩪᨶᩥ ᨸᨾᩣᨿ [ᨸᩉᩣᨿ (ᨠ. ᩈᩦ. ᨠ.), ᩈᨾᩣᨿ (ᨠ.) ᨸ + ᨾᩦ + ᨲ᩠ᩅᩣ = ᨸᨾᩣᨿ, ᨿᨳᩣ ᨶᩥᩔᩣᨿᩣᨲᩥᨸᨴᩴ] ᨻᩦᨩᩴ, ᩈᩥᨶᩮᩉᨾᩔ ᨶᩣᨶᩩᨸ᩠ᨸᩅᩮᨧ᩠ᨨᩮ;

ᩈ ᩅᩮ ᨾᩩᨶᩦ ᨩᩣᨲᩥᨡᨿᨶ᩠ᨲᨴᩔᩦ, ᨲᨠ᩠ᨠᩴ ᨸᩉᩣᨿ ᨶ ᩏᨸᩮᨲᩥ ᩈᨦ᩠ᨡᩴ.

ᩋᨬ᩠ᨬᩣᨿ ᩈᨻ᩠ᨻᩣᨶᩥ ᨶᩥᩅᩮᩈᨶᩣᨶᩥ, ᩋᨶᩥᨠᩣᨾᨿᩴ ᩋᨬ᩠ᨬᨲᩁᨾ᩠ᨸᩥ ᨲᩮᩈᩴ;

ᩈ ᩅᩮ ᨾᩩᨶᩦ ᩅᩦᨲᨣᩮᨵᩮᩣ ᩋᨣᩥᨴ᩠ᨵᩮᩣ, ᨶᩣᨿᩪᩉᨲᩦ ᨸᩣᩁᨣᨲᩮᩣ ᩉᩥ ᩉᩮᩣᨲᩥ.

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

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

ᨸᨬ᩠ᨬᩣᨻᩃᩴ ᩈᩦᩃᩅᨲᩪᨸᨸᨶ᩠ᨶᩴ, ᩈᨾᩣᩉᩥᨲᩴ ᨫᩣᨶᩁᨲᩴ ᩈᨲᩦᨾᩴ;

ᩈᨦ᩠ᨣᩣ ᨸᨾᩩᨲ᩠ᨲᩴ ᩋᨡᩥᩃᩴ ᩋᨶᩣᩈᩅᩴ, ᨲᩴ ᩅᩣᨸᩥ ᨵᩦᩁᩣ ᨾᩩᨶᩥ ᩅᩮᨴᨿᨶ᩠ᨲᩥ.

ᩑᨠᩴ ¶ ᨧᩁᨶ᩠ᨲᩴ ᨾᩩᨶᩥᨾᨸ᩠ᨸᨾᨲ᩠ᨲᩴ, ᨶᩥᨶ᩠ᨴᩣᨸᩈᩴᩈᩣᩈᩩ ᩋᩅᩮᨵᨾᩣᨶᩴ;

ᩈᩦᩉᩴᩅ ᩈᨴ᩠ᨴᩮᩈᩩ ᩋᩈᨶ᩠ᨲᩈᨶ᩠ᨲᩴ, ᩅᩣᨲᩴᩅ ¶ ᨩᩣᩃᨾ᩠ᩉᩥ ᩋᩈᨩ᩠ᨩᨾᩣᨶᩴ;

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

ᨿᩮᩣ ¶ ᩒᨣᩉᨱᩮ ᨳᨾ᩠ᨽᩮᩣᩁᩥᩅᩣᨽᩥᨩᩣᨿᨲᩥ, ᨿᩈ᩠ᨾᩥᩴ ᨸᩁᩮ ᩅᩣᨧᩣᨸᩁᩥᨿᨶ᩠ᨲᩴ [ᩅᩣᨧᩴ ᨸᩁᩥᨿᨶ᩠ᨲᩴ (ᨠ.)] ᩅᨴᨶ᩠ᨲᩥ;

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

ᨿᩮᩣ ᩅᩮ ᨮᩥᨲᨲ᩠ᨲᩮᩣ ᨲᩈᩁᩴᩅ ᩏᨩ᩠ᨩᩩ, ᨩᩥᨣᩩᨧ᩠ᨨᨲᩥ ᨠᨾ᩠ᨾᩮᩉᩥ ᨸᩣᨸᨠᩮᩉᩥ;

ᩅᩦᨾᩴᩈᨾᩣᨶᩮᩣ ᩅᩥᩈᨾᩴ ᩈᨾᨬ᩠ᨧ, ᨲᩴ ᩅᩣᨸᩥ ᨵᩦᩁᩣ ᨾᩩᨶᩥ ᩅᩮᨴᨿᨶ᩠ᨲᩥ.

ᨿᩮᩣ ᩈᨬ᩠ᨬᨲᨲ᩠ᨲᩮᩣ ᨶ ᨠᩁᩮᩣᨲᩥ ᨸᩣᨸᩴ, ᨴᩉᩁᩮᩣ ᨾᨩ᩠ᨫᩥᨾᩮᩣ ᨧ ᨾᩩᨶᩥ [ᨴᩉᩁᩮᩣ ᨧ ᨾᨩ᩠ᨫᩮᩣ ᨧ ᨾᩩᨶᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᨿᨲᨲ᩠ᨲᩮᩣ;

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

ᨿᨴᨣ᩠ᨣᨲᩮᩣ ᨾᨩ᩠ᨫᨲᩮᩣ ᩈᩮᩈᨲᩮᩣ ᩅᩣ, ᨸᩥᨱ᩠ᨯᩴ ᩃᨽᩮᨳ ᨸᩁᨴᨲ᩠ᨲᩪᨸᨩᩦᩅᩦ;

ᨶᩣᩃᩴ ᨳᩩᨲᩩᩴ ᨶᩮᩣᨸᩥ ᨶᩥᨸᨧ᩠ᨧᩅᩣᨴᩦ, ᨲᩴ ᩅᩣᨸᩥ ᨵᩦᩁᩣ ᨾᩩᨶᩥ ᩅᩮᨴᨿᨶ᩠ᨲᩥ.

ᨾᩩᨶᩥᩴ ¶ ᨧᩁᨶ᩠ᨲᩴ ᩅᩥᩁᨲᩴ ᨾᩮᨳᩩᨶᩈ᩠ᨾᩣ, ᨿᩮᩣ ᨿᩮᩣᨻ᩠ᨻᨶᩮ ᨶᩮᩣᨸᨶᩥᨻᨩ᩠ᨫᨲᩮ ᨠ᩠ᩅᨧᩥ;

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

ᩋᨬ᩠ᨬᩣᨿ ¶ ᩃᩮᩣᨠᩴ ᨸᩁᨾᨲ᩠ᨳᨴᩔᩥᩴ, ᩒᨥᩴ ᩈᨾᩩᨴ᩠ᨴᩴ ᩋᨲᩥᨲᩁᩥᨿ ᨲᩣᨴᩥᩴ;

ᨲᩴ ¶ ᨨᩥᨶ᩠ᨶᨣᨶ᩠ᨳᩴ ᩋᩈᩥᨲᩴ ᩋᨶᩣᩈᩅᩴ, ᨲᩴ ᩅᩣᨸᩥ ᨵᩦᩁᩣ ᨾᩩᨶᩥ ᩅᩮᨴᨿᨶ᩠ᨲᩥ.

ᩋᩈᨾᩣ ᩏᨽᩮᩣ ᨴᩪᩁᩅᩥᩉᩣᩁᩅᩩᨲ᩠ᨲᩥᨶᩮᩣ, ᨣᩥᩉᩦ [ᨣᩥᩉᩥ (ᨠ.)] ᨴᩣᩁᨸᩮᩣᩈᩦ ᩋᨾᨾᩮᩣ ᨧ ᩈᩩᨻ᩠ᨻᨲᩮᩣ;

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

ᩈᩥᨡᩦ ᨿᨳᩣ ᨶᩦᩃᨣᩦᩅᩮᩣ [ᨶᩦᩃᨣᩥᩅᩮᩣ (ᩈ᩠ᨿᩣ.)] ᩅᩥᩉᨦ᩠ᨣᨾᩮᩣ, ᩉᩴᩈᩔ ᨶᩮᩣᨸᩮᨲᩥ ᨩᩅᩴ ᨠᩩᨴᩣᨧᨶᩴ;

ᩑᩅᩴ ᨣᩥᩉᩦ ᨶᩣᨶᩩᨠᩁᩮᩣᨲᩥ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ, ᨾᩩᨶᩥᨶᩮᩣ ᩅᩥᩅᩥᨲ᩠ᨲᩔ ᩅᨶᨾ᩠ᩉᩥ ᨫᩣᨿᨲᩮᩣᨲᩥ.

ᨾᩩᨶᩥᩈᩩᨲ᩠ᨲᩴ ᨴ᩠ᩅᩣᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩏᩁᨣᩮᩣ ᨵᨶᩥᨿᩮᩣ ᨧᩮᩅ, ᩅᩥᩈᩣᨱᨬ᩠ᨧ ᨲᨳᩣ ᨠᩈᩥ;

ᨧᩩᨶ᩠ᨴᩮᩣ ᨸᩁᩣᨽᩅᩮᩣ ¶ ᨧᩮᩅ, ᩅᩈᩃᩮᩣ ᨾᩮᨲ᩠ᨲᨽᩣᩅᨶᩣ.

ᩈᩣᨲᩣᨣᩥᩁᩮᩣ ᩌᩊᩅᨠᩮᩣ, ᩅᩥᨩᨿᩮᩣ ᨧ ᨲᨳᩣ ᨾᩩᨶᩥ;

ᨴ᩠ᩅᩣᨴᩈᩮᨲᩣᨶᩥ ᩈᩩᨲ᩠ᨲᩣᨶᩥ, ᩏᩁᨣᩅᨣ᩠ᨣᩮᩣᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩦᨲᩥ.

ᨿᩣᨶᩦᨵ ¶ ¶ ¶ ᨽᩪᨲᩣᨶᩥ ᩈᨾᩣᨣᨲᩣᨶᩥ, ᨽᩩᨾ᩠ᨾᩣᨶᩥ [ᨽᩪᨾᩣᨶᩥ (ᨠ.)] ᩅᩣ ᨿᩣᨶᩥ ᩅ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ;

ᩈᨻ᩠ᨻᩮᩅ ᨽᩪᨲᩣ ᩈᩩᨾᨶᩣ ᨽᩅᨶ᩠ᨲᩩ, ᩋᨳᩮᩣᨸᩥ ᩈᨠ᩠ᨠᨧ᩠ᨧ ᩈᩩᨱᨶ᩠ᨲᩩ ᨽᩣᩈᩥᨲᩴ.

ᨲᩈ᩠ᨾᩣ ᩉᩥ ᨽᩪᨲᩣ ᨶᩥᩈᩣᨾᩮᨳ ᩈᨻ᩠ᨻᩮ, ᨾᩮᨲ᩠ᨲᩴ ᨠᩁᩮᩣᨳ ᨾᩣᨶᩩᩈᩥᨿᩣ ᨸᨩᩣᨿ;

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

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

ᨶ ᨶᩮᩣ ᩈᨾᩴ ᩋᨲ᩠ᨳᩥ ᨲᨳᩣᨣᨲᩮᨶ, ᩍᨴᨾ᩠ᨸᩥ ᨻᩩᨴ᩠ᨵᩮ ᩁᨲᨶᩴ ᨸᨱᩦᨲᩴ;

ᨡᨿᩴ ᩅᩥᩁᩣᨣᩴ ᩋᨾᨲᩴ ᨸᨱᩦᨲᩴ, ᨿᨴᨩ᩠ᨫᨣᩣ ¶ ᩈᨠ᩠ᨿᨾᩩᨶᩦ ᩈᨾᩣᩉᩥᨲᩮᩣ;

ᨶ ᨲᩮᨶ ᨵᨾ᩠ᨾᩮᨶ ᩈᨾᨲ᩠ᨳᩥ ᨠᩥᨬ᩠ᨧᩥ, ᩍᨴᨾ᩠ᨸᩥ ᨵᨾ᩠ᨾᩮ ᩁᨲᨶᩴ ᨸᨱᩦᨲᩴ;

ᨿᩴ ᨻᩩᨴ᩠ᨵᩈᩮᨭ᩠ᨮᩮᩣ ᨸᩁᩥᩅᨱ᩠ᨱᨿᩦ ᩈᩩᨧᩥᩴ, ᩈᨾᩣᨵᩥᨾᩣᨶᨶ᩠ᨲᩁᩥᨠᨬ᩠ᨬᨾᩣᩉᩩ;

ᩈᨾᩣᨵᩥᨶᩣ ¶ ᨲᩮᨶ ᩈᨾᩮᩣ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ, ᩍᨴᨾ᩠ᨸᩥ ᨵᨾ᩠ᨾᩮ ᩁᨲᨶᩴ ᨸᨱᩦᨲᩴ;

ᨿᩮ ¶ ᨸᩩᨣ᩠ᨣᩃᩣ ᩋᨭ᩠ᨮ ᩈᨲᩴ ᨸᩈᨲ᩠ᨳᩣ, ᨧᨲ᩠ᨲᩣᩁᩥ ᩑᨲᩣᨶᩥ ᨿᩩᨣᩣᨶᩥ ᩉᩮᩣᨶ᩠ᨲᩥ;

ᨲᩮ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩣ ᩈᩩᨣᨲᩔ ᩈᩣᩅᨠᩣ, ᩑᨲᩮᩈᩩ ᨴᩥᨶ᩠ᨶᩣᨶᩥ ᨾᩉᨸ᩠ᨹᩃᩣᨶᩥ;

ᩍᨴᨾ᩠ᨸᩥ ᩈᨦ᩠ᨥᩮ ᩁᨲᨶᩴ ᨸᨱᩦᨲᩴ, ᩑᨲᩮᨶ ¶ ᩈᨧ᩠ᨧᩮᨶ ᩈᩩᩅᨲ᩠ᨳᩥ ᩉᩮᩣᨲᩩ.

ᨿᩮ ¶ ᩈᩩᨸ᩠ᨸᨿᩩᨲ᩠ᨲᩣ ᨾᨶᩈᩣ ᨴᩊ᩠ᩉᩮᨶ, ᨶᩥᨠ᩠ᨠᩣᨾᩥᨶᩮᩣ ᨣᩮᩣᨲᨾᩈᩣᩈᨶᨾ᩠ᩉᩥ;

ᨲᩮ ᨸᨲ᩠ᨲᩥᨸᨲ᩠ᨲᩣ ᩋᨾᨲᩴ ᩅᩥᨣᨿ᩠ᩉ, ᩃᨴ᩠ᨵᩣ ᨾᩩᨵᩣ ᨶᩥᨻ᩠ᨻᩩᨲᩥᩴ [ᨶᩥᨻ᩠ᨻᩩᨲᩥ (ᨠ.)] ᨽᩩᨬ᩠ᨩᨾᩣᨶᩣ;

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

ᨿᨳᩥᨶ᩠ᨴᨡᩦᩃᩮᩣ ᨸᨳᩅᩥᩔᩥᨲᩮᩣ [ᨸᨴᩅᩥᩔᩥᨲᩮᩣ (ᨠ. ᩈᩦ.), ᨸᨮᩅᩥᩴ ᩈᩥᨲᩮᩣ (ᨠ. ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᩈᩥᨿᩣ, ᨧᨲᩩᨻ᩠ᨽᩥ ᩅᩣᨲᩮᩉᩥ ᩋᩈᨾ᩠ᨸᨠᨾ᩠ᨸᩥᨿᩮᩣ;

ᨲᨳᩪᨸᨾᩴ ᩈᨸ᩠ᨸᩩᩁᩥᩈᩴ ᩅᨴᩣᨾᩥ, ᨿᩮᩣ ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶᩥ ᩋᩅᩮᨧ᩠ᨧ ᨸᩔᨲᩥ;

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

ᨿᩮ ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶᩥ ᩅᩥᨽᩣᩅᨿᨶ᩠ᨲᩥ, ᨣᨾ᩠ᨽᩦᩁᨸᨬ᩠ᨬᩮᨶ ᩈᩩᨴᩮᩈᩥᨲᩣᨶᩥ;

ᨠᩥᨬ᩠ᨧᩣᨸᩥ ᨲᩮ ᩉᩮᩣᨶ᩠ᨲᩥ ᨽᩩᩈᩴ ᨸᨾᨲ᩠ᨲᩣ, ᨶ ᨲᩮ ᨽᩅᩴ ᩋᨭ᩠ᨮᨾᨾᩣᨴᩥᨿᨶ᩠ᨲᩥ;

ᩍᨴᨾ᩠ᨸᩥ ᩈᨦ᩠ᨥᩮ ᩁᨲᨶᩴ ᨸᨱᩦᨲᩴ, ᩑᨲᩮᨶ ¶ ᩈᨧ᩠ᨧᩮᨶ ᩈᩩᩅᨲ᩠ᨳᩥ ᩉᩮᩣᨲᩩ.

ᩈᩉᩣᩅᩔ ᨴᩔᨶᩈᨾ᩠ᨸᨴᩣᨿ [ᩈᩉᩣᩅᩈᨴ᩠ᨴᩔᨶᩈᨾ᩠ᨸᨴᩣᨿ (ᨠ.)], ᨲᨿᩔᩩ ᨵᨾ᩠ᨾᩣ ᨩᩉᩥᨲᩣ ᨽᩅᨶ᩠ᨲᩥ;

ᩈᨠ᩠ᨠᩣᨿᨴᩥᨭ᩠ᨮᩥ ¶ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᩥᨲᨬ᩠ᨧ, ᩈᩦᩃᨻ᩠ᨻᨲᩴ ᩅᩣᨸᩥ ᨿᨴᨲ᩠ᨳᩥ ᨠᩥᨬ᩠ᨧᩥ.

ᨧᨲᩪᩉᨸᩣᨿᩮᩉᩥ ¶ ᨧ ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩮᩣ, ᨨᨧ᩠ᨧᩣᨽᩥᨮᩣᨶᩣᨶᩥ [ᨨ ᨧᩣᨽᩥᨮᩣᨶᩣᨶᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨽᨻ᩠ᨻ ᨠᩣᨲᩩᩴ [ᩋᨽᨻ᩠ᨻᩮᩣ ᨠᩣᨲᩩᩴ (ᩈᩦ.)];

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

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

ᩋᨽᨻ᩠ᨻ [ᩋᨽᨻ᩠ᨻᩮᩣ (ᨻᩉᩪᩈᩩ)] ᩈᩮᩣ ᨲᩔ ᨸᨭᩥᨧ᩠ᨨᨴᩣᨿ [ᨸᨭᩥᨧ᩠ᨨᩣᨴᩣᨿ (ᩈᩦ.)], ᩋᨽᨻ᩠ᨻᨲᩣ ᨴᩥᨭ᩠ᨮᨸᨴᩔ ᩅᩩᨲ᩠ᨲᩣ;

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

ᩅᨶᨸ᩠ᨸᨣᩩᨾ᩠ᨻᩮ ᨿᨳ [ᨿᨳᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨹᩩᩔᩥᨲᨣ᩠ᨣᩮ, ᨣᩥᨾ᩠ᩉᩣᨶᨾᩣᩈᩮ ᨸᨮᨾᩈ᩠ᨾᩥᩴ [ᨸᨮᨾᩈ᩠ᨾᩥ (?)] ᨣᩥᨾ᩠ᩉᩮ;

ᨲᨳᩪᨸᨾᩴ ᨵᨾ᩠ᨾᩅᩁᩴ ᩋᨴᩮᩈᨿᩥ [ᩋᨴᩮᩈᨿᩦ (ᩈᩦ.)], ᨶᩥᨻ᩠ᨻᩣᨶᨣᩣᨾᩥᩴ ᨸᩁᨾᩴ ᩉᩥᨲᩣᨿ;

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

ᩅᩁᩮᩣ ᩅᩁᨬ᩠ᨬᩪ ᩅᩁᨴᩮᩣ ᩅᩁᩣᩉᩁᩮᩣ, ᩋᨶᩩᨲ᩠ᨲᩁᩮᩣ ᨵᨾ᩠ᨾᩅᩁᩴ ᩋᨴᩮᩈᨿᩥ;

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

ᨡᩦᨱᩴ ¶ ᨸᩩᩁᩣᨱᩴ ᨶᩅ ᨶᨲ᩠ᨳᩥ ᩈᨾ᩠ᨽᩅᩴ, ᩅᩥᩁᨲ᩠ᨲᨧᩥᨲ᩠ᨲᩣᨿᨲᩥᨠᩮ ᨽᩅᩈ᩠ᨾᩥᩴ;

ᨲᩮ ᨡᩦᨱᨻᩦᨩᩣ ᩋᩅᩥᩁᩪᩊ᩠ᩉᩥᨨᨶ᩠ᨴᩣ, ᨶᩥᨻ᩠ᨻᨶ᩠ᨲᩥ ¶ ¶ ᨵᩦᩁᩣ ᨿᨳᩣᨿᩴ [ᨿᨳᨿᩴ (ᨠ.)] ᨸᨴᩦᨸᩮᩣ;

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

ᨿᩣᨶᩦᨵ ¶ ᨽᩪᨲᩣᨶᩥ ᩈᨾᩣᨣᨲᩣᨶᩥ, ᨽᩩᨾ᩠ᨾᩣᨶᩥ ᩅᩣ ᨿᩣᨶᩥ ᩅ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ;

ᨲᨳᩣᨣᨲᩴ ᨴᩮᩅᨾᨶᩩᩔᨸᩪᨩᩥᨲᩴ, ᨻᩩᨴ᩠ᨵᩴ ᨶᨾᩔᩣᨾ ᩈᩩᩅᨲ᩠ᨳᩥ ᩉᩮᩣᨲᩩ.

ᨿᩣᨶᩦᨵ ᨽᩪᨲᩣᨶᩥ ᩈᨾᩣᨣᨲᩣᨶᩥ, ᨽᩩᨾ᩠ᨾᩣᨶᩥ ᩅᩣ ᨿᩣᨶᩥ ᩅ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ;

ᨲᨳᩣᨣᨲᩴ ᨴᩮᩅᨾᨶᩩᩔᨸᩪᨩᩥᨲᩴ, ᨵᨾ᩠ᨾᩴ ᨶᨾᩔᩣᨾ ᩈᩩᩅᨲ᩠ᨳᩥ ᩉᩮᩣᨲᩩ.

ᨿᩣᨶᩦᨵ ᨽᩪᨲᩣᨶᩥ ᩈᨾᩣᨣᨲᩣᨶᩥ, ᨽᩩᨾ᩠ᨾᩣᨶᩥ ᩅᩣ ᨿᩣᨶᩥ ᩅ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ;

ᨲᨳᩣᨣᨲᩴ ᨴᩮᩅᨾᨶᩩᩔᨸᩪᨩᩥᨲᩴ, ᩈᨦ᩠ᨥᩴ ᨶᨾᩔᩣᨾ ᩈᩩᩅᨲ᩠ᨳᩥ ᩉᩮᩣᨲᩪᨲᩥ.

‘‘ᩈᩣᨾᩣᨠᨧᩥᨦ᩠ᨣᩪᩃᨠᨧᩦᨶᨠᩣᨶᩥ ¶ ᨧ, ᨸᨲ᩠ᨲᨸ᩠ᨹᩃᩴ ᨾᩪᩃᨹᩃᩴ ᨣᩅᩥᨸ᩠ᨹᩃᩴ;

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

‘‘ᨿᨴᩈ᩠ᨶᨾᩣᨶᩮᩣ ᩈᩩᨠᨲᩴ ᩈᩩᨶᩥᨭ᩠ᨮᩥᨲᩴ, ᨸᩁᩮᩉᩥ ᨴᩥᨶ᩠ᨶᩴ ᨸᨿᨲᩴ ᨸᨱᩦᨲᩴ;

ᩈᩣᩃᩦᨶᨾᨶ᩠ᨶᩴ ¶ ᨸᩁᩥᨽᩩᨬ᩠ᨩᨾᩣᨶᩮᩣ, ᩈᩮᩣ ᨽᩩᨬ᩠ᨩᩈᩦ ᨠᩔᨸ ᩌᨾᨣᨶ᩠ᨵᩴ.

‘‘ᨶ ¶ ᩌᨾᨣᨶ᩠ᨵᩮᩣ ᨾᨾ ᨠᨸ᩠ᨸᨲᩦᨲᩥ, ᩍᨧ᩠ᨧᩮᩅ ᨲ᩠ᩅᩴ ᨽᩣᩈᩈᩥ ᨻᩕᩉ᩠ᨾᨻᨶ᩠ᨵᩩ;

ᩈᩣᩃᩦᨶᨾᨶ᩠ᨶᩴ ᨸᩁᩥᨽᩩᨬ᩠ᨩᨾᩣᨶᩮᩣ, ᩈᨠᩩᨶ᩠ᨲᨾᩴᩈᩮᩉᩥ ᩈᩩᩈᨦ᩠ᨡᨲᩮᩉᩥ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨠᩔᨸ ᩑᨲᨾᨲ᩠ᨳᩴ, ᨠᨳᩴ ᨸᨠᩣᩁᩮᩣ ᨲᩅ ᩌᨾᨣᨶ᩠ᨵᩮᩣ’’.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩮᩣ ¶ ᩅᨵᨨᩮᨴᨻᨶ᩠ᨵᨶᩴ, ᨳᩮᨿ᩠ᨿᩴ ᨾᩩᩈᩣᩅᩣᨴᩮᩣ ᨶᩥᨠᨲᩥᩅᨬ᩠ᨧᨶᩣᨶᩥ ᨧ;

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

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

ᨶᨲ᩠ᨳᩥᨠᨴᩥᨭ᩠ᨮᩦ ᩅᩥᩈᨾᩣ ᨴᩩᩁᨶ᩠ᨶᨿᩣ, ᩑᩈᩣᨾᨣᨶ᩠ᨵᩮᩣ ᨶ ᩉᩥ ᨾᩴᩈᨽᩮᩣᨩᨶᩴ.

‘‘ᨿᩮ ᩃᩪᨡᩈᩣ ᨴᩣᩁᩩᨱᩣ ᨸᩥᨭ᩠ᨮᩥᨾᩴᩈᩥᨠᩣ [ᨿᩮ ᩃᩪᨡᩁᩈᩣ ᨴᩣᩁᩩᨱᩣ ᨸᩁᨸᩥᨭ᩠ᨮᩥᨾᩴᩈᩥᨠᩣ (ᨠ.)], ᨾᩥᨲ᩠ᨲᨴ᩠ᨴᩩᨶᩮᩣ ᨶᩥᨠ᩠ᨠᩁᩩᨱᩣᨲᩥᨾᩣᨶᩥᨶᩮᩣ;

ᩋᨴᩣᨶᩈᩦᩃᩣ ᨶ ᨧ ᨴᩮᨶ᩠ᨲᩥ ᨠᩔᨧᩥ, ᩑᩈᩣᨾᨣᨶ᩠ᨵᩮᩣ ᨶ ᩉᩥ ᨾᩴᩈᨽᩮᩣᨩᨶᩴ.

‘‘ᨠᩮᩣᨵᩮᩣ ¶ ᨾᨴᩮᩣ ᨳᨾ᩠ᨽᩮᩣ ᨸᨧ᩠ᨧᩩᨸᨭ᩠ᨮᩣᨸᨶᩣ [ᨸᨧ᩠ᨧᩩᨭ᩠ᨮᩣᨸᨶᩣ ᨧ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨸᨧ᩠ᨧᩩᨭ᩠ᨮᩣᨸᨶᩣ (ᨸᩦ.)], ᨾᩣᨿᩣ ᩏᩈᩪᨿᩣ ᨽᩔᩈᨾᩩᩔᨿᩮᩣ ᨧ;

ᨾᩣᨶᩣᨲᩥᨾᩣᨶᩮᩣ ᨧ ᩋᩈᨻ᩠ᨽᩥ ᩈᨶ᩠ᨳᩅᩮᩣ, ᩑᩈᩣᨾᨣᨶ᩠ᨵᩮᩣ ᨶ ᩉᩥ ᨾᩴᩈᨽᩮᩣᨩᨶᩴ.

‘‘ᨿᩮ ᨸᩣᨸᩈᩦᩃᩣ ᩍᨱᨥᩣᨲᩈᩪᨧᨠᩣ, ᩅᩮᩣᩉᩣᩁᨠᩪᨭᩣ ᩍᨵ ᨸᩣᨭᩥᩁᩪᨸᩥᨠᩣ [ᨸᩣᨲᩥᩁᩪᨸᩥᨠᩣ (?)];

ᨶᩁᩣᨵᨾᩣ ᨿᩮᨵ ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᨠᩥᨻ᩠ᨻᩥᩈᩴ, ᩑᩈᩣᨾᨣᨶ᩠ᨵᩮᩣ ᨶ ᩉᩥ ᨾᩴᩈᨽᩮᩣᨩᨶᩴ.

‘‘ᨿᩮ ¶ ᩍᨵ ᨸᩣᨱᩮᩈᩩ ᩋᩈᨬ᩠ᨬᨲᩣ ᨩᨶᩣ, ᨸᩁᩮᩈᨾᩣᨴᩣᨿ ᩅᩥᩉᩮᩈᨾᩩᨿ᩠ᨿᩩᨲᩣ;

ᨴᩩᩔᩦᩃᩃᩩᨴ᩠ᨴᩣ ᨹᩁᩩᩈᩣ ᩋᨶᩣᨴᩁᩣ, ᩑᩈᩣᨾᨣᨶ᩠ᨵᩮᩣ ¶ ᨶ ᩉᩥ ᨾᩴᩈᨽᩮᩣᨩᨶᩴ.

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

ᨸᨲᨶ᩠ᨲᩥ ᩈᨲ᩠ᨲᩣ ᨶᩥᩁᨿᩴ ᩋᩅᩴᩈᩥᩁᩣ, ᩑᩈᩣᨾᨣᨶ᩠ᨵᩮᩣ ᨶ ᩉᩥ ᨾᩴᩈᨽᩮᩣᨩᨶᩴ.

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

ᨡᩁᩣᨩᩥᨶᩣᨶᩥ ᨶᩣᨣ᩠ᨣᩥᩉᩩᨲ᩠ᨲᩔᩩᨸᩈᩮᩅᨶᩣ, ᨿᩮ ᩅᩣᨸᩥ ᩃᩮᩣᨠᩮ ᩋᨾᩁᩣ ᨻᩉᩪ ᨲᨸᩣ;

ᨾᨶ᩠ᨲᩣᩉᩩᨲᩦ ᨿᨬ᩠ᨬᨾᩩᨲᩪᨸᩈᩮᩅᨶᩣ, ᩈᩮᩣᨵᩮᨶ᩠ᨲᩥ ᨾᨧ᩠ᨧᩴ ᩋᩅᩥᨲᩥᨱ᩠ᨱᨠᨦ᩠ᨡᩴ.

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

ᩈᨦ᩠ᨣᩣᨲᩥᨣᩮᩣ ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᨸ᩠ᨸᩉᩦᨶᩮᩣ, ᨶ ᩃᩥᨸ᩠ᨸᨲᩥ [ᨶ ᩃᩥᨾ᩠ᨸᨲᩥ (ᩈ᩠ᨿᩣ. ᨠᩴ ᨠ.)] ᨴᩥᨭ᩠ᨮᩈᩩᨲᩮᩈᩩ ᨵᩦᩁᩮᩣ’’.

ᩍᨧ᩠ᨧᩮᨲᨾᨲ᩠ᨳᩴ ᨽᨣᩅᩣ ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ, ᩋᨠ᩠ᨡᩣᩈᩥ ᨶᩴ [ᨲᩴ (ᩈᩦ. ᨸᩦ.)] ᩅᩮᨴᨿᩥ ᨾᨶ᩠ᨲᨸᩣᩁᨣᩪ;

ᨧᩥᨲᩕᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᨾᩩᨶᩦ ᨸᨠᩣᩈᨿᩥ, ᨶᩥᩁᩣᨾᨣᨶ᩠ᨵᩮᩣ ᩋᩈᩥᨲᩮᩣ ᨴᩩᩁᨶ᩠ᨶᨿᩮᩣ.

ᩈᩩᨲ᩠ᩅᩣᨶ ¶ ᨻᩩᨴ᩠ᨵᩔ ᩈᩩᨽᩣᩈᩥᨲᩴ ᨸᨴᩴ, ᨶᩥᩁᩣᨾᨣᨶ᩠ᨵᩴ ¶ ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᨸ᩠ᨸᨶᩪᨴᨶᩴ;

ᨶᩦᨧᨾᨶᩮᩣ ᩅᨶ᩠ᨴᩥ ᨲᨳᩣᨣᨲᩔ, ᨲᨲ᩠ᨳᩮᩅ ᨸᨻ᩠ᨻᨩ᩠ᨩᨾᩁᩮᩣᨧᨿᩥᨲ᩠ᨳᩣᨲᩥ.

ᩌᨾᨣᨶ᩠ᨵᩈᩩᨲ᩠ᨲᩴ ᨴᩩᨲᩥᨿᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩉᩥᩁᩥᩴ ¶ ᨲᩁᨶ᩠ᨲᩴ ᩅᩥᨩᩥᨣᩩᨧ᩠ᨨᨾᩣᨶᩴ, ᨲᩅᩣᩉᨾᩈ᩠ᨾᩥ [ᩈᨡᩣᩉᨾᩈ᩠ᨾᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᩍᨲᩥ ᨽᩣᩈᨾᩣᨶᩴ;

ᩈᨿ᩠ᩉᩣᨶᩥ ᨠᨾ᩠ᨾᩣᨶᩥ ᩋᨶᩣᨴᩥᨿᨶ᩠ᨲᩴ, ᨶᩮᩈᩮᩣ ᨾᨾᨶ᩠ᨲᩥ ᩍᨲᩥ ᨶᩴ ᩅᩥᨩᨬ᩠ᨬᩣ.

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

ᩋᨠᩁᩮᩣᨶ᩠ᨲᩴ ᨽᩣᩈᨾᩣᨶᩴ, ᨸᩁᩥᨩᩣᨶᨶ᩠ᨲᩥ ᨸᨱ᩠ᨯᩥᨲᩣ.

ᨶ ¶ ᩈᩮᩣ ᨾᩥᨲ᩠ᨲᩮᩣ ᨿᩮᩣ ᩈᨴᩣ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ, ᨽᩮᨴᩣᩈᨦ᩠ᨠᩦ ᩁᨶ᩠ᨵᨾᩮᩅᩣᨶᩩᨸᩔᩦ;

ᨿᩈ᩠ᨾᩥᨬ᩠ᨧ ᩈᩮᨲᩥ ᩏᩁᩈᩦᩅ ᨸᩩᨲ᩠ᨲᩮᩣ, ᩈ ᩅᩮ ᨾᩥᨲ᩠ᨲᩮᩣ ᨿᩮᩣ ᨸᩁᩮᩉᩥ ᩋᨽᩮᨩ᩠ᨩᩮᩣ.

ᨸᩣᨾᩩᨩ᩠ᨩᨠᩁᨱᩴ ᨮᩣᨶᩴ, ᨸᩈᩴᩈᩣᩅᩉᨶᩴ ᩈᩩᨡᩴ;

ᨹᩃᩣᨶᩥᩈᩴᩈᩮᩣ ᨽᩣᩅᩮᨲᩥ, ᩅᩉᨶ᩠ᨲᩮᩣ ᨸᩮᩣᩁᩥᩈᩴ ᨵᩩᩁᩴ.

ᨶᩥᨴ᩠ᨴᩁᩮᩣ ¶ ᩉᩮᩣᨲᩥ ᨶᩥᨸ᩠ᨸᩣᨸᩮᩣ, ᨵᨾ᩠ᨾᨸᩦᨲᩥᩁᩈᩴ ᨸᩥᩅᨶ᩠ᨲᩥ.

ᩑᩅᩴ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨩᩮᨲᩅᨶᩮ ᩋᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩔ ᩌᩁᩣᨾᩮ. ᩋᨳ ᨡᩮᩣ ᩋᨬ᩠ᨬᨲᩁᩣ ᨴᩮᩅᨲᩣ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩣᨿ ᩁᨲ᩠ᨲᩥᨿᩣ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩅᨱ᩠ᨱᩣ ᨠᩮᩅᩃᨠᨸ᩠ᨸᩴ ᨩᩮᨲᩅᨶᩴ ᩒᨽᩣᩈᩮᨲ᩠ᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᩋᨭ᩠ᨮᩣᩈᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨮᩥᨲᩣ ᨡᩮᩣ ᩈᩣ ᨴᩮᩅᨲᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨻᩉᩪ ᨴᩮᩅᩣ ᨾᨶᩩᩔᩣ ᨧ, ᨾᨦ᩠ᨣᩃᩣᨶᩥ ᩋᨧᩥᨶ᩠ᨲᨿᩩᩴ;

ᩌᨠᨦ᩠ᨡᨾᩣᨶᩣ ᩈᩮᩣᨲ᩠ᨳᩣᨶᩴ, ᨻᩕᩪᩉᩥ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ’’.

‘‘ᩋᩈᩮᩅᨶᩣ ¶ ᨧ ᨻᩣᩃᩣᨶᩴ, ᨸᨱ᩠ᨯᩥᨲᩣᨶᨬ᩠ᨧ ᩈᩮᩅᨶᩣ;

ᨸᩪᨩᩣ ᨧ ᨸᩪᨩᨶᩮᨿ᩠ᨿᩣᨶᩴ [ᨸᩪᨩᨶᩦᨿᩣᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)], ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨸᨲᩥᩁᩪᨸᨴᩮᩈᩅᩣᩈᩮᩣ ᨧ, ᨸᩩᨻ᩠ᨻᩮ ᨧ ᨠᨲᨸᩩᨬ᩠ᨬᨲᩣ;

ᩋᨲ᩠ᨲᩈᨾ᩠ᨾᩣᨸᨱᩥᨵᩥ [ᩋᨲ᩠ᨲᩈᨾ᩠ᨾᩣᨸᨱᩦᨵᩦ (ᨠᨲ᩠ᨳᨧᩥ)] ᨧ, ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨻᩣᩉᩩᩈᨧ᩠ᨧᨬ᩠ᨧ ¶ ᩈᩥᨸ᩠ᨸᨬ᩠ᨧ, ᩅᩥᨶᨿᩮᩣ ᨧ ᩈᩩᩈᩥᨠ᩠ᨡᩥᨲᩮᩣ;

ᩈᩩᨽᩣᩈᩥᨲᩣ ᨧ ᨿᩣ ᩅᩣᨧᩣ, ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨾᩣᨲᩣᨸᩥᨲᩩ ᩏᨸᨭ᩠ᨮᩣᨶᩴ, ᨸᩩᨲ᩠ᨲᨴᩣᩁᩔ ᩈᨦ᩠ᨣᩉᩮᩣ;

ᩋᨶᩣᨠᩩᩃᩣ ¶ ᨧ ᨠᨾ᩠ᨾᨶ᩠ᨲᩣ, ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨴᩣᨶᨬ᩠ᨧ ᨵᨾ᩠ᨾᨧᩁᩥᨿᩣ ᨧ, ᨬᩣᨲᨠᩣᨶᨬ᩠ᨧ ᩈᨦ᩠ᨣᩉᩮᩣ;

ᩋᨶᩅᨩ᩠ᨩᩣᨶᩥ ᨠᨾ᩠ᨾᩣᨶᩥ, ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᩌᩁᨲᩦ ᩅᩥᩁᨲᩦ ᨸᩣᨸᩣ, ᨾᨩ᩠ᨩᨸᩣᨶᩣ ᨧ ᩈᩴᨿᨾᩮᩣ;

ᩋᨸ᩠ᨸᨾᩣᨴᩮᩣ ᨧ ᨵᨾ᩠ᨾᩮᩈᩩ, ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨣᩣᩁᩅᩮᩣ ¶ ᨧ ᨶᩥᩅᩣᨲᩮᩣ ᨧ, ᩈᨶ᩠ᨲᩩᨭ᩠ᨮᩥ ᨧ ᨠᨲᨬ᩠ᨬᩩᨲᩣ;

ᨠᩣᩃᩮᨶ ᨵᨾ᩠ᨾᩔᩅᨶᩴ [ᨵᨾ᩠ᨾᩈᩅᨱᩴ (ᨠᨲ᩠ᨳᨧᩥ), ᨵᨾ᩠ᨾᩈᩅᨶᩴ (ᩈᩦ. ᨠ.)], ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨡᨶ᩠ᨲᩦ ᨧ ᩈᩮᩣᩅᨧᩔᨲᩣ, ᩈᨾᨱᩣᨶᨬ᩠ᨧ ᨴᩔᨶᩴ;

ᨠᩣᩃᩮᨶ ᨵᨾ᩠ᨾᩈᩣᨠᨧ᩠ᨨᩣ, ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

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

ᨶᩥᨻ᩠ᨻᩣᨶᩈᨧ᩠ᨨᩥᨠᩥᩁᩥᨿᩣ ᨧ, ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨹᩩᨭ᩠ᨮᩔ ᩃᩮᩣᨠᨵᨾ᩠ᨾᩮᩉᩥ, ᨧᩥᨲ᩠ᨲᩴ ᨿᩔ ᨶ ᨠᨾ᩠ᨸᨲᩥ;

ᩋᩈᩮᩣᨠᩴ ᩅᩥᩁᨩᩴ ᨡᩮᨾᩴ, ᩑᨲᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᩑᨲᩣᨴᩥᩈᩣᨶᩥ ᨠᨲ᩠ᩅᩣᨶ, ᩈᨻ᩠ᨻᨲ᩠ᨳᨾᨸᩁᩣᨩᩥᨲᩣ;

ᩈᨻ᩠ᨻᨲ᩠ᨳ ᩈᩮᩣᨲ᩠ᨳᩥᩴ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨲᩴ ᨲᩮᩈᩴ ᨾᨦ᩠ᨣᩃᨾᩩᨲ᩠ᨲᨾ’’ᨶ᩠ᨲᩥ.

ᨾᨦ᩠ᨣᩃᩈᩩᨲ᩠ᨲᩴ ᨧᨲᩩᨲ᩠ᨳᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩑᩅᩴ ¶ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᨣᨿᩣᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨭᨦ᩠ᨠᩥᨲᨾᨬ᩠ᨧᩮ ᩈᩪᨧᩥᩃᩮᩣᨾᩔ ᨿᨠ᩠ᨡᩔ ᨽᩅᨶᩮ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ¶ ᨡᩁᩮᩣ ᨧ ᨿᨠ᩠ᨡᩮᩣ ᩈᩪᨧᩥᩃᩮᩣᨾᩮᩣ ᨧ ᨿᨠ᩠ᨡᩮᩣ ᨽᨣᩅᨲᩮᩣ ᩋᩅᩥᨴᩪᩁᩮ ᩋᨲᩥᨠ᩠ᨠᨾᨶ᩠ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᨡᩁᩮᩣ ᨿᨠ᩠ᨡᩮᩣ ᩈᩪᨧᩥᩃᩮᩣᨾᩴ ᨿᨠ᩠ᨡᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩑᩈᩮᩣ ᩈᨾᨱᩮᩣ’’ᨲᩥ. ‘‘ᨶᩮᩈᩮᩣ ᩈᨾᨱᩮᩣ, ᩈᨾᨱᨠᩮᩣ ᩑᩈᩮᩣ. ᨿᩣᩅᩣᩉᩴ ᨩᩣᨶᩣᨾᩥ [ᨿᩣᩅ ᨩᩣᨶᩣᨾᩥ (ᩈᩦ. ᨸᩦ.)] ᨿᨴᩥ ᩅᩣ ᩈᩮᩣ ᩈᨾᨱᩮᩣ [ᨿᨴᩥ ᩅᩣ ᩈᨾᨱᩮᩣ (ᩈ᩠ᨿᩣ.)], ᨿᨴᩥ ᩅᩣ ᩈᩮᩣ ᩈᨾᨱᨠᩮᩣ’’ᨲᩥ [ᨿᨴᩥ ᩅᩣ ᩈᨾᨱᨠᩮᩣᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)].

ᩋᨳ ᨡᩮᩣ ᩈᩪᨧᩥᩃᩮᩣᨾᩮᩣ ᨿᨠ᩠ᨡᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩮᩣ ᨠᩣᨿᩴ ᩏᨸᨶᩣᨾᩮᩈᩥ. ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨠᩣᨿᩴ ᩋᨸᨶᩣᨾᩮᩈᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩪᨧᩥᩃᩮᩣᨾᩮᩣ ᨿᨠ᩠ᨡᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ ¶ – ‘‘ᨽᩣᨿᩈᩥ ᨾᩴ, ᩈᨾᨱᩣ’’ᨲᩥ? ‘‘ᨶ ᨡ᩠ᩅᩣᩉᩴ ᨲᩴ, ᩌᩅᩩᩈᩮᩣ, ᨽᩣᨿᩣᨾᩥ; ᩋᨸᩥ ᨧ ᨲᩮ ᩈᨸ᩠ᨹᩔᩮᩣ ᨸᩣᨸᨠᩮᩣ’’ᨲᩥ.

‘‘ᨸᨬ᩠ᩉᩴ ᨲᩴ, ᩈᨾᨱ, ᨸᩩᨧ᩠ᨨᩥᩔᩣᨾᩥ. ᩈᨧᩮ ᨾᩮ ᨶ ᨻ᩠ᨿᩣᨠᩁᩥᩔᩈᩥ, ᨧᩥᨲ᩠ᨲᩴ ᩅᩣ ᨲᩮ ᨡᩥᨸᩥᩔᩣᨾᩥ, ᩉᨴᨿᩴ ᩅᩣ ᨲᩮ ᨹᩣᩃᩮᩔᩣᨾᩥ, ᨸᩣᨴᩮᩈᩩ ᩅᩣ ᨣᩉᩮᨲ᩠ᩅᩣ ᨸᩣᩁᨣᨦ᩠ᨣᩣᨿ ᨡᩥᨸᩥᩔᩣᨾᩦ’’ᨲᩥ.

‘‘ᨶ ᨡ᩠ᩅᩣᩉᩴ ᨲᩴ, ᩌᩅᩩᩈᩮᩣ, ᨸᩔᩣᨾᩥ ᩈᨴᩮᩅᨠᩮ ᩃᩮᩣᨠᩮ ᩈᨾᩣᩁᨠᩮ ᩈᨻᩕᩉ᩠ᨾᨠᩮ ᩈᩔᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩥᨿᩣ ᨸᨩᩣᨿ ᩈᨴᩮᩅᨾᨶᩩᩔᩣᨿ ᨿᩮᩣ ᨾᩮ ᨧᩥᨲ᩠ᨲᩴ ᩅᩣ ᨡᩥᨸᩮᨿ᩠ᨿ ᩉᨴᨿᩴ ᩅᩣ ᨹᩣᩃᩮᨿ᩠ᨿ ᨸᩣᨴᩮᩈᩩ ᩅᩣ ᨣᩉᩮᨲ᩠ᩅᩣ ᨸᩣᩁᨣᨦ᩠ᨣᩣᨿ ᨡᩥᨸᩮᨿ᩠ᨿ. ᩋᨸᩥ ᨧ ᨲ᩠ᩅᩴ, ᩌᩅᩩᩈᩮᩣ, ᨸᩩᨧ᩠ᨨ ᨿᨴᩣᨠᨦ᩠ᨡᩈᩦ’’ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩪᨧᩥᩃᩮᩣᨾᩮᩣ ᨿᨠ᩠ᨡᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᩁᩣᨣᩮᩣ ᨧ ᨴᩮᩣᩈᩮᩣ ᨧ ᨠᩩᨲᩮᩣᨶᩥᨴᩣᨶᩣ, ᩋᩁᨲᩦ ¶ ᩁᨲᩦ ᩃᩮᩣᨾᩉᩴᩈᩮᩣ ᨠᩩᨲᩮᩣᨩᩣ;

ᨠᩩᨲᩮᩣ ᩈᨾᩩᨭ᩠ᨮᩣᨿ ᨾᨶᩮᩣᩅᩥᨲᨠ᩠ᨠᩣ, ᨠᩩᨾᩣᩁᨠᩣ ᨵᨦ᩠ᨠᨾᩥᩅᩮᩣᩔᨩᨶ᩠ᨲᩥ’’.

‘‘ᩁᩣᨣᩮᩣ ᨧ ᨴᩮᩣᩈᩮᩣ ᨧ ᩍᨲᩮᩣᨶᩥᨴᩣᨶᩣ, ᩋᩁᨲᩦ ᩁᨲᩦ ᩃᩮᩣᨾᩉᩴᩈᩮᩣ ᩍᨲᩮᩣᨩᩣ;

ᩍᨲᩮᩣ ᩈᨾᩩᨭ᩠ᨮᩣᨿ ᨾᨶᩮᩣᩅᩥᨲᨠ᩠ᨠᩣ, ᨠᩩᨾᩣᩁᨠᩣ ᨵᨦ᩠ᨠᨾᩥᩅᩮᩣᩔᨩᨶ᩠ᨲᩥ.

‘‘ᩈ᩠ᨶᩮᩉᨩᩣ ¶ ¶ ᩋᨲ᩠ᨲᩈᨾ᩠ᨽᩪᨲᩣ, ᨶᩥᨣᩕᩮᩣᨵᩔᩮᩅ ᨡᨶ᩠ᨵᨩᩣ;

ᨸᩩᨳᩪ ᩅᩥᩈᨲ᩠ᨲᩣ ᨠᩣᨾᩮᩈᩩ, ᨾᩣᩃᩩᩅᩣᩅ ᩅᩥᨲᨲᩣᩅᨶᩮ.

‘‘ᨿᩮ ᨶᩴ ᨸᨩᩣᨶᨶ᩠ᨲᩥ ᨿᨲᩮᩣᨶᩥᨴᩣᨶᩴ, ᨲᩮ ᨶᩴ ᩅᩥᨶᩮᩣᨴᩮᨶ᩠ᨲᩥ ᩈᩩᨱᩮᩣᩉᩥ ᨿᨠ᩠ᨡ;

ᨲᩮ ᨴᩩᨲ᩠ᨲᩁᩴ ᩒᨥᨾᩥᨾᩴ ᨲᩁᨶ᩠ᨲᩥ, ᩋᨲᩥᨱ᩠ᨱᨸᩩᨻ᩠ᨻᩴ ᩋᨸᩩᨶᨻ᩠ᨽᩅᩣᨿᩣ’’ᨲᩥ.

ᩈᩪᨧᩥᩃᩮᩣᨾᩈᩩᨲ᩠ᨲᩴ ᨸᨬ᩠ᨧᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨵᨾ᩠ᨾᨧᩁᩥᨿᩴ ¶ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᩑᨲᨴᩣᩉᩩ ᩅᩈᩩᨲ᩠ᨲᨾᩴ;

ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣᨸᩥ ᨧᩮ ᩉᩮᩣᨲᩥ, ᩋᨣᩣᩁᩣ ᩋᨶᨣᩣᩁᩥᨿᩴ.

ᩈᩮᩣ ᨧᩮ ᨾᩩᨡᩁᨩᩣᨲᩥᨠᩮᩣ, ᩅᩥᩉᩮᩈᩣᨽᩥᩁᨲᩮᩣ ᨾᨣᩮᩣ;

ᨩᩦᩅᩥᨲᩴ ¶ ᨲᩔ ᨸᩣᨸᩥᨿᩮᩣ, ᩁᨩᩴ ᩅᨯ᩠ᨰᩮᨲᩥ ᩋᨲ᩠ᨲᨶᩮᩣ.

ᨠᩃᩉᩣᨽᩥᩁᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ, ᨾᩮᩣᩉᨵᨾ᩠ᨾᩮᨶ ᩌᩅᩩᨲᩮᩣ;

ᩋᨠ᩠ᨡᩣᨲᨾ᩠ᨸᩥ ᨶ ᨩᩣᨶᩣᨲᩥ, ᨵᨾ᩠ᨾᩴ ᨻᩩᨴ᩠ᨵᩮᨶ ᨴᩮᩈᩥᨲᩴ.

ᩅᩥᩉᩮᩈᩴ ᨽᩣᩅᩥᨲᨲ᩠ᨲᩣᨶᩴ, ᩋᩅᩥᨩ᩠ᨩᩣᨿ ᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ;

ᩈᩴᨠᩥᩃᩮᩈᩴ ᨶ ᨩᩣᨶᩣᨲᩥ, ᨾᨣ᩠ᨣᩴ ᨶᩥᩁᨿᨣᩣᨾᩥᨶᩴ.

ᩅᩥᨶᩥᨸᩣᨲᩴ ᩈᨾᩣᨸᨶ᩠ᨶᩮᩣ, ᨣᨻ᩠ᨽᩣ ᨣᨻ᩠ᨽᩴ ᨲᨾᩣ ᨲᨾᩴ;

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

ᨣᩪᨳᨠᩪᨸᩮᩣ ᨿᨳᩣ ᩋᩔ, ᩈᨾ᩠ᨸᩩᨱ᩠ᨱᩮᩣ ᨣᨱᩅᩔᩥᨠᩮᩣ;

ᨿᩮᩣ ᨧ ᩑᩅᩁᩪᨸᩮᩣ ᩋᩔ, ᨴᩩᨻ᩠ᨻᩥᩈᩮᩣᨵᩮᩣ ᩉᩥ ᩈᩣᨦ᩠ᨣᨱᩮᩣ.

ᨿᩴ ᩑᩅᩁᩪᨸᩴ ᨩᩣᨶᩣᨳ, ᨽᩥᨠ᩠ᨡᩅᩮᩣ ᨣᩮᩉᨶᩥᩔᩥᨲᩴ;

ᨸᩣᨸᩥᨧ᩠ᨨᩴ ᨸᩣᨸᩈᨦ᩠ᨠᨸ᩠ᨸᩴ, ᨸᩣᨸᩌᨧᩣᩁᨣᩮᩣᨧᩁᩴ.

ᩈᨻ᩠ᨻᩮ ¶ ¶ ᩈᨾᨣ᩠ᨣᩣ ᩉᩩᨲ᩠ᩅᩣᨶ, ᩋᨽᩥᨶᩥᨻ᩠ᨻᨩ᩠ᨩᩥᨿᩣᨳ [ᩋᨽᩥᨶᩥᨻ᩠ᨻᨩ᩠ᨩᨿᩣᨳ (ᩈᩦ. ᨸᩦ. ᩋ. ᨶᩥ. ᪘.᪑᪐)] ᨶᩴ;

ᨠᩣᩁᨱ᩠ᨯᩅᩴ [ᨠᩣᩁᨱ᩠ᨯᩴ ᩅ (ᩈ᩠ᨿᩣ. ᨠ.) ᩋ. ᨶᩥ. ᪘.᪑᪐] ᨶᩥᨴ᩠ᨵᨾᨳ, ᨠᩈᨾ᩠ᨻᩩᩴ ᩋᨸᨠᩔᨳ [ᩋᩅᨠᩔᨳ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)].

ᨲᨲᩮᩣ ᨸᩃᩣᨸᩮ [ᨸᩃᩣᩈᩮ (ᨠ.)] ᩅᩣᩉᩮᨳ, ᩋᩔᨾᨱᩮ ᩈᨾᨱᨾᩣᨶᩥᨶᩮ;

ᨶᩥᨴ᩠ᨵᨾᩥᨲ᩠ᩅᩣᨶ ᨸᩣᨸᩥᨧ᩠ᨨᩮ, ᨸᩣᨸᩌᨧᩣᩁᨣᩮᩣᨧᩁᩮ.

ᩈᩩᨴ᩠ᨵᩣ ¶ ᩈᩩᨴ᩠ᨵᩮᩉᩥ ᩈᩴᩅᩣᩈᩴ, ᨠᨸ᩠ᨸᨿᩅ᩠ᩉᩮᩣ ᨸᨲᩥᩔᨲᩣ;

ᨲᨲᩮᩣ ᩈᨾᨣ᩠ᨣᩣ ᨶᩥᨸᨠᩣ, ᨴᩩᨠ᩠ᨡᩔᨶ᩠ᨲᩴ ᨠᩁᩥᩔᨳᩣᨲᩥ.

ᨵᨾ᩠ᨾᨧᩁᩥᨿᩈᩩᨲ᩠ᨲᩴ [ᨠᨸᩥᩃᩈᩩᨲ᩠ᨲᩴ (ᩋᨭ᩠ᨮ.)] ᨨᨭ᩠ᨮᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩑᩅᩴ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨩᩮᨲᩅᨶᩮ ᩋᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩔ ᩌᩁᩣᨾᩮ. ᩋᨳ ᨡᩮᩣ ᩈᨾ᩠ᨻᩉᩩᩃᩣ ᨠᩮᩣᩈᩃᨠᩣ ᨻᩕᩣᩉ᩠ᨾᨱᨾᩉᩣᩈᩣᩃᩣ ᨩᩥᨱ᩠ᨱᩣ ᩅᩩᨯ᩠ᨰᩣ ᨾᩉᩃ᩠ᩃᨠᩣ ᩋᨴ᩠ᨵᨣᨲᩣ ᩅᨿᩮᩣᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥᩴᩈᩩ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩣ ᩈᨴ᩠ᨵᩥᩴ ᩈᨾ᩠ᨾᩮᩣᨴᩥᩴᩈᩩ. ᩈᨾ᩠ᨾᩮᩣᨴᨶᩦᨿᩴ ᨠᨳᩴ ᩈᩣᩁᨱᩦᨿᩴ ᩅᩦᨲᩥᩈᩣᩁᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥᩴᩈᩩ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩣ ᨡᩮᩣ ᨲᩮ ᨻᩕᩣᩉ᩠ᨾᨱᨾᩉᩣᩈᩣᩃᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧᩩᩴ – ‘‘ᩈᨶ᩠ᨴᩥᩔᨶ᩠ᨲᩥ ᨶᩩ ᨡᩮᩣ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᩑᨲᩁᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨸᩮᩣᩁᩣᨱᩣᨶᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᨻᩕᩣᩉ᩠ᨾᨱᨵᨾ᩠ᨾᩮ’’ᨲᩥ? ‘‘ᨶ ᨡᩮᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩣ, ᩈᨶ᩠ᨴᩥᩔᨶ᩠ᨲᩥ ᩑᨲᩁᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨸᩮᩣᩁᩣᨱᩣᨶᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᨻᩕᩣᩉ᩠ᨾᨱᨵᨾ᩠ᨾᩮ’’ᨲᩥ. ‘‘ᩈᩣᨵᩩ ᨶᩮᩣ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᨸᩮᩣᩁᩣᨱᩣᨶᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᨻᩕᩣᩉ᩠ᨾᨱᨵᨾ᩠ᨾᩴ ᨽᩣᩈᨲᩩ, ᩈᨧᩮ ᨽᩮᩣᨲᩮᩣ ᨣᩮᩣᨲᨾᩔ ᩋᨣᩁᩪ’’ᨲᩥ. ‘‘ᨲᩮᨶ ᩉᩥ, ᨻᩕᩣᩉ᩠ᨾᨱᩣ, ᩈᩩᨱᩣᨳ, ᩈᩣᨵᩩᨠᩴ ᨾᨶᩈᩥ ᨠᩁᩮᩣᨳ, ᨽᩣᩈᩥᩔᩣᨾᩦ’’ᨲᩥ. ‘‘ᩑᩅᩴ, ᨽᩮᩣ’’ᨲᩥ ᨡᩮᩣ ᨲᩮ ᨻᩕᩣᩉ᩠ᨾᨱᨾᩉᩣᩈᩣᩃᩣ ᨽᨣᩅᨲᩮᩣ ᨸᨧ᩠ᨧᩔᩮᩣᩈᩩᩴ. ᨽᨣᩅᩣ ᩑᨲᨴᩅᩮᩣᨧ –

‘‘ᩍᩈᨿᩮᩣ ᨸᩩᨻ᩠ᨻᨠᩣ ᩌᩈᩩᩴ, ᩈᨬ᩠ᨬᨲᨲ᩠ᨲᩣ ᨲᨸᩔᩥᨶᩮᩣ;

ᨸᨬ᩠ᨧ ᨠᩣᨾᨣᩩᨱᩮ ᩉᩥᨲ᩠ᩅᩣ, ᩋᨲ᩠ᨲᨴᨲ᩠ᨳᨾᨧᩣᩁᩥᩈᩩᩴ.

‘‘ᨶ ¶ ᨸᩈᩪ ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩣᩈᩩᩴ, ᨶ ᩉᩥᩁᨬ᩠ᨬᩴ ᨶ ᨵᩣᨶᩥᨿᩴ;

ᩈᨩ᩠ᨫᩣᨿᨵᨶᨵᨬ᩠ᨬᩣᩈᩩᩴ, ᨻᩕᩉ᩠ᨾᩴ ᨶᩥᨵᩥᨾᨸᩣᩃᨿᩩᩴ.

‘‘ᨿᩴ ¶ ¶ ᨶᩮᩈᩴ ᨸᨠᨲᩴ ᩌᩈᩥ, ᨴ᩠ᩅᩣᩁᨽᨲ᩠ᨲᩴ ᩏᨸᨭ᩠ᨮᩥᨲᩴ;

ᩈᨴ᩠ᨵᩣᨸᨠᨲᨾᩮᩈᩣᨶᩴ, ᨴᩣᨲᩅᩮ ᨲᨴᨾᨬ᩠ᨬᩥᩈᩩᩴ.

‘‘ᨶᩣᨶᩣᩁᨲ᩠ᨲᩮᩉᩥ ¶ ᩅᨲ᩠ᨳᩮᩉᩥ, ᩈᨿᨶᩮᩉᩣᩅᩈᨳᩮᩉᩥ ᨧ;

ᨹᩦᨲᩣ ᨩᨶᨸᨴᩣ ᩁᨭ᩠ᨮᩣ, ᨲᩮ ᨶᨾᩔᩥᩴᩈᩩ ᨻᩕᩣᩉ᩠ᨾᨱᩮ.

‘‘ᩋᩅᨩ᩠ᨫᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩌᩈᩩᩴ, ᩋᨩᩮᨿ᩠ᨿᩣ ᨵᨾ᩠ᨾᩁᨠ᩠ᨡᩥᨲᩣ;

ᨶ ᨶᩮ ᨠᩮᩣᨧᩥ ᨶᩥᩅᩣᩁᩮᩈᩥ, ᨠᩩᩃᨴ᩠ᩅᩣᩁᩮᩈᩩ ᩈᨻ᩠ᨻᩈᩮᩣ.

‘‘ᩋᨭ᩠ᨮᨧᨲ᩠ᨲᩣᩃᩦᩈᩴ ᩅᩔᩣᨶᩥ, (ᨠᩮᩣᨾᩣᩁ) ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ ᨧᩁᩥᩴᩈᩩ ᨲᩮ;

ᩅᩥᨩ᩠ᨩᩣᨧᩁᨱᨸᩁᩥᨿᩮᨭ᩠ᨮᩥᩴ, ᩋᨧᩁᩩᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨸᩩᩁᩮ.

‘‘ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩋᨬ᩠ᨬᨾᨣᨾᩩᩴ, ᨶᨸᩥ ᨽᩁᩥᨿᩴ ᨠᩥᨱᩥᩴᩈᩩ ᨲᩮ;

ᩈᨾ᩠ᨸᩥᨿᩮᨶᩮᩅ ᩈᩴᩅᩣᩈᩴ, ᩈᨦ᩠ᨣᨶ᩠ᨲ᩠ᩅᩣ ᩈᨾᩁᩮᩣᨧᨿᩩᩴ.

‘‘ᩋᨬ᩠ᨬᨲᩕ ᨲᨾ᩠ᩉᩣ ᩈᨾᨿᩣ, ᩏᨲᩩᩅᩮᩁᨾᨱᩥᩴ ᨸᨲᩥ;

ᩋᨶ᩠ᨲᩁᩣ ᨾᩮᨳᩩᨶᩴ ᨵᨾ᩠ᨾᩴ, ᨶᩣᩔᩩ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩣ.

‘‘ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᨬ᩠ᨧ ᩈᩦᩃᨬ᩠ᨧ, ᩋᨩ᩠ᨩᩅᩴ ᨾᨴ᩠ᨴᩅᩴ ᨲᨸᩴ;

ᩈᩮᩣᩁᨧ᩠ᨧᩴ ᩋᩅᩥᩉᩥᩴᩈᨬ᩠ᨧ, ᨡᨶ᩠ᨲᩥᨬ᩠ᨧᩣᨸᩥ ᩋᩅᨱ᩠ᨱᨿᩩᩴ.

‘‘ᨿᩮᩣ ¶ ᨶᩮᩈᩴ ᨸᩁᨾᩮᩣ ᩌᩈᩥ, ᨻᩕᩉ᩠ᨾᩣ ᨴᩊ᩠ᩉᨸᩁᨠ᩠ᨠᨾᩮᩣ;

ᩈ ᩅᩣᨸᩥ ᨾᩮᨳᩩᨶᩴ ᨵᨾ᩠ᨾᩴ, ᩈᩩᨸᩥᨶᨶ᩠ᨲᩮᨸᩥ ᨶᩣᨣᨾᩣ.

‘‘ᨲᩔ ᩅᨲ᩠ᨲᨾᨶᩩᩈᩥᨠ᩠ᨡᨶ᩠ᨲᩣ, ᩍᨵᩮᨠᩮ ᩅᩥᨬ᩠ᨬᩩᨩᩣᨲᩥᨠᩣ;

ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᨬ᩠ᨧ ᩈᩦᩃᨬ᩠ᨧ, ᨡᨶ᩠ᨲᩥᨬ᩠ᨧᩣᨸᩥ ᩋᩅᨱ᩠ᨱᨿᩩᩴ.

‘‘ᨲᨱ᩠ᨯᩩᩃᩴ ᩈᨿᨶᩴ ᩅᨲ᩠ᨳᩴ, ᩈᨸ᩠ᨸᩥᨲᩮᩃᨬ᩠ᨧ ᨿᩣᨧᩥᨿ;

ᨵᨾ᩠ᨾᩮᨶ ᩈᨾᩮᩣᨵᩣᨶᩮᨲ᩠ᩅᩣ, ᨲᨲᩮᩣ ᨿᨬ᩠ᨬᨾᨠᨸ᩠ᨸᨿᩩᩴ.

‘‘ᩏᨸᨭ᩠ᨮᩥᨲᩈ᩠ᨾᩥᩴ ¶ ᨿᨬ᩠ᨬᩈ᩠ᨾᩥᩴ, ᨶᩣᩔᩩ ᨣᩣᩅᩮᩣ ᩉᨶᩥᩴᩈᩩ ᨲᩮ;

ᨿᨳᩣ ᨾᩣᨲᩣ ᨸᩥᨲᩣ ᨽᩣᨲᩣ, ᩋᨬ᩠ᨬᩮ ᩅᩣᨸᩥ ᨧ ᨬᩣᨲᨠᩣ;

ᨣᩣᩅᩮᩣ ᨶᩮᩣ ᨸᩁᨾᩣ ᨾᩥᨲ᩠ᨲᩣ, ᨿᩣᩈᩩ ᨩᩣᨿᨶ᩠ᨲᩥ ᩒᩈᨵᩣ.

‘‘ᩋᨶ᩠ᨶᨴᩣ ¶ ᨻᩃᨴᩣ ᨧᩮᨲᩣ, ᩅᨱ᩠ᨱᨴᩣ ᩈᩩᨡᨴᩣ ᨲᨳᩣ [ᩈᩩᨡᨴᩣ ᨧ ᨲᩣ (ᨠ.)];

ᩑᨲᨾᨲ᩠ᨳᩅᩈᩴ ᨬᨲ᩠ᩅᩣ, ᨶᩣᩔᩩ ᨣᩣᩅᩮᩣ ᩉᨶᩥᩴᩈᩩ ᨲᩮ.

‘‘ᩈᩩᨡᩩᨾᩣᩃᩣ ¶ ᨾᩉᩣᨠᩣᨿᩣ, ᩅᨱ᩠ᨱᩅᨶ᩠ᨲᩮᩣ ᨿᩈᩔᩥᨶᩮᩣ;

ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩈᩮᩉᩥ ᨵᨾ᩠ᨾᩮᩉᩥ, ᨠᩥᨧ᩠ᨧᩣᨠᩥᨧ᩠ᨧᩮᩈᩩ ᩏᩔᩩᨠᩣ;

ᨿᩣᩅ ᩃᩮᩣᨠᩮ ᩋᩅᨲ᩠ᨲᩥᩴᩈᩩ, ᩈᩩᨡᨾᩮᨵᩥᨲ᩠ᨳᨿᩴ ᨸᨩᩣ.

‘‘ᨲᩮᩈᩴ ᩌᩈᩥ ᩅᩥᨸᩃ᩠ᩃᩣᩈᩮᩣ, ᨴᩥᩈ᩠ᩅᩣᨶ ᩋᨱᩩᨲᩮᩣ ᩋᨱᩩᩴ;

ᩁᩣᨩᩥᨶᩮᩣ ᨧ ᩅᩥᨿᩣᨠᩣᩁᩴ, ᨶᩣᩁᩥᨿᩮᩣ ᩈᨾᩃᨦ᩠ᨠᨲᩣ.

‘‘ᩁᨳᩮ ᨧᩣᨩᨬ᩠ᨬᩈᩴᨿᩩᨲ᩠ᨲᩮ, ᩈᩩᨠᨲᩮ ᨧᩥᨲ᩠ᨲᩈᩥᨻ᩠ᨻᨶᩮ;

ᨶᩥᩅᩮᩈᨶᩮ ᨶᩥᩅᩮᩈᩮ ᨧ, ᩅᩥᨽᨲ᩠ᨲᩮ ᨽᩣᨣᩈᩮᩣ ᨾᩥᨲᩮ.

‘‘ᨣᩮᩣᨾᨱ᩠ᨯᩃᨸᩁᩥᨻ᩠ᨿᩪᩊ᩠ᩉᩴ, ᨶᩣᩁᩦᩅᩁᨣᨱᩣᨿᩩᨲᩴ;

ᩏᩊᩣᩁᩴ ᨾᩣᨶᩩᩈᩴ ᨽᩮᩣᨣᩴ, ᩋᨽᩥᨩ᩠ᨫᩣᨿᩥᩴᩈᩩ ᨻᩕᩣᩉ᩠ᨾᨱᩣ.

‘‘ᨲᩮ ᨲᨲ᩠ᨳ ᨾᨶ᩠ᨲᩮ ᨣᨶ᩠ᨳᩮᨲ᩠ᩅᩣ, ᩒᨠ᩠ᨠᩣᨠᩴ ᨲᨴᩩᨸᩣᨣᨾᩩᩴ;

ᨸᩉᩪᨲᨵᨶᨵᨬ᩠ᨬᩮᩣᩈᩥ ¶ , ᨿᨩᩔᩩ ᨻᩉᩩ ᨲᩮ ᩅᩥᨲ᩠ᨲᩴ;

‘‘ᨲᨲᩮᩣ ᨧ ᩁᩣᨩᩣ ᩈᨬ᩠ᨬᨲ᩠ᨲᩮᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩮᩉᩥ ᩁᨳᩮᩈᨽᩮᩣ;

ᩋᩔᨾᩮᨵᩴ ᨸᩩᩁᩥᩈᨾᩮᨵᩴ, ᩈᨾ᩠ᨾᩣᨸᩣᩈᩴ ᩅᩣᨩᨸᩮᨿ᩠ᨿᩴ ᨶᩥᩁᨣ᩠ᨣᩊᩴ;

ᩑᨲᩮ ¶ ᨿᩣᨣᩮ ᨿᨩᩥᨲ᩠ᩅᩣᨶ, ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᨾᨴᩣ ᨵᨶᩴ.

‘‘ᨣᩣᩅᩮᩣ ᩈᨿᨶᨬ᩠ᨧ ᩅᨲ᩠ᨳᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᩈᨾᩃᨦ᩠ᨠᨲᩣ;

ᩁᨳᩮ ᨧᩣᨩᨬ᩠ᨬᩈᩴᨿᩩᨲ᩠ᨲᩮ, ᩈᩩᨠᨲᩮ ᨧᩥᨲ᩠ᨲᩈᩥᨻ᩠ᨻᨶᩮ.

‘‘ᨶᩥᩅᩮᩈᨶᩣᨶᩥ ᩁᨾ᩠ᨾᩣᨶᩥ, ᩈᩩᩅᩥᨽᨲ᩠ᨲᩣᨶᩥ ᨽᩣᨣᩈᩮᩣ;

ᨶᩣᨶᩣᨵᨬ᩠ᨬᩔ ᨸᩪᩁᩮᨲ᩠ᩅᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᨾᨴᩣ ᨵᨶᩴ.

‘‘ᨲᩮ ¶ ᨧ ᨲᨲ᩠ᨳ ᨵᨶᩴ ᩃᨴ᩠ᨵᩣ, ᩈᨶ᩠ᨶᩥᨵᩥᩴ ᩈᨾᩁᩮᩣᨧᨿᩩᩴ;

ᨲᩮᩈᩴ ᩍᨧ᩠ᨨᩣᩅᨲᩥᨱ᩠ᨱᩣᨶᩴ, ᨽᩥᨿ᩠ᨿᩮᩣ ᨲᨱ᩠ᩉᩣ ᨸᩅᨯ᩠ᨰᨳ;

ᨲᩮ ᨲᨲ᩠ᨳ ᨾᨶ᩠ᨲᩮ ᨣᨶ᩠ᨳᩮᨲ᩠ᩅᩣ, ᩒᨠ᩠ᨠᩣᨠᩴ ᨸᩩᨶᨾᩩᨸᩣᨣᨾᩩᩴ.

‘‘ᨿᨳᩣ ᩌᨸᩮᩣ ᨧ ᨸᨳᩅᩦ ᨧ, ᩉᩥᩁᨬ᩠ᨬᩴ ᨵᨶᨵᩣᨶᩥᨿᩴ;

ᩑᩅᩴ ᨣᩣᩅᩮᩣ ᨾᨶᩩᩔᩣᨶᩴ, ᨸᩁᩥᨠ᩠ᨡᩣᩁᩮᩣ ᩈᩮᩣ ᩉᩥ ᨸᩣᨱᩥᨶᩴ;

ᨿᨩᩔᩩ ᨻᩉᩩ ᨲᩮ ᩅᩥᨲ᩠ᨲᩴ, ᨿᨩᩔᩩ ᨻᩉᩩ ᨲᩮ ᨵᨶᩴ.

‘‘ᨲᨲᩮᩣ ᨧ ᩁᩣᨩᩣ ᩈᨬ᩠ᨬᨲ᩠ᨲᩮᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩮᩉᩥ ᩁᨳᩮᩈᨽᩮᩣ;

ᨶᩮᨠᩣ ᩈᨲᩈᩉᩔᩥᨿᩮᩣ, ᨣᩣᩅᩮᩣ ᨿᨬ᩠ᨬᩮ ᩋᨥᩣᨲᨿᩥ.

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

ᨣᩣᩅᩮᩣ ᩑᩊᨠᩈᨾᩣᨶᩣ, ᩈᩮᩣᩁᨲᩣ ᨠᩩᨾ᩠ᨽᨴᩪᩉᨶᩣ;

ᨲᩣ ᩅᩥᩈᩣᨱᩮ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᩁᩣᨩᩣ ᩈᨲ᩠ᨳᩮᨶ ᨥᩣᨲᨿᩥ.

‘‘ᨲᨲᩮᩣ ¶ ᨴᩮᩅᩣ ᨸᩥᨲᩁᩮᩣ ᨧ [ᨲᨲᩮᩣ ᨧ ᨴᩮᩅᩣ ᨸᩥᨲᩁᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᩍᨶ᩠ᨴᩮᩣ ᩋᩈᩩᩁᩁᨠ᩠ᨡᩈᩣ;

ᩋᨵᨾ᩠ᨾᩮᩣ ᩍᨲᩥ ᨸᨠ᩠ᨠᨶ᩠ᨴᩩᩴ, ᨿᩴ ᩈᨲ᩠ᨳᩴ ᨶᩥᨸᨲᩦ ᨣᩅᩮ.

‘‘ᨲᨿᩮᩣ ᩁᩮᩣᨣᩣ ᨸᩩᩁᩮ ᩌᩈᩩᩴ, ᩍᨧ᩠ᨨᩣ ᩋᨶᩈᨶᩴ ᨩᩁᩣ;

ᨸᩈᩪᨶᨬ᩠ᨧ ᩈᨾᩣᩁᨾ᩠ᨽᩣ, ᩋᨭ᩠ᨮᩣᨶᩅᩩᨲᩥᨾᩣᨣᨾᩩᩴ.

‘‘ᩑᩈᩮᩣ ¶ ᩋᨵᨾ᩠ᨾᩮᩣ ᨴᨱ᩠ᨯᩣᨶᩴ, ᩒᨠ᩠ᨠᨶ᩠ᨲᩮᩣ ᨸᩩᩁᩣᨱᩮᩣ ᩋᩉᩩ;

ᩋᨴᩪᩈᩥᨠᩣᨿᩮᩣ ᩉᨬ᩠ᨬᨶ᩠ᨲᩥ, ᨵᨾ᩠ᨾᩣ ᨵᩴᩈᨶ᩠ᨲᩥ [ᨵᩴᩈᩮᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᨿᩣᨩᨠᩣ.

‘‘ᩑᩅᨾᩮᩈᩮᩣ ᩋᨱᩩᨵᨾ᩠ᨾᩮᩣ, ᨸᩮᩣᩁᩣᨱᩮᩣ ᩅᩥᨬ᩠ᨬᩩᨣᩁᩉᩥᨲᩮᩣ;

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

‘‘ᩑᩅᩴ ᨵᨾ᩠ᨾᩮ ᩅᩥᨿᩣᨸᨶ᩠ᨶᩮ, ᩅᩥᨽᩥᨶ᩠ᨶᩣ ᩈᩩᨴ᩠ᨴᩅᩮᩔᩥᨠᩣ;

ᨸᩩᨳᩪ ᩅᩥᨽᩥᨶ᩠ᨶᩣ ᨡᨲ᩠ᨲᩥᨿᩣ, ᨸᨲᩥᩴ ᨽᩁᩥᨿᩣᩅᨾᨬ᩠ᨬᨳ.

‘‘ᨡᨲ᩠ᨲᩥᨿᩣ ¶ ᨻᩕᩉ᩠ᨾᨻᨶ᩠ᨵᩪ ᨧ, ᨿᩮ ᨧᨬ᩠ᨬᩮ ᨣᩮᩣᨲ᩠ᨲᩁᨠ᩠ᨡᩥᨲᩣ;

ᨩᩣᨲᩥᩅᩣᨴᩴ ᨶᩥᩁᩴᨠᨲ᩠ᩅᩣ [ᨶᩥᩁᩣᨠᨲ᩠ᩅᩣ (?) ᨿᨳᩣ ᩋᨶᩥᩁᩣᨠᨲᨩ᩠ᨫᩣᨶᩮᩣᨲᩥ], ᨠᩣᨾᩣᨶᩴ ᩅᩈᨾᨶ᩠ᩅᨣᩩ’’ᨶ᩠ᨲᩥ.

ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᨲᩮ ᨻᩕᩣᩉ᩠ᨾᨱᨾᩉᩣᩈᩣᩃᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧᩩᩴ – ‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ…ᨸᩮ. ¶ … ᩏᨸᩣᩈᨠᩮ ᨶᩮᩣ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᨵᩣᩁᩮᨲᩩ ᩋᨩ᩠ᨩᨲᨣ᩠ᨣᩮ ᨸᩣᨱᩩᨸᩮᨲᩮ ᩈᩁᨱᩴ ᨣᨲᩮ’’ᨲᩥ.

ᨻᩕᩣᩉ᩠ᨾᨱᨵᨾ᩠ᨾᩥᨠᩈᩩᨲ᩠ᨲᩴ ᩈᨲ᩠ᨲᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨿᩈ᩠ᨾᩣ ¶ ᩉᩥ ᨵᨾ᩠ᨾᩴ ᨸᩩᩁᩥᩈᩮᩣ ᩅᩥᨩᨬ᩠ᨬᩣ, ᩍᨶ᩠ᨴᩴᩅ ᨶᩴ ᨴᩮᩅᨲᩣ ᨸᩪᨩᨿᩮᨿ᩠ᨿ;

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

ᨲᨴᨭ᩠ᨮᩥᨠᨲ᩠ᩅᩣᨶ ¶ ᨶᩥᩈᨾ᩠ᨾ ᨵᩦᩁᩮᩣ, ᨵᨾ᩠ᨾᩣᨶᩩᨵᨾ᩠ᨾᩴ ᨸᨭᩥᨸᨩ᩠ᨩᨾᩣᨶᩮᩣ;

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

ᨡᩩᨴ᩠ᨴᨬ᩠ᨧ ᨻᩣᩃᩴ ᩏᨸᩈᩮᩅᨾᩣᨶᩮᩣ, ᩋᨶᩣᨣᨲᨲ᩠ᨳᨬ᩠ᨧ ᩏᩈᩪᨿᨠᨬ᩠ᨧ;

ᩍᨵᩮᩅ ᨵᨾ᩠ᨾᩴ ᩋᩅᩥᨽᩣᩅᨿᩥᨲ᩠ᩅᩣ, ᩋᩅᩥᨲᩥᨱ᩠ᨱᨠᨦ᩠ᨡᩮᩣ ᨾᩁᨱᩴ ᩏᨸᩮᨲᩥ.

ᨿᨳᩣ ᨶᩁᩮᩣ ᩌᨸᨣᨾᩮᩣᨲᩁᩥᨲ᩠ᩅᩣ, ᨾᩉᩮᩣᨴᨠᩴ ᩈᩃᩥᩃᩴ ᩈᩦᨥᩈᩮᩣᨲᩴ;

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

ᨲᨳᩮᩅ ᨵᨾ᩠ᨾᩴ ᩋᩅᩥᨽᩣᩅᨿᩥᨲ᩠ᩅᩣ, ᨻᩉᩩᩔᩩᨲᩣᨶᩴ ᩋᨶᩥᩈᩣᨾᨿᨲ᩠ᨳᩴ;

ᩈᨿᩴ ᩋᨩᩣᨶᩴ ᩋᩅᩥᨲᩥᨱ᩠ᨱᨠᨦ᩠ᨡᩮᩣ, ᨠᩥᩴ ¶ ᩈᩮᩣ ᨸᩁᩮ ᩈᨠ᩠ᨡᨲᩥ ᨶᩥᨩ᩠ᨫᨸᩮᨲᩩᩴ.

ᨿᨳᩣᨸᩥ ¶ ᨶᩣᩅᩴ ᨴᩊ᩠ᩉᨾᩣᩁᩩᩉᩥᨲ᩠ᩅᩣ, ᨹᩥᨿᩮᨶ [ᨸᩥᨿᩮᨶ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩁᩥᨲ᩠ᨲᩮᨶ ᩈᨾᨦ᩠ᨣᩥᨽᩪᨲᩮᩣ;

ᩈᩮᩣ ᨲᩣᩁᨿᩮ ᨲᨲ᩠ᨳ ᨻᩉᩪᨸᩥ ᩋᨬ᩠ᨬᩮ, ᨲᨲᩕᩪᨸᨿᨬ᩠ᨬᩪ ᨠᩩᩈᩃᩮᩣ ᨾᩩᨲᩦᨾᩣ [ᨾᨲᩦᨾᩣ (ᩈ᩠ᨿᩣ. ᨠ.)].

ᩑᩅᨾ᩠ᨸᩥ ¶ ᨿᩮᩣ ᩅᩮᨴᨣᩩ ᨽᩣᩅᩥᨲᨲ᩠ᨲᩮᩣ, ᨻᩉᩩᩔᩩᨲᩮᩣ ᩉᩮᩣᨲᩥ ᩋᩅᩮᨵᨵᨾ᩠ᨾᩮᩣ;

ᩈᩮᩣ ᨡᩮᩣ ᨸᩁᩮ ᨶᩥᨩ᩠ᨫᨸᨿᩮ ᨸᨩᩣᨶᩴ, ᩈᩮᩣᨲᩣᩅᨵᩣᨶᩪᨸᨶᩥᩈᩪᨸᨸᨶ᩠ᨶᩮ.

ᨲᩈ᩠ᨾᩣ ᩉᩅᩮ ᩈᨸ᩠ᨸᩩᩁᩥᩈᩴ ᨽᨩᩮᨳ, ᨾᩮᨵᩣᩅᩥᨶᨬ᩠ᨧᩮᩅ ᨻᩉᩩᩔᩩᨲᨬ᩠ᨧ;

ᩋᨬ᩠ᨬᩣᨿ ᩋᨲ᩠ᨳᩴ ᨸᨭᩥᨸᨩ᩠ᨩᨾᩣᨶᩮᩣ, ᩅᩥᨬ᩠ᨬᩣᨲᨵᨾ᩠ᨾᩮᩣ ᩈ ᩈᩩᨡᩴ [ᩈᩮᩣ ᩈᩩᨡᩴ (ᩈᩦ.)] ᩃᨽᩮᨳᩣᨲᩥ.

‘‘ᨠᩥᩴᩈᩦᩃᩮᩣ ¶ ᨠᩥᩴᩈᨾᩣᨧᩣᩁᩮᩣ, ᨠᩣᨶᩥ ᨠᨾ᩠ᨾᩣᨶᩥ ᨻᩕᩪᩉᨿᩴ;

ᨶᩁᩮᩣ ᩈᨾ᩠ᨾᩣ ᨶᩥᩅᩥᨭ᩠ᨮᩔ, ᩏᨲ᩠ᨲᨾᨲ᩠ᨳᨬ᩠ᨧ ᨸᩣᨸᩩᨱᩮ’’.

‘‘ᩅᩩᨯ᩠ᨰᩣᨸᨧᩣᨿᩦ ᩋᨶᩩᩈᩪᨿᨠᩮᩣ ᩈᩥᨿᩣ, ᨠᩣᩃᨬ᩠ᨬᩪ ¶ [ᨠᩣᩃᨬ᩠ᨬᩩ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨧᩔ ᨣᩁᩪᨶᩴ [ᨣᩁᩪᨶᩴ (ᩈᩦ.)] ᨴᩔᨶᩣᨿ;

ᨵᨾ᩠ᨾᩥᩴ ᨠᨳᩴ ᩑᩁᨿᩥᨲᩴ ᨡᨱᨬ᩠ᨬᩪ, ᩈᩩᨱᩮᨿ᩠ᨿ ᩈᨠ᩠ᨠᨧ᩠ᨧ ᩈᩩᨽᩣᩈᩥᨲᩣᨶᩥ.

‘‘ᨠᩣᩃᩮᨶ ᨣᨧ᩠ᨨᩮ ᨣᩁᩪᨶᩴ ᩈᨠᩣᩈᩴ, ᨳᨾ᩠ᨽᩴ ᨶᩥᩁᩴᨠᨲ᩠ᩅᩣ [ᨶᩥᩁᩣᨠᨲ᩠ᩅᩣ (?) ᨶᩥ + ᩌ + ᨠᩁ + ᨲ᩠ᩅᩣ] ᨶᩥᩅᩣᨲᩅᩩᨲ᩠ᨲᩥ;

ᩋᨲ᩠ᨳᩴ ¶ ᨵᨾ᩠ᨾᩴ ᩈᩴᨿᨾᩴ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᩋᨶᩩᩔᩁᩮ ᨧᩮᩅ ᩈᨾᩣᨧᩁᩮ ᨧ.

‘‘ᨵᨾ᩠ᨾᩣᩁᩣᨾᩮᩣ ᨵᨾ᩠ᨾᩁᨲᩮᩣ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩮᩣ ᨵᨾ᩠ᨾᩅᩥᨶᩥᨧ᩠ᨨᨿᨬ᩠ᨬᩪ;

ᨶᩮᩅᩣᨧᩁᩮ ᨵᨾ᩠ᨾᩈᨶ᩠ᨴᩮᩣᩈᩅᩣᨴᩴ, ᨲᨧ᩠ᨨᩮᩉᩥ ᨶᩦᨿᩮᨳ ᩈᩩᨽᩣᩈᩥᨲᩮᩉᩥ.

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

ᩈᩣᩁᨾ᩠ᨽᩴ ᨠᨠ᩠ᨠᩈᩴ ᨠᩈᩣᩅᨬ᩠ᨧ ᨾᩩᨧ᩠ᨨᩴ [ᩈᩣᩁᨾ᩠ᨽ ᨠᨠ᩠ᨠᩔ ᨠᩈᩣᩅ ᨾᩩᨧ᩠ᨨᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩉᩥᨲ᩠ᩅᩣ ᨧᩁᩮ ᩅᩦᨲᨾᨴᩮᩣ ᨮᩥᨲᨲ᩠ᨲᩮᩣ.

‘‘ᩅᩥᨬ᩠ᨬᩣᨲᩈᩣᩁᩣᨶᩥ ᩈᩩᨽᩣᩈᩥᨲᩣᨶᩥ, ᩈᩩᨲᨬ᩠ᨧ ᩅᩥᨬ᩠ᨬᩣᨲᩈᨾᩣᨵᩥᩈᩣᩁᩴ;

ᨶ ᨲᩔ ᨸᨬ᩠ᨬᩣ ᨧ ᩈᩩᨲᨬ᩠ᨧ ᩅᨯ᩠ᨰᨲᩥ, ᨿᩮᩣ ᩈᩣᩉᩈᩮᩣ ᩉᩮᩣᨲᩥ ᨶᩁᩮᩣ ᨸᨾᨲ᩠ᨲᩮᩣ.

‘‘ᨵᨾ᩠ᨾᩮ ¶ ¶ ᨧ ᨿᩮ ᩋᩁᩥᨿᨸᩅᩮᨴᩥᨲᩮ ᩁᨲᩣ,

ᩋᨶᩩᨲ᩠ᨲᩁᩣ ¶ ᨲᩮ ᩅᨧᩈᩣ ᨾᨶᩈᩣ ᨠᨾ᩠ᨾᩩᨶᩣ ᨧ;

ᨲᩮ ᩈᨶ᩠ᨲᩥᩈᩮᩣᩁᨧ᩠ᨧᩈᨾᩣᨵᩥᩈᨱ᩠ᨮᩥᨲᩣ,

ᩏᨭ᩠ᨮᩉᨳ ᨶᩥᩈᩦᨴᨳ, ᨠᩮᩣ ᩋᨲ᩠ᨳᩮᩣ ᩈᩩᨸᩥᨲᩮᨶ ᩅᩮᩣ;

ᩌᨲᩩᩁᩣᨶᨬ᩠ᩉᩥ ᨠᩣ ᨶᩥᨴ᩠ᨴᩣ, ᩈᩃ᩠ᩃᩅᩥᨴ᩠ᨵᩣᨶ ᩁᩩᨸ᩠ᨸᨲᩴ.

ᩏᨭ᩠ᨮᩉᨳ ¶ ᨶᩥᩈᩦᨴᨳ, ᨴᩊ᩠ᩉᩴ ᩈᩥᨠ᩠ᨡᨳ ᩈᨶ᩠ᨲᩥᨿᩣ;

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

ᨿᩣᨿ ᨴᩮᩅᩣ ᨾᨶᩩᩔᩣ ᨧ, ᩈᩥᨲᩣ ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᩋᨲ᩠ᨳᩥᨠᩣ;

ᨲᩁᨳᩮᨲᩴ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩴ, ᨡᨱᩮᩣ ᩅᩮᩣ [ᨡᨱᩮᩣ ᩅᩮ (ᨸᩦ. ᨠ.)] ᨾᩣ ᩏᨸᨧ᩠ᨧᨣᩣ;

ᨡᨱᩣᨲᩦᨲᩣ ᩉᩥ ᩈᩮᩣᨧᨶ᩠ᨲᩥ, ᨶᩥᩁᨿᨾ᩠ᩉᩥ ᩈᨾᨸ᩠ᨸᩥᨲᩣ.

ᨸᨾᩣᨴᩮᩣ ᩁᨩᩮᩣ ᨸᨾᩣᨴᩮᩣ, ᨸᨾᩣᨴᩣᨶᩩᨸᨲᩥᨲᩮᩣ ᩁᨩᩮᩣ;

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

‘‘ᨠᨧ᩠ᨧᩥ ¶ ¶ ᩋᨽᩥᨱ᩠ᩉᩈᩴᩅᩣᩈᩣ, ᨶᩣᩅᨩᩣᨶᩣᩈᩥ ᨸᨱ᩠ᨯᩥᨲᩴ;

ᩏᨠ᩠ᨠᩣᨵᩣᩁᩮᩣ [ᩒᨠ᩠ᨠᩣᨵᩣᩁᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨾᨶᩩᩔᩣᨶᩴ, ᨠᨧ᩠ᨧᩥ ᩋᨸᨧᩥᨲᩮᩣ ᨲᨿᩣ’’ [ᨲᩅ (ᩈᩦ. ᩋᨭ᩠ᨮ.)].

‘‘ᨶᩣᩉᩴ ᩋᨽᩥᨱ᩠ᩉᩈᩴᩅᩣᩈᩣ, ᩋᩅᨩᩣᨶᩣᨾᩥ ᨸᨱ᩠ᨯᩥᨲᩴ;

ᩏᨠ᩠ᨠᩣᨵᩣᩁᩮᩣ ᨾᨶᩩᩔᩣᨶᩴ, ᨶᩥᨧ᩠ᨧᩴ ᩋᨸᨧᩥᨲᩮᩣ ᨾᨿᩣ’’.

‘‘ᨸᨬ᩠ᨧ ¶ ᨠᩣᨾᨣᩩᨱᩮ ᩉᩥᨲ᩠ᩅᩣ, ᨸᩥᨿᩁᩪᨸᩮ ᨾᨶᩮᩣᩁᨾᩮ;

ᩈᨴ᩠ᨵᩣᨿ ᨥᩁᩣ ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ, ᨴᩩᨠ᩠ᨡᩔᨶ᩠ᨲᨠᩁᩮᩣ ᨽᩅ.

‘‘ᨾᩥᨲ᩠ᨲᩮ ᨽᨩᩔᩩ ᨠᩃ᩠ᨿᩣᨱᩮ, ᨸᨶ᩠ᨲᨬ᩠ᨧ ᩈᨿᨶᩣᩈᨶᩴ;

ᩅᩥᩅᩥᨲ᩠ᨲᩴ ᩋᨸ᩠ᨸᨶᩥᨣ᩠ᨥᩮᩣᩈᩴ, ᨾᨲ᩠ᨲᨬ᩠ᨬᩪ ᩉᩮᩣᩉᩥ ᨽᩮᩣᨩᨶᩮ.

‘‘ᨧᩦᩅᩁᩮ ¶ ᨸᩥᨱ᩠ᨯᨸᩣᨲᩮ ᨧ, ᨸᨧ᩠ᨧᨿᩮ ᩈᨿᨶᩣᩈᨶᩮ;

ᩑᨲᩮᩈᩩ ᨲᨱ᩠ᩉᩴ ᨾᩣᨠᩣᩈᩥ, ᨾᩣ ᩃᩮᩣᨠᩴ ᨸᩩᨶᩁᩣᨣᨾᩥ.

‘‘ᩈᩴᩅᩩᨲᩮᩣ ᨸᩣᨲᩥᨾᩮᩣᨠ᩠ᨡᩈ᩠ᨾᩥᩴ, ᩍᨶ᩠ᨴᩕᩥᨿᩮᩈᩩ ᨧ ᨸᨬ᩠ᨧᩈᩩ;

ᩈᨲᩥ ᨠᩣᨿᨣᨲᩣᨲ᩠ᨿᨲ᩠ᨳᩩ, ᨶᩥᨻ᩠ᨻᩥᨴᩣᨻᩉᩩᩃᩮᩣ ᨽᩅ.

‘‘ᨶᩥᨾᩥᨲ᩠ᨲᩴ ᨸᩁᩥᩅᨩ᩠ᨩᩮᩉᩥ, ᩈᩩᨽᩴ ᩁᩣᨣᩪᨸᩈᨬ᩠ᩉᩥᨲᩴ;

ᩋᩈᩩᨽᩣᨿ ᨧᩥᨲ᩠ᨲᩴ ᨽᩣᩅᩮᩉᩥ, ᩑᨠᨣ᩠ᨣᩴ ᩈᩩᩈᨾᩣᩉᩥᨲᩴ.

‘‘ᩋᨶᩥᨾᩥᨲ᩠ᨲᨬ᩠ᨧ ᨽᩣᩅᩮᩉᩥ, ᨾᩣᨶᩣᨶᩩᩈᨿᨾᩩᨩ᩠ᨩᩉ;

ᨲᨲᩮᩣ ᨾᩣᨶᩣᨽᩥᩈᨾᨿᩣ, ᩏᨸᩈᨶ᩠ᨲᩮᩣ ᨧᩁᩥᩔᨲᩦ’’ᨲᩥ.

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᨽᨣᩅᩣ ᩌᨿᩈ᩠ᨾᨶ᩠ᨲᩴ ᩁᩣᩉᩩᩃᩴ ᩍᨾᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨽᩥᨱ᩠ᩉᩴ ᩒᩅᨴᨲᩦᨲᩥ.

ᩁᩣᩉᩩᩃᩈᩩᨲ᩠ᨲᩴ ᩑᨠᩣᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩑᩅᩴ ¶ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩌᩊᩅᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᩋᨣ᩠ᨣᩣᩊᩅᩮ ᨧᩮᨲᩥᨿᩮ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᩌᨿᩈ᩠ᨾᨲᩮᩣ ᩅᨦ᩠ᨣᩦᩈᩔ ᩏᨸᨩ᩠ᨫᩣᨿᩮᩣ ᨶᩥᨣᩕᩮᩣᨵᨠᨸ᩠ᨸᩮᩣ ᨶᩣᨾ ᨳᩮᩁᩮᩣ ᩋᨣ᩠ᨣᩣᩊᩅᩮ ᨧᩮᨲᩥᨿᩮ ᩋᨧᩥᩁᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ ᩉᩮᩣᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩌᨿᩈ᩠ᨾᨲᩮᩣ ᩅᨦ᩠ᨣᩦᩈᩔ ᩁᩉᩮᩣᨣᨲᩔ ᨸᨭᩥᩈᩃ᩠ᩃᩦᨶᩔ ᩑᩅᩴ ᨧᩮᨲᩈᩮᩣ ᨸᩁᩥᩅᩥᨲᨠ᩠ᨠᩮᩣ ᩏᨴᨸᩣᨴᩥ – ‘‘ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ ᨶᩩ ᨡᩮᩣ ᨾᩮ ᩏᨸᨩ᩠ᨫᩣᨿᩮᩣ ᩏᨴᩣᩉᩩ ᨶᩮᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ’’ᨲᩥ? ᩋᨳ ᨡᩮᩣ ᩌᨿᩈ᩠ᨾᩣ ᩅᨦ᩠ᨣᩦᩈᩮᩣ ᩈᩣᨿᨶ᩠ᩉᩈᨾᨿᩴ ᨸᨭᩥᩈᩃ᩠ᩃᩣᨶᩣ ᩅᩩᨭ᩠ᨮᩥᨲᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ¶ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᩌᨿᩈ᩠ᨾᩣ ᩅᨦ᩠ᨣᩦᩈᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩍᨵ ᨾᨿ᩠ᩉᩴ, ᨽᨶ᩠ᨲᩮ, ᩁᩉᩮᩣᨣᨲᩔ ᨸᨭᩥᩈᩃ᩠ᩃᩦᨶᩔ ᩑᩅᩴ ᨧᩮᨲᩈᩮᩣ ᨸᩁᩥᩅᩥᨲᨠ᩠ᨠᩮᩣ ᩏᨴᨸᩣᨴᩥ – ‘ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ ¶ ᨶᩩ ᨡᩮᩣ ᨾᩮ ᩏᨸᨩ᩠ᨫᩣᨿᩮᩣ, ᩏᨴᩣᩉᩩ ᨶᩮᩣ ᨸᩁᩥᨶᨻ᩠ᨻᩩᨲᩮᩣ’’’ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩌᨿᩈ᩠ᨾᩣ ᩅᨦ᩠ᨣᩦᩈᩮᩣ ᩏᨭ᩠ᨮᩣᨿᩣᩈᨶᩣ ᩑᨠᩴᩈᩴ ᨧᩦᩅᩁᩴ ᨠᨲ᩠ᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᨬ᩠ᨩᩃᩥᩴ ᨸᨱᩣᨾᩮᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨸᩩᨧ᩠ᨨᩣᨾ [ᨸᩩᨧ᩠ᨨᩣᨾᩥ (ᨠ.)] ᩈᨲ᩠ᨳᩣᩁᨾᨶᩮᩣᨾᨸᨬ᩠ᨬᩴ, ᨴᩥᨭ᩠ᨮᩮᩅ ᨵᨾ᩠ᨾᩮ ᨿᩮᩣ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᩣᨶᩴ ᨨᩮᨲ᩠ᨲᩣ;

ᩋᨣ᩠ᨣᩣᩊᩅᩮ ᨠᩣᩃᨾᨠᩣᩈᩥ ᨽᩥᨠ᩠ᨡᩩ, ᨬᩣᨲᩮᩣ ᨿᩈᩔᩦ ᩋᨽᩥᨶᩥᨻ᩠ᨻᩩᨲᨲ᩠ᨲᩮᩣ.

‘‘ᨶᩥᨣᩕᩮᩣᨵᨠᨸ᩠ᨸᩮᩣ ¶ ᩍᨲᩥ ᨲᩔ ᨶᩣᨾᩴ, ᨲᨿᩣ ᨠᨲᩴ ᨽᨣᩅᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩔ;

ᩈᩮᩣ ᨲᩴ ᨶᨾᩔᩴ ᩋᨧᩁᩥ ᨾᩩᨲ᩠ᨿᨸᩮᨠ᩠ᨡᩮᩣ, ᩌᩁᨴ᩠ᨵᩅᩦᩁᩥᨿᩮᩣ ᨴᩊ᩠ᩉᨵᨾ᩠ᨾᨴᩔᩦ.

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

ᩈᨾᩅᨭ᩠ᨮᩥᨲᩣ ᨶᩮᩣ ᩈᩅᨶᩣᨿ ᩈᩮᩣᨲᩣ, ᨲᩩᩅᩴ ᨶᩮᩣ ᩈᨲ᩠ᨳᩣ ᨲ᩠ᩅᨾᨶᩩᨲ᩠ᨲᩁᩮᩣᩈᩥ.

‘‘ᨨᩥᨶ᩠ᨴᩮᩅ ᨶᩮᩣ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᩴ ᨻᩕᩪᩉᩥ ᨾᩮᨲᩴ, ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩴ ᩅᩮᨴᨿ ᨽᩪᩁᩥᨸᨬ᩠ᨬ;

ᨾᨩ᩠ᨫᩮᩅ [ᨾᨩ᩠ᨫᩮ ᨧ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨶᩮᩣ ᨽᩣᩈ ᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩩ, ᩈᨠ᩠ᨠᩮᩣᩅ ᨴᩮᩅᩣᨶ ᩈᩉᩔᨶᩮᨲ᩠ᨲᩮᩣ.

‘‘ᨿᩮ ᨠᩮᨧᩥ ᨣᨶ᩠ᨳᩣ ᩍᨵ ᨾᩮᩣᩉᨾᨣ᩠ᨣᩣ, ᩋᨬ᩠ᨬᩣᨱᨸᨠ᩠ᨡᩣ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᨮᩣᨶᩣ;

ᨲᨳᩣᨣᨲᩴ ¶ ᨸᨲ᩠ᩅᩣ ᨶ ᨲᩮ ᨽᩅᨶ᩠ᨲᩥ, ᨧᨠ᩠ᨡᩩᨬ᩠ᩉᩥ ᩑᨲᩴ ᨸᩁᨾᩴ ᨶᩁᩣᨶᩴ.

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

ᨲᨾᩮᩣᩅᩔ ᨶᩥᩅᩩᨲᩮᩣ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩮᩣ, ᨶ ¶ ᨩᩮᩣᨲᩥᨾᨶ᩠ᨲᩮᩣᨸᩥ ᨶᩁᩣ ᨲᨸᩮᨿ᩠ᨿᩩᩴ.

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

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

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

ᨻᩥᨶ᩠ᨴᩩᩔᩁᩮᨶ ᩈᩩᩅᩥᨠᨸ᩠ᨸᩥᨲᩮᨶ, ᩈᨻ᩠ᨻᩮᩅ ᨲᩮ ᩏᨩ᩠ᨩᩩᨣᨲᩣ ᩈᩩᨱᩮᩣᨾ.

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

ᨶ ᨠᩣᨾᨠᩣᩁᩮᩣ ᩉᩥ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩣᨶᩴ, ᩈᨦ᩠ᨡᩮᨿ᩠ᨿᨠᩣᩁᩮᩣ ᨧ [ᩈᨦ᩠ᨡᨿ᩠ᨿᨠᩣᩁᩮᩣᩅ (ᨠ.)] ᨲᨳᩣᨣᨲᩣᨶᩴ.

‘‘ᩈᨾ᩠ᨸᨶ᩠ᨶᩅᩮᨿ᩠ᨿᩣᨠᩁᨱᩴ ᨲᩅᩮᨴᩴ, ᩈᨾᩩᨩ᩠ᨩᩩᨸᨬ᩠ᨬᩔ [ᩈᨾᩩᨩ᩠ᨩᨸᨬ᩠ᨬᩔ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩈᨾᩩᨣ᩠ᨣᩉᩦᨲᩴ;

ᩋᨿᨾᨬ᩠ᨩᩃᩦ ᨸᨧ᩠ᨨᩥᨾᩮᩣ ᩈᩩᨸ᩠ᨸᨱᩣᨾᩥᨲᩮᩣ, ᨾᩣ ᨾᩮᩣᩉᨿᩦ ᨩᩣᨶᨾᨶᩮᩣᨾᨸᨬ᩠ᨬ.

‘‘ᨸᩁᩮᩣᩅᩁᩴ [ᩅᩁᩣᩅᩁᩴ (ᨠᨲ᩠ᨳᨧᩥ)] ᩋᩁᩥᨿᨵᨾ᩠ᨾᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ, ᨾᩣ ᨾᩮᩣᩉᨿᩦ ᨩᩣᨶᨾᨶᩮᩣᨾᩅᩦᩁ;

ᩅᩣᩁᩥᩴ ᨿᨳᩣ ¶ ᨥᨾ᩠ᨾᨶᩥ ᨥᨾ᩠ᨾᨲᨲ᩠ᨲᩮᩣ, ᩅᩣᨧᩣᨽᩥᨠᨦ᩠ᨡᩣᨾᩥ ¶ ᩈᩩᨲᩴ ᨸᩅᩔ [ᩈᩩᨲᩔ ᩅᩔ (ᩈ᩠ᨿᩣ.)].

‘‘ᨿᨴᨲ᩠ᨳᩥᨠᩴ [ᨿᨴᨲ᩠ᨳᩥᨿᩴ (ᨸᩦ.), ᨿᨴᨲ᩠ᨳᩥᨲᩴ (ᨠ.)] ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ ᩋᨧᩁᩦ, ᨠᨸ᩠ᨸᩣᨿᨶᩮᩣ ᨠᨧ᩠ᨧᩥᩔ ᨲᩴ ᩋᨾᩮᩣᨥᩴ;

ᨶᩥᨻ᩠ᨻᩣᨿᩥ ᩈᩮᩣ ᩌᨴᩩ ᩈᩏᨸᩣᨴᩥᩈᩮᩈᩮᩣ, ᨿᨳᩣ ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ ᩋᩉᩩ ᨲᩴ ᩈᩩᨱᩮᩣᨾ’’.

‘‘ᩋᨧ᩠ᨨᩮᨧ᩠ᨨᩥ ¶ [ᩋᨨᩮᨩ᩠ᨩᩥ (ᨠ.)] ᨲᨱ᩠ᩉᩴ ᩍᨵ ᨶᩣᨾᩁᩪᨸᩮ, (ᩍᨲᩥ ᨽᨣᩅᩣ)

ᨠᨱ᩠ᩉᩔ [ᨲᨱ᩠ᩉᩣᨿ (ᨠ.)] ᩈᩮᩣᨲᩴ ᨴᩦᨥᩁᨲ᩠ᨲᩣᨶᩩᩈᨿᩥᨲᩴ;

‘‘ᩑᩈ ᩈᩩᨲ᩠ᩅᩣ ᨸᩈᩦᨴᩣᨾᩥ, ᩅᨧᩮᩣ ᨲᩮ ᩍᩈᩥᩈᨲ᩠ᨲᨾ;

ᩋᨾᩮᩣᨥᩴ ᨠᩥᩁ ᨾᩮ ᨸᩩᨭ᩠ᨮᩴ, ᨶ ᨾᩴ ᩅᨬ᩠ᨧᩮᩈᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨿᨳᩣᩅᩣᨴᩦ ¶ ᨲᨳᩣᨠᩣᩁᩦ, ᩋᩉᩩ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩅᨠᩮᩣ;

ᩋᨧ᩠ᨨᩥᨴᩣ ᨾᨧ᩠ᨧᩩᨶᩮᩣ ᨩᩣᩃᩴ, ᨲᨲᩴ ᨾᩣᨿᩣᩅᩥᨶᩮᩣ ᨴᩊ᩠ᩉᩴ.

‘‘ᩋᨴ᩠ᨴᩈᩣ ᨽᨣᩅᩣ ᩌᨴᩥᩴ, ᩏᨸᩣᨴᩣᨶᩔ ᨠᨸ᩠ᨸᩥᨿᩮᩣ;

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

ᨶᩥᨣᩕᩮᩣᨵᨠᨸ᩠ᨸᩈᩩᨲ᩠ᨲᩴ ᨴ᩠ᩅᩣᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ¶ ¶ ᨾᩩᨶᩥᩴ ᨸᩉᩪᨲᨸᨬ᩠ᨬᩴ,

ᨲᩥᨱ᩠ᨱᩴ ᨸᩣᩁᨦ᩠ᨣᨲᩴ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩴ ᨮᩥᨲᨲ᩠ᨲᩴ;

ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ ᨥᩁᩣ ᨸᨶᩩᨩ᩠ᨩ ᨠᩣᨾᩮ, ᨠᨳᩴ ᨽᩥᨠ᩠ᨡᩩ

ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ’’.

‘‘ᩁᩣᨣᩴ ᩅᩥᨶᨿᩮᨳ ᨾᩣᨶᩩᩈᩮᩈᩩ, ᨴᩥᨻ᩠ᨻᩮᩈᩩ ᨠᩣᨾᩮᩈᩩ ᨧᩣᨸᩥ ᨽᩥᨠ᩠ᨡᩩ;

ᩋᨲᩥᨠ᩠ᨠᨾ᩠ᨾ ᨽᩅᩴ ᩈᨾᩮᨧ᩠ᨧ ᨵᨾ᩠ᨾᩴ, ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

‘‘ᩅᩥᨸᩥᨭ᩠ᨮᩥᨠᨲ᩠ᩅᩣᨶ ¶ ᨸᩮᩈᩩᨱᩣᨶᩥ, ᨠᩮᩣᨵᩴ ᨠᨴᩁᩥᨿᩴ ᨩᩉᩮᨿ᩠ᨿ ᨽᩥᨠ᩠ᨡᩩ;

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

‘‘ᩉᩥᨲ᩠ᩅᩣᨶ ¶ ᨸᩥᨿᨬ᩠ᨧ ᩋᨸ᩠ᨸᩥᨿᨬ᩠ᨧ, ᩋᨶᩩᨸᩣᨴᩣᨿ ᩋᨶᩥᩔᩥᨲᩮᩣ ᨠᩩᩉᩥᨬ᩠ᨧᩥ;

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

‘‘ᨶ ¶ ᩈᩮᩣ ᩏᨸᨵᩦᩈᩩ ᩈᩣᩁᨾᩮᨲᩥ, ᩌᨴᩣᨶᩮᩈᩩ ᩅᩥᨶᩮᨿ᩠ᨿ ᨨᨶ᩠ᨴᩁᩣᨣᩴ;

ᩈᩮᩣ ᩋᨶᩥᩔᩥᨲᩮᩣ ᩋᨶᨬ᩠ᨬᨶᩮᨿ᩠ᨿᩮᩣ, ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

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

ᨶᩥᨻ᩠ᨻᩣᨶᨸᨴᩣᨽᩥᨸᨲ᩠ᨳᨿᩣᨶᩮᩣ, ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

‘‘ᨿᩮᩣ ᩅᨶ᩠ᨴᨲᩥ ᨾᨶ᩠ᨲᩥ ᨶᩩᨱ᩠ᨱᨾᩮᨿ᩠ᨿ [ᨶᩩᨶ᩠ᨶᨾᩮᨿ᩠ᨿ (?)], ᩋᨠ᩠ᨠᩩᨭ᩠ᨮᩮᩣᨸᩥ ᨶ ᩈᨶ᩠ᨵᩥᨿᩮᨳ ᨽᩥᨠ᩠ᨡᩩ;

ᩃᨴ᩠ᨵᩣ ᨸᩁᨽᩮᩣᨩᨶᩴ ᨶ ᨾᨩ᩠ᨩᩮ, ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

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

ᩈᩮᩣ ᨲᩥᨱ᩠ᨱᨠᨳᩴᨠᨳᩮᩣ ᩅᩥᩈᩃ᩠ᩃᩮᩣ, ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

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

ᨿᨳᩣ ᨲᨳᩥᨿᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᨵᨾ᩠ᨾᩴ, ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

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

ᩈᩮᩣ ᨶᩥᩁᩣᩈᩮᩣ [ᨶᩥᩁᩣᩈᨿᩮᩣ (ᩈᩦ.), ᨶᩥᩁᩣᩈᩈᩮᩣ (ᩈ᩠ᨿᩣ.)] ᩋᨶᩣᩈᩥᩈᩣᨶᩮᩣ [ᩋᨶᩣᩈᨿᩣᨶᩮᩣ (ᩈᩦ. ᨸᩦ.), ᩋᨶᩣᩈᩈᩣᨶᩮᩣ (ᩈ᩠ᨿᩣ.)], ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

‘‘ᩌᩈᩅᨡᩦᨱᩮᩣ ¶ ᨸᩉᩦᨶᨾᩣᨶᩮᩣ, ᩈᨻ᩠ᨻᩴ ᩁᩣᨣᨸᨳᩴ ᩏᨸᩣᨲᩥᩅᨲ᩠ᨲᩮᩣ;

ᨴᨶ᩠ᨲᩮᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ ᨮᩥᨲᨲ᩠ᨲᩮᩣ, ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

‘‘ᩈᨴ᩠ᨵᩮᩣ ᩈᩩᨲᩅᩣ ᨶᩥᨿᩣᨾᨴᩔᩦ, ᩅᨣ᩠ᨣᨣᨲᩮᩈᩩ ᨶ ᩅᨣ᩠ᨣᩈᩣᩁᩥ ᨵᩦᩁᩮᩣ;

ᩃᩮᩣᨽᩴ ᨴᩮᩣᩈᩴ ᩅᩥᨶᩮᨿ᩠ᨿ ᨸᨭᩥᨥᩴ, ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

‘‘ᩈᩴᩈᩩᨴ᩠ᨵᨩᩥᨶᩮᩣ ᩅᩥᩅᨭ᩠ᨭᨧ᩠ᨨᨴᩮᩣ, ᨵᨾ᩠ᨾᩮᩈᩩ ᩅᩈᩦ ᨸᩣᩁᨣᩪ ᩋᨶᩮᨩᩮᩣ;

ᩈᨦ᩠ᨡᩣᩁᨶᩥᩁᩮᩣᨵᨬᩣᨱᨠᩩᩈᩃᩮᩣ ¶ , ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ.

‘‘ᩋᨲᩦᨲᩮᩈᩩ ᩋᨶᩣᨣᨲᩮᩈᩩ ᨧᩣᨸᩥ, ᨠᨸ᩠ᨸᩣᨲᩦᨲᩮᩣ ᩋᨲᩥᨧ᩠ᨧᩈᩩᨴ᩠ᨵᩥᨸᨬ᩠ᨬᩮᩣ;

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

‘‘ᩋᨬ᩠ᨬᩣᨿ ¶ ᨸᨴᩴ ᩈᨾᩮᨧ᩠ᨧ ᨵᨾ᩠ᨾᩴ, ᩅᩥᩅᨭᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᨸᩉᩣᨶᨾᩣᩈᩅᩣᨶᩴ;

ᩈᨻ᩠ᨻᩩᨸᨵᩦᨶᩴ ᨸᩁᩥᨠ᩠ᨡᨿᩣᨶᩮᩣ [ᨸᩁᩥᨠ᩠ᨡᨿᩣ (ᨸᩦ.)], ᩈᨾ᩠ᨾᩣ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨻ᩠ᨻᨩᩮᨿ᩠ᨿ’’.

‘‘ᩋᨴ᩠ᨵᩣ ¶ ᩉᩥ ᨽᨣᩅᩣ ᨲᨳᩮᩅ ᩑᨲᩴ, ᨿᩮᩣ ᩈᩮᩣ ᩑᩅᩴᩅᩥᩉᩣᩁᩦ ᨴᨶ᩠ᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ;

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

ᩈᨾ᩠ᨾᩣᨸᩁᩥᨻ᩠ᨻᩣᨩᨶᩦᨿᩈᩩᨲ᩠ᨲᩴ ᨲᩮᩁᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩑᩅᩴ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨩᩮᨲᩅᨶᩮ ᩋᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩔ ᩌᩁᩣᨾᩮ. ᩋᨳ ᨡᩮᩣ ᨵᨾ᩠ᨾᩥᨠᩮᩣ ᩏᨸᩣᩈᨠᩮᩣ ¶ ᨸᨬ᩠ᨧᩉᩥ ᩏᨸᩣᩈᨠᩈᨲᩮᩉᩥ ᩈᨴ᩠ᨵᩥᩴ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᨵᨾ᩠ᨾᩥᨠᩮᩣ ᩏᨸᩣᩈᨠᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᩉᩥ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨣᩮᩣᨲᨾ ᨽᩪᩁᩥᨸᨬ᩠ᨬ, ᨠᨳᩴᨠᩁᩮᩣ ᩈᩣᩅᨠᩮᩣ ᩈᩣᨵᩩ ᩉᩮᩣᨲᩥ;

ᨿᩮᩣ ᩅᩣ ᩋᨣᩣᩁᩣ ᩋᨶᨣᩣᩁᨾᩮᨲᩥ, ᩋᨣᩣᩁᩥᨶᩮᩣ ᩅᩣ ᨸᨶᩩᨸᩣᩈᨠᩣᩈᩮ.

‘‘ᨲᩩᩅᨬ᩠ᩉᩥ ᩃᩮᩣᨠᩔ ᩈᨴᩮᩅᨠᩔ, ᨣᨲᩥᩴ ᨸᨩᩣᨶᩣᩈᩥ ᨸᩁᩣᨿᨱᨬ᩠ᨧ;

ᨶ ᨧᨲ᩠ᨳᩥ ᨲᩩᩃ᩠ᨿᩮᩣ ᨶᩥᨸᩩᨱᨲ᩠ᨳᨴᩔᩦ, ᨲᩩᩅᨬ᩠ᩉᩥ ᨻᩩᨴ᩠ᨵᩴ ᨸᩅᩁᩴ ᩅᨴᨶ᩠ᨲᩥ.

‘‘ᩈᨻ᩠ᨻᩴ ᨲᩩᩅᩴ ᨬᩣᨱᨾᩅᩮᨧ᩠ᨧ ᨵᨾ᩠ᨾᩴ, ᨸᨠᩣᩈᩮᩈᩥ ᩈᨲ᩠ᨲᩮ ᩋᨶᩩᨠᨾ᩠ᨸᨾᩣᨶᩮᩣ;

ᩅᩥᩅᨭ᩠ᨭᨧ᩠ᨨᨴᩮᩣᩈᩥ ᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩩ, ᩅᩥᩁᩮᩣᨧᩈᩥ ᩅᩥᨾᩃᩮᩣ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩮ.

‘‘ᩌᨣᨬ᩠ᨨᩥ ¶ ᨲᩮ ᩈᨶ᩠ᨲᩥᨠᩮ ᨶᩣᨣᩁᩣᨩᩣ, ᩑᩁᩣᩅᨱᩮᩣ ᨶᩣᨾ ᨩᩥᨶᩮᩣᨲᩥ ᩈᩩᨲ᩠ᩅᩣ;

ᩈᩮᩣᨸᩥ ᨲᨿᩣ ᨾᨶ᩠ᨲᨿᩥᨲ᩠ᩅᩣᨩ᩠ᨫᨣᨾᩣ, ᩈᩣᨵᩪᨲᩥ ᩈᩩᨲ᩠ᩅᩣᨶ ᨸᨲᩦᨲᩁᩪᨸᩮᩣ.

‘‘ᩁᩣᨩᩣᨸᩥ ¶ ¶ ¶ ᨲᩴ ᩅᩮᩔᩅᨱᩮᩣ ᨠᩩᩅᩮᩁᩮᩣ, ᩏᨸᩮᨲᩥ ᨵᨾ᩠ᨾᩴ ᨸᩁᩥᨸᩩᨧ᩠ᨨᨾᩣᨶᩮᩣ;

ᨲᩔᩣᨸᩥ ᨲ᩠ᩅᩴ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᨻᩕᩪᩈᩥ ᨵᩦᩁ, ᩈᩮᩣ ᨧᩣᨸᩥ ᩈᩩᨲ᩠ᩅᩣᨶ ᨸᨲᩦᨲᩁᩪᨸᩮᩣ.

‘‘ᨿᩮ ᨠᩮᨧᩥᨾᩮ ᨲᩥᨲ᩠ᨳᩥᨿᩣ ᩅᩣᨴᩈᩦᩃᩣ, ᩌᨩᩦᩅᨠᩣ ᩅᩣ ᨿᨴᩥ ᩅᩣ ᨶᩥᨣᨱ᩠ᨮᩣ;

ᨸᨬ᩠ᨬᩣᨿ ᨲᩴ ᨶᩣᨲᩥᨲᩁᨶ᩠ᨲᩥ ᩈᨻ᩠ᨻᩮ, ᨮᩥᨲᩮᩣ ᩅᨩᨶ᩠ᨲᩴ ᩅᩥᨿ ᩈᩦᨥᨣᩣᨾᩥᩴ.

‘‘ᨿᩮ ᨠᩮᨧᩥᨾᩮ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩅᩣᨴᩈᩦᩃᩣ, ᩅᩩᨴ᩠ᨵᩣ ᨧᩣᨸᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩈᨶ᩠ᨲᩥ ᨠᩮᨧᩥ;

ᩈᨻ᩠ᨻᩮ ᨲᨿᩥ ᩋᨲ᩠ᨳᨻᨴ᩠ᨵᩣ ᨽᩅᨶ᩠ᨲᩥ, ᨿᩮ ᨧᩣᨸᩥ ᩋᨬ᩠ᨬᩮ ᩅᩣᨴᩥᨶᩮᩣ ᨾᨬ᩠ᨬᨾᩣᨶᩣ.

‘‘ᩋᨿᨬ᩠ᩉᩥ ᨵᨾ᩠ᨾᩮᩣ ᨶᩥᨸᩩᨱᩮᩣ ᩈᩩᨡᩮᩣ ᨧ, ᨿᩮᩣᨿᩴ ᨲᨿᩣ ᨽᨣᩅᩣ ᩈᩩᨸ᩠ᨸᩅᩩᨲ᩠ᨲᩮᩣ;

ᨲᨾᩮᩅ ᩈᨻ᩠ᨻᩮᨸᩥ [ᩈᨻ᩠ᨻᩮ ᨾᨿᩴ (ᩈ᩠ᨿᩣ.)] ᩈᩩᩔᩪᩈᨾᩣᨶᩣ, ᨲᩴ ᨶᩮᩣ ᩅᨴ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᨻᩩᨴ᩠ᨵᩈᩮᨭ᩠ᨮ.

‘‘ᩈᨻ᩠ᨻᩮᨸᩥ ᨾᩮ ᨽᩥᨠ᩠ᨡᩅᩮᩣ ᩈᨶ᩠ᨶᩥᩈᩥᨶ᩠ᨶᩣ, ᩏᨸᩣᩈᨠᩣ ᨧᩣᨸᩥ ᨲᨳᩮᩅ ᩈᩮᩣᨲᩩᩴ;

ᩈᩩᨱᨶ᩠ᨲᩩ ᨵᨾ᩠ᨾᩴ ᩅᩥᨾᩃᩮᨶᩣᨶᩩᨻᩩᨴ᩠ᨵᩴ, ᩈᩩᨽᩣᩈᩥᨲᩴ ¶ ᩅᩣᩈᩅᩔᩮᩅ ᨴᩮᩅᩣ’’.

‘‘ᩈᩩᨱᩣᨳ ᨾᩮ ᨽᩥᨠ᩠ᨡᩅᩮᩣ ᩈᩣᩅᨿᩣᨾᩥ ᩅᩮᩣ, ᨵᨾ᩠ᨾᩴ ᨵᩩᨲᩴ ᨲᨬ᩠ᨧ ᨧᩁᩣᨳ ᩈᨻ᩠ᨻᩮ;

ᩍᩁᩥᨿᩣᨸᨳᩴ ¶ ᨸᨻ᩠ᨻᨩᩥᨲᩣᨶᩩᩃᩮᩣᨾᩥᨠᩴ, ᩈᩮᩅᩮᨳ ᨶᩴ ᩋᨲ᩠ᨳᨴᩈᩮᩣ ᨾᩩᨲᩦᨾᩣ.

‘‘ᨶᩮᩣ ᩅᩮ ᩅᩥᨠᩣᩃᩮ ᩅᩥᨧᩁᩮᨿ᩠ᨿ ᨽᩥᨠ᩠ᨡᩩ, ᨣᩣᨾᩮ ᨧ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᩮᨿ᩠ᨿ ᨠᩣᩃᩮ;

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

‘‘ᩁᩪᨸᩣ ¶ ᨧ ᩈᨴ᩠ᨴᩣ ᨧ ᩁᩈᩣ ᨧ ᨣᨶ᩠ᨵᩣ, ᨹᩔᩣ ᨧ ᨿᩮ ᩈᨾ᩠ᨾᨴᨿᨶ᩠ᨲᩥ ᩈᨲ᩠ᨲᩮ;

ᩑᨲᩮᩈᩩ ᨵᨾ᩠ᨾᩮᩈᩩ ᩅᩥᨶᩮᨿ᩠ᨿ ᨨᨶ᩠ᨴᩴ, ᨠᩣᩃᩮᨶ ᩈᩮᩣ ᨸᩅᩥᩈᩮ ᨸᩣᨲᩁᩣᩈᩴ.

‘‘ᨸᩥᨱ᩠ᨯᨬ᩠ᨧ ᨽᩥᨠ᩠ᨡᩩ ᩈᨾᨿᩮᨶ ᩃᨴ᩠ᨵᩣ, ᩑᨠᩮᩣ ᨸᨭᩥᨠ᩠ᨠᨾ᩠ᨾ ᩁᩉᩮᩣ ᨶᩥᩈᩦᨴᩮ;

ᩋᨩ᩠ᨫᨲ᩠ᨲᨧᩥᨶ᩠ᨲᩦ ᨶ ᨾᨶᩮᩣ ᨻᩉᩥᨴ᩠ᨵᩣ, ᨶᩥᨧ᩠ᨨᩣᩁᨿᩮ ᩈᨦ᩠ᨣᩉᩥᨲᨲ᩠ᨲᨽᩣᩅᩮᩣ.

‘‘ᩈᨧᩮᨸᩥ ᩈᩮᩣ ᩈᩃ᩠ᩃᨸᩮ ᩈᩣᩅᨠᩮᨶ, ᩋᨬ᩠ᨬᩮᨶ ᩅᩣ ᨠᩮᨶᨧᩥ ᨽᩥᨠ᩠ᨡᩩᨶᩣ ᩅᩣ;

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

‘‘ᩅᩣᨴᨬ᩠ᩉᩥ ¶ ᩑᨠᩮ ᨸᨭᩥᩈᩮᨶᩥᨿᨶ᩠ᨲᩥ, ᨶ ᨲᩮ ᨸᩈᩴᩈᩣᨾ ᨸᩁᩥᨲ᩠ᨲᨸᨬ᩠ᨬᩮ;

ᨲᨲᩮᩣ ᨲᨲᩮᩣ ᨶᩮ ᨸᩈᨩᨶ᩠ᨲᩥ ᩈᨦ᩠ᨣᩣ, ᨧᩥᨲ᩠ᨲᨬ᩠ᩉᩥ ᨲᩮ ᨲᨲ᩠ᨳ ᨣᨾᩮᨶ᩠ᨲᩥ ᨴᩪᩁᩮ.

‘‘ᨸᩥᨱ᩠ᨯᩴ ᩅᩥᩉᩣᩁᩴ ᩈᨿᨶᩣᩈᨶᨬ᩠ᨧ, ᩌᨸᨬ᩠ᨧ ᩈᨦ᩠ᨥᩣᨭᩥᩁᨩᩪᨸᩅᩣᩉᨶᩴ;

ᩈᩩᨲ᩠ᩅᩣᨶ ᨵᨾ᩠ᨾᩴ ᩈᩩᨣᨲᩮᨶ ᨴᩮᩈᩥᨲᩴ, ᩈᨦ᩠ᨡᩣᨿ ᩈᩮᩅᩮ ᩅᩁᨸᨬ᩠ᨬᩈᩣᩅᨠᩮᩣ.

‘‘ᨲᩈ᩠ᨾᩣ ᩉᩥ ᨸᩥᨱ᩠ᨯᩮ ᩈᨿᨶᩣᩈᨶᩮ ᨧ, ᩌᨸᩮ ᨧ ᩈᨦ᩠ᨥᩣᨭᩥᩁᨩᩪᨸᩅᩣᩉᨶᩮ;

ᩑᨲᩮᩈᩩ ¶ ᨵᨾ᩠ᨾᩮᩈᩩ ᩋᨶᩪᨸᩃᩥᨲ᩠ᨲᩮᩣ, ᨽᩥᨠ᩠ᨡᩩ ᨿᨳᩣ ᨸᩮᩣᨠ᩠ᨡᩁᩮ ᩅᩣᩁᩥᨻᩥᨶ᩠ᨴᩩ.

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

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

‘‘ᨸᩣᨱᩴ ¶ ᨶ ᩉᨶᩮ [ᨶ ᩉᩣᨶᩮ (ᩈᩦ.)] ᨶ ᨧ ᨥᩣᨲᨿᩮᨿ᩠ᨿ, ᨶ ᨧᩣᨶᩩᨩᨬ᩠ᨬᩣ ᩉᨶᨲᩴ ᨸᩁᩮᩈᩴ;

ᩈᨻ᩠ᨻᩮᩈᩩ ¶ ᨽᩪᨲᩮᩈᩩ ᨶᩥᨵᩣᨿ ᨴᨱ᩠ᨯᩴ, ᨿᩮ ᨳᩣᩅᩁᩣ ᨿᩮ ᨧ ᨲᩈᩣ ᩈᨶ᩠ᨲᩥ [ᨲᩈᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᩃᩮᩣᨠᩮ.

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

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

‘‘ᩋᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩮᨿ᩠ᨿ, ᩋᨦ᩠ᨣᩣᩁᨠᩣᩈᩩᩴ ᨩᩃᩥᨲᩴᩅ ᩅᩥᨬ᩠ᨬᩪ;

ᩋᩈᨾ᩠ᨽᩩᨱᨶ᩠ᨲᩮᩣ ᨸᨶ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᨸᩁᩔ ᨴᩣᩁᩴ ᨶ ᩋᨲᩥᨠ᩠ᨠᨾᩮᨿ᩠ᨿ.

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

ᨶ ᨽᩣᨱᨿᩮ ᨽᨱᨲᩴ ᨶᩣᨶᩩᨩᨬ᩠ᨬᩣ, ᩈᨻ᩠ᨻᩴ ᩋᨽᩪᨲᩴ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩮᨿ᩠ᨿ.

‘‘ᨾᨩ᩠ᨩᨬ᩠ᨧ ᨸᩣᨶᩴ ᨶ ᩈᨾᩣᨧᩁᩮᨿ᩠ᨿ, ᨵᨾ᩠ᨾᩴ ᩍᨾᩴ ᩁᩮᩣᨧᨿᩮ ᨿᩮᩣ ᨣᩉᨭ᩠ᨮᩮᩣ;

ᨶ ᨸᩣᨿᨿᩮ ᨸᩥᩅᨲᩴ ᨶᩣᨶᩩᨩᨬ᩠ᨬᩣ, ᩏᨾ᩠ᨾᩣᨴᨶᨶ᩠ᨲᩴ ᩍᨲᩥ ᨶᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ.

‘‘ᨾᨴᩣ ᩉᩥ ᨸᩣᨸᩣᨶᩥ ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᨻᩣᩃᩣ, ᨠᩣᩁᩮᨶ᩠ᨲᩥ ᨧᨬ᩠ᨬᩮᨸᩥ ᨩᨶᩮ ᨸᨾᨲ᩠ᨲᩮ;

ᩑᨲᩴ ¶ ¶ ᩋᨸᩩᨬ᩠ᨬᩣᨿᨲᨶᩴ ᩅᩥᩅᨩ᩠ᨩᨿᩮ, ᩏᨾ᩠ᨾᩣᨴᨶᩴ ᨾᩮᩣᩉᨶᩴ ᨻᩣᩃᨠᨶ᩠ᨲᩴ.

‘‘ᨸᩣᨱᩴ ¶ ᨶ ᩉᨶᩮ ᨶ ᨧᩣᨴᩥᨶ᩠ᨶᨾᩣᨴᩥᨿᩮ, ᨾᩩᩈᩣ ᨶ ᨽᩣᩈᩮ ᨶ ᨧ ᨾᨩ᩠ᨩᨸᩮᩣ ᩈᩥᨿᩣ;

ᩋᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩣ ᩅᩥᩁᨾᩮᨿ᩠ᨿ ᨾᩮᨳᩩᨶᩣ, ᩁᨲ᩠ᨲᩥᩴ ᨶ ᨽᩩᨬ᩠ᨩᩮᨿ᩠ᨿ ᩅᩥᨠᩣᩃᨽᩮᩣᨩᨶᩴ.

‘‘ᨾᩣᩃᩴ ¶ ᨶ ᨵᩣᩁᩮ ᨶ ᨧ ᨣᨶ᩠ᨵᨾᩣᨧᩁᩮ, ᨾᨬ᩠ᨧᩮ ᨨᨾᩣᨿᩴ ᩅ ᩈᨿᩮᨳ ᩈᨶ᩠ᨳᨲᩮ;

ᩑᨲᨬ᩠ᩉᩥ ᩋᨭ᩠ᨮᨦ᩠ᨣᩥᨠᨾᩣᩉᩩᨸᩮᩣᩈᨳᩴ, ᨻᩩᨴ᩠ᨵᩮᨶ ᨴᩩᨠ᩠ᨡᨶ᩠ᨲᨣᩩᨶᩣ ᨸᨠᩣᩈᩥᨲᩴ.

‘‘ᨲᨲᩮᩣ ᨧ ᨸᨠ᩠ᨡᩔᩩᨸᩅᩔᩩᨸᩮᩣᩈᨳᩴ, ᨧᩣᨲᩩᨴ᩠ᨴᩈᩥᩴ ᨸᨬ᩠ᨧᨴᩈᩥᨬ᩠ᨧ ᩋᨭ᩠ᨮᨾᩥᩴ;

ᨸᩣᨭᩥᩉᩣᩁᩥᨿᨸᨠ᩠ᨡᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨾᩣᨶᩈᩮᩣ, ᩋᨭ᩠ᨮᨦ᩠ᨣᩩᨸᩮᨲᩴ ᩈᩩᩈᨾᨲ᩠ᨲᩁᩪᨸᩴ.

‘‘ᨲᨲᩮᩣ ᨧ ᨸᩣᨲᩮᩣ ᩏᨸᩅᩩᨲ᩠ᨳᩩᨸᩮᩣᩈᨳᩮᩣ, ᩋᨶ᩠ᨶᩮᨶ ᨸᩣᨶᩮᨶ ᨧ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩴ;

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

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

ᩑᨲᩴ ¶ ᨣᩥᩉᩦ ᩅᨲ᩠ᨲᨿᨾᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ, ᩈᨿᨾ᩠ᨸᨽᩮ ᨶᩣᨾ ᩏᨸᩮᨲᩥ ᨴᩮᩅᩮ’’ᨲᩥ.

ᨵᨾ᩠ᨾᩥᨠᩈᩩᨲ᩠ᨲᩴ ᨧᩩᨴ᩠ᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩁᨲᨶᩣᨾᨣᨶ᩠ᨵᩮᩣ ᩉᩥᩁᩥ ᨧ, ᨾᨦ᩠ᨣᩃᩴ ᩈᩪᨧᩥᩃᩮᩣᨾᩮᨶ;

ᨵᨾ᩠ᨾᨧᩁᩥᨿᨬ᩠ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ [ᨠᨸᩥᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣᨸᩥ ᨧ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨶᩣᩅᩣ ᨠᩥᩴᩈᩦᩃᨾᩩᨭ᩠ᨮᩣᨶᩴ.

ᩁᩣᩉᩩᩃᩮᩣ ᨸᩩᨶ ᨠᨸ᩠ᨸᩮᩣ ᨧ, ᨸᩁᩥᨻ᩠ᨻᩣᨩᨶᩥᨿᩴ ᨲᨳᩣ;

ᨵᨾ᩠ᨾᩥᨠᨬ᩠ᨧ ᩅᩥᨴᩩᨶᩮᩣ ᩌᩉᩩ, ᨧᩪᩊᩅᨣ᩠ᨣᨶ᩠ᨲᩥ ᨧᩩᨴ᩠ᨴᩈᩣᨲᩥ.

ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ ¶ ¶ ¶ ᨠᩥᨲ᩠ᨲᨿᩥᩔᩣᨾᩥ, ᨿᨳᩣ ᨸᨻ᩠ᨻᨩᩥ ᨧᨠ᩠ᨡᩩᨾᩣ;

ᨿᨳᩣ ᩅᩦᨾᩴᩈᨾᩣᨶᩮᩣ ᩈᩮᩣ, ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ ᩈᨾᩁᩮᩣᨧᨿᩥ.

ᩈᨾ᩠ᨻᩣᨵᩮᩣᨿᩴ ᨥᩁᩣᩅᩣᩈᩮᩣ, ᩁᨩᩔᩣᨿᨲᨶᩴ ᩍᨲᩥ;

ᩋᨻ᩠ᨽᩮᩣᨠᩣᩈᩮᩣᩅ ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ, ᩍᨲᩥ ᨴᩥᩈ᩠ᩅᩣᨶ ᨸᨻ᩠ᨻᨩᩥ.

ᨸᨻ᩠ᨻᨩᩥᨲ᩠ᩅᩣᨶ ᨠᩣᨿᩮᨶ, ᨸᩣᨸᨠᨾ᩠ᨾᩴ ᩅᩥᩅᨩ᩠ᨩᨿᩥ;

ᩅᨧᩦᨴᩩᨧ᩠ᨧᩁᩥᨲᩴ ¶ ᩉᩥᨲ᩠ᩅᩣ, ᩌᨩᩦᩅᩴ ᨸᩁᩥᩈᩮᩣᨵᨿᩥ.

ᩋᨣᨾᩣ ᩁᩣᨩᨣᩉᩴ ᨻᩩᨴ᩠ᨵᩮᩣ, ᨾᨣᨵᩣᨶᩴ ᨣᩥᩁᩥᨻ᩠ᨻᨩᩴ;

ᨸᩥᨱ᩠ᨯᩣᨿ ᩋᨽᩥᩉᩣᩁᩮᩈᩥ, ᩌᨠᩥᨱ᩠ᨱᩅᩁᩃᨠ᩠ᨡᨱᩮᩣ.

ᨲᨾᨴ᩠ᨴᩈᩣ ᨻᩥᨾ᩠ᨻᩥᩈᩣᩁᩮᩣ, ᨸᩣᩈᩣᨴᩈ᩠ᨾᩥᩴ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩮᩣ;

ᨴᩥᩈ᩠ᩅᩣ ᩃᨠ᩠ᨡᨱᩈᨾ᩠ᨸᨶ᩠ᨶᩴ, ᩍᨾᨾᨲ᩠ᨳᩴ ᩋᨽᩣᩈᨳ.

‘‘ᩍᨾᩴ ᨽᩮᩣᨶ᩠ᨲᩮᩣ ᨶᩥᩈᩣᨾᩮᨳ, ᩋᨽᩥᩁᩪᨸᩮᩣ ᨻᩕᩉᩣ ᩈᩩᨧᩥ;

ᨧᩁᨱᩮᨶ ᨧ ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᨿᩩᨣᨾᨲ᩠ᨲᨬ᩠ᨧ ᨸᩮᨠ᩠ᨡᨲᩥ.

‘‘ᩒᨠ᩠ᨡᩥᨲ᩠ᨲᨧᨠ᩠ᨡᩩ ᩈᨲᩥᨾᩣ, ᨶᩣᨿᩴ ᨶᩦᨧᨠᩩᩃᩣᨾᩥᩅ;

ᩁᩣᨩᨴᩪᨲᩣᨽᩥᨵᩣᩅᨶ᩠ᨲᩩ, ᨠᩩᩉᩥᩴ ᨽᩥᨠ᩠ᨡᩩ ᨣᨾᩥᩔᨲᩥ’’.

ᨲᩮ ᨸᩮᩈᩥᨲᩣ ᩁᩣᨩᨴᩪᨲᩣ, ᨸᩥᨭ᩠ᨮᩥᨲᩮᩣ ᩋᨶᩩᨻᨶ᩠ᨵᩥᩈᩩᩴ;

ᨠᩩᩉᩥᩴ ᨣᨾᩥᩔᨲᩥ ᨽᩥᨠ᩠ᨡᩩ, ᨠᨲ᩠ᨳ ᩅᩣᩈᩮᩣ ᨽᩅᩥᩔᨲᩥ.

ᩈᨸᨴᩣᨶᩴ ¶ ᨧᩁᨾᩣᨶᩮᩣ, ᨣᩩᨲ᩠ᨲᨴ᩠ᩅᩣᩁᩮᩣ ᩈᩩᩈᩴᩅᩩᨲᩮᩣ;

ᨡᩥᨸ᩠ᨸᩴ ᨸᨲ᩠ᨲᩴ ᩋᨸᩪᩁᩮᩈᩥ, ᩈᨾ᩠ᨸᨩᩣᨶᩮᩣ ᨸᨭᩥᩔᨲᩮᩣ.

ᨸᩥᨱ᩠ᨯᨧᩣᩁᩴ ¶ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ ᨶᨣᩁᩣ ᨾᩩᨶᩥ;

ᨸᨱ᩠ᨯᩅᩴ ᩋᨽᩥᩉᩣᩁᩮᩈᩥ, ᩑᨲ᩠ᨳ ᩅᩣᩈᩮᩣ ᨽᩅᩥᩔᨲᩥ.

ᨴᩥᩈ᩠ᩅᩣᨶ ᩅᩣᩈᩪᨸᨣᨲᩴ, ᨲᨿᩮᩣ [ᨲᨲᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᨴᩪᨲᩣ ᩏᨸᩣᩅᩥᩈᩩᩴ;

ᨲᩮᩈᩩ ᩑᨠᩮᩣᩅ [ᩑᨠᩮᩣ ᨧ ᨴᩪᨲᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩌᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩁᩣᨩᩥᨶᩮᩣ ᨸᨭᩥᩅᩮᨴᨿᩥ.

‘‘ᩑᩈ ¶ ᨽᩥᨠ᩠ᨡᩩ ᨾᩉᩣᩁᩣᨩ, ᨸᨱ᩠ᨯᩅᩔ ᨸᩩᩁᨲ᩠ᨳᨲᩮᩣ [ᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨻ᩠ᨿᨣ᩠ᨥᩩᩈᨽᩮᩣᩅ, ᩈᩦᩉᩮᩣᩅ ᨣᩥᩁᩥᨣᨻ᩠ᨽᩁᩮ’’.

ᩈᩩᨲ᩠ᩅᩣᨶ ¶ ᨴᩪᨲᩅᨧᨶᩴ, ᨽᨴ᩠ᨴᨿᩣᨶᩮᨶ ᨡᨲ᩠ᨲᩥᨿᩮᩣ;

ᨲᩁᨾᩣᨶᩁᩪᨸᩮᩣ ᨶᩥᨿ᩠ᨿᩣᩈᩥ, ᨿᩮᨶ ᨸᨱ᩠ᨯᩅᨸᨻ᩠ᨻᨲᩮᩣ.

ᩈ ᨿᩣᨶᨽᩪᨾᩥᩴ ᨿᩣᨿᩥᨲ᩠ᩅᩣ, ᨿᩣᨶᩣ ᩒᩁᩩᨿ᩠ᩉ ᨡᨲ᩠ᨲᩥᨿᩮᩣ;

ᨸᨲ᩠ᨲᩥᨠᩮᩣ ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ, ᩌᩈᨩ᩠ᨩ ᨶᩴ ᩏᨸᩣᩅᩥᩈᩥ.

ᨶᩥᩈᨩ᩠ᨩ ᩁᩣᨩᩣ ᩈᨾ᩠ᨾᩮᩣᨴᩥ, ᨠᨳᩴ ᩈᩣᩁᨱᩦᨿᩴ ᨲᨲᩮᩣ;

ᨠᨳᩴ ᩈᩮᩣ ᩅᩦᨲᩥᩈᩣᩁᩮᨲ᩠ᩅᩣ, ᩍᨾᨾᨲ᩠ᨳᩴ ᩋᨽᩣᩈᨳ.

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

ᩅᨱ᩠ᨱᩣᩁᩮᩣᩉᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᨩᩣᨲᩥᨾᩣ ᩅᩥᨿ ᨡᨲ᩠ᨲᩥᨿᩮᩣ.

‘‘ᩈᩮᩣᨽᨿᨶ᩠ᨲᩮᩣ ᩋᨶᩦᨠᨣ᩠ᨣᩴ, ᨶᩣᨣᩈᨦ᩠ᨥᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ;

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

‘‘ᩏᨩᩩᩴ ᨩᨶᨸᨴᩮᩣ ᩁᩣᨩ, ᩉᩥᨾᩅᨶ᩠ᨲᩔ ᨸᩔᨲᩮᩣ;

ᨵᨶᩅᩦᩁᩥᨿᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᨠᩮᩣᩈᩃᩮᩈᩩ [ᨠᩮᩣᩈᩃᩔ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨶᩥᨠᩮᨲᩥᨶᩮᩣ.

‘‘ᩌᨴᩥᨧ᩠ᨧᩣ ¶ ¶ [ᩌᨴᩥᨧ᩠ᨧᩮᩣ (ᨠ.)] ᨶᩣᨾ ᨣᩮᩣᨲ᩠ᨲᩮᨶ, ᩈᩣᨠᩥᨿᩣ [ᩈᩣᨠᩥᨿᩮᩣ (ᨠ.)] ᨶᩣᨾ ᨩᩣᨲᩥᨿᩣ;

ᨲᨾ᩠ᩉᩣ ᨠᩩᩃᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣᨾ᩠ᩉᩥ, ᨶ ᨠᩣᨾᩮ ᩋᨽᩥᨸᨲ᩠ᨳᨿᩴ.

‘‘ᨠᩣᨾᩮᩈ᩠ᩅᩣᨴᩦᨶᩅᩴ ᨴᩥᩈ᩠ᩅᩣ, ᨶᩮᨠ᩠ᨡᨾ᩠ᨾᩴ ᨴᨭ᩠ᨮᩩ ᨡᩮᨾᨲᩮᩣ;

ᨸᨵᩣᨶᩣᨿ ᨣᨾᩥᩔᩣᨾᩥ, ᩑᨲ᩠ᨳ ᨾᩮ ᩁᨬ᩠ᨩᨲᩦ ᨾᨶᩮᩣ’’ᨲᩥ.

ᨸᨻ᩠ᨻᨩ᩠ᨩᩣᩈᩩᨲ᩠ᨲᩴ ᨸᨮᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

‘‘ᨲᩴ ¶ ᨾᩴ ᨸᨵᩣᨶᨸᩉᩥᨲᨲ᩠ᨲᩴ, ᨶᨴᩥᩴ ᨶᩮᩁᨬ᩠ᨩᩁᩴ ᨸᨲᩥ;

ᩅᩥᨸᩁᨠ᩠ᨠᨾ᩠ᨾ ᨫᩣᨿᨶ᩠ᨲᩴ, ᨿᩮᩣᨣᨠ᩠ᨡᩮᨾᩔ ᨸᨲ᩠ᨲᩥᨿᩣ.

‘‘ᨶᨾᩩᨧᩦ ᨠᩁᩩᨱᩴ ᩅᩣᨧᩴ, ᨽᩣᩈᨾᩣᨶᩮᩣ ᩏᨸᩣᨣᨾᩥ;

‘ᨠᩥᩈᩮᩣ ᨲ᩠ᩅᨾᩈᩥ ᨴᩩᨻ᩠ᨻᨱ᩠ᨱᩮᩣ, ᩈᨶ᩠ᨲᩥᨠᩮ ᨾᩁᨱᩴ ᨲᩅ.

‘‘‘ᩈᩉᩔᨽᩣᨣᩮᩣ ¶ ᨾᩁᨱᩔ, ᩑᨠᩴᩈᩮᩣ ᨲᩅ ᨩᩦᩅᩥᨲᩴ;

ᨩᩦᩅ ᨽᩮᩣ ᨩᩦᩅᩥᨲᩴ ᩈᩮᨿ᩠ᨿᩮᩣ, ᨩᩦᩅᩴ ᨸᩩᨬ᩠ᨬᩣᨶᩥ ᨠᩣᩉᩈᩥ.

‘‘‘ᨧᩁᨲᩮᩣ ¶ ᨧ ᨲᩮ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᩋᨣ᩠ᨣᩥᩉᩩᨲ᩠ᨲᨬ᩠ᨧ ᨩᩪᩉᨲᩮᩣ;

ᨸᩉᩪᨲᩴ ᨧᩦᨿᨲᩮ ᨸᩩᨬ᩠ᨬᩴ, ᨠᩥᩴ ᨸᨵᩣᨶᩮᨶ ᨠᩣᩉᩈᩥ.

‘‘‘ᨴᩩᨣ᩠ᨣᩮᩣ ᨾᨣ᩠ᨣᩮᩣ ᨸᨵᩣᨶᩣᨿ, ᨴᩩᨠ᩠ᨠᩁᩮᩣ ᨴᩩᩁᨽᩥᩈᨾ᩠ᨽᩅᩮᩣ’’’;

ᩍᨾᩣ ᨣᩣᨳᩣ ᨽᨱᩴ ᨾᩣᩁᩮᩣ, ᩋᨭ᩠ᨮᩣ ᨻᩩᨴ᩠ᨵᩔ ᩈᨶ᩠ᨲᩥᨠᩮ.

ᨲᩴ ᨲᨳᩣᩅᩣᨴᩥᨶᩴ ᨾᩣᩁᩴ, ᨽᨣᩅᩣ ᩑᨲᨴᨻᩕᩅᩥ;

‘‘ᨸᨾᨲ᩠ᨲᨻᨶ᩠ᨵᩩ ᨸᩣᨸᩥᨾ, ᨿᩮᨶᨲ᩠ᨳᩮᨶ [ᩈᩮᨶᨲ᩠ᨳᩮᨶ (?), ᩋᨲ᩠ᨲᨶᩮᩣ ᩋᨲ᩠ᨳᩮᨶ (ᩋᨭ᩠ᨮ. ᩈᩴᩅᨱ᩠ᨱᨶᩣ)] ᩍᨵᩣᨣᨲᩮᩣ.

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

ᨿᩮᩈᨬ᩠ᨧ ᩋᨲ᩠ᨳᩮᩣ ᨸᩩᨬ᩠ᨬᩮᨶ, ᨲᩮ ᨾᩣᩁᩮᩣ ᩅᨲ᩠ᨲᩩᨾᩁᩉᨲᩥ.

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

ᩑᩅᩴ ᨾᩴ ᨸᩉᩥᨲᨲ᩠ᨲᨾ᩠ᨸᩥ, ᨠᩥᩴ ᨩᩦᩅᨾᨶᩩᨸᩩᨧ᩠ᨨᩈᩥ.

‘‘ᨶᨴᩦᨶᨾᨸᩥ ᩈᩮᩣᨲᩣᨶᩥ, ᩋᨿᩴ ᩅᩣᨲᩮᩣ ᩅᩥᩈᩮᩣᩈᨿᩮ;

ᨠᩥᨬ᩠ᨧ ¶ ᨾᩮ ᨸᩉᩥᨲᨲ᩠ᨲᩔ, ᩃᩮᩣᩉᩥᨲᩴ ᨶᩩᨸᩈᩩᩔᨿᩮ.

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

ᨾᩴᩈᩮᩈᩩ ᨡᩦᨿᨾᩣᨶᩮᩈᩩ, ᨽᩥᨿ᩠ᨿᩮᩣ ᨧᩥᨲ᩠ᨲᩴ ᨸᩈᩦᨴᨲᩥ;

ᨽᩥᨿ᩠ᨿᩮᩣ ᩈᨲᩥ ᨧ ᨸᨬ᩠ᨬᩣ ᨧ, ᩈᨾᩣᨵᩥ ᨾᨾ ᨲᩥᨭ᩠ᨮᨲᩥ.

‘‘ᨲᩔ ᨾᩮᩅᩴ ᩅᩥᩉᩁᨲᩮᩣ, ᨸᨲ᩠ᨲᩔᩩᨲ᩠ᨲᨾᩅᩮᨴᨶᩴ;

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

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

ᨲᨲᩥᨿᩣ ᨡᩩᨸ᩠ᨸᩥᨸᩣᩈᩣ ᨲᩮ, ᨧᨲᩩᨲ᩠ᨳᩦ ᨲᨱ᩠ᩉᩣ ᨸᩅᩩᨧ᩠ᨧᨲᩥ.

‘‘ᨸᨬ᩠ᨧᨾᩴ [ᨸᨬ᩠ᨧᨾᩦ (ᩈᩦ. ᨸᩦ.)] ᨳᩥᨶᨾᩥᨴ᩠ᨵᩴ ᨲᩮ, ᨨᨭ᩠ᨮᩣ ᨽᩦᩁᩪ ᨸᩅᩩᨧ᩠ᨧᨲᩥ;

ᩈᨲ᩠ᨲᨾᩦ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᩣ ᨲᩮ, ᨾᨠ᩠ᨡᩮᩣ ᨳᨾ᩠ᨽᩮᩣ ᨲᩮ ᩋᨭ᩠ᨮᨾᩮᩣ.

‘‘ᩃᩣᨽᩮᩣ ᩈᩥᩃᩮᩣᨠᩮᩣ ᩈᨠ᩠ᨠᩣᩁᩮᩣ, ᨾᩥᨧ᩠ᨨᩣᩃᨴ᩠ᨵᩮᩣ ᨧ ᨿᩮᩣ ᨿᩈᩮᩣ;

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

‘‘ᩑᩈᩣ ¶ ᨶᨾᩩᨧᩥ ᨲᩮ ᩈᩮᨶᩣ, ᨠᨱ᩠ᩉᩔᩣᨽᩥᨸ᩠ᨸᩉᩣᩁᩥᨶᩦ;

ᨶ ᨶᩴ ᩋᩈᩪᩁᩮᩣ ᨩᩥᨶᩣᨲᩥ, ᨩᩮᨲ᩠ᩅᩣ ᨧ ᩃᨽᨲᩮ ᩈᩩᨡᩴ.

‘‘ᩑᩈ ᨾᩩᨬ᩠ᨩᩴ ᨸᩁᩥᩉᩁᩮ, ᨵᩥᩁᨲ᩠ᨳᩩ ᨾᨾ [ᩍᨴ (ᨠ.)] ᨩᩦᩅᩥᨲᩴ;

ᩈᨦ᩠ᨣᩣᨾᩮ ᨾᩮ ᨾᨲᩴ ᩈᩮᨿ᩠ᨿᩮᩣ, ᨿᩴ ᨧᩮ ᨩᩦᩅᩮ ᨸᩁᩣᨩᩥᨲᩮᩣ.

‘‘ᨸᨣᩣᩊ᩠ᩉᩮᨲ᩠ᨳ ¶ ᨶ ᨴᩥᩔᨶ᩠ᨲᩥ, ᩑᨠᩮ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ;

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

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

ᨿᩩᨴ᩠ᨵᩣᨿ ᨸᨧ᩠ᨧᩩᨣ᩠ᨣᨧ᩠ᨨᩣᨾᩥ, ᨾᩣ ᨾᩴ ᨮᩣᨶᩣ ᩋᨧᩣᩅᨿᩥ.

‘‘ᨿᩴ ¶ ᨲᩮ ᨲᩴ ᨶᨸ᩠ᨸᩈᩉᨲᩥ, ᩈᩮᨶᩴ ᩃᩮᩣᨠᩮᩣ ᩈᨴᩮᩅᨠᩮᩣ;

ᨲᩴ ¶ ᨲᩮ ᨸᨬ᩠ᨬᩣᨿ ᨽᩮᨧ᩠ᨨᩣᨾᩥ [ᨣᨧ᩠ᨨᩣᨾᩥ (ᩈᩦ.), ᩅᩮᨧ᩠ᨨᩣᨾᩥ (ᩈ᩠ᨿᩣ.), ᩅᨩ᩠ᨫᩣᨾᩥ (ᨠ.)], ᩌᨾᩴ ᨸᨲ᩠ᨲᩴᩅ ᩋᩈ᩠ᨾᨶᩣ [ᨸᨠ᩠ᨠᩴᩅ ᩋᨾᩩᨶᩣ (ᨠ.)].

‘‘ᩅᩈᩦᨠᩁᩥᨲ᩠ᩅᩣ [ᩅᩈᩥᩴ ᨠᩁᩥᨲ᩠ᩅᩣ (ᨻᩉᩪᩈᩩ)] ᩈᨦ᩠ᨠᨸ᩠ᨸᩴ, ᩈᨲᩥᨬ᩠ᨧ ᩈᩪᨸᨲᩥᨭ᩠ᨮᩥᨲᩴ;

ᩁᨭ᩠ᨮᩣ ᩁᨭ᩠ᨮᩴ ᩅᩥᨧᩁᩥᩔᩴ, ᩈᩣᩅᨠᩮ ᩅᩥᨶᨿᩴ ᨸᩩᨳᩪ.

‘‘ᨲᩮ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩣ ᨸᩉᩥᨲᨲ᩠ᨲᩣ, ᨾᨾ ᩈᩣᩈᨶᨠᩣᩁᨠᩣ;

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

‘‘ᩈᨲ᩠ᨲ ᩅᩔᩣᨶᩥ ᨽᨣᩅᨶ᩠ᨲᩴ, ᩋᨶᩩᨻᨶ᩠ᨵᩥᩴ ᨸᨴᩣᨸᨴᩴ;

ᩒᨲᩣᩁᩴ ᨶᩣᨵᩥᨣᨧ᩠ᨨᩥᩔᩴ, ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩔ ᩈᨲᩦᨾᨲᩮᩣ.

‘‘ᨾᩮᨴᩅᨱ᩠ᨱᩴᩅ ᨸᩣᩈᩣᨱᩴ, ᩅᩣᨿᩈᩮᩣ ᩋᨶᩩᨸᩁᩥᨿᨣᩣ;

ᩋᨸᩮᨲ᩠ᨳ ᨾᩩᨴᩩᩴ [ᨾᩩᨴᩩ (ᩈᩦ.)] ᩅᩥᨶ᩠ᨴᩮᨾ, ᩋᨸᩥ ᩋᩔᩣᨴᨶᩣ ᩈᩥᨿᩣ.

‘‘ᩋᩃᨴ᩠ᨵᩣ ᨲᨲ᩠ᨳ ᩋᩔᩣᨴᩴ, ᩅᩣᨿᩈᩮᨲ᩠ᨲᩮᩣ ᩋᨸᨠ᩠ᨠᨾᩥ;

ᨠᩣᨠᩮᩣᩅ ᩈᩮᩃᨾᩣᩈᨩ᩠ᨩ, ᨶᩥᨻ᩠ᨻᩥᨩ᩠ᨩᩣᨸᩮᨾ ᨣᩮᩣᨲᨾᩴ’’.

ᨲᩔ ¶ ᩈᩮᩣᨠᨸᩁᩮᨲᩔ, ᩅᩦᨱᩣ ᨠᨧ᩠ᨨᩣ ᩋᨽᩔᨳ;

ᨲᨲᩮᩣ ᩈᩮᩣ ᨴᩩᨾ᩠ᨾᨶᩮᩣ ᨿᨠ᩠ᨡᩮᩣ, ᨲᨲ᩠ᨳᩮᩅᨶ᩠ᨲᩁᨵᩣᨿᨳᩣᨲᩥ.

ᩑᩅᩴ ¶ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨩᩮᨲᩅᨶᩮ ᩋᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩔ ᩌᩁᩣᨾᩮ. ᨲᨲᩕ ᨡᩮᩣ ᨽᨣᩅᩣ ᨽᩥᨠ᩠ᨡᩪ ¶ ᩌᨾᨶ᩠ᨲᩮᩈᩥ – ‘‘ᨽᩥᨠ᩠ᨡᩅᩮᩣ’’ᨲᩥ. ‘‘ᨽᨴᨶ᩠ᨲᩮ’’ᨲᩥ ᨲᩮ ᨽᩥᨠ᩠ᨡᩪ ᨽᨣᩅᨲᩮᩣ ᨸᨧ᩠ᨧᩔᩮᩣᩈᩩᩴ. ᨽᨣᩅᩣ ᩑᨲᨴᩅᩮᩣᨧ –

‘‘ᨧᨲᩪᩉᩥ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᩋᨦ᩠ᨣᩮᩉᩥ ᩈᨾᨶ᩠ᨶᩣᨣᨲᩣ ᩅᩣᨧᩣ ᩈᩩᨽᩣᩈᩥᨲᩣ ᩉᩮᩣᨲᩥ, ᨶ ᨴᩩᨻ᩠ᨽᩣᩈᩥᨲᩣ, ᩋᨶᩅᨩ᩠ᨩᩣ ᨧ ᩋᨶᨶᩩᩅᨩ᩠ᨩᩣ ᨧ ᩅᩥᨬ᩠ᨬᩪᨶᩴ. ᨠᨲᨾᩮᩉᩥ ᨧᨲᩪᩉᩥ? ᩍᨵ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨽᩥᨠ᩠ᨡᩩ ᩈᩩᨽᩣᩈᩥᨲᩴᨿᩮᩅ ᨽᩣᩈᨲᩥ ᨶᩮᩣ ᨴᩩᨻ᩠ᨽᩣᩈᩥᨲᩴ, ᨵᨾ᩠ᨾᩴᨿᩮᩅ ᨽᩣᩈᨲᩥ ᨶᩮᩣ ᩋᨵᨾ᩠ᨾᩴ, ᨸᩥᨿᩴᨿᩮᩅ ᨽᩣᩈᨲᩥ ᨶᩮᩣ ᩋᨸ᩠ᨸᩥᨿᩴ, ᩈᨧ᩠ᨧᩴᨿᩮᩅ ᨽᩣᩈᨲᩥ ᨶᩮᩣ ᩋᩃᩥᨠᩴ. ᩍᨾᩮᩉᩥ ᨡᩮᩣ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨧᨲᩪᩉᩥ ᩋᨦ᩠ᨣᩮᩉᩥ ᩈᨾᨶ᩠ᨶᩣᨣᨲᩣ ᩅᩣᨧᩣ ᩈᩩᨽᩣᩈᩥᨲᩣ ᩉᩮᩣᨲᩥ, ᨶᩮᩣ ᨴᩩᨻ᩠ᨽᩣᩈᩥᨲᩣ, ᩋᨶᩅᨩ᩠ᨩᩣ ᨧ ᩋᨶᨶᩩᩅᨩ᩠ᨩᩣ ᨧ ᩅᩥᨬ᩠ᨬᩪᨶ’’ᨶ᩠ᨲᩥ. ᩍᨴᨾᩅᩮᩣᨧ ᨽᨣᩅᩣ. ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᩈᩩᨣᨲᩮᩣ ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᩈᩩᨽᩣᩈᩥᨲᩴ ᩏᨲ᩠ᨲᨾᨾᩣᩉᩩ ᩈᨶ᩠ᨲᩮᩣ, ᨵᨾ᩠ᨾᩴ ᨽᨱᩮ ᨶᩣᨵᨾ᩠ᨾᩴ ᨲᩴ ᨴᩩᨲᩥᨿᩴ;

ᨸᩥᨿᩴ ᨽᨱᩮ ᨶᩣᨸ᩠ᨸᩥᨿᩴ ᨲᩴ ᨲᨲᩥᨿᩴ, ᩈᨧ᩠ᨧᩴ ᨽᨱᩮ ᨶᩣᩃᩥᨠᩴ ᨲᩴ ᨧᨲᩩᨲ᩠ᨳ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ¶ ᨡᩮᩣ ᩌᨿᩈ᩠ᨾᩣ ᩅᨦ᩠ᨣᩦᩈᩮᩣ ᩏᨭ᩠ᨮᩣᨿᩣᩈᨶᩣ ᩑᨠᩴᩈᩴ ᨧᩦᩅᩁᩴ ᨠᨲ᩠ᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᨬ᩠ᨩᩃᩥᩴ ᨸᨱᩣᨾᩮᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨸᨭᩥᨽᩣᨲᩥ ᨾᩴ ᨽᨣᩅᩣ, ᨸᨭᩥᨽᩣᨲᩥ ᨾᩴ ᩈᩩᨣᨲᩣ’’ᨲᩥ. ‘‘ᨸᨭᩥᨽᩣᨲᩩ ᨲᩴ ᩅᨦ᩠ᨣᩦᩈᩣ’’ᨲᩥ ᨽᨣᩅᩣ ᩋᩅᩮᩣᨧ. ᩋᨳ ᨡᩮᩣ ᩌᨿᩈ᩠ᨾᩣ ᩅᨦ᩠ᨣᩦᩈᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩈᨾ᩠ᨾᩩᨡᩣ ᩈᩣᩁᩩᨸ᩠ᨸᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨽᩥᨲ᩠ᨳᩅᩥ –

‘‘ᨲᨾᩮᩅ ᩅᩣᨧᩴ ᨽᩣᩈᩮᨿ᩠ᨿ, ᨿᩣᨿᨲ᩠ᨲᩣᨶᩴ ᨶ ᨲᩣᨸᨿᩮ;

ᨸᩁᩮ ¶ ᨧ ᨶ ᩅᩥᩉᩥᩴᩈᩮᨿ᩠ᨿ, ᩈᩣ ᩅᩮ ᩅᩣᨧᩣ ᩈᩩᨽᩣᩈᩥᨲᩣ.

‘‘ᨸᩥᨿᩅᩣᨧᨾᩮᩅ ᨽᩣᩈᩮᨿ᩠ᨿ, ᨿᩣ ᩅᩣᨧᩣ ᨸᨭᩥᨶᨶ᩠ᨴᩥᨲᩣ;

ᨿᩴ ᩋᨶᩣᨴᩣᨿ ᨸᩣᨸᩣᨶᩥ, ᨸᩁᩮᩈᩴ ᨽᩣᩈᨲᩮ ᨸᩥᨿᩴ.

‘‘ᩈᨧ᩠ᨧᩴ ᩅᩮ ᩋᨾᨲᩣ ᩅᩣᨧᩣ, ᩑᩈ ᨵᨾ᩠ᨾᩮᩣ ᩈᨶᨶ᩠ᨲᨶᩮᩣ;

ᩈᨧ᩠ᨧᩮ ᩋᨲ᩠ᨳᩮ ᨧ ᨵᨾ᩠ᨾᩮ ᨧ, ᩌᩉᩩ ᩈᨶ᩠ᨲᩮᩣ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨿᩴ ¶ ¶ ᨻᩩᨴ᩠ᨵᩮᩣ ᨽᩣᩈᨲᩥ ᩅᩣᨧᩴ, ᨡᩮᨾᩴ ᨶᩥᨻ᩠ᨻᩣᨶᨸᨲ᩠ᨲᩥᨿᩣ;

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

ᩈᩩᨽᩣᩈᩥᨲᩈᩩᨲ᩠ᨲᩴ ᨲᨲᩥᨿᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩑᩅᩴ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᨠᩮᩣᩈᩃᩮᩈᩩ ᩅᩥᩉᩁᨲᩥ ᩈᩩᨶ᩠ᨴᩁᩥᨠᩣᨿ ᨶᨴᩥᨿᩣ ᨲᩦᩁᩮ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᩣᨿ ᨶᨴᩥᨿᩣ ᨲᩦᩁᩮ ᩋᨣ᩠ᨣᩥᩴ ᨩᩩᩉᨲᩥ, ᩋᨣ᩠ᨣᩥᩉᩩᨲ᩠ᨲᩴ ᨸᩁᩥᨧᩁᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩋᨣ᩠ᨣᩥᩴ ᨩᩩᩉᩥᨲ᩠ᩅᩣ ᩋᨣ᩠ᨣᩥᩉᩩᨲ᩠ᨲᩴ ᨸᩁᩥᨧᩁᩥᨲ᩠ᩅᩣ ᩏᨭ᩠ᨮᩣᨿᩣᩈᨶᩣ ᩈᨾᨶ᩠ᨲᩣ ᨧᨲᩩᨴ᩠ᨴᩥᩈᩣ ᩋᨶᩩᩅᩥᩃᩮᩣᨠᩮᩈᩥ – ‘‘ᨠᩮᩣ ᨶᩩ ᨡᩮᩣ ᩍᨾᩴ ᩉᨻ᩠ᨿᩈᩮᩈᩴ ᨽᩩᨬ᩠ᨩᩮᨿ᩠ᨿᩣ’’ᨲᩥ? ᩋᨴ᩠ᨴᩈᩣ ᨡᩮᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩋᩅᩥᨴᩪᩁᩮ ᩋᨬ᩠ᨬᨲᩁᩈ᩠ᨾᩥᩴ ᩁᩩᨠ᩠ᨡᨾᩪᩃᩮ ᩈᩈᩦᩈᩴ ᨸᩣᩁᩩᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩴ; ᨴᩥᩈ᩠ᩅᩣᨶ ᩅᩣᨾᩮᨶ ᩉᨲ᩠ᨳᩮᨶ ᩉᨻ᩠ᨿᩈᩮᩈᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᨴᨠ᩠ᨡᩥᨱᩮᨶ ᩉᨲ᩠ᨳᩮᨶ ᨠᨾᨱ᩠ᨯᩃᩩᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ.

ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨸᨴᩈᨴ᩠ᨴᩮᨶ ᩈᩦᩈᩴ ¶ ᩅᩥᩅᩁᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ – ‘‘ᨾᩩᨱ᩠ᨯᩮᩣ ᩋᨿᩴ ᨽᩅᩴ, ᨾᩩᨱ᩠ᨯᨠᩮᩣ ᩋᨿᩴ ᨽᩅ’’ᨶ᩠ᨲᩥ ᨲᨲᩮᩣᩅ ᨸᩩᨶ ᨶᩥᩅᨲ᩠ᨲᩥᨲᩩᨠᩣᨾᩮᩣ ᩋᩉᩮᩣᩈᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᨾᩩᨱ᩠ᨯᩣᨸᩥ ᩉᩥ ᩍᨵᩮᨠᨧ᩠ᨧᩮ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨽᩅᨶ᩠ᨲᩥ, ᨿᩴᨶᩪᨶᩣᩉᩴ ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨩᩣᨲᩥᩴ ᨸᩩᨧ᩠ᨨᩮᨿ᩠ᨿ’’ᨶ᩠ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩥᩴᨩᨧ᩠ᨧᩮᩣ ᨽᩅ’’ᨶ᩠ᨲᩥ?

ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᨣᩣᨳᩣᩉᩥ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨶᩮᩣᨾ᩠ᩉᩥ ᨶ ᩁᩣᨩᨸᩩᨲ᩠ᨲᩮᩣ, ᨶ ᩅᩮᩔᩣᨿᨶᩮᩣ ᩏᨴ ᨠᩮᩣᨧᩥ ᨶᩮᩣᨾ᩠ᩉᩥ;

ᨣᩮᩣᨲ᩠ᨲᩴ ᨸᩁᩥᨬ᩠ᨬᩣᨿ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩣᨶᩴ, ᩋᨠᩥᨬ᩠ᨧᨶᩮᩣ ᨾᨶ᩠ᨲ ᨧᩁᩣᨾᩥ ᩃᩮᩣᨠᩮ.

‘‘ᩈᨦ᩠ᨥᩣᨭᩥᩅᩣᩈᩦ ¶ ¶ ᩋᨣᩉᩮᩣ ᨧᩁᩣᨾᩥ [ᩋᨣᩥᩉᩮᩣ (ᨠ. ᩈᩦ. ᨸᩦ.) ᩋᨣᩮᩉᩮᩣ (ᨠᨲ᩠ᨳᨧᩥ)], ᨶᩥᩅᩩᨲ᩠ᨲᨠᩮᩈᩮᩣ ᩋᨽᩥᨶᩥᨻ᩠ᨻᩩᨲᨲ᩠ᨲᩮᩣ;

ᩋᩃᩥᨸ᩠ᨸᨾᩣᨶᩮᩣ ᩍᨵ ᨾᩣᨱᩅᩮᩉᩥ, ᩋᨠᩃ᩠ᩃᩴ ᨾᩴ ᨻᩕᩣᩉ᩠ᨾᨱ ᨸᩩᨧ᩠ᨨᩈᩥ ᨣᩮᩣᨲ᩠ᨲᨸᨬ᩠ᩉᩴ’’.

‘‘ᨸᩩᨧ᩠ᨨᨶ᩠ᨲᩥ ¶ ᩅᩮ ᨽᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩮᨽᩥ ᩈᩉ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨶᩮᩣ ᨽᩅ’’ᨶ᩠ᨲᩥ.

‘‘ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩥ ᨧᩮ ᨲ᩠ᩅᩴ ᨻᩕᩪᩈᩥ, ᨾᨬ᩠ᨧ ᨻᩕᩪᩈᩥ ᩋᨻᩕᩣᩉ᩠ᨾᨱᩴ;

ᨲᩴ ᨲᩴ ᩈᩣᩅᩥᨲ᩠ᨲᩥᩴ ᨸᩩᨧ᩠ᨨᩣᨾᩥ, ᨲᩥᨸᨴᩴ ᨧᨲᩩᩅᩦᩈᨲᨠ᩠ᨡᩁᩴ.

‘‘ᨠᩥᩴ ¶ ᨶᩥᩔᩥᨲᩣ ᩍᩈᨿᩮᩣ ᨾᨶᩩᨩᩣ, ᨡᨲ᩠ᨲᩥᨿᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩣ [ᨸᨮᨾᨸᩣᨴᨶ᩠ᨲᩮᩣ] ᨴᩮᩅᨲᩣᨶᩴ;

ᨿᨬ᩠ᨬᨾᨠᨸ᩠ᨸᨿᩥᩴᩈᩩ ᨸᩩᨳᩪ ᩍᨵ ᩃᩮᩣᨠᩮ [ᨴᩩᨲᩥᨿᨸᩣᨴᨶ᩠ᨲᩮᩣ (ᩈᩦ.)].

‘‘ᨿᨴᨶ᩠ᨲᨣᩪ ᩅᩮᨴᨣᩪ ᨿᨬ᩠ᨬᨠᩣᩃᩮ, ᨿᩔᩣᩉᩩᨲᩥᩴ ᩃᨽᩮ ᨲᩔᩥᨩ᩠ᨫᩮᨲᩥ ᨻᩕᩪᨾᩥ’’.

‘‘ᩋᨴ᩠ᨵᩣ ᩉᩥ ᨲᩔ ᩉᩩᨲᨾᩥᨩ᩠ᨫᩮ, (ᩍᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ)

ᨲᩩᨾ᩠ᩉᩣᨴᩥᩈᩣᨶᨬ᩠ᩉᩥ ᩋᨴᩔᨶᩮᨶ, ᩋᨬ᩠ᨬᩮᩣ ᨩᨶᩮᩣ ᨽᩩᨬ᩠ᨩᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ’’.

‘‘ᨲᩈ᩠ᨾᩣᨲᩥᩉ ᨲ᩠ᩅᩴ ᨻᩕᩣᩉ᩠ᨾᨱ ᩋᨲ᩠ᨳᩮᨶ, ᩋᨲ᩠ᨳᩥᨠᩮᩣ ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ ᨸᩩᨧ᩠ᨨ;

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

‘‘ᨿᨬ᩠ᨬᩮ ᩁᨲᩮᩣᩉᩴ ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᨿᨬ᩠ᨬᩴ ᨿᩥᨭ᩠ᨮᩩᨠᩣᨾᩮᩣ ᨶᩣᩉᩴ ᨸᨩᩣᨶᩣᨾᩥ;

ᩋᨶᩩᩈᩣᩈᨲᩩ ᨾᩴ ᨽᩅᩴ, ᨿᨲ᩠ᨳ ¶ ᩉᩩᨲᩴ ᩍᨩ᩠ᨫᨲᩮ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ’’.

‘‘ᨲᩮᨶ ᩉᩥ ᨲ᩠ᩅᩴ, ᨻᩕᩣᩉ᩠ᨾᨱ, ᩒᨴᩉᩔᩩ ᩈᩮᩣᨲᩴ; ᨵᨾ᩠ᨾᩴ ᨲᩮ ᨴᩮᩈᩮᩔᩣᨾᩥ –

‘‘ᨾᩣ ¶ ᨩᩣᨲᩥᩴ ᨸᩩᨧ᩠ᨨᩦ ᨧᩁᨱᨬ᩠ᨧ ᨸᩩᨧ᩠ᨨ, ᨠᨭ᩠ᨮᩣ ᩉᩅᩮ ᨩᩣᨿᨲᩥ ᨩᩣᨲᩅᩮᨴᩮᩣ;

ᨶᩦᨧᩣᨠᩩᩃᩦᨶᩮᩣᨸᩥ ¶ ᨾᩩᨶᩦ ᨵᩥᨲᩦᨾᩣ, ᩌᨩᩣᨶᩥᨿᩮᩣ ᩉᩮᩣᨲᩥ ᩉᩥᩁᩦᨶᩥᩈᩮᨵᩮᩣ.

‘‘ᩈᨧ᩠ᨧᩮᨶ ᨴᨶ᩠ᨲᩮᩣ ᨴᨾᩈᩣ ᩏᨸᩮᨲᩮᩣ, ᩅᩮᨴᨶ᩠ᨲᨣᩪ ᩅᩪᩈᩥᨲᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩮᩣ;

ᨠᩣᩃᩮᨶ ᨲᨾ᩠ᩉᩥ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ [ᨸᩩᨬ᩠ᨬᨸᩮᨡᩮᩣ (ᩈᩦ. ᨸᩦ.)] ᨿᨩᩮᨳ.

‘‘ᨿᩮ ¶ ᨠᩣᨾᩮ ᩉᩥᨲ᩠ᩅᩣ ᩋᨣᩉᩣ ᨧᩁᨶ᩠ᨲᩥ, ᩈᩩᩈᨬ᩠ᨬᨲᨲ᩠ᨲᩣ ᨲᩈᩁᩴᩅ ᩏᨩ᩠ᨩᩩᩴ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮ ᩅᩦᨲᩁᩣᨣᩣ ᩈᩩᩈᨾᩣᩉᩥᨲᩥᨶ᩠ᨴᩕᩥᨿᩣ, ᨧᨶ᩠ᨴᩮᩣᩅ ᩁᩣᩉᩩᨣ᩠ᨣᩉᨱᩣ ᨸᨾᩩᨲ᩠ᨲᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

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

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮᩣ ᨠᩣᨾᩮ ᩉᩥᨲ᩠ᩅᩣ ᩋᨽᩥᨽᩩᨿ᩠ᨿᨧᩣᩁᩦ, ᨿᩮᩣ ᩅᩮᨴᩥ ᨩᩣᨲᩦᨾᩁᨱᩔ ᩋᨶ᩠ᨲᩴ;

ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ ¶ ᩏᨴᨠᩁᩉᨴᩮᩣᩅ ᩈᩦᨲᩮᩣ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᩈᨾᩮᩣ ¶ ᩈᨾᩮᩉᩥ ᩅᩥᩈᨾᩮᩉᩥ ᨴᩪᩁᩮ, ᨲᨳᩣᨣᨲᩮᩣ ᩉᩮᩣᨲᩥ ᩋᨶᨶ᩠ᨲᨸᨬ᩠ᨬᩮᩣ;

ᩋᨶᩪᨸᩃᩥᨲ᩠ᨲᩮᩣ ᩍᨵ ᩅᩣ ᩉᩩᩁᩴ ᩅᩣ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᨿᨾ᩠ᩉᩥ ¶ ᨶ ᨾᩣᨿᩣ ᩅᩈᨲᩥ ᨶ ᨾᩣᨶᩮᩣ, ᨿᩮᩣ ᩅᩦᨲᩃᩮᩣᨽᩮᩣ ᩋᨾᨾᩮᩣ ᨶᩥᩁᩣᩈᩮᩣ;

ᨸᨶᩩᨱ᩠ᨱᨠᩮᩣᨵᩮᩣ ᩋᨽᩥᨶᩥᨻ᩠ᨻᩩᨲᨲ᩠ᨲᩮᩣ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩈᩮᩣᨠᨾᩃᩴ ᩋᩉᩣᩈᩥ;

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

ᩋᨶᩩᨸᩣᨴᩥᨿᩣᨶᩮᩣ ᩍᨵ ᩅᩣ ᩉᩩᩁᩴ ᩅᩣ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᩈᨾᩣᩉᩥᨲᩮᩣ ᨿᩮᩣ ᩏᨴᨲᩣᩁᩥ ᩒᨥᩴ, ᨵᨾ᩠ᨾᩴ ᨧᨬ᩠ᨬᩣᩈᩥ ᨸᩁᨾᩣᨿ ᨴᩥᨭ᩠ᨮᩥᨿᩣ;

ᨡᩦᨱᩣᩈᩅᩮᩣ ᩋᨶ᩠ᨲᩥᨾᨴᩮᩉᨵᩣᩁᩦ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᨽᩅᩣᩈᩅᩣ ᨿᩔ ᩅᨧᩦ ᨡᩁᩣ ᨧ, ᩅᩥᨵᩪᨸᩥᨲᩣ ᩋᨲ᩠ᨳᨣᨲᩣ ᨶ ᩈᨶ᩠ᨲᩥ;

ᩈ ᩅᩮᨴᨣᩪ ᩈᨻ᩠ᨻᨵᩥ ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩮᩣ, ᨲᨳᩣᨣᨲᩮᩣ ¶ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᩈᨦ᩠ᨣᩣᨲᩥᨣᩮᩣ ᨿᩔ ᨶ ᩈᨶ᩠ᨲᩥ ᩈᨦ᩠ᨣᩣ, ᨿᩮᩣ ᨾᩣᨶᩈᨲ᩠ᨲᩮᩈᩩ ᩋᨾᩣᨶᩈᨲ᩠ᨲᩮᩣ;

ᨴᩩᨠ᩠ᨡᩴ ¶ ᨸᩁᩥᨬ᩠ᨬᩣᨿ ᩈᨡᩮᨲ᩠ᨲᩅᨲ᩠ᨳᩩᩴ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᩌᩈᩴ ¶ ᩋᨶᩥᩔᩣᨿ ᩅᩥᩅᩮᨠᨴᩔᩦ, ᨸᩁᩅᩮᨴᩥᨿᩴ ᨴᩥᨭ᩠ᨮᩥᨾᩩᨸᩣᨲᩥᩅᨲ᩠ᨲᩮᩣ;

ᩌᩁᨾ᩠ᨾᨱᩣ ᨿᩔ ᨶ ᩈᨶ᩠ᨲᩥ ᨠᩮᨧᩥ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

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

ᩈᨶ᩠ᨲᩮᩣ ᩏᨸᩣᨴᩣᨶᨡᨿᩮ ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᩈᩴᨿᩮᩣᨩᨶᩴ ¶ ᨩᩣᨲᩥᨡᨿᨶ᩠ᨲᨴᩔᩦ, ᨿᩮᩣᨸᩣᨶᩩᨴᩥ ᩁᩣᨣᨸᨳᩴ ᩋᩈᩮᩈᩴ;

ᩈᩩᨴ᩠ᨵᩮᩣ ᨶᩥᨴᩮᩣᩈᩮᩣ ᩅᩥᨾᩃᩮᩣ ᩋᨠᩣᨧᩮᩣ [ᩋᨠᩣᨾᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᨲᨳᩣᨣᨲᩮᩣ ¶ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᨿᩮᩣ ᩋᨲ᩠ᨲᨶᩮᩣ ᩋᨲ᩠ᨲᩣᨶᩴ [ᩋᨲ᩠ᨲᨶᩣᨲ᩠ᨲᩣᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨶᩣᨶᩩᨸᩔᨲᩥ, ᩈᨾᩣᩉᩥᨲᩮᩣ ᩏᨩ᩠ᨩᩩᨣᨲᩮᩣ ᨮᩥᨲᨲ᩠ᨲᩮᩣ;

ᩈ ᩅᩮ ᩋᨶᩮᨩᩮᩣ ᩋᨡᩥᩃᩮᩣ ᩋᨠᨦ᩠ᨡᩮᩣ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ.

‘‘ᨾᩮᩣᩉᨶ᩠ᨲᩁᩣ ᨿᩔ ᨶ ᩈᨶ᩠ᨲᩥ ᨠᩮᨧᩥ, ᩈᨻ᩠ᨻᩮᩈᩩ ᨵᨾ᩠ᨾᩮᩈᩩ ᨧ ᨬᩣᨱᨴᩔᩦ;

ᩈᩁᩦᩁᨬ᩠ᨧ ᩋᨶ᩠ᨲᩥᨾᩴ ᨵᩣᩁᩮᨲᩥ, ᨸᨲ᩠ᨲᩮᩣ ᨧ ᩈᨾ᩠ᨻᩮᩣᨵᩥᨾᨶᩩᨲ᩠ᨲᩁᩴ ᩈᩥᩅᩴ;

ᩑᨲ᩠ᨲᩣᩅᨲᩣ ᨿᨠ᩠ᨡᩔ ᩈᩩᨴ᩠ᨵᩥ, ᨲᨳᩣᨣᨲᩮᩣ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ’’.

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

ᨻᩕᩉ᩠ᨾᩣ ᩉᩥ ᩈᨠ᩠ᨡᩥ ᨸᨭᩥᨣᨱ᩠ᩉᩣᨲᩩ ᨾᩮ ᨽᨣᩅᩣ, ᨽᩩᨬ᩠ᨩᨲᩩ ᨾᩮ ᨽᨣᩅᩣ ᨸᩪᩁᩊᩣᩈᩴ’’.

‘‘ᨣᩣᨳᩣᨽᩥᨣᩦᨲᩴ ᨾᩮ ᩋᨽᩮᩣᨩᨶᩮᨿ᩠ᨿᩴ, ᩈᨾ᩠ᨸᩔᨲᩴ ᨻᩕᩣᩉ᩠ᨾᨱ ᨶᩮᩈ ᨵᨾ᩠ᨾᩮᩣ;

ᨣᩣᨳᩣᨽᩥᨣᩦᨲᩴ ᨸᨶᩩᨴᨶ᩠ᨲᩥ ᨻᩩᨴ᩠ᨵᩣ, ᨵᨾ᩠ᨾᩮ ᩈᨲᩦ ᨻᩕᩣᩉ᩠ᨾᨱ ᩅᩩᨲ᩠ᨲᩥᩁᩮᩈᩣ.

‘‘ᩋᨬ᩠ᨬᩮᨶ ᨧ ᨠᩮᩅᩃᩥᨶᩴ ᨾᩉᩮᩈᩥᩴ, ᨡᩦᨱᩣᩈᩅᩴ ᨠᩩᨠ᩠ᨠᩩᨧ᩠ᨧᩅᩪᨸᩈᨶ᩠ᨲᩴ;

ᩋᨶ᩠ᨶᩮᨶ ᨸᩣᨶᩮᨶ ᩏᨸᨭ᩠ᨮᩉᩔᩩ, ᨡᩮᨲ᩠ᨲᨬ᩠ᩉᩥ ᨲᩴ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩔ ᩉᩮᩣᨲᩥ’’.

‘‘ᩈᩣᨵᩣᩉᩴ ¶ ¶ ᨽᨣᩅᩣ ᨲᨳᩣ ᩅᩥᨩᨬ᩠ᨬᩴ, ᨿᩮᩣ ᨴᨠ᩠ᨡᩥᨱᩴ ᨽᩩᨬ᩠ᨩᩮᨿ᩠ᨿ ᨾᩣᨴᩥᩈᩔ;

ᨿᩴ ᨿᨬ᩠ᨬᨠᩣᩃᩮ ᨸᩁᩥᨿᩮᩈᨾᩣᨶᩮᩣ, ᨸᨸ᩠ᨸᩩᨿ᩠ᨿ ᨲᩅ ᩈᩣᩈᨶᩴ’’.

‘‘ᩈᩣᩁᨾ᩠ᨽᩣ ᨿᩔ ᩅᩥᨣᨲᩣ, ᨧᩥᨲ᩠ᨲᩴ ᨿᩔ ᩋᨶᩣᩅᩥᩃᩴ;

ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩮᩣ ᨧ ᨠᩣᨾᩮᩉᩥ, ᨳᩥᨶᩴ ᨿᩔ ᨸᨶᩪᨴᩥᨲᩴ.

‘‘ᩈᩦᨾᨶ᩠ᨲᩣᨶᩴ ¶ ᩅᩥᨶᩮᨲᩣᩁᩴ, ᨩᩣᨲᩥᨾᩁᨱᨠᩮᩣᩅᩥᨴᩴ;

ᨾᩩᨶᩥᩴ ᨾᩮᩣᨶᩮᨿ᩠ᨿᩈᨾ᩠ᨸᨶ᩠ᨶᩴ, ᨲᩣᨴᩥᩈᩴ ᨿᨬ᩠ᨬᨾᩣᨣᨲᩴ.

‘‘ᨽᨠᩩᨭᩥᩴ [ᨽᩪᨠᩩᨭᩥᩴ (ᨠ. ᩈᩦ.), ᨽᩣᨠᩩᨭᩥᩴ (ᨠ. ᩈᩦ., ᨾ. ᨶᩥ. ᪑.᪒᪒᪖)] ᩅᩥᨶᨿᩥᨲ᩠ᩅᩣᨶ, ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᨶᨾᩔᨳ;

ᨸᩪᨩᩮᨳ ᩋᨶ᩠ᨶᨸᩣᨶᩮᨶ, ᩑᩅᩴ ᩍᨩ᩠ᨫᨶ᩠ᨲᩥ ᨴᨠ᩠ᨡᩥᨱᩣ.

‘‘ᨻᩩᨴ᩠ᨵᩮᩣ ¶ ᨽᩅᩴ ᩋᩁᩉᨲᩥ ᨸᩪᩁᩊᩣᩈᩴ, ᨸᩩᨬ᩠ᨬᨡᩮᨲ᩠ᨲᨾᨶᩩᨲ᩠ᨲᩁᩴ;

ᩌᨿᩣᨣᩮᩣ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩔ, ᨽᩮᩣᨲᩮᩣ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ! ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᨶᩥᨠ᩠ᨠᩩᨩ᩠ᨩᩥᨲᩴ ᩅᩣ ᩏᨠ᩠ᨠᩩᨩ᩠ᨩᩮᨿ᩠ᨿ, ᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᩴ ᩅᩣ ᩅᩥᩅᩁᩮᨿ᩠ᨿ, ᨾᩪᩊ᩠ᩉᩔ ᩅᩣ ᨾᨣ᩠ᨣᩴ ᩌᨧᩥᨠ᩠ᨡᩮᨿ᩠ᨿ, ᩋᨶ᩠ᨵᨠᩣᩁᩮ ᩅᩣ ᨲᩮᩃᨸᨩ᩠ᨩᩮᩣᨲᩴ ᨵᩣᩁᩮᨿ᩠ᨿ – ᨧᨠ᩠ᨡᩩᨾᨶ᩠ᨲᩮᩣ ᩁᩪᨸᩣᨶᩥ ᨴᨠ᩠ᨡᨶ᩠ᨲᩦᨲᩥ; ᩑᩅᨾᩮᩅᩴ ᨽᩮᩣᨲᩣ ᨣᩮᩣᨲᨾᩮᨶ ᩋᨶᩮᨠᨸᩁᩥᨿᩣᨿᩮᨶ ᨵᨾ᩠ᨾᩮᩣ ᨸᨠᩣᩈᩥᨲᩮᩣ. ᩑᩈᩣᩉᩴ ᨽᩅᨶ᩠ᨲᩴ ᨣᩮᩣᨲᨾᩴ ᩈᩁᨱᩴ ᨣᨧ᩠ᨨᩣᨾᩥ ᨵᨾ᩠ᨾᨬ᩠ᨧ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᨬ᩠ᨧ. ᩃᨽᩮᨿ᩠ᨿᩣᩉᩴ ᨽᩮᩣᨲᩮᩣ ᨣᩮᩣᨲᨾᩔ ᩈᨶ᩠ᨲᩥᨠᩮ ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ, ᩃᨽᩮᨿ᩠ᨿᩴ ᩏᨸᩈᨾ᩠ᨸᨴ’’ᨶ᩠ᨲᩥ. ᩋᩃᨲ᩠ᨳ ᨡᩮᩣ ¶ ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ…ᨸᩮ… ᩋᩁᩉᨲᩴ ᩋᩉᩮᩣᩈᩦᨲᩥ.

ᩈᩩᨶ᩠ᨴᩁᩥᨠᨽᩣᩁᨴ᩠ᩅᩣᨩᩈᩩᨲ᩠ᨲᩴ ᨧᨲᩩᨲ᩠ᨳᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩑᩅᩴ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩁᩣᨩᨣᩉᩮ ᩅᩥᩉᩁᨲᩥ ᨣᩥᨩ᩠ᨫᨠᩪᨭᩮ ᨸᨻ᩠ᨻᨲᩮ. ᩋᨳ ᨡᩮᩣ ᨾᩣᨥᩮᩣ ᨾᩣᨱᩅᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ¶ ᨽᨣᩅᨲᩣ ᩈᨴ᩠ᨵᩥᩴ ᩈᨾ᩠ᨾᩮᩣᨴᩥ. ᩈᨾ᩠ᨾᩮᩣᨴᨶᩦᨿᩴ ᨠᨳᩴ ᩈᩣᩁᨱᩦᨿᩴ ᩅᩦᨲᩥᩈᩣᩁᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᨾᩣᨥᩮᩣ ᨾᩣᨱᩅᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ¶ ᩑᨲᨴᩅᩮᩣᨧ –

‘‘ᩋᩉᨬ᩠ᩉᩥ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᨴᩣᨿᨠᩮᩣ ᨴᩣᨶᨸᨲᩥ ᩅᨴᨬ᩠ᨬᩪ ᨿᩣᨧᨿᩮᩣᨣᩮᩣ; ᨵᨾ᩠ᨾᩮᨶ ᨽᩮᩣᨣᩮ ᨸᩁᩥᨿᩮᩈᩣᨾᩥ; ᨵᨾ᩠ᨾᩮᨶ ᨽᩮᩣᨣᩮ ᨸᩁᩥᨿᩮᩈᩥᨲ᩠ᩅᩣ ᨵᨾ᩠ᨾᩃᨴ᩠ᨵᩮᩉᩥ ᨽᩮᩣᨣᩮᩉᩥ ᨵᨾ᩠ᨾᩣᨵᩥᨣᨲᩮᩉᩥ ᩑᨠᩔᨸᩥ ᨴᨴᩣᨾᩥ ᨴ᩠ᩅᩥᨶ᩠ᨶᨾ᩠ᨸᩥ ¶ ᨲᩥᨱ᩠ᨱᨾ᩠ᨸᩥ ᨧᨲᩩᨶ᩠ᨶᨾ᩠ᨸᩥ ᨸᨬ᩠ᨧᨶ᩠ᨶᨾ᩠ᨸᩥ ᨨᨶ᩠ᨶᨾ᩠ᨸᩥ ᩈᨲ᩠ᨲᨶ᩠ᨶᨾ᩠ᨸᩥ ᩋᨭ᩠ᨮᨶ᩠ᨶᨾ᩠ᨸᩥ ᨶᩅᨶ᩠ᨶᨾ᩠ᨸᩥ ᨴᩈᨶ᩠ᨶᨾ᩠ᨸᩥ ᨴᨴᩣᨾᩥ, ᩅᩦᩈᩣᨿᨸᩥ ᨲᩥᩴᩈᩣᨿᨸᩥ ᨧᨲ᩠ᨲᩣᩃᩦᩈᩣᨿᨸᩥ ᨸᨬ᩠ᨬᩣᩈᩣᨿᨸᩥ ᨴᨴᩣᨾᩥ, ᩈᨲᩔᨸᩥ ᨴᨴᩣᨾᩥ, ᨽᩥᨿ᩠ᨿᩮᩣᨸᩥ ᨴᨴᩣᨾᩥ. ᨠᨧ᩠ᨧᩣᩉᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᩑᩅᩴ ᨴᨴᨶ᩠ᨲᩮᩣ ᩑᩅᩴ ᨿᨩᨶ᩠ᨲᩮᩣ ᨻᩉᩩᩴ ᨸᩩᨬ᩠ᨬᩴ ᨸᩈᩅᩣᨾᩦ’’ᨲᩥ ¶ ?

‘‘ᨲᨣ᩠ᨥ ᨲ᩠ᩅᩴ, ᨾᩣᨱᩅ, ᩑᩅᩴ ᨴᨴᨶ᩠ᨲᩮᩣ ᩑᩅᩴ ᨿᨩᨶ᩠ᨲᩮᩣ ᨻᩉᩩᩴ ᨸᩩᨬ᩠ᨬᩴ ᨸᩈᩅᩈᩥ. ᨿᩮᩣ ᨡᩮᩣ, ᨾᩣᨱᩅ, ᨴᩣᨿᨠᩮᩣ ᨴᩣᨶᨸᨲᩥ ᩅᨴᨬ᩠ᨬᩪ ᨿᩣᨧᨿᩮᩣᨣᩮᩣ; ᨵᨾ᩠ᨾᩮᨶ ᨽᩮᩣᨣᩮ ᨸᩁᩥᨿᩮᩈᨲᩥ; ᨵᨾ᩠ᨾᩮᨶ ᨽᩮᩣᨣᩮ ᨸᩁᩥᨿᩮᩈᩥᨲ᩠ᩅᩣ ᨵᨾ᩠ᨾᩃᨴ᩠ᨵᩮᩉᩥ ᨽᩮᩣᨣᩮᩉᩥ ᨵᨾ᩠ᨾᩣᨵᩥᨣᨲᩮᩉᩥ ᩑᨠᩔᨸᩥ ᨴᨴᩣᨲᩥ…ᨸᩮ… ᩈᨲᩔᨸᩥ ᨴᨴᩣᨲᩥ, ᨽᩥᨿ᩠ᨿᩮᩣᨸᩥ ᨴᨴᩣᨲᩥ, ᨻᩉᩩᩴ ᩈᩮᩣ ᨸᩩᨬ᩠ᨬᩴ ᨸᩈᩅᨲᩦ’’ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᨾᩣᨥᩮᩣ ᨾᩣᨱᩅᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩉᩴ ᨣᩮᩣᨲᨾᩴ ᩅᨴᨬ᩠ᨬᩩᩴ, (ᩍᨲᩥ ᨾᩣᨥᩮᩣ ᨾᩣᨱᩅᩮᩣ)

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

ᨿᩮᩣ ᨿᩣᨧᨿᩮᩣᨣᩮᩣ ᨴᩣᨶᨸᨲᩥ [ᨴᩣᨶᨸᨲᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨣᩉᨭ᩠ᨮᩮᩣ, ᨸᩩᨬ᩠ᨬᨲ᩠ᨳᩥᨠᩮᩣ [ᨸᩩᨬ᩠ᨬᨸᩮᨡᩮᩣ (ᩈᩦ. ᨸᩦ. ᨠ.)] ᨿᨩᨲᩥ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ;

ᨴᨴᩴ ¶ ᨸᩁᩮᩈᩴ ᩍᨵ ᩋᨶ᩠ᨶᨸᩣᨶᩴ, ᨠᨳᩴ ᩉᩩᨲᩴ ᨿᨩᨾᩣᨶᩔ ᩈᩩᨩ᩠ᨫᩮ’’.

‘‘ᨿᩮᩣ ᨿᩣᨧᨿᩮᩣᨣᩮᩣ ᨴᩣᨶᨸᨲᩥ ᨣᩉᨭ᩠ᨮᩮᩣ, (ᨾᩣᨥᩣᨲᩥ ᨽᨣᩅᩣ)

ᨸᩩᨬ᩠ᨬᨲ᩠ᨳᩥᨠᩮᩣ ᨿᨩᨲᩥ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ;

ᨴᨴᩴ ᨸᩁᩮᩈᩴ ᩍᨵ ᩋᨶ᩠ᨶᨸᩣᨶᩴ, ᩌᩁᩣᨵᨿᩮ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩮᨽᩥ ᨲᩣᨴᩥ’’.

‘‘ᨿᩮᩣ ¶ ᨿᩣᨧᨿᩮᩣᨣᩮᩣ ᨴᩣᨶᨸᨲᩥ ᨣᩉᨭ᩠ᨮᩮᩣ, (ᩍᨲᩥ ᨾᩣᨥᩮᩣ ᨾᩣᨱᩅᩮᩣ)

ᨸᩩᨬ᩠ᨬᨲ᩠ᨳᩥᨠᩮᩣ ᨿᨩᨲᩥ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ;

ᨴᨴᩴ ᨸᩁᩮᩈᩴ ᩍᨵ ᩋᨶ᩠ᨶᨸᩣᨶᩴ, ᩋᨠ᩠ᨡᩣᩉᩥ ᨾᩮ ᨽᨣᩅᩣ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩮ’’.

‘‘ᨿᩮ ¶ ᩅᩮ ᩋᩈᨲ᩠ᨲᩣ [ᩋᩃᨣ᩠ᨣᩣ (ᩈ᩠ᨿᩣ.)] ᩅᩥᨧᩁᨶ᩠ᨲᩥ ᩃᩮᩣᨠᩮ, ᩋᨠᩥᨬ᩠ᨧᨶᩣ ᨠᩮᩅᩃᩥᨶᩮᩣ ᨿᨲᨲ᩠ᨲᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

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

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮ ¶ ᩈᨻ᩠ᨻᩈᩴᨿᩮᩣᨩᨶᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩣ, ᨴᨶ᩠ᨲᩣ ᩅᩥᨾᩩᨲ᩠ᨲᩣ ᩋᨶᩦᨥᩣ ᨶᩥᩁᩣᩈᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᩁᩣᨣᨬ᩠ᨧ ᨴᩮᩣᩈᨬ᩠ᨧ ᨸᩉᩣᨿ ᨾᩮᩣᩉᩴ, ᨡᩦᨱᩣᩈᩅᩣ ᩅᩪᩈᩥᨲᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮᩈᩩ ᨶ ᨾᩣᨿᩣ ᩅᩈᨲᩥ ᨶ ᨾᩣᨶᩮᩣ, ᨡᩦᨱᩣᩈᩅᩣ ᩅᩪᩈᩥᨲᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮ ¶ ¶ ᩅᩦᨲᩃᩮᩣᨽᩣ ᩋᨾᨾᩣ ᨶᩥᩁᩣᩈᩣ, ᨡᩦᨱᩣᩈᩅᩣ ᩅᩪᩈᩥᨲᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮ ¶ ᩅᩮ ᨶ ᨲᨱ᩠ᩉᩣᩈᩩ ᩏᨸᩣᨲᩥᨸᨶ᩠ᨶᩣ, ᩅᩥᨲᩁᩮᨿ᩠ᨿ ᩒᨥᩴ ᩋᨾᨾᩣ ᨧᩁᨶ᩠ᨲᩥ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮᩈᩴ ᨲᨱ᩠ᩉᩣ ᨶᨲ᩠ᨳᩥ ᨠᩩᩉᩥᨬ᩠ᨧᩥ ᩃᩮᩣᨠᩮ, ᨽᩅᩣᨽᩅᩣᨿ ᩍᨵ ᩅᩣ ᩉᩩᩁᩴ ᩅᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮ ᨠᩣᨾᩮ ᩉᩥᨲ᩠ᩅᩣ ᩋᨣᩉᩣ ᨧᩁᨶ᩠ᨲᩥ, ᩈᩩᩈᨬ᩠ᨬᨲᨲ᩠ᨲᩣ ᨲᩈᩁᩴᩅ ᩏᨩ᩠ᨩᩩᩴ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮ ᩅᩦᨲᩁᩣᨣᩣ ᩈᩩᩈᨾᩣᩉᩥᨲᩥᨶ᩠ᨴᩕᩥᨿᩣ, ᨧᨶ᩠ᨴᩮᩣᩅ ᩁᩣᩉᩩᨣ᩠ᨣᩉᨱᩣ ᨸᨾᩩᨲ᩠ᨲᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

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

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨩᩉᩥᨲ᩠ᩅᩣ ᨩᩣᨲᩥᨾᩁᨱᩴ ᩋᩈᩮᩈᩴ, ᨠᨳᩴᨠᨳᩥᩴ ᩈᨻ᩠ᨻᨾᩩᨸᩣᨲᩥᩅᨲ᩠ᨲᩣ;

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

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

ᨠᩣᩃᩮᨶ ¶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

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

ᨠᩣᩃᩮᨶ ᨲᩮᩈᩩ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ.

‘‘ᨿᩮᩣ ¶ ᩅᩮᨴᨣᩪ ᨫᩣᨶᩁᨲᩮᩣ ᩈᨲᩦᨾᩣ, ᩈᨾ᩠ᨻᩮᩣᨵᩥᨸᨲ᩠ᨲᩮᩣ ᩈᩁᨱᩴ ᨻᩉᩪᨶᩴ;

ᨠᩣᩃᩮᨶ ᨲᨾ᩠ᩉᩥ ᩉᨻ᩠ᨿᩴ ᨸᩅᩮᨧ᩠ᨨᩮ, ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ ᨿᨩᩮᨳ’’.

‘‘ᩋᨴ᩠ᨵᩣ ᩋᨾᩮᩣᨥᩣ ᨾᨾ ᨸᩩᨧ᩠ᨨᨶᩣ ᩋᩉᩩ, ᩋᨠ᩠ᨡᩣᩈᩥ ᨾᩮ ᨽᨣᩅᩣ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩮ;

ᨲ᩠ᩅᨬ᩠ᩉᩮᨲ᩠ᨳ ᨩᩣᨶᩣᩈᩥ ᨿᨳᩣ ᨲᨳᩣ ᩍᨴᩴ, ᨲᨳᩣ ᩉᩥ ᨲᩮ ᩅᩥᨴᩥᨲᩮᩣ ᩑᩈ ᨵᨾ᩠ᨾᩮᩣ.

‘‘ᨿᩮᩣ ᨿᩣᨧᨿᩮᩣᨣᩮᩣ ᨴᩣᨶᨸᨲᩥ ᨣᩉᨭ᩠ᨮᩮᩣ, (ᩍᨲᩥ ᨾᩣᨥᩮᩣ ᨾᩣᨱᩅᩮᩣ)

ᨸᩩᨬ᩠ᨬᨲ᩠ᨳᩥᨠᩮᩣ ᨿᨩᨲᩥ ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩮᩣ;

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

ᩌᩁᨾ᩠ᨾᨱᩴ ᨿᨩᨾᩣᨶᩔ ᨿᨬ᩠ᨬᩮᩣ, ᩑᨲ᩠ᨳᨸ᩠ᨸᨲᩥᨭ᩠ᨮᩣᨿ ᨩᩉᩣᨲᩥ ᨴᩮᩣᩈᩴ.

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

ᩁᨲ᩠ᨲᩥᨶ᩠ᨴᩥᩅᩴ ᩈᨲᨲᨾᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ, ᩈᨻ᩠ᨻᩣ ᨴᩥᩈᩣ ᨹᩁᨲᩥ ᩋᨸ᩠ᨸᨾᨬ᩠ᨬᩴ’’.

‘‘ᨠᩮᩣ ¶ ᩈᩩᨩ᩠ᨫᨲᩥ ᨾᩩᨧ᩠ᨧᨲᩥ ᨻᨩ᩠ᨫᨲᩦ ᨧ, ᨠᩮᨶᨲ᩠ᨲᨶᩣ ᨣᨧ᩠ᨨᨲᩥ [ᨠᩮᨶᨲ᩠ᨳᩮᨶᩣ ᨣᨧ᩠ᨨᨲᩥ (ᨠ.)] ᨻᩕᩉ᩠ᨾᩃᩮᩣᨠᩴ;

ᩋᨩᩣᨶᨲᩮᩣ ᨾᩮ ᨾᩩᨶᩥ ᨻᩕᩪᩉᩥ ᨸᩩᨭ᩠ᨮᩮᩣ, ᨽᨣᩅᩣ ᩉᩥ ᨾᩮ ᩈᨠ᩠ᨡᩥ ᨻᩕᩉ᩠ᨾᨩ᩠ᨩᨴᩥᨭ᩠ᨮᩮᩣ;

ᨲᩩᩅᨬ᩠ᩉᩥ ¶ ᨶᩮᩣ ᨻᩕᩉ᩠ᨾᩈᨾᩮᩣᩈᩥ ᩈᨧ᩠ᨧᩴ, ᨠᨳᩴ ᩏᨸᨸᨩ᩠ᨩᨲᩥ ᨻᩕᩉ᩠ᨾᩃᩮᩣᨠᩴ ᨩᩩᨲᩥᨾ’’.

‘‘ᨿᩮᩣ ᨿᨩᨲᩥ ᨲᩥᩅᩥᨵᩴ ᨿᨬ᩠ᨬᩈᨾ᩠ᨸᨴᩴ, (ᨾᩣᨥᩣᨲᩥ ᨽᨣᩅᩣ)

ᩏᨸᨸᨩ᩠ᨩᨲᩥ ᨻᩕᩉ᩠ᨾᩃᩮᩣᨠᨶ᩠ᨲᩥ ᨻᩕᩪᨾᩦ’’ᨲᩥ.

ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᨾᩣᨥᩮᩣ ᨾᩣᨱᩅᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ…ᨸᩮ… ᩋᨩ᩠ᨩᨲᨣ᩠ᨣᩮ ᨸᩣᨱᩩᨸᩮᨲᩴ ᩈᩁᨱᩴ ᨣᨲ’’ᨶ᩠ᨲᩥ.

ᩑᩅᩴ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩁᩣᨩᨣᩉᩮ ᩅᩥᩉᩁᨲᩥ ᩅᩮᩊᩩᩅᨶᩮ ᨠᩃᨶ᩠ᨴᨠᨶᩥᩅᩣᨸᩮ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᩈᨽᩥᨿᩔ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩔ ᨸᩩᩁᩣᨱᩈᩣᩃᩮᩣᩉᩥᨲᩣᨿ ᨴᩮᩅᨲᩣᨿ ᨸᨬ᩠ᩉᩣ ᩏᨴ᩠ᨴᩥᨭ᩠ᨮᩣ ᩉᩮᩣᨶ᩠ᨲᩥ – ‘‘ᨿᩮᩣ ᨲᩮ, ᩈᨽᩥᨿ, ᩈᨾᨱᩮᩣ ᩅᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩅᩣ ᩍᨾᩮ ᨸᨬ᩠ᩉᩮ ᨸᩩᨭ᩠ᨮᩮᩣ ᨻ᩠ᨿᩣᨠᩁᩮᩣᨲᩥ ᨲᩔ ᩈᨶ᩠ᨲᩥᨠᩮ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ ᨧᩁᩮᨿ᩠ᨿᩣᩈᩦ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ ᨲᩔᩣ ᨴᩮᩅᨲᩣᨿ ᩈᨶ᩠ᨲᩥᨠᩮ ᨲᩮ ᨸᨬ᩠ᩉᩮ ᩏᨣ᩠ᨣᩉᩮᨲ᩠ᩅᩣ ᨿᩮ ᨲᩮ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩈᨦ᩠ᨥᩥᨶᩮᩣ ᨣᨱᩥᨶᩮᩣ ᨣᨱᩣᨧᩁᩥᨿᩣ ᨬᩣᨲᩣ ᨿᩈᩔᩥᨶᩮᩣ ᨲᩥᨲ᩠ᨳᨠᩁᩣ ᩈᩣᨵᩩᩈᨾ᩠ᨾᨲᩣ ¶ ᨻᩉᩩᨩᨶᩔ, ᩈᩮᨿ᩠ᨿᨳᩥᨴᩴ – ᨸᩪᩁᨱᩮᩣ ᨠᩔᨸᩮᩣ ᨾᨠ᩠ᨡᩃᩥᨣᩮᩣᩈᩣᩃᩮᩣ ᩋᨩᩥᨲᩮᩣ ᨠᩮᩈᨠᨾ᩠ᨻᩃᩮᩣ ᨸᨠᩩᨵᩮᩣ [ᨠᨠᩩᨵᩮᩣ (ᩈᩦ.) ᨸᨠᩩᨴ᩠ᨵᩮᩣ (ᩈ᩠ᨿᩣ. ᨠᩴ.)] ᨠᨧ᩠ᨧᩣᨶᩮᩣ ᩈᨬ᩠ᨧᨿᩮᩣ [ᩈᨬ᩠ᨩᨿᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠᩴ. ᨸᩦ.)] ᨻᩮᩃᨭ᩠ᨮᨸᩩᨲ᩠ᨲᩮᩣ [ᨻᩮᩃ᩠ᩃᨭ᩠ᨮᩥᨸᩩᨲ᩠ᨲᩮᩣ (ᩈᩦ. ᨸᩦ.), ᩅᩮᩊᨭ᩠ᨮᨸᩩᨲ᩠ᨲᩮᩣ (ᩈ᩠ᨿᩣ.)] ᨶᩥᨣᨱ᩠ᨮᩮᩣ ᨶᩣᨭᨸᩩᨲ᩠ᨲᩮᩣ [ᨶᩣᨲᨸᩩᨲ᩠ᨲᩮᩣ (ᩈᩦ. ᨸᩦ.)], ᨲᩮ ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨲᩮ ᨸᨬ᩠ᩉᩮ ᨸᩩᨧ᩠ᨨᨲᩥ. ᨲᩮ ᩈᨽᩥᨿᩮᨶ ¶ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᨶ ᨸᨬ᩠ᩉᩮ ᨸᩩᨭ᩠ᨮᩣ ᨶ ᩈᨾ᩠ᨸᩣᨿᨶ᩠ᨲᩥ; ᩋᩈᨾ᩠ᨸᩣᨿᨶ᩠ᨲᩣ ᨠᩮᩣᨸᨬ᩠ᨧ ᨴᩮᩣᩈᨬ᩠ᨧ ᩋᨸ᩠ᨸᨧ᩠ᨧᨿᨬ᩠ᨧ ᨸᩣᨲᩩᨠᩁᩮᩣᨶ᩠ᨲᩥ. ᩋᨸᩥ ᨧ ᩈᨽᩥᨿᩴ ᨿᩮᩅ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩴ ᨸᨭᩥᨸᩩᨧ᩠ᨨᨶ᩠ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩔ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩔ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᨿᩮ ᨡᩮᩣ ᨲᩮ ᨽᩮᩣᨶ᩠ᨲᩮᩣ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩈᨦ᩠ᨥᩥᨶᩮᩣ ᨣᨱᩥᨶᩮᩣ ᨣᨱᩣᨧᩁᩥᨿᩣ ᨬᩣᨲᩣ ᨿᩈᩔᩥᨶᩮᩣ ᨲᩥᨲ᩠ᨳᨠᩁᩣ ᩈᩣᨵᩩᩈᨾ᩠ᨾᨲᩣ ᨻᩉᩩᨩᨶᩔ, ᩈᩮᨿ᩠ᨿᨳᩥᨴᩴ – ᨸᩪᩁᨱᩮᩣ ᨠᩔᨸᩮᩣ…ᨸᩮ… ᨶᩥᨣᨱ᩠ᨮᩮᩣ ᨶᩣᨭᨸᩩᨲ᩠ᨲᩮᩣ, ᨲᩮ ᨾᨿᩣ ᨸᨬ᩠ᩉᩮ ᨸᩩᨭ᩠ᨮᩣ ᨶ ᩈᨾ᩠ᨸᩣᨿᨶ᩠ᨲᩥ, ᩋᩈᨾ᩠ᨸᩣᨿᨶ᩠ᨲᩣ ᨠᩮᩣᨸᨬ᩠ᨧ ᨴᩮᩣᩈᨬ᩠ᨧ ᩋᨸ᩠ᨸᨧ᩠ᨧᨿᨬ᩠ᨧ ᨸᩣᨲᩩᨠᩁᩮᩣᨶ᩠ᨲᩥ; ᩋᨸᩥ ¶ ᨧ ᨾᨬ᩠ᨬᩮᩅᩮᨲ᩠ᨳ ᨸᨭᩥᨸᩩᨧ᩠ᨨᨶ᩠ᨲᩥ. ᨿᨶ᩠ᨶᩪᨶ᩠ᨶᩣᩉᩴ ᩉᩦᨶᩣᨿᩣᩅᨲ᩠ᨲᩥᨲ᩠ᩅᩣ ᨠᩣᨾᩮ ᨸᩁᩥᨽᩩᨬ᩠ᨩᩮᨿ᩠ᨿ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ¶ ᨡᩮᩣ ᩈᨽᩥᨿᩔ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩔ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᩋᨿᨾ᩠ᨸᩥ ᨡᩮᩣ ᩈᨾᨱᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ ᩈᨦ᩠ᨥᩦ ᨧᩮᩅ ᨣᨱᩦ ᨧ ᨣᨱᩣᨧᩁᩥᨿᩮᩣ ᨧ ᨬᩣᨲᩮᩣ ᨿᩈᩔᩦ ᨲᩥᨲ᩠ᨳᨠᩁᩮᩣ ᩈᩣᨵᩩᩈᨾ᩠ᨾᨲᩮᩣ ᨻᩉᩩᨩᨶᩔ; ᨿᩴᨶᩪᨶᩣᩉᩴ ᩈᨾᨱᩴ ᨣᩮᩣᨲᨾᩴ ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᩍᨾᩮ ᨸᨬ᩠ᩉᩮ ᨸᩩᨧ᩠ᨨᩮᨿ᩠ᨿ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩔ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩔ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᨿᩮᨸᩥ ᨡᩮᩣ ᨲᩮ [ᨿᩮ ᨡᩮᩣ ᨲᩮ (ᩈ᩠ᨿᩣ.), ᨿᩴ ᨡᩮᩣ ᨲᩮ (ᨠ.)] ᨽᩮᩣᨶ᩠ᨲᩮᩣ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨩᩥᨱ᩠ᨱᩣ ᩅᩩᨯ᩠ᨰᩣ ᨾᩉᩃ᩠ᩃᨠᩣ ᩋᨴ᩠ᨵᨣᨲᩣ ᩅᨿᩮᩣᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩣ ᨳᩮᩁᩣ ᩁᨲ᩠ᨲᨬ᩠ᨬᩪ ᨧᩥᩁᨸᨻ᩠ᨻᨩᩥᨲᩣ ᩈᨦ᩠ᨥᩥᨶᩮᩣ ᨣᨱᩥᨶᩮᩣ ᨣᨱᩣᨧᩁᩥᨿᩣ ᨬᩣᨲᩣ ᨿᩈᩔᩥᨶᩮᩣ ᨲᩥᨲ᩠ᨳᨠᩁᩣ ᩈᩣᨵᩩᩈᨾ᩠ᨾᨲᩣ ᨻᩉᩩᨩᨶᩔ, ᩈᩮᨿ᩠ᨿᨳᩥᨴᩴ – ᨸᩪᩁᨱᩮᩣ ᨠᩔᨸᩮᩣ…ᨸᩮ. ¶ … ᨶᩥᨣᨱ᩠ᨮᩮᩣ ᨶᩣᨭᨸᩩᨲ᩠ᨲᩮᩣ, ᨲᩮᨸᩥ ᨾᨿᩣ ᨸᨬ᩠ᩉᩮ ᨸᩩᨭ᩠ᨮᩣ ᨶ ᩈᨾ᩠ᨸᩣᨿᨶ᩠ᨲᩥ, ᩋᩈᨾ᩠ᨸᩣᨿᨶ᩠ᨲᩣ ᨠᩮᩣᨸᨬ᩠ᨧ ᨴᩮᩣᩈᨬ᩠ᨧ ᩋᨸ᩠ᨸᨧ᩠ᨧᨿᨬ᩠ᨧ ᨸᩣᨲᩩᨠᩁᩮᩣᨶ᩠ᨲᩥ, ᩋᨸᩥ ᨧ ᨾᨬ᩠ᨬᩮᩅᩮᨲ᩠ᨳ ᨸᨭᩥᨸᩩᨧ᩠ᨨᨶ᩠ᨲᩥ; ᨠᩥᩴ ᨸᨶ ᨾᩮ ᩈᨾᨱᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ ᩍᨾᩮ ᨸᨬ᩠ᩉᩮ ᨸᩩᨭ᩠ᨮᩮᩣ ᨻ᩠ᨿᩣᨠᩁᩥᩔᨲᩥ! ᩈᨾᨱᩮᩣ ᩉᩥ ᨣᩮᩣᨲᨾᩮᩣ ᨴᩉᩁᩮᩣ ᨧᩮᩅ ᨩᩣᨲᩥᨿᩣ, ᨶᩅᩮᩣ ᨧ ᨸᨻ᩠ᨻᨩ᩠ᨩᩣᨿᩣ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩔ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩔ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᩈᨾᨱᩮᩣ ᨡᩮᩣ [ᩈᨾᨱᩮᩣ ᨡᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨴᩉᩁᩮᩣᨲᩥ ᨶ ᩏᨬ᩠ᨬᩣᨲᨻ᩠ᨻᩮᩣ ᨶ ᨸᩁᩥᨽᩮᩣᨲᨻ᩠ᨻᩮᩣ. ᨴᩉᩁᩮᩣᨸᩥ ᨧᩮᩈ ᩈᨾᨱᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ ᨾᩉᩥᨴ᩠ᨵᩥᨠᩮᩣ ᩉᩮᩣᨲᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨿᩴᨶᩪᨶᩣᩉᩴ ᩈᨾᨱᩴ ᨣᩮᩣᨲᨾᩴ ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᩍᨾᩮ ᨸᨬ᩠ᩉᩮ ᨸᩩᨧ᩠ᨨᩮᨿ᩠ᨿ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ¶ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ ᨿᩮᨶ ᩁᩣᨩᨣᩉᩴ ᨲᩮᨶ ᨧᩣᩁᩥᨠᩴ ᨸᨠ᩠ᨠᩣᨾᩥ. ᩋᨶᩩᨸᩩᨻ᩠ᨻᩮᨶ ᨧᩣᩁᩥᨠᩴ ᨧᩁᨾᩣᨶᩮᩣ ᨿᩮᨶ ᩁᩣᨩᨣᩉᩴ ᩅᩮᩊᩩᩅᨶᩴ ᨠᩃᨶ᩠ᨴᨠᨶᩥᩅᩣᨸᩮᩣ, ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩣ ᩈᨴ᩠ᨵᩥᩴ ¶ ᩈᨾ᩠ᨾᩮᩣᨴᩥ. ᩈᨾ᩠ᨾᩮᩣᨴᨶᩦᨿᩴ ᨠᨳᩴ ᩈᩣᩁᨱᩦᨿᩴ ᩅᩦᨲᩥᩈᩣᩁᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨠᨦ᩠ᨡᩦ ᩅᩮᨧᩥᨠᩥᨧ᩠ᨨᩦ ᩌᨣᨾᩴ, (ᩍᨲᩥ ᩈᨽᩥᨿᩮᩣ)

ᨸᨬ᩠ᩉᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩩᩴ ᩋᨽᩥᨠᨦ᩠ᨡᨾᩣᨶᩮᩣ;

ᨲᩮᩈᨶ᩠ᨲᨠᩁᩮᩣ ᨽᩅᩣᩉᩥ [ᨽᩅᩣᩉᩥ ᨾᩮ (ᨸᩦ. ᨠ.)] ᨸᨬ᩠ᩉᩮ ᨾᩮ ᨸᩩᨭ᩠ᨮᩮᩣ,

ᩋᨶᩩᨸᩩᨻ᩠ᨻᩴ ᩋᨶᩩᨵᨾ᩠ᨾᩴ ᨻ᩠ᨿᩣᨠᩁᩮᩣᩉᩥ ᨾᩮ’’.

‘‘ᨴᩪᩁᨲᩮᩣ ¶ ᩌᨣᨲᩮᩣᩈᩥ ᩈᨽᩥᨿ, (ᩍᨲᩥ ᨽᨣᩅᩣ)

ᨸᨬ᩠ᩉᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩩᩴ ᩋᨽᩥᨠᨦ᩠ᨡᨾᩣᨶᩮᩣ;

ᨲᩮᩈᨶ᩠ᨲᨠᩁᩮᩣ ᨽᩅᩣᨾᩥ [ᨲᩮᩈᨾᨶ᩠ᨲᨠᩁᩮᩣᨾᩥ ᨲᩮ (ᨠ.)] ᨸᨬ᩠ᩉᩮ ᨲᩮ ᨸᩩᨭ᩠ᨮᩮᩣ,

ᩋᨶᩩᨸᩩᨻ᩠ᨻᩴ ᩋᨶᩩᨵᨾ᩠ᨾᩴ ᨻ᩠ᨿᩣᨠᩁᩮᩣᨾᩥ ᨲᩮ.

‘‘ᨸᩩᨧ᩠ᨨ ¶ ᨾᩴ ᩈᨽᩥᨿ ᨸᨬ᩠ᩉᩴ, ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨾᨶᩈᩥᨧ᩠ᨨᩈᩥ;

ᨲᩔ ᨲᩔᩮᩅ ᨸᨬ᩠ᩉᩔ, ᩋᩉᩴ ᩋᨶ᩠ᨲᩴ ᨠᩁᩮᩣᨾᩥ ᨲᩮ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩔ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩔ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᩋᨧ᩠ᨨᩁᩥᨿᩴ ᩅᨲ, ᨽᩮᩣ, ᩋᨻ᩠ᨽᩩᨲᩴ ᩅᨲ, ᨽᩮᩣ! ᨿᩴ ᩅᨲᩣᩉᩴ ᩋᨬ᩠ᨬᩮᩈᩩ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ᩒᨠᩣᩈᨠᨾ᩠ᨾᨾᨲ᩠ᨲᨾ᩠ᨸᩥ [ᩒᨠᩣᩈᨾᨲ᩠ᨲᨾ᩠ᨸᩥ (ᩈᩦ. ᨸᩦ.)] ᨶᩣᩃᨲ᩠ᨳᩴ ᨲᩴ ᨾᩮ ᩍᨴᩴ ᩈᨾᨱᩮᨶ ᨣᩮᩣᨲᨾᩮᨶ ᩒᨠᩣᩈᨠᨾ᩠ᨾᩴ ᨠᨲ’’ᨶ᩠ᨲᩥ. ᩋᨲ᩠ᨲᨾᨶᩮᩣ ᨸᨾᩩᨴᩥᨲᩮᩣ ᩏᨴᨣ᩠ᨣᩮᩣ ᨸᩦᨲᩥᩈᩮᩣᨾᨶᩔᨩᩣᨲᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ¶ ᨸᨬ᩠ᩉᩴ ᩋᨸᩩᨧ᩠ᨨᩥ –

‘‘ᨠᩥᩴ ᨸᨲ᩠ᨲᩥᨶᨾᩣᩉᩩ ᨽᩥᨠ᩠ᨡᩩᨶᩴ, (ᩍᨲᩥ ᩈᨽᩥᨿᩮᩣ)

‘‘ᨸᨩ᩠ᨩᩮᨶ ¶ ᨠᨲᩮᨶ ᩋᨲ᩠ᨲᨶᩣ, (ᩈᨽᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᨸᩁᩥᨶᩥᨻ᩠ᨻᩣᨶᨣᨲᩮᩣ ᩅᩥᨲᩥᨱ᩠ᨱᨠᨦ᩠ᨡᩮᩣ;

ᩅᩩᩈᩥᨲᩅᩣ ᨡᩦᨱᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ ᩈ ᨽᩥᨠ᩠ᨡᩩ.

‘‘ᩈᨻ᩠ᨻᨲ᩠ᨳ ¶ ᩏᨸᩮᨠ᩠ᨡᨠᩮᩣ ᩈᨲᩥᨾᩣ, ᨶ ᩈᩮᩣ ᩉᩥᩴᩈᨲᩥ ᨠᨬ᩠ᨧᩥ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩮ;

ᨲᩥᨱ᩠ᨱᩮᩣ ᩈᨾᨱᩮᩣ ᩋᨶᩣᩅᩥᩃᩮᩣ, ᩏᩔᨴᩣ ᨿᩔ ᨶ ᩈᨶ᩠ᨲᩥ ᩈᩮᩣᩁᨲᩮᩣ ᩈᩮᩣ.

‘‘ᨿᩔᩥᨶ᩠ᨴᩕᩥᨿᩣᨶᩥ ᨽᩣᩅᩥᨲᩣᨶᩥ, ᩋᨩ᩠ᨫᨲ᩠ᨲᩴ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩮ;

ᨶᩥᨻ᩠ᨻᩥᨩ᩠ᨫ ᩍᨾᩴ ᨸᩁᨬ᩠ᨧ ᩃᩮᩣᨠᩴ, ᨠᩣᩃᩴ ᨠᨦ᩠ᨡᨲᩥ ᨽᩣᩅᩥᨲᩮᩣ ᩈ ᨴᨶ᩠ᨲᩮᩣ.

‘‘ᨠᨸ᩠ᨸᩣᨶᩥ ᩅᩥᨧᩮᨿ᩠ᨿ ᨠᩮᩅᩃᩣᨶᩥ, ᩈᩴᩈᩣᩁᩴ ᨴᩩᨽᨿᩴ ᨧᩩᨲᩪᨸᨸᩣᨲᩴ;

ᩅᩥᨣᨲᩁᨩᨾᨶᨦ᩠ᨣᨱᩴ ¶ ᩅᩥᩈᩩᨴ᩠ᨵᩴ, ᨸᨲ᩠ᨲᩴ ᨩᩣᨲᩥᨡᨿᩴ ᨲᨾᩣᩉᩩ ᨻᩩᨴ᩠ᨵ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ ᨽᨣᩅᨲᩮᩣ ᨽᩣᩈᩥᨲᩴ ᩋᨽᩥᨶᨶ᩠ᨴᩥᨲ᩠ᩅᩣ ᩋᨶᩩᨾᩮᩣᨴᩥᨲ᩠ᩅᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ ᨸᨾᩩᨴᩥᨲᩮᩣ ᩏᨴᨣ᩠ᨣᩮᩣ ᨸᩦᨲᩥᩈᩮᩣᨾᨶᩔᨩᩣᨲᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩏᨲ᩠ᨲᩁᩥᩴ [ᩏᨲ᩠ᨲᩁᩥ (ᨠ.)] ᨸᨬ᩠ᩉᩴ ᩋᨸᩩᨧ᩠ᨨᩥ –

‘‘ᨠᩥᩴ ¶ ᨸᨲ᩠ᨲᩥᨶᨾᩣᩉᩩ ᨻᩕᩣᩉ᩠ᨾᨱᩴ, (ᩍᨲᩥ ᩈᨽᩥᨿᩮᩣ)

‘‘ᨻᩣᩉᩥᨲ᩠ᩅᩣ ᩈᨻ᩠ᨻᨸᩣᨸᨠᩣᨶᩥ, (ᩈᨽᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᩅᩥᨾᩃᩮᩣ ᩈᩣᨵᩩᩈᨾᩣᩉᩥᨲᩮᩣ ᨮᩥᨲᨲ᩠ᨲᩮᩣ;

ᩋᩈᩥᨲᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᩈ ᨻᩕᩉ᩠ᨾᩣ.

‘‘ᩈᨾᩥᨲᩣᩅᩥ ᨸᩉᩣᨿ ᨸᩩᨬ᩠ᨬᨸᩣᨸᩴ, ᩅᩥᩁᨩᩮᩣ ᨬᨲ᩠ᩅᩣ ᩍᨾᩴ ᨸᩁᨬ᩠ᨧ ᩃᩮᩣᨠᩴ;

ᨩᩣᨲᩥᨾᩁᨱᩴ ᩏᨸᩣᨲᩥᩅᨲ᩠ᨲᩮᩣ, ᩈᨾᨱᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᨲᨳᨲ᩠ᨲᩣ.

‘‘ᨶᩥᨶ᩠ᩉᩣᨿ ¶ [ᨶᩥᨶᩉᩣᨿ (ᩈ᩠ᨿᩣ.)] ᩈᨻ᩠ᨻᨸᩣᨸᨠᩣᨶᩥ, ᩋᨩ᩠ᨫᨲ᩠ᨲᩴ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩮ;

ᨴᩮᩅᨾᨶᩩᩔᩮᩈᩩ ¶ ᨠᨸ᩠ᨸᩥᨿᩮᩈᩩ, ᨠᨸ᩠ᨸᩴ ᨶᩮᨲᩥ ᨲᨾᩣᩉᩩ ᨶ᩠ᩉᩣᨲᨠᩮᩣ’’ᨲᩥ.

‘‘ᩌᨣᩩᩴ ᨶ ᨠᩁᩮᩣᨲᩥ ᨠᩥᨬ᩠ᨧᩥ ᩃᩮᩣᨠᩮ, ᩈᨻ᩠ᨻᩈᩴᨿᩮᩣᨣᩮ [ᩈᨻ᩠ᨻᨿᩮᩣᨣᩮ (ᨠ.)] ᩅᩥᩈᨩ᩠ᨩ ᨻᨶ᩠ᨵᨶᩣᨶᩥ;

ᩈᨻ᩠ᨻᨲ᩠ᨳ ᨶ ᩈᨩ᩠ᨩᨲᩦ ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ, ᨶᩣᨣᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᨲᨳᨲ᩠ᨲᩣ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ…ᨸᩮ… ᨽᨣᩅᨶ᩠ᨲᩴ ᩏᨲ᩠ᨲᩁᩥᩴ ᨸᨬ᩠ᩉᩴ ᩋᨸᩩᨧ᩠ᨨᩥ –

‘‘ᨠᩴ ᨡᩮᨲ᩠ᨲᨩᩥᨶᩴ ᩅᨴᨶ᩠ᨲᩥ ᨻᩩᨴ᩠ᨵᩣ, (ᩍᨲᩥ ᩈᨽᩥᨿᩮᩣ)

‘‘ᨡᩮᨲ᩠ᨲᩣᨶᩥ ᩅᩥᨧᩮᨿ᩠ᨿ ᨠᩮᩅᩃᩣᨶᩥ, (ᩈᨽᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᨴᩥᨻ᩠ᨻᩴ ᨾᩣᨶᩩᩈᨠᨬ᩠ᨧ ᨻᩕᩉ᩠ᨾᨡᩮᨲ᩠ᨲᩴ;

ᩈᨻ᩠ᨻᨡᩮᨲ᩠ᨲᨾᩪᩃᨻᨶ᩠ᨵᨶᩣ ᨸᨾᩩᨲ᩠ᨲᩮᩣ,

ᨡᩮᨲ᩠ᨲᨩᩥᨶᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᨲᨳᨲ᩠ᨲᩣ.

‘‘ᨠᩮᩣᩈᩣᨶᩥ ¶ ᩅᩥᨧᩮᨿ᩠ᨿ ᨠᩮᩅᩃᩣᨶᩥ, ᨴᩥᨻ᩠ᨻᩴ ᨾᩣᨶᩩᩈᨠᨬ᩠ᨧ ᨻᩕᩉ᩠ᨾᨠᩮᩣᩈᩴ;

ᩈᨻ᩠ᨻᨠᩮᩣᩈᨾᩪᩃᨻᨶ᩠ᨵᨶᩣ ᨸᨾᩩᨲ᩠ᨲᩮᩣ, ᨠᩩᩈᩃᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᨲᨳᨲ᩠ᨲᩣ.

‘‘ᨴᩩᨽᨿᩣᨶᩥ ¶ ᩅᩥᨧᩮᨿ᩠ᨿ ᨸᨱ᩠ᨯᩁᩣᨶᩥ, ᩋᨩ᩠ᨫᨲ᩠ᨲᩴ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ ᩈᩩᨴ᩠ᨵᩥᨸᨬ᩠ᨬᩮᩣ;

ᨠᨱ᩠ᩉᩴ ᩈᩩᨠ᩠ᨠᩴ ᩏᨸᩣᨲᩥᩅᨲ᩠ᨲᩮᩣ, ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᨲᨳᨲ᩠ᨲᩣ.

‘‘ᩋᩈᨲᨬ᩠ᨧ ¶ ᩈᨲᨬ᩠ᨧ ᨬᨲ᩠ᩅᩣ ᨵᨾ᩠ᨾᩴ, ᩋᨩ᩠ᨫᨲ᩠ᨲᩴ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩮ;

ᨴᩮᩅᨾᨶᩩᩔᩮᩉᩥ ᨸᩪᨩᨶᩦᨿᩮᩣ, ᩈᨦ᩠ᨣᩴ ᨩᩣᩃᨾᨲᩥᨧ᩠ᨧ ᩈᩮᩣ ᨾᩩᨶᩦ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ…ᨸᩮ… ᨽᨣᩅᨶ᩠ᨲᩴ ᩏᨲ᩠ᨲᩁᩥᩴ ᨸᨬ᩠ᩉᩴ ᩋᨸᩩᨧ᩠ᨨᩥ –

‘‘ᨠᩥᩴ ᨸᨲ᩠ᨲᩥᨶᨾᩣᩉᩩ ¶ ᩅᩮᨴᨣᩩᩴ, (ᩍᨲᩥ ᩈᨽᩥᨿᩮᩣ)

ᩋᨶᩩᩅᩥᨴᩥᨲᩴ ᨠᩮᨶ ᨠᨳᨬ᩠ᨧ ᩅᩦᩁᩥᨿᩅᩣᨲᩥ;

‘‘ᩅᩮᨴᩣᨶᩥ ᩅᩥᨧᩮᨿ᩠ᨿ ᨠᩮᩅᩃᩣᨶᩥ, (ᩈᨽᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᩈᨾᨱᩣᨶᩴ ᨿᩣᨶᩥᨵᨲ᩠ᨳᩥ [ᨿᩣᨶᩥᨸᨲ᩠ᨳᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ;

‘‘ᩋᨶᩩᩅᩥᨧ᩠ᨧ ᨸᨸᨬ᩠ᨧᨶᩣᨾᩁᩪᨸᩴ, ᩋᨩ᩠ᨫᨲ᩠ᨲᩴ ¶ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ ᩁᩮᩣᨣᨾᩪᩃᩴ;

ᩈᨻ᩠ᨻᩁᩮᩣᨣᨾᩪᩃᨻᨶ᩠ᨵᨶᩣ ᨸᨾᩩᨲ᩠ᨲᩮᩣ, ᩋᨶᩩᩅᩥᨴᩥᨲᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᨲᨳᨲ᩠ᨲᩣ.

‘‘ᩅᩥᩁᨲᩮᩣ ᩍᨵ ᩈᨻ᩠ᨻᨸᩣᨸᨠᩮᩉᩥ, ᨶᩥᩁᨿᨴᩩᨠ᩠ᨡᩴ ᩋᨲᩥᨧ᩠ᨧ ᩅᩦᩁᩥᨿᩅᩣ ᩈᩮᩣ;

ᩈᩮᩣ ᩅᩦᩁᩥᨿᩅᩣ ᨸᨵᩣᨶᩅᩣ, ᨵᩦᩁᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᨲᨳᨲ᩠ᨲᩣ.

‘‘ᨿᩔᩔᩩ ᩃᩩᨶᩣᨶᩥ ᨻᨶ᩠ᨵᨶᩣᨶᩥ, ᩋᨩ᩠ᨫᨲ᩠ᨲᩴ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ ᩈᨦ᩠ᨣᨾᩪᩃᩴ;

ᩈᨻ᩠ᨻᩈᨦ᩠ᨣᨾᩪᩃᨻᨶ᩠ᨵᨶᩣ ᨸᨾᩩᨲ᩠ᨲᩮᩣ, ᩌᨩᩣᨶᩥᨿᩮᩣ ᨲᩣᨴᩥ ᨸᩅᩩᨧ᩠ᨧᨲᩮ ᨲᨳᨲ᩠ᨲᩣ’’ᨲᩥ.

ᩋᨳ ¶ ¶ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ…ᨸᩮ… ᨽᨣᩅᨶ᩠ᨲᩴ ᩏᨲ᩠ᨲᩁᩥᩴ ᨸᨬ᩠ᩉᩴ ᩋᨸᩩᨧ᩠ᨨᩥ –

‘‘ᨠᩥᩴ ᨸᨲ᩠ᨲᩥᨶᨾᩣᩉᩩ ᩈᩮᩣᨲ᩠ᨲᩥᨿᩴ, (ᩍᨲᩥ ᩈᨽᩥᨿᩮᩣ)

‘‘ᩈᩩᨲ᩠ᩅᩣ ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩴ ᩋᨽᩥᨬ᩠ᨬᩣᨿ ᩃᩮᩣᨠᩮ, (ᩈᨽᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᩋᨶᩥᨥᩴ ¶ ᩈᨻ᩠ᨻᨵᩥᨾᩣᩉᩩ ᩈᩮᩣᨲ᩠ᨲᩥᨿᩮᩣᨲᩥ.

‘‘ᨨᩮᨲ᩠ᩅᩣ ᩌᩈᩅᩣᨶᩥ ᩌᩃᨿᩣᨶᩥ, ᩅᩥᨴ᩠ᩅᩣ ᩈᩮᩣ ᨶ ᩏᨸᩮᨲᩥ ᨣᨻ᩠ᨽᩈᩮᨿ᩠ᨿᩴ;

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

‘‘ᨿᩮᩣ ᩍᨵ ᨧᩁᨱᩮᩈᩩ ᨸᨲ᩠ᨲᩥᨸᨲ᩠ᨲᩮᩣ, ᨠᩩᩈᩃᩮᩣ ᩈᨻ᩠ᨻᨴᩣ ᩌᨩᩣᨶᩣᨲᩥ [ᩌᨩᩣᨶᩥ (ᩈ᩠ᨿᩣ.)] ᨵᨾ᩠ᨾᩴ;

ᩈᨻ᩠ᨻᨲ᩠ᨳ ᨶ ᩈᨩ᩠ᨩᨲᩥ ᩅᩥᨾᩩᨲ᩠ᨲᨧᩥᨲ᩠ᨲᩮᩣ [ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ (ᩈᩦ.)], ᨸᨭᩥᨥᩣ ᨿᩔ ᨶ ᩈᨶ᩠ᨲᩥ ᨧᩁᨱᩅᩣ ᩈᩮᩣ.

‘‘ᨴᩩᨠ᩠ᨡᩅᩮᨸᨠ᩠ᨠᩴ ᨿᨴᨲ᩠ᨳᩥ ᨠᨾ᩠ᨾᩴ, ᩏᨴ᩠ᨵᨾᨵᩮᩣ ᨲᩥᩁᩥᨿᩴ ᩅᩣᨸᩥ [ᨲᩥᩁᩥᨿᨬ᩠ᨧᩣᨸᩥ (ᩈ᩠ᨿᩣ.)] ᨾᨩ᩠ᨫᩮ;

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

ᨸᩁᩥᨿᨶ᩠ᨲᨾᨠᩣᩈᩥ ᨶᩣᨾᩁᩪᨸᩴ, ᨲᩴ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᨾᩣᩉᩩ ᨸᨲ᩠ᨲᩥᨸᨲ᩠ᨲ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ ᨽᨣᩅᨲᩮᩣ ᨽᩣᩈᩥᨲᩴ ᩋᨽᩥᨶᨶ᩠ᨴᩥᨲ᩠ᩅᩣ ᩋᨶᩩᨾᩮᩣᨴᩥᨲ᩠ᩅᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ ᨸᨾᩩᨴᩥᨲᩮᩣ ᩏᨴᨣ᩠ᨣᩮᩣ ᨸᩦᨲᩥᩈᩮᩣᨾᨶᩔᨩᩣᨲᩮᩣ ¶ ᩏᨭ᩠ᨮᩣᨿᩣᩈᨶᩣ ᩑᨠᩴᩈᩴ ᩏᨲ᩠ᨲᩁᩣᩈᨦ᩠ᨣᩴ ᨠᩁᩥᨲ᩠ᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᨬ᩠ᨩᩃᩥᩴ ᨸᨱᩣᨾᩮᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩈᨾ᩠ᨾᩩᨡᩣ ᩈᩣᩁᩩᨸ᩠ᨸᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨽᩥᨲ᩠ᨳᩅᩥ –

‘‘ᨿᩣᨶᩥ ¶ ¶ ᨧ ᨲᩦᨱᩥ ᨿᩣᨶᩥ ᨧ ᩈᨭ᩠ᨮᩥ, ᩈᨾᨱᨸ᩠ᨸᩅᩣᨴᩈᩥᨲᩣᨶᩥ [ᩈᨾᨱᨸ᩠ᨸᩅᩣᨴᨶᩥᩔᩥᨲᩣᨶᩥ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨽᩪᩁᩥᨸᨬ᩠ᨬ;

ᩈᨬ᩠ᨬᨠ᩠ᨡᩁᩈᨬ᩠ᨬᨶᩥᩔᩥᨲᩣᨶᩥ, ᩒᩈᩁᨱᩣᨶᩥ ᩅᩥᨶᩮᨿ᩠ᨿ ᩒᨥᨲᨾᨣᩣ.

‘‘ᩋᨶ᩠ᨲᨣᩪᩈᩥ ¶ ᨸᩣᩁᨣᩪ [ᨸᩣᩁᨣᩪᩈᩥ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᨴᩩᨠ᩠ᨡᩔ, ᩋᩁᩉᩣᩈᩥ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ ᨡᩦᨱᩣᩈᩅᩴ ᨲᩴ ᨾᨬ᩠ᨬᩮ;

ᨩᩩᨲᩥᨾᩣ ᨾᩩᨲᩥᨾᩣ ᨸᩉᩪᨲᨸᨬ᩠ᨬᩮᩣ, ᨴᩩᨠ᩠ᨡᩔᨶ᩠ᨲᨠᩁᩴ ᩋᨲᩣᩁᩮᩈᩥ ᨾᩴ.

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

ᨾᩩᨶᩥ ᨾᩮᩣᨶᨸᨳᩮᩈᩩ ᨸᨲ᩠ᨲᩥᨸᨲ᩠ᨲ, ᩋᨡᩥᩃ ᩌᨴᩥᨧ᩠ᨧᨻᨶ᩠ᨵᩩ ᩈᩮᩣᩁᨲᩮᩣᩈᩥ.

‘‘ᨿᩣ ¶ ᨾᩮ ᨠᨦ᩠ᨡᩣ ᨸᩩᩁᩮ ᩌᩈᩥ, ᨲᩴ ᨾᩮ ᨻ᩠ᨿᩣᨠᩣᩈᩥ ᨧᨠ᩠ᨡᩩᨾᩣ;

ᩋᨴ᩠ᨵᩣ ᨾᩩᨶᩦᩈᩥ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ, ᨶᨲ᩠ᨳᩥ ᨶᩦᩅᩁᨱᩣ ᨲᩅ.

‘‘ᩏᨸᩣᨿᩣᩈᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᩮ, ᩅᩥᨴ᩠ᨵᩈ᩠ᨲᩣ ᩅᩥᨶᩊᩦᨠᨲᩣ;

ᩈᩦᨲᩥᨽᩪᨲᩮᩣ ᨴᨾᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᨵᩥᨲᩥᨾᩣ ᩈᨧ᩠ᨧᨶᩥᨠ᩠ᨠᨾᩮᩣ.

‘‘ᨲᩔ ᨲᩮ ᨶᩣᨣᨶᩣᨣᩔ, ᨾᩉᩣᩅᩦᩁᩔ ᨽᩣᩈᨲᩮᩣ;

ᩈᨻ᩠ᨻᩮ ᨴᩮᩅᩣᨶᩩᨾᩮᩣᨴᨶ᩠ᨲᩥ, ᩏᨽᩮᩣ ᨶᩣᩁᨴᨸᨻ᩠ᨻᨲᩣ.

‘‘ᨶᨾᩮᩣ ᨲᩮ ᨸᩩᩁᩥᩈᩣᨩᨬ᩠ᨬ, ᨶᨾᩮᩣ ᨲᩮ ᨸᩩᩁᩥᩈᩩᨲ᩠ᨲᨾ;

ᩈᨴᩮᩅᨠᩈ᩠ᨾᩥᩴ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ, ᨶᨲ᩠ᨳᩥ ᨲᩮ ᨸᨭᩥᨸᩩᨣ᩠ᨣᩃᩮᩣ.

‘‘ᨲᩩᩅᩴ ¶ ᨻᩩᨴ᩠ᨵᩮᩣ ᨲᩩᩅᩴ ᩈᨲ᩠ᨳᩣ, ᨲᩩᩅᩴ ᨾᩣᩁᩣᨽᩥᨽᩪ ᨾᩩᨶᩥ;

ᨲᩩᩅᩴ ᩋᨶᩩᩈᨿᩮ ᨨᩮᨲ᩠ᩅᩣ, ᨲᩥᨱ᩠ᨱᩮᩣ ᨲᩣᩁᩮᩈᩥ ᨾᩴ ᨸᨩᩴ.

‘‘ᩏᨸᨵᩦ ᨲᩮ ᩈᨾᨲᩥᨠ᩠ᨠᨶ᩠ᨲᩣ, ᩌᩈᩅᩣ ᨲᩮ ᨸᨴᩣᩃᩥᨲᩣ;

ᩈᩦᩉᩮᩣᩈᩥ ᩋᨶᩩᨸᩣᨴᩣᨶᩮᩣ, ᨸᩉᩦᨶᨽᨿᨽᩮᩁᩅᩮᩣ.

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

ᩑᩅᩴ ᨸᩩᨬ᩠ᨬᩮ ᨧ ᨸᩣᨸᩮ ᨧ, ᩏᨽᨿᩮ ᨲ᩠ᩅᩴ ᨶ ᩃᩥᨾ᩠ᨸᩈᩥ;

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

ᩋᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ ᨽᨣᩅᨲᩮᩣ ᨸᩣᨴᩮᩈᩩ ᩈᩥᩁᩈᩣ ᨶᩥᨸᨲᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ ¶ – ‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ, ᨽᨶ᩠ᨲᩮ…ᨸᩮ… ᩑᩈᩣᩉᩴ ᨽᨣᩅᨶ᩠ᨲᩴ ᩈᩁᨱᩴ ᨣᨧ᩠ᨨᩣᨾᩥ ᨵᨾ᩠ᨾᨬ᩠ᨧ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᨬ᩠ᨧ; ᩃᨽᩮᨿ᩠ᨿᩣᩉᩴ, ᨽᨶ᩠ᨲᩮ, ᨽᨣᩅᨲᩮᩣ ᩈᨶ᩠ᨲᩥᨠᩮ ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ, ᩃᨽᩮᨿ᩠ᨿᩴ ᩏᨸᩈᨾ᩠ᨸᨴ’’ᨶ᩠ᨲᩥ ¶ .

‘‘ᨿᩮᩣ ᨡᩮᩣ, ᩈᨽᩥᨿ, ᩋᨬ᩠ᨬᨲᩥᨲ᩠ᨳᩥᨿᨸᩩᨻ᩠ᨻᩮᩣ ᩍᨾᩈ᩠ᨾᩥᩴ ᨵᨾ᩠ᨾᩅᩥᨶᨿᩮ ᩌᨠᨦ᩠ᨡᨲᩥ ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ, ᩌᨠᨦ᩠ᨡᨲᩥ ᩏᨸᩈᨾ᩠ᨸᨴᩴ, ᩈᩮᩣ ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᨾᩣᩈᩮ ᨸᩁᩥᩅᩈᨲᩥ; ᨧᨲᩩᨶ᩠ᨶᩴ ᨾᩣᩈᩣᨶᩴ ᩋᨧ᩠ᨧᨿᩮᨶ ᩌᩁᨴ᩠ᨵᨧᩥᨲ᩠ᨲᩣ ᨽᩥᨠ᩠ᨡᩪ ᨸᨻ᩠ᨻᩣᨩᩮᨶ᩠ᨲᩥ, ᩏᨸᩈᨾ᩠ᨸᩣᨴᩮᨶ᩠ᨲᩥ ᨽᩥᨠ᩠ᨡᩩᨽᩣᩅᩣᨿ. ᩋᨸᩥ ᨧ ᨾᩮᨲ᩠ᨳ ᨸᩩᨣ᩠ᨣᩃᩅᩮᨾᨲ᩠ᨲᨲᩣ ᩅᩥᨴᩥᨲᩣ’’ᨲᩥ.

‘‘ᩈᨧᩮ, ᨽᨶ᩠ᨲᩮ, ᩋᨬ᩠ᨬᨲᩥᨲ᩠ᨳᩥᨿᨸᩩᨻ᩠ᨻᩣ ᩍᨾᩈ᩠ᨾᩥᩴ ᨵᨾ᩠ᨾᩅᩥᨶᨿᩮ ᩌᨠᨦ᩠ᨡᨶ᩠ᨲᩣ ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ, ᩌᨠᨦ᩠ᨡᨶ᩠ᨲᩣ ¶ ᩏᨸᩈᨾ᩠ᨸᨴᩴ ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᨾᩣᩈᩮ ᨸᩁᩥᩅᩈᨶ᩠ᨲᩥ, ᨧᨲᩩᨶ᩠ᨶᩴ ᨾᩣᩈᩣᨶᩴ ᩋᨧ᩠ᨧᨿᩮᨶ ᩌᩁᨴ᩠ᨵᨧᩥᨲ᩠ᨲᩣ ᨽᩥᨠ᩠ᨡᩪ ᨸᨻ᩠ᨻᩣᨩᩮᨶ᩠ᨲᩥ, ᩏᨸᩈᨾ᩠ᨸᩣᨴᩮᨶ᩠ᨲᩥ ᨽᩥᨠ᩠ᨡᩩᨽᩣᩅᩣᨿ, ᩋᩉᩴ ᨧᨲ᩠ᨲᩣᩁᩥ ᩅᩔᩣᨶᩥ ᨸᩁᩥᩅᩈᩥᩔᩣᨾᩥ; ᨧᨲᩩᨶ᩠ᨶᩴ ᩅᩔᩣᨶᩴ ᩋᨧ᩠ᨧᨿᩮᨶ ᩌᩁᨴ᩠ᨵᨧᩥᨲ᩠ᨲᩣ ᨽᩥᨠ᩠ᨡᩪ ᨸᨻ᩠ᨻᩣᨩᩮᨶ᩠ᨲᩩ ᩏᨸᩈᨾ᩠ᨸᩣᨴᩮᨶ᩠ᨲᩩ ᨽᩥᨠ᩠ᨡᩩᨽᩣᩅᩣᨿᩣ’’ᨲᩥ. ᩋᩃᨲ᩠ᨳ ᨡᩮᩣ ᩈᨽᩥᨿᩮᩣ ᨸᩁᩥᨻ᩠ᨻᩣᨩᨠᩮᩣ ᨽᨣᩅᨲᩮᩣ ᩈᨶ᩠ᨲᩥᨠᩮ ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ ᩋᩃᨲ᩠ᨳ ᩏᨸᩈᨾ᩠ᨸᨴᩴ…ᨸᩮ… ᩋᨬ᩠ᨬᨲᩁᩮᩣ ᨡᩮᩣ ᨸᨶᩣᨿᩈ᩠ᨾᩣ ᩈᨽᩥᨿᩮᩣ ᩋᩁᩉᨲᩴ ᩋᩉᩮᩣᩈᩦᨲᩥ.

ᩑᩅᩴ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩋᨦ᩠ᨣᩩᨲ᩠ᨲᩁᩣᨸᩮᩈᩩ ᨧᩣᩁᩥᨠᩴ ᨧᩁᨾᩣᨶᩮᩣ ᨾᩉᨲᩣ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶ ᩈᨴ᩠ᨵᩥᩴ ᩋᨯ᩠ᨰᨲᩮᩊᩈᩮᩉᩥ ¶ ᨽᩥᨠ᩠ᨡᩩᩈᨲᩮᩉᩥ ᨿᩮᨶ ᩌᨸᨱᩴ ᨶᩣᨾ ᩋᨦ᩠ᨣᩩᨲ᩠ᨲᩁᩣᨸᩣᨶᩴ ᨶᩥᨣᨾᩮᩣ ᨲᨴᩅᩈᩁᩥ. ᩋᩔᩮᩣᩈᩥ ¶ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ‘‘ᩈᨾᨱᩮᩣ ᨡᩃᩩ, ᨽᩮᩣ, ᨣᩮᩣᨲᨾᩮᩣ ᩈᨠ᩠ᨿᨸᩩᨲ᩠ᨲᩮᩣ ᩈᨠ᩠ᨿᨠᩩᩃᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ ᩋᨦ᩠ᨣᩩᨲ᩠ᨲᩁᩣᨸᩮᩈᩩ ᨧᩣᩁᩥᨠᩴ ᨧᩁᨾᩣᨶᩮᩣ ᨾᩉᨲᩣ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶ ᩈᨴ᩠ᨵᩥᩴ ᩋᨯ᩠ᨰᨲᩮᩊᩈᩮᩉᩥ ᨽᩥᨠ᩠ᨡᩩᩈᨲᩮᩉᩥ ᩌᨸᨱᩴ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ. ᨲᩴ ᨡᩮᩣ ᨸᨶ ᨽᩅᨶ᩠ᨲᩴ ᨣᩮᩣᨲᨾᩴ ¶ ᩑᩅᩴ ᨠᩃ᩠ᨿᩣᨱᩮᩣ ᨠᩥᨲ᩠ᨲᩥᩈᨴ᩠ᨴᩮᩣ ᩋᨻ᩠ᨽᩩᨣ᩠ᨣᨲᩮᩣ – ‘ᩍᨲᩥᨸᩥ ᩈᩮᩣ ᨽᨣᩅᩣ ᩋᩁᩉᩴ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ ᩅᩥᨩ᩠ᨩᩣᨧᩁᨱᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ ᩈᩩᨣᨲᩮᩣ ᩃᩮᩣᨠᩅᩥᨴᩪ ᩋᨶᩩᨲ᩠ᨲᩁᩮᩣ ᨸᩩᩁᩥᩈᨴᨾ᩠ᨾᩈᩣᩁᨳᩥ ᩈᨲ᩠ᨳᩣ ᨴᩮᩅᨾᨶᩩᩔᩣᨶᩴ ᨻᩩᨴ᩠ᨵᩮᩣ ᨽᨣᩅᩣ’ᨲᩥ [ᨽᨣᩅᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)]. ᩈᩮᩣ ᩍᨾᩴ ᩃᩮᩣᨠᩴ ᩈᨴᩮᩅᨠᩴ ᩈᨾᩣᩁᨠᩴ ᩈᨻᩕᩉ᩠ᨾᨠᩴ ᩈᩔᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩥᩴ ᨸᨩᩴ ᩈᨴᩮᩅᨾᨶᩩᩔᩴ ᩈᨿᩴ ᩋᨽᩥᨬ᩠ᨬᩣ ᩈᨧ᩠ᨨᩥᨠᨲ᩠ᩅᩣ ᨸᩅᩮᨴᩮᨲᩥ. ᩈᩮᩣ ᨵᨾ᩠ᨾᩴ ᨴᩮᩈᨲᩥ ᩌᨴᩥᨠᩃ᩠ᨿᩣᨱᩴ ᨾᨩ᩠ᨫᩮᨠᩃ᩠ᨿᩣᨱᩴ ᨸᩁᩥᨿᩮᩣᩈᩣᨶᨠᩃ᩠ᨿᩣᨱᩴ ᩈᩣᨲ᩠ᨳᩴ ᩈᨻ᩠ᨿᨬ᩠ᨩᨶᩴ, ᨠᩮᩅᩃᨸᩁᩥᨸᩩᨱ᩠ᨱᩴ ¶ ᨸᩁᩥᩈᩩᨴ᩠ᨵᩴ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ ᨸᨠᩣᩈᩮᨲᩥ. ᩈᩣᨵᩩ ᨡᩮᩣ ᨸᨶ ᨲᨳᩣᩁᩪᨸᩣᨶᩴ ᩋᩁᩉᨲᩴ ᨴᩔᨶᩴ ᩉᩮᩣᨲᩦ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩣ ᩈᨴ᩠ᨵᩥᩴ ᩈᨾ᩠ᨾᩮᩣᨴᩥ. ᩈᨾ᩠ᨾᩮᩣᨴᨶᩦᨿᩴ ᨠᨳᩴ ᩈᩣᩁᨱᩦᨿᩴ ᩅᩦᨲᩥᩈᩣᩁᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩴ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩴ ᨩᨭᩥᩃᩴ ᨽᨣᩅᩣ ᨵᨾ᩠ᨾᩥᨿᩣ ᨠᨳᩣᨿ ᩈᨶ᩠ᨴᩔᩮᩈᩥ ᩈᨾᩣᨴᨸᩮᩈᩥ ᩈᨾᩩᨲ᩠ᨲᩮᨩᩮᩈᩥ ᩈᨾ᩠ᨸᩉᩴᩈᩮᩈᩥ. ᩋᨳ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨽᨣᩅᨲᩣ ᨵᨾ᩠ᨾᩥᨿᩣ ᨠᨳᩣᨿ ᩈᨶ᩠ᨴᩔᩥᨲᩮᩣ ᩈᨾᩣᨴᨸᩥᨲᩮᩣ ᩈᨾᩩᨲ᩠ᨲᩮᨩᩥᨲᩮᩣ ᩈᨾ᩠ᨸᩉᩴᩈᩥᨲᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᩋᨵᩥᩅᩣᩈᩮᨲᩩ ᨾᩮ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᩈ᩠ᩅᩣᨲᨶᩣᨿ ᨽᨲ᩠ᨲᩴ ᩈᨴ᩠ᨵᩥᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶᩣ’’ᨲᩥ. ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᨽᨣᩅᩣ ᨠᩮᨱᩥᨿᩴ ᨩᨭᩥᩃᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨾᩉᩣ ᨡᩮᩣ, ᨠᩮᨱᩥᨿ, ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᩣ ¶ ᩋᨯ᩠ᨰᨲᩮᩊᩈᩣᨶᩥ ᨽᩥᨠ᩠ᨡᩩᩈᨲᩣᨶᩥ; ᨲ᩠ᩅᨬ᩠ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ¶ ᩋᨽᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᩣ’’ᨲᩥ.

ᨴᩩᨲᩥᨿᨾ᩠ᨸᩥ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩥᨬ᩠ᨧᩣᨸᩥ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᨾᩉᩣ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᩣ ᩋᨯ᩠ᨰᨲᩮᩊᩈᩣᨶᩥ ᨽᩥᨠ᩠ᨡᩩᩈᨲᩣᨶᩥ, ᩋᩉᨬ᩠ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ᩋᨽᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᩣ; ᩋᨵᩥᩅᩣᩈᩮᨲᩩ ᨾᩮ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᩈ᩠ᩅᩣᨲᨶᩣᨿ ᨽᨲ᩠ᨲᩴ ᩈᨴ᩠ᨵᩥᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶᩣ’’ᨲᩥ. ᨴᩩᨲᩥᨿᨾ᩠ᨸᩥ ᨡᩮᩣ ᨽᨣᩅᩣ ᨠᩮᨱᩥᨿᩴ ᨩᨭᩥᩃᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨾᩉᩣ ᨡᩮᩣ, ᨠᩮᨱᩥᨿ, ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᩣ ᩋᨯ᩠ᨰᨲᩮᩊᩈᩣᨶᩥ ᨽᩥᨠ᩠ᨡᩩᩈᨲᩣᨶᩥ; ᨲ᩠ᩅᨬ᩠ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ᩋᨽᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᩣ’’ᨲᩥ.

ᨲᨲᩥᨿᨾ᩠ᨸᩥ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩥᨬ᩠ᨧᩣᨸᩥ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᨾᩉᩣ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᩣ ᩋᨯ᩠ᨰᨲᩮᩊᩈᩣᨶᩥ ᨽᩥᨠ᩠ᨡᩩᩈᨲᩣᨶᩥ, ᩋᩉᨬ᩠ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ᩋᨽᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᩣ, ᩋᨵᩥᩅᩣᩈᩮᨲᩩ [ᩋᨵᩥᩅᩣᩈᩮᨲ᩠ᩅᩮᩅ (ᩈᩦ.)] ᨾᩮ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᩈ᩠ᩅᩣᨲᨶᩣᨿ ᨽᨲ᩠ᨲᩴ ᩈᨴ᩠ᨵᩥᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶᩣ’’ᨲᩥ. ᩋᨵᩥᩅᩣᩈᩮᩈᩥ ᨽᨣᩅᩣ ᨲᩩᨱ᩠ᩉᩦᨽᩣᩅᩮᨶ. ᩋᨳ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨽᨣᩅᨲᩮᩣ ᩋᨵᩥᩅᩣᩈᨶᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ¶ ᩏᨭ᩠ᨮᩣᨿᩣᩈᨶᩣ ᨿᩮᨶ ᩈᨠᩮᩣ ᩋᩔᨾᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨾᩥᨲ᩠ᨲᩣᨾᨧ᩠ᨧᩮ ᨬᩣᨲᩥᩈᩣᩃᩮᩣᩉᩥᨲᩮ ᩌᨾᨶ᩠ᨲᩮᩈᩥ – ‘‘ᩈᩩᨱᨶ᩠ᨲᩩ ᨾᩮ ᨽᩅᨶ᩠ᨲᩮᩣ ᨾᩥᨲ᩠ᨲᩣᨾᨧ᩠ᨧᩣ ᨬᩣᨲᩥᩈᩣᩃᩮᩣᩉᩥᨲᩣ, ᩈᨾᨱᩮᩣ ᨾᩮ ᨣᩮᩣᨲᨾᩮᩣ ᨶᩥᨾᨶ᩠ᨲᩥᨲᩮᩣ ᩈ᩠ᩅᩣᨲᨶᩣᨿ ᨽᨲ᩠ᨲᩴ ᩈᨴ᩠ᨵᩥᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶ, ᨿᩮᨶ ᨾᩮ ᨠᩣᨿᩅᩮᨿ᩠ᨿᩣᩅᨭᩥᨠᩴ ᨠᩁᩮᨿ᩠ᨿᩣᨳᩣ’’ᨲᩥ. ‘‘ᩑᩅᩴ, ᨽᩮᩣ’’ᨲᩥ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩔ ᨩᨭᩥᩃᩔ ᨾᩥᨲ᩠ᨲᩣᨾᨧ᩠ᨧᩣ ᨬᩣᨲᩥᩈᩣᩃᩮᩣᩉᩥᨲᩣ ᨠᩮᨱᩥᨿᩔ ᨩᨭᩥᩃᩔ ᨸᨭᩥᩔᩩᨲ᩠ᩅᩣ ᩋᨸ᩠ᨸᩮᨠᨧ᩠ᨧᩮ ᩏᨴ᩠ᨵᨶᩣᨶᩥ ᨡᨱᨶ᩠ᨲᩥ, ᩋᨸ᩠ᨸᩮᨠᨧ᩠ᨧᩮ ᨠᨭ᩠ᨮᩣᨶᩥ ᨹᩣᩃᩮᨶ᩠ᨲᩥ, ᩋᨸ᩠ᨸᩮᨠᨧ᩠ᨧᩮ ᨽᩣᨩᨶᩣᨶᩥ ᨵᩮᩣᩅᨶ᩠ᨲᩥ, ᩋᨸ᩠ᨸᩮᨠᨧ᩠ᨧᩮ ᩏᨴᨠᨾᨱᩥᨠᩴ ᨸᨲᩥᨭ᩠ᨮᩣᨸᩮᨶ᩠ᨲᩥ, ᩋᨸ᩠ᨸᩮᨠᨧ᩠ᨧᩮ ᩌᩈᨶᩣᨶᩥ ᨸᨬ᩠ᨬᩣᨸᩮᨶ᩠ᨲᩥ. ᨠᩮᨱᩥᨿᩮᩣ ᨸᨶ ᨩᨭᩥᩃᩮᩣ ᩈᩣᨾᩴᨿᩮᩅ ᨾᨱ᩠ᨯᩃᨾᩣᩊᩴ ¶ ᨸᨭᩥᨿᩣᨴᩮᨲᩥ.

ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩌᨸᨱᩮ ᨸᨭᩥᩅᩈᨲᩥ, ᨲᩥᨱ᩠ᨱᩴ ¶ ᩅᩮᨴᩣᨶᩴ ᨸᩣᩁᨣᩪ ᩈᨶᩥᨥᨱ᩠ᨯᩩᨠᩮᨭᩩᨽᩣᨶᩴ ¶ ᩈᩣᨠ᩠ᨡᩁᨸ᩠ᨸᨽᩮᨴᩣᨶᩴ ᩍᨲᩥᩉᩣᩈᨸᨬ᩠ᨧᨾᩣᨶᩴ ᨸᨴᨠᩮᩣ ᩅᩮᨿ᩠ᨿᩣᨠᩁᨱᩮᩣ ᩃᩮᩣᨠᩣᨿᨲᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩮᩈᩩ ᩋᨶᩅᨿᩮᩣ, ᨲᩦᨱᩥ ᨧ ᨾᩣᨱᩅᨠᩈᨲᩣᨶᩥ ᨾᨶ᩠ᨲᩮ ᩅᩣᨧᩮᨲᩥ.

ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᩈᩮᩃᩮ ᨻᩕᩣᩉ᩠ᨾᨱᩮ ᩋᨽᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᩣ ᩉᩮᩣᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨲᩦᩉᩥ ᨾᩣᨱᩅᨠᩈᨲᩮᩉᩥ ᨸᩁᩥᩅᩩᨲᩮᩣ ᨩᨦ᩠ᨥᩣᩅᩥᩉᩣᩁᩴ ᩋᨶᩩᨧᨦ᩠ᨠᨾᨾᩣᨶᩮᩣ ᩋᨶᩩᩅᩥᨧᩁᨾᩣᨶᩮᩣ ᨿᩮᨶ ᨠᩮᨱᩥᨿᩔ ᨩᨭᩥᩃᩔ ᩋᩔᨾᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ. ᩋᨴ᩠ᨴᩈᩣ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨠᩮᨱᩥᨿᩔ ᨩᨭᩥᩃᩔ ᩋᩔᨾᩮ [ᨠᩮᨱᩥᩔᨾᩥᨿᩮ ᨩᨭᩥᩃᩮ (ᩈᩦ. ᨸᩦ.)] ᩋᨸ᩠ᨸᩮᨠᨧ᩠ᨧᩮ ᩏᨴ᩠ᨵᨶᩣᨶᩥ ᨡᨱᨶ᩠ᨲᩮ…ᨸᩮ… ᩋᨸ᩠ᨸᩮᨠᨧ᩠ᨧᩮ ᩌᩈᨶᩣᨶᩥ ᨸᨬ᩠ᨬᨸᩮᨶ᩠ᨲᩮ, ᨠᩮᨱᩥᨿᩴ ᨸᨶ ᨩᨭᩥᩃᩴ ᩈᩣᨾᩴᨿᩮᩅ ᨾᨱ᩠ᨯᩃᨾᩣᩊᩴ ᨸᨭᩥᨿᩣᨴᩮᨶ᩠ᨲᩴ. ᨴᩥᩈ᩠ᩅᩣᨶ ᨠᩮᨱᩥᨿᩴ ᨩᨭᩥᩃᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩥᩴ ᨶᩩ ᨡᩮᩣ ᨽᩮᩣᨲᩮᩣ ᨠᩮᨱᩥᨿᩔ ᩌᩅᩣᩉᩮᩣ ᩅᩣ ᨽᩅᩥᩔᨲᩥ, ᩅᩥᩅᩣᩉᩮᩣ ᩅᩣ ᨽᩅᩥᩔᨲᩥ, ᨾᩉᩣᨿᨬ᩠ᨬᩮᩣ ᩅᩣ ᨸᨧ᩠ᨧᩩᨸᨭ᩠ᨮᩥᨲᩮᩣ, ᩁᩣᨩᩣ ᩅᩣ ᨾᩣᨣᨵᩮᩣ ᩈᩮᨶᩥᨿᩮᩣ ᨻᩥᨾ᩠ᨻᩥᩈᩣᩁᩮᩣ ᨶᩥᨾᨶ᩠ᨲᩥᨲᩮᩣ ᩈ᩠ᩅᩣᨲᨶᩣᨿ ᩈᨴ᩠ᨵᩥᩴ ᨻᩃᨠᩣᨿᩮᨶᩣ’’ᨲᩥ?

‘‘ᨶ ᨾᩮ, ᨽᩮᩣ ᩈᩮᩃ, ᩌᩅᩣᩉᩮᩣ ᩅᩣ ᨽᩅᩥᩔᨲᩥ ᩅᩥᩅᩣᩉᩮᩣ ᩅᩣ, ᨶᩣᨸᩥ ᩁᩣᨩᩣ ᨾᩣᨣᨵᩮᩣ ᩈᩮᨶᩥᨿᩮᩣ ᨻᩥᨾ᩠ᨻᩥᩈᩣᩁᩮᩣ ᨶᩥᨾᨶ᩠ᨲᩥᨲᩮᩣ ᩈ᩠ᩅᩣᨲᨶᩣᨿ ᩈᨴ᩠ᨵᩥᩴ ᨻᩃᨠᩣᨿᩮᨶ; ᩋᨸᩥ ᨧ ᨡᩮᩣ ᨾᩮ ᨾᩉᩣᨿᨬ᩠ᨬᩮᩣ ᨸᨧ᩠ᨧᩩᨸᨭ᩠ᨮᩥᨲᩮᩣ. ᩋᨲ᩠ᨳᩥ ᩈᨾᨱᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ ᩈᨠ᩠ᨿᨸᩩᨲ᩠ᨲᩮᩣ ᩈᨠ᩠ᨿᨠᩩᩃᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ ᩋᨦ᩠ᨣᩩᨲ᩠ᨲᩁᩣᨸᩮᩈᩩ ᨧᩣᩁᩥᨠᩴ ¶ ᨧᩁᨾᩣᨶᩮᩣ ᨾᩉᨲᩣ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶ ᩈᨴ᩠ᨵᩥᩴ ᩋᨯ᩠ᨰᨲᩮᩊᩈᩮᩉᩥ ¶ ᨽᩥᨠ᩠ᨡᩩᩈᨲᩮᩉᩥ ᩌᨸᨱᩴ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ. ᨲᩴ ᨡᩮᩣ ᨸᨶ ¶ ᨽᩅᨶ᩠ᨲᩴ ᨣᩮᩣᨲᨾᩴ…ᨸᩮ… ᨻᩩᨴ᩠ᨵᩮᩣ ᨽᨣᩅᩣᨲᩥ. ᩈᩮᩣ ᨾᩮ ᨶᩥᨾᨶ᩠ᨲᩥᨲᩮᩣ ᩈ᩠ᩅᩣᨲᨶᩣᨿ ᨽᨲ᩠ᨲᩴ ᩈᨴ᩠ᨵᩥᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶᩣ’’ᨲᩥ. ‘‘ᨻᩩᨴ᩠ᨵᩮᩣᨲᩥ, ᨽᩮᩣ ᨠᩮᨱᩥᨿ, ᩅᨴᩮᩈᩥ’’? ‘‘ᨻᩩᨴ᩠ᨵᩮᩣᨲᩥ, ᨽᩮᩣ ᩈᩮᩃ, ᩅᨴᩣᨾᩥ’’. ‘‘ᨻᩩᨴ᩠ᨵᩮᩣᨲᩥ, ᨽᩮᩣ ᨠᩮᨱᩥᨿ, ᩅᨴᩮᩈᩥ’’? ‘‘ᨻᩩᨴ᩠ᨵᩮᩣᨲᩥ, ᨽᩮᩣ ᩈᩮᩃ, ᩅᨴᩣᨾᩦ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᩮᩃᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᨥᩮᩣᩈᩮᩣᨸᩥ ᨡᩮᩣ ᩑᩈᩮᩣ ᨴᩩᩃ᩠ᩃᨽᩮᩣ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ ᨿᨴᩥᨴᩴ ᨻᩩᨴ᩠ᨵᩮᩣᨲᩥ. ᩌᨣᨲᩣᨶᩥ ᨡᩮᩣ ᨸᨶᨾ᩠ᩉᩣᨠᩴ ᨾᨶ᩠ᨲᩮᩈᩩ ᨴ᩠ᩅᨲ᩠ᨲᩥᩴᩈᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩣᨶᩥ, ᨿᩮᩉᩥ ᩈᨾᨶ᩠ᨶᩣᨣᨲᩔ ᨾᩉᩣᨸᩩᩁᩥᩈᩔ ᨴ᩠ᩅᩮᩅ ᨣᨲᩥᨿᩮᩣ ᨽᩅᨶ᩠ᨲᩥ ᩋᨶᨬ᩠ᨬᩣ. ᩈᨧᩮ ᩋᨣᩣᩁᩴ ᩋᨩ᩠ᨫᩣᩅᩈᨲᩥ ᩁᩣᨩᩣ ᩉᩮᩣᨲᩥ ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩥ ᨵᨾ᩠ᨾᩥᨠᩮᩣ ᨵᨾ᩠ᨾᩁᩣᨩᩣ ᨧᩣᨲᩩᩁᨶ᩠ᨲᩮᩣ ᩅᩥᨩᩥᨲᩣᩅᩦ ᨩᨶᨸᨴᨲ᩠ᨳᩣᩅᩁᩥᨿᨸ᩠ᨸᨲ᩠ᨲᩮᩣ ᩈᨲ᩠ᨲᩁᨲᨶᩈᨾᨶ᩠ᨶᩣᨣᨲᩮᩣ. ᨲᩔᩥᨾᩣᨶᩥ ᩈᨲ᩠ᨲ ᩁᨲᨶᩣᨶᩥ ᨽᩅᨶ᩠ᨲᩥ, ᩈᩮᨿ᩠ᨿᨳᩥᨴᩴ – ᨧᨠ᩠ᨠᩁᨲᨶᩴ, ᩉᨲ᩠ᨳᩥᩁᨲᨶᩴ, ᩋᩔᩁᨲᨶᩴ, ᨾᨱᩥᩁᨲᨶᩴ, ᩍᨲ᩠ᨳᩥᩁᨲᨶᩴ, ᨣᩉᨸᨲᩥᩁᨲᨶᩴ, ᨸᩁᩥᨱᩣᨿᨠᩁᨲᨶᨾᩮᩅ ᩈᨲ᩠ᨲᨾᩴ. ᨸᩁᩮᩣᩈᩉᩔᩴ ᨡᩮᩣ ᨸᨶᩔ ᨸᩩᨲ᩠ᨲᩣ ᨽᩅᨶ᩠ᨲᩥ ᩈᩪᩁᩣ ᩅᩦᩁᨦ᩠ᨣᩁᩪᨸᩣ ᨸᩁᩈᩮᨶᨸ᩠ᨸᨾᨴ᩠ᨴᨶᩣ. ᩈᩮᩣ ᩍᨾᩴ ᨸᨳᩅᩥᩴ ᩈᩣᨣᩁᨸᩁᩥᨿᨶ᩠ᨲᩴ ᩋᨴᨱ᩠ᨯᩮᨶ ᩋᩈᨲ᩠ᨳᩮᨶ ᨵᨾ᩠ᨾᩮᨶ ᩋᨽᩥᩅᩥᨩᩥᨿ ᩋᨩ᩠ᨫᩣᩅᩈᨲᩥ. ᩈᨧᩮ ᨡᩮᩣ ᨸᨶ ᩋᨣᩣᩁᩈ᩠ᨾᩣ ᩋᨶᨣᩣᩁᩥᨿᩴ ᨸᨻ᩠ᨻᨩᨲᩥ, ᩋᩁᩉᩴ ᩉᩮᩣᨲᩥ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ ᩃᩮᩣᨠᩮ ᩅᩥᩅᨭ᩠ᨭᨧ᩠ᨨᨴᩮᩣ [ᩅᩥᩅᨲ᩠ᨲᨧ᩠ᨨᨴ᩠ᨴᩮᩣ (ᩈᩦ. ᨸᩦ.)]. ᨠᩉᩴ ᨸᨶ, ᨽᩮᩣ ᨠᩮᨱᩥᨿ, ᩑᨲᩁᩉᩥ ᩈᩮᩣ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᩅᩥᩉᩁᨲᩥ ¶ ᩋᩁᩉᩴ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ’’ᨲᩥ?

ᩑᩅᩴ ¶ ᩅᩩᨲ᩠ᨲᩮ, ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨴᨠ᩠ᨡᩥᨱᩴ ᨻᩣᩉᩩᩴ ᨸᨣ᩠ᨣᩉᩮᨲ᩠ᩅᩣ ᩈᩮᩃᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨿᩮᨶᩮᩈᩣ ¶ , ᨽᩮᩣ ᩈᩮᩃ, ᨶᩦᩃᩅᨶᩁᩣᨩᩦ’’ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨲᩦᩉᩥ ᨾᩣᨱᩅᨠᩈᨲᩮᩉᩥ ᩈᨴ᩠ᨵᩥᩴ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨲᩮ ᨾᩣᨱᩅᨠᩮ ᩌᨾᨶ᩠ᨲᩮᩈᩥ – ‘‘ᩋᨸ᩠ᨸᩈᨴ᩠ᨴᩣ ᨽᩮᩣᨶ᩠ᨲᩮᩣ ᩌᨣᨧ᩠ᨨᨶ᩠ᨲᩩ, ᨸᨴᩮ ᨸᨴᩴ ᨶᩥᨠ᩠ᨡᩥᨸᨶ᩠ᨲᩣ. ᨴᩩᩁᩣᩈᨴᩣ ᩉᩥ ᨲᩮ ᨽᨣᩅᨶ᩠ᨲᩮᩣ [ᨽᩅᨶ᩠ᨲᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩈᩦᩉᩣᩅ ᩑᨠᨧᩁᩣ. ᨿᨴᩣ ᨧᩣᩉᩴ, ᨽᩮᩣ, ᩈᨾᨱᩮᨶ ᨣᩮᩣᨲᨾᩮᨶ ᩈᨴ᩠ᨵᩥᩴ ᨾᨶ᩠ᨲᩮᨿ᩠ᨿᩩᩴ, ᨾᩣ ᨾᩮ ᨽᩮᩣᨶ᩠ᨲᩮᩣ ᩋᨶ᩠ᨲᩁᨶ᩠ᨲᩁᩣ ᨠᨳᩴ ᩒᨸᩣᨲᩮᨳ; ᨠᨳᩣᨸᩁᩥᨿᩮᩣᩈᩣᨶᩴ ᨾᩮ ᨽᩅᨶ᩠ᨲᩮᩣ ᩌᨣᨾᩮᨶ᩠ᨲᩪ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩣ ᩈᨴ᩠ᨵᩥᩴ ᩈᨾ᩠ᨾᩮᩣᨴᩥ. ᩈᨾ᩠ᨾᩮᩣᨴᨶᩦᨿᩴ ᨠᨳᩴ ᩈᩣᩁᨱᩦᨿᩴ ᩅᩦᨲᩥᩈᩣᩁᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨲᩮᩣ ¶ ᨠᩣᨿᩮ ᨴ᩠ᩅᨲ᩠ᨲᩥᩴᩈᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩣᨶᩥ ᩈᨾᨶ᩠ᨶᩮᩈᩥ [ᩈᨾ᩠ᨾᨶ᩠ᨶᩮᩈᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)]. ᩋᨴ᩠ᨴᩈᩣ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨲᩮᩣ ᨠᩣᨿᩮ ᨴ᩠ᩅᨲ᩠ᨲᩥᩴᩈᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩣᨶᩥ ᨿᩮᨽᩩᨿ᩠ᨿᩮᨶ ᨮᨸᩮᨲ᩠ᩅᩣ ᨴ᩠ᩅᩮ. ᨴ᩠ᩅᩦᩈᩩ ᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩮᩈᩩ ᨠᨦ᩠ᨡᨲᩥ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᨲᩥ ᨶᩣᨵᩥᨾᩩᨧ᩠ᨧᨲᩥ ᨶ ᩈᨾ᩠ᨸᩈᩦᨴᨲᩥ – ᨠᩮᩣᩈᩮᩣᩉᩥᨲᩮ ᨧ ᩅᨲ᩠ᨳᨣᩩᨿ᩠ᩉᩮ, ᨸᩉᩪᨲᨩᩥᩅ᩠ᩉᨲᩣᨿ ᨧᩣᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᨲᩮᩣ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᨸᩔᨲᩥ ᨡᩮᩣ ᨾᩮ ᩋᨿᩴ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨴ᩠ᩅᨲ᩠ᨲᩥᩴᩈᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩣᨶᩥ ᨿᩮᨽᩩᨿ᩠ᨿᩮᨶ ᨮᨸᩮᨲ᩠ᩅᩣ ᨴ᩠ᩅᩮ. ᨴ᩠ᩅᩦᩈᩩ ᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩮᩈᩩ ᨠᨦ᩠ᨡᨲᩥ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᨲᩥ ᨶᩣᨵᩥᨾᩩᨧ᩠ᨧᨲᩥ ᨶ ᩈᨾ᩠ᨸᩈᩦᨴᨲᩥ – ᨠᩮᩣᩈᩮᩣᩉᩥᨲᩮ ᨧ ᩅᨲ᩠ᨳᨣᩩᨿ᩠ᩉᩮ, ᨸᩉᩪᨲᨩᩥᩅ᩠ᩉᨲᩣᨿ ¶ ᨧᩣ’’ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨲᨳᩣᩁᩪᨸᩴ ᩍᨴ᩠ᨵᩣᨽᩥᩈᨦ᩠ᨡᩣᩁᩴ ᩋᨽᩥᩈᨦ᩠ᨡᩣᩈᩥ [ᩋᨽᩥᩈᨦ᩠ᨡᩣᩁᩮᩈᩥ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨿᨳᩣ ᩋᨴ᩠ᨴᩈ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨲᩮᩣ ᨠᩮᩣᩈᩮᩣᩉᩥᨲᩴ ᩅᨲ᩠ᨳᨣᩩᨿ᩠ᩉᩴ ¶ . ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨩᩥᩅ᩠ᩉᩴ ᨶᩥᨶ᩠ᨶᩣᨾᩮᨲ᩠ᩅᩣ ᩏᨽᩮᩣᨸᩥ ᨠᨱ᩠ᨱᩈᩮᩣᨲᩣᨶᩥ ᩋᨶᩩᨾᩈᩥ ᨸᨭᩥᨾᩈᩥ, ᩏᨽᩮᩣᨸᩥ ᨶᩣᩈᩥᨠᩈᩮᩣᨲᩣᨶᩥ ᩋᨶᩩᨾᩈᩥ ᨸᨭᩥᨾᩈᩥ, ᨠᩮᩅᩃᨾ᩠ᨸᩥ ᨶᩃᩣᨭᨾᨱ᩠ᨯᩃᩴ ᨩᩥᩅ᩠ᩉᩣᨿ ᨨᩣᨴᩮᩈᩥ.

ᩋᨳ ᨡᩮᩣ ᩈᩮᩃᩔ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᩑᨲᨴᩉᩮᩣᩈᩥ – ‘‘ᩈᨾᨶ᩠ᨶᩣᨣᨲᩮᩣ ᨡᩮᩣ ᩈᨾᨱᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ ᨴ᩠ᩅᨲ᩠ᨲᩥᩴᩈᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩮᩉᩥ ᨸᩁᩥᨸᩩᨱ᩠ᨱᩮᩉᩥ, ᨶᩮᩣ ᩋᨸᩩᩁᩥᨸᩩᨱ᩠ᨱᩮᩉᩥ. ᨶᩮᩣ ᨧ ᨡᩮᩣ ᨶᩴ ᨩᩣᨶᩣᨾᩥ ᨻᩩᨴ᩠ᨵᩮᩣ ᩅᩣ ᨶᩮᩣ ᩅᩣ. ᩈᩩᨲᩴ ᨡᩮᩣ ᨸᨶ ᨾᩮᨲᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᩅᩩᨯ᩠ᨰᩣᨶᩴ ᨾᩉᩃ᩠ᩃᨠᩣᨶᩴ ᩌᨧᩁᩥᨿᨸᩣᨧᩁᩥᨿᩣᨶᩴ ᨽᩣᩈᨾᩣᨶᩣᨶᩴ – ‘ᨿᩮ ᨲᩮ ᨽᩅᨶ᩠ᨲᩥ ᩋᩁᩉᨶ᩠ᨲᩮᩣ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩣ, ᨲᩮ ᩈᨠᩮ ᩅᨱ᩠ᨱᩮ ᨽᨬ᩠ᨬᨾᩣᨶᩮ ᩋᨲ᩠ᨲᩣᨶᩴ ᨸᩣᨲᩩᨠᩁᩮᩣᨶ᩠ᨲᩦ’ᨲᩥ. ᨿᩴᨶᩪᨶᩣᩉᩴ ᩈᨾᨱᩴ ᨣᩮᩣᨲᨾᩴ ᩈᨾ᩠ᨾᩩᨡᩣ ᩈᩣᩁᩩᨸ᩠ᨸᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨽᩥᨲ᩠ᨳᩅᩮᨿ᩠ᨿ’’ᨶ᩠ᨲᩥ. ᩋᨳ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩈᨾ᩠ᨾᩩᨡᩣ ᩈᩣᩁᩩᨸ᩠ᨸᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨽᩥᨲ᩠ᨳᩅᩥ –

‘‘ᨸᩁᩥᨸᩩᨱ᩠ᨱᨠᩣᨿᩮᩣ ᩈᩩᩁᩩᨧᩥ, ᩈᩩᨩᩣᨲᩮᩣ ᨧᩣᩁᩩᨴᩔᨶᩮᩣ;

ᩈᩩᩅᨱ᩠ᨱᩅᨱ᩠ᨱᩮᩣᩈᩥ ᨽᨣᩅᩣ, ᩈᩩᩈᩩᨠ᩠ᨠᨴᩣᨮᩮᩣᩈᩥ ᩅᩦᩁᩥᨿᩅᩣ.

‘‘ᨶᩁᩔ ¶ ᩉᩥ ᩈᩩᨩᩣᨲᩔ, ᨿᩮ ᨽᩅᨶ᩠ᨲᩥ ᩅᩥᨿᨬ᩠ᨩᨶᩣ;

ᩈᨻ᩠ᨻᩮ ᨲᩮ ᨲᩅ ᨠᩣᨿᩈ᩠ᨾᩥᩴ, ᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩣ.

‘‘ᨸᩈᨶ᩠ᨶᨶᩮᨲ᩠ᨲᩮᩣ ᩈᩩᨾᩩᨡᩮᩣ, ᨻᩕᩉᩣ ᩏᨩᩩ ᨸᨲᩣᨸᩅᩣ;

ᨾᨩ᩠ᨫᩮ ¶ ᩈᨾᨱᩈᨦ᩠ᨥᩔ, ᩌᨴᩥᨧ᩠ᨧᩮᩣᩅ ᩅᩥᩁᩮᩣᨧᩈᩥ.

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

ᨠᩥᩴ ᨲᩮ ᩈᨾᨱᨽᩣᩅᩮᨶ, ᩑᩅᩴ ᩏᨲ᩠ᨲᨾᩅᨱ᩠ᨱᩥᨶᩮᩣ.

‘‘ᩁᩣᨩᩣ ᩋᩁᩉᩈᩥ ᨽᩅᩥᨲᩩᩴ, ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩦ ᩁᨳᩮᩈᨽᩮᩣ;

ᨧᩣᨲᩩᩁᨶ᩠ᨲᩮᩣ ᩅᩥᨩᩥᨲᩣᩅᩦ, ᨩᨾ᩠ᨻᩩᩈᨱ᩠ᨯᩔ [ᨩᨾ᩠ᨻᩩᨾᨱ᩠ᨯᩔ (ᨠ.)] ᩍᩔᩁᩮᩣ.

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

ᩁᩣᨩᩣᨽᩥᩁᩣᨩᩣ ᨾᨶᩩᨩᩥᨶ᩠ᨴᩮᩣ, ᩁᨩ᩠ᨩᩴ ᨠᩣᩁᩮᩉᩥ ᨣᩮᩣᨲᨾ’’.

‘‘ᩁᩣᨩᩣᩉᨾᩈ᩠ᨾᩥ ᩈᩮᩃᩣᨲᩥ, (ᨽᨣᩅᩣ) ᨵᨾ᩠ᨾᩁᩣᨩᩣ ᩋᨶᩩᨲ᩠ᨲᩁᩮᩣ;

ᨵᨾ᩠ᨾᩮᨶ ᨧᨠ᩠ᨠᩴ ᩅᨲ᩠ᨲᩮᨾᩥ, ᨧᨠ᩠ᨠᩴ ᩋᨸ᩠ᨸᨭᩥᩅᨲ᩠ᨲᩥᨿᩴ’’.

‘‘ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ ᨸᨭᩥᨩᩣᨶᩣᩈᩥ, (ᩍᨲᩥ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ) ᨵᨾ᩠ᨾᩁᩣᨩᩣ ᩋᨶᩩᨲ᩠ᨲᩁᩮᩣ;

‘ᨵᨾ᩠ᨾᩮᨶ ᨧᨠ᩠ᨠᩴ ᩅᨲ᩠ᨲᩮᨾᩥ’, ᩍᨲᩥ ᨽᩣᩈᩈᩥ ᨣᩮᩣᨲᨾ.

‘‘ᨠᩮᩣ ᨶᩩ ᩈᩮᨶᩣᨸᨲᩥ ᨽᩮᩣᨲᩮᩣ, ᩈᩣᩅᨠᩮᩣ ᩈᨲ᩠ᨳᩩᩁᨶ᩠ᩅᨿᩮᩣ;

ᨠᩮᩣ ᨲᩮ ᨲᨾᨶᩩᩅᨲ᩠ᨲᩮᨲᩥ, ᨵᨾ᩠ᨾᨧᨠ᩠ᨠᩴ ᨸᩅᨲ᩠ᨲᩥᨲᩴ’’.

‘‘ᨾᨿᩣ ᨸᩅᨲ᩠ᨲᩥᨲᩴ ᨧᨠ᩠ᨠᩴ, (ᩈᩮᩃᩣᨲᩥ ᨽᨣᩅᩣ) ᨵᨾ᩠ᨾᨧᨠ᩠ᨠᩴ ᩋᨶᩩᨲ᩠ᨲᩁᩴ;

ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨶᩩᩅᨲ᩠ᨲᩮᨲᩥ, ᩋᨶᩩᨩᩣᨲᩮᩣ ᨲᨳᩣᨣᨲᩴ.

‘‘ᩋᨽᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ ᩋᨽᩥᨬ᩠ᨬᩣᨲᩴ, ᨽᩣᩅᩮᨲᨻ᩠ᨻᨬ᩠ᨧ ᨽᩣᩅᩥᨲᩴ;

ᨸᩉᩣᨲᨻ᩠ᨻᩴ ᨸᩉᩦᨶᩴ ᨾᩮ, ᨲᩈ᩠ᨾᩣ ᨻᩩᨴ᩠ᨵᩮᩣᩈ᩠ᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱ.

‘‘ᩅᩥᨶᨿᩔᩩ ¶ ᨾᨿᩥ ᨠᨦ᩠ᨡᩴ, ᩋᨵᩥᨾᩩᨧ᩠ᨧᩔᩩ ᨻᩕᩣᩉ᩠ᨾᨱ;

ᨴᩩᩃ᩠ᩃᨽᩴ ᨴᩔᨶᩴ ᩉᩮᩣᨲᩥ, ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩣᨶᩴ ᩋᨽᩥᨱ᩠ᩉᩈᩮᩣ.

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

ᩈᩮᩣᩉᩴ ᨻᩕᩣᩉ᩠ᨾᨱ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ, ᩈᩃ᩠ᩃᨠᨲ᩠ᨲᩮᩣ ᩋᨶᩩᨲ᩠ᨲᩁᩮᩣ.

‘‘ᨻᩕᩉ᩠ᨾᨽᩪᨲᩮᩣ ᩋᨲᩥᨲᩩᩃᩮᩣ, ᨾᩣᩁᩈᩮᨶᨸ᩠ᨸᨾᨴ᩠ᨴᨶᩮᩣ;

ᩈᨻ᩠ᨻᩣᨾᩥᨲ᩠ᨲᩮ ᩅᩈᩦᨠᨲ᩠ᩅᩣ, ᨾᩮᩣᨴᩣᨾᩥ ᩋᨠᩩᨲᩮᩣᨽᨿᩮᩣ’’.

‘‘ᩍᨾᩴ ᨽᩅᨶ᩠ᨲᩮᩣ ᨶᩥᩈᩣᨾᩮᨳ, ᨿᨳᩣ ᨽᩣᩈᨲᩥ ᨧᨠ᩠ᨡᩩᨾᩣ;

ᩈᩃ᩠ᩃᨠᨲ᩠ᨲᩮᩣ ᨾᩉᩣᩅᩦᩁᩮᩣ, ᩈᩦᩉᩮᩣᩅ ᨶᨴᨲᩦ ᩅᨶᩮ.

‘‘ᨻᩕᩉ᩠ᨾᨽᩪᨲᩴ ᩋᨲᩥᨲᩩᩃᩴ, ᨾᩣᩁᩈᩮᨶᨸ᩠ᨸᨾᨴ᩠ᨴᨶᩴ;

ᨠᩮᩣ ᨴᩥᩈ᩠ᩅᩣ ᨶᨸ᩠ᨸᩈᩦᨴᩮᨿ᩠ᨿ, ᩋᨸᩥ ᨠᨱ᩠ᩉᩣᨽᩥᨩᩣᨲᩥᨠᩮᩣ.

‘‘ᨿᩮᩣ ᨾᩴ ᩍᨧ᩠ᨨᨲᩥ ᩋᨶ᩠ᩅᩮᨲᩩ, ᨿᩮᩣ ᩅᩣ ᨶᩥᨧ᩠ᨨᨲᩥ ᨣᨧ᩠ᨨᨲᩩ;

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

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

ᨾᨿᨾ᩠ᨸᩥ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾ, ᩅᩁᨸᨬ᩠ᨬᩔ ᩈᨶ᩠ᨲᩥᨠᩮ’’.

‘‘ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨲᩥᩈᨲᩣ ᩍᨾᩮ, ᨿᩣᨧᨶ᩠ᨲᩥ ᨸᨬ᩠ᨩᩃᩦᨠᨲᩣ;

ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ ᨧᩁᩥᩔᩣᨾ, ᨽᨣᩅᩣ ᨲᩅ ᩈᨶ᩠ᨲᩥᨠᩮ’’.

‘‘ᩈ᩠ᩅᩣᨠ᩠ᨡᩣᨲᩴ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, (ᩈᩮᩃᩣᨲᩥ ᨽᨣᩅᩣ) ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨠᨾᨠᩣᩃᩥᨠᩴ;

ᨿᨲ᩠ᨳ ᩋᨾᩮᩣᨥᩣ ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ, ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩔ ᩈᩥᨠ᩠ᨡᨲᩮᩣ’’ᨲᩥ.

ᩋᩃᨲ᩠ᨳ ᨡᩮᩣ ᩈᩮᩃᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩈᨸᩁᩥᩈᩮᩣ ᨽᨣᩅᨲᩮᩣ ᩈᨶ᩠ᨲᩥᨠᩮ ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ, ᩋᩃᨲ᩠ᨳ ᩏᨸᩈᨾ᩠ᨸᨴᩴ. ᩋᨳ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨲᩔᩣ ¶ ᩁᨲ᩠ᨲᩥᨿᩣ ᩋᨧ᩠ᨧᨿᩮᨶ ᩈᨠᩮ ᩋᩔᨾᩮ ᨸᨱᩦᨲᩴ ᨡᩣᨴᨶᩦᨿᩴ ᨽᩮᩣᨩᨶᩦᨿᩴ ᨸᨭᩥᨿᩣᨴᩣᨸᩮᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩮᩣ ¶ ᨠᩣᩃᩴ ᩌᩁᩮᩣᨧᩣᨸᩮᩈᩥ – ‘‘ᨠᩣᩃᩮᩣ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ, ᨶᩥᨭ᩠ᨮᩥᨲᩴ ᨽᨲ᩠ᨲ’’ᨶ᩠ᨲᩥ ¶ . ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨸᩩᨻ᩠ᨻᨱ᩠ᩉᩈᨾᨿᩴ ᨶᩥᩅᩣᩈᩮᨲ᩠ᩅᩣ ᨸᨲ᩠ᨲᨧᩦᩅᩁᨾᩣᨴᩣᨿ ᨿᩮᨶ ᨠᩮᨱᩥᨿᩔ ᨩᨭᩥᩃᩔ ᩋᩔᨾᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨸᨬ᩠ᨬᨲ᩠ᨲᩮ ᩌᩈᨶᩮ ᨶᩥᩈᩦᨴᩥ ᩈᨴ᩠ᨵᩥᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩮᨶ.

ᩋᨳ ¶ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨻᩩᨴ᩠ᨵᨸ᩠ᨸᨾᩩᨡᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩴ ᨸᨱᩦᨲᩮᨶ ᨡᩣᨴᨶᩦᨿᩮᨶ ᨽᩮᩣᨩᨶᩦᨿᩮᨶ ᩈᩉᨲ᩠ᨳᩣ ᩈᨶ᩠ᨲᨸ᩠ᨸᩮᩈᩥ ᩈᨾ᩠ᨸᩅᩣᩁᩮᩈᩥ. ᩋᨳ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩮᩣ ᨩᨭᩥᩃᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨽᩩᨲ᩠ᨲᩣᩅᩥᩴ ᩒᨶᩦᨲᨸᨲ᩠ᨲᨸᩣᨱᩥᩴ ᩋᨬ᩠ᨬᨲᩁᩴ ᨶᩦᨧᩴ ᩌᩈᨶᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩴ ᨡᩮᩣ ᨠᩮᨱᩥᨿᩴ ᨩᨭᩥᩃᩴ ᨽᨣᩅᩣ ᩍᨾᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨶᩩᨾᩮᩣᨴᩥ –

‘‘ᩋᨣ᩠ᨣᩥᩉᩩᨲ᩠ᨲᨾᩩᨡᩣ ᨿᨬ᩠ᨬᩣ, ᩈᩣᩅᩥᨲ᩠ᨲᩦ ᨨᨶ᩠ᨴᩈᩮᩣ ᨾᩩᨡᩴ;

ᩁᩣᨩᩣ ᨾᩩᨡᩴ ᨾᨶᩩᩔᩣᨶᩴ, ᨶᨴᩦᨶᩴ ᩈᩣᨣᩁᩮᩣ ᨾᩩᨡᩴ.

‘‘ᨶᨠ᩠ᨡᨲ᩠ᨲᩣᨶᩴ ᨾᩩᨡᩴ ᨧᨶ᩠ᨴᩮᩣ, ᩌᨴᩥᨧ᩠ᨧᩮᩣ ᨲᨸᨲᩴ ᨾᩩᨡᩴ;

ᨸᩩᨬ᩠ᨬᩴ ᩌᨠᨦ᩠ᨡᨾᩣᨶᩣᨶᩴ, ᩈᨦ᩠ᨥᩮᩣ ᩅᩮ ᨿᨩᨲᩴ ᨾᩩᨡ’’ᨶ᩠ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨠᩮᨱᩥᨿᩴ ᨩᨭᩥᩃᩴ ᩍᨾᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨶᩩᨾᩮᩣᨴᩥᨲ᩠ᩅᩣ ᩏᨭ᩠ᨮᩣᨿᩣᩈᨶᩣ ᨸᨠ᩠ᨠᩣᨾᩥ. ᩋᨳ ᨡᩮᩣ ᩌᨿᩈ᩠ᨾᩣ ᩈᩮᩃᩮᩣ ᩈᨸᩁᩥᩈᩮᩣ ᩑᨠᩮᩣ ᩅᩪᨸᨠᨭ᩠ᨮᩮᩣ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ ᩌᨲᩣᨸᩦ ᨸᩉᩥᨲᨲ᩠ᨲᩮᩣ ᩅᩥᩉᩁᨶ᩠ᨲᩮᩣ ᨶᨧᩥᩁᩔᩮ ¶ …ᨸᩮ… ¶ ᩋᨬ᩠ᨬᨲᩁᩮᩣ ᨡᩮᩣ ᨸᨶᩣᨸᩈ᩠ᨾᩣ ᩈᩮᩃᩮᩣ ᩈᨸᩁᩥᩈᩮᩣ ᩋᩁᩉᨲᩴ ᩋᩉᩮᩣᩈᩥ.

ᩋᨳ ᨡᩮᩣ ᩌᨿᩈ᩠ᨾᩣ ᩈᩮᩃᩮᩣ ᩈᨸᩁᩥᩈᩮᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ, ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᩑᨠᩴᩈᩴ ᨧᩦᩅᩁᩴ ᨠᨲ᩠ᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᨬ᩠ᨩᩃᩥᩴ ᨸᨱᩣᨾᩮᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᨿ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᨿᩴ ᨲᩴ ᩈᩁᨱᨾᩣᨣᨾ᩠ᩉ [ᨾᩣᨣᨾ᩠ᨾ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)], ᩍᨲᩮᩣ ᩋᨭ᩠ᨮᨾᩥ ᨧᨠ᩠ᨡᩩᨾ;

ᩈᨲ᩠ᨲᩁᨲ᩠ᨲᩮᨶ ᨽᨣᩅᩣ, ᨴᨶ᩠ᨲᨾ᩠ᩉ ᨲᩅ ᩈᩣᩈᨶᩮ.

‘‘ᨲᩩᩅᩴ ᨻᩩᨴ᩠ᨵᩮᩣ ᨲᩩᩅᩴ ᩈᨲ᩠ᨳᩣ, ᨲᩩᩅᩴ ᨾᩣᩁᩣᨽᩥᨽᩪ ᨾᩩᨶᩥ;

ᨲᩩᩅᩴ ᩋᨶᩩᩈᨿᩮ ᨨᩮᨲ᩠ᩅᩣ, ᨲᩥᨱ᩠ᨱᩮᩣ ᨲᩣᩁᩮᩈᩥᨾᩴ ᨸᨩᩴ.

‘‘ᩏᨸᨵᩦ ᨲᩮ ᩈᨾᨲᩥᨠ᩠ᨠᨶ᩠ᨲᩣ, ᩌᩈᩅᩣ ᨲᩮ ᨸᨴᩣᩃᩥᨲᩣ;

ᩈᩦᩉᩮᩣᩈᩥ [ᩈᩦᩉᩮᩣᩅ (ᨾ. ᨶᩥ. ᪒.᪔᪐᪑)] ᩋᨶᩩᨸᩣᨴᩣᨶᩮᩣ, ᨸᩉᩦᨶᨽᨿᨽᩮᩁᩅᩮᩣ.

‘‘ᨽᩥᨠ᩠ᨡᩅᩮᩣ ¶ ᨲᩥᩈᨲᩣ ᩍᨾᩮ, ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᨸᨬ᩠ᨩᩃᩦᨠᨲᩣ;

ᨸᩣᨴᩮ ᩅᩦᩁ ᨸᩈᩣᩁᩮᩉᩥ, ᨶᩣᨣᩣ ᩅᨶ᩠ᨴᨶ᩠ᨲᩩ ᩈᨲ᩠ᨳᩩᨶᩮᩣ’’ᨲᩥ.

ᩋᨶᩥᨾᩥᨲ᩠ᨲᨾᨶᨬ᩠ᨬᩣᨲᩴ ¶ , ᨾᨧ᩠ᨧᩣᨶᩴ ᩍᨵ ᨩᩦᩅᩥᨲᩴ;

ᨠᩈᩥᩁᨬ᩠ᨧ ᨸᩁᩥᨲ᩠ᨲᨬ᩠ᨧ, ᨲᨬ᩠ᨧ ᨴᩩᨠ᩠ᨡᩮᨶ ᩈᩴᨿᩩᨲᩴ.

ᨶ ¶ ᩉᩥ ᩈᩮᩣ ᩏᨸᨠ᩠ᨠᨾᩮᩣ ᩋᨲ᩠ᨳᩥ, ᨿᩮᨶ ᨩᩣᨲᩣ ᨶ ᨾᩥᨿ᩠ᨿᩁᩮ;

ᨩᩁᨾ᩠ᨸᩥ ¶ ᨸᨲ᩠ᩅᩣ ᨾᩁᨱᩴ, ᩑᩅᩴᨵᨾ᩠ᨾᩣ ᩉᩥ ᨸᩣᨱᩥᨶᩮᩣ.

ᨹᩃᩣᨶᨾᩥᩅ ᨸᨠ᩠ᨠᩣᨶᩴ, ᨸᩣᨲᩮᩣ ᨸᨲᨶᨲᩮᩣ [ᨸᨸᨲᨲᩮᩣ (ᩈᩦ. ᨸᩦ. ᩋᨭ᩠ᨮ.)] ᨽᨿᩴ;

ᩑᩅᩴ ᨩᩣᨲᩣᨶ ᨾᨧ᩠ᨧᩣᨶᩴ, ᨶᩥᨧ᩠ᨧᩴ ᨾᩁᨱᨲᩮᩣ ᨽᨿᩴ.

ᨿᨳᩣᨸᩥ ᨠᩩᨾ᩠ᨽᨠᩣᩁᩔ, ᨠᨲᩣ ᨾᨲ᩠ᨲᩥᨠᨽᩣᨩᨶᩣ;

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

ᨴᩉᩁᩣ ᨧ ᨾᩉᨶ᩠ᨲᩣ ᨧ, ᨿᩮ ᨻᩣᩃᩣ ᨿᩮ ᨧ ᨸᨱ᩠ᨯᩥᨲᩣ;

ᩈᨻ᩠ᨻᩮ ᨾᨧ᩠ᨧᩩᩅᩈᩴ ᨿᨶ᩠ᨲᩥ, ᩈᨻ᩠ᨻᩮ ᨾᨧ᩠ᨧᩩᨸᩁᩣᨿᨱᩣ.

ᨲᩮᩈᩴ ᨾᨧ᩠ᨧᩩᨸᩁᩮᨲᩣᨶᩴ, ᨣᨧ᩠ᨨᨲᩴ ᨸᩁᩃᩮᩣᨠᨲᩮᩣ;

ᨶ ᨸᩥᨲᩣ ᨲᩣᨿᨲᩮ ᨸᩩᨲ᩠ᨲᩴ, ᨬᩣᨲᩦ ᩅᩣ ᨸᨶ ᨬᩣᨲᨠᩮ.

ᨸᩮᨠ᩠ᨡᨲᩴ ᨿᩮᩅ ᨬᩣᨲᩦᨶᩴ, ᨸᩔ ᩃᩣᩃᨸᨲᩴ ᨸᩩᨳᩩ;

ᩑᨠᨾᩮᨠᩮᩣᩅ ᨾᨧ᩠ᨧᩣᨶᩴ, ᨣᩮᩣᩅᨩ᩠ᨫᩮᩣ ᩅᩥᨿ ᨶᩦᨿᨲᩥ [ᨶᩥᨿ᩠ᨿᨲᩥ (ᨻᩉᩪᩈᩩ)].

ᩑᩅᨾᨻ᩠ᨽᩣᩉᨲᩮᩣ ¶ ᩃᩮᩣᨠᩮᩣ, ᨾᨧ᩠ᨧᩩᨶᩣ ᨧ ᨩᩁᩣᨿ ᨧ;

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

ᩏᨽᩮᩣ ᩋᨶ᩠ᨲᩮ ᩋᩈᨾ᩠ᨸᩔᩴ, ᨶᩥᩁᨲ᩠ᨳᩴ ᨸᩁᩥᨴᩮᩅᩈᩥ.

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

ᩈᨾ᩠ᨾᩪᩊ᩠ᩉᩮᩣ ᩉᩥᩴᩈᨾᨲ᩠ᨲᩣᨶᩴ, ᨠᨿᩥᩁᩣ ᨧᩮ ᨶᩴ ᩅᩥᨧᨠ᩠ᨡᨱᩮᩣ.

ᨶ ᩉᩥ ᩁᩩᨱ᩠ᨱᩮᨶ ᩈᩮᩣᨠᩮᨶ, ᩈᨶ᩠ᨲᩥᩴ ᨸᨸ᩠ᨸᩮᩣᨲᩥ ᨧᩮᨲᩈᩮᩣ;

ᨽᩥᨿ᩠ᨿᩔᩩᨸ᩠ᨸᨩ᩠ᨩᨲᩮ ᨴᩩᨠ᩠ᨡᩴ, ᩈᩁᩦᩁᩴ ᨧᩩᨸᩉᨬ᩠ᨬᨲᩥ.

ᨠᩥᩈᩮᩣ ¶ ᩅᩥᩅᨱ᩠ᨱᩮᩣ ᨽᩅᨲᩥ, ᩉᩥᩴᩈᨾᨲ᩠ᨲᩣᨶᨾᨲ᩠ᨲᨶᩣ;

ᨶ ¶ ᨲᩮᨶ ᨸᩮᨲᩣ ᨸᩣᩃᩮᨶ᩠ᨲᩥ, ᨶᩥᩁᨲ᩠ᨳᩣ ᨸᩁᩥᨴᩮᩅᨶᩣ.

ᩈᩮᩣᨠᨾᨸ᩠ᨸᨩᩉᩴ ¶ ᨩᨶ᩠ᨲᩩ, ᨽᩥᨿ᩠ᨿᩮᩣ ᨴᩩᨠ᩠ᨡᩴ ᨶᩥᨣᨧ᩠ᨨᨲᩥ;

ᩋᨶᩩᨲ᩠ᨳᩩᨶᨶ᩠ᨲᩮᩣ ᨠᩣᩃᨦ᩠ᨠᨲᩴ [ᨠᩣᩃᨠᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᩈᩮᩣᨠᩔ ᩅᩈᨾᨶ᩠ᩅᨣᩪ.

ᩋᨬ᩠ᨬᩮᨸᩥ ᨸᩔ ᨣᨾᩥᨶᩮ, ᨿᨳᩣᨠᨾ᩠ᨾᩪᨸᨣᩮ ᨶᩁᩮ;

ᨾᨧ᩠ᨧᩩᨶᩮᩣ ᩅᩈᨾᩣᨣᨾ᩠ᨾ, ᨹᨶ᩠ᨴᨶ᩠ᨲᩮᩅᩥᨵ ᨸᩣᨱᩥᨶᩮᩣ.

ᨿᩮᨶ ᨿᩮᨶ ᩉᩥ ᨾᨬ᩠ᨬᨶ᩠ᨲᩥ, ᨲᨲᩮᩣ ᨲᩴ ᩉᩮᩣᨲᩥ ᩋᨬ᩠ᨬᨳᩣ;

ᩑᨲᩣᨴᩥᩈᩮᩣ ᩅᩥᨶᩣᨽᩣᩅᩮᩣ, ᨸᩔ ᩃᩮᩣᨠᩔ ᨸᩁᩥᨿᩣᨿᩴ.

ᩋᨸᩥ ᩅᩔᩈᨲᩴ ᨩᩦᩅᩮ, ᨽᩥᨿ᩠ᨿᩮᩣ ᩅᩣ ᨸᨶ ᨾᩣᨱᩅᩮᩣ;

ᨬᩣᨲᩥᩈᨦ᩠ᨥᩣ ᩅᩥᨶᩣ ᩉᩮᩣᨲᩥ, ᨩᩉᩣᨲᩥ ᩍᨵ ᨩᩦᩅᩥᨲᩴ.

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

ᨸᩮᨲᩴ ᨠᩣᩃᨦ᩠ᨠᨲᩴ ᨴᩥᩈ᩠ᩅᩣ, ᨶᩮᩈᩮᩣ ᩃᨻ᩠ᨽᩣ ᨾᨿᩣ ᩍᨲᩥ.

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

ᩑᩅᨾ᩠ᨸᩥ ᨵᩦᩁᩮᩣ ᩈᨸᨬ᩠ᨬᩮᩣ, ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᨠᩩᩈᩃᩮᩣ ᨶᩁᩮᩣ;

ᨡᩥᨸ᩠ᨸᨾᩩᨸ᩠ᨸᨲᩥᨲᩴ ᩈᩮᩣᨠᩴ, ᩅᩣᨲᩮᩣ ᨲᩪᩃᩴᩅ ᨵᩴᩈᨿᩮ.

ᨸᩁᩥᨴᩮᩅᩴ ᨸᨩᨸ᩠ᨸᨬ᩠ᨧ, ᨴᩮᩣᨾᨶᩔᨬ᩠ᨧ ᩋᨲ᩠ᨲᨶᩮᩣ;

ᩋᨲ᩠ᨲᨶᩮᩣ ᩈᩩᨡᨾᩮᩈᩣᨶᩮᩣ, ᩋᨻ᩠ᨻᩉᩮ ᩈᩃ᩠ᩃᨾᨲ᩠ᨲᨶᩮᩣ.

ᩋᨻ᩠ᨻᩩᩊ᩠ᩉᩈᩃ᩠ᩃᩮᩣ ᩋᩈᩥᨲᩮᩣ, ᩈᨶ᩠ᨲᩥᩴ ᨸᨸ᩠ᨸᩩᨿ᩠ᨿ ᨧᩮᨲᩈᩮᩣ;

ᩈᨻ᩠ᨻᩈᩮᩣᨠᩴ ᩋᨲᩥᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᩋᩈᩮᩣᨠᩮᩣ ᩉᩮᩣᨲᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩮᩣᨲᩥ.

ᩑᩅᩴ ¶ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩍᨧ᩠ᨨᩣᨶᨦ᩠ᨣᩃᩮ ᩅᩥᩉᩁᨲᩥ ᩍᨧ᩠ᨨᩣᨶᨦ᩠ᨣᩃᩅᨶᩈᨱ᩠ᨯᩮ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᩈᨾ᩠ᨻᩉᩩᩃᩣ ᩋᨽᩥᨬ᩠ᨬᩣᨲᩣ ᩋᨽᩥᨬ᩠ᨬᩣᨲᩣ ᨻᩕᩣᩉ᩠ᨾᨱᨾᩉᩣᩈᩣᩃᩣ ᩍᨧ᩠ᨨᩣᨶᨦ᩠ᨣᩃᩮ ᨸᨭᩥᩅᩈᨶ᩠ᨲᩥ, ᩈᩮᨿ᩠ᨿᨳᩥᨴᩴ – ᨧᨦ᩠ᨠᩦ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ, ᨲᩣᩁᩩᨠ᩠ᨡᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ, ᨸᩮᩣᨠ᩠ᨡᩁᩈᩣᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ, ᨩᩣᨱᩩᩔᩮᩣᨱᩥ [ᨩᩣᨱᩩᩈᩮᩣᨱᩥ (ᨠ.)] ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ, ᨲᩮᩣᨴᩮᨿ᩠ᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ, ᩋᨬ᩠ᨬᩮ ᨧ ᩋᨽᩥᨬ᩠ᨬᩣᨲᩣ ᩋᨽᩥᨬ᩠ᨬᩣᨲᩣ ᨻᩕᩣᩉ᩠ᨾᨱᨾᩉᩣᩈᩣᩃᩣ. ᩋᨳ ᨡᩮᩣ ᩅᩣᩈᩮᨭ᩠ᨮᨽᩣᩁᨴ᩠ᩅᩣᨩᩣᨶᩴ ᨾᩣᨱᩅᩣᨶᩴ ¶ ᨩᨦ᩠ᨥᩣᩅᩥᩉᩣᩁᩴ ᩋᨶᩩᨧᨦ᩠ᨠᨾᨶ᩠ᨲᩣᨶᩴ ᩋᨶᩩᩅᩥᨧᩁᨶ᩠ᨲᩣᨶᩴ [ᩋᨶᩩᨧᨦ᩠ᨠᨾᨾᩣᨶᩣᨶᩴ ᩋᨶᩩᩅᩥᨧᩁᨾᩣᨶᩣᨶᩴ (ᩈᩦ. ᨸᩦ.)] ᩋᨿᨾᨶ᩠ᨲᩁᩣᨠᨳᩣ ᩏᨴᨸᩣᨴᩥ – ‘‘ᨠᨳᩴ, ᨽᩮᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩮᩣᨲᩦ’’ᨲᩥ?

ᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨾᩣᨱᩅᩮᩣ ᩑᩅᨾᩣᩉ – ‘‘ᨿᨲᩮᩣ ᨡᩮᩣ, ᨽᩮᩣ, ᩏᨽᨲᩮᩣ ᩈᩩᨩᩣᨲᩮᩣ ᩉᩮᩣᨲᩥ ᨾᩣᨲᩥᨲᩮᩣ ᨧ ᨸᩥᨲᩥᨲᩮᩣ ᨧ ᩈᩴᩈᩩᨴ᩠ᨵᨣᩉᨱᩥᨠᩮᩣ ᨿᩣᩅ ᩈᨲ᩠ᨲᨾᩣ ᨸᩥᨲᩣᨾᩉᨿᩩᨣᩣ ᩋᨠ᩠ᨡᩥᨲ᩠ᨲᩮᩣ ᩋᨶᩩᨸᨠ᩠ᨠᩩᨭ᩠ᨮᩮᩣ ᨩᩣᨲᩥᩅᩣᨴᩮᨶ, ᩑᨲ᩠ᨲᩣᩅᨲᩣ ᨡᩮᩣ ᨽᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩮᩣᨲᩦ’’ᨲᩥ.

ᩅᩣᩈᩮᨭ᩠ᨮᩮᩣ ᨾᩣᨱᩅᩮᩣ ᩑᩅᨾᩣᩉ – ‘‘ᨿᨲᩮᩣ ᨡᩮᩣ, ᨽᩮᩣ, ᩈᩦᩃᩅᩣ ᨧ ᩉᩮᩣᨲᩥ ᩅᨲᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ [ᩅᨲ᩠ᨲᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨾ. ᨶᩥ. ᪒.᪔᪕᪔)] ᨧ, ᩑᨲ᩠ᨲᩣᩅᨲᩣ ᨡᩮᩣ, ᨽᩮᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩮᩣᨲᩦ’’ᨲᩥ. ᨶᩮᩅ ᨡᩮᩣ ᩋᩈᨠ᩠ᨡᩥ ᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨾᩣᨱᩅᩮᩣ ᩅᩣᩈᩮᨭ᩠ᨮᩴ ¶ ᨾᩣᨱᩅᩴ ᩈᨬ᩠ᨬᩣᨸᩮᨲᩩᩴ, ᨶ ᨸᨶ ᩋᩈᨠ᩠ᨡᩥ ᩅᩣᩈᩮᨭ᩠ᨮᩮᩣ ᨾᩣᨱᩅᩮᩣ ᨽᩣᩁᨴ᩠ᩅᩣᨩᩴ ᨾᩣᨱᩅᩴ ᩈᨬ᩠ᨬᩣᨸᩮᨲᩩᩴ.

ᩋᨳ ¶ ᨡᩮᩣ ᩅᩣᩈᩮᨭ᩠ᨮᩮᩣ ᨾᩣᨱᩅᩮᩣ ᨽᩣᩁᨴ᩠ᩅᩣᨩᩴ ᨾᩣᨱᩅᩴ ᩌᨾᨶ᩠ᨲᩮᩈᩥ – ‘‘ᩋᨿᩴ ᨡᩮᩣ, ᨽᩮᩣ [ᩋᨿᩴ ᨽᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.), ᩋᨿᩴ ᨡᩮᩣ (ᨸᩦ.)] ᨽᩣᩁᨴ᩠ᩅᩣᨩ, ᩈᨾᨱᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ ᩈᨠ᩠ᨿᨸᩩᨲ᩠ᨲᩮᩣ ᩈᨠ᩠ᨿᨠᩩᩃᩣ ¶ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ ᩍᨧ᩠ᨨᩣᨶᨦ᩠ᨣᩃᩮ ᩅᩥᩉᩁᨲᩥ ᩍᨧ᩠ᨨᩣᨶᨦ᩠ᨣᩃᩅᨶᩈᨱ᩠ᨯᩮ; ᨲᩴ ᨡᩮᩣ ᨸᨶ ᨽᩅᨶ᩠ᨲᩴ ᨣᩮᩣᨲᨾᩴ ᩑᩅᩴ ᨠᩃ᩠ᨿᩣᨱᩮᩣ ᨠᩥᨲ᩠ᨲᩥᩈᨴ᩠ᨴᩮᩣ ᩋᨻ᩠ᨽᩩᨣ᩠ᨣᨲᩮᩣ – ‘ᩍᨲᩥᨸᩥ…ᨸᩮ… ᨻᩩᨴ᩠ᨵᩮᩣ ᨽᨣᩅᩣ’ᨲᩥ. ᩌᨿᩣᨾ, ᨽᩮᩣ ᨽᩣᩁᨴ᩠ᩅᩣᨩ, ᨿᩮᨶ ᩈᨾᨱᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥᩔᩣᨾ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᩈᨾᨱᩴ ᨣᩮᩣᨲᨾᩴ ᩑᨲᨾᨲ᩠ᨳᩴ ᨸᩩᨧ᩠ᨨᩥᩔᩣᨾ. ᨿᨳᩣ ᨶᩮᩣ ᩈᨾᨱᩮᩣ ᨣᩮᩣᨲᨾᩮᩣ ᨻ᩠ᨿᩣᨠᩁᩥᩔᨲᩥ ᨲᨳᩣ ᨶᩴ ᨵᩣᩁᩮᩔᩣᨾᩣ’’ᨲᩥ. ‘‘ᩑᩅᩴ, ᨽᩮᩣ’’ᨲᩥ ᨡᩮᩣ ᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨾᩣᨱᩅᩮᩣ ᩅᩣᩈᩮᨭ᩠ᨮᩔ ᨾᩣᨱᩅᩔ ᨸᨧ᩠ᨧᩔᩮᩣᩈᩥ.

ᩋᨳ ᨡᩮᩣ ᩅᩣᩈᩮᨭ᩠ᨮᨽᩣᩁᨴ᩠ᩅᩣᨩᩣ ᨾᩣᨱᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥᩴᩈᩩ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨲᩣ ᩈᨴ᩠ᨵᩥᩴ ᩈᨾ᩠ᨾᩮᩣᨴᩥᩴᩈᩩ. ᩈᨾ᩠ᨾᩮᩣᨴᨶᩦᨿᩴ ᨠᨳᩴ ᩈᩣᩁᨱᩦᨿᩴ ᩅᩦᨲᩥᩈᩣᩁᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥᩴᩈᩩ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᩅᩣᩈᩮᨭ᩠ᨮᩮᩣ ᨾᩣᨱᩅᩮᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᨣᩣᨳᩣᩉᩥ ᩋᨩ᩠ᨫᨽᩣᩈᩥ –

‘‘ᩋᨶᩩᨬ᩠ᨬᩣᨲᨸᨭᩥᨬ᩠ᨬᩣᨲᩣ, ᨲᩮᩅᩥᨩ᩠ᨩᩣ ᨾᨿᨾᩈ᩠ᨾᩩᨽᩮᩣ;

ᩋᩉᩴ ᨸᩮᩣᨠ᩠ᨡᩁᩈᩣᨲᩥᩔ, ᨲᩣᩁᩩᨠ᩠ᨡᩔᩣᨿᩴ ᨾᩣᨱᩅᩮᩣ.

‘‘ᨲᩮᩅᩥᨩ᩠ᨩᩣᨶᩴ ᨿᨴᨠ᩠ᨡᩣᨲᩴ, ᨲᨲᩕ ᨠᩮᩅᩃᩥᨶᩮᩣᩈ᩠ᨾᩈᩮ;

ᨸᨴᨠᩈ᩠ᨾ ᩅᩮᨿ᩠ᨿᩣᨠᩁᨱᩣ, ᨩᨸ᩠ᨸᩮ ᩌᨧᩁᩥᨿᩈᩣᨴᩥᩈᩣ.

‘‘ᨲᩮᩈᩴ ¶ ¶ ᨶᩮᩣ ᨩᩣᨲᩥᩅᩣᨴᩈ᩠ᨾᩥᩴ, ᩅᩥᩅᩣᨴᩮᩣ ᩋᨲ᩠ᨳᩥ ᨣᩮᩣᨲᨾ;

ᨩᩣᨲᩥᨿᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩮᩣᨲᩥ, ᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᩍᨲᩥ ᨽᩣᩈᨲᩥ;

ᩋᩉᨬ᩠ᨧ ᨠᨾ᩠ᨾᩩᨶᩣ [ᨠᨾ᩠ᨾᨶᩣ (ᩈᩦ. ᨸᩦ.) ᩑᩅᨾᩩᨸᩁᩥᨸᩥ] ᨻᩕᩪᨾᩥ, ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨧᨠ᩠ᨡᩩᨾ.

‘‘ᨲᩮ ᨶ ᩈᨠ᩠ᨠᩮᩣᨾ ᩈᨬ᩠ᨬᩣᨸᩮᨲᩩᩴ, ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩴ ᨾᨿᩴ ᩏᨽᩮᩣ;

ᨽᩅᨶ᩠ᨲᩴ [ᨽᨣᩅᨶ᩠ᨲᩴ (ᨠ.)] ᨸᩩᨭ᩠ᨮᩩᨾᩣᨣᨾ᩠ᩉᩣ, ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩴ ᩍᨲᩥ ᩅᩥᩔᩩᨲᩴ.

‘‘ᨧᨶ᩠ᨴᩴ ¶ ᨿᨳᩣ ᨡᨿᩣᨲᩦᨲᩴ, ᨸᩮᨧ᩠ᨧ ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᨩᨶᩣ;

ᩅᨶ᩠ᨴᨾᩣᨶᩣ ᨶᨾᩔᨶ᩠ᨲᩥ, ᩑᩅᩴ ᩃᩮᩣᨠᩈ᩠ᨾᩥ ᨣᩮᩣᨲᨾᩴ.

‘‘ᨧᨠ᩠ᨡᩩᩴ ᩃᩮᩣᨠᩮ ᩈᨾᩩᨸ᩠ᨸᨶ᩠ᨶᩴ, ᨾᨿᩴ ᨸᩩᨧ᩠ᨨᩣᨾ ᨣᩮᩣᨲᨾᩴ;

ᨩᩣᨲᩥᨿᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩮᩣᨲᩥ, ᩏᨴᩣᩉᩩ ᨽᩅᨲᩥ ᨠᨾ᩠ᨾᩩᨶᩣ;

ᩋᨩᩣᨶᨲᩴ ᨶᩮᩣ ᨸᨻᩕᩪᩉᩥ, ᨿᨳᩣ ᨩᩣᨶᩮᩈᩩ ᨻᩕᩣᩉ᩠ᨾᨱᩴ’’.

‘‘ᨲᩮᩈᩴ ¶ ᩅᩮᩣ ᩋᩉᩴ ᨻ᩠ᨿᨠ᩠ᨡᩥᩔᩴ, (ᩅᩣᩈᩮᨭ᩠ᨮᩣᨲᩥ ᨽᨣᩅᩣ) ᩋᨶᩩᨸᩩᨻ᩠ᨻᩴ ᨿᨳᩣᨲᨳᩴ;

ᨩᩣᨲᩥᩅᩥᨽᨦ᩠ᨣᩴ ᨸᩣᨱᩣᨶᩴ, ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩣ ᩉᩥ ᨩᩣᨲᩥᨿᩮᩣ.

‘‘ᨲᩥᨱᩁᩩᨠ᩠ᨡᩮᨸᩥ ᨩᩣᨶᩣᨳ, ᨶ ᨧᩣᨸᩥ ᨸᨭᩥᨩᩣᨶᩁᩮ;

ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨲᩮᩈᩴ, ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩣ ᩉᩥ ᨩᩣᨲᩥᨿᩮᩣ.

‘‘ᨲᨲᩮᩣ ¶ ᨠᩦᨭᩮ ᨸᨭᨦ᩠ᨣᩮ ᨧ, ᨿᩣᩅ ᨠᩩᨶ᩠ᨳᨠᩥᨸᩥᩃ᩠ᩃᩥᨠᩮ;

ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨲᩮᩈᩴ, ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩣ ᩉᩥ ᨩᩣᨲᩥᨿᩮᩣ.

‘‘ᨧᨲᩩᨸ᩠ᨸᨴᩮᨸᩥ ᨩᩣᨶᩣᨳ, ᨡᩩᨴ᩠ᨴᨠᩮ ᨧ ᨾᩉᩃ᩠ᩃᨠᩮ;

ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨲᩮᩈᩴ, ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩣ ᩉᩥ ᨩᩣᨲᩥᨿᩮᩣ.

‘‘ᨸᩣᨴᩪᨴᩁᩮᨸᩥ ᨩᩣᨶᩣᨳ, ᩏᩁᨣᩮ ᨴᩦᨥᨸᩥᨭ᩠ᨮᩥᨠᩮ;

ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨲᩮᩈᩴ, ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩣ ᩉᩥ ᨩᩣᨲᩥᨿᩮᩣ.

‘‘ᨲᨲᩮᩣ ᨾᨧ᩠ᨨᩮᨸᩥ ᨩᩣᨶᩣᨳ, ᩒᨴᨠᩮ ᩅᩣᩁᩥᨣᩮᩣᨧᩁᩮ;

ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨲᩮᩈᩴ, ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩣ ᩉᩥ ᨩᩣᨲᩥᨿᩮᩣ.

‘‘ᨲᨲᩮᩣ ᨸᨠ᩠ᨡᩦᨸᩥ ᨩᩣᨶᩣᨳ, ᨸᨲ᩠ᨲᨿᩣᨶᩮ ᩅᩥᩉᨦ᩠ᨣᨾᩮ;

ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨲᩮᩈᩴ, ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩣ ᩉᩥ ᨩᩣᨲᩥᨿᩮᩣ.

‘‘ᨿᨳᩣ ¶ ¶ ᩑᨲᩣᩈᩩ ᨩᩣᨲᩦᩈᩩ, ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨸᩩᨳᩩ;

ᩑᩅᩴ ᨶᨲ᩠ᨳᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨸᩩᨳᩩ.

‘‘ᨶ ᨠᩮᩈᩮᩉᩥ ᨶ ᩈᩦᩈᩮᨶ, ᨶ ᨠᨱ᩠ᨱᩮᩉᩥ ᨶ ᩋᨠ᩠ᨡᩥᨽᩥ;

ᨶ ᨾᩩᨡᩮᨶ ᨶ ᨶᩣᩈᩣᨿ, ᨶ ᩒᨭ᩠ᨮᩮᩉᩥ ᨽᨾᩪᩉᩥ ᩅᩣ.

‘‘ᨶ ᨣᩦᩅᩣᨿ ᨶ ᩋᩴᩈᩮᩉᩥ, ᨶ ᩏᨴᩁᩮᨶ ᨶ ᨸᩥᨭ᩠ᨮᩥᨿᩣ;

ᨶ ᩈᩮᩣᨱᩥᨿᩣ ᨶ ᩏᩁᩈᩣ, ᨶ ᩈᨾ᩠ᨻᩣᨵᩮ ᨶ ᨾᩮᨳᩩᨶᩮ [ᨶ ᩈᨾ᩠ᨻᩣᨵᩣ ᨶ ᨾᩮᨳᩩᨶᩣ (ᩈ᩠ᨿᩣ. ᨠ.)].

‘‘ᨶ ¶ ᩉᨲ᩠ᨳᩮᩉᩥ ᨶ ᨸᩣᨴᩮᩉᩥ, ᨶᩣᨦ᩠ᨣᩩᩃᩦᩉᩥ ᨶᨡᩮᩉᩥ ᩅᩣ;

ᨶ ᨩᨦ᩠ᨥᩣᩉᩥ ᨶ ᩐᩁᩪᩉᩥ, ᨶ ᩅᨱ᩠ᨱᩮᨶ ᩈᩁᩮᨶ ᩅᩣ;

ᩃᩥᨦ᩠ᨣᩴ ᨩᩣᨲᩥᨾᨿᩴ ᨶᩮᩅ, ᨿᨳᩣ ᩋᨬ᩠ᨬᩣᩈᩩ ᨩᩣᨲᩥᩈᩩ.

‘‘ᨸᨧ᩠ᨧᨲ᩠ᨲᨬ᩠ᨧ ¶ ᩈᩁᩦᩁᩮᩈᩩ [ᨸᨧ᩠ᨧᨲ᩠ᨲᩴ ᩈᩈᩁᩦᩁᩮᩈᩩ (ᩈᩦ. ᨸᩦ.)], ᨾᨶᩩᩔᩮᩈ᩠ᩅᩮᨲᩴ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᩅᩮᩣᨠᩣᩁᨬ᩠ᨧ ᨾᨶᩩᩔᩮᩈᩩ, ᩈᨾᨬ᩠ᨬᩣᨿ ᨸᩅᩩᨧ᩠ᨧᨲᩥ.

‘‘ᨿᩮᩣ ᩉᩥ ᨠᩮᩣᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᨣᩮᩣᩁᨠ᩠ᨡᩴ ᩏᨸᨩᩦᩅᨲᩥ;

ᩑᩅᩴ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᨠᩔᨠᩮᩣ ᩈᩮᩣ ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨿᩮᩣ ᩉᩥ ᨠᩮᩣᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᨸᩩᨳᩩᩈᩥᨸ᩠ᨸᩮᨶ ᨩᩦᩅᨲᩥ;

ᩑᩅᩴ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᩈᩥᨸ᩠ᨸᩥᨠᩮᩣ ᩈᩮᩣ ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨿᩮᩣ ᩉᩥ ᨠᩮᩣᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᩅᩮᩣᩉᩣᩁᩴ ᩏᨸᨩᩦᩅᨲᩥ;

ᩑᩅᩴ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᩅᩣᨱᩥᨩᩮᩣ ᩈᩮᩣ ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨿᩮᩣ ᩉᩥ ᨠᩮᩣᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᨸᩁᨸᩮᩔᩮᨶ ᨩᩦᩅᨲᩥ;

ᩑᩅᩴ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᨸᩮᩔᩥᨠᩮᩣ [ᨸᩮᩔᨠᩮᩣ (ᨠ.)] ᩈᩮᩣ ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨿᩮᩣ ᩉᩥ ᨠᩮᩣᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᩋᨴᩥᨶ᩠ᨶᩴ ᩏᨸᨩᩦᩅᨲᩥ;

ᩑᩅᩴ ¶ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᨧᩮᩣᩁᩮᩣ ᩑᩈᩮᩣ ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨿᩮᩣ ᩉᩥ ᨠᩮᩣᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᩍᩔᨲ᩠ᨳᩴ ᩏᨸᨩᩦᩅᨲᩥ;

ᩑᩅᩴ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᨿᩮᩣᨵᩣᨩᩦᩅᩮᩣ ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨿᩮᩣ ᩉᩥ ᨠᩮᩣᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᨸᩮᩣᩁᩮᩣᩉᩥᨧ᩠ᨧᩮᨶ ᨩᩦᩅᨲᩥ;

ᩑᩅᩴ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᨿᩣᨩᨠᩮᩣ ᩑᩈᩮᩣ ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨿᩮᩣ ¶ ᩉᩥ ᨠᩮᩣᨧᩥ ᨾᨶᩩᩔᩮᩈᩩ, ᨣᩣᨾᩴ ᩁᨭ᩠ᨮᨬ᩠ᨧ ᨽᩩᨬ᩠ᨩᨲᩥ;

ᩑᩅᩴ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᩁᩣᨩᩣ ᩑᩈᩮᩣ ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨶ ¶ ᨧᩣᩉᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᨻᩕᩪᨾᩥ, ᨿᩮᩣᨶᩥᨩᩴ ᨾᨲ᩠ᨲᩥᩈᨾ᩠ᨽᩅᩴ;

ᨽᩮᩣᩅᩣᨴᩥ ᨶᩣᨾ ᩈᩮᩣ ᩉᩮᩣᨲᩥ, ᩈᨧᩮ [ᩈ ᩅᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩉᩮᩣᨲᩥ ᩈᨠᩥᨬ᩠ᨧᨶᩮᩣ;

ᩋᨠᩥᨬ᩠ᨧᨶᩴ ᩋᨶᩣᨴᩣᨶᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩈᨻ᩠ᨻᩈᩴᨿᩮᩣᨩᨶᩴ ᨨᩮᨲ᩠ᩅᩣ, ᩈᩮᩣ ᩅᩮ ᨶ ᨸᩁᩥᨲᩔᨲᩥ;

ᩈᨦ᩠ᨣᩣᨲᩥᨣᩴ ᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

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

ᩏᨠ᩠ᨡᩥᨲ᩠ᨲᨸᩃᩥᨥᩴ ᨻᩩᨴ᩠ᨵᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩋᨠ᩠ᨠᩮᩣᩈᩴ ᩅᨵᨻᨶ᩠ᨵᨬ᩠ᨧ, ᩋᨴᩩᨭ᩠ᨮᩮᩣ ᨿᩮᩣ ᨲᩥᨲᩥᨠ᩠ᨡᨲᩥ;

ᨡᨶ᩠ᨲᩦᨻᩃᩴ ᨻᩃᩣᨶᩦᨠᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩋᨠ᩠ᨠᩮᩣᨵᨶᩴ ᩅᨲᩅᨶ᩠ᨲᩴ, ᩈᩦᩃᩅᨶ᩠ᨲᩴ ᩋᨶᩩᩔᨴᩴ;

ᨴᨶ᩠ᨲᩴ ᩋᨶ᩠ᨲᩥᨾᩈᩣᩁᩦᩁᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩅᩣᩁᩥ ᨸᩮᩣᨠ᩠ᨡᩁᨸᨲ᩠ᨲᩮᩅ, ᩌᩁᨣ᩠ᨣᩮᩁᩥᩅ ᩈᩣᩈᨸᩮᩣ;

ᨿᩮᩣ ᨶ ᩃᩥᨾ᩠ᨸᨲᩥ ᨠᩣᨾᩮᩈᩩ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩮᩣ ¶ ᨴᩩᨠ᩠ᨡᩔ ᨸᨩᩣᨶᩣᨲᩥ, ᩍᨵᩮᩅ ᨡᨿᨾᨲ᩠ᨲᨶᩮᩣ;

ᨸᨶ᩠ᨶᨽᩣᩁᩴ ᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨣᨾ᩠ᨽᩦᩁᨸᨬ᩠ᨬᩴ ᨾᩮᨵᩣᩅᩥᩴ, ᨾᨣ᩠ᨣᩣᨾᨣ᩠ᨣᩔ ᨠᩮᩣᩅᩥᨴᩴ;

ᩏᨲ᩠ᨲᨾᨲ᩠ᨳᨾᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩋᩈᩴᩈᨭ᩠ᨮᩴ ᨣᩉᨭ᩠ᨮᩮᩉᩥ, ᩋᨶᩣᨣᩣᩁᩮᩉᩥ ᨧᩪᨽᨿᩴ;

ᩋᨶᩮᩣᨠᩈᩣᩁᩥᨾᨸ᩠ᨸᩥᨧ᩠ᨨᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨶᩥᨵᩣᨿ ᨴᨱ᩠ᨯᩴ ᨽᩪᨲᩮᩈᩩ, ᨲᩈᩮᩈᩩ ᨳᩣᩅᩁᩮᩈᩩ ᨧ;

ᨿᩮᩣ ᨶ ᩉᨶ᩠ᨲᩥ ᨶ ᨥᩣᨲᩮᨲᩥ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩋᩅᩥᩁᩩᨴ᩠ᨵᩴ ¶ ᩅᩥᩁᩩᨴ᩠ᨵᩮᩈᩩ, ᩋᨲ᩠ᨲᨴᨱ᩠ᨯᩮᩈᩩ ᨶᩥᨻ᩠ᨻᩩᨲᩴ;

ᩈᩣᨴᩣᨶᩮᩈᩩ ᩋᨶᩣᨴᩣᨶᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩔ ¶ ᩁᩣᨣᩮᩣ ᨧ ᨴᩮᩣᩈᩮᩣ ᨧ, ᨾᩣᨶᩮᩣ ᨾᨠ᩠ᨡᩮᩣ ᨧ ᨸᩣᨲᩥᨲᩮᩣ;

ᩈᩣᩈᨸᩮᩣᩁᩥᩅ ᩌᩁᨣ᩠ᨣᩣ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩋᨠᨠ᩠ᨠᩈᩴ ¶ ᩅᩥᨬ᩠ᨬᩣᨸᨶᩥᩴ, ᨣᩥᩁᩴ ᩈᨧ᩠ᨧᨾᩩᨴᩦᩁᨿᩮ;

ᨿᩣᨿ ᨶᩣᨽᩥᩈᨩᩮ ᨠᨬ᩠ᨧᩥ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩮᩣᨵ ᨴᩦᨥᩴ ᩅ ᩁᩔᩴ ᩅᩣ, ᩋᨱᩩᩴ ᨳᩪᩃᩴ ᩈᩩᨽᩣᩈᩩᨽᩴ;

ᩃᩮᩣᨠᩮ ᩋᨴᩥᨶ᩠ᨶᩴ ᨶᩣᨴᩥᨿᨲᩥ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩌᩈᩣ ᨿᩔ ᨶ ᩅᩥᨩ᩠ᨩᨶ᩠ᨲᩥ, ᩋᩈ᩠ᨾᩥᩴ ᩃᩮᩣᨠᩮ ᨸᩁᨾ᩠ᩉᩥ ᨧ;

ᨶᩥᩁᩣᩈᩣᩈᩴ [ᨶᩥᩁᩣᩈᨿᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.), ᨶᩥᩁᩣᩈᨠᩴ (?)] ᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩔᩣᩃᨿᩣ ᨶ ᩅᩥᨩ᩠ᨩᨶ᩠ᨲᩥ, ᩋᨬ᩠ᨬᩣᨿ ᩋᨠᨳᩴᨠᨳᩦ;

ᩋᨾᨲᩮᩣᨣᨵᨾᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩮᩣᨵ ¶ ᨸᩩᨬ᩠ᨬᨬ᩠ᨧ ᨸᩣᨸᨬ᩠ᨧ, ᩏᨽᩮᩣ ᩈᨦ᩠ᨣᨾᩩᨸᨧ᩠ᨧᨣᩣ;

ᩋᩈᩮᩣᨠᩴ ᩅᩥᩁᨩᩴ ᩈᩩᨴ᩠ᨵᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨧᨶ᩠ᨴᩴᩅ ᩅᩥᨾᩃᩴ ᩈᩩᨴ᩠ᨵᩴ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᨾᨶᩣᩅᩥᩃᩴ;

ᨶᨶ᩠ᨴᩦᨽᩅᨸᩁᩥᨠ᩠ᨡᩦᨱᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩮᩣᨾᩴ ᨸᩃᩥᨸᨳᩴ ᨴᩩᨣ᩠ᨣᩴ, ᩈᩴᩈᩣᩁᩴ ᨾᩮᩣᩉᨾᨧ᩠ᨧᨣᩣ;

ᨲᩥᨱ᩠ᨱᩮᩣ ᨸᩣᩁᨦ᩠ᨣᨲᩮᩣ ᨫᩣᨿᩦ, ᩋᨶᩮᨩᩮᩣ ᩋᨠᨳᩴᨠᨳᩦ;

ᩋᨶᩩᨸᩣᨴᩣᨿ ᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩮᩣᨵ ᨠᩣᨾᩮ ᨸᩉᨶ᩠ᨲ᩠ᩅᩣᨶ, ᩋᨶᩣᨣᩣᩁᩮᩣ ᨸᩁᩥᨻ᩠ᨻᨩᩮ;

ᨠᩣᨾᨽᩅᨸᩁᩥᨠ᩠ᨡᩦᨱᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩮᩣᨵ ¶ ᨲᨱ᩠ᩉᩴ ᨸᩉᨶ᩠ᨲ᩠ᩅᩣᨶ, ᩋᨶᩣᨣᩣᩁᩮᩣ ᨸᩁᩥᨻ᩠ᨻᨩᩮ;

ᨲᨱ᩠ᩉᩣᨽᩅᨸᩁᩥᨠ᩠ᨡᩦᨱᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩉᩥᨲ᩠ᩅᩣ ᨾᩣᨶᩩᩈᨠᩴ ᨿᩮᩣᨣᩴ, ᨴᩥᨻ᩠ᨻᩴ ᨿᩮᩣᨣᩴ ᩏᨸᨧ᩠ᨧᨣᩣ;

ᩈᨻ᩠ᨻᨿᩮᩣᨣᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩉᩥᨲ᩠ᩅᩣ ᩁᨲᩥᨬ᩠ᨧ ᩋᩁᨲᩥᩴ, ᩈᩦᨲᩥᨽᩪᨲᩴ ᨶᩥᩁᩪᨸᨵᩥᩴ;

ᩈᨻ᩠ᨻᩃᩮᩣᨠᩣᨽᩥᨽᩩᩴ ᩅᩦᩁᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨧᩩᨲᩥᩴ ¶ ¶ ᨿᩮᩣ ᩅᩮᨴᩥ [ᨿᩮᩣ’ᩅᩮᨲᩥ (?) ᩍᨲᩥᩅᩩᨲ᩠ᨲᨠᩮ ᪙᪙ ᩋᨭ᩠ᨮᨠᨳᩣᩈᩴᩅᨱᨶᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨲ᩠ᨲᩣᨶᩴ, ᩏᨸᨸᨲ᩠ᨲᩥᨬ᩠ᨧ ᩈᨻ᩠ᨻᩈᩮᩣ;

ᩋᩈᨲ᩠ᨲᩴ ᩈᩩᨣᨲᩴ ᨻᩩᨴ᩠ᨵᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩔ ᨣᨲᩥᩴ ᨶ ᨩᩣᨶᨶ᩠ᨲᩥ, ᨴᩮᩅᩣ ᨣᨶ᩠ᨵᨻ᩠ᨻᨾᩣᨶᩩᩈᩣ;

ᨡᩦᨱᩣᩈᩅᩴ ᩋᩁᩉᨶ᩠ᨲᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨿᩔ ᨸᩩᩁᩮ ᨧ ᨸᨧ᩠ᨨᩣ ᨧ, ᨾᨩ᩠ᨫᩮ ᨧ ᨶᨲ᩠ᨳᩥ ᨠᩥᨬ᩠ᨧᨶᩴ;

ᩋᨠᩥᨬ᩠ᨧᨶᩴ ¶ ᩋᨶᩣᨴᩣᨶᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩏᩈᨽᩴ ᨸᩅᩁᩴ ᩅᩦᩁᩴ, ᨾᩉᩮᩈᩥᩴ ᩅᩥᨩᩥᨲᩣᩅᩥᨶᩴ;

ᩋᨶᩮᨩᩴ ᨶ᩠ᩉᩣᨲᨠᩴ ᨻᩩᨴ᩠ᨵᩴ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᨸᩩᨻ᩠ᨻᩮᨶᩥᩅᩣᩈᩴ ᨿᩮᩣ ᩅᩮᨴᩥ [ᨿᩮᩣ’ᩅᩮᨲᩥ (?) ᩍᨲᩥᩅᩩᨲ᩠ᨲᨠᩮ ᪙᪙ ᩋᨭ᩠ᨮᨠᨳᩣᩈᩴᩅᨱᨶᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ], ᩈᨣ᩠ᨣᩣᨸᩣᨿᨬ᩠ᨧ ᨸᩔᨲᩥ;

ᩋᨳᩮᩣ ᨩᩣᨲᩥᨠ᩠ᨡᨿᩴ ᨸᨲ᩠ᨲᩮᩣ, ᨲᨾᩉᩴ ᨻᩕᩪᨾᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

‘‘ᩈᨾᨬ᩠ᨬᩣ ᩉᩮᩈᩣ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ, ᨶᩣᨾᨣᩮᩣᨲ᩠ᨲᩴ ᨸᨠᨸ᩠ᨸᩥᨲᩴ;

ᩈᨾ᩠ᨾᩩᨧ᩠ᨧᩣ ᩈᨾᩩᨴᩣᨣᨲᩴ, ᨲᨲ᩠ᨳ ᨲᨲ᩠ᨳ ᨸᨠᨸ᩠ᨸᩥᨲᩴ.

‘‘ᨴᩦᨥᩁᨲ᩠ᨲᨾᨶᩩᩈᨿᩥᨲᩴ, ᨴᩥᨭ᩠ᨮᩥᨣᨲᨾᨩᩣᨶᨲᩴ;

ᩋᨩᩣᨶᨶ᩠ᨲᩣ ᨶᩮᩣ [ᩋᨩᩣᨶᨶ᩠ᨲᩣ ᨲᩮ (ᩋᨭ᩠ᨮ.) ᨾ. ᨶᩥ. ᪒.᪔᪖᪐] ᨸᨻᩕᩩᩅᨶ᩠ᨲᩥ, ᨩᩣᨲᩥᨿᩣ ᩉᩮᩣᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨶ ¶ ᨩᨧ᩠ᨧᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩮᩣᨲᩥ, ᨶ ᨩᨧ᩠ᨧᩣ ᩉᩮᩣᨲᩥ ᩋᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᨠᨾ᩠ᨾᩩᨶᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩮᩣᨲᩥ, ᨠᨾ᩠ᨾᩩᨶᩣ ᩉᩮᩣᨲᩥ ᩋᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨠᩔᨠᩮᩣ ᨠᨾ᩠ᨾᩩᨶᩣ ᩉᩮᩣᨲᩥ, ᩈᩥᨸ᩠ᨸᩥᨠᩮᩣ ᩉᩮᩣᨲᩥ ᨠᨾ᩠ᨾᩩᨶᩣ;

ᩅᩣᨱᩥᨩᩮᩣ ᨠᨾ᩠ᨾᩩᨶᩣ ᩉᩮᩣᨲᩥ, ᨸᩮᩔᩥᨠᩮᩣ ᩉᩮᩣᨲᩥ ᨠᨾ᩠ᨾᩩᨶᩣ.

‘‘ᨧᩮᩣᩁᩮᩣᨸᩥ ᨠᨾ᩠ᨾᩩᨶᩣ ᩉᩮᩣᨲᩥ, ᨿᩮᩣᨵᩣᨩᩦᩅᩮᩣᨸᩥ ᨠᨾ᩠ᨾᩩᨶᩣ;

ᨿᩣᨩᨠᩮᩣ ᨠᨾ᩠ᨾᩩᨶᩣ ᩉᩮᩣᨲᩥ, ᩁᩣᨩᩣᨸᩥ ᩉᩮᩣᨲᩥ ᨠᨾ᩠ᨾᩩᨶᩣ.

‘‘ᩑᩅᨾᩮᨲᩴ ¶ ¶ ᨿᨳᩣᨽᩪᨲᩴ, ᨠᨾ᩠ᨾᩴ ᨸᩔᨶ᩠ᨲᩥ ᨸᨱ᩠ᨯᩥᨲᩣ;

ᨸᨭᩥᨧ᩠ᨧᩈᨾᩩᨸ᩠ᨸᩣᨴᨴᩔᩣ, ᨠᨾ᩠ᨾᩅᩥᨸᩣᨠᨠᩮᩣᩅᩥᨴᩣ.

‘‘ᨠᨾ᩠ᨾᩩᨶᩣ ᩅᨲ᩠ᨲᨲᩥ ᩃᩮᩣᨠᩮᩣ, ᨠᨾ᩠ᨾᩩᨶᩣ ᩅᨲ᩠ᨲᨲᩥ ᨸᨩᩣ;

ᨠᨾ᩠ᨾᨶᩥᨻᨶ᩠ᨵᨶᩣ ᩈᨲ᩠ᨲᩣ, ᩁᨳᩔᩣᨱᩦᩅ ᨿᩣᨿᨲᩮᩣ.

‘‘ᨲᨸᩮᨶ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩮᨶ, ᩈᩴᨿᨾᩮᨶ ᨴᨾᩮᨶ ᨧ;

ᩑᨲᩮᨶ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩉᩮᩣᨲᩥ, ᩑᨲᩴ ᨻᩕᩣᩉ᩠ᨾᨱᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨲᩦᩉᩥ ᩅᩥᨩ᩠ᨩᩣᩉᩥ ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᩈᨶ᩠ᨲᩮᩣ ᨡᩦᨱᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ;

ᩑᩅᩴ ᩅᩣᩈᩮᨭ᩠ᨮ ᨩᩣᨶᩣᩉᩥ, ᨻᩕᩉ᩠ᨾᩣ ᩈᨠ᩠ᨠᩮᩣ ᩅᩥᨩᩣᨶᨲ’’ᨶ᩠ᨲᩥ.

ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᩅᩣᩈᩮᨭ᩠ᨮᨽᩣᩁᨴ᩠ᩅᩣᨩᩣ ᨾᩣᨱᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧᩩᩴ – ‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩴ, ᨽᩮᩣ ᨣᩮᩣᨲᨾ…ᨸᩮ… ᩏᨸᩣᩈᨠᩮ ᨶᩮᩣ ᨽᩅᩴ ᨣᩮᩣᨲᨾᩮᩣ ᨵᩣᩁᩮᨲᩩ ᩋᨩ᩠ᨩᨲᨣ᩠ᨣᩮ ᨸᩣᨱᩩᨸᩮᨲᩮ [ᨸᩣᨱᩩᨸᩮᨲᩴ (ᨠ.)] ᩈᩁᨱᩴ ᨣᨲᩮ’’ᨲᩥ.

ᩑᩅᩴ ¶ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨩᩮᨲᩅᨶᩮ ᩋᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩔ ᩌᩁᩣᨾᩮ. ᩋᨳ ᨡᩮᩣ ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ¶ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᩥ. ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨡᩮᩣ ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨸᩣᨸᩥᨧ᩠ᨨᩣ, ᨽᨶ᩠ᨲᩮ, ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩣ, ᨸᩣᨸᩥᨠᩣᨶᩴ ᩍᨧ᩠ᨨᩣᨶᩴ ᩅᩈᩴ ᨣᨲᩣ’’ᨲᩥ.

ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᨽᨣᩅᩣ ᨠᩮᩣᨠᩣᩃᩥᨠᩴ ᨽᩥᨠ᩠ᨡᩩᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨾᩣ ᩉᩮᩅᩴ, ᨠᩮᩣᨠᩣᩃᩥᨠ, ᨾᩣ ᩉᩮᩅᩴ, ᨠᩮᩣᨠᩣᩃᩥᨠ! ᨸᩈᩣᨴᩮᩉᩥ, ᨠᩮᩣᨠᩣᩃᩥᨠ, ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᩈᩩ ᨧᩥᨲ᩠ᨲᩴ. ᨸᩮᩈᩃᩣ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩣ’’ᨲᩥ.

ᨴᩩᨲᩥᨿᨾ᩠ᨸᩥ ᨡᩮᩣ…ᨸᩮ… ¶ ᨲᨲᩥᨿᨾ᩠ᨸᩥ ᨡᩮᩣ ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩥᨬ᩠ᨧᩣᨸᩥ ᨾᩮ, ᨽᨶ᩠ᨲᩮ, ᨽᨣᩅᩣ ᩈᨴ᩠ᨵᩣᨿᩥᨠᩮᩣ ᨸᨧ᩠ᨧᨿᩥᨠᩮᩣ, ᩋᨳ ᨡᩮᩣ ᨸᩣᨸᩥᨧ᩠ᨨᩣᩅ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩣ, ᨸᩣᨸᩥᨠᩣᨶᩴ ᩍᨧ᩠ᨨᩣᨶᩴ ᩅᩈᩴ ᨣᨲᩣ’’ᨲᩥ. ᨲᨲᩥᨿᨾ᩠ᨸᩥ ᨡᩮᩣ ᨽᨣᩅᩣ ᨠᩮᩣᨠᩣᩃᩥᨠᩴ ᨽᩥᨠ᩠ᨡᩩᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨾᩣ ᩉᩮᩅᩴ, ᨠᩮᩣᨠᩣᩃᩥᨠ ¶ , ᨾᩣ ᩉᩮᩅᩴ, ᨠᩮᩣᨠᩣᩃᩥᨠ! ᨸᩈᩣᨴᩮᩉᩥ, ᨠᩮᩣᨠᩣᩃᩥᨠ, ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᩈᩩ ᨧᩥᨲ᩠ᨲᩴ. ᨸᩮᩈᩃᩣ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩣ’’ᨲᩥ.

ᩋᨳ ᨡᩮᩣ ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᩏᨭ᩠ᨮᩣᨿᩣᩈᨶᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ ᨸᨴᨠ᩠ᨡᩥᨱᩴ ᨠᨲ᩠ᩅᩣ ᨸᨠ᩠ᨠᩣᨾᩥ. ᩋᨧᩥᩁᨸ᩠ᨸᨠ᩠ᨠᨶ᩠ᨲᩔ ᨧ ᨠᩮᩣᨠᩣᩃᩥᨠᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᩈᩣᩈᨸᨾᨲ᩠ᨲᩦᩉᩥ ᨸᩥᩊᨠᩣᩉᩥ ᩈᨻ᩠ᨻᩮᩣ ᨠᩣᨿᩮᩣ ᨹᩩᨭᩮᩣ [ᨹᩩᨭ᩠ᨮᩮᩣ (ᩈ᩠ᨿᩣ.)] ᩋᩉᩮᩣᩈᩥ; ᩈᩣᩈᨸᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩉᩩᨲ᩠ᩅᩣ ᨾᩩᨣ᩠ᨣᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩉᩮᩈᩩᩴ; ᨾᩩᨣ᩠ᨣᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩉᩩᨲ᩠ᩅᩣ ᨠᩊᩣᨿᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩉᩮᩈᩩᩴ; ᨠᩊᩣᨿᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩉᩩᨲ᩠ᩅᩣ ᨠᩮᩣᩃᨭ᩠ᨮᩥᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩉᩮᩈᩩᩴ; ᨠᩮᩣᩃᨭ᩠ᨮᩥᨾᨲ᩠ᨲᩥᨿᩮᩣ ¶ ᩉᩩᨲ᩠ᩅᩣ ᨠᩮᩣᩃᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩉᩮᩈᩩᩴ; ᨠᩮᩣᩃᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩉᩩᨲ᩠ᩅᩣ ᩌᨾᩃᨠᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩉᩮᩈᩩᩴ; ᩌᨾᩃᨠᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩉᩩᨲ᩠ᩅᩣ ᨻᩮᩊᩩᩅᩈᩃᩣᨭᩩᨠᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩉᩮᩈᩩᩴ; ᨻᩮᩊᩩᩅᩈᩃᩣᨭᩩᨠᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩉᩩᨲ᩠ᩅᩣ ᨻᩥᩃ᩠ᩃᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩋᩉᩮᩈᩩᩴ; ᨻᩥᩃ᩠ᩃᨾᨲ᩠ᨲᩥᨿᩮᩣ ᩉᩩᨲ᩠ᩅᩣ ᨸᨽᩥᨩ᩠ᨩᩥᩴᩈᩩ; ᨸᩩᨻ᩠ᨻᨬ᩠ᨧ ᩃᩮᩣᩉᩥᨲᨬ᩠ᨧ ᨸᨣ᩠ᨥᩁᩥᩴᩈᩩ. ᩋᨳ ᨡᩮᩣ ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨲᩮᨶᩮᩅᩣᨻᩣᨵᩮᨶ ᨠᩣᩃᨾᨠᩣᩈᩥ. ᨠᩣᩃᨦ᩠ᨠᨲᩮᩣ ᨧ ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨸᨴᩩᨾᩴ ᨶᩥᩁᨿᩴ ᩏᨸᨸᨩ᩠ᨩᩥ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᩈᩩ ᨧᩥᨲ᩠ᨲᩴ ᩌᨥᩣᨲᩮᨲ᩠ᩅᩣ ¶ .

ᩋᨳ ᨡᩮᩣ ᨻᩕᩉ᩠ᨾᩣ ᩈᩉᨾ᩠ᨸᨲᩥ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩣᨿ ᩁᨲ᩠ᨲᩥᨿᩣ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩅᨱ᩠ᨱᩮᩣ ᨠᩮᩅᩃᨠᨸ᩠ᨸᩴ ᨩᩮᨲᩅᨶᩴ ᩒᨽᩣᩈᩮᨲ᩠ᩅᩣ ᨿᩮᨶ ᨽᨣᩅᩣ ᨲᩮᨶᩩᨸᩈᨦ᩠ᨠᨾᩥ; ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ ᩑᨠᨾᨶ᩠ᨲᩴ ᩋᨭ᩠ᨮᩣᩈᩥ ¶ . ᩑᨠᨾᨶ᩠ᨲᩴ, ᨮᩥᨲᩮᩣ ᨡᩮᩣ ᨻᩕᩉ᩠ᨾᩣ ᩈᩉᨾ᩠ᨸᨲᩥ ᨽᨣᩅᨶ᩠ᨲᩴ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ, ᨽᨶ᩠ᨲᩮ, ᨽᩥᨠ᩠ᨡᩩ ᨠᩣᩃᨦ᩠ᨠᨲᩮᩣ; ᨠᩣᩃᨦ᩠ᨠᨲᩮᩣ ᨧ, ᨽᨶ᩠ᨲᩮ, ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨸᨴᩩᨾᩴ ᨶᩥᩁᨿᩴ ᩏᨸᨸᨶ᩠ᨶᩮᩣ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᩈᩩ ᨧᩥᨲ᩠ᨲᩴ ᩌᨥᩣᨲᩮᨲ᩠ᩅᩣ’’ᨲᩥ. ᩍᨴᨾᩅᩮᩣᨧ ᨻᩕᩉ᩠ᨾᩣ ᩈᩉᨾ᩠ᨸᨲᩥ; ᩍᨴᩴ ᩅᨲ᩠ᩅᩣ ᨽᨣᩅᨶ᩠ᨲᩴ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ ᨸᨴᨠ᩠ᨡᩥᨱᩴ ᨠᨲ᩠ᩅᩣ ᨲᨲ᩠ᨳᩮᩅᨶ᩠ᨲᩁᨵᩣᨿᩥ.

ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨲᩔᩣ ᩁᨲ᩠ᨲᩥᨿᩣ ᩋᨧ᩠ᨧᨿᩮᨶ ᨽᩥᨠ᩠ᨡᩪ ᩌᨾᨶ᩠ᨲᩮᩈᩥ – ‘‘ᩍᨾᩴ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᩁᨲ᩠ᨲᩥᩴ ᨻᩕᩉ᩠ᨾᩣ ᩈᩉᨾ᩠ᨸᨲᩥ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩣᨿ ᩁᨲ᩠ᨲᩥᨿᩣ…ᨸᩮ… ᩍᨴᨾᩅᩮᩣᨧ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨻᩕᩉ᩠ᨾᩣ ᩈᩉᨾ᩠ᨸᨲᩥ, ᩍᨴᩴ ᩅᨲ᩠ᩅᩣ ᨾᩴ ᨸᨴᨠ᩠ᨡᩥᨱᩴ ᨠᨲ᩠ᩅᩣ ᨲᨲ᩠ᨳᩮᩅᨶ᩠ᨲᩁᨵᩣᨿᩦ’’ᨲᩥ.

ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ, ᩋᨬ᩠ᨬᨲᩁᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨽᨣᩅᨶ᩠ᨲᩴ ¶ ᩑᨲᨴᩅᩮᩣᨧ – ‘‘ᨠᩦᩅᨴᩦᨥᩴ ᨶᩩ ᨡᩮᩣ, ᨽᨶ᩠ᨲᩮ, ᨸᨴᩩᨾᩮ ᨶᩥᩁᨿᩮ ᩌᨿᩩᨸ᩠ᨸᨾᩣᨱ’’ᨶ᩠ᨲᩥ? ‘‘ᨴᩦᨥᩴ ᨡᩮᩣ, ᨽᩥᨠ᩠ᨡᩩ, ᨸᨴᩩᨾᩮ ᨶᩥᩁᨿᩮ ᩌᨿᩩᨸ᩠ᨸᨾᩣᨱᩴ; ᨲᩴ ᨶ ᩈᩩᨠᩁᩴ ᩈᨦ᩠ᨡᩣᨲᩩᩴ ᩑᨲ᩠ᨲᨠᩣᨶᩥ ᩅᩔᩣᨶᩥ ᩍᨲᩥ ᩅᩣ ᩑᨲ᩠ᨲᨠᩣᨶᩥ ᩅᩔᩈᨲᩣᨶᩥ ᩍᨲᩥ ᩅᩣ ᩑᨲ᩠ᨲᨠᩣᨶᩥ ᩅᩔᩈᩉᩔᩣᨶᩥ ¶ ᩍᨲᩥ ᩅᩣ ᩑᨲ᩠ᨲᨠᩣᨶᩥ ᩅᩔᩈᨲᩈᩉᩔᩣᨶᩥ ᩍᨲᩥ ᩅᩣ’’ᨲᩥ. ‘‘ᩈᨠ᩠ᨠᩣ ᨸᨶ, ᨽᨶ᩠ᨲᩮ, ᩏᨸᨾᩣ [ᩏᨸᨾᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)] ᨠᩣᨲᩩ’’ᨶ᩠ᨲᩥ? ‘‘ᩈᨠ᩠ᨠᩣ, ᨽᩥᨠ᩠ᨡᩪ’’ᨲᩥ ᨽᨣᩅᩣ ᩋᩅᩮᩣᨧ –

‘‘ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥᨡᩣᩁᩥᨠᩮᩣ ᨠᩮᩣᩈᩃᨠᩮᩣ ᨲᩥᩃᩅᩣᩉᩮᩣ; ᨲᨲᩮᩣ ᨸᩩᩁᩥᩈᩮᩣ ᩅᩔᩈᨲᩔ ᩅᩔᩈᨲᩔ ᩋᨧ᩠ᨧᨿᩮᨶ ᩑᨠᨾᩮᨠᩴ ᨲᩥᩃᩴ ᩏᨴ᩠ᨵᩁᩮᨿ᩠ᨿ. ᨡᩥᨸ᩠ᨸᨲᩁᩴ ᨡᩮᩣ ᩈᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᩅᩦᩈᨲᩥᨡᩣᩁᩥᨠᩮᩣ ᨠᩮᩣᩈᩃᨠᩮᩣ ᨲᩥᩃᩅᩣᩉᩮᩣ ¶ ᩍᨾᩥᨶᩣ ᩏᨸᨠ᩠ᨠᨾᩮᨶ ᨸᩁᩥᨠ᩠ᨡᨿᩴ ᨸᩁᩥᨿᩣᨴᩣᨶᩴ ᨣᨧ᩠ᨨᩮᨿ᩠ᨿ, ᨶᨲ᩠ᩅᩮᩅ ᩑᨠᩮᩣ ᩋᨻ᩠ᨻᩩᨴᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᩋᨻ᩠ᨻᩩᨴᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᨶᩥᩁᨻ᩠ᨻᩩᨴᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᨶᩥᩁᨻ᩠ᨻᩩᨴᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᩋᨻᨻᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᩋᨻᨻᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᩋᩉᩉᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᩋᩉᩉᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᩋᨭᨭᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᩋᨭᨭᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᨠᩩᨾᩩᨴᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᨠᩩᨾᩩᨴᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᩈᩮᩣᨣᨶ᩠ᨵᩥᨠᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᩈᩮᩣᨣᨶ᩠ᨵᩥᨠᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᩏᨸ᩠ᨸᩃᨠᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᩏᨸ᩠ᨸᩃᨠᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᨸᩩᨱ᩠ᨯᩁᩦᨠᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨽᩥᨠ᩠ᨡᩩ, ᩅᩦᩈᨲᩥ ᨸᩩᨱ᩠ᨯᩁᩦᨠᩣ ᨶᩥᩁᨿᩣ ᩑᩅᨾᩮᨠᩮᩣ ᨸᨴᩩᨾᩮᩣ ᨶᩥᩁᨿᩮᩣ. ᨸᨴᩩᨾᩴ ᨡᩮᩣ ᨸᨶ ᨽᩥᨠ᩠ᨡᩩ ᨶᩥᩁᨿᩴ ᨠᩮᩣᨠᩣᩃᩥᨠᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᩏᨸᨸᨶ᩠ᨶᩮᩣ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᩈᩩ ᨧᩥᨲ᩠ᨲᩴ ᩌᨥᩣᨲᩮᨲ᩠ᩅᩣ’’ᨲᩥ. ᩍᨴᨾᩅᩮᩣᨧ ᨽᨣᩅᩣ, ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᩈᩩᨣᨲᩮᩣ ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨸᩩᩁᩥᩈᩔ ¶ ¶ ᩉᩥ ᨩᩣᨲᩔ, ᨠᩩᨮᩣᩁᩦ [ᨠᩩᨵᩣᩁᩦ (ᨠ.)] ᨩᩣᨿᨲᩮ ᨾᩩᨡᩮ;

ᨿᩣᨿ ᨨᩥᨶ᩠ᨴᨲᩥ ᩋᨲ᩠ᨲᩣᨶᩴ, ᨻᩣᩃᩮᩣ ᨴᩩᨻ᩠ᨽᩣᩈᩥᨲᩴ ᨽᨱᩴ.

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

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

‘‘ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ ¶ ᩋᨿᩴ ᨠᩃᩥ, ᨿᩮᩣ ᩋᨠ᩠ᨡᩮᩈᩩ ᨵᨶᨸᩁᩣᨩᨿᩮᩣ;

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

‘‘ᩈᨲᩴ ᩈᩉᩔᩣᨶᩴ ᨶᩥᩁᨻ᩠ᨻᩩᨴᩣᨶᩴ, ᨨᨲ᩠ᨲᩥᩴᩈᨲᩥ ᨸᨬ᩠ᨧ ᨧ ᩋᨻ᩠ᨻᩩᨴᩣᨶᩥ [ᩋᨻ᩠ᨻᩩᨴᩣᨶᩴ (ᨠ.)];

ᨿᨾᩁᩥᨿᨣᩁᩉᩦ ᨶᩥᩁᨿᩴ ᩏᨸᩮᨲᩥ, ᩅᩣᨧᩴ ᨾᨶᨬ᩠ᨧ ᨸᨱᩥᨵᩣᨿ ᨸᩣᨸᨠᩴ.

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

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

‘‘ᨿᩮᩣ ᩋᨸ᩠ᨸᨴᩩᨭ᩠ᨮᩔ ᨶᩁᩔ ᨴᩩᩔᨲᩥ, ᩈᩩᨴ᩠ᨵᩔ ᨸᩮᩣᩈᩔ ᩋᨶᨦ᩠ᨣᨱᩔ;

ᨲᨾᩮᩅ ᨻᩣᩃᩴ ᨸᨧ᩠ᨧᩮᨲᩥ ᨸᩣᨸᩴ, ᩈᩩᨡᩩᨾᩮᩣ ᩁᨩᩮᩣ ᨸᨭᩥᩅᩣᨲᩴᩅ ᨡᩥᨲ᩠ᨲᩮᩣ.

‘‘ᨿᩮᩣ ᩃᩮᩣᨽᨣᩩᨱᩮ ᩋᨶᩩᨿᩩᨲ᩠ᨲᩮᩣ, ᩈᩮᩣ ᩅᨧᩈᩣ ᨸᩁᩥᨽᩣᩈᨲᩥ ᩋᨬ᩠ᨬᩮ;

ᩋᩈᨴ᩠ᨵᩮᩣ ¶ ¶ ᨠᨴᩁᩥᨿᩮᩣ ᩋᩅᨴᨬ᩠ᨬᩪ, ᨾᨧ᩠ᨨᩁᩥ ᨸᩮᩈᩩᨱᩥᨿᩴ [ᨸᩮᩈᩩᨱᩥᨿᩈ᩠ᨾᩥᩴ (ᨻᩉᩪᩈᩩ)] ᩋᨶᩩᨿᩩᨲ᩠ᨲᩮᩣ.

‘‘ᨾᩩᨡᨴᩩᨣ᩠ᨣ ᩅᩥᨽᩪᨲ ᩋᨶᩁᩥᨿ, ᨽᩪᨶᩉᩩ [ᨽᩩᨶᩉᨲ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨸᩣᨸᨠ ᨴᩩᨠ᩠ᨠᨭᨠᩣᩁᩥ;

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

‘‘ᩁᨩᨾᩣᨠᩥᩁᩈᩦ ¶ ᩋᩉᩥᨲᩣᨿ, ᩈᨶ᩠ᨲᩮ ᨣᩁᩉᩈᩥ ᨠᩥᨻ᩠ᨻᩥᩈᨠᩣᩁᩦ;

ᨻᩉᩪᨶᩥ ᨴᩩᨧ᩠ᨧᩁᩥᨲᩣᨶᩥ ᨧᩁᩥᨲ᩠ᩅᩣ, ᨣᨧ᩠ᨨᩈᩥ ᨡᩮᩣ ᨸᨸᨲᩴ ᨧᩥᩁᩁᨲ᩠ᨲᩴ.

‘‘ᨶ ᩉᩥ ᨶᩔᨲᩥ ᨠᩔᨧᩥ ᨠᨾ᩠ᨾᩴ, ᩑᨲᩥ ᩉᨲᩴ ᩃᨽᨲᩮᩅ ᩈᩩᩅᩣᨾᩥ;

ᨴᩩᨠ᩠ᨡᩴ ᨾᨶ᩠ᨴᩮᩣ ᨸᩁᩃᩮᩣᨠᩮ, ᩋᨲ᩠ᨲᨶᩥ ᨸᩔᨲᩥ ᨠᩥᨻ᩠ᨻᩥᩈᨠᩣᩁᩦ.

‘‘ᩋᨿᩮᩣᩈᨦ᩠ᨠᩩᩈᨾᩣᩉᨲᨭ᩠ᨮᩣᨶᩴ ¶ , ᨲᩥᨱ᩠ᩉᨵᩣᩁᨾᨿᩈᩪᩃᨾᩩᨸᩮᨲᩥ;

ᩋᨳ ¶ ᨲᨲ᩠ᨲᩋᨿᩮᩣᨣᩩᩊᩈᨶ᩠ᨶᩥᨽᩴ, ᨽᩮᩣᨩᨶᨾᨲ᩠ᨳᩥ ᨲᨳᩣ ᨸᨲᩥᩁᩪᨸᩴ.

‘‘ᨶ ᩉᩥ ᩅᨣ᩠ᨣᩩ ᩅᨴᨶ᩠ᨲᩥ ᩅᨴᨶ᩠ᨲᩣ, ᨶᩣᨽᩥᨩᩅᨶ᩠ᨲᩥ ᨶ ᨲᩣᨱᨾᩩᨸᩮᨶ᩠ᨲᩥ;

ᩋᨦ᩠ᨣᩣᩁᩮ ¶ ᩈᨶ᩠ᨳᨲᩮ ᩈᨿᨶ᩠ᨲᩥ [ᩈᩮᨶ᩠ᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨣᩥᨶᩥᩈᨾ᩠ᨸᨩ᩠ᨩᩃᩥᨲᩴ ᨸᩅᩥᩈᨶ᩠ᨲᩥ.

‘‘ᨩᩣᩃᩮᨶ ᨧ ᩒᨶᩉᩥᨿᩣᨶ, ᨲᨲ᩠ᨳ ᩉᨶᨶ᩠ᨲᩥ ᩋᨿᩮᩣᨾᨿᨠᩩᨭᩮᨽᩥ [ᩋᨿᩮᩣᨾᨿᨠᩪᨭᩮᩉᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᩋᨶ᩠ᨵᩴᩅ ᨲᩥᨾᩥᩈᨾᩣᨿᨶ᩠ᨲᩥ, ᨲᩴ ᩅᩥᨲᨲᨬ᩠ᩉᩥ ᨿᨳᩣ ᨾᩉᩥᨠᩣᨿᩮᩣ.

‘‘ᩋᨳ ᩃᩮᩣᩉᨾᨿᩴ ᨸᨶ ᨠᩩᨾ᩠ᨽᩥᩴ, ᨣᩥᨶᩥᩈᨾ᩠ᨸᨩ᩠ᨩᩃᩥᨲᩴ ᨸᩅᩥᩈᨶ᩠ᨲᩥ;

ᨸᨧ᩠ᨧᨶ᩠ᨲᩥ ᩉᩥ ᨲᩣᩈᩩ ᨧᩥᩁᩁᨲ᩠ᨲᩴ, ᩋᨣ᩠ᨣᩥᨶᩥᩈᨾᩣᩈᩩ [ᨣᩥᨶᩥᩔᨾᩣᩈᩩ (ᨠ.)] ᩈᨾᩩᨸ᩠ᨸᩥᩃᩅᩣᨲᩮ.

‘‘ᩋᨳ ᨸᩩᨻ᩠ᨻᩃᩮᩣᩉᩥᨲᨾᩥᩔᩮ, ᨲᨲ᩠ᨳ ᨠᩥᩴ ᨸᨧ᩠ᨧᨲᩥ ᨠᩥᨻ᩠ᨻᩥᩈᨠᩣᩁᩦ;

ᨿᩴ ᨿᩴ ¶ ᨴᩥᩈᨠᩴ [ᨴᩥᩈᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩋᨵᩥᩈᩮᨲᩥ, ᨲᨲ᩠ᨳ ᨠᩥᩃᩥᩔᨲᩥ ᩈᨾ᩠ᨹᩩᩈᨾᩣᨶᩮᩣ.

‘‘ᨸᩩᩊᩅᩣᩅᩈᨳᩮ ¶ ᩈᩃᩥᩃᩈ᩠ᨾᩥᩴ, ᨲᨲ᩠ᨳ ᨠᩥᩴ ᨸᨧ᩠ᨧᨲᩥ ᨠᩥᨻ᩠ᨻᩥᩈᨠᩣᩁᩦ;

ᨣᨶ᩠ᨲᩩᩴ ᨶ ᩉᩥ ᨲᩦᩁᨾᨸᨲ᩠ᨳᩥ, ᩈᨻ᩠ᨻᩈᨾᩣ ᩉᩥ ᩈᨾᨶ᩠ᨲᨠᨸᩃ᩠ᩃᩣ.

‘‘ᩋᩈᩥᨸᨲ᩠ᨲᩅᨶᩴ ᨸᨶ ᨲᩥᨱ᩠ᩉᩴ, ᨲᩴ ᨸᩅᩥᩈᨶ᩠ᨲᩥ ᩈᨾᩩᨧ᩠ᨨᩥᨴᨣᨲ᩠ᨲᩣ;

ᨩᩥᩅ᩠ᩉᩴ ¶ ᨻᩃᩥᩈᩮᨶ ᨣᩉᩮᨲ᩠ᩅᩣ, ᩌᩁᨩᨿᩣᩁᨩᨿᩣ ᩅᩥᩉᨶᨶ᩠ᨲᩥ.

‘‘ᩋᨳ ᩅᩮᨲᩁᨱᩥᩴ ᨸᨶ ᨴᩩᨣ᩠ᨣᩴ, ᨲᩥᨱ᩠ᩉᨵᩣᩁᨡᩩᩁᨵᩣᩁᨾᩩᨸᩮᨶ᩠ᨲᩥ;

ᨲᨲ᩠ᨳ ᨾᨶ᩠ᨴᩣ ᨸᨸᨲᨶ᩠ᨲᩥ, ᨸᩣᨸᨠᩁᩣ ᨸᩣᨸᩣᨶᩥ ᨠᩁᩥᨲ᩠ᩅᩣ.

‘‘ᨡᩣᨴᨶ᩠ᨲᩥ ¶ ᩉᩥ ᨲᨲ᩠ᨳ ᩁᩩᨴᨶ᩠ᨲᩮ, ᩈᩣᨾᩣ ᩈᨻᩃᩣ ᨠᩣᨠᩮᩣᩃᨣᨱᩣ ᨧ;

ᩈᩮᩣᨱᩣ ᩈᩥᨦ᩠ᨣᩣᩃᩣ [ᩈᩥᨣᩣᩃᩣ (ᩈᩦ. ᨸᩦ.)] ᨸᨭᩥᨣᩥᨴ᩠ᨵᩣ [ᨸᨭᩥᨣᩥᨩ᩠ᨫᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨠᩩᩃᩃᩣ ᩅᩣᨿᩈᩣ ᨧ [ᨠᩩᩃᩃᩣ ᨧ ᩅᩣᨿᩈᩣ (?)] ᩅᩥᨲᩩᨴᨶ᩠ᨲᩥ.

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

ᨲᩈ᩠ᨾᩣ ᩍᨵ ᨩᩦᩅᩥᨲᩈᩮᩈᩮ, ᨠᩥᨧ᩠ᨧᨠᩁᩮᩣ ᩈᩥᨿᩣ ᨶᩁᩮᩣ ᨶ ᨧᨸ᩠ᨸᨾᨩ᩠ᨩᩮ.

‘‘ᨲᩮ ¶ ᨣᨱᩥᨲᩣ ᩅᩥᨴᩪᩉᩥ ᨲᩥᩃᩅᩣᩉᩣ, ᨿᩮ ᨸᨴᩩᨾᩮ ᨶᩥᩁᨿᩮ ᩏᨸᨶᩦᨲᩣ;

ᨶᩉᩩᨲᩣᨶᩥ ᩉᩥ ᨠᩮᩣᨭᩥᨿᩮᩣ ᨸᨬ᩠ᨧ ᨽᩅᨶ᩠ᨲᩥ, ᨴ᩠ᩅᩣᨴᩈ ᨠᩮᩣᨭᩥᩈᨲᩣᨶᩥ ᨸᩩᨶᨬ᩠ᨬᩣ [ᨸᨶᨿ᩠ᨿᩮ (ᨠ.)].

‘‘ᨿᩣᩅ ¶ ᨴᩩᨡᩣ [ᨴᩩᨠ᩠ᨡᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨴᩩᨠ᩠ᨡ (ᨸᩦ. ᨠ.)] ᨶᩥᩁᨿᩣ ᩍᨵ ᩅᩩᨲ᩠ᨲᩣ, ᨲᨲ᩠ᨳᨸᩥ ᨲᩣᩅ ᨧᩥᩁᩴ ᩅᩈᩥᨲᨻ᩠ᨻᩴ;

ᨲᩈ᩠ᨾᩣ ¶ ᩈᩩᨧᩥᨸᩮᩈᩃᩈᩣᨵᩩᨣᩩᨱᩮᩈᩩ, ᩅᩣᨧᩴ ᨾᨶᩴ ᩈᨲᨲᩴ [ᨸᨠᨲᩴ (ᩈ᩠ᨿᩣ.)] ᨸᩁᩥᩁᨠ᩠ᨡᩮ’’ᨲᩥ.

ᨠᩮᩣᨠᩣᩃᩥᨠᩈᩩᨲ᩠ᨲᩴ ᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩌᨶᨶ᩠ᨴᨩᩣᨲᩮ ᨲᩥᨴᩈᨣᨱᩮ ᨸᨲᩦᨲᩮ, ᩈᨠ᩠ᨠᨬ᩠ᨧ ᩍᨶ᩠ᨴᩴ ᩈᩩᨧᩥᩅᩈᨶᩮ ᨧ ᨴᩮᩅᩮ;

ᨴᩩᩔᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᩋᨲᩥᩁᩥᩅ ᨳᩮᩣᨾᨿᨶ᩠ᨲᩮ, ᩋᩈᩥᨲᩮᩣ ᩍᩈᩥ ᩋᨴ᩠ᨴᩈ ᨴᩥᩅᩣᩅᩥᩉᩣᩁᩮ.

ᨴᩥᩈ᩠ᩅᩣᨶ ¶ ᨴᩮᩅᩮ ᨾᩩᨴᩥᨲᨾᨶᩮ ᩏᨴᨣ᩠ᨣᩮ, ᨧᩥᨲ᩠ᨲᩥᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ ᩍᨴᨾᩅᩮᩣᨧ [ᨠᩁᩥᨲ᩠ᩅᩣ ᩍᨴᨾᩅᩮᩣᨧᩣᩈᩥ (ᩈᩦ.)] ᨲᨲ᩠ᨳ;

‘‘ᨠᩥᩴ ᨴᩮᩅᩈᨦ᩠ᨥᩮᩣ ᩋᨲᩥᩁᩥᩅ ᨠᩃ᩠ᨿᩁᩪᨸᩮᩣ, ᨴᩩᩔᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᩁᨾᨿᨳ [ᨽᨾᨿᨳ (ᩈᩦ.)] ᨠᩥᩴ ᨸᨭᩥᨧ᩠ᨧ.

‘‘ᨿᨴᩣᨸᩥ ᩌᩈᩦ ᩋᩈᩩᩁᩮᩉᩥ ᩈᨦ᩠ᨣᨾᩮᩣ, ᨩᨿᩮᩣ ᩈᩩᩁᩣᨶᩴ ᩋᩈᩩᩁᩣ ᨸᩁᩣᨩᩥᨲᩣ.

ᨲᨴᩣᨸᩥ ᨶᩮᨲᩣᨴᩥᩈᩮᩣ ᩃᩮᩣᨾᩉᩴᩈᨶᩮᩣ, ᨠᩥᨾᨻ᩠ᨽᩩᨲᩴ ᨴᨭ᩠ᨮᩩ ᨾᩁᩪ ᨸᨾᩮᩣᨴᩥᨲᩣ.

‘‘ᩈᩮᩊᩮᨶ᩠ᨲᩥ ᨣᩣᨿᨶ᩠ᨲᩥ ᨧ ᩅᩣᨴᨿᨶ᩠ᨲᩥ ᨧ, ᨽᩩᨩᩣᨶᩥ ᨹᩮᩣᨭᩮᨶ᩠ᨲᩥ [ᨸᩮᩣᨮᩮᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.), ᨸᩮᩣᨳᩮᨶ᩠ᨲᩥ (ᨠ.)] ᨧ ᨶᨧ᩠ᨧᨿᨶ᩠ᨲᩥ ᨧ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ¶ ᩅᩮᩣᩉᩴ ᨾᩮᩁᩩᨾᩩᨴ᩠ᨵᩅᩣᩈᩥᨶᩮ, ᨵᩩᨶᩣᨳ ᨾᩮ ᩈᩴᩈᨿᩴ ᨡᩥᨸ᩠ᨸ ᨾᩣᩁᩥᩈᩣ’’.

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

ᩈᨠ᩠ᨿᩣᨶ ᨣᩣᨾᩮ ᨩᨶᨸᨴᩮ ᩃᩩᨾ᩠ᨻᩥᨶᩮᨿ᩠ᨿᩮ, ᨲᩮᨶᨾ᩠ᩉ ᨲᩩᨭ᩠ᨮᩣ ᩋᨲᩥᩁᩥᩅ ᨠᩃ᩠ᨿᩁᩪᨸᩣ.

‘‘ᩈᩮᩣ ᩈᨻ᩠ᨻᩈᨲ᩠ᨲᩩᨲ᩠ᨲᨾᩮᩣ ᩋᨣ᩠ᨣᨸᩩᨣ᩠ᨣᩃᩮᩣ, ᨶᩁᩣᩈᨽᩮᩣ ᩈᨻ᩠ᨻᨸᨩᩣᨶᨾᩩᨲ᩠ᨲᨾᩮᩣ;

ᩅᨲ᩠ᨲᩮᩔᨲᩥ ¶ ᨧᨠ᩠ᨠᨾᩥᩈᩥᩅ᩠ᩉᨿᩮ ᩅᨶᩮ, ᨶᨴᩴᩅ ᩈᩦᩉᩮᩣ ᨻᩃᩅᩣ ᨾᩥᨣᩣᨽᩥᨽᩪ’’.

ᨲᩴ ¶ ᩈᨴ᩠ᨴᩴ ᩈᩩᨲ᩠ᩅᩣ ᨲᩩᩁᩥᨲᨾᩅᩈᩁᩦ ᩈᩮᩣ, ᩈᩩᨴ᩠ᨵᩮᩣᨴᨶᩔ ᨲᨴ ᨽᩅᨶᩴ ᩏᨸᩣᩅᩥᩈᩥ [ᩏᨸᩣᨣᨾᩥ (ᩈᩦ. ᨸᩦ.)];

ᨶᩥᩈᨩ᩠ᨩ ᨲᨲ᩠ᨳ ᩍᨴᨾᩅᩮᩣᨧᩣᩈᩥ ᩈᨠ᩠ᨿᩮ, ‘‘ᨠᩩᩉᩥᩴ ᨠᩩᨾᩣᩁᩮᩣ ᩋᩉᨾᨸᩥ ᨴᨭ᩠ᨮᩩᨠᩣᨾᩮᩣ’’.

ᨲᨲᩮᩣ ᨠᩩᨾᩣᩁᩴ ᨩᩃᩥᨲᨾᩥᩅ ᩈᩩᩅᨱ᩠ᨱᩴ, ᩏᨠ᩠ᨠᩣᨾᩩᨡᩮᩅ ᩈᩩᨠᩩᩈᩃᩈᨾ᩠ᨸᩉᨭ᩠ᨮᩴ [ᩈᩩᨠᩩᩈᩃᩮᨶ ᩈᨾ᩠ᨸᩉᨭ᩠ᨮᩴ (ᨠ.)];

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

ᨴᩥᩈ᩠ᩅᩣ ᨠᩩᨾᩣᩁᩴ ᩈᩥᨡᩥᨾᩥᩅ ᨸᨩ᩠ᨩᩃᨶ᩠ᨲᩴ, ᨲᩣᩁᩣᩈᨽᩴᩅ ¶ ᨶᨽᩈᩥᨣᨾᩴ ᩅᩥᩈᩩᨴ᩠ᨵᩴ;

ᩈᩪᩁᩥᨿᩴ ᨲᨸᨶ᩠ᨲᩴ ᩈᩁᨴᩁᩥᩅᨻ᩠ᨽᨾᩩᨲ᩠ᨲᩴ, ᩌᨶᨶ᩠ᨴᨩᩣᨲᩮᩣ ᩅᩥᨸᩩᩃᨾᩃᨲ᩠ᨳ ᨸᩦᨲᩥᩴ.

ᩋᨶᩮᨠᩈᩣᨡᨬ᩠ᨧ ᩈᩉᩔᨾᨱ᩠ᨯᩃᩴ, ᨨᨲ᩠ᨲᩴ ᨾᩁᩪ ᨵᩣᩁᨿᩩᨾᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ;

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

ᨴᩥᩈ᩠ᩅᩣ ¶ ¶ ᨩᨭᩦ ᨠᨱ᩠ᩉᩈᩥᩁᩥᩅ᩠ᩉᨿᩮᩣ ᩍᩈᩥ, ᩈᩩᩅᨱ᩠ᨱᨶᩥᨠ᩠ᨡᩴ ᩅᩥᨿ ᨸᨱ᩠ᨯᩩᨠᨾ᩠ᨻᩃᩮ;

ᩈᩮᨲᨬ᩠ᨧ ᨨᨲ᩠ᨲᩴ ᨵᩁᩥᨿᨶ᩠ᨲ [ᨵᩣᩁᩥᨿᨶ᩠ᨲ (ᩈ᩠ᨿᩣ.), ᨵᩣᩁᨿᨶ᩠ᨲᩴ (ᩈᩦ. ᨠ.)] ᨾᩩᨴ᩠ᨵᨶᩥ, ᩏᨴᨣ᩠ᨣᨧᩥᨲ᩠ᨲᩮᩣ ᩈᩩᨾᨶᩮᩣ ᨸᨭᩥᨣ᩠ᨣᩉᩮ.

ᨸᨭᩥᨣ᩠ᨣᩉᩮᨲ᩠ᩅᩣ ᨸᨶ ᩈᨠ᩠ᨿᨸᩩᨦ᩠ᨣᩅᩴ, ᨩᩥᨣᩦᩈᨲᩮᩣ [ᨩᩥᨣᩥᩴᩈᨠᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩃᨠ᩠ᨡᨱᨾᨶ᩠ᨲᨸᩣᩁᨣᩪ;

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

ᩋᨳᨲ᩠ᨲᨶᩮᩣ ᨣᨾᨶᨾᨶᩩᩔᩁᨶ᩠ᨲᩮᩣ, ᩋᨠᩃ᩠ᨿᩁᩪᨸᩮᩣ ᨣᩊᨿᨲᩥ ᩋᩔᩩᨠᩣᨶᩥ;

ᨴᩥᩈ᩠ᩅᩣᨶ ᩈᨠ᩠ᨿᩣ ᩍᩈᩥᨾᩅᩮᩣᨧᩩᩴ ᩁᩩᨴᨶ᩠ᨲᩴ,

‘‘ᨶᩮᩣ ᨧᩮ ᨠᩩᨾᩣᩁᩮ ᨽᩅᩥᩔᨲᩥ ᩋᨶ᩠ᨲᩁᩣᨿᩮᩣ’’.

ᨴᩥᩈ᩠ᩅᩣᨶ ᩈᨠ᩠ᨿᩮ ᩍᩈᩥᨾᩅᩮᩣᨧ ᩋᨠᩃ᩠ᨿᩮ, ‘‘ᨶᩣᩉᩴ ¶ ᨠᩩᨾᩣᩁᩮ ᩋᩉᩥᨲᨾᨶᩩᩔᩁᩣᨾᩥ;

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

‘‘ᩈᨾ᩠ᨻᩮᩣᨵᩥᨿᨣ᩠ᨣᩴ ᨹᩩᩈᩥᩔᨲᩣᨿᩴ ᨠᩩᨾᩣᩁᩮᩣ, ᩈᩮᩣ ᨵᨾ᩠ᨾᨧᨠ᩠ᨠᩴ ᨸᩁᨾᩅᩥᩈᩩᨴ᩠ᨵᨴᩔᩦ;

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

‘‘ᨾᨾᨬ᩠ᨧ ¶ ᩌᨿᩩ ᨶ ᨧᩥᩁᨾᩥᨵᩣᩅᩈᩮᩈᩮᩣ, ᩋᨳᨶ᩠ᨲᩁᩣ ᨾᩮ ᨽᩅᩥᩔᨲᩥ ᨠᩣᩃᨠᩥᩁᩥᨿᩣ;

ᩈᩮᩣᩉᩴ ᨶ ᩈᩮᩣᩔᩴ [ᩈᩩᩔᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩋᩈᨾᨵᩩᩁᩔ ᨵᨾ᩠ᨾᩴ, ᨲᩮᨶᨾ᩠ᩉᩥ ᩋᨭ᩠ᨭᩮᩣ ᨻ᩠ᨿᩈᨶᩴᨣᨲᩮᩣ ᩋᨥᩣᩅᩦ’’.

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

ᩈᩮᩣ ᨽᩣᨣᩥᨶᩮᨿ᩠ᨿᩴ ᩈᨿᩴ ᩋᨶᩩᨠᨾ᩠ᨸᨾᩣᨶᩮᩣ, ᩈᨾᩣᨴᨸᩮᩈᩥ ᩋᩈᨾᨵᩩᩁᩔ ᨵᨾ᩠ᨾᩮ.

‘‘ᨻᩩᨴ᩠ᨵᩮᩣᨲᩥ ᨥᩮᩣᩈᩴ ᨿᨴ [ᨿᨴᩥ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨸᩁᨲᩮᩣ ᩈᩩᨱᩣᩈᩥ, ᩈᨾ᩠ᨻᩮᩣᨵᩥᨸᨲ᩠ᨲᩮᩣ ᩅᩥᩅᩁᨲᩥ ᨵᨾ᩠ᨾᨾᨣ᩠ᨣᩴ;

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

ᨲᩮᨶᩣᨶᩩᩈᩥᨭ᩠ᨮᩮᩣ ᩉᩥᨲᨾᨶᩮᨶ ᨲᩣᨴᩥᨶᩣ, ᩋᨶᩣᨣᨲᩮ ¶ ᨸᩁᨾᩅᩥᩈᩩᨴ᩠ᨵᨴᩔᩥᨶᩣ;

ᩈᩮᩣ ᨶᩣᩃᨠᩮᩣ ᩏᨸᨧᩥᨲᨸᩩᨬ᩠ᨬᩈᨬ᩠ᨧᨿᩮᩣ, ᨩᩥᨶᩴ ᨸᨲᩥᨠ᩠ᨡᩴ [ᨸᨲᩥ + ᩍᨠ᩠ᨡᩴ = ᨸᨲᩥᨠ᩠ᨡᩴ] ᨸᩁᩥᩅᩈᩥ ᩁᨠ᩠ᨡᩥᨲᩥᨶ᩠ᨴᩕᩥᨿᩮᩣ.

ᩈᩩᨲ᩠ᩅᩣᨶ ᨥᩮᩣᩈᩴ ᨩᩥᨶᩅᩁᨧᨠ᩠ᨠᩅᨲ᩠ᨲᨶᩮ, ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨴᩥᩈ᩠ᩅᩣ ᩍᩈᩥᨶᩥᩈᨽᩴ ᨸᩈᨶ᩠ᨶᩮᩣ;

ᨾᩮᩣᨶᩮᨿ᩠ᨿᩈᩮᨭ᩠ᨮᩴ ¶ ᨾᩩᨶᩥᨸᩅᩁᩴ ᩋᨸᩩᨧ᩠ᨨᩥ, ᩈᨾᩣᨣᨲᩮ ᩋᩈᩥᨲᩣᩅ᩠ᩉᨿᩔ ᩈᩣᩈᨶᩮᨲᩥ.

‘‘ᩋᨬ᩠ᨬᩣᨲᨾᩮᨲᩴ ᩅᨧᨶᩴ, ᩋᩈᩥᨲᩔ ᨿᨳᩣᨲᨳᩴ;

ᨲᩴ ᨲᩴ ᨣᩮᩣᨲᨾ ᨸᩩᨧ᩠ᨨᩣᨾᩥ, ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩣᨶ ᨸᩣᩁᨣᩩᩴ.

‘‘ᩋᨶᨣᩣᩁᩥᨿᩩᨸᩮᨲᩔ, ᨽᩥᨠ᩠ᨡᩣᨧᩁᩥᨿᩴ ᨩᩥᨣᩦᩈᨲᩮᩣ;

ᨾᩩᨶᩥ ᨸᨻᩕᩪᩉᩥ ᨾᩮ ᨸᩩᨭ᩠ᨮᩮᩣ, ᨾᩮᩣᨶᩮᨿ᩠ᨿᩴ ᩏᨲ᩠ᨲᨾᩴ ᨸᨴᩴ’’.

‘‘ᨾᩮᩣᨶᩮᨿ᩠ᨿᩴ ᨲᩮ ᩏᨸᨬ᩠ᨬᩥᩔᩴ, (ᩍᨲᩥ ᨽᨣᩅᩣ) ᨴᩩᨠ᩠ᨠᩁᩴ ᨴᩩᩁᨽᩥᩈᨾ᩠ᨽᩅᩴ;

ᩉᨶ᩠ᨴ ᨲᩮ ᨶᩴ ᨸᩅᨠ᩠ᨡᩣᨾᩥ, ᩈᨶ᩠ᨳᨾ᩠ᨽᩔᩩ ᨴᩊ᩠ᩉᩮᩣ ᨽᩅ.

‘‘ᩈᨾᩣᨶᨽᩣᨣᩴ ¶ ᨠᩩᨻ᩠ᨻᩮᨳ, ᨣᩣᨾᩮ ᩋᨠ᩠ᨠᩩᨭ᩠ᨮᩅᨶ᩠ᨴᩥᨲᩴ;

ᨾᨶᩮᩣᨸᨴᩮᩣᩈᩴ ᩁᨠ᩠ᨡᩮᨿ᩠ᨿ, ᩈᨶ᩠ᨲᩮᩣ ᩋᨶᩩᨱ᩠ᨱᨲᩮᩣ ᨧᩁᩮ.

‘‘ᩏᨧ᩠ᨧᩣᩅᨧᩣ ¶ ¶ ᨶᩥᨧ᩠ᨨᩁᨶ᩠ᨲᩥ, ᨴᩣᨿᩮ ᩋᨣ᩠ᨣᩥᩈᩥᨡᩪᨸᨾᩣ;

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

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

ᩋᩅᩥᩁᩩᨴ᩠ᨵᩮᩣ ¶ ᩋᩈᩣᩁᨲ᩠ᨲᩮᩣ, ᨸᩣᨱᩮᩈᩩ ᨲᩈᨳᩣᩅᩁᩮ.

‘‘ᨿᨳᩣ ᩋᩉᩴ ᨲᨳᩣ ᩑᨲᩮ, ᨿᨳᩣ ᩑᨲᩮ ᨲᨳᩣ ᩋᩉᩴ;

ᩋᨲ᩠ᨲᩣᨶᩴ ᩏᨸᨾᩴ ᨠᨲ᩠ᩅᩣ, ᨶ ᩉᨶᩮᨿ᩠ᨿ ᨶ ᨥᩣᨲᨿᩮ.

‘‘ᩉᩥᨲ᩠ᩅᩣ ᩍᨧ᩠ᨨᨬ᩠ᨧ ᩃᩮᩣᨽᨬ᩠ᨧ, ᨿᨲ᩠ᨳ ᩈᨲ᩠ᨲᩮᩣ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩮᩣ;

ᨧᨠ᩠ᨡᩩᨾᩣ ᨸᨭᩥᨸᨩ᩠ᨩᩮᨿ᩠ᨿ, ᨲᩁᩮᨿ᩠ᨿ ᨶᩁᨠᩴ ᩍᨾᩴ.

‘‘ᩐᨶᩪᨴᩁᩮᩣ ᨾᩥᨲᩣᩉᩣᩁᩮᩣ, ᩋᨸ᩠ᨸᩥᨧ᩠ᨨᩔ ᩋᩃᩮᩣᩃᩩᨸᩮᩣ;

ᩈᨴᩣ [ᩈ ᩅᩮ (ᨸᩦ.)] ᩍᨧ᩠ᨨᩣᨿ ᨶᩥᨧ᩠ᨨᩣᨲᩮᩣ, ᩋᨶᩥᨧ᩠ᨨᩮᩣ ᩉᩮᩣᨲᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ.

‘‘ᩈ ᨸᩥᨱ᩠ᨯᨧᩣᩁᩴ ᨧᩁᩥᨲ᩠ᩅᩣ, ᩅᨶᨶ᩠ᨲᨾᨽᩥᩉᩣᩁᨿᩮ;

ᩏᨸᨭ᩠ᨮᩥᨲᩮᩣ ᩁᩩᨠ᩠ᨡᨾᩪᩃᩈ᩠ᨾᩥᩴ, ᩌᩈᨶᩪᨸᨣᨲᩮᩣ ᨾᩩᨶᩥ.

‘‘ᩈ ᨫᩣᨶᨸᩈᩩᨲᩮᩣ ᨵᩦᩁᩮᩣ, ᩅᨶᨶ᩠ᨲᩮ ᩁᨾᩥᨲᩮᩣ ᩈᩥᨿᩣ;

ᨫᩣᨿᩮᨳ ᩁᩩᨠ᩠ᨡᨾᩪᩃᩈ᩠ᨾᩥᩴ, ᩋᨲ᩠ᨲᩣᨶᨾᨽᩥᨲᩮᩣᩈᨿᩴ.

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

ᩋᩅ᩠ᩉᩣᨶᩴ ᨶᩣᨽᩥᨶᨶ᩠ᨴᩮᨿ᩠ᨿ, ᩋᨽᩥᩉᩣᩁᨬ᩠ᨧ ᨣᩣᨾᨲᩮᩣ.

‘‘ᨶ ᨾᩩᨶᩦ ᨣᩣᨾᨾᩣᨣᨾ᩠ᨾ, ᨠᩩᩃᩮᩈᩩ ᩈᩉᩈᩣ ᨧᩁᩮ;

ᨥᩣᩈᩮᩈᨶᩴ ᨨᩥᨶ᩠ᨶᨠᨳᩮᩣ, ᨶ ᩅᩣᨧᩴ ᨸᨿᩩᨲᩴ ᨽᨱᩮ.

‘‘ᩋᩃᨲ᩠ᨳᩴ ᨿᨴᩥᨴᩴ ᩈᩣᨵᩩ, ᨶᩣᩃᨲ᩠ᨳᩴ ᨠᩩᩈᩃᩴ ᩍᨲᩥ;

ᩏᨽᨿᩮᨶᩮᩅ ᩈᩮᩣ ᨲᩣᨴᩦ, ᩁᩩᨠ᩠ᨡᩴᩅᩩᨸᨶᩥᩅᨲ᩠ᨲᨲᩥ [ᩁᩩᨠ᩠ᨡᩴᩅᩩ’ᨸᨲᩥᩅᨲ᩠ᨲᨲᩥ (ᨠ.), ᩁᩩᨠ᩠ᨡᩴᩅ ᩏᨸᩣᨲᩥᩅᨲ᩠ᨲᨲᩥ (ᩈ᩠ᨿᩣ.)].

‘‘ᩈ ¶ ¶ ᨸᨲ᩠ᨲᨸᩣᨱᩥ ᩅᩥᨧᩁᨶ᩠ᨲᩮᩣ, ᩋᨾᩪᨣᩮᩣ ᨾᩪᨣᩈᨾ᩠ᨾᨲᩮᩣ;

ᩋᨸ᩠ᨸᩴ ᨴᩣᨶᩴ ᨶ ᩉᩦᩊᩮᨿ᩠ᨿ, ᨴᩣᨲᩣᩁᩴ ᨶᩣᩅᨩᩣᨶᩥᨿᩣ.

‘‘ᩏᨧ᩠ᨧᩣᩅᨧᩣ ¶ ᩉᩥ ᨸᨭᩥᨸᨴᩣ, ᩈᨾᨱᩮᨶ ᨸᨠᩣᩈᩥᨲᩣ;

ᨶ ᨸᩣᩁᩴ ¶ ᨴᩥᨣᩩᨱᩴ ᨿᨶ᩠ᨲᩥ, ᨶᨿᩥᨴᩴ ᩑᨠᨣᩩᨱᩴ ᨾᩩᨲᩴ.

‘‘ᨿᩔ ᨧ ᩅᩥᩈᨲᩣ ᨶᨲ᩠ᨳᩥ, ᨨᩥᨶ᩠ᨶᩈᩮᩣᨲᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᨠᩥᨧ᩠ᨧᩣᨠᩥᨧ᩠ᨧᨸ᩠ᨸᩉᩦᨶᩔ, ᨸᩁᩥᩊᩣᩉᩮᩣ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ.

‘‘ᨾᩮᩣᨶᩮᨿ᩠ᨿᩴ ᨲᩮ ᩏᨸᨬ᩠ᨬᩥᩔᩴ, ᨡᩩᩁᨵᩣᩁᩪᨸᨾᩮᩣ ᨽᩅᩮ;

ᨩᩥᩅ᩠ᩉᩣᨿ ᨲᩣᩃᩩᨾᩣᩉᨧ᩠ᨧ, ᩏᨴᩁᩮ ᩈᨬ᩠ᨬᨲᩮᩣ ᩈᩥᨿᩣ.

‘‘ᩋᩃᩦᨶᨧᩥᨲ᩠ᨲᩮᩣ ᨧ ᩈᩥᨿᩣ, ᨶ ᨧᩣᨸᩥ ᨻᩉᩩ ᨧᩥᨶ᩠ᨲᨿᩮ;

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

‘‘ᩑᨠᩣᩈᨶᩔ ᩈᩥᨠ᩠ᨡᩮᨳ, ᩈᨾᨱᩪᨸᩣᩈᨶᩔ ᨧ;

ᩑᨠᨲ᩠ᨲᩴ ᨾᩮᩣᨶᨾᨠ᩠ᨡᩣᨲᩴ, ᩑᨠᩮᩣ ᨧᩮ ᩋᨽᩥᩁᨾᩥᩔᩈᩥ;

ᩋᨳ ᨽᩣᩉᩥᩈᩥ [ᨽᩣᩈᩥᩉᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨴᩈᨴᩥᩈᩣ.

‘‘ᩈᩩᨲ᩠ᩅᩣ ᨵᩦᩁᩣᨶᩴ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩴ, ᨫᩣᨿᩦᨶᩴ ᨠᩣᨾᨧᩣᨣᩥᨶᩴ;

ᨲᨲᩮᩣ ᩉᩥᩁᩥᨬ᩠ᨧ ᩈᨴ᩠ᨵᨬ᩠ᨧ, ᨽᩥᨿ᩠ᨿᩮᩣ ᨠᩩᨻ᩠ᨻᩮᨳ ᨾᩣᨾᨠᩮᩣ.

‘‘ᨲᩴ ¶ ᨶᨴᩦᩉᩥ ᩅᩥᨩᩣᨶᩣᨳ, ᩈᩮᩣᨻ᩠ᨽᩮᩈᩩ ᨸᨴᩁᩮᩈᩩ ᨧ;

ᩈᨱᨶ᩠ᨲᩣ ᨿᨶ᩠ᨲᩥ ᨠᩩᩈᩮᩣᨻ᩠ᨽᩣ [ᨠᩩᩔᩩᨻ᩠ᨽᩣ (ᩈᩦ.)], ᨲᩩᨱ᩠ᩉᩦᨿᨶ᩠ᨲᩥ ᨾᩉᩮᩣᨴᨵᩦ.

‘‘ᨿᨴᩪᨶᨠᩴ ᨲᩴ ᩈᨱᨲᩥ, ᨿᩴ ᨸᩪᩁᩴ ᩈᨶ᩠ᨲᨾᩮᩅ ᨲᩴ;

ᩋᨯ᩠ᨰᨠᩩᨾ᩠ᨽᩪᨸᨾᩮᩣ ᨻᩣᩃᩮᩣ, ᩁᩉᨴᩮᩣ ᨸᩪᩁᩮᩣᩅ ᨸᨱ᩠ᨯᩥᨲᩮᩣ.

‘‘ᨿᩴ ᩈᨾᨱᩮᩣ ᨻᩉᩩᩴ ᨽᩣᩈᨲᩥ, ᩏᨸᩮᨲᩴ ᩋᨲ᩠ᨳᩈᨬ᩠ᩉᩥᨲᩴ;

ᨩᩣᨶᩴ ᩈᩮᩣ ᨵᨾ᩠ᨾᩴ ᨴᩮᩈᩮᨲᩥ, ᨩᩣᨶᩴ ᩈᩮᩣ ᨻᩉᩩ ᨽᩣᩈᨲᩥ.

‘‘ᨿᩮᩣ ¶ ᨧ ᨩᩣᨶᩴ ᩈᩴᨿᨲᨲ᩠ᨲᩮᩣ, ᨩᩣᨶᩴ ᨶ ᨻᩉᩩ ᨽᩣᩈᨲᩥ;

ᩈ ¶ ᨾᩩᨶᩦ ᨾᩮᩣᨶᨾᩁᩉᨲᩥ, ᩈ ᨾᩩᨶᩦ ᨾᩮᩣᨶᨾᨩ᩠ᨫᨣᩣ’’ᨲᩥ.

ᩑᩅᩴ ᨾᩮ ᩈᩩᨲᩴ – ᩑᨠᩴ ᩈᨾᨿᩴ ᨽᨣᩅᩣ ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᩅᩥᩉᩁᨲᩥ ᨸᩩᨻ᩠ᨻᩣᩁᩣᨾᩮ ᨾᩥᨣᩣᩁᨾᩣᨲᩩᨸᩣᩈᩣᨴᩮ. ᨲᩮᨶ ᨡᩮᩣ ᨸᨶ ᩈᨾᨿᩮᨶ ᨽᨣᩅᩣ ᨲᨴᩉᩩᨸᩮᩣᩈᨳᩮ ᨸᨶ᩠ᨶᩁᩈᩮ ¶ ᨸᩩᨱ᩠ᨱᩣᨿ ᨸᩩᨱ᩠ᨱᨾᩣᨿ ᩁᨲ᩠ᨲᩥᨿᩣ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᨸᩁᩥᩅᩩᨲᩮᩣ ᩋᨻ᩠ᨽᩮᩣᨠᩣᩈᩮ ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᩉᩮᩣᨲᩥ ¶ . ᩋᨳ ᨡᩮᩣ ᨽᨣᩅᩣ ᨲᩩᨱ᩠ᩉᩦᨽᩪᨲᩴ ᨲᩩᨱ᩠ᩉᩦᨽᩪᨲᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩴ ᩋᨶᩩᩅᩥᩃᩮᩣᨠᩮᨲ᩠ᩅᩣ ᨽᩥᨠ᩠ᨡᩪ ᩌᨾᨶ᩠ᨲᩮᩈᩥ –

‘‘‘ᨿᩮ ᨲᩮ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨠᩩᩈᩃᩣ ᨵᨾ᩠ᨾᩣ ᩋᩁᩥᨿᩣ ᨶᩥᨿ᩠ᨿᩣᨶᩥᨠᩣ ᩈᨾ᩠ᨻᩮᩣᨵᨣᩣᨾᩥᨶᩮᩣ, ᨲᩮᩈᩴ ᩅᩮᩣ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨠᩩᩈᩃᩣᨶᩴ ᨵᨾ᩠ᨾᩣᨶᩴ ᩋᩁᩥᨿᩣᨶᩴ ᨶᩥᨿ᩠ᨿᩣᨶᩥᨠᩣᨶᩴ ᩈᨾ᩠ᨻᩮᩣᨵᨣᩣᨾᩦᨶᩴ ᨠᩣ ᩏᨸᨶᩥᩈᩣ ᩈᩅᨶᩣᨿᩣ’ᨲᩥ ᩍᨲᩥ ᨧᩮ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨸᩩᨧ᩠ᨨᩥᨲᩣᩁᩮᩣ ᩋᩔᩩ, ᨲᩮ ᩑᩅᨾᩔᩩ ᩅᨧᨶᩦᨿᩣ – ‘ᨿᩣᩅᨴᩮᩅ ᨴ᩠ᩅᨿᨲᩣᨶᩴ ᨵᨾ᩠ᨾᩣᨶᩴ ᨿᨳᩣᨽᩪᨲᩴ ᨬᩣᨱᩣᨿᩣ’ᨲᩥ. ᨠᩥᨬ᩠ᨧ ᨴ᩠ᩅᨿᨲᩴ ᩅᨴᩮᨳ?

(᪑) ‘‘ᩍᨴᩴ ᨴᩩᨠ᩠ᨡᩴ, ᩋᨿᩴ ᨴᩩᨠ᩠ᨡᩈᨾᩩᨴᨿᩮᩣᨲᩥ ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩋᨿᩴ ᨴᩩᨠ᩠ᨡᨶᩥᩁᩮᩣᨵᩮᩣ, ᩋᨿᩴ ᨴᩩᨠ᩠ᨡᨶᩥᩁᩮᩣᨵᨣᩣᨾᩥᨶᩦ ᨸᨭᩥᨸᨴᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ ᨴ᩠ᩅᨿᨲᩣᨶᩩᨸᩔᩥᨶᩮᩣ ᨡᩮᩣ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩔ ᩌᨲᩣᨸᩥᨶᩮᩣ ᨸᩉᩥᨲᨲ᩠ᨲᩔ ᩅᩥᩉᩁᨲᩮᩣ ᨴ᩠ᩅᩥᨶ᩠ᨶᩴ ᨹᩃᩣᨶᩴ ᩋᨬ᩠ᨬᨲᩁᩴ ᨹᩃᩴ ᨸᩣᨭᩥᨠᨦ᩠ᨡᩴ – ᨴᩥᨭ᩠ᨮᩮᩅ ᨵᨾ᩠ᨾᩮ ᩋᨬ᩠ᨬᩣ, ᩈᨲᩥ ᩅᩣ ¶ ᩏᨸᩣᨴᩥᩈᩮᩈᩮ ᩋᨶᩣᨣᩣᨾᩥᨲᩣ’’ᨲᩥ.

ᩍᨴᨾᩅᩮᩣᨧ ᨽᨣᩅᩣ. ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᩈᩩᨣᨲᩮᩣ ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨿᩮ ᨴᩩᨠ᩠ᨡᩴ ᨶᨸ᩠ᨸᨩᩣᨶᨶ᩠ᨲᩥ, ᩋᨳᩮᩣ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩴ;

ᨿᨲ᩠ᨳ ᨧ ᩈᨻ᩠ᨻᩈᩮᩣ ᨴᩩᨠ᩠ᨡᩴ, ᩋᩈᩮᩈᩴ ᩏᨸᩁᩩᨩ᩠ᨫᨲᩥ;

ᨲᨬ᩠ᨧ ᨾᨣ᩠ᨣᩴ ᨶ ᨩᩣᨶᨶ᩠ᨲᩥ, ᨴᩩᨠ᩠ᨡᩪᨸᩈᨾᨣᩣᨾᩥᨶᩴ.

‘‘ᨧᩮᨲᩮᩣᩅᩥᨾᩩᨲ᩠ᨲᩥᩉᩦᨶᩣ ᨲᩮ, ᩋᨳᩮᩣ ᨸᨬ᩠ᨬᩣᩅᩥᨾᩩᨲ᩠ᨲᩥᨿᩣ;

ᩋᨽᨻ᩠ᨻᩣ ᨲᩮ ᩋᨶ᩠ᨲᨠᩥᩁᩥᨿᩣᨿ, ᨲᩮ ᩅᩮ ᨩᩣᨲᩥᨩᩁᩪᨸᨣᩣ.

‘‘ᨿᩮ ¶ ᨧ ᨴᩩᨠ᩠ᨡᩴ ᨸᨩᩣᨶᨶ᩠ᨲᩥ, ᩋᨳᩮᩣ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩴ;

ᨿᨲ᩠ᨳ ᨧ ᩈᨻ᩠ᨻᩈᩮᩣ ᨴᩩᨠ᩠ᨡᩴ, ᩋᩈᩮᩈᩴ ᩏᨸᩁᩩᨩ᩠ᨫᨲᩥ;

ᨲᨬ᩠ᨧ ¶ ᨾᨣ᩠ᨣᩴ ᨸᨩᩣᨶᨶ᩠ᨲᩥ, ᨴᩩᨠ᩠ᨡᩪᨸᩈᨾᨣᩣᨾᩥᨶᩴ.

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

ᨽᨻ᩠ᨻᩣ ᨲᩮ ᩋᨶ᩠ᨲᨠᩥᩁᩥᨿᩣᨿ, ᨶ ᨲᩮ ᨩᩣᨲᩥᨩᩁᩪᨸᨣᩣ’’ᨲᩥ.

(᪒) ‘‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ ᨸᩁᩥᨿᩣᨿᩮᨶ ᩈᨾ᩠ᨾᩣ ᨴ᩠ᩅᨿᨲᩣᨶᩩᨸᩔᨶᩣ’ᨲᩥ, ᩍᨲᩥ ᨧᩮ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨸᩩᨧ᩠ᨨᩥᨲᩣᩁᩮᩣ ᩋᩔᩩ; ‘ᩈᩥᨿᩣ’ᨲᩥᩔᩩ ᩅᨧᨶᩦᨿᩣ. ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩏᨸᨵᩥᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩏᨸᨵᩦᨶᩴ ¶ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᩏᨸᨵᩥᨶᩥᨴᩣᨶᩣ ᨸᨽᩅᨶ᩠ᨲᩥ ᨴᩩᨠ᩠ᨡᩣ, ᨿᩮ ¶ ᨠᩮᨧᩥ ᩃᩮᩣᨠᩈ᩠ᨾᩥᨾᨶᩮᨠᩁᩪᨸᩣ;

ᨿᩮᩣ ᩅᩮ ᩋᩅᩥᨴ᩠ᩅᩣ ᩏᨸᨵᩥᩴ ᨠᩁᩮᩣᨲᩥ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ ᨴᩩᨠ᩠ᨡᨾᩩᨸᩮᨲᩥ ᨾᨶ᩠ᨴᩮᩣ;

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

(᪓) ‘‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ ᨸᩁᩥᨿᩣᨿᩮᨶ ᩈᨾ᩠ᨾᩣ ᨴ᩠ᩅᨿᨲᩣᨶᩩᨸᩔᨶᩣ’ᨲᩥ, ᩍᨲᩥ ᨧᩮ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨸᩩᨧ᩠ᨨᩥᨲᩣᩁᩮᩣ ᩋᩔᩩ; ‘ᩈᩥᨿᩣ’ᨲᩥᩔᩩ ᩅᨧᨶᩦᨿᩣ. ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩋᩅᩥᨩ᩠ᨩᩣᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩋᩅᩥᨩ᩠ᨩᩣᨿ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨩᩣᨲᩥᨾᩁᨱᩈᩴᩈᩣᩁᩴ ¶ , ᨿᩮ ᩅᨩᨶ᩠ᨲᩥ ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ;

ᩍᨲ᩠ᨳᨽᩣᩅᨬ᩠ᨬᨳᩣᨽᩣᩅᩴ, ᩋᩅᩥᨩ᩠ᨩᩣᨿᩮᩅ ᩈᩣ ᨣᨲᩥ.

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

ᩅᩥᨩ᩠ᨩᩣᨣᨲᩣ ᨧ ᨿᩮ ᩈᨲ᩠ᨲᩣ, ᨶ ᨲᩮ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ [ᨶᩣᨣᨧ᩠ᨨᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᨸᩩᨶᨻ᩠ᨽᩅ’’ᨶ᩠ᨲᩥ.

(᪔) ‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩈᨦ᩠ᨡᩣᩁᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩈᨦ᩠ᨡᩣᩁᩣᨶᩴ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨿᩴ ¶ ¶ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ, ᩈᨻ᩠ᨻᩴ ᩈᨦ᩠ᨡᩣᩁᨸᨧ᩠ᨧᨿᩣ;

ᩈᨦ᩠ᨡᩣᩁᩣᨶᩴ ᨶᩥᩁᩮᩣᨵᩮᨶ, ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣ.

‘‘ᩑᨲᨾᩣᨴᩦᨶᩅᩴ ᨬᨲ᩠ᩅᩣ, ᨴᩩᨠ᩠ᨡᩴ ᩈᨦ᩠ᨡᩣᩁᨸᨧ᩠ᨧᨿᩣ;

ᩈᨻ᩠ᨻᩈᨦ᩠ᨡᩣᩁᩈᨾᨳᩣ, ᩈᨬ᩠ᨬᩣᨶᩴ ᩏᨸᩁᩮᩣᨵᨶᩣ;

ᩑᩅᩴ ᨴᩩᨠ᩠ᨡᨠ᩠ᨡᨿᩮᩣ ᩉᩮᩣᨲᩥ, ᩑᨲᩴ ᨬᨲ᩠ᩅᩣ ᨿᨳᩣᨲᨳᩴ.

‘‘ᩈᨾ᩠ᨾᨴ᩠ᨴᩈᩣ ᩅᩮᨴᨣᩩᨶᩮᩣ, ᩈᨾ᩠ᨾᨴᨬ᩠ᨬᩣᨿ ᨸᨱ᩠ᨯᩥᨲᩣ;

ᩋᨽᩥᨽᩩᨿ᩠ᨿ ᨾᩣᩁᩈᩴᨿᩮᩣᨣᩴ, ᨶ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ [ᨶᩣᨣᨧ᩠ᨨᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᨸᩩᨶᨻ᩠ᨽᩅ’’ᨶ᩠ᨲᩥ.

(᪕) ‘‘ᩈᩥᨿᩣ ¶ ¶ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩅᩥᨬ᩠ᨬᩣᨱᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩅᩥᨬ᩠ᨬᩣᨱᩔ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

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

ᩅᩥᨬ᩠ᨬᩣᨱᩔ ᨶᩥᩁᩮᩣᨵᩮᨶ, ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣ.

‘‘ᩑᨲᨾᩣᨴᩦᨶᩅᩴ ᨬᨲ᩠ᩅᩣ, ᨴᩩᨠ᩠ᨡᩴ ᩅᩥᨬ᩠ᨬᩣᨱᨸᨧ᩠ᨧᨿᩣ;

ᩅᩥᨬ᩠ᨬᩣᨱᩪᨸᩈᨾᩣ ᨽᩥᨠ᩠ᨡᩩ, ᨶᩥᨧ᩠ᨨᩣᨲᩮᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ’’ᨲᩥ.

(᪖) ‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᨹᩔᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᨹᩔᩔ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ¶ ᩈᨲ᩠ᨳᩣ –

‘‘ᨲᩮᩈᩴ ᨹᩔᨸᩁᩮᨲᩣᨶᩴ, ᨽᩅᩈᩮᩣᨲᩣᨶᩩᩈᩣᩁᩥᨶᩴ;

ᨠᩩᨾ᩠ᨾᨣ᩠ᨣᨸᨭᩥᨸᨶ᩠ᨶᩣᨶᩴ, ᩌᩁᩣ ᩈᩴᨿᩮᩣᨩᨶᨠ᩠ᨡᨿᩮᩣ.

‘‘ᨿᩮ ᨧ ᨹᩔᩴ ᨸᩁᩥᨬ᩠ᨬᩣᨿ, ᩋᨬ᩠ᨬᩣᨿᩩᨸᩈᨾᩮ [ᨸᨬ᩠ᨬᩣᨿ ᩏᨸᩈᨾᩮ (ᩈ᩠ᨿᩣ.)] ᩁᨲᩣ;

ᨲᩮ ᩅᩮ ᨹᩔᩣᨽᩥᩈᨾᨿᩣ, ᨶᩥᨧ᩠ᨨᩣᨲᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

(᪗) ‘‘ᩈᩥᨿᩣ ¶ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩅᩮᨴᨶᩣᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩅᩮᨴᨶᩣᨶᩴ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᩈᩩᨡᩴ ¶ ᩅᩣ ᨿᨴᩥ ᩅᩣ ᨴᩩᨠ᩠ᨡᩴ, ᩋᨴᩩᨠ᩠ᨡᨾᩈᩩᨡᩴ ᩈᩉ;

ᩋᨩ᩠ᨫᨲ᩠ᨲᨬ᩠ᨧ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ, ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᩋᨲ᩠ᨳᩥ ᩅᩮᨴᩥᨲᩴ.

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

ᨹᩩᩔ ᨹᩩᩔ ᩅᨿᩴ ᨸᩔᩴ, ᩑᩅᩴ ᨲᨲ᩠ᨳ ᩅᩥᨩᩣᨶᨲᩥ [ᩅᩥᩁᨩ᩠ᨩᨲᩥ (ᨠ. ᩈᩦ.)];

ᩅᩮᨴᨶᩣᨶᩴ ᨡᨿᩣ ᨽᩥᨠ᩠ᨡᩩ, ᨶᩥᨧ᩠ᨨᩣᨲᩮᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ’’ᨲᩥ.

(᪘) ‘‘ᩈᩥᨿᩣ ¶ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᨲᨱ᩠ᩉᩣᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᨲᨱ᩠ᩉᩣᨿ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨲᨱ᩠ᩉᩣᨴᩩᨲᩥᨿᩮᩣ ¶ ᨸᩩᩁᩥᩈᩮᩣ, ᨴᩦᨥᨾᨴ᩠ᨵᩣᨶ ᩈᩴᩈᩁᩴ;

ᩍᨲ᩠ᨳᨽᩣᩅᨬ᩠ᨬᨳᩣᨽᩣᩅᩴ, ᩈᩴᩈᩣᩁᩴ ᨶᩣᨲᩥᩅᨲ᩠ᨲᨲᩥ.

‘‘ᩑᨲᨾᩣᨴᩦᨶᩅᩴ ᨬᨲ᩠ᩅᩣ, ᨲᨱ᩠ᩉᩴ [ᨲᨱ᩠ᩉᩣ (ᨻᩉᩪᩈᩩ) ᩍᨲᩥᩅᩩᨲ᩠ᨲᨠᩮ ᪑᪕ ᨸᩔᩥᨲᨻ᩠ᨻᩴ] ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩴ;

ᩅᩦᨲᨲᨱ᩠ᩉᩮᩣ ᩋᨶᩣᨴᩣᨶᩮᩣ, ᩈᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨸᩁᩥᨻ᩠ᨻᨩᩮ’’ᨲᩥ.

(᪙) ‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩏᨸᩣᨴᩣᨶᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩏᨸᩣᨴᩣᨶᩣᨶᩴ [ᩏᨸᩣᨴᩣᨶᩔ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᩏᨸᩣᨴᩣᨶᨸᨧ᩠ᨧᨿᩣ ᨽᩅᩮᩣ, ᨽᩪᨲᩮᩣ ᨴᩩᨠ᩠ᨡᩴ ᨶᩥᨣᨧ᩠ᨨᨲᩥ;

ᨩᩣᨲᩔ ᨾᩁᨱᩴ ᩉᩮᩣᨲᩥ, ᩑᩈᩮᩣ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣ.

‘‘ᨲᩈ᩠ᨾᩣ ᩏᨸᩣᨴᩣᨶᨠ᩠ᨡᨿᩣ, ᩈᨾ᩠ᨾᨴᨬ᩠ᨬᩣᨿ ᨸᨱ᩠ᨯᩥᨲᩣ;

ᨩᩣᨲᩥᨠ᩠ᨡᨿᩴ ᩋᨽᩥᨬ᩠ᨬᩣᨿ, ᨶ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ ᨸᩩᨶᨻ᩠ᨽᩅ’’ᨶ᩠ᨲᩥ.

(᪑᪐) ‘‘ᩈᩥᨿᩣ ¶ ¶ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩌᩁᨾ᩠ᨽᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩌᩁᨾ᩠ᨽᩣᨶᩴ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ, ᩈᨻ᩠ᨻᩴ ᩌᩁᨾ᩠ᨽᨸᨧ᩠ᨧᨿᩣ;

ᩌᩁᨾ᩠ᨽᩣᨶᩴ ᨶᩥᩁᩮᩣᨵᩮᨶ, ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣ.

‘‘ᩑᨲᨾᩣᨴᩦᨶᩅᩴ ¶ ᨬᨲ᩠ᩅᩣ, ᨴᩩᨠ᩠ᨡᩴ ᩌᩁᨾ᩠ᨽᨸᨧ᩠ᨧᨿᩣ;

ᩈᨻ᩠ᨻᩣᩁᨾ᩠ᨽᩴ ᨸᨭᩥᨶᩥᩔᨩ᩠ᨩ, ᩋᨶᩣᩁᨾ᩠ᨽᩮ ᩅᩥᨾᩩᨲ᩠ᨲᩥᨶᩮᩣ.

‘‘ᩏᨧ᩠ᨨᩥᨶ᩠ᨶᨽᩅᨲᨱ᩠ᩉᩔ, ᩈᨶ᩠ᨲᨧᩥᨲ᩠ᨲᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ;

ᩅᩥᨠ᩠ᨡᩦᨱᩮᩣ [ᩅᩥᨲᩥᨱ᩠ᨱᩮᩣ (ᩈᩦ.)] ᨩᩣᨲᩥᩈᩴᩈᩣᩁᩮᩣ, ᨶᨲ᩠ᨳᩥ ᨲᩔ ᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ’’ᨲᩥ.

(᪑᪑) ‘‘ᩈᩥᨿᩣ ¶ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩌᩉᩣᩁᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩌᩉᩣᩁᩣᨶᩴ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ, ᩈᨻ᩠ᨻᩴ ᩌᩉᩣᩁᨸᨧ᩠ᨧᨿᩣ;

ᩌᩉᩣᩁᩣᨶᩴ ᨶᩥᩁᩮᩣᨵᩮᨶ, ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣ.

‘‘ᩑᨲᨾᩣᨴᩦᨶᩅᩴ ᨬᨲ᩠ᩅᩣ, ᨴᩩᨠ᩠ᨡᩴ ᩌᩉᩣᩁᨸᨧ᩠ᨧᨿᩣ;

ᩈᨻ᩠ᨻᩣᩉᩣᩁᩴ ᨸᩁᩥᨬ᩠ᨬᩣᨿ, ᩈᨻ᩠ᨻᩣᩉᩣᩁᨾᨶᩥᩔᩥᨲᩮᩣ.

‘‘ᩌᩁᩮᩣᨣ᩠ᨿᩴ ¶ ᩈᨾ᩠ᨾᨴᨬ᩠ᨬᩣᨿ, ᩌᩈᩅᩣᨶᩴ ᨸᩁᩥᨠ᩠ᨡᨿᩣ;

ᩈᨦ᩠ᨡᩣᨿ ᩈᩮᩅᩦ ᨵᨾ᩠ᨾᨭ᩠ᨮᩮᩣ, ᩈᨦ᩠ᨡ᩠ᨿᩴ [ᩈᨦ᩠ᨡᩴ (ᩈᩦ. ᨸᩦ.)] ᨶᩮᩣᨸᩮᨲᩥ ᩅᩮᨴᨣᩪ’’ᨲᩥ.

(᪑᪒) ‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ ᩈᨻ᩠ᨻᩴ ᩍᨬ᩠ᨩᩥᨲᨸᨧ᩠ᨧᨿᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩍᨬ᩠ᨩᩥᨲᩣᨶᩴ ᨲ᩠ᩅᩮᩅ ᩋᩈᩮᩈᩅᩥᩁᩣᨣᨶᩥᩁᩮᩣᨵᩣ ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨿᩴ ¶ ¶ ᨠᩥᨬ᩠ᨧᩥ ᨴᩩᨠ᩠ᨡᩴ ᩈᨾ᩠ᨽᩮᩣᨲᩥ, ᩈᨻ᩠ᨻᩴ ᩍᨬ᩠ᨩᩥᨲᨸᨧ᩠ᨧᨿᩣ;

ᩍᨬ᩠ᨩᩥᨲᩣᨶᩴ ᨶᩥᩁᩮᩣᨵᩮᨶ, ᨶᨲ᩠ᨳᩥ ᨴᩩᨠ᩠ᨡᩔ ᩈᨾ᩠ᨽᩅᩮᩣ.

‘‘ᩑᨲᨾᩣᨴᩦᨶᩅᩴ ᨬᨲ᩠ᩅᩣ, ᨴᩩᨠ᩠ᨡᩴ ᩍᨬ᩠ᨩᩥᨲᨸᨧ᩠ᨧᨿᩣ;

ᨲᩈ᩠ᨾᩣ ᩉᩥ ᩑᨩᩴ ᩅᩮᩣᩔᨩ᩠ᨩ, ᩈᨦ᩠ᨡᩣᩁᩮ ᩏᨸᩁᩩᨶ᩠ᨵᩥᨿ;

ᩋᨶᩮᨩᩮᩣ ᩋᨶᩩᨸᩣᨴᩣᨶᩮᩣ, ᩈᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨸᩁᩥᨻ᩠ᨻᨩᩮ’’ᨲᩥ.

(᪑᪓) ‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨶᩥᩔᩥᨲᩔ ᨧᩃᩥᨲᩴ ᩉᩮᩣᨲᩦᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩋᨶᩥᩔᩥᨲᩮᩣ ᨶ ᨧᩃᨲᩦᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᩋᨶᩥᩔᩥᨲᩮᩣ ᨶ ᨧᩃᨲᩥ, ᨶᩥᩔᩥᨲᩮᩣ ᨧ ᩏᨸᩣᨴᩥᨿᩴ;

ᩍᨲ᩠ᨳᨽᩣᩅᨬ᩠ᨬᨳᩣᨽᩣᩅᩴ, ᩈᩴᩈᩣᩁᩴ ᨶᩣᨲᩥᩅᨲ᩠ᨲᨲᩥ.

‘‘ᩑᨲᨾᩣᨴᩦᨶᩅᩴ ᨬᨲ᩠ᩅᩣ, ᨶᩥᩔᨿᩮᩈᩩ ᨾᩉᨻ᩠ᨽᨿᩴ;

ᩋᨶᩥᩔᩥᨲᩮᩣ ᩋᨶᩩᨸᩣᨴᩣᨶᩮᩣ, ᩈᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨸᩁᩥᨻ᩠ᨻᨩᩮ’’ᨲᩥ.

(᪑᪔) ‘‘ᩈᩥᨿᩣ ¶ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᩁᩪᨸᩮᩉᩥ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᩋᩁᩪᨸᩣ [ᩌᩁᩩᨸ᩠ᨸᩣ (ᩈᩦ. ᨸᩦ.)] ᩈᨶ᩠ᨲᨲᩁᩣᨲᩥ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᩋᩁᩪᨸᩮᩉᩥ ¶ ᨶᩥᩁᩮᩣᨵᩮᩣ ᩈᨶ᩠ᨲᨲᩁᩮᩣᨲᩥ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᨿᩮ ᨧ ᩁᩪᨸᩪᨸᨣᩣ ᩈᨲ᩠ᨲᩣ, ᨿᩮ ᨧ ᩋᩁᩪᨸᨭ᩠ᨮᩣᨿᩥᨶᩮᩣ [ᩌᩁᩩᨸ᩠ᨸᩅᩣᩈᩥᨶᩮᩣ (ᩈᩦ. ᨸᩦ.)];

ᨶᩥᩁᩮᩣᨵᩴ ᩋᨸ᩠ᨸᨩᩣᨶᨶ᩠ᨲᩣ, ᩌᨣᨶ᩠ᨲᩣᩁᩮᩣ ᨸᩩᨶᨻ᩠ᨽᩅᩴ.

‘‘ᨿᩮ ᨧ ᩁᩪᨸᩮ ᨸᩁᩥᨬ᩠ᨬᩣᨿ, ᩋᩁᩪᨸᩮᩈᩩ ᩋᩈᨱ᩠ᨮᩥᨲᩣ [ᩈᩩᩈᨱ᩠ᨮᩥᨲᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᨶᩥᩁᩮᩣᨵᩮ ¶ ᨿᩮ ᩅᩥᨾᩩᨧ᩠ᨧᨶ᩠ᨲᩥ, ᨲᩮ ᨩᨶᩣ ᨾᨧ᩠ᨧᩩᩉᩣᨿᩥᨶᩮᩣ’’ᨲᩥ.

(᪑᪕) ‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ…ᨸᩮ… ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᩈᨴᩮᩅᨠᩔ ᩃᩮᩣᨠᩔ ᩈᨾᩣᩁᨠᩔ ᩈᨻᩕᩉ᩠ᨾᨠᩔ ᩈᩔᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩥᨿᩣ ᨸᨩᩣᨿ ᩈᨴᩮᩅᨾᨶᩩᩔᩣᨿ ᩍᨴᩴ ᩈᨧ᩠ᨧᨶ᩠ᨲᩥ ᩏᨸᨶᩥᨩ᩠ᨫᩣᨿᩥᨲᩴ ᨲᨴᨾᩁᩥᨿᩣᨶᩴ ᩑᨲᩴ ᨾᩩᩈᩣᨲᩥ ᨿᨳᩣᨽᩪᨲᩴ ᩈᨾ᩠ᨾᨸ᩠ᨸᨬ᩠ᨬᩣᨿ ᩈᩩᨴᩥᨭ᩠ᨮᩴ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ. ᨿᩴ ¶ , ᨽᩥᨠ᩠ᨡᩅᩮ, ᩈᨴᩮᩅᨠᩔ…ᨸᩮ… ᩈᨴᩮᩅᨾᨶᩩᩔᩣᨿ ᩍᨴᩴ ᨾᩩᩈᩣᨲᩥ ᩏᨸᨶᩥᨩ᩠ᨫᩣᨿᩥᨲᩴ, ᨲᨴᨾᩁᩥᨿᩣᨶᩴ ᩑᨲᩴ ᩈᨧ᩠ᨧᨶ᩠ᨲᩥ ᨿᨳᩣᨽᩪᨲᩴ ᩈᨾ᩠ᨾᨸ᩠ᨸᨬ᩠ᨬᩣᨿ ᩈᩩᨴᩥᨭ᩠ᨮᩴ, ᩋᨿᩴ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ…ᨸᩮ… ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

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

ᨶᩥᩅᩥᨭ᩠ᨮᩴ ᨶᩣᨾᩁᩪᨸᩈ᩠ᨾᩥᩴ, ᩍᨴᩴ ᩈᨧ᩠ᨧᨶ᩠ᨲᩥ ᨾᨬ᩠ᨬᨲᩥ.

‘‘ᨿᩮᨶ ᨿᩮᨶ ᩉᩥ ᨾᨬ᩠ᨬᨶ᩠ᨲᩥ, ᨲᨲᩮᩣ ᨲᩴ ᩉᩮᩣᨲᩥ ᩋᨬ᩠ᨬᨳᩣ;

ᨲᨬ᩠ᩉᩥ ᨲᩔ ᨾᩩᩈᩣ ᩉᩮᩣᨲᩥ, ᨾᩮᩣᩈᨵᨾ᩠ᨾᨬ᩠ᩉᩥ ᩍᨲ᩠ᨲᩁᩴ.

‘‘ᩋᨾᩮᩣᩈᨵᨾ᩠ᨾᩴ ¶ ᨶᩥᨻ᩠ᨻᩣᨶᩴ, ᨲᨴᩁᩥᨿᩣ ᩈᨧ᩠ᨧᨲᩮᩣ ᩅᩥᨴᩪ;

ᨲᩮ ᩅᩮ ᩈᨧ᩠ᨧᩣᨽᩥᩈᨾᨿᩣ, ᨶᩥᨧ᩠ᨨᩣᨲᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

(᪑᪖) ‘‘‘ᩈᩥᨿᩣ ᩋᨬ᩠ᨬᩮᨶᨸᩥ ᨸᩁᩥᨿᩣᨿᩮᨶ ᩈᨾ᩠ᨾᩣ ᨴ᩠ᩅᨿᨲᩣᨶᩩᨸᩔᨶᩣ’ᨲᩥ, ᩍᨲᩥ ᨧᩮ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨸᩩᨧ᩠ᨨᩥᨲᩣᩁᩮᩣ ᩋᩔᩩ; ‘ᩈᩥᨿᩣ’ᨲᩥᩔᩩ ᩅᨧᨶᩦᨿᩣ. ᨠᨳᨬ᩠ᨧ ᩈᩥᨿᩣ? ᨿᩴ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᩈᨴᩮᩅᨠᩔ ᩃᩮᩣᨠᩔ ᩈᨾᩣᩁᨠᩔ ᩈᨻᩕᩉ᩠ᨾᨠᩔ ᩈᩔᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩥᨿᩣ ᨸᨩᩣᨿ ᩈᨴᩮᩅᨾᨶᩩᩔᩣᨿ ᩍᨴᩴ ᩈᩩᨡᨶ᩠ᨲᩥ ᩏᨸᨶᩥᨩ᩠ᨫᩣᨿᩥᨲᩴ, ᨲᨴᨾᩁᩥᨿᩣᨶᩴ ᩑᨲᩴ ᨴᩩᨠ᩠ᨡᨶ᩠ᨲᩥ ᨿᨳᩣᨽᩪᨲᩴ ᩈᨾ᩠ᨾᨸ᩠ᨸᨬ᩠ᨬᩣᨿ ᩈᩩᨴᩥᨭ᩠ᨮᩴ, ᩋᨿᨾᩮᨠᩣᨶᩩᨸᩔᨶᩣ ¶ . ᨿᩴ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᩈᨴᩮᩅᨠᩔ…ᨸᩮ… ᩈᨴᩮᩅᨾᨶᩩᩔᩣᨿ ᩍᨴᩴ ᨴᩩᨠ᩠ᨡᨶ᩠ᨲᩥ ᩏᨸᨶᩥᨩ᩠ᨫᩣᨿᩥᨲᩴ ᨲᨴᨾᩁᩥᨿᩣᨶᩴ ᩑᨲᩴ ᩈᩩᨡᨶ᩠ᨲᩥ ᨿᨳᩣᨽᩪᨲᩴ ᩈᨾ᩠ᨾᨸ᩠ᨸᨬ᩠ᨬᩣᨿ ᩈᩩᨴᩥᨭ᩠ᨮᩴ, ᩋᨿᩴ ¶ ᨴᩩᨲᩥᨿᩣᨶᩩᨸᩔᨶᩣ. ᩑᩅᩴ ᩈᨾ᩠ᨾᩣ ᨴ᩠ᩅᨿᨲᩣᨶᩩᨸᩔᩥᨶᩮᩣ ᨡᩮᩣ, ᨽᩥᨠ᩠ᨡᩅᩮ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩔ ᩌᨲᩣᨸᩥᨶᩮᩣ ᨸᩉᩥᨲᨲ᩠ᨲᩔ ᩅᩥᩉᩁᨲᩮᩣ ᨴ᩠ᩅᩥᨶ᩠ᨶᩴ ᨹᩃᩣᨶᩴ ᩋᨬ᩠ᨬᨲᩁᩴ ᨹᩃᩴ ᨸᩣᨭᩥᨠᨦ᩠ᨡᩴ – ᨴᩥᨭ᩠ᨮᩮᩅ ᨵᨾ᩠ᨾᩮ ᩋᨬ᩠ᨬᩣ, ᩈᨲᩥ ᩅᩣ ᩏᨸᩣᨴᩥᩈᩮᩈᩮ ᩋᨶᩣᨣᩣᨾᩥᨲᩣᨲᩥ. ᩍᨴᨾᩅᩮᩣᨧ ᨽᨣᩅᩣ. ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᩈᩩᨣᨲᩮᩣ ᩋᨳᩣᨸᩁᩴ ᩑᨲᨴᩅᩮᩣᨧ ᩈᨲ᩠ᨳᩣ –

‘‘ᩁᩪᨸᩣ ᩈᨴ᩠ᨴᩣ ᩁᩈᩣ ᨣᨶ᩠ᨵᩣ, ᨹᩔᩣ ᨵᨾ᩠ᨾᩣ ᨧ ᨠᩮᩅᩃᩣ;

ᩍᨭ᩠ᨮᩣ ᨠᨶ᩠ᨲᩣ ᨾᨶᩣᨸᩣ ᨧ, ᨿᩣᩅᨲᨲ᩠ᨳᩦᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩥ.

‘‘ᩈᨴᩮᩅᨠᩔ ᩃᩮᩣᨠᩔ, ᩑᨲᩮ ᩅᩮᩣ ᩈᩩᨡᩈᨾ᩠ᨾᨲᩣ;

ᨿᨲ᩠ᨳ ᨧᩮᨲᩮ ᨶᩥᩁᩩᨩ᩠ᨫᨶ᩠ᨲᩥ, ᨲᩴ ᨶᩮᩈᩴ ᨴᩩᨠ᩠ᨡᩈᨾ᩠ᨾᨲᩴ.

‘‘ᩈᩩᨡᨶ᩠ᨲᩥ ¶ ᨴᩥᨭ᩠ᨮᨾᩁᩥᨿᩮᩉᩥ, ᩈᨠ᩠ᨠᩣᨿᩔᩩᨸᩁᩮᩣᨵᨶᩴ;

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

‘‘ᨿᩴ ¶ ᨸᩁᩮ ᩈᩩᨡᨲᩮᩣ ᩌᩉᩩ, ᨲᨴᩁᩥᨿᩣ ᩌᩉᩩ ᨴᩩᨠ᩠ᨡᨲᩮᩣ;

ᨿᩴ ᨸᩁᩮ ᨴᩩᨠ᩠ᨡᨲᩮᩣ ᩌᩉᩩ, ᨲᨴᩁᩥᨿᩣ ᩈᩩᨡᨲᩮᩣ ᩅᩥᨴᩪ.

‘‘ᨸᩔ ᨵᨾ᩠ᨾᩴ ᨴᩩᩁᩣᨩᩣᨶᩴ, ᩈᨾ᩠ᨸᨾᩪᩊ᩠ᩉᩮᨲ᩠ᨳᩅᩥᨴ᩠ᨴᩈᩩ [ᩈᨾ᩠ᨸᨾᩪᩊ᩠ᩉᩮᨲ᩠ᨳ ᩋᩅᩥᨴ᩠ᨴᩈᩩ (ᩈᩦ. ᨸᩦ.), ᩈᨾ᩠ᨾᩪᩊ᩠ᩉᩮᨲ᩠ᨳ ᩋᩅᩥᨴ᩠ᨴᩈᩩ (?)];

ᨶᩥᩅᩩᨲᩣᨶᩴ ᨲᨾᩮᩣ ᩉᩮᩣᨲᩥ, ᩋᨶ᩠ᨵᨠᩣᩁᩮᩣ ᩋᨸᩔᨲᩴ.

‘‘ᩈᨲᨬ᩠ᨧ ᩅᩥᩅᨭᩴ ᩉᩮᩣᨲᩥ, ᩌᩃᩮᩣᨠᩮᩣ ᨸᩔᨲᩣᨾᩥᩅ;

ᩈᨶ᩠ᨲᩥᨠᩮ ᨶ ᩅᩥᨩᩣᨶᨶ᩠ᨲᩥ, ᨾᨣ᩠ᨣᩣ ᨵᨾ᩠ᨾᩔ ᨠᩮᩣᩅᩥᨴᩣ.

‘‘ᨽᩅᩁᩣᨣᨸᩁᩮᨲᩮᩉᩥ ¶ , ᨽᩅᩈᩮᩣᨲᩣᨶᩩᩈᩣᩁᩥᨽᩥ;

ᨾᩣᩁᨵᩮᨿ᩠ᨿᩣᨶᩩᨸᨶ᩠ᨶᩮᩉᩥ, ᨶᩣᨿᩴ ᨵᨾ᩠ᨾᩮᩣ ᩈᩩᩈᨾ᩠ᨻᩩᨵᩮᩣ.

‘‘ᨠᩮᩣ ᨶᩩ ᩋᨬ᩠ᨬᨲᩕᨾᩁᩥᨿᩮᩉᩥ, ᨸᨴᩴ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩩᨾᩁᩉᨲᩥ;

ᨿᩴ ᨸᨴᩴ ᩈᨾ᩠ᨾᨴᨬ᩠ᨬᩣᨿ, ᨸᩁᩥᨶᩥᨻ᩠ᨻᨶ᩠ᨲᩥ ᩋᨶᩣᩈᩅᩣ’’ᨲᩥ.

ᩍᨴᨾᩅᩮᩣᨧ ᨽᨣᩅᩣ. ᩋᨲ᩠ᨲᨾᨶᩣ ᨲᩮ ᨽᩥᨠ᩠ᨡᩪ ᨽᨣᩅᨲᩮᩣ ᨽᩣᩈᩥᨲᩴ ᩋᨽᩥᨶᨶ᩠ᨴᩩᨶ᩠ᨲᩥ. ᩍᨾᩈ᩠ᨾᩥᩴ ᨧ [ᩍᨾᩈ᩠ᨾᩥᩴ ᨡᩮᩣ (ᩈᩦ.)] ᨸᨶ ᩅᩮᨿ᩠ᨿᩣᨠᩁᨱᩈ᩠ᨾᩥᩴ ᨽᨬ᩠ᨬᨾᩣᨶᩮ ᩈᨭ᩠ᨮᩥᨾᨲ᩠ᨲᩣᨶᩴ ᨽᩥᨠ᩠ᨡᩪᨶᩴ ᩋᨶᩩᨸᩣᨴᩣᨿ ᩌᩈᩅᩮᩉᩥ ᨧᩥᨲ᩠ᨲᩣᨶᩥ ᩅᩥᨾᩩᨧ᩠ᨧᩥᩴᩈᩪᨲᩥ.

ᨴ᩠ᩅᨿᨲᩣᨶᩩᨸᩔᨶᩣᩈᩩᨲ᩠ᨲᩴ ᨴ᩠ᩅᩣᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩈᨧ᩠ᨧᩴ ¶ ᩏᨸᨵᩥ ᩋᩅᩥᨩ᩠ᨩᩣ ᨧ, ᩈᨦ᩠ᨡᩣᩁᩮ ᩅᩥᨬ᩠ᨬᩣᨱᨸᨬ᩠ᨧᨾᩴ;

ᨹᩔᩅᩮᨴᨶᩥᨿᩣ ᨲᨱ᩠ᩉᩣ, ᩏᨸᩣᨴᩣᨶᩣᩁᨾ᩠ᨽᩌᩉᩣᩁᩣ;

ᩍᨬ᩠ᨩᩥᨲᩴ ᨧᩃᩥᨲᩴ ᩁᩪᨸᩴ, ᩈᨧ᩠ᨧᩴ ᨴᩩᨠ᩠ᨡᩮᨶ ᩈᩮᩣᩊᩈᩣᨲᩥ.

ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ ᨧ ᨸᨵᩣᨶᨬ᩠ᨧ, ᩈᩩᨽᩣᩈᩥᨲᨬ᩠ᨧ ᩈᩩᨶ᩠ᨴᩁᩥ;

ᨾᩣᨥᩈᩩᨲ᩠ᨲᩴ ᩈᨽᩥᨿᩮᩣ ᨧ, ᩈᩮᩃᩮᩣ ᩈᩃ᩠ᩃᨬ᩠ᨧ ᩅᩩᨧ᩠ᨧᨲᩥ.

ᩅᩣᩈᩮᨭ᩠ᨮᩮᩣ ᨧᩣᨸᩥ ᨠᩮᩣᨠᩣᩃᩥ, ᨶᩣᩃᨠᩮᩣ ᨴ᩠ᩅᨿᨲᩣᨶᩩᨸᩔᨶᩣ;

ᨴ᩠ᩅᩣᨴᩈᩮᨲᩣᨶᩥ ᩈᩩᨲ᩠ᨲᩣᨶᩥ, ᨾᩉᩣᩅᨣ᩠ᨣᩮᩣᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩦᨲᩥ.

ᨠᩣᨾᩴ ¶ ¶ ¶ ¶ ᨠᩣᨾᨿᨾᩣᨶᩔ, ᨲᩔ ᨧᩮ ᨲᩴ ᩈᨾᩥᨩ᩠ᨫᨲᩥ;

ᩋᨴ᩠ᨵᩣ ᨸᩦᨲᩥᨾᨶᩮᩣ ᩉᩮᩣᨲᩥ, ᩃᨴ᩠ᨵᩣ ᨾᨧ᩠ᨧᩮᩣ ᨿᨴᩥᨧ᩠ᨨᨲᩥ.

ᨲᩔ ᨧᩮ ᨠᩣᨾᨿᩣᨶᩔ [ᨠᩣᨾᨿᨾᩣᨶᩔ (ᨠ.)], ᨨᨶ᩠ᨴᨩᩣᨲᩔ ᨩᨶ᩠ᨲᩩᨶᩮᩣ;

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

ᨿᩮᩣ ᨠᩣᨾᩮ ᨸᩁᩥᩅᨩ᩠ᨩᩮᨲᩥ, ᩈᨸ᩠ᨸᩔᩮᩅ ᨸᨴᩣ ᩈᩥᩁᩮᩣ;

ᩈᩮᩣᨾᩴ [ᩈᩮᩣ ᩍᨾᩴ (ᩈᩦ. ᨸᩦ.)] ᩅᩥᩈᨲ᩠ᨲᩥᨠᩴ ᩃᩮᩣᨠᩮ, ᩈᨲᩮᩣ ᩈᨾᨲᩥᩅᨲ᩠ᨲᨲᩥ.

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

ᨳᩥᨿᩮᩣ ᨻᨶ᩠ᨵᩪ ᨸᩩᨳᩩ ᨠᩣᨾᩮ, ᨿᩮᩣ ᨶᩁᩮᩣ ᩋᨶᩩᨣᩥᨩ᩠ᨫᨲᩥ.

ᩋᨻᩃᩣ ᨶᩴ ᨻᩃᩦᨿᨶ᩠ᨲᩥ, ᨾᨴ᩠ᨴᨶ᩠ᨲᩮᨶᩴ ᨸᩁᩥᩔᨿᩣ;

ᨲᨲᩮᩣ ᨶᩴ ᨴᩩᨠ᩠ᨡᨾᨶ᩠ᩅᩮᨲᩥ, ᨶᩣᩅᩴ ᨽᩥᨶ᩠ᨶᨾᩥᩅᩮᩣᨴᨠᩴ.

ᨲᩈ᩠ᨾᩣ ᨩᨶ᩠ᨲᩩ ᩈᨴᩣ ᩈᨲᩮᩣ, ᨠᩣᨾᩣᨶᩥ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩮ;

ᨲᩮ ᨸᩉᩣᨿ ᨲᩁᩮ ᩒᨥᩴ, ᨶᩣᩅᩴ ᩈᩥᨲ᩠ᩅᩣᩅ [ᩈᩥᨬ᩠ᨧᩥᨲ᩠ᩅᩣ (ᩈᩦ.)] ᨸᩣᩁᨣᩪᨲᩥ.

ᩈᨲ᩠ᨲᩮᩣ ¶ ¶ ᨣᩩᩉᩣᨿᩴ ᨻᩉᩩᨶᩣᨽᩥᨨᨶ᩠ᨶᩮᩣ, ᨲᩥᨭ᩠ᨮᩴ ᨶᩁᩮᩣ ᨾᩮᩣᩉᨶᩈ᩠ᨾᩥᩴ ᨸᨣᩣᩊ᩠ᩉᩮᩣ;

ᨴᩪᩁᩮ ¶ ᩅᩥᩅᩮᨠᩣ ᩉᩥ ᨲᨳᩣᩅᩥᨵᩮᩣ ᩈᩮᩣ, ᨠᩣᨾᩣ ᩉᩥ ᩃᩮᩣᨠᩮ ᨶ ᩉᩥ ᩈᩩᨸ᩠ᨸᩉᩣᨿᩣ.

ᩍᨧ᩠ᨨᩣᨶᩥᨴᩣᨶᩣ ¶ ᨽᩅᩈᩣᨲᨻᨴ᩠ᨵᩣ, ᨲᩮ ᨴᩩᨸ᩠ᨸᨾᩩᨬ᩠ᨧᩣ ᨶ ᩉᩥ ᩋᨬ᩠ᨬᨾᩮᩣᨠ᩠ᨡᩣ;

ᨸᨧ᩠ᨨᩣ ᨸᩩᩁᩮ ᩅᩣᨸᩥ ᩋᨸᩮᨠ᩠ᨡᨾᩣᨶᩣ, ᩍᨾᩮᩅ ᨠᩣᨾᩮ ᨸᩩᩁᩥᨾᩮᩅ ᨩᨸ᩠ᨸᩴ.

ᨠᩣᨾᩮᩈᩩ ᨣᩥᨴ᩠ᨵᩣ ᨸᩈᩩᨲᩣ ᨸᨾᩪᩊ᩠ᩉᩣ, ᩋᩅᨴᩣᨶᩥᨿᩣ ᨲᩮ ᩅᩥᩈᨾᩮ ᨶᩥᩅᩥᨭ᩠ᨮᩣ;

ᨴᩩᨠ᩠ᨡᩪᨸᨶᩦᨲᩣ ᨸᩁᩥᨴᩮᩅᨿᨶ᩠ᨲᩥ, ᨠᩥᩴᩈᩪ ᨽᩅᩥᩔᩣᨾ ᩍᨲᩮᩣ ᨧᩩᨲᩣᩈᩮ.

ᨲᩈ᩠ᨾᩣ ᩉᩥ ᩈᩥᨠ᩠ᨡᩮᨳ ᩍᨵᩮᩅ ᨩᨶ᩠ᨲᩩ, ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨩᨬ᩠ᨬᩣ ᩅᩥᩈᨾᨶ᩠ᨲᩥ ᩃᩮᩣᨠᩮ;

ᨶ ᨲᩔ ᩉᩮᨲᩪ ᩅᩥᩈᨾᩴ ᨧᩁᩮᨿ᩠ᨿ, ᩋᨸ᩠ᨸᨬ᩠ᩉᩥᨴᩴ ᨩᩦᩅᩥᨲᨾᩣᩉᩩ ᨵᩦᩁᩣ.

ᨸᩔᩣᨾᩥ ᩃᩮᩣᨠᩮ ᨸᩁᩥᨹᨶ᩠ᨴᨾᩣᨶᩴ, ᨸᨩᩴ ᩍᨾᩴ ᨲᨱ᩠ᩉᨣᨲᩴ ᨽᩅᩮᩈᩩ;

ᩉᩦᨶᩣ ¶ ᨶᩁᩣ ᨾᨧ᩠ᨧᩩᨾᩩᨡᩮ ᩃᨸᨶ᩠ᨲᩥ, ᩋᩅᩦᨲᨲᨱ᩠ᩉᩣᩈᩮ ᨽᩅᩣᨽᩅᩮᩈᩩ.

ᨾᨾᩣᨿᩥᨲᩮ ᨸᩔᨳ ᨹᨶ᩠ᨴᨾᩣᨶᩮ, ᨾᨧ᩠ᨨᩮᩅ ᩋᨸ᩠ᨸᩮᩣᨴᨠᩮ ᨡᩦᨱᩈᩮᩣᨲᩮ;

ᩑᨲᨾ᩠ᨸᩥ ᨴᩥᩈ᩠ᩅᩣ ᩋᨾᨾᩮᩣ ᨧᩁᩮᨿ᩠ᨿ, ᨽᩅᩮᩈᩩ ᩌᩈᨲ᩠ᨲᩥᨾᨠᩩᨻ᩠ᨻᨾᩣᨶᩮᩣ.

ᩏᨽᩮᩣᩈᩩ ᩋᨶ᩠ᨲᩮᩈᩩ ᩅᩥᨶᩮᨿ᩠ᨿ ᨨᨶ᩠ᨴᩴ, ᨹᩔᩴ ᨸᩁᩥᨬ᩠ᨬᩣᨿ ᩋᨶᩣᨶᩩᨣᩥᨴ᩠ᨵᩮᩣ;

ᨿᨴᨲ᩠ᨲᨣᩁᩉᩦ ᨲᨴᨠᩩᨻ᩠ᨻᨾᩣᨶᩮᩣ, ᨶ ᩃᩥᨸ᩠ᨸᨲᩦ [ᨶ ᩃᩥᨾ᩠ᨸᨲᩦ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨴᩥᨭ᩠ᨮᩈᩩᨲᩮᩈᩩ ᨵᩦᩁᩮᩣ.

ᩈᨬ᩠ᨬᩴ ¶ ᨸᩁᩥᨬ᩠ᨬᩣ ᩅᩥᨲᩁᩮᨿ᩠ᨿ ᩒᨥᩴ, ᨸᩁᩥᨣ᩠ᨣᩉᩮᩈᩩ ᨾᩩᨶᩥ ᨶᩮᩣᨸᩃᩥᨲ᩠ᨲᩮᩣ;

ᩋᨻ᩠ᨻᩪᩊ᩠ᩉᩈᩃ᩠ᩃᩮᩣ ᨧᩁᨾᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ, ᨶᩣᩈᩦᩈᨲᩦ [ᨶᩣᩈᩥᩴᩈᨲᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩃᩮᩣᨠᨾᩥᨾᩴ ᨸᩁᨬ᩠ᨧᩣᨲᩥ.

ᨣᩩᩉᨭ᩠ᨮᨠᩈᩩᨲ᩠ᨲᩴ ᨴᩩᨲᩥᨿᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩅᨴᨶ᩠ᨲᩥ ¶ ¶ ¶ ᩅᩮ ᨴᩩᨭ᩠ᨮᨾᨶᩣᨸᩥ ᩑᨠᩮ, ᩋᨳᩮᩣᨸᩥ ᩅᩮ ᩈᨧ᩠ᨧᨾᨶᩣ ᩅᨴᨶ᩠ᨲᩥ;

ᩅᩣᨴᨬ᩠ᨧ ᨩᩣᨲᩴ ᨾᩩᨶᩥ ᨶᩮᩣ ᩏᨸᩮᨲᩥ, ᨲᩈ᩠ᨾᩣ ᨾᩩᨶᩦ ᨶᨲ᩠ᨳᩥ ᨡᩥᩃᩮᩣ ᨠᩩᩉᩥᨬ᩠ᨧᩥ.

ᩈᨠᨬ᩠ᩉᩥ ᨴᩥᨭ᩠ᨮᩥᩴ ᨠᨳᨾᨧ᩠ᨧᨿᩮᨿ᩠ᨿ, ᨨᨶ᩠ᨴᩣᨶᩩᨶᩦᨲᩮᩣ ᩁᩩᨧᩥᨿᩣ ᨶᩥᩅᩥᨭ᩠ᨮᩮᩣ;

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

ᨿᩮᩣ ᩋᨲ᩠ᨲᨶᩮᩣ ᩈᩦᩃᩅᨲᩣᨶᩥ ᨩᨶ᩠ᨲᩩ, ᩋᨶᩣᨶᩩᨸᩩᨭ᩠ᨮᩮᩣᩅ ᨸᩁᩮᩈ [ᨸᩁᩔ (ᨠ.)] ᨸᩣᩅ [ᨸᩣᩅᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᩋᨶᩁᩥᨿᨵᨾ᩠ᨾᩴ ᨠᩩᩈᩃᩣ ᨲᨾᩣᩉᩩ, ᨿᩮᩣ ᩌᨲᩩᨾᩣᨶᩴ ᩈᨿᨾᩮᩅ ᨸᩣᩅ.

ᩈᨶ᩠ᨲᩮᩣ ᨧ ᨽᩥᨠ᩠ᨡᩩ ᩋᨽᩥᨶᩥᨻ᩠ᨻᩩᨲᨲ᩠ᨲᩮᩣ, ᩍᨲᩥᩉᨶ᩠ᨲᩥ ᩈᩦᩃᩮᩈᩩ ᩋᨠᨲ᩠ᨳᨾᩣᨶᩮᩣ;

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

ᨸᨠᨸ᩠ᨸᩥᨲᩣ ¶ ᩈᨦ᩠ᨡᨲᩣ ᨿᩔ ᨵᨾ᩠ᨾᩣ, ᨸᩩᩁᨠ᩠ᨡᨲᩣ [ᨸᩩᩁᩮᨠ᩠ᨡᨲᩣ (ᩈᩦ.)] ᩈᨶ᩠ᨲᩥ ᩋᩅᩦᩅᨴᩣᨲᩣ;

ᨿᨴᨲ᩠ᨲᨶᩥ ¶ ᨸᩔᨲᩥ ᩌᨶᩥᩈᩴᩈᩴ, ᨲᩴ ᨶᩥᩔᩥᨲᩮᩣ ᨠᩩᨸ᩠ᨸᨸᨭᩥᨧ᩠ᨧ ᩈᨶ᩠ᨲᩥᩴ.

ᨴᩥᨭ᩠ᨮᩦᨶᩥᩅᩮᩈᩣ ᨶ ᩉᩥ ᩈ᩠ᩅᩣᨲᩥᩅᨲ᩠ᨲᩣ, ᨵᨾ᩠ᨾᩮᩈᩩ ᨶᩥᨧ᩠ᨨᩮᨿ᩠ᨿ ᩈᨾᩩᨣ᩠ᨣᩉᩦᨲᩴ;

ᨲᩈ᩠ᨾᩣ ᨶᩁᩮᩣ ᨲᩮᩈᩩ ᨶᩥᩅᩮᩈᨶᩮᩈᩩ, ᨶᩥᩁᩔᨲᩦ ᩌᨴᩥᨿᨲᩦ ᨧ ᨵᨾ᩠ᨾᩴ.

ᨵᩮᩣᨶᩔ ¶ ᩉᩥ ᨶᨲ᩠ᨳᩥ ᨠᩩᩉᩥᨬ᩠ᨧᩥ ᩃᩮᩣᨠᩮ, ᨸᨠᨸ᩠ᨸᩥᨲᩣ ᨴᩥᨭ᩠ᨮᩥ ᨽᩅᩣᨽᩅᩮᩈᩩ;

ᨾᩣᨿᨬ᩠ᨧ ᨾᩣᨶᨬ᩠ᨧ ᨸᩉᩣᨿ ᨵᩮᩣᨶᩮᩣ, ᩈ ᨠᩮᨶ ᨣᨧ᩠ᨨᩮᨿ᩠ᨿ ᩋᨶᩪᨸᨿᩮᩣ ᩈᩮᩣ.

ᩏᨸᨿᩮᩣ ᩉᩥ ᨵᨾ᩠ᨾᩮᩈᩩ ᩏᨸᩮᨲᩥ ᩅᩣᨴᩴ, ᩋᨶᩪᨸᨿᩴ ᨠᩮᨶ ᨠᨳᩴ ᩅᨴᩮᨿ᩠ᨿ;

ᩋᨲ᩠ᨲᩣ ᨶᩥᩁᨲ᩠ᨲᩣ [ᩋᨲ᩠ᨲᩴ ᨶᩥᩁᨲ᩠ᨲᩴ (ᨻᩉᩪᩈᩩ)] ᨶ ᩉᩥ ᨲᩔ ᩋᨲ᩠ᨳᩥ, ᩋᨵᩮᩣᩈᩥ ᩈᩮᩣ ᨴᩥᨭ᩠ᨮᩥᨾᩥᨵᩮᩅ ᩈᨻ᩠ᨻᨶ᩠ᨲᩥ.

ᨴᩩᨭ᩠ᨮᨭ᩠ᨮᨠᩈᩩᨲ᩠ᨲᩴ ᨲᨲᩥᨿᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨸᩔᩣᨾᩥ ¶ ᩈᩩᨴ᩠ᨵᩴ ᨸᩁᨾᩴ ᩋᩁᩮᩣᨣᩴ, ᨴᩥᨭ᩠ᨮᩮᨶ ᩈᩴᩈᩩᨴ᩠ᨵᩥ ᨶᩁᩔ ᩉᩮᩣᨲᩥ;

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

ᨴᩥᨭ᩠ᨮᩮᨶ ¶ ᨧᩮ ᩈᩩᨴ᩠ᨵᩥ ᨶᩁᩔ ᩉᩮᩣᨲᩥ, ᨬᩣᨱᩮᨶ ᩅᩣ ᩈᩮᩣ ᨸᨩᩉᩣᨲᩥ ᨴᩩᨠ᩠ᨡᩴ;

ᩋᨬ᩠ᨬᩮᨶ ᩈᩮᩣ ᩈᩩᨩ᩠ᨫᨲᩥ ᩈᩮᩣᨸᨵᩦᨠᩮᩣ, ᨴᩥᨭ᩠ᨮᩦ ᩉᩥ ᨶᩴ ᨸᩣᩅ ᨲᨳᩣ ᩅᨴᩣᨶᩴ.

ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩋᨬ᩠ᨬᨲᩮᩣ ᩈᩩᨴ᩠ᨵᩥᨾᩣᩉ, ᨴᩥᨭ᩠ᨮᩮ ᩈᩩᨲᩮ ᩈᩦᩃᩅᨲᩮ ᨾᩩᨲᩮ ᩅᩣ;

ᨸᩩᨬ᩠ᨬᩮ ᨧ ᨸᩣᨸᩮ ᨧ ᩋᨶᩪᨸᩃᩥᨲ᩠ᨲᩮᩣ, ᩋᨲ᩠ᨲᨬ᩠ᨩᩉᩮᩣ ᨶᨿᩥᨵ ᨸᨠᩩᨻ᩠ᨻᨾᩣᨶᩮᩣ.

ᨸᩩᩁᩥᨾᩴ ᨸᩉᩣᨿ ᩋᨸᩁᩴ ᩈᩥᨲᩣᩈᩮ, ᩑᨩᩣᨶᩩᨣᩣ ᨲᩮ ᨶ ᨲᩁᨶ᩠ᨲᩥ ᩈᨦ᩠ᨣᩴ;

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

ᩈᨿᩴ ¶ ᩈᨾᩣᨴᩣᨿ ᩅᨲᩣᨶᩥ ᨩᨶ᩠ᨲᩩ, ᩏᨧ᩠ᨧᩣᩅᨧᩴ ᨣᨧ᩠ᨨᨲᩥ ᩈᨬ᩠ᨬᩈᨲ᩠ᨲᩮᩣ;

ᩅᩥᨴ᩠ᩅᩣ ᨧ ᩅᩮᨴᩮᩉᩥ ᩈᨾᩮᨧ᩠ᨧ ᨵᨾ᩠ᨾᩴ, ᨶ ᩏᨧ᩠ᨧᩣᩅᨧᩴ ᨣᨧ᩠ᨨᨲᩥ ᨽᩪᩁᩥᨸᨬ᩠ᨬᩮᩣ.

ᩈ ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩮᩈᩩ ᩅᩥᩈᩮᨶᩥᨽᩪᨲᩮᩣ, ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩥᨭ᩠ᨮᩴ ᩅ ᩈᩩᨲᩴ ᨾᩩᨲᩴ ᩅᩣ;

ᨲᨾᩮᩅ ¶ ᨴᩔᩥᩴ ᩅᩥᩅᨭᩴ ᨧᩁᨶ᩠ᨲᩴ, ᨠᩮᨶᩦᨵ ᩃᩮᩣᨠᩈ᩠ᨾᩥ ᩅᩥᨠᨸ᩠ᨸᨿᩮᨿ᩠ᨿ.

ᨶ ᨠᨸ᩠ᨸᨿᨶ᩠ᨲᩥ ᨶ ᨸᩩᩁᩮᨠ᩠ᨡᩁᩮᩣᨶ᩠ᨲᩥ, ᩋᨧ᩠ᨧᨶ᩠ᨲᩈᩩᨴ᩠ᨵᩦᨲᩥ ᨶ ᨲᩮ ᩅᨴᨶ᩠ᨲᩥ;

ᩌᨴᩣᨶᨣᨶ᩠ᨳᩴ ¶ ᨣᨳᩥᨲᩴ ᩅᩥᩈᨩ᩠ᨩ, ᩌᩈᩴ ᨶ ᨠᩩᨻ᩠ᨻᨶ᩠ᨲᩥ ᨠᩩᩉᩥᨬ᩠ᨧᩥ ᩃᩮᩣᨠᩮ.

ᩈᩦᨾᩣᨲᩥᨣᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨲᩔ ᨶᨲ᩠ᨳᩥ, ᨬᨲ᩠ᩅᩣ ᩅ ᨴᩥᩈ᩠ᩅᩣ ᩅ [ᨬᨲ᩠ᩅᩣ ᨧ ᨴᩥᩈ᩠ᩅᩣ ᨧ (ᨠ. ᩈᩦ. ᨠ.)] ᩈᨾᩩᨣ᩠ᨣᩉᩦᨲᩴ;

ᨶ ᩁᩣᨣᩁᩣᨣᩦ ᨶ ᩅᩥᩁᩣᨣᩁᨲ᩠ᨲᩮᩣ, ᨲᩔᩦᨵ ᨶᨲ᩠ᨳᩦ ᨸᩁᨾᩩᨣ᩠ᨣᩉᩦᨲᨶ᩠ᨲᩥ.

ᩈᩩᨴ᩠ᨵᨭ᩠ᨮᨠᩈᩩᨲ᩠ᨲᩴ ᨧᨲᩩᨲ᩠ᨳᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨸᩁᨾᨶ᩠ᨲᩥ ¶ ᨴᩥᨭ᩠ᨮᩦᩈᩩ ᨸᩁᩥᨻ᩠ᨻᩈᩣᨶᩮᩣ, ᨿᨴᩩᨲ᩠ᨲᩁᩥ ᨠᩩᩁᩩᨲᩮ ᨩᨶ᩠ᨲᩩ ᩃᩮᩣᨠᩮ;

ᩉᩦᨶᩣᨲᩥ ᩋᨬ᩠ᨬᩮ ᨲᨲᩮᩣ ᩈᨻ᩠ᨻᨾᩣᩉ, ᨲᩈ᩠ᨾᩣ ᩅᩥᩅᩣᨴᩣᨶᩥ ᩋᩅᩦᨲᩥᩅᨲ᩠ᨲᩮᩣ.

ᨿᨴᨲ᩠ᨲᨶᩦ ᨸᩔᨲᩥ ᩌᨶᩥᩈᩴᩈᩴ, ᨴᩥᨭ᩠ᨮᩮ ¶ ᩈᩩᨲᩮ ᩈᩦᩃᩅᨲᩮ [ᩈᩦᩃᨻ᩠ᨻᨲᩮ (ᩈ᩠ᨿᩣ.)] ᨾᩩᨲᩮ ᩅᩣ;

ᨲᨴᩮᩅ ᩈᩮᩣ ᨲᨲ᩠ᨳ ᩈᨾᩩᨣ᩠ᨣᩉᩣᨿ, ᨶᩥᩉᩦᨶᨲᩮᩣ ᨸᩔᨲᩥ ᩈᨻ᩠ᨻᨾᨬ᩠ᨬᩴ.

ᨲᩴ ¶ ᩅᩣᨸᩥ ᨣᨶ᩠ᨳᩴ ᨠᩩᩈᩃᩣ ᩅᨴᨶ᩠ᨲᩥ, ᨿᩴ ᨶᩥᩔᩥᨲᩮᩣ ᨸᩔᨲᩥ ᩉᩦᨶᨾᨬ᩠ᨬᩴ;

ᨲᩈ᩠ᨾᩣ ᩉᩥ ᨴᩥᨭ᩠ᨮᩴ ᩅ ᩈᩩᨲᩴ ᨾᩩᨲᩴ ᩅᩣ, ᩈᩦᩃᨻ᩠ᨻᨲᩴ ᨽᩥᨠ᩠ᨡᩩ ᨶ ᨶᩥᩔᨿᩮᨿ᩠ᨿ.

ᨴᩥᨭ᩠ᨮᩥᨾ᩠ᨸᩥ ¶ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ ᨶ ᨠᨸ᩠ᨸᨿᩮᨿ᩠ᨿ, ᨬᩣᨱᩮᨶ ᩅᩣ ᩈᩦᩃᩅᨲᩮᨶ ᩅᩣᨸᩥ;

ᩈᨾᩮᩣᨲᩥ ᩋᨲ᩠ᨲᩣᨶᨾᨶᩪᨸᨶᩮᨿ᩠ᨿ, ᩉᩦᨶᩮᩣ ᨶ ᨾᨬ᩠ᨬᩮᨳ ᩅᩥᩈᩮᩈᩥ ᩅᩣᨸᩥ.

ᩋᨲ᩠ᨲᩴ ᨸᩉᩣᨿ ᩋᨶᩩᨸᩣᨴᩥᨿᩣᨶᩮᩣ, ᨬᩣᨱᩮᨸᩥ ᩈᩮᩣ ᨶᩥᩔᨿᩴ ᨶᩮᩣ ᨠᩁᩮᩣᨲᩥ;

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

ᨿᩔᩪᨽᨿᨶ᩠ᨲᩮ ᨸᨱᩥᨵᩦᨵ ᨶᨲ᩠ᨳᩥ, ᨽᩅᩣᨽᩅᩣᨿ ᩍᨵ ᩅᩣ ᩉᩩᩁᩴ ᩅᩣ;

ᨶᩥᩅᩮᩈᨶᩣ ᨲᩔ ᨶ ᩈᨶ᩠ᨲᩥ ᨠᩮᨧᩥ, ᨵᨾ᩠ᨾᩮᩈᩩ ᨶᩥᨧ᩠ᨨᩮᨿ᩠ᨿ ᩈᨾᩩᨣ᩠ᨣᩉᩦᨲᩴ.

ᨲᩔᩦᨵ ᨴᩥᨭ᩠ᨮᩮ ᩅ ᩈᩩᨲᩮ ᨾᩩᨲᩮ ᩅᩣ, ᨸᨠᨸ᩠ᨸᩥᨲᩣ ¶ ᨶᨲ᩠ᨳᩥ ᩋᨱᩪᨸᩥ ᩈᨬ᩠ᨬᩣ;

ᨲᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᨴᩥᨭ᩠ᨮᩥᨾᨶᩣᨴᩥᨿᩣᨶᩴ, ᨠᩮᨶᩦᨵ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ ᩅᩥᨠᨸ᩠ᨸᨿᩮᨿ᩠ᨿ.

ᨶ ᨠᨸ᩠ᨸᨿᨶ᩠ᨲᩥ ᨶ ᨸᩩᩁᩮᨠ᩠ᨡᩁᩮᩣᨶ᩠ᨲᩥ, ᨵᨾ᩠ᨾᩣᨸᩥ ᨲᩮᩈᩴ ᨶ ᨸᨭᩥᨧ᩠ᨨᩥᨲᩣᩈᩮ;

ᨶ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩈᩦᩃᩅᨲᩮᨶ ᨶᩮᨿ᩠ᨿᩮᩣ, ᨸᩣᩁᨦ᩠ᨣᨲᩮᩣ ᨶ ᨸᨧ᩠ᨧᩮᨲᩥ ᨲᩣᨴᩦᨲᩥ.

ᨸᩁᨾᨭ᩠ᨮᨠᩈᩩᨲ᩠ᨲᩴ ᨸᨬ᩠ᨧᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩋᨸ᩠ᨸᩴ ¶ ¶ ᩅᨲ ᨩᩦᩅᩥᨲᩴ ᩍᨴᩴ, ᩒᩁᩴ ᩅᩔᩈᨲᩣᨸᩥ ᨾᩥᨿ᩠ᨿᨲᩥ [ᨾᩦᨿᨲᩥ (ᩈᩦ. ᩋᨭ᩠ᨮ.)];

ᨿᩮᩣ ᨧᩮᨸᩥ ᩋᨲᩥᨧ᩠ᨧ ᨩᩦᩅᨲᩥ, ᩋᨳ ᨡᩮᩣ ᩈᩮᩣ ᨩᩁᩈᩣᨸᩥ ᨾᩥᨿ᩠ᨿᨲᩥ.

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

ᩅᩥᨶᩣᨽᩣᩅᩈᨶ᩠ᨲᨾᩮᩅᩥᨴᩴ, ᩍᨲᩥ ᨴᩥᩈ᩠ᩅᩣ ᨶᩣᨣᩣᩁᨾᩣᩅᩈᩮ.

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

ᩑᨲᨾ᩠ᨸᩥ ᩅᩥᨴᩥᨲ᩠ᩅᩣ [ᩑᨲᩴ ᨴᩥᩈ᩠ᩅᩣᨶ (ᨶᩥᨴ᩠ᨴᩮᩈᩮ), ᩑᨲᨾ᩠ᨸᩥ ᩅᩥᨴᩥᨲ᩠ᩅ (?)] ᨸᨱ᩠ᨯᩥᨲᩮᩣ, ᨶ ᨾᨾᨲ᩠ᨲᩣᨿ ᨶᨾᩮᨳ ᨾᩣᨾᨠᩮᩣ.

ᩈᩩᨸᩥᨶᩮᨶ ᨿᨳᩣᨸᩥ ᩈᨦ᩠ᨣᨲᩴ, ᨸᨭᩥᨻᩩᨴ᩠ᨵᩮᩣ ᨸᩩᩁᩥᩈᩮᩣ ᨶ ᨸᩔᨲᩥ;

ᩑᩅᨾ᩠ᨸᩥ ¶ ᨸᩥᨿᩣᨿᩥᨲᩴ ᨩᨶᩴ, ᨸᩮᨲᩴ ᨠᩣᩃᨠᨲᩴ ᨶ ᨸᩔᨲᩥ.

ᨴᩥᨭ᩠ᨮᩣᨸᩥ ¶ ᩈᩩᨲᩣᨸᩥ ᨲᩮ ᨩᨶᩣ, ᨿᩮᩈᩴ ᨶᩣᨾᨾᩥᨴᩴ ᨸᩅᩩᨧ᩠ᨧᨲᩥ [ᨶᩣᨾᨾᩮᩅᩣ ᩅᩈᩥᩔᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)];

ᨶᩣᨾᩴᨿᩮᩅᩣᩅᩈᩥᩔᨲᩥ, ᩋᨠ᩠ᨡᩮᨿ᩠ᨿᩴ ᨸᩮᨲᩔ ᨩᨶ᩠ᨲᩩᨶᩮᩣ.

ᩈᩮᩣᨠᨸ᩠ᨸᩁᩥᨴᩮᩅᨾᨧ᩠ᨨᩁᩴ [ᩈᩮᩣᨠᨸᩁᩥᨴᩮᩅᨾᨧ᩠ᨨᩁᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.), ᩈᩮᩣᨠᩴ ᨸᩁᩥᨴᩮᩅᨾᨧ᩠ᨨᩁᩴ (?)], ᨶ ᨩᩉᨶ᩠ᨲᩥ ᨣᩥᨴ᩠ᨵᩣ ᨾᨾᩣᨿᩥᨲᩮ;

ᨲᩈ᩠ᨾᩣ ᨾᩩᨶᨿᩮᩣ ᨸᩁᩥᨣ᩠ᨣᩉᩴ, ᩉᩥᨲ᩠ᩅᩣ ᩋᨧᩁᩥᩴᩈᩩ ᨡᩮᨾᨴᩔᩥᨶᩮᩣ.

ᨸᨲᩥᩃᩦᨶᨧᩁᩔ ¶ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ, ᨽᨩᨾᩣᨶᩔ ᩅᩥᩅᩥᨲ᩠ᨲᨾᩣᩈᨶᩴ;

ᩈᩣᨾᨣ᩠ᨣᩥᨿᨾᩣᩉᩩ ᨲᩔ ᨲᩴ, ᨿᩮᩣ ᩋᨲ᩠ᨲᩣᨶᩴ ᨽᩅᨶᩮ ᨶ ᨴᩔᨿᩮ.

ᩈᨻ᩠ᨻᨲ᩠ᨳ ᨾᩩᨶᩦ ᩋᨶᩥᩔᩥᨲᩮᩣ, ᨶ ᨸᩥᨿᩴ ᨠᩩᨻ᩠ᨻᨲᩥ ᨶᩮᩣᨸᩥ ᩋᨸ᩠ᨸᩥᨿᩴ;

ᨲᩈ᩠ᨾᩥᩴ ᨸᩁᩥᨴᩮᩅᨾᨧ᩠ᨨᩁᩴ, ᨸᨱ᩠ᨱᩮ ᩅᩣᩁᩥ ᨿᨳᩣ ᨶ ᩃᩥᨾ᩠ᨸᨲᩥ [ᩃᩥᨸ᩠ᨸᨲᩥ (ᩈᩦ. ᨸᩦ.)].

ᩏᨴᨻᩥᨶ᩠ᨴᩩ ᨿᨳᩣᨸᩥ ᨸᩮᩣᨠ᩠ᨡᩁᩮ, ᨸᨴᩩᨾᩮ ᩅᩣᩁᩥ ᨿᨳᩣ ᨶ ᩃᩥᨾ᩠ᨸᨲᩥ;

ᩑᩅᩴ ᨾᩩᨶᩥ ᨶᩮᩣᨸᩃᩥᨾ᩠ᨸᨲᩥ, ᨿᨴᩥᨴᩴ ᨴᩥᨭ᩠ᨮᩈᩩᨲᩴ ᨾᩩᨲᩮᩈᩩ ᩅᩣ.

ᨵᩮᩣᨶᩮᩣ ¶ ¶ ᨶ ᩉᩥ ᨲᩮᨶ ᨾᨬ᩠ᨬᨲᩥ, ᨿᨴᩥᨴᩴ ᨴᩥᨭ᩠ᨮᩈᩩᨲᩴ ᨾᩩᨲᩮᩈᩩ ᩅᩣ;

ᨶᩣᨬ᩠ᨬᩮᨶ ᩅᩥᩈᩩᨴ᩠ᨵᩥᨾᩥᨧ᩠ᨨᨲᩥ, ᨶ ᩉᩥ ᩈᩮᩣ ᩁᨩ᩠ᨩᨲᩥ ᨶᩮᩣ ᩅᩥᩁᨩ᩠ᨩᨲᩦᨲᩥ.

‘‘ᨾᩮᨳᩩᨶᨾᨶᩩᨿᩩᨲ᩠ᨲᩔ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨲᩥᩔᩮᩣ ᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᩮᩣ) ᩅᩥᨥᩣᨲᩴ ᨻᩕᩪᩉᩥ ᨾᩣᩁᩥᩈ;

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

‘‘ᨾᩮᨳᩩᨶᨾᨶᩩᨿᩩᨲ᩠ᨲᩔ, (ᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᩣᨲᩥ ᨽᨣᩅᩣ) ᨾᩩᩔᨲᩮ ᩅᩣᨸᩥ ᩈᩣᩈᨶᩴ;

ᨾᩥᨧ᩠ᨨᩣ ¶ ᨧ ᨸᨭᩥᨸᨩ᩠ᨩᨲᩥ, ᩑᨲᩴ ᨲᩈ᩠ᨾᩥᩴ ᩋᨶᩣᩁᩥᨿᩴ.

‘‘ᩑᨠᩮᩣ ¶ ᨸᩩᨻ᩠ᨻᩮ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᨾᩮᨳᩩᨶᩴ ᨿᩮᩣ ᨶᩥᩈᩮᩅᨲᩥ;

ᨿᩣᨶᩴ ᨽᨶ᩠ᨲᩴ ᩅ ᨲᩴ ᩃᩮᩣᨠᩮ, ᩉᩦᨶᨾᩣᩉᩩ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩴ.

‘‘ᨿᩈᩮᩣ ᨠᩥᨲ᩠ᨲᩥ ᨧ ᨿᩣ ᨸᩩᨻ᩠ᨻᩮ, ᩉᩣᨿᨲᩮ ᩅᩣᨸᩥ ᨲᩔ ᩈᩣ;

ᩑᨲᨾ᩠ᨸᩥ ᨴᩥᩈ᩠ᩅᩣ ᩈᩥᨠ᩠ᨡᩮᨳ, ᨾᩮᨳᩩᨶᩴ ᩅᩥᨸ᩠ᨸᩉᩣᨲᩅᩮ.

‘‘ᩈᨦ᩠ᨠᨸ᩠ᨸᩮᩉᩥ ᨸᩁᩮᨲᩮᩣ ᩈᩮᩣ, ᨠᨸᨱᩮᩣ ᩅᩥᨿ ᨫᩣᨿᨲᩥ;

ᩈᩩᨲ᩠ᩅᩣ ᨸᩁᩮᩈᩴ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩴ, ᨾᨦ᩠ᨠᩩ ᩉᩮᩣᨲᩥ ᨲᨳᩣᩅᩥᨵᩮᩣ.

‘‘ᩋᨳ ᩈᨲ᩠ᨳᩣᨶᩥ ᨠᩩᩁᩩᨲᩮ, ᨸᩁᩅᩣᨴᩮᩉᩥ ᨧᩮᩣᨴᩥᨲᩮᩣ;

ᩑᩈ ᨡ᩠ᩅᩔ ᨾᩉᩣᨣᩮᨵᩮᩣ, ᨾᩮᩣᩈᩅᨩ᩠ᨩᩴ ᨸᨣᩣᩉᨲᩥ.

‘‘ᨸᨱ᩠ᨯᩥᨲᩮᩣᨲᩥ ᩈᨾᨬ᩠ᨬᩣᨲᩮᩣ, ᩑᨠᨧᩁᩥᨿᩴ ᩋᨵᩥᨭ᩠ᨮᩥᨲᩮᩣ;

ᩋᨳᩣᨸᩥ [ᩈ ᨧᩣᨸᩥ (ᨶᩥᨴ᩠ᨴᩮᩈᩮ)] ᨾᩮᨳᩩᨶᩮ ᨿᩩᨲ᩠ᨲᩮᩣ, ᨾᨶ᩠ᨴᩮᩣᩅ ᨸᩁᩥᨠᩥᩔᨲᩥ [ᨸᩁᩥᨠᩥᩃᩥᩔᨲᩥ (ᩈᩦ.)].

‘‘ᩑᨲᨾᩣᨴᩦᨶᩅᩴ ¶ ¶ ᨬᨲ᩠ᩅᩣ, ᨾᩩᨶᩥ ᨸᩩᨻ᩠ᨻᩣᨸᩁᩮ ᩍᨵ;

ᩑᨠᨧᩁᩥᨿᩴ ᨴᩊ᩠ᩉᩴ ᨠᨿᩥᩁᩣ, ᨶ ᨶᩥᩈᩮᩅᩮᨳ ᨾᩮᨳᩩᨶᩴ.

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

ᨶ ᨲᩮᨶ ᩈᩮᨭ᩠ᨮᩮᩣ ᨾᨬ᩠ᨬᩮᨳ, ᩈ ᩅᩮ ᨶᩥᨻ᩠ᨻᩣᨶᩈᨶ᩠ᨲᩥᨠᩮ.

‘‘ᩁᩥᨲ᩠ᨲᩔ ᨾᩩᨶᩥᨶᩮᩣ ᨧᩁᨲᩮᩣ, ᨠᩣᨾᩮᩈᩩ ᩋᨶᨸᩮᨠ᩠ᨡᩥᨶᩮᩣ;

ᩒᨥᨲᩥᨱ᩠ᨱᩔ ᨸᩥᩉᨿᨶ᩠ᨲᩥ, ᨠᩣᨾᩮᩈᩩ ᨣᨵᩥᨲᩣ [ᨣᨳᩥᨲᩣ (ᩈᩦ.)] ᨸᨩᩣ’’ᨲᩥ.

ᨲᩥᩔᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᩈᩩᨲ᩠ᨲᩴ ᩈᨲ᩠ᨲᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᩍᨵᩮᩅ ¶ ᩈᩩᨴ᩠ᨵᩥ ᩍᨲᩥ ᩅᩣᨴᨿᨶ᩠ᨲᩥ [ᩅᩥᨴᩥᨿᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)], ᨶᩣᨬ᩠ᨬᩮᩈᩩ ᨵᨾ᩠ᨾᩮᩈᩩ ᩅᩥᩈᩩᨴ᩠ᨵᩥᨾᩣᩉᩩ;

ᨿᩴ ᨶᩥᩔᩥᨲᩣ ᨲᨲ᩠ᨳ ᩈᩩᨽᩴ ᩅᨴᩣᨶᩣ, ᨸᨧ᩠ᨧᩮᨠᩈᨧ᩠ᨧᩮᩈᩩ ᨸᩩᨳᩪ ᨶᩥᩅᩥᨭ᩠ᨮᩣ.

ᨲᩮ ¶ ᩅᩣᨴᨠᩣᨾᩣ ᨸᩁᩥᩈᩴ ᩅᩥᨣᨿ᩠ᩉ, ᨻᩣᩃᩴ ᨴᩉᨶ᩠ᨲᩦ ᨾᩥᨳᩩ ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩴ;

ᩅᨴᨶ᩠ᨲᩥ ᨲᩮ ᩋᨬ᩠ᨬᩈᩥᨲᩣ ᨠᨳᩮᩣᨩ᩠ᨩᩴ, ᨸᩈᩴᩈᨠᩣᨾᩣ ᨠᩩᩈᩃᩣ ᩅᨴᩣᨶᩣ.

ᨿᩩᨲ᩠ᨲᩮᩣ ᨠᨳᩣᨿᩴ ᨸᩁᩥᩈᩣᨿ ᨾᨩ᩠ᨫᩮ, ᨸᩈᩴᩈᨾᩥᨧ᩠ᨨᩴ ᩅᩥᨶᩥᨥᩣᨲᩥ ᩉᩮᩣᨲᩥ;

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

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

ᨸᩁᩥᨴᩮᩅᨲᩥ ᩈᩮᩣᨧᨲᩥ ᩉᩦᨶᩅᩣᨴᩮᩣ, ᩏᨸᨧ᩠ᨧᨣᩣ ᨾᨶ᩠ᨲᩥ ᩋᨶᩩᨲ᩠ᨳᩩᨶᩣᨲᩥ.

ᩑᨲᩮ ᩅᩥᩅᩣᨴᩣ ᩈᨾᨱᩮᩈᩩ ᨩᩣᨲᩣ, ᩑᨲᩮᩈᩩ ᩏᨣ᩠ᨥᩣᨲᩥ ᨶᩥᨥᩣᨲᩥ ᩉᩮᩣᨲᩥ;

ᩑᨲᨾ᩠ᨸᩥ ¶ ᨴᩥᩈ᩠ᩅᩣ ᩅᩥᩁᨾᩮ ᨠᨳᩮᩣᨩ᩠ᨩᩴ, ᨶ ᩉᨬ᩠ᨬᨴᨲ᩠ᨳᨲ᩠ᨳᩥᨸᩈᩴᩈᩃᩣᨽᩣ.

ᨸᩈᩴᩈᩥᨲᩮᩣ ¶ ᩅᩣ ᨸᨶ ᨲᨲ᩠ᨳ ᩉᩮᩣᨲᩥ, ᩋᨠ᩠ᨡᩣᨿ ᩅᩣᨴᩴ ᨸᩁᩥᩈᩣᨿ ᨾᨩ᩠ᨫᩮ;

ᩈᩮᩣ ᩉᩔᨲᩦ ᩏᨱ᩠ᨱᨾᨲᩦ [ᩏᨶ᩠ᨶᨾᨲᩦ (?)] ᨧ ᨲᩮᨶ, ᨸᨸ᩠ᨸᩩᨿ᩠ᨿ ᨲᨾᨲ᩠ᨳᩴ ᨿᨳᩣ ᨾᨶᩮᩣ ᩋᩉᩩ.

ᨿᩣ ᩏᨱ᩠ᨱᨲᩦ [ᩏᨶ᩠ᨶᨲᩦ (?)] ᩈᩣᩔ ᩅᩥᨥᩣᨲᨽᩪᨾᩥ, ᨾᩣᨶᩣᨲᩥᨾᩣᨶᩴ ᩅᨴᨲᩮ ᨸᨶᩮᩈᩮᩣ;

ᩑᨲᨾ᩠ᨸᩥ ᨴᩥᩈ᩠ᩅᩣ ᨶ ᩅᩥᩅᩣᨴᨿᩮᨳ, ᨶ ᩉᩥ ᨲᩮᨶ ᩈᩩᨴ᩠ᨵᩥᩴ ᨠᩩᩈᩃᩣ ᩅᨴᨶ᩠ᨲᩥ.

ᩈᩪᩁᩮᩣ ᨿᨳᩣ ᩁᩣᨩᨡᩣᨴᩣᨿ ᨸᩩᨭ᩠ᨮᩮᩣ, ᩋᨽᩥᨣᨩ᩠ᨩᨾᩮᨲᩥ ᨸᨭᩥᩈᩪᩁᨾᩥᨧ᩠ᨨᩴ;

ᨿᩮᨶᩮᩅ ᩈᩮᩣ ᨲᩮᨶ ᨸᩃᩮᩉᩥ ᩈᩪᩁ, ᨸᩩᨻ᩠ᨻᩮᩅ ᨶᨲ᩠ᨳᩥ ᨿᨴᩥᨴᩴ ᨿᩩᨵᩣᨿ.

ᨿᩮ ¶ ᨴᩥᨭ᩠ᨮᩥᨾᩩᨣ᩠ᨣᨿ᩠ᩉ ᩅᩥᩅᩣᨴᨿᨶ᩠ᨲᩥ [ᩅᩥᩅᩣᨴᩥᨿᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)], ᩍᨴᨾᩮᩅ ᩈᨧ᩠ᨧᨶ᩠ᨲᩥ ᨧ ᩅᩣᨴᨿᨶ᩠ᨲᩥ;

ᨲᩮ ¶ ᨲ᩠ᩅᩴ ᩅᨴᩔᩪ ᨶ ᩉᩥ ᨲᩮᨵ ᩋᨲ᩠ᨳᩥ, ᩅᩣᨴᨾ᩠ᩉᩥ ᨩᩣᨲᩮ ᨸᨭᩥᩈᩮᨶᩥᨠᨲ᩠ᨲᩣ.

ᩅᩥᩈᩮᨶᩥᨠᨲ᩠ᩅᩣ ᨸᨶ ᨿᩮ ᨧᩁᨶ᩠ᨲᩥ, ᨴᩥᨭ᩠ᨮᩦᩉᩥ ᨴᩥᨭ᩠ᨮᩥᩴ ᩋᩅᩥᩁᩩᨩ᩠ᨫᨾᩣᨶᩣ;

ᨲᩮᩈᩩ ¶ ᨲ᩠ᩅᩴ ᨠᩥᩴ ᩃᨽᩮᨳᩮᩣ ᨸᩈᩪᩁ, ᨿᩮᩈᩦᨵ ᨶᨲ᩠ᨳᩦ ᨸᩁᨾᩩᨣ᩠ᨣᩉᩦᨲᩴ.

ᩋᨳ ᨲ᩠ᩅᩴ ᨸᩅᩥᨲᨠ᩠ᨠᨾᩣᨣᨾᩣ, ᨾᨶᩈᩣ ᨴᩥᨭ᩠ᨮᩥᨣᨲᩣᨶᩥ ᨧᩥᨶ᩠ᨲᨿᨶ᩠ᨲᩮᩣ;

ᨵᩮᩣᨶᩮᨶ ᨿᩩᨣᩴ ᩈᨾᩣᨣᨾᩣ, ᨶ ᩉᩥ ᨲ᩠ᩅᩴ ᩈᨠ᩠ᨡᩈᩥ ᩈᨾ᩠ᨸᨿᩣᨲᩅᩮᨲᩥ.

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

ᨠᩥᨾᩮᩅᩥᨴᩴ ᨾᩩᨲ᩠ᨲᨠᩁᩦᩈᨸᩩᨱ᩠ᨱᩴ, ᨸᩣᨴᩣᨸᩥ ᨶᩴ ᩈᨾ᩠ᨹᩩᩈᩥᨲᩩᩴ ᨶ ᩍᨧ᩠ᨨᩮ’’.

‘‘ᩑᨲᩣᨴᩥᩈᩴ ¶ ᨧᩮ ᩁᨲᨶᩴ ᨶ ᩍᨧ᩠ᨨᩈᩥ, ᨶᩣᩁᩥᩴ ᨶᩁᩥᨶ᩠ᨴᩮᩉᩥ ᨻᩉᩪᩉᩥ ᨸᨲ᩠ᨳᩥᨲᩴ;

ᨴᩥᨭ᩠ᨮᩥᨣᨲᩴ ᩈᩦᩃᩅᨲᩴ ᨶᩩ ᨩᩦᩅᩥᨲᩴ [ᩈᩦᩃᩅᨲᩣᨶᩩᨩᩦᩅᩥᨲᩴ (ᩈᩦ. ᨸᩦ. ᨠ.)], ᨽᩅᩪᨸᨸᨲ᩠ᨲᩥᨬ᩠ᨧ ᩅᨴᩮᩈᩥ ᨠᩦᨴᩥᩈᩴ’’.

‘‘ᩍᨴᩴ ¶ ᩅᨴᩣᨾᩦᨲᩥ ᨶ ᨲᩔ ᩉᩮᩣᨲᩥ, (ᨾᩣᨣᨱ᩠ᨯᩥᨿᩣᨲᩥ [ᨾᩣᨣᨶ᩠ᨴᩥᨿᩣᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨽᨣᩅᩣ)

ᨵᨾ᩠ᨾᩮᩈᩩ ᨶᩥᨧ᩠ᨨᩮᨿ᩠ᨿ ᩈᨾᩩᨣ᩠ᨣᩉᩦᨲᩴ;

‘‘ᩅᩥᨶᩥᨧ᩠ᨨᨿᩣ ¶ ᨿᩣᨶᩥ ᨸᨠᨸ᩠ᨸᩥᨲᩣᨶᩥ, (ᩍᨲᩥ ᨾᩣᨣᨱ᩠ᨯᩥᨿᩮᩣ [ᨾᩣᨣᨶ᩠ᨴᩥᨿᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] )

‘‘ᨶ ᨴᩥᨭ᩠ᨮᩥᨿᩣ ᨶ ᩈᩩᨲᩥᨿᩣ ᨶ ᨬᩣᨱᩮᨶ, (ᨾᩣᨣᨱ᩠ᨯᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

‘‘ᨶᩮᩣ ᨧᩮ ᨠᩥᩁ ᨴᩥᨭ᩠ᨮᩥᨿᩣ ᨶ ᩈᩩᨲᩥᨿᩣ ᨶ ᨬᩣᨱᩮᨶ, (ᩍᨲᩥ ᨾᩣᨣᨱ᩠ᨯᩥᨿᩮᩣ)

ᨴᩥᨭ᩠ᨮᩥᨿᩣ ᩑᨠᩮ ᨸᨧ᩠ᨧᩮᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ’’.

‘‘ᨴᩥᨭ᩠ᨮᨬ᩠ᨧ ᨶᩥᩔᩣᨿ ᩋᨶᩩᨸᩩᨧ᩠ᨨᨾᩣᨶᩮᩣ, (ᨾᩣᨣᨱ᩠ᨯᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᩈᨾᩩᨣ᩠ᨣᩉᩦᨲᩮᩈᩩ ᨸᨾᩮᩣᩉᨾᩣᨣᩣ [ᩈᨾᩮᩣᩉᨾᩣᨣᩣ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᩍᨲᩮᩣ ¶ ᨧ ᨶᩣᨴ᩠ᨴᨠ᩠ᨡᩥ ᩋᨱᩩᨾ᩠ᨸᩥ ᩈᨬ᩠ᨬᩴ,

‘‘ᩈᨾᩮᩣ ¶ ᩅᩥᩈᩮᩈᩦ ᩏᨴ ᩅᩣ ᨶᩥᩉᩦᨶᩮᩣ, ᨿᩮᩣ ᨾᨬ᩠ᨬᨲᩦ ᩈᩮᩣ ᩅᩥᩅᨴᩮᨳ ᨲᩮᨶ;

ᨲᩦᩈᩩ ᩅᩥᨵᩣᩈᩩ ᩋᩅᩥᨠᨾ᩠ᨸᨾᩣᨶᩮᩣ, ᩈᨾᩮᩣ ᩅᩥᩈᩮᩈᩦᨲᩥ ᨶ ᨲᩔ ᩉᩮᩣᨲᩥ.

‘‘ᩈᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨠᩥᩴ ᩅᨴᩮᨿ᩠ᨿ, ᨾᩩᩈᩣᨲᩥ ᩅᩣ ᩈᩮᩣ ᩅᩥᩅᨴᩮᨳ ᨠᩮᨶ;

ᨿᩈ᩠ᨾᩥᩴ ᩈᨾᩴ ᩅᩥᩈᨾᩴ ᩅᩣᨸᩥ ᨶᨲ᩠ᨳᩥ, ᩈ ᨠᩮᨶ ᩅᩣᨴᩴ ᨸᨭᩥᩈᩴᨿᩩᨩᩮᨿ᩠ᨿ.

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

ᨠᩣᨾᩮᩉᩥ ᩁᩥᨲ᩠ᨲᩮᩣ ᩋᨸᩩᩁᩮᨠ᩠ᨡᩁᩣᨶᩮᩣ, ᨠᨳᩴ ᨶ ᩅᩥᨣ᩠ᨣᨿ᩠ᩉ ᨩᨶᩮᨶ ᨠᨿᩥᩁᩣ.

‘‘ᨿᩮᩉᩥ ᩅᩥᩅᩥᨲ᩠ᨲᩮᩣ ᩅᩥᨧᩁᩮᨿ᩠ᨿ ᩃᩮᩣᨠᩮ, ᨶ ᨲᩣᨶᩥ ᩏᨣ᩠ᨣᨿ᩠ᩉ ᩅᨴᩮᨿ᩠ᨿ ᨶᩣᨣᩮᩣ;

ᨩᩃᨾ᩠ᨻᩩᨩᩴ ¶ [ᩑᩃᨾ᩠ᨻᩩᨩᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨠᨱ᩠ᨯᨠᩴ ᩅᩣᩁᩥᨩᩴ ᨿᨳᩣ, ᨩᩃᩮᨶ ᨸᨦ᩠ᨠᩮᨶ ᨧᨶᩪᨸᩃᩥᨲ᩠ᨲᩴ;

ᩑᩅᩴ ᨾᩩᨶᩦ ᩈᨶ᩠ᨲᩥᩅᩣᨴᩮᩣ ᩋᨣᩥᨴ᩠ᨵᩮᩣ, ᨠᩣᨾᩮ ᨧ ᩃᩮᩣᨠᩮ ᨧ ᩋᨶᩪᨸᩃᩥᨲ᩠ᨲᩮᩣ.

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

ᨶ ᨠᨾ᩠ᨾᩩᨶᩣ ᨶᩮᩣᨸᩥ ᩈᩩᨲᩮᨶ ᨶᩮᨿ᩠ᨿᩮᩣ, ᩋᨶᩪᨸᨶᩦᨲᩮᩣ ᩈ ᨶᩥᩅᩮᩈᨶᩮᩈᩩ.

‘‘ᩈᨬ᩠ᨬᩣᩅᩥᩁᨲ᩠ᨲᩔ ᨶ ᩈᨶ᩠ᨲᩥ ᨣᨶ᩠ᨳᩣ, ᨸᨬ᩠ᨬᩣᩅᩥᨾᩩᨲ᩠ᨲᩔ ᨶ ᩈᨶ᩠ᨲᩥ ᨾᩮᩣᩉᩣ;

ᩈᨬ᩠ᨬᨬ᩠ᨧ ᨴᩥᨭ᩠ᨮᩥᨬ᩠ᨧ ᨿᩮ ᩋᨣ᩠ᨣᩉᩮᩈᩩᩴ, ᨲᩮ ᨥᨭ᩠ᨭᨿᨶ᩠ᨲᩣ [ᨥᨭ᩠ᨭᨾᩣᨶᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩅᩥᨧᩁᨶ᩠ᨲᩥ ᩃᩮᩣᨠᩮ’’ᨲᩥ.

ᨾᩣᨣᨱ᩠ᨯᩥᨿᩈᩩᨲ᩠ᨲᩴ ᨶᩅᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

‘‘ᨠᨳᩴᨴᩔᩦ ᨠᨳᩴᩈᩦᩃᩮᩣ, ᩏᨸᩈᨶ᩠ᨲᩮᩣᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩥ;

ᨲᩴ ᨾᩮ ᨣᩮᩣᨲᨾ ᨸᨻᩕᩪᩉᩥ, ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᩏᨲ᩠ᨲᨾᩴ ᨶᩁᩴ’’.

‘‘ᩅᩦᨲᨲᨱ᩠ᩉᩮᩣ ᨸᩩᩁᩣ ᨽᩮᨴᩣ, (ᩍᨲᩥ ᨽᨣᩅᩣ) ᨸᩩᨻ᩠ᨻᨾᨶ᩠ᨲᨾᨶᩥᩔᩥᨲᩮᩣ;

ᩅᩮᨾᨩ᩠ᨫᩮ ᨶᩩᨸᩈᨦ᩠ᨡᩮᨿ᩠ᨿᩮᩣ, ᨲᩔ ᨶᨲ᩠ᨳᩥ ᨸᩩᩁᨠ᩠ᨡᨲᩴ.

‘‘ᩋᨠ᩠ᨠᩮᩣᨵᨶᩮᩣ ¶ ¶ ¶ ᩋᩈᨶ᩠ᨲᩣᩈᩦ, ᩋᩅᩥᨠᨲ᩠ᨳᩦ ᩋᨠᩩᨠ᩠ᨠᩩᨧᩮᩣ;

ᨾᨶ᩠ᨲᨽᩣᨱᩦ [ᨾᨶ᩠ᨲᩣᨽᩣᨱᩦ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩋᨶᩩᨴ᩠ᨵᨲᩮᩣ, ᩈ ᩅᩮ ᩅᩣᨧᩣᨿᨲᩮᩣ ᨾᩩᨶᩥ.

‘‘ᨶᩥᩁᩣᩈᨲ᩠ᨲᩥ ᩋᨶᩣᨣᨲᩮ, ᩋᨲᩦᨲᩴ ᨶᩣᨶᩩᩈᩮᩣᨧᨲᩥ;

ᩅᩥᩅᩮᨠᨴᩔᩦ ᨹᩔᩮᩈᩩ, ᨴᩥᨭ᩠ᨮᩦᩈᩩ ᨧ ᨶ ᨶᩦᨿᨲᩥ [ᨶᩥᨿ᩠ᨿᨲᩥ (ᨻᩉᩪᩈᩩ)].

‘‘ᨸᨲᩥᩃᩦᨶᩮᩣ ᩋᨠᩩᩉᨠᩮᩣ, ᩋᨸᩥᩉᩣᩃᩩ ᩋᨾᨧ᩠ᨨᩁᩦ;

ᩋᨸ᩠ᨸᨣᨻ᩠ᨽᩮᩣ ¶ ᩋᨩᩮᨣᩩᨧ᩠ᨨᩮᩣ, ᨸᩮᩈᩩᨱᩮᨿ᩠ᨿᩮ ᨧ ᨶᩮᩣ ᨿᩩᨲᩮᩣ.

‘‘ᩈᩣᨲᩥᨿᩮᩈᩩ ᩋᨶᩔᩣᩅᩦ, ᩋᨲᩥᨾᩣᨶᩮ ᨧ ᨶᩮᩣ ᨿᩩᨲᩮᩣ;

ᩈᨱ᩠ᩉᩮᩣ ᨧ ᨸᨭᩥᨽᩣᨶᩅᩣ [ᨸᨭᩥᨽᩣᨱᩅᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨶ ᩈᨴ᩠ᨵᩮᩣ ᨶ ᩅᩥᩁᨩ᩠ᨩᨲᩥ.

‘‘ᩃᩣᨽᨠᨾ᩠ᨿᩣ ᨶ ᩈᩥᨠ᩠ᨡᨲᩥ, ᩋᩃᩣᨽᩮ ᨧ ᨶ ᨠᩩᨸ᩠ᨸᨲᩥ;

ᩋᩅᩥᩁᩩᨴ᩠ᨵᩮᩣ ᨧ ᨲᨱ᩠ᩉᩣᨿ, ᩁᩈᩮᩈᩩ ᨶᩣᨶᩩᨣᩥᨩ᩠ᨫᨲᩥ.

‘‘ᩏᨸᩮᨠ᩠ᨡᨠᩮᩣ ᩈᨴᩣ ᩈᨲᩮᩣ, ᨶ ᩃᩮᩣᨠᩮ ᨾᨬ᩠ᨬᨲᩮ ᩈᨾᩴ;

ᨶ ᩅᩥᩈᩮᩈᩦ ᨶ ᨶᩦᨧᩮᨿ᩠ᨿᩮᩣ, ᨲᩔ ᨶᩮᩣ ᩈᨶ᩠ᨲᩥ ᩏᩔᨴᩣ.

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

ᨽᩅᩣᨿ ᩅᩥᨽᩅᩣᨿ ᩅᩣ, ᨲᨱ᩠ᩉᩣ ᨿᩔ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ.

‘‘ᨲᩴ ᨻᩕᩪᨾᩥ ᩏᨸᩈᨶ᩠ᨲᩮᩣᨲᩥ, ᨠᩣᨾᩮᩈᩩ ᩋᨶᨸᩮᨠ᩠ᨡᩥᨶᩴ;

ᨣᨶ᩠ᨳᩣ ᨲᩔ ᨶ ᩅᩥᨩ᩠ᨩᨶ᩠ᨲᩥ, ᩋᨲᩁᩦ ᩈᩮᩣ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩴ.

‘‘ᨶ ᨲᩔ ᨸᩩᨲ᩠ᨲᩣ ᨸᩈᩅᩮᩣ, ᨡᩮᨲ᩠ᨲᩴ ᩅᨲ᩠ᨳᩩᨬ᩠ᨧ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᩋᨲ᩠ᨲᩣ ¶ ᩅᩣᨸᩥ ᨶᩥᩁᨲ᩠ᨲᩣ ᩅᩣ [ᩋᨲ᩠ᨲᩴ ᩅᩣᨸᩥ ᨶᩥᩁᨲ᩠ᨲᩴ ᩅᩣ (ᨻᩉᩪᩈᩩ)], ᨶ ᨲᩈ᩠ᨾᩥᩴ ᩏᨸᩃᨻ᩠ᨽᨲᩥ.

‘‘ᨿᩮᨶ ᨶᩴ ᩅᨩ᩠ᨩᩩᩴ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩣ, ᩋᨳᩮᩣ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣ;

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

‘‘ᩅᩦᨲᨣᩮᨵᩮᩣ ¶ ᩋᨾᨧ᩠ᨨᩁᩦ, ᨶ ᩏᩔᩮᩈᩩ ᩅᨴᨲᩮ ᨾᩩᨶᩥ;

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

‘‘ᨿᩔ ᩃᩮᩣᨠᩮ ᩈᨠᩴ ᨶᨲ᩠ᨳᩥ, ᩋᩈᨲᩣ ᨧ ᨶ ᩈᩮᩣᨧᨲᩥ;

ᨵᨾ᩠ᨾᩮᩈᩩ ᨧ ᨶ ᨣᨧ᩠ᨨᨲᩥ, ᩈ ᩅᩮ ᩈᨶ᩠ᨲᩮᩣᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩦ’’ᨲᩥ.

‘‘ᨠᩩᨲᩮᩣᨸᩉᩪᨲᩣ ¶ ¶ ᨠᩃᩉᩣ ᩅᩥᩅᩣᨴᩣ, ᨸᩁᩥᨴᩮᩅᩈᩮᩣᨠᩣ ᩈᩉᨾᨧ᩠ᨨᩁᩣ ᨧ;

ᨾᩣᨶᩣᨲᩥᨾᩣᨶᩣ ᩈᩉᨸᩮᩈᩩᨱᩣ ᨧ, ᨠᩩᨲᩮᩣᨸᩉᩪᨲᩣ ᨲᩮ ᨲᨴᩥᨦ᩠ᨥ ᨻᩕᩪᩉᩥ’’.

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

ᩌᩈᩣ ᨧ ᨶᩥᨭ᩠ᨮᩣ ᨧ ᨠᩩᨲᩮᩣᨶᩥᨴᩣᨶᩣ, ᨿᩮ ᩈᨾ᩠ᨸᩁᩣᨿᩣᨿ ᨶᩁᩔ ᩉᩮᩣᨶ᩠ᨲᩥ’’.

‘‘ᨨᨶ᩠ᨴᩣᨶᩥᨴᩣᨶᩣᨶᩥ ᨸᩥᨿᩣᨶᩥ ᩃᩮᩣᨠᩮ, ᨿᩮ ᨧᩣᨸᩥ ᩃᩮᩣᨽᩣ ᩅᩥᨧᩁᨶ᩠ᨲᩥ ᩃᩮᩣᨠᩮ;

ᩌᩈᩣ ᨧ ᨶᩥᨭ᩠ᨮᩣ ᨧ ᩍᨲᩮᩣᨶᩥᨴᩣᨶᩣ, ᨿᩮ ᩈᨾ᩠ᨸᩁᩣᨿᩣᨿ ᨶᩁᩔ ᩉᩮᩣᨶ᩠ᨲᩥ’’.

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

ᨠᩮᩣᨵᩮᩣ ᨾᩮᩣᩈᩅᨩ᩠ᨩᨬ᩠ᨧ ᨠᨳᩴᨠᨳᩣ ᨧ, ᨿᩮ ᩅᩣᨸᩥ ᨵᨾ᩠ᨾᩣ ᩈᨾᨱᩮᨶ ᩅᩩᨲ᩠ᨲᩣ’’.

‘‘ᩈᩣᨲᩴ ¶ ᩋᩈᩣᨲᨶ᩠ᨲᩥ ᨿᨾᩣᩉᩩ ᩃᩮᩣᨠᩮ, ᨲᨾᩪᨸᨶᩥᩔᩣᨿ ᨸᩉᩮᩣᨲᩥ ᨨᨶ᩠ᨴᩮᩣ;

ᩁᩪᨸᩮᩈᩩ ᨴᩥᩈ᩠ᩅᩣ ᩅᩥᨽᩅᩴ ᨽᩅᨬ᩠ᨧ, ᩅᩥᨶᩥᨧ᩠ᨨᨿᩴ ᨠᩩᨻ᩠ᨻᨲᩥ [ᨠᩩᩁᩩᨲᩮ (ᨻᩉᩪᩈᩩ)] ᨩᨶ᩠ᨲᩩ ᩃᩮᩣᨠᩮ.

‘‘ᨠᩮᩣᨵᩮᩣ ¶ ᨾᩮᩣᩈᩅᨩ᩠ᨩᨬ᩠ᨧ ᨠᨳᩴᨠᨳᩣ ᨧ, ᩑᨲᩮᨸᩥ ᨵᨾ᩠ᨾᩣ ᨴ᩠ᩅᨿᨾᩮᩅ ᩈᨶ᩠ᨲᩮ;

ᨠᨳᩴᨠᨳᩦ ᨬᩣᨱᨸᨳᩣᨿ ᩈᩥᨠ᩠ᨡᩮ, ᨬᨲ᩠ᩅᩣ ᨸᩅᩩᨲ᩠ᨲᩣ ᩈᨾᨱᩮᨶ ᨵᨾ᩠ᨾᩣ’’.

‘‘ᩈᩣᨲᩴ ᩋᩈᩣᨲᨬ᩠ᨧ ᨠᩩᨲᩮᩣᨶᩥᨴᩣᨶᩣ, ᨠᩥᩈ᩠ᨾᩥᩴ ᩋᩈᨶ᩠ᨲᩮ ᨶ ᨽᩅᨶ᩠ᨲᩥ ᩉᩮᨲᩮ;

ᩅᩥᨽᩅᩴ ᨽᩅᨬ᩠ᨧᩣᨸᩥ ᨿᨾᩮᨲᨾᨲ᩠ᨳᩴ, ᩑᨲᩴ ᨾᩮ ᨸᨻᩕᩪᩉᩥ ᨿᨲᩮᩣᨶᩥᨴᩣᨶᩴ’’.

‘‘ᨹᩔᨶᩥᨴᩣᨶᩴ ᩈᩣᨲᩴ ᩋᩈᩣᨲᩴ, ᨹᩔᩮ ᩋᩈᨶ᩠ᨲᩮ ᨶ ᨽᩅᨶ᩠ᨲᩥ ᩉᩮᨲᩮ;

ᩅᩥᨽᩅᩴ ¶ ᨽᩅᨬ᩠ᨧᩣᨸᩥ ᨿᨾᩮᨲᨾᨲ᩠ᨳᩴ, ᩑᨲᩴ ᨲᩮ ᨸᨻᩕᩪᨾᩥ ᩍᨲᩮᩣᨶᩥᨴᩣᨶᩴ’’.

‘‘ᨹᩔᩮᩣ ¶ ᨶᩩ ᩃᩮᩣᨠᩈ᩠ᨾᩥ ᨠᩩᨲᩮᩣᨶᩥᨴᩣᨶᩮᩣ, ᨸᩁᩥᨣ᩠ᨣᩉᩣ ᨧᩣᨸᩥ ᨠᩩᨲᩮᩣᨸᩉᩪᨲᩣ;

ᨠᩥᩈ᩠ᨾᩥᩴ ᩋᩈᨶ᩠ᨲᩮ ᨶ ᨾᨾᨲ᩠ᨲᨾᨲ᩠ᨳᩥ, ᨠᩥᩈ᩠ᨾᩥᩴ ᩅᩥᨽᩪᨲᩮ ᨶ ᨹᩩᩈᨶ᩠ᨲᩥ ᨹᩔᩣ’’.

‘‘ᨶᩣᨾᨬ᩠ᨧ ᩁᩪᨸᨬ᩠ᨧ ᨸᨭᩥᨧ᩠ᨧ ᨹᩔᩮᩣ, ᩍᨧ᩠ᨨᩣᨶᩥᨴᩣᨶᩣᨶᩥ ᨸᩁᩥᨣ᩠ᨣᩉᩣᨶᩥ;

ᩍᨧ᩠ᨨᩣᨿᩈᨶ᩠ᨲ᩠ᨿᩣ ᨶ ᨾᨾᨲ᩠ᨲᨾᨲ᩠ᨳᩥ, ᩁᩪᨸᩮ ᩅᩥᨽᩪᨲᩮ ᨶ ᨹᩩᩈᨶ᩠ᨲᩥ ᨹᩔᩣ’’.

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

ᩑᨲᩴ ᨾᩮ ᨸᨻᩕᩪᩉᩥ ᨿᨳᩣ ᩅᩥᨽᩮᩣᨲᩥ, ᨲᩴ ᨩᩣᨶᩥᨿᩣᨾᩣᨲᩥ [ᨩᩣᨶᩥᩔᩣᨾᩣᨲᩥ (ᩈᩦ. ᨠ.)] ᨾᩮ ᨾᨶᩮᩣ ᩋᩉᩩ’’.

‘‘ᨶ ᩈᨬ᩠ᨬᩈᨬ᩠ᨬᩦ ᨶ ᩅᩥᩈᨬ᩠ᨬᩈᨬ᩠ᨬᩦ, ᨶᩮᩣᨸᩥ ᩋᩈᨬ᩠ᨬᩦ ᨶ ᩅᩥᨽᩪᨲᩈᨬ᩠ᨬᩦ;

ᩑᩅᩴᩈᨾᩮᨲᩔ ᩅᩥᨽᩮᩣᨲᩥ ᩁᩪᨸᩴ, ᩈᨬ᩠ᨬᩣᨶᩥᨴᩣᨶᩣ ᩉᩥ ᨸᨸᨬ᩠ᨧᩈᨦ᩠ᨡᩣ’’.

‘‘ᨿᩴ ¶ ᨲᩴ ᩋᨸᩩᨧ᩠ᨨᩥᨾ᩠ᩉ ᩋᨠᩥᨲ᩠ᨲᨿᩦ ᨶᩮᩣ,

ᩋᨬ᩠ᨬᩴ ᨲᩴ ᨸᩩᨧ᩠ᨨᩣᨾ ᨲᨴᩥᨦ᩠ᨥ ᨻᩕᩪᩉᩥ;

ᩑᨲ᩠ᨲᩣᩅᨲᨣ᩠ᨣᩴ ¶ ᨶᩩ [ᨶᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩅᨴᨶ᩠ᨲᩥ ᩉᩮᨠᩮ,

ᩏᨴᩣᩉᩩ ¶ ᩋᨬ᩠ᨬᨾ᩠ᨸᩥ ᩅᨴᨶ᩠ᨲᩥ ᩑᨲ᩠ᨲᩮᩣ.

‘‘ᩑᨲ᩠ᨲᩣᩅᨲᨣ᩠ᨣᨾ᩠ᨸᩥ ¶ ᩅᨴᨶ᩠ᨲᩥ ᩉᩮᨠᩮ, ᨿᨠ᩠ᨡᩔ ᩈᩩᨴ᩠ᨵᩥᩴ ᩍᨵ ᨸᨱ᩠ᨯᩥᨲᩣᩈᩮ;

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

‘‘ᩑᨲᩮ ᨧ ᨬᨲ᩠ᩅᩣ ᩏᨸᨶᩥᩔᩥᨲᩣᨲᩥ, ᨬᨲ᩠ᩅᩣ ᨾᩩᨶᩦ ᨶᩥᩔᨿᩮ ᩈᩮᩣ ᩅᩥᨾᩴᩈᩦ;

ᨬᨲ᩠ᩅᩣ ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ ᨶ ᩅᩥᩅᩣᨴᨾᩮᨲᩥ, ᨽᩅᩣᨽᩅᩣᨿ ᨶ ᩈᨾᩮᨲᩥ ᨵᩦᩁᩮᩣ’’ᨲᩥ.

ᨠᩃᩉᩅᩥᩅᩣᨴᩈᩩᨲ᩠ᨲᩴ ᩑᨠᩣᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

᪑᪒. ᨧᩪᩊᨻ᩠ᨿᩪᩉᩈᩩᨲ᩠ᨲᩴ [ᨧᩪᩊᩅᩥᨿᩪᩉᩈᩩᨲ᩠ᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨶᩥᨴ᩠ᨴᩮᩈ)]

ᩈᨠᩴᩈᨠᩴᨴᩥᨭ᩠ᨮᩥᨸᩁᩥᨻ᩠ᨻᩈᩣᨶᩣ, ᩅᩥᨣ᩠ᨣᨿ᩠ᩉ ᨶᩣᨶᩣ ᨠᩩᩈᩃᩣ ᩅᨴᨶ᩠ᨲᩥ;

ᨿᩮᩣ ᩑᩅᩴ ᨩᩣᨶᩣᨲᩥ ᩈ ᩅᩮᨴᩥ ᨵᨾ᩠ᨾᩴ, ᩍᨴᩴ ᨸᨭᩥᨠ᩠ᨠᩮᩣᩈᨾᨠᩮᩅᩃᩦ ᩈᩮᩣ.

ᩑᩅᨾ᩠ᨸᩥ ᩅᩥᨣ᩠ᨣᨿ᩠ᩉ ᩅᩥᩅᩣᨴᨿᨶ᩠ᨲᩥ, ᨻᩣᩃᩮᩣ ᨸᩁᩮᩣ ᩋᨠ᩠ᨠᩩᩈᩃᩮᩣᨲᩥ [ᩋᨠᩩᩈᩃᩮᩣᨲᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨧᩣᩉᩩ;

ᩈᨧ᩠ᨧᩮᩣ ᨶᩩ ᩅᩣᨴᩮᩣ ᨠᨲᨾᩮᩣ ᩍᨾᩮᩈᩴ, ᩈᨻ᩠ᨻᩮᩅ ¶ ᩉᩦᨾᩮ ᨠᩩᩈᩃᩣ ᩅᨴᩣᨶᩣ.

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

ᩈᨻ᩠ᨻᩮᩅ ᨻᩣᩃᩣ ᩈᩩᨶᩥᩉᩦᨶᨸᨬ᩠ᨬᩣ, ᩈᨻ᩠ᨻᩮᩅᩥᨾᩮ ᨴᩥᨭ᩠ᨮᩥᨸᩁᩥᨻ᩠ᨻᩈᩣᨶᩣ.

ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨿᩣ ᨧᩮᩅ ᨶ ᩅᩦᩅᨴᩣᨲᩣ, ᩈᩴᩈᩩᨴ᩠ᨵᨸᨬ᩠ᨬᩣ ᨠᩩᩈᩃᩣ ᨾᩩᨲᩦᨾᩣ;

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

ᨶ ᩅᩣᩉᨾᩮᨲᩴ ᨲᨳᩥᨿᨶ᩠ᨲᩥ [ᨲᨳᩥᩅᨶ᩠ᨲᩥ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨻᩕᩪᨾᩥ, ᨿᨾᩣᩉᩩ ᨻᩣᩃᩣ ᨾᩥᨳᩩ ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩴ;

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

ᨿᨾᩣᩉᩩ ᩈᨧ᩠ᨧᩴ ᨲᨳᩥᨿᨶ᩠ᨲᩥ ᩑᨠᩮ, ᨲᨾᩣᩉᩩ ᩋᨬ᩠ᨬᩮ [ᩋᨬ᩠ᨬᩮᨸᩥ (ᩈ᩠ᨿᩣ.), ᩋᨬ᩠ᨬᩮ ᨧ (?)] ᨲᩩᨧ᩠ᨨᩴ ᨾᩩᩈᩣᨲᩥ;

ᩑᩅᨾ᩠ᨸᩥ ᩅᩥᨣᨿ᩠ᩉ ᩅᩥᩅᩣᨴᨿᨶ᩠ᨲᩥ, ᨠᩈ᩠ᨾᩣ ᨶ ᩑᨠᩴ ᩈᨾᨱᩣ ᩅᨴᨶ᩠ᨲᩥ.

ᩑᨠᨬ᩠ᩉᩥ ¶ ᩈᨧ᩠ᨧᩴ ᨶ ᨴᩩᨲᩦᨿᨾᨲ᩠ᨳᩥ, ᨿᩈ᩠ᨾᩥᩴ ᨸᨩᩣ ᨶᩮᩣ ᩅᩥᩅᨴᩮ ᨸᨩᩣᨶᩴ;

ᨶᩣᨶᩣ ᨲᩮ [ᨶᩣᨶᩣᨲᩮᩣ (ᨠ.)] ᩈᨧ᩠ᨧᩣᨶᩥ ᩈᨿᩴ ᨳᩩᨶᨶ᩠ᨲᩥ, ᨲᩈ᩠ᨾᩣ ¶ ᨶ ᩑᨠᩴ ᩈᨾᨱᩣ ᩅᨴᨶ᩠ᨲᩥ.

ᨠᩈ᩠ᨾᩣ ¶ ᨶᩩ ᩈᨧ᩠ᨧᩣᨶᩥ ᩅᨴᨶ᩠ᨲᩥ ᨶᩣᨶᩣ, ᨸᩅᩣᨴᩥᨿᩣᩈᩮ ᨠᩩᩈᩃᩣ ᩅᨴᩣᨶᩣ;

ᩈᨧ᩠ᨧᩣᨶᩥ ᩈᩩᨲᩣᨶᩥ ᨻᩉᩪᨶᩥ ᨶᩣᨶᩣ, ᩏᨴᩣᩉᩩ ᨲᩮ ᨲᨠ᩠ᨠᨾᨶᩩᩔᩁᨶ᩠ᨲᩥ.

ᨶ ᩉᩮᩅ ᩈᨧ᩠ᨧᩣᨶᩥ ᨻᩉᩪᨶᩥ ᨶᩣᨶᩣ, ᩋᨬ᩠ᨬᨲᩕ ᩈᨬ᩠ᨬᩣᨿ ᨶᩥᨧ᩠ᨧᩣᨶᩥ ᩃᩮᩣᨠᩮ;

ᨲᨠ᩠ᨠᨬ᩠ᨧ ᨴᩥᨭ᩠ᨮᩦᩈᩩ ᨸᨠᨸ᩠ᨸᨿᩥᨲ᩠ᩅᩣ, ᩈᨧ᩠ᨧᩴ ᨾᩩᩈᩣᨲᩥ ᨴ᩠ᩅᨿᨵᨾ᩠ᨾᨾᩣᩉᩩ.

ᨴᩥᨭ᩠ᨮᩮ ¶ ᩈᩩᨲᩮ ᩈᩦᩃᩅᨲᩮ ᨾᩩᨲᩮ ᩅᩣ, ᩑᨲᩮ ᨧ ᨶᩥᩔᩣᨿ ᩅᩥᨾᩣᨶᨴᩔᩦ;

ᩅᩥᨶᩥᨧ᩠ᨨᨿᩮ ᨮᨲ᩠ᩅᩣ ᨸᩉᩔᨾᩣᨶᩮᩣ, ᨻᩣᩃᩮᩣ ᨸᩁᩮᩣ ᩋᨠ᩠ᨠᩩᩈᩃᩮᩣᨲᩥ ᨧᩣᩉ.

ᨿᩮᨶᩮᩅ ᨻᩣᩃᩮᩣᨲᩥ ᨸᩁᩴ ᨴᩉᩣᨲᩥ, ᨲᩮᨶᩣᨲᩩᨾᩣᨶᩴ ᨠᩩᩈᩃᩮᩣᨲᩥ ᨧᩣᩉ;

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

ᩋᨲᩥᩈᩣᩁᨴᩥᨭ᩠ᨮᩥᨿᩣᩅ ᩈᩮᩣ ᩈᨾᨲ᩠ᨲᩮᩣ, ᨾᩣᨶᩮᨶ ᨾᨲ᩠ᨲᩮᩣ ᨸᩁᩥᨸᩩᨱ᩠ᨱᨾᩣᨶᩦ;

ᩈᨿᨾᩮᩅ ᩈᩣᨾᩴ ᨾᨶᩈᩣᨽᩥᩈᩥᨲ᩠ᨲᩮᩣ, ᨴᩥᨭ᩠ᨮᩦ ¶ ᩉᩥ ᩈᩣ ᨲᩔ ᨲᨳᩣ ᩈᨾᨲ᩠ᨲᩣ.

ᨸᩁᩔ ᨧᩮ ᩉᩥ ᩅᨧᩈᩣ ᨶᩥᩉᩦᨶᩮᩣ, ᨲᩩᨾᩮᩣ ᩈᩉᩣ ᩉᩮᩣᨲᩥ ᨶᩥᩉᩦᨶᨸᨬ᩠ᨬᩮᩣ;

ᩋᨳ ᨧᩮ ᩈᨿᩴ ᩅᩮᨴᨣᩪ ᩉᩮᩣᨲᩥ ᨵᩦᩁᩮᩣ, ᨶ ᨠᩮᩣᨧᩥ ᨻᩣᩃᩮᩣ ᩈᨾᨱᩮᩈᩩ ᩋᨲ᩠ᨳᩥ.

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

ᩑᩅᨾ᩠ᨸᩥ ᨲᩥᨲ᩠ᨳ᩠ᨿᩣ ᨸᩩᨳᩩᩈᩮᩣ ᩅᨴᨶ᩠ᨲᩥ, ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᩁᩣᨣᩮᨶ ᩉᩥ ᨲᩮᨽᩥᩁᨲ᩠ᨲᩣ [ᨲ᩠ᨿᩣᨽᩥᩁᨲ᩠ᨲᩣ (ᩈ᩠ᨿᩣ. ᨠ.)].

ᩍᨵᩮᩅ ᩈᩩᨴ᩠ᨵᩥ ᩍᨲᩥ ᩅᩣᨴᨿᨶ᩠ᨲᩥ, ᨶᩣᨬ᩠ᨬᩮᩈᩩ ᨵᨾ᩠ᨾᩮᩈᩩ ᩅᩥᩈᩩᨴ᩠ᨵᩥᨾᩣᩉᩩ;

ᩑᩅᨾ᩠ᨸᩥ ᨲᩥᨲ᩠ᨳ᩠ᨿᩣ ᨸᩩᨳᩩᩈᩮᩣ ᨶᩥᩅᩥᨭ᩠ᨮᩣ, ᩈᨠᩣᨿᨶᩮ ᨲᨲ᩠ᨳ ᨴᩊ᩠ᩉᩴ ᩅᨴᩣᨶᩣ.

ᩈᨠᩣᨿᨶᩮ ᩅᩣᨸᩥ ᨴᩊ᩠ᩉᩴ ᩅᨴᩣᨶᩮᩣ, ᨠᨾᩮᨲ᩠ᨳ ᨻᩣᩃᩮᩣᨲᩥ ᨸᩁᩴ ᨴᩉᩮᨿ᩠ᨿ;

ᩈᨿᨾᩮᩅ ᩈᩮᩣ ᨾᩮᨵᨣᨾᩣᩅᩉᩮᨿ᩠ᨿ [ᨾᩮᨵᨠᩴ ᩌᩅᩉᩮᨿ᩠ᨿ (ᩈᩦ. ᨸᩦ.)], ᨸᩁᩴ ᩅᨴᩴ ᨻᩣᩃᨾᩈᩩᨴ᩠ᨵᩥᨵᨾ᩠ᨾᩴ.

ᩅᩥᨶᩥᨧ᩠ᨨᨿᩮ ¶ ¶ ᨮᨲ᩠ᩅᩣ ᩈᨿᩴ ᨸᨾᩣᨿ, ᩏᨴ᩠ᨵᩴ ᩈ [ᩏᨴ᩠ᨴᩴ ᩈᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ ᩅᩥᩅᩣᨴᨾᩮᨲᩥ;

ᩉᩥᨲ᩠ᩅᩣᨶ ᩈᨻ᩠ᨻᩣᨶᩥ ᩅᩥᨶᩥᨧ᩠ᨨᨿᩣᨶᩥ, ᨶ ¶ ᨾᩮᨵᨣᩴ ᨠᩩᨻ᩠ᨻᨲᩥ ᨩᨶ᩠ᨲᩩ ᩃᩮᩣᨠᩮᨲᩥ.

ᨧᩪᩊᨻ᩠ᨿᩪᩉᩈᩩᨲ᩠ᨲᩴ ᨴ᩠ᩅᩣᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨿᩮ ᨠᩮᨧᩥᨾᩮ ᨴᩥᨭ᩠ᨮᩥᨸᩁᩥᨻ᩠ᨻᩈᩣᨶᩣ, ᩍᨴᨾᩮᩅ ᩈᨧ᩠ᨧᨶ᩠ᨲᩥ ᩅᩥᩅᩣᨴᨿᨶ᩠ᨲᩥ [ᩅᩥᩅᩣᨴᩥᨿᨶ᩠ᨲᩥ (ᩈᩦ. ᨸᩦ.)];

ᩈᨻ᩠ᨻᩮᩅ ᨲᩮ ᨶᩥᨶ᩠ᨴᨾᨶ᩠ᩅᩣᨶᨿᨶ᩠ᨲᩥ, ᩋᨳᩮᩣ ᨸᩈᩴᩈᨾ᩠ᨸᩥ ᩃᨽᨶ᩠ᨲᩥ ᨲᨲ᩠ᨳ.

ᩋᨸ᩠ᨸᨬ᩠ᩉᩥ ¶ ᩑᨲᩴ ᨶ ᩋᩃᩴ ᩈᨾᩣᨿ, ᨴᩩᩅᩮ ᩅᩥᩅᩣᨴᩔ ᨹᩃᩣᨶᩥ ᨻᩕᩪᨾᩥ;

ᩑᨲᨾ᩠ᨸᩥ ᨴᩥᩈ᩠ᩅᩣ ᨶ ᩅᩥᩅᩣᨴᨿᩮᨳ, ᨡᩮᨾᩣᨽᩥᨸᩔᩴ ᩋᩅᩥᩅᩣᨴᨽᩪᨾᩥᩴ.

ᨿᩣ ᨠᩣᨧᩥᨾᩣ ᩈᨾ᩠ᨾᩩᨲᩥᨿᩮᩣ ᨸᩩᨳᩩᨩ᩠ᨩᩣ, ᩈᨻ᩠ᨻᩣᩅ ᩑᨲᩣ ᨶ ᩏᨸᩮᨲᩥ ᩅᩥᨴ᩠ᩅᩣ;

ᩋᨶᩪᨸᨿᩮᩣ ᩈᩮᩣ ᩏᨸᨿᩴ ᨠᩥᨾᩮᨿ᩠ᨿ, ᨴᩥᨭ᩠ᨮᩮ ᩈᩩᨲᩮ ᨡᨶ᩠ᨲᩥᨾᨠᩩᨻ᩠ᨻᨾᩣᨶᩮᩣ.

ᩈᩦᩃᩩᨲ᩠ᨲᨾᩣ ᩈᨬ᩠ᨬᨾᩮᨶᩣᩉᩩ ᩈᩩᨴ᩠ᨵᩥᩴ, ᩅᨲᩴ ᩈᨾᩣᨴᩣᨿ ᩏᨸᨭ᩠ᨮᩥᨲᩣᩈᩮ;

ᩍᨵᩮᩅ ᩈᩥᨠ᩠ᨡᩮᨾ ᩋᨳᩔ ᩈᩩᨴ᩠ᨵᩥᩴ, ᨽᩅᩪᨸᨶᩦᨲᩣ ¶ ᨠᩩᩈᩃᩣ ᩅᨴᩣᨶᩣ.

ᩈᨧᩮ ᨧᩩᨲᩮᩣ ᩈᩦᩃᩅᨲᨲᩮᩣ ᩉᩮᩣᨲᩥ, ᨸᩅᩮᨵᨲᩦ [ᩈ ᩅᩮᨵᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᨠᨾ᩠ᨾ ᩅᩥᩁᩣᨵᨿᩥᨲ᩠ᩅᩣ;

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

ᩈᩦᩃᨻ᩠ᨻᨲᩴ ¶ ᩅᩣᨸᩥ ᨸᩉᩣᨿ ᩈᨻ᩠ᨻᩴ, ᨠᨾ᩠ᨾᨬ᩠ᨧ ᩈᩣᩅᨩ᩠ᨩᨶᩅᨩ᩠ᨩᨾᩮᨲᩴ;

ᩈᩩᨴ᩠ᨵᩥᩴ ¶ ᩋᩈᩩᨴ᩠ᨵᩥᨶ᩠ᨲᩥ ᩋᨸᨲ᩠ᨳᨿᩣᨶᩮᩣ, ᩅᩥᩁᨲᩮᩣ ᨧᩁᩮ ᩈᨶ᩠ᨲᩥᨾᨶᩩᨣ᩠ᨣᩉᩣᨿ.

ᨲᨾᩪᨸᨶᩥᩔᩣᨿ ᨩᩥᨣᩩᨧ᩠ᨨᩥᨲᩴ ᩅᩣ, ᩋᨳᩅᩣᨸᩥ ᨴᩥᨭ᩠ᨮᩴ ᩅ ᩈᩩᨲᩴ ᨾᩩᨲᩴ ᩅᩣ;

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

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

ᨧᩩᨲᩪᨸᨸᩣᨲᩮᩣ ᩍᨵ ᨿᩔ ᨶᨲ᩠ᨳᩥ, ᩈ ᨠᩮᨶ ᩅᩮᨵᩮᨿ᩠ᨿ ᨠᩩᩉᩥᩴᩅ ᨩᨸ᩠ᨸᩮ [ᨠᩩᩉᩥᨬ᩠ᨧᩥ ᨩᨸ᩠ᨸᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.), ᨠᩩᩉᩥᩴ ᨸᨩᨸ᩠ᨸᩮ (ᨸᩦ.) ᨶᩥᨴ᩠ᨴᩮᩈᩮᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩮᩣ].

ᨿᨾᩣᩉᩩ ᨵᨾ᩠ᨾᩴ ᨸᩁᨾᨶ᩠ᨲᩥ ᩑᨠᩮ, ᨲᨾᩮᩅ ᩉᩦᨶᨶ᩠ᨲᩥ ᨸᨶᩣᩉᩩ ᩋᨬ᩠ᨬᩮ;

ᩈᨧ᩠ᨧᩮᩣ ᨶᩩ ᩅᩣᨴᩮᩣ ᨠᨲᨾᩮᩣ ᩍᨾᩮᩈᩴ, ᩈᨻ᩠ᨻᩮᩅ ¶ ᩉᩦᨾᩮ ᨠᩩᩈᩃᩣ ᩅᨴᩣᨶᩣ.

ᩈᨠᨬ᩠ᩉᩥ ᨵᨾ᩠ᨾᩴ ᨸᩁᩥᨸᩩᨱ᩠ᨱᨾᩣᩉᩩ, ᩋᨬ᩠ᨬᩔ ᨵᨾ᩠ᨾᩴ ᨸᨶ ᩉᩦᨶᨾᩣᩉᩩ;

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

ᨸᩁᩔ ᨧᩮ ᩅᨾ᩠ᨽᨿᩥᨲᩮᨶ ᩉᩦᨶᩮᩣ, ᨶ ᨠᩮᩣᨧᩥ ᨵᨾ᩠ᨾᩮᩈᩩ ᩅᩥᩈᩮᩈᩥ ᩋᩔ;

ᨸᩩᨳᩪ ᩉᩥ ᩋᨬ᩠ᨬᩔ ᩅᨴᨶ᩠ᨲᩥ ᨵᨾ᩠ᨾᩴ, ᨶᩥᩉᩦᨶᨲᩮᩣ ᩈᨾ᩠ᩉᩥ ᨴᩊ᩠ᩉᩴ ᩅᨴᩣᨶᩣ.

ᩈᨴ᩠ᨵᨾ᩠ᨾᨸᩪᨩᩣᨸᩥ ¶ ᨶᩮᩈᩴ ᨲᨳᩮᩅ, ᨿᨳᩣ ᨸᩈᩴᩈᨶ᩠ᨲᩥ ᩈᨠᩣᨿᨶᩣᨶᩥ;

ᩈᨻ᩠ᨻᩮᩅ ᩅᩣᨴᩣ [ᩈᨻ᩠ᨻᩮ ᨸᩅᩣᨴᩣ (ᩈ᩠ᨿᩣ.)] ᨲᨳᩥᨿᩣ [ᨲᨳᩥᩅᩣ (ᩈᨻ᩠ᨻᨲ᩠ᨳ)] ᨽᩅᩮᨿ᩠ᨿᩩᩴ, ᩈᩩᨴ᩠ᨵᩦ ᩉᩥ ᨶᩮᩈᩴ ᨸᨧ᩠ᨧᨲ᩠ᨲᨾᩮᩅ.

ᨶ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨸᩁᨶᩮᨿ᩠ᨿᨾᨲ᩠ᨳᩥ, ᨵᨾ᩠ᨾᩮᩈᩩ ᨶᩥᨧ᩠ᨨᩮᨿ᩠ᨿ ᩈᨾᩩᨣ᩠ᨣᩉᩦᨲᩴ;

ᨲᩈ᩠ᨾᩣ ᩅᩥᩅᩣᨴᩣᨶᩥ ᩏᨸᩣᨲᩥᩅᨲ᩠ᨲᩮᩣ, ᨶ ᩉᩥ ᩈᩮᨭ᩠ᨮᨲᩮᩣ ᨸᩔᨲᩥ ᨵᨾ᩠ᨾᨾᨬ᩠ᨬᩴ.

ᨩᩣᨶᩣᨾᩥ ᨸᩔᩣᨾᩥ ᨲᨳᩮᩅ ᩑᨲᩴ, ᨴᩥᨭ᩠ᨮᩥᨿᩣ ᩑᨠᩮ ᨸᨧ᩠ᨧᩮᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ;

ᩋᨴ᩠ᨴᨠ᩠ᨡᩥ ᨧᩮ ᨠᩥᨬ᩠ᩉᩥ ᨲᩩᨾᩔ ᨲᩮᨶ, ᩋᨲᩥᩈᩥᨲ᩠ᩅᩣ ¶ ᩋᨬ᩠ᨬᩮᨶ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ.

ᨸᩔᩴ ᨶᩁᩮᩣ ᨴᨠ᩠ᨡᨲᩥ [ᨴᨠ᩠ᨡᩥᨲᩥ (ᩈᩦ.)] ᨶᩣᨾᩁᩪᨸᩴ, ᨴᩥᩈ᩠ᩅᩣᨶ ᩅᩣ ᨬᩔᨲᩥ ᨲᩣᨶᩥᨾᩮᩅ;

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

ᨶᩥᩅᩥᩔᩅᩣᨴᩦ ᨶ ᩉᩥ ᩈᩩᨻ᩠ᨻᩥᨶᩣᨿᩮᩣ, ᨸᨠᨸ᩠ᨸᩥᨲᩴ ᨴᩥᨭ᩠ᨮᩥ ᨸᩩᩁᩮᨠ᩠ᨡᩁᩣᨶᩮᩣ;

ᨿᩴ ᨶᩥᩔᩥᨲᩮᩣ ᨲᨲ᩠ᨳ ᩈᩩᨽᩴ ᩅᨴᩣᨶᩮᩣ, ᩈᩩᨴ᩠ᨵᩥᩴᩅᨴᩮᩣ ᨲᨲ᩠ᨳ ᨲᨳᨴ᩠ᨴᩈᩣ ᩈᩮᩣ.

ᨶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨠᨸ᩠ᨸᨾᩩᨸᩮᨲᩥ ᩈᨦ᩠ᨡᩣ [ᩈᨦ᩠ᨡᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᨶ ᨴᩥᨭ᩠ᨮᩥᩈᩣᩁᩦ ᨶᨸᩥ ᨬᩣᨱᨻᨶ᩠ᨵᩩ;

ᨬᨲ᩠ᩅᩣ ¶ ᨧ ᩈᩮᩣ ᩈᨾ᩠ᨾᩩᨲᩥᨿᩮᩣ [ᩈᨾ᩠ᨾᨲᩥᨿᩮᩣ (ᩈ᩠ᨿᩣ.)] ᨸᩩᨳᩩᨩ᩠ᨩᩣ, ᩏᨸᩮᨠ᩠ᨡᨲᩦ ᩏᨣ᩠ᨣᩉᨱᨶ᩠ᨲᩥ ᨾᨬ᩠ᨬᩮ.

ᩅᩥᩔᨩ᩠ᨩ ¶ ᨣᨶ᩠ᨳᩣᨶᩥ ᨾᩩᨶᩦᨵ ᩃᩮᩣᨠᩮ, ᩅᩥᩅᩣᨴᨩᩣᨲᩮᩈᩩ ᨶ ᩅᨣ᩠ᨣᩈᩣᩁᩦ;

ᩈᨶ᩠ᨲᩮᩣ ᩋᩈᨶ᩠ᨲᩮᩈᩩ ᩏᨸᩮᨠ᩠ᨡᨠᩮᩣ ᩈᩮᩣ, ᩋᨶᩩᨣ᩠ᨣᩉᩮᩣ ᩏᨣ᩠ᨣᩉᨱᨶ᩠ᨲᩥ ᨾᨬ᩠ᨬᩮ.

ᨸᩩᨻ᩠ᨻᩣᩈᩅᩮ ᩉᩥᨲ᩠ᩅᩣ ᨶᩅᩮ ᩋᨠᩩᨻ᩠ᨻᩴ, ᨶ ᨨᨶ᩠ᨴᨣᩪ ᨶᩮᩣᨸᩥ ᨶᩥᩅᩥᩔᩅᩣᨴᩦ;

ᩈ ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩮᩣ ᨴᩥᨭ᩠ᨮᩥᨣᨲᩮᩉᩥ ᨵᩦᩁᩮᩣ, ᨶ ¶ ᩃᩥᨾ᩠ᨸᨲᩥ [ᨶ ᩃᩥᨸ᩠ᨸᨲᩥ (ᩈᩦ. ᨸᩦ.)] ᩃᩮᩣᨠᩮ ᩋᨶᨲ᩠ᨲᨣᩁᩉᩦ.

ᩈ ¶ ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩮᩈᩩ ᩅᩥᩈᩮᨶᩥᨽᩪᨲᩮᩣ, ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨴᩥᨭ᩠ᨮᩴ ᩅ ᩈᩩᨲᩴ ᨾᩩᨲᩴ ᩅᩣ;

ᩈ ᨸᨶ᩠ᨶᨽᩣᩁᩮᩣ ᨾᩩᨶᩥ ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩮᩣ, ᨶ ᨠᨸ᩠ᨸᩥᨿᩮᩣ ᨶᩪᨸᩁᨲᩮᩣ ᨶ ᨸᨲ᩠ᨳᩥᨿᩮᩣᨲᩥ.

ᨾᩉᩣᨻ᩠ᨿᩪᩉᩈᩩᨲ᩠ᨲᩴ ᨲᩮᩁᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

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

ᨠᨳᩴ ᨴᩥᩈ᩠ᩅᩣ ᨶᩥᨻ᩠ᨻᩣᨲᩥ ᨽᩥᨠ᩠ᨡᩩ, ᩋᨶᩩᨸᩣᨴᩥᨿᩣᨶᩮᩣ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ ᨠᩥᨬ᩠ᨧᩥ’’.

ᨾᨶ᩠ᨲᩣ ᩋᩈ᩠ᨾᩦᨲᩥ ᩈᨻ᩠ᨻᨾᩩᨸᩁᩩᨶ᩠ᨵᩮ [ᩈᨻ᩠ᨻᨾᩩᨸᩁᩩᨴ᩠ᨵᩮ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)];

ᨲᩣᩈᩴ ᩅᩥᨶᨿᩣ [ᩅᩥᨶᨿᩣᨿ (?)] ᩈᨴᩣ ᩈᨲᩮᩣ ᩈᩥᨠ᩠ᨡᩮ.

‘‘ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᨵᨾ᩠ᨾᨾᨽᩥᨩᨬ᩠ᨬᩣ, ᩋᨩ᩠ᨫᨲ᩠ᨲᩴ ᩋᨳᩅᩣᨸᩥ ᨻᩉᩥᨴ᩠ᨵᩣ;

ᨶ ᨲᩮᨶ ᨳᩣᨾᩴ [ᨾᩣᨶᩴ (ᩈᩦ. ᨠ.)] ᨠᩩᨻ᩠ᨻᩮᨳ, ᨶ ¶ ᩉᩥ ᩈᩣ ᨶᩥᨻ᩠ᨻᩩᨲᩥ ᩈᨲᩴ ᩅᩩᨲ᩠ᨲᩣ.

‘‘ᩈᩮᨿ᩠ᨿᩮᩣ ᨶ ᨲᩮᨶ ᨾᨬ᩠ᨬᩮᨿ᩠ᨿ, ᨶᩦᨧᩮᨿ᩠ᨿᩮᩣ ᩋᨳᩅᩣᨸᩥ ᩈᩁᩥᨠ᩠ᨡᩮᩣ;

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

‘‘ᩋᨩ᩠ᨫᨲ᩠ᨲᨾᩮᩅᩩᨸᩈᨾᩮ ¶ , ᨶ ᩋᨬ᩠ᨬᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᩈᨶ᩠ᨲᩥᨾᩮᩈᩮᨿ᩠ᨿ;

ᩋᨩ᩠ᨫᨲ᩠ᨲᩴ ᩏᨸᩈᨶ᩠ᨲᩔ, ᨶᨲ᩠ᨳᩥ ᩋᨲ᩠ᨲᩣ ᨠᩩᨲᩮᩣ ᨶᩥᩁᨲ᩠ᨲᩣ ᩅᩣ.

‘‘ᨾᨩ᩠ᨫᩮ ¶ ¶ ᨿᨳᩣ ᩈᨾᩩᨴ᩠ᨴᩔ, ᩐᨾᩥ ᨶᩮᩣ ᨩᩣᨿᨲᩦ ᨮᩥᨲᩮᩣ ᩉᩮᩣᨲᩥ;

ᩑᩅᩴ ᨮᩥᨲᩮᩣ ᩋᨶᩮᨩᩔ, ᩏᩔᨴᩴ ᨽᩥᨠ᩠ᨡᩩ ᨶ ᨠᩁᩮᨿ᩠ᨿ ᨠᩩᩉᩥᨬ᩠ᨧᩥ’’.

‘‘ᩋᨠᩥᨲ᩠ᨲᨿᩦ ᩅᩥᩅᨭᨧᨠ᩠ᨡᩩ, ᩈᨠ᩠ᨡᩥᨵᨾ᩠ᨾᩴ ᨸᩁᩥᩔᨿᩅᩥᨶᨿᩴ;

ᨸᨭᩥᨸᨴᩴ ᩅᨴᩮᩉᩥ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨸᩣᨲᩥᨾᩮᩣᨠ᩠ᨡᩴ ᩋᨳᩅᩣᨸᩥ ᩈᨾᩣᨵᩥᩴ’’.

‘‘ᨧᨠ᩠ᨡᩪᩉᩥ ᨶᩮᩅ ᩃᩮᩣᩃᩔ, ᨣᩣᨾᨠᨳᩣᨿ ᩌᩅᩁᨿᩮ ᩈᩮᩣᨲᩴ;

ᩁᩈᩮ ᨧ ᨶᩣᨶᩩᨣᩥᨩ᩠ᨫᩮᨿ᩠ᨿ, ᨶ ¶ ᨧ ᨾᨾᩣᨿᩮᨳ ᨠᩥᨬ᩠ᨧᩥ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ.

‘‘ᨹᩔᩮᨶ ᨿᨴᩣ ᨹᩩᨭ᩠ᨮᩔ, ᨸᩁᩥᨴᩮᩅᩴ ᨽᩥᨠ᩠ᨡᩩ ᨶ ᨠᩁᩮᨿ᩠ᨿ ᨠᩩᩉᩥᨬ᩠ᨧᩥ;

ᨽᩅᨬ᩠ᨧ ᨶᩣᨽᩥᨩᨸ᩠ᨸᩮᨿ᩠ᨿ, ᨽᩮᩁᩅᩮᩈᩩ ᨧ ᨶ ᩈᨾ᩠ᨸᩅᩮᨵᩮᨿ᩠ᨿ.

‘‘ᩋᨶ᩠ᨶᩣᨶᨾᨳᩮᩣ ᨸᩣᨶᩣᨶᩴ, ᨡᩣᨴᨶᩦᨿᩣᨶᩴ ᩋᨳᩮᩣᨸᩥ ᩅᨲ᩠ᨳᩣᨶᩴ;

ᩃᨴ᩠ᨵᩣ ᨶ ᩈᨶ᩠ᨶᩥᨵᩥᩴ ᨠᨿᩥᩁᩣ, ᨶ ᨧ ᨸᩁᩥᨲ᩠ᨲᩈᩮ ᨲᩣᨶᩥ ᩋᩃᨽᨾᩣᨶᩮᩣ.

‘‘ᨫᩣᨿᩦ ᨶ ᨸᩣᨴᩃᩮᩣᩃᩔ, ᩅᩥᩁᨾᩮ ᨠᩩᨠ᩠ᨠᩩᨧ᩠ᨧᩣ ᨶᨸ᩠ᨸᨾᨩ᩠ᨩᩮᨿ᩠ᨿ;

ᩋᨳᩣᩈᨶᩮᩈᩩ ᩈᨿᨶᩮᩈᩩ, ᩋᨸ᩠ᨸᩈᨴ᩠ᨴᩮᩈᩩ ᨽᩥᨠ᩠ᨡᩩ ᩅᩥᩉᩁᩮᨿ᩠ᨿ.

‘‘ᨶᩥᨴ᩠ᨴᩴ ¶ ᨶ ᨻᩉᩩᩃᩦᨠᩁᩮᨿ᩠ᨿ, ᨩᩣᨣᩁᩥᨿᩴ ᨽᨩᩮᨿ᩠ᨿ ᩌᨲᩣᨸᩦ;

ᨲᨶ᩠ᨴᩥᩴ ᨾᩣᨿᩴ ᩉᩔᩴ ᨡᩥᨯ᩠ᨯᩴ, ᨾᩮᨳᩩᨶᩴ ᩅᩥᨸ᩠ᨸᨩᩉᩮ ᩈᩅᩥᨽᩪᩈᩴ.

‘‘ᩌᨳᨻ᩠ᨻᨱᩴ ¶ ᩈᩩᨸᩥᨶᩴ ᩃᨠ᩠ᨡᨱᩴ, ᨶᩮᩣ ᩅᩥᨴᩉᩮ ᩋᨳᩮᩣᨸᩥ ᨶᨠ᩠ᨡᨲ᩠ᨲᩴ;

ᩅᩥᩁᩩᨲᨬ᩠ᨧ ᨣᨻ᩠ᨽᨠᩁᨱᩴ, ᨲᩥᨠᩥᨧ᩠ᨨᩴ ¶ ᨾᩣᨾᨠᩮᩣ ᨶ ᩈᩮᩅᩮᨿ᩠ᨿ.

‘‘ᨶᩥᨶ᩠ᨴᩣᨿ ᨶᨸ᩠ᨸᩅᩮᨵᩮᨿ᩠ᨿ, ᨶ ᩏᨱ᩠ᨱᨾᩮᨿ᩠ᨿ ᨸᩈᩴᩈᩥᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ;

ᩃᩮᩣᨽᩴ ᩈᩉ ᨾᨧ᩠ᨨᩁᩥᨿᩮᨶ, ᨠᩮᩣᨵᩴ ᨸᩮᩈᩩᨱᩥᨿᨬ᩠ᨧ ᨸᨶᩩᨴᩮᨿ᩠ᨿ.

‘‘ᨠᨿᩅᩥᨠ᩠ᨠᨿᩮ ¶ ᨶ ᨲᩥᨭ᩠ᨮᩮᨿ᩠ᨿ, ᩏᨸᩅᩣᨴᩴ ᨽᩥᨠ᩠ᨡᩩ ᨶ ᨠᩁᩮᨿ᩠ᨿ ᨠᩩᩉᩥᨬ᩠ᨧᩥ;

ᨣᩣᨾᩮ ᨧ ᨶᩣᨽᩥᩈᨩ᩠ᨩᩮᨿ᩠ᨿ, ᩃᩣᨽᨠᨾ᩠ᨿᩣ ᨩᨶᩴ ᨶ ᩃᨸᨿᩮᨿ᩠ᨿ.

‘‘ᨶ ᨧ ᨠᨲ᩠ᨳᩥᨲᩣ ᩈᩥᨿᩣ ᨽᩥᨠ᩠ᨡᩩ, ᨶ ᨧ ᩅᩣᨧᩴ ᨸᨿᩩᨲ᩠ᨲᩴ ᨽᩣᩈᩮᨿ᩠ᨿ;

ᨸᩣᨣᨻ᩠ᨽᩥᨿᩴ ᨶ ᩈᩥᨠ᩠ᨡᩮᨿ᩠ᨿ, ᨠᨳᩴ ᩅᩥᨣ᩠ᨣᩣᩉᩥᨠᩴ ᨶ ᨠᨳᨿᩮᨿ᩠ᨿ.

‘‘ᨾᩮᩣᩈᩅᨩ᩠ᨩᩮ ᨶ ᨶᩦᨿᩮᨳ, ᩈᨾ᩠ᨸᨩᩣᨶᩮᩣ ᩈᨮᩣᨶᩥ ᨶ ᨠᨿᩥᩁᩣ;

ᩋᨳ ¶ ᨩᩦᩅᩥᨲᩮᨶ ᨸᨬ᩠ᨬᩣᨿ, ᩈᩦᩃᨻ᩠ᨻᨲᩮᨶ ᨶᩣᨬ᩠ᨬᨾᨲᩥᨾᨬ᩠ᨬᩮ.

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

ᨹᩁᩩᩈᩮᨶ ᨶᩮ ᨶ ᨸᨭᩥᩅᨩ᩠ᨩᩣ, ᨶ ¶ ᩉᩥ ᩈᨶ᩠ᨲᩮᩣ ᨸᨭᩥᩈᩮᨶᩥᨠᩁᩮᩣᨶ᩠ᨲᩥ.

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

ᩈᨶ᩠ᨲᩦᨲᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩥᩴ ᨬᨲ᩠ᩅᩣ, ᩈᩣᩈᨶᩮ ᨣᩮᩣᨲᨾᩔ ᨶ ᨸᨾᨩ᩠ᨩᩮᨿ᩠ᨿ.

‘‘ᩋᨽᩥᨽᩪ ¶ ᩉᩥ ᩈᩮᩣ ᩋᨶᨽᩥᨽᩪᨲᩮᩣ, ᩈᨠ᩠ᨡᩥᨵᨾ᩠ᨾᨾᨶᩦᨲᩥᩉᨾᨴᩔᩦ;

ᨲᩈ᩠ᨾᩣ ᩉᩥ ᨲᩔ ᨽᨣᩅᨲᩮᩣ ᩈᩣᩈᨶᩮ, ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ ᩈᨴᩣ ᨶᨾᩔᨾᨶᩩᩈᩥᨠ᩠ᨡᩮ’’ᨲᩥ.

ᨲᩩᩅᨭᨠᩈᩩᨲ᩠ᨲᩴ ᨧᩩᨴ᩠ᨴᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

‘‘ᩋᨲ᩠ᨲᨴᨱ᩠ᨯᩣ ᨽᨿᩴ ᨩᩣᨲᩴ, ᨩᨶᩴ ᨸᩔᨳ ᨾᩮᨵᨣᩴ;

ᩈᩴᩅᩮᨣᩴ ᨠᩥᨲ᩠ᨲᨿᩥᩔᩣᨾᩥ, ᨿᨳᩣ ᩈᩴᩅᩥᨩᩥᨲᩴ ᨾᨿᩣ.

‘‘ᨹᨶ᩠ᨴᨾᩣᨶᩴ ¶ ᨸᨩᩴ ᨴᩥᩈ᩠ᩅᩣ, ᨾᨧ᩠ᨨᩮ ᩋᨸ᩠ᨸᩮᩣᨴᨠᩮ ᨿᨳᩣ;

ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩮᩉᩥ ᨻ᩠ᨿᩣᩁᩩᨴ᩠ᨵᩮ, ᨴᩥᩈ᩠ᩅᩣ ᨾᩴ ᨽᨿᨾᩣᩅᩥᩈᩥ.

‘‘ᩈᨾᨶ᩠ᨲᨾᩈᩣᩁᩮᩣ ¶ ᩃᩮᩣᨠᩮᩣ, ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ ᩈᨾᩮᩁᩥᨲᩣ;

ᩍᨧ᩠ᨨᩴ ᨽᩅᨶᨾᨲ᩠ᨲᨶᩮᩣ, ᨶᩣᨴ᩠ᨴᩈᩣᩈᩥᩴ ᩋᨶᩮᩣᩈᩥᨲᩴ.

‘‘ᩒᩈᩣᨶᩮᨲ᩠ᩅᩮᩅ ¶ ᨻ᩠ᨿᩣᩁᩩᨴ᩠ᨵᩮ, ᨴᩥᩈ᩠ᩅᩣ ᨾᩮ ᩋᩁᨲᩦ ᩋᩉᩩ;

ᩋᨳᩮᨲ᩠ᨳ ᩈᩃ᩠ᩃᨾᨴ᩠ᨴᨠ᩠ᨡᩥᩴ, ᨴᩩᨴ᩠ᨴᩈᩴ ᩉᨴᨿᨶᩥᩔᩥᨲᩴ.

‘‘ᨿᩮᨶ ᩈᩃ᩠ᩃᩮᨶ ᩒᨲᩥᨱ᩠ᨱᩮᩣ, ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ ᩅᩥᨵᩣᩅᨲᩥ;

ᨲᨾᩮᩅ ᩈᩃ᩠ᩃᨾᨻ᩠ᨻᩩᨿ᩠ᩉ, ᨶ ᨵᩣᩅᨲᩥ ᨶ ᩈᩦᨴᨲᩥ.

‘‘ᨲᨲ᩠ᨳ ᩈᩥᨠ᩠ᨡᩣᨶᩩᨣᩦᨿᨶ᩠ᨲᩥ [ᩈᩥᨠ᩠ᨡᩣᨶᩩᨠᩥᩁᩥᨿᨶ᩠ᨲᩥ (ᨠ.)], ᨿᩣᨶᩥ ᩃᩮᩣᨠᩮ ᨣᨵᩥᨲᩣᨶᩥ;

ᨶ ᨲᩮᩈᩩ ᨸᩈᩩᨲᩮᩣ ᩈᩥᨿᩣ, ᨶᩥᨻ᩠ᨻᩥᨩ᩠ᨫ ᩈᨻ᩠ᨻᩈᩮᩣ ᨠᩣᨾᩮ;

‘‘ᩈᨧ᩠ᨧᩮᩣ ᩈᩥᨿᩣ ᩋᨸ᩠ᨸᨣᨻ᩠ᨽᩮᩣ, ᩋᨾᩣᨿᩮᩣ ᩁᩥᨲ᩠ᨲᨸᩮᩈᩩᨱᩮᩣ;

ᩋᨠ᩠ᨠᩮᩣᨵᨶᩮᩣ ᩃᩮᩣᨽᨸᩣᨸᩴ, ᩅᩮᩅᩥᨧ᩠ᨨᩴ ᩅᩥᨲᩁᩮ ᨾᩩᨶᩥ.

‘‘ᨶᩥᨴ᩠ᨴᩴ ᨲᨶ᩠ᨴᩥᩴ ᩈᩉᩮ ᨳᩦᨶᩴ, ᨸᨾᩣᨴᩮᨶ ᨶ ᩈᩴᩅᩈᩮ;

ᩋᨲᩥᨾᩣᨶᩮ ᨶ ᨲᩥᨭ᩠ᨮᩮᨿ᩠ᨿ, ᨶᩥᨻ᩠ᨻᩣᨶᨾᨶᩈᩮᩣ ᨶᩁᩮᩣ.

‘‘ᨾᩮᩣᩈᩅᨩ᩠ᨩᩮ ¶ ¶ ᨶ ᨶᩦᨿᩮᨳ, ᩁᩪᨸᩮ ᩈ᩠ᨶᩮᩉᩴ ᨶ ᨠᩩᨻ᩠ᨻᨿᩮ;

ᨾᩣᨶᨬ᩠ᨧ ᨸᩁᩥᨩᩣᨶᩮᨿ᩠ᨿ, ᩈᩣᩉᩈᩣ ᩅᩥᩁᨲᩮᩣ ᨧᩁᩮ.

‘‘ᨸᩩᩁᩣᨱᩴ ᨶᩣᨽᩥᨶᨶ᩠ᨴᩮᨿ᩠ᨿ, ᨶᩅᩮ ᨡᨶ᩠ᨲᩥᩴ ᨶ ᨠᩩᨻ᩠ᨻᨿᩮ;

ᩉᩥᨿ᩠ᨿᨾᩣᨶᩮ ᨶ ᩈᩮᩣᨧᩮᨿ᩠ᨿ, ᩌᨠᩣᩈᩴ ᨶ ᩈᩥᨲᩮᩣ ᩈᩥᨿᩣ.

‘‘ᨣᩮᨵᩴ ᨻᩕᩪᨾᩥ ᨾᩉᩮᩣᨥᩮᩣᨲᩥ, ᩌᨩᩅᩴ ᨻᩕᩪᨾᩥ ᨩᨸ᩠ᨸᨶᩴ;

ᩌᩁᨾ᩠ᨾᨱᩴ ᨸᨠᨸ᩠ᨸᨶᩴ, ᨠᩣᨾᨸᨦ᩠ᨠᩮᩣ ᨴᩩᩁᨧ᩠ᨧᨿᩮᩣ.

‘‘ᩈᨧ᩠ᨧᩣ ᩋᩅᩮᩣᨠ᩠ᨠᨾ᩠ᨾ [ᩋᩅᩮᩣᨠ᩠ᨠᨾᩴ (ᨶᩥᨴ᩠ᨴᩮᩈ)] ᨾᩩᨶᩥ, ᨳᩃᩮ ᨲᩥᨭ᩠ᨮᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᩈᨻ᩠ᨻᩴ ᩈᩮᩣ [ᩈᨻ᩠ᨻᩈᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨸᨭᩥᨶᩥᩔᨩ᩠ᨩ, ᩈ ᩅᩮ ᩈᨶ᩠ᨲᩮᩣᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩥ.

‘‘ᩈ ¶ ᩅᩮ ᩅᩥᨴ᩠ᩅᩣ ᩈ ᩅᩮᨴᨣᩪ, ᨬᨲ᩠ᩅᩣ ᨵᨾ᩠ᨾᩴ ᩋᨶᩥᩔᩥᨲᩮᩣ;

ᩈᨾ᩠ᨾᩣ ¶ ᩈᩮᩣ ᩃᩮᩣᨠᩮ ᩍᩁᩥᨿᩣᨶᩮᩣ, ᨶ ᨸᩥᩉᩮᨲᩦᨵ ᨠᩔᨧᩥ.

‘‘ᨿᩮᩣᨵ ᨠᩣᨾᩮ ᩋᨧ᩠ᨧᨲᩁᩥ, ᩈᨦ᩠ᨣᩴ ᩃᩮᩣᨠᩮ ᨴᩩᩁᨧ᩠ᨧᨿᩴ;

ᨶ ᩈᩮᩣ ᩈᩮᩣᨧᨲᩥ ᨶᩣᨩ᩠ᨫᩮᨲᩥ, ᨨᩥᨶ᩠ᨶᩈᩮᩣᨲᩮᩣ ᩋᨻᨶ᩠ᨵᨶᩮᩣ.

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

ᨾᨩ᩠ᨫᩮ ᨧᩮ ᨶᩮᩣ ᨣᩉᩮᩔᩈᩥ, ᩏᨸᩈᨶ᩠ᨲᩮᩣ ᨧᩁᩥᩔᩈᩥ.

‘‘ᩈᨻ᩠ᨻᩈᩮᩣ ᨶᩣᨾᩁᩪᨸᩈ᩠ᨾᩥᩴ, ᨿᩔ ᨶᨲ᩠ᨳᩥ ᨾᨾᩣᨿᩥᨲᩴ;

ᩋᩈᨲᩣ ᨧ ᨶ ᩈᩮᩣᨧᨲᩥ, ᩈ ᩅᩮ ᩃᩮᩣᨠᩮ ᨶ ᨩᩦᨿᨲᩥ.

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

ᨾᨾᨲ᩠ᨲᩴ ᩈᩮᩣ ᩋᩈᩴᩅᩥᨶ᩠ᨴᩴ, ᨶᨲ᩠ᨳᩥ ᨾᩮᨲᩥ ᨶ ᩈᩮᩣᨧᨲᩥ.

‘‘ᩋᨶᩥᨭ᩠ᨮᩩᩁᩦ ¶ ᩋᨶᨶᩩᨣᩥᨴ᩠ᨵᩮᩣ, ᩋᨶᩮᨩᩮᩣ ᩈᨻ᩠ᨻᨵᩦ ᩈᨾᩮᩣ;

ᨲᨾᩣᨶᩥᩈᩴᩈᩴ ᨸᨻᩕᩪᨾᩥ, ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᩋᩅᩥᨠᨾ᩠ᨸᩥᨶᩴ.

‘‘ᩋᨶᩮᨩᩔ ᩅᩥᨩᩣᨶᨲᩮᩣ, ᨶᨲ᩠ᨳᩥ ᨠᩣᨧᩥ ᨶᩥᩈᨦ᩠ᨡᨲᩥ [ᨶᩥᩈᨦ᩠ᨡᩥᨲᩥ (ᩈᩦ. ᨸᩦ.)].

ᩅᩥᩁᨲᩮᩣ ᩈᩮᩣ ᩅᩥᨿᩣᩁᨻ᩠ᨽᩣ, ᨡᩮᨾᩴ ᨸᩔᨲᩥ ᩈᨻ᩠ᨻᨵᩥ.

‘‘ᨶ ᩈᨾᩮᩈᩩ ᨶ ᩒᨾᩮᩈᩩ, ᨶ ᩏᩔᩮᩈᩩ ᩅᨴᨲᩮ ᨾᩩᨶᩥ;

ᩈᨶ᩠ᨲᩮᩣ ᩈᩮᩣ ᩅᩦᨲᨾᨧ᩠ᨨᩁᩮᩣ, ᨶᩣᨴᩮᨲᩥ ᨶ ᨶᩥᩁᩔᨲᩦ’’ᨲᩥ.

ᩋᨲ᩠ᨲᨴᨱ᩠ᨯᩈᩩᨲ᩠ᨲᩴ ᨸᨶ᩠ᨶᩁᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

‘‘ᨶ ¶ ¶ ¶ ᨾᩮ ᨴᩥᨭ᩠ᨮᩮᩣ ᩍᨲᩮᩣ ᨸᩩᨻ᩠ᨻᩮ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᩣ)

‘‘ᩈᨴᩮᩅᨠᩔ ᩃᩮᩣᨠᩔ, ᨿᨳᩣ ᨴᩥᩔᨲᩥ ᨧᨠ᩠ᨡᩩᨾᩣ;

ᩈᨻ᩠ᨻᩴ ᨲᨾᩴ ᩅᩥᨶᩮᩣᨴᩮᨲ᩠ᩅᩣ, ᩑᨠᩮᩣᩅ ᩁᨲᩥᨾᨩ᩠ᨫᨣᩣ.

‘‘ᨲᩴ ¶ ᨻᩩᨴ᩠ᨵᩴ ᩋᩈᩥᨲᩴ ᨲᩣᨴᩥᩴ, ᩋᨠᩩᩉᩴ ᨣᨱᩥᨾᩣᨣᨲᩴ;

ᨻᩉᩪᨶᨾᩥᨵ ᨻᨴ᩠ᨵᩣᨶᩴ, ᩋᨲ᩠ᨳᩥ ᨸᨬ᩠ᩉᩮᨶ ᩌᨣᨾᩴ.

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

ᩁᩩᨠ᩠ᨡᨾᩪᩃᩴ ᩈᩩᩈᩣᨶᩴ ᩅᩣ, ᨸᨻ᩠ᨻᨲᩣᨶᩴ ᨣᩩᩉᩣᩈᩩ ᩅᩣ.

‘‘ᩏᨧ᩠ᨧᩣᩅᨧᩮᩈᩩ ᩈᨿᨶᩮᩈᩩ, ᨠᩦᩅᨶ᩠ᨲᩮᩣ ᨲᨲ᩠ᨳ ᨽᩮᩁᩅᩣ;

ᨿᩮᩉᩥ ᨽᩥᨠ᩠ᨡᩩ ᨶ ᩅᩮᨵᩮᨿ᩠ᨿ, ᨶᩥᨣ᩠ᨥᩮᩣᩈᩮ ᩈᨿᨶᩣᩈᨶᩮ.

‘‘ᨠᨲᩦ ᨸᩁᩥᩔᨿᩣ ᩃᩮᩣᨠᩮ, ᨣᨧ᩠ᨨᨲᩮᩣ ᩋᨣᨲᩴ ᨴᩥᩈᩴ;

ᨿᩮ ᨽᩥᨠ᩠ᨡᩩ ᩋᨽᩥᩈᨾ᩠ᨽᩅᩮ, ᨸᨶ᩠ᨲᨾ᩠ᩉᩥ ᩈᨿᨶᩣᩈᨶᩮ.

‘‘ᨠ᩠ᨿᩣᩔ ᨻ᩠ᨿᨸ᩠ᨸᨳᨿᩮᩣ ᩋᩔᩩ, ᨠ᩠ᨿᩣᩔᩔᩩ ᩍᨵ ᨣᩮᩣᨧᩁᩣ;

ᨠᩣᨶᩥ ᩈᩦᩃᨻ᩠ᨻᨲᩣᨶᩣᩔᩩ, ᨸᩉᩥᨲᨲ᩠ᨲᩔ ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ.

‘‘ᨠᩴ ᩈᩮᩣ ᩈᩥᨠ᩠ᨡᩴ ᩈᨾᩣᨴᩣᨿ, ᩑᨠᩮᩣᨴᩥ ᨶᩥᨸᨠᩮᩣ ᩈᨲᩮᩣ;

ᨠᨾ᩠ᨾᩣᩁᩮᩣ ᩁᨩᨲᩔᩮᩅ, ᨶᩥᨴ᩠ᨵᨾᩮ ᨾᩃᨾᨲ᩠ᨲᨶᩮᩣ’’.

‘‘ᩅᩥᨩᩥᨣᩩᨧ᩠ᨨᨾᩣᨶᩔ ¶ ¶ ᨿᨴᩥᨴᩴ ᨹᩣᩈᩩ, (ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩣᨲᩥ ᨽᨣᩅᩣ)

‘‘ᨸᨬ᩠ᨧᨶ᩠ᨶᩴ ᨵᩦᩁᩮᩣ ᨽᨿᩣᨶᩴ ᨶ ᨽᩣᨿᩮ, ᨽᩥᨠ᩠ᨡᩩ ᩈᨲᩮᩣ ᩈᨸᩁᩥᨿᨶ᩠ᨲᨧᩣᩁᩦ;

ᨯᩴᩈᩣᨵᩥᨸᩣᨲᩣᨶᩴ ᩈᩁᩦᩈᨸᩣᨶᩴ, ᨾᨶᩩᩔᨹᩔᩣᨶᩴ ᨧᨲᩩᨸ᩠ᨸᨴᩣᨶᩴ.

‘‘ᨸᩁᨵᨾ᩠ᨾᩥᨠᩣᨶᨾ᩠ᨸᩥ ¶ ¶ ᨶ ᩈᨶ᩠ᨲᩈᩮᨿ᩠ᨿ, ᨴᩥᩈ᩠ᩅᩣᨸᩥ ᨲᩮᩈᩴ ᨻᩉᩩᨽᩮᩁᩅᩣᨶᩥ;

ᩋᨳᩣᨸᩁᩣᨶᩥ ᩋᨽᩥᩈᨾ᩠ᨽᩅᩮᨿ᩠ᨿ, ᨸᩁᩥᩔᨿᩣᨶᩥ ᨠᩩᩈᩃᩣᨶᩩᩑᩈᩦ.

‘‘ᩌᨲᨦ᩠ᨠᨹᩔᩮᨶ ᨡᩩᨴᩣᨿ ᨹᩩᨭ᩠ᨮᩮᩣ, ᩈᩦᨲᩴ ᩋᨲᩩᨱ᩠ᩉᩴ [ᩋᨧ᩠ᨧᩩᨱ᩠ᩉᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩋᨵᩥᩅᩣᩈᨿᩮᨿ᩠ᨿ;

ᩈᩮᩣ ᨲᩮᩉᩥ ᨹᩩᨭ᩠ᨮᩮᩣ ᨻᩉᩩᨵᩣ ᩋᨶᩮᩣᨠᩮᩣ, ᩅᩦᩁᩥᨿᩴ ᨸᩁᨠ᩠ᨠᨾ᩠ᨾᨴᩊ᩠ᩉᩴ ᨠᩁᩮᨿ᩠ᨿ.

‘‘ᨳᩮᨿ᩠ᨿᩴ ᨶ ᨠᩣᩁᩮ [ᨶ ᨠᩁᩮᨿ᩠ᨿ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)] ᨶ ᨾᩩᩈᩣ ᨽᨱᩮᨿ᩠ᨿ, ᨾᩮᨲ᩠ᨲᩣᨿ ᨹᩔᩮ ᨲᩈᨳᩣᩅᩁᩣᨶᩥ;

ᨿᨴᩣᩅᩥᩃᨲ᩠ᨲᩴ ᨾᨶᩈᩮᩣ ᩅᩥᨩᨬ᩠ᨬᩣ, ᨠᨱ᩠ᩉᩔ ᨸᨠ᩠ᨡᩮᩣᨲᩥ ᩅᩥᨶᩮᩣᨴᨿᩮᨿ᩠ᨿ.

‘‘ᨠᩮᩣᨵᩣᨲᩥᨾᩣᨶᩔ ¶ ᩅᩈᩴ ᨶ ᨣᨧ᩠ᨨᩮ, ᨾᩪᩃᨾ᩠ᨸᩥ ᨲᩮᩈᩴ ᨸᩃᩥᨡᨬ᩠ᨬ ᨲᩥᨭ᩠ᨮᩮ;

ᩋᨳᨸ᩠ᨸᩥᨿᩴ ᩅᩣ ᨸᨶ ᩋᨸ᩠ᨸᩥᨿᩴ ᩅᩣ, ᩋᨴ᩠ᨵᩣ ᨽᩅᨶ᩠ᨲᩮᩣ ᩋᨽᩥᩈᨾ᩠ᨽᩅᩮᨿ᩠ᨿ.

‘‘ᨸᨬ᩠ᨬᩴ ᨸᩩᩁᨠ᩠ᨡᨲ᩠ᩅᩣ ᨠᩃ᩠ᨿᩣᨱᨸᩦᨲᩥ, ᩅᩥᨠ᩠ᨡᨾ᩠ᨽᨿᩮ ᨲᩣᨶᩥ ᨸᩁᩥᩔᨿᩣᨶᩥ;

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

‘‘ᨠᩥᩴᩈᩪ ᩋᩈᩥᩔᩣᨾᩥ ᨠᩩᩅᩴ ᩅᩣ [ᨠᩩᨵ ᩅᩣ (ᨠ.), ᨠᩩᨳ ᩅᩣ (ᨶᩥᨴ᩠ᨴᩮᩈ)] ᩋᩈᩥᩔᩴ, ᨴᩩᨠ᩠ᨡᩴ ᩅᨲ ᩈᩮᨲ᩠ᨳ ᨠ᩠ᩅᨩ᩠ᨩ ᩈᩮᩔᩴ;

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

‘‘ᩋᨶ᩠ᨶᨬ᩠ᨧ ¶ ᩃᨴ᩠ᨵᩣ ᩅᩈᨶᨬ᩠ᨧ ᨠᩣᩃᩮ, ᨾᨲ᩠ᨲᩴ ᩈᩮᩣ ᨩᨬ᩠ᨬᩣ ᩍᨵ ᨲᩮᩣᩈᨶᨲ᩠ᨳᩴ;

ᩈᩮᩣ ᨲᩮᩈᩩ ᨣᩩᨲ᩠ᨲᩮᩣ ᨿᨲᨧᩣᩁᩥ ᨣᩣᨾᩮ, ᩁᩩᩈᩥᨲᩮᩣᨸᩥ ᩅᩣᨧᩴ ᨹᩁᩩᩈᩴ ᨶ ᩅᨩ᩠ᨩᩣ.

‘‘ᩒᨠ᩠ᨡᩥᨲ᩠ᨲᨧᨠ᩠ᨡᩩ ¶ ¶ ᨶ ᨧ ᨸᩣᨴᩃᩮᩣᩃᩮᩣ, ᨫᩣᨶᩣᨶᩩᨿᩩᨲ᩠ᨲᩮᩣ ᨻᩉᩩᨩᩣᨣᩁᩔ;

ᩏᨸᩮᨠ᩠ᨡᨾᩣᩁᨻ᩠ᨽ ᩈᨾᩣᩉᩥᨲᨲ᩠ᨲᩮᩣ, ᨲᨠ᩠ᨠᩣᩈᨿᩴ ᨠᩩᨠ᩠ᨠᩩᨧ᩠ᨧᩥᨿᩪᨸᨨᩥᨶ᩠ᨴᩮ.

‘‘ᨧᩩᨴᩥᨲᩮᩣ ¶ ᩅᨧᩦᨽᩥ ᩈᨲᩥᨾᩣᨽᩥᨶᨶ᩠ᨴᩮ, ᩈᨻᩕᩉ᩠ᨾᨧᩣᩁᩦᩈᩩ ᨡᩥᩃᩴ ᨸᨽᩥᨶ᩠ᨴᩮ;

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

‘‘ᩋᨳᩣᨸᩁᩴ ᨸᨬ᩠ᨧ ᩁᨩᩣᨶᩥ ᩃᩮᩣᨠᩮ, ᨿᩮᩈᩴ ᩈᨲᩦᨾᩣ ᩅᩥᨶᨿᩣᨿ ᩈᩥᨠ᩠ᨡᩮ;

ᩁᩪᨸᩮᩈᩩ ᩈᨴ᩠ᨴᩮᩈᩩ ᩋᨳᩮᩣ ᩁᩈᩮᩈᩩ, ᨣᨶ᩠ᨵᩮᩈᩩ ᨹᩔᩮᩈᩩ ᩈᩉᩮᨳ ᩁᩣᨣᩴ.

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

ᨠᩣᩃᩮᨶ ¶ ᩈᩮᩣ ᩈᨾ᩠ᨾᩣ ᨵᨾ᩠ᨾᩴ ᨸᩁᩥᩅᩦᨾᩴᩈᨾᩣᨶᩮᩣ,

ᩑᨠᩮᩣᨴᩥᨽᩪᨲᩮᩣ ᩅᩥᩉᨶᩮ ᨲᨾᩴ ᩈᩮᩣ’’ᨲᩥ.

ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩈᩩᨲ᩠ᨲᩴ ᩈᩮᩣᩊᩈᨾᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩴ.

ᨠᩣᨾᩴ ᨣᩩᩉᨬ᩠ᨧ ᨴᩩᨭ᩠ᨮᩣ ᨧ, ᩈᩩᨴ᩠ᨵᨬ᩠ᨧ ᨸᩁᨾᩣ ᨩᩁᩣ;

ᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᩮᩣ ᨧ ᨸᩈᩪᩁᩮᩣ ᨧ, ᨾᩣᨣᨱ᩠ᨯᩥ ᨸᩩᩁᩣᨽᩮᨴᨶᩴ.

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

ᩋᨲ᩠ᨲᨴᨱ᩠ᨯᩅᩁᩴ ᩈᩩᨲ᩠ᨲᩴ, ᨳᩮᩁᨸᩩᨭ᩠ᨮᩮᨶ [ᨳᩮᩁᨸᨬ᩠ᩉᩮᨶ (ᩈᩦ.), ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᨶ (ᩈ᩠ᨿᩣ.)] ᩈᩮᩣᩊᩈ;

ᩍᨲᩥ ᩑᨲᩣᨶᩥ ᩈᩩᨲ᩠ᨲᩣᨶᩥ, ᩈᨻ᩠ᨻᩣᨶᨭ᩠ᨮᨠᩅᨣ᩠ᨣᩥᨠᩣᨲᩥ.

ᨠᩮᩣᩈᩃᩣᨶᩴ ¶ ¶ ¶ ¶ ᨸᩩᩁᩣ ᩁᨾ᩠ᨾᩣ, ᩋᨣᨾᩣ ᨴᨠ᩠ᨡᩥᨱᩣᨸᨳᩴ;

ᩌᨠᩥᨬ᩠ᨧᨬ᩠ᨬᩴ ᨸᨲ᩠ᨳᨿᩣᨶᩮᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨾᨶ᩠ᨲᨸᩣᩁᨣᩪ.

ᩈᩮᩣ ᩋᩔᨠᩔ ᩅᩥᩈᨿᩮ, ᩋᩊᨠᩔ [ᨾᩩᩊᨠᩔ (ᩈ᩠ᨿᩣ.), ᨾᩪᩊ᩠ᩉᨠᩔ (ᨠ.), ᨾᩊᨠᩔ (ᨶᩥᨴ᩠ᨴᩮᩈ)] ᩈᨾᩣᩈᨶᩮ;

ᩅᩈᩥ ᨣᩮᩣᨵᩣᩅᩁᩦᨠᩪᩃᩮ, ᩏᨬ᩠ᨨᩮᨶ ᨧ ᨹᩃᩮᨶ ᨧ.

ᨲᩔᩮᩅ ᩏᨸᨶᩥᩔᩣᨿ, ᨣᩣᨾᩮᩣ ᨧ ᩅᩥᨸᩩᩃᩮᩣ ᩋᩉᩩ;

ᨲᨲᩮᩣ ᨩᩣᨲᩮᨶ ᩌᨿᩮᨶ, ᨾᩉᩣᨿᨬ᩠ᨬᨾᨠᨸ᩠ᨸᨿᩥ.

ᨾᩉᩣᨿᨬ᩠ᨬᩴ ᨿᨩᩥᨲ᩠ᩅᩣᨶ, ᨸᩩᨶ ᨸᩣᩅᩥᩈᩥ ᩋᩔᨾᩴ;

ᨲᩈ᩠ᨾᩥᩴ ᨸᨭᩥᨸᩅᩥᨭ᩠ᨮᨾ᩠ᩉᩥ, ᩋᨬ᩠ᨬᩮᩣ ᩌᨣᨬ᩠ᨨᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

ᩏᨣ᩠ᨥᨭ᩠ᨭᨸᩣᨴᩮᩣ ᨲᩈᩥᨲᩮᩣ [ᨲᩔᩥᨲᩮᩣ (ᨠ.)], ᨸᨦ᩠ᨠᨴᨶ᩠ᨲᩮᩣ ᩁᨩᩔᩥᩁᩮᩣ;

ᩈᩮᩣ ᨧ ᨶᩴ ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ, ᩈᨲᩣᨶᩥ ᨸᨬ᩠ᨧ ᨿᩣᨧᨲᩥ.

ᨲᨾᩮᨶᩴ ᨻᩣᩅᩁᩦ ᨴᩥᩈ᩠ᩅᩣ, ᩌᩈᨶᩮᨶ ᨶᩥᨾᨶ᩠ᨲᨿᩥ;

ᩈᩩᨡᨬ᩠ᨧ ᨠᩩᩈᩃᩴ ᨸᩩᨧ᩠ᨨᩥ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥ.

‘‘ᨿᩴ ᨡᩮᩣ ᨾᨾ ᨴᩮᨿ᩠ᨿᨵᨾ᩠ᨾᩴ, ᩈᨻ᩠ᨻᩴ ᩅᩥᩈᨩ᩠ᨩᩥᨲᩴ ᨾᨿᩣ;

ᩋᨶᩩᨩᩣᨶᩣᩉᩥ ᨾᩮ ᨻᩕᩉ᩠ᨾᩮ, ᨶᨲ᩠ᨳᩥ ᨸᨬ᩠ᨧᩈᨲᩣᨶᩥ ᨾᩮ’’.

‘‘ᩈᨧᩮ ¶ ᨾᩮ ᨿᩣᨧᨾᩣᨶᩔ, ᨽᩅᩴ ᨶᩣᨶᩩᨸᨴᩔᨲᩥ;

ᩈᨲ᩠ᨲᨾᩮ ᨴᩥᩅᩈᩮ ᨲᩩᨿ᩠ᩉᩴ, ᨾᩩᨴ᩠ᨵᩣ ᨹᩃᨲᩩ ᩈᨲ᩠ᨲᨵᩣ’’.

ᩋᨽᩥᩈᨦ᩠ᨡᩁᩥᨲ᩠ᩅᩣ ¶ ¶ ᨠᩩᩉᨠᩮᩣ, ᨽᩮᩁᩅᩴ ᩈᩮᩣ ᩋᨠᩥᨲ᩠ᨲᨿᩥ;

ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨻᩣᩅᩁᩦ ᨴᩩᨠ᩠ᨡᩥᨲᩮᩣ ᩋᩉᩩ.

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

ᩋᨳᩮᩣᨸᩥ ᩑᩅᩴ ᨧᩥᨲ᩠ᨲᩔ, ᨫᩣᨶᩮ ᨶ ᩁᨾᨲᩦ ᨾᨶᩮᩣ.

ᩏᨲᩕᩈ᩠ᨲᩴ ᨴᩩᨠ᩠ᨡᩥᨲᩴ ᨴᩥᩈ᩠ᩅᩣ, ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨳᨠᩣᨾᩥᨶᩦ;

ᨻᩣᩅᩁᩥᩴ ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥ.

‘‘ᨶ ¶ ᩈᩮᩣ ᨾᩩᨴ᩠ᨵᩴ ᨸᨩᩣᨶᩣᨲᩥ, ᨠᩩᩉᨠᩮᩣ ᩈᩮᩣ ᨵᨶᨲ᩠ᨳᩥᨠᩮᩣ;

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

‘‘ᨽᩮᩣᨲᩦ ᨧᩁᩉᩥ ᨩᩣᨶᩣᩈᩥ, ᨲᩴ ᨾᩮ ᩋᨠ᩠ᨡᩣᩉᩥ ᨸᩩᨧ᩠ᨨᩥᨲᩣ;

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

‘‘ᩋᩉᨾ᩠ᨸᩮᨲᩴ ᨶ ᨩᩣᨶᩣᨾᩥ, ᨬᩣᨱᨾᩮᨲ᩠ᨳ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

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

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

ᨾᩩᨴ᩠ᨵᩴ ᨾᩩᨴ᩠ᨵᩣᨵᩥᨸᩣᨲᨬ᩠ᨧ, ᨲᩴ ᨾᩮ ᩋᨠ᩠ᨡᩣᩉᩥ ᨴᩮᩅᨲᩮ’’.

‘‘ᨸᩩᩁᩣ ¶ ᨠᨸᩥᩃᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩣ, ᨶᩥᨠ᩠ᨡᨶ᩠ᨲᩮᩣ ᩃᩮᩣᨠᨶᩣᨿᨠᩮᩣ;

ᩋᨸᨧ᩠ᨧᩮᩣ ᩒᨠ᩠ᨠᩣᨠᩁᩣᨩᩔ, ᩈᨠ᩠ᨿᨸᩩᨲ᩠ᨲᩮᩣ ᨸᨽᨦ᩠ᨠᩁᩮᩣ.

‘‘ᩈᩮᩣ ᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ, ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩣᨶ ᨸᩣᩁᨣᩪ;

ᩈᨻ᩠ᨻᩣᨽᩥᨬ᩠ᨬᩣᨻᩃᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩮᩈᩩ ᨧᨠ᩠ᨡᩩᨾᩣ;

ᩈᨻ᩠ᨻᨠᨾ᩠ᨾᨠ᩠ᨡᨿᩴ ᨸᨲ᩠ᨲᩮᩣ, ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ ᩏᨸᨵᩥᨠ᩠ᨡᨿᩮ.

‘‘ᨻᩩᨴ᩠ᨵᩮᩣ ᩈᩮᩣ ᨽᨣᩅᩣ ᩃᩮᩣᨠᩮ, ᨵᨾ᩠ᨾᩴ ᨴᩮᩈᩮᨲᩥ ᨧᨠ᩠ᨡᩩᨾᩣ;

ᨲᩴ ¶ ᨲ᩠ᩅᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨸᩩᨧ᩠ᨨᩔᩩ, ᩈᩮᩣ ᨲᩮ ᨲᩴ ᨻ᩠ᨿᩣᨠᩁᩥᩔᨲᩥ’’.

ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣᨲᩥ ¶ ᩅᨧᩮᩣ ᩈᩩᨲ᩠ᩅᩣ, ᩏᨴᨣ᩠ᨣᩮᩣ ᨻᩣᩅᩁᩦ ᩋᩉᩩ;

ᩈᩮᩣᨠᩔ ᨲᨶᩩᨠᩮᩣ ᩌᩈᩥ, ᨸᩦᨲᩥᨬ᩠ᨧ ᩅᩥᨸᩩᩃᩴ ᩃᨽᩥ.

ᩈᩮᩣ ᨻᩣᩅᩁᩦ ᩋᨲ᩠ᨲᨾᨶᩮᩣ ᩏᨴᨣ᩠ᨣᩮᩣ, ᨲᩴ ᨴᩮᩅᨲᩴ ᨸᩩᨧ᩠ᨨᨲᩥ ᩅᩮᨴᨩᩣᨲᩮᩣ;

‘‘ᨠᨲᨾᨾ᩠ᩉᩥ ᨣᩣᨾᩮ ᨶᩥᨣᨾᨾ᩠ᩉᩥ ᩅᩣ ᨸᨶ, ᨠᨲᨾᨾ᩠ᩉᩥ ᩅᩣ ᨩᨶᨸᨴᩮ ᩃᩮᩣᨠᨶᩣᨳᩮᩣ;

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

‘‘ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ᨠᩮᩣᩈᩃᨾᨶ᩠ᨴᩥᩁᩮ ᨩᩥᨶᩮᩣ, ᨸᩉᩪᨲᨸᨬ᩠ᨬᩮᩣ ᩅᩁᨽᩪᩁᩥᨾᩮᨵᩈᩮᩣ;

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

ᨲᨲᩮᩣ ¶ ᩌᨾᨶ᩠ᨲᨿᩦ ᩈᩥᩔᩮ, ᨻᩕᩣᩉ᩠ᨾᨱᩮ ᨾᨶ᩠ᨲᨸᩣᩁᨣᩮ;

‘‘ᩑᨳ ᨾᩣᨱᩅᩣ ᩋᨠ᩠ᨡᩥᩔᩴ, ᩈᩩᨱᩣᨳ ᩅᨧᨶᩴ ᨾᨾ.

‘‘ᨿᩔᩮᩈᩮᩣ ¶ ᨴᩩᩃ᩠ᩃᨽᩮᩣ ᩃᩮᩣᨠᩮ, ᨸᩣᨲᩩᨽᩣᩅᩮᩣ ᩋᨽᩥᨱ᩠ᩉᩈᩮᩣ;

ᩈ᩠ᩅᩣᨩ᩠ᨩ ᩃᩮᩣᨠᨾ᩠ᩉᩥ ᩏᨸ᩠ᨸᨶ᩠ᨶᩮᩣ, ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ ᩍᨲᩥ ᩅᩥᩔᩩᨲᩮᩣ;

ᨡᩥᨸ᩠ᨸᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᩈᩣᩅᨲ᩠ᨳᩥᩴ, ᨸᩔᩅ᩠ᩉᩮᩣ ᨴ᩠ᩅᩥᨸᨴᩩᨲ᩠ᨲᨾᩴ’’.

‘‘ᨠᨳᩴ ᨧᩁᩉᩥ ᨩᩣᨶᩮᨾᩩ, ᨴᩥᩈ᩠ᩅᩣ ᨻᩩᨴ᩠ᨵᩮᩣᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱ;

ᩋᨩᩣᨶᨲᩴ ᨶᩮᩣ ᨸᨻᩕᩪᩉᩥ, ᨿᨳᩣ ᨩᩣᨶᩮᨾᩩ ᨲᩴ ᨾᨿᩴ’’.

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

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

‘‘ᨿᩔᩮᨲᩮ ᩉᩮᩣᨶ᩠ᨲᩥ ᨣᨲ᩠ᨲᩮᩈᩩ, ᨾᩉᩣᨸᩩᩁᩥᩈᩃᨠ᩠ᨡᨱᩣ;

ᨴ᩠ᩅᩮᨿᩮᩅ ᨲᩔ ᨣᨲᩥᨿᩮᩣ, ᨲᨲᩥᨿᩣ ᩉᩥ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ.

‘‘ᩈᨧᩮ ᩋᨣᩣᩁᩴ ᩌᩅᩈᨲᩥ [ᩋᨩ᩠ᨫᩣᩅᩈᨲᩥ (ᨠ.)], ᩅᩥᨩᩮᨿ᩠ᨿ ᨸᨳᩅᩥᩴ ᩍᨾᩴ;

ᩋᨴᨱ᩠ᨯᩮᨶ ᩋᩈᨲ᩠ᨳᩮᨶ, ᨵᨾ᩠ᨾᩮᨶᨾᨶᩩᩈᩣᩈᨲᩥ.

‘‘ᩈᨧᩮ ¶ ᨧ ᩈᩮᩣ ᨸᨻ᩠ᨻᨩᨲᩥ, ᩋᨣᩣᩁᩣ ᩋᨶᨣᩣᩁᩥᨿᩴ;

ᩅᩥᩅᨭ᩠ᨭᨧ᩠ᨨᨴᩮᩣ [ᩅᩥᩅᨲ᩠ᨲᨨᨴ᩠ᨴᩮᩣ (ᩈᩦ.)] ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ, ᩋᩁᩉᩣ ᨽᩅᨲᩥ ᩋᨶᩩᨲ᩠ᨲᩁᩮᩣ.

‘‘ᨩᩣᨲᩥᩴ ᨣᩮᩣᨲ᩠ᨲᨬ᩠ᨧ ᩃᨠ᩠ᨡᨱᩴ, ᨾᨶ᩠ᨲᩮ ᩈᩥᩔᩮ ᨸᩩᨶᩣᨸᩁᩮ;

ᨾᩩᨴ᩠ᨵᩴ ᨾᩩᨴ᩠ᨵᩣᨵᩥᨸᩣᨲᨬ᩠ᨧ, ᨾᨶᩈᩣᨿᩮᩅ ᨸᩩᨧ᩠ᨨᨳ.

‘‘ᩋᨶᩣᩅᩁᨱᨴᩔᩣᩅᩦ, ᨿᨴᩥ ᨻᩩᨴ᩠ᨵᩮᩣ ᨽᩅᩥᩔᨲᩥ;

ᨾᨶᩈᩣ ᨸᩩᨧ᩠ᨨᩥᨲᩮ ᨸᨬ᩠ᩉᩮ, ᩅᩣᨧᩣᨿ ᩅᩥᩔᨩᩮᩔᨲᩥ’’.

ᨻᩣᩅᩁᩥᩔ ᩅᨧᩮᩣ ᩈᩩᨲ᩠ᩅᩣ, ᩈᩥᩔᩣ ᩈᩮᩣᩊᩈ ᨻᩕᩣᩉ᩠ᨾᨱᩣ;

ᩋᨩᩥᨲᩮᩣ ᨲᩥᩔᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᩮᩣ, ᨸᩩᨱ᩠ᨱᨠᩮᩣ ᩋᨳ ᨾᩮᨲ᩠ᨲᨣᩪ.

ᨵᩮᩣᨲᨠᩮᩣ ¶ ᩏᨸᩈᩦᩅᩮᩣ ᨧ, ᨶᨶ᩠ᨴᩮᩣ ᨧ ᩋᨳ ᩉᩮᨾᨠᩮᩣ;

ᨲᩮᩣᨴᩮᨿ᩠ᨿᨠᨸ᩠ᨸᩣ ᨴᩩᨽᨿᩮᩣ, ᨩᨲᩩᨠᨱ᩠ᨱᩦ ᨧ ᨸᨱ᩠ᨯᩥᨲᩮᩣ.

ᨽᨴᩕᩣᩅᩩᨵᩮᩣ ¶ ᩏᨴᨿᩮᩣ ᨧ, ᨸᩮᩣᩈᩣᩃᩮᩣ ᨧᩣᨸᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᨾᩮᩣᨥᩁᩣᨩᩣ ᨧ ᨾᩮᨵᩣᩅᩦ, ᨸᩥᨦ᩠ᨣᩥᨿᩮᩣ ᨧ ᨾᩉᩣᩍᩈᩥ.

ᨸᨧ᩠ᨧᩮᨠᨣᨱᩥᨶᩮᩣ ᩈᨻ᩠ᨻᩮ, ᩈᨻ᩠ᨻᩃᩮᩣᨠᩔ ᩅᩥᩔᩩᨲᩣ;

ᨫᩣᨿᩦ ᨫᩣᨶᩁᨲᩣ ᨵᩦᩁᩣ, ᨸᩩᨻ᩠ᨻᩅᩣᩈᨶᩅᩣᩈᩥᨲᩣ.

ᨻᩣᩅᩁᩥᩴ ¶ ᩋᨽᩥᩅᩣᨴᩮᨲ᩠ᩅᩣ, ᨠᨲ᩠ᩅᩣ ᨧ ᨶᩴ ᨸᨴᨠ᩠ᨡᩥᨱᩴ;

ᨩᨭᩣᨩᩥᨶᨵᩁᩣ ᩈᨻ᩠ᨻᩮ, ᨸᨠ᩠ᨠᩣᨾᩩᩴ ᩏᨲ᩠ᨲᩁᩣᨾᩩᨡᩣ.

ᩋᩊᨠᩔ ᨸᨲᩥᨭ᩠ᨮᩣᨶᩴ, ᨸᩩᩁᩥᨾᩣᩉᩥᩔᨲᩥᩴ [ᨸᩩᩁᩥᨾᩴ ᨾᩣᩉᩥᩔᨲᩥᩴ (ᩈᩦ. ᨸᩦ.), ᨸᩩᩁᩴ ᨾᩣᩉᩥᩔᨲᩥᩴ (ᩈ᩠ᨿᩣ.)] ᨲᨴᩣ;

ᩏᨩ᩠ᨩᩮᨶᩥᨬ᩠ᨧᩣᨸᩥ ᨣᩮᩣᨶᨴ᩠ᨵᩴ, ᩅᩮᨴᩥᩈᩴ ᩅᨶᩈᩅ᩠ᩉᨿᩴ.

ᨠᩮᩣᩈᨾ᩠ᨻᩥᨬ᩠ᨧᩣᨸᩥ ᩈᩣᨠᩮᨲᩴ, ᩈᩣᩅᨲ᩠ᨳᩥᨬ᩠ᨧ ᨸᩩᩁᩩᨲ᩠ᨲᨾᩴ;

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

ᨸᩣᩅᨬ᩠ᨧ ¶ ᨽᩮᩣᨣᨶᨣᩁᩴ, ᩅᩮᩈᩣᩃᩥᩴ ᨾᩣᨣᨵᩴ ᨸᩩᩁᩴ;

ᨸᩣᩈᩣᨱᨠᩴ ᨧᩮᨲᩥᨿᨬ᩠ᨧ, ᩁᨾᨱᩦᨿᩴ ᨾᨶᩮᩣᩁᨾᩴ.

ᨲᩈᩥᨲᩮᩣᩅᩩᨴᨠᩴ ¶ ᩈᩦᨲᩴ, ᨾᩉᩣᩃᩣᨽᩴᩅ ᩅᩣᨱᩥᨩᩮᩣ;

ᨨᩣᨿᩴ ᨥᨾ᩠ᨾᩣᨽᩥᨲᨲ᩠ᨲᩮᩣᩅ, ᨲᩩᩁᩥᨲᩣ ᨸᨻ᩠ᨻᨲᨾᩣᩁᩩᩉᩩᩴ.

ᨽᨣᩅᩣ ᨲᨾ᩠ᩉᩥ ᩈᨾᨿᩮ, ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ;

ᨽᩥᨠ᩠ᨡᩪᨶᩴ ᨵᨾ᩠ᨾᩴ ᨴᩮᩈᩮᨲᩥ, ᩈᩦᩉᩮᩣᩅ ᨶᨴᨲᩦ ᩅᨶᩮ.

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

ᨧᨶ᩠ᨴᩴ ᨿᨳᩣ ᨸᨶ᩠ᨶᩁᩈᩮ, ᨸᩣᩁᩥᨸᩪᩁᩥᩴ ᩏᨸᩣᨣᨲᩴ.

ᩋᨳᩔ ᨣᨲ᩠ᨲᩮ ᨴᩥᩈ᩠ᩅᩣᨶ, ᨸᩁᩥᨸᩪᩁᨬ᩠ᨧ ᨻ᩠ᨿᨬ᩠ᨩᨶᩴ;

ᩑᨠᨾᨶ᩠ᨲᩴ ᨮᩥᨲᩮᩣ ᩉᨭ᩠ᨮᩮᩣ, ᨾᨶᩮᩣᨸᨬ᩠ᩉᩮ ᩋᨸᩩᨧ᩠ᨨᨳ.

‘‘ᩌᨴᩥᩔ ᨩᨾ᩠ᨾᨶᩴ [ᨩᨸ᩠ᨸᨶᩴ (ᨠ.)] ᨻᩕᩪᩉᩥ, ᨣᩮᩣᨲ᩠ᨲᩴ ᨻᩕᩪᩉᩥ ᩈᩃᨠ᩠ᨡᨱᩴ [ᨻᩕᩪᩉᩥᩔ ᩃᨠ᩠ᨡᨱᩴ (ᨶᩥᨴ᩠ᨴᩮᩈ)];

ᨾᨶ᩠ᨲᩮᩈᩩ ᨸᩣᩁᨾᩥᩴ ᨻᩕᩪᩉᩥ, ᨠᨲᩥ ᩅᩣᨧᩮᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ’’.

‘‘ᩅᩦᩈᩴ ᩅᩔᩈᨲᩴ ᩌᨿᩩ, ᩈᩮᩣ ᨧ ᨣᩮᩣᨲ᩠ᨲᩮᨶ ᨻᩣᩅᩁᩦ;

ᨲᩦᨱᩥᩔ ᩃᨠ᩠ᨡᨱᩣ ᨣᨲ᩠ᨲᩮ, ᨲᩥᨱ᩠ᨱᩴ ᩅᩮᨴᩣᨶ ᨸᩣᩁᨣᩪ.

‘‘ᩃᨠ᩠ᨡᨱᩮ ¶ ¶ ᩍᨲᩥᩉᩣᩈᩮ ᨧ, ᩈᨶᩥᨥᨱ᩠ᨯᩩᩈᨠᩮᨭᩩᨽᩮ;

ᨸᨬ᩠ᨧᩈᨲᩣᨶᩥ ᩅᩣᨧᩮᨲᩥ, ᩈᨵᨾ᩠ᨾᩮ ᨸᩣᩁᨾᩥᩴ ᨣᨲᩮᩣ’’.

‘‘ᩃᨠ᩠ᨡᨱᩣᨶᩴ ¶ ᨸᩅᩥᨧᨿᩴ, ᨻᩣᩅᩁᩥᩔ ᨶᩁᩩᨲ᩠ᨲᨾ;

ᨠᨦ᩠ᨡᨧ᩠ᨨᩥᨴ [ᨲᨱ᩠ᩉᨧ᩠ᨨᩥᨴ (ᨻᩉᩪᩈᩩ)] ᨸᨠᩣᩈᩮᩉᩥ, ᨾᩣ ᨶᩮᩣ ᨠᨦ᩠ᨡᩣᨿᩥᨲᩴ ᩋᩉᩩ’’.

‘‘ᨾᩩᨡᩴ ᨩᩥᩅ᩠ᩉᩣᨿ ᨨᩣᨴᩮᨲᩥ, ᩏᨱ᩠ᨱᩔ ᨽᨾᩩᨠᨶ᩠ᨲᩁᩮ;

ᨠᩮᩣᩈᩮᩣᩉᩥᨲᩴ ᩅᨲ᩠ᨳᨣᩩᨿ᩠ᩉᩴ, ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨾᩣᨱᩅ’’.

ᨸᩩᨧ᩠ᨨᨬ᩠ᩉᩥ ¶ ᨠᩥᨬ᩠ᨧᩥ ᩋᩈᩩᨱᨶ᩠ᨲᩮᩣ, ᩈᩩᨲ᩠ᩅᩣ ᨸᨬ᩠ᩉᩮ ᩅᩥᨿᩣᨠᨲᩮ;

ᩅᩥᨧᩥᨶ᩠ᨲᩮᨲᩥ ᨩᨶᩮᩣ ᩈᨻ᩠ᨻᩮᩣ, ᩅᩮᨴᨩᩣᨲᩮᩣ ᨠᨲᨬ᩠ᨩᩃᩦ.

‘‘ᨠᩮᩣ ᨶᩩ ᨴᩮᩅᩮᩣ ᩅᩣ ᨻᩕᩉ᩠ᨾᩣ ᩅᩣ, ᩍᨶ᩠ᨴᩮᩣ ᩅᩣᨸᩥ ᩈᩩᨩᨾ᩠ᨸᨲᩥ;

ᨾᨶᩈᩣ ᨸᩩᨧ᩠ᨨᩥᨲᩮ ᨸᨬ᩠ᩉᩮ, ᨠᨾᩮᨲᩴ ᨸᨭᩥᨽᩣᩈᨲᩥ.

‘‘ᨾᩩᨴ᩠ᨵᩴ ᨾᩩᨴ᩠ᨵᩣᨵᩥᨸᩣᨲᨬ᩠ᨧ, ᨻᩣᩅᩁᩦ ᨸᩁᩥᨸᩩᨧ᩠ᨨᨲᩥ;

ᨲᩴ ᨻ᩠ᨿᩣᨠᩁᩮᩣᩉᩥ ᨽᨣᩅᩣ, ᨠᨦ᩠ᨡᩴ ᩅᩥᨶᨿ ᨶᩮᩣ ᩍᩈᩮ’’.

‘‘ᩋᩅᩥᨩ᩠ᨩᩣ ᨾᩩᨴ᩠ᨵᩣᨲᩥ ᨩᩣᨶᩣᩉᩥ, ᩅᩥᨩ᩠ᨩᩣ ᨾᩩᨴ᩠ᨵᩣᨵᩥᨸᩣᨲᩥᨶᩦ;

ᩈᨴ᩠ᨵᩣᩈᨲᩥᩈᨾᩣᨵᩦᩉᩥ, ᨨᨶ᩠ᨴᩅᩦᩁᩥᨿᩮᨶ ᩈᩴᨿᩩᨲᩣ’’.

ᨲᨲᩮᩣ ᩅᩮᨴᩮᨶ ᨾᩉᨲᩣ, ᩈᨶ᩠ᨳᨾ᩠ᨽᩥᨲ᩠ᩅᩣᨶ ᨾᩣᨱᩅᩮᩣ;

ᩑᨠᩴᩈᩴ ᩋᨩᩥᨶᩴ ᨠᨲ᩠ᩅᩣ, ᨸᩣᨴᩮᩈᩩ ᩈᩥᩁᩈᩣ ᨸᨲᩥ.

‘‘ᨻᩣᩅᩁᩦ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨽᩮᩣᨲᩮᩣ, ᩈᩉ ᩈᩥᩔᩮᩉᩥ ᨾᩣᩁᩥᩈ;

ᩏᨴᨣ᩠ᨣᨧᩥᨲ᩠ᨲᩮᩣ ᩈᩩᨾᨶᩮᩣ, ᨸᩣᨴᩮ ᩅᨶ᩠ᨴᨲᩥ ᨧᨠ᩠ᨡᩩᨾ’’.

‘‘ᩈᩩᨡᩥᨲᩮᩣ ¶ ᨻᩣᩅᩁᩦ ᩉᩮᩣᨲᩩ, ᩈᩉ ᩈᩥᩔᩮᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᨲ᩠ᩅᨬ᩠ᨧᩣᨸᩥ ᩈᩩᨡᩥᨲᩮᩣ ᩉᩮᩣᩉᩥ, ᨧᩥᩁᩴ ᨩᩦᩅᩣᩉᩥ ᨾᩣᨱᩅ.

‘‘ᨻᩣᩅᩁᩥᩔ ¶ ᨧ ᨲᩩᨿ᩠ᩉᩴ ᩅᩣ, ᩈᨻ᩠ᨻᩮᩈᩴ ᩈᨻ᩠ᨻᩈᩴᩈᨿᩴ;

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

ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᨶ ᨠᨲᩮᩣᨠᩣᩈᩮᩣ, ᨶᩥᩈᩦᨴᩥᨲ᩠ᩅᩣᨶ ᨸᨬ᩠ᨩᩃᩦ;

ᩋᨩᩥᨲᩮᩣ ᨸᨮᨾᩴ ᨸᨬ᩠ᩉᩴ, ᨲᨲ᩠ᨳ ᨸᩩᨧ᩠ᨨᩥ ᨲᨳᩣᨣᨲᩴ.

‘‘ᨠᩮᨶᩔᩩ ¶ ¶ ᨶᩥᩅᩩᨲᩮᩣ ᩃᩮᩣᨠᩮᩣ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᩋᨩᩥᨲᩮᩣ)

ᨠᩥᩔᩣᨽᩥᩃᩮᨸᨶᩴ ᨻᩕᩪᩈᩥ, ᨠᩥᩴᩈᩩ ᨲᩔ ᨾᩉᨻ᩠ᨽᨿᩴ’’.

‘‘ᩋᩅᩥᨩ᩠ᨩᩣᨿ ᨶᩥᩅᩩᨲᩮᩣ ᩃᩮᩣᨠᩮᩣ, (ᩋᨩᩥᨲᩣᨲᩥ ᨽᨣᩅᩣ)

ᨩᨸ᩠ᨸᩣᨽᩥᩃᩮᨸᨶᩴ ᨻᩕᩪᨾᩥ, ᨴᩩᨠ᩠ᨡᨾᩔ ᨾᩉᨻ᩠ᨽᨿᩴ’’.

‘‘ᩈᩅᨶ᩠ᨲᩥ ¶ ᩈᨻ᩠ᨻᨵᩥ ᩈᩮᩣᨲᩣ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᩋᨩᩥᨲᩮᩣ)

ᩈᩮᩣᨲᩣᨶᩴ ᩈᩴᩅᩁᩴ ᨻᩕᩪᩉᩥ, ᨠᩮᨶ ᩈᩮᩣᨲᩣ ᨸᩥᨵᩥᨿ᩠ᨿᩁᩮ’’ [ᨸᩥᨳᩥᨿ᩠ᨿᩁᩮ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.), ᨸᩥᨳᩦᨿᩁᩮ (ᩈᩦ. ᩋᨭ᩠ᨮ.), ᨸᩥᨵᩦᨿᩁᩮ (?)].

‘‘ᨿᩣᨶᩥ ᩈᩮᩣᨲᩣᨶᩥ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ, (ᩋᨩᩥᨲᩣᨲᩥ ᨽᨣᩅᩣ)

ᩈᩮᩣᨲᩣᨶᩴ ᩈᩴᩅᩁᩴ ᨻᩕᩪᨾᩥ, ᨸᨬ᩠ᨬᩣᨿᩮᨲᩮ ᨸᩥᨵᩥᨿ᩠ᨿᩁᩮ’’.

‘‘ᨸᨬ᩠ᨬᩣ ᨧᩮᩅ ᩈᨲᩥ ᨿᨬ᩠ᨧ [ᩈᨲᩦ ᨧᩮᩅ (ᩈᩦ.), ᩈᨲᩦ ᨧ (ᩈ᩠ᨿᩣ.), ᩈᨲᩦ ᨧᩣᨸᩥ (ᨸᩦ. ᨶᩥᨴ᩠ᨴᩮᩈ), ᩈᨲᩥ ᨧᩣᨸᩥ (ᨶᩥᨴ᩠ᨴᩮᩈ)], (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᩋᨩᩥᨲᩮᩣ)

ᩑᨲᩴ ¶ ᨾᩮ ᨸᩩᨭ᩠ᨮᩮᩣ ᨸᨻᩕᩪᩉᩥ, ᨠᨲ᩠ᨳᩮᨲᩴ ᩏᨸᩁᩩᨩ᩠ᨫᨲᩥ’’.

‘‘ᨿᨾᩮᨲᩴ ᨸᨬ᩠ᩉᩴ ᩋᨸᩩᨧ᩠ᨨᩥ, ᩋᨩᩥᨲ ᨲᩴ ᩅᨴᩣᨾᩥ ᨲᩮ;

ᨿᨲ᩠ᨳ ᨶᩣᨾᨬ᩠ᨧ ᩁᩪᨸᨬ᩠ᨧ, ᩋᩈᩮᩈᩴ ᩏᨸᩁᩩᨩ᩠ᨫᨲᩥ;

ᩅᩥᨬ᩠ᨬᩣᨱᩔ ᨶᩥᩁᩮᩣᨵᩮᨶ, ᩑᨲ᩠ᨳᩮᨲᩴ ᩏᨸᩁᩩᨩ᩠ᨫᨲᩥ’’.

‘‘ᨿᩮ ᨧ ᩈᨦ᩠ᨡᩣᨲᨵᨾ᩠ᨾᩣᩈᩮ, ᨿᩮ ᨧ ᩈᩮᨡᩣ ᨸᩩᨳᩪ ᩍᨵ;

ᨲᩮᩈᩴ ᨾᩮ ᨶᩥᨸᨠᩮᩣ ᩍᩁᩥᨿᩴ, ᨸᩩᨭ᩠ᨮᩮᩣ ᨸᨻᩕᩪᩉᩥ ᨾᩣᩁᩥᩈ’’.

‘‘ᨠᩣᨾᩮᩈᩩ ¶ ᨶᩣᨽᩥᨣᩥᨩ᩠ᨫᩮᨿ᩠ᨿ, ᨾᨶᩈᩣᨶᩣᩅᩥᩃᩮᩣ ᩈᩥᨿᩣ;

ᨠᩩᩈᩃᩮᩣ ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩣᨶᩴ, ᩈᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ ᨸᩁᩥᨻ᩠ᨻᨩᩮ’’ᨲᩥ.

ᩋᨩᩥᨲᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨸᨮᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨠᩮᩣᨵ ¶ ¶ ᩈᨶ᩠ᨲᩩᩈᩥᨲᩮᩣ ᩃᩮᩣᨠᩮ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨲᩥᩔᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᩮᩣ)

ᨠᩮᩣ ᩏᨽᨶ᩠ᨲᨾᨽᩥᨬ᩠ᨬᩣᨿ, ᨾᨩ᩠ᨫᩮ ᨾᨶ᩠ᨲᩣ ᨶ ᩃᩥᨸ᩠ᨸᨲᩥ [ᩃᩥᨾ᩠ᨸᨲᩥ (ᨠ.)];

ᨠᩴ ᨻᩕᩪᩈᩥ ᨾᩉᩣᨸᩩᩁᩥᩈᩮᩣᨲᩥ, ᨠᩮᩣ ᩍᨵ ᩈᩥᨻ᩠ᨻᩥᨶᩥᨾᨧ᩠ᨧᨣᩣ’’.

‘‘ᨠᩣᨾᩮᩈᩩ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩅᩣ, (ᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᩈᨦ᩠ᨡᩣᨿ ¶ ᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ ᨽᩥᨠ᩠ᨡᩩ, ᨲᩔ ᨶᩮᩣ ᩈᨶ᩠ᨲᩥ ᩍᨬ᩠ᨩᩥᨲᩣ.

‘‘ᩈᩮᩣ ᩏᨽᨶ᩠ᨲᨾᨽᩥᨬ᩠ᨬᩣᨿ, ᨾᨩ᩠ᨫᩮ ᨾᨶ᩠ᨲᩣ ᨶ ᩃᩥᨸ᩠ᨸᨲᩥ;

ᨲᩴ ᨻᩕᩪᨾᩥ ᨾᩉᩣᨸᩩᩁᩥᩈᩮᩣᨲᩥ, ᩈᩮᩣ ᩍᨵ ᩈᩥᨻ᩠ᨻᩥᨶᩥᨾᨧ᩠ᨧᨣᩣ’’ᨲᩥ.

ᨲᩥᩔᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨴᩩᨲᩥᨿᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᩋᨶᩮᨩᩴ ᨾᩪᩃᨴᩔᩣᩅᩥᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨸᩩᨱ᩠ᨱᨠᩮᩣ)

ᩋᨲ᩠ᨳᩥ [ᩋᨲ᩠ᨳᩦ (ᩈ᩠ᨿᩣ.)] ᨸᨬ᩠ᩉᩮᨶ ᩌᨣᨾᩴ;

ᨠᩥᩴ ¶ ᨶᩥᩔᩥᨲᩣ ¶ ᩍᩈᨿᩮᩣ ᨾᨶᩩᨩᩣ, ᨡᨲ᩠ᨲᩥᨿᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᨴᩮᩅᨲᩣᨶᩴ;

ᨿᨬ᩠ᨬᨾᨠᨸ᩠ᨸᨿᩥᩴᩈᩩ ᨸᩩᨳᩪᨵ ᩃᩮᩣᨠᩮ, ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ’’.

‘‘ᨿᩮ ᨠᩮᨧᩥᨾᩮ ᩍᩈᨿᩮᩣ ᨾᨶᩩᨩᩣ, (ᨸᩩᨱ᩠ᨱᨠᩣᨲᩥ ᨽᨣᩅᩣ)

ᨿᨬ᩠ᨬᨾᨠᨸ᩠ᨸᨿᩥᩴᩈᩩ ᨸᩩᨳᩪᨵ ᩃᩮᩣᨠᩮ, ᩌᩈᩦᩈᨾᩣᨶᩣ ᨸᩩᨱ᩠ᨱᨠ ᩍᨲ᩠ᨳᨲ᩠ᨲᩴ [ᩍᨲ᩠ᨳᨽᩣᩅᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

‘‘ᨿᩮ ¶ ᨠᩮᨧᩥᨾᩮ ᩍᩈᨿᩮᩣ ᨾᨶᩩᨩᩣ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨸᩩᨱ᩠ᨱᨠᩮᩣ)

ᨿᨬ᩠ᨬᨾᨠᨸ᩠ᨸᨿᩥᩴᩈᩩ ¶ ᨸᩩᨳᩪᨵ ᩃᩮᩣᨠᩮ, ᨠᨧ᩠ᨧᩥᩔᩩ ᨲᩮ ᨽᨣᩅᩣ ᨿᨬ᩠ᨬᨸᨳᩮ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩣ;

ᩋᨲᩣᩁᩩᩴ ᨩᩣᨲᩥᨬ᩠ᨧ ᨩᩁᨬ᩠ᨧ ᨾᩣᩁᩥᩈ, ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ’’.

‘‘ᩌᩈᩦᩈᨶ᩠ᨲᩥ ᨳᩮᩣᨾᨿᨶ᩠ᨲᩥ, ᩋᨽᩥᨩᨸ᩠ᨸᨶ᩠ᨲᩥ ᨩᩩᩉᨶ᩠ᨲᩥ; (ᨸᩩᨱ᩠ᨱᨠᩣᨲᩥ ᨽᨣᩅᩣ)

ᨠᩣᨾᩣᨽᩥᨩᨸ᩠ᨸᨶ᩠ᨲᩥ ᨸᨭᩥᨧ᩠ᨧ ᩃᩣᨽᩴ, ᨲᩮ ᨿᩣᨩᨿᩮᩣᨣᩣ ᨽᩅᩁᩣᨣᩁᨲ᩠ᨲᩣ;

‘‘ᨲᩮ ¶ ᨧᩮ ᨶᩣᨲᩁᩥᩴᩈᩩ ᨿᩣᨩᨿᩮᩣᨣᩣ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨸᩩᨱ᩠ᨱᨠᩮᩣ)

ᩋᨳ ᨠᩮᩣ ᨧᩁᩉᩥ ᨴᩮᩅᨾᨶᩩᩔᩃᩮᩣᨠᩮ, ᩋᨲᩣᩁᩥ ᨩᩣᨲᩥᨬ᩠ᨧ ᨩᩁᨬ᩠ᨧ ᨾᩣᩁᩥᩈ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ’’.

‘‘ᩈᨦ᩠ᨡᩣᨿ ᩃᩮᩣᨠᩈ᩠ᨾᩥ ᨸᩁᩮᩣᨸᩁᩣᨶᩥ [ᨸᩁᩮᩣᩅᩁᩣᨶᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], (ᨸᩩᨱ᩠ᨱᨠᩣᨲᩥ ᨽᨣᩅᩣ)

ᨿᩔᩥᨬ᩠ᨩᩥᨲᩴ ᨶᨲ᩠ᨳᩥ ᨠᩩᩉᩥᨬ᩠ᨧᩥ ᩃᩮᩣᨠᩮ;

ᩈᨶ᩠ᨲᩮᩣ ᩅᩥᨵᩪᨾᩮᩣ ᩋᨶᩦᨥᩮᩣ ᨶᩥᩁᩣᩈᩮᩣ, ᩋᨲᩣᩁᩥ ᩈᩮᩣ ᨩᩣᨲᩥᨩᩁᨶ᩠ᨲᩥ ᨻᩕᩪᨾᩦ’’ᨲᩥ.

ᨸᩩᨱ᩠ᨱᨠᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨲᨲᩥᨿᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ¶ ¶ ᨲᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨾᩮᨲ᩠ᨲᨣᩪ)

ᨠᩩᨲᩮᩣ ᨶᩩ ᨴᩩᨠ᩠ᨡᩣ ᩈᨾᩩᨴᩣᨣᨲᩣ ᩍᨾᩮ, ᨿᩮ ᨠᩮᨧᩥ ᩃᩮᩣᨠᩈ᩠ᨾᩥᨾᨶᩮᨠᩁᩪᨸᩣ’’.

‘‘ᨴᩩᨠ᩠ᨡᩔ ¶ ¶ ᩅᩮ ᨾᩴ ᨸᨽᩅᩴ ᩋᨸᩩᨧ᩠ᨨᩈᩥ, (ᨾᩮᨲ᩠ᨲᨣᩪᨲᩥ ᨽᨣᩅᩣ)

ᩏᨸᨵᩥᨶᩥᨴᩣᨶᩣ ᨸᨽᩅᨶ᩠ᨲᩥ ᨴᩩᨠ᩠ᨡᩣ, ᨿᩮ ᨠᩮᨧᩥ ᩃᩮᩣᨠᩈ᩠ᨾᩥᨾᨶᩮᨠᩁᩪᨸᩣ.

‘‘ᨿᩮᩣ ᩅᩮ ᩋᩅᩥᨴ᩠ᩅᩣ ᩏᨸᨵᩥᩴ ᨠᩁᩮᩣᨲᩥ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ ᨴᩩᨠ᩠ᨡᨾᩩᨸᩮᨲᩥ ᨾᨶ᩠ᨴᩮᩣ;

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

‘‘ᨿᩴ ᨲᩴ ᩋᨸᩩᨧ᩠ᨨᩥᨾ᩠ᩉ ᩋᨠᩥᨲ᩠ᨲᨿᩦ ᨶᩮᩣ, ᩋᨬ᩠ᨬᩴ ᨲᩴ ᨸᩩᨧ᩠ᨨᩣᨾ [ᨸᩩᨧ᩠ᨨᩣᨾᩥ (ᩈᩦ. ᨸᩦ.)] ᨲᨴᩥᨦ᩠ᨥ ᨻᩕᩪᩉᩥ;

ᨠᨳᩴ ᨶᩩ ᨵᩦᩁᩣ ᩅᩥᨲᩁᨶ᩠ᨲᩥ ᩒᨥᩴ, ᨩᩣᨲᩥᩴ ᨩᩁᩴ ᩈᩮᩣᨠᨸᩁᩥᨴ᩠ᨴᩅᨬ᩠ᨧ;

ᨲᩴ ᨾᩮ ᨾᩩᨶᩥ ᩈᩣᨵᩩ ᩅᩥᨿᩣᨠᩁᩮᩣᩉᩥ, ᨲᨳᩣ ᩉᩥ ᨲᩮ ᩅᩥᨴᩥᨲᩮᩣ ᩑᩈ ᨵᨾ᩠ᨾᩮᩣ’’.

‘‘ᨠᩥᨲ᩠ᨲᨿᩥᩔᩣᨾᩥ ¶ ᨲᩮ ᨵᨾ᩠ᨾᩴ, (ᨾᩮᨲ᩠ᨲᨣᩪᨲᩥ ᨽᨣᩅᩣ)

ᨿᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᩈᨲᩮᩣ ᨧᩁᩴ, ᨲᩁᩮ ᩃᩮᩣᨠᩮ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩴ’’.

‘‘ᨲᨬ᩠ᨧᩣᩉᩴ ᩋᨽᩥᨶᨶ᩠ᨴᩣᨾᩥ, ᨾᩉᩮᩈᩥ ᨵᨾ᩠ᨾᨾᩩᨲ᩠ᨲᨾᩴ;

ᨿᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᩈᨲᩮᩣ ᨧᩁᩴ, ᨲᩁᩮ ᩃᩮᩣᨠᩮ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩴ’’.

‘‘ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᩈᨾ᩠ᨸᨩᩣᨶᩣᩈᩥ, (ᨾᩮᨲ᩠ᨲᨣᩪᨲᩥ ᨽᨣᩅᩣ)

ᩑᨲᩮᩈᩩ ¶ ᨶᨶ᩠ᨴᩥᨬ᩠ᨧ ᨶᩥᩅᩮᩈᨶᨬ᩠ᨧ, ᨸᨶᩩᨩ᩠ᨩ ᩅᩥᨬ᩠ᨬᩣᨱᩴ ᨽᩅᩮ ᨶ ᨲᩥᨭ᩠ᨮᩮ.

‘‘ᩑᩅᩴᩅᩥᩉᩣᩁᩦ ¶ ᩈᨲᩮᩣ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ, ᨽᩥᨠ᩠ᨡᩩ ᨧᩁᩴ ᩉᩥᨲ᩠ᩅᩣ ᨾᨾᩣᨿᩥᨲᩣᨶᩥ;

ᨩᩣᨲᩥᩴ ᨩᩁᩴ ᩈᩮᩣᨠᨸᩁᩥᨴ᩠ᨴᩅᨬ᩠ᨧ, ᩍᨵᩮᩅ ᩅᩥᨴ᩠ᩅᩣ ᨸᨩᩉᩮᨿ᩠ᨿ ᨴᩩᨠ᩠ᨡᩴ’’.

‘‘ᩑᨲᩣᨽᩥᨶᨶ᩠ᨴᩣᨾᩥ ¶ ᩅᨧᩮᩣ ᨾᩉᩮᩈᩥᨶᩮᩣ, ᩈᩩᨠᩥᨲ᩠ᨲᩥᨲᩴ ᨣᩮᩣᨲᨾᨶᩪᨸᨵᩦᨠᩴ;

ᩋᨴ᩠ᨵᩣ ᩉᩥ ᨽᨣᩅᩣ ᨸᩉᩣᩈᩥ ᨴᩩᨠ᩠ᨡᩴ, ᨲᨳᩣ ᩉᩥ ᨲᩮ ᩅᩥᨴᩥᨲᩮᩣ ᩑᩈ ᨵᨾ᩠ᨾᩮᩣ.

‘‘ᨲᩮ ᨧᩣᨸᩥ ᨶᩪᨶᨸ᩠ᨸᨩᩉᩮᨿ᩠ᨿᩩ ᨴᩩᨠ᩠ᨡᩴ, ᨿᩮ ᨲ᩠ᩅᩴ ᨾᩩᨶᩥ ᩋᨭ᩠ᨮᩥᨲᩴ ᩒᩅᨴᩮᨿ᩠ᨿ;

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

‘‘ᨿᩴ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᩅᩮᨴᨣᩩᨾᩣᨽᩥᨩᨬ᩠ᨬᩣ, ᩋᨠᩥᨬ᩠ᨧᨶᩴ ᨠᩣᨾᨽᩅᩮ ᩋᩈᨲ᩠ᨲᩴ;

ᩋᨴ᩠ᨵᩣ ᩉᩥ ᩈᩮᩣ ᩒᨥᨾᩥᨾᩴ ᩋᨲᩣᩁᩥ, ᨲᩥᨱ᩠ᨱᩮᩣ ᨧ ᨸᩣᩁᩴ ᩋᨡᩥᩃᩮᩣ ᩋᨠᨦ᩠ᨡᩮᩣ.

‘‘ᩅᩥᨴ᩠ᩅᩣ ᨧ ᨿᩮᩣ [ᩈᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩅᩮᨴᨣᩪ ᨶᩁᩮᩣ ᩍᨵ, ᨽᩅᩣᨽᩅᩮ ᩈᨦ᩠ᨣᨾᩥᨾᩴ ᩅᩥᩈᨩ᩠ᨩ;

ᩈᩮᩣ ¶ ᩅᩦᨲᨲᨱ᩠ᩉᩮᩣ ᩋᨶᩦᨥᩮᩣ ᨶᩥᩁᩣᩈᩮᩣ, ᩋᨲᩣᩁᩥ ᩈᩮᩣ ᨩᩣᨲᩥᨩᩁᨶ᩠ᨲᩥ ᨻᩕᩪᨾᩦ’’ᨲᩥ.

ᨾᩮᨲ᩠ᨲᨣᩪᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨧᨲᩩᨲ᩠ᨳᩦ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨵᩮᩣᨲᨠᩮᩣ)

ᨲᩅ ᩈᩩᨲ᩠ᩅᩣᨶ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩴ, ᩈᩥᨠ᩠ᨡᩮ ᨶᩥᨻ᩠ᨻᩣᨶᨾᨲ᩠ᨲᨶᩮᩣ’’.

‘‘ᨲᩮᨶᩉᩣᨲᨸ᩠ᨸᩴ ᨠᩁᩮᩣᩉᩥ, (ᨵᩮᩣᨲᨠᩣᨲᩥ ᨽᨣᩅᩣ) ᩍᨵᩮᩅ ᨶᩥᨸᨠᩮᩣ ᩈᨲᩮᩣ;

ᩍᨲᩮᩣ ᩈᩩᨲ᩠ᩅᩣᨶ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩴ, ᩈᩥᨠ᩠ᨡᩮ ᨶᩥᨻ᩠ᨻᩣᨶᨾᨲ᩠ᨲᨶᩮᩣ’’.

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

ᨲᩴ ᨲᩴ ᨶᨾᩔᩣᨾᩥ ᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩩ, ᨸᨾᩩᨬ᩠ᨧ ¶ ᨾᩴ ᩈᨠ᩠ᨠ ᨠᨳᩴᨠᨳᩣᩉᩥ’’.

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

ᨵᨾ᩠ᨾᨬ᩠ᨧ ᩈᩮᨭ᩠ᨮᩴ ᩋᨽᩥᨩᩣᨶᨾᩣᨶᩮᩣ [ᩌᨩᩣᨶᨾᩣᨶᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)], ᩑᩅᩴ ᨲᩩᩅᩴ ᩒᨥᨾᩥᨾᩴ ᨲᩁᩮᩈᩥ’’.

‘‘ᩋᨶᩩᩈᩣᩈ ᨻᩕᩉ᩠ᨾᩮ ᨠᩁᩩᨱᩣᨿᨾᩣᨶᩮᩣ, ᩅᩥᩅᩮᨠᨵᨾ᩠ᨾᩴ ᨿᨾᩉᩴ ᩅᩥᨩᨬ᩠ᨬᩴ;

ᨿᨳᩣᩉᩴ ¶ ᩌᨠᩣᩈᩮᩣᩅ ᩋᨻ᩠ᨿᩣᨸᨩ᩠ᨩᨾᩣᨶᩮᩣ, ᩍᨵᩮᩅ ᩈᨶ᩠ᨲᩮᩣ ᩋᩈᩥᨲᩮᩣ ᨧᩁᩮᨿ᩠ᨿᩴ’’.

‘‘ᨠᩥᨲ᩠ᨲᨿᩥᩔᩣᨾᩥ ᨲᩮ ᩈᨶ᩠ᨲᩥᩴ, (ᨵᩮᩣᨲᨠᩣᨲᩥ ᨽᨣᩅᩣ) ᨴᩥᨭ᩠ᨮᩮ ᨵᨾ᩠ᨾᩮ ᩋᨶᩦᨲᩥᩉᩴ;

ᨿᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᩈᨲᩮᩣ ᨧᩁᩴ, ᨲᩁᩮ ᩃᩮᩣᨠᩮ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩴ’’.

‘‘ᨲᨬ᩠ᨧᩣᩉᩴ ᩋᨽᩥᨶᨶ᩠ᨴᩣᨾᩥ, ᨾᩉᩮᩈᩥ ᩈᨶ᩠ᨲᩥᨾᩩᨲ᩠ᨲᨾᩴ;

ᨿᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᩈᨲᩮᩣ ᨧᩁᩴ, ᨲᩁᩮ ᩃᩮᩣᨠᩮ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩴ’’.

‘‘ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᩈᨾ᩠ᨸᨩᩣᨶᩣᩈᩥ, (ᨵᩮᩣᨲᨠᩣᨲᩥ ᨽᨣᩅᩣ)

ᩑᨲᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᩈᨦ᩠ᨣᩮᩣᨲᩥ ᩃᩮᩣᨠᩮ, ᨽᩅᩣᨽᩅᩣᨿ ᨾᩣᨠᩣᩈᩥ ᨲᨱ᩠ᩉ’’ᨶ᩠ᨲᩥ.

ᨵᩮᩣᨲᨠᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨸᨬ᩠ᨧᨾᩦ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᩑᨠᩮᩣ ¶ ᩋᩉᩴ ᩈᨠ᩠ᨠ ᨾᩉᨶ᩠ᨲᨾᩮᩣᨥᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᩏᨸᩈᩦᩅᩮᩣ)

ᩌᩁᨾ᩠ᨾᨱᩴ ᨻᩕᩪᩉᩥ ᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩩ, ᨿᩴ ᨶᩥᩔᩥᨲᩮᩣ ᩒᨥᨾᩥᨾᩴ ᨲᩁᩮᨿ᩠ᨿᩴ’’.

‘‘ᩌᨠᩥᨬ᩠ᨧᨬ᩠ᨬᩴ ¶ ᨸᩮᨠ᩠ᨡᨾᩣᨶᩮᩣ ᩈᨲᩥᨾᩣ, (ᩏᨸᩈᩦᩅᩣᨲᩥ ᨽᨣᩅᩣ)

ᨠᩣᨾᩮ ¶ ᨸᩉᩣᨿ ᩅᩥᩁᨲᩮᩣ ᨠᨳᩣᩉᩥ, ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᩴ ᨶᨲ᩠ᨲᨾᩉᩣᨽᩥᨸᩔ’’ [ᩁᨲ᩠ᨲᨾᩉᩣᨽᩥᨸᩔ (ᩈ᩠ᨿᩣ.), ᩁᨲ᩠ᨲᨾᩉᩴ ᩅᩥᨸᩔ (ᨠ.)].

‘‘ᩈᨻ᩠ᨻᩮᩈᩩ ¶ ᨠᩣᨾᩮᩈᩩ ᨿᩮᩣ ᩅᩦᨲᩁᩣᨣᩮᩣ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᩏᨸᩈᩦᩅᩮᩣ)

ᩌᨠᩥᨬ᩠ᨧᨬ᩠ᨬᩴ ᨶᩥᩔᩥᨲᩮᩣ ᩉᩥᨲ᩠ᩅᩣ ᨾᨬ᩠ᨬᩴ;

ᩈᨬ᩠ᨬᩣᩅᩥᨾᩮᩣᨠ᩠ᨡᩮ ᨸᩁᨾᩮ ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ [ᨵᩥᨾᩩᨲ᩠ᨲᩮᩣ (ᨠ.)], ᨲᩥᨭ᩠ᨮᩮ ᨶᩩ ᩈᩮᩣ ᨲᨲ᩠ᨳ ᩋᨶᩣᨶᩩᨿᩣᨿᩦ’’ [ᩋᨶᩣᨶᩩᩅᩣᨿᩦ (ᩈ᩠ᨿᩣ. ᨠ.)].

‘‘ᩈᨻ᩠ᨻᩮᩈᩩ ᨠᩣᨾᩮᩈᩩ ᨿᩮᩣ ᩅᩦᨲᩁᩣᨣᩮᩣ, (ᩏᨸᩈᩦᩅᩣᨲᩥ ᨽᨣᩅᩣ)

ᩌᨠᩥᨬ᩠ᨧᨬ᩠ᨬᩴ ᨶᩥᩔᩥᨲᩮᩣ ᩉᩥᨲ᩠ᩅᩣ ᨾᨬ᩠ᨬᩴ;

ᩈᨬ᩠ᨬᩣᩅᩥᨾᩮᩣᨠ᩠ᨡᩮ ᨸᩁᨾᩮ ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ, ᨲᩥᨭ᩠ᨮᩮᨿ᩠ᨿ ᩈᩮᩣ ᨲᨲ᩠ᨳ ᩋᨶᩣᨶᩩᨿᩣᨿᩦ’’.

‘‘ᨲᩥᨭ᩠ᨮᩮ ᨧᩮ ᩈᩮᩣ ᨲᨲ᩠ᨳ ᩋᨶᩣᨶᩩᨿᩣᨿᩦ, ᨸᩪᨣᨾ᩠ᨸᩥ ¶ ᩅᩔᩣᨶᩴ ᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩩ;

ᨲᨲ᩠ᨳᩮᩅ ᩈᩮᩣ ᩈᩦᨲᩥᩈᩥᨿᩣ ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ, ᨧᩅᩮᨳ ᩅᩥᨬ᩠ᨬᩣᨱᩴ ᨲᨳᩣᩅᩥᨵᩔ’’.

‘‘ᩋᨧ᩠ᨧᩦ ᨿᨳᩣ ᩅᩣᨲᩅᩮᨣᩮᨶ ᨡᩥᨲ᩠ᨲᩣ [ᨡᩥᨲ᩠ᨲᩴ (ᩈ᩠ᨿᩣ.), ᨡᩥᨲ᩠ᨲᩮᩣ (ᨸᩦ.)], (ᩏᨸᩈᩦᩅᩣᨲᩥ ᨽᨣᩅᩣ)

ᩑᩅᩴ ¶ ᨾᩩᨶᩦ ᨶᩣᨾᨠᩣᨿᩣ ᩅᩥᨾᩩᨲ᩠ᨲᩮᩣ, ᩋᨲ᩠ᨳᩴ ᨸᩃᩮᨲᩥ ᨶ ᩏᨸᩮᨲᩥ ᩈᨦ᩠ᨡᩴ’’.

‘‘ᩋᨲ᩠ᨳᨦ᩠ᨣᨲᩮᩣ ᩈᩮᩣ ᩏᨴ ᩅᩣ ᩈᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩏᨴᩣᩉᩩ ᩅᩮ ᩈᩔᨲᩥᨿᩣ ᩋᩁᩮᩣᨣᩮᩣ;

ᨲᩴ ᨾᩮ ᨾᩩᨶᩦ ᩈᩣᨵᩩ ᩅᩥᨿᩣᨠᩁᩮᩣᩉᩥ, ᨲᨳᩣ ᩉᩥ ᨲᩮ ᩅᩥᨴᩥᨲᩮᩣ ᩑᩈ ᨵᨾ᩠ᨾᩮᩣ’’.

‘‘ᩋᨲ᩠ᨳᨦ᩠ᨣᨲᩔ ¶ ᨶ ᨸᨾᩣᨱᨾᨲ᩠ᨳᩥ, (ᩏᨸᩈᩦᩅᩣᨲᩥ ᨽᨣᩅᩣ)

ᩈᨻ᩠ᨻᩮᩈᩩ ᨵᨾ᩠ᨾᩮᩈᩩ ᩈᨾᩪᩉᨲᩮᩈᩩ, ᩈᨾᩪᩉᨲᩣ ᩅᩣᨴᨸᨳᩣᨸᩥ ᩈᨻ᩠ᨻᩮ’’ᨲᩥ.

ᩏᨸᩈᩦᩅᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨨᨭ᩠ᨮᩦ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᩈᨶ᩠ᨲᩥ ¶ ᩃᩮᩣᨠᩮ ᨾᩩᨶᨿᩮᩣ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨶᨶ᩠ᨴᩮᩣ)

ᨬᩣᨱᩪᨸᨸᨶ᩠ᨶᩴ ¶ ᨶᩮᩣ ᨾᩩᨶᩥᩴ [ᨾᩩᨶᩥ ᨶᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩅᨴᨶ᩠ᨲᩥ, ᩏᨴᩣᩉᩩ ᩅᩮ ᨩᩦᩅᩥᨲᩮᨶᩪᨸᨸᨶ᩠ᨶᩴ’’.

‘‘ᨶ ᨴᩥᨭ᩠ᨮᩥᨿᩣ ᨶ ᩈᩩᨲᩥᨿᩣ ᨶ ᨬᩣᨱᩮᨶ, (ᨶ ᩈᩦᩃᨻ᩠ᨻᨲᩮᨶ) [( ) ᨶᨲ᩠ᨳᩥ ᩈᩦ.-ᨸᩦ ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ]

ᩅᩥᩈᩮᨶᩥᨠᨲ᩠ᩅᩣ ¶ ᩋᨶᩦᨥᩣ ᨶᩥᩁᩣᩈᩣ, ᨧᩁᨶ᩠ᨲᩥ ᨿᩮ ᨲᩮ ᨾᩩᨶᨿᩮᩣᨲᩥ ᨻᩕᩪᨾᩥ’’.

‘‘ᨿᩮ ᨠᩮᨧᩥᨾᩮ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣᩈᩮ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨶᨶ᩠ᨴᩮᩣ)

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

ᩈᩦᩃᨻ᩠ᨻᨲᩮᨶᩣᨸᩥ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ, ᩋᨶᩮᨠᩁᩪᨸᩮᨶ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ;

ᨠᨧ᩠ᨧᩥᩔᩩ ᨲᩮ ᨽᨣᩅᩣ ᨲᨲ᩠ᨳ ᨿᨲᩣ ᨧᩁᨶ᩠ᨲᩣ, ᩋᨲᩣᩁᩩ ᨩᩣᨲᩥᨬ᩠ᨧ ᨩᩁᨬ᩠ᨧ ᨾᩣᩁᩥᩈ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ’’.

‘‘ᨿᩮ ¶ ᨠᩮᨧᩥᨾᩮ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣᩈᩮ, (ᨶᨶ᩠ᨴᩣᨲᩥ ᨽᨣᩅᩣ)

ᨴᩥᨭ᩠ᨮᩔᩩᨲᩮᨶᩣᨸᩥ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ;

ᩈᩦᩃᨻ᩠ᨻᨲᩮᨶᩣᨸᩥ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ, ᩋᨶᩮᨠᩁᩪᨸᩮᨶ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ;

ᨠᩥᨬ᩠ᨧᩣᨸᩥ ᨲᩮ ᨲᨲ᩠ᨳ ᨿᨲᩣ ᨧᩁᨶ᩠ᨲᩥ, ᨶᩣᩁᩥᩴᩈᩩ ᨩᩣᨲᩥᨩᩁᨶ᩠ᨲᩥ ᨻᩕᩪᨾᩥ’’.

‘‘ᨿᩮ ¶ ᨠᩮᨧᩥᨾᩮ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣᩈᩮ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨶᨶ᩠ᨴᩮᩣ)

ᨴᩥᨭ᩠ᨮᩔᩩᨲᩮᨶᩣᨸᩥ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ;

ᩈᩦᩃᨻ᩠ᨻᨲᩮᨶᩣᨸᩥ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ, ᩋᨶᩮᨠᩁᩪᨸᩮᨶ ᩅᨴᨶ᩠ᨲᩥ ᩈᩩᨴ᩠ᨵᩥᩴ;

ᨲᩮ ᨧᩮ ᨾᩩᨶᩥ [ᩈᨧᩮ ᨾᩩᨶᩥ (ᩈᩦ.)] ᨻᩕᩪᩈᩥ ᩋᨶᩮᩣᨥᨲᩥᨱ᩠ᨱᩮ, ᩋᨳ ¶ ᨠᩮᩣ ᨧᩁᩉᩥ ᨴᩮᩅᨾᨶᩩᩔᩃᩮᩣᨠᩮ;

ᩋᨲᩣᩁᩥ ᨩᩣᨲᩥᨬ᩠ᨧ ᨩᩁᨬ᩠ᨧ ᨾᩣᩁᩥᩈ, ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ’’.

‘‘ᨶᩣᩉᩴ ᩈᨻ᩠ᨻᩮ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣᩈᩮ, (ᨶᨶ᩠ᨴᩣᨲᩥ ᨽᨣᩅᩣ)

ᨿᩮ ¶ ᩈᩦᨵ ᨴᩥᨭ᩠ᨮᩴᩅ ᩈᩩᨲᩴ ᨾᩩᨲᩴ ᩅᩣ, ᩈᩦᩃᨻ᩠ᨻᨲᩴ ᩅᩣᨸᩥ ᨸᩉᩣᨿ ᩈᨻ᩠ᨻᩴ;

ᩋᨶᩮᨠᩁᩪᨸᨾ᩠ᨸᩥ ᨸᩉᩣᨿ ᩈᨻ᩠ᨻᩴ, ᨲᨱ᩠ᩉᩴ ᨸᩁᩥᨬ᩠ᨬᩣᨿ ᩋᨶᩣᩈᩅᩣᩈᩮ;

‘‘ᩑᨲᩣᨽᩥᨶᨶ᩠ᨴᩣᨾᩥ ᩅᨧᩮᩣ ᨾᩉᩮᩈᩥᨶᩮᩣ, ᩈᩩᨠᩥᨲ᩠ᨲᩥᨲᩴ ᨣᩮᩣᨲᨾᨶᩪᨸᨵᩦᨠᩴ;

ᨿᩮ ᩈᩦᨵ ᨴᩥᨭ᩠ᨮᩴ ᩅ ᩈᩩᨲᩴ ᨾᩩᨲᩴ ᩅᩣ, ᩈᩦᩃᨻ᩠ᨻᨲᩴ ᩅᩣᨸᩥ ᨸᩉᩣᨿ ᩈᨻ᩠ᨻᩴ;

ᩋᨶᩮᨠᩁᩪᨸᨾ᩠ᨸᩥ ¶ ᨸᩉᩣᨿ ᩈᨻ᩠ᨻᩴ, ᨲᨱ᩠ᩉᩴ ᨸᩁᩥᨬ᩠ᨬᩣᨿ ᩋᨶᩣᩈᩅᩣᩈᩮ;

ᩋᩉᨾ᩠ᨸᩥ ᨲᩮ ᩒᨥᨲᩥᨱ᩠ᨱᩣᨲᩥ ᨻᩕᩪᨾᩦ’’ᨲᩥ.

ᨶᨶ᩠ᨴᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᩈᨲ᩠ᨲᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨿᩮ ¶ ᨾᩮ ᨸᩩᨻ᩠ᨻᩮ ᩅᩥᨿᩣᨠᩴᩈᩩ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᩉᩮᨾᨠᩮᩣ)

ᩍᨧ᩠ᨧᩣᩈᩥ ᩍᨲᩥ ᨽᩅᩥᩔᨲᩥ, ᩈᨻ᩠ᨻᩴ ᨲᩴ ᩍᨲᩥᩉᩦᨲᩥᩉᩴ;

ᩈᨻ᩠ᨻᩴ ᨲᩴ ᨲᨠ᩠ᨠᩅᨯ᩠ᨰᨶᩴ, ᨶᩣᩉᩴ ᨲᨲ᩠ᨳ ᩋᨽᩥᩁᨾᩥᩴ.

‘‘ᨲ᩠ᩅᨬ᩠ᨧ ᨾᩮ ᨵᨾ᩠ᨾᨾᨠ᩠ᨡᩣᩉᩥ, ᨲᨱ᩠ᩉᩣᨶᩥᨣ᩠ᨥᩣᨲᨶᩴ ᨾᩩᨶᩥ;

ᨿᩴ ᩅᩥᨴᩥᨲ᩠ᩅᩣ ᩈᨲᩮᩣ ᨧᩁᩴ, ᨲᩁᩮ ᩃᩮᩣᨠᩮ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩴ’’.

‘‘ᩍᨵ ᨴᩥᨭ᩠ᨮᩈᩩᨲᨾᩩᨲᩅᩥᨬ᩠ᨬᩣᨲᩮᩈᩩ, ᨸᩥᨿᩁᩪᨸᩮᩈᩩ ᩉᩮᨾᨠ;

ᨨᨶ᩠ᨴᩁᩣᨣᩅᩥᨶᩮᩣᨴᨶᩴ, ᨶᩥᨻ᩠ᨻᩣᨶᨸᨴᨾᨧ᩠ᨧᩩᨲᩴ.

‘‘ᩑᨲᨴᨬ᩠ᨬᩣᨿ ᨿᩮ ᩈᨲᩣ, ᨴᩥᨭ᩠ᨮᨵᨾ᩠ᨾᩣᨽᩥᨶᩥᨻ᩠ᨻᩩᨲᩣ;

ᩏᨸᩈᨶ᩠ᨲᩣ ᨧ ᨲᩮ ᩈᨴᩣ, ᨲᩥᨱ᩠ᨱᩣ ᩃᩮᩣᨠᩮ ᩅᩥᩈᨲ᩠ᨲᩥᨠ’’ᨶ᩠ᨲᩥ.

ᩉᩮᨾᨠᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᩋᨭ᩠ᨮᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨿᩈ᩠ᨾᩥᩴ ¶ ¶ ᨠᩣᨾᩣ ᨶ ᩅᩈᨶ᩠ᨲᩥ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨲᩮᩣᨴᩮᨿ᩠ᨿᩮᩣ)

ᨠᨳᩴᨠᨳᩣ ᨧ ᨿᩮᩣ ᨲᩥᨱ᩠ᨱᩮᩣ, ᩅᩥᨾᩮᩣᨠ᩠ᨡᩮᩣ ᨲᩔ ᨠᩦᨴᩥᩈᩮᩣ’’.

‘‘ᨿᩈ᩠ᨾᩥᩴ ¶ ᨠᩣᨾᩣ ᨶ ᩅᩈᨶ᩠ᨲᩥ, (ᨲᩮᩣᨴᩮᨿ᩠ᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᨠᨳᩴᨠᨳᩣ ᨧ ᨿᩮᩣ ᨲᩥᨱ᩠ᨱᩮᩣ, ᩅᩥᨾᩮᩣᨠ᩠ᨡᩮᩣ ᨲᩔ ᨶᩣᨸᩁᩮᩣ’’.

‘‘ᨶᩥᩁᩣᩈᩈᩮᩣ ᩈᩮᩣ ᩏᨴ ᩌᩈᩈᩣᨶᩮᩣ, ᨸᨬ᩠ᨬᩣᨱᩅᩣ ᩈᩮᩣ ᩏᨴ ᨸᨬ᩠ᨬᨠᨸ᩠ᨸᩦ;

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

‘‘ᨶᩥᩁᩣᩈᩈᩮᩣ ¶ ᩈᩮᩣ ᨶ ᨧ ᩌᩈᩈᩣᨶᩮᩣ, ᨸᨬ᩠ᨬᩣᨱᩅᩣ ᩈᩮᩣ ᨶ ᨧ ᨸᨬ᩠ᨬᨠᨸ᩠ᨸᩦ;

ᩑᩅᨾ᩠ᨸᩥ ᨲᩮᩣᨴᩮᨿ᩠ᨿ ᨾᩩᨶᩥᩴ ᩅᩥᨩᩣᨶ, ᩋᨠᩥᨬ᩠ᨧᨶᩴ ᨠᩣᨾᨽᩅᩮ ᩋᩈᨲ᩠ᨲ’’ᨶ᩠ᨲᩥ.

ᨲᩮᩣᨴᩮᨿ᩠ᨿᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨶᩅᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨾᨩ᩠ᨫᩮ ¶ ᩈᩁᩈ᩠ᨾᩥᩴ ᨲᩥᨭ᩠ᨮᨲᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨠᨸ᩠ᨸᩮᩣ)

ᨩᩁᩣᨾᨧ᩠ᨧᩩᨸᩁᩮᨲᩣᨶᩴ, ᨴᩦᨸᩴ ᨸᨻᩕᩪᩉᩥ ᨾᩣᩁᩥᩈ;

ᨲ᩠ᩅᨬ᩠ᨧ ᨾᩮ ᨴᩦᨸᨾᨠ᩠ᨡᩣᩉᩥ, ᨿᨳᩣᨿᩥᨴᩴ ᨶᩣᨸᩁᩴ ᩈᩥᨿᩣ’’.

‘‘ᨾᨩ᩠ᨫᩮ ¶ ¶ ᩈᩁᩈ᩠ᨾᩥᩴ ᨲᩥᨭ᩠ᨮᨲᩴ, (ᨠᨸ᩠ᨸᩣᨲᩥ ᨽᨣᩅᩣ)

ᨩᩁᩣᨾᨧ᩠ᨧᩩᨸᩁᩮᨲᩣᨶᩴ, ᨴᩦᨸᩴ ᨸᨻᩕᩪᨾᩥ ᨠᨸ᩠ᨸ ᨲᩮ.

‘‘ᩋᨠᩥᨬ᩠ᨧᨶᩴ ᩋᨶᩣᨴᩣᨶᩴ, ᩑᨲᩴ ᨴᩦᨸᩴ ᩋᨶᩣᨸᩁᩴ;

ᨶᩥᨻ᩠ᨻᩣᨶᩴ ᩍᨲᩥ [ᨶᩥᨻ᩠ᨻᩣᨶᨾᩦᨲᩥ (ᩈᩦ.)] ᨶᩴ ᨻᩕᩪᨾᩥ, ᨩᩁᩣᨾᨧ᩠ᨧᩩᨸᩁᩥᨠ᩠ᨡᨿᩴ.

‘‘ᩑᨲᨴᨬ᩠ᨬᩣᨿ ᨿᩮ ᩈᨲᩣ, ᨴᩥᨭ᩠ᨮᨵᨾ᩠ᨾᩣᨽᩥᨶᩥᨻ᩠ᨻᩩᨲᩣ;

ᨶ ᨲᩮ ᨾᩣᩁᩅᩈᩣᨶᩩᨣᩣ, ᨶ ᨲᩮ ᨾᩣᩁᩔ ᨸᨴ᩠ᨵᨣᩪ’’ᨲᩥ [ᨸᨭ᩠ᨮᨣᩪᨲᩥ (ᩈ᩠ᨿᩣ. ᨠ.)].

ᨠᨸ᩠ᨸᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨴᩈᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᩈᩩᨲ᩠ᩅᩣᨶᩉᩴ ᩅᩦᩁᨾᨠᩣᨾᨠᩣᨾᩥᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨩᨲᩩᨠᨱ᩠ᨱᩥ)

ᩈᨶ᩠ᨲᩥᨸᨴᩴ ᨻᩕᩪᩉᩥ ᩈᩉᨩᨶᩮᨲ᩠ᨲ, ᨿᨳᩣᨲᨧ᩠ᨨᩴ ¶ ᨽᨣᩅᩣ ᨻᩕᩪᩉᩥ ᨾᩮ ᨲᩴ.

‘‘ᨽᨣᩅᩣ ¶ ᩉᩥ ᨠᩣᨾᩮ ᩋᨽᩥᨽᩩᨿ᩠ᨿ ᩍᩁᩥᨿᨲᩥ, ᩌᨴᩥᨧ᩠ᨧᩮᩣᩅ ᨸᨳᩅᩥᩴ ᨲᩮᨩᩦ ᨲᩮᨩᩈᩣ;

ᨸᩁᩥᨲ᩠ᨲᨸᨬ᩠ᨬᩔ ᨾᩮ ᨽᩪᩁᩥᨸᨬ᩠ᨬ, ᩌᨧᩥᨠ᩠ᨡ ᨵᨾ᩠ᨾᩴ ᨿᨾᩉᩴ ᩅᩥᨩᨬ᩠ᨬᩴ;

‘‘ᨠᩣᨾᩮᩈᩩ ¶ ᩅᩥᨶᨿ ᨣᩮᨵᩴ, (ᨩᨲᩩᨠᨱ᩠ᨱᩦᨲᩥ ᨽᨣᩅᩣ) ᨶᩮᨠ᩠ᨡᨾ᩠ᨾᩴ ᨴᨭ᩠ᨮᩩ ᨡᩮᨾᨲᩮᩣ;

ᩏᨣ᩠ᨣᩉᩦᨲᩴ ᨶᩥᩁᨲ᩠ᨲᩴ ᩅᩣ, ᨾᩣ ᨲᩮ ᩅᩥᨩ᩠ᨩᩥᨲ᩠ᨳ ᨠᩥᨬ᩠ᨧᨶᩴ.

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

ᨾᨩ᩠ᨫᩮ ᨧᩮ ᨶᩮᩣ ᨣᩉᩮᩔᩈᩥ, ᩏᨸᩈᨶ᩠ᨲᩮᩣ ᨧᩁᩥᩔᩈᩥ.

‘‘ᩈᨻ᩠ᨻᩈᩮᩣ ¶ ᨶᩣᨾᩁᩪᨸᩈ᩠ᨾᩥᩴ, ᩅᩦᨲᨣᩮᨵᩔ ᨻᩕᩣᩉ᩠ᨾᨱ;

ᩌᩈᩅᩣᩔ ᨶ ᩅᩥᨩ᩠ᨩᨶ᩠ᨲᩥ, ᨿᩮᩉᩥ ᨾᨧ᩠ᨧᩩᩅᩈᩴ ᩅᨩᩮ’’ᨲᩥ.

ᨩᨲᩩᨠᨱ᩠ᨱᩥᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᩑᨠᩣᨴᩈᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᩒᨠᨬ᩠ᨩᩉᩴ ᨲᨱ᩠ᩉᨧ᩠ᨨᩥᨴᩴ ᩋᨶᩮᨩᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨽᨴᩕᩣᩅᩩᨵᩮᩣ)

ᨶᨶ᩠ᨴᩥᨬ᩠ᨩᩉᩴ ᩒᨥᨲᩥᨱ᩠ᨱᩴ ᩅᩥᨾᩩᨲ᩠ᨲᩴ;

ᨠᨸ᩠ᨸᨬ᩠ᨩᩉᩴ ᩋᨽᩥᨿᩣᨧᩮ ᩈᩩᨾᩮᨵᩴ, ᩈᩩᨲ᩠ᩅᩣᨶ ¶ ᨶᩣᨣᩔ ᩋᨸᨶᨾᩥᩔᨶ᩠ᨲᩥ ᩍᨲᩮᩣ.

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

ᨲᩮᩈᩴ ᨲᩩᩅᩴ ᩈᩣᨵᩩ ᩅᩥᨿᩣᨠᩁᩮᩣᩉᩥ, ᨲᨳᩣ ᩉᩥ ᨲᩮ ᩅᩥᨴᩥᨲᩮᩣ ᩑᩈ ᨵᨾ᩠ᨾᩮᩣ’’.

‘‘ᩌᨴᩣᨶᨲᨱ᩠ᩉᩴ ᩅᩥᨶᨿᩮᨳ ᩈᨻ᩠ᨻᩴ, (ᨽᨴᩕᩣᩅᩩᨵᩣᨲᩥ ᨽᨣᩅᩣ)

ᨿᩴ ¶ ᨿᨬ᩠ᩉᩥ ᩃᩮᩣᨠᩈ᩠ᨾᩥᨾᩩᨸᩣᨴᩥᨿᨶ᩠ᨲᩥ, ᨲᩮᨶᩮᩅ ᨾᩣᩁᩮᩣ ᩋᨶ᩠ᩅᩮᨲᩥ ᨩᨶ᩠ᨲᩩᩴ.

‘‘ᨲᩈ᩠ᨾᩣ ¶ ᨸᨩᩣᨶᩴ ᨶ ᩏᨸᩣᨴᩥᨿᩮᨳ, ᨽᩥᨠ᩠ᨡᩩ ᩈᨲᩮᩣ ᨠᩥᨬ᩠ᨧᨶᩴ ᩈᨻ᩠ᨻᩃᩮᩣᨠᩮ;

ᩌᨴᩣᨶᩈᨲ᩠ᨲᩮ ᩍᨲᩥ ᨸᩮᨠ᩠ᨡᨾᩣᨶᩮᩣ, ᨸᨩᩴ ᩍᨾᩴ ᨾᨧ᩠ᨧᩩᨵᩮᨿ᩠ᨿᩮ ᩅᩥᩈᨲ᩠ᨲ’’ᨶ᩠ᨲᩥ.

ᨽᨴᩕᩣᩅᩩᨵᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨴ᩠ᩅᩣᨴᩈᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨫᩣᨿᩥᩴ ¶ ᩅᩥᩁᨩᨾᩣᩈᩦᨶᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᩏᨴᨿᩮᩣ) ᨠᨲᨠᩥᨧ᩠ᨧᩴ ᩋᨶᩣᩈᩅᩴ;

ᨸᩣᩁᨣᩩᩴ ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩣᨶᩴ, ᩋᨲ᩠ᨳᩥ ᨸᨬ᩠ᩉᩮᨶ ᩌᨣᨾᩴ;

ᩋᨬ᩠ᨬᩣᩅᩥᨾᩮᩣᨠ᩠ᨡᩴ ᨸᨻᩕᩪᩉᩥ, ᩋᩅᩥᨩ᩠ᨩᩣᨿ ᨸᨽᩮᨴᨶᩴ’’.

‘‘ᨸᩉᩣᨶᩴ ¶ ᨠᩣᨾᨧ᩠ᨨᨶ᩠ᨴᩣᨶᩴ, (ᩏᨴᨿᩣᨲᩥ ᨽᨣᩅᩣ) ᨴᩮᩣᨾᨶᩔᩣᨶ ᨧᩪᨽᨿᩴ;

ᨳᩥᨶᩔ ᨧ ᨸᨶᩪᨴᨶᩴ, ᨠᩩᨠ᩠ᨠᩩᨧ᩠ᨧᩣᨶᩴ ᨶᩥᩅᩣᩁᨱᩴ.

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

ᩋᨬ᩠ᨬᩣᩅᩥᨾᩮᩣᨠ᩠ᨡᩴ ᨸᨻᩕᩪᨾᩥ, ᩋᩅᩥᨩ᩠ᨩᩣᨿ ᨸᨽᩮᨴᨶᩴ’’.

‘‘ᨠᩥᩴᩈᩩ ¶ ᩈᩴᨿᩮᩣᨩᨶᩮᩣ ᩃᩮᩣᨠᩮᩣ, ᨠᩥᩴᩈᩩ ᨲᩔ ᩅᩥᨧᩣᩁᨱᩴ;

ᨠᩥᩔᩔ ᩅᩥᨸ᩠ᨸᩉᩣᨶᩮᨶ, ᨶᩥᨻ᩠ᨻᩣᨶᩴ ᩍᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩥ’’.

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

ᨲᨱ᩠ᩉᩣᨿ ᩅᩥᨸ᩠ᨸᩉᩣᨶᩮᨶ, ᨶᩥᨻ᩠ᨻᩣᨶᩴ ᩍᨲᩥ ᩅᩩᨧ᩠ᨧᨲᩥ’’.

‘‘ᨠᨳᩴ ᩈᨲᩔ ᨧᩁᨲᩮᩣ, ᩅᩥᨬ᩠ᨬᩣᨱᩴ ᩏᨸᩁᩩᨩ᩠ᨫᨲᩥ;

ᨽᨣᩅᨶ᩠ᨲᩴ ᨸᩩᨭ᩠ᨮᩩᨾᩣᨣᨾ᩠ᨾ, ᨲᩴ ᩈᩩᨱᩮᩣᨾ ᩅᨧᩮᩣ ᨲᩅ’’.

‘‘ᩋᨩ᩠ᨫᨲ᩠ᨲᨬ᩠ᨧ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ, ᩅᩮᨴᨶᩴ ᨶᩣᨽᩥᨶᨶ᩠ᨴᨲᩮᩣ;

ᩑᩅᩴ ᩈᨲᩔ ᨧᩁᨲᩮᩣ, ᩅᩥᨬ᩠ᨬᩣᨱᩴ ᩏᨸᩁᩩᨩ᩠ᨫᨲᩦ’’ᨲᩥ.

ᩏᨴᨿᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨲᩮᩁᩈᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨿᩮᩣ ¶ ¶ ᩋᨲᩦᨲᩴ ᩌᨴᩥᩈᨲᩥ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨸᩮᩣᩈᩣᩃᩮᩣ) ᩋᨶᩮᨩᩮᩣ ᨨᩥᨶ᩠ᨶᩈᩴᩈᨿᩮᩣ;

ᨸᩣᩁᨣᩩᩴ ᩈᨻ᩠ᨻᨵᨾ᩠ᨾᩣᨶᩴ, ᩋᨲ᩠ᨳᩥ ᨸᨬ᩠ᩉᩮᨶ ᩌᨣᨾᩴ.

‘‘ᩅᩥᨽᩪᨲᩁᩪᨸᩈᨬ᩠ᨬᩥᩔ ¶ , ᩈᨻ᩠ᨻᨠᩣᨿᨸ᩠ᨸᩉᩣᨿᩥᨶᩮᩣ;

ᩋᨩ᩠ᨫᨲ᩠ᨲᨬ᩠ᨧ ᨻᩉᩥᨴ᩠ᨵᩣ ᨧ, ᨶᨲ᩠ᨳᩥ ᨠᩥᨬ᩠ᨧᩦᨲᩥ ᨸᩔᨲᩮᩣ;

ᨬᩣᨱᩴ ᩈᨠ᩠ᨠᩣᨶᩩᨸᩩᨧ᩠ᨨᩣᨾᩥ, ᨠᨳᩴ ᨶᩮᨿ᩠ᨿᩮᩣ ᨲᨳᩣᩅᩥᨵᩮᩣ’’.

‘‘ᩅᩥᨬ᩠ᨬᩣᨱᨭ᩠ᨮᩥᨲᩥᨿᩮᩣ ¶ ᩈᨻ᩠ᨻᩣ, (ᨸᩮᩣᩈᩣᩃᩣᨲᩥ ᨽᨣᩅᩣ) ᩋᨽᩥᨩᩣᨶᩴ ᨲᨳᩣᨣᨲᩮᩣ;

ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᨾᩮᨶᩴ ᨩᩣᨶᩣᨲᩥ, ᩅᩥᨾᩩᨲ᩠ᨲᩴ ᨲᨸ᩠ᨸᩁᩣᨿᨱᩴ.

‘‘ᩌᨠᩥᨬ᩠ᨧᨬ᩠ᨬᩈᨾ᩠ᨽᩅᩴ ᨬᨲ᩠ᩅᩣ, ᨶᨶ᩠ᨴᩦ ᩈᩴᨿᩮᩣᨩᨶᩴ ᩍᨲᩥ;

ᩑᩅᨾᩮᨲᩴ ᩋᨽᩥᨬ᩠ᨬᩣᨿ, ᨲᨲᩮᩣ ᨲᨲ᩠ᨳ ᩅᩥᨸᩔᨲᩥ;

ᩑᨲᩴ [ᩑᩅᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨬᩣᨱᩴ ᨲᨳᩴ ᨲᩔ, ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᩅᩩᩈᩦᨾᨲᩮᩣ’’ᨲᩥ.

ᨸᩮᩣᩈᩣᩃᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨧᩩᨴ᩠ᨴᩈᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨴ᩠ᩅᩣᩉᩴ ᩈᨠ᩠ᨠᩴ ᩋᨸᩩᨧ᩠ᨨᩥᩔᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨾᩮᩣᨥᩁᩣᨩᩣ)

ᨿᩣᩅᨲᨲᩥᨿᨬ᩠ᨧ ᨴᩮᩅᩦᩈᩥ, ᨻ᩠ᨿᩣᨠᩁᩮᩣᨲᩦᨲᩥ ᨾᩮ ᩈᩩᨲᩴ.

‘‘ᩋᨿᩴ ᩃᩮᩣᨠᩮᩣ ᨸᩁᩮᩣ ᩃᩮᩣᨠᩮᩣ, ᨻᩕᩉ᩠ᨾᩃᩮᩣᨠᩮᩣ ᩈᨴᩮᩅᨠᩮᩣ;

ᨴᩥᨭ᩠ᨮᩥᩴ ᨲᩮ ᨶᩣᨽᩥᨩᩣᨶᩣᨲᩥ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

‘‘ᩑᩅᩴ ¶ ¶ ¶ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᨴᩔᩣᩅᩥᩴ, ᩋᨲ᩠ᨳᩥ ᨸᨬ᩠ᩉᩮᨶ ᩌᨣᨾᩴ;

ᨠᨳᩴ ᩃᩮᩣᨠᩴ ᩋᩅᩮᨠ᩠ᨡᨶ᩠ᨲᩴ, ᨾᨧ᩠ᨧᩩᩁᩣᨩᩣ ᨶ ᨸᩔᨲᩥ’’.

‘‘ᩈᩩᨬ᩠ᨬᨲᩮᩣ ¶ ᩃᩮᩣᨠᩴ ᩋᩅᩮᨠ᩠ᨡᩔᩩ, ᨾᩮᩣᨥᩁᩣᨩ ᩈᨴᩣ ᩈᨲᩮᩣ;

ᩋᨲ᩠ᨲᩣᨶᩩᨴᩥᨭ᩠ᨮᩥᩴ ᩐᩉᨧ᩠ᨧ, ᩑᩅᩴ ᨾᨧ᩠ᨧᩩᨲᩁᩮᩣ ᩈᩥᨿᩣ;

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

ᨾᩮᩣᨥᩁᩣᨩᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᨸᨶ᩠ᨶᩁᩈᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨩᩥᨱ᩠ᨱᩮᩣᩉᨾᩈ᩠ᨾᩥ ᩋᨻᩃᩮᩣ ᩅᩦᨲᩅᨱ᩠ᨱᩮᩣ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨸᩥᨦ᩠ᨣᩥᨿᩮᩣ)

‘‘ᨴᩥᩈ᩠ᩅᩣᨶ ᩁᩪᨸᩮᩈᩩ ᩅᩥᩉᨬ᩠ᨬᨾᩣᨶᩮ, (ᨸᩥᨦ᩠ᨣᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

ᨲᩈ᩠ᨾᩣ ᨲᩩᩅᩴ ᨸᩥᨦ᩠ᨣᩥᨿ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩮᩣ,

‘‘ᨴᩥᩈᩣ ᨧᨲᩔᩮᩣ ᩅᩥᨴᩥᩈᩣ ᨧᨲᩔᩮᩣ, ᩏᨴ᩠ᨵᩴ ¶ ᩋᨵᩮᩣ ᨴᩈ ᨴᩥᩈᩣ ᩍᨾᩣᨿᩮᩣ;

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

ᩌᨧᩥᨠ᩠ᨡ ᨵᨾ᩠ᨾᩴ ᨿᨾᩉᩴ ᩅᩥᨩᨬ᩠ᨬᩴ, ᨩᩣᨲᩥᨩᩁᩣᨿ ᩍᨵ ᩅᩥᨸ᩠ᨸᩉᩣᨶᩴ’’.

‘‘ᨲᨱ᩠ᩉᩣᨵᩥᨸᨶ᩠ᨶᩮ ¶ ᨾᨶᩩᨩᩮ ᨸᩮᨠ᩠ᨡᨾᩣᨶᩮᩣ, (ᨸᩥᨦ᩠ᨣᩥᨿᩣᨲᩥ ᨽᨣᩅᩣ)

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

ᨸᩥᨦ᩠ᨣᩥᨿᨾᩣᨱᩅᨸᩩᨧ᩠ᨨᩣ ᩈᩮᩣᩊᩈᨾᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩣ.

ᩍᨴᨾᩅᩮᩣᨧ ¶ ᨽᨣᩅᩣ ᨾᨣᨵᩮᩈᩩ ᩅᩥᩉᩁᨶ᩠ᨲᩮᩣ ᨸᩣᩈᩣᨱᨠᩮ ᨧᩮᨲᩥᨿᩮ, ᨸᩁᩥᨧᩣᩁᨠᩈᩮᩣᩊᩈᩣᨶᩴ [ᨸᩁᩥᨧᩣᩁᨠᩈᩮᩣᩊᩈᨶ᩠ᨶᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᩋᨩ᩠ᨫᩥᨭ᩠ᨮᩮᩣ ᨸᩩᨭ᩠ᨮᩮᩣ ᨸᩩᨭ᩠ᨮᩮᩣ ᨸᨬ᩠ᩉᩴ [ᨸᨬ᩠ᩉᩮ (ᩈᩦ. ᨸᩦ.)] ᨻ᩠ᨿᩣᨠᩣᩈᩥ. ᩑᨠᨾᩮᨠᩔ ᨧᩮᨸᩥ ᨸᨬ᩠ᩉᩔ ᩋᨲ᩠ᨳᨾᨬ᩠ᨬᩣᨿ ᨵᨾ᩠ᨾᨾᨬ᩠ᨬᩣᨿ ᨵᨾ᩠ᨾᩣᨶᩩᨵᨾ᩠ᨾᩴ ᨸᨭᩥᨸᨩ᩠ᨩᩮᨿ᩠ᨿ, ᨣᨧ᩠ᨨᩮᨿ᩠ᨿᩮᩅ ᨩᩁᩣᨾᩁᨱᩔ ᨸᩣᩁᩴ. ᨸᩣᩁᨦ᩠ᨣᨾᨶᩦᨿᩣ ᩍᨾᩮ ᨵᨾ᩠ᨾᩣᨲᩥ, ᨲᩈ᩠ᨾᩣ ᩍᨾᩔ ᨵᨾ᩠ᨾᨸᩁᩥᨿᩣᨿᩔ ᨸᩣᩁᩣᨿᨶᨶ᩠ᨲᩮᩅ [ᨸᩣᩁᩣᨿᨱᩴᨲ᩠ᩅᩮᩅ (ᩈᩦ. ᩋᨭ᩠ᨮ.)] ᩋᨵᩥᩅᨧᨶᩴ.

ᩋᨩᩥᨲᩮᩣ ᨲᩥᩔᨾᩮᨲ᩠ᨲᩮᨿ᩠ᨿᩮᩣ, ᨸᩩᨱ᩠ᨱᨠᩮᩣ ᩋᨳ ᨾᩮᨲ᩠ᨲᨣᩪ;

ᨵᩮᩣᨲᨠᩮᩣ ᩏᨸᩈᩦᩅᩮᩣ ᨧ, ᨶᨶ᩠ᨴᩮᩣ ᨧ ᩋᨳ ᩉᩮᨾᨠᩮᩣ.

ᨲᩮᩣᨴᩮᨿ᩠ᨿ-ᨠᨸ᩠ᨸᩣ ¶ ᨴᩩᨽᨿᩮᩣ, ᨩᨲᩩᨠᨱ᩠ᨱᩦ ᨧ ᨸᨱ᩠ᨯᩥᨲᩮᩣ;

ᨽᨴᩕᩣᩅᩩᨵᩮᩣ ᩏᨴᨿᩮᩣ ᨧ, ᨸᩮᩣᩈᩣᩃᩮᩣ ᨧᩣᨸᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᨾᩮᩣᨥᩁᩣᨩᩣ ¶ ᨧ ᨾᩮᨵᩣᩅᩦ, ᨸᩥᨦ᩠ᨣᩥᨿᩮᩣ ᨧ ᨾᩉᩣᩍᩈᩥ.

ᩑᨲᩮ ᨻᩩᨴ᩠ᨵᩴ ᩏᨸᩣᨣᨧ᩠ᨨᩩᩴ, ᩈᨾ᩠ᨸᨶ᩠ᨶᨧᩁᨱᩴ ᩍᩈᩥᩴ;

ᨸᩩᨧ᩠ᨨᨶ᩠ᨲᩣ ᨶᩥᨸᩩᨱᩮ ᨸᨬ᩠ᩉᩮ, ᨻᩩᨴ᩠ᨵᩈᩮᨭ᩠ᨮᩴ ᩏᨸᩣᨣᨾᩩᩴ.

ᨲᩮᩈᩴ ᨻᩩᨴ᩠ᨵᩮᩣ ᨸᨻ᩠ᨿᩣᨠᩣᩈᩥ, ᨸᨬ᩠ᩉᩮ ᨸᩩᨭ᩠ᨮᩮᩣ ᨿᨳᩣᨲᨳᩴ;

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

ᨲᩮ ᨲᩮᩣᩈᩥᨲᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩣ, ᨻᩩᨴ᩠ᨵᩮᨶᩣᨴᩥᨧ᩠ᨧᨻᨶ᩠ᨵᩩᨶᩣ;

ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᨾᨧᩁᩥᩴᩈᩩ, ᩅᩁᨸᨬ᩠ᨬᩔ ᩈᨶ᩠ᨲᩥᨠᩮ.

ᩑᨠᨾᩮᨠᩔ ¶ ᨸᨬ᩠ᩉᩔ, ᨿᨳᩣ ᨻᩩᨴ᩠ᨵᩮᨶ ᨴᩮᩈᩥᨲᩴ;

ᨲᨳᩣ ᨿᩮᩣ ᨸᨭᩥᨸᨩ᩠ᨩᩮᨿ᩠ᨿ, ᨣᨧ᩠ᨨᩮ ᨸᩣᩁᩴ ᩋᨸᩣᩁᨲᩮᩣ.

ᩋᨸᩣᩁᩣ ᨸᩣᩁᩴ ᨣᨧ᩠ᨨᩮᨿ᩠ᨿ, ᨽᩣᩅᩮᨶ᩠ᨲᩮᩣ ᨾᨣ᩠ᨣᨾᩩᨲ᩠ᨲᨾᩴ;

ᨾᨣ᩠ᨣᩮᩣ ᩈᩮᩣ ᨸᩣᩁᩴ ᨣᨾᨶᩣᨿ, ᨲᩈ᩠ᨾᩣ ᨸᩣᩁᩣᨿᨶᩴ ᩍᨲᩥ.

‘‘ᨸᩣᩁᩣᨿᨶᨾᨶᩩᨣᩣᨿᩥᩔᩴ, (ᩍᨧ᩠ᨧᩣᨿᩈ᩠ᨾᩣ ᨸᩥᨦ᩠ᨣᩥᨿᩮᩣ)

ᨿᨳᩣᨴ᩠ᨴᨠ᩠ᨡᩥ ᨲᨳᩣᨠ᩠ᨡᩣᩈᩥ, ᩅᩥᨾᩃᩮᩣ ᨽᩪᩁᩥᨾᩮᨵᩈᩮᩣ;

ᨶᩥᨠ᩠ᨠᩣᨾᩮᩣ ᨶᩥᨻ᩠ᨻᨶᩮᩣ [ᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ (ᩈ᩠ᨿᩣ.)] ᨶᩣᨣᩮᩣ, ᨠᩥᩔ ᩉᩮᨲᩩ ᨾᩩᩈᩣ ᨽᨱᩮ.

‘‘ᨸᩉᩦᨶᨾᩃᨾᩮᩣᩉᩔ ¶ ¶ , ᨾᩣᨶᨾᨠ᩠ᨡᨸ᩠ᨸᩉᩣᨿᩥᨶᩮᩣ;

ᩉᨶ᩠ᨴᩣᩉᩴ ᨠᩥᨲ᩠ᨲᨿᩥᩔᩣᨾᩥ, ᨣᩥᩁᩴ ᩅᨱ᩠ᨱᩪᨸᩈᨬ᩠ᩉᩥᨲᩴ.

‘‘ᨲᨾᩮᩣᨶᩩᨴᩮᩣ ᨻᩩᨴ᩠ᨵᩮᩣ ᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩩ, ᩃᩮᩣᨠᨶ᩠ᨲᨣᩪ ᩈᨻ᩠ᨻᨽᩅᩣᨲᩥᩅᨲ᩠ᨲᩮᩣ;

ᩋᨶᩣᩈᩅᩮᩣ ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᨸᩉᩦᨶᩮᩣ, ᩈᨧ᩠ᨧᩅ᩠ᩉᨿᩮᩣ ¶ ᨻᩕᩉ᩠ᨾᩮ ᩏᨸᩣᩈᩥᨲᩮᩣ ᨾᩮ.

‘‘ᨴᩥᨩᩮᩣ ᨿᨳᩣ ᨠᩩᨻ᩠ᨻᨶᨠᩴ ᨸᩉᩣᨿ, ᨻᩉᩩᨸ᩠ᨹᩃᩴ ᨠᩣᨶᨶᨾᩣᩅᩈᩮᨿ᩠ᨿ;

ᩑᩅᩴ ᨸᩉᩴ ᩋᨸ᩠ᨸᨴᩔᩮ ᨸᩉᩣᨿ, ᨾᩉᩮᩣᨴᨵᩥᩴ ᩉᩴᩈᩮᩣᩁᩥᩅ ᩋᨩ᩠ᨫᨸᨲ᩠ᨲᩮᩣ.

‘‘ᨿᩮᨾᩮ ᨸᩩᨻ᩠ᨻᩮ ᩅᩥᨿᩣᨠᩴᩈᩩ, ᩉᩩᩁᩴ ᨣᩮᩣᨲᨾᩈᩣᩈᨶᩣ;

ᩈᨻ᩠ᨻᩴ ᨲᩴ ᩍᨲᩥᩉᩥᨲᩥᩉᩴ, ᩈᨻ᩠ᨻᩴ ᨲᩴ ᨲᨠ᩠ᨠᩅᨯ᩠ᨰᨶᩴ.

‘‘ᩑᨠᩮᩣ ᨲᨾᨶᩩᨴᩣᩈᩥᨶᩮᩣ, ᨩᩩᨲᩥᨾᩣ ᩈᩮᩣ ᨸᨽᨦ᩠ᨠᩁᩮᩣ;

ᨣᩮᩣᨲᨾᩮᩣ ᨽᩪᩁᩥᨸᨬ᩠ᨬᩣᨱᩮᩣ, ᨣᩮᩣᨲᨾᩮᩣ ᨽᩪᩁᩥᨾᩮᨵᩈᩮᩣ.

‘‘ᨿᩮᩣ ¶ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨠᨾᨠᩣᩃᩥᨠᩴ;

ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᨾᨶᩦᨲᩥᨠᩴ ¶ , ᨿᩔ ᨶᨲ᩠ᨳᩥ ᩏᨸᨾᩣ ᨠ᩠ᩅᨧᩥ’’.

‘‘ᨠᩥᩴᨶᩩ ¶ ᨲᨾ᩠ᩉᩣ ᩅᩥᨸ᩠ᨸᩅᩈᩈᩥ, ᨾᩩᩉᩩᨲ᩠ᨲᨾᨸᩥ ᨸᩥᨦ᩠ᨣᩥᨿ;

ᨣᩮᩣᨲᨾᩣ ᨽᩪᩁᩥᨸᨬ᩠ᨬᩣᨱᩣ, ᨣᩮᩣᨲᨾᩣ ᨽᩪᩁᩥᨾᩮᨵᩈᩣ.

‘‘ᨿᩮᩣ ᨲᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨠᨾᨠᩣᩃᩥᨠᩴ;

ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᨾᨶᩦᨲᩥᨠᩴ, ᨿᩔ ᨶᨲ᩠ᨳᩥ ᩏᨸᨾᩣ ᨠ᩠ᩅᨧᩥ’’.

‘‘ᨶᩣᩉᩴ ᨲᨾ᩠ᩉᩣ ᩅᩥᨸ᩠ᨸᩅᩈᩣᨾᩥ, ᨾᩩᩉᩩᨲ᩠ᨲᨾᨸᩥ ᨻᩕᩣᩉ᩠ᨾᨱ;

ᨣᩮᩣᨲᨾᩣ ᨽᩪᩁᩥᨸᨬ᩠ᨬᩣᨱᩣ, ᨣᩮᩣᨲᨾᩣ ᨽᩪᩁᩥᨾᩮᨵᩈᩣ.

‘‘ᨿᩮᩣ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨠᨾᨠᩣᩃᩥᨠᩴ;

ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᨾᨶᩦᨲᩥᨠᩴ, ᨿᩔ ᨶᨲ᩠ᨳᩥ ᩏᨸᨾᩣ ᨠ᩠ᩅᨧᩥ.

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

ᨶᨾᩔᨾᩣᨶᩮᩣ ᩅᩥᩅᩈᩮᨾᩥ ᩁᨲ᩠ᨲᩥᩴ, ᨲᩮᨶᩮᩅ ᨾᨬ᩠ᨬᩣᨾᩥ ᩋᩅᩥᨸ᩠ᨸᩅᩣᩈᩴ.

‘‘ᩈᨴ᩠ᨵᩣ ᨧ ᨸᩦᨲᩥ ᨧ ᨾᨶᩮᩣ ᩈᨲᩥ ᨧ, ᨶᩣᨸᩮᨶ᩠ᨲᩥ ᨾᩮ ᨣᩮᩣᨲᨾᩈᩣᩈᨶᨾ᩠ᩉᩣ;

ᨿᩴ ᨿᩴ ᨴᩥᩈᩴ ᩅᨩᨲᩥ ᨽᩪᩁᩥᨸᨬ᩠ᨬᩮᩣ, ᩈ ᨲᩮᨶ ᨲᩮᨶᩮᩅ ᨶᨲᩮᩣᩉᨾᩈ᩠ᨾᩥ.

‘‘ᨩᩥᨱ᩠ᨱᩔ ¶ ᨾᩮ ᨴᩩᨻ᩠ᨻᩃᨳᩣᨾᨠᩔ, ᨲᩮᨶᩮᩅ ᨠᩣᨿᩮᩣ ᨶ ᨸᩃᩮᨲᩥ ᨲᨲ᩠ᨳ;

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

‘‘ᨸᨦ᩠ᨠᩮ ᩈᨿᩣᨶᩮᩣ ᨸᩁᩥᨹᨶ᩠ᨴᨾᩣᨶᩮᩣ, ᨴᩦᨸᩣ ᨴᩦᨸᩴ ᩏᨸᨸ᩠ᩃᩅᩥᩴ [ᩏᨸᩃ᩠ᩃᩅᩥᩴ (ᩈ᩠ᨿᩣ. ᨶᩥᨴ᩠ᨴᩮᩈ)];

ᩋᨳᨴ᩠ᨴᩈᩣᩈᩥᩴ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩴ, ᩒᨥᨲᩥᨱ᩠ᨱᨾᨶᩣᩈᩅᩴ’’.

‘‘ᨿᨳᩣ ᩋᩉᩪ ᩅᨠ᩠ᨠᩃᩥ ᨾᩩᨲ᩠ᨲᩈᨴ᩠ᨵᩮᩣ, ᨽᨴᩕᩣᩅᩩᨵᩮᩣ ᩌᩊᩅᩥ ᨣᩮᩣᨲᨾᩮᩣ ᨧ;

ᨣᨾᩥᩔᩈᩥ ᨲ᩠ᩅᩴ ᨸᩥᨦ᩠ᨣᩥᨿ ᨾᨧ᩠ᨧᩩᨵᩮᨿ᩠ᨿᩔ ᨸᩣᩁᩴ’’ [ᨾᨧ᩠ᨧᩩᨵᩮᨿ᩠ᨿᨸᩣᩁᩴ (ᩈᩦ.)].

‘‘ᩑᩈ ᨽᩥᨿ᩠ᨿᩮᩣ ᨸᩈᩦᨴᩣᨾᩥ, ᩈᩩᨲ᩠ᩅᩣᨶ ᨾᩩᨶᩥᨶᩮᩣ ᩅᨧᩮᩣ;

ᩅᩥᩅᨭ᩠ᨭᨧ᩠ᨨᨴᩮᩣ ¶ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ, ᩋᨡᩥᩃᩮᩣ ᨸᨭᩥᨽᩣᨶᩅᩣ.

‘‘ᩋᨵᩥᨴᩮᩅᩮ ¶ ᩋᨽᩥᨬ᩠ᨬᩣᨿ, ᩈᨻ᩠ᨻᩴ ᩅᩮᨴᩥ ᩅᩁᩮᩣᩅᩁᩴ [ᨸᩁᩮᩣ ᩅᩁᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨸᩁᩮᩣ ᨸᩁᩴ (ᨶᩥᨴ᩠ᨴᩮᩈ)];

ᨸᨬ᩠ᩉᩣᨶᨶ᩠ᨲᨠᩁᩮᩣ ᩈᨲ᩠ᨳᩣ, ᨠᨦ᩠ᨡᩦᨶᩴ ᨸᨭᩥᨩᩣᨶᨲᩴ.

‘‘ᩋᩈᩴᩉᩦᩁᩴ ¶ ᩋᩈᨦ᩠ᨠᩩᨸ᩠ᨸᩴ, ᨿᩔ ᨶᨲ᩠ᨳᩥ ᩏᨸᨾᩣ ᨠ᩠ᩅᨧᩥ;

ᩋᨴ᩠ᨵᩣ ᨣᨾᩥᩔᩣᨾᩥ ᨶ ᨾᩮᨲ᩠ᨳ ᨠᨦ᩠ᨡᩣ, ᩑᩅᩴ ᨾᩴ ᨵᩣᩁᩮᩉᩥ ᩋᨵᩥᨾᩩᨲ᩠ᨲᨧᩥᨲ᩠ᨲ’’ᨶ᩠ᨲᩥ.

ᨸᩣᩁᩣᨿᨶᩅᨣ᩠ᨣᩮᩣ ᨸᨬ᩠ᨧᨾᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

ᩏᩁᨣᩮᩣ ¶ [ᩍᨾᩣ ᩏᨴ᩠ᨴᩣᨶᨣᩣᨳᩣᨿᩮᩣ ᩈᩦ. ᨸᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮᩈᩩ ᨶ ᩈᨶ᩠ᨲᩥ] ᨵᨶᩥᨿᩮᩣᨸᩥ ᨧ, ᨡᨣ᩠ᨣᩅᩥᩈᩣᨱᩮᩣ ᨠᩈᩥ ᨧ;

ᨧᩩᨶ᩠ᨴᩮᩣ ᨽᩅᩮᩣ ᨸᩩᨶᨴᩮᩅ, ᩅᩈᩃᩮᩣ ᨧ ᨠᩁᨱᩦᨿᨬ᩠ᨧ;

ᩉᩮᨾᩅᨲᩮᩣ ᩋᨳ ᨿᨠ᩠ᨡᩮᩣ, ᩅᩥᨩᨿᩈᩩᨲ᩠ᨲᩴ ᨾᩩᨶᩥᩈᩩᨲ᩠ᨲᩅᩁᨶ᩠ᨲᩥ.

ᨸᨮᨾᨠᨭ᩠ᨮᩅᩁᩮᩣ ᩅᩁᩅᨣ᩠ᨣᩮᩣ, ᨴ᩠ᩅᩣᨴᩈᩈᩩᨲ᩠ᨲᨵᩁᩮᩣ ᩈᩩᩅᩥᨽᨲ᩠ᨲᩮᩣ;

ᨴᩮᩈᩥᨲᩮᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩣ ᩅᩥᨾᩃᩮᨶ, ᩈᩩᨿ᩠ᨿᨲᩥ ᩅᨣ᩠ᨣᩅᩁᩮᩣ ᩏᩁᨣᩮᩣᨲᩥ.

ᩁᨲᨶᩣᨾᨣᨶ᩠ᨵᩮᩣ ᩉᩥᩁᩥᨾᨦ᩠ᨣᩃᨶᩣᨾᩮᩣ, ᩈᩩᨧᩥᩃᩮᩣᨾᨠᨸᩥᩃᩮᩣ ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᨵᨾ᩠ᨾᩮᩣ;

ᨶᩣᩅᩣ [ᨶᩣᨳ (ᨠ.)] ᨠᩥᩴᩈᩦᩃᩏᨭ᩠ᨮᩉᨶᩮᩣ ᨧ, ᩁᩣᩉᩩᩃᩮᩣ ¶ ᨧ ᨸᩩᨶᨸᩥ ᩅᨦ᩠ᨣᩦᩈᩮᩣ.

ᩈᨾ᩠ᨾᩣᨸᩁᩥᨻ᩠ᨻᩣᨩᨶᩦᨿᩮᩣᨸᩥ ᨧᩮᨲ᩠ᨳ, ᨵᨾ᩠ᨾᩥᨠᩈᩩᨲ᩠ᨲᩅᩁᩮᩣ ᩈᩩᩅᩥᨽᨲ᩠ᨲᩮᩣ;

ᨧᩩᨴ᩠ᨴᩈᩈᩩᨲ᩠ᨲᨵᩁᩮᩣ ᨴᩩᨲᩥᨿᨾ᩠ᩉᩥ, ᨧᩪᩊᨠᩅᨣ᩠ᨣᩅᩁᩮᩣᨲᩥ ᨲᨾᩣᩉᩩ.

ᨸᨻ᩠ᨻᨩ᩠ᨩᨸᨵᩣᨶᩈᩩᨽᩣᩈᩥᨲᨶᩣᨾᩮᩣ, ᨸᩪᩁᩊᩣᩈᩮᩣ ᨸᩩᨶᨴᩮᩅ ᨾᩣᨥᩮᩣ ᨧ;

ᩈᨽᩥᨿᩴ ᨠᩮᨱᩥᨿᨾᩮᩅ ᩈᩃ᩠ᩃᨶᩣᨾᩮᩣ, ᩅᩣᩈᩮᨭ᩠ᨮᩅᩁᩮᩣ ᨠᩣᩃᩥᨠᩮᩣᨸᩥ ᨧ.

ᨶᩣᩃᨠᩈᩩᨲ᩠ᨲᩅᩁᩮᩣ ᩈᩩᩅᩥᨽᨲ᩠ᨲᩮᩣ, ᨲᩴ ᩋᨶᩩᨸᩔᩦ ᨲᨳᩣ ᨸᩩᨶᨴᩮᩅ;

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

ᨠᩣᨾᨣᩩᩉᨭ᩠ᨮᨠᨴᩩᨭ᩠ᨮᨠᨶᩣᨾᩣ ¶ , ᩈᩩᨴ᩠ᨵᩅᩁᩮᩣ ᨸᩁᨾᨭ᩠ᨮᨠᨶᩣᨾᩮᩣ;

ᨩᩁᩣ ᨾᩮᨲ᩠ᨲᩥᨿᩅᩁᩮᩣ ᩈᩩᩅᩥᨽᨲ᩠ᨲᩮᩣ, ᨸᩈᩪᩁᨾᩣᨣᨱ᩠ᨯᩥᨿᩣ ᨸᩩᩁᩣᨽᩮᨴᩮᩣ.

ᨠᩃᩉᩅᩥᩅᩣᨴᩮᩣ ¶ ᩏᨽᩮᩣ ᩅᩥᨿᩩᩉᩣ ᨧ, ᨲᩩᩅᨭᨠᩋᨲ᩠ᨲᨴᨱ᩠ᨯᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩣ;

ᩈᩮᩣᩊᩈᩈᩩᨲ᩠ᨲᨵᩁᩮᩣ ᨧᨲᩩᨲ᩠ᨳᨾ᩠ᩉᩥ, ᩋᨭ᩠ᨮᨠᩅᨣ᩠ᨣᩅᩁᩮᩣᨲᩥ ¶ ᨲᨾᩣᩉᩩ.

ᨾᨣᨵᩮ ᨩᨶᨸᨴᩮ ᩁᨾᨱᩦᨿᩮ, ᨴᩮᩈᩅᩁᩮ ᨠᨲᨸᩩᨬ᩠ᨬᨶᩥᩅᩮᩈᩮ;

ᨸᩣᩈᩣᨱᨠᨧᩮᨲᩥᨿᩅᩁᩮ ᩈᩩᩅᩥᨽᨲ᩠ᨲᩮ, ᩅᩈᩥ ᨽᨣᩅᩣ ᨣᨱᩈᩮᨭ᩠ᨮᩮᩣ.

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

ᩈᩮᩣᩊᩈᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᨠᩥᩁ ᨸᩩᨭ᩠ᨮᩮᩣ, ᨸᩩᨧ᩠ᨨᩣᨿ ᩈᩮᩣᩊᩈᨸᨬ᩠ᩉᨠᨾ᩠ᨾᩥᨿᩣ;

ᩋᨲ᩠ᨳᨸᨠᩣᩈᨠᨻ᩠ᨿᨬ᩠ᨩᨶᨸᩩᨱ᩠ᨱᩴ, ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ ᨸᩁᨡᩮᨾᨩᨶᩥᨿᩴ [ᩅᩁᩴ ᨡᨾᨶᩦᨿᩴ (ᨠ.)];

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

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

ᨻ᩠ᨿᨬ᩠ᨩᨶᨾᨲ᩠ᨳᨸᨴᩴ ᩈᨾᨿᩩᨲ᩠ᨲᩴ [ᨻ᩠ᨿᨬ᩠ᨩᨶᨾᨲ᩠ᨳᨸᨴᩈᨾᨿᩩᨲ᩠ᨲᩴ (ᩈ᩠ᨿᩣ.)], ᩋᨠ᩠ᨡᩁᩈᨬ᩠ᨬᩥᨲᩒᨸᨾᨣᩣᩊ᩠ᩉᩴ;

ᩃᩮᩣᨠᩅᩥᨧᩣᩁᨱᨬᩣᨱᨸᨽᨣ᩠ᨣᩴ, ᨴᩮᩈᨿᩥ ᩈᩩᨲ᩠ᨲᩅᩁᩴ ᨴ᩠ᩅᩥᨸᨴᨣ᩠ᨣᩮᩣ.

ᩁᩣᨣᨾᩃᩮ ¶ ᩋᨾᩃᩴ ᩅᩥᨾᩃᨣ᩠ᨣᩴ, ᨴᩮᩣᩈᨾᩃᩮ ᩋᨾᩃᩴ ᩅᩥᨾᩃᨣ᩠ᨣᩴ;

ᨾᩮᩣᩉᨾᩃᩮ ᩋᨾᩃᩴ ᩅᩥᨾᩃᨣ᩠ᨣᩴ, ᩃᩮᩣᨠᩅᩥᨧᩣᩁᨱᨬᩣᨱᨸᨽᨣ᩠ᨣᩴ;

ᨠ᩠ᩃᩮᩈᨾᩃᩮ ¶ ᩋᨾᩃᩴ ᩅᩥᨾᩃᨣ᩠ᨣᩴ, ᨴᩩᨧ᩠ᨧᩁᩥᨲᨾᩃᩮ ᩋᨾᩃᩴ ᩅᩥᨾᩃᨣ᩠ᨣᩴ;

ᩃᩮᩣᨠᩅᩥᨧᩣᩁᨱᨬᩣᨱᨸᨽᨣ᩠ᨣᩴ, ᨴᩮᩈᨿᩥ ᩈᩩᨲ᩠ᨲᩅᩁᩴ ᨴ᩠ᩅᩥᨸᨴᨣ᩠ᨣᩮᩣ.

ᩌᩈᩅᨻᨶ᩠ᨵᨶᨿᩮᩣᨣᩣᨠᩥᩃᩮᩈᩴ, ᨶᩦᩅᩁᨱᩣᨶᩥ ᨧ ᨲᩦᨱᩥ ᨾᩃᩣᨶᩥ;

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

ᨶᩥᨾ᩠ᨾᩃᩈᨻ᩠ᨻᨠᩥᩃᩮᩈᨸᨶᩪᨴᩴ, ᩁᩣᨣᩅᩥᩁᩣᨣᨾᨶᩮᨩᨾᩈᩮᩣᨠᩴ;

ᩈᨶ᩠ᨲᨸᨱᩦᨲᩈᩩᨴᩩᨴ᩠ᨴᩈᨵᨾ᩠ᨾᩴ, ᨴᩮᩈᨿᩥ ¶ ᩈᩩᨲ᩠ᨲᩅᩁᩴ ᨴ᩠ᩅᩥᨸᨴᨣ᩠ᨣᩮᩣ.

ᩁᩣᨣᨬ᩠ᨧ ¶ ᨴᩮᩣᩈᨠᨾᨽᨬ᩠ᨩᩥᨲᩈᨶ᩠ᨲᩴ [ᨴᩮᩣᩈᨬ᩠ᨧ ᨽᨬ᩠ᨩᩥᨲᩈᨶ᩠ᨲᩴ (ᩈ᩠ᨿᩣ.)], ᨿᩮᩣᨶᩥᨧᨲᩩᨣ᩠ᨣᨲᩥᨸᨬ᩠ᨧᩅᩥᨬ᩠ᨬᩣᨱᩴ;

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

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

ᩃᩮᩣᨠᩅᩥᨧᩣᩁᨱᨬᩣᨱᨸᨽᨣ᩠ᨣᩴ, ᨴᩮᩈᨿᩥ ᩈᩩᨲ᩠ᨲᩅᩁᩴ ᨴ᩠ᩅᩥᨸᨴᨣ᩠ᨣᩮᩣ.

ᨶᩅᨦ᩠ᨣᨠᩩᩈᩩᨾᨾᩣᩃᨣᩦᩅᩮᨿ᩠ᨿᩴ, ᩍᨶ᩠ᨴᩕᩥᨿᨫᩣᨶᩅᩥᨾᩮᩣᨠ᩠ᨡᩅᩥᨽᨲ᩠ᨲᩴ;

ᩋᨭ᩠ᨮᨦ᩠ᨣᨾᨣ᩠ᨣᨵᩁᩴ ᩅᩁᨿᩣᨶᩴ, ᨴᩮᩈᨿᩥ ᩈᩩᨲ᩠ᨲᩅᩁᩴ ᨴ᩠ᩅᩥᨸᨴᨣ᩠ᨣᩮᩣ.

ᩈᩮᩣᨾᩩᨸᨾᩴ ¶ ᩅᩥᨾᩃᩴ ᨸᩁᩥᩈᩩᨴ᩠ᨵᩴ, ᩋᨱ᩠ᨱᩅᨾᩪᨸᨾᩁᨲᨶᩈᩩᨧᩥᨲ᩠ᨲᩴ;

ᨸᩩᨸ᩠ᨹᩈᨾᩴ ᩁᩅᩥᨾᩪᨸᨾᨲᩮᨩᩴ, ᨴᩮᩈᨿᩥ ᩈᩩᨲ᩠ᨲᩅᩁᩴ ᨴ᩠ᩅᩥᨸᨴᨣ᩠ᨣᩮᩣ.

ᨡᩮᨾᩈᩥᩅᩴ ᩈᩩᨡᩈᩦᨲᩃᩈᨶ᩠ᨲᩴ, ᨾᨧ᩠ᨧᩩᨲᨲᩣᨱᨸᩁᩴ ᨸᩁᨾᨲ᩠ᨳᩴ;

ᨲᩔ ᩈᩩᨶᩥᨻ᩠ᨻᩩᨲᨴᩔᨶᩉᩮᨲᩩᩴ, ᨴᩮᩈᨿᩥ ᩈᩩᨲ᩠ᨲᩅᩁᩴ ᨴ᩠ᩅᩥᨸᨴᨣ᩠ᨣᩮᩣᨲᩥ.