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

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

Misc. Paragraph

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

ᨧᩁᩥᨿᩣᨸᩥᨭᨠᨸᩣᩊᩥ

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

‘‘ᨠᨸ᩠ᨸᩮ ¶ ¶ ¶ ¶ ᨧ ᩈᨲᩈᩉᩔᩮ, ᨧᨲᩩᩁᩮᩣ ᨧ ᩋᩈᨦ᩠ᨡᩥᨿᩮ;

ᩑᨲ᩠ᨳᨶ᩠ᨲᩁᩮ ᨿᩴ ᨧᩁᩥᨲᩴ, ᩈᨻ᩠ᨻᩴ ᨲᩴ ᨻᩮᩣᨵᩥᨸᩣᨧᨶᩴ.

‘‘ᩋᨲᩦᨲᨠᨸ᩠ᨸᩮ ᨧᩁᩥᨲᩴ, ᨮᨸᨿᩥᨲ᩠ᩅᩣ ᨽᩅᩣᨽᩅᩮ;

ᩍᨾᨾ᩠ᩉᩥ ᨠᨸ᩠ᨸᩮ ᨧᩁᩥᨲᩴ, ᨸᩅᨠ᩠ᨡᩥᩔᩴ ᩈᩩᨱᩮᩣᩉᩥ ᨾᩮ.

‘‘ᨿᨴᩣ ᩋᩉᩴ ᨻᩕᩉᩣᩁᨬ᩠ᨬᩮ, ᩈᩩᨬ᩠ᨬᩮ ᩅᩥᨸᩥᨶᨠᩣᨶᨶᩮ;

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

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

ᨵᩣᩁᩮᨶ᩠ᨲᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩅᨱ᩠ᨱᩴ, ᨽᩥᨠ᩠ᨡᩣᨿ ᨾᩴ ᩏᨸᩣᨣᨾᩥ.

‘‘ᨸᩅᨶᩣ ᩌᨽᨲᩴ ᨸᨱ᩠ᨱᩴ, ᩋᨲᩮᩃᨬ᩠ᨧ ᩋᩃᩮᩣᨱᩥᨠᩴ;

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

‘‘ᨲᩔ ᨴᨲ᩠ᩅᩣᨶᩉᩴ ᨸᨱ᩠ᨱᩴ, ᨶᩥᨠ᩠ᨠᩩᨩ᩠ᨩᩥᨲ᩠ᩅᩣᨶ ᨽᩣᨩᨶᩴ;

ᨸᩩᨶᩮᩈᨶᩴ ᨩᩉᩥᨲ᩠ᩅᩣᨶ, ᨸᩣᩅᩥᩈᩥᩴ ᨸᨱ᩠ᨱᩈᩣᩃᨠᩴ.

‘‘ᨴᩩᨲᩥᨿᨾ᩠ᨸᩥ ¶ ᨲᨲᩥᨿᨾ᩠ᨸᩥ, ᩏᨸᨣᨬ᩠ᨨᩥ ᨾᨾᨶ᩠ᨲᩥᨠᩴ;

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

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

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

‘‘ᨿᨴᩥ ᨾᩣᩈᨾ᩠ᨸᩥ ᨴ᩠ᩅᩮᨾᩣᩈᩴ, ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩴ ᩅᩁᩴ ᩃᨽᩮ;

ᩋᨠᨾ᩠ᨸᩥᨲᩮᩣ ᩋᨶᩮᩣᩃᩦᨶᩮᩣ, ᨴᨴᩮᨿ᩠ᨿᩴ ᨴᩣᨶᨾᩩᨲ᩠ᨲᨾᩴ.

‘‘ᨶ ᨲᩔ ᨴᩣᨶᩴ ᨴᨴᨾᩣᨶᩮᩣ, ᨿᩈᩴ ᩃᩣᨽᨬ᩠ᨧ ᨸᨲ᩠ᨳᨿᩥᩴ;

ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩴ ᨸᨲ᩠ᨳᨿᩣᨶᩮᩣ, ᨲᩣᨶᩥ ᨠᨾ᩠ᨾᩣᨶᩥ ᩌᨧᩁᩥ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩈᨦ᩠ᨡᩈᩅ᩠ᩉᨿᩮᩣ;

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

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

ᨠᨶ᩠ᨲᩣᩁᨴ᩠ᨵᩣᨶᩴ ᨸᨭᩥᨸᨶ᩠ᨶᩴ [ᨠᨶ᩠ᨲᩣᩁᨴ᩠ᨵᩣᨶᨸᨭᩥᨸᨶ᩠ᨶᩴ (ᩈᩦ. ᩈ᩠ᨿᩣ.)], ᨲᨲ᩠ᨲᩣᨿ ᨠᨮᩥᨶᨽᩪᨾᩥᨿᩣ.

‘‘ᨲᨾᩉᩴ ᨸᨭᩥᨸᨳᩮ ᨴᩥᩈ᩠ᩅᩣ, ᩍᨾᨾᨲ᩠ᨳᩴ ᩅᩥᨧᩥᨶ᩠ᨲᨿᩥᩴ;

‘ᩍᨴᩴ ᨡᩮᨲ᩠ᨲᩴ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩴ, ᨸᩩᨬ᩠ᨬᨠᩣᨾᩔ ᨩᨶ᩠ᨲᩩᨶᩮᩣ.

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

ᨲᨲ᩠ᨳ ᨻᩦᨩᩴ ᨶ ᩁᩮᩣᨸᩮᨲᩥ, ᨶ ᩈᩮᩣ ᨵᨬ᩠ᨬᩮᨶ ᩋᨲ᩠ᨳᩥᨠᩮᩣ.

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

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

‘‘‘ᨿᨳᩣ ᩋᨾᨧ᩠ᨧᩮᩣ ᨾᩩᨴ᩠ᨴᩥᨠᩣᨾᩮᩣ, ᩁᨬ᩠ᨬᩮᩣ ᩋᨶ᩠ᨲᩮᨸᩩᩁᩮ ᨩᨶᩮ;

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

‘‘‘ᩑᩅᨾᩮᩅᩣᩉᩴ ᨸᩩᨬ᩠ᨬᨠᩣᨾᩮᩣ, ᩅᩥᨸᩩᩃᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᨴᨠ᩠ᨡᩥᨱᩴ;

ᨿᨴᩥ ᨲᩔ ᨴᩣᨶᩴ ᨶ ᨴᨴᩣᨾᩥ, ᨸᩁᩥᩉᩣᨿᩥᩔᩣᨾᩥ ᨸᩩᨬ᩠ᨬᨲᩮᩣ’.

‘‘ᩑᩅᩣᩉᩴ ᨧᩥᨶ᩠ᨲᨿᩥᨲ᩠ᩅᩣᨶ, ᩒᩁᩮᩣᩉᩥᨲ᩠ᩅᩣ ᩏᨸᩣᩉᨶᩣ;

ᨲᩔ ᨸᩣᨴᩣᨶᩥ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ, ᩋᨴᩣᩈᩥᩴ ᨨᨲ᩠ᨲᩩᨸᩣᩉᨶᩴ.

‘‘ᨲᩮᨶᩮᩅᩣᩉᩴ ¶ ᩈᨲᨣᩩᨱᨲᩮᩣ, ᩈᩩᨡᩩᨾᩣᩃᩮᩣ ᩈᩩᨡᩮᨵᩥᨲᩮᩣ;

ᩋᨸᩥ ᨧ ᨴᩣᨶᩴ ᨸᩁᩥᨸᩪᩁᩮᨶ᩠ᨲᩮᩣ, ᩑᩅᩴ ᨲᩔ ᩋᨴᩣᩈᩉ’’ᨶ᩠ᨲᩥ.

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

ᩁᩣᨩᩣ ᨵᨶᨬ᩠ᨧᨿᩮᩣ ᨶᩣᨾ, ᨠᩩᩈᩃᩮ ᨴᩈᩉᩩᨸᩣᨣᨲᩮᩣ.

‘‘ᨠᩃᩥᨦ᩠ᨣᩁᨭ᩠ᨮᩅᩥᩈᨿᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩏᨸᨣᨬ᩠ᨨᩩ ᨾᩴ;

ᩌᨿᩣᨧᩩᩴ ᨾᩴ ᩉᨲ᩠ᨳᩥᨶᩣᨣᩴ, ᨵᨬ᩠ᨬᩴ ᨾᨦ᩠ᨣᩃᩈᨾ᩠ᨾᨲᩴ.

‘‘‘ᩋᩅᩩᨭ᩠ᨮᩥᨠᩮᩣ ᨩᨶᨸᨴᩮᩣ, ᨴᩩᨻ᩠ᨽᩥᨠ᩠ᨡᩮᩣ ᨨᩣᨲᨠᩮᩣ ᨾᩉᩣ;

ᨴᨴᩣᩉᩥ ᨸᩅᩁᩴ ᨶᩣᨣᩴ, ᨶᩦᩃᩴ ᩋᨬ᩠ᨩᨶᩈᩅ᩠ᩉᨿᩴ.

‘‘‘ᨶ ¶ ¶ ᨾᩮ ᨿᩣᨧᨠᨾᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮ, ᨸᨭᩥᨠ᩠ᨡᩮᨸᩮᩣ ᩋᨶᩩᨧ᩠ᨨᩅᩮᩣ;

ᨾᩣ ᨾᩮ ᨽᩥᨩ᩠ᨩᩥ ᩈᨾᩣᨴᩣᨶᩴ, ᨴᩔᩣᨾᩥ ᩅᩥᨸᩩᩃᩴ ᨣᨩᩴ’.

‘‘ᨶᩣᨣᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᩈᩮᩣᨱ᩠ᨯᩣᨿ, ᨽᩥᨦ᩠ᨣᩣᩁᩮ [ᨽᩥᨦ᩠ᨠᩣᩁᩮ (ᩈᩦ.)] ᩁᨲᨶᩣᨾᨿᩮ;

ᨩᩃᩴ ᩉᨲ᩠ᨳᩮ ᩌᨠᩥᩁᩥᨲ᩠ᩅᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᩋᨴᩴ ᨣᨩᩴ.

‘‘ᨲᩔ ᨶᩣᨣᩮ ᨸᨴᩥᨶ᩠ᨶᨾ᩠ᩉᩥ, ᩋᨾᨧ᩠ᨧᩣ ᩑᨲᨴᨻᩕᩅᩩᩴ;

‘ᨠᩥᩴ ᨶᩩ ᨲᩩᨿ᩠ᩉᩴ ᩅᩁᩴ ᨶᩣᨣᩴ, ᨿᩣᨧᨠᩣᨶᩴ ᨸᨴᩔᩈᩥ.

‘‘‘ᨵᨬ᩠ᨬᩴ ¶ ᨾᨦ᩠ᨣᩃᩈᨾ᩠ᨸᨶ᩠ᨶᩴ, ᩈᨦ᩠ᨣᩣᨾᩅᩥᨩᨿᩩᨲ᩠ᨲᨾᩴ;

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

‘‘‘ᩁᨩ᩠ᨩᨾ᩠ᨸᩥ ᨾᩮ ᨴᨴᩮ ᩈᨻ᩠ᨻᩴ, ᩈᩁᩦᩁᩴ ᨴᨩ᩠ᨩᨾᨲ᩠ᨲᨶᩮᩣ;

ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩴ ᨸᩥᨿᩴ ᨾᨿ᩠ᩉᩴ, ᨲᩈ᩠ᨾᩣ ᨶᩣᨣᩴ ᩋᨴᩣᩈᩉ’’’ᨶ᩠ᨲᩥ.

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

ᨾᩉᩣᩈᩩᨴᩔᨶᩮᩣ ᨶᩣᨾ, ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩦ ᨾᩉᨻ᩠ᨻᩃᩮᩣ.

‘‘ᨲᨲ᩠ᨳᩣᩉᩴ ¶ ᨴᩥᩅᩈᩮ ᨲᩥᨠ᩠ᨡᨲ᩠ᨲᩩᩴ, ᨥᩮᩣᩈᩣᨸᩮᨾᩥ ᨲᩉᩥᩴ ᨲᩉᩥᩴ;

‘ᨠᩮᩣ ᨠᩥᩴ ᩍᨧ᩠ᨨᨲᩥ ᨸᨲ᩠ᨳᩮᨲᩥ, ᨠᩔ ᨠᩥᩴ ᨴᩦᨿᨲᩪ ᨵᨶᩴ.

‘‘‘ᨠᩮᩣ ᨨᩣᨲᨠᩮᩣ ᨠᩮᩣ ᨲᩈᩥᨲᩮᩣ, ᨠᩮᩣ ᨾᩣᩃᩴ ᨠᩮᩣ ᩅᩥᩃᩮᨸᨶᩴ;

ᨶᩣᨶᩣᩁᨲ᩠ᨲᩣᨶᩥ ᩅᨲ᩠ᨳᩣᨶᩥ, ᨠᩮᩣ ᨶᨣ᩠ᨣᩮᩣ ᨸᩁᩥᨴᩉᩥᩔᨲᩥ.

‘‘‘ᨠᩮᩣ ᨸᨳᩮ ᨨᨲ᩠ᨲᨾᩣᨴᩮᨲᩥ, ᨠᩮᩣᨸᩣᩉᨶᩣ ᨾᩩᨴᩪ ᩈᩩᨽᩣ’;

ᩍᨲᩥ ¶ ᩈᩣᨿᨬ᩠ᨧ ᨸᩣᨲᩮᩣ ᨧ, ᨥᩮᩣᩈᩣᨸᩮᨾᩥ ᨲᩉᩥᩴ ᨲᩉᩥᩴ.

‘‘ᨶ ᨲᩴ ᨴᩈᩈᩩ ᨮᩣᨶᩮᩈᩩ, ᨶᨸᩥ ᨮᩣᨶᩈᨲᩮᩈᩩ ᩅᩣ;

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

‘‘ᨴᩥᩅᩣ ᩅᩣ ᨿᨴᩥ ᩅᩣ ᩁᨲ᩠ᨲᩥᩴ, ᨿᨴᩥ ᩑᨲᩥ ᩅᨶᩥᨻ᩠ᨻᨠᩮᩣ;

ᩃᨴ᩠ᨵᩣ ᨿᨴᩥᨧ᩠ᨨᨠᩴ ᨽᩮᩣᨣᩴ, ᨸᩪᩁᩉᨲ᩠ᨳᩮᩣᩅ ᨣᨧ᩠ᨨᨲᩥ.

‘‘ᩑᩅᩁᩪᨸᩴ ᨾᩉᩣᨴᩣᨶᩴ, ᩋᨴᩣᩈᩥᩴ ᨿᩣᩅᨩᩦᩅᩥᨠᩴ;

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

‘‘ᨿᨳᩣᨸᩥ ᩌᨲᩩᩁᩮᩣ ᨶᩣᨾ, ᩁᩮᩣᨣᨲᩮᩣ ᨸᩁᩥᨾᩩᨲ᩠ᨲᩥᨿᩣ;

ᨵᨶᩮᨶ ᩅᩮᨩ᩠ᨩᩴ ᨲᨸ᩠ᨸᩮᨲ᩠ᩅᩣ, ᩁᩮᩣᨣᨲᩮᩣ ᨸᩁᩥᨾᩩᨧ᩠ᨧᨲᩥ.

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

ᩐᨶᨾᨶᩴ ᨸᩪᩁᨿᩥᨲᩩᩴ, ᨴᩮᨾᩥ ᨴᩣᨶᩴ ᩅᨶᩥᨻ᩠ᨻᨠᩮ;

ᨶᩥᩁᩣᩃᨿᩮᩣ ᩋᨸᨧ᩠ᨧᩣᩈᩮᩣ, ᩈᨾ᩠ᨻᩮᩣᨵᩥᨾᨶᩩᨸᨲ᩠ᨲᩥᨿᩣ’’ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᩈᨲ᩠ᨲᩁᩣᨩᨸᩩᩁᩮᩣᩉᩥᨲᩮᩣ;

ᨸᩪᨩᩥᨲᩮᩣ ᨶᩁᨴᩮᩅᩮᩉᩥ, ᨾᩉᩣᨣᩮᩣᩅᩥᨶ᩠ᨴᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

‘‘ᨲᨴᩣᩉᩴ ᩈᨲ᩠ᨲᩁᨩ᩠ᨩᩮᩈᩩ, ᨿᩴ ᨾᩮ ᩌᩈᩥ ᩏᨸᩣᨿᨶᩴ;

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

‘‘ᨶ ¶ ¶ ᨾᩮ ᨴᩮᩔᩴ ᨵᨶᩴ ᨵᨬ᩠ᨬᩴ, ᨶᨸᩥ ᨶᨲ᩠ᨳᩥ ᨶᩥᨧᨿᩮᩣ ᨾᨿᩥ;

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

‘‘ᨸᩩᨶᩣᨸᩁᩴ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨾᩥᨳᩥᩃᩣᨿᩴ ᨸᩩᩁᩩᨲ᩠ᨲᨾᩮ;

ᨶᩥᨾᩥ ᨶᩣᨾ ᨾᩉᩣᩁᩣᨩᩣ, ᨸᨱ᩠ᨯᩥᨲᩮᩣ ᨠᩩᩈᩃᨲ᩠ᨳᩥᨠᩮᩣ.

‘‘ᨲᨴᩣᩉᩴ ᨾᩣᨸᨿᩥᨲ᩠ᩅᩣᨶ, ᨧᨲᩩᩔᩣᩃᩴ ᨧᨲᩩᨾ᩠ᨾᩩᨡᩴ;

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

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

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

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

ᨠᩣᨿᩮᨶ ᩅᩣᨧᩣ ᨾᨶᩈᩣ, ᩌᩁᩣᨵᨶᩦᨿᨾᩮᩈᨲᩥ.

‘‘ᨲᨳᩮᩅᩣᩉᩴ ᩈᨻ᩠ᨻᨽᩅᩮ, ᨸᩁᩥᨿᩮᩈᩥᩔᩣᨾᩥ ᨻᩮᩣᨵᩥᨩᩴ;

ᨴᩣᨶᩮᨶ ᩈᨲ᩠ᨲᩮ ᨲᨸ᩠ᨸᩮᨲ᩠ᩅᩣ, ᩍᨧ᩠ᨨᩣᨾᩥ ᨻᩮᩣᨵᩥᨾᩩᨲ᩠ᨲᨾ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᩑᨠᩁᩣᨩᩔ ᩋᨲᩕᨩᩮᩣ;

ᨶᨣᩁᩮ ᨸᩩᨸ᩠ᨹᩅᨲᩥᨿᩣ, ᨠᩩᨾᩣᩁᩮᩣ ᨧᨶ᩠ᨴᩈᩅ᩠ᩉᨿᩮᩣ.

‘‘ᨲᨴᩣᩉᩴ ¶ ᨿᨩᨶᩣ ᨾᩩᨲ᩠ᨲᩮᩣ, ᨶᩥᨠ᩠ᨡᨶ᩠ᨲᩮᩣ ᨿᨬ᩠ᨬᩅᩣᨭᨲᩮᩣ;

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

‘‘ᨶᩣᩉᩴ ᨸᩥᩅᩣᨾᩥ ᨡᩣᨴᩣᨾᩥ, ᨶᨸᩥ ᨽᩩᨬ᩠ᨩᩣᨾᩥ ᨽᩮᩣᨩᨶᩴ;

ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩮ ᩋᨴᨲ᩠ᩅᩣᨶ, ᩋᨸᩥ ᨨᨸ᩠ᨸᨬ᩠ᨧᩁᨲ᩠ᨲᩥᨿᩮᩣ.

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

ᨿᨲ᩠ᨳ ᩃᩣᨽᩮᩣ ᨾᩉᩣ ᩉᩮᩣᨲᩥ, ᨲᨲ᩠ᨳ ᨲᩴ [ᨲᨲ᩠ᨳ ᨶᩴ (ᩈᩦ.), ᨲᨲ᩠ᨳ (ᨠ.)] ᩉᩁᨲᩥ ᨽᨱ᩠ᨯᨠᩴ.

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

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

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

ᨶ ᨸᨭᩥᨠ᩠ᨠᨾᩣᨾᩥ ᨴᩣᨶᨲᩮᩣ, ᩈᨾ᩠ᨻᩮᩣᨵᩥᨾᨶᩩᨸᨲ᩠ᨲᩥᨿᩣ’’ᨲᩥ.

‘‘ᩋᩁᩥᨭ᩠ᨮᩈᩅ᩠ᩉᨿᩮ ᨶᨣᩁᩮ, ᩈᩥᩅᩥᨶᩣᨾᩣᩈᩥ ᨡᨲ᩠ᨲᩥᨿᩮᩣ;

ᨶᩥᩈᨩ᩠ᨩ ᨸᩣᩈᩣᨴᩅᩁᩮ, ᩑᩅᩴ ᨧᩥᨶ᩠ᨲᩮᩈᩉᩴ ᨲᨴᩣ.

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

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

‘‘ᨾᨾ ᩈᨦ᩠ᨠᨸ᩠ᨸᨾᨬ᩠ᨬᩣᨿ, ᩈᨠ᩠ᨠᩮᩣ ᨴᩮᩅᩣᨶᨾᩥᩔᩁᩮᩣ;

ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᨴᩮᩅᨸᩁᩥᩈᩣᨿ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥ.

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

ᨧᩥᨶ᩠ᨲᩮᨶ᩠ᨲᩮᩣ ᩅᩥᩅᩥᨵᩴ ᨴᩣᨶᩴ, ᩋᨴᩮᨿ᩠ᨿᩴ ᩈᩮᩣ ᨶ ᨸᩔᨲᩥ.

‘‘‘ᨲᨳᩴ ¶ ᨶᩩ ᩅᩥᨲᨳᩴ ᨶᩮᨲᩴ, ᩉᨶ᩠ᨴ ᩅᩦᨾᩴᩈᨿᩣᨾᩥ ᨲᩴ;

ᨾᩩᩉᩩᨲ᩠ᨲᩴ ᩌᨣᨾᩮᨿ᩠ᨿᩣᨳ, ᨿᩣᩅ ᨩᩣᨶᩣᨾᩥ ᨲᩴ ᨾᨶᩴ’.

‘‘ᨸᩅᩮᨵᨾᩣᨶᩮᩣ ᨸᩃᩥᨲᩈᩥᩁᩮᩣ, ᩅᩃᩥᨣᨲ᩠ᨲᩮᩣ [ᩅᩃᩥᨲᨣᨲ᩠ᨲᩮᩣ (ᩈᩦ.)] ᨩᩁᩣᨲᩩᩁᩮᩣ;

ᩋᨶ᩠ᨵᩅᨱ᩠ᨱᩮᩣᩅ ᩉᩩᨲ᩠ᩅᩣᨶ, ᩁᩣᨩᩣᨶᩴ ᩏᨸᩈᨦ᩠ᨠᨾᩥ.

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

ᩈᩥᩁᩈ᩠ᨾᩥᩴ ᩋᨬ᩠ᨩᩃᩥᩴ ᨠᨲ᩠ᩅᩣ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥ.

‘‘‘ᨿᩣᨧᩣᨾᩥ ᨲᩴ ᨾᩉᩣᩁᩣᨩ, ᨵᨾ᩠ᨾᩥᨠ ᩁᨭ᩠ᨮᩅᨯ᩠ᨰᨶ;

ᨲᩅ ᨴᩣᨶᩁᨲᩣ ᨠᩥᨲ᩠ᨲᩥ, ᩏᨣ᩠ᨣᨲᩣ ᨴᩮᩅᨾᩣᨶᩩᩈᩮ.

‘‘‘ᩏᨽᩮᩣᨸᩥ ¶ ᨶᩮᨲ᩠ᨲᩣ ᨶᨿᨶᩣ, ᩋᨶ᩠ᨵᩣ ᩏᨸᩉᨲᩣ ᨾᨾ;

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

‘‘ᨲᩔᩣᩉᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩉᨭ᩠ᨮᩮᩣ ᩈᩴᩅᩥᨣ᩠ᨣᨾᩣᨶᩈᩮᩣ;

ᨠᨲᨬ᩠ᨩᩃᩦ ᩅᩮᨴᨩᩣᨲᩮᩣ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥᩴ.

‘‘‘ᩍᨴᩣᨶᩣᩉᩴ ᨧᩥᨶ᩠ᨲᨿᩥᨲ᩠ᩅᩣᨶ, ᨸᩣᩈᩣᨴᨲᩮᩣ ᩍᨵᩣᨣᨲᩮᩣ;

ᨲ᩠ᩅᩴ ᨾᨾ ᨧᩥᨲ᩠ᨲᨾᨬ᩠ᨬᩣᨿ, ᨶᩮᨲ᩠ᨲᩴ ᨿᩣᨧᩥᨲᩩᨾᩣᨣᨲᩮᩣ.

‘‘‘ᩋᩉᩮᩣ ᨾᩮ ᨾᩣᨶᩈᩴ ᩈᩥᨴ᩠ᨵᩴ, ᩈᨦ᩠ᨠᨸ᩠ᨸᩮᩣ ᨸᩁᩥᨸᩪᩁᩥᨲᩮᩣ;

ᩋᨴᩥᨶ᩠ᨶᨸᩩᨻ᩠ᨻᩴ ᨴᩣᨶᩅᩁᩴ, ᩋᨩ᩠ᨩ ᨴᩔᩣᨾᩥ ᨿᩣᨧᨠᩮ.

‘‘‘ᩑᩉᩥ ᩈᩥᩅᨠ ᩏᨭ᩠ᨮᩮᩉᩥ, ᨾᩣ ᨴᨶ᩠ᨵᨿᩥ ᨾᩣ ᨸᩅᩮᨵᨿᩥ;

ᩏᨽᩮᩣᨸᩥ ᨶᨿᨶᩴ ᨴᩮᩉᩥ, ᩏᨸ᩠ᨸᩣᨭᩮᨲ᩠ᩅᩣ ᩅᨱᩥᨻ᩠ᨻᨠᩮ’.

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

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

‘‘ᨴᨴᨾᩣᨶᩔ ᨴᩮᨶ᩠ᨲᩔ, ᨴᩥᨶ᩠ᨶᨴᩣᨶᩔ ᨾᩮ ᩈᨲᩮᩣ;

ᨧᩥᨲ᩠ᨲᩔ ᩋᨬ᩠ᨬᨳᩣ ᨶᨲ᩠ᨳᩥ, ᨻᩮᩣᨵᩥᨿᩣᨿᩮᩅ ᨠᩣᩁᨱᩣ.

‘‘ᨶ ᨾᩮ ᨴᩮᩔᩣ ᩏᨽᩮᩣ ᨧᨠ᩠ᨡᩪ, ᩋᨲ᩠ᨲᩣ ᨶ ᨾᩮ ᨶ ᨴᩮᩔᩥᨿᩮᩣ;

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

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

ᩈᩣ ᩋᨲᩦᨲᩣᩈᩩ ᨩᩣᨲᩦᩈᩩ, ᩈᨠ᩠ᨠᩔ ᨾᩉᩮᩈᩦ ᨸᩥᨿᩣ.

‘‘ᨲᩔᩣ ᩌᨿᩩᨠ᩠ᨡᨿᩴ ᨬᨲ᩠ᩅᩣ, ᨴᩮᩅᩥᨶ᩠ᨴᩮᩣ ᩑᨲᨴᨻᩕᩅᩥ;

‘ᨴᨴᩣᨾᩥ ᨲᩮ ᨴᩈ ᩅᩁᩮ, ᩅᩁᨽᨴ᩠ᨴᩮ ᨿᨴᩥᨧ᩠ᨨᩈᩥ’.

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

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

ᩁᨾ᩠ᨾᩣ ᨧᩣᩅᩮᩈᩥ ᨾᩴ ᨮᩣᨶᩣ, ᩅᩣᨲᩮᩣᩅ ᨵᩁᨱᩦᩁᩩᩉᩴ’.

‘‘ᩑᩅᩴ ¶ ᩅᩩᨲ᩠ᨲᩮᩣ ᨧ ᩈᩮᩣ ᩈᨠ᩠ᨠᩮᩣ, ᨸᩩᨶ ᨲᩔᩥᨴᨾᨻᩕᩅᩥ;

‘ᨶ ᨧᩮᩅ ᨲᩮ ᨠᨲᩴ ᨸᩣᨸᩴ, ᨶ ᨧ ᨾᩮ ᨲ᩠ᩅᩴᩈᩥ ᩋᨸ᩠ᨸᩥᨿᩣ.

‘‘‘ᩑᨲ᩠ᨲᨠᩴᨿᩮᩅ ¶ ᨲᩮ ᩌᨿᩩ, ᨧᩅᨶᨠᩣᩃᩮᩣ ᨽᩅᩥᩔᨲᩥ;

ᨸᨭᩥᨣ᩠ᨣᨱ᩠ᩉ ᨾᨿᩣ ᨴᩥᨶ᩠ᨶᩮ, ᩅᩁᩮ ᨴᩈ ᩅᩁᩩᨲ᩠ᨲᨾᩮ’.

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

ᨾᨾᩴ ᩋᨻ᩠ᨽᨶ᩠ᨲᩁᩴ ᨠᨲ᩠ᩅᩣ, ᨹᩩᩔᨲᩦ ᨴᩈ ᩅᩁᩮ ᩅᩁᩦ.

‘‘ᨲᨲᩮᩣ ᨧᩩᨲᩣ ᩈᩣ ᨹᩩᩔᨲᩦ, ᨡᨲ᩠ᨲᩥᨿᩮ ᩏᨸᨸᨩ᩠ᨩᨳ;

ᨩᩮᨲᩩᨲ᩠ᨲᩁᨾ᩠ᩉᩥ ᨶᨣᩁᩮ, ᩈᨬ᩠ᨩᨿᩮᨶ ᩈᨾᩣᨣᨾᩥ.

‘‘ᨿᨴᩣᩉᩴ ᨹᩩᩔᨲᩥᨿᩣ ᨠᩩᨧ᩠ᨨᩥᩴ, ᩒᨠ᩠ᨠᨶ᩠ᨲᩮᩣ ᨸᩥᨿᨾᩣᨲᩩᨿᩣ;

ᨾᨾ ᨲᩮᨩᩮᨶ ᨾᩮ ᨾᩣᨲᩣ, ᩈᨴᩣ ᨴᩣᨶᩁᨲᩣ ᩋᩉᩩ.

‘‘ᩋᨵᨶᩮ ᩌᨲᩩᩁᩮ ᨩᩥᨱ᩠ᨱᩮ, ᨿᩣᨧᨠᩮ ᩋᨴ᩠ᨵᩥᨠᩮ [ᨸᨳᩥᨠᩮ (ᨠ.)] ᨩᨶᩮ;

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

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

ᩅᩮᩔᩣᨶᩴ ᩅᩦᨳᩥᨿᩣ ᨾᨩ᩠ᨫᩮ, ᨩᨶᩮᩈᩥ ᨹᩩᩔᨲᩦ ᨾᨾᩴ.

‘‘ᨶ ᨾᨿ᩠ᩉᩴ ᨾᨲ᩠ᨲᩥᨠᩴ ᨶᩣᨾᩴ, ᨶᨸᩥ ᨸᩮᨲ᩠ᨲᩥᨠᩈᨾ᩠ᨽᩅᩴ;

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

‘‘ᨿᨴᩣᩉᩴ ᨴᩣᩁᨠᩮᩣ ᩉᩮᩣᨾᩥ, ᨩᩣᨲᩥᨿᩣ ᩋᨭ᩠ᨮᩅᩔᩥᨠᩮᩣ;

ᨲᨴᩣ ᨶᩥᩈᨩ᩠ᨩ ᨸᩣᩈᩣᨴᩮ, ᨴᩣᨶᩴ ᨴᩣᨲᩩᩴ ᩅᩥᨧᩥᨶ᩠ᨲᨿᩥᩴ.

‘‘‘ᩉᨴᨿᩴ ¶ ᨴᨴᩮᨿ᩠ᨿᩴ ᨧᨠ᩠ᨡᩩᩴ, ᨾᩴᩈᨾ᩠ᨸᩥ ᩁᩩᨵᩥᩁᨾ᩠ᨸᩥ ᨧ;

ᨴᨴᩮᨿ᩠ᨿᩴ ᨠᩣᨿᩴ ᩈᩣᩅᩮᨲ᩠ᩅᩣ, ᨿᨴᩥ ᨠᩮᩣᨧᩥ ᨿᩣᨧᨿᩮ ᨾᨾᩴ’.

‘‘ᩈᨽᩣᩅᩴ ᨧᩥᨶ᩠ᨲᨿᨶ᩠ᨲᩔ, ᩋᨠᨾ᩠ᨸᩥᨲᨾᩈᨱ᩠ᨮᩥᨲᩴ;

ᩋᨠᨾ᩠ᨸᩥ ᨲᨲ᩠ᨳ ᨸᨳᩅᩦ, ᩈᩥᨶᩮᩁᩩᩅᨶᩅᨭᩴᩈᨠᩣ.

‘‘ᩋᨶ᩠ᩅᨴ᩠ᨵᨾᩣᩈᩮ ᨸᨶ᩠ᨶᩁᩈᩮ, ᨸᩩᨱ᩠ᨱᨾᩣᩈᩮ ᩏᨸᩮᩣᩈᨳᩮ;

ᨸᨧ᩠ᨧᨿᩴ ᨶᩣᨣᨾᩣᩁᩩᨿ᩠ᩉ, ᨴᩣᨶᩴ ᨴᩣᨲᩩᩴ ᩏᨸᩣᨣᨾᩥᩴ.

‘‘ᨠᩃᩥᨦ᩠ᨣᩁᨭ᩠ᨮᩅᩥᩈᨿᩣ ¶ , ᨻᩕᩣᩉ᩠ᨾᨱᩣ ᩏᨸᨣᨬ᩠ᨨᩩ ᨾᩴ;

ᩋᨿᩣᨧᩩᩴ ᨾᩴ ᩉᨲ᩠ᨳᩥᨶᩣᨣᩴ, ᨵᨬ᩠ᨬᩴ ᨾᨦ᩠ᨣᩃᩈᨾ᩠ᨾᨲᩴ.

‘‘ᩋᩅᩩᨭ᩠ᨮᩥᨠᩮᩣ ¶ ᨩᨶᨸᨴᩮᩣ, ᨴᩩᨻ᩠ᨽᩥᨠ᩠ᨡᩮᩣ ᨨᩣᨲᨠᩮᩣ ᨾᩉᩣ;

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

‘‘ᨴᨴᩣᨾᩥ ᨶ ᩅᩥᨠᨾ᩠ᨸᩣᨾᩥ, ᨿᩴ ᨾᩴ ᨿᩣᨧᨶ᩠ᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩣ;

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

‘‘ᨶ ᨾᩮ ᨿᩣᨧᨠᨾᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮ, ᨸᨭᩥᨠ᩠ᨡᩮᨸᩮᩣ ᩋᨶᩩᨧ᩠ᨨᩅᩮᩣ;

‘ᨾᩣ ᨾᩮ ᨽᩥᨩ᩠ᨩᩥ ᩈᨾᩣᨴᩣᨶᩴ, ᨴᩔᩣᨾᩥ ᩅᩥᨸᩩᩃᩴ ᨣᨩᩴ’.

‘‘ᨶᩣᨣᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᩈᩮᩣᨱ᩠ᨯᩣᨿ, ᨽᩥᨦ᩠ᨣᩣᩁᩮ ᩁᨲᨶᩣᨾᨿᩮ;

ᨩᩃᩴ ᩉᨲ᩠ᨳᩮ ᩌᨠᩥᩁᩥᨲ᩠ᩅᩣ, ᨻᩕᩣᩉ᩠ᨾᨱᩣᨶᩴ ᩋᨴᩴ ᨣᨩᩴ.

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

ᨲᨴᩣᨸᩥ ᨸᨳᩅᩦ ᨠᨾ᩠ᨸᩥ, ᩈᩥᨶᩮᩁᩩᩅᨶᩅᨭᩴᩈᨠᩣ.

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

ᨸᨻ᩠ᨻᩣᨩᩮᩈᩩᩴ ᩈᨠᩣ ᩁᨭ᩠ᨮᩣ, ‘ᩅᨦ᩠ᨠᩴ ᨣᨧ᩠ᨨᨲᩩ ᨸᨻ᩠ᨻᨲᩴ’.

‘‘ᨲᩮᩈᩴ ᨶᩥᨧ᩠ᨨᩩᨽᨾᩣᨶᩣᨶᩴ, ᩋᨠᨾ᩠ᨸᩥᨲ᩠ᨳᨾᩈᨱ᩠ᨮᩥᨲᩴ;

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

‘‘ᨿᩣᨧᩥᨲᩣ ¶ ᩈᩥᩅᨿᩮᩣ ᩈᨻ᩠ᨻᩮ, ᩑᨠᩴ ᩅᩁᨾᨴᩴᩈᩩ ᨾᩮ;

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

‘‘ᩋᨳᩮᨲ᩠ᨳ ᩅᨲ᩠ᨲᨲᩦ ᩈᨴ᩠ᨴᩮᩣ, ᨲᩩᨾᩩᩃᩮᩣ ᨽᩮᩁᩅᩮᩣ ᨾᩉᩣ;

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

‘‘ᩉᨲ᩠ᨳᩥᩴ ¶ ᩋᩔᩮ ᩁᨳᩮ ᨴᨲ᩠ᩅᩣ, ᨴᩣᩈᩥᩴ ᨴᩣᩈᩴ ᨣᩅᩴ ᨵᨶᩴ;

ᨾᩉᩣᨴᩣᨶᩴ ᨴᨴᩥᨲ᩠ᩅᩣᨶ, ᨶᨣᩁᩣ ᨶᩥᨠ᩠ᨡᨾᩥᩴ ᨲᨴᩣ.

‘‘ᨶᩥᨠ᩠ᨡᨾᩥᨲ᩠ᩅᩣᨶ ¶ ᨶᨣᩁᩣ, ᨶᩥᩅᨲ᩠ᨲᩥᨲ᩠ᩅᩣ ᩅᩥᩃᩮᩣᨠᩥᨲᩮ;

ᨲᨴᩣᨸᩥ ᨸᨳᩅᩦ ᨠᨾ᩠ᨸᩥ, ᩈᩥᨶᩮᩁᩩᩅᨶᩅᨭᩴᩈᨠᩣ.

‘‘ᨧᨲᩩᩅᩣᩉᩥᩴ ᩁᨳᩴ ᨴᨲ᩠ᩅᩣ, ᨮᨲ᩠ᩅᩣ ᨧᩣᨲᩩᨾ᩠ᨾᩉᩣᨸᨳᩮ;

ᩑᨠᩣᨠᩥᨿᩮᩣ ᩋᨴᩩᨲᩥᨿᩮᩣ, ᨾᨴ᩠ᨴᩥᨴᩮᩅᩥᩴ ᩍᨴᨾᨻᩕᩅᩥᩴ.

‘‘‘ᨲ᩠ᩅᩴ ᨾᨴ᩠ᨴᩥ ᨠᨱ᩠ᩉᩴ ᨣᨱ᩠ᩉᩣᩉᩥ, ᩃᩉᩩᨠᩣ ᩑᩈᩣ ᨠᨶᩥᨭ᩠ᨮᩥᨠᩣ;

ᩋᩉᩴ ᨩᩣᩃᩥᩴ ᨣᩉᩮᩔᩣᨾᩥ, ᨣᩁᩩᨠᩮᩣ ᨽᩣᨲᩥᨠᩮᩣ ᩉᩥ ᩈᩮᩣ’.

‘‘ᨸᨴᩩᨾᩴ ¶ ᨸᩩᨱ᩠ᨯᩁᩦᨠᩴᩅ, ᨾᨴ᩠ᨴᩦ ᨠᨱ᩠ᩉᩣᨩᩥᨶᨣ᩠ᨣᩉᩦ;

ᩋᩉᩴ ᩈᩩᩅᨱ᩠ᨱᨻᩥᨾ᩠ᨻᩴᩅ, ᨩᩣᩃᩥᩴ ᨡᨲ᩠ᨲᩥᨿᨾᨣ᩠ᨣᩉᩥᩴ.

‘‘ᩋᨽᩥᨩᩣᨲᩣ ᩈᩩᨡᩩᨾᩣᩃᩣ, ᨡᨲ᩠ᨲᩥᨿᩣ ᨧᨲᩩᩁᩮᩣ ᨩᨶᩣ;

ᩅᩥᩈᨾᩴ ᩈᨾᩴ ᩋᨠ᩠ᨠᨾᨶ᩠ᨲᩣ, ᩅᨦ᩠ᨠᩴ ᨣᨧ᩠ᨨᩣᨾ ᨸᨻ᩠ᨻᨲᩴ.

‘‘ᨿᩮ ᨠᩮᨧᩥ ᨾᨶᩩᨩᩣ ᩑᨶ᩠ᨲᩥ, ᩋᨶᩩᨾᨣ᩠ᨣᩮ ᨸᨭᩥᨸ᩠ᨸᨳᩮ;

ᨾᨣ᩠ᨣᨶ᩠ᨲᩮ ᨸᨭᩥᨸᩩᨧ᩠ᨨᩣᨾ, ‘ᨠᩩᩉᩥᩴ ᩅᨦ᩠ᨠᨶ᩠ᨲ [ᩅᨦ᩠ᨠᨲ (ᩈᩦ.)] ᨸᨻ᩠ᨻᨲᩮᩣ’.

‘‘ᨲᩮ ᨲᨲ᩠ᨳ ᩋᨾ᩠ᩉᩮ ᨸᩔᩥᨲ᩠ᩅᩣ, ᨠᩁᩩᨱᩴ ᨣᩥᩁᨾᩩᨴᩦᩁᨿᩩᩴ;

ᨴᩩᨠ᩠ᨡᩴ ᨲᩮ ᨸᨭᩥᩅᩮᨴᩮᨶ᩠ᨲᩥ, ᨴᩪᩁᩮ ᩅᨦ᩠ᨠᨶ᩠ᨲᨸᨻ᩠ᨻᨲᩮᩣ.

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

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

‘‘ᩁᩮᩣᨴᨶ᩠ᨲᩮ ᨴᩣᩁᨠᩮ ᨴᩥᩈ᩠ᩅᩣ, ᩏᨻ᩠ᨻᩥᨴ᩠ᨵᩣ [ᩏᨻ᩠ᨻᩥᨣ᩠ᨣᩣ (ᩈ᩠ᨿᩣ. ᨠᩴ.)] ᩅᩥᨸᩩᩃᩣ ᨴᩩᨾᩣ;

ᩈᨿᨾᩮᩅᩮᩣᨱᨾᩥᨲ᩠ᩅᩣᨶ, ᩏᨸᨣᨧ᩠ᨨᨶ᩠ᨲᩥ ᨴᩣᩁᨠᩮ.

‘‘ᩍᨴᩴ ¶ ᩋᨧ᩠ᨨᩁᩥᨿᩴ ᨴᩥᩈ᩠ᩅᩣ, ᩋᨻ᩠ᨽᩩᨲᩴ ᩃᩮᩣᨾᩉᩴᩈᨶᩴ;

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

‘‘ᩋᨧ᩠ᨨᩮᩁᩴ ᩅᨲ ᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ, ᩋᨻ᩠ᨽᩩᨲᩴ ᩃᩮᩣᨾᩉᩴᩈᨶᩴ;

ᩅᩮᩔᨶ᩠ᨲᩁᩔ ᨲᩮᨩᩮᨶ, ᩈᨿᨾᩮᩅᩮᩣᨱᨲᩣ ᨴᩩᨾᩣ.

‘‘ᩈᨦ᩠ᨡᩥᨸᩥᩴᩈᩩ ᨸᨳᩴ ᨿᨠ᩠ᨡᩣ, ᩋᨶᩩᨠᨾ᩠ᨸᩣᨿ ᨴᩣᩁᨠᩮ;

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

‘‘ᩈᨭ᩠ᨮᩥᩁᩣᨩᩈᩉᩔᩣᨶᩥ, ᨲᨴᩣ ᩅᩈᨶ᩠ᨲᩥ ᨾᩣᨲᩩᩃᩮ;

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

‘‘ᨲᨲ᩠ᨳ ᩅᨲ᩠ᨲᩮᨲ᩠ᩅᩣ ᩈᩃ᩠ᩃᩣᨸᩴ, ᨧᩮᨲᩮᩉᩥ ᨧᩮᨲᨸᩩᨲ᩠ᨲᩮᩉᩥ;

ᨲᩮ ᨲᨲᩮᩣ ᨶᩥᨠ᩠ᨡᨾᩥᨲ᩠ᩅᩣᨶ, ᩅᨦ᩠ᨠᩴ ᩋᨣᨾᩩ ᨸᨻ᩠ᨻᨲᩴ.

‘‘ᩌᨾᨶ᩠ᨲᨿᩥᨲ᩠ᩅᩣ ¶ ᨴᩮᩅᩥᨶ᩠ᨴᩮᩣ, ᩅᩥᩔᨠᨾ᩠ᨾᩴ [ᩅᩥᩈᩩᨠᨾ᩠ᨾᩴ (ᨠ.)] ᨾᩉᩥᨴ᩠ᨵᩥᨠᩴ;

ᩋᩔᨾᩴ ᩈᩩᨠᨲᩴ ᩁᨾ᩠ᨾᩴ, ᨸᨱ᩠ᨱᩈᩣᩃᩴ ᩈᩩᨾᩣᨸᨿ.

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

ᩋᩔᨾᩴ ¶ ᩈᩩᨠᨲᩴ ᩁᨾ᩠ᨾᩴ, ᨸᨱ᩠ᨱᩈᩣᩃᩴ ᩈᩩᨾᩣᨸᨿᩥ.

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

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

‘‘ᩋᩉᨬ᩠ᨧ ᨾᨴ᩠ᨴᩥᨴᩮᩅᩦ ᨧ, ᨩᩣᩃᩦ ᨠᨱ᩠ᩉᩣᨩᩥᨶᩣ ᨧᩩᨽᩮᩣ;

ᩋᨬ᩠ᨬᨾᨬ᩠ᨬᩴ ᩈᩮᩣᨠᨶᩩᨴᩣ, ᩅᩈᩣᨾ ᩋᩔᨾᩮ ᨲᨴᩣ.

‘‘ᨴᩣᩁᨠᩮ ᩋᨶᩩᩁᨠ᩠ᨡᨶ᩠ᨲᩮᩣ, ᩋᩈᩩᨬ᩠ᨬᩮᩣ ᩉᩮᩣᨾᩥ ᩋᩔᨾᩮ;

ᨾᨴ᩠ᨴᩦ ᨹᩃᩴ ᩌᩉᩁᩥᨲ᩠ᩅᩣ, ᨸᩮᩣᩈᩮᨲᩥ ᩈᩣ ᨲᨿᩮᩣ ᨩᨶᩮ.

‘‘ᨸᩅᨶᩮ ¶ ᩅᩈᨾᩣᨶᩔ, ᩋᨴ᩠ᨵᩥᨠᩮᩣ ᨾᩴ ᩏᨸᩣᨣᨾᩥ;

ᩌᨿᩣᨧᩥ ᨸᩩᨲ᩠ᨲᨠᩮ ᨾᨿ᩠ᩉᩴ, ᨩᩣᩃᩥᩴ ᨠᨱ᩠ᩉᩣᨩᩥᨶᩴ ᨧᩩᨽᩮᩣ.

‘‘ᨿᩣᨧᨠᩴ ᩏᨸᨣᨲᩴ ᨴᩥᩈ᩠ᩅᩣ, ᩉᩣᩈᩮᩣ ᨾᩮ ᩏᨸᨸᨩ᩠ᨩᨳ;

ᩏᨽᩮᩣ ᨸᩩᨲ᩠ᨲᩮ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᩋᨴᩣᩈᩥᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩮ ᨲᨴᩣ.

‘‘ᩈᨠᩮ ᨸᩩᨲ᩠ᨲᩮ ᨧᨩᨶ᩠ᨲᩔ, ᨩᩪᨩᨠᩮ ᨻᩕᩣᩉ᩠ᨾᨱᩮ ᨿᨴᩣ;

ᨲᨴᩣᨸᩥ ᨸᨳᩅᩦ ᨠᨾ᩠ᨸᩥ, ᩈᩥᨶᩮᩁᩩᩅᨶᩅᨭᩴᩈᨠᩣ.

‘‘ᨸᩩᨶᨴᩮᩅ ᩈᨠ᩠ᨠᩮᩣ ᩒᩁᩩᨿ᩠ᩉ, ᩉᩩᨲ᩠ᩅᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩈᨶ᩠ᨶᩥᨽᩮᩣ;

ᩌᨿᩣᨧᩥ ᨾᩴ ᨾᨴ᩠ᨴᩥᨴᩮᩅᩥᩴ, ᩈᩦᩃᩅᨶ᩠ᨲᩥᩴ ᨸᨲᩥᨻ᩠ᨻᨲᩴ.

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

ᨸᩈᨶ᩠ᨶᨾᨶᩈᨦ᩠ᨠᨸ᩠ᨸᩮᩣ, ᨲᩔ ᨾᨴ᩠ᨴᩥᩴ ᩋᨴᩣᩈᩉᩴ.

‘‘ᨾᨴ᩠ᨴᩥᨿᩣ ᨴᩦᨿᨾᩣᨶᩣᨿ, ᨣᨣᨶᩮ ᨴᩮᩅᩣ ᨸᨾᩮᩣᨴᩥᨲᩣ;

ᨲᨴᩣᨸᩥ ᨸᨳᩅᩦ ᨠᨾ᩠ᨸᩥ, ᩈᩥᨶᩮᩁᩩᩅᨶᩅᨭᩴᩈᨠᩣ.

‘‘ᨩᩣᩃᩥᩴ ᨠᨱ᩠ᩉᩣᨩᩥᨶᩴ ᨵᩦᨲᩴ, ᨾᨴ᩠ᨴᩥᨴᩮᩅᩥᩴ ᨸᨲᩥᨻ᩠ᨻᨲᩴ;

ᨧᨩᨾᩣᨶᩮᩣ ᨶ ᨧᩥᨶ᩠ᨲᩮᩈᩥᩴ, ᨻᩮᩣᨵᩥᨿᩣᨿᩮᩅ ᨠᩣᩁᨱᩣ.

‘‘ᨶ ᨾᩮ ᨴᩮᩔᩣ ᩏᨽᩮᩣ ᨸᩩᨲ᩠ᨲᩣ, ᨾᨴ᩠ᨴᩥᨴᩮᩅᩦ ᨶ ᨴᩮᩔᩥᨿᩣ;

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

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

ᨠᩁᩩᨱᩴ ᨸᩁᩥᨴᩮᩅᨶ᩠ᨲᩮ, ᩈᩃ᩠ᩃᨸᨶ᩠ᨲᩮ ᩈᩩᨡᩴ ᨴᩩᨡᩴ.

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

ᨲᨴᩣᨸᩥ ᨸᨳᩅᩦ ᨠᨾ᩠ᨸᩥ, ᩈᩥᨶᩮᩁᩩᩅᨶᩅᨭᩴᩈᨠᩣ.

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

ᨸᩅᩥᩈᩣᨾᩥ ᨸᩩᩁᩴ ᩁᨾ᩠ᨾᩴ, ᨩᩮᨲᩩᨲ᩠ᨲᩁᩴ ᨸᩩᩁᩩᨲ᩠ᨲᨾᩴ.

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

ᨲᨴᩣᨸᩥ ᨸᨳᩅᩦ ᨠᨾ᩠ᨸᩥ, ᩈᩥᨶᩮᩁᩩᩅᨶᩅᨭᩴᩈᨠᩣ.

‘‘ᩋᨧᩮᨲᨶᩣᨿᩴ ᨸᨳᩅᩦ, ᩋᩅᩥᨬ᩠ᨬᩣᨿ ᩈᩩᨡᩴ ᨴᩩᨡᩴ;

ᩈᩣᨸᩥ ᨴᩣᨶᨻᩃᩣ ᨾᨿ᩠ᩉᩴ, ᩈᨲ᩠ᨲᨠ᩠ᨡᨲ᩠ᨲᩩᩴ ᨸᨠᨾ᩠ᨸᨳᩣ’’ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᩈᩈᨠᩮᩣ ᨸᩅᨶᨧᩣᩁᨠᩮᩣ;

ᨲᩥᨱᨸᨱ᩠ᨱᩈᩣᨠᨹᩃᨽᨠ᩠ᨡᩮᩣ, ᨸᩁᩉᩮᨮᨶᩅᩥᩅᨩ᩠ᨩᩥᨲᩮᩣ.

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

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

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

‘ᨸᩣᨸᩣᨶᩥ ᨸᩁᩥᩅᨩ᩠ᨩᩮᨳ, ᨠᩃ᩠ᨿᩣᨱᩮ ᩋᨽᩥᨶᩥᩅᩥᩔᨳ’.

‘‘ᩏᨸᩮᩣᩈᨳᨾ᩠ᩉᩥ ᨴᩥᩅᩈᩮ, ᨧᨶ᩠ᨴᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᨸᩪᩁᩥᨲᩴ;

ᩑᨲᩮᩈᩴ ᨲᨲ᩠ᨳ ᩌᨧᩥᨠ᩠ᨡᩥᩴ, ᨴᩥᩅᩈᩮᩣ ᩋᨩ᩠ᨩᩩᨸᩮᩣᩈᨳᩮᩣ.

‘‘ᨴᩣᨶᩣᨶᩥ ᨸᨭᩥᨿᩣᨴᩮᨳ, ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩔ ᨴᩣᨲᩅᩮ;

ᨴᨲ᩠ᩅᩣ ᨴᩣᨶᩴ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩮ, ᩏᨸᩅᩔᨳᩩᨸᩮᩣᩈᨳᩴ.

‘‘ᨲᩮ ¶ ᨾᩮ ᩈᩣᨵᩪᨲᩥ ᩅᨲ᩠ᩅᩣᨶ, ᨿᨳᩣᩈᨲ᩠ᨲᩥ ᨿᨳᩣᨻᩃᩴ;

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

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

‘ᨿᨴᩥᩉᩴ ᩃᨽᩮ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩴ, ᨠᩥᩴ ᨾᩮ ᨴᩣᨶᩴ ᨽᩅᩥᩔᨲᩥ.

‘‘‘ᨶ ¶ ᨾᩮ ᩋᨲ᩠ᨳᩥ ᨲᩥᩃᩣ ᨾᩩᨣ᩠ᨣᩣ, ᨾᩣᩈᩣ ᩅᩣ ᨲᨱ᩠ᨯᩩᩃᩣ ᨥᨲᩴ;

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

‘‘‘ᨿᨴᩥ ¶ ᨠᩮᩣᨧᩥ ᩑᨲᩥ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩮᩣ, ᨽᩥᨠ᩠ᨡᩣᨿ ᨾᨾ ᩈᨶ᩠ᨲᩥᨠᩮ;

ᨴᨩ᩠ᨩᩣᩉᩴ ᩈᨠᨾᨲ᩠ᨲᩣᨶᩴ, ᨶ ᩈᩮᩣ ᨲᩩᨧ᩠ᨨᩮᩣ ᨣᨾᩥᩔᨲᩥ’.

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

ᩌᩈᨿᩴ ᨾᩮ ᩏᨸᩣᨣᨧ᩠ᨨᩥ, ᨴᩣᨶᩅᩦᨾᩴᩈᨶᩣᨿ ᨾᩮ.

‘‘ᨲᨾᩉᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᩈᨶ᩠ᨲᩩᨭ᩠ᨮᩮᩣ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥᩴ;

‘ᩈᩣᨵᩩ ᨡᩮᩣᩈᩥ ᩋᨶᩩᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᨥᩣᩈᩉᩮᨲᩩ ᨾᨾᨶ᩠ᨲᩥᨠᩮ.

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

ᨲᩩᩅᩴ ᩈᩦᩃᨣᩩᨱᩪᨸᩮᨲᩮᩣ, ᩋᨿᩩᨲ᩠ᨲᩴ ᨲᩮ ᨸᩁᩉᩮᨮᨶᩴ.

‘‘‘ᩑᩉᩥ ᩋᨣ᩠ᨣᩥᩴ ᨸᨴᩦᨸᩮᩉᩥ, ᨶᩣᨶᩣᨠᨭ᩠ᨮᩮ ᩈᨾᩣᨶᨿ;

ᩋᩉᩴ ᨸᨧᩥᩔᨾᨲ᩠ᨲᩣᨶᩴ, ᨸᨠ᩠ᨠᩴ ᨲ᩠ᩅᩴ ᨽᨠ᩠ᨡᨿᩥᩔᩈᩥ’.

‘‘‘ᩈᩣᨵᩪ’ᨲᩥ ᩈᩮᩣ ᩉᨭ᩠ᨮᨾᨶᩮᩣ, ᨶᩣᨶᩣᨠᨭ᩠ᨮᩮ ᩈᨾᩣᨶᨿᩥ;

ᨾᩉᨶ᩠ᨲᩴ ᩋᨠᩣᩈᩥ ᨧᩥᨲᨠᩴ, ᨠᨲ᩠ᩅᩣ ᩋᨦ᩠ᨣᩣᩁᨣᨻ᩠ᨽᨠᩴ.

‘‘ᩋᨣ᩠ᨣᩥᩴ ᨲᨲ᩠ᨳ ᨸᨴᩦᨸᩮᩈᩥ, ᨿᨳᩣ ᩈᩮᩣ ᨡᩥᨸ᩠ᨸᩴ ᨾᩉᩣ ᨽᩅᩮ;

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

‘‘ᨿᨴᩣ ¶ ᨾᩉᩣᨠᨭ᩠ᨮᨸᩩᨬ᩠ᨩᩮᩣ, ᩌᨴᩥᨲ᩠ᨲᩮᩣ ᨵᨾᨵᨾᩣᨿᨲᩥ [ᨵᩩᨾᨵᩩᨾᩣᨿᨲᩥ (ᩈᩦ.), ᨵᨾᨾᩣᨿᨲᩥ (ᨠ.)];

ᨲᨴᩩᨸ᩠ᨸᨲᩥᨲ᩠ᩅᩣ ᨸᨸᨲᩥᩴ, ᨾᨩ᩠ᨫᩮ ᨩᩣᩃᩈᩥᨡᨶ᩠ᨲᩁᩮ.

‘‘ᨿᨳᩣ ¶ ᩈᩦᨲᩮᩣᨴᨠᩴ ᨶᩣᨾ, ᨸᩅᩥᨭ᩠ᨮᩴ ᨿᩔ ᨠᩔᨧᩥ;

ᩈᨾᩮᨲᩥ ᨴᩁᨳᨸᩁᩥᩊᩣᩉᩴ, ᩋᩔᩣᨴᩴ ᨴᩮᨲᩥ ᨸᩦᨲᩥ ᨧ.

‘‘ᨲᨳᩮᩅ ᨩᩃᩥᨲᩴ ᩋᨣ᩠ᨣᩥᩴ, ᨸᩅᩥᨭ᩠ᨮᩔ ᨾᨾᩴ ᨲᨴᩣ;

ᩈᨻ᩠ᨻᩴ ᩈᨾᩮᨲᩥ ᨴᩁᨳᩴ, ᨿᨳᩣ ᩈᩦᨲᩮᩣᨴᨠᩴ ᩅᩥᨿ.

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

ᨠᩮᩅᩃᩴ ᩈᨠᩃᩴ ᨠᩣᨿᩴ, ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᩋᨴᩣᩈᩉ’’ᨶ᩠ᨲᩥ.

ᩋᨠᩥᨲ᩠ᨲᩥᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ¶ ᩈᨦ᩠ᨡᩮᩣ, ᨠᩩᩁᩩᩁᩣᨩᩣ ᨵᨶᨬ᩠ᨧᨿᩮᩣ;

ᨾᩉᩣᩈᩩᨴᩔᨶᩮᩣ ᩁᩣᨩᩣ, ᨾᩉᩣᨣᩮᩣᩅᩥᨶ᩠ᨴᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

ᨶᩥᨾᩥ ᨧᨶ᩠ᨴᨠᩩᨾᩣᩁᩮᩣ ᨧ, ᩈᩥᩅᩥ ᩅᩮᩔᨶ᩠ᨲᩁᩮᩣ ᩈᩈᩮᩣ;

ᩋᩉᨾᩮᩅ ᨲᨴᩣ ᩌᩈᩥᩴ, ᨿᩮᩣ ᨲᩮ ᨴᩣᨶᩅᩁᩮ ᩋᨴᩣ.

ᩑᨲᩮ ᨴᩣᨶᨸᩁᩥᨠ᩠ᨡᩣᩁᩣ, ᩑᨲᩮ ᨴᩣᨶᩔ ᨸᩣᩁᨾᩦ;

ᨩᩦᩅᩥᨲᩴ ᨿᩣᨧᨠᩮ ᨴᨲ᩠ᩅᩣ, ᩍᨾᩴ ᨸᩣᩁᨾᩥ ᨸᩪᩁᨿᩥᩴ.

ᨽᩥᨠ᩠ᨡᩣᨿ ᩏᨸᨣᨲᩴ ᨴᩥᩈ᩠ᩅᩣ, ᩈᨠᨲ᩠ᨲᩣᨶᩴ ᨸᩁᩥᨧ᩠ᨧᨩᩥᩴ;

ᨴᩣᨶᩮᨶ ᨾᩮ ᩈᨾᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩑᩈᩣ ᨾᩮ ᨴᩣᨶᨸᩣᩁᨾᩦᨲᩥ.

ᨴᩣᨶᨸᩣᩁᨾᩥᨶᩥᨴ᩠ᨴᩮᩈᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

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

ᨶ ᨲᨴᩣ ᩋᨲ᩠ᨳᩥ ᨾᩉᩥᨿᩣ, ᨣᩩᨱᩮᨶ ᨾᨾ ᩈᩣᨴᩥᩈᩮᩣ.

‘‘ᨸᩅᨶᩮ ᨴᩥᩈ᩠ᩅᩣ ᩅᨶᨧᩁᩮᩣ, ᩁᨬ᩠ᨬᩮᩣ ᨾᩴ ᨸᨭᩥᩅᩮᨴᨿᩥ;

‘ᨲᩅᩣᨶᩩᨧ᩠ᨨᩅᩮᩣ ᨾᩉᩣᩁᩣᨩ, ᨣᨩᩮᩣ ᩅᩈᨲᩥ ᨠᩣᨶᨶᩮ.

‘‘‘ᨶ ᨲᩔ ᨸᩁᩥᨠ᩠ᨡᩣᨿᨲ᩠ᨳᩮᩣ, ᨶᨸᩥ ᩌᩊᨠᨠᩣᩈᩩᨿᩣ;

ᩈᩉ ᨣᩉᩥᨲᩮ [ᩈᨾᩴ ᨣᩉᩥᨲᩮ (ᩈᩦ.)] ᩈᩮᩣᨱ᩠ᨯᩣᨿ, ᩈᨿᨾᩮᩅ ᩍᨵᩮᩉᩥ’ᨲᩥ.

‘‘ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩁᩣᨩᩣᨸᩥ ᨲᩩᨭ᩠ᨮᨾᩣᨶᩈᩮᩣ;

ᨸᩮᩈᩮᩈᩥ ᩉᨲ᩠ᨳᩥᨴᨾᨠᩴ, ᨨᩮᨠᩣᨧᩁᩥᨿᩴ ᩈᩩᩈᩥᨠ᩠ᨡᩥᨲᩴ.

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

ᨽᩥᩈᨾᩩᩊᩣᩃᩴ [ᨽᩥᩈᨾᩪᩃᩴ (ᨠ.)] ᩏᨴ᩠ᨵᩁᨶ᩠ᨲᩴ, ᨿᩣᨸᨶᨲ᩠ᨳᩣᨿ ᨾᩣᨲᩩᨿᩣ.

‘‘ᩅᩥᨬ᩠ᨬᩣᨿ ᨾᩮ ᩈᩦᩃᨣᩩᨱᩴ, ᩃᨠ᩠ᨡᨱᩴ ᩏᨸᨵᩣᩁᨿᩥ;

‘ᩑᩉᩥ ᨸᩩᨲ᩠ᨲᩣ’ᨲᩥ ᨸᨲ᩠ᩅᩣᨶ, ᨾᨾ ᩈᩮᩣᨱ᩠ᨯᩣᨿ ᩋᨣ᩠ᨣᩉᩥ.

‘‘ᨿᩴ ᨾᩮ ᨲᨴᩣ ᨸᩣᨠᨲᩥᨠᩴ, ᩈᩁᩦᩁᩣᨶᩩᨣᨲᩴ ᨻᩃᩴ;

ᩋᨩ᩠ᨩ ᨶᩣᨣᩈᩉᩔᩣᨶᩴ, ᨻᩃᩮᨶ ᩈᨾᩈᩣᨴᩥᩈᩴ.

‘‘ᨿᨴᩥᩉᩴ ᨲᩮᩈᩴ ᨸᨠᩩᨸ᩠ᨸᩮᨿ᩠ᨿᩴ, ᩏᨸᩮᨲᩣᨶᩴ ᨣᩉᨱᩣᨿ ᨾᩴ;

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

‘‘ᩋᨸᩥ ¶ ᨧᩣᩉᩴ ᩈᩦᩃᩁᨠ᩠ᨡᩣᨿ, ᩈᩦᩃᨸᩣᩁᨾᩥᨸᩪᩁᩥᨿᩣ;

ᨶ ᨠᩁᩮᩣᨾᩥ ᨧᩥᨲ᩠ᨲᩮ ᩋᨬ᩠ᨬᨳᨲ᩠ᨲᩴ, ᨸᨠ᩠ᨡᩥᨸᨶ᩠ᨲᩴ ᨾᨾᩣᩊᨠᩮ.

‘‘ᨿᨴᩥ ᨲᩮ ᨾᩴ ᨲᨲ᩠ᨳ ᨠᩮᩣᨭ᩠ᨭᩮᨿ᩠ᨿᩩᩴ, ᨹᩁᩈᩪᩉᩥ ᨲᩮᩣᨾᩁᩮᩉᩥ ᨧ;

ᨶᩮᩅ ᨲᩮᩈᩴ ᨸᨠᩩᨸ᩠ᨸᩮᨿ᩠ᨿᩴ, ᩈᩦᩃᨡᨱ᩠ᨯᨽᨿᩣ ᨾᨾᩣ’’ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ¶ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᩣ ᨾᩉᩥᨴ᩠ᨵᩥᨠᩮᩣ;

ᩅᩥᩁᩪᨸᨠ᩠ᨡᩮᨶ ᨾᩉᩣᩁᨬ᩠ᨬᩣ, ᨴᩮᩅᩃᩮᩣᨠᨾᨣᨬ᩠ᨨᩉᩴ.

‘‘ᨲᨲ᩠ᨳ ᨸᩔᩥᨲ᩠ᩅᩣᩉᩴ ᨴᩮᩅᩮ, ᩑᨠᨶ᩠ᨲᩴ ᩈᩩᨡᩈᨾᨸ᩠ᨸᩥᨲᩮ;

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

‘‘ᩈᩁᩦᩁᨠᩥᨧ᩠ᨧᩴ ᨠᨲ᩠ᩅᩣᨶ, ᨽᩩᨲ᩠ᩅᩣ ᨿᩣᨸᨶᨾᨲ᩠ᨲᨠᩴ;

ᨧᨲᩩᩁᩮᩣ ᩋᨦ᩠ᨣᩮ ᩋᨵᩥᨭ᩠ᨮᩣᨿ, ᩈᩮᨾᩥ ᩅᨾ᩠ᨾᩥᨠᨾᩩᨴ᩠ᨵᨶᩥ.

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

ᨿᩔ ᩑᨲᩮᨶ ᨠᩁᨱᩦᨿᩴ, ᨴᩥᨶ᩠ᨶᩴᨿᩮᩅ ᩉᩁᩣᨲᩩ ᩈᩮᩣ.

‘‘ᩈᩴᩈᩥᨲᩮᩣ ᩋᨠᨲᨬ᩠ᨬᩩᨶᩣ, ᩌᩃᨾ᩠ᨸᩣᨿᨶᩮᩣ [ᩌᩃᨾ᩠ᨻᨱᩮᩣ (ᩈᩦ.)] ᨾᨾᨣ᩠ᨣᩉᩥ;

ᨸᩮᩊᩣᨿ ᨸᨠ᩠ᨡᩥᨸᩥᨲ᩠ᩅᩣᨶ, ᨠᩦᩊᩮᨲᩥ ᨾᩴ ᨲᩉᩥᩴ ᨲᩉᩥᩴ.

‘‘ᨸᩮᩊᩣᨿ ᨸᨠ᩠ᨡᩥᨸᨶ᩠ᨲᩮᨸᩥ, ᩈᨾ᩠ᨾᨴ᩠ᨴᨶ᩠ᨲᩮᨸᩥ ᨸᩣᨱᩥᨶᩣ;

ᩌᩃᨾ᩠ᨸᩣᨿᨶᩮ [ᩌᩃᨾ᩠ᨻᨱᩮ (ᩈᩦ.)] ᨶ ᨠᩩᨸ᩠ᨸᩣᨾᩥ, ᩈᩦᩃᨡᨱ᩠ᨯᨽᨿᩣ ᨾᨾ.

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

ᩈᩦᩃᩅᩦᨲᩥᨠ᩠ᨠᨾᩮᩣ ᨾᨿ᩠ᩉᩴ, ᨸᨳᩅᩦᩏᨸ᩠ᨸᨲᨶᩴ ᩅᩥᨿ.

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

ᨶᩮᩅ ᩈᩦᩃᩴ ᨸᨽᩥᨶ᩠ᨴᩮᨿ᩠ᨿᩴ, ᨧᨲᩩᨴ᩠ᨴᩦᨸᩣᨶ ᩉᩮᨲᩩᨸᩥ.

‘‘ᩋᨸᩥ ᨧᩣᩉᩴ ᩈᩦᩃᩁᨠ᩠ᨡᩣᨿ, ᩈᩦᩃᨸᩣᩁᨾᩥᨸᩪᩁᩥᨿᩣ;

ᨶ ᨠᩁᩮᩣᨾᩥ ᨧᩥᨲ᩠ᨲᩮ ᩋᨬ᩠ᨬᨳᨲ᩠ᨲᩴ, ᨸᨠ᩠ᨡᩥᨸᨶ᩠ᨲᨾ᩠ᨸᩥ ᨸᩮᩊᨠᩮ’’ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨧᨾ᩠ᨸᩮᨿ᩠ᨿᨠᩮᩣ ᨾᩉᩥᨴ᩠ᨵᩥᨠᩮᩣ;

ᨲᨴᩣᨸᩥ ᨵᨾ᩠ᨾᩥᨠᩮᩣ ᩌᩈᩥᩴ, ᩈᩦᩃᨻ᩠ᨻᨲᩈᨾᨸ᩠ᨸᩥᨲᩮᩣ.

‘‘ᨲᨴᩣᨸᩥ ¶ ᨾᩴ ᨵᨾ᩠ᨾᨧᩣᩁᩥᩴ, ᩏᨸᩅᩩᨲ᩠ᨳᩴ ᩏᨸᩮᩣᩈᨳᩴ;

ᩋᩉᩥᨲᩩᨱ᩠ᨯᩥᨠᩮᩣ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᩁᩣᨩᨴ᩠ᩅᩣᩁᨾ᩠ᩉᩥ ᨠᩦᩊᨲᩥ.

‘‘ᨿᩴ ¶ ᨿᩴ ᩈᩮᩣ ᩅᨱ᩠ᨱᩴ ᨧᩥᨶ᩠ᨲᨿᩥ, ᨶᩦᩃᩴᩅ ᨸᩦᨲᩃᩮᩣᩉᩥᨲᩴ;

ᨲᩔ ᨧᩥᨲ᩠ᨲᩣᨶᩩᩅᨲ᩠ᨲᨶ᩠ᨲᩮᩣ, ᩉᩮᩣᨾᩥ ᨧᩥᨶ᩠ᨲᩥᨲᩈᨶ᩠ᨶᩥᨽᩮᩣ.

‘‘ᨳᩃᩴ ¶ ᨠᩁᩮᨿ᩠ᨿᨾᩩᨴᨠᩴ, ᩏᨴᨠᨾ᩠ᨸᩥ ᨳᩃᩴ ᨠᩁᩮ;

ᨿᨴᩥᩉᩴ ᨲᩔ ᨸᨠᩩᨸ᩠ᨸᩮᨿ᩠ᨿᩴ, ᨡᨱᩮᨶ ᨨᩣᩁᩥᨠᩴ ᨠᩁᩮ.

‘‘ᨿᨴᩥ ᨧᩥᨲ᩠ᨲᩅᩈᩦ ᩉᩮᩔᩴ, ᨸᩁᩥᩉᩣᨿᩥᩔᩣᨾᩥ ᩈᩦᩃᨲᩮᩣ;

ᩈᩦᩃᩮᨶ ᨸᩁᩥᩉᩦᨶᩔ, ᩏᨲ᩠ᨲᨾᨲ᩠ᨳᩮᩣ ᨶ ᩈᩥᨩ᩠ᨫᨲᩥ.

‘‘ᨠᩣᨾᩴ ¶ ᨽᩥᨩ᩠ᨩᨲᩩᨿᩴ ᨠᩣᨿᩮᩣ, ᩍᨵᩮᩅ ᩅᩥᨠᩥᩁᩦᨿᨲᩩ;

ᨶᩮᩅ ᩈᩦᩃᩴ ᨸᨽᩥᨶ᩠ᨴᩮᨿ᩠ᨿᩴ, ᩅᩥᨠᩥᩁᨶ᩠ᨲᩮ ᨽᩩᩈᩴ ᩅᩥᨿᩣ’’ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨧᩪᩊᨻᩮᩣᨵᩥ ᩈᩩᩈᩦᩃᩅᩣ;

ᨽᩅᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᨽᨿᨲᩮᩣ, ᨶᩮᨠ᩠ᨡᨾ᩠ᨾᩴ ᩋᨽᩥᨶᩥᨠ᩠ᨡᨾᩥᩴ.

‘‘ᨿᩣ ᨾᩮ ᨴᩩᨲᩥᨿᩥᨠᩣ ᩌᩈᩥ, ᨻᩕᩣᩉ᩠ᨾᨱᩦ ᨠᨶᨠᩈᨶ᩠ᨶᩥᨽᩣ;

ᩈᩣᨸᩥ ᩅᨭ᩠ᨭᩮ ᩋᨶᨸᩮᨠ᩠ᨡᩣ, ᨶᩮᨠ᩠ᨡᨾ᩠ᨾᩴ ᩋᨽᩥᨶᩥᨠ᩠ᨡᨾᩥ.

‘‘ᨶᩥᩁᩣᩃᨿᩣ ᨨᩥᨶ᩠ᨶᨻᨶ᩠ᨵᩪ, ᩋᨶᨸᩮᨠ᩠ᨡᩣ ᨠᩩᩃᩮ ᨣᨱᩮ;

ᨧᩁᨶ᩠ᨲᩣ ᨣᩣᨾᨶᩥᨣᨾᩴ, ᨻᩣᩁᩣᨱᩈᩥᨾᩩᨸᩣᨣᨾᩩᩴ.

‘‘ᨲᨲ᩠ᨳ ᩅᩈᩣᨾ ᨶᩥᨸᨠᩣ, ᩋᩈᩴᩈᨭ᩠ᨮᩣ ᨠᩩᩃᩮ ᨣᨱᩮ;

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

‘‘ᩏᨿ᩠ᨿᩣᨶᨴᩔᨶᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩁᩣᨩᩣ ᩋᨴ᩠ᨴᩈ ᨻᩕᩣᩉ᩠ᨾᨱᩥᩴ;

ᩏᨸᨣᨾ᩠ᨾ ᨾᨾᩴ ᨸᩩᨧ᩠ᨨᩥ, ‘ᨲᩩᨿ᩠ᩉᩮᩈᩣ ᨠᩣ ᨠᩔ ᨽᩁᩥᨿᩣ’.

‘‘ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩮ ᩋᩉᩴ ᨲᩔ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥᩴ;

‘ᨶ ᨾᨿ᩠ᩉᩴ ᨽᩁᩥᨿᩣ ᩑᩈᩣ, ᩈᩉᨵᨾ᩠ᨾᩣ ᩑᨠᩈᩣᩈᨶᩦ’.

‘‘ᨲᩥᩔᩣ ¶ [ᨲᩔᩣ (ᩈᩦ.)] ᩈᩣᩁᨲ᩠ᨲᨣᨵᩥᨲᩮᩣ, ᨣᩣᩉᩣᨸᩮᨲ᩠ᩅᩣᨶ ᨧᩮᨭᨠᩮ;

ᨶᩥᨸ᩠ᨸᩦᩊᨿᨶ᩠ᨲᩮᩣ ᨻᩃᩈᩣ, ᩋᨶ᩠ᨲᩮᨸᩩᩁᩴ ᨸᩅᩮᩈᨿᩥ.

‘‘ᩒᨴᨸᨲ᩠ᨲᨠᩥᨿᩣ ¶ ᨾᨿ᩠ᩉᩴ, ᩈᩉᨩᩣ ᩑᨠᩈᩣᩈᨶᩦ;

ᩌᨠᨯ᩠ᨰᩥᨲ᩠ᩅᩣ ᨶᨿᨶ᩠ᨲᩥᨿᩣ, ᨠᩮᩣᨸᩮᩣ ᨾᩮ ᩏᨸᨸᨩ᩠ᨩᨳ.

‘‘ᩈᩉ ¶ ᨠᩮᩣᨸᩮ ᩈᨾᩩᨸ᩠ᨸᨶ᩠ᨶᩮ, ᩈᩦᩃᨻ᩠ᨻᨲᨾᨶᩩᩔᩁᩥᩴ;

ᨲᨲ᩠ᨳᩮᩅ ᨠᩮᩣᨸᩴ ᨶᩥᨣ᩠ᨣᨱ᩠ᩉᩥᩴ, ᨶᩣᨴᩣᩈᩥᩴ ᩅᨯ᩠ᨰᩥᨲᩪᨸᩁᩥ.

‘‘ᨿᨴᩥ ᨶᩴ ᨻᩕᩣᩉ᩠ᨾᨱᩥᩴ ᨠᩮᩣᨧᩥ, ᨠᩮᩣᨭ᩠ᨭᩮᨿ᩠ᨿ ᨲᩥᨱ᩠ᩉᩈᨲ᩠ᨲᩥᨿᩣ;

ᨶᩮᩅ ᩈᩦᩃᩴ ᨸᨽᩥᨶ᩠ᨴᩮᨿ᩠ᨿᩴ, ᨻᩮᩣᨵᩥᨿᩣᨿᩮᩅ ᨠᩣᩁᨱᩣ.

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

ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩴ ᨸᩥᨿᩴ ᨾᨿ᩠ᩉᩴ, ᨲᩈ᩠ᨾᩣ ᩈᩦᩃᩣᨶᩩᩁᨠ᩠ᨡᩥᩈ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨾᩉᩥᩴᩈᩮᩣ ᨸᩅᨶᨧᩣᩁᨠᩮᩣ;

ᨸᩅᨯ᩠ᨰᨠᩣᨿᩮᩣ ᨻᩃᩅᩣ, ᨾᩉᨶ᩠ᨲᩮᩣ ᨽᩦᨾᨴᩔᨶᩮᩣ.

‘‘ᨸᨻ᩠ᨽᩣᩁᩮ ᨣᩥᩁᩥᨴᩩᨣ᩠ᨣᩮ [ᩅᨶᨴᩩᨣ᩠ᨣᩮ (ᩈᩦ.)] ᨧ, ᩁᩩᨠ᩠ᨡᨾᩪᩃᩮ ᨴᨠᩣᩈᨿᩮ;

ᩉᩮᩣᨲᩮᨲ᩠ᨳ ᨮᩣᨶᩴ ᨾᩉᩥᩴᩈᩣᨶᩴ, ᨠᩮᩣᨧᩥ ᨠᩮᩣᨧᩥ ᨲᩉᩥᩴ ᨲᩉᩥᩴ.

‘‘ᩅᩥᨧᩁᨶ᩠ᨲᩮᩣ ᨻᩕᩉᩣᩁᨬ᩠ᨬᩮ, ᨮᩣᨶᩴ ᩋᨴ᩠ᨴᩈ ᨽᨴ᩠ᨴᨠᩴ;

ᨲᩴ ᨮᩣᨶᩴ ᩏᨸᨣᨶ᩠ᨲ᩠ᩅᩣᨶ, ᨲᩥᨭ᩠ᨮᩣᨾᩥ ᨧ ᩈᨿᩣᨾᩥ ᨧ.

‘‘ᩋᨳᩮᨲ᩠ᨳ ᨠᨸᩥᨾᩣᨣᨶ᩠ᨲ᩠ᩅᩣ, ᨸᩣᨸᩮᩣ ᩋᨶᩁᩥᨿᩮᩣ ᩃᩉᩩ;

ᨡᨶ᩠ᨵᩮ ᨶᩃᩣᨭᩮ ᨽᨾᩩᨠᩮ, ᨾᩩᨲ᩠ᨲᩮᨲᩥ ᩒᩉᨶᩮᨲᩥᨲᩴ.

‘‘ᩈᨠᩥᨾ᩠ᨸᩥ ᨴᩥᩅᩈᩴ ᨴᩩᨲᩥᨿᩴ, ᨲᨲᩥᨿᩴ ᨧᨲᩩᨲ᩠ᨳᨾ᩠ᨸᩥ ᨧ;

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

‘‘ᨾᨾᩴ ¶ ᩏᨸᨴ᩠ᨴᩩᨲᩴ ᨴᩥᩈ᩠ᩅᩣ, ᨿᨠ᩠ᨡᩮᩣ ᨾᩴ ᩍᨴᨾᨻᩕᩅᩥ;

‘ᨶᩣᩈᩮᩉᩮᨲᩴ ᨨᩅᩴ ᨸᩣᨸᩴ, ᩈᩥᨦ᩠ᨣᩮᩉᩥ ᨧ ᨡᩩᩁᩮᩉᩥ ᨧ’.

‘‘ᩑᩅᩴ ¶ ᩅᩩᨲ᩠ᨲᩮ ᨲᨴᩣ ᨿᨠ᩠ᨡᩮ, ᩋᩉᩴ ᨲᩴ ᩍᨴᨾᨻᩕᩅᩥᩴ;

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

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

ᩈᩦᩃᨬ᩠ᨧ ᨾᩮ ᨸᨽᩥᨩ᩠ᨩᩮᨿ᩠ᨿ, ᩅᩥᨬ᩠ᨬᩪ ᨧ ᨣᩁᩉᩮᨿ᩠ᨿᩩ ᨾᩴ.

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

ᨠ᩠ᨿᩣᩉᩴ ᨩᩦᩅᩥᨲᩉᩮᨲᩪᨸᩥ, ᨠᩣᩉᩣᨾᩥᩴ ᨸᩁᩉᩮᨮᨶᩴ’.

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

ᨲᩮᩅ ᨲᩔ ᩅᨵᩥᩔᨶ᩠ᨲᩥ, ᩈᩣ ᨾᩮ ᨾᩩᨲ᩠ᨲᩥ ᨽᩅᩥᩔᨲᩥ.

‘‘ᩉᩦᨶᨾᨩ᩠ᨫᩥᨾᩏᨠ᩠ᨠᨭ᩠ᨮᩮ, ᩈᩉᨶ᩠ᨲᩮᩣ ᩋᩅᨾᩣᨶᩥᨲᩴ;

ᩑᩅᩴ ᩃᨽᨲᩥ ᩈᨸ᩠ᨸᨬ᩠ᨬᩮᩣ, ᨾᨶᩈᩣ ᨿᨳᩣ ᨸᨲ᩠ᨳᩥᨲ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᩈᩩᨲᨲ᩠ᨲᨠᨶᨠᩈᨶ᩠ᨶᩥᨽᩮᩣ;

ᨾᩥᨣᩁᩣᨩᩣ ᩁᩩᩁᩩᨶᩣᨾ, ᨸᩁᨾᩈᩦᩃᩈᨾᩣᩉᩥᨲᩮᩣ.

‘‘ᩁᨾ᩠ᨾᩮ ᨸᨴᩮᩈᩮ ᩁᨾᨱᩦᨿᩮ, ᩅᩥᩅᩥᨲ᩠ᨲᩮ ᩋᨾᨶᩩᩔᨠᩮ;

ᨲᨲ᩠ᨳ ᩅᩣᩈᩴ ᩏᨸᨣᨬ᩠ᨨᩥᩴ, ᨣᨦ᩠ᨣᩣᨠᩪᩃᩮ ᨾᨶᩮᩣᩁᨾᩮ.

‘‘ᩋᨳ ¶ ᩏᨸᩁᩥ ᨣᨦ᩠ᨣᩣᨿ, ᨵᨶᩥᨠᩮᩉᩥ ᨸᩁᩥᨸᩦᩊᩥᨲᩮᩣ;

ᨸᩩᩁᩥᩈᩮᩣ ᨣᨦ᩠ᨣᩣᨿ ᨸᨸᨲᩥ, ‘ᨩᩦᩅᩣᨾᩥ ᩅᩣ ᨾᩁᩣᨾᩥ ᩅᩣ’.

‘‘ᩁᨲ᩠ᨲᩥᨶ᩠ᨴᩥᩅᩴ ¶ ᩈᩮᩣ ᨣᨦ᩠ᨣᩣᨿ, ᩅᩩᨿ᩠ᩉᨾᩣᨶᩮᩣ ᨾᩉᩮᩣᨴᨠᩮ;

ᩁᩅᨶ᩠ᨲᩮᩣ ᨠᩁᩩᨱᩴ ᩁᩅᩴ, ᨾᨩ᩠ᨫᩮ ᨣᨦ᩠ᨣᩣᨿ ᨣᨧ᩠ᨨᨲᩥ.

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

ᨣᨦ᩠ᨣᩣᨿ ᨲᩦᩁᩮ ᨮᨲ᩠ᩅᩣᨶ, ᩋᨸᩩᨧ᩠ᨨᩥᩴ ‘ᨠᩮᩣᩈᩥ ᨲ᩠ᩅᩴ ᨶᩁᩮᩣ’.

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

‘ᨵᨶᩥᨠᩮᩉᩥ ᨽᩦᨲᩮᩣ ᨲᩈᩥᨲᩮᩣ, ᨸᨠ᩠ᨡᨶ᩠ᨴᩮᩣᩉᩴ ᨾᩉᩣᨶᨴᩥᩴ’.

‘‘ᨲᩔ ¶ ᨠᨲ᩠ᩅᩣᨶ ᨠᩣᩁᩩᨬ᩠ᨬᩴ, ᨧᨩᩥᨲ᩠ᩅᩣ ᨾᨾ ᨩᩦᩅᩥᨲᩴ;

ᨸᩅᩥᩈᩥᨲ᩠ᩅᩣ ᨶᩦᩉᩁᩥᩴ ᨲᩔ, ᩋᨶ᩠ᨵᨠᩣᩁᨾ᩠ᩉᩥ ᩁᨲ᩠ᨲᩥᨿᩣ.

‘‘ᩋᩔᨲ᩠ᨳᨠᩣᩃᨾᨬ᩠ᨬᩣᨿ, ᨲᩔᩣᩉᩴ ᩍᨴᨾᨻᩕᩅᩥᩴ;

‘ᩑᨠᩴ ᨲᩴ ᩅᩁᩴ ᨿᩣᨧᩣᨾᩥ, ᨾᩣ ᨾᩴ ᨠᩔᨧᩥ ᨸᩣᩅᨴ’.

‘‘ᨶᨣᩁᩴ ¶ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶ ᩌᨧᩥᨠ᩠ᨡᩥ, ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ ᨵᨶᩉᩮᨲᩩᨠᩮᩣ;

ᩁᩣᨩᩣᨶᩴ ᩈᩮᩣ ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᩏᨸᨣᨬ᩠ᨨᩥ ᨾᨾᨶ᩠ᨲᩥᨠᩴ.

‘‘ᨿᩣᩅᨲᩣ ᨠᩁᨱᩴ ᩈᨻ᩠ᨻᩴ, ᩁᨬ᩠ᨬᩮᩣ ᩌᩁᩮᩣᨧᩥᨲᩴ ᨾᨿᩣ;

ᩁᩣᨩᩣ ᩈᩩᨲ᩠ᩅᩣᨶ ᩅᨧᨶᩴ, ᩏᩈᩩᩴ ᨲᩔ ᨸᨠᨸ᩠ᨸᨿᩥ;

‘ᩍᨵᩮᩅ ᨥᩣᨲᨿᩥᩔᩣᨾᩥ, ᨾᩥᨲ᩠ᨲᨴᩩᨻ᩠ᨽᩥᩴ [ᨾᩥᨲ᩠ᨲᨴᩪᨽᩥᩴ (ᩈᩦ.)] ᩋᨶᩣᩁᩥᨿᩴ’.

‘‘ᨲᨾᩉᩴ ᩋᨶᩩᩁᨠ᩠ᨡᨶ᩠ᨲᩮᩣ, ᨶᩥᨾ᩠ᨾᩥᨶᩥᩴ ᨾᨾ ᩋᨲ᩠ᨲᨶᩣ;

‘ᨲᩥᨭ᩠ᨮᨲᩮᩈᩮᩣ ᨾᩉᩣᩁᩣᨩ, ᨠᩣᨾᨠᩣᩁᩮᩣ ᨽᩅᩣᨾᩥ ᨲᩮ’.

‘‘ᩋᨶᩩᩁᨠ᩠ᨡᩥᩴ ᨾᨾ ᩈᩦᩃᩴ, ᨶᩣᩁᨠ᩠ᨡᩥᩴ ᨾᨾ ᨩᩦᩅᩥᨲᩴ;

ᩈᩦᩃᩅᩣ ᩉᩥ ᨲᨴᩣ ᩌᩈᩥᩴ, ᨻᩮᩣᨵᩥᨿᩣᨿᩮᩅ ᨠᩣᩁᨱᩣ’’ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨩᨭᩥᩃᩮᩣ ᩏᨣ᩠ᨣᨲᩣᨸᨶᩮᩣ;

ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᨶᩣᨾ ᨶᩣᨾᩮᨶ, ᩈᩦᩃᩅᩣ ᩈᩩᩈᨾᩣᩉᩥᨲᩮᩣ.

‘‘ᩋᩉᨬ᩠ᨧ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᩑᨠᩮᩣ, ᨣᨦ᩠ᨣᩣᨠᩪᩃᩮ ᩅᩈᩣᨾᩩᨽᩮᩣ;

ᩋᩉᩴ ᩅᩈᩣᨾᩥ ᩏᨸᩁᩥ, ᩉᩮᨭ᩠ᨮᩣ ᩅᩈᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ.

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

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

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

ᩒᩃᩮᩣᨠᩮᨲ᩠ᩅᩣᨶᩉᩴ ᨲᩔ, ᨠᩁᩮᨿ᩠ᨿᩴ ᨨᩣᩁᩥᨠᩴ ᩅᩥᨿ.

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

ᨲᩔᩮᩅ ᨾᨲ᩠ᨳᨠᩮ ᨶᩥᨸᨲᩥ, ᨿᩮᩣᨣᩮᨶ ᨲᩴ ᨸᨾᩮᩣᨧᨿᩥᩴ.

‘‘ᩋᨶᩩᩁᨠ᩠ᨡᩥᩴ ¶ ᨾᨾ ᩈᩦᩃᩴ, ᨶᩣᩁᨠ᩠ᨡᩥᩴ ᨾᨾ ᨩᩦᩅᩥᨲᩴ;

ᩈᩦᩃᩅᩣ ᩉᩥ ᨲᨴᩣ ᩌᩈᩥᩴ, ᨻᩮᩣᨵᩥᨿᩣᨿᩮᩅ ᨠᩣᩁᨱᩣ’’ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨾᩉᩣᨸᨠ᩠ᨡᩮᩣ ᨾᩉᩥᨴ᩠ᨵᩥᨠᩮᩣ;

ᨵᨾ᩠ᨾᩮᩣ ᨶᩣᨾ ᨾᩉᩣᨿᨠ᩠ᨡᩮᩣ, ᩈᨻ᩠ᨻᩃᩮᩣᨠᩣᨶᩩᨠᨾ᩠ᨸᨠᩮᩣ.

‘‘ᨴᩈᨠᩩᩈᩃᨠᨾ᩠ᨾᨸᨳᩮ ¶ , ᩈᨾᩣᨴᨸᩮᨶ᩠ᨲᩮᩣ ᨾᩉᩣᨩᨶᩴ;

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

‘‘ᨸᩣᨸᩮᩣ ᨠᨴᩁᩥᨿᩮᩣ ᨿᨠ᩠ᨡᩮᩣ, ᨴᩦᨸᩮᨶ᩠ᨲᩮᩣ ᨴᩈ ᨸᩣᨸᨠᩮ;

ᩈᩮᩣᨸᩮᨲ᩠ᨳ ᨾᩉᩥᨿᩣ ᨧᩁᨲᩥ, ᩈᨾᩥᨲ᩠ᨲᩮᩣ ᩈᨸᩁᩥᨩ᩠ᨩᨶᩮᩣ.

‘‘ᨵᨾ᩠ᨾᩅᩣᨴᩦ ᩋᨵᨾ᩠ᨾᩮᩣ ᨧ, ᩏᨽᩮᩣ ᨸᨧ᩠ᨧᨶᩥᨠᩣ ᨾᨿᩴ;

ᨵᩩᩁᩮ ᨵᩩᩁᩴ ᨥᨭ᩠ᨭᨿᨶ᩠ᨲᩣ, ᩈᨾᩥᨾ᩠ᩉᩣ ᨸᨭᩥᨸᨳᩮ ᩏᨽᩮᩣ.

‘‘ᨠᩃᩉᩮᩣ ᩅᨲ᩠ᨲᨲᩦ ᨽᩮᩈ᩠ᨾᩣ, ᨠᩃ᩠ᨿᩣᨱᨸᩣᨸᨠᩔ ᨧ;

ᨾᨣ᩠ᨣᩣ ᩒᨠ᩠ᨠᨾᨶᨲ᩠ᨳᩣᨿ, ᨾᩉᩣᨿᩩᨴ᩠ᨵᩮᩣ ᩏᨸᨭ᩠ᨮᩥᨲᩮᩣ.

‘‘ᨿᨴᩥᩉᩴ ᨲᩔ ᨠᩩᨸ᩠ᨸᩮᨿ᩠ᨿᩴ, ᨿᨴᩥ ᨽᩥᨶ᩠ᨴᩮ ᨲᨸᩮᩣᨣᩩᨱᩴ;

‘‘ᩋᨸᩥᨧᩣᩉᩴ ᩈᩦᩃᩁᨠ᩠ᨡᩣᨿ, ᨶᩥᨻ᩠ᨻᩣᨸᩮᨲ᩠ᩅᩣᨶ ᨾᩣᨶᩈᩴ;

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

‘‘ᩈᩉ ᨸᨳᨲᩮᩣ ᩒᨠ᩠ᨠᨶ᩠ᨲᩮ, ᨠᨲ᩠ᩅᩣ ᨧᩥᨲ᩠ᨲᩔ ᨶᩥᨻ᩠ᨻᩩᨲᩥᩴ;

ᩅᩥᩅᩁᩴ ᩋᨴᩣᩈᩥ ᨸᨳᩅᩦ, ᨸᩣᨸᨿᨠ᩠ᨡᩔ ᨲᩣᩅᨴᩮ’’ᨲᩥ.

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

ᩁᩣᨩᩣ ᨩᨿᨴ᩠ᨴᩥᩈᩮᩣ ᨶᩣᨾ, ᩈᩦᩃᨣᩩᨱᨾᩩᨸᩣᨣᨲᩮᩣ.

‘‘ᨲᩔ ¶ ᩁᨬ᩠ᨬᩮᩣ ᩋᩉᩴ ᨸᩩᨲ᩠ᨲᩮᩣ, ᩈᩩᨲᨵᨾ᩠ᨾᩮᩣ ᩈᩩᩈᩦᩃᩅᩣ;

ᩋᩃᩦᨶᩈᨲ᩠ᨲᩮᩣ ᨣᩩᨱᩅᩣ, ᩋᨶᩩᩁᨠ᩠ᨡᨸᩁᩥᨩᨶᩮᩣ ᩈᨴᩣ.

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

ᩈᩮᩣ ᨾᩮ ᨸᩥᨲᩩᨾᨣ᩠ᨣᩉᩮᩈᩥ, ‘ᨽᨠ᩠ᨡᩮᩣᩈᩥ ᨾᨾ ᨾᩣ ᨧᩃᩥ’.

‘‘ᨲᩔ ¶ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᨽᩦᨲᩮᩣ ᨲᩈᩥᨲᩅᩮᨵᩥᨲᩮᩣ;

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

‘‘ᨾᩥᨣᩅᩴ ᨣᩉᩮᨲ᩠ᩅᩣ ᨾᩩᨬ᩠ᨧᩔᩩ, ᨠᨲ᩠ᩅᩣ ᩌᨣᨾᨶᩴ ᨸᩩᨶ;

ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨵᨶᩴ ᨴᨲ᩠ᩅᩣ, ᨸᩥᨲᩣ ᩌᨾᨶ᩠ᨲᨿᩦ ᨾᨾᩴ.

‘‘‘ᩁᨩ᩠ᨩᩴ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩ, ᨾᩣ ᨸᨾᨩ᩠ᨩᩥ ᨸᩩᩁᩴ ᩍᨴᩴ;

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

‘‘ᨾᩣᨲᩣᨸᩥᨲᩪ ᨧ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ, ᨶᩥᨾ᩠ᨾᩥᨶᩥᨲ᩠ᩅᩣᨶ ᩋᨲ᩠ᨲᨶᩣ;

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

‘‘ᩈᩈᨲ᩠ᨳᩉᨲ᩠ᨳᩪᨸᨣᨲᩴ, ᨠᨴᩣᨧᩥ ᩈᩮᩣ ᨲᩈᩥᩔᨲᩥ;

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

‘‘ᩈᩦᩃᨡᨱ᩠ᨯᨽᨿᩣ ᨾᨿ᩠ᩉᩴ, ᨲᩔ ᨴᩮᩔᩴ ᨶ ᨻ᩠ᨿᩣᩉᩁᩥᩴ;

ᨾᩮᨲ᩠ᨲᨧᩥᨲ᩠ᨲᩮᩣ ᩉᩥᨲᩅᩣᨴᩦ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥᩴ.

‘‘‘ᩏᨩ᩠ᨩᩣᩃᩮᩉᩥ ᨾᩉᩣᩋᨣ᩠ᨣᩥᩴ, ᨸᨸᨲᩥᩔᩣᨾᩥ ᩁᩩᨠ᩠ᨡᨲᩮᩣ;

ᨲ᩠ᩅᩴ ᨸᨠ᩠ᨠᨠᩣᩃᨾᨬ᩠ᨬᩣᨿ [ᩈᩩᨸᨠ᩠ᨠᨠᩣᩃᨾᨬ᩠ᨬᩣᨿ (ᨸᩦ.)], ᨽᨠ᩠ᨡᨿ ᨾᩴ ᨸᩥᨲᩣᨾᩉ’.

‘‘ᩍᨲᩥ ᩈᩦᩃᩅᨲᩴ ᩉᩮᨲᩩ, ᨶᩣᩁᨠ᩠ᨡᩥᩴ ᨾᨾ ᨩᩦᩅᩥᨲᩴ;

ᨸᨻ᩠ᨻᩣᨩᩮᩈᩥᩴ ᨧᩉᩴ ᨲᩔ, ᩈᨴᩣ ᨸᩣᨱᩣᨲᩥᨸᩣᨲᩥᨠ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ¶ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᩈᨦ᩠ᨡᨸᩣᩃᩮᩣ ᨾᩉᩥᨴ᩠ᨵᩥᨠᩮᩣ;

ᨴᩣᨮᩣᩅᩩᨵᩮᩣ ᨥᩮᩣᩁᩅᩥᩈᩮᩣ, ᨴ᩠ᩅᩥᨩᩥᩅ᩠ᩉᩮᩣ ᩏᩁᨣᩣᨵᩥᨽᩪ.

‘‘ᨧᨲᩩᨸ᩠ᨸᨳᩮ ᨾᩉᩣᨾᨣ᩠ᨣᩮ, ᨶᩣᨶᩣᨩᨶᩈᨾᩣᨠᩩᩃᩮ;

ᨧᨲᩩᩁᩮᩣ ᩋᨦ᩠ᨣᩮ ᩋᨵᩥᨭ᩠ᨮᩣᨿ, ᨲᨲ᩠ᨳ ᩅᩣᩈᨾᨠᨸ᩠ᨸᨿᩥᩴ.

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

ᨿᩔ ᩑᨲᩮᨶ ᨠᩁᨱᩦᨿᩴ, ᨴᩥᨶ᩠ᨶᩴᨿᩮᩅ ᩉᩁᩣᨲᩩ ᩈᩮᩣ.

‘‘ᩋᨴ᩠ᨴᩈᩴᩈᩩ ¶ ᨽᩮᩣᨩᨸᩩᨲ᩠ᨲᩣ, ᨡᩁᩣ ᩃᩩᨴ᩠ᨴᩣ ᩋᨠᩣᩁᩩᨱᩣ;

ᩏᨸᨣᨬ᩠ᨨᩩᩴ ᨾᨾᩴ ᨲᨲ᩠ᨳ, ᨴᨱ᩠ᨯᨾᩩᨣ᩠ᨣᩁᨸᩣᨱᩥᨶᩮᩣ.

‘‘ᨶᩣᩈᩣᨿ ᩅᩥᨶᩥᩅᩥᨩ᩠ᨫᩥᨲ᩠ᩅᩣ, ᨶᨦ᩠ᨣᩩᨭ᩠ᨮᩮ ᨸᩥᨭ᩠ᨮᩥᨠᨱ᩠ᨭᨠᩮ;

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

‘‘ᩈᩈᩣᨣᩁᨶ᩠ᨲᩴ ᨸᨳᩅᩥᩴ, ᩈᨠᩣᨶᨶᩴ ᩈᨸᨻ᩠ᨻᨲᩴ;

ᩍᨧ᩠ᨨᨾᩣᨶᩮᩣ ᨧᩉᩴ ᨲᨲ᩠ᨳ, ᨶᩣᩈᩣᩅᩣᨲᩮᨶ ᨫᩣᨸᨿᩮ.

‘‘ᩈᩪᩃᩮᩉᩥ ᩅᩥᨶᩥᩅᩥᨩ᩠ᨫᨶ᩠ᨲᩮ, ᨠᩮᩣᨭ᩠ᨭᨿᨶ᩠ᨲᩮᨸᩥ ᩈᨲ᩠ᨲᩥᨽᩥ;

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

ᩉᨲ᩠ᨳᩥᨶᩣᨣᩮᩣ ¶ ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᩣ, ᨧᨾ᩠ᨸᩮᨿ᩠ᨿᩮᩣ ᨻᩮᩣᨵᩥ ᨾᩉᩥᩴᩈᩮᩣ;

ᩁᩩᩁᩩ ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᨵᨾ᩠ᨾᩮᩣ ᨧ, ᩋᨲᩕᨩᩮᩣ ᨧ ᨩᨿᨴ᩠ᨴᩥᩈᩮᩣ.

ᩑᨲᩮ ᨶᩅ ᩈᩦᩃᨻᩃᩣ, ᨸᩁᩥᨠ᩠ᨡᩣᩁᩣ ᨸᨴᩮᩈᩥᨠᩣ;

ᨩᩦᩅᩥᨲᩴ ᨸᩁᩥᩁᨠ᩠ᨡᩥᨲ᩠ᩅᩣ, ᩈᩦᩃᩣᨶᩥ ᩋᨶᩩᩁᨠ᩠ᨡᩥᩈᩴ.

ᩈᨦ᩠ᨡᨸᩣᩃᩔ ᨾᩮ ᩈᨲᩮᩣ, ᩈᨻ᩠ᨻᨠᩣᩃᨾ᩠ᨸᩥ ᨩᩦᩅᩥᨲᩴ;

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

ᩈᩦᩃᨸᩣᩁᨾᩥᨶᩥᨴ᩠ᨴᩮᩈᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.

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

ᩏᩔᩣᩅᨻᩥᨶ᩠ᨴᩩᩴ ᩈᩪᩁᩥᨿᩣᨲᨸᩮ, ᨸᨲᩥᨲᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᩈᩴᩅᩥᨩᩥᩴ.

‘‘ᨲᨬ᩠ᨬᩮᩅᩣᨵᩥᨸᨲᩥᩴ ᨠᨲ᩠ᩅᩣ, ᩈᩴᩅᩮᨣᨾᨶᩩᨻᩕᩪᩉᨿᩥᩴ;

ᨾᩣᨲᩣᨸᩥᨲᩪ ᨧ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅᩣ, ᨸᨻ᩠ᨻᨩ᩠ᨩᨾᨶᩩᨿᩣᨧᩉᩴ.

‘‘ᨿᩣᨧᨶ᩠ᨲᩥ ᨾᩴ ᨸᨬ᩠ᨩᩃᩥᨠᩣ, ᩈᨶᩮᨣᨾᩣ ᩈᩁᨭ᩠ᨮᨠᩣ;

‘ᩋᨩ᩠ᨩᩮᩅ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩ, ᩍᨴ᩠ᨵᩴ ᨹᩦᨲᩴ ᨾᩉᩣᨾᩉᩥᩴ’.

‘‘ᩈᩁᩣᨩᨠᩮ ᩈᩉᩮᩣᩁᩮᩣᨵᩮ, ᩈᨶᩮᨣᨾᩮ ᩈᩁᨭ᩠ᨮᨠᩮ;

ᨠᩁᩩᨱᩴ ᨸᩁᩥᨴᩮᩅᨶ᩠ᨲᩮ, ᩋᨶᨸᩮᨠ᩠ᨡᩮᩣᩅ ᨸᩁᩥᨧ᩠ᨧᨩᩥᩴ.

‘‘ᨠᩮᩅᩃᩴ ᨸᨳᩅᩥᩴ ᩁᨩ᩠ᨩᩴ, ᨬᩣᨲᩥᨸᩁᩥᨩᨶᩴ ᨿᩈᩴ;

ᨧᨩᨾᩣᨶᩮᩣ ᨶ ᨧᩥᨶ᩠ᨲᩮᩈᩥᩴ, ᨻᩮᩣᨵᩥᨿᩣᨿᩮᩅ ᨠᩣᩁᨱᩣ.

‘‘ᨾᩣᨲᩣᨸᩥᨲᩣ ᨶ ᨾᩮ ᨴᩮᩔᩣ, ᨶᨸᩥ ᨾᩮ ᨴᩮᩔᩴ ᨾᩉᩣᨿᩈᩴ;

ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩴ ᨸᩥᨿᩴ ᨾᨿ᩠ᩉᩴ, ᨲᩈ᩠ᨾᩣ ᩁᨩ᩠ᨩᩴ ᨸᩁᩥᨧ᩠ᨧᨩᩥ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᩍᨶ᩠ᨴᨸᨲ᩠ᨳᩮ ᨸᩩᩁᩩᨲ᩠ᨲᨾᩮ;

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

‘‘ᩈᩦᩃᩅᩣ ᨣᩩᨱᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᨠᩃ᩠ᨿᩣᨱᨸᨭᩥᨽᩣᨶᩅᩣ;

ᩅᩩᨯ᩠ᨰᩣᨸᨧᩣᨿᩦ ᩉᩥᩁᩦᨾᩣ, ᩈᨦ᩠ᨣᩉᩮᩈᩩ ᨧ ᨠᩮᩣᩅᩥᨴᩮᩣ.

‘‘ᨲᩔ ¶ ᩁᨬ᩠ᨬᩮᩣ ᨸᨲᩥᨠᩁᩮᩣ, ᩋᩉᩮᩣᩈᩥ ᨠᩩᩉᨠᨲᩣᨸᩈᩮᩣ;

ᩌᩁᩣᨾᩴ ᨾᩣᩃᩣᩅᨧ᩠ᨨᨬ᩠ᨧ, ᩁᩮᩣᨸᨿᩥᨲ᩠ᩅᩣᨶ ᨩᩦᩅᨲᩥ.

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

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

‘‘ᨶᨲ᩠ᨳᩥᨾᩔ ¶ ᩈᨲᩴ ᨵᨾ᩠ᨾᩮᩣ, ᩈᩣᨾᨬ᩠ᨬᩣᨸᨣᨲᩮᩣ ᩋᨿᩴ;

ᩉᩥᩁᩦᩈᩩᨠ᩠ᨠᨵᨾ᩠ᨾᨩᩉᩥᨲᩮᩣ, ᨩᩦᩅᩥᨲᩅᩩᨲ᩠ᨲᩥᨠᩣᩁᨱᩣ.

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

ᨲᩴ ᨶᩥᩈᩮᨵᩮᨲᩩᩴ ᨣᨧ᩠ᨨᨶ᩠ᨲᩮᩣ, ᩋᨶᩩᩈᩣᩈᩥ ᨸᩥᨲᩣ ᨾᨾᩴ.

‘‘‘ᨾᩣ ᨸᨾᨩ᩠ᨩᩥ ᨲᩩᩅᩴ ᨲᩣᨲ, ᨩᨭᩥᩃᩴ ᩏᨣ᩠ᨣᨲᩣᨸᨶᩴ;

ᨿᨴᩥᨧ᩠ᨨᨠᩴ ᨸᩅᨲ᩠ᨲᩮᩉᩥ, ᩈᨻ᩠ᨻᨠᩣᨾᨴᨴᩮᩣ ᩉᩥ ᩈᩮᩣ’.

‘‘ᨲᨾᩉᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣᨶᩩᨸᨭ᩠ᨮᩣᨶᩴ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥᩴ;

‘ᨠᨧ᩠ᨧᩥ ᨲᩮ ᨣᩉᨸᨲᩥ ᨠᩩᩈᩃᩴ, ᨠᩥᩴ ᩅᩣ ᨲᩮ ᩌᩉᩁᩦᨿᨲᩩ’.

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

‘ᨥᩣᨲᩣᨸᩮᨾᩥ ᨲᩩᩅᩴ ᩋᨩ᩠ᨩ, ᩁᨭ᩠ᨮᩣ ᨸᨻ᩠ᨻᩣᨩᨿᩣᨾᩥ ᩅᩣ’.

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

‘ᨠᨧ᩠ᨧᩥ ᨲᩮ ᨽᨶ᩠ᨲᩮ ᨡᨾᨶᩦᨿᩴ, ᩈᨾ᩠ᨾᩣᨶᩮᩣ ᨲᩮ ᨸᩅᨲ᩠ᨲᩥᨲᩮᩣ’.

‘‘ᨲᩔ ᩌᨧᩥᨠ᩠ᨡᨲᩦ ᨸᩣᨸᩮᩣ, ᨠᩩᨾᩣᩁᩮᩣ ᨿᨳᩣ ᨶᩣᩈᩥᨿᩮᩣ;

ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩌᨱᩣᨸᩮᩈᩥ ᨾᩉᩦᨸᨲᩥ.

‘‘‘ᩈᩦᩈᩴ ᨲᨲ᩠ᨳᩮᩅ ᨨᩥᨶ᩠ᨴᩥᨲ᩠ᩅᩣ, ᨠᨲ᩠ᩅᩣᨶ ᨧᨲᩩᨡᨱ᩠ᨯᩥᨠᩴ;

ᩁᨳᩥᨿᩣ ᩁᨳᩥᨿᩴ ᨴᩔᩮᨳ, ᩈᩣ ᨣᨲᩥ ᨩᨭᩥᩃᩉᩦᩊᩥᨲᩣ’.

‘‘ᨲᨲ᩠ᨳ ᨠᩣᩁᨱᩥᨠᩣ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᨧᨱ᩠ᨯᩣ ᩃᩩᨴ᩠ᨴᩣ ᩋᨠᩣᩁᩩᨱᩣ;

ᨾᩣᨲᩩᩋᨦ᩠ᨠᩮ ᨶᩥᩈᩥᨶ᩠ᨶᩔ, ᩌᨠᨯ᩠ᨰᩥᨲ᩠ᩅᩣ ᨶᨿᨶ᩠ᨲᩥ ᨾᩴ.

‘‘ᨲᩮᩈᩣᩉᩴ ᩑᩅᨾᩅᨧᩴ, ᨻᨶ᩠ᨵᨲᩴ ᨣᩣᩊ᩠ᩉᨻᨶ᩠ᨵᨶᩴ;

‘ᩁᨬ᩠ᨬᩮᩣ ᨴᩔᩮᨳ ᨾᩴ ᨡᩥᨸ᩠ᨸᩴ, ᩁᩣᨩᨠᩥᩁᩥᨿᩣᨶᩥ ᩋᨲ᩠ᨳᩥ ᨾᩮ’.

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

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

‘‘ᩈᩮᩣ ᨾᩴ ᨲᨲ᩠ᨳ ᨡᨾᩣᨸᩮᩈᩥ, ᨾᩉᩣᩁᨩ᩠ᨩᨾᨴᩣᩈᩥ ᨾᩮ;

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

‘‘ᨶ ¶ ᨾᩮ ᨴᩮᩔᩴ ᨾᩉᩣᩁᨩ᩠ᨩᩴ, ᨠᩣᨾᨽᩮᩣᨣᩮᩣ ᨶ ᨴᩮᩔᩥᨿᩮᩣ;

ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩴ ᨸᩥᨿᩴ ᨾᨿ᩠ᩉᩴ, ᨲᩈ᩠ᨾᩣ ᩁᨩ᩠ᨩᩴ ᨸᩁᩥᨧ᩠ᨧᨩᩥ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ¶ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨠᩣᩈᩥᩁᩣᨩᩔ ᩋᨲᩕᨩᩮᩣ;

ᩋᨿᩮᩣᨥᩁᨾ᩠ᩉᩥ ᩈᩴᩅᨯ᩠ᨰᩮᩣ, ᨶᩣᨾᩮᨶᩣᩈᩥ ᩋᨿᩮᩣᨥᩁᩮᩣ.

‘‘ᨴᩩᨠ᩠ᨡᩮᨶ ᨩᩦᩅᩥᨲᩮᩣ ᩃᨴ᩠ᨵᩮᩣ, ᩈᩴᨸᩦᩊᩮ ᨸᨲᩥᨸᩮᩣᩈᩥᨲᩮᩣ;

ᩋᨩ᩠ᨩᩮᩅ ᨸᩩᨲ᩠ᨲ ᨸᨭᩥᨸᨩ᩠ᨩ, ᨠᩮᩅᩃᩴ ᩅᩈᩩᨵᩴ ᩍᨾᩴ.

‘‘ᩈᩁᨭ᩠ᨮᨠᩴ ᩈᨶᩥᨣᨾᩴ, ᩈᨩᨶᩴ ᩅᨶ᩠ᨴᩥᨲ᩠ᩅ ᨡᨲ᩠ᨲᩥᨿᩴ;

ᩋᨬ᩠ᨩᩃᩥᩴ ᨸᨣ᩠ᨣᩉᩮᨲ᩠ᩅᩣᨶ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥᩴ.

‘‘‘ᨿᩮ ᨠᩮᨧᩥ ᨾᩉᩥᨿᩣ ᩈᨲ᩠ᨲᩣ, ᩉᩦᨶᨾᩩᨠ᩠ᨠᨭ᩠ᨮᨾᨩ᩠ᨫᩥᨾᩣ;

ᨶᩥᩁᩣᩁᨠ᩠ᨡᩣ ᩈᨠᩮ ᨣᩮᩉᩮ, ᩅᨯ᩠ᨰᨶ᩠ᨲᩥ ᩈᨠᨬᩣᨲᩥᨽᩥ.

‘‘‘ᩍᨴᩴ ᩃᩮᩣᨠᩮ ᩏᨲ᩠ᨲᩁᩥᨿᩴ, ᩈᩴᨸᩦᩊᩮ ᨾᨾ ᨸᩮᩣᩈᨶᩴ;

ᩋᨿᩮᩣᨥᩁᨾ᩠ᩉᩥ ᩈᩴᩅᨯ᩠ᨰᩮᩣ, ᩋᨸ᩠ᨸᨽᩮ ᨧᨶ᩠ᨴᩈᩪᩁᩥᨿᩮ.

‘‘‘ᨸᩪᨲᩥᨠᩩᨱᨸᩈᨾ᩠ᨸᩩᨱ᩠ᨱᩣ, ᨾᩩᨧ᩠ᨧᩥᨲ᩠ᩅᩣ ᨾᩣᨲᩩ ᨠᩩᨧ᩠ᨨᩥᨲᩮᩣ;

ᨲᨲᩮᩣ ᨥᩮᩣᩁᨲᩁᩮ ᨴᩩᨠ᩠ᨡᩮ, ᨸᩩᨶ ᨸᨠ᩠ᨡᩥᨲ᩠ᨲᨿᩮᩣᨥᩁᩮ.

‘‘‘ᨿᨴᩥᩉᩴ ᨲᩣᨴᩥᩈᩴ ᨸᨲ᩠ᩅᩣ, ᨴᩩᨠ᩠ᨡᩴ ᨸᩁᨾᨴᩣᩁᩩᨱᩴ;

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

‘‘‘ᩏᨠ᩠ᨠᨱ᩠ᨮᩥᨲᩮᩣᨾ᩠ᩉᩥ ᨠᩣᨿᩮᨶ, ᩁᨩ᩠ᨩᩮᨶᨾ᩠ᩉᩥ ᩋᨶᨲ᩠ᨳᩥᨠᩮᩣ;

ᨶᩥᨻ᩠ᨻᩩᨲᩥᩴ ᨸᩁᩥᨿᩮᩈᩥᩔᩴ, ᨿᨲ᩠ᨳ ᨾᩴ ᨾᨧ᩠ᨧᩩ ᨶ ᨾᨴ᩠ᨴᩥᨿᩮ’.

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

ᨶᩣᨣᩮᩣᩅ ᨻᨶ᩠ᨵᨶᩴ ᨨᩮᨲ᩠ᩅᩣ, ᨸᩣᩅᩥᩈᩥᩴ ᨠᩣᨶᨶᩴ ᩅᨶᩴ.

‘‘ᨾᩣᨲᩣᨸᩥᨲᩣ ¶ ¶ ᨶ ᨾᩮ ᨴᩮᩔᩣ, ᨶᨸᩥ ᨾᩮ ᨴᩮᩔᩴ ᨾᩉᩣᨿᩈᩴ;

ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩴ ᨸᩥᨿᩴ ᨾᨿ᩠ᩉᩴ, ᨲᩈ᩠ᨾᩣ ᩁᨩ᩠ᨩᩴ ᨸᩁᩥᨧ᩠ᨧᨩᩥ’’ᨶ᩠ᨲᩥ.

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

ᨽᨣᩥᨶᩦ ᨧ ᨽᩣᨲᩁᩮᩣ ᩈᨲ᩠ᨲ, ᨶᩥᨻ᩠ᨻᨲ᩠ᨲᩣ ᩈᩮᩣᨲ᩠ᨳᩥᨿᩮ ᨠᩩᩃᩮ.

‘‘ᩑᨲᩮᩈᩴ ¶ ᨸᩩᨻ᩠ᨻᨩᩮᩣ ᩌᩈᩥᩴ, ᩉᩥᩁᩦᩈᩩᨠ᩠ᨠᨾᩩᨸᩣᨣᨲᩮᩣ;

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

‘‘ᨾᩣᨲᩣᨸᩥᨲᩪᩉᩥ ¶ ᨸᩉᩥᨲᩣ, ᩈᩉᩣᨿᩣ ᩑᨠᨾᩣᨶᩈᩣ;

ᨠᩣᨾᩮᩉᩥ ᨾᩴ ᨶᩥᨾᨶ᩠ᨲᩮᨶ᩠ᨲᩥ, ‘ᨠᩩᩃᩅᩴᩈᩴ ᨵᩁᩮᩉᩥ’ᨲᩥ.

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

ᨲᩴ ᨾᩮ ᩋᩉᩮᩣᩈᩥ ᨠᨮᩥᨶᩴ, ᨲᨲ᩠ᨲ [ᩈᨶ᩠ᨲᨲ᩠ᨲ (ᨠ.)] ᨹᩣᩃᩈᨾᩴ ᩅᩥᨿ.

‘‘ᨲᩮ ᨾᩴ ᨲᨴᩣ ᩏᨠ᩠ᨡᩥᨸᨶ᩠ᨲᩴ, ᨸᩩᨧ᩠ᨨᩥᩴᩈᩩ ᨸᨲ᩠ᨳᩥᨲᩴ ᨾᨾ;

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

‘‘ᨲᩮᩈᩣᩉᩴ ᩑᩅᨾᩅᨧᩴ, ᩋᨲ᩠ᨳᨠᩣᨾᩮᩣ ᩉᩥᨲᩮᩈᩥᨶᩴ;

‘ᨶᩣᩉᩴ ᨸᨲ᩠ᨳᩮᨾᩥ ᨣᩥᩉᩦᨽᩣᩅᩴ, ᨶᩮᨠ᩠ᨡᨾ᩠ᨾᩣᨽᩥᩁᨲᩮᩣ ᩋᩉᩴ’.

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

ᨾᩣᨲᩣᨸᩥᨲᩣ ᩑᩅᨾᩣᩉᩩ, ‘ᩈᨻ᩠ᨻᩮᩅ ᨸᨻ᩠ᨻᨩᩣᨾ ᨽᩮᩣ’.

‘‘ᩏᨽᩮᩣ ¶ ᨾᩣᨲᩣᨸᩥᨲᩣ ᨾᨿ᩠ᩉᩴ, ᨽᨣᩥᨶᩦ ᨧ ᩈᨲ᩠ᨲ ᨽᩣᨲᩁᩮᩣ;

ᩋᨾᩥᨲᨵᨶᩴ ᨨᨯ᩠ᨯᨿᩥᨲ᩠ᩅᩣ, ᨸᩣᩅᩥᩈᩥᨾ᩠ᩉᩣ ᨾᩉᩣᩅᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨶᨣᩁᩮ ᨻᩕᩉ᩠ᨾᩅᨯ᩠ᨰᨶᩮ;

ᨲᨲ᩠ᨳ ᨠᩩᩃᩅᩁᩮ ᩈᩮᨭ᩠ᨮᩮ, ᨾᩉᩣᩈᩣᩃᩮ ᩋᨩᩣᨿᩉᩴ.

‘‘ᨲᨴᩣᨸᩥ ᩃᩮᩣᨠᩴ ᨴᩥᩈ᩠ᩅᩣᨶ, ᩋᨶ᩠ᨵᩦᨽᩪᨲᩴ ᨲᨾᩮᩣᨲ᩠ᨳᨭᩴ;

ᨧᩥᨲ᩠ᨲᩴ ᨽᩅᨲᩮᩣ ᨸᨲᩥᨠᩩᨭᨲᩥ, ᨲᩩᨲ᩠ᨲᩅᩮᨣᩉᨲᩴ ᩅᩥᨿ.

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

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

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

ᨲᩮᩈᨾ᩠ᨸᩥ ᨨᨶ᩠ᨴᨾᩣᨧᩥᨠ᩠ᨡᩥᩴ, ‘ᨾᩣ ᨶᩥᨾᨶ᩠ᨲᩮᨳ ᨲᩮᩉᩥ ᨾᩴ’.

‘‘ᨿᩮᩣ ¶ ᨾᩮ ᨠᨶᩥᨭ᩠ᨮᨠᩮᩣ ᨽᩣᨲᩣ, ᨶᨶ᩠ᨴᩮᩣ ᨶᩣᨾᩣᩈᩥ ᨸᨱ᩠ᨯᩥᨲᩮᩣ;

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

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

ᨲᨴᩣᨸᩥ ᨽᩮᩣᨣᩮ ᨨᨯ᩠ᨯᩮᨲ᩠ᩅᩣ, ᨸᩣᩅᩥᩈᩥᨾ᩠ᩉᩣ ᨾᩉᩣᩅᨶ’’ᨶ᩠ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ¶ ¶ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᨠᩣᩈᩥᩁᩣᨩᩔ ᩋᨲᩕᨩᩮᩣ;

ᨾᩪᨣᨸᨠ᩠ᨡᩮᩣᨲᩥ ᨶᩣᨾᩮᨶ, ᨲᩮᨾᩥᨿᩮᩣᨲᩥ ᩅᨴᨶ᩠ᨲᩥ ᨾᩴ.

‘‘ᩈᩮᩣᩊᩈᩥᨲ᩠ᨳᩥᩈᩉᩔᩣᨶᩴ, ᨶ ᩅᩥᨩ᩠ᨩᨲᩥ ᨸᩩᨾᩮᩣ ᨲᨴᩣ [ᩈᨴᩣ (ᩈᩦ.)];

ᩋᩉᩮᩣᩁᨲ᩠ᨲᩣᨶᩴ ᩋᨧ᩠ᨧᨿᩮᨶ, ᨶᩥᨻ᩠ᨻᨲ᩠ᨲᩮᩣ ᩋᩉᨾᩮᨠᨠᩮᩣ.

‘‘ᨠᩥᨧ᩠ᨨᩣ ᩃᨴ᩠ᨵᩴ ᨸᩥᨿᩴ ᨸᩩᨲ᩠ᨲᩴ, ᩋᨽᩥᨩᩣᨲᩴ ᨩᩩᨲᩥᨶ᩠ᨵᩁᩴ;

ᩈᩮᨲᨧ᩠ᨨᨲ᩠ᨲᩴ ᨵᩣᩁᨿᩥᨲ᩠ᩅᩣᨶ, ᩈᨿᨶᩮ ᨸᩮᩣᩈᩮᨲᩥ ᨾᩴ ᨸᩥᨲᩣ.

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

ᩋᨴ᩠ᨴᩈᩴ ᨸᨱ᩠ᨯᩁᩴ ᨨᨲ᩠ᨲᩴ, ᨿᩮᨶᩣᩉᩴ ᨶᩥᩁᨿᩴ ᨣᨲᩮᩣ.

‘‘ᩈᩉ ¶ ᨴᩥᨭ᩠ᨮᩔ ᨾᩮ ᨨᨲ᩠ᨲᩴ, ᨲᩣᩈᩮᩣ ᩏᨸ᩠ᨸᨩ᩠ᨩᩥ ᨽᩮᩁᩅᩮᩣ;

ᩅᩥᨶᩥᨧ᩠ᨨᨿᩴ ᩈᨾᩣᨸᨶ᩠ᨶᩮᩣ, ‘ᨠᨳᩣᩉᩴ ᩍᨾᩴ ᨾᩩᨬ᩠ᨧᩥᩔᩴ’.

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

ᩈᩣ ᨾᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᨴᩩᨠ᩠ᨡᩥᨲᩴ, ᨲᩦᩈᩩ ᨮᩣᨶᩮᩈᩩ ᨿᩮᩣᨩᨿᩥ.

‘‘‘ᨾᩣ ᨸᨱ᩠ᨯᩥᨧ᩠ᨧᨿᩴ ᩅᩥᨽᩣᩅᨿ, ᨻᩣᩃᨾᨲᩮᩣ ᨽᩅ ᩈᨻ᩠ᨻᨸᩣᨱᩥᨶᩴ;

ᩈᨻ᩠ᨻᩮᩣ ᨲᩴ ᨩᨶᩮᩣ ᩒᨧᩥᨶᩣᨿᨲᩩ, ᩑᩅᩴ ᨲᩅ ᩋᨲ᩠ᨳᩮᩣ ᨽᩅᩥᩔᨲᩥ’.

‘‘ᩑᩅᩴ ᩅᩩᨲ᩠ᨲᩣᨿᩉᩴ ᨲᩔᩣ, ᩍᨴᩴ ᩅᨧᨶᨾᨻᩕᩅᩥᩴ;

‘ᨠᩁᩮᩣᨾᩥ ᨲᩮ ᨲᩴ ᩅᨧᨶᩴ, ᨿᩴ ᨲ᩠ᩅᩴ ᨽᨱᩈᩥ ᨴᩮᩅᨲᩮ;

ᩋᨲ᩠ᨳᨠᩣᨾᩣᩈᩥ ᨾᩮ ᩋᨾ᩠ᨾ, ᩉᩥᨲᨠᩣᨾᩣᩈᩥ ᨴᩮᩅᨲᩮ’.

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

ᩉᨭ᩠ᨮᩮᩣ ¶ ᩈᩴᩅᩥᨣ᩠ᨣᨾᩣᨶᩈᩮᩣ, ᨲᨿᩮᩣ ᩋᨦ᩠ᨣᩮ ᩋᨵᩥᨭ᩠ᨮᩉᩥᩴ.

‘‘ᨾᩪᨣᩮᩣ ¶ ᩋᩉᩮᩣᩈᩥᩴ ᨻᨵᩥᩁᩮᩣ, ᨸᨠ᩠ᨡᩮᩣ ᨣᨲᩥᩅᩥᩅᨩ᩠ᨩᩥᨲᩮᩣ;

ᩑᨲᩮ ᩋᨦ᩠ᨣᩮ ᩋᨵᩥᨭ᩠ᨮᩣᨿ, ᩅᩔᩣᨶᩥ ᩈᩮᩣᩊᩈᩴ ᩅᩈᩥᩴ.

‘‘ᨲᨲᩮᩣ ᨾᩮ ᩉᨲ᩠ᨳᨸᩣᨴᩮ ᨧ, ᨩᩥᩅ᩠ᩉᩴ ᩈᩮᩣᨲᨬ᩠ᨧ ᨾᨴ᩠ᨴᩥᨿ;

ᩋᨶᩪᨶᨲᩴ ᨾᩮ ᨸᩔᩥᨲ᩠ᩅᩣ, ‘ᨠᩣᩊᨠᨱ᩠ᨱᩦ’ᨲᩥ ᨶᩥᨶ᩠ᨴᩥᩈᩩᩴ.

‘‘ᨲᨲᩮᩣ ᨩᩣᨶᨸᨴᩣ ᩈᨻ᩠ᨻᩮ, ᩈᩮᨶᩣᨸᨲᩥᨸᩩᩁᩮᩣᩉᩥᨲᩣ;

ᩈᨻ᩠ᨻᩮ ᩑᨠᨾᨶᩣ ᩉᩩᨲ᩠ᩅᩣ, ᨨᨯ᩠ᨯᨶᩴ ᩋᨶᩩᨾᩮᩣᨴᩥᩈᩩᩴ.

‘‘ᩈᩮᩣᩉᩴ ᨲᩮᩈᩴ ᨾᨲᩥᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩉᨭ᩠ᨮᩮᩣ ᩈᩴᩅᩥᨣ᩠ᨣᨾᩣᨶᩈᩮᩣ;

ᨿᩔᨲ᩠ᨳᩣᨿ ᨲᨸᩮᩣᨧᩥᨱ᩠ᨱᩮᩣ, ᩈᩮᩣ ᨾᩮ ᩋᨲ᩠ᨳᩮᩣ ᩈᨾᩥᨩ᩠ᨫᨳ.

‘‘ᨶ᩠ᩉᩣᨸᩮᨲ᩠ᩅᩣ ᩋᨶᩩᩃᩥᨾ᩠ᨸᩥᨲ᩠ᩅᩣ, ᩅᩮᨮᩮᨲ᩠ᩅᩣ ᩁᩣᨩᩅᩮᨮᨶᩴ;

ᨨᨲ᩠ᨲᩮᨶ ᩋᨽᩥᩈᩥᨬ᩠ᨧᩥᨲ᩠ᩅᩣ, ᨠᩣᩁᩮᩈᩩᩴ ᨸᩩᩁᩴ ᨸᨴᨠ᩠ᨡᩥᨱᩴ.

‘‘ᩈᨲ᩠ᨲᩣᩉᩴ ᨵᩣᩁᨿᩥᨲ᩠ᩅᩣᨶ, ᩏᨣ᩠ᨣᨲᩮ ᩁᩅᩥᨾᨱ᩠ᨯᩃᩮ;

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

‘‘ᩑᨠᩮᩣᨠᩣᩈᩮ ¶ ᩁᨳᩴ ᨠᨲ᩠ᩅᩣ, ᩈᨩ᩠ᨩᩔᩴ ᩉᨲ᩠ᨳᨾᩩᨧ᩠ᨧᩥᨲᩮᩣ [ᩉᨲ᩠ᨳᨾᩩᨬ᩠ᨧᩥᨲᩮᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ.)];

ᩈᩣᩁᨳᩦ ᨡᨱᨲᩦ ᨠᩣᩈᩩᩴ, ᨶᩥᨡᩣᨲᩩᩴ ᨸᨳᩅᩥᨿᩣ ᨾᨾᩴ.

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

ᨶ ᨽᩥᨶ᩠ᨴᩥᩴ ᨲᨾᨵᩥᨭ᩠ᨮᩣᨶᩴ, ᨻᩮᩣᨵᩥᨿᩣᨿᩮᩅ ᨠᩣᩁᨱᩣ.

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

ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩴ ᨸᩥᨿᩴ ᨾᨿ᩠ᩉᩴ, ᨲᩈ᩠ᨾᩣ ᩅᨲᨾᨵᩥᨭ᩠ᨮᩉᩥᩴ.

‘‘ᩑᨲᩮ ¶ ¶ ᩋᨦ᩠ᨣᩮ ᩋᨵᩥᨭ᩠ᨮᩣᨿ, ᩅᩔᩣᨶᩥ ᩈᩮᩣᩊᩈᩴ ᩅᩈᩥᩴ;

ᩋᨵᩥᨭ᩠ᨮᩣᨶᩮᨶ ᨾᩮ ᩈᨾᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩑᩈᩣ ᨾᩮ ᩋᨵᩥᨭ᩠ᨮᩣᨶᨸᩣᩁᨾᩦ’’ᨲᩥ.

‘‘ᨿᨴᩣ ᩋᩉᩴ ᨠᨸᩥ ᩌᩈᩥᩴ, ᨶᨴᩦᨠᩪᩃᩮ ᨴᩁᩦᩈᨿᩮ;

ᨸᩦᩊᩥᨲᩮᩣ ᩈᩩᩈᩩᨾᩣᩁᩮᨶ, ᨣᨾᨶᩴ ᨶ ᩃᨽᩣᨾᩉᩴ.

‘‘ᨿᨾ᩠ᩉᩮᩣᨠᩣᩈᩮ ¶ ᩋᩉᩴ ᨮᨲ᩠ᩅᩣ, ᩒᩁᩣ ᨸᩣᩁᩴ ᨸᨲᩣᨾᩉᩴ;

ᨲᨲ᩠ᨳᨧ᩠ᨨᩥ ᩈᨲ᩠ᨲᩩ ᩅᨵᨠᩮᩣ, ᨠᩩᨾ᩠ᨽᩦᩃᩮᩣ ᩃᩩᨴ᩠ᨴᨴᩔᨶᩮᩣ.

‘‘ᩈᩮᩣ ᨾᩴ ᩋᩈᩴᩈᩥ ‘ᩑᩉᩦ’ᨲᩥ, ‘ᩋᩉᩴᨸᩮᨾᩦ’ᨲᩥ ᨲᩴ ᩅᨲᩥᩴ;

ᨲᩔ ᨾᨲ᩠ᨳᨠᨾᨠ᩠ᨠᨾ᩠ᨾ, ᨸᩁᨠᩪᩃᩮ ᨸᨲᩥᨭ᩠ᨮᩉᩥᩴ.

‘‘ᨶ ᨲᩔ ᩋᩃᩥᨠᩴ ᨽᨱᩥᨲᩴ, ᨿᨳᩣ ᩅᩣᨧᩴ ᩋᨠᩣᩈᩉᩴ;

ᩈᨧ᩠ᨧᩮᨶ ᨾᩮ ᩈᨾᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩑᩈᩣ ᨾᩮ ᩈᨧ᩠ᨧᨸᩣᩁᨾᩦ’’ᨲᩥ.

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

ᩈᨧ᩠ᨧᩮᨶ ᩃᩮᩣᨠᩴ ᨸᩣᩃᩮᩈᩥᩴ, ᩈᨾᨣ᩠ᨣᩴ ᨩᨶᨾᨠᩣᩈᩉ’’ᨶ᩠ᨲᩥ.

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

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

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

ᨲᩔᩣ ᨹᩔᩮᨶ ᨩᩦᩅᩣᨾᩥ, ᨶᨲ᩠ᨳᩥ ᨾᩮ ᨠᩣᨿᩥᨠᩴ ᨻᩃᩴ.

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

ᩏᨸᨣᨧ᩠ᨨᨲᩥ ᩋᨾ᩠ᩉᩣᨠᩴ, ᨸᩣᩅᨠᩮᩣ ᨠᨱ᩠ᩉᩅᨲ᩠ᨲᨶᩦ.

‘‘ᨵᨾᨵᨾᩣ ᩍᨲᩥᩑᩅᩴ, ᩈᨴ᩠ᨴᩣᨿᨶ᩠ᨲᩮᩣ ᨾᩉᩣᩈᩥᨡᩦ;

ᩋᨶᩩᨸᩩᨻ᩠ᨻᩮᨶ ᨫᩣᨸᩮᨶ᩠ᨲᩮᩣ, ᩋᨣ᩠ᨣᩥ ᨾᨾᨾᩩᨸᩣᨣᨾᩥ.

‘‘ᩋᨣ᩠ᨣᩥᩅᩮᨣᨽᨿᩣᨲᩦᨲᩣ, ᨲᩈᩥᨲᩣ ᨾᩣᨲᩣᨸᩥᨲᩣ ᨾᨾ;

ᨠᩩᩃᩣᩅᨠᩮ ᨾᩴ ᨨᨯ᩠ᨯᩮᨲ᩠ᩅᩣ, ᩋᨲ᩠ᨲᩣᨶᩴ ᨸᩁᩥᨾᩮᩣᨧᨿᩩᩴ.

‘‘ᨸᩣᨴᩮ ¶ ᨸᨠ᩠ᨡᩮ ᨸᨩᩉᩣᨾᩥ, ᨶᨲ᩠ᨳᩥ ᨾᩮ ᨠᩣᨿᩥᨠᩴ ᨻᩃᩴ;

ᩈᩮᩣᩉᩴ ᩋᨣᨲᩥᨠᩮᩣ ᨲᨲ᩠ᨳ, ᩑᩅᩴ ᨧᩥᨶ᩠ᨲᩮᩈᩉᩴ ᨲᨴᩣ.

‘‘‘ᨿᩮᩈᩣᩉᩴ ᩏᨸᨵᩣᩅᩮᨿ᩠ᨿᩴ, ᨽᩦᨲᩮᩣ ᨲᩈᩥᨲᩅᩮᨵᩥᨲᩮᩣ;

ᨲᩮ ᨾᩴ ᩒᩉᩣᨿ ᨸᨠ᩠ᨠᨶ᩠ᨲᩣ, ᨠᨳᩴ ᨾᩮ ᩋᨩ᩠ᨩ ᨠᩣᨲᩅᩮ.

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

ᨲᩮᨶ ᩈᨧ᩠ᨧᩮᨶ ᨠᩣᩉᩣᨾᩥ, ᩈᨧ᩠ᨧᨠᩥᩁᩥᨿᨾᩩᨲ᩠ᨲᨾᩴ.

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

ᩈᨧ᩠ᨧᨻᩃᨾᩅᩔᩣᨿ, ᩈᨧ᩠ᨧᨠᩥᩁᩥᨿᨾᨠᩣᩈᩉᩴ.

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

ᨾᩣᨲᩣᨸᩥᨲᩣ ᨧ ᨶᩥᨠ᩠ᨡᨶ᩠ᨲᩣ, ᨩᩣᨲᩅᩮᨴ ᨸᨭᩥᨠ᩠ᨠᨾ’.

‘‘ᩈᩉᩈᨧ᩠ᨧᩮ ᨠᨲᩮ ᨾᨿ᩠ᩉᩴ, ᨾᩉᩣᨸᨩ᩠ᨩᩃᩥᨲᩮᩣ ᩈᩥᨡᩦ;

ᩅᨩ᩠ᨩᩮᩈᩥ ᩈᩮᩣᩊᩈᨠᩁᩦᩈᩣᨶᩥ, ᩏᨴᨠᩴ ᨸᨲ᩠ᩅᩣ ᨿᨳᩣ ᩈᩥᨡᩦ;

ᩈᨧ᩠ᨧᩮᨶ ᨾᩮ ᩈᨾᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩑᩈᩣ ᨾᩮ ᩈᨧ᩠ᨧᨸᩣᩁᨾᩦ’’ᨲᩥ.

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

ᩏᨱ᩠ᩉᩮ ᩈᩪᩁᩥᨿᩈᨶ᩠ᨲᩣᨸᩮ, ᩈᩁᩮ ᩏᨴᨠ ᨡᩦᨿᨳ.

‘‘ᨲᨲᩮᩣ ᨠᩣᨠᩣ ᨧ ᨣᩥᨩ᩠ᨫᩣ ᨧ, ᨠᨦ᩠ᨠᩣ [ᨻᨠᩣ (ᩈᩦ.)] ᨠᩩᩃᩃᩈᩮᨶᨠᩣ;

ᨽᨠ᩠ᨡᨿᨶ᩠ᨲᩥ ᨴᩥᩅᩣᩁᨲ᩠ᨲᩥᩴ, ᨾᨧ᩠ᨨᩮ ᩏᨸᨶᩥᩈᩦᨴᩥᨿ.

‘‘ᩑᩅᩴ ᨧᩥᨶ᩠ᨲᩮᩈᩉᩴ ᨲᨲ᩠ᨳ, ᩈᩉ ᨬᩣᨲᩦᩉᩥ ᨸᩦᩊᩥᨲᩮᩣ;

‘ᨠᩮᨶ ᨶᩩ ᨡᩮᩣ ᩏᨸᩣᨿᩮᨶ, ᨬᩣᨲᩦ ᨴᩩᨠ᩠ᨡᩣ ᨸᨾᩮᩣᨧᨿᩮ’.

‘‘ᩅᩥᨧᩥᨶ᩠ᨲᨿᩥᨲ᩠ᩅᩣ ᨵᨾ᩠ᨾᨲ᩠ᨳᩴ, ᩈᨧ᩠ᨧᩴ ᩋᨴ᩠ᨴᩈ ᨸᩔᨿᩴ;

ᩈᨧ᩠ᨧᩮ ᨮᨲ᩠ᩅᩣ ᨸᨾᩮᩣᨧᩮᩈᩥᩴ, ᨬᩣᨲᩦᨶᩴ ᨲᩴ ᩋᨲᩥᨠ᩠ᨡᨿᩴ.

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

ᩋᨠᩣᩈᩥ ᩈᨧ᩠ᨧᨠᩥᩁᩥᨿᩴ, ᨿᩴ ᩃᩮᩣᨠᩮ ᨵᩩᩅᩈᩔᨲᩴ.

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

ᨶᩣᨽᩥᨩᩣᨶᩣᨾᩥ ᩈᨬ᩠ᨧᩥᨧ᩠ᨧ, ᩑᨠᨸᩣᨱᨾ᩠ᨸᩥ ᩉᩥᩴᩈᩥᨲᩴ.

‘‘‘ᩑᨲᩮᨶ ¶ ᩈᨧ᩠ᨧᩅᨩ᩠ᨩᩮᨶ, ᨸᨩ᩠ᨩᩩᨶ᩠ᨶᩮᩣ ᩋᨽᩥᩅᩔᨲᩩ;

ᩋᨽᩥᨲ᩠ᨳᨶᨿ ᨸᨩ᩠ᨩᩩᨶ᩠ᨶ, ᨶᩥᨵᩥᩴ ᨠᩣᨠᩔ ᨶᩣᩈᨿ;

ᨠᩣᨠᩴ ᩈᩮᩣᨠᩣᨿ ᩁᨶ᩠ᨵᩮᩉᩥ, ᨾᨧ᩠ᨨᩮ ᩈᩮᩣᨠᩣ ᨸᨾᩮᩣᨧᨿ’.

‘‘ᩈᩉᨠᨲᩮ ᩈᨧ᩠ᨧᩅᩁᩮ, ᨸᨩ᩠ᨩᩩᨶ᩠ᨶᩮᩣ ᩋᨽᩥᨣᨩ᩠ᨩᩥᨿ;

ᨳᩃᩴ ᨶᩥᨶ᩠ᨶᨬ᩠ᨧ ᨸᩪᩁᩮᨶ᩠ᨲᩮᩣ, ᨡᨱᩮᨶ ᩋᨽᩥᩅᩔᨳ.

‘‘ᩑᩅᩁᩪᨸᩴ ᩈᨧ᩠ᨧᩅᩁᩴ, ᨠᨲ᩠ᩅᩣ ᩅᩦᩁᩥᨿᨾᩩᨲ᩠ᨲᨾᩴ;

ᩅᩔᩣᨸᩮᩈᩥᩴ ᨾᩉᩣᨾᩮᨥᩴ, ᩈᨧ᩠ᨧᨲᩮᨩᨻᩃᩔᩥᨲᩮᩣ;

ᩈᨧ᩠ᨧᩮᨶ ᨾᩮ ᩈᨾᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩑᩈᩣ ᨾᩮ ᩈᨧ᩠ᨧᨸᩣᩁᨾᩦ’’ᨲᩥ.

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

ᨸᩁᩮᩣᨸᨬ᩠ᨬᩣᩈᩅᩔᩣᨶᩥ, ᩋᨶᨽᩥᩁᨲᩮᩣᨧᩁᩥᩴ ᩋᩉᩴ.

‘‘ᨶ ᨠᩮᩣᨧᩥ ᩑᨲᩴ ᨩᩣᨶᩣᨲᩥ, ᩋᨶᨽᩥᩁᨲᩥᨾᨶᩴ ᨾᨾ;

ᩋᩉᨬ᩠ᩉᩥ ᨠᩔᨧᩥ ᨶᩣᨧᩥᨠ᩠ᨡᩥᩴ, ᩋᩁᨲᩥ ᨾᩮ ᨧᩁᨲᩥ ᨾᩣᨶᩈᩮ.

‘‘ᩈᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ ¶ ᨾᨱ᩠ᨯᨻ᩠ᨿᩮᩣ, ᩈᩉᩣᨿᩮᩣ ᨾᩮ ᨾᩉᩣᩍᩈᩥ;

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

‘‘ᨲᨾᩉᩴ ᩏᨸᨭ᩠ᨮᩉᩥᨲ᩠ᩅᩣᨶ, ᩌᩁᩮᩣᨣ᩠ᨿᨾᨶᩩᨸᩣᨸᨿᩥᩴ;

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

‘‘ᩈᩉᩣᨿᩮᩣ ¶ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ ᨾᨿ᩠ᩉᩴ, ᨽᩁᩥᨿᩴ ᩌᨴᩣᨿ ᨸᩩᨲ᩠ᨲᨠᩴ;

ᨲᨿᩮᩣ ᨩᨶᩣ ᩈᨾᩣᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩌᨣᨬ᩠ᨨᩩᩴ ᨸᩣᩉᩩᨶᩣᨣᨲᩴ.

‘‘ᩈᨾ᩠ᨾᩮᩣᨴᨾᩣᨶᩮᩣ ᨲᩮᩉᩥ ᩈᩉ, ᨶᩥᩈᩥᨶ᩠ᨶᩮᩣ ᩈᨠᨾᩔᨾᩮ;

ᨴᩣᩁᨠᩮᩣ ᩅᨭ᩠ᨭᨾᨶᩩᨠ᩠ᨡᩥᨸᩴ, ᩌᩈᩦᩅᩥᩈᨾᨠᩮᩣᨸᨿᩥ.

‘‘ᨲᨲᩮᩣ ᩈᩮᩣ ᩅᨭ᩠ᨭᨣᨲᩴ ᨾᨣ᩠ᨣᩴ, ᩋᨶ᩠ᩅᩮᩈᨶ᩠ᨲᩮᩣ ᨠᩩᨾᩣᩁᨠᩮᩣ;

ᩌᩈᩦᩅᩥᩈᩔ ᩉᨲ᩠ᨳᩮᨶ, ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᩴ ᨸᩁᩣᨾᩈᩥ.

‘‘ᨲᩔ ¶ ᩌᨾᩈᨶᩮ ᨠᩩᨴ᩠ᨵᩮᩣ, ᩈᨸ᩠ᨸᩮᩣ ᩅᩥᩈᨻᩃᩔᩥᨲᩮᩣ;

ᨠᩩᨸᩥᨲᩮᩣ ᨸᩁᨾᨠᩮᩣᨸᩮᨶ, ᩋᨯᩴᩈᩥ ᨴᩣᩁᨠᩴ ᨡᨱᩮ.

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

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

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

ᨸᨮᨾᩴ ᩋᨠᩣᩈᩥᩴ ᨠᩥᩁᩥᨿᩴ, ᩋᨣ᩠ᨣᩴ ᩈᨧ᩠ᨧᩴ ᩅᩁᩩᨲ᩠ᨲᨾᩴ.

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

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

‘‘‘ᩋᨠᩣᨾᨠᩮᩣ ᩅᩣᩉᩥ ᩋᩉᩴ ᨧᩁᩣᨾᩥ, ᩑᨲᩮᨶ ᩈᨧ᩠ᨧᩮᨶ ᩈᩩᩅᨲ᩠ᨳᩥ ᩉᩮᩣᨲᩩ;

‘‘ᩈᩉ ¶ ¶ ᩈᨧ᩠ᨧᩮ ᨠᨲᩮ ᨾᨿ᩠ᩉᩴ, ᩅᩥᩈᩅᩮᨣᩮᨶ ᩅᩮᨵᩥᨲᩮᩣ;

ᩋᨻᩩᨩ᩠ᨫᩥᨲ᩠ᩅᩣᨶ ᩅᩩᨭ᩠ᨮᩣᩈᩥ, ᩋᩁᩮᩣᨣᩮᩣ ᨧᩣᩈᩥ ᨾᩣᨱᩅᩮᩣ;

ᩈᨧ᩠ᨧᩮᨶ ᨾᩮ ᩈᨾᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩑᩈᩣ ᨾᩮ ᩈᨧ᩠ᨧᨸᩣᩁᨾᩦ’’ᨲᩥ.

‘‘ᨸᩩᨶᩣᨸᩁᩴ ᨿᨴᩣ ᩉᩮᩣᨾᩥ, ᩈᩩᨲᩈᩮᩣᨾᩮᩣ ᨾᩉᩦᨸᨲᩥ;

ᨣᩉᩥᨲᩮᩣ ᨸᩮᩣᩁᩥᩈᩣᨴᩮᨶ, ᨻᩕᩣᩉ᩠ᨾᨱᩮ ᩈᨦ᩠ᨣᩁᩴ ᩈᩁᩥᩴ.

‘‘ᨡᨲ᩠ᨲᩥᨿᩣᨶᩴ ᩑᨠᩈᨲᩴ, ᩌᩅᩩᨱᩥᨲ᩠ᩅᩣ ᨠᩁᨲ᩠ᨲᩃᩮ;

ᩑᨲᩮᩈᩴ ᨸᨾᩥᩃᩣᨸᩮᨲ᩠ᩅᩣ, ᨿᨬ᩠ᨬᨲ᩠ᨳᩮ ᩏᨸᨶᨿᩦ ᨾᨾᩴ.

‘‘ᩋᨸᩩᨧ᩠ᨨᩥ ¶ ᨾᩴ ᨸᩮᩣᩁᩥᩈᩣᨴᩮᩣ, ‘ᨠᩥᩴ ᨲ᩠ᩅᩴ ᩍᨧ᩠ᨨᩈᩥ ᨶᩥᩔᨩᩴ;

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

‘‘ᨲᩔ ¶ ᨸᨭᩥᩔᩩᨱᩥᨲ᩠ᩅᩣᨶ, ᨸᨱ᩠ᩉᩮ ᩌᨣᨾᨶᩴ ᨾᨾ;

ᩏᨸᨣᨶ᩠ᨲ᩠ᩅᩣ ᨸᩩᩁᩴ ᩁᨾ᩠ᨾᩴ, ᩁᨩ᩠ᨩᩴ ᨶᩥᨿ᩠ᨿᩣᨴᨿᩥᩴ ᨲᨴᩣ.

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

ᨻᩕᩣᩉ᩠ᨾᨱᩔ ᨵᨶᩴ ᨴᨲ᩠ᩅᩣ, ᨸᩮᩣᩁᩥᩈᩣᨴᩴ ᩏᨸᩣᨣᨾᩥᩴ.

‘‘ᨶᨲ᩠ᨳᩥ ᨾᩮ ᩈᩴᩈᨿᩮᩣ ᨲᨲ᩠ᨳ, ᨥᩣᨲᨿᩥᩔᨲᩥ ᩅᩣ ᨶ ᩅᩣ;

ᩈᨧ᩠ᨧᩅᩣᨧᩣᨶᩩᩁᨠ᩠ᨡᨶ᩠ᨲᩮᩣ, ᨩᩦᩅᩥᨲᩴ ᨧᨩᩥᨲᩩᨾᩩᨸᩣᨣᨾᩥᩴ;

ᩈᨧ᩠ᨧᩮᨶ ᨾᩮ ᩈᨾᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩑᩈᩣ ᨾᩮ ᩈᨧ᩠ᨧᨸᩣᩁᨾᩦ’’ᨲᩥ.

‘‘ᩈᩣᨾᩮᩣ ¶ ¶ ᨿᨴᩣ ᩅᨶᩮ ᩌᩈᩥᩴ, ᩈᨠ᩠ᨠᩮᨶ ᩋᨽᩥᨶᩥᨾ᩠ᨾᩥᨲᩮᩣ;

ᨸᩅᨶᩮ ᩈᩦᩉᨻ᩠ᨿᨣ᩠ᨥᩮ ᨧ, ᨾᩮᨲ᩠ᨲᩣᨿᨾᩩᨸᨶᩣᨾᨿᩥᩴ.

‘‘ᩈᩦᩉᨻ᩠ᨿᨣ᩠ᨥᩮᩉᩥ ᨴᩦᨸᩦᩉᩥ, ᩋᨧ᩠ᨨᩮᩉᩥ ᨾᩉᩥᩈᩮᩉᩥ ᨧ;

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

‘‘ᨶ ᨾᩴ ᨠᩮᩣᨧᩥ ᩏᨲ᩠ᨲᩈᨲᩥ, ᨶᨸᩥ ᨽᩣᨿᩣᨾᩥ ᨠᩔᨧᩥ;

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

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

ᨸᩁᨾᩴ ᩈᩦᩃᩴ ᩋᨵᩥᨭ᩠ᨮᩣᨿ, ᨸᩈᩣᩈᩣᨾᩥ ᨾᩉᩣᨾᩉᩥᩴ.

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

ᨧᨲᩪᩉᩥ ᩈᨦ᩠ᨣᩉᩅᨲ᩠ᨳᩪᩉᩥ, ᩈᨦ᩠ᨣᨱ᩠ᩉᩣᨾᩥ [ᩈᨦ᩠ᨣᩉᩣᨾᩥ (ᨠ.)] ᨾᩉᩣᨩᨶᩴ.

‘‘ᩑᩅᩴ ᨾᩮ ᩋᨸ᩠ᨸᨾᨲ᩠ᨲᩔ, ᩍᨵ ᩃᩮᩣᨠᩮ ᨸᩁᨲ᩠ᨳ ᨧ;

ᨴᨻ᩠ᨻᩈᩮᨶᩮᩣ ¶ ᩏᨸᨣᨶ᩠ᨲ᩠ᩅᩣ, ᩋᨧ᩠ᨨᩥᨶ᩠ᨴᨶ᩠ᨲᩮᩣ ᨸᩩᩁᩴ ᨾᨾ.

‘‘ᩁᩣᨩᩪᨸᨩᩦᩅᩮ ¶ ᨶᩥᨣᨾᩮ, ᩈᨻᩃᨭ᩠ᨮᩮ ᩈᩁᨭ᩠ᨮᨠᩮ;

ᩈᨻ᩠ᨻᩴ ᩉᨲ᩠ᨳᨣᨲᩴ ᨠᨲ᩠ᩅᩣ, ᨠᩣᩈᩩᨿᩣ ᨶᩥᨡᨱᩦ ᨾᨾᩴ.

‘‘ᩋᨾᨧ᩠ᨧᨾᨱ᩠ᨯᩃᩴ ᩁᨩ᩠ᨩᩴ, ᨹᩦᨲᩴ ᩋᨶ᩠ᨲᩮᨸᩩᩁᩴ ᨾᨾ;

ᩋᨧ᩠ᨨᩥᨶ᩠ᨴᩥᨲ᩠ᩅᩣᨶ ᨣᩉᩥᨲᩴ, ᨸᩥᨿᩴ ᨸᩩᨲ᩠ᨲᩴᩅ ᨸᩔᩉᩴ;

ᨾᩮᨲ᩠ᨲᩣᨿ ᨾᩮ ᩈᨾᩮᩣ ᨶᨲ᩠ᨳᩥ, ᩑᩈᩣ ᨾᩮ ᨾᩮᨲ᩠ᨲᩣᨸᩣᩁᨾᩦ’’ᨲᩥ.

‘‘ᩈᩩᩈᩣᨶᩮ ¶ ¶ ᩈᩮᨿ᩠ᨿᩴ ᨠᨸ᩠ᨸᩮᨾᩥ, ᨨᩅᨭ᩠ᨮᩥᨠᩴ ᩏᨸᨶᩥᨵᩣᨿᩉᩴ;

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

‘‘ᩋᨸᩁᩮ ᨣᨶ᩠ᨵᨾᩣᩃᨬ᩠ᨧ, ᨽᩮᩣᨩᨶᩴ ᩅᩥᩅᩥᨵᩴ ᨻᩉᩩᩴ;

ᩏᨸᩣᨿᨶᩣᨶᩪᨸᨶᩮᨶ᩠ᨲᩥ, ᩉᨭ᩠ᨮᩣ ᩈᩴᩅᩥᨣ᩠ᨣᨾᩣᨶᩈᩣ.

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

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

‘‘ᩈᩩᨡᨴᩩᨠ᩠ᨡᩮ ᨲᩩᩃᩣᨽᩪᨲᩮᩣ, ᨿᩈᩮᩈᩩ ᩋᨿᩈᩮᩈᩩ ᨧ;

ᩈᨻ᩠ᨻᨲ᩠ᨳ ᩈᨾᨠᩮᩣ ᩉᩮᩣᨾᩥ, ᩑᩈᩣ ᨾᩮ ᩏᨸᩮᨠ᩠ᨡᩣᨸᩣᩁᨾᩦ’’ᨲᩥ.

ᨿᩩᨵᨬ᩠ᨩᨿᩮᩣ ᩈᩮᩣᨾᨶᩔᩮᩣ, ᩋᨿᩮᩣᨥᩁᨽᩥᩈᩮᨶ ᨧ;

ᩈᩮᩣᨱᨶᨶ᩠ᨴᩮᩣ ᨾᩪᨣᨸᨠ᩠ᨡᩮᩣ, ᨠᨸᩥᩁᩣᨩᩣ ᩈᨧ᩠ᨧᩈᩅ᩠ᩉᨿᩮᩣ.

ᩅᨭ᩠ᨭᨠᩮᩣ ᨾᨧ᩠ᨨᩁᩣᨩᩣ ᨧ, ᨠᨱ᩠ᩉᨴᩦᨸᩣᨿᨶᩮᩣ ᩍᩈᩥ;

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

ᩏᨸᩮᨠ᩠ᨡᩣᨸᩣᩁᨾᩦ ᩌᩈᩥ, ᩍᨲᩥ ᩅᩩᨲ᩠ᨳᩴ [ᩅᩩᨲ᩠ᨲᩴ (ᩈᨻ᩠ᨻᨲ᩠ᨳ) ᩋᨭ᩠ᨮᨠᨳᩣ ᩒᩃᩮᩣᨠᩮᨲᨻ᩠ᨻᩣ] ᨾᩉᩮᩈᩥᨶᩣ.

ᩑᩅᩴ ¶ ᨻᩉᩩᨻ᩠ᨻᩥᨵᩴ ᨴᩩᨠ᩠ᨡᩴ, ᩈᨾ᩠ᨸᨲ᩠ᨲᩦ ᨧ ᨻᩉᩩᨻ᩠ᨻᩥᨵᩣ [ᩈᨾ᩠ᨸᨲ᩠ᨲᩥ ᨧ ᨻᩉᩩᩅᩥᨵᩣ (ᩈᩦ.), ᩈᨾ᩠ᨸᨲ᩠ᨲᩥᩴ ᨧ ᨻᩉᩩᩅᩥᨵᩴ (ᨠ.)];

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

ᨴᨲ᩠ᩅᩣ ᨴᩣᨲᨻ᩠ᨻᨠᩴ ᨴᩣᨶᩴ, ᩈᩦᩃᩴ ᨸᩪᩁᩮᨲ᩠ᩅᩣ ᩋᩈᩮᩈᨲᩮᩣ;

ᨶᩮᨠ᩠ᨡᨾ᩠ᨾᩮ ᨸᩣᩁᨾᩥᩴ ᨣᨶ᩠ᨲ᩠ᩅᩣ, ᨸᨲ᩠ᨲᩮᩣ ᩈᨾ᩠ᨻᩮᩣᨵᩥᨾᩩᨲ᩠ᨲᨾᩴ.

ᨸᨱ᩠ᨯᩥᨲᩮ ¶ ᨸᩁᩥᨸᩩᨧ᩠ᨨᩥᨲ᩠ᩅᩣ, ᩅᩦᩁᩥᨿᩴ ᨠᨲ᩠ᩅᩣᨶ ᨾᩩᨲ᩠ᨲᨾᩴ;

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

ᨠᨲ᩠ᩅᩣ ᨴᩊ᩠ᩉᨾᨵᩥᨭ᩠ᨮᩣᨶᩴ, ᩈᨧ᩠ᨧᩅᩣᨧᩣᨶᩩᩁᨠ᩠ᨡᩥᨿ;

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

ᩃᩣᨽᩣᩃᩣᨽᩮ ¶ ᨿᩈᩣᨿᩈᩮ, ᩈᨾ᩠ᨾᩣᨶᨶᩣᩅᨾᩣᨶᨶᩮ;

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

ᨠᩮᩣᩈᨩ᩠ᨩᩴ ᨽᨿᨲᩮᩣ ᨴᩥᩈ᩠ᩅᩣ, ᩅᩦᩁᩥᨿᩣᩁᨾ᩠ᨽᨬ᩠ᨧ ᨡᩮᨾᨲᩮᩣ;

ᩌᩁᨴ᩠ᨵᩅᩦᩁᩥᨿᩣ ᩉᩮᩣᨳ, ᩑᩈᩣ ᨻᩩᨴ᩠ᨵᩣᨶᩩᩈᩣᩈᨶᩦ.

ᩅᩥᩅᩣᨴᩴ ᨽᨿᨲᩮᩣ ᨴᩥᩈ᩠ᩅᩣ, ᩋᩅᩥᩅᩣᨴᨬ᩠ᨧ ᨡᩮᨾᨲᩮᩣ;

ᩈᨾᨣ᩠ᨣᩣ ᩈᨡᩥᩃᩣ ᩉᩮᩣᨳ, ᩑᩈᩣ ᨻᩩᨴ᩠ᨵᩣᨶᩩᩈᩣᩈᨶᩦ.

ᨸᨾᩣᨴᩴ ᨽᨿᨲᩮᩣ ᨴᩥᩈ᩠ᩅᩣ, ᩋᨸ᩠ᨸᨾᩣᨴᨬ᩠ᨧ ᨡᩮᨾᨲᩮᩣ;

ᨽᩣᩅᩮᨳᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩴ ᨾᨣ᩠ᨣᩴ, ᩑᩈᩣ ᨻᩩᨴ᩠ᨵᩣᨶᩩᩈᩣᩈᨶᩦ.

ᩍᨲ᩠ᨳᩴ ᩈᩩᨴᩴ ᨽᨣᩅᩣ ᩋᨲ᩠ᨲᨶᩮᩣ ᨸᩩᨻ᩠ᨻᨧᩁᩥᨿᩴ ᩈᨾ᩠ᨽᩣᩅᨿᨾᩣᨶᩮᩣ ᨻᩩᨴ᩠ᨵᩣᨸᨴᩣᨶᩥᨿᩴ ᨶᩣᨾ ᨵᨾ᩠ᨾᨸᩁᩥᨿᩣᨿᩴ ᩋᨽᩣᩈᩥᨲ᩠ᨳᩣᨲᩥ.