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

THA Vol 0
MMR Vol 0
VRI Vol 0
PTS Vol 0

Misc. Paragraph

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

ᨳᩮᩁᩦᨣᩣᨳᩣᨸᩣᩊᩥ

᪕. ᩋᨬ᩠ᨬᨲᩁᩣᨲᩥᩔᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪒. ᨵᨾ᩠ᨾᨴᩥᨶ᩠ᨶᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪓.ᩅᩥᩈᩣᨡᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪔.ᩈᩩᨾᨶᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪕. ᩏᨲ᩠ᨲᩁᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪖. ᩅᩩᨯ᩠ᨰᨸᨻ᩠ᨻᨩᩥᨲᩈᩩᨾᨶᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪗. ᨵᨾ᩠ᨾᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪘. ᩈᨦ᩠ᨥᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪒. ᨴᩩᨠᨶᩥᨸᩣᨲᩮᩣ

᪑. ᩋᨽᩥᩁᩪᨸᨶᨶ᩠ᨴᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪒. ᨩᩮᨶ᩠ᨲᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪓. ᩈᩩᨾᨦ᩠ᨣᩃᨾᩣᨲᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪓. ᩋᨸᩁᩣᩏᨲ᩠ᨲᨾᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑. ᨽᨴ᩠ᨴᩣᨠᩣᨸᩥᩃᩣᨶᩦᨳᩮᩁᩦᨣᩣᨳᩣ

᪔. ᩈᩩᨶ᩠ᨴᩁᩦᨶᨶ᩠ᨴᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪕. ᨶᨶ᩠ᨴᩩᨲ᩠ᨲᩁᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪖. ᨾᩥᨲ᩠ᨲᩣᨠᩣᩊᩦᨳᩮᩁᩦᨣᩣᨳᩣ

᪗. ᩈᨠᩩᩃᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪘. ᩈᩮᩣᨱᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪙. ᨽᨴ᩠ᨴᩣᨠᩩᨱ᩠ᨯᩃᨠᩮᩈᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪐. ᨸᨭᩣᨧᩣᩁᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪑. ᨲᩥᩴᩈᨾᨲ᩠ᨲᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪒. ᨧᨶ᩠ᨴᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪖. ᨨᨠ᩠ᨠᨶᩥᨸᩣᨲᩮᩣ

᪑. ᨸᨬ᩠ᨧᩈᨲᨾᨲ᩠ᨲᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪖. ᨾᩉᩣᨸᨩᩣᨸᨲᩥᨣᩮᩣᨲᨾᩦᨳᩮᩁᩦᨣᩣᨳᩣ

᪑. ᨠᩥᩈᩣᨣᩮᩣᨲᨾᩦᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪑. ᨴ᩠ᩅᩣᨴᩈᨠᨶᩥᨸᩣᨲᩮᩣ

᪑. ᩏᨸ᩠ᨸᩃᩅᨱ᩠ᨱᩣᨳᩮᩁᩦᨣᩣᨳᩣ

᪕. ᩈᩩᨽᩣᨠᨾ᩠ᨾᩣᩁᨵᩦᨲᩩᨳᩮᩁᩦᨣᩣᨳᩣ

᪑᪔. ᨲᩥᩴᩈᨶᩥᨸᩣᨲᩮᩣ

᪑. ᩈᩩᨽᩣᨩᩦᩅᨠᨾ᩠ᨻᩅᨶᩥᨠᩣᨳᩮᩁᩦᨣᩣᨳᩣ

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

‘‘ᩈᩩᨡᩴ ¶ ¶ ¶ ¶ ᩈᩩᨸᩣᩉᩥ ᨳᩮᩁᩥᨠᩮ, ᨠᨲ᩠ᩅᩣ ᨧᩮᩣᩊᩮᨶ ᨸᩣᩁᩩᨲᩣ;

ᩏᨸᩈᨶ᩠ᨲᩮᩣ ᩉᩥ ᨲᩮ ᩁᩣᨣᩮᩣ, ᩈᩩᨠ᩠ᨡᨯᩣᨠᩴ ᩅ ᨠᩩᨾ᩠ᨽᩥᨿ’’ᨶ᩠ᨲᩥ.

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᩋᨬ᩠ᨬᨲᩁᩣ ᨳᩮᩁᩦ ᩋᨸᨬ᩠ᨬᩣᨲᩣ ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᨣᩣᨳᩴ ᩋᨽᩣᩈᩥᨲ᩠ᨳᩣᨲᩥ.

‘‘ᨾᩩᨲ᩠ᨲᩮ ¶ ᨾᩩᨧ᩠ᨧᩔᩩ ᨿᩮᩣᨣᩮᩉᩥ, ᨧᨶ᩠ᨴᩮᩣ ᩁᩣᩉᩩᨣ᩠ᨣᩉᩣ ᩍᩅ;

ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩮᨶ ᨧᩥᨲ᩠ᨲᩮᨶ, ᩋᨶᨱᩣ ᨽᩩᨬ᩠ᨩ ᨸᩥᨱ᩠ᨯᨠ’’ᨶ᩠ᨲᩥ.

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

‘‘ᨸᩩᨱ᩠ᨱᩮ ᨸᩪᩁᩔᩩ ᨵᨾ᩠ᨾᩮᩉᩥ, ᨧᨶ᩠ᨴᩮᩣ ᨸᨶ᩠ᨶᩁᩈᩮᩁᩥᩅ;

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

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᨸᩩᨱ᩠ᨱᩣ ᨳᩮᩁᩦ ᨣᩣᨳᩴ ᩋᨽᩣᩈᩥᨲ᩠ᨳᩣᨲᩥ.

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

ᩈᨻ᩠ᨻᨿᩮᩣᨣᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩣ, ᨧᩁ ᩃᩮᩣᨠᩮ ᩋᨶᩣᩈᩅᩣ’’ᨲᩥ.

‘‘ᨲᩥᩔᩮ ¶ ¶ ᨿᩩᨬ᩠ᨩᩔᩩ ᨵᨾ᩠ᨾᩮᩉᩥ, ᨡᨱᩮᩣ ᨲᩴ ᨾᩣ ᩏᨸᨧ᩠ᨧᨣᩣ;

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

‘‘ᨵᩦᩁᩮ ¶ ᨶᩥᩁᩮᩣᨵᩴ ᨹᩩᩈᩮᩉᩥ [ᨹᩩᩔᩮᩉᩥ (ᩈᩦ.)], ᩈᨬ᩠ᨬᩣᩅᩪᨸᩈᨾᩴ ᩈᩩᨡᩴ;

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

‘‘ᩅᩦᩁᩣ ¶ ᩅᩦᩁᩮᩉᩥ [ᨵᩦᩁᩣ ᨵᩦᩁᩮᩉᩥ (ᨠ.)] ᨵᨾ᩠ᨾᩮᩉᩥ, ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᨽᩣᩅᩥᨲᩥᨶ᩠ᨴᩕᩥᨿᩣ;

ᨵᩣᩁᩮᩉᩥ ᩋᨶ᩠ᨲᩥᨾᩴ ᨴᩮᩉᩴ, ᨩᩮᨲ᩠ᩅᩣ ᨾᩣᩁᩴ ᩈᩅᩣᩉᩥᨶᩥ’’ᨶ᩠ᨲᩥ [ᩈᩅᩣᩉᨶᨶ᩠ᨲᩥ (ᨠ.)].

‘‘ᩈᨴ᩠ᨵᩣᨿ ᨸᨻ᩠ᨻᨩᩥᨲ᩠ᩅᩣᨶ, ᨾᩥᨲ᩠ᨲᩮ ᨾᩥᨲ᩠ᨲᩁᨲᩣ ᨽᩅ;

ᨽᩣᩅᩮᩉᩥ ᨠᩩᩈᩃᩮ ᨵᨾ᩠ᨾᩮ, ᨿᩮᩣᨣᨠ᩠ᨡᩮᨾᩔ ᨸᨲ᩠ᨲᩥᨿᩣ’’ᨲᩥ.

‘‘ᩈᨴ᩠ᨵᩣᨿ ᨸᨻ᩠ᨻᨩᩥᨲ᩠ᩅᩣᨶ, ᨽᨴᩕᩮ ᨽᨴᩕᩁᨲᩣ ᨽᩅ;

ᨽᩣᩅᩮᩉᩥ ᨠᩩᩈᩃᩮ ᨵᨾ᩠ᨾᩮ, ᨿᩮᩣᨣᨠ᩠ᨡᩮᨾᨾᨶᩩᨲ᩠ᨲᩁ’’ᨶ᩠ᨲᩥ.

‘‘ᩏᨸᩈᨾᩮ ᨲᩁᩮ ᩒᨥᩴ, ᨾᨧ᩠ᨧᩩᨵᩮᨿ᩠ᨿᩴ ᩈᩩᨴᩩᨲ᩠ᨲᩁᩴ;

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

‘‘ᩈᩩᨾᩩᨲ᩠ᨲᩣ ¶ ᩈᩣᨵᩩᨾᩩᨲ᩠ᨲᩣᨾ᩠ᩉᩥ, ᨲᩦᩉᩥ ᨡᩩᨩ᩠ᨩᩮᩉᩥ ᨾᩩᨲ᩠ᨲᩥᨿᩣ;

ᩏᨴᩩᨠ᩠ᨡᩃᩮᨶ ᨾᩩᩈᩃᩮᨶ, ᨸᨲᩥᨶᩣ ᨡᩩᨩ᩠ᨩᨠᩮᨶ ᨧ;

ᨾᩩᨲ᩠ᨲᩣᨾ᩠ᩉᩥ ¶ ᨩᩣᨲᩥᨾᩁᨱᩣ, ᨽᩅᨶᩮᨲ᩠ᨲᩥ ᩈᨾᩪᩉᨲᩣ’’ᨲᩥ.

‘‘ᨨᨶ᩠ᨴᨩᩣᨲᩣ ᩋᩅᩈᩣᨿᩦ, ᨾᨶᩈᩣ ᨧ ᨹᩩᨭᩣ [ᨹᩩᨭ᩠ᨮᩣ (ᩈ᩠ᨿᩣ.), ᨹᩩᨮᩣ (ᩈᩦ. ᩋᨭ᩠ᨮ.)] ᩈᩥᨿᩣ;

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

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

ᨡᩥᨸ᩠ᨸᩴ ᨸᩣᨴᩣᨶᩥ ᨵᩮᩣᩅᩥᨲ᩠ᩅᩣ, ᩑᨠᨾᨶ᩠ᨲᩮ ᨶᩥᩈᩦᨴᨳᩣ’’ᨲᩥ.

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

ᨽᩅᩮ ᨨᨶ᩠ᨴᩴ ᩅᩥᩁᩣᨩᩮᨲ᩠ᩅᩣ, ᩏᨸᩈᨶ᩠ᨲᩣ ᨧᩁᩥᩔᩈᩦ’’ᨲᩥ.

‘‘ᨠᩣᨿᩮᨶ ¶ ᩈᩴᩅᩩᨲᩣ ᩌᩈᩥᩴ, ᩅᩣᨧᩣᨿ ᩏᨴ ᨧᩮᨲᩈᩣ;

ᩈᨾᩪᩃᩴ ᨲᨱ᩠ᩉᨾᨻ᩠ᨻᩩᨿ᩠ᩉ, ᩈᩦᨲᩥᨽᩪᨲᩣᨾ᩠ᩉᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

᪑᪖. ᩅᩩᨯ᩠ᨰᨸᨻ᩠ᨻᨩᩥᨲᩈᩩᨾᨶᩣᨳᩮᩁᩦᨣᩣᨳᩣ

‘‘ᩈᩩᨡᩴ ᨲ᩠ᩅᩴ ᩅᩩᨯ᩠ᨰᩥᨠᩮ ᩈᩮᩉᩥ, ᨠᨲ᩠ᩅᩣ ᨧᩮᩣᩊᩮᨶ ᨸᩣᩁᩪᨲᩣ;

ᩏᨸᩈᨶ᩠ᨲᩮᩣ ᩉᩥ ᨲᩮ ᩁᩣᨣᩮᩣ, ᩈᩦᨲᩥᨽᩪᨲᩣᩈᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

‘‘ᨸᩥᨱ᩠ᨯᨸᩣᨲᩴ ¶ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᨴᨱ᩠ᨯᨾᩮᩣᩃᩩᨻ᩠ᨽ ᨴᩩᨻ᩠ᨻᩃᩣ;

ᩅᩮᨵᨾᩣᨶᩮᩉᩥ ᨣᨲ᩠ᨲᩮᩉᩥ, ᨲᨲ᩠ᨳᩮᩅ ᨶᩥᨸᨲᩥᩴ ᨨᨾᩣ;

ᨴᩥᩈ᩠ᩅᩣ ¶ ᩌᨴᩦᨶᩅᩴ ᨠᩣᨿᩮ, ᩋᨳ ᨧᩥᨲ᩠ᨲᩴ ᩅᩥᨾᩩᨧ᩠ᨧᩥ ᨾᩮ’’ᨲᩥ.

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

ᩉᩥᨲ᩠ᩅᩣ ᩁᩣᨣᨬ᩠ᨧ ᨴᩮᩣᩈᨬ᩠ᨧ, ᩋᩅᩥᨩ᩠ᨩᨬ᩠ᨧ ᩅᩥᩁᩣᨩᩥᨿ;

ᩈᨾᩪᩃᩴ ᨲᨱ᩠ᩉᨾᨻ᩠ᨻᩩᨿ᩠ᩉ, ᩏᨸᩈᨶ᩠ᨲᩣᨾ᩠ᩉᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

[ᩋᨸ. ᨳᩮᩁᩦ ᪒.᪔.᪑᪕᪗ ᩋᨸᨴᩣᨶᩮᨸᩥ] ‘‘ᩌᨲᩩᩁᩴ ¶ ᩋᩈᩩᨧᩥᩴ ᨸᩪᨲᩥᩴ, ᨸᩔ ᨶᨶ᩠ᨴᩮ ᩈᨾᩩᩔᨿᩴ;

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

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

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

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᨽᨣᩅᩣ ᩋᨽᩥᩁᩪᨸᨶᨶ᩠ᨴᩴ ᩈᩥᨠ᩠ᨡᨾᩣᨶᩴ ᩍᨾᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨽᩥᨱ᩠ᩉᩴ ᩒᩅᨴᨲᩦᨲᩥ [ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᨽᨣᩅᩣ ᩋᨽᩥᩁᩪᨸᨶᨶ᩠ᨴᩴ ᩈᩥᨠ᩠ᨡᨾᩣᨶᩴ ᩍᨾᩣᩉᩥ ᨣᩣᨳᩣᩉᩥ ᩋᨽᩥᨱ᩠ᩉᩴ ᩒᩅᨴᨲᩦᨲᩥ (ᨠ.)].

‘‘ᨿᩮ ᩍᨾᩮ ᩈᨲ᩠ᨲ ᨻᩮᩣᨩ᩠ᨫᨦ᩠ᨣᩣ, ᨾᨣ᩠ᨣᩣ ᨶᩥᨻ᩠ᨻᩣᨶᨸᨲ᩠ᨲᩥᨿᩣ;

ᨽᩣᩅᩥᨲᩣ ᨲᩮ ᨾᨿᩣ ᩈᨻ᩠ᨻᩮ, ᨿᨳᩣ ᨻᩩᨴ᩠ᨵᩮᨶ ᨴᩮᩈᩥᨲᩣ.

‘‘ᨴᩥᨭ᩠ᨮᩮᩣ ᩉᩥ ᨾᩮ ᩈᩮᩣ ᨽᨣᩅᩣ, ᩋᨶ᩠ᨲᩥᨾᩮᩣᨿᩴ ᩈᨾᩩᩔᨿᩮᩣ;

ᩅᩥᨠ᩠ᨡᩦᨱᩮᩣ ᨩᩣᨲᩥᩈᩴᩈᩣᩁᩮᩣ, ᨶᨲ᩠ᨳᩥ ᨴᩣᨶᩥ ᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ’’ᨲᩥ.

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᨩᩮᨶ᩠ᨲᩣ ᨳᩮᩁᩦ ᨣᩣᨳᩣᨿᩮᩣ ᩋᨽᩣᩈᩥᨲ᩠ᨳᩣᨲᩥ.

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

ᩋᩉᩥᩁᩥᨠᩮᩣ ᨾᩮ ᨨᨲ᩠ᨲᨠᩴ ᩅᩣᨸᩥ, ᩏᨠ᩠ᨡᩃᩥᨠᩣ ᨾᩮ ᨴᩮᨯ᩠ᨯᩩᨽᩴ ᩅᩣᨲᩥ.

‘‘ᩁᩣᨣᨬ᩠ᨧ ᩋᩉᩴ ᨴᩮᩣᩈᨬ᩠ᨧ, ᨧᩥᨧ᩠ᨧᩥᨭᩥ ᨧᩥᨧ᩠ᨧᩥᨭᩦᨲᩥ ᩅᩥᩉᨶᩣᨾᩥ;

ᩈᩣ ᩁᩩᨠ᩠ᨡᨾᩪᩃᨾᩩᨸᨣᨾ᩠ᨾ, ᩋᩉᩮᩣ ᩈᩩᨡᨶ᩠ᨲᩥ ᩈᩩᨡᨲᩮᩣ ᨫᩣᨿᩣᨾᩦ’’ᨲᩥ.

… ᩈᩩᨾᨦ᩠ᨣᩃᨾᩣᨲᩣ ᨳᩮᩁᩦ [ᩋᨬ᩠ᨬᨲᩁᩣ ᨳᩮᩁᩦ ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᩋᨸᨬ᩠ᨬᩣᨲᩣ (ᩈ᩠ᨿᩣ. ᨠ.)].

‘‘ᨿᩣᩅ ᨠᩣᩈᩥᨩᨶᨸᨴᩮᩣ, ᩈᩩᨦ᩠ᨠᩮᩣ ᨾᩮ ᨲᨲ᩠ᨳᨠᩮᩣ ᩋᩉᩩ;

ᨲᩴ ᨠᨲ᩠ᩅᩣ ᨶᩮᨣᨾᩮᩣ ᩋᨣ᩠ᨥᩴ, ᩋᨯ᩠ᨰᩮᨶᨣ᩠ᨥᩴ ᨮᨸᩮᩈᩥ ᨾᩴ.

‘‘ᩋᨳ ¶ ᨶᩥᨻ᩠ᨻᩥᨶ᩠ᨴᩉᩴ ᩁᩪᨸᩮ, ᨶᩥᨻ᩠ᨻᩥᨶ᩠ᨴᨬ᩠ᨧ ᩅᩥᩁᨩ᩠ᨩᩉᩴ;

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

ᨲᩥᩔᩮᩣ ᩅᩥᨩ᩠ᨩᩣ ᩈᨧ᩠ᨨᩥᨠᨲᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᨠᩥᨬ᩠ᨧᩣᨸᩥ ᨡᩮᩣᨾ᩠ᩉᩥ ᨠᩥᩈᩥᨠᩣ, ᨣᩥᩃᩣᨶᩣ ᨻᩣᩊ᩠ᩉᨴᩩᨻ᩠ᨻᩃᩣ;

ᨴᨱ᩠ᨯᨾᩮᩣᩃᩩᨻ᩠ᨽ ᨣᨧ᩠ᨨᩣᨾᩥ, ᨸᨻ᩠ᨻᨲᩴ ᩋᨽᩥᩁᩪᩉᩥᨿ.

‘‘ᩈᨦ᩠ᨥᩣᨭᩥᩴ ᨶᩥᨠ᩠ᨡᩥᨸᩥᨲ᩠ᩅᩣᨶ, ᨸᨲ᩠ᨲᨠᨬ᩠ᨧ ᨶᩥᨠᩩᨩ᩠ᨩᩥᨿ;

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

‘‘ᨠᩥᨬ᩠ᨧᩣᨸᩥ ᨡᩮᩣᨾ᩠ᩉᩥ ᨴᩩᨠ᩠ᨡᩥᨲᩣ, ᨴᩩᨻ᩠ᨻᩃᩣ ᨣᨲᨿᩮᩣᨻ᩠ᨻᨶᩣ;

ᨴᨱ᩠ᨯᨾᩮᩣᩃᩩᨻ᩠ᨽ ᨣᨧ᩠ᨨᩣᨾᩥ, ᨸᨻ᩠ᨻᨲᩴ ᩋᨽᩥᩁᩪᩉᩥᨿ.

‘‘ᨶᩥᨠ᩠ᨡᩥᨸᩥᨲ᩠ᩅᩣᨶ ¶ ᩈᨦ᩠ᨥᩣᨭᩥᩴ, ᨸᨲ᩠ᨲᨠᨬ᩠ᨧ ᨶᩥᨠᩩᨩ᩠ᨩᩥᨿ;

ᨶᩥᩈᩥᨶ᩠ᨶᩣ ᨧᨾ᩠ᩉᩥ ᩈᩮᩃᨾ᩠ᩉᩥ, ᩋᨳ ᨧᩥᨲ᩠ᨲᩴ ᩅᩥᨾᩩᨧ᩠ᨧᩥ ᨾᩮ;

ᨲᩥᩔᩮᩣ ¶ ᩅᩥᨩ᩠ᨩᩣ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶ’’ᨶ᩠ᨲᩥ.

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

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

‘‘ᩏᨸᩮᩣᩈᨳᩴ ¶ ᩏᨸᩣᨣᨧ᩠ᨨᩥᩴ, ᨴᩮᩅᨠᩣᨿᩣᨽᩥᨶᨶ᩠ᨴᩥᨶᩦ;

ᩈᩣᨩ᩠ᨩ ᩑᨠᩮᨶ ᨽᨲ᩠ᨲᩮᨶ, ᨾᩩᨱ᩠ᨯᩣ ᩈᨦ᩠ᨥᩣᨭᩥᨸᩣᩁᩩᨲᩣ;

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

‘‘ᩏᨴ᩠ᨵᩴ ᨸᩣᨴᨲᩃᩣ ᩋᨾ᩠ᨾ, ᩋᨵᩮᩣ ᩅᩮ ᨠᩮᩈᨾᨲ᩠ᨳᨠᩣ;

ᨸᨧ᩠ᨧᩅᩮᨠ᩠ᨡᩔᩩᨾᩴ ᨠᩣᨿᩴ, ᩋᩈᩩᨧᩥᩴ ᨸᩪᨲᩥᨣᨶ᩠ᨵᩥᨠᩴ.

‘‘ᩑᩅᩴ ¶ ᩅᩥᩉᩁᨾᩣᨶᩣᨿ, ᩈᨻ᩠ᨻᩮᩣ ᩁᩣᨣᩮᩣ ᩈᨾᩪᩉᨲᩮᩣ;

ᨸᩁᩥᩊᩣᩉᩮᩣ ᩈᨾᩩᨧ᩠ᨨᩥᨶ᩠ᨶᩮᩣ, ᩈᩦᨲᩥᨽᩪᨲᩣᨾ᩠ᩉᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

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

ᨶᩥᨠ᩠ᨡᩥᨸᩥᩔᩣᨾᩥᨾᩴ ᨴᩮᩉᩴ, ᩈᨾ᩠ᨸᨩᩣᨶᩣ ᩈᨲᩦᨾᨲᩦ.

‘‘ᨻᩉᩪᩉᩥ ᨴᩩᨠ᩠ᨡᨵᨾ᩠ᨾᩮᩉᩥ, ᩋᨸ᩠ᨸᨾᩣᨴᩁᨲᩣᨿ ᨾᩮ;

ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᩮᩣ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᨧᨲᩩᨠ᩠ᨡᨲ᩠ᨲᩩᩴ ¶ ¶ ᨸᨬ᩠ᨧᨠ᩠ᨡᨲ᩠ᨲᩩᩴ, ᩅᩥᩉᩣᩁᩣ ᩏᨸᨶᩥᨠ᩠ᨡᨾᩥᩴ;

ᩋᩃᨴ᩠ᨵᩣ ᨧᩮᨲᩈᩮᩣ ᩈᨶ᩠ᨲᩥᩴ, ᨧᩥᨲ᩠ᨲᩮ ᩋᩅᩈᩅᨲ᩠ᨲᩥᨶᩦ;

ᨲᩔᩣ ᨾᩮ ᩋᨭ᩠ᨮᨾᩦ ᩁᨲ᩠ᨲᩥ, ᨿᨲᩮᩣ ᨲᨱ᩠ᩉᩣ ᩈᨾᩪᩉᨲᩣ.

‘‘ᨻᩉᩪᩉᩥ ᨴᩩᨠ᩠ᨡᨵᨾ᩠ᨾᩮᩉᩥ, ᩋᨸ᩠ᨸᨾᩣᨴᩁᨲᩣᨿ ᨾᩮ;

ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᩮᩣ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᨱ᩠ᨱᩅᩦᩈᨲᩥᩅᩔᩣᨶᩥ ¶ , ᨿᨲᩮᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩣᨿ ᨾᩮ;

ᨶᩣᨽᩥᨩᩣᨶᩣᨾᩥ ᨧᩥᨲ᩠ᨲᩔ, ᩈᨾᩴ ᩃᨴ᩠ᨵᩴ ᨠᩩᨴᩣᨧᨶᩴ.

‘‘ᩋᩃᨴ᩠ᨵᩣ ᨧᩮᨲᩈᩮᩣ ᩈᨶ᩠ᨲᩥᩴ, ᨧᩥᨲ᩠ᨲᩮ ᩋᩅᩈᩅᨲ᩠ᨲᩥᨶᩦ;

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

‘‘ᨻᩉᩪᩉᩥ ᨴᩩᨠ᩠ᨡᨵᨾ᩠ᨾᩮᩉᩥ, ᩋᨸ᩠ᨸᨾᩣᨴᩁᨲᩣᨿ ᨾᩮ;

ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᩮᩣ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶᩴ;

ᩋᨩ᩠ᨩ ¶ ᨾᩮ ᩈᨲ᩠ᨲᨾᩦ ᩁᨲ᩠ᨲᩥ, ᨿᨲᩮᩣ ᨲᨱ᩠ᩉᩣ ᩅᩥᩈᩮᩣᩈᩥᨲᩣ’’ᨲᩥ.

‘‘ᨧᨲᩩᨠ᩠ᨡᨲ᩠ᨲᩩᩴ ¶ ᨸᨬ᩠ᨧᨠ᩠ᨡᨲ᩠ᨲᩩᩴ, ᩅᩥᩉᩣᩁᩣ ᩏᨸᨶᩥᨠ᩠ᨡᨾᩥᩴ;

ᩋᩃᨴ᩠ᨵᩣ ᨧᩮᨲᩈᩮᩣ ᩈᨶ᩠ᨲᩥᩴ, ᨧᩥᨲ᩠ᨲᩮ ᩋᩅᩈᩅᨲ᩠ᨲᩥᨶᩦ.

‘‘ᩈᩣ ¶ ᨽᩥᨠ᩠ᨡᩩᨶᩥᩴ ᩏᨸᨣᨧ᩠ᨨᩥᩴ, ᨿᩣ ᨾᩮ ᩈᨴ᩠ᨵᩣᨿᩥᨠᩣ ᩋᩉᩩ;

ᩈᩣ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᨡᨶ᩠ᨵᩣᨿᨲᨶᨵᩣᨲᩩᨿᩮᩣ.

‘‘ᨲᩔᩣ ᨵᨾ᩠ᨾᩴ ᩈᩩᨱᩥᨲ᩠ᩅᩣᨶ, ᨿᨳᩣ ᨾᩴ ᩋᨶᩩᩈᩣᩈᩥ ᩈᩣ;

ᩈᨲ᩠ᨲᩣᩉᩴ ᩑᨠᨸᩃ᩠ᩃᨦ᩠ᨠᩮᨶ, ᨶᩥᩈᩦᨴᩥᩴ ᨸᩦᨲᩥᩈᩩᨡᩈᨾᨸ᩠ᨸᩥᨲᩣ [ᨶᩥᩈᩦᨴᩥᩴ ᩈᩩᨡᩈᨾᨸ᩠ᨸᩥᨲᩣ (ᩈᩦ.)];

ᩋᨭ᩠ᨮᨾᩥᨿᩣ ᨸᩣᨴᩮ ᨸᩈᩣᩁᩮᩈᩥᩴ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩴ ᨸᨴᩣᩃᩥᨿᩣ’’ᨲᩥ.

‘‘ᨿᩮ ᩍᨾᩮ ᩈᨲ᩠ᨲ ᨻᩮᩣᨩ᩠ᨫᨦ᩠ᨣᩣ, ᨾᨣ᩠ᨣᩣ ᨶᩥᨻ᩠ᨻᩣᨶᨸᨲ᩠ᨲᩥᨿᩣ;

ᨽᩣᩅᩥᨲᩣ ᨲᩮ ᨾᨿᩣ ᩈᨻ᩠ᨻᩮ, ᨿᨳᩣ ᨻᩩᨴ᩠ᨵᩮᨶ ᨴᩮᩈᩥᨲᩣ.

‘‘ᩈᩩᨬ᩠ᨬᨲᩔᩣᨶᩥᨾᩥᨲ᩠ᨲᩔ, ᩃᩣᨽᩥᨶᩦᩉᩴ ᨿᨴᩥᨧ᩠ᨨᨠᩴ;

ᩒᩁᩈᩣ ᨵᩦᨲᩣ ᨻᩩᨴ᩠ᨵᩔ, ᨶᩥᨻ᩠ᨻᩣᨶᩣᨽᩥᩁᨲᩣ ᩈᨴᩣ.

‘‘ᩈᨻ᩠ᨻᩮ ¶ ᨠᩣᨾᩣ ᩈᨾᩩᨧ᩠ᨨᩥᨶ᩠ᨶᩣ, ᨿᩮ ᨴᩥᨻ᩠ᨻᩣ ᨿᩮ ᨧ ᨾᩣᨶᩩᩈᩣ;

ᩅᩥᨠ᩠ᨡᩦᨱᩮᩣ ᨩᩣᨲᩥᩈᩴᩈᩣᩁᩮᩣ, ᨶᨲ᩠ᨳᩥ ᨴᩣᨶᩥ ᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ’’ᨲᩥ.

‘‘ᨴᩥᩅᩣᩅᩥᩉᩣᩁᩣ ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ, ᨣᩥᨩ᩠ᨫᨠᩪᨭᨾ᩠ᩉᩥ ᨸᨻ᩠ᨻᨲᩮ;

ᨶᩣᨣᩴ ᩒᨣᩣᩉᨾᩩᨲ᩠ᨲᩥᨱ᩠ᨱᩴ, ᨶᨴᩦᨲᩦᩁᨾ᩠ᩉᩥ ᩋᨴ᩠ᨴᩈᩴ.

‘‘ᨸᩩᩁᩥᩈᩮᩣ ᩋᨦ᩠ᨠᩩᩈᨾᩣᨴᩣᨿ, ‘ᨴᩮᩉᩥ ᨸᩣᨴ’ᨶ᩠ᨲᩥ ᨿᩣᨧᨲᩥ;

ᨶᩣᨣᩮᩣ ᨸᩈᩣᩁᨿᩦ ᨸᩣᨴᩴ, ᨸᩩᩁᩥᩈᩮᩣ ᨶᩣᨣᨾᩣᩁᩩᩉᩥ.

‘‘ᨴᩥᩈ᩠ᩅᩣ ¶ ᩋᨴᨶ᩠ᨲᩴ ᨴᨾᩥᨲᩴ, ᨾᨶᩩᩔᩣᨶᩴ ᩅᩈᩴ ᨣᨲᩴ;

ᨲᨲᩮᩣ ᨧᩥᨲ᩠ᨲᩴ ᩈᨾᩣᨵᩮᩈᩥᩴ, ᨡᩃᩩ ᨲᩣᨿ ᩅᨶᩴ ᨣᨲᩣ’’ᨲᩥ.

‘‘ᩋᨾ᩠ᨾ ᨩᩦᩅᩣᨲᩥ ᩅᨶᨾ᩠ᩉᩥ ᨠᨶ᩠ᨴᩈᩥ, ᩋᨲ᩠ᨲᩣᨶᩴ ᩋᨵᩥᨣᨧ᩠ᨨ ᩏᨻ᩠ᨻᩥᩁᩥ;

ᨧᩩᩃ᩠ᩃᩣᩈᩦᨲᩥᩈᩉᩔᩣᨶᩥ [ᨧᩪᩊᩣᩈᩦᨲᩥᩈᩉᩔᩣᨶᩥ (ᩈᩦ.)], ᩈᨻ᩠ᨻᩣ ᨩᩦᩅᩈᨶᩣᨾᩥᨠᩣ;

ᩑᨲᨾ᩠ᩉᩣᩊᩣᩉᨶᩮ ᨴᨯ᩠ᨰᩣ, ᨲᩣᩈᩴ ᨠᨾᨶᩩᩈᩮᩣᨧᩈᩥ.

‘‘ᩋᨻ᩠ᨻᩉᩦ ¶ ¶ [ᩋᨻ᩠ᨻᩩᨲᩦ (ᩈ᩠ᨿᩣ.), ᩋᨻ᩠ᨻᩩᩊ᩠ᩉᩴ (ᨠ.)] ᩅᨲ ᨾᩮ ᩈᩃ᩠ᩃᩴ, ᨴᩩᨴ᩠ᨴᩈᩴ ᩉᨴᨿᩔᩥᨲᩴ [ᩉᨴᨿᨶᩥᩔᩥᨲᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

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

‘‘ᩈᩣᨩ᩠ᨩ ᩋᨻ᩠ᨻᩪᩊ᩠ᩉᩈᩃ᩠ᩃᩣᩉᩴ, ᨶᩥᨧ᩠ᨨᩣᨲᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩣ;

ᨻᩩᨴ᩠ᨵᩴ ᨵᨾ᩠ᨾᨬ᩠ᨧ ᩈᨦ᩠ᨥᨬ᩠ᨧ, ᩏᨸᩮᨾᩥ ᩈᩁᨱᩴ ᨾᩩᨶᩥ’’ᨶ᩠ᨲᩥ.

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

ᨿᩮ ᩈᩩᨠ᩠ᨠᩴ ᨶ ᩏᨸᩣᩈᨶ᩠ᨲᩥ, ᨴᩮᩈᩮᨶ᩠ᨲᩥᩴ ᨻᩩᨴ᩠ᨵᩈᩣᩈᨶᩴ.

‘‘ᨲᨬ᩠ᨧ ᩋᨸ᩠ᨸᨭᩥᩅᩣᨶᩦᨿᩴ, ᩋᩈᩮᨧᨶᨠᨾᩮᩣᨩᩅᩴ;

ᨸᩥᩅᨶ᩠ᨲᩥ ᨾᨬ᩠ᨬᩮ ᩈᨸ᩠ᨸᨬ᩠ᨬᩣ, ᩅᩃᩣᩉᨠᨾᩥᩅᨴ᩠ᨵᨣᩪ.

‘‘ᩈᩩᨠ᩠ᨠᩣ ¶ ᩈᩩᨠ᩠ᨠᩮᩉᩥ ᨵᨾ᩠ᨾᩮᩉᩥ, ᩅᩦᨲᩁᩣᨣᩣ ᩈᨾᩣᩉᩥᨲᩣ;

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

‘‘ᨶᨲ᩠ᨳᩥ ᨶᩥᩔᩁᨱᩴ ᩃᩮᩣᨠᩮ, ᨠᩥᩴ ᩅᩥᩅᩮᨠᩮᨶ ᨠᩣᩉᩈᩥ;

ᨽᩩᨬ᩠ᨩᩣᩉᩥ ¶ ᨠᩣᨾᩁᨲᩥᨿᩮᩣ, ᨾᩣᩉᩩ ᨸᨧ᩠ᨨᩣᨶᩩᨲᩣᨸᩥᨶᩦ’’.

‘‘ᩈᨲ᩠ᨲᩥᩈᩪᩃᩪᨸᨾᩣ ᨠᩣᨾᩣ, ᨡᨶ᩠ᨵᩣᩈᩴ ᩋᨵᩥᨠᩩᨭ᩠ᨭᨶᩣ;

ᨿᩴ ᨲ᩠ᩅᩴ ‘ᨠᩣᨾᩁᨲᩥᩴ’ ᨻᩕᩪᩈᩥ, ‘ᩋᩁᨲᩦ’ ᨴᩣᨶᩥ ᩈᩣ ᨾᨾ.

‘‘ᩈᨻ᩠ᨻᨲ᩠ᨳ ᩅᩥᩉᨲᩣ ᨶᨶ᩠ᨴᩦ [ᨶᨶ᩠ᨴᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᨲᨾᩮᩣᨡᨶ᩠ᨵᩮᩣ ᨸᨴᩣᩃᩥᨲᩮᩣ;

ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨸᩣᨸᩥᨾ, ᨶᩥᩉᨲᩮᩣ ᨲ᩠ᩅᨾᩈᩥ ᩋᨶ᩠ᨲᨠᩣ’’ᨲᩥ.

‘‘ᨿᩴ ᨲᩴ ᩍᩈᩦᩉᩥ ᨸᨲ᩠ᨲᨻ᩠ᨻᩴ, ᨮᩣᨶᩴ ᨴᩩᩁᨽᩥᩈᨾ᩠ᨽᩅᩴ;

ᨶ ᨲᩴ ᨴ᩠ᩅᨦ᩠ᨣᩩᩃᨸᨬ᩠ᨬᩣᨿ, ᩈᨠ᩠ᨠᩣ ᨸᨸ᩠ᨸᩮᩣᨲᩩᨾᩥᨲ᩠ᨳᩥᨿᩣ’’.

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

ᨬᩣᨱᨾ᩠ᩉᩥ ᩅᨲ᩠ᨲᨾᩣᨶᨾ᩠ᩉᩥ, ᩈᨾ᩠ᨾᩣ ᨵᨾ᩠ᨾᩴ ᩅᩥᨸᩔᨲᩮᩣ.

‘‘ᩈᨻ᩠ᨻᨲ᩠ᨳ ¶ ¶ ᩅᩥᩉᨲᩣ ᨶᨶ᩠ᨴᩦ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩮᩣ ᨸᨴᩣᩃᩥᨲᩮᩣ;

ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨸᩣᨸᩥᨾ, ᨶᩥᩉᨲᩮᩣ ᨲ᩠ᩅᨾᩈᩥ ᩋᨶ᩠ᨲᨠᩣ’’ᨲᩥ.

‘‘ᨸᩩᨲ᩠ᨲᩮᩣ ¶ ᨻᩩᨴ᩠ᨵᩔ ᨴᩣᨿᩣᨴᩮᩣ, ᨠᩔᨸᩮᩣ ᩈᩩᩈᨾᩣᩉᩥᨲᩮᩣ;

ᨸᩩᨻ᩠ᨻᩮᨶᩥᩅᩣᩈᩴ ᨿᩮᩣᩅᩮᨴᩥ, ᩈᨣ᩠ᨣᩣᨸᩣᨿᨬ᩠ᨧ ᨸᩔᨲᩥ.

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

ᩑᨲᩣᩉᩥ ᨲᩦᩉᩥ ᩅᩥᨩ᩠ᨩᩣᩉᩥ, ᨲᩮᩅᩥᨩ᩠ᨩᩮᩣ ᩉᩮᩣᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨲᨳᩮᩅ ᨽᨴ᩠ᨴᩣ ᨠᩣᨸᩥᩃᩣᨶᩦ, ᨲᩮᩅᩥᨩ᩠ᨩᩣ ᨾᨧ᩠ᨧᩩᩉᩣᨿᩥᨶᩦ;

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

‘‘ᨴᩥᩈ᩠ᩅᩣ ᩌᨴᩦᨶᩅᩴ ᩃᩮᩣᨠᩮ, ᩏᨽᩮᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩣ ᨾᨿᩴ;

ᨲ᩠ᨿᨾ᩠ᩉ ᨡᩦᨱᩣᩈᩅᩣ ᨴᨶ᩠ᨲᩣ, ᩈᩦᨲᩥᨽᩪᨲᨾ᩠ᩉ ᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

‘‘ᨸᨱ᩠ᨱᩅᩦᩈᨲᩥᩅᩔᩣᨶᩥ ¶ ¶ , ᨿᨲᩮᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩣ ᩋᩉᩴ;

ᨶᩣᨧ᩠ᨨᩁᩣᩈᨦ᩠ᨥᩣᨲᨾᨲ᩠ᨲᨾ᩠ᨸᩥ, ᨧᩥᨲ᩠ᨲᩔᩪᨸᩈᨾᨩ᩠ᨫᨣᩴ.

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

ᨻᩣᩉᩣ ᨸᨣ᩠ᨣᨿ᩠ᩉ ᨠᨶ᩠ᨴᨶ᩠ᨲᩦ, ᩅᩥᩉᩣᩁᩴ ᨸᩣᩅᩥᩈᩥᩴ ᩋᩉᩴ.

‘‘ᩈᩣ ᨽᩥᨠ᩠ᨡᩩᨶᩥᩴ ᩏᨸᩣᨣᨧ᩠ᨨᩥᩴ, ᨿᩣ ᨾᩮ ᩈᨴ᩠ᨵᩣᨿᩥᨠᩣ ᩋᩉᩩ;

ᩈᩣ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᨡᨶ᩠ᨵᩣᨿᨲᨶᨵᩣᨲᩩᨿᩮᩣ.

‘‘ᨲᩔᩣ ᨵᨾ᩠ᨾᩴ ᩈᩩᨱᩥᨲ᩠ᩅᩣᨶ, ᩑᨠᨾᨶ᩠ᨲᩮ ᩏᨸᩣᩅᩥᩈᩥᩴ;

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

‘‘ᨧᩮᨲᩮᩣᨸᩁᩥᨧ᩠ᨧᨬᩣᨱᨬ᩠ᨧ ¶ ¶ [ᨧᩮᨲᩮᩣᨸᩁᩥᨿᨬᩣᨱᨬ᩠ᨧ (ᨠ.)], ᩈᩮᩣᨲᨵᩣᨲᩩ ᩅᩥᩈᩮᩣᨵᩥᨲᩣ;

ᩍᨴ᩠ᨵᩦᨸᩥ ᨾᩮ ᩈᨧ᩠ᨨᩥᨠᨲᩣ, ᨸᨲ᩠ᨲᩮᩣ ᨾᩮ ᩌᩈᩅᨠ᩠ᨡᨿᩮᩣ;

ᨨᩊᨽᩥᨬ᩠ᨬᩣ [ᨨ ᨾᩮᨽᩥᨬ᩠ᨬᩣ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩈᨧ᩠ᨨᩥᨠᨲᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᨾᨲ᩠ᨲᩣ ᩅᨱ᩠ᨱᩮᨶ ᩁᩪᨸᩮᨶ, ᩈᩮᩣᨽᨣ᩠ᨣᩮᨶ ᨿᩈᩮᨶ ᨧ;

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

‘‘ᩅᩥᨽᩪᩈᩮᨲ᩠ᩅᩣ ᩍᨾᩴ ᨠᩣᨿᩴ, ᩈᩩᨧᩥᨲ᩠ᨲᩴ ᨻᩣᩃᩃᩣᨸᨶᩴ;

ᩋᨭ᩠ᨮᩣᩈᩥᩴ ᩅᩮᩈᩥᨴ᩠ᩅᩣᩁᨾ᩠ᩉᩥ, ᩃᩩᨴ᩠ᨴᩮᩣ ᨸᩣᩈᨾᩥᩅᩮᩣᨯ᩠ᨯᩥᨿ.

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

ᩋᨠᩣᩈᩥᩴ ᩅᩥᩅᩥᨵᩴ ᨾᩣᨿᩴ, ᩏᨩ᩠ᨩᨣ᩠ᨥᨶ᩠ᨲᩦ ᨻᩉᩩᩴ ᨩᨶᩴ.

‘‘ᩈᩣᨩ᩠ᨩ ᨸᩥᨱ᩠ᨯᩴ ᨧᩁᩥᨲ᩠ᩅᩣᨶ, ᨾᩩᨱ᩠ᨯᩣ ᩈᨦ᩠ᨥᩣᨭᩥᨸᩣᩁᩩᨲᩣ;

ᨶᩥᩈᩥᨶ᩠ᨶᩣ ᩁᩩᨠ᩠ᨡᨾᩪᩃᨾ᩠ᩉᩥ, ᩋᩅᩥᨲᨠ᩠ᨠᩔ ᩃᩣᨽᩥᨶᩦ.

‘‘ᩈᨻ᩠ᨻᩮ ᨿᩮᩣᨣᩣ ᩈᨾᩩᨧ᩠ᨨᩥᨶ᩠ᨶᩣ, ᨿᩮ ᨴᩥᨻ᩠ᨻᩣ ᨿᩮ ᨧ ᨾᩣᨶᩩᩈᩣ;

ᨡᩮᨸᩮᨲ᩠ᩅᩣ ᩌᩈᩅᩮ ᩈᨻ᩠ᨻᩮ, ᩈᩦᨲᩥᨽᩪᨲᩣᨾ᩠ᩉᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

‘‘ᩋᨿᩮᩣᨶᩥᩈᩮᩣ ¶ ¶ ᨾᨶᩈᩥᨠᩣᩁᩣ, ᨠᩣᨾᩁᩣᨣᩮᨶ ᩋᨭ᩠ᨭᩥᨲᩣ;

ᩋᩉᩮᩣᩈᩥᩴ ᩏᨴ᩠ᨵᨲᩣ ᨸᩩᨻ᩠ᨻᩮ, ᨧᩥᨲ᩠ᨲᩮ ᩋᩅᩈᩅᨲ᩠ᨲᩥᨶᩦ.

‘‘ᨸᩁᩥᨿᩩᨭ᩠ᨮᩥᨲᩣ ᨠ᩠ᩃᩮᩈᩮᩉᩥ, ᩈᩩᨽᩈᨬ᩠ᨬᩣᨶᩩᩅᨲ᩠ᨲᩥᨶᩦ;

ᩈᨾᩴ ᨧᩥᨲ᩠ᨲᩔ ᨶ ᩃᨽᩥᩴ, ᩁᩣᨣᨧᩥᨲ᩠ᨲᩅᩈᩣᨶᩩᨣᩣ.

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

ᨶᩣᩉᩴ ᨴᩥᩅᩣ ᩅᩣ ᩁᨲ᩠ᨲᩥᩴ ᩅᩣ, ᩈᩩᨡᩴ ᩅᩥᨶ᩠ᨴᩥᩴ ᩈᩩᨴᩩᨠ᩠ᨡᩥᨲᩣ.

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

ᩅᩁᩴ ᨾᩮ ᩍᨵ ᩏᨻ᩠ᨻᨶ᩠ᨵᩴ, ᨿᨬ᩠ᨧ ᩉᩦᨶᩴ ᨸᩩᨶᩣᨧᩁᩮ.

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

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

‘‘ᩌᨲᩩᩁᩴ ᩋᩈᩩᨧᩥᩴ ᨸᩪᨲᩥᩴ, ᨸᩔ ᨶᨶ᩠ᨴᩮ ᩈᨾᩩᩔᨿᩴ;

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

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

ᨴᩩᨣ᩠ᨣᨶ᩠ᨵᩴ ᨸᩪᨲᩥᨠᩴ ᩅᩣᨲᩥ, ᨻᩣᩃᩣᨶᩴ ᩋᨽᩥᨶᨶ᩠ᨴᩥᨲᩴ.

‘‘ᩑᩅᨾᩮᨲᩴ ᩋᩅᩮᨠ᩠ᨡᨶ᩠ᨲᩦ, ᩁᨲ᩠ᨲᩥᨶ᩠ᨴᩥᩅᨾᨲᨶ᩠ᨴᩥᨲᩣ;

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

‘‘ᨲᩔᩣ ᨾᩮ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩣᨿ, ᩅᩥᨧᩥᨶᨶ᩠ᨲᩥᨿᩣ ᨿᩮᩣᨶᩥᩈᩮᩣ;

ᨿᨳᩣᨽᩪᨲᩴ ᩋᨿᩴ ᨠᩣᨿᩮᩣ, ᨴᩥᨭ᩠ᨮᩮᩣ ᩈᨶ᩠ᨲᩁᨻᩣᩉᩥᩁᩮᩣ.

‘‘ᩋᨳ ᨶᩥᨻ᩠ᨻᩥᨶ᩠ᨴᩉᩴ ᨠᩣᨿᩮ, ᩋᨩ᩠ᨫᨲ᩠ᨲᨬ᩠ᨧ ᩅᩥᩁᨩ᩠ᨩᩉᩴ;

ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩣ ᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩣ, ᩏᨸᩈᨶ᩠ᨲᩣᨾ᩠ᩉᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

‘‘ᩋᨣ᩠ᨣᩥᩴ ¶ ᨧᨶ᩠ᨴᨬ᩠ᨧ ᩈᩪᩁᩥᨿᨬ᩠ᨧ, ᨴᩮᩅᨲᩣ ᨧ ᨶᨾᩔᩥᩉᩴ;

ᨶᨴᩦᨲᩥᨲ᩠ᨳᩣᨶᩥ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ, ᩏᨴᨠᩴ ᩒᩁᩩᩉᩣᨾᩥᩉᩴ.

‘‘ᨻᩉᩪᩅᨲᩈᨾᩣᨴᩣᨶᩣ ¶ ¶ , ᩋᨯ᩠ᨰᩴ ᩈᩦᩈᩔ ᩒᩃᩥᨡᩥᩴ;

ᨨᨾᩣᨿ ᩈᩮᨿ᩠ᨿᩴ ᨠᨸ᩠ᨸᩮᨾᩥ, ᩁᨲ᩠ᨲᩥᩴ ᨽᨲ᩠ᨲᩴ ᨶ ᨽᩩᨬ᩠ᨩᩉᩴ.

‘‘ᩅᩥᨽᩪᩈᩣᨾᨱ᩠ᨯᨶᩁᨲᩣ, ᨶ᩠ᩉᩣᨸᨶᩩᨧ᩠ᨨᩣᨴᨶᩮᩉᩥ ᨧ;

ᩏᨸᨠᩣᩈᩥᩴ ᩍᨾᩴ ᨠᩣᨿᩴ, ᨠᩣᨾᩁᩣᨣᩮᨶ ᩋᨭ᩠ᨭᩥᨲᩣ.

‘‘ᨲᨲᩮᩣ ᩈᨴ᩠ᨵᩴ ᩃᨽᩥᨲ᩠ᩅᩣᨶ, ᨸᨻ᩠ᨻᨩᩥᩴ ᩋᨶᨣᩣᩁᩥᨿᩴ;

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

‘‘ᩈᨻ᩠ᨻᩮ ᨽᩅᩣ ᩈᨾᩩᨧ᩠ᨨᩥᨶ᩠ᨶᩣ, ᩍᨧ᩠ᨨᩣ ᨧ ᨸᨲ᩠ᨳᨶᩣᨸᩥ ᨧ;

ᩈᨻ᩠ᨻᨿᩮᩣᨣᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩣ, ᩈᨶ᩠ᨲᩥᩴ ᨸᩣᨸᩩᨱᩥ ᨧᩮᨲᩈᩮᩣ’’ᨲᩥ.

‘‘ᩈᨴ᩠ᨵᩣᨿ ᨸᨻ᩠ᨻᨩᩥᨲ᩠ᩅᩣᨶ, ᩋᨣᩣᩁᩈ᩠ᨾᩣᨶᨣᩣᩁᩥᨿᩴ;

ᩅᩥᨧᩁᩥᩴᩉᩴ ᨲᩮᨶ ᨲᩮᨶ, ᩃᩣᨽᩈᨠ᩠ᨠᩣᩁᩏᩔᩩᨠᩣ.

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

ᨠᩥᩃᩮᩈᩣᨶᩴ ᩅᩈᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩈᩣᨾᨬ᩠ᨬᨲ᩠ᨳᩴ ᨶ ᨻᩩᨩ᩠ᨫᩥᩉᩴ.

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

ᩏᨾ᩠ᨾᨣ᩠ᨣᨸᨭᩥᨸᨶ᩠ᨶᩣᨾ᩠ᩉᩥ, ᨲᨱ᩠ᩉᩣᨿ ᩅᩈᨾᩣᨣᨲᩣ.

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

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

‘‘ᨿᨳᩣᨽᩪᨲᨾᩅᩮᨠ᩠ᨡᨶ᩠ᨲᩦ, ᨡᨶ᩠ᨵᩣᨶᩴ ᩏᨴᨿᨻ᩠ᨻᨿᩴ;

ᩅᩥᨾᩩᨲ᩠ᨲᨧᩥᨲ᩠ᨲᩣ ᩏᨭ᩠ᨮᩣᩈᩥᩴ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶ’’ᨶ᩠ᨲᩥ.

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

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

‘‘ᩈᩣᩉᩴ ᨸᩩᨲ᩠ᨲᩴ ᨵᩦᨲᩁᨬ᩠ᨧ, ᨵᨶᨵᨬ᩠ᨬᨬ᩠ᨧ ᨨᨯ᩠ᨯᩥᨿ;

ᨠᩮᩈᩮ ᨨᩮᨴᩣᨸᨿᩥᨲ᩠ᩅᩣᨶ, ᨸᨻ᩠ᨻᨩᩥᩴ ᩋᨶᨣᩣᩁᩥᨿᩴ.

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

ᨸᩉᩣᩈᩥᩴ ᩁᩣᨣᨴᩮᩣᩈᨬ᩠ᨧ, ᨲᨴᩮᨠᨭ᩠ᨮᩮ ᨧ ᩌᩈᩅᩮ.

‘‘ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᩏᨸᩈᨾ᩠ᨸᨩ᩠ᨩ, ᨸᩩᨻ᩠ᨻᨩᩣᨲᩥᨾᨶᩩᩔᩁᩥᩴ;

ᨴᩥᨻ᩠ᨻᨧᨠ᩠ᨡᩩ ᩅᩥᩈᩮᩣᨵᩥᨲᩴ [ᩅᩥᩈᩮᩣᨵᩥᨲᩴ ᨴᩥᨻ᩠ᨻᨧᨠ᩠ᨡᩩ (ᩈᩦ.)], ᩅᩥᨾᩃᩴ ᩈᩣᨵᩩᨽᩣᩅᩥᨲᩴ.

‘‘ᩈᨦ᩠ᨡᩣᩁᩮ ᨸᩁᨲᩮᩣ ᨴᩥᩈ᩠ᩅᩣ, ᩉᩮᨲᩩᨩᩣᨲᩮ ᨸᩃᩮᩣᨠᩥᨲᩮ [ᨸᩃᩮᩣᨠᩥᨶᩮ (ᨠ.)];

ᨸᩉᩣᩈᩥᩴ ᩌᩈᩅᩮ ᩈᨻ᩠ᨻᩮ, ᩈᩦᨲᩥᨽᩪᨲᩣᨾ᩠ᩉᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩣ’’ᨲᩥ.

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

ᨲᨲᩮᩣᩉᩴ ᨴᩩᨻ᩠ᨻᩃᩣ ᨩᩥᨱ᩠ᨱᩣ, ᨽᩥᨠ᩠ᨡᩩᨶᩥᩴ ᩏᨸᩈᨦ᩠ᨠᨾᩥᩴ.

‘‘ᩈᩣ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᨡᨶ᩠ᨵᩣᨿᨲᨶᨵᩣᨲᩩᨿᩮᩣ;

ᨲᩔᩣ ᨵᨾ᩠ᨾᩴ ᩈᩩᨱᩥᨲ᩠ᩅᩣᨶ, ᨠᩮᩈᩮ ᨨᩮᨲ᩠ᩅᩣᨶ ᨸᨻ᩠ᨻᨩᩥᩴ.

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

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

‘‘ᩋᨶᩥᨾᩥᨲ᩠ᨲᨬ᩠ᨧ ¶ ᨽᩣᩅᩮᨾᩥ, ᩑᨠᨣ᩠ᨣᩣ ᩈᩩᩈᨾᩣᩉᩥᨲᩣ;

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

‘‘ᨸᨬ᩠ᨧᨠ᩠ᨡᨶ᩠ᨵᩣ ᨸᩁᩥᨬ᩠ᨬᩣᨲᩣ, ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᨨᩥᨶ᩠ᨶᨾᩪᩃᨠᩣ;

ᨵᩥ ¶ ᨲᩅᨲ᩠ᨳᩩ ᨩᩁᩮ ᨩᨾ᩠ᨾᩮ, ᨶᨲ᩠ᨳᩥ ᨴᩣᨶᩥ ᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ’’ᨲᩥ.

‘‘ᩃᩪᨶᨠᩮᩈᩦ ¶ ᨸᨦ᩠ᨠᨵᩁᩦ, ᩑᨠᩈᩣᨭᩦ ᨸᩩᩁᩮ ᨧᩁᩥᩴ;

ᩋᩅᨩ᩠ᨩᩮ ᩅᨩ᩠ᨩᨾᨲᩥᨶᩦ, ᩅᨩ᩠ᨩᩮ ᨧᩣᩅᨩ᩠ᨩᨴᩔᩥᨶᩦ.

‘‘ᨴᩥᩅᩣᩅᩥᩉᩣᩁᩣ ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ, ᨣᩥᨩ᩠ᨫᨠᩪᨭᨾ᩠ᩉᩥ ᨸᨻ᩠ᨻᨲᩮ;

ᩋᨴ᩠ᨴᩈᩴ ᩅᩥᩁᨩᩴ ᨻᩩᨴ᩠ᨵᩴ, ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᨸᩩᩁᨠ᩠ᨡᨲᩴ.

‘‘ᨶᩥᩉᨧ᩠ᨧ ᨩᩣᨱᩩᩴ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ, ᩈᨾ᩠ᨾᩩᨡᩣ ᩋᨬ᩠ᨩᩃᩥᩴ ᩋᨠᩴ;

‘ᩑᩉᩥ ᨽᨴ᩠ᨴᩮ’ᨲᩥ ᨾᩴ ᩋᩅᨧ, ᩈᩣ ᨾᩮ ᩌᩈᩪᨸᩈᨾ᩠ᨸᨴᩣ.

‘‘ᨧᩥᨱ᩠ᨱᩣ ¶ ᩋᨦ᩠ᨣᩣ ᨧ ᨾᨣᨵᩣ, ᩅᨩ᩠ᨩᩦ ᨠᩣᩈᩦ ᨧ ᨠᩮᩣᩈᩃᩣ;

ᩋᨶᨱᩣ ᨸᨱ᩠ᨱᩣᩈᩅᩔᩣᨶᩥ, ᩁᨭ᩠ᨮᨸᩥᨱ᩠ᨯᩴ ᩋᨽᩩᨬ᩠ᨩᩉᩴ.

‘‘ᨸᩩᨬ᩠ᨬᩴ ᩅᨲ ᨸᩈᩅᩥ ᨻᩉᩩᩴ, ᩈᨸ᩠ᨸᨬ᩠ᨬᩮᩣ ᩅᨲᩣᨿᩴ ᩏᨸᩣᩈᨠᩮᩣ;

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

‘‘ᨶᨦ᩠ᨣᩃᩮᩉᩥ ᨠᩈᩴ ᨡᩮᨲ᩠ᨲᩴ, ᨻᩦᨩᩣᨶᩥ ᨸᩅᨸᩴ ᨨᨾᩣ;

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

‘‘ᨠᩥᨾᩉᩴ ᩈᩦᩃᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩈᨲ᩠ᨳᩩᩈᩣᩈᨶᨠᩣᩁᩥᨠᩣ;

ᨶᩥᨻ᩠ᨻᩣᨶᩴ ᨶᩣᨵᩥᨣᨧ᩠ᨨᩣᨾᩥ, ᩋᨠᩩᩈᩦᨲᩣ ᩋᨶᩩᨴ᩠ᨵᨲᩣ.

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

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

‘‘ᨲᨲᩮᩣ ᨧᩥᨲ᩠ᨲᩴ ᩈᨾᩣᨵᩮᩈᩥᩴ, ᩋᩔᩴ ᨽᨴᩕᩴᩅᨩᩣᨶᩥᨿᩴ;

ᨲᨲᩮᩣ ¶ ᨴᩦᨸᩴ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᩅᩥᩉᩣᩁᩴ ᨸᩣᩅᩥᩈᩥᩴ ᩋᩉᩴ;

ᩈᩮᨿ᩠ᨿᩴ ᩒᩃᩮᩣᨠᨿᩥᨲ᩠ᩅᩣᨶ, ᨾᨬ᩠ᨧᨠᨾ᩠ᩉᩥ ᩏᨸᩣᩅᩥᩈᩥᩴ.

‘‘ᨲᨲᩮᩣ ᩈᩪᨧᩥᩴ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᩅᨭ᩠ᨭᩥᩴ ᩒᨠᩔᨿᩣᨾᩉᩴ;

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

‘‘‘ᨾᩩᩈᩃᩣᨶᩥ ¶ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᨵᨬ᩠ᨬᩴ ᨠᩮᩣᨭ᩠ᨭᩮᨶ᩠ᨲᩥ ᨾᩣᨱᩅᩣ [ᨾᩣᨶᩅᩣ (ᩈᩦ.)];

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

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

ᨡᩥᨸ᩠ᨸᩴ ᨸᩣᨴᩣᨶᩥ ᨵᩮᩣᩅᩥᨲ᩠ᩅᩣ, ᩑᨠᨾᨶ᩠ᨲᩮ ᨶᩥᩈᩦᨴᨳ;

ᨧᩮᨲᩮᩣᩈᨾᨳᨾᨶᩩᨿᩩᨲ᩠ᨲᩣ, ᨠᩁᩮᩣᨳ ᨻᩩᨴ᩠ᨵᩈᩣᩈᨶᩴ’.

‘‘ᨲᩔᩣ ᨲᩣ [ᨲᩴ (ᩈᩦ.)] ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨸᨭᩣᨧᩣᩁᩣᨿ ᩈᩣᩈᨶᩴ;

ᨸᩣᨴᩮ ᨸᨠ᩠ᨡᩣᩃᨿᩥᨲ᩠ᩅᩣᨶ, ᩑᨠᨾᨶ᩠ᨲᩴ ᩏᨸᩣᩅᩥᩈᩩᩴ;

ᨧᩮᨲᩮᩣᩈᨾᨳᨾᨶᩩᨿᩩᨲ᩠ᨲᩣ, ᩋᨠᩴᩈᩩ ᨻᩩᨴ᩠ᨵᩈᩣᩈᨶᩴ.

‘‘ᩁᨲ᩠ᨲᩥᨿᩣ ¶ ᨸᩩᩁᩥᨾᩮ ᨿᩣᨾᩮ, ᨸᩩᨻ᩠ᨻᨩᩣᨲᩥᨾᨶᩩᩔᩁᩩᩴ;

ᩁᨲ᩠ᨲᩥᨿᩣ ᨾᨩ᩠ᨫᩥᨾᩮ ᨿᩣᨾᩮ, ᨴᩥᨻ᩠ᨻᨧᨠ᩠ᨡᩩᩴ ᩅᩥᩈᩮᩣᨵᨿᩩᩴ;

ᩁᨲ᩠ᨲᩥᨿᩣ ᨸᨧ᩠ᨨᩥᨾᩮ ᨿᩣᨾᩮ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩴ ᨸᨴᩣᩃᨿᩩᩴ.

‘‘ᩏᨭ᩠ᨮᩣᨿ ᨸᩣᨴᩮ ᩅᨶ᩠ᨴᩥᩴᩈᩩ, ‘ᨠᨲᩣ ᨲᩮ ᩋᨶᩩᩈᩣᩈᨶᩦ;

ᩍᨶ᩠ᨴᩴᩅ ¶ ᨴᩮᩅᩣ ᨲᩥᨴᩈᩣ, ᩈᨦ᩠ᨣᩣᨾᩮ ᩋᨸᩁᩣᨩᩥᨲᩴ;

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

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᨲᩥᩴᩈᨾᨲ᩠ᨲᩣ ᨳᩮᩁᩦ ᨽᩥᨠ᩠ᨡᩩᨶᩥᨿᩮᩣ ᨸᨭᩣᨧᩣᩁᩣᨿ ᩈᨶ᩠ᨲᩥᨠᩮ ᩋᨬ᩠ᨬᩴ ᨻ᩠ᨿᩣᨠᩁᩥᩴᩈᩪᨲᩥ.

‘‘ᨴᩩᨣ᩠ᨣᨲᩣᩉᩴ ᨸᩩᩁᩮ ᩌᩈᩥᩴ, ᩅᩥᨵᩅᩣ ᨧ ᩋᨸᩩᨲ᩠ᨲᩥᨠᩣ;

ᩅᩥᨶᩣ ᨾᩥᨲ᩠ᨲᩮᩉᩥ ᨬᩣᨲᩦᩉᩥ, ᨽᨲ᩠ᨲᨧᩮᩣᩊᩔ ᨶᩣᨵᩥᨣᩴ.

‘‘ᨸᨲ᩠ᨲᩴ ᨴᨱ᩠ᨯᨬ᩠ᨧ ᨣᨱ᩠ᩉᩥᨲ᩠ᩅᩣ, ᨽᩥᨠ᩠ᨡᨾᩣᨶᩣ ᨠᩩᩃᩣ ᨠᩩᩃᩴ;

ᩈᩦᨲᩩᨱ᩠ᩉᩮᨶ ᨧ ᨯᨿ᩠ᩉᨶ᩠ᨲᩦ, ᩈᨲ᩠ᨲ ᩅᩔᩣᨶᩥ ᨧᩣᩁᩥᩉᩴ.

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

ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ ᩋᩅᩮᩣᨧᩴ [ᩋᩅᩮᩣᨧᩥᩴ (ᨠ.)], ‘ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ ᩋᨶᨣᩣᩁᩥᨿᩴ’.

‘‘ᩈᩣ ¶ ᨧ ᨾᩴ ᩋᨶᩩᨠᨾ᩠ᨸᩣᨿ, ᨸᨻ᩠ᨻᩣᨩᩮᩈᩥ ᨸᨭᩣᨧᩣᩁᩣ;

ᨲᨲᩮᩣ ᨾᩴ ᩒᩅᨴᩥᨲ᩠ᩅᩣᨶ, ᨸᩁᨾᨲ᩠ᨳᩮ ᨶᩥᨿᩮᩣᨩᨿᩥ.

‘‘ᨲᩔᩣᩉᩴ ¶ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩋᨠᩣᩈᩥᩴ ᩋᨶᩩᩈᩣᩈᨶᩥᩴ;

ᩋᨾᩮᩣᨥᩮᩣ ᩋᨿ᩠ᨿᩣᨿᩮᩣᩅᩣᨴᩮᩣ, ᨲᩮᩅᩥᨩ᩠ᨩᩣᨾ᩠ᩉᩥ ᩋᨶᩣᩈᩅᩣ’’ᨲᩥ.

‘‘ᨿᩔ ¶ ᨾᨣ᩠ᨣᩴ ᨶ ᨩᩣᨶᩣᩈᩥ, ᩌᨣᨲᩔ ᨣᨲᩔ ᩅᩣ;

ᨲᩴ ¶ ᨠᩩᨲᩮᩣ ᨧᩣᨣᨲᩴ ᩈᨲ᩠ᨲᩴ [ᩈᨶ᩠ᨲᩴ (ᩈᩦ.), ᨸᩩᨲ᩠ᨲᩴ (ᩈ᩠ᨿᩣ.)], ‘ᨾᨾ ᨸᩩᨲ᩠ᨲᩮᩣ’ᨲᩥ ᩁᩮᩣᨴᩈᩥ.

‘‘ᨾᨣ᩠ᨣᨬ᩠ᨧ ᨡᩮᩣᩔ [ᨡᩮᩣ’ᨳ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨩᩣᨶᩣᩈᩥ, ᩌᨣᨲᩔ ᨣᨲᩔ ᩅᩣ;

ᨶ ᨶᩴ ᩈᨾᨶᩩᩈᩮᩣᨧᩮᩈᩥ, ᩑᩅᩴᨵᨾ᩠ᨾᩣ ᩉᩥ ᨸᩣᨱᩥᨶᩮᩣ.

‘‘ᩋᨿᩣᨧᩥᨲᩮᩣ ᨲᨲᩣᨣᨧ᩠ᨨᩥ, ᨶᩣᨶᩩᨬ᩠ᨬᩣᨲᩮᩣ [ᩋᨶᨶᩩᨬ᩠ᨬᩣᨲᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᩍᨲᩮᩣ ᨣᨲᩮᩣ;

ᨠᩩᨲᩮᩣᨧᩥ ᨶᩪᨶ ᩌᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩅᩈᩥᨲ᩠ᩅᩣ ᨠᨲᩥᨸᩣᩉᨠᩴ;

ᩍᨲᩮᩣᨸᩥ ᩋᨬ᩠ᨬᩮᨶ ᨣᨲᩮᩣ, ᨲᨲᩮᩣᨸᨬ᩠ᨬᩮᨶ ᨣᨧ᩠ᨨᨲᩥ.

‘‘ᨸᩮᨲᩮᩣ ᨾᨶᩩᩔᩁᩪᨸᩮᨶ, ᩈᩴᩈᩁᨶ᩠ᨲᩮᩣ ᨣᨾᩥᩔᨲᩥ;

ᨿᨳᩣᨣᨲᩮᩣ ᨲᨳᩣ ᨣᨲᩮᩣ, ᨠᩣ ᨲᨲ᩠ᨳ ᨸᩁᩥᨴᩮᩅᨶᩣ’’.

‘‘ᩋᨻ᩠ᨻᩉᩦ [ᩋᨻ᩠ᨻᩩᨿ᩠ᩉᩴ (ᩈ᩠ᨿᩣ.)] ᩅᨲ ᨾᩮ ᩈᩃ᩠ᩃᩴ, ᨴᩩᨴ᩠ᨴᩈᩴ ᩉᨴᨿᩔᩥᨲᩴ;

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

‘‘ᩈᩣᨩ᩠ᨩ ᩋᨻ᩠ᨻᩪᩊ᩠ᩉᩈᩃ᩠ᩃᩣᩉᩴ, ᨶᩥᨧ᩠ᨨᩣᨲᩣ ᨸᩁᩥᨶᩥᨻ᩠ᨻᩩᨲᩣ;

ᨻᩩᨴ᩠ᨵᩴ ᨵᨾ᩠ᨾᨬ᩠ᨧ ᩈᨦ᩠ᨥᨬ᩠ᨧ, ᩏᨸᩮᨾᩥ ᩈᩁᨱᩴ ᨾᩩᨶᩥᩴ’’.

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᨸᨬ᩠ᨧᩈᨲᨾᨲ᩠ᨲᩣ ᨳᩮᩁᩦ ᨽᩥᨠ᩠ᨡᩩᨶᩥᨿᩮᩣ…ᨸᩮ….

‘‘ᨸᩩᨲ᩠ᨲᩈᩮᩣᨠᩮᨶᩉᩴ ᩋᨭ᩠ᨭᩣ, ᨡᩥᨲ᩠ᨲᨧᩥᨲ᩠ᨲᩣ ᩅᩥᩈᨬ᩠ᨬᩥᨶᩦ;

ᨶᨣ᩠ᨣᩣ ᨸᨠᩥᨱ᩠ᨱᨠᩮᩈᩦ ᨧ, ᨲᩮᨶ ᨲᩮᨶ ᩅᩥᨧᩣᩁᩥᩉᩴ.

‘‘ᩅᩦᨳᩥ [ᩅᩈᩥᩴ (ᩈᩦ.)] ᩈᨦ᩠ᨠᩣᩁᨠᩪᨭᩮᩈᩩ, ᩈᩩᩈᩣᨶᩮ ᩁᨳᩥᨿᩣᩈᩩ ᨧ;

ᩋᨧᩁᩥᩴ ᨲᩦᨱᩥ ᩅᩔᩣᨶᩥ, ᨡᩩᨸ᩠ᨸᩥᨸᩣᩈᩣᩈᨾᨸ᩠ᨸᩥᨲᩣ.

‘‘ᩋᨳᨴ᩠ᨴᩈᩣᩈᩥᩴ ¶ ¶ ᩈᩩᨣᨲᩴ, ᨶᨣᩁᩴ ᨾᩥᨳᩥᩃᩴ ᨸᨲᩥ [ᨣᨲᩴ (ᨠ.)];

ᩋᨴᨶ᩠ᨲᩣᨶᩴ ᨴᨾᩮᨲᩣᩁᩴ, ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᨾᨠᩩᨲᩮᩣᨽᨿᩴ.

‘‘ᩈᨧᩥᨲ᩠ᨲᩴ ¶ ᨸᨭᩥᩃᨴ᩠ᨵᩣᨶ, ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣᨶ ᩏᨸᩣᩅᩥᩈᩥᩴ;

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

‘‘ᨲᩔ ¶ ᨵᨾ᩠ᨾᩴ ᩈᩩᨱᩥᨲ᩠ᩅᩣᨶ, ᨸᨻ᩠ᨻᨩᩥᩴ ᩋᨶᨣᩣᩁᩥᨿᩴ;

ᨿᩩᨬ᩠ᨩᨶ᩠ᨲᩦ ᩈᨲ᩠ᨳᩩᩅᨧᨶᩮ, ᩈᨧ᩠ᨨᩣᨠᩣᩈᩥᩴ ᨸᨴᩴ ᩈᩥᩅᩴ.

‘‘ᩈᨻ᩠ᨻᩮ ᩈᩮᩣᨠᩣ ᩈᨾᩩᨧ᩠ᨨᩥᨶ᩠ᨶᩣ, ᨸᩉᩦᨶᩣ ᩑᨲᨴᨶ᩠ᨲᩥᨠᩣ;

ᨸᩁᩥᨬ᩠ᨬᩣᨲᩣ ᩉᩥ ᨾᩮ ᩅᨲ᩠ᨳᩪ, ᨿᨲᩮᩣ ᩈᩮᩣᨠᩣᨶ ᩈᨾ᩠ᨽᩅᩮᩣ’’ᨲᩥ.

‘‘ᨴᩉᩁᩣ ᨲ᩠ᩅᩴ ᩁᩪᨸᩅᨲᩦ, ᩋᩉᨾ᩠ᨸᩥ ᨴᩉᩁᩮᩣ ᨿᩩᩅᩣ;

ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠᩮᨶ ᨲᩩᩁᩥᨿᩮᨶ [ᨲᩪᩁᩮᨶ (ᨠ.)], ᩑᩉᩥ ᨡᩮᨾᩮ ᩁᨾᩣᨾᩈᩮ’’.

‘‘ᩍᨾᩥᨶᩣ ᨸᩪᨲᩥᨠᩣᨿᩮᨶ, ᩌᨲᩩᩁᩮᨶ ᨸᨽᨦ᩠ᨣᩩᨶᩣ;

ᩋᨭ᩠ᨭᩥᨿᩣᨾᩥ ᩉᩁᩣᨿᩣᨾᩥ, ᨠᩣᨾᨲᨱ᩠ᩉᩣ ᩈᨾᩪᩉᨲᩣ.

‘‘ᩈᨲ᩠ᨲᩥᩈᩪᩃᩪᨸᨾᩣ ᨠᩣᨾᩣ, ᨡᨶ᩠ᨵᩣᩈᩴ ᩋᨵᩥᨠᩩᨭ᩠ᨭᨶᩣ;

ᨿᩴ ‘ᨲ᩠ᩅᩴ ᨠᩣᨾᩁᨲᩥᩴ’ ᨻᩕᩪᩈᩥ, ‘ᩋᩁᨲᩦ’ ᨴᩣᨶᩥ ᩈᩣ ᨾᨾ.

‘‘ᩈᨻ᩠ᨻᨲ᩠ᨳ ᩅᩥᩉᨲᩣ ᨶᨶ᩠ᨴᩦ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩮᩣ ᨸᨴᩣᩃᩥᨲᩮᩣ;

ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨸᩣᨸᩥᨾ, ᨶᩥᩉᨲᩮᩣ ᨲ᩠ᩅᨾᩈᩥ ᩋᨶ᩠ᨲᨠ.

‘‘ᨶᨠ᩠ᨡᨲ᩠ᨲᩣᨶᩥ ᨶᨾᩔᨶ᩠ᨲᩣ, ᩋᨣ᩠ᨣᩥᩴ ᨸᩁᩥᨧᩁᩴ ᩅᨶᩮ;

ᨿᨳᩣᨽᩩᨧ᩠ᨧᨾᨩᩣᨶᨶ᩠ᨲᩣ, ᨻᩣᩃᩣ ᩈᩩᨴ᩠ᨵᩥᨾᨾᨬ᩠ᨬᨳ.

‘‘ᩋᩉᨬ᩠ᨧ ᨡᩮᩣ ᨶᨾᩔᨶ᩠ᨲᩦ, ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩴ ᨸᩩᩁᩥᩈᩩᨲ᩠ᨲᨾᩴ;

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

‘‘ᩋᩃᨦ᩠ᨠᨲᩣ ¶ ᩈᩩᩅᩈᨶᩣ, ᨾᩣᩃᩥᨶᩦ ᨧᨶ᩠ᨴᨶᩮᩣᨠ᩠ᨡᩥᨲᩣ;

ᩈᨻ᩠ᨻᩣᨽᩁᨱᩈᨬ᩠ᨨᨶ᩠ᨶᩣ, ᨴᩣᩈᩦᨣᨱᨸᩩᩁᨠ᩠ᨡᨲᩣ.

‘‘ᩋᨶ᩠ᨶᩴ ¶ ᨸᩣᨶᨬ᩠ᨧ ᩌᨴᩣᨿ, ᨡᨩ᩠ᨩᩴ ᨽᩮᩣᨩ᩠ᨩᩴ ᩋᨶᨸ᩠ᨸᨠᩴ;

ᨣᩮᩉᨲᩮᩣ ᨶᩥᨠ᩠ᨡᨾᩥᨲ᩠ᩅᩣᨶ, ᩏᨿ᩠ᨿᩣᨶᨾᨽᩥᩉᩣᩁᨿᩥᩴ.

‘‘ᨲᨲ᩠ᨳ ¶ ᩁᨾᩥᨲ᩠ᩅᩣ ᨠᩦᩊᩥᨲ᩠ᩅᩣ, ᩌᨣᨧ᩠ᨨᨶ᩠ᨲᩦ ᩈᨠᩴ ᨥᩁᩴ;

ᩅᩥᩉᩣᩁᩴ ᨴᨭ᩠ᨮᩩᩴ ᨸᩣᩅᩥᩈᩥᩴ, ᩈᩣᨠᩮᨲᩮ ᩋᨬ᩠ᨩᨶᩴ ᩅᨶᩴ.

‘‘ᨴᩥᩈ᩠ᩅᩣᨶ ¶ ᩃᩮᩣᨠᨸᨩ᩠ᨩᩮᩣᨲᩴ, ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣᨶ ᩏᨸᩣᩅᩥᩈᩥᩴ;

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

‘‘ᩈᩩᨲ᩠ᩅᩣ ᨧ ᨡᩮᩣ ᨾᩉᩮᩈᩥᩔ, ᩈᨧ᩠ᨧᩴ ᩈᨾ᩠ᨸᨭᩥᩅᩥᨩ᩠ᨫᩉᩴ;

ᨲᨲ᩠ᨳᩮᩅ ᩅᩥᩁᨩᩴ ᨵᨾ᩠ᨾᩴ, ᨹᩩᩈᨿᩥᩴ ᩋᨾᨲᩴ ᨸᨴᩴ.

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

ᨲᩥᩔᩮᩣ ᩅᩥᨩ᩠ᨩᩣ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩣ, ᩋᨾᩮᩣᨥᩴ ᨻᩩᨴ᩠ᨵᩈᩣᩈᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᩏᨧ᩠ᨧᩮ ᨠᩩᩃᩮ ᩋᩉᩴ ᨩᩣᨲᩣ, ᨻᩉᩩᩅᩥᨲ᩠ᨲᩮ ᨾᩉᨴ᩠ᨵᨶᩮ;

ᩅᨱ᩠ᨱᩁᩪᨸᩮᨶ ᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᨵᩦᨲᩣ ᨾᨩ᩠ᨫᩔ [ᨾᩮᨥᩔ (ᩈᩦ.), ᨾᩮᨥᩥᩔ (ᩈ᩠ᨿᩣ.)] ᩋᨲᩕᨩᩣ.

‘‘ᨸᨲ᩠ᨳᩥᨲᩣ ᩁᩣᨩᨸᩩᨲ᩠ᨲᩮᩉᩥ, ᩈᩮᨭ᩠ᨮᩥᨸᩩᨲ᩠ᨲᩮᩉᩥ ᨣᩥᨩ᩠ᨫᩥᨲᩣ [ᩈᩮᨭ᩠ᨮᩥᨸᩩᨲ᩠ᨲᩮᩉᩥ ᨽᩥᨩ᩠ᨫᩥᨲᩣ (ᩈᩦ.)];

ᨸᩥᨲᩩ ᨾᩮ ᨸᩮᩈᨿᩦ ᨴᩪᨲᩴ, ᨴᩮᨳ ᨾᨿ᩠ᩉᩴ ᩋᨶᩮᩣᨸᨾᩴ.

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

ᨲᨲᩮᩣ ᩋᨭ᩠ᨮᨣᩩᨱᩴ ᨴᩔᩴ, ᩉᩥᩁᨬ᩠ᨬᩴ ᩁᨲᨶᩣᨶᩥ ᨧ.

‘‘ᩈᩣᩉᩴ ¶ ᨴᩥᩈ᩠ᩅᩣᨶ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩴ, ᩃᩮᩣᨠᨩᩮᨭ᩠ᨮᩴ ᩋᨶᩩᨲ᩠ᨲᩁᩴ;

ᨲᩔ ᨸᩣᨴᩣᨶᩥ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ, ᩑᨠᨾᨶ᩠ᨲᩴ ᩏᨸᩣᩅᩥᩈᩥᩴ.

‘‘ᩈᩮᩣ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᩋᨶᩩᨠᨾ᩠ᨸᩣᨿ ᨣᩮᩣᨲᨾᩮᩣ;

ᨶᩥᩈᩥᨶ᩠ᨶᩣ ᩌᩈᨶᩮ ᨲᩈ᩠ᨾᩥᩴ, ᨹᩩᩈᨿᩥᩴ ᨲᨲᩥᨿᩴ ᨹᩃᩴ.

‘‘ᨲᨲᩮᩣ ᨠᩮᩈᩣᨶᩥ ᨨᩮᨲ᩠ᩅᩣᨶ, ᨸᨻ᩠ᨻᨩᩥᩴ ᩋᨶᨣᩣᩁᩥᨿᩴ;

ᩋᨩ᩠ᨩ ᨾᩮ ᩈᨲ᩠ᨲᨾᩦ ᩁᨲ᩠ᨲᩥ, ᨿᨲᩮᩣ ᨲᨱ᩠ᩉᩣ ᩅᩥᩈᩮᩣᩈᩥᨲᩣ’’ᨲᩥ.

‘‘ᨻᩩᨴ᩠ᨵ ¶ ᩅᩦᩁ ᨶᨾᩮᩣ ᨲ᩠ᨿᨲ᩠ᨳᩩ, ᩈᨻ᩠ᨻᩈᨲ᩠ᨲᩣᨶᨾᩩᨲ᩠ᨲᨾ;

ᨿᩮᩣ ᨾᩴ ᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩮᩣᨧᩮᩈᩥ, ᩋᨬ᩠ᨬᨬ᩠ᨧ ᨻᩉᩩᨠᩴ ᨩᨶᩴ.

‘‘ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᩴ ᨸᩁᩥᨬ᩠ᨬᩣᨲᩴ, ᩉᩮᨲᩩᨲᨱ᩠ᩉᩣ ᩅᩥᩈᩮᩣᩈᩥᨲᩣ;

ᨽᩣᩅᩥᨲᩮᩣ ᩋᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩮᩣ [ᩋᩁᩥᨿᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩮᩣ (ᩈᩦ. ᨠ.), ᨽᩣᩅᩥᨲᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩮᩣ (ᩈ᩠ᨿᩣ.)] ᨾᨣ᩠ᨣᩮᩣ, ᨶᩥᩁᩮᩣᨵᩮᩣ ᨹᩩᩈᩥᨲᩮᩣ ᨾᨿᩣ.

‘‘ᨾᩣᨲᩣ ¶ ¶ ᨸᩩᨲ᩠ᨲᩮᩣ ᨸᩥᨲᩣ ᨽᩣᨲᩣ, ᩋᨿ᩠ᨿᨠᩣ ᨧ ᨸᩩᩁᩮ ᩋᩉᩩᩴ;

ᨿᨳᩣᨽᩩᨧ᩠ᨧᨾᨩᩣᨶᨶ᩠ᨲᩦ, ᩈᩴᩈᩁᩥᩴᩉᩴ ᩋᨶᩥᨻ᩠ᨻᩥᩈᩴ.

‘‘ᨴᩥᨭ᩠ᨮᩮᩣ ᩉᩥ ᨾᩮ ᩈᩮᩣ ᨽᨣᩅᩣ, ᩋᨶ᩠ᨲᩥᨾᩮᩣᨿᩴ ᩈᨾᩩᩔᨿᩮᩣ;

ᩅᩥᨠ᩠ᨡᩦᨱᩮᩣ ᨩᩣᨲᩥᩈᩴᩈᩣᩁᩮᩣ, ᨶᨲ᩠ᨳᩥ ᨴᩣᨶᩥ ᨸᩩᨶᨻ᩠ᨽᩅᩮᩣ.

‘‘ᩌᩁᨴ᩠ᨵᩅᩦᩁᩥᨿᩮ ᨸᩉᩥᨲᨲ᩠ᨲᩮ, ᨶᩥᨧ᩠ᨧᩴ ᨴᩊ᩠ᩉᨸᩁᨠ᩠ᨠᨾᩮ;

ᩈᨾᨣ᩠ᨣᩮ ᩈᩣᩅᨠᩮ ᨸᩔᩮ, ᩑᩈᩣ ᨻᩩᨴ᩠ᨵᩣᨶ ᩅᨶ᩠ᨴᨶᩣ.

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

ᨻ᩠ᨿᩣᨵᩥᨾᩁᨱᨲᩩᨶ᩠ᨶᩣᨶᩴ, ᨴᩩᨠ᩠ᨡᨠ᩠ᨡᨶ᩠ᨵᩴ ᨻ᩠ᨿᨸᩣᨶᩩᨴᩦ’’ᨲᩥ.

‘‘ᨣᩩᨲ᩠ᨲᩮ ¶ ᨿᨴᨲ᩠ᨳᩴ ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ, ᩉᩥᨲ᩠ᩅᩣ ᨸᩩᨲ᩠ᨲᩴ ᩅᩈᩩᩴ ᨸᩥᨿᩴ;

ᨲᨾᩮᩅ ᩋᨶᩩᨻᩕᩪᩉᩮᩉᩥ, ᨾᩣ ᨧᩥᨲ᩠ᨲᩔ ᩅᩈᩴ ᨣᨾᩥ.

‘‘ᨧᩥᨲ᩠ᨲᩮᨶ ᩅᨬ᩠ᨧᩥᨲᩣ ᩈᨲ᩠ᨲᩣ, ᨾᩣᩁᩔ ᩅᩥᩈᨿᩮ ᩁᨲᩣ;

ᩋᨶᩮᨠᨩᩣᨲᩥᩈᩴᩈᩣᩁᩴ, ᩈᨶ᩠ᨵᩣᩅᨶ᩠ᨲᩥ ᩋᩅᩥᨴ᩠ᨴᩈᩪ.

‘‘ᨠᩣᨾᨧ᩠ᨨᨶ᩠ᨴᨬ᩠ᨧ ᨻ᩠ᨿᩣᨸᩣᨴᩴ, ᩈᨠ᩠ᨠᩣᨿᨴᩥᨭ᩠ᨮᩥᨾᩮᩅ ᨧ;

ᩈᩦᩃᨻ᩠ᨻᨲᨸᩁᩣᨾᩣᩈᩴ, ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᨬ᩠ᨧ ᨸᨬ᩠ᨧᨾᩴ.

‘‘ᩈᩴᨿᩮᩣᨩᨶᩣᨶᩥ ᩑᨲᩣᨶᩥ, ᨸᨩᩉᩥᨲ᩠ᩅᩣᨶ ᨽᩥᨠ᩠ᨡᩩᨶᩦ;

ᩒᩁᨾ᩠ᨽᩣᨣᨾᨶᩦᨿᩣᨶᩥ, ᨶᨿᩥᨴᩴ ᨸᩩᨶᩁᩮᩉᩥᩈᩥ.

‘‘ᩁᩣᨣᩴ ᨾᩣᨶᩴ ᩋᩅᩥᨩ᩠ᨩᨬ᩠ᨧ, ᩏᨴ᩠ᨵᨧ᩠ᨧᨬ᩠ᨧ ᩅᩥᩅᨩ᩠ᨩᩥᨿ;

ᩈᩴᨿᩮᩣᨩᨶᩣᨶᩥ ᨨᩮᨲ᩠ᩅᩣᨶ, ᨴᩩᨠ᩠ᨡᩔᨶ᩠ᨲᩴ ᨠᩁᩥᩔᩈᩥ.

‘‘ᨡᩮᨸᩮᨲ᩠ᩅᩣ ¶ ᨩᩣᨲᩥᩈᩴᩈᩣᩁᩴ, ᨸᩁᩥᨬ᩠ᨬᩣᨿ ᨸᩩᨶᨻ᩠ᨽᩅᩴ;

ᨴᩥᨭ᩠ᨮᩮᩅ ᨵᨾ᩠ᨾᩮ ᨶᩥᨧ᩠ᨨᩣᨲᩣ, ᩏᨸᩈᨶ᩠ᨲᩣ ᨧᩁᩥᩔᨲᩦ’’ᨲᩥ.

‘‘ᨧᨲᩩᨠ᩠ᨡᨲ᩠ᨲᩩᩴ ᨸᨬ᩠ᨧᨠ᩠ᨡᨲ᩠ᨲᩩᩴ, ᩅᩥᩉᩣᩁᩣ ᩏᨸᨶᩥᨠ᩠ᨡᨾᩥᩴ;

ᩋᩃᨴ᩠ᨵᩣ ᨧᩮᨲᩈᩮᩣ ᩈᨶ᩠ᨲᩥᩴ, ᨧᩥᨲ᩠ᨲᩮ ᩋᩅᩈᩅᨲ᩠ᨲᩥᨶᩦ.

‘‘ᨽᩥᨠ᩠ᨡᩩᨶᩥᩴ ¶ ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ, ᩈᨠ᩠ᨠᨧ᩠ᨧᩴ ᨸᩁᩥᨸᩩᨧ᩠ᨨᩉᩴ;

ᩈᩣ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᨵᩣᨲᩩᩌᨿᨲᨶᩣᨶᩥ ᨧ.

‘‘ᨧᨲ᩠ᨲᩣᩁᩥ ¶ ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶᩥ, ᩍᨶ᩠ᨴᩕᩥᨿᩣᨶᩥ ᨻᩃᩣᨶᩥ ᨧ;

ᨻᩮᩣᨩ᩠ᨫᨦ᩠ᨣᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩴ ᨾᨣ᩠ᨣᩴ, ᩏᨲ᩠ᨲᨾᨲ᩠ᨳᩔ ᨸᨲ᩠ᨲᩥᨿᩣ.

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

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

‘‘ᩁᨲ᩠ᨲᩥᨿᩣ ᨾᨩ᩠ᨫᩥᨾᩮ ᨿᩣᨾᩮ, ᨴᩥᨻ᩠ᨻᨧᨠ᩠ᨡᩩᩴ ᩅᩥᩈᩮᩣᨵᨿᩥᩴ;

ᩁᨲ᩠ᨲᩥᨿᩣ ᨸᨧ᩠ᨨᩥᨾᩮ ᨿᩣᨾᩮ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩴ ᨸᨴᩣᩃᨿᩥᩴ.

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

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

‘‘‘ᨾᩩᩈᩃᩣᨶᩥ ¶ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᨵᨬ᩠ᨬᩴ ᨠᩮᩣᨭ᩠ᨭᩮᨶ᩠ᨲᩥ ᨾᩣᨱᩅᩣ;

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

‘‘‘ᨥᨭᩮᨳ ¶ ᨻᩩᨴ᩠ᨵᩈᩣᩈᨶᩮ, ᨿᩴ ᨠᨲ᩠ᩅᩣ ᨶᩣᨶᩩᨲᨸ᩠ᨸᨲᩥ;

ᨡᩥᨸ᩠ᨸᩴ ᨸᩣᨴᩣᨶᩥ ᨵᩮᩣᩅᩥᨲ᩠ᩅᩣ, ᩑᨠᨾᨶ᩠ᨲᩴ ᨶᩥᩈᩦᨴᨳ.

‘‘‘ᨧᩥᨲ᩠ᨲᩴ ᩏᨸᨭ᩠ᨮᨸᩮᨲ᩠ᩅᩣᨶ, ᩑᨠᨣ᩠ᨣᩴ ᩈᩩᩈᨾᩣᩉᩥᨲᩴ;

ᨸᨧ᩠ᨧᩅᩮᨠ᩠ᨡᨳ ᩈᨦ᩠ᨡᩣᩁᩮ, ᨸᩁᨲᩮᩣ ᨶᩮᩣ ᨧ ᩋᨲ᩠ᨲᨲᩮᩣ’.

‘‘ᨲᩔᩣᩉᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨸᨭᩣᨧᩣᩁᩣᨶᩩᩈᩣᩈᨶᩥᩴ;

ᨸᩣᨴᩮ ᨸᨠ᩠ᨡᩣᩃᨿᩥᨲ᩠ᩅᩣᨶ, ᩑᨠᨾᨶ᩠ᨲᩮ ᩏᨸᩣᩅᩥᩈᩥᩴ.

‘‘ᩁᨲ᩠ᨲᩥᨿᩣ ¶ ᨸᩩᩁᩥᨾᩮ ᨿᩣᨾᩮ, ᨸᩩᨻ᩠ᨻᨩᩣᨲᩥᨾᨶᩩᩔᩁᩥᩴ;

ᩁᨲ᩠ᨲᩥᨿᩣ ᨾᨩ᩠ᨫᩥᨾᩮ ᨿᩣᨾᩮ, ᨴᩥᨻ᩠ᨻᨧᨠ᩠ᨡᩩᩴ ᩅᩥᩈᩮᩣᨵᨿᩥᩴ.

‘‘ᩁᨲ᩠ᨲᩥᨿᩣ ᨸᨧ᩠ᨨᩥᨾᩮ ᨿᩣᨾᩮ, ᨲᨾᩮᩣᨠ᩠ᨡᨶ᩠ᨵᩴ ᨸᨴᩣᩃᨿᩥᩴ;

ᨲᩮᩅᩥᨩ᩠ᨩᩣ ᩋᨳ ᩅᩩᨭ᩠ᨮᩣᩈᩥᩴ, ᨠᨲᩣ ᨲᩮ ᩋᨶᩩᩈᩣᩈᨶᩦ.

‘‘ᩈᨠ᩠ᨠᩴᩅ ᨴᩮᩅᩣ ᨲᩥᨴᩈᩣ, ᩈᨦ᩠ᨣᩣᨾᩮ ᩋᨸᩁᩣᨩᩥᨲᩴ;

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

‘‘ᩈᨲᩥᩴ ¶ ᩏᨸᨭ᩠ᨮᨸᩮᨲ᩠ᩅᩣᨶ, ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᨽᩣᩅᩥᨲᩥᨶ᩠ᨴᩕᩥᨿᩣ;

ᨸᨭᩥᩅᩥᨩ᩠ᨫᩥ ᨸᨴᩴ ᩈᨶ᩠ᨲᩴ, ᩈᨦ᩠ᨡᩣᩁᩪᨸᩈᨾᩴ ᩈᩩᨡᩴ’’.

‘‘ᨠᩴ ᨶᩩ ᩏᨴ᩠ᨴᩥᩔ ᨾᩩᨱ᩠ᨯᩣᩈᩥ, ᩈᨾᨱᩦ ᩅᩥᨿ ᨴᩥᩔᩈᩥ;

ᨶ ᨧ ᩁᩮᩣᨧᩮᩈᩥ ᨸᩣᩈᨱ᩠ᨯᩮ, ᨠᩥᨾᩥᨴᩴ ᨧᩁᩈᩥ ᨾᩮᩣᨾᩩᩉᩣ’’.

‘‘ᩍᨲᩮᩣ ᨻᩉᩥᨴ᩠ᨵᩣ ᨸᩣᩈᨱ᩠ᨯᩣ, ᨴᩥᨭ᩠ᨮᩥᨿᩮᩣ ᩏᨸᨶᩥᩔᩥᨲᩣ;

ᨶ ᨲᩮ ᨵᨾ᩠ᨾᩴ ᩅᩥᨩᩣᨶᨶ᩠ᨲᩥ, ᨶ ᨲᩮ ᨵᨾ᩠ᨾᩔ ᨠᩮᩣᩅᩥᨴᩣ.

‘‘ᩋᨲ᩠ᨳᩥ ᩈᨠ᩠ᨿᨠᩩᩃᩮ ᨩᩣᨲᩮᩣ, ᨻᩩᨴ᩠ᨵᩮᩣ ᩋᨸ᩠ᨸᨭᩥᨸᩩᨣ᩠ᨣᩃᩮᩣ;

ᩈᩮᩣ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᨴᩥᨭ᩠ᨮᩦᨶᩴ ᩈᨾᨲᩥᨠ᩠ᨠᨾᩴ.

‘‘ᨴᩩᨠ᩠ᨡᩴ ¶ ᨴᩩᨠ᩠ᨡᩈᨾᩩᨸ᩠ᨸᩣᨴᩴ, ᨴᩩᨠ᩠ᨡᩔ ᨧ ᩋᨲᩥᨠ᩠ᨠᨾᩴ;

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

‘‘ᨲᩔᩣᩉᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩅᩥᩉᩁᩥᩴ ᩈᩣᩈᨶᩮ ᩁᨲᩣ;

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

‘‘ᩈᨻ᩠ᨻᨲ᩠ᨳ ¶ ¶ ᩅᩥᩉᨲᩣ ᨶᨶ᩠ᨴᩦ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩮᩣ ᨸᨴᩣᩃᩥᨲᩮᩣ;

ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨸᩣᨸᩥᨾ, ᨶᩥᩉᨲᩮᩣ ᨲ᩠ᩅᨾᩈᩥ ᩋᨶ᩠ᨲᨠ’’.

‘‘ᩈᨲᩥᨾᨲᩦ ᨧᨠ᩠ᨡᩩᨾᨲᩦ, ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᨽᩣᩅᩥᨲᩥᨶ᩠ᨴᩕᩥᨿᩣ;

ᨸᨭᩥᩅᩥᨩ᩠ᨫᩥᩴ ᨸᨴᩴ ᩈᨶ᩠ᨲᩴ, ᩋᨠᩣᨸᩩᩁᩥᩈᩈᩮᩅᩥᨲᩴ’’.

‘‘ᨠᩥᩴ ᨶᩩ ᨩᩣᨲᩥᩴ ᨶ ᩁᩮᩣᨧᩮᩈᩥ, ᨩᩣᨲᩮᩣ ᨠᩣᨾᩣᨶᩥ ᨽᩩᨬ᩠ᨩᨲᩥ;

ᨽᩩᨬ᩠ᨩᩣᩉᩥ ᨠᩣᨾᩁᨲᩥᨿᩮᩣ, ᨾᩣᩉᩩ ᨸᨧ᩠ᨨᩣᨶᩩᨲᩣᨸᩥᨶᩦ’’.

‘‘ᨩᩣᨲᩔ ᨾᩁᨱᩴ ᩉᩮᩣᨲᩥ, ᩉᨲ᩠ᨳᨸᩣᨴᩣᨶ ᨨᩮᨴᨶᩴ;

ᩅᨵᨻᨶ᩠ᨵᨸᩁᩥᨠ᩠ᩃᩮᩈᩴ, ᨩᩣᨲᩮᩣ ᨴᩩᨠ᩠ᨡᩴ ᨶᩥᨣᨧ᩠ᨨᨲᩥ.

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

ᩈᩮᩣ ᨾᩮ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᨩᩣᨲᩥᨿᩣ ᩈᨾᨲᩥᨠ᩠ᨠᨾᩴ.

‘‘ᨴᩩᨠ᩠ᨡᩴ ᨴᩩᨠ᩠ᨡᩈᨾᩩᨸ᩠ᨸᩣᨴᩴ, ᨴᩩᨠ᩠ᨡᩔ ᨧ ᩋᨲᩥᨠ᩠ᨠᨾᩴ;

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

‘‘ᨲᩔᩣᩉᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩅᩥᩉᩁᩥᩴ ᩈᩣᩈᨶᩮ ᩁᨲᩣ;

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

‘‘ᩈᨻ᩠ᨻᨲ᩠ᨳ ¶ ᩅᩥᩉᨲᩣ ᨶᨶ᩠ᨴᩦ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩮᩣ ᨸᨴᩣᩃᩥᨲᩮᩣ;

ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨸᩣᨸᩥᨾ, ᨶᩥᩉᨲᩮᩣ ᨲ᩠ᩅᨾᩈᩥ ᩋᨶ᩠ᨲᨠ’’.

‘‘ᨽᩥᨠ᩠ᨡᩩᨶᩦ ¶ ¶ ¶ ᩈᩦᩃᩈᨾ᩠ᨸᨶ᩠ᨶᩣ, ᩍᨶ᩠ᨴᩕᩥᨿᩮᩈᩩ ᩈᩩᩈᩴᩅᩩᨲᩣ;

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

‘‘ᨲᩣᩅᨲᩥᩴᩈᩣ ᨧ ᨿᩣᨾᩣ ᨧ, ᨲᩩᩈᩥᨲᩣ ᨧᩣᨸᩥ ᨴᩮᩅᨲᩣ;

ᨶᩥᨾ᩠ᨾᩣᨶᩁᨲᩥᨶᩮᩣ ᨴᩮᩅᩣ, ᨿᩮ ᨴᩮᩅᩣ ᩅᩈᩅᨲ᩠ᨲᩥᨶᩮᩣ;

ᨲᨲ᩠ᨳ ᨧᩥᨲ᩠ᨲᩴ ᨸᨱᩦᨵᩮᩉᩥ, ᨿᨲ᩠ᨳ ᨲᩮ ᩅᩩᩈᩥᨲᩴ ᨸᩩᩁᩮ’’.

‘‘ᨲᩣᩅᨲᩥᩴᩈᩣ ᨧ ᨿᩣᨾᩣ ᨧ, ᨲᩩᩈᩥᨲᩣ ᨧᩣᨸᩥ ᨴᩮᩅᨲᩣ;

ᨶᩥᨾ᩠ᨾᩣᨶᩁᨲᩥᨶᩮᩣ ᨴᩮᩅᩣ, ᨿᩮ ᨴᩮᩅᩣ ᩅᩈᩅᨲ᩠ᨲᩥᨶᩮᩣ.

‘‘ᨠᩣᩃᩴ ᨠᩣᩃᩴ ᨽᩅᩣᨽᩅᩴ, ᩈᨠ᩠ᨠᩣᨿᩈ᩠ᨾᩥᩴ ᨸᩩᩁᨠ᩠ᨡᨲᩣ;

ᩋᩅᩦᨲᩥᩅᨲ᩠ᨲᩣ ᩈᨠ᩠ᨠᩣᨿᩴ, ᨩᩣᨲᩥᨾᩁᨱᩈᩣᩁᩥᨶᩮᩣ.

‘‘ᩈᨻ᩠ᨻᩮᩣ ᩌᨴᩦᨸᩥᨲᩮᩣ ᩃᩮᩣᨠᩮᩣ, ᩈᨻ᩠ᨻᩮᩣ ᩃᩮᩣᨠᩮᩣ ᨸᨴᩦᨸᩥᨲᩮᩣ;

ᩈᨻ᩠ᨻᩮᩣ ᨸᨩ᩠ᨩᩃᩥᨲᩮᩣ ᩃᩮᩣᨠᩮᩣ, ᩈᨻ᩠ᨻᩮᩣ ᩃᩮᩣᨠᩮᩣ ᨸᨠᨾ᩠ᨸᩥᨲᩮᩣ.

‘‘ᩋᨠᨾ᩠ᨸᩥᨿᩴ ᩋᨲᩩᩃᩥᨿᩴ, ᩋᨸᩩᨳᩩᨩ᩠ᨩᨶᩈᩮᩅᩥᨲᩴ;

ᨻᩩᨴ᩠ᨵᩮᩣ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᨲᨲ᩠ᨳ ᨾᩮ ᨶᩥᩁᨲᩮᩣ ᨾᨶᩮᩣ.

‘‘ᨲᩔᩣᩉᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩅᩥᩉᩁᩥᩴ ᩈᩣᩈᨶᩮ ᩁᨲᩣ;

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

‘‘ᩈᨻ᩠ᨻᨲ᩠ᨳ ᩅᩥᩉᨲᩣ ᨶᨶ᩠ᨴᩦ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩮᩣ ᨸᨴᩣᩃᩥᨲᩮᩣ;

ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨸᩣᨸᩥᨾ, ᨶᩥᩉᨲᩮᩣ ᨲ᩠ᩅᨾᩈᩥ ᩋᨶ᩠ᨲᨠ’’.

‘‘ᨾᩣ ¶ ¶ ¶ ᩈᩩ ᨲᩮ ᩅᨯ᩠ᨰ ᩃᩮᩣᨠᨾ᩠ᩉᩥ, ᩅᨶᨳᩮᩣ ᩌᩉᩩ ᨠᩩᨴᩣᨧᨶᩴ;

ᨾᩣ ᨸᩩᨲ᩠ᨲᨠ ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ, ᩋᩉᩩ ᨴᩩᨠ᩠ᨡᩔ ᨽᩣᨣᩥᨾᩣ.

‘‘ᩈᩩᨡᨬ᩠ᩉᩥ ¶ ᩅᨯ᩠ᨰ ᨾᩩᨶᨿᩮᩣ, ᩋᨶᩮᨩᩣ ᨨᩥᨶ᩠ᨶᩈᩴᩈᨿᩣ;

ᩈᩦᨲᩥᨽᩪᨲᩣ ᨴᨾᨸ᩠ᨸᨲ᩠ᨲᩣ, ᩅᩥᩉᩁᨶ᩠ᨲᩥ ᩋᨶᩣᩈᩅᩣ.

‘‘ᨲᩮᩉᩣᨶᩩᨧᩥᨱ᩠ᨱᩴ ᩍᩈᩦᨽᩥ, ᨾᨣ᩠ᨣᩴ ᨴᩔᨶᨸᨲ᩠ᨲᩥᨿᩣ;

ᨴᩩᨠ᩠ᨡᩔᨶ᩠ᨲᨠᩥᩁᩥᨿᩣᨿ, ᨲ᩠ᩅᩴ ᩅᨯ᩠ᨰ ᩋᨶᩩᨻᩕᩪᩉᨿ’’.

‘‘ᩅᩥᩈᩣᩁᨴᩣᩅ ᨽᨱᩈᩥ, ᩑᨲᨾᨲ᩠ᨳᩴ ᨩᨶᩮᨲ᩠ᨲᩥ ᨾᩮ;

ᨾᨬ᩠ᨬᩣᨾᩥ ᨶᩪᨶ ᨾᩣᨾᩥᨠᩮ, ᩅᨶᨳᩮᩣ ᨲᩮ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ’’.

‘‘ᨿᩮ ᨠᩮᨧᩥ ᩅᨯ᩠ᨰ ᩈᨦ᩠ᨡᩣᩁᩣ, ᩉᩦᨶᩣ ᩏᨠ᩠ᨠᨭ᩠ᨮᨾᨩ᩠ᨫᩥᨾᩣ;

ᩋᨱᩪᨸᩥ ᩋᨱᩩᨾᨲ᩠ᨲᩮᩣᨸᩥ, ᩅᨶᨳᩮᩣ ᨾᩮ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ.

‘‘ᩈᨻ᩠ᨻᩮ ᨾᩮ ᩌᩈᩅᩣ ᨡᩦᨱᩣ, ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩔ ᨫᩣᨿᨲᩮᩣ;

ᨲᩥᩔᩮᩣ ᩅᩥᨩ᩠ᨩᩣ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶᩴ’’.

‘‘ᩏᩊᩣᩁᩴ ᩅᨲ ᨾᩮ ᨾᩣᨲᩣ, ᨸᨲᩮᩣᨴᩴ ᩈᨾᩅᩔᩁᩥ;

ᨸᩁᨾᨲ᩠ᨳᩈᨬ᩠ᩉᩥᨲᩣ ᨣᩣᨳᩣ, ᨿᨳᩣᨸᩥ ᩋᨶᩩᨠᨾ᩠ᨸᩥᨠᩣ.

‘‘ᨲᩔᩣᩉᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩋᨶᩩᩈᩥᨭ᩠ᨮᩥᩴ ᨩᨶᩮᨲ᩠ᨲᩥᨿᩣ;

ᨵᨾ᩠ᨾᩈᩴᩅᩮᨣᨾᩣᨸᩣᨴᩥᩴ, ᨿᩮᩣᨣᨠ᩠ᨡᩮᨾᩔ ᨸᨲ᩠ᨲᩥᨿᩣ.

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

ᨾᩣᨲᩁᩣ ᨧᩮᩣᨴᩥᨲᩮᩣ ᩈᨶ᩠ᨲᩮᩣ, ᩋᨹᩩᩈᩥᩴ ᩈᨶ᩠ᨲᩥᨾᩩᨲ᩠ᨲᨾᩴ’’.

‘‘ᨠᩃ᩠ᨿᩣᨱᨾᩥᨲ᩠ᨲᨲᩣ ¶ ¶ ¶ ᨾᩩᨶᩥᨶᩣ, ᩃᩮᩣᨠᩴ ᩌᨴᩥᩔ ᩅᨱ᩠ᨱᩥᨲᩣ;

ᨠᩃ᩠ᨿᩣᨱᨾᩥᨲ᩠ᨲᩮ ᨽᨩᨾᩣᨶᩮᩣ, ᩋᨸᩥ ᨻᩣᩃᩮᩣ ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᩋᩔ.

‘‘ᨽᨩᩥᨲᨻ᩠ᨻᩣ ᩈᨸ᩠ᨸᩩᩁᩥᩈᩣ, ᨸᨬ᩠ᨬᩣ ᨲᨳᩣ ᩅᨯ᩠ᨰᨲᩥ ᨽᨩᨶ᩠ᨲᩣᨶᩴ;

ᨽᨩᨾᩣᨶᩮᩣ ᩈᨸ᩠ᨸᩩᩁᩥᩈᩮ, ᩈᨻ᩠ᨻᩮᩉᩥᨸᩥ ᨴᩩᨠ᩠ᨡᩮᩉᩥ ᨸᨾᩩᨧ᩠ᨧᩮᨿ᩠ᨿ.

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

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

‘‘ᨴᩩᨠ᩠ᨡᩮᩣ ¶ ᩍᨲ᩠ᨳᩥᨽᩣᩅᩮᩣ, ᩋᨠ᩠ᨡᩣᨲᩮᩣ ᨸᩩᩁᩥᩈᨴᨾ᩠ᨾᩈᩣᩁᨳᩥᨶᩣ;

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

‘‘ᨣᩃᨠᩮ ᩋᨸᩥ ᨠᨶ᩠ᨲᨶ᩠ᨲᩥ, ᩈᩩᨡᩩᨾᩣᩃᩥᨶᩥᨿᩮᩣ ᩅᩥᩈᩣᨶᩥ ᨡᩣᨴᨶ᩠ᨲᩥ;

ᨩᨶᨾᩣᩁᨠᨾᨩ᩠ᨫᨣᨲᩣ, ᩏᨽᩮᩣᨸᩥ ᨻ᩠ᨿᩈᨶᩣᨶᩥ ᩋᨶᩩᨽᩮᩣᨶ᩠ᨲᩥ.

‘‘ᩏᨸᩅᩥᨩᨬ᩠ᨬᩣ ᨣᨧ᩠ᨨᨶ᩠ᨲᩦ, ᩋᨴ᩠ᨴᩈᩣᩉᩴ ᨸᨲᩥᩴ ᨾᨲᩴ;

ᨸᨶ᩠ᨳᨾ᩠ᩉᩥ ᩅᩥᨩᩣᨿᩥᨲ᩠ᩅᩣᨶ, ᩋᨸ᩠ᨸᨲ᩠ᨲᩣᩅ ᩈᨠᩴ ᨥᩁᩴ.

‘‘ᨴ᩠ᩅᩮ ᨸᩩᨲ᩠ᨲᩣ ᨠᩣᩃᨠᨲᩣ, ᨸᨲᩦ ᨧ ᨸᨶ᩠ᨳᩮ ᨾᨲᩮᩣ ᨠᨸᨱᩥᨠᩣᨿ;

ᨾᩣᨲᩣ ᨸᩥᨲᩣ ᨧ ᨽᩣᨲᩣ, ᨯᨿ᩠ᩉᨶ᩠ᨲᩥ ᨧ ᩑᨠᨧᩥᨲᨠᩣᨿᩴ.

‘‘ᨡᩦᨱᨠᩩᩃᩦᨶᩮ ᨠᨸᨱᩮ, ᩋᨶᩩᨽᩪᨲᩴ ᨲᩮ ᨴᩩᨡᩴ ᩋᨸᩁᩥᨾᩣᨱᩴ;

ᩋᩔᩪ ᨧ ᨲᩮ ᨸᩅᨲ᩠ᨲᩴ, ᨻᩉᩪᨶᩥ ᨧ ᨩᩣᨲᩥᩈᩉᩔᩣᨶᩥ.

‘‘ᩅᩈᩥᨲᩣ ᩈᩩᩈᩣᨶᨾᨩ᩠ᨫᩮ, ᩋᨳᩮᩣᨸᩥ ᨡᩣᨴᩥᨲᩣᨶᩥ ᨸᩩᨲ᩠ᨲᨾᩴᩈᩣᨶᩥ;

ᩉᨲᨠᩩᩃᩥᨠᩣ ¶ ᩈᨻ᩠ᨻᨣᩁᩉᩥᨲᩣ, ᨾᨲᨸᨲᩥᨠᩣ ᩋᨾᨲᨾᨵᩥᨣᨧ᩠ᨨᩥᩴ.

‘‘ᨽᩣᩅᩥᨲᩮᩣ ᨾᩮ ᨾᨣ᩠ᨣᩮᩣ, ᩋᩁᩥᨿᩮᩣ ᩋᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩮᩣ ᩋᨾᨲᨣᩣᨾᩦ;

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

‘‘ᩋᩉᨾᨾ᩠ᩉᩥ ᨠᨶ᩠ᨲᩈᩃ᩠ᩃᩣ, ᩒᩉᩥᨲᨽᩣᩁᩣ ᨠᨲᨬ᩠ᩉᩥ ᨠᩁᨱᩦᨿᩴ;

ᨠᩥᩈᩣ ᨣᩮᩣᨲᨾᩦ ᨳᩮᩁᩦ, ᩅᩥᨾᩩᨲ᩠ᨲᨧᩥᨲ᩠ᨲᩣ ᩍᨾᩴ ᨽᨱᩦ’’ᨲᩥ.

‘‘ᩏᨽᩮᩣ ¶ ¶ ᨾᩣᨲᩣ ᨧ ᨵᩦᨲᩣ ᨧ, ᨾᨿᩴ ᩌᩈᩩᩴ [ᩌᨽᩩᩴ (ᩈᩦ.)] ᩈᨸᨲ᩠ᨲᩥᨿᩮᩣ;

ᨲᩔᩣ ᨾᩮ ᩋᩉᩩ ᩈᩴᩅᩮᨣᩮᩣ, ᩋᨻ᩠ᨽᩩᨲᩮᩣ ᩃᩮᩣᨾᩉᩴᩈᨶᩮᩣ.

‘‘ᨵᩥᩁᨲ᩠ᨳᩩ ᨠᩣᨾᩣ ᩋᩈᩩᨧᩦ, ᨴᩩᨣ᩠ᨣᨶ᩠ᨵᩣ ᨻᩉᩩᨠᨱ᩠ᨭᨠᩣ;

ᨿᨲ᩠ᨳ ᨾᩣᨲᩣ ᨧ ᨵᩦᨲᩣ ᨧ, ᩈᨽᩁᩥᨿᩣ ᨾᨿᩴ ᩋᩉᩩᩴ.

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

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

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

ᨧᩮᨲᩮᩣᨸᩁᩥᨧ᩠ᨧᨬᩣᨱᨬ᩠ᨧ, ᩈᩮᩣᨲᨵᩣᨲᩩ ᩅᩥᩈᩮᩣᨵᩥᨲᩣ.

‘‘ᩍᨴ᩠ᨵᩦᨸᩥ ᨾᩮ ᩈᨧ᩠ᨨᩥᨠᨲᩣ, ᨸᨲ᩠ᨲᩮᩣ ᨾᩮ ᩌᩈᩅᨠ᩠ᨡᨿᩮᩣ;

ᨨᩊᨽᩥᨬ᩠ᨬᩣ ᩈᨧ᩠ᨨᩥᨠᨲᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶᩴ.

‘‘ᩍᨴ᩠ᨵᩥᨿᩣ ¶ ᩋᨽᩥᨶᩥᨾ᩠ᨾᩥᨲ᩠ᩅᩣ, ᨧᨲᩩᩁᩔᩴ ᩁᨳᩴ ᩋᩉᩴ;

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

‘‘ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᨣ᩠ᨣᩴ ᩏᨸᨣᨾ᩠ᨾ ᨸᩣᨴᨸᩴ, ᩑᨠᩣ ᨲᩩᩅᩴ ᨲᩥᨭ᩠ᨮᩈᩥ ᩈᩣᩃᨾᩪᩃᩮ [ᩁᩩᨠ᩠ᨡᨾᩪᩃᩮ (ᩈ᩠ᨿᩣ. ᨠ.)];

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

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

ᩃᩮᩣᨾᩴ ᨶ ᩍᨬ᩠ᨩᩮ ᨶᨸᩥ ᩈᨾ᩠ᨸᩅᩮᨵᩮ, ᨠᩥᩴ ᨾᩮ ᨲᩩᩅᩴ ᨾᩣᩁ ᨠᩁᩥᩔᩈᩮᨠᩮᩣ.

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

ᨽᨾᩩᨠᨶ᩠ᨲᩁᩮ ᨲᩥᨭ᩠ᨮᩣᨾᩥ, ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥᩴ ᨾᩴ ᨶ ᨴᨠ᩠ᨡᩈᩥ.

‘‘ᨧᩥᨲ᩠ᨲᨾ᩠ᩉᩥ ¶ ᩅᩈᩦᨽᩪᨲᩣᩉᩴ, ᩍᨴ᩠ᨵᩥᨸᩣᨴᩣ ᩈᩩᨽᩣᩅᩥᨲᩣ;

ᨨᩊᨽᩥᨬ᩠ᨬᩣ ᩈᨧ᩠ᨨᩥᨠᨲᩣ, ᨠᨲᩴ ᨻᩩᨴ᩠ᨵᩔ ᩈᩣᩈᨶᩴ.

‘‘ᩈᨲ᩠ᨲᩥᩈᩪᩃᩪᨸᨾᩣ ᨠᩣᨾᩣ, ᨡᨶ᩠ᨵᩣᩈᩴ ᩋᨵᩥᨠᩩᨭ᩠ᨭᨶᩣ;

ᨿᩴ ᨲ᩠ᩅᩴ ‘ᨠᩣᨾᩁᨲᩥᩴ’ ᨻᩕᩪᩈᩥ, ‘ᩋᩁᨲᩦ’ ᨴᩣᨶᩥ ᩈᩣ ᨾᨾ.

‘‘ᩈᨻ᩠ᨻᨲ᩠ᨳ ¶ ᩅᩥᩉᨲᩣ ᨶᨶ᩠ᨴᩦ, ᨲᨾᩮᩣᨡᨶ᩠ᨵᩮᩣ ᨸᨴᩣᩃᩥᨲᩮᩣ;

ᩑᩅᩴ ᨩᩣᨶᩣᩉᩥ ᨸᩣᨸᩥᨾ, ᨶᩥᩉᨲᩮᩣ ᨲ᩠ᩅᨾᩈᩥ ᩋᨶ᩠ᨲᨠᩣ’’ᨲᩥ.

‘‘ᩏᨴᩉᩣᩁᩦ ¶ ¶ ¶ ᩋᩉᩴ ᩈᩦᨲᩮ [ᩏᨴᨠᨾᩣᩉᩁᩥᩴ ᩈᩦᨲᩮ (ᩈᩦ.)], ᩈᨴᩣ ᩏᨴᨠᨾᩮᩣᨲᩁᩥᩴ;

ᩋᨿ᩠ᨿᩣᨶᩴ ᨴᨱ᩠ᨯᨽᨿᨽᩦᨲᩣ, ᩅᩣᨧᩣᨴᩮᩣᩈᨽᨿᨭ᩠ᨭᩥᨲᩣ.

‘‘ᨠᩔ ᨻᩕᩣᩉ᩠ᨾᨱ ᨲ᩠ᩅᩴ ᨽᩦᨲᩮᩣ, ᩈᨴᩣ ᩏᨴᨠᨾᩮᩣᨲᩁᩥ;

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

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

ᨠᩁᩮᩣᨶ᩠ᨲᩴ ᨠᩩᩈᩃᩴ ᨠᨾ᩠ᨾᩴ, ᩁᩩᨶ᩠ᨵᨶ᩠ᨲᩴ ᨠᨲᨸᩣᨸᨠᩴ.

‘‘ᨿᩮᩣ ᨧ ᩅᩩᨯ᩠ᨰᩮᩣ ᨴᩉᩁᩮᩣ ᩅᩣ, ᨸᩣᨸᨠᨾ᩠ᨾᩴ ᨸᨠᩩᨻ᩠ᨻᨲᩥ;

ᨴᨠᩣᨽᩥᩈᩮᨧᨶᩣ ᩈᩮᩣᨸᩥ, ᨸᩣᨸᨠᨾ᩠ᨾᩣ ᨸᨾᩩᨧ᩠ᨧᨲᩥ’’.

‘‘ᨠᩮᩣ ᨶᩩ ᨲᩮ ᩍᨴᨾᨠ᩠ᨡᩣᩈᩥ, ᩋᨩᩣᨶᨶ᩠ᨲᩔ ᩋᨩᩣᨶᨠᩮᩣ;

ᨴᨠᩣᨽᩥᩈᩮᨧᨶᩣ ᨶᩣᨾ, ᨸᩣᨸᨠᨾ᩠ᨾᩣ ᨸᨾᩩᨧ᩠ᨧᨲᩥ.

‘‘ᩈᨣ᩠ᨣᩴ ᨶᩪᨶ ᨣᨾᩥᩔᨶ᩠ᨲᩥ, ᩈᨻ᩠ᨻᩮ ᨾᨱ᩠ᨯᩪᨠᨠᨧ᩠ᨨᨸᩣ;

ᨶᩣᨣᩣ [ᨶᨠ᩠ᨠᩣ (ᩈᩦ.)] ᨧ ᩈᩩᩈᩩᨾᩣᩁᩣ ᨧ, ᨿᩮ ᨧᨬ᩠ᨬᩮ ᩏᨴᨠᩮ ᨧᩁᩣ.

‘‘ᩒᩁᨻ᩠ᨽᩥᨠᩣ ᩈᩪᨠᩁᩥᨠᩣ, ᨾᨧ᩠ᨨᩥᨠᩣ ᨾᩥᨣᨻᨶ᩠ᨵᨠᩣ;

ᨧᩮᩣᩁᩣ ᨧ ᩅᨩ᩠ᨫᨥᩣᨲᩣ ᨧ, ᨿᩮ ᨧᨬ᩠ᨬᩮ ᨸᩣᨸᨠᨾ᩠ᨾᩥᨶᩮᩣ;

ᨴᨠᩣᨽᩥᩈᩮᨧᨶᩣ ᨲᩮᨸᩥ, ᨸᩣᨸᨠᨾ᩠ᨾᩣ ᨸᨾᩩᨧ᩠ᨧᩁᩮ.

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

ᨸᩩᨬ᩠ᨬᨾ᩠ᨸᩥᨾᩣ ¶ ᩅᩉᩮᨿ᩠ᨿᩩᩴ ᨲᩮ, ᨲᩮᨶ ᨲ᩠ᩅᩴ ᨸᩁᩥᨻᩣᩉᩥᩁᩮᩣ.

‘‘ᨿᩔ ¶ ᨻᩕᩣᩉ᩠ᨾᨱ ᨲ᩠ᩅᩴ ᨽᩦᨲᩮᩣ, ᩈᨴᩣ ᩏᨴᨠᨾᩮᩣᨲᩁᩥ;

ᨲᨾᩮᩅ ᨻᩕᩉ᩠ᨾᩮ ᨾᩣ ᨠᩣᩈᩥ, ᨾᩣ ᨲᩮ ᩈᩦᨲᩴ ᨨᩅᩥᩴ ᩉᨶᩮ’’.

‘‘ᨠᩩᨾ᩠ᨾᨣ᩠ᨣᨸᨭᩥᨸᨶ᩠ᨶᩴ ᨾᩴ, ᩋᩁᩥᨿᨾᨣ᩠ᨣᩴ ᩈᨾᩣᨶᨿᩥ;

ᨴᨠᩣᨽᩥᩈᩮᨧᨶᩣ ᨽᩮᩣᨲᩥ, ᩍᨾᩴ ᩈᩣᨭᩴ ᨴᨴᩣᨾᩥ ᨲᩮ’’.

‘‘ᨲᩩᨿ᩠ᩉᩮᩅ ᩈᩣᨭᨠᩮᩣ ᩉᩮᩣᨲᩩ, ᨶᩣᩉᨾᩥᨧ᩠ᨨᩣᨾᩥ ᩈᩣᨭᨠᩴ;

ᩈᨧᩮ ᨽᩣᨿᩈᩥ ᨴᩩᨠ᩠ᨡᩔ, ᩈᨧᩮ ᨲᩮ ᨴᩩᨠ᩠ᨡᨾᨸ᩠ᨸᩥᨿᩴ.

‘‘ᨾᩣᨠᩣᩈᩥ ¶ ¶ ᨸᩣᨸᨠᩴ ᨠᨾ᩠ᨾᩴ, ᩌᩅᩥ ᩅᩣ ᨿᨴᩥ ᩅᩣ ᩁᩉᩮᩣ;

ᩈᨧᩮ ᨧ ᨸᩣᨸᨠᩴ ᨠᨾ᩠ᨾᩴ, ᨠᩁᩥᩔᩈᩥ ᨠᩁᩮᩣᩈᩥ ᩅᩣ.

‘‘ᨶ ᨲᩮ ᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩩᨲ᩠ᨿᨲ᩠ᨳᩥ, ᩏᨸᩮᨧ᩠ᨧᩣᨸᩥ [ᩏᨸ᩠ᨸᨧ᩠ᨧᩣᨸᩥ (ᩋᨭ᩠ᨮ. ᨸᩣᨮᨶ᩠ᨲᩁᩴ)] ᨸᩃᩣᨿᨲᩮᩣ;

ᩈᨧᩮ ᨽᩣᨿᩈᩥ ᨴᩩᨠ᩠ᨡᩔ, ᩈᨧᩮ ᨲᩮ ᨴᩩᨠ᩠ᨡᨾᨸ᩠ᨸᩥᨿᩴ.

‘‘ᩏᨸᩮᩉᩥ ᩈᩁᨱᩴ ᨻᩩᨴ᩠ᨵᩴ, ᨵᨾ᩠ᨾᩴ ᩈᨦ᩠ᨥᨬ᩠ᨧ ᨲᩣᨴᩥᨶᩴ;

ᩈᨾᩣᨴᩥᨿᩣᩉᩥ ᩈᩦᩃᩣᨶᩥ, ᨲᩴ ᨲᩮ ᩋᨲ᩠ᨳᩣᨿ ᩉᩮᩉᩥᨲᩥ’’.

‘‘ᩏᨸᩮᨾᩥ ᩈᩁᨱᩴ ᨻᩩᨴ᩠ᨵᩴ, ᨵᨾ᩠ᨾᩴ ᩈᨦ᩠ᨥᨬ᩠ᨧ ᨲᩣᨴᩥᨶᩴ;

ᩈᨾᩣᨴᩥᨿᩣᨾᩥ ᩈᩦᩃᩣᨶᩥ, ᨲᩴ ᨾᩮ ᩋᨲ᩠ᨳᩣᨿ ᩉᩮᩉᩥᨲᩥ.

‘‘ᨻᩕᩉ᩠ᨾᨻᨶ᩠ᨵᩩ ᨸᩩᩁᩮ ᩌᩈᩥᩴ, ᩋᨩ᩠ᨩᨾ᩠ᩉᩥ ᩈᨧ᩠ᨧᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᨲᩮᩅᩥᨩ᩠ᨩᩮᩣ ᩅᩮᨴᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᩈᩮᩣᨲ᩠ᨲᩥᨿᩮᩣ ᨧᨾ᩠ᩉᩥ ᨶ᩠ᩉᩣᨲᨠᩮᩣ’’ᨲᩥ.

‘‘ᨠᩣᩊᨠᩣ ¶ ¶ ᨽᨾᩁᩅᨱ᩠ᨱᩈᩣᨴᩥᩈᩣ, ᩅᩮᩃ᩠ᩃᩥᨲᨣ᩠ᨣᩣ ᨾᨾ ᨾᩩᨴ᩠ᨵᨩᩣ ᩋᩉᩩᩴ;

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

‘‘ᩅᩣᩈᩥᨲᩮᩣᩅ ᩈᩩᩁᨽᩦ ᨠᩁᨱ᩠ᨯᨠᩮᩣ, ᨸᩩᨸ᩠ᨹᨸᩪᩁ ᨾᨾ ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᨩᩮᩣ [ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᨽᩪᨲᩮᩣ (ᨠ.)].

ᨲᩴ ᨩᩁᩣᨿᨳ ᩈᩃᩮᩣᨾᨣᨶ᩠ᨵᩥᨠᩴ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

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

ᨲᩴ ᨩᩁᩣᨿ ᩅᩥᩁᩃᩴ ᨲᩉᩥᩴ ᨲᩉᩥᩴ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᨠᨱ᩠ᩉᨡᨶ᩠ᨵᨠᩈᩩᩅᨱ᩠ᨱᨾᨱ᩠ᨯᩥᨲᩴ, ᩈᩮᩣᨽᨲᩮ ᩈᩩᩅᩮᨱᩦᩉᩥᩃᨦ᩠ᨠᨲᩴ;

ᨲᩴ ¶ ᨩᩁᩣᨿ ᨡᩃᩥᨲᩴ ᩈᩥᩁᩴ ᨠᨲᩴ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

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

ᨲᩣ ¶ ᨩᩁᩣᨿ ᩅᩃᩥᨽᩥᨸ᩠ᨸᩃᨾ᩠ᨻᩥᨲᩣ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᨽᩔᩁᩣ ᩈᩩᩁᩩᨧᩥᩁᩣ ᨿᨳᩣ ᨾᨱᩦ, ᨶᩮᨲ᩠ᨲᩉᩮᩈᩩᨾᨽᩥᨶᩦᩃᨾᩣᨿᨲᩣ;

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

‘‘ᩈᨱ᩠ᩉᨲᩩᨦ᩠ᨣᩈᨴᩥᩈᩦ ¶ ᨧ ᨶᩣᩈᩥᨠᩣ, ᩈᩮᩣᨽᨲᩮ ᩈᩩ ᩋᨽᩥᨿᩮᩣᨻ᩠ᨻᨶᩴ ᨸᨲᩥ;

ᩈᩣ ᨩᩁᩣᨿ ᩏᨸᨠᩪᩃᩥᨲᩣ ᩅᩥᨿ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᨠᨦ᩠ᨠᨱᩴ ᩅ ᩈᩩᨠᨲᩴ ᩈᩩᨶᩥᨭ᩠ᨮᩥᨲᩴ, ᩈᩮᩣᨽᩁᩮ ᩈᩩ ᨾᨾ ᨠᨱ᩠ᨱᨸᩣᩊᩥᨿᩮᩣ;

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

‘‘ᨸᨲ᩠ᨲᩃᩦᨾᨠᩩᩃᩅᨱ᩠ᨱᩈᩣᨴᩥᩈᩣ, ᩈᩮᩣᨽᩁᩮ ᩈᩩ ᨴᨶ᩠ᨲᩣ ᨸᩩᩁᩮ ᨾᨾ;

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

‘‘ᨠᩣᨶᨶᨾ᩠ᩉᩥ ᩅᨶᩈᨱ᩠ᨯᨧᩣᩁᩥᨶᩦ, ᨠᩮᩣᨠᩥᩃᩣᩅ ¶ ᨾᨵᩩᩁᩴ ᨶᩥᨠᩪᨩᩥᩉᩴ;

ᨲᩴ ᨩᩁᩣᨿ ᨡᩃᩥᨲᩴ ᨲᩉᩥᩴ ᨲᩉᩥᩴ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᩈᨱ᩠ᩉᨠᨾ᩠ᨻᩩᩁᩥᩅ ᩈᩩᨸ᩠ᨸᨾᨩ᩠ᨩᩥᨲᩣ, ᩈᩮᩣᨽᨲᩮ ᩈᩩ ᨣᩦᩅᩣ ᨸᩩᩁᩮ ᨾᨾ;

ᩈᩣ ᨩᩁᩣᨿ ᨽᨣ᩠ᨣᩣ [ᨽᨬ᩠ᨩᩥᨲᩣ (?)] ᩅᩥᨶᩣᨾᩥᨲᩣ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᩅᨭ᩠ᨭᨸᩃᩥᨥᩈᨴᩥᩈᩮᩣᨸᨾᩣ ¶ ᩏᨽᩮᩣ, ᩈᩮᩣᨽᩁᩮ ᩈᩩ ᨻᩣᩉᩣ ᨸᩩᩁᩮ ᨾᨾ;

ᨲᩣ ᨩᩁᩣᨿ ᨿᨳ ᨸᩣᨭᩃᩥᨻ᩠ᨻᩃᩥᨲᩣ [ᨿᨳᩣ ᨸᩣᨭᩃᩥᨸ᩠ᨸᩃᩥᨲᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨠ.)], ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᩈᨱ᩠ᩉᨾᩩᨴ᩠ᨴᩥᨠᩈᩩᩅᨱ᩠ᨱᨾᨱ᩠ᨯᩥᨲᩣ, ᩈᩮᩣᨽᩁᩮ ᩈᩩ ᩉᨲ᩠ᨳᩣ ᨸᩩᩁᩮ ᨾᨾ;

ᨲᩮ ᨩᩁᩣᨿ ᨿᨳᩣ ᨾᩪᩃᨾᩪᩃᩥᨠᩣ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᨸᩦᨶᩅᨭ᩠ᨭᩈᩉᩥᨲᩩᨣ᩠ᨣᨲᩣ ¶ ᩏᨽᩮᩣ, ᩈᩮᩣᨽᩁᩮ [ᩈᩮᩣᨽᨲᩮ (ᩋᨭ᩠ᨮ.)] ᩈᩩ ᨳᨶᨠᩣ ᨸᩩᩁᩮ ᨾᨾ;

ᨳᩮᩅᩥᨠᩦᩅ ᩃᨾ᩠ᨻᨶ᩠ᨲᩥ ᨶᩮᩣᨴᨠᩣ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ¶ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᨠᨬ᩠ᨧᨶᩔᨹᩃᨠᩴᩅ ᩈᨾ᩠ᨾᨭ᩠ᨮᩴ, ᩈᩮᩣᨽᨲᩮ ᩈᩩ ᨠᩣᨿᩮᩣ ᨸᩩᩁᩮ ᨾᨾ;

ᩈᩮᩣ ᩅᩃᩦᩉᩥ ᩈᩩᨡᩩᨾᩣᩉᩥ ᩒᨲᨲᩮᩣ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᨶᩣᨣᨽᩮᩣᨣᩈᨴᩥᩈᩮᩣᨸᨾᩣ ᩏᨽᩮᩣ, ᩈᩮᩣᨽᩁᩮ ᩈᩩ ᩐᩁᩪ ᨸᩩᩁᩮ ᨾᨾ;

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

‘‘ᩈᨱ᩠ᩉᨶᩪᨸᩩᩁᩈᩩᩅᨱ᩠ᨱᨾᨱ᩠ᨯᩥᨲᩣ ¶ , ᩈᩮᩣᨽᩁᩮ ᩈᩩ ᨩᨦ᩠ᨥᩣ ᨸᩩᩁᩮ ᨾᨾ;

ᨲᩣ ᨩᩁᩣᨿ ᨲᩥᩃᨴᨱ᩠ᨯᨠᩣᩁᩥᩅ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᨲᩪᩃᨸᩩᨱ᩠ᨱᩈᨴᩥᩈᩮᩣᨸᨾᩣ ᩏᨽᩮᩣ, ᩈᩮᩣᨽᩁᩮ ᩈᩩ ᨸᩣᨴᩣ ᨸᩩᩁᩮ ᨾᨾ;

ᨲᩮ ᨩᩁᩣᨿ ᨹᩩᨭᩥᨲᩣ ᩅᩃᩦᨾᨲᩣ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ.

‘‘ᩑᨴᩥᩈᩮᩣ ᩋᩉᩩ ᩋᨿᩴ ᩈᨾᩩᩔᨿᩮᩣ, ᨩᨩ᩠ᨩᩁᩮᩣ ᨻᩉᩩᨴᩩᨠ᩠ᨡᩣᨶᨾᩣᩃᨿᩮᩣ;

ᩈᩮᩣᨸᩃᩮᨸᨸᨲᩥᨲᩮᩣ ¶ ᨩᩁᩣᨥᩁᩮᩣ, ᩈᨧ᩠ᨧᩅᩣᨴᩥᩅᨧᨶᩴ ᩋᨶᨬ᩠ᨬᨳᩣ’’.

‘‘‘ᩈᨾᨱᩣ’ᨲᩥ ¶ ᨽᩮᩣᨲᩥ ᩈᩩᨸᩥ [ᨽᩮᩣᨲᩥ ᨲ᩠ᩅᩴ ᩈᨿᩈᩥ (ᩈᩦ.), ᨽᩮᩣᨲᩥ ᨾᩴ ᩅᩥᨸᩔᩥ (ᩈ᩠ᨿᩣ.)], ‘ᩈᨾᨱᩣ’ᨲᩥ ᨸᨻᩩᨩ᩠ᨫᩈᩥ [ᨸᨭᩥᨻᩩᨩ᩠ᨫᩈᩥ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

ᩈᨾᨱᩣᨶᩮᩅ [ᩈᨾᨱᩣᨶᨾᩮᩅ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨠᩥᨲ᩠ᨲᩮᩈᩥ, ᩈᨾᨱᩦ ᨶᩪᨶ [ᩈᨾᨱᩦ ᨶᩩ (ᨠ.)] ᨽᩅᩥᩔᩈᩥ.

‘‘ᩅᩥᨸᩩᩃᩴ ¶ ᩋᨶ᩠ᨶᨬ᩠ᨧ ᨸᩣᨶᨬ᩠ᨧ, ᩈᨾᨱᩣᨶᩴ ᨸᩅᩮᨧ᩠ᨧᩈᩥ [ᨸᨿᨧ᩠ᨨᩈᩥ (ᩈᩦ.)];

ᩁᩮᩣᩉᩥᨶᩦ ᨴᩣᨶᩥ ᨸᩩᨧ᩠ᨨᩣᨾᩥ, ᨠᩮᨶ ᨲᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ.

‘‘ᩋᨠᨾ᩠ᨾᨠᩣᨾᩣ ᩋᩃᩈᩣ, ᨸᩁᨴᨲ᩠ᨲᩪᨸᨩᩦᩅᩥᨶᩮᩣ;

ᩌᩈᩴᩈᩩᨠᩣ ᩈᩣᨴᩩᨠᩣᨾᩣ, ᨠᩮᨶ ᨲᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ’’.

‘‘ᨧᩥᩁᩔᩴ ᩅᨲ ᨾᩴ ᨲᩣᨲ, ᩈᨾᨱᩣᨶᩴ ᨸᩁᩥᨸᩩᨧ᩠ᨨᩈᩥ;

ᨲᩮᩈᩴ ᨲᩮ ᨠᩥᨲ᩠ᨲᨿᩥᩔᩣᨾᩥ, ᨸᨬ᩠ᨬᩣᩈᩦᩃᨸᩁᨠ᩠ᨠᨾᩴ.

‘‘ᨠᨾ᩠ᨾᨠᩣᨾᩣ ᩋᨶᩃᩈᩣ, ᨠᨾ᩠ᨾᩈᩮᨭ᩠ᨮᩔ ᨠᩣᩁᨠᩣ;

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

‘‘ᨲᩦᨱᩥ ᨸᩣᨸᩔ ᨾᩪᩃᩣᨶᩥ, ᨵᩩᨶᨶ᩠ᨲᩥ ᩈᩩᨧᩥᨠᩣᩁᩥᨶᩮᩣ;

ᩈᨻ᩠ᨻᩴ ᨸᩣᨸᩴ ᨸᩉᩦᨶᩮᩈᩴ, ᨲᩮᨶ ᨾᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ.

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

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

‘‘ᩅᩥᨾᩃᩣ ᩈᨦ᩠ᨡᨾᩩᨲ᩠ᨲᩣᩅ, ᩈᩩᨴ᩠ᨵᩣ ᩈᨶ᩠ᨲᩁᨻᩣᩉᩥᩁᩣ;

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

‘‘ᨻᩉᩩᩔᩩᨲᩣ ᨵᨾ᩠ᨾᨵᩁᩣ, ᩋᩁᩥᨿᩣ ᨵᨾ᩠ᨾᨩᩦᩅᩥᨶᩮᩣ;

ᩋᨲ᩠ᨳᩴ ᨵᨾ᩠ᨾᨬ᩠ᨧ ᨴᩮᩈᩮᨶ᩠ᨲᩥ, ᨲᩮᨶ ᨾᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ.

‘‘ᨻᩉᩩᩔᩩᨲᩣ ¶ ᨵᨾ᩠ᨾᨵᩁᩣ, ᩋᩁᩥᨿᩣ ᨵᨾ᩠ᨾᨩᩦᩅᩥᨶᩮᩣ;

ᩑᨠᨣ᩠ᨣᨧᩥᨲ᩠ᨲᩣ ᩈᨲᩥᨾᨶ᩠ᨲᩮᩣ, ᨲᩮᨶ ᨾᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ.

‘‘ᨴᩪᩁᨦ᩠ᨣᨾᩣ ¶ ᩈᨲᩥᨾᨶ᩠ᨲᩮᩣ, ᨾᨶ᩠ᨲᨽᩣᨱᩦ ᩋᨶᩩᨴ᩠ᨵᨲᩣ;

ᨴᩩᨠ᩠ᨡᩔᨶ᩠ᨲᩴ ᨸᨩᩣᨶᨶ᩠ᨲᩥ, ᨲᩮᨶ ᨾᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ.

‘‘ᨿᩈ᩠ᨾᩣ ᨣᩣᨾᩣ ᨸᨠ᩠ᨠᨾᨶ᩠ᨲᩥ, ᨶ ᩅᩥᩃᩮᩣᨠᩮᨶ᩠ᨲᩥ ᨠᩥᨬ᩠ᨧᨶᩴ;

ᩋᨶᨸᩮᨠ᩠ᨡᩣᩅ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ, ᨲᩮᨶ ᨾᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ.

‘‘ᨶ ¶ ᨲᩮᩈᩴ ᨠᩮᩣᨭ᩠ᨮᩮ ᩒᨸᩮᨶ᩠ᨲᩥ, ᨶ ᨠᩩᨾ᩠ᨽᩥᩴ ᨶ ᨡᩊᩮᩣᨸᩥᨿᩴ;

ᨸᩁᩥᨶᩥᨭ᩠ᨮᩥᨲᨾᩮᩈᩣᨶᩣ, ᨲᩮᨶ ᨾᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ.

‘‘ᨶ ᨲᩮ ᩉᩥᩁᨬ᩠ᨬᩴ ᨣᨱ᩠ᩉᨶ᩠ᨲᩥ, ᨶ ᩈᩩᩅᨱ᩠ᨱᩴ ᨶ ᩁᩪᨸᩥᨿᩴ;

ᨸᨧ᩠ᨧᩩᨸ᩠ᨸᨶ᩠ᨶᩮᨶ ᨿᩣᨸᩮᨶ᩠ᨲᩥ, ᨲᩮᨶ ᨾᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ.

‘‘ᨶᩣᨶᩣᨠᩩᩃᩣ ¶ ᨸᨻ᩠ᨻᨩᩥᨲᩣ, ᨶᩣᨶᩣᨩᨶᨸᨴᩮᩉᩥ ᨧ;

ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩴ ᨸᩥᨿᩣᨿᨶ᩠ᨲᩥ [ᨸᩥᩉᨿᨶ᩠ᨲᩥ (ᨠ.)], ᨲᩮᨶ ᨾᩮ ᩈᨾᨱᩣ ᨸᩥᨿᩣ’’.

‘‘ᩋᨲ᩠ᨳᩣᨿ ᩅᨲ ᨶᩮᩣ ᨽᩮᩣᨲᩥ, ᨠᩩᩃᩮ ᨩᩣᨲᩣᩈᩥ ᩁᩮᩣᩉᩥᨶᩦ;

ᩈᨴ᩠ᨵᩣ ᨻᩩᨴ᩠ᨵᩮ ᨧ ᨵᨾ᩠ᨾᩮ ᨧ, ᩈᨦ᩠ᨥᩮ ᨧ ᨲᩥᨻ᩠ᨻᨣᩣᩁᩅᩣ.

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

ᩋᨾ᩠ᩉᨾ᩠ᨸᩥ ᩑᨲᩮ ᩈᨾᨱᩣ, ᨸᨭᩥᨣᨱ᩠ᩉᨶ᩠ᨲᩥ ᨴᨠ᩠ᨡᩥᨱᩴ’’.

‘‘ᨸᨲᩥᨭ᩠ᨮᩥᨲᩮᩣ ᩉᩮᨲ᩠ᨳ ᨿᨬ᩠ᨬᩮᩣ, ᩅᩥᨸᩩᩃᩮᩣ ᨶᩮᩣ ᨽᩅᩥᩔᨲᩥ;

ᩈᨧᩮ ᨽᩣᨿᩈᩥ ᨴᩩᨠ᩠ᨡᩔ, ᩈᨧᩮ ᨲᩮ ᨴᩩᨠ᩠ᨡᨾᨸ᩠ᨸᩥᨿᩴ.

‘‘ᩏᨸᩮᩉᩥ ᩈᩁᨱᩴ ᨻᩩᨴ᩠ᨵᩴ, ᨵᨾ᩠ᨾᩴ ᩈᨦ᩠ᨥᨬ᩠ᨧ ᨲᩣᨴᩥᨶᩴ;

ᩈᨾᩣᨴᩥᨿᩣᩉᩥ ᩈᩦᩃᩣᨶᩥ, ᨲᩴ ᨲᩮ ᩋᨲ᩠ᨳᩣᨿ ᩉᩮᩉᩥᨲᩥ’’.

‘‘ᩏᨸᩮᨾᩥ ¶ ᩈᩁᨱᩴ ᨻᩩᨴ᩠ᨵᩴ, ᨵᨾ᩠ᨾᩴ ᩈᨦ᩠ᨥᨬ᩠ᨧ ᨲᩣᨴᩥᨶᩴ;

ᩈᨾᩣᨴᩥᨿᩣᨾᩥ ᩈᩦᩃᩣᨶᩥ, ᨲᩴ ᨾᩮ ᩋᨲ᩠ᨳᩣᨿ ᩉᩮᩉᩥᨲᩥ.

‘‘ᨻᩕᩉ᩠ᨾᨻᨶ᩠ᨵᩩ ᨸᩩᩁᩮ ᩌᩈᩥᩴ, ᩈᩮᩣ ᩍᨴᩣᨶᩥᨾ᩠ᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

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

‘‘ᩃᨭ᩠ᨮᩥᩉᨲ᩠ᨳᩮᩣ ᨸᩩᩁᩮ ᩌᩈᩥ, ᩈᩮᩣ ᨴᩣᨶᩥ ᨾᩥᨣᩃᩩᨴ᩠ᨴᨠᩮᩣ;

ᩌᩈᩣᨿ ᨸᩃᩥᨸᩣ ᨥᩮᩣᩁᩣ, ᨶᩣᩈᨠ᩠ᨡᩥ ᨸᩣᩁᨾᩮᨲᩅᩮ.

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

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

‘‘ᨾᩣ ¶ ᨾᩮ ᨠᩩᨩ᩠ᨫᩥ ᨾᩉᩣᩅᩦᩁ, ᨾᩣ ᨾᩮ ᨠᩩᨩ᩠ᨫᩥ ᨾᩉᩣᨾᩩᨶᩥ;

ᨶ ᩉᩥ ᨠᩮᩣᨵᨸᩁᩮᨲᩔ, ᩈᩩᨴ᩠ᨵᩥ ᩋᨲ᩠ᨳᩥ ᨠᩩᨲᩮᩣ ᨲᨸᩮᩣ.

‘‘ᨸᨠ᩠ᨠᨾᩥᩔᨬ᩠ᨧ ¶ ᨶᩣᩊᩣᨲᩮᩣ, ᨠᩮᩣᨵ ᨶᩣᩊᩣᨿ ᩅᨧ᩠ᨨᨲᩥ;

ᨻᨶ᩠ᨵᨶ᩠ᨲᩦ ᩍᨲ᩠ᨳᩥᩁᩪᨸᩮᨶ, ᩈᨾᨱᩮ ᨵᨾ᩠ᨾᨩᩦᩅᩥᨶᩮᩣ’’ [ᨵᨾ᩠ᨾᨩᩦᩅᩥᨶᩮ (ᨠ.)].

‘‘ᩑᩉᩥ ᨠᩣᩊ ᨶᩥᩅᨲ᩠ᨲᩔᩩ, ᨽᩩᨬ᩠ᨩ ᨠᩣᨾᩮ ᨿᨳᩣ ᨸᩩᩁᩮ;

ᩋᩉᨬ᩠ᨧ ᨲᩮ ᩅᩈᩦᨠᨲᩣ, ᨿᩮ ᨧ ᨾᩮ ᩈᨶ᩠ᨲᩥ ᨬᩣᨲᨠᩣ’’.

‘‘ᩑᨲ᩠ᨲᩮᩣ ¶ ᨧᩣᨸᩮ ᨧᨲᩩᨻ᩠ᨽᩣᨣᩴ, ᨿᨳᩣ ᨽᩣᩈᩈᩥ ᨲ᩠ᩅᨬ᩠ᨧ ᨾᩮ;

ᨲᨿᩥ ᩁᨲ᩠ᨲᩔ ᨸᩮᩣᩈᩔ, ᩏᩊᩣᩁᩴ ᩅᨲ ᨲᩴ ᩈᩥᨿᩣ’’.

‘‘ᨠᩣᩊᨦ᩠ᨣᩥᨶᩥᩴᩅ ᨲᨠ᩠ᨠᩣᩁᩥᩴ, ᨸᩩᨸ᩠ᨹᩥᨲᩴ ᨣᩥᩁᩥᨾᩩᨴ᩠ᨵᨶᩥ;

ᨹᩩᩃ᩠ᩃᩴ ᨴᩣᩃᩥᨾᩃᨭ᩠ᨮᩥᩴᩅ, ᩋᨶ᩠ᨲᩮᩣᨴᩦᨸᩮᩅ ᨸᩣᨭᩃᩥᩴ.

‘‘ᩉᩁᩥᨧᨶ᩠ᨴᨶᩃᩥᨲ᩠ᨲᨦ᩠ᨣᩥᩴ, ᨠᩣᩈᩥᨠᩩᨲ᩠ᨲᨾᨵᩣᩁᩥᨶᩥᩴ;

ᨲᩴ ¶ ᨾᩴ ᩁᩪᨸᩅᨲᩥᩴ ᩈᨶ᩠ᨲᩥᩴ, ᨠᩔ ᩒᩉᩣᨿ ᨣᨧ᩠ᨨᩈᩥ’’.

‘‘ᩈᩣᨠᩩᨶ᩠ᨲᩥᨠᩮᩣᩅ ᩈᨠᩩᨱᩥᩴ [ᩈᨠᩩᨱᩴ (ᩈ᩠ᨿᩣ.)], ᨿᨳᩣ ᨻᨶ᩠ᨵᩥᨲᩩᨾᩥᨧ᩠ᨨᨲᩥ;

ᩌᩉᩁᩥᨾᩮᨶ ᩁᩪᨸᩮᨶ, ᨶ ᨾᩴ ᨲ᩠ᩅᩴ ᨻᩣᨵᨿᩥᩔᩈᩥ’’.

‘‘ᩍᨾᨬ᩠ᨧ ᨾᩮ ᨸᩩᨲ᩠ᨲᨹᩃᩴ, ᨠᩣᩊ ᩏᨸ᩠ᨸᩣᨴᩥᨲᩴ ᨲᨿᩣ;

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

‘‘ᨩᩉᨶ᩠ᨲᩥ ᨸᩩᨲ᩠ᨲᩮ ᩈᨸ᩠ᨸᨬ᩠ᨬᩣ, ᨲᨲᩮᩣ ᨬᩣᨲᩦ ᨲᨲᩮᩣ ᨵᨶᩴ;

ᨸᨻ᩠ᨻᨩᨶ᩠ᨲᩥ ᨾᩉᩣᩅᩦᩁᩣ, ᨶᩣᨣᩮᩣ ᨨᩮᨲ᩠ᩅᩣᩅ ᨻᨶ᩠ᨵᨶᩴ’’.

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

ᨽᩪᨾᩥᨿᩴ ᩅᩣ ᨶᩥᩈᩩᨾ᩠ᨽᩥᩔᩴ [ᨶᩥᩈᩩᨾ᩠ᨽᩮᨿ᩠ᨿᩴ (ᩈᩦ.)], ᨸᩩᨲ᩠ᨲᩈᩮᩣᨠᩣ ᨶ ᨣᨧ᩠ᨨᩈᩥ’’.

‘‘ᩈᨧᩮ ᨸᩩᨲ᩠ᨲᩴ ᩈᩥᨦ᩠ᨣᩣᩃᩣᨶᩴ, ᨠᩩᨠ᩠ᨠᩩᩁᩣᨶᩴ ᨸᨴᩣᩉᩥᩈᩥ;

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

‘‘ᩉᨶ᩠ᨴ ᨡᩮᩣ ᨴᩣᨶᩥ ᨽᨴ᩠ᨴᨶ᩠ᨲᩮ, ᨠᩩᩉᩥᩴ ᨠᩣᩊ ᨣᨾᩥᩔᩈᩥ;

ᨠᨲᨾᩴ ¶ ᨣᩣᨾᨶᩥᨣᨾᩴ, ᨶᨣᩁᩴ ᩁᩣᨩᨵᩣᨶᩥᨿᩮᩣ’’.

‘‘ᩋᩉᩩᨾ᩠ᩉ ᨸᩩᨻ᩠ᨻᩮ ᨣᨱᩥᨶᩮᩣ, ᩋᩔᨾᨱᩣ ᩈᨾᨱᨾᩣᨶᩥᨶᩮᩣ;

ᨣᩣᨾᩮᨶ ᨣᩣᨾᩴ ᩅᩥᨧᩁᩥᨾ᩠ᩉ, ᨶᨣᩁᩮ ᩁᩣᨩᨵᩣᨶᩥᨿᩮᩣ.

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

ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᨸ᩠ᨸᩉᩣᨶᩣᨿ, ᨵᨾ᩠ᨾᩴ ᨴᩮᩈᩮᨲᩥ ᨸᩣᨱᩥᨶᩴ;

ᨲᩔᩣᩉᩴ ᩈᨶ᩠ᨲᩥᨠᩴ ᨣᨧ᩠ᨨᩴ, ᩈᩮᩣ ᨾᩮ ᩈᨲ᩠ᨳᩣ ᨽᩅᩥᩔᨲᩥ’’.

‘‘ᩅᨶ᩠ᨴᨶᩴ ¶ ᨴᩣᨶᩥ ᩅᨩ᩠ᨩᩣᩈᩥ, ᩃᩮᩣᨠᨶᩣᨳᩴ ᩋᨶᩩᨲ᩠ᨲᩁᩴ;

ᨸᨴᨠ᩠ᨡᩥᨱᨬ᩠ᨧ ᨠᨲ᩠ᩅᩣᨶ, ᩌᨴᩥᩈᩮᨿ᩠ᨿᩣᩈᩥ ᨴᨠ᩠ᨡᩥᨱᩴ’’.

‘‘ᩑᨲᩴ ᨡᩮᩣ ᩃᨻ᩠ᨽᨾᨾ᩠ᩉᩮᩉᩥ, ᨿᨳᩣ ᨽᩣᩈᩈᩥ ᨲ᩠ᩅᨬ᩠ᨧ ᨾᩮ;

ᩅᨶ᩠ᨴᨶᩴ ᨴᩣᨶᩥ ᨲᩮ ᩅᨩ᩠ᨩᩴ, ᩃᩮᩣᨠᨶᩣᨳᩴ ᩋᨶᩩᨲ᩠ᨲᩁᩴ;

ᨸᨴᨠ᩠ᨡᩥᨱᨬ᩠ᨧ ¶ ᨠᨲ᩠ᩅᩣᨶ, ᩌᨴᩥᩈᩥᩔᩣᨾᩥ ᨴᨠ᩠ᨡᩥᨱᩴ’’.

ᨲᨲᩮᩣ ¶ ᨧ ᨠᩣᩊᩮᩣ ᨸᨠ᩠ᨠᩣᨾᩥ, ᨶᨴᩥᩴ ᨶᩮᩁᨬ᩠ᨩᩁᩴ ᨸᨲᩥ;

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

ᨴᩩᨠ᩠ᨡᩴ ᨴᩩᨠ᩠ᨡᩈᨾᩩᨸ᩠ᨸᩣᨴᩴ, ᨴᩩᨠ᩠ᨡᩔ ᨧ ᩋᨲᩥᨠ᩠ᨠᨾᩴ;

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

ᨲᩔ ᨸᩣᨴᩣᨶᩥ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ, ᨠᨲ᩠ᩅᩣᨶ ᨶᩴ [ᨠᨲ᩠ᩅᩣᨶᩉᩴ (ᩈᩦ.)] ᨸᨴᨠ᩠ᨡᩥᨱᩴ;

ᨧᩣᨸᩣᨿ ᩌᨴᩥᩈᩥᨲ᩠ᩅᩣᨶ, ᨸᨻ᩠ᨻᨩᩥᩴ ᩋᨶᨣᩣᩁᩥᨿᩴ;

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

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

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

‘‘ᩈᩣᨩ᩠ᨩ ᩈᨻ᩠ᨻᩣᨶᩥ ᨡᩣᨴᩥᨲ᩠ᩅᩣ, ᩈᨲᨸᩩᨲ᩠ᨲᩣᨶᩥ [ᩈᨲ᩠ᨲ ᨸᩩᨲ᩠ᨲᩣᨶᩥ (ᩈ᩠ᨿᩣ.)] ᨻᩕᩣᩉ᩠ᨾᨱᩦ;

ᩅᩣᩈᩮᨭ᩠ᨮᩥ ᨠᩮᨶ ᩅᨱ᩠ᨱᩮᨶ, ᨶ ᨻᩣᩊ᩠ᩉᩴ ᨸᩁᩥᨲᨸ᩠ᨸᩈᩥ’’.

‘‘ᨻᩉᩪᨶᩥ ᨸᩩᨲ᩠ᨲᩈᨲᩣᨶᩥ, ᨬᩣᨲᩥᩈᨦ᩠ᨥᩈᨲᩣᨶᩥ ᨧ;

ᨡᩣᨴᩥᨲᩣᨶᩥ ᩋᨲᩦᨲᩴᩈᩮ, ᨾᨾ ᨲᩩᨿ᩠ᩉᨬ᩠ᨧ ᨻᩕᩣᩉ᩠ᨾᨱ.

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

ᨶ ¶ ᩈᩮᩣᨧᩣᨾᩥ ᨶ ᩁᩮᩣᨴᩣᨾᩥ, ᨶ ᨧᩣᨸᩥ ᨸᩁᩥᨲᨸ᩠ᨸᨿᩥᩴ’’.

‘‘ᩋᨻ᩠ᨽᩩᨲᩴ ¶ ᩅᨲ ᩅᩣᩈᩮᨭ᩠ᨮᩥ, ᩅᩣᨧᩴ ᨽᩣᩈᩈᩥ ᩑᨴᩥᩈᩥᩴ;

ᨠᩔ ᨲ᩠ᩅᩴ ᨵᨾ᩠ᨾᨾᨬ᩠ᨬᩣᨿ, ᨣᩥᩁᩴ [ᨳᩥᩁᩴ (ᩈᩦ.)] ᨽᩣᩈᩈᩥ ᩑᨴᩥᩈᩥᩴ’’.

‘‘ᩑᩈ ᨻᩕᩣᩉ᩠ᨾᨱ ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ, ᨶᨣᩁᩴ ᨾᩥᨳᩥᩃᩴ ᨸᨲᩥ;

ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᨸ᩠ᨸᩉᩣᨶᩣᨿ, ᨵᨾ᩠ᨾᩴ ᨴᩮᩈᩮᩈᩥ ᨸᩣᨱᩥᨶᩴ.

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

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

‘‘ᩈᩮᩣ ¶ ᩋᩉᨾ᩠ᨸᩥ ᨣᨾᩥᩔᩣᨾᩥ, ᨶᨣᩁᩴ ᨾᩥᨳᩥᩃᩴ ᨸᨲᩥ;

ᩋᨸ᩠ᨸᩮᩅ ᨾᩴ ᩈᩮᩣ ᨽᨣᩅᩣ, ᩈᨻ᩠ᨻᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩮᩣᨧᨿᩮ’’.

ᩋᨴ᩠ᨴᩈ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨻᩩᨴ᩠ᨵᩴ, ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩴ ᨶᩥᩁᩪᨸᨵᩥᩴ;

ᩈ᩠ᩅᩔ ᨵᨾ᩠ᨾᨾᨴᩮᩈᩮᩈᩥ, ᨾᩩᨶᩥ ᨴᩩᨠ᩠ᨡᩔ ᨸᩣᩁᨣᩪ.

ᨴᩩᨠ᩠ᨡᩴ ᨴᩩᨠ᩠ᨡᩈᨾᩩᨸ᩠ᨸᩣᨴᩴ, ᨴᩩᨠ᩠ᨡᩔ ᨧ ᩋᨲᩥᨠ᩠ᨠᨾᩴ;

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

ᨲᨲ᩠ᨳ ᩅᩥᨬ᩠ᨬᩣᨲᩈᨴ᩠ᨵᨾ᩠ᨾᩮᩣ, ᨸᨻ᩠ᨻᨩ᩠ᨩᩴ ᩈᨾᩁᩮᩣᨧᨿᩥ;

ᩈᩩᨩᩣᨲᩮᩣ ᨲᩦᩉᩥ ᩁᨲ᩠ᨲᩦᩉᩥ, ᨲᩥᩔᩮᩣ ᩅᩥᨩ᩠ᨩᩣ ᩋᨹᩔᨿᩥ.

‘‘ᩑᩉᩥ ᩈᩣᩁᨳᩥ ᨣᨧ᩠ᨨᩣᩉᩥ, ᩁᨳᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩣᩉᩥᨾᩴ;

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

ᩈᩩᨩᩣᨲᩮᩣ ᨲᩦᩉᩥ ᩁᨲ᩠ᨲᩦᩉᩥ, ᨲᩥᩔᩮᩣ ᩅᩥᨩ᩠ᨩᩣ ᩋᨹᩔᨿᩥ’’’.

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

ᩌᩁᩮᩣᨣ᩠ᨿᩴ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩥᩅᩮᩣᨧ, ‘‘ᨸᨻ᩠ᨻᨩᩥ ᨴᩣᨶᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᩈᩩᨩᩣᨲᩮᩣ ᨲᩦᩉᩥ ᩁᨲ᩠ᨲᩦᩉᩥ, ᨲᩥᩔᩮᩣ ᩅᩥᨩ᩠ᨩᩣ ᩋᨹᩔᨿᩥ’’.

‘‘ᩑᨲᨬ᩠ᨧᩣᩉᩴ ᩋᩔᩁᨳᩴ, ᩈᩉᩔᨬ᩠ᨧᩣᨸᩥ ᩈᩣᩁᨳᩥ;

ᨲᩮᩅᩥᨩ᩠ᨩᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩴ ᩈᩩᨲ᩠ᩅᩣ [ᨬᨲ᩠ᩅᩣ (ᩈᩦ.)], ᨸᩩᨱ᩠ᨱᨸᨲ᩠ᨲᩴ ᨴᨴᩣᨾᩥ ᨲᩮ’’.

‘‘ᨲᩩᨿ᩠ᩉᩮᩅ ᩉᩮᩣᨲ᩠ᩅᩔᩁᨳᩮᩣ, ᩈᩉᩔᨬ᩠ᨧᩣᨸᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩥ;

ᩋᩉᨾ᩠ᨸᩥ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᩅᩁᨸᨬ᩠ᨬᩔ ᩈᨶ᩠ᨲᩥᨠᩮ’’.

‘‘ᩉᨲ᩠ᨳᩦ ¶ ᨣᩅᩔᩴ ᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᨬ᩠ᨧ, ᨹᩦᨲᨬ᩠ᨧᩥᨾᩴ ᨣᩉᩅᩥᨽᩅᩴ ᨸᩉᩣᨿ;

ᨸᩥᨲᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ ᨲᩩᨿ᩠ᩉᩴ, ᨽᩩᨬ᩠ᨩ ᨽᩮᩣᨣᩣᨶᩥ ᩈᩩᨶ᩠ᨴᩁᩥ; ᨲᩩᩅᩴ ᨴᩣᨿᩣᨴᩥᨠᩣ ᨠᩩᩃᩮ’’.

‘‘ᩉᨲ᩠ᨳᩦ ᨣᩅᩔᩴ ᨾᨱᩥᨠᩩᨱ᩠ᨯᩃᨬ᩠ᨧ, ᩁᨾ᩠ᨾᩴ ᨧᩥᨾᩴ ᨣᩉᩅᩥᨽᩅᩴ ᨸᩉᩣᨿ;

ᨸᩥᨲᩣ ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ ᨾᨿ᩠ᩉᩴ, ᨸᩩᨲ᩠ᨲᩈᩮᩣᨠᩮᨶ ᩋᨭ᩠ᨭᩥᨲᩮᩣ;

ᩋᩉᨾ᩠ᨸᩥ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ, ᨽᩣᨲᩩᩈᩮᩣᨠᩮᨶ ᩋᨭ᩠ᨭᩥᨲᩣ’’.

‘‘ᩈᩮᩣ ᨲᩮ ᩍᨩ᩠ᨫᨲᩩ ᩈᨦ᩠ᨠᨸ᩠ᨸᩮᩣ, ᨿᩴ ᨲ᩠ᩅᩴ ᨸᨲ᩠ᨳᩮᩈᩥ ᩈᩩᨶ᩠ᨴᩁᩦ;

ᩏᨲ᩠ᨲᩥᨭ᩠ᨮᨸᩥᨱ᩠ᨯᩮᩣ ᩏᨬ᩠ᨨᩮᩣ ᨧ, ᨸᩴᩈᩩᨠᩪᩃᨬ᩠ᨧ ᨧᩦᩅᩁᩴ;

ᩑᨲᩣᨶᩥ ᩋᨽᩥᩈᨾ᩠ᨽᩮᩣᨶ᩠ᨲᩦ, ᨸᩁᩃᩮᩣᨠᩮ ᩋᨶᩣᩈᩅᩣ’’.

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

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

‘‘ᨲᩩᩅᩴ ¶ ¶ ᨶᩥᩔᩣᨿ ᨠᩃ᩠ᨿᩣᨱᩦ, ᨳᩮᩁᩦ ᩈᨦ᩠ᨥᩔ ᩈᩮᩣᨽᨶᩮ;

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

‘‘ᩋᨶᩩᨩᩣᨶᩣᩉᩥ ᨾᩮ ᩋᨿ᩠ᨿᩮ, ᩍᨧ᩠ᨨᩮ ᩈᩣᩅᨲ᩠ᨳᩥ ᨣᨶ᩠ᨲᩅᩮ;

ᩈᩦᩉᨶᩣᨴᩴ ᨶᨴᩥᩔᩣᨾᩥ, ᨻᩩᨴ᩠ᨵᩈᩮᨭ᩠ᨮᩔ ᩈᨶ᩠ᨲᩥᨠᩮ’’.

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

ᩋᨴᨶ᩠ᨲᩣᨶᩴ ᨴᨾᩮᨲᩣᩁᩴ, ᩈᨾ᩠ᨻᩩᨴ᩠ᨵᨾᨠᩩᨲᩮᩣᨽᨿᩴ’’.

‘‘ᨸᩔ ᩈᩩᨶ᩠ᨴᩁᩥᨾᩣᨿᨶ᩠ᨲᩥᩴ, ᩅᩥᨸ᩠ᨸᨾᩩᨲ᩠ᨲᩴ ᨶᩥᩁᩪᨸᨵᩥᩴ;

ᩅᩦᨲᩁᩣᨣᩴ ᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩴ, ᨠᨲᨠᩥᨧ᩠ᨧᨾᨶᩣᩈᩅᩴ.

‘‘ᨻᩣᩁᩣᨱᩈᩦᨲᩮᩣ ᨶᩥᨠ᩠ᨡᨾ᩠ᨾ, ᨲᩅ ᩈᨶ᩠ᨲᩥᨠᨾᩣᨣᨲᩣ;

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

‘‘ᨲᩩᩅᩴ ᨻᩩᨴ᩠ᨵᩮᩣ ᨲᩩᩅᩴ ᩈᨲ᩠ᨳᩣ, ᨲᩩᨿ᩠ᩉᩴ ᨵᩦᨲᩣᨾ᩠ᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱ;

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

‘‘ᨲᩔᩣ ¶ ᨲᩮ ᩈ᩠ᩅᩣᨣᨲᩴ ᨽᨴ᩠ᨴᩮ, ᨲᨲᩮᩣ [ᩋᨳᩮᩣ (ᨠ.)] ᨲᩮ ᩋᨴᩩᩁᩣᨣᨲᩴ;

ᩑᩅᨬ᩠ᩉᩥ ᨴᨶ᩠ᨲᩣ ᩌᨿᨶ᩠ᨲᩥ, ᩈᨲ᩠ᨳᩩ ᨸᩣᨴᩣᨶᩥ ᩅᨶ᩠ᨴᩥᨠᩣ;

ᩅᩦᨲᩁᩣᨣᩣ ᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩣ, ᨠᨲᨠᩥᨧ᩠ᨧᩣ ᩋᨶᩣᩈᩅᩣ’’.

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

ᨲᩔᩣ ᨾᩮ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩣᨿ, ᩈᨧ᩠ᨧᩣᨽᩥᩈᨾᨿᩮᩣ ᩋᩉᩩ.

‘‘ᨲᨲᩮᩣᩉᩴ ᩈᨻ᩠ᨻᨠᩣᨾᩮᩈᩩ, ᨽᩩᩈᩴ ᩋᩁᨲᩥᨾᨩ᩠ᨫᨣᩴ;

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

‘‘ᩉᩥᨲ᩠ᩅᩣᨶᩉᩴ ¶ ᨬᩣᨲᩥᨣᨱᩴ, ᨴᩣᩈᨠᨾ᩠ᨾᨠᩁᩣᨶᩥ ᨧ;

ᨣᩣᨾᨡᩮᨲ᩠ᨲᩣᨶᩥ ᨹᩦᨲᩣᨶᩥ, ᩁᨾᨱᩦᨿᩮ ᨸᨾᩮᩣᨴᩥᨲᩮ.

‘‘ᨸᩉᩣᨿᩉᩴ ¶ ᨸᨻ᩠ᨻᨩᩥᨲᩣ, ᩈᩣᨸᨲᩮᨿ᩠ᨿᨾᨶᨸ᩠ᨸᨠᩴ;

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

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

ᨿᩮᩣ [ᨿᩣ (ᩈ᩠ᨿᩣ.)] ᨩᩣᨲᩁᩪᨸᩴ ᩁᨩᨲᩴ, ᨨᨯ᩠ᨯᩮᨲ᩠ᩅᩣ [ᨳᨸᩮᨲ᩠ᩅᩣ (ᨠ.)] ᨸᩩᨶᩁᩣᨣᨾᩮ [ᨸᩩᨶᩁᩣᨣᩉᩮ (ᨠ.)].

‘‘ᩁᨩᨲᩴ ¶ ᨩᩣᨲᩁᩪᨸᩴ ᩅᩣ, ᨶ ᨻᩮᩣᨵᩣᨿ ᨶ ᩈᨶ᩠ᨲᩥᨿᩣ;

ᨶᩮᨲᩴ ᩈᨾᨱᩈᩣᩁᩩᨸ᩠ᨸᩴ, ᨶ ᩑᨲᩴ ᩋᩁᩥᨿᨴ᩠ᨵᨶᩴ.

‘‘ᩃᩮᩣᨽᨶᩴ ᨾᨴᨶᨬ᩠ᨧᩮᨲᩴ, ᨾᩮᩣᩉᨶᩴ ᩁᨩᩅᨯ᩠ᨰᨶᩴ;

ᩈᩣᩈᨦ᩠ᨠᩴ ᨻᩉᩩᩌᨿᩣᩈᩴ, ᨶᨲ᩠ᨳᩥ ᨧᩮᨲ᩠ᨳ ᨵᩩᩅᩴ ᨮᩥᨲᩥ.

‘‘ᩑᨲ᩠ᨳ ᩁᨲ᩠ᨲᩣ ᨸᨾᨲ᩠ᨲᩣ ᨧ, ᩈᨦ᩠ᨠᩥᩃᩥᨭ᩠ᨮᨾᨶᩣ ᨶᩁᩣ;

ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩮᨶ ᨻ᩠ᨿᩣᩁᩩᨴ᩠ᨵᩣ, ᨸᩩᨳᩩ ᨠᩩᨻ᩠ᨻᨶ᩠ᨲᩥ ᨾᩮᨵᨣᩴ.

‘‘ᩅᨵᩮᩣ ᨻᨶ᩠ᨵᩮᩣ ᨸᩁᩥᨠ᩠ᩃᩮᩈᩮᩣ, ᨩᩣᨶᩥ ᩈᩮᩣᨠᨸᩁᩥᨴ᩠ᨴᩅᩮᩣ;

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

‘‘ᨲᩴ ᨾᩴ ᨬᩣᨲᩦ ᩋᨾᩥᨲ᩠ᨲᩣᩅ, ᨠᩥᩴ ᩅᩮᩣ ᨠᩣᨾᩮᩈᩩ ᨿᩩᨬ᩠ᨩᨳ;

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

‘‘ᨶ ¶ ᩉᩥᩁᨬ᩠ᨬᩈᩩᩅᨱ᩠ᨱᩮᨶ, ᨸᩁᩥᨠ᩠ᨡᩦᨿᨶ᩠ᨲᩥ ᩌᩈᩅᩣ;

ᩋᨾᩥᨲ᩠ᨲᩣ ᩅᨵᨠᩣ ᨠᩣᨾᩣ, ᩈᨸᨲ᩠ᨲᩣ ᩈᩃ᩠ᩃᨻᨶ᩠ᨵᨶᩣ.

‘‘ᨲᩴ ¶ ᨾᩴ ᨬᩣᨲᩦ ᩋᨾᩥᨲ᩠ᨲᩣᩅ, ᨠᩥᩴ ᩅᩮᩣ ᨠᩣᨾᩮᩈᩩ ᨿᩩᨬ᩠ᨩᨳ;

ᨩᩣᨶᩣᨳ ᨾᩴ ᨸᨻ᩠ᨻᨩᩥᨲᩴ, ᨾᩩᨱ᩠ᨯᩴ ᩈᨦ᩠ᨥᩣᨭᩥᨸᩣᩁᩩᨲᩴ.

‘‘ᩏᨲ᩠ᨲᩥᨭ᩠ᨮᨸᩥᨱ᩠ᨯᩮᩣ ᩏᨬ᩠ᨨᩮᩣ ᨧ, ᨸᩴᩈᩩᨠᩪᩃᨬ᩠ᨧ ᨧᩦᩅᩁᩴ;

ᩑᨲᩴ ᨡᩮᩣ ᨾᨾ ᩈᩣᩁᩩᨸ᩠ᨸᩴ, ᩋᨶᨣᩣᩁᩪᨸᨶᩥᩔᨿᩮᩣ.

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

ᨡᩮᨾᨭ᩠ᨮᩣᨶᩮ ᩅᩥᨾᩩᨲ᩠ᨲᩣ ᨲᩮ, ᨸᨲ᩠ᨲᩣ ᨲᩮ ᩋᨧᩃᩴ ᩈᩩᨡᩴ.

‘‘ᨾᩣᩉᩴ ᨠᩣᨾᩮᩉᩥ ᩈᨦ᩠ᨣᨧ᩠ᨨᩥᩴ, ᨿᩮᩈᩩ ᨲᩣᨱᩴ ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ;

ᩋᨾᩥᨲ᩠ᨲᩣ ᩅᨵᨠᩣ ᨠᩣᨾᩣ, ᩋᨣ᩠ᨣᩥᨠ᩠ᨡᨶ᩠ᨵᩪᨸᨾᩣ ᨴᩩᨡᩣ.

‘‘ᨸᩁᩥᨸᨶ᩠ᨳᩮᩣ ¶ ᩑᩈ ᨽᨿᩮᩣ, ᩈᩅᩥᨥᩣᨲᩮᩣ ᩈᨠᨱ᩠ᨭᨠᩮᩣ;

ᨣᩮᨵᩮᩣ ᩈᩩᩅᩥᩈᨾᩮᩣ ᨧᩮᩈᩮᩣ [ᩃᩮᨸᩮᩣ (ᩈᩦ.)], ᨾᩉᨶ᩠ᨲᩮᩣ ᨾᩮᩣᩉᨶᩣᨾᩩᨡᩮᩣ.

‘‘ᩏᨸᩈᨣ᩠ᨣᩮᩣ ᨽᩦᨾᩁᩪᨸᩮᩣ, ᨠᩣᨾᩣ ᩈᨸ᩠ᨸᩈᩥᩁᩪᨸᨾᩣ;

ᨿᩮ ᨻᩣᩃᩣ ᩋᨽᩥᨶᨶ᩠ᨴᨶ᩠ᨲᩥ, ᩋᨶ᩠ᨵᨽᩪᨲᩣ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩣ.

‘‘ᨠᩣᨾᨸᨦ᩠ᨠᩮᨶ ᩈᨲ᩠ᨲᩣ ᩉᩥ, ᨻᩉᩪ ᩃᩮᩣᨠᩮ ᩋᩅᩥᨴ᩠ᨴᩈᩪ;

ᨸᩁᩥᨿᨶ᩠ᨲᩴ ᨶ ᨩᩣᨶᨶ᩠ᨲᩥ, ᨩᩣᨲᩥᨿᩣ ᨾᩁᨱᩔ ᨧ.

‘‘ᨴᩩᨣ᩠ᨣᨲᩥᨣᨾᨶᩴ ᨾᨣ᩠ᨣᩴ, ᨾᨶᩩᩔᩣ ᨠᩣᨾᩉᩮᨲᩩᨠᩴ;

ᨻᩉᩩᩴ ᩅᩮ ᨸᨭᩥᨸᨩ᩠ᨩᨶ᩠ᨲᩥ, ᩋᨲ᩠ᨲᨶᩮᩣ ᩁᩮᩣᨣᨾᩣᩅᩉᩴ.

‘‘ᩑᩅᩴ ¶ ᩋᨾᩥᨲ᩠ᨲᨩᨶᨶᩣ, ᨲᩣᨸᨶᩣ ᩈᩴᨠᩥᩃᩮᩈᩥᨠᩣ;

ᩃᩮᩣᨠᩣᨾᩥᩈᩣ ᨻᨶ᩠ᨵᨶᩦᨿᩣ, ᨠᩣᨾᩣ ᨾᩁᨱᨻᨶ᩠ᨵᨶᩣ [ᨧᩁᨱᨻᨶ᩠ᨵᨶᩣ (ᩈᩦ.)].

‘‘ᩏᨾ᩠ᨾᩣᨴᨶᩣ ¶ ᩏᩃ᩠ᩃᨸᨶᩣ, ᨠᩣᨾᩣ ᨧᩥᨲ᩠ᨲᨸ᩠ᨸᨾᨴ᩠ᨴᩥᨶᩮᩣ;

ᩈᨲ᩠ᨲᩣᨶᩴ ᩈᨦ᩠ᨠᩥᩃᩮᩈᩣᨿ, ᨡᩥᨸ᩠ᨸᩴ [ᨡᩥᨸᩴ (ᩈᩦ.)] ᨾᩣᩁᩮᨶ ᩒᨯ᩠ᨯᩥᨲᩴ.

‘‘ᩋᨶᨶ᩠ᨲᩣᨴᩦᨶᩅᩣ ᨠᩣᨾᩣ, ᨻᩉᩩᨴᩩᨠ᩠ᨡᩣ ᨾᩉᩣᩅᩥᩈᩣ;

ᩋᨸ᩠ᨸᩔᩣᨴᩣ ¶ ᩁᨱᨠᩁᩣ, ᩈᩩᨠ᩠ᨠᨸᨠ᩠ᨡᩅᩥᩈᩮᩣᩈᨶᩣ [ᩅᩥᩈᩮᩣᩈᨠᩣ (ᩈᩦ.)].

‘‘ᩈᩣᩉᩴ ᩑᨲᩣᨴᩥᩈᩴ ᨠᨲ᩠ᩅᩣ, ᨻ᩠ᨿᩈᨶᩴ ᨠᩣᨾᩉᩮᨲᩩᨠᩴ;

ᨶ ᨲᩴ ᨸᨧ᩠ᨧᩣᨣᨾᩥᩔᩣᨾᩥ, ᨶᩥᨻ᩠ᨻᩣᨶᩣᨽᩥᩁᨲᩣ ᩈᨴᩣ.

‘‘ᩁᨱᩴ ᨠᩁᩥᨲ᩠ᩅᩣ [ᨲᩁᩥᨲ᩠ᩅᩣ (ᩈᩦ.)] ᨠᩣᨾᩣᨶᩴ, ᩈᩦᨲᩥᨽᩣᩅᩣᨽᩥᨠᨦ᩠ᨡᩥᨶᩦ;

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

‘‘ᩋᩈᩮᩣᨠᩴ ᩅᩥᩁᨩᩴ ᨡᩮᨾᩴ, ᩋᩁᩥᨿᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩴ ᩏᨩᩩᩴ;

ᨲᩴ ᨾᨣ᩠ᨣᩴ ᩋᨶᩩᨣᨧ᩠ᨨᩣᨾᩥ, ᨿᩮᨶ ᨲᩥᨱ᩠ᨱᩣ ᨾᩉᩮᩈᩥᨶᩮᩣ’’.

ᩍᨾᩴ ᨸᩔᨳ ᨵᨾ᩠ᨾᨭ᩠ᨮᩴ, ᩈᩩᨽᩴ ᨠᨾ᩠ᨾᩣᩁᨵᩦᨲᩁᩴ;

ᩋᨶᩮᨩᩴ ᩏᨸᩈᨾ᩠ᨸᨩ᩠ᨩ, ᩁᩩᨠ᩠ᨡᨾᩪᩃᨾ᩠ᩉᩥ ᨫᩣᨿᨲᩥ.

ᩋᨩ᩠ᨩᨭ᩠ᨮᨾᩦ ᨸᨻ᩠ᨻᨩᩥᨲᩣ, ᩈᨴ᩠ᨵᩣ ᩈᨴ᩠ᨵᨾ᩠ᨾᩈᩮᩣᨽᨶᩣ;

ᩅᩥᨶᩦᨲᩩᨸ᩠ᨸᩃᩅᨱ᩠ᨱᩣᨿ, ᨲᩮᩅᩥᨩ᩠ᨩᩣ ᨾᨧ᩠ᨧᩩᩉᩣᨿᩥᨶᩦ.

ᩈᩣᨿᩴ ¶ ᨽᩩᨩᩥᩔᩣ ᩋᨶᨱᩣ, ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᨽᩣᩅᩥᨲᩥᨶ᩠ᨴᩕᩥᨿᩣ;

ᩈᨻ᩠ᨻᨿᩮᩣᨣᩅᩥᩈᩴᨿᩩᨲ᩠ᨲᩣ, ᨠᨲᨠᩥᨧ᩠ᨧᩣ ᩋᨶᩣᩈᩅᩣ.

ᨲᩴ ᩈᨠ᩠ᨠᩮᩣ ᨴᩮᩅᩈᨦ᩠ᨥᩮᨶ, ᩏᨸᩈᨦ᩠ᨠᨾ᩠ᨾ ᩍᨴ᩠ᨵᩥᨿᩣ;

ᨶᨾᩔᨲᩥ ᨽᩪᨲᨸᨲᩥ, ᩈᩩᨽᩴ ᨠᨾ᩠ᨾᩣᩁᨵᩦᨲᩁᨶ᩠ᨲᩥ.

ᨩᩦᩅᨠᨾ᩠ᨻᩅᨶᩴ ¶ ¶ ¶ ᩁᨾ᩠ᨾᩴ, ᨣᨧ᩠ᨨᨶ᩠ᨲᩥᩴ ᨽᩥᨠ᩠ᨡᩩᨶᩥᩴ ᩈᩩᨽᩴ;

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

‘‘ᨠᩥᩴ ᨲᩮ ᩋᨸᩁᩣᨵᩥᨲᩴ ᨾᨿᩣ, ᨿᩴ ᨾᩴ ᩒᩅᩁᩥᨿᩣᨶ ᨲᩥᨭ᩠ᨮᩈᩥ;

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

‘‘ᨣᩁᩩᨠᩮ ᨾᨾ ᩈᨲ᩠ᨳᩩᩈᩣᩈᨶᩮ, ᨿᩣ ᩈᩥᨠ᩠ᨡᩣ ᩈᩩᨣᨲᩮᨶ ᨴᩮᩈᩥᨲᩣ;

ᨸᩁᩥᩈᩩᨴ᩠ᨵᨸᨴᩴ ¶ ᩋᨶᨦ᩠ᨣᨱᩴ, ᨠᩥᩴ ᨾᩴ ᩒᩅᩁᩥᨿᩣᨶ ᨲᩥᨭ᩠ᨮᩈᩥ.

‘‘ᩌᩅᩥᩃᨧᩥᨲ᩠ᨲᩮᩣ ᩋᨶᩣᩅᩥᩃᩴ, ᩈᩁᨩᩮᩣ ᩅᩦᨲᩁᨩᩴ ᩋᨶᨦ᩠ᨣᨱᩴ;

ᩈᨻ᩠ᨻᨲ᩠ᨳ ᩅᩥᨾᩩᨲ᩠ᨲᨾᩣᨶᩈᩴ, ᨠᩥᩴ ᨾᩴ ᩒᩅᩁᩥᨿᩣᨶ ᨲᩥᨭ᩠ᨮᩈᩥ’’.

‘‘ᨴᩉᩁᩣ ᨧ ᩋᨸᩣᨸᩥᨠᩣ ᨧᩈᩥ, ᨠᩥᩴ ᨲᩮ ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ ᨠᩁᩥᩔᨲᩥ;

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

‘‘ᨾᨵᩩᩁᨬ᩠ᨧ ᨸᩅᨶ᩠ᨲᩥ ᩈᨻ᩠ᨻᩈᩮᩣ, ᨠᩩᩈᩩᨾᩁᨩᩮᨶ ᩈᨾᩩᨭ᩠ᨮᩥᨲᩣ ᨴᩩᨾᩣ;

ᨸᨮᨾᩅᩈᨶ᩠ᨲᩮᩣ ᩈᩩᨡᩮᩣ ᩏᨲᩩ, ᩑᩉᩥ ᩁᨾᩣᨾ ᩈᩩᨸᩩᨸ᩠ᨹᩥᨲᩮ ᩅᨶᩮ.

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

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

‘‘ᩅᩣᩊᨾᩥᨣᩈᨦ᩠ᨥᩈᩮᩅᩥᨲᩴ ¶ , ᨠᩩᨬ᩠ᨩᩁᨾᨲ᩠ᨲᨠᩁᩮᨱᩩᩃᩮᩣᩊᩥᨲᩴ;

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

‘‘ᨲᨸᨶᩦᨿᨠᨲᩣᩅ ᨵᩦᨲᩥᨠᩣ, ᩅᩥᨧᩁᩈᩥ ᨧᩥᨲ᩠ᨲᩃᨲᩮᩅ ᩋᨧ᩠ᨨᩁᩣ;

ᨠᩣᩈᩥᨠᩈᩩᨡᩩᨾᩮᩉᩥ ¶ ᩅᨣ᩠ᨣᩩᨽᩥ, ᩈᩮᩣᨽᩈᩦ ᩈᩩᩅᩈᨶᩮᩉᩥ ᨶᩪᨸᨾᩮ.

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

ᨶ ᩉᩥ ᨾᨲ᩠ᨳᩥ ᨲᨿᩣ ᨸᩥᨿᨲ᩠ᨲᩁᩮᩣ, ᨸᩣᨱᩮᩣ ᨠᩥᨶ᩠ᨶᩁᩥᨾᨶ᩠ᨴᩃᩮᩣᨧᨶᩮ.

‘‘ᨿᨴᩥ ᨾᩮ ᩅᨧᨶᩴ ᨠᩁᩥᩔᩈᩥ, ᩈᩩᨡᩥᨲᩣ ᩑᩉᩥ ᩋᨣᩣᩁᨾᩣᩅᩈ;

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

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

ᨠᨬ᩠ᨧᨶᨾᨱᩥᨾᩩᨲ᩠ᨲᨠᩴ ¶ ᨻᩉᩩᩴ, ᩅᩥᩅᩥᨵᩴ ᩌᨽᩁᨱᩴ ᨠᩁᩮᩣᨾᩥ ᨲᩮ.

‘‘ᩈᩩᨵᩮᩣᨲᩁᨩᨸᨧ᩠ᨨᨴᩴ ¶ ᩈᩩᨽᩴ, ᨣᩮᩣᨱᨠᨲᩪᩃᩥᨠᩈᨶ᩠ᨳᨲᩴ ᨶᩅᩴ;

ᩋᨽᩥᩁᩩᩉ ᩈᨿᨶᩴ ᨾᩉᩣᩁᩉᩴ, ᨧᨶ᩠ᨴᨶᨾᨱ᩠ᨯᩥᨲᩈᩣᩁᨣᨶ᩠ᨵᩥᨠᩴ;

‘‘ᩏᨸ᩠ᨸᩃᩴ ᨧᩩᨴᨠᩣ ᩈᨾᩩᨣ᩠ᨣᨲᩴ, ᨿᨳᩣ ᨲᩴ ᩋᨾᨶᩩᩔᩈᩮᩅᩥᨲᩴ;

ᩑᩅᩴ ᨲ᩠ᩅᩴ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩦ, ᩈᨠᩮᩈᨦ᩠ᨣᩮᩈᩩ ᨩᩁᩴ ᨣᨾᩥᩔᩈᩥ’’.

‘‘ᨠᩥᩴ ¶ ᨲᩮ ᩍᨵ ᩈᩣᩁᩈᨾ᩠ᨾᨲᩴ, ᨠᩩᨱᨸᨸᩪᩁᨾ᩠ᩉᩥ ᩈᩩᩈᩣᨶᩅᨯ᩠ᨰᨶᩮ;

ᨽᩮᨴᨶᨵᨾ᩠ᨾᩮ ᨠᩊᩮᩅᩁᩮ [ᨠᩃᩮᩅᩁᩮ (ᩈᩦ. ᨠ.)], ᨿᩴ ᨴᩥᩈ᩠ᩅᩣ ᩅᩥᨾᨶᩮᩣ ᩏᨴᩥᨠ᩠ᨡᩈᩥ’’.

‘‘ᩋᨠ᩠ᨡᩦᨶᩥ ᨧ ᨲᩩᩁᩥᨿᩣᩁᩥᩅ, ᨠᩥᨶ᩠ᨶᩁᩥᨿᩣᩁᩥᩅ ᨸᨻ᩠ᨻᨲᨶ᩠ᨲᩁᩮ;

ᨲᩅ ᨾᩮ ᨶᨿᨶᩣᨶᩥ ᨴᨠ᩠ᨡᩥᨿ, ᨽᩥᨿ᩠ᨿᩮᩣ ᨠᩣᨾᩁᨲᩦ ᨸᩅᨯ᩠ᨰᨲᩥ.

‘‘ᩏᨸ᩠ᨸᩃᩈᩥᨡᩁᩮᩣᨸᨾᩣᨶᩥ ᨲᩮ, ᩅᩥᨾᩃᩮ ᩉᩣᨭᨠᩈᨶ᩠ᨶᩥᨽᩮ ᨾᩩᨡᩮ;

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

‘‘ᩋᨸᩥ ᨴᩪᩁᨣᨲᩣ ᩈᩁᨾ᩠ᩉᩈᩮ, ᩌᨿᨲᨸᨾ᩠ᩉᩮ ᩅᩥᩈᩩᨴ᩠ᨵᨴᩔᨶᩮ;

ᨶ ¶ ᩉᩥ ᨾᨲ᩠ᨳᩥ ᨲᨿᩣ ᨸᩥᨿᨲ᩠ᨲᩁᩣ, ᨶᨿᨶᩣ ᨠᩥᨶ᩠ᨶᩁᩥᨾᨶ᩠ᨴᩃᩮᩣᨧᨶᩮ’’.

‘‘ᩋᨸᨳᩮᨶ ᨸᨿᩣᨲᩩᨾᩥᨧ᩠ᨨᩈᩥ, ᨧᨶ᩠ᨴᩴ ᨠᩦᩊᨶᨠᩴ ᨣᩅᩮᩈᩈᩥ;

ᨾᩮᩁᩩᩴ ᩃᨦ᩠ᨥᩮᨲᩩᨾᩥᨧ᩠ᨨᩈᩥ, ᨿᩮᩣ ᨲ᩠ᩅᩴ ᨻᩩᨴ᩠ᨵᩈᩩᨲᩴ ᨾᨣ᩠ᨣᨿᩈᩥ.

‘‘ᨶᨲ᩠ᨳᩥ ¶ ᩉᩥ ᩃᩮᩣᨠᩮ ᩈᨴᩮᩅᨠᩮ, ᩁᩣᨣᩮᩣ ᨿᨲ᩠ᨳᨸᩥ ᨴᩣᨶᩥ ᨾᩮ ᩈᩥᨿᩣ;

ᨶᨸᩥ ᨶᩴ ᨩᩣᨶᩣᨾᩥ ᨠᩦᩁᩥᩈᩮᩣ, ᩋᨳ ᨾᨣ᩠ᨣᩮᨶ ᩉᨲᩮᩣ ᩈᨾᩪᩃᨠᩮᩣ.

‘‘ᩍᨦ᩠ᨣᩣᩃᨠᩩᨿᩣᩅ [ᩍᨦ᩠ᨥᩣᩊᨡᩩᨿᩣᩅ (ᩈ᩠ᨿᩣ.)] ᩏᨩ᩠ᨫᩥᨲᩮᩣ, ᩅᩥᩈᨸᨲ᩠ᨲᩮᩣᩁᩥᩅ ᩋᨣ᩠ᨣᩥᨲᩮᩣ ᨠᨲᩮᩣ [ᩋᨣ᩠ᨥᨲᩮᩣ ᩉᨲᩮᩣ (ᩈᩦ.)];

ᨶᨸᩥ ᨶᩴ ᨸᩔᩣᨾᩥ ᨠᩦᩁᩥᩈᩮᩣ, ᩋᨳ ᨾᨣ᩠ᨣᩮᨶ ᩉᨲᩮᩣ ᩈᨾᩪᩃᨠᩮᩣ.

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

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

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

ᩈᨦ᩠ᨡᨲᨾᩈᩩᨽᨶ᩠ᨲᩥ ᨩᩣᨶᩥᨿ, ᩈᨻ᩠ᨻᨲ᩠ᨳᩮᩅ ᨾᨶᩮᩣ ᨶ ᩃᩥᨾ᩠ᨸᨲᩥ.

‘‘ᩈᩣᩉᩴ ᩈᩩᨣᨲᩔ ᩈᩣᩅᩥᨠᩣ, ᨾᨣ᩠ᨣᨭ᩠ᨮᨦ᩠ᨣᩥᨠᨿᩣᨶᨿᩣᨿᩥᨶᩦ;

ᩏᨴ᩠ᨵᨭᩈᩃ᩠ᩃᩣ ᩋᨶᩣᩈᩅᩣ, ᩈᩩᨬ᩠ᨬᩣᨣᩣᩁᨣᨲᩣ ᩁᨾᩣᨾᩉᩴ.

‘‘ᨴᩥᨭ᩠ᨮᩣ ᩉᩥ ᨾᨿᩣ ᩈᩩᨧᩥᨲ᩠ᨲᩥᨲᩣ, ᩈᩮᩣᨾ᩠ᨽᩣ ᨴᩣᩁᩩᨠᨸᩥᩃ᩠ᩃᨠᩣᨶᩥ ᩅᩣ;

ᨲᨶ᩠ᨲᩦᩉᩥ ᨧ ᨡᩦᩃᨠᩮᩉᩥ ᨧ, ᩅᩥᨶᩥᨻᨴ᩠ᨵᩣ ᩅᩥᩅᩥᨵᩴ ᨸᨶᨧ᩠ᨧᨠᩣ.

‘‘ᨲᨾ᩠ᩉᩩᨴ᩠ᨵᨭᩮ ᨲᨶ᩠ᨲᩥᨡᩦᩃᨠᩮ, ᩅᩥᩔᨭ᩠ᨮᩮ ᩅᩥᨠᩃᩮ ᨸᩁᩥᨠᩕᩥᨲᩮ [ᨸᩁᩥᨸᨠ᩠ᨡᩦᨲᩮ (ᩈᩦ.), ᨸᩁᩥᨸᨠ᩠ᨠᨲᩮ (ᩈ᩠ᨿᩣ.)];

ᨶ ᩅᩥᨶ᩠ᨴᩮᨿ᩠ᨿ ᨡᨱ᩠ᨯᩈᩮᩣ ᨠᨲᩮ, ᨠᩥᨾ᩠ᩉᩥ ᨲᨲ᩠ᨳ ᨾᨶᩴ ᨶᩥᩅᩮᩈᨿᩮ.

‘‘ᨲᨳᩪᨸᨾᩣ ¶ ᨴᩮᩉᨠᩣᨶᩥ ᨾᩴ, ᨲᩮᩉᩥ ᨵᨾ᩠ᨾᩮᩉᩥ ᩅᩥᨶᩣ ᨶ ᩅᨲ᩠ᨲᨶ᩠ᨲᩥ;

ᨵᨾ᩠ᨾᩮᩉᩥ ¶ ᩅᩥᨶᩣ ᨶ ᩅᨲ᩠ᨲᨲᩥ, ᨠᩥᨾ᩠ᩉᩥ ᨲᨲ᩠ᨳ ᨾᨶᩴ ᨶᩥᩅᩮᩈᨿᩮ.

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

ᨲᨾ᩠ᩉᩥ ¶ ᨲᩮ ᩅᩥᨸᩁᩦᨲᨴᩔᨶᩴ, ᩈᨬ᩠ᨬᩣ ᨾᩣᨶᩩᩈᩥᨠᩣ ᨶᩥᩁᨲ᩠ᨳᩥᨠᩣ.

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

ᩏᨸᨣᨧ᩠ᨨᩈᩥ ᩋᨶ᩠ᨵ ᩁᩥᨲ᩠ᨲᨠᩴ, ᨩᨶᨾᨩ᩠ᨫᩮᩁᩥᩅ ᩁᩩᨸ᩠ᨸᩁᩪᨸᨠᩴ [ᩁᩪᨸᩁᩪᨸᨠᩴ (ᨠ.)].

‘‘ᩅᨭ᩠ᨭᨶᩥᩁᩥᩅ ᨠᩮᩣᨭᩁᩮᩣᩉᩥᨲᩣ, ᨾᨩ᩠ᨫᩮ ᨸᩩᨻ᩠ᨻᩩᩊᨠᩣ ᩈᩋᩔᩩᨠᩣ;

ᨸᩦᩊᨠᩮᩣᩊᩥᨠᩣ ᨧᩮᨲ᩠ᨳ ᨩᩣᨿᨲᩥ, ᩅᩥᩅᩥᨵᩣ ᨧᨠ᩠ᨡᩩᩅᩥᨵᩣ ᨧ ᨸᩥᨱ᩠ᨯᩥᨲᩣ’’.

ᩏᨸ᩠ᨸᩣᨭᩥᨿ ᨧᩣᩁᩩᨴᩔᨶᩣ, ᨶ ᨧ ᨸᨩ᩠ᨩᩥᨲ᩠ᨳ ᩋᩈᨦ᩠ᨣᨾᩣᨶᩈᩣ;

‘‘ᩉᨶ᩠ᨴ ᨲᩮ ᨧᨠ᩠ᨡᩩᩴ ᩉᩁᩔᩩ ᨲᩴ’’, ᨲᩔ ᨶᩁᩔ ᩋᨴᩣᩈᩥ ᨲᩣᩅᨴᩮ.

ᨲᩔ ᨧ ᩅᩥᩁᨾᩣᩈᩥ ᨲᩣᩅᨴᩮ, ᩁᩣᨣᩮᩣ ᨲᨲ᩠ᨳ ᨡᨾᩣᨸᨿᩦ ᨧ ᨶᩴ;

‘‘ᩈᩮᩣᨲ᩠ᨳᩥ ᩈᩥᨿᩣ ᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩦ, ᨶ ᨸᩩᨶᩮᩣ ᩑᨴᩥᩈᨠᩴ ᨽᩅᩥᩔᨲᩥ’’.

‘‘ᩌᩈᩣᨴᩥᨿ [ᩌᩉᨶᩥᨿ (ᩈ᩠ᨿᩣ. ᨠ.)] ᩑᨴᩥᩈᩴ ᨩᨶᩴ, ᩋᨣ᩠ᨣᩥᩴ ᨸᨩ᩠ᨩᩃᩥᨲᩴ ᩅ ᩃᩥᨦ᩠ᨣᩥᨿ;

ᨣᨱ᩠ᩉᩥᨿ ᩌᩈᩦᩅᩥᩈᩴ ᩅᩥᨿ, ᩋᨸᩥ ᨶᩩ ᩈᩮᩣᨲ᩠ᨳᩥ ᩈᩥᨿᩣ ᨡᨾᩮᩉᩥ ᨶᩮᩣ’’.

ᨾᩩᨲ᩠ᨲᩣ ᨧ ᨲᨲᩮᩣ ᩈᩣ ᨽᩥᨠ᩠ᨡᩩᨶᩦ, ᩋᨣᨾᩦ ᨻᩩᨴ᩠ᨵᩅᩁᩔ ᩈᨶ᩠ᨲᩥᨠᩴ;

ᨸᩔᩥᨿ ᩅᩁᨸᩩᨬ᩠ᨬᩃᨠ᩠ᨡᨱᩴ, ᨧᨠ᩠ᨡᩩ ᩌᩈᩥ ᨿᨳᩣ ᨸᩩᩁᩣᨱᨠᨶ᩠ᨲᩥ.

ᨶᨣᩁᨾ᩠ᩉᩥ ¶ ¶ ᨠᩩᩈᩩᨾᨶᩣᨾᩮ, ᨸᩣᨭᩃᩥᨸᩩᨲ᩠ᨲᨾ᩠ᩉᩥ ᨸᨳᩅᩥᨿᩣ ᨾᨱ᩠ᨯᩮ;

ᩈᨠ᩠ᨿᨠᩩᩃᨠᩩᩃᩦᨶᩣᨿᩮᩣ, ᨴ᩠ᩅᩮ ᨽᩥᨠ᩠ᨡᩩᨶᩥᨿᩮᩣ ᩉᩥ ᨣᩩᨱᩅᨲᩥᨿᩮᩣ.

ᩍᩈᩥᨴᩣᩈᩦ ¶ ᨲᨲ᩠ᨳ ᩑᨠᩣ, ᨴᩩᨲᩥᨿᩣ ᨻᩮᩣᨵᩦᨲᩥ ᩈᩦᩃᩈᨾ᩠ᨸᨶ᩠ᨶᩣ ᨧ;

ᨫᩣᨶᨩ᩠ᨫᩣᨿᨶᩁᨲᩣᨿᩮᩣ, ᨻᩉᩩᩔᩩᨲᩣᨿᩮᩣ ᨵᩩᨲᨠᩥᩃᩮᩈᩣᨿᩮᩣ.

ᨲᩣ ¶ ᨸᩥᨱ᩠ᨯᩣᨿ ᨧᩁᩥᨲ᩠ᩅᩣ, ᨽᨲ᩠ᨲᨲ᩠ᨳᩴ [ᨽᨲ᩠ᨲᨲ᩠ᨲᩴ (ᩈᩦ.)] ᨠᩁᩥᨿ ᨵᩮᩣᨲᨸᨲ᩠ᨲᩣᨿᩮᩣ;

ᩁᩉᩥᨲᨾ᩠ᩉᩥ ᩈᩩᨡᨶᩥᩈᩥᨶ᩠ᨶᩣ, ᩍᨾᩣ ᨣᩥᩁᩣ ᩋᨻ᩠ᨽᩩᨴᩦᩁᩮᩈᩩᩴ.

‘‘ᨸᩣᩈᩣᨴᩥᨠᩣᩈᩥ ᩋᨿ᩠ᨿᩮ, ᩍᩈᩥᨴᩣᩈᩥ ᩅᨿᩮᩣᨸᩥ ᨲᩮ ᩋᨸᩁᩥᩉᩦᨶᩮᩣ;

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

ᩑᩅᨾᨶᩩᨿᩩᨬ᩠ᨩᩥᨿᨾᩣᨶᩣ ᩈᩣ, ᩁᩉᩥᨲᩮ ᨵᨾ᩠ᨾᨴᩮᩈᨶᩣᨠᩩᩈᩃᩣ;

ᩍᩈᩥᨴᩣᩈᩦ ᩅᨧᨶᨾᨻᩕᩅᩥ, ‘‘ᩈᩩᨱ ᨻᩮᩣᨵᩥ ᨿᨳᩣᨾ᩠ᩉᩥ ᨸᨻ᩠ᨻᨩᩥᨲᩣ.

‘‘ᩏᨩ᩠ᨩᩮᨶᩥᨿᩣ ᨸᩩᩁᩅᩁᩮ, ᨾᨿ᩠ᩉᩴ ᨸᩥᨲᩣ ᩈᩦᩃᩈᩴᩅᩩᨲᩮᩣ ᩈᩮᨭ᩠ᨮᩥ;

ᨲᩔᨾ᩠ᩉᩥ ᩑᨠᨵᩦᨲᩣ, ᨸᩥᨿᩣ ᨾᨶᩣᨸᩣ ᨧ ᨴᨿᩥᨲᩣ ᨧ.

‘‘ᩋᨳ ᨾᩮ ᩈᩣᨠᩮᨲᨲᩮᩣ ᩅᩁᨠᩣ, ᩌᨣᨧ᩠ᨨᩩᨾᩩᨲ᩠ᨲᨾᨠᩩᩃᩦᨶᩣ;

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

‘‘ᩈᩔᩩᨿᩣ ᩈᩔᩩᩁᩔ ᨧ, ᩈᩣᨿᩴ ᨸᩣᨲᩴ ᨸᨱᩣᨾᨾᩩᨸᨣᨾ᩠ᨾ;

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

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

ᨲᨾᩮᨠᩅᩁᨠᨾ᩠ᨸᩥ ᨴᩥᩈ᩠ᩅᩣ, ᩏᨻ᩠ᨻᩥᨣ᩠ᨣᩣ ᩌᩈᨶᩴ ᨴᩮᨾᩥ.

‘‘ᩋᨶ᩠ᨶᩮᨶ ᨧ ᨸᩣᨶᩮᨶ ᨧ, ᨡᨩ᩠ᨩᩮᨶ ᨧ ᨿᨬ᩠ᨧ ᨲᨲ᩠ᨳ ᩈᨶ᩠ᨶᩥᩉᩥᨲᩴ;

ᨨᩣᨴᩮᨾᩥ ᩏᨸᨶᨿᩣᨾᩥ ᨧ, ᨴᩮᨾᩥ ᨧ ᨿᩴ ᨿᩔ ᨸᨲᩥᩁᩪᨸᩴ.

‘‘ᨠᩣᩃᩮᨶ ᩏᨸᨭ᩠ᨮᩉᩥᨲ᩠ᩅᩣ [ᩏᨭ᩠ᨮᩉᩥᨲ᩠ᩅᩣ (ᩈ᩠ᨿᩣ. ᨠ.), ᩏᨸᨭ᩠ᨮᩉᩥᨲᩩᩴ (?)], ᨥᩁᩴ ᩈᨾᩩᨸᨣᨾᩣᨾᩥ ᩏᨾ᩠ᨾᩣᩁᩮ;

ᨵᩮᩣᩅᨶ᩠ᨲᩦ ᩉᨲ᩠ᨳᨸᩣᨴᩮ, ᨸᨬ᩠ᨩᩃᩥᨠᩣ ᩈᩣᨾᩥᨠᨾᩩᨸᩮᨾᩥ.

‘‘ᨠᩮᩣᨧ᩠ᨨᩴ ᨸᩈᩣᨴᩴ ᩋᨬ᩠ᨩᨶᩥᨬ᩠ᨧ, ᩌᨴᩣᩈᨠᨬ᩠ᨧ ᨣᨱ᩠ᩉᩥᨲ᩠ᩅᩣ;

ᨸᩁᩥᨠᨾ᩠ᨾᨠᩣᩁᩥᨠᩣ ¶ ᩅᩥᨿ, ᩈᨿᨾᩮᩅ ᨸᨲᩥᩴ ᩅᩥᨽᩪᩈᩮᨾᩥ.

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

ᨾᩣᨲᩣᩅ ᩑᨠᨸᩩᨲ᩠ᨲᨠᩴ, ᨲᨳᩣ [ᨲᨴᩣ (ᩈᩦ.)] ᨽᨲ᩠ᨲᩣᩁᩴ ᨸᩁᩥᨧᩁᩣᨾᩥ.

‘‘ᩑᩅᩴ ᨾᩴ ᨽᨲ᩠ᨲᩥᨠᨲᩴ, ᩋᨶᩩᩁᨲ᩠ᨲᩴ ᨠᩣᩁᩥᨠᩴ ᨶᩥᩉᨲᨾᩣᨶᩴ;

ᩏᨭ᩠ᨮᩣᨿᩥᨠᩴ [ᩏᨭ᩠ᨮᩣᩉᩥᨠᩴ (ᨠ.)] ᩋᨶᩃᩈᩴ, ᩈᩦᩃᩅᨲᩥᩴ ᨴᩩᩔᨲᩮ ᨽᨲ᩠ᨲᩣ.

‘‘ᩈᩮᩣ ᨾᩣᨲᩁᨬ᩠ᨧ ᨸᩥᨲᩁᨬ᩠ᨧ, ᨽᨱᨲᩥ ‘ᩌᨸᩩᨧ᩠ᨨᩉᩴ ᨣᨾᩥᩔᩣᨾᩥ;

ᩍᩈᩥᨴᩣᩈᩥᨿᩣ ᨶ ᩈᩉ ᩅᨧ᩠ᨨᩴ, ᩑᨠᩣᨣᩣᩁᩮᩉᩴ [ᩑᨠᨥᩁᩮᨸ’ᩉᩴ (?)] ᩈᩉ ᩅᨲ᩠ᨳᩩᩴ’.

‘‘‘ᨾᩣ ᩑᩅᩴ ᨸᩩᨲ᩠ᨲ ᩋᩅᨧ, ᩍᩈᩥᨴᩣᩈᩦ ᨸᨱ᩠ᨯᩥᨲᩣ ᨸᩁᩥᨻ᩠ᨿᨲ᩠ᨲᩣ;

ᩏᨭ᩠ᨮᩣᨿᩥᨠᩣ ᩋᨶᩃᩈᩣ, ᨠᩥᩴ ᨲᩩᨿ᩠ᩉᩴ ᨶ ᩁᩮᩣᨧᨲᩮ ᨸᩩᨲ᩠ᨲ’.

‘‘‘ᨶ ¶ ᨧ ᨾᩮ ᩉᩥᩴᩈᨲᩥ ᨠᩥᨬ᩠ᨧᩥ, ᨶ ᨧᩉᩴ ᩍᩈᩥᨴᩣᩈᩥᨿᩣ ᩈᩉ ᩅᨧ᩠ᨨᩴ;

ᨴᩮᩔᩣᩅ ᨾᩮ ᩋᩃᩴ ᨾᩮ, ᩋᨸᩩᨧ᩠ᨨᩣᩉᩴ [ᩌᨸᩩᨧ᩠ᨨᩣᩉᩴ (ᩈ᩠ᨿᩣ.), ᩌᨸᩩᨧ᩠ᨨᩉᩴ-ᨶᩣᨸᩩᨧ᩠ᨨᩉᩴ (?)] ᨣᨾᩥᩔᩣᨾᩥ’.

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

‘ᨠᩥᩔ [ᨠᩥᩴᩈ (?)] ᨲᨿᩣ ᩋᨸᩁᨴ᩠ᨵᩴ, ᨽᨱ ᩅᩥᩔᨭ᩠ᨮᩣ ᨿᨳᩣᨽᩪᨲᩴ’.

‘‘‘ᨶᨸᩥᩉᩴ ¶ ᩋᨸᩁᨩ᩠ᨫᩴ ᨠᩥᨬ᩠ᨧᩥ, ᨶᨸᩥ ᩉᩥᩴᩈᩮᨾᩥ ᨶ ᨽᨱᩣᨾᩥ ᨴᩩᨻ᩠ᨻᨧᨶᩴ;

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

‘‘ᨲᩮ ᨾᩴ ᨸᩥᨲᩩᨥᩁᩴ ᨸᨭᩥᨶᨿᩥᩴᩈᩩ, ᩅᩥᨾᨶᩣ ᨴᩩᨡᩮᨶ ᩋᨵᩥᨽᩪᨲᩣ;

‘ᨸᩩᨲ᩠ᨲᨾᨶᩩᩁᨠ᩠ᨡᨾᩣᨶᩣ, ᨩᩥᨲᩣᨾ᩠ᩉᩈᩮ ᩁᩪᨸᩥᨶᩥᩴ ᩃᨠ᩠ᨡᩥᩴ’.

‘‘ᩋᨳ ᨾᩴ ᩋᨴᩣᩈᩥ ᨲᩣᨲᩮᩣ, ᩋᨯ᩠ᨰᩔ ᨥᩁᨾ᩠ᩉᩥ ᨴᩩᨲᩥᨿᨠᩩᩃᩥᨠᩔ;

ᨲᨲᩮᩣ ᩏᨸᨯ᩠ᨰᩈᩩᨦ᩠ᨠᩮᨶ, ᨿᩮᨶ ᨾᩴ ᩅᩥᨶ᩠ᨴᨳ ᩈᩮᨭ᩠ᨮᩥ.

‘‘ᨲᩔᨸᩥ ᨥᩁᨾ᩠ᩉᩥ ᨾᩣᩈᩴ, ᩋᩅᩈᩥᩴ ᩋᨳ ᩈᩮᩣᨸᩥ ᨾᩴ ᨸᨭᩥᨧ᩠ᨨᩁᨿᩥ [ᨸᨭᩥᨧ᩠ᨨᩈᩥ (ᩈᩦ. ᨠ.), ᨸᨭᩥᨧ᩠ᨨᨲᩥ (ᩈ᩠ᨿᩣ.), ᨸᨭᩥᨧ᩠ᨨᩁᨲᩥ (ᨠ.)];

ᨴᩣᩈᩦᩅ ¶ ᩏᨸᨭ᩠ᨮᩉᨶ᩠ᨲᩥᩴ, ᩋᨴᩪᩈᩥᨠᩴ ᩈᩦᩃᩈᨾ᩠ᨸᨶ᩠ᨶᩴ.

‘‘ᨽᩥᨠ᩠ᨡᩣᨿ ᨧ ᩅᩥᨧᩁᨶ᩠ᨲᩴ, ᨴᨾᨠᩴ ᨴᨶ᩠ᨲᩴ ᨾᩮ ᨸᩥᨲᩣ ᨽᨱᨲᩥ;

‘ᩉᩮᩣᩉᩥᩈᩥ [ᩈᩮᩣᩉᩥᩈᩥ (ᩈᨻ᩠ᨻᨲ᩠ᨳ)] ᨾᩮ ᨩᩣᨾᩣᨲᩣ, ᨶᩥᨠ᩠ᨡᩥᨸ ᨸᩮᩣᨭ᩠ᨮᩥᨬ᩠ᨧ [ᨸᩮᩣᨶ᩠ᨲᩥᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)] ᨥᨭᩥᨠᨬ᩠ᨧ’.

‘‘ᩈᩮᩣᨸᩥ ᩅᩈᩥᨲ᩠ᩅᩣ ᨸᨠ᩠ᨡᩴ [ᨸᨠ᩠ᨠᨾᨳ (ᩈᩦ.)], ᩋᨳ ᨲᩣᨲᩴ ᨽᨱᨲᩥ ‘ᨴᩮᩉᩥ ᨾᩮ ᨸᩮᩣᨭ᩠ᨮᩥᩴ;

ᨥᨭᩥᨠᨬ᩠ᨧ ᨾᩃ᩠ᩃᨠᨬ᩠ᨧ, ᨸᩩᨶᨸᩥ ᨽᩥᨠ᩠ᨡᩴ ᨧᩁᩥᩔᩣᨾᩥ’.

‘‘ᩋᨳ ¶ ᨶᩴ ᨽᨱᨲᩦ ᨲᩣᨲᩮᩣ, ᩋᨾ᩠ᨾᩣ ᩈᨻ᩠ᨻᩮᩣ ᨧ ᨾᩮ ᨬᩣᨲᩥᨣᨱᩅᨣ᩠ᨣᩮᩣ;

‘ᨠᩥᩴ ᨲᩮ ᨶ ᨠᩦᩁᨲᩥ ᩍᨵ, ᨽᨱ ᨡᩥᨸ᩠ᨸᩴ ᨲᩴ ᨲᩮ ᨠᩁᩥᩉᩥ’ᨲᩥ.

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

ᩍᩈᩥᨴᩣᩈᩥᨿᩣ ᨶ ᩈᩉ ᩅᨧ᩠ᨨᩴ, ᩑᨠᨥᩁᩮᩉᩴ ᩈᩉ ᩅᨲ᩠ᨳᩩᩴ’.

‘‘ᩅᩥᩔᨩ᩠ᨩᩥᨲᩮᩣ ᨣᨲᩮᩣ ᩈᩮᩣ, ᩋᩉᨾ᩠ᨸᩥ ᩑᨠᩣᨠᩥᨶᩦ ᩅᩥᨧᩥᨶ᩠ᨲᩮᨾᩥ;

‘ᩌᨸᩩᨧ᩠ᨨᩥᨲᩪᨶ ᨣᨧ᩠ᨨᩴ, ᨾᩁᩥᨲᩩᨿᩮ [ᨾᩁᩥᨲᩣᨿᩮ (ᩈᩦ.), ᨾᩁᩥᨲᩩᩴ (ᩈ᩠ᨿᩣ.)] ᩅᩣ ᨸᨻ᩠ᨻᨩᩥᩔᩴ ᩅᩣ’.

‘‘ᩋᨳ ᩋᨿ᩠ᨿᩣ ᨩᩥᨶᨴᨲ᩠ᨲᩣ, ᩌᨣᨧ᩠ᨨᩦ ᨣᩮᩣᨧᩁᩣᨿ ᨧᩁᨾᩣᨶᩣ;

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

‘‘ᨲᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᩋᨾ᩠ᩉᩣᨠᩴ, ᩏᨭ᩠ᨮᩣᨿᩣᩈᨶᩴ ᨲᩔᩣ ᨸᨬ᩠ᨬᩣᨸᨿᩥᩴ;

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

‘‘ᩋᨶ᩠ᨶᩮᨶ ¶ ᨧ ᨸᩣᨶᩮᨶ ᨧ, ᨡᨩ᩠ᨩᩮᨶ ᨧ ᨿᨬ᩠ᨧ ᨲᨲ᩠ᨳ ᩈᨶ᩠ᨶᩥᩉᩥᨲᩴ;

ᩈᨶ᩠ᨲᨸ᩠ᨸᨿᩥᨲ᩠ᩅᩣ ᩋᩅᨧᩴ, ‘ᩋᨿ᩠ᨿᩮ ᩍᨧ᩠ᨨᩣᨾᩥ ᨸᨻ᩠ᨻᨩᩥᨲᩩᩴ’.

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

ᩋᨶ᩠ᨶᩮᨶ ᨧ ᨸᩣᨶᩮᨶ ᨧ, ᨲᨸ᩠ᨸᨿ ᩈᨾᨱᩮ ᨴ᩠ᩅᩥᨩᩣᨲᩦ ᨧ’.

‘‘ᩋᨳᩉᩴ ᨽᨱᩣᨾᩥ ᨲᩣᨲᩴ, ᩁᩮᩣᨴᨶ᩠ᨲᩦ ᩋᨬ᩠ᨩᩃᩥᩴ ᨸᨱᩣᨾᩮᨲ᩠ᩅᩣ;

‘ᨸᩣᨸᨬ᩠ᩉᩥ ᨾᨿᩣ ᨸᨠᨲᩴ, ᨠᨾ᩠ᨾᩴ ᨲᩴ ᨶᩥᨩ᩠ᨩᩁᩮᩔᩣᨾᩥ’.

‘‘ᩋᨳ ¶ ᨾᩴ ᨽᨱᨲᩦ ᨲᩣᨲᩮᩣ, ‘ᨸᩣᨸᩩᨱ ᨻᩮᩣᨵᩥᨬ᩠ᨧ ᩋᨣ᩠ᨣᨵᨾ᩠ᨾᨬ᩠ᨧ;

ᨶᩥᨻ᩠ᨻᩣᨶᨬ᩠ᨧ ᩃᨽᩔᩩ, ᨿᩴ ᩈᨧ᩠ᨨᩥᨠᩁᩦ ᨴ᩠ᩅᩥᨸᨴᩈᩮᨭ᩠ᨮᩮᩣ’.

‘‘ᨾᩣᨲᩣᨸᩥᨲᩪ ᩋᨽᩥᩅᩣᨴᨿᩥᨲ᩠ᩅᩣ, ᩈᨻ᩠ᨻᨬ᩠ᨧ ᨬᩣᨲᩥᨣᨱᩅᨣ᩠ᨣᩴ;

ᩈᨲ᩠ᨲᩣᩉᩴ ᨸᨻ᩠ᨻᨩᩥᨲᩣ, ᨲᩥᩔᩮᩣ ᩅᩥᨩ᩠ᨩᩣ ᩋᨹᩔᨿᩥᩴ.

‘‘ᨩᩣᨶᩣᨾᩥ ᩋᨲ᩠ᨲᨶᩮᩣ ᩈᨲ᩠ᨲ, ᨩᩣᨲᩥᨿᩮᩣ ᨿᩔᨿᩴ ᨹᩃᩅᩥᨸᩣᨠᩮᩣ;

ᨲᩴ ᨲᩅ ᩌᨧᩥᨠ᩠ᨡᩥᩔᩴ, ᨲᩴ ᩑᨠᨾᨶᩣ ᨶᩥᩈᩣᨾᩮᩉᩥ.

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

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

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

ᨸᨠ᩠ᨠᩮᩣ ᨲᨲᩮᩣ ᨧ ᩏᨭ᩠ᨮᩉᩥᨲ᩠ᩅᩣ, ᨾᨠ᩠ᨠᨭᩥᨿᩣ ᨠᩩᨧ᩠ᨨᩥᨾᩮᩣᨠ᩠ᨠᨾᩥᩴ.

‘‘ᩈᨲ᩠ᨲᩣᩉᨩᩣᨲᨠᩴ ¶ ¶ ᨾᩴ, ᨾᩉᩣᨠᨸᩥ ᨿᩪᨳᨸᩮᩣ ᨶᩥᩃ᩠ᩃᨧ᩠ᨨᩮᩈᩥ;

ᨲᩔᩮᨲᩴ ᨠᨾ᩠ᨾᨹᩃᩴ, ᨿᨳᩣᨸᩥ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨸᩁᨴᩣᩁᩴ.

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

ᨠᩣᨱᩣᨿ ᨧ ᨡᨬ᩠ᨩᩣᨿ ᨧ, ᩑᩊᨠᩥᨿᩣ ᨠᩩᨧ᩠ᨨᩥᨾᩮᩣᨠ᩠ᨠᨾᩥᩴ.

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

ᨠᩥᨾᩥᨶᩣᩅᨭ᩠ᨭᩮᩣ ᩋᨠᩃ᩠ᩃᩮᩣ, ᨿᨳᩣᨸᩥ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨸᩁᨴᩣᩁᩴ.

‘‘ᩈᩮᩣᩉᩴ ᨲᨲᩮᩣ ᨧᩅᩥᨲ᩠ᩅᩣ, ᨣᩮᩣᩅᩣᨱᩥᨩᨠᩔ ᨣᩣᩅᩥᨿᩣ ᨩᩣᨲᩮᩣ;

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

‘‘ᩅᩮᩣᨰᩪᨶ [ᨲᩮ ᨸᩩᨶ (ᩈ᩠ᨿᩣ. ᨠ.), ᩅᩮᩣᨵᩩᨶ (ᨠ. ᩋᨭ᩠ᨮ.)] ᨶᨦ᩠ᨣᩃᨾᩉᩴ, ᩈᨠᨭᨬ᩠ᨧ ᨵᩣᩁᨿᩣᨾᩥ;

ᩋᨶ᩠ᨵᩮᩣᩅᨭ᩠ᨭᩮᩣ ᩋᨠᩃ᩠ᩃᩮᩣ, ᨿᨳᩣᨸᩥ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᨸᩁᨴᩣᩁᩴ.

‘‘ᩈᩮᩣᩉᩴ ᨲᨲᩮᩣ ᨧᩅᩥᨲ᩠ᩅᩣ, ᩅᩦᨳᩥᨿᩣ ᨴᩣᩈᩥᨿᩣ ᨥᩁᩮ ᨩᩣᨲᩮᩣ;

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

‘‘ᨲᩥᩴᩈᨲᩥᩅᩔᨾ᩠ᩉᩥ ¶ ¶ ᨾᨲᩮᩣ, ᩈᩣᨠᨭᩥᨠᨠᩩᩃᨾ᩠ᩉᩥ ᨴᩣᩁᩥᨠᩣ ᨩᩣᨲᩣ;

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

‘‘ᨲᩴ ᨾᩴ ᨲᨲᩮᩣ ᩈᨲ᩠ᨳᩅᩣᩉᩮᩣ, ᩏᩔᨶ᩠ᨶᩣᨿ ᩅᩥᨸᩩᩃᩣᨿ ᩅᨯ᩠ᨰᩥᨿᩣ;

ᩒᨠᨯ᩠ᨰᨲᩥ ᩅᩥᩃᨸᨶ᩠ᨲᩥᩴ, ᩋᨧ᩠ᨨᩥᨶ᩠ᨴᩥᨲ᩠ᩅᩣ ᨠᩩᩃᨥᩁᩈ᩠ᨾᩣ.

‘‘ᩋᨳ ᩈᩮᩣᩊᩈᨾᩮ ᩅᩔᩮ, ᨴᩥᩈ᩠ᩅᩣ ᨾᩴ ᨸᨲ᩠ᨲᨿᩮᩣᨻ᩠ᨻᨶᩴ ᨠᨬ᩠ᨬᩴ;

ᩒᩁᩩᨶ᩠ᨵᨲᩔ ᨸᩩᨲ᩠ᨲᩮᩣ, ᨣᩥᩁᩥᨴᩣᩈᩮᩣ ᨶᩣᨾ ᨶᩣᨾᩮᨶ.

‘‘ᨲᩔᨸᩥ ᩋᨬ᩠ᨬᩣ ᨽᩁᩥᨿᩣ, ᩈᩦᩃᩅᨲᩦ ᨣᩩᨱᩅᨲᩦ ᨿᩈᩅᨲᩦ ᨧ;

ᩋᨶᩩᩁᨲ᩠ᨲᩣ ¶ [ᩋᨶᩩᩅᨲ᩠ᨲᩣ (ᨠ.)] ᨽᨲ᩠ᨲᩣᩁᩴ, ᨲᩔᩣᩉᩴ [ᨲᩔ ᨲᩴ (?)] ᩅᩥᨴ᩠ᨴᩮᩈᨶᨾᨠᩣᩈᩥᩴ.

‘‘ᨲᩔᩮᨲᩴ ᨠᨾ᩠ᨾᨹᩃᩴ, ᨿᩴ ᨾᩴ ᩋᨸᨠᩦᩁᩥᨲᩪᨶ ᨣᨧ᩠ᨨᨶ᩠ᨲᩥ;

ᨴᩣᩈᩦᩅ ᩏᨸᨭ᩠ᨮᩉᨶ᩠ᨲᩥᩴ, ᨲᩔᨸᩥ ᩋᨶ᩠ᨲᩮᩣ ᨠᨲᩮᩣ ᨾᨿᩣ’’ᨲᩥ.

ᨾᨶ᩠ᨲᩣᩅᨲᩥᨿᩣ ¶ ᨶᨣᩁᩮ, ᩁᨬ᩠ᨬᩮᩣ ᨠᩮᩣᨬ᩠ᨧᩔ ᩋᨣ᩠ᨣᨾᩉᩮᩈᩥᨿᩣ;

ᨵᩦᨲᩣ ᩌᩈᩥᩴ ᩈᩩᨾᩮᨵᩣ, ᨸᩈᩣᨴᩥᨲᩣ ᩈᩣᩈᨶᨠᩁᩮᩉᩥ.

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

ᨾᩣᨲᩣᨸᩥᨲᩁᩮᩣ ᩏᨸᨣᨾ᩠ᨾ, ᨽᨱᨲᩥ ‘‘ᩏᨽᨿᩮᩣ ᨶᩥᩈᩣᨾᩮᨳ.

‘‘ᨶᩥᨻ᩠ᨻᩣᨶᩣᨽᩥᩁᨲᩣᩉᩴ, ᩋᩈᩔᨲᩴ ᨽᩅᨣᨲᩴ ᨿᨴᩥᨸᩥ ᨴᩥᨻ᩠ᨻᩴ;

ᨠᩥᨾᨦ᩠ᨣᩴ ᨸᨶ [ᨠᩥᨾᨦ᩠ᨣ ᨸᨶ (ᩈᩦ. ᩈ᩠ᨿᩣ.), ᨠᩥᩴ ᨸᨶ (?)] ᨲᩩᨧ᩠ᨨᩣ ᨠᩣᨾᩣ, ᩋᨸ᩠ᨸᩔᩣᨴᩣ ᨻᩉᩩᩅᩥᨥᩣᨲᩣ.

‘‘ᨠᩣᨾᩣ ᨠᨭᩩᨠᩣ ᩌᩈᩦᩅᩥᩈᩪᨸᨾᩣ, ᨿᩮᩈᩩ ᨾᩩᨧ᩠ᨨᩥᨲᩣ ᨻᩣᩃᩣ;

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

‘‘ᩈᩮᩣᨧᨶ᩠ᨲᩥ ᨸᩣᨸᨠᨾ᩠ᨾᩣ, ᩅᩥᨶᩥᨸᩣᨲᩮ ᨸᩣᨸᩅᨴ᩠ᨵᩥᨶᩮᩣ ᩈᨴᩣ;

ᨠᩣᨿᩮᨶ ᨧ ᩅᩣᨧᩣᨿ ᨧ, ᨾᨶᩈᩣ ᨧ ᩋᩈᩴᩅᩩᨲᩣ ᨻᩣᩃᩣ.

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

ᨴᩮᩈᨶ᩠ᨲᩮ ¶ ᩋᨩᩣᨶᨶ᩠ᨲᩣ, ᨶ ᨻᩩᨩ᩠ᨫᩁᩮ ᩋᩁᩥᨿᩈᨧ᩠ᨧᩣᨶᩥ.

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

ᩋᨽᩥᨶᨶ᩠ᨴᨶ᩠ᨲᩥ ᨽᩅᨣᨲᩴ, ᨸᩥᩉᩮᨶ᩠ᨲᩥ ᨴᩮᩅᩮᩈᩩ ᩏᨸᨸᨲ᩠ᨲᩥᩴ.

‘‘ᨴᩮᩅᩮᩈᩩᨸᩥ ᩏᨸᨸᨲ᩠ᨲᩥ, ᩋᩈᩔᨲᩣ ᨽᩅᨣᨲᩮ ᩋᨶᩥᨧ᩠ᨧᨾ᩠ᩉᩥ;

ᨶ ᨧ ᩈᨶ᩠ᨲᩈᨶ᩠ᨲᩥ ᨻᩣᩃᩣ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ ᨩᩣᨿᩥᨲᨻ᩠ᨻᩔ.

‘‘ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᩅᩥᨶᩥᨸᩣᨲᩣ, ᨴᩩᩅᩮ [ᨴ᩠ᩅᩮ (ᩈᨻ᩠ᨻᨲ᩠ᨳ)] ᨧ ᨣᨲᩥᨿᩮᩣ ᨠᨳᨬ᩠ᨧᩥ ᩃᨻ᩠ᨽᨶ᩠ᨲᩥ;

ᨶ ᨧ ᩅᩥᨶᩥᨸᩣᨲᨣᨲᩣᨶᩴ, ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ ᩋᨲ᩠ᨳᩥ ᨶᩥᩁᨿᩮᩈᩩ.

‘‘ᩋᨶᩩᨩᩣᨶᩣᨳ ᨾᩴ ᩏᨽᨿᩮᩣ, ᨸᨻ᩠ᨻᨩᩥᨲᩩᩴ ᨴᩈᨻᩃᩔ ᨸᩣᩅᨧᨶᩮ;

ᩋᨸ᩠ᨸᩮᩣᩔᩩᨠ᩠ᨠᩣ ᨥᨭᩥᩔᩴ, ᨩᩣᨲᩥᨾᩁᨱᨸ᩠ᨸᩉᩣᨶᩣᨿ.

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

ᨽᩅᨲᨱ᩠ᩉᩣᨿ ᨶᩥᩁᩮᩣᨵᩣ, ᩋᨶᩩᨩᩣᨶᩣᨳ ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ.

‘‘ᨻᩩᨴ᩠ᨵᩣᨶᩴ ¶ ᩏᨸ᩠ᨸᩣᨴᩮᩣ ᩅᩥᩅᨩ᩠ᨩᩥᨲᩮᩣ, ᩋᨠ᩠ᨡᨱᩮᩣ ᨡᨱᩮᩣ ᩃᨴ᩠ᨵᩮᩣ;

ᩈᩦᩃᩣᨶᩥ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᨿᩣᩅᨩᩦᩅᩴ ᨶ ᨴᩪᩈᩮᨿ᩠ᨿᩴ’’.

ᩑᩅᩴ ᨽᨱᨲᩥ ᩈᩩᨾᩮᨵᩣ, ᨾᩣᨲᩣᨸᩥᨲᩁᩮᩣ ‘‘ᨶ ᨲᩣᩅ ᩌᩉᩣᩁᩴ;

ᩌᩉᩁᩥᩔᩴ [ᩌᩉᩁᩥᨿᩣᨾᩥ (ᩈᩦ.), ᩌᩉᩣᩁᩥᩈᩴ (?)] ᨣᩉᨭ᩠ᨮᩣ, ᨾᩁᨱᩅᩈᩴ ᨣᨲᩣᩅ ᩉᩮᩔᩣᨾᩥ’’.

ᨾᩣᨲᩣ ᨴᩩᨠ᩠ᨡᩥᨲᩣ ᩁᩮᩣᨴᨲᩥ ᨸᩥᨲᩣ ᨧ, ᩋᩔᩣ ᩈᨻ᩠ᨻᩈᩮᩣ ᩈᨾᨽᩥᩉᨲᩮᩣ;

ᨥᨭᩮᨶ᩠ᨲᩥ ᩈᨬ᩠ᨬᩣᨸᩮᨲᩩᩴ, ᨸᩣᩈᩣᨴᨲᩃᩮ ᨨᨾᩣᨸᨲᩥᨲᩴ.

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

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

‘‘ᩋᨣ᩠ᨣᨾᩉᩮᩈᩦ ᨽᩅᩥᩔᩈᩥ, ᩋᨶᩥᨠᩁᨲ᩠ᨲᩔ ᩁᩣᨩᩥᨶᩮᩣ ᨽᩁᩥᨿᩣ;

ᩈᩦᩃᩣᨶᩥ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ, ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ ᨴᩩᨠ᩠ᨠᩁᩣ ᨸᩩᨲ᩠ᨲᨠ.

‘‘ᩁᨩ᩠ᨩᩮ ᩌᨱᩣᨵᨶᨾᩥᩔᩁᩥᨿᩴ, ᨽᩮᩣᨣᩣ ᩈᩩᨡᩣ ᨴᩉᩁᩥᨠᩣᩈᩥ;

ᨽᩩᨬ᩠ᨩᩣᩉᩥ ᨠᩣᨾᨽᩮᩣᨣᩮ, ᩅᩣᩁᩮᨿ᩠ᨿᩴ ᩉᩮᩣᨲᩩ ᨲᩮ ᨸᩩᨲ᩠ᨲ’’.

ᩋᨳ ᨶᩮ ᨽᨱᨲᩥ ᩈᩩᨾᩮᨵᩣ, ‘‘ᨾᩣ ᩑᨴᩥᩈᩥᨠᩣᨶᩥ ᨽᩅᨣᨲᨾᩈᩣᩁᩴ;

ᨸᨻ᩠ᨻᨩ᩠ᨩᩣ ᩅᩣ ᩉᩮᩣᩉᩥᨲᩥ, ᨾᩁᨱᩴ ᩅᩣ ᨾᩮ ᨶ ᨧᩮᩅ ᩅᩣᩁᩮᨿ᩠ᨿᩴ.

‘‘ᨠᩥᨾᩥᩅ ¶ ᨸᩪᨲᩥᨠᩣᨿᨾᩈᩩᨧᩥᩴ, ᩈᩅᨶᨣᨶ᩠ᨵᩴ ᨽᨿᩣᨶᨠᩴ ᨠᩩᨱᨸᩴ;

ᩋᨽᩥᩈᩴᩅᩥᩈᩮᨿ᩠ᨿᩴ ᨽᩈ᩠ᨲᩴ, ᩋᩈᨠᩥᩴ ᨸᨣ᩠ᨥᩁᩥᨲᩴ ᩋᩈᩩᨧᩥᨸᩩᨱ᩠ᨱᩴ.

‘‘ᨠᩥᨾᩥᩅ ¶ ᨲᩣᩉᩴ ᨩᩣᨶᨶ᩠ᨲᩦ, ᩅᩥᨠᩩᩃᨠᩴ ᨾᩴᩈᩈᩮᩣᨱᩥᨲᩩᨸᩃᩥᨲ᩠ᨲᩴ;

ᨠᩥᨾᩥᨠᩩᩃᩣᩃᨿᩴ ᩈᨠᩩᨱᨽᨲ᩠ᨲᩴ, ᨠᩊᩮᩅᩁᩴ ᨠᩥᩔ ᨴᩥᨿ᩠ᨿᨲᩥ.

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

ᨨᩩᨴ᩠ᨵᩮᩣ [ᨨᨯ᩠ᨯᩥᨲᩮᩣ (ᩈ᩠ᨿᩣ.), ᨨᩩᨭ᩠ᨮᩮᩣ (ᨠ.)] ᨠᩊᩥᨦ᩠ᨣᩁᩴ ᩅᩥᨿ, ᨩᩥᨣᩩᨧ᩠ᨨᨾᩣᨶᩮᩉᩥ ᨬᩣᨲᩦᩉᩥ.

‘‘ᨨᩩᨴ᩠ᨵᩪᨶ [ᨨᨯ᩠ᨯᩪᨶ (ᩈ᩠ᨿᩣ.), ᨨᩩᨭ᩠ᨮᩪᨶ (ᨠ.)] ᨶᩴ ᩈᩩᩈᩣᨶᩮ, ᨸᩁᨽᨲ᩠ᨲᩴ ᨶ᩠ᩉᩣᨿᨶ᩠ᨲᩥ [ᨶ᩠ᩉᩣᨿᩁᩮ (?)] ᨩᩥᨣᩩᨧ᩠ᨨᨶ᩠ᨲᩣ;

ᨶᩥᨿᨠᩣ ᨾᩣᨲᩣᨸᩥᨲᩁᩮᩣ, ᨠᩥᩴ ᨸᨶ ᩈᩣᨵᩣᩁᨱᩣ ᨩᨶᨲᩣ.

‘‘ᩋᨩ᩠ᨫᩮᩣᩈᩥᨲᩣ ᩋᩈᩣᩁᩮ, ᨠᩊᩮᩅᩁᩮ ᩋᨭ᩠ᨮᩥᨶ᩠ᩉᩣᩁᩩᩈᨦ᩠ᨥᩣᨲᩮ;

ᨡᩮᩊᩔᩩᨧ᩠ᨧᩣᩁᩔᩅ, ᨸᩁᩥᨸᩩᨱ᩠ᨱᩮ [ᨡᩮᩊᩔᩩᨧ᩠ᨧᩣᩁᨸᩔᩅᨸᩁᩥᨸᩩᨱ᩠ᨱᩮ (ᩈᩦ.)] ᨸᩪᨲᩥᨠᩣᨿᨾ᩠ᩉᩥ.

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

ᨣᨶ᩠ᨵᩔ ᩋᩈᩉᨾᩣᨶᩣ, ᩈᨠᩣᨸᩥ ᨾᩣᨲᩣ ᨩᩥᨣᩩᨧ᩠ᨨᩮᨿ᩠ᨿ.

‘‘ᨡᨶ᩠ᨵᨵᩣᨲᩩᩌᨿᨲᨶᩴ, ᩈᨦ᩠ᨡᨲᩴ ᨩᩣᨲᩥᨾᩪᩃᨠᩴ ᨴᩩᨠ᩠ᨡᩴ;

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

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

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

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

‘ᨴᩦᨥᩮᩣ ᨲᩮᩈᩴ [ᩅᩮᩣ (ᨠ.)] ᩈᩴᩈᩣᩁᩮᩣ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ ᩉᨬ᩠ᨬᨾᩣᨶᩣᨶᩴ’.

‘‘ᨴᩮᩅᩮᩈᩩ ᨾᨶᩩᩔᩮᩈᩩ ᨧ, ᨲᩥᩁᨧ᩠ᨨᩣᨶᨿᩮᩣᨶᩥᨿᩣ ᩋᩈᩩᩁᨠᩣᨿᩮ;

ᨸᩮᨲᩮᩈᩩ ¶ ᨧ ᨶᩥᩁᨿᩮᩈᩩ ᨧ, ᩋᨸᩁᩥᨾᩥᨲᩣ ᨴᩥᩔᩁᩮ ᨥᩣᨲᩣ.

‘‘ᨥᩣᨲᩣ ᨶᩥᩁᨿᩮᩈᩩ ᨻᩉᩪ, ᩅᩥᨶᩥᨸᩣᨲᨣᨲᩔ ᨸᩦᩊᩥᨿᨾᩣᨶᩔ [ᨠᩥᩃᩥᩔᨾᩣᨶᩔ (ᩈ᩠ᨿᩣ. ᨠ.)];

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

‘‘ᨸᨲ᩠ᨲᩣ ᨲᩮ ᨶᩥᨻ᩠ᨻᩣᨶᩴ, ᨿᩮ ᨿᩩᨲ᩠ᨲᩣ ᨴᩈᨻᩃᩔ ᨸᩣᩅᨧᨶᩮ;

ᩋᨸ᩠ᨸᩮᩣᩔᩩᨠ᩠ᨠᩣ ᨥᨭᩮᨶ᩠ᨲᩥ, ᨩᩣᨲᩥᨾᩁᨱᨸ᩠ᨸᩉᩣᨶᩣᨿ.

‘‘ᩋᨩ᩠ᨩᩮᩅ ᨲᩣᨲᨽᩥᨶᩥᨠ᩠ᨡᨾᩥᩔᩴ, ᨽᩮᩣᨣᩮᩉᩥ ᨠᩥᩴ ᩋᩈᩣᩁᩮᩉᩥ;

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

ᩈᩣ ᨧᩮᩅᩴ ᨽᨱᨲᩥ ᨸᩥᨲᩁᨾᨶᩦᨠᩁᨲ᩠ᨲᩮᩣ ᨧ ᨿᩔ ᩈᩣ ᨴᩥᨶ᩠ᨶᩣ;

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

ᩋᨳ ᩋᩈᩥᨲᨶᩥᨧᩥᨲᨾᩩᨴᩩᨠᩮ, ᨠᩮᩈᩮ ᨡᨣ᩠ᨣᩮᨶ ᨨᩥᨶ᩠ᨴᩥᨿ ᩈᩩᨾᩮᨵᩣ;

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

ᩈᩣ ¶ ¶ ᨧ ᨲᩉᩥᩴ ᩈᨾᩣᨸᨶ᩠ᨶᩣ, ᩋᨶᩦᨠᩁᨲ᩠ᨲᩮᩣ ᨧ ᩌᨣᨲᩮᩣ ᨶᨣᩁᩴ;

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

ᩈᩣ ᨧ ᨾᨶᩈᩥ ᨠᩁᩮᩣᨲᩥ, ᩋᨶᩦᨠᩁᨲ᩠ᨲᩮᩣ ᨧ ᩌᩁᩩᩉᩦ ᨲᩩᩁᩥᨲᩴ;

ᨾᨱᩥᨠᨶᨠᨽᩪᩈᩥᨲᨦ᩠ᨣᩮᩣ, ᨠᨲᨬ᩠ᨩᩃᩦ ᨿᩣᨧᨲᩥ ᩈᩩᨾᩮᨵᩴ.

‘‘ᩁᨩ᩠ᨩᩮ ᩌᨱᩣᨵᨶᨾᩥᩔᩁᩥᨿᩴ, ᨽᩮᩣᨣᩣ ᩈᩩᨡᩣ ᨴᩉᩁᩥᨠᩣᩈᩥ;

ᨽᩩᨬ᩠ᨩᩣᩉᩥ ᨠᩣᨾᨽᩮᩣᨣᩮ, ᨠᩣᨾᩈᩩᨡᩣ ᨴᩩᩃ᩠ᩃᨽᩣ ᩃᩮᩣᨠᩮ.

‘‘ᨶᩥᩔᨭ᩠ᨮᩴ ¶ ᨲᩮ ᩁᨩ᩠ᨩᩴ, ᨽᩮᩣᨣᩮ ᨽᩩᨬ᩠ᨩᩔᩩ ᨴᩮᩉᩥ ᨴᩣᨶᩣᨶᩥ;

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

ᨲᩴ ᨲᩴ ᨽᨱᨲᩥ ᩈᩩᨾᩮᨵᩣ, ᨠᩣᨾᩮᩉᩥ ᩋᨶᨲ᩠ᨳᩥᨠᩣ ᩅᩥᨣᨲᨾᩮᩣᩉᩣ;

‘‘ᨾᩣ ᨠᩣᨾᩮ ᩋᨽᩥᨶᨶ᩠ᨴᩥ, ᨠᩣᨾᩮᩈ᩠ᩅᩣᨴᩦᨶᩅᩴ ᨸᩔ.

‘‘ᨧᩣᨲᩩᨴ᩠ᨴᩦᨸᩮᩣ ᩁᩣᨩᩣ ᨾᨶ᩠ᨵᩣᨲᩣ, ᩌᩈᩥ ᨠᩣᨾᨽᩮᩣᨣᩥᨶ ᨾᨣ᩠ᨣᩮᩣ;

ᩋᨲᩥᨲ᩠ᨲᩮᩣ ¶ ᨠᩣᩃᨦ᩠ᨠᨲᩮᩣ, ᨶ ᨧᩔ ᨸᩁᩥᨸᩪᩁᩥᨲᩣ ᩍᨧ᩠ᨨᩣ.

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

ᨶ ᨧᨲ᩠ᨳᩥ ᨲᩥᨲ᩠ᨲᩥ ᨠᩣᨾᩣᨶᩴ, ᩋᨲᩥᨲ᩠ᨲᩣᩅ ᨾᩁᨶ᩠ᨲᩥ ᨶᩁᩣ.

‘‘ᩋᩈᩥᩈᩪᨶᩪᨸᨾᩣ ᨠᩣᨾᩣ, ᨠᩣᨾᩣ ᩈᨸ᩠ᨸᩈᩥᩁᩮᩣᨸᨾᩣ;

ᩏᨠ᩠ᨠᩮᩣᨸᨾᩣ ᩋᨶᩩᨴᩉᨶ᩠ᨲᩥ, ᩋᨭ᩠ᨮᩥᨠᨦ᩠ᨠᩃ [ᨠᨦ᩠ᨡᩃ (ᩈᩦ.)] ᩈᨶ᩠ᨶᩥᨽᩣ.

‘‘ᩋᨶᩥᨧ᩠ᨧᩣ ᩋᨴ᩠ᨵᩩᩅᩣ ᨠᩣᨾᩣ, ᨻᩉᩩᨴᩩᨠ᩠ᨡᩣ ᨾᩉᩣᩅᩥᩈᩣ;

ᩋᨿᩮᩣᨣᩩᩊᩮᩣᩅ ᩈᨶ᩠ᨲᨲ᩠ᨲᩮᩣ, ᩋᨥᨾᩪᩃᩣ ᨴᩩᨡᨸ᩠ᨹᩃᩣ.

‘‘ᩁᩩᨠ᩠ᨡᨸ᩠ᨹᩃᩪᨸᨾᩣ ᨠᩣᨾᩣ, ᨾᩴᩈᨸᩮᩈᩪᨸᨾᩣ ᨴᩩᨡᩣ;

ᩈᩩᨸᩥᨶᩮᩣᨸᨾᩣ ¶ ᩅᨬ᩠ᨧᨶᩥᨿᩣ, ᨠᩣᨾᩣ ᨿᩣᨧᩥᨲᨠᩪᨸᨾᩣ.

‘‘ᩈᨲ᩠ᨲᩥᩈᩪᩃᩪᨸᨾᩣ ᨠᩣᨾᩣ, ᩁᩮᩣᨣᩮᩣ ᨣᨱ᩠ᨯᩮᩣ ᩋᨥᩴ ᨶᩥᨥᩴ;

ᩋᨦ᩠ᨣᩣᩁᨠᩣᩈᩩᩈᨴᩥᩈᩣ, ᩋᨥᨾᩪᩃᩴ ᨽᨿᩴ ᩅᨵᩮᩣ.

‘‘ᩑᩅᩴ ᨻᩉᩩᨴᩩᨠ᩠ᨡᩣ ᨠᩣᨾᩣ, ᩋᨠ᩠ᨡᩣᨲᩣ ᩋᨶ᩠ᨲᩁᩣᨿᩥᨠᩣ;

ᨣᨧ᩠ᨨᨳ ᨶ ᨾᩮ ᨽᨣᩅᨲᩮ, ᩅᩥᩔᩣᩈᩮᩣ ᩋᨲ᩠ᨳᩥ ᩋᨲ᩠ᨲᨶᩮᩣ.

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

ᩋᨶᩩᨻᨶ᩠ᨵᩮ ᨩᩁᩣᨾᩁᨱᩮ, ᨲᩔ ᨥᩣᨲᩣᨿ ᨥᨭᩥᨲᨻ᩠ᨻᩴ’’.

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

ᨴᩥᩈ᩠ᩅᩣᨶ ᨨᨾᩴ ᨶᩥᩈᩥᨶ᩠ᨶᩮ, ᩁᩮᩣᨴᨶ᩠ᨲᩮ ᩍᨴᨾᩅᩮᩣᨧᩴ.

‘‘ᨴᩦᨥᩮᩣ ᨻᩣᩃᩣᨶᩴ ᩈᩴᩈᩣᩁᩮᩣ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᨬ᩠ᨧ ᩁᩮᩣᨴᨲᩴ;

ᩋᨶᨾᨲᨣ᩠ᨣᩮ ᨸᩥᨲᩩ ᨾᩁᨱᩮ, ᨽᩣᨲᩩ ᩅᨵᩮ ᩋᨲ᩠ᨲᨶᩮᩣ ᨧ ᩅᨵᩮ.

‘‘ᩋᩔᩩ ᨳᨬ᩠ᨬᩴ ᩁᩩᨵᩥᩁᩴ, ᩈᩴᩈᩣᩁᩴ ᩋᨶᨾᨲᨣ᩠ᨣᨲᩮᩣ ᩈᩁᨳ;

ᩈᨲ᩠ᨲᩣᨶᩴ ᩈᩴᩈᩁᨲᩴ, ᩈᩁᩣᩉᩥ ᩋᨭ᩠ᨮᩦᨶᨬ᩠ᨧ ᩈᨶ᩠ᨶᩥᨧᨿᩴ.

‘‘ᩈᩁ ¶ ᨧᨲᩩᩁᩮᩣᨴᨵᩦ [ᩈᩁᩔᩩ ᨧᨲᩩᩁᩮᩣ ᩏᨴᨵᩦ (?)], ᩏᨸᨶᩦᨲᩮ ᩋᩔᩩᨳᨬ᩠ᨬᩁᩩᨵᩥᩁᨾ᩠ᩉᩥ;

ᩈᩁ ᩑᨠᨠᨸ᩠ᨸᨾᨭ᩠ᨮᩦᨶᩴ, ᩈᨬ᩠ᨧᨿᩴ ᩅᩥᨸᩩᩃᩮᨶ ᩈᨾᩴ.

‘‘ᩋᨶᨾᨲᨣ᩠ᨣᩮ ¶ ᩈᩴᩈᩁᨲᩮᩣ, ᨾᩉᩥᩴ [ᨾᩉᩣᨾᩉᩥᩴ (?)] ᨩᨾ᩠ᨻᩩᨴᩦᨸᨾᩩᨸᨶᩦᨲᩴ;

ᨠᩮᩣᩃᨭ᩠ᨮᩥᨾᨲ᩠ᨲᨣᩩᩊᩥᨠᩣ, ᨾᩣᨲᩣ ᨾᩣᨲᩩᩈ᩠ᩅᩮᩅ ᨶᨸ᩠ᨸᩉᩮᩣᨶ᩠ᨲᩥ.

‘‘ᨲᩥᨱᨠᨭ᩠ᨮᩈᩣᨡᩣᨸᩃᩣᩈᩴ [ᩈᩁ ᨲᩥᨱᨠᨭ᩠ᨮᩈᩣᨡᩣᨸᩃᩣᩈᩴ (ᩈᩦ.)], ᩏᨸᨶᩦᨲᩴ ᩋᨶᨾᨲᨣ᩠ᨣᨲᩮᩣ ᩈᩁ;

ᨧᨲᩩᩁᨦ᩠ᨣᩩᩃᩥᨠᩣ ᨥᨭᩥᨠᩣ, ᨸᩥᨲᩩᨸᩥᨲᩩᩈ᩠ᩅᩮᩅ ᨶᨸ᩠ᨸᩉᩮᩣᨶ᩠ᨲᩥ.

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

ᩈᩥᩁᩴ ¶ [ᩈᩁ (ᩈᩦ.)] ᨲᩔ ᨧ ᨸᨭᩥᨾᩩᨠ᩠ᨠᩴ, ᨾᨶᩩᩔᩃᩣᨽᨾ᩠ᩉᩥ ᩒᨸᨾ᩠ᨾᩴ.

‘‘ᩈᩁ ᩁᩪᨸᩴ ᨹᩮᨱᨸᩥᨱ᩠ᨯᩮᩣᨸᨾᩔ, ᨠᩣᨿᨠᩃᩥᨶᩮᩣ ᩋᩈᩣᩁᩔ;

ᨡᨶ᩠ᨵᩮ ᨸᩔ ᩋᨶᩥᨧ᩠ᨧᩮ, ᩈᩁᩣᩉᩥ ᨶᩥᩁᨿᩮ ᨻᩉᩩᩅᩥᨥᩣᨲᩮ.

‘‘ᩈᩁ ᨠᨭᩈᩥᩴ ᩅᨯ᩠ᨰᩮᨶ᩠ᨲᩮ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ ᨲᩣᩈᩩ ᨲᩣᩈᩩ ᨩᩣᨲᩦᩈᩩ;

ᩈᩁ ᨠᩩᨾ᩠ᨽᩦᩃᨽᨿᩣᨶᩥ ᨧ, ᩈᩁᩣᩉᩥ ᨧᨲ᩠ᨲᩣᩁᩥ ᩈᨧ᩠ᨧᩣᨶᩥ.

‘‘ᩋᨾᨲᨾ᩠ᩉᩥ ᩅᩥᨩ᩠ᨩᨾᩣᨶᩮ, ᨠᩥᩴ ᨲᩅ ᨸᨬ᩠ᨧᨠᨭᩩᨠᩮᨶ ᨸᩦᨲᩮᨶ;

ᩈᨻ᩠ᨻᩣ ᩉᩥ ᨠᩣᨾᩁᨲᩥᨿᩮᩣ, ᨠᨭᩩᨠᨲᩁᩣ ᨸᨬ᩠ᨧᨠᨭᩩᨠᩮᨶ.

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

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

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

ᩁᩣᨩᨣ᩠ᨣᩥᨧᩮᩣᩁᩏᨴᨠᨸ᩠ᨸᩥᨿᩮᩉᩥ, ᩈᩣᨵᩣᩁᨱᩣ ᨠᩣᨾᩣ ᨻᩉᩩᩈᨸᨲ᩠ᨲᩣ.

‘‘ᨾᩮᩣᨠ᩠ᨡᨾ᩠ᩉᩥ ᩅᩥᨩ᩠ᨩᨾᩣᨶᩮ, ᨠᩥᩴ ᨲᩅ ᨠᩣᨾᩮᩉᩥ ᨿᩮᩈᩩ ᩅᨵᨻᨶ᩠ᨵᩮᩣ;

ᨠᩣᨾᩮᩈᩩ ᩉᩥ ᩋᩈᨠᩣᨾᩣ, ᩅᨵᨻᨶ᩠ᨵᨴᩩᨡᩣᨶᩥ ᩋᨶᩩᨽᩮᩣᨶ᩠ᨲᩥ.

‘‘ᩌᨴᩦᨸᩥᨲᩣ ¶ ¶ ᨲᩥᨱᩩᨠ᩠ᨠᩣ, ᨣᨱ᩠ᩉᨶ᩠ᨲᩴ ᨴᩉᨶ᩠ᨲᩥ ᨶᩮᩅ ᨾᩩᨬ᩠ᨧᨶ᩠ᨲᩴ;

ᩏᨠ᩠ᨠᩮᩣᨸᨾᩣ ᩉᩥ ᨠᩣᨾᩣ, ᨴᩉᨶ᩠ᨲᩥ ᨿᩮ ᨲᩮ ᨶ ᨾᩩᨬ᩠ᨧᨶ᩠ᨲᩥ.

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

ᨾᩣ ᨸᩩᨳᩩᩃᩮᩣᨾᩮᩣᩅ ᨻᩊᩥᩈᩴ, ᨣᩥᩃᩥᨲ᩠ᩅᩣ ᨸᨧ᩠ᨨᩣ ᩅᩥᩉᨬ᩠ᨬᩈᩥ.

‘‘ᨠᩣᨾᩴ ¶ ᨠᩣᨾᩮᩈᩩ ᨴᨾᩔᩩ, ᨲᩣᩅ ᩈᩩᨶᨡᩮᩣᩅ ᩈᨦ᩠ᨡᩃᩣᨻᨴ᩠ᨵᩮᩣ;

ᨠᩣᩉᩥᨶ᩠ᨲᩥ ᨡᩩ ᨲᩴ ᨠᩣᨾᩣ, ᨨᩣᨲᩣ ᩈᩩᨶᨡᩴᩅ ᨧᨱ᩠ᨯᩣᩃᩣ.

‘‘ᩋᨸᩁᩥᨾᩥᨲᨬ᩠ᨧ ¶ ᨴᩩᨠ᩠ᨡᩴ, ᨻᩉᩪᨶᩥ ᨧ ᨧᩥᨲ᩠ᨲᨴᩮᩣᨾᨶᩔᩣᨶᩥ;

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

‘‘ᩋᨩᩁᨾ᩠ᩉᩥ ᩅᩥᨩ᩠ᨩᨾᩣᨶᩮ, ᨠᩥᩴ ᨲᩅ ᨠᩣᨾᩮᩉᩥ [ᨿᩮᩈᩩ ᨩᩁᩣᨿ ᨧ; ᨾᩁᨱᨻ᩠ᨿᩣᨵᩥᩉᩥ ᨣᩉᩥᨲᩣ (?)] ᨿᩮᩈᩩ ᨩᩁᩣ;

ᨾᩁᨱᨻ᩠ᨿᩣᨵᩥᨣᩉᩥᨲᩣ [ᨿᩮᩈᩩ ᨩᩁᩣᨿ ᨧ; ᨾᩁᨱᨻ᩠ᨿᩣᨵᩥᩉᩥ ᨣᩉᩥᨲᩣ (?)], ᩈᨻ᩠ᨻᩣ ᩈᨻ᩠ᨻᨲ᩠ᨳ ᨩᩣᨲᩥᨿᩮᩣ.

‘‘ᩍᨴᨾᨩᩁᨾᩥᨴᨾᨾᩁᩴ [ᩍᨴᩴ ᩋᨩᩁᩴ ᩍᨴᩴ ᩋᨾᩁᩴ (?)], ᩍᨴᨾᨩᩁᩣᨾᩁᩴ ᨸᨴᨾᩈᩮᩣᨠᩴ;

ᩋᩈᨸᨲ᩠ᨲᨾᩈᨾ᩠ᨻᩣᨵᩴ, ᩋᨡᩃᩥᨲᨾᨽᨿᩴ ᨶᩥᩁᩩᨸᨲᩣᨸᩴ.

‘‘ᩋᨵᩥᨣᨲᨾᩥᨴᩴ ᨻᩉᩪᩉᩥ, ᩋᨾᨲᩴ ᩋᨩ᩠ᨩᩣᨸᩥ ᨧ ᩃᨽᨶᩦᨿᨾᩥᨴᩴ;

ᨿᩮᩣ ᨿᩮᩣᨶᩥᩈᩮᩣ ᨸᨿᩩᨬ᩠ᨩᨲᩥ, ᨶ ᨧ ᩈᨠ᩠ᨠᩣ ᩋᨥᨭᨾᩣᨶᩮᨶ’’.

ᩑᩅᩴ ᨽᨱᨲᩥ ᩈᩩᨾᩮᨵᩣ, ᩈᨦ᩠ᨡᩣᩁᨣᨲᩮ ᩁᨲᩥᩴ ᩋᩃᨽᨾᩣᨶᩣ;

ᩋᨶᩩᨶᩮᨶ᩠ᨲᩦ ᩋᨶᩥᨠᩁᨲ᩠ᨲᩴ, ᨠᩮᩈᩮ ᨧ ᨨᨾᩴ ᨡᩥᨸᩥ ᩈᩩᨾᩮᨵᩣ.

ᩏᨭ᩠ᨮᩣᨿ ᩋᨶᩥᨠᩁᨲ᩠ᨲᩮᩣ, ᨸᨬ᩠ᨩᩃᩥᨠᩮᩣ ᨿᩣᨧᩥᨲᩔᩣ ᨸᩥᨲᩁᩴ ᩈᩮᩣ;

‘‘ᩅᩥᩔᨩ᩠ᨩᩮᨳ ᩈᩩᨾᩮᨵᩴ, ᨸᨻ᩠ᨻᨩᩥᨲᩩᩴ ᩅᩥᨾᩮᩣᨠ᩠ᨡᩈᨧ᩠ᨧᨴᩔᩣ’’.

ᩅᩥᩔᨩ᩠ᨩᩥᨲᩣ ᨾᩣᨲᩣᨸᩥᨲᩪᩉᩥ, ᨸᨻ᩠ᨻᨩᩥ ᩈᩮᩣᨠᨽᨿᨽᩦᨲᩣ;

ᨨ ᩋᨽᩥᨬ᩠ᨬᩣ ᩈᨧ᩠ᨨᩥᨠᨲᩣ, ᩋᨣ᩠ᨣᨹᩃᩴ ᩈᩥᨠ᩠ᨡᨾᩣᨶᩣᨿ.

ᩋᨧ᩠ᨨᩁᩥᨿᨾᨻ᩠ᨽᩩᨲᩴ ¶ ᨲᩴ, ᨶᩥᨻ᩠ᨻᩣᨶᩴ ᩌᩈᩥ ᩁᩣᨩᨠᨬ᩠ᨬᩣᨿ;

ᨸᩩᨻ᩠ᨻᩮᨶᩥᩅᩣᩈᨧᩁᩥᨲᩴ, ᨿᨳᩣ ᨻ᩠ᨿᩣᨠᩁᩥ ᨸᨧ᩠ᨨᩥᨾᩮ ᨠᩣᩃᩮ.

‘‘ᨽᨣᩅᨲᩥ ᨠᩮᩣᨱᩣᨣᨾᨶᩮ, ᩈᨦ᩠ᨥᩣᩁᩣᨾᨾ᩠ᩉᩥ ᨶᩅᨶᩥᩅᩮᩈᨾ᩠ᩉᩥ;

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

‘‘ᨴᩈᨠ᩠ᨡᨲ᩠ᨲᩩᩴ ᩈᨲᨠ᩠ᨡᨲ᩠ᨲᩩᩴ, ᨴᩈᩈᨲᨠ᩠ᨡᨲ᩠ᨲᩩᩴ ᩈᨲᩣᨶᩥ ᨧ ᩈᨲᨠ᩠ᨡᨲ᩠ᨲᩩᩴ;

ᨴᩮᩅᩮᩈᩩ ¶ ᩏᨸ᩠ᨸᨩ᩠ᨩᩥᨾ᩠ᩉ, ᨠᩮᩣ ᨸᨶ ᩅᩣᨴᩮᩣ ᨾᨶᩩᩔᩮᩈᩩ.

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

ᩈᨲ᩠ᨲᩁᨲᨶᩔ ᨾᩉᩮᩈᩦ, ᩍᨲ᩠ᨳᩥᩁᨲᨶᩴ ᩋᩉᩴ ᩌᩈᩥᩴ.

‘‘ᩈᩮᩣ ¶ ¶ ᩉᩮᨲᩩ ᩈᩮᩣ ᨸᨽᩅᩮᩣ, ᨲᩴ ᨾᩪᩃᩴ ᩈᩣᩅ ᩈᩣᩈᨶᩮ ᨡᨶ᩠ᨲᩦ;

ᨲᩴ ᨸᨮᨾᩈᨾᩮᩣᨵᩣᨶᩴ, ᨲᩴ ᨵᨾ᩠ᨾᩁᨲᩣᨿ ᨶᩥᨻ᩠ᨻᩣᨶᩴ’’.

ᩑᩅᩴ ᨠᩁᩮᩣᨶ᩠ᨲᩥ ᨿᩮ ᩈᨴ᩠ᨴᩉᨶ᩠ᨲᩥ, ᩅᨧᨶᩴ ᩋᨶᩮᩣᨾᨸᨬ᩠ᨬᩔ;

ᨶᩥᨻ᩠ᨻᩥᨶ᩠ᨴᨶ᩠ᨲᩥ ᨽᩅᨣᨲᩮ, ᨶᩥᨻ᩠ᨻᩥᨶ᩠ᨴᩥᨲ᩠ᩅᩣ ᩅᩥᩁᨩ᩠ᨩᨶ᩠ᨲᩦᨲᩥ.

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᩈᩩᨾᩮᨵᩣ ᨳᩮᩁᩦ ᨣᩣᨳᩣᨿᩮᩣ ᩋᨽᩣᩈᩥᨲ᩠ᨳᩣᨲᩥ.

ᨣᩣᨳᩣᩈᨲᩣᨶᩥ ᨧᨲ᩠ᨲᩣᩁᩥ, ᩋᩈᩦᨲᩥ ᨸᩩᨶ ᨧᩩᨴ᩠ᨴᩈ [ᨣᩣᨳᩣᩈᨦ᩠ᨡ᩠ᨿᩣ ᩍᨵ ᩋᨶᩩᨠ᩠ᨠᨾᨱᩥᨠᨣᨱᨶᩣᩅᩈᩮᨶ ᨸᩣᨠᨭᩣ];

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