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

᪑᪓᪖. ‘‘ᨾᨾ ¶ ᨧ, ᨽᨶ᩠ᨲᩮ, ᩅᨧᨶᩮᨶ ᨽᨣᩅᨲᩮᩣ ᨸᩣᨴᩮ ᩈᩥᩁᩈᩣ ᩅᨶ᩠ᨴᩮᨿ᩠ᨿᩣᩈᩥ – ‘ᩏᨲ᩠ᨲᩁᩣ ᨶᩣᨾ, ᨽᨶ᩠ᨲᩮ, ᩏᨸᩣᩈᩥᨠᩣ ᨽᨣᩅᨲᩮᩣ ᨸᩣᨴᩮ ᩈᩥᩁᩈᩣ ᩅᨶ᩠ᨴᨲᩦ’ᨲᩥ. ᩋᨶᨧ᩠ᨨᩁᩥᨿᩴ ᨡᩮᩣ ᨸᨶᩮᨲᩴ, ᨽᨶ᩠ᨲᩮ, ᨿᩴ ᨾᩴ ᨽᨣᩅᩣ ᩋᨬ᩠ᨬᨲᩁᩈ᩠ᨾᩥᩴ ᩈᩣᨾᨬ᩠ᨬᨹᩃᩮ ᨻ᩠ᨿᩣᨠᩁᩮᨿ᩠ᨿ [ᨻ᩠ᨿᩣᨠᩁᩮᨿ᩠ᨿᩣᨲᩥ (?)], ᨲᩴ ᨽᨣᩅᩣ ᩈᨠᨴᩣᨣᩣᨾᩥᨹᩃᩮ ᨻ᩠ᨿᩣᨠᩣᩈᩦ’’ᨲᩥ.

‘‘ᨿᩩᨲ᩠ᨲᩣ ¶ ᨧ ᨲᩮ ᨸᩁᨾᩋᩃᨦ᩠ᨠᨲᩣ ᩉᨿᩣ, ᩋᨵᩮᩣᨾᩩᨡᩣ ᩋᨥᩈᩥᨣᨾᩣ ᨻᩃᩦ ᨩᩅᩣ;

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

‘‘ᩈᩣ ᨲᩥᨭ᩠ᨮᩈᩥ ᩁᨳᩅᩁᩮ ᩋᩃᨦ᩠ᨠᨲᩣ, ᩒᨽᩣᩈᨿᩴ ᨩᩃᨾᩥᩅ ᨩᩮᩣᨲᩥ ᨸᩣᩅᨠᩮᩣ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᩅᩁᨲᨶᩩ [ᩅᩁᨧᩣᩁᩩ (ᨠᨲ᩠ᨳᨧᩥ)] ᩋᨶᩮᩣᨾᨴᩔᨶᩮ, ᨠᩈ᩠ᨾᩣ ᨶᩩ ᨠᩣᨿᩣ ᩋᨶᨵᩥᩅᩁᩴ ᩏᨸᩣᨣᨾᩥ.

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

ᨲᩈ᩠ᨾᩣ ᨠᩣᨿᩣ ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦ, ᩍᨵᩣᨣᨲᩣ ᩋᨶᨵᩥᩅᩁᩴ ᨶᨾᩔᩥᨲᩩᩴ.

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

ᨠᩮᨶᨧ᩠ᨨᩈᩥ ¶ ᨲ᩠ᩅᩴ ᩋᨾᩥᨲᨿᩈᩣ ᩈᩩᨡᩮᨵᩥᨲᩣ;

‘‘ᨴᩮᩅᩮᩉᩥ ᨲ᩠ᩅᩴ ᨸᩁᩥᩅᩩᨲᩣ ᩈᨠ᩠ᨠᨲᩣ ᨧᩈᩥ,

ᩌᨧᩥᨠ᩠ᨡ ᨾᩮ ᨲ᩠ᩅᩴ ᨿᨴᩥ ᨻᩩᨴ᩠ᨵᩈᩣᩅᩥᨠᩣ’’ᨲᩥ.

‘‘ᨶᨣᨶ᩠ᨲᩁᩮ ¶ ᨶᨣᩁᩅᩁᩮ ᩈᩩᨾᩣᨸᩥᨲᩮ, ᨸᩁᩥᨧᩣᩁᩥᨠᩣ ᩁᩣᨩᩅᩁᩔ ᩈᩥᩁᩥᨾᨲᩮᩣ;

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

‘‘ᨻᩩᨴ᩠ᨵᩮᩣ ᨧ ᨾᩮ ᩍᩈᩥᨶᩥᩈᨽᩮᩣ ᩅᩥᨶᩣᨿᨠᩮᩣ, ᩋᨴᩮᩈᨿᩦ ᩈᨾᩩᨴᨿᨴᩩᨠ᩠ᨡᨶᩥᨧ᩠ᨧᨲᩴ;

ᩋᩈᨦ᩠ᨡᨲᩴ ᨴᩩᨠ᩠ᨡᨶᩥᩁᩮᩣᨵᩈᩔᨲᩴ, ᨾᨣ᩠ᨣᨬ᩠ᨧᩥᨾᩴ ᩋᨠᩩᨭᩥᩃᨾᨬ᩠ᨩᩈᩴ ᩈᩥᩅᩴ.

‘‘ᩈᩩᨲ᩠ᩅᩣᨶᩉᩴ ᩋᨾᨲᨸᨴᩴ ᩋᩈᨦ᩠ᨡᨲᩴ, ᨲᨳᩣᨣᨲᩔᨶᨵᩥᩅᩁᩔ ᩈᩣᩈᨶᩴ;

ᩈᩦᩃᩮᩈ᩠ᩅᩉᩴ ᨸᩁᨾᩈᩩᩈᩴᩅᩩᨲᩣ ᩋᩉᩩᩴ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩣ ᨶᩁᩅᩁᨻᩩᨴ᩠ᨵᨴᩮᩈᩥᨲᩮ [ᨽᩣᩈᩥᨲᩮ (ᩈᩦ.)].

‘‘ᨬᨲ᩠ᩅᩣᨶᩉᩴ ᩅᩥᩁᨩᨸᨴᩴ ᩋᩈᨦ᩠ᨡᨲᩴ, ᨲᨳᩣᨣᨲᩮᨶᨶᨵᩥᩅᩁᩮᨶ ¶ ᨴᩮᩈᩥᨲᩴ;

ᨲᨲ᩠ᨳᩮᩅᩉᩴ ᩈᨾᨳᩈᨾᩣᨵᩥᨾᩣᨹᩩᩈᩥᩴ, ᩈᩣᨿᩮᩅ ᨾᩮ ᨸᩁᨾᨶᩥᨿᩣᨾᨲᩣ ᩋᩉᩩ.

‘‘ᩃᨴ᩠ᨵᩣᨶᩉᩴ ¶ ᩋᨾᨲᩅᩁᩴ ᩅᩥᩈᩮᩈᨶᩴ, ᩑᨠᩴᩈᩥᨠᩣ ᩋᨽᩥᩈᨾᨿᩮ ᩅᩥᩈᩮᩈᩥᨿ;

ᩋᩈᩴᩈᨿᩣ ᨻᩉᩩᨩᨶᨸᩪᨩᩥᨲᩣ ᩋᩉᩴ, ᨡᩥᨯ᩠ᨯᩣᩁᨲᩥᩴ [ᨡᩥᨯ᩠ᨯᩴ ᩁᨲᩥᩴ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨸᨧ᩠ᨧᨶᩩᨽᩮᩣᨾᨶᨸ᩠ᨸᨠᩴ.

‘‘ᩑᩅᩴ ᩋᩉᩴ ᩋᨾᨲᨴᩈᨾ᩠ᩉᩥ [ᩋᨾᨲᩁᩈᨾ᩠ᩉᩥ (ᨠ.)] ᨴᩮᩅᨲᩣ, ᨲᨳᩣᨣᨲᩔᨶᨵᩥᩅᩁᩔ ᩈᩣᩅᩥᨠᩣ;

ᨵᨾ᩠ᨾᨴ᩠ᨴᩈᩣ ᨸᨮᨾᨹᩃᩮ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩣ, ᩈᩮᩣᨲᩣᨸᨶ᩠ᨶᩣ ᨶ ᨧ ᨸᨶ ᨾᨲ᩠ᨳᩥ ᨴᩩᨣ᩠ᨣᨲᩥ.

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

ᨶᨾᩔᩥᨲᩩᩴ ᩈᨾᨱᩈᨾᩣᨣᨾᩴ ᩈᩥᩅᩴ, ᩈᨣᩣᩁᩅᩣ ᩈᩥᩁᩥᨾᨲᩮᩣ ᨵᨾ᩠ᨾᩁᩣᨩᩥᨶᩮᩣ.

‘‘ᨴᩥᩈ᩠ᩅᩣ ¶ ᨾᩩᨶᩥᩴ ᨾᩩᨴᩥᨲᨾᨶᨾ᩠ᩉᩥ ᨸᩦᨱᩥᨲᩣ, ᨲᨳᩣᨣᨲᩴ ᨶᩁᩅᩁᨴᨾ᩠ᨾᩈᩣᩁᨳᩥᩴ;

ᨲᨱ᩠ᩉᨧ᩠ᨨᩥᨴᩴ ᨠᩩᩈᩃᩁᨲᩴ ᩅᩥᨶᩣᨿᨠᩴ, ᩅᨶ᩠ᨴᩣᨾᩉᩴ ᨸᩁᨾᩉᩥᨲᩣᨶᩩᨠᨾ᩠ᨸᨠ’’ᨶ᩠ᨲᩥ.

‘‘ᩍᨴᩴ ¶ ¶ ¶ ᩅᩥᨾᩣᨶᩴ ᩁᩩᨧᩥᩁᩴ ᨸᨽᩔᩁᩴ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩴ ᩈᨲᨲᩴ ᩈᩩᨶᩥᨾ᩠ᨾᩥᨲᩴ;

ᩈᩩᩅᨱ᩠ᨱᩁᩩᨠ᩠ᨡᩮᩉᩥ ᩈᨾᨶ᩠ᨲᨾᩮᩣᨲ᩠ᨳᨲᩴ, ᨮᩣᨶᩴ ᨾᨾᩴ ᨠᨾ᩠ᨾᩅᩥᨸᩣᨠᩈᨾ᩠ᨽᩅᩴ.

‘‘ᨲᨲᩕᩪᨸᨸᨶ᩠ᨶᩣ ᨸᩩᩁᩥᨾᨧ᩠ᨨᩁᩣ ᩍᨾᩣ, ᩈᨲᩴ ᩈᩉᩔᩣᨶᩥ ᩈᨠᩮᨶ ᨠᨾ᩠ᨾᩩᨶᩣ;

ᨲᩩᩅᩴᩈᩥ ᩋᨩ᩠ᨫᩩᨸᨣᨲᩣ ᨿᩈᩔᩥᨶᩦ, ᩒᨽᩣᩈᨿᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨸᩩᨻ᩠ᨻᨴᩮᩅᨲᩣ.

‘‘ᩈᩈᩦ ᩋᨵᩥᨣ᩠ᨣᨿ᩠ᩉ ᨿᨳᩣ ᩅᩥᩁᩮᩣᨧᨲᩥ, ᨶᨠ᩠ᨡᨲ᩠ᨲᩁᩣᨩᩣᩁᩥᩅ ᨲᩣᩁᨠᩣᨣᨱᩴ;

ᨲᨳᩮᩅ ᨲ᩠ᩅᩴ ᩋᨧ᩠ᨨᩁᩣᩈᨦ᩠ᨣᨱᩴ [ᩋᨧ᩠ᨨᩁᩣᩈᨦ᩠ᨣᨾᩴ (ᩈᩦ.)] ᩍᨾᩴ, ᨴᨴ᩠ᨴᩃ᩠ᩃᨾᩣᨶᩣ ᨿᩈᩈᩣ ᩅᩥᩁᩮᩣᨧᩈᩥ.

‘‘ᨠᩩᨲᩮᩣ ᨶᩩ ᩌᨣᨾ᩠ᨾ ᩋᨶᩮᩣᨾᨴᩔᨶᩮ, ᩏᨸᨸᨶ᩠ᨶᩣ ᨲ᩠ᩅᩴ ᨽᩅᨶᩴ ᨾᨾᩴ ᩍᨴᩴ;

ᨻᩕᩉ᩠ᨾᩴᩅ ᨴᩮᩅᩣ ᨲᩥᨴᩈᩣ ᩈᩉᩥᨶ᩠ᨴᨠᩣ, ᩈᨻ᩠ᨻᩮ ᨶ ᨲᨸ᩠ᨸᩣᨾᩈᩮ ᨴᩔᨶᩮᨶ ᨲ’’ᨶ᩠ᨲᩥ.

‘‘ᨿᨾᩮᨲᩴ ᩈᨠ᩠ᨠ ᩋᨶᩩᨸᩩᨧ᩠ᨨᩈᩮ ᨾᨾᩴ, ‘ᨠᩩᨲᩮᩣ ᨧᩩᨲᩣ ᨲ᩠ᩅᩴ ᩍᨵ ᩌᨣᨲᩣ’ᨲᩥ [ᨠᩩᨲᩮᩣ ᨧᩩᨲᩣ ᩍᨵ ᩌᨣᨲᩣ ᨲᩩᩅᩴ (ᩈ᩠ᨿᩣ.), ᨠᩩᨲᩮᩣ ᨧᩩᨲᩣᨿ ᩌᨣᨲᩥ ᨲᩅ (ᨸᩦ.)];

ᨻᩣᩁᩣᨱᩈᩦ ᨶᩣᨾ ᨸᩩᩁᨲ᩠ᨳᩥ ᨠᩣᩈᩥᨶᩴ, ᨲᨲ᩠ᨳ ᩋᩉᩮᩣᩈᩥᩴ ᨸᩩᩁᩮ ᨠᩮᩈᨠᩣᩁᩥᨠᩣ.

‘‘ᨻᩩᨴ᩠ᨵᩮ ¶ ¶ ᨧ ᨵᨾ᩠ᨾᩮ ᨧ ᨸᩈᨶ᩠ᨶᨾᩣᨶᩈᩣ, ᩈᨦ᩠ᨥᩮ ᨧ ᩑᨠᨶ᩠ᨲᨣᨲᩣ ᩋᩈᩴᩈᨿᩣ;

ᩋᨡᨱ᩠ᨯᩈᩥᨠ᩠ᨡᩣᨸᨴᩣ ᩌᨣᨲᨸ᩠ᨹᩃᩣ, ᩈᨾ᩠ᨻᩮᩣᨵᩥᨵᨾ᩠ᨾᩮ ᨶᩥᨿᨲᩣ ᩋᨶᩣᨾᨿᩣ’’ᨲᩥ.

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

ᨻᩩᨴ᩠ᨵᩮ ᨧ ᨵᨾ᩠ᨾᩮ ᨧ ᨸᩈᨶ᩠ᨶᨾᩣᨶᩈᩮ, ᩈᨦ᩠ᨥᩮ ᨧ ᩑᨠᨶ᩠ᨲᨣᨲᩮ ᩋᩈᩴᩈᨿᩮ;

ᩋᨡᨱ᩠ᨯᩈᩥᨠ᩠ᨡᩣᨸᨴᩮ ᩌᨣᨲᨸ᩠ᨹᩃᩮ, ᩈᨾ᩠ᨻᩮᩣᨵᩥᨵᨾ᩠ᨾᩮ ᨶᩥᨿᨲᩮ ᩋᨶᩣᨾᨿᩮ’’ᨲᩥ.

ᨸᨬ᩠ᨧ ᨸᩦᨮᩣ ᨲᨿᩮᩣ ᨶᩣᩅᩣ, ᨴᩦᨸᨲᩥᩃᨴᨠ᩠ᨡᩥᨱᩣ ᨴ᩠ᩅᩮ;

ᨸᨲᩥ ᨴ᩠ᩅᩮ ᩈᩩᨱᩥᩈᩣ ᩏᨲ᩠ᨲᩁᩣ, ᩈᩥᩁᩥᨾᩣ ᨠᩮᩈᨠᩣᩁᩥᨠᩣ;

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

ᩈᨾᨶ᩠ᨲᩣ ᩋᨶᩩᨸᩁᩥᨿᩣᩈᩥ, ᨶᩣᩁᩦᨣᨱᨸᩩᩁᨠ᩠ᨡᨲᩣ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ¶ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᨠᩮᨶ ᨲᩮ ᩍᨵ ᨾᩥᨩ᩠ᨫᨲᩥ;

ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨧ ᨲᩮ ᨽᩮᩣᨣᩣ, ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

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

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩣ, ᨴᩣᩈᩦ ᩋᩉᩮᩣᩈᩥᩴ ᨸᩁᨸᩮᩔᩥᨿᩣ [ᨸᩁᨸᩮᩈᩥᨿᩣ (ᨠ.)] ᨠᩩᩃᩮ.

‘‘ᩏᨸᩣᩈᩥᨠᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ;

ᨲᩔᩣ ᨾᩮ ᨶᩥᨠ᩠ᨠᨾᩮᩣ ᩌᩈᩥ, ᩈᩣᩈᨶᩮ ᨲᩔ ᨲᩣᨴᩥᨶᩮᩣ.

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

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

‘‘ᩋᨠᨱ᩠ᨭᨠᩮᩣ ᩋᨣᩉᨶᩮᩣ, ᩏᨩᩩ ᩈᨻ᩠ᨽᩥ ᨸᩅᩮᨴᩥᨲᩮᩣ;

ᨶᩥᨠ᩠ᨠᨾᩔ ᨹᩃᩴ ᨸᩔ, ᨿᨳᩥᨴᩴ ᨸᩣᨸᩩᨱᩥᨲ᩠ᨳᩥᨠᩣ.

‘‘ᩌᨾᨶ᩠ᨲᨶᩥᨠᩣ ᩁᨬ᩠ᨬᩮᩣᨾ᩠ᩉᩥ, ᩈᨠ᩠ᨠᩔ ᩅᩈᩅᨲ᩠ᨲᩥᨶᩮᩣ;

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

‘‘ᩌᩃᨾ᩠ᨻᩮᩣ ᨣᨣ᩠ᨣᩁᩮᩣ [ᨣᨣ᩠ᨣᨾᩮᩣ (ᩈ᩠ᨿᩣ.), ᨽᨣ᩠ᨣᩁᩮᩣ (ᨠ.)] ᨽᩦᨾᩮᩣ [ᨽᩥᨾ᩠ᨾᩮᩣ (ᨠ.)], ᩈᩣᨵᩩᩅᩣᨴᩦ ᨧ ᩈᩴᩈᨿᩮᩣ;

ᨸᩮᩣᨠ᩠ᨡᩁᩮᩣ ¶ ᨧ ᩈᩩᨹᩔᩮᩣ ᨧ, ᩅᩥᨱᩣᨾᩮᩣᨠ᩠ᨡᩣ [ᩅᩥᩃᩣᨾᩮᩣᨠ᩠ᨡᩣ (ᨠ.)] ᨧ ᨶᩣᩁᩥᨿᩮᩣ.

‘‘ᨶᨶ᩠ᨴᩣ ᨧᩮᩅ ᩈᩩᨶᨶ᩠ᨴᩣ ᨧ, ᩈᩮᩣᨱᨴᩥᨶ᩠ᨶᩣ ᩈᩩᨧᩥᨾ᩠ᩉᩥᨲᩣ [ᩈᩩᨧᩥᨾ᩠ᨽᩥᨠᩣ (ᩈ᩠ᨿᩣ.)];

ᩋᩃᨾ᩠ᨻᩩᩈᩣ ᨾᩥᩔᨠᩮᩈᩦ ᨧ, ᨸᩩᨱ᩠ᨯᩁᩦᨠᩣᨲᩥ ᨴᩣᩁᩩᨱᩦ.

‘‘ᩑᨱᩦᨹᩔᩣ ᩈᩩᨹᩔᩣ ᨧ, ᩈᩩᨽᨴ᩠ᨴᩣ ᨾᩩᨴᩩᩅᩣᨴᩥᨶᩦ;

ᩑᨲᩣ ᨧᨬ᩠ᨬᩣ ᨧ ᩈᩮᨿ᩠ᨿᩣᩈᩮ, ᩋᨧ᩠ᨨᩁᩣᨶᩴ ᨸᨻᩮᩣᨵᩥᨠᩣ.

‘‘ᨲᩣ ¶ ᨾᩴ ᨠᩣᩃᩮᨶᩩᨸᩣᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩋᨽᩥᨽᩣᩈᨶ᩠ᨲᩥ ᨴᩮᩅᨲᩣ;

ᩉᨶ᩠ᨴ ᨶᨧ᩠ᨧᩣᨾ ᨣᩣᨿᩣᨾ, ᩉᨶ᩠ᨴ ᨲᩴ ᩁᨾᨿᩣᨾᩈᩮ.

‘‘ᨶᨿᩥᨴᩴ ¶ ᩋᨠᨲᨸᩩᨬ᩠ᨬᩣᨶᩴ, ᨠᨲᨸᩩᨬ᩠ᨬᩣᨶᨾᩮᩅᩥᨴᩴ;

ᩋᩈᩮᩣᨠᩴ ᨶᨶ᩠ᨴᨶᩴ ᩁᨾ᩠ᨾᩴ, ᨲᩥᨴᩈᩣᨶᩴ ᨾᩉᩣᩅᨶᩴ.

‘‘ᩈᩩᨡᩴ ᩋᨠᨲᨸᩩᨬ᩠ᨬᩣᨶᩴ, ᩍᨵ ᨶᨲ᩠ᨳᩥ ᨸᩁᨲ᩠ᨳ ᨧ;

ᩈᩩᨡᨬ᩠ᨧ ᨠᨲᨸᩩᨬ᩠ᨬᩣᨶᩴ, ᩍᨵ ᨧᩮᩅ ᨸᩁᨲ᩠ᨳ ᨧ.

‘‘ᨲᩮᩈᩴ ᩈᩉᨻ᩠ᨿᨠᩣᨾᩣᨶᩴ, ᨠᨲ᩠ᨲᨻ᩠ᨻᩴ ᨠᩩᩈᩃᩴ ᨻᩉᩩᩴ;

ᨠᨲᨸᩩᨬ᩠ᨬᩣ ᩉᩥ ᨾᩮᩣᨴᨶ᩠ᨲᩥ, ᩈᨣ᩠ᨣᩮ ᨽᩮᩣᨣᩈᨾᨦ᩠ᨣᩥᨶᩮᩣ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᨠᩮᨶ ᨲᩮ ᩍᨵ ᨾᩥᨩ᩠ᨫᨲᩥ;

ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨧ ᨲᩮ ᨽᩮᩣᨣᩣ, ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨴᩮᩅᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ, ᨾᨶᩩᩔᨽᩪᨲᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩣ;

ᨸᨬ᩠ᩉᩴ ¶ ᨸᩩᨭ᩠ᨮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨠᩮᩅᨭ᩠ᨭᨴ᩠ᩅᩣᩁᩣ ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ, ᩋᩉᩩ ᨾᨿ᩠ᩉᩴ ᨶᩥᩅᩮᩈᨶᩴ;

ᨲᨲ᩠ᨳ ᩈᨬ᩠ᨧᩁᨾᩣᨶᩣᨶᩴ, ᩈᩣᩅᨠᩣᨶᩴ ᨾᩉᩮᩈᩥᨶᩴ.

‘‘ᩒᨴᨶᩴ ᨠᩩᨾ᩠ᨾᩣᩈᩴ [ᩈᩣᨠᩴ (ᩈᩦ.)] ᨯᩣᨠᩴ, ᩃᩮᩣᨱᩈᩮᩣᩅᩦᩁᨠᨬ᩠ᨧᩉᩴ;

ᩋᨴᩣᩈᩥᩴ ᩏᨩᩩᨽᩪᨲᩮᩈᩩ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ.

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

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

‘‘ᩏᨸᩮᩣᩈᨳᩴ ¶ ᩏᨸᩅᩈᩥᩔᩴ, ᩈᨴᩣ ᩈᩦᩃᩮᩈᩩ ᩈᩴᩅᩩᨲᩣ;

ᩈᨬ᩠ᨬᨾᩣ ᩈᩴᩅᩥᨽᩣᨣᩣ ᨧ, ᩅᩥᨾᩣᨶᩴ ᩌᩅᩈᩣᨾᩉᩴ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ¶ ᩅᩥᩁᨲᩣ, ᨾᩩᩈᩣᩅᩣᨴᩣ ᨧ ᩈᨬ᩠ᨬᨲᩣ;

ᨳᩮᨿ᩠ᨿᩣ ᨧ ᩋᨲᩥᨧᩣᩁᩣ ᨧ, ᨾᨩ᩠ᨩᨸᩣᨶᩣ ᨧ ᩌᩁᨠᩣ.

‘‘ᨸᨬ᩠ᨧᩈᩥᨠ᩠ᨡᩣᨸᨴᩮ ᩁᨲᩣ, ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶ ᨠᩮᩣᩅᩥᨴᩣ;

ᩏᨸᩣᩈᩥᨠᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦᨲᩥ.

‘‘ᨾᨾ ᨧ, ᨽᨶ᩠ᨲᩮ, ᩅᨧᨶᩮᨶ ᨽᨣᩅᨲᩮᩣ ᨸᩣᨴᩮ ᩈᩥᩁᩈᩣ ᩅᨶ᩠ᨴᩮᨿ᩠ᨿᩣᩈᩥ – ‘ᩃᨡᩩᨾᩣ ᨶᩣᨾ,ᨽᨶ᩠ᨲᩮ,ᩏᨸᩣᩈᩥᨠᩣ ᨽᨣᩅᨲᩮᩣ ᨸᩣᨴᩮ ᩈᩥᩁᩈᩣ ᩅᨶ᩠ᨴᨲᩦ’ᨲᩥ. ᩋᨶᨧ᩠ᨨᩁᩥᨿᩴ ᨡᩮᩣ ᨸᨶᩮᨲᩴ, ᨽᨶ᩠ᨲᩮ, ᨿᩴ ᨾᩴ ᨽᨣᩅᩣ ᩋᨬ᩠ᨬᨲᩁᩈ᩠ᨾᩥᩴ ᩈᩣᨾᨬ᩠ᨬᨹᩃᩮ ᨻ᩠ᨿᩣᨠᩁᩮᨿ᩠ᨿ [ᨻ᩠ᨿᩣᨠᩁᩮᨿ᩠ᨿᩣᨲᩥ (?)]. ᨲᩴ ᨽᨣᩅᩣ ᩈᨠᨴᩣᨣᩣᨾᩥᨹᩃᩮ ᨻ᩠ᨿᩣᨠᩣᩈᩦ’’ᨲᩥ.

‘‘ᨸᩥᨱ᩠ᨯᩣᨿ ¶ ¶ ᨲᩮ ᨧᩁᨶ᩠ᨲᩔ, ᨲᩩᨱ᩠ᩉᩦᨽᩪᨲᩔ ᨲᩥᨭ᩠ᨮᨲᩮᩣ;

ᨴᩃᩥᨴ᩠ᨴᩣ ᨠᨸᨱᩣ ᨶᩣᩁᩦ, ᨸᩁᩣᨣᩣᩁᩴ ᩋᨸᩔᩥᨲᩣ [ᩋᩅᩔᩥᨲᩣ (ᩈᩦ.)].

‘‘ᨿᩣ ᨲᩮ ᩋᨴᩣᩈᩥ ᩌᨧᩣᨾᩴ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ;

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

‘‘ᨸᩥᨱ᩠ᨯᩣᨿ ᨾᩮ ᨧᩁᨶ᩠ᨲᩔ, ᨲᩩᨱ᩠ᩉᩦᨽᩪᨲᩔ ᨲᩥᨭ᩠ᨮᨲᩮᩣ;

ᨴᩃᩥᨴ᩠ᨴᩣ ᨠᨸᨱᩣ ᨶᩣᩁᩦ, ᨸᩁᩣᨣᩣᩁᩴ ᩋᨸᩔᩥᨲᩣ.

‘‘ᨿᩣ ᨾᩮ ᩋᨴᩣᩈᩥ ᩌᨧᩣᨾᩴ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ;

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

‘‘ᨶᩥᨾ᩠ᨾᩣᨶᩁᨲᩥᨶᩮᩣ ᨶᩣᨾ, ᩈᨶ᩠ᨲᩥ ᨴᩮᩅᩣ ᨾᩉᩥᨴ᩠ᨵᩥᨠᩣ;

ᨲᨲ᩠ᨳ ᩈᩣ ᩈᩩᨡᩥᨲᩣ ᨶᩣᩁᩦ, ᨾᩮᩣᨴᨲᩣᨧᩣᨾᨴᩣᨿᩥᨠᩣ’’ᨲᩥ.

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

ᨸᩁᩣᨽᨲᩮᨶ ᨴᩣᨶᩮᨶ, ᩍᨩ᩠ᨫᩥᨲ᩠ᨳ ᩅᨲ ᨴᨠ᩠ᨡᩥᨱᩣ.

‘‘ᨿᩣ ᨾᩉᩮᩈᩥᨲ᩠ᨲᩴ ᨠᩣᩁᩮᨿ᩠ᨿ, ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩥᩔ ᩁᩣᨩᩥᨶᩮᩣ;

ᨶᩣᩁᩦ ᩈᨻ᩠ᨻᨦ᩠ᨣᨠᩃ᩠ᨿᩣᨱᩦ, ᨽᨲ᩠ᨲᩩ ᨧᩣᨶᩮᩣᨾᨴᩔᩥᨠᩣ;

ᩑᨲᩔᩣᨧᩣᨾᨴᩣᨶᩔ ¶ , ᨠᩃᩴ ᨶᩣᨣ᩠ᨥᨲᩥ ᩈᩮᩣᩊᩈᩥᩴ.

‘‘ᩈᨲᩴ ¶ ᨶᩥᨠ᩠ᨡᩣ ᩈᨲᩴ ᩋᩔᩣ, ᩈᨲᩴ ᩋᩔᨲᩁᩦᩁᨳᩣ;

ᩈᨲᩴ ᨠᨬ᩠ᨬᩣᩈᩉᩔᩣᨶᩥ, ᩌᨾᩩᨲ᩠ᨲᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᩣ;

ᩑᨲᩔᩣᨧᩣᨾᨴᩣᨶᩔ, ᨠᩃᩴ ᨶᩣᨣ᩠ᨥᨶ᩠ᨲᩥ ᩈᩮᩣᩊᩈᩥᩴ.

‘‘ᩈᨲᩴ ᩉᩮᨾᩅᨲᩣ ᨶᩣᨣᩣ, ᩎᩈᩣᨴᨶ᩠ᨲᩣ ᩏᩁᩪᩊ᩠ᩉᩅᩣ;

ᩈᩩᩅᨱ᩠ᨱᨠᨧ᩠ᨨᩣ ᨾᩣᨲᨦ᩠ᨣᩣ, ᩉᩮᨾᨠᨸ᩠ᨸᨶᩅᩣᩈᩈᩣ [ᩉᩮᨾᨠᨸ᩠ᨸᨶᩥᩅᩣᩈᩈᩣ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᩑᨲᩔᩣᨧᩣᨾᨴᩣᨶᩔ, ᨠᩃᩴ ᨶᩣᨣ᩠ᨥᨲᩥ ᩈᩮᩣᩊᩈᩥᩴ.

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

ᩑᨲᩔᩣᨧᩣᨾᨴᩣᨶᩔ, ᨠᩃᩴ ᨶᩣᨣ᩠ᨥᨲᩥ ᩈᩮᩣᩊᩈᩥ’’ᨶ᩠ᨲᩥ.

‘‘ᨧᨱ᩠ᨯᩣᩃᩥ ᩅᨶ᩠ᨴ ᨸᩣᨴᩣᨶᩥ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ;

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

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

ᨡᩥᨸ᩠ᨸᩴ ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᩅᨶ᩠ᨴ, ᨸᩁᩥᨲ᩠ᨲᩴ ᨲᩅ ᨩᩦᩅᩥᨲ’’ᨶ᩠ᨲᩥ.

ᨧᩮᩣᨴᩥᨲᩣ ᨽᩣᩅᩥᨲᨲ᩠ᨲᩮᨶ, ᩈᩁᩦᩁᨶ᩠ᨲᩥᨾᨵᩣᩁᩥᨶᩣ;

ᨧᨱ᩠ᨯᩣᩃᩦ ᩅᨶ᩠ᨴᩥ ᨸᩣᨴᩣᨶᩥ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

ᨲᨾᩮᨶᩴ ᩋᩅᨵᩦ ᨣᩣᩅᩦ, ᨧᨱ᩠ᨯᩣᩃᩥᩴ ᨸᨬ᩠ᨩᩃᩥᩴ ᨮᩥᨲᩴ;

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

‘‘ᨡᩦᨱᩣᩈᩅᩴ ¶ ᩅᩥᨣᨲᩁᨩᩴ ᩋᨶᩮᨩᩴ, ᩑᨠᩴ ᩋᩁᨬ᩠ᨬᨾ᩠ᩉᩥ ᩁᩉᩮᩣ ᨶᩥᩈᩥᨶ᩠ᨶᩴ;

ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩣ ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ, ᩅᨶ᩠ᨴᩣᨾᩥ ᨲᩴ ᩅᩦᩁ ᨾᩉᩣᨶᩩᨽᩣᩅ’’ᨶ᩠ᨲᩥ.

‘‘ᩈᩩᩅᨱ᩠ᨱᩅᨱ᩠ᨱᩣ ᨩᩃᩥᨲᩣ ᨾᩉᩣᨿᩈᩣ, ᩅᩥᨾᩣᨶᨾᩮᩣᩁᩩᨿ᩠ᩉ ᩋᨶᩮᨠᨧᩥᨲ᩠ᨲᩣ;

ᨸᩁᩥᩅᩣᩁᩥᨲᩣ ᩋᨧ᩠ᨨᩁᩣᩈᨦ᩠ᨣᨱᩮᨶ [ᩋᨧ᩠ᨨᩁᩣᨶᩴ ᨣᨱᩮᨶ (ᩈᩦ.)], ᨠᩣ ᨲ᩠ᩅᩴ ᩈᩩᨽᩮ ᨴᩮᩅᨲᩮ ᩅᨶ᩠ᨴᩈᩮ ᨾᨾ’’ᨶ᩠ᨲᩥ.

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

ᩅᨶ᩠ᨴᩥᩴ ¶ ᩋᩁᩉᨲᩮᩣ ᨸᩣᨴᩮ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

‘‘ᩈᩣᩉᩴ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ [ᩅᨶ᩠ᨴᩥᨲ᩠ᩅ (ᩈᩦ.)] ᨸᩣᨴᩣᨶᩥ, ᨧᩩᨲᩣ ᨧᨱ᩠ᨯᩣᩃᨿᩮᩣᨶᩥᨿᩣ;

ᩅᩥᨾᩣᨶᩴ ᩈᨻ᩠ᨻᨲᩮᩣ ᨽᨴ᩠ᨴᩴ, ᩏᨸᨸᨶ᩠ᨶᨾ᩠ᩉᩥ ᨶᨶ᩠ᨴᨶᩮ.

‘‘ᩋᨧ᩠ᨨᩁᩣᨶᩴ ¶ ᩈᨲᩈᩉᩔᩴ, ᨸᩩᩁᨠ᩠ᨡᨲ᩠ᩅᩣᨶ [ᨸᩩᩁᨠ᩠ᨡᩥᨲ᩠ᩅᩣ ᨾᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨲᩥᨭ᩠ᨮᨲᩥ;

ᨲᩣᩈᩣᩉᩴ ᨸᩅᩁᩣ ᩈᩮᨭ᩠ᨮᩣ, ᩅᨱ᩠ᨱᩮᨶ ᨿᩈᩈᩣᨿᩩᨶᩣ.

‘‘ᨸᩉᩪᨲᨠᨲᨠᩃ᩠ᨿᩣᨱᩣ, ᩈᨾ᩠ᨸᨩᩣᨶᩣ ᨸᨭᩥᩔᨲᩣ [ᨸᨲᩥᩔᨲᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

ᨾᩩᨶᩥᩴ ᨠᩣᩁᩩᨱᩥᨠᩴ ᩃᩮᩣᨠᩮ, ᨲᩴ ᨽᨶ᩠ᨲᩮ ᩅᨶ᩠ᨴᩥᨲᩩᨾᩣᨣᨲᩣ’’ᨲᩥ.

ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᨧᨱ᩠ᨯᩣᩃᩦ, ᨠᨲᨬ᩠ᨬᩪ ᨠᨲᩅᩮᨴᩥᨶᩦ;

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

‘‘ᨶᩦᩃᩣ ᨸᩦᨲᩣ ᨧ ᨠᩣᩊᩣ ᨧ, ᨾᨬ᩠ᨩᩥᨭ᩠ᨮᩣ [ᨾᨬ᩠ᨩᩮᨭ᩠ᨮᩣ (ᩈᩦ.), ᨾᨬ᩠ᨩᨭ᩠ᨮᩣ (ᨸᩦ.)] ᩋᨳ ᩃᩮᩣᩉᩥᨲᩣ;

ᩏᨧ᩠ᨧᩣᩅᨧᩣᨶᩴ ᩅᨱ᩠ᨱᩣᨶᩴ, ᨠᩥᨬ᩠ᨩᨠ᩠ᨡᨸᩁᩥᩅᩣᩁᩥᨲᩣ.

‘‘ᨾᨶ᩠ᨴᩣᩁᩅᩣᨶᩴ ᨸᩩᨸ᩠ᨹᩣᨶᩴ, ᨾᩣᩃᩴ ᨵᩣᩁᩮᩈᩥ ᨾᩩᨴ᩠ᨵᨶᩥ;

ᨶᨿᩥᨾᩮ ᩋᨬ᩠ᨬᩮᩈᩩ ᨠᩣᨿᩮᩈᩩ, ᩁᩩᨠ᩠ᨡᩣ ᩈᨶ᩠ᨲᩥ ᩈᩩᨾᩮᨵᩈᩮ.

‘‘ᨠᩮᨶ ¶ ¶ ᨠᩣᨿᩴ ᩏᨸᨸᨶ᩠ᨶᩣ, ᨲᩣᩅᨲᩥᩴᩈᩴ ᨿᩈᩔᩥᨶᩦ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᨽᨴ᩠ᨴᩥᨲ᩠ᨳᩥᨠᩣᨲᩥ [ᨽᨴ᩠ᨴᩥᨲ᩠ᨳᩦᨲᩥ (ᩈᩦ.)] ᨾᩴ ᩋᨬ᩠ᨬᩴᩈᩩ, ᨠᩥᨾᩥᩃᩣᨿᩴ ᩏᨸᩣᩈᩥᨠᩣ;

ᩈᨴ᩠ᨵᩣ ᩈᩦᩃᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩈᩴᩅᩥᨽᩣᨣᩁᨲᩣ ᩈᨴᩣ.

‘‘ᩋᨧ᩠ᨨᩣᨴᨶᨬ᩠ᨧ ᨽᨲ᩠ᨲᨬ᩠ᨧ, ᩈᩮᨶᩣᩈᨶᩴ ᨸᨴᩦᨸᩥᨿᩴ;

ᩋᨴᩣᩈᩥᩴ ᩏᨩᩩᨽᩪᨲᩮᩈᩩ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ.

‘‘ᨧᩣᨲᩩᨴ᩠ᨴᩈᩥᩴ ¶ ᨸᨬ᩠ᨧᨴᩈᩥᩴ, ᨿᩣ ᨧ ᨸᨠ᩠ᨡᩔ ᩋᨭ᩠ᨮᨾᩦ;

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

‘‘ᩏᨸᩮᩣᩈᨳᩴ ᩏᨸᩅᩈᩥᩔᩴ, ᩈᨴᩣ ᩈᩦᩃᩮᩈᩩ ᩈᩴᩅᩩᨲᩣ;

ᩈᨬ᩠ᨬᨾᩣ ᩈᩴᩅᩥᨽᩣᨣᩣ ᨧ, ᩅᩥᨾᩣᨶᩴ ᩌᩅᩈᩣᨾᩉᩴ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ᩅᩥᩁᨲᩣ, ᨾᩩᩈᩣᩅᩣᨴᩣ ᨧ ᩈᨬ᩠ᨬᨲᩣ;

ᨳᩮᨿ᩠ᨿᩣ ᨧ ᩋᨲᩥᨧᩣᩁᩣ ᨧ, ᨾᨩ᩠ᨩᨸᩣᨶᩣ ᨧ ᩌᩁᨠᩣ.

‘‘ᨸᨬ᩠ᨧᩈᩥᨠ᩠ᨡᩣᨸᨴᩮ ᩁᨲᩣ, ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶ ᨠᩮᩣᩅᩥᨴᩣ;

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

ᨠᨲᩣᩅᩣᩈᩣ ᨠᨲᨠᩩᩈᩃᩣ ᨲᨲᩮᩣ ᨧᩩᨲᩣ [ᨠᨲᩣᩅᨠᩣᩈᩣ ᨠᨲᨠᩩᩈᩃᩣ (ᨠ.)],

‘‘ᨽᩥᨠ᩠ᨡᩪ ᨧᩣᩉᩴ ᨸᩁᨾᩉᩥᨲᩣᨶᩩᨠᨾ᩠ᨸᨠᩮ, ᩋᨽᩮᩣᨩᨿᩥᩴ ᨲᨸᩔᩥᨿᩩᨣᩴ ᨾᩉᩣᨾᩩᨶᩥᩴ;

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

‘‘ᩋᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩴ ᩋᨸᩁᩥᨾᩥᨲᩴ ᩈᩩᨡᩣᩅᩉᩴ, ᩏᨸᩮᩣᩈᨳᩴ ᩈᨲᨲᨾᩩᨸᩣᩅᩈᩥᩴ ᩋᩉᩴ;

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

ᨽᨴ᩠ᨴᩥᨲ᩠ᨳᩥᩅᩥᨾᩣᨶᩴ [ᨽᨴ᩠ᨴᩥᨲ᩠ᨳᩥᨠᩣᩅᩥᨾᩣᨶᩴ (ᩈ᩠ᨿᩣ.)] ᨸᨬ᩠ᨧᨾᩴ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ¶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ¶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᨠᩮᨶ ᨲᩮ ᩍᨵ ᨾᩥᨩ᩠ᨫᨲᩥ;

ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨧ ᨲᩮ ᨽᩮᩣᨣᩣ, ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨴᩮᩅᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ, ᨾᨶᩩᩔᨽᩪᨲᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩈᩮᩣᨱᨴᩥᨶ᩠ᨶᩣᨲᩥ ᨾᩴ ᩋᨬ᩠ᨬᩴᩈᩩ, ᨶᩣᩊᨶ᩠ᨴᩣᨿᩴ ᩏᨸᩣᩈᩥᨠᩣ;

ᩈᨴ᩠ᨵᩣ ᩈᩦᩃᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩈᩴᩅᩥᨽᩣᨣᩁᨲᩣ ᩈᨴᩣ.

‘‘ᩋᨧ᩠ᨨᩣᨴᨶᨬ᩠ᨧ ᨽᨲ᩠ᨲᨬ᩠ᨧ, ᩈᩮᨶᩣᩈᨶᩴ ᨸᨴᩦᨸᩥᨿᩴ;

ᩋᨴᩣᩈᩥᩴ ᩏᨩᩩᨽᩪᨲᩮᩈᩩ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ.

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

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

‘‘ᩏᨸᩮᩣᩈᨳᩴ ᩏᨸᩅᩈᩥᩔᩴ, ᩈᨴᩣ ᩈᩦᩃᩮᩈᩩ ᩈᩴᩅᩩᨲᩣ;

ᩈᨬ᩠ᨬᨾᩣ ᩈᩴᩅᩥᨽᩣᨣᩣ ᨧ, ᩅᩥᨾᩣᨶᩴ ᩌᩅᩈᩣᨾᩉᩴ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ᩅᩥᩁᨲᩣ, ᨾᩩᩈᩣᩅᩣᨴᩣ ᨧ ᩈᨬ᩠ᨬᨲᩣ;

ᨳᩮᨿ᩠ᨿᩣ ᨧ ᩋᨲᩥᨧᩣᩁᩣ ᨧ, ᨾᨩ᩠ᨩᨸᩣᨶᩣ ᨧ ᩌᩁᨠᩣ.

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

ᩏᨸᩣᩈᩥᨠᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

ᩅᨱ᩠ᨱᩮᩣ ¶ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ¶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩏᨸᩮᩣᩈᨳᩣᨲᩥ ᨾᩴ ᩋᨬ᩠ᨬᩴᩈᩩ, ᩈᩣᨠᩮᨲᩣᨿᩴ ᩏᨸᩣᩈᩥᨠᩣ;

ᩈᨴ᩠ᨵᩣ ᩈᩦᩃᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩈᩴᩅᩥᨽᩣᨣᩁᨲᩣ ᩈᨴᩣ.

‘‘ᩋᨧ᩠ᨨᩣᨴᨶᨬ᩠ᨧ ᨽᨲ᩠ᨲᨬ᩠ᨧ, ᩈᩮᨶᩣᩈᨶᩴ ᨸᨴᩦᨸᩥᨿᩴ;

ᩋᨴᩣᩈᩥᩴ ᩏᨩᩩᨽᩪᨲᩮᩈᩩ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ.

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

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

‘‘ᩏᨸᩮᩣᩈᨳᩴ ᩏᨸᩅᩈᩥᩔᩴ, ᩈᨴᩣ ᩈᩦᩃᩮᩈᩩ ᩈᩴᩅᩩᨲᩣ;

ᩈᨬ᩠ᨬᨾᩣ ᩈᩴᩅᩥᨽᩣᨣᩣ ᨧ, ᩅᩥᨾᩣᨶᩴ ᩌᩅᩈᩣᨾᩉᩴ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ᩅᩥᩁᨲᩣ, ᨾᩩᩈᩣᩅᩣᨴᩣ ᨧ ᩈᨬ᩠ᨬᨲᩣ;

ᨳᩮᨿ᩠ᨿᩣ ᨧ ᩋᨲᩥᨧᩣᩁᩣ ᨧ, ᨾᨩ᩠ᨩᨸᩣᨶᩣ ᨧ ᩌᩁᨠᩣ.

‘‘ᨸᨬ᩠ᨧᩈᩥᨠ᩠ᨡᩣᨸᨴᩮ ᩁᨲᩣ, ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶ ᨠᩮᩣᩅᩥᨴᩣ;

ᩏᨸᩣᩈᩥᨠᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

ᩅᨱ᩠ᨱᩮᩣ ¶ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨡᨱᩴ ¶ ᨶᨶ᩠ᨴᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨨᨶ᩠ᨴᩮᩣ ᨾᩮ ᩏᨴᨸᨩ᩠ᨩᨳ [ᩏᨸᨸᨩ᩠ᨩᨳ (ᨻᩉᩪᩈᩩ)];

ᨲᨲ᩠ᨳ ᨧᩥᨲ᩠ᨲᩴ ᨸᨱᩥᨵᩣᨿ, ᩏᨸᨸᨶ᩠ᨶᨾ᩠ᩉᩥ ᨶᨶ᩠ᨴᨶᩴ.

‘‘ᨶᩣᨠᩣᩈᩥᩴ ¶ ᩈᨲ᩠ᨳᩩ ᩅᨧᨶᩴ, ᨻᩩᨴ᩠ᨵᩔᩣᨴᩥᨧ᩠ᨧᨻᨶ᩠ᨵᩩᨶᩮᩣ;

ᩉᩦᨶᩮ ᨧᩥᨲ᩠ᨲᩴ ᨸᨱᩥᨵᩣᨿ, ᩈᩣᨾ᩠ᩉᩥ ᨸᨧ᩠ᨨᩣᨶᩩᨲᩣᨸᩥᨶᩦ’’ᨲᩥ.

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

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨿᨴᩥ ᨩᩣᨶᩣᩈᩥ ᩌᨿᩩᨶᩮᩣ’’ᨲᩥ.

‘‘ᩈᨭ᩠ᨮᩥᩅᩔᩈᩉᩔᩣᨶᩥ ¶ [ᩈᨭ᩠ᨮᩥ ᩈᨲᩈᩉᩔᩣᨶᩥ (?)], ᨲᩥᩔᩮᩣ ᨧ ᩅᩔᨠᩮᩣᨭᩥᨿᩮᩣ;

ᩍᨵ ᨮᨲ᩠ᩅᩣ ᨾᩉᩣᨾᩩᨶᩥ, ᩍᨲᩮᩣ ᨧᩩᨲᩣ ᨣᨾᩥᩔᩣᨾᩥ;

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

ᩈᩮᩣᨲᩣᨸᨶ᩠ᨶᩣ ᩅᩥᩈᩮᩈᨿᩥ, ᨸᩉᩦᨶᩣ ᨲᩅ ᨴᩩᨣ᩠ᨣᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᩈᨴ᩠ᨵᩣ ᩈᩦᩃᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩈᩴᩅᩥᨽᩣᨣᩁᨲᩣ ᩈᨴᩣ.

‘‘ᩋᨧ᩠ᨨᩣᨴᨶᨬ᩠ᨧ ¶ ¶ ᨽᨲ᩠ᨲᨬ᩠ᨧ, ᩈᩮᨶᩣᩈᨶᩴ ᨸᨴᩦᨸᩥᨿᩴ;

ᩋᨴᩣᩈᩥᩴ ᩏᨩᩩᨽᩪᨲᩮᩈᩩ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ.

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

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

‘‘ᩏᨸᩮᩣᩈᨳᩴ ᩏᨸᩅᩈᩥᩔᩴ, ᩈᨴᩣ ᩈᩦᩃᩮᩈᩩ ᩈᩴᩅᩩᨲᩣ;

ᩈᨬ᩠ᨬᨾᩣ ᩈᩴᩅᩥᨽᩣᨣᩣ ᨧ, ᩅᩥᨾᩣᨶᩴ ᩌᩅᩈᩣᨾᩉᩴ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ¶ ᩅᩥᩁᨲᩣ, ᨾᩩᩈᩣᩅᩣᨴᩣ ᨧ ᩈᨬ᩠ᨬᨲᩣ;

ᨳᩮᨿ᩠ᨿᩣ ᨧ ᩋᨲᩥᨧᩣᩁᩣ ᨧ, ᨾᨩ᩠ᨩᨸᩣᨶᩣ ᨧ ᩌᩁᨠᩣ.

‘‘ᨸᨬ᩠ᨧᩈᩥᨠ᩠ᨡᩣᨸᨴᩮ ᩁᨲᩣ, ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶ ᨠᩮᩣᩅᩥᨴᩣ;

ᩏᨸᩣᩈᩥᨠᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᨶᩥᨴ᩠ᨴᩣᩅᩥᨾᩣᨶᩴ [ᩈᨴ᩠ᨵᩣᩅᩥᨾᩣᨶᩴ (ᩈᩦ.)] ᩋᨭ᩠ᨮᨾᩴ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩈᩩᨶᩥᨴ᩠ᨴᩣᨲᩥ ¶ [ᩈᩩᨶᨶ᩠ᨴᩣᨲᩥ (ᩈᩦ.)] ᨾᩴ ᩋᨬ᩠ᨬᩴᩈᩩ, ᩁᩣᨩᨣᩉᩈ᩠ᨾᩥᩴ ᩏᨸᩣᩈᩥᨠᩣ;

ᩈᨴ᩠ᨵᩣ ᩈᩦᩃᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩈᩴᩅᩥᨽᩣᨣᩁᨲᩣ ᩈᨴᩣ.

(ᨿᨳᩣ ᨶᩥᨴ᩠ᨴᩣᩅᩥᨾᩣᨶᩴ ᨲᨳᩣ ᩅᩥᨲ᩠ᨳᩣᩁᩮᨲᨻ᩠ᨻᩴ.)

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

ᩏᨸᩣᩈᩥᨠᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

᪑᪐. ᨸᨮᨾᨽᩥᨠ᩠ᨡᩣᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ¶ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ¶ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩣ, ᨸᩩᩁᩥᨾᩣᨿ ᨩᩣᨲᩥᨿᩣ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ.

‘‘ᩋᨴ᩠ᨴᩈᩴ ¶ ¶ ᩅᩥᩁᨩᩴ ᨻᩩᨴ᩠ᨵᩴ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᨾᨶᩣᩅᩥᩃᩴ;

ᨲᩔ ᩋᨴᩣᩈᩉᩴ ᨽᩥᨠ᩠ᨡᩴ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

᪑᪑. ᨴᩩᨲᩥᨿᨽᩥᨠ᩠ᨡᩣᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩣ, ᨸᩩᩁᩥᨾᩣᨿ ᨩᩣᨲᩥᨿᩣ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ.

‘‘ᩋᨴ᩠ᨴᩈᩴ ᩅᩥᩁᨩᩴ ᨽᩥᨠ᩠ᨡᩩᩴ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᨾᨶᩣᩅᩥᩃᩴ;

ᨲᩔ ᩋᨴᩣᩈᩉᩴ ᨽᩥᨠ᩠ᨡᩴ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ. ¶ … ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᨴᩩᨲᩥᨿᨽᩥᨠ᩠ᨡᩣᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩴ ᩑᨠᩣᨴᩈᨾᩴ.

ᨧᩥᨲ᩠ᨲᩃᨲᩣᩅᨣ᩠ᨣᩮᩣ ᨴᩩᨲᩥᨿᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

ᨴᩣᩈᩦ ¶ ᨧᩮᩅ ᩃᨡᩩᨾᩣ ᨧ, ᩋᨳ ᩌᨧᩣᨾᨴᩣᨿᩥᨠᩣ;

ᨧᨱ᩠ᨯᩣᩃᩦ ¶ ᨽᨴ᩠ᨴᩥᨲ᩠ᨳᩦ ᨧᩮᩅ [ᨽᨴ᩠ᨴᩥᨲ᩠ᨳᩥᨠᩣ ᨧ (ᩈ᩠ᨿᩣ.)], ᩈᩮᩣᨱᨴᩥᨶ᩠ᨶᩣ ᩏᨸᩮᩣᩈᨳᩣ;

ᨶᩥᨴ᩠ᨴᩣ ᨧᩮᩅ ᩈᩩᨶᩥᨴ᩠ᨴᩣ ᨧ [ᨶᨶ᩠ᨴᩣ ᨧᩮᩅ ᩈᩩᨶᨶ᩠ᨴᩣ ᨧ (ᩈᩦ.)], ᨴ᩠ᩅᩮ ᨧ ᨽᩥᨠ᩠ᨡᩣᨿ ᨴᩣᨿᩥᨠᩣ;

‘‘ᩏᩊᩣᩁᩮᩣ ¶ ¶ ᨲᩮ ᨿᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᩈᨻ᩠ᨻᩣ ᩒᨽᩣᩈᨲᩮ ᨴᩥᩈᩣ;

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

‘‘ᨾᩮᩣᨴᩮᨶ᩠ᨲᩥ ᨸᩁᩥᩅᩣᩁᩮᨶ᩠ᨲᩥ, ᨲᩅ ᨸᩪᨩᩣᨿ ᨴᩮᩅᨲᩮ;

ᩈᩮᩣᩅᨱ᩠ᨱᩣᨶᩥ ᩅᩥᨾᩣᨶᩣᨶᩥ, ᨲᩅᩥᨾᩣᨶᩥ ᩈᩩᨴᩔᨶᩮ.

‘‘ᨲᩩᩅᩴᩈᩥ ᩍᩔᩁᩣ ᨲᩮᩈᩴ, ᩈᨻ᩠ᨻᨠᩣᨾᩈᨾᩥᨴ᩠ᨵᩥᨶᩦ;

ᩋᨽᩥᨩᩣᨲᩣ ᨾᩉᨶ᩠ᨲᩣᩈᩥ, ᨴᩮᩅᨠᩣᨿᩮ ᨸᨾᩮᩣᨴᩈᩥ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩣ, ᨸᩩᩁᩥᨾᩣᨿ ᨩᩣᨲᩥᨿᩣ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ;

ᨴᩩᩔᩦᩃᨠᩩᩃᩮ ᩈᩩᨱᩥᩈᩣ ᩋᩉᩮᩣᩈᩥᩴ, ᩋᩔᨴ᩠ᨵᩮᩈᩩ ᨠᨴᩁᩥᨿᩮᩈᩩ ᩋᩉᩴ.

‘‘ᩈᨴ᩠ᨵᩣ ᩈᩦᩃᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩈᩴᩅᩥᨽᩣᨣᩁᨲᩣ ᩈᨴᩣ;

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

‘‘ᨲᨴᩣᩉᩴ ¶ ᩈᩔᩩᨿᩣᨧᩥᨠ᩠ᨡᩥᩴ, ᩈᨾᨱᩮᩣ ᩌᨣᨲᩮᩣ ᩍᨵ;

ᨲᩔ ᩋᨴᩣᩈᩉᩴ ᨸᩪᩅᩴ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᩍᨲᩥᩔᩣ ¶ ¶ ᩈᩔᩩ ᨸᩁᩥᨽᩣᩈᩥ, ᩋᩅᩥᨶᩦᨲᩣᩈᩥ ᨲ᩠ᩅᩴ [ᩋᩅᩥᨶᩦᨲᩣ ᨲᩩᩅᩴ (ᩈᩦ.)] ᩅᨵᩩ;

ᨶ ᨾᩴ ᩈᨾ᩠ᨸᩩᨧ᩠ᨨᩥᨲᩩᩴ ᩍᨧ᩠ᨨᩥ, ᩈᨾᨱᩔ ᨴᨴᩣᨾᩉᩴ.

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

ᨠᩪᨭᨦ᩠ᨣᨧ᩠ᨨᩥ ᩋᩅᨵᩥ ᨾᩴ, ᨶᩣᩈᨠ᩠ᨡᩥᩴ ᨩᩦᩅᩥᨲᩩᩴ ᨧᩥᩁᩴ.

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

ᨴᩮᩅᩣᨶᩴ ᨲᩣᩅᨲᩥᩴᩈᩣᨶᩴ, ᩏᨸᨸᨶ᩠ᨶᩣ ᩈᩉᨻ᩠ᨿᨲᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

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

ᩈᩥᩁᩥᨿᩣ ᨧ ᩅᨱ᩠ᨱᩮᨶ ᨿᩈᩮᨶ ᨲᩮᨩᩈᩣ, ᨻᩕᩉ᩠ᨾᩣᩅ ᨴᩮᩅᩮ ᨲᩥᨴᩈᩮ ᩈᩉᩥᨶ᩠ᨴᨠᩮ [ᩈᩍᨶ᩠ᨴᨠᩮ (ᩈᩦ.)].

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᩏᨸ᩠ᨸᩃᨾᩣᩃᨵᩣᩁᩥᨶᩦ, ᩌᩅᩮᩊᩥᨶᩦ ᨠᨬ᩠ᨧᨶᩈᨶ᩠ᨶᩥᨽᨲ᩠ᨲᨧᩮ;

ᩋᩃᨦ᩠ᨠᨲᩮ ᩏᨲ᩠ᨲᨾᩅᨲ᩠ᨳᨵᩣᩁᩥᨶᩦ, ᨠᩣ ᨲ᩠ᩅᩴ ᩈᩩᨽᩮ ᨴᩮᩅᨲᩮ ᩅᨶ᩠ᨴᩈᩮ ᨾᨾᩴ.

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

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

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᩍᨴᩣᨶᩥ ¶ ᨽᨶ᩠ᨲᩮ ᩍᨾᨾᩮᩅ ᨣᩣᨾᩴ [ᨣᩣᨾᩮ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨸᩥᨱ᩠ᨯᩣᨿ ᩋᨾ᩠ᩉᩣᨠᩴ ᨥᩁᩴ ᩏᨸᩣᨣᨾᩥ;

ᨲᨲᩮᩣ ᨲᩮ ᩏᨧ᩠ᨨᩩᩔ ᩋᨴᩣᩈᩥ ᨡᨱ᩠ᨯᩥᨠᩴ, ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ ᩋᨲᩩᩃᩣᨿ ᨸᩦᨲᩥᨿᩣ.

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

ᨶ ᨨᨯ᩠ᨯᩥᨲᩴ ᨶᩮᩣ ᨸᨶ ᨡᩣᨴᩥᨲᩴ ᨾᨿᩣ, ᩈᨶ᩠ᨲᩔ ᨽᩥᨠ᩠ᨡᩩᩔ ᩈᨿᩴ ᩋᨴᩣᩈᩉᩴ.

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

ᨸᩦᨮᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᨸᩉᩣᩁᩴ ᩋᨴᩣᩈᩥ ᨾᩮ, ᨲᨲᩮᩣ ᨧᩩᨲᩣ ᨠᩣᩃᨠᨲᩣᨾ᩠ᩉᩥ ᨴᩮᩅᨲᩣ.

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

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

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

ᨴᩮᩅᩥᨶ᩠ᨴᨣᩩᨲ᩠ᨲᩣ ¶ ᨲᩥᨴᩈᩮᩉᩥ ᩁᨠ᩠ᨡᩥᨲᩣ, ᩈᨾᨸ᩠ᨸᩥᨲᩣ ᨠᩣᨾᨣᩩᨱᩮᩉᩥ ᨸᨬ᩠ᨧᩉᩥ.

‘‘ᩑᨲᩣᨴᩥᩈᩴ ᨸᩩᨬ᩠ᨬᨹᩃᩴ ᩋᨶᨸ᩠ᨸᨠᩴ, ᨾᩉᩣᩅᩥᨸᩣᨠᩣ ᨾᨾ ᩏᨧ᩠ᨨᩩᨴᨠ᩠ᨡᩥᨱᩣ;

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

‘‘ᩑᨲᩣᨴᩥᩈᩴ ¶ ᨸᩩᨬ᩠ᨬᨹᩃᩴ ᩋᨶᨸ᩠ᨸᨠᩴ, ᨾᩉᩣᨩᩩᨲᩥᨠᩣ ᨾᨾ ᩏᨧ᩠ᨨᩩᨴᨠ᩠ᨡᩥᨱᩣ;

ᨴᩮᩅᩥᨶ᩠ᨴᨣᩩᨲ᩠ᨲᩣ ᨲᩥᨴᩈᩮᩉᩥ ᩁᨠ᩠ᨡᩥᨲᩣ, ᩈᩉᩔᨶᩮᨲ᩠ᨲᩮᩣᩁᩥᩅ ᨶᨶ᩠ᨴᨶᩮ ᩅᨶᩮ.

‘‘ᨲᩩᩅᨬ᩠ᨧ ¶ ᨽᨶ᩠ᨲᩮ ᩋᨶᩩᨠᨾ᩠ᨸᨠᩴ ᩅᩥᨴᩩᩴ, ᩏᨸᩮᨧ᩠ᨧ ᩅᨶ᩠ᨴᩥᩴ ᨠᩩᩈᩃᨬ᩠ᨧ ᨸᩩᨧ᩠ᨨᩥᩈᩴ;

ᨲᨲᩮᩣ ᨲᩮ ᩏᨧ᩠ᨨᩩᩔ ᩋᨴᩣᩈᩥ ᨡᨱ᩠ᨯᩥᨠᩴ, ᨸᩈᨶ᩠ᨶᨧᩥᨲᩣ ᩋᨲᩩᩃᩣᨿ ᨸᩦᨲᩥᨿᩣ’’ᨲᩥ.

‘‘ᨸᩃ᩠ᩃᨦ᩠ᨠᩈᩮᨭ᩠ᨮᩮ ¶ ¶ ᨾᨱᩥᩈᩮᩣᨱ᩠ᨱᨧᩥᨲ᩠ᨲᩮ, ᨸᩩᨸ᩠ᨹᩣᨽᩥᨠᩥᨱ᩠ᨱᩮ ᩈᨿᨶᩮ ᩏᩊᩣᩁᩮ;

ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ᨴᩮᩅᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ, ᩏᨧ᩠ᨧᩣᩅᨧᩣ ᩍᨴ᩠ᨵᩥ ᩅᩥᨠᩩᨻ᩠ᨻᨾᩣᨶᩣ.

‘‘ᩍᨾᩣ ᨧ ᨲᩮ ᩋᨧ᩠ᨨᩁᩣᨿᩮᩣ ᩈᨾᨶ᩠ᨲᨲᩮᩣ, ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ¶ ᨣᩣᨿᨶ᩠ᨲᩥ ᨸᨾᩮᩣᨴᨿᨶ᩠ᨲᩥ;

ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ, ᨾᨶᩩᩔᨽᩪᨲᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩣ, ᩋᨯ᩠ᨰᩮ ᨠᩩᩃᩮ ᩈᩩᨱᩥᩈᩣ ᩋᩉᩮᩣᩈᩥᩴ;

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

‘‘ᨾᨶᩩᩔᨽᩪᨲᩣ ᨴᩉᩁᩣ ᩋᨸᩣᨸᩥᨠᩣ [ᨴᩉᩁᩣᩈ’ᨸᩣᨸᩥᨠᩣ (ᩈᩦ.)], ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ ᨸᨲᩥᨾᩣᨽᩥᩁᩣᨵᨿᩥᩴ;

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

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

ᩋᨾᨩ᩠ᨩᨸᩣ ᨶᩮᩣ ᨧ ᨾᩩᩈᩣ ᩋᨽᩣᨱᩥᩴ, ᩈᩥᨠ᩠ᨡᩣᨸᨴᩮᩈᩩ ᨸᩁᩥᨸᩪᩁᨠᩣᩁᩥᨶᩦ.

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

ᨸᩣᨭᩥᩉᩣᩁᩥᨿᨸᨠ᩠ᨡᨬ᩠ᨧ, ᨸᩈᨶ᩠ᨶᨾᩣᨶᩈᩣ ᩋᩉᩴ [ᩋᨲᩥᨸᩈᨶ᩠ᨶᨾᩣᨶᩈᩣ (ᨠ.)].

‘‘ᩋᨭ᩠ᨮᨦ᩠ᨣᩩᨸᩮᨲᩴ ᩋᨶᩩᨵᨾ᩠ᨾᨧᩣᩁᩥᨶᩦ, ᩏᨸᩮᩣᩈᨳᩴ ¶ ᨸᩦᨲᩥᨾᨶᩣ ᩏᨸᩣᩅᩈᩥᩴ;

ᩍᨾᨬ᩠ᨧ ᩋᩁᩥᨿᩴ ᩋᨭ᩠ᨮᨦ᩠ᨣᩅᩁᩮᩉᩩᨸᩮᨲᩴ, ᩈᨾᩣᨴᩥᨿᩥᨲ᩠ᩅᩣ ᨠᩩᩈᩃᩴ ᩈᩩᨡᩩᨴᩕᨿᩴ;

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

‘‘ᩑᨲᩣᨴᩥᩈᩴ ᨠᩩᩈᩃᩴ ᨩᩦᩅᩃᩮᩣᨠᩮ, ᨠᨾ᩠ᨾᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ ᩅᩥᩈᩮᩈᨽᩣᨣᩥᨶᩦ;

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

‘‘ᩅᩥᨾᩣᨶᨸᩣᩈᩣᨴᩅᩁᩮ ᨾᨶᩮᩣᩁᨾᩮ, ᨸᩁᩥᩅᩣᩁᩥᨲᩣ ᩋᨧ᩠ᨨᩁᩣᩈᨦ᩠ᨣᨱᩮᨶ;

ᩈᨿᩴᨸᨽᩣ ᨴᩮᩅᨣᨱᩣ ᩁᨾᩮᨶ᩠ᨲᩥ ᨾᩴ, ᨴᩦᨥᩣᨿᩩᨠᩥᩴ ᨴᩮᩅᩅᩥᨾᩣᨶᨾᩣᨣᨲ’’ᨶ᩠ᨲᩥ;

ᩃᨲᩣ ¶ ᨧ ᩈᨩ᩠ᨩᩣ ᨸᩅᩁᩣ ᨧ ᨴᩮᩅᨲᩣ, ᩋᨧ᩠ᨧᩥᨾᨲᩦ [ᩋᨧ᩠ᨧᩥᨾᩩᨡᩦ (ᩈᩦ.), ᩋᨧ᩠ᨨᩥᨾᨲᩦ (ᨸᩦ. ᨠ.) ᩋᨧ᩠ᨨᩥᨾᩩᨲᩦ (ᩈ᩠ᨿᩣ.)] ᩁᩣᨩᩅᩁᩔ ᩈᩥᩁᩦᨾᨲᩮᩣ;

ᩈᩩᨲᩣ ᨧ ᩁᨬ᩠ᨬᩮᩣ ᩅᩮᩔᩅᨱᩔ ᨵᩦᨲᩣ, ᩁᩣᨩᩦᨾᨲᩦ ᨵᨾ᩠ᨾᨣᩩᨱᩮᩉᩥ ᩈᩮᩣᨽᨳ.

ᨸᨬ᩠ᨧᩮᨲ᩠ᨳ ¶ ¶ ᨶᩣᩁᩥᨿᩮᩣ ᩌᨣᨾᩴᩈᩩ ᨶ᩠ᩉᩣᨿᩥᨲᩩᩴ, ᩈᩦᨲᩮᩣᨴᨠᩴ ᩏᨸ᩠ᨸᩃᩥᨶᩥᩴ ᩈᩥᩅᩴ ᨶᨴᩥᩴ;

ᨲᩣ ¶ ᨲᨲ᩠ᨳ ᨶ᩠ᩉᩣᨿᩥᨲ᩠ᩅᩣ ᩁᨾᩮᨲ᩠ᩅᩣ ᨴᩮᩅᨲᩣ, ᨶᨧ᩠ᨧᩥᨲ᩠ᩅᩣ ᨣᩣᨿᩥᨲ᩠ᩅᩣ ᩈᩩᨲᩣ ᩃᨲᩴ ᨻᩕᩅᩥ [ᨻᩕᩩᩅᩦ (ᩈᩦ.)].

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᩏᨸ᩠ᨸᩃᨾᩣᩃᨵᩣᩁᩥᨶᩥ, ᩌᩅᩮᩊᩥᨶᩥ ᨠᨬ᩠ᨧᨶᩈᨶ᩠ᨶᩥᨽᨲ᩠ᨲᨧᩮ;

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

‘‘ᨠᩮᨶᩣᩈᩥ ᨽᨴ᩠ᨴᩮ ᨸᨲᩥᨶᩮᩣ ᨸᩥᨿᨲᩁᩣ, ᩅᩥᩈᩥᨭ᩠ᨮᨠᩃ᩠ᨿᩣᨱᩥᨲᩁᩔᩩ ᩁᩪᨸᨲᩮᩣ;

ᨸᨴᨠ᩠ᨡᩥᨱᩣ ᨶᨧ᩠ᨧᨣᩦᨲᩅᩣᨴᩥᨲᩮ, ᩌᨧᩥᨠ᩠ᨡ ᨶᩮᩣ ᨲ᩠ᩅᩴ ᨶᩁᨶᩣᩁᩥᨸᩩᨧ᩠ᨨᩥᨲᩣ’’ᨲᩥ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩣ, ᩏᩊᩣᩁᨽᩮᩣᨣᩮ ᨠᩩᩃᩮ ᩈᩩᨱᩥᩈᩣ ᩋᩉᩮᩣᩈᩥᩴ;

ᩋᨠ᩠ᨠᩮᩣᨵᨶᩣ ᨽᨲ᩠ᨲᩩᩅᩈᩣᨶᩩᩅᨲ᩠ᨲᩥᨶᩦ, ᩏᨸᩮᩣᩈᨳᩮ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩣ ᩋᩉᩮᩣᩈᩥᩴ.

‘‘ᨾᨶᩩᩔᨽᩪᨲᩣ ¶ ᨴᩉᩁᩣ ᩋᨸᩣᨸᩥᨠᩣ [ᨴᩉᩁᩣᩈ’ᨸᩣᨸᩥᨠᩣ (ᩈᩦ.)], ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ ᨸᨲᩥᨾᩣᨽᩥᩁᩣᨵᨿᩥᩴ;

ᩈᨴᩮᩅᩁᩴ ᩈᩔᩈᩩᩁᩴ ᩈᨴᩣᩈᨠᩴ, ᩋᨽᩥᩁᩣᨵᨿᩥᩴ ᨲᨾ᩠ᩉᩥ ᨠᨲᩮᩣ ᨿᩈᩮᩣ ᨾᨾ.

‘‘ᩈᩣᩉᩴ ᨲᩮᨶ ᨠᩩᩈᩃᩮᨶ ᨠᨾ᩠ᨾᩩᨶᩣ, ᨧᨲᩩᨻ᩠ᨽᩥ ᨮᩣᨶᩮᩉᩥ ᩅᩥᩈᩮᩈᨾᨩ᩠ᨫᨣᩣ;

ᩌᨿᩩᨬ᩠ᨧ ¶ ᩅᨱ᩠ᨱᨬ᩠ᨧ ᩈᩩᨡᩴ ᨻᩃᨬ᩠ᨧ, ᨡᩥᨯ᩠ᨯᩣᩁᨲᩥᩴ ᨸᨧ᩠ᨧᨶᩩᨽᩮᩣᨾᨶᨸ᩠ᨸᨠᩴ.

‘‘ᩈᩩᨲᩴ ᨶᩩ ᨲᩴ ᨽᩣᩈᨲᩥ ᨿᩴ ᩋᨿᩴ ᩃᨲᩣ, ᨿᩴ ᨶᩮᩣ ᩋᨸᩩᨧ᩠ᨨᩥᨾ᩠ᩉ ᩋᨠᩥᨲ᩠ᨲᨿᩦ ᨶᩮᩣ;

ᨸᨲᩥᨶᩮᩣ ᨠᩥᩁᨾ᩠ᩉᩣᨠᩴ ᩅᩥᩈᩥᨭ᩠ᨮ ᨶᩣᩁᩦᨶᩴ, ᨣᨲᩦ ᨧ ᨲᩣᩈᩴ ᨸᩅᩁᩣ ᨧ ᨴᩮᩅᨲᩣ.

‘‘ᨸᨲᩦᩈᩩ ¶ ᨵᨾ᩠ᨾᩴ ᨸᨧᩁᩣᨾ ᩈᨻ᩠ᨻᩣ, ᨸᨲᩥᨻ᩠ᨻᨲᩣ ᨿᨲ᩠ᨳ ᨽᩅᨶ᩠ᨲᩥ ᩍᨲ᩠ᨳᩥᨿᩮᩣ;

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

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

ᨸᩈᨿ᩠ᩉ ᩉᨶ᩠ᨲ᩠ᩅᩣ ᩍᨲᩁᩮ ᨧᨲᩩᨸ᩠ᨸᨴᩮ, ᨡᩩᨴ᩠ᨴᩮ ᨾᩥᨣᩮ ᨡᩣᨴᨲᩥ ᨾᩴᩈᨽᩮᩣᨩᨶᩮᩣ.

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

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

᪑. ᩅᨲ᩠ᨳᩩᨲ᩠ᨲᨾᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ

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

ᩈᩮᩣ ¶ ᨾᩴ ᩁᨦ᩠ᨣᨾ᩠ᩉᩥ ᩋᩅ᩠ᩉᩮᨲᩥ, ‘ᩈᩁᨱᩴ ᨾᩮ ᩉᩮᩣᩉᩥ ᨠᩮᩣᩈᩥᨿᩣ’ᨲᩥ.

‘‘ᩋᩉᩴ ¶ ᨲᩮ ᩈᩁᨱᩴ ᩉᩮᩣᨾᩥ, ᩋᩉᨾᩣᨧᩁᩥᨿᨸᩪᨩᨠᩮᩣ;

ᨶ ᨲᩴ ᨩᨿᩥᩔᨲᩥ ᩈᩥᩔᩮᩣ, ᩈᩥᩔᨾᩣᨧᩁᩥᨿ ᨩᩮᩔᩈᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᨠᩮᨶ ᨲᩮ ᩍᨵ ᨾᩥᨩ᩠ᨫᨲᩥ;

ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨧ ᨲᩮ ᨽᩮᩣᨣᩣ, ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

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

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᩑᩅᩴ ᨸᩥᨿᩁᩪᨸᨴᩣᨿᩥᨠᩣ ᨾᨶᩣᨸᩴ, ᨴᩥᨻ᩠ᨻᩴ ᩈᩣ ᩃᨽᨲᩮ ᩏᨸᩮᨧ᩠ᨧ ᨮᩣᨶᩴ.

‘‘ᨲᩔᩣ ¶ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ [ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ ᨸᩅᩁᩣ, (ᩈ᩠ᨿᩣ.)] ᨸᩔ ¶ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᨲᩮᨶ ᨾᩮ ᩍᨵ ᨾᩥᨩ᩠ᨫᨲᩥ;

ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨧ ᨾᩮ ᨽᩮᩣᨣᩣ, ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᩋᨠ᩠ᨡᩣᨾᩥ ᨲᩮ ᨽᩥᨠ᩠ᨡᩩ ᨾᩉᩣᨶᩩᨽᩣᩅ, ᨾᨶᩩᩔᨽᩪᨲᩣ ᨿᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨲᩮᨶᨾ᩠ᩉᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

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

᪒. ᨸᩩᨸ᩠ᨹᩩᨲ᩠ᨲᨾᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑)

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨴᩮᩅᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ…ᨸᩮ…

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨸᩩᨸ᩠ᨹᩩᨲ᩠ᨲᨾᨴᩣᨿᩥᨠᩣ ᨶᩣᩁᩦ, ᨸᩅᩁᩣ ᩉᩮᩣᨲᩥ ᨶᩁᩮᩈᩩ ᨶᩣᩁᩦᩈᩩ;

ᩑᩅᩴ ᨸᩥᨿᩁᩪᨸᨴᩣᨿᩥᨠᩣ ᨾᨶᩣᨸᩴ, ᨴᩥᨻ᩠ᨻᩴ ᩈᩣ ᩃᨽᨲᩮ ᩏᨸᩮᨧ᩠ᨧ ᨮᩣᨶᩴ.

‘‘ᨲᩔᩣ ¶ ¶ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

᪓. ᨣᨶ᩠ᨵᩩᨲ᩠ᨲᨾᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪒)

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ¶ ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨴᩮᩅᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ…ᨸᩮ…

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᩑᩅᩴ ᨸᩥᨿᩁᩪᨸᨴᩣᨿᩥᨠᩣ ᨾᨶᩣᨸᩴ, ᨴᩥᨻ᩠ᨻᩴ ᩈᩣ ᩃᨽᨲᩮ ᩏᨸᩮᨧ᩠ᨧ ᨮᩣᨶᩴ.

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

᪔. ᨹᩃᩩᨲ᩠ᨲᨾᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪓)

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨴᩮᩅᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ…ᨸᩮ…

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ¶ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨹᩃᩩᨲ᩠ᨲᨾᨴᩣᨿᩥᨠᩣ ᨶᩣᩁᩦ, ᨸᩅᩁᩣ ᩉᩮᩣᨲᩥ ᨶᩁᩮᩈᩩ ᨶᩣᩁᩦᩈᩩ;

ᩑᩅᩴ ᨸᩥᨿᩁᩪᨸᨴᩣᨿᩥᨠᩣ ᨾᨶᩣᨸᩴ, ᨴᩥᨻ᩠ᨻᩴ ᩈᩣ ᩃᨽᨲᩮ ᩏᨸᩮᨧ᩠ᨧ ᨮᩣᨶᩴ.

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

᪕. ᩁᩈᩩᨲ᩠ᨲᨾᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪔)

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ¶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨴᩮᩅᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ…ᨸᩮ…

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩁᩈᩩᨲ᩠ᨲᨾᨴᩣᨿᩥᨠᩣ ᨶᩣᩁᩦ, ᨸᩅᩁᩣ ¶ ᩉᩮᩣᨲᩥ ᨶᩁᩮᩈᩩ ᨶᩣᩁᩦᩈᩩ;

ᩑᩅᩴ ᨸᩥᨿᩁᩪᨸᨴᩣᨿᩥᨠᩣ ᨾᨶᩣᨸᩴ, ᨴᩥᨻ᩠ᨻᩴ ᩈᩣ ᩃᨽᨲᩮ ᩏᨸᩮᨧ᩠ᨧ ᨮᩣᨶᩴ.

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

᪖. ᨣᨶ᩠ᨵᨸᨬ᩠ᨧᨦ᩠ᨣᩩᩃᩥᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨣᨶ᩠ᨵᨸᨬ᩠ᨧᨦ᩠ᨣᩩᩃᩥᨠᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨠᩔᨸᩔ ᨽᨣᩅᨲᩮᩣ ᨳᩪᨸᨾ᩠ᩉᩥ;

ᩑᩅᩴ ᨸᩥᨿᩁᩪᨸᨴᩣᨿᩥᨠᩣ ᨾᨶᩣᨸᩴ, ᨴᩥᨻ᩠ᨻᩴ ᩈᩣ ᩃᨽᨲᩮ ᩏᨸᩮᨧ᩠ᨧ ᨮᩣᨶᩴ.

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ ¶ , ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

(ᩋᨶᨶ᩠ᨲᩁᩴ ¶ ᨧᨲᩩᩁᩅᩥᨾᩣᨶᩴ ᨿᨳᩣ ᨣᨶ᩠ᨵᨸᨬ᩠ᨧᨦ᩠ᨣᩩᩃᩥᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩴ ᨲᨳᩣ ᩅᩥᨲ᩠ᨳᩣᩁᩮᨲᨻ᩠ᨻᩴ [( ) ᨶᨲ᩠ᨳᩥ ᩈᩦ. ᨸᩮᩣᨲ᩠ᨳᨠᩮ] )

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ…ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨽᩥᨠ᩠ᨡᩪ ᨧ ᩋᩉᩴ ᨽᩥᨠ᩠ᨡᩩᨶᩥᨿᩮᩣ ᨧ, ᩋᨴ᩠ᨴᩈᩣᩈᩥᩴ ᨸᨶ᩠ᨳᨸᨭᩥᨸᨶ᩠ᨶᩮ;

ᨲᩮᩈᩣᩉᩴ ᨵᨾ᩠ᨾᩴ ᩈᩩᨲ᩠ᩅᩣᨶ, ᩑᨠᩪᨸᩮᩣᩈᨳᩴ ᩏᨸᩅᩈᩥᩔᩴ.

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ¶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᩑᩅᩴ ᨸᩥᨿᩁᩪᨸᨴᩣᨿᩥᨠᩣ ᨾᨶᩣᨸᩴ, ᨴᩥᨻ᩠ᨻᩴ ᩈᩣ ᩃᨽᨲᩮ ᩏᨸᩮᨧ᩠ᨧ ᨮᩣᨶᩴ.

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ¶ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩈᩔᩩᨬ᩠ᨧᩣᩉᩴ ᩈᩈᩩᩁᨬ᩠ᨧ, ᨧᨱ᩠ᨯᩥᨠᩮ ᨠᩮᩣᨵᨶᩮ ᨧ ᨹᩁᩩᩈᩮ ᨧ;

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

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

᪑᪐. ᩋᨸᩁᨠᨾ᩠ᨾᨠᩣᩁᩥᨶᩦᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪔)

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᩋᨠ᩠ᨠᩮᩣᨵᨶᩣᨶᨲᩥᨾᩣᨶᩥᨶᩦ [ᩋᨶᨲᩥᨾᩣᨶᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᩈᩴᩅᩥᨽᩣᨣᩥᨶᩦ ᩈᨠᩔ ᨽᩣᨣᩔ.

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ¶ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ¶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨡᩦᩁᩮᩣᨴᨶᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ;

ᩑᩅᩴ ᨠᩁᩥᨲ᩠ᩅᩣ ᨠᨾ᩠ᨾᩴ, ᩈᩩᨣᨲᩥᩴ ᩏᨸᨸᨩ᩠ᨩ ᨾᩮᩣᨴᩣᨾᩥ.

‘‘ᨲᩔᩣ ¶ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

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

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ¶ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨹᩣᨱᩥᨲᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ…’’.

᪑᪓. ᩏᨧ᩠ᨨᩩᨡᨱ᩠ᨯᩥᨠᨴᩣᨿᩥᨠᩣᩅᨲ᩠ᨳᩩ (᪒)

ᩏᨧ᩠ᨨᩩᨡᨱ᩠ᨯᩥᨠᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪑᪔. ᨲᩥᨾ᩠ᨻᩁᩩᩈᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪓)

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

᪑᪕. ᨠᨠ᩠ᨠᩣᩁᩥᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪔)

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

᪑᪖. ᩑᩊᩣᩃᩩᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪕)

ᩑᩊᩣᩃᩩᨠᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪑᪗. ᩅᩃ᩠ᩃᩥᨹᩃᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ(᪖)

ᩅᩃ᩠ᩃᩥᨹᩃᩴ ¶ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪑᪘. ᨹᩣᩁᩩᩈᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪗)

ᨹᩣᩁᩩᩈᨠᩴ ¶ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪑᪙. ᩉᨲ᩠ᨳᨸ᩠ᨸᨲᩣᨸᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪘)

ᩉᨲ᩠ᨳᨸ᩠ᨸᨲᩣᨸᨠᩴ ¶ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪒᪐. ᩈᩣᨠᨾᩩᨭ᩠ᨮᩥᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪙)

ᩈᩣᨠᨾᩩᨭ᩠ᨮᩥᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᨶ᩠ᨳᨸᨭᩥᨸᨶ᩠ᨶᩔ…ᨸᩮ….

᪒᪑. ᨸᩩᨸ᩠ᨹᨠᨾᩩᨭ᩠ᨮᩥᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪐)

ᨸᩩᨸ᩠ᨹᨠᨾᩩᨭ᩠ᨮᩥᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

ᨾᩪᩃᨠᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪒᪓. ᨶᩥᨾ᩠ᨻᨾᩩᨭ᩠ᨮᩥᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪒)

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

᪒᪔. ᩋᨾ᩠ᨻᨠᨬ᩠ᨩᩥᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪓)

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

᪒᪕. ᨴᩮᩣᨱᩥᨶᩥᨾ᩠ᨾᨩ᩠ᨩᨶᩥᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪔)

ᨴᩮᩣᨱᩥᨶᩥᨾ᩠ᨾᨩ᩠ᨩᨶᩥᩴ [ᨴᩮᩣᨱᩥᨶᩥᨾ᩠ᨾᩩᨩ᩠ᨩᨶᩴ (ᩈ᩠ᨿᩣ.)] ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪒᪖. ᨠᩣᨿᨻᨶ᩠ᨵᨶᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪕)

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

᪒᪗. ᩋᩴᩈᨻᨴ᩠ᨵᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪖)

ᩋᩴᩈᨻᨴ᩠ᨵᨠᩴ ¶ [ᩋᩴᩈᩅᨭ᩠ᨭᨠᩴ (ᩈᩦ.), ᩋᩴᩈᨻᨶ᩠ᨵᨶᩴ (ᨠ.)] ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪒᪘. ᩌᨿᩮᩣᨣᨸᨭ᩠ᨭᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪗)

ᩌᨿᩮᩣᨣᨸᨭ᩠ᨭᩴ ¶ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪒᪙. ᩅᩥᨵᩪᨸᨶᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪘)

ᩅᩥᨵᩪᨸᨶᩴ ¶ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪓᪐. ᨲᩣᩃᩅᨱ᩠ᨭᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪑᪙)

ᨲᩣᩃᩅᨱ᩠ᨭᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪓᪑. ᨾᩮᩣᩁᩉᨲ᩠ᨳᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪒᪐)

ᨾᩮᩣᩁᩉᨲ᩠ᨳᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

ᨨᨲ᩠ᨲᩴ [ᨨᨲ᩠ᨲᨬ᩠ᨧ (ᨠ.)] ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪓᪓. ᩏᨸᩣᩉᨶᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪒᪒)

ᩏᨸᩣᩉᨶᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

ᨸᩪᩅᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

᪓᪕. ᨾᩮᩣᨴᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪒᪔)

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

᪓᪖. ᩈᨠ᩠ᨡᩃᩥᨠᨴᩣᨿᩥᨠᩣᩅᩥᨾᩣᨶᩅᨲ᩠ᨳᩩ (᪒᪕)

‘‘ᩈᨠ᩠ᨡᩃᩥᨠᩴ [ᩈᨠ᩠ᨡᩃᩥᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ…ᨸᩮ….

‘‘ᨲᩔᩣ ᨾᩮ ᨸᩔ ᩅᩥᨾᩣᨶᩴ, ᩋᨧ᩠ᨨᩁᩣ ᨠᩣᨾᩅᨱ᩠ᨱᩥᨶᩦᩉᨾᩈ᩠ᨾᩥ;

ᩋᨧ᩠ᨨᩁᩣᩈᩉᩔᩔᩣᩉᩴ, ᨸᩅᩁᩣ ᨸᩔ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᩅᩥᨸᩣᨠᩴ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

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

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

‘‘ᩍᨾᩣᩈᩣᩉᩴ ¶ [ᨲᩣᩈᩣᩉᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨵᨾ᩠ᨾᩴ ᩈᩩᨲ᩠ᩅᩣ [ᩈᩩᨲ᩠ᩅᩣᨶ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨠᩣᩉᩣᨾᩥ ᨠᩩᩈᩃᩴ ᨻᩉᩩᩴ.

ᨴᩣᨶᩮᨶ ᩈᨾᨧᩁᩥᨿᩣᨿ, ᩈᨬ᩠ᨬᨾᩮᨶ ᨴᨾᩮᨶ ᨧ;

ᩈ᩠ᩅᩣᩉᩴ ᨲᨲ᩠ᨳ ᨣᨾᩥᩔᩣᨾᩥ [ᨲᨲ᩠ᨳᩮᩅ ᨣᨧ᩠ᨨᩣᨾᩥ (ᨠ.)], ᨿᨲ᩠ᨳ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᨶ ᩈᩮᩣᨧᩁᩮ’’ᨲᩥ.

‘‘ᨴᨴ᩠ᨴᩃ᩠ᩃᨾᩣᨶᩣ ¶ ¶ [ᨴᨴ᩠ᨴᩊ᩠ᩉᨾᩣᨶᩣ (ᨠ.)] ᩅᨱ᩠ᨱᩮᨶ, ᨿᩈᩈᩣ ᨧ ᨿᩈᩔᩥᨶᩦ;

ᩈᨻ᩠ᨻᩮ ᨴᩮᩅᩮ ᨲᩣᩅᨲᩥᩴᩈᩮ, ᩅᨱ᩠ᨱᩮᨶ ᩋᨲᩥᩁᩮᩣᨧᩈᩥ.

‘‘ᨴᩔᨶᩴ ᨶᩣᨽᩥᨩᩣᨶᩣᨾᩥ, ᩍᨴᩴ ᨸᨮᨾᨴᩔᨶᩴ;

ᨠᩈ᩠ᨾᩣ ᨠᩣᨿᩣ ᨶᩩ ᩌᨣᨾ᩠ᨾ, ᨶᩣᨾᩮᨶ ᨽᩣᩈᩈᩮ ᨾᨾ’’ᨶ᩠ᨲᩥ.

‘‘ᩋᩉᩴ ᨽᨴ᩠ᨴᩮ ᩈᩩᨽᨴ᩠ᨴᩣᩈᩥᩴ, ᨸᩩᨻ᩠ᨻᩮ ᨾᩣᨶᩩᩈᨠᩮ ᨽᩅᩮ;

ᩈᩉᨽᩁᩥᨿᩣ ᨧ ᨲᩮ ᩌᩈᩥᩴ, ᨽᨣᩥᨶᩦ ᨧ ᨠᨶᩥᨭ᩠ᨮᩥᨠᩣ.

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

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

‘‘ᨸᩉᩪᨲᨠᨲᨠᩃ᩠ᨿᩣᨱᩣ, ᨲᩮ ᨴᩮᩅᩮ ᨿᨶ᩠ᨲᩥ ᨸᩣᨱᩥᨶᩮᩣ;

ᨿᩮᩈᩴ ᨲ᩠ᩅᩴ ᨠᩥᨲ᩠ᨲᨿᩥᩔᩈᩥ, ᩈᩩᨽᨴ᩠ᨴᩮ ᨩᩣᨲᩥᨾᨲ᩠ᨲᨶᩮᩣ.

‘‘ᩋᨳ [ᨠᨳᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨲ᩠ᩅᩴ ᨠᩮᨶ ᩅᨱ᩠ᨱᩮᨶ, ᨠᩮᨶ ᩅᩣ ᩋᨶᩩᩈᩣᩈᩥᨲᩣ;

ᨠᩦᨴᩥᩈᩮᨶᩮᩅ ᨴᩣᨶᩮᨶ, ᩈᩩᨻ᩠ᨻᨲᩮᨶ ᨿᩈᩔᩥᨶᩦ.

‘‘ᨿᩈᩴ ᩑᨲᩣᨴᩥᩈᩴ ᨸᨲ᩠ᨲᩣ, ᩅᩥᩈᩮᩈᩴ ᩅᩥᨸᩩᩃᨾᨩ᩠ᨫᨣᩣ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᩋᨭ᩠ᨮᩮᩅ ᨸᩥᨱ᩠ᨯᨸᩣᨲᩣᨶᩥ, ᨿᩴ ᨴᩣᨶᩴ ᩋᨴᨴᩴ ᨸᩩᩁᩮ;

ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩔ ᩈᨦ᩠ᨥᩔ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

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

ᨲᨸ᩠ᨸᩮᩈᩥᩴ ᩋᨶ᩠ᨶᨸᩣᨶᩮᨶ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᨲᨿᩣ ¶ ¶ ᨻᩉᩩᨲᩁᩴ ᨴᨲ᩠ᩅᩣ, ᩉᩦᨶᨠᩣᨿᩪᨸᨣᩣ ᩋᩉᩴ [ᩋᩉᩩᩴ (ᨠ. ᩈᩦ.)];

ᨠᨳᩴ ᨲ᩠ᩅᩴ ᩋᨸ᩠ᨸᨲᩁᩴ ᨴᨲ᩠ᩅᩣ, ᩅᩥᩈᩮᩈᩴ ᩅᩥᨸᩩᩃᨾᨩ᩠ᨫᨣᩣ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᨾᨶᩮᩣᨽᩣᩅᨶᩦᨿᩮᩣ ¶ ᨽᩥᨠ᩠ᨡᩩ, ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩮᩣ ᨾᩮ ᨸᩩᩁᩮ ᩋᩉᩩ;

ᨲᩣᩉᩴ ᨽᨲ᩠ᨲᩮᨶ [ᨽᨴ᩠ᨴᩮ (ᨠ.)] ᨶᩥᨾᨶ᩠ᨲᩮᩈᩥᩴ, ᩁᩮᩅᨲᩴ ᩋᨲ᩠ᨲᨶᨭ᩠ᨮᨾᩴ.

‘‘ᩈᩮᩣ ᨾᩮ ᩋᨲ᩠ᨳᨸᩩᩁᩮᨠ᩠ᨡᩣᩁᩮᩣ, ᩋᨶᩩᨠᨾ᩠ᨸᩣᨿ ᩁᩮᩅᨲᩮᩣ;

ᩈᨦ᩠ᨥᩮ ᨴᩮᩉᩦᨲᩥ ᨾᩴᩅᩮᩣᨧ, ᨲᩔᩣᩉᩴ ᩅᨧᨶᩴ ᨠᩁᩥᩴ.

‘‘ᩈᩣ ᨴᨠ᩠ᨡᩥᨱᩣ ᩈᨦ᩠ᨥᨣᨲᩣ, ᩋᨸ᩠ᨸᨾᩮᨿ᩠ᨿᩮ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩣ;

ᨸᩩᨣ᩠ᨣᩃᩮᩈᩩ ᨲᨿᩣ ᨴᩥᨶ᩠ᨶᩴ, ᨶ ᨲᩴ ᨲᩅ ᨾᩉᨸ᩠ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᩍᨴᩣᨶᩮᩅᩣᩉᩴ ᨩᩣᨶᩣᨾᩥ, ᩈᨦ᩠ᨥᩮ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ;

ᩈᩣᩉᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᨾᨶᩩᩔᨲ᩠ᨲᩴ, ᩅᨴᨬ᩠ᨬᩪ ᩅᩦᨲᨾᨧ᩠ᨨᩁᩣ;

ᩈᨦ᩠ᨥᩮ ᨴᩣᨶᩣᨶᩥ ᨴᩔᩣᨾᩥ [ᩈᨦ᩠ᨥᩮ ᨴᩣᨶᩴ ᨴᩔᩣᨾᩥᩉᩴ (ᩈ᩠ᨿᩣ.)], ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩣ ᨸᩩᨶᨸ᩠ᨸᩩᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᨠᩣ ᩑᩈᩣ ᨴᩮᩅᨲᩣ ᨽᨴ᩠ᨴᩮ, ᨲᨿᩣ ᨾᨶ᩠ᨲᨿᨲᩮ ᩈᩉ;

ᩈᨻ᩠ᨻᩮ ᨴᩮᩅᩮ ᨲᩣᩅᨲᩥᩴᩈᩮ, ᩅᨱ᩠ᨱᩮᨶ ᩋᨲᩥᩁᩮᩣᨧᨲᩦ’’ᨲᩥ.

‘‘ᨾᨶᩩᩔᨽᩪᨲᩣ ᨴᩮᩅᩥᨶ᩠ᨴ, ᨸᩩᨻ᩠ᨻᩮ ᨾᩣᨶᩩᩈᨠᩮ ᨽᩅᩮ;

ᩈᩉᨽᩁᩥᨿᩣ ᨧ ᨾᩮ ᩌᩈᩥ, ᨽᨣᩥᨶᩦ ᨧ ᨠᨶᩥᨭ᩠ᨮᩥᨠᩣ;

ᩈᨦ᩠ᨥᩮ ᨴᩣᨶᩣᨶᩥ ᨴᨲ᩠ᩅᩣᨶ, ᨠᨲᨸᩩᨬ᩠ᨬᩣ ᩅᩥᩁᩮᩣᨧᨲᩦ’’ᨲᩥ.

‘‘ᨵᨾ᩠ᨾᩮᨶ ᨸᩩᨻ᩠ᨻᩮ ᨽᨣᩥᨶᩦ, ᨲᨿᩣ ᨽᨴ᩠ᨴᩮ ᩅᩥᩁᩮᩣᨧᨲᩥ;

ᨿᩴ ᩈᨦ᩠ᨥᨾ᩠ᩉᩥ ᩋᨸ᩠ᨸᨾᩮᨿ᩠ᨿᩮ, ᨸᨲᩥᨭ᩠ᨮᩣᨸᩮᩈᩥ ᨴᨠ᩠ᨡᩥᨱᩴ.

‘‘ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᩉᩥ ᨾᨿᩣ ᨻᩩᨴ᩠ᨵᩮᩣ, ᨣᩥᨩ᩠ᨫᨠᩪᨭᨾ᩠ᩉᩥ ᨸᨻ᩠ᨻᨲᩮ;

ᩅᩥᨸᩣᨠᩴ ¶ ᩈᩴᩅᩥᨽᩣᨣᩔ, ᨿᨲ᩠ᨳ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ.

‘‘ᨿᨩᨾᩣᨶᩣᨶᩴ ᨾᨶᩩᩔᩣᨶᩴ, ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩣᨶ ᨸᩣᨱᩥᨶᩴ;

ᨠᩁᩮᩣᨲᩴ ᩒᨸᨵᩥᨠᩴ ᨸᩩᨬ᩠ᨬᩴ, ᨿᨲ᩠ᨳ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ.

‘‘ᨲᩴ ¶ ᨾᩮ ᨻᩩᨴ᩠ᨵᩮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨩᩣᨶᩴ ᨠᨾ᩠ᨾᨹᩃᩴ ᩈᨠᩴ;

ᩅᩥᨸᩣᨠᩴ ᩈᩴᩅᩥᨽᩣᨣᩔ, ᨿᨲ᩠ᨳ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ.

[ᩅᩥ. ᩅ. ᪗᪕᪐; ᨠᨳᩣ. ᪗᪙᪘] ‘‘ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᨧ ᨸᨭᩥᨸᨶ᩠ᨶᩣ, ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᨧ ᨹᩃᩮ ᨮᩥᨲᩣ;

ᩑᩈ ᩈᨦ᩠ᨥᩮᩣ ᩏᨩᩩᨽᩪᨲᩮᩣ, ᨸᨬ᩠ᨬᩣᩈᩦᩃᩈᨾᩣᩉᩥᨲᩮᩣ.

[ᩅᩥ. ᩅ. ᪗᪕᪑; ᨠᨳᩣ. ᪗᪙᪘] ‘‘ᨿᨩᨾᩣᨶᩣᨶᩴ ᨾᨶᩩᩔᩣᨶᩴ, ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩣᨶ ᨸᩣᨱᩥᨶᩴ;

ᨠᩁᩮᩣᨲᩴ ᩒᨸᨵᩥᨠᩴ ᨸᩩᨬ᩠ᨬᩴ, ᩈᨦ᩠ᨥᩮ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ.

[ᩅᩥ. ᩅ. ᪗᪕᪒; ᨠᨳᩣ. ᪗᪙᪘] ‘‘ᩑᩈᩮᩣ ¶ ᩉᩥ ᩈᨦ᩠ᨥᩮᩣ ᩅᩥᨸᩩᩃᩮᩣ ᨾᩉᨣ᩠ᨣᨲᩮᩣ, ᩑᩈᨸ᩠ᨸᨾᩮᨿ᩠ᨿᩮᩣ ᩏᨴᨵᩦᩅ ᩈᩣᨣᩁᩮᩣ;

ᩑᨲᩮ ᩉᩥ ᩈᩮᨭ᩠ᨮᩣ ᨶᩁᩅᩦᩁᩈᩣᩅᨠᩣ, ᨸᨽᨦ᩠ᨠᩁᩣ ᨵᨾ᩠ᨾᨾᩩᨴᩦᩁᨿᨶ᩠ᨲᩥ [ᨵᨾ᩠ᨾᨠᨳᩴ ᩏᨴᩦᩁᨿᨶ᩠ᨲᩥ (ᩈ᩠ᨿᩣ.)].

[ᩅᩥ. ᩅ. ᪗᪕᪓; ᨠᨳᩣ. ᪗᪙᪘] ‘‘ᨲᩮᩈᩴ ¶ ᩈᩩᨴᩥᨶ᩠ᨶᩴ ᩈᩩᩉᩩᨲᩴ ᩈᩩᨿᩥᨭ᩠ᨮᩴ, ᨿᩮ ᩈᨦ᩠ᨥᨾᩩᨴ᩠ᨴᩥᩔ ᨴᨴᨶ᩠ᨲᩥ ᨴᩣᨶᩴ;

ᩈᩣ ᨴᨠ᩠ᨡᩥᨱᩣ ᩈᨦ᩠ᨥᨣᨲᩣ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩣ, ᨾᩉᨸ᩠ᨹᩃᩣ ᩃᩮᩣᨠᩅᩥᨴᩪᨶ [ᩃᩮᩣᨠᩅᩥᨴᩪᩉᩥ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩅᨱ᩠ᨱᩥᨲᩣ.

[ᩅᩥ. ᩅ. ᪗᪕᪔; ᨠᨳᩣ. ᪗᪙᪘] ‘‘ᩑᨲᩣᨴᩥᩈᩴ ᨿᨬ᩠ᨬᨾᨶᩩᩔᩁᨶ᩠ᨲᩣ [ᨸᩩᨬ᩠ᨬᨾᨶᩩᩔᩁᨶ᩠ᨲᩣ (ᩈ᩠ᨿᩣ. ᨠ.)], ᨿᩮ ᩅᩮᨴᨩᩣᨲᩣ ᩅᩥᨧᩁᨶ᩠ᨲᩥ ᩃᩮᩣᨠᩮ;

ᩅᩥᨶᩮᨿ᩠ᨿ ᨾᨧ᩠ᨨᩮᩁᨾᩃᩴ ᩈᨾᩪᩃᩴ, ᩋᨶᩥᨶ᩠ᨴᩥᨲᩣ ¶ ᩈᨣ᩠ᨣᨾᩩᨸᩮᨶ᩠ᨲᩥ ᨮᩣᨶ’’ᨶ᩠ᨲᩥ.

ᨴᨴ᩠ᨴᩃ᩠ᩃᩅᩥᨾᩣᨶᩴ [ᨴᨴ᩠ᨴᩊ᩠ᩉᩅᩥᨾᩣᨶᩴ (ᨠ.)] ᨨᨭ᩠ᨮᩴ.

‘‘ᨹᩃᩥᨠᩁᨩᨲᩉᩮᨾᨩᩣᩃᨨᨶ᩠ᨶᩴ ¶ , ᩅᩥᩅᩥᨵᨧᩥᨲᩕᨲᩃᨾᨴ᩠ᨴᩈᩴ ᩈᩩᩁᨾ᩠ᨾᩴ;

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

‘‘ᨽᩣᨲᩥ ¶ ᨧ ᨴᩈ ᨴᩥᩈᩣ ᨶᨽᩮᩅ ᩈᩩᩁᩥᨿᩮᩣ, ᩈᩁᨴᩮ ᨲᨾᩮᩣᨶᩩᨴᩮᩣ ᩈᩉᩔᩁᩴᩈᩦ;

ᨲᨳᩣ ᨲᨸᨲᩥᨾᩥᨴᩴ ᨲᩅ ᩅᩥᨾᩣᨶᩴ, ᨩᩃᨾᩥᩅ ᨵᩪᨾᩈᩥᨡᩮᩣ ᨶᩥᩈᩮ ᨶᨽᨣ᩠ᨣᩮ.

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

ᩅᩦᨱᩣᨾᩩᩁᨩᩈᨾ᩠ᨾᨲᩣᩊᨥᩩᨭ᩠ᨮᩴ, ᩍᨴ᩠ᨵᩴ ᩍᨶ᩠ᨴᨸᩩᩁᩴ ᨿᨳᩣ ᨲᩅᩮᨴᩴ.

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

ᩈᩣᩃᨠᩩᩈᩩᨾᩥᨲᨸᩩᨸ᩠ᨹᩥᨲᩣ ᩋᩈᩮᩣᨠᩣ, ᩅᩥᩅᩥᨵᨴᩩᨾᨣ᩠ᨣᩈᩩᨣᨶ᩠ᨵᩈᩮᩅᩥᨲᨾᩥᨴᩴ.

‘‘ᩈᩊᩃᩃᨻᩩᨩᨽᩩᨩᨠ [ᩈᩩᨩᨠ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩈᩴᨿᩩᨲ᩠ᨲᩣ [ᩈᨬ᩠ᨬᨲᩣ (ᩈᩦ.)], ᨠᩩᩈᨠᩈᩩᨹᩩᩃ᩠ᩃᩥᨲᩃᨲᩣᩅᩃᨾ᩠ᨻᩥᨶᩦᩉᩥ ¶ ;

ᨾᨱᩥᨩᩣᩃᩈᨴᩥᩈᩣ ᨿᩈᩔᩥᨶᩦ, ᩁᨾ᩠ᨾᩣ ᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ ᩏᨸᨭ᩠ᨮᩥᨲᩣ ᨲᩮ.

‘‘ᩏᨴᨠᩁᩩᩉᩣ ᨧ ᨿᩮᨲ᩠ᨳᩥ ᨸᩩᨸ᩠ᨹᨩᩣᨲᩣ, ᨳᩃᨩᩣ ᨿᩮ ᨧ ᩈᨶ᩠ᨲᩥ ᩁᩩᨠ᩠ᨡᨩᩣᨲᩣ;

ᨾᩣᨶᩩᩈᨠᩣᨾᩣᨶᩩᩔᨠᩣ ᨧ ᨴᩥᨻ᩠ᨻᩣ, ᩈᨻ᩠ᨻᩮ ᨲᩩᨿ᩠ᩉᩴ ᨶᩥᩅᩮᩈᨶᨾ᩠ᩉᩥ ᨩᩣᨲᩣ.

‘‘ᨠᩥᩔ ᩈᩴᨿᨾᨴᨾᩔᨿᩴ ᩅᩥᨸᩣᨠᩮᩣ, ᨠᩮᨶᩣᩈᩥ ᨠᨾ᩠ᨾᨹᩃᩮᨶᩥᨵᩪᨸᨸᨶ᩠ᨶᩣ;

ᨿᨳᩣ ᨧ ᨲᩮ ᩋᨵᩥᨣᨲᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᨲᨴᨶᩩᨸᨴᩴ ᩋᩅᨧᩣᩈᩥᩊᩣᩁᨸᨾ᩠ᩉᩮ’’ᨲᩥ [ᨸᨡᩩᨾᩮᨲᩥ (ᩈᩦ.)].

‘‘ᨿᨳᩣ ¶ ᨧ ᨾᩮ ᩋᨵᩥᨣᨲᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᨠᩮᩣᨬ᩠ᨧᨾᨿᩪᩁᨧᨠᩮᩣᩁ [ᨧᨦ᩠ᨠᩮᩣᩁ (ᨠ.)] ᩈᨦ᩠ᨥᨧᩁᩥᨲᩴ;

ᨴᩥᨻ᩠ᨿ [ᨴᩥᨻ᩠ᨻ (ᩈᩦ. ᨸᩦ.)] ᨸᩥᩃᩅᩉᩴᩈᩁᩣᨩᨧᩥᨱ᩠ᨱᩴ, ᨴᩥᨩᨠᩣᩁᨱ᩠ᨯᩅᨠᩮᩣᨠᩥᩃᩣᨽᩥᨶᨴᩥᨲᩴ.

‘‘ᨶᩣᨶᩣᩈᨶ᩠ᨲᩣᨶᨠᨸᩩᨸ᩠ᨹᩁᩩᨠ᩠ᨡᩅᩥᩅᩥᨵᩣ, ᨸᩣᨭᩃᩥᨩᨾ᩠ᨻᩩᩋᩈᩮᩣᨠᩁᩩᨠ᩠ᨡᩅᨶ᩠ᨲᩴ;

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

‘‘ᨾᨣᨵᩅᩁᨸᩩᩁᨲ᩠ᨳᩥᨾᩮᨶ ¶ , ᨶᩣᩊᨠᨣᩣᨾᩮᩣ ᨶᩣᨾ ᩋᨲ᩠ᨳᩥ ᨽᨶ᩠ᨲᩮ;

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

‘‘ᩈᩣᩉᨾᨸᨧᩥᨲᨲ᩠ᨳᨵᨾ᩠ᨾᨠᩩᩈᩃᩴ ¶ , ᨴᩮᩅᨾᨶᩩᩔᨸᩪᨩᩥᨲᩴ ᨾᩉᨶ᩠ᨲᩴ;

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

‘‘ᨸᩁᨾᨣᨲᩥᨣᨲᨬ᩠ᨧ ᨸᩪᨩᨿᩥᨲ᩠ᩅᩣ, ᩋᨶ᩠ᨲᩥᨾᨴᩮᩉᨵᩁᩴ ᩍᩈᩥᩴ ᩏᩊᩣᩁᩴ;

ᨸᩉᩣᨿ ᨾᩣᨶᩩᩈᨠᩴ ᩈᨾᩩᩔᨿᩴ, ᨲᩥᨴᩈᨣᨲᩣ ᩍᨵ ᨾᩣᩅᩈᩣᨾᩥ ᨮᩣᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩦᨲᩅᨲ᩠ᨳᩮ ¶ ᨸᩦᨲᨵᨩᩮ, ᨸᩦᨲᩣᩃᨦ᩠ᨠᩣᩁᨽᩪᩈᩥᨲᩮ;

ᨸᩦᨲᨶ᩠ᨲᩁᩣᩉᩥ ᩅᨣ᩠ᨣᩪᩉᩥ, ᩋᨸᩥᩊᨶ᩠ᨵᩣᩅ ᩈᩮᩣᨽᩈᩥ.

‘‘ᨠᩣ ¶ ᨠᨾ᩠ᨻᩩᨠᩣᨿᩪᩁᨵᩁᩮ [ᨠᨠᨾ᩠ᨻᩩᨠᩣᨿᩩᩁᨵᩁᩮ (ᩈ᩠ᨿᩣ.)], ᨠᨬ᩠ᨧᨶᩣᩅᩮᩊᨽᩪᩈᩥᨲᩮ;

ᩉᩮᨾᨩᩣᩃᨠᩈᨬ᩠ᨨᨶ᩠ᨶᩮ [ᨸᨧ᩠ᨨᨶ᩠ᨶᩮ (ᩈᩦ.)], ᨶᩣᨶᩣᩁᨲᨶᨾᩣᩃᩥᨶᩦ.

‘‘ᩈᩮᩣᩅᨱ᩠ᨱᨾᨿᩣ ᩃᩮᩣᩉᩥᨲᨦ᩠ᨣᨾᨿᩣ [ᩃᩮᩣᩉᩥᨲᨦ᩠ᨠᨾᨿᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨧ, ᨾᩩᨲ᩠ᨲᩣᨾᨿᩣ ¶ ᩅᩮᩊᩩᩁᩥᨿᨾᨿᩣ ᨧ;

ᨾᩈᩣᩁᨣᩃ᩠ᩃᩣ ᩈᩉᩃᩮᩣᩉᩥᨲᨦ᩠ᨣᩣ [ᩈᩉᩃᩮᩣᩉᩥᨲᨦ᩠ᨠᩣ (ᩈᩦ.), ᩈᩉᩃᩮᩣᩉᩥᨲᨠᩣ (ᩈ᩠ᨿᩣ.)], ᨸᩣᩁᩮᩅᨲᨠ᩠ᨡᩦᩉᩥ ᨾᨱᩦᩉᩥ ᨧᩥᨲ᩠ᨲᨲᩣ.

‘‘ᨠᩮᩣᨧᩥ ᨠᩮᩣᨧᩥ ᩑᨲ᩠ᨳ ᨾᨿᩪᩁᩈᩩᩔᩁᩮᩣ, ᩉᩴᩈᩔ ᩁᨬ᩠ᨬᩮᩣ ᨠᩁᩅᩦᨠᩈᩩᩔᩁᩮᩣ;

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

‘‘ᩁᨳᩮᩣ ᨧ ᨲᩮ ᩈᩩᨽᩮᩣ ᩅᨣ᩠ᨣᩩ [ᩅᨣ᩠ᨣᩪ (ᩈ᩠ᨿᩣ.)], ᨶᩣᨶᩣᩁᨲᨶᨧᩥᨲ᩠ᨲᩥᨲᩮᩣ [ᨶᩣᨶᩣᩁᨲᨶᨧᩥᨲ᩠ᨲᨦ᩠ᨣᩮᩣ (ᩈ᩠ᨿᩣ.)];

ᨶᩣᨶᩣᩅᨱ᩠ᨱᩣᩉᩥ ᨵᩣᨲᩪᩉᩥ, ᩈᩩᩅᩥᨽᨲ᩠ᨲᩮᩣᩅ ᩈᩮᩣᨽᨲᩥ.

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

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

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

ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮ ᨣᩮᩣᨲᨾᩮ ᩋᨸ᩠ᨸᨾᩮᨿ᩠ᨿᩮ, ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ ᩋᩉᨾᩣᨽᩥᩁᩮᩣᨸᨿᩥᩴ.

‘‘ᨲᩣᩉᩴ ᨠᨾ᩠ᨾᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ, ᨠᩩᩈᩃᩴ ᨻᩩᨴ᩠ᨵᩅᨱ᩠ᨱᩥᨲᩴ;

ᩋᨸᩮᨲᩈᩮᩣᨠᩣ ᩈᩩᨡᩥᨲᩣ, ᩈᨾ᩠ᨸᨾᩮᩣᨴᩣᨾᨶᩣᨾᨿᩣ’’ᨲᩥ.

‘‘ᨠᩣ ¶ ¶ ¶ ᨶᩣᨾ ᨲ᩠ᩅᩴ ᩅᩥᩈᩣᩃᨠ᩠ᨡᩥ [ᩅᩥᩈᩣᩃᨠ᩠ᨡᩦ (ᩈ᩠ᨿᩣ.)], ᩁᨾ᩠ᨾᩮ ᨧᩥᨲ᩠ᨲᩃᨲᩣᩅᨶᩮ;

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

‘‘ᨿᨴᩣ ¶ ᨴᩮᩅᩣ ᨲᩣᩅᨲᩥᩴᩈᩣ, ᨸᩅᩥᩈᨶ᩠ᨲᩥ ᩍᨾᩴ ᩅᨶᩴ;

ᩈᨿᩮᩣᨣ᩠ᨣᩣ ᩈᩁᨳᩣ ᩈᨻ᩠ᨻᩮ, ᨧᩥᨲᩕᩣ ᩉᩮᩣᨶ᩠ᨲᩥ ᩍᨵᩣᨣᨲᩣ.

‘‘ᨲᩩᨿ᩠ᩉᨬ᩠ᨧ ᩍᨵ ᨸᨲ᩠ᨲᩣᨿ, ᩏᨿ᩠ᨿᩣᨶᩮ ᩅᩥᨧᩁᨶ᩠ᨲᩥᨿᩣ;

ᨠᩣᨿᩮ ᨶ ᨴᩥᩔᨲᩦ ᨧᩥᨲ᩠ᨲᩴ, ᨠᩮᨶ ᩁᩪᨸᩴ ᨲᩅᩮᨴᩥᩈᩴ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᨿᩮᨶ ᨠᨾ᩠ᨾᩮᨶ ᨴᩮᩅᩥᨶ᩠ᨴ, ᩁᩪᨸᩴ ᨾᨿ᩠ᩉᩴ ᨣᨲᩦ ᨧ ᨾᩮ;

ᩍᨴ᩠ᨵᩥ ᨧ ᩌᨶᩩᨽᩣᩅᩮᩣ ᨧ, ᨲᩴ ᩈᩩᨱᩮᩣᩉᩥ ᨸᩩᩁᩥᨶ᩠ᨴᨴ.

‘‘ᩋᩉᩴ ᩁᩣᨩᨣᩉᩮ ᩁᨾ᩠ᨾᩮ, ᩈᩩᨶᨶ᩠ᨴᩣ ᨶᩣᨾᩩᨸᩣᩈᩥᨠᩣ;

ᩈᨴ᩠ᨵᩣ ᩈᩦᩃᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩈᩴᩅᩥᨽᩣᨣᩁᨲᩣ ᩈᨴᩣ.

‘‘ᩋᨧ᩠ᨨᩣᨴᨶᨬ᩠ᨧ ᨽᨲ᩠ᨲᨬ᩠ᨧ, ᩈᩮᨶᩣᩈᨶᩴ ᨸᨴᩦᨸᩥᨿᩴ;

ᩋᨴᩣᩈᩥᩴ ᩏᨩᩩᨽᩪᨲᩮᩈᩩ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ.

‘‘ᨧᩣᨲᩩᨴ᩠ᨴᩈᩥᩴ [ᨧᨲᩩᨴ᩠ᨴᩈᩥᩴ (ᨸᩦ. ᨠ.)] ᨸᨬ᩠ᨧᨴᩈᩥᩴ, ᨿᩣ ᨧ ᨸᨠ᩠ᨡᩔ ᩋᨭ᩠ᨮᨾᩦ;

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

‘‘ᩏᨸᩮᩣᩈᨳᩴ ᩏᨸᩅᩈᩥᩔᩴ, ᩈᨴᩣ ᩈᩦᩃᩮᩈᩩ ᩈᩴᩅᩩᨲᩣ;

ᩈᨬ᩠ᨬᨾᩣ ᩈᩴᩅᩥᨽᩣᨣᩣ ᨧ, ᩅᩥᨾᩣᨶᩴ ᩌᩅᩈᩣᨾᩉᩴ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ᩅᩥᩁᨲᩣ, ᨾᩩᩈᩣᩅᩣᨴᩣ ᨧ ᩈᨬ᩠ᨬᨲᩣ;

ᨳᩮᨿ᩠ᨿᩣ ᨧ ᩋᨲᩥᨧᩣᩁᩣ ᨧ, ᨾᨩ᩠ᨩᨸᩣᨶᩣ ᨧ ᩌᩁᨠᩣ.

‘‘ᨸᨬ᩠ᨧᩈᩥᨠ᩠ᨡᩣᨸᨴᩮ ᩁᨲᩣ, ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶ ᨠᩮᩣᩅᩥᨴᩣ;

ᩏᨸᩣᩈᩥᨠᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ, ᨣᩮᩣᨲᨾᩔ ᨿᩈᩔᩥᨶᩮᩣ.

‘‘ᨲᩔᩣ ¶ ¶ ᨾᩮ ᨬᩣᨲᩥᨠᩩᩃᩣ ᨴᩣᩈᩦ [ᨬᩣᨲᩥᨠᩩᩃᩴ ᩌᩈᩦ (ᩈ᩠ᨿᩣ. ᨠ.)], ᩈᨴᩣ ᨾᩣᩃᩣᨽᩥᩉᩣᩁᨲᩥ;

ᨲᩣᩉᩴ ᨽᨣᩅᨲᩮᩣ ᨳᩪᨸᩮ, ᩈᨻ᩠ᨻᨾᩮᩅᩣᨽᩥᩁᩮᩣᨸᨿᩥᩴ.

‘‘ᩏᨸᩮᩣᩈᨳᩮ ᨧᩉᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᨾᩣᩃᩣᨣᨶ᩠ᨵᩅᩥᩃᩮᨸᨶᩴ;

ᨳᩪᨸᩈ᩠ᨾᩥᩴ ᩋᨽᩥᩁᩮᩣᨸᩮᩈᩥᩴ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᨲᩮᨶ ¶ ᨠᨾ᩠ᨾᩮᨶ ᨴᩮᩅᩥᨶ᩠ᨴ, ᩁᩪᨸᩴ ᨾᨿ᩠ᩉᩴ ᨣᨲᩦ ᨧ ᨾᩮ;

ᩍᨴ᩠ᨵᩦ ᨧ ᩌᨶᩩᨽᩣᩅᩮᩣ ᨧ, ᨿᩴ ᨾᩣᩃᩴ ᩋᨽᩥᩁᩮᩣᨸᨿᩥᩴ.

‘‘ᨿᨬ᩠ᨧ ᩈᩦᩃᩅᨲᩦ ᩌᩈᩥᩴ, ᨶ ᨲᩴ ᨲᩣᩅ ᩅᩥᨸᨧ᩠ᨧᨲᩥ;

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

‘‘ᨸᩣᩁᩥᨧ᩠ᨨᨲ᩠ᨲᨠᩮ ¶ ᨠᩮᩣᩅᩥᩊᩣᩁᩮ, ᩁᨾᨱᩦᨿᩮ ᨾᨶᩮᩣᩁᨾᩮ;

ᨴᩥᨻ᩠ᨻᨾᩣᩃᩴ ᨣᨶ᩠ᨳᨾᩣᨶᩣ, ᨣᩣᨿᨶ᩠ᨲᩦ ᩈᨾ᩠ᨸᨾᩮᩣᨴᩈᩥ.

‘‘ᨲᩔᩣ ᨲᩮ ᨶᨧ᩠ᨧᨾᩣᨶᩣᨿ, ᩋᨦ᩠ᨣᨾᨦ᩠ᨣᩮᩉᩥ ᩈᨻ᩠ᨻᩈᩮᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᩈᨴ᩠ᨴᩣ ᨶᩥᨧ᩠ᨨᩁᨶ᩠ᨲᩥ, ᩈᩅᨶᩦᨿᩣ ᨾᨶᩮᩣᩁᨾᩣ.

‘‘ᨲᩔᩣ ᨲᩮ ᨶᨧ᩠ᨧᨾᩣᨶᩣᨿ, ᩋᨦ᩠ᨣᨾᨦ᩠ᨣᩮᩉᩥ ᩈᨻ᩠ᨻᩈᩮᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᨣᨶ᩠ᨵᩣ ᨸᩅᩣᨿᨶ᩠ᨲᩥ, ᩈᩩᨧᩥᨣᨶ᩠ᨵᩣ ᨾᨶᩮᩣᩁᨾᩣ.

‘‘ᩅᩥᩅᨲ᩠ᨲᨾᩣᨶᩣ ᨠᩣᨿᩮᨶ, ᨿᩣ ᩅᩮᨱᩦᩈᩩ ᨸᩥᩊᨶ᩠ᨵᨶᩣ.

ᨲᩮᩈᩴ ᩈᩩᨿ᩠ᨿᨲᩥ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩮᩣ, ᨲᩪᩁᩥᨿᩮ ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠᩮ ᨿᨳᩣ.

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

ᨲᩮᩈᩴ ᩈᩩᨿ᩠ᨿᨲᩥ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩮᩣ, ᨲᩪᩁᩥᨿᩮ ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠᩮ ᨿᨳᩣ.

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

ᩅᩣᨲᩥ ¶ ᨣᨶ᩠ᨵᩮᩣ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩁᩩᨠ᩠ᨡᩮᩣ ᨾᨬ᩠ᨩᩪᩈᨠᩮᩣ ᨿᨳᩣ.

‘‘ᨥᩣᨿᩈᩮ ᨲᩴ ᩈᩩᨧᩥᨣᨶ᩠ᨵᩴ [ᩈᩩᨧᩥᩴ ᨣᨶ᩠ᨵᩴ (ᩈᩦ.)], ᩁᩪᨸᩴ ᨸᩔᩈᩥ ᩋᨾᩣᨶᩩᩈᩴ [ᨾᩣᨶᩩᩈᩴ (ᨸᩦ.)];

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᨽᩔᩁᩴ ᩋᨧ᩠ᨧᩥᨾᨶ᩠ᨲᩴ, ᩅᨱ᩠ᨱᨣᨶ᩠ᨵᩮᨶ ᩈᩴᨿᩩᨲᩴ;

ᩋᩈᩮᩣᨠᨸᩩᨸ᩠ᨹᨾᩣᩃᩣᩉᩴ, ᨻᩩᨴ᩠ᨵᩔ ᩏᨸᨶᩣᨾᨿᩥᩴ.

‘‘ᨲᩣᩉᩴ ᨠᨾ᩠ᨾᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ, ᨠᩩᩈᩃᩴ ᨻᩩᨴ᩠ᨵᩅᨱ᩠ᨱᩥᨲᩴ;

ᩋᨸᩮᨲᩈᩮᩣᨠᩣ ᩈᩩᨡᩥᨲᩣ, ᩈᨾ᩠ᨸᨾᩮᩣᨴᩣᨾᨶᩣᨾᨿᩣ’’ᨲᩥ.

ᨸᩣᩁᩥᨧ᩠ᨨᨲ᩠ᨲᨠᩅᨣ᩠ᨣᩮᩣ ᨲᨲᩥᨿᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

ᩏᩊᩣᩁᩮᩣ ᩏᨧ᩠ᨨᩩ ᨸᩃ᩠ᩃᨦ᩠ᨠᩮᩣ, ᩃᨲᩣ ᨧ ᨣᩩᨲ᩠ᨲᩥᩃᩮᨶ ᨧ;

ᨴᨴ᩠ᨴᩃ᩠ᩃᨸᩮᩈᨾᩃ᩠ᩃᩥᨠᩣ, ᩅᩥᩈᩣᩃᨠ᩠ᨡᩥ ᨸᩣᩁᩥᨧ᩠ᨨᨲ᩠ᨲᨠᩮᩣ;

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

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

‘‘ᨲᨾ᩠ᩉᩣ ᩅᩥᨾᩣᨶᩣ ᩒᩁᩩᨿ᩠ᩉ, ᨶᩥᨾ᩠ᨾᩥᨲᩣ ᩁᨲᨶᩣᨾᨿᩣ;

ᩒᨣᩣᩉᩈᩥ ¶ ᩈᩣᩃᩅᨶᩴ, ᨸᩩᨸ᩠ᨹᩥᨲᩴ ᩈᨻ᩠ᨻᨠᩣᩃᩥᨠᩴ.

‘‘ᨿᩔ ᨿᩔᩮᩅ ᩈᩣᩃᩔ, ᨾᩪᩃᩮ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩈᩮᩣ ᩈᩮᩣ ᨾᩩᨬ᩠ᨧᨲᩥ ᨸᩩᨸ᩠ᨹᩣᨶᩥ, ᩒᨶᨾᩥᨲ᩠ᩅᩣ ᨴᩩᨾᩩᨲ᩠ᨲᨾᩮᩣ.

‘‘ᩅᩣᨲᩮᩁᩥᨲᩴ ᩈᩣᩃᩅᨶᩴ, ᩌᨵᩩᨲᩴ [ᩌᨵᩪᨲᩴ (ᩈᩦ.)] ᨴᩥᨩᩈᩮᩅᩥᨲᩴ;

ᩅᩣᨲᩥ ᨣᨶ᩠ᨵᩮᩣ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩁᩩᨠ᩠ᨡᩮᩣ ᨾᨬ᩠ᨩᩪᩈᨠᩮᩣ ᨿᨳᩣ.

‘‘ᨥᩣᨿᩈᩮ ᨲᩴ ᩈᩩᨧᩥᨣᨶ᩠ᨵᩴ, ᩁᩪᨸᩴ ᨸᩔᩈᩥ ᩋᨾᩣᨶᩩᩈᩴ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

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

ᨻᩩᨴ᩠ᨵᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩴ ᨴᩥᩈ᩠ᩅᩣᨶ, ᩈᩣᩃᨸᩩᨸ᩠ᨹᩮᩉᩥ ᩒᨠᩥᩁᩥᩴ.

‘‘ᩅᨭᩴᩈᨠᨬ᩠ᨧ ᩈᩩᨠᨲᩴ, ᩈᩣᩃᨸᩩᨸ᩠ᨹᨾᨿᩴ ᩋᩉᩴ;

ᨻᩩᨴ᩠ᨵᩔ ᩏᨸᨶᩣᨾᩮᩈᩥᩴ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᨲᩣᩉᩴ ¶ ᨠᨾ᩠ᨾᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ, ᨠᩩᩈᩃᩴ ᨻᩩᨴ᩠ᨵᩅᨱ᩠ᨱᩥᨲᩴ;

ᩋᨸᩮᨲᩈᩮᩣᨠᩣ ᩈᩩᨡᩥᨲᩣ, ᩈᨾ᩠ᨸᨾᩮᩣᨴᩣᨾᨶᩣᨾᨿᩣ’’ᨲᩥ.

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

ᨾᩉᩥᨴ᩠ᨵᩥᨠᩮ ᨧᨶ᩠ᨴᨶᩁᩩᨧᩥᩁᨣᨲ᩠ᨲᩮ, ᨠᩣ ᨲ᩠ᩅᩴ ᩈᩩᨽᩮ ᨴᩮᩅᨲᩮ ᩅᨶ᩠ᨴᩈᩮ ᨾᨾᩴ.

‘‘ᨸᩃ᩠ᩃᨦ᩠ᨠᩮᩣ ¶ ᨧ ᨲᩮ ᨾᩉᨣ᩠ᨥᩮᩣ, ᨶᩣᨶᩣᩁᨲᨶᨧᩥᨲ᩠ᨲᩥᨲᩮᩣ ¶ ᩁᩩᨧᩥᩁᩮᩣ;

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

‘‘ᨠᩥᩴ ᨲ᩠ᩅᩴ ᨸᩩᩁᩮ ᩈᩩᨧᩁᩥᨲᨾᩣᨧᩁᩦ ᨽᨴ᩠ᨴᩮ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔ ᩅᩥᨸᩣᨠᩴ;

ᩋᨶᩩᨽᩮᩣᩈᩥ ᨴᩮᩅᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ, ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ;

‘‘ᨸᩥᨱ᩠ᨯᩣᨿ ᨲᩮ ᨧᩁᨶ᩠ᨲᩔ, ᨾᩣᩃᩴ ᨹᩣᨱᩥᨲᨬ᩠ᨧ ᩋᨴᨴᩴ ᨽᨶ᩠ᨲᩮ;

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

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

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

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

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

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

ᨲᩮ ᨾᩴ ᩋᨲᩥᩅᩥᩁᩮᩣᨧᨶ᩠ᨲᩥ, ᩌᨿᩩᨶᩣ ᨿᩈᩈᩣ ᩈᩥᩁᩥᨿᩣ.

ᩋᨬ᩠ᨬᩮ ᨾᩉᩥᨴ᩠ᨵᩥᨠᨲᩁᩣ ᨾᨿᩣ ᨴᩮᩅᩣ’’ᨲᩥ;

‘‘ᩋᩃᨦ᩠ᨠᨲᩣ ¶ ¶ ᨾᨱᩥᨠᨬ᩠ᨧᨶᩣᨧᩥᨲᩴ, ᩈᩮᩣᩅᨱ᩠ᨱᨩᩣᩃᨧᩥᨲᩴ ᨾᩉᨶ᩠ᨲᩴ;

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

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

ᨸᨴᩩᨾᩮᩈᩩ ᨧ ᨲᩩᩁᩥᨿᨣᨱᩣ ᨸᨽᩥᨩ᩠ᨩᩁᩮ, ᩍᨾᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᨾᨶᩮᩣᩉᩁᩣᨿᩮᩣ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮ, ᨾᨶᩩᩔᨽᩪᨲᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨻᩣᩁᩣᨱᩈᩥᨿᩴ ¶ ᩏᨸᩈᨦ᩠ᨠᨾᩥᨲ᩠ᩅᩣ, ᨻᩩᨴ᩠ᨵᩔᩉᩴ ᩅᨲ᩠ᨳᨿᩩᨣᩴ ᩋᨴᩣᩈᩥᩴ;

ᨸᩣᨴᩣᨶᩥ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ [ᩅᨶ᩠ᨴᩥᨲ᩠ᩅ (ᩈᩦ.)] ᨨᨾᩣ ᨶᩥᩈᩦᨴᩥᩴ, ᩅᩥᨲ᩠ᨲᩣ ᨧᩉᩴ ᩋᨬ᩠ᨩᩃᩥᨠᩴ ᩋᨠᩣᩈᩥᩴ.

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

ᩋᩈᨦ᩠ᨡᨲᩴ ᨴᩩᨠ᩠ᨡᨶᩥᩁᩮᩣᨵᩈᩔᨲᩴ, ᨾᨣ᩠ᨣᩴ ᩋᨴᩮᩈᨿᩥ [ᩋᨴᩮᩈᩮᩈᩥ (ᩈᩦ.)] ᨿᨲᩮᩣ ᩅᩥᨩᩣᨶᩥᩈᩴ;

‘‘ᩋᨸ᩠ᨸᩣᨿᩩᨠᩦ ¶ ᨠᩣᩃᨠᨲᩣ ᨲᨲᩮᩣ ᨧᩩᨲᩣ, ᩏᨸᨸᨶ᩠ᨶᩣ ᨲᩥᨴᩈᨣᨱᩴ ᨿᩈᩔᩥᨶᩦ;

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

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ¶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᨬ᩠ᨧ ¶ ᨻᩣᩁᩣᨱᩈᩥᨿᩴ, ᨻᩩᨴ᩠ᨵᩔᩣᨴᩥᨧ᩠ᨧᨻᨶ᩠ᨵᩩᨶᩮᩣ;

ᩋᨴᩣᩈᩥᩴ ᩈᩩᨠ᩠ᨡᨠᩩᨾ᩠ᨾᩣᩈᩴ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᩈᩩᨠ᩠ᨡᩣᨿ ᩋᩃᩮᩣᨱᩥᨠᩣᨿ ᨧ, ᨸᩔ ᨹᩃᩴ ᨠᩩᨾ᩠ᨾᩣᩈᨸᩥᨱ᩠ᨯᩥᨿᩣ;

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

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ¶ ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᩋᨶ᩠ᨵᨠᩅᩥᨶ᩠ᨴᨾ᩠ᩉᩥ, ᨻᩩᨴ᩠ᨵᩔᩣᨴᩥᨧ᩠ᨧᨻᨶ᩠ᨵᩩᨶᩮᩣ;

ᩋᨴᩣᩈᩥᩴ ᨠᩮᩣᩃᩈᨾ᩠ᨸᩣᨠᩴ, ᨠᨬ᩠ᨩᩥᨠᩴ ᨲᩮᩃᨵᩪᨸᩥᨲᩴ.

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

ᩋᨴᩣᩈᩥᩴ ᩏᨩᩩᨽᩪᨲᩈ᩠ᨾᩥᩴ [ᩏᨩᩩᨽᩪᨲᩮᩈᩩ (ᨠ.)], ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ.

‘‘ᨿᩣ ¶ ¶ ᨾᩉᩮᩈᩥᨲ᩠ᨲᩴ ᨠᩣᩁᩮᨿ᩠ᨿ, ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩥᩔ ᩁᩣᨩᩥᨶᩮᩣ;

ᨶᩣᩁᩦ ᩈᨻ᩠ᨻᨦ᩠ᨣᨠᩃ᩠ᨿᩣᨱᩦ, ᨽᨲ᩠ᨲᩩ ᨧᩣᨶᩮᩣᨾᨴᩔᩥᨠᩣ;

ᩑᨠᩔ ¶ ᨠᨬ᩠ᨩᩥᨠᨴᩣᨶᩔ, ᨠᩃᩴ ᨶᩣᨣ᩠ᨥᨲᩥ ᩈᩮᩣᩊᩈᩥᩴ.

‘‘ᩈᨲᩴ ᨶᩥᨠ᩠ᨡᩣ ᩈᨲᩴ ᩋᩔᩣ, ᩈᨲᩴ ᩋᩔᨲᩁᩦᩁᨳᩣ;

ᩈᨲᩴ ᨠᨬ᩠ᨬᩣᩈᩉᩔᩣᨶᩥ, ᩌᨾᩩᨲ᩠ᨲᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᩣ;

ᩑᨠᩔ ᨠᨬ᩠ᨩᩥᨠᨴᩣᨶᩔ, ᨠᩃᩴ ᨶᩣᨣ᩠ᨥᨶ᩠ᨲᩥ ᩈᩮᩣᩊᩈᩥᩴ.

‘‘ᩈᨲᩴ ᩉᩮᨾᩅᨲᩣ ᨶᩣᨣᩣ, ᩎᩈᩣᨴᨶ᩠ᨲᩣ ᩏᩁᩪᩊ᩠ᩉᩅᩣ;

ᩈᩩᩅᨱ᩠ᨱᨠᨧ᩠ᨨᩣ ᨾᩣᨲᨦ᩠ᨣᩣ, ᩉᩮᨾᨠᨸ᩠ᨸᨶᩅᩣᩈᩈᩣ;

ᩑᨠᩔ ᨠᨬ᩠ᨩᩥᨠᨴᩣᨶᩔ, ᨠᩃᩴ ᨶᩣᨣ᩠ᨥᨶ᩠ᨲᩥ ᩈᩮᩣᩊᩈᩥᩴ.

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

ᩑᨠᩔ ᨠᨬ᩠ᨩᩥᨠᨴᩣᨶᩔ, ᨠᩃᩴ ᨶᩣᨣ᩠ᨥᨲᩥ ᩈᩮᩣᩊᩈᩥ’’ᨶ᩠ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ… ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨲᩔᩣ ᨲᩮ ᨶᨧ᩠ᨧᨾᩣᨶᩣᨿ, ᩋᨦ᩠ᨣᨾᨦ᩠ᨣᩮᩉᩥ ᩈᨻ᩠ᨻᩈᩮᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᩈᨴ᩠ᨴᩣ ᨶᩥᨧ᩠ᨨᩁᨶ᩠ᨲᩥ, ᩈᩅᨶᩦᨿᩣ ᨾᨶᩮᩣᩁᨾᩣ.

‘‘ᨲᩔᩣ ᨲᩮ ᨶᨧ᩠ᨧᨾᩣᨶᩣᨿ, ᩋᨦ᩠ᨣᨾᨦ᩠ᨣᩮᩉᩥ ᩈᨻ᩠ᨻᩈᩮᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᨣᨶ᩠ᨵᩣ ᨸᩅᩣᨿᨶ᩠ᨲᩥ, ᩈᩩᨧᩥᨣᨶ᩠ᨵᩣ ᨾᨶᩮᩣᩁᨾᩣ.

‘‘ᩅᩥᩅᨲ᩠ᨲᨾᩣᨶᩣ ᨠᩣᨿᩮᨶ, ᨿᩣ ᩅᩮᨱᩦᩈᩩ ᨸᩥᩊᨶ᩠ᨵᨶᩣ;

ᨲᩮᩈᩴ ᩈᩩᨿ᩠ᨿᨲᩥ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩮᩣ, ᨲᩩᩁᩥᨿᩮ ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠᩮ ᨿᨳᩣ.

‘‘ᩅᨭᩴᩈᨠᩣ ᩅᩣᨲᨵᩩᨲᩣ, ᩅᩣᨲᩮᨶ ᩈᨾ᩠ᨸᨠᨾ᩠ᨸᩥᨲᩣ;

ᨲᩮᩈᩴ ᩈᩩᨿ᩠ᨿᨲᩥ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩮᩣ, ᨲᩩᩁᩥᨿᩮ ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠᩮ ᨿᨳᩣ.

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

ᩅᩣᨲᩥ ᨣᨶ᩠ᨵᩮᩣ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩁᩩᨠ᩠ᨡᩮᩣ ᨾᨬ᩠ᨩᩪᩈᨠᩮᩣ ᨿᨳᩣ.

‘‘ᨥᩣᨿᩈᩮ ᨲᩴ ᩈᩩᨧᩥᨣᨶ᩠ᨵᩴ, ᩁᩪᨸᩴ ᨸᩔᩈᩥ ᩋᨾᩣᨶᩩᩈᩴ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᩈᩣᩅᨲ᩠ᨳᩥᨿᩴ ¶ ¶ ᨾᨿ᩠ᩉᩴ ᩈᨡᩦ ᨽᨴᨶ᩠ᨲᩮ, ᩈᨦ᩠ᨥᩔ ᨠᩣᩁᩮᩈᩥ ᨾᩉᩣᩅᩥᩉᩣᩁᩴ;

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

‘‘ᨲᩣᨿᩮᩅ ¶ ᨾᩮ ᩈᩩᨴ᩠ᨵᨶᩩᨾᩮᩣᨴᨶᩣᨿ, ᩃᨴ᩠ᨵᩴ ᩅᩥᨾᩣᨶᨻ᩠ᨽᩩᨲᨴᩔᨶᩮᨿ᩠ᨿᩴ;

ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᩈᩮᩣᩊᩈᨿᩮᩣᨩᨶᩣᨶᩥ, ᩅᩮᩉᩣᨿᩈᩴ ᨣᨧ᩠ᨨᨲᩥ ᩍᨴ᩠ᨵᩥᨿᩣ ᨾᨾ.

‘‘ᨠᩪᨭᩣᨣᩣᩁᩣ ᨶᩥᩅᩮᩈᩣ ᨾᩮ, ᩅᩥᨽᨲ᩠ᨲᩣ ᨽᩣᨣᩈᩮᩣ ᨾᩥᨲᩣ;

ᨴᨴ᩠ᨴᩃ᩠ᩃᨾᩣᨶᩣ ᩌᨽᨶ᩠ᨲᩥ, ᩈᨾᨶ᩠ᨲᩣ ᩈᨲᨿᩮᩣᨩᨶᩴ.

‘‘ᨸᩮᩣᨠ᩠ᨡᩁᨬ᩠ᨬᩮᩣ ᨧ ᨾᩮ ᩑᨲ᩠ᨳ, ᨸᩩᨳᩩᩃᩮᩣᨾᨶᩥᩈᩮᩅᩥᨲᩣ;

ᩋᨧ᩠ᨨᩮᩣᨴᨠᩣ [ᩋᨧ᩠ᨨᩮᩣᨴᩥᨠᩣ (ᩈᩦ.)] ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩣ, ᩈᩮᩣᨱ᩠ᨱᩅᩣᩃᩩᨠᩈᨶ᩠ᨳᨲᩣ.

‘‘ᨶᩣᨶᩣᨸᨴᩩᨾᩈᨬ᩠ᨨᨶ᩠ᨶᩣ, ᨸᩩᨱ᩠ᨯᩁᩦᨠᩈᨾᩮᩣᨲᨲᩣ [ᨸᨱ᩠ᨯᩁᩦᨠᩈᨾᩮᩣᨶᨲᩣ (ᩈᩦ.)];

ᩈᩩᩁᨽᩦ ᩈᨾ᩠ᨸᩅᩣᨿᨶ᩠ᨲᩥ, ᨾᨶᩩᨬ᩠ᨬᩣ ᨾᩣᩃᩩᨲᩮᩁᩥᨲᩣ.

‘‘ᨩᨾ᩠ᨻᩩᨿᩮᩣ ᨸᨶᩈᩣ ᨲᩣᩃᩣ, ᨶᩣᩊᩥᨠᩮᩁᩅᨶᩣᨶᩥ ᨧ;

ᩋᨶ᩠ᨲᩮᩣᨶᩥᩅᩮᩈᨶᩮ ᨩᩣᨲᩣ, ᨶᩣᨶᩣᩁᩩᨠ᩠ᨡᩣ ᩋᩁᩮᩣᨸᩥᨾᩣ.

‘‘ᨶᩣᨶᩣᨲᩪᩁᩥᨿᩈᨦ᩠ᨥᩩᨭ᩠ᨮᩴ ¶ , ᩋᨧ᩠ᨨᩁᩣᨣᨱᨥᩮᩣᩈᩥᨲᩴ;

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

‘‘ᩑᨲᩣᨴᩥᩈᩴ ᩋᨻ᩠ᨽᩩᨲᨴᩔᨶᩮᨿ᩠ᨿᩴ, ᩅᩥᨾᩣᨶᩴ ᩈᨻ᩠ᨻᩈᩮᩣᨸᨽᩴ;

ᨾᨾ ᨠᨾ᩠ᨾᩮᩉᩥ ᨶᩥᨻ᩠ᨻᨲ᩠ᨲᩴ, ᩋᩃᩴ ᨸᩩᨬ᩠ᨬᩣᨶᩥ ᨠᩣᨲᩅᩮ’’ᨲᩥ.

‘‘ᨲᩣᨿᩮᩅ ᨲᩮ ᩈᩩᨴ᩠ᨵᨶᩩᨾᩮᩣᨴᨶᩣᨿ, ᩃᨴ᩠ᨵᩴ ᩅᩥᨾᩣᨶᨻ᩠ᨽᩩᨲᨴᩔᨶᩮᨿ᩠ᨿᩴ;

ᨿᩣ ᨧᩮᩅ ᩈᩣ ᨴᩣᨶᨾᨴᩣᩈᩥ ᨶᩣᩁᩦ, ᨲᩔᩣ ᨣᨲᩥᩴ ᨻᩕᩪᩉᩥ ᨠᩩᩉᩥᩴ ᩏᨸ᩠ᨸᨶ᩠ᨶᩣ [ᩏᨸᨸᨶ᩠ᨶᩣ (ᨠ.)] ᩈᩣ’’ᨲᩥ.

‘‘ᨿᩣ ᩈᩣ ᩋᩉᩩ ᨾᨿ᩠ᩉᩴ ᩈᨡᩦ ᨽᨴᨶ᩠ᨲᩮ, ᩈᨦ᩠ᨥᩔ ᨠᩣᩁᩮᩈᩥ ᨾᩉᩣᩅᩥᩉᩣᩁᩴ;

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

‘‘ᨸᨩᩣᨸᨲᩦ ¶ ᨲᩔ ᩈᩩᨶᩥᨾ᩠ᨾᩥᨲᩔ, ᩋᨧᩥᨶ᩠ᨲᩥᨿᩣ ᨠᨾ᩠ᨾᩅᩥᨸᩣᨠᩣ ᨲᩔ;

ᨿᨾᩮᨲᩴ ᨸᩩᨧ᩠ᨨᩈᩥ ᨠᩩᩉᩥᩴ ᩏᨸ᩠ᨸᨶ᩠ᨶᩣ [ᩏᨸᨸᨶ᩠ᨶᩣ (ᨠ.)] ᩈᩣᨲᩥ, ᨲᩴ ᨲᩮ ᩅᩥᨿᩣᨠᩣᩈᩥᩴ ᩋᨶᨬ᩠ᨬᨳᩣ ᩋᩉᩴ.

‘‘ᨲᩮᨶᩉᨬ᩠ᨬᩮᨸᩥ ᩈᨾᩣᨴᨸᩮᨳ, ᩈᨦ᩠ᨥᩔ ᨴᩣᨶᩣᨶᩥ ᨴᨴᩣᨳ ᩅᩥᨲ᩠ᨲᩣ;

ᨵᨾ᩠ᨾᨬ᩠ᨧ ᩈᩩᨱᩣᨳ ᨸᩈᨶ᩠ᨶᨾᩣᨶᩈᩣ, ᩈᩩᨴᩩᩃ᩠ᩃᨽᩮᩣ ᩃᨴ᩠ᨵᩮᩣ ᨾᨶᩩᩔᩃᩣᨽᩮᩣ.

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

ᩈᨦ᩠ᨥᩔ ᨴᩣᨶᩣᨶᩥ ᨴᨴᩣᨳ ᩅᩥᨲ᩠ᨲᩣ, ᨾᩉᨸ᩠ᨹᩃᩣ ᨿᨲ᩠ᨳ ᨽᩅᨶ᩠ᨲᩥ ᨴᨠ᩠ᨡᩥᨱᩣ.

[ᨡᩩ. ᨸᩣ. ᪖.᪖; ᩈᩩ. ᨶᩥ. ᪒᪒᪙] ‘‘ᨿᩮ ¶ ᨸᩩᨣ᩠ᨣᩃᩣ ᩋᨭ᩠ᨮ ᩈᨲᩴ ᨸᩈᨲ᩠ᨳᩣ, ᨧᨲ᩠ᨲᩣᩁᩥ ᩑᨲᩣᨶᩥ ᨿᩩᨣᩣᨶᩥ ᩉᩮᩣᨶ᩠ᨲᩥ;

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

[ᩅᩥ. ᩅ. ᪖᪔᪑] ‘‘ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᨧ ᨸᨭᩥᨸᨶ᩠ᨶᩣ, ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᨧ ᨹᩃᩮ ᨮᩥᨲᩣ;

ᩑᩈ ᩈᨦ᩠ᨥᩮᩣ ᩏᨩᩩᨽᩪᨲᩮᩣ, ᨸᨬ᩠ᨬᩣᩈᩦᩃᩈᨾᩣᩉᩥᨲᩮᩣ.

[ᩅᩥ. ᩅ. ᪖᪔᪒] ‘‘ᨿᨩᨾᩣᨶᩣᨶᩴ ¶ ᨾᨶᩩᩔᩣᨶᩴ, ᨸᩩᨬ᩠ᨬᨸᩮᨠ᩠ᨡᩣᨶ ᨸᩣᨱᩥᨶᩴ;

ᨠᩁᩮᩣᨲᩴ ᩒᨸᨵᩥᨠᩴ ᨸᩩᨬ᩠ᨬᩴ, ᩈᨦ᩠ᨥᩮ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ.

[ᩅᩥ. ᩅ. ᪖᪔᪓] ‘‘ᩑᩈᩮᩣ ᩉᩥ ᩈᨦ᩠ᨥᩮᩣ ᩅᩥᨸᩩᩃᩮᩣ ᨾᩉᨣ᩠ᨣᨲᩮᩣ, ᩑᩈᨸ᩠ᨸᨾᩮᨿ᩠ᨿᩮᩣ ᩏᨴᨵᩦᩅ ᩈᩣᨣᩁᩮᩣ;

ᩑᨲᩮᩉᩥ ᩈᩮᨭ᩠ᨮᩣ ᨶᩁᩅᩦᩁᩈᩣᩅᨠᩣ, ᨸᨽᨦ᩠ᨠᩁᩣ ᨵᨾ᩠ᨾᨾᩩᨴᩦᩁᨿᨶ᩠ᨲᩥ [ᨶᨲ᩠ᨳᩮᨲ᩠ᨳ ᨸᩣᨮᨽᩮᨴᩮᩣ].

[ᩅᩥ. ᩅ. ᪖᪔᪔] ‘‘ᨲᩮᩈᩴ ᩈᩩᨴᩥᨶ᩠ᨶᩴ ᩈᩩᩉᩩᨲᩴ ᩈᩩᨿᩥᨭ᩠ᨮᩴ, ᨿᩮ ᩈᨦ᩠ᨥᨾᩩᨴ᩠ᨴᩥᩔ ᨴᨴᨶ᩠ᨲᩥ ᨴᩣᨶᩴ;

ᩈᩣ ᨴᨠ᩠ᨡᩥᨱᩣ ᩈᨦ᩠ᨥᨣᨲᩣ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩣ, ᨾᩉᨸ᩠ᨹᩃᩣ ᩃᩮᩣᨠᩅᩥᨴᩪᨶ [ᩃᩮᩣᨠᩅᩥᨴᩪᩉᩥ (ᨠ.)] ᩅᨱ᩠ᨱᩥᨲᩣ.

‘‘ᩑᨲᩣᨴᩥᩈᩴ ¶ ¶ ᨿᨬ᩠ᨬᨾᨶᩩᩔᩁᨶ᩠ᨲᩣ, ᨿᩮ ᩅᩮᨴᨩᩣᨲᩣ ᩅᩥᨧᩁᨶ᩠ᨲᩥ ᩃᩮᩣᨠᩮ;

ᩅᩥᨶᩮᨿ᩠ᨿ ᨾᨧ᩠ᨨᩮᩁᨾᩃᩴ ᩈᨾᩪᩃᩴ, ᩋᨶᩥᨶ᩠ᨴᩥᨲᩣ ᩈᨣ᩠ᨣᨾᩩᨸᩮᨶ᩠ᨲᩥ ᨮᩣᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩍᨶ᩠ᨴᩦᩅᩁᩣᨶᩴ ¶ ᩉᨲ᩠ᨳᨠᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ;

ᩑᩈᩥᨠᩣᨶᩴ ᩏᨱ᩠ᨱᨲᩈ᩠ᨾᩥᩴ, ᨶᨣᩁᩅᩁᩮ ᨸᨱ᩠ᨱᨠᨲᩮ ᩁᨾ᩠ᨾᩮ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩔᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ¶ ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨶᩦᩃᩩᨸ᩠ᨸᩃᩉᨲ᩠ᨳᨠᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ, ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ;

ᩑᩈᩥᨠᩣᨶᩴ ᩏᨱ᩠ᨱᨲᩈ᩠ᨾᩥᩴ, ᨶᨣᩁᩅᩁᩮ ᨸᨱ᩠ᨱᨠᨲᩮ ᩁᨾ᩠ᨾᩮ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩒᨴᩣᨲᨾᩪᩃᨠᩴ ᩉᩁᩥᨲᨸᨲ᩠ᨲᩴ, ᩏᨴᨠᩈ᩠ᨾᩥᩴ ᩈᩁᩮ ᨩᩣᨲᩴ ᩋᩉᨾᨴᩣᩈᩥᩴ;

ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ, ᩑᩈᩥᨠᩣᨶᩴ ᩏᨱ᩠ᨱᨲᩈ᩠ᨾᩥᩴ;

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ¶ ᩅᨱ᩠ᨱᩮᨶ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᩈᩩᨾᨶᩣ ᩈᩩᨾᨶᩔ ᩈᩩᨾᨶᨾᨠᩩᩊᩣᨶᩥ, ᨴᨶ᩠ᨲᩅᨱ᩠ᨱᩣᨶᩥ ᩋᩉᨾᨴᩣᩈᩥᩴ;

ᨽᩥᨠ᩠ᨡᩩᨶᩮᩣ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᨶ᩠ᨲᩔ, ᩑᩈᩥᨠᩣᨶᩴ ᩏᨱ᩠ᨱᨲᩈ᩠ᨾᩥᩴ;

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨴᩥᨻ᩠ᨻᩴ ¶ ᨲᩮ ᩋᨾ᩠ᨻᩅᨶᩴ ᩁᨾ᩠ᨾᩴ, ᨸᩣᩈᩣᨴᩮᨲ᩠ᨳ ᨾᩉᩃ᩠ᩃᨠᩮᩣ;

ᨶᩣᨶᩣᨲᩩᩁᩥᨿᩈᨦ᩠ᨥᩩᨭ᩠ᨮᩮᩣ, ᩋᨧ᩠ᨨᩁᩣᨣᨱᨥᩮᩣᩈᩥᨲᩮᩣ.

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

ᨴᩩᩔᨹᩃᩮᩉᩥ ᩁᩩᨠ᩠ᨡᩮᩉᩥ, ᩈᨾᨶ᩠ᨲᩣ ᨸᩁᩥᩅᩣᩁᩥᨲᩮᩣ.

‘‘ᨠᩮᨶ ¶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ;

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ¶ ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩣ, ᨸᩩᩁᩥᨾᩣᨿ ᨩᩣᨲᩥᨿᩣ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ;

ᩅᩥᩉᩣᩁᩴ ᩈᨦ᩠ᨥᩔ ᨠᩣᩁᩮᩈᩥᩴ, ᩋᨾ᩠ᨻᩮᩉᩥ ᨸᩁᩥᩅᩣᩁᩥᨲᩴ.

‘‘ᨸᩁᩥᨿᩮᩣᩈᩥᨲᩮ ᩅᩥᩉᩣᩁᩮ, ᨠᩣᩁᩮᨶ᩠ᨲᩮ ᨶᩥᨭ᩠ᨮᩥᨲᩮ ᨾᩉᩮ;

ᩋᨾ᩠ᨻᩮᩉᩥ ᨨᩣᨴᨿᩥᨲ᩠ᩅᩣᨶ [ᩋᨾ᩠ᨻᩮ ᩋᨧ᩠ᨨᩣᨴᨿᩥᨲ᩠ᩅᩣᨶ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩋᨾ᩠ᨻᩮᩉᨧ᩠ᨨᩣᨴᨿᩥᨲ᩠ᩅᩣᨶ (ᨸᩦ. ᨠ.)], ᨠᨲ᩠ᩅᩣ ᨴᩩᩔᨾᨿᩮ ᨹᩃᩮ.

‘‘ᨸᨴᩦᨸᩴ ᨲᨲ᩠ᨳ ᨩᩣᩃᩮᨲ᩠ᩅᩣ, ᨽᩮᩣᨩᨿᩥᨲ᩠ᩅᩣ ᨣᨱᩩᨲ᩠ᨲᨾᩴ;

ᨶᩥᨿ᩠ᨿᩣᨴᩮᩈᩥᩴ ᨲᩴ ᩈᨦ᩠ᨥᩔ, ᨸᩈᨶ᩠ᨶᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᨲᩮᨶ ᨾᩮ ᩋᨾ᩠ᨻᩅᨶᩴ ᩁᨾ᩠ᨾᩴ, ᨸᩣᩈᩣᨴᩮᨲ᩠ᨳ ᨾᩉᩃ᩠ᩃᨠᩮᩣ;

ᨶᩣᨶᩣᨲᩩᩁᩥᨿᩈᨦ᩠ᨥᩩᨭ᩠ᨮᩮᩣ, ᩋᨧ᩠ᨨᩁᩣᨣᨱᨥᩮᩣᩈᩥᨲᩮᩣ.

‘‘ᨸᨴᩦᨸᩮᩣ ¶ ᨧᩮᨲ᩠ᨳ ᨩᩃᨲᩥ, ᨶᩥᨧ᩠ᨧᩴ ᩈᩮᩣᩅᨱ᩠ᨱᨿᩮᩣ ᨾᩉᩣ;

ᨴᩩᩔᨹᩃᩮᩉᩥ ᩁᩩᨠ᩠ᨡᩮᩉᩥ, ᩈᨾᨶ᩠ᨲᩣ ᨸᩁᩥᩅᩣᩁᩥᨲᩮᩣ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨸᩦᨲᩅᨲ᩠ᨳᩮ ¶ ᨸᩦᨲᨵᨩᩮ, ᨸᩦᨲᩣᩃᨦ᩠ᨠᩣᩁᨽᩪᩈᩥᨲᩮ;

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

‘‘ᨸᩦᨲᨸᩣᩈᩣᨴᩈᨿᨶᩮ, ᨸᩦᨲᩣᩈᨶᩮ ᨸᩦᨲᨽᩣᨩᨶᩮ;

ᨸᩦᨲᨨᨲ᩠ᨲᩮ ᨸᩦᨲᩁᨳᩮ, ᨸᩦᨲᩔᩮ ᨸᩦᨲᨻᩦᨩᨶᩮ.

‘‘ᨠᩥᩴ ¶ ¶ ᨠᨾ᩠ᨾᨾᨠᩁᩦ ᨽᨴ᩠ᨴᩮ, ᨸᩩᨻ᩠ᨻᩮ ᨾᩣᨶᩩᩈᨠᩮ ᨽᩅᩮ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᨠᩮᩣᩈᩣᨲᨠᩦ ᨶᩣᨾ ᩃᨲᨲ᩠ᨳᩥ ᨽᨶ᩠ᨲᩮ, ᨲᩥᨲ᩠ᨲᩥᨠᩣ ᩋᨶᨽᩥᨧ᩠ᨨᩥᨲᩣ;

ᨲᩔᩣ ᨧᨲ᩠ᨲᩣᩁᩥ ᨸᩩᨸ᩠ᨹᩣᨶᩥ, ᨳᩪᨸᩴ ᩋᨽᩥᩉᩁᩥᩴ ᩋᩉᩴ.

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

ᨶᩣᩔ ᨾᨣ᩠ᨣᩴ ᩋᩅᩮᨠ᩠ᨡᩥᩔᩴ, ᨶ ᨲᨣ᩠ᨣᨾᨶᩈᩣ [ᨲᨴᨣ᩠ᨣᨾᨶᩈᩣ (ᩈᩦ.), ᨲᨴᨦ᩠ᨣᨾᨶᩈᩣ (ᩈ᩠ᨿᩣ.)] ᩈᨲᩦ.

‘‘ᨲᨲᩮᩣ ᨾᩴ ᩋᩅᨵᩦ ᨣᩣᩅᩦ, ᨳᩪᨸᩴ ᩋᨸᨲ᩠ᨲᨾᩣᨶᩈᩴ;

ᨲᨬ᩠ᨧᩣᩉᩴ ᩋᨽᩥᩈᨬ᩠ᨧᩮᨿ᩠ᨿᩴ, ᨽᩥᨿ᩠ᨿᩮᩣ [ᨽᩦᨿᩮᩣ (ᩈᩦ. ᩋᨭ᩠ᨮ.)] ᨶᩪᨶ ᩍᨲᩮᩣ ᩈᩥᨿᩣ.

‘‘ᨲᩮᨶ ᨠᨾ᩠ᨾᩮᨶ ᨴᩮᩅᩥᨶ᩠ᨴ, ᨾᨥᩅᩣ ᨴᩮᩅᨠᩩᨬ᩠ᨩᩁᩮᩣ;

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

ᩍᨴᩴ ¶ ᩈᩩᨲ᩠ᩅᩣ ᨲᩥᨴᩈᩣᨵᩥᨸᨲᩥ, ᨾᨥᩅᩣ ᨴᩮᩅᨠᩩᨬ᩠ᨩᩁᩮᩣ;

ᨲᩣᩅᨲᩥᩴᩈᩮ ᨸᩈᩣᨴᩮᨶ᩠ᨲᩮᩣ, ᨾᩣᨲᩃᩥᩴ ᩑᨲᨴᨻᩕᩅᩥ [ᩑᨲᨴᨻᩕᩪᩅᩦᨲᩥ (ᩈᩦ.)].

‘‘ᨸᩔ ᨾᩣᨲᩃᩥ ᩋᨧ᩠ᨨᩮᩁᩴ, ᨧᩥᨲ᩠ᨲᩴ ᨠᨾ᩠ᨾᨹᩃᩴ ᩍᨴᩴ;

ᩋᨸ᩠ᨸᨠᨾ᩠ᨸᩥ ᨠᨲᩴ ᨴᩮᨿ᩠ᨿᩴ, ᨸᩩᨬ᩠ᨬᩴ ᩉᩮᩣᨲᩥ ᨾᩉᨸ᩠ᨹᩃᩴ.

‘‘ᨶᨲ᩠ᨳᩥ ᨧᩥᨲ᩠ᨲᩮ ᨸᩈᨶ᩠ᨶᨾ᩠ᩉᩥ, ᩋᨸ᩠ᨸᨠᩣ ᨶᩣᨾ ᨴᨠ᩠ᨡᩥᨱᩣ;

ᨲᨳᩣᨣᨲᩮ ᩅᩣ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮ, ᩋᨳ ᩅᩣ ᨲᩔ ᩈᩣᩅᨠᩮ.

‘‘ᩑᩉᩥ ᨾᩣᨲᩃᩥ ᩋᨾ᩠ᩉᩮᨸᩥ, ᨽᩥᨿ᩠ᨿᩮᩣ ᨽᩥᨿ᩠ᨿᩮᩣ ᨾᩉᩮᨾᩈᩮ;

ᨲᨳᩣᨣᨲᩔ ᨵᩣᨲᩩᨿᩮᩣ, ᩈᩩᨡᩮᩣ ᨸᩩᨬ᩠ᨬᩣᨶ ᨾᩩᨧ᩠ᨧᨿᩮᩣ.

‘‘ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩮ ᨶᩥᨻ᩠ᨻᩩᨲᩮ ᨧᩣᨸᩥ, ᩈᨾᩮ ᨧᩥᨲ᩠ᨲᩮ ᩈᨾᩴ ᨹᩃᩴ;

ᨧᩮᨲᩮᩣᨸᨱᩥᨵᩥᩉᩮᨲᩩ ¶ ᩉᩥ, ᩈᨲ᩠ᨲᩣ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ ᩈᩩᨣ᩠ᨣᨲᩥᩴ.

‘‘ᨻᩉᩪᨶᩴ [ᨻᩉᩩᨶ᩠ᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩅᨲ ᩋᨲ᩠ᨳᩣᨿ, ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨲᨳᩣᨣᨲᩣ;

ᨿᨲ᩠ᨳ ᨠᩣᩁᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ, ᩈᨣ᩠ᨣᩴ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ ᨴᩣᨿᨠᩣ’’ᨲᩥ.

‘‘ᩒᨽᩣᩈᨿᩥᨲ᩠ᩅᩣ ¶ ¶ ᨸᨳᩅᩥᩴ ᩈᨴᩮᩅᨠᩴ, ᩋᨲᩥᩁᩮᩣᨧᩈᩥ ᨧᨶ᩠ᨴᩥᨾᩈᩪᩁᩥᨿᩣ ᩅᩥᨿ;

ᩈᩥᩁᩥᨿᩣ ᨧ ᩅᨱ᩠ᨱᩮᨶ ᨿᩈᩮᨶ ᨲᩮᨩᩈᩣ, ᨻᩕᩉ᩠ᨾᩣᩅ ᨴᩮᩅᩮ ᨲᩥᨴᩈᩮ ᩈᩉᩥᨶ᩠ᨴᨠᩮ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ¶ ᨲᩴ ᩏᨸ᩠ᨸᩃᨾᩣᩃᨵᩣᩁᩥᨶᩦ, ᩌᩅᩮᩊᩥᨶᩦ ᨠᨬ᩠ᨧᨶᩈᨶ᩠ᨶᩥᨽᨲ᩠ᨲᨧᩮ;

ᩋᩃᨦ᩠ᨠᨲᩮ ᩏᨲ᩠ᨲᨾᩅᨲ᩠ᨳᨵᩣᩁᩥᨶᩦ, ᨠᩣ ᨲ᩠ᩅᩴ ᩈᩩᨽᩮ ᨴᩮᩅᨲᩮ ᩅᨶ᩠ᨴᩈᩮ ᨾᨾᩴ.

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

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

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᩍᨴᩣᨶᩥ ᨽᨶ᩠ᨲᩮ ᩍᨾᨾᩮᩅ ᨣᩣᨾᩴ, ᨸᩥᨱ᩠ᨯᩣᨿ ᩋᨾ᩠ᩉᩣᨠ ᨥᩁᩴ ᩏᨸᩣᨣᨾᩥ;

ᨲᨲᩮᩣ ᨲᩮ ᩏᨧ᩠ᨨᩩᩔ ᩋᨴᩣᩈᩥ ᨡᨱ᩠ᨯᩥᨠᩴ, ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ ᩋᨲᩩᩃᩣᨿ ᨸᩦᨲᩥᨿᩣ;

‘‘ᩈᩔᩩ ¶ ᨧ ᨸᨧ᩠ᨨᩣ ᩋᨶᩩᨿᩩᨬ᩠ᨩᨲᩮ ᨾᨾᩴ, ᨠᩉᩴ ᨶᩩ ᩏᨧ᩠ᨨᩩᩴ ᩅᨵᩩᨠᩮ ᩋᩅᩣᨠᩥᩁᩦ;

ᨶ ᨨᨯ᩠ᨯᩥᨲᩴ ᨶᩮᩣ ᨸᨶ ᨡᩣᨴᩥᨲᩴ ᨾᨿᩣ, ᩈᨶ᩠ᨲᩔ ᨽᩥᨠ᩠ᨡᩩᩔ ᩈᨿᩴ ᩋᨴᩣᩈᩉᩴ.

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

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

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

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

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

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

‘‘ᩑᨲᩣᨴᩥᩈᩴ ¶ ᨸᩩᨬ᩠ᨬᨹᩃᩴ ᩋᨶᨸ᩠ᨸᨠᩴ, ᨾᩉᩣᩅᩥᨸᩣᨠᩣ ᨾᨾ ᩏᨧ᩠ᨨᩩᨴᨠ᩠ᨡᩥᨱᩣ;

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

‘‘ᩑᨲᩣᨴᩥᩈᩴ ᨸᩩᨬ᩠ᨬᨹᩃᩴ ᩋᨶᨸ᩠ᨸᨠᩴ, ᨾᩉᩣᨩᩩᨲᩥᨠᩣ ᨾᨾ ᩏᨧ᩠ᨨᩩᨴᨠ᩠ᨡᩥᨱᩣ;

ᨴᩮᩅᩥᨶ᩠ᨴᨣᩩᨲ᩠ᨲᩣ ᨲᩥᨴᩈᩮᩉᩥ ᩁᨠ᩠ᨡᩥᨲᩣ, ᩈᩉᩔᨶᩮᨲ᩠ᨲᩮᩣᩁᩥᩅ ᨶᨶ᩠ᨴᨶᩮ ᩅᨶᩮ.

‘‘ᨲᩩᩅᨬ᩠ᨧ ¶ ᨽᨶ᩠ᨲᩮ ᩋᨶᩩᨠᨾ᩠ᨸᨠᩴ ᩅᩥᨴᩩᩴ, ᩏᨸᩮᨧ᩠ᨧ ᩅᨶ᩠ᨴᩥᩴ ᨠᩩᩈᩃᨬ᩠ᨧ ᨸᩩᨧ᩠ᨨᩥᩈᩴ;

ᨲᨲᩮᩣ ᨲᩮ ᩏᨧ᩠ᨨᩩᩔ ᩋᨴᩣᩈᩥᩴ ᨡᨱ᩠ᨯᩥᨠᩴ, ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ ᩋᨲᩩᩃᩣᨿ ᨸᩦᨲᩥᨿᩣ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ¶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩦ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩣ ᨴᩮᩅᨲᩣ ᩋᨲ᩠ᨲᨾᨶᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩣ, ᨴᩥᩈ᩠ᩅᩣᨶ ᩈᨾᨱᩮ ᩈᩦᩃᩅᨶ᩠ᨲᩮ;

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

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ¶ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ, ᨿᩣ ᨲ᩠ᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᨴᩮᩅᨲᩮ;

ᩉᨲ᩠ᨳᨸᩣᨴᩮ ᨧ ᩅᩥᨣ᩠ᨣᨿ᩠ᩉ, ᨶᨧ᩠ᨧᩈᩥ ᩈᩩᨸ᩠ᨸᩅᩣᨴᩥᨲᩮ.

‘‘ᨲᩔᩣ ᨲᩮ ᨶᨧ᩠ᨧᨾᩣᨶᩣᨿ, ᩋᨦ᩠ᨣᨾᨦ᩠ᨣᩮᩉᩥ ᩈᨻ᩠ᨻᩈᩮᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᩈᨴ᩠ᨴᩣ ᨶᩥᨧ᩠ᨨᩁᨶ᩠ᨲᩥ, ᩈᩅᨶᩦᨿᩣ ᨾᨶᩮᩣᩁᨾᩣ.

‘‘ᨲᩔᩣ ᨲᩮ ᨶᨧ᩠ᨧᨾᩣᨶᩣᨿ, ᩋᨦ᩠ᨣᨾᨦ᩠ᨣᩮᩉᩥ ᩈᨻ᩠ᨻᩈᩮᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᨣᨶ᩠ᨵᩣ ᨸᩅᩣᨿᨶ᩠ᨲᩥ, ᩈᩩᨧᩥᨣᨶ᩠ᨵᩣ ᨾᨶᩮᩣᩁᨾᩣ.

‘‘ᩅᩥᩅᨲ᩠ᨲᨾᩣᨶᩣ ᨠᩣᨿᩮᨶ, ᨿᩣ ᩅᩮᨱᩦᩈᩩ ᨸᩥᩊᨶ᩠ᨵᨶᩣ;

ᨲᩮᩈᩴ ᩈᩩᨿ᩠ᨿᨲᩥ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩮᩣ, ᨲᩩᩁᩥᨿᩮ ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠᩮ ᨿᨳᩣ.

‘‘ᩅᨭᩴᩈᨠᩣ ᩅᩣᨲᨵᩩᨲᩣ, ᩅᩣᨲᩮᨶ ᩈᨾ᩠ᨸᨠᨾ᩠ᨸᩥᨲᩣ;

ᨲᩮᩈᩴ ᩈᩩᨿ᩠ᨿᨲᩥ ᨶᩥᨣ᩠ᨥᩮᩣᩈᩮᩣ, ᨲᩩᩁᩥᨿᩮ ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠᩮ ᨿᨳᩣ.

‘‘ᨿᩣᨸᩥ ᨲᩮ ᩈᩥᩁᩈ᩠ᨾᩥᩴ ᨾᩣᩃᩣ, ᩈᩩᨧᩥᨣᨶ᩠ᨵᩣ ᨾᨶᩮᩣᩁᨾᩣ;

ᩅᩣᨲᩥ ᨣᨶ᩠ᨵᩮᩣ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩁᩩᨠ᩠ᨡᩮᩣ ᨾᨬ᩠ᨩᩪᩈᨠᩮᩣ ᨿᨳᩣ.

‘‘ᨥᩣᨿᩈᩮ ¶ ᨲᩴ ᩈᩩᨧᩥᨣᨶ᩠ᨵᩴ, ᩁᩪᨸᩴ ᨸᩔᩈᩥ ᩋᨾᩣᨶᩩᩈᩴ;

ᨴᩮᩅᨲᩮ ᨸᩩᨧ᩠ᨨᩥᨲᩣᨧᩥᨠ᩠ᨡ, ᨠᩥᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᨴᩣᩈᩦ ¶ ᩋᩉᩴ ᨸᩩᩁᩮ ᩌᩈᩥᩴ, ᨣᨿᩣᨿᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩔᩉᩴ;

ᩋᨸ᩠ᨸᨸᩩᨬ᩠ᨬᩣ ᩋᩃᨠ᩠ᨡᩥᨠᩣ, ᩁᨩ᩠ᨩᩩᨾᩣᩃᩣᨲᩥ ᨾᩴ ᩅᩥᨴᩩᩴ [ᩅᩥᨴᩪ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)].

‘‘ᩋᨠ᩠ᨠᩮᩣᩈᩣᨶᩴ ᩅᨵᩣᨶᨬ᩠ᨧ, ᨲᨩ᩠ᨩᨶᩣᨿ ᨧ ᩏᨣ᩠ᨣᨲᩣ [ᩏᨠ᩠ᨠᨲᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

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

‘‘ᩅᩥᨸᨳᩮ ¶ ᨠᩩᨭᩴ ᨶᩥᨠ᩠ᨡᩥᨸᩥᨲ᩠ᩅᩣ, ᩅᨶᩈᨱ᩠ᨯᩴ ᩏᨸᩣᨣᨾᩥᩴ;

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

‘‘ᨴᩊ᩠ᩉᩴ ᨸᩣᩈᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ, ᩌᩈᩩᨾ᩠ᨽᩥᨲ᩠ᩅᩣᨶ ᨸᩣᨴᨸᩮ;

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

‘‘ᨲᨲ᩠ᨳᨴ᩠ᨴᩈᩣᩈᩥᩴ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩴ, ᩈᨻ᩠ᨻᩃᩮᩣᨠᩉᩥᨲᩴ ᨾᩩᨶᩥᩴ;

ᨶᩥᩈᩥᨶ᩠ᨶᩴ ᩁᩩᨠ᩠ᨡᨾᩪᩃᩈ᩠ᨾᩥᩴ, ᨫᩣᨿᨶ᩠ᨲᩴ ᩋᨠᩩᨲᩮᩣᨽᨿᩴ.

‘‘ᨲᩔᩣ ᨾᩮ ᩋᩉᩩ ᩈᩴᩅᩮᨣᩮᩣ, ᩋᨻ᩠ᨽᩩᨲᩮᩣ ᩃᩮᩣᨾᩉᩴᩈᨶᩮᩣ;

ᨠᩮᩣ ᨶᩩ ᨡᩮᩣ ᩅᨶᨾᩔᩥᨲᩮᩣ, ᨾᨶᩩᩔᩮᩣ ᩏᨴᩣᩉᩩ ᨴᩮᩅᨲᩣ.

‘‘ᨸᩣᩈᩣᨴᩥᨠᩴ ᨸᩈᩣᨴᨶᩦᨿᩴ, ᩅᨶᩣ ᨶᩥᨻ᩠ᨻᨶᨾᩣᨣᨲᩴ;

ᨴᩥᩈ᩠ᩅᩣ ᨾᨶᩮᩣ ᨾᩮ ᨸᩈᩦᨴᩥ, ᨶᩣᨿᩴ ᨿᩣᨴᩥᩈᨠᩦᨴᩥᩈᩮᩣ.

‘‘ᨣᩩᨲ᩠ᨲᩥᨶ᩠ᨴᩕᩥᨿᩮᩣ ᨫᩣᨶᩁᨲᩮᩣ, ᩋᨻᩉᩥᨣ᩠ᨣᨲᨾᩣᨶᩈᩮᩣ;

ᩉᩥᨲᩮᩣ ᩈᨻ᩠ᨻᩔ ᩃᩮᩣᨠᩔ, ᨻᩩᨴ᩠ᨵᩮᩣ ᩋᨿᩴ [ᩈᩮᩣᨿᩴ (ᩈᩦ.)] ᨽᩅᩥᩔᨲᩥ.

‘‘ᨽᨿᨽᩮᩁᩅᩮᩣ ᨴᩩᩁᩣᩈᨴᩮᩣ, ᩈᩦᩉᩮᩣᩅ ᨣᩩᩉᨾᩔᩥᨲᩮᩣ;

ᨴᩩᩃ᩠ᩃᨽᩣᨿᩴ ᨴᩔᨶᩣᨿ, ᨸᩩᨸ᩠ᨹᩴ ᩒᨴᩩᨾ᩠ᨻᩁᩴ ᨿᨳᩣ.

‘‘ᩈᩮᩣ ᨾᩴ ᨾᩩᨴᩪᩉᩥ ᩅᩣᨧᩣᩉᩥ, ᩌᩃᨸᩥᨲ᩠ᩅᩣ ᨲᨳᩣᨣᨲᩮᩣ;

ᩁᨩ᩠ᨩᩩᨾᩣᩃᩮᨲᩥ ᨾᩴᩅᩮᩣᨧ, ᩈᩁᨱᩴ ᨣᨧ᩠ᨨ ᨲᨳᩣᨣᨲᩴ.

‘‘ᨲᩣᩉᩴ ᨣᩥᩁᩴ ᩈᩩᨱᩥᨲ᩠ᩅᩣᨶ, ᨶᩮᩃᩴ ᩋᨲ᩠ᨳᩅᨲᩥᩴ ᩈᩩᨧᩥᩴ;

ᩈᨱ᩠ᩉᩴ ᨾᩩᨴᩩᨬ᩠ᨧ ᩅᨣ᩠ᨣᩩᨬ᩠ᨧ, ᩈᨻ᩠ᨻᩈᩮᩣᨠᩣᨸᨶᩪᨴᨶᩴ.

‘‘ᨠᩃ᩠ᩃᨧᩥᨲ᩠ᨲᨬ᩠ᨧ ᨾᩴ ᨬᨲ᩠ᩅᩣ, ᨸᩈᨶ᩠ᨶᩴ ᩈᩩᨴ᩠ᨵᨾᩣᨶᩈᩴ;

ᩉᩥᨲᩮᩣ ¶ ᩈᨻ᩠ᨻᩔ ᩃᩮᩣᨠᩔ, ᩋᨶᩩᩈᩣᩈᩥ ᨲᨳᩣᨣᨲᩮᩣ.

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

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

‘‘ᩋᨶᩩᨠᨾ᩠ᨸᨠᩔ ¶ ᨠᩩᩈᩃᩔ, ᩒᩅᩣᨴᨾ᩠ᩉᩥ ᩋᩉᩴ ᨮᩥᨲᩣ;

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

‘‘ᩈᩣᩉᩴ ᩋᩅᨭ᩠ᨮᩥᨲᩣᨸᩮᨾᩣ, ᨴᩔᨶᩮ ᩋᩅᩥᨠᨾ᩠ᨸᩥᨶᩦ;

ᨾᩪᩃᨩᩣᨲᩣᨿ ᩈᨴ᩠ᨵᩣᨿ, ᨵᩦᨲᩣ ᨻᩩᨴ᩠ᨵᩔ ᩒᩁᩈᩣ.

‘‘ᩈᩣᩉᩴ ¶ ¶ ᩁᨾᩣᨾᩥ ᨠᩦᩊᩣᨾᩥ, ᨾᩮᩣᨴᩣᨾᩥ ᩋᨠᩩᨲᩮᩣᨽᨿᩣ;

ᨴᩥᨻ᩠ᨻᨾᩣᩃᩴ ᨵᩣᩁᨿᩣᨾᩥ, ᨸᩥᩅᩣᨾᩥ ᨾᨵᩩᨾᨴ᩠ᨴᩅᩴ.

‘‘ᩈᨭ᩠ᨮᩥᨲᩩᩁᩥᨿᩈᩉᩔᩣᨶᩥ, ᨸᨭᩥᨻᩮᩣᨵᩴ ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᨾᩮ;

ᩌᩊᨾ᩠ᨻᩮᩣ ᨣᨣ᩠ᨣᩁᩮᩣ ᨽᩦᨾᩮᩣ, ᩈᩣᨵᩩᩅᩣᨴᩦ ᨧ ᩈᩴᩈᨿᩮᩣ.

‘‘ᨸᩮᩣᨠ᩠ᨡᩁᩮᩣ ᨧ ᩈᩩᨹᩔᩮᩣ ᨧ, ᩅᩦᨱᩣᨾᩮᩣᨠ᩠ᨡᩣ ᨧ ᨶᩣᩁᩥᨿᩮᩣ;

ᨶᨶ᩠ᨴᩣ ᨧᩮᩅ ᩈᩩᨶᨶ᩠ᨴᩣ ᨧ, ᩈᩮᩣᨱᨴᩥᨶ᩠ᨶᩣ ᩈᩩᨧᩥᨾ᩠ᩉᩥᨲᩣ.

‘‘ᩋᩃᨾ᩠ᨻᩩᩈᩣ ᨾᩥᩔᨠᩮᩈᩦ ᨧ, ᨸᩩᨱ᩠ᨯᩁᩦᨠᩣᨲᩥᨴᩣᩁᩩᨱᩦ [… ᨲᩥᨧᩣᩁᩩᨱᩦ (ᩈᩦ.)];

ᩑᨱᩦᨹᩔᩣ ᩈᩩᨹᩔᩣ [ᩈᩩᨸᩔᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᨧ, ᩈᩩᨽᨴ᩠ᨴᩣ [ᩈᩴᨽᨴ᩠ᨴᩣ (ᨠ.)] ᨾᩩᨴᩩᩅᩣᨴᩥᨶᩦ.

‘‘ᩑᨲᩣ ᨧᨬ᩠ᨬᩣ ᨧ ᩈᩮᨿ᩠ᨿᩣᩈᩮ, ᩋᨧ᩠ᨨᩁᩣᨶᩴ ᨸᨻᩮᩣᨵᩥᨠᩣ;

ᨲᩣ ᨾᩴ ᨠᩣᩃᩮᨶᩩᨸᩣᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩋᨽᩥᨽᩣᩈᨶ᩠ᨲᩥ ᨴᩮᩅᨲᩣ.

‘‘ᩉᨶ᩠ᨴ ᨶᨧ᩠ᨧᩣᨾ ᨣᩣᨿᩣᨾ, ᩉᨶ᩠ᨴ ᨲᩴ ᩁᨾᨿᩣᨾᩈᩮ;

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

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

ᩈᩩᨡᩴ ᩋᨠᨲᨸᩩᨬ᩠ᨬᩣᨶᩴ, ᩍᨵ ᨶᨲ᩠ᨳᩥ ᨸᩁᨲ᩠ᨳ ᨧ.

‘‘ᩈᩩᨡᨬ᩠ᨧ ᨠᨲᨸᩩᨬ᩠ᨬᩣᨶᩴ, ᩍᨵ ᨧᩮᩅ ᨸᩁᨲ᩠ᨳ ᨧ;

ᨲᩮᩈᩴ ᩈᩉᨻ᩠ᨿᨠᩣᨾᩣᨶᩴ, ᨠᨲ᩠ᨲᨻ᩠ᨻᩴ ᨠᩩᩈᩃᩴ ᨻᩉᩩᩴ;

ᨠᨲᨸᩩᨬ᩠ᨬᩣ ᩉᩥ ᨾᩮᩣᨴᨶ᩠ᨲᩥ, ᩈᨣ᩠ᨣᩮ ᨽᩮᩣᨣᩈᨾᨦ᩠ᨣᩥᨶᩮᩣ.

‘‘ᨻᩉᩪᨶᩴ ᩅᨲ ᩋᨲ᩠ᨳᩣᨿ, ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨲᨳᩣᨣᨲᩣ;

ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩣ ᨾᨶᩩᩔᩣᨶᩴ, ᨸᩩᨬ᩠ᨬᨡᩮᨲ᩠ᨲᩣᨶᨾᩣᨠᩁᩣ;

ᨿᨲ᩠ᨳ ᨠᩣᩁᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ, ᩈᨣ᩠ᨣᩮ ᨾᩮᩣᨴᨶ᩠ᨲᩥ ᨴᩣᨿᨠᩣ’’ᨲᩥ.

ᨾᨬ᩠ᨩᩥᨭ᩠ᨮᨠᩅᨣ᩠ᨣᩮᩣ ᨧᨲᩩᨲ᩠ᨳᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

ᨾᨬ᩠ᨩᩥᨭ᩠ᨮᩣ ¶ ᨸᨽᩔᩁᩣ ᨶᩣᨣᩣ, ᩋᩃᩮᩣᨾᩣᨠᨬ᩠ᨩᩥᨠᨴᩣᨿᩥᨠᩣ;

ᩅᩥᩉᩣᩁᨧᨲᩩᩁᩥᨲ᩠ᨳᨾ᩠ᨻᩣ, ᨸᩦᨲᩣ ᩏᨧ᩠ᨨᩩᩅᨶ᩠ᨴᨶᩁᨩ᩠ᨩᩩᨾᩣᩃᩣ ᨧ;

‘‘ᨠᩮᩣ ¶ ¶ ¶ ᨾᩮ ᩅᨶ᩠ᨴᨲᩥ ᨸᩣᨴᩣᨶᩥ, ᩍᨴ᩠ᨵᩥᨿᩣ ᨿᩈᩈᩣ ᨩᩃᩴ;

ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᨶ ᩅᨱ᩠ᨱᩮᨶ, ᩈᨻ᩠ᨻᩣ ᩒᨽᩣᩈᨿᩴ ᨴᩥᩈᩣ’’ᨲᩥ.

‘‘ᨾᨱ᩠ᨯᩪᨠᩮᩣᩉᩴ ᨸᩩᩁᩮ ᩌᩈᩥᩴ, ᩏᨴᨠᩮ ᩅᩣᩁᩥᨣᩮᩣᨧᩁᩮᩣ;

ᨲᩅ ᨵᨾ᩠ᨾᩴ ᩈᩩᨱᨶ᩠ᨲᩔ, ᩋᩅᨵᩦ ᩅᨧ᩠ᨨᨸᩣᩃᨠᩮᩣ.

‘‘ᨾᩩᩉᩩᨲ᩠ᨲᩴ ¶ ᨧᩥᨲ᩠ᨲᨸᩈᩣᨴᩔ, ᩍᨴ᩠ᨵᩥᩴ ᨸᩔ ᨿᩈᨬ᩠ᨧ ᨾᩮ;

ᩌᨶᩩᨽᩣᩅᨬ᩠ᨧ ᨾᩮ ᨸᩔ, ᩅᨱ᩠ᨱᩴ ᨸᩔ ᨩᩩᨲᩥᨬ᩠ᨧ ᨾᩮ.

‘‘ᨿᩮ ᨧ ᨲᩮ ᨴᩦᨥᨾᨴ᩠ᨵᩣᨶᩴ, ᨵᨾ᩠ᨾᩴ ᩋᩔᩮᩣᩈᩩᩴ ᨣᩮᩣᨲᨾ;

ᨸᨲ᩠ᨲᩣ ᨲᩮ ᩋᨧᩃᨭ᩠ᨮᩣᨶᩴ, ᨿᨲ᩠ᨳ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᨶ ᩈᩮᩣᨧᩁᩮ’’ᨲᩥ.

[ᨵ. ᨸ. ᪒᪑᪙ ᨵᨾ᩠ᨾᨸᨴᩮ] ‘‘ᨧᩥᩁᨸ᩠ᨸᩅᩣᩈᩥᩴ ᨸᩩᩁᩥᩈᩴ, ᨴᩪᩁᨲᩮᩣ ᩈᩮᩣᨲ᩠ᨳᩥᨾᩣᨣᨲᩴ;

ᨬᩣᨲᩥᨾᩥᨲ᩠ᨲᩣ ᩈᩩᩉᨩ᩠ᨩᩣ ᨧ, ᩋᨽᩥᨶᨶ᩠ᨴᨶ᩠ᨲᩥ ᩌᨣᨲᩴ;

[ᨵ. ᨸ. ᪒᪒᪐ ᨵᨾ᩠ᨾᨸᨴᩮ] ‘‘ᨲᨳᩮᩅ ¶ ᨠᨲᨸᩩᨬ᩠ᨬᨾ᩠ᨸᩥ, ᩋᩈ᩠ᨾᩣ ᩃᩮᩣᨠᩣ ᨸᩁᩴ ᨣᨲᩴ;

ᨸᩩᨬ᩠ᨬᩣᨶᩥ ᨸᨭᩥᨣᨱ᩠ᩉᨶ᩠ᨲᩥ, ᨸᩥᨿᩴ ᨬᩣᨲᩦᩅ ᩌᨣᨲᩴ.

[ᨸᩮ. ᩅ. ᪗᪑᪔]‘‘ᩏᨭ᩠ᨮᩮᩉᩥ ᩁᩮᩅᨲᩮ ᩈᩩᨸᩣᨸᨵᨾ᩠ᨾᩮ, ᩋᨸᩣᩁᩩᨲᨴ᩠ᩅᩣᩁᩮ [ᩋᨸᩣᩁᩩᨽᩴ ᨴ᩠ᩅᩣᩁᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩋᨸᩣᩁᩩᨲᨴ᩠ᩅᩣᩁᩴ (ᨸᩦ. ᨠ.)] ᩋᨴᩣᨶᩈᩦᩃᩮ;

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

ᩍᨧ᩠ᨧᩮᩅ ¶ [ᩍᨧ᩠ᨧᩮᩅᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩅᨲ᩠ᩅᩣᨶ ᨿᨾᩔ ᨴᩪᨲᩣ, ᨲᩮ ᨴ᩠ᩅᩮ ᨿᨠ᩠ᨡᩣ ᩃᩮᩣᩉᩥᨲᨠ᩠ᨡᩣ ᨻᩕᩉᨶ᩠ᨲᩣ;

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

‘‘ᩌᨴᩥᨧ᩠ᨧᩅᨱ᩠ᨱᩴ ¶ ᩁᩩᨧᩥᩁᩴ ᨸᨽᩔᩁᩴ, ᨻ᩠ᨿᨾ᩠ᩉᩴ ᩈᩩᨽᩴ ᨠᨬ᩠ᨧᨶᨩᩣᩃᨨᨶ᩠ᨶᩴ;

ᨠᩔᩮᨲᨾᩣᨠᩥᨱ᩠ᨱᨩᨶᩴ ¶ ᩅᩥᨾᩣᨶᩴ, ᩈᩪᩁᩥᨿᩔ ᩁᩴᩈᩦᩁᩥᩅ ᨩᩮᩣᨲᨾᩣᨶᩴ.

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

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

‘‘ᨻᩣᩁᩣᨱᩈᩥᨿᩴ ᨶᨶ᩠ᨴᩥᨿᩮᩣ ᨶᩣᨾᩣᩈᩥ, ᩏᨸᩣᩈᨠᩮᩣ ᩋᨾᨧ᩠ᨨᩁᩦ ᨴᩣᨶᨸᨲᩥ ᩅᨴᨬ᩠ᨬᩪ;

ᨲᩔᩮᨲᨾᩣᨠᩥᨱ᩠ᨱᨩᨶᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᩪᩁᩥᨿᩔ ᩁᩴᩈᩦᩁᩥᩅ ᨩᩮᩣᨲᨾᩣᨶᩴ.

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

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

‘‘ᨶᨶ᩠ᨴᩥᨿᩔᩣᩉᩴ ᨽᩁᩥᨿᩣ, ᩋᨣᩣᩁᩥᨶᩦ ᩈᨻ᩠ᨻᨠᩩᩃᩔ ᩍᩔᩁᩣ;

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

‘‘ᩑᩈᩮᩣ ᨲᩮ ᨶᩥᩁᨿᩮᩣ ᩈᩩᨸᩣᨸᨵᨾ᩠ᨾᩮ, ᨸᩩᨬ᩠ᨬᩴ ¶ ᨲᨿᩣ ᩋᨠᨲᩴ ᨩᩦᩅᩃᩮᩣᨠᩮ;

ᨶ ᩉᩥ ᨾᨧ᩠ᨨᩁᩦ ᩁᩮᩣᩈᨠᩮᩣ ᨸᩣᨸᨵᨾ᩠ᨾᩮᩣ, ᩈᨣ᩠ᨣᩪᨸᨣᩣᨶᩴ ᩃᨽᨲᩥ ᩈᩉᨻ᩠ᨿᨲ’’ᨶ᩠ᨲᩥ.

‘‘ᨠᩥᩴ ¶ ᨶᩩ ᨣᩪᨳᨬ᩠ᨧ ᨾᩩᨲ᩠ᨲᨬ᩠ᨧ, ᩋᩈᩩᨧᩦ ᨸᨭᩥᨴᩥᩔᨲᩥ;

ᨴᩩᨣ᩠ᨣᨶ᩠ᨵᩴ ᨠᩥᨾᩥᨴᩴ ᨾᩦᩊ᩠ᩉᩴ, ᨠᩥᨾᩮᨲᩴ ᩏᨸᩅᩣᨿᨲᩦ’’ᨲᩥ.

‘‘ᩑᩈ ᩈᩴᩈᩅᨠᩮᩣ ᨶᩣᨾ, ᨣᨾ᩠ᨽᩦᩁᩮᩣ ᩈᨲᨸᩮᩣᩁᩥᩈᩮᩣ;

ᨿᨲ᩠ᨳ ᩅᩔᩈᩉᩔᩣᨶᩥ, ᨲᩩᩅᩴ ᨸᨧ᩠ᨧᩈᩥ ᩁᩮᩅᨲᩮ’’ᨲᩥ.

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

ᨠᩮᨶ ᩈᩴᩈᩅᨠᩮᩣ ᩃᨴ᩠ᨵᩮᩣ, ᨣᨾ᩠ᨽᩦᩁᩮᩣ ᩈᨲᨸᩮᩣᩁᩥᩈᩮᩣ’’ᨲᩥ.

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

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

‘‘ᨲᩮᨶ ᩈᩴᩈᩅᨠᩮᩣ ᩃᨴ᩠ᨵᩮᩣ, ᨣᨾ᩠ᨽᩦᩁᩮᩣ ᩈᨲᨸᩮᩣᩁᩥᩈᩮᩣ;

ᨲᨲ᩠ᨳ ᩅᩔᩈᩉᩔᩣᨶᩥ, ᨲᩩᩅᩴ ᨸᨧ᩠ᨧᩈᩥ ᩁᩮᩅᨲᩮ.

‘‘ᩉᨲ᩠ᨳᩮᨸᩥ ᨨᩥᨶ᩠ᨴᨶ᩠ᨲᩥ ᩋᨳᩮᩣᨸᩥ ᨸᩣᨴᩮ, ᨠᨱ᩠ᨱᩮᨸᩥ ᨨᩥᨶ᩠ᨴᨶ᩠ᨲᩥ ᩋᨳᩮᩣᨸᩥ ᨶᩣᩈᩴ;

ᩋᨳᩮᩣᨸᩥ ᨠᩣᨠᩮᩣᩊᨣᨱᩣ ᩈᨾᩮᨧ᩠ᨧ, ᩈᨦ᩠ᨣᨾ᩠ᨾ ᨡᩣᨴᨶ᩠ᨲᩥ ᩅᩥᨹᨶ᩠ᨴᨾᩣᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᩈᩣᨵᩩ ᨡᩮᩣ ᨾᩴ ᨸᨭᩥᨶᩮᨳ, ᨠᩣᩉᩣᨾᩥ ᨠᩩᩈᩃᩴ ᨻᩉᩩᩴ;

ᨿᩴ ᨠᨲ᩠ᩅᩣ ᩈᩩᨡᩥᨲᩣ ᩉᩮᩣᨶ᩠ᨲᩥ, ᨶ ᨧ ᨸᨧ᩠ᨨᩣᨶᩩᨲᨸ᩠ᨸᩁᩮ’’ᨲᩥ.

‘‘ᨸᩩᩁᩮ ¶ ᨲᩩᩅᩴ ᨸᨾᨩ᩠ᨩᩥᨲ᩠ᩅᩣ, ᩍᨴᩣᨶᩥ ᨸᩁᩥᨴᩮᩅᩈᩥ;

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

‘‘ᨠᩮᩣ ¶ ᨴᩮᩅᩃᩮᩣᨠᨲᩮᩣ ᨾᨶᩩᩔᩃᩮᩣᨠᩴ, ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨸᩩᨭ᩠ᨮᩮᩣ ᨾᩮ ᩑᩅᩴ ᩅᨴᩮᨿ᩠ᨿ;

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

ᨶᩉᩥ ᨾᨧ᩠ᨨᩁᩦ ᩁᩮᩣᩈᨠᩮᩣ ᨸᩣᨸᨵᨾ᩠ᨾᩮᩣ, ᩈᨣ᩠ᨣᩪᨸᨣᩣᨶᩴ ᩃᨽᨲᩥ ᩈᩉᨻ᩠ᨿᨲᩴ’.

‘‘ᩈᩣᩉᩴ ᨶᩪᨶ ᩍᨲᩮᩣ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᨿᩮᩣᨶᩥᩴ ᩃᨴ᩠ᨵᩣᨶ ᨾᩣᨶᩩᩈᩥᩴ;

ᩅᨴᨬ᩠ᨬᩪ ᩈᩦᩃᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᨠᩣᩉᩣᨾᩥ ᨠᩩᩈᩃᩴ ᨻᩉᩩᩴ;

‘‘ᩌᩁᩣᨾᩣᨶᩥ ¶ ᨧ ᩁᩮᩣᨸᩥᩔᩴ, ᨴᩩᨣ᩠ᨣᩮ ᩈᨦ᩠ᨠᨾᨶᩣᨶᩥ ᨧ;

ᨸᨸᨬ᩠ᨧ ᩏᨴᨸᩣᨶᨬ᩠ᨧ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ.

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

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

‘‘ᩏᨸᩮᩣᩈᨳᩴ ᩏᨸᩅᩈᩥᩔᩴ, ᩈᨴᩣ ᩈᩦᩃᩮᩈᩩ ᩈᩴᩅᩩᨲᩣ;

ᨶ ᨧ ᨴᩣᨶᩮ ᨸᨾᨩ᩠ᨩᩥᩔᩴ, ᩈᩣᨾᩴ ᨴᩥᨭ᩠ᨮᨾᩥᨴᩴ ᨾᨿᩣ’’ᨲᩥ;

ᩍᨧ᩠ᨧᩮᩅᩴ ᩅᩥᨸ᩠ᨸᩃᨸᨶ᩠ᨲᩥᩴ, ᨹᨶ᩠ᨴᨾᩣᨶᩴ ᨲᨲᩮᩣ ᨲᨲᩮᩣ;

ᨡᩥᨸᩥᩴᩈᩩ ᨶᩥᩁᨿᩮ ᨥᩮᩣᩁᩮ, ᩏᨴ᩠ᨵᨸᩣᨴᩴ ᩋᩅᩴᩈᩥᩁᩴ.

‘‘ᩋᩉᩴ ᨸᩩᩁᩮ ᨾᨧ᩠ᨨᩁᩥᨶᩦ ᩋᩉᩮᩣᩈᩥᩴ, ᨸᩁᩥᨽᩣᩈᩥᨠᩣ ¶ ᩈᨾᨱᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ;

ᩅᩥᨲᨳᩮᨶ ᨧ ᩈᩣᨾᩥᨠᩴ ᩅᨬ᩠ᨧᨿᩥᨲ᩠ᩅᩣ, ᨸᨧ᩠ᨧᩣᨾᩉᩴ ᨶᩥᩁᨿᩮ ᨥᩮᩣᩁᩁᩪᨸᩮ’’ᨲᩥ.

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

ᨸᩣᩁᨣᨲᩮᩣ ᨻᩃᩅᩦᩁᩥᨿᩈᨾᨦ᩠ᨣᩦ [ᨻᩃᩅᩦᩁᩈᨾᨦ᩠ᨣᩦ (ᨠ.)], ᨲᩴ ᩈᩩᨣᨲᩴ ᩈᩁᨱᨲ᩠ᨳᨾᩩᨸᩮᩉᩥ.

‘‘ᩁᩣᨣᩅᩥᩁᩣᨣᨾᨶᩮᨩᨾᩈᩮᩣᨠᩴ, ᨵᨾ᩠ᨾᨾᩈᨦ᩠ᨡᨲᨾᨸ᩠ᨸᨭᩥᨠᩪᩃᩴ;

ᨾᨵᩩᩁᨾᩥᨾᩴ ᨸᨣᩩᨱᩴ ᩈᩩᩅᩥᨽᨲ᩠ᨲᩴ, ᨵᨾ᩠ᨾᨾᩥᨾᩴ ᩈᩁᨱᨲ᩠ᨳᨾᩩᨸᩮᩉᩥ.

‘‘ᨿᨲ᩠ᨳ ¶ ᨧ ᨴᩥᨶ᩠ᨶ ᨾᩉᨸ᩠ᨹᩃᨾᩣᩉᩩ, ᨧᨲᩪᩈᩩ ᩈᩩᨧᩦᩈᩩ ᨸᩩᩁᩥᩈᨿᩩᨣᩮᩈᩩ;

ᩋᨭ᩠ᨮ ᨧ ᨸᩩᨣ᩠ᨣᩃᨵᨾ᩠ᨾᨴᩈᩣ ᨲᩮ, ᩈᨦ᩠ᨥᨾᩥᨾᩴ ᩈᩁᨱᨲ᩠ᨳᨾᩩᨸᩮᩉᩥ.

‘‘ᨶ ¶ ᨲᨳᩣ ᨲᨸᨲᩥ ᨶᨽᩮ ᩈᩪᩁᩥᨿᩮᩣ, ᨧᨶ᩠ᨴᩮᩣ ᨧ ᨶ ᨽᩣᩈᨲᩥ ᨶ ᨹᩩᩔᩮᩣ;

ᨿᨳᩣ ᩋᨲᩩᩃᨾᩥᨴᩴ ᨾᩉᨸ᩠ᨸᨽᩣᩈᩴ, ᨠᩮᩣ ¶ ᨶᩩ ᨲ᩠ᩅᩴ ᨲᩥᨴᩥᩅᩣ ᨾᩉᩥᩴ ᩏᨸᩣᨣᩣ.

‘‘ᨨᩥᨶ᩠ᨴᨲᩥ ¶ ᩁᩴᩈᩦ ᨸᨽᨦ᩠ᨠᩁᩔ, ᩈᩣᨵᩥᨠᩅᩦᩈᨲᩥᨿᩮᩣᨩᨶᩣᨶᩥ ᩌᨽᩣ;

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

‘‘ᨻᩉᩩᨸᨴᩩᨾᩅᩥᨧᩥᨲᩕᨸᩩᨱ᩠ᨯᩁᩦᨠᩴ, ᩅᩮᩣᨠᩥᨱ᩠ᨱᩴ ᨠᩩᩈᩩᨾᩮᩉᩥ ᨶᩮᨠᨧᩥᨲ᩠ᨲᩴ;

ᩋᩁᨩᩅᩥᩁᨩᩉᩮᨾᨩᩣᩃᨨᨶ᩠ᨶᩴ, ᩌᨠᩣᩈᩮ ᨲᨸᨲᩥ ᨿᨳᩣᨸᩥ ᩈᩪᩁᩥᨿᩮᩣ.

‘‘ᩁᨲ᩠ᨲᨾ᩠ᨻᩁᨸᩦᨲᩅᩈᩈᩣᩉᩥ, ᩋᨣᩁᩩᨸᩥᨿᨦ᩠ᨣᩩᨧᨶ᩠ᨴᨶᩩᩔᨴᩣᩉᩥ;

ᨠᨬ᩠ᨧᨶᨲᨶᩩᩈᨶ᩠ᨶᩥᨽᨲ᩠ᨲᨧᩣᩉᩥ, ᨸᩁᩥᨸᩪᩁᩴ ᨣᨣᨶᩴᩅ ᨲᩣᩁᨠᩣᩉᩥ.

‘‘ᨶᩁᨶᩣᩁᩥᨿᩮᩣ [ᨶᩁᨶᩣᩁᩦ (ᨠ.), ᨶᩣᩁᩥᨿᩮᩣ (?)] ᨻᩉᩩᨠᩮᨲ᩠ᨳᨶᩮᨠᩅᨱ᩠ᨱᩣ, ᨠᩩᩈᩩᨾᩅᩥᨽᩪᩈᩥᨲᩣᨽᩁᨱᩮᨲ᩠ᨳ ᩈᩩᨾᨶᩣ;

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

‘‘ᨠᩥᩔ ᩈᩴᨿᨾᩔ [ᩈᨾᨴᨾᩔ (ᩈᩦ.)] ᩋᨿᩴ ᩅᩥᨸᩣᨠᩮᩣ, ᨠᩮᨶᩣᩈᩥ ᨠᨾ᩠ᨾᨹᩃᩮᨶᩥᨵᩪᨸᨸᨶ᩠ᨶᩮᩣ;

ᨿᨳᩣ ¶ ᨧ ᨲᩮ ᩋᨵᩥᨣᨲᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᨲᨴᨶᩩᨸᨴᩴ ᩋᩅᨧᩣᩈᩥ ᩍᨦ᩠ᨥ ᨸᩩᨭ᩠ᨮᩮᩣ’’ᨲᩥ.

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

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

‘‘ᨩᩥᨶᩅᩁᨸᩅᩁᩴ ¶ [ᨩᩥᨶᨸᩅᩁᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩏᨸᩮᩉᩥ [ᩏᨸᩮᨾᩥ (ᨻᩉᩪᩈᩩ)] ᩈᩁᨱᩴ, ᨵᨾ᩠ᨾᨬ᩠ᨧᩣᨸᩥ ᨲᨳᩮᩅ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩴ;

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

‘‘ᨾᩣ ᨧ ᨸᩣᨱᩅᨵᩴ ᩅᩥᩅᩥᨵᩴ ᨧᩁᩔᩩ ᩋᩈᩩᨧᩥᩴ,

ᨶ ᩉᩥ ᨸᩣᨱᩮᩈᩩ ᩋᩈᨬ᩠ᨬᨲᩴ ᩋᩅᨱ᩠ᨱᨿᩥᩴᩈᩩ ᩈᨸ᩠ᨸᨬ᩠ᨬᩣ;

‘‘ᨾᩣ ¶ ᨧ ᨸᩁᨩᨶᩔ ᩁᨠ᩠ᨡᩥᨲᨾ᩠ᨸᩥ, ᩌᨴᩣᨲᨻ᩠ᨻᨾᨾᨬ᩠ᨬᩥᨳᩮᩣ [ᨾᨾᨬ᩠ᨬᩥᨲ᩠ᨳ (ᩈᩦ. ᨸᩦ.)] ᩋᨴᩥᨶ᩠ᨶᩴ;

ᨶᩮᩣᨲᩥ ᨸᨮᨾᩴ ᩋᩅᩮᩣᨧᩉᩴ ᨽᨶ᩠ᨲᩮ, ᨸᨧ᩠ᨨᩣ ᩅᨧᨶᩴ ᨲᨳᩮᩅᨠᩣᩈᩥᩴ.

‘‘ᨾᩣ ᨧ ᨸᩁᨩᨶᩔ ᩁᨠ᩠ᨡᩥᨲᩣᨿᩮᩣ, ᨸᩁᨽᩁᩥᨿᩣ ᩋᨣᨾᩣ ᩋᨶᩁᩥᨿᨾᩮᨲᩴ;

ᨶᩮᩣᨲᩥ ᨸᨮᨾᩴ ᩋᩅᩮᩣᨧᩉᩴ ᨽᨶ᩠ᨲᩮ, ᨸᨧ᩠ᨨᩣ ᨲᩮ ᩅᨧᨶᩴ ᨲᨳᩮᩅᨠᩣᩈᩥᩴ;

ᨶ ¶ ᩉᩥ ᨾᩩᩈᩣᩅᩣᨴᩴ ᩋᩅᨱ᩠ᨱᨿᩥᩴᩈᩩ ᩈᨸ᩠ᨸᨬ᩠ᨬᩣ;

ᨶᩮᩣᨲᩥ ᨸᨮᨾᩴ ᩋᩅᩮᩣᨧᩉᩴ ᨽᨶ᩠ᨲᩮ, ᨸᨧ᩠ᨨᩣ ᨲᩮ ᩅᨧᨶᩴ ᨲᨳᩮᩅᨠᩣᩈᩥᩴ.

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

ᨶᩮᩣᨲᩥ ᨸᨮᨾᩴ ᩋᩅᩮᩣᨧᩉᩴ ᨽᨶ᩠ᨲᩮ, ᨸᨧ᩠ᨨᩣ ᨲᩮ ᩅᨧᨶᩴ ᨲᨳᩮᩅᨠᩣᩈᩥᩴ.

‘‘ᩈ᩠ᩅᩣᩉᩴ ᩍᨵ ᨸᨬ᩠ᨧ ᩈᩥᨠ᩠ᨡᩣ ᨠᩁᩥᨲ᩠ᩅᩣ, ᨸᨭᩥᨸᨩ᩠ᨩᩥᨲ᩠ᩅᩣ ᨲᨳᩣᨣᨲᩔ ᨵᨾ᩠ᨾᩮ;

ᨴ᩠ᩅᩮᨸᨳᨾᨣᨾᩣᩈᩥᩴ ᨧᩮᩣᩁᨾᨩ᩠ᨫᩮ, ᨲᩮ ᨾᩴ ᨲᨲ᩠ᨳ ᩅᨵᩥᩴᩈᩩ ᨽᩮᩣᨣᩉᩮᨲᩩ.

‘‘ᩑᨲ᩠ᨲᨠᨾᩥᨴᩴ ¶ ¶ ᩋᨶᩩᩔᩁᩣᨾᩥ ᨠᩩᩈᩃᩴ, ᨲᨲᩮᩣ ᨸᩁᩴ ᨶ ᨾᩮ ᩅᩥᨩ᩠ᨩᨲᩥ ᩋᨬ᩠ᨬᩴ;

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

‘‘ᨸᩔ ᨡᨱᨾᩩᩉᩩᨲ᩠ᨲᩈᨬ᩠ᨬᨾᩔ, ᩋᨶᩩᨵᨾ᩠ᨾᨸ᩠ᨸᨭᩥᨸᨲ᩠ᨲᩥᨿᩣ ᩅᩥᨸᩣᨠᩴ;

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

‘‘ᨸᩔ ᨠᨲᩥᨸᨿᩣᨿ ᨴᩮᩈᨶᩣᨿ, ᩈᩩᨣᨲᩥᨬ᩠ᨧᨾ᩠ᩉᩥ ¶ ᨣᨲᩮᩣ ᩈᩩᨡᨬ᩠ᨧ ᨸᨲ᩠ᨲᩮᩣ;

ᨿᩮ ᨧ ᨲᩮ ᩈᨲᨲᩴ ᩈᩩᨱᨶ᩠ᨲᩥ ᨵᨾ᩠ᨾᩴ, ᨾᨬ᩠ᨬᩮ ᨲᩮ ᩋᨾᨲᩴ ᨹᩩᩈᨶ᩠ᨲᩥ ᨡᩮᨾᩴ.

‘‘ᩋᨸ᩠ᨸᨾ᩠ᨸᩥ ᨠᨲᩴ ᨾᩉᩣᩅᩥᨸᩣᨠᩴ, ᩅᩥᨸᩩᩃᩴ ᩉᩮᩣᨲᩥ [ᩅᩥᨸᩩᩃᨹᩃᩴ (ᨠ.)] ᨲᨳᩣᨣᨲᩔ ᨵᨾ᩠ᨾᩮ;

ᨸᩔ ᨠᨲᨸᩩᨬ᩠ᨬᨲᩣᨿ ᨨᨲ᩠ᨲᩮᩣ, ᩒᨽᩣᩈᩮᨲᩥ ᨸᨳᩅᩥᩴ ᨿᨳᩣᨸᩥ ᩈᩪᩁᩥᨿᩮᩣ.

‘‘ᨠᩥᨾᩥᨴᩴ ᨠᩩᩈᩃᩴ ᨠᩥᨾᩣᨧᩁᩮᨾ, ᩍᨧ᩠ᨧᩮᨠᩮ ᩉᩥ ᩈᨾᩮᨧ᩠ᨧ ᨾᨶ᩠ᨲᨿᨶ᩠ᨲᩥ;

ᨲᩮ ᨾᨿᩴ ᨸᩩᨶᩁᩮᩅ [ᨸᩩᨶᨸᩥ (?)] ᩃᨴ᩠ᨵ ᨾᩣᨶᩩᩈᨲ᩠ᨲᩴ, ᨸᨭᩥᨸᨶ᩠ᨶᩣ ᩅᩥᩉᩁᩮᨾᩩ ᩈᩦᩃᩅᨶ᩠ᨲᩮᩣ.

‘‘ᨻᩉᩩᨠᩣᩁᩮᩣ ¶ ᩋᨶᩩᨠᨾ᩠ᨸᨠᩮᩣ ᨧ ᩈᨲ᩠ᨳᩣ, ᩍᨲᩥ ᨾᩮ ᩈᨲᩥ ᩋᨣᨾᩣ ᨴᩥᩅᩣ ᨴᩥᩅᩔ;

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

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

ᨶ ᨧ ᨲᩮ ᨸᩩᨶᨾᩩᨸᩮᨶ᩠ᨲᩥ ᨣᨻ᩠ᨽᩈᩮᨿ᩠ᨿᩴ, ᨸᩁᩥᨶᩥᨻ᩠ᨻᩣᨶᨣᨲᩣ ᩉᩥ ᩈᩦᨲᩥᨽᩪᨲᩣ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ [ᩁᩩᨧᩥᩁᨲ᩠ᨳᨲᩣ (ᩈ᩠ᨿᩣ. ᨠ.) ᪖᪔᪖ ᨣᩣᨳᩣᨿᩴ ‘‘ᩁᩩᨧᨠᩩᨸᨠᩥᨱ᩠ᨱᩴ’’ᨲᩥ ᨸᨴᩔ ᩈᩴᩅᨱ᩠ᨱᨶᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᩈᩩᨽᩣ.

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

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᨠᩮᨶ ᨲᩮ ᩍᨵ ᨾᩥᨩ᩠ᨫᨲᩥ;

ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨧ ᨲᩮ ᨽᩮᩣᨣᩣ, ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩴ ᨴᩮᩅ ᨾᩉᩣᨶᩩᨽᩣᩅ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩈᨲᩥᩈᨾᩩᨸ᩠ᨸᩣᨴᨠᩁᩮᩣ ¶ , ᨴ᩠ᩅᩣᩁᩮ ᨠᨠ᩠ᨠᨭᨠᩮᩣ ᨮᩥᨲᩮᩣ;

ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ ᨩᩣᨲᩁᩪᨸᩔ, ᩈᩮᩣᨽᨲᩥ ᨴᩈᨸᩣᨴᨠᩮᩣ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᨲᩮᨶ ᨾᩮ ᩍᨵ ᨾᩥᨩ᩠ᨫᨲᩥ;

ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ¶ ᨧ ᨾᩮ ᨽᩮᩣᨣᩣ, ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

‘‘ᩋᨠ᩠ᨡᩣᨾᩥ ᨲᩮ ᨽᩥᨠ᩠ᨡᩩ ᨾᩉᩣᨶᩩᨽᩣᩅ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨿᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨲᩮᨶᨾ᩠ᩉᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

(ᩋᨶᨶ᩠ᨲᩁᩴ ᨸᨬ᩠ᨧᩅᩥᨾᩣᨶᩴ ᨿᨳᩣ ᨠᨠ᩠ᨠᨭᨠᩁᩈᨴᩣᨿᨠᩅᩥᨾᩣᨶᩴ ᨲᨳᩣ ᩅᩥᨲ᩠ᨳᩣᩁᩮᨲᨻ᩠ᨻᩴ)

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ¶ ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨴᩥᨻ᩠ᨻᩴ ᨾᨾᩴ ᩅᩔᩈᩉᩔᨾᩣᨿᩩ, ᩅᩣᨧᩣᨽᩥᨣᩦᨲᩴ ᨾᨶᩈᩣ ᨸᩅᨲ᩠ᨲᩥᨲᩴ;

ᩑᨲ᩠ᨲᩣᩅᨲᩣ ᨮᩔᨲᩥ ᨸᩩᨬ᩠ᨬᨠᨾ᩠ᨾᩮᩣ, ᨴᩥᨻ᩠ᨻᩮᩉᩥ ᨠᩣᨾᩮᩉᩥ ᩈᨾᨦ᩠ᨣᩥᨽᩪᨲᩮᩣ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ¶ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ…ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨠᩁᨱᩦᨿᩣᨶᩥ ᨸᩩᨬ᩠ᨬᩣᨶᩥ, ᨸᨱ᩠ᨯᩥᨲᩮᨶ ᩅᩥᨩᩣᨶᨲᩣ;

ᩈᨾ᩠ᨾᨣ᩠ᨣᨲᩮᩈᩩ ᨻᩩᨴ᩠ᨵᩮᩈᩩ, ᨿᨲ᩠ᨳ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ.

‘‘ᩋᨲ᩠ᨳᩣᨿ ᩅᨲ ᨾᩮ ᨻᩩᨴ᩠ᨵᩮᩣ, ᩋᩁᨬ᩠ᨬᩣ ᨣᩣᨾᨾᩣᨣᨲᩮᩣ;

ᨲᨲ᩠ᨳ ¶ ᨧᩥᨲ᩠ᨲᩴ ᨸᩈᩣᨴᩮᨲ᩠ᩅᩣ, ᨲᩣᩅᨲᩥᩴᩈᩪᨸᨣᩮᩣ ᩋᩉᩴ [ᩋᩉᩩᩴ (ᩈᩦ.)].

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨠᩁᨱᩦᨿᩣᨶᩥ ᨸᩩᨬ᩠ᨬᩣᨶᩥ, ᨸᨱ᩠ᨯᩥᨲᩮᨶ ᩅᩥᨩᩣᨶᨲᩣ;

ᩈᨾ᩠ᨾᨣ᩠ᨣᨲᩮᩈᩩ ᨽᩥᨠ᩠ᨡᩪᩈᩩ, ᨿᨲ᩠ᨳ ᨴᩥᨶ᩠ᨶᩴ ᨾᩉᨸ᩠ᨹᩃᩴ.

‘‘ᩋᨲ᩠ᨳᩣᨿ ᩅᨲ ᨾᩮ ᨽᩥᨠ᩠ᨡᩩ, ᩋᩁᨬ᩠ᨬᩣ ᨣᩣᨾᨾᩣᨣᨲᩮᩣ;

ᨲᨲ᩠ᨳ ᨧᩥᨲ᩠ᨲᩴ ᨸᩈᩣᨴᩮᨲ᩠ᩅᩣ, ᨲᩣᩅᨲᩥᩴᩈᩪᨸᨣᩮᩣ ᩋᩉᩴ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ¶ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ¶ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ¶ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩮᩣ,ᨸᩩᩁᩥᨾᨩᩣᨲᩥᨿᩣ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ.

‘‘ᩋᨴ᩠ᨴᩈᩴ ¶ ᩅᩥᩁᨩᩴ ᨽᩥᨠ᩠ᨡᩩᩴ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᨾᨶᩣᩅᩥᩃᩴ;

ᨲᩔ ᩋᨴᩣᩈᩉᩴ ᩈᩪᨧᩥᩴ, ᨸᩈᨶ᩠ᨶᩮᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩈᩩᩈᩩᨠ᩠ᨠᨡᨶ᩠ᨵᩴ ¶ ¶ ᩋᨽᩥᩁᩩᨿ᩠ᩉ ᨶᩣᨣᩴ, ᩋᨠᩣᨧᩥᨶᩴ ᨴᨶ᩠ᨲᩥᩴ ᨻᩃᩥᩴ ᨾᩉᩣᨩᩅᩴ;

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

‘‘ᨶᩣᨣᩔ ᨴᨶ᩠ᨲᩮᩈᩩ ᨴᩩᩅᩮᩈᩩ ᨶᩥᨾ᩠ᨾᩥᨲᩣ, ᩋᨧ᩠ᨨᩮᩣᨴᨠᩣ ᨸᨴᩩᨾᩥᨶᩥᨿᩮᩣ ᩈᩩᨹᩩᩃ᩠ᩃᩣ;

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

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᨭ᩠ᨮᩮᩅ ᨾᩩᨲ᩠ᨲᨸᩩᨸ᩠ᨹᩣᨶᩥ, ᨠᩔᨸᩔ ᨾᩉᩮᩈᩥᨶᩮᩣ [ᨽᨣᩅᨲᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)];

ᨳᩪᨸᩈ᩠ᨾᩥᩴ ᩋᨽᩥᩁᩮᩣᨸᩮᩈᩥᩴ, ᨸᩈᨶ᩠ᨶᩮᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨾᩉᨶ᩠ᨲᩴ ¶ ¶ ᨶᩣᨣᩴ ᩋᨽᩥᩁᩩᨿ᩠ᩉ, ᩈᨻ᩠ᨻᩈᩮᨲᩴ ᨣᨩᩩᨲ᩠ᨲᨾᩴ;

ᩅᨶᩣ ᩅᨶᩴ ᩋᨶᩩᨸᩁᩥᨿᩣᩈᩥ, ᨶᩣᩁᩦᨣᨱᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ;

ᩒᨽᩣᩈᩮᨶ᩠ᨲᩮᩣ ᨴᩥᩈᩣ ᩈᨻ᩠ᨻᩣ, ᩒᩈᨵᩦ ᩅᩥᨿ ᨲᩣᩁᨠᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ, ᩅᨦ᩠ᨣᩦᩈᩮᨶᩮᩅ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩮᩣ, ᩏᨸᩣᩈᨠᩮᩣ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ ᩋᩉᩮᩣᩈᩥᩴ;

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

‘‘ᩋᨾᨩ᩠ᨩᨸᩮᩣ ¶ ᨶᩮᩣ ᨧ ᨾᩩᩈᩣ ᩋᨽᩣᨱᩥᩴ [ᩋᨽᩣᩈᩥᩴ (ᩈᩦ. ᨠ.)], ᩈᨠᩮᨶ ᨴᩣᩁᩮᨶ ᨧ ᨲᩩᨭ᩠ᨮᩮᩣ ᩋᩉᩮᩣᩈᩥᩴ;

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᩣᩈᩥᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨠᩮᩣ ¶ ¶ ᨶᩩ ᨴᩥᨻ᩠ᨻᩮᨶ ᨿᩣᨶᩮᨶ, ᩈᨻ᩠ᨻᩈᩮᨲᩮᨶ ᩉᨲ᩠ᨳᩥᨶᩣ;

ᨲᩩᩁᩥᨿᨲᩣᩊᩥᨲᨶᩥᨣ᩠ᨥᩮᩣᩈᩮᩣ, ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ ᨾᩉᩦᨿᨲᩥ.

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

ᩋᨩᩣᨶᨶ᩠ᨲᩣ ᨲᩴ ᨸᩩᨧ᩠ᨨᩣᨾ, ᨠᨳᩴ ᨩᩣᨶᩮᨾᩩ ᨲᩴ ᨾᨿ’’ᨶ᩠ᨲᩥ.

‘‘ᨶᨾ᩠ᩉᩥ ¶ ᨴᩮᩅᩮᩣ ᨶ ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ, ᨶᩣᨸᩥ [ᨶᩣᨾ᩠ᩉᩥ (ᨠ.)] ᩈᨠ᩠ᨠᩮᩣ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ;

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

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

ᨠᩥᩴ ᨠᨲ᩠ᩅᩣ ᨾᩣᨶᩩᩈᩮ ᨠᨾ᩠ᨾᩴ, ᩈᩩᨵᨾ᩠ᨾᩴ ᩏᨸᨸᨩ᩠ᨩᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨨᩣᨣᩣᩁᩴ ᨲᩥᨱᩣᨣᩣᩁᩴ, ᩅᨲ᩠ᨳᩣᨣᩣᩁᨬ᩠ᨧ ᨿᩮᩣ ᨴᨴᩮ;

ᨲᩥᨱ᩠ᨱᩴ ᩋᨬ᩠ᨬᨲᩁᩴ ᨴᨲ᩠ᩅᩣ, ᩈᩩᨵᨾ᩠ᨾᩴ ᩏᨸᨸᨩ᩠ᨩᨲᩦ’’ᨲᩥ.

‘‘ᨴᩊ᩠ᩉᨵᨾ᩠ᨾᩣ ᨶᩥᩈᩣᩁᩔ, ᨵᨶᩩᩴ ᩒᩃᩩᨻ᩠ᨽ ᨲᩥᨭ᩠ᨮᩈᩥ;

ᨡᨲ᩠ᨲᩥᨿᩮᩣ ᨶᩩᩈᩥ ᩁᩣᨩᨬ᩠ᨬᩮᩣ, ᩋᨴᩩ ᩃᩩᨴ᩠ᨴᩮᩣ ᩅᨶᩮᨧᩁᩮᩣ’’ᨲᩥ [ᩅᨶᩣᨧᩁᩮᩣᨲᩥ (ᩈ᩠ᨿᩣ. ᨠ.)].

‘‘ᩋᩔᨠᩣᨵᩥᨸᨲᩥᩔᩣᩉᩴ ¶ , ᨽᨶ᩠ᨲᩮ ᨸᩩᨲ᩠ᨲᩮᩣ ᩅᨶᩮᨧᩁᩮᩣ;

ᨶᩣᨾᩴ ᨾᩮ ᨽᩥᨠ᩠ᨡᩩ ᨲᩮ ᨻᩕᩪᨾᩥ, ᩈᩩᨩᩣᨲᩮᩣ ᩍᨲᩥ ᨾᩴ ᩅᩥᨴᩪ [ᩅᩥᨴᩩᩴ (ᩈᩦ.)].

‘‘ᨾᩥᨣᩮ ᨣᩅᩮᩈᨾᩣᨶᩮᩣᩉᩴ, ᩒᨣᩣᩉᨶ᩠ᨲᩮᩣ ᨻᩕᩉᩣᩅᨶᩴ;

ᨾᩥᨣᩴ ᨲᨬ᩠ᨧᩮᩅ [ᨾᩥᨣᩴ ᨣᨶ᩠ᨲ᩠ᩅᩮᩅ (ᩈ᩠ᨿᩣ.), ᨾᩥᨣᩅᨵᨬ᩠ᨧ (ᨠ.)] ᨶᩣᨴ᩠ᨴᨠ᩠ᨡᩥᩴ, ᨲᨬ᩠ᨧ ᨴᩥᩈ᩠ᩅᩣ ᨮᩥᨲᩮᩣ ᩋᩉ’’ᨶ᩠ᨲᩥ.

‘‘ᩈ᩠ᩅᩣᨣᨲᩴ ¶ ᨲᩮ ᨾᩉᩣᨸᩩᨬ᩠ᨬ, ᩋᨳᩮᩣ ᨲᩮ ᩋᨴᩩᩁᩣᨣᨲᩴ;

ᩑᨲ᩠ᨲᩮᩣ ᩏᨴᨠᨾᩣᨴᩣᨿ, ᨸᩣᨴᩮ ᨸᨠ᩠ᨡᩣᩃᨿᩔᩩ ᨲᩮ.

‘‘ᩍᨴᨾ᩠ᨸᩥ ᨸᩣᨶᩦᨿᩴ ᩈᩦᨲᩴ, ᩌᨽᨲᩴ ᨣᩥᩁᩥᨣᨻ᩠ᨽᩁᩣ;

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

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

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

‘‘ᨠᩣ ¶ ᨲᩮ ᩁᨲᩥ ᩅᨶᩮ ᩅᩥᩉᩁᨲᩮᩣ, ᩍᩈᩥᨶᩥᩈᨽ ᩅᨴᩮᩉᩥ ᨸᩩᨭ᩠ᨮᩮᩣ;

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

‘‘ᩋᩉᩥᩴᩈᩣ ¶ ᩈᨻ᩠ᨻᨸᩣᨱᩦᨶᩴ, ᨠᩩᨾᩣᩁᨾ᩠ᩉᩣᨠ ᩁᩩᨧ᩠ᨧᨲᩥ;

ᨳᩮᨿ᩠ᨿᩣ ᨧ ᩋᨲᩥᨧᩣᩁᩣ ᨧ, ᨾᨩ᩠ᨩᨸᩣᨶᩣ ᨧ ᩌᩁᨲᩥ.

‘‘ᩌᩁᨲᩥ ᩈᨾᨧᩁᩥᨿᩣ ᨧ, ᨻᩣᩉᩩᩈᨧ᩠ᨧᩴ ᨠᨲᨬ᩠ᨬᩩᨲᩣ;

ᨴᩥᨭ᩠ᨮᩮᩅ ᨵᨾ᩠ᨾᩮ ᨸᩣᩈᩴᩈᩣ, ᨵᨾ᩠ᨾᩣ ᩑᨲᩮ ᨸᩈᩴᩈᩥᨿᩣᨲᩥ.

‘‘ᩈᨶ᩠ᨲᩥᨠᩮ ᨾᩁᨱᩴ ᨲᩩᨿ᩠ᩉᩴ, ᩒᩁᩴ ᨾᩣᩈᩮᩉᩥ ᨸᨬ᩠ᨧᩉᩥ;

ᩁᩣᨩᨸᩩᨲ᩠ᨲ ¶ ᩅᩥᨩᩣᨶᩣᩉᩥ, ᩋᨲ᩠ᨲᩣᨶᩴ ᨸᩁᩥᨾᩮᩣᨧᨿᩣ’’ᨲᩥ.

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

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

‘‘ᨶ ᩅᩥᨩ᩠ᨩᨲᩮ ᩈᩮᩣ ᨸᨴᩮᩈᩮᩣ, ᨠᨾ᩠ᨾᩴ ᩅᩥᨩ᩠ᨩᩣ ᨧ ᨸᩮᩣᩁᩥᩈᩴ;

ᨿᨲ᩠ᨳ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᨽᩅᩮ ᨾᨧ᩠ᨧᩮᩣ, ᩁᩣᨩᨸᩩᨲ᩠ᨲᩣᨩᩁᩣᨾᩁᩮᩣ.

‘‘ᨾᩉᨴ᩠ᨵᨶᩣ ᨾᩉᩣᨽᩮᩣᨣᩣ, ᩁᨭ᩠ᨮᩅᨶ᩠ᨲᩮᩣᨸᩥ ᨡᨲ᩠ᨲᩥᨿᩣ;

ᨸᩉᩪᨲᨵᨶᨵᨬ᩠ᨬᩣᩈᩮ, ᨲᩮᨸᩥ ᨶᩮᩣ [ᨲᩮᨸᩥ ᨶ (ᨻᩉᩪᩈᩩ)] ᩋᨩᩁᩣᨾᩁᩣ.

‘‘ᨿᨴᩥ ᨲᩮ ᩈᩩᨲᩣ ᩋᨶ᩠ᨵᨠᩅᩮᨱ᩠ᨯᩩᨸᩩᨲ᩠ᨲᩣ [ᩋᨶ᩠ᨵᨠᩅᩮᨱ᩠ᩉᩩᨸᩩᨲ᩠ᨲᩣ (ᩈᩦ.), ᩋᨱ᩠ᨯᨠᩅᩮᨱ᩠ᨯᨸᩩᨲ᩠ᨲᩣ (ᩈ᩠ᨿᩣ. ᨠ.)], ᩈᩪᩁᩣ ᩅᩦᩁᩣ ᩅᩥᨠ᩠ᨠᨶ᩠ᨲᨸ᩠ᨸᩉᩣᩁᩥᨶᩮᩣ;

ᨲᩮᨸᩥ ᩌᨿᩩᨠ᩠ᨡᨿᩴ ᨸᨲ᩠ᨲᩣ, ᩅᩥᨴ᩠ᨵᩈ᩠ᨲᩣ ᩈᩔᨲᩦᩈᨾᩣ.

‘‘ᨡᨲ᩠ᨲᩥᨿᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩅᩮᩔᩣ, ᩈᩩᨴ᩠ᨴᩣ ᨧᨱ᩠ᨯᩣᩃᨸᩩᨠ᩠ᨠᩩᩈᩣ;

ᩑᨲᩮ ᨧᨬ᩠ᨬᩮ ᨧ ᨩᩣᨲᩥᨿᩣ, ᨲᩮᨸᩥ ᨶᩮᩣ ᩋᨩᩁᩣᨾᩁᩣ.

‘‘ᨿᩮ ᨾᨶ᩠ᨲᩴ ᨸᩁᩥᩅᨲ᩠ᨲᩮᨶ᩠ᨲᩥ, ᨨᩊᨦ᩠ᨣᩴ ᨻᩕᩉ᩠ᨾᨧᩥᨶ᩠ᨲᩥᨲᩴ;

ᩑᨲᩮ ᨧᨬ᩠ᨬᩮ ᨧ ᩅᩥᨩ᩠ᨩᩣᨿ, ᨲᩮᨸᩥ ᨶᩮᩣ ᩋᨩᩁᩣᨾᩁᩣ.

‘‘ᩍᩈᨿᩮᩣ ᨧᩣᨸᩥ ᨿᩮ ᩈᨶ᩠ᨲᩣ, ᩈᨬ᩠ᨬᨲᨲ᩠ᨲᩣ ᨲᨸᩔᩥᨶᩮᩣ;

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

‘‘ᨽᩣᩅᩥᨲᨲ᩠ᨲᩣᨸᩥ ¶ ᩋᩁᩉᨶ᩠ᨲᩮᩣ, ᨠᨲᨠᩥᨧ᩠ᨧᩣ ᩋᨶᩣᩈᩅᩣ;

ᨶᩥᨠ᩠ᨡᩥᨸᨶ᩠ᨲᩥ ᩍᨾᩴ ᨴᩮᩉᩴ, ᨸᩩᨬ᩠ᨬᨸᩣᨸᨸᩁᩥᨠ᩠ᨡᨿᩣ’’ᨲᩥ.

‘‘ᩈᩩᨽᩣᩈᩥᨲᩣ ᩋᨲ᩠ᨳᩅᨲᩦ, ᨣᩣᨳᩣᨿᩮᩣ ᨲᩮ ᨾᩉᩣᨾᩩᨶᩥ;

ᨶᩥᨩ᩠ᨫᨲ᩠ᨲᩮᩣᨾ᩠ᩉᩥ ¶ ᩈᩩᨽᨭ᩠ᨮᩮᨶ, ᨲ᩠ᩅᨬ᩠ᨧ ᨾᩮ ᩈᩁᨱᩴ ᨽᩅᩣ’’ᨲᩥ.

‘‘ᨾᩣ ¶ ᨾᩴ ᨲ᩠ᩅᩴ ᩈᩁᨱᩴ ᨣᨧ᩠ᨨ, ᨲᨾᩮᩅ ᩈᩁᨱᩴ ᩅᨩ [ᨽᨩ (ᨠ.)];

ᩈᨠ᩠ᨿᨸᩩᨲ᩠ᨲᩴ ᨾᩉᩣᩅᩦᩁᩴ, ᨿᨾᩉᩴ ᩈᩁᨱᩴ ᨣᨲᩮᩣ’’ᨲᩥ.

‘‘ᨠᨲᩁᩈ᩠ᨾᩥᩴ ᩈᩮᩣ ᨩᨶᨸᨴᩮ, ᩈᨲ᩠ᨳᩣ ᨲᩩᨾ᩠ᩉᩣᨠ ᨾᩣᩁᩥᩈ;

ᩋᩉᨾ᩠ᨸᩥ ᨴᨭ᩠ᨮᩩᩴ ᨣᨧ᩠ᨨᩥᩔᩴ, ᨩᩥᨶᩴ ᩋᨸ᩠ᨸᨭᩥᨸᩩᨣ᩠ᨣᩃ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᩁᨲ᩠ᨳᩥᨾᩈ᩠ᨾᩥᩴ ¶ ᨩᨶᨸᨴᩮ, ᩒᨠ᩠ᨠᩣᨠᨠᩩᩃᩈᨾ᩠ᨽᩅᩮᩣ;

ᨲᨲ᩠ᨳᩣᩈᩥ ᨸᩩᩁᩥᩈᩣᨩᨬ᩠ᨬᩮᩣ, ᩈᩮᩣ ᨧ ᨡᩮᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ’’ᨲᩥ.

‘‘ᩈᨧᩮ ᩉᩥ ᨻᩩᨴ᩠ᨵᩮᩣ ᨲᩥᨭ᩠ᨮᩮᨿ᩠ᨿ, ᩈᨲ᩠ᨳᩣ ᨲᩩᨾ᩠ᩉᩣᨠ ᨾᩣᩁᩥᩈ;

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

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

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

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

ᩈᨦ᩠ᨥᨬ᩠ᨧ ᨶᩁᨴᩮᩅᩔ, ᨣᨧ᩠ᨨᩣᨾᩥ ᩈᩁᨱᩴ ᩋᩉᩴ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ᩅᩥᩁᨾᩣᨾᩥ ᨡᩥᨸ᩠ᨸᩴ, ᩃᩮᩣᨠᩮ ᩋᨴᩥᨶ᩠ᨶᩴ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩣᨾᩥ;

ᩋᨾᨩ᩠ᨩᨸᩮᩣ ᨶᩮᩣ ᨧ ᨾᩩᩈᩣ ᨽᨱᩣᨾᩥ, ᩈᨠᩮᨶ ᨴᩣᩁᩮᨶ ᨧ ᩉᩮᩣᨾᩥ ᨲᩩᨭ᩠ᨮᩮᩣ’’ᨲᩥ.

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

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

‘‘ᩈᩩᩅᨱ᩠ᨱᨸᨭ᩠ᨭᩮᩉᩥ ᩈᨾᨶ᩠ᨲᨾᩮᩣᨲ᩠ᨳᨭᩮᩣ, ᩏᩁᩔ ᨾᩩᨲ᩠ᨲᩣᩉᩥ ᨾᨱᩦᩉᩥ ᨧᩥᨲ᩠ᨲᩥᨲᩮᩣ;

ᩃᩮᨡᩣ ᩈᩩᩅᨱ᩠ᨱᩔ ᨧ ᩁᩪᨸᩥᨿᩔ ᨧ, ᩈᩮᩣᨽᩮᨶ᩠ᨲᩥ ᩅᩮᩊᩩᩁᩥᨿᨾᨿᩣ ᩈᩩᨶᩥᨾ᩠ᨾᩥᨲᩣ.

‘‘ᩈᩦᩈᨬ᩠ᨧᩥᨴᩴ ¶ ᩅᩮᩊᩩᩁᩥᨿᩔ ᨶᩥᨾ᩠ᨾᩥᨲᩴ, ᨿᩩᨣᨬ᩠ᨧᩥᨴᩴ ᩃᩮᩣᩉᩥᨲᨠᩣᨿ ᨧᩥᨲ᩠ᨲᩥᨲᩴ;

ᨿᩩᨲ᩠ᨲᩣ ᩈᩩᩅᨱ᩠ᨱᩔ ᨧ ᩁᩪᨸᩥᨿᩔ ᨧ, ᩈᩮᩣᨽᨶ᩠ᨲᩥ ᩋᩔᩣ ᨧ ᩍᨾᩮ ᨾᨶᩮᩣᨩᩅᩣ.

‘‘ᩈᩮᩣ ᨲᩥᨭ᩠ᨮᩈᩥ ᩉᩮᨾᩁᨳᩮ ᩋᨵᩥᨭ᩠ᨮᩥᨲᩮᩣ, ᨴᩮᩅᩣᨶᨾᩥᨶ᩠ᨴᩮᩣᩅ ᩈᩉᩔᩅᩣᩉᨶᩮᩣ;

ᨸᩩᨧ᩠ᨨᩣᨾᩥ ᨲᩣᩉᩴ ᨿᩈᩅᨶ᩠ᨲ ᨠᩮᩣᩅᩥᨴᩴ [ᨠᩮᩣᩅᩥᨴ (ᨠ.)], ᨠᨳᩴ ᨲᨿᩣ ᩃᨴ᩠ᨵᩮᩣ ᩋᨿᩴ ᩏᩊᩣᩁᩮᩣ’’ᨲᩥ.

‘‘ᩈᩩᨩᩣᨲᩮᩣ ¶ ᨶᩣᨾᩉᩴ ᨽᨶ᩠ᨲᩮ, ᩁᩣᨩᨸᩩᨲ᩠ᨲᩮᩣ ᨸᩩᩁᩮ ᩋᩉᩩᩴ;

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

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

ᩍᨾᩴ ᩈᩩᨩᩣᨲ ᨸᩪᨩᩮᩉᩥ, ᨲᩴ ᨲᩮ ᩋᨲ᩠ᨳᩣᨿ ᩉᩮᩉᩥᨲᩥ.

‘‘ᨲᩣᩉᩴ ᨣᨶ᩠ᨵᩮᩉᩥ ᨾᩣᩃᩮᩉᩥ, ᨸᩪᨩᨿᩥᨲ᩠ᩅᩣ ᩈᨾᩩᨿ᩠ᨿᩩᨲᩮᩣ;

ᨸᩉᩣᨿ ᨾᩣᨶᩩᩈᩴ ᨴᩮᩉᩴ, ᩏᨸᨸᨶ᩠ᨶᩮᩣᨾ᩠ᩉᩥ ᨶᨶ᩠ᨴᨶᩴ.

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

ᩁᨾᩣᨾᩥ ᨶᨧ᩠ᨧᨣᩦᨲᩮᩉᩥ, ᩋᨧ᩠ᨨᩁᩣᩉᩥ ᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ’’ᨲᩥ.

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

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

‘‘ᩈᩮᩣᩅᨱ᩠ᨱᨾᨿᩣ ᨲᩮ ᩁᨳᨠᩩᨻ᩠ᨻᩁᩣ ᩏᨽᩮᩣ, ᨹᩃᩮᩉᩥ [ᨳᩃᩮᩉᩥ (ᩈᩦ.)] ᩋᩴᩈᩮᩉᩥ ᩋᨲᩦᩅ ᩈᨦ᩠ᨣᨲᩣ;

ᩈᩩᨩᩣᨲᨣᩩᨾ᩠ᨻᩣ ᨶᩁᩅᩦᩁᨶᩥᨭ᩠ᨮᩥᨲᩣ, ᩅᩥᩁᩮᩣᨧᨲᩦ ᨸᨶ᩠ᨶᩁᩈᩮᩅ ᨧᨶ᩠ᨴᩮᩣ.

‘‘ᩈᩩᩅᨱ᩠ᨱᨩᩣᩃᩣᩅᨲᨲᩮᩣ ¶ ᩁᨳᩮᩣ ᩋᨿᩴ, ᨻᩉᩪᩉᩥ ᨶᩣᨶᩣᩁᨲᨶᩮᩉᩥ ᨧᩥᨲ᩠ᨲᩥᨲᩮᩣ;

ᩈᩩᨶᨶ᩠ᨴᩥᨥᩮᩣᩈᩮᩣ ᨧ ᩈᩩᨽᩔᩁᩮᩣ ᨧ, ᩅᩥᩁᩮᩣᨧᨲᩦ ᨧᩣᨾᩁᩉᨲ᩠ᨳᨻᩣᩉᩩᨽᩥ.

‘‘ᩍᨾᩣ ᨧ ᨶᩣᨽ᩠ᨿᩮᩣ ᨾᨶᩈᩣᨽᩥᨶᩥᨾ᩠ᨾᩥᨲᩣ, ᩁᨳᩔ ᨸᩣᨴᨶ᩠ᨲᩁᨾᨩ᩠ᨫᨽᩪᩈᩥᨲᩣ;

ᩍᨾᩣ ᨧ ᨶᩣᨽ᩠ᨿᩮᩣ ᩈᨲᩁᩣᨩᩥᨧᩥᨲ᩠ᨲᩥᨲᩣ, ᩈᨲᩮᩁᨲᩣ ᩅᩥᨩ᩠ᨩᩩᩁᩥᩅᨸ᩠ᨸᨽᩣᩈᩁᩮ.

‘‘ᩋᨶᩮᨠᨧᩥᨲ᩠ᨲᩣᩅᨲᨲᩮᩣ ¶ ᩁᨳᩮᩣ ᩋᨿᩴ, ᨸᩩᨳᩪ ᨧ ᨶᩮᨾᩦ ᨧ ᩈᩉᩔᩁᩴᩈᩥᨠᩮᩣ;

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

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

ᩈᩩᩅᨱ᩠ᨱᩁᩣᨩᩦᩉᩥ ᩋᨲᩦᩅ ᩈᨦ᩠ᨣᨲᩴ, ᩅᩮᩊᩩᩁᩥᨿᩁᩣᨩᩦᩅ ᩋᨲᩦᩅ ᩈᩮᩣᨽᨲᩥ.

‘‘ᩍᨾᩮ ᨧ ᩅᩣᩊᩦ ᨾᨱᩥᨧᨶ᩠ᨴᨠᨸ᩠ᨸᩥᨲᩣ, ᩌᩁᩮᩣᩉᨠᨾ᩠ᨻᩪ ᩈᩩᨩᩅᩣ ᨻᩕᩉᩪᨸᨾᩣ.

ᨻᩕᩉᩣ ᨾᩉᨶ᩠ᨲᩣ ᨻᩃᩥᨶᩮᩣ ᨾᩉᩣᨩᩅᩣ, ᨾᨶᩮᩣ ᨲᩅᨬ᩠ᨬᩣᨿ ᨲᨳᩮᩅ ᩈᩥᩴᩈᩁᩮ [ᩈᨻ᩠ᨻᩁᩮ (ᨠ.), ᩈᨸ᩠ᨸᩁᩮ (?)].

‘‘ᩍᨾᩮ ᨧ ᩈᨻ᩠ᨻᩮ ᩈᩉᩥᨲᩣ ᨧᨲᩩᨠ᩠ᨠᨾᩣ, ᨾᨶᩮᩣ ᨲᩅᨬ᩠ᨬᩣᨿ ᨲᨳᩮᩅ ᩈᩥᩴᩈᩁᩮ;

ᩈᨾᩴ ᩅᩉᨶ᩠ᨲᩣ ᨾᩩᨴᩩᨠᩣ ᩋᨶᩩᨴ᩠ᨵᨲᩣ, ᩌᨾᩮᩣᨴᨾᩣᨶᩣ ᨲᩩᩁᨣᩣᨶ [ᨲᩩᩁᨦ᩠ᨣᩣᨶ (ᨠ.)] ᨾᩩᨲ᩠ᨲᨾᩣ.

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

ᨲᩮᩈᩴ ᩈᩁᩮᩣ ᩈᩩᨿ᩠ᨿᨲᩥ ᩅᨣ᩠ᨣᩩᩁᩪᨸᩮᩣ, ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠᩴ ¶ ᨲᩩᩁᩥᨿᨾᩥᩅᨸ᩠ᨸᩅᩣᨴᩥᨲᩴ.

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

ᨥᩮᩣᩈᩮᩣ ᩈᩩᩅᨣ᩠ᨣᩪ ᩈᨾᩥᨲᩔ ᩈᩩᨿ᩠ᨿᨲᩥ, ᨣᨶ᩠ᨵᨻ᩠ᨻᨲᩪᩁᩥᨿᩣᨶᩥ ᩅᩥᨧᩥᨲᩕᩈᩴᩅᨶᩮ.

‘‘ᩁᨳᩮ ᨮᩥᨲᩣ ᨲᩣ ᨾᩥᨣᨾᨶ᩠ᨴᩃᩮᩣᨧᨶᩣ, ᩌᩊᩣᩁᨸᨾ᩠ᩉᩣ ᩉᩈᩥᨲᩣ ᨸᩥᨿᩴᩅᨴᩣ;

ᩅᩮᩊᩩᩁᩥᨿᨩᩣᩃᩣᩅᨲᨲᩣ ᨲᨶᩩᨧ᩠ᨨᩅᩣ, ᩈᨴᩮᩅ ᨣᨶ᩠ᨵᨻ᩠ᨻᩈᩪᩁᨣ᩠ᨣᨸᩪᨩᩥᨲᩣ.

‘‘ᨲᩣ ᩁᨲ᩠ᨲᩁᨲ᩠ᨲᨾ᩠ᨻᩁᨸᩦᨲᩅᩣᩈᩈᩣ, ᩅᩥᩈᩣᩃᨶᩮᨲ᩠ᨲᩣ ᩋᨽᩥᩁᨲ᩠ᨲᩃᩮᩣᨧᨶᩣ;

ᨠᩩᩃᩮ ᩈᩩᨩᩣᨲᩣ ᩈᩩᨲᨶᩪ ᩈᩩᨧᩥᨾ᩠ᩉᩥᨲᩣ, ᩁᨳᩮ ᨮᩥᨲᩣ ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᩏᨸᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨲᩣ ᨠᨾ᩠ᨻᩩᨠᩮᨿᩪᩁᨵᩁᩣ ᩈᩩᩅᩣᩈᩈᩣ, ᩈᩩᨾᨩ᩠ᨫᩥᨾᩣ ᩐᩁᩩᨳᨶᩪᨸᨸᨶ᩠ᨶᩣ;

ᩅᨭ᩠ᨭᨦ᩠ᨣᩩᩃᩥᨿᩮᩣ ᩈᩩᨾᩩᨡᩣ ᩈᩩᨴᩔᨶᩣ, ᩁᨳᩮ ᨮᩥᨲᩣ ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᩏᨸᨭ᩠ᨮᩥᨲᩣ.

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

ᩋᨶᩩᨻ᩠ᨻᨲᩣ ᨲᩣ ᨲᩅ ᨾᩣᨶᩈᩮ ᩁᨲᩣ, ᩁᨳᩮ ᨮᩥᨲᩣ ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᩏᨸᨭ᩠ᨮᩥᨲᩣ.

‘‘ᩌᩅᩮᩊᩥᨶᩥᨿᩮᩣ ¶ ᨸᨴᩩᨾᩩᨸ᩠ᨸᩃᨧ᩠ᨨᨴᩣ, ᩋᩃᨦ᩠ᨠᨲᩣ ᨧᨶ᩠ᨴᨶᩈᩣᩁᩅᩣᩈᩥᨲᩣ [ᩅᩮᩣᩈᩥᨲᩣ (ᩈ᩠ᨿᩣ.), ᨽᩪᩈᩥᨲᩣ (ᨠ.)];

ᩋᨶᩩᨻ᩠ᨻᨲᩣ ¶ ᨲᩣ ᨲᩅ ᨾᩣᨶᩈᩮ ᩁᨲᩣ, ᩁᨳᩮ ᨮᩥᨲᩣ ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᩏᨸᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨲᩣ ¶ ᨾᩣᩃᩥᨶᩥᨿᩮᩣ ᨸᨴᩩᨾᩩᨸ᩠ᨸᩃᨧ᩠ᨨᨴᩣ, ᩋᩃᨦ᩠ᨠᨲᩣ ᨧᨶ᩠ᨴᨶᩈᩣᩁᩅᩣᩈᩥᨲᩣ;

ᩋᨶᩩᨻ᩠ᨻᨲᩣ ᨲᩣ ᨲᩅ ᨾᩣᨶᩈᩮ ᩁᨲᩣ, ᩁᨳᩮ ᨮᩥᨲᩣ ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᩏᨸᨭ᩠ᨮᩥᨲᩣ.

‘‘ᨠᨱ᩠ᨮᩮᩈᩩ ¶ ᨲᩮ ᨿᩣᨶᩥ ᨸᩥᩊᨶ᩠ᨵᨶᩣᨶᩥ, ᩉᨲ᩠ᨳᩮᩈᩩ ᨸᩣᨴᩮᩈᩩ ᨲᨳᩮᩅ ᩈᩦᩈᩮ;

ᩒᨽᩣᩈᨿᨶ᩠ᨲᩦ ᨴᩈ ᩈᨻ᩠ᨻᩈᩮᩣ ᨴᩥᩈᩣ, ᩋᨻ᩠ᨽᩩᨴ᩠ᨴᨿᩴ ᩈᩣᩁᨴᩥᨠᩮᩣᩅ ᨽᩣᨱᩩᨾᩣ.

‘‘ᩅᩣᨲᩔ ᩅᩮᨣᩮᨶ ᨧ ᩈᨾ᩠ᨸᨠᨾ᩠ᨸᩥᨲᩣ, ᨽᩩᨩᩮᩈᩩ ᨾᩣᩃᩣ ᩋᨸᩥᩊᨶ᩠ᨵᨶᩣᨶᩥ ᨧ;

ᨾᩩᨬ᩠ᨧᨶ᩠ᨲᩥ ᨥᩮᩣᩈᩴ ᩁᩪᨧᩥᩁᩴ ᩈᩩᨧᩥᩴ ᩈᩩᨽᩴ, ᩈᨻ᩠ᨻᩮᩉᩥ ᩅᩥᨬ᩠ᨬᩪᩉᩥ ᩈᩩᨲᨻ᩠ᨻᩁᩪᨸᩴ.

‘‘ᩏᨿ᩠ᨿᩣᨶᨽᩪᨾ᩠ᨿᩣ ᨧ ᨴᩩᩅᨴ᩠ᨵᨲᩮᩣ ᨮᩥᨲᩣ, ᩁᨳᩣ ¶ ᨧ ᨶᩣᨣᩣ ᨲᩪᩁᩥᨿᩣᨶᩥ ᨧ ᩈᩁᩮᩣ;

ᨲᨾᩮᩅ ᨴᩮᩅᩥᨶ᩠ᨴ ᨸᨾᩮᩣᨴᨿᨶ᩠ᨲᩥ, ᩅᩦᨱᩣ ᨿᨳᩣ ᨸᩮᩣᨠ᩠ᨡᩁᨸᨲ᩠ᨲᨻᩣᩉᩩᨽᩥ.

‘‘ᩍᨾᩣᩈᩩ ᩅᩦᨱᩣᩈᩩ ᨻᩉᩪᩈᩩ ᩅᨣ᩠ᨣᩪᩈᩩ, ᨾᨶᩩᨬ᩠ᨬᩁᩪᨸᩣᩈᩩ ᩉᨴᨿᩮᩁᩥᨲᩴ ᨸᩦᨲᩥᩴ [ᩉᨴᨿᩮᩁᩥᨲᩴ ᨸᨲᩥ (ᩈᩦ.), ᩉᨴᨿᩮᩁᩥᨲᨾ᩠ᨸᩥ ᨲᩴ (ᩈ᩠ᨿᩣ.)];

ᨸᩅᨩ᩠ᨩᨾᩣᨶᩣᩈᩩ ᩋᨲᩦᩅ ᩋᨧ᩠ᨨᩁᩣ, ᨽᨾᨶ᩠ᨲᩥ ᨠᨬ᩠ᨬᩣ ᨸᨴᩩᨾᩮᩈᩩ ᩈᩥᨠ᩠ᨡᩥᨲᩣ.

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

ᩋᨳᩮᨲ᩠ᨳ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩋᨳᩮᨲ᩠ᨳ ᩋᨧ᩠ᨨᩁᩣ, ᩒᨽᩣᩈᨿᨶ᩠ᨲᩦ ᩏᨽᨲᩮᩣ ᩅᩁᩥᨲ᩠ᨳᩥᨿᩮᩣ.

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

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

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

ᩏᨸᩮᩣᩈᨳᩴ ᨠᩴ ᩅᩣ [ᩏᨸᩮᩣᩈᨳᩴ ᨠᩥᩴ ᩅ (ᩈ᩠ᨿᩣ.)] ᨲᩩᩅᩴ ᩏᨸᩣᩅᩈᩥ, ᨠᩴ [ᨠᩥᩴ (ᩈ᩠ᨿᩣ.)] ᨵᨾ᩠ᨾᨧᩁᩥᨿᩴ ᩅᨲᨾᩣᨽᩥᩁᩮᩣᨧᨿᩥ.

‘‘ᨶᨿᩦᨴᨾᨸ᩠ᨸᩔ ¶ ᨠᨲᩔ [ᨶᨿᩥᨴᩴ ᩋᨸ᩠ᨸᩔ ᨠᨲᩔ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᩈᩣᩈᩮᨴᩴ ᩋᨸ᩠ᨸᨠᨲᩔ (ᨠ.)] ᨠᨾ᩠ᨾᩩᨶᩮᩣ, ᨸᩩᨻ᩠ᨻᩮ ᩈᩩᨧᩥᨱ᩠ᨱᩔ ᩏᨸᩮᩣᩈᨳᩔ ᩅᩣ;

ᩍᨴ᩠ᨵᩣᨶᩩᨽᩣᩅᩮᩣ ¶ ᩅᩥᨸᩩᩃᩮᩣ ᩋᨿᩴ ᨲᩅ, ᨿᩴ ᨴᩮᩅᩈᨦ᩠ᨥᩴ ᩋᨽᩥᩁᩮᩣᨧᩈᩮ ᨽᩩᩈᩴ.

‘‘ᨴᩣᨶᩔ ᨲᩮ ᩍᨴᩴ ᨹᩃᩴ, ᩋᨳᩮᩣ ᩈᩦᩃᩔ ᩅᩣ ᨸᨶ;

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

ᩈᩮᩣ ¶ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᨶ᩠ᨲᩥ.

‘‘ᨩᩥᨲᩥᨶ᩠ᨴᩕᩥᨿᩴ ᨻᩩᨴ᩠ᨵᨾᨶᩮᩣᨾᨶᩥᨠ᩠ᨠᨾᩴ, ᨶᩁᩩᨲ᩠ᨲᨾᩴ ᨠᩔᨸᨾᨣ᩠ᨣᨸᩩᨣ᩠ᨣᩃᩴ;

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

‘‘ᨲᨾᨴ᩠ᨴᩈᩴ ᨠᩩᨬ᩠ᨩᩁᨾᩮᩣᨥᨲᩥᨱ᩠ᨱᩴ, ᩈᩩᩅᨱ᩠ᨱᩈᩥᨦ᩠ᨣᩦᨶᨴᨻᩥᨾ᩠ᨻᩈᩣᨴᩥᩈᩴ;

ᨴᩥᩈ᩠ᩅᩣᨶ ᨲᩴ ᨡᩥᨸ᩠ᨸᨾᩉᩩᩴ ᩈᩩᨧᩦᨾᨶᩮᩣ, ᨲᨾᩮᩅ ᨴᩥᩈ᩠ᩅᩣᨶ ᩈᩩᨽᩣᩈᩥᨲᨴ᩠ᨵᨩᩴ.

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

ᨸᩩᨸ᩠ᨹᩣᨽᩥᨠ᩠ᨠᩥᨱᨾ᩠ᩉᩥ ᩈᨠᩮ ᨶᩥᩅᩮᩈᨶᩮ, ᨸᨲᩥᨭ᩠ᨮᨸᩮᩈᩥᩴ ᩈ ᩋᩈᨦ᩠ᨣᨾᩣᨶᩈᩮᩣ.

‘‘ᨲᨾᨶ᩠ᨶᨸᩣᨶᩮᨶ ¶ ᨧ ᨧᩦᩅᩁᩮᨶ ᨧ, ᨡᨩ᩠ᨩᩮᨶ ᨽᩮᩣᨩ᩠ᨩᩮᨶ ᨧ ᩈᩣᨿᨶᩮᨶ ᨧ;

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

‘‘ᩑᨲᩮᨶᩩᨸᩣᨿᩮᨶ ᩍᨾᩴ ᨶᩥᩁᨣ᩠ᨣᩊᩴ, ᨿᨬ᩠ᨬᩴ ᨿᨩᩥᨲ᩠ᩅᩣ ᨲᩥᩅᩥᨵᩴ ᩅᩥᩈᩩᨴ᩠ᨵᩴ.

ᨸᩉᩣᨿᩉᩴ ᨾᩣᨶᩩᩈᨠᩴ ᩈᨾᩩᩔᨿᩴ, ᩍᨶ᩠ᨴᩪᨸᨾᩮᩣ [ᩍᨶ᩠ᨴᩔᨾᩮᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨴᩮᩅᨸᩩᩁᩮ ᩁᨾᩣᨾᩉᩴ.

‘‘ᩌᨿᩩᨬ᩠ᨧ ¶ ᩅᨱ᩠ᨱᨬ᩠ᨧ ᩈᩩᨡᩴ ᨻᩃᨬ᩠ᨧ, ᨸᨱᩦᨲᩁᩪᨸᩴ ᩋᨽᩥᨠᨦ᩠ᨡᨲᩣ ᨾᩩᨶᩥ;

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

[ᨠᨳᩣ. ᪗᪙᪙]‘‘ᨶᨿᩥᨾᩈ᩠ᨾᩥᩴ ᩃᩮᩣᨠᩮ ᨸᩁᩈ᩠ᨾᩥᩴ [ᨶᨿᩥᨾᩈ᩠ᨾᩥᩴ ᩅᩣ ᩃᩮᩣᨠᩮ ᨸᩁᩈ᩠ᨾᩥᩴ (ᨠᨳᩣᩅᨲ᩠ᨳᩩ ᪗᪙᪙), ᨶᨿᩥᨾᩈ᩠ᨾᩥ ᩃᩮᩣᨠᩮ ᩅ ᨸᩁᩈ᩠ᨾᩥ (?)] ᩅᩣ ᨸᨶ, ᨻᩩᨴ᩠ᨵᩮᨶ ᩈᩮᨭ᩠ᨮᩮᩣ ᩅ ᩈᨾᩮᩣ ᩅ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᩌᩉᩩᨶᩮᨿ᩠ᨿᩣᨶᩴ [ᨿᨾᩣᩉᩩᨶᩮᨿ᩠ᨿᩣᨶᩴ (ᨠ.)] ᨸᩁᨾᩣᩉᩩᨲᩥᩴ ᨣᨲᩮᩣ, ᨸᩩᨬ᩠ᨬᨲ᩠ᨳᩥᨠᩣᨶᩴ ᩅᩥᨸᩩᩃᨸ᩠ᨹᩃᩮᩈᩥᨶ’’ᨶ᩠ᨲᩥ.

ᨾᩉᩣᩁᨳᩅᨣ᩠ᨣᩮᩣ ᨸᨬ᩠ᨧᨾᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

ᨾᨱ᩠ᨯᩪᨠᩮᩣ ᩁᩮᩅᨲᩦ ᨨᨲ᩠ᨲᩮᩣ, ᨠᨠ᩠ᨠᨭᩮᩣ ᨴ᩠ᩅᩣᩁᨸᩣᩃᨠᩮᩣ;

ᨴ᩠ᩅᩮ ᨠᩁᨱᩦᨿᩣ ᨴ᩠ᩅᩮ ᩈᩪᨧᩥ, ᨲᨿᩮᩣ ᨶᩣᨣᩣ ᨧ ᨴ᩠ᩅᩮ ᩁᨳᩣ;

ᨸᩩᩁᩥᩈᩣᨶᩴ ᨸᨮᨾᩮᩣ ᩅᨣ᩠ᨣᩮᩣ ᨸᩅᩩᨧ᩠ᨧᨲᩦᨲᩥ.

‘‘ᨿᨳᩣ ¶ ¶ ¶ ᩅᨶᩴ ᨧᩥᨲ᩠ᨲᩃᨲᩴ ᨸᨽᩣᩈᨲᩥ [ᨸᨠᩣᩈᨲᩥ (ᨠ.)], ᩏᨿ᩠ᨿᩣᨶᩈᩮᨭ᩠ᨮᩴ ᨲᩥᨴᩈᩣᨶᨾᩩᨲ᩠ᨲᨾᩴ;

ᨲᨳᩪᨸᨾᩴ ᨲᩩᨿ᩠ᩉᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᩒᨽᩣᩈᨿᩴ ᨲᩥᨭ᩠ᨮᨲᩥ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ¶ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᨬ᩠ᨧ ᨽᩁᩥᨿᩣ ᨧ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ, ᩒᨸᩣᨶᨽᩪᨲᩣ ᨥᩁᨾᩣᩅᩈᩥᨾ᩠ᩉ;

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᨾ᩠ᩉ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨿᨳᩣ ¶ ᩅᨶᩴ ᨧᩥᨲ᩠ᨲᩃᨲᩴ ᨸᨽᩣᩈᨲᩥ, ᩏᨿ᩠ᨿᩣᨶᩈᩮᨭ᩠ᨮᩴ ᨲᩥᨴᩈᩣᨶᨾᩩᨲ᩠ᨲᨾᩴ;

ᨲᨳᩪᨸᨾᩴ ¶ ᨲᩩᨿ᩠ᩉᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᩒᨽᩣᩈᨿᩴ ᨲᩥᨭ᩠ᨮᨲᩥ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᨬ᩠ᨧ ᨽᩁᩥᨿᩣ ᨧ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ, ᩒᨸᩣᨶᨽᩪᨲᩣ ᨥᩁᨾᩣᩅᩈᩥᨾ᩠ᩉ;

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᨾ᩠ᩉ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ¶ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᩈᩮᩣᩊᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ¶ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᩋᨭ᩠ᨮᨭ᩠ᨮᨠᩣ ᩈᩥᨠ᩠ᨡᩥᨲᩣ ᩈᩣᨵᩩᩁᩪᨸᩣ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᨠᨬ᩠ᨬᩣ ᨲᩥᨴᩈᨧᩁᩣ ᩏᩊᩣᩁᩣ;

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨹᩃᨴᩣᨿᩦ ᨹᩃᩴ ᩅᩥᨸᩩᩃᩴ ᩃᨽᨲᩥ, ᨴᨴᨾᩩᨩᩩᨣᨲᩮᩈᩩ ᨸᩈᨶ᩠ᨶᨾᩣᨶᩈᩮᩣ;

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

‘‘ᨲᩅᩮᩅᩣᩉᩴ [ᨲᨳᩮᩅᩣᩉᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩉᩣᨾᩩᨶᩥ, ᩋᨴᩣᩈᩥᩴ ᨧᨲᩩᩁᩮᩣ ᨹᩃᩮ.

‘‘ᨲᩈ᩠ᨾᩣ ᩉᩥ ᨹᩃᩴ ᩋᩃᨾᩮᩅ ᨴᩣᨲᩩᩴ, ᨶᩥᨧ᩠ᨧᩴ ᨾᨶᩩᩔᩮᨶ ᩈᩩᨡᨲ᩠ᨳᩥᨠᩮᨶ;

ᨴᩥᨻ᩠ᨻᩣᨶᩥ ᩅᩣ ᨸᨲ᩠ᨳᨿᨲᩣ ᩈᩩᨡᩣᨶᩥ, ᨾᨶᩩᩔᩈᩮᩣᨽᨣ᩠ᨣᨲᨾᩥᨧ᩠ᨨᨲᩣ ᩅᩣ.

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨧᨶ᩠ᨴᩮᩣ ¶ ¶ ᨿᨳᩣ ᩅᩥᨣᨲᩅᩃᩣᩉᨠᩮ ᨶᨽᩮ, ᩒᨽᩣᩈᨿᩴ ᨣᨧ᩠ᨨᨲᩥ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ;

ᨲᨳᩪᨸᨾᩴ ᨲᩩᨿ᩠ᩉᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᩒᨽᩣᩈᨿᩴ ᨲᩥᨭ᩠ᨮᨲᩥ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᨬ᩠ᨧ ᨽᩁᩥᨿᩣ ᨧ ᨾᨶᩩᩔᩃᩮᩣᨠᩮ, ᩏᨸᩔᨿᩴ ᩋᩁᩉᨲᩮᩣ ᩋᨴᨾ᩠ᩉ;

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᨾ᩠ᩉ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩪᩁᩥᨿᩮᩣ ¶ ¶ ᨿᨳᩣ ᩅᩥᨣᨲᩅᩃᩣᩉᨠᩮ ᨶᨽᩮ…ᨸᩮ….

(ᨿᨳᩣ ᨸᩩᩁᩥᨾᩅᩥᨾᩣᨶᩴ ᨲᨳᩣ ᩅᩥᨲ᩠ᨳᩣᩁᩮᨲᨻ᩠ᨻᩴ).

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ¶ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩮᩣ, ᨴᩥᩈ᩠ᩅᩣᨶ ᨽᩥᨠ᩠ᨡᩩᩴ ᨲᩈᩥᨲᩴ ᨠᩥᩃᨶ᩠ᨲᩴ;

ᩑᨠᩣᩉᩴ ᨽᩥᨠ᩠ᨡᩴ ᨸᨭᩥᨸᩣᨴᨿᩥᩔᩴ, ᩈᨾᨦ᩠ᨣᩥ ᨽᨲ᩠ᨲᩮᨶ ᨲᨴᩣ ᩋᨠᩣᩈᩥᩴ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ¶ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩮᩣ, ᩋᩉᩮᩣᩈᩥᩴ ᨿᩅᨸᩣᩃᨠᩮᩣ;

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

‘‘ᨲᩔ ¶ ᩋᨴᩣᩈᩉᩴ ᨽᩣᨣᩴ, ᨸᩈᨶ᩠ᨶᩮᩣ ᩈᩮᩉᩥ ᨸᩣᨱᩥᨽᩥ;

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

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᩃᨦ᩠ᨠᨲᩮᩣ ᨾᩃ᩠ᨿᨵᩁᩮᩣ ᩈᩩᩅᨲ᩠ᨳᩮᩣ, ᩈᩩᨠᩩᨱ᩠ᨯᩃᩦ ᨠᨸ᩠ᨸᩥᨲᨠᩮᩈᨾᩔᩩ;

ᩌᨾᩩᨲ᩠ᨲᩉᨲ᩠ᨳᩣᨽᩁᨱᩮᩣ ᨿᩈᩔᩦ, ᨴᩥᨻ᩠ᨻᩮ ¶ ᩅᩥᨾᩣᨶᨾ᩠ᩉᩥ ᨿᨳᩣᨸᩥ ᨧᨶ᩠ᨴᩥᨾᩣ.

‘‘ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ, ᩋᨭ᩠ᨮᨭ᩠ᨮᨠᩣ ᩈᩥᨠ᩠ᨡᩥᨲᩣ ᩈᩣᨵᩩᩁᩪᨸᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᨧ ᨠᨬ᩠ᨬᩣ ᨲᩥᨴᩈᨧᩁᩣ ᩏᩊᩣᩁᩣ, ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᨣᩣᨿᨶ᩠ᨲᩥ ᨸᨾᩮᩣᨴᨿᨶ᩠ᨲᩥ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩮᩣ, ᨴᩥᩈ᩠ᩅᩣᨶ ᩈᨾᨱᩮ ᩈᩦᩃᩅᨶ᩠ᨲᩮ;

ᩈᨾ᩠ᨸᨶ᩠ᨶᩅᩥᨩ᩠ᨩᩣᨧᩁᨱᩮ ᨿᩈᩔᩦ, ᨻᩉᩩᩔᩩᨲᩮ ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᩪᨸᨸᨶ᩠ᨶᩮ;

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᩣᩈᩥᩴ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩋᩃᨦ᩠ᨠᨲᩮᩣ ¶ ¶ ᨾᩃ᩠ᨿᨵᩁᩮᩣ ᩈᩩᩅᨲ᩠ᨳᩮᩣ, ᩈᩩᨠᩩᨱ᩠ᨯᩃᩦ ᨠᨸ᩠ᨸᩥᨲᨠᩮᩈᨾᩔᩩ;

ᩌᨾᩩᨲ᩠ᨲᩉᨲ᩠ᨳᩣᨽᩁᨱᩮᩣ ᨿᩈᩔᩦ, ᨴᩥᨻ᩠ᨻᩮ ᩅᩥᨾᩣᨶᨾ᩠ᩉᩥ ᨿᨳᩣᨸᩥ ᨧᨶ᩠ᨴᩥᨾᩣ.

‘‘ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ, ᩋᨭ᩠ᨮᨭ᩠ᨮᨠᩣ ᩈᩥᨠ᩠ᨡᩥᨲᩣ ᩈᩣᨵᩩᩁᩪᨸᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᨧ ᨠᨬ᩠ᨬᩣ ᨲᩥᨴᩈᨧᩁᩣ ᩏᩊᩣᩁᩣ, ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᨣᩣᨿᨶ᩠ᨲᩥ ᨸᨾᩮᩣᨴᨿᨶ᩠ᨲᩥ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᩈᨾ᩠ᨸᨶ᩠ᨶᩅᩥᨩ᩠ᨩᩣᨧᩁᨱᩮ ᨿᩈᩔᩦ, ᨻᩉᩩᩔᩩᨲᩮ ᩈᩦᩃᩅᨶ᩠ᨲᩮ ᨸᩈᨶ᩠ᨶᩮ [ᩈᩦᩃᩅᨲᩪᨸᨸᨶ᩠ᨶᩮ (ᨠ. ᩈᩦ. ᨠ.)];

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ¶ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᩣᩈᩥᩴ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨿᩣ ¶ ᨴᩮᩅᩁᩣᨩᩔ ᩈᨽᩣ ᩈᩩᨵᨾ᩠ᨾᩣ, ᨿᨲ᩠ᨳᨧ᩠ᨨᨲᩥ ᨴᩮᩅᩈᨦ᩠ᨥᩮᩣ ᩈᨾᨣ᩠ᨣᩮᩣ;

ᨲᨳᩪᨸᨾᩴ ᨲᩩᨿ᩠ᩉᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᩒᨽᩣᩈᨿᩴ ᨲᩥᨭ᩠ᨮᨲᩥ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩮᩣ, ᩁᨬ᩠ᨬᩮᩣ ᨸᩣᨿᩣᩈᩥᩔ ᩋᩉᩮᩣᩈᩥᩴ ᨾᩣᨱᩅᩮᩣ;

ᩃᨴ᩠ᨵᩣ ᨵᨶᩴ ᩈᩴᩅᩥᨽᩣᨣᩴ ᩋᨠᩣᩈᩥᩴ, ᨸᩥᨿᩣ ᨧ ᨾᩮ ᩈᩦᩃᩅᨶ᩠ᨲᩮᩣ ᩋᩉᩮᩈᩩᩴ;

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ¶ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᩣᩈᩥᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ. ¶ …ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

(ᩏᨲ᩠ᨲᩁ) ᨸᩣᨿᩣᩈᩥᩅᩥᨾᩣᨶᩴ [ᩏᨲ᩠ᨲᩁᩅᩥᨾᩣᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᩋᨭ᩠ᨮ.)] ᨴᩈᨾᩴ.

ᨸᩣᨿᩣᩈᩥᩅᨣ᩠ᨣᩮᩣ ᨨᨭ᩠ᨮᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

ᨴ᩠ᩅᩮ ᩋᨣᩣᩁᩥᨶᩮᩣ ᨹᩃᨴᩣᨿᩦ, ᨴ᩠ᩅᩮ ᩏᨸᩔᨿᨴᩣᨿᩦ ᨽᩥᨠ᩠ᨡᩣᨿ ᨴᩣᨿᩦ;

ᨿᩅᨸᩣᩃᨠᩮᩣ ᨧᩮᩅ ᨴ᩠ᩅᩮ, ᨠᩩᨱ᩠ᨯᩃᩥᨶᩮᩣ ᨸᩣᨿᩣᩈᩦᨲᩥ [ᨸᩣᨮᨽᩮᨴᩮᩣ ᨶᨲ᩠ᨳᩥ];

ᨸᩩᩁᩥᩈᩣᨶᩴ ᨴᩩᨲᩥᨿᩮᩣ ᩅᨣ᩠ᨣᩮᩣ ᨸᩅᩩᨧ᩠ᨧᨲᩦᨲᩥ.

‘‘ᨿᨳᩣ ¶ ¶ ¶ ᩅᨶᩴ ᨧᩥᨲ᩠ᨲᩃᨲᩴ ᨸᨽᩣᩈᨲᩥ, ᩏᨿ᩠ᨿᩣᨶᩈᩮᨭ᩠ᨮᩴ ᨲᩥᨴᩈᩣᨶᨾᩩᨲ᩠ᨲᨾᩴ;

ᨲᨳᩪᨸᨾᩴ ᨲᩩᨿ᩠ᩉᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᩒᨽᩣᩈᨿᩴ ᨲᩥᨭ᩠ᨮᨲᩥ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ¶ ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

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

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᩣᩈᩥ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᨿᨳᩣ ¶ ᩅᨶᩴ ᨶᨶ᩠ᨴᨶᩴ [ᨶᨶ᩠ᨴᨶᩴ ᨧᩥᨲ᩠ᨲᩃᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.), ᨶᨶ᩠ᨴᩅᨶᩴ (ᨠ.)] ᨸᨽᩣᩈᨲᩥ, ᩏᨿ᩠ᨿᩣᨶᩈᩮᨭ᩠ᨮᩴ ᨲᩥᨴᩈᩣᨶᨾᩩᨲ᩠ᨲᨾᩴ;

ᨲᨳᩪᨸᨾᩴ ᨲᩩᨿ᩠ᩉᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ, ᩒᨽᩣᩈᨿᩴ ᨲᩥᨭ᩠ᨮᨲᩥ ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩮ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ¶ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ¶ ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᨩᩥᨱ᩠ᨱᩮ ᨧ ᨾᩣᨲᩣᨸᩥᨲᩁᩮᩣ ᩋᨽᩣᩁᩥᩴ, ᨸᩥᨿᩣ ᨧ ᨾᩮ ᩈᩦᩃᩅᨶ᩠ᨲᩮᩣ ᩋᩉᩮᩈᩩᩴ;

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᩣᩈᩥᩴ.

‘‘ᨲᩮᨶ ¶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ…ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ¶ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ…ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᩌᩁᩣᨾᩁᩩᨠ᩠ᨡᩣᨶᩥ ᨧ ᩁᩮᩣᨸᨿᩥᩔᩴ, ᨸᩥᨿᩣ ᨧ ᨾᩮ ᩈᩦᩃᩅᨶ᩠ᨲᩮᩣ ᩋᩉᩮᩈᩩᩴ;

ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ, ᩈᨠ᩠ᨠᨧ᩠ᨧ ᨴᩣᨶᩴ ᩅᩥᨸᩩᩃᩴ ᩋᨴᩣᩈᩥᩴ.

‘‘ᨲᩮᨶ ᨾᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

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

ᩉᩮᨾᨩᩣᩃᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᩴ [ᩉᩮᨾᨩᩣᩃᨠᨸᨧ᩠ᨨᨶ᩠ᨶᩴ (ᩈᩦ.)], ᨠᩥᨦ᩠ᨠᩥᨱᩥ [ᨠᩥᨦ᩠ᨠᨱᩥᨠ (ᩈ᩠ᨿᩣ. ᨠ.), ᨠᩥᨦ᩠ᨠᩥᨱᩥᨠ (ᨸᩦ.)] ᨩᩣᩃᨠᨸ᩠ᨸᩥᨲᩴ.

‘‘ᩋᨭ᩠ᨮᩴᩈᩣ ᩈᩩᨠᨲᩣ ᨳᨾ᩠ᨽᩣ, ᩈᨻ᩠ᨻᩮ ᩅᩮᩊᩩᩁᩥᨿᩣᨾᨿᩣ;

ᩑᨠᨾᩮᨠᩣᨿ ᩋᩴᩈᩥᨿᩣ, ᩁᨲᨶᩣ ᩈᨲ᩠ᨲ ᨶᩥᨾ᩠ᨾᩥᨲᩣ.

‘‘ᩅᩮᩊᩩᩁᩥᨿᩈᩩᩅᨱ᩠ᨱᩔ, ᨹᩃᩥᨠᩣ ᩁᩪᨸᩥᨿᩔ ᨧ;

ᨾᩈᩣᩁᨣᩃ᩠ᩃᨾᩩᨲ᩠ᨲᩣᩉᩥ, ᩃᩮᩣᩉᩥᨲᨦ᩠ᨣᨾᨱᩦᩉᩥ ᨧ.

‘‘ᨧᩥᨲᩕᩣ ᨾᨶᩮᩣᩁᨾᩣ ᨽᩪᨾᩥ, ᨶ ᨲᨲ᩠ᨳᩩᨴ᩠ᨵᩴᩈᨲᩦ ᩁᨩᩮᩣ;

ᨣᩮᩣᨸᩣᨱᩈᩦᨣᨱᩣ ᨸᩦᨲᩣ, ᨠᩪᨭᩴ ᨵᩣᩁᩮᨶ᩠ᨲᩥ ᨶᩥᨾ᩠ᨾᩥᨲᩣ.

‘‘ᩈᩮᩣᨸᩣᨱᩣᨶᩥ ¶ ᨧ ᨧᨲ᩠ᨲᩣᩁᩥ, ᨶᩥᨾ᩠ᨾᩥᨲᩣ ᨧᨲᩩᩁᩮᩣ ᨴᩥᩈᩣ;

ᨶᩣᨶᩣᩁᨲᨶᨣᨻ᩠ᨽᩮᩉᩥ ¶ , ᩌᨴᩥᨧ᩠ᨧᩮᩣᩅ ᩅᩥᩁᩮᩣᨧᨲᩥ.

‘‘ᩅᩮᨴᩥᨿᩣ ᨧᨲᩔᩮᩣ ᨲᨲ᩠ᨳ, ᩅᩥᨽᨲ᩠ᨲᩣ ᨽᩣᨣᩈᩮᩣ ᨾᩥᨲᩣ;

ᨴᨴ᩠ᨴᩃ᩠ᩃᨾᩣᨶᩣ ᩌᨽᨶ᩠ᨲᩥ, ᩈᨾᨶ᩠ᨲᩣ ᨧᨲᩩᩁᩮᩣ ᨴᩥᩈᩣ.

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

ᩋᨲᩥᩁᩮᩣᨧᩈᩥ ᩅᨱ᩠ᨱᩮᨶ, ᩏᨴᨿᨶ᩠ᨲᩮᩣᩅ ᨽᩣᨱᩩᨾᩣ.

‘‘ᨴᩣᨶᩔ ¶ ᨲᩮ ᩍᨴᩴ ᨹᩃᩴ, ᩋᨳᩮᩣ ᩈᩦᩃᩔ ᩅᩣ ᨸᨶ;

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

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᩋᨶ᩠ᨵᨠᩅᩥᨶ᩠ᨴᩈ᩠ᨾᩥᩴ, ᨻᩩᨴ᩠ᨵᩔᩣᨴᩥᨧ᩠ᨧᨻᨶ᩠ᨵᩩᨶᩮᩣ;

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

‘‘ᨲᨲ᩠ᨳ ᨣᨶ᩠ᨵᨬ᩠ᨧ ᨾᩣᩃᨬ᩠ᨧ, ᨸᨧ᩠ᨧᨿᨬ᩠ᨧ [ᨸᨧ᩠ᨧᨣ᩠ᨣᨬ᩠ᨧ (ᩈᩦ.), ᨸᨧ᩠ᨧᨣ᩠ᨥᨬ᩠ᨧ (?)] ᩅᩥᩃᩮᨸᨶᩴ;

ᩅᩥᩉᩣᩁᩴ ᩈᨲ᩠ᨳᩩ ᩋᨴᩣᩈᩥᩴ, ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩮᨶ ᨧᩮᨲᩈᩣ;

ᨲᩮᨶ ᨾᨿ᩠ᩉᩴ ᩍᨴᩴ ᩃᨴ᩠ᨵᩴ, ᩅᩈᩴ ᩅᨲ᩠ᨲᩮᨾᩥ ᨶᨶ᩠ᨴᨶᩮ.

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

ᩁᨾᩣᨾᩥ ᨶᨧ᩠ᨧᨣᩦᨲᩮᩉᩥ, ᩋᨧ᩠ᨨᩁᩣᩉᩥ ᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ’’ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ¶ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ…ᨸᩮ… ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᨸᩁᩮᩈᩴ ᨽᨲᨠᩮᩣ ᨸᩮᩣᩈᩮᩣ, ᩋᨾ᩠ᨻᩣᩁᩣᨾᨾᩈᩥᨬ᩠ᨧᨲᩥ.

‘‘ᩋᨳ ¶ ᨲᩮᨶᩣᨣᨾᩣ ᨽᩥᨠ᩠ᨡᩩ, ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᩣᨲᩥ ᩅᩥᩔᩩᨲᩮᩣ;

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

‘‘ᨲᨬ᩠ᨧ ¶ ᨴᩥᩈ᩠ᩅᩣᨶ ᩌᨿᨶ᩠ᨲᩴ, ᩋᩅᩮᩣᨧᩴ ᩋᨾ᩠ᨻᩈᩥᨬ᩠ᨧᨠᩮᩣ;

ᩈᩣᨵᩩ ᨲᩴ [ᩈᩣᨵᩩᨠᩴ (ᨠ.)] ᨽᨶ᩠ᨲᩮ ᨶ᩠ᩉᩣᨸᩮᨿ᩠ᨿᩴ, ᨿᩴ ᨾᨾᩔ ᩈᩩᨡᩣᩅᩉᩴ.

‘‘ᨲᩔ ᨾᩮ ᩋᨶᩩᨠᨾ᩠ᨸᩣᨿ, ᨶᩥᨠ᩠ᨡᩥᨸᩥ ᨸᨲ᩠ᨲᨧᩦᩅᩁᩴ;

ᨶᩥᩈᩦᨴᩥ ᩁᩩᨠ᩠ᨡᨾᩪᩃᩈ᩠ᨾᩥᩴ, ᨨᩣᨿᩣᨿ ᩑᨠᨧᩦᩅᩁᩮᩣ.

‘‘ᨲᨬ᩠ᨧ ᩋᨧ᩠ᨨᩮᨶ ᩅᩣᩁᩥᨶᩣ, ᨸᩈᨶ᩠ᨶᨾᩣᨶᩈᩮᩣ ᨶᩁᩮᩣ;

ᨶ᩠ᩉᩣᨸᨿᩦ ᩁᩩᨠ᩠ᨡᨾᩪᩃᩈ᩠ᨾᩥᩴ, ᨨᩣᨿᩣᨿ ᩑᨠᨧᩦᩅᩁᩴ.

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

ᩍᨲᩥ ᩈᩮᩣ ᨸᩦᨲᩥᨿᩣ ᨠᩣᨿᩴ, ᩈᨻ᩠ᨻᩴ ᨹᩁᨲᩥ ᩋᨲ᩠ᨲᨶᩮᩣ.

‘‘ᨲᨴᩮᩅ ᩑᨲ᩠ᨲᨠᩴ ᨠᨾ᩠ᨾᩴ, ᩋᨠᩣᩈᩥᩴ ᨲᩣᨿ ᨩᩣᨲᩥᨿᩣ;

ᨸᩉᩣᨿ ᨾᩣᨶᩩᩈᩴ ᨴᩮᩉᩴ, ᩏᨸᨸᨶ᩠ᨶᩮᩣᨾ᩠ᩉᩥ ᨶᨶ᩠ᨴᨶᩴ.

‘‘ᨶᨶ᩠ᨴᨶᩮ ᨧ ᩅᨶᩮ ᩁᨾ᩠ᨾᩮ, ᨶᩣᨶᩣᨴᩥᨩᨣᨱᩣᨿᩩᨲᩮ;

ᩁᨾᩣᨾᩥ ᨶᨧ᩠ᨧᨣᩦᨲᩮᩉᩥ, ᩋᨧ᩠ᨨᩁᩣᩉᩥ ᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ’’ᨲᩥ.

‘‘ᨴᩥᩈ᩠ᩅᩣᨶ ᨴᩮᩅᩴ ᨸᨭᩥᨸᩩᨧ᩠ᨨᩥ ᨽᩥᨠ᩠ᨡᩩ, ᩏᨧ᩠ᨧᩮ ᩅᩥᨾᩣᨶᨾ᩠ᩉᩥ ᨧᩥᩁᨭ᩠ᨮᩥᨲᩥᨠᩮ;

ᩌᨾᩩᨲ᩠ᨲᩉᨲ᩠ᨳᩣᨽᩁᨱᩴ ᨿᩈᩔᩥᩴ [ᩌᨾᩩᨲ᩠ᨲᩉᨲ᩠ᨳᩣᨽᩁᨱᩮᩣ ᨿᩈᩔᩦ (ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)], ᨴᩥᨻ᩠ᨻᩮ ᩅᩥᨾᩣᨶᨾ᩠ᩉᩥ ᨿᨳᩣᨸᩥ ᨧᨶ᩠ᨴᩥᨾᩣ.

‘‘ᩋᩃᨦ᩠ᨠᨲᩮᩣ ¶ ¶ ᨾᩃ᩠ᨿᨵᩁᩮᩣ [ᨾᩣᩃᨽᩣᩁᩦ (ᩈᩦ.), ᨾᩣᩃᨵᩁᩦ (ᨠ.)] ᩈᩩᩅᨲ᩠ᨳᩮᩣ, ᩈᩩᨠᩩᨱ᩠ᨯᩃᩦ ᨠᨸ᩠ᨸᩥᨲᨠᩮᩈᨾᩔᩩ;

ᩌᨾᩩᨲ᩠ᨲᩉᨲ᩠ᨳᩣᨽᩁᨱᩮᩣ ᨿᩈᩔᩦ, ᨴᩥᨻ᩠ᨻᩮ ᩅᩥᨾᩣᨶᨾ᩠ᩉᩥ ᨿᨳᩣᨸᩥ ᨧᨶ᩠ᨴᩥᨾᩣ.

‘‘ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ, ᩋᨭ᩠ᨮᨭ᩠ᨮᨠᩣ ᩈᩥᨠ᩠ᨡᩥᨲᩣ ᩈᩣᨵᩩᩁᩪᨸᩣ;

ᨴᩥᨻ᩠ᨻᩣ ᨧ ᨠᨬ᩠ᨬᩣ ᨲᩥᨴᩈᨧᩁᩣ ᩏᩊᩣᩁᩣ, ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᨣᩣᨿᨶ᩠ᨲᩥ ᨸᨾᩮᩣᨴᨿᨶ᩠ᨲᩥ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ¶ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨾᨶᩩᩔᩮᩈᩩ ᨾᨶᩩᩔᨽᩪᨲᩮᩣ, ᩈᨦ᩠ᨣᨾ᩠ᨾ ᩁᨠ᩠ᨡᩥᩔᩴ ᨸᩁᩮᩈᩴ ᨵᩮᨶᩩᨿᩮᩣ;

ᨲᨲᩮᩣ ᨧ ᩌᨣᩣ ᩈᨾᨱᩮᩣ ᨾᨾᨶ᩠ᨲᩥᨠᩮ ᨣᩣᩅᩮᩣ ᨧ ᨾᩣᩈᩮ ᩋᨣᨾᩴᩈᩩ ᨡᩣᨴᩥᨲᩩᩴ.

‘‘ᨴ᩠ᩅᨿᨩ᩠ᨩ ¶ ᨠᩥᨧ᩠ᨧᩴ ᩏᨽᨿᨬ᩠ᨧ ᨠᩣᩁᩥᨿᩴ, ᩍᨧ᩠ᨧᩮᩅᩉᩴ [ᩍᨧ᩠ᨧᩮᩅᩴ (ᨠ.)] ᨽᨶ᩠ᨲᩮ ᨲᨴᩣ ᩅᩥᨧᩥᨶ᩠ᨲᨿᩥᩴ;

ᨲᨲᩮᩣ ᨧ ᩈᨬ᩠ᨬᩴ ᨸᨭᩥᩃᨴ᩠ᨵᨿᩮᩣᨶᩥᩈᩮᩣ, ᨴᨴᩣᨾᩥ ᨽᨶ᩠ᨲᩮᨲᩥ ᨡᩥᨸᩥᩴ ᩋᨶᨶ᩠ᨲᨠᩴ.

‘‘ᩈᩮᩣ ᨾᩣᩈᨡᩮᨲ᩠ᨲᩴ ᨲᩩᩁᩥᨲᩮᩣ ᩋᩅᩣᩈᩁᩥᩴ, ᨸᩩᩁᩣ ᩋᨿᩴ ᨽᨬ᩠ᨩᨲᩥ ᨿᩔᩥᨴᩴ ᨵᨶᩴ;

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

‘‘ᩈ᩠ᩅᩣᩉᩴ ¶ ᩋᨭ᩠ᨭᩮᩣᨾ᩠ᩉᩥ ᨴᩩᨠ᩠ᨡᩮᨶ ᨸᩦᩊᩥᨲᩮᩣ, ᨽᩥᨠ᩠ᨡᩩ ᨧ ᨲᩴ ᩈᩣᨾᩴ ᨾᩩᨬ᩠ᨧᩥᨲ᩠ᩅᩣᨶᨶ᩠ᨲᨠᩴ [ᨾᩩᨬ᩠ᨧᩥᨲ᩠ᩅ ᨶᨶ᩠ᨲᨠᩴ (ᩈᩦ.), ᨾᩩᨬ᩠ᨧᩥᨲ᩠ᩅᩣ ᩋᨶᨶ᩠ᨲᨠᩴ (ᩈ᩠ᨿᩣ.)];

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

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

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

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

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

‘‘ᩍᨾᩈ᩠ᨾᩥᩴ ¶ ᩃᩮᩣᨠᩮ ᨸᩁᩈ᩠ᨾᩥᩴ ᩅᩣ ᨸᨶ, ᩋᨬ᩠ᨬᩮᩣ ᨾᩩᨶᩦ ᨶᨲ᩠ᨳᩥ ᨲᨿᩣᨶᩩᨠᨾ᩠ᨸᨠᩮᩣ;

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

‘‘ᨸᩩᨱ᩠ᨱᨾᩣᩈᩮ ᨿᨳᩣ ᨧᨶ᩠ᨴᩮᩣ, ᨶᨠ᩠ᨡᨲ᩠ᨲᨸᩁᩥᩅᩣᩁᩥᨲᩮᩣ;

ᩈᨾᨶ᩠ᨲᩣ ᩋᨶᩩᨸᩁᩥᨿᩣᨲᩥ, ᨲᩣᩁᨠᩣᨵᩥᨸᨲᩦ ᩈᩈᩦ.

‘‘ᨲᨳᩪᨸᨾᩴ ᩍᨴᩴ ᨻ᩠ᨿᨾ᩠ᩉᩴ, ᨴᩥᨻ᩠ᨻᩴ ᨴᩮᩅᨸᩩᩁᨾ᩠ᩉᩥ ᨧ;

ᩋᨲᩥᩁᩮᩣᨧᨲᩥ ᩅᨱ᩠ᨱᩮᨶ, ᩏᨴᨿᨶ᩠ᨲᩮᩣᩅ ᩁᩴᩈᩥᨾᩣ.

‘‘ᩅᩮᩊᩩᩁᩥᨿᩈᩩᩅᨱ᩠ᨱᩔ, ᨹᩃᩥᨠᩣ ᩁᩪᨸᩥᨿᩔ ᨧ;

ᨾᩈᩣᩁᨣᩃ᩠ᩃᨾᩩᨲ᩠ᨲᩣᩉᩥ, ᩃᩮᩣᩉᩥᨲᨦ᩠ᨣᨾᨱᩦᩉᩥ ᨧ.

‘‘ᨧᩥᨲᩕᩣ ᨾᨶᩮᩣᩁᨾᩣ ᨽᩪᨾᩥ, ᩅᩮᩊᩪᩁᩥᨿᩔ ᩈᨶ᩠ᨳᨲᩣ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ¶ ᩈᩩᨽᩣ ᩁᨾ᩠ᨾᩣ, ᨸᩣᩈᩣᨴᩮᩣ ᨲᩮ ᩈᩩᨾᩣᨸᩥᨲᩮᩣ.

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

ᩋᨧ᩠ᨨᩮᩣᨴᨠᩣ ᩅᩥᨸ᩠ᨸᩈᨶ᩠ᨶᩣ, ᩈᩮᩣᩅᨱ᩠ᨱᩅᩣᩃᩩᨠᩈᨶ᩠ᨳᨲᩣ.

‘‘ᨶᩣᨶᩣᨸᨴᩩᨾᩈᨬ᩠ᨨᨶ᩠ᨶᩣ, ᨸᩩᨱ᩠ᨯᩁᩦᨠᩈᨾᩮᩣᨲᨲᩣ [ᩈᨾᩮᩣᨲ᩠ᨳᨲᩣ (ᨠ.), ᩈᨾᩮᩣᨣᨲᩣ (ᩈ᩠ᨿᩣ.)];

ᩈᩩᩁᨽᩥᩴ ᩈᨾ᩠ᨸᩅᩣᨿᨶ᩠ᨲᩥ, ᨾᨶᩩᨬ᩠ᨬᩣ ᨾᩣᩃᩩᨲᩮᩁᩥᨲᩣ.

‘‘ᨲᩔᩣ ¶ ᨲᩮ ᩏᨽᨲᩮᩣ ᨸᩔᩮ, ᩅᨶᨣᩩᨾ᩠ᨻᩣ ᩈᩩᨾᩣᨸᩥᨲᩣ;

ᩏᨸᩮᨲᩣ ᨸᩩᨸ᩠ᨹᩁᩩᨠ᩠ᨡᩮᩉᩥ, ᨹᩃᩁᩩᨠ᩠ᨡᩮᩉᩥ ᨧᩪᨽᨿᩴ.

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

ᨶᩥᩈᩥᨶ᩠ᨶᩴ ᨴᩮᩅᩁᩣᨩᩴᩅ, ᩏᨸᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᩋᨧ᩠ᨨᩁᩣ.

‘‘ᩈᨻ᩠ᨻᩣᨽᩁᨱᩈᨬ᩠ᨨᨶ᩠ᨶᩣ, ᨶᩣᨶᩣᨾᩣᩃᩣᩅᩥᨽᩪᩈᩥᨲᩣ;

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

‘‘ᨽᩮᩁᩥᩈᨦ᩠ᨡᨾᩩᨴᩥᨦ᩠ᨣᩣᩉᩥ, ᩅᩦᨱᩣᩉᩥ ᨸᨱᩅᩮᩉᩥ ᨧ;

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

‘‘ᨴᩥᨻ᩠ᨻᩣ ᨲᩮ ᩅᩥᩅᩥᨵᩣ ᩁᩪᨸᩣ, ᨴᩥᨻ᩠ᨻᩣ ᩈᨴ᩠ᨴᩣ ᩋᨳᩮᩣ ᩁᩈᩣ;

ᨣᨶ᩠ᨵᩣ ᨧ ᨲᩮ ᩋᨵᩥᨸ᩠ᨸᩮᨲᩣ, ᨹᩮᩣᨭ᩠ᨮᨻ᩠ᨻᩣ ᨧ ᨾᨶᩮᩣᩁᨾᩣ.

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

ᩋᨲᩥᩁᩮᩣᨧᩈᩥ ᩅᨱ᩠ᨱᩮᨶ, ᩏᨴᨿᨶ᩠ᨲᩮᩣᩅ ᨽᩣᨱᩩᨾᩣ.

‘‘ᨴᩣᨶᩔ ᨲᩮ ᩍᨴᩴ ᨹᩃᩴ, ᩋᨳᩮᩣ ᩈᩦᩃᩔ ᩅᩣ ᨸᨶ;

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

ᩈᩮᩣ ¶ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

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

ᩈᩩᨴ᩠ᨵᩮᩣᨴᨶᩔ ᨸᩩᨲ᩠ᨲᩔ, ᨠᨱ᩠ᨯᨠᩮᩣ ᩈᩉᨩᩮᩣ ᩋᩉᩴ.

‘‘ᨿᨴᩣ ᩈᩮᩣ ᩋᨯ᩠ᨰᩁᨲ᩠ᨲᩣᨿᩴ, ᨻᩮᩣᨵᩣᨿ ᨾᨽᩥᨶᩥᨠ᩠ᨡᨾᩥ;

ᩈᩮᩣ ᨾᩴ ᨾᩩᨴᩪᩉᩥ ᨸᩣᨱᩦᩉᩥ, ᨩᩣᩃᩥ [ᨩᩣᩃ (ᩈᩦ.)] ᨲᨾ᩠ᨻᨶᨡᩮᩉᩥ ᨧ.

‘‘ᩈᨲ᩠ᨳᩥᩴ ᩌᨠᩮᩣᨭᨿᩥᨲ᩠ᩅᩣᨶ, ᩅᩉ ᩈᨾ᩠ᨾᩣᨲᩥ ᨧᨻᩕᩅᩥ;

ᩋᩉᩴ ᩃᩮᩣᨠᩴ ᨲᩣᩁᨿᩥᩔᩴ, ᨸᨲ᩠ᨲᩮᩣ ᩈᨾ᩠ᨻᩮᩣᨵᩥᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨲᩴ ¶ ᨾᩮ ᨣᩥᩁᩴ ᩈᩩᨱᨶ᩠ᨲᩔ, ᩉᩣᩈᩮᩣ ᨾᩮ ᩅᩥᨸᩩᩃᩮᩣ ᩋᩉᩩ;

ᩏᨴᨣ᩠ᨣᨧᩥᨲ᩠ᨲᩮᩣ ᩈᩩᨾᨶᩮᩣ, ᩋᨽᩥᩈᩦᩈᩥᩴ [ᩋᨽᩥᩈᩥᩴᩈᩥᩴ (ᩈᩦ.), ᩋᨽᩥᩈᩦᩈᩥ (ᨸᩦ.)] ᨲᨴᩣ ᩋᩉᩴ.

‘‘ᩋᨽᩥᩁᩪᩊ᩠ᩉᨬ᩠ᨧ ᨾᩴ ᨬᨲ᩠ᩅᩣ, ᩈᨠ᩠ᨿᨸᩩᨲ᩠ᨲᩴ ᨾᩉᩣᨿᩈᩴ;

ᩏᨴᨣ᩠ᨣᨧᩥᨲ᩠ᨲᩮᩣ ᨾᩩᨴᩥᨲᩮᩣ, ᩅᩉᩥᩔᩴ ᨸᩩᩁᩥᩈᩩᨲ᩠ᨲᨾᩴ.

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

ᨾᨾᩴ ᨨᨶ᩠ᨶᨬ᩠ᨧ ᩒᩉᩣᨿ, ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣ ᩈᩮᩣ ᩋᨸᨠ᩠ᨠᨾᩥ.

‘‘ᨲᩔ ¶ ᨲᨾ᩠ᨻᨶᨡᩮ ᨸᩣᨴᩮ, ᨩᩥᩅ᩠ᩉᩣᨿ ᨸᩁᩥᩃᩮᩉᩥᩈᩴ;

ᨣᨧ᩠ᨨᨶ᩠ᨲᨬ᩠ᨧ ᨾᩉᩣᩅᩦᩁᩴ, ᩁᩩᨴᨾᩣᨶᩮᩣ ᩏᨴᩥᨠ᩠ᨡᩥᩈᩴ.

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

ᩋᩃᨲ᩠ᨳᩴ ᨣᩁᩩᨠᩣᨻᩣᨵᩴ, ᨡᩥᨸ᩠ᨸᩴ ᨾᩮ ᨾᩁᨱᩴ ᩋᩉᩩ.

‘‘ᨲᩔᩮᩅ ᩌᨶᩩᨽᩣᩅᩮᨶ, ᩅᩥᨾᩣᨶᩴ ᩌᩅᩈᩣᨾᩥᨴᩴ;

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

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

ᨲᩮᨶᩮᩅ ᨠᩩᩈᩃᨾᩪᩃᩮᨶ, ᨹᩩᩈᩥᩔᩴ ᩌᩈᩅᨠ᩠ᨡᨿᩴ.

‘‘ᩈᨧᩮ ᩉᩥ ᨽᨶ᩠ᨲᩮ ᨣᨧ᩠ᨨᩮᨿ᩠ᨿᩣᩈᩥ, ᩈᨲ᩠ᨳᩩ ᨻᩩᨴ᩠ᨵᩔ ᩈᨶ᩠ᨲᩥᨠᩮ;

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

‘‘ᩋᩉᨾ᩠ᨸᩥ ᨴᨭ᩠ᨮᩩᩴ ᨣᨧ᩠ᨨᩥᩔᩴ, ᨩᩥᨶᩴ ᩋᨸ᩠ᨸᨭᩥᨸᩩᨣ᩠ᨣᩃᩴ;

ᨴᩩᩃ᩠ᩃᨽᩴ ᨴᩔᨶᩴ ᩉᩮᩣᨲᩥ, ᩃᩮᩣᨠᨶᩣᨳᩣᨶ ᨲᩣᨴᩥᨶ’’ᨶ᩠ᨲᩥ.

ᩈᩮᩣ ᨠᨲᨬ᩠ᨬᩪ ᨠᨲᩅᩮᨴᩦ, ᩈᨲ᩠ᨳᩣᩁᩴ ᩏᨸᩈᨦ᩠ᨠᨾᩥ;

ᩈᩩᨲ᩠ᩅᩣ ᨣᩥᩁᩴ ᨧᨠ᩠ᨡᩩᨾᨲᩮᩣ, ᨵᨾ᩠ᨾᨧᨠ᩠ᨡᩩᩴ ᩅᩥᩈᩮᩣᨵᨿᩥ.

ᩅᩥᩈᩮᩣᨵᩮᨲ᩠ᩅᩣ ᨴᩥᨭ᩠ᨮᩥᨣᨲᩴ, ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᩴ ᩅᨲᩣᨶᩥ ᨧ;

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

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

ᨸᩁᩥᩅᩣᩁᩥᨲᩮᩣ ᩋᨧ᩠ᨨᩁᩣᩈᨦ᩠ᨣᨱᩮᨶ, ᩈᩩᨶᩥᨾ᩠ᨾᩥᨲᩮᩣ ᨽᩪᨲᨸᨲᩦᩅ ᨾᩮᩣᨴᩈᩥ.

‘‘ᩈᨾᩔᨾᩮᩣ ᨶᨲ᩠ᨳᩥ ᨠᩩᨲᩮᩣ ᨸᨶᩩᨲ᩠ᨲᩁᩮᩣ [ᩏᨲ᩠ᨲᩁᩥ (ᨠ.)], ᨿᩈᩮᨶ ᨸᩩᨬ᩠ᨬᩮᨶ ᨧ ᩍᨴ᩠ᨵᩥᨿᩣ ᨧ;

ᩈᨻ᩠ᨻᩮ ᨧ ᨴᩮᩅᩣ ᨲᩥᨴᩈᨣᨱᩣ ᩈᨾᩮᨧ᩠ᨧ, ᨲᩴ ¶ ᨲᩴ ᨶᨾᩔᨶ᩠ᨲᩥ ᩈᩈᩥᩴᩅ ᨴᩮᩅᩣ;

ᩍᨾᩣ ᨧ ᨲᩮ ᩋᨧ᩠ᨨᩁᩣᨿᩮᩣ ᩈᨾᨶ᩠ᨲᨲᩮᩣ, ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᨣᩣᨿᨶ᩠ᨲᩥ ᨸᨾᩮᩣᨴᨿᨶ᩠ᨲᩥ.

‘‘ᨴᩮᩅᩥᨴ᩠ᨵᩥᨸᨲ᩠ᨲᩮᩣᩈᩥ ¶ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ, ᨾᨶᩩᩔᨽᩪᨲᩮᩣ ᨠᩥᨾᨠᩣᩈᩥ ᨸᩩᨬ᩠ᨬᩴ;

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ…ᨸᩮ… ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᩋᩉᩴ ᨽᨴᨶ᩠ᨲᩮ ᩋᩉᩩᩅᩣᩈᩥ ᨸᩩᨻ᩠ᨻᩮ, ᩈᩩᨾᩮᨵᨶᩣᨾᩔ ᨩᩥᨶᩔ ᩈᩣᩅᨠᩮᩣ;

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

‘‘ᩈᩮᩣᩉᩴ ¶ ᩈᩩᨾᩮᨵᩔ ᨩᩥᨶᩔ ᩈᨲ᩠ᨳᩩᨶᩮᩣ, ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩔᩮᩣᨥᨲᩥᨱ᩠ᨱᩔ ᨲᩣᨴᩥᨶᩮᩣ;

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

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

ᨸᩪᨩᩮᨳ ᨶᩴ ᨸᩪᨩᨶᩦᨿᩔ [ᨸᩪᨩᨶᩮᨿ᩠ᨿᩔ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨵᩣᨲᩩᩴ, ᩑᩅᩴ ¶ ᨠᩥᩁ ᩈᨣ᩠ᨣᨾᩥᨲᩮᩣ ᨣᨾᩥᩔᨳ.

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

ᨾᩮᩣᨴᩣᨾᩉᩴ ᨲᩥᨴᩈᨣᨱᩔ ᨾᨩ᩠ᨫᩮ, ᨶ ᨲᩔ ᨸᩩᨬ᩠ᨬᩔ ᨡᨿᨾ᩠ᨸᩥ ᩋᨩ᩠ᨫᨣ’’ᨶ᩠ᨲᩥ.

[ᨸᩮ. ᩅ. ᪑᪘᪖] ‘‘ᩋᩃᨦ᩠ᨠᨲᩮᩣ ¶ ᨾᨭ᩠ᨮᨠᩩᨱ᩠ᨯᩃᩦ [ᨾᨭ᩠ᨭᨠᩩᨱ᩠ᨯᩃᩦ (ᩈᩦ.)], ᨾᩣᩃᨵᩣᩁᩦ ᩉᩁᩥᨧᨶ᩠ᨴᨶᩩᩔᨴᩮᩣ;

ᨻᩣᩉᩣ ᨸᨣ᩠ᨣᨿ᩠ᩉ ᨠᨶ᩠ᨴᩈᩥ, ᩅᨶᨾᨩ᩠ᨫᩮ ᨠᩥᩴ ᨴᩩᨠ᩠ᨡᩥᨲᩮᩣ ᨲᩩᩅ’’ᨶ᩠ᨲᩥ.

‘‘ᩈᩮᩣᩅᨱ᩠ᨱᨾᨿᩮᩣ ᨸᨽᩔᩁᩮᩣ, ᩏᨸ᩠ᨸᨶ᩠ᨶᩮᩣ ᩁᨳᨸᨬ᩠ᨩᩁᩮᩣ ᨾᨾ;

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

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

ᩌᨧᩥᨠ᩠ᨡ [ᩌᨧᩥᨠ᩠ᨡᨳ (ᨠ.)] ᨾᩮ ᨽᨴ᩠ᨴᨾᩣᨱᩅ, ᨧᨠ᩠ᨠᨿᩩᨣᩴ ᨸᨭᩥᨸᩣᨴᨿᩣᨾᩥ ᨲᩮ’’ᨲᩥ.

ᩈᩮᩣ ¶ ᨾᩣᨱᩅᩮᩣ ᨲᩔ ᨸᩣᩅᨴᩥ, ‘‘ᨧᨶ᩠ᨴᩥᨾᩈᩪᩁᩥᨿᩣ ᩏᨽᨿᩮᨲ᩠ᨳ ᨴᩥᩔᩁᩮ;

ᩈᩮᩣᩅᨱ᩠ᨱᨾᨿᩮᩣ ᩁᨳᩮᩣ ᨾᨾ, ᨲᩮᨶ ᨧᨠ᩠ᨠᨿᩩᨣᩮᨶ ᩈᩮᩣᨽᨲᩦ’’ᨲᩥ.

‘‘ᨻᩣᩃᩮᩣ ¶ ᨡᩮᩣ ᨲ᩠ᩅᩴ ᩋᩈᩥ ᨾᩣᨱᩅ, ᨿᩮᩣ ᨲ᩠ᩅᩴ ᨸᨲ᩠ᨳᨿᩈᩮ ᩋᨸᨲ᩠ᨳᩥᨿᩴ;

ᨾᨬ᩠ᨬᩣᨾᩥ ᨲᩩᩅᩴ ᨾᩁᩥᩔᩈᩥ, ᨶ ᩉᩥ ᨲ᩠ᩅᩴ ᩃᨧ᩠ᨨᩈᩥ ᨧᨶ᩠ᨴᩥᨾᩈᩪᩁᩥᨿᩮ’’ᨲᩥ.

‘‘ᨣᨾᨶᩣᨣᨾᨶᨾ᩠ᨸᩥ ᨴᩥᩔᨲᩥ, ᩅᨱ᩠ᨱᨵᩣᨲᩩ ᩏᨽᨿᨲ᩠ᨳ ᩅᩦᨳᩥᨿᩣ;

ᨸᩮᨲᩮᩣ [ᨸᩮᨲᩮᩣ ᨸᨶ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨠᩣᩃᨠᨲᩮᩣ ᨶ ᨴᩥᩔᨲᩥ, ᨠᩮᩣ ᨶᩥᨵ ᨠᨶ᩠ᨴᨲᩴ ᨻᩣᩃ᩠ᨿᨲᩁᩮᩣ’’ᨲᩥ.

‘‘ᩈᨧ᩠ᨧᩴ ᨡᩮᩣ ᩅᨴᩮᩈᩥ ᨾᩣᨱᩅ, ᩋᩉᨾᩮᩅ ᨠᨶ᩠ᨴᨲᩴ ᨻᩣᩃ᩠ᨿᨲᩁᩮᩣ;

ᨧᨶ᩠ᨴᩴ ᩅᩥᨿ ᨴᩣᩁᨠᩮᩣ ᩁᩩᨴᩴ, ᨸᩮᨲᩴ ᨠᩣᩃᨠᨲᩣᨽᩥᨸᨲ᩠ᨳᨿᩥ’’ᨶ᩠ᨲᩥ.

‘‘ᩌᨴᩥᨲ᩠ᨲᩴ ᩅᨲ ᨾᩴ ᩈᨶ᩠ᨲᩴ, ᨥᨲᩈᩥᨲ᩠ᨲᩴᩅ ᨸᩣᩅᨠᩴ;

ᩅᩣᩁᩥᨶᩣ ᩅᩥᨿ ᩒᩈᩥᨬ᩠ᨧᩴ, ᩈᨻ᩠ᨻᩴ ᨶᩥᨻ᩠ᨻᩣᨸᨿᩮ ᨴᩁᩴ.

‘‘ᩋᨻ᩠ᨻᩉᩦ ¶ [ᩋᨻ᩠ᨻᩪᩊ᩠ᩉ (ᨸᩦ.), ᩋᨻ᩠ᨻᩪᩊ᩠ᩉᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩅᨲ ᨾᩮ ᩈᩃ᩠ᩃᩴ, ᩈᩮᩣᨠᩴ ᩉᨴᨿᨶᩥᩔᩥᨲᩴ;

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

‘‘ᩈ᩠ᩅᩣᩉᩴ ¶ ¶ ᩋᨻ᩠ᨻᩪᩊ᩠ᩉᩈᩃ᩠ᩃᩮᩣᩈ᩠ᨾᩥ, ᩈᩦᨲᩥᨽᩪᨲᩮᩣᩈ᩠ᨾᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩮᩣ;

ᨶ ᩈᩮᩣᨧᩣᨾᩥ ᨶ ᩁᩮᩣᨴᩣᨾᩥ, ᩅᨲ ᩈᩩᨲ᩠ᩅᩣᨶ ᨾᩣᨱᩅᩣᨲᩥ.

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

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

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

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

‘‘ᩋᨸ᩠ᨸᩴ ¶ ᩅᩣ ᨻᩉᩩᩴ ᩅᩣ ᨶᩣᨴ᩠ᨴᩈᩣᨾ, ᨴᩣᨶᩴ ᨴᨴᨶ᩠ᨲᩔ ᩈᨠᩮ ᩋᨣᩣᩁᩮ;

ᩏᨸᩮᩣᩈᨳᨠᨾ᩠ᨾᩴ ᩅᩣ [ᩏᨸᩮᩣᩈᨳᨠᨾ᩠ᨾᨬ᩠ᨧ (ᨠ.)] ᨲᩣᨴᩥᩈᩴ, ᨠᩮᨶ ᨠᨾ᩠ᨾᩮᨶ ᨣᨲᩮᩣᩈᩥ ᨴᩮᩅᩃᩮᩣᨠ’’ᨶ᩠ᨲᩥ.

‘‘ᩌᨻᩣᨵᩥᨠᩮᩣᩉᩴ ᨴᩩᨠ᩠ᨡᩥᨲᩮᩣ ᨣᩥᩃᩣᨶᩮᩣ, ᩌᨲᩩᩁᩁᩪᨸᩮᩣᨾ᩠ᩉᩥ ᩈᨠᩮ ᨶᩥᩅᩮᩈᨶᩮ;

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

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

ᨲᩣᩉᩴ ᨠᩩᩈᩃᩴ ᨠᩁᩥᨲ᩠ᩅᩣᨶ ᨠᨾ᩠ᨾᩴ, ᨲᩥᨴᩈᩣᨶᩴ ᩈᩉᨻ᩠ᨿᨲᩴ ᨣᨲᩮᩣ’’ᨲᩥ.

‘‘ᩋᨧ᩠ᨨᩁᩥᨿᩴ ᩅᨲ ᩋᨻ᩠ᨽᩩᨲᩴ ᩅᨲ, ᩋᨬ᩠ᨩᩃᩥᨠᨾ᩠ᨾᩔ ᩋᨿᨾᩦᨴᩥᩈᩮᩣ ᩅᩥᨸᩣᨠᩮᩣ;

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

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨻᩩᨴ᩠ᨵᩴ ᩈᩁᨱᩴ ᩅᨩᩣᩉᩥ, ᨵᨾ᩠ᨾᨬ᩠ᨧ ᩈᨦ᩠ᨥᨬ᩠ᨧ ᨸᩈᨶ᩠ᨶᨧᩥᨲ᩠ᨲᩮᩣ;

ᨲᨳᩮᩅ ᩈᩥᨠ᩠ᨡᩣᨿ ᨸᨴᩣᨶᩥ ᨸᨬ᩠ᨧ, ᩋᨡᨱ᩠ᨯᨹᩩᩃ᩠ᩃᩣᨶᩥ ᩈᨾᩣᨴᩥᨿᩔᩩ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ᩅᩥᩁᨾᩔᩩ ᨡᩥᨸ᩠ᨸᩴ, ᩃᩮᩣᨠᩮ ᩋᨴᩥᨶ᩠ᨶᩴ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩔᩩ;

ᩋᨾᨩ᩠ᨩᨸᩮᩣ ᨾᩣ ᨧ ᨾᩩᩈᩣ ᨽᨱᩣᩉᩥ, ᩈᨠᩮᨶ ᨴᩣᩁᩮᨶ ᨧ ᩉᩮᩣᩉᩥ ᨲᩩᨭ᩠ᨮᩮᩣ’’ᨲᩥ.

‘‘ᩋᨲ᩠ᨳᨠᩣᨾᩮᩣᩈᩥ ᨾᩮ ᨿᨠ᩠ᨡ, ᩉᩥᨲᨠᩣᨾᩮᩣᩈᩥ ᨴᩮᩅᨲᩮ;

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

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

ᩈᨦ᩠ᨥᨬ᩠ᨧ ᨶᩁᨴᩮᩅᩔ, ᨣᨧ᩠ᨨᩣᨾᩥ ᩈᩁᨱᩴ ᩋᩉᩴ.

‘‘ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ¶ ¶ ᩅᩥᩁᨾᩣᨾᩥ ᨡᩥᨸ᩠ᨸᩴ, ᩃᩮᩣᨠᩮ ¶ ᩋᨴᩥᨶ᩠ᨶᩴ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩣᨾᩥ;

ᩋᨾᨩ᩠ᨩᨸᩮᩣ ᨶᩮᩣ ᨧ ᨾᩩᩈᩣ ᨽᨱᩣᨾᩥ, ᩈᨠᩮᨶ ᨴᩣᩁᩮᨶ ᨧ ᩉᩮᩣᨾᩥ ᨲᩩᨭ᩠ᨮᩮᩣ’’ᨲᩥ.

[ᨸᩮ. ᩅ. ᪖᪐᪔] ᩈᩩᨱᩮᩣᨳ ¶ ¶ ᨿᨠ᩠ᨡᩔ ᨧ ᩅᩣᨱᩥᨩᩣᨶ ᨧ, ᩈᨾᩣᨣᨾᩮᩣ ᨿᨲ᩠ᨳ ᨲᨴᩣ ᩋᩉᩮᩣᩈᩥ;

ᨿᨳᩣ ᨠᨳᩴ ᩍᨲᩁᩥᨲᩁᩮᨶ ᨧᩣᨸᩥ, ᩈᩩᨽᩣᩈᩥᨲᩴ ᨲᨬ᩠ᨧ ᩈᩩᨱᩣᨳ ᩈᨻ᩠ᨻᩮ.

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

ᩈᩮᩣ ᨾᩮᩣᨴᨾᩣᨶᩮᩣᩅ ᩈᨠᩮ ᩅᩥᨾᩣᨶᩮ, ᩋᨾᩣᨶᩩᩈᩮᩣ ᨾᩣᨶᩩᩈᩮ ᩋᨩ᩠ᨫᨽᩣᩈᩦᨲᩥ.

‘‘ᩅᨦ᩠ᨠᩮ ᩋᩁᨬ᩠ᨬᩮ ᩋᨾᨶᩩᩔᨭ᩠ᨮᩣᨶᩮ, ᨠᨶ᩠ᨲᩣᩁᩮ ᩋᨸ᩠ᨸᩮᩣᨴᨠᩮ ᩋᨸ᩠ᨸᨽᨠ᩠ᨡᩮ;

ᩈᩩᨴᩩᨣ᩠ᨣᨾᩮ ᩅᨱ᩠ᨱᩩᨸᨳᩔ ᨾᨩ᩠ᨫᩮ, ᩅᨦ᩠ᨠᩴ ᨽᨿᩣ [ᨵᨦ᩠ᨠᩴᨽᨿᩣ (ᨠ.)] ᨶᨭ᩠ᨮᨾᨶᩣ ᨾᨶᩩᩔᩣ.

‘‘ᨶᨿᩥᨵ ᨹᩃᩣ ᨾᩪᩃᨾᨿᩣ ᨧ ᩈᨶ᩠ᨲᩥ, ᩏᨸᩣᨴᩣᨶᩴ ᨶᨲ᩠ᨳᩥ ᨠᩩᨲᩮᩣᨵ ᨽᨠ᩠ᨡᩮᩣ;

ᩋᨬ᩠ᨬᨲᩕ ᨸᩴᩈᩪᩉᩥ ᨧ ᩅᩣᩃᩩᨠᩣᩉᩥ ᨧ, ᨲᨲᩣᩉᩥ ¶ ᩏᨱ᩠ᩉᩣᩉᩥ ᨧ ᨴᩣᩁᩩᨱᩣᩉᩥ ᨧ.

‘‘ᩏᨩ᩠ᨩᨦ᩠ᨣᩃᩴ ᨲᨲ᩠ᨲᨾᩥᩅᩴ ᨠᨸᩣᩃᩴ, ᩋᨶᩣᨿᩈᩴ ᨸᩁᩃᩮᩣᨠᩮᨶ ᨲᩩᩃ᩠ᨿᩴ;

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

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

ᩋᨶᩩᨸᩅᩥᨭ᩠ᨮᩣ ᩈᩉᩈᩣ ᩈᨾᩮᨧ᩠ᨧ, ᩃᩮᩣᨽᩣ ᨽᨿᩣ ᩋᨳ ᩅᩣ ᩈᨾ᩠ᨸᨾᩪᩊ᩠ᩉᩣ’’ᨲᩥ.

‘‘ᨾᨣᨵᩮᩈᩩ ᩋᨦ᩠ᨣᩮᩈᩩ ᨧ ᩈᨲ᩠ᨳᩅᩣᩉᩣ, ᩌᩁᩮᩣᨸᨿᩥᨲ᩠ᩅᩣ ᨸᨱᩥᨿᩴ ᨸᩩᨳᩩᨲ᩠ᨲᩴ;

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

‘‘ᨴᩥᩅᩣ ¶ ᨸᩥᨸᩣᩈᩴ ᨶᨵᩥᩅᩣᩈᨿᨶ᩠ᨲᩣ, ᨿᩮᩣᨣ᩠ᨣᩣᨶᩩᨠᨾ᩠ᨸᨬ᩠ᨧ ᩈᨾᩮᨠ᩠ᨡᨾᩣᨶᩣ,

ᩑᨲᩮᨶ ᩅᩮᨣᩮᨶ ᩌᨿᩣᨾ ᩈᨻ᩠ᨻᩮ [ᩈᨻ᩠ᨻᩮ ᨲᩮ (ᨠ.)], ᩁᨲ᩠ᨲᩥᩴ ᨾᨣ᩠ᨣᩴ ᨸᨭᩥᨸᨶ᩠ᨶᩣ ᩅᩥᨠᩣᩃᩮ.

‘‘ᨲᩮ ᨴᩩᨸ᩠ᨸᨿᩣᨲᩣ ᩋᨸᩁᨴ᩠ᨵᨾᨣ᩠ᨣᩣ, ᩋᨶ᩠ᨵᩣᨠᩩᩃᩣ ᩅᩥᨸ᩠ᨸᨶᨭ᩠ᨮᩣ ᩋᩁᨬ᩠ᨬᩮ;

ᩈᩩᨴᩩᨣ᩠ᨣᨾᩮ ¶ ᩅᨱ᩠ᨱᩩᨸᨳᩔ ᨾᨩ᩠ᨫᩮ, ᨴᩥᩈᩴ ᨶ ᨩᩣᨶᩣᨾ ᨸᨾᩪᩊ᩠ᩉᨧᩥᨲ᩠ᨲᩣ.

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

ᨲᨲᩩᨲ᩠ᨲᩁᩥᩴ ᨩᩦᩅᩥᨲᨾᩣᩈᨾᩣᨶᩣ, ᨴᩥᩈ᩠ᩅᩣ ᨸᨲᩦᨲᩣ ᩈᩩᨾᨶᩣ ᩏᨴᨣ᩠ᨣᩣ’’ᨲᩥ.

‘‘ᨸᩣᩁᩴ ᩈᨾᩩᨴ᩠ᨴᩔ ᩍᨾᨬ᩠ᨧ ᩅᨱ᩠ᨱᩩᩴ [ᩅᨶᩴ (ᩈ᩠ᨿᩣ.), ᩅᨱ᩠ᨱᩴ (ᨠ.)], ᩅᩮᨲ᩠ᨲᩣᨧᩁᩴ [ᩅᩮᨲ᩠ᨲᩴ ᨸᩁᩴ (ᩈ᩠ᨿᩣ.), ᩅᩮᨲ᩠ᨲᩣᨧᩣᩁᩴ (ᨠ.)] ᩈᨦ᩠ᨠᩩᨸᨳᨬ᩠ᨧ ᨾᨣ᩠ᨣᩴ;

ᨶᨴᩥᨿᩮᩣ ᨸᨶ ᨸᨻ᩠ᨻᨲᩣᨶᨬ᩠ᨧ ᨴᩩᨣ᩠ᨣᩣ, ᨸᩩᨳᩩᨴ᩠ᨴᩥᩈᩣ ᨣᨧ᩠ᨨᨳ ᨽᩮᩣᨣᩉᩮᨲᩩ.

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

ᨿᩴ ᩅᩮᩣ ᩈᩩᨲᩴ ᩅᩣ ᩋᨳ ᩅᩣᨸᩥ ᨴᩥᨭ᩠ᨮᩴ, ᩋᨧ᩠ᨨᩮᩁᨠᩴ ᨲᩴ ᩅᩮᩣ ᩈᩩᨱᩮᩣᨾ ᨲᩣᨲᩣ’’ᨲᩥ.

‘‘ᩍᨲᩮᩣᨸᩥ ¶ ᩋᨧ᩠ᨨᩮᩁᨲᩁᩴ ᨠᩩᨾᩣᩁ, ᨶ ᨲᩮᩣ ᩈᩩᨲᩴ ᩅᩣ ᩋᨳ ᩅᩣᨸᩥ ᨴᩥᨭ᩠ᨮᩴ;

ᩋᨲᩦᨲᨾᩣᨶᩩᩔᨠᨾᩮᩅ ᩈᨻ᩠ᨻᩴ, ᨴᩥᩈ᩠ᩅᩣᨶ ᨲᨸ᩠ᨸᩣᨾ ᩋᨶᩮᩣᨾᩅᨱ᩠ᨱᩴ.

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

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

‘‘ᩅᩮᩊᩪᩁᩥᨿᨳᨾ᩠ᨽᩣ ¶ ᩈᨲᨾᩩᩔᩥᨲᩣᩈᩮ, ᩈᩥᩃᩣᨸᩅᩣᩊᩔ ᨧ ᩌᨿᨲᩴᩈᩣ;

ᨾᩈᩣᩁᨣᩃ᩠ᩃᩣ ᩈᩉᩃᩮᩣᩉᩥᨲᨦ᩠ᨣᩣ, ᨳᨾ᩠ᨽᩣ ᩍᨾᩮ ᨩᩮᩣᨲᩥᩁᩈᩣᨾᨿᩣᩈᩮ.

‘‘ᩈᩉᩔᨳᨾ᩠ᨽᩴ ᩋᨲᩩᩃᩣᨶᩩᨽᩣᩅᩴ, ᨲᩮᩈᩪᨸᩁᩥ ᩈᩣᨵᩩᨾᩥᨴᩴ ᩅᩥᨾᩣᨶᩴ;

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

‘‘ᨩᨾ᩠ᨻᩮᩣᨶᨴᩩᨲ᩠ᨲᨲ᩠ᨲᨾᩥᨴᩴ ᩈᩩᨾᨭ᩠ᨮᩮᩣ, ᨸᩣᩈᩣᨴᩈᩮᩣᨸᩣᨱᨹᩃᩪᨸᨸᨶ᩠ᨶᩮᩣ;

ᨴᩊ᩠ᩉᩮᩣ ᨧ ᩅᨣ᩠ᨣᩩ ᨧ ᩈᩩᩈᨦ᩠ᨣᨲᩮᩣ ᨧ [ᩅᨣ᩠ᨣᩩ ᩈᩩᨾᩩᨡᩮᩣ ᩈᩩᩈᨦ᩠ᨣᨲᩮᩣ (ᩈᩦ.)], ᩋᨲᩦᩅ ᨶᩥᨩ᩠ᨫᩣᨶᨡᨾᩮᩣ ᨾᨶᩩᨬ᩠ᨬᩮᩣ.

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

ᨾᩩᩁᨩᩌᩃᨾ᩠ᨻᩁᨲᩪᩁᩥᨿᨥᩩᨭ᩠ᨮᩮᩣ, ᩋᨽᩥᩅᨶ᩠ᨴᩥᨲᩮᩣᩈᩥ ᨳᩩᨲᩥᩅᨶ᩠ᨴᨶᩣᨿ.

‘‘ᩈᩮᩣ ¶ ᨾᩮᩣᨴᩈᩥ ᨶᩣᩁᩥᨣᨱᨸ᩠ᨸᨻᩮᩣᨵᨶᩮᩣ, ᩅᩥᨾᩣᨶᨸᩣᩈᩣᨴᩅᩁᩮ ᨾᨶᩮᩣᩁᨾᩮ;

ᩋᨧᩥᨶ᩠ᨲᩥᨿᩮᩣ ᩈᨻ᩠ᨻᨣᩩᨱᩪᨸᨸᨶ᩠ᨶᩮᩣ, ᩁᩣᨩᩣ ᨿᨳᩣ ᩅᩮᩔᩅᨱᩮᩣ ᨶᩊᩥᨶ᩠ᨿᩣ [ᨶᩊᩥᨬ᩠ᨬᩴ (ᨠ.)].

‘‘ᨴᩮᩅᩮᩣ ¶ ᨶᩩ ᩌᩈᩥ ᩏᨴᩅᩣᩈᩥ ᨿᨠ᩠ᨡᩮᩣ, ᩏᨴᩣᩉᩩ ᨴᩮᩅᩥᨶ᩠ᨴᩮᩣ ᨾᨶᩩᩔᨽᩪᨲᩮᩣ;

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

‘‘ᩈᩮᩁᩦᩈᨠᩮᩣ [ᩈᩮᩁᩥᩔᨠᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨶᩣᨾ ᩋᩉᨾ᩠ᩉᩥ ᨿᨠ᩠ᨡᩮᩣ, ᨠᨶ᩠ᨲᩣᩁᩥᨿᩮᩣ ᩅᨱ᩠ᨱᩩᨸᨳᨾ᩠ᩉᩥ ᨣᩩᨲ᩠ᨲᩮᩣ;

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

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

ᨸᩩᨧ᩠ᨨᨶ᩠ᨲᩥ ᨲᩴ ᩅᩣᨱᩥᨩᩣ ᩈᨲ᩠ᨳᩅᩣᩉᩣ, ᨠᨳᩴ ᨲᨿᩣ ᩃᨴ᩠ᨵᨾᩥᨴᩴ ᨾᨶᩩᨬ᩠ᨬ’’ᨶ᩠ᨲᩥ.

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

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

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

ᨸᩩᨧ᩠ᨨᨶ᩠ᨲᩥ ᨲᩴ ᩅᩣᨱᩥᨩᩣ ᩈᨲ᩠ᨳᩅᩣᩉᩣ, ᨠᨳᩴ ᨲᨿᩣ ᩃᨴ᩠ᨵᨾᩥᨴᩴ ᩅᩥᨾᩣᨶ’’ᨶ᩠ᨲᩥ.

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

ᨶᨲ᩠ᨳᩥᨠᨴᩥᨭ᩠ᨮᩥ ᨠᨴᩁᩥᨿᩮᩣ ᨸᩣᨸᨵᨾ᩠ᨾᩮᩣ, ᩏᨧ᩠ᨨᩮᨴᩅᩣᨴᩦ ᨧ ᨲᨴᩣ ᩋᩉᩮᩣᩈᩥᩴ.

‘‘ᩈᨾᨱᩮᩣ ᨧ ᨡᩮᩣ ᩌᩈᩥ ᨠᩩᨾᩣᩁᨠᩔᨸᩮᩣ, ᨻᩉᩩᩔᩩᨲᩮᩣ ᨧᩥᨲ᩠ᨲᨠᨳᩦ ᩏᩊᩣᩁᩮᩣ;

ᩈᩮᩣ ᨾᩮ ᨲᨴᩣ ᨵᨾ᩠ᨾᨠᨳᩴ ᩋᨽᩣᩈᩥ [ᩋᨠᩣᩈᩥ (ᩈᩦ.)], ᨴᩥᨭ᩠ᨮᩥᩅᩥᩈᩪᨠᩣᨶᩥ ᩅᩥᨶᩮᩣᨴᨿᩦ ᨾᩮ.

‘‘ᨲᩣᩉᩴ ¶ ᨲᩔ [ᨲᩣᩉᩴ (ᨠ.)] ᨵᨾ᩠ᨾᨠᨳᩴ ᩈᩩᨱᩥᨲ᩠ᩅᩣ, ᩏᨸᩣᩈᨠᨲ᩠ᨲᩴ ᨸᨭᩥᩅᩮᨴᨿᩥᩔᩴ;

ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ᩅᩥᩁᨲᩮᩣ ᩋᩉᩮᩣᩈᩥᩴ, ᩃᩮᩣᨠᩮ ᩋᨴᩥᨶ᩠ᨶᩴ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩥᩔᩴ;

ᩋᨾᨩ᩠ᨩᨸᩮᩣ ¶ ᨶᩮᩣ ᨧ ᨾᩩᩈᩣ ᩋᨽᩣᨱᩥᩴ, ᩈᨠᩮᨶ ᨴᩣᩁᩮᨶ ᨧ ᩋᩉᩮᩣᩈᩥ ᨲᩩᨭ᩠ᨮᩮᩣ.

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

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

‘‘ᩈᨧ᩠ᨧᩴ ¶ ᨠᩥᩁᩣᩉᩴᩈᩩ ᨶᩁᩣ ᩈᨸᨬ᩠ᨬᩣ, ᩋᨶᨬ᩠ᨬᨳᩣ ᩅᨧᨶᩴ ᨸᨱ᩠ᨯᩥᨲᩣᨶᩴ;

ᨿᩉᩥᩴ ᨿᩉᩥᩴ ᨣᨧ᩠ᨨᨲᩥ ᨸᩩᨬ᩠ᨬᨠᨾ᩠ᨾᩮᩣ, ᨲᩉᩥᩴ ᨲᩉᩥᩴ ᨾᩮᩣᨴᨲᩥ ᨠᩣᨾᨠᩣᨾᩦ.

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

ᨲᩉᩥᩴ ᨲᩉᩥᩴ ᨣᨧ᩠ᨨᨲᩥ ᨸᩣᨸᨠᨾ᩠ᨾᩮᩣ, ᨶ ᨾᩩᨧ᩠ᨧᨲᩥ ᨴᩩᨣ᩠ᨣᨲᩥᨿᩣ ᨠᨴᩣᨧᩦ’’ᨲᩥ.

‘‘ᩈᨾ᩠ᨾᩪᩊ᩠ᩉᩁᩪᨸᩮᩣᩅ ᨩᨶᩮᩣ ᩋᩉᩮᩣᩈᩥ, ᩋᩈ᩠ᨾᩥᩴ ᨾᩩᩉᩩᨲ᩠ᨲᩮ ᨠᩃᩃᩦᨠᨲᩮᩣᩅ;

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

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

ᨲᩮ ᩈᨾ᩠ᨸᩅᩣᨿᨶ᩠ᨲᩥ ᩍᨾᩴ ᩅᩥᨾᩣᨶᩴ, ᨴᩥᩅᩣ ¶ ᨧ ᩁᨲ᩠ᨲᩮᩣ ᨧ ᨲᨾᩴ ᨶᩥᩉᨶ᩠ᨲ᩠ᩅᩣ.

‘‘ᩍᨾᩮᩈᨬ᩠ᨧ ¶ ᨡᩮᩣ ᩅᩔᩈᨲᨧ᩠ᨧᨿᩮᨶ, ᩈᩥᨸᩣᨭᩥᨠᩣ ᨹᩃᨲᩥ ᩑᨠᨾᩮᨠᩣ;

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

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

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

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

ᨿᩮ ᨧᩣᨸᩥ ᨡᩮᩣ ᩍᨲ᩠ᨲᩁᨾᩩᨸᨸᨶ᩠ᨶᩣ, ᨲᩮ ᨶᩪᨶ ᩈᩮᩣᨧᩮᨿ᩠ᨿᩩᩴ ᨸᩁᩥᨲ᩠ᨲᨸᩩᨬ᩠ᨬᩣ’’ᨲᩥ.

‘‘ᩋᨶᩩᨧ᩠ᨨᩅᩥᩴ ᩒᩅᨴᩥᨿᨬ᩠ᨧ ᨾᩮ ᨲᩴ, ᨿᩴ ᨾᩴ ᨲᩩᨾ᩠ᩉᩮ ᨸᩮᨿ᩠ᨿᩅᩣᨧᩴ ᩅᨴᩮᨳ;

ᨲᩩᨾ᩠ᩉᩮ ᨧ ᨡᩮᩣ ᨲᩣᨲᩣ ᨾᨿᩣᨶᩩᨣᩩᨲ᩠ᨲᩣ, ᨿᩮᨶᩥᨧ᩠ᨨᨠᩴ ᨲᩮᨶ ᨸᩃᩮᨳ ᩈᩮᩣᨲ᩠ᨳᩥ’’ᨶ᩠ᨲᩥ.

‘‘ᨣᨶ᩠ᨲ᩠ᩅᩣ ¶ ᨾᨿᩴ ᩈᩥᨶ᩠ᨵᩩᩈᩮᩣᩅᩦᩁᨽᩪᨾᩥᩴ, ᨵᨶᨲ᩠ᨳᩥᨠᩣ ᩏᨴ᩠ᨴᨿᩴ ᨸᨲ᩠ᨳᨿᩣᨶᩣ;

ᨿᨳᩣᨸᨿᩮᩣᨣᩣ ᨸᩁᩥᨸᩩᨱ᩠ᨱᨧᩣᨣᩣ, ᨠᩣᩉᩣᨾ ¶ ᩈᩮᩁᩦᩈᨾᩉᩴ ᩏᩊᩣᩁ’’ᨶ᩠ᨲᩥ.

‘‘ᨾᩣ ᨧᩮᩅ ᩈᩮᩁᩦᩈᨾᩉᩴ ᩋᨠᨲ᩠ᨳ, ᩈᨻ᩠ᨻᨬ᩠ᨧ ᩅᩮᩣ ᨽᩅᩥᩔᨲᩥ ᨿᩴ ᩅᨴᩮᨳ;

ᨸᩣᨸᩣᨶᩥ ᨠᨾ᩠ᨾᩣᨶᩥ ᩅᩥᩅᨩ᩠ᨩᨿᩣᨳ, ᨵᨾ᩠ᨾᩣᨶᩩᨿᩮᩣᨣᨬ᩠ᨧ ᩋᨵᩥᨭ᩠ᨮᩉᩣᨳ.

‘‘ᩏᨸᩣᩈᨠᩮᩣ ᩋᨲ᩠ᨳᩥ ᩍᨾᨾ᩠ᩉᩥ ᩈᨦ᩠ᨥᩮ, ᨻᩉᩩᩔᩩᨲᩮᩣ ᩈᩦᩃᩅᨲᩪᨸᨸᨶ᩠ᨶᩮᩣ;

ᩈᨴ᩠ᨵᩮᩣ ᨧ ᨧᩣᨣᩦ ᨧ ᩈᩩᨸᩮᩈᩃᩮᩣ ᨧ, ᩅᩥᨧᨠ᩠ᨡᨱᩮᩣ ᩈᨶ᩠ᨲᩩᩈᩥᨲᩮᩣ ᨾᩩᨲᩦᨾᩣ.

‘‘ᩈᨬ᩠ᨩᩣᨶᨾᩣᨶᩮᩣ ¶ ᨶ ᨾᩩᩈᩣ ᨽᨱᩮᨿ᩠ᨿ, ᨸᩁᩪᨸᨥᩣᨲᩣᨿ ᨶ ᨧᩮᨲᨿᩮᨿ᩠ᨿ;

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

‘‘ᩈᨣᩣᩁᩅᩮᩣ ᩈᨸ᩠ᨸᨭᩥᩔᩮᩣ ᩅᩥᨶᩦᨲᩮᩣ, ᩋᨸᩣᨸᨠᩮᩣ ᩋᨵᩥᩈᩦᩃᩮ ᩅᩥᩈᩩᨴ᩠ᨵᩮᩣ;

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

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

ᨾᩣᨲᩣᨸᩥᨲᩪᨶᨬ᩠ᨧ ᨿᩮᩣ [ᩈᩮᩣ (?)] ᩋᨧ᩠ᨧᨿᩮᨶ, ᨶᩮᨠ᩠ᨡᨾ᩠ᨾᨸᩮᩣᨱᩮᩣ ¶ ᨧᩁᩥᩔᨲᩥ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ.

‘‘ᩏᨩᩪ ᩋᩅᨦ᩠ᨠᩮᩣ ᩋᩈᨮᩮᩣ ᩋᨾᩣᨿᩮᩣ, ᨶ ᩃᩮᩈᨠᨸ᩠ᨸᩮᨶ ᨧ ᩅᩮᩣᩉᩁᩮᨿ᩠ᨿ;

ᩈᩮᩣ ᨲᩣᨴᩥᩈᩮᩣ ᩈᩩᨠᨲᨠᨾ᩠ᨾᨠᩣᩁᩦ, ᨵᨾ᩠ᨾᩮ ᨮᩥᨲᩮᩣ ᨠᩥᨶ᩠ᨲᩥ ᩃᨽᩮᨳ ᨴᩩᨠ᩠ᨡᩴ.

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

ᩋᨬ᩠ᨬᨲᩕ ᨲᩮᨶᩥᩉ ᨽᩈ᩠ᨾᩦ [ᨽᩈ᩠ᨾᩥ (ᩈ᩠ᨿᩣ.), ᨽᩈ᩠ᨾ (ᨠ.)] ᨽᩅᩮᨳ, ᩋᨶ᩠ᨵᩣᨠᩩᩃᩣ ᩅᩥᨸ᩠ᨸᨶᨭ᩠ᨮᩣ ᩋᩁᨬ᩠ᨬᩮ;

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

‘‘ᨠᩥᩴ ᨶᩣᨾ ᩈᩮᩣ ᨠᩥᨬ᩠ᨧ ᨠᩁᩮᩣᨲᩥ ᨠᨾ᩠ᨾᩴ,

ᨠᩥᩴ ᨶᩣᨾᨵᩮᨿ᩠ᨿᩴ ᨠᩥᩴ ᨸᨶ ᨲᩔ ᨣᩮᩣᨲ᩠ᨲᩴ;

ᨾᨿᨾ᩠ᨸᩥ ᨶᩴ ᨴᨭ᩠ᨮᩩᨠᩣᨾᨾ᩠ᩉ ᨿᨠ᩠ᨡ, ᨿᩔᩣᨶᩩᨠᨾ᩠ᨸᩣᨿ ᩍᨵᩣᨣᨲᩮᩣᩈᩥ;

‘‘ᨿᩮᩣ ¶ ¶ ᨠᨸ᩠ᨸᨠᩮᩣ ᩈᨾ᩠ᨽᩅᨶᩣᨾᨵᩮᨿ᩠ᨿᩮᩣ,

ᨩᩣᨶᩣᨳ ᨶᩴ ᨲᩩᨾ᩠ᩉᩣᨠᩴ ᨸᩮᩈᩥᨿᩮᩣ ᩈᩮᩣ,

ᨾᩣ ¶ ᨡᩮᩣ ᨶᩴ ᩉᩦᩊᩥᨲ᩠ᨳ ᩈᩩᨸᩮᩈᩃᩮᩣ ᩈᩮᩣ’’ᨲᩥ.

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

ᩈᩩᨲ᩠ᩅᩣᨶ ᨲᩩᨿ᩠ᩉᩴ ᩅᨧᨶᩴ ᩏᩊᩣᩁ’’ᨶ᩠ᨲᩥ.

‘‘ᨿᩮ ᨠᩮᨧᩥ ᩍᨾᩈ᩠ᨾᩥᩴ ᩈᨲ᩠ᨳᩮ ᨾᨶᩩᩔᩣ,

ᨸᩔᨶ᩠ᨲᩩ ᨸᩩᨬ᩠ᨬᩣᨶᩴ ᨹᩃᩴ ᨠᨴᩁᩥᨿᩣ’’ᨲᩥ.

ᨲᩴ ᨠᨸ᩠ᨸᨠᩴ ᨲᨲ᩠ᨳ ᨸᩩᩁᨠ᩠ᨡᨲ᩠ᩅᩣ [ᨸᩩᩁᨠ᩠ᨡᩥᨸᩥᨲ᩠ᩅᩣ (ᩈᩦ.)];

ᨲᩮ ¶ ᨲᨲ᩠ᨳ ᩈᨻ᩠ᨻᩮᩅ ‘ᩋᩉᩴ ᨸᩩᩁᩮ’ᨲᩥ, ᩏᨸᩣᩈᨠᨲ᩠ᨲᩴ ᨸᨭᩥᩅᩮᨴᨿᩥᩴᩈᩩ;

ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩣ ᩅᩥᩁᨲᩣ ᩋᩉᩮᩈᩩᩴ, ᩃᩮᩣᨠᩮ ᩋᨴᩥᨶ᩠ᨶᩴ ᨸᩁᩥᩅᨩ᩠ᨩᨿᩥᩴᩈᩩ;

ᩋᨾᨩ᩠ᨩᨸᩣ ᨶᩮᩣ ᨧ ᨾᩩᩈᩣ ᨽᨱᩥᩴᩈᩩ, ᩈᨠᩮᨶ ᨴᩣᩁᩮᨶ ᨧ ᩋᩉᩮᩈᩩᩴ ᨲᩩᨭ᩠ᨮᩣ.

ᨲᩮ ᨲᨲ᩠ᨳ ᩈᨻ᩠ᨻᩮᩅ ‘ᩋᩉᩴ ᨸᩩᩁᩮ’ᨲᩥ, ᩏᨸᩣᩈᨠᨲ᩠ᨲᩴ ᨸᨭᩥᩅᩮᨴᨿᩥᨲ᩠ᩅᩣ;

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

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

ᨿᨳᩣᨸᨿᩮᩣᨣᩣ ᨸᩁᩥᨸᩩᨱ᩠ᨱᩃᩣᨽᩣ, ᨸᨧ᩠ᨧᩣᨣᨾᩩᩴ ᨸᩣᨭᩃᩥᨸᩩᨲ᩠ᨲᨾᨠ᩠ᨡᨲᩴ.

‘‘ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ¶ ᨲᩮ ᩈᨦ᩠ᨥᩁᩴ ᩈᩮᩣᨲ᩠ᨳᩥᩅᨶ᩠ᨲᩮᩣ,

ᩌᨶᨶ᩠ᨴᩦ ᩅᩥᨲ᩠ᨲᩣ [ᩌᨶᨶ᩠ᨴᨧᩥᨲ᩠ᨲᩣ (ᩈ᩠ᨿᩣ.), ᩌᨶᨶ᩠ᨴᩦᨧᩥᨲ᩠ᨲᩣ (ᨠ.)] ᩈᩩᨾᨶᩣ ᨸᨲᩦᨲᩣ,

ᩈᨻ᩠ᨻᩮᩅ ᩈᨲ᩠ᨲᩣ ᩈᩩᨡᩥᨲᩣ [ᩈᩩᨡᩥᨶᩮᩣ (ᨸᩦ. ᨠ.)] ᩋᩉᩮᩈᩩᨶ᩠ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᨾᩥᨴᩴ ¶ ᨾᨱᩥᨳᩪᨱᩴ ᩅᩥᨾᩣᨶᩴ, ᩈᨾᨶ᩠ᨲᨲᩮᩣ ᨴ᩠ᩅᩣᨴᩈ ᨿᩮᩣᨩᨶᩣᨶᩥ;

ᨠᩪᨭᩣᨣᩣᩁᩣ ¶ ᩈᨲ᩠ᨲᩈᨲᩣ ᩏᩊᩣᩁᩣ, ᩅᩮᩊᩩᩁᩥᨿᨳᨾ᩠ᨽᩣ ᩁᩩᨧᨠᨲ᩠ᨳᨲᩣ ᩈᩩᨽᩣ.

‘‘ᨲᨲ᩠ᨳᨧ᩠ᨨᩈᩥ ᨸᩥᩅᩈᩥ ᨡᩣᨴᩈᩥ ᨧ, ᨴᩥᨻ᩠ᨻᩣ ᨧ ᩅᩦᨱᩣ ᨸᩅᨴᨶ᩠ᨲᩥ ᩅᨣ᩠ᨣᩩᩴ;

ᨴᩥᨻ᩠ᨻᩣ ᩁᩈᩣ ᨠᩣᨾᨣᩩᨱᩮᨲ᩠ᨳ ᨸᨬ᩠ᨧ, ᨶᩣᩁᩥᨿᩮᩣ ᨧ ᨶᨧ᩠ᨧᨶ᩠ᨲᩥ ᩈᩩᩅᨱ᩠ᨱᨨᨶ᩠ᨶᩣ.

‘‘ᨠᩮᨶ ᨲᩮᨲᩣᨴᩥᩈᩮᩣ ᩅᨱ᩠ᨱᩮᩣ, ᨠᩮᨶ ᨲᩮ ᩍᨵ ᨾᩥᨩ᩠ᨫᨲᩥ;

ᩏᨸ᩠ᨸᨩ᩠ᨩᨶ᩠ᨲᩥ ᨧ ᨲᩮ ᨽᩮᩣᨣᩣ, ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩈᩮᩣ ᨸᩥᨿᩣ.

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

ᨠᩮᨶᩣᩈᩥ ᩑᩅᩴ ᨩᩃᩥᨲᩣᨶᩩᨽᩣᩅᩮᩣ, ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨲᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩮᩣ ¶ ᨴᩮᩅᨸᩩᨲ᩠ᨲᩮᩣ ᩋᨲ᩠ᨲᨾᨶᩮᩣ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ;

ᨸᨬ᩠ᩉᩴ ᨸᩩᨭ᩠ᨮᩮᩣ ᩅᩥᨿᩣᨠᩣᩈᩥ, ᨿᩔ ᨠᨾ᩠ᨾᩔᩥᨴᩴ ᨹᩃᩴ.

‘‘ᨴᩩᨶ᩠ᨶᩥᨠ᩠ᨡᩥᨲ᩠ᨲᩴ ᨾᩣᩃᩴ ᩈᩩᨶᩥᨠ᩠ᨡᩥᨸᩥᨲ᩠ᩅᩣ, ᨸᨲᩥᨭ᩠ᨮᨸᩮᨲ᩠ᩅᩣ ᩈᩩᨣᨲᩔ ᨳᩪᨸᩮ;

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

ᩅᨱ᩠ᨱᩮᩣ ᨧ ᨾᩮ ᩈᨻ᩠ᨻᨴᩥᩈᩣ ᨸᨽᩣᩈᨲᩦ’’ᨲᩥ.

ᩈᩩᨶᩥᨠ᩠ᨡᩥᨲ᩠ᨲᩅᨣ᩠ᨣᩮᩣ ᩈᨲ᩠ᨲᨾᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

ᨴ᩠ᩅᩮ ᨴᩃᩥᨴ᩠ᨴᩣ ᩅᨶᩅᩥᩉᩣᩁᩣ, ᨽᨲᨠᩮᩣ ᨣᩮᩣᨸᩣᩃᨠᨱ᩠ᨯᨠᩣ;

ᩋᨶᩮᨠᩅᨱ᩠ᨱᨾᨭ᩠ᨮᨠᩩᨱ᩠ᨯᩃᩦ, ᩈᩮᩁᩦᩈᨠᩮᩣ ᩈᩩᨶᩥᨠ᩠ᨡᩥᨲ᩠ᨲᩴ;

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