ᩋᨬ᩠ᨬ > ᨻ᩠ᨿᩣᨠᩁᨱ ᨣᨶ᩠ᨳ-ᩈᨦ᩠ᨣᩉᩮᩣ > ᩋᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩣᨸᩣᨮ

MMR Vol 0

Misc. Paragraph

ᩋᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩣ

ᨻᩩᨴ᩠ᨵᨸ᩠ᨸᨱᩣᨾᩮᩣ

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

ᩈᩩᨸᩩᨬ᩠ᨬᨡᩮᨲ᩠ᨲᩴ ᨽᩩᩅᨶᩮ ᩈᩩᨲᩴ ᩈᩩᨲᩴ;

ᨶᩣᨾᩃᩥᨦ᩠ᨣᩮᩈᩩ ᨠᩮᩣᩈᩃ᩠ᩃ, ᨾᨲ᩠ᨳᨶᩥᨧ᩠ᨨᨿᨠᩣᩁᨱᩴ;

ᨿᨲᩮᩣ ᨾᩉᨻ᩠ᨻᩃᩴ ᨻᩩᨴ᩠ᨵ, ᩅᨧᨶᩮ ᨸᩣᨭᩅᨲ᩠ᨳᩥᨶᩴ.

ᨶᩣᨾᩃᩥᨦ᩠ᨣᩣᨶ᩠ᨿ’ᨲᩮᩣ ¶ ᨻᩩᨴ᩠ᨵ, ᨽᩣᩈᩥᨲᩔᩣ’ᩁᩉᩣᨶ᩠ᨿ’ᩉᩴ;

ᨴᩔᨿᨶ᩠ᨲᩮᩣ ᨸᨠᩣᩈᩮᩔ, ᨾᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩴ.

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

ᨠ᩠ᩅᨧᩣ’ ᩉᨧ᩠ᨧᩅᩥᨵᩣᨶᩮᨶ ᨬᩮᨿ᩠ᨿᩴ ᨳᩦᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩴ.

ᩋᨽᩥᨶ᩠ᨶᩃᩥᨦ᩠ᨣᩣᨶᩴᨿᩮᩅ, ᨴ᩠ᩅᨶ᩠ᨴᩮᩣ ᨧ, ᩃᩥᨦ᩠ᨣᩅᩣᨧᨠᩣ;

ᨣᩣᨳᩣᨸᩣᨴᨶ᩠ᨲᨾᨩ᩠ᨫᨭ᩠ᨮᩣ, ᨸᩩᨻ᩠ᨻᩴ ᨿᨶ᩠ᨲ᩠ᨿᨸᩁᩮ ᨸᩁᩴ.

ᨸᩩᨾᩥᨲ᩠ᨳᩥᨿᩴ ᨸᨴᩴ ᨴ᩠ᩅᩦᩈᩩ, ᩈᨻ᩠ᨻᩃᩥᨦ᩠ᨣᩮ ᨧ ᨲᩦᩈ᩠ᩅᩥᨲᩥ;

ᩋᨽᩥᨵᩣᨶᨶ᩠ᨲᩁᩣᩁᨾ᩠ᨽᩮ, ᨬᩮᨿ᩠ᨿᩴ ᨲ᩠ᩅ’ᨶ᩠ᨲ ᨾᨳᩣᨴᩥ ᨧ.

ᨽᩥᨿ᩠ᨿᩮᩣ ᨸᨿᩮᩣᨣ ᨾᩣᨣᨾ᩠ᨾ, ᩈᩮᩣᨣᨲᩮ ᩌᨣᨾᩮ ᨠ᩠ᩅᨧᩥ;

ᨶᩥᨥᨱ᩠ᨯᩩ ᨿᩩᨲ᩠ᨲᩥ ᨬ᩠ᨧᩣᨶᩦᨿ, ᨶᩣᨾᩃᩥᨦ᩠ᨣᩴ ᨠᨳᩦᨿᨲᩦᨲᩥ.

ᨻᩩᨴ᩠ᨵᩮᩣ ᨴᩈᨻᩃᩮᩣ ᩈᨲ᩠ᨳᩣ, ᩈᨻ᩠ᨻᨬ᩠ᨬᩪ ᨴ᩠ᩅᩥᨸᨴᩩᨲ᩠ᨲᨾᩮᩣ;

ᨾᩩᨶᩥᨶ᩠ᨴᩮᩣ ᨽᨣᩅᩣ ᨶᩣᨳᩮᩣ, ᨧᨠ᩠ᨡᩩᨾ’ᨦ᩠ᨣᩦᩁᩈᩮᩣ ᨾᩩᨶᩥ.

ᩃᩮᩣᨠᨶᩣᨳᩮᩣ’ ᨶᨵᩥᩅᩁᩮᩣ, ᨾᩉᩮᩈᩥ ᨧ ᩅᩥᨶᩣᨿᨠᩮᩣ;

ᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩩ ᩈᩩᨣᨲᩮᩣ, ᨽᩪᩁᩥᨸᨬ᩠ᨬᩮᩣ ᨧ ᨾᩣᩁᨩᩥ.

ᨶᩁᩈᩦᩉᩮᩣ ᨶᩁᩅᩁᩮᩣ, ᨵᨾ᩠ᨾᩁᩣᨩᩣ ᨾᩉᩣᨾᩩᨶᩥ;

ᨴᩮᩅᨴᩮᩅᩮᩣ ᩃᩮᩣᨠᨣᩁᩩ, ᨵᨾ᩠ᨾᩔᩣᨾᩦ ᨲᨳᩣᨣᨲᩮᩣ.

ᩈᨿᨾ᩠ᨽᩪ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ, ᩅᩁᨸᨬ᩠ᨬᩮᩣ ᨧ ᨶᩣᨿᨠᩮᩣ;

ᨩᩥᨶᩮᩣ, ᩈᨠ᩠ᨠᩮᩣ ᨲᩩ ᩈᩥᨴ᩠ᨵᨲ᩠ᨳᩮᩣ, ᩈᩩᨴ᩠ᨵᩮᩣᨴᨶᩥ ᨧ ᨣᩮᩣᨲᨾᩮᩣ.

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

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

ᨲᩣᨱᩴ ᩃᩮᨱ ᨾᩁᩪᨸᨬ᩠ᨧ, ᩈᨶ᩠ᨲᩴ ᩈᨧ᩠ᨧ ᨾᨶᩣᩃᨿᩴ.

ᨴᩩᨠ᩠ᨡᨠ᩠ᨡᨿᩮᩣ ¶ ᨻ᩠ᨿᩣᨻᨩ᩠ᨫᨬ᩠ᨧ [ᨻ᩠ᨿᩣᨸᨩ᩠ᨩᩴ (ᨭᩦᨠᩣ)], ᩅᩥᩅᨭ᩠ᨭᩴ ᨡᩮᨾ ᨠᩮᩅᩃᩴ;

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

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

ᩅᩥᨾᩩᨲ᩠ᨿ’ ᩈᨦ᩠ᨡᨲᨵᩣᨲᩩ, ᩈᩩᨴ᩠ᨵᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩥᨿᩮᩣ ᩈᩥᨿᩩᩴ.

ᨡᩦᨱᩣᩈᩅᩮᩣ ᨲ᩠ᩅ’ᩈᩮᨠ᩠ᨡᩮᩣ ᨧ, ᩅᩦᨲᩁᩣᨣᩮᩣ ᨲᨳᩣ’ ᩁᩉᩣ;

ᨴᩮᩅᩃᩮᩣᨠᩮᩣ ᨴᩥᩅᩮᩣ ᩈᨣ᩠ᨣᩮᩣ [ᨶᩣᨠᩮᩣ (ᩈᩦ.)],

ᨲᩥᨴᩈᩣ ᨲ᩠ᩅ’ᨾᩁᩣ ᨴᩮᩅᩣ, ᩅᩥᨻᩩᨵᩣ ᨧ ᩈᩩᨵᩣᩈᩥᨶᩮᩣ;

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

ᨶᩥᨩ᩠ᨩᩁᩣ’ ᨶᩥᨾᩥᩈᩣ ᨴᩥᨻ᩠ᨻᩣ, ᩋᨸᩩᨾᩮ ᨴᩮᩅᨲᩣᨶᩥ ᨧ [ᨴᩮᩅᨲᩣ ᩑᩅ ᨴᩮᩅᨲᩣᨶᩥ, ᩈᨠᨲ᩠ᨳᩮ ᨶᩥᨸᨧ᩠ᨧᨿᩮᩣ (ᨭᩦᨠᩣ)];

ᩈᩥᨴ᩠ᨵᩮᩣ ᨽᩪᨲᩮᩣ ᨧ ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ, ᨣᩩᨿ᩠ᩉᨠᩮᩣ ᨿᨠ᩠ᨡ ᩁᨠ᩠ᨡᩈᩣ;

ᨠᩩᨾ᩠ᨽᨱ᩠ᨯᩮᩣ ᨧ ᨸᩥᩈᩣᨧᩣ’ᨴᩦ, ᨶᩥᨴ᩠ᨴᩥᨭ᩠ᨮᩣ ᨴᩮᩅᨿᩮᩣᨶᩥᨿᩮᩣ.

ᨸᩩᨻ᩠ᨻᨴᩮᩅᩣ ᩈᩩᩁᩁᩥᨸᩪ, ᩋᩈᩩᩁᩣ ᨴᩣᨶᩅᩣ ᨸᩩᨾᩮ;

ᨲᨻ᩠ᨻᩥᩈᩮᩈᩣ ᨸᩉᩣᩁᩣᨴᩮᩣ, ᩈᨾ᩠ᨻᩁᩮᩣ ᨻᩃᩥᩌᨴᨿᩮᩣ.

ᨸᩥᨲᩣᨾᩉᩮᩣ ᨸᩥᨲᩣ ᨻᩕᩉ᩠ᨾᩣ, ᩃᩮᩣᨠᩮᩈᩮᩣ ᨠᨾᩃᩣᩈᨶᩮᩣ;

ᨲᨳᩣ ᩉᩥᩁᨬ᩠ᨬᨣᨻ᩠ᨽᩮᩣ ᨧ, ᩈᩩᩁᨩᩮᨭ᩠ᨮᩮᩣ ᨸᨩᩣᨸᨲᩥ.

ᩅᩣᩈᩩᨴᩮᩅᩮᩣ ᩉᩁᩥ [ᩉᩁᩦ (ᨭᩦᨠᩣ)] ᨠᨱ᩠ᩉᩮᩣ, ᨠᩮᩈᩅᩮᩣ ᨧᨠ᩠ᨠᨸᩣᨱ᩠ᨿ’ᨳ;

ᨾᩉᩥᩔᩁᩮᩣ ᩈᩥᩅᩮᩣ ᩈᩪᩃᩦ, ᩍᩔᩁᩮᩣ ᨸᩈᩩᨸᨲ᩠ᨿ’ᨸᩥ.

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

ᩈᨠ᩠ᨠᩮᩣ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ ᨴᩮᩅ, ᩁᩣᨩᩣ ᩅᨩᩥᩁᨸᩣᨱᩥ ᨧ;

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

ᩅᩣᩈᩅᩮᩣ ᨧ ᨴᩈᩈᨲ, ᨶᨿᨶᩮᩣ ᨲᩥᨴᩥᩅᩣᨵᩥᨽᩪ;

ᩈᩩᩁᨶᩣᨳᩮᩣ ᨧ ᩅᨩᩥᩁ, ᩉᨲ᩠ᨳᩮᩣ ᨧ ᨽᩪᨲᨸᨲ᩠ᨿ’ᨸᩥ.

ᨾᨥᩅᩣ ᨠᩮᩣᩈᩥᨿᩮᩣ ᩍᨶ᩠ᨴᩮᩣ, ᩅᨲᩕᨽᩪ ᨸᩣᨠᩈᩣᩈᨶᩮᩣ;

ᩅᩥᨯᩮᩣᨩᩮᩣ ᨳ ᩈᩩᨩᩣ ᨲᩔ [ᩈᩩᨩᩣᨲᩣ’ᩔ (ᨭᩦᨠᩣ)], ᨽᩁᩥᨿᩣ ᨳ ᨸᩩᩁᩴ ᨽᩅᩮ.

ᨾᩈᨠ᩠ᨠᩈᩣᩁᩣ ¶ [ᨾᩈᨠ᩠ᨠᩈᩣᩁᩮᩣ (ᩈᩦ.)] ᩅᩔᩮᩣᨠ, ᩈᩣᩁᩣ ᨧᩮᩅᩣ’ ᨾᩁᩣᩅᨲᩦ;

ᩑᩁᩣᩅᨱᩮᩣ ᨣᨩᩮᩣ ᨸᨱ᩠ᨯᩩ, ᨠᨾ᩠ᨻᩃᩮᩣ ᨲᩩ ᩈᩥᩃᩣᩈᨶᩴ.

ᩈᩩᩅᩦᩁᩮᩣᨧ᩠ᨧᩣᨴᨿᩮᩣ ᨸᩩᨲ᩠ᨲᩣ, ᨶᨶ᩠ᨴᩣ ᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ ᨽᩅᩮ;

ᨶᨶ᩠ᨴᨶᩴ ᨾᩥᩔᨠᩴ ᨧᩥᨲ᩠ᨲ, ᩃᨲᩣ ᨹᩣᩁᩩᩈᨠᩴ ᩅᨶᩣ.

ᩋᩈᨶᩥ ᨴ᩠ᩅᩦᩈᩩ ᨠᩩᩃᩥᩈᩴ, ᩅᨩᩥᩁᩴ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ;

ᩋᨧ᩠ᨨᩁᩣᨿᩮᩣᨲ᩠ᨳᩥᨿᩴ ᩅᩩᨲ᩠ᨲᩣ, ᩁᨾ᩠ᨽᩣ ᩋᩃᨾ᩠ᨻᩩᩈᩣᨴᨿᩮᩣ;

ᨴᩮᩅᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨳ ᨣᨶ᩠ᨵᨻ᩠ᨻᩣ, ᨸᨬ᩠ᨧᩈᩥᨡᩮᩣᨲᩥ ᩌᨴᨿᩮᩣ.

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

ᩈᩥᨶᩮᩁᩩ ᨾᩮᩁᩩ ᨲᩥᨴᩥᩅᩣ, ᨵᩣᩁᩮᩣ ᨶᩮᩁᩩ ᩈᩩᨾᩮᩁᩩ ᨧ.

ᨿᩩᨣᨶ᩠ᨵᩁᩮᩣ ᩎᩈᨵᩁᩮᩣ, ᨠᩁᩅᩦᨠᩮᩣ ᩈᩩᨴᩔᨶᩮᩣ;

ᨶᩮᨾᩥᨶ᩠ᨵᩁᩮᩣ ᩅᩥᨶᨲᨠᩮᩣ, ᩋᩔᨠᨱ᩠ᨱᩮᩣ ᨠᩩᩃᩣᨧᩃᩣ.

ᨾᨶ᩠ᨴᩣᨠᩥᨶᩦ ᨲᨳᩣ’ᨠᩣᩈ, ᨣᨦ᩠ᨣᩣ ᩈᩩᩁᨶᨴᩦ ᨸ᩠ᨿᨳ;

ᨠᩮᩣᩅᩥᩊᩣᩁᩮᩣ ᨲᨳᩣ ᨸᩣᩁᩥ, ᨧ᩠ᨨᨲ᩠ᨲᨠᩮᩣ ᨸᩣᩁᩥᨩᩣᨲᨠᩮᩣ;

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

ᨸᩣᨧᩦ ᨸᨲᩦᨫᩩ’ ᨴᩦᨧᩥ’ᨲ᩠ᨳᩦ, ᨸᩩᨻ᩠ᨻ ᨸᨧ᩠ᨨᩥᨾ ᩏᨲ᩠ᨲᩁᩣ;

ᨴᩥᩈᩣᨳ ᨴᨠ᩠ᨡᩥᨱᩣ’ ᨸᩣᨧᩦ, ᩅᩥᨴᩥᩈᩣ’ᨶᩩᨴᩥᩈᩣ ᨽᩅᩮ.

ᩑᩁᩣᩅᨲᩮᩣ [ᩑᩁᩣᩅᨱᩮᩣ (ᩈᩦ.), ᩋᨾᩁᨠᩮᩣᩈᩮ ᨸᨶ ᩑᩁᩣᩅᨲᩮᩣ ᩑᩅ ᩋᨲ᩠ᨳᩥ] ᨸᩩᨱ᩠ᨯᩁᩦᨠᩮᩣ, ᩅᩣᨾᨶᩮᩣ ᨠᩩᨾᩩᨴᩮᩣ’ ᨬ᩠ᨩᨶᩮᩣ;

ᨸᩩᨸ᩠ᨹᨴᨶ᩠ᨲᩮᩣ ᩈᨻ᩠ᨻᨽᩩᨾ᩠ᨾᩮᩣ, ᩈᩩᨸ᩠ᨸᨲᩦᨠᩮᩣ ᨴᩥᩈᩣᨣᨩᩣ.

ᨵᨲᩁᨭ᩠ᨮᩮᩣ ᨧ ᨣᨶ᩠ᨵᨻ᩠ᨻᩣ, ᨵᩥᨸᩮᩣ, ᨠᩩᨾ᩠ᨽᨱ᩠ᨯᩈᩣᨾᩥ ᨲᩩ;

ᩅᩥᩁᩩᩊ᩠ᩉᨠᩮᩣ, ᩅᩥᩁᩪᨸᨠ᩠ᨡᩮᩣ, ᨲᩩ ᨶᩣᨣᩣᨵᩥᨸᨲᩦᩁᩥᨲᩮᩣ.

ᨿᨠ᩠ᨡᩣᨵᩥᨸᩮᩣ ᩅᩮᩔᩅᨱᩮᩣ, ᨠᩩᩅᩮᩁᩮᩣ ᨶᩁᩅᩣᩉᨶᩮᩣ;

ᩋᩊᨠᩣ [ᩋᩃᨠᩣ (ᩋᨾᩁᨠᩮᩣᩈ)] ᩊᨠᨾᨶ᩠ᨴᩣᩔ, ᨸᩩᩁᩦ, ᨸᩉᩁᨱᩴ ᨣᨴᩣ;

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

ᨩᩣᨲᩅᩮᨴᩮᩣ ¶ ᩈᩥᨡᩦ ᨩᩮᩣᨲᩥ, ᨸᩣᩅᨠᩮᩣ ᨴᩉᨶᩮᩣ’ ᨶᩃᩮᩣ;

ᩉᩩᨲᩣᩅᩉᩮᩣ’ ᨧ᩠ᨧᩥᨾᩣ ᨵᩪᨾ, ᨠᩮᨲ᩠ᩅ’ᨣ᩠ᨣᩥ ᨣᩥᨶᩥ ᨽᩣᨶᩩᨾᩣ.

ᨲᩮᨩᩮᩣ ᨵᩪᨾᩈᩥᨡᩮᩣ ᩅᩣᨿᩩ, ᩈᨡᩮᩣ ᨧ ᨠᨱ᩠ᩉᩅᨲ᩠ᨲᨶᩦ;

ᩅᩮᩔᩣᨶᩁᩮᩣ ᩉᩩᨲᩣᩈᩮᩣ ᨳ, ᩈᩥᨡᩣᨩᩣᩃ’ᨧ᩠ᨧᩥ ᨧᩣᨸᩩᨾᩮ.

ᩅᩥᨸ᩠ᨹᩩᩃᩥᨦ᩠ᨣᩴ ᨹᩩᩃᩥᨦ᩠ᨣᨬ᩠ᨧ, ᨽᩈ᩠ᨾᩣ [‘ᨽᩈ᩠ᨾᩣ’ ᨲᩥᨸᨴᩴ ᩁᩣᨩᩣᨴᩥᨣᨱᩮ ᨸᩁᩥᨿᩣᨸᨶ᩠ᨶᩴ (ᩁᩪᨸᩈᩥᨴ᩠ᨵᩥ-ᩏᨱᩣᨴᩥ), ᨽᩈ᩠ᨾᩴ (ᩈᩦ.)] ᨲᩩ ᩈᩮᨭ᩠ᨮᩥ ᨨᩣᩁᩥᨠᩣ;

ᨠᩩᨠ᩠ᨠᩩᩊᩮᩣ ᨲᩩ’ᨱ᩠ᩉᨽᩈ᩠ᨾᩈ᩠ᨾᩥ, ᨾᨦ᩠ᨣᩣᩁᩮᩣ’ᩃᩣᨲ ᨾᩩᨾ᩠ᨾᩩᨠᩴ [ᨲᩥᨠᩴ ᨴᩥᨲ᩠ᨲᨠᨭ᩠ᨮᩣᨴᩥᨶ᩠ᨵᨶᩮ (ᨭᩦᨠᩣ)];

ᩈᨾᩥᨵᩣ ᩍᨵᩩᨾᩴ ᨧᩮ’ᨵᩮᩣ, ᩏᨸᩣᨴᩣᨶᩴ ᨲᨳᩥᨶ᩠ᨵᨶᩴ.

ᨾᩣᩃᩩᨲᩮᩣ ᨸᩅᨶᩮᩣ ᩅᩣᨿᩩ, ᩅᩣᨲᩮᩣ’ᨶᩥᩃ ᩈᨾᩦᩁᨱᩣ;

ᨣᨶ᩠ᨵᩅᩣᩉᩮᩣ ᨲᨳᩣ ᩅᩣᨿᩮᩣ, ᩈᨾᩦᩁᩮᩣ ᨧ ᩈᨴᩣᨣᨲᩥ.

ᩅᩣᨿᩩᨽᩮᨴᩣ ᩍᨾᩮ ᨨᩩ’ᨴ᩠ᨵ, ᨦ᩠ᨣᨾᩮᩣ ᨧᩣᨵᩮᩣᨣᨾᩮᩣ ᨲᨳᩣ;

ᨠᩩᨧ᩠ᨨᩥᨭ᩠ᨮᩮᩣ ᨧ ᨠᩮᩣᨭ᩠ᨮᩣᩈᨿᩮᩣ, ᩋᩔᩣᩈᨦ᩠ᨣᩣᨶᩩᩈᩣᩁᩥᨶᩮᩣ.

ᩅᩮᨣᩮᩣ ᨩᩅᩮᩣ ᩁᨿᩮᩣ ᨡᩥᨸ᩠ᨸᩴ, ᨲᩩ ᩈᩦᨥᩴ ᨲᩩᩁᩥᨲᩴ ᩃᩉᩩ;

ᩌᩈᩩ ᨲᩩᨱ᩠ᨱ ᨾᩁᩴ ᨧᩣᩅᩥ, ᩃᨾ᩠ᨻᩥᨲᩴ ᨲᩩᩅᨭᩴᨸᩥ ᨧ.

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

ᨽᩩᩈ ᨾᨲᩥᩈᨿᩮᩣ ᨧ ᨴᩊ᩠ᩉᩴ, ᨲᩥᨻ᩠ᨻᩮ’ᨠᨶ᩠ᨲᩣ’ᨲᩥᨾᨲ᩠ᨲ, ᨻᩣᩊ᩠ᩉᩣᨶᩥ;

ᨡᩥᨸ᩠ᨸᩣᨴᩦ ᨸᨱ᩠ᨯᨠᩮ ᨴᨻ᩠ᨻᩮ, ᨴᨻ᩠ᨻᨣᩣ ᨲᩮᩈᩩ ᨿᩮ ᨲᩥᩈᩩ.

ᩋᩅᩥᨣ᩠ᨣᩉᩮᩣ ᨲᩩ ᨠᩣᨾᩮᩣ ᨧ, ᨾᨶᩮᩣᨽᩪ ᨾᨴᨶᩮᩣ ᨽᩅᩮ;

ᩋᨶ᩠ᨲᨠᩮᩣ ᩅᩈᩅᨲ᩠ᨲᩦ ᨧ, ᨸᩣᨸᩥᨾᩣ ᨧ ᨸᨩᩣᨸᨲᩥ.

ᨸᨾᨲ᩠ᨲᨻᨶ᩠ᨵᩩ ᨠᨱ᩠ᩉᩮᩣ ᨧ, ᨾᩣᩁᩮᩣ ᨶᨾᩩᨧᩥ, ᨲᩔ ᨲᩩ;

ᨲᨱ᩠ᩉᩣ’ᩁᨲᩦ ᩁᨣᩣ ᨵᩦᨲᩪ, ᩉᨲ᩠ᨳᩦ ᨲᩩ ᨣᩥᩁᩥᨾᩮᨡᩃᩮᩣ.

ᨿᨾᩁᩣᨩᩣ ᨧ ᩅᩮᩈᩣᨿᩦ, ᨿᨾᩮᩣ’ᩔ ᨶᨿᨶᩣᩅᩩᨵᩴ;

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

ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩴ ᨡ’ᨾᩣᨴᩥᨧ᩠ᨧ, ᨸᨳᩮᩣ’ᨻ᩠ᨽᩴ ᨣᨣᨶ’ᨾ᩠ᨻᩁᩴ;

ᩅᩮᩉᩣᩈᩮᩣ ᨧᩣᨶᩥᩃᨸᨳᩮᩣ, ᩌᨠᩣᩈᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨶᨽᩴ.

ᨾᩮᨥᩮᩣ ᩅᩃᩣᩉᨠᩮᩣ ᨴᩮᩅᩮᩣ, ᨸᨩ᩠ᨩᩩᨶ᩠ᨶᩮᩣ’ᨾ᩠ᨻᩩᨵᩁᩮᩣ ᨥᨶᩮᩣ;

ᨵᩣᩁᩣᨵᩁᩮᩣ ᨧ ᨩᩦᨾᩪᨲᩮᩣ, ᩅᩣᩁᩥᩅᩣᩉᩮᩣ ᨲᨳᩣ’ᨾ᩠ᨻᩩᨴᩮᩣ.

ᩋᨻ᩠ᨽᩴ ᨲᩦᩈ᩠ᩅᨳ ᩅᩔᨬ᩠ᨧ, ᩅᩔᨶᩴ ᩅᩩᨭ᩠ᨮᩥ ᨶᩣᩁᩥᨿᩴ;

ᩈᨲᩮᩁᨲᩣ’ᨠ᩠ᨡᨱᩣ ᩅᩥᨩ᩠ᨩᩩ, ᩅᩥᨩ᩠ᨩᩩᨲᩣ ᨧᩣᨧᩥᩁᨸ᩠ᨸᨽᩣ.

ᨾᩮᨥᨶᩣᨴᩮ ᨲᩩ ᨵᨶᩥᨲᩴ, ᨣᨩ᩠ᨩᩥᨲᩴ ᩁᩈᩥᨲᩣᨴᩥ ᨧ;

ᩍᨶ᩠ᨴᩣᩅᩩᨵᩴ ᩍᨶ᩠ᨴᨵᨶᩩ, ᩅᩣᨲᨠ᩠ᨡᩥᨲ᩠ᨲᨾ᩠ᨻᩩ ᩈᩦᨠᩁᩮᩣ.

ᨴᩩᨴ᩠ᨴᩥᨶᩴ ᨾᩮᨥᨧ᩠ᨨᨶ᩠ᨶᩣᩉᩮ, ᨸᩥᨵᩣᨶᩴ ᨲ᩠ᩅᨸᨵᩣᩁᨱᩴ.

ᨲᩥᩁᩮᩣᨵᩣᨶ’ᨶ᩠ᨲᩁᨵᩣᨶᩣ, ᨸᩥᨵᩣᨶ ᨨᩣᨴᨶᩣᨶᩥ ᨧ;

ᩍᨶ᩠ᨴᩩ ᨧᨶ᩠ᨴᩮᩣ ᨧ ᨶᨠ᩠ᨡᨲ᩠ᨲ, ᩁᩣᨩᩣ ᩈᩮᩣᨾᩮᩣ ᨶᩥᩈᩣᨠᩁᩮᩣ.

ᩒᩈᨵᩦᩈᩮᩣ ᩉᩥᨾᩁᩴᩈᩥ, ᩈᩈᨦ᩠ᨠᩮᩣ ᨧᨶ᩠ᨴᩥᨾᩣ ᩈᩈᩦ;

ᩈᩦᨲᩁᩴᩈᩥ ᨶᩥᩈᩣᨶᩣᨳᩮᩣ, ᩏᩊᩩᩁᩣᨩᩣ ᨧ ᨾᩣ ᨸᩩᨾᩮ.

ᨠᩃᩣ ᩈᩮᩣᩊᩈᨾᩮᩣ ᨽᩣᨣᩮᩣ, ᨻᩥᨾ᩠ᨻᩴ ᨲᩩ ᨾᨱ᩠ᨯᩃᩴ ᨽᩅᩮ;

ᩋᨯ᩠ᨰᩮᩣ ᨲ᩠ᩅᨴ᩠ᨵᩮᩣ ᩏᨸᨯ᩠ᨰᩮᩣ ᨧ, ᩅᩣ ᨡᨱ᩠ᨯᩴ ᩈᨠᩃᩴ ᨸᩩᨾᩮ.

ᩋᨴ᩠ᨵᩴ ᩅᩩᨲ᩠ᨲᩴ ᩈᨾᩮ ᨽᩣᨣᩮ, ᨸᩈᩣᨴᩮᩣ ᨲᩩ ᨸᩈᨶ᩠ᨶᨲᩣ;

ᨠᩮᩣᨾᩩᨴᩦ ᨧᨶ᩠ᨴᩥᨠᩣ ᨩᩩᨱ᩠ᩉᩣ, ᨠᨶ᩠ᨲᩥ ᩈᩮᩣᨽᩣ ᨩᩩᨲᩥ ᨧ᩠ᨨᩅᩥ.

ᨠᩃᨦ᩠ᨠᩮᩣ ᩃᨬ᩠ᨨᨶᩴ ᩃᨠ᩠ᨡᩴ, ᩋᨦ᩠ᨠᩮᩣ’ᨽᩥᨬ᩠ᨬᩣᨱ ᩃᨠ᩠ᨡᨱᩴ;

ᨧᩥᩉᨶᩴ ᨧᩣᨸᩥ ᩈᩮᩣᨽᩣ ᨲᩩ, ᨸᩁᨾᩣ ᩈᩩᩈᨾᩣ ᨳ ᨧ.

ᩈᩦᨲᩴ ᨣᩩᨱᩮ, ᨣᩩᨱᩥᩃᩥᨦ᩠ᨣᩣ, ᩈᩦᨲ ᩈᩥᩈᩥᩁ ᩈᩦᨲᩃᩣ;

ᩉᩥᨾᩴ ᨲᩩᩉᩥᨶ ᨾᩩᩔᩣᩅᩮᩣ, ᨶᩦᩉᩣᩁᩮᩣ ᨾᩉᩥᨠᩣ ᨸ᩠ᨿᨳ.

ᨶᨠ᩠ᨡᨲ᩠ᨲᩴ ᨩᩮᩣᨲᩥ ᨽᩴ ᨲᩣᩁᩣ, ᩋᨸᩩᨾᩮ ᨲᩣᩁᨠᩮᩣ’ᩊᩩ ᨧ;

ᩋᩔᨿᩩᨩᩮᩣ ᨽᩁᨱᩥᨲ᩠ᨳᩦ, ᩈᨠᨲ᩠ᨲᩥᨠᩣ ᩁᩮᩣᩉᩥᨱᩦ ᨸᩥᨧ;

ᨾᩥᨣᩈᩥᩁ [ᨾᨣᩈᩥᩁ (ᩈᩦ.)] ᨾᨴ᩠ᨴᩣ ᨧ ᨸᩩᨶᨻ᩠ᨻᩈᩩ, ᨹᩩᩔᩮᩣ [ᨸᩩᩔᩮᩣ (ᨭᩦ.)] ᨧᩣᩈᩥᩃᩮᩈ’ᨸᩥ.

ᨾᩣᨥᩣ [ᨾᨥ (ᩈᩦ.)] ᨧ ᨹᨣ᩠ᨣᩩᨶᩦ ᨴ᩠ᩅᩮ ᨧ, ᩉᨲ᩠ᨳᩣ ᨧᩥᨲ᩠ᨲᩣ ᨧ ᩈ᩠ᩅᩣᨲᩥᨸᩥ;

ᩅᩥᩈᩣᨡᩣ’ ᨶᩩᩁᩣᨵᩣ ᨩᩮᨭ᩠ᨮᩣ, ᨾᩪᩃᩣ’ ᩈᩣᩊ᩠ᩉᩣ ᨴᩩᩅᩮ ᨲᨳᩣ.

ᩈᩅᨱᩮᩣ ¶ ᨧ ᨵᨶᩥᨭ᩠ᨮᩣ ᨧ, ᩈᨲᨽᩥᩈᨩᩮᩣ ᨸᩩᨻ᩠ᨻᩩ’ᨲ᩠ᨲᩁᨽᨴ᩠ᨴᨸᨴᩣ;

ᩁᩮᩅᨲ᩠ᨿᨸᩦᨲᩥ ᨠᨾᨲᩮᩣ, ᩈᨲ᩠ᨲᩣᨵᩥᨠᩅᩦᩈᨶᨠ᩠ᨡᨲ᩠ᨲᩣ.

ᩈᩮᩣᨻ᩠ᨽᩣᨶᩩ ᨠᨳᩥᨲᩮᩣ ᩁᩣᩉᩩ, ᩈᩪᩁᩣᨴᩦ ᨲᩩ ᨶᩅᨣ᩠ᨣᩉᩣ;

ᩁᩣᩈᩥ ᨾᩮᩈᩣᨴᩥᨠᩮᩣ ᨽᨴ᩠ᨴ, ᨸᨴᩣ ᨸᩮᩣᨭ᩠ᨮᨸᨴᩣ ᩈᨾᩣ.

ᩌᨴᩥᨧ᩠ᨧᩮᩣ ᩈᩪᩁᩥᨿᩮᩣ ᩈᩪᩁᩮᩣ, ᩈᨲᩁᩴᩈᩥ ᨴᩥᩅᩣᨠᩁᩮᩣ;

ᩅᩮᩁᩮᩣᨧᨶᩮᩣ ᨴᩥᨶᨠᩁᩮᩣ, ᩏᨱ᩠ᩉᩁᩴᩈᩥ ᨸᨽᨦ᩠ᨠᩁᩮᩣ.

ᩋᩴᩈᩩᨾᩣᩃᩦ ᨴᩥᨶᨸᨲᩥ, ᨲᨸᨶᩮᩣ ᩁᩅᩥ ᨽᩣᨶᩩᨾᩣ;

ᩁᩴᩈᩥᨾᩣ ᨽᩣᨠᩁᩮᩣ ᨽᩣᨶᩩ, ᩋᨠ᩠ᨠᩮᩣ ᩈᩉᩔᩁᩴᩈᩥ ᨧ.

ᩁᩴᩈᩥ ᩌᨽᩣ ᨸᨽᩣ ᨴᩥᨲ᩠ᨲᩥ, ᩁᩩᨧᩥ ᨽᩣ ᨩᩩᨲᩥ ᨴᩦᨵᩥᨲᩥ;

ᨾᩁᩦᨧᩥ ᨴ᩠ᩅᩦᩈᩩ ᨽᩣᨶ᩠ᩅᩴ’ᩈᩩ, ᨾᨿᩪᨡᩮᩣ ᨠᩥᩁᨱᩮᩣ ᨠᩁᩮᩣ.

ᨸᩁᩥᨵᩥ ᨸᩁᩥᩅᩮᩈᩮᩣ ᨳ, ᨾᩁᩦᨧᩥ ᨾᩥᨣᨲᨱ᩠ᩉᩥᨠᩣ;

ᩈᩪᩁᩔᩮᩣᨴᨿᨲᩮᩣ ᨸᩩᨻ᩠ᨻᩩ’, ᨭ᩠ᨮᩥᨲᩁᩴᩈᩥ ᩈᩥᨿᩣ’ ᩁᩩᨱᩮᩣ.

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

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

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

ᨩᩩᨱ᩠ᩉᩣ ᨲᩩ ᨧᨶ᩠ᨴᩥᨠᩣᨿᩩᨲ᩠ᨲᩣ, ᨲᨾᩩᩔᨶ᩠ᨶᩣ ᨲᩥᨾᩥᩈᩥᨠᩣ.

ᨶᩥᩈᩦᨳᩮᩣ ᨾᨩ᩠ᨫᩥᨾᩣ ᩁᨲ᩠ᨲᩥ, ᩋᨯ᩠ᨰᩁᨲ᩠ᨲᩮᩣ ᨾᩉᩣᨶᩥᩈᩣ;

ᩋᨶ᩠ᨵᨠᩣᩁᩮᩣ ᨲᨾᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨲᩥᨾᩥᩈᩴ ᨲᩥᨾᩥᩁᩴ ᨾᨲᩴ.

ᨧᨲᩩᩁᨦ᩠ᨣᨲᨾᩴ ᩑᩅᩴ, ᨠᩣᩊᨸᨠ᩠ᨡᨧᨲᩩᨴ᩠ᨴᩈᩦ;

ᩅᨶᩈᨱ᩠ᨯᩮᩣ ᨥᨶᩮᩣ ᨾᩮᨥ, ᨸᨭᩃᩴ ᨧᩣ’ᨯ᩠ᨰᩁᨲ᩠ᨲᩥ ᨧ.

ᩋᨶ᩠ᨵᨲᨾᩴ ¶ ᨥᨶᨲᨾᩮ, ᨸᩉᩣᩁᩮᩣ ᨿᩣᨾ, ᩈᨬ᩠ᨬᩥᨲᩮᩣ;

ᨸᩣᨭᩥᨸᨴᩮᩣ ᨲᩩ ᨴᩩᨲᩥᨿᩣ, ᨲᨲᩥᨿᩣᨴᩦ ᨲᩥᨳᩦ [ᨲᩥᨳᩥ], ᨲᩣᨿᨲᩥ ᨸᩣᩃᩮᨲᩦᨲᩥ ᨲᩥᨳᩥ, ᨲᩣ+ᩍᨲᩥ (ᨱ᩠ᩅᩣᨴᩥ) ᨴ᩠ᩅᩥᩈᩩ.

ᨸᨶ᩠ᨶᩁᩈᩦ ᨸᨬ᩠ᨧᨴᩈᩦ, ᨸᩩᨱ᩠ᨱᨾᩣᩈᩦ ᨲᩩ ᨸᩩᨱ᩠ᨱᨾᩣ;

ᩋᨾᩣᩅᩈᩦ ᨸ᩠ᨿᨾᩣᩅᩣᩈᩦ, ᨳᩥᨿᩴ ᨸᨶ᩠ᨶᩁᩈᩦ’ ᨸᩁᩣ.

ᨥᨭᩥᨠᩣ ᩈᨭ᩠ᨮ᩠ᨿ’ ᩉᩮᩣᩁᨲ᩠ᨲᩮᩣ, ᨸᨠ᩠ᨡᩮᩣ ᨲᩮ ᨴᩈ ᨸᨬ᩠ᨧ ᨧ;

ᨧᩥᨲ᩠ᨲᩮᩣ ᩅᩮᩈᩣᨡ, ᨩᩮᨭ᩠ᨮᩮᩣ ᨧᩣ, ᩈᩣᩊ᩠ᩉᩮᩣ ᨴ᩠ᩅᩦᩈᩩ ᨧ ᩈᩣᩅᨱᩮᩣ;

ᨸᩮᩣᨭ᩠ᨮᨸᩣᨴ’ᩔᨿᩩᨩᩣ ᨧ, ᨾᩣᩈᩣ ᨴ᩠ᩅᩣᨴᩈ ᨠᨲ᩠ᨲᩥᨠᩮᩣ.

ᨾᩣᨣᩈᩥᩁᩮᩣ ᨲᨳᩣ ᨹᩩᩔᩮᩣ, ᨠᨾᩮᨶ ᨾᩣᨥ ᨹᨣ᩠ᨣᩩᨱᩣ;

ᨠᨲ᩠ᨲᩥᨠ’ᩔᨿᩩᨩᩣ ᨾᩣᩈᩣ, ᨸᨧ᩠ᨨᩥᨾ ᨸᩩᨻ᩠ᨻᨠᨲ᩠ᨲᩥᨠᩣ.

ᨧᨲᩩᩁᩮᩣ ᨧᨲᩩᩁᩮᩣ ᨾᩣᩈᩣ, ᨠᨲ᩠ᨲᩥᨠᨠᩣᩊᨸᨠ᩠ᨡᨲᩮᩣ;

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

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

ᩏᨲᩪᩉᩥ ᨲᩦᩉᩥ ᩅᩔᩣᨶᩣ, ᨴᩥᨠᩮᩉᩥ ᨴᨠ᩠ᨡᩥᨱᩣᨿᨶᩴ.

ᩏᨲ᩠ᨲᩁᩣᨿᨶ ᨾᨬ᩠ᨬᩮᩉᩥ, ᨲᩦᩉᩥ ᩅᩔᩣᨿᨶᨴ᩠ᩅᨿᩴ;

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

ᨠᨸ᩠ᨸᨠ᩠ᨡᨿᩮᩣ ᨲᩩ ᩈᩴᩅᨭ᩠ᨭᩮᩣ, ᨿᩩᨣᨶ᩠ᨲ ᨸᩃᨿᩣ ᩋᨸᩥ;

ᩋᩃᨠ᩠ᨡᩦ ᨠᩣᩃᨠᨱ᩠ᨱᩥᨲ᩠ᨳᩦ, ᩋᨳ ᩃᨠ᩠ᨡᩦ ᩈᩥᩁᩥ’ᨲ᩠ᨳᩥᨿᩴ.

ᨴᨶᩩ ᨴᩣᨶᩅᨾᩣᨲᩣ ᨳ, ᨴᩮᩅᨾᩣᨲᩣ ᨸᨶᩣ’ᨴᩥᨲᩥ;

ᨸᩣᨸᨬ᩠ᨧ ᨠᩥᨻ᩠ᨻᩥᩈᩴ ᩅᩮᩁᩣ, ᨥᩴ ᨴᩩᨧ᩠ᨧᩁᩥᨲ ᨴᩩᨠ᩠ᨠᨭᩴ;

ᩋᨸᩩᨬ᩠ᨬᩣ’ᨠᩩᩈᩃᩴ ᨠᨱ᩠ᩉᩴ, ᨠᩃᩩᩈᩴ ᨴᩩᩁᩥᨲᩣ’ᨣᩩ ᨧ.

ᨠᩩᩈᩃᩴ ¶ ᩈᩩᨠᨲᩴ ᩈᩩᨠ᩠ᨠᩴ, ᨸᩩᨬ᩠ᨬᩴ ᨵᨾ᩠ᨾ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ;

ᩈᩩᨧᩁᩥᨲ ᨾᨳᩮᩣ ᨴᩥᨭ᩠ᨮ, ᨵᨾ᩠ᨾᩥᨠᩴ ᩍᩉᩃᩮᩣᨠᩥᨠᩴ.

ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨠ ᨾᨳᩮᩣ ᨸᩣᩁ, ᩃᩮᩣᨠᩥᨠᩴ ᩈᨾ᩠ᨸᩁᩣᨿᩥᨠᩴ;

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

ᩌᨶᨶ᩠ᨴᩮᩣ ᨸᨾᩩᨴᩣ’ᨾᩮᩣᨴᩮᩣ, ᩈᨶ᩠ᨲᩮᩣᩈᩮᩣ ᨶᨶ᩠ᨴᩥ ᩈᨾ᩠ᨾᨴᩮᩣ.

ᨸᩣᨾᩮᩣᨩ᩠ᨩᨬ᩠ᨧ ᨸᨾᩮᩣᨴᩮᩣ ᨳ, ᩈᩩᨡᩴ ᩈᩣᨲᨬ᩠ᨧ ᨹᩣᩈ᩠ᩅ’ᨳ;

ᨽᨴ᩠ᨴᩴ ᩈᩮᨿ᩠ᨿᩮᩣ ᩈᩩᨽᩴ ᨡᩮᨾᩴ, ᨠᩃ᩠ᨿᩣᨱᩴ ᨾᨦ᩠ᨣᩃᩴ ᩈᩥᩅᩴ.

ᨴᩩᨠ᩠ᨡᨬ᩠ᨧ ᨠᩈᩥᩁᩴ ᨠᩥᨧ᩠ᨨᩴ, ᨶᩦᨥᩮᩣ ᨧ ᨻ᩠ᨿᩈᨶᩴ ᩋᨥᩴ;

ᨴᨻ᩠ᨻᩮ ᨲᩩ ᨸᩣᨸᨸᩩᨬ᩠ᨬᩣᨶᩥ, ᨲᩦᩈ᩠ᩅᩣᨠᩥᨧ᩠ᨨᩴ ᩈᩩᨡᩣᨴᩥ ᨧ.

ᨽᩣᨣ᩠ᨿᩴ ᨶᩥᨿᨲᩥ ᨽᩣᨣᩮᩣ ᨧ, ᨽᩣᨣᨵᩮᨿ᩠ᨿᩴ ᩅᩥᨵᩦ’ᩁᩥᨲᩮᩣ;

ᩋᨳᩮᩣ ᩏᨸ᩠ᨸᨲ᩠ᨲᩥ ᨶᩥᨻ᩠ᨻᨲ᩠ᨲᩥ, ᨩᩣᨲᩥ ᨩᨶᨶ ᨾᩩᨻ᩠ᨽᩅᩮᩣ.

ᨶᩥᨾᩥᨲ᩠ᨲᩴ ᨠᩣᩁᨱᩴ ᨮᩣᨶᩴ, ᨸᨴᩴ ᨻᩦᨩᩴ ᨶᩥᨻᨶ᩠ᨵᨶᩴ;

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

ᨠᩣᩁᨱᩴ ᨿᩴ ᩈᨾᩣᩈᨶ᩠ᨶᩴ, ᨸᨴᨭ᩠ᨮᩣᨶᨶ᩠ᨲᩥ ᨲᩴ ᨾᨲᩴ;

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

ᨸᩣᨱᩮᩣ ᩈᩁᩦᩁᩦ ᨽᩪᨲᩴ ᩅᩣ, ᩈᨲ᩠ᨲᩮᩣ ᨴᩮᩉᩦ ᨧ ᨸᩩᨣ᩠ᨣᩃᩮᩣ;

ᩁᩪᨸᩴ ᩈᨴ᩠ᨴᩮᩣ ᨣᨶ᩠ᨵ ᩁᩈᩣ, ᨹᩔᩮᩣ ᨵᨾ᩠ᨾᩮᩣ ᨧ ᨣᩮᩣᨧᩁᩣ;

ᩌᩃᨾ᩠ᨻᩣ ᩅᩥᩈᨿᩣ ᨲᩮ ᨨᩣ, ᩁᨾ᩠ᨾᨱᩣ ᩃᨾ᩠ᨻᨱᩣᨶᩥ ᨧ.

ᩈᩥᨲᨸᩦᨲᩮᨲᩩ ᨸᨱ᩠ᨯᩩ’ᨲ᩠ᨲᩮᩣ, ᩎᩈᩴᨸᨱ᩠ᨯᩩᨲᩩ ᨵᩪᩈᩁᩮᩣ.

ᨠᩊᩣᩁᩮᩣ ᨠᨸᩥᩃᩮᩣ ᨶᩦᩃ, ᨸᩦᨲᩮ ᨳ ᩁᩮᩣᨧᨶᨸ᩠ᨸᨽᩮ;

ᨸᩥᨦ᩠ᨣᩮᩣ ᨸᩥᩈᨦ᩠ᨣᩮᩣ ᨸ᩠ᨿᨳᩅᩣ, ᨠᩊᩣᩁᩣᨴᩦ ᨲᩩ ᨸᩥᨦ᩠ᨣᩃᩮ.

ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩣ ᨣᩩᨱᩥᨶ᩠ᨿᩮᨲᩮ, ᨣᩩᨱᩮ ᩈᩩᨠ᩠ᨠᩣᨴᨿᩮᩣ ᨸᩩᨾᩮ.

ᨶᨧ᩠ᨧᩴ ᨶᨭ᩠ᨭᨬ᩠ᨧ ᨶᨭᨶᩴ, ᨶᨲ᩠ᨲᨶᩴ ᩃᩣᩈᨶᩴ ᨽᩅᩮ;

ᨶᨧ᩠ᨧᩴ ᨲᩩ ᩅᩣᨴᩥᨲᩴ ᨣᩦᨲ, ᨾᩥᨲᩥ ᨶᩣᨭᩩᨾᩥᨴᩴ ᨲᨿᩴ.

ᨶᨧ᩠ᨧᨭ᩠ᨮᩣᨶᩴ ᩈᩥᨿᩣ ᩁᨦ᩠ᨣᩮᩣ, ᨽᩥᨶᨿᩮᩣ ᩈᩪᨧ᩠ᨿᩈᩪᨧᨶᩴ;

ᩋᨦ᩠ᨣᩉᩣᩁᩮᩣ’ᨦ᩠ᨣᩅᩥᨠ᩠ᨡᩮᨸᩮᩣ, ᨶᨭ᩠ᨭᨠᩮᩣ ᨶᨭᨠᩮᩣ ᨶᨭᩮᩣ.

ᩈᩥᨦ᩠ᨣᩣᩁᩮᩣ ᨠᩁᩩᨱᩮᩣ ᩅᩦᩁ, ᨻ᩠ᨽᩩᨲ ᩉᩔ ᨽᨿᩣᨶᨠᩣ;

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

ᨸᩮᩣᩈᩔ ᨶᩣᩁᩥᨿᩴ ᨸᩮᩣᩈᩮ, ᩍᨲ᩠ᨳᩥᨿᩣ ᩈᨦ᩠ᨣᨾᩴ ᨸᨲᩥ;

ᨿᩣ ᨸᩥᩉᩣ ᩑᩈ ᩈᩥᨦ᩠ᨣᩣᩁᩮᩣ, ᩁᨲᩥᨠᩦᩊᩣᨴᩥᨠᩣᩁᨱᩮᩣ.

ᩏᨲ᩠ᨲᨾ ᨸ᩠ᨸᨠᨲᩥᨸ᩠ᨸᩣᨿᩮᩣ, ᩍᨲ᩠ᨳᩥᨸᩩᩁᩥᩈᩉᩮᨲᩩᨠᩮᩣ;

ᨽᩣᩈᩥᨲᩴ ¶ ᩃᨸᩥᨲᩴ ᨽᩣᩈᩣ, ᩅᩮᩣᩉᩣᩁᩮᩣ ᩅᨧᨶᩴ ᩅᨧᩮᩣ;

ᩏᨲ᩠ᨲᩥ ᩅᩣᨧᩣ ᨣᩥᩁᩣ ᩅᩣᨱᩦ, ᨽᩣᩁᨲᩦ ᨠᨳᩥᨲᩣ [ᨠᨳᩣ (ᨠᨲ᩠ᨳᨧᩥ)] ᩅᨧᩦ.

ᩑᨠᩣᨡ᩠ᨿᩣᨲᩮᩣ ᨸᨴᨧᨿᩮᩣ, ᩈᩥᨿᩣ ᩅᩣᨠ᩠ᨿᩴᩈᨠᩣᩁᨠᩮᩣ;

ᩌᨾᩮᨯᩥᨲᨶ᩠ᨲᩥ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ, ᨴ᩠ᩅᨲ᩠ᨲᩥᨠ᩠ᨡᨲ᩠ᨲᩩ ᨾᩩᨴᩦᩁᨱᩴ.

ᨽᨿᩮ ᨠᩮᩣᨵᩮ ᨸᩈᩴᩈᩣᨿᩴ, ᨲᩩᩁᩥᨲᩮ ᨠᩮᩣᨲᩪᩉᩃᩮ’ᨧ᩠ᨨᩁᩮ;

ᩉᩣᩈᩮ ᩈᩮᩣᨠᩮ ᨸᩈᩣᨴᩮ ᨧ, ᨠᩁᩮ ᩌᨾᩮᨯᩥᨲᩴ ᨻᩩᨵᩮᩣ.

ᩍᩁᩩ ᨶᩣᩁᩦ ᨿᨩᩩ ᩈᩣᨾ, ᨾᩥᨲᩥ ᩅᩮᨴᩣ ᨲᨿᩮᩣ ᩈᩥᨿᩩᩴ;

ᩑᨲᩮ ᩑᩅ ᨲᨿᩦ ᨶᩣᩁᩦ, ᩅᩮᨴᩮᩣ ᨾᨶ᩠ᨲᩮᩣ ᩈᩩᨲᩥᨲ᩠ᨳᩥᨿᩴ.

ᩋᨭ᩠ᨮᨠᩮᩣ ᩅᩣᨾᨠᩮᩣ ᩅᩣᨾ, ᨴᩮᩅᩮᩣ ᨧᨦ᩠ᨣᩦᩁᩈᩮᩣ ᨽᨣᩩ;

ᨿᨾᨴᨣ᩠ᨣᩥ ᨧ ᩅᩣᩈᩥᨭ᩠ᨮᩮᩣ, ᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨧ ᨠᩔᨸᩮᩣ;

ᩅᩮᩔᩣᨾᩥᨲ᩠ᨲᩮᩣᨲᩥ ᨾᨶ᩠ᨲᩣᨶᩴ, ᨠᨲ᩠ᨲᩣᩁᩮᩣ ᩍᩈᨿᩮᩣ ᩍᨾᩮ.

ᨠᨸ᩠ᨸᩮᩣ ᨻ᩠ᨿᩣᨠᩁᨱᩴ ᨩᩮᩣᨲᩥ, ᩈᨲ᩠ᨳᩴ ᩈᩥᨠ᩠ᨡᩣ ᨶᩥᩁᩩᨲ᩠ᨲᩥ ᨧ;

ᨨᨶ᩠ᨴᩮᩣᩅᩥᨧᩥᨲᩥ ᨧᩮᨲᩣᨶᩥ, ᩅᩮᨴᨦ᩠ᨣᩣᨶᩥ ᩅᨴᨶ᩠ᨲᩥ ᨨ.

ᩍᨲᩥᩉᩣᩈᩮᩣ ᨸᩩᩁᩣᩅᩩᨲ᩠ᨲ, ᨸ᩠ᨸᨻᨶ᩠ᨵᩮᩣ ᨽᩣᩁᨲᩣᨴᩥᨠᩮᩣ;

ᨶᩣᨾᨸ᩠ᨸᨠᩣᩈᨠᩴ ᩈᨲ᩠ᨳᩴ, ᩁᩩᨠ᩠ᨡᩣᨴᩦᨶᩴ ᨶᩥᨥᨱ᩠ᨯᩩ ᩈᩮᩣ.

ᩅᩥᨲᨱ᩠ᨯᩈᨲ᩠ᨳᩴ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ, ᨿᩴ ᨲᩴ ᩃᩮᩣᨠᩣᨿᨲᩴ ᩍᨲᩥ;

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

ᩌᨡ᩠ᨿᩣᨿᩥᨠᩮᩣᨸᩃᨴ᩠ᨵᨲ᩠ᨳᩣ, ᨸᨻᨶ᩠ᨵᨠᨸ᩠ᨸᨶᩣ ᨠᨳᩣ;

ᨴᨱ᩠ᨯᨶᩦᨲ᩠ᨿ’ᨲ᩠ᨳᩈᨲ᩠ᨳᩈ᩠ᨾᩥᩴ, ᩅᩩᨲ᩠ᨲᨶ᩠ᨲᩮᩣ ᨲᩩ ᨸᩅᨲ᩠ᨲᩥ ᨧ.

ᩈᨬ᩠ᨬᩣ, ᨡ᩠ᨿᩣ, ᩅ᩠ᩉᩣ ᩈᨾᨬ᩠ᨬᩣ ᨧᩣ, ᨽᩥᨵᩣᨶᩴ ᨶᩣᨾ ᨾᩅ᩠ᩉᨿᩮᩣ;

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

ᨸᨬ᩠ᩉᩮᩣ ᨲᩦᩈ᩠ᩅ ᨶᩩᨿᩮᩣᨣᩮᩣ ᨧ, ᨸᩩᨧ᩠ᨨᩣ ᨸ᩠ᨿᨳ ᨶᩥᨴᩔᨶᩴ;

ᩏᨸᩮᩣᨣ᩠ᨥᩣᨲᩮᩣ ᨧ ᨴᩥᨭ᩠ᨮᨶ᩠ᨲᩮᩣ, ᨲᨳᩮᩣ’ᨴᩣᩉᩁᨱᩴ ᨽᩅᩮ.

ᩈᨾᩣ ᩈᨦ᩠ᨡᩮᨸ ᩈᩴᩉᩣᩁᩣ, ᩈᨾᩣᩈᩮᩣ ᩈᨦ᩠ᨣᩉᩮᩣ ᨸ᩠ᨿᨳ;

ᩈᨲᩴ ᨵᩣᩁᨿᩈᩦ ᨲ᩠ᨿᩣᨴ᩠ᨿ, ᨻ᩠ᨽᨠ᩠ᨡᩣᨶᩴ ᨲᩩᨧ᩠ᨨᨽᩣᩈᨶᩴ.

ᩅᩮᩣᩉᩣᩁᩮᩣ ᨲᩩ ᩅᩥᩅᩣᨴᩮᩣ ᨳ, ᩈᨸᨶᩴ ᩈᨸᨳᩮᩣᨸᩥ ᨧ;

ᨸᨭᩥᨥᩮᩣᩈᩮᩣ ᨸᨭᩥᩁᩅᩮᩣ, ᨳᩮᩣ’ ᨸᨬ᩠ᨬᩣᩈᩮᩣ ᩅᨧᩦᨾᩩᨡᩴ;

ᨠᨲ᩠ᨳᨶᩣ ᨧ ᩈᩥᩃᩣᨥᩣ ᨧ, ᩅᨱ᩠ᨱᨶᩣ ᨧ ᨶᩩᨲᩥ ᨲ᩠ᨳᩩᨲᩥ.

ᨳᩮᩣᨾᨶᨬ᩠ᨧ [ᨳᩮᩣᨾᨶᩴ ᩅᩣ (ᨠᨲ᩠ᨳᨧᩥ ᨳᩮᩣᨾᨶᩴ ᨳᩮᩣᨾᨶᩣ ᨴ᩠ᩅᩥᩃᩥᨦ᩠ᨣᩮ)] ᨸᩈᩴᩈᩣᨳ, ᨠᩮᨠᩣ ᨶᩣᨴᩮᩣ ᩈᩥᨡᨱ᩠ᨯᩥᨶᩴ;

ᨸᩁᩥᨿᩣᨿᩮᩣ ᩅᩮᩅᨧᨶᩴ, ᩈᩣᨠᨧ᩠ᨨᩣ ᨲᩩ ᨧ ᩈᩴᨠᨳᩣ;

ᩏᨸᩅᩣᨴᩮᩣ ᨧᩩ’ᨸᨠ᩠ᨠᩮᩣᩈᩣ, ᩅᨱ᩠ᨱᩅᩣᨴᩣ’ᨶᩩᩅᩣᨴᩮᩣ ᨧ;

ᨩᨶᩅᩣᨴᩣ’ᨸᩅᩣᨴᩣᨸᩥ, ᨸᩁᩥᩅᩣᨴᩮᩣ ᨧ ᨲᩩᩃ᩠ᨿᨲ᩠ᨳᩣ.

ᨡᩮᨸᩮᩣ ¶ ᨶᩥᨶ᩠ᨴᩣ ᨲᨳᩣ ᨠᩩᨧ᩠ᨨᩣ, ᨩᩥᨣᩩᨧ᩠ᨨᩣ ᨣᩁᩉᩣ ᨽᩅᩮ;

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

ᩋᨭ᩠ᨮᩣᨶᩁᩥᨿᩅᩮᩣᩉᩣᩁ, ᩅᩈᩮᨶ ᨿᩣ ᨸᩅᨲ᩠ᨲᩥᨲᩣ;

ᩋᨽᩥᩅᩣᨠ᩠ᨿᩴ ᩈᩥᨿᩣ ᩅᩣᨧᩣ, ᩈᩣ ᩅᩦᨲᩥᨠ᩠ᨠᨾᨴᩦᨸᨶᩦ.

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

ᩅᩥᨸ᩠ᨸᩃᩣᨸᩮᩣ ᩅᩥᩁᩮᩣᨵᩮᩣᨲ᩠ᨲᩥ, ᩈᨶ᩠ᨴᩮᩈᩮᩣᨲ᩠ᨲᩥ ᨲᩩ ᩅᩣᨧᩥᨠᩴ;

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

ᨹᩁᩩᩈᩴ ᨶᩥᨭ᩠ᨮᩩᩁᩴ ᩅᩣᨠ᩠ᨿᩴ, ᨾᨶᩩᨬ᩠ᨬᩴ ᩉᨴᨿᨦ᩠ᨣᨾᩴ;

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

ᩈᨾᩩᨴᩣᨿᨲ᩠ᨳᩁᩉᩥᨲᩴ, ᩋᨻᨴ᩠ᨵᨾᩥᨲᩥ [ᩋᨻᨶ᩠ᨵ (ᨠ.)] ᨠᩥᨲ᩠ᨲᩥᨲᩴ;

ᩅᩥᨲᨳᩴ ᨲᩩ ᨾᩩᩈᩣ ᨧᩣᨳ [ᩌᩉᨲᩴ ᨲᩩ ᨾᩩᩈᩣᨲ᩠ᨳᨠᩴ (ᨠᨲ᩠ᨳᨧᩥ, ᩋᨾᩁᨠᩮᩣᩈᩮ)], ᨹᩁᩩᩈᩣᨴᩦ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩣ.

ᩈᨾ᩠ᨾᩣ ᨻ᩠ᨿᨿᨬ᩠ᨧᩣ ᩅᩥᨲᨳᩴ, ᩈᨧ᩠ᨧᩴ ᨲᨧ᩠ᨨᩴ ᨿᨳᩣᨲᨳᩴ;

ᨲᨻ᩠ᨻᨶ᩠ᨲᩣ ᨲᩦᩈ᩠ᩅ ᩃᩦᨠᩴ ᨲ᩠ᩅ, ᩈᨧ᩠ᨧᩴ ᨾᩥᨧ᩠ᨨᩣ ᨾᩩᩈᩣ ᨻ᩠ᨿᨿᩴ.

ᩅᩥᩔᨭ᩠ᨮ ᨾᨬ᩠ᨩᩩ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩣ, ᩈᩅᨶᩦᨿᩣ ᩅᩥᩈᩣᩁᩥᨶᩮᩣ;

ᨻᩥᨶ᩠ᨴᩩ ᨣᨾ᩠ᨽᩦᩁ ᨶᩥᨶ᩠ᨶᩣᨴᩦ, ᨲ᩠ᨿᩮᩅ ᨾᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩮᩣ ᩈᩁᩮᩣ.

ᨲᩥᩁᨧ᩠ᨨᩣᨶᨣᨲᩣᨶᨬ᩠ᩉᩥ, ᩁᩩᨲᩴ ᩅᩔᩥᨲ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᩈᩁᩣ ᩈᨲ᩠ᨲ ᨲᨿᩮᩣ ᨣᩣᨾᩣ, ᨧᩮᨠᩅᩦᩈᨲᩥ ᨾᩩᨧ᩠ᨨᨶᩣ;

ᨲᩣᨶᩣ [ᨮᩣᨶᩣᨶᩥ (ᨻᩉᩪᩈᩩ)] ᨧᩮᨠᩪᨶᨸᨬ᩠ᨬᩣᩈ, ᩍᨧ᩠ᨧᩮᨲᩴ ᩈᩁᨾᨱ᩠ᨯᩃᩴ.

ᩏᩈᨽᩮᩣ ᨵᩮᩅᨲᩮᩣ ᨧᩮᩅ, ᨨᨩ᩠ᨩ ᨣᨶ᩠ᨵᩣᩁ ᨾᨩ᩠ᨫᩥᨾᩣ;

ᨸᨬ᩠ᨧᨾᩮᩣ ᨧ ᨶᩥᩈᩣᨴᩮᩣᨲᩥ, ᩈᨲ᩠ᨲᩮ’ᨲᩮ ᨣᨴᩥᨲᩣ ᩈᩁᩣ.

ᨶᨴᨶ᩠ᨲᩥ ¶ ᩏᩈᨽᩴ ᨣᩣᩅᩮᩣ, ᨲᩩᩁᨣᩣ ᨵᩮᩅᨲᩴ ᨲᨳᩣ;

ᨨᨩ᩠ᨩᩴ ᨾᨿᩪᩁᩣ ᨣᨶ᩠ᨵᩣᩁ, ᨾᨩᩣ ᨠᩮᩣᨬ᩠ᨧᩣ ᨧ ᨾᨩ᩠ᨫᩥᨾᩴ.

ᨸᨬ᩠ᨧᨾᩴ ᨸᩁᨸᩩᨭ᩠ᨮᩣᨴᩦ, ᨶᩥᩈᩣᨴᨾ᩠ᨸᩥ ᨧ ᩅᩣᩁᨱᩣ;

ᩈᩁᩮᩈᩩ ᨲᩮᩈᩩ ᨸᨧ᩠ᨧᩮᨠᩮ, ᨲᩥᩔᩮᩣ ᨲᩥᩔᩮᩣ ᩉᩥ ᨾᩩᨧ᩠ᨨᨶᩣ;

ᩈᩥᨿᩩᩴ ᨲᨳᩮᩅ ᨲᩣᨶᩣᨶᩥ [ᨮᩣᨶᩣᨶᩥ (ᨻᩉᩪᩈᩩ)], ᩈᨲ᩠ᨲ ᩈᨲ᩠ᨲᩮᩅ ᩃᨻ᩠ᨽᩁᩮ.

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

ᨲᩥᩔᩮᩣ ᨴᩩᩅᩮ ᨧᨲᩔᩮᩣᨲᩥ, ᨴ᩠ᩅᩣᩅᩦᩈᨲᩥ ᩈᩩᨲᩦ ᩈᩥᨿᩩᩴ.

ᩏᨧ᩠ᨧᨲᩁᩮ ᩁᩅᩮ ᨲᩣᩁᩮᩣ, ᨳᩣᨻ᩠ᨿᨲ᩠ᨲᩮ ᨾᨵᩩᩁᩮ ᨠᩃᩮᩣ;

ᨣᨾ᩠ᨽᩦᩁᩮ ᨲᩩ ᩁᩅᩮ ᨾᨶ᩠ᨴᩮᩣ, ᨲᩣᩁᩣᨴᩦ ᨲᩦᩈ᩠ᩅᨳᩮᩣ ᨠᩃᩮ;

ᩅᩦᨱᩣ ᨧ ᩅᩃ᩠ᩃᨠᩦ ᩈᨲ᩠ᨲ, ᨲᨶ᩠ᨲᩦ ᩈᩣ ᨸᩁᩥᩅᩣᨴᩥᨶᩦ;

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

ᩌᨲᨲᩴ ᨶᩣᨾ ᨧᨾ᩠ᨾᩣᩅ, ᨶᨴ᩠ᨵᩮᩈᩩ ᨽᩮᩁᩥᨿᩣᨴᩥᩈᩩ;

ᨲᩃᩮ’ᨠᩮᨠᨿᩩᨲᩴ ᨠᩩᨾ᩠ᨽ, ᨳᩩᨱ ᨴᨴ᩠ᨴᩁᩥᨠᩣᨴᩥᨠᩴ.

ᩅᩥᨲᨲᩴ ᨧᩮᩣ’ᨽᨿᨲᩃᩴ, ᨲᩪᩁᩥᨿᩴ ᨾᩩᩁᨩᩣᨴᩥᨠᩴ;

ᩌᨲᨲᩅᩥᨲᨲᩴ ᩈᨻ᩠ᨻ, ᩅᩥᨶᨴ᩠ᨵᩴ ᨸᨱᩅᩣᨴᩥᨠᩴ.

ᩈᩩᩈᩥᩁᩴ ᩅᩴᩈᩈᨦ᩠ᨡᩣᨴᩥ, ᩈᨾ᩠ᨾᨲᩣᩃᩣᨴᩥᨠᩴ ᨥᨶᩴ;

ᩌᨲᩮᩣᨩ᩠ᨩᩴ ᨲᩩ ᨧ ᩅᩣᨴᩥᨲ᩠ᨲᩴ, ᩅᩣᨴᩥᨲᩴ ᩅᨩ᩠ᨩ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᩌᩃᨾ᩠ᨻᩁᩮᩣ ¶ ᨲᩩ ᨸᨱᩅᩮᩣ, ᨠᩮᩣᨱᩮᩣ ᩅᩦᨱᩣᨴᩥᩅᩣᨴᨶᩴ;

ᨴᨴ᩠ᨴᩁᩦ ᨸᨭᩉᩮᩣ ᨽᩮᩁᩥ, ᨸ᩠ᨸᨽᩮᨴᩣ ᨾᨴ᩠ᨴᩃᩣᨴᨿᩮᩣ.

ᨩᨶᨸ᩠ᨸᩥᨿᩮ ᩅᩥᨾᨴ᩠ᨴᩩᨭ᩠ᨮᩮ, ᨣᨶ᩠ᨵᩮ ᨸᩁᩥᨾᩃᩮᩣ ᨽᩅᩮ;

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

ᩍᨭ᩠ᨮᨣᨶ᩠ᨵᩮᩣ ᨧ ᩈᩩᩁᨽᩥ, ᩈᩩᨣᨶ᩠ᨵᩮᩣ ᨧ ᩈᩩᨣᨶ᩠ᨵᩥ ᨧ;

ᨸᩪᨲᩥᨣᨶ᩠ᨵᩥ ᨲᩩ ᨴᩩᨣ᩠ᨣᨶ᩠ᨵᩮᩣ, ᨳ ᩅᩥᩔᩴ ᩌᨾᨣᨶ᩠ᨵᩥ ᨿᩴ.

ᨠᩩᨦ᩠ᨠᩩᨾᨬ᩠ᨧᩮᩅ ᨿᩅᨶ, ᨸᩩᨸ᩠ᨹᨬ᩠ᨧ ᨲᨣᩁᩴ ᨲᨳᩣ;

ᨲᩩᩁᩩᨠ᩠ᨡᩮᩣᨲᩥ ᨧᨲᩩᨩ᩠ᨩᩣᨲᩥ, ᨣᨶ᩠ᨵᩣ ᩑᨲᩮ ᨸᨠᩣᩈᩥᨲᩣ.

ᨠᩈᩣᩅᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨲᩥᨲ᩠ᨲᩮᩣ, ᨾᨵᩩᩁᩮᩣ ᩃᩅᨱᩮᩣ ᩍᨾᩮ;

ᩋᨾ᩠ᨻᩥᩃᩮᩣ ᨠᨭᩩᨠᩮᩣ ᨧᩮᨲᩥ, ᨨ ᩁᩈᩣ ᨲᨻ᩠ᨻᨲᩦ ᨲᩥᩈᩩ.

ᨶᨿᨶᩴ ᨲ᩠ᩅᨠ᩠ᨡᩥ ᨶᩮᨲ᩠ᨲᨬ᩠ᨧ, ᩃᩮᩣᨧᨶᩴ ᨧ’ᨧ᩠ᨨᩥ ᨧᨠ᩠ᨡᩩ ᨧ.

ᩈᩮᩣᨲᩴ ᩈᨴ᩠ᨴᨣ᩠ᨣᩉᩮᩣ ᨠᨱ᩠ᨱᩮᩣ, ᩈᩅᨶᩴ ᩈᩩᨲᩥ ᨶᨲ᩠ᨳᩩ ᨲᩩ;

ᨶᩣᩈᩣ ᨧ ᨶᩣᩈᩥᨠᩣ ᨥᩣᨶᩴ, ᨩᩥᩅ᩠ᩉᩣᨲᩩ ᩁᩈᨶᩣ ᨽᩅᩮ.

ᩈᩁᩦᩁᩴ ᩅᨸᩩ ᨣᨲ᩠ᨲᨬ᩠ᨧᩣ, ᨲ᩠ᨲᨽᩣᩅᩮᩣ ᨻᩮᩣᨶ᩠ᨴᩥ ᩅᩥᨣ᩠ᨣᩉᩮᩣ;

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

ᨧᩥᨲ᩠ᨲᩴ ᨧᩮᨲᩮᩣ ᨾᨶᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩅᩥᨬ᩠ᨬᩣᨱᩴ ᩉᨴᨿᩴ ᨲᨳᩣ;

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

ᨽᩪᩁᩦ ᨾᨶ᩠ᨲᩣ ᨧ ᨸᨬ᩠ᨬᩣᨱᩴ, ᨬᩣᨱᩴ ᩅᩥᨩ᩠ᨩᩣ ᨧ ᨿᩮᩣᨶᩥ ᨧ;

ᨸᨭᩥᨽᩣᨶ ᨾᨾᩮᩣᩉᩮᩣ ᨳ, ᨸᨬ᩠ᨬᩣᨽᩮᨴᩣ ᩅᩥᨸᩔᨶᩣ.

ᩈᨾ᩠ᨾᩣᨴᩥᨭ᩠ᨮᩥ ᨸᨽᩩᨲᩥᨠᩣ, ᩅᩦᨾᩴᩈᩣ ᨲᩩ ᩅᩥᨧᩣᩁᨱᩣ;

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

ᩑᨠᨣ᩠ᨣᨲᩣ ᨲᩩ ᩈᨾᨳᩮᩣ, ᩋᩅᩥᨠ᩠ᨡᩮᨸᩮᩣ ᩈᨾᩣᨵᩥ ᨧ.

ᩏᩔᩣᩉᩣ’ ᨲᨸ᩠ᨸ ᨸᨣ᩠ᨣᩣᩉᩣ, ᩅᩣᨿᩣᨾᩮᩣ ᨧ ᨸᩁᨠ᩠ᨠᨾᩮᩣ;

ᨸᨵᩣᨶᩴ ᩅᩦᩁᩥᨿᩴ ᨧᩮᩉᩣ, ᩏᨿ᩠ᨿᩣᨾᩮᩣ ᨧ ᨵᩥᨲᩥ ᨲ᩠ᨳᩥᨿᩴ.

ᨧᨲ᩠ᨲᩣᩁᩥ ᩅᩦᩁᩥᨿᨦ᩠ᨣᩣᨶᩥ, ᨲᨧᩔ ᨧ ᨶᩉᩣᩁᩩᨶᩮᩣ;

ᩋᩅᩈᩥᩔᨶ ᨾᨭ᩠ᨮᩥᩔ, ᨾᩴᩈᩃᩮᩣᩉᩥᨲᩈᩩᩔᨶᩴ.

ᩏᩔᩮᩣᩊ᩠ᩉᩦ ¶ ᨲ᩠ᩅ ᨵᩥᨾᨲ᩠ᨲᩮᩉᩣ, ᩈᨲᩥ ᨲ᩠ᩅ ᨶᩩᩔᨲᩥ ᨲ᩠ᨳᩥᨿ;

ᩃᨩ᩠ᨩᩣ ᩉᩥᩁᩦ ᩈᨾᩣᨶᩣ ᨳ, ᩒᨲ᩠ᨲᨸ᩠ᨸᩴ ᨸᩣᨸᨽᩦᩁᩩᨲᩣ.

ᨾᨩ᩠ᨫᨲ᩠ᨲᨲᩣ ᨲᩩ’ᨸᩮᨠ᩠ᨡᩣ ᨧ, ᩋᨴᩩᨠ᩠ᨡᨾᩈᩩᨡᩣ ᩈᩥᨿᩣ;

ᨴᨿᩣ’ ᨶᩩᨠᨾ᩠ᨸᩣ ᨠᩣᩁᩩᨬ᩠ᨬᩴ, ᨠᩁᩩᨱᩣ ᨧ ᩋᨶᩩᨴ᩠ᨴᨿᩣ;

ᨳᩥᨿᩴ ᩅᩮᩁᨾᨱᩦ ᨧᩮᩅ, ᩅᩥᩁᨲ᩠ᨿᩣ’ ᩁᨲᩥ ᨧᩣᨸ᩠ᨿᨳ.

ᨲᩥᨲᩥᨠ᩠ᨡᩣ ᨡᨶ᩠ᨲᩥ ᨡᨾᨶᩴ, ᨡᨾᩣ ᨾᩮᨲ᩠ᨲᩣ ᨲᩩ ᨾᩮᨲ᩠ᨿ’ᨳ;

ᨴᩔᨶᩴ ᨴᩥᨭ᩠ᨮᩥ ᩃᨴ᩠ᨵᩥᨲ᩠ᨳᩦ, ᩈᩥᨴ᩠ᨵᨶ᩠ᨲᩮᩣ ᩈᨾᨿᩮᩣ ᨽᩅᩮ.

ᨲᨱ᩠ᩉᩣ ᨧ ᨲᩈᩥᨱᩣ ᩑᨩᩣ, ᨩᩣᩃᩥᨶᩦ ᨧ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩣ;

ᨨᨶ᩠ᨴᩮᩣ ᨩᨭᩣ ᨶᩥᨠᨶ᩠ᨲ᩠ᨿᩣ’ᩈᩣ, ᩈᩥᨻ᩠ᨻᩥᨶᩦ ᨽᩅᨶᩮᨲ᩠ᨲᩥ ᨧ.

ᩋᨽᩥᨩ᩠ᨫᩣ ᩅᨶᨳᩮᩣ ᩅᩣᨶᩴ, ᩃᩮᩣᨽᩮᩣ ᩁᩣᨣᩮᩣ ᨧ ᩌᩃᨿᩮᩣ;

ᨸᩥᩉᩣ ᨾᨶᩮᩣᩁᨳᩮᩣ ᩍᨧ᩠ᨨᩣ, ᨽᩥᩃᩣᩈᩮᩣ ᨠᩣᨾ ᨴᩮᩣᩉᩊᩣ;

ᩌᨠᨦ᩠ᨡᩣ ᩁᩩᨧᩥ ᩅᩩᨲ᩠ᨲᩣ ᩈᩣ, ᨲ᩠ᩅᨵᩥᨠᩣ ᩃᩣᩃᩈᩣ ᨴ᩠ᩅᩥᩈᩩ.

ᩅᩮᩁᩴ ᩅᩥᩁᩮᩣᨵᩮᩣ ᩅᩥᨴ᩠ᨴᩮᩈᩮᩣ, ᨴᩮᩣᩈᩮᩣ ᨧ ᨸᨭᩥᨥᨬ᩠ᨧ ᩅᩣ;

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

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

ᨽᩦᨲᩥᨲ᩠ᨳᩥ ᨽᨿ ᨾᩩᨲ᩠ᨲᩣᩈᩮᩣ, ᨽᩮᩁᩅᩴ ᨲᩩ ᨾᩉᨻ᩠ᨽᨿᩴ;

ᨽᩮᩁᩅᩴ ᨽᩦᩈᨶᩴ ᨽᩦᨾᩴ, ᨴᩣᩁᩩᨱᨬ᩠ᨧ ᨽᨿᩣᨶᨠᩴ;

ᨥᩮᩣᩁᩴ ᨸᨭᩥᨽᨿᩴ ᨽᩮᩈ᩠ᨾᩴ, ᨽᨿᨦ᩠ᨠᩁ ᨾᩥᨾᩮ ᨲᩦᩈᩩ.

ᩍᩔᩣ ᩏᩈᩪᨿᩣ ᨾᨧ᩠ᨨᩮᩁᩴ, ᨲᩩ ᨾᨧ᩠ᨨᩁᩥᨿ ᨾᨧ᩠ᨨᩁᩴ;

ᨾᩮᩣᩉᩮᩣ’ᩅᩥᨩ᩠ᨩᩣ ᨲᨳᩣ’ᨬᩣᨱᩴ, ᨾᩣᨶᩮᩣ ᩅᩥᨵᩣ ᨧ ᩏᨶ᩠ᨶᨲᩥ.

ᩏᨴ᩠ᨵᨧ᩠ᨧ ᨾᩩᨴ᩠ᨵᨭᩴ ᨧᩣᨳ [ᩏᨴ᩠ᨵᩅᩴᩏᨴ᩠ᨵᩴ ᨵᩣᩅᨲᩥ ᨧᩥᨲ᩠ᨲ ᨾᩮᨲᩮᨶᩣᨲᩥ ᩏᨴ᩠ᨵᩅᩴ (ᨭᩦᨠᩣ)], ᨲᩣᨸᩮᩣ ᨠᩩᨠ᩠ᨠᩩᨧ᩠ᨧᨾᩮᩅ ᨧ;

ᨸᨧ᩠ᨨᩣᨲᩣᨸᩮᩣ ᨶᩩᨲᩣᨸᩮᩣ ᨧ, ᩅᩥᨸ᩠ᨸᨭᩥᩈᩣᩁᩮᩣ ᨸᨠᩣᩈᩥᨲᩮᩣ.

ᨾᨶᩮᩣᩅᩥᩃᩮᨡ ᩈᨶ᩠ᨴᩮᩉᩣ, ᩈᩴᩈᨿᩮᩣ ᨧ ᨠᨳᩴᨠᨳᩣ;

ᨴ᩠ᩅᩮᩊ᩠ᩉᨠᩴ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᩣ ᨧ, ᨠᨦ᩠ᨡᩣ ᩈᨦ᩠ᨠᩣ ᩅᩥᨾᨲ᩠ᨿᨸᩥ.

ᨣᨻ᩠ᨻᩮᩣ ¶ ᨽᩥᨾᩣᨶᩮᩣ’ᩉᩴᨠᩣᩁᩮᩣ, ᨧᩥᨶ᩠ᨲᩣᨲᩩ ᨫᩣᨶ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᨶᩥᨧ᩠ᨨᨿᩮᩣ ᨶᩥᨱ᩠ᨱᨿᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨸᨭᩥᨬ᩠ᨬᩣ ᨲᩩ ᨸᨭᩥᩔᩅᩮᩣ.

ᩋᩅᨾᩣᨶᩴ ᨲᩥᩁᨠ᩠ᨠᩣᩁᩮᩣ, ᨸᩁᩥᨽᩅᩮᩣ ᨸ᩠ᨿ’ ᨶᩣᨴᩁᩮᩣ;

ᨸᩁᩣᨽᩅᩮᩣ ᨸ᩠ᨿ’ ᩅᨬ᩠ᨬᩣ ᨳ, ᩏᨾ᩠ᨾᩣᨴᩮᩣ ᨧᩥᨲ᩠ᨲᩅᩥᨻ᩠ᨽᨾᩮᩣ.

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

ᨸᨾᩣᨴᩮᩣ ᩈᨲᩥᩅᩮᩣᩔᨣ᩠ᨣᩮᩣ, ᨠᩮᩣᨲᩪᩉᩃᩴ ᨠᩩᨲᩪᩉᩃᩴ.

ᩅᩥᩃᩣᩈᩮᩣ ᩃᩃᩥᨲᩴ ᩃᩦᩃᩣ, ᩉᩣᩅᩮᩣ ᩉᩮᩊᩣ ᨧ ᩅᩥᨻ᩠ᨽᨾᩮᩣ;

ᩍᨧ᩠ᨧᩣᨴᩥᨠᩣ ᩈᩥᨿᩩᩴ ᨶᩣᩁᩥ, ᩈᩥᨦ᩠ᨣᩣᩁᨽᩣᩅᨩᩣ ᨠᩥᩁᩥᨿᩣ.

ᩉᩈᨶᩴ ᩉᩈᩥᨲᩴ ᩉᩣᩈᩮᩣ, ᨾᨶ᩠ᨴᩮᩣ ᩈᩮᩣ ᨾᩥᩉᩥᨲᩴ ᩈᩥᨲᩴ;

ᨸᩁᩥᩉᩣᩈᩮᩣ ᨴᩅᩮᩣ ᨡᩥᨯ᩠ᨯᩣ, ᨠᩮᩊᩥ ᨠᩦᩊᩣ ᨧ ᨠᩦᩊᩥᨲᩴ;

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

ᨳᩥᨿᩴ ᨶᩥᨠᨲᩥ ᨠᩪᨭᨬ᩠ᨧ, ᨴᨾ᩠ᨽᩮᩣ ᩈᩣᨮ᩠ᨿᨬ᩠ᨧ ᨠᩮᨲᩅᩴ;

ᩈᨽᩣᩅᩮᩣ ᨲᩩ ᨶᩥᩔᨣ᩠ᨣᩮᩣ ᨧ, ᩈᩁᩪᨸᩴ ᨸᨠᨲᩥᨲ᩠ᨳᩥᨿᩴ.

ᨵᩣᩁᩮᨶ᩠ᨲᩮᩣ ᨩᨶ᩠ᨲᩩ ᩈᩈ᩠ᨶᩮᩉ, ᨾᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩴ;

ᨡᩩᨴ᩠ᨴᨠᩣᨴ᩠ᨿᨲ᩠ᨳᨩᩣᨲᩣᨶᩥ [ᨡᩩᨴ᩠ᨴᨠᩣᨶ᩠ᨿᨲ᩠ᨳᨩᩣᨲᩣᨶᩥ (ᨠ.)], ᩈᨾ᩠ᨸᩔᨲᩥ ᨿᨳᩣᩈᩩᨡᩴ.

ᩅᨣ᩠ᨣᩣ ᨽᩪᨾᩥ, ᨸᩩᩁᩦ, ᨾᨧ᩠ᨧ, ᨧᨲᩩᨻ᩠ᨻᨱ᩠ᨱ, ᩅᨶᩣᨴᩥᩉᩥ;

ᨸᩣᨲᩣᩃᩮᨶ ᨧ ᩅᩩᨧ᩠ᨧᨶ᩠ᨲᩮ, ᩈᨦ᩠ᨣᩮᩣ’ᨸᨦ᩠ᨣᩮᩉᩥ’ᨵ’ᨠ᩠ᨠᨾᩣ.

ᩅᩈᩩᨶ᩠ᨵᩁᩣ ᨨᨾᩣ ᨽᩪᨾᩥ, ᨸᨳᩅᩦ ᨾᩮᨴᨶᩦ ᨾᩉᩦ;

ᩏᨻ᩠ᨻᩦ ᩅᩈᩩᨾᨲᩦ ᨣᩮᩣ ᨠᩩ, ᩅᩈᩩᨵᩣ ᨵᩁᨱᩦ ᨵᩁᩣ;

ᨸᩩᨳᩅᩦ ᨩᨣᨲᩦ ᨽᩪᩁᩦ, ᨽᩪ ᨧ ᨽᩪᨲᨵᩁᩣ’ ᩅᨶᩦ.

ᨡᩣᩁᩣ ¶ ᨲᩩ ᨾᨲ᩠ᨲᩥᨠᩣ ᩐᩈᩮᩣ, ᩐᩈᩅᩣ ᨲᩪᩈᩁᩮᩣ ᨲᩥᩈᩩ;

ᨳᩃᩴ ᨳᩃᩦᨲ᩠ᨳᩦ ᨽᩪᨽᩣᨣᩮ, ᨳᨴ᩠ᨵᩃᩪᨡᨾ᩠ᩉᩥ ᨩᨦ᩠ᨣᩃᩮᩣ.

ᨸᩩᨻ᩠ᨻᩅᩥᨴᩮᩉᩮᩣ ᨧᩣᨸᩁ, ᨣᩮᩣᨿᩣᨶᩴ ᨩᨾ᩠ᨻᩩᨴᩦᨸᩮᩣ ᨧ;

ᩏᨲ᩠ᨲᩁᨠᩩᩁᩩ ᨧᩮᨲᩥ ᩈᩥᨿᩩᩴ, ᨧᨲ᩠ᨲᩣᩁᩮᩣᨾᩮ ᨾᩉᩣᨴᩦᨸᩣ.

ᨸᩩᨾ᩠ᨻᩉᩩᨲ᩠ᨲᩮ ᨠᩩᩁᩪ ᩈᨠ᩠ᨠᩣ, ᨠᩮᩣᩈᩃᩣ ᨾᨣᨵᩣ ᩈᩥᩅᩦ;

ᨠᩃᩥᨦ᩠ᨣᩣ’ᩅᨶ᩠ᨲᩥ ᨸᨬ᩠ᨧᩣᩃᩣ, ᩅᨩ᩠ᨩᩦ ᨣᨶ᩠ᨵᩣᩁ ᨧᩮᨲᨿᩮᩣ.

ᩅᨦ᩠ᨣᩣ ᩅᩥᨴᩮᩉᩣ ᨠᨾ᩠ᨻᩮᩣᨩᩣ, ᨾᨴ᩠ᨴᩣ ᨽᨣ᩠ᨣ’ᨦ᩠ᨣ ᩈᩦᩉᩊᩣ;

ᨠᩈ᩠ᨾᩦᩁᩣ ᨠᩣᩈᩥ ᨸᨱ᩠ᨯᩅᩣᨴᩦ, ᩈᩥᨿᩩᩴ ᨩᨶᨸᨴᨶ᩠ᨲᩁᩣ.

ᩃᩮᩣᨠᩮᩣ ᨧ ᨽᩩᩅᨶᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨴᩮᩈᩮᩣ ᨲᩩ ᩅᩥᩈᨿᩮᩣ ᨸ᩠ᨿᨳ;

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

ᩋᨶᩪᨸᩮᩣ ᩈᩃᩥᩃᨸ᩠ᨸᩣᨿᩮᩣ, ᨠᨧ᩠ᨨᩴ ᨸᩩᨾ ᨶᨸᩩᩴᩈᨠᩮ;

ᩈᨴ᩠ᨴᩃᩮᩣ ᩉᩁᩥᨲᩮ ᨴᩮᩈᩮ, ᨲᩥᨱᩮᨶᩣ, ᨽᩥᨶᩅᩮᨶ ᩉᩥ.

ᨶᨴ᩠ᨿᨾ᩠ᨻᩩᨩᩦᩅᨶᩮᩣ ᨴᩮᩈᩮᩣ, ᩅᩩᨭ᩠ᨮᩥᨶᩥᨸ᩠ᨸᨩ᩠ᨩᩈᩔᨠᩮᩣ;

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

ᩁᨭ᩠ᨮᩴ ᨲᩩ ᩅᩥᨩᩥᨲᨬ᩠ᨧᩣᨳ, ᨸᩩᩁᩥᩈᩮ ᩈᩮᨲᩩ ᩌᩃᩥᨿᩴ.

ᩏᨸᩣᨶ᩠ᨲᨽᩪ ᨸᩁᩥᩈᩁᩮᩣ, ᨣᩮᩣᨭ᩠ᨮᩴ ᨲᩩ ᨣᩮᩣᨠᩩᩃᩴ ᩅᨩᩮᩣ;

ᨾᨣ᩠ᨣᩮᩣ ᨸᨶ᩠ᨳᩮᩣ ᨸᨳᩮᩣ ᩋᨴ᩠ᨵᩣ, ᩋᨬ᩠ᨩᩈᩴ ᩅᨭᩩᨾᩴ ᨲᨳᩣ.

ᨸᨩ᩠ᨩᩮᩣ [ᨸᨩ᩠ᨩᩣ…. (ᨠ.)], ᨿᨶᨬ᩠ᨧ ᨸᨴᩅᩦ, ᩅᨲ᩠ᨲᨶᩦ ᨸᨴ᩠ᨵᨲᩥᨲ᩠ᨳᩥᨿᩴ;

ᨲᨻ᩠ᨽᩮᨴᩣ ᨩᨦ᩠ᨥ, ᩈᨠᨭ, ᨾᨣ᩠ᨣᩣ ᨲᩮ ᨧ ᨾᩉᨴ᩠ᨵᨶᩥ.

ᩑᨠᨸᨴ᩠ᨿᩮᨠᨸᨴᩥᨠᩮ, ᨠᨶ᩠ᨲᩣᩁᩮᩣ ᨲᩩ ᨧ ᨴᩩᨣ᩠ᨣᨾᩮ;

ᨸᨭᩥᨾᨣ᩠ᨣᩮᩣ ᨸᨭᩥᨸᨳᩮᩣ, ᩋᨴ᩠ᨵᩣᨶᩴ ᨴᩦᨥ ᨾᨬ᩠ᨩᩈᩴ;

ᩈᩩᨸ᩠ᨸᨳᩮᩣ ᨲᩩ ᩈᩩᨸᨶ᩠ᨳᩮᩣ ᨧ, ᩏᨸ᩠ᨸᨳᩴ ᨲ᩠ᩅᨸᨳᩴ ᨽᩅᩮ.

ᨨᨲ᩠ᨲᩥᩴᩈᨸᩁᨾᩣᨱᩪᨶ, ᨾᩮᨠᩮᩣ ᨱᩩ ᨧ ᨨᨲ᩠ᨲᩥᩴᩈ ᨲᩮ;

ᨲᨩ᩠ᨩᩣᩁᩦ ᨲᩣᨸᩥ ᨨᨲ᩠ᨲᩥᩴᩈ, ᩁᨳᩁᩮᨱᩩ ᨨᨲ᩠ᨲᩥᩴᩈ ᨲᩮ.

ᩃᩥᨠ᩠ᨡᩣᨲᩣ ᩈᨲ᩠ᨲ ᩐᨠᩣ ᨲᩣ, ᨵᨬ᩠ᨬᨾᩣᩈᩮᩣᨲᩥ ᩈᨲ᩠ᨲ ᨲᩮ;

ᩈᨲ᩠ᨲ ᨦ᩠ᨣᩩᩃ’ ᨾᨾᩩ ᨴ᩠ᩅᩥᨧ᩠ᨨ, ᩅᩥᨴᨲ᩠ᨳᩥ ᨲᩣ ᨴᩩᩅᩮ ᩈᩥᨿᩩᩴ.

ᩁᨲᨶᩴ ¶ ᨲᩣᨶᩥ ᩈᨲ᩠ᨲᩮᩅ, ᨿᨭ᩠ᨮᩥ ᨲᩣ ᩅᩦᩈᨲᩪ ᩈᨽᩴ;

ᨣᩣᩅᩩᨲ ᨾᩩᩈᨽᩣᩈᩦᨲᩥ, ᨿᩮᩣᨩᨶᩴ ᨧᨲᩩᨣᩣᩅᩩᨲᩴ.

ᨵᨶᩩᨸᨬ᩠ᨧᩈᨲᩴ ᨠᩮᩣᩈᩮᩣ, ᨠᩁᩦᩈᩴ ᨧᨲᩩᩁᨾ᩠ᨻᨱᩴ;

ᩋᨻ᩠ᨽᨶ᩠ᨲᩁᩴ ᨲᩩ ᩉᨲ᩠ᨳᩣᨶ, ᨾᨭ᩠ᨮᩅᩦᩈ ᨸᨾᩣᨱᨲᩮᩣ.

ᨸᩩᩁᩴ ᨶᨣᩁ ᨾᩥᨲ᩠ᨳᩦ ᩅᩣ, ᨮᩣᨶᩦᨿᩴ ᨸᩩᨭᨽᩮᨴᨶᩴ;

ᨳᩥᨿᩴ ᨲᩩ ᩁᩣᨩᨵᩣᨶᩦ [ᩁᩣᨩᨮᩣᨶᩦ (ᨭᩦ.)] ᨧ, ᨡᨶ᩠ᨵᩣᩅᩣᩁᩮᩣ ᨽᩅᩮ ᨳ ᨧ.

ᩈᩣᨡᩣᨶᨣᩁ ᨾᨬ᩠ᨬᨲᩕ, ᨿᩴ ᨲᩴ ᨾᩪᩃᨸᩩᩁᩣ ᨸᩩᩁᩴ;

ᨻᩣᩁᩣᨱᩈᩦ ᨧ ᩈᩣᩅᨲ᩠ᨳᩥ, ᩅᩮᩈᩣᩃᩦ ᨾᩥᨳᩥᩃᩣ, ᩊᩅᩦ.

ᨠᩮᩣᩈᨾ᩠ᨻᩩ, ᨩ᩠ᨩᩮᨶᩥᨿᩮᩣ ᨲᨠ᩠ᨠ, ᩈᩥᩃᩣ ᨧᨾ᩠ᨸᩣ ᨧ ᩈᩣᨣᩃᩴ;

ᩈᩩᩈᩩᨾᩣᩁᨣᩥᩁᩴ [ᩈᩴᩈᩩᨾᩣᩁ (ᨭᩦᨠᩣ)] ᩁᩣᨩ, ᨣᩉᩴ ᨠᨸᩥᩃᩅᨲ᩠ᨳᩩ ᨧ.

ᩈᩣᨠᩮᨲ, ᨾᩥᨶ᩠ᨴᨸᨲ᩠ᨳᨬ᩠ᨧᩮᩣ, ᨠ᩠ᨠᨭ᩠ᨮᩣ ᨸᩣᨭᩃᩥᨸᩩᨲ᩠ᨲᨠᩴ;

ᨩᩮᨲᩩᨲ᩠ᨲᩁᨬ᩠ᨧ ᩈᨦ᩠ᨠᩔᩴ, ᨠᩩᩈᩥᨶᩣᩁᩣᨴᨿᩮᩣ ᨸᩩᩁᩦ.

ᩁᨧ᩠ᨨᩣ ᨧ ᩅᩥᩈᩥᨡᩣ ᩅᩩᨲ᩠ᨲᩣ, ᩁᨳᩥᨠᩣ ᩅᩦᨳᩥ ᨧᩣᨸ᩠ᨿᨳ;

ᨻ᩠ᨿᩪᩉᩮᩣ ᩁᨧ᩠ᨨᩣ ᩋᨶᩥᨻ᩠ᨻᩥᨴ᩠ᨵᩣ, ᨶᩥᨻ᩠ᨻᩥᨴ᩠ᨵᩣ ᨲᩩ ᨸᨳᨴ᩠ᨵᩥ ᨧ.

ᨧᨲᩩᨠ᩠ᨠᩴ ᨧᨧ᩠ᨧᩁᩮ ᨾᨣ᩠ᨣ, ᩈᨶ᩠ᨵᩥ ᩈᩥᨦ᩠ᨥᩣᨭᨠᩴ ᨽᩅᩮ;

ᨸᩣᨠᩣᩁᩮᩣ ᩅᩁᨱᩮᩣ ᨧᩣᨳ, ᩏᨴᩣᨸᩮᩣ [ᩏᨴ᩠ᨴᩣᨸ, ᩏᨴ᩠ᨴᩣᨸ] ᩏᨸᨠᩣᩁᩥᨠᩣ.

ᨠᩩᨭ᩠ᨭᩴ ᨲᩩ ᨽᩥᨲ᩠ᨲᩥ ᨶᩣᩁᩦ ᨳ, ᨣᩮᩣᨸᩩᩁᩴ ᨴ᩠ᩅᩣᩁᨠᩮᩣᨭ᩠ᨮᨠᩮᩣ;

ᩑᩈᩥᨠᩣ ᩍᨶ᩠ᨴᨡᩦᩃᩮᩣ ᨧ, ᩋᨭ᩠ᨭᩮᩣ ᨲ᩠ᩅᨭ᩠ᨭᩣᩃᨠᩮᩣ ᨽᩅᩮ.

ᨲᩮᩣᩁᨱᩴ ᨲᩩ ᨻᩉᩥᨴ᩠ᩅᩣᩁᩴ, ᨸᩁᩥᨡᩣᨲᩩ ᨧ ᨴᩦᨥᩥᨠᩣ;

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

ᩌᩅᩣᩈᩮᩣ ᨽᩅᨶᩴ ᩅᩮᩈ᩠ᨾᩴ, ᨶᩥᨠᩮᨲᨶᩴ ᨶᩥᩅᩮᩈᨶᩴ;

ᨥᩁᩴ ᨣᩉᨬ᩠ᨧᩣ, ᩅᩈᨳᩮᩣ, ᩈᩁᨱᨬ᩠ᨧ ᨸᨲᩥᩔᨿᩮᩣ.

ᩒᨠᩴ ᩈᩣᩃᩣ ᨡᨿᩮᩣ ᩅᩣᩈᩮᩣ, ᨳᩥᨿᩴ ᨠᩩᨭᩥ ᩅᩈᨲ᩠ᨿ’ᨸᩥ;

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

ᨸᩣᩈᩣᨴᩮᩣ ¶ ᨧᩮᩅ ᨿᩪᨸᩮᩣ ᨳ, ᨾᩩᨱ᩠ᨯᨧ᩠ᨨᨴᩮᩣ ᨧ ᩉᨾ᩠ᨾᩥᨿᩴ;

ᨿᩪᨸᩮᩣᨲᩩ ᨣᨩᨠᩩᨾ᩠ᨽᨾ᩠ᩉᩥ, ᩉᨲ᩠ᨳᩥᨶᨡᩮᩣ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩮᩣ.

ᩈᩩᨸᨱ᩠ᨱᩅᨦ᩠ᨠᨧ᩠ᨨᨴᨶ, ᨾᨯ᩠ᨰᨿᩮᩣᨣᩮᩣ ᩈᩥᨿᩣ ᨳ ᨧ;

ᩈᨽᩣᨿᨬ᩠ᨧ ᩈᨽᩣ ᨧᩣᨳ, ᨾᨱ᩠ᨯᨸᩴ ᩅᩣ ᨩᨶᩣᩃᨿᩮᩣ;

ᩋᨳᩮᩣ ᩌᩈᨶᩈᩣᩃᩣᨿᩴ, ᨸᨭᩥᨠ᩠ᨠᨾᨶ ᨾᩦᩁᩥᨲᩴ.

ᨩᩥᨶᩔ ᩅᩣᩈᨽᩅᨶ, ᨾᩥᨲ᩠ᨳᩦ ᨣᨶ᩠ᨵᨠᩩᨭᩥ ᨸ᩠ᨿᨳ;

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

ᩌᩅᩮᩈᨶᩴ ᩈᩥᨸ᩠ᨸᩈᩣᩃᩣ, ᩈᩮᩣᨱ᩠ᨯᩣ ᨲᩩ ᨸᩣᨶᨾᨶ᩠ᨴᩥᩁᩴ;

ᩅᨧ᩠ᨧᨭ᩠ᨮᩣᨶᩴ ᩅᨧ᩠ᨧᨠᩩᨭᩥ, ᨾᩩᨶᩦᨶᩴ ᨮᩣᨶ ᨾᩔᨾᩮᩣ.

ᨸᨱ᩠ᨿᩅᩥᨠ᩠ᨠᨿᩈᩣᩃᩣ ᨠᩩ, ᩌᨸᨱᩮᩣ ᨸᨱ᩠ᨿᩅᩦᨳᩥᨠᩣ;

ᩏᨴᩮᩣᩈᩥᨲᩮᩣ ᨽᨱ᩠ᨯᩈᩣᩃᩣ, ᨧᨦ᩠ᨠᨾᨶᩴ ᨲᩩ ᨧᨦ᩠ᨠᨾᩮᩣ.

ᨩᨶ᩠ᨲᩣᨥᩁᩴ ᨲ᩠ᩅᨣ᩠ᨣᩥᩈᩣᩃᩣ, ᨸᨸᩣ ᨸᩣᨶᩦᨿᩈᩣᩃᩥᨠᩣ;

ᨣᨻ᩠ᨽᩮᩣ ᩒᩅᩁᨠᩮᩣ ᩅᩣᩈᩣ, ᨣᩣᩁᩴ ᨲᩩ ᩈᨿᨶᩥᨣ᩠ᨣᩉᩴ.

ᩍᨲ᩠ᨳᩣᨣᩣᩁᩴ ᨲᩩ ᩒᩁᩮᩣᨵᩮᩣ, ᩈᩩᨴ᩠ᨵᨶ᩠ᨲᩮᩣ’ ᨶ᩠ᨲᩮᨸᩩᩁᨾ᩠ᨸᩥ ᨧ;

ᩋᩈᨻ᩠ᨻᩅᩥᩈᨿᨭ᩠ᨮᩣᨶᩴ, ᩁᨬ᩠ᨬᩴ ᨠᨧ᩠ᨨᨶ᩠ᨲᩁᩴ ᨾᨲᩴ.

ᩅᩣᨲᨸᩣᨶᩴ ᨣᩅᨠ᩠ᨡᩮᩣ ᨧ, ᨩᩣᩃᨬ᩠ᨧ ᩈᩦᩉᨸᨬ᩠ᨩᩁᩴ.

ᩌᩃᩮᩣᨠᩈᨶ᩠ᨵᩥ ᩅᩩᨲ᩠ᨲᩮᩣ ᨳ, ᩃᨦ᩠ᨣᩦ’ᨲ᩠ᨳᩦ ᨸᩃᩥᨥᩮᩣ ᨽᩅᩮ;

ᨠᨸᩥᩈᩦᩈᩮᩣ, ᨣ᩠ᨣᩃᨲ᩠ᨳᨾ᩠ᨽᩮᩣ, ᨶᩥᨻ᩠ᨻᩴ ᨲᩩ ᨨᨴ᩠ᨴᨠᩮᩣᨭᩥᨿᩴ.

ᨨᨴᨶᩴ ᨸᨭᩃᩴ ᨨᨴ᩠ᨴ, ᨾᨩᩥᩁᩴ ᨧᨧ᩠ᨧᩁᩮᩣ, ᨦ᩠ᨣᨱᩴ;

ᨸᨥᩣᨶᩮᩣ ᨸᨥᨶᩣ, ᩃᩥᨶ᩠ᨴᩮᩣ, ᨸᨾᩩᨡᩴ ᨴ᩠ᩅᩣᩁᨻᨶ᩠ᨵᨶᩴ.

ᨸᩥᨭ᩠ᨮᩈᨦ᩠ᨥᩣᨭᨠᩴ ᨴ᩠ᩅᩣᩁ, ᨻᩣᩉᩣ ᨠᩪᨭᩴ ᨲᩩ ᨠᨱ᩠ᨱᩥᨠᩣ;

ᨴ᩠ᩅᩣᩁᨬ᩠ᨧ ᨸᨭᩥᩉᩣᩁᩮᩣ ᨳ, ᩏᨾ᩠ᨾᩣᩁᩮᩣ ᨴᩮᩉᨶᩦ, ᨲ᩠ᨳᩥᨿᩴ.

ᩑᩊᨠᩮᩣ ᩍᨶ᩠ᨴᨡᩦᩃᩮᩣ ᨳ, ᨳᨾ᩠ᨽᩮᩣ ᨳᩪᨱᩮᩣ ᨸᩩᨾᩥᨲ᩠ᨳᩥᨿᩴ;

ᨸᩣᨭᩥᨠᩣ, ᨯ᩠ᨰᩮᨶ᩠ᨴᩩᨸᩣᩈᩣᨱᩮ, ᨣᩥᨬ᩠ᨩᨠᩣ ᨲᩩ ᨧ ᩍᨭ᩠ᨮᨠᩣ.

ᩅᩃᨽᩥᨧ᩠ᨨᩣᨴᩥᨴᩣᩁᩩᨾ᩠ᩉᩥ, ᩅᨦ᩠ᨠᩮ ᨣᩮᩣᨸᩣᨶᩈᩦ, ᨲ᩠ᨳᩥᨿᩴ;

ᨠᨸᩮᩣᨲᨸᩣᩃᩥᨠᩣᨿᩴ ᨲᩩ, ᩅᩥᨭᨦ᩠ᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨽᩅᩮ.

ᨠᩩᨬ᩠ᨧᩥᨠᩣᩅᩥᩅᩁᩴ ¶ ᨲᩣᩊ, ᨧ᩠ᨨᩥᨣ᩠ᨣᩃᩮᩣ ᨸ᩠ᨿᨳ ᨠᩩᨬ᩠ᨧᩥᨠᩣ;

ᨲᩣᩊᩮᩣ’ᩅᩣᨸᩩᩁᨱᩴ ᨧᩣᨳ, ᩅᩮᨴᩥᨠᩣ ᩅᩮᨴᩥ ᨠᨳ᩠ᨿᨲᩮ.

ᩈᨦ᩠ᨥᩣᨲᩮᩣ ᨸᨠ᩠ᨡᨸᩣᩈᩮᩣ ᨧ, ᨾᨶ᩠ᨴᩥᩁᨦ᩠ᨣᩣ ᨲᩩᩃᩣ ᩋᨸᩥ;

ᨳᩥᨿᩴ ᩈᨾ᩠ᨾᩩᨩ᩠ᨩᨶᩦ ᨧᩮᩅ, ᩈᨾ᩠ᨾᨩ᩠ᨩᨶᩦ ᨧ ᩈᩮᩣᨵᨶᩦ.

ᩈᨦ᩠ᨠᨭᩦᩁᩴ ᨲᩩ ᩈᨦ᩠ᨠᩣᩁ, ᨭ᩠ᨮᩣᨶᩴ ᩈᨦ᩠ᨠᩣᩁᨠᩪᨭᨠᩴ;

ᩋᨳᩮᩣ ᨠᨧᩅᩁᩮᩣ, ᨠ᩠ᩃᩣᨸᩮᩣ, ᩈᨦ᩠ᨠᩣᩁᩮᩣ ᨧ ᨠᩈᨾ᩠ᨻᩩᨸᩥ.

ᨥᩁᩣᨴᩥᨽᩪᨾᩥ ᨲᩴ ᩅᨲ᩠ᨳᩩ, ᨣᩣᨾᩮᩣ ᩈᩴᩅᩈᨳᩮᩣ ᨳ ᩈᩮᩣ;

ᨸᩣᨠᨭᩮᩣ ᨶᩥᨣᨾᩮᩣ ᨽᩮᩣᨣ, ᨾᨧ᩠ᨧᩣᨴᩥᨽ᩠ᨿᩮᩣ ᨵᩥ ᨲᩪᨴᩥᨲᩮᩣ [‘ᩋᨵᩥᨽᩪ’ᨲᩥ ᩎᩁᩥᨲᩮᩣ ᨠᨳᩥᨲᩮᩣ (ᨭᩦ.)].

ᨾᨶᩩᩔᩮᩣ ᨾᩣᨶᩩᩈᩮᩣ ᨾᨧ᩠ᨧᩮᩣ, ᨾᩣᨶᩅᩮᩣ ᨾᨶᩩᨩᩮᩣ ᨶᩁᩮᩣ;

ᨻᩩᨵᩮᩣ ᩅᩥᨴ᩠ᩅᩣ ᩅᩥᨽᩣᩅᩦ ᨧ, ᩈᨶ᩠ᨲᩮᩣ ᩈᨸ᩠ᨸᨬ᩠ᨬ ᨠᩮᩣᩅᩥᨴᩣ;

ᨵᩦᨾᩣ ᩈᩩᨵᩦ ᨠᩅᩥ ᨻ᩠ᨿᨲ᩠ᨲᩮᩣ, ᩅᩥᨧᨠ᩠ᨡᨱᩮᩣ ᩅᩥᩈᩣᩁᨴᩮᩣ.

ᨾᩮᨵᩣᩅᩦ ᨾᨲᩥᨾᩣ ᨸᨬ᩠ᨬᩮᩣ, ᩅᩥᨬ᩠ᨬᩪ ᨧ ᩅᩥᨴᩪᩁᩮᩣ ᩅᩥᨴᩪ;

ᨵᩦᩁᩮᩣ ᩅᩥᨸᩔᩦ ᨴᩮᩣᩈᨬ᩠ᨬᩪ, ᨻᩩᨴ᩠ᨵᩮᩣ ᨧ ᨴᨻ᩠ᨻ ᩅᩥᨴ᩠ᨴᩈᩩ.

ᩍᨲ᩠ᨳᩦ ᩈᩦᨾᨶ᩠ᨲᩥᨶᩦ ᨶᩣᩁᩦ, ᨳᩦ ᩅᨵᩪ ᩅᨶᩥᨲᩣ, ᨦ᩠ᨣᨶᩣ;

ᨸᨾᨴᩣ ᩈᩩᨶ᩠ᨴᩁᩦ ᨠᨶ᩠ᨲᩣ, ᩁᨾᨱᩦ ᨴᨿᩥᨲᩣ, ᨻᩃᩣ.

ᨾᩣᨲᩩᨣᩣᨾᩮᩣ ᨧ ᨾᩉᩥᩃᩣ, ᩃᩃᨶᩣ ᨽᩦᩁᩩ ᨠᩣᨾᩥᨶᩦ;

ᨠᩩᨾᩣᩁᩥᨠᩣ ᨲᩩ ᨠᨬ᩠ᨬᩣ ᨳ, ᨿᩩᩅᨲᩦ ᨲᩁᩩᨱᩦ ᨽᩅᩮ.

ᨵᩅᨲ᩠ᨳᩥᨶᩦ ᨲᩩ ᩈᨦ᩠ᨠᩮᨲᩴ, ᨿᩣᨲᩥ ᨿᩣ ᩈᩣ, ᨽᩥᩈᩣᩁᩥᨠᩣ.

ᨣᨱᩥᨠᩣ ¶ ᩅᩮᩈᩥᨿᩣ ᩅᨱ᩠ᨱ, ᨴᩣᩈᩦ ᨶᨣᩁᩈᩮᩣᨽᩥᨶᩦ;

ᩁᩪᨸᩪᨸᨩᩦᩅᩥᨶᩦ ᩅᩮᩈᩦ, ᨠᩩᩃᨭᩣ ᨲᩩ ᨧ ᨻᨶ᩠ᨵᨠᩦ.

ᩅᩁᩣᩁᩮᩣᩉᩮᩣ, ᨲ᩠ᨲᨾᩣ ᨾᨲ᩠ᨲ, ᨠᩣᩈᩥᨶᩦ ᩅᩁᩅᨱ᩠ᨱᩥᨶᩦ;

ᨸᨲᩥᨻ᩠ᨻᨲᩣ ᨲ᩠ᩅᨸᩥ ᩈᨲᩦ, ᨠᩩᩃᩥᨲ᩠ᨳᩦ ᨠᩩᩃᨸᩣᩃᩥᨠᩣ.

ᩅᩥᨵᩅᩣ ᨸᨲᩥᩈᩩᨬ᩠ᨬᩣ ᨳ, ᨸᨲᩥᨾ᩠ᨻᩁᩣ ᩈᨿᨾ᩠ᨻᩁᩣ;

ᩅᩥᨩᩣᨲᩣ ᨲᩩ ᨸᩈᩪᨲᩣ ᨧ, ᨩᩣᨲᩣᨸᨧ᩠ᨧᩣ ᨸᩈᩪᨲᩥᨠᩣ.

ᨴᩪᨲᩦ ᩈᨬ᩠ᨧᩣᩁᩥᨠᩣ ᨴᩣᩈᩦ, ᨲᩩ ᨧᩮᨭᩦ ᨠᩩᨭᨵᩣᩁᩥᨠᩣ;

ᩅᩣᩁᩩᨱᩦ, ᨠ᩠ᨡᨱᩥᨠᩣ ᨲᩩᩃ᩠ᨿᩣ, ᨡᨲ᩠ᨲᩥᨿᩣᨶᩦ ᨲᩩ ᨡᨲ᩠ᨲᩥᨿᩣ.

ᨴᩣᩁᩮᩣ ᨩᩣᨿᩣ ᨠᩃᨲ᩠ᨲᨬ᩠ᨧ, ᨥᩁᨱᩦ ᨽᩁᩥᨿᩣ ᨸᩥᨿᩣ,

ᨸᨩᩣᨸᨲᩦ ᨧ ᨴᩩᨲᩥᨿᩣ, ᩈᩣ ᨸᩣᨴᨸᩁᩥᨧᩣᩁᩥᨠᩣ.

ᩈᨡᩦ ᨲ᩠ᩅᩣ’ᩃᩦ ᩅᨿᩔᩣ ᨳ, ᨩᩣᩁᩦ ᨧᩮᩅᩣ’ᨲᩥᨧᩣᩁᩥᨶᩦ;

ᨸᩩᨾᩮ ᨲᩪ’ᨲᩩ ᩁᨩᩮᩣ ᨸᩩᨸ᩠ᨹᩴ, ᩏᨲᩩᨶᩦ ᨲᩩ ᩁᨩᩔᩃᩣ.

ᨸᩩᨸ᩠ᨹᩅᨲᩦ ᨣᩁᩩᨣᨻ᩠ᨽᩣ, ᨸᨶ᩠ᨶᩈᨲ᩠ᨲᩣ ᨧ ᨣᨻ᩠ᨽᩥᨶᩦ;

ᨣᨻ᩠ᨽᩣᩈᨿᩮᩣ ᨩᩃᩣᨻᩩᨸᩥ, ᨠᩃᩃᩴ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ.

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

ᨲᨶᩩᨩᩮᩣ ᨲᨶᨿᩮᩣ ᩈᩪᨶᩩ, ᨸᩩᨲ᩠ᨲᩣᨴᩦ ᨵᩦᨲᩁᩥ’ᨲ᩠ᨳᩥᨿᩴ;

ᨩᩣᨿᩣᨸᨲᩦ ᨩᨶᩥᨸᨲᩦ, ᨩᨿᨾ᩠ᨸᨲᩦ ᨲᩩ ᨴᨾ᩠ᨸᨲᩦ [ᨴᨾ᩠ᨸᨲᩦᨲᩥ ᨸᨴᩴ ᨸᩩᩃ᩠ᩃᩥᨦ᩠ᨣ ᨻᩉᩩᩅᨧᨶᨶ᩠ᨲᩴ ᩍᨠᩣᩁᨶ᩠ᨲᩴ, ᨲᩩᨴᨾ᩠ᨸᨲᩥ (ᨭᩦ.)];

ᩋᨳ ᩅᩔᩅᩁᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨸᨱ᩠ᨯᨠᩮᩣ ᨧ ᨶᨸᩩᩴᩈᨠᩴ.

ᨻᨶ᩠ᨵᩅᩮᩣ ᨻᨶ᩠ᨵᩩ ᩈᨩᨶᩮᩣ, ᩈᨣᩮᩣᨲ᩠ᨲᩮᩣ ᨬᩣᨲᩥ ᨬᩣᨲᨠᩮᩣ;

ᩋᨾ᩠ᨾ, ᨾ᩠ᨻᩣ ᨩᨶᨶᩦ ᨾᩣᨲᩣ, ᨩᨶᩮᨲ᩠ᨲᩥ ᨩᨶᩥᨠᩣ ᨽᩅᩮ;

ᨶᨶᨶ᩠ᨴᩣ ¶ ᩈᩣᨾᩥᨽᨣᩥᨶᩦ, ᨾᩣᨲᩣᨾᩉᩦ ᨲᩩ ᩋᨿ᩠ᨿᩥᨠᩣ;

ᨾᩣᨲᩩᩃᩮᩣ ᨾᩣᨲᩩᨽᩣᨲᩣ,ᩔ, ᨾᩣᨲᩩᩃᩣᨶᩦ ᨸᨩᩣᨸᨲᩥ.

ᨩᩣᨿᩣᨸᨲᩦᨶᩴ ᨩᨶᨶᩦ, ᩈᩔᩩ ᩅᩩᨲ᩠ᨲᩣᨳ ᨲᨸ᩠ᨸᩥᨲᩣ;

ᩈᩈᩩᩁᩮᩣ ᨽᩣᨣᩥᨶᩮᨿ᩠ᨿᩮᩣᨲᩩ, ᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨣᩥᨶᩥᨿᩣ ᨽᩅᩮ.

ᨶᨲ᩠ᨲᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᨸᨸᩩᨲ᩠ᨲᩮᩣ ᨳ, ᩈᩣᨾᩥᨽᩣᨲᩣ ᨲᩩ ᨴᩮᩅᩁᩮᩣ;

ᨾᩣᨲᩩᨧ᩠ᨨᩣ ᨾᩣᨲᩩᨽᨣᩥᨶᩦ, ᨸᩥᨲᩩᨧ᩠ᨨᩣ ᨽᨣᩥᨶᩦ ᨸᩥᨲᩩ;

ᩈᩮᩣᨴᩁᩥᨿᩮᩣ ᩈᨣᨻ᩠ᨽᩮᩣ ᨧ, ᩈᩮᩣᨴᩁᩮᩣ ᩈᩉᨩᩮᩣ ᨸ᩠ᨿᨳ;

ᨾᩣᨲᩣᨸᩥᨲᩪ ᨲᩮ ᨸᩥᨲᩁᩮᩣ, ᨸᩩᨲ᩠ᨲᩣ ᨲᩩ ᨸᩩᨲ᩠ᨲᨵᩦᨲᩁᩮᩣ.

ᩈᩈᩩᩁᩣ ᩈᩔᩩᩈᩈᩩᩁᩣ, ᨽᩣᨲᩩᨽᨣᩥᨶᩦ ᨽᩣᨲᩁᩮᩣ;

ᨻᩣᩃᨲ᩠ᨲᩴ ᨻᩣᩃᨲᩣ ᨻᩣᩃ᩠ᨿᩴ, ᨿᩮᩣᨻ᩠ᨻᨬ᩠ᨬᩴᨲᩩ ᨧ ᨿᩮᩣᨻ᩠ᨻᨶᩴ.

ᩈᩩᨠ᩠ᨠᩣ ᨲᩩ ᨸᩃᩥᨲᩴ ᨠᩮᩈᩣ, ᨴᨿᩮᩣ ᨳ ᨩᩁᨲᩣ ᨩᩁᩣ;

ᨸᩩᨳᩩᨠᩮᩣ ᨸᩥᩃ᩠ᩃᨠᩮᩣ ᨨᩣᨸᩮᩣ, ᨠᩩᨾᩣᩁᩮᩣ ᨻᩣᩃ ᨸᩮᩣᨲᨠᩣ.

ᩋᨳᩩ’ ᨲ᩠ᨲᩣᨶᩈᨿᩩ’ᨲ᩠ᨲᩣᨶ, ᩈᩮᨿ᩠ᨿᨠᩣ ᨳᨶᨸᩮᩣᨸᩥ ᨧ;

ᨲᩁᩩᨱᩮᩣ ᨧ ᩅᨿᨭ᩠ᨮᩮᩣ ᨧ, ᨴᩉᩁᩮᩣ ᨧ ᨿᩩᩅᩣ ᩈᩩᩈᩩ;

ᨾᩣᨱᩅᩮᩣᨴᩣᩁᨠᩮᩣᨧᩣᨳ, ᩈᩩᨠᩩᨾᩣᩁᩮᩣ ᩈᩩᨡᩮᨵᩥᨲᩮᩣ.

ᨾᩉᩃ᩠ᩃᨠᩮᩣ ᨧ ᩅᩩᨴ᩠ᨵᩮᩣ ᨧ, ᨳᩮᩁᩮᩣ ᨩᩥᨱ᩠ᨱᩮᩣ ᨧ ᨩᩥᨱ᩠ᨱᨠᩮᩣ;

ᩋᨣ᩠ᨣᨩᩮᩣ ᨸᩩᨻ᩠ᨻᨩᩮᩣ ᨩᩮᨭ᩠ᨮᩮᩣ, ᨠᨶᩥᨿᩮᩣ ᨠᨶᩥᨭ᩠ᨮᩮᩣ ᨶᩩᨩᩮᩣ.

ᩅᩃᩥᨲ᩠ᨲᨧᩮᩣ ᨲᩩ ᩅᩃᩥᨶᩮᩣ; ᨲᩦᩈᩩ’ᨲ᩠ᨲᩣᨶᩈᨿᩣᨴᨿᩮᩣ;

ᩈᩦᩈᩮᩣ’ᨲ᩠ᨲᨾᨦ᩠ᨣᩣᨶᩥ ᩈᩥᩁᩮᩣ, ᨾᩩᨴ᩠ᨵᩣ ᨧ ᨾᨲ᩠ᨳᨠᩮᩣ ᨽᩅᩮ;

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

ᩈᩦᨾᨶ᩠ᨲᩮᩣ ᨲᩩ ᨾᨲᩮᩣ ᨶᩣᩁᩥ, ᨠᩮᩈᨾᨩ᩠ᨫᨾ᩠ᩉᩥ ᨸᨴ᩠ᨵᨲᩥ.

ᩃᩮᩣᨾᩴ ¶ ᨲᨶᩩᩁᩩᩉᩴ ᩁᩮᩣᨾᩴ, ᨸᨾ᩠ᩉᩴ ᨸᨡᩩᨾ ᨾᨠ᩠ᨡᩥᨣᩴ;

ᨾᩔᩩ ᩅᩩᨲ᩠ᨲᩴ ᨸᩩᨾᨾᩩᨡᩮ, ᨽᩪ ᨲ᩠ᩅᩥᨲ᩠ᨳᩦ ᨽᨾᩩᨠᩮᩣ ᨽᨾᩩ.

ᨻᨸ᩠ᨸᩮᩣ [ᨡᨸ᩠ᨸᩮᩣ (ᨭᩦ.)] ᨶᩮᨲ᩠ᨲᨩᩃ’ᩔᩪᨶᩥ, ᨶᩮᨲ᩠ᨲᨲᩣᩁᩣ ᨠᨶᩦᨶᩥᨠᩣ;

ᩅᨴᨶᩴ ᨲᩩ ᨾᩩᨡᩴ ᨲᩩᨱ᩠ᨯᩴ, ᩅᨲ᩠ᨲᩴ ᩃᨸᨶ ᨾᩣᨶᨶᩴ.

ᨴ᩠ᩅᩥᨩᩮᩣ ᩃᨸᨶᨩᩮᩣ ᨴᨶ᩠ᨲᩮᩣ, ᨴᩈᨶᩮᩣ ᩁᨴᨶᩮᩣ ᩁᨴᩮᩣ;

ᨴᩣᨮᩣ ᨲᩩᨴᨶ᩠ᨲᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᩋᨸᩣᨦ᩠ᨣᩮᩣ ᨲ᩠ᩅᨠ᩠ᨡᩥᨠᩮᩣᨭᩥᩈᩩ.

ᨴᨶ᩠ᨲᩣᩅᩁᨱ ᨾᩮᩣᨭ᩠ᨮᩮᩣ ᨧᩣ, ᨸ᩠ᨿ’ᨵᩁᩮᩣ ᨴᩈᨶᨧ᩠ᨨᨴᩮᩣ;

ᨣᨱ᩠ᨯᩮᩣ ᨠᨸᩮᩣᩃᩮᩣ ᩉᨶ᩠ᩅᩥᨲ᩠ᨳᩦ [ᨣᨱ᩠ᨯᨲ᩠ᨳᩦ (ᨭᩦ.) ᩉᨶ᩠ᩅᨲ᩠ᨳᩦ=ᩉᨶᩩ+ᩍᨲ᩠ᨳᩦ; ᩉᨶ+ᩏ (ᨱ᩠ᩅᩣᨴᩥ)],

ᨣᩃᩮᩣ ᨧ ᨠᨱ᩠ᨮᩮᩣ ᨣᩦᩅᩣ ᨧ, ᨠᨶ᩠ᨵᩁᩣ ᨧ ᩈᩥᩁᩮᩣᨵᩁᩣ;

ᨠᨾ᩠ᨻᩩᨣᩦᩅᩣ ᨲᩩ ᨿᩣ ᨣᩦᩅᩣ, ᩈᩩᩅᨱ᩠ᨱᩣᩃᩥᨦ᩠ᨣᩈᨶ᩠ᨶᩥᨽᩣ;

ᩋᨦ᩠ᨠᩥᨲᩣ ᨲᩦᩉᩥ ᩃᩮᨡᩣᩉᩥ, ᨠᨾ᩠ᨻᩩᨣᩦᩅᩣ ᨳᩅᩣ ᨾᨲᩣ.

ᩋᩴᩈᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨽᩩᨩᩈᩥᩁᩮᩣ, ᨡᨶ᩠ᨵᩮᩣ ᨲᩔᨶ᩠ᨵᩥ ᨩᨲ᩠ᨲᩩ ᨲᩴ;

ᨻᩣᩉᩩᨾᩪᩃᩴ ᨲᩩ ᨠᨧ᩠ᨨᩮᩣ, ᨵᩮᩣ, ᨲ᩠ᩅ’ᩔ ᨸᩔ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.

ᨻᩣᩉᩩ ᨽᩩᨩᩣᨴ᩠ᩅᩦᩈᩩ ᨻᩣᩉᩣ, ᩉᨲ᩠ᨳᩮᩣ ᨲᩩ ᨠᩁ ᨸᩣᨱᨿᩮᩣ;

ᨾᨱᩥᨻᨶ᩠ᨵᩮᩣ ᨸᨠᩮᩣᨭ᩠ᨮᨶ᩠ᨲᩮᩣ, ᨠᨸ᩠ᨸᩁᩮᩣ ᨲᩩ ᨠᨸᩮᩣᨱ᩠ᨿ’ᨳ.

ᨾᨱᩥᨻᨶ᩠ᨵ ᨠᨶᩥᨭ᩠ᨮᩣᨶᩴ, ᨸᩣᨱᩥᩔ ᨠᩁᨽᩮᩣ,ᨶ᩠ᨲᩁᩴ;

ᨠᩁᩈᩣᨡᩣ, ᨦ᩠ᨣᩩᩃᩦ ᨲᩣ ᨲᩩ, ᨸᨬ᩠ᨧ, ᨦ᩠ᨣᩩᨭ᩠ᨮᩮᩣ ᨧ ᨲᨩ᩠ᨩᨶᩦ;

ᨾᨩ᩠ᨫᩥᨾᩣ ᨶᩣᨾᩥᨠᩣ ᨧᩣᨸᩥ, ᨠᨶᩥᨭ᩠ᨮᩣ’ᨲᩥ ᨠᨾᩣ ᩈᩥᨿᩩᩴ.

ᨸᨴᩮᩈᩮᩣ ᨲᩣᩃᨣᩮᩣᨠᨱ᩠ᨱᩣ, ᩅᩥᨴᨲ᩠ᨳᩥ,ᨲ᩠ᨳᩦ ᨠᨾᩣ ᨲᨲᩮ;

ᨲᨩ᩠ᨩᨶ᩠ᨿᩣᨴᩥᨿᩩᨲᩮ’ᨦ᩠ᨣᩩᨭ᩠ᨮᩮ, ᨸᩈᨲᩮᩣ ᨸᩣᨱᩥ ᨠᩩᨬ᩠ᨧᩥᨲᩮᩣ.

ᩁᨲᨶᩴ ᨠᩩᨠ᩠ᨠᩩ ᩉᨲ᩠ᨳᩮᩣ ᨳ, ᨸᩩᨾᩮ ᨠᩁᨸᩩᨭᩮᩣ,ᨬ᩠ᨩᩃᩥ;

ᨠᩁᨩᩮᩣ ᨲᩩ ᨶᨡᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨡᨭᨠᩮᩣ ᨾᩩᨭ᩠ᨮᩥ ᨧ ᨴ᩠ᩅᩦᩈᩩ.

ᨻ᩠ᨿᩣᨾᩮᩣ ᩈᩉᨠᩁᩣ ᨻᩣᩉᩩ, ᨴ᩠ᩅᩮ ᨸᩔᨴ᩠ᩅᨿᩅᩥᨲ᩠ᨳᨲᩣ;

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

ᩏᩁᩮᩣ ᨧ ᩉᨴᨿᩴ ᨧᩣᨳ, ᨳᨶᩮᩣ ᨠᩩᨧ ᨸᨿᩮᩣᨵᩁᩣ;

ᨧᩪᨧᩩᨠᩴ ᨲᩩ ᨳᨶᨣ᩠ᨣᩈ᩠ᨾᩥᩴ, ᨸᩥᨭ᩠ᨮᩴ ᨲᩩ ᨸᩥᨭ᩠ᨮᩥ ᨶᩣᩁᩥᨿᩴ.

ᨾᨩ᩠ᨫᩮᩣ’ᨶᩥᨲ᩠ᨳᩦ ¶ ᩅᩥᩃᨣ᩠ᨣᩮᩣ ᨧ, ᨾᨩ᩠ᨫᩥᨾᩴ ᨠᩩᨧ᩠ᨨᩥ [ᨧᨲᩩᨠ᩠ᨠᩴ ᩏᨴᩁᩮ; ᪙᪔᪔-ᨣᩣᨳᩣᨸᩥ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨲᩩ ᨴ᩠ᩅᩥᩈᩩ;

ᨣᩉᨱᩦᨲ᩠ᨳ᩠ᨿᩩᨴᩁᩴ ᨣᨻ᩠ᨽᩮᩣ, ᨠᩮᩣᨭ᩠ᨮᩮᩣᨶ᩠ᨲᩮᩣ ᨠᩩᨧ᩠ᨨᩥᩈᨾ᩠ᨽᩅᩮ.

ᨩᨥᨶᩴ ᨲᩩ ᨶᩥᨲᨾ᩠ᨻᩮᩣ ᨧ, ᩈᩮᩣᨱᩦ ᨧ ᨠᨭᩥ ᨶᩣᩁᩥᨿᩴ;

ᩋᨦ᩠ᨣᨩᩣᨲᩴ ᩁᩉᩔᨦ᩠ᨣᩴ, ᩅᨲ᩠ᨳᨣᩩᨿ᩠ᩉᨬ᩠ᨧ ᨾᩮᩉᨶᩴ.

ᨶᩥᨾᩥᨲ᩠ᨲᨬ᩠ᨧ ᩅᩁᨦ᩠ᨣᨬ᩠ᨧ, ᨻᩦᨩᨬ᩠ᨧ ᨹᩃᨾᩮᩅ ᨧ;

ᩋᩈᩩᨧᩥ ᩈᨾ᩠ᨽᩅᩮᩣ ᩈᩩᨠ᩠ᨠᩴ, ᨸᩣᨿᩩ ᨲᩩ ᨸᩩᩁᩥᩈᩮ ᨣᩩᨴᩴ;

ᩅᩣ ᨸᩩᨾᩮ ᨣᩪᨳ ᨠᩁᩦᩈ, ᩅᨧ᩠ᨧᩣᨶᩥ ᨧ ᨾᩃᩴ ᨨᨠᩴ.

ᩏᨧ᩠ᨧᩣᩁᩮᩣ ᨾᩦᩊ᩠ᩉ ᨾᩩᨠ᩠ᨠᩣᩁᩮᩣ, ᨸᩔᩣᩅᩮᩣ ᨾᩩᨲ᩠ᨲ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᨸᩪᨲᩥᨾᩩᨲ᩠ᨲᨬ᩠ᨧ ᨣᩮᩣᨾᩩᨲ᩠ᨲᩮ, ᩔᩣᨴᩦᨶᩴ ᨨᨠᨱᩴ ᨾᩃᩮ.

ᨴ᩠ᩅᩦᩈ᩠ᩅᨵᩮᩣ ᨶᩣᨽᩥᨿᩣ ᩅᨲ᩠ᨳᩥ, ᩏᨧ᩠ᨨᨦ᩠ᨣ’ᨦ᩠ᨠᩣ ᨲᩩ’ᨽᩮᩣ ᨸᩩᨾᩮ;

ᩐᩁᩩ ᩈᨲ᩠ᨳᩥ ᨸᩩᨾᩮ ᩐᩁᩩ, ᨸᨻ᩠ᨻᩴ ᨲᩩ ᨩᩣᨱᩩ ᨩᨱ᩠ᨱᩩ ᨧ.

ᨣᩮᩣᨸ᩠ᨹᨠᩮᩣ ᨸᩣᨴᨣᨱ᩠ᨮᩥᨸᩥ, ᨸᩩᨾᩮ ᨲᩩ ᨸᨱ᩠ᩉᩥ ᨸᩣᩈᨱᩥ;

ᨸᩣᨴᨣ᩠ᨣᩴ ᨸᨸᨴᩮᩣ ᨸᩣᨴᩮᩣ, ᨲᩩ ᨸᨴᩮᩣ ᨧᩁᨱᨬ᩠ᨧ ᩅᩣ.

ᩋᨦ᩠ᨣᩴᨲ᩠ᩅ’ᩅᨿᩅᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨹᩣᩈᩩᩃᩥᨠᩣ ᨲᩩ ᨹᩣᩈᩩᨠᩣ;

ᨸᨱ᩠ᨯᨠᩮ ᩋᨭ᩠ᨮᩥ ᨵᩣᨲ᩠ᩅᩥᨲ᩠ᨳᩦ, ᨣᩃᨶ᩠ᨲᨭ᩠ᨮᩥ ᨲᩩ ᩋᨠ᩠ᨡᨠᩮᩣ.

ᨠᨸ᩠ᨸᩁᩮᩣ ᨲᩩ ᨠᨸᩣᩃᩴ ᩅᩣ, ᨠᨱ᩠ᨯᩁᩣ ᨲᩩ ᨾᩉᩣᩈᩥᩁᩣ;

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

ᩁᩈᩉᩁᨱ᩠ᨿ’ᨳᩮᩣ ᨾᩴᩈ, ᨾᩣᨾᩥᩈᩴ ᨸᩥᩈᩥᨲᩴ ᨽᩅᩮ;

ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩴ ᨲᩩ ᩅᩃ᩠ᩃᩪᩁ, ᨾᩩᨲ᩠ᨲᨲ᩠ᨲᩴ ᩋᨳ ᩃᩮᩣᩉᩥᨲᩴ.

ᩁᩩᨵᩥᩁᩴ ᩈᩮᩣᨱᩥᨲᩴ ᩁᨲ᩠ᨲᩴ, ᩃᩣᩃᩣ ᨡᩮᩊᩮᩣ ᩑᩃᩣ ᨽᩅᩮ;

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

ᩅᩈᩣ ᩅᩥᩃᩦᨶᩈ᩠ᨶᩮᩉᩮᩣ ᨳ, ᨾᩮᨴᩮᩣ ᨧᩮᩅ ᩅᨸᩣ ᨽᩅᩮ;

ᩌᨠᨸ᩠ᨸᩮᩣ ᩅᩮᩈᩮᩣ ᨶᩮᨸᨧ᩠ᨨᩴ, ᨾᨱ᩠ᨯᨶᩴ ᨲᩩ ᨸᩈᩣᨵᨶᩴ.

ᩅᩥᨽᩪᩈᨶᩴ ᨧᩣᨽᩁᨱᩴ, ᩋᩃᨦ᩠ᨠᩣᩁᩮᩣ ᨸᩥᩃᨶ᩠ᨵᨶᩴ;

ᨠᩥᩁᩦᨭ ᨾᨠᩩᨭᩣ’ᨶᩥᨲ᩠ᨳᩦ, ᨧᩪᩊᩣᨾᨱᩥ ᩈᩥᩁᩮᩣᨾᨱᩥ.

ᩈᩥᩁᩮᩣᩅᩮᨮᨶ ¶ ᨾᩩᨱ᩠ᩉᩦᩈᩴ, ᨠᩩᨱ᩠ᨯᩃᩴ ᨠᨱ᩠ᨱᩅᩮᨮᨶᩴ;

ᨠᨱ᩠ᨱᩥᨠᩣ ᨠᨱ᩠ᨱᨸᩪᩁᩮᩣ ᨧ, ᩈᩥᨿᩣ ᨠᨱ᩠ᨱᩅᩥᨽᩪᩈᨶᩴ.

ᨠᨱ᩠ᨮᨽᩪᩈᩣ ᨲᩩ ᨣᩦᩅᩮᨿ᩠ᨿᩴ, ᩉᩣᩁᩮᩣ ᨾᩩᨲ᩠ᨲᩣᩅᩃᩥ’ᨲ᩠ᨳᩥᨿᩴ;

ᨶᩥᨿᩩᩁᩮᩣ ᩅᩃᨿᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᨭᨠᩴ ᨸᩁᩥᩉᩣᩁᨠᩴ.

ᨠᨦ᩠ᨠᨱᩴ ᨠᩁᨽᩪᩈᩣ ᨳ, ᨠᩥᨦ᩠ᨠᩥᨱᩦ [ᨠᩥᩴᨠᨱᩦ ᨠᩥᩴ ᨠᨱᩥᨠᩣ (ᨠ.)] ᨡᩩᨴ᩠ᨴᨥᨱ᩠ᨭᩥᨠᩣ;

ᩋᨦ᩠ᨣᩩᩃᩦᨿᨠ ᨾᨦ᩠ᨣᩩᩃ᩠ᨿᩣ, ᨽᩁᨱᩴ, ᩈᩣᨠ᩠ᨡᩁᩴ ᨲᩩ ᨲᩴ.

ᨾᩩᨴ᩠ᨴᩥᨠᩣ’ᨦ᩠ᨣᩩᩃᩥᨾᩩᨴ᩠ᨴᩣ ᨳ, ᩁᩈᨶᩣ ᨾᩮᨡᩃᩣ ᨽᩅᩮ;

ᨠᩮᨿᩪᩁ ᨾᨦ᩠ᨣᨴᨬ᩠ᨧᩮᩅ, ᨻᩣᩉᩩᨾᩪᩃᩅᩥᨽᩪᩈᨶᩴ.

ᨸᩣᨴᨦ᩠ᨣᨴᩴ ᨲᩩ ᨾᨬ᩠ᨩᩦᩁᩮᩣ, ᨸᩣᨴᨠᨭᨠ ᨶᩪᨸᩩᩁᩣ;

ᩋᩃᨦ᩠ᨠᩣᩁᨸ᩠ᨸᨽᩮᨴᩣ ᨲᩩ, ᨾᩩᨡᨹᩩᩃ᩠ᩃᩴ ᨲᨳᩮᩣ’ᨱ᩠ᨱᨲᩴ;

ᩏᨣ᩠ᨣᨲ᩠ᨳᨶᩴ ᨣᩥᨦ᩠ᨣᨾᨠ, ᨾᩥᨧ᩠ᨧᩮᩅᨾᩣᨴᨿᩮᩣ ᩈᩥᨿᩩᩴ.

ᨧᩮᩃ ᨾᨧ᩠ᨨᩣᨴᨶᩴ ᩅᨲ᩠ᨳᩴ, ᩅᩣᩈᩮᩣ ᩅᩈᨶ ᨾᩴᩈᩩᨠᩴ;

ᩋᨾ᩠ᨻᩁᨬ᩠ᨧ ᨸᨭᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨴᩩᩔᩴ ᨧᩮᩣᩃᩮᩣ ᨧ ᩈᩣᨭᨠᩮᩣ.

ᨡᩮᩣᨾᩴ ᨴᩩᨠᩪᩃᩴ ᨠᩮᩣᩈᩮᨿ᩠ᨿᩴ, ᨸᨲ᩠ᨲᩩᨱ᩠ᨱᩴ ᨠᨾ᩠ᨻᩃᩮᩣ ᨧ ᩅᩣ;

ᩈᩣᨱᩴ ᨠᩮᩣᨭᨾ᩠ᨻᩩᩁᩴ ᨽᨦ᩠ᨣ, ᨶ᩠ᨲ᩠ᨿᩣᨴᩥ ᩅᨲ᩠ᨳᨶ᩠ᨲᩁᩴ ᨾᨲᩴ.

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

ᨸᩣᩅᩣᩁᩮᩣ ᨲᩩ’ᨲ᩠ᨲᩁᩣᩈᨦ᩠ᨣᩮᩣ, ᩏᨸᩈᩴᨻ᩠ᨿᩣᨶ ᨾᩩᨲ᩠ᨲᩁᩴ.

ᩏᨲ᩠ᨲᩁᩦᨿ ᨾᨳᩮᩣ ᩅᨲ᩠ᨳ, ᨾᩉᨲᨶ᩠ᨲᩥ ᨾᨲᩴ ᨶᩅᩴ;

ᨶᨶ᩠ᨲᨠᩴ ᨠᨸ᩠ᨸᨭᩮᩣ ᨩᩥᨱ᩠ᨱ, ᩅᩈᨶᩴ ᨲᩩ ᨸᨭᨧ᩠ᨧᩁᩴ.

ᨠᨬ᩠ᨧᩩᨠᩮᩣ ᩅᩣᩁᩅᩣᨱᩴ ᩅᩣ, ᨳ ᩅᨲ᩠ᨳᩣᩅᨿᩅᩮ ᨴᩈᩣ;

ᨶᩣᩃᩥᨸᨭ᩠ᨭᩮᩣᨲᩥ ᨠᨳᩥᨲᩮᩣ, ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᨾ᩠ᩉᩥ ᨠᨬ᩠ᨧᩩᨠᩮᩣ.

ᩋᩁᩉᨴ᩠ᨵᨩᩮᩣ ᨧ ᨠᩣᩈᩣᨿ, ᨠᩣᩈᩣᩅᩣᨶᩥ ᨧ ᨧᩦᩅᩁᩴ;

ᨾᨱ᩠ᨯᩃᩴ ᨲᩩ ᨲᨴᨦ᩠ᨣᩣᨶᩥ, ᩅᩥᩅᨭ᩠ᨭ ᨠᩩᩈᩥᩌᨴᨿᩮᩣ.

ᨹᩃ,ᨲ᩠ᨲᨧ, ᨠᩥᨾᩥ, ᩁᩮᩣᨾᩣ, ᨶ᩠ᨿᩮᨲᩣ ᩅᨲ᩠ᨳᩔ ᨿᩮᩣᨶᩥᨿᩮᩣ;

ᨹᩣᩃᩴ ᨠᨸ᩠ᨸᩣᩈᩥᨠᩴ ᨲᩦᩈᩩ, ᨡᩮᩣᨾᩣᨴᩦ ᨲᩩ ᨲᨧᨻ᩠ᨽᩅᩣ.

ᨠᩮᩣᩈᩮᨿ᩠ᨿᩴ ¶ ᨠᩥᨾᩥᨩᩴ, ᩁᩮᩣᨾ, ᨾᨿᩴ ᨲᩩ ᨠᨾ᩠ᨻᩃᩴ ᨽᩅᩮ;

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

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

ᨶᩉᩣᨶᨬ᩠ᨧ ᩈᩥᨶᩣᨶᩮ ᨳᩮᩣ, ᨻ᩠ᨻᨭ᩠ᨭᨶᩩ’ᨾ᩠ᨾᨩ᩠ᨩᨶᩴ ᩈᨾᩴ.

ᩅᩥᩈᩮᩈᨠᩮᩣ ᨲᩩ ᨲᩥᩃᨠᩮᩣ, ᨲ᩠ᨿᩪᨽᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨧ ᨧᩥᨲ᩠ᨲᨠᩴ;

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

ᨣᩮᩣᩈᩦᩈᩴ ᨲᩮᩃᨸᨱ᩠ᨱᩥᨠᩴ, ᨸᩩᨾᩮ ᩅᩣ ᩉᩁᩥᨧᨶ᩠ᨴᨶᩴ;

ᨲᩥᩃᨸᨱ᩠ᨱᩦ ᨲᩩ ᨸᨲ᩠ᨲᨦ᩠ᨣ, ᩁᨬ᩠ᨩᨶᩴ ᩁᨲ᩠ᨲᨧᨶ᩠ᨴᨶᩴ.

ᨠᩣᩊᩣᨶᩩᩈᩣᩁᩦ ᨠᩣᩊᩥᨿᩴ, ᩃᩮᩣᩉᩴ ᨲ᩠ᩅᩣ’ᨣᩁᩩ ᨧᩣ’ᨣᩊᩩ;

ᨠᩣᩊᩣᨣᩁᩩᨲᩩ ᨠᩣᩊᩮ’ᩈ᩠ᨾᩥᩴ, ᨲᩩᩁᩩᨠ᩠ᨡᩮᩣᨲᩩ ᨧ ᨸᩥᨱ᩠ᨯᨠᩮᩣ.

ᨠᨲ᩠ᨳᩪᩁᩥᨠᩣ ᨾᩥᨣᨾᨴᩮᩣ, ᨠᩩᨭ᩠ᨮᩴ ᨲᩩ ᩋᨩᨸᩣᩃᨠᩴ;

ᩃᩅᨦ᩠ᨣᩴ ᨴᩮᩅᨠᩩᩈᩩᨾᩴ, ᨠᩈ᩠ᨾᩦᩁᨩᩴ ᨲᩩ ᨠᩩᨦ᩠ᨠᩩᨾᩴ.

ᨿᨠ᩠ᨡᨵᩪᨸᩮᩣ ᩈᨩ᩠ᨩᩩᩃᩈᩮᩣ, ᨲᨠ᩠ᨠᩮᩣᩃᩴ ᨲᩩ ᨧ ᨠᩮᩣᩃᨠᩴ;

ᨠᩮᩣᩈᨹᩃ ᨾᨳᩮᩣ ᨩᩣᨲᩥ, ᨠᩮᩣᩈᩴ ᨩᩣᨲᩥᨹᩃᩴ ᨽᩅᩮ.

ᨥᨶᩈᩣᩁᩮᩣ ᩈᩥᨲᨻ᩠ᨽᩮᩣ ᨧ, ᨠᨸ᩠ᨸᩪᩁᩴ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ;

ᩋᩃᨲ᩠ᨲᨠᩮᩣ ᨿᩣᩅᨠᩮᩣ ᨧ, ᩃᩣᨡᩣ ᨩᨲᩩ ᨶᨸᩩᩴᩈᨠᩮ.

ᩈᩥᩁᩥᩅᩣᩈᩮᩣ ᨲᩩ ᩈᩁᩃ, ᨴ᩠ᨴᩅᩮᩣ’ ᨬ᩠ᨩᨶᩴ ᨲᩩ ᨠᨩ᩠ᨩᩃᩴ;

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

ᨣᨶ᩠ᨵᨾᩣᩃ᩠ᨿᩣᨴᩥᩈᨦ᩠ᨡᩣᩁᩮᩣ, ᨿᩮᩣ ᨲᩴ ᩅᩣᩈᨶ ᨾᩩᨧ᩠ᨧᨲᩮ;

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

ᩏᨲ᩠ᨲᩴᩈᩮᩣ ᩈᩮᨡᩁᩣ’ ᩅᩮᩊᩣ, ᨾᩩᨴ᩠ᨵᨾᩣᩃ᩠ᨿᩮ ᩅᨭᩴᩈᨠᩮᩣ;

ᩈᩮᨿ᩠ᨿᩣ ᨧ ᩈᨿᨶᩴ ᩈᩮᨶᩴ, ᨸᩃ᩠ᩃᨦ᩠ᨠᩮᩣ ᨲᩩ ᨧ ᨾᨬ᩠ᨧᨠᩮᩣ.

ᨾᨬ᩠ᨧᩣᨵᩣᩁᩮᩣ ᨸᨭᩥᨸᩣᨴᩮᩣ, ᨾᨬ᩠ᨧᨦ᩠ᨣᩮ ᨲ᩠ᩅᨭᨶᩦ ᨲ᩠ᨳᩥᨿᩴ,

ᨠᩩᩊᩦᩁᨸᩣᨴᩮᩣ ᩌᩉᨧ᩠ᨧ, ᨸᩣᨴᩮᩣ ᨧᩮᩅ ᨾᩈᩣᩁᨠᩮᩣ;

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

ᨻᩥᨻ᩠ᨻᩮᩣᩉᨶᩴ ᨧᩮᩣ’ ᨸᨵᩣᨶᩴ, ᨸᩦᨮᩥᨠᩣ ᨸᩦᨮ ᨾᩣᩈᨶᩴ;

ᨠᩮᩣᨧ᩠ᨨᩴ ᨲᩩ ᨽᨴ᩠ᨴᨸᩦᨮᩮ ᨳᩣ, ᩈᨶ᩠ᨴᩦ ᨸᩦᨮᨶ᩠ᨲᩁᩮ ᨾᨲᩣ.

ᩏᨱ᩠ᨱᩣᨾᨿᩴ ᨲ᩠ᩅᨲ᩠ᨳᩁᨱᩴ, ᨧᩥᨲ᩠ᨲᨠᩴ ᩅᩣᨶᨧᩥᨲ᩠ᨲᨠᩴ.

ᨥᨶᨸᩩᨸ᩠ᨹᩴ ᨸᨭᩃᩥᨠᩣ, ᩈᩮᨲᩴ ᨲᩩ ᨸᨭᩥᨠᩣ ᨸ᩠ᨿᨳ;

ᨴ᩠ᩅᩥᨴᩈᩮᨠᨴᩈᩣᨶ᩠ᨿᩩ’ ᨴ᩠ᨴ,ᩃᩮᩣᨾᩥ ᩑᨠᨶ᩠ᨲᩃᩮᩣᨾᩥᨶᩮᩣ.

ᨲᨴᩮᩅ ᩈᩮᩣᩊᩈᩥᨲ᩠ᨳᩦᨶᩴ, ᨶᨧ᩠ᨧᨿᩮᩣᨣ᩠ᨣᨬ᩠ᩉᩥ ᨠᩩᨲ᩠ᨲᨠᩴ;

ᩈᩦᩉᨻ᩠ᨿᨣ᩠ᨥᩣᨴᩥᩁᩪᨸᩮᩉᩥ, ᨧᩥᨲ᩠ᨲᩴ ᩅᩥᨠᨲᩥᨠᩣ ᨽᩅᩮ.

ᨠᨭ᩠ᨭᩥᩔᩴ ᨠᩮᩣᩈᩮᨿ᩠ᨿᩴ ᩁᨲᨶ, ᨸᩁᩥᩈᩥᨻ᩠ᨻᩥᨲ ᨾᨲ᩠ᨳᩁᨱᩴ ᨠᨾᩣ;

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

ᨴᩦᨸᩮᩣ ᨸᨴᩦᨸᩮᩣ ᨸᨩ᩠ᨩᩮᩣᨲᩮᩣ, ᨸᩩᨾᩮ ᨲ᩠ᩅᩣᨴᩣᩈ ᨴᨸ᩠ᨸᨱᩣ;

ᨣᩮᨱ᩠ᨯᩩᨠᩮᩣ ᨠᨱ᩠ᨯᩩᨠᩮᩣ ᨲᩣᩃ, ᩅᨱ᩠ᨭᩴ ᨲᩩ ᨻᩦᨩᨶᩦᨲ᩠ᨳᩥᨿᩴ.

ᨧᨦ᩠ᨠᩮᩣᨭᨠᩮᩣ ᨠᩁᨱ᩠ᨯᩮᩣ ᨧ, ᩈᨾᩩᨣ᩠ᨣᩮᩣ ᩈᨾ᩠ᨸᩩᨭᩮᩣ ᨽᩅᩮ;

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

ᩅᩥᩅᩣᩉᩮᩣ ᨸᨿᨾᩣ ᨸᩣᨱᩥ, ᨣ᩠ᨣᩉᩮᩣ ᨸᩁᩥᨱᨿᩮᩣ ᨸ᩠ᨿᨳ;

ᨲᩥᩅᨣ᩠ᨣᩮᩣ ᨵᨾ᩠ᨾ, ᨠᩣᨾ,ᨲ᩠ᨳᩣ, ᨧᨲᩩᩅᨣ᩠ᨣᩮᩣ ᩈᨾᩮᩣᨠ᩠ᨡᨠᩣ.

ᨡᩩᨩ᩠ᨩᩮᩣ ᨧ ᨣᨱ᩠ᨯᩩᩃᩮᩣ ᩁᩔ, ᩅᩣᨾᨶᩣ ᨲᩩ ᩃᨠᩩᨱ᩠ᨯᨠᩮᩣ;

ᨸᨦ᩠ᨣᩩᩃᩮᩣ ᨸᩦᨮᩈᨸ᩠ᨸᩦ ᨧ, ᨸᨦ᩠ᨣᩩ ᨨᩥᨶ᩠ᨶᩥᩁᩥᨿᩣᨸᨳᩮᩣ.

ᨠᩩᨱᩦ ᩉᨲ᩠ᨳᩣᨴᩥᩅᨦ᩠ᨠᩮᩣ ᨧ, ᩅᩃᩥᩁᩮᩣ ᨲᩩ ᨧ ᨠᩮᨠᩁᩮᩣ.

ᨻᨵᩥᩁᩮᩣ ᩈᩩᨲᩥᩉᩦᨶᩮᩣ ᨳ, ᨣᩥᩃᩣᨶᩮᩣ ᨻ᩠ᨿᩣᨵᩥᨲᩣ’ᨲᩩᩁᩣ;

ᩏᨾ᩠ᨾᩣᨴᩅᨲᩥ ᩏᨾ᩠ᨾᨲ᩠ᨲᩮᩣ, ᨡᩩᨩ᩠ᨩᩣᨴᩦ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩣ.

ᩌᨲᨦ᩠ᨠᩮᩣ ᩌᨾᨿᩮᩣ ᨻ᩠ᨿᩣᨵᩥ, ᨣᨴᩮᩣ ᩁᩮᩣᨣᩮᩣ ᩁᩩᨩᩣᨸᩥ ᨧ;

ᨸᩦᨶᩈᩮᩣ [ᨸᩦᨶᩣᩈᩮᩣᨲᩥᨸᩥ ᨸᩣᨮᩮᩣ] ¶ ᨶᩣᩈᩥᨠᩣᩁᩮᩣᨣᩮᩣ,

ᨬᩮᨿ᩠ᨿᩴ ᨲ᩠ᩅ’ᩁᩩ ᩅᨱᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨹᩮᩣᨭᩮᩣ ᨲᩩ ᨸᩥᩊᨠᩣ ᨽᩅᩮ.

ᨸᩩᨻ᩠ᨻᩮᩣ ᨸᩪᨿᩮᩣ ᨳ ᩁᨲ᩠ᨲᩣᨲᩥ, ᩈᩣᩁᩮᩣ ᨸᨠ᩠ᨡᨶ᩠ᨴᩥᨠᩣ ᨸ᩠ᨿᨳ;

ᩋᨸᨾᩣᩁᩮᩣ ᩋᨸᩈ᩠ᨾᩣᩁᩮᩣ, ᨸᩣᨴᨹᩮᩣᨭᩮᩣ ᩅᩥᨸᩣᨴᩥᨠᩣ.

ᩅᩩᨯ᩠ᨰᩥᩁᩮᩣᨣᩮᩣ ᨲᩩ ᩅᩣᨲᨱ᩠ᨯᩴ, ᩈᩦᨸᨴᩴ ᨽᩣᩁᨸᩣᨴᨲᩣ;

ᨠᨱ᩠ᨯᩪ ᨠᨱ᩠ᨯᩪᨲᩥ ᨠᨱ᩠ᨯᩪᨿᩣ, ᨡᨩ᩠ᨩᩩ ᨠᨱ᩠ᨯᩪᩅᨶᩴ ᨸ᩠ᨿᨳ.

ᨸᩣᨾᩴ ᩅᩥᨲᨧ᩠ᨨᩥᨠᩣ ᨠᨧ᩠ᨨᩩ, ᩈᩮᩣᨳᩮᩣ ᨲᩩ ᩈᨿᨳᩪ’ᨴᩥᨲᩮᩣ;

ᨴᩩᨶ᩠ᨶᩣᨾᨠᨬ᩠ᨧ ᩋᩁᩥᩈᩴ, ᨨᨴ᩠ᨴᩥᨠᩣ ᩅᨾᨳᩪ’ᨴᩥᨲᩮᩣ.

ᨴᩅᨳᩩ ᨸᩁᩥᨲᩣᨸᩮᩣ ᨳ, ᨲᩥᩃᨠᩮᩣ ᨲᩥᩃᨠᩣᩊᨠᩮᩣ;

ᩅᩥᩈᩪᨧᩥᨠᩣ ᩍᨲᩥ ᨾᩉᩣ, ᩅᩥᩁᩮᨠᩮᩣ ᨳ ᨽᨣᨶ᩠ᨴᩃᩮᩣ [ᨽᨣᨶ᩠ᨴᩁᩮᩣ (ᨠ.)].

ᨾᩮᩉᩮᩣ ᨩᩁᩮᩣ ᨠᩣᩈ ᩈᩣᩈᩣ, ᨠᩩᨭ᩠ᨮᩴ ᩈᩪᩃᩣᨾᨿᨶ᩠ᨲᩁᩣ;

ᩅᩩᨲ᩠ᨲᩮᩣ ᩅᩮᨩ᩠ᨩᩮᩣ ᨽᩥᩈᨠ᩠ᨠᩮᩣ ᨧ, ᩁᩮᩣᨣᩉᩣᩁᩦ ᨲᩥᨠᩥᨧ᩠ᨨᨠᩮᩣ.

ᩈᩃ᩠ᩃᩅᩮᨩ᩠ᨩᩮᩣ ᩈᩃ᩠ᩃᨠᨲ᩠ᨲᩮᩣ, ᨲᩥᨠᩥᨧ᩠ᨨᩣ ᨲᩩ ᨸᨲᩥᨠᩕᩥᨿᩣ;

ᨽᩮᩈᨩ᩠ᨩ ᨾᨣᨴᩮᩣ ᨧᩮᩅ, ᨽᩮᩈᨩᩴ ᨾᩮᩣ’ᩈᨵᩴ ᨸ᩠ᨿᨳ.

ᨠᩩᩃᩴ ᩅᩴᩈᩮᩣ ᨧ ᩈᨶ᩠ᨲᩣᨶᩣ, ᨽᩥᨩᨶᩣ ᨣᩮᩣᨲ᩠ᨲ ᨾᨶ᩠ᩅᨿᩮᩣ;

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

ᩁᩣᨩᩣ ᨽᩪᨸᨲᩥ ᨽᩪᨸᩣᩃᩮᩣ, ᨸᨲ᩠ᨳᩥᩅᩮᩣ ᨧ ᨶᩁᩣᨵᩥᨸᩮᩣ.

ᨽᩪᨶᩣᨳᩮᩣ ¶ ᨩᨣᨲᩥᨸᩣᩃᩮᩣ, ᨴᩥᩈᨾ᩠ᨸᨲᩥ ᨩᨶᩣᨵᩥᨸᩮᩣ;

ᩁᨭ᩠ᨮᩣᨵᩥᨸᩮᩣ ᨶᩁᨴᩮᩅᩮᩣ, ᨽᩪᨾᩥᨸᩮᩣ ᨽᩪᨽᩩᨩᩮᩣ ᨸ᩠ᨿᨳ.

ᩁᩣᨩᨬ᩠ᨬᩮᩣ ᨡᨲ᩠ᨲᩥᨿᩮᩣ ᨡᨲ᩠ᨲᩴ, ᨾᩩᨴ᩠ᨵᩣᨽᩥᩈᩥᨲ᩠ᨲ ᨻᩣᩉᩩᨩᩣ;

ᩈᨻ᩠ᨻᨽᩩᨾ᩠ᨾᩮᩣ ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩦ, ᨽᩪᨸᩮᩣᨬ᩠ᨬᩮᩣ ᨾᨱ᩠ᨯᩃᩥᩔᩁᩮᩣ.

ᨸᩩᨾᩮ ᩃᩥᨧ᩠ᨨᩅᩥ ᩅᨩ᩠ᨩᩦ ᨧ, ᩈᨠ᩠ᨿᩮᩣ ᨲᩩ ᩈᩣᨠᩥᨿᩮᩣ ᨳ ᨧ;

ᨽᨴ᩠ᨴᨠᨧ᩠ᨧᩣᨶᩣ [ᨽᨴ᩠ᨴᩣ ᨠᨧ᩠ᨧᩣᨶᩣ (ᨭᩦ.)] ᩁᩣᩉᩩᩃ, ᨾᩣᨲᩣ ᨻᩥᨾ᩠ᨻᩣ ᨿᩈᩮᩣᨵᩁᩣ.

ᨠᩮᩣᨭᩦᨶᩴ ᩉᩮᨭ᩠ᨮᩥᨾᨶ᩠ᨲᩮᨶ, ᩈᨲᩴ ᨿᩮᩈᩴ ᨶᩥᨵᩣᨶᨣᩴ;

ᨠᩉᩣᨸᨱᩣᨶᩴ ᨴᩥᩅᩈ, ᩅᩊᨬ᩠ᨩᩮᩣ ᩅᩦᩈᨲᨾ᩠ᨻᨱᩴ.

ᨲᩮ ᨡᨲ᩠ᨲᩥᨿᨾᩉᩣᩈᩣᩃᩣ, ᩈᩦᨲᩥ ᨠᩮᩣᨭᩥᨵᨶᩣᨶᩥ ᨲᩩ;

ᨶᩥᨵᩣᨶᨣᩣᨶᩥ ᨴᩥᩅᩈ, ᩅᩊᨬ᩠ᨩᩮᩣ ᨧ ᨴᩈᨾ᩠ᨻᨱᩴ.

ᨿᩮᩈᩴ ᨴ᩠ᩅᩥᨩᨾᩉᩣᩈᩣᩃᩣ, ᨲᨴᩩᨸᨯ᩠ᨰᩮ ᨶᩥᨵᩣᨶᨣᩮ;

ᩅᩊᨬ᩠ᨩᩮ ᨧ ᨣᩉᨸᨲᩥ, ᨾᩉᩣᩈᩣᩃᩣ ᨵᨶᩮ ᩈᩥᨿᩩᩴ.

ᨾᩉᩣᨾᨲ᩠ᨲᩮᩣ ᨸᨵᩣᨶᨬ᩠ᨧ, ᨾᨲᩥᩈᨩᩦᩅᩮᩣ ᨾᨶ᩠ᨲᩥᨶᩦ;

ᩈᨩᩦᩅᩮᩣ ᩈᨧᩥᩅᩣ, ᨾᨧ᩠ᨧᩮᩣ, ᩈᩮᨶᩣᨶᩦ ᨲᩩ ᨧᨾᩪᨸᨲᩥ.

ᨶ᩠ᨿᩣᩈᩣᨴᩦᨶᩴ ᩅᩥᩅᩣᨴᩣᨶᩴ, ᩋᨠ᩠ᨡᨴᩔᩮᩣ ᨸᨴᨭ᩠ᨮᩁᩥ;

ᨴᩮᩣᩅᩣᩁᩥᨠᩮᩣ ᨸᨲᩦᩉᩣᩁᩮᩣ, ᨴ᩠ᩅᩣᩁᨭ᩠ᨮᩮᩣ ᨴ᩠ᩅᩣᩁᨸᩣᩃᨠᩮᩣ.

ᩋᨶᩦᨠᨭ᩠ᨮᩮᩣᨲᩥ ᩁᩣᨩᩪᨶᩴ, ᩋᨦ᩠ᨣᩁᨠ᩠ᨡᨣᨱᩮᩣ ᨾᨲᩮᩣ;

ᨠᨬ᩠ᨧᩩᨠᩦ ᩈᩮᩣᩅᩥᨴᩃ᩠ᩃᩮᩣ ᨧ, ᩋᨶᩩᨩᩦᩅᩦ ᨲᩩ ᩈᩮᩅᨠᩮᩣ.

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

ᩋᨾᩥᨲ᩠ᨲᩮᩣ ᩁᩥᨸᩩ ᩅᩮᩁᩦ ᨧ, ᩈᨸᨲ᩠ᨲᩣ ᩁᩣᨲᩥ ᩈᨲ᩠ᩅ’ᩁᩥ; (ᩈᨲ᩠ᨲᩩ+ᩋᩁᩥ)

ᨸᨧ᩠ᨧᨲ᩠ᨳᩥᨠᩮᩣ ᨸᩁᩥᨸᨶ᩠ᨳᩦ, ᨸᨭᩥᨸᨠ᩠ᨡᩣ ᩉᩥᨲᩣᨸᩁᩮᩣ.

ᨸᨧ᩠ᨧᩣᨾᩥᨲ᩠ᨲᩮᩣ ᩅᩥᨸᨠ᩠ᨡᩮᩣ ᨧ, ᨸᨧ᩠ᨧᨶᩦᨠ ᩅᩥᩁᩮᩣᨵᩥᨶᩮᩣ;

ᩅᩥᨴ᩠ᨴᩮᩈᩦ ᨧ ᨴᩥᩈᩮᩣ ᨴᩥᨭ᩠ᨮᩮᩣ,ᨳᩣ ᨶᩩᩁᩮᩣᨵᩮᩣ ᨶᩩᩅᨲ᩠ᨲᨶᩴ.

ᨾᩥᨲ᩠ᨲᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩅᨿᩔᩮᩣ ᨧ, ᩈᩉᩣᨿᩮᩣ [ᩈᩩᩉᨩ᩠ᨩᩮᩣ (ᨭᩦ.)] ᩈᩩᩉᨴᩮᩣ ᩈᨡᩣ;

ᩈᨾ᩠ᨽᨲ᩠ᨲᩮᩣ ᨴᩊ᩠ᩉᨾᩥᨲ᩠ᨲᩮᩣ ᨳ, ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩮᩣ ᨴᩥᨭ᩠ᨮᨾᨲ᩠ᨲᨠᩮᩣ.

ᨧᩁᩮᩣ ᨧ ᨣᩩᩊ᩠ᩉᨸᩩᩁᩥᩈᩮᩣ, ᨸᨳᩣᩅᩦ ᨸᨳᩥᨠᩮᩣ’ᨴ᩠ᨵᨣᩪ;

ᨴᩪᨲᩮᩣ ᨲᩩ ᩈᨶ᩠ᨴᩮᩈᩉᩁᩮᩣ, ᨣᨱᨠᩮᩣ ᨲᩩ ᨾᩩᩉᩩᨲ᩠ᨲᩥᨠᩮᩣ.

ᩃᩮᨡᨠᩮᩣ ¶ ᩃᩥᨸᩥᨠᩣᩁᩮᩣ ᨧ, ᩅᨱ᩠ᨱᩮᩣ ᨲᩩ ᩋᨠ᩠ᨡᩁᩮᩣ ᨸ᩠ᨿᨳ;

ᨽᩮᨴᩮᩣ ᨴᨱ᩠ᨯᩮᩣ ᩈᩣᨾ ᨴᩣᨶᩣ, ᨶ᩠ᨿᩩᨸᩣᨿᩣ ᨧᨲᩩᩁᩮᩣ ᩍᨾᩮ.

ᩏᨸᨩᩣᨸᩮᩣᨲᩩ ᨽᩮᨴᩮᩣ ᨧ, ᨴᨱ᩠ᨯᩮᩣ ᨲᩩ ᩈᩣᩉᩈᩴ ᨴᨾᩮᩣ;

ᩈᩣᨾ᩠ᨿ’ ᨾᨧ᩠ᨧᩮᩣ ᩈᨡᩣ ᨠᩮᩣᩈᩮᩣ, ᨴᩩᨣ᩠ᨣᨬ᩠ᨧ ᩅᩥᨩᩥᨲᩴ ᨻᩃᩴ;

ᩁᨩ᩠ᨩᨦ᩠ᨣᩣᨶᩦᨲᩥ ᩈᨲ᩠ᨲᩮᨲᩮ, ᩈᩥᨿᩩᩴ ᨸᨠᨲᩥᨿᩮᩣ ᨸᩥᨧ.

ᨸᨽᩣᩅᩩ’ᩔᩣᩉ, ᨾᨶ᩠ᨲᩣᨶᩴ, ᩅᩈᩣ ᨲᩥᩔᩮᩣ ᩉᩥ ᩈᨲ᩠ᨲᩥᨿᩮᩣ;

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

ᨲᩥᨣᩮᩣᨧᩁᩮᩣ ᨲᩩ ᨨᨠ᩠ᨠᨱ᩠ᨱᩮᩣ, ᩁᩉᩔᩴ ᨣᩩᨿ᩠ᩉ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᨲᩦᩈᩩ ᩅᩥᩅᩥᨲ᩠ᨲ ᩅᩥᨩᨶ, ᨨᨶ᩠ᨶᩣ, ᩁᩉᩮᩣ ᩁᩉᩮᩣ ᨻ᩠ᨿᨿᩴ;

ᩒᩅᩣᨴᩮᩣ ᨧᩣᨶᩩᩈᩥᨭ᩠ᨮᩥᨲ᩠ᨳᩦ, ᨸᩩᨾᩅᨩ᩠ᨩᩮ ᨶᩩᩈᩣᩈᨶᩴ;

ᩌᨱᩣ ᨧ ᩈᩣᩈᨶᩴ ᨬᩮᨿ᩠ᨿᩴ, ᩏᨴ᩠ᨴᩣᨶᩴ ᨲᩩ ᨧ ᨻᨶ᩠ᨵᨶᩴ.

ᩌᨣᩩ ᩅᩩᨲ᩠ᨲ [ᨾᨶ᩠ᨲᩩ (ᨠ.)] ᨾᨸᩁᩣᨵᩮᩣ, ᨠᩁᩮᩣ ᨲᩩ ᨻᩃᩥ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᨸᩩᨱ᩠ᨱᨸᨲ᩠ᨲᩮᩣ ᨲᩩᨭ᩠ᨮᩥᨴᩣᨿᩮᩣ, ᩏᨸᨴᩣ ᨲᩩ ᨧ ᨸᩣᨽᨲᩴ.

ᨲᨳᩮᩣ’ᨸᩣᨿᨶ ᨾᩩᨠ᩠ᨠᩮᩣᨧᩮᩣ, ᨸᨱ᩠ᨱᩣᨠᩣᩁᩮᩣ ᨸᩉᩮᨱᨠᩴ;

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

ᩌᨲᨸᨲ᩠ᨲᩴ ᨲᨳᩣ ᨨᨲ᩠ᨲᩴ, ᩁᨬ᩠ᨬᩴ ᨲᩩ ᩉᩮᨾᨾᩣᩈᨶᩴ;

ᩈᩦᩉᩣᩈᨶᩴ ᩋᨳᩮᩣ ᩅᩣᩊ, ᨻᩦᨩᨶᩦᨲ᩠ᨳᩦ ᨧ ᨧᩣᨾᩁᩴ.

ᨡᨣ᩠ᨣᩮᩣ ᨧ ᨨᨲ᩠ᨲ ᨾᩩᨱ᩠ᩉᩦᩈᩴ, ᨸᩣᨴᩩᨠᩣ ᩅᩣᩃᨻᩦᨩᨶᩦ;

ᩍᨾᩮ ᨠᨠᩩᨵᨽᨱ᩠ᨯᩣᨶᩥ, ᨽᩅᨶ᩠ᨲᩥ ᨸᨬ᩠ᨧ ᩁᩣᨩᩩᨶᩴ.

ᨽᨴ᩠ᨴᨠᩩᨾ᩠ᨽᩮᩣ ᨸᩩᨱ᩠ᨱᨠᩩᨾ᩠ᨽᩮᩣ, ᨽᩥᨦ᩠ᨠᩣᩁᩮᩣ ᨩᩃᨴᩣᨿᨠᩮᩣ;

ᩉᨲ᩠ᨳᩥ,ᩔ,ᩁᨳ,ᨸᨲ᩠ᨲᩦ ᨲᩩ, ᩈᩮᨶᩣ ᩉᩥ ᨧᨲᩩᩁᨦ᩠ᨣᩥᨶᩦ.

ᨠᩩᨬ᩠ᨩᩁᩮᩣ ᩅᩣᩁᨱᩮᩣ ᩉᨲ᩠ᨳᩦ, ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᨴ᩠ᩅᩥᩁᨴᩮᩣ ᨣᨩᩮᩣ;

ᨠᩣᩊᩣᩅᨠ ¶ ᨣᨦ᩠ᨣᩮᨿ᩠ᨿᩣ, ᨸᨱ᩠ᨯᩁ ᨲᨾ᩠ᨻᩣ ᨧ ᨸᩥᨦ᩠ᨣᩃᩮᩣ ᨣᨶ᩠ᨵᩮᩣ;

ᨠᩃᨽᩮᩣ ᨧᩮᩅ ᨽᩥᨦ᩠ᨠᩮᩣᨳ, ᨸᨽᩥᨶ᩠ᨶᩮᩣ ᨾᨲ᩠ᨲ ᨣᨩ᩠ᨩᩥᨲᩣ;

ᩉᨲ᩠ᨳᩥᨥᨭᩣ ᨲᩩ ᨣᨩᨲᩣ, ᩉᨲ᩠ᨳᩦᨶᩦ ᨲᩩ ᨠᩁᩮᨱᩩᨠᩣ.

ᨠᩩᨾ᩠ᨽᩮᩣ ᩉᨲ᩠ᨳᩥᩈᩥᩁᩮᩣᨸᩥᨱ᩠ᨯᩣ, ᨠᨱ᩠ᨱᨾᩪᩃᩴ ᨲᩩ ᨧᩪᩃᩥᨠᩣ;

ᩌᩈᨶᩴ ᨡᨶ᩠ᨵᨴᩮᩈᨾ᩠ᩉᩥ, ᨸᩩᨧ᩠ᨨᨾᩪᩃᩴ ᨲᩩ ᨾᩮᨧᨠᩮᩣ.

ᩌᩃᩣᨶ ᨾᩣᩊ᩠ᩉᨠᩮᩣ ᨳᨾ᩠ᨽᩮᩣ, ᨶᩥᨲ᩠ᨳᩦᨲᩩ ᨶᩥᨣᩊᩮᩣ’ᨶ᩠ᨴᩩᨠᩮᩣ;

ᨾᨩ᩠ᨫᨾ᩠ᩉᩥ ᨻᨶ᩠ᨵᨶᩴ ᨠᨧ᩠ᨨᩣ, ᨠᨸ᩠ᨸᨶᩮᩣ ᨲᩩ ᨠᩩᨳᩣᨴᨿᩮᩣ.

ᩒᨸᩅᨿ᩠ᩉᩮᩣ ᩁᩣᨩᩅᨿ᩠ᩉᩮᩣ, ᩈᨩ᩠ᨩᩥᨲᩮᩣ ᨲᩩ ᨧ ᨠᨸ᩠ᨸᩥᨲᩮᩣ;

ᨲᩮᩣᨾᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨸᩣᨴᩮ, ᩈᩥᨿᩣ ᩅᩥᨩ᩠ᨫᨶᨠᨱ᩠ᨭᨠᩮᩣ.

ᨲᩩᨲ᩠ᨲᩴ ᨲᩩ ᨠᨱ᩠ᨱᨾᩪᩃᨾ᩠ᩉᩥ, ᨾᨲ᩠ᨳᨠᨾ᩠ᩉᩥ ᨲᩩ ᩋᨦ᩠ᨠᩩᩈᩮᩣ;

ᨣᩣᨾᨱᩦᨿᩮᩣ ᨲᩩ ᨾᩣᨲᨦ᩠ᨣ, ᩉᨿᩣᨴ᩠ᨿᩣᨧᩁᩥᨿᩮᩣ ᨽᩅᩮ;

ᨥᩮᩣᨭᨠᩮᩣ ᨲᩩ ᨡᩊᩩᨦ᩠ᨠᩮᩣ ᨳ, ᨩᩅᨶᩮᩣ ᨧ ᨩᩅᩣᨵᩥᨠᩮᩣ;

ᨾᩩᨡᩣᨵᩣᨶᩴ ᨡᩃᩦᨶᩮᩣ ᩅᩣ, ᨠᩈᩣ ᨲ᩠ᩅ ᩔᩣᨽᩥᨲᩣᩊᩥᨶᩦ.

ᨠᩩᩈᩣ ᨲᩩ ᨶᩣᩈᩁᨩ᩠ᨩᩩᨾ᩠ᩉᩥ, ᩅᩊᩅᩣ’ᩔᩣ ᨡᩩᩁᩮᩣ ᩈᨹᩴ;

ᨸᩩᨧ᩠ᨨ ᨾᨶᩥᨲ᩠ᨳᩦ ᨶᨦ᩠ᨣᩩᨭ᩠ᨮᩴ, ᩅᩣᩃᩉᨲ᩠ᨳᩮᩣ ᨧ ᩅᩣᩃᨵᩥ.

ᩈᨶ᩠ᨴᨶᩮᩣ ¶ ᨧ ᩁᨳᩮᩣ ᨹᩩᩔ, ᩁᨳᩮᩣ ᨲᩩ ᨶᩁᨱᩣᨿ ᩈᩮᩣ;

ᩈᩥᩅᩥᨠᩣ ᨿᩣᨸ᩠ᨿᨿᩣᨶᨬ᩠ᨧᩣ, ᨶᩥᨲ᩠ᨳᩦ ᨲᩩ ᩈᨠᨭᩮᩣ ᨸ᩠ᨿ’ᨶᩴ [(ᩈᨠᨭᩮᩣ ᨸᩥ+ᩋᨶᩴ)];

ᨧᨠ᩠ᨠᩴ ᩁᨳᨦ᩠ᨣ ᨾᩣᨡ᩠ᨿᩣᨲᩴ, ᨲᩔᨶ᩠ᨲᩮᩣ ᨶᩮᨾᩥ ᨶᩣᩁᩥᨿᩴ.

ᨲᨾ᩠ᨾᨩ᩠ᨫᩮ ᨸᩥᨱ᩠ᨯᩥᨠᩣ ᨶᩣᨽᩥ, ᨠᩩᨻ᩠ᨻᩁᩮᩣ ᨲᩩ ᨿᩩᨣᨶ᩠ᨵᩁᩮᩣ;

ᩋᨠ᩠ᨡᨣ᩠ᨣᨠᩦᩃᩮ ᩌᨱᩦᨲ᩠ᨳᩦ, ᩅᩁᩩᨳᩮᩣ ᩁᨳᨣᩩᨲ᩠ᨿ’ᨳ.

ᨵᩩᩁᩮᩣ ᨾᩩᨡᩮ ᩁᨳᩔᨦ᩠ᨣᩣ, ᨲ᩠ᩅ ᨠ᩠ᨡᩮᩣ ᨸᨠ᩠ᨡᩁᩌᨴᨿᩮᩣ;

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

ᩁᨳᨧᩣᩁᩦ ᨲᩩ ᩈᩪᨲᩮᩣ ᨧ, ᨸᩣᨩᩥᨲᩣ ᨧᩮᩅ ᩈᩣᩁᨳᩦ;

ᨸᨴᩣᨲᩥ ᨸᨲ᩠ᨲᩦ ᨲᩩ ᨸᩩᨾᩮ, ᨸᨴᨣᩮᩣ ᨸᨴᩥᨠᩮᩣ ᨾᨲᩮᩣ;

ᩈᨶ᩠ᨶᩣᩉᩮᩣ ᨠᨦ᩠ᨠᨭᩮᩣ ᩅᨾ᩠ᨾᩴ, ᨠᩅᨧᩮᩣ ᩅᩣ ᩏᩁᨧ᩠ᨨᨴᩮᩣ.

ᨩᩣᩃᩥᨠᩣ ᨳ ᨧ ᩈᨶ᩠ᨶᨴ᩠ᨵᩮᩣ, ᩈᨩ᩠ᨩᩮᩣ ᨧ ᩅᨾ᩠ᨾᩥᨠᩮᩣ ᨽᩅᩮ;

ᩌᨾᩩᨠ᩠ᨠᩮᩣ ᨸᨭᩥᨾᩩᨠ᩠ᨠᩮᩣ ᨳ, ᨸᩩᩁᩮᨧᩣᩁᩦ ᨸᩩᩁᩮᨧᩁᩮᩣ.

ᨸᩩᨻ᩠ᨻᨦ᩠ᨣᨾᩮᩣ ᨸᩩᩁᩮᨣᩣᨾᩦ, ᨾᨶ᩠ᨴᨣᩣᨾᩦ ᨲᩩ ᨾᨶ᩠ᨳᩁᩮᩣ;

ᨩᩅᨶᩮᩣ ᨲᩩᩁᩥᨲᩮᩣ ᩅᩮᨣᩦ, ᨩᩮᨲᨻ᩠ᨻᩴ ᨩᩮᨿ᩠ᨿ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᩈᩪᩁ ᩅᩦᩁᩣ ᨲᩩ ᩅᩥᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᩈᩉᩣᨿᩮᩣ ᨶᩩᨧᩁᩮᩣ ᩈᨾᩣ;

ᩈᨶ᩠ᨶᨴ᩠ᨵᨸ᩠ᨸᨽᩩᨲᩦ ᨲᩦᩈᩩ, ᨸᩣᨳᩮᨿ᩠ᨿᩴ ᨲᩩ ᨧ ᩈᨾ᩠ᨻᩃᩴ.

ᩅᩣᩉᩥᨶᩦ ᨵᨩᩥᨶᩦ ᩈᩮᨶᩣ, ᨧᨾᩪ ᨧᨠ᩠ᨠᩴ ᨻᩃᩴ ᨲᨳᩣ;

ᨧᨲᩩᨸᩮᩣᩈᩮᩣᨲᩥ ᩑᨲᩮᨶ, ᩃᨠ᩠ᨡᨱᩮᨶᩣ ᨵᨾᨶ᩠ᨲᨲᩮᩣ.

ᩉᨲ᩠ᨳᩣᨶᩦᨠᩴ ᩉᨿᩣᨶᩦᨠᩴ, ᩁᨳᩣᨶᩦᨠᩴ ᨲᨿᩮᩣ ᨲᨿᩮᩣ;

ᨣᨩᩣᨴᨿᩮᩣ ᩈᩈᨲ᩠ᨳᩣ ᨲᩩ, ᨸᨲ᩠ᨲᩣᨶᩦᨠᩴ ᨧᨲᩩᨩ᩠ᨩᨶᩣ.

ᩈᨭ᩠ᨮᩥᩅᩴᩈᨠᩃᩣᨸᩮᩈᩩ, ¶ ᨸᨧ᩠ᨧᩮᨠᩴ ᩈᨭ᩠ᨮᩥᨴᨱ᩠ᨯᩥᩈᩩ;

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

ᩈᨾ᩠ᨸᨲ᩠ᨲᩥ ᩈᨾ᩠ᨸᨴᩣ ᩃᨠ᩠ᨡᩦ, ᩈᩥᩁᩦ ᩅᩥᨸᨲ᩠ᨲᩥ ᩌᨸᨴᩣ;

ᩋᨳᩣ ᩅᩩᨵᨬ᩠ᨧ [ᩌᨿᩩᨵᨶ᩠ᨲᩥᨸᩥ ᨸᩣᨮᩮᩣ] ᩉᩮᨲᩥ’ᨲ᩠ᨳᩦ, ᩈᨲ᩠ᨳᩴ ᨸᩉᩁᨱᩴ ᨽᩅᩮ.

ᨾᩩᨲ᩠ᨲᩣᨾᩩᨲ᩠ᨲ ᨾᨾᩩᨲ᩠ᨲᨬ᩠ᨧ, ᨸᩣᨱᩥᨲᩮᩣ ᨾᩩᨲ᩠ᨲᨾᩮᩅ ᨧ;

ᨿᨶ᩠ᨲᨾᩩᨲ᩠ᨲᨶ᩠ᨲᩥ ᩈᨠᩃᩴ, ᩌᨿᩩᨵᩴ ᨲᩴ ᨧᨲᩩᨻ᩠ᨻᩥᨵᩴ.

ᨾᩩᨲ᩠ᨲᩣᨾᩩᨲ᩠ᨲᨬ᩠ᨧ ᨿᨭ᩠ᨮ᩠ᨿᩣᨴᩥ, ᩋᨾᩩᨲ᩠ᨲᩴ ᨨᩩᩁᩥᨠᩣᨴᩥᨠᩴ;

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

ᩍᩔᩣᩈᩮᩣ ᨵᨶᩩ ᨠᩮᩣᨴᨱ᩠ᨯᩴ, ᨧᩣᨸᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᩁᩣᩈᨶᩴ;

ᩅᩣᨱᩮᩣ ᨠᨱ᩠ᨯ ᨾᩩᩈᩩ ᨴ᩠ᩅᩦᩈᩩ, ᨡᩩᩁᨸ᩠ᨸᩮᩣ [ᩏᩁᨸ᩠ᨸᩮᩣ (ᨠ.)] ᨲᩮᨩᨶᩣ’ᩈᨶᩴ;

ᨲᩪᨱᩦᨲ᩠ᨳᩥᨿᩴ ᨠᩃᩣᨸᩮᩣ ᨧ, ᨲᩪᨱᩮᩣ ᨲᩪᨱᩦᩁ ᩅᩣᨱᨵᩥ.

ᨸᨠ᩠ᨡᩮᩣ ᨲᩩ ᩅᩣᨩᩮᩣ ᨴᩥᨴ᩠ᨵᩮᩣ ᨲᩩ, ᩅᩥᩈᨸ᩠ᨸᩥᨲᩮᩣ ᩈᩁᩮᩣ ᨽᩅᩮ;

ᩃᨠ᩠ᨡᩴ ᩅᩮᨩ᩠ᨫᩴ ᩈᩁᨻ᩠ᨿᨬ᩠ᨧ, ᩈᩁᩣᨽ᩠ᨿᩣᩈᩮᩣ ᨲᩩ’ᨸᩣᩈᨶᩴ.

ᨾᨱ᩠ᨯᩃᨣ᩠ᨣᩮᩣ ᨲᩩ ᨶᩮᨲ᩠ᨲᩥᩴᩈᩮᩣ, ᩋᩈᩥ ᨡᨣ᩠ᨣᩮᩣ ᨧ ᩈᩣᨿᨠᩮᩣ;

ᨠᩮᩣᩈᩥᨲ᩠ᨳᩦ ᨲᨻ᩠ᨻᩥᨵᩣᨶᩮ ᨳᩮᩣ, ᨳᩁᩩ ᨡᨣ᩠ᨣᩣᨴᩥᨾᩩᨭ᩠ᨮᩥᨿᩴ.

ᨡᩮᨭᨠᩴ ᨹᩃᨠᩴ ᨧᨾ᩠ᨾᩴ, ᩍᩃ᩠ᩃᩦ ᨲᩩ ᨠᩁᨸᩣᩃᩥᨠᩣ;

ᨨᩩᩁᩥᨠᩣ ᩈᨲ᩠ᨿ’ᩈᩥᨸᩩᨲ᩠ᨲᩦ, ᩃᨣᩩᩊᩮᩣ ᨲᩩ ᨧ ᨾᩩᨣ᩠ᨣᩁᩮᩣ.

ᩈᩃ᩠ᩃᩮᩣ ᨶᩥᨲ᩠ᨳᩥ ᩈᨦ᩠ᨠᩩ ᨸᩩᨾᩮ, ᩅᩣᩈᩦ ᨲᩩ ᨲᨧ᩠ᨨᨶᩦᨲ᩠ᨳᩥᨿᩴ;

ᨠᩩᨮᩣᩁᩦ [ᨠᩩᨵᩣᩁᩦ (ᨭᩦ.)] ᨲ᩠ᨳᩦᨹᩁᩈᩩᩈᩮᩣ, ᨭᨦ᩠ᨠᩮᩣ ᨸᩣᩈᩣᨱᨴᩣᩁᨱᩮᩣ.

ᨠᨱᨿᩮᩣ ᨽᩥᨶ᩠ᨴᩥᩅᩣᩊᩮᩣ ᨧ, ᨧᨠ᩠ᨠᩴ ᨠᩩᨶ᩠ᨲᩮᩣ ᨣᨴᩣ ᨲᨳᩣ;

ᨶᩥᨿ᩠ᨿᩣᨶᩴ ᨣᨾᨶᩴ ᨿᩣᨲᩕᩣ, ᨸᨭ᩠ᨮᩣᨶᨬ᩠ᨧ ᨣᨾᩮᩣ ᨣᨲᩥ;

ᨧᩩᨱ᩠ᨱᩮᩣ ᨸᩴᩈᩩ ᩁᨩᩮᩣ ᨧᩮᩅ, ᨵᩪᩃᩦ’ᨲ᩠ᨳᩦ ᩁᩮᨱᩩ ᨧ ᨴ᩠ᩅᩥᩈᩩ.

ᨾᩣᨣᨵᩮᩣ ¶ ᨾᨵᩩᨠᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩅᨶ᩠ᨴᩦ ᨲᩩ ᨳᩩᨲᩥᨸᩣᨮᨠᩮᩣ;

ᨠᩮᨲᩩ ᨵᨩᩮᩣ ᨸᨭᩣᨠᩣ ᨧ, ᨠᨴᩃᩦ ᨠᩮᨲᨶᩴ ᨸ᩠ᨿᨳ;

ᨿᩮᩣ’ᩉᩴᨠᩣᩁᩮᩣ’ᨬ᩠ᨬᨾᨬ᩠ᨬᩔ, ᩈᩣ’ ᩉᨾᩉᨾᩥᨠᩣ ᨽᩅᩮ.

ᨻᩃᩴ ᨳᩣᨾᩮᩣ ᩈᩉᩴ ᩈᨲ᩠ᨲᩥ, ᩅᩥᨠ᩠ᨠᨾᩮᩣ ᨲ᩠ᩅᨲᩥᩈᩪᩁᨲᩣ;

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

ᩈᨦ᩠ᨣᩣᨾᩮᩣ ᩈᨾ᩠ᨸᩉᩣᩁᩮᩣ ᨧᩣ, ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᩈᨾᩁᩴ ᩁᨱᩴ;

ᩌᨩᩥᨲ᩠ᨳᩦ ᩌᩉᩅᩮᩣ ᨿᩩᨴ᩠ᨵ, ᨾᩣᨿᩮᩣᨵᨶᨬ᩠ᨧ ᩈᩴᨿᩩᨣᩴ.

ᨽᨱ᩠ᨯᨶᩴ ᨲᩩ ᩅᩥᩅᩣᨴᩮᩣ ᨧ, ᩅᩥᨣ᩠ᨣᩉᩮᩣ ᨠᩃᩉ ᨾᩮᨵᨣᩣ;

ᩏᨸ᩠ᨸᩣᨴᩮᩣ [ᩏᨸ᩠ᨸᩣᨲᩮᩣ (ᨠ.)᪑᪐᪒᪗-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨽᩪᨲᩅᩥᨠᨲᩥ, ᨿᩣ ᩈᩩᨽᩣᩈᩩᨽᩈᩪᨧᩥᨠᩣ;

ᩎᨲᩥ ᨲ᩠ᩅᩥᨲ᩠ᨳᩦ ᩋᨩᨬ᩠ᨬᨬ᩠ᨧ, ᩏᨸᩈᨣ᩠ᨣᩮᩣ ᩏᨸᨴ᩠ᨴᩅᩮᩣ.

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

ᨸᩁᩣᨩᨿᩮᩣ ᩁᨱᩮ ᨽᨦ᩠ᨣᩮᩣ, ᨸᩃᩣᨿᨶ ᨾᨸᨠ᩠ᨠᨾᩮᩣ.

ᨾᩣᩁᨱᩴ ᩉᨶᨶᩴ ᨥᩣᨲᩮᩣ, ᨶᩣᩈᨶᨬ᩠ᨧ ᨶᩥᩈᩪᨴᨶᩴ;

ᩉᩥᩴᩈᨶᩴ ᩈᩁᨱᩴ ᩉᩥᩴᩈᩣ, ᩅᨵᩮᩣ ᩈᩈᨶ ᨥᩣᨲᨶᩴ.

ᨾᩁᨱᩴ ᨠᩣᩃᨠᩥᩁᩥᨿᩣ, ᨸᩃᨿᩮᩣ ᨾᨧ᩠ᨧᩩ ᩋᨧ᩠ᨧᨿᩮᩣ;

ᨶᩥᨵᨶᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨶᩣᩈᩮᩣ, ᨠᩣᩃᩮᩣ’ᨶ᩠ᨲᩮᩣ ᨧᩅᨶᩴ ᨽᩅᩮ.

ᩌᩊᩉᨶᩴ ᩈᩩᩈᩣᨶᨬ᩠ᨧᩣ, ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨠᩩᨱᨸᩮᩣ ᨨᩅᩮᩣ.

ᨠᨻᨶ᩠ᨵᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨴᩮᩉᩮᩣ, ᩈᩥᩁᩮᩣᩈᩩᨬ᩠ᨬᩮᩣ ᩈᩉᨠᩕᩥᨿᩮᩣ;

ᩋᨳ ᩈᩥᩅᨳᩥᨠᩣ ᩅᩩᨲ᩠ᨲᩣ, ᩈᩩᩈᩣᨶᩈ᩠ᨾᩥᨬ᩠ᩉᩥ ᩌᨾᨠᩮ.

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

ᨠᩣᩁᩣ ᨲᩩ ᨻᨶ᩠ᨵᨶᩣᨣᩣᩁᩴ, ᨠᩣᩁᨱᩣ ᨲᩩ ᨧ ᨿᩣᨲᨶᩣ.

ᨻᩕᩉ᩠ᨾᨻᨶ᩠ᨵᩩ ¶ ᨴ᩠ᩅᩥᨩᩮᩣ ᩅᩥᨸ᩠ᨸᩮᩣ, ᨻᩕᩉ᩠ᨾᩣ ᨽᩮᩣᩅᩣᨴᩦ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;

ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ ᨣᩉᨭ᩠ᨮᩮᩣ ᨧ, ᩅᨶᨸ᩠ᨸᨲ᩠ᨳᩮᩣ ᨧ ᨽᩥᨠ᩠ᨡᩩᨲᩥ;

ᨽᩅᨶ᩠ᨲᩥ ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᩑᨲᩮ, ᩋᩔᨾᩣ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ.

ᨧᩁᨶ᩠ᨲᩣ ᩈᩉ ᩈᩦᩃᩣᨴᩦ, ᩈᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩮᩣ ᨾᩥᨳᩩ;

ᩏᨸᨩ᩠ᨫᩣᨿᩮᩣ ᩏᨸᨩ᩠ᨫᩣ ᨳᩣ, ᨧᩁᩥᨿᩮᩣ ᨶᩥᩔᨿᨴᩣᨴᩥᨠᩮᩣ [ᨶᩥᩔᨿᨴᩣᨿᨠᩮᩣ (ᨭᩦ.)].

ᩏᨸᨶᩦᨿᩣ ᨳᩅᩣ ᨸᩩᨻ᩠ᨻᩴ, ᩅᩮᨴ ᨾᨩ᩠ᨫᩣᨸᨿᩮ ᨴ᩠ᩅᩥᨩᩮᩣ;

ᨿᩮᩣ ᩈᨦ᩠ᨣᩴ ᩈᩁᩉᩔᨬ᩠ᨧᩣ, ᨧᩁᩥᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ᩈᩮᩣ.

ᨸᩣᩁᨾ᩠ᨸᩁᩥᨿ ᨾᩮᨲᩥᩉ᩠ᨿᩴ, ᩏᨸᨴᩮᩈᩮᩣ ᨲᨳᩮ’ᨲᩥᩉᩣ;

ᨿᩣᨣᩮᩣ ᨲᩩ ᨠᨲᩩ ᨿᨬ᩠ᨬᩮᩣ ᨳ, ᩅᩮᨴᩦᨲ᩠ᨳᩦ ᨽᩪ ᨸᩁᩥᨠ᩠ᨡᨲᩣ.

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

ᩈᨾ᩠ᨾᩣᨸᩣᩈᩮᩣ ᩅᩣᨩᨸᩮᨿ᩠ᨿ, ᨾᩥᨲᩥ ᨿᩣᨣᩣ ᨾᩉᩣ ᩍᨾᩮ.

ᩍᨲ᩠ᩅᩥᨩᩮᩣ [ᩍᨴᩥᨲ᩠ᩅᩥᨩᩮᩣ (ᨭᩦ.)] ᨿᩣᨩᨠᩮᩣ ᨧᩣᨳ,

ᨸᩁᩥᩈᩣ ᩈᨽᩣ ᩈᨾᨩ᩠ᨩᩣ ᨧ, ᨲᨳᩣ ᩈᨾᩥᨲᩥ ᩈᩴᩈᨴᩮᩣ.

ᨧᨲᩔᩮᩣ ᨸᩁᩥᩈᩣ ᨽᩥᨠ᩠ᨡᩩ, ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᨧ ᩏᨸᩣᩈᨠᩣ;

ᩏᨸᩣᩈᩥᨠᩣᨿᩮᩣᨲᩥ ᩍᨾᩣ, ᨳᩅᩣ ᨭ᩠ᨮ ᨸᩁᩥᩈᩣ ᩈᩥᨿᩩᩴ.

ᨲᩣᩅᨲᩥᩴᩈ,ᨴ᩠ᩅᩥᨩ,ᨠ᩠ᨡᨲ᩠ᨲ,ᨾᩣᩁ,ᨣ᩠ᨣᩉᨸᨲᩥᩔ ᨧ;

ᩈᨾᨱᩣᨶᩴ ᩅᩈᩣ ᨧᩣᨲᩩ, ᨾᩉᩣᩁᩣᨩᩥᨠ, ᨻᩕᩉ᩠ᨾᩩᨶᩴ.

ᨣᩣᨿᨲ᩠ᨲᩥᨸ᩠ᨸᨾᩩᨡᩴ ᨨᨶ᩠ᨴᩴ, ᨧᨲᩩᩅᩦᩈ’ᨠ᩠ᨡᩁᩴ ᨲᩩ ᨿᩴ;

ᩅᩮᨴᩣᨶ ᨾᩣᨴᩥᨽᩪᨲᩴ ᩈᩣ, ᩈᩣᩅᩥᨲ᩠ᨲᩦ ᨲᩥᨸᨴᩴ ᩈᩥᨿᩣ.

ᩉᨻ᩠ᨿᨸᩣᨠᩮ ᨧᩁᩩ ᨾᨲᩮᩣ, ᩈᩩᨩᩣ ᨲᩩ ᩉᩮᩣᨾᨴᨻ᩠ᨻᩥᨿᩴ;

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

ᨿᩪᨸᩮᩣ ᨳᩪᨱᩣᨿᩴ ᨶᩥᨾ᩠ᨾᨶ᩠ᨲ᩠ᨿ, ᨴᩣᩁᩩᨾ᩠ᩉᩥ ᨲ᩠ᩅ’ᩁᨱᩦ ᨴ᩠ᩅᩥᩈᩩ;

ᨣᩣᩉᨸ᩠ᨸᨧ᩠ᨧᩣ’ᩉᩅᨶᩦᨿᩮᩣ, ᨴᨠ᩠ᨡᩥᨱᨣ᩠ᨣᩥ ᨲᨿᩮᩣ’ ᨣ᩠ᨣᨿᩮᩣ.

ᨧᩣᨣᩮᩣ ᩅᩥᩔᨩ᩠ᨩᨶᩴ ᨴᩣᨶᩴ, ᩅᩮᩣᩔᨣ᩠ᨣᩮᩣ ᨧᩣᨸᨴᩮᩈᨶᩴ;

ᩅᩥᩔᩣᨱᨶᩴ ᩅᩥᨲᩁᨱᩴ, ᩅᩥᩉᩣᨿᩥᨲᩣ ᨸᩅᨩ᩠ᨩᨶᩴ.

ᨸᨬ᩠ᨧ ¶ ᨾᩉᩣᨸᩁᩥᨧ᩠ᨧᩣᨣᩮᩣ, ᩅᩩᨲ᩠ᨲᩮᩣ ᩈᩮᨭ᩠ᨮ, ᨵᨶᩔ ᨧ;

ᩅᩈᩮᨶ ᨸᩩᨲ᩠ᨲ ᨴᩣᩁᩣᨶᩴ, ᩁᨩ᩠ᨩᩔ’ ᨦ᩠ᨣᩣᨶ ᨾᩮᩅ ᨧ.

ᩋᨶ᩠ᨶᩴ ᨸᩣᨶᩴ ᨥᩁᩴ ᩅᨲ᩠ᨳᩴ, ᨿᩣᨶᩴ ᨾᩣᩃᩣ ᩅᩥᩃᩮᨸᨶᩴ;

ᨣᨶ᩠ᨵᩮᩣ ᩈᩮᨿ᩠ᨿᩣ ᨸᨴᩦᨸᩮᨿ᩠ᨿᩴ, ᨴᩣᨶᩅᨲ᩠ᨳᩪ ᩈᩥᨿᩩᩴ ᨴᩈ.

ᨾᨲᨲ᩠ᨳᩴ ᨲᨴᩉᩮ ᨴᩣᨶᩴ, ᨲᩦᩈ᩠ᩅᩮᨲ ᨾᩩᨴ᩠ᨵᨴᩮᩉᩥᨠᩴ;

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

ᨸᩩᨾᩮ ᩋᨲᩥᨳᩥ ᩌᨣᨶ᩠ᨲᩩ, ᨸᩣᩉᩩᨶᩣ ᩅᩮᩈᩥᨠᩣ ᨸ᩠ᨿᨳ;

ᩋᨬ᩠ᨬᨲ᩠ᨳ ᨣᨶ᩠ᨲᩩ ᨾᩥᨧ᩠ᨨᨶ᩠ᨲᩮᩣ, ᨣᨾᩥᨠᩮᩣ ᨳᩣ ᨣ᩠ᨥ ᨾᨣ᩠ᨥᩥᨿᩴ.

ᨸᨩ᩠ᨩᩴ ᨸᩣᨴᩮᩣᨴᨠᩣᨴᩮᩣ ᨳ, ᩈᨲ᩠ᨲᩣ’ᨣᨶ᩠ᨲ᩠ᩅᩣᨴᨿᩮᩣ ᨲᩥᩈᩩ;

ᩋᨸᨧᩥᨲ᩠ᨿ’ᨧ᩠ᨧᨶᩣ ᨸᩪᨩᩣ, ᨸᩉᩣᩁᩮᩣ ᨻᩃᩥ ᨾᩣᨶᨶᩣ.

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

ᨸᨲ᩠ᨳᨶᩣ ᨸᨱᩥᨵᩣᨶᨬ᩠ᨧ, ᨸᩩᩁᩥᩈᩮ ᨸᨱᩥᨵᩦᩁᩥᨲᩮᩣ.

ᩋᨩ᩠ᨫᩮᩈᨶᩣ ᨲᩩ ᩈᨠ᩠ᨠᩣᩁ, ᨸᩩᨻ᩠ᨻᨦ᩠ᨣᨾᨶᩥᨿᩮᩣᨩᨶᩴ;

ᨸᩁᩥᨿᩮᩈᨶᩣ ᨶ᩠ᩅᩮᩈᨶᩣ, ᨸᩁᩥᨿᩮᨭ᩠ᨮᩥ ᨣᩅᩮᩈᨶᩣ;

ᩏᨸᩣᩈᨶᩴ ᨲᩩ ᩈᩩᩔᩪᩈᩣ, ᩈᩣ ᨸᩣᩁᩥᨧᩁᩥᨿᩣ ᨽᩅᩮ.

ᨾᩮᩣᨶ ᨾᨽᩣᩈᨶᩴ ᨲᩩᨱ᩠ᩉᩦ, ᨽᩣᩅᩮᩣ ᨳ ᨸᨭᩥᨸᩣᨭᩥ ᩈᩣ;

ᩋᨶᩩᨠ᩠ᨠᨾᩮᩣ ᨸᩁᩥᨿᩣᨿᩮᩣ, ᩋᨶᩩᨸᩩᨻ᩠ᨻ᩠ᨿ’ᨸᩩᨾᩮ ᨠᨾᩮᩣ.

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

ᩅᩦᨲᩥᨠ᩠ᨠᨾᩮᩣ’ ᨩ᩠ᨫᨧᩣᩁᩮᩣ ᨳ, ᩅᩥᩅᩮᨠᩮᩣ ᨸᩩᨳᩩᨣᨲ᩠ᨲᨲᩣ.

ᨡᩩᨴ᩠ᨴᩣᨶᩩᨡᩩᨴ᩠ᨴᨠᩴ ᩌᨽᩥ, ᩈᨾᩣᨧᩣᩁᩥᨠ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᩌᨴᩥᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ ᨲᩩ, ᨲᨴᨬ᩠ᨬᩴ ᩈᩦᩃ ᨾᩦᩁᩥᨲᩴ.

ᨿᩮᩣ ᨸᩣᨸᩮᩉᩥ ᩏᨸᩣᩅᨲ᩠ᨲᩮᩣ, ᩅᩣᩈᩮᩣ ᩈᨴ᩠ᨵᩥᩴ ᨣᩩᨱᩮᩉᩥ ᩈᩮᩣ;

ᩏᨸᩅᩣᩈᩮᩣᨲᩥ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩮᩣ, ᩈᨻ᩠ᨻᨽᩮᩣᨣᩅᩥᩅᨩ᩠ᨩᩥᨲᩮᩣ.

ᨲᨸᩔᩦ ᨽᩥᨠ᩠ᨡᩩ ᩈᨾᨱᩮᩣ, ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ ᨲᨸᩮᩣᨵᨶᩮᩣ;

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

ᨿᩮᩈᩴᨿᨲᩥᨶ᩠ᨴᩕᩥᨿᨣᨱᩣ, ᨿᨲᨿᩮᩣ ᩅᩈᩥᨶᩮᩣ ᨧ ᨲᩮ;

ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᩣ’ᨸᨲᩥᩔᩮᩣ ᨲᩩ, ᨵᨾ᩠ᨾᩈᩮᨶᩣᨸᨲᩦ ᩁᩥᨲᩮᩣ.

ᩈᩮᩣᨲᩣᨸᨶ᩠ᨶᩣᨴᩥᨠᩣ ᩈᩮᨡᩣ, ᨶᩁᩥᨿᩮᩣ ᨲᩩ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩮᩣ.

ᩋᨬ᩠ᨬᩣ ¶ ᨲᩩ ᩋᩁᩉᨲ᩠ᨲᨬ᩠ᨧ, ᨳᩪᨸᩮᩣ ᨲᩩ ᨧᩮᨲᩥᨿᩴ ᨽᩅᩮ;

ᨵᨾ᩠ᨾᨽᨱ᩠ᨯᩣᨣᩣᩁᩥᨠᩮᩣ ᨧ, ᩌᨶᨶ᩠ᨴᩮᩣ ᨴ᩠ᩅᩮ ᩈᨾᩣ ᨳ ᨧ.

ᩅᩥᩈᩣᨡᩣ ᨾᩥᨣᩣᩁᨾᩣᨲᩣ, ᩈᩩᨴᨲ᩠ᨲᩮᩣ’ ᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩮᩣ;

ᨽᩥᨠ᩠ᨡᩩᨸᩥ ᩈᩣᨾᨱᩮᩁᩮᩣ ᨧ, ᩈᩥᨠ᩠ᨡᨾᩣᨶᩣ ᨧ ᨽᩥᨠ᩠ᨡᩩᨶᩦ;

ᩈᩣᨾᨱᩮᩁᩦᨲᩥ ᨠᨳᩥᨲᩣ, ᨸᨬ᩠ᨧᩮᨲᩮ ᩈᩉᨵᨾ᩠ᨾᩥᨠᩣ.

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

ᨸᩁᩥᩔᩣᩅᨶ ᨾᩥᨧ᩠ᨧᩮᨲᩮ, ᨸᩁᩥᨠ᩠ᨡᩣᩁᩣ’ᨭ᩠ᨮ ᨽᩣᩈᩥᨲᩣ.

ᩈᩣᨾᨱᩮᩁᩮᩣ ᨧ ᩈᨾᨱᩩ, ᨴ᩠ᨴᩮᩈᩮᩣ ᨧᩣᨳ ᨴᩥᨣᨾ᩠ᨻᩁᩮᩣ;

ᩋᨧᩮᩊᨠᩮᩣ ᨶᩥᨣᨱ᩠ᨮᩮᩣ ᨧ, ᨩᨭᩥᩃᩮᩣ ᨲᩩ ᨩᨭᩣᨵᩁᩮᩣ.

ᨠᩩᨭᩦᩈᨠᩣᨴᩥᨠᩣ ᨧᨲᩩ, ᨲ᩠ᨲᩥᩴᩈ ᨴ᩠ᩅᩣᩈᨭ᩠ᨮᩥ ᨴᩥᨭ᩠ᨮᩥᨿᩮᩣ;

ᩍᨲᩥ ᨨᨶ᩠ᨶᩅᩩᨲᩥ ᩑᨲᩮ, ᨸᩣᩈᨱ᩠ᨯᩣ ᩈᨾ᩠ᨸᨠᩣᩈᩥᨲᩣ.

ᨸᩅᩥᨲ᩠ᨲᩮᩣ ᨸᨿᨲᩮᩣ ᨸᩪᨲᩮᩣ, ᨧᨾ᩠ᨾᩴ ᨲᩩ ᩋᨩᩥᨶᩴ ᨸ᩠ᨿᨳ;

ᨴᨶ᩠ᨲᨸᩮᩣᨱᩮᩣ ᨴᨶ᩠ᨲᨠᨭ᩠ᨮᩴ, ᩅᨠ᩠ᨠᩃᩮᩣ ᩅᩣ ᨲᩥᩁᩦᨭᨠᩴ.

ᨸᨲ᩠ᨲᩮᩣ ᨸᩣᨲᩥᨲ᩠ᨳᩥᨿᩴᨶᩥᨲ᩠ᨳᩦ, ᨠᨾᨱ᩠ᨯᩃᩩ ᨲᩩ ᨠᩩᨱ᩠ᨯᩥᨠᩣ;

ᩋᨳᩣᩃᨾ᩠ᨻᨱᨴᨱ᩠ᨯᩈ᩠ᨾᩥᩴ, ᨠᨲ᩠ᨲᩁᨿᨭ᩠ᨮᩥ ᨶᩣᩁᩥᨿᩴ.

ᨿᩴ ᨴᩮᩉᩈᩣᨵᨶᩣᨸᩮᨠ᩠ᨡᩴ, ᨶᩥᨧ᩠ᨧᩴ ᨠᨾ᩠ᨾᨾᨿᩴ ᨿᨾᩮᩣ;

ᩌᨣᨶ᩠ᨲᩩᩈᩣᨵᨶᩴ ᨠᨾ᩠ᨾᩴ, ᩋᨶᩥᨧ᩠ᨧᩴ ᨶᩥᨿᨾᩮᩣ ᨽᩅᩮ.

ᩅᩮᩔᩮᩣ ᨧ ᩅᩮᩈᩥᨿᩣᨶᩮᩣ ᨳ, ᨩᩦᩅᨶᩴ ᩅᩩᨲ᩠ᨲᩥ ᨩᩦᩅᩥᨠᩣ;

ᩌᨩᩦᩅᩮᩣ ᩅᨲ᩠ᨲᨶᩴ ᨧᩣᨳ, ᨠᩈᩥᨠᨾ᩠ᨾᩴ ᨠᩈᩥᨲ᩠ᨳᩥᨿᩴ.

ᩅᩣᨱᩥᨩ᩠ᨩᨬ᩠ᨧ ᩅᨱᩥᨩ᩠ᨩᩣ ᨳ, ᨣᩮᩣᩁᨠ᩠ᨡᩣ ᨸᩈᩩᨸᩣᩃᨶᩴ;

ᩅᩮᩔᩔ ᩅᩩᨲ᩠ᨲᩥᨿᩮᩣ ᨲᩥᩔᩮᩣ, ᨣᩉᨭ᩠ᨮᩣ’ᨣᩣᩁᩥᨠᩣ ᨣᩥᩉᩥ.

ᨡᩮᨲ᩠ᨲᩣᨩᩦᩅᩮᩣ ᨠᩔᨠᩮᩣ ᨳ, ᨡᩮᨲ᩠ᨲᩴ ᨠᩮᨴᩣᩁ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᩃᩮᨯ᩠ᨯᩩ’ᨲ᩠ᨲᩮᩣ ᨾᨲ᩠ᨲᩥᨠᩣᨡᨱ᩠ᨯᩮᩣ, ᨡᨱᩥᨲ᩠ᨲᩥ’ᨲ᩠ᨳ᩠ᨿ’ᩅᨴᩣᩁᨱᩴ.

ᨴᩣᨲ᩠ᨲᩴ ᩃᩅᩥᨲ᩠ᨲ ᨾᩈᩥᨲᩴ [‘‘ᩋᩈᩥᨲ’’ ᩈᨴ᩠ᨴᩮᩣ ᨸᩩᩴᨶᨸᩩᩴᩈᨠᩮ-᪑᪐᪐᪕-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ], ᨸᨲᩮᩣᨴᩮᩣ ᨲᩩᨲ᩠ᨲ ᨸᩣᨩᨶᩴ;

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

ᨶᨦ᩠ᨣᩃᨬ᩠ᨧ ᩉᩃᩴ ᩈᩦᩁᩮᩣ, ᩎᩈᩣ ᨶᨦ᩠ᨣᩃᨴᨱ᩠ᨯᨠᩮᩣ;

ᩈᨾ᩠ᨾᩣ ᨲᩩ ᨿᩩᨣᨠᩦᩃᩈ᩠ᨾᩥᩴ, ᩈᩦᨲᩣ ᨲᩩ ᩉᩃᨸᨴ᩠ᨵᨲᩥ.

ᨾᩩᨣ᩠ᨣᩣᨴᩥᨠᩮ ¶ ᨸᩁᨱ᩠ᨱᨬ᩠ᨧ, ᨸᩩᨻ᩠ᨻᨱ᩠ᨱᩴ ᩈᩣᩃᩥᩌᨴᩥᨠᩮ;

ᩈᩣᩃᩥ ᩅᩦᩉᩥ ᨧ ᨠᩩᨴᩕᩪᩈᩮᩣ, ᨣᩮᩣᨵᩩᨾᩮᩣ ᩅᩁᨠᩮᩣ ᨿᩅᩮᩣ;

ᨠᨦ᩠ᨣᩪᨲᩥ ᩈᨲ᩠ᨲ ᨵᨬ᩠ᨬᩣᨶᩥ, ᨶᩦᩅᩣᩁᩣᨴᩦ ᨲᩩ ᨲᨻ᩠ᨽᩥᨴᩣ.

ᩋᨳ ᨠᨦ᩠ᨣᩩ ᨸᩥᨿᨦ᩠ᨣᩩ’ᨲ᩠ᨳᩦ, ᩏᨾ᩠ᨾᩣ ᨲᩩ ᩋᨲᩈᩦ ᨽᩅᩮ;

ᨠᩥᨭ᩠ᨮᨬ᩠ᨧ ᩈᩔᩴ ᨵᨬ᩠ᨬᨬ᩠ᨧ [ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ (ᨭᩦ.)], ᩅᩦᩉᩥ ᨳᨾ᩠ᨻᨠᩁᩦ [ᨳᨾ᩠ᨽᨠᩁᩦ (ᨠ.)] ᩁᩥᨲᩮᩣ.

ᨠᨱ᩠ᨯᩮᩣ ᨲᩩ ᨶᩣᩊ ᨾᨳ ᩈᩮᩣ, ᨸᩃᩣᩃᩴ ᨶᩥᨲ᩠ᨳᩥ ᨶᩥᨸ᩠ᨹᩃᩮᩣ;

ᨽᩩᩈᩴ ᨠᩃᩥᨦ᩠ᨣᩁᩮᩣ ᨧᩣᨳ, ᨳᩩᩈᩮᩣ ᨵᨬ᩠ᨬᨲ᩠ᨲᨧᩮ ᨳ ᨧ.

ᨡᩃᩮᩣ ᨧ ᨵᨬ᩠ᨬᨠᩁᨱᩴ, ᨳᨾ᩠ᨻᩮᩣ [ᨳᨾ᩠ᨽᩮᩣ (ᨠ.)] ᨣᩩᨾ᩠ᨻᩮᩣ ᨲᩥᨱᩣᨴᩥᨶᩴ.

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

ᩋᨳᩮᩣ’ᨴ᩠ᨵᨶᨬ᩠ᨧ ᨧᩩᩃ᩠ᩃᩥ’ᨲ᩠ᨳᩦ, ᨠᩥᩃᨬ᩠ᨩᩮᩣ ᨲᩩ ᨠᨭᩮᩣ ᨽᩅᩮ.

ᨠᩩᨾ᩠ᨽᩦ’ᨲ᩠ᨳᩦ ᨸᩥᨮᩁᩮᩣ ᨠᩩᨱ᩠ᨯᩴ, ᨡᩊᩮᩣᨸ᩠ᨿᩩ’ᨠ᩠ᨡᩃᩥ ᨳᩣᩃ᩠ᨿᩩ’ᨡᩣ;

ᨠᩮᩣᩃᨾ᩠ᨻᩮᩣ ᨧᩣᨳ ᨾᨱᩥᨠᩴ, ᨽᩣᨱᨠᩮᩣ ᨧ ᩋᩁᨬ᩠ᨩᩁᩮᩣ.

ᨥᨭᩮᩣ ᨴ᩠ᩅᩦᩈᩩ ᨠᩩᨭᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᩩᨾ᩠ᨽᩮᩣ ᨠᩃᩈ, ᩅᩣᩁᨠᩣ;

ᨠᩴᩈᩮᩣ ᨽᩩᨬ᩠ᨩᨶᨸᨲ᩠ᨲᩮᩣ ᨳᩣ, ᨾᨲ᩠ᨲᩴ ᨸᨲ᩠ᨲᩮᩣ ᨧ ᨽᩣᨩᨶᩴ.

ᩋᨱ᩠ᨯᩩᨸᨠᩴ ᨧᩩᨾ᩠ᨻᨭᨠᩴ, ᩈᩁᩣᩅᩮᩣ ᨲᩩ ᨧ ᨾᩃ᩠ᩃᨠᩮᩣ;

ᨸᩩᨾᩮ ᨠᨭᨧ᩠ᨨᩩᨴᨻ᩠ᨻᩥ’ᨲ᩠ᨳᩦ, ᨠᩩᩈᩪᩃᩮᩣ ᨠᩮᩣᨭ᩠ᨮ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᩈᩣᨠᩮᩣ ᩋᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨯᩣᨠᩮᩣ, ᩈᩥᨦ᩠ᨣᩦᩅᩮᩁᩴᨲᩩ ᩋᨴ᩠ᨴᨠᩴ;

ᨾᩉᩮᩣᩈᨵᩴ ᨲᩩ ᨲᩴ ᩈᩩᨠ᩠ᨡᩴ, ᨾᩁᩥᨧᩴ ᨲᩩ ᨧ ᨠᩮᩣᩃᨠᩴ.

ᩈᩮᩣᩅᩦᩁᩴ ᨠᨬ᩠ᨩᩥᨿᩴ ᩅᩩᨲ᩠ᨲᩴ, ᩌᩁᨶᩣᩊᩴ ᨳᩩᩈᩮᩣᨴᨠᩴ;

ᨵᨬ᩠ᨬᨾ᩠ᨻᩥᩃᩴ ᨻᩥᩊᨦ᩠ᨣᩮᩣ ᨳ, ᩃᩅᨱᩴ ᩃᩮᩣᨱ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᩈᩣᨾᩩᨴ᩠ᨴᩴ ᩈᩥᨶ᩠ᨵᩅᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᩣᩊᩃᩮᩣᨱᩴ ᨲᩩ ᩏᨻ᩠ᨽᩥᨴᩴ;

ᨻᩥᩊᨠᩴ [ᨻᩥᩊᩣᩃ (ᨠ.)] ᨧᩮᨲᩥ ᨸᨬ᩠ᨧᩮᨲᩮ, ᨸᨽᩮᨴᩣ ᩃᩅᨱᩔ ᩉᩥ.

ᨣᩩᩊᩮᩣ ᨧ ᨹᩣᨱᩥᨲᩴ ᨡᨱ᩠ᨯᩮᩣ, ᨾᨧ᩠ᨨᨱ᩠ᨯᩦ ᩈᨠ᩠ᨡᩁᩣ ᩍᨲᩥ;

ᩍᨾᩮ ᩏᨧ᩠ᨨᩩᩅᩥᨠᩣᩁᩣ ᨳ, ᨣᩩᩊᩈ᩠ᨾᩥᩴ ᩅᩥᩈᨠᨱ᩠ᨭᨠᩴ.

ᩃᩣᨩᩣ ¶ ᩈᩥᨿᩣ’ᨠ᩠ᨡᨲᩴ ᨧᩣᨳ, ᨵᩣᨶᩣ ᨽᨭ᩠ᨮᨿᩅᩮ ᨽᩅᩮ;

ᩋᨻᨴ᩠ᨵᩈᨲ᩠ᨲᩩ ᨾᨶ᩠ᨳᩮᩣ ᨧ, ᨸᩪᨸᩣ’ ᨸᩪᨸᩣ ᨲᩩ ᨸᩥᨭ᩠ᨮᨠᩮᩣ.

ᨽᨲ᩠ᨲᨠᩣᩁᩮᩣ ᩈᩪᨸᨠᩣᩁᩮᩣ, ᩈᩪᨴᩮᩣ ᩌᩊᩣᩁᩥᨠᩮᩣ ᨲᨳᩣ;

ᩒᨴᨶᩥᨠᩮᩣ ᨧ ᩁᩈᨠᩮᩣ, ᩈᩪᨸᩮᩣ ᨲᩩ ᨻ᩠ᨿᨬ᩠ᨩᨶᩴ ᨽᩅᩮ.

ᩒᨴᨶᩮᩣ ᩅᩣ ᨠᩩᩁᩴ ᨽᨲ᩠ᨲᩴ, ᨽᩥᨠ᩠ᨡᩣ ᨧᩣ’ᨶ᩠ᨶ ᨾᨳᩣ ᩈᨶᩴ;

ᨡᨩ᩠ᨩᩴ ᨲᩩ ᨽᩮᩣᨩ᩠ᨩ ᩃᩮᨿ᩠ᨿᩣᨶᩥ, ᨸᩮᨿ᩠ᨿᨶ᩠ᨲᩥ ᨧᨲᩩᨵᩣ’ᩈᨶᩴ;

ᨾᨱ᩠ᨯᩮᩣ ᨶᩥᨲ᩠ᨳᩦᩁᩈᨣ᩠ᨣᩈ᩠ᨾᩥᩴ, ᩅᩥᨥᩣᩈᩮᩣ ᨽᩩᨲ᩠ᨲᩈᩮᩈᨠᩮ;

ᩅᩥᨥᩣᩈᩣᨴᩮᩣ ᨧ ᨴᨾᨠᩮᩣ, ᨸᩥᨸᩣᩈᩣ ᨲᩩ ᨧ ᨲᩔᨶᩴ.

ᨡᩩᨴ᩠ᨴᩣ ᨩᩥᨥᨧ᩠ᨨᩣ, ᨾᩴᩈᩔ, ᨸᨭᩥᨧ᩠ᨨᩣᨴᨶᩥᨿᩴ ᩁᩈᩮᩣ;

ᩏᨴᩕᩮᨠᩮᩣ ᨧᩮᩅ ᩏᨣ᩠ᨣᩣᩁᩮᩣ, ᩈᩮᩣᩉᩥᨧ᩠ᨧᩴ ᨲᩥᨲ᩠ᨲᩥ ᨲᨸ᩠ᨸᨶᩴ.

ᨠᩣᨾᩴ ᨲ᩠ᩅᩥᨭ᩠ᨮᩴ ᨶᩥᨠᩣᨾᨬ᩠ᨧ, ᨸᩁᩥᨿᨲ᩠ᨲᩴ ᨿᨳᨧ᩠ᨨᩥᨲᩴ;

ᨠᨿᩅᩥᨠ᩠ᨠᨿᩥᨠᩮᩣ ᩈᨲ᩠ᨳ,ᩅᩣᩉᩣ’ ᨸᨱᩥᨠ ᩅᩣᨱᩥᨩᩣ.

ᩏᨲ᩠ᨲᨾᨱ᩠ᨱᩮᩣ ᨧ ᨵᨶᩥᨠᩮᩣ, ᨵᨾᨱ᩠ᨱᩮᩣ ᨲᩩ ᩍᨱᩣᨿᩥᨠᩮᩣ.

ᩏᨴ᩠ᨵᩣᩁᩮᩣ ᨲᩩ ᩍᨱᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨾᩪᩃᩴ ᨲᩩ ᨸᩣᨽᨲᩴ ᨽᩅᩮ;

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

ᨸᨭᩥᨴᩣᨶᩴ ᨸᩁᩥᩅᨲ᩠ᨲᩮᩣ, ᨶ᩠ᨿᩣᩈᩮᩣ ᨲᩪ’ᨸᨶᩥᨵᩦ ᩁᩥᨲᩮᩣ;

ᩋᨭ᩠ᨮᩣᩁᩈᨶ᩠ᨲᩣ ᩈᨦ᩠ᨡ᩠ᨿᩮᨿ᩠ᨿᩮ, ᩈᨦ᩠ᨡ᩠ᨿᩣ ᩑᨠᩣᨴᨿᩮᩣ ᨲᩥᩈᩩ;

ᩈᨦ᩠ᨡ᩠ᨿᩣᨶᩮ ᨲᩩ ᨧ ᩈᨦ᩠ᨡ᩠ᨿᩮᨿ᩠ᨿᩮ, ᩑᨠᨲ᩠ᨲᩮ ᩅᩦᩈᨲᩣᨴᨿᩮᩣ;

ᩅᨣ᩠ᨣᨽᩮᨴᩮ ᨻᩉᩩᨲ᩠ᨲᩮᨸᩥ, ᨲᩣ ᩌᨶᩅᩩᨲᩥ ᨶᩣᩁᩥᨿᩴ.

ᩈᨲᩴ ᩈᩉᩔᩴ ᨶᩥᨿᩩᨲᩴ [ᨶᩉᩩᨲᩴ-ᨶᨿᩩᨲᩴ (ᨠᨲ᩠ᨳᨧᩥ)], ᩃᨠ᩠ᨡᩴ ᨠᩮᩣᨭᩥ ᨸᨠᩮᩣᨭᩥᨿᩮᩣ;

ᨠᩮᩣᨭᩥᨸᨠᩮᩣᨭᩥ ᨶᩉᩩᨲᩴ, ᨲᨳᩣ ᨶᩥᨶ᩠ᨶᩉᩩᨲᨾ᩠ᨸᩥ ᨧ.

ᩋᨠ᩠ᨡᩮᩣᨽᨶᩦᨲ᩠ᨳᩥᨿᩴ ¶ [ᩋᨠ᩠ᨡᩮᩣᨽᩥᨱᩦ (ᨠ.)] ᨻᩥᨶ᩠ᨴᩩ, ᩋᨻ᩠ᨻᩩᨴᨬ᩠ᨧ ᨶᩥᩁᨻ᩠ᨻᩩᨴᩴ;

ᩋᩉᩉᩴ ᩋᨻᨻᩴ ᨧᩮᩅᩣ, ᨭᨭᩴ ᩈᩮᩣᨣᨶ᩠ᨵᩥ ᨠᩩᨸ᩠ᨸᩃᩴ.

ᨠᩩᨾᩩᨴᩴ ᨸᩩᨱ᩠ᨯᩁᩦᨠᨬ᩠ᨧ, ᨸᨴᩩᨾᩴ ᨠᨳᩣᨶᨾ᩠ᨸᩥ ᨧ;

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

ᨠᩮᩣᨭ᩠ᨿᩣᨴᩥᨠᩴ ᨴᩈᨣᩩᨱᩴ, ᩈᨲᩃᨠ᩠ᨡᨣᩩᨱᩴ ᨠᨾᩣ;

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

ᨴ᩠ᩅᩮ ᩋᨠ᩠ᨡᩣ ᨾᩣᩈᨠᩣ ᨸᨬ᩠ᨧ, ᨠ᩠ᨡᩣᨶᩴ ᨵᩁᨱᨾᨭ᩠ᨮᨠᩴ.

ᩈᩩᩅᨱ᩠ᨱᩮᩣ ᨸᨬ᩠ᨧᨵᩁᨱᩴ, ᨶᩥᨠ᩠ᨡᩴ ᨲ᩠ᩅᨶᩥᨲ᩠ᨳᩥ ᨸᨬ᩠ᨧ ᨲᩮ;

ᨸᩣᨴᩮᩣ ᨽᩣᨣᩮ ᨧᨲᩩᨲ᩠ᨳᩮ ᨳ, ᨵᩁᨱᩣᨶᩥ ᨸᩃᩴ ᨴᩈ.

ᨲᩩᩃᩣ ᨸᩃᩈᨲᩴ ᨧᩣᨳ, ᨽᩣᩁᩮᩣ ᩅᩦᩈᨲᩥ ᨲᩣ ᨲᩩᩃᩣ;

ᩋᨳᩮᩣ ᨠᩉᩣᨸᨱᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᨳ᩠ᨿᨲᩮ ᨠᩁᩥᩈᩣᨸᨱᩮᩣ.

ᩌᩊ᩠ᩉᨠᩮᩣ ᨧᨲᩩᩁᩮᩣ ᨸᨲ᩠ᨳᩣ, ᨴᩮᩣᨱᩴ ᩅᩣᨧᨲᩩᩁᩣ’ᩊ᩠ᩉᨠᩴ.

ᨾᩣᨶᩥᨠᩣ ᨧᨲᩩᩁᩮᩣ ᨴᩮᩣᨱᩣ, ᨡᩣᩁᩦᨲ᩠ᨳᩦ ᨧᨲᩩᨾᩣᨶᩥᨠᩣ;

ᩌᩊ᩠ᩉᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨲᩩᨾ᩠ᨽᩮᩣ, ᨸᨲ᩠ᨳᩮᩣᨲᩩ ᨶᩣᩊᩥ ᨶᩣᩁᩥᨿᩴ;

ᨴᨻ᩠ᨻᩴ ᩅᩥᨲ᩠ᨲᩴ ᩈᩣᨸᨲᩮᨿ᩠ᨿᩴ, ᩅᩈ᩠ᩅ’ᨲ᩠ᨳᩮᩣ ᩅᩥᨽᩅᩮᩣ ᨽᩅᩮ.

ᨠᩮᩣᩈᩮᩣ ¶ ᩉᩥᩁᨬ᩠ᨬᨬ᩠ᨧ ᨠᨲᩣ, ᨠᨲᩴ ᨠᨬ᩠ᨧᨶ, ᩁᩪᨸᩥᨿᩴ;

ᨠᩩᨸ᩠ᨸᩴ ᨲᨴᨬ᩠ᨬᩴ ᨲᨾ᩠ᨻᩣᨴᩥ, ᩁᩪᨸᩥᨿᩴ ᨴ᩠ᩅᨿ ᨾᩣᩉᨲᩴ.

ᩈᩩᩅᨱ᩠ᨱᩴ ᨠᨶᨠᩴ ᨩᩣᨲ, ᩁᩪᨸᩴ ᩈᩮᩣᨱ᩠ᨱᨬ᩠ᨧ ᨠᨬ᩠ᨧᨶᩴ;

ᩈᨲ᩠ᨳᩩᩅᨱ᩠ᨱᩮᩣ ᩉᩁᩦ ᨠᨾ᩠ᨻᩩ, ᨧᩣᩁᩩ ᩉᩮᨾᨬ᩠ᨧ ᩉᩣᨭᨠᩴ.

ᨲᨸᨶᩥᨿᩴ ᩉᩥᩁᨬ᩠ᨬᩴ ᨲ, ᨻ᩠ᨽᩮᨴᩣ ᨧᩣᨾᩦᨠᩁᨾ᩠ᨸᩥ ᨧ;

ᩈᩣᨲᨠᩩᨾ᩠ᨽᩴ ᨲᨳᩣ ᨩᨾ᩠ᨻᩩ, ᨶᨴᩴ ᩈᩥᨦ᩠ᨣᩦ ᨧ ᨶᩣᩁᩥᨿᩴ.

ᩁᩪᨸᩥᨿᩴ ᩁᨩᨲᩴ ᩈᨩ᩠ᨫᩩ, ᩁᩪᨸᩦ ᩈᨩ᩠ᨫᩴ ᩋᨳᩮᩣ ᩅᩈᩩ;

ᩁᨲᨶᨬ᩠ᨧ ᨾᨱᩥ ᨴ᩠ᩅᩦᩈᩩ, ᨸᩩᨸ᩠ᨹᩁᩣᨣᩣᨴᩦ ᨲᨻ᩠ᨽᩥᨴᩣ.

ᩈᩩᩅᨱ᩠ᨱᩴ ᩁᨩᨲᩴ ᨾᩩᨲ᩠ᨲᩣ, ᨾᨱᩥ ᩅᩮᩊᩩᩁᩥᨿᩣᨶᩥ ᨧ;

ᩅᨩᩥᩁᨬ᩠ᨧ ᨸᩅᩣᩊᨶ᩠ᨲᩥ, ᩈᨲ᩠ᨲᩣ’ᩉᩩ ᩁᨲᨶᩣᨶᩥ’ ᨾᩮ.

ᩃᩮᩣᩉᩥᨲᨦ᩠ᨠᩮᩣ ᨧ ᨸᨴᩩᨾ, ᩁᩣᨣᩮᩣ ᩁᨲ᩠ᨲᨾᨱᩥ ᨸ᩠ᨿᨳ;

ᩅᩴᩈᩅᨱ᩠ᨱᩮᩣ ᩅᩮᩊᩩᩁᩥᨿᩴ, ᨸᩅᩣᩊᩴ ᩅᩣ ᨧ ᩅᩥᨴ᩠ᨴᩩᨾᩮᩣ.

ᨾᩈᩣᩁᨣᩃ᩠ᩃᩴ ᨠᨻᩁᨾᨱᩥ, ᩋᨳ ᨾᩩᨲ᩠ᨲᩣ ᨧ ᨾᩩᨲ᩠ᨲᩥᨠᩴ;

ᩁᩦᨲᩥ [ᩁᩦᩁᩦ (ᨭᩦ.)] ᨲ᩠ᨳᩦ ᩌᩁᨠᩪᨭᩮᩣ ᩅᩣ, ᩋᨾᩃᩴ ᨲ᩠ᩅ’ᨻ᩠ᨽᨠᩴ ᨽᩅᩮ.

ᨠᩣᩊᨲᩥᨸᩩ ᨲᩩ ᩈᩦᩈᨬ᩠ᨧ, ᩉᩁᩥᨲᩣᩃᩴ ᨲᩩ ᨸᩦᨲᨶᩴ.

ᨧᩥᨶᨸᩥᨭ᩠ᨮᨬ᩠ᨧ ᩈᩥᨶ᩠ᨴᩪᩁᩴ, ᩋᨳ ᨲᩪᩃᩮᩣ ᨲᨳᩣ ᨸᩥᨧᩩ;

ᨡᩩᨴ᩠ᨴᨩᩴ ᨲᩩ ᨾᨵᩩ ᨡᩩᨴ᩠ᨴᩴ, ᨾᨵᩩᨧ᩠ᨨᩥᨭ᩠ᨮᩴ ᨲᩩ ᩈᩥᨲ᩠ᨳᨠᩴ.

ᩏᩈᨽᩮᩣ ᨻᩃᩦᨻᨴ᩠ᨵᩮᩣ [ᨻᩃᩥᨻᨴ᩠ᨴ (ᨠ.)] ᨧ, ᨣᩮᩣᨱᩮᩣ ᨣᩮᩣᩅᩈᨽᩮᩣ ᩅᩩᩈᩮᩣ.

ᩅᩩᨴ᩠ᨵᩮᩣ ᨩᩁᨣ᩠ᨣᩅᩮᩣ ᩈᩮᩣ ᨳ, ᨴᨾ᩠ᨾᩮᩣ ᩅᨧ᩠ᨨᨲᩁᩮᩣ ᩈᨾᩣ;

ᨵᩩᩁᩅᩣᩉᩦ ᨲᩩ ᨵᩮᩣᩁᨿ᩠ᩉᩮᩣ, ᨣᩮᩣᩅᩥᨶ᩠ᨴᩮᩣ ᨵᩥᨠᨲᩮᩣ ᨣᩅᩴ.

ᩅᩉᩮᩣ ᨧ ᨡᨶ᩠ᨵᨴᩮᩈᩮᩣ ᨳ, ᨠᨠᩩᨵᩮᩣ [ᨠᨠᩩᨴᩮᩣ (ᨠ.)] ᨠᨠᩩ ᩅᩩᨧ᩠ᨧᨲᩮ;

ᩋᨳᩮᩣ ᩅᩥᩈᩣᨱᩴ ᩈᩥᨦ᩠ᨣᨬ᩠ᨧ, ᩁᨲ᩠ᨲᨣᩣᩅᩦ ᨲᩩ ᩁᩮᩣᩉᩥᨱᩦ.

ᨣᩣᩅᩦ ᨧ ᩈᩥᨦ᩠ᨣᩥᨶᩦ ᨣᩮᩣ ᨧ, ᩅᨬ᩠ᨫᩣ ᨲᩩ ᨠᨳ᩠ᨿᨲᩮ ᩅᩈᩣ;

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

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

ᨣᩮᩣᨾᩥᩊ᩠ᩉᩮᩣ ᨣᩮᩣᨾᨿᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩋᨳᩮᩣ ᩈᨸ᩠ᨸᩥ ᨥᨲᩴ ᨽᩅᩮ.

ᨶᩅᩩᨴ᩠ᨵᨭᩴ ᨲᩩ ᨶᩮᩣᨶᩦᨲᩴ, ᨴᨾᩥᨾᨱ᩠ᨯᩴ ᨲᩩ ᨾᨲ᩠ᨳᩩ ᨧ,

ᨡᩦᩁᩴ ᨴᩩᨴ᩠ᨵᩴ ᨸᨿᩮᩣ ᨳᨬ᩠ᨬᩴ, ᨲᨠ᩠ᨠᩴ ᨲᩩ ᨾᨳᩥᨲᩴ ᨸ᩠ᨿᨳ.

ᨡᩦᩁᩴ ᨴᨵᩥ ᨥᨲᩴ ᨲᨠ᩠ᨠᩴ, ᨶᩮᩣᨶᩦᨲᩴ ᨸᨬ᩠ᨧ ᨣᩮᩣᩁᩈᩣ;

ᩏᩁᨻ᩠ᨽᩮᩣ ᨾᩮᨱ᩠ᨯ ᨾᩮᩈᩣ ᨧ, ᩏᩁᨱᩮᩣ ᩋᩅᩥ ᩑᩊᨠᩮᩣ.

ᨣᨴᩕᨽᩮᩣ ᨲᩩ ᨡᩁᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩏᩁᨱᩦ ᨲᩩ ᩋᨩᩦ ᩋᨩᩣ.

ᩈᩩᨴ᩠ᨴᩮᩣ’ᨶ᩠ᨲᩅᨱ᩠ᨱᩮᩣ ᩅᩈᩃᩮᩣ, ᩈᩴᨠᩥᨱ᩠ᨱᩣ ᨾᩣᨣᨵᩣᨴᨿᩮᩣ;

ᨾᩣᨣᨵᩮᩣ ᩈᩩᨴ᩠ᨴᨡᨲ᩠ᨲᩣᨩᩮᩣ, ᩏᨣ᩠ᨣᩮᩣ ᩈᩩᨴ᩠ᨴᩣᨿ ᨡᨲ᩠ᨲᨩᩮᩣ.

ᨴ᩠ᩅᩥᨩᩣᨡᨲ᩠ᨲᩥᨿᨩᩮᩣ ᩈᩪᨲᩮᩣ, ᨠᩣᩁᩩᨲᩩ ᩈᩥᨸ᩠ᨸᩥᨠᩮᩣᨸᩩᨾᩮ;

ᩈᨦ᩠ᨥᩣᨲᩮᩣᨲᩩ ᩈᨩᩣᨲᩦᨶᩴ, ᨲᩮᩈᩴ ᩈᩮᨱᩦ ᨴ᩠ᩅᩥᩈᩩᨧ᩠ᨧᨲᩮ.

ᨲᨧ᩠ᨨᨠᩮᩣ ᨲᨶ᩠ᨲᩅᩣᨿᩮᩣ ᨧ, ᩁᨩᨠᩮᩣ ᨧ ᨶᩉᩣᨸᩥᨲᩮᩣ;

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

ᨲᨧ᩠ᨨᨠᩮᩣ ᩅᨯ᩠ᨰᨠᩦ ᨾᨲᩮᩣ, ᨸᩃᨣᨱ᩠ᨯᩮᩣ ᨳᨸᨲ᩠ᨿᨸᩥ;

ᩁᨳᨠᩣᩁᩮᩣ ᨳ ᩈᩩᩅᨱ᩠ᨱ, ᨠᩣᩁᩮᩣ ᨶᩣᩊᩥᨶ᩠ᨵᨾᩮᩣ ᨽᩅᩮ.

ᨧᨾ᩠ᨾᨠᩣᩁᩮᩣ ᩁᨳᨠᩣᩁᩮᩣ, ᨠᨸ᩠ᨸᨠᩮᩣ ᨲᩩ ᨶᩉᩣᨸᩥᨲᩮᩣ;

ᩁᨦ᩠ᨣᩣᨩᩦᩅᩮᩣ ᨧᩥᨲ᩠ᨲᨠᩣᩁᩮᩣ, ᨸᩩᨠ᩠ᨠᩩᩈᩮᩣ ᨸᩩᨸ᩠ᨹᨨᨯ᩠ᨯᨠᩮᩣ.

ᩅᩮᨶᩮᩣ ᩅᩥᩃᩦᩅᨠᩣᩁᩮᩣ ᨧ, ᨶᩊᨠᩣᩁᩮᩣ ᩈᨾᩣ ᨲᨿᩮᩣ;

ᨶᩥᨶ᩠ᨶᩮᨩᨠᩮᩣ ᨧ ᩁᨩᨠᩮᩣ, ᨶᩮᨲ᩠ᨲᩥᨠᩮᩣ ᩏᨴᩉᩣᩁᨠᩮᩣ;

ᩅᩦᨱᩣᩅᩣᨴᩦ ᩅᩮᨱᩥᨠᩮᩣ ᨳ, ᩏᩈᩩᨠᩣᩁᩮᩣ’ ᩈᩩᩅᨯ᩠ᨰᨠᩦ.

ᨸᩣᨱᩥᩅᩣᨴᩮᩣ ᨲᩩ ᨸᩣᨱᩥᨥᩮᩣ [ᨸᩣᨱᩥᨿᩮᩣ (ᨠᨲ᩠ᨳᨧᩥ)];

ᨸᩪᨸᩥᨿᩮᩣ ᨸᩪᨸᨸᨱᩥᨿᩮᩣ, ᩈᩮᩣᨱ᩠ᨯᩥᨠᩮᩣ ᨾᨩ᩠ᨩᩅᩥᨠ᩠ᨠᨿᩦ.

ᨾᩣᨿᩣ ᨲᩩ ᩈᨾ᩠ᨻᩁᩦ ᨾᩣᨿᩣ, ᨠᩣᩁᩮᩣ ᨲᩩ ᩍᨶ᩠ᨴᨩᩣᩃᩥᨠᩮᩣ;

ᩒᩁᨻ᩠ᨽᩥᨠᩣ ᩈᩪᨠᩁᩥᨠᩣ, ᨾᩣᨣᩅᩥᨠᩣ ᨲᩮ ᨧ ᩈᩣᨠᩩᨱᩥᨠᩣ;

ᩉᨶ᩠ᨲ᩠ᩅᩣ ᨩᩦᩅᨶ᩠ᨲᩮ’ᩊᨠ, ᩈᩪᨠᩁ, ᨾᩥᨣ, ᨸᨠ᩠ᨡᩥᨶᩮᩣ ᨠᨾᨲᩮᩣ.

ᩅᩮᨲᨶᩥᨠᩮᩣ ᨲᩩ ᨽᨲᨠᩮᩣ, ᨠᨾ᩠ᨾᨠᩁᩮᩣ ᨳ ᨠᩥᩴ ᨠᩁᩮᩣ;

ᨴᩣᩈᩮᩣ ᨧ ᨧᩮᨭᨠᩮᩣ ᨸᩮᩔᩮᩣ, ᨽᨧ᩠ᨧᩮᩣ ᨧ ᨸᩁᩥᨧᩣᩁᩥᨠᩮᩣ.

ᩋᨶ᩠ᨲᩮᩣᨩᩣᨲᩮᩣ ᨵᨶᨠ᩠ᨠᩦᨲᩮᩣ, ᨴᩣᩈᨻ᩠ᨿᩮᩣ’ᨸᨣᨲᩮᩣ ᩈᨿᩴ;

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

ᩈᨸᩣᨠᩮᩣ ᨧᩮᩅ ᨧᨱ᩠ᨯᩣᩃᩮᩣ, ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᩈᨸᨧᩮᩣ ᨽᩅᩮ;

ᨲᨻ᩠ᨽᩮᨴᩣ ᨾᩥᩃᨠ᩠ᨡᨩᩣᨲᩦ, ᨠᩥᩁᩣᨲ, ᩈᩅᩁᩣᨴᨿᩮᩣ.

ᩈᩣᩁᨾᩮᨿ᩠ᨿᩮᩣ ᨧ ᩈᩩᨶᨡᩮᩣ, ᩈᩩᨶᩮᩣ ᩈᩮᩣᨱᩮᩣ ᨧ ᨠᩩᨠ᩠ᨠᩩᩁᩮᩣ.

ᩏᨾ᩠ᨾᨲ᩠ᨲᩣᨴᩥᨲ ᨾᩣᨸᨶ᩠ᨶᩮᩣ, ᩋᩊᨠ᩠ᨠᩮᩣᨲᩥ ᩈᩩᨶᩮᩣ ᨾᨲᩮᩣ.

ᩈᩣᨻᨶ᩠ᨵᨶᩴ ᨲᩩ ᨣᨴ᩠ᨴᩪᩃᩮᩣ, ᨴᩦᨸᨠᩮᩣ ᨲᩩ ᨧ ᨧᩮᨲᨠᩮᩣ;

ᨻᨶ᩠ᨵᨶᩴ ᨣᨱ᩠ᨮᩥ ᨸᩣᩈᩮᩣ ᨳ, ᩅᩣᨣᩩᩁᩣ [ᩅᩣᨠᩁᩣ (ᩈᩦ. ᨭᩦ.)] ᨾᩥᨣᨻᨶ᩠ᨵᨶᩦ.

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

ᩌᨥᩣᨲᨶᩴ ᩅᨵᨭ᩠ᨮᩣᨶᩴ, ᩈᩪᨶᩣ ᨲᩩ ᩋᨵᩥᨠᩮᩣᨭ᩠ᨭᨶᩴ.

ᩈᩩᨲ᩠ᨲᩴ ᨲᨶ᩠ᨲᩩ ᨸᩩᨾᩮ ᨲᨶ᩠ᨲᩴ, ᨸᩮᩣᨲ᩠ᨳᩴ ᩃᩮᨸ᩠ᨿᩣᨴᩥᨠᨾ᩠ᨾᨶᩥ;

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

ᩏᨣ᩠ᨥᩣᨭᨶᩴ ᨥᨭᩦᨿᨶ᩠ᨲᩴ, ᨠᩪᨸᨾ᩠ᨻᩩᨻ᩠ᨻᩣᩉᨶᩴ ᨽᩅᩮ;

ᨾᨬ᩠ᨩᩪᩈᩣ ᨸᩮᩊᩣ ᨸᩥᨭᨠᩮᩣ, ᨲ᩠ᩅᩥᨲ᩠ᨳᩥᨿᩴ ᨸᨧ᩠ᨨᩥ ᨸᩮᨭᨠᩮᩣ.

ᨻ᩠ᨿᩣᨽᨦ᩠ᨣᩦ ᨲ᩠ᩅᩥᨲ᩠ᨳᩥᨿᩴ ᨠᩣᨩᩮᩣ, ᩈᩥᨠ᩠ᨠᩣ ᨲ᩠ᩅᨲᩕᩣ’ᩅᩃᨾ᩠ᨻᨶᩴ;

ᩏᨸᩣᩉᨶᩮᩣ ᩅᩣ ᨸᩣᨴᩩ’ᨲ᩠ᨳᩦ, ᨲᨻ᩠ᨽᩮᨴᩣ ᨸᩣᨴᩩᨠᩣ ᨸ᩠ᨿᨳ.

ᩅᩁᨲ᩠ᨲᩣ ᩅᨴ᩠ᨵᩥᨠᩣ ᨶᨴ᩠ᨵᩥ, ᨽᩈ᩠ᨲᩣ ᨧᨾ᩠ᨾᨸᩈᩥᨻ᩠ᨻᨠᩴ;

ᨠᨾ᩠ᨾᩣᩁᨽᨱ᩠ᨯᩣ ᩈᨱ᩠ᨯᩣᩈᩮᩣ, ᨾᩩᨭ᩠ᨮ᩠ᨿᩣ’ᨵᩥᨠᩁᨱᩦᨲ᩠ᨳᩦᨿᩴ;

ᨲᨻ᩠ᨽᩈ᩠ᨲᩣ ᨣᨣ᩠ᨣᩁᩦ ᨶᩣᩁᩦ, ᩈᨲ᩠ᨲᩴ ᨲᩩ ᨸᩥᨸ᩠ᨹᩃᩴ ᨽᩅᩮ.

ᨡᩁᩮᩣ ᨧ ᨠᨠᨧᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩈᩥᨸ᩠ᨸᩴ ᨠᨾ᩠ᨾᩴ ᨠᩃᩣᨴᩥᨠᩴ.

ᨸᨭᩥᨾᩣ ᨸᨭᩥᨻᩥᨾ᩠ᨻᨬ᩠ᨧ, ᨻᩥᨾ᩠ᨻᩮᩣ ᨸᨭᩥᨶᩥᨵᩦᩁᩥᨲᩮᩣ;

ᨲᩦᩈᩩ ᩈᨾᩮᩣ ᨸᨭᩥᨽᩣᨣᩮᩣ, ᩈᨶ᩠ᨶᩥᨠᩣᩈᩮᩣ ᩈᩁᩥᨠ᩠ᨡᨠᩮᩣ.

ᩒᨸᨾ᩠ᨾ ᨾᩩᨸᨾᩣᨶᩴ ᨧᩩ, ᨸᨾᩣ ᨽᨲᩥ ᨲᩩ ᨶᩣᩁᩥᨿᩴ.

ᨶᩥᨻ᩠ᨻᩮᩈᩮᩣ ᩅᩮᨲᨶᩴ ᨾᩪᩃ᩠ᨿᩴ, ᨩᩪᨲᩴ ᨲ᩠ᩅᨶᩥᨲ᩠ᨳᩥ ᨠᩮᨲᩅᩴ;

ᨵᩩᨲ᩠ᨲᩮᩣ’ᨠ᩠ᨡᨵᩩᨲ᩠ᨲᩮᩣ ᨠᩥᨲᩅᩮᩣ, ᨩᩪᨲᨠᩣᩁ, ᨠ᩠ᨡᨴᩮᩅᩥᨶᩮᩣ.

ᨸᩣᨭᩥᨽᩮᩣᨣᩮᩣᨲᩩ ᨸᨭᩥᨽᩪ, ᩋᨠ᩠ᨡᩮᩣ ᨲᩩ ᨸᩣᩈᨠᩮᩣ ᨽᩅᩮ;

ᨸᩩᨾᩮᩅᩣ’ ᨭ᩠ᨮᨸᨴᩴ [ᩋᨭ᩠ᨮᩣᨸᨴᩴ (ᨭᩦ. ᩈᩦ.)] ᩈᩣᩁᩥ, ᨹᩃᨠᩮ ᨳ ᨸᨱᩮᩣ, ᨻ᩠ᨽᩩᨲᩮᩣ.

ᨠᩥᨱ᩠ᨱᩴ ¶ ᨲᩩ ᨾᨴᩥᩁᩣᨻᩦᨩᩮ, ᨾᨵᩩ ᨾᨵ᩠ᩅᩣᩈᩅᩮ ᨾᨲᩴ;

ᨾᨴᩥᩁᩣ ᩅᩣᩁᩩᨱᩦ ᨾᨩ᩠ᨩᩴ, ᩈᩩᩁᩣ ᨽᩅᩮᩣ ᨲᩩ ᨾᩮᩁᨿᩴ.

ᩈᩁᨠᩮᩣ ᨧᩈᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩌᨸᩣᨶᩴ ᨸᩣᨶᨾᨱ᩠ᨯᩃᩴ;

ᨿᩮ’ᨲᩕ ᨽᩪᩁᩥᨸ᩠ᨸᨿᩮᩣᨣᨲ᩠ᨲᩣ, ᨿᩮᩣᨣᩥᨠᩮᨠᩈ᩠ᨾᩥ ᨾᩦᩁᩥᨲᩣ;

ᩃᩥᨦ᩠ᨣᨶ᩠ᨲᩁᩮᨸᩥ ᨲᩮ ᨬᩮᨿ᩠ᨿᩣ, ᨲᨴ᩠ᨵᨾ᩠ᨾᨲ᩠ᨲᩣ’ᨬ᩠ᨬᩅᩩᨲ᩠ᨲᩥᨿᨶ᩠ᨲᩥ.

ᩋᩁᨬ᩠ᨬᩴ ᨠᩣᨶᨶᩴ ᨴᩣᨿᩮᩣ, ᨣᩉᨶᩴ ᩅᩥᨸᩥᨶᩴ ᩅᨶᩴ;

ᩋᨭᩅᩦ’ᨲ᩠ᨳᩦ ᨾᩉᩣᩁᨬ᩠ᨬᩴ, ᨲ᩠ᩅ, ᩁᨬ᩠ᨬᩣᨶᩦᨲ᩠ᨳᩥᨿᩴ ᨽᩅᩮ.

ᨶᨣᩁᩣ ᨶᩣᨲᩥᨴᩪᩁᩈ᩠ᨾᩥᩴ, ᩈᨶ᩠ᨲᩮᩉᩥ ᨿᩮᩣ ᨽᩥᩁᩮᩣᨸᩥᨲᩮᩣ;

ᨲᩁᩩᩈᨱ᩠ᨯᩮᩣ ᩈ ᩌᩁᩣᨾᩮᩣ, ᨲᨳᩮᩣ ᨸᩅᨶ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᩈᨻ᩠ᨻᩈᩣᨵᩣᩁᨱᩣ’ᩁᨬ᩠ᨬᩴ, ᩁᨬ᩠ᨬ ᨾᩩᨿ᩠ᨿᩣᨶ ᨾᩩᨧ᩠ᨧᨲᩮ;

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

ᨸᨶ᩠ᨲᩥ ᩅᩦᨳ᩠ᨿᩣ’ᩅᩃᩥ ᩈᩮᨱᩦ, ᨸᩣᩊᩥ ᩃᩮᨡᩣ ᨲᩩ ᩁᩣᨩᩥ ᨧ;

ᨸᩣᨴᨸᩮᩣ ᩅᩥᨭᨸᩦ ᩁᩩᨠ᩠ᨡᩮᩣ, ᩋᨣᩮᩣ ᩈᩣᩃᩮᩣ ᨾᩉᩦᩁᩩᩉᩮᩣ.

ᨴᩩᨾᩮᩣ ᨲᩁᩩ ᨠᩩᨩᩮᩣ ᩈᩣᨡᩦ, ᨣᨧ᩠ᨨᩮᩣ ᨲᩩ ᨡᩩᨴ᩠ᨴᨸᩣᨴᨸᩮᩣ;

ᨹᩃᨶ᩠ᨲᩥ ᨿᩮ ᩅᩥᨶᩣ ᨸᩩᨸ᩠ᨹᩴ, ᨲᩮ ᩅᩩᨧ᩠ᨧᨶ᩠ᨲᩥ ᩅᨶᨸ᩠ᨸᨲᩦ.

ᨲᩦᩈᩩ ᩅᨬ᩠ᨧ᩠ᨿᩣ’ᨹᩃᩣ ᨧᩣᨳ, ᨹᩃᩥᨶᩮᩣ ᨹᩃᩅᩣ ᨹᩃᩦ.

ᩈᨾ᩠ᨹᩩᩃ᩠ᩃᩥᨲᩮᩣ ᨲᩩ ᩅᩥᨠᨧᩮᩣ, ᨹᩩᩃ᩠ᩃᩮᩣ ᩅᩥᨠᩈᩥᨲᩮᩣ ᨲᩥᩈᩩ;

ᩈᩥᩁᩮᩣ’ᨣ᩠ᨣᩴ ᩈᩥᨡᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩈᩣᨡᩣ ᨲᩩ ᨠᨳᩥᨲᩣ ᩃᨲᩣ.

ᨴᩃᩴ ᨸᩃᩣᩈᩴ ᨨᨴᨶᩴ, ᨸᨱ᩠ᨱᩴ ᨸᨲ᩠ᨲᩴ ᨨᨴᩮᩣ ᨸ᩠ᨿᨳ;

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

ᨾᨠᩩᩃᩴ ᩅᩣ ᨠᩩᨭᩩᨾᩃᩮᩣ, ᨡᩣᩁᨠᩮᩣ ᨲᩩ ᨧ ᨩᩣᩃᨠᩴ;

ᨠᩃᩥᨠᩣ ᨠᩮᩣᩁᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩅᨱ᩠ᨭᩴ ᨸᩩᨸ᩠ᨹᩣᨴᩥᨻᨶ᩠ᨵᨶᩴ.

ᨸᩈᩅᩮᩣ ¶ ᨠᩩᩈᩩᨾᩴ ᨸᩩᨸ᩠ᨹᩴ, ᨸᩁᩣᨣᩮᩣ ᨸᩩᨸ᩠ᨹᨩᩮᩣ ᩁᨩᩮᩣ;

ᨾᨠᩁᨶ᩠ᨴᩮᩣ ᨾᨵᩩ ᨾᨲᩴ, ᨳᩅᨠᩮᩣ ᨲᩩ ᨧ ᨣᩮᩣᨧ᩠ᨨᨠᩮᩣ.

ᨧᨾ᩠ᨸᨠ’ᨾ᩠ᨻᩣᨴᩥᨠᩩᩈᩩᨾ, ᨹᩃᨶᩣᨾᩴ ᨶᨸᩩᩴᩈᨠᩮ.

ᨾᩃ᩠ᩃᩥᨠᩣᨴᩦ ᨲᩩ ᨠᩩᩈᩩᨾᩮ, ᩈᩃᩥᨦ᩠ᨣᩣ ᩅᩦᩉᨿᩮᩣ ᨹᩃᩮ;

ᨩᨾ᩠ᨻᩪ’ᨲ᩠ᨳᩦ ᨩᨾ᩠ᨻᩅᩴ ᨩᨾ᩠ᨻᩪ, ᩅᩥᨭᨸᩮᩣ ᩅᩥᨭᨽᩦ’ᨲ᩠ᨳᩥᨿᩴ.

ᨾᩪᩃ ᨾᩣᩁᨻ᩠ᨽ ᩈᩣᨡᨶ᩠ᨲᩮᩣ, ᨡᨶ᩠ᨵᩮᩣ ᨽᩣᨣᩮᩣ ᨲᩁᩩᩔ ᨳ;

ᨠᩮᩣᨭᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᩁᩩᨠ᩠ᨡ, ᨧ᩠ᨨᩥᨴ᩠ᨴᩮ ᨠᨭ᩠ᨮᩴ ᨲᩩ ᨴᩣᩁᩩ ᨧ.

ᨻᩩᨶ᩠ᨴᩮᩣ ᨾᩪᩃᨬ᩠ᨧ ᨸᩣᨴᩮᩣ ᨳ, ᩈᨦ᩠ᨠᩩ’ᨲ᩠ᨲᩮᩣ ᨡᩣᨱᩩᨶᩥᨲ᩠ᨳᩥᨿᩴ;

ᨠᩁᩉᩣᨭᩴ ᨲᩩ ᨠᨶ᩠ᨴᩮᩣ ᨳ, ᨠᩊᩦᩁᩮᩣ ᨾᨲ᩠ᨳᨠᩮᩣ ᨽᩅᩮ.

ᩅᩃ᩠ᩃᩁᩦ ᨾᨬ᩠ᨩᩁᩦ ᨶᩣᩁᩦ, ᩅᩃ᩠ᩃᩦ ᨲᩩ ᨠᨳᩥᨲᩣ ᩃᨲᩣ;

ᨳᨾ᩠ᨽᩮᩣ ᨣᩩᨾ᩠ᨻᩮᩣ ᨧ ᩋᨠ᩠ᨡᨶ᩠ᨵᩮ, ᩃᨲᩣ ᩅᩥᩁᩪ ᨸᨲᩣᨶᩥᨶᩦ.

ᩋᩔᨲ᩠ᨳᩮᩣ ᨻᩮᩣᨵᩥ ᨧ ᨴ᩠ᩅᩦᩈᩩ, ᨶᩥᨣᩕᩮᩣᨵᩮᩣ ᨲᩩ ᩅᨭᩮᩣ ᨽᩅᩮ;

ᨠᨻᩥᨭ᩠ᨮᩮᩣ ᨧ ᨠᨸᩥᨲ᩠ᨳᩮᩣ ᨧ, ᨿᨬ᩠ᨬᨦ᩠ᨣᩮᩣ ᨲᩩ ᩏᨴᩩᨾ᩠ᨻᩁᩮᩣ.

ᨠᩮᩣᩅᩥᩊᩣᩁᩮᩣ ᨿᩩᨣᨸᨲ᩠ᨲᩮᩣ, ᩏᨴ᩠ᨴᩣᩃᩮᩣ ᩅᩣᨲᨥᩣᨲᨠᩮᩣ;

ᩁᩣᨩᩁᩩᨠ᩠ᨡᩮᩣ ᨠᨲᨾᩣᩃᩦ, ᨶ᩠ᨴᩦᩅᩁᩮᩣ ᨻ᩠ᨿᩣᨵᩥᨥᩣᨲᨠᩮᩣ.

ᨴᨶ᩠ᨲᩈᨮᩮᩣ ᨧ ᨩᨾ᩠ᨽᩦᩁᩮᩣ, ᩅᩁᨱᩮᩣ ᨲᩩ ᨠᩁᩮᩁᩥ ᨧ;

ᨠᩥᩴ ᩈᩩᨠᩮᩣ ᨸᩣᩃᩥᨽᨴ᩠ᨴᩮᩣᨳ, ᩅᨬ᩠ᨩᩩᩃᩮᩣ ᨲᩩ ᨧ ᩅᩮᨲᩈᩮᩣ.

ᩋᨾ᩠ᨻᩣᨭᨠᩮᩣᨸᩦᨲᨶᨠᩮᩣ, ᨾᨵᩩᨠᩮᩣ ᨲᩩ ᨾᨵᩩᨴ᩠ᨴᩩᨾᩮᩣ;

ᩋᨳᩮᩣ ᨣᩩᩊᨹᩃᩮᩣ ᨸᩦᩃᩩ, ᩈᩮᩣᨽᨬ᩠ᨩᨶᩮᩣ ᨧ ᩈᩥᨣ᩠ᨣᩩ ᨧ.

ᩈᨲ᩠ᨲᨸᨱ᩠ᨱᩥ ᨨᨲ᩠ᨲᨸᨱ᩠ᨱᩮᩣ, ᨲᩥᨶᩥᩈᩮᩣ ᨲ᩠ᩅ ᨲᩥᨾᩩᨲ᩠ᨲᨠᩮᩣ;

ᨾᩣᩃᩪᩁ ᨻᩮᩃᩩᩅᩣᨻᩥᩃ᩠ᩃᩮᩣ, ᨸᩩᨶ᩠ᨶᩣᨣᩮᩣ ᨲᩩ ᨧ ᨠᩮᩈᩁᩮᩣ;

ᩈᩣᩃᩅᩮᩣ ᨲᩩ ᨧ ᩃᩮᩣᨴ᩠ᨴᩮᩣ ᨳ, ᨸᩥᨿᩣᩃᩮᩣ ᩈᨶ᩠ᨶᨠᨴ᩠ᨴᩩ ᨧ.

ᨸᩩᨱ᩠ᨯᩁᩦᨠᩮᩣ ¶ ᨧ ᩈᩮᨲᨾ᩠ᨻᩮᩣ, ᩈᩮᩃᩩ ᨲᩩ ᨻᩉᩩᩅᩣᩁᨠᩮᩣ;

ᩈᩮᨸᨱ᩠ᨱᩦ ᨠᩣᩈ᩠ᨾᩥᩁᩦ ᨧᩣᨳ, ᨠᩮᩣᩃᩦ ᨧ ᨻᨴᩁᩦᨲ᩠ᨳᩥᨿᩴ.

ᨠᩮᩣᩃᩴ ᨧᩣᨶᩥᨲ᩠ᨳᩦ ᨻᨴᩁᩮᩣ, ᨸᩥᩃᨠ᩠ᨡᩮᩣ ᨸᩥᨸ᩠ᨸᩃᩦ’ᨲ᩠ᨳᩥᨿᩴ;

ᨸᩣᨭᩃᩦ ᨠᨱ᩠ᩉᩅᨶ᩠ᨲᩣ ᨧ, ᩈᩣᨴᩩᨠᨱ᩠ᨭᩮᩣ ᩅᩥᨠᨦ᩠ᨠᨲᩮᩣ.

ᨲᩥᨶ᩠ᨴᩩᨠᩮᩣ ᨠᩣᩊᨠ᩠ᨡᨶ᩠ᨵᩮᩣ ᨧ, ᨲᩥᨾ᩠ᨻᩁᩪᩈᨠ ᨲᩥᨾ᩠ᨻᩁᩪ;

ᩑᩁᩣᩅᨲᩮᩣ ᨲᩩ ᨶᩣᩁᨦ᩠ᨣᩮᩣ, ᨠᩩᩃᨠᩮᩣ ᨠᩣᨠᨲᩥᨶ᩠ᨴᩩᨠᩮᩣ.

ᨠᨴᨾ᩠ᨻᩮᩣ ᨸᩥᨿᨠᩮᩣ ᨶᩦᨸᩮᩣ, ᨽᩃ᩠ᩃᩦ ᨽᩃ᩠ᩃᩣᨲᨠᩮᩣ ᨲᩥᩈᩩ;

ᨫᩣᩅᩩᨠᩮᩣ ᨸᩥᨧᩩᩃᩮᩣ ᨧᩣᨳ, ᨲᩥᩃᨠᩮᩣ ᨡᩩᩁᨠᩮᩣ ᨽᩅᩮ.

ᨧᩥᨬ᩠ᨧᩣ ᨧ ᨲᩥᨶ᩠ᨲᩥᨱᩦ ᨧᩣᨳ, ᨣᨴ᩠ᨴᨽᨱ᩠ᨯᩮᩣ ᨠᨸᩦᨲᨶᩮᩣ;

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

ᨡᩦᩁᩥᨠᩣ ᩁᩣᨩᩣᨿᨲᨶᩴ, ᨠᩩᨾ᩠ᨽᩦ ᨠᩩᨾᩩᨴᩥᨠᩣ ᨽᩅᩮ;

ᨿᩪᨸᩮᩣ [ᨸᩪᨣᩮᩣ (ᨠ.)] ᨲᩩ ᨠᨾᩩᨠᩮᩣ ᨧᩣᨳ, ᨸᨭ᩠ᨭᩥ ᩃᩣᨡᩣᨸᩈᩣᨴᨶᩮᩣ.

ᩍᨦ᩠ᨣᩩᨴᩦ ᨲᩣᨸᩈᨲᩁᩩ, ᨽᩩᨩᨸᨲ᩠ᨲᩮᩣ ᨲᩩ ᩌᨽᩩᨩᩦ;

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

ᨸᨠᩥᩁᩥᨿᩮᩣ ᨸᩪᨲᩥᨠᩮᩣ ᨳ, ᩁᩮᩣᩉᩦ ᩁᩮᩣᩉᩥᨲᨠᩮᩣ ᨽᩅᩮ;

ᩑᩁᨱ᩠ᨯᩮᩣ ᨲᩩ ᨧ ᩌᨾᨱ᩠ᨯᩮᩣ, ᩋᨳ ᩈᨲ᩠ᨲᩩᨹᩃᩣ ᩈᨾᩦ.

ᨶᨲ᩠ᨲᨾᩣᩃᩮᩣ ᨠᩁᨬ᩠ᨩᩮᩣ ᨳ, ᨡᨴᩥᩁᩮᩣ ᨴᨶ᩠ᨲᨵᩣᩅᨶᩮᩣ;

ᩈᩮᩣᨾᩅᨠ᩠ᨠᩮᩣ ᨲᩩ ᨠᨴᩁᩮᩣ, ᩈᩃ᩠ᩃᩮᩣᨲᩩ ᨾᨴᨶᩮᩣ ᨽᩅᩮ.

ᩋᨳᩣᨸᩥ ᩍᨶ᩠ᨴᩈᩣᩃᩮᩣ ᨧ, ᩈᩃ᩠ᩃᨠᩦ ᨡᩣᩁᨠᩮᩣ ᩈᩥᨿᩣ;

ᨴᩮᩅᨴᩣᩁᩩ ᨽᨴ᩠ᨴᨴᩣᩁᩩ, ᨧᨾ᩠ᨸᩮᨿ᩠ᨿᩮᩣ ᨲᩩ ᨧ ᨧᨾ᩠ᨸᨠᩮᩣ.

ᨸᨶᩈᩮᩣ ᨠᨱ᩠ᨭᨠᩥᨹᩃᩮᩣ, ᩋᨽᨿᩣ ᨲᩩ ᩉᩁᩦᨲᨠᩦ;

ᩋᨠ᩠ᨡᩮᩣ ᩅᩥᨽᩦᨲᨠᩮᩣ ᨲᩦᩈᩩ, ᩋᨾᨲᩣ’ᨾᩃᨠᩦ ᨲᩥᩈᩩ.

ᩃᨻᩩᨩᩮᩣ ᩃᩥᨠᩩᨧᩮᩣ ᨧᩣᨳ, ᨠᨱᩥᨠᩣᩁᩮᩣ ᨴᩩᨾᩩᨸ᩠ᨸᩃᩮᩣ;

ᨶᩥᨾ᩠ᨻᩮᩣ’ᩁᩥᨭ᩠ᨮᩮᩣ ᨸᩩᨧᩥᨾᨶ᩠ᨴᩮᩣ, ᨠᩁᨠᩮᩣ ᨲᩩ ᨧ ᨴᩣᩊᩥᨾᩮᩣ.

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

ᩈᩣᨾᩣ ᨸᩥᨿᨦ᩠ᨣᩩ ᨠᨦ᩠ᨣᩩᨸᩥ, ᩈᩥᩁᩦᩈᩮᩣ ᨲᩩ ᨧ ᨽᨱ᩠ᨯᩥᩃᩮᩣ.

ᨠᩣᨠᩮᩣᨴᩩᨾ᩠ᨻᩁᩥᨠᩣ ᨹᩮᨣ᩠ᨣᩩ, ᨶᩣᨣᩮᩣ ᨲᩩ ᨶᩣᨣᨾᩣᩃᩥᨠᩣ.

ᩋᩈᩮᩣᨠᩮᩣ ᩅᨬ᩠ᨩᩩᩃᩮᩣ ᨧᩣᨳ, ᨲᨠ᩠ᨠᩣᩁᩦ ᩅᩮᨩᨿᨶ᩠ᨲᩥᨠᩣ;

ᨲᩣᨸᩥᨬ᩠ᨨᩮᩣ ᨧ ᨲᨾᩣᩃᩮᩣ ᨳ, ᨠᩩᨭᨩᩮᩣ ᨣᩥᩁᩥᨾᩃ᩠ᩃᩥᨠᩣ.

ᩍᨶ᩠ᨴᨿᩅᩮᩣ ᨹᩃᩮ ᨲᩔᩣ, ᨣ᩠ᨣᩥᨾᨶ᩠ᨳᩮᩣ ᨠᨱᩥᨠᩣ ᨽᩅᩮ;

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

ᩈᩮᨹᩣᩃᩥᨠᩣ ᨶᩦᩃᩥᨠᩣ ᨳ, ᩋᨸ᩠ᨹᩮᩣᨭᩣ ᩅᨶᨾᩃ᩠ᩃᩥᨠᩣ;

ᨻᨶ᩠ᨵᩩᨠᩮᩣ ᨩᨿᩈᩩᨾᨶᩴ, ᨽᨱ᩠ᨯᩥᨠᩮᩣ ᨻᨶ᩠ᨵᩩᨩᩦᩅᨠᩮᩣ.

ᩈᩩᨾᨶᩣ ᨩᩣᨲᩥᩈᩩᨾᨶᩣ, ᨾᩣᩃᨲᩦ ᨩᩣᨲᩥ ᩅᩔᩥᨠᩦ;

ᨿᩪᨳᩥᨠᩣ ᨾᩣᨣᨵᩦ ᨧᩣᨳ, ᩈᨲ᩠ᨲᩃᩣ ᨶᩅᨾᩃ᩠ᩃᩥᨠᩣ.

ᩅᩣᩈᨶ᩠ᨲᩦ,ᨲ᩠ᨳᩦ ᩋᨲᩥᨾᩩᨲ᩠ᨲᩮᩣ, ᨠᩁᩅᩦᩁᩮᩣ’ᩔᨾᩣᩁᨠᩮᩣ;

ᨾᩣᨲᩩᩃᩩᨦ᩠ᨣᩮᩣ ᨻᩦᨩᨸᩪᩁᩮᩣ, ᩏᨾ᩠ᨾᨲ᩠ᨲᩮᩣ ᨲᩩ ᨧ ᨾᩣᨲᩩᩃᩮᩣ.

ᨠᩁᨾᨶ᩠ᨴᩮᩣ ᩈᩩᩈᩮᨶᩮᩣ ᨧ, ᨠᩩᨶ᩠ᨴᩴ ᨲᩩ ᨾᩣᨥ᩠ᨿ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᨴᩮᩅᨲᩣᩈᩮᩣ [ᨴᩮᩅᨲᩣᨯᩮᩣ (ᩈᩦ. ᩋᨾᩁᨠᩮᩣᩈ)] ᨲᩩ ᨩᩦᨾᩪᨲᩮᩣ,

ᩋᨩ᩠ᨩᩩᨠᩮᩣ ᩈᩥᨲᨸᨱ᩠ᨱᩣᩈᩮᩣ, ᩈᨾᩦᩁᨱᩮᩣ ᨹᨱᩥᨩ᩠ᨩᨠᩮᩣ.

ᨩᨸᩣ ᨲᩩ ᨩᨿᩈᩩᨾᨶᩴ, ᨠᩁᩦᩁᩮᩣ ᨠᨠᨧᩮᩣ ᨽᩅᩮ;

ᩁᩩᨠ᩠ᨡᩣᨴᨶᩦ ᨧ ᩅᨶ᩠ᨴᩣᨠᩣ, ᨧᩥᨲ᩠ᨲᨠᩮᩣ ᨲ᩠ᩅ’ᨣ᩠ᨣᩥᩈᨬ᩠ᨬᩥᨲᩮᩣ.

ᨸᩪᨲᩥᩃᨲᩣ ᨣᩊᩮᩣᨧᩦ ᨧ, ᨾᩩᨻ᩠ᨻᩣ ᨾᨵᩩᩁᩈᩣ ᨸ᩠ᨿᨳ.

ᨠᨸᩥᨠᨧ᩠ᨨᩩ ᨴᩩᨹᩔᩮᩣ ᨳ, ᨾᨬ᩠ᨩᩥᨭ᩠ᨮᩣ ᩅᩥᨠᩈᩣ ᨽᩅᩮ;

ᩋᨾ᩠ᨻᨭ᩠ᨮᩣ ᨧ ᨲᨳᩣ ᨸᩣᨮᩣ, ᨠᨭᩩᨠᩣ ᨠᨭᩩᩁᩮᩣᩉᩥᨱᩦ.

ᩋᨸᩣᨾᨣ᩠ᨣᩮᩣ ¶ ᩈᩮᨡᩁᩥᨠᩮᩣ, ᨸᩥᨸ᩠ᨸᩃᩦ ᨾᩣᨣᨵᩦ ᨾᨲᩣ;

ᨣᩮᩣᨠᨱ᩠ᨭᨠᩮᩣ ᨧ ᩈᩥᨦ᩠ᨥᩣᨭᩮᩣ, ᨠᩮᩣᩃᩅᩃ᩠ᩃᩦ’ᨽᨸᩥᨸ᩠ᨸᩃᩦ.

ᨣᩮᩣᩃᩮᩣᨾᩦ ᨲᩩ ᩅᨧᩣ ᨧᩣᨳ, ᨣᩥᩁᩥᨠᨱ᩠ᨿ’ᨸᩁᩣᨩᩥᨲᩣ;

ᩈᩦᩉᨸᩩᨧ᩠ᨨᩦ ᨸᨬ᩠ᩉᩥᨸᨱ᩠ᨱᩦ, ᩈᩣᩃᨸᨱ᩠ᨱᩦ ᨲᩩ ᨧ’ᨲ᩠ᨳᩥᩁᩣ; (ᨧᨳᩥᩁᩣ).

ᨶᩥᨴᩥᨴ᩠ᨵᩥᨠᩣ ᨲᩩ ᨻ᩠ᨿᨣ᩠ᨥᩦ ᨧ, ᩋᨳ ᨶᩦᩃᩦ ᨧ ᨶᩦᩃᩥᨶᩦ;

ᨩᩥᨬ᩠ᨩᩩᨠᩮᩣ [ᨩᩥᨬ᩠ᨩᩩᨠᩣ (ᨠ.)] ᨧᩮᩅ ᨣᩩᨬ᩠ᨩᩣ ᨳ, ᩈᨲᨾᩪᩃᩦ ᩈᨲᩣᩅᩁᩦ.

ᨾᩉᩮᩣᩈᨵᩴ ᨲ᩠ᩅ’ᨲᩥᩅᩥᩈᩣ, ᨻᩣᨠᩩᨧᩦ ᩈᩮᩣᨾᩅᩃ᩠ᩃᩥᨠᩣ;

ᨴᩣᨻ᩠ᨻᩦ ᨴᩣᩁᩩᩉᩃᩥᨴ᩠ᨴᩣ ᨳ, ᨻᩥᩊᨦ᩠ᨣᩴ ᨧᩥᨲᩕᨲᨱ᩠ᨯᩩᩃᩣ.

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

ᩋᨳᩣᨸᩥ ᨾᨵᩩᨠᩴ ᨿᨭ᩠ᨮᩥ, ᨾᨵᩩᨠᩣᨾᨵᩩᨿᨭ᩠ᨮᩥᨠᩣ [ᨾᨵᩩᩃᨭ᩠ᨮᩥᨠᩣ (ᩈᩦ. ᨭᩦ.)].

ᩅᩣᨲᩥᨦ᩠ᨣᨱᩮᩣ ᨧ ᨽᨱ᩠ᨯᩣᨠᩦ, ᩅᩣᨲ᩠ᨲᩣᨠᩦ ᨻᩕᩉᨲᩦ ᨸ᩠ᨿᨳ;

ᨶᩣᨣᨻᩃᩣ ᨧᩮᩅ ᨫᩈᩣ, ᩃᩣᨦ᩠ᨣᩃᩦ ᨲᩩ ᨧ ᩈᩣᩁᨴᩦ.

ᩁᨾ᩠ᨽᩣ ᨧ ᨠᨴᩃᩦ ᨾᩮᩣᨧᩮᩣ, ᨠᨸ᩠ᨸᩣᩈᩦ ᨻᨴᩁᩣ ᨽᩅᩮ;

ᨶᩣᨣᩃᨲᩣ ᨲᩩ ᨲᨾ᩠ᨻᩪᩃᩦ, ᩋᨣ᩠ᨣᩥᨩᩣᩃᩣ ᨲᩩ ᨵᩣᨲᨠᩦ.

ᨲᩥᩅᩩᨲᩣ ᨲᩥᨸᩩᨭᩣ ᨧᩣᨳ, ᩈᩣᨾᩣ ᨠᩣᩊᩣ ᨧ ᨠᨳ᩠ᨿᨲᩮ;

ᩋᨳᩮᩣ ᩈᩥᨦ᩠ᨣᩦ ᨧ ᩏᩈᨽᩮᩣ, ᩁᩮᨱᩩᨠᩣ ᨠᨸᩥᩊᩣ ᨽᩅᩮ.

ᩉᩥᩁᩥᩅᩮᩁᨬ᩠ᨧ ᩅᩣᩃᨬ᩠ᨧ, ᩁᨲ᩠ᨲᨹᩃᩣ ᨲᩩ ᨻᩥᨾ᩠ᨻᩥᨠᩣ;

ᩈᩮᩃᩮᨿ᩠ᨿ’ ᨾᩈ᩠ᨾᨸᩩᨸ᩠ᨹᨬ᩠ᨧ, ᩑᩃᩣ ᨲᩩ ᨻᩉᩩᩃᩣ ᨽᩅᩮ.

ᨠᩩᨭ᩠ᨮᨬ᩠ᨧ ᨻ᩠ᨿᩣᨵᩥ ᨠᨳᩥᨲᩮᩣ, ᩅᩣᨶᩮᨿ᩠ᨿᩴ ᨲᩩ ᨠᩩᨭᨶ᩠ᨶᨭᩴ;

ᩒᩈᨵᩥ ᨩᩣᨲᩥᨾᨲ᩠ᨲᨾ᩠ᩉᩥ, ᩒᩈᨵᩴ ᩈᨻ᩠ᨻ’ ᨾᨩᩣᨲᩥᨿᩴ.

ᨾᩪᩃᩴ ᨸᨲ᩠ᨲᩴ ᨠᩊᩦᩁ’ᨣ᩠ᨣᩴ, ᨠᨶ᩠ᨴᩴ ᨾᩥᨬ᩠ᨩᩣ ᨹᩃᩴ ᨲᨳᩣ;

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

ᨩᩦᩅᨶ᩠ᨲᩥ ᨩᩦᩅᨶᩦ ᨧᩣᨳ, ᨾᨵᩩᩁᨠᩮᩣ ᨧ ᨩᩦᩅᨠᩮᩣ.

ᨾᩉᩣᨠᨶ᩠ᨴᩮᩣ ᨧ ᩃᩈᩩᨱᩴ, ᨸᩃᨱ᩠ᨯᩩ ᨲᩩ ᩈᩩᨠᨶ᩠ᨴᨠᩮᩣ;

ᨸᨭᩮᩣᩃᩮᩣ ᨲᩥᨲ᩠ᨲᨠᩮᩣ ᨧᩣᨳ, ᨽᩥᨦ᩠ᨣᩁᩣᨩᩮᩣ ᨧ ᨾᨠ᩠ᨠᩅᩮᩣ.

ᨸᩩᨶᨶ᩠ᨶᩅᩣ ¶ ᩈᩮᩣᨳᨥᩣᨲᩦ, ᩅᩥᨲᩩᨶ᩠ᨶᩴ ᩈᩩᨶᩥᩈᨱ᩠ᨱᨠᩴ;

ᨠᩣᩁᩅᩮᩃ᩠ᩃᩮᩣ ᨲᩩ ᩈᩩᩈᩅᩦ, ᨲᩩᨾ᩠ᨻ᩠ᨿᩣ’ᩃᩣᨻᩩ ᨧ ᩃᩣᨻᩩ ᩈᩣ.

ᩑᩊᩣᩃᩩᨠᨬ᩠ᨧ ᨠᨠ᩠ᨠᩣᩁᩦ, ᨠᩩᨾ᩠ᨽᨱ᩠ᨯᩮᩣ ᨲᩩ ᨧ ᩅᩃ᩠ᩃᩥᨽᩮᩣ;

ᩍᨶ᩠ᨴᩅᩣᩁᩩᨱᩦ ᩅᩥᩈᩣᩃᩣ, ᩅᨲ᩠ᨳᩩᨠᩴ ᩅᨲ᩠ᨳᩩᩃᩮᨿ᩠ᨿᨠᩮᩣ.

ᨾᩪᩃᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨧᩩᨧ᩠ᨧᩩ, ᨲᨾ᩠ᨻᨠᩮᩣ ᨧ ᨠᩃᨾ᩠ᨻᨠᩮᩣ;

ᩈᩣᨠᨽᩮᨴᩣ ᨠᩣᩈᨾᨴ᩠ᨴ, ᨫᨩ᩠ᨫᩁᩦ ᨹᨣ᩠ᨣᩅᩣ’ᨴᨿᩮᩣ.

ᩈᨴ᩠ᨴᩃᩮᩣ ᨧᩮᩅ ᨴᩩᨻ᩠ᨻᩣ ᨧ, ᨣᩮᩣᩃᩮᩣᨾᩦ ᩈᩣ ᩈᩥᨲᩣ ᨽᩅᩮ;

ᨣᩩᨶ᩠ᨴᩣ ᨧ ᨽᨴ᩠ᨴᨾᩩᨲ᩠ᨲᨬ᩠ᨧ, ᩁᩈᩣᩃᩮᩣ ᨲᩩ’ᨧ᩠ᨨᩩ ᩅᩮᩊᩩ ᨲᩩ.

ᨲᨧᩈᩣᩁᩮᩣ ᩅᩮᨱᩩ ᩅᩴᩈᩮᩣ, ᨸᨻ᩠ᨻᩴ ᨲᩩ ᨹᩃᩩ ᨣᨱ᩠ᨮᩥᩈᩮᩣ;

ᨠᩦᨧᨠᩣ ᨲᩮ ᩈᩥᨿᩩᩴ ᩅᩮᨱᩪ, ᨿᩮ ᨶᨴᨶ᩠ᨲ᩠ᨿᩣ’ᨶᩥᩃᨴ᩠ᨵᩩᨲᩣ.

ᨶᩊᩮᩣ ᨧ ᨵᨾᨶᩮᩣ ᨸᩮᩣᨭ, ᨣᩃᩮᩣ ᨲᩩ ᨠᩣᩈ ᨾᩥᨲ᩠ᨳᩥ ᨶ;

ᨲᩮᨩᨶᩮᩣ ᨲᩩ ᩈᩁᩮᩣ, ᨾᩪᩃᩴ, ᨲᩪ’ ᩈᩦᩁᩴ ᨻᩦᩁᨱᩔ ᩉᩥ.

ᨠᩩᩈᩮᩣ ᩅᩁᩉᩥᩈᩴ ᨴᨻ᩠ᨻᩮᩣ, ᨽᩪᨲᩥᨱᨠᩴ ᨲᩩ ᨽᩪᨲᩥᨱᩴ;

ᨲᩣᩃᩮᩣ ᩅᩥᨽᩮᨴᩥᨠᩣ ᨧᩣᨳ, ᨡᨩ᩠ᨩᩩᩁᩦ ᩈᩥᨶ᩠ᨴᩥ ᩅᩩᨧ᩠ᨧᨲᩥ;

ᩉᩥᨶ᩠ᨲᩣᩃ, ᨲᩣᩃ, ᨡᨩ᩠ᨩᩪᩁᩦ, ᨶᩣᩃᩥᨠᩮᩁᩣ ᨲᨳᩮᩅ ᨧ;

ᨲᩣᩃᩦ ᨧ ᨠᩮᨲᨠᩦ ᨶᩣᩁᩦ, ᨸᩪᨣᩮᩣ ᨧ ᨲᩥᨱᨸᩣᨴᨸᩣᨲᩥ.

ᨸᨻ᩠ᨻᨲᩮᩣ ᨣᩥᩁᩥ ᩈᩮᩃᩮᩣ’ᨴ᩠ᨴᩥ, ᨶᨣᩣ’ᨧᩃ, ᩈᩥᩃᩩᨧ᩠ᨧᨿᩣ;

ᩈᩥᨡᩁᩦ ᨽᩪᨵᩁᩮᩣᨳ ᨻ᩠ᨽ, ᨸᩣᩈᩣᨱᩣ’ᩈ᩠ᨾᩮᩣ’ᨸᩃᩮᩣ ᩈᩥᩃᩣ.

ᨣᩥᨩ᩠ᨫᨠᩪᨭᩮᩣ ᨧ ᩅᩮᨽᩣᩁᩮᩣ, ᩅᩮᨸᩩᩃ᩠ᩃᩮᩣ’ᩈᩥᨣᩥᩃᩦ ᨶᨣᩣ;

ᩅᩥᨬ᩠ᨫᩮᩣ ᨸᨱ᩠ᨯᩅ ᩅᨦ᩠ᨠᩣᨴᩦ, ᨸᩩᨻ᩠ᨻᩈᩮᩃᩮᩣ ᨲᩩ ᨧᩮᩣ’ᨴᨿᩮᩣ;

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

ᨣᨶ᩠ᨵᨾᩣᨴᨶ ᨠᩮᩃᩣᩈ, ᨧᩥᨲ᩠ᨲᨠᩪᨭ ᩈᩩᨴᩔᨶᩣ;

ᨠᩣᩃᨠᩪᨭᩮᩣ ᨲᩥᨠᩪᨭᩣ’ᩔ, ᨸᨲ᩠ᨳᩮᩣ ᨲᩩ ᩈᩣᨶᩩ ᨶᩥᨲ᩠ᨳᩥᨿᩴ.

ᨠᩪᨭᩮᩣ ¶ ᩅᩣ ᩈᩥᨡᩁᩴ ᩈᩥᨦ᩠ᨣᩴ, ᨸᨸᩣᨲᩮᩣ ᨲᩩ ᨲᨭᩮᩣ ᨽᩅᩮ;

ᨶᩥᨲᨾ᩠ᨻᩮᩣ ᨠᨭᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨶᩥᨩ᩠ᨫᩁᩮᩣ ᨸᩈᩅᩮᩣ’ᨾ᩠ᨻᩩᨶᩮᩣ.

ᨴᩁᩦ’ᨲ᩠ᨳᩦ ᨠᨶ᩠ᨴᩁᩮᩣ ᨴ᩠ᩅᩦᩈᩩ, ᩃᩮᨱᩴ ᨲᩩ ᨣᨻ᩠ᨽᩁᩴ ᨣᩩᩉᩣ;

ᩈᩥᩃᩣᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ ᩈᩮᩣᨱ᩠ᨯᩦ, ᨠᩩᨬ᩠ᨩᩴ ᨶᩥᨠᩩᨬ᩠ᨩ ᨾᩥᨲ᩠ᨳᩥ ᨶ.

ᩏᨴ᩠ᨵ ᨾᨵᩥᨧ᩠ᨧᨠᩣ ᩈᩮᩃ, ᩔᩣᩈᨶ᩠ᨶᩣ ᨽᩪᨾ᩠ᨿᩩ ᨸᨧ᩠ᨧᨠᩣ;

ᨾᩥᨣᩥᨶ᩠ᨴᩮᩣ ᨠᩮᩈᩁᩦ ᩈᩦᩉᩮᩣ, ᨲᩁᨧ᩠ᨨᩮᩣ ᨲᩩ ᨾᩥᨣᩣᨴᨶᩮᩣ;

ᨻ᩠ᨿᨣ᩠ᨥᩮᩣ ᨲᩩ ᨸᩩᨱ᩠ᨯᩁᩦᨠᩮᩣ ᨳ, ᩈᨴ᩠ᨴᩪᩃᩮᩣ ᨴᩦᨸᩥᨶᩦ’ᩁᩥᨲᩮᩣ.

ᨡᨣ᩠ᨣ ᨡᨣ᩠ᨣᩅᩥᩈᩣᨱᩣ ᨲᩩ, ᨸᩃᩣᩈᩣᨴᩮᩣ ᨧ ᨣᨱ᩠ᨯᨠᩮᩣ;

ᨻ᩠ᨿᨣ᩠ᨥᩣᨴᩥᨠᩮ ᩅᩣᩊᨾᩥᨣᩮᩣ, ᩈᩣᨸᨴᩮᩣ ᨳ ᨸ᩠ᩃᩅᨦ᩠ᨣᨾᩮᩣ.

ᨾᨠ᩠ᨠᨭᩮᩣ ᩅᩣᨶᩁᩮᩣ ᩈᩣᨡᩣ, ᨾᩥᨣᩮᩣ ᨠᨸᩥ ᩅᩃᩦᨾᩩᨡᩮᩣ;

ᨣᩮᩣᨶᨦ᩠ᨣᩩᩃᩮᩣ [ᨣᩮᩣᨶᨦ᩠ᨣᩃᩮᩣ (ᨭᩦ.)] ᨲᩥ ᩈᩮᩣ ᨾᨲᩮᩣ.

ᩈᩥᨦ᩠ᨣᩣᩃᩮᩣ [ᩈᩥᨣᩣᩃᩮᩣ (ᩈᩦ.)] ᨩᨾ᩠ᨻᩩᨠᩮᩣ ᨠᩮᩣᨲ᩠ᨳᩩ, ᨽᩮᩁᩅᩮᩣ ᨧ ᩈᩥᩅᩣ ᨸ᩠ᨿᨳ;

ᨻᩥᩊᩣᩁᩮᩣ ᨻᨻ᩠ᨻᩩ ᨾᨬ᩠ᨩᩣᩁᩮᩣ, ᨠᩮᩣᨠᩮᩣ ᨲᩩ ᨧ ᩅᨠᩮᩣ ᨽᩅᩮ.

ᨾᩉᩥᩴᩈᩮᩣ [ᨾᩉᩥᩈᩮᩣ (ᩈᩦ.)] ᨧ ᩃᩩᩃᩣᨿᩮᩣ ᨳ,

ᩉᩁᩥᨱᩮᩣ ᨾᩥᨣ ᩈᩣᩁᨦ᩠ᨣᩣ, ᨾᨣᩮᩣ ᩋᨩᩥᨶᨿᩮᩣᨶᩥ ᨧ;

ᩑᨱᩮᨿ᩠ᨿᩮᩣ ¶ ᩑᨱᩦᨾᩥᨣᩮᩣ ᨧ, ᨸᨾ᩠ᨸᨭᨠᩮᩣ ᨲᩩ ᨸᨾ᩠ᨸᨠᩮᩣ;

ᩅᩣᨲᨾᩥᨣᩮᩣ ᨲᩩ ᨧᩃᨶᩦ, ᨾᩪᩈᩥᨠᩮᩣ ᨲ᩠ᩅᩣ’ᨡᩩ ᩏᨶ᩠ᨴᩩᩁᩮᩣ.

ᨧᨾᩁᩮᩣ ᨸᩈᨴᩮᩣ ᨧᩮᩅ, ᨠᩩᩁᩩᨦ᩠ᨣᩮᩣ ᨾᩥᨣᨾᩣᨲᩩᨠᩣ;

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

ᨸᩥᨿᨠᩮᩣ ᨧᨾᩪᩁᩩ ᨠᨴᩃᩦ, ᨾᩥᨣᩣᨴᩦ ᨧᨾ᩠ᨾᨿᩮᩣᨶᨿᩮᩣ;

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

ᩃᩪᨲᩣ ᨲᩩ ᩃᩪᨲᩥᨠᩣ ᩏᨱ᩠ᨱ, ᨶᩣᨽᩥ ᨾᨠ᩠ᨠᨭᨠᩮᩣ ᩈᩥᨿᩣ;

ᩅᩥᨧ᩠ᨨᩥᨠᩮᩣ ᨲ᩠ᩅᩣ’ᩊᩥ ᨠᨳᩥᨲᩮᩣ, ᩈᩁᨻᩪ ᨥᩁᨣᩮᩣᩊᩥᨠᩣ.

ᨣᩮᩣᨵᩣ ᨠᩩᨱ᩠ᨯᩮᩣ ᨸ᩠ᨿᨳᩮᩣ ᨠᨱ᩠ᨱ, ᨩᩃᩪᨠᩣ ᩈᨲᨸᨴ᩠ᨿᨳ;

ᨠᩃᨶ᩠ᨴᨠᩮᩣ ᨠᩣᩊᨠᩣ ᨳ, ᨶᨠᩩᩃᩮᩣ ᨾᨦ᩠ᨣᩩᩈᩮᩣ ᨽᩅᩮ.

ᨠᨠᨱ᩠ᨭᨠᩮᩣ ᨧ ᩈᩁᨭᩮᩣ, ᨠᩦᨭᩮᩣ ᨲᩩ ᨸᩩᩊᩅᩮᩣ ᨠᩥᨾᩥ;

ᩅᩥᩉᨦ᩠ᨣᩮᩣ ᩅᩥᩉᨣᩮᩣ ᨸᨠ᩠ᨡᩦ, ᩅᩥᩉᨦ᩠ᨣᨾ ᨡᨣ’ᨱ᩠ᨯᨩᩣ;

ᩈᨠᩩᨱᩮᩣ ᨧ ᩈᨠᩩᨶ᩠ᨲᩮᩣ ᩅᩥ, ᨸᨲᨦ᩠ᨣᩮᩣ ᩈᨠᩩᨱᩦ ᨴ᩠ᩅᩥᨩᩮᩣ.

ᩅᨠ᩠ᨠᨦ᩠ᨣᩮᩣ ᨸᨲ᩠ᨲᨿᩣᨶᩮᩣ ᨧ, ᨸᨲᨶ᩠ᨲᩮᩣ ᨶᩦᩊᨩᩮᩣ ᨽᩅᩮ;

ᨲᨻ᩠ᨽᩮᨴᩣ ᩅᨭ᩠ᨭᨠᩣ ᨩᩦᩅ, ᨬ᩠ᨩᩦᩅᩮᩣ ᨧᨠᩮᩣᩁ ᨲᩥᨲ᩠ᨲᩥᩁᩣ.

ᩈᩣᩊᩥᨠᩣ ᨠᩁᩅᩦᨠᩮᩣ ᨧ, ᩁᩅᩥᩉᩴᩈᩮᩣ ᨠᩩᨠᩩᨲ᩠ᨳᨠᩮᩣ;

ᨠᩣᩁᨱ᩠ᨯᩅᩮᩣ ᨧ ᨸᩥᩃᩅᩮᩣ [ᨻᩥᩃᩅᩮᩣ (ᨭᩦ.)], ᨸᩮᩣᨠ᩠ᨡᩁᩈᩣᨲᨠᩣ’ᨴᨿᩮᩣ.

ᨸᨲᨲ᩠ᨲᩴ ᨸᩮᨡᩩᨱᩴ ᨸᨲ᩠ᨲᩴ, ᨸᨠ᩠ᨡᩮᩣ ᨸᩥᨬ᩠ᨨᩴ ᨨᨴᩮᩣ ᨣᩁᩩ;

ᩋᨱ᩠ᨯᩴ ᨲᩩ ᨸᨠ᩠ᨡᩥᨻᩦᨩᩮ ᨳ, ᨶᩦᩊᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨠᩩᩃᩣᩅᨠᩴ.

ᩈᩩᨸᨱ᩠ᨱᨾᩣᨲᩣ ᩅᩥᨶᨲᩣ, ᨾᩥᨳᩩᨶᩴ ᨳᩦᨸᩩᨾᨴ᩠ᩅᨿᩴ;

ᨿᩩᨣᩴ ᨲᩩ ᨿᩩᨣᩃᩴ ᨴ᩠ᩅᨶ᩠ᨴᩴ, ᨿᨾᨠᩴ ᨿᨾᩃᩴ ᨿᨾᩴ.

ᩈᨾᩪᩉᩮᩣ ᨣᨱ ᩈᨦ᩠ᨥᩣᨲᩣ, ᩈᨾᩩᨴᩣᨿᩮᩣ ᨧ ᩈᨬ᩠ᨧᨿᩮᩣ;

ᩈᨶ᩠ᨴᩮᩣᩉᩮᩣ ᨶᩥᩅᩉᩮᩣ ᩒᨥᩮᩣ, ᩅᩥᩈᩁᩮᩣ ᨶᩥᨠᩁᩮᩣ ᨧᨿᩮᩣ.

ᨠᩣᨿᩮᩣ ᨡᨶ᩠ᨵᩮᩣ ᩈᨾᩩᨴᨿᩮᩣ, ᨥᨭᩣ ᩈᨾᩥᨲᩥ ᩈᩴᩉᨲᩥ;

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

ᨻ᩠ᨿᩪᩉᩮᩣ ¶ ᩅᩥᨲᩣᨶ ᨣᩩᨾ᩠ᨻᩣ ᨧ, ᨠᩃᩣᨸᩮᩣ ᨩᩣᩃ ᨾᨱ᩠ᨯᩃᩴ;

ᩈᨩᩣᨲᩥᨠᩣᨶᩴ ᨲᩩ ᨠᩩᩃᩴ, ᨶᩥᨠᩣᨿᩮᩣ ᨲᩩ ᩈᨵᨾ᩠ᨾᩥᨶᩴ;

ᨿᩪᨳᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᨩᩣᨲᩥᨿ, ᨲᩥᩁᨧ᩠ᨨᩣᨶᩣᨶᨾᩩᨧ᩠ᨧᨲᩮ.

ᩈᩩᨸᨱ᩠ᨱᩮᩣ ᩅᩮᨶᨲᩮᨿ᩠ᨿᩮᩣ ᨧ, ᨣᩁᩩᩊᩮᩣ ᩅᩥᩉᨣᩣᨵᩥᨸᩮᩣ;

ᨸᩁᨸᩩᨭ᩠ᨮᩮᩣ ᨸᩁᨽᨲᩮᩣ, ᨠᩩᨱᩣᩃᩮᩣ ᨠᩮᩣᨠᩥᩃᩮᩣ ᨸᩥᨠᩮᩣ.

ᨾᩮᩣᩁᩮᩣ ᨾᨿᩪᩁᩮᩣ ᩅᩁᩉᩦ, ᨶᩦᩃᨣᩦᩅ ᩈᩥᨡᨱ᩠ᨯᩥᨶᩮᩣ;

ᨠᩃᩣᨸᩦ ᨧ ᩈᩥᨡᩦ ᨠᩮᨠᩦ, ᨧᩪᩊᩣ ᨲᩩ ᨧ ᩈᩥᨡᩣ ᨽᩅᩮ.

ᩈᩥᨡᨱ᩠ᨯᩮᩣ ᩅᩁᩉᨬ᩠ᨧᩮᩅ, ᨠᩃᩣᨸᩮᩣ ᨸᩥᨬ᩠ᨨ ᨾᨸ᩠ᨿᨳ;

ᨧᨶ᩠ᨴᨠᩮᩣ ᨾᩮᨧᨠᩮᩣ ᨧᩣᨳ, ᨨᨸ᩠ᨸᨴᩮᩣ ᨧ ᨾᨵᩩᨻ᩠ᨻᨲᩮᩣ.

ᨾᨵᩩᩃᩦᩉᩮᩣ ᨾᨵᩩᨠᩁᩮᩣ, ᨾᨵᩩᨸᩮᩣ ᨽᨾᩁᩮᩣ ᩋᩃᩥ;

ᨸᩣᩁᩣᩅᨲᩮᩣ ᨠᨸᩮᩣᨲᩮᩣ ᨧ, ᨠᨠᩩᨭᩮᩣ ᨧ ᨸᩣᩁᩮᩅᨲᩮᩣ.

ᨣᩥᨩ᩠ᨫᩮᩣ ᨣᨴ᩠ᨵᩮᩣᨳ ᨠᩩᩃᩃᩮᩣ, ᩈᩮᨶᩮᩣ ᨻ᩠ᨿᨣ᩠ᨥᩦᨶᩈᩮᩣ ᨸ᩠ᨿᨳ;

ᨲᨻ᩠ᨽᩮᨴᩣ ᩈᨠᩩᨱᨣ᩠ᨥᩥ’ᨲ᩠ᨳᩦ, ᩌᨭᩮᩣ ᨴᨻ᩠ᨻᩥᨾᩩᨡᨴ᩠ᩅᩥᨩᩮᩣ.

ᩏᩉᩩᨦ᩠ᨠᩣᩁᩮᩣ ᩏᩃᩪᨠᩮᩣ ᨧ, ᨠᩮᩣᩈᩥᨿᩮᩣ ᩅᩣᨿᩈᩣᩁᩥ ᨧ;

ᨠᩣᨠᩮᩣ ᨲ᩠ᩅ’ᩁᩥᨭ᩠ᨮᩮᩣ ᨵᨦ᩠ᨠᩮᩣ ᨧ, ᨻᩃᩥᨸᩩᨭ᩠ᨮᩮᩣ ᨧ ᩅᩣᨿᩈᩮᩣ.

ᩅᩣᩁᨱᩮᩣ ᩉᨲ᩠ᨳᩥᩃᩥᨦ᩠ᨣᩮᩣ ᨧ, ᩉᨲ᩠ᨳᩥᩈᩮᩣᨱ᩠ᨯᩅᩥᩉᨦ᩠ᨣᨾᩮᩣ.

ᩏᨠ᩠ᨠᩩᩈᩮᩣ ᨠᩩᩁᩁᩮᩣ ᨠᩮᩣᩃ,ᨭ᩠ᨮᩥᨸᨠ᩠ᨡᩥᨾ᩠ᩉᩥ ᨧ ᨠᩩᨠ᩠ᨠᩩᩉᩮᩣ;

ᩈᩩᩅᩮᩣ ᨲᩩ ᨠᩦᩁᩮᩣ ᨧ ᩈᩩᨠᩮᩣ, ᨲᨾ᩠ᨻᨧᩪᩊᩮᩣ ᨲᩩ ᨠᩩᨠ᩠ᨠᩩᨭᩮᩣ.

ᩅᨶᨠᩩᨠ᩠ᨠᩩᨭᩮᩣ ᨧ ᨶᩥᨩ᩠ᨩᩥᩅ᩠ᩉᩮᩣ, ᩋᨳ ᨠᩮᩣᨬ᩠ᨧᩣ ᨧ ᨠᩩᨶ᩠ᨲᨶᩦ;

ᨧᨠ᩠ᨠᩅᩣᨠᩮᩣ ᨲᩩ ᨧᨠ᩠ᨠᩅ᩠ᩉᩮᩣ, ᩈᩣᩁᨦ᩠ᨣᩮᩣᨲᩩ ᨧ ᨧᩣᨲᨠᩮᩣ.

ᩃᩮᩣᩉᨸᩥᨭ᩠ᨮᩮᩣ ᨲᨳᩣ ᨠᨦ᩠ᨠᩮᩣ, ᨡᨬ᩠ᨩᩁᩦᨭᩮᩣ ᨲᩩ ᨡᨬ᩠ᨩᨶᩮᩣ;

ᨠᩃᩅᩥᨦ᩠ᨠᩮᩣ ᨲᩩ ᨧᩣᨭᨠᩮᩣ, ᨴᩥᨶ᩠ᨴᩥᨽᩮᩣ ᨲᩩ ᨠᩥᨠᩦ ᨽᩅᩮ.

ᨠᩣᨴᨾ᩠ᨻᩮᩣ ¶ ᨠᩣᩊᩉᩴᩈᩮᩣᨳ, ᩈᨠᩩᨶ᩠ᨲᩮᩣ ᨽᩣᩈᨸᨠ᩠ᨡᩥᨶᩥ;

ᨡᩩᨴ᩠ᨴᩣᨴᩦ ᨾᨠ᩠ᨡᩥᨠᩣᨽᩮᨴᩣ, ᨯᩴᩈᩮᩣ ᨸᩥᨦ᩠ᨣᩃᨾᨠ᩠ᨡᩥᨠᩣ;

ᩌᩈᩣᨭᩥᨠᩣ ᨾᨠ᩠ᨡᩥᨠᩣᨱ᩠ᨯᩴ, ᨸᨲᨦ᩠ᨣᩮᩣ ᩈᩃᨽᩮᩣ ᨽᩅᩮ.

ᩈᩪᨧᩥᨾᩩᨡᩮᩣ ᨧ ᨾᨠᩈᩮᩣ, ᨧᩦᩁᩦ ᨲᩩ ᨫᩃ᩠ᩃᩥᨠᩣ [ᨫᩥᩃ᩠ᩃᩥᨠᩣ (ᨠ.)] ᨳ ᨧ;

ᨩᨲᩩᨠᩣ ᨩᩥᨶᨸᨲ᩠ᨲᩣ ᨳ, ᩉᩴᩈᩮᩣ ᩈᩮᨲᨧ᩠ᨨᨴᩮᩣ ᨽᩅᩮ.

ᨲᩮ ᩁᩣᨩᩉᩴᩈᩣ ᩁᨲ᩠ᨲᩮᩉᩥ, ᨸᩣᨴᨲᩩᨱ᩠ᨯᩮᩉᩥ ᨽᩣᩈᩥᨲᩣ;

ᨾᩃ᩠ᩃᩥᨠᩣ’ᨡ᩠ᨿᩣ ᨵᨲᩁᨭ᩠ᨮᩣ, ᨾᩃᩦᨶᩮᩉ᩠ᨿ’ᩈᩥᨲᩮᩉᩥ ᨧ.

᪖᪔᪘. ᨲᩥᩁᨧ᩠ᨨᩮᩣ ᨲᩩ ᨲᩥᩁᨧ᩠ᨨᩣᨶᩮᩣ, ᨲᩥᩁᨧ᩠ᨨᩣᨶᨣᨲᩮᩣ ᩈᩥᨿᩣᨲᩥ.

ᩋᨵᩮᩣᨽᩩᩅᨶᩴ ᨸᩣᨲᩣᩃᩴ, ᨶᩣᨣᩃᩮᩣᨠᩮᩣ ᩁᩈᩣᨲᩃᩴ;

ᩁᨶ᩠ᨵᩴ ᨲᩩ ᩅᩥᩅᩁᩴ ᨨᩥᨴ᩠ᨴᩴ, ᨠᩩᩉᩁᩴ ᩈᩩᩈᩥᩁᩴ ᨻᩥᩃᩴ.

ᩈᩩᩈᩥ’ᨲ᩠ᨳᩦ ᨨᩥᨣ᩠ᨣᩃᩴ ᩈᩮᩣᨻ᩠ᨽᩴ, ᩈᨧ᩠ᨨᩥᨴ᩠ᨴᩮ ᩈᩩᩈᩥᩁᩴ ᨲᩥᩈᩩ;

ᨳᩥᨿᩴ ᨲᩩ ᨠᩣᩈᩩ ᩌᩅᩣᨭᩮᩣ, ᩈᨸ᩠ᨸᩁᩣᨩᩣ ᨲᩩ ᩅᩣᩈᩩᨠᩦ.

ᩋᨶᨶ᩠ᨲᩮᩣ ᨶᩣᨣᩁᩣᨩᩣ ᨳ, ᩅᩣᩉᩈᩮᩣ’ᨩᨣᩁᩮᩣ ᨽᩅᩮ;

ᨠᨾ᩠ᨻᩃᩮᩣ’ᩔᨲᩁᩮᩣ ᨾᩮᩁᩩ, ᨸᩣᨴᩮ ᨶᩣᨣᩣᨳ ᨵᨾ᩠ᨾᨶᩦ;

ᩈᩥᩃᩩᨲ᩠ᨲᩮᩣ ᨥᩁᩈᨸ᩠ᨸᩮᩣ ᨳ, ᨶᩦᩃᩈᨸ᩠ᨸᩮᩣ ᩈᩥᩃᩣᨽᩩ ᨧ.

ᩌᩈᩥᩅᩥᩈᩮᩣ ᨽᩩᨩᨦ᩠ᨣᩮᩣ’ᩉᩥ, ᨽᩩᨩᨣᩮᩣ ᨧ ᨽᩩᨩᨦ᩠ᨣᨾᩮᩣ;

ᩈᩁᩦᩈᨸᩮᩣ ᨹᨱᩦ ᩈᨸ᩠ᨸᩣ, ᩃᨣᨴ᩠ᨴᩣ ᨽᩮᩣᨣᩥ ᨸᨶ᩠ᨶᨣᩣ.

ᨴ᩠ᩅᩥᨩᩥᩅ᩠ᩉᩮᩣ ᩏᩁᨣᩮᩣ ᩅᩣᩊᩮᩣ, ᨴᩦᨥᩮᩣ ᨧ ᨴᩦᨥᨸᩥᨭ᩠ᨮᩥᨠᩮᩣ;

ᨸᩣᨴᩪᨴᩁᩮᩣ ᩅᩥᩈᨵᩁᩮᩣ, ᨽᩮᩣᨣᩮᩣ ᨲᩩ ᨹᨱᩥᨶᩮᩣ ᨲᨶᩩ.

ᩌᩈᩦ’ᨲ᩠ᨳᩦ ¶ ᩈᨸ᩠ᨸᨴᩣᨮᩣ ᨳ, ᨶᩥᨾ᩠ᨾᩮᩣᨠᩮᩣ ᨠᨬ᩠ᨧᩩᨠᩮᩣ ᩈᨾᩣ;

ᩅᩥᩈᩴ ᨲ᩠ᩅ’ᨶᩥᨲ᩠ᨳᩦ ᨣᩁᩊᩴ, ᨲᨻ᩠ᨽᩮᨴᩣ ᩅᩣ ᩉᩃᩣᩉᩃᩮᩣ.

ᨠᩣᩊᨠᩪᨭᩣᨴᨿᩮᩣ ᨧᩣᨳ, ᩅᩣᩊᨣ᩠ᨣᩣᨲ᩠ᨿ’ᩉᩥᨲᩩᨱ᩠ᨯᩥᨠᩮᩣ;

ᨶᩥᩁᨿᩮᩣ ᨴᩩᨣ᩠ᨣᨲᩥ’ᨲ᩠ᨳᩦ ᨧ, ᨶᩁᨠᩮᩣ, ᩈᩮᩣ ᨾᩉᩣ’ᨭ᩠ᨮᨵᩣ;

ᩈᨬ᩠ᨩᩦᩅᩮᩣ ᨠᩣᩊᩈᩩᨲ᩠ᨲᩮᩣ ᨧ, ᨾᩉᩣᩁᩮᩣᩁᩩᩅ ᩁᩮᩣᩁᩩᩅᩣ;

ᨸᨲᩣᨸᨶᩮᩣ ᩋᩅᩦᨧᩥ’ᨲ᩠ᨳᩦ, ᩈᨦ᩠ᨥᩣᨲᩮᩣ ᨲᩣᨸᨶᩮᩣ ᩍᨲᩥ.

ᨳᩥᨿᩴ ᩅᩮᨲᩁᨱᩦ ᩃᩮᩣᩉ, ᨠᩩᨾ᩠ᨽᩦ ᨲᨲ᩠ᨳ ᨩᩃᩣᩈᨿᩣ;

ᩋᨱ᩠ᨱᩅᩮᩣ ᩈᩣᨣᩁᩮᩣ ᩈᩥᨶ᩠ᨵᩩ, ᩈᨾᩩᨴ᩠ᨴᩮᩣ ᩁᨲᨶᩣᨠᩁᩮᩣ;

ᨩᩃᨶᩥᨫᩩ’ ᨴᨵᩥ, ᨲᩔ, ᨽᩮᨴᩣ ᨡᩦᩁᨱ᩠ᨱᩅᩣᨴᨿᩮᩣ.

ᨳᩮᩅᩮᩣ ᨲᩩ ᨻᩥᨶ᩠ᨴᩩ ᨹᩩᩈᩥᨲᩴ, ᨽᨾᩮᩣ ᨲᩩ ᨩᩃᨶᩥᨣ᩠ᨣᨾᩮᩣ.

ᩌᨸᩮᩣ ᨸᨿᩮᩣ ᨩᩃᩴ ᩅᩣᩁᩥ, ᨸᩣᨶᩦᨿᩴ ᩈᩃᩥᩃᩴ ᨴᨠᩴ;

ᩋᨱ᩠ᨱᩮᩣ ᨶᩦᩁᩴ ᩅᨶᩴ ᩅᩣᩃᩴ, ᨲᩮᩣᨿᩴ ᩋᨾ᩠ᨻᩩ’ᨴᨠᨬ᩠ᨧ ᨠᩴ.

ᨲᩁᨦ᩠ᨣᩮᩣ ᨧ ᨲᨳᩣ ᨽᨦ᩠ᨣᩮᩣ, ᩐᨾᩥ ᩅᩦᨧᩥ ᨸᩩᨾᩥᨲ᩠ᨳᩥᨿᩴ;

ᩏᩃ᩠ᩃᩮᩣᩃᩮᩣ ᨲᩩ ᨧ ᨠᩃ᩠ᩃᩮᩣᩃᩮᩣ, ᨾᩉᩣᩅᩦᨧᩦᩈᩩ ᨠᨳ᩠ᨿᨲᩮ.

ᨩᨾ᩠ᨻᩣᩃᩮᩣ ᨠᩃᩃᩴ ᨸᨦ᩠ᨠᩮᩣ, ᨧᩥᨠ᩠ᨡᩃ᩠ᩃᩴ ᨠᨴ᩠ᨴᨾᩮᩣ ᨸ᩠ᨿᨳ;

ᨸᩩᩃᩥᨶᩴ ᩅᩣᩃᩩᨠᩣ ᩅᨱ᩠ᨱᩩ, ᨾᩁᩪ’ᩁᩩ ᩈᩥᨠᨲᩣ ᨽᩅᩮ.

ᩋᨶ᩠ᨲᩁᩦᨸᨬ᩠ᨧ ᨴᩦᨸᩮᩣ ᩅᩣ, ᨩᩃᨾᨩ᩠ᨫᨣᨲᩴ ᨳᩃᩴ;

ᨲᩦᩁᩴ ᨲᩩ ᨠᩪᩃᩴ ᩁᩮᩣᨵᨬ᩠ᨧ, ᨸᨲᩦᩁᨬ᩠ᨧ ᨲᨭᩴ ᨲᩥᩈᩩ.

ᨸᩣᩁᩴ ᨸᩁᨾ᩠ᩉᩥ ᨲᩦᩁᨾ᩠ᩉᩥ, ᩒᩁᩴ ᨲ᩠ᩅ’ᨸᩣᩁ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᩏᩊᩩᨾ᩠ᨸᩮᩣ [ᩏᩊᩩᨸᩮᩣ (ᨠ.)] ᨲᩩ ᨸ᩠ᩃᩅᩮᩣ ᨠᩩᩃ᩠ᩃᩮᩣ, ᨲᩁᩮᩣ ᨧ ᨸᨧ᩠ᨧᩁᩦ’ᨲ᩠ᨳᩥᨿᩴ.

ᨲᩁᨱᩦ ᨲᩁᩥ ᨶᩣᩅᩣ ᨧ, ᨠᩪᨸᨠᩮᩣ ᨲᩩ ᨧ ᨠᩩᨾ᩠ᨽᨠᩴ;

ᨸᨧ᩠ᨨᩣᨻᨶ᩠ᨵᩮᩣ ᨣᩮᩣᨭᩅᩥᩈᩮᩣ, ᨠᨱ᩠ᨱᨵᩣᩁᩮᩣ ᨲᩩ ᨶᩣᩅᩥᨠᩮᩣ.

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

ᨶᩣᩅᩣᨿ’ᨦ᩠ᨣᩣ’ ¶ ᩃᨦ᩠ᨠᩣᩁᩮᩣ ᨧ, ᩅᨭᩣᨠᩣᩁᩮᩣ ᨹᩥᨿᩣᨴᨿᩮᩣ;

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

ᨣᨽᩦᩁ ᨶᩥᨶ᩠ᨶ ᨣᨾ᩠ᨽᩦᩁᩣ, ᨳᩮᩣ ᨲ᩠ᨲᩣᨶᩴ ᨲᨻ᩠ᨻᩥᨸᨠ᩠ᨡᨠᩮ;

ᩋᨣᩣᨵᩴ ᨲ᩠ᩅ’ᨲᩃᨾ᩠ᨹᩔᩴ, ᩋᨶᨧ᩠ᨨᩮᩣ ᨠᩃᩩᩈᩣ’ᩅᩥᩃᩣ.

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

ᨵᩦᩅᩁᩮᩣ ᨾᨧ᩠ᨨᩥᨠᩮᩣ ᨾᨧ᩠ᨨ, ᨻᨶ᩠ᨵ ᨠᩮᩅᨭ᩠ᨭ ᨩᩣᩃᩥᨠᩣ.

ᨾᨧ᩠ᨨᩮᩣ ᨾᩦᨶᩮᩣ ᨩᩃᨧᩁᩮᩣ, ᨸᩩᨳᩩᩃᩮᩣᨾᩮᩣ’ᨾ᩠ᨻᩩᨩᩮᩣ ᨫᩈᩮᩣ;

ᩁᩮᩣᩉᩥᨲᩮᩣ ᨾᨣ᩠ᨣᩩᩁᩮᩣ ᩈᩥᨦ᩠ᨣᩦ, ᨻᩃᨩᩮᩣ ᨾᩩᨬ᩠ᨩ ᨸᩣᩅᩩᩈᩣ.

ᩈᨲ᩠ᨲᩅᨦ᩠ᨠᩮᩣ ᩈᩅᨦ᩠ᨠᩮᩣ ᨧ, ᨶᩊᨾᩦᨶᩮᩣ ᨧ ᨣᨱ᩠ᨯᨠᩮᩣ;

ᩈᩩᩈᩩᨠᩣ ᩈᨹᩁᩦ ᨾᨧ᩠ᨨ, ᨸ᩠ᨸᨽᩮᨴᩣ ᨾᨠᩁᩣᨴᨿᩮᩣ.

ᨾᩉᩣᨾᨧ᩠ᨨᩣ ᨲᩥᨾᩥ ᨲᩥᨾᩥ, ᨦ᩠ᨣᩃᩮᩣ ᨲᩥᨾᩥᩁᨸᩥᨦ᩠ᨣᩃᩮᩣ;

ᩌᨶᨶ᩠ᨴᩮᩣ ᨲᩥᨾᩥᨶᨶ᩠ᨴᩮᩣ ᨧ, ᩋᨩ᩠ᨫᩣᩁᩮᩣᩉᩮᩣ ᨾᩉᩣᨲᩥᨾᩥ.

ᨸᩣᩈᩣᨱᨾᨧ᩠ᨨᩮᩣ ᨸᩣᨮᩦᨶᩮᩣ, ᩅᨦ᩠ᨠᩮᩣ ᨲᩩ ᨻᩊᩥᩈᩮᩣ ᨽᩅᩮ;

ᩈᩩᩈᩩᨾᩣᩁᩮᩣ [ᩈᩴᩈᩩᨾᩣᩁᩮᩣ (ᨭᩦ.), ᩈᩩᩴᩈᩩᨾᩣᩁᩮᩣ (ᩈᩦ.)] ᨲᩩ ᨠᩩᨾ᩠ᨽᩦᩃᩮᩣ,

ᨠᨠ᩠ᨠᨭᨠᩮᩣ ᨠᩩᩊᩦᩁᩮᩣ ᨧ, ᨩᩃᩪᨠᩣ ᨲᩩ ᨧ ᩁᨲ᩠ᨲᨸᩣ;

ᩋᨳ ᩈᩥᨸ᩠ᨸᩦ ᨧ ᩈᩩᨲ᩠ᨲᩥ’ᨲ᩠ᨳᩦ, ᩈᨦ᩠ᨡᩮ ᨲᩩ ᨠᨾ᩠ᨻᩩ’ᨶᩥᨲ᩠ᨳᩥᨿᩴ;

ᨡᩩᨴ᩠ᨴᩈᨦ᩠ᨡ᩠ᨿᩮ ᩈᨦ᩠ᨡᨶᨡᩮᩣ, ᨩᩃᩈᩩᨲ᩠ᨲᩥ ᨧ ᩈᨾ᩠ᨻᩩᨠᩮᩣ.

ᨩᩃᩣᩈᨿᩮᩣ ᨩᩃᩣᨵᩣᩁᩮᩣ, ᨣᨾ᩠ᨽᩦᩁᩮᩣ ᩁᩉᨴᩮᩣ ᨳ ᨧ;

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

ᨲᩊᩣᨠᩮᩣ ᨧ ᩈᩁᩮᩣ’ᨶᩥᨲ᩠ᨳᩦ, ᩅᩣᨸᩦ ᨧ ᩈᩁᩈᩦ’ᨲ᩠ᨳᩥᨿᩴ;

ᨴᩉᩮᩣ’ᨾ᩠ᨻᩩᨩᩣᨠᩁᩮᩣ ᨧᩣᨳ, ᨸᩃ᩠ᩃᩃᩴ ᨡᩩᨴ᩠ᨴᨠᩮᩣ ᩈᩁᩮᩣ.

ᩋᨶᩮᩣᨲᨲ᩠ᨲᩮᩣ ᨲᨳᩣ ᨠᨱ᩠ᨱ, ᨾᩩᨱ᩠ᨯᩮᩣ ᨧ ᩁᨳᨠᩣᩁᨠᩮᩣ;

ᨨᨴ᩠ᨴᨶ᩠ᨲᩮᩣ ᨧ ᨠᩩᨱᩣᩃᩮᩣ ᨧ, ᩅᩩᨲ᩠ᨲᩣ ᨾᨶ᩠ᨴᩣᨠᩥᨶᩦ’ᨲ᩠ᨳᩥᨿᩴ.

ᨲᨳᩣ ᩈᩦᩉᨸ᩠ᨸᨸᩣᨲᩮᩣᨲᩥ, ᩑᨲᩮ ᩈᨲ᩠ᨲ ᨾᩉᩣᩈᩁᩣ;

ᩌᩉᩣᩅᩮᩣ ᨲᩩ ᨶᩥᨸᩣᨶᨬ᩠ᨧᩣ, ᨡᩣᨲᩴ ᨲᩩ ᨴᩮᩅᨡᩣᨲᨠᩴ.

ᩈᩅᨶ᩠ᨲᩦ ¶ ᨶᩥᨶ᩠ᨶᨣᩣ ᩈᩥᨶ᩠ᨵᩩ, ᩈᩁᩥᨲᩣ ᩌᨸᨣᩣ ᨶᨴᩦ;

ᨽᩣᨣᩦᩁᨳᩦ ᨲᩩ ᨣᨦ᩠ᨣᩣ ᨳ, ᩈᨾ᩠ᨽᩮᨴᩮᩣ ᩈᩥᨶ᩠ᨵᩩᩈᨦ᩠ᨣᨾᩮᩣ.

ᨣᨦ᩠ᨣᩣ’ᨧᩥᩁᩅᨲᩦ ᨧᩮᩅ, ᨿᨾᩩᨶᩣ ᩈᩁᨽᩪ (ᩈᩁᨻᩪ [ᩈᩁᨿᩪ (ᨠ.)] ) ᨾᩉᩦ;

ᩍᨾᩣ ᨾᩉᩣᨶᨴᩦ ᨸᨬ᩠ᨧ, ᨧᨶ᩠ᨴᨽᩣᨣᩣ ᩈᩁᩔᨲᩦ [ᩈᩁᩈ᩠ᩅᨲᩦ (ᩈᩦ. ᨭᩦ.)].

ᨶᩮᩁᨬ᩠ᨩᩁᩣ ᨧ ᨠᩣᩅᩮᩁᩦ, ᨶᨾ᩠ᨾᨴᩣᨴᩦ ᨧ ᨶᩥᨶ᩠ᨶᨣᩣ;

ᩅᩣᩁᩥᨾᨣ᩠ᨣᩮᩣ ᨸᨱᩣᩃᩦ’ᨲ᩠ᨳᩦ [ᨸᨶᩣᩊᩦ (ᨭᩦ.)], ᨸᩩᨾᩮ ᨧᨶ᩠ᨴᨶᩥᨠᩣ ᨲᩩ ᨧ.

ᨩᨾ᩠ᨻᩣᩃᩦ ᩒᩃᩥᨣᩃ᩠ᩃᩮᩣ ᨧ, ᨣᩣᨾᨴ᩠ᩅᩣᩁᨾ᩠ᩉᩥ ᨠᩣᩈᩩᨿᩴ;

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

ᩋᨶᩥᨲ᩠ᨳᩦ ᨸᨴᩩᨾᩴ ᨸᨦ᩠ᨠᩮ, ᩁᩩᩉᩴ ᨶᩃᩥᨶ ᨸᩮᩣᨠ᩠ᨡᩁᩴ;

ᨾᩩᩊᩣᩃᨸᩩᨸ᩠ᨹᩴ ᨠᨾᩃᩴ, ᨽᩥᩈᨸᩩᨸ᩠ᨹᩴ ᨠᩩᩈᩮᩈᨿᩴ.

ᨸᩩᨱ᩠ᨯᩁᩦᨠᩴ ᩈᩥᨲᩴ, ᩁᨲ᩠ᨲᩴ, ᨠᩮᩣᨠᨶᨴᩴ ᨠᩮᩣᨠᩣᩈᨠᩮᩣ;

ᨠᩥᨬ᩠ᨩᨠ᩠ᨡᩮᩣ ᨠᩮᩈᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨴᨱ᩠ᨯᩮᩣ ᨲᩩ ᨶᩣᩃ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᨽᩥᩈᩴ ᨾᩩᩊᩣᩃᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨧ, ᨻᩦᨩᨠᩮᩣᩈᩮᩣ ᨲᩩ ᨠᨱ᩠ᨱᩥᨠᩣ;

ᨸᨴᩩᨾᩣᨴᩥᩈᨾᩪᩉᩮ ᨲᩩ, ᨽᩅᩮ ᩈᨱ᩠ᨯᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.

ᩏᨸ᩠ᨸᩃᩴ ᨠᩩᩅᩃᨿᨬ᩠ᨧ, ᨶᩦᩃᩴ ᨲ᩠ᩅᩥ’ᨶ᩠ᨴᩦᩅᩁᩴ ᩈᩥᨿᩣ;

ᩈᩮᨲᩮᨲᩩ ᨠᩩᨾᩩᨴᨬ᩠ᨧᩔ, ᨠᨶ᩠ᨴᩮᩣ ᩈᩣᩃᩪᨠ ᨾᩩᨧ᩠ᨧᨲᩮ.

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

ᩈᩮᩅᩣᩃᩮᩣ ᨶᩦᩃᩥᨠᩣ ᨧᩣᨳ, ᨽᩥᩈᩥᨶ᩠ᨿ’ᨾ᩠ᨻᩩᨩᩥᨶᩦ ᨽᩅᩮ.

᪖᪙᪐. ᩈᩮᩅᩣᩃᩣ ᨲᩥᩃᨻᩦᨩᨬ᩠ᨧ, ᩈᨦ᩠ᨡᩮ ᨧ ᨸᨱᨠᩣᨴᨿᩮᩣᨲᩥ.

ᩅᩥᩈᩮᩈ᩠ᨿᩣᨵᩦᨶ ᩈᩴᨠᩥᨱ᩠ᨱᩣ, ᨶᩮᨠᨲ᩠ᨳᩮᩉ᩠ᨿ’ᨻ᩠ᨿᨿᩮᩉᩥ ᨧ;

ᩈᩣ’ᨦ᩠ᨣᩮᩣ’ᨸᩣᨦ᩠ᨣᩮᩉᩥ ᨠᨳ᩠ᨿᨶ᩠ᨲᩮ, ᨠᨱ᩠ᨯᩮ ᩅᨣ᩠ᨣᩣ ᩍᩉ ᨠ᩠ᨠᨾᩣ.

ᨣᩩᨱᨴᨻ᩠ᨻᨠᩕᩥᨿᩣᩈᨴ᩠ᨴᩣ, ¶ ᩈᩥᨿᩩᩴ ᩈᨻ᩠ᨻᩮ ᩅᩥᩈᩮᩈᨶᩣ;

ᩅᩥᩈᩮᩈ᩠ᨿᩣᨵᩦᨶᨽᩣᩅᩮᨶ, ᩅᩥᩈᩮᩈ᩠ᨿᩈᨾᩃᩥᨦ᩠ᨣᩥᨶᩮᩣ.

ᩈᩮᩣᨽᨶᩴ ᩁᩩᨧᩥᩁᩴ ᩈᩣᨵᩩ, ᨾᨶᩩᨬ᩠ᨬᩴ ᨧᩣᩁᩩ ᩈᩩᨶ᩠ᨴᩁᩴ;

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

ᨽᨴ᩠ᨴᩴ ᩅᩣᨾᨬ᩠ᨧ ᨠᩃ᩠ᨿᩣᨱᩴ, ᨾᨶᩣᨸᩴ ᩃᨴ᩠ᨵᨠᩴ ᩈᩩᨽᩴ;

ᩏᨲ᩠ᨲᨾᩮᩣ ᨸᩅᩁᩮᩣ ᨩᩮᨭ᩠ᨮᩮᩣ, ᨸᨾᩩᨡᩣ’ᨶᩩᨲ᩠ᨲᩁᩮᩣ ᩅᩁᩮᩣ.

ᨾᩩᨡ᩠ᨿᩮᩣ ᨸᨵᩣᨶᩴ ᨸᩣᨾᩮᩣᨠ᩠ᨡᩮᩣ, ᨸᩁ ᨾᨣ᩠ᨣᨬ᩠ᨬ ᨾᩩᨲ᩠ᨲᩁᩴ;

ᨸᨱᩦᨲᩴ ᨸᩁᨾᩴ ᩈᩮᨿ᩠ᨿᩮᩣ, ᨣᩣᨾᨱᩦ ᩈᩮᨭ᩠ᨮ ᩈᨲ᩠ᨲᨾᩣ.

ᩅᩥᩈᩥᨭ᩠ᨮᩣ’ᩁᩥᨿ ᨶᩣᨣᩮ’ᨠᩮᩣ, ᩈᨽᨣ᩠ᨣᩣ ᨾᩮᩣᨠ᩠ᨡ ᨸᩩᨦ᩠ᨣᩅᩣ;

ᩈᩦᩉ ᨠᩩᨬ᩠ᨩᩁ ᩈᨴ᩠ᨴᩪᩃᩣ, ᨴᩦ ᨲᩩ ᩈᨾᩣᩈᨣᩣ ᨸᩩᨾᩮ.

ᨧᩥᨲ᩠ᨲ’ᨠ᩠ᨡᩥ ᨸᩦᨲᩥᨩᨶᨶ, ᨾᨻ᩠ᨿᩣᩈᩮᨠ ᨾᩈᩮᨧᨶᩴ;

ᩍᨭ᩠ᨮᩴ ᨲᩩ ᩈᩩᨽᨣᩴ ᩉᨩ᩠ᨩᩴ, ᨴᨿᩥᨲᩴ ᩅᩃ᩠ᩃᨽᩴ ᨸᩥᨿᩴ.

ᨲᩩᨧ᩠ᨨᨬ᩠ᨧ ᩁᩥᨲ᩠ᨲᨠᩴ ᩈᩩᨬ᩠ᨬᩴ, ᩋᨳᩣ’ᩈᩣᩁᨬ᩠ᨧ ᨹᩮᨣ᩠ᨣᩩ ᨧ;

ᨾᩮᨩ᩠ᨫᩴ ᨸᩪᨲᩴ ᨸᩅᩥᨲ᩠ᨲᩮᩣ ᨳ, ᩋᩅᩥᩁᨴ᩠ᨵᩮᩣ ᩋᨸᨱ᩠ᨱᨠᩮᩣ.

ᩏᨠ᩠ᨠᨭ᩠ᨮᩮᩣ ᨧ ᨸᨠᨭ᩠ᨮᩮᩣ ᨳ, ᨶᩥᩉᩦᨶᩮᩣ ᩉᩦᨶ ᩃᩣᨾᨠᩣ;

ᨸᨲᩥᨠᩥᨭ᩠ᨮᩴ ᨶᩥᨠᩥᨭ᩠ᨮᨬ᩠ᨧ, ᩍᨲ᩠ᨲᩁᩣ’ᩅᨩ᩠ᨩ ᨠᩩᨧ᩠ᨨᩥᨲᩣ.

ᨻᩕᩉᩣ ᨾᩉᨶ᩠ᨲᩴ ᩅᩥᨸᩩᩃᩴ, ᩅᩥᩈᩣᩃᩴ ᨸᩩᨳᩩᩃᩴ ᨸᩩᨳᩩ.

ᨣᩁᩩ’ᩁᩩ ᩅᩥᨲ᩠ᨳᩥᨱ᩠ᨱ ᨾᨳᩮᩣ, ᨸᩦᨶᩴ ᨳᩪᩃᨬ᩠ᨧ ᨸᩦᩅᩁᩴ;

ᨳᩩᩃ᩠ᩃᨬ᩠ᨧ ᩅᨮᩁᨬ᩠ᨧᩣ ᨳ, ᩌᨧᩥᨲᩴ ᨶᩥᨧᩥᨲᩴ ᨽᩅᩮ.

ᩈᨻ᩠ᨻᩴ ᩈᨾᨲ᩠ᨲ ᨾᨡᩥᩃᩴ, ᨶᩥᨡᩥᩃᩴ ᩈᨠᩃᩴ ᨲᨳᩣ;

ᨶᩥᩔᩮᩈᩴ ᨠᩈᩥᨱᩣ’ᩈᩮᩈᩴ, ᩈᨾᨣ᩠ᨣᨬ᩠ᨧ ᩋᨶᩪᨶᨠᩴ,

ᨽᩪᩁᩥ ᨸᩉᩩᨲᩴ ᨸᨧᩩᩁᩴ, ᨽᩥᨿ᩠ᨿᩮᩣ ᩈᨾ᩠ᨻᩉᩩᩃᩴ ᨻᩉᩩ;

ᨿᩮᨽᩩᨿ᩠ᨿᩴ ᨻᩉᩩᩃᩴ ᨧᩣᨳ, ᨻᩣᩉᩥᩁᩴ ᨸᩁᩥᨻᩣᩉᩥᩁᩴ.

ᨸᩁᩮᩣᩈᨲᩣᨴᩦ ᨲᩮ, ᨿᩮᩈᩴ, ᨸᩁᩴ ᨾᨲ᩠ᨲᩴ ᩈᨲᩣᨴᩥᨲᩮᩣ;

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

ᩈᨾᩦᨸᩴ ᨶᩥᨠᨭᩣ’ᩈᨶ᩠ᨶᩮᩣ, ᨸᨠᨭ᩠ᨮᩣ’ᨽ᩠ᨿᩣᩈ ᩈᨶ᩠ᨲᩥᨠᩴ.

ᩋᩅᩥᨴᩪᩁᨬ᩠ᨧ ¶ ᩈᩣᨾᨶ᩠ᨲᩴ, ᩈᨶ᩠ᨶᩥᨠᨭ᩠ᨮ ᨾᩩᨸᨶ᩠ᨲᩥᨠᩴ;

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

ᨶᩥᩁᨶ᩠ᨲᩁᩴ ᨥᨶᩴ ᩈᨶ᩠ᨴᩴ, ᩅᩥᩁᩊᩴ ᨸᩮᩃᩅᩴ ᨲᨶᩩ;

ᩋᨳᩣ ᨿᨲᩴ ᨴᩦᨥ ᨾᨳᩮᩣ, ᨶᩥᨲ᩠ᨲᩃᩴ ᩅᨭ᩠ᨭ ᩅᨭ᩠ᨭᩩᩃᩴ.

ᩏᨧ᩠ᨧᩮᩣ ᨲᩩ ᩏᨶ᩠ᨶᨲᩮᩣ ᨲᩩᨦ᩠ᨣᩮᩣ, ᩏᨴᨣ᩠ᨣᩮᩣ ᨧᩮᩅ ᩏᨧ᩠ᨨᩥᨲᩮᩣ;

ᨶᩦᨧᩮᩣ ᩁᩔᩮᩣ ᩅᩣᨾᨶᩮᩣ ᨳ, ᩋᨩᩥᨾ᩠ᩉᩮᩣ ᨸᨣᩩᨱᩮᩣ ᩏᨩᩩ.

ᩋᩊᩣᩁᩴ ᩅᩮᩃ᩠ᩃᩥᨲᩴ ᩅᨦ᩠ᨠᩴ, ᨠᩩᨭᩥᩃᩴ ᨩᩥᨾ᩠ᩉ ᨠᩩᨬ᩠ᨧᩥᨲᩴ;

ᨵᩩᩅᩮᩣ ᨧ ᩈᩔᨲᩮᩣ ᨶᩥᨧ᩠ᨧᩮᩣ, ᩈᨴᩣᨲᨶ ᩈᨶᨶ᩠ᨲᨶᩣ.

ᨠᩪᨭᨭ᩠ᨮᩮᩣ ᨲ᩠ᩅᩮ’ᨠᩁᩪᨸᩮᨶ, ᨠᩣᩃᨻ᩠ᨿᩣᨸᩦ ᨸᨠᩣᩈᩥᨲᩮᩣ;

ᩃᩉᩩ ᩈᩃ᩠ᩃᩉᩩᨠᩴ ᨧᩣᨳ, ᩈᨦ᩠ᨡ᩠ᨿᩣᨲᩴ ᨣᨱᩥᨲᩴ ᨾᩥᨲᩴ.

ᨲᩥᨱ᩠ᩉᩴ ᨲᩩ ᨲᩥᨡᩥᨱᩴ ᨲᩥᨻ᩠ᨻᩴ, ᨧᨱ᩠ᨯᩴ ᩏᨣ᩠ᨣᩴ ᨡᩁᩴ ᨽᩅᩮ;

ᨩᨦ᩠ᨣᨾᨬ᩠ᨧ ᨧᩁᨬ᩠ᨧᩮᩅ, ᨲᩈᩴ ᨬᩮᨿ᩠ᨿᩴ ᨧᩁᩣᨧᩁᩴ.

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

ᨳᩣᩅᩁᩮᩣ ᨩᨦ᩠ᨣᨾᩣ ᩋᨬ᩠ᨬᩮᩣ, ᩃᩮᩣᩃᩴ ᨲᩩ ᨧᨬ᩠ᨧᩃᩴ ᨧᩃᩴ.

ᨲᩁᩃᨬ᩠ᨧ ᨸᩩᩁᩣᨱᩮᩣ ᨲᩩ, ᨸᩩᩁᩣᨲᨶ ᩈᨶᨶ᩠ᨲᨶᩣ;

ᨧᩥᩁᨶ᩠ᨲᨶᩮᩣ ᨳ ᨸᨧ᩠ᨧᨣ᩠ᨥᩮᩣ, ᨶᩪᨲᨶᩮᩣ’ᨽᩥᨶᩅᩮᩣ ᨶᩅᩮᩣ.

ᨠᩩᩁᩪᩁᩴ ᨠᨮᩥᨶᩴ ᨴᩊ᩠ᩉᩴ, ᨶᩥᨭ᩠ᨮᩩᩁᩴ ᨠᨠ᩠ᨡᩊᩴ ᨽᩅᩮ;

ᩋᨶᩥᨲ᩠ᨳ᩠ᨿ’ᨶ᩠ᨲᩮᩣ ᨸᩁᩥᨿᨶ᩠ᨲᩮᩣ, ᨸᨶ᩠ᨲᩮᩣ ᨧ ᨸᨧ᩠ᨨᩥᨾ’ᨶ᩠ᨲᩥᨾᩣ.

ᨩᩥᨥᨬ᩠ᨬᩴ ᨧᩁᩥᨾᩴ ᨸᩩᨻ᩠ᨻᩴ, ᨲ᩠ᩅ’ᨣ᩠ᨣᩴ ᨸᨮᨾ ᨾᩣᨴᩥ ᩈᩮᩣ;

ᨸᨲᩥᩁᩪᨸᩮᩣ ᨶᩩᨧ᩠ᨨᩅᩥᨠᩴ, ᩋᨳ ᨾᩮᩣᨥᩴ ᨶᩥᩁᨲ᩠ᨳᨠᩴ.

ᨻ᩠ᨿᨲ᩠ᨲᩴ ᨸᩩᨭ [ᨹᩩᨭᩴ (ᩈᩦ.)] ᨬ᩠ᨧ ᨾᩩᨴᩩ ᨲᩩ, ᩈᩩᨠᩩᨾᩣᩁᨬ᩠ᨧ ᨠᩮᩣᨾᩃᩴ;

ᨸᨧ᩠ᨧᨠ᩠ᨡᩴ ᩍᨶ᩠ᨴᩕᩥᨿᨣ᩠ᨣᨿ᩠ᩉᩴ, ᩋᨸᨧ᩠ᨧᨠ᩠ᨡᩴ ᩋᨲᩥᨶ᩠ᨴᩕᩥᨿᩴ.

ᩍᨲᩁᩣ’ᨬ᩠ᨬᨲᩁᩮᩣ ᩑᨠᩮᩣ, ᩋᨬ᩠ᨬᩮᩣ ᨻᩉᩩᩅᩥᨵᩮᩣ ᨲᩩ ᨧ;

ᨶᩣᨶᩣᩁᩪᨸᩮᩣ ᨧ ᩅᩥᩅᩥᨵᩮᩣ, ᩋᨻᩣᨵᩴ ᨲᩩ ᨶᩥᩁᨣ᩠ᨣᩃᩴ.

ᩋᨳᩮ’ᨠᩣᨠᩦ ᨧ ᩑᨠᨧ᩠ᨧᩮᩣ, ᩑᨠᩮᩣ ᨧ ᩑᨠᨠᩮᩣ ᩈᨾᩣ;

ᩈᩣᨵᩣᩁᨱᨬ᩠ᨧ ᩈᩣᨾᨬ᩠ᨬᩴ, ᩈᨾ᩠ᨻᩣᨵᩮᩣ ᨲᩩ ᨧ ᩈᩴᨠᨭᩴ.

ᩅᩣᨾᩴ ᨠᩊᩮᩅᩁᩴ ᩈᨻ᩠ᨿᩴ; ᩋᨸᩈᨻ᩠ᨿᩴ ᨲᩩ ᨴᨠ᩠ᨡᩥᨱᩴ;

ᨸᨭᩥᨠᩪᩃᩴ ᨲ᩠ᩅ’ᨸᩈᨻ᩠ᨿᩴ, ᨣᩉᨶᩴ ᨠᩃᩥᩃᩴ ᩈᨾᩣ.

ᩏᨧ᩠ᨧᩣᩅᨧᩴ ¶ ᨻᩉᩩᨽᩮᨴᩴ, ᩈᩴᨠᩥᨱ᩠ᨱᩣ’ ᨠᩥᨱ᩠ᨱ ᩈᩴᨠᩩᩃᩣ;

ᨠᨲᩉᨲ᩠ᨳᩮᩣ ᨧ ᨠᩩᩈᩃᩮᩣ, ᨸᩅᩦᨱᩣ’ᨽᩥᨬ᩠ᨬ ᩈᩥᨠ᩠ᨡᩥᨲᩣ.

ᨶᩥᨸᩩᨱᩮᩣ ᨧ ᨸᨭᩩ ᨨᩮᨠᩮᩣ, ᨧᩣᨲᩩᩁᩮᩣ ᨴᨠ᩠ᨡ ᨸᩮᩈᩃᩣ;

ᨻᩣᩃᩮᩣ ᨴᨲ᩠ᨲᩩ ᨩᩃᩮᩣ ᨾᩪᩊ᩠ᩉᩮᩣ, ᨾᨶ᩠ᨴᩮᩣ ᩅᩥᨬ᩠ᨬᩪ ᨧ ᨻᩣᩃᩥᩈᩮᩣ.

ᨸᩩᨬ᩠ᨬᩅᩣ ᩈᩩᨠᨲᩦ ᨵᨬ᩠ᨬᩮᩣ, ᨾᩉᩩᩔᩣᩉᩮᩣ ᨾᩉᩣᨵᩥᨲᩥ;

ᨾᩉᩣᨲᨱ᩠ᩉᩮᩣ ᨾᩉᩥᨧ᩠ᨨᩮᩣ ᨳ, ᩉᨴᨿᩦ ᩉᨴᨿᩣᩃᩩ ᨧ.

ᩈᩩᨾᨶᩮᩣ ᩉᨭ᩠ᨮᨧᩥᨲ᩠ᨲᩮᩣ ᨳ, ᨴᩩᨾ᩠ᨾᨶᩮᩣ ᩅᩥᨾᨶᩮᩣ ᨸ᩠ᨿᨳ;

ᩅᨴᩣᨶᩥᨿᩮᩣ ᩅᨴᨬ᩠ᨬᩪ ᨧ, ᨴᩣᨶᩈᩮᩣᨱ᩠ᨯᩮᩣ ᨻᩉᩩᨸ᩠ᨸᨴᩮᩣ.

ᩅᩥᩔᩩᨲᩮᩣ ᩅᩥᨴᩥᨲᩮᩣ ᨧᩮᩅ, ᨸᩈᩥᨴ᩠ᨵᩮᩣ ᨸᩣᨠᨭᩮᩣ ᨽᩅᩮ.

ᩍᩔᩁᩮᩣ ᨶᩣᨿᨠᩮᩣ ᩈᩣᨾᩦ, ᨸᨲᩦ’ᩈᩣ’ᨵᩥᨸᨲᩦ ᨸᨽᩪ;

ᨴᩣᨶᩣᩁᩉᩮᩣ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩮᩣ, ᩈᩥᨶᩥᨴ᩠ᨵᩮᩣ ᨲᩩ ᨧ ᩅᨧ᩠ᨨᩃᩮᩣ;

ᨠᩣᩁᩩᨱᩥᨠᩮᩣ ᨴᨿᩣᩃᩩᨸᩥ, ᩈᩪᩁᨲᩮᩣ ᩏᩔᩩᨠᩮᩣ ᨲᩩ ᨧ;

ᩍᨭ᩠ᨮᨲ᩠ᨳᩮ ᩏᨿ᩠ᨿᩩᨲᩮᩣ ᨧᩣᨳ, ᨴᩦᨥᩈᩩᨲ᩠ᨲᩮᩣ ᨧᩥᩁᨠᩕᩥᨿᩮᩣ.

ᨸᩁᩣᨵᩦᨶᩮᩣ ᨸᩁᩣᨿᨲ᩠ᨲᩮᩣ, ᩌᨿᨲ᩠ᨲᩮᩣ ᨲᩩ ᨧ ᩈᨶ᩠ᨲᨠᩮᩣ;

ᨸᩁᩥᨣ᩠ᨣᩉᩮᩣ ᩋᨵᩦᨶᩮᩣ ᨧ, ᩈᨧ᩠ᨨᨶ᩠ᨴᩮᩣ ᨲᩩ ᨧ ᩈᩮᩁᩥᨶᩥ.

ᩋᨶᩥᩈᨾ᩠ᨾᨠᩣᩁᩦ ᨩᨾ᩠ᨾᩮᩣ, ᩋᨲᩥᨲᨱ᩠ᩉᩮᩣ ᨲᩩ ᩃᩮᩣᩃᩩᨸᩮᩣ;

ᨠᩣᨾᨿᩥᨲᩣ ᨲᩩ ᨠᨾᩥᨲᩣ, ᨠᩣᨾᨶᩮᩣ ᨠᩣᨾᩥ ᨠᩣᨾᩩᨠᩮᩣ;

ᨸᨣᨻ᩠ᨽᩮᩣ ¶ ᨸᨭᩥᨽᩣᨿᩩᨲ᩠ᨲᩮᩣ, ᨽᩦᩈᩦᩃᩮᩣ ᨽᩦᩁᩩ ᨽᩦᩁᩩᨠᩮᩣ;

ᨠᩮᩣᨵᨶᩮᩣ ᩁᩮᩣᩈᨶᩮᩣ [ᨴᩮᩣᩈᨶᩮᩣ (ᩈᩦ.)] ᨠᩮᩣᨸᩦ,

ᩈᩉᨶᩮᩣ ᨡᨾᨶᩮᩣ ᨡᨶ᩠ᨲᩣ, ᨲᩥᨲᩥᨠ᩠ᨡᩅᩣ ᨧ ᨡᨶ᩠ᨲᩥᨾᩣ.

ᩈᨴ᩠ᨵᩣᨿᩩᨲ᩠ᨲᩮᩣ ᨲᩩ ᩈᨴ᩠ᨵᩣᩃᩩ, ᨵᨩᩅᩣ ᨲᩩ ᨵᨩᩣᩃᩩ ᨧ [ᩃᨩ᩠ᨩᩣᩃᩩᨲᩩ ᨧ ᩃᨩ᩠ᨩᩅᩣ (ᨠ.)];

ᨶᩥᨴ᩠ᨴᩣᩃᩩ ᨶᩥᨴ᩠ᨴᩣᩈᩦᩃᩮᩣ ᨳ, ᨽᩔᩁᩮᩣ ᨽᩣᩈᩩᩁᩮᩣ ᨽᩅᩮ.

ᨶᨣ᩠ᨣᩮᩣ ᨴᩥᨣᨾ᩠ᨻᩁᩮᩣ’ᩅᨲ᩠ᨳᩮᩣ, ᨥᩈ᩠ᨾᩁᩮᩣ ᨲᩩ ᨧ ᨽᨠ᩠ᨡᨠᩮᩣ;

ᩑᩊᨾᩪᨣᩮᩣ ᨲᩩ ᩅᨲ᩠ᨲᩩᨬ᩠ᨧ, ᩈᩮᩣᨲᩩᩴ ᨧᩣ’ᨠᩩᩈᩃᩮᩣ ᨽᩅᩮ.

ᨾᩩᨡᩁᩮᩣ ᨴᩩᨾ᩠ᨾᩩᨡᩣ’ᨻᨴ᩠ᨵ, ᨾᩩᨡᩣ ᨧᩣᨸ᩠ᨸᩥᨿᩅᩣᨴᩥᨶᩥ;

ᩅᩣᨧᩣᩃᩮᩣ ᨻᩉᩩᨣᩣᩁᨿ᩠ᩉ, ᩅᨧᩮ ᩅᨲ᩠ᨲᩣ ᨲᩩ ᩈᩮᩣ ᩅᨴᩮᩣ.

ᩈᩦᩈᨧ᩠ᨨᩮᨩ᩠ᨩᨾ᩠ᩉᩥ ᩅᨩ᩠ᨫᩮᩣ ᨳ, ᨶᩥᨠᨲᩮᩣ ᨧ ᩈᨮᩮᩣ’ᨶᩩᨩᩩ;

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

ᩋᩅᩥᨶᩥᨧ᩠ᨨᩥᨲᨠᩣᩁᩥᨲ᩠ᨲᩣ, ᩈᩮᩣᨡᩃᩩ ᨧᨸᩃᩮᩣᨲᩥ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩮᩣ.

ᨡᩩᨴ᩠ᨴᩮᩣ ᨠᨴᩁᩥᨿᩮᩣ ᨳᨴ᩠ᨵ, ᨾᨧ᩠ᨨᩁᩦ ᨠᨸᨱᩮᩣ ᨸ᩠ᨿᨳ;

ᩋᨠᩥᨬ᩠ᨧᨶᩮᩣ ᨴᩃᩥᨴ᩠ᨴᩮᩣ ᨧ, ᨴᩦᨶᩮᩣ ᨶᩥᨴ᩠ᨵᨶ ᨴᩩᨣ᩠ᨣᨲᩣ.

ᩋᩈᨾ᩠ᨽᩣᩅᩥᨲᩈᨾ᩠ᨸᨲ᩠ᨲᩴ, ᨠᩣᨠᨲᩣᩃᩥᨿ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᩋᨳ ᨿᩣᨧᨶᨠᩮᩣ ᩋᨲ᩠ᨳᩦ, ᨿᩣᨧᨠᩮᩣ ᨧ ᩅᨶᩥᨻ᩠ᨻᨠᩮᩣ.

ᩋᨱ᩠ᨯᨩᩣ ᨸᨠ᩠ᨡᩥᩈᨸ᩠ᨸᩣᨴᩦ, ᨶᩁᩣᨴᩦ ᨲᩩ ᨩᩃᩣᨻᩩᨩᩣ;

ᩈᩮᨴᨩᩣ ᨠᩥᨾᩥᨯᩴᩈᩣᨴᩦ, ᨴᩮᩅᩣᨴᩦ ᨲ᩠ᩅᩮᩣ’ ᨸᨸᩣᨲᩥᨠᩣ.

ᨩᨱ᩠ᨱᩩᨲᨣ᩠ᨥᩮᩣ ¶ ᨩᨱ᩠ᨱᩩᨾᨲ᩠ᨲᩮᩣ, ᨠᨸ᩠ᨸᩮᩣ ᨲᩩ ᨠᩥᨬ᩠ᨧᩥᨴᩪᨶᨠᩮ;

ᩋᨶ᩠ᨲᨣ᩠ᨣᨲᩴ ᨽᩩ ᨸᩁᩥᨿᩣ, ᨸᨶ᩠ᨶ ᨾᨶ᩠ᨲᩮᩣᨣᨵᩮᩣ’ᨣᨵᩣ.

ᩁᩣᨵᩥᨲᩮᩣ ᩈᩣᨵᩥᨲᩮᩣ ᨧᩣᨳ, ᨶᩥᨸ᩠ᨸᨠ᩠ᨠᩴ ᨠᩩᨳᩥᨲᩴ ᨽᩅᩮ;

ᩌᨸᨶ᩠ᨶᩮᩣ ᨲ᩠ᩅᩣ’ᨸᨴᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᩅᩥᩅᩈᩮᩣ ᨲ᩠ᩅᩅᩈᩮᩣ ᨽᩅᩮ.

ᨶᩩᨱ᩠ᨱᩮᩣ ᨶᩩᨲ᩠ᨲᩣ’ᨲ᩠ᨲ, ᨡᩥᨲ᩠ᨲᩣ ᨧᩮ’, ᩁᩥᨲᩣ ᩅᩥᨴ᩠ᨵᩣ ᨳ ᨠᨾ᩠ᨸᩥᨲᩮᩣ;

ᨵᩪᨲᩮᩣ ᩌᨵᩪᨲ ᨧᩃᩥᨲᩣ, ᨶᩥᩈᩥᨲᩴ ᨲᩩ ᨧ ᨲᩮᨩᩥᨲᩴ.

ᨸᨲ᩠ᨲᨻ᩠ᨻᩴ ᨣᨾ᩠ᨾ ᨾᩣᨸᨩ᩠ᨩᩴ [ᩌᩈᨩ᩠ᨩᩴ (ᨠ.)], ᨸᨠ᩠ᨠᩴ ᨸᩁᩥᨱᨲᩴ ᩈᨾᩣ;

ᩅᩮᨮᩥᨲᩴ ᨲᩩ ᩅᩃᨿᩥᨲᩴ, ᩁᩩᨴ᩠ᨵᩴ ᩈᩴᩅᩩᨲ ᨾᩣᩅᩩᨲᩴ.

ᨸᩁᩥᨠ᩠ᨡᩥᨲ᩠ᨲᨬ᩠ᨧ ᨶᩥᩅᩩᨲᩴ, ᩅᩥᩈᨭᩴ ᩅᩥᨲ᩠ᨳᨲᩴ ᨲᨲᩴ;

ᩃᩥᨲ᩠ᨲᩮᩣ ᨲᩩ ᨴᩥᨴ᩠ᨵᩮᩣ ᨣᩪᩊ᩠ᩉᩮᩣ ᨲᩩ,

ᩃᨩ᩠ᨩᩥᨲᩮᩣ ᩉᩦᩊᩥᨲᩮᩣ ᨧᩣᨳ, ᩈᨶᩥᨲᩴ ᨵᨶᩥᨲᩴ ᨸ᩠ᨿᨳ;

ᩈᩥᨴ᩠ᨵᩮ ᨶᩥᨸ᩠ᨹᨶ᩠ᨶ ᨶᩥᨻ᩠ᨻᨲ᩠ᨲᩣ, ᨴᩣᩁᩥᨲᩮ ᨽᩥᨶ᩠ᨶ ᨽᩮᨴᩥᨲᩣ;

ᨨᨶ᩠ᨶᩮᩣ ᨲᩩ ᨨᩣᨴᩥᨲᩮ ᨧᩣᨳ, ᩅᩥᨴ᩠ᨵᩮ ᨨᩥᨴ᩠ᨴᩥᨲ ᩅᩮᨵᩥᨲᩣ.

ᩋᨸᨧᩣᨿᩥᨲᩮᩣ ᨾᩉᩥᨲᩮᩣ, ᨸᩪᨩᩥᨲᩣ’ᩁᩉᩥᨲᩮᩣ’ᨧ᩠ᨧᩥᨲᩮᩣ;

ᨾᩣᨶᩥᨲᩮᩣ ᨧᩣ’ᨸᨧᩥᨲᩮᩣ ᨧ, ᨲᨧ᩠ᨨᩥᨲᩴ ᨲᩩᨲᨶᩪᨠᨲᩮ.

ᨽᨭ᩠ᨮᩴ ᨲᩩ ᨣᩃᩥᨲᩴ ᨸᨶ᩠ᨶᩴ, ᨧᩩᨲᨬ᩠ᨧ ᨵᩴᩈᩥᨲᩴ ᨽᩅᩮ.

ᨲᩥᨶ᩠ᨲᩮᩣ’ᩃ᩠ᩃ’ᨴ᩠ᨴ ¶ ᨠᩥᩃᩥᨶ᩠ᨶᩮᩣ’ᨶ᩠ᨶᩣ, ᨾᨣ᩠ᨣᩥᨲᩴ ᨸᩁᩥᨿᩮᩈᩥᨲᩴ;

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

ᩁᨠ᩠ᨡᩥᨲᩴ ᨣᩮᩣᨸᩥᨲᩴ ᨣᩩᨲ᩠ᨲᩴ, ᨲᩣᨲᩴ ᨣᩮᩣᨸᩣᨿᩥᨲᩣ’ᩅᩥᨲᩣ;

ᨸᩣᩃᩥᨲᩴ ᩋᨳ ᩒᩔᨭ᩠ᨮᩴ, ᨧᨲ᩠ᨲᩴ ᩉᩦᨶᩴ ᩈᨾᩩᨩ᩠ᨫᩥᨲᩴ.

ᨽᩣᩈᩥᨲᩴ ᩃᨸᩥᨲᩴ ᩅᩩᨲ᩠ᨲᩣ, ᨽᩥᩉᩥᨲᩣ’ᨡ᩠ᨿᩣᨲ ᨩᨸ᩠ᨸᩥᨲᩣ;

ᩏᨴᩦᩁᩥᨲᨬ᩠ᨧ ᨠᨳᩥᨲᩴ, ᨣᨴᩥᨲᩴ ᨽᨱᩥᨲᩮᩣ’ᨴᩥᨲᩣ.

ᩋᩅᨬ᩠ᨬᩣᨲᩣ’ᩅᨣᨱᩥᨲᩣ, ᨸᩁᩥᨽᩪᨲᩣ’ᩅᨾᩣᨶᩥᨲᩣ;

ᨻᩩᨴ᩠ᨵᩴ ᨬᩣᨲᩴ ᨸᨭᩥᨸᨶ᩠ᨶᩴ, ᩅᩥᨴᩥᨲᩣ’ᩅᨣᨲᩴ ᨾᨲᩴ;

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

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

ᩋᨳᩮᩣ ᩌᩈᨦ᩠ᨣᩅᨧᨶᩴ, ᨲᩦᩈᩩ ᩅᩩᨲ᩠ᨲᩴ ᨸᩁᩣᨿᨱᩴ.

ᨽᩮᨴᩮᩣ ᩅᩥᨴᩣᩁᩮᩣ ᨹᩩᨭᨶᩴ, ᨲᨸ᩠ᨸᨶᩴ ᨲᩩ ᨧ ᨸᩦᨱᨶᩴ;

ᨶᩥᨶ᩠ᨶᩥᨾᩥᨲ᩠ᨲᩴ ᨿᨴᩥᨧ᩠ᨨᩣ ᨳᩣ’, ᨸᩩᨧ᩠ᨨᨶᩣ ᨶᨶ᩠ᨴᨶᩣᨶᩥ ᨧ;

ᨠᩥᩃᨾᨳᩮᩣ ᨠᩥᩃᨾᨶᩴ, ᨸᩈᩅᩮᩣ ᨲᩩ ᨸᩈᩪᨲᩥᨿᩴ;

ᨸᨧᩣ ᨸᩣᨠᩮᩣ ᩉᩅᩮᩣ ᩉᩩᨲᩥ [ᩉᩪᨽᩥ (ᩈᩦ. ᩋᨾᩁᨠᩮᩣᩈ)],

ᨩᩦᩁᨱᩴ ᨩᩣᨶᩥ ᨲᩣᨱᩴ ᨲᩩ, ᩁᨠ᩠ᨡᨱᩴ ᨸᨾᩥᨲᩥᨸ᩠ᨸᨾᩣ;

ᨶᩥᨣᩣᨴᩮᩣ ᨶᩥᨣᨴᩮᩣ ᨾᩣᨴᩮᩣ, ᨾᨴᩮᩣ ᨸᩈᩥᨲᩥ ᨻᨶ᩠ᨵᨶᩴ;

ᨸᩅᩥᩈᩥᩃᩮᩈᩮᩣ ᩅᩥᨵᩩᩁᩴ, ᩏᨸᩅᩮᩈᨶᨾᩣᩈᨶᩴ.

ᩋᨩ᩠ᨫᩣᩈᨿᩮᩣ ᩋᨵᩥᨸ᩠ᨸᩣᨿᩮᩣ, ᩌᩈᨿᩮᩣ ᨧᩣᨽᩥᩈᨶ᩠ᨵᩥ ᨧ;

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

ᩅᩣ ᨩᩣᨣᩁᩮᩣ ᨩᩣᨣᩁᩥᨿᩴ [ᨩᩣᨣᩁᩥᨿᩮᩣ (ᨭᩦ.)], ᨸᩅᩣᩉᩮᩣ ᨲᩩ ᨸᩅᨲ᩠ᨲᩥ ᨧ;

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

ᩈᨶ᩠ᨶᩥᨵᩥ ᩈᨶ᩠ᨶᩥᨠᨭ᩠ᨮᨾ᩠ᩉᩥ, ᩅᩥᨶᩣᩈᩮᩣ ᨲᩩ ᩋᨴᩔᨶᩴ;

ᩒᩈᩣᨶᩴ ¶ ᨸᩁᩥᨿᩮᩣᩈᩣᨶᩴ, ᩏᨠ᩠ᨠᩴᩈᩮᩣ’ᨲᩥᩈᨿᩮᩣ ᨽᩅᩮ [ᩋᩅᩈᩣᨶᩴ ᩈᨾᩣᨸᨶᩴ (?)];

ᩈᨶ᩠ᨶᩥᩅᩮᩈᩮᩣ ᨧ ᩈᨱ᩠ᨮᩣᨶᩴ, ᩋᨳᩣ’ᨻ᩠ᨽᨶ᩠ᨲᩁ ᨾᨶ᩠ᨲᩁᩴ.

ᨸᩣᨭᩥᩉᩦᩁᩴ ᨸᩣᨭᩥᩉᩮᩁᩴ, ᨸᩣᨭᩥᩉᩣᩁᩥᨿ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᨠᩥᨧ᩠ᨧᩴ ᨲᩩ ᨠᩁᨱᩦᨿᨬ᩠ᨧ, ᩈᨦ᩠ᨡᩣᩁᩮᩣ ᩅᩣᩈᨶᩣ ᨽᩅᩮ.

ᨸᩅᨶᩴ ᨸᩅ ᨶᩥᨸ᩠ᨸᩣᩅᩣ, ᨲᩈᩁᩮᩣ ᩈᩩᨲ᩠ᨲᩅᩮᨮᨶᩴ;

ᩈᨦ᩠ᨠᨾᩮᩣ ᨴᩩᨣ᩠ᨣᩈᨬ᩠ᨧᩣᩁᩮᩣ, ᨸᨠ᩠ᨠᨾᩮᩣ ᨲᩩ ᩏᨸᨠ᩠ᨠᨾᩮᩣ.

ᨸᩣᨮᩮᩣ ᨶᩥᨸᩣᨮᩮᩣ ᨶᩥᨸᨮᩮᩣ, ᩅᩥᨧᨿᩮᩣ ᨾᨣ᩠ᨣᨶᩣ ᨸᩩᨾᩮ;

ᩌᩃᩥᨦ᩠ᨣᨶᩴ ᨸᩁᩥᩔᨦ᩠ᨣᩮᩣ, ᩈᩥᩃᩮᩈᩮᩣ ᩏᨸᨣᩪᩉᨶᩴ.

ᩌᩃᩮᩣᨠᨶᨬ᩠ᨧ ᨶᩥᨩ᩠ᨫᩣᨶᩴ, ᩍᨠ᩠ᨡᨱᩴ ᨴᩔᨶᩴ ᨸ᩠ᨿᨳ;

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

ᩅᩥᨸᩃ᩠ᩃᩣᩈᩮᩣ’ᨬ᩠ᨬᨳᩣᨽᩣᩅᩮᩣ, ᨻ᩠ᨿᨲ᩠ᨲᨿᩮᩣ ᩅᩥᨸᩁᩦᨿᨿᩮᩣ;

ᩅᩥᨸᩁᩥᨿᩣᩈᩮᩣ’ᨲᩥᨠ᩠ᨠᨾᩮᩣ, ᨲ᩠ᩅ’ᨲᩥᨸᩣᨲᩮᩣ ᩏᨸᨧ᩠ᨧᨿᩮᩣ.

ᩋᨶᩮᨠᨲ᩠ᨳᩮ ᨸᩅᨠ᩠ᨡᩣᨾᩥ, ᨣᩣᨳᩣ’ᨴ᩠ᨵᨸᩣᨴᨲᩮᩣ ᨠᨾᩣ;

ᩑᨲ᩠ᨳ ᩃᩥᨦ᩠ᨣᩅᩥᩈᩮᩈᨲ᩠ᨳ, ᨾᩮᨠᩔ ᨸᩩᨶᩁᩩᨲ᩠ᨲᨲᩣ.

ᩈᨾᨿᩮᩣ ᩈᨾᩅᩣᨿᩮ ᨧ, ᩈᨾᩪᩉᩮ ᨠᩣᩁᨱᩮ ᨡᨱᩮ;

ᨸᨭᩥᩅᩮᨵᩮ ᩈᩥᨿᩣ ᨠᩣᩃᩮ, ᨸᩉᩣᨶᩮ ᩃᩣᨽ ᨴᩥᨭ᩠ᨮᩥᩈᩩ.

ᩅᨱ᩠ᨱᩮᩣ ᩈᨱ᩠ᨮᩣᨶ ᩁᩪᨸᩮᩈᩩ, ᨩᩣᨲᩥ,ᨧ᩠ᨨᩅᩦᩈᩩ ᨠᩣᩁᨱᩮ;

ᨸᨾᩣᨱᩮ ᨧ ᨸᩈᩴᩈᩣᨿᩴ, ᩋᨠ᩠ᨡᩁᩮ ᨧ ᨿᩈᩮ ᨣᩩᨱᩮ.

ᩏᨴ᩠ᨴᩮᩈᩮ ᨸᩣᨲᩥᨾᩮᩣᨠ᩠ᨡᩔ, ᨸᨱ᩠ᨱᨲ᩠ᨲᩥᨿ ᨾᩩᨸᩮᩣᩈᨳᩮᩣ;

ᩏᨸᩅᩣᩈᩮ ᨧ ᩋᨭ᩠ᨮᨦ᩠ᨣᩮ, ᩏᨸᩮᩣᩈᨳᨴᩥᨶᩮ ᩈᩥᨿᩣ.

ᩁᨳᨦ᩠ᨣᩮ ᩃᨠ᩠ᨡᨱᩮ ᨵᨾ᩠ᨾᩮᩣ, ᩁᨧᨠ᩠ᨠᩮ’ᩈ᩠ᩅᩦᩁᩥᨿᩣᨸᨳᩮ;

ᨧᨠ᩠ᨠᩴ ᩈᨾ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᨧᨠ᩠ᨠ, ᩁᨲᨶᩮ ᨾᨱ᩠ᨯᩃᩮ ᨻᩃᩮ.

ᨠᩩᩃᩣᩃᨽᨱ᩠ᨯᩮ ᩌᨱᩣᨿ, ᨾᩣᨿᩩᨵᩮ ᨴᩣᨶ ᩁᩣᩈᩥᩈᩩ;

ᨴᩣᨶᩈ᩠ᨾᩥᩴ ¶ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿ, ᨾᨸ᩠ᨸᨾᨬ᩠ᨬᩣᩈᩩ ᩈᩣᩈᨶᩮ;

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

ᨸᨬ᩠ᨧᩈᩦᩃᩣ’ᩁᩥᨿᨾᨣ᩠ᨣᩮᩣ, ᨸᩮᩣᩈᨳᨦ᩠ᨣ ᨵᩥᨲᩦᩈᩩ [ᨮᩥᨲᩦᩈᩩ (ᨠ.)] ᨧ.

ᩋᨲ᩠ᨳᩮᩣ ᨸᨿᩮᩣᨩᨶᩮ ᩈᨴ᩠ᨴᩣ, ᨽᩥᨵᩮᨿ᩠ᨿᩮ ᩅᩩᨴ᩠ᨵᩥᨿᩴ ᨵᨶᩮ;

ᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩥ ᨠᩣᩁᨱᩮ ᨶᩣᩈᩮ, ᩉᩥᨲᩮ ᨸᨧ᩠ᨨᩥᨾᨸᨻ᩠ᨻᨲᩮ.

ᨿᩮᨽᩩᨿ᩠ᨿᨲᩣ’ᨻ᩠ᨿᩣᨾᩥᩔᩮᩈᩩ, ᩅᩥᩈᩴᨿᩮᩣᨣᩮ ᨧ ᨠᩮᩅᩃᩴ;

ᨴᩊ᩠ᩉᨲ᩠ᨳᩮ’ᨶᨲᩥᩁᩮᨠᩮ ᨧᩣ, ᨶᩅᩈᩮᩈᨾ᩠ᩉᩥ ᨲᩴ ᨲᩥᩈᩩ.

ᨣᩩᨱᩮᩣ ᨸᨭᩃ ᩁᩣᩈᩦᩈᩩ, ᩌᨶᩥᩈᩴᩈᩮ ᨧ ᨻᨶ᩠ᨵᨶᩮ;

ᩋᨸ᩠ᨸᨵᩣᨶᩮ ᨧ ᩈᩦᩃᩣᨴᩮᩣ, ᩈᩩᨠ᩠ᨠᩣᨴᩥᨾ᩠ᩉᩥ ᨩᩥᨿᩣᨿ ᨧ.

ᩁᩩᨠ᩠ᨡᩣᨴᩮᩣ ᩅᩥᨩ᩠ᨩᨾᩣᨶᩮ ᨧᩣ, ᩁᩉᨶ᩠ᨲᩮ ᨡᨶ᩠ᨵᨸᨬ᩠ᨧᨠᩮ;

ᨽᩪᨲᩮᩣ ᩈᨲ᩠ᨲ ᨾᩉᩣᨽᩪᨲᩣ, ᨾᨶᩩᩔᩮᩈᩩ ᨶ ᨶᩣᩁᩥᨿᩴ.

ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩮᩣ ᩋᨲᩦᨲᩈ᩠ᨾᩥᩴ, ᨩᩣᨲᩮ ᨸᨲ᩠ᨲᩮ ᩈᨾᩮ ᨾᨲᩮᩣ;

ᩈᩩᨶ᩠ᨴᩁᩮ ᨴᩊ᩠ᩉᩥᨠᨾ᩠ᨾᩮ ᨧᩣ, ᨿᩣᨧᨶᩮ ᩈᨾ᩠ᨸᨭᩥᨧ᩠ᨨᨶᩮ;

ᩈᨩ᩠ᨩᨶᩮ ᩈᨾ᩠ᨸᩉᩴᩈᩣᨿᩴ, ᩈᩣᨵ᩠ᩅᩣ’ᨽᩥᨵᩮᨿ᩠ᨿᩃᩥᨦ᩠ᨣᩥᨠᩴ.

ᩋᨶ᩠ᨲᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᨾᩦᨸᩮ ᨧᩣ, ᩅᩈᩣᨶᩮ ᨸᨴᨸᩪᩁᨱᩮ;

ᨴᩮᩉᩣᩅᨿᩅᩮ ᨠᩮᩣᨭ᩠ᨮᩣᩈᩮ, ᨶᩣᩈ ᩈᩦᨾᩣᩈᩩ ᩃᩣᨾᨠᩮ.

ᨶᩥᨠᩣᨿᩮ ᩈᨶ᩠ᨵᩥ ᩈᩣᨾᨬ᩠ᨬ, ᨸ᩠ᨸᩈᩪᨲᩦᩈᩩ ᨠᩩᩃᩮ ᨽᩅᩮ;

ᩅᩥᩈᩮᩈᩮ ᩈᩩᨾᨶᩣᨿᨬ᩠ᨧ, ᨩᩣᨲᩥ ᩈᨦ᩠ᨡᨲᩃᨠ᩠ᨡᨱᩮ.

ᨽᩅᨽᩮᨴᩮ ᨸᨲᩥᨭ᩠ᨮᩣᨿᩴ, ᨶᩥᨭ᩠ᨮᩣ’ᨩ᩠ᨫᩣᩈᨿᨻᩩᨴ᩠ᨵᩥᩈᩩ;

ᩅᩣᩈᨭ᩠ᨮᩣᨶᩮ ᨧ ᨣᨾᨶᩮ, ᩅᩥᩈᨭᨲ᩠ᨲᩮ [ᩅᩥᩈᩁᨲ᩠ᨲ ᩅᩥᩈᨴᨲ᩠ᨲᩮ] ᨣᨲᩦᩁᩥᨲᩣ.

ᨹᩃᩮ ᩅᩥᨸᩔᨶᩣ ᨴᩥᨻ᩠ᨻ, ᨧᨠ᩠ᨡᩩ ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩣᩈᩩ ᨧ;

ᨸᨧ᩠ᨧᩅᩮᨠ᩠ᨡᨱᨬᩣᨱᨾ᩠ᩉᩥ, ᨾᨣ᩠ᨣᩮ ᨧ ᨬᩣᨱᨴᩔᨶᩴ.

ᨠᨾ᩠ᨾᩣᩁᩩᨴ᩠ᨵᨶ ᩋᨦ᩠ᨣᩣᩁ, ᨠᨸᩃ᩠ᩃ ᨴᩦᨸᩥᨠᩣᩈᩩ ᨧ;

ᩈᩩᩅᨱ᩠ᨱᨠᩣᩁᨾᩪᩈᩣᨿᩴ, ᩏᨠ᩠ᨠᩣ ᩅᩮᨣᩮ ᨧ ᩅᩣᨿᩩᨶᩮᩣ.

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

ᨠᨳᨶᩮ ᨸᨾᩩᨲ᩠ᨲᨽᩣᩅ, ᨩ᩠ᨫᩮᨶᩣᨴᩮᩣ [ᨩ᩠ᨫᩮᩈᨶᩣᨴᩮᩣ (ᩈᩦ.)] ᩅᩩᨲ᩠ᨲ ᨾᨸᩥ ᨲᩦᩈᩩ.

ᨣᨾᨶᩮ ᩅᩥᩔᩩᨲᩮ ᨧᩣ’ᩅ, ᨵᩣᩁᩥᨲᩮᩣ’ᨸᨧᩥᨲᩮᩈᩩ ᨧ;

ᩋᨶᩩᨿᩮᩣᨣᩮ ᨠᩥᩃᩥᨶ᩠ᨶᩮ ᨧ, ᩈᩩᨲᩮᩣ’ ᨽᩥᨵᩮᨿ᩠ᨿᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.

ᩈᩮᩣᨲᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿ ᩈᨲ᩠ᨳᩮᩈᩩ, ᩈᩩᨲᩴ ᨸᩩᨲ᩠ᨲᩮ ᩈᩩᨲᩮᩣ ᩈᩥᨿᩣ;

ᨠᨸ᩠ᨸᩮᩣ ᨠᩣᩃᩮ ᨿᩩᨣᩮ ᩃᩮᩈᩮ, ᨸᨬ᩠ᨬᨲ᩠ᨲᩥ ᨸᩁᨾᩣᨿᩩᩈᩩ;

ᩈᨴᩥᩈᩮ ᨲᩦᩈᩩ ᩈᨾᨱ, ᩅᩮᩣᩉᩣᩁ ᨠᨸ᩠ᨸᨻᩥᨶ᩠ᨴᩩᩈᩩ;

ᩈᨾᨶ᩠ᨲᨲ᩠ᨳᩮ’ᨶ᩠ᨲᩁᨠᨸ᩠ᨸᩣ, ᨴᩥᨠᩮ ᨲᨠ᩠ᨠᩮ ᩅᩥᨵᩥᨾ᩠ᩉᩥ ᨧ.

ᨶᩥᨻ᩠ᨻᩣᨶ ᨾᨣ᩠ᨣ ᩅᩥᩁᨲᩥ, ᩈᨸᨳᩮ ᩈᨧ᩠ᨧᨽᩣᩈᩥᨲᩮ;

ᨲᨧ᩠ᨨᩮ ᨧᩣ’ᩁᩥᨿᩈᨧ᩠ᨧᨾ᩠ᩉᩥ, ᨴᩥᨭ᩠ᨮᩥᨿᩴ ᩈᨧ᩠ᨧ ᨾᩦᩁᩥᨲᩴ.

ᩈᨬ᩠ᨩᩣᨲᩥᨴᩮᩈᩮ ᩉᩮᨲᩩᨾ᩠ᩉᩥ, ᩅᩣᩈᨭ᩠ᨮᩣᨶᩣ’ᨠᩁᩮᩈᩩ ᨧ;

ᩈᨾᩮᩣᩈᩁᨱᨭ᩠ᨮᩣᨶᩮ ᨧᩣ, ᨿᨲᨶᩴ ᨸᨴᨸᩪᩁᨱᩮ.

ᩋᨶ᩠ᨲᩁᩴ ᨾᨩ᩠ᨫ ᩅᨲ᩠ᨳ’ᨬ᩠ᨬ, ᨡᨱᩮᩣ’ᨠᩣᩈᩮᩣ’ᨵᩥ ᩉᩮᨲᩩᩈᩩ;

ᨻ᩠ᨿᩅᨵᩣᨶᩮ ᩅᩥᨶᨭ᩠ᨮᩮ ᨧ, ᨽᩮᨴᩮ ᨨᩥᨴ᩠ᨴᩮ ᨾᨶᩈ᩠ᨿ’ᨸᩥ.

ᩌᩁᩮᩣᨣ᩠ᨿᩮ ᨠᩩᩈᩃᩴ ᩍᨭ᩠ᨮ, ᩅᩥᨸᩣᨠᩮ ᨠᩩᩈᩃᩮᩣ ᨲᨳᩣ;

ᩋᨶᩅᨩ᩠ᨩᨾ᩠ᩉᩥ ᨨᩮᨠᩮ ᨧ, ᨠᨳᩥᨲᩮᩣ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.

ᨴᩕᩅᩣ’ᨧᩣᩁᩮᩈᩩ ᩅᩦᩁᩥᨿᩮ, ᨾᨵᩩᩁᩣᨴᩦᩈᩩ ᨸᩣᩁᨴᩮ;

ᩈᩥᨦ᩠ᨣᩣᩁᩣᨴᩮᩣ ᨵᩣᨲᩩᨽᩮᨴᩮ, ᨠᩥᨧ᩠ᨧᩮ ᩈᨾ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᩁᩈᩮᩣ.

ᨻᩮᩣᨵᩥ ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᨬ᩠ᨬᩣᨱᩮ, ᩁᩥᨿᨾᨣ᩠ᨣᩮ ᨧ ᨶᩣᩁᩥᨿᩴ;

ᨸᨬ᩠ᨬᨲ᩠ᨲᩥᨿᩴ ᨸᩩᨾᩮ’ ᩔᨲ᩠ᨳ, ᩁᩩᨠ᩠ᨡᨾ᩠ᩉᩥ ᨸᩩᩁᩥᩈᩥᨲ᩠ᨳᩥᨿᩴ.

ᩈᩮᩅᩥᨲᩮᩣ ᨿᩮᨶ ᨿᩮᩣ ᨶᩥᨧ᩠ᨧᩴ, ᨲᨲ᩠ᨳᩣᨸᩥ ᩅᩥᩈᨿᩮᩣ ᩈᩥᨿᩣ;

ᩁᩪᨸᩣᨴᩥᨠᩮ ᨩᨶᨸᨴᩮ, ᨲᨳᩣ ᨴᩮᩈᩮ ᨧ ᨣᩮᩣᨧᩁᩮ.

ᨽᩣᩅᩮᩣ ᨸᨴᨲ᩠ᨳᩮ ᩈᨲ᩠ᨲᩣᨿ, ᨾᨵᩥᨸ᩠ᨸᩣᨿ ᨠᩕᩥᨿᩣᩈᩩ ᨧ;

ᩈᨽᩣᩅᩈ᩠ᨾᩥᨬ᩠ᨧ ᩃᩦᩃᩣᨿᩴ, ᨸᩩᩁᩥᩈᩥ’ᨲ᩠ᨳᩥᨶ᩠ᨴᩕᩥᨿᩮᩈᩩ ᨧ.

ᩈᩮᩣ ᨻᨶ᩠ᨵᩅᩮ’ᨲ᩠ᨲᨶᩥ ᨧ ᩈᩴ, ᩈᩮᩣ ᨵᨶᩈ᩠ᨾᩥ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ;

ᩈᩣ ᨸᩩᨾᩮ ᩈᩩᨶᨡᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨲ᩠ᨲᨶᩥᨿᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.

ᩈᩩᩅᨱ᩠ᨱᩴ ᨠᨶᨠᩮ ᩅᩩᨲ᩠ᨲᩴ, ᩈᩩᩅᨱ᩠ᨱᩮᩣ ᨣᩁᩩᩊᩮ ᨲᨳᩣ;

ᨸᨬ᩠ᨧᨵᩁᨱᨾᨲ᩠ᨲᩮ ᨧ, ᨨᩅᩥ ᩈᨾ᩠ᨸᨲ᩠ᨲᩥᨿᨾ᩠ᨸᩥ ᨧ.

ᩅᩁᩮᩣ ¶ ᨴᩮᩅᩣᨴᩥᨠᩣ [ᨴᩮᩅᩣᨴᩥᨲᩮᩣ (ᩈᩦ.)] ᩍᨭ᩠ᨮᩮ, ᨩᩣᨾᩣᨲᩁᩥ ᨸᨲᩥᨾ᩠ᩉᩥ ᨧ,

ᩏᨲ᩠ᨲᨾᩮ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩮᩣ ᩈᩮᩣ, ᩅᩁᩴ ᨾᨶ᩠ᨴᨸ᩠ᨸᩥᨿᩮ ᨻ᩠ᨿᨿᩴ.

ᨾᨠᩩᩃᩮ ᨵᨶᩁᩣᩈᩥᨾ᩠ᩉᩥ, ᩈᩥᨿᩣ ᨠᩮᩣᩈ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ;

ᨶᩮᨲ᩠ᨲᩥᩴᩈᩣᨴᩥ ᨸᩥᨵᩣᨶᩮ ᨧ, ᨵᨶᩩᨸᨬ᩠ᨧᩈᨲᩮᨸᩥ ᨧ.

ᨸᩥᨲᩣᨾᩉᩮ ᨩᩥᨶᩮ ᩈᩮᨭ᩠ᨮᩮ, ᨻᩕᩣᩉ᩠ᨾᨱᩮ ᨧ ᨸᩥᨲᩪᩈ᩠ᩅᨸᩥ;

ᨻᩕᩉ᩠ᨾᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᨲᨳᩣ ᨻᩕᩉ᩠ᨾᩴ, ᩅᩮᨴᩮ ᨲᨸᩈᩥ ᩅᩩᨧ᩠ᨧᨲᩮ.

ᩉᨲ᩠ᨳᩦᨶᩴ ᨾᨩ᩠ᨫᨻᨶ᩠ᨵᩮ ᨧ, ᨸᨠᩮᩣᨭ᩠ᨮᩮ ᨠᨧ᩠ᨨᨻᨶ᩠ᨵᨶᩮ;

ᨾᩮᨡᩃᩣᨿᩴ ᨾᨲᩣ ᨠᨧ᩠ᨨᩣ, ᨠᨧ᩠ᨨᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᩃᨲᩣᨿ ᨧ.

ᨲᨳᩮᩅ ᨻᩣᩉᩩᨾᩪᩃᨾ᩠ᩉᩥ, ᩋᨶᩪᨸᨾ᩠ᩉᩥ ᨲᩥᨱᩮᨸᩥ ᨧ;

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

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

ᩈᨲ᩠ᨲᩴ ᨴᨻ᩠ᨻ’ᨲ᩠ᨲᨽᩣᩅᩮᩈᩩ, ᨸᩣᨱᩮᩈᩩ ᨧ ᨻᩃᩮ, ᩈᩥᨿᩣ [ᨻᩃᩮ ᩈᨠ᩠ᨠᩣ (ᨭᩦ.)];

ᩈᨲ᩠ᨲᩣᨿᨬ᩠ᨧ, ᨩᨶᩮᩈᨲ᩠ᨲᩮᩣ, ᩌᩈᨲ᩠ᨲᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.

ᩈᩮᨾ᩠ᩉᩣᨴᩮᩣ ᩁᩈᩁᨲ᩠ᨲᩣᨴᩮᩣ, ᨾᩉᩣᨽᩪᨲᩮ ᨸᨽᩣᨴᩥᨠᩮ;

ᨵᩣᨲᩩ ᨴ᩠ᩅᩦᩈ᩠ᩅ’ᨭ᩠ᨮᩥᨧᨠ᩠ᨡᩣ’ᨴᩥ, ᨽ᩠ᩅᩣ’ᨴᩦᩈᩩ ᨣᩮᩁᩥᨠᩣᨴᩥᩈᩩ.

ᩋᨾᨧ᩠ᨧᩣᨴᩮᩣ ᩈᨽᩣᩅᩮ ᨧ, ᨿᩮᩣᨶᩥᨿᩴ ᨸᨠᨲᩦ’ᩁᩥᨲᩣ;

ᩈᨲ᩠ᩅᩣᨴᩥᩈᩣᨾ᩠ᨿᩣ’ᩅᨲ᩠ᨳᩣᨿᩴ, ᨸᨧ᩠ᨧᨿᩣ ᨸᨮᨾᩮᨸᩥ ᨧ.

ᨸᨴᩴ ᨮᩣᨶᩮ ᨸᩁᩥᨲ᩠ᨲᩣᨱᩮ, ᨶᩥᨻ᩠ᨻᩣᨶᨾ᩠ᩉᩥ ᨧ ᨠᩣᩁᨱᩮ;

ᩈᨴ᩠ᨴᩮ ᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩥ ᨠᩮᩣᨭ᩠ᨮᩣᩈᩮ, ᨸᩣᨴᩮ ᨲᩃ᩠ᩃᨬ᩠ᨨᨶᩮ ᨾᨲᩴ.

ᩃᩮᩣᩉᨾᩩᨣ᩠ᨣᩁ ᨾᩮᨥᩮᩈᩩ, ᨥᨶᩮᩣ, ᨲᩣᩃᩣᨴᩥᨠᩮ ᨥᨶᩴ,;

ᨶᩥᩁᨶ᩠ᨲᩁᩮ ᨧ ᨠᨮᩥᨶᩮ, ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᨡᩩᨴ᩠ᨴᩣ ᨧ ᨾᨠ᩠ᨡᩥᨠᩣᨽᩮᨴᩮ, ᨾᨵᩩᨾ᩠ᩉᩥ ᨡᩩᨴ᩠ᨴ, ᨾᨸ᩠ᨸᨠᩮ;

ᩋᨵᨾᩮ ᨠᨸᨱᩮ ᨧᩣᨸᩥ, ᨻᩉᩩᨾ᩠ᩉᩥ ᨧᨲᩪᩈᩩ ᨲ᩠ᨲᩥᩈᩩ.

ᨲᨠ᩠ᨠᩮ ᨾᩁᨱᩃᩥᨦ᩠ᨣᩮ ᨧ, ᩋᩁᩥᨭ᩠ᨮᩴ ᩋᩈᩩᨽᩮ ᩈᩩᨽᩮ,;

ᩋᩁᩥᨭ᩠ᨮᩮᩣ ᩌᩈᩅᩮ ᨠᩣᨠᩮ, ᨶᩥᨾ᩠ᨻᩮ ᨧ ᨹᩮᨶᩥᩃᨴ᩠ᨴᩩᨾᩮ.

ᨾᩣᨶᨽᨱ᩠ᨯᩮ ᨸᩃᩈᨲᩮ, ᩈᨴᩥᩈᨲ᩠ᨲᩮ ᨲᩩᩃᩣ ᨲᨳᩣ;

ᨣᩮᩉᩣᨶᩴ ᨴᩣᩁᩩᨻᨶ᩠ᨵᨲ᩠ᨳ, ᨸᩦᨮᩥᨠᩣᨿᨬ᩠ᨧ ᨴᩥᩔᨲᩥ.

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

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

ᨡᨶ᩠ᨵᩮ ᨽᩅᩮ ᨶᩥᨾᩥᨲ᩠ᨲᨾ᩠ᩉᩥ, ᩁᩪᨸᩴ ᩅᨱ᩠ᨱᩮ ᨧ ᨸᨧ᩠ᨧᨿᩮ;

ᩈᨽᩣᩅ ᩈᨴ᩠ᨴ ᩈᨱ᩠ᨮᩣᨶ, ᩁᩪᨸᨩ᩠ᨫᩣᨶ ᩅᨸᩪᩈᩩ ᨧ.

ᩅᨲ᩠ᨳᩩ ᨠᩥᩃᩮᩈ ᨠᩣᨾᩮᩈᩩ, ᩍᨧ᩠ᨨᩣᨿᩴ ᨾᨴᨶᩮ ᩁᨲᩮ;

ᨠᩣᨾᩮᩣ, ᨠᩣᨾᩴ ᨶᩥᨠᩣᨾᩮ, ᨧᩣ, ᨶᩩᨬ᩠ᨬᩣᨿᩴ ᨠᩣᨾ ᨾᨻ᩠ᨿᨿᩴ.

ᨸᩮᩣᨠ᩠ᨡᩁᩴ ᨸᨴᩩᨾᩮ ᨴᩮᩉᩮ, ᩅᨩ᩠ᨩᨽᨱ᩠ᨯᨾᩩᨡᩮᨸᩥ ᨧ;

ᩈᩩᨶ᩠ᨴᩁᨲ᩠ᨲᩮ ᨧ ᩈᩃᩥᩃᩮ, ᨾᩣᨲᨦ᩠ᨣᨠᩁᨠᩮᩣᨭᩥᨿᩴ.

ᩁᩣᩈᩥᨶᩥᨧ᩠ᨧᩃ ᨾᩣᨿᩣᩈᩩ, ᨴᨾ᩠ᨽᩣ’ᩈᨧ᩠ᨧᩮᩈ᩠ᩅ’ᨿᩮᩣᨥᨶᩮ;

ᨣᩥᩁᩥᩈᩥᨦ᩠ᨣᨾ᩠ᩉᩥ ᩈᩦᩁᨦ᩠ᨣᩮ, ᨿᨶ᩠ᨲᩮ ᨠᩪᨭ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.

ᩅᩩᨴ᩠ᨵᩥᨿᩴ ᨩᨶᨶᩮ ᨠᩣᨾ, ᨵᩣᨲ᩠ᩅᩣᨴᩦᨾ᩠ᩉᩥ ᨧ ᨸᨲ᩠ᨲᩥᨿᩴ;

ᩈᨲ᩠ᨲᩣᨿᨬ᩠ᨧᩮᩅ ᩈᩴᩈᩣᩁᩮ, ᨽᩅᩮᩣ ᩈᩔᨲᨴᩥᨭ᩠ᨮᩥᨿᩴ.

ᨸᨭᩥᩅᩣᨠ᩠ᨿᩮᩣ’ᨲ᩠ᨲᩁᩣᩈᨦ᩠ᨣᩮ, ᩈᩩ’ᨲ᩠ᨲᩁᩴ ᩏᨲ᩠ᨲᩁᩮᩣ ᨲᩥᩈᩩ;

ᩈᩮᨭ᩠ᨮᩮ ᨴᩥᩈᩣᨴᩥᨽᩮᨴᩮ ᨧ, ᨸᩁᩈ᩠ᨾᩥ ᨾᩩᨸᩁᩦ’ᩁᩥᨲᩮᩣ.

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

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

ᩈᨦ᩠ᨡᩣᩁᩮᩣ ᩈᨦ᩠ᨡᨲᩮ ᨸᩩᨬ᩠ᨬᩣ, ᨽᩥᩈᨦ᩠ᨡᩣᩁᩣᨴᩥᨠᩮᨸᩥ ᨧ;

ᨸᨿᩮᩣᨣᩮ ᨠᩣᨿᩈᨦ᩠ᨡᩣᩁᩣ, ᨴ᩠ᨿ’ᨽᩥᩈᨦ᩠ᨡᩁᨱᩮᩈᩩ ᨧ.

ᩌᩁᨾ᩠ᨾᨱᩮ ᨧ ᩈᩴᩈᨭ᩠ᨮᩮ, ᩅᩮᩣᨠᩥᨱ᩠ᨱᩮ ᨶᩥᩔᨿᩮ ᨲᨳᩣ;

ᨲᨻ᩠ᨽᩣᩅᩮ ᨧᩣᨸ᩠ᨿᨽᩥᨵᩮᨿ᩠ᨿ, ᩃᩥᨦ᩠ᨣᩮᩣ ᩈᩉᨣᨲᩮᩣ ᨽᩅᩮ.

ᨲᩦᩈᩩ ᨨᨶ᩠ᨶᩴ ᨸᨲᩥᩁᩪᨸᩮ, ᨨᩣᨴᩥᨲᩮ ᨧ ᨶᩥᨣᩪᩉᩥᨲᩮ;

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

ᨻᩩᨴ᩠ᨵᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩪᩈᩩ, ᨧᨠ᩠ᨡᩩ ᨸᨬ᩠ᨬᩣᨿ ᨾᩦᩁᩥᨲᩴ;

ᨵᨾ᩠ᨾᨧᨠ᩠ᨡᩩᨾ᩠ᩉᩥ ᨧ ᨾᩴᩈ, ᨴᩥᨻ᩠ᨻᨧᨠ᩠ᨡᩩᨴ᩠ᩅᨿᩮᩈᩩ ᨧ.

ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩮᩣ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᩈᩩᨶ᩠ᨴᩁᨾ᩠ᩉᩥ ᩋᨽᩥᨠ᩠ᨠᨾᩮ;

ᩋᨽᩥᩁᩪᨸᩮ ᨡᨿᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨲᨳᩮᩅ’ᨻ᩠ᨽᨶᩩᨾᩮᩣᨴᨶᩮ.

ᨠᩣᩁᨱᩮ ᨴᩮᩈᨶᩣᨿᨬ᩠ᨧ, ᩅᩣᩁᩮ ᩅᩮᩅᨧᨶᩮᨸᩥ ᨧ;

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

ᩅᩥᨬ᩠ᨬᩣᨱᩮ ¶ ᨧᩥᨲ᩠ᨲᨠᨾ᩠ᨾᩮ ᨧ, ᩅᩥᨧᩥᨲ᩠ᨲᩮ ᨧᩥᨲ᩠ᨲ ᨾᩩᨧ᩠ᨧᨲᩮ;

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

ᩈᩣᨾᩴ ᩅᩮᨴᨶ᩠ᨲᩁᩮ ᩈᩣᨶ᩠ᨲ᩠ᩅᩮ, ᨲᩴ ᨸᩦᨲᩮ ᩈᩣᨾᩃᩮ ᨲᩥᩈᩩ;

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

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

ᨣᩁᩩ ᨲᩦᩈᩩ ᨾᩉᨶ᩠ᨲᩮ ᨧ, ᨴᩩᨩ᩠ᨩᩁᩣ’ᩃᩉᩩᨠᩮᩈᩩ ᨧ.

ᩋᨧ᩠ᨧᩥᨲᩮ ᩅᩥᨩ᩠ᨩᨾᩣᨶᩮ ᨧ, ᨸᩈᨲ᩠ᨳᩮ ᩈᨧ᩠ᨧ ᩈᩣᨵᩩᩈᩩ;

ᨡᩥᨶ᩠ᨶᩮ ᨧ ᩈᨾᩥᨲᩮ ᨧᩮᩅ, ᩈᨶ᩠ᨲᩮᩣᨽᩥᨵᩮᨿ᩠ᨿᩃᩥᨦ᩠ᨣᩥᨠᩮᩣᨲᩥ.

ᨴᩮᩅᩮᩣ ᩅᩥᩈᩩᨴ᩠ᨵᩥᨴᩮᩅᩣ’ᨴᩮᩣ, ᨾᩮᨥ ᨾᨧ᩠ᨧᩩ ᨶᨽᩮᩈᩩ ᨧ;

ᩋᨳᩮᩣᨸᩥ ᨲᩁᩩᨱᩮ ᩈᨲ᩠ᨲᩮ, ᨧᩮᩣᩁᩮᨸᩥ ᨾᩣᨱᩅᩮᩣ ᨽᩅᩮ.

ᩌᨴᩥ ᨠᩮᩣᨭ᩠ᨮᩣᩈ ᨠᩮᩣᨭᩦᩈᩩ, ᨸᩩᩁᨲᩮᩣ’ᨣ᩠ᨣᩴᩅᩁᩮ ᨲᩦᩈᩩ;

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

ᨿᩮᩣᨶᩥ ᨠᩣᨾ ᩈᩥᩁᩥ’ᩔᩁᩮ, ᨵᨾ᩠ᨾᩩ’ᨿ᩠ᨿᩣᨾ ᨿᩈᩮ ᨽᨣᩴ;

ᩏᩊᩣᩁᩮᩣ ᨲᩦᩈᩩ ᩅᩥᨸᩩᩃᩮ, ᩈᩮᨭ᩠ᨮᩮ ᨧ ᨾᨵᩩᩁᩮ ᩈᩥᨿᩣ.

ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ ᨲᩦᩈᩩ ᩈᨾ᩠ᨸᩩᨱ᩠ᨱᩮ, ᨾᨵᩩᩁᩮ ᨧ ᩈᨾᨦ᩠ᨣᩥᨶᩥ;

ᩈᨦ᩠ᨡᩣ ᨲᩩ ᨬᩣᨱᩮ ᨠᩮᩣᨭ᩠ᨮᩣᩈ, ᨸᨬ᩠ᨬᨲ᩠ᨲᩥ ᨣᨱᨶᩮᩈᩩ ᨧ.

ᨮᩣᨶᩴ ᩍᩔᩁᩥᨿᩮᩣ’ᨠᩣᩈ, ᩉᩮᨲᩪᩈᩩ ᨮᩥᨲᩥᨿᨾ᩠ᨸᩥ ᨧ;

ᩋᨳᩮᩣ ᨾᩣᨶᩮ ᨸᨠᩣᩁᩮᨧ, ᨠᩮᩣᨭ᩠ᨮᩣᩈᩮᨧ ᩅᩥᨵᩮᩣ ᨴ᩠ᩅᩥᩈᩩ.

ᨸᨬ᩠ᨬᩮᩣ’ᨸᩅᩣᩈ ᨡᨶ᩠ᨲᩦᩈᩩ, ᨴᨾᩮᩣ ᩍᨶ᩠ᨴᩕᩥᨿᩈᩴᩅᩁᩮ;

ᨬᩣᨱᩮ ᨧ ᩈᩮᩣᨾᨶᩔᩮᨧ, ᩅᩮᨴᩮᩣ ᨨᨶ᩠ᨴᩈᩥ ᨧᩮᩣ’ᨧ᩠ᨧᨲᩮ.

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

ᨠᩣᩃᩮ ᨲᩩ ᨠᩪᩃᩮ ᩈᩦᨾᩣᨿᩴ, ᩅᩮᩃᩣ ᩁᩣᩈᩥᨾ᩠ᩉᩥ ᨽᩣᩈᩥᨲᩣ.

ᩅᩮᩣᩉᩣᩁᩮᩣ ᩈᨴ᩠ᨴ ᨸᨱ᩠ᨱᨲ᩠ᨲᩥ, ᩅᨱᩥᨩ᩠ᨩᩣ ᨧᩮᨲᨶᩣᩈᩩ ᨧ;

ᨶᩣᨣᩮᩣ ᨲᩩ’ᩁᨣ ᩉᨲ᩠ᨳᩦᩈᩩ, ᨶᩣᨣᩁᩩᨠ᩠ᨡᩮ ᨲᨳᩩ’ᨲ᩠ᨲᨾᩮ.

ᨲᩩᩃ᩠ᨿᩮᩈ᩠ᩅᩮ’ᨠᩮᩣᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;

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

ᨾᩪᩃᩴ ¶ ᨽᩮ ᩈᨶ᩠ᨲᩥᨠᩮ ᨾᩪᩃ, ᨾᩪᩃᩮ ᩉᩮᨲᩩᨾ᩠ᩉᩥ ᨸᩣᨽᨲᩮ;

ᩁᩪᨸᩣᨴ᩠ᨿᩴ’ᩈ ᨸᨠᨱ᩠ᨯᩮᩈᩩ, ᨡᨶ᩠ᨵᩮᩣ ᩁᩣᩈᩥ ᨣᩩᨱᩮᩈᩩ ᨧ.

ᩌᩁᨾ᩠ᨽᩮᩣ ᩅᩦᩁᩥᨿᩮ ᨠᨾ᩠ᨾᩮ, ᩌᨴᩥᨠᨾ᩠ᨾᩮ ᩅᩥᨠᩮᩣᨸᨶᩮ;

ᩋᨳᩮᩣ ᩉᨴᨿᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩥ, ᨧᩥᨲ᩠ᨲᩮ ᨧ ᩉᨴᨿᩴ ᩏᩁᩮ.

ᨸᨧ᩠ᨨᩣᨲᩣᨸᩣ’ᨶᩩᨻᨶ᩠ᨵᩮᩈᩩ, ᩁᩣᨣᩣᨴᩮᩣ’ᨶᩩᩈᨿᩮᩣ ᨽᩅᩮ;

ᨾᩣᨲᨦ᩠ᨣᨾᩩᨴ᩠ᨵᨸᩥᨱ᩠ᨯᩮ ᨲᩩ, ᨥᨭᩮ ᨠᩩᨾ᩠ᨽᩮᩣ ᨴᩈᨾ᩠ᨻᨱᩮ.

ᨸᩁᩥᩅᩣᩁᩮᩣ ᨸᩁᩥᨩᨶᩮ, ᨡᨣ᩠ᨣᨠᩮᩣᩈᩮ ᨸᩁᩥᨧ᩠ᨨᨴᩮ;

ᩌᩃᨾ᩠ᨻᩁᩮᩣ ᨲᩩ ᩈᩣᩁᨾ᩠ᨽᩮ, ᨽᩮᩁᩥᨽᩮᨴᩮ ᨧ ᨴᩥᩔᨲᩥ.

ᨡᨱᩮᩣ ᨠᩣᩃᩅᩥᩈᩮᩈᩮ ᨧ, ᨶᩥᨻ᩠ᨿᩣᨸᩣᩁᨭ᩠ᨮᩥᨲᩥᨾ᩠ᩉᩥ ᨧ;

ᨠᩩᩃᩮ ᨲ᩠ᩅ’ᨽᩥᨩᨶᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩏᨸ᩠ᨸᨲ᩠ᨲᩥᨽᩪᨾᩥᨿᨾ᩠ᨸᩥ ᨧ.

ᩌᩉᩣᩁᩮᩣ ᨠᨻᩊᩦᨠᩣᩁᩣ, ᩉᩣᩁᩣᨴᩦᩈᩩ ᨧ ᨠᩣᩁᨱᩮ;

ᩅᩥᩔᩣᩈᩮ ᨿᩣᨧᨶᩣᨿᨬ᩠ᨧ, ᨸᩮᨾᩮ ᨧ ᨸᨱᨿᩮᩣ ᨾᨲᩮᩣ.

ᨱᩣᨴᩮᩣ ᩈᨴ᩠ᨵᩣ, ᨧᩦᩅᩁᩣᨴᩥ, ᩉᩮᨲ᩠ᩅᩣ’ᨵᩣᩁᩮᩈᩩ ᨸᨧ᩠ᨧᨿᩮᩣ;

ᨠᩦᩊᩣ ᨴᩥᨻ᩠ᨻᩅᩥᩉᩣᩁᩣᨴᩮᩣ, ᩅᩥᩉᩣᩁᩮᩣ ᩈᩩᨣᨲᩣᩃᨿᩮ.

ᩈᨾᨲ᩠ᨳᨶᩮ ᨾᨲᩮᩣ ᨧᩥᨲ᩠ᨲᩮ, ᨠᨣ᩠ᨣᨲᩣᨿᩴ ᩈᨾᩣᨵᩥ ᨧ;

ᨿᩮᩣᨣᩮᩣ ᩈᨦ᩠ᨣᨲᩥ [ᩈᨦ᩠ᨣᩮ ᨧ (ᨭᩦ.)] ᨠᩣᨾᩣᨴᩮᩣ,

ᨽᩮᩣᨣᩮᩣ ᩈᨸ᩠ᨸᨹᨱ’ᨦ᩠ᨣᩮᩈᩩ, ᨠᩮᩣᨭᩥᩃ᩠ᩃᩮ ᨽᩩᨬ᩠ᨩᨶᩮ ᨵᨶᩮ;

ᨽᩪᨾᩥᨽᩣᨣᩮ ᨠᩥᩃᩮᩈᩮ ᨧ, ᨾᩃᩮ ᨧᩣ’ᨦ᩠ᨣᨱ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᨵᨶᩣᨴᩥᨴᨸ᩠ᨸᩮ ᨸᨬ᩠ᨬᩣᨿ, ᩋᨽᩥᨾᩣᨶᩮᩣ ᨾᨲᩮᩣ ᨳ ᨧ;

ᩋᨸᨴᩮᩈᩮᩣ ᨶᩥᨾᩥᨲ᩠ᨲᩮ ᨧ, ᨨᩃᩮ ᨧ ᨠᨳᨶᩮ ᨾᨲᩮᩣ.

ᨧᩥᨲ᩠ᨲᩮ ᨠᩣᨿᩮ ᩈᨽᩣᩅᩮ ᨧ, ᩈᩮᩣ ᩋᨲ᩠ᨲᩣ ᨸᩁᨾ’ᨲ᩠ᨲᨶᩥ;

ᩋᨳ ᨣᩩᨾ᩠ᨻᩮᩣ ᨧ ᨳᨾ᩠ᨻᩈ᩠ᨾᩥᩴ [ᨳᨾ᩠ᨽᩈ᩠ᨾᩥᩴ (ᨭᩦ.)], ᩈᨾᩪᩉᩮ ᨻᩃᩈᨩ᩠ᨩᨶᩮ.

ᩋᨶ᩠ᨲᩮᩣᨥᩁᩮ ᨠᩩᩈᩪᩃᩮ ᨧ, ᨠᩮᩣᨭ᩠ᨮᩮᩣ ᨶ᩠ᨲᩮᩣᨠᩩᨧ᩠ᨨᩥᨿᩴ ᨸ᩠ᨿᨳ;

ᩈᩮᩣᨸᩣᨶᨦ᩠ᨣᨾ᩠ᩉᩥ ᩏᨱ᩠ᩉᩦᩈᩮᩣ, ᨾᨠᩩᨭᩮ ᩈᩦᩈᩅᩮᨮᨶᩮ.

ᨶᩥᨿ᩠ᨿᩣᩈᩮ ᩈᩮᨡᩁᩮ ᨴ᩠ᩅᩣᩁᩮ, ᨶᩥᨿ᩠ᨿᩪᩉᩮᩣ ᨶᩣᨣᨴᨶ᩠ᨲᨠᩮ;

ᩋᨳᩮᩣ ᩈᩥᨡᨱ᩠ᨯᩮ ᨲᩪᨱᩦᩁᩮ, ᨠᩃᩣᨸᩮᩣ ᨶᩥᨠᩁᩮ ᨾᨲᩮᩣ.

ᨧᩪᩊᩣ ᩈᩴᨿᨲᨠᩮᩈᩮᩈᩩ, ᨾᨠᩩᨭᩮ ᨾᩮᩣᩊᩥ ᨧ ᨴ᩠ᩅᩥᩈᩩ;

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

ᨸᨠ᩠ᨡᩮᩣ ¶ ᨠᩣᩃᩮ ᨻᩃᩮ ᩈᩣᨵ᩠ᨿᩮ, ᩈᨡᩦ ᩅᩣᨩᩮᩈᩩ ᨸᨦ᩠ᨣᩩᩃᩮ;

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

ᨣᨩᩮ ᨠᩁᩮᨱᩩ ᨸᩩᩁᩥᩈᩮ, ᩈᩮᩣ ᩉᨲ᩠ᨳᩥᨶᩥᨿ ᨾᩥᨲ᩠ᨳᩥᨿᩴ;

ᩁᨲᨶᩮ ᩅᨩᩥᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨾᨱᩥᩅᩮᨵᩥ’ᨶ᩠ᨴᩉᩮᨲᩥᩈᩩ.

ᩅᩥᩈᩣᨱᩴ ᨲᩦᩈᩩ ᨾᩣᨲᨦ᩠ᨣ, ᨴᨶ᩠ᨲᩮ ᨧ ᨸᩈᩩᩈᩥᨦ᩠ᨣᨠᩮ;

ᨠᩮᩣᨭᩥᨿᩴ ᨲᩩ ᨾᨲᩮᩣ ᨠᩮᩣᨱᩮᩣ, ᨲᨳᩣ ᩅᩣᨴᩥᨲ᩠ᨲᩅᩣᨴᨶᩮ.

ᩅᨱᩥᨸ᩠ᨸᨳᩮ ᨧ ᨶᨣᩁᩮ, ᩅᩮᨴᩮ ᨧ ᨶᩥᨣᨾᩮᩣ ᨳ ᨧ;

ᩅᩥᩅᩣᨴᩣᨴᩮᩣ’ ᨵᩥᨠᩁᨱᩴ, ᩈᩥᨿᩣ’ᨵᩣᩁᩮ ᨧ ᨠᩣᩁᨱᩮ.

ᨸᩈᩩᨾ᩠ᩉᩥ ᩅᩈᩩᨵᩣᨿᨬ᩠ᨧ, ᩅᩣᨧᩣᨴᩮᩣ ᨣᩮᩣ ᨸᩩᨾᩥᨲ᩠ᨳᩥᨿᩴ;

ᩉᩁᩥᨲᩮ ᨲᩩ ᩈᩩᩅᨱ᩠ᨱᩮ ᨧ, ᩅᩣᩈᩩᨴᩮᩅᩮ ᩉᩁᩦ’ᩁᩥᨲᩮᩣ.

ᩌᨿᨲ᩠ᨲᩮ ᨸᩁᩥᩅᩣᩁᩮ ᨧ, ᨽᩁᩥᨿᩣᨿᩴ ᨸᩁᩥᨣ᩠ᨣᩉᩮᩣ;

ᩏᨲ᩠ᨲᩴᩈᩮᩣ ᨲ᩠ᩅ’ ᩅᨲᩴᩈᩮᩣ ᨧ, ᨠᨱ᩠ᨱᨸᩪᩁᩮ ᨧ ᩈᩮᨡᩁᩮ.

ᩅᩥᨩ᩠ᨩᩩᨿᩴ ᩅᨩᩥᩁᩮ ᨧᩮᩅᩣ, ᩈᨶᩥ’ᨲ᩠ᨳᩥᨸᩩᩁᩥᩈᩮ ᨸ᩠ᨿᨳ;

ᨠᩮᩣᨱᩮ ᩈᨦ᩠ᨡ᩠ᨿᩣᩅᩥᩈᩮᩈᩈ᩠ᨾᩥᩴ, ᩏᨠ᩠ᨠᩴᩈᩮ ᨠᩮᩣᨭᩥ ᨶᩣᩁᩥᨿᩴ.

ᨧᩪᩊᩣ ᨩᩣᩃᩣ ᨸᨵᩣᨶ’ᨣ᩠ᨣ, ᨾᩮᩣᩁᨧᩪᩊᩣᩈᩩ ᩈᩣ ᩈᩥᨡᩣ;

ᩈᨸ᩠ᨸᨴᩣᨮᩣᨿ ᨾᩣᩈᩦ’ᨲ᩠ᨳᩦ, ᩍᨭ᩠ᨮᩔᩣ’ᩈᩦᩈᨶᩣᨿᨸᩥ.

ᩅᩈᩣ ᩅᩥᩃᩦᨶ ᨲᩮᩃᩈ᩠ᨾᩥᩴ, ᩅᩈᨣᩣ ᩅᨬ᩠ᨫᨣᩣᩅᩥᩈᩩ;

ᩋᨽᩥᩃᩣᩈᩮ ᨲᩩ ᨠᩥᩁᨱᩮ, ᩋᨽᩥᩈᨦ᩠ᨣᩮ ᩁᩩᨧᩥ’ᨲ᩠ᨳᩥᨿᩴ.

ᩈᨬ᩠ᨬᩣ ᩈᨬ᩠ᨩᩣᨶᨶᩮ ᨶᩣᨾᩮ, ᨧᩮᨲᨶᩣᨿᨬ᩠ᨧ ᨴᩥᩔᨲᩥ;

ᩋᩴᩈᩮ ᩈᩥᨸ᩠ᨸᩮ ᨠᩃᩣ ᨠᩣᩃᩮ, ᨽᩣᨣᩮ ᨧᨶ᩠ᨴᩔ ᩈᩮᩣᩊᩈᩮ.

ᨻᩦᨩᨠᩮᩣᩈᩮ ᨥᩁᨠᩪᨭᩮ, ᨠᨱ᩠ᨱᨽᩪᩈᩣᨿ ᨠᨱ᩠ᨱᩥᨠᩣ;

ᩌᨣᩣᨾᩥᨠᩣᩃᩮ ᨴᩦᨥᨲ᩠ᨲᩮ, ᨸᨽᩣᩅᩮ ᨧ ᨾᨲᩣ’ᨿᨲᩥ.

ᩏᨱ᩠ᨱᩣ ᨾᩮᩈᩣᨴᩥᩃᩮᩣᨾᩮ, ᨧ, ᨽᩪᨾᨩ᩠ᨫᩮ ᩁᩮᩣᨾᨵᩣᨲᩩᨿᩴ;

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

ᨠᩕᩥᨿᨧᩥᨲ᩠ᨲᩮ ᨧ ᨠᩁᨱᩮ, ᨠᩥᩁᩥᨿᩴ ᨠᨾ᩠ᨾᨶᩥ ᨠᩕᩥᨿᩣ;

ᩈᩩᨶᩥᩈᩣᨿᩴ ᨲᩩ ᨠᨬ᩠ᨬᩣᨿ, ᨩᩣᨿᩣᨿ ᨧ ᩅᨵᩪ ᨾᨲᩣ.

ᨸᨾᩣᨱᩥ’ᩔᩁᩥᨿᩮ ᨾᨲ᩠ᨲᩣ, ᩋᨠ᩠ᨡᩁᩣᩅᨿᩅᩮ’ᨸ᩠ᨸᨠᩮ;

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

ᩁᩣᨩᩃᩥᨦ᩠ᨣᩮᩣ’ᩈᨽᨦ᩠ᨣᩮᩈᩩ, ¶ ᩁᩩᨠ᩠ᨡᩮ ᨧ ᨠᨠᩩᨴᩮᩣ [ᨠᨠᩩᨵᩮᩣ (ᨭᩦ. ᩈᩦ.)] ᨸ᩠ᨿᨳ;

ᨶᩥᨾᩥᨲ᩠ᨲ’ᨠ᩠ᨡᩁ ᩈᩪᨸᩮᩈᩩ, ᨻ᩠ᨿᨬ᩠ᨩᨶᩴ ᨧᩥᩉᨶᩮ ᨸᨴᩮ.

ᩅᩮᩣᩉᩣᩁᩮ ᨩᩮᨲᩩ ᨾᩥᨧ᩠ᨨᩣᨿᩴ, ᨠᩦᩊᩣᨴᩮᩣ ᨧᩣᨸᩥ ᨴᩮᩅᨶᩴ;

ᨽᩁᩥᨿᩣᨿᩴ ᨲᩩ ᨠᩮᨴᩣᩁᩮ, ᩈᩁᩦᩁᩮ ᨡᩮᨲ᩠ᨲ ᨾᩦᩁᩥᨲᩴ.

ᩈᩩᩔᩪᩈᩣᨿᨬ᩠ᨧ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ, ᩍᩔᩣᨽ᩠ᨿᩣᩈᩮ ᨸ᩠ᨿᩩ’ᨸᩣᩈᨶᩴ;

ᩈᩪᩃᩴ ᨲᩩ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᩉᩮᨲᩥ, ᨽᩮᨴᩮ ᩈᩴᨠᩩ ᩁᩩᨩᩣᩈᩩ ᨧ.

ᨲᨶ᩠ᨲᩥ ᩅᩦᨱᩣᨣᩩᨱᩮ, ᨲᨶ᩠ᨲᩴ, ᨾᩩᨡ᩠ᨿᩈᩥᨴ᩠ᨵᨶ᩠ᨲ ᨲᨶ᩠ᨲᩩᩈᩩ;

ᩁᨳᩣᨴ᩠ᨿᨦ᩠ᨣᩮ ᨲᩩ ᨧ ᨿᩩᨣᩮᩣ, ᨠᨸ᩠ᨸᨾ᩠ᩉᩥ ᨿᩩᨣᩃᩮ ᨿᩩᨣᩴ.

ᩍᨲ᩠ᨳᩥᨸᩩᨸ᩠ᨹᩮ ᨧ ᩁᩮᨱᩩᨾ᩠ᩉᩥ, ᩁᨩᩮᩣ ᨸᨠᨲᩥᨩᩮ ᨣᩩᨱᩮ;

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

ᨣᩁᩩ’ᨸᩣᨿᩣ’ᩅᨲᩣᩁᩮᩈᩩ, ᨲᩥᨲ᩠ᨳᩴ ᨸᩪᨲᨾ᩠ᨻᩩ ᨴᩥᨭ᩠ᨮᩥᩈᩩ;

ᨸᨱ᩠ᨯᨠᩮ ᨩᩮᩣᨲᩥ ᨶᨠ᩠ᨡᨲ᩠ᨲ, ᩁᩴᩈᩦᩈ᩠ᩅ’ᨣ᩠ᨣᩥᨾ᩠ᩉᩥ ᨩᩮᩣᨲᩥ ᩈᩮᩣ.

ᨠᨱ᩠ᨯᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᩁᩮ ᨴᨱ᩠ᨯᩮ, ᩅᨣ᩠ᨣᩮ ᨧᩣᩅᩈᩁᩮ ᨸ᩠ᨿᨳ;

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

ᩏᨭ᩠ᨮᩣᨶᩴ ᨸᩮᩣᩁᩥᩈᩮ’ᩉᩣᩈᩩ, ᨶᩥᩈᩥᨶ᩠ᨶᩣᨴ᩠ᨿᩩ’ᨣ᩠ᨣᨾᩮ ᨸ᩠ᨿᨳ;

ᩋᨶᩥᩔᨿᨾᩉᩦᨽᩣᨣᩮ, ᨲ᩠ᩅᩥ’ᩁᩦᨱᩴ ᩐᩈᩁᩮ ᩈᩥᨿᩣ.

ᩌᩁᩣᨵᨶᩴ ᩈᩣᨵᨶᩮ ᨧ, ᨸᨲ᩠ᨲᩥᨿᩴ ᨸᩁᩥᨲᩮᩣᩈᨶᩮ;

ᨸᨵᩣᨶᩮ ᨲᩩ ᨧ ᩈᩣᨶᩩᨾ᩠ᩉᩥ, ᩅᩥᩈᩣᨱᩮ ᩈᩥᨦ᩠ᨣ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᨴᩥᨭ᩠ᨮᩣ’ᨴᩥᨾᨣ᩠ᨣᩮ ᨬᩣᨱ’ᨠ᩠ᨡᩥ, ᨠ᩠ᨡᨱ ᩃᨴ᩠ᨵᩦᩈᩩ ᨴᩔᨶᩴ;

ᩉᩮᨾᩮ ᨸᨬ᩠ᨧᩈᩩᩅᨱ᩠ᨱᩮ ᨧ, ᨶᩥᨠ᩠ᨡᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨸᩈᩣᨵᨶᩮ.

ᨲᩥᨳᩥᨽᩮᨴᩮ ᨧ ᩈᩣᨡᩣᨴᩥ, ᨹᩊᩩᨾ᩠ᩉᩥ ᨸᨻ᩠ᨻ ᨾᩩᨧ᩠ᨧᨲᩮ;

ᨶᩣᨣᩃᩮᩣᨠᩮ ᨲᩩ ᨸᩣᨲᩣᩃᩴ, ᨽᩣᩈᩥᨲᩴ ᨻᩃᩅᩣᨾᩩᨡᩮ.

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

ᩋᨳᩮᩣ’ᨸᨠᩁᨱᩮ ᩈᩥᨴ᩠ᨵᩥ, ᨠᩣᩁᨠᩮᩈᩩ ᨧ ᩈᩣᨵᨶᩴ.

ᨲᩦᩈ᩠ᩅᩦᩁᩥᨲᩮᩣ [ᨲᩦᩈ᩠ᩅᩥᨲᩮᩣ (ᨭᩦ.)] ᨴᩣᨶᩈᩦᩃᩮ, ᩅᨴᨬ᩠ᨬᩪ ᩅᨣ᩠ᨣᩩᩅᩣᨴᩥᨶᩥ;

ᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ ᨽᩥᩈᩥᨲ᩠ᨲᩮ ᨧ, ᨸᩪᨩᩥᨲᩮ ᨸᩩᩁᨲᩮᩣᨠᨲᩮ.

ᨾᨶ᩠ᨴᩮᩣ ᨽᩣᨣ᩠ᨿᩅᩥᩉᩦᨶᩮ ᨧᩣ, ᨸ᩠ᨸᨠᩮ ᨾᩪᩊ᩠ᩉᩣ’ᨸᨭᩪᩈ᩠ᩅᨸᩥ;

ᩅᩩᨴ᩠ᨵᩥᨿᩩᨲ᩠ᨲᩮ ᩈᨾᩩᨶ᩠ᨶᨴ᩠ᨵᩮ, ᩏᨸ᩠ᨸᨶ᩠ᨶᩮ ᩏᩔᩥᨲᩴ ᨽᩅᩮ.

ᩁᨳᨦ᩠ᨣᩮ’ᨠ᩠ᨡᩮᩣ ¶ ᩈᩩᩅᨱ᩠ᨱᩈ᩠ᨾᩥᩴ, ᨸᩣᩈᨠᩮ, ᩋᨠ᩠ᨡ ᨾᩥᨶ᩠ᨴᩕᩥᨿᩮ;

ᩈᩔᨲᩮ ᨧ ᨵᩩᩅᩮᩣ ᨲᩦᩈᩩ, ᨵᩩᩅᩴ ᨲᨠ᩠ᨠᩮ ᨧ ᨶᩥᨧ᩠ᨨᩥᨲᩮ.

ᩉᩁᩮ ᩈᩥᩅᩮᩣ, ᩈᩥᩅᩴ ᨽᨴ᩠ᨴ, ᨾᩮᩣᨠ᩠ᨡᩮᩈᩩ, ᨩᨾ᩠ᨻᩩᨠᩮ ᩈᩥᩅᩣ;

ᩈᩮᨶᩣᨿᩴ ᩈᨲ᩠ᨲᩥᨿᨬ᩠ᨧᩮᩅ, ᨳᩪᩃᨲ᩠ᨲᩮ ᨧ ᨻᩃᩴ ᨽᩅᩮ.

ᩈᨦ᩠ᨡ᩠ᨿᩣ ᨶᩁᨠᨽᩮᨴᩮᩈᩩ, ᨸᨴᩩᨾᩴ ᩅᩣᩁᩥᨩᩮ ᨸ᩠ᨿᨳ;

ᨴᩮᩅᨽᩮᨴᩮ ᩅᩈᩩ ᨸᩩᨾᩮ, ᨸᨱ᩠ᨯᨠᩴ ᩁᨲᨶᩮ ᨵᨶᩮ.

ᨶᩥᨻ᩠ᨻᩣᨶᩴ ᩋᨲ᩠ᨳᨣᨾᨶᩮ, ᩋᨸᩅᨣ᩠ᨣᩮ ᩈᩥᨿᩣ ᨳ ᨧ;

ᩈᩮᨲᨾ᩠ᨻᩩᨩᩮ ᨸᩩᨱ᩠ᨯᩁᩦᨠᩴ, ᨻ᩠ᨿᨣ᩠ᨥᩮ ᩁᩩᨠ᩠ᨡᨶ᩠ᨲᩁᩮ ᨸᩩᨾᩮ.

ᩏᨸᩉᩣᩁᩮ ᨻᩃᩥ ᨸᩩᨾᩮ, ᨠᩁᩈ᩠ᨾᩥᩴᨧᩣ’ᩈᩩᩁᨶ᩠ᨲᩁᩮ;

ᩈᩩᨠ᩠ᨠᩴ ᨲᩩ ᩈᨾ᩠ᨽᩅᩮ, ᩈᩩᨠ᩠ᨠᩮᩣ, ᨵᩅᩃᩮ, ᨠᩩᩈᩃᩮ ᨲᩥᩈᩩ.

ᨴᩣᨿᩮᩣ ᨴᩣᨶᩮ ᩅᩥᨽᨲ᩠ᨲᨻ᩠ᨻ, ᨵᨶᩮ ᨧ ᨸᩥᨲᩩᨶᩴ ᩅᨶᩮ [ᨵᨶᩮ (ᨭᩦ.)];

ᨸᨽᩩᨲ᩠ᨲᩣ’ᨿᨲ᩠ᨲᨲᩣ’ᨿᨲ᩠ᨲᩣ’, ᨽᩥᩃᩣᩈᩮᩈᩩ ᩅᩈᩮᩣ ᨽᩅᩮ.

ᨸᩁᩥᨽᩣᩈᨶ ᨾᨠ᩠ᨠᩮᩣᩈᩮ, ᨶᩥᨿᨾᩮ ᨽᩣᩈᨶᩮ ᨳ ᨧ,

ᨵᨶᨾ᩠ᩉᩥ ᩈᩮᩊᨶᩴ ᨿᩮᩣᨵ, ᩈᩦᩉᨶᩣᨴᨾ᩠ᩉᩥ ᨴᩥᩔᨲᩥ.

ᨸᨽᩅᩮᩣ ᨩᩣᨲᩥᩉᩮᨲᩩᨾ᩠ᩉᩥ, ᨮᩣᨶᩮ ᨧᩣᨴ᩠ᨿᩩᨸᩃᨴ᩠ᨵᩥᨿᩴ;

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

ᨠᩁᨱᩴ ᩈᩣᨵᨠᨲᨾᩮ, ᨠᩕᩥᨿᩣ ᨣᨲ᩠ᨲᩮᩈᩩ ᩍᨶ᩠ᨴᩕᩥᨿᩮ;

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

ᨸᩩᨸ᩠ᨹᩮ ᨹᩃᩮ ᨧ ᨸᩈᩅᩮᩣ, ᩏᨸ᩠ᨸᩣᨴᩮ ᨣᨻ᩠ᨽᨾᩮᩣᨧᨶᩮ;

ᨣᩣᨿᨶᩮ ᨣᩣᨿᨠᩮ ᩋᩔᩮ, ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ ᨴᩮᩅᨲᩣᨶ᩠ᨲᩁᩮ.

ᩅᩥᨶᩣ ᨸᩩᨸ᩠ᨹᩴ ᨹᩃᨣ᩠ᨣᩣᩉᩥ, ᩁᩩᨠ᩠ᨡᩮ ᩅᨶᨸ᩠ᨸᨲᩥ;

ᩌᩉᨲᩮ ᩉᩮᨾᩁᨩᨲᩮ, ᩁᩪᨸᩥᨿᩴ ᩁᨩᨲᩮᨸᩥ ᨧ.

ᨡᨣᩣᨴᩥᨻᨶ᩠ᨵᨶᩮ ᨸᩣᩈᩮᩣ, ᨠᩮᩈᨸᩩᨻ᩠ᨻᩮᩣ ᨧᨿᩮ ᨸ᩠ᨿᨳ;

ᨲᩣᩁᩣ’ᨠ᩠ᨡᩥᨾᨩ᩠ᨫᩮ ᨶᨠ᩠ᨡᨲ᩠ᨲᩮ, ᨲᩣᩁᩮᩣ ᩏᨧ᩠ᨧᨲᩁᩔᩁᩮ.

ᨸᨲ᩠ᨲᩮ ᨧ ᩃᩮᩣᩉᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᨠᩴᩈᩮᩣ ᨧᨲᩩᨠᩉᩣᨸᨱᩮ;

ᨾᨩ᩠ᨫᩥᨾᩮᩣ ᨴᩮᩉᨾᨩ᩠ᨫᩈ᩠ᨾᩥᩴ, ᨾᨩ᩠ᨫᨽᩅᩮ ᨧ ᩈᩮᩣ ᨲᩥᩈᩩ.

ᩌᩅᩮᩈᨶᩴᨽᩪᨲᩣᩅᩮᩈᩮ, ᩈᩥᨸ᩠ᨸᩈᩣᩃᩣ ᨥᩁᩮᩈᩩ ᨧ;

ᩈᩮᩣᨽᩣ ᩈᨾ᩠ᨸᨲ᩠ᨲᩦᩈᩩ ᩈᩥᩁᩦ, ᩃᨠ᩠ᨡᩦᨲ᩠ᨳᩦ ᨴᩮᩅᨲᩣᨿ ᨧ.

ᨠᩩᨾᩣᩁᩮᩣ ¶ ᨿᩩᩅᩁᩣᨩᩮ ᨧ, ᨡᨶ᩠ᨴᩮ ᩅᩩᨲ᩠ᨲᩮᩣ ᩈᩩᩈᩩᨾ᩠ᩉᩥ ᨧ;

ᩋᨳᩣ’ᨶᩥᨲ᩠ᨳᩦ ᨸᩅᩣᩊᩮᩣ ᨧ, ᨾᨱᩥᨽᩮᨴᩮ ᨲᨳᩣ’ᨦ᩠ᨠᩩᩁᩮ.

ᨸᨱᩮᩣ ᩅᩮᨲᨶ ᨾᩪᩃᩮᩈᩩ, ᩅᩮᩣᩉᩣᩁᩮ ᨧ ᨵᨶᩮ ᨾᨲᩮᩣ;

ᨸᨭᩥᨣ᩠ᨣᩉᩮᩣ ᨲᩩ ᨣᩉᨱᩮ, ᨠᨳᩥᨲᩮᩣ ᨽᩣᨩᨶᨶ᩠ᨲᩁᩮ.

ᩋᩈᩩᨽᩮ ᨧ ᩈᩩᨽᩮ ᨠᨾ᩠ᨾᩮ, ᨽᩣᨣ᩠ᨿᩴ ᩅᩩᨲ᩠ᨲᩴ ᨴ᩠ᩅᨿᩮ ᨸ᩠ᨿᨳ;

ᨸᩥᨸ᩠ᨹᩃᩴ ᨲᩁᩩᨽᩮᨴᩮ ᨧ, ᩅᨲ᩠ᨳᨧ᩠ᨨᩮᨴᨶᩈᨲ᩠ᨳᨠᩮ.

ᩋᨸᩅᨣ᩠ᨣᩮᩣ ᨸᩁᩥᨧ᩠ᨧᩣᨣᩣ’, ᩅᩈᩣᨶᩮᩈᩩ ᩅᩥᨾᩩᨲ᩠ᨲᩥᨿᩴ;

ᩃᩥᨦ᩠ᨣᩴ ᨲᩩ ᩋᨦ᩠ᨣᨩᩣᨲᩈ᩠ᨾᩥᩴ, ᨸᩩᨾᨲ᩠ᨲᩣᨴᩥᨾ᩠ᩉᩥ ᩃᨠ᩠ᨡᨱᩮ.

ᨧᩣᨣᩮ ᩈᨽᩣᩅᩮ ᨶᩥᨾ᩠ᨾᩣᨶᩮ, ᩈᨣ᩠ᨣᩮᩣ ᨩ᩠ᨫᩣᨿᩮ ᨴᩥᩅᩮᨸ᩠ᨿᨳ;

ᩁᩮᩣᩉᩥᨲᩮᩣ ᩃᩮᩣᩉᩥᨲᩮ ᨾᨧ᩠ᨨ, ᨽᩮᨴᩮ ᨧᩮᩅ ᨾᩥᨣᨶ᩠ᨲᩁᩮ.

ᨶᩥᨭ᩠ᨮᩣ ᨶᩥᨸ᩠ᨹᨲ᩠ᨲᩥᨿᩴ ᨧᩮᩅᩣ, ᩅᩈᩣᨶᨾ᩠ᩉᩥ ᩋᨴᩔᨶᩮ;

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

ᨾᩩᨡ᩠ᨿᩮᩣ’ᨸᩣᨿᩮᩈᩩ ᩅᨴᨶᩮ, ᩌᨴᩥᩈ᩠ᨾᩥᩴ ᨾᩩᨡ ᨾᩦᩁᩥᨲᩴ;

ᨴᨻ᩠ᨻᩴ ᨽᨻ᩠ᨻᩮ ᨣᩩᨱᩣᨵᩣᩁᩮ, ᩅᩥᨲ᩠ᨲᩮ ᨧ ᨻᩩᨵ ᨴᩣᩁᩩᩈᩩ.

ᨾᩣᨶᩴ ᨸᨾᩣᨱᩮ ᨸᨲ᩠ᨳᩣᨴᩮᩣ, ᨾᩣᨶᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᩅᩥᨵᩣᨿ ᨧ;

ᩋᨳᩮᩣ ᨸᩁᩥᩔᨾᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩅᩣᨿᩣᨾᩮᩣ ᩅᩦᩁᩥᨿᩮᨸᩥ ᨧ.

ᩈᩁᩮᩣᩁᩩᩉᩮ ᩈᨲᨸᨲ᩠ᨲᩴ, ᩈᨲᨸᨲ᩠ᨲᩮᩣ ᨡᨣᨶ᩠ᨲᩁᩮ;

ᨨᩥᨴ᩠ᨴᩮ ᨲᩩ ᨨᩥᨴ᩠ᨴᩅᨶ᩠ᨲᩮ ᨧ, ᩈᩩᩈᩥᩁᩴ ᨲᩪᩁᩥᨿᨶ᩠ᨲᩁᩮ.

ᩑᨠᩈ᩠ᨾᩥᩴ ᩈᨴᩥᩈᩮ ᩈᨶ᩠ᨲᩮ, ᩈᨾᩣᨶᩴ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩴ;

ᩋᨳᩮᩣ ᨣᩣᩁᩅ ᨽᩦᨲᩦᩈᩩ, ᩈᩴᩅᩮᨣᩮ ᩈᨾ᩠ᨽᨾᩮᩣ ᨾᨲᩮᩣ.

ᨩᩩᨱ᩠ᩉᩣ ᨧᨶ᩠ᨴᨸ᩠ᨸᨽᩣᨿᨬ᩠ᨧ, ᨲᨴᩩᨸᩮᨲᨶᩥᩈᩣᨿ ᨧ;

ᩅᩥᨾᩣᨶᩴ ᨴᩮᩅᨲᩣᩅᩣᩈᩮ, ᩈᨲ᩠ᨲᨽᩪᨾᩥᨥᩁᨾ᩠ᩉᩥ ᨧ.

ᨾᩣᩈᩮ ᨩᩮᨭ᩠ᨮᩮᩣ, ᨲᩥᩅᩩᨴ᩠ᨵᩣ’ᨲᩥ, ᨸ᩠ᨸᩈᨲ᩠ᨳᩮᩈᩩ ᨧ ᨲᩦᩈᩩ ᩈᩮᩣ;

ᨵᨾ᩠ᨾᩮ ᨧ ᨾᨦ᩠ᨣᩃᩮ ᩈᩮᨿ᩠ᨿᩮᩣ, ᩈᩮᩣ ᨸᩈᨲ᩠ᨳᨲᩁᩮ ᨲᩥᩈᩩ.

ᩌᨴᩥᨧ᩠ᨧᩣᨴᩥᨾ᩠ᩉᩥ ᨣᩉᨱᩮ, ᨶᩥᨻᨶ᩠ᨵᩮ ᨧ ᨥᩁᩮ ᨣᩉᩮᩣ;

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

ᨲᩦᩈᩩ ᨣᩣᨾᨱᩥ ᩈᩮᨭ᩠ᨮᩈ᩠ᨾᩥᩴ, ᩋᨵᩥᨸᩮ ᨣᩣᨾᨩᩮᨭ᩠ᨮᨠᩮ;

ᨻᩥᨾ᩠ᨻᩴ ᨲᩩ ᨸᨭᩥᨻᩥᨾ᩠ᨻᩮ ᨧ, ᨾᨱ᩠ᨯᩃᩮ ᨻᩥᨾ᩠ᨻᩥᨠᩣᨹᩃᩮ.

ᨽᩣᨩᨶᩣᨴᩥ ᨸᩁᩥᨠ᩠ᨡᩣᩁᩮ, ᨽᨱ᩠ᨯᩴ ᨾᩪᩃᨵᨶᩮᨸᩥ ᨧ;

ᨾᨣ᩠ᨣᩮᩣ ᨲ᩠ᩅᩁᩥᨿᨾᨣ᩠ᨣᩮ ᨧ, ᩈᨾ᩠ᨾᩣᨴᩥᨭ᩠ᨮᩣᨴᩥᨠᩮ, ᨸᨳᩮ.

ᩈᨾᩣ ¶ ᩅᩔᩮ, ᩈᨾᩮᩣ ᨡᩮᨴ, ᩈᨶ᩠ᨲᩦᩈᩩ, ᩈᩮᩣ ᨶᩥᨽᩮ ᨲᩥᩈᩩ;

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

ᨻᩣᩃᩮᩣ ᨲᩦᩈ᩠ᩅᩣ’ᨴᩥᩅᨿᩈᩣ, ᩈᨾᨦ᩠ᨣᩥᨶᩥ ᩋᨸᨱ᩠ᨯᩥᨲᩮ;

ᩁᨲ᩠ᨲᩴ ᨲᩩ ᩈᩮᩣᨱᩥᨲᩮ, ᨲᨾ᩠ᨻᩣ, ᨶᩩᩁᨲ᩠ᨲ, ᩁᨬ᩠ᨩᩥᨲᩮ ᨲᩥᩈᩩ.

ᨲᨧᩮ ᨠᩣᨿᩮ ᨧ ᨲᨶ᩠ᩅᩥᨲ᩠ᨳᩦ, ᨲᩦᩈ᩠ᩅ’ᨸ᩠ᨸᩮ ᩅᩥᩁᩊᩮ ᨠᩥᩈᩮ;

ᩏᨲᩩᨽᩮᨴᩮ ᨲᩩ ᩈᩥᩈᩥᩁᩮᩣ, ᩉᩥᨾᩮ ᩈᩮᩣ ᩈᩦᨲᩃᩮ ᨲᩥᩈᩩ.

ᩈᨠ᩠ᨡᩁᩣ ᨣᩩᩊᨽᩮᨴᩮ ᨧ, ᨠᨳᩃᩮᨸᩥ ᨧ ᨴᩥᩔᨲᩥ;

ᩋᨶᩩᨣ᩠ᨣᩉᩮ ᨲᩩ ᩈᨦ᩠ᨡᩮᨸᩮ, ᨣᩉᨱᩮ ᩈᨦ᩠ᨣᩉᩮᩣ ᨾᨲᩮᩣ.

ᨴᨠ᩠ᨡᩮ ᨧ ᨲᩥᨡᩥᨱᩮ ᨻ᩠ᨿᨲ᩠ᨲᩮ, ᩁᩮᩣᨣᨾᩩᨲ᩠ᨲᩮ ᨸᨭᩩᨲ᩠ᨲᩥᩈᩩ;

ᩁᩣᨩᩣ ᨲᩩ ᨡᨲ᩠ᨲᩥᨿᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨶᩁᨶᩣᨳᩮ ᨸᨽᩩᨾ᩠ᩉᩥ ᨧ.

ᨡᩃᨬ᩠ᨧ ᨵᨬ᩠ᨬᨠᩁᨱᩮ, ᨠᨠ᩠ᨠᩮ ᨶᩦᨧᩮ ᨡᩃᩮᩣ ᨽᩅᩮ;

ᩋᨳᩩ’ᨸ᩠ᨸᩣᨴᩮ ᩈᨾᩩᨴᨿᩮᩣ, ᩈᨾᩪᩉᩮ ᨸᨧ᩠ᨧᨿᩮᨸᩥ ᨧ.

ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ ᨣᩉᨭ᩠ᨮᩣᨴᩮᩣ, ᩋᩔᨾᩮᩣ ᨧ ᨲᨸᩮᩣᩅᨶᩮ;

ᨽᨿᨦ᩠ᨠᩁᩮ ᨲᩩ ᨠᨮᩥᨶᩮ, ᨠᩩᩁᩪᩁᩮᩣ ᨲᩦᩈᩩ ᨶᩥᨴ᩠ᨴᨿᩮ.

ᨠᨶᩥᨭ᩠ᨮᩮᩣ ᨠᨶᩥᨿᩮᩣ ᨲᩦᩈᩩ, ᩋᨲ᩠ᨿᨸ᩠ᨸᩮ’ᨲᩥᨿᩩᩅᩮ ᨸ᩠ᨿᨳ;

ᩈᩦᨥᨾ᩠ᩉᩥ ᩃᩉᩩ ᨲᩴ, ᩍᨭ᩠ᨮ, ᨶᩥᩔᩣᩁᩣ’ᨣᩁᩩᩈᩩᨲ᩠ᨲᩥᩈᩩ.

ᩋᨵᩁᩮᩣ ᨲᩦᩈ᩠ᩅᨵᩮᩣ ᩉᩦᨶᩮ, ᨸᩩᨾᩮ ᨴᨶ᩠ᨲᨧ᩠ᨨᨴᩮ ᨸ᩠ᨿᨳ;

ᩈᩩᩔᩩᩈᩣ ᩈᩮᩣᨲᩩ ᨾᩥᨧ᩠ᨨᩣᨿ, ᩈᩣ ᨸᩣᩁᩥᨧᩁᩥᨿᩣᨿ ᨧ.

ᩉᨲ᩠ᨳᩮᩣ ᨸᩣᨱᩥᨾ᩠ᩉᩥ ᩁᨲᨶᩮ, ᨣᨱᩮ ᩈᩮᩣᨱ᩠ᨯᩣᨿ ᨽᨶ᩠ᨲᩁᩮ;

ᩌᩅᩣᨭᩮ ᩏᨴᨸᩣᨶᩮ ᨧ, ᨠᩪᨸᩮᩣ ᨠᩩᨾ᩠ᨽᩮ ᨧ ᨴᩥᩔᨲᩥ.

ᩌᨴᩮᩣ ᨸᨵᩣᨶᩮ ᨸᨮᨾᩴ, ᨸᨾᩩᨡᨬ᩠ᨧ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩴ;

ᩅᨩ᩠ᨩᨽᩮᨴᩮ ᨧ ᩅᩥᨲ ᨲᩴ, ᨲᩴ ᩅᩥᨲ᩠ᨳᩣᩁᩮ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩴ.

ᩈᩣᩁᩮᩣ ᨻᩃᩮ ᨳᩥᩁᩴᩈᩮ ᨧ, ᩏᨲ᩠ᨲᨾᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;

ᨽᩣᩁᩮᩣ ᨲᩩ ᨡᨶ᩠ᨵᨽᩣᩁᩣᨴᩮᩣ, ᨴ᩠ᩅᩥᩈᩉᩔᨸᩃᩮᨸᩥ ᨧ.

ᨾᨶ᩠ᨴᩥᩁᩮ ᩁᩮᩣᨣᨽᩮᨴᩮ ᨧ, ᨡᨿᩮᩣ ᩋᨸᨧᨿᨾ᩠ᩉᩥ ᨧ;

ᩅᩣᩊᩮᩣ ᨲᩩ ᩈᩣᨸᨴᩮ ᩈᨸ᩠ᨸᩮ, ᨠᩩᩁᩪᩁᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.

ᩈᩣᩃᩮᩣ ᩈᨩ᩠ᨩᨴ᩠ᨴᩩᨾᩮ ᩁᩩᨠ᩠ᨡᩮ, ᩈᩣᩃᩣᨣᩮᩉᩮ ᨧ ᨴᩥᩔᨲᩥ;

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

ᨲᩦᩈᩩ ᨸᨲᩮᩣ ᨸᩁᩮᨲᩮᩣ ᨧ, ᨾᨲᩮ ᨧ ᨸᩮᨲᨿᩮᩣᨶᩥᨩᩮ;

ᨡ᩠ᨿᩣᨲᩮ ᨲᩩ ᩉᨭ᩠ᨮᩮ ᩅᩥᨬ᩠ᨬᩣᨲᩮ, ᨸᨲᩦᨲᩴ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩴ.

ᩋᨵᩥᨸ᩠ᨸᩣᨿᩮ ¶ ᨧ ᩌᨵᩣᩁᩮ, ᩌᩈᨿᩮᩣ ᨠᨳᩥᨲᩮᩣ ᨳ ᨧ;

ᨸᨲ᩠ᨲᩴ ᨸᨠ᩠ᨡᩮ ᨴᩃᩮ, ᨸᨲ᩠ᨲᩮᩣ, ᨽᩣᨩᨶᩮ ᩈᩮᩣ ᨣᨲᩮ ᨲᩥᩈᩩ.

ᨠᩩᩈᩃᩮ ᩈᩩᨠᨲᩴ, ᩈᩩᨭ᩠ᨮᩩ, ᨠᨲᩮ ᨧ ᩈᩩᨠᨲᩮᩣ ᨲᩥᩈᩩ;

ᨲᨸᩔᩦ ᨲ᩠ᩅ’ᨶᩩᨠᨾ᩠ᨸᩣᨿᩣ, ᩁᩉᩮ ᩅᩩᨲ᩠ᨲᩮᩣ ᨲᨸᩮᩣᨵᨶᩮ.

ᨲᩦᩈᩩ ᩈᩩᩁᩣᨴᩥᩃᩮᩣᩃᩈ᩠ᨾᩥᩴ, ᩈᩮᩣᨱ᩠ᨯᩮᩣ ᩉᨲ᩠ᨳᩥᨠᩁᩮ ᨴ᩠ᩅᩥᩈᩩ;

ᩋᩔᩣᨴᨶᩮ ᨲᩩ ᩁᩈᨶᩴ, ᨩᩥᩅ᩠ᩉᩣᨿᨬ᩠ᨧ ᨵᨶᩥᨾ᩠ᩉᩥ ᨧ.

ᨸᨱᩦᨲᩮᩣ ᨲᩦᩈᩩ ᨾᨵᩩᩁᩮ, ᩏᨲ᩠ᨲᨾᩮ ᩅᩥᩉᩥᨲᩮ ᨸ᩠ᨿᨳ;

ᩋᨬ᩠ᨩᩈᩮ ᩅᩥᩈᩥᨡᩣᨿᨬ᩠ᨧ, ᨸᨶ᩠ᨲᩥᨿᩴ ᩅᩦᨳᩥ ᨶᩣᩁᩥᨿᩴ.

ᨸᩣᨸᩈ᩠ᨾᩥᩴ ᨣᨣᨶᩮ ᨴᩩᨠ᩠ᨡᩮ, ᨻ᩠ᨿᩈᨶᩮ ᨧᩣ’ᨥ ᨾᩩᨧ᩠ᨧᨲᩮ;

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

ᩈᨶ᩠ᨵᩥ ᩈᨦ᩠ᨥᨭ᩠ᨭᨶᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩈᨶ᩠ᨵᩥ’ᨲ᩠ᨳᩥ ᨸᨭᩥᩈᨶ᩠ᨵᩥᨿᩴ;

ᩈᨲ᩠ᨲᨶ᩠ᨶᩴ ᨸᩪᩁᨱᩮ ᩈᩮᨭ᩠ᨮᩮ, ᨲᩥᩈᨶ᩠ᨲᩮ ᩈᨲ᩠ᨲᨾᩮᩣ ᨲᩥᩈᩩ.

ᩒᨩᩣ ᨲᩩ ᨿᩣᨸᨶᩣᨿᨬ᩠ᨧ, ᩒᨩᩮᩣ ᨴᩥᨲ᩠ᨲᩥ ᨻᩃᩮᩈᩩ ᨧ;

ᩋᨳᩮᩣ ᨶᩥᩈᩣᨾᨶᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨴᩔᨶᩮ ᩈᩅᨶᩮᨸᩥ ᨧ.

ᨣᨻ᩠ᨽᩮᩣ ᨠᩩᨧ᩠ᨨᩥᨭ᩠ᨮᩈᨲ᩠ᨲᩮ ᨧ, ᨠᩩᨧ᩠ᨨᩥ ᩒᩅᩁᨠᩮᩈᩩ ᨧ;

ᨡᨱ᩠ᨯᨶᩮ ᨲ᩠ᩅ’ᨸᨴᩣᨶᨬ᩠ᨧ, ᩍᨲᩥᩅᩩᨲ᩠ᨲᩮ ᨧ ᨠᨾ᩠ᨾᨶᩥ.

ᨧᩥᨲ᩠ᨲᨠᩮ ᩁᩩᨠ᩠ᨡᨽᩮᨴᩮ ᨧ, ᨲᩥᩃᨠᩮᩣ ᨲᩥᩃᨠᩣᩊᨠᩮ;

ᩈᩦᩃᩣᨴᩮᩣ ᨸᨭᩥᨸᨲ᩠ᨲᩥ’ᨲ᩠ᨳᩦ, ᨻᩮᩣᨵᩮ ᨸᨲ᩠ᨲᩥ ᨸᩅᨲ᩠ᨲᩥᩈᩩ.

ᩋᩈᩩᨾ᩠ᩉᩥ [ᩌᨿᩩᨾ᩠ᩉᩥ (ᨭᩦ.), ᪔᪐᪗-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨧ ᨻᩃᩮ ᨸᩣᨱᩮᩣ, ᩈᨲ᩠ᨲᩮ ᩉᨴᨿᨣᩣ’ᨶᩥᩃᩮ;

ᨨᨶ᩠ᨴᩮᩣ ᩅᩈᩮ ᩋᨵᩥᨸ᩠ᨸᩣᨿᩮ, ᩅᩮᨴᩮ’ᨧ᩠ᨨᩣ’ᨶᩩᨭ᩠ᨮᩩᨽᩣᨴᩥᩈᩩ.

ᨠᩣᨾᩮᩣᨥᩣᨴᩮᩣ, ᩈᨾᩪᩉᩈ᩠ᨾᩥᩴ, ᩒᨥᩮᩣᩅᩮᨣᩮ ᨩᩃᩔ ᨧ;

ᨠᨸᩣᩃᩴ ᩈᩥᩁᩈᨭ᩠ᨮᩥᨾ᩠ᩉᩥ, ᨥᨭᩣᨴᩥ ᩈᨠᩃᩮᨸᩥ ᨧ.

ᩅᩮᨱ᩠ᩅᩣᨴᩥᩈᩣᨡᩣᨩᩣᩃᩈ᩠ᨾᩥᩴ, ᩃᨣ᩠ᨣᨠᩮᩈᩮ ᨩᨭᩣ’ᩃᨿᩮ;

ᩈᩁᨱᩴ ᨲᩩ ᩅᨵᩮ ᨣᩮᩉᩮ, ᩁᨠ᩠ᨡᩥᨲᩈ᩠ᨾᩥᨬ᩠ᨧ ᩁᨠ᩠ᨡᨱᩮ.

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

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

ᨸᩩᨧ᩠ᨨᩣᨿᩴ ᨣᩁᩉᩣᨿᨬ᩠ᨧᩣ, ᨶᩥᨿᨾᩮ ᨠᩥᩴ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩴ;

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

ᨻᩦᨩᩴ ¶ ᩉᩮᨲᩩᨾ᩠ᩉᩥ ᩋᨭ᩠ᨮᩥᩈ᩠ᨾᩥᩴ, ᩋᨦ᩠ᨣᨩᩣᨲᩮ ᨧ ᨴᩥᩔᨲᩥ;

ᨸᩩᨻ᩠ᨻᩮᩣ ᨸᩪᨿᩮ’ᨣ᩠ᨣᨲᩮᩣ [ᩋᨣ᩠ᨣᨲᩮ (ᨭᩦ.)] ᩌᨴᩮᩣ,

ᨹᩃᨧᩥᨲ᩠ᨲᩮ ᩉᩮᨲᩩᨠᨲᩮ, ᩃᩣᨽᩮ ᨵᨬ᩠ᨬᩣᨴᩥᨠᩮ ᨹᩃᩴ;

ᩌᨣᨾᨶᩮ ᨲᩩ ᨴᩦᨥᩣᨴᩥ, ᨶᩥᨠᩣᨿᩮᩈᩩ ᨧ ᩌᨣᨾᩮᩣ.

ᩈᨶ᩠ᨲᩣᨶᩮᩣ ᨴᩮᩅᩁᩩᨠ᩠ᨡᩮ ᨧ, ᩅᩩᨲ᩠ᨲᩮᩣ ᩈᨶ᩠ᨲᨲᩥᨿᩴ ᨸ᩠ᨿᨳ;

ᩏᨲ᩠ᨲᩁᩅᩥᨸᩁᩦᨲᩮ ᨧ, ᩈᩮᨭ᩠ᨮᩮ ᨧᩣ’ᨶᩩᨲ᩠ᨲᩁᩴ ᨲᩥᩈᩩ.

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

ᨨᩣᨿᩣ ᨲᩩ ᩌᨲᨸᩣᨽᩣᩅᩮ, ᨸᨭᩥᨻᩥᨾ᩠ᨻᩮ ᨸᨽᩣᨿ ᨧ.

ᨣᩥᨾ᩠ᩉᩮ ᨥᨾ᩠ᨾᩮᩣ ᨶᩥᨴᩣᨥᩮᩣ ᨧ, ᩏᨱ᩠ᩉᩮ ᩈᩮᨴᨩᩃᩮ ᨸ᩠ᨿᨳ;

ᨠᨸ᩠ᨸᨶᩴ ᨠᨶ᩠ᨲᨶᩮ ᩅᩩᨲ᩠ᨲᩴ, ᩅᩥᨠᨸ᩠ᨸᩮ ᩈᨩ᩠ᨩᨶᩮ’ᨲ᩠ᨳᩥᨿᩴ.

ᩋᨦ᩠ᨣᩣ ᨴᩮᩈᩮ ᨻᩉᩩᨾ᩠ᩉ’ᨦ᩠ᨣᩴ, ᩋᨦ᩠ᨣᩮᩣ ᨴᩮᩈᩮ ᩅᨸᩩᨾ᩠ᩉ’[ᨦ᩠ᨣ (ᨭᩦ.)] ᨲᨳᩣ’ᩅᨿᩅᩉᩮᨲᩩᩈᩩ;

ᨴᩮᩅᩣᩃᨿᩮ ᨧ ᨳᩪᨸᩈ᩠ᨾᩥᩴ, ᨧᩮᨲᩥᨿᩴ ᨧᩮᨲᩥᨿ’ᨴ᩠ᨴᩩᨾᩮ.

ᩈᨩ᩠ᨩᨶᩮᩣ ᩈᩣᨵᩩᨸᩩᩁᩥᩈᩮ, ᩈᨩ᩠ᨩᨶᩴ ᨠᨸ᩠ᨸᨶᩮ ᨸ᩠ᨿᨳ;

ᩈᩩᨸᩥᨶᩴ ᩈᩩᨸᩥᨶᩮ ᩈᩩᨲ᩠ᨲ, ᩅᩥᨬ᩠ᨬᩣᨱᩮ ᨲ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.

ᨸᨧ᩠ᨧᨠ᩠ᨡᩮ ᩈᨶ᩠ᨶᩥᨵᩣᨶᩮ ᨧ, ᩈᨶ᩠ᨶᩥᨵᩥ ᨸᩁᩥᨠᩥᨲ᩠ᨲᩥᨲᩮᩣ;

ᨽᩥᨿ᩠ᨿᩮᩣ ᨻᩉᩩᨲᩁᨲ᩠ᨳᩮ ᩈᩮᩣ, ᨸᩩᨶᩁᨲ᩠ᨳᩮ’ᨻ᩠ᨿᨿᩴ ᨽᩅᩮ.

ᩅᩥᩈᩃᩥᨲ᩠ᨲᩈᩁᩮ ᨴᩥᨴ᩠ᨵᩮᩣ, ᨴᩥᨴ᩠ᨵᩮᩣ ᩃᩥᨲ᩠ᨲᩮ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;

ᩅᩣᩈᩮ ᨵᩪᨾᩣᨴᩥᩈᨦ᩠ᨡᩣᩁᩮ, ᨵᩥᩅᩣᩈᩮᩣ ᩈᨾ᩠ᨸᨭᩥᨧ᩠ᨨᨶᩮ.

ᩅᩩᨲ᩠ᨲᩮᩣ ᩅᩥᩈᩣᩁᨴᩮᩣ ᨲᩦᩈᩩ, ᩈᩩᨸ᩠ᨸᨣᨻ᩠ᨽᩮ ᨧ ᨸᨱ᩠ᨯᩥᨲᩮ;

ᩋᨳ ᩈᩥᨲ᩠ᨳᩴ ᨾᨵᩩᨧ᩠ᨨᩥᨭ᩠ᨮᩮ, ᩅᩩᨲ᩠ᨲᩴ ᩒᨴᨶᩈᨾ᩠ᨽᩅᩮ.

ᨴᩕᩅᩮ ᩅᨱ᩠ᨱᩮ ᩁᩈᨽᩮᨴᩮ, ᨠᩈᩣᨿᩮᩣ ᩈᩩᩁᨽᩥᨾ᩠ᩉᩥ ᨧ;

ᩋᨳᩮᩣ ᩏᨣ᩠ᨣᨾᨶᩴ ᩅᩩᨲ᩠ᨲᩴ, ᩏᨸ᩠ᨸᨲ᩠ᨲᩩ’ᨴ᩠ᨵᨣᨲᩦᩈᩩ ᨧ.

ᩃᩪᨡᩮ ᨶᩥᨭ᩠ᨮᩩᩁᩅᩣᨧᩣᨿᩴ, ᨹᩁᩩᩈᩴ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩴ;

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

ᨶᩥᩔᨿᩮ ᨲᨸ᩠ᨸᩁᩮ ᩍᨭ᩠ᨮᩮ, ᨸᩁᩣᨿᨱᨸᨴᩴ ᨲᩥᩈᩩ;

ᨠᩅᨧᩮ ᩅᩣᩁᩅᩣᨱᩮ ᨧ, ᨶᩥᨾ᩠ᨾᩮᩣᨠᩮᨸᩥ ᨧ ᨠᨬ᩠ᨧᩩᨠᩮᩣ.

ᩃᩮᩣᩉᨽᩮᨴᩮ ¶ ᨾᨲᩴ ᨲᨾ᩠ᨻᩴ, ᨲᨾ᩠ᨻᩮᩣ ᩁᨲ᩠ᨲᩮ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;

ᨲᩦᩈᩩ ᨲ᩠ᩅ’ᩅᩈᩥᨲᩴ ᨬᩣᨲᩮ, ᩋᩅᩈᩣᨶᨣᨲᩮ ᨾᨲᩴ.

ᨻᩮᩣᨵᨶᩮ ᨧ ᨸᨴᩣᨶᩮ ᨧ, ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ ᨸᨭᩥᨸᩣᨴᨶᩴ;

ᩈᩮᩃᩮ ᨶᩥᨩ᩠ᨩᩃᨴᩮᩈᩮ ᨧ, ᨴᩮᩅᨲᩣᩈᩩ ᨾᩁᩪ’ᩁᩥᨲᩮᩣ.

ᩈᨲ᩠ᨳᩴ ᩌᨿᩩᨵ ᨣᨶ᩠ᨳᩮᩈᩩ, ᩃᩮᩣᩉᩮ, ᩈᨲ᩠ᨳᩮᩣ ᨧ ᩈᨬ᩠ᨧᨿᩮ;

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

ᩅᩦᩁᩥᨿᩮ ᩈᩪᩁᨽᩣᩅᩮ ᨧ, ᨠᨳᩦᨿᨲᩥ ᨸᩁᨠ᩠ᨠᨾᩮᩣ;

ᩋᨳ ᨠᨾ᩠ᨻᩩ ᨾᨲᩮᩣ ᩈᨦ᩠ᨡᩮ, ᩈᩩᩅᨱ᩠ᨱᩮ ᩅᩃᨿᩮᨸᩥ ᨧ.

ᩈᩁᩮᩣ ᨠᨱ᩠ᨯᩮ ᩋᨠᩣᩁᩣᨴᩮᩣ, ᩈᨴ᩠ᨴᩮ ᩅᩣᨸᩥᨾ᩠ᩉᩥ’ᨶᩥᨲ᩠ᨳᩥᨿᩴ;

ᨴᩩᨸ᩠ᨹᩔᩮ ᨲᩥᨡᩥᨱᩮ ᨲᩦᩈᩩ, ᨣᨴᩕᨽᩮ ᨠᨠᨧᩮ ᨡᩁᩮᩣ.

ᩈᩩᩁᩣᨿᩩ’ᨸᨴ᩠ᨴᩅᩮ ᨠᩣᨾᩣ, ᩈᩅᩣᨴᩥᨾ᩠ᩉᩥ ᨧ ᩌᩈᩅᩮᩣ;

ᨴᩮᩉᩮ ᩅᩩᨲ᩠ᨲᩮᩣ ᩁᨳᨦ᩠ᨣᩮ ᨧ, ᨧᨲᩩᩁᩮᩣ’ᨸᨵᩥᩈᩪ’ᨸᨵᩥ.

ᩅᨲ᩠ᨳᩩ’ᨲ᩠ᨲᩴ ᨠᩣᩁᨱᩮ ᨴᨻ᩠ᨻᩮ, ᨽᩪᨽᩮᨴᩮ ᩁᨲᨶᨲ᩠ᨲᨿᩮ;

ᨿᨠ᩠ᨡᩮᩣ ᨴᩮᩅᩮ ᨾᩉᩣᩁᩣᨩᩮ, ᨠᩩᩅᩮᩁᩣ’ᨶᩩᨧᩁᩮ ᨶᩁᩮ.

ᨴᩣᩁᩩᨠ᩠ᨡᨶ᩠ᨵᩮ ᨸᩦᨮᩥᨠᩣᨿᩴ, ᩌᨸᨱᩮ ᨸᩦᨮ ᨾᩣᩈᨶᩮ;

ᨸᩁᩥᩅᩣᩁᩮ ᨸᩁᩥᨠ᩠ᨡᩣᩁᩮᩣ, ᩈᨾ᩠ᨽᩣᩁᩮ ᨧ ᩅᩥᨽᩪᩈᨶᩮ.

ᩅᩮᩣᩉᩣᩁᩈ᩠ᨾᩥᨬ᩠ᨧ ᨮᨸᨶᩮ, ᨸᨬ᩠ᨬᨲ᩠ᨲᩥ’ᨲ᩠ᨳᩦ ᨸᨠᩣᩈᨶᩮ;

ᨸᨭᩥᨽᩣᨶᩴ ᨲᩩ ᨸᨬ᩠ᨬᩣᨿᩴ, ᩏᨸᨭ᩠ᨮᩥᨲ ᨣᩥᩁᩣᨿ ᨧ.

ᩅᨧᨶᩣᩅᨿᩅᩮ ᨾᩪᩃᩮ, ᨠᨳᩥᨲᩮᩣ ᩉᩮᨲᩩ ᨠᩣᩁᨱᩮ;

ᩏᨴᩁᩮ ᨲᩩ ᨲᨳᩣ ᨸᩣᨧᩣ, ᨶᩃᩈ᩠ᨾᩥᩴ ᨣᩉᨱᩦ’ᨲ᩠ᨳᩥᨿᩴ.

ᨸᩥᨿᩮᩣ ᨽᨲ᩠ᨲᩁᩥ, ᨩᩣᨿᩣᨿᩴ, ᨸᩥᨿᩣ, ᩍᨭ᩠ᨮᩮ ᨸᩥᨿᩮᩣ ᨲᩥᩈᩩ;

ᨿᨾᩁᩣᨩᩮ ᨲᩩ ᨿᩩᨣᩊᩮ, ᩈᩴᨿᨾᩮ ᨧ ᨿᨾᩮᩣ ᨽᩅᩮ.

ᨾᩩᨴ᩠ᨴᩥᨠᩔ ᨧ ᨸᩩᨸ᩠ᨹᩔ, ᩁᩈᩮ ᨡᩩᨴ᩠ᨴᩮ ᨾᨵᩪ’ᩁᩥᨲᩴ;

ᩏᩃ᩠ᩃᩮᩣᨧᩮ ᨲᩩ ᨧ ᩅᩥᨲ᩠ᨳᩣᩁᩮ, ᩅᩥᨲᩣᨶᩴ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ.

ᩋᨸᩅᨣ᩠ᨣᩮ ᨧ ᩈᩃᩥᩃᩮ, ᩈᩩᨵᩣᨿᩴ ᩋᨾᨲᩴ ᨾᨲᩴ;

ᨾᩮᩣᩉᩮ ᨲᩩ ᨲᩥᨾᩥᩁᩮ ᩈᨦ᩠ᨡ᩠ᨿᩣ, ᨣᩩᨱᩮ ᨲᨾ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.

ᨡᩁᩮ ᨧᩣ’ᨠᩣᩁᩥᨿᩮ ᨲᩦᩈᩩ, ᩁᩈᨾ᩠ᩉᩥ ᨸᩩᩁᩥᩈᩮ ᨠᨭᩩ;

ᨸᨱ᩠ᨯᨠᩮ ᩈᩩᨠᨲᩮ, ᨸᩩᨬ᩠ᨬᩴ, ᨾᨶᩩᨬ᩠ᨬᩮ ᨸᩅᨶᩮ ᨲᩥᩈᩩ.

ᩁᩩᨠ᩠ᨡᩮᩣ ᨴᩩᨾᨾ᩠ᩉᩥ, ᨹᩁᩩᩈᩣ, ᩈᩥᨶᩥᨴ᩠ᨵᩮᩈᩩ ᨧ ᩈᩮᩣ ᨲᩥᩈᩩ;

ᩏᨸ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᨲᩩ ᩉᩮᨲᩩᨾ᩠ᩉᩥ, ᩈᨦ᩠ᨣᩮ ᩈᩩᨠ᩠ᨠᩮ ᨧ ᩈᨾ᩠ᨽᩅᩮᩣ.

ᨶᩥᨾᩥᨲ᩠ᨲᩴ ¶ ᨠᩣᩁᨱᩮ ᩅᩩᨲ᩠ᨲᩴ, ᩋᨦ᩠ᨣᨩᩣᨲᩮ ᨧ ᩃᨬ᩠ᨨᨶᩮ;

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

ᩅᩮᨴᩮ ᨧ ᨾᨶ᩠ᨲᨶᩮ ᨾᨶ᩠ᨲᩮᩣ, ᨾᨶ᩠ᨲᩣ ᨸᨬ᩠ᨬᩣᨿ ᨾᩩᨧ᩠ᨧᨲᩮ;

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

ᩋᩁᩩᨱᩮᩣ ᩁᩴᩈᩥᨽᩮᨴᩮ ᨧᩣ, ᨻ᩠ᨿᨲ᩠ᨲᩁᩣᨣᩮ ᨧ ᩃᩮᩣᩉᩥᨲᩮ;

ᩋᨶᩩᨻᨶ᩠ᨵᩮᩣ ᨲᩩ ᨸᨠᨲᩣ, ᨶᩥᩅᨲ᩠ᨲᩮ ᨶᩔᨶᨠ᩠ᨡᩁᩮ.

ᩋᩅᨲᩣᩁᩮᩣ’ᩅᨲᩁᨱᩮ, ᨲᩥᨲ᩠ᨳᨾ᩠ᩉᩥ ᩅᩥᩅᩁᩮ ᨸ᩠ᨿᨳ;

ᩌᨠᩣᩁᩮᩣ ᨠᩣᩁᨱᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩈᨱ᩠ᨮᩣᨶᩮ ᩍᨦ᩠ᨣᩥᨲᩮᨸᩥ ᨧ.

ᩈᩩᨴ᩠ᨴᩥᨲ᩠ᨳᩥ ᨲᨶᨿᩮ ᨡᨲ᩠ᨲᩣ, ᩏᨣ᩠ᨣᩮᩣ, ᨲᩥᨻ᩠ᨻᨾ᩠ᩉᩥ ᩈᩮᩣ ᨲᩥᩈᩩ;

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

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

ᨠᩩᩉᨶᩣ ᨠᩪᨭᨧᩁᩥᨿᩣᨿᩴ, ᨠᩩᩉᨶᩮᩣ ᨠᩩᩉᨠᩮ ᨲᩥᩈᩩ.

ᨠᨸᩮᩣᨲᩮᩣ ᨸᨠ᩠ᨡᩥᨽᩮᨴᩮ ᨧ, ᨴᩥᨭ᩠ᨮᩮᩣ ᨸᩣᩁᩣᩅᨲᩮ ᨳ ᨧ;

ᩈᩣᩁᨴᩮᩣ ᩈᩣᩁᨴᨻ᩠ᨽᩪᨲᩮ, ᩋᨸᨣᨻ᩠ᨽᩮ ᨾᨲᩮᩣ ᨲᩥᩈᩩ.

ᨲᩦᩈᩩ ᨡᩁᩮ ᨧ ᨠᨮᩥᨶᩮ, ᨠᨠ᩠ᨠᩈᩮᩣ ᩈᩣᩉᩈᨸ᩠ᨸᩥᨿᩮ [ᩈᩣᩉᩈᨸ᩠ᨸᩥᨿᩮ=ᩈᩣᩉᩈ+ᩋᨸ᩠ᨸᩥᨿᩮ (ᨭᩦ.)];

ᩋᨠᩣᩁᩥᨿᩮ ᨲᩩ ᨣᩩᨿ᩠ᩉᨦ᩠ᨣᩮ, ᨧᩦᩁᩮ ᨠᩮᩣᨸᩦᨶ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᨾᩥᨣᨽᩮᨴᩮ ᨸᨭᩣᨠᩣᨿᩴ, ᨾᩮᩣᨧᩮ ᨧ ᨠᨴᩃᩦ’ᨲ᩠ᨳᩥᨿᩴ;

ᨴᨠ᩠ᨡᩥᨱᩣ ᨴᩣᨶᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᩅᩣᨾᨲᩮᩣ’ᨬ᩠ᨬᨾ᩠ᩉᩥ ᨴᨠ᩠ᨡᩥᨱᩮᩣ.

ᨴᩩᨲᩥᨿᩣ ᨽᩁᩥᨿᩣᨿᨬ᩠ᨧ, ᨴ᩠ᩅᩥᨶ᩠ᨶᩴ ᨸᩪᩁᨱᩥᨿᩴ ᨾᨲᩣ;

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

ᨽᩅᨶᩥᨣ᩠ᨣᨾᨶᩮ ᨿᩣᨶᩮ, ᨴ᩠ᩅᩣᩁᩮ ᨶᩥᩔᩁᨱᩴ ᩈᩥᨿᩣ;

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

ᩋᨸᩅᨣ᩠ᨣᩮ ᩅᩥᨶᩣᩈᩮ ᨧ, ᨶᩥᩁᩮᩣᨵᩮᩣ ᩁᩮᩣᨵᨶᩮ ᨸ᩠ᨿᨳ;

ᨽᨿᩮ ᨸᨭᩥᨽᨿᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨲᩥᩃᩥᨦ᩠ᨣᩴ ᨲᩴ ᨽᨿᩴᨠᩁᩮ.

ᨸᩥᨭᨠᩴ ᨽᩣᨩᨶᩮ ᩅᩩᨲ᩠ᨲᩴ, ᨲᨳᩮᩅ ᨸᩁᩥᨿᨲ᩠ᨲᩥᨿᩴ;

ᨩᩁᩣᩈᩥᨳᩥᩃᨧᨾ᩠ᨾᩈ᩠ᨾᩥᩴ, ᩏᨴᩁᨦ᩠ᨣᩮ ᨾᨲᩣ ᩅᩃᩥ.

ᨽᩥᨶ᩠ᨶᩴ ᩅᩥᨴᩣᩁᩥᨲᩮ’ᨬ᩠ᨬᩈ᩠ᨾᩥᩴ, ᨶᩥᩔᩥᨲᩮ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩴ;

ᩏᨸᨩᩣᨸᩮ ᨾᨲᩮᩣ ᨽᩮᨴᩮᩣ, ᩅᩥᩈᩮᩈᩮ ᨧ ᩅᩥᨴᩣᩁᨱᩮ.

ᨾᨱ᩠ᨯᩃᩴ ¶ ᨣᩣᨾᩈᨶ᩠ᨴᩮᩣᩉᩮ, ᨻᩥᨾ᩠ᨻᩮ ᨸᩁᩥᨵᩥᩁᩣᩈᩥᩈᩩ;

ᩌᨱᩣᨿ ᨾᩣᨣᨾᩮ ᩃᩮᨡᩮ; ᩈᩣᩈᨶᩴ ᩋᨶᩩᩈᩣᩈᨶᩮ.

ᩋᨣ᩠ᨣᩮ ᨲᩩ ᩈᩥᨡᩁᩴ ᨧᩣ’ᨿᩮᩣ, ᨾᨿᩅᩥᨩ᩠ᨫᨶᨠᨱ᩠ᨭᨠᩮ;

ᨣᩩᨱᩩᨠ᩠ᨠᩴᩈᩮ ᨧ ᩅᩥᨽᩅᩮ, ᩈᨾ᩠ᨸᨲ᩠ᨲᩥ ᨧᩮᩅ ᩈᨾ᩠ᨸᨴᩣ.

ᨽᩪᨡᨶ᩠ᨲᩦᩈᩩ ᨡᨾᩣ, ᨿᩮᩣᨣ᩠ᨿᩮ, ᩉᩥᨲᩮ ᩈᨠ᩠ᨠᩮ [ᨿᩩᨲ᩠ᨲᩮ (ᨭᩦ.) ᪑᪐᪐᪑-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨡᨾᩮᩣ ᨲᩥᩈᩩ;

ᩋᨴ᩠ᨵᩮᩣ ᨽᩣᨣᩮ ᨸᨳᩮ ᨠᩣᩃᩮ, ᩑᨠᩴᩈᩮ’ᨴ᩠ᨵᩮᩣ’ᨻ᩠ᨿᨿᩴ ᨽᩅᩮ;

ᩋᨳᩮᩣ ᨠᩁᩦᩈᩴ ᩅᨧ᩠ᨧᩈ᩠ᨾᩥᩴ, ᩅᩩᨧ᩠ᨧᨲᩮ ᨧᨲᩩᩁᨾ᩠ᨻᨱᩮ.

ᩏᩈᨽᩮᩣ’ᩈᨵ ᨣᩮᩣ [ᩏᩈᨽᩮᩣ ᩏᩈᨽᩮ (ᨭᩦ.)] ᩈᩮᨭ᩠ᨮᩮ, ᩈᩪ’ᩈᨽᩴ ᩅᩦᩈᨿᨭ᩠ᨮᩥᨿᩴ;

ᩈᩮᨲᩩᩈ᩠ᨾᩥᩴ ᨲᨶ᩠ᨲᩥ ᨸᨶ᩠ᨲᩦᩈᩩ, ᨶᩣᩁᩥᨿᩴ ᨸᩣᩊᩥ ᨠᨳ᩠ᨿᨲᩮ.

ᨠᨭᩮᩣ ᨩᨿᩮ’ᨲ᩠ᨳᩥᨶᩥᨾᩥᨲ᩠ᨲᩮ, ᨠᩥᩃᨬ᩠ᨩᩮ ᩈᩮᩣ ᨠᨲᩮ ᨲᩥᩈᩩ;

ᨾᩉᩥᨿᩴ ᨩᨣᨲᩦ ᩅᩩᨲ᩠ᨲᩣ, ᨾᨶ᩠ᨴᩥᩁᩣᩃᩥᨶ᩠ᨴᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩥ.

ᩅᩥᨲᨠ᩠ᨠᩮ ᨾᨳᩥᨲᩮ ᨲᨠ᩠ᨠᩮᩣ, ᨲᨳᩣ ᩈᩪᨧᩥᨹᩃᩮ ᨾᨲᩮᩣ;

ᩈᩩᨴᩔᨶᩴ ᩈᨠ᩠ᨠᨸᩩᩁᩮ, ᨲᩦᩈᩩ ᨲᩴ ᨴᩩᨴ᩠ᨴᩈᩮ’ᨲᩁᩮ.

ᨴᩦᨸᩮᩣ’ᨶ᩠ᨲᩁᩦᨸ ᨸᨩ᩠ᨩᩮᩣᨲ, ᨸᨲᩥᨭ᩠ᨮᩣ ᨶᩥᨻ᩠ᨻᩩᨲᩦᩈᩩ ᨧ;

ᨻᨴ᩠ᨵᨶᩥᩔᩥᨲ ᩈᩮᨲᩮᩈᩩ, ᨲᩦᩈᩩ ᨲᩴ ᨾᩥᩉᩥᨲᩮ ᩈᩥᨲᩴ.

ᨳᩥᨿᩴ ᨸᨩᩣᨸᨲᩥ ᨴᩣᩁᩮ, ᨻᩕᩉ᩠ᨾᩮ ᨾᩣᩁᩮ ᩈᩩᩁᩮ ᨸᩩᨾᩮ;

ᩅᩣᩈᩩᨴᩮᩅᩮ’ᨶ᩠ᨲᨠᩮ ᨠᨱ᩠ᩉᩮᩣ, ᩈᩮᩣ ᨸᩣᨸᩮ ᩋᩈᩥᨲᩮ ᨲᩥᩈᩩ.

ᩏᨸᨧᩣᩁᩮᩣ ᩏᨸᨭ᩠ᨮᩣᨶᩮ, ᩌᩈᨶ᩠ᨶᩮ ᩋᨬ᩠ᨬᩁᩮᩣᨸᨶᩮ;

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

ᩅᨩ᩠ᨩᨶᩮ ᨸᩁᩥᩉᩣᩁᩮᩣ ᨧ, ᩈᨠ᩠ᨠᩣᩁᩮ ᨧᩮᩅ ᩁᨠ᩠ᨡᨱᩮ;

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

ᩈᩩᩈᩩᨠᩮᩣ ᩈᩩᩈᩩᨾᩣᩁᩮ ᨧ, ᨻᩣᩃᨠᩮ ᨧ ᩏᩃᩪᨸᩥᨶᩥ;

ᩍᨶ᩠ᨴᩦᩅᩁᩴ ᨾᨲᩴ ᨶᩦᩃᩩ, ᨸ᩠ᨸᩃᩮ ᩏᨴ᩠ᨴᩣᩃᨸᩣᨴᨸᩮ.

ᩋᩈᨶᩮᩣ ᨸᩥᨿᨠᩮ ᨠᨱ᩠ᨯᩮ, ᨽᨠ᩠ᨡᨱᩮ ᨡᩥᨸᨶᩮ’ ᩈᨶᩴ;

ᨿᩩᨣᩮ’ᨵᩥᨠᩣᩁᩮ [ᩅᩥᨠᩣᩁᩮ (ᨭᩦ.)] ᩅᩦᩁᩥᨿᩮ, ᨸᨵᩣᨶᩮ ᨧᩣ’ᨶ᩠ᨲᩥᨠᩮ ᨵᩩᩁᩮᩣ.

ᨠᩣᩊᩮ ᨧ ᨽᨠ᩠ᨡᩥᨲᩮ ᨲᩦᩈᩩ, ᩃᩅᩥᨲ᩠ᨲᩮ ᩋᩈᩥᨲᩮᩣ ᨸᩩᨾᩮ;

ᨸᩅᩣᩁᨱᩣ ᨸᨭᩥᨠ᩠ᨡᩮᨸᩮ, ᨠᨳᩥᨲᩣ’ᨩ᩠ᨫᩮᩈᨶᩣᨿ ᨧ.

ᩏᨾ᩠ᨾᩣᩁᩮ ¶ ᩑᩈᩥᨠᨲ᩠ᨳᨾ᩠ᨽᩮ, ᩍᨶ᩠ᨴᨡᩦᩃᩮᩣ ᨾᨲᩮᩣ ᨳ ᨧ;

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

ᨵᨬ᩠ᨬᩴ ᩈᩣᩃ᩠ᨿᩣᨴᩥᨠᩮ ᩅᩩᨲ᩠ᨲᩴ, ᨵᨬ᩠ᨬᩮᩣ ᨸᩩᨬ᩠ᨬᩅᨲᩥ ᨲ᩠ᨲᩥᩈᩩ;

ᨸᩣᨱᩥ ᩉᨲ᩠ᨳᩮ ᨧ ᩈᨲ᩠ᨲᩮ ᨽᩪ, ᩈᨱ᩠ᩉᨠᩁᨱᩥᨿᩴ ᨾᨲᩮᩣ.

ᨲᩦᩈᩩ ᨸᩦᨲᩴ ᩉᩃᩥᨴ᩠ᨿᩣᨽᩮ, ᩉᨭ᩠ᨮᩮ ᨧ ᨸᩣᨿᩥᨲᩮ ᩈᩥᨿᩣ;

ᨻ᩠ᨿᩪᩉᩮᩣ ᨶᩥᨻ᩠ᨻᩥᨴ᩠ᨵᩁᨧ᩠ᨨᩣᨿᩴ, ᨻᩃᨶ᩠ᨿᩣᩈᩮ ᨣᨱᩮ ᨾᨲᩮᩣ.

ᩃᩮᩣᩉᩥᨲᩣᨴᩥᨾ᩠ᩉᩥ ᩃᩮᩣᨽᩮ ᨧ, ᩁᩣᨣᩮᩣ ᨧ ᩁᨬ᩠ᨩᨶᩮ ᨾᨲᩮᩣ;

ᨸᨴᩁᩮᩣ ᨹᩃᨠᩮ ᨽᨦ᩠ᨣᩮ, ᨸᩅᩩᨴ᩠ᨵ ᨴᩁᩥᨿᩴ ᨸᩥᨧ.

ᩈᩥᨦ᩠ᨥᩣᨭᨠᩴ ᨠᩈᩮᩁᩩᩔ, ᨹᩃᩮ, ᨾᨣ᩠ᨣᩈᨾᩣᨣᨾᩮ;

ᨻᩉᩩᩃᩣᨿᨬ᩠ᨧ ᨡᩮᩊᨾ᩠ᩉᩥ, ᩑᩊᩣ, ᨴᩮᩣᩈᩮ’ᩊ ᨾᩦᩁᩥᨲᩴ.

ᩌᨵᩣᩁᩮᩣ ᨧᩣ’ᨵᩥᨠᩁᨱᩮ, ᨸᨲ᩠ᨲᩣᨵᩣᩁᩮ’ ᩃᩅᩣᩃᨠᩮ;

ᨠᩣᩁᩮᩣ’ ᨣᨽᩮᨴᩮ ᩈᨠ᩠ᨠᩣᩁᩮ, ᨠᩣᩁᩣ ᨲᩩ ᨻᨶ᩠ᨵᨶᩣᩃᨿᩮ.

ᨠᩁᨠᩣ ᨾᩮᨥᨸᩣᩈᩣᨱᩮ, ᨠᩁᨠᩮᩣ ᨠᩩᨱ᩠ᨯᩥᨠᩣᨿ ᨧ;

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

ᨨᩥᨴ᩠ᨴᩴ ᩁᨶ᩠ᨵᨬ᩠ᨧ ᩅᩥᩅᩁᩴ, ᩈᩩᩈᩥᩁᩮ ᨴᩪᩈᨶᩮᨸᩥ ᨧ;

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

ᨶᩥᩈᩮᨵᩮ ᩅᩣᩁᨱᩴ, ᩉᨲ᩠ᨳᩥ, ᩃᩥᨦ᩠ᨣ ᩉᨲ᩠ᨳᩦᩈᩩ ᩅᩣᩁᨱᩮᩣ;

ᨴᩣᨶᩴ ᨧᩣᨣᩮ ᨾᨴᩮ ᩈᩩᨴ᩠ᨵᩮ, ᨡᨱ᩠ᨯᨶᩮ ᩃᩅᨶᩮ ᨡᨿᩮ.

ᨾᨶᩮᩣᨲᩮᩣᩈᩮ ᨧ ᨶᩥᨻ᩠ᨻᩣᨶᩮ, ᨲ᩠ᨳᨦ᩠ᨣᨾᩮ ᨶᩥᨻ᩠ᨻᩩᨲᩥ’ᨲ᩠ᨳᩥᨿᩴ;

ᨶᩮᨣᨾᩮᩣ ᨶᩥᨣᨾᩩᨻ᩠ᨽᩪᨲᩮ, ᨲᨳᩣ’ᨸᨱᩮᩣᨸᨩᩦᩅᩥᨶᩥ.

ᩉᩁᩥᨲᩈ᩠ᨾᩥᨬ᩠ᨧ ᨸᨱ᩠ᨱᩮ ᨧ, ᨸᩃᩣᩈᩮᩣ ᨠᩥᩴ ᩈᩩᨠᨴ᩠ᨴᩩᨾᩮ;

ᨸᨠᩣᩈᩮᩣ ᨸᩣᨠᨭᩮᨲᩦᩈᩩ, ᩌᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ ᨸᩩᨾᩮ ᨾᨲᩮᩣ.

ᨸᨠ᩠ᨠᩴ ᨹᩃᨾ᩠ᩉᩥ, ᨲᩴ ᨶᩣᩈᩩ, ᨾ᩠ᨾᩩᨡᩮ [ᨶᩣᩈᨾᩩᨡᩮ (ᨠ.)] ᨸᩁᩥᨱᨲᩮ ᨲᩥᩈᩩ;

ᨸᩥᨱ᩠ᨯᩮᩣ ᩌᨩᩦᩅᨶᩮ ᨴᩮᩉᩮ, ᨸᩥᨱ᩠ᨯᨶᩮ ᨣᩮᩣᩊᨠᩮ ᨾᨲᩮᩣ.

ᩅᨭ᩠ᨭᩮᩣ ᨸᩁᩥᨻ᩠ᨻᨿᩮ ᨠᨾ᩠ᨾᩣ, ᨴᩥᨠᩮ, ᩈᩮᩣ ᩅᨭ᩠ᨭᩩᩃᩮ ᨲᩥᩈᩩ;

ᨸᨧ᩠ᨧᩣᩉᩣᩁᩮ ᨸᨭᩥᩉᩣᩁᩮᩣ, ᨴ᩠ᩅᩣᩁᩮ ᨧ ᨴ᩠ᩅᩣᩁᨸᩣᩃᨠᩮ.

ᨶᩣᩁᩥᨿᩴ ᨽᩦᩁᩩ ᨠᨳᩥᨲᩣ, ᨽᩦᩁᩩᨠᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;

ᩅᩥᨠᨭᩴ ᨣᩪᨳᨾᩩᨲ᩠ᨲᩣᨴᩮᩣ, ᩅᩥᨠᨭᩮᩣ ᩅᩥᨠᨲᩮ ᨲᩥᩈᩩ.

ᩅᩣᨾᩴ ¶ ᩈᨻ᩠ᨿᨾ᩠ᩉᩥ, ᨲᩴ ᨧᩣᩁᩩ, ᩅᩥᨸᩁᩦᨲᩮᩈᩩ ᨲᩦᩈ᩠ᩅ’ᨳ;

ᩈᨦ᩠ᨡ᩠ᨿᩣᨽᩮᨴᩮ ᩈᩁᨻ᩠ᨿᩮ ᨧ, ᨧᩥᩉᨱᩮ ᩃᨠ᩠ᨡ ᨾᩩᨧ᩠ᨧᨲᩮ.

ᩈᩮᨱᩦ’ᨲ᩠ᨳᩦ ᩈᨾᩈᩥᨸ᩠ᨸᩦᨶᩴ, ᨣᨱᩮ ᨧᩣ’ᩅᩃᩥᨿᩴ ᨸᩥᨧ;

ᩈᩩᨵᩣᨿᩴ ᨵᩪᩃᩥᨿᩴ ᨧᩩᨱ᩠ᨱᩮᩣ, ᨧᩩᨱ᩠ᨱᨬ᩠ᨧ ᩅᩣᩈᨧᩩᨱ᩠ᨱᨠᩮ.

ᨩᩮᨲᨻ᩠ᨻᩮ’ᨲᩥᨸ᩠ᨸᩈᨲ᩠ᨳᩮ’ᨲᩥ, ᩅᩩᨴ᩠ᨵᩮ ᨩᩮᨿ᩠ᨿᩴ ᨲᩥᩈᩪ’ᩁᩥᨲᩴ;

ᩋᨻ᩠ᨽᩩᨲᩮᩣ’ᨧ᩠ᨨᩁᩥᨿᩮ ᨲᩦᩈᩩ, ᨸᨱᩮ ᨧᩮᩅᩣ’ᨻ᩠ᨽᩩᨲᩮᩣ ᨸᩩᨾᩮ;

ᨾᩮᨧᨠᩮᩣ ᨸᩩᨧ᩠ᨨᨾᩪᩃᨾ᩠ᩉᩥ, ᨠᨱ᩠ᩉᩮᨸᩥ ᨾᩮᨧᨠᩮᩣ ᨲᩥᩈᩩ.

ᩅᩈᩅᨲ᩠ᨲᩦ ᨸᩩᨾᩮ ᨾᩣᩁᩮ, ᩅᩈᩅᨲ᩠ᨲᩣᨸᨠᩮ ᨲᩥᩈᩩ;

ᩈᨾ᩠ᨽᩅᩮ ᨧᩣ’ᩈᩩᨧᩥ ᨸᩩᨾᩮ, ᩋᨾᩮᨩ᩠ᨫᩮ ᨲᩦᩈᩩ ᨴᩥᩔᨲᩥ.

ᩋᨧ᩠ᨨᩮᩣ ᩍᨠ᩠ᨠᩮ ᨸᩩᨾᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨸᩈᨶ᩠ᨶᨾ᩠ᩉᩥ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;

ᨻᩊᩥᩈᩮ ᩈᩮᩃᨽᩮᨴᩮ ᨧ, ᩅᨦ᩠ᨠᩮᩣ, ᩈᩮᩣ ᨠᩩᨭᩥᩃᩮ ᨲᩥᩈᩩ.

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

ᨧᨶ᩠ᨴᨣ᩠ᨣᩣᩉᩣᨴᩥᨠᩮ ᨧᩮᩅᩩ, ᨸ᩠ᨸᩣᨴᩮᩣ ᩏᨸ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᨸᩥᨧ;

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

ᩁᩩᨵᩥᩁᩮ ᩃᩮᩣᩉᩥᨲᩴ ᩅᩩᨲ᩠ᨲᩴ, ᩁᨲ᩠ᨲᨾ᩠ᩉᩥ ᩃᩮᩣᩉᩥᨲᩮᩣ ᨲᩥᩈᩩ;

ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᩮ ᨸᩩᨾᩮ ᨾᩩᨴ᩠ᨵᩣ, ᨾᩩᨴ᩠ᨵᩮᩣ ᨾᩪᩊ᩠ᩉᩮ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.

ᩁᨭ᩠ᨮᨾ᩠ᩉᩥ ᩅᩥᨩᩥᨲᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨩᩥᨲᩮ ᨧ ᩅᩥᨩᩥᨲᩮᩣ ᨲᩥᩈᩩ;

ᨸᩁᩥᨲ᩠ᨲᩴ ᨲᩩ ᨸᩁᩥᨲ᩠ᨲᩣᨱᩮ, ᨸᩁᩥᨲ᩠ᨲᩮᩣ ᨲᩦᩈᩩ ᩋᨸ᩠ᨸᨠᩮ.

ᨠᩩᨾ᩠ᨽᨱ᩠ᨯᩮᩣ ᨴᩮᩅᨽᩮᨴᩮ ᨧ, ᨴᩥᩔᨲᩥ ᩅᩃ᩠ᩃᩥᨩᩣᨲᩥᨿᩴ;

ᨧᨲᩩᨲ᩠ᨳᩴᩈᩮ ᨸᨴᩮ ᨸᩣᨴᩮᩣ, ᨸᨧ᩠ᨧᨶ᩠ᨲᩈᩮᩃᩁᩴᩈᩥᩈᩩ.

ᩅᨦ᩠ᨣᩮᩣ ᩃᩮᩣᩉᨶ᩠ᨲᩁᩮ ᩅᨦ᩠ᨣᩣ, ᨴᩮᩈᩮ ᨸᩩᨾᩮ ᨻᩉᩩᨾ᩠ᩉᩥ ᨧ;

ᨠᨾ᩠ᨾᩣᩁᨽᨱ᩠ᨯᨽᩮᨴᩮ ᨧ, ᨡᨭᨠᩮ ᨾᩩᨭ᩠ᨮᩥ ᨧ ᨴ᩠ᩅᩥᩈᩩ.

ᩋᨾ᩠ᨻᨱᩴ ᨴᩮᩣᨱᩥᨿᩴ ᨧᩮ’ᨠᩣ, ᨴᩈᨴᩮᩣᨱᨸ᩠ᨸᨾᩣᨱᨠᩮ;

ᩋᨵᩥᨭ᩠ᨮᩥᨲᩥᨿ ᨾᩣᨵᩣᩁᩮ, ᨮᩣᨶᩮ’ᨵᩥᨭ᩠ᨮᩣᨶ ᨾᩩᨧ᩠ᨧᨲᩮ.

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

ᩏᨸᨴ᩠ᨴᩅᩮ ᩏᨸᩈᨣ᩠ᨣᩮᩣ, ᨴᩥᩔᨲᩥ ᨸᩣᨴᩥᨠᩮᨸᩥ ᨧ.

ᩅᨠ᩠ᨠᩴ ¶ ᨠᩮᩣᨭ᩠ᨮᩣᩈᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᩅᨠ᩠ᨠᩮᩣ ᩅᨦ᩠ᨠᩮ ᨲᩥᩈᩩ’ᨧ᩠ᨧᨲᩮ;

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

ᩈᨾᩣᨵᩥᨾ᩠ᩉᩥ ᨸᩩᨾᩮ’ᨠᨣ᩠ᨣᩮᩣ, ᨶᩣᨠᩩᩃᩮ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;

ᨸᨩ᩠ᨩᩴ ᩈᩥᩃᩮᩣᨠᩮ, ᨸᨩ᩠ᨩᩮᩣ’ᨴ᩠ᨵᩮ, ᨸᨩ᩠ᨩᩮᩣ ᨸᩣᨴᩉᩥᨲᩮ ᨲᩥᩈᩩ.

ᨠᨲᨠᩮᩣ ᩁᩩᨠ᩠ᨡᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᨠᨲᨠᩮᩣ ᨠᩥᨲ᩠ᨲᩥᨾᩮ ᨲᩥᩈᩩ;

ᩅᩥᨵᩮᨿ᩠ᨿᩮ ᩋᩔᩅᩮᩣ ᨲᩦᩈᩩ, ᨸᩩᨻ᩠ᨻᨾ᩠ᩉᩦ ᨸᩩᩁᩥᩈᩮ ᩈᩥᨿᩣ.

ᨠᩃ᩠ᨿᩣᨱᩮ ᨠᨳᩥᨲᩴ ᨡᩮᨾᩴ, ᨲᩦᩈᩩ ᩃᨴ᩠ᨵᨲ᩠ᨳᩁᨠ᩠ᨡᨱᩮ;

ᩋᨳᩮᩣ ᨶᩥᨿᩮᩣᨩᨶᩮ ᩅᩩᨲ᩠ᨲᩴ, ᨠᩣᩁᩥᨿᩮᨸᩥ ᨸᨿᩮᩣᨩᨶᩴ.

ᩋᩔᨲ᩠ᨳᩮᩣ ᨲᩦᩈᩩ ᩋᩔᩣᩈ, ᨸ᩠ᨸᨲ᩠ᨲᩮ, ᨻᩮᩣᨵᩥᨴ᩠ᨴᩩᨾᩮ ᨸᩩᨾᩮ;

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

ᩅᩥᩃᨣ᩠ᨣᩮᩣ ᨲᩦᩈᩩ ᩃᨣ᩠ᨣᩈ᩠ᨾᩥᩴ, ᨸᩩᨾᩮ ᨾᨩ᩠ᨫᨾ᩠ᩉᩥ ᨴᩥᩔᨲᩥ;

ᩋᨯ᩠ᨰᩮᩣ ᨲ᩠ᩅᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨽᩣᨣᩮ, ᨵᨶᩥᨾ᩠ᩉᩥ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.

ᨠᨭ᩠ᨮᩴ ᨴᩣᩁᩩᨾ᩠ᩉᩥ, ᨲᩴ ᨠᩥᨧ᩠ᨨᩮ, ᨣᩉᨶᩮ ᨠᩈᩥᨲᩮ ᨲᩥᩈᩩ;

ᩈᩈᨶ᩠ᨲᩣᨶᩮ ᨧ ᩅᩥᩈᨿᩮ, ᨣᩮᩣᨧᩁᩮ’ ᨩ᩠ᨫᨲ᩠ᨲ ᨾᩩᨧ᩠ᨧᨲᩮᨲᩥ.

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

ᩅᨭᨻ᩠ᨿᩣᨾᩮᩈᩩ ᨶᩥᨣᩕᩮᩣᨵᩮᩣ, ᨵᨦ᩠ᨠᩮᩣ ᨲᩩ ᩅᩣᨿᩈᩮ ᨻᨠᩮ;

ᩅᩣᩁᩮᩣ ᨲ᩠ᩅ’ᩅᩈᩁᩣ’ᩉᩮᩈᩩ, ᨠᩩᨧᩮᨲ᩠ᩅᨻ᩠ᨽᩮ ᨸᨿᩮᩣᨵᩁᩮᩣ.

ᩏᨧ᩠ᨨᨦ᩠ᨣᩮ ᩃᨠ᩠ᨡᨱᩮ ᨧᩣ’ᨦ᩠ᨠᩮᩣ, ᩁᩈ᩠ᨾᩥ’ᨲ᩠ᨳᩦ ᨩᩩᨲᩥ ᩁᨩ᩠ᨩᩩᩈᩩ;

ᩈᩪᩁᩴ’ᩈᩪᩈᩩ ᨸᩩᨾᩮ ᨽᩣᨶᩪ, ᨴᨱ᩠ᨯᩮᩣ ᨲᩩ ᨾᩩᨣ᩠ᨣᩁᩮ ᨴᨾᩮ;

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

ᨾᩥᨣᩮᩣ ᨸᩈᩩ ᨠᩩᩁᩩᨦ᩠ᨣᩮᩈᩩ, ᩏᩃᩪᨠᩥ’ᨶ᩠ᨴᩮᩈᩩ ᨠᩮᩣᩈᩥᨿᩮᩣ.

ᩅᩥᨣ᩠ᨣᩉᩮᩣ ¶ ᨠᩃᩉᩮ ᨠᩣᨿᩮ, ᨸᩩᩁᩥᩈᩮᩣ ᨾᩣᨱᩅ’ᨲ᩠ᨲᩈᩩ;

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

ᨻᩃᩥᩉᨲ᩠ᨳᩴ’ᩈᩪᩈᩩ ᨠᩁᩮᩣ, ᨴᨶ᩠ᨲᩮ ᩅᩥᨸ᩠ᨸᩮ’ᨱ᩠ᨯᨩᩮ ᨴ᩠ᩅᩥᨩᩮᩣ;

ᩅᨲ᩠ᨲᩴ ᨸᨩ᩠ᨩᩣ’ᨶᨶᩣ’ᨧᩣᩁᩮ, ᨵᨬ᩠ᨬᨦ᩠ᨣᩮ ᩈᩩᨡᩩᨾᩮ ᨠᨱᩮᩣ.

ᨳᨾ᩠ᨽᩮᩣ ᨳᩪᨱ ᨩᩊᨲ᩠ᨲᩮᩈᩩ, ᩈᩪᨸᩮᩣ ᨠᩩᨾ᩠ᨾᩣᩈ ᨻ᩠ᨿᨬ᩠ᨩᨶᩮ;

ᨣᨱ᩠ᨯᩮᩣ ᨹᩮᩣᨭᩮ ᨠᨸᩮᩣᩃᨾ᩠ᩉᩥ, ᩋᨣ᩠ᨥᩮᩣ ᨾᩪᩃ᩠ᨿᩮ ᨧ ᨸᩪᨩᨶᩮ.

ᨸᨠᩣᩁᩮᩣ ᨲᩩᩃ᩠ᨿ ᨽᩮᨴᩮᩈᩩ, ᩈᨠᩩᨶ᩠ᨲᩮᩣ ᨽᩣᩈᨸᨠ᩠ᨡᩥᩈᩩ;

ᨽᩣᨣ᩠ᨿᩮ ᩅᩥᨵᩥ ᩅᩥᨵᩣᨶᩮ ᨧ, ᩈᩁᩮ ᨡᨣ᩠ᨣᩮ ᨧ ᩈᩣᨿᨠᩮᩣ.

ᩈᩣᩁᨦ᩠ᨣᩮᩣ ᨧᩣᨲᨠᩮ ᩑᨱᩮ, ᨸᨲ᩠ᨲᩦ ᨲᩩ ᩈᩁᨸᨠ᩠ᨡᩥᩈᩩ;

ᩈᩴᩅᨭ᩠ᨭᩮ ᨸᩃᨿᩮᩣ ᨶᩣᩈᩮ, ᨸᩪᨣᩮᩣ ᨠᨾᩩᨠᩁᩣᩈᩥᩈᩩ.

ᩋᨾᨲᩮ ᨲᩩ ᩈᩩᨵᩣ ᩃᩮᨸᩮ, ᩋᨽᩥᨡ᩠ᨿᩣ ᨶᩣᨾ ᩁᩴᩈᩥᩈᩩ;

ᩈᨲ᩠ᨲᩥ ᩈᩣᨾᨲ᩠ᨳᩥᨿᩮ ᩈᨲ᩠ᨳᩮ, ᨾᩉᩦ ᨶᨩ᩠ᨩᨶ᩠ᨲᩁᩮ ᨽᩩᩅᩥ;

ᨬᩣᨱᩮ ᩃᩣᨽᩮ ᩏᨸᩃᨴ᩠ᨵᩥ, ᨸᩅᩮᨱᩦ ᨠᩩᨳᩅᩮᨱᩥᩈᩩ;

ᨸᩅᨲ᩠ᨲᩥ ᩅᩩᨲ᩠ᨲᩥ ᩅᨲ᩠ᨲᩣᩈᩩ, ᩅᩮᨲᨶᩮ ᨽᩁᨱᩮ ᨽᨲᩥ.

ᩌᨧᩣᩁᩮᨸᩥ ᨾᩁᩥᨿᩣᨴᩣ, ᨽᩪᨲᩥ ᩈᨲ᩠ᨲᩣ ᩈᨾᩥᨴ᩠ᨵᩥᩈᩩ;

ᩈᩮᩣᨸ᩠ᨸᩮ ᨸᨾᩣᨴᩮ ᨲᨶ᩠ᨴᩦ ᨧ, ᨿᩣᨲᩕᩣ ᨣᨾᨶ ᩅᩩᨲ᩠ᨲᩥᩈᩩ.

ᨶᩥᨶ᩠ᨴᩣ ᨠᩩᨧ᩠ᨨᩣ’ᨸᩅᩣᨴᩮᩈᩩ, ᨠᨦ᩠ᨣᩩ ᨵᨬ᩠ᨬ ᨸᩥᨿᨦ᩠ᨣᩩᩈᩩ;

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

ᩍᨧ᩠ᨨᩣᨿᩴ ᨩᩩᨲᩥᨿᩴ ᨠᨶ᩠ᨲᩥ, ᩁᨬ᩠ᨩᨶᩮ ᩈᩪᩁᨲᩮ ᩁᨲᩥ;

ᨣᩮᩉᩮ ᩅᩈᨲᩥ ᩅᩣᩈᩮ ᨳ, ᨶᨴᩦ ᩈᩮᨶᩣᩈᩩ ᩅᩣᩉᩥᨶᩦ.

ᨸᨲ᩠ᨳᩮ ᨶᩣᩊᩮ ᨧ ᨶᩣᩊᩥ’ᨲ᩠ᨳᩦ, ᨣᨱᩮ ᩈᨾᩥᨲᩥ ᩈᨦ᩠ᨣᨾᩮ;

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

ᨸᩣᨱ᩠ᨿᨦ᩠ᨣᩮ ᨶᩣᨽᩥ ᨧᨠ᩠ᨠᨶ᩠ᨲᩮ, ᨿᩣᨧᩮ ᩅᩥᨬ᩠ᨬᨲ᩠ᨲᩥ ᨬᩣᨸᨶᩮ;

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

ᨲᩁᨦ᩠ᨣᩮ ¶ ᨧᩣ’ᨶ᩠ᨲᩁᩮ ᩅᩦᨧᩥ, ᨵᩦᩁᨲ᩠ᨲᩮ ᨵᩣᩁᨱᩮ ᨵᩥᨲᩥ;

ᨽᩪ ᨽᩪᨾᩥᨿᨬ᩠ᨧ ᨽᨾᩩᨠᩮ, ᩈᨴ᩠ᨴᩮ ᩅᩮᨴᩮ ᩈᩅᩮ ᩈᩩᨲᩥ.

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

ᩒᨠᩴ ᨲᩩ ᨶᩥᩔᨿᩮ ᨣᩮᩉᩮ, ᨠᩩᩃᩴ ᨲᩩ ᨣᩮᩣᨲ᩠ᨲᩁᩣᩈᩥᩈᩩ.

ᩉᩮᨾᩮ ᩅᩥᨲ᩠ᨲᩮ ᩉᩥᩁᨬ᩠ᨬᨬ᩠ᨧ, ᨸᨬ᩠ᨬᩣᨱᩴ ᨲ᩠ᩅ’ᨦ᩠ᨠ ᩅᩩᨴ᩠ᨵᩥᩈᩩ;

ᩋᨳᩣ’ᨾ᩠ᨻᩁᨬ᩠ᨧ ᨡᩮ ᩅᨲ᩠ᨳᩮ, ᨣᩩᨿ᩠ᩉᩴ ᩃᩥᨦ᩠ᨣᩮ ᩁᩉᩈ᩠ᨿ’ᨸᩥ.

ᨲᨸᩮᩣ ᨵᨾ᩠ᨾᩮ ᩅᨲᩮ ᨧᩮᩅ, ᨸᩣᨸᩮ ᨲ᩠ᩅᩣ’ᨣᩩᨾ᩠ᩉᩥ ᨠᩥᨻ᩠ᨻᩥᩈᩴ;

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

ᩅᨶᩴ ᩋᩁᨬ᩠ᨬ ᩅᩣᩁᩦᩈᩩ, ᨡᩦᩁᨾ᩠ᩉᩥ ᨲᩩ ᨩᩃᩮ ᨸᨿᩮᩣ;

ᩋᨠ᩠ᨡᩁᩴ ᩃᩥᨸᩥ ᨾᩮᩣᨠ᩠ᨡᩮᩈᩩ, ᨾᩮᨳᩪᨶᩴ ᩈᨦ᩠ᨣᨾᩮ ᩁᨲᩮ.

ᩈᩮᩣᨲᩴ ᨠᨱ᩠ᨱᩮ ᨸᨿᩮᩣᩅᩮᨣᩮ, ᩁᩥᨭ᩠ᨮᩴ ᨸᩣᨸᩣ’ᩈᩩᨽᩮᩈᩩ ᨧ;

ᩌᨣᩩ ᨸᩣᨸᩣ’ᨸᩁᩣᨵᩮᩈᩩ, ᨠᩮᨲᩩᨾ᩠ᩉᩥ ᨧᩥᩉᨶᩮ ᨵᨩᩮᩣ.

ᨣᩮᩣᨸᩩᩁᩴ ᨴ᩠ᩅᩣᩁᨾᨲ᩠ᨲᩮᨸᩥ, ᨾᨶ᩠ᨴᩥᩁᩴ ᨶᨣᩁᩮ ᨥᩁᩮ;

ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩣ ᨸᩁᨾᩥᨲᩮᩣ, ᨻ᩠ᨿᨲ᩠ᨲᩮᩣ ᨲᩩ ᨸᨱ᩠ᨯᩥᨲᩮ ᨹᩩᨭᩮ.

ᩅᩃ᩠ᩃᨽᩮᩣ ᨴᨿᩥᨲᩮ’ᨩ᩠ᨫᨠ᩠ᨡᩮ, ᨩᩃᩮ ᨳᩪᩃᩮᩣ ᨾᩉᨲ᩠ᨿᨸᩥ;

ᨻᩦᨽᨧ᩠ᨨᩮᩣ ᩅᩥᨠᨲᩮ ᨽᩦᨾᩮ, ᨠᩮᩣᨾᩃᩮ ᨲᩥᨡᩥᨱᩮ ᨾᩩᨴᩩ;

ᩍᨭ᩠ᨮᩮ ᨧ ᨾᨵᩩᩁᩮ ᩈᩣᨴᩩ, ᩈᩣᨴᩩᨾ᩠ᩉᩥ ᨾᨵᩩᩁᩮᩣ ᨸᩥᨿᩮ.

ᩈᩥᨲᩮ ᨲᩩ ᩈᩩᨴ᩠ᨵᩮ ᩒᨴᩣᨲᩮᩣ, ᨴ᩠ᩅᩥᨩᩥᩅ᩠ᩉᩮᩣ ᩈᩪᨧᨠᩣ’ᩉᩥᩈᩩ;

ᩈᨠ᩠ᨠᩮ ᩈᨾᨲ᩠ᨳᩮᩣ ᩈᨾ᩠ᨻᨶ᩠ᨵᩮ, ᩈᨾᨲ᩠ᨲᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩣ’ᨡᩥᩃᩮ.

ᩈᩩᨴ᩠ᨵᩮᩣ ᨠᩮᩅᩃ ᨸᩪᨲᩮᩈᩩ, ᨩᩥᨥᨬ᩠ᨬᩮᩣ’ᨶ᩠ᨲᩣ’ᨵᨾᩮᩈᩩ ᨧ;

ᨸᩮᩣᨱᩮᩣ’ᨸᨶᨲ ᨶᩥᨶ᩠ᨶᩮᩈᩩ, ᩋᨬ᩠ᨬ ᨶᩦᨧᩮᩈᩩ ᨧᩮ’ᨲᩁᩮᩣ.

ᩈᩩᨧᩥ ᩈᩩᨴ᩠ᨵᩮ ᩈᩥᨲᩮ ᨸᩪᨲᩮ, ᨸᩮᩈᩃᩮᩣ ᨴᨠ᩠ᨡᨧᩣᩁᩩᩈᩩ;

ᩋᨵᨾᩮᩣ ᨠᩩᨧ᩠ᨨᩥᨲᩮ ᩐᨶᩮ, ᩋᨸ᩠ᨸᩥᨿᩮ ᨸ᩠ᨿ’ᩃᩥᨠᩮᩣ ᨽᩅᩮ.

ᨻ᩠ᨿᩣᨸᩮ ᩋᩈᩩᨴ᩠ᨵᩮ ᩈᩴᨠᩥᨱ᩠ᨱᩮᩣ, ᨽᨻ᩠ᨻᩴ ᨿᩮᩣᨣ᩠ᨿᩮ ᨧ ᨽᩣᩅᩥᨶᩥ;

ᩈᩩᨡᩩᨾᩮᩣ ᩋᨸ᩠ᨸᨠᩣ’ᨱᩪᩈᩩ, ᩅᩩᨴ᩠ᨵᩮᩣ ᨳᩮᩁᩮ ᨧ ᨸᨱ᩠ᨯᩥᨲᩮ.

ᩈᩩᨽᩮ ᩈᩣᨵᩩᨾ᩠ᩉᩥ ᨽᨴ᩠ᨴᩮᩣ ᨳ, ᨲ᩠ᨿᩣ’ᨴᩮᩣ ᨧ ᩅᩥᨸᩩᩃᩮ ᨻᩉᩩ;

ᨵᩦᩁᩮᩣ ᨻᩩᨵᩮ ᨵᩥᨲᩥᨾᨶ᩠ᨲᩮ, ᩅᩮᩃ᩠ᩃᩥᨲᩴ ᨠᩩᨭᩥᩃᩮ ᨵᩩᨲᩮ.

ᩅᩥᩈᨴᩮᩣ ¶ ᨻ᩠ᨿᨲ᩠ᨲ ᩈᩮᨲᩮᩈᩩ, ᨲᩁᩩᨱᩮᩣ ᨲᩩ ᨿᩩᩅᩮ ᨶᩅᩮ;

ᨻᩩᨵᩮ’ᨽᩥᨩᩣᨲᩮᩣ ᨠᩩᩃᨩᩮ, ᩅᩩᨴ᩠ᨵᩮᩣ’ᩁᩪᩈᩩ ᨾᩉᩃ᩠ᩃᨠᩮᩣ;

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

ᩃᩮᩣᩃᩮ ᨲᩩ ᩈᩦᨥᩮ ᨧᨸᩃᩮᩣ, ᩅᩩᨲ᩠ᨲᩮ ᩏᨴᩥᨲ ᨾᩩᨣ᩠ᨣᨲᩮ;

ᩌᨴᩥᨲ᩠ᨲᩮ ᨣᨻ᩠ᨻᩥᨲᩮ ᨴᩥᨲ᩠ᨲᩮᩣ, ᨸᩥᨭ᩠ᨮᩴ ᨲᩩ ᨧᩩᨱ᩠ᨱᩥᨲᩮᨸᩥ ᨧ.

ᩅᩥᨣᨲᩮ ᩅᩣᨿᩥᨲᩮ [ᩅᩣᨿᨶᩮ (ᨠ.)] ᩅᩦᨲᩴ, ᨽᩣᩅᩥᨲᩴ ᩅᨯ᩠ᨰᩥᨲᩮᨸᩥ ᨧ;

ᨽᨩ᩠ᨩᩥᨲᩮ ᨸᨲᩥᨲᩮ ᨽᨭ᩠ᨮᩮᩣ, ᨸᩩᨭ᩠ᨮᩮᩣ ᨸᩩᨧ᩠ᨨᩥᨲ ᨸᩮᩣᩈᩥᨲᩮ.

ᩈᩪᩁᩮᩣ ᩅᩦᩁᩮ ᩁᩅᩥᩈᩪᩁᩮ, ᨴᩩᨭ᩠ᨮᩮᩣ ᨠᩩᨴ᩠ᨵᩮ ᨧ ᨴᩪᩈᩥᨲᩮ.

ᨴᩥᨭ᩠ᨮᩮᩣ’ᩁᩥᨾ᩠ᩉᩥ’ᨠ᩠ᨡᩥᨲᩮ ᨴᩥᨭ᩠ᨮᩮᩣ [ᨴᩥᨭ᩠ᨮᩴ (ᨠ.)],

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

ᩃᩮᨸ ᨣᨻ᩠ᨻᩮᩈ᩠ᩅ’ᩅᩃᩮᨸᩮᩣ, ᩋᨱ᩠ᨯᨩᩮᩣ ᨾᩦᨶᨸᨠ᩠ᨡᩥᩈᩩ.

ᨻᩥᩃᩣᩃᩮ ᨶᨠᩩᩃᩮ ᨻᨻ᩠ᨻᩩ, ᨾᨶ᩠ᨳᩮᩣ ᨾᨶ᩠ᨳᨶᩈᨲ᩠ᨲᩩᩈᩩ;

ᨣᩮᩣᨸᨣᩣᨾᩮ ᩁᩅᩮ ᨥᩮᩣᩈᩮᩣ, ᩈᩪᨲᩮᩣ ᩈᩣᩁᨳᩥᩅᨶ᩠ᨴᩥᩈᩩ;

ᨾᩣᩃ᩠ᨿᩴ ᨲᩩ ᨸᩩᨸ᩠ᨹᩮ ᨲᨴ᩠ᨴᩣᨾᩮ, ᩅᩣᩉᩮᩣ ᨲᩩ ᩈᨠᨭᩮ ᩉᨿᩮ.

ᨡᨿᩮ’ᨧ᩠ᨧᨶᩮ ᨧᩣ’ᨸᨧᨿᩮᩣ, ᨠᩣᩃᩮᩣ ᩈᨾᨿ ᨾᨧ᩠ᨧᩩᩈᩩ;

ᨽᩮ ᨲᩣᩁᨠᩣ ᨶᩮᨲ᩠ᨲᨾᨩ᩠ᨫᩮ, ᩈᩦᨾᩣ’ ᩅᨵᩥ, ᨭ᩠ᨮᩥᨲᩦᩈᩩ ᨧ.

ᩈᨲ᩠ᨲᩮ ᨳᩪᩃᩮ ᨲᩦᩈᩩ ᨴᩊ᩠ᩉᩮᩣ, ᩃᨲᩣ ᩈᩣᨡᩣᨿ ᩅᩃ᩠ᩃᩥᨿᩴ.

ᨾᩩᨲ᩠ᨲᩥ’ᨲ᩠ᨳᩦ ¶ ᨾᩮᩣᨧᨶᩮ ᨾᩮᩣᨠ᩠ᨡᩮ,

ᨶᩦᨧᩮ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩮᩣ ᨾᩪᩊ᩠ᩉᩮ, ᨽᨲ᩠ᨲᩣ ᩈᩣᨾᩥᨶᩥ ᨵᩣᩁᨠᩮ.

ᩈᩥᨡᩣ, ᨸᩥᨬ᩠ᨨᩮᩈᩩ ᩈᩥᨡᨱ᩠ᨯᩮᩣ, ᩈᨲ᩠ᨲᩮ ᨲ᩠ᩅ’ᨲ᩠ᨲᨶᩥ ᨸᩩᨣ᩠ᨣᩃᩮᩣ;

ᩅᨧ᩠ᨧᩮᩣ ᩁᩪᨸᩮ ᨠᩁᩦᩈᩮ ᨳ, ᨩᩩᨲᩥ’ᨲ᩠ᨳᩦ ᨠᨶ᩠ᨲᩥᩁᩴᩈᩥᩈᩩ;

ᩃᨻ᩠ᨽᩴ ᨿᩩᨲ᩠ᨲᩮ ᨧ ᩃᨴ᩠ᨵᨻ᩠ᨻᩮ, ᨡᨱ᩠ᨯᩮ ᨸᨱ᩠ᨱᩮ ᨴᩃᩴ ᨾᨲᩴ;

ᩈᩃ᩠ᩃᩴ ᨠᨱ᩠ᨯᩮ ᩈᩃᩣᨠᩣᨿᩴ, ᩈᩩᨧᩥᨲ᩠ᨲᩮ ᨵᩣᩅᨶᩴ ᨣᨲᩮ;

ᨽᨶ᩠ᨲᨲ᩠ᨳᩮ ᩅᩥᨻ᩠ᨽᨾᩮᩣ ᩉᩣᩅᩮ, ᨾᩮᩣᩉᩮᩣ’ᩅᩥᨩ᩠ᨩᩣᨿ ᨾᩩᨧ᩠ᨨᨶᩮ.

ᨾᩥᨲ᩠ᨲᩮ ᩈᩉᩣᨿᩮ ᨧ ᩈᨡᩣ, ᩅᩥᨽᩪ ᨶᩥᨧ᩠ᨧᨸ᩠ᨸᨽᩪᩈᩩ ᩈᩮᩣ.

ᨡᨣ᩠ᨣᩮ ᨠᩩᩁᩪᩁᩮ ᨶᩮᨲ᩠ᨲᩥᩴᩈᩮᩣ, ᨸᩁᩈ᩠ᨾᩥᩴ ᩋᨲᩕ ᨲᩦᩈ᩠ᩅ’ᨾᩩ;

ᨸᨩ᩠ᨩᩮ ᨣᩣᨳᩣ ᩅᨧᩦᨽᩮᨴᩮ, ᩅᩴᩈᩮᩣ ᨲ᩠ᩅ’ᨶ᩠ᩅᨿᩅᩮᨱᩩᩈᩩ;

ᨿᩣᨶᩴ ᩁᨳᩣᨴᩮᩣ ᨣᨾᨶᩮ, ᩈᩁᩪᨸᩈ᩠ᨾᩥᩴ ᩋᨵᩮᩣ ᨲᩃᩴ.

ᨾᨩ᩠ᨫᩮᩣ ᩅᩥᩃᨣ᩠ᨣᩮ ᩅᩮᨾᨩ᩠ᨫᩮ, ᨸᩩᨸ᩠ᨹᩴ ᨲᩩ ᨠᩩᩈᩩᨾᩮᩣ’ᨲᩩᩈᩩ;

ᩈᩦᩃᩴ ᩈᨽᩣᩅᩮ ᩈᩩᨻ᩠ᨻᨲᩮ, ᨸᩩᨦ᩠ᨣᩅᩮᩣ ᩏᩈᨽᩮ ᩅᩁᩮ.

ᨠᩮᩣᩈᩮ ᨡᨣᩣᨴᩥᨻᩦᨩᩮ’ᨱ᩠ᨯᩴ, ᨠᩩᩉᩁᩴ ᨣᨻ᩠ᨽᩁᩮ ᨻᩥᩃᩮ;

ᨶᩮᨲ᩠ᨲᩥᩴᩈᩮ ᨣᨱ᩠ᨯᨠᩮ ᨡᨣ᩠ᨣᩮᩣ, ᨠᨴᨾ᩠ᨻᩮᩣ ᨲᩩ ᨴᩩᨾᩮ ᨧᨿᩮ.

ᨽᩮ’ᨵᩮᨶᩩᨿᩴ ᩁᩮᩣᩉᩥᨱᩦ’ᨲ᩠ᨳᩦ, ᩅᩁᨦ᩠ᨣᩴ ᨿᩮᩣᨶᩥᨿᩴ ᩈᩥᩁᩮ;

ᩋᨠ᩠ᨠᩮᩣᩈᩮ ᩈᨸᨳᩮ ᩈᩣᨸᩮᩣ, ᨸᨦ᩠ᨠᩴ ᨸᩣᨸᩮ ᨧ ᨠᨴ᩠ᨴᨾᩮ.

ᨽᩮᩣᨣᩅᨲ᩠ᨿᩩ’ᩁᨣᩮ ᨽᩮᩣᨣᩦ, ᩔᩁᩮᩣ ᨲᩩ ᩈᩥᩅᩈᩣᨾᩥᩈᩩ;

ᨻᩃᩮ ᨸᨽᩣᩅᩮ ᩅᩦᩁᩥᨿᩴ, ᨲᩮᨩᩮᩣ ᨲᩮᩈᩩ ᨧ ᨴᩥᨲ᩠ᨲᩥᨿᩴ.

ᨵᩣᩁᩣ ᩈᨶ᩠ᨲᨲᩥ ᨡᨣ᩠ᨣᨦ᩠ᨣᩮ, ᩅᩣᨶᩴ ᨲᨱ᩠ᩉᩣᨿ ᩈᩥᨻ᩠ᨻᨶᩮ;

ᨡᨲ᩠ᨲᩣ ᩈᩪᨲᩮ ᨸᨭᩥᩉᩣᩁᩮ, ᩅᩥᨲ᩠ᨲᩥ ᨸᩦᩊᩣᩈᩩ ᩅᩮᨴᨶᩣ.

ᨳᩥᨿᩴ ¶ ᨾᨲᩥ’ᨧ᩠ᨨᩣᨸᨬ᩠ᨬᩣᩈᩩ, ᨸᩣᨸᩮ ᨿᩩᨴ᩠ᨵᩮ ᩁᩅᩮ ᩁᨱᩮᩣ;

ᩃᩅᩮᩣᨲᩩ ᨻᩥᨶ᩠ᨴᩩ’ᨧ᩠ᨨᩮᨴᩮᩈᩩ, ᨸᩃᩣᩃᩮ’ [ᨸᩃᩣᩈᩮ (ᨭᩦ.), ᨸᩃᩣᨸᩮ-ᨭᩦ (᪔᪕᪓-᪑᪑᪒᪔) ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨲᩥᩈᨿᩮ ᨽᩩᩈᩴ.

ᨻᩣᨵᩣ ᨴᩩᨠ᩠ᨡᩮ ᨶᩥᩈᩮᨵᩮ ᨧ, ᨾᩪᩃᨸᨴᩮᨸᩥ ᨾᩣᨲᩥᨠᩣ;

ᨠᩮᨲᩩᩈ᩠ᨾᩥᩴ ᨠᩮᨲᨶᩴ ᨣᩮᩉᩮ, ᨮᩣᨶᩮ ᨽᩪᨾᩥ’ᨲ᩠ᨳᩥᨿᩴ ᨽᩩᩅᩥ;

ᩃᩮᨡ᩠ᨿᩮ ᩃᩮᨡᩮᩣ ᩁᩣᨩᩥ ᩃᩮᨡᩣ, ᨸᩪᨩᩥᨲᩮ ᨽᨣᩅᩣ ᨩᩥᨶᩮ.

ᨣᨴᩣ ᩈᨲ᩠ᨳᩮ ᨣᨴᩮᩣ ᩁᩮᩣᨣᩮ, ᨶᩥᩈᨩ᩠ᨩᩣ ᨸᩦᨮᩮᩈ᩠ᩅᩣ’ᩈᨶᩴ;

ᨻᩥᩃᩴ ᨠᩮᩣᨭ᩠ᨮᩣᩈ ᨨᩥᨴ᩠ᨴᩮᩈᩩ, ᩅᨩ᩠ᨩᩴ ᨴᩮᩣᩈᩮ ᨧ ᨽᩮᩁᩥᨿᩴ;

ᨠᩣᩃᩮ ᨴᩦᨥᨬ᩠ᨩᩈᩮ’ᨴ᩠ᨵᩣᨶᩴ, ᩌᩃᩥᨿᩴ ᩈᩮᨲᩩ ᨠᩣᩁᨱᩮ.

ᨿᩪᨸᩮᩣ ᨳᨾ᩠ᨽᩮ ᨧ ᨸᩣᩈᩣᨴᩮ, ᩋᨿᨶᩴ ᨣᨾᨶᩮ ᨸᨳᩮ.

ᨨᨴᨶᩮ’ᨧ᩠ᨨᩣᨴᨶᩴ ᩅᨲ᩠ᨳᩮ, ᨶᩥᨠᩣᨿᩮᩣ ᨣᩮᩉᩁᩣᩈᩥᩈᩩ;

ᩋᨶ᩠ᨶᩣᨴᩮᩣ ᩌᨾᩥᩈᩴ ᨾᩴᩈᩮ; ᨴᩥᨠ᩠ᨡᩣ ᨲᩩ ᨿᨩᨶᩮ’ᨧ᩠ᨧᨶᩮ.

ᨠᩩᩈᩩᨾᩴ ᨳᩦᩁᨩᩮ ᨸᩩᨸ᩠ᨹᩮ, ᩅᩣᨶᩁᩮ ᨲᩩ ᨻᩩᨵᩮ ᨠᩅᩥ.

ᩋᨵᩁᩮ ¶ ᨡᩁᨽᩮ ᩒᨭ᩠ᨮᩮᩣ, ᩃᩩᨴ᩠ᨴᩮᩣ ᨲᩩ ᩃᩩᨴ᩠ᨴᨠᩮᨸᩥ ᨧ;

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

ᨠᨶ᩠ᨲᩣᩁᩮᩣ ᩅᨶ, ᨴᩩᨣ᩠ᨣᩮᩈᩩ, ᨧᩁᩮᩣ ᨧᩣᩁᨾ᩠ᩉᩥ ᨧᨬ᩠ᨧᩃᩮ;

ᨩᨶᩣᩅᩣᩈᩮ ᨣᨱᩮ ᨣᩣᨾᩮᩣ, ᨧᨾ᩠ᨾᩴ ᨲᩩ ᨹᩃᨠᩮ ᨲᨧᩮ.

ᩈᨲ᩠ᨲᩣᨿᩴ ᨽᩅᨶᩴ ᨣᩮᩉᩮ, ᩃᩮᩈᩮ ᨲᩩ ᨡᩃᩥᨲᩮ ᨨᩃᩴ.

ᩅᩮᩁᩴ ᨸᩣᨸᩮ ᨧ ᨸᨭᩥᨥᩮ, ᨲᨧᩮᩣ ᨧᨾ᩠ᨾᨶᩥ ᩅᨠ᩠ᨠᩃᩮ;

ᩏᨧ᩠ᨧᩮ’ᨵᩥᩁᩮᩣᩉᩮ ᩌᩁᩮᩣᩉᩮᩣ, ᨶᩮᨲ᩠ᨲᩴ ᩅᨲ᩠ᨳᨶ᩠ᨲᩁ’ᨠ᩠ᨡᩥᩈᩩ.

ᨸᨭᩥᩉᩣᩁᩮ ᨾᩩᨡᩮ ᨴ᩠ᩅᩣᩁᩴ, ᨸᩮᨲᩮ ᨬᩣᨲᩮ ᨾᨲᩮᩣ ᨲᩥᩈᩩ;

ᨾᩣᩈᩮᩣ ᨸᩁᨱ᩠ᨱ ᨠᩣᩃᩮᩈᩩ, ᨶᨣ᩠ᨣᩮᩣ ᨲ᩠ᩅ’ᨧᩮᩃᨠᩮᨸᩥ ᨧ.

ᨴᩮᩣᩈᩮ ᨥᩣᨲᩮ ᨧ ᨸᨭᩥᨥᩮᩣ, ᨾᩥᨣᩣᨴᩮᩣ ᨨᨣᩃᩮ ᨸᩈᩩ;

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

ᨴᨻ᩠ᨻᩥ’ᨶ᩠ᨴᨩᩣᨿᩣᩈᩩ ᩈᩩᨩᩣ, ᨾᩮᨥᩮ ᨲ᩠ᩅ’ᨻ᩠ᨽᩴ ᩅᩥᩉᩣᨿᩈᩮ.

ᨾᩮᩣᨴᨠᩮᩣ ᨡᨩ᩠ᨩᨽᩮᨴᩮᨸᩥ, ᨾᨱᩥᨠᩮ ᩁᨲᨶᩮ ᨾᨱᩥ;

ᩉᩅᩥ ᩈᨸ᩠ᨸᩥᨾ᩠ᩉᩥ ᩉᩮᩣᨲᨻ᩠ᨻᩮ, ᩈᩥᩁᩮᩣ ᩈᩮᨭ᩠ᨮᩮ ᨧ ᨾᩩᨴ᩠ᨵᨶᩥ;

ᩅᩥᨧᩣᩁᩮᨸᩥ ᩅᩥᩅᩮᨠᩮᩣ ᨳ, ᩈᩥᨡᩁᩦ ᨸᨻ᩠ᨻᨲᩮ ᨴᩩᨾᩮ.

ᩅᩮᨣᩮᩣ ᨩᩅᩮ ᨸᩅᩣᩉᩮ ᨧ, ᩈᨦ᩠ᨠᩩ ᨲᩩ ᨡᩥᩃᩉᩮᨲᩥᩈᩩ;

ᨶᩥᨣ᩠ᨣᩉᩦᨲᩮ ᨠᨱᩮ ᨻᩥᨶ᩠ᨴᩩ, ᩅᩁᩣᩉᩮᩣ ᩈᩪᨠᩁᩮ ᨣᨩᩮ.

ᨶᩮᨲ᩠ᨲᨶ᩠ᨲᩮ ᨧᩥᨲ᩠ᨲᨠᩮ’ᨸᩣᨦ᩠ᨣᩴ, ᩈᩥᨴ᩠ᨵᨲ᩠ᨳᩮᩣ ᩈᩣᩈᨸᩮ ᨩᩥᨶᩮ;

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

ᩅᨲ᩠ᨳᩮ ᨣᨶ᩠ᨵᩮ ᨥᩁᩮ ᩅᩣᩈᩮᩣ, ᨧᩩᩃ᩠ᩃᩮᩣ ᨡᩩᨴ᩠ᨴᩮ ᨧ ᩏᨴ᩠ᨵᨶᩮ.

ᩈᩮᨿ᩠ᨿᩣ ᩈᩮᨶᩣᩈᨶᩮ ᩈᩮᨶᩮ, ᨧᩩᨶ᩠ᨴᨽᨱ᩠ᨯᨾ᩠ᩉᩥ ᨧ’ᨻ᩠ᨽᨾᩮᩣ;

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

ᩈᩣᨡᩣᨿᩴ ᩅᩥᨭᨸᩮᩣ ᨳᨾ᩠ᨽᩮ, ᩈᨲ᩠ᨲᩩ ᨡᨩ᩠ᨩᨶ᩠ᨲᩁᩮ ᨴᩥᩈᩮ;

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

ᩁᩣᨣᩮ ᩁᨦ᩠ᨣᩮᩣ ᨶᨧ᩠ᨧᨭ᩠ᨮᩣᨶᩮ, ᨸᩣᨶᩴ ᨸᩮᨿ᩠ᨿᩮ ᨧ ᨸᩦᨲᩥᨿᩴ;

ᩍᨱᩩ’ᨠ᩠ᨡᩮᨸᩮᩈᩩ ᩏᨴ᩠ᨵᩣᩁᩮᩣ, ᩏᨾ᩠ᨾᩣᩁᩮ ᩑᩊᨠᩮᩣ ᩋᨩᩮ.

ᨸᩃᩣᩃᩮᩣ [ᨸᩃᩣᨸᩮᩣ (ᨠ.) ᪔᪕᪓-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨲᩩ ᨽᩩᩈᨾ᩠ᩉᩥ ᨧ.

ᨾᨲᩣ’ᩅᩣᨭᩮ ᨧᨿᩮ ᨠᩣᩈᩩ, ᨸᨶᩥᩈᩣ ᨠᩣᩁᨱᩮ ᩁᩉᩮᩣ;

ᨿᩩᨲ᩠ᨿ’ᨭ᩠ᨭᩣᩃ’ᨭ᩠ᨭᩥᨲᩮᩈ᩠ᩅ’ᨭ᩠ᨭᩮᩣ, ᨠᩦᩊᩣᨿᩴ ᨠᩣᨶᨶᩮ ᨴᩅᩮᩣ;

ᩏᨸ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᨧᩮᩣ’ᨸ᩠ᨸᨲᨶᩴ, ᩏᨿ᩠ᨿᩣᨶᩴ ᨣᨾᨶᩮ ᩅᨶᩮ.

ᩅᩮᩣᨠᩣᩁᩮᩣ ᩃᩣᨾᨠᩮ ᨡᨶ᩠ᨵᩮ, ᨾᩪᩃᩮᩣ’ᨸᨴᩣᩈᩩ ᨸᩣᨽᨲᩴ;

ᨴᩈᩣ’ ᩅᨲ᩠ᨳᩣ ᨸᨭᨶ᩠ᨲᩮᩈᩩ, ᨠᩣᩁᨱᩴ ᨥᩣᨲ, ᩉᩮᨲᩩᩈᩩ.

ᩉᨲ᩠ᨳᩥᨴᩣᨶᩮ ¶ ᨾᨴᩮᩣ ᨣᨻ᩠ᨻᩮ, ᨥᨭᩣ ᨥᨭᨶ ᩁᩣᩈᩥᩈᩩ;

ᩏᨸᩉᩣᩁᩮᩣ’ᨽᩥᩉᩣᩁᩮᨸᩥ, ᨧᨿᩮᩣ ᨻᨶ᩠ᨵᨶ ᩁᩣᩈᩥᩈᩩ.

ᨸᩣᨶᩮ ᨸᨾᩮᩣᨴᩮ ᨸᩦᨲᩥ’ᨲ᩠ᨳᩦ, ᩍᨱᩮ ᨣᩥᩅᩣ ᨣᩃᩮᨸᩥ ᨧ.

ᨸᨲᩥᨭ᩠ᨮᩣ ᨶᩥᩔᨿᩮ ᨮᩣᨶᩮ, ᨻᩃᨠ᩠ᨠᩣᩁᩮᨸᩥ ᩈᩣᩉᩈᩴ;

ᨽᨦ᩠ᨣᩮᩣ ᨽᩮᨴᩮ ᨸᨭᩮ ᨽᨦ᩠ᨣᩴ, ᨨᨲ᩠ᨲᩴ ᨲᩩ ᨨᩅᨠᩮᨸᩥ ᨧ.

ᨬᩣᨱᩮ ᨽᩩᩅᩥ ᨧ ᨽᩪᩁᩥ’ᨲ᩠ᨲᩦ, ᩋᨶᨦ᩠ᨣᩮ ᨾᨴᨶᩮᩣ ᨴᩩᨾᩮ;

ᨸᨾᩣᨲᩁᩥᨸᩥ ᨾᩣᨲᩣ ᨳ, ᩅᩮᨮᩩ’ᨱᩦᩈᩮᩈᩩ ᩅᩮᨮᨶᩴ.

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

ᨡᩮᨲ᩠ᨲᩮ [ᩅᨸ᩠ᨸᩮ (ᨸᩣᨠᩣᩁᨾᩪᩃᩮ ᨶᩮᨲ᩠ᨲᨩᩃᩮ ᩏᩈᩩᨾᩮ ᨧ ᩅᨸ᩠ᨸᩮᩣ-ᨭᩦ)] ᩅᨸ᩠ᨸᩮᩣ ᨲᨭᩮᨸᩥ ᨧ;

ᩈᨾ᩠ᨾᩩᨲ᩠ᨿ’ᨶᩩᨬ᩠ᨬᩣ ᩅᩮᩣᩉᩣᩁᩮ, ᩈ᩠ᩅ’ᨳ ᩃᩣᨩᩣᩈᩩ ᨧᩣ’ᨠ᩠ᨡᨲᩴ.

ᩈᨦ᩠ᨥᩣᨲᩮᩣ ᨿᩩᨣᨣᩮᩉᨦ᩠ᨣᩮ, ᨡᩣᩁᩮᩣ ᩐᩈᩮ ᨧ ᨽᩈ᩠ᨾᨶᩥ.

ᩋᨻ᩠ᨿᨿᩴ ᩅᩩᨧ᩠ᨧᨲᩮ ᨴᩣᨶᩥ, ᨧᩥᩁᩔᩴ ᨲᩩ ᨧᩥᩁᩴ ᨲᨳᩣ;

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

ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ ¶ ᩋᨽᩥᨱ᩠ᩉᨬ᩠ᨧᩣ, ᩈᨠᩥᩴ ᨧᩣ’ᨽᩥᨠ᩠ᨡᨱᩴ ᨾᩩᩉᩩᩴ;

ᩅᨩ᩠ᨩᨶᩮ ᨲᩩ ᩅᩥᨶᩣ ᨶᩣᨶᩣ, ᩋᨶ᩠ᨲᩁᩮᨶ ᩁᩥᨲᩮ ᨸᩩᨳᩩ.

ᨻᩃᩅᩴ ᩈᩩᨭ᩠ᨮᩩ ᨧᩣ’ᨲᩦᩅᩣ, ᨲᩥᩈᨿᩮ ᨠᩥᨾᩩᨲ ᩈ᩠ᩅ’ᨲᩥ;

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

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

ᩋᨵᩩᨶᩮ’ᨲᩁᩉᩦ’ᨴᩣᨶᩥ, ᩈᨾ᩠ᨸᨲᩥ ᩋᨬ᩠ᨬᨴᨲ᩠ᨳᩩ ᨲᩩ;

ᨲᨣ᩠ᨥᩮ’ ᨠᩴᩈᩮ ᩈᩈᨠ᩠ᨠᨬ᩠ᨧᩣ, ᨴ᩠ᨵᩣ ᨠᩣᨾᩴ ᨩᩣᨲᩩ ᩅᩮ ᩉᩅᩮ.

ᨿᩣᩅᨲᩣ ᨲᩣᩅᨲᩣ ᨿᩣᩅ, ᨲᩣᩅ ᨠᩥᨲ᩠ᨲᩣᩅᨲᩣ ᨲᨳᩣ;

ᩑᨲ᩠ᨲᩣᩅᨲᩣ ᨧ ᨠᩦᩅᩮ’ᨲᩥ, ᨸᩁᩥᨧ᩠ᨨᩮᨴᨲ᩠ᨳᩅᩣᨧᨠᩣ.

ᨿᨳᩣ ᨲᨳᩣ ᨿᨳᩮᩅᩮ’ᩅᩴ, ᨿᨳᩣᨶᩣᨾ ᨿᨳᩣᩉᩥ ᨧ;

ᩈᩮᨿ᩠ᨿᨳᩣᨸ᩠ᨿᩮ’ᩅᨾᩮᩅᩴ, ᩅᩣ, ᨲᨳᩮᩅ ᨧ ᨿᨳᩣᨸᩥ ᨧ.

ᩑᩅᨾ᩠ᨸᩥ ᨧ ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨶᩣᨾ ᨿᨳᩁᩥᩅᩣ’ᨸᩥ ᨧ;

ᨸᨭᩥᨽᩣᨣᨲ᩠ᨳᩮ ᨿᨳᩣᨧ, ᩅᩥᨿ ᨲᨳᩁᩥᩅᩣ’ᨸᩥ ᨧ.

ᩈᩴ ᩈᩣᨾᨬ᩠ᨧ ᩈᨿᩴ ᨧᩣᨳ, ᩌᨾ ᩈᩣᩉᩩ ᩃᩉᩪ’ᨸᩥ ᨧ;

ᩒᨸᩣᨿᩥᨠᩴ ᨸᨲᩥᩁᩪᨸᩴ, ᩈᩣᨵ᩠ᩅᩮ’ᩅᩴ ᩈᨾ᩠ᨸᨭᩥᨧ᩠ᨨᨶᩮ.

ᩋᩈᩣᨠᩃ᩠ᨿᩮ ᨲᩩ ᨧᨶ ᨧᩥ, ᨶᩥᨸ᩠ᨹᩃᩮ ᨲᩩ ᨾᩩᨵᩣ ᨽᩅᩮ.

ᨠᨴᩣᨧᩥ ᨩᩣᨲᩩ ᨲᩩᩃ᩠ᨿᩣ’ᨳ, ᩈᨻ᩠ᨻᨲᩮᩣ ᨧ ᩈᨾᨶ᩠ᨲᨲᩮᩣ;

ᨸᩁᩥᨲᩮᩣ ᨧ ᩈᨾᨶ᩠ᨲᩣᨸᩥ, ᩋᨳ ᨾᩥᨧ᩠ᨨᩣ ᨾᩩᩈᩣ ᨽᩅᩮ.

ᨶᩥᩈᩮᨵᩮ ᨶ ᩋᨶᩮᩣᨾᩣ’ᩃᩴ, ᨶᩉᩥ ᨧᩮᨲᩩ ᩈᨧᩮ ᨿᨴᩥ;

ᨶᨲ᩠ᨲᩴ [ᩁᨲ᩠ᨲᩴ (ᨭᩦ.)] ᨴᩮᩣᩈᩮᩣ ᨴᩥᩅᩣ ᨲ᩠ᩅ’ᩉᩮ.

ᩎᩈᩴ ᨠᩥᨬ᩠ᨧᩥ ᨾᨶᩴ ᩋᨸ᩠ᨸᩮ, ᩈᩉᩈᩣ ᨲᩩ ᩋᨲᨠ᩠ᨠᩥᨲᩮ;

ᨸᩩᩁᩮ ᨣ᩠ᨣᨲᩮᩣ ᨲᩩ ᨸᩩᩁᨲᩮᩣ, ᨸᩮᨧ᩠ᨧᩣ’ᨾᩩᨲᩕᨽᩅᨶ᩠ᨲᩁᩮ.

ᨲᨦ᩠ᨡᨱᩮ ᩈᨩ᩠ᨩᩩ ᩈᨸᨴᩥ, ᨻᩃᨠ᩠ᨠᩣᩁᩮ ᨸᩈᨿ᩠ᩉ ᨧ.

ᩈᩩᨴᩴ ᨡᩮᩣ [ᩅᩮᩣ (ᨠ.)] ᩋᩔᩩ ᨿᨣ᩠ᨥᩮ ᩅᩮ,ᩉᩣ’ᨴᨿᩮᩣ ᨸᨴᨸᩪᩁᨱᩮ;

ᩋᨶ᩠ᨲᩁᩮᨶ’ᨶ᩠ᨲᩁᩣ ᩋᨶ᩠ᨲᩮᩣ, ᩅᩔᩴ ᨶᩪᨶ ᨧ ᨶᩥᨧ᩠ᨨᨿᩮ.

ᩌᨶᨶ᩠ᨴᩮ ᩈᨬ᩠ᨧ ᨴᩥᨭ᩠ᨮᩣ ᨳ, ᩅᩥᩁᩮᩣᨵᨠᨳᨶᩮ ᨶᨶᩩ;

ᨠᩣᨾᨸ᩠ᨸᩅᩮᨴᨶᩮ ᨠᨧ᩠ᨧᩥ, ᩏᩈᩪᨿᩮᩣᨸᨣᨾᩮ’ᨲ᩠ᨳᩩ ᨧ.

ᩑᩅᩣ’ᩅᨵᩣᩁᨱᩮ ᨬᩮᨿ᩠ᨿᩴ, ᨿᨳᩣᨲ᩠ᨲᩴ ᨲᩩ ᨿᨳᩣᨲᨳᩴ;

ᨶᩦᨧᩴ ᩋᨸ᩠ᨸᩮ, ᨾᩉᨲ᩠ᨿᩩ’ᨧ᩠ᨧᩴ, ᩋᨳ ᨸᩣᨲᩮᩣ ᨸᨣᩮ ᩈᨾᩣ.

ᨶᩥᨧ᩠ᨧᩮ ᩈᨴᩣ ᩈᨶᩴ [ᩈᨶᩣ (ᨠ.)] ᨸᩣᨿᩮᩣ,

ᨻᩉᩥᨴ᩠ᨵᩣ ᨻᩣᩉᩥᩁᩣ ᨻᩣᩉ᩠ᨿᩮ, ᩈᩦᨥᩮᨲᩩ ᩈᨱᩥᨠᩴ ᨽᩅᩮ.

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

ᩈᨾ᩠ᨾᩣ ᩈᩩᨭ᩠ᨮᩩ ᨸᩈᩴᩈᩣᨿᩴ, ᩋᨳᩮᩣ ᩈᨲ᩠ᨲᩣᨿ ᨾᨲ᩠ᨳᩥ ᨧ.

ᨲᨲᩮᩣ ᨸᩁᩮ ᨸᩁᩈᩩᩅᩮ, ᩉᩥᨿ᩠ᨿᩮᩣᨲᩩ ᨴᩥᩅᩈᩮ ᨣᨲᩮ.

ᨿᨲ᩠ᨳ ᨿᨲᩕ ᨿᩉᩥᩴᨧᩣᨳ, ᨲᨲ᩠ᨳ ᨲᨲᩕ ᨲᩉᩥᩴᨲᩉᩴ;

ᩋᨳᩮᩣ ᩏᨴ᩠ᨵᨬ᩠ᨧ ᩏᨸᩁᩥ, ᩉᩮᨭ᩠ᨮᩣ ᨲᩩ ᨧ ᩋᨵᩮᩣ ᩈᨾᩣ.

ᨧᩮᩣᨴᨶᩮ ᩍᨦ᩠ᨥ ᩉᨶ᩠ᨴᩣ’ᨳ, ᩌᩁᩣᨴᩪᩁᩣ ᨧ ᩌᩁᨠᩣ;

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

ᩈᩴᩈᨿᨲ᩠ᨳᨾ᩠ᩉᩥ ᩋᨸ᩠ᨸᩮᩅ, ᩋᨸ᩠ᨸᩮᩅᨶᩣᨾ ᨶᩪ’ᨲᩥ ᨧ;

ᨶᩥᨴᩔᨶᩮ ᩍᨲᩥ’ᨲ᩠ᨳᨬ᩠ᨧ, ᩑᩅᩴ, ᨠᩥᨧ᩠ᨨᩮ ᨠᨳᨬ᩠ᨧᩥ ᨧ.

ᨲᩥᩁᩮᩣ ᨲᩩ ᨲᩥᩁᩥᨿᩴ ᨧᩣᨳ, ᨠᩩᨧ᩠ᨨᩣᨿᩴ ᨴᩩᨭ᩠ᨮᩩ ᨠᩩ’ᨧ᩠ᨧᨲᩮ.

ᩈᩩᩅᨲ᩠ᨳᩥ ᩌᩈᩥᨭ᩠ᨮᨲ᩠ᨳᨾ᩠ᩉᩥ, ᨶᩥᨶ᩠ᨴᩣᨿᩴ ᨲᩩ ᨵᩦ [ᨵᩥ (ᨠ.)] ᨠᨳ᩠ᨿᨲᩮ;

ᨠᩩᩉᩥᨬ᩠ᨧᨶᩴ ᨠᩩᩉᩥᩴ ᨠᩩᨲᩕ, ᨠᩩᨲ᩠ᨳ ᨠᨲ᩠ᨳ ᨠᩉᩴ ᨠ᩠ᩅ ᨳ.

ᨠᨴᩣ ᨠᩩᨴᩣᨧᨶᩴ ᨧᩣᨳ, ᨲᨴᩣᨶᩥ ᨧ ᨲᨴᩣ ᩈᨾᩣ.

ᩌᨴᩥᨠᨾ᩠ᨾᩮ ᨽᩩᩈᨲ᩠ᨳᩮ ᨧ, ᩈᨾ᩠ᨽᩅᩮᩣ’ᨲᩥᨱ᩠ᨱ ᨲᩥᨲ᩠ᨲᩥᩈᩩ;

ᨶᩥᨿᩮᩣᨣᩥ’ᩔᩁᩥᨿ’ᨸ᩠ᨸᩦᨲᩥ, ᨴᩣᨶ ᨸᩪᨩᩣ’ᨣ᩠ᨣ, ᩈᨶ᩠ᨲᩥᩈᩩ.

ᨴᩔᨶᩮ ᨲᨸ᩠ᨸᩁᩮ ᩈᨦ᩠ᨣᩮ, ᨸᩈᩴᩈᩣ, ᨣᨲᩥ, ᩈᩩᨴ᩠ᨵᩥᩈᩩ;

ᩉᩥᩴᩈᩣ, ᨸᨠᩣᩁᨶ᩠ᨲᩮᩣ’ᨽᩣᩅ, ᩅᩥᨿᩮᩣᨣᩣ’ᩅᨿᩅᩮᩈᩩ ᨧ;

ᨸᩮᩣ’ᨸᩈᨣ᩠ᨣᩮᩣ ᨴᩥᩈᩣᨿᩮᩣᨣᩮ, ᨸᨲ᩠ᨳᨶᩣ, ᨵᩥᨲᩥᩌᨴᩥᩈᩩ.

ᨸᩁᩣᩈᨴ᩠ᨴᩮᩣ ᨸᩁᩥᩉᩣᨶᩥ, ᨸᩁᩣᨩᨿ ᨣᨲᩦᩈᩩ ᨧ;

ᨽᩩᩈᨲ᩠ᨳᩮ ᨸᨭᩥᩃᩮᩣᨾᨲ᩠ᨳᩮ, ᩅᩥᨠ᩠ᨠᨾᩣ’ᨾᩈᨶᩣᨴᩥᩈᩩ.

ᨶᩥᩔᩮᩈᩣ’ᨽᩣᩅ ᩈᨶ᩠ᨿᩣᩈ, ᨽᩩᩈᨲ᩠ᨳ ᨾᩮᩣᨠ᩠ᨡ ᩁᩣᩈᩥᩈᩩ;

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

ᨴᩔᨶᩮᩣ’ᩈᩣᨶᨶᩥᨠ᩠ᨡᨶ᩠ᨲᩣ, ᨵᩮᩣᨽᩣᨣᩮᩈ᩠ᩅ’ᩅᨵᩣᩁᨱᩮ;

ᩈᩣᨾᩦᨸ᩠ᨿᩮ ᨻᨶ᩠ᨵᨶᩮ ᨨᩮᨠ, ᨶ᩠ᨲᩮᩣᨽᩣᨣᩮᩣ’ᨸᩁᨲᩦᩈᩩ ᨧ.

ᨸᩣᨲᩩᨽᩣᩅᩮ ᩅᩥᨿᩮᩣᨣᩮ ᨧ, ᨶᩥᩈᩮᨵᩣᨴᩮᩣ ᨶᩥ ᨴᩥᩔᨲᩥ;

ᩋᨳᩮᩣ ᨶᩦᩉᩁᨱᩮ ᨧᩮᩅᩣ, ᩅᩁᨱᩣᨴᩮᩣ ᨧ ᨶᩦ ᩈᩥᨿᩣ.

ᩏᨴ᩠ᨵᨠᨾ᩠ᨾ ᩅᩥᨿᩮᩣᨣ ᨲ᩠ᨲ, ᩃᩣᨽ ᨲᩥᨲ᩠ᨲᩥ ᩈᨾᩥᨴ᩠ᨵᩥᩈᩩ;

ᨸᩣᨲᩩᨽᩣᩅ’ᨧ᩠ᨧᨿᩣᨽᩣᩅ, ᨸᨻᩃᨲ᩠ᨲᩮ ᨸᨠᩣᩈᨶᩮ;

ᨴᨠ᩠ᨡ’ᨣ᩠ᨣᨲᩣᩈᩩ ᨠᨳᨶᩮ, ᩈᨲ᩠ᨲᩥᨾᩮᩣᨠ᩠ᨡᩣᨴᩥᨠᩮ ᩏ ᨧ.

ᨴᩩ ᨠᩩᨧ᩠ᨨᩥᨲᩮ’ᩈᨴᨲ᩠ᨳᩮᩈᩩ, ᩅᩥᩁᩪᨸᨲ᩠ᨲᩮ ᨸ᩠ᨿ’ᩈᩮᩣᨽᨶᩮ;

ᩈᩥᨿᩣ’ᨽᩣᩅᩣ’ᩈᨾᩥᨴ᩠ᨵᩦᩈᩩ, ᨠᩥᨧ᩠ᨨᩮ ᨧᩣ’ᨶᨶ᩠ᨴᨶᩣᨴᩥᨠᩮ.

ᩈᩴ ᩈᨾᩮᩣᨵᩣᨶ ᩈᨦ᩠ᨡᩮᨸ, ᩈᨾᨶ᩠ᨲᨲ᩠ᨲ ᩈᨾᩥᨴ᩠ᨵᩥᩈᩩ;

ᩈᨾ᩠ᨾᩣ ᨽᩩᩈ ᩈᩉ ᨸ᩠ᨸᨲ᩠ᨳᩣ, ᨽᩥᨾᩩᨡᨲ᩠ᨳᩮᩈᩩ ᩈᨦ᩠ᨣᨲᩮ;

ᩅᩥᨵᩣᨶᩮ ᨸᨽᩅᩮ ᨸᩪᨩᩣ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᨠᩕᩥᨿᩣᨴᩥᩈᩩ.

ᩅᩥᩅᩥᨵᩣ’ᨲᩥᩈᨿᩣ’ᨽᩣᩅ, ᨽᩩᩈᨲ᩠ᨲᩥ’ᩔᩁᩥᨿᩣ’ᨧ᩠ᨧᨿᩮ;

ᩅᩥᨿᩮᩣᨣᩮ ᨠᩃᩉᩮ ᨸᩣᨲᩩ, ᨽᩣᩅᩮ ᨽᩣᩈᩮ ᨧ ᨠᩩᨧ᩠ᨨᨶᩮ.

ᨴᩪᩁᩣ’ᨶᨽᩥᨾᩩᨡᨲ᩠ᨲᩮᩈᩩ, ᨾᩮᩣᩉᩣ’ᨶᩅᨭ᩠ᨮᩥᨲᩦᩈᩩ ᨧ;

ᨸᨵᩣᨶ ᨴᨠ᩠ᨡᨲᩣ ᨡᩮᨴ, ᩈᩉᨲ᩠ᨳᩣᨴᩮᩣ ᩅᩥ ᨴᩥᩔᨲᩥ.

ᩅᩥᨿᩮᩣᨣᩮ ¶ ᨩᩣᨶᨶᩮ ᨧᩣ’ᨵᩮᩣ,ᨽᩣᨣ ᨶᩥᨧ᩠ᨨᨿ [ᨽᩣᨣ’ᨶᩥᨧ᩠ᨨᨿ (ᨽᩣᨣ+ᩋᨶᩥᨧ᩠ᨨᨿ-ᨭᩦ)] ᩈᩩᨴ᩠ᨵᩥᩈᩩ;

ᩎᩈᨴᨲ᩠ᨳᩮ ᨸᩁᩥᨽᩅᩮ, ᨴᩮᩈ ᨻ᩠ᨿᩣᨸᨶ ᩉᩣᨶᩥᩈᩩ;

ᩅᨧᩮᩣᨠᩕᩥᨿᩣᨿ ᨳᩮᨿ᩠ᨿᩮ ᨧ, ᨬᩣᨱᨸ᩠ᨸᨲ᩠ᨲᩣᨴᩥᨠᩮ ᩋᩅ.

ᨸᨧ᩠ᨨᩣ ᨽᩩᩈᨲ᩠ᨲ ᩈᩣᨴᩥᩈ᩠ᨿᩣ, ᨶᩩᨸᨧ᩠ᨨᩥᨶ᩠ᨶᩣ’ᨶᩩᩅᨲ᩠ᨲᩥᩈᩩ;

ᩉᩦᨶᩮ ᨧ ᨲᨲᩥᨿᨲ᩠ᨳᩣ’ᨵᩮᩣ, ᨽᩣᨣᩮᩈ᩠ᩅ’ᨶᩩᨣᨲᩮ ᩉᩥᨲᩮ;

ᨴᩮᩈᩮ ᩃᨠ᩠ᨡᨱ ᩅᩥᨧ᩠ᨨᩮ’ᨲ᩠ᨳ, ᨾ᩠ᨽᩪᨲ ᨽᩣᨣᩣᨴᩥᨠᩮ ᩋᨶᩩ.

ᩈᨾᨶ᩠ᨲᨲ᩠ᨳᩮ ᨸᩁᩥᨧ᩠ᨨᩮᨴᩮ, ᨸᩪᨩᩣ’ᩃᩥᨦ᩠ᨣᨶ ᩅᨩ᩠ᨩᨶᩮ;

ᨴᩮᩣᩈᨠ᩠ᨡᩣᨶᩮ ᨶᩥᩅᩣᩈᨶᩣ, ᩅᨬ᩠ᨬᩣ’ᨵᩣᩁᩮᩈᩩ ᨽᩮᩣᨩᨶᩮ;

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

ᩌᨽᩥᨾᩩᨡ᩠ᨿ ᩅᩥᩈᩥᨭ᩠ᨮᩩ’ᨴ᩠ᨵ, ᨠᨾ᩠ᨾᩈᩣᩁᩩᨸ᩠ᨸᩅᩩᨴ᩠ᨵᩥᩈᩩ;

ᨸᩪᨩᩣ’ᨵᩥᨠ ᨠᩩᩃᩣ’ᩈᨧ᩠ᨧ, ᩃᨠ᩠ᨡᨱᩣᨴᩥᨾ᩠ᩉᩥ ᨧᩣᨸ᩠ᨿ’ᨽᩥ.

ᩋᨵᩥᨠᩥ’ᩔᩁ, ᨸᩣᨮᩣ’ᨵᩥ, ᨭ᩠ᨮᩣᨶ, ᨸᩣᨸᩩᨱᨶᩮᩈ᩠ᩅ’ᨵᩥ;

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

ᨸᨭᩥᨴᩣᨶᨶᩥᩈᩮᨵᩮᩈᩩ, ᩅᩣᨾᩣ’ᨴᩣᨶᨶᩥᩅᨲ᩠ᨲᩥᩈᩩ;

ᩈᩣᨴᩥᩈᩮ ᨸᨭᩥᨶᩥᨵᩥᨾ᩠ᩉᩥ, ᩌᨽᩥᨾᩩᨡ᩠ᨿᨣᨲᩦᩈᩩ ᨧ.

ᨸᨲᩥᨻᩮᩣᨵᩮ ᨸᨲᩥᨣᨲᩮ, ᨲᨳᩣ ᨸᩩᨶᨠᩕᩥᨿᩣᨿ ᨧ;

ᩈᨾ᩠ᨽᩣᩅᨶᩮ ᨸᨭᩥᨧ᩠ᨧᨲ᩠ᨳᩮ, ᨸᨲᩦᨲᩥ ᩃᨠ᩠ᨡᨱᩣᨴᩥᨠᩮ;

ᩈᩩ ᩈᩮᩣᨽᨶᩮ ᩈᩩᨡᩮ ᩈᨾ᩠ᨾᩣ, ᨽᩩᩈ ᩈᩩᨭ᩠ᨮᩩ ᩈᨾᩥᨴ᩠ᨵᩥᩈᩩ.

ᩌᨽᩥᨾᩩᨡ᩠ᨿ, ᩈᨾᩦᨸᩣ’ᨴᩥ, ᨠᨾ᩠ᨾᩣ’ᩃᩥᨦ᩠ᨣᨶ ᨸᨲ᩠ᨲᩥᩈᩩ;

ᨾᩁᩥᨿᩣᨴᩩ’ᨴ᩠ᨵᨠᨾ᩠ᨾᩥ’ᨧ᩠ᨨᩣ, ᨻᨶ᩠ᨵᨶᩣ’ᨽᩥᩅᩥᨵᩦᩈᩩ ᩌ.

ᨶᩥᩅᩣᩈᩣ’ᩅ᩠ᩉᩣᨶ ᨣᩉᨱ, ᨠᩥᨧ᩠ᨨᩮ’ᩈᨲ᩠ᨳ ᨶᩥᩅᨲ᩠ᨲᩥᩈᩩ;

ᩋᨸ᩠ᨸᩈᩣᨴᩣ’ᩈᩥ ᩈᩁᨱ, ᨸᨲᩥᨭ᩠ᨮᩣ’ᩅᩥᨾ᩠ᩉᨿᩣᨴᩥᩈᩩ.

ᩋᨶ᩠ᨲᩮᩣᨽᩣᩅ ᨽᩩᩈᨲ᩠ᨲᩣ’ᨲᩥ, ᩈᨿ ᨸᩪᨩᩣᩈ᩠ᩅ’ᨲᩥᨠ᩠ᨠᨾᩮ;

ᨽᩪᨲᨽᩣᩅᩮ ᨸᩈᩴᩈᩣᨿᩴ, ᨴᩊ᩠ᩉᨲ᩠ᨳᩣᨴᩮᩣ ᩈᩥᨿᩣ ᩋᨲᩥ.

ᩈᨾ᩠ᨽᩣᩅᨶᩮ ᨧ ᨣᩁᩉᩣ, ᨸᩮᨠ᩠ᨡᩣᩈᩩ ᨧ ᩈᨾᩩᨧ᩠ᨧᨿᩮ;

ᨸᨬ᩠ᩉᩮ ᩈᩴᩅᩁᨱᩮ ᨧᩮᩅ, ᩌᩈᩦᩈᨲ᩠ᨳᩮ ᩋᨸᩦ’ᩁᩥᨲᩴ.

ᨶᩥᨴ᩠ᨴᩮᩈᩮ ᩅᨩ᩠ᨩᨶᩮ ᨸᩪᨩᩣ, ᨸᨣᨲᩮ ᩅᩣᩁᨱᩮᨸᩥ ᨧ;

ᨸᨴᩩᩔᨶᩮ ᨧ ᨣᩁᩉᩣ, ᨧᩮᩣᩁᩥᨠᩣ’ᨴᩮᩣ ᩈᩥᨿᩣ ᩋᨸ.

ᩈᨾᩦᨸᨸᩪᨩᩣ ¶ ᩈᩣᨴᩥᩔ, ᨴᩮᩣᩈᨠ᩠ᨡᩣᨶᩮᩣ’ᨸᨸᨲ᩠ᨲᩥᩈᩩ;

ᨽᩩᩈᨲ᩠ᨲᩮᩣ’ᨸᨣᨾᩣ’ᨵᩥᨠ᩠ᨿ, ᨸᩩᨻ᩠ᨻᨠᨾ᩠ᨾᨶᩥᩅᨲ᩠ᨲᩥᩈᩩ;

ᨣᨿ᩠ᩉᩣᨠᩣᩁᩮᩣ’ᨸᩁᩥᨲ᩠ᨲᩮᩈᩩ, ᩏᨸᩮ’ᨲ᩠ᨿ [ᩏᨸᩮᨲ᩠ᨿ=ᩏᨸ+ᩍᨲᩥ]’ᨶᩈᨶᩣ’ᨴᩥᨠᩮ.

ᩑᩅᩴ ᨶᩥᨴᩔᨶᩣ’ᨠᩣᩁᩮᩣ, ᨸᨾᩣᩈᩩ ᩈᨾ᩠ᨸᩉᩴᩈᨶᩮ;

ᩏᨸᨴᩮᩈᩮ ᨧ ᩅᨧᨶ, ᨸᨭᩥᨣ᩠ᨣᩣᩉᩮ’ᩅᨵᩣᩁᨱᩮ;

ᨣᩁᩉᩣᨿᩮ’ᨴᨾᨲ᩠ᨳᩮ ᨧ, ᨸᩁᩥᨾᩣᨶᩮ ᨧ ᨸᩩᨧ᩠ᨨᨶᩮ.

ᩈᨾᩩᨧ᩠ᨧᨿᩮ ᩈᨾᩣᩉᩣᩁᩮ, ᨶ᩠ᩅᩣᨧᨿᩮ ᨧᩮ’ᨲᩁᩦᨲᩁᩮ;

ᨸᨴᨸᩪᩁᨱᨾᨲ᩠ᨲᩮ ᨧ, ᨧᩈᨴ᩠ᨴᩮᩣ ᩋᩅᨵᩣᩁᨱᩮ.

ᩍᨲᩥ ᩉᩮᨲᩩᨸᨠᩣᩁᩮᩈᩩ, ᩌᨴᩥᨾ᩠ᩉᩥ ᨧᩣ’ᩅᨵᩣᩁᨱᩮ;

ᨶᩥᨴᩔᨶᩮ ᨸᨴᨲ᩠ᨳᩔ, ᩅᩥᨸᩃ᩠ᩃᩣᩈᩮ ᩈᨾᩣᨸᨶᩮ.

ᩈᨾᩩᨧ᩠ᨧᨿᩮ ᨧᩮᩣ’ᨸᨾᩣᨿᩴ, ᩈᩴᩈᨿᩮ ᨸᨴᨸᩪᩁᨱᩮ;

ᩅᩅᨲ᩠ᨳᩥᨲᩅᩥᨽᩣᩈᩣᨿᩴ, ᩅᩣ’ᩅᩔᨣ᩠ᨣᩮ ᩅᩥᨠᨸ᩠ᨸᨶᩮ.

ᨽᩪᩈᨶᩮ ᩅᩣᩁᨱᩮ ᨧᩣ’ᩃᩴ, ᩅᩩᨧ᩠ᨧᨲᩮ ᨸᩁᩥᨿᨲ᩠ᨲᩥᨿᩴ;

ᩋᨳᩮᩣ’ᨳᩣ’ᨶᨶ᩠ᨲᩁᩣ’ᩁᨾ᩠ᨽ, ᨸᨬ᩠ᩉᩮᩈᩩ ᨸᨴᨸᩪᩁᨱᩮ.

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

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

ᨸᩩᨧ᩠ᨨᩣ’ᩅᨵᩣᩁᨱᩣ’ᨶᩩᨬ᩠ᨬᩣ, ᩈᩣᨶ᩠ᨲ᩠ᩅᨶᩣ’ᩃᨸᨶᩮ [ᩈᨶ᩠ᨲᨶᩣᩃᨸᨶᩮ (ᨠ.)] ᨶᨶᩩ;

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

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

ᨿᩣᩅ ᨲᩩ ᨲᩣᩅ ᩈᩣᨠᩃ᩠ᨿ, ᨾᩣᨶᩣ’ᩅᨵ᩠ᨿ’ᩅᨵᩣᩁᨱᩮ.

ᨸᩣᨧᩦ, ᨸᩩᩁ, ᨦ᩠ᨣᨲᩮᩣᨲ᩠ᨳᩮᩈᩩ, ᨸᩩᩁᨲ᩠ᨳᩣ ᨸᨮᨾᩮ ᨸ᩠ᨿᨳ;

ᨸᨻᨶ᩠ᨵᩮ ᨧ ᨧᩥᩁᩣᨲᩦᨲᩮ, ᨶᩥᨠᨭᩣᨣᩣᨾᩥᨠᩮ ᨸᩩᩁᩣ.

ᨶᩥᩈᩮᨵᩅᩣᨠ᩠ᨿᩣᩃᨦ᩠ᨠᩣᩁᩣ, ᩅᨵᩣᩁᨱᨸᩈᩥᨴ᩠ᨵᩥᩈᩩ;

ᨠᩣᨾᩴ ᨿᨴ᩠ᨿᨸᩥᩈᨴ᩠ᨴᨲ᩠ᨳᩮ, ᩑᨠᩴᩈᨲ᩠ᨳᩮ ᨧ ᨴᩥᩔᨲᩥ;

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

ᩉᩥ ¶ ᨠᩣᩁᨱᩮ ᩅᩥᩈᩮᩈᩣ’ᩅ, ᨵᩣᩁᨱᩮ ᨸᨴᨸᩪᩁᨱᩮ;

ᨲᩩ ᩉᩮᨲᩩᩅᨩ᩠ᨩᩮ ᨲᨲ᩠ᨳᩣ’ᨳ, ᨠᩩ ᨸᩣᨸᩮ’ᩈᨲ᩠ᨳ’ᨠᩩᨧ᩠ᨨᨶᩮ.

ᨶᩩ ᩈᩴᩈᨿᩮ ᨧ ᨸᨬ᩠ᩉᩮ ᨳ, ᨶᩣᨶᩣ’ ᨶᩮᨠᨲ᩠ᨳ ᩅᨩ᩠ᨩᨶᩮ;

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

ᩋᨾᩣ ᩈᩉᩈᨾᩦᨸᩮ ᨳ, ᨽᩮᨴᩮ ᩋᨸ᩠ᨸᨮᨾᩮ ᨸᩩᨶ;

ᨠᩥᩁᩣ’ᨶᩩᩔᩅᩣ’ᩁᩩᨧᩥᩈᩩ, ᩏᨴᩣ’ᨸ᩠ᨿᨲ᩠ᨳᩮ ᩅᩥᨠᨸ᩠ᨸᨶᩮ.

ᨸᨲᩦᨧᩦ ᨧᩁᩥᨾᩮ ᨸᨧ᩠ᨨᩣ, ᩈᩣᨾᩥ ᨲ᩠ᩅᨴ᩠ᨵᩮ ᨩᩥᨣᩩᨧ᩠ᨨᨶᩮ;

ᩉᩣ ᨡᩮᨴᩈᩮᩣᨠᨴᩩᨠ᩠ᨡᩮᩈᩩ, ᨡᩮᨴᩮ ᨲ᩠ᩅ’ᩉᩉ ᩅᩥᨾ᩠ᩉᨿᩮ;

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

ᨲᩩᨶ ᨲ᩠ᩅᩣᨶ ᨲᩅᩮ ᨲ᩠ᩅᩣ ᨲᩩᩴ, ᨵᩣ ᩈᩮᩣ ᨳᩣ ᨠ᩠ᨡᨲ᩠ᨲᩩ, ᨾᩮᩅ ᨧ;

ᨲᩮᩣ ᨳ ᨲᩕ ᩉᩥᨬ᩠ᨧᨶᩴ ᩉᩥᩴᩉᩴ, ᨵᩥ ᩉ ᩉᩥ ᨵ ᨵᩩᨶᩣ ᩁᩉᩥ.

ᨴᩣᨶᩥ ᩅᩮᩣᨴᩣᨧᨶᩴ ᨴᩣᨩ᩠ᨩ, ᨳᩴ ᨲᨲ᩠ᨲᩴ ᨩ᩠ᨫ ᨩ᩠ᨩᩩ ᩌᨴᨿᩮᩣ;

ᩈᨣ᩠ᨣᨠᨱ᩠ᨯᩮᩣ ¶ ᨧ ᨽᩪᨠᨱ᩠ᨯᩮᩣ, ᨲᨳᩣ ᩈᩣᨾᨬ᩠ᨬᨠᨱ᩠ᨯᩥᨲᩥ;

ᨠᨱ᩠ᨯᨲ᩠ᨲᨿᩣᨶ᩠ᩅᩥᨲᩣ ᩑᩈᩣ, ᩋᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩣ.

ᨸᩁᨠ᩠ᨠᨾᨽᩩᨩᩮᩣ ᨶᩣᨾ, ᨽᩪᨸᩣᩃᩮᩣ ᨣᩩᨱᨽᩪᩈᨶᩮᩣ;

ᩃᨦ᩠ᨠᩣᨿ ᨾᩣᩈᩥ ᨲᩮᨩᩔᩦ, ᨩᨿᩦ ᨠᩮᩈᩁᩥᩅᩥᨠ᩠ᨠᨾᩮᩣ.

ᩅᩥᨽᩥᨶ᩠ᨶᩴ ᨧᩥᩁᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩴ ᨶᩥᨠᩣᨿ-

ᨲ᩠ᨲᨿᩈ᩠ᨾᩥᨬ᩠ᨧ ᨠᩣᩁᩮᩈᩥ ᩈᨾ᩠ᨾᩣ ᩈᨾᨣ᩠ᨣᩮ;

ᨾᩉᨣ᩠ᨥᩮᩉᩥ ᩁᨠ᩠ᨡᩮᩈᩥ ᨿᩮᩣ ᨸᨧ᩠ᨧᨿᩮᩉᩥ.

ᨿᩮᨶ ᩃᨦ᩠ᨠᩣ ᩅᩥᩉᩣᩁᩮᩉᩥ, ᨣᩣᨾᩣ’ᩁᩣᨾᨸᩩᩁᩦᩉᩥ ᨧ;

ᨠᩥᨲ᩠ᨲᩥᨿᩣ ᩅᩥᨿ ᩈᨾ᩠ᨻᩣᨵᩦ, ᨠᨲᩣ ᨡᩮᨲ᩠ᨲᩮᩉᩥ ᩅᩣᨸᩥᩉᩥ.

ᨿᩔᩣ’ᩈᩣᨵᩣᩁᨱᩴ ᨸᨲ᩠ᩅᩣ, ᨶᩩᨣ᩠ᨣᩉᩴ ᩈᨻ᩠ᨻᨠᩣᨾᨴᩴ;

ᩋᩉᨾ᩠ᨸᩥ ᨣᨶ᩠ᨳᨠᩣᩁᨲ᩠ᨲᩴ, ᨸᨲ᩠ᨲᩮᩣ ᩅᩥᨻᩩᨵᨣᩮᩣᨧᩁᩴ.

ᨠᩣᩁᩥᨲᩮ ᨲᩮᨶ ᨸᩣᩈᩣᨴ, ᨣᩮᩣᨸᩩᩁᩣᨴᩥᩅᩥᨽᩪᩈᩥᨲᩮ;

ᩈᨣ᩠ᨣᨡᨱ᩠ᨯᩮ’ᩅ ᨲᨲ᩠ᨲᩮᩣᨿᩣ, ᩈᨿᩈ᩠ᨾᩥᩴ ᨸᨲᩥᨻᩥᨾ᩠ᨻᩥᨲᩮ.

ᨾᩉᩣᨩᩮᨲᩅᨶᩣ’ᨡ᩠ᨿᨾ᩠ᩉᩥ, ᩅᩥᩉᩣᩁᩮ ᩈᩣᨵᩩᩈᨾ᩠ᨾᨲᩮ;

ᩈᩁᩮᩣᨣᩣᨾᩈᨾᩪᩉᨾ᩠ᩉᩥ, ᩅᩈᨲᩣ ᩈᨶ᩠ᨲᩅᩩᨲ᩠ᨲᩥᨶᩣ.

ᩈᨴ᩠ᨵᨾ᩠ᨾᨭ᩠ᨮᩥᨲᩥᨠᩣᨾᩮᨶ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨵᩦᨾᨲᩣ;

ᨳᩮᩁᩮᨶ ᩁᨧᩥᨲᩣ ᩑᩈᩣ, ᩋᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩣᨲᩥ.