📜
ᨶᨾᩮᩣ ᨲᩔ ᨽᨣᩅᨲᩮᩣ ᩋᩁᩉᨲᩮᩣ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩔ
ᩋᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩣ
ᨻᩩᨴ᩠ᨵᨸ᩠ᨸᨱᩣᨾᩮᩣ
ᨲᨳᩣᨣᨲᩮᩣ ¶ ᨿᩮᩣ ᨠᩁᩩᨱᩣᨠᩁᩮᩣ ᨠᩁᩮᩣ,
ᨸᨿᩣᨲ’ᨾᩮᩣᩈᨩ᩠ᨩ ᩈᩩᨡᨸ᩠ᨸᨴᩴ ᨸᨴᩴ;
ᩋᨠᩣ ᨸᩁᨲ᩠ᨳᩴ ᨠᩃᩥᩈᨾ᩠ᨽᩅᩮ ᨽᩅᩮ,
ᨶᨾᩣᨾᩥ ᨲᩴ ᨠᩮᩅᩃᨴᩩᨠ᩠ᨠᩁᩴ ᨠᩁᩴ.
ᨵᨾ᩠ᨾᨸ᩠ᨸᨱᩣᨾᩮᩣ
ᩋᨸᩪᨩᨿᩩᩴ ᨿᩴ ᨾᩩᨶᩥᨠᩩᨬ᩠ᨩᩁᩣ ᨩᩁᩣ,
ᩁᩩᨩᩣᨴᩥᨾᩩᨲ᩠ᨲᩣ ᨿᩉᩥᨾᩩᨲ᩠ᨲᩁᩮ ᨲᩁᩮ;
ᨮᩥᨲᩣ ᨲᩥᩅᨭ᩠ᨭᨾ᩠ᨻᩩᨶᩥᨵᩥᩴ ᨶᩁᩣᨶᩁᩣ,
ᨲᩁᩥᩴᩈᩩ ᨲᩴ ᨵᨾ᩠ᨾᨾᨥᨸ᩠ᨸᩉᩴ ᨸᩉᩴ.
ᩈᨦ᩠ᨥᨸ᩠ᨸᨱᩣᨾᩮᩣ
ᨣᨲᩴ ᨾᩩᨶᩥᨶ᩠ᨴᩮᩣ’ᩁᩈᩈᩪᨶᩩᨲᩴ ᨶᩩᨲᩴ,
ᩈᩩᨸᩩᨬ᩠ᨬᨡᩮᨲ᩠ᨲᩴ ᨽᩩᩅᨶᩮ ᩈᩩᨲᩴ ᩈᩩᨲᩴ;
ᨣᨱᨾ᩠ᨸᩥ ᨸᩣᨱᩦᨠᨲᩈᩴᩅᩁᩴ ᩅᩁᩴ,
ᩈᨴᩣ ᨣᩩᨱᩮᩣᨥᩮᨶ ᨶᩥᩁᨶ᩠ᨲᩁ’ᨶ᩠ᨲᩁᩴ.
ᨸᨭᩥᨬ᩠ᨬᩣ
ᨶᩣᨾᩃᩥᨦ᩠ᨣᩮᩈᩩ ᨠᩮᩣᩈᩃ᩠ᩃ, ᨾᨲ᩠ᨳᨶᩥᨧ᩠ᨨᨿᨠᩣᩁᨱᩴ;
ᨿᨲᩮᩣ ᨾᩉᨻ᩠ᨻᩃᩴ ᨻᩩᨴ᩠ᨵ, ᩅᨧᨶᩮ ᨸᩣᨭᩅᨲ᩠ᨳᩥᨶᩴ.
ᨶᩣᨾᩃᩥᨦ᩠ᨣᩣᨶ᩠ᨿ’ᨲᩮᩣ ¶ ᨻᩩᨴ᩠ᨵ, ᨽᩣᩈᩥᨲᩔᩣ’ᩁᩉᩣᨶ᩠ᨿ’ᩉᩴ;
ᨴᩔᨿᨶ᩠ᨲᩮᩣ ᨸᨠᩣᩈᩮᩔ, ᨾᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩴ.
ᨸᩁᩥᨽᩣᩈᩣ
ᨽᩥᨿ᩠ᨿᩮᩣ ᩁᩪᨸᨶ᩠ᨲᩁᩣ ᩈᩣᩉ, ᨧᩁᩥᨿᩮᨶ ᨧ ᨠᨲ᩠ᨳᨧᩥ;
ᨠ᩠ᩅᨧᩣ’ ᩉᨧ᩠ᨧᩅᩥᨵᩣᨶᩮᨶ ᨬᩮᨿ᩠ᨿᩴ ᨳᩦᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩴ.
ᩋᨽᩥᨶ᩠ᨶᩃᩥᨦ᩠ᨣᩣᨶᩴᨿᩮᩅ, ᨴ᩠ᩅᨶ᩠ᨴᩮᩣ ᨧ, ᩃᩥᨦ᩠ᨣᩅᩣᨧᨠᩣ;
ᨣᩣᨳᩣᨸᩣᨴᨶ᩠ᨲᨾᨩ᩠ᨫᨭ᩠ᨮᩣ, ᨸᩩᨻ᩠ᨻᩴ ᨿᨶ᩠ᨲ᩠ᨿᨸᩁᩮ ᨸᩁᩴ.
ᨸᩩᨾᩥᨲ᩠ᨳᩥᨿᩴ ᨸᨴᩴ ᨴ᩠ᩅᩦᩈᩩ, ᩈᨻ᩠ᨻᩃᩥᨦ᩠ᨣᩮ ᨧ ᨲᩦᩈ᩠ᩅᩥᨲᩥ;
ᩋᨽᩥᨵᩣᨶᨶ᩠ᨲᩁᩣᩁᨾ᩠ᨽᩮ, ᨬᩮᨿ᩠ᨿᩴ ᨲ᩠ᩅ’ᨶ᩠ᨲ ᨾᨳᩣᨴᩥ ᨧ.
ᨽᩥᨿ᩠ᨿᩮᩣ ᨸᨿᩮᩣᨣ ᨾᩣᨣᨾ᩠ᨾ, ᩈᩮᩣᨣᨲᩮ ᩌᨣᨾᩮ ᨠ᩠ᩅᨧᩥ;
ᨶᩥᨥᨱ᩠ᨯᩩ ᨿᩩᨲ᩠ᨲᩥ ᨬ᩠ᨧᩣᨶᩦᨿ, ᨶᩣᨾᩃᩥᨦ᩠ᨣᩴ ᨠᨳᩦᨿᨲᩦᨲᩥ.
᪑. ᩈᨣ᩠ᨣᨠᨱ᩠ᨯ
ᨻᩩᨴ᩠ᨵᩮᩣ ᨴᩈᨻᩃᩮᩣ ᩈᨲ᩠ᨳᩣ, ᩈᨻ᩠ᨻᨬ᩠ᨬᩪ ᨴ᩠ᩅᩥᨸᨴᩩᨲ᩠ᨲᨾᩮᩣ;
ᨾᩩᨶᩥᨶ᩠ᨴᩮᩣ ᨽᨣᩅᩣ ᨶᩣᨳᩮᩣ, ᨧᨠ᩠ᨡᩩᨾ’ᨦ᩠ᨣᩦᩁᩈᩮᩣ ᨾᩩᨶᩥ.
ᩃᩮᩣᨠᨶᩣᨳᩮᩣ’ ᨶᨵᩥᩅᩁᩮᩣ, ᨾᩉᩮᩈᩥ ᨧ ᩅᩥᨶᩣᨿᨠᩮᩣ;
ᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩩ ᩈᩩᨣᨲᩮᩣ, ᨽᩪᩁᩥᨸᨬ᩠ᨬᩮᩣ ᨧ ᨾᩣᩁᨩᩥ.
ᨶᩁᩈᩦᩉᩮᩣ ᨶᩁᩅᩁᩮᩣ, ᨵᨾ᩠ᨾᩁᩣᨩᩣ ᨾᩉᩣᨾᩩᨶᩥ;
ᨴᩮᩅᨴᩮᩅᩮᩣ ᩃᩮᩣᨠᨣᩁᩩ, ᨵᨾ᩠ᨾᩔᩣᨾᩦ ᨲᨳᩣᨣᨲᩮᩣ.
ᩈᨿᨾ᩠ᨽᩪ ᩈᨾ᩠ᨾᩣᩈᨾ᩠ᨻᩩᨴ᩠ᨵᩮᩣ, ᩅᩁᨸᨬ᩠ᨬᩮᩣ ᨧ ᨶᩣᨿᨠᩮᩣ;
ᨩᩥᨶᩮᩣ, ᩈᨠ᩠ᨠᩮᩣ ᨲᩩ ᩈᩥᨴ᩠ᨵᨲ᩠ᨳᩮᩣ, ᩈᩩᨴ᩠ᨵᩮᩣᨴᨶᩥ ᨧ ᨣᩮᩣᨲᨾᩮᩣ.
ᩈᨠ᩠ᨿᩈᩦᩉᩮᩣ ᨲᨳᩣ ᩈᨠ᩠ᨿ, ᨾᩩᨶᩥ ᨧᩣᨴᩥᨧ᩠ᨧᨻᨶ᩠ᨵᩩ ᨧ;
ᨾᩮᩣᨠ᩠ᨡᩮᩣ ᨶᩥᩁᩮᩣᨵᩮᩣ ᨶᩥᨻ᩠ᨻᩣᨶᩴ, ᨴᩦᨸᩮᩣ ᨲᨱ᩠ᩉᨠ᩠ᨡᨿᩮᩣ ᨸᩁᩴ;
ᨲᩣᨱᩴ ᩃᩮᨱ ᨾᩁᩪᨸᨬ᩠ᨧ, ᩈᨶ᩠ᨲᩴ ᩈᨧ᩠ᨧ ᨾᨶᩣᩃᨿᩴ.
ᩋᩈᨦ᩠ᨡᨲᩴ ᩈᩥᩅ ᨾᨾᨲᩴ ᩈᩩᨴᩩᨴ᩠ᨴᩈᩴ,
ᨸᩁᩣᨿᨱᩴ ᩈᩁᨱ ᨾᨶᩦᨲᩥᨠᩴ ᨲᨳᩣ;
ᩋᨶᩣᩈᩅᩴ ᨵᩩᩅ ᨾᨶᩥᨴᩔᨶᩣ’ ᨠᨲᩣ,
ᨸᩃᩮᩣᨠᩥᨲᩴ ᨶᩥᨸᩩᨱ ᨾᨶᨶ᩠ᨲ ᨾᨠ᩠ᨡᩁᩴ.
ᨴᩩᨠ᩠ᨡᨠ᩠ᨡᨿᩮᩣ ¶ ᨻ᩠ᨿᩣᨻᨩ᩠ᨫᨬ᩠ᨧ [ᨻ᩠ᨿᩣᨸᨩ᩠ᨩᩴ (ᨭᩦᨠᩣ)], ᩅᩥᩅᨭ᩠ᨭᩴ ᨡᩮᨾ ᨠᩮᩅᩃᩴ;
ᩋᨸᩅᨣ᩠ᨣᩮᩣ ᩅᩥᩁᩣᨣᩮᩣ ᨧ, ᨸᨱᩦᨲ ᨾᨧ᩠ᨧᩩᨲᩴ ᨸᨴᩴ.
ᨿᩮᩣᨣᨠ᩠ᨡᩮᨾᩮᩣ ᨸᩣᩁ ᨾᨸᩥ, ᨾᩩᨲ᩠ᨲᩥ ᩈᨶ᩠ᨲᩥ ᩅᩥᩈᩩᨴ᩠ᨵᩥᨿᩮᩣ;
ᩅᩥᨾᩩᨲ᩠ᨿ’ ᩈᨦ᩠ᨡᨲᨵᩣᨲᩩ, ᩈᩩᨴ᩠ᨵᩥ ᨶᩥᨻ᩠ᨻᩩᨲᩥᨿᩮᩣ ᩈᩥᨿᩩᩴ.
ᨡᩦᨱᩣᩈᩅᩮᩣ ᨲ᩠ᩅ’ᩈᩮᨠ᩠ᨡᩮᩣ ᨧ, ᩅᩦᨲᩁᩣᨣᩮᩣ ᨲᨳᩣ’ ᩁᩉᩣ;
ᨴᩮᩅᩃᩮᩣᨠᩮᩣ ᨴᩥᩅᩮᩣ ᩈᨣ᩠ᨣᩮᩣ [ᨶᩣᨠᩮᩣ (ᩈᩦ.)],
ᨲᩥᨴᩥᩅᩮᩣ ᨲᩥᨴᩈᩣᩃᨿᩮᩣ.
ᨲᩥᨴᩈᩣ ᨲ᩠ᩅ’ᨾᩁᩣ ᨴᩮᩅᩣ, ᩅᩥᨻᩩᨵᩣ ᨧ ᩈᩩᨵᩣᩈᩥᨶᩮᩣ;
ᩈᩩᩁᩣ ᨾᩁᩪ ᨴᩥᩅᩮᩣᨠᩣ ᨧᩣ, ᨾᨲᨸᩣ ᩈᨣ᩠ᨣᩅᩣᩈᩥᨶᩮᩣ.
ᨶᩥᨩ᩠ᨩᩁᩣ’ ᨶᩥᨾᩥᩈᩣ ᨴᩥᨻ᩠ᨻᩣ, ᩋᨸᩩᨾᩮ ᨴᩮᩅᨲᩣᨶᩥ ᨧ [ᨴᩮᩅᨲᩣ ᩑᩅ ᨴᩮᩅᨲᩣᨶᩥ, ᩈᨠᨲ᩠ᨳᩮ ᨶᩥᨸᨧ᩠ᨧᨿᩮᩣ (ᨭᩦᨠᩣ)];
ᩈᩥᨴ᩠ᨵᩮᩣ ᨽᩪᨲᩮᩣ ᨧ ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ, ᨣᩩᨿ᩠ᩉᨠᩮᩣ ᨿᨠ᩠ᨡ ᩁᨠ᩠ᨡᩈᩣ;
ᨠᩩᨾ᩠ᨽᨱ᩠ᨯᩮᩣ ᨧ ᨸᩥᩈᩣᨧᩣ’ᨴᩦ, ᨶᩥᨴ᩠ᨴᩥᨭ᩠ᨮᩣ ᨴᩮᩅᨿᩮᩣᨶᩥᨿᩮᩣ.
ᨸᩩᨻ᩠ᨻᨴᩮᩅᩣ ᩈᩩᩁᩁᩥᨸᩪ, ᩋᩈᩩᩁᩣ ᨴᩣᨶᩅᩣ ᨸᩩᨾᩮ;
ᨲᨻ᩠ᨻᩥᩈᩮᩈᩣ ᨸᩉᩣᩁᩣᨴᩮᩣ, ᩈᨾ᩠ᨻᩁᩮᩣ ᨻᩃᩥᩌᨴᨿᩮᩣ.
ᨸᩥᨲᩣᨾᩉᩮᩣ ᨸᩥᨲᩣ ᨻᩕᩉ᩠ᨾᩣ, ᩃᩮᩣᨠᩮᩈᩮᩣ ᨠᨾᩃᩣᩈᨶᩮᩣ;
ᨲᨳᩣ ᩉᩥᩁᨬ᩠ᨬᨣᨻ᩠ᨽᩮᩣ ᨧ, ᩈᩩᩁᨩᩮᨭ᩠ᨮᩮᩣ ᨸᨩᩣᨸᨲᩥ.
ᩅᩣᩈᩩᨴᩮᩅᩮᩣ ᩉᩁᩥ [ᩉᩁᩦ (ᨭᩦᨠᩣ)] ᨠᨱ᩠ᩉᩮᩣ, ᨠᩮᩈᩅᩮᩣ ᨧᨠ᩠ᨠᨸᩣᨱ᩠ᨿ’ᨳ;
ᨾᩉᩥᩔᩁᩮᩣ ᩈᩥᩅᩮᩣ ᩈᩪᩃᩦ, ᩍᩔᩁᩮᩣ ᨸᩈᩩᨸᨲ᩠ᨿ’ᨸᩥ.
ᩉᩁᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᨠᩩᨾᩣᩁᩮᩣ ᨲᩩ, ᨡᨶ᩠ᨵᩮᩣ ᩈᨲ᩠ᨲᩥᨵᩁᩮᩣ ᨽᩅᩮ;
ᩈᨠ᩠ᨠᩮᩣ ᨸᩩᩁᩥᨶ᩠ᨴᨴᩮᩣ ᨴᩮᩅ, ᩁᩣᨩᩣ ᩅᨩᩥᩁᨸᩣᨱᩥ ᨧ;
ᩈᩩᨩᨾ᩠ᨸᨲᩥ ᩈᩉᩔᨠ᩠ᨡᩮᩣ, ᨾᩉᩥᨶ᩠ᨴᩮᩣ ᩅᨩᩥᩁᩣᩅᩩᨵᩮᩣ.
ᩅᩣᩈᩅᩮᩣ ᨧ ᨴᩈᩈᨲ, ᨶᨿᨶᩮᩣ ᨲᩥᨴᩥᩅᩣᨵᩥᨽᩪ;
ᩈᩩᩁᨶᩣᨳᩮᩣ ᨧ ᩅᨩᩥᩁ, ᩉᨲ᩠ᨳᩮᩣ ᨧ ᨽᩪᨲᨸᨲ᩠ᨿ’ᨸᩥ.
ᨾᨥᩅᩣ ᨠᩮᩣᩈᩥᨿᩮᩣ ᩍᨶ᩠ᨴᩮᩣ, ᩅᨲᩕᨽᩪ ᨸᩣᨠᩈᩣᩈᨶᩮᩣ;
ᩅᩥᨯᩮᩣᨩᩮᩣ ᨳ ᩈᩩᨩᩣ ᨲᩔ [ᩈᩩᨩᩣᨲᩣ’ᩔ (ᨭᩦᨠᩣ)], ᨽᩁᩥᨿᩣ ᨳ ᨸᩩᩁᩴ ᨽᩅᩮ.
ᨾᩈᨠ᩠ᨠᩈᩣᩁᩣ ¶ [ᨾᩈᨠ᩠ᨠᩈᩣᩁᩮᩣ (ᩈᩦ.)] ᩅᩔᩮᩣᨠ, ᩈᩣᩁᩣ ᨧᩮᩅᩣ’ ᨾᩁᩣᩅᨲᩦ;
ᩅᩮᨩᨿᨶ᩠ᨲᩮᩣ ᨲᩩ ᨸᩣᩈᩣᨴᩮᩣ,
ᩈᩩᨵᨾ᩠ᨾᩣ ᨲᩩ ᩈᨽᩣ ᨾᨲᩣ.
ᩅᩮᨩᨿᨶ᩠ᨲᩮᩣ ᩁᨳᩮᩣ ᨲᩔ,
ᩅᩩᨲ᩠ᨲᩮᩣ ᨾᩣᨲᩃᩥ ᩈᩣᩁᨳᩥ;
ᩑᩁᩣᩅᨱᩮᩣ ᨣᨩᩮᩣ ᨸᨱ᩠ᨯᩩ, ᨠᨾ᩠ᨻᩃᩮᩣ ᨲᩩ ᩈᩥᩃᩣᩈᨶᩴ.
ᩈᩩᩅᩦᩁᩮᩣᨧ᩠ᨧᩣᨴᨿᩮᩣ ᨸᩩᨲ᩠ᨲᩣ, ᨶᨶ᩠ᨴᩣ ᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ ᨽᩅᩮ;
ᨶᨶ᩠ᨴᨶᩴ ᨾᩥᩔᨠᩴ ᨧᩥᨲ᩠ᨲ, ᩃᨲᩣ ᨹᩣᩁᩩᩈᨠᩴ ᩅᨶᩣ.
ᩋᩈᨶᩥ ᨴ᩠ᩅᩦᩈᩩ ᨠᩩᩃᩥᩈᩴ, ᩅᨩᩥᩁᩴ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ;
ᩋᨧ᩠ᨨᩁᩣᨿᩮᩣᨲ᩠ᨳᩥᨿᩴ ᩅᩩᨲ᩠ᨲᩣ, ᩁᨾ᩠ᨽᩣ ᩋᩃᨾ᩠ᨻᩩᩈᩣᨴᨿᩮᩣ;
ᨴᩮᩅᩥᨲ᩠ᨳᩥᨿᩮᩣ ᨳ ᨣᨶ᩠ᨵᨻ᩠ᨻᩣ, ᨸᨬ᩠ᨧᩈᩥᨡᩮᩣᨲᩥ ᩌᨴᨿᩮᩣ.
ᩅᩥᨾᩣᨶᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨻ᩠ᨿᨾ᩠ᩉᩴ, ᨸᩦᨿᩪᩈᩴ ᨲ᩠ᩅᨾᨲᩴ ᩈᩩᨵᩣ;
ᩈᩥᨶᩮᩁᩩ ᨾᩮᩁᩩ ᨲᩥᨴᩥᩅᩣ, ᨵᩣᩁᩮᩣ ᨶᩮᩁᩩ ᩈᩩᨾᩮᩁᩩ ᨧ.
ᨿᩩᨣᨶ᩠ᨵᩁᩮᩣ ᩎᩈᨵᩁᩮᩣ, ᨠᩁᩅᩦᨠᩮᩣ ᩈᩩᨴᩔᨶᩮᩣ;
ᨶᩮᨾᩥᨶ᩠ᨵᩁᩮᩣ ᩅᩥᨶᨲᨠᩮᩣ, ᩋᩔᨠᨱ᩠ᨱᩮᩣ ᨠᩩᩃᩣᨧᩃᩣ.
ᨾᨶ᩠ᨴᩣᨠᩥᨶᩦ ᨲᨳᩣ’ᨠᩣᩈ, ᨣᨦ᩠ᨣᩣ ᩈᩩᩁᨶᨴᩦ ᨸ᩠ᨿᨳ;
ᨠᩮᩣᩅᩥᩊᩣᩁᩮᩣ ᨲᨳᩣ ᨸᩣᩁᩥ, ᨧ᩠ᨨᨲ᩠ᨲᨠᩮᩣ ᨸᩣᩁᩥᨩᩣᨲᨠᩮᩣ;
ᨠᨸ᩠ᨸᩁᩩᨠ᩠ᨡᩮᩣ ᨲᩩ ᩈᨶ᩠ᨲᩣᨶᩣ, ᨴᨿᩮᩣ ᨴᩮᩅᨴ᩠ᨴᩩᨾᩣ ᩈᩥᨿᩩᩴ.
ᨸᩣᨧᩦ ᨸᨲᩦᨫᩩ’ ᨴᩦᨧᩥ’ᨲ᩠ᨳᩦ, ᨸᩩᨻ᩠ᨻ ᨸᨧ᩠ᨨᩥᨾ ᩏᨲ᩠ᨲᩁᩣ;
ᨴᩥᩈᩣᨳ ᨴᨠ᩠ᨡᩥᨱᩣ’ ᨸᩣᨧᩦ, ᩅᩥᨴᩥᩈᩣ’ᨶᩩᨴᩥᩈᩣ ᨽᩅᩮ.
ᩑᩁᩣᩅᨲᩮᩣ [ᩑᩁᩣᩅᨱᩮᩣ (ᩈᩦ.), ᩋᨾᩁᨠᩮᩣᩈᩮ ᨸᨶ ᩑᩁᩣᩅᨲᩮᩣ ᩑᩅ ᩋᨲ᩠ᨳᩥ] ᨸᩩᨱ᩠ᨯᩁᩦᨠᩮᩣ, ᩅᩣᨾᨶᩮᩣ ᨠᩩᨾᩩᨴᩮᩣ’ ᨬ᩠ᨩᨶᩮᩣ;
ᨸᩩᨸ᩠ᨹᨴᨶ᩠ᨲᩮᩣ ᩈᨻ᩠ᨻᨽᩩᨾ᩠ᨾᩮᩣ, ᩈᩩᨸ᩠ᨸᨲᩦᨠᩮᩣ ᨴᩥᩈᩣᨣᨩᩣ.
ᨵᨲᩁᨭ᩠ᨮᩮᩣ ᨧ ᨣᨶ᩠ᨵᨻ᩠ᨻᩣ, ᨵᩥᨸᩮᩣ, ᨠᩩᨾ᩠ᨽᨱ᩠ᨯᩈᩣᨾᩥ ᨲᩩ;
ᩅᩥᩁᩩᩊ᩠ᩉᨠᩮᩣ, ᩅᩥᩁᩪᨸᨠ᩠ᨡᩮᩣ, ᨲᩩ ᨶᩣᨣᩣᨵᩥᨸᨲᩦᩁᩥᨲᩮᩣ.
ᨿᨠ᩠ᨡᩣᨵᩥᨸᩮᩣ ᩅᩮᩔᩅᨱᩮᩣ, ᨠᩩᩅᩮᩁᩮᩣ ᨶᩁᩅᩣᩉᨶᩮᩣ;
ᩋᩊᨠᩣ [ᩋᩃᨠᩣ (ᩋᨾᩁᨠᩮᩣᩈ)] ᩊᨠᨾᨶ᩠ᨴᩣᩔ, ᨸᩩᩁᩦ, ᨸᩉᩁᨱᩴ ᨣᨴᩣ;
ᨧᨲᩩᨴ᩠ᨴᩥᩈᩣᨶ ᨾᨵᩥᨸᩣ, ᨸᩩᨻ᩠ᨻᩣᨴᩦᨶᩴ ᨠᨾᩣ ᩍᨾᩮ.
ᨩᩣᨲᩅᩮᨴᩮᩣ ¶ ᩈᩥᨡᩦ ᨩᩮᩣᨲᩥ, ᨸᩣᩅᨠᩮᩣ ᨴᩉᨶᩮᩣ’ ᨶᩃᩮᩣ;
ᩉᩩᨲᩣᩅᩉᩮᩣ’ ᨧ᩠ᨧᩥᨾᩣ ᨵᩪᨾ, ᨠᩮᨲ᩠ᩅ’ᨣ᩠ᨣᩥ ᨣᩥᨶᩥ ᨽᩣᨶᩩᨾᩣ.
ᨲᩮᨩᩮᩣ ᨵᩪᨾᩈᩥᨡᩮᩣ ᩅᩣᨿᩩ, ᩈᨡᩮᩣ ᨧ ᨠᨱ᩠ᩉᩅᨲ᩠ᨲᨶᩦ;
ᩅᩮᩔᩣᨶᩁᩮᩣ ᩉᩩᨲᩣᩈᩮᩣ ᨳ, ᩈᩥᨡᩣᨩᩣᩃ’ᨧ᩠ᨧᩥ ᨧᩣᨸᩩᨾᩮ.
ᩅᩥᨸ᩠ᨹᩩᩃᩥᨦ᩠ᨣᩴ ᨹᩩᩃᩥᨦ᩠ᨣᨬ᩠ᨧ, ᨽᩈ᩠ᨾᩣ [‘ᨽᩈ᩠ᨾᩣ’ ᨲᩥᨸᨴᩴ ᩁᩣᨩᩣᨴᩥᨣᨱᩮ ᨸᩁᩥᨿᩣᨸᨶ᩠ᨶᩴ (ᩁᩪᨸᩈᩥᨴ᩠ᨵᩥ-ᩏᨱᩣᨴᩥ), ᨽᩈ᩠ᨾᩴ (ᩈᩦ.)] ᨲᩩ ᩈᩮᨭ᩠ᨮᩥ ᨨᩣᩁᩥᨠᩣ;
ᨠᩩᨠ᩠ᨠᩩᩊᩮᩣ ᨲᩩ’ᨱ᩠ᩉᨽᩈ᩠ᨾᩈ᩠ᨾᩥ, ᨾᨦ᩠ᨣᩣᩁᩮᩣ’ᩃᩣᨲ ᨾᩩᨾ᩠ᨾᩩᨠᩴ [ᨲᩥᨠᩴ ᨴᩥᨲ᩠ᨲᨠᨭ᩠ᨮᩣᨴᩥᨶ᩠ᨵᨶᩮ (ᨭᩦᨠᩣ)];
ᩈᨾᩥᨵᩣ ᩍᨵᩩᨾᩴ ᨧᩮ’ᨵᩮᩣ, ᩏᨸᩣᨴᩣᨶᩴ ᨲᨳᩥᨶ᩠ᨵᨶᩴ.
ᩋᨳᩮᩣ’ᨽᩣᩈᩮᩣ ᨸᨠᩣᩈᩮᩣ ᨧᩣ,
'ᩃᩮᩣᨠᩮᩣ’ᨩ᩠ᨩᩮᩣᨲᩣ’ᨲᨸᩣ ᩈᨾᩣ;
ᨾᩣᩃᩩᨲᩮᩣ ᨸᩅᨶᩮᩣ ᩅᩣᨿᩩ, ᩅᩣᨲᩮᩣ’ᨶᩥᩃ ᩈᨾᩦᩁᨱᩣ;
ᨣᨶ᩠ᨵᩅᩣᩉᩮᩣ ᨲᨳᩣ ᩅᩣᨿᩮᩣ, ᩈᨾᩦᩁᩮᩣ ᨧ ᩈᨴᩣᨣᨲᩥ.
ᩅᩣᨿᩩᨽᩮᨴᩣ ᩍᨾᩮ ᨨᩩ’ᨴ᩠ᨵ, ᨦ᩠ᨣᨾᩮᩣ ᨧᩣᨵᩮᩣᨣᨾᩮᩣ ᨲᨳᩣ;
ᨠᩩᨧ᩠ᨨᩥᨭ᩠ᨮᩮᩣ ᨧ ᨠᩮᩣᨭ᩠ᨮᩣᩈᨿᩮᩣ, ᩋᩔᩣᩈᨦ᩠ᨣᩣᨶᩩᩈᩣᩁᩥᨶᩮᩣ.
ᩋᨳᩮᩣ ᩋᨸᩣᨶᩴ ᨸᩔᩣᩈᩮᩣ,
ᩋᩔᩣᩈᩮᩣ ᩌᨶ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩅᩮᨣᩮᩣ ᨩᩅᩮᩣ ᩁᨿᩮᩣ ᨡᩥᨸ᩠ᨸᩴ, ᨲᩩ ᩈᩦᨥᩴ ᨲᩩᩁᩥᨲᩴ ᩃᩉᩩ;
ᩌᩈᩩ ᨲᩩᨱ᩠ᨱ ᨾᩁᩴ ᨧᩣᩅᩥ, ᩃᨾ᩠ᨻᩥᨲᩴ ᨲᩩᩅᨭᩴᨸᩥ ᨧ.
ᩈᨲᨲᩴ ᨶᩥᨧ᩠ᨧ ᨾᩅᩥᩁᨲᩣ, ᨶᩣᩁᨲ ᩈᨶ᩠ᨲᨲ ᨾᨶᩅᩁᨲᨬ᩠ᨧ ᨵᩩᩅᩴ;
ᨽᩩᩈ ᨾᨲᩥᩈᨿᩮᩣ ᨧ ᨴᩊ᩠ᩉᩴ, ᨲᩥᨻ᩠ᨻᩮ’ᨠᨶ᩠ᨲᩣ’ᨲᩥᨾᨲ᩠ᨲ, ᨻᩣᩊ᩠ᩉᩣᨶᩥ;
ᨡᩥᨸ᩠ᨸᩣᨴᩦ ᨸᨱ᩠ᨯᨠᩮ ᨴᨻ᩠ᨻᩮ, ᨴᨻ᩠ᨻᨣᩣ ᨲᩮᩈᩩ ᨿᩮ ᨲᩥᩈᩩ.
ᩋᩅᩥᨣ᩠ᨣᩉᩮᩣ ᨲᩩ ᨠᩣᨾᩮᩣ ᨧ, ᨾᨶᩮᩣᨽᩪ ᨾᨴᨶᩮᩣ ᨽᩅᩮ;
ᩋᨶ᩠ᨲᨠᩮᩣ ᩅᩈᩅᨲ᩠ᨲᩦ ᨧ, ᨸᩣᨸᩥᨾᩣ ᨧ ᨸᨩᩣᨸᨲᩥ.
ᨸᨾᨲ᩠ᨲᨻᨶ᩠ᨵᩩ ᨠᨱ᩠ᩉᩮᩣ ᨧ, ᨾᩣᩁᩮᩣ ᨶᨾᩩᨧᩥ, ᨲᩔ ᨲᩩ;
ᨲᨱ᩠ᩉᩣ’ᩁᨲᩦ ᩁᨣᩣ ᨵᩦᨲᩪ, ᩉᨲ᩠ᨳᩦ ᨲᩩ ᨣᩥᩁᩥᨾᩮᨡᩃᩮᩣ.
ᨿᨾᩁᩣᨩᩣ ᨧ ᩅᩮᩈᩣᨿᩦ, ᨿᨾᩮᩣ’ᩔ ᨶᨿᨶᩣᩅᩩᨵᩴ;
ᩅᩮᨸᨧᩥᨲ᩠ᨲᩥ ᨸᩩᩃᩮᩣᨾᩮᩣ ᨧ, ᨠᩥᨾ᩠ᨸᩩᩁᩥᩈᩮᩣ ᨲᩩ ᨠᩥᨶ᩠ᨶᩁᩮᩣ.
ᩋᨶ᩠ᨲᩃᩥᨠ᩠ᨡᩴ ᨡ’ᨾᩣᨴᩥᨧ᩠ᨧ, ᨸᨳᩮᩣ’ᨻ᩠ᨽᩴ ᨣᨣᨶ’ᨾ᩠ᨻᩁᩴ;
ᩅᩮᩉᩣᩈᩮᩣ ᨧᩣᨶᩥᩃᨸᨳᩮᩣ, ᩌᨠᩣᩈᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨶᨽᩴ.
ᨴᩮᩅᩮᩣ ¶ ᩅᩮᩉᩣᨿᩈᩮᩣ ᨲᩣᩁᩣ,
ᨸᨳᩮᩣ ᩈᩩᩁᨸᨳᩮᩣ ᩋᨥᩴ.
ᨾᩮᨥᩮᩣ ᩅᩃᩣᩉᨠᩮᩣ ᨴᩮᩅᩮᩣ, ᨸᨩ᩠ᨩᩩᨶ᩠ᨶᩮᩣ’ᨾ᩠ᨻᩩᨵᩁᩮᩣ ᨥᨶᩮᩣ;
ᨵᩣᩁᩣᨵᩁᩮᩣ ᨧ ᨩᩦᨾᩪᨲᩮᩣ, ᩅᩣᩁᩥᩅᩣᩉᩮᩣ ᨲᨳᩣ’ᨾ᩠ᨻᩩᨴᩮᩣ.
ᩋᨻ᩠ᨽᩴ ᨲᩦᩈ᩠ᩅᨳ ᩅᩔᨬ᩠ᨧ, ᩅᩔᨶᩴ ᩅᩩᨭ᩠ᨮᩥ ᨶᩣᩁᩥᨿᩴ;
ᩈᨲᩮᩁᨲᩣ’ᨠ᩠ᨡᨱᩣ ᩅᩥᨩ᩠ᨩᩩ, ᩅᩥᨩ᩠ᨩᩩᨲᩣ ᨧᩣᨧᩥᩁᨸ᩠ᨸᨽᩣ.
ᨾᩮᨥᨶᩣᨴᩮ ᨲᩩ ᨵᨶᩥᨲᩴ, ᨣᨩ᩠ᨩᩥᨲᩴ ᩁᩈᩥᨲᩣᨴᩥ ᨧ;
ᩍᨶ᩠ᨴᩣᩅᩩᨵᩴ ᩍᨶ᩠ᨴᨵᨶᩩ, ᩅᩣᨲᨠ᩠ᨡᩥᨲ᩠ᨲᨾ᩠ᨻᩩ ᩈᩦᨠᩁᩮᩣ.
ᩌᩈᩣᩁᩮᩣ ᨵᩣᩁᩣ ᩈᨾ᩠ᨸᩣᨲᩮᩣ,
ᨠᩁᨠᩣ ᨲᩩ ᨥᨶᩮᩣᨸᩃᩴ;
ᨴᩩᨴ᩠ᨴᩥᨶᩴ ᨾᩮᨥᨧ᩠ᨨᨶ᩠ᨶᩣᩉᩮ, ᨸᩥᨵᩣᨶᩴ ᨲ᩠ᩅᨸᨵᩣᩁᨱᩴ.
ᨲᩥᩁᩮᩣᨵᩣᨶ’ᨶ᩠ᨲᩁᨵᩣᨶᩣ, ᨸᩥᨵᩣᨶ ᨨᩣᨴᨶᩣᨶᩥ ᨧ;
ᩍᨶ᩠ᨴᩩ ᨧᨶ᩠ᨴᩮᩣ ᨧ ᨶᨠ᩠ᨡᨲ᩠ᨲ, ᩁᩣᨩᩣ ᩈᩮᩣᨾᩮᩣ ᨶᩥᩈᩣᨠᩁᩮᩣ.
ᩒᩈᨵᩦᩈᩮᩣ ᩉᩥᨾᩁᩴᩈᩥ, ᩈᩈᨦ᩠ᨠᩮᩣ ᨧᨶ᩠ᨴᩥᨾᩣ ᩈᩈᩦ;
ᩈᩦᨲᩁᩴᩈᩥ ᨶᩥᩈᩣᨶᩣᨳᩮᩣ, ᩏᩊᩩᩁᩣᨩᩣ ᨧ ᨾᩣ ᨸᩩᨾᩮ.
ᨠᩃᩣ ᩈᩮᩣᩊᩈᨾᩮᩣ ᨽᩣᨣᩮᩣ, ᨻᩥᨾ᩠ᨻᩴ ᨲᩩ ᨾᨱ᩠ᨯᩃᩴ ᨽᩅᩮ;
ᩋᨯ᩠ᨰᩮᩣ ᨲ᩠ᩅᨴ᩠ᨵᩮᩣ ᩏᨸᨯ᩠ᨰᩮᩣ ᨧ, ᩅᩣ ᨡᨱ᩠ᨯᩴ ᩈᨠᩃᩴ ᨸᩩᨾᩮ.
ᩋᨴ᩠ᨵᩴ ᩅᩩᨲ᩠ᨲᩴ ᩈᨾᩮ ᨽᩣᨣᩮ, ᨸᩈᩣᨴᩮᩣ ᨲᩩ ᨸᩈᨶ᩠ᨶᨲᩣ;
ᨠᩮᩣᨾᩩᨴᩦ ᨧᨶ᩠ᨴᩥᨠᩣ ᨩᩩᨱ᩠ᩉᩣ, ᨠᨶ᩠ᨲᩥ ᩈᩮᩣᨽᩣ ᨩᩩᨲᩥ ᨧ᩠ᨨᩅᩥ.
ᨠᩃᨦ᩠ᨠᩮᩣ ᩃᨬ᩠ᨨᨶᩴ ᩃᨠ᩠ᨡᩴ, ᩋᨦ᩠ᨠᩮᩣ’ᨽᩥᨬ᩠ᨬᩣᨱ ᩃᨠ᩠ᨡᨱᩴ;
ᨧᩥᩉᨶᩴ ᨧᩣᨸᩥ ᩈᩮᩣᨽᩣ ᨲᩩ, ᨸᩁᨾᩣ ᩈᩩᩈᨾᩣ ᨳ ᨧ.
ᩈᩦᨲᩴ ᨣᩩᨱᩮ, ᨣᩩᨱᩥᩃᩥᨦ᩠ᨣᩣ, ᩈᩦᨲ ᩈᩥᩈᩥᩁ ᩈᩦᨲᩃᩣ;
ᩉᩥᨾᩴ ᨲᩩᩉᩥᨶ ᨾᩩᩔᩣᩅᩮᩣ, ᨶᩦᩉᩣᩁᩮᩣ ᨾᩉᩥᨠᩣ ᨸ᩠ᨿᨳ.
ᨶᨠ᩠ᨡᨲ᩠ᨲᩴ ᨩᩮᩣᨲᩥ ᨽᩴ ᨲᩣᩁᩣ, ᩋᨸᩩᨾᩮ ᨲᩣᩁᨠᩮᩣ’ᩊᩩ ᨧ;
ᩋᩔᨿᩩᨩᩮᩣ ᨽᩁᨱᩥᨲ᩠ᨳᩦ, ᩈᨠᨲ᩠ᨲᩥᨠᩣ ᩁᩮᩣᩉᩥᨱᩦ ᨸᩥᨧ;
ᨾᩥᨣᩈᩥᩁ [ᨾᨣᩈᩥᩁ (ᩈᩦ.)] ᨾᨴ᩠ᨴᩣ ᨧ ᨸᩩᨶᨻ᩠ᨻᩈᩩ, ᨹᩩᩔᩮᩣ [ᨸᩩᩔᩮᩣ (ᨭᩦ.)] ᨧᩣᩈᩥᩃᩮᩈ’ᨸᩥ.
ᨾᩣᨥᩣ [ᨾᨥ (ᩈᩦ.)] ᨧ ᨹᨣ᩠ᨣᩩᨶᩦ ᨴ᩠ᩅᩮ ᨧ, ᩉᨲ᩠ᨳᩣ ᨧᩥᨲ᩠ᨲᩣ ᨧ ᩈ᩠ᩅᩣᨲᩥᨸᩥ;
ᩅᩥᩈᩣᨡᩣ’ ᨶᩩᩁᩣᨵᩣ ᨩᩮᨭ᩠ᨮᩣ, ᨾᩪᩃᩣ’ ᩈᩣᩊ᩠ᩉᩣ ᨴᩩᩅᩮ ᨲᨳᩣ.
ᩈᩅᨱᩮᩣ ¶ ᨧ ᨵᨶᩥᨭ᩠ᨮᩣ ᨧ, ᩈᨲᨽᩥᩈᨩᩮᩣ ᨸᩩᨻ᩠ᨻᩩ’ᨲ᩠ᨲᩁᨽᨴ᩠ᨴᨸᨴᩣ;
ᩁᩮᩅᨲ᩠ᨿᨸᩦᨲᩥ ᨠᨾᨲᩮᩣ, ᩈᨲ᩠ᨲᩣᨵᩥᨠᩅᩦᩈᨶᨠ᩠ᨡᨲ᩠ᨲᩣ.
ᩈᩮᩣᨻ᩠ᨽᩣᨶᩩ ᨠᨳᩥᨲᩮᩣ ᩁᩣᩉᩩ, ᩈᩪᩁᩣᨴᩦ ᨲᩩ ᨶᩅᨣ᩠ᨣᩉᩣ;
ᩁᩣᩈᩥ ᨾᩮᩈᩣᨴᩥᨠᩮᩣ ᨽᨴ᩠ᨴ, ᨸᨴᩣ ᨸᩮᩣᨭ᩠ᨮᨸᨴᩣ ᩈᨾᩣ.
ᩌᨴᩥᨧ᩠ᨧᩮᩣ ᩈᩪᩁᩥᨿᩮᩣ ᩈᩪᩁᩮᩣ, ᩈᨲᩁᩴᩈᩥ ᨴᩥᩅᩣᨠᩁᩮᩣ;
ᩅᩮᩁᩮᩣᨧᨶᩮᩣ ᨴᩥᨶᨠᩁᩮᩣ, ᩏᨱ᩠ᩉᩁᩴᩈᩥ ᨸᨽᨦ᩠ᨠᩁᩮᩣ.
ᩋᩴᩈᩩᨾᩣᩃᩦ ᨴᩥᨶᨸᨲᩥ, ᨲᨸᨶᩮᩣ ᩁᩅᩥ ᨽᩣᨶᩩᨾᩣ;
ᩁᩴᩈᩥᨾᩣ ᨽᩣᨠᩁᩮᩣ ᨽᩣᨶᩩ, ᩋᨠ᩠ᨠᩮᩣ ᩈᩉᩔᩁᩴᩈᩥ ᨧ.
ᩁᩴᩈᩥ ᩌᨽᩣ ᨸᨽᩣ ᨴᩥᨲ᩠ᨲᩥ, ᩁᩩᨧᩥ ᨽᩣ ᨩᩩᨲᩥ ᨴᩦᨵᩥᨲᩥ;
ᨾᩁᩦᨧᩥ ᨴ᩠ᩅᩦᩈᩩ ᨽᩣᨶ᩠ᩅᩴ’ᩈᩩ, ᨾᨿᩪᨡᩮᩣ ᨠᩥᩁᨱᩮᩣ ᨠᩁᩮᩣ.
ᨸᩁᩥᨵᩥ ᨸᩁᩥᩅᩮᩈᩮᩣ ᨳ, ᨾᩁᩦᨧᩥ ᨾᩥᨣᨲᨱ᩠ᩉᩥᨠᩣ;
ᩈᩪᩁᩔᩮᩣᨴᨿᨲᩮᩣ ᨸᩩᨻ᩠ᨻᩩ’, ᨭ᩠ᨮᩥᨲᩁᩴᩈᩥ ᩈᩥᨿᩣ’ ᩁᩩᨱᩮᩣ.
ᨠᩣᩃᩮᩣ’ᨴ᩠ᨵᩣ ᩈᨾᨿᩮᩣ ᩅᩮᩃᩣ,
ᨲᨻ᩠ᨻᩥᩈᩮᩈᩣ ᨡᨱᩣᨴᨿᩮᩣ;
ᨡᨱᩮᩣ ᨴᩈᨧ᩠ᨨᩁᩣᨠᩣᩃᩮᩣ,
ᨡᨱᩣ ᨴᩈ ᩃᨿᩮᩣ ᨽᩅᩮ.
ᩃᨿᩣ ᨴᩈ ᨡᨱᩃᨿᩮᩣ,
ᨾᩩᩉᩩᨲ᩠ᨲᩮᩣ ᨲᩮ ᩈᩥᨿᩣ ᨴᩈ;
ᨴᩈ ᨡᨱᨾᩩᩉᩩᨲ᩠ᨲᩮᩣ ᨲᩮ, ᨴᩥᩅᩈᩮᩣ ᨲᩩ ᩋᩉᩴ ᨴᩥᨶᩴ.
ᨸᨽᩣᨲᨬ᩠ᨧ ᩅᩥᨽᩣᨲᨬ᩠ᨧ, ᨸᨧ᩠ᨧᩪᩈᩮᩣ ᨠᩃ᩠ᩃ ᨾᨸ᩠ᨿᨳ;
ᩋᨽᩥᨴᩮᩣᩈᩮᩣ ᨸᨴᩮᩣᩈᩮᩣ ᨳ,
ᩈᩣᨿᩮᩣ ᩈᨬ᩠ᨫᩣ ᨴᩥᨶᨧ᩠ᨧᨿᩮᩣ.
ᨶᩥᩈᩣ ᨧ ᩁᨩᨶᩦ ᩁᨲ᩠ᨲᩥ, ᨲᩥᨿᩣᨾᩣ ᩈᩴᩅᩁᩦ ᨽᩅᩮ;
ᨩᩩᨱ᩠ᩉᩣ ᨲᩩ ᨧᨶ᩠ᨴᩥᨠᩣᨿᩩᨲ᩠ᨲᩣ, ᨲᨾᩩᩔᨶ᩠ᨶᩣ ᨲᩥᨾᩥᩈᩥᨠᩣ.
ᨶᩥᩈᩦᨳᩮᩣ ᨾᨩ᩠ᨫᩥᨾᩣ ᩁᨲ᩠ᨲᩥ, ᩋᨯ᩠ᨰᩁᨲ᩠ᨲᩮᩣ ᨾᩉᩣᨶᩥᩈᩣ;
ᩋᨶ᩠ᨵᨠᩣᩁᩮᩣ ᨲᨾᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨲᩥᨾᩥᩈᩴ ᨲᩥᨾᩥᩁᩴ ᨾᨲᩴ.
ᨧᨲᩩᩁᨦ᩠ᨣᨲᨾᩴ ᩑᩅᩴ, ᨠᩣᩊᨸᨠ᩠ᨡᨧᨲᩩᨴ᩠ᨴᩈᩦ;
ᩅᨶᩈᨱ᩠ᨯᩮᩣ ᨥᨶᩮᩣ ᨾᩮᨥ, ᨸᨭᩃᩴ ᨧᩣ’ᨯ᩠ᨰᩁᨲ᩠ᨲᩥ ᨧ.
ᩋᨶ᩠ᨵᨲᨾᩴ ¶ ᨥᨶᨲᨾᩮ, ᨸᩉᩣᩁᩮᩣ ᨿᩣᨾ, ᩈᨬ᩠ᨬᩥᨲᩮᩣ;
ᨸᩣᨭᩥᨸᨴᩮᩣ ᨲᩩ ᨴᩩᨲᩥᨿᩣ, ᨲᨲᩥᨿᩣᨴᩦ ᨲᩥᨳᩦ [ᨲᩥᨳᩥ], ᨲᩣᨿᨲᩥ ᨸᩣᩃᩮᨲᩦᨲᩥ ᨲᩥᨳᩥ, ᨲᩣ+ᩍᨲᩥ (ᨱ᩠ᩅᩣᨴᩥ) ᨴ᩠ᩅᩥᩈᩩ.
ᨸᨶ᩠ᨶᩁᩈᩦ ᨸᨬ᩠ᨧᨴᩈᩦ, ᨸᩩᨱ᩠ᨱᨾᩣᩈᩦ ᨲᩩ ᨸᩩᨱ᩠ᨱᨾᩣ;
ᩋᨾᩣᩅᩈᩦ ᨸ᩠ᨿᨾᩣᩅᩣᩈᩦ, ᨳᩥᨿᩴ ᨸᨶ᩠ᨶᩁᩈᩦ’ ᨸᩁᩣ.
ᨥᨭᩥᨠᩣ ᩈᨭ᩠ᨮ᩠ᨿ’ ᩉᩮᩣᩁᨲ᩠ᨲᩮᩣ, ᨸᨠ᩠ᨡᩮᩣ ᨲᩮ ᨴᩈ ᨸᨬ᩠ᨧ ᨧ;
ᨲᩮ ᨲᩩ ᨸᩩᨻ᩠ᨻᩣᨸᩁᩣ ᩈᩩᨠ᩠ᨠ,
ᨠᩣᩊᩣ, ᨾᩣᩈᩮᩣ ᨲᩩ ᨲᩮ ᨴᩩᩅᩮ.
ᨧᩥᨲ᩠ᨲᩮᩣ ᩅᩮᩈᩣᨡ, ᨩᩮᨭ᩠ᨮᩮᩣ ᨧᩣ, ᩈᩣᩊ᩠ᩉᩮᩣ ᨴ᩠ᩅᩦᩈᩩ ᨧ ᩈᩣᩅᨱᩮᩣ;
ᨸᩮᩣᨭ᩠ᨮᨸᩣᨴ’ᩔᨿᩩᨩᩣ ᨧ, ᨾᩣᩈᩣ ᨴ᩠ᩅᩣᨴᩈ ᨠᨲ᩠ᨲᩥᨠᩮᩣ.
ᨾᩣᨣᩈᩥᩁᩮᩣ ᨲᨳᩣ ᨹᩩᩔᩮᩣ, ᨠᨾᩮᨶ ᨾᩣᨥ ᨹᨣ᩠ᨣᩩᨱᩣ;
ᨠᨲ᩠ᨲᩥᨠ’ᩔᨿᩩᨩᩣ ᨾᩣᩈᩣ, ᨸᨧ᩠ᨨᩥᨾ ᨸᩩᨻ᩠ᨻᨠᨲ᩠ᨲᩥᨠᩣ.
ᩈᩣᩅᨱᩮᩣ ᨶᩥᨠ᩠ᨡᨾᨶᩦᨿᩮᩣ,
ᨧᩥᨲ᩠ᨲᨾᩣᩈᩮᩣ ᨲᩩ ᩁᨾ᩠ᨾᨠᩮᩣ.
ᨧᨲᩩᩁᩮᩣ ᨧᨲᩩᩁᩮᩣ ᨾᩣᩈᩣ, ᨠᨲ᩠ᨲᩥᨠᨠᩣᩊᨸᨠ᩠ᨡᨲᩮᩣ;
ᨠᨾᩣ ᩉᩮᨾᨶ᩠ᨲ ᨣᩥᨾ᩠ᩉᩣᨶ, ᩅᩔᩣᨶᩣ ᩏᨲᩩᨿᩮᩣ ᨴ᩠ᩅᩥᩈᩩ.
ᩉᩮᨾᨶ᩠ᨲᩮᩣ ᩈᩥᩈᩥᩁ ᨾᩩᨲᩪ,
ᨨ ᩅᩣ ᩅᩈᨶ᩠ᨲᩮᩣ ᨧ ᨣᩥᨾ᩠ᩉ ᩅᩔᩣᨶᩣ;
ᩈᩁᨴᩮᩣᨲᩥ ᨠᨾᩣ ᨾᩣᩈᩣ, ᨴ᩠ᩅᩮ ᨴ᩠ᩅᩮ ᩅᩩᨲ᩠ᨲᩣᨶᩩᩈᩣᩁᩮᨶ.
ᩏᨱ᩠ᩉᩮᩣ ᨶᩥᨴᩣᨥᩮᩣ ᨣᩥᨾ᩠ᩉᩮᩣᨳ,
ᩅᩔᩮᩣ ᩅᩔᩣᨶ ᨸᩣᩅᩩᩈᩣ;
ᩏᨲᩪᩉᩥ ᨲᩦᩉᩥ ᩅᩔᩣᨶᩣ, ᨴᩥᨠᩮᩉᩥ ᨴᨠ᩠ᨡᩥᨱᩣᨿᨶᩴ.
ᩏᨲ᩠ᨲᩁᩣᨿᨶ ᨾᨬ᩠ᨬᩮᩉᩥ, ᨲᩦᩉᩥ ᩅᩔᩣᨿᨶᨴ᩠ᩅᨿᩴ;
ᩅᩔ ᩈᩴᩅᨧ᩠ᨨᩁᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩈᩁᨴᩮᩣ ᩉᩣᨿᨶᩮᩣ ᩈᨾᩣ.
ᨠᨸ᩠ᨸᨠ᩠ᨡᨿᩮᩣ ᨲᩩ ᩈᩴᩅᨭ᩠ᨭᩮᩣ, ᨿᩩᨣᨶ᩠ᨲ ᨸᩃᨿᩣ ᩋᨸᩥ;
ᩋᩃᨠ᩠ᨡᩦ ᨠᩣᩃᨠᨱ᩠ᨱᩥᨲ᩠ᨳᩦ, ᩋᨳ ᩃᨠ᩠ᨡᩦ ᩈᩥᩁᩥ’ᨲ᩠ᨳᩥᨿᩴ.
ᨴᨶᩩ ᨴᩣᨶᩅᨾᩣᨲᩣ ᨳ, ᨴᩮᩅᨾᩣᨲᩣ ᨸᨶᩣ’ᨴᩥᨲᩥ;
ᨸᩣᨸᨬ᩠ᨧ ᨠᩥᨻ᩠ᨻᩥᩈᩴ ᩅᩮᩁᩣ, ᨥᩴ ᨴᩩᨧ᩠ᨧᩁᩥᨲ ᨴᩩᨠ᩠ᨠᨭᩴ;
ᩋᨸᩩᨬ᩠ᨬᩣ’ᨠᩩᩈᩃᩴ ᨠᨱ᩠ᩉᩴ, ᨠᩃᩩᩈᩴ ᨴᩩᩁᩥᨲᩣ’ᨣᩩ ᨧ.
ᨠᩩᩈᩃᩴ ¶ ᩈᩩᨠᨲᩴ ᩈᩩᨠ᩠ᨠᩴ, ᨸᩩᨬ᩠ᨬᩴ ᨵᨾ᩠ᨾ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ;
ᩈᩩᨧᩁᩥᨲ ᨾᨳᩮᩣ ᨴᩥᨭ᩠ᨮ, ᨵᨾ᩠ᨾᩥᨠᩴ ᩍᩉᩃᩮᩣᨠᩥᨠᩴ.
ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨠ ᨾᨳᩮᩣ ᨸᩣᩁ, ᩃᩮᩣᨠᩥᨠᩴ ᩈᨾ᩠ᨸᩁᩣᨿᩥᨠᩴ;
ᨲᨠ᩠ᨠᩣᩃᩴ ᨲᩩ ᨲᨴᩣᨲ᩠ᩅᩴ ᨧᩮᩣ,
ᨲ᩠ᨲᩁᨠᩣᩃᩮᩣ ᨲᩩ ᩌᨿᨲᩥ.
ᩉᩣᩈᩮᩣ’ ᨲ᩠ᨲᨾᨶᨲᩣ ᨸᩦᨲᩥ, ᩅᩥᨲ᩠ᨲᩥ ᨲᩩᨭ᩠ᨮᩥ ᨧ ᨶᩣᩁᩥᨿᩴ;
ᩌᨶᨶ᩠ᨴᩮᩣ ᨸᨾᩩᨴᩣ’ᨾᩮᩣᨴᩮᩣ, ᩈᨶ᩠ᨲᩮᩣᩈᩮᩣ ᨶᨶ᩠ᨴᩥ ᩈᨾ᩠ᨾᨴᩮᩣ.
ᨸᩣᨾᩮᩣᨩ᩠ᨩᨬ᩠ᨧ ᨸᨾᩮᩣᨴᩮᩣ ᨳ, ᩈᩩᨡᩴ ᩈᩣᨲᨬ᩠ᨧ ᨹᩣᩈ᩠ᩅ’ᨳ;
ᨽᨴ᩠ᨴᩴ ᩈᩮᨿ᩠ᨿᩮᩣ ᩈᩩᨽᩴ ᨡᩮᨾᩴ, ᨠᩃ᩠ᨿᩣᨱᩴ ᨾᨦ᩠ᨣᩃᩴ ᩈᩥᩅᩴ.
ᨴᩩᨠ᩠ᨡᨬ᩠ᨧ ᨠᩈᩥᩁᩴ ᨠᩥᨧ᩠ᨨᩴ, ᨶᩦᨥᩮᩣ ᨧ ᨻ᩠ᨿᩈᨶᩴ ᩋᨥᩴ;
ᨴᨻ᩠ᨻᩮ ᨲᩩ ᨸᩣᨸᨸᩩᨬ᩠ᨬᩣᨶᩥ, ᨲᩦᩈ᩠ᩅᩣᨠᩥᨧ᩠ᨨᩴ ᩈᩩᨡᩣᨴᩥ ᨧ.
ᨽᩣᨣ᩠ᨿᩴ ᨶᩥᨿᨲᩥ ᨽᩣᨣᩮᩣ ᨧ, ᨽᩣᨣᨵᩮᨿ᩠ᨿᩴ ᩅᩥᨵᩦ’ᩁᩥᨲᩮᩣ;
ᩋᨳᩮᩣ ᩏᨸ᩠ᨸᨲ᩠ᨲᩥ ᨶᩥᨻ᩠ᨻᨲ᩠ᨲᩥ, ᨩᩣᨲᩥ ᨩᨶᨶ ᨾᩩᨻ᩠ᨽᩅᩮᩣ.
ᨶᩥᨾᩥᨲ᩠ᨲᩴ ᨠᩣᩁᨱᩴ ᨮᩣᨶᩴ, ᨸᨴᩴ ᨻᩦᨩᩴ ᨶᩥᨻᨶ᩠ᨵᨶᩴ;
ᨶᩥᨴᩣᨶᩴ ᨸᨽᩅᩮᩣ ᩉᩮᨲᩩ, ᩈᨾ᩠ᨽᩅᩮᩣ ᩈᩮᨲᩩ ᨸᨧ᩠ᨧᨿᩮᩣ.
ᨠᩣᩁᨱᩴ ᨿᩴ ᩈᨾᩣᩈᨶ᩠ᨶᩴ, ᨸᨴᨭ᩠ᨮᩣᨶᨶ᩠ᨲᩥ ᨲᩴ ᨾᨲᩴ;
ᨩᩦᩅᩮᩣ ᨲᩩ ᨸᩩᩁᩥᩈᩮᩣ’ᨲ᩠ᨲᩣ ᨳ, ᨸᨵᩣᨶᩴ ᨸᨠᨲᩥᨲ᩠ᨳᩥᨿᩴ.
ᨸᩣᨱᩮᩣ ᩈᩁᩦᩁᩦ ᨽᩪᨲᩴ ᩅᩣ, ᩈᨲ᩠ᨲᩮᩣ ᨴᩮᩉᩦ ᨧ ᨸᩩᨣ᩠ᨣᩃᩮᩣ;
ᨩᩦᩅᩮᩣ ᨸᩣᨱᩦ ᨸᨩᩣ ᨩᨶ᩠ᨲᩩ,
ᨩᨶᩮᩣ ᩃᩮᩣᨠᩮᩣ ᨲᨳᩣᨣᨲᩮᩣ.
ᩁᩪᨸᩴ ᩈᨴ᩠ᨴᩮᩣ ᨣᨶ᩠ᨵ ᩁᩈᩣ, ᨹᩔᩮᩣ ᨵᨾ᩠ᨾᩮᩣ ᨧ ᨣᩮᩣᨧᩁᩣ;
ᩌᩃᨾ᩠ᨻᩣ ᩅᩥᩈᨿᩣ ᨲᩮ ᨨᩣ, ᩁᨾ᩠ᨾᨱᩣ ᩃᨾ᩠ᨻᨱᩣᨶᩥ ᨧ.
ᩈᩩᨠ᩠ᨠᩮᩣ ᨣᩮᩣᩁᩮᩣ ᩈᩥᨲᩮᩣ’ᨴᩣᨲᩣ,
ᨵᩅᩃᩮᩣ ᩈᩮᨲ, ᨸᨱ᩠ᨯᩁᩣ;
ᩈᩮᩣᨱᩮᩣ ᨲᩩ ᩃᩮᩣᩉᩥᨲᩮᩣ ᩁᨲ᩠ᨲᩮᩣ,
ᨲᨾ᩠ᨻ ᨾᨬ᩠ᨩᩥᨭ᩠ᨮ ᩁᩮᩣᩉᩥᨲᩣ.
ᨶᩦᩃᩮᩣ ᨠᨱ᩠ᩉᩣ’ᩈᩥᨲᩣ ᨠᩣᩊᩮᩣ,
ᨾᩮᨧᨠᩮᩣ ᩈᩣᨾ ᩈᩣᨾᩃᩣ;
ᩈᩥᨲᨸᩦᨲᩮᨲᩩ ᨸᨱ᩠ᨯᩩ’ᨲ᩠ᨲᩮᩣ, ᩎᩈᩴᨸᨱ᩠ᨯᩩᨲᩩ ᨵᩪᩈᩁᩮᩣ.
ᩋᩁᩩᨱᩮᩣ ¶ ᨠᩥᨬ᩠ᨧᩥᩁᨲ᩠ᨲᩮᩣ ᨳ,
ᨸᩣᨭᩃᩮᩣ ᩈᩮᨲᩃᩮᩣᩉᩥᨲᩮᩣ;
ᩋᨳᩮᩣ ᨸᩦᨲᩮᩣ ᩉᩃᩥᨴ᩠ᨿᩣᨽᩮᩣ,
ᨸᩃᩣᩈᩮᩣ ᩉᩁᩥᨲᩮᩣ ᩉᩁᩥ.
ᨠᩊᩣᩁᩮᩣ ᨠᨸᩥᩃᩮᩣ ᨶᩦᩃ, ᨸᩦᨲᩮ ᨳ ᩁᩮᩣᨧᨶᨸ᩠ᨸᨽᩮ;
ᨸᩥᨦ᩠ᨣᩮᩣ ᨸᩥᩈᨦ᩠ᨣᩮᩣ ᨸ᩠ᨿᨳᩅᩣ, ᨠᩊᩣᩁᩣᨴᩦ ᨲᩩ ᨸᩥᨦ᩠ᨣᩃᩮ.
ᨠᨾ᩠ᨾᩣᩈᩮᩣ ᩈᨻᩃᩮᩣ ᨧᩥᨲ᩠ᨲᩮᩣ,
ᩈᩣᩅᩮᩣ ᨲᩩ ᨠᨱ᩠ᩉᨸᩦᨲᨠᩮ;
ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩣ ᨣᩩᨱᩥᨶ᩠ᨿᩮᨲᩮ, ᨣᩩᨱᩮ ᩈᩩᨠ᩠ᨠᩣᨴᨿᩮᩣ ᨸᩩᨾᩮ.
ᨶᨧ᩠ᨧᩴ ᨶᨭ᩠ᨭᨬ᩠ᨧ ᨶᨭᨶᩴ, ᨶᨲ᩠ᨲᨶᩴ ᩃᩣᩈᨶᩴ ᨽᩅᩮ;
ᨶᨧ᩠ᨧᩴ ᨲᩩ ᩅᩣᨴᩥᨲᩴ ᨣᩦᨲ, ᨾᩥᨲᩥ ᨶᩣᨭᩩᨾᩥᨴᩴ ᨲᨿᩴ.
ᨶᨧ᩠ᨧᨭ᩠ᨮᩣᨶᩴ ᩈᩥᨿᩣ ᩁᨦ᩠ᨣᩮᩣ, ᨽᩥᨶᨿᩮᩣ ᩈᩪᨧ᩠ᨿᩈᩪᨧᨶᩴ;
ᩋᨦ᩠ᨣᩉᩣᩁᩮᩣ’ᨦ᩠ᨣᩅᩥᨠ᩠ᨡᩮᨸᩮᩣ, ᨶᨭ᩠ᨭᨠᩮᩣ ᨶᨭᨠᩮᩣ ᨶᨭᩮᩣ.
ᩈᩥᨦ᩠ᨣᩣᩁᩮᩣ ᨠᩁᩩᨱᩮᩣ ᩅᩦᩁ, ᨻ᩠ᨽᩩᨲ ᩉᩔ ᨽᨿᩣᨶᨠᩣ;
ᩈᨶ᩠ᨲᩮᩣ ᨻᩦᨽᨧ᩠ᨨ ᩁᩩᨴ᩠ᨴᩣᨶᩥ, ᨶᩅ ᨶᩣᨭ᩠ᨿᩁᩈᩣ ᩍᨾᩮ.
ᨸᩮᩣᩈᩔ ᨶᩣᩁᩥᨿᩴ ᨸᩮᩣᩈᩮ, ᩍᨲ᩠ᨳᩥᨿᩣ ᩈᨦ᩠ᨣᨾᩴ ᨸᨲᩥ;
ᨿᩣ ᨸᩥᩉᩣ ᩑᩈ ᩈᩥᨦ᩠ᨣᩣᩁᩮᩣ, ᩁᨲᩥᨠᩦᩊᩣᨴᩥᨠᩣᩁᨱᩮᩣ.
ᩏᨲ᩠ᨲᨾ ᨸ᩠ᨸᨠᨲᩥᨸ᩠ᨸᩣᨿᩮᩣ, ᩍᨲ᩠ᨳᩥᨸᩩᩁᩥᩈᩉᩮᨲᩩᨠᩮᩣ;
ᩈᩮᩣ ᩈᨾ᩠ᨽᩮᩣᨣᩮᩣ ᩅᩥᨿᩮᩣᨣᩮᩣᨲᩥ,
ᩈᩥᨦ᩠ᨣᩣᩁᩮᩣ ᨴᩩᩅᩥᨵᩮᩣ ᨾᨲᩮᩣ.
ᨽᩣᩈᩥᨲᩴ ¶ ᩃᨸᩥᨲᩴ ᨽᩣᩈᩣ, ᩅᩮᩣᩉᩣᩁᩮᩣ ᩅᨧᨶᩴ ᩅᨧᩮᩣ;
ᩏᨲ᩠ᨲᩥ ᩅᩣᨧᩣ ᨣᩥᩁᩣ ᩅᩣᨱᩦ, ᨽᩣᩁᨲᩦ ᨠᨳᩥᨲᩣ [ᨠᨳᩣ (ᨠᨲ᩠ᨳᨧᩥ)] ᩅᨧᩦ.
ᩑᨠᩣᨡ᩠ᨿᩣᨲᩮᩣ ᨸᨴᨧᨿᩮᩣ, ᩈᩥᨿᩣ ᩅᩣᨠ᩠ᨿᩴᩈᨠᩣᩁᨠᩮᩣ;
ᩌᨾᩮᨯᩥᨲᨶ᩠ᨲᩥ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ, ᨴ᩠ᩅᨲ᩠ᨲᩥᨠ᩠ᨡᨲ᩠ᨲᩩ ᨾᩩᨴᩦᩁᨱᩴ.
ᨽᨿᩮ ᨠᩮᩣᨵᩮ ᨸᩈᩴᩈᩣᨿᩴ, ᨲᩩᩁᩥᨲᩮ ᨠᩮᩣᨲᩪᩉᩃᩮ’ᨧ᩠ᨨᩁᩮ;
ᩉᩣᩈᩮ ᩈᩮᩣᨠᩮ ᨸᩈᩣᨴᩮ ᨧ, ᨠᩁᩮ ᩌᨾᩮᨯᩥᨲᩴ ᨻᩩᨵᩮᩣ.
ᩍᩁᩩ ᨶᩣᩁᩦ ᨿᨩᩩ ᩈᩣᨾ, ᨾᩥᨲᩥ ᩅᩮᨴᩣ ᨲᨿᩮᩣ ᩈᩥᨿᩩᩴ;
ᩑᨲᩮ ᩑᩅ ᨲᨿᩦ ᨶᩣᩁᩦ, ᩅᩮᨴᩮᩣ ᨾᨶ᩠ᨲᩮᩣ ᩈᩩᨲᩥᨲ᩠ᨳᩥᨿᩴ.
ᩋᨭ᩠ᨮᨠᩮᩣ ᩅᩣᨾᨠᩮᩣ ᩅᩣᨾ, ᨴᩮᩅᩮᩣ ᨧᨦ᩠ᨣᩦᩁᩈᩮᩣ ᨽᨣᩩ;
ᨿᨾᨴᨣ᩠ᨣᩥ ᨧ ᩅᩣᩈᩥᨭ᩠ᨮᩮᩣ, ᨽᩣᩁᨴ᩠ᩅᩣᨩᩮᩣ ᨧ ᨠᩔᨸᩮᩣ;
ᩅᩮᩔᩣᨾᩥᨲ᩠ᨲᩮᩣᨲᩥ ᨾᨶ᩠ᨲᩣᨶᩴ, ᨠᨲ᩠ᨲᩣᩁᩮᩣ ᩍᩈᨿᩮᩣ ᩍᨾᩮ.
ᨠᨸ᩠ᨸᩮᩣ ᨻ᩠ᨿᩣᨠᩁᨱᩴ ᨩᩮᩣᨲᩥ, ᩈᨲ᩠ᨳᩴ ᩈᩥᨠ᩠ᨡᩣ ᨶᩥᩁᩩᨲ᩠ᨲᩥ ᨧ;
ᨨᨶ᩠ᨴᩮᩣᩅᩥᨧᩥᨲᩥ ᨧᩮᨲᩣᨶᩥ, ᩅᩮᨴᨦ᩠ᨣᩣᨶᩥ ᩅᨴᨶ᩠ᨲᩥ ᨨ.
ᩍᨲᩥᩉᩣᩈᩮᩣ ᨸᩩᩁᩣᩅᩩᨲ᩠ᨲ, ᨸ᩠ᨸᨻᨶ᩠ᨵᩮᩣ ᨽᩣᩁᨲᩣᨴᩥᨠᩮᩣ;
ᨶᩣᨾᨸ᩠ᨸᨠᩣᩈᨠᩴ ᩈᨲ᩠ᨳᩴ, ᩁᩩᨠ᩠ᨡᩣᨴᩦᨶᩴ ᨶᩥᨥᨱ᩠ᨯᩩ ᩈᩮᩣ.
ᩅᩥᨲᨱ᩠ᨯᩈᨲ᩠ᨳᩴ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ, ᨿᩴ ᨲᩴ ᩃᩮᩣᨠᩣᨿᨲᩴ ᩍᨲᩥ;
ᨠᩮᨭᩩᨽᩴ ᨲᩩ ᨠᩕᩥᨿᩣᨠᨸ᩠ᨸ, ᩅᩥᨠᨸ᩠ᨸᩮᩣ ᨠᩅᩥᨶᩴ ᩉᩥᨲᩮᩣ.
ᩌᨡ᩠ᨿᩣᨿᩥᨠᩮᩣᨸᩃᨴ᩠ᨵᨲ᩠ᨳᩣ, ᨸᨻᨶ᩠ᨵᨠᨸ᩠ᨸᨶᩣ ᨠᨳᩣ;
ᨴᨱ᩠ᨯᨶᩦᨲ᩠ᨿ’ᨲ᩠ᨳᩈᨲ᩠ᨳᩈ᩠ᨾᩥᩴ, ᩅᩩᨲ᩠ᨲᨶ᩠ᨲᩮᩣ ᨲᩩ ᨸᩅᨲ᩠ᨲᩥ ᨧ.
ᩈᨬ᩠ᨬᩣ, ᨡ᩠ᨿᩣ, ᩅ᩠ᩉᩣ ᩈᨾᨬ᩠ᨬᩣ ᨧᩣ, ᨽᩥᨵᩣᨶᩴ ᨶᩣᨾ ᨾᩅ᩠ᩉᨿᩮᩣ;
ᨶᩣᨾᨵᩮᨿ᩠ᨿᩣ’ ᨵᩥᩅᨧᨶᩴ, ᨸᨭᩥᩅᩣᨠ᩠ᨿᩴ ᨲᩩ ᩏᨲ᩠ᨲᩁᩴ.
ᨸᨬ᩠ᩉᩮᩣ ᨲᩦᩈ᩠ᩅ ᨶᩩᨿᩮᩣᨣᩮᩣ ᨧ, ᨸᩩᨧ᩠ᨨᩣ ᨸ᩠ᨿᨳ ᨶᩥᨴᩔᨶᩴ;
ᩏᨸᩮᩣᨣ᩠ᨥᩣᨲᩮᩣ ᨧ ᨴᩥᨭ᩠ᨮᨶ᩠ᨲᩮᩣ, ᨲᨳᩮᩣ’ᨴᩣᩉᩁᨱᩴ ᨽᩅᩮ.
ᩈᨾᩣ ᩈᨦ᩠ᨡᩮᨸ ᩈᩴᩉᩣᩁᩣ, ᩈᨾᩣᩈᩮᩣ ᩈᨦ᩠ᨣᩉᩮᩣ ᨸ᩠ᨿᨳ;
ᩈᨲᩴ ᨵᩣᩁᨿᩈᩦ ᨲ᩠ᨿᩣᨴ᩠ᨿ, ᨻ᩠ᨽᨠ᩠ᨡᩣᨶᩴ ᨲᩩᨧ᩠ᨨᨽᩣᩈᨶᩴ.
ᩅᩮᩣᩉᩣᩁᩮᩣ ᨲᩩ ᩅᩥᩅᩣᨴᩮᩣ ᨳ, ᩈᨸᨶᩴ ᩈᨸᨳᩮᩣᨸᩥ ᨧ;
ᨿᩈᩮᩣ ᩈᩥᩃᩮᩣᨠᩮᩣ ᨠᩥᨲ᩠ᨲᩥᨲ᩠ᨳᩦ,
ᨥᩮᩣᩈᨶᩣ ᨲᩩ’ᨧ᩠ᨧᩈᨴ᩠ᨴᨶᩴ.
ᨸᨭᩥᨥᩮᩣᩈᩮᩣ ᨸᨭᩥᩁᩅᩮᩣ, ᨳᩮᩣ’ ᨸᨬ᩠ᨬᩣᩈᩮᩣ ᩅᨧᩦᨾᩩᨡᩴ;
ᨠᨲ᩠ᨳᨶᩣ ᨧ ᩈᩥᩃᩣᨥᩣ ᨧ, ᩅᨱ᩠ᨱᨶᩣ ᨧ ᨶᩩᨲᩥ ᨲ᩠ᨳᩩᨲᩥ.
ᨳᩮᩣᨾᨶᨬ᩠ᨧ [ᨳᩮᩣᨾᨶᩴ ᩅᩣ (ᨠᨲ᩠ᨳᨧᩥ ᨳᩮᩣᨾᨶᩴ ᨳᩮᩣᨾᨶᩣ ᨴ᩠ᩅᩥᩃᩥᨦ᩠ᨣᩮ)] ᨸᩈᩴᩈᩣᨳ, ᨠᩮᨠᩣ ᨶᩣᨴᩮᩣ ᩈᩥᨡᨱ᩠ᨯᩥᨶᩴ;
ᨣᨩᩣᨶᩴ ᨠᩮᩣᨬ᩠ᨧᨶᩣᨴᩮᩣ ᨳ,
ᨾᨲᩣ ᩉᩮᩈᩣ ᩉᨿᨴ᩠ᨵᨶᩥ.
ᨸᩁᩥᨿᩣᨿᩮᩣ ᩅᩮᩅᨧᨶᩴ, ᩈᩣᨠᨧ᩠ᨨᩣ ᨲᩩ ᨧ ᩈᩴᨠᨳᩣ;
ᩏᨸᩅᩣᨴᩮᩣ ᨧᩩ’ᨸᨠ᩠ᨠᩮᩣᩈᩣ, ᩅᨱ᩠ᨱᩅᩣᨴᩣ’ᨶᩩᩅᩣᨴᩮᩣ ᨧ;
ᨩᨶᩅᩣᨴᩣ’ᨸᩅᩣᨴᩣᨸᩥ, ᨸᩁᩥᩅᩣᨴᩮᩣ ᨧ ᨲᩩᩃ᩠ᨿᨲ᩠ᨳᩣ.
ᨡᩮᨸᩮᩣ ¶ ᨶᩥᨶ᩠ᨴᩣ ᨲᨳᩣ ᨠᩩᨧ᩠ᨨᩣ, ᨩᩥᨣᩩᨧ᩠ᨨᩣ ᨣᩁᩉᩣ ᨽᩅᩮ;
ᨶᩥᨶ᩠ᨴᩣᨸᩩᨻ᩠ᨻᩮᩣ ᩏᨸᩣᩁᨾ᩠ᨽᩮᩣ, ᨸᩁᩥᨽᩣᩈᨶ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩋᨭ᩠ᨮᩣᨶᩁᩥᨿᩅᩮᩣᩉᩣᩁ, ᩅᩈᩮᨶ ᨿᩣ ᨸᩅᨲ᩠ᨲᩥᨲᩣ;
ᩋᨽᩥᩅᩣᨠ᩠ᨿᩴ ᩈᩥᨿᩣ ᩅᩣᨧᩣ, ᩈᩣ ᩅᩦᨲᩥᨠ᩠ᨠᨾᨴᩦᨸᨶᩦ.
ᨾᩩᩉᩩᩴᨽᩣᩈᩣ ᨶᩩᩃᩣᨸᩮᩣᨳ, ᨸᩃᩣᨸᩮᩣ ᨶᨲ᩠ᨳᩥᨠᩣ ᨣᩥᩁᩣ;
ᩌᨴᩮᩣᨽᩣᩈᨶ ᨾᩣᩃᩣᨸᩮᩣ,
ᩅᩥᩃᩣᨸᩮᩣ ᨲᩩ ᨸᩁᩥᨴ᩠ᨴᩅᩮᩣ.
ᩅᩥᨸ᩠ᨸᩃᩣᨸᩮᩣ ᩅᩥᩁᩮᩣᨵᩮᩣᨲ᩠ᨲᩥ, ᩈᨶ᩠ᨴᩮᩈᩮᩣᨲ᩠ᨲᩥ ᨲᩩ ᩅᩣᨧᩥᨠᩴ;
ᩈᨾ᩠ᨽᩣᩈᨶᩴ ᨲᩩ ᩈᩃ᩠ᩃᩣᨸᩮᩣ, ᩅᩥᩁᩮᩣᨵᩁᩉᩥᨲᩴ ᨾᩥᨳᩩ.
ᨹᩁᩩᩈᩴ ᨶᩥᨭ᩠ᨮᩩᩁᩴ ᩅᩣᨠ᩠ᨿᩴ, ᨾᨶᩩᨬ᩠ᨬᩴ ᩉᨴᨿᨦ᩠ᨣᨾᩴ;
ᩈᩴᨠᩩᩃᩴ ᨲᩩ ᨠᩥᩃᩥᨭ᩠ᨮᨬ᩠ᨧ, ᨸᩩᨻ᩠ᨻᩣᨸᩁᩅᩥᩁᩮᩣᨵᩥᨶᩦ.
ᩈᨾᩩᨴᩣᨿᨲ᩠ᨳᩁᩉᩥᨲᩴ, ᩋᨻᨴ᩠ᨵᨾᩥᨲᩥ [ᩋᨻᨶ᩠ᨵ (ᨠ.)] ᨠᩥᨲ᩠ᨲᩥᨲᩴ;
ᩅᩥᨲᨳᩴ ᨲᩩ ᨾᩩᩈᩣ ᨧᩣᨳ [ᩌᩉᨲᩴ ᨲᩩ ᨾᩩᩈᩣᨲ᩠ᨳᨠᩴ (ᨠᨲ᩠ᨳᨧᩥ, ᩋᨾᩁᨠᩮᩣᩈᩮ)], ᨹᩁᩩᩈᩣᨴᩦ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩣ.
ᩈᨾ᩠ᨾᩣ ᨻ᩠ᨿᨿᨬ᩠ᨧᩣ ᩅᩥᨲᨳᩴ, ᩈᨧ᩠ᨧᩴ ᨲᨧ᩠ᨨᩴ ᨿᨳᩣᨲᨳᩴ;
ᨲᨻ᩠ᨻᨶ᩠ᨲᩣ ᨲᩦᩈ᩠ᩅ ᩃᩦᨠᩴ ᨲ᩠ᩅ, ᩈᨧ᩠ᨧᩴ ᨾᩥᨧ᩠ᨨᩣ ᨾᩩᩈᩣ ᨻ᩠ᨿᨿᩴ.
ᩁᩅᩮᩣ ᨶᩥᨶᩣᨴᩮᩣ ᨶᩥᨶᨴᩮᩣ ᨧ ᩈᨴ᩠ᨴᩮᩣ,
ᨶᩥᨣ᩠ᨥᩮᩣᩈ ᨶᩣᨴ ᨴ᩠ᨵᨶᨿᩮᩣ ᨧ ᩁᩣᩅᩮᩣ;
ᩌᩁᩣᩅ ᩈᩴᩁᩣᩅ ᩅᩥᩁᩣᩅ ᨥᩮᩣᩈᩣ,
ᩁᩅᩣ ᩈᩩᨲᩥᨲ᩠ᨳᩦ ᩈᩁ ᨶᩥᩔᨶᩣ ᨧ.
ᩅᩥᩔᨭ᩠ᨮ ᨾᨬ᩠ᨩᩩ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩣ, ᩈᩅᨶᩦᨿᩣ ᩅᩥᩈᩣᩁᩥᨶᩮᩣ;
ᨻᩥᨶ᩠ᨴᩩ ᨣᨾ᩠ᨽᩦᩁ ᨶᩥᨶ᩠ᨶᩣᨴᩦ, ᨲ᩠ᨿᩮᩅ ᨾᨭ᩠ᨮᨦ᩠ᨣᩥᨠᩮᩣ ᩈᩁᩮᩣ.
ᨲᩥᩁᨧ᩠ᨨᩣᨶᨣᨲᩣᨶᨬ᩠ᩉᩥ, ᩁᩩᨲᩴ ᩅᩔᩥᨲ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨠᩮᩣᩃᩣᩉᩃᩮᩣ ᨠᩃᩉᩃᩮᩣ,
ᨣᩦᨲᩴ ᨣᩣᨶᨬ᩠ᨧ ᨣᩦᨲᩥᨠᩣ.
ᩈᩁᩣ ᩈᨲ᩠ᨲ ᨲᨿᩮᩣ ᨣᩣᨾᩣ, ᨧᩮᨠᩅᩦᩈᨲᩥ ᨾᩩᨧ᩠ᨨᨶᩣ;
ᨲᩣᨶᩣ [ᨮᩣᨶᩣᨶᩥ (ᨻᩉᩪᩈᩩ)] ᨧᩮᨠᩪᨶᨸᨬ᩠ᨬᩣᩈ, ᩍᨧ᩠ᨧᩮᨲᩴ ᩈᩁᨾᨱ᩠ᨯᩃᩴ.
ᩏᩈᨽᩮᩣ ᨵᩮᩅᨲᩮᩣ ᨧᩮᩅ, ᨨᨩ᩠ᨩ ᨣᨶ᩠ᨵᩣᩁ ᨾᨩ᩠ᨫᩥᨾᩣ;
ᨸᨬ᩠ᨧᨾᩮᩣ ᨧ ᨶᩥᩈᩣᨴᩮᩣᨲᩥ, ᩈᨲ᩠ᨲᩮ’ᨲᩮ ᨣᨴᩥᨲᩣ ᩈᩁᩣ.
ᨶᨴᨶ᩠ᨲᩥ ¶ ᩏᩈᨽᩴ ᨣᩣᩅᩮᩣ, ᨲᩩᩁᨣᩣ ᨵᩮᩅᨲᩴ ᨲᨳᩣ;
ᨨᨩ᩠ᨩᩴ ᨾᨿᩪᩁᩣ ᨣᨶ᩠ᨵᩣᩁ, ᨾᨩᩣ ᨠᩮᩣᨬ᩠ᨧᩣ ᨧ ᨾᨩ᩠ᨫᩥᨾᩴ.
ᨸᨬ᩠ᨧᨾᩴ ᨸᩁᨸᩩᨭ᩠ᨮᩣᨴᩦ, ᨶᩥᩈᩣᨴᨾ᩠ᨸᩥ ᨧ ᩅᩣᩁᨱᩣ;
ᨨᨩ᩠ᨩᩮᩣ ᨧ ᨾᨩ᩠ᨫᩥᨾᩮᩣ ᨣᩣᨾᩣ,
ᨲᨿᩮᩣ ᩈᩣᨵᩣᩁᨱᩮᩣᨲᩥ ᨧ.
ᩈᩁᩮᩈᩩ ᨲᩮᩈᩩ ᨸᨧ᩠ᨧᩮᨠᩮ, ᨲᩥᩔᩮᩣ ᨲᩥᩔᩮᩣ ᩉᩥ ᨾᩩᨧ᩠ᨨᨶᩣ;
ᩈᩥᨿᩩᩴ ᨲᨳᩮᩅ ᨲᩣᨶᩣᨶᩥ [ᨮᩣᨶᩣᨶᩥ (ᨻᩉᩪᩈᩩ)], ᩈᨲ᩠ᨲ ᩈᨲ᩠ᨲᩮᩅ ᩃᨻ᩠ᨽᩁᩮ.
ᨲᩥᩔᩮᩣ ᨴᩩᩅᩮ ᨧᨲᩔᩮᩣ ᨧ, ᨧᨲᩔᩮᩣ ᨠᨾᨲᩮᩣ ᩈᩁᩮ;
ᨲᩥᩔᩮᩣ ᨴᩩᩅᩮ ᨧᨲᩔᩮᩣᨲᩥ, ᨴ᩠ᩅᩣᩅᩦᩈᨲᩥ ᩈᩩᨲᩦ ᩈᩥᨿᩩᩴ.
ᩏᨧ᩠ᨧᨲᩁᩮ ᩁᩅᩮ ᨲᩣᩁᩮᩣ, ᨳᩣᨻ᩠ᨿᨲ᩠ᨲᩮ ᨾᨵᩩᩁᩮ ᨠᩃᩮᩣ;
ᨣᨾ᩠ᨽᩦᩁᩮ ᨲᩩ ᩁᩅᩮ ᨾᨶ᩠ᨴᩮᩣ, ᨲᩣᩁᩣᨴᩦ ᨲᩦᩈ᩠ᩅᨳᩮᩣ ᨠᩃᩮ;
ᨠᩣᨠᩃᩦ ᩈᩩᨡᩩᨾᩮ ᩅᩩᨲ᩠ᨲᩮᩣ,
ᨠᩕᩥᨿᩣᨴᩥᩈᨾᨲᩣ ᩃᨿᩮᩣ.
ᩅᩦᨱᩣ ᨧ ᩅᩃ᩠ᩃᨠᩦ ᩈᨲ᩠ᨲ, ᨲᨶ᩠ᨲᩦ ᩈᩣ ᨸᩁᩥᩅᩣᨴᩥᨶᩦ;
ᨸᩮᩣᨠ᩠ᨡᩁᩮᩣ ᨴᩮᩣᨱᩥ ᩅᩦᨱᩣᨿ,
ᩏᨸᩅᩦᨱᩮᩣ ᨲᩩ ᩅᩮᨮᨠᩮᩣ.
ᩌᨲᨲᨬ᩠ᨧᩮᩅ ᩅᩥᨲᨲ, ᨾᩣᨲᨲᩅᩥᨲᨲᩴ ᨥᨶᩴ;
ᩈᩩᩈᩥᩁᩴ ᨧᩮᨲᩥ ᨲᩪᩁᩥᨿᩴ, ᨸᨬ᩠ᨧᨦ᩠ᨣᩥᨠ ᨾᩩᨴᩦᩁᩥᨲᩴ.
ᩌᨲᨲᩴ ᨶᩣᨾ ᨧᨾ᩠ᨾᩣᩅ, ᨶᨴ᩠ᨵᩮᩈᩩ ᨽᩮᩁᩥᨿᩣᨴᩥᩈᩩ;
ᨲᩃᩮ’ᨠᩮᨠᨿᩩᨲᩴ ᨠᩩᨾ᩠ᨽ, ᨳᩩᨱ ᨴᨴ᩠ᨴᩁᩥᨠᩣᨴᩥᨠᩴ.
ᩅᩥᨲᨲᩴ ᨧᩮᩣ’ᨽᨿᨲᩃᩴ, ᨲᩪᩁᩥᨿᩴ ᨾᩩᩁᨩᩣᨴᩥᨠᩴ;
ᩌᨲᨲᩅᩥᨲᨲᩴ ᩈᨻ᩠ᨻ, ᩅᩥᨶᨴ᩠ᨵᩴ ᨸᨱᩅᩣᨴᩥᨠᩴ.
ᩈᩩᩈᩥᩁᩴ ᩅᩴᩈᩈᨦ᩠ᨡᩣᨴᩥ, ᩈᨾ᩠ᨾᨲᩣᩃᩣᨴᩥᨠᩴ ᨥᨶᩴ;
ᩌᨲᩮᩣᨩ᩠ᨩᩴ ᨲᩩ ᨧ ᩅᩣᨴᩥᨲ᩠ᨲᩴ, ᩅᩣᨴᩥᨲᩴ ᩅᨩ᩠ᨩ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᨽᩮᩁᩦ (ᨽᩮᩁᩥ) ᨴᩩᨶ᩠ᨴᩩᨽᩥ ᩅᩩᨲ᩠ᨲᩮᩣ ᨳ,
ᨾᩩᨴᩥᨦ᩠ᨣᩮᩣ ᨾᩩᩁᨩᩮᩣᩔ ᨲᩩ;
ᩌᩃᩥᨦ᩠ᨣ, ᨦ᩠ᨠ᩠ᨿᩮᩣ, ᨴ᩠ᨵᨠᩣ ᨽᩮᨴᩣ,
ᨲᩥᨱᩅᩮᩣ ᨲᩩ ᨧ ᨯᩥᨱ᩠ᨯᩥᨾᩮᩣ.
ᩌᩃᨾ᩠ᨻᩁᩮᩣ ¶ ᨲᩩ ᨸᨱᩅᩮᩣ, ᨠᩮᩣᨱᩮᩣ ᩅᩦᨱᩣᨴᩥᩅᩣᨴᨶᩴ;
ᨴᨴ᩠ᨴᩁᩦ ᨸᨭᩉᩮᩣ ᨽᩮᩁᩥ, ᨸ᩠ᨸᨽᩮᨴᩣ ᨾᨴ᩠ᨴᩃᩣᨴᨿᩮᩣ.
ᨩᨶᨸ᩠ᨸᩥᨿᩮ ᩅᩥᨾᨴ᩠ᨴᩩᨭ᩠ᨮᩮ, ᨣᨶ᩠ᨵᩮ ᨸᩁᩥᨾᩃᩮᩣ ᨽᩅᩮ;
ᩈᩮᩣ ᨲ᩠ᩅᩣ ᨾᩮᩣᨴᩮᩣ ᨴᩪᩁᨣᩣᨾᩦ, ᩅᩥᩔᨶ᩠ᨲᩣ ᨲᩦᩈ᩠ᩅᩥᨲᩮᩣ ᨸᩁᩴ.
ᩍᨭ᩠ᨮᨣᨶ᩠ᨵᩮᩣ ᨧ ᩈᩩᩁᨽᩥ, ᩈᩩᨣᨶ᩠ᨵᩮᩣ ᨧ ᩈᩩᨣᨶ᩠ᨵᩥ ᨧ;
ᨸᩪᨲᩥᨣᨶ᩠ᨵᩥ ᨲᩩ ᨴᩩᨣ᩠ᨣᨶ᩠ᨵᩮᩣ, ᨳ ᩅᩥᩔᩴ ᩌᨾᨣᨶ᩠ᨵᩥ ᨿᩴ.
ᨠᩩᨦ᩠ᨠᩩᨾᨬ᩠ᨧᩮᩅ ᨿᩅᨶ, ᨸᩩᨸ᩠ᨹᨬ᩠ᨧ ᨲᨣᩁᩴ ᨲᨳᩣ;
ᨲᩩᩁᩩᨠ᩠ᨡᩮᩣᨲᩥ ᨧᨲᩩᨩ᩠ᨩᩣᨲᩥ, ᨣᨶ᩠ᨵᩣ ᩑᨲᩮ ᨸᨠᩣᩈᩥᨲᩣ.
ᨠᩈᩣᩅᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨲᩥᨲ᩠ᨲᩮᩣ, ᨾᨵᩩᩁᩮᩣ ᩃᩅᨱᩮᩣ ᩍᨾᩮ;
ᩋᨾ᩠ᨻᩥᩃᩮᩣ ᨠᨭᩩᨠᩮᩣ ᨧᩮᨲᩥ, ᨨ ᩁᩈᩣ ᨲᨻ᩠ᨻᨲᩦ ᨲᩥᩈᩩ.
ᩈᩥᨿᩣ ᨹᩔᩮᩣ ᨧ ᨹᩮᩣᨭ᩠ᨮᨻ᩠ᨻᩮᩣ,
ᩅᩥᩈᨿᩦ ᨲ᩠ᩅᨠ᩠ᨡ ᨾᩥᨶ᩠ᨴᩕᩥᨿᩴ;
ᨶᨿᨶᩴ ᨲ᩠ᩅᨠ᩠ᨡᩥ ᨶᩮᨲ᩠ᨲᨬ᩠ᨧ, ᩃᩮᩣᨧᨶᩴ ᨧ’ᨧ᩠ᨨᩥ ᨧᨠ᩠ᨡᩩ ᨧ.
ᩈᩮᩣᨲᩴ ᩈᨴ᩠ᨴᨣ᩠ᨣᩉᩮᩣ ᨠᨱ᩠ᨱᩮᩣ, ᩈᩅᨶᩴ ᩈᩩᨲᩥ ᨶᨲ᩠ᨳᩩ ᨲᩩ;
ᨶᩣᩈᩣ ᨧ ᨶᩣᩈᩥᨠᩣ ᨥᩣᨶᩴ, ᨩᩥᩅ᩠ᩉᩣᨲᩩ ᩁᩈᨶᩣ ᨽᩅᩮ.
ᩈᩁᩦᩁᩴ ᩅᨸᩩ ᨣᨲ᩠ᨲᨬ᩠ᨧᩣ, ᨲ᩠ᨲᨽᩣᩅᩮᩣ ᨻᩮᩣᨶ᩠ᨴᩥ ᩅᩥᨣ᩠ᨣᩉᩮᩣ;
ᨴᩮᩉᩴ ᩅᩣ ᨸᩩᩁᩥᩈᩮ ᨠᩣᨿᩮᩣ, ᨳᩥᨿᩴ ᨲᨶᩩ ᨠᩊᩮᩅᩁᩴ.
ᨧᩥᨲ᩠ᨲᩴ ᨧᩮᨲᩮᩣ ᨾᨶᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩅᩥᨬ᩠ᨬᩣᨱᩴ ᩉᨴᨿᩴ ᨲᨳᩣ;
ᨾᩣᨶᩈᩴ ᨵᩦ ᨲᩩ ᨸᨬ᩠ᨬᩣ ᨧ, ᨻᩩᨴ᩠ᨵᩥ ᨾᩮᨵᩣ ᨾᨲᩥ ᨾᩩᨲᩥ.
ᨽᩪᩁᩦ ᨾᨶ᩠ᨲᩣ ᨧ ᨸᨬ᩠ᨬᩣᨱᩴ, ᨬᩣᨱᩴ ᩅᩥᨩ᩠ᨩᩣ ᨧ ᨿᩮᩣᨶᩥ ᨧ;
ᨸᨭᩥᨽᩣᨶ ᨾᨾᩮᩣᩉᩮᩣ ᨳ, ᨸᨬ᩠ᨬᩣᨽᩮᨴᩣ ᩅᩥᨸᩔᨶᩣ.
ᩈᨾ᩠ᨾᩣᨴᩥᨭ᩠ᨮᩥ ᨸᨽᩩᨲᩥᨠᩣ, ᩅᩦᨾᩴᩈᩣ ᨲᩩ ᩅᩥᨧᩣᩁᨱᩣ;
ᩈᨾ᩠ᨸᨩᨬ᩠ᨬᩴ ᨲᩩ ᨶᩮᨸᨠ᩠ᨠᩴ, ᩅᩮᨴᨿᩥᨲᩴ ᨲᩩ ᩅᩮᨴᨶᩣ.
ᨲᨠ᩠ᨠᩮᩣ ᩅᩥᨲᨠ᩠ᨠᩮᩣ ᩈᨦ᩠ᨠᨸ᩠ᨸᩮᩣ,
ᨸ᩠ᨸᨶᩮᩣ’ ᩉᩣ’ ᨿᩩ ᨲᩩ ᨩᩦᩅᩥᨲᩴ;
ᩑᨠᨣ᩠ᨣᨲᩣ ᨲᩩ ᩈᨾᨳᩮᩣ, ᩋᩅᩥᨠ᩠ᨡᩮᨸᩮᩣ ᩈᨾᩣᨵᩥ ᨧ.
ᩏᩔᩣᩉᩣ’ ᨲᨸ᩠ᨸ ᨸᨣ᩠ᨣᩣᩉᩣ, ᩅᩣᨿᩣᨾᩮᩣ ᨧ ᨸᩁᨠ᩠ᨠᨾᩮᩣ;
ᨸᨵᩣᨶᩴ ᩅᩦᩁᩥᨿᩴ ᨧᩮᩉᩣ, ᩏᨿ᩠ᨿᩣᨾᩮᩣ ᨧ ᨵᩥᨲᩥ ᨲ᩠ᨳᩥᨿᩴ.
ᨧᨲ᩠ᨲᩣᩁᩥ ᩅᩦᩁᩥᨿᨦ᩠ᨣᩣᨶᩥ, ᨲᨧᩔ ᨧ ᨶᩉᩣᩁᩩᨶᩮᩣ;
ᩋᩅᩈᩥᩔᨶ ᨾᨭ᩠ᨮᩥᩔ, ᨾᩴᩈᩃᩮᩣᩉᩥᨲᩈᩩᩔᨶᩴ.
ᩏᩔᩮᩣᩊ᩠ᩉᩦ ¶ ᨲ᩠ᩅ ᨵᩥᨾᨲ᩠ᨲᩮᩉᩣ, ᩈᨲᩥ ᨲ᩠ᩅ ᨶᩩᩔᨲᩥ ᨲ᩠ᨳᩥᨿ;
ᩃᨩ᩠ᨩᩣ ᩉᩥᩁᩦ ᩈᨾᩣᨶᩣ ᨳ, ᩒᨲ᩠ᨲᨸ᩠ᨸᩴ ᨸᩣᨸᨽᩦᩁᩩᨲᩣ.
ᨾᨩ᩠ᨫᨲ᩠ᨲᨲᩣ ᨲᩩ’ᨸᩮᨠ᩠ᨡᩣ ᨧ, ᩋᨴᩩᨠ᩠ᨡᨾᩈᩩᨡᩣ ᩈᩥᨿᩣ;
ᨧᩥᨲ᩠ᨲᩣᨽᩮᩣᨣᩮᩣ ᨾᨶᨠ᩠ᨠᩣᩁᩮᩣ,
ᩋᨵᩥᨾᩮᩣᨠ᩠ᨡᩮᩣ ᨲᩩ ᨶᩥᨧ᩠ᨨᨿᩮᩣ.
ᨴᨿᩣ’ ᨶᩩᨠᨾ᩠ᨸᩣ ᨠᩣᩁᩩᨬ᩠ᨬᩴ, ᨠᩁᩩᨱᩣ ᨧ ᩋᨶᩩᨴ᩠ᨴᨿᩣ;
ᨳᩥᨿᩴ ᩅᩮᩁᨾᨱᩦ ᨧᩮᩅ, ᩅᩥᩁᨲ᩠ᨿᩣ’ ᩁᨲᩥ ᨧᩣᨸ᩠ᨿᨳ.
ᨲᩥᨲᩥᨠ᩠ᨡᩣ ᨡᨶ᩠ᨲᩥ ᨡᨾᨶᩴ, ᨡᨾᩣ ᨾᩮᨲ᩠ᨲᩣ ᨲᩩ ᨾᩮᨲ᩠ᨿ’ᨳ;
ᨴᩔᨶᩴ ᨴᩥᨭ᩠ᨮᩥ ᩃᨴ᩠ᨵᩥᨲ᩠ᨳᩦ, ᩈᩥᨴ᩠ᨵᨶ᩠ᨲᩮᩣ ᩈᨾᨿᩮᩣ ᨽᩅᩮ.
ᨲᨱ᩠ᩉᩣ ᨧ ᨲᩈᩥᨱᩣ ᩑᨩᩣ, ᨩᩣᩃᩥᨶᩦ ᨧ ᩅᩥᩈᨲ᩠ᨲᩥᨠᩣ;
ᨨᨶ᩠ᨴᩮᩣ ᨩᨭᩣ ᨶᩥᨠᨶ᩠ᨲ᩠ᨿᩣ’ᩈᩣ, ᩈᩥᨻ᩠ᨻᩥᨶᩦ ᨽᩅᨶᩮᨲ᩠ᨲᩥ ᨧ.
ᩋᨽᩥᨩ᩠ᨫᩣ ᩅᨶᨳᩮᩣ ᩅᩣᨶᩴ, ᩃᩮᩣᨽᩮᩣ ᩁᩣᨣᩮᩣ ᨧ ᩌᩃᨿᩮᩣ;
ᨸᩥᩉᩣ ᨾᨶᩮᩣᩁᨳᩮᩣ ᩍᨧ᩠ᨨᩣ, ᨽᩥᩃᩣᩈᩮᩣ ᨠᩣᨾ ᨴᩮᩣᩉᩊᩣ;
ᩌᨠᨦ᩠ᨡᩣ ᩁᩩᨧᩥ ᩅᩩᨲ᩠ᨲᩣ ᩈᩣ, ᨲ᩠ᩅᨵᩥᨠᩣ ᩃᩣᩃᩈᩣ ᨴ᩠ᩅᩥᩈᩩ.
ᩅᩮᩁᩴ ᩅᩥᩁᩮᩣᨵᩮᩣ ᩅᩥᨴ᩠ᨴᩮᩈᩮᩣ, ᨴᩮᩣᩈᩮᩣ ᨧ ᨸᨭᩥᨥᨬ᩠ᨧ ᩅᩣ;
ᨠᩮᩣᨵᩣ’ ᨥᩣᨲᩣ ᨠᩮᩣᨸ ᩁᩮᩣᩈᩣ,
ᨻ᩠ᨿᩣᨸᩣᨴᩮᩣ’ ᨶᨽᩥᩁᨴ᩠ᨵᩥ ᨧ.
ᨻᨴ᩠ᨵᩅᩮᩁ ᨾᩩᨸᨶᩣᩉᩮᩣ, ᩈᩥᨿᩣ ᩈᩮᩣᨠᩮᩣ ᨲᩩ ᩈᩮᩣᨧᨶᩴ;
ᩁᩮᩣᨴᩥᨲᩴ ᨠᨶ᩠ᨴᩥᨲᩴ ᩁᩩᨱ᩠ᨱᩴ, ᨸᩁᩥᨴᩮᩅᩮᩣ ᨸᩁᩥᨴ᩠ᨴᩅᩮᩣ.
ᨽᩦᨲᩥᨲ᩠ᨳᩥ ᨽᨿ ᨾᩩᨲ᩠ᨲᩣᩈᩮᩣ, ᨽᩮᩁᩅᩴ ᨲᩩ ᨾᩉᨻ᩠ᨽᨿᩴ;
ᨽᩮᩁᩅᩴ ᨽᩦᩈᨶᩴ ᨽᩦᨾᩴ, ᨴᩣᩁᩩᨱᨬ᩠ᨧ ᨽᨿᩣᨶᨠᩴ;
ᨥᩮᩣᩁᩴ ᨸᨭᩥᨽᨿᩴ ᨽᩮᩈ᩠ᨾᩴ, ᨽᨿᨦ᩠ᨠᩁ ᨾᩥᨾᩮ ᨲᩦᩈᩩ.
ᩍᩔᩣ ᩏᩈᩪᨿᩣ ᨾᨧ᩠ᨨᩮᩁᩴ, ᨲᩩ ᨾᨧ᩠ᨨᩁᩥᨿ ᨾᨧ᩠ᨨᩁᩴ;
ᨾᩮᩣᩉᩮᩣ’ᩅᩥᨩ᩠ᨩᩣ ᨲᨳᩣ’ᨬᩣᨱᩴ, ᨾᩣᨶᩮᩣ ᩅᩥᨵᩣ ᨧ ᩏᨶ᩠ᨶᨲᩥ.
ᩏᨴ᩠ᨵᨧ᩠ᨧ ᨾᩩᨴ᩠ᨵᨭᩴ ᨧᩣᨳ [ᩏᨴ᩠ᨵᩅᩴᩏᨴ᩠ᨵᩴ ᨵᩣᩅᨲᩥ ᨧᩥᨲ᩠ᨲ ᨾᩮᨲᩮᨶᩣᨲᩥ ᩏᨴ᩠ᨵᩅᩴ (ᨭᩦᨠᩣ)], ᨲᩣᨸᩮᩣ ᨠᩩᨠ᩠ᨠᩩᨧ᩠ᨧᨾᩮᩅ ᨧ;
ᨸᨧ᩠ᨨᩣᨲᩣᨸᩮᩣ ᨶᩩᨲᩣᨸᩮᩣ ᨧ, ᩅᩥᨸ᩠ᨸᨭᩥᩈᩣᩁᩮᩣ ᨸᨠᩣᩈᩥᨲᩮᩣ.
ᨾᨶᩮᩣᩅᩥᩃᩮᨡ ᩈᨶ᩠ᨴᩮᩉᩣ, ᩈᩴᩈᨿᩮᩣ ᨧ ᨠᨳᩴᨠᨳᩣ;
ᨴ᩠ᩅᩮᩊ᩠ᩉᨠᩴ ᩅᩥᨧᩥᨠᩥᨧ᩠ᨨᩣ ᨧ, ᨠᨦ᩠ᨡᩣ ᩈᨦ᩠ᨠᩣ ᩅᩥᨾᨲ᩠ᨿᨸᩥ.
ᨣᨻ᩠ᨻᩮᩣ ¶ ᨽᩥᨾᩣᨶᩮᩣ’ᩉᩴᨠᩣᩁᩮᩣ, ᨧᩥᨶ᩠ᨲᩣᨲᩩ ᨫᩣᨶ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨶᩥᨧ᩠ᨨᨿᩮᩣ ᨶᩥᨱ᩠ᨱᨿᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨸᨭᩥᨬ᩠ᨬᩣ ᨲᩩ ᨸᨭᩥᩔᩅᩮᩣ.
ᩋᩅᨾᩣᨶᩴ ᨲᩥᩁᨠ᩠ᨠᩣᩁᩮᩣ, ᨸᩁᩥᨽᩅᩮᩣ ᨸ᩠ᨿ’ ᨶᩣᨴᩁᩮᩣ;
ᨸᩁᩣᨽᩅᩮᩣ ᨸ᩠ᨿ’ ᩅᨬ᩠ᨬᩣ ᨳ, ᩏᨾ᩠ᨾᩣᨴᩮᩣ ᨧᩥᨲ᩠ᨲᩅᩥᨻ᩠ᨽᨾᩮᩣ.
ᨸᩮᨾᩴ ᩈᩥᨶᩮᩉᩮᩣ ᩈ᩠ᨶᩮᩉᩮᩣ ᨳ, ᨧᩥᨲ᩠ᨲᨸᩦᩊᩣ ᩅᩥᩈᨬ᩠ᨬᩥᨲᩣ;
ᨸᨾᩣᨴᩮᩣ ᩈᨲᩥᩅᩮᩣᩔᨣ᩠ᨣᩮᩣ, ᨠᩮᩣᨲᩪᩉᩃᩴ ᨠᩩᨲᩪᩉᩃᩴ.
ᩅᩥᩃᩣᩈᩮᩣ ᩃᩃᩥᨲᩴ ᩃᩦᩃᩣ, ᩉᩣᩅᩮᩣ ᩉᩮᩊᩣ ᨧ ᩅᩥᨻ᩠ᨽᨾᩮᩣ;
ᩍᨧ᩠ᨧᩣᨴᩥᨠᩣ ᩈᩥᨿᩩᩴ ᨶᩣᩁᩥ, ᩈᩥᨦ᩠ᨣᩣᩁᨽᩣᩅᨩᩣ ᨠᩥᩁᩥᨿᩣ.
ᩉᩈᨶᩴ ᩉᩈᩥᨲᩴ ᩉᩣᩈᩮᩣ, ᨾᨶ᩠ᨴᩮᩣ ᩈᩮᩣ ᨾᩥᩉᩥᨲᩴ ᩈᩥᨲᩴ;
ᩋᨭ᩠ᨭᩉᩣᩈᩮᩣ ᨾᩉᩣᩉᩣᩈᩮᩣ,
ᩁᩮᩣᨾᨬ᩠ᨧᩮᩣ ᩃᩮᩣᨾᩉᩴᩈᨶᩴ.
ᨸᩁᩥᩉᩣᩈᩮᩣ ᨴᩅᩮᩣ ᨡᩥᨯ᩠ᨯᩣ, ᨠᩮᩊᩥ ᨠᩦᩊᩣ ᨧ ᨠᩦᩊᩥᨲᩴ;
ᨶᩥᨴ᩠ᨴᩣ ᨲᩩ ᩈᩩᨸᩥᨶᩴ ᩈᩮᩣᨸ᩠ᨸᩴ, ᨾᩥᨴ᩠ᨵᨬ᩠ᨧ ᨸᨧᩃᩣᨿᩥᨠᩣ.
ᨳᩥᨿᩴ ᨶᩥᨠᨲᩥ ᨠᩪᨭᨬ᩠ᨧ, ᨴᨾ᩠ᨽᩮᩣ ᩈᩣᨮ᩠ᨿᨬ᩠ᨧ ᨠᩮᨲᩅᩴ;
ᩈᨽᩣᩅᩮᩣ ᨲᩩ ᨶᩥᩔᨣ᩠ᨣᩮᩣ ᨧ, ᩈᩁᩪᨸᩴ ᨸᨠᨲᩥᨲ᩠ᨳᩥᨿᩴ.
ᩈᩦᩃᨬ᩠ᨧ ᩃᨠ᩠ᨡᨱᩴ ᨽᩣᩅᩮᩣ,
ᩏᩔᩅᩮᩣ ᨲᩩ ᨨᨱᩮᩣ ᨾᩉᩮᩣ [ᨾᨲᩮᩣ (ᨭᩦ.)].
ᨵᩣᩁᩮᨶ᩠ᨲᩮᩣ ᨩᨶ᩠ᨲᩩ ᩈᩈ᩠ᨶᩮᩉ, ᨾᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩴ;
ᨡᩩᨴ᩠ᨴᨠᩣᨴ᩠ᨿᨲ᩠ᨳᨩᩣᨲᩣᨶᩥ [ᨡᩩᨴ᩠ᨴᨠᩣᨶ᩠ᨿᨲ᩠ᨳᨩᩣᨲᩣᨶᩥ (ᨠ.)], ᩈᨾ᩠ᨸᩔᨲᩥ ᨿᨳᩣᩈᩩᨡᩴ.
ᩈᨣ᩠ᨣᨠᨱ᩠ᨯᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.
᪒. ᨽᩪᨠᨱ᩠ᨯ
᪑. ᨽᩪᨾᩥᩅᨣ᩠ᨣ
ᩅᨣ᩠ᨣᩣ ᨽᩪᨾᩥ, ᨸᩩᩁᩦ, ᨾᨧ᩠ᨧ, ᨧᨲᩩᨻ᩠ᨻᨱ᩠ᨱ, ᩅᨶᩣᨴᩥᩉᩥ;
ᨸᩣᨲᩣᩃᩮᨶ ᨧ ᩅᩩᨧ᩠ᨧᨶ᩠ᨲᩮ, ᩈᨦ᩠ᨣᩮᩣ’ᨸᨦ᩠ᨣᩮᩉᩥ’ᨵ’ᨠ᩠ᨠᨾᩣ.
ᩅᩈᩩᨶ᩠ᨵᩁᩣ ᨨᨾᩣ ᨽᩪᨾᩥ, ᨸᨳᩅᩦ ᨾᩮᨴᨶᩦ ᨾᩉᩦ;
ᩏᨻ᩠ᨻᩦ ᩅᩈᩩᨾᨲᩦ ᨣᩮᩣ ᨠᩩ, ᩅᩈᩩᨵᩣ ᨵᩁᨱᩦ ᨵᩁᩣ;
ᨸᩩᨳᩅᩦ ᨩᨣᨲᩦ ᨽᩪᩁᩦ, ᨽᩪ ᨧ ᨽᩪᨲᨵᩁᩣ’ ᩅᨶᩦ.
ᨡᩣᩁᩣ ¶ ᨲᩩ ᨾᨲ᩠ᨲᩥᨠᩣ ᩐᩈᩮᩣ, ᩐᩈᩅᩣ ᨲᩪᩈᩁᩮᩣ ᨲᩥᩈᩩ;
ᨳᩃᩴ ᨳᩃᩦᨲ᩠ᨳᩦ ᨽᩪᨽᩣᨣᩮ, ᨳᨴ᩠ᨵᩃᩪᨡᨾ᩠ᩉᩥ ᨩᨦ᩠ᨣᩃᩮᩣ.
ᨸᩩᨻ᩠ᨻᩅᩥᨴᩮᩉᩮᩣ ᨧᩣᨸᩁ, ᨣᩮᩣᨿᩣᨶᩴ ᨩᨾ᩠ᨻᩩᨴᩦᨸᩮᩣ ᨧ;
ᩏᨲ᩠ᨲᩁᨠᩩᩁᩩ ᨧᩮᨲᩥ ᩈᩥᨿᩩᩴ, ᨧᨲ᩠ᨲᩣᩁᩮᩣᨾᩮ ᨾᩉᩣᨴᩦᨸᩣ.
ᨸᩩᨾ᩠ᨻᩉᩩᨲ᩠ᨲᩮ ᨠᩩᩁᩪ ᩈᨠ᩠ᨠᩣ, ᨠᩮᩣᩈᩃᩣ ᨾᨣᨵᩣ ᩈᩥᩅᩦ;
ᨠᩃᩥᨦ᩠ᨣᩣ’ᩅᨶ᩠ᨲᩥ ᨸᨬ᩠ᨧᩣᩃᩣ, ᩅᨩ᩠ᨩᩦ ᨣᨶ᩠ᨵᩣᩁ ᨧᩮᨲᨿᩮᩣ.
ᩅᨦ᩠ᨣᩣ ᩅᩥᨴᩮᩉᩣ ᨠᨾ᩠ᨻᩮᩣᨩᩣ, ᨾᨴ᩠ᨴᩣ ᨽᨣ᩠ᨣ’ᨦ᩠ᨣ ᩈᩦᩉᩊᩣ;
ᨠᩈ᩠ᨾᩦᩁᩣ ᨠᩣᩈᩥ ᨸᨱ᩠ᨯᩅᩣᨴᩦ, ᩈᩥᨿᩩᩴ ᨩᨶᨸᨴᨶ᩠ᨲᩁᩣ.
ᩃᩮᩣᨠᩮᩣ ᨧ ᨽᩩᩅᨶᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨴᩮᩈᩮᩣ ᨲᩩ ᩅᩥᩈᨿᩮᩣ ᨸ᩠ᨿᨳ;
ᨾᩥᩃᨠ᩠ᨡᨴᩮᩈᩮᩣ ᨸᨧ᩠ᨧᨶ᩠ᨲᩮᩣ, ᨾᨩ᩠ᨫᨴᩮᩈᩮᩣ ᨲᩩ ᨾᨩ᩠ᨫᩥᨾᩮᩣ.
ᩋᨶᩪᨸᩮᩣ ᩈᩃᩥᩃᨸ᩠ᨸᩣᨿᩮᩣ, ᨠᨧ᩠ᨨᩴ ᨸᩩᨾ ᨶᨸᩩᩴᩈᨠᩮ;
ᩈᨴ᩠ᨴᩃᩮᩣ ᩉᩁᩥᨲᩮ ᨴᩮᩈᩮ, ᨲᩥᨱᩮᨶᩣ, ᨽᩥᨶᩅᩮᨶ ᩉᩥ.
ᨶᨴ᩠ᨿᨾ᩠ᨻᩩᨩᩦᩅᨶᩮᩣ ᨴᩮᩈᩮᩣ, ᩅᩩᨭ᩠ᨮᩥᨶᩥᨸ᩠ᨸᨩ᩠ᨩᩈᩔᨠᩮᩣ;
ᨿᩮᩣ ᨶᨴᩦᨾᩣᨲᩥᨠᩮᩣ ᨴᩮᩅ,
ᨾᩣᨲᩥᨠᩮᩣ ᨧ ᨠᨾᩮᨶ ᩈᩮᩣ.
ᨲᩦᩈ᩠ᩅᨶᩪᨸᩣᨴ᩠ᨿᨳᩮᩣ ᨧᨶ᩠ᨴ, ᩈᩪᩁᩣᨴᩮᩣ ᩈᩔᨲᩦᩁᩥᨲᩮᩣ;
ᩁᨭ᩠ᨮᩴ ᨲᩩ ᩅᩥᨩᩥᨲᨬ᩠ᨧᩣᨳ, ᨸᩩᩁᩥᩈᩮ ᩈᩮᨲᩩ ᩌᩃᩥᨿᩴ.
ᩏᨸᩣᨶ᩠ᨲᨽᩪ ᨸᩁᩥᩈᩁᩮᩣ, ᨣᩮᩣᨭ᩠ᨮᩴ ᨲᩩ ᨣᩮᩣᨠᩩᩃᩴ ᩅᨩᩮᩣ;
ᨾᨣ᩠ᨣᩮᩣ ᨸᨶ᩠ᨳᩮᩣ ᨸᨳᩮᩣ ᩋᨴ᩠ᨵᩣ, ᩋᨬ᩠ᨩᩈᩴ ᩅᨭᩩᨾᩴ ᨲᨳᩣ.
ᨸᨩ᩠ᨩᩮᩣ [ᨸᨩ᩠ᨩᩣ…. (ᨠ.)], ᨿᨶᨬ᩠ᨧ ᨸᨴᩅᩦ, ᩅᨲ᩠ᨲᨶᩦ ᨸᨴ᩠ᨵᨲᩥᨲ᩠ᨳᩥᨿᩴ;
ᨲᨻ᩠ᨽᩮᨴᩣ ᨩᨦ᩠ᨥ, ᩈᨠᨭ, ᨾᨣ᩠ᨣᩣ ᨲᩮ ᨧ ᨾᩉᨴ᩠ᨵᨶᩥ.
ᩑᨠᨸᨴ᩠ᨿᩮᨠᨸᨴᩥᨠᩮ, ᨠᨶ᩠ᨲᩣᩁᩮᩣ ᨲᩩ ᨧ ᨴᩩᨣ᩠ᨣᨾᩮ;
ᨸᨭᩥᨾᨣ᩠ᨣᩮᩣ ᨸᨭᩥᨸᨳᩮᩣ, ᩋᨴ᩠ᨵᩣᨶᩴ ᨴᩦᨥ ᨾᨬ᩠ᨩᩈᩴ;
ᩈᩩᨸ᩠ᨸᨳᩮᩣ ᨲᩩ ᩈᩩᨸᨶ᩠ᨳᩮᩣ ᨧ, ᩏᨸ᩠ᨸᨳᩴ ᨲ᩠ᩅᨸᨳᩴ ᨽᩅᩮ.
ᨨᨲ᩠ᨲᩥᩴᩈᨸᩁᨾᩣᨱᩪᨶ, ᨾᩮᨠᩮᩣ ᨱᩩ ᨧ ᨨᨲ᩠ᨲᩥᩴᩈ ᨲᩮ;
ᨲᨩ᩠ᨩᩣᩁᩦ ᨲᩣᨸᩥ ᨨᨲ᩠ᨲᩥᩴᩈ, ᩁᨳᩁᩮᨱᩩ ᨨᨲ᩠ᨲᩥᩴᩈ ᨲᩮ.
ᩃᩥᨠ᩠ᨡᩣᨲᩣ ᩈᨲ᩠ᨲ ᩐᨠᩣ ᨲᩣ, ᨵᨬ᩠ᨬᨾᩣᩈᩮᩣᨲᩥ ᩈᨲ᩠ᨲ ᨲᩮ;
ᩈᨲ᩠ᨲ ᨦ᩠ᨣᩩᩃ’ ᨾᨾᩩ ᨴ᩠ᩅᩥᨧ᩠ᨨ, ᩅᩥᨴᨲ᩠ᨳᩥ ᨲᩣ ᨴᩩᩅᩮ ᩈᩥᨿᩩᩴ.
ᩁᨲᨶᩴ ¶ ᨲᩣᨶᩥ ᩈᨲ᩠ᨲᩮᩅ, ᨿᨭ᩠ᨮᩥ ᨲᩣ ᩅᩦᩈᨲᩪ ᩈᨽᩴ;
ᨣᩣᩅᩩᨲ ᨾᩩᩈᨽᩣᩈᩦᨲᩥ, ᨿᩮᩣᨩᨶᩴ ᨧᨲᩩᨣᩣᩅᩩᨲᩴ.
ᨵᨶᩩᨸᨬ᩠ᨧᩈᨲᩴ ᨠᩮᩣᩈᩮᩣ, ᨠᩁᩦᩈᩴ ᨧᨲᩩᩁᨾ᩠ᨻᨱᩴ;
ᩋᨻ᩠ᨽᨶ᩠ᨲᩁᩴ ᨲᩩ ᩉᨲ᩠ᨳᩣᨶ, ᨾᨭ᩠ᨮᩅᩦᩈ ᨸᨾᩣᨱᨲᩮᩣ.
ᨽᩪᨾᩥᩅᨣ᩠ᨣᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.
᪒. ᨽᩪᨠᨱ᩠ᨯ
᪒. ᨸᩩᩁᩅᨣ᩠ᨣ
ᨸᩩᩁᩴ ᨶᨣᩁ ᨾᩥᨲ᩠ᨳᩦ ᩅᩣ, ᨮᩣᨶᩦᨿᩴ ᨸᩩᨭᨽᩮᨴᨶᩴ;
ᨳᩥᨿᩴ ᨲᩩ ᩁᩣᨩᨵᩣᨶᩦ [ᩁᩣᨩᨮᩣᨶᩦ (ᨭᩦ.)] ᨧ, ᨡᨶ᩠ᨵᩣᩅᩣᩁᩮᩣ ᨽᩅᩮ ᨳ ᨧ.
ᩈᩣᨡᩣᨶᨣᩁ ᨾᨬ᩠ᨬᨲᩕ, ᨿᩴ ᨲᩴ ᨾᩪᩃᨸᩩᩁᩣ ᨸᩩᩁᩴ;
ᨻᩣᩁᩣᨱᩈᩦ ᨧ ᩈᩣᩅᨲ᩠ᨳᩥ, ᩅᩮᩈᩣᩃᩦ ᨾᩥᨳᩥᩃᩣ, ᩊᩅᩦ.
ᨠᩮᩣᩈᨾ᩠ᨻᩩ, ᨩ᩠ᨩᩮᨶᩥᨿᩮᩣ ᨲᨠ᩠ᨠ, ᩈᩥᩃᩣ ᨧᨾ᩠ᨸᩣ ᨧ ᩈᩣᨣᩃᩴ;
ᩈᩩᩈᩩᨾᩣᩁᨣᩥᩁᩴ [ᩈᩴᩈᩩᨾᩣᩁ (ᨭᩦᨠᩣ)] ᩁᩣᨩ, ᨣᩉᩴ ᨠᨸᩥᩃᩅᨲ᩠ᨳᩩ ᨧ.
ᩈᩣᨠᩮᨲ, ᨾᩥᨶ᩠ᨴᨸᨲ᩠ᨳᨬ᩠ᨧᩮᩣ, ᨠ᩠ᨠᨭ᩠ᨮᩣ ᨸᩣᨭᩃᩥᨸᩩᨲ᩠ᨲᨠᩴ;
ᨩᩮᨲᩩᨲ᩠ᨲᩁᨬ᩠ᨧ ᩈᨦ᩠ᨠᩔᩴ, ᨠᩩᩈᩥᨶᩣᩁᩣᨴᨿᩮᩣ ᨸᩩᩁᩦ.
ᩁᨧ᩠ᨨᩣ ᨧ ᩅᩥᩈᩥᨡᩣ ᩅᩩᨲ᩠ᨲᩣ, ᩁᨳᩥᨠᩣ ᩅᩦᨳᩥ ᨧᩣᨸ᩠ᨿᨳ;
ᨻ᩠ᨿᩪᩉᩮᩣ ᩁᨧ᩠ᨨᩣ ᩋᨶᩥᨻ᩠ᨻᩥᨴ᩠ᨵᩣ, ᨶᩥᨻ᩠ᨻᩥᨴ᩠ᨵᩣ ᨲᩩ ᨸᨳᨴ᩠ᨵᩥ ᨧ.
ᨧᨲᩩᨠ᩠ᨠᩴ ᨧᨧ᩠ᨧᩁᩮ ᨾᨣ᩠ᨣ, ᩈᨶ᩠ᨵᩥ ᩈᩥᨦ᩠ᨥᩣᨭᨠᩴ ᨽᩅᩮ;
ᨸᩣᨠᩣᩁᩮᩣ ᩅᩁᨱᩮᩣ ᨧᩣᨳ, ᩏᨴᩣᨸᩮᩣ [ᩏᨴ᩠ᨴᩣᨸ, ᩏᨴ᩠ᨴᩣᨸ] ᩏᨸᨠᩣᩁᩥᨠᩣ.
ᨠᩩᨭ᩠ᨭᩴ ᨲᩩ ᨽᩥᨲ᩠ᨲᩥ ᨶᩣᩁᩦ ᨳ, ᨣᩮᩣᨸᩩᩁᩴ ᨴ᩠ᩅᩣᩁᨠᩮᩣᨭ᩠ᨮᨠᩮᩣ;
ᩑᩈᩥᨠᩣ ᩍᨶ᩠ᨴᨡᩦᩃᩮᩣ ᨧ, ᩋᨭ᩠ᨭᩮᩣ ᨲ᩠ᩅᨭ᩠ᨭᩣᩃᨠᩮᩣ ᨽᩅᩮ.
ᨲᩮᩣᩁᨱᩴ ᨲᩩ ᨻᩉᩥᨴ᩠ᩅᩣᩁᩴ, ᨸᩁᩥᨡᩣᨲᩩ ᨧ ᨴᩦᨥᩥᨠᩣ;
ᨾᨶ᩠ᨴᩥᩁᩴ ᩈᨴᨶᩣ, ᨣᩣᩁᩴ, ᨶᩥᨠᩣᨿᩮᩣ ᨶᩥᩃᨿᩣ, ᩃᨿᩮᩣ.
ᩌᩅᩣᩈᩮᩣ ᨽᩅᨶᩴ ᩅᩮᩈ᩠ᨾᩴ, ᨶᩥᨠᩮᨲᨶᩴ ᨶᩥᩅᩮᩈᨶᩴ;
ᨥᩁᩴ ᨣᩉᨬ᩠ᨧᩣ, ᩅᩈᨳᩮᩣ, ᩈᩁᨱᨬ᩠ᨧ ᨸᨲᩥᩔᨿᩮᩣ.
ᩒᨠᩴ ᩈᩣᩃᩣ ᨡᨿᩮᩣ ᩅᩣᩈᩮᩣ, ᨳᩥᨿᩴ ᨠᩩᨭᩥ ᩅᩈᨲ᩠ᨿ’ᨸᩥ;
ᨣᩮᩉᨬ᩠ᨧᩣ, ᨶᩥᨲ᩠ᨳᩥ ᩈᨴᩩᨾᩴ, ᨧᩮᨲᩥᨿᩣ, ᨿᨲᨶᩣᨶᩥ ᨲᩩ.
ᨸᩣᩈᩣᨴᩮᩣ ¶ ᨧᩮᩅ ᨿᩪᨸᩮᩣ ᨳ, ᨾᩩᨱ᩠ᨯᨧ᩠ᨨᨴᩮᩣ ᨧ ᩉᨾ᩠ᨾᩥᨿᩴ;
ᨿᩪᨸᩮᩣᨲᩩ ᨣᨩᨠᩩᨾ᩠ᨽᨾ᩠ᩉᩥ, ᩉᨲ᩠ᨳᩥᨶᨡᩮᩣ ᨸᨲᩥᨭ᩠ᨮᩥᨲᩮᩣ.
ᩈᩩᨸᨱ᩠ᨱᩅᨦ᩠ᨠᨧ᩠ᨨᨴᨶ, ᨾᨯ᩠ᨰᨿᩮᩣᨣᩮᩣ ᩈᩥᨿᩣ ᨳ ᨧ;
ᩑᨠᨠᩪᨭᨿᩩᨲᩮᩣ ᨾᩣᩊᩮᩣ,
ᨸᩣᩈᩣᨴᩮᩣ ᨧᨲᩩᩁᩔᨠᩮᩣ.
ᩈᨽᩣᨿᨬ᩠ᨧ ᩈᨽᩣ ᨧᩣᨳ, ᨾᨱ᩠ᨯᨸᩴ ᩅᩣ ᨩᨶᩣᩃᨿᩮᩣ;
ᩋᨳᩮᩣ ᩌᩈᨶᩈᩣᩃᩣᨿᩴ, ᨸᨭᩥᨠ᩠ᨠᨾᨶ ᨾᩦᩁᩥᨲᩴ.
ᨩᩥᨶᩔ ᩅᩣᩈᨽᩅᨶ, ᨾᩥᨲ᩠ᨳᩦ ᨣᨶ᩠ᨵᨠᩩᨭᩥ ᨸ᩠ᨿᨳ;
ᨳᩥᨿᩴ ᩁᩈᩅᨲᩦ ᨸᩣᨠ, ᨭ᩠ᨮᩣᨶᨬ᩠ᨧᩮᩅ ᨾᩉᩣᨶᩈᩴ.
ᩌᩅᩮᩈᨶᩴ ᩈᩥᨸ᩠ᨸᩈᩣᩃᩣ, ᩈᩮᩣᨱ᩠ᨯᩣ ᨲᩩ ᨸᩣᨶᨾᨶ᩠ᨴᩥᩁᩴ;
ᩅᨧ᩠ᨧᨭ᩠ᨮᩣᨶᩴ ᩅᨧ᩠ᨧᨠᩩᨭᩥ, ᨾᩩᨶᩦᨶᩴ ᨮᩣᨶ ᨾᩔᨾᩮᩣ.
ᨸᨱ᩠ᨿᩅᩥᨠ᩠ᨠᨿᩈᩣᩃᩣ ᨠᩩ, ᩌᨸᨱᩮᩣ ᨸᨱ᩠ᨿᩅᩦᨳᩥᨠᩣ;
ᩏᨴᩮᩣᩈᩥᨲᩮᩣ ᨽᨱ᩠ᨯᩈᩣᩃᩣ, ᨧᨦ᩠ᨠᨾᨶᩴ ᨲᩩ ᨧᨦ᩠ᨠᨾᩮᩣ.
ᨩᨶ᩠ᨲᩣᨥᩁᩴ ᨲ᩠ᩅᨣ᩠ᨣᩥᩈᩣᩃᩣ, ᨸᨸᩣ ᨸᩣᨶᩦᨿᩈᩣᩃᩥᨠᩣ;
ᨣᨻ᩠ᨽᩮᩣ ᩒᩅᩁᨠᩮᩣ ᩅᩣᩈᩣ, ᨣᩣᩁᩴ ᨲᩩ ᩈᨿᨶᩥᨣ᩠ᨣᩉᩴ.
ᩍᨲ᩠ᨳᩣᨣᩣᩁᩴ ᨲᩩ ᩒᩁᩮᩣᨵᩮᩣ, ᩈᩩᨴ᩠ᨵᨶ᩠ᨲᩮᩣ’ ᨶ᩠ᨲᩮᨸᩩᩁᨾ᩠ᨸᩥ ᨧ;
ᩋᩈᨻ᩠ᨻᩅᩥᩈᨿᨭ᩠ᨮᩣᨶᩴ, ᩁᨬ᩠ᨬᩴ ᨠᨧ᩠ᨨᨶ᩠ᨲᩁᩴ ᨾᨲᩴ.
ᩈᩮᩣᨸᩣᨶᩮᩣ ᩅᩣ’ᩁᩮᩣᩉᨱᨬ᩠ᨧ,
ᨶᩥᩔᩮᨱᩦ ᩈᩣ, ᨵᩥᩁᩮᩣᩉᩥᨱᩦ;
ᩅᩣᨲᨸᩣᨶᩴ ᨣᩅᨠ᩠ᨡᩮᩣ ᨧ, ᨩᩣᩃᨬ᩠ᨧ ᩈᩦᩉᨸᨬ᩠ᨩᩁᩴ.
ᩌᩃᩮᩣᨠᩈᨶ᩠ᨵᩥ ᩅᩩᨲ᩠ᨲᩮᩣ ᨳ, ᩃᨦ᩠ᨣᩦ’ᨲ᩠ᨳᩦ ᨸᩃᩥᨥᩮᩣ ᨽᩅᩮ;
ᨠᨸᩥᩈᩦᩈᩮᩣ, ᨣ᩠ᨣᩃᨲ᩠ᨳᨾ᩠ᨽᩮᩣ, ᨶᩥᨻ᩠ᨻᩴ ᨲᩩ ᨨᨴ᩠ᨴᨠᩮᩣᨭᩥᨿᩴ.
ᨨᨴᨶᩴ ᨸᨭᩃᩴ ᨨᨴ᩠ᨴ, ᨾᨩᩥᩁᩴ ᨧᨧ᩠ᨧᩁᩮᩣ, ᨦ᩠ᨣᨱᩴ;
ᨸᨥᩣᨶᩮᩣ ᨸᨥᨶᩣ, ᩃᩥᨶ᩠ᨴᩮᩣ, ᨸᨾᩩᨡᩴ ᨴ᩠ᩅᩣᩁᨻᨶ᩠ᨵᨶᩴ.
ᨸᩥᨭ᩠ᨮᩈᨦ᩠ᨥᩣᨭᨠᩴ ᨴ᩠ᩅᩣᩁ, ᨻᩣᩉᩣ ᨠᩪᨭᩴ ᨲᩩ ᨠᨱ᩠ᨱᩥᨠᩣ;
ᨴ᩠ᩅᩣᩁᨬ᩠ᨧ ᨸᨭᩥᩉᩣᩁᩮᩣ ᨳ, ᩏᨾ᩠ᨾᩣᩁᩮᩣ ᨴᩮᩉᨶᩦ, ᨲ᩠ᨳᩥᨿᩴ.
ᩑᩊᨠᩮᩣ ᩍᨶ᩠ᨴᨡᩦᩃᩮᩣ ᨳ, ᨳᨾ᩠ᨽᩮᩣ ᨳᩪᨱᩮᩣ ᨸᩩᨾᩥᨲ᩠ᨳᩥᨿᩴ;
ᨸᩣᨭᩥᨠᩣ, ᨯ᩠ᨰᩮᨶ᩠ᨴᩩᨸᩣᩈᩣᨱᩮ, ᨣᩥᨬ᩠ᨩᨠᩣ ᨲᩩ ᨧ ᩍᨭ᩠ᨮᨠᩣ.
ᩅᩃᨽᩥᨧ᩠ᨨᩣᨴᩥᨴᩣᩁᩩᨾ᩠ᩉᩥ, ᩅᨦ᩠ᨠᩮ ᨣᩮᩣᨸᩣᨶᩈᩦ, ᨲ᩠ᨳᩥᨿᩴ;
ᨠᨸᩮᩣᨲᨸᩣᩃᩥᨠᩣᨿᩴ ᨲᩩ, ᩅᩥᨭᨦ᩠ᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨽᩅᩮ.
ᨠᩩᨬ᩠ᨧᩥᨠᩣᩅᩥᩅᩁᩴ ¶ ᨲᩣᩊ, ᨧ᩠ᨨᩥᨣ᩠ᨣᩃᩮᩣ ᨸ᩠ᨿᨳ ᨠᩩᨬ᩠ᨧᩥᨠᩣ;
ᨲᩣᩊᩮᩣ’ᩅᩣᨸᩩᩁᨱᩴ ᨧᩣᨳ, ᩅᩮᨴᩥᨠᩣ ᩅᩮᨴᩥ ᨠᨳ᩠ᨿᨲᩮ.
ᩈᨦ᩠ᨥᩣᨲᩮᩣ ᨸᨠ᩠ᨡᨸᩣᩈᩮᩣ ᨧ, ᨾᨶ᩠ᨴᩥᩁᨦ᩠ᨣᩣ ᨲᩩᩃᩣ ᩋᨸᩥ;
ᨳᩥᨿᩴ ᩈᨾ᩠ᨾᩩᨩ᩠ᨩᨶᩦ ᨧᩮᩅ, ᩈᨾ᩠ᨾᨩ᩠ᨩᨶᩦ ᨧ ᩈᩮᩣᨵᨶᩦ.
ᩈᨦ᩠ᨠᨭᩦᩁᩴ ᨲᩩ ᩈᨦ᩠ᨠᩣᩁ, ᨭ᩠ᨮᩣᨶᩴ ᩈᨦ᩠ᨠᩣᩁᨠᩪᨭᨠᩴ;
ᩋᨳᩮᩣ ᨠᨧᩅᩁᩮᩣ, ᨠ᩠ᩃᩣᨸᩮᩣ, ᩈᨦ᩠ᨠᩣᩁᩮᩣ ᨧ ᨠᩈᨾ᩠ᨻᩩᨸᩥ.
ᨥᩁᩣᨴᩥᨽᩪᨾᩥ ᨲᩴ ᩅᨲ᩠ᨳᩩ, ᨣᩣᨾᩮᩣ ᩈᩴᩅᩈᨳᩮᩣ ᨳ ᩈᩮᩣ;
ᨸᩣᨠᨭᩮᩣ ᨶᩥᨣᨾᩮᩣ ᨽᩮᩣᨣ, ᨾᨧ᩠ᨧᩣᨴᩥᨽ᩠ᨿᩮᩣ ᨵᩥ ᨲᩪᨴᩥᨲᩮᩣ [‘ᩋᨵᩥᨽᩪ’ᨲᩥ ᩎᩁᩥᨲᩮᩣ ᨠᨳᩥᨲᩮᩣ (ᨭᩦ.)].
ᩈᩦᨾᩣ ᨧ ᨾᩁᩥᨿᩣᨴᩣ ᨳ,
ᨥᩮᩣᩈᩮᩣ ᨣᩮᩣᨸᩣᩃᨣᩣᨾᨠᩮᩣᨲᩥ.
ᨸᩩᩁᩅᨣ᩠ᨣᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.
᪓. ᨶᩁᩅᨣ᩠ᨣ
ᨾᨶᩩᩔᩮᩣ ᨾᩣᨶᩩᩈᩮᩣ ᨾᨧ᩠ᨧᩮᩣ, ᨾᩣᨶᩅᩮᩣ ᨾᨶᩩᨩᩮᩣ ᨶᩁᩮᩣ;
ᨸᩮᩣᩈᩮᩣ ᨸᩩᨾᩣ ᨧ ᨸᩩᩁᩥᩈᩮᩣ,
ᨸᩮᩣᩁᩥᩈᩮᩣ ᨸ᩠ᨿᨳ ᨸᨱ᩠ᨯᩥᨲᩮᩣ.
ᨻᩩᨵᩮᩣ ᩅᩥᨴ᩠ᩅᩣ ᩅᩥᨽᩣᩅᩦ ᨧ, ᩈᨶ᩠ᨲᩮᩣ ᩈᨸ᩠ᨸᨬ᩠ᨬ ᨠᩮᩣᩅᩥᨴᩣ;
ᨵᩦᨾᩣ ᩈᩩᨵᩦ ᨠᩅᩥ ᨻ᩠ᨿᨲ᩠ᨲᩮᩣ, ᩅᩥᨧᨠ᩠ᨡᨱᩮᩣ ᩅᩥᩈᩣᩁᨴᩮᩣ.
ᨾᩮᨵᩣᩅᩦ ᨾᨲᩥᨾᩣ ᨸᨬ᩠ᨬᩮᩣ, ᩅᩥᨬ᩠ᨬᩪ ᨧ ᩅᩥᨴᩪᩁᩮᩣ ᩅᩥᨴᩪ;
ᨵᩦᩁᩮᩣ ᩅᩥᨸᩔᩦ ᨴᩮᩣᩈᨬ᩠ᨬᩪ, ᨻᩩᨴ᩠ᨵᩮᩣ ᨧ ᨴᨻ᩠ᨻ ᩅᩥᨴ᩠ᨴᩈᩩ.
ᩍᨲ᩠ᨳᩦ ᩈᩦᨾᨶ᩠ᨲᩥᨶᩦ ᨶᩣᩁᩦ, ᨳᩦ ᩅᨵᩪ ᩅᨶᩥᨲᩣ, ᨦ᩠ᨣᨶᩣ;
ᨸᨾᨴᩣ ᩈᩩᨶ᩠ᨴᩁᩦ ᨠᨶ᩠ᨲᩣ, ᩁᨾᨱᩦ ᨴᨿᩥᨲᩣ, ᨻᩃᩣ.
ᨾᩣᨲᩩᨣᩣᨾᩮᩣ ᨧ ᨾᩉᩥᩃᩣ, ᩃᩃᨶᩣ ᨽᩦᩁᩩ ᨠᩣᨾᩥᨶᩦ;
ᨠᩩᨾᩣᩁᩥᨠᩣ ᨲᩩ ᨠᨬ᩠ᨬᩣ ᨳ, ᨿᩩᩅᨲᩦ ᨲᩁᩩᨱᩦ ᨽᩅᩮ.
ᨾᩉᩮᩈᩦ ᩈᩣᨽᩥᩈᩮᨠᩣᨬ᩠ᨬᩣ,
ᨽᩮᩣᨣᩥᨶᩦ ᩁᩣᨩᨶᩣᩁᩥᨿᩮᩣ;
ᨵᩅᨲ᩠ᨳᩥᨶᩦ ᨲᩩ ᩈᨦ᩠ᨠᩮᨲᩴ, ᨿᩣᨲᩥ ᨿᩣ ᩈᩣ, ᨽᩥᩈᩣᩁᩥᨠᩣ.
ᨣᨱᩥᨠᩣ ¶ ᩅᩮᩈᩥᨿᩣ ᩅᨱ᩠ᨱ, ᨴᩣᩈᩦ ᨶᨣᩁᩈᩮᩣᨽᩥᨶᩦ;
ᩁᩪᨸᩪᨸᨩᩦᩅᩥᨶᩦ ᩅᩮᩈᩦ, ᨠᩩᩃᨭᩣ ᨲᩩ ᨧ ᨻᨶ᩠ᨵᨠᩦ.
ᩅᩁᩣᩁᩮᩣᩉᩮᩣ, ᨲ᩠ᨲᨾᩣ ᨾᨲ᩠ᨲ, ᨠᩣᩈᩥᨶᩦ ᩅᩁᩅᨱ᩠ᨱᩥᨶᩦ;
ᨸᨲᩥᨻ᩠ᨻᨲᩣ ᨲ᩠ᩅᨸᩥ ᩈᨲᩦ, ᨠᩩᩃᩥᨲ᩠ᨳᩦ ᨠᩩᩃᨸᩣᩃᩥᨠᩣ.
ᩅᩥᨵᩅᩣ ᨸᨲᩥᩈᩩᨬ᩠ᨬᩣ ᨳ, ᨸᨲᩥᨾ᩠ᨻᩁᩣ ᩈᨿᨾ᩠ᨻᩁᩣ;
ᩅᩥᨩᩣᨲᩣ ᨲᩩ ᨸᩈᩪᨲᩣ ᨧ, ᨩᩣᨲᩣᨸᨧ᩠ᨧᩣ ᨸᩈᩪᨲᩥᨠᩣ.
ᨴᩪᨲᩦ ᩈᨬ᩠ᨧᩣᩁᩥᨠᩣ ᨴᩣᩈᩦ, ᨲᩩ ᨧᩮᨭᩦ ᨠᩩᨭᨵᩣᩁᩥᨠᩣ;
ᩅᩣᩁᩩᨱᩦ, ᨠ᩠ᨡᨱᩥᨠᩣ ᨲᩩᩃ᩠ᨿᩣ, ᨡᨲ᩠ᨲᩥᨿᩣᨶᩦ ᨲᩩ ᨡᨲ᩠ᨲᩥᨿᩣ.
ᨴᩣᩁᩮᩣ ᨩᩣᨿᩣ ᨠᩃᨲ᩠ᨲᨬ᩠ᨧ, ᨥᩁᨱᩦ ᨽᩁᩥᨿᩣ ᨸᩥᨿᩣ,
ᨸᨩᩣᨸᨲᩦ ᨧ ᨴᩩᨲᩥᨿᩣ, ᩈᩣ ᨸᩣᨴᨸᩁᩥᨧᩣᩁᩥᨠᩣ.
ᩈᨡᩦ ᨲ᩠ᩅᩣ’ᩃᩦ ᩅᨿᩔᩣ ᨳ, ᨩᩣᩁᩦ ᨧᩮᩅᩣ’ᨲᩥᨧᩣᩁᩥᨶᩦ;
ᨸᩩᨾᩮ ᨲᩪ’ᨲᩩ ᩁᨩᩮᩣ ᨸᩩᨸ᩠ᨹᩴ, ᩏᨲᩩᨶᩦ ᨲᩩ ᩁᨩᩔᩃᩣ.
ᨸᩩᨸ᩠ᨹᩅᨲᩦ ᨣᩁᩩᨣᨻ᩠ᨽᩣ, ᨸᨶ᩠ᨶᩈᨲ᩠ᨲᩣ ᨧ ᨣᨻ᩠ᨽᩥᨶᩦ;
ᨣᨻ᩠ᨽᩣᩈᨿᩮᩣ ᨩᩃᩣᨻᩩᨸᩥ, ᨠᩃᩃᩴ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ.
ᨵᩅᩮᩣᨲᩩ ᩈᩣᨾᩥᨠᩮᩣ ᨽᨲ᩠ᨲᩣ, ᨠᨶ᩠ᨲᩮᩣ ᨸᨲᩥ ᩅᩁᩮᩣ ᨸᩥᨿᩮᩣ;
ᩋᨳᩮᩣ ᨸᨸᨲᩥ ᨩᩣᩁᩮᩣ ᨳᩣ,
ᨸᨧ᩠ᨧᩴ ᨸᩩᨲ᩠ᨲᩮᩣ’ᨲᩕᨩᩮᩣ ᩈᩩᨲᩮᩣ.
ᨲᨶᩩᨩᩮᩣ ᨲᨶᨿᩮᩣ ᩈᩪᨶᩩ, ᨸᩩᨲ᩠ᨲᩣᨴᩦ ᨵᩦᨲᩁᩥ’ᨲ᩠ᨳᩥᨿᩴ;
ᨶᩣᩁᩥᨿᩴ ᨴᩩᩉᩥᨲᩣ ᨵᩦᨲᩣ,
ᩈᨩᩣᨲᩮᩣ ᨲ᩠ᩅᩮᩣ’ᩁᩈᩮᩣ ᩈᩩᨲᩮᩣ.
ᨩᩣᨿᩣᨸᨲᩦ ᨩᨶᩥᨸᨲᩦ, ᨩᨿᨾ᩠ᨸᨲᩦ ᨲᩩ ᨴᨾ᩠ᨸᨲᩦ [ᨴᨾ᩠ᨸᨲᩦᨲᩥ ᨸᨴᩴ ᨸᩩᩃ᩠ᩃᩥᨦ᩠ᨣ ᨻᩉᩩᩅᨧᨶᨶ᩠ᨲᩴ ᩍᨠᩣᩁᨶ᩠ᨲᩴ, ᨲᩩᨴᨾ᩠ᨸᨲᩥ (ᨭᩦ.)];
ᩋᨳ ᩅᩔᩅᩁᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨸᨱ᩠ᨯᨠᩮᩣ ᨧ ᨶᨸᩩᩴᩈᨠᩴ.
ᨻᨶ᩠ᨵᩅᩮᩣ ᨻᨶ᩠ᨵᩩ ᩈᨩᨶᩮᩣ, ᩈᨣᩮᩣᨲ᩠ᨲᩮᩣ ᨬᩣᨲᩥ ᨬᩣᨲᨠᩮᩣ;
ᩈᩣᩃᩮᩣᩉᩥᨲᩮᩣ ᩈᨸᩥᨱ᩠ᨯᩮᩣ ᨧ,
ᨲᩣᨲᩮᩣ ᨲᩩ ᨩᨶᨠᩮᩣ ᨸᩥᨲᩣ.
ᩋᨾ᩠ᨾ, ᨾ᩠ᨻᩣ ᨩᨶᨶᩦ ᨾᩣᨲᩣ, ᨩᨶᩮᨲ᩠ᨲᩥ ᨩᨶᩥᨠᩣ ᨽᩅᩮ;
ᩏᨸᨾᩣᨲᩣ ᨲᩩ ᨵᩣᨲᩥ’ᨲ᩠ᨳᩦ,
ᩈᩣᩃᩮᩣ ᨩᩣᨿᩣᨿ ᨽᩣᨲᩥᨠᩮᩣ.
ᨶᨶᨶ᩠ᨴᩣ ¶ ᩈᩣᨾᩥᨽᨣᩥᨶᩦ, ᨾᩣᨲᩣᨾᩉᩦ ᨲᩩ ᩋᨿ᩠ᨿᩥᨠᩣ;
ᨾᩣᨲᩩᩃᩮᩣ ᨾᩣᨲᩩᨽᩣᨲᩣ,ᩔ, ᨾᩣᨲᩩᩃᩣᨶᩦ ᨸᨩᩣᨸᨲᩥ.
ᨩᩣᨿᩣᨸᨲᩦᨶᩴ ᨩᨶᨶᩦ, ᩈᩔᩩ ᩅᩩᨲ᩠ᨲᩣᨳ ᨲᨸ᩠ᨸᩥᨲᩣ;
ᩈᩈᩩᩁᩮᩣ ᨽᩣᨣᩥᨶᩮᨿ᩠ᨿᩮᩣᨲᩩ, ᨸᩩᨲ᩠ᨲᩮᩣ ᨽᨣᩥᨶᩥᨿᩣ ᨽᩅᩮ.
ᨶᨲ᩠ᨲᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᨸᨸᩩᨲ᩠ᨲᩮᩣ ᨳ, ᩈᩣᨾᩥᨽᩣᨲᩣ ᨲᩩ ᨴᩮᩅᩁᩮᩣ;
ᨵᩦᨲᩩᨸᨲᩥ ᨲᩩ ᨩᩣᨾᩣᨲᩣ,
ᩋᨿ᩠ᨿᨠᩮᩣ ᨲᩩ ᨸᩥᨲᩣᨾᩉᩮᩣ.
ᨾᩣᨲᩩᨧ᩠ᨨᩣ ᨾᩣᨲᩩᨽᨣᩥᨶᩦ, ᨸᩥᨲᩩᨧ᩠ᨨᩣ ᨽᨣᩥᨶᩦ ᨸᩥᨲᩩ;
ᨸᨸᩥᨲᩣᨾᩉᩮᩣ ᨸᨿ᩠ᨿᨠᩮᩣ,
ᩈᩩᨱ᩠ᩉᩣ ᨲᩩ ᩈᩩᨱᩥᩈᩣ ᩉᩩᩈᩣ.
ᩈᩮᩣᨴᩁᩥᨿᩮᩣ ᩈᨣᨻ᩠ᨽᩮᩣ ᨧ, ᩈᩮᩣᨴᩁᩮᩣ ᩈᩉᨩᩮᩣ ᨸ᩠ᨿᨳ;
ᨾᩣᨲᩣᨸᩥᨲᩪ ᨲᩮ ᨸᩥᨲᩁᩮᩣ, ᨸᩩᨲ᩠ᨲᩣ ᨲᩩ ᨸᩩᨲ᩠ᨲᨵᩦᨲᩁᩮᩣ.
ᩈᩈᩩᩁᩣ ᩈᩔᩩᩈᩈᩩᩁᩣ, ᨽᩣᨲᩩᨽᨣᩥᨶᩦ ᨽᩣᨲᩁᩮᩣ;
ᨻᩣᩃᨲ᩠ᨲᩴ ᨻᩣᩃᨲᩣ ᨻᩣᩃ᩠ᨿᩴ, ᨿᩮᩣᨻ᩠ᨻᨬ᩠ᨬᩴᨲᩩ ᨧ ᨿᩮᩣᨻ᩠ᨻᨶᩴ.
ᩈᩩᨠ᩠ᨠᩣ ᨲᩩ ᨸᩃᩥᨲᩴ ᨠᩮᩈᩣ, ᨴᨿᩮᩣ ᨳ ᨩᩁᨲᩣ ᨩᩁᩣ;
ᨸᩩᨳᩩᨠᩮᩣ ᨸᩥᩃ᩠ᩃᨠᩮᩣ ᨨᩣᨸᩮᩣ, ᨠᩩᨾᩣᩁᩮᩣ ᨻᩣᩃ ᨸᩮᩣᨲᨠᩣ.
ᩋᨳᩩ’ ᨲ᩠ᨲᩣᨶᩈᨿᩩ’ᨲ᩠ᨲᩣᨶ, ᩈᩮᨿ᩠ᨿᨠᩣ ᨳᨶᨸᩮᩣᨸᩥ ᨧ;
ᨲᩁᩩᨱᩮᩣ ᨧ ᩅᨿᨭ᩠ᨮᩮᩣ ᨧ, ᨴᩉᩁᩮᩣ ᨧ ᨿᩩᩅᩣ ᩈᩩᩈᩩ;
ᨾᩣᨱᩅᩮᩣᨴᩣᩁᨠᩮᩣᨧᩣᨳ, ᩈᩩᨠᩩᨾᩣᩁᩮᩣ ᩈᩩᨡᩮᨵᩥᨲᩮᩣ.
ᨾᩉᩃ᩠ᩃᨠᩮᩣ ᨧ ᩅᩩᨴ᩠ᨵᩮᩣ ᨧ, ᨳᩮᩁᩮᩣ ᨩᩥᨱ᩠ᨱᩮᩣ ᨧ ᨩᩥᨱ᩠ᨱᨠᩮᩣ;
ᩋᨣ᩠ᨣᨩᩮᩣ ᨸᩩᨻ᩠ᨻᨩᩮᩣ ᨩᩮᨭ᩠ᨮᩮᩣ, ᨠᨶᩥᨿᩮᩣ ᨠᨶᩥᨭ᩠ᨮᩮᩣ ᨶᩩᨩᩮᩣ.
ᩅᩃᩥᨲ᩠ᨲᨧᩮᩣ ᨲᩩ ᩅᩃᩥᨶᩮᩣ; ᨲᩦᩈᩩ’ᨲ᩠ᨲᩣᨶᩈᨿᩣᨴᨿᩮᩣ;
ᩈᩦᩈᩮᩣ’ᨲ᩠ᨲᨾᨦ᩠ᨣᩣᨶᩥ ᩈᩥᩁᩮᩣ, ᨾᩩᨴ᩠ᨵᩣ ᨧ ᨾᨲ᩠ᨳᨠᩮᩣ ᨽᩅᩮ;
ᨠᩮᩈᩮᩣ ᨲᩩ ᨠᩩᨶ᩠ᨲᩃᩮᩣ ᩅᩣᩃᩮᩣ, ᨲ᩠ᨲᨾᨦ᩠ᨣᩁᩩᩉ ᨾᩩᨴ᩠ᨵᨩᩣ.
ᨵᨾ᩠ᨾᩥᩃ᩠ᩃᩮᩣ ᩈᩴᨿᨲᩣ ᨠᩮᩈᩣ,
ᨠᩣᨠᨸᨠ᩠ᨡᩮᩣ ᩈᩥᨡᨱ᩠ᨯᨠᩮᩣ;
ᨸᩣᩈᩮᩣ ᩉᨲ᩠ᨳᩮᩣ ᨠᩮᩈᨧᨿᩮ;
ᨲᩣᨸᩈᩣᨶᩴ ᨲᩉᩥᩴ ᨩᨭᩣ.
ᨳᩥᨿᩴ ᩅᩮᨱᩦ ᨸᩅᩮᨱᩦ ᨧ;
ᩋᨳᩮᩣ ᨧᩪᩊᩣ ᩈᩥᨡᩣ ᩈᩥᨿᩣ;
ᩈᩦᨾᨶ᩠ᨲᩮᩣ ᨲᩩ ᨾᨲᩮᩣ ᨶᩣᩁᩥ, ᨠᩮᩈᨾᨩ᩠ᨫᨾ᩠ᩉᩥ ᨸᨴ᩠ᨵᨲᩥ.
ᩃᩮᩣᨾᩴ ¶ ᨲᨶᩩᩁᩩᩉᩴ ᩁᩮᩣᨾᩴ, ᨸᨾ᩠ᩉᩴ ᨸᨡᩩᨾ ᨾᨠ᩠ᨡᩥᨣᩴ;
ᨾᩔᩩ ᩅᩩᨲ᩠ᨲᩴ ᨸᩩᨾᨾᩩᨡᩮ, ᨽᩪ ᨲ᩠ᩅᩥᨲ᩠ᨳᩦ ᨽᨾᩩᨠᩮᩣ ᨽᨾᩩ.
ᨻᨸ᩠ᨸᩮᩣ [ᨡᨸ᩠ᨸᩮᩣ (ᨭᩦ.)] ᨶᩮᨲ᩠ᨲᨩᩃ’ᩔᩪᨶᩥ, ᨶᩮᨲ᩠ᨲᨲᩣᩁᩣ ᨠᨶᩦᨶᩥᨠᩣ;
ᩅᨴᨶᩴ ᨲᩩ ᨾᩩᨡᩴ ᨲᩩᨱ᩠ᨯᩴ, ᩅᨲ᩠ᨲᩴ ᩃᨸᨶ ᨾᩣᨶᨶᩴ.
ᨴ᩠ᩅᩥᨩᩮᩣ ᩃᨸᨶᨩᩮᩣ ᨴᨶ᩠ᨲᩮᩣ, ᨴᩈᨶᩮᩣ ᩁᨴᨶᩮᩣ ᩁᨴᩮᩣ;
ᨴᩣᨮᩣ ᨲᩩᨴᨶ᩠ᨲᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᩋᨸᩣᨦ᩠ᨣᩮᩣ ᨲ᩠ᩅᨠ᩠ᨡᩥᨠᩮᩣᨭᩥᩈᩩ.
ᨴᨶ᩠ᨲᩣᩅᩁᨱ ᨾᩮᩣᨭ᩠ᨮᩮᩣ ᨧᩣ, ᨸ᩠ᨿ’ᨵᩁᩮᩣ ᨴᩈᨶᨧ᩠ᨨᨴᩮᩣ;
ᨣᨱ᩠ᨯᩮᩣ ᨠᨸᩮᩣᩃᩮᩣ ᩉᨶ᩠ᩅᩥᨲ᩠ᨳᩦ [ᨣᨱ᩠ᨯᨲ᩠ᨳᩦ (ᨭᩦ.) ᩉᨶ᩠ᩅᨲ᩠ᨳᩦ=ᩉᨶᩩ+ᩍᨲ᩠ᨳᩦ; ᩉᨶ+ᩏ (ᨱ᩠ᩅᩣᨴᩥ)],
ᨧᩩᨻᩩᨠᩴ ᨲ᩠ᩅ’ ᨵᩁᩣ ᩋᨵᩮᩣ.
ᨣᩃᩮᩣ ᨧ ᨠᨱ᩠ᨮᩮᩣ ᨣᩦᩅᩣ ᨧ, ᨠᨶ᩠ᨵᩁᩣ ᨧ ᩈᩥᩁᩮᩣᨵᩁᩣ;
ᨠᨾ᩠ᨻᩩᨣᩦᩅᩣ ᨲᩩ ᨿᩣ ᨣᩦᩅᩣ, ᩈᩩᩅᨱ᩠ᨱᩣᩃᩥᨦ᩠ᨣᩈᨶ᩠ᨶᩥᨽᩣ;
ᩋᨦ᩠ᨠᩥᨲᩣ ᨲᩦᩉᩥ ᩃᩮᨡᩣᩉᩥ, ᨠᨾ᩠ᨻᩩᨣᩦᩅᩣ ᨳᩅᩣ ᨾᨲᩣ.
ᩋᩴᩈᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨽᩩᨩᩈᩥᩁᩮᩣ, ᨡᨶ᩠ᨵᩮᩣ ᨲᩔᨶ᩠ᨵᩥ ᨩᨲ᩠ᨲᩩ ᨲᩴ;
ᨻᩣᩉᩩᨾᩪᩃᩴ ᨲᩩ ᨠᨧ᩠ᨨᩮᩣ, ᨵᩮᩣ, ᨲ᩠ᩅ’ᩔ ᨸᩔ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.
ᨻᩣᩉᩩ ᨽᩩᨩᩣᨴ᩠ᩅᩦᩈᩩ ᨻᩣᩉᩣ, ᩉᨲ᩠ᨳᩮᩣ ᨲᩩ ᨠᩁ ᨸᩣᨱᨿᩮᩣ;
ᨾᨱᩥᨻᨶ᩠ᨵᩮᩣ ᨸᨠᩮᩣᨭ᩠ᨮᨶ᩠ᨲᩮᩣ, ᨠᨸ᩠ᨸᩁᩮᩣ ᨲᩩ ᨠᨸᩮᩣᨱ᩠ᨿ’ᨳ.
ᨾᨱᩥᨻᨶ᩠ᨵ ᨠᨶᩥᨭ᩠ᨮᩣᨶᩴ, ᨸᩣᨱᩥᩔ ᨠᩁᨽᩮᩣ,ᨶ᩠ᨲᩁᩴ;
ᨠᩁᩈᩣᨡᩣ, ᨦ᩠ᨣᩩᩃᩦ ᨲᩣ ᨲᩩ, ᨸᨬ᩠ᨧ, ᨦ᩠ᨣᩩᨭ᩠ᨮᩮᩣ ᨧ ᨲᨩ᩠ᨩᨶᩦ;
ᨾᨩ᩠ᨫᩥᨾᩣ ᨶᩣᨾᩥᨠᩣ ᨧᩣᨸᩥ, ᨠᨶᩥᨭ᩠ᨮᩣ’ᨲᩥ ᨠᨾᩣ ᩈᩥᨿᩩᩴ.
ᨸᨴᩮᩈᩮᩣ ᨲᩣᩃᨣᩮᩣᨠᨱ᩠ᨱᩣ, ᩅᩥᨴᨲ᩠ᨳᩥ,ᨲ᩠ᨳᩦ ᨠᨾᩣ ᨲᨲᩮ;
ᨲᨩ᩠ᨩᨶ᩠ᨿᩣᨴᩥᨿᩩᨲᩮ’ᨦ᩠ᨣᩩᨭ᩠ᨮᩮ, ᨸᩈᨲᩮᩣ ᨸᩣᨱᩥ ᨠᩩᨬ᩠ᨧᩥᨲᩮᩣ.
ᩁᨲᨶᩴ ᨠᩩᨠ᩠ᨠᩩ ᩉᨲ᩠ᨳᩮᩣ ᨳ, ᨸᩩᨾᩮ ᨠᩁᨸᩩᨭᩮᩣ,ᨬ᩠ᨩᩃᩥ;
ᨠᩁᨩᩮᩣ ᨲᩩ ᨶᨡᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨡᨭᨠᩮᩣ ᨾᩩᨭ᩠ᨮᩥ ᨧ ᨴ᩠ᩅᩦᩈᩩ.
ᨻ᩠ᨿᩣᨾᩮᩣ ᩈᩉᨠᩁᩣ ᨻᩣᩉᩩ, ᨴ᩠ᩅᩮ ᨸᩔᨴ᩠ᩅᨿᩅᩥᨲ᩠ᨳᨲᩣ;
ᩏᨴ᩠ᨵᨶ᩠ᨲᨲ ᨽᩩᨩᨸᩮᩣᩈ, ᨸ᩠ᨸᨾᩣᨱᩮ ᨸᩮᩣᩁᩥᩈᩴ ᨲᩥᩈᩩ.
ᩏᩁᩮᩣ ᨧ ᩉᨴᨿᩴ ᨧᩣᨳ, ᨳᨶᩮᩣ ᨠᩩᨧ ᨸᨿᩮᩣᨵᩁᩣ;
ᨧᩪᨧᩩᨠᩴ ᨲᩩ ᨳᨶᨣ᩠ᨣᩈ᩠ᨾᩥᩴ, ᨸᩥᨭ᩠ᨮᩴ ᨲᩩ ᨸᩥᨭ᩠ᨮᩥ ᨶᩣᩁᩥᨿᩴ.
ᨾᨩ᩠ᨫᩮᩣ’ᨶᩥᨲ᩠ᨳᩦ ¶ ᩅᩥᩃᨣ᩠ᨣᩮᩣ ᨧ, ᨾᨩ᩠ᨫᩥᨾᩴ ᨠᩩᨧ᩠ᨨᩥ [ᨧᨲᩩᨠ᩠ᨠᩴ ᩏᨴᩁᩮ; ᪙᪔᪔-ᨣᩣᨳᩣᨸᩥ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨲᩩ ᨴ᩠ᩅᩥᩈᩩ;
ᨣᩉᨱᩦᨲ᩠ᨳ᩠ᨿᩩᨴᩁᩴ ᨣᨻ᩠ᨽᩮᩣ, ᨠᩮᩣᨭ᩠ᨮᩮᩣᨶ᩠ᨲᩮᩣ ᨠᩩᨧ᩠ᨨᩥᩈᨾ᩠ᨽᩅᩮ.
ᨩᨥᨶᩴ ᨲᩩ ᨶᩥᨲᨾ᩠ᨻᩮᩣ ᨧ, ᩈᩮᩣᨱᩦ ᨧ ᨠᨭᩥ ᨶᩣᩁᩥᨿᩴ;
ᩋᨦ᩠ᨣᨩᩣᨲᩴ ᩁᩉᩔᨦ᩠ᨣᩴ, ᩅᨲ᩠ᨳᨣᩩᨿ᩠ᩉᨬ᩠ᨧ ᨾᩮᩉᨶᩴ.
ᨶᩥᨾᩥᨲ᩠ᨲᨬ᩠ᨧ ᩅᩁᨦ᩠ᨣᨬ᩠ᨧ, ᨻᩦᨩᨬ᩠ᨧ ᨹᩃᨾᩮᩅ ᨧ;
ᩃᩥᨦ᩠ᨣᩴ ᩋᨱ᩠ᨯᩴ ᨲᩩ ᨠᩮᩣᩈᩮᩣ ᨧ,
ᨿᩮᩣᨶᩥ ᨲ᩠ᩅᩥᨲ᩠ᨳᩦᨸᩩᨾᩮᨽᨣᩴ.
ᩋᩈᩩᨧᩥ ᩈᨾ᩠ᨽᩅᩮᩣ ᩈᩩᨠ᩠ᨠᩴ, ᨸᩣᨿᩩ ᨲᩩ ᨸᩩᩁᩥᩈᩮ ᨣᩩᨴᩴ;
ᩅᩣ ᨸᩩᨾᩮ ᨣᩪᨳ ᨠᩁᩦᩈ, ᩅᨧ᩠ᨧᩣᨶᩥ ᨧ ᨾᩃᩴ ᨨᨠᩴ.
ᩏᨧ᩠ᨧᩣᩁᩮᩣ ᨾᩦᩊ᩠ᩉ ᨾᩩᨠ᩠ᨠᩣᩁᩮᩣ, ᨸᩔᩣᩅᩮᩣ ᨾᩩᨲ᩠ᨲ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨸᩪᨲᩥᨾᩩᨲ᩠ᨲᨬ᩠ᨧ ᨣᩮᩣᨾᩩᨲ᩠ᨲᩮ, ᩔᩣᨴᩦᨶᩴ ᨨᨠᨱᩴ ᨾᩃᩮ.
ᨴ᩠ᩅᩦᩈ᩠ᩅᨵᩮᩣ ᨶᩣᨽᩥᨿᩣ ᩅᨲ᩠ᨳᩥ, ᩏᨧ᩠ᨨᨦ᩠ᨣ’ᨦ᩠ᨠᩣ ᨲᩩ’ᨽᩮᩣ ᨸᩩᨾᩮ;
ᩐᩁᩩ ᩈᨲ᩠ᨳᩥ ᨸᩩᨾᩮ ᩐᩁᩩ, ᨸᨻ᩠ᨻᩴ ᨲᩩ ᨩᩣᨱᩩ ᨩᨱ᩠ᨱᩩ ᨧ.
ᨣᩮᩣᨸ᩠ᨹᨠᩮᩣ ᨸᩣᨴᨣᨱ᩠ᨮᩥᨸᩥ, ᨸᩩᨾᩮ ᨲᩩ ᨸᨱ᩠ᩉᩥ ᨸᩣᩈᨱᩥ;
ᨸᩣᨴᨣ᩠ᨣᩴ ᨸᨸᨴᩮᩣ ᨸᩣᨴᩮᩣ, ᨲᩩ ᨸᨴᩮᩣ ᨧᩁᨱᨬ᩠ᨧ ᩅᩣ.
ᩋᨦ᩠ᨣᩴᨲ᩠ᩅ’ᩅᨿᩅᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨹᩣᩈᩩᩃᩥᨠᩣ ᨲᩩ ᨹᩣᩈᩩᨠᩣ;
ᨸᨱ᩠ᨯᨠᩮ ᩋᨭ᩠ᨮᩥ ᨵᩣᨲ᩠ᩅᩥᨲ᩠ᨳᩦ, ᨣᩃᨶ᩠ᨲᨭ᩠ᨮᩥ ᨲᩩ ᩋᨠ᩠ᨡᨠᩮᩣ.
ᨠᨸ᩠ᨸᩁᩮᩣ ᨲᩩ ᨠᨸᩣᩃᩴ ᩅᩣ, ᨠᨱ᩠ᨯᩁᩣ ᨲᩩ ᨾᩉᩣᩈᩥᩁᩣ;
ᨸᩩᨾᩮ ᨶ᩠ᩉᩣᩁᩩ ᨧᩥᨲ᩠ᨳᩦ ᩈᩥᩁᩣ, ᨵᨾᨶᩦ ᨳ ᩁᩈᨣ᩠ᨣᩈᩣ.
ᩁᩈᩉᩁᨱ᩠ᨿ’ᨳᩮᩣ ᨾᩴᩈ, ᨾᩣᨾᩥᩈᩴ ᨸᩥᩈᩥᨲᩴ ᨽᩅᩮ;
ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩴ ᨲᩩ ᩅᩃ᩠ᩃᩪᩁ, ᨾᩩᨲ᩠ᨲᨲ᩠ᨲᩴ ᩋᨳ ᩃᩮᩣᩉᩥᨲᩴ.
ᩁᩩᨵᩥᩁᩴ ᩈᩮᩣᨱᩥᨲᩴ ᩁᨲ᩠ᨲᩴ, ᩃᩣᩃᩣ ᨡᩮᩊᩮᩣ ᩑᩃᩣ ᨽᩅᩮ;
ᨸᩩᩁᩥᩈᩮ ᨾᩣᨿᩩ ᨸᩥᨲ᩠ᨲᨬ᩠ᨧ, ᩈᩮᨾ᩠ᩉᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᩥᩃᩮᩈᩩᨾᩮᩣ.
ᩅᩈᩣ ᩅᩥᩃᩦᨶᩈ᩠ᨶᩮᩉᩮᩣ ᨳ, ᨾᩮᨴᩮᩣ ᨧᩮᩅ ᩅᨸᩣ ᨽᩅᩮ;
ᩌᨠᨸ᩠ᨸᩮᩣ ᩅᩮᩈᩮᩣ ᨶᩮᨸᨧ᩠ᨨᩴ, ᨾᨱ᩠ᨯᨶᩴ ᨲᩩ ᨸᩈᩣᨵᨶᩴ.
ᩅᩥᨽᩪᩈᨶᩴ ᨧᩣᨽᩁᨱᩴ, ᩋᩃᨦ᩠ᨠᩣᩁᩮᩣ ᨸᩥᩃᨶ᩠ᨵᨶᩴ;
ᨠᩥᩁᩦᨭ ᨾᨠᩩᨭᩣ’ᨶᩥᨲ᩠ᨳᩦ, ᨧᩪᩊᩣᨾᨱᩥ ᩈᩥᩁᩮᩣᨾᨱᩥ.
ᩈᩥᩁᩮᩣᩅᩮᨮᨶ ¶ ᨾᩩᨱ᩠ᩉᩦᩈᩴ, ᨠᩩᨱ᩠ᨯᩃᩴ ᨠᨱ᩠ᨱᩅᩮᨮᨶᩴ;
ᨠᨱ᩠ᨱᩥᨠᩣ ᨠᨱ᩠ᨱᨸᩪᩁᩮᩣ ᨧ, ᩈᩥᨿᩣ ᨠᨱ᩠ᨱᩅᩥᨽᩪᩈᨶᩴ.
ᨠᨱ᩠ᨮᨽᩪᩈᩣ ᨲᩩ ᨣᩦᩅᩮᨿ᩠ᨿᩴ, ᩉᩣᩁᩮᩣ ᨾᩩᨲ᩠ᨲᩣᩅᩃᩥ’ᨲ᩠ᨳᩥᨿᩴ;
ᨶᩥᨿᩩᩁᩮᩣ ᩅᩃᨿᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᨭᨠᩴ ᨸᩁᩥᩉᩣᩁᨠᩴ.
ᨠᨦ᩠ᨠᨱᩴ ᨠᩁᨽᩪᩈᩣ ᨳ, ᨠᩥᨦ᩠ᨠᩥᨱᩦ [ᨠᩥᩴᨠᨱᩦ ᨠᩥᩴ ᨠᨱᩥᨠᩣ (ᨠ.)] ᨡᩩᨴ᩠ᨴᨥᨱ᩠ᨭᩥᨠᩣ;
ᩋᨦ᩠ᨣᩩᩃᩦᨿᨠ ᨾᨦ᩠ᨣᩩᩃ᩠ᨿᩣ, ᨽᩁᨱᩴ, ᩈᩣᨠ᩠ᨡᩁᩴ ᨲᩩ ᨲᩴ.
ᨾᩩᨴ᩠ᨴᩥᨠᩣ’ᨦ᩠ᨣᩩᩃᩥᨾᩩᨴ᩠ᨴᩣ ᨳ, ᩁᩈᨶᩣ ᨾᩮᨡᩃᩣ ᨽᩅᩮ;
ᨠᩮᨿᩪᩁ ᨾᨦ᩠ᨣᨴᨬ᩠ᨧᩮᩅ, ᨻᩣᩉᩩᨾᩪᩃᩅᩥᨽᩪᩈᨶᩴ.
ᨸᩣᨴᨦ᩠ᨣᨴᩴ ᨲᩩ ᨾᨬ᩠ᨩᩦᩁᩮᩣ, ᨸᩣᨴᨠᨭᨠ ᨶᩪᨸᩩᩁᩣ;
ᩋᩃᨦ᩠ᨠᩣᩁᨸ᩠ᨸᨽᩮᨴᩣ ᨲᩩ, ᨾᩩᨡᨹᩩᩃ᩠ᩃᩴ ᨲᨳᩮᩣ’ᨱ᩠ᨱᨲᩴ;
ᩏᨣ᩠ᨣᨲ᩠ᨳᨶᩴ ᨣᩥᨦ᩠ᨣᨾᨠ, ᨾᩥᨧ᩠ᨧᩮᩅᨾᩣᨴᨿᩮᩣ ᩈᩥᨿᩩᩴ.
ᨧᩮᩃ ᨾᨧ᩠ᨨᩣᨴᨶᩴ ᩅᨲ᩠ᨳᩴ, ᩅᩣᩈᩮᩣ ᩅᩈᨶ ᨾᩴᩈᩩᨠᩴ;
ᩋᨾ᩠ᨻᩁᨬ᩠ᨧ ᨸᨭᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨴᩩᩔᩴ ᨧᩮᩣᩃᩮᩣ ᨧ ᩈᩣᨭᨠᩮᩣ.
ᨡᩮᩣᨾᩴ ᨴᩩᨠᩪᩃᩴ ᨠᩮᩣᩈᩮᨿ᩠ᨿᩴ, ᨸᨲ᩠ᨲᩩᨱ᩠ᨱᩴ ᨠᨾ᩠ᨻᩃᩮᩣ ᨧ ᩅᩣ;
ᩈᩣᨱᩴ ᨠᩮᩣᨭᨾ᩠ᨻᩩᩁᩴ ᨽᨦ᩠ᨣ, ᨶ᩠ᨲ᩠ᨿᩣᨴᩥ ᩅᨲ᩠ᨳᨶ᩠ᨲᩁᩴ ᨾᨲᩴ.
ᨶᩥᩅᩣᩈᨶ ᨶ᩠ᨲᩁᩦᨿᩣᨶ᩠ᨿ, ᨶ᩠ᨲᩁᨾᨶ᩠ᨲᩁᩅᩣᩈᨠᩮᩣ;
ᨸᩣᩅᩣᩁᩮᩣ ᨲᩩ’ᨲ᩠ᨲᩁᩣᩈᨦ᩠ᨣᩮᩣ, ᩏᨸᩈᩴᨻ᩠ᨿᩣᨶ ᨾᩩᨲ᩠ᨲᩁᩴ.
ᩏᨲ᩠ᨲᩁᩦᨿ ᨾᨳᩮᩣ ᩅᨲ᩠ᨳ, ᨾᩉᨲᨶ᩠ᨲᩥ ᨾᨲᩴ ᨶᩅᩴ;
ᨶᨶ᩠ᨲᨠᩴ ᨠᨸ᩠ᨸᨭᩮᩣ ᨩᩥᨱ᩠ᨱ, ᩅᩈᨶᩴ ᨲᩩ ᨸᨭᨧ᩠ᨧᩁᩴ.
ᨠᨬ᩠ᨧᩩᨠᩮᩣ ᩅᩣᩁᩅᩣᨱᩴ ᩅᩣ, ᨳ ᩅᨲ᩠ᨳᩣᩅᨿᩅᩮ ᨴᩈᩣ;
ᨶᩣᩃᩥᨸᨭ᩠ᨭᩮᩣᨲᩥ ᨠᨳᩥᨲᩮᩣ, ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᨾ᩠ᩉᩥ ᨠᨬ᩠ᨧᩩᨠᩮᩣ.
ᩌᨿᩣᨾᩮᩣ ᨴᩦᨥᨲᩣ ᩁᩮᩣᩉᩮᩣ,
ᨸᩁᩥᨱᩣᩉᩮᩣ ᩅᩥᩈᩣᩃᨲᩣ.
ᩋᩁᩉᨴ᩠ᨵᨩᩮᩣ ᨧ ᨠᩣᩈᩣᨿ, ᨠᩣᩈᩣᩅᩣᨶᩥ ᨧ ᨧᩦᩅᩁᩴ;
ᨾᨱ᩠ᨯᩃᩴ ᨲᩩ ᨲᨴᨦ᩠ᨣᩣᨶᩥ, ᩅᩥᩅᨭ᩠ᨭ ᨠᩩᩈᩥᩌᨴᨿᩮᩣ.
ᨹᩃ,ᨲ᩠ᨲᨧ, ᨠᩥᨾᩥ, ᩁᩮᩣᨾᩣ, ᨶ᩠ᨿᩮᨲᩣ ᩅᨲ᩠ᨳᩔ ᨿᩮᩣᨶᩥᨿᩮᩣ;
ᨹᩣᩃᩴ ᨠᨸ᩠ᨸᩣᩈᩥᨠᩴ ᨲᩦᩈᩩ, ᨡᩮᩣᨾᩣᨴᩦ ᨲᩩ ᨲᨧᨻ᩠ᨽᩅᩣ.
ᨠᩮᩣᩈᩮᨿ᩠ᨿᩴ ¶ ᨠᩥᨾᩥᨩᩴ, ᩁᩮᩣᨾ, ᨾᨿᩴ ᨲᩩ ᨠᨾ᩠ᨻᩃᩴ ᨽᩅᩮ;
ᩈᨾᩣᨶᨲ᩠ᨳᩣ ᨩᩅᨶᩥᨠᩣ, ᩈᩣ ᨲᩥᩁᩮᩣᨠᩁᨱᩦ ᨸ᩠ᨿᨳ.
ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠ ᨾᩩᩃ᩠ᩃᩮᩣᨧᩴ, ᩅᩥᨲᩣᨶᩴ ᨴ᩠ᩅᨿ ᨾᩦᩁᩥᨲᩴ;
ᨶᩉᩣᨶᨬ᩠ᨧ ᩈᩥᨶᩣᨶᩮ ᨳᩮᩣ, ᨻ᩠ᨻᨭ᩠ᨭᨶᩩ’ᨾ᩠ᨾᨩ᩠ᨩᨶᩴ ᩈᨾᩴ.
ᩅᩥᩈᩮᩈᨠᩮᩣ ᨲᩩ ᨲᩥᩃᨠᩮᩣ, ᨲ᩠ᨿᩪᨽᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨧ ᨧᩥᨲ᩠ᨲᨠᩴ;
ᨧᨶ᩠ᨴᨶᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨣᨶ᩠ᨵ, ᩈᩣᩁᩮᩣ ᨾᩃᨿᨩᩮᩣ ᨸ᩠ᨿᨳ.
ᨣᩮᩣᩈᩦᩈᩴ ᨲᩮᩃᨸᨱ᩠ᨱᩥᨠᩴ, ᨸᩩᨾᩮ ᩅᩣ ᩉᩁᩥᨧᨶ᩠ᨴᨶᩴ;
ᨲᩥᩃᨸᨱ᩠ᨱᩦ ᨲᩩ ᨸᨲ᩠ᨲᨦ᩠ᨣ, ᩁᨬ᩠ᨩᨶᩴ ᩁᨲ᩠ᨲᨧᨶ᩠ᨴᨶᩴ.
ᨠᩣᩊᩣᨶᩩᩈᩣᩁᩦ ᨠᩣᩊᩥᨿᩴ, ᩃᩮᩣᩉᩴ ᨲ᩠ᩅᩣ’ᨣᩁᩩ ᨧᩣ’ᨣᩊᩩ;
ᨠᩣᩊᩣᨣᩁᩩᨲᩩ ᨠᩣᩊᩮ’ᩈ᩠ᨾᩥᩴ, ᨲᩩᩁᩩᨠ᩠ᨡᩮᩣᨲᩩ ᨧ ᨸᩥᨱ᩠ᨯᨠᩮᩣ.
ᨠᨲ᩠ᨳᩪᩁᩥᨠᩣ ᨾᩥᨣᨾᨴᩮᩣ, ᨠᩩᨭ᩠ᨮᩴ ᨲᩩ ᩋᨩᨸᩣᩃᨠᩴ;
ᩃᩅᨦ᩠ᨣᩴ ᨴᩮᩅᨠᩩᩈᩩᨾᩴ, ᨠᩈ᩠ᨾᩦᩁᨩᩴ ᨲᩩ ᨠᩩᨦ᩠ᨠᩩᨾᩴ.
ᨿᨠ᩠ᨡᨵᩪᨸᩮᩣ ᩈᨩ᩠ᨩᩩᩃᩈᩮᩣ, ᨲᨠ᩠ᨠᩮᩣᩃᩴ ᨲᩩ ᨧ ᨠᩮᩣᩃᨠᩴ;
ᨠᩮᩣᩈᨹᩃ ᨾᨳᩮᩣ ᨩᩣᨲᩥ, ᨠᩮᩣᩈᩴ ᨩᩣᨲᩥᨹᩃᩴ ᨽᩅᩮ.
ᨥᨶᩈᩣᩁᩮᩣ ᩈᩥᨲᨻ᩠ᨽᩮᩣ ᨧ, ᨠᨸ᩠ᨸᩪᩁᩴ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ;
ᩋᩃᨲ᩠ᨲᨠᩮᩣ ᨿᩣᩅᨠᩮᩣ ᨧ, ᩃᩣᨡᩣ ᨩᨲᩩ ᨶᨸᩩᩴᩈᨠᩮ.
ᩈᩥᩁᩥᩅᩣᩈᩮᩣ ᨲᩩ ᩈᩁᩃ, ᨴ᩠ᨴᩅᩮᩣ’ ᨬ᩠ᨩᨶᩴ ᨲᩩ ᨠᨩ᩠ᨩᩃᩴ;
ᩅᩣᩈᨧᩩᨱ᩠ᨱᩴ ᩅᩣᩈᨿᩮᩣᨣᩮᩣ, ᩅᨱ᩠ᨱᨠᩴ ᨲᩩ ᩅᩥᩃᩮᨸᨶᩴ.
ᨣᨶ᩠ᨵᨾᩣᩃ᩠ᨿᩣᨴᩥᩈᨦ᩠ᨡᩣᩁᩮᩣ, ᨿᩮᩣ ᨲᩴ ᩅᩣᩈᨶ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨾᩣᩃᩣ ᨾᩣᩃ᩠ᨿᩴ ᨸᩩᨸ᩠ᨹᨴᩣᨾᩮ [ᨸᩩᨸ᩠ᨹᩴ ᨴᩣᨾᩴ (ᨠ.)], ᨽᩣᩅᩥᨲᩴ ᩅᩣᩈᩥᨲᩴ ᨲᩥᩈᩩ.
ᩏᨲ᩠ᨲᩴᩈᩮᩣ ᩈᩮᨡᩁᩣ’ ᩅᩮᩊᩣ, ᨾᩩᨴ᩠ᨵᨾᩣᩃ᩠ᨿᩮ ᩅᨭᩴᩈᨠᩮᩣ;
ᩈᩮᨿ᩠ᨿᩣ ᨧ ᩈᨿᨶᩴ ᩈᩮᨶᩴ, ᨸᩃ᩠ᩃᨦ᩠ᨠᩮᩣ ᨲᩩ ᨧ ᨾᨬ᩠ᨧᨠᩮᩣ.
ᨾᨬ᩠ᨧᩣᨵᩣᩁᩮᩣ ᨸᨭᩥᨸᩣᨴᩮᩣ, ᨾᨬ᩠ᨧᨦ᩠ᨣᩮ ᨲ᩠ᩅᨭᨶᩦ ᨲ᩠ᨳᩥᨿᩴ,
ᨠᩩᩊᩦᩁᨸᩣᨴᩮᩣ ᩌᩉᨧ᩠ᨧ, ᨸᩣᨴᩮᩣ ᨧᩮᩅ ᨾᩈᩣᩁᨠᩮᩣ;
ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᨻᩩᨶ᩠ᨴᩥᨠᩣᨻᨴ᩠ᨵᩮᩣ, ᨲᩥᨾᩮ ᨾᨬ᩠ᨧᨶ᩠ᨲᩁᩣ ᩈᩥᨿᩩᩴ.
ᨻᩥᨻ᩠ᨻᩮᩣᩉᨶᩴ ᨧᩮᩣ’ ᨸᨵᩣᨶᩴ, ᨸᩦᨮᩥᨠᩣ ᨸᩦᨮ ᨾᩣᩈᨶᩴ;
ᨠᩮᩣᨧ᩠ᨨᩴ ᨲᩩ ᨽᨴ᩠ᨴᨸᩦᨮᩮ ᨳᩣ, ᩈᨶ᩠ᨴᩦ ᨸᩦᨮᨶ᩠ᨲᩁᩮ ᨾᨲᩣ.
ᨾᩉᨶ᩠ᨲᩮᩣ ¶ ᨠᩮᩣᨩᩅᩮᩣ ᨴᩦᨥ,
ᩃᩮᩣᨾᨠᩮᩣ ᨣᩮᩣᨶᨠᩮᩣ ᨾᨲᩮᩣ;
ᩏᨱ᩠ᨱᩣᨾᨿᩴ ᨲ᩠ᩅᨲ᩠ᨳᩁᨱᩴ, ᨧᩥᨲ᩠ᨲᨠᩴ ᩅᩣᨶᨧᩥᨲ᩠ᨲᨠᩴ.
ᨥᨶᨸᩩᨸ᩠ᨹᩴ ᨸᨭᩃᩥᨠᩣ, ᩈᩮᨲᩴ ᨲᩩ ᨸᨭᩥᨠᩣ ᨸ᩠ᨿᨳ;
ᨴ᩠ᩅᩥᨴᩈᩮᨠᨴᩈᩣᨶ᩠ᨿᩩ’ ᨴ᩠ᨴ,ᩃᩮᩣᨾᩥ ᩑᨠᨶ᩠ᨲᩃᩮᩣᨾᩥᨶᩮᩣ.
ᨲᨴᩮᩅ ᩈᩮᩣᩊᩈᩥᨲ᩠ᨳᩦᨶᩴ, ᨶᨧ᩠ᨧᨿᩮᩣᨣ᩠ᨣᨬ᩠ᩉᩥ ᨠᩩᨲ᩠ᨲᨠᩴ;
ᩈᩦᩉᨻ᩠ᨿᨣ᩠ᨥᩣᨴᩥᩁᩪᨸᩮᩉᩥ, ᨧᩥᨲ᩠ᨲᩴ ᩅᩥᨠᨲᩥᨠᩣ ᨽᩅᩮ.
ᨠᨭ᩠ᨭᩥᩔᩴ ᨠᩮᩣᩈᩮᨿ᩠ᨿᩴ ᩁᨲᨶ, ᨸᩁᩥᩈᩥᨻ᩠ᨻᩥᨲ ᨾᨲ᩠ᨳᩁᨱᩴ ᨠᨾᩣ;
ᨠᩮᩣᩈᩥᨿᨠᨭ᩠ᨭᩥᩔᨾᨿᩴ, ᨠᩮᩣᩈᩥᨿᩈᩩᨲ᩠ᨲᩮᨶ ᨸᨠᨲᨬ᩠ᨧ.
ᨴᩦᨸᩮᩣ ᨸᨴᩦᨸᩮᩣ ᨸᨩ᩠ᨩᩮᩣᨲᩮᩣ, ᨸᩩᨾᩮ ᨲ᩠ᩅᩣᨴᩣᩈ ᨴᨸ᩠ᨸᨱᩣ;
ᨣᩮᨱ᩠ᨯᩩᨠᩮᩣ ᨠᨱ᩠ᨯᩩᨠᩮᩣ ᨲᩣᩃ, ᩅᨱ᩠ᨭᩴ ᨲᩩ ᨻᩦᨩᨶᩦᨲ᩠ᨳᩥᨿᩴ.
ᨧᨦ᩠ᨠᩮᩣᨭᨠᩮᩣ ᨠᩁᨱ᩠ᨯᩮᩣ ᨧ, ᩈᨾᩩᨣ᩠ᨣᩮᩣ ᩈᨾ᩠ᨸᩩᨭᩮᩣ ᨽᩅᩮ;
ᨣᩣᨾᨵᨾ᩠ᨾᩮᩣ ᩋᩈᨴ᩠ᨵᨾ᩠ᨾᩮᩣ, ᨻ᩠ᨿᩅᩣᨿᩮᩣ ᨾᩮᨳᩩᨶᩴ ᩁᨲᩥ.
ᩅᩥᩅᩣᩉᩮᩣ ᨸᨿᨾᩣ ᨸᩣᨱᩥ, ᨣ᩠ᨣᩉᩮᩣ ᨸᩁᩥᨱᨿᩮᩣ ᨸ᩠ᨿᨳ;
ᨲᩥᩅᨣ᩠ᨣᩮᩣ ᨵᨾ᩠ᨾ, ᨠᩣᨾ,ᨲ᩠ᨳᩣ, ᨧᨲᩩᩅᨣ᩠ᨣᩮᩣ ᩈᨾᩮᩣᨠ᩠ᨡᨠᩣ.
ᨡᩩᨩ᩠ᨩᩮᩣ ᨧ ᨣᨱ᩠ᨯᩩᩃᩮᩣ ᩁᩔ, ᩅᩣᨾᨶᩣ ᨲᩩ ᩃᨠᩩᨱ᩠ᨯᨠᩮᩣ;
ᨸᨦ᩠ᨣᩩᩃᩮᩣ ᨸᩦᨮᩈᨸ᩠ᨸᩦ ᨧ, ᨸᨦ᩠ᨣᩩ ᨨᩥᨶ᩠ᨶᩥᩁᩥᨿᩣᨸᨳᩮᩣ.
ᨸᨠ᩠ᨡᩮᩣ ᨡᨬ᩠ᨩᩮᩣ ᨲᩩ ᨡᩮᩣᨱ᩠ᨯᩮᩣ ᨳ,
ᨾᩪᨣᩮᩣ ᩈᩩᨬ᩠ᨬᩅᨧᩮᩣ ᨽᩅᩮ;
ᨠᩩᨱᩦ ᩉᨲ᩠ᨳᩣᨴᩥᩅᨦ᩠ᨠᩮᩣ ᨧ, ᩅᩃᩥᩁᩮᩣ ᨲᩩ ᨧ ᨠᩮᨠᩁᩮᩣ.
ᨶᩥᨠ᩠ᨠᩮᩈᩈᩦᩈᩮᩣ ᨡᩃ᩠ᩃᩣᨭᩮᩣ,
ᨾᩩᨱ᩠ᨯᩮᩣ ᨲᩩ ᨽᨱ᩠ᨯᩩ ᨾᩩᨱ᩠ᨯᩥᨠᩮᩣ;
ᨠᩣᨱᩮᩣ ᩋᨠ᩠ᨡᩦᨶ ᨾᩮᨠᩮᨶ,
ᩈᩩᨬ᩠ᨬᩮᩣ ᩋᨶ᩠ᨵᩮᩣ ᨴ᩠ᩅᨿᩮᨶ ᨳ.
ᨻᨵᩥᩁᩮᩣ ᩈᩩᨲᩥᩉᩦᨶᩮᩣ ᨳ, ᨣᩥᩃᩣᨶᩮᩣ ᨻ᩠ᨿᩣᨵᩥᨲᩣ’ᨲᩩᩁᩣ;
ᩏᨾ᩠ᨾᩣᨴᩅᨲᩥ ᩏᨾ᩠ᨾᨲ᩠ᨲᩮᩣ, ᨡᩩᨩ᩠ᨩᩣᨴᩦ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩣ.
ᩌᨲᨦ᩠ᨠᩮᩣ ᩌᨾᨿᩮᩣ ᨻ᩠ᨿᩣᨵᩥ, ᨣᨴᩮᩣ ᩁᩮᩣᨣᩮᩣ ᩁᩩᨩᩣᨸᩥ ᨧ;
ᨣᩮᩃᨬ᩠ᨬᩣᨠᩃ᩠ᩃ ᨾᩣᨻᩣᨵᩮᩣ,
ᩈᩮᩣᩈᩮᩣ ᨲᩩ ᨧ ᨡᨿᩮᩣ ᩈᩥᨿᩣ.
ᨸᩦᨶᩈᩮᩣ [ᨸᩦᨶᩣᩈᩮᩣᨲᩥᨸᩥ ᨸᩣᨮᩮᩣ] ¶ ᨶᩣᩈᩥᨠᩣᩁᩮᩣᨣᩮᩣ,
ᨥᩣᨶᩮ ᩈᩥᨦ᩠ᨥᩣᨶᩥᨠᩣ ᩔᩅᩮᩣ;
ᨬᩮᨿ᩠ᨿᩴ ᨲ᩠ᩅ’ᩁᩩ ᩅᨱᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨹᩮᩣᨭᩮᩣ ᨲᩩ ᨸᩥᩊᨠᩣ ᨽᩅᩮ.
ᨸᩩᨻ᩠ᨻᩮᩣ ᨸᩪᨿᩮᩣ ᨳ ᩁᨲ᩠ᨲᩣᨲᩥ, ᩈᩣᩁᩮᩣ ᨸᨠ᩠ᨡᨶ᩠ᨴᩥᨠᩣ ᨸ᩠ᨿᨳ;
ᩋᨸᨾᩣᩁᩮᩣ ᩋᨸᩈ᩠ᨾᩣᩁᩮᩣ, ᨸᩣᨴᨹᩮᩣᨭᩮᩣ ᩅᩥᨸᩣᨴᩥᨠᩣ.
ᩅᩩᨯ᩠ᨰᩥᩁᩮᩣᨣᩮᩣ ᨲᩩ ᩅᩣᨲᨱ᩠ᨯᩴ, ᩈᩦᨸᨴᩴ ᨽᩣᩁᨸᩣᨴᨲᩣ;
ᨠᨱ᩠ᨯᩪ ᨠᨱ᩠ᨯᩪᨲᩥ ᨠᨱ᩠ᨯᩪᨿᩣ, ᨡᨩ᩠ᨩᩩ ᨠᨱ᩠ᨯᩪᩅᨶᩴ ᨸ᩠ᨿᨳ.
ᨸᩣᨾᩴ ᩅᩥᨲᨧ᩠ᨨᩥᨠᩣ ᨠᨧ᩠ᨨᩩ, ᩈᩮᩣᨳᩮᩣ ᨲᩩ ᩈᨿᨳᩪ’ᨴᩥᨲᩮᩣ;
ᨴᩩᨶ᩠ᨶᩣᨾᨠᨬ᩠ᨧ ᩋᩁᩥᩈᩴ, ᨨᨴ᩠ᨴᩥᨠᩣ ᩅᨾᨳᩪ’ᨴᩥᨲᩮᩣ.
ᨴᩅᨳᩩ ᨸᩁᩥᨲᩣᨸᩮᩣ ᨳ, ᨲᩥᩃᨠᩮᩣ ᨲᩥᩃᨠᩣᩊᨠᩮᩣ;
ᩅᩥᩈᩪᨧᩥᨠᩣ ᩍᨲᩥ ᨾᩉᩣ, ᩅᩥᩁᩮᨠᩮᩣ ᨳ ᨽᨣᨶ᩠ᨴᩃᩮᩣ [ᨽᨣᨶ᩠ᨴᩁᩮᩣ (ᨠ.)].
ᨾᩮᩉᩮᩣ ᨩᩁᩮᩣ ᨠᩣᩈ ᩈᩣᩈᩣ, ᨠᩩᨭ᩠ᨮᩴ ᩈᩪᩃᩣᨾᨿᨶ᩠ᨲᩁᩣ;
ᩅᩩᨲ᩠ᨲᩮᩣ ᩅᩮᨩ᩠ᨩᩮᩣ ᨽᩥᩈᨠ᩠ᨠᩮᩣ ᨧ, ᩁᩮᩣᨣᩉᩣᩁᩦ ᨲᩥᨠᩥᨧ᩠ᨨᨠᩮᩣ.
ᩈᩃ᩠ᩃᩅᩮᨩ᩠ᨩᩮᩣ ᩈᩃ᩠ᩃᨠᨲ᩠ᨲᩮᩣ, ᨲᩥᨠᩥᨧ᩠ᨨᩣ ᨲᩩ ᨸᨲᩥᨠᩕᩥᨿᩣ;
ᨽᩮᩈᨩ᩠ᨩ ᨾᨣᨴᩮᩣ ᨧᩮᩅ, ᨽᩮᩈᨩᩴ ᨾᩮᩣ’ᩈᨵᩴ ᨸ᩠ᨿᨳ.
ᨠᩩᩈᩃᩣ ᨶᩣᨾᨿᩣ ᩁᩮᩣᨣ᩠ᨿᩴ,
ᩋᨳ ᨠᩃ᩠ᩃᩮᩣ ᨶᩥᩁᩣᨾᨿᩮᩣᨲᩥ,
ᨶᩁᩅᨣ᩠ᨣᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.
᪔. ᨧᨲᩩᨻ᩠ᨻᨱ᩠ᨱᩅᨣ᩠ᨣ
ᨡᨲ᩠ᨲᩥᨿᩅᨣ᩠ᨣ
ᨠᩩᩃᩴ ᩅᩴᩈᩮᩣ ᨧ ᩈᨶ᩠ᨲᩣᨶᩣ, ᨽᩥᨩᨶᩣ ᨣᩮᩣᨲ᩠ᨲ ᨾᨶ᩠ᩅᨿᩮᩣ;
ᨳᩥᨿᩴ ᩈᨶ᩠ᨲᨲ᩠ᨿ ᨳᩮᩣ ᩅᨱ᩠ᨱᩣ, ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᨡᨲ᩠ᨲᩥᨿᩣᨴᨿᩮᩣ.
ᨠᩩᩃᩦᨶᩮᩣ ᩈᨩ᩠ᨩᨶᩮᩣ ᩈᩣᨵᩩ,
ᩈᨽ᩠ᨿᩮᩣ ᨧᩣᨿ᩠ᨿᩮᩣ ᨾᩉᩣᨠᩩᩃᩮᩣ;
ᩁᩣᨩᩣ ᨽᩪᨸᨲᩥ ᨽᩪᨸᩣᩃᩮᩣ, ᨸᨲ᩠ᨳᩥᩅᩮᩣ ᨧ ᨶᩁᩣᨵᩥᨸᩮᩣ.
ᨽᩪᨶᩣᨳᩮᩣ ¶ ᨩᨣᨲᩥᨸᩣᩃᩮᩣ, ᨴᩥᩈᨾ᩠ᨸᨲᩥ ᨩᨶᩣᨵᩥᨸᩮᩣ;
ᩁᨭ᩠ᨮᩣᨵᩥᨸᩮᩣ ᨶᩁᨴᩮᩅᩮᩣ, ᨽᩪᨾᩥᨸᩮᩣ ᨽᩪᨽᩩᨩᩮᩣ ᨸ᩠ᨿᨳ.
ᩁᩣᨩᨬ᩠ᨬᩮᩣ ᨡᨲ᩠ᨲᩥᨿᩮᩣ ᨡᨲ᩠ᨲᩴ, ᨾᩩᨴ᩠ᨵᩣᨽᩥᩈᩥᨲ᩠ᨲ ᨻᩣᩉᩩᨩᩣ;
ᩈᨻ᩠ᨻᨽᩩᨾ᩠ᨾᩮᩣ ᨧᨠ᩠ᨠᩅᨲ᩠ᨲᩦ, ᨽᩪᨸᩮᩣᨬ᩠ᨬᩮᩣ ᨾᨱ᩠ᨯᩃᩥᩔᩁᩮᩣ.
ᨸᩩᨾᩮ ᩃᩥᨧ᩠ᨨᩅᩥ ᩅᨩ᩠ᨩᩦ ᨧ, ᩈᨠ᩠ᨿᩮᩣ ᨲᩩ ᩈᩣᨠᩥᨿᩮᩣ ᨳ ᨧ;
ᨽᨴ᩠ᨴᨠᨧ᩠ᨧᩣᨶᩣ [ᨽᨴ᩠ᨴᩣ ᨠᨧ᩠ᨧᩣᨶᩣ (ᨭᩦ.)] ᩁᩣᩉᩩᩃ, ᨾᩣᨲᩣ ᨻᩥᨾ᩠ᨻᩣ ᨿᩈᩮᩣᨵᩁᩣ.
ᨠᩮᩣᨭᩦᨶᩴ ᩉᩮᨭ᩠ᨮᩥᨾᨶ᩠ᨲᩮᨶ, ᩈᨲᩴ ᨿᩮᩈᩴ ᨶᩥᨵᩣᨶᨣᩴ;
ᨠᩉᩣᨸᨱᩣᨶᩴ ᨴᩥᩅᩈ, ᩅᩊᨬ᩠ᨩᩮᩣ ᩅᩦᩈᨲᨾ᩠ᨻᨱᩴ.
ᨲᩮ ᨡᨲ᩠ᨲᩥᨿᨾᩉᩣᩈᩣᩃᩣ, ᩈᩦᨲᩥ ᨠᩮᩣᨭᩥᨵᨶᩣᨶᩥ ᨲᩩ;
ᨶᩥᨵᩣᨶᨣᩣᨶᩥ ᨴᩥᩅᩈ, ᩅᩊᨬ᩠ᨩᩮᩣ ᨧ ᨴᩈᨾ᩠ᨻᨱᩴ.
ᨿᩮᩈᩴ ᨴ᩠ᩅᩥᨩᨾᩉᩣᩈᩣᩃᩣ, ᨲᨴᩩᨸᨯ᩠ᨰᩮ ᨶᩥᨵᩣᨶᨣᩮ;
ᩅᩊᨬ᩠ᨩᩮ ᨧ ᨣᩉᨸᨲᩥ, ᨾᩉᩣᩈᩣᩃᩣ ᨵᨶᩮ ᩈᩥᨿᩩᩴ.
ᨾᩉᩣᨾᨲ᩠ᨲᩮᩣ ᨸᨵᩣᨶᨬ᩠ᨧ, ᨾᨲᩥᩈᨩᩦᩅᩮᩣ ᨾᨶ᩠ᨲᩥᨶᩦ;
ᩈᨩᩦᩅᩮᩣ ᩈᨧᩥᩅᩣ, ᨾᨧ᩠ᨧᩮᩣ, ᩈᩮᨶᩣᨶᩦ ᨲᩩ ᨧᨾᩪᨸᨲᩥ.
ᨶ᩠ᨿᩣᩈᩣᨴᩦᨶᩴ ᩅᩥᩅᩣᨴᩣᨶᩴ, ᩋᨠ᩠ᨡᨴᩔᩮᩣ ᨸᨴᨭ᩠ᨮᩁᩥ;
ᨴᩮᩣᩅᩣᩁᩥᨠᩮᩣ ᨸᨲᩦᩉᩣᩁᩮᩣ, ᨴ᩠ᩅᩣᩁᨭ᩠ᨮᩮᩣ ᨴ᩠ᩅᩣᩁᨸᩣᩃᨠᩮᩣ.
ᩋᨶᩦᨠᨭ᩠ᨮᩮᩣᨲᩥ ᩁᩣᨩᩪᨶᩴ, ᩋᨦ᩠ᨣᩁᨠ᩠ᨡᨣᨱᩮᩣ ᨾᨲᩮᩣ;
ᨠᨬ᩠ᨧᩩᨠᩦ ᩈᩮᩣᩅᩥᨴᩃ᩠ᩃᩮᩣ ᨧ, ᩋᨶᩩᨩᩦᩅᩦ ᨲᩩ ᩈᩮᩅᨠᩮᩣ.
ᩋᨩ᩠ᨫᨠ᩠ᨡᩮᩣ ᨵᩥᨠᨲᩮᩣ ᨧᩮᩅ,
ᩉᩮᩁᨬ᩠ᨬᩥᨠᩮᩣ ᨲᩩ ᨶᩥᨠ᩠ᨡᩥᨠᩮᩣ;
ᩈᨴᩮᩈᩣᨶᨶ᩠ᨲᩁᩮᩣ ᩈᨲ᩠ᨲᩩ, ᨾᩥᨲ᩠ᨲᩮᩣᩁᩣᨩᩣ ᨲᨲᩮᩣ ᨸᩁᩴ.
ᩋᨾᩥᨲ᩠ᨲᩮᩣ ᩁᩥᨸᩩ ᩅᩮᩁᩦ ᨧ, ᩈᨸᨲ᩠ᨲᩣ ᩁᩣᨲᩥ ᩈᨲ᩠ᩅ’ᩁᩥ; (ᩈᨲ᩠ᨲᩩ+ᩋᩁᩥ)
ᨸᨧ᩠ᨧᨲ᩠ᨳᩥᨠᩮᩣ ᨸᩁᩥᨸᨶ᩠ᨳᩦ, ᨸᨭᩥᨸᨠ᩠ᨡᩣ ᩉᩥᨲᩣᨸᩁᩮᩣ.
ᨸᨧ᩠ᨧᩣᨾᩥᨲ᩠ᨲᩮᩣ ᩅᩥᨸᨠ᩠ᨡᩮᩣ ᨧ, ᨸᨧ᩠ᨧᨶᩦᨠ ᩅᩥᩁᩮᩣᨵᩥᨶᩮᩣ;
ᩅᩥᨴ᩠ᨴᩮᩈᩦ ᨧ ᨴᩥᩈᩮᩣ ᨴᩥᨭ᩠ᨮᩮᩣ,ᨳᩣ ᨶᩩᩁᩮᩣᨵᩮᩣ ᨶᩩᩅᨲ᩠ᨲᨶᩴ.
ᨾᩥᨲ᩠ᨲᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩅᨿᩔᩮᩣ ᨧ, ᩈᩉᩣᨿᩮᩣ [ᩈᩩᩉᨩ᩠ᨩᩮᩣ (ᨭᩦ.)] ᩈᩩᩉᨴᩮᩣ ᩈᨡᩣ;
ᩈᨾ᩠ᨽᨲ᩠ᨲᩮᩣ ᨴᩊ᩠ᩉᨾᩥᨲ᩠ᨲᩮᩣ ᨳ, ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩮᩣ ᨴᩥᨭ᩠ᨮᨾᨲ᩠ᨲᨠᩮᩣ.
ᨧᩁᩮᩣ ᨧ ᨣᩩᩊ᩠ᩉᨸᩩᩁᩥᩈᩮᩣ, ᨸᨳᩣᩅᩦ ᨸᨳᩥᨠᩮᩣ’ᨴ᩠ᨵᨣᩪ;
ᨴᩪᨲᩮᩣ ᨲᩩ ᩈᨶ᩠ᨴᩮᩈᩉᩁᩮᩣ, ᨣᨱᨠᩮᩣ ᨲᩩ ᨾᩩᩉᩩᨲ᩠ᨲᩥᨠᩮᩣ.
ᩃᩮᨡᨠᩮᩣ ¶ ᩃᩥᨸᩥᨠᩣᩁᩮᩣ ᨧ, ᩅᨱ᩠ᨱᩮᩣ ᨲᩩ ᩋᨠ᩠ᨡᩁᩮᩣ ᨸ᩠ᨿᨳ;
ᨽᩮᨴᩮᩣ ᨴᨱ᩠ᨯᩮᩣ ᩈᩣᨾ ᨴᩣᨶᩣ, ᨶ᩠ᨿᩩᨸᩣᨿᩣ ᨧᨲᩩᩁᩮᩣ ᩍᨾᩮ.
ᩏᨸᨩᩣᨸᩮᩣᨲᩩ ᨽᩮᨴᩮᩣ ᨧ, ᨴᨱ᩠ᨯᩮᩣ ᨲᩩ ᩈᩣᩉᩈᩴ ᨴᨾᩮᩣ;
ᩈᩣᨾ᩠ᨿ’ ᨾᨧ᩠ᨧᩮᩣ ᩈᨡᩣ ᨠᩮᩣᩈᩮᩣ, ᨴᩩᨣ᩠ᨣᨬ᩠ᨧ ᩅᩥᨩᩥᨲᩴ ᨻᩃᩴ;
ᩁᨩ᩠ᨩᨦ᩠ᨣᩣᨶᩦᨲᩥ ᩈᨲ᩠ᨲᩮᨲᩮ, ᩈᩥᨿᩩᩴ ᨸᨠᨲᩥᨿᩮᩣ ᨸᩥᨧ.
ᨸᨽᩣᩅᩩ’ᩔᩣᩉ, ᨾᨶ᩠ᨲᩣᨶᩴ, ᩅᩈᩣ ᨲᩥᩔᩮᩣ ᩉᩥ ᩈᨲ᩠ᨲᩥᨿᩮᩣ;
ᨸᨽᩣᩅᩮᩣ ᨴᨱ᩠ᨯᨩᩮᩣ ᨲᩮᨩᩮᩣ,
ᨸᨲᩣᨸᩮᩣ ᨲᩩ ᨧ ᨠᩮᩣᩈᨩᩮᩣ.
ᨾᨶ᩠ᨲᩮᩣ ᨧ ᨾᨶ᩠ᨲᨶᩴ ᩈᩮᩣ ᨲᩩ, ᨧᨲᩩᨠ᩠ᨠᨱ᩠ᨱᩮᩣ ᨴ᩠ᩅᩥᨣᩮᩣᨧᩁᩮᩣ;
ᨲᩥᨣᩮᩣᨧᩁᩮᩣ ᨲᩩ ᨨᨠ᩠ᨠᨱ᩠ᨱᩮᩣ, ᩁᩉᩔᩴ ᨣᩩᨿ᩠ᩉ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᨲᩦᩈᩩ ᩅᩥᩅᩥᨲ᩠ᨲ ᩅᩥᨩᨶ, ᨨᨶ᩠ᨶᩣ, ᩁᩉᩮᩣ ᩁᩉᩮᩣ ᨻ᩠ᨿᨿᩴ;
ᩅᩥᩔᩣᩈᩮᩣ ᨲᩩ ᨧ ᩅᩥᩔᨾ᩠ᨽᩮᩣ,
ᨿᩩᨲ᩠ᨲᩴ ᨲ᩠ᩅᩮᩣ’ᨸᩣᨿᩥᨠᩴ ᨲᩥᩈᩩ.
ᩒᩅᩣᨴᩮᩣ ᨧᩣᨶᩩᩈᩥᨭ᩠ᨮᩥᨲ᩠ᨳᩦ, ᨸᩩᨾᩅᨩ᩠ᨩᩮ ᨶᩩᩈᩣᩈᨶᩴ;
ᩌᨱᩣ ᨧ ᩈᩣᩈᨶᩴ ᨬᩮᨿ᩠ᨿᩴ, ᩏᨴ᩠ᨴᩣᨶᩴ ᨲᩩ ᨧ ᨻᨶ᩠ᨵᨶᩴ.
ᩌᨣᩩ ᩅᩩᨲ᩠ᨲ [ᨾᨶ᩠ᨲᩩ (ᨠ.)] ᨾᨸᩁᩣᨵᩮᩣ, ᨠᩁᩮᩣ ᨲᩩ ᨻᩃᩥ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨸᩩᨱ᩠ᨱᨸᨲ᩠ᨲᩮᩣ ᨲᩩᨭ᩠ᨮᩥᨴᩣᨿᩮᩣ, ᩏᨸᨴᩣ ᨲᩩ ᨧ ᨸᩣᨽᨲᩴ.
ᨲᨳᩮᩣ’ᨸᩣᨿᨶ ᨾᩩᨠ᩠ᨠᩮᩣᨧᩮᩣ, ᨸᨱ᩠ᨱᩣᨠᩣᩁᩮᩣ ᨸᩉᩮᨱᨠᩴ;
ᩈᩩᨦ᩠ᨠᩴ ᨲ᩠ᩅᨶᩥᨲ᩠ᨳᩦ ᨣᩩᨾ᩠ᨻᩣᨴᩥ, ᨴᩮᨿ᩠ᨿᩮ ᨳᩣ’ᨿᩮᩣ ᨵᨶᩣᨣᨾᩮᩣ.
ᩌᨲᨸᨲ᩠ᨲᩴ ᨲᨳᩣ ᨨᨲ᩠ᨲᩴ, ᩁᨬ᩠ᨬᩴ ᨲᩩ ᩉᩮᨾᨾᩣᩈᨶᩴ;
ᩈᩦᩉᩣᩈᨶᩴ ᩋᨳᩮᩣ ᩅᩣᩊ, ᨻᩦᨩᨶᩦᨲ᩠ᨳᩦ ᨧ ᨧᩣᨾᩁᩴ.
ᨡᨣ᩠ᨣᩮᩣ ᨧ ᨨᨲ᩠ᨲ ᨾᩩᨱ᩠ᩉᩦᩈᩴ, ᨸᩣᨴᩩᨠᩣ ᩅᩣᩃᨻᩦᨩᨶᩦ;
ᩍᨾᩮ ᨠᨠᩩᨵᨽᨱ᩠ᨯᩣᨶᩥ, ᨽᩅᨶ᩠ᨲᩥ ᨸᨬ᩠ᨧ ᩁᩣᨩᩩᨶᩴ.
ᨽᨴ᩠ᨴᨠᩩᨾ᩠ᨽᩮᩣ ᨸᩩᨱ᩠ᨱᨠᩩᨾ᩠ᨽᩮᩣ, ᨽᩥᨦ᩠ᨠᩣᩁᩮᩣ ᨩᩃᨴᩣᨿᨠᩮᩣ;
ᩉᨲ᩠ᨳᩥ,ᩔ,ᩁᨳ,ᨸᨲ᩠ᨲᩦ ᨲᩩ, ᩈᩮᨶᩣ ᩉᩥ ᨧᨲᩩᩁᨦ᩠ᨣᩥᨶᩦ.
ᨠᩩᨬ᩠ᨩᩁᩮᩣ ᩅᩣᩁᨱᩮᩣ ᩉᨲ᩠ᨳᩦ, ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᨴ᩠ᩅᩥᩁᨴᩮᩣ ᨣᨩᩮᩣ;
ᨶᩣᨣᩮᩣ ᨴ᩠ᩅᩥᨸᩮᩣ ᩍᨽᩮᩣ ᨴᨶ᩠ᨲᩦ,
ᨿᩪᨳᨩᩮᨭ᩠ᨮᩮᩣ ᨲᩩ ᨿᩪᨳᨸᩮᩣ.
ᨠᩣᩊᩣᩅᨠ ¶ ᨣᨦ᩠ᨣᩮᨿ᩠ᨿᩣ, ᨸᨱ᩠ᨯᩁ ᨲᨾ᩠ᨻᩣ ᨧ ᨸᩥᨦ᩠ᨣᩃᩮᩣ ᨣᨶ᩠ᨵᩮᩣ;
ᨾᨦ᩠ᨣᩃ ᩉᩮᨾᩮᩣ’ᨸᩮᩣᩈᨳ,
ᨨᨴ᩠ᨴᨶ᩠ᨲᩣ ᨣᨩᨠᩩᩃᩣᨶᩥ ᩑᨲᩣᨶᩥ.
ᨠᩃᨽᩮᩣ ᨧᩮᩅ ᨽᩥᨦ᩠ᨠᩮᩣᨳ, ᨸᨽᩥᨶ᩠ᨶᩮᩣ ᨾᨲ᩠ᨲ ᨣᨩ᩠ᨩᩥᨲᩣ;
ᩉᨲ᩠ᨳᩥᨥᨭᩣ ᨲᩩ ᨣᨩᨲᩣ, ᩉᨲ᩠ᨳᩦᨶᩦ ᨲᩩ ᨠᩁᩮᨱᩩᨠᩣ.
ᨠᩩᨾ᩠ᨽᩮᩣ ᩉᨲ᩠ᨳᩥᩈᩥᩁᩮᩣᨸᩥᨱ᩠ᨯᩣ, ᨠᨱ᩠ᨱᨾᩪᩃᩴ ᨲᩩ ᨧᩪᩃᩥᨠᩣ;
ᩌᩈᨶᩴ ᨡᨶ᩠ᨵᨴᩮᩈᨾ᩠ᩉᩥ, ᨸᩩᨧ᩠ᨨᨾᩪᩃᩴ ᨲᩩ ᨾᩮᨧᨠᩮᩣ.
ᩌᩃᩣᨶ ᨾᩣᩊ᩠ᩉᨠᩮᩣ ᨳᨾ᩠ᨽᩮᩣ, ᨶᩥᨲ᩠ᨳᩦᨲᩩ ᨶᩥᨣᩊᩮᩣ’ᨶ᩠ᨴᩩᨠᩮᩣ;
ᩈᨦ᩠ᨡᩃᩴ ᨲᩦᩈ᩠ᩅᨳᩮᩣ ᨣᨱ᩠ᨯᩮᩣ,
ᨠᨭᩮᩣ ᨴᩣᨶᩴ ᨲᩩ ᩈᩮᩣ ᨾᨴᩮᩣ.
ᩈᩮᩣᨱ᩠ᨯᩮᩣ ᨲᩩ ᨴ᩠ᩅᩦᩈᩩ ᩉᨲ᩠ᨳᩮᩣ ᨳ,
ᨠᩁᨣ᩠ᨣᩴ ᨸᩮᩣᨠ᩠ᨡᩁᩴ ᨽᩅᩮ;
ᨾᨩ᩠ᨫᨾ᩠ᩉᩥ ᨻᨶ᩠ᨵᨶᩴ ᨠᨧ᩠ᨨᩣ, ᨠᨸ᩠ᨸᨶᩮᩣ ᨲᩩ ᨠᩩᨳᩣᨴᨿᩮᩣ.
ᩒᨸᩅᨿ᩠ᩉᩮᩣ ᩁᩣᨩᩅᨿ᩠ᩉᩮᩣ, ᩈᨩ᩠ᨩᩥᨲᩮᩣ ᨲᩩ ᨧ ᨠᨸ᩠ᨸᩥᨲᩮᩣ;
ᨲᩮᩣᨾᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨸᩣᨴᩮ, ᩈᩥᨿᩣ ᩅᩥᨩ᩠ᨫᨶᨠᨱ᩠ᨭᨠᩮᩣ.
ᨲᩩᨲ᩠ᨲᩴ ᨲᩩ ᨠᨱ᩠ᨱᨾᩪᩃᨾ᩠ᩉᩥ, ᨾᨲ᩠ᨳᨠᨾ᩠ᩉᩥ ᨲᩩ ᩋᨦ᩠ᨠᩩᩈᩮᩣ;
ᩉᨲ᩠ᨳᩣᩁᩮᩣᩉᩮᩣ ᩉᨲ᩠ᨳᩥᨾᩮᨱ᩠ᨯᩮᩣ,
ᩉᨲ᩠ᨳᩥᨸᩮᩣ ᩉᨲ᩠ᨳᩥᨣᩮᩣᨸᨠᩮᩣ.
ᨣᩣᨾᨱᩦᨿᩮᩣ ᨲᩩ ᨾᩣᨲᨦ᩠ᨣ, ᩉᨿᩣᨴ᩠ᨿᩣᨧᩁᩥᨿᩮᩣ ᨽᩅᩮ;
ᩉᨿᩮᩣ ᨲᩩᩁᨦ᩠ᨣᩮᩣ ᨲᩩᩁᨣᩮᩣ,
ᩅᩣᩉᩮᩣ ᩋᩔᩮᩣ ᨧ ᩈᩥᨶ᩠ᨵᩅᩮᩣ.
ᨽᩮᨴᩮᩣ ᩋᩔᨲᩁᩮᩣ ᨲᩔᩣ,
ᨩᩣᨶᩥᨿᩮᩣ ᨲᩩ ᨠᩩᩃᩦᨶᨠᩮᩣ;
ᩈᩩᨡᩅᩣᩉᩦ ᩅᩥᨶᩦᨲᩮᩣ ᨳ,
ᨠᩥᩈᩮᩣᩁᩮᩣ ᩉᨿᨸᩮᩣᨲᨠᩮᩣ.
ᨥᩮᩣᨭᨠᩮᩣ ᨲᩩ ᨡᩊᩩᨦ᩠ᨠᩮᩣ ᨳ, ᨩᩅᨶᩮᩣ ᨧ ᨩᩅᩣᨵᩥᨠᩮᩣ;
ᨾᩩᨡᩣᨵᩣᨶᩴ ᨡᩃᩦᨶᩮᩣ ᩅᩣ, ᨠᩈᩣ ᨲ᩠ᩅ ᩔᩣᨽᩥᨲᩣᩊᩥᨶᩦ.
ᨠᩩᩈᩣ ᨲᩩ ᨶᩣᩈᩁᨩ᩠ᨩᩩᨾ᩠ᩉᩥ, ᩅᩊᩅᩣ’ᩔᩣ ᨡᩩᩁᩮᩣ ᩈᨹᩴ;
ᨸᩩᨧ᩠ᨨ ᨾᨶᩥᨲ᩠ᨳᩦ ᨶᨦ᩠ᨣᩩᨭ᩠ᨮᩴ, ᩅᩣᩃᩉᨲ᩠ᨳᩮᩣ ᨧ ᩅᩣᩃᨵᩥ.
ᩈᨶ᩠ᨴᨶᩮᩣ ¶ ᨧ ᩁᨳᩮᩣ ᨹᩩᩔ, ᩁᨳᩮᩣ ᨲᩩ ᨶᩁᨱᩣᨿ ᩈᩮᩣ;
ᨧᨾ᩠ᨾᩣᩅᩩᨲᩮᩣ ᨧ ᩅᩮᨿᨣ᩠ᨥᩮᩣ,
ᨴᩮᨸ᩠ᨸᩮᩣ ᨻ᩠ᨿᨣ᩠ᨥᩔ ᨴᩦᨸᩥᨶᩮᩣ.
ᩈᩥᩅᩥᨠᩣ ᨿᩣᨸ᩠ᨿᨿᩣᨶᨬ᩠ᨧᩣ, ᨶᩥᨲ᩠ᨳᩦ ᨲᩩ ᩈᨠᨭᩮᩣ ᨸ᩠ᨿ’ᨶᩴ [(ᩈᨠᨭᩮᩣ ᨸᩥ+ᩋᨶᩴ)];
ᨧᨠ᩠ᨠᩴ ᩁᨳᨦ᩠ᨣ ᨾᩣᨡ᩠ᨿᩣᨲᩴ, ᨲᩔᨶ᩠ᨲᩮᩣ ᨶᩮᨾᩥ ᨶᩣᩁᩥᨿᩴ.
ᨲᨾ᩠ᨾᨩ᩠ᨫᩮ ᨸᩥᨱ᩠ᨯᩥᨠᩣ ᨶᩣᨽᩥ, ᨠᩩᨻ᩠ᨻᩁᩮᩣ ᨲᩩ ᨿᩩᨣᨶ᩠ᨵᩁᩮᩣ;
ᩋᨠ᩠ᨡᨣ᩠ᨣᨠᩦᩃᩮ ᩌᨱᩦᨲ᩠ᨳᩦ, ᩅᩁᩩᨳᩮᩣ ᩁᨳᨣᩩᨲ᩠ᨿ’ᨳ.
ᨵᩩᩁᩮᩣ ᨾᩩᨡᩮ ᩁᨳᩔᨦ᩠ᨣᩣ, ᨲ᩠ᩅ ᨠ᩠ᨡᩮᩣ ᨸᨠ᩠ᨡᩁᩌᨴᨿᩮᩣ;
ᨿᩣᨶᨬ᩠ᨧ ᩅᩣᩉᨶᩴ ᨿᩮᩣᨣ᩠ᨣᩴ, ᩈᨻ᩠ᨻᩉᨲ᩠ᨳ᩠ᨿᩣᨴᩥᩅᩣᩉᨶᩮ.
ᩁᨳᨧᩣᩁᩦ ᨲᩩ ᩈᩪᨲᩮᩣ ᨧ, ᨸᩣᨩᩥᨲᩣ ᨧᩮᩅ ᩈᩣᩁᨳᩦ;
ᩁᨳᩣᩁᩮᩣᩉᩮᩣ ᨧ ᩁᨳᩥᨠᩮᩣ,
ᩁᨳᩦ ᨿᩮᩣᨵᩮᩣ ᨲᩩ ᨿᩮᩣ ᨽᨭᩮᩣ.
ᨸᨴᩣᨲᩥ ᨸᨲ᩠ᨲᩦ ᨲᩩ ᨸᩩᨾᩮ, ᨸᨴᨣᩮᩣ ᨸᨴᩥᨠᩮᩣ ᨾᨲᩮᩣ;
ᩈᨶ᩠ᨶᩣᩉᩮᩣ ᨠᨦ᩠ᨠᨭᩮᩣ ᩅᨾ᩠ᨾᩴ, ᨠᩅᨧᩮᩣ ᩅᩣ ᩏᩁᨧ᩠ᨨᨴᩮᩣ.
ᨩᩣᩃᩥᨠᩣ ᨳ ᨧ ᩈᨶ᩠ᨶᨴ᩠ᨵᩮᩣ, ᩈᨩ᩠ᨩᩮᩣ ᨧ ᩅᨾ᩠ᨾᩥᨠᩮᩣ ᨽᩅᩮ;
ᩌᨾᩩᨠ᩠ᨠᩮᩣ ᨸᨭᩥᨾᩩᨠ᩠ᨠᩮᩣ ᨳ, ᨸᩩᩁᩮᨧᩣᩁᩦ ᨸᩩᩁᩮᨧᩁᩮᩣ.
ᨸᩩᨻ᩠ᨻᨦ᩠ᨣᨾᩮᩣ ᨸᩩᩁᩮᨣᩣᨾᩦ, ᨾᨶ᩠ᨴᨣᩣᨾᩦ ᨲᩩ ᨾᨶ᩠ᨳᩁᩮᩣ;
ᨩᩅᨶᩮᩣ ᨲᩩᩁᩥᨲᩮᩣ ᩅᩮᨣᩦ, ᨩᩮᨲᨻ᩠ᨻᩴ ᨩᩮᨿ᩠ᨿ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩈᩪᩁ ᩅᩦᩁᩣ ᨲᩩ ᩅᩥᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᩈᩉᩣᨿᩮᩣ ᨶᩩᨧᩁᩮᩣ ᩈᨾᩣ;
ᩈᨶ᩠ᨶᨴ᩠ᨵᨸ᩠ᨸᨽᩩᨲᩦ ᨲᩦᩈᩩ, ᨸᩣᨳᩮᨿ᩠ᨿᩴ ᨲᩩ ᨧ ᩈᨾ᩠ᨻᩃᩴ.
ᩅᩣᩉᩥᨶᩦ ᨵᨩᩥᨶᩦ ᩈᩮᨶᩣ, ᨧᨾᩪ ᨧᨠ᩠ᨠᩴ ᨻᩃᩴ ᨲᨳᩣ;
ᩋᨶᩦᨠᩮᩣ ᩅᩣ ᨳ ᩅᩥᨶ᩠ᨿᩣᩈᩮᩣ,
ᨻ᩠ᨿᩪᩉᩮᩣ ᩈᩮᨶᩣᨿ ᨠᨳ᩠ᨿᨲᩮ.
ᩉᨲ᩠ᨳᩦ ᨴ᩠ᩅᩣᨴᩈᨸᩮᩣᩈᩮᩣ,ᨲᩥ,
ᨸᩩᩁᩥᩈᩮᩣ ᨲᩩᩁᨣᩮᩣ, ᩁᨳᩮᩣ;
ᨧᨲᩩᨸᩮᩣᩈᩮᩣᨲᩥ ᩑᨲᩮᨶ, ᩃᨠ᩠ᨡᨱᩮᨶᩣ ᨵᨾᨶ᩠ᨲᨲᩮᩣ.
ᩉᨲ᩠ᨳᩣᨶᩦᨠᩴ ᩉᨿᩣᨶᩦᨠᩴ, ᩁᨳᩣᨶᩦᨠᩴ ᨲᨿᩮᩣ ᨲᨿᩮᩣ;
ᨣᨩᩣᨴᨿᩮᩣ ᩈᩈᨲ᩠ᨳᩣ ᨲᩩ, ᨸᨲ᩠ᨲᩣᨶᩦᨠᩴ ᨧᨲᩩᨩ᩠ᨩᨶᩣ.
ᩈᨭ᩠ᨮᩥᩅᩴᩈᨠᩃᩣᨸᩮᩈᩩ, ¶ ᨸᨧ᩠ᨧᩮᨠᩴ ᩈᨭ᩠ᨮᩥᨴᨱ᩠ᨯᩥᩈᩩ;
ᨵᩪᩃᩦᨠᨲᩮᩈᩩ ᩈᩮᨶᩣᨿ, ᨿᨶ᩠ᨲᩥᨿᩣ ᨠ᩠ᨡᩮᩣᨽᨶᩦ [ᩋᨠ᩠ᨡᩮᩣᨽᩥᨱᩦ (ᨠ.)] ᨲ᩠ᨳᩥᨿᩴ.
ᩈᨾ᩠ᨸᨲ᩠ᨲᩥ ᩈᨾ᩠ᨸᨴᩣ ᩃᨠ᩠ᨡᩦ, ᩈᩥᩁᩦ ᩅᩥᨸᨲ᩠ᨲᩥ ᩌᨸᨴᩣ;
ᩋᨳᩣ ᩅᩩᨵᨬ᩠ᨧ [ᩌᨿᩩᨵᨶ᩠ᨲᩥᨸᩥ ᨸᩣᨮᩮᩣ] ᩉᩮᨲᩥ’ᨲ᩠ᨳᩦ, ᩈᨲ᩠ᨳᩴ ᨸᩉᩁᨱᩴ ᨽᩅᩮ.
ᨾᩩᨲ᩠ᨲᩣᨾᩩᨲ᩠ᨲ ᨾᨾᩩᨲ᩠ᨲᨬ᩠ᨧ, ᨸᩣᨱᩥᨲᩮᩣ ᨾᩩᨲ᩠ᨲᨾᩮᩅ ᨧ;
ᨿᨶ᩠ᨲᨾᩩᨲ᩠ᨲᨶ᩠ᨲᩥ ᩈᨠᩃᩴ, ᩌᨿᩩᨵᩴ ᨲᩴ ᨧᨲᩩᨻ᩠ᨻᩥᨵᩴ.
ᨾᩩᨲ᩠ᨲᩣᨾᩩᨲ᩠ᨲᨬ᩠ᨧ ᨿᨭ᩠ᨮ᩠ᨿᩣᨴᩥ, ᩋᨾᩩᨲ᩠ᨲᩴ ᨨᩩᩁᩥᨠᩣᨴᩥᨠᩴ;
ᨸᩣᨱᩥᨾᩩᨲ᩠ᨲᩴ ᨲᩩ ᩈᨲ᩠ᨿᩣᨴᩥ, ᨿᨶ᩠ᨲᨾᩩᨲ᩠ᨲᩴ ᩈᩁᩣᨴᩥᨠᩴ.
ᩍᩔᩣᩈᩮᩣ ᨵᨶᩩ ᨠᩮᩣᨴᨱ᩠ᨯᩴ, ᨧᩣᨸᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᩁᩣᩈᨶᩴ;
ᩋᨳᩮᩣ ᨣᩩᨱᩮᩣ ᨩᩥᨿᩣ ᨩ᩠ᨿᩣ ᨳ,
ᩈᩁᩮᩣ ᨸᨲ᩠ᨲᩥ ᨧ ᩈᩣᨿᨠᩮᩣ.
ᩅᩣᨱᩮᩣ ᨠᨱ᩠ᨯ ᨾᩩᩈᩩ ᨴ᩠ᩅᩦᩈᩩ, ᨡᩩᩁᨸ᩠ᨸᩮᩣ [ᩏᩁᨸ᩠ᨸᩮᩣ (ᨠ.)] ᨲᩮᨩᨶᩣ’ᩈᨶᩴ;
ᨲᩪᨱᩦᨲ᩠ᨳᩥᨿᩴ ᨠᩃᩣᨸᩮᩣ ᨧ, ᨲᩪᨱᩮᩣ ᨲᩪᨱᩦᩁ ᩅᩣᨱᨵᩥ.
ᨸᨠ᩠ᨡᩮᩣ ᨲᩩ ᩅᩣᨩᩮᩣ ᨴᩥᨴ᩠ᨵᩮᩣ ᨲᩩ, ᩅᩥᩈᨸ᩠ᨸᩥᨲᩮᩣ ᩈᩁᩮᩣ ᨽᩅᩮ;
ᩃᨠ᩠ᨡᩴ ᩅᩮᨩ᩠ᨫᩴ ᩈᩁᨻ᩠ᨿᨬ᩠ᨧ, ᩈᩁᩣᨽ᩠ᨿᩣᩈᩮᩣ ᨲᩩ’ᨸᩣᩈᨶᩴ.
ᨾᨱ᩠ᨯᩃᨣ᩠ᨣᩮᩣ ᨲᩩ ᨶᩮᨲ᩠ᨲᩥᩴᩈᩮᩣ, ᩋᩈᩥ ᨡᨣ᩠ᨣᩮᩣ ᨧ ᩈᩣᨿᨠᩮᩣ;
ᨠᩮᩣᩈᩥᨲ᩠ᨳᩦ ᨲᨻ᩠ᨻᩥᨵᩣᨶᩮ ᨳᩮᩣ, ᨳᩁᩩ ᨡᨣ᩠ᨣᩣᨴᩥᨾᩩᨭ᩠ᨮᩥᨿᩴ.
ᨡᩮᨭᨠᩴ ᨹᩃᨠᩴ ᨧᨾ᩠ᨾᩴ, ᩍᩃ᩠ᩃᩦ ᨲᩩ ᨠᩁᨸᩣᩃᩥᨠᩣ;
ᨨᩩᩁᩥᨠᩣ ᩈᨲ᩠ᨿ’ᩈᩥᨸᩩᨲ᩠ᨲᩦ, ᩃᨣᩩᩊᩮᩣ ᨲᩩ ᨧ ᨾᩩᨣ᩠ᨣᩁᩮᩣ.
ᩈᩃ᩠ᩃᩮᩣ ᨶᩥᨲ᩠ᨳᩥ ᩈᨦ᩠ᨠᩩ ᨸᩩᨾᩮ, ᩅᩣᩈᩦ ᨲᩩ ᨲᨧ᩠ᨨᨶᩦᨲ᩠ᨳᩥᨿᩴ;
ᨠᩩᨮᩣᩁᩦ [ᨠᩩᨵᩣᩁᩦ (ᨭᩦ.)] ᨲ᩠ᨳᩦᨹᩁᩈᩩᩈᩮᩣ, ᨭᨦ᩠ᨠᩮᩣ ᨸᩣᩈᩣᨱᨴᩣᩁᨱᩮᩣ.
ᨠᨱᨿᩮᩣ ᨽᩥᨶ᩠ᨴᩥᩅᩣᩊᩮᩣ ᨧ, ᨧᨠ᩠ᨠᩴ ᨠᩩᨶ᩠ᨲᩮᩣ ᨣᨴᩣ ᨲᨳᩣ;
ᩈᨲ᩠ᨿᩣ’ᨴᩦ ᩈᨲ᩠ᨳᨽᩮᨴᩣ ᨳ,
ᨠᩮᩣᨱᩮᩣ’ᩔᩮᩣ ᨠᩮᩣᨭᩥ ᨶᩣᩁᩥᨿᩴ.
ᨶᩥᨿ᩠ᨿᩣᨶᩴ ᨣᨾᨶᩴ ᨿᩣᨲᩕᩣ, ᨸᨭ᩠ᨮᩣᨶᨬ᩠ᨧ ᨣᨾᩮᩣ ᨣᨲᩥ;
ᨧᩩᨱ᩠ᨱᩮᩣ ᨸᩴᩈᩩ ᩁᨩᩮᩣ ᨧᩮᩅ, ᨵᩪᩃᩦ’ᨲ᩠ᨳᩦ ᩁᩮᨱᩩ ᨧ ᨴ᩠ᩅᩥᩈᩩ.
ᨾᩣᨣᨵᩮᩣ ¶ ᨾᨵᩩᨠᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩅᨶ᩠ᨴᩦ ᨲᩩ ᨳᩩᨲᩥᨸᩣᨮᨠᩮᩣ;
ᩅᩮᨲᩣᩊᩥᨠᩮᩣ ᨻᩮᩣᨵᨠᩁᩮᩣ,
ᨧᨠ᩠ᨠᩥᨠᩮᩣ ᨲᩩ ᨧ ᨥᨱ᩠ᨭᩥᨠᩮᩣ.
ᨠᩮᨲᩩ ᨵᨩᩮᩣ ᨸᨭᩣᨠᩣ ᨧ, ᨠᨴᩃᩦ ᨠᩮᨲᨶᩴ ᨸ᩠ᨿᨳ;
ᨿᩮᩣ’ᩉᩴᨠᩣᩁᩮᩣ’ᨬ᩠ᨬᨾᨬ᩠ᨬᩔ, ᩈᩣ’ ᩉᨾᩉᨾᩥᨠᩣ ᨽᩅᩮ.
ᨻᩃᩴ ᨳᩣᨾᩮᩣ ᩈᩉᩴ ᩈᨲ᩠ᨲᩥ, ᩅᩥᨠ᩠ᨠᨾᩮᩣ ᨲ᩠ᩅᨲᩥᩈᩪᩁᨲᩣ;
ᩁᨱᩮ ᨩᩥᨲᩔ ᨿᩴ ᨸᩣᨶᩴ, ᨩᨿᨸᩣᨶᨶ᩠ᨲᩥ ᨲᩴ ᨾᨲᩴ.
ᩈᨦ᩠ᨣᩣᨾᩮᩣ ᩈᨾ᩠ᨸᩉᩣᩁᩮᩣ ᨧᩣ, ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᩈᨾᩁᩴ ᩁᨱᩴ;
ᩌᨩᩥᨲ᩠ᨳᩦ ᩌᩉᩅᩮᩣ ᨿᩩᨴ᩠ᨵ, ᨾᩣᨿᩮᩣᨵᨶᨬ᩠ᨧ ᩈᩴᨿᩩᨣᩴ.
ᨽᨱ᩠ᨯᨶᩴ ᨲᩩ ᩅᩥᩅᩣᨴᩮᩣ ᨧ, ᩅᩥᨣ᩠ᨣᩉᩮᩣ ᨠᩃᩉ ᨾᩮᨵᨣᩣ;
ᨾᩩᨧ᩠ᨨᩣ ᨾᩮᩣᩉᩮᩣ ᨳ ᨸᩈᨿ᩠ᩉᩮᩣ,
ᨻᩃᨠ᩠ᨠᩣᩁᩮᩣ ᩉᨮᩮᩣ ᨽᩅᩮ.
ᩏᨸ᩠ᨸᩣᨴᩮᩣ [ᩏᨸ᩠ᨸᩣᨲᩮᩣ (ᨠ.)᪑᪐᪒᪗-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨽᩪᨲᩅᩥᨠᨲᩥ, ᨿᩣ ᩈᩩᨽᩣᩈᩩᨽᩈᩪᨧᩥᨠᩣ;
ᩎᨲᩥ ᨲ᩠ᩅᩥᨲ᩠ᨳᩦ ᩋᨩᨬ᩠ᨬᨬ᩠ᨧ, ᩏᨸᩈᨣ᩠ᨣᩮᩣ ᩏᨸᨴ᩠ᨴᩅᩮᩣ.
ᨶᩥᨻ᩠ᨻᩩᨴ᩠ᨵᩴ [ᨶᩥᨿᩩᨴ᩠ᨵᩴ (ᨠ.)] ᨾᩃ᩠ᩃᨿᩩᨴ᩠ᨵᨾ᩠ᩉᩥ, ᨩᨿᩮᩣ ᨲᩩ ᩅᩥᨩᨿᩮᩣ ᨽᩅᩮ;
ᨸᩁᩣᨩᨿᩮᩣ ᩁᨱᩮ ᨽᨦ᩠ᨣᩮᩣ, ᨸᩃᩣᨿᨶ ᨾᨸᨠ᩠ᨠᨾᩮᩣ.
ᨾᩣᩁᨱᩴ ᩉᨶᨶᩴ ᨥᩣᨲᩮᩣ, ᨶᩣᩈᨶᨬ᩠ᨧ ᨶᩥᩈᩪᨴᨶᩴ;
ᩉᩥᩴᩈᨶᩴ ᩈᩁᨱᩴ ᩉᩥᩴᩈᩣ, ᩅᨵᩮᩣ ᩈᩈᨶ ᨥᩣᨲᨶᩴ.
ᨾᩁᨱᩴ ᨠᩣᩃᨠᩥᩁᩥᨿᩣ, ᨸᩃᨿᩮᩣ ᨾᨧ᩠ᨧᩩ ᩋᨧ᩠ᨧᨿᩮᩣ;
ᨶᩥᨵᨶᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨶᩣᩈᩮᩣ, ᨠᩣᩃᩮᩣ’ᨶ᩠ᨲᩮᩣ ᨧᩅᨶᩴ ᨽᩅᩮ.
ᨲᩦᩈᩩ ᨸᩮᨲᩮᩣ ᨸᩁᩮᨲᩮᩣ ᨧ,
ᨾᨲᩮᩣ ᨳ ᨧᩥᨲᨠᩮᩣ ᨧᩥᨲᩮᩣ;
ᩌᩊᩉᨶᩴ ᩈᩩᩈᩣᨶᨬ᩠ᨧᩣ, ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨠᩩᨱᨸᩮᩣ ᨨᩅᩮᩣ.
ᨠᨻᨶ᩠ᨵᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨴᩮᩉᩮᩣ, ᩈᩥᩁᩮᩣᩈᩩᨬ᩠ᨬᩮᩣ ᩈᩉᨠᩕᩥᨿᩮᩣ;
ᩋᨳ ᩈᩥᩅᨳᩥᨠᩣ ᩅᩩᨲ᩠ᨲᩣ, ᩈᩩᩈᩣᨶᩈ᩠ᨾᩥᨬ᩠ᩉᩥ ᩌᨾᨠᩮ.
ᩅᨶ᩠ᨴᩦᨲ᩠ᨳᩥᨿᩴ ᨠᩁᨾᩁᩮᩣ, ᨸᩣᨱᩮᩣ ᨲ᩠ᩅ’ᩈᩩ ᨸᨠᩣᩈᩥᨲᩮᩣ;
ᨠᩣᩁᩣ ᨲᩩ ᨻᨶ᩠ᨵᨶᩣᨣᩣᩁᩴ, ᨠᩣᩁᨱᩣ ᨲᩩ ᨧ ᨿᩣᨲᨶᩣ.
ᩍᨲᩥ ᨡᨲ᩠ᨲᩥᨿᩅᨣ᩠ᨣᩮᩣ.
ᨻᩕᩉ᩠ᨾᨻᨶ᩠ᨵᩩ ¶ ᨴ᩠ᩅᩥᨩᩮᩣ ᩅᩥᨸ᩠ᨸᩮᩣ, ᨻᩕᩉ᩠ᨾᩣ ᨽᩮᩣᩅᩣᨴᩦ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩣ;
ᩈᩮᩣᨲ᩠ᨲᩥᨿᩮᩣ ᨨᨶ᩠ᨴᩈᩮᩣ ᩈᩮᩣ ᨳ,
ᩈᩥᩔ’ ᨶ᩠ᨲᩮᩅᩣᩈᩥᨶᩮᩣ ᨸᩩᨾᩮ.
ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ ᨣᩉᨭ᩠ᨮᩮᩣ ᨧ, ᩅᨶᨸ᩠ᨸᨲ᩠ᨳᩮᩣ ᨧ ᨽᩥᨠ᩠ᨡᩩᨲᩥ;
ᨽᩅᨶ᩠ᨲᩥ ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᩑᨲᩮ, ᩋᩔᨾᩣ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ.
ᨧᩁᨶ᩠ᨲᩣ ᩈᩉ ᩈᩦᩃᩣᨴᩦ, ᩈᨻᩕᩉ᩠ᨾᨧᩣᩁᩥᨶᩮᩣ ᨾᩥᨳᩩ;
ᩏᨸᨩ᩠ᨫᩣᨿᩮᩣ ᩏᨸᨩ᩠ᨫᩣ ᨳᩣ, ᨧᩁᩥᨿᩮᩣ ᨶᩥᩔᨿᨴᩣᨴᩥᨠᩮᩣ [ᨶᩥᩔᨿᨴᩣᨿᨠᩮᩣ (ᨭᩦ.)].
ᩏᨸᨶᩦᨿᩣ ᨳᩅᩣ ᨸᩩᨻ᩠ᨻᩴ, ᩅᩮᨴ ᨾᨩ᩠ᨫᩣᨸᨿᩮ ᨴ᩠ᩅᩥᨩᩮᩣ;
ᨿᩮᩣ ᩈᨦ᩠ᨣᩴ ᩈᩁᩉᩔᨬ᩠ᨧᩣ, ᨧᩁᩥᨿᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱᩮᩈᩩ ᩈᩮᩣ.
ᨸᩣᩁᨾ᩠ᨸᩁᩥᨿ ᨾᩮᨲᩥᩉ᩠ᨿᩴ, ᩏᨸᨴᩮᩈᩮᩣ ᨲᨳᩮ’ᨲᩥᩉᩣ;
ᨿᩣᨣᩮᩣ ᨲᩩ ᨠᨲᩩ ᨿᨬ᩠ᨬᩮᩣ ᨳ, ᩅᩮᨴᩦᨲ᩠ᨳᩦ ᨽᩪ ᨸᩁᩥᨠ᩠ᨡᨲᩣ.
ᩋᩔᨾᩮᨵᩮᩣ ᨧ ᨸᩩᩁᩥᩈ, ᨾᩮᨵᩮᩣ ᨧᩮᩅ ᨶᩥᩁᨣ᩠ᨣᩊᩮᩣ;
ᩈᨾ᩠ᨾᩣᨸᩣᩈᩮᩣ ᩅᩣᨩᨸᩮᨿ᩠ᨿ, ᨾᩥᨲᩥ ᨿᩣᨣᩣ ᨾᩉᩣ ᩍᨾᩮ.
ᩍᨲ᩠ᩅᩥᨩᩮᩣ [ᩍᨴᩥᨲ᩠ᩅᩥᨩᩮᩣ (ᨭᩦ.)] ᨿᩣᨩᨠᩮᩣ ᨧᩣᨳ,
ᩈᨽ᩠ᨿᩮᩣ ᩈᩣᨾᩣᨩᩥᨠᩮᩣ ᨸ᩠ᨿᨳ;
ᨸᩁᩥᩈᩣ ᩈᨽᩣ ᩈᨾᨩ᩠ᨩᩣ ᨧ, ᨲᨳᩣ ᩈᨾᩥᨲᩥ ᩈᩴᩈᨴᩮᩣ.
ᨧᨲᩔᩮᩣ ᨸᩁᩥᩈᩣ ᨽᩥᨠ᩠ᨡᩩ, ᨽᩥᨠ᩠ᨡᩩᨶᩦ ᨧ ᩏᨸᩣᩈᨠᩣ;
ᩏᨸᩣᩈᩥᨠᩣᨿᩮᩣᨲᩥ ᩍᨾᩣ, ᨳᩅᩣ ᨭ᩠ᨮ ᨸᩁᩥᩈᩣ ᩈᩥᨿᩩᩴ.
ᨲᩣᩅᨲᩥᩴᩈ,ᨴ᩠ᩅᩥᨩ,ᨠ᩠ᨡᨲ᩠ᨲ,ᨾᩣᩁ,ᨣ᩠ᨣᩉᨸᨲᩥᩔ ᨧ;
ᩈᨾᨱᩣᨶᩴ ᩅᩈᩣ ᨧᩣᨲᩩ, ᨾᩉᩣᩁᩣᨩᩥᨠ, ᨻᩕᩉ᩠ᨾᩩᨶᩴ.
ᨣᩣᨿᨲ᩠ᨲᩥᨸ᩠ᨸᨾᩩᨡᩴ ᨨᨶ᩠ᨴᩴ, ᨧᨲᩩᩅᩦᩈ’ᨠ᩠ᨡᩁᩴ ᨲᩩ ᨿᩴ;
ᩅᩮᨴᩣᨶ ᨾᩣᨴᩥᨽᩪᨲᩴ ᩈᩣ, ᩈᩣᩅᩥᨲ᩠ᨲᩦ ᨲᩥᨸᨴᩴ ᩈᩥᨿᩣ.
ᩉᨻ᩠ᨿᨸᩣᨠᩮ ᨧᩁᩩ ᨾᨲᩮᩣ, ᩈᩩᨩᩣ ᨲᩩ ᩉᩮᩣᨾᨴᨻ᩠ᨻᩥᨿᩴ;
ᨸᩁᨾᨶ᩠ᨶᩴ ᨲᩩ ᨸᩣᨿᩣᩈᩮᩣ, ᩉᨻ᩠ᨿᩴ ᨲᩩ ᩉᩅᩥ ᨠᨳ᩠ᨿᨲᩮ.
ᨿᩪᨸᩮᩣ ᨳᩪᨱᩣᨿᩴ ᨶᩥᨾ᩠ᨾᨶ᩠ᨲ᩠ᨿ, ᨴᩣᩁᩩᨾ᩠ᩉᩥ ᨲ᩠ᩅ’ᩁᨱᩦ ᨴ᩠ᩅᩥᩈᩩ;
ᨣᩣᩉᨸ᩠ᨸᨧ᩠ᨧᩣ’ᩉᩅᨶᩦᨿᩮᩣ, ᨴᨠ᩠ᨡᩥᨱᨣ᩠ᨣᩥ ᨲᨿᩮᩣ’ ᨣ᩠ᨣᨿᩮᩣ.
ᨧᩣᨣᩮᩣ ᩅᩥᩔᨩ᩠ᨩᨶᩴ ᨴᩣᨶᩴ, ᩅᩮᩣᩔᨣ᩠ᨣᩮᩣ ᨧᩣᨸᨴᩮᩈᨶᩴ;
ᩅᩥᩔᩣᨱᨶᩴ ᩅᩥᨲᩁᨱᩴ, ᩅᩥᩉᩣᨿᩥᨲᩣ ᨸᩅᨩ᩠ᨩᨶᩴ.
ᨸᨬ᩠ᨧ ¶ ᨾᩉᩣᨸᩁᩥᨧ᩠ᨧᩣᨣᩮᩣ, ᩅᩩᨲ᩠ᨲᩮᩣ ᩈᩮᨭ᩠ᨮ, ᨵᨶᩔ ᨧ;
ᩅᩈᩮᨶ ᨸᩩᨲ᩠ᨲ ᨴᩣᩁᩣᨶᩴ, ᩁᨩ᩠ᨩᩔ’ ᨦ᩠ᨣᩣᨶ ᨾᩮᩅ ᨧ.
ᩋᨶ᩠ᨶᩴ ᨸᩣᨶᩴ ᨥᩁᩴ ᩅᨲ᩠ᨳᩴ, ᨿᩣᨶᩴ ᨾᩣᩃᩣ ᩅᩥᩃᩮᨸᨶᩴ;
ᨣᨶ᩠ᨵᩮᩣ ᩈᩮᨿ᩠ᨿᩣ ᨸᨴᩦᨸᩮᨿ᩠ᨿᩴ, ᨴᩣᨶᩅᨲ᩠ᨳᩪ ᩈᩥᨿᩩᩴ ᨴᩈ.
ᨾᨲᨲ᩠ᨳᩴ ᨲᨴᩉᩮ ᨴᩣᨶᩴ, ᨲᩦᩈ᩠ᩅᩮᨲ ᨾᩩᨴ᩠ᨵᨴᩮᩉᩥᨠᩴ;
ᨸᩥᨲᩩᨴᩣᨶᩴ ᨲᩩ ᨶᩥᩅᩣᨸᩮᩣ, ᩈᨴ᩠ᨵᩴ ᨲᩩ ᨲᩴᩅ ᩈᩣᨲ᩠ᨳᨲᩮᩣ.
ᨸᩩᨾᩮ ᩋᨲᩥᨳᩥ ᩌᨣᨶ᩠ᨲᩩ, ᨸᩣᩉᩩᨶᩣ ᩅᩮᩈᩥᨠᩣ ᨸ᩠ᨿᨳ;
ᩋᨬ᩠ᨬᨲ᩠ᨳ ᨣᨶ᩠ᨲᩩ ᨾᩥᨧ᩠ᨨᨶ᩠ᨲᩮᩣ, ᨣᨾᩥᨠᩮᩣ ᨳᩣ ᨣ᩠ᨥ ᨾᨣ᩠ᨥᩥᨿᩴ.
ᨸᨩ᩠ᨩᩴ ᨸᩣᨴᩮᩣᨴᨠᩣᨴᩮᩣ ᨳ, ᩈᨲ᩠ᨲᩣ’ᨣᨶ᩠ᨲ᩠ᩅᩣᨴᨿᩮᩣ ᨲᩥᩈᩩ;
ᩋᨸᨧᩥᨲ᩠ᨿ’ᨧ᩠ᨧᨶᩣ ᨸᩪᨩᩣ, ᨸᩉᩣᩁᩮᩣ ᨻᩃᩥ ᨾᩣᨶᨶᩣ.
ᨶᨾᩔᩣ ᨲᩩ ᨶᨾᨠ᩠ᨠᩣᩁᩮᩣ, ᩅᨶ᩠ᨴᨶᩣ ᨧᩣᨽᩥᩅᩣᨴᨶᩴ;
ᨸᨲ᩠ᨳᨶᩣ ᨸᨱᩥᨵᩣᨶᨬ᩠ᨧ, ᨸᩩᩁᩥᩈᩮ ᨸᨱᩥᨵᩦᩁᩥᨲᩮᩣ.
ᩋᨩ᩠ᨫᩮᩈᨶᩣ ᨲᩩ ᩈᨠ᩠ᨠᩣᩁ, ᨸᩩᨻ᩠ᨻᨦ᩠ᨣᨾᨶᩥᨿᩮᩣᨩᨶᩴ;
ᨸᩁᩥᨿᩮᩈᨶᩣ ᨶ᩠ᩅᩮᩈᨶᩣ, ᨸᩁᩥᨿᩮᨭ᩠ᨮᩥ ᨣᩅᩮᩈᨶᩣ;
ᩏᨸᩣᩈᨶᩴ ᨲᩩ ᩈᩩᩔᩪᩈᩣ, ᩈᩣ ᨸᩣᩁᩥᨧᩁᩥᨿᩣ ᨽᩅᩮ.
ᨾᩮᩣᨶ ᨾᨽᩣᩈᨶᩴ ᨲᩩᨱ᩠ᩉᩦ, ᨽᩣᩅᩮᩣ ᨳ ᨸᨭᩥᨸᩣᨭᩥ ᩈᩣ;
ᩋᨶᩩᨠ᩠ᨠᨾᩮᩣ ᨸᩁᩥᨿᩣᨿᩮᩣ, ᩋᨶᩩᨸᩩᨻ᩠ᨻ᩠ᨿ’ᨸᩩᨾᩮ ᨠᨾᩮᩣ.
ᨲᨸᩮᩣ ᨧ ᩈᩴᨿᨾᩮᩣ ᩈᩦᩃᩴ, ᨶᩥᨿᨾᩮᩣ ᨲᩩ ᩅᨲᨬ᩠ᨧ ᩅᩣ;
ᩅᩦᨲᩥᨠ᩠ᨠᨾᩮᩣ’ ᨩ᩠ᨫᨧᩣᩁᩮᩣ ᨳ, ᩅᩥᩅᩮᨠᩮᩣ ᨸᩩᨳᩩᨣᨲ᩠ᨲᨲᩣ.
ᨡᩩᨴ᩠ᨴᩣᨶᩩᨡᩩᨴ᩠ᨴᨠᩴ ᩌᨽᩥ, ᩈᨾᩣᨧᩣᩁᩥᨠ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᩌᨴᩥᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩴ ᨲᩩ, ᨲᨴᨬ᩠ᨬᩴ ᩈᩦᩃ ᨾᩦᩁᩥᨲᩴ.
ᨿᩮᩣ ᨸᩣᨸᩮᩉᩥ ᩏᨸᩣᩅᨲ᩠ᨲᩮᩣ, ᩅᩣᩈᩮᩣ ᩈᨴ᩠ᨵᩥᩴ ᨣᩩᨱᩮᩉᩥ ᩈᩮᩣ;
ᩏᨸᩅᩣᩈᩮᩣᨲᩥ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩮᩣ, ᩈᨻ᩠ᨻᨽᩮᩣᨣᩅᩥᩅᨩ᩠ᨩᩥᨲᩮᩣ.
ᨲᨸᩔᩦ ᨽᩥᨠ᩠ᨡᩩ ᩈᨾᨱᩮᩣ, ᨸᨻ᩠ᨻᨩᩥᨲᩮᩣ ᨲᨸᩮᩣᨵᨶᩮᩣ;
ᩅᩣᨧᩴᨿᨾᩮᩣ ᨲᩩ ᨾᩩᨶᩥ ᨧ, ᨲᩣᨸᩈᩮᩣ ᨲᩩ ᩍᩈᩦ ᩁᩥᨲᩮᩣ.
ᨿᩮᩈᩴᨿᨲᩥᨶ᩠ᨴᩕᩥᨿᨣᨱᩣ, ᨿᨲᨿᩮᩣ ᩅᩈᩥᨶᩮᩣ ᨧ ᨲᩮ;
ᩈᩣᩁᩥᨸᩩᨲ᩠ᨲᩮᩣ’ᨸᨲᩥᩔᩮᩣ ᨲᩩ, ᨵᨾ᩠ᨾᩈᩮᨶᩣᨸᨲᩦ ᩁᩥᨲᩮᩣ.
ᨠᩮᩣᩃᩥᨲᩮᩣ ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᩣ ᨳ,
ᩋᩁᩥᨿᩮᩣ ᨵᩥᨣᨲᩮᩣ ᩈᩥᨿᩣ;
ᩈᩮᩣᨲᩣᨸᨶ᩠ᨶᩣᨴᩥᨠᩣ ᩈᩮᨡᩣ, ᨶᩁᩥᨿᩮᩣ ᨲᩩ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩮᩣ.
ᩋᨬ᩠ᨬᩣ ¶ ᨲᩩ ᩋᩁᩉᨲ᩠ᨲᨬ᩠ᨧ, ᨳᩪᨸᩮᩣ ᨲᩩ ᨧᩮᨲᩥᨿᩴ ᨽᩅᩮ;
ᨵᨾ᩠ᨾᨽᨱ᩠ᨯᩣᨣᩣᩁᩥᨠᩮᩣ ᨧ, ᩌᨶᨶ᩠ᨴᩮᩣ ᨴ᩠ᩅᩮ ᩈᨾᩣ ᨳ ᨧ.
ᩅᩥᩈᩣᨡᩣ ᨾᩥᨣᩣᩁᨾᩣᨲᩣ, ᩈᩩᨴᨲ᩠ᨲᩮᩣ’ ᨶᩣᨳᨸᩥᨱ᩠ᨯᩥᨠᩮᩣ;
ᨽᩥᨠ᩠ᨡᩩᨸᩥ ᩈᩣᨾᨱᩮᩁᩮᩣ ᨧ, ᩈᩥᨠ᩠ᨡᨾᩣᨶᩣ ᨧ ᨽᩥᨠ᩠ᨡᩩᨶᩦ;
ᩈᩣᨾᨱᩮᩁᩦᨲᩥ ᨠᨳᩥᨲᩣ, ᨸᨬ᩠ᨧᩮᨲᩮ ᩈᩉᨵᨾ᩠ᨾᩥᨠᩣ.
ᨸᨲ᩠ᨲᩮᩣ ᨲᩥᨧᩦᩅᩁᩴ ᨠᩣᨿ, ᨻᨶ᩠ᨵᨶᩴ ᩅᩣᩈᩥ ᩈᩪᨧᩥ ᨧ;
ᨸᩁᩥᩔᩣᩅᨶ ᨾᩥᨧ᩠ᨧᩮᨲᩮ, ᨸᩁᩥᨠ᩠ᨡᩣᩁᩣ’ᨭ᩠ᨮ ᨽᩣᩈᩥᨲᩣ.
ᩈᩣᨾᨱᩮᩁᩮᩣ ᨧ ᩈᨾᨱᩩ, ᨴ᩠ᨴᩮᩈᩮᩣ ᨧᩣᨳ ᨴᩥᨣᨾ᩠ᨻᩁᩮᩣ;
ᩋᨧᩮᩊᨠᩮᩣ ᨶᩥᨣᨱ᩠ᨮᩮᩣ ᨧ, ᨩᨭᩥᩃᩮᩣ ᨲᩩ ᨩᨭᩣᨵᩁᩮᩣ.
ᨠᩩᨭᩦᩈᨠᩣᨴᩥᨠᩣ ᨧᨲᩩ, ᨲ᩠ᨲᩥᩴᩈ ᨴ᩠ᩅᩣᩈᨭ᩠ᨮᩥ ᨴᩥᨭ᩠ᨮᩥᨿᩮᩣ;
ᩍᨲᩥ ᨨᨶ᩠ᨶᩅᩩᨲᩥ ᩑᨲᩮ, ᨸᩣᩈᨱ᩠ᨯᩣ ᩈᨾ᩠ᨸᨠᩣᩈᩥᨲᩣ.
ᨸᩅᩥᨲ᩠ᨲᩮᩣ ᨸᨿᨲᩮᩣ ᨸᩪᨲᩮᩣ, ᨧᨾ᩠ᨾᩴ ᨲᩩ ᩋᨩᩥᨶᩴ ᨸ᩠ᨿᨳ;
ᨴᨶ᩠ᨲᨸᩮᩣᨱᩮᩣ ᨴᨶ᩠ᨲᨠᨭ᩠ᨮᩴ, ᩅᨠ᩠ᨠᩃᩮᩣ ᩅᩣ ᨲᩥᩁᩦᨭᨠᩴ.
ᨸᨲ᩠ᨲᩮᩣ ᨸᩣᨲᩥᨲ᩠ᨳᩥᨿᩴᨶᩥᨲ᩠ᨳᩦ, ᨠᨾᨱ᩠ᨯᩃᩩ ᨲᩩ ᨠᩩᨱ᩠ᨯᩥᨠᩣ;
ᩋᨳᩣᩃᨾ᩠ᨻᨱᨴᨱ᩠ᨯᩈ᩠ᨾᩥᩴ, ᨠᨲ᩠ᨲᩁᨿᨭ᩠ᨮᩥ ᨶᩣᩁᩥᨿᩴ.
ᨿᩴ ᨴᩮᩉᩈᩣᨵᨶᩣᨸᩮᨠ᩠ᨡᩴ, ᨶᩥᨧ᩠ᨧᩴ ᨠᨾ᩠ᨾᨾᨿᩴ ᨿᨾᩮᩣ;
ᩌᨣᨶ᩠ᨲᩩᩈᩣᨵᨶᩴ ᨠᨾ᩠ᨾᩴ, ᩋᨶᩥᨧ᩠ᨧᩴ ᨶᩥᨿᨾᩮᩣ ᨽᩅᩮ.
ᩍᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩅᨣ᩠ᨣᩮᩣ.
ᩅᩮᩔᩮᩣ ᨧ ᩅᩮᩈᩥᨿᩣᨶᩮᩣ ᨳ, ᨩᩦᩅᨶᩴ ᩅᩩᨲ᩠ᨲᩥ ᨩᩦᩅᩥᨠᩣ;
ᩌᨩᩦᩅᩮᩣ ᩅᨲ᩠ᨲᨶᩴ ᨧᩣᨳ, ᨠᩈᩥᨠᨾ᩠ᨾᩴ ᨠᩈᩥᨲ᩠ᨳᩥᨿᩴ.
ᩅᩣᨱᩥᨩ᩠ᨩᨬ᩠ᨧ ᩅᨱᩥᨩ᩠ᨩᩣ ᨳ, ᨣᩮᩣᩁᨠ᩠ᨡᩣ ᨸᩈᩩᨸᩣᩃᨶᩴ;
ᩅᩮᩔᩔ ᩅᩩᨲ᩠ᨲᩥᨿᩮᩣ ᨲᩥᩔᩮᩣ, ᨣᩉᨭ᩠ᨮᩣ’ᨣᩣᩁᩥᨠᩣ ᨣᩥᩉᩥ.
ᨡᩮᨲ᩠ᨲᩣᨩᩦᩅᩮᩣ ᨠᩔᨠᩮᩣ ᨳ, ᨡᩮᨲ᩠ᨲᩴ ᨠᩮᨴᩣᩁ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᩃᩮᨯ᩠ᨯᩩ’ᨲ᩠ᨲᩮᩣ ᨾᨲ᩠ᨲᩥᨠᩣᨡᨱ᩠ᨯᩮᩣ, ᨡᨱᩥᨲ᩠ᨲᩥ’ᨲ᩠ᨳ᩠ᨿ’ᩅᨴᩣᩁᨱᩴ.
ᨴᩣᨲ᩠ᨲᩴ ᩃᩅᩥᨲ᩠ᨲ ᨾᩈᩥᨲᩴ [‘‘ᩋᩈᩥᨲ’’ ᩈᨴ᩠ᨴᩮᩣ ᨸᩩᩴᨶᨸᩩᩴᩈᨠᩮ-᪑᪐᪐᪕-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ], ᨸᨲᩮᩣᨴᩮᩣ ᨲᩩᨲ᩠ᨲ ᨸᩣᨩᨶᩴ;
ᨿᩮᩣᨲ᩠ᨲᩴ ᨲᩩ ᩁᨩ᩠ᨩᩩ ᩁᩈ᩠ᨾᩥᨲ᩠ᨳᩦ, ᨹᩣᩃᩮᩣ ᨲᩩ ᨠᩈᨠᩮᩣ ᨽᩅᩮ.
ᨶᨦ᩠ᨣᩃᨬ᩠ᨧ ᩉᩃᩴ ᩈᩦᩁᩮᩣ, ᩎᩈᩣ ᨶᨦ᩠ᨣᩃᨴᨱ᩠ᨯᨠᩮᩣ;
ᩈᨾ᩠ᨾᩣ ᨲᩩ ᨿᩩᨣᨠᩦᩃᩈ᩠ᨾᩥᩴ, ᩈᩦᨲᩣ ᨲᩩ ᩉᩃᨸᨴ᩠ᨵᨲᩥ.
ᨾᩩᨣ᩠ᨣᩣᨴᩥᨠᩮ ¶ ᨸᩁᨱ᩠ᨱᨬ᩠ᨧ, ᨸᩩᨻ᩠ᨻᨱ᩠ᨱᩴ ᩈᩣᩃᩥᩌᨴᩥᨠᩮ;
ᩈᩣᩃᩥ ᩅᩦᩉᩥ ᨧ ᨠᩩᨴᩕᩪᩈᩮᩣ, ᨣᩮᩣᨵᩩᨾᩮᩣ ᩅᩁᨠᩮᩣ ᨿᩅᩮᩣ;
ᨠᨦ᩠ᨣᩪᨲᩥ ᩈᨲ᩠ᨲ ᨵᨬ᩠ᨬᩣᨶᩥ, ᨶᩦᩅᩣᩁᩣᨴᩦ ᨲᩩ ᨲᨻ᩠ᨽᩥᨴᩣ.
ᨧᨱᨠᩮᩣ ᨧ ᨠᩊᩣᨿᩮᩣ ᨳ,
ᩈᩥᨴ᩠ᨵᨲ᩠ᨳᩮᩣ ᩈᩣᩈᨸᩮᩣ ᨽᩅᩮ.
ᩋᨳ ᨠᨦ᩠ᨣᩩ ᨸᩥᨿᨦ᩠ᨣᩩ’ᨲ᩠ᨳᩦ, ᩏᨾ᩠ᨾᩣ ᨲᩩ ᩋᨲᩈᩦ ᨽᩅᩮ;
ᨠᩥᨭ᩠ᨮᨬ᩠ᨧ ᩈᩔᩴ ᨵᨬ᩠ᨬᨬ᩠ᨧ [ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ (ᨭᩦ.)], ᩅᩦᩉᩥ ᨳᨾ᩠ᨻᨠᩁᩦ [ᨳᨾ᩠ᨽᨠᩁᩦ (ᨠ.)] ᩁᩥᨲᩮᩣ.
ᨠᨱ᩠ᨯᩮᩣ ᨲᩩ ᨶᩣᩊ ᨾᨳ ᩈᩮᩣ, ᨸᩃᩣᩃᩴ ᨶᩥᨲ᩠ᨳᩥ ᨶᩥᨸ᩠ᨹᩃᩮᩣ;
ᨽᩩᩈᩴ ᨠᩃᩥᨦ᩠ᨣᩁᩮᩣ ᨧᩣᨳ, ᨳᩩᩈᩮᩣ ᨵᨬ᩠ᨬᨲ᩠ᨲᨧᩮ ᨳ ᨧ.
ᩈᩮᨲᨭ᩠ᨭᩥᨠᩣ ᩈᩔᩁᩮᩣᨣᩮᩣ,
ᨠᨱᩮᩣ ᨲᩩ ᨠᩩᨱ᩠ᨯᨠᩮᩣ ᨽᩅᩮ;
ᨡᩃᩮᩣ ᨧ ᨵᨬ᩠ᨬᨠᩁᨱᩴ, ᨳᨾ᩠ᨻᩮᩣ [ᨳᨾ᩠ᨽᩮᩣ (ᨠ.)] ᨣᩩᨾ᩠ᨻᩮᩣ ᨲᩥᨱᩣᨴᩥᨶᩴ.
ᩋᨿᩮᩣᨣ᩠ᨣᩮᩣ ᨾᩩᩈᩃᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᩩᩃ᩠ᩃᩮᩣ ᩈᩩᨸ᩠ᨸ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ;
ᩋᨳᩮᩣ’ᨴ᩠ᨵᨶᨬ᩠ᨧ ᨧᩩᩃ᩠ᩃᩥ’ᨲ᩠ᨳᩦ, ᨠᩥᩃᨬ᩠ᨩᩮᩣ ᨲᩩ ᨠᨭᩮᩣ ᨽᩅᩮ.
ᨠᩩᨾ᩠ᨽᩦ’ᨲ᩠ᨳᩦ ᨸᩥᨮᩁᩮᩣ ᨠᩩᨱ᩠ᨯᩴ, ᨡᩊᩮᩣᨸ᩠ᨿᩩ’ᨠ᩠ᨡᩃᩥ ᨳᩣᩃ᩠ᨿᩩ’ᨡᩣ;
ᨠᩮᩣᩃᨾ᩠ᨻᩮᩣ ᨧᩣᨳ ᨾᨱᩥᨠᩴ, ᨽᩣᨱᨠᩮᩣ ᨧ ᩋᩁᨬ᩠ᨩᩁᩮᩣ.
ᨥᨭᩮᩣ ᨴ᩠ᩅᩦᩈᩩ ᨠᩩᨭᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᩩᨾ᩠ᨽᩮᩣ ᨠᩃᩈ, ᩅᩣᩁᨠᩣ;
ᨠᩴᩈᩮᩣ ᨽᩩᨬ᩠ᨩᨶᨸᨲ᩠ᨲᩮᩣ ᨳᩣ, ᨾᨲ᩠ᨲᩴ ᨸᨲ᩠ᨲᩮᩣ ᨧ ᨽᩣᨩᨶᩴ.
ᩋᨱ᩠ᨯᩩᨸᨠᩴ ᨧᩩᨾ᩠ᨻᨭᨠᩴ, ᩈᩁᩣᩅᩮᩣ ᨲᩩ ᨧ ᨾᩃ᩠ᩃᨠᩮᩣ;
ᨸᩩᨾᩮ ᨠᨭᨧ᩠ᨨᩩᨴᨻ᩠ᨻᩥ’ᨲ᩠ᨳᩦ, ᨠᩩᩈᩪᩃᩮᩣ ᨠᩮᩣᨭ᩠ᨮ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩈᩣᨠᩮᩣ ᩋᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨯᩣᨠᩮᩣ, ᩈᩥᨦ᩠ᨣᩦᩅᩮᩁᩴᨲᩩ ᩋᨴ᩠ᨴᨠᩴ;
ᨾᩉᩮᩣᩈᨵᩴ ᨲᩩ ᨲᩴ ᩈᩩᨠ᩠ᨡᩴ, ᨾᩁᩥᨧᩴ ᨲᩩ ᨧ ᨠᩮᩣᩃᨠᩴ.
ᩈᩮᩣᩅᩦᩁᩴ ᨠᨬ᩠ᨩᩥᨿᩴ ᩅᩩᨲ᩠ᨲᩴ, ᩌᩁᨶᩣᩊᩴ ᨳᩩᩈᩮᩣᨴᨠᩴ;
ᨵᨬ᩠ᨬᨾ᩠ᨻᩥᩃᩴ ᨻᩥᩊᨦ᩠ᨣᩮᩣ ᨳ, ᩃᩅᨱᩴ ᩃᩮᩣᨱ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩈᩣᨾᩩᨴ᩠ᨴᩴ ᩈᩥᨶ᩠ᨵᩅᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᩣᩊᩃᩮᩣᨱᩴ ᨲᩩ ᩏᨻ᩠ᨽᩥᨴᩴ;
ᨻᩥᩊᨠᩴ [ᨻᩥᩊᩣᩃ (ᨠ.)] ᨧᩮᨲᩥ ᨸᨬ᩠ᨧᩮᨲᩮ, ᨸᨽᩮᨴᩣ ᩃᩅᨱᩔ ᩉᩥ.
ᨣᩩᩊᩮᩣ ᨧ ᨹᩣᨱᩥᨲᩴ ᨡᨱ᩠ᨯᩮᩣ, ᨾᨧ᩠ᨨᨱ᩠ᨯᩦ ᩈᨠ᩠ᨡᩁᩣ ᩍᨲᩥ;
ᩍᨾᩮ ᩏᨧ᩠ᨨᩩᩅᩥᨠᩣᩁᩣ ᨳ, ᨣᩩᩊᩈ᩠ᨾᩥᩴ ᩅᩥᩈᨠᨱ᩠ᨭᨠᩴ.
ᩃᩣᨩᩣ ¶ ᩈᩥᨿᩣ’ᨠ᩠ᨡᨲᩴ ᨧᩣᨳ, ᨵᩣᨶᩣ ᨽᨭ᩠ᨮᨿᩅᩮ ᨽᩅᩮ;
ᩋᨻᨴ᩠ᨵᩈᨲ᩠ᨲᩩ ᨾᨶ᩠ᨳᩮᩣ ᨧ, ᨸᩪᨸᩣ’ ᨸᩪᨸᩣ ᨲᩩ ᨸᩥᨭ᩠ᨮᨠᩮᩣ.
ᨽᨲ᩠ᨲᨠᩣᩁᩮᩣ ᩈᩪᨸᨠᩣᩁᩮᩣ, ᩈᩪᨴᩮᩣ ᩌᩊᩣᩁᩥᨠᩮᩣ ᨲᨳᩣ;
ᩒᨴᨶᩥᨠᩮᩣ ᨧ ᩁᩈᨠᩮᩣ, ᩈᩪᨸᩮᩣ ᨲᩩ ᨻ᩠ᨿᨬ᩠ᨩᨶᩴ ᨽᩅᩮ.
ᩒᨴᨶᩮᩣ ᩅᩣ ᨠᩩᩁᩴ ᨽᨲ᩠ᨲᩴ, ᨽᩥᨠ᩠ᨡᩣ ᨧᩣ’ᨶ᩠ᨶ ᨾᨳᩣ ᩈᨶᩴ;
ᩌᩉᩣᩁᩮᩣ ᨽᩮᩣᨩᨶᩴ ᨥᩣᩈᩮᩣ,
ᨲᩁᩃᩴ ᨿᩣᨣᩩ ᨶᩣᩁᩥᨿᩴ.
ᨡᨩ᩠ᨩᩴ ᨲᩩ ᨽᩮᩣᨩ᩠ᨩ ᩃᩮᨿ᩠ᨿᩣᨶᩥ, ᨸᩮᨿ᩠ᨿᨶ᩠ᨲᩥ ᨧᨲᩩᨵᩣ’ᩈᨶᩴ;
ᨶᩥᩔᩣᩅᩮᩣ ᨧ ᨲᨳᩣ’ᨧᩣᨾᩮᩣ,
ᩌᩃᩮᩣᨸᩮᩣ ᨠᨻᩊᩮᩣ ᨽᩅᩮ.
ᨾᨱ᩠ᨯᩮᩣ ᨶᩥᨲ᩠ᨳᩦᩁᩈᨣ᩠ᨣᩈ᩠ᨾᩥᩴ, ᩅᩥᨥᩣᩈᩮᩣ ᨽᩩᨲ᩠ᨲᩈᩮᩈᨠᩮ;
ᩅᩥᨥᩣᩈᩣᨴᩮᩣ ᨧ ᨴᨾᨠᩮᩣ, ᨸᩥᨸᩣᩈᩣ ᨲᩩ ᨧ ᨲᩔᨶᩴ.
ᨡᩩᨴ᩠ᨴᩣ ᨩᩥᨥᨧ᩠ᨨᩣ, ᨾᩴᩈᩔ, ᨸᨭᩥᨧ᩠ᨨᩣᨴᨶᩥᨿᩴ ᩁᩈᩮᩣ;
ᩏᨴᩕᩮᨠᩮᩣ ᨧᩮᩅ ᩏᨣ᩠ᨣᩣᩁᩮᩣ, ᩈᩮᩣᩉᩥᨧ᩠ᨧᩴ ᨲᩥᨲ᩠ᨲᩥ ᨲᨸ᩠ᨸᨶᩴ.
ᨠᩣᨾᩴ ᨲ᩠ᩅᩥᨭ᩠ᨮᩴ ᨶᩥᨠᩣᨾᨬ᩠ᨧ, ᨸᩁᩥᨿᨲ᩠ᨲᩴ ᨿᨳᨧ᩠ᨨᩥᨲᩴ;
ᨠᨿᩅᩥᨠ᩠ᨠᨿᩥᨠᩮᩣ ᩈᨲ᩠ᨳ,ᩅᩣᩉᩣ’ ᨸᨱᩥᨠ ᩅᩣᨱᩥᨩᩣ.
ᩅᩥᨠ᩠ᨠᨿᩥᨠᩮᩣ ᨲᩩ ᩅᩥᨠ᩠ᨠᩮᨲᩣ,
ᨠᨿᩥᨠᩮᩣ ᨲᩩ ᨧ ᨠᩣᨿᩥᨠᩮᩣ;
ᩏᨲ᩠ᨲᨾᨱ᩠ᨱᩮᩣ ᨧ ᨵᨶᩥᨠᩮᩣ, ᨵᨾᨱ᩠ᨱᩮᩣ ᨲᩩ ᩍᨱᩣᨿᩥᨠᩮᩣ.
ᩏᨴ᩠ᨵᩣᩁᩮᩣ ᨲᩩ ᩍᨱᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨾᩪᩃᩴ ᨲᩩ ᨸᩣᨽᨲᩴ ᨽᩅᩮ;
ᩈᨧ᩠ᨧᩣᨸᨶᩴ ᩈᨧ᩠ᨧᩴᨠᩣᩁᩮᩣ, ᩅᩥᨠ᩠ᨠᩮᨿ᩠ᨿᩴ ᨸᨱᩥᨿ᩠ᨿᩴ ᨲᩥᩈᩩ.
ᨸᨭᩥᨴᩣᨶᩴ ᨸᩁᩥᩅᨲ᩠ᨲᩮᩣ, ᨶ᩠ᨿᩣᩈᩮᩣ ᨲᩪ’ᨸᨶᩥᨵᩦ ᩁᩥᨲᩮᩣ;
ᩋᨭ᩠ᨮᩣᩁᩈᨶ᩠ᨲᩣ ᩈᨦ᩠ᨡ᩠ᨿᩮᨿ᩠ᨿᩮ, ᩈᨦ᩠ᨡ᩠ᨿᩣ ᩑᨠᩣᨴᨿᩮᩣ ᨲᩥᩈᩩ;
ᩈᨦ᩠ᨡ᩠ᨿᩣᨶᩮ ᨲᩩ ᨧ ᩈᨦ᩠ᨡ᩠ᨿᩮᨿ᩠ᨿᩮ, ᩑᨠᨲ᩠ᨲᩮ ᩅᩦᩈᨲᩣᨴᨿᩮᩣ;
ᩅᨣ᩠ᨣᨽᩮᨴᩮ ᨻᩉᩩᨲ᩠ᨲᩮᨸᩥ, ᨲᩣ ᩌᨶᩅᩩᨲᩥ ᨶᩣᩁᩥᨿᩴ.
ᩈᨲᩴ ᩈᩉᩔᩴ ᨶᩥᨿᩩᨲᩴ [ᨶᩉᩩᨲᩴ-ᨶᨿᩩᨲᩴ (ᨠᨲ᩠ᨳᨧᩥ)], ᩃᨠ᩠ᨡᩴ ᨠᩮᩣᨭᩥ ᨸᨠᩮᩣᨭᩥᨿᩮᩣ;
ᨠᩮᩣᨭᩥᨸᨠᩮᩣᨭᩥ ᨶᩉᩩᨲᩴ, ᨲᨳᩣ ᨶᩥᨶ᩠ᨶᩉᩩᨲᨾ᩠ᨸᩥ ᨧ.
ᩋᨠ᩠ᨡᩮᩣᨽᨶᩦᨲ᩠ᨳᩥᨿᩴ ¶ [ᩋᨠ᩠ᨡᩮᩣᨽᩥᨱᩦ (ᨠ.)] ᨻᩥᨶ᩠ᨴᩩ, ᩋᨻ᩠ᨻᩩᨴᨬ᩠ᨧ ᨶᩥᩁᨻ᩠ᨻᩩᨴᩴ;
ᩋᩉᩉᩴ ᩋᨻᨻᩴ ᨧᩮᩅᩣ, ᨭᨭᩴ ᩈᩮᩣᨣᨶ᩠ᨵᩥ ᨠᩩᨸ᩠ᨸᩃᩴ.
ᨠᩩᨾᩩᨴᩴ ᨸᩩᨱ᩠ᨯᩁᩦᨠᨬ᩠ᨧ, ᨸᨴᩩᨾᩴ ᨠᨳᩣᨶᨾ᩠ᨸᩥ ᨧ;
ᨾᩉᩣᨠᨳᩣᨶᩣ’ᩈᨦ᩠ᨡ᩠ᨿᩮᨿ᩠ᨿᩣ, ᨶᩥ’ᨧ᩠ᨧᩮᨲᩣᩈᩩ ᩈᨲᩣᨴᩥ ᨧ.
ᨠᩮᩣᨭ᩠ᨿᩣᨴᩥᨠᩴ ᨴᩈᨣᩩᨱᩴ, ᩈᨲᩃᨠ᩠ᨡᨣᩩᨱᩴ ᨠᨾᩣ;
ᨧᨲᩩᨲ᩠ᨳᩮᩣ’ᨯ᩠ᨰᩮᨶ ᩋᨯ᩠ᨰᩩᨯ᩠ᨰᩮᩣ,
ᨲᨲᩥᨿᩮᩣ ᨯ᩠ᨰᨲᩥᨿᩮᩣ ᨲᨳᩣ.
ᩋᨯ᩠ᨰᨲᩮᨿ᩠ᨿᩮᩣ ᨴᩥᨿᨯ᩠ᨰᩮᩣ ᨲᩩ,
ᨴᩥᩅᨯ᩠ᨰᩮᩣ ᨴᩩᨲᩥᨿᩮᩣ ᨽᩅᩮ;
ᨲᩩᩃᩣ, ᨸᨲ᩠ᨳ, ᨦ᩠ᨣᩩᩃᩥ, ᩅᩈᩣ, ᨲᩥᨵᩣ ᨾᩣᨶ ᨾᨳᩮᩣ ᩈᩥᨿᩣ.
ᨧᨲ᩠ᨲᩣᩁᩮᩣ ᩅᩥᩉᨿᩮᩣ ᨣᩩᨬ᩠ᨩᩣ,
ᨴ᩠ᩅᩮ ᨣᩩᨬ᩠ᨩᩣ ᨾᩣᩈᨠᩮᩣ ᨽᩅᩮ;
ᨴ᩠ᩅᩮ ᩋᨠ᩠ᨡᩣ ᨾᩣᩈᨠᩣ ᨸᨬ᩠ᨧ, ᨠ᩠ᨡᩣᨶᩴ ᨵᩁᨱᨾᨭ᩠ᨮᨠᩴ.
ᩈᩩᩅᨱ᩠ᨱᩮᩣ ᨸᨬ᩠ᨧᨵᩁᨱᩴ, ᨶᩥᨠ᩠ᨡᩴ ᨲ᩠ᩅᨶᩥᨲ᩠ᨳᩥ ᨸᨬ᩠ᨧ ᨲᩮ;
ᨸᩣᨴᩮᩣ ᨽᩣᨣᩮ ᨧᨲᩩᨲ᩠ᨳᩮ ᨳ, ᨵᩁᨱᩣᨶᩥ ᨸᩃᩴ ᨴᩈ.
ᨲᩩᩃᩣ ᨸᩃᩈᨲᩴ ᨧᩣᨳ, ᨽᩣᩁᩮᩣ ᩅᩦᩈᨲᩥ ᨲᩣ ᨲᩩᩃᩣ;
ᩋᨳᩮᩣ ᨠᩉᩣᨸᨱᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨠᨳ᩠ᨿᨲᩮ ᨠᩁᩥᩈᩣᨸᨱᩮᩣ.
ᨠᩩᨯᩩᩅᩮᩣ ᨸᩈᨲᩮᩣ ᩑᨠᩮᩣ,
ᨸᨲ᩠ᨳᩮᩣ ᨲᩮ ᨧᨲᩩᩁᩮᩣ ᩈᩥᨿᩩᩴ;
ᩌᩊ᩠ᩉᨠᩮᩣ ᨧᨲᩩᩁᩮᩣ ᨸᨲ᩠ᨳᩣ, ᨴᩮᩣᨱᩴ ᩅᩣᨧᨲᩩᩁᩣ’ᩊ᩠ᩉᨠᩴ.
ᨾᩣᨶᩥᨠᩣ ᨧᨲᩩᩁᩮᩣ ᨴᩮᩣᨱᩣ, ᨡᩣᩁᩦᨲ᩠ᨳᩦ ᨧᨲᩩᨾᩣᨶᩥᨠᩣ;
ᨡᩣᩁᩥᨿᩮᩣ ᩅᩦᩈ ᩅᩣᩉᩮᩣ ᨳ,
ᩈᩥᨿᩣ ᨠᩩᨾ᩠ᨽᩮᩣ ᨴᩈᨾ᩠ᨻᨱᩴ.
ᩌᩊ᩠ᩉᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨲᩩᨾ᩠ᨽᩮᩣ, ᨸᨲ᩠ᨳᩮᩣᨲᩩ ᨶᩣᩊᩥ ᨶᩣᩁᩥᨿᩴ;
ᩅᩣᩉᩮᩣ ᨲᩩ ᩈᨠᨭᩮᩣ ᨧᩮᨠᩣ,
ᨴᩈ ᨴᩮᩣᨱᩣ ᨲᩩ ᩋᨾ᩠ᨻᨱᩴ.
ᨸᨭᩥᩅᩦᩈᩮᩣ ᨧ ᨠᩮᩣᨭ᩠ᨮᩣᩈᩮᩣ,
ᩋᩴᩈᩮᩣ ᨽᩣᨣᩮᩣ ᨵᨶᩴ ᨲᩩ ᩈᩮᩣ;
ᨴᨻ᩠ᨻᩴ ᩅᩥᨲ᩠ᨲᩴ ᩈᩣᨸᨲᩮᨿ᩠ᨿᩴ, ᩅᩈ᩠ᩅ’ᨲ᩠ᨳᩮᩣ ᩅᩥᨽᩅᩮᩣ ᨽᩅᩮ.
ᨠᩮᩣᩈᩮᩣ ¶ ᩉᩥᩁᨬ᩠ᨬᨬ᩠ᨧ ᨠᨲᩣ, ᨠᨲᩴ ᨠᨬ᩠ᨧᨶ, ᩁᩪᨸᩥᨿᩴ;
ᨠᩩᨸ᩠ᨸᩴ ᨲᨴᨬ᩠ᨬᩴ ᨲᨾ᩠ᨻᩣᨴᩥ, ᩁᩪᨸᩥᨿᩴ ᨴ᩠ᩅᨿ ᨾᩣᩉᨲᩴ.
ᩈᩩᩅᨱ᩠ᨱᩴ ᨠᨶᨠᩴ ᨩᩣᨲ, ᩁᩪᨸᩴ ᩈᩮᩣᨱ᩠ᨱᨬ᩠ᨧ ᨠᨬ᩠ᨧᨶᩴ;
ᩈᨲ᩠ᨳᩩᩅᨱ᩠ᨱᩮᩣ ᩉᩁᩦ ᨠᨾ᩠ᨻᩩ, ᨧᩣᩁᩩ ᩉᩮᨾᨬ᩠ᨧ ᩉᩣᨭᨠᩴ.
ᨲᨸᨶᩥᨿᩴ ᩉᩥᩁᨬ᩠ᨬᩴ ᨲ, ᨻ᩠ᨽᩮᨴᩣ ᨧᩣᨾᩦᨠᩁᨾ᩠ᨸᩥ ᨧ;
ᩈᩣᨲᨠᩩᨾ᩠ᨽᩴ ᨲᨳᩣ ᨩᨾ᩠ᨻᩩ, ᨶᨴᩴ ᩈᩥᨦ᩠ᨣᩦ ᨧ ᨶᩣᩁᩥᨿᩴ.
ᩁᩪᨸᩥᨿᩴ ᩁᨩᨲᩴ ᩈᨩ᩠ᨫᩩ, ᩁᩪᨸᩦ ᩈᨩ᩠ᨫᩴ ᩋᨳᩮᩣ ᩅᩈᩩ;
ᩁᨲᨶᨬ᩠ᨧ ᨾᨱᩥ ᨴ᩠ᩅᩦᩈᩩ, ᨸᩩᨸ᩠ᨹᩁᩣᨣᩣᨴᩦ ᨲᨻ᩠ᨽᩥᨴᩣ.
ᩈᩩᩅᨱ᩠ᨱᩴ ᩁᨩᨲᩴ ᨾᩩᨲ᩠ᨲᩣ, ᨾᨱᩥ ᩅᩮᩊᩩᩁᩥᨿᩣᨶᩥ ᨧ;
ᩅᨩᩥᩁᨬ᩠ᨧ ᨸᩅᩣᩊᨶ᩠ᨲᩥ, ᩈᨲ᩠ᨲᩣ’ᩉᩩ ᩁᨲᨶᩣᨶᩥ’ ᨾᩮ.
ᩃᩮᩣᩉᩥᨲᨦ᩠ᨠᩮᩣ ᨧ ᨸᨴᩩᨾ, ᩁᩣᨣᩮᩣ ᩁᨲ᩠ᨲᨾᨱᩥ ᨸ᩠ᨿᨳ;
ᩅᩴᩈᩅᨱ᩠ᨱᩮᩣ ᩅᩮᩊᩩᩁᩥᨿᩴ, ᨸᩅᩣᩊᩴ ᩅᩣ ᨧ ᩅᩥᨴ᩠ᨴᩩᨾᩮᩣ.
ᨾᩈᩣᩁᨣᩃ᩠ᩃᩴ ᨠᨻᩁᨾᨱᩥ, ᩋᨳ ᨾᩩᨲ᩠ᨲᩣ ᨧ ᨾᩩᨲ᩠ᨲᩥᨠᩴ;
ᩁᩦᨲᩥ [ᩁᩦᩁᩦ (ᨭᩦ.)] ᨲ᩠ᨳᩦ ᩌᩁᨠᩪᨭᩮᩣ ᩅᩣ, ᩋᨾᩃᩴ ᨲ᩠ᩅ’ᨻ᩠ᨽᨠᩴ ᨽᩅᩮ.
ᩃᩮᩣᩉᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩋᨿᩮᩣ ᨠᩣᩊᩣ,
ᨿᩈᨬ᩠ᨧ ᨸᩣᩁᨴᩮᩣ ᩁᩈᩮᩣ;
ᨠᩣᩊᨲᩥᨸᩩ ᨲᩩ ᩈᩦᩈᨬ᩠ᨧ, ᩉᩁᩥᨲᩣᩃᩴ ᨲᩩ ᨸᩦᨲᨶᩴ.
ᨧᩥᨶᨸᩥᨭ᩠ᨮᨬ᩠ᨧ ᩈᩥᨶ᩠ᨴᩪᩁᩴ, ᩋᨳ ᨲᩪᩃᩮᩣ ᨲᨳᩣ ᨸᩥᨧᩩ;
ᨡᩩᨴ᩠ᨴᨩᩴ ᨲᩩ ᨾᨵᩩ ᨡᩩᨴ᩠ᨴᩴ, ᨾᨵᩩᨧ᩠ᨨᩥᨭ᩠ᨮᩴ ᨲᩩ ᩈᩥᨲ᩠ᨳᨠᩴ.
ᨣᩮᩣᨸᩣᩃᩮᩣ ᨣᩮᩣᨸ ᨣᩮᩣᩈᨦ᩠ᨡ᩠ᨿᩣ,
ᨣᩮᩣᨾᩣ ᨲᩩ ᨣᩮᩣᨾᩥᨠᩮᩣ ᨸ᩠ᨿᨳ;
ᩏᩈᨽᩮᩣ ᨻᩃᩦᨻᨴ᩠ᨵᩮᩣ [ᨻᩃᩥᨻᨴ᩠ᨴ (ᨠ.)] ᨧ, ᨣᩮᩣᨱᩮᩣ ᨣᩮᩣᩅᩈᨽᩮᩣ ᩅᩩᩈᩮᩣ.
ᩅᩩᨴ᩠ᨵᩮᩣ ᨩᩁᨣ᩠ᨣᩅᩮᩣ ᩈᩮᩣ ᨳ, ᨴᨾ᩠ᨾᩮᩣ ᩅᨧ᩠ᨨᨲᩁᩮᩣ ᩈᨾᩣ;
ᨵᩩᩁᩅᩣᩉᩦ ᨲᩩ ᨵᩮᩣᩁᨿ᩠ᩉᩮᩣ, ᨣᩮᩣᩅᩥᨶ᩠ᨴᩮᩣ ᨵᩥᨠᨲᩮᩣ ᨣᩅᩴ.
ᩅᩉᩮᩣ ᨧ ᨡᨶ᩠ᨵᨴᩮᩈᩮᩣ ᨳ, ᨠᨠᩩᨵᩮᩣ [ᨠᨠᩩᨴᩮᩣ (ᨠ.)] ᨠᨠᩩ ᩅᩩᨧ᩠ᨧᨲᩮ;
ᩋᨳᩮᩣ ᩅᩥᩈᩣᨱᩴ ᩈᩥᨦ᩠ᨣᨬ᩠ᨧ, ᩁᨲ᩠ᨲᨣᩣᩅᩦ ᨲᩩ ᩁᩮᩣᩉᩥᨱᩦ.
ᨣᩣᩅᩦ ᨧ ᩈᩥᨦ᩠ᨣᩥᨶᩦ ᨣᩮᩣ ᨧ, ᩅᨬ᩠ᨫᩣ ᨲᩩ ᨠᨳ᩠ᨿᨲᩮ ᩅᩈᩣ;
ᨶᩅᨸ᩠ᨸᩈᩪᨲᩥᨠᩣ ᨵᩮᨶᩩ, ᩅᨧ᩠ᨨᨠᩣᨾᩣ ᨲᩩ ᩅᨧ᩠ᨨᩃᩣ.
ᨣᨣ᩠ᨣᩁᩦ ¶ ᨾᨶ᩠ᨳᨶᩦᨲ᩠ᨳᩦ ᨴ᩠ᩅᩮ, ᩈᨶ᩠ᨴᩣᨶᩴ ᨴᩣᨾᨾᩩᨧ᩠ᨧᨲᩮ;
ᨣᩮᩣᨾᩥᩊ᩠ᩉᩮᩣ ᨣᩮᩣᨾᨿᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩋᨳᩮᩣ ᩈᨸ᩠ᨸᩥ ᨥᨲᩴ ᨽᩅᩮ.
ᨶᩅᩩᨴ᩠ᨵᨭᩴ ᨲᩩ ᨶᩮᩣᨶᩦᨲᩴ, ᨴᨾᩥᨾᨱ᩠ᨯᩴ ᨲᩩ ᨾᨲ᩠ᨳᩩ ᨧ,
ᨡᩦᩁᩴ ᨴᩩᨴ᩠ᨵᩴ ᨸᨿᩮᩣ ᨳᨬ᩠ᨬᩴ, ᨲᨠ᩠ᨠᩴ ᨲᩩ ᨾᨳᩥᨲᩴ ᨸ᩠ᨿᨳ.
ᨡᩦᩁᩴ ᨴᨵᩥ ᨥᨲᩴ ᨲᨠ᩠ᨠᩴ, ᨶᩮᩣᨶᩦᨲᩴ ᨸᨬ᩠ᨧ ᨣᩮᩣᩁᩈᩣ;
ᩏᩁᨻ᩠ᨽᩮᩣ ᨾᩮᨱ᩠ᨯ ᨾᩮᩈᩣ ᨧ, ᩏᩁᨱᩮᩣ ᩋᩅᩥ ᩑᩊᨠᩮᩣ.
ᩅᩔᩮᩣ ᨲ᩠ᩅᨩᩮᩣ ᨨᨣᩃᨠᩮᩣ,
ᩒᨭ᩠ᨮᩮᩣ ᨲᩩ ᨠᩁᨽᩮᩣ ᨽᩅᩮ;
ᨣᨴᩕᨽᩮᩣ ᨲᩩ ᨡᩁᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩏᩁᨱᩦ ᨲᩩ ᩋᨩᩦ ᩋᨩᩣ.
ᩍᨲᩥ ᩅᩮᩔᩅᨣ᩠ᨣᩮᩣ.
ᩈᩩᨴ᩠ᨴᩮᩣ’ᨶ᩠ᨲᩅᨱ᩠ᨱᩮᩣ ᩅᩈᩃᩮᩣ, ᩈᩴᨠᩥᨱ᩠ᨱᩣ ᨾᩣᨣᨵᩣᨴᨿᩮᩣ;
ᨾᩣᨣᨵᩮᩣ ᩈᩩᨴ᩠ᨴᨡᨲ᩠ᨲᩣᨩᩮᩣ, ᩏᨣ᩠ᨣᩮᩣ ᩈᩩᨴ᩠ᨴᩣᨿ ᨡᨲ᩠ᨲᨩᩮᩣ.
ᨴ᩠ᩅᩥᨩᩣᨡᨲ᩠ᨲᩥᨿᨩᩮᩣ ᩈᩪᨲᩮᩣ, ᨠᩣᩁᩩᨲᩩ ᩈᩥᨸ᩠ᨸᩥᨠᩮᩣᨸᩩᨾᩮ;
ᩈᨦ᩠ᨥᩣᨲᩮᩣᨲᩩ ᩈᨩᩣᨲᩦᨶᩴ, ᨲᩮᩈᩴ ᩈᩮᨱᩦ ᨴ᩠ᩅᩥᩈᩩᨧ᩠ᨧᨲᩮ.
ᨲᨧ᩠ᨨᨠᩮᩣ ᨲᨶ᩠ᨲᩅᩣᨿᩮᩣ ᨧ, ᩁᨩᨠᩮᩣ ᨧ ᨶᩉᩣᨸᩥᨲᩮᩣ;
ᨸᨬ᩠ᨧᨾᩮᩣ ᨧᨾ᩠ᨾᨠᩣᩁᩮᩣᨲᩥ, ᨠᩣᩁᩅᩮᩣ ᨸᨬ᩠ᨧᩥᨾᩮ ᩈᩥᨿᩩᩴ.
ᨲᨧ᩠ᨨᨠᩮᩣ ᩅᨯ᩠ᨰᨠᩦ ᨾᨲᩮᩣ, ᨸᩃᨣᨱ᩠ᨯᩮᩣ ᨳᨸᨲ᩠ᨿᨸᩥ;
ᩁᨳᨠᩣᩁᩮᩣ ᨳ ᩈᩩᩅᨱ᩠ᨱ, ᨠᩣᩁᩮᩣ ᨶᩣᩊᩥᨶ᩠ᨵᨾᩮᩣ ᨽᩅᩮ.
ᨲᨶ᩠ᨲᩅᩣᨿᩮᩣ ᨸᩮᩈᨠᩣᩁᩮᩣ,
ᨾᩣᩃᩣᨠᩣᩁᩮᩣ ᨲᩩ ᨾᩣᩃᩥᨠᩮᩣ;
ᨠᩩᨾ᩠ᨽᨠᩣᩁᩮᩣ ᨠᩩᩃᩣᩃᩮᩣ ᨳ,
ᨲᩩᨶ᩠ᨶᩅᩣᨿᩮᩣ ᨧ ᩈᩪᨧᩥᨠᩮᩣ.
ᨧᨾ᩠ᨾᨠᩣᩁᩮᩣ ᩁᨳᨠᩣᩁᩮᩣ, ᨠᨸ᩠ᨸᨠᩮᩣ ᨲᩩ ᨶᩉᩣᨸᩥᨲᩮᩣ;
ᩁᨦ᩠ᨣᩣᨩᩦᩅᩮᩣ ᨧᩥᨲ᩠ᨲᨠᩣᩁᩮᩣ, ᨸᩩᨠ᩠ᨠᩩᩈᩮᩣ ᨸᩩᨸ᩠ᨹᨨᨯ᩠ᨯᨠᩮᩣ.
ᩅᩮᨶᩮᩣ ᩅᩥᩃᩦᩅᨠᩣᩁᩮᩣ ᨧ, ᨶᩊᨠᩣᩁᩮᩣ ᩈᨾᩣ ᨲᨿᩮᩣ;
ᨧᩩᨶ᩠ᨴᨠᩣᩁᩮᩣ ᨽᨾᨠᩣᩁᩮᩣ,
ᨠᨾ᩠ᨾᩣᩁᩮᩣ ᩃᩮᩣᩉᨠᩣᩁᨠᩮᩣ.
ᨶᩥᨶ᩠ᨶᩮᨩᨠᩮᩣ ᨧ ᩁᨩᨠᩮᩣ, ᨶᩮᨲ᩠ᨲᩥᨠᩮᩣ ᩏᨴᩉᩣᩁᨠᩮᩣ;
ᩅᩦᨱᩣᩅᩣᨴᩦ ᩅᩮᨱᩥᨠᩮᩣ ᨳ, ᩏᩈᩩᨠᩣᩁᩮᩣ’ ᩈᩩᩅᨯ᩠ᨰᨠᩦ.
ᩅᩮᨱᩩᨵᨾᩮᩣ ¶ ᩅᩮᨱᩅᩥᨠᩮᩣ,
ᨸᩣᨱᩥᩅᩣᨴᩮᩣ ᨲᩩ ᨸᩣᨱᩥᨥᩮᩣ [ᨸᩣᨱᩥᨿᩮᩣ (ᨠᨲ᩠ᨳᨧᩥ)];
ᨸᩪᨸᩥᨿᩮᩣ ᨸᩪᨸᨸᨱᩥᨿᩮᩣ, ᩈᩮᩣᨱ᩠ᨯᩥᨠᩮᩣ ᨾᨩ᩠ᨩᩅᩥᨠ᩠ᨠᨿᩦ.
ᨾᩣᨿᩣ ᨲᩩ ᩈᨾ᩠ᨻᩁᩦ ᨾᩣᨿᩣ, ᨠᩣᩁᩮᩣ ᨲᩩ ᩍᨶ᩠ᨴᨩᩣᩃᩥᨠᩮᩣ;
ᩒᩁᨻ᩠ᨽᩥᨠᩣ ᩈᩪᨠᩁᩥᨠᩣ, ᨾᩣᨣᩅᩥᨠᩣ ᨲᩮ ᨧ ᩈᩣᨠᩩᨱᩥᨠᩣ;
ᩉᨶ᩠ᨲ᩠ᩅᩣ ᨩᩦᩅᨶ᩠ᨲᩮ’ᩊᨠ, ᩈᩪᨠᩁ, ᨾᩥᨣ, ᨸᨠ᩠ᨡᩥᨶᩮᩣ ᨠᨾᨲᩮᩣ.
ᩅᩣᨣᩩᩁᩥᨠᩮᩣ ᨩᩣᩃᩥᨠᩮᩣ ᨳ,
ᨽᩣᩁᩅᩣᩉᩮᩣ ᨲᩩ ᨽᩣᩁᩥᨠᩮᩣ;
ᩅᩮᨲᨶᩥᨠᩮᩣ ᨲᩩ ᨽᨲᨠᩮᩣ, ᨠᨾ᩠ᨾᨠᩁᩮᩣ ᨳ ᨠᩥᩴ ᨠᩁᩮᩣ;
ᨴᩣᩈᩮᩣ ᨧ ᨧᩮᨭᨠᩮᩣ ᨸᩮᩔᩮᩣ, ᨽᨧ᩠ᨧᩮᩣ ᨧ ᨸᩁᩥᨧᩣᩁᩥᨠᩮᩣ.
ᩋᨶ᩠ᨲᩮᩣᨩᩣᨲᩮᩣ ᨵᨶᨠ᩠ᨠᩦᨲᩮᩣ, ᨴᩣᩈᨻ᩠ᨿᩮᩣ’ᨸᨣᨲᩮᩣ ᩈᨿᩴ;
ᨴᩣᩈᩣ ᨠᩁᨾᩁᩣᨶᩦᨲᩮᩣ, ᨧ᩠ᨧᩮᩅᩴ ᨲᩮ ᨧᨲᩩᨵᩣ ᩈᩥᨿᩩᩴ.
ᩋᨴᩣᩈᩮᩣ ᨲᩩ ᨽᩩᨩᩥᩔᩮᩣ ᨳ,
ᨶᩦᨧᩮᩣ ᨩᨾ᩠ᨾᩮᩣ ᨶᩥᩉᩦᨶᨠᩮᩣ;
ᨶᩥᨠ᩠ᨠᩮᩣᩈᨩ᩠ᨩᩮᩣ ᩋᨠᩥᩃᩣᩈᩩ,
ᨾᨶ᩠ᨴᩮᩣ ᨲᩩ ᩋᩃᩈᩮᩣ ᨸ᩠ᨿᨳ.
ᩈᨸᩣᨠᩮᩣ ᨧᩮᩅ ᨧᨱ᩠ᨯᩣᩃᩮᩣ, ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᩈᨸᨧᩮᩣ ᨽᩅᩮ;
ᨲᨻ᩠ᨽᩮᨴᩣ ᨾᩥᩃᨠ᩠ᨡᨩᩣᨲᩦ, ᨠᩥᩁᩣᨲ, ᩈᩅᩁᩣᨴᨿᩮᩣ.
ᨶᩮᩈᩣᨴᩮᩣ ᩃᩩᨴ᩠ᨴᨠᩮᩣ ᨻ᩠ᨿᩣᨵᩮᩣ,
ᨾᩥᨣᩅᩮᩣ ᨲᩩ ᨾᩥᨣᨻ᩠ᨿᨵᩮᩣ;
ᩈᩣᩁᨾᩮᨿ᩠ᨿᩮᩣ ᨧ ᩈᩩᨶᨡᩮᩣ, ᩈᩩᨶᩮᩣ ᩈᩮᩣᨱᩮᩣ ᨧ ᨠᩩᨠ᩠ᨠᩩᩁᩮᩣ.
ᩈ᩠ᩅᩣᨶᩮᩣ ᩈᩩᩅᩣᨶᩮᩣ ᩈᩣᩊᩪᩁᩮᩣ,
ᩈᩪᨶᩮᩣ ᩈᩣᨶᩮᩣ ᨧ ᩈᩣ ᨸᩩᨾᩮ;
ᩏᨾ᩠ᨾᨲ᩠ᨲᩣᨴᩥᨲ ᨾᩣᨸᨶ᩠ᨶᩮᩣ, ᩋᩊᨠ᩠ᨠᩮᩣᨲᩥ ᩈᩩᨶᩮᩣ ᨾᨲᩮᩣ.
ᩈᩣᨻᨶ᩠ᨵᨶᩴ ᨲᩩ ᨣᨴ᩠ᨴᩪᩃᩮᩣ, ᨴᩦᨸᨠᩮᩣ ᨲᩩ ᨧ ᨧᩮᨲᨠᩮᩣ;
ᨻᨶ᩠ᨵᨶᩴ ᨣᨱ᩠ᨮᩥ ᨸᩣᩈᩮᩣ ᨳ, ᩅᩣᨣᩩᩁᩣ [ᩅᩣᨠᩁᩣ (ᩈᩦ. ᨭᩦ.)] ᨾᩥᨣᨻᨶ᩠ᨵᨶᩦ.
ᨳᩥᨿᩴ ᨠᩩᩅᩮᨱᩦ ᨠᩩᨾᩦᨶᩴ, ᩌᨶᨿᩮᩣ ᨩᩣᩃ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᩌᨥᩣᨲᨶᩴ ᩅᨵᨭ᩠ᨮᩣᨶᩴ, ᩈᩪᨶᩣ ᨲᩩ ᩋᨵᩥᨠᩮᩣᨭ᩠ᨭᨶᩴ.
ᨲᨠ᩠ᨠᩁᩮᩣ ¶ ᨾᩮᩣᩈᨠᩮᩣ ᨧᩮᩣᩁᩮᩣ,
ᨳᩮᨶᩮ’ᨠᩣᨣᩣᩁᩥᨠᩮᩣ ᩈᨾᩣ;
ᨳᩮᨿ᩠ᨿᨬ᩠ᨧ ᨧᩮᩣᩁᩥᨠᩣ ᨾᩮᩣᩈᩮᩣ,
ᩅᩮᨾᩮᩣ ᩅᩣᨿᨶᨴᨱ᩠ᨯᨠᩮᩣ.
ᩈᩩᨲ᩠ᨲᩴ ᨲᨶ᩠ᨲᩩ ᨸᩩᨾᩮ ᨲᨶ᩠ᨲᩴ, ᨸᩮᩣᨲ᩠ᨳᩴ ᩃᩮᨸ᩠ᨿᩣᨴᩥᨠᨾ᩠ᨾᨶᩥ;
ᨸᨬ᩠ᨧᩣᩃᩥᨠᩣ ᨸᩮᩣᨲ᩠ᨳᩃᩥᨠᩣ, ᩅᨲ᩠ᨳᨴᨶ᩠ᨲᩣᨴᩥᨶᩥᨾ᩠ᨾᩥᨲᩣ.
ᩏᨣ᩠ᨥᩣᨭᨶᩴ ᨥᨭᩦᨿᨶ᩠ᨲᩴ, ᨠᩪᨸᨾ᩠ᨻᩩᨻ᩠ᨻᩣᩉᨶᩴ ᨽᩅᩮ;
ᨾᨬ᩠ᨩᩪᩈᩣ ᨸᩮᩊᩣ ᨸᩥᨭᨠᩮᩣ, ᨲ᩠ᩅᩥᨲ᩠ᨳᩥᨿᩴ ᨸᨧ᩠ᨨᩥ ᨸᩮᨭᨠᩮᩣ.
ᨻ᩠ᨿᩣᨽᨦ᩠ᨣᩦ ᨲ᩠ᩅᩥᨲ᩠ᨳᩥᨿᩴ ᨠᩣᨩᩮᩣ, ᩈᩥᨠ᩠ᨠᩣ ᨲ᩠ᩅᨲᩕᩣ’ᩅᩃᨾ᩠ᨻᨶᩴ;
ᩏᨸᩣᩉᨶᩮᩣ ᩅᩣ ᨸᩣᨴᩩ’ᨲ᩠ᨳᩦ, ᨲᨻ᩠ᨽᩮᨴᩣ ᨸᩣᨴᩩᨠᩣ ᨸ᩠ᨿᨳ.
ᩅᩁᨲ᩠ᨲᩣ ᩅᨴ᩠ᨵᩥᨠᩣ ᨶᨴ᩠ᨵᩥ, ᨽᩈ᩠ᨲᩣ ᨧᨾ᩠ᨾᨸᩈᩥᨻ᩠ᨻᨠᩴ;
ᩈᩮᩣᨱ᩠ᨱᩣᨴ᩠ᨿᩣᩅᨲ᩠ᨲᨶᩦ ᨾᩪᩈᩣ,
ᨳ ᨠᩪᨭᩴ ᩅᩣ ᩋᨿᩮᩣᨥᨶᩮᩣ.
ᨠᨾ᩠ᨾᩣᩁᨽᨱ᩠ᨯᩣ ᩈᨱ᩠ᨯᩣᩈᩮᩣ, ᨾᩩᨭ᩠ᨮ᩠ᨿᩣ’ᨵᩥᨠᩁᨱᩦᨲ᩠ᨳᩦᨿᩴ;
ᨲᨻ᩠ᨽᩈ᩠ᨲᩣ ᨣᨣ᩠ᨣᩁᩦ ᨶᩣᩁᩦ, ᩈᨲ᩠ᨲᩴ ᨲᩩ ᨸᩥᨸ᩠ᨹᩃᩴ ᨽᩅᩮ.
ᩈᩣᨱᩮᩣ ᨲᩩ ᨶᩥᨠᩈᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ,
ᩌᩁᩣ ᨲᩩ ᩈᩪᨧᩥᩅᩥᨩ᩠ᨫᨶᩴ;
ᨡᩁᩮᩣ ᨧ ᨠᨠᨧᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩈᩥᨸ᩠ᨸᩴ ᨠᨾ᩠ᨾᩴ ᨠᩃᩣᨴᩥᨠᩴ.
ᨸᨭᩥᨾᩣ ᨸᨭᩥᨻᩥᨾ᩠ᨻᨬ᩠ᨧ, ᨻᩥᨾ᩠ᨻᩮᩣ ᨸᨭᩥᨶᩥᨵᩦᩁᩥᨲᩮᩣ;
ᨲᩦᩈᩩ ᩈᨾᩮᩣ ᨸᨭᩥᨽᩣᨣᩮᩣ, ᩈᨶ᩠ᨶᩥᨠᩣᩈᩮᩣ ᩈᩁᩥᨠ᩠ᨡᨠᩮᩣ.
ᩈᨾᩣᨶᩮᩣ ᩈᨴᩥᩈᩮᩣ ᨲᩩᩃ᩠ᨿᩮᩣ,
ᩈᨦ᩠ᨠᩣᩈᩮᩣ ᩈᨶ᩠ᨶᩥᨽᩮᩣ ᨶᩥᨽᩮᩣ;
ᩒᨸᨾ᩠ᨾ ᨾᩩᨸᨾᩣᨶᩴ ᨧᩩ, ᨸᨾᩣ ᨽᨲᩥ ᨲᩩ ᨶᩣᩁᩥᨿᩴ.
ᨶᩥᨻ᩠ᨻᩮᩈᩮᩣ ᩅᩮᨲᨶᩴ ᨾᩪᩃ᩠ᨿᩴ, ᨩᩪᨲᩴ ᨲ᩠ᩅᨶᩥᨲ᩠ᨳᩥ ᨠᩮᨲᩅᩴ;
ᨵᩩᨲ᩠ᨲᩮᩣ’ᨠ᩠ᨡᨵᩩᨲ᩠ᨲᩮᩣ ᨠᩥᨲᩅᩮᩣ, ᨩᩪᨲᨠᩣᩁ, ᨠ᩠ᨡᨴᩮᩅᩥᨶᩮᩣ.
ᨸᩣᨭᩥᨽᩮᩣᨣᩮᩣᨲᩩ ᨸᨭᩥᨽᩪ, ᩋᨠ᩠ᨡᩮᩣ ᨲᩩ ᨸᩣᩈᨠᩮᩣ ᨽᩅᩮ;
ᨸᩩᨾᩮᩅᩣ’ ᨭ᩠ᨮᨸᨴᩴ [ᩋᨭ᩠ᨮᩣᨸᨴᩴ (ᨭᩦ. ᩈᩦ.)] ᩈᩣᩁᩥ, ᨹᩃᨠᩮ ᨳ ᨸᨱᩮᩣ, ᨻ᩠ᨽᩩᨲᩮᩣ.
ᨠᩥᨱ᩠ᨱᩴ ¶ ᨲᩩ ᨾᨴᩥᩁᩣᨻᩦᨩᩮ, ᨾᨵᩩ ᨾᨵ᩠ᩅᩣᩈᩅᩮ ᨾᨲᩴ;
ᨾᨴᩥᩁᩣ ᩅᩣᩁᩩᨱᩦ ᨾᨩ᩠ᨩᩴ, ᩈᩩᩁᩣ ᨽᩅᩮᩣ ᨲᩩ ᨾᩮᩁᨿᩴ.
ᩈᩁᨠᩮᩣ ᨧᩈᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩌᨸᩣᨶᩴ ᨸᩣᨶᨾᨱ᩠ᨯᩃᩴ;
ᨿᩮ’ᨲᩕ ᨽᩪᩁᩥᨸ᩠ᨸᨿᩮᩣᨣᨲ᩠ᨲᩣ, ᨿᩮᩣᨣᩥᨠᩮᨠᩈ᩠ᨾᩥ ᨾᩦᩁᩥᨲᩣ;
ᩃᩥᨦ᩠ᨣᨶ᩠ᨲᩁᩮᨸᩥ ᨲᩮ ᨬᩮᨿ᩠ᨿᩣ, ᨲᨴ᩠ᨵᨾ᩠ᨾᨲ᩠ᨲᩣ’ᨬ᩠ᨬᩅᩩᨲ᩠ᨲᩥᨿᨶ᩠ᨲᩥ.
ᩍᨲᩥ ᩈᩩᨴ᩠ᨴᩅᨣ᩠ᨣᩮᩣ.
ᨧᨲᩩᨻ᩠ᨻᨱ᩠ᨱᩅᨣ᩠ᨣᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.
᪕. ᩋᩁᨬ᩠ᨬᩅᨣ᩠ᨣ
ᩋᩁᨬ᩠ᨬᩴ ᨠᩣᨶᨶᩴ ᨴᩣᨿᩮᩣ, ᨣᩉᨶᩴ ᩅᩥᨸᩥᨶᩴ ᩅᨶᩴ;
ᩋᨭᩅᩦ’ᨲ᩠ᨳᩦ ᨾᩉᩣᩁᨬ᩠ᨬᩴ, ᨲ᩠ᩅ, ᩁᨬ᩠ᨬᩣᨶᩦᨲ᩠ᨳᩥᨿᩴ ᨽᩅᩮ.
ᨶᨣᩁᩣ ᨶᩣᨲᩥᨴᩪᩁᩈ᩠ᨾᩥᩴ, ᩈᨶ᩠ᨲᩮᩉᩥ ᨿᩮᩣ ᨽᩥᩁᩮᩣᨸᩥᨲᩮᩣ;
ᨲᩁᩩᩈᨱ᩠ᨯᩮᩣ ᩈ ᩌᩁᩣᨾᩮᩣ, ᨲᨳᩮᩣ ᨸᩅᨶ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩈᨻ᩠ᨻᩈᩣᨵᩣᩁᨱᩣ’ᩁᨬ᩠ᨬᩴ, ᩁᨬ᩠ᨬ ᨾᩩᨿ᩠ᨿᩣᨶ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨬᩮᨿ᩠ᨿᩴ ᨲᨴᩮᩅ ᨸᨾᨴ, ᩅᨶ ᨾᨶ᩠ᨲᩮᨸᩩᩁᩮᩣᨧᩥᨲᩴ.
ᨸᨶ᩠ᨲᩥ ᩅᩦᨳ᩠ᨿᩣ’ᩅᩃᩥ ᩈᩮᨱᩦ, ᨸᩣᩊᩥ ᩃᩮᨡᩣ ᨲᩩ ᩁᩣᨩᩥ ᨧ;
ᨸᩣᨴᨸᩮᩣ ᩅᩥᨭᨸᩦ ᩁᩩᨠ᩠ᨡᩮᩣ, ᩋᨣᩮᩣ ᩈᩣᩃᩮᩣ ᨾᩉᩦᩁᩩᩉᩮᩣ.
ᨴᩩᨾᩮᩣ ᨲᩁᩩ ᨠᩩᨩᩮᩣ ᩈᩣᨡᩦ, ᨣᨧ᩠ᨨᩮᩣ ᨲᩩ ᨡᩩᨴ᩠ᨴᨸᩣᨴᨸᩮᩣ;
ᨹᩃᨶ᩠ᨲᩥ ᨿᩮ ᩅᩥᨶᩣ ᨸᩩᨸ᩠ᨹᩴ, ᨲᩮ ᩅᩩᨧ᩠ᨧᨶ᩠ᨲᩥ ᩅᨶᨸ᩠ᨸᨲᩦ.
ᨹᩃᨸᩣᨠᩣᩅᩈᩣᨶᩮ ᨿᩮᩣ,
ᨾᩁᨲ᩠ᨿᩮᩣ ᩈᨵᩥ ᩈᩣ ᨽᩅᩮ;
ᨲᩦᩈᩩ ᩅᨬ᩠ᨧ᩠ᨿᩣ’ᨹᩃᩣ ᨧᩣᨳ, ᨹᩃᩥᨶᩮᩣ ᨹᩃᩅᩣ ᨹᩃᩦ.
ᩈᨾ᩠ᨹᩩᩃ᩠ᩃᩥᨲᩮᩣ ᨲᩩ ᩅᩥᨠᨧᩮᩣ, ᨹᩩᩃ᩠ᩃᩮᩣ ᩅᩥᨠᩈᩥᨲᩮᩣ ᨲᩥᩈᩩ;
ᩈᩥᩁᩮᩣ’ᨣ᩠ᨣᩴ ᩈᩥᨡᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩈᩣᨡᩣ ᨲᩩ ᨠᨳᩥᨲᩣ ᩃᨲᩣ.
ᨴᩃᩴ ᨸᩃᩣᩈᩴ ᨨᨴᨶᩴ, ᨸᨱ᩠ᨱᩴ ᨸᨲ᩠ᨲᩴ ᨨᨴᩮᩣ ᨸ᩠ᨿᨳ;
ᨸᩃ᩠ᩃᩅᩮᩣ ᩅᩣ ᨠᩥᩈᩃᨿᩴ, ᨶᩅᩩᨻ᩠ᨽᩥᨶ᩠ᨶᩮ ᨲᩩ ᩋᨦ᩠ᨠᩩᩁᩮᩣ.
ᨾᨠᩩᩃᩴ ᩅᩣ ᨠᩩᨭᩩᨾᩃᩮᩣ, ᨡᩣᩁᨠᩮᩣ ᨲᩩ ᨧ ᨩᩣᩃᨠᩴ;
ᨠᩃᩥᨠᩣ ᨠᩮᩣᩁᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᩅᨱ᩠ᨭᩴ ᨸᩩᨸ᩠ᨹᩣᨴᩥᨻᨶ᩠ᨵᨶᩴ.
ᨸᩈᩅᩮᩣ ¶ ᨠᩩᩈᩩᨾᩴ ᨸᩩᨸ᩠ᨹᩴ, ᨸᩁᩣᨣᩮᩣ ᨸᩩᨸ᩠ᨹᨩᩮᩣ ᩁᨩᩮᩣ;
ᨾᨠᩁᨶ᩠ᨴᩮᩣ ᨾᨵᩩ ᨾᨲᩴ, ᨳᩅᨠᩮᩣ ᨲᩩ ᨧ ᨣᩮᩣᨧ᩠ᨨᨠᩮᩣ.
ᨹᩃᩮ ᨲ᩠ᩅᩣ’ᨾᩮ ᩈᩃᩣᨭᩩ’ᨲ᩠ᨲᩮᩣ,
ᨹᩃᩴ ᨲᩩ ᨸᨠ᩠ᨠ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨧᨾ᩠ᨸᨠ’ᨾ᩠ᨻᩣᨴᩥᨠᩩᩈᩩᨾ, ᨹᩃᨶᩣᨾᩴ ᨶᨸᩩᩴᩈᨠᩮ.
ᨾᩃ᩠ᩃᩥᨠᩣᨴᩦ ᨲᩩ ᨠᩩᩈᩩᨾᩮ, ᩈᩃᩥᨦ᩠ᨣᩣ ᩅᩦᩉᨿᩮᩣ ᨹᩃᩮ;
ᨩᨾ᩠ᨻᩪ’ᨲ᩠ᨳᩦ ᨩᨾ᩠ᨻᩅᩴ ᨩᨾ᩠ᨻᩪ, ᩅᩥᨭᨸᩮᩣ ᩅᩥᨭᨽᩦ’ᨲ᩠ᨳᩥᨿᩴ.
ᨾᩪᩃ ᨾᩣᩁᨻ᩠ᨽ ᩈᩣᨡᨶ᩠ᨲᩮᩣ, ᨡᨶ᩠ᨵᩮᩣ ᨽᩣᨣᩮᩣ ᨲᩁᩩᩔ ᨳ;
ᨠᩮᩣᨭᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᩁᩩᨠ᩠ᨡ, ᨧ᩠ᨨᩥᨴ᩠ᨴᩮ ᨠᨭ᩠ᨮᩴ ᨲᩩ ᨴᩣᩁᩩ ᨧ.
ᨻᩩᨶ᩠ᨴᩮᩣ ᨾᩪᩃᨬ᩠ᨧ ᨸᩣᨴᩮᩣ ᨳ, ᩈᨦ᩠ᨠᩩ’ᨲ᩠ᨲᩮᩣ ᨡᩣᨱᩩᨶᩥᨲ᩠ᨳᩥᨿᩴ;
ᨠᩁᩉᩣᨭᩴ ᨲᩩ ᨠᨶ᩠ᨴᩮᩣ ᨳ, ᨠᩊᩦᩁᩮᩣ ᨾᨲ᩠ᨳᨠᩮᩣ ᨽᩅᩮ.
ᩅᩃ᩠ᩃᩁᩦ ᨾᨬ᩠ᨩᩁᩦ ᨶᩣᩁᩦ, ᩅᩃ᩠ᩃᩦ ᨲᩩ ᨠᨳᩥᨲᩣ ᩃᨲᩣ;
ᨳᨾ᩠ᨽᩮᩣ ᨣᩩᨾ᩠ᨻᩮᩣ ᨧ ᩋᨠ᩠ᨡᨶ᩠ᨵᩮ, ᩃᨲᩣ ᩅᩥᩁᩪ ᨸᨲᩣᨶᩥᨶᩦ.
ᩋᩔᨲ᩠ᨳᩮᩣ ᨻᩮᩣᨵᩥ ᨧ ᨴ᩠ᩅᩦᩈᩩ, ᨶᩥᨣᩕᩮᩣᨵᩮᩣ ᨲᩩ ᩅᨭᩮᩣ ᨽᩅᩮ;
ᨠᨻᩥᨭ᩠ᨮᩮᩣ ᨧ ᨠᨸᩥᨲ᩠ᨳᩮᩣ ᨧ, ᨿᨬ᩠ᨬᨦ᩠ᨣᩮᩣ ᨲᩩ ᩏᨴᩩᨾ᩠ᨻᩁᩮᩣ.
ᨠᩮᩣᩅᩥᩊᩣᩁᩮᩣ ᨿᩩᨣᨸᨲ᩠ᨲᩮᩣ, ᩏᨴ᩠ᨴᩣᩃᩮᩣ ᩅᩣᨲᨥᩣᨲᨠᩮᩣ;
ᩁᩣᨩᩁᩩᨠ᩠ᨡᩮᩣ ᨠᨲᨾᩣᩃᩦ, ᨶ᩠ᨴᩦᩅᩁᩮᩣ ᨻ᩠ᨿᩣᨵᩥᨥᩣᨲᨠᩮᩣ.
ᨴᨶ᩠ᨲᩈᨮᩮᩣ ᨧ ᨩᨾ᩠ᨽᩦᩁᩮᩣ, ᩅᩁᨱᩮᩣ ᨲᩩ ᨠᩁᩮᩁᩥ ᨧ;
ᨠᩥᩴ ᩈᩩᨠᩮᩣ ᨸᩣᩃᩥᨽᨴ᩠ᨴᩮᩣᨳ, ᩅᨬ᩠ᨩᩩᩃᩮᩣ ᨲᩩ ᨧ ᩅᩮᨲᩈᩮᩣ.
ᩋᨾ᩠ᨻᩣᨭᨠᩮᩣᨸᩦᨲᨶᨠᩮᩣ, ᨾᨵᩩᨠᩮᩣ ᨲᩩ ᨾᨵᩩᨴ᩠ᨴᩩᨾᩮᩣ;
ᩋᨳᩮᩣ ᨣᩩᩊᨹᩃᩮᩣ ᨸᩦᩃᩩ, ᩈᩮᩣᨽᨬ᩠ᨩᨶᩮᩣ ᨧ ᩈᩥᨣ᩠ᨣᩩ ᨧ.
ᩈᨲ᩠ᨲᨸᨱ᩠ᨱᩥ ᨨᨲ᩠ᨲᨸᨱ᩠ᨱᩮᩣ, ᨲᩥᨶᩥᩈᩮᩣ ᨲ᩠ᩅ ᨲᩥᨾᩩᨲ᩠ᨲᨠᩮᩣ;
ᨠᩥᩴ ᩈᩩᨠᩮᩣ ᨲᩩ ᨸᩃᩣᩈᩮᩣ ᨳ,
ᩋᩁᩥᨭ᩠ᨮᩮᩣ ᨹᩮᨶᩥᩃᩮᩣ ᨽᩅᩮ.
ᨾᩣᩃᩪᩁ ᨻᩮᩃᩩᩅᩣᨻᩥᩃ᩠ᩃᩮᩣ, ᨸᩩᨶ᩠ᨶᩣᨣᩮᩣ ᨲᩩ ᨧ ᨠᩮᩈᩁᩮᩣ;
ᩈᩣᩃᩅᩮᩣ ᨲᩩ ᨧ ᩃᩮᩣᨴ᩠ᨴᩮᩣ ᨳ, ᨸᩥᨿᩣᩃᩮᩣ ᩈᨶ᩠ᨶᨠᨴ᩠ᨴᩩ ᨧ.
ᩃᩥᨠᩮᩣᨧᨠᩮᩣ ᨲᨳᩣ’ᨦ᩠ᨠᩮᩣᩃᩮᩣ,
ᩋᨳ ᨣᩩᨣ᩠ᨣᩩᩃᩩ ᨠᩮᩣᩈᩥᨠᩮᩣ;
ᩋᨾ᩠ᨻᩮᩣ ᨧᩪᨲᩮᩣ ᩈᩉᩮᩣ ᨲ᩠ᩅᩮᩈᩮᩣ,
ᩈᩉᨠᩣᩁᩮᩣ ᩈᩩᨣᨶ᩠ᨵᩅᩣ.
ᨸᩩᨱ᩠ᨯᩁᩦᨠᩮᩣ ¶ ᨧ ᩈᩮᨲᨾ᩠ᨻᩮᩣ, ᩈᩮᩃᩩ ᨲᩩ ᨻᩉᩩᩅᩣᩁᨠᩮᩣ;
ᩈᩮᨸᨱ᩠ᨱᩦ ᨠᩣᩈ᩠ᨾᩥᩁᩦ ᨧᩣᨳ, ᨠᩮᩣᩃᩦ ᨧ ᨻᨴᩁᩦᨲ᩠ᨳᩥᨿᩴ.
ᨠᩮᩣᩃᩴ ᨧᩣᨶᩥᨲ᩠ᨳᩦ ᨻᨴᩁᩮᩣ, ᨸᩥᩃᨠ᩠ᨡᩮᩣ ᨸᩥᨸ᩠ᨸᩃᩦ’ᨲ᩠ᨳᩥᨿᩴ;
ᨸᩣᨭᩃᩦ ᨠᨱ᩠ᩉᩅᨶ᩠ᨲᩣ ᨧ, ᩈᩣᨴᩩᨠᨱ᩠ᨭᩮᩣ ᩅᩥᨠᨦ᩠ᨠᨲᩮᩣ.
ᨲᩥᨶ᩠ᨴᩩᨠᩮᩣ ᨠᩣᩊᨠ᩠ᨡᨶ᩠ᨵᩮᩣ ᨧ, ᨲᩥᨾ᩠ᨻᩁᩪᩈᨠ ᨲᩥᨾ᩠ᨻᩁᩪ;
ᩑᩁᩣᩅᨲᩮᩣ ᨲᩩ ᨶᩣᩁᨦ᩠ᨣᩮᩣ, ᨠᩩᩃᨠᩮᩣ ᨠᩣᨠᨲᩥᨶ᩠ᨴᩩᨠᩮᩣ.
ᨠᨴᨾ᩠ᨻᩮᩣ ᨸᩥᨿᨠᩮᩣ ᨶᩦᨸᩮᩣ, ᨽᩃ᩠ᩃᩦ ᨽᩃ᩠ᩃᩣᨲᨠᩮᩣ ᨲᩥᩈᩩ;
ᨫᩣᩅᩩᨠᩮᩣ ᨸᩥᨧᩩᩃᩮᩣ ᨧᩣᨳ, ᨲᩥᩃᨠᩮᩣ ᨡᩩᩁᨠᩮᩣ ᨽᩅᩮ.
ᨧᩥᨬ᩠ᨧᩣ ᨧ ᨲᩥᨶ᩠ᨲᩥᨱᩦ ᨧᩣᨳ, ᨣᨴ᩠ᨴᨽᨱ᩠ᨯᩮᩣ ᨠᨸᩦᨲᨶᩮᩣ;
ᩈᩣᩃᩮᩣ’ᩔᨠᨱ᩠ᨱᩮᩣ ᩈᨩ᩠ᨩᩮᩣ ᨳ,
ᩋᨩ᩠ᨩᩩᨶᩮᩣ ᨠᨠᩩᨵᩮᩣ ᨽᩅᩮ.
ᨶᩥᨧᩩᩃᩮᩣ ᨾᩩᨧᩃᩥᨶ᩠ᨴᩮᩣ ᨧ, ᨶᩦᨸᩮᩣ ᨳ ᨸᩥᨿᨠᩮᩣ ᨲᨳᩣ;
ᩋᩈᨶᩮᩣ ᨸᩦᨲᩈᩣᩃᩮᩣ ᨳ,
ᨣᩮᩣᩃᩦᩈᩮᩣ ᨫᩣᨭᩃᩮᩣ ᨽᩅᩮ.
ᨡᩦᩁᩥᨠᩣ ᩁᩣᨩᩣᨿᨲᨶᩴ, ᨠᩩᨾ᩠ᨽᩦ ᨠᩩᨾᩩᨴᩥᨠᩣ ᨽᩅᩮ;
ᨿᩪᨸᩮᩣ [ᨸᩪᨣᩮᩣ (ᨠ.)] ᨲᩩ ᨠᨾᩩᨠᩮᩣ ᨧᩣᨳ, ᨸᨭ᩠ᨭᩥ ᩃᩣᨡᩣᨸᩈᩣᨴᨶᩮᩣ.
ᩍᨦ᩠ᨣᩩᨴᩦ ᨲᩣᨸᩈᨲᩁᩩ, ᨽᩩᨩᨸᨲ᩠ᨲᩮᩣ ᨲᩩ ᩌᨽᩩᨩᩦ;
ᨸᩥᨧ᩠ᨨᩥᩃᩣ ᩈᩥᨾ᩠ᨻᩃᩦ ᨴ᩠ᩅᩦᩈᩩ, ᩁᩮᩣᨧᨶᩮᩣ ᨠᩮᩣᨭᩈᩥᨾ᩠ᨻᩃᩦ.
ᨸᨠᩥᩁᩥᨿᩮᩣ ᨸᩪᨲᩥᨠᩮᩣ ᨳ, ᩁᩮᩣᩉᩦ ᩁᩮᩣᩉᩥᨲᨠᩮᩣ ᨽᩅᩮ;
ᩑᩁᨱ᩠ᨯᩮᩣ ᨲᩩ ᨧ ᩌᨾᨱ᩠ᨯᩮᩣ, ᩋᨳ ᩈᨲ᩠ᨲᩩᨹᩃᩣ ᩈᨾᩦ.
ᨶᨲ᩠ᨲᨾᩣᩃᩮᩣ ᨠᩁᨬ᩠ᨩᩮᩣ ᨳ, ᨡᨴᩥᩁᩮᩣ ᨴᨶ᩠ᨲᨵᩣᩅᨶᩮᩣ;
ᩈᩮᩣᨾᩅᨠ᩠ᨠᩮᩣ ᨲᩩ ᨠᨴᩁᩮᩣ, ᩈᩃ᩠ᩃᩮᩣᨲᩩ ᨾᨴᨶᩮᩣ ᨽᩅᩮ.
ᩋᨳᩣᨸᩥ ᩍᨶ᩠ᨴᩈᩣᩃᩮᩣ ᨧ, ᩈᩃ᩠ᩃᨠᩦ ᨡᩣᩁᨠᩮᩣ ᩈᩥᨿᩣ;
ᨴᩮᩅᨴᩣᩁᩩ ᨽᨴ᩠ᨴᨴᩣᩁᩩ, ᨧᨾ᩠ᨸᩮᨿ᩠ᨿᩮᩣ ᨲᩩ ᨧ ᨧᨾ᩠ᨸᨠᩮᩣ.
ᨸᨶᩈᩮᩣ ᨠᨱ᩠ᨭᨠᩥᨹᩃᩮᩣ, ᩋᨽᨿᩣ ᨲᩩ ᩉᩁᩦᨲᨠᩦ;
ᩋᨠ᩠ᨡᩮᩣ ᩅᩥᨽᩦᨲᨠᩮᩣ ᨲᩦᩈᩩ, ᩋᨾᨲᩣ’ᨾᩃᨠᩦ ᨲᩥᩈᩩ.
ᩃᨻᩩᨩᩮᩣ ᩃᩥᨠᩩᨧᩮᩣ ᨧᩣᨳ, ᨠᨱᩥᨠᩣᩁᩮᩣ ᨴᩩᨾᩩᨸ᩠ᨸᩃᩮᩣ;
ᨶᩥᨾ᩠ᨻᩮᩣ’ᩁᩥᨭ᩠ᨮᩮᩣ ᨸᩩᨧᩥᨾᨶ᩠ᨴᩮᩣ, ᨠᩁᨠᩮᩣ ᨲᩩ ᨧ ᨴᩣᩊᩥᨾᩮᩣ.
ᩈᩁᩃᩮᩣ ¶ ᨸᩪᨲᩥᨠᨭ᩠ᨮᨬ᩠ᨧ, ᨠᨸᩥᩃᩣ ᨲᩩ ᨧ ᩈᩥᩴᩈᨸᩣ;
ᩈᩣᨾᩣ ᨸᩥᨿᨦ᩠ᨣᩩ ᨠᨦ᩠ᨣᩩᨸᩥ, ᩈᩥᩁᩦᩈᩮᩣ ᨲᩩ ᨧ ᨽᨱ᩠ᨯᩥᩃᩮᩣ.
ᩈᩮᩣᨱᨠᩮᩣ ᨴᩦᨥᩅᨶ᩠ᨲᩮᩣ ᨧ,
ᩅᨠᩩᩃᩮᩣ ᨲᩩ ᨧ ᨠᩮᩈᩁᩮᩣ;
ᨠᩣᨠᩮᩣᨴᩩᨾ᩠ᨻᩁᩥᨠᩣ ᨹᩮᨣ᩠ᨣᩩ, ᨶᩣᨣᩮᩣ ᨲᩩ ᨶᩣᨣᨾᩣᩃᩥᨠᩣ.
ᩋᩈᩮᩣᨠᩮᩣ ᩅᨬ᩠ᨩᩩᩃᩮᩣ ᨧᩣᨳ, ᨲᨠ᩠ᨠᩣᩁᩦ ᩅᩮᨩᨿᨶ᩠ᨲᩥᨠᩣ;
ᨲᩣᨸᩥᨬ᩠ᨨᩮᩣ ᨧ ᨲᨾᩣᩃᩮᩣ ᨳ, ᨠᩩᨭᨩᩮᩣ ᨣᩥᩁᩥᨾᩃ᩠ᩃᩥᨠᩣ.
ᩍᨶ᩠ᨴᨿᩅᩮᩣ ᨹᩃᩮ ᨲᩔᩣ, ᨣ᩠ᨣᩥᨾᨶ᩠ᨳᩮᩣ ᨠᨱᩥᨠᩣ ᨽᩅᩮ;
ᨶᩥᨣᩩᨱ᩠ᨮᩥ’ᨲ᩠ᨳᩦ ᩈᩥᨶ᩠ᨴᩩᩅᩣᩁᩮᩣ, ᨲᩥᨱᩈᩩᨬ᩠ᨬᩴ [ᨲᩥᨱᩈᩪᩃᩴ (ᨭᩦ.)] ᨲᩩ ᨾᩃ᩠ᩃᩥᨠᩣ.
ᩈᩮᨹᩣᩃᩥᨠᩣ ᨶᩦᩃᩥᨠᩣ ᨳ, ᩋᨸ᩠ᨹᩮᩣᨭᩣ ᩅᨶᨾᩃ᩠ᩃᩥᨠᩣ;
ᨻᨶ᩠ᨵᩩᨠᩮᩣ ᨩᨿᩈᩩᨾᨶᩴ, ᨽᨱ᩠ᨯᩥᨠᩮᩣ ᨻᨶ᩠ᨵᩩᨩᩦᩅᨠᩮᩣ.
ᩈᩩᨾᨶᩣ ᨩᩣᨲᩥᩈᩩᨾᨶᩣ, ᨾᩣᩃᨲᩦ ᨩᩣᨲᩥ ᩅᩔᩥᨠᩦ;
ᨿᩪᨳᩥᨠᩣ ᨾᩣᨣᨵᩦ ᨧᩣᨳ, ᩈᨲ᩠ᨲᩃᩣ ᨶᩅᨾᩃ᩠ᩃᩥᨠᩣ.
ᩅᩣᩈᨶ᩠ᨲᩦ,ᨲ᩠ᨳᩦ ᩋᨲᩥᨾᩩᨲ᩠ᨲᩮᩣ, ᨠᩁᩅᩦᩁᩮᩣ’ᩔᨾᩣᩁᨠᩮᩣ;
ᨾᩣᨲᩩᩃᩩᨦ᩠ᨣᩮᩣ ᨻᩦᨩᨸᩪᩁᩮᩣ, ᩏᨾ᩠ᨾᨲ᩠ᨲᩮᩣ ᨲᩩ ᨧ ᨾᩣᨲᩩᩃᩮᩣ.
ᨠᩁᨾᨶ᩠ᨴᩮᩣ ᩈᩩᩈᩮᨶᩮᩣ ᨧ, ᨠᩩᨶ᩠ᨴᩴ ᨲᩩ ᨾᩣᨥ᩠ᨿ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨴᩮᩅᨲᩣᩈᩮᩣ [ᨴᩮᩅᨲᩣᨯᩮᩣ (ᩈᩦ. ᩋᨾᩁᨠᩮᩣᩈ)] ᨲᩩ ᨩᩦᨾᩪᨲᩮᩣ,
ᨳᩣ’ᨾᩥᩃᩣᨲᩮᩣ ᨾᩉᩣᩈᩉᩣ.
ᩋᨳᩮᩣ ᩈᩮᩁᩮᨿ᩠ᨿᨠᩮᩣ ᨴᩣᩈᩦ,
ᨠᩥᩴ ᨠᩥᩁᩣᨲᩮᩣ ᨠᩩᩁᨱ᩠ᨭᨠᩮᩣ;
ᩋᨩ᩠ᨩᩩᨠᩮᩣ ᩈᩥᨲᨸᨱ᩠ᨱᩣᩈᩮᩣ, ᩈᨾᩦᩁᨱᩮᩣ ᨹᨱᩥᨩ᩠ᨩᨠᩮᩣ.
ᨩᨸᩣ ᨲᩩ ᨩᨿᩈᩩᨾᨶᩴ, ᨠᩁᩦᩁᩮᩣ ᨠᨠᨧᩮᩣ ᨽᩅᩮ;
ᩁᩩᨠ᩠ᨡᩣᨴᨶᩦ ᨧ ᩅᨶ᩠ᨴᩣᨠᩣ, ᨧᩥᨲ᩠ᨲᨠᩮᩣ ᨲ᩠ᩅ’ᨣ᩠ᨣᩥᩈᨬ᩠ᨬᩥᨲᩮᩣ.
ᩋᨠ᩠ᨠᩮᩣ ᩅᩥᨠᩦᩁᨱᩮᩣ ᨲᩈ᩠ᨾᩥᩴ,
ᨲ᩠ᩅ’ ᩊᨠ᩠ᨠᩮᩣ ᩈᩮᨲᨸᩩᨸ᩠ᨹᨠᩮ;
ᨸᩪᨲᩥᩃᨲᩣ ᨣᩊᩮᩣᨧᩦ ᨧ, ᨾᩩᨻ᩠ᨻᩣ ᨾᨵᩩᩁᩈᩣ ᨸ᩠ᨿᨳ.
ᨠᨸᩥᨠᨧ᩠ᨨᩩ ᨴᩩᨹᩔᩮᩣ ᨳ, ᨾᨬ᩠ᨩᩥᨭ᩠ᨮᩣ ᩅᩥᨠᩈᩣ ᨽᩅᩮ;
ᩋᨾ᩠ᨻᨭ᩠ᨮᩣ ᨧ ᨲᨳᩣ ᨸᩣᨮᩣ, ᨠᨭᩩᨠᩣ ᨠᨭᩩᩁᩮᩣᩉᩥᨱᩦ.
ᩋᨸᩣᨾᨣ᩠ᨣᩮᩣ ¶ ᩈᩮᨡᩁᩥᨠᩮᩣ, ᨸᩥᨸ᩠ᨸᩃᩦ ᨾᩣᨣᨵᩦ ᨾᨲᩣ;
ᨣᩮᩣᨠᨱ᩠ᨭᨠᩮᩣ ᨧ ᩈᩥᨦ᩠ᨥᩣᨭᩮᩣ, ᨠᩮᩣᩃᩅᩃ᩠ᩃᩦ’ᨽᨸᩥᨸ᩠ᨸᩃᩦ.
ᨣᩮᩣᩃᩮᩣᨾᩦ ᨲᩩ ᩅᨧᩣ ᨧᩣᨳ, ᨣᩥᩁᩥᨠᨱ᩠ᨿ’ᨸᩁᩣᨩᩥᨲᩣ;
ᩈᩦᩉᨸᩩᨧ᩠ᨨᩦ ᨸᨬ᩠ᩉᩥᨸᨱ᩠ᨱᩦ, ᩈᩣᩃᨸᨱ᩠ᨱᩦ ᨲᩩ ᨧ’ᨲ᩠ᨳᩥᩁᩣ; (ᨧᨳᩥᩁᩣ).
ᨶᩥᨴᩥᨴ᩠ᨵᩥᨠᩣ ᨲᩩ ᨻ᩠ᨿᨣ᩠ᨥᩦ ᨧ, ᩋᨳ ᨶᩦᩃᩦ ᨧ ᨶᩦᩃᩥᨶᩦ;
ᨩᩥᨬ᩠ᨩᩩᨠᩮᩣ [ᨩᩥᨬ᩠ᨩᩩᨠᩣ (ᨠ.)] ᨧᩮᩅ ᨣᩩᨬ᩠ᨩᩣ ᨳ, ᩈᨲᨾᩪᩃᩦ ᩈᨲᩣᩅᩁᩦ.
ᨾᩉᩮᩣᩈᨵᩴ ᨲ᩠ᩅ’ᨲᩥᩅᩥᩈᩣ, ᨻᩣᨠᩩᨧᩦ ᩈᩮᩣᨾᩅᩃ᩠ᩃᩥᨠᩣ;
ᨴᩣᨻ᩠ᨻᩦ ᨴᩣᩁᩩᩉᩃᩥᨴ᩠ᨴᩣ ᨳ, ᨻᩥᩊᨦ᩠ᨣᩴ ᨧᩥᨲᩕᨲᨱ᩠ᨯᩩᩃᩣ.
ᨶᩩᩉᩦ ᨧᩮᩅ ᨾᩉᩣᨶᩣᨾᩮᩣ, ᨾᩩᨴ᩠ᨴᩥᨠᩣ ᨲᩩ ᨾᨵᩩᩁᩈᩣ;
ᩋᨳᩣᨸᩥ ᨾᨵᩩᨠᩴ ᨿᨭ᩠ᨮᩥ, ᨾᨵᩩᨠᩣᨾᨵᩩᨿᨭ᩠ᨮᩥᨠᩣ [ᨾᨵᩩᩃᨭ᩠ᨮᩥᨠᩣ (ᩈᩦ. ᨭᩦ.)].
ᩅᩣᨲᩥᨦ᩠ᨣᨱᩮᩣ ᨧ ᨽᨱ᩠ᨯᩣᨠᩦ, ᩅᩣᨲ᩠ᨲᩣᨠᩦ ᨻᩕᩉᨲᩦ ᨸ᩠ᨿᨳ;
ᨶᩣᨣᨻᩃᩣ ᨧᩮᩅ ᨫᩈᩣ, ᩃᩣᨦ᩠ᨣᩃᩦ ᨲᩩ ᨧ ᩈᩣᩁᨴᩦ.
ᩁᨾ᩠ᨽᩣ ᨧ ᨠᨴᩃᩦ ᨾᩮᩣᨧᩮᩣ, ᨠᨸ᩠ᨸᩣᩈᩦ ᨻᨴᩁᩣ ᨽᩅᩮ;
ᨶᩣᨣᩃᨲᩣ ᨲᩩ ᨲᨾ᩠ᨻᩪᩃᩦ, ᩋᨣ᩠ᨣᩥᨩᩣᩃᩣ ᨲᩩ ᨵᩣᨲᨠᩦ.
ᨲᩥᩅᩩᨲᩣ ᨲᩥᨸᩩᨭᩣ ᨧᩣᨳ, ᩈᩣᨾᩣ ᨠᩣᩊᩣ ᨧ ᨠᨳ᩠ᨿᨲᩮ;
ᩋᨳᩮᩣ ᩈᩥᨦ᩠ᨣᩦ ᨧ ᩏᩈᨽᩮᩣ, ᩁᩮᨱᩩᨠᩣ ᨠᨸᩥᩊᩣ ᨽᩅᩮ.
ᩉᩥᩁᩥᩅᩮᩁᨬ᩠ᨧ ᩅᩣᩃᨬ᩠ᨧ, ᩁᨲ᩠ᨲᨹᩃᩣ ᨲᩩ ᨻᩥᨾ᩠ᨻᩥᨠᩣ;
ᩈᩮᩃᩮᨿ᩠ᨿ’ ᨾᩈ᩠ᨾᨸᩩᨸ᩠ᨹᨬ᩠ᨧ, ᩑᩃᩣ ᨲᩩ ᨻᩉᩩᩃᩣ ᨽᩅᩮ.
ᨠᩩᨭ᩠ᨮᨬ᩠ᨧ ᨻ᩠ᨿᩣᨵᩥ ᨠᨳᩥᨲᩮᩣ, ᩅᩣᨶᩮᨿ᩠ᨿᩴ ᨲᩩ ᨠᩩᨭᨶ᩠ᨶᨭᩴ;
ᩒᩈᨵᩥ ᨩᩣᨲᩥᨾᨲ᩠ᨲᨾ᩠ᩉᩥ, ᩒᩈᨵᩴ ᩈᨻ᩠ᨻ’ ᨾᨩᩣᨲᩥᨿᩴ.
ᨾᩪᩃᩴ ᨸᨲ᩠ᨲᩴ ᨠᩊᩦᩁ’ᨣ᩠ᨣᩴ, ᨠᨶ᩠ᨴᩴ ᨾᩥᨬ᩠ᨩᩣ ᨹᩃᩴ ᨲᨳᩣ;
ᨲᨧᩮᩣ ᨸᩩᨸ᩠ᨹᨬ᩠ᨧ ᨨᨲ᩠ᨲᨶ᩠ᨲᩥ, ᩈᩣᨠᩴ ᨴᩈᩅᩥᨵᩴ ᨾᨲᩴ.
ᨸᨸᩩᨶ᩠ᨶᩣᨭᩮᩣ ᩑᩊᨣᩃᩮᩣ,
ᨲᨱ᩠ᨯᩩᩃᩮᨿ᩠ᨿᩮᩣ’ᨸ᩠ᨸᨾᩣᩁᩥᩈᩮᩣ;
ᨩᩦᩅᨶ᩠ᨲᩥ ᨩᩦᩅᨶᩦ ᨧᩣᨳ, ᨾᨵᩩᩁᨠᩮᩣ ᨧ ᨩᩦᩅᨠᩮᩣ.
ᨾᩉᩣᨠᨶ᩠ᨴᩮᩣ ᨧ ᩃᩈᩩᨱᩴ, ᨸᩃᨱ᩠ᨯᩩ ᨲᩩ ᩈᩩᨠᨶ᩠ᨴᨠᩮᩣ;
ᨸᨭᩮᩣᩃᩮᩣ ᨲᩥᨲ᩠ᨲᨠᩮᩣ ᨧᩣᨳ, ᨽᩥᨦ᩠ᨣᩁᩣᨩᩮᩣ ᨧ ᨾᨠ᩠ᨠᩅᩮᩣ.
ᨸᩩᨶᨶ᩠ᨶᩅᩣ ¶ ᩈᩮᩣᨳᨥᩣᨲᩦ, ᩅᩥᨲᩩᨶ᩠ᨶᩴ ᩈᩩᨶᩥᩈᨱ᩠ᨱᨠᩴ;
ᨠᩣᩁᩅᩮᩃ᩠ᩃᩮᩣ ᨲᩩ ᩈᩩᩈᩅᩦ, ᨲᩩᨾ᩠ᨻ᩠ᨿᩣ’ᩃᩣᨻᩩ ᨧ ᩃᩣᨻᩩ ᩈᩣ.
ᩑᩊᩣᩃᩩᨠᨬ᩠ᨧ ᨠᨠ᩠ᨠᩣᩁᩦ, ᨠᩩᨾ᩠ᨽᨱ᩠ᨯᩮᩣ ᨲᩩ ᨧ ᩅᩃ᩠ᩃᩥᨽᩮᩣ;
ᩍᨶ᩠ᨴᩅᩣᩁᩩᨱᩦ ᩅᩥᩈᩣᩃᩣ, ᩅᨲ᩠ᨳᩩᨠᩴ ᩅᨲ᩠ᨳᩩᩃᩮᨿ᩠ᨿᨠᩮᩣ.
ᨾᩪᩃᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨧᩩᨧ᩠ᨧᩩ, ᨲᨾ᩠ᨻᨠᩮᩣ ᨧ ᨠᩃᨾ᩠ᨻᨠᩮᩣ;
ᩈᩣᨠᨽᩮᨴᩣ ᨠᩣᩈᨾᨴ᩠ᨴ, ᨫᨩ᩠ᨫᩁᩦ ᨹᨣ᩠ᨣᩅᩣ’ᨴᨿᩮᩣ.
ᩈᨴ᩠ᨴᩃᩮᩣ ᨧᩮᩅ ᨴᩩᨻ᩠ᨻᩣ ᨧ, ᨣᩮᩣᩃᩮᩣᨾᩦ ᩈᩣ ᩈᩥᨲᩣ ᨽᩅᩮ;
ᨣᩩᨶ᩠ᨴᩣ ᨧ ᨽᨴ᩠ᨴᨾᩩᨲ᩠ᨲᨬ᩠ᨧ, ᩁᩈᩣᩃᩮᩣ ᨲᩩ’ᨧ᩠ᨨᩩ ᩅᩮᩊᩩ ᨲᩩ.
ᨲᨧᩈᩣᩁᩮᩣ ᩅᩮᨱᩩ ᩅᩴᩈᩮᩣ, ᨸᨻ᩠ᨻᩴ ᨲᩩ ᨹᩃᩩ ᨣᨱ᩠ᨮᩥᩈᩮᩣ;
ᨠᩦᨧᨠᩣ ᨲᩮ ᩈᩥᨿᩩᩴ ᩅᩮᨱᩪ, ᨿᩮ ᨶᨴᨶ᩠ᨲ᩠ᨿᩣ’ᨶᩥᩃᨴ᩠ᨵᩩᨲᩣ.
ᨶᩊᩮᩣ ᨧ ᨵᨾᨶᩮᩣ ᨸᩮᩣᨭ, ᨣᩃᩮᩣ ᨲᩩ ᨠᩣᩈ ᨾᩥᨲ᩠ᨳᩥ ᨶ;
ᨲᩮᨩᨶᩮᩣ ᨲᩩ ᩈᩁᩮᩣ, ᨾᩪᩃᩴ, ᨲᩪ’ ᩈᩦᩁᩴ ᨻᩦᩁᨱᩔ ᩉᩥ.
ᨠᩩᩈᩮᩣ ᩅᩁᩉᩥᩈᩴ ᨴᨻ᩠ᨻᩮᩣ, ᨽᩪᨲᩥᨱᨠᩴ ᨲᩩ ᨽᩪᨲᩥᨱᩴ;
ᨥᩣᩈᩮᩣ ᨲᩩ ᨿᩅᩈᩮᩣ ᨧᩣᨳ,
ᨸᩪᨣᩮᩣ ᨲᩩ ᨠᨾᩩᨠᩮᩣ ᨽᩅᩮ.
ᨲᩣᩃᩮᩣ ᩅᩥᨽᩮᨴᩥᨠᩣ ᨧᩣᨳ, ᨡᨩ᩠ᨩᩩᩁᩦ ᩈᩥᨶ᩠ᨴᩥ ᩅᩩᨧ᩠ᨧᨲᩥ;
ᩉᩥᨶ᩠ᨲᩣᩃ, ᨲᩣᩃ, ᨡᨩ᩠ᨩᩪᩁᩦ, ᨶᩣᩃᩥᨠᩮᩁᩣ ᨲᨳᩮᩅ ᨧ;
ᨲᩣᩃᩦ ᨧ ᨠᩮᨲᨠᩦ ᨶᩣᩁᩦ, ᨸᩪᨣᩮᩣ ᨧ ᨲᩥᨱᨸᩣᨴᨸᩣᨲᩥ.
ᩍᨲᩥ ᩋᩁᨬ᩠ᨬᩅᨣ᩠ᨣᩮᩣ.
᪖. ᩋᩁᨬ᩠ᨬᩣᨴᩥᩅᨣ᩠ᨣ
ᨸᨻ᩠ᨻᨲᩮᩣ ᨣᩥᩁᩥ ᩈᩮᩃᩮᩣ’ᨴ᩠ᨴᩥ, ᨶᨣᩣ’ᨧᩃ, ᩈᩥᩃᩩᨧ᩠ᨧᨿᩣ;
ᩈᩥᨡᩁᩦ ᨽᩪᨵᩁᩮᩣᨳ ᨻ᩠ᨽ, ᨸᩣᩈᩣᨱᩣ’ᩈ᩠ᨾᩮᩣ’ᨸᩃᩮᩣ ᩈᩥᩃᩣ.
ᨣᩥᨩ᩠ᨫᨠᩪᨭᩮᩣ ᨧ ᩅᩮᨽᩣᩁᩮᩣ, ᩅᩮᨸᩩᩃ᩠ᩃᩮᩣ’ᩈᩥᨣᩥᩃᩦ ᨶᨣᩣ;
ᩅᩥᨬ᩠ᨫᩮᩣ ᨸᨱ᩠ᨯᩅ ᩅᨦ᩠ᨠᩣᨴᩦ, ᨸᩩᨻ᩠ᨻᩈᩮᩃᩮᩣ ᨲᩩ ᨧᩮᩣ’ᨴᨿᩮᩣ;
ᨾᨶ᩠ᨴᩁᩮᩣ ᨸᩁᩈᩮᩃᩮᩣ’ᨲ᩠ᨳᩮᩣ, ᩉᩥᨾᩅᩣ ᨲᩩ ᩉᩥᨾᩣᨧᩃᩮᩣ.
ᨣᨶ᩠ᨵᨾᩣᨴᨶ ᨠᩮᩃᩣᩈ, ᨧᩥᨲ᩠ᨲᨠᩪᨭ ᩈᩩᨴᩔᨶᩣ;
ᨠᩣᩃᨠᩪᨭᩮᩣ ᨲᩥᨠᩪᨭᩣ’ᩔ, ᨸᨲ᩠ᨳᩮᩣ ᨲᩩ ᩈᩣᨶᩩ ᨶᩥᨲ᩠ᨳᩥᨿᩴ.
ᨠᩪᨭᩮᩣ ¶ ᩅᩣ ᩈᩥᨡᩁᩴ ᩈᩥᨦ᩠ᨣᩴ, ᨸᨸᩣᨲᩮᩣ ᨲᩩ ᨲᨭᩮᩣ ᨽᩅᩮ;
ᨶᩥᨲᨾ᩠ᨻᩮᩣ ᨠᨭᨠᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨶᩥᨩ᩠ᨫᩁᩮᩣ ᨸᩈᩅᩮᩣ’ᨾ᩠ᨻᩩᨶᩮᩣ.
ᨴᩁᩦ’ᨲ᩠ᨳᩦ ᨠᨶ᩠ᨴᩁᩮᩣ ᨴ᩠ᩅᩦᩈᩩ, ᩃᩮᨱᩴ ᨲᩩ ᨣᨻ᩠ᨽᩁᩴ ᨣᩩᩉᩣ;
ᩈᩥᩃᩣᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ ᩈᩮᩣᨱ᩠ᨯᩦ, ᨠᩩᨬ᩠ᨩᩴ ᨶᩥᨠᩩᨬ᩠ᨩ ᨾᩥᨲ᩠ᨳᩥ ᨶ.
ᩏᨴ᩠ᨵ ᨾᨵᩥᨧ᩠ᨧᨠᩣ ᩈᩮᩃ, ᩔᩣᩈᨶ᩠ᨶᩣ ᨽᩪᨾ᩠ᨿᩩ ᨸᨧ᩠ᨧᨠᩣ;
ᨸᩣᨴᩮᩣ ᨲᩩ’ᨸᨶ᩠ᨲᩈᩮᩃᩮᩣ ᨳ,
ᨵᩣᨲᩩ’ᨲ᩠ᨲᩮᩣ ᨣᩮᩁᩥᨠᩣᨴᩥᨠᩮᩣ.
ᩍᨲᩥ ᩈᩮᩃᩅᨣ᩠ᨣᩮᩣ.
ᨾᩥᨣᩥᨶ᩠ᨴᩮᩣ ᨠᩮᩈᩁᩦ ᩈᩦᩉᩮᩣ, ᨲᩁᨧ᩠ᨨᩮᩣ ᨲᩩ ᨾᩥᨣᩣᨴᨶᩮᩣ;
ᨻ᩠ᨿᨣ᩠ᨥᩮᩣ ᨲᩩ ᨸᩩᨱ᩠ᨯᩁᩦᨠᩮᩣ ᨳ, ᩈᨴ᩠ᨴᩪᩃᩮᩣ ᨴᩦᨸᩥᨶᩦ’ᩁᩥᨲᩮᩣ.
ᩋᨧ᩠ᨨᩮᩣ ᩍᨠ᩠ᨠᩮᩣ ᨧ ᩍᩔᩮᩣ ᨲᩩ,
ᨠᩣᩊᩈᩦᩉᩮᩣ ᩍᩈᩮᩣ ᨸ᩠ᨿᨳ;
ᩁᩮᩣᩉᩥᩈᩮᩣ ᩁᩮᩣᩉᩥᨲᩮᩣ ᨧᩣᨳ,
ᨣᩮᩣᨠᨱ᩠ᨱᩮᩣ ᨣᨱᩥ ᨠᨱ᩠ᨭᨠᩣ.
ᨡᨣ᩠ᨣ ᨡᨣ᩠ᨣᩅᩥᩈᩣᨱᩣ ᨲᩩ, ᨸᩃᩣᩈᩣᨴᩮᩣ ᨧ ᨣᨱ᩠ᨯᨠᩮᩣ;
ᨻ᩠ᨿᨣ᩠ᨥᩣᨴᩥᨠᩮ ᩅᩣᩊᨾᩥᨣᩮᩣ, ᩈᩣᨸᨴᩮᩣ ᨳ ᨸ᩠ᩃᩅᨦ᩠ᨣᨾᩮᩣ.
ᨾᨠ᩠ᨠᨭᩮᩣ ᩅᩣᨶᩁᩮᩣ ᩈᩣᨡᩣ, ᨾᩥᨣᩮᩣ ᨠᨸᩥ ᩅᩃᩦᨾᩩᨡᩮᩣ;
ᨸᩃᩅᨦ᩠ᨣᩮᩣ, ᨠᨱ᩠ᩉᨲᩩᨱ᩠ᨯᩮᩣ,
ᨣᩮᩣᨶᨦ᩠ᨣᩩᩃᩮᩣ [ᨣᩮᩣᨶᨦ᩠ᨣᩃᩮᩣ (ᨭᩦ.)] ᨲᩥ ᩈᩮᩣ ᨾᨲᩮᩣ.
ᩈᩥᨦ᩠ᨣᩣᩃᩮᩣ [ᩈᩥᨣᩣᩃᩮᩣ (ᩈᩦ.)] ᨩᨾ᩠ᨻᩩᨠᩮᩣ ᨠᩮᩣᨲ᩠ᨳᩩ, ᨽᩮᩁᩅᩮᩣ ᨧ ᩈᩥᩅᩣ ᨸ᩠ᨿᨳ;
ᨻᩥᩊᩣᩁᩮᩣ ᨻᨻ᩠ᨻᩩ ᨾᨬ᩠ᨩᩣᩁᩮᩣ, ᨠᩮᩣᨠᩮᩣ ᨲᩩ ᨧ ᩅᨠᩮᩣ ᨽᩅᩮ.
ᨾᩉᩥᩴᩈᩮᩣ [ᨾᩉᩥᩈᩮᩣ (ᩈᩦ.)] ᨧ ᩃᩩᩃᩣᨿᩮᩣ ᨳ,
ᨣᩅᨩᩮᩣ ᨣᩅᨿᩮᩣ ᩈᨾᩣ;
ᩈᩃ᩠ᩃᩮᩣ ᨲᩩ ᩈᩃ᩠ᩃᨠᩮᩣ ᨳᩣ’ᩔ,
ᩃᩮᩣᨾᨾ᩠ᩉᩥ ᩈᩃᩃᩴ ᩈᩃᩴ.
ᩉᩁᩥᨱᩮᩣ ᨾᩥᨣ ᩈᩣᩁᨦ᩠ᨣᩣ, ᨾᨣᩮᩣ ᩋᨩᩥᨶᨿᩮᩣᨶᩥ ᨧ;
ᩈᩪᨠᩁᩮᩣ ᨲᩩ ᩅᩁᩮᩣᩉᩮᩣ ᨳ,
ᨸᩮᩃᨠᩮᩣ ᨧ ᩈᩈᩮᩣ ᨽᩅᩮ.
ᩑᨱᩮᨿ᩠ᨿᩮᩣ ¶ ᩑᨱᩦᨾᩥᨣᩮᩣ ᨧ, ᨸᨾ᩠ᨸᨭᨠᩮᩣ ᨲᩩ ᨸᨾ᩠ᨸᨠᩮᩣ;
ᩅᩣᨲᨾᩥᨣᩮᩣ ᨲᩩ ᨧᩃᨶᩦ, ᨾᩪᩈᩥᨠᩮᩣ ᨲ᩠ᩅᩣ’ᨡᩩ ᩏᨶ᩠ᨴᩩᩁᩮᩣ.
ᨧᨾᩁᩮᩣ ᨸᩈᨴᩮᩣ ᨧᩮᩅ, ᨠᩩᩁᩩᨦ᩠ᨣᩮᩣ ᨾᩥᨣᨾᩣᨲᩩᨠᩣ;
ᩁᩩᩁᩩ ᩁᨦ᩠ᨠᩩ ᨧ ᨶᩦᨠᩮᩣ ᨧ, ᩈᩁᨽᩣᨴᩦ ᨾᩥᨣᨶ᩠ᨲᩁᩣ.
ᨸᩥᨿᨠᩮᩣ ᨧᨾᩪᩁᩩ ᨠᨴᩃᩦ, ᨾᩥᨣᩣᨴᩦ ᨧᨾ᩠ᨾᨿᩮᩣᨶᨿᩮᩣ;
ᨾᩥᨣᩣ ᨲᩩ ᨸᩈᩅᩮᩣ ᩈᩦᩉᩣ, ᨴᨿᩮᩣ ᩈᨻ᩠ᨻᨧᨲᩩᨸ᩠ᨸᨴᩣ.
ᩃᩪᨲᩣ ᨲᩩ ᩃᩪᨲᩥᨠᩣ ᩏᨱ᩠ᨱ, ᨶᩣᨽᩥ ᨾᨠ᩠ᨠᨭᨠᩮᩣ ᩈᩥᨿᩣ;
ᩅᩥᨧ᩠ᨨᩥᨠᩮᩣ ᨲ᩠ᩅᩣ’ᩊᩥ ᨠᨳᩥᨲᩮᩣ, ᩈᩁᨻᩪ ᨥᩁᨣᩮᩣᩊᩥᨠᩣ.
ᨣᩮᩣᨵᩣ ᨠᩩᨱ᩠ᨯᩮᩣ ᨸ᩠ᨿᨳᩮᩣ ᨠᨱ᩠ᨱ, ᨩᩃᩪᨠᩣ ᩈᨲᨸᨴ᩠ᨿᨳ;
ᨠᩃᨶ᩠ᨴᨠᩮᩣ ᨠᩣᩊᨠᩣ ᨳ, ᨶᨠᩩᩃᩮᩣ ᨾᨦ᩠ᨣᩩᩈᩮᩣ ᨽᩅᩮ.
ᨠᨠᨱ᩠ᨭᨠᩮᩣ ᨧ ᩈᩁᨭᩮᩣ, ᨠᩦᨭᩮᩣ ᨲᩩ ᨸᩩᩊᩅᩮᩣ ᨠᩥᨾᩥ;
ᨸᩣᨱᨠᩮᩣ ᨧᩣᨸ᩠ᨿᨳᩮᩣ ᩏᨧ᩠ᨧᩣ,
ᩃᩥᨦ᩠ᨣᩮᩣ ᩃᩮᩣᨾᩈᨸᩣᨱᨠᩮᩣ.
ᩅᩥᩉᨦ᩠ᨣᩮᩣ ᩅᩥᩉᨣᩮᩣ ᨸᨠ᩠ᨡᩦ, ᩅᩥᩉᨦ᩠ᨣᨾ ᨡᨣ’ᨱ᩠ᨯᨩᩣ;
ᩈᨠᩩᨱᩮᩣ ᨧ ᩈᨠᩩᨶ᩠ᨲᩮᩣ ᩅᩥ, ᨸᨲᨦ᩠ᨣᩮᩣ ᩈᨠᩩᨱᩦ ᨴ᩠ᩅᩥᨩᩮᩣ.
ᩅᨠ᩠ᨠᨦ᩠ᨣᩮᩣ ᨸᨲ᩠ᨲᨿᩣᨶᩮᩣ ᨧ, ᨸᨲᨶ᩠ᨲᩮᩣ ᨶᩦᩊᨩᩮᩣ ᨽᩅᩮ;
ᨲᨻ᩠ᨽᩮᨴᩣ ᩅᨭ᩠ᨭᨠᩣ ᨩᩦᩅ, ᨬ᩠ᨩᩦᩅᩮᩣ ᨧᨠᩮᩣᩁ ᨲᩥᨲ᩠ᨲᩥᩁᩣ.
ᩈᩣᩊᩥᨠᩣ ᨠᩁᩅᩦᨠᩮᩣ ᨧ, ᩁᩅᩥᩉᩴᩈᩮᩣ ᨠᩩᨠᩩᨲ᩠ᨳᨠᩮᩣ;
ᨠᩣᩁᨱ᩠ᨯᩅᩮᩣ ᨧ ᨸᩥᩃᩅᩮᩣ [ᨻᩥᩃᩅᩮᩣ (ᨭᩦ.)], ᨸᩮᩣᨠ᩠ᨡᩁᩈᩣᨲᨠᩣ’ᨴᨿᩮᩣ.
ᨸᨲᨲ᩠ᨲᩴ ᨸᩮᨡᩩᨱᩴ ᨸᨲ᩠ᨲᩴ, ᨸᨠ᩠ᨡᩮᩣ ᨸᩥᨬ᩠ᨨᩴ ᨨᨴᩮᩣ ᨣᩁᩩ;
ᩋᨱ᩠ᨯᩴ ᨲᩩ ᨸᨠ᩠ᨡᩥᨻᩦᨩᩮ ᨳ, ᨶᩦᩊᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨠᩩᩃᩣᩅᨠᩴ.
ᩈᩩᨸᨱ᩠ᨱᨾᩣᨲᩣ ᩅᩥᨶᨲᩣ, ᨾᩥᨳᩩᨶᩴ ᨳᩦᨸᩩᨾᨴ᩠ᩅᨿᩴ;
ᨿᩩᨣᩴ ᨲᩩ ᨿᩩᨣᩃᩴ ᨴ᩠ᩅᨶ᩠ᨴᩴ, ᨿᨾᨠᩴ ᨿᨾᩃᩴ ᨿᨾᩴ.
ᩈᨾᩪᩉᩮᩣ ᨣᨱ ᩈᨦ᩠ᨥᩣᨲᩣ, ᩈᨾᩩᨴᩣᨿᩮᩣ ᨧ ᩈᨬ᩠ᨧᨿᩮᩣ;
ᩈᨶ᩠ᨴᩮᩣᩉᩮᩣ ᨶᩥᩅᩉᩮᩣ ᩒᨥᩮᩣ, ᩅᩥᩈᩁᩮᩣ ᨶᩥᨠᩁᩮᩣ ᨧᨿᩮᩣ.
ᨠᩣᨿᩮᩣ ᨡᨶ᩠ᨵᩮᩣ ᩈᨾᩩᨴᨿᩮᩣ, ᨥᨭᩣ ᩈᨾᩥᨲᩥ ᩈᩴᩉᨲᩥ;
ᩁᩣᩈᩥ ᨸᩩᨬ᩠ᨩᩮᩣ ᩈᨾᩅᩣᨿᩮᩣ, ᨸᩪᨣᩮᩣ ᨩᩣᨲᩴ ᨠᨴᨾ᩠ᨻᨠᩴ.
ᨻ᩠ᨿᩪᩉᩮᩣ ¶ ᩅᩥᨲᩣᨶ ᨣᩩᨾ᩠ᨻᩣ ᨧ, ᨠᩃᩣᨸᩮᩣ ᨩᩣᩃ ᨾᨱ᩠ᨯᩃᩴ;
ᩈᨾᩣᨶᩣᨶᩴ ᨣᨱᩮᩣ ᩅᨣ᩠ᨣᩮᩣ,
ᩈᨦ᩠ᨥᩮᩣ ᩈᨲ᩠ᨳᩮᩣ ᨲᩩ ᨩᨶ᩠ᨲᩩᨶᩴ.
ᩈᨩᩣᨲᩥᨠᩣᨶᩴ ᨲᩩ ᨠᩩᩃᩴ, ᨶᩥᨠᩣᨿᩮᩣ ᨲᩩ ᩈᨵᨾ᩠ᨾᩥᨶᩴ;
ᨿᩪᨳᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᨩᩣᨲᩥᨿ, ᨲᩥᩁᨧ᩠ᨨᩣᨶᩣᨶᨾᩩᨧ᩠ᨧᨲᩮ.
ᩈᩩᨸᨱ᩠ᨱᩮᩣ ᩅᩮᨶᨲᩮᨿ᩠ᨿᩮᩣ ᨧ, ᨣᩁᩩᩊᩮᩣ ᩅᩥᩉᨣᩣᨵᩥᨸᩮᩣ;
ᨸᩁᨸᩩᨭ᩠ᨮᩮᩣ ᨸᩁᨽᨲᩮᩣ, ᨠᩩᨱᩣᩃᩮᩣ ᨠᩮᩣᨠᩥᩃᩮᩣ ᨸᩥᨠᩮᩣ.
ᨾᩮᩣᩁᩮᩣ ᨾᨿᩪᩁᩮᩣ ᩅᩁᩉᩦ, ᨶᩦᩃᨣᩦᩅ ᩈᩥᨡᨱ᩠ᨯᩥᨶᩮᩣ;
ᨠᩃᩣᨸᩦ ᨧ ᩈᩥᨡᩦ ᨠᩮᨠᩦ, ᨧᩪᩊᩣ ᨲᩩ ᨧ ᩈᩥᨡᩣ ᨽᩅᩮ.
ᩈᩥᨡᨱ᩠ᨯᩮᩣ ᩅᩁᩉᨬ᩠ᨧᩮᩅ, ᨠᩃᩣᨸᩮᩣ ᨸᩥᨬ᩠ᨨ ᨾᨸ᩠ᨿᨳ;
ᨧᨶ᩠ᨴᨠᩮᩣ ᨾᩮᨧᨠᩮᩣ ᨧᩣᨳ, ᨨᨸ᩠ᨸᨴᩮᩣ ᨧ ᨾᨵᩩᨻ᩠ᨻᨲᩮᩣ.
ᨾᨵᩩᩃᩦᩉᩮᩣ ᨾᨵᩩᨠᩁᩮᩣ, ᨾᨵᩩᨸᩮᩣ ᨽᨾᩁᩮᩣ ᩋᩃᩥ;
ᨸᩣᩁᩣᩅᨲᩮᩣ ᨠᨸᩮᩣᨲᩮᩣ ᨧ, ᨠᨠᩩᨭᩮᩣ ᨧ ᨸᩣᩁᩮᩅᨲᩮᩣ.
ᨣᩥᨩ᩠ᨫᩮᩣ ᨣᨴ᩠ᨵᩮᩣᨳ ᨠᩩᩃᩃᩮᩣ, ᩈᩮᨶᩮᩣ ᨻ᩠ᨿᨣ᩠ᨥᩦᨶᩈᩮᩣ ᨸ᩠ᨿᨳ;
ᨲᨻ᩠ᨽᩮᨴᩣ ᩈᨠᩩᨱᨣ᩠ᨥᩥ’ᨲ᩠ᨳᩦ, ᩌᨭᩮᩣ ᨴᨻ᩠ᨻᩥᨾᩩᨡᨴ᩠ᩅᩥᨩᩮᩣ.
ᩏᩉᩩᨦ᩠ᨠᩣᩁᩮᩣ ᩏᩃᩪᨠᩮᩣ ᨧ, ᨠᩮᩣᩈᩥᨿᩮᩣ ᩅᩣᨿᩈᩣᩁᩥ ᨧ;
ᨠᩣᨠᩮᩣ ᨲ᩠ᩅ’ᩁᩥᨭ᩠ᨮᩮᩣ ᨵᨦ᩠ᨠᩮᩣ ᨧ, ᨻᩃᩥᨸᩩᨭ᩠ᨮᩮᩣ ᨧ ᩅᩣᨿᩈᩮᩣ.
ᨠᩣᨠᩮᩣᩃᩮᩣ ᩅᨶᨠᩣᨠᩮᩣ ᨳ,
ᩃᩣᨸᩮᩣ ᩃᨭᩩᨠᩥᨠᩣ ᨸ᩠ᨿᨳ;
ᩅᩣᩁᨱᩮᩣ ᩉᨲ᩠ᨳᩥᩃᩥᨦ᩠ᨣᩮᩣ ᨧ, ᩉᨲ᩠ᨳᩥᩈᩮᩣᨱ᩠ᨯᩅᩥᩉᨦ᩠ᨣᨾᩮᩣ.
ᩏᨠ᩠ᨠᩩᩈᩮᩣ ᨠᩩᩁᩁᩮᩣ ᨠᩮᩣᩃ,ᨭ᩠ᨮᩥᨸᨠ᩠ᨡᩥᨾ᩠ᩉᩥ ᨧ ᨠᩩᨠ᩠ᨠᩩᩉᩮᩣ;
ᩈᩩᩅᩮᩣ ᨲᩩ ᨠᩦᩁᩮᩣ ᨧ ᩈᩩᨠᩮᩣ, ᨲᨾ᩠ᨻᨧᩪᩊᩮᩣ ᨲᩩ ᨠᩩᨠ᩠ᨠᩩᨭᩮᩣ.
ᩅᨶᨠᩩᨠ᩠ᨠᩩᨭᩮᩣ ᨧ ᨶᩥᨩ᩠ᨩᩥᩅ᩠ᩉᩮᩣ, ᩋᨳ ᨠᩮᩣᨬ᩠ᨧᩣ ᨧ ᨠᩩᨶ᩠ᨲᨶᩦ;
ᨧᨠ᩠ᨠᩅᩣᨠᩮᩣ ᨲᩩ ᨧᨠ᩠ᨠᩅ᩠ᩉᩮᩣ, ᩈᩣᩁᨦ᩠ᨣᩮᩣᨲᩩ ᨧ ᨧᩣᨲᨠᩮᩣ.
ᨲᩩᩃᩥᨿᩮᩣ ᨸᨠ᩠ᨡᩥᨻᩥᩊᩣᩃᩮᩣ,
ᩈᨲᨸᨲ᩠ᨲᩮᩣ ᨲᩩ ᩈᩣᩁᩈᩮᩣ;
ᨻᨠᩮᩣ ᨲᩩ ᩈᩩᨠ᩠ᨠᨠᩣᨠᩮᩣᨳ,
ᨻᩃᩣᨠᩣ ᩅᩥᩈᨠᨱ᩠ᨮᩥᨠᩣ.
ᩃᩮᩣᩉᨸᩥᨭ᩠ᨮᩮᩣ ᨲᨳᩣ ᨠᨦ᩠ᨠᩮᩣ, ᨡᨬ᩠ᨩᩁᩦᨭᩮᩣ ᨲᩩ ᨡᨬ᩠ᨩᨶᩮᩣ;
ᨠᩃᩅᩥᨦ᩠ᨠᩮᩣ ᨲᩩ ᨧᩣᨭᨠᩮᩣ, ᨴᩥᨶ᩠ᨴᩥᨽᩮᩣ ᨲᩩ ᨠᩥᨠᩦ ᨽᩅᩮ.
ᨠᩣᨴᨾ᩠ᨻᩮᩣ ¶ ᨠᩣᩊᩉᩴᩈᩮᩣᨳ, ᩈᨠᩩᨶ᩠ᨲᩮᩣ ᨽᩣᩈᨸᨠ᩠ᨡᩥᨶᩥ;
ᨵᩪᨾ᩠ᨿᩣᨭᩮᩣ ᨲᩩ ᨠᩃᩥᨦ᩠ᨣᩮᩣᨳ,
ᨴᩣᨲ᩠ᨿᩪᩉᩮᩣ ᨠᩣᩊᨠᨱ᩠ᨮᨠᩮᩣ.
ᨡᩩᨴ᩠ᨴᩣᨴᩦ ᨾᨠ᩠ᨡᩥᨠᩣᨽᩮᨴᩣ, ᨯᩴᩈᩮᩣ ᨸᩥᨦ᩠ᨣᩃᨾᨠ᩠ᨡᩥᨠᩣ;
ᩌᩈᩣᨭᩥᨠᩣ ᨾᨠ᩠ᨡᩥᨠᩣᨱ᩠ᨯᩴ, ᨸᨲᨦ᩠ᨣᩮᩣ ᩈᩃᨽᩮᩣ ᨽᩅᩮ.
ᩈᩪᨧᩥᨾᩩᨡᩮᩣ ᨧ ᨾᨠᩈᩮᩣ, ᨧᩦᩁᩦ ᨲᩩ ᨫᩃ᩠ᩃᩥᨠᩣ [ᨫᩥᩃ᩠ᩃᩥᨠᩣ (ᨠ.)] ᨳ ᨧ;
ᨩᨲᩩᨠᩣ ᨩᩥᨶᨸᨲ᩠ᨲᩣ ᨳ, ᩉᩴᩈᩮᩣ ᩈᩮᨲᨧ᩠ᨨᨴᩮᩣ ᨽᩅᩮ.
ᨲᩮ ᩁᩣᨩᩉᩴᩈᩣ ᩁᨲ᩠ᨲᩮᩉᩥ, ᨸᩣᨴᨲᩩᨱ᩠ᨯᩮᩉᩥ ᨽᩣᩈᩥᨲᩣ;
ᨾᩃ᩠ᩃᩥᨠᩣ’ᨡ᩠ᨿᩣ ᨵᨲᩁᨭ᩠ᨮᩣ, ᨾᩃᩦᨶᩮᩉ᩠ᨿ’ᩈᩥᨲᩮᩉᩥ ᨧ.
᪖᪔᪘. ᨲᩥᩁᨧ᩠ᨨᩮᩣ ᨲᩩ ᨲᩥᩁᨧ᩠ᨨᩣᨶᩮᩣ, ᨲᩥᩁᨧ᩠ᨨᩣᨶᨣᨲᩮᩣ ᩈᩥᨿᩣᨲᩥ.
ᩍᨲᩥ ᩋᩁᨬ᩠ᨬᩣᨴᩥᩅᨣ᩠ᨣᩮᩣ.
᪗. ᨸᩣᨲᩣᩃᩅᨣ᩠ᨣ
ᩋᨵᩮᩣᨽᩩᩅᨶᩴ ᨸᩣᨲᩣᩃᩴ, ᨶᩣᨣᩃᩮᩣᨠᩮᩣ ᩁᩈᩣᨲᩃᩴ;
ᩁᨶ᩠ᨵᩴ ᨲᩩ ᩅᩥᩅᩁᩴ ᨨᩥᨴ᩠ᨴᩴ, ᨠᩩᩉᩁᩴ ᩈᩩᩈᩥᩁᩴ ᨻᩥᩃᩴ.
ᩈᩩᩈᩥ’ᨲ᩠ᨳᩦ ᨨᩥᨣ᩠ᨣᩃᩴ ᩈᩮᩣᨻ᩠ᨽᩴ, ᩈᨧ᩠ᨨᩥᨴ᩠ᨴᩮ ᩈᩩᩈᩥᩁᩴ ᨲᩥᩈᩩ;
ᨳᩥᨿᩴ ᨲᩩ ᨠᩣᩈᩩ ᩌᩅᩣᨭᩮᩣ, ᩈᨸ᩠ᨸᩁᩣᨩᩣ ᨲᩩ ᩅᩣᩈᩩᨠᩦ.
ᩋᨶᨶ᩠ᨲᩮᩣ ᨶᩣᨣᩁᩣᨩᩣ ᨳ, ᩅᩣᩉᩈᩮᩣ’ᨩᨣᩁᩮᩣ ᨽᩅᩮ;
ᨣᩮᩣᨶᩈᩮᩣ ᨲᩩ ᨲᩥᩃᩥᨧ᩠ᨨᩮᩣ ᨳ,
ᨴᩮᨯ᩠ᨯᩩᨽᩮᩣ ᩁᩣᨩᩩᩃᩮᩣ ᨽᩅᩮ.
ᨠᨾ᩠ᨻᩃᩮᩣ’ᩔᨲᩁᩮᩣ ᨾᩮᩁᩩ, ᨸᩣᨴᩮ ᨶᩣᨣᩣᨳ ᨵᨾ᩠ᨾᨶᩦ;
ᩈᩥᩃᩩᨲ᩠ᨲᩮᩣ ᨥᩁᩈᨸ᩠ᨸᩮᩣ ᨳ, ᨶᩦᩃᩈᨸ᩠ᨸᩮᩣ ᩈᩥᩃᩣᨽᩩ ᨧ.
ᩌᩈᩥᩅᩥᩈᩮᩣ ᨽᩩᨩᨦ᩠ᨣᩮᩣ’ᩉᩥ, ᨽᩩᨩᨣᩮᩣ ᨧ ᨽᩩᨩᨦ᩠ᨣᨾᩮᩣ;
ᩈᩁᩦᩈᨸᩮᩣ ᨹᨱᩦ ᩈᨸ᩠ᨸᩣ, ᩃᨣᨴ᩠ᨴᩣ ᨽᩮᩣᨣᩥ ᨸᨶ᩠ᨶᨣᩣ.
ᨴ᩠ᩅᩥᨩᩥᩅ᩠ᩉᩮᩣ ᩏᩁᨣᩮᩣ ᩅᩣᩊᩮᩣ, ᨴᩦᨥᩮᩣ ᨧ ᨴᩦᨥᨸᩥᨭ᩠ᨮᩥᨠᩮᩣ;
ᨸᩣᨴᩪᨴᩁᩮᩣ ᩅᩥᩈᨵᩁᩮᩣ, ᨽᩮᩣᨣᩮᩣ ᨲᩩ ᨹᨱᩥᨶᩮᩣ ᨲᨶᩩ.
ᩌᩈᩦ’ᨲ᩠ᨳᩦ ¶ ᩈᨸ᩠ᨸᨴᩣᨮᩣ ᨳ, ᨶᩥᨾ᩠ᨾᩮᩣᨠᩮᩣ ᨠᨬ᩠ᨧᩩᨠᩮᩣ ᩈᨾᩣ;
ᩅᩥᩈᩴ ᨲ᩠ᩅ’ᨶᩥᨲ᩠ᨳᩦ ᨣᩁᩊᩴ, ᨲᨻ᩠ᨽᩮᨴᩣ ᩅᩣ ᩉᩃᩣᩉᩃᩮᩣ.
ᨠᩣᩊᨠᩪᨭᩣᨴᨿᩮᩣ ᨧᩣᨳ, ᩅᩣᩊᨣ᩠ᨣᩣᨲ᩠ᨿ’ᩉᩥᨲᩩᨱ᩠ᨯᩥᨠᩮᩣ;
ᨶᩥᩁᨿᩮᩣ ᨴᩩᨣ᩠ᨣᨲᩥ’ᨲ᩠ᨳᩦ ᨧ, ᨶᩁᨠᩮᩣ, ᩈᩮᩣ ᨾᩉᩣ’ᨭ᩠ᨮᨵᩣ;
ᩈᨬ᩠ᨩᩦᩅᩮᩣ ᨠᩣᩊᩈᩩᨲ᩠ᨲᩮᩣ ᨧ, ᨾᩉᩣᩁᩮᩣᩁᩩᩅ ᩁᩮᩣᩁᩩᩅᩣ;
ᨸᨲᩣᨸᨶᩮᩣ ᩋᩅᩦᨧᩥ’ᨲ᩠ᨳᩦ, ᩈᨦ᩠ᨥᩣᨲᩮᩣ ᨲᩣᨸᨶᩮᩣ ᩍᨲᩥ.
ᨳᩥᨿᩴ ᩅᩮᨲᩁᨱᩦ ᩃᩮᩣᩉ, ᨠᩩᨾ᩠ᨽᩦ ᨲᨲ᩠ᨳ ᨩᩃᩣᩈᨿᩣ;
ᨠᩣᩁᨱᩥᨠᩮᩣ ᨶᩥᩁᨿᨸᩮᩣ,
ᨶᩮᩁᨿᩥᨠᩮᩣ ᨲᩩ ᨶᩣᩁᨠᩮᩣ.
ᩋᨱ᩠ᨱᩅᩮᩣ ᩈᩣᨣᩁᩮᩣ ᩈᩥᨶ᩠ᨵᩩ, ᩈᨾᩩᨴ᩠ᨴᩮᩣ ᩁᨲᨶᩣᨠᩁᩮᩣ;
ᨩᩃᨶᩥᨫᩩ’ ᨴᨵᩥ, ᨲᩔ, ᨽᩮᨴᩣ ᨡᩦᩁᨱ᩠ᨱᩅᩣᨴᨿᩮᩣ.
ᩅᩮᩃᩣ’ᩔ ᨠᩪᩃᨴᩮᩈᩮᩣ ᨳ,
ᩌᩅᨭ᩠ᨭᩮᩣ ᩈᩃᩥᩃᨻ᩠ᨽᨾᩮᩣ;
ᨳᩮᩅᩮᩣ ᨲᩩ ᨻᩥᨶ᩠ᨴᩩ ᨹᩩᩈᩥᨲᩴ, ᨽᨾᩮᩣ ᨲᩩ ᨩᩃᨶᩥᨣ᩠ᨣᨾᩮᩣ.
ᩌᨸᩮᩣ ᨸᨿᩮᩣ ᨩᩃᩴ ᩅᩣᩁᩥ, ᨸᩣᨶᩦᨿᩴ ᩈᩃᩥᩃᩴ ᨴᨠᩴ;
ᩋᨱ᩠ᨱᩮᩣ ᨶᩦᩁᩴ ᩅᨶᩴ ᩅᩣᩃᩴ, ᨲᩮᩣᨿᩴ ᩋᨾ᩠ᨻᩩ’ᨴᨠᨬ᩠ᨧ ᨠᩴ.
ᨲᩁᨦ᩠ᨣᩮᩣ ᨧ ᨲᨳᩣ ᨽᨦ᩠ᨣᩮᩣ, ᩐᨾᩥ ᩅᩦᨧᩥ ᨸᩩᨾᩥᨲ᩠ᨳᩥᨿᩴ;
ᩏᩃ᩠ᩃᩮᩣᩃᩮᩣ ᨲᩩ ᨧ ᨠᩃ᩠ᩃᩮᩣᩃᩮᩣ, ᨾᩉᩣᩅᩦᨧᩦᩈᩩ ᨠᨳ᩠ᨿᨲᩮ.
ᨩᨾ᩠ᨻᩣᩃᩮᩣ ᨠᩃᩃᩴ ᨸᨦ᩠ᨠᩮᩣ, ᨧᩥᨠ᩠ᨡᩃ᩠ᩃᩴ ᨠᨴ᩠ᨴᨾᩮᩣ ᨸ᩠ᨿᨳ;
ᨸᩩᩃᩥᨶᩴ ᩅᩣᩃᩩᨠᩣ ᩅᨱ᩠ᨱᩩ, ᨾᩁᩪ’ᩁᩩ ᩈᩥᨠᨲᩣ ᨽᩅᩮ.
ᩋᨶ᩠ᨲᩁᩦᨸᨬ᩠ᨧ ᨴᩦᨸᩮᩣ ᩅᩣ, ᨩᩃᨾᨩ᩠ᨫᨣᨲᩴ ᨳᩃᩴ;
ᨲᩦᩁᩴ ᨲᩩ ᨠᩪᩃᩴ ᩁᩮᩣᨵᨬ᩠ᨧ, ᨸᨲᩦᩁᨬ᩠ᨧ ᨲᨭᩴ ᨲᩥᩈᩩ.
ᨸᩣᩁᩴ ᨸᩁᨾ᩠ᩉᩥ ᨲᩦᩁᨾ᩠ᩉᩥ, ᩒᩁᩴ ᨲ᩠ᩅ’ᨸᩣᩁ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᩏᩊᩩᨾ᩠ᨸᩮᩣ [ᩏᩊᩩᨸᩮᩣ (ᨠ.)] ᨲᩩ ᨸ᩠ᩃᩅᩮᩣ ᨠᩩᩃ᩠ᩃᩮᩣ, ᨲᩁᩮᩣ ᨧ ᨸᨧ᩠ᨧᩁᩦ’ᨲ᩠ᨳᩥᨿᩴ.
ᨲᩁᨱᩦ ᨲᩁᩥ ᨶᩣᩅᩣ ᨧ, ᨠᩪᨸᨠᩮᩣ ᨲᩩ ᨧ ᨠᩩᨾ᩠ᨽᨠᩴ;
ᨸᨧ᩠ᨨᩣᨻᨶ᩠ᨵᩮᩣ ᨣᩮᩣᨭᩅᩥᩈᩮᩣ, ᨠᨱ᩠ᨱᨵᩣᩁᩮᩣ ᨲᩩ ᨶᩣᩅᩥᨠᩮᩣ.
ᩋᩁᩥᨲ᩠ᨲᩴ ᨠᩮᨶᩥᨸᩣᨲᩮᩣ ᨳ,
ᨸᩮᩣᨲᩅᩣᩉᩮᩣ ᨶᩥᨿᩣᨾᨠᩮᩣ;
ᩈᩴᨿᨲ᩠ᨲᩥᨠᩣ ᨲᩩ ᨶᩣᩅᩣᨿ, ᩅᩣᨱᩥᨩ᩠ᨩᨾᩣᨧᩁᨶ᩠ᨲᩥ ᨿᩮ.
ᨶᩣᩅᩣᨿ’ᨦ᩠ᨣᩣ’ ¶ ᩃᨦ᩠ᨠᩣᩁᩮᩣ ᨧ, ᩅᨭᩣᨠᩣᩁᩮᩣ ᨹᩥᨿᩣᨴᨿᩮᩣ;
ᨸᩮᩣᨲᩮᩣ ᨸᩅᩉᨶᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨴᩮᩣᨱᩥ ᨲ᩠ᩅᩥ’ᨲ᩠ᨳᩦ ᨲᨳᩣ’ᨾ᩠ᨻᨱᩴ [ᩋᨾ᩠ᨾᨱᩴ (ᩈᩦ.)].
ᨣᨽᩦᩁ ᨶᩥᨶ᩠ᨶ ᨣᨾ᩠ᨽᩦᩁᩣ, ᨳᩮᩣ ᨲ᩠ᨲᩣᨶᩴ ᨲᨻ᩠ᨻᩥᨸᨠ᩠ᨡᨠᩮ;
ᩋᨣᩣᨵᩴ ᨲ᩠ᩅ’ᨲᩃᨾ᩠ᨹᩔᩴ, ᩋᨶᨧ᩠ᨨᩮᩣ ᨠᩃᩩᩈᩣ’ᩅᩥᩃᩣ.
ᩋᨧ᩠ᨨᩮᩣ ᨸᩈᨶ᩠ᨶᩮᩣ ᩅᩥᨾᩃᩮᩣ, ᨣᨽᩦᩁᨸ᩠ᨸᨽᩩᨲᩦ ᨲᩥᩈᩩ;
ᨵᩦᩅᩁᩮᩣ ᨾᨧ᩠ᨨᩥᨠᩮᩣ ᨾᨧ᩠ᨨ, ᨻᨶ᩠ᨵ ᨠᩮᩅᨭ᩠ᨭ ᨩᩣᩃᩥᨠᩣ.
ᨾᨧ᩠ᨨᩮᩣ ᨾᩦᨶᩮᩣ ᨩᩃᨧᩁᩮᩣ, ᨸᩩᨳᩩᩃᩮᩣᨾᩮᩣ’ᨾ᩠ᨻᩩᨩᩮᩣ ᨫᩈᩮᩣ;
ᩁᩮᩣᩉᩥᨲᩮᩣ ᨾᨣ᩠ᨣᩩᩁᩮᩣ ᩈᩥᨦ᩠ᨣᩦ, ᨻᩃᨩᩮᩣ ᨾᩩᨬ᩠ᨩ ᨸᩣᩅᩩᩈᩣ.
ᩈᨲ᩠ᨲᩅᨦ᩠ᨠᩮᩣ ᩈᩅᨦ᩠ᨠᩮᩣ ᨧ, ᨶᩊᨾᩦᨶᩮᩣ ᨧ ᨣᨱ᩠ᨯᨠᩮᩣ;
ᩈᩩᩈᩩᨠᩣ ᩈᨹᩁᩦ ᨾᨧ᩠ᨨ, ᨸ᩠ᨸᨽᩮᨴᩣ ᨾᨠᩁᩣᨴᨿᩮᩣ.
ᨾᩉᩣᨾᨧ᩠ᨨᩣ ᨲᩥᨾᩥ ᨲᩥᨾᩥ, ᨦ᩠ᨣᩃᩮᩣ ᨲᩥᨾᩥᩁᨸᩥᨦ᩠ᨣᩃᩮᩣ;
ᩌᨶᨶ᩠ᨴᩮᩣ ᨲᩥᨾᩥᨶᨶ᩠ᨴᩮᩣ ᨧ, ᩋᨩ᩠ᨫᩣᩁᩮᩣᩉᩮᩣ ᨾᩉᩣᨲᩥᨾᩥ.
ᨸᩣᩈᩣᨱᨾᨧ᩠ᨨᩮᩣ ᨸᩣᨮᩦᨶᩮᩣ, ᩅᨦ᩠ᨠᩮᩣ ᨲᩩ ᨻᩊᩥᩈᩮᩣ ᨽᩅᩮ;
ᩈᩩᩈᩩᨾᩣᩁᩮᩣ [ᩈᩴᩈᩩᨾᩣᩁᩮᩣ (ᨭᩦ.), ᩈᩩᩴᩈᩩᨾᩣᩁᩮᩣ (ᩈᩦ.)] ᨲᩩ ᨠᩩᨾ᩠ᨽᩦᩃᩮᩣ,
ᨶᨠ᩠ᨠᩮᩣ ᨠᩩᨾ᩠ᨾᩮᩣ ᨲᩩ ᨠᨧ᩠ᨨᨸᩮᩣ.
ᨠᨠ᩠ᨠᨭᨠᩮᩣ ᨠᩩᩊᩦᩁᩮᩣ ᨧ, ᨩᩃᩪᨠᩣ ᨲᩩ ᨧ ᩁᨲ᩠ᨲᨸᩣ;
ᨾᨱ᩠ᨯᩪᨠᩮᩣ ᨴᨴ᩠ᨴᩩᩁᩮᩣ ᨽᩮᨠᩮᩣ;
ᨣᨱ᩠ᨯᩩᨸ᩠ᨸᩣᨴᩮᩣ ᨾᩉᩦᩃᨲᩣ.
ᩋᨳ ᩈᩥᨸ᩠ᨸᩦ ᨧ ᩈᩩᨲ᩠ᨲᩥ’ᨲ᩠ᨳᩦ, ᩈᨦ᩠ᨡᩮ ᨲᩩ ᨠᨾ᩠ᨻᩩ’ᨶᩥᨲ᩠ᨳᩥᨿᩴ;
ᨡᩩᨴ᩠ᨴᩈᨦ᩠ᨡ᩠ᨿᩮ ᩈᨦ᩠ᨡᨶᨡᩮᩣ, ᨩᩃᩈᩩᨲ᩠ᨲᩥ ᨧ ᩈᨾ᩠ᨻᩩᨠᩮᩣ.
ᨩᩃᩣᩈᨿᩮᩣ ᨩᩃᩣᨵᩣᩁᩮᩣ, ᨣᨾ᩠ᨽᩦᩁᩮᩣ ᩁᩉᨴᩮᩣ ᨳ ᨧ;
ᩏᨴᨸᩣᨶᩮᩣ ᨸᩣᨶᨠᩪᨸᩮᩣ, ᨡᩣᨲᩴ ᨸᩮᩣᨠ᩠ᨡᩁᨱᩦ’ᨲ᩠ᨳᩥᨿᩴ.
ᨲᩊᩣᨠᩮᩣ ᨧ ᩈᩁᩮᩣ’ᨶᩥᨲ᩠ᨳᩦ, ᩅᩣᨸᩦ ᨧ ᩈᩁᩈᩦ’ᨲ᩠ᨳᩥᨿᩴ;
ᨴᩉᩮᩣ’ᨾ᩠ᨻᩩᨩᩣᨠᩁᩮᩣ ᨧᩣᨳ, ᨸᩃ᩠ᩃᩃᩴ ᨡᩩᨴ᩠ᨴᨠᩮᩣ ᩈᩁᩮᩣ.
ᩋᨶᩮᩣᨲᨲ᩠ᨲᩮᩣ ᨲᨳᩣ ᨠᨱ᩠ᨱ, ᨾᩩᨱ᩠ᨯᩮᩣ ᨧ ᩁᨳᨠᩣᩁᨠᩮᩣ;
ᨨᨴ᩠ᨴᨶ᩠ᨲᩮᩣ ᨧ ᨠᩩᨱᩣᩃᩮᩣ ᨧ, ᩅᩩᨲ᩠ᨲᩣ ᨾᨶ᩠ᨴᩣᨠᩥᨶᩦ’ᨲ᩠ᨳᩥᨿᩴ.
ᨲᨳᩣ ᩈᩦᩉᨸ᩠ᨸᨸᩣᨲᩮᩣᨲᩥ, ᩑᨲᩮ ᩈᨲ᩠ᨲ ᨾᩉᩣᩈᩁᩣ;
ᩌᩉᩣᩅᩮᩣ ᨲᩩ ᨶᩥᨸᩣᨶᨬ᩠ᨧᩣ, ᨡᩣᨲᩴ ᨲᩩ ᨴᩮᩅᨡᩣᨲᨠᩴ.
ᩈᩅᨶ᩠ᨲᩦ ¶ ᨶᩥᨶ᩠ᨶᨣᩣ ᩈᩥᨶ᩠ᨵᩩ, ᩈᩁᩥᨲᩣ ᩌᨸᨣᩣ ᨶᨴᩦ;
ᨽᩣᨣᩦᩁᨳᩦ ᨲᩩ ᨣᨦ᩠ᨣᩣ ᨳ, ᩈᨾ᩠ᨽᩮᨴᩮᩣ ᩈᩥᨶ᩠ᨵᩩᩈᨦ᩠ᨣᨾᩮᩣ.
ᨣᨦ᩠ᨣᩣ’ᨧᩥᩁᩅᨲᩦ ᨧᩮᩅ, ᨿᨾᩩᨶᩣ ᩈᩁᨽᩪ (ᩈᩁᨻᩪ [ᩈᩁᨿᩪ (ᨠ.)] ) ᨾᩉᩦ;
ᩍᨾᩣ ᨾᩉᩣᨶᨴᩦ ᨸᨬ᩠ᨧ, ᨧᨶ᩠ᨴᨽᩣᨣᩣ ᩈᩁᩔᨲᩦ [ᩈᩁᩈ᩠ᩅᨲᩦ (ᩈᩦ. ᨭᩦ.)].
ᨶᩮᩁᨬ᩠ᨩᩁᩣ ᨧ ᨠᩣᩅᩮᩁᩦ, ᨶᨾ᩠ᨾᨴᩣᨴᩦ ᨧ ᨶᩥᨶ᩠ᨶᨣᩣ;
ᩅᩣᩁᩥᨾᨣ᩠ᨣᩮᩣ ᨸᨱᩣᩃᩦ’ᨲ᩠ᨳᩦ [ᨸᨶᩣᩊᩦ (ᨭᩦ.)], ᨸᩩᨾᩮ ᨧᨶ᩠ᨴᨶᩥᨠᩣ ᨲᩩ ᨧ.
ᨩᨾ᩠ᨻᩣᩃᩦ ᩒᩃᩥᨣᩃ᩠ᩃᩮᩣ ᨧ, ᨣᩣᨾᨴ᩠ᩅᩣᩁᨾ᩠ᩉᩥ ᨠᩣᩈᩩᨿᩴ;
ᩈᩁᩮᩣᩁᩩᩉᩴ ᩈᨲᨸᨲ᩠ᨲᩴ, ᩋᩁᩅᩥᨶ᩠ᨴᨬ᩠ᨧ ᩅᩣᩁᩥᨩᩴ.
ᩋᨶᩥᨲ᩠ᨳᩦ ᨸᨴᩩᨾᩴ ᨸᨦ᩠ᨠᩮ, ᩁᩩᩉᩴ ᨶᩃᩥᨶ ᨸᩮᩣᨠ᩠ᨡᩁᩴ;
ᨾᩩᩊᩣᩃᨸᩩᨸ᩠ᨹᩴ ᨠᨾᩃᩴ, ᨽᩥᩈᨸᩩᨸ᩠ᨹᩴ ᨠᩩᩈᩮᩈᨿᩴ.
ᨸᩩᨱ᩠ᨯᩁᩦᨠᩴ ᩈᩥᨲᩴ, ᩁᨲ᩠ᨲᩴ, ᨠᩮᩣᨠᨶᨴᩴ ᨠᩮᩣᨠᩣᩈᨠᩮᩣ;
ᨠᩥᨬ᩠ᨩᨠ᩠ᨡᩮᩣ ᨠᩮᩈᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨴᨱ᩠ᨯᩮᩣ ᨲᩩ ᨶᩣᩃ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᨽᩥᩈᩴ ᨾᩩᩊᩣᩃᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨧ, ᨻᩦᨩᨠᩮᩣᩈᩮᩣ ᨲᩩ ᨠᨱ᩠ᨱᩥᨠᩣ;
ᨸᨴᩩᨾᩣᨴᩥᩈᨾᩪᩉᩮ ᨲᩩ, ᨽᩅᩮ ᩈᨱ᩠ᨯᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.
ᩏᨸ᩠ᨸᩃᩴ ᨠᩩᩅᩃᨿᨬ᩠ᨧ, ᨶᩦᩃᩴ ᨲ᩠ᩅᩥ’ᨶ᩠ᨴᩦᩅᩁᩴ ᩈᩥᨿᩣ;
ᩈᩮᨲᩮᨲᩩ ᨠᩩᨾᩩᨴᨬ᩠ᨧᩔ, ᨠᨶ᩠ᨴᩮᩣ ᩈᩣᩃᩪᨠ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩈᩮᩣᨣᨶ᩠ᨵᩥᨠᩴ ᨠᩃ᩠ᩃᩉᩣᩁᩴ, ᨴᨠᩈᩦᨲᩃᩥᨠᩴ ᨸ᩠ᨿᨳ;
ᩈᩮᩅᩣᩃᩮᩣ ᨶᩦᩃᩥᨠᩣ ᨧᩣᨳ, ᨽᩥᩈᩥᨶ᩠ᨿ’ᨾ᩠ᨻᩩᨩᩥᨶᩦ ᨽᩅᩮ.
᪖᪙᪐. ᩈᩮᩅᩣᩃᩣ ᨲᩥᩃᨻᩦᨩᨬ᩠ᨧ, ᩈᨦ᩠ᨡᩮ ᨧ ᨸᨱᨠᩣᨴᨿᩮᩣᨲᩥ.
ᩍᨲᩥ ᨸᩣᨲᩣᩃᩅᨣ᩠ᨣᩮᩣ.
ᨽᩪᨠᨱ᩠ᨯᩮᩣ ᨴᩩᨲᩥᨿᩮᩣ.
᪓. ᩈᩣᨾᨬ᩠ᨬᨠᨱ᩠ᨯ
᪑. ᩅᩥᩈᩮᩈ᩠ᨿᩣᨵᩦᨶᩅᨣ᩠ᨣ
ᩅᩥᩈᩮᩈ᩠ᨿᩣᨵᩦᨶ ᩈᩴᨠᩥᨱ᩠ᨱᩣ, ᨶᩮᨠᨲ᩠ᨳᩮᩉ᩠ᨿ’ᨻ᩠ᨿᨿᩮᩉᩥ ᨧ;
ᩈᩣ’ᨦ᩠ᨣᩮᩣ’ᨸᩣᨦ᩠ᨣᩮᩉᩥ ᨠᨳ᩠ᨿᨶ᩠ᨲᩮ, ᨠᨱ᩠ᨯᩮ ᩅᨣ᩠ᨣᩣ ᩍᩉ ᨠ᩠ᨠᨾᩣ.
ᨣᩩᨱᨴᨻ᩠ᨻᨠᩕᩥᨿᩣᩈᨴ᩠ᨴᩣ, ¶ ᩈᩥᨿᩩᩴ ᩈᨻ᩠ᨻᩮ ᩅᩥᩈᩮᩈᨶᩣ;
ᩅᩥᩈᩮᩈ᩠ᨿᩣᨵᩦᨶᨽᩣᩅᩮᨶ, ᩅᩥᩈᩮᩈ᩠ᨿᩈᨾᩃᩥᨦ᩠ᨣᩥᨶᩮᩣ.
ᩈᩮᩣᨽᨶᩴ ᩁᩩᨧᩥᩁᩴ ᩈᩣᨵᩩ, ᨾᨶᩩᨬ᩠ᨬᩴ ᨧᩣᩁᩩ ᩈᩩᨶ᩠ᨴᩁᩴ;
ᩅᨣ᩠ᨣᩩ ᨾᨶᩮᩣᩁᨾᩴ ᨠᨶ᩠ᨲᩴ, ᩉᩣᩁᩦ ᨾᨬ᩠ᨩᩩ ᨧ ᨸᩮᩈᩃᩴ.
ᨽᨴ᩠ᨴᩴ ᩅᩣᨾᨬ᩠ᨧ ᨠᩃ᩠ᨿᩣᨱᩴ, ᨾᨶᩣᨸᩴ ᩃᨴ᩠ᨵᨠᩴ ᩈᩩᨽᩴ;
ᩏᨲ᩠ᨲᨾᩮᩣ ᨸᩅᩁᩮᩣ ᨩᩮᨭ᩠ᨮᩮᩣ, ᨸᨾᩩᨡᩣ’ᨶᩩᨲ᩠ᨲᩁᩮᩣ ᩅᩁᩮᩣ.
ᨾᩩᨡ᩠ᨿᩮᩣ ᨸᨵᩣᨶᩴ ᨸᩣᨾᩮᩣᨠ᩠ᨡᩮᩣ, ᨸᩁ ᨾᨣ᩠ᨣᨬ᩠ᨬ ᨾᩩᨲ᩠ᨲᩁᩴ;
ᨸᨱᩦᨲᩴ ᨸᩁᨾᩴ ᩈᩮᨿ᩠ᨿᩮᩣ, ᨣᩣᨾᨱᩦ ᩈᩮᨭ᩠ᨮ ᩈᨲ᩠ᨲᨾᩣ.
ᩅᩥᩈᩥᨭ᩠ᨮᩣ’ᩁᩥᨿ ᨶᩣᨣᩮ’ᨠᩮᩣ, ᩈᨽᨣ᩠ᨣᩣ ᨾᩮᩣᨠ᩠ᨡ ᨸᩩᨦ᩠ᨣᩅᩣ;
ᩈᩦᩉ ᨠᩩᨬ᩠ᨩᩁ ᩈᨴ᩠ᨴᩪᩃᩣ, ᨴᩦ ᨲᩩ ᩈᨾᩣᩈᨣᩣ ᨸᩩᨾᩮ.
ᨧᩥᨲ᩠ᨲ’ᨠ᩠ᨡᩥ ᨸᩦᨲᩥᨩᨶᨶ, ᨾᨻ᩠ᨿᩣᩈᩮᨠ ᨾᩈᩮᨧᨶᩴ;
ᩍᨭ᩠ᨮᩴ ᨲᩩ ᩈᩩᨽᨣᩴ ᩉᨩ᩠ᨩᩴ, ᨴᨿᩥᨲᩴ ᩅᩃ᩠ᩃᨽᩴ ᨸᩥᨿᩴ.
ᨲᩩᨧ᩠ᨨᨬ᩠ᨧ ᩁᩥᨲ᩠ᨲᨠᩴ ᩈᩩᨬ᩠ᨬᩴ, ᩋᨳᩣ’ᩈᩣᩁᨬ᩠ᨧ ᨹᩮᨣ᩠ᨣᩩ ᨧ;
ᨾᩮᨩ᩠ᨫᩴ ᨸᩪᨲᩴ ᨸᩅᩥᨲ᩠ᨲᩮᩣ ᨳ, ᩋᩅᩥᩁᨴ᩠ᨵᩮᩣ ᩋᨸᨱ᩠ᨱᨠᩮᩣ.
ᩏᨠ᩠ᨠᨭ᩠ᨮᩮᩣ ᨧ ᨸᨠᨭ᩠ᨮᩮᩣ ᨳ, ᨶᩥᩉᩦᨶᩮᩣ ᩉᩦᨶ ᩃᩣᨾᨠᩣ;
ᨸᨲᩥᨠᩥᨭ᩠ᨮᩴ ᨶᩥᨠᩥᨭ᩠ᨮᨬ᩠ᨧ, ᩍᨲ᩠ᨲᩁᩣ’ᩅᨩ᩠ᨩ ᨠᩩᨧ᩠ᨨᩥᨲᩣ.
ᩋᨵᨾᩮᩣ’ᨾᨠ ᨣᩣᩁᨿ᩠ᩉᩣ,
ᨾᩃᩦᨶᩮᩣ ᨲᩩ ᨾᩃᩦᨾᩈᩮᩣ;
ᨻᩕᩉᩣ ᨾᩉᨶ᩠ᨲᩴ ᩅᩥᨸᩩᩃᩴ, ᩅᩥᩈᩣᩃᩴ ᨸᩩᨳᩩᩃᩴ ᨸᩩᨳᩩ.
ᨣᩁᩩ’ᩁᩩ ᩅᩥᨲ᩠ᨳᩥᨱ᩠ᨱ ᨾᨳᩮᩣ, ᨸᩦᨶᩴ ᨳᩪᩃᨬ᩠ᨧ ᨸᩦᩅᩁᩴ;
ᨳᩩᩃ᩠ᩃᨬ᩠ᨧ ᩅᨮᩁᨬ᩠ᨧᩣ ᨳ, ᩌᨧᩥᨲᩴ ᨶᩥᨧᩥᨲᩴ ᨽᩅᩮ.
ᩈᨻ᩠ᨻᩴ ᩈᨾᨲ᩠ᨲ ᨾᨡᩥᩃᩴ, ᨶᩥᨡᩥᩃᩴ ᩈᨠᩃᩴ ᨲᨳᩣ;
ᨶᩥᩔᩮᩈᩴ ᨠᩈᩥᨱᩣ’ᩈᩮᩈᩴ, ᩈᨾᨣ᩠ᨣᨬ᩠ᨧ ᩋᨶᩪᨶᨠᩴ,
ᨽᩪᩁᩥ ᨸᩉᩩᨲᩴ ᨸᨧᩩᩁᩴ, ᨽᩥᨿ᩠ᨿᩮᩣ ᩈᨾ᩠ᨻᩉᩩᩃᩴ ᨻᩉᩩ;
ᨿᩮᨽᩩᨿ᩠ᨿᩴ ᨻᩉᩩᩃᩴ ᨧᩣᨳ, ᨻᩣᩉᩥᩁᩴ ᨸᩁᩥᨻᩣᩉᩥᩁᩴ.
ᨸᩁᩮᩣᩈᨲᩣᨴᩦ ᨲᩮ, ᨿᩮᩈᩴ, ᨸᩁᩴ ᨾᨲ᩠ᨲᩴ ᩈᨲᩣᨴᩥᨲᩮᩣ;
ᨸᩁᩥᨲ᩠ᨲᩴ ᩈᩩᨡᩩᨾᩴ ᨡᩩᨴ᩠ᨴᩴ, ᨳᩮᩣᨠ ᨾᨸ᩠ᨸᩴ ᨠᩥᩈᩴ ᨲᨶᩩ.
ᨧᩩᩃ᩠ᩃᩴ ᨾᨲ᩠ᨲᩮ’ᨲ᩠ᨳᩥᨿᩴ ᩃᩮᩈ,
ᩃᩅᩣ’ᨱᩩᩉᩥ ᨠᨱᩮᩣ ᨸᩩᨾᩮ;
ᩈᨾᩦᨸᩴ ᨶᩥᨠᨭᩣ’ᩈᨶ᩠ᨶᩮᩣ, ᨸᨠᨭ᩠ᨮᩣ’ᨽ᩠ᨿᩣᩈ ᩈᨶ᩠ᨲᩥᨠᩴ.
ᩋᩅᩥᨴᩪᩁᨬ᩠ᨧ ¶ ᩈᩣᨾᨶ᩠ᨲᩴ, ᩈᨶ᩠ᨶᩥᨠᨭ᩠ᨮ ᨾᩩᨸᨶ᩠ᨲᩥᨠᩴ;
ᩈᨠᩣᩈᩴ ᩋᨶ᩠ᨲᩥᨠᩴ ᨬᨲ᩠ᨲᩴ, ᨴᩪᩁᩴ ᨲᩩ ᩅᩥᨸ᩠ᨸᨠᨭ᩠ᨮᨠᩴ.
ᨶᩥᩁᨶ᩠ᨲᩁᩴ ᨥᨶᩴ ᩈᨶ᩠ᨴᩴ, ᩅᩥᩁᩊᩴ ᨸᩮᩃᩅᩴ ᨲᨶᩩ;
ᩋᨳᩣ ᨿᨲᩴ ᨴᩦᨥ ᨾᨳᩮᩣ, ᨶᩥᨲ᩠ᨲᩃᩴ ᩅᨭ᩠ᨭ ᩅᨭ᩠ᨭᩩᩃᩴ.
ᩏᨧ᩠ᨧᩮᩣ ᨲᩩ ᩏᨶ᩠ᨶᨲᩮᩣ ᨲᩩᨦ᩠ᨣᩮᩣ, ᩏᨴᨣ᩠ᨣᩮᩣ ᨧᩮᩅ ᩏᨧ᩠ᨨᩥᨲᩮᩣ;
ᨶᩦᨧᩮᩣ ᩁᩔᩮᩣ ᩅᩣᨾᨶᩮᩣ ᨳ, ᩋᨩᩥᨾ᩠ᩉᩮᩣ ᨸᨣᩩᨱᩮᩣ ᩏᨩᩩ.
ᩋᩊᩣᩁᩴ ᩅᩮᩃ᩠ᩃᩥᨲᩴ ᩅᨦ᩠ᨠᩴ, ᨠᩩᨭᩥᩃᩴ ᨩᩥᨾ᩠ᩉ ᨠᩩᨬ᩠ᨧᩥᨲᩴ;
ᨵᩩᩅᩮᩣ ᨧ ᩈᩔᨲᩮᩣ ᨶᩥᨧ᩠ᨧᩮᩣ, ᩈᨴᩣᨲᨶ ᩈᨶᨶ᩠ᨲᨶᩣ.
ᨠᩪᨭᨭ᩠ᨮᩮᩣ ᨲ᩠ᩅᩮ’ᨠᩁᩪᨸᩮᨶ, ᨠᩣᩃᨻ᩠ᨿᩣᨸᩦ ᨸᨠᩣᩈᩥᨲᩮᩣ;
ᩃᩉᩩ ᩈᩃ᩠ᩃᩉᩩᨠᩴ ᨧᩣᨳ, ᩈᨦ᩠ᨡ᩠ᨿᩣᨲᩴ ᨣᨱᩥᨲᩴ ᨾᩥᨲᩴ.
ᨲᩥᨱ᩠ᩉᩴ ᨲᩩ ᨲᩥᨡᩥᨱᩴ ᨲᩥᨻ᩠ᨻᩴ, ᨧᨱ᩠ᨯᩴ ᩏᨣ᩠ᨣᩴ ᨡᩁᩴ ᨽᩅᩮ;
ᨩᨦ᩠ᨣᨾᨬ᩠ᨧ ᨧᩁᨬ᩠ᨧᩮᩅ, ᨲᩈᩴ ᨬᩮᨿ᩠ᨿᩴ ᨧᩁᩣᨧᩁᩴ.
ᨠᨾ᩠ᨸᨶᩴ ᨧᩃᨶᩴ ᨧᩣᨳ, ᩋᨲᩥᩁᩥᨲ᩠ᨲᩮᩣ ᨲᨳᩣ’ᨵᩥᨠᩮᩣ;
ᨳᩣᩅᩁᩮᩣ ᨩᨦ᩠ᨣᨾᩣ ᩋᨬ᩠ᨬᩮᩣ, ᩃᩮᩣᩃᩴ ᨲᩩ ᨧᨬ᩠ᨧᩃᩴ ᨧᩃᩴ.
ᨲᩁᩃᨬ᩠ᨧ ᨸᩩᩁᩣᨱᩮᩣ ᨲᩩ, ᨸᩩᩁᩣᨲᨶ ᩈᨶᨶ᩠ᨲᨶᩣ;
ᨧᩥᩁᨶ᩠ᨲᨶᩮᩣ ᨳ ᨸᨧ᩠ᨧᨣ᩠ᨥᩮᩣ, ᨶᩪᨲᨶᩮᩣ’ᨽᩥᨶᩅᩮᩣ ᨶᩅᩮᩣ.
ᨠᩩᩁᩪᩁᩴ ᨠᨮᩥᨶᩴ ᨴᩊ᩠ᩉᩴ, ᨶᩥᨭ᩠ᨮᩩᩁᩴ ᨠᨠ᩠ᨡᩊᩴ ᨽᩅᩮ;
ᩋᨶᩥᨲ᩠ᨳ᩠ᨿ’ᨶ᩠ᨲᩮᩣ ᨸᩁᩥᨿᨶ᩠ᨲᩮᩣ, ᨸᨶ᩠ᨲᩮᩣ ᨧ ᨸᨧ᩠ᨨᩥᨾ’ᨶ᩠ᨲᩥᨾᩣ.
ᨩᩥᨥᨬ᩠ᨬᩴ ᨧᩁᩥᨾᩴ ᨸᩩᨻ᩠ᨻᩴ, ᨲ᩠ᩅ’ᨣ᩠ᨣᩴ ᨸᨮᨾ ᨾᩣᨴᩥ ᩈᩮᩣ;
ᨸᨲᩥᩁᩪᨸᩮᩣ ᨶᩩᨧ᩠ᨨᩅᩥᨠᩴ, ᩋᨳ ᨾᩮᩣᨥᩴ ᨶᩥᩁᨲ᩠ᨳᨠᩴ.
ᨻ᩠ᨿᨲ᩠ᨲᩴ ᨸᩩᨭ [ᨹᩩᨭᩴ (ᩈᩦ.)] ᨬ᩠ᨧ ᨾᩩᨴᩩ ᨲᩩ, ᩈᩩᨠᩩᨾᩣᩁᨬ᩠ᨧ ᨠᩮᩣᨾᩃᩴ;
ᨸᨧ᩠ᨧᨠ᩠ᨡᩴ ᩍᨶ᩠ᨴᩕᩥᨿᨣ᩠ᨣᨿ᩠ᩉᩴ, ᩋᨸᨧ᩠ᨧᨠ᩠ᨡᩴ ᩋᨲᩥᨶ᩠ᨴᩕᩥᨿᩴ.
ᩍᨲᩁᩣ’ᨬ᩠ᨬᨲᩁᩮᩣ ᩑᨠᩮᩣ, ᩋᨬ᩠ᨬᩮᩣ ᨻᩉᩩᩅᩥᨵᩮᩣ ᨲᩩ ᨧ;
ᨶᩣᨶᩣᩁᩪᨸᩮᩣ ᨧ ᩅᩥᩅᩥᨵᩮᩣ, ᩋᨻᩣᨵᩴ ᨲᩩ ᨶᩥᩁᨣ᩠ᨣᩃᩴ.
ᩋᨳᩮ’ᨠᩣᨠᩦ ᨧ ᩑᨠᨧ᩠ᨧᩮᩣ, ᩑᨠᩮᩣ ᨧ ᩑᨠᨠᩮᩣ ᩈᨾᩣ;
ᩈᩣᨵᩣᩁᨱᨬ᩠ᨧ ᩈᩣᨾᨬ᩠ᨬᩴ, ᩈᨾ᩠ᨻᩣᨵᩮᩣ ᨲᩩ ᨧ ᩈᩴᨠᨭᩴ.
ᩅᩣᨾᩴ ᨠᩊᩮᩅᩁᩴ ᩈᨻ᩠ᨿᩴ; ᩋᨸᩈᨻ᩠ᨿᩴ ᨲᩩ ᨴᨠ᩠ᨡᩥᨱᩴ;
ᨸᨭᩥᨠᩪᩃᩴ ᨲ᩠ᩅ’ᨸᩈᨻ᩠ᨿᩴ, ᨣᩉᨶᩴ ᨠᩃᩥᩃᩴ ᩈᨾᩣ.
ᩏᨧ᩠ᨧᩣᩅᨧᩴ ¶ ᨻᩉᩩᨽᩮᨴᩴ, ᩈᩴᨠᩥᨱ᩠ᨱᩣ’ ᨠᩥᨱ᩠ᨱ ᩈᩴᨠᩩᩃᩣ;
ᨠᨲᩉᨲ᩠ᨳᩮᩣ ᨧ ᨠᩩᩈᩃᩮᩣ, ᨸᩅᩦᨱᩣ’ᨽᩥᨬ᩠ᨬ ᩈᩥᨠ᩠ᨡᩥᨲᩣ.
ᨶᩥᨸᩩᨱᩮᩣ ᨧ ᨸᨭᩩ ᨨᩮᨠᩮᩣ, ᨧᩣᨲᩩᩁᩮᩣ ᨴᨠ᩠ᨡ ᨸᩮᩈᩃᩣ;
ᨻᩣᩃᩮᩣ ᨴᨲ᩠ᨲᩩ ᨩᩃᩮᩣ ᨾᩪᩊ᩠ᩉᩮᩣ, ᨾᨶ᩠ᨴᩮᩣ ᩅᩥᨬ᩠ᨬᩪ ᨧ ᨻᩣᩃᩥᩈᩮᩣ.
ᨸᩩᨬ᩠ᨬᩅᩣ ᩈᩩᨠᨲᩦ ᨵᨬ᩠ᨬᩮᩣ, ᨾᩉᩩᩔᩣᩉᩮᩣ ᨾᩉᩣᨵᩥᨲᩥ;
ᨾᩉᩣᨲᨱ᩠ᩉᩮᩣ ᨾᩉᩥᨧ᩠ᨨᩮᩣ ᨳ, ᩉᨴᨿᩦ ᩉᨴᨿᩣᩃᩩ ᨧ.
ᩈᩩᨾᨶᩮᩣ ᩉᨭ᩠ᨮᨧᩥᨲ᩠ᨲᩮᩣ ᨳ, ᨴᩩᨾ᩠ᨾᨶᩮᩣ ᩅᩥᨾᨶᩮᩣ ᨸ᩠ᨿᨳ;
ᩅᨴᩣᨶᩥᨿᩮᩣ ᩅᨴᨬ᩠ᨬᩪ ᨧ, ᨴᩣᨶᩈᩮᩣᨱ᩠ᨯᩮᩣ ᨻᩉᩩᨸ᩠ᨸᨴᩮᩣ.
ᨡ᩠ᨿᩣᨲᩮᩣ ᨸᨲᩦᨲᩮᩣ ᨸᨬ᩠ᨬᩣᨲᩮᩣ,
ᨽᩥᨬ᩠ᨬᩣᨲᩮᩣ ᨸᨳᩥᨲᩮᩣ ᩈᩩᨲᩮᩣ,
ᩅᩥᩔᩩᨲᩮᩣ ᩅᩥᨴᩥᨲᩮᩣ ᨧᩮᩅ, ᨸᩈᩥᨴ᩠ᨵᩮᩣ ᨸᩣᨠᨭᩮᩣ ᨽᩅᩮ.
ᩍᩔᩁᩮᩣ ᨶᩣᨿᨠᩮᩣ ᩈᩣᨾᩦ, ᨸᨲᩦ’ᩈᩣ’ᨵᩥᨸᨲᩦ ᨸᨽᩪ;
ᩋᨿ᩠ᨿᩣ’ᨵᩥᨸᩣ’ᨵᩥᨽᩪ ᨶᩮᨲᩣ,
ᩍᨻ᩠ᨽᩮᩣ ᨲ᩠ᩅ’ᨯ᩠ᨰᩮᩣ ᨲᨳᩣ ᨵᨶᩦ.
ᨴᩣᨶᩣᩁᩉᩮᩣ ᨴᨠ᩠ᨡᩥᨱᩮᨿ᩠ᨿᩮᩣ, ᩈᩥᨶᩥᨴ᩠ᨵᩮᩣ ᨲᩩ ᨧ ᩅᨧ᩠ᨨᩃᩮᩣ;
ᨸᩁᩥᨠ᩠ᨡᨠᩮᩣ ᨠᩣᩁᨱᩥᨠᩮᩣ,
ᩌᩈᨲ᩠ᨲᩮᩣ ᨲᩩ ᨧ ᨲᨸ᩠ᨸᩁᩮᩣ.
ᨠᩣᩁᩩᨱᩥᨠᩮᩣ ᨴᨿᩣᩃᩩᨸᩥ, ᩈᩪᩁᨲᩮᩣ ᩏᩔᩩᨠᩮᩣ ᨲᩩ ᨧ;
ᩍᨭ᩠ᨮᨲ᩠ᨳᩮ ᩏᨿ᩠ᨿᩩᨲᩮᩣ ᨧᩣᨳ, ᨴᩦᨥᩈᩩᨲ᩠ᨲᩮᩣ ᨧᩥᩁᨠᩕᩥᨿᩮᩣ.
ᨸᩁᩣᨵᩦᨶᩮᩣ ᨸᩁᩣᨿᨲ᩠ᨲᩮᩣ, ᩌᨿᨲ᩠ᨲᩮᩣ ᨲᩩ ᨧ ᩈᨶ᩠ᨲᨠᩮᩣ;
ᨸᩁᩥᨣ᩠ᨣᩉᩮᩣ ᩋᨵᩦᨶᩮᩣ ᨧ, ᩈᨧ᩠ᨨᨶ᩠ᨴᩮᩣ ᨲᩩ ᨧ ᩈᩮᩁᩥᨶᩥ.
ᩋᨶᩥᩈᨾ᩠ᨾᨠᩣᩁᩦ ᨩᨾ᩠ᨾᩮᩣ, ᩋᨲᩥᨲᨱ᩠ᩉᩮᩣ ᨲᩩ ᩃᩮᩣᩃᩩᨸᩮᩣ;
ᨣᩥᨴ᩠ᨵᩮᩣ ᨲᩩ ᩃᩩᨴ᩠ᨵᩮᩣ ᩃᩮᩣᩃᩮᩣ ᨳ,
ᨠᩩᨱ᩠ᨮᩮᩣ ᨾᨶ᩠ᨴᩮᩣ ᨠᩕᩥᨿᩣᩈᩩ ᩉᩥ.
ᨠᩣᨾᨿᩥᨲᩣ ᨲᩩ ᨠᨾᩥᨲᩣ, ᨠᩣᨾᨶᩮᩣ ᨠᩣᨾᩥ ᨠᩣᨾᩩᨠᩮᩣ;
ᩈᩮᩣᨱ᩠ᨯᩮᩣ ᨾᨲ᩠ᨲᩮᩣ ᩅᩥᨵᩮᨿ᩠ᨿᩮᩣ ᨲᩩ,
ᩋᩔᩅᩮᩣ ᩈᩩᨻ᩠ᨻᨧᩮᩣ ᩈᨾᩣ.
ᨸᨣᨻ᩠ᨽᩮᩣ ¶ ᨸᨭᩥᨽᩣᨿᩩᨲ᩠ᨲᩮᩣ, ᨽᩦᩈᩦᩃᩮᩣ ᨽᩦᩁᩩ ᨽᩦᩁᩩᨠᩮᩣ;
ᩋᨵᩦᩁᩮᩣ [ᩋᩅᩦᩁᩮᩣ (ᨭᩦ.)] ᨠᩣᨲᩁᩮᩣ ᨧᩣᨳ,
ᩉᩥᩴᩈᩣᩈᩦᩃᩮᩣ ᨧ ᨥᩣᨲᩩᨠᩮᩣ.
ᨠᩮᩣᨵᨶᩮᩣ ᩁᩮᩣᩈᨶᩮᩣ [ᨴᩮᩣᩈᨶᩮᩣ (ᩈᩦ.)] ᨠᩮᩣᨸᩦ,
ᨧᨱ᩠ᨯᩮᩣ ᨲ᩠ᩅᨧ᩠ᨧᨶ᩠ᨲᨠᩮᩣᨵᨶᩮᩣ;
ᩈᩉᨶᩮᩣ ᨡᨾᨶᩮᩣ ᨡᨶ᩠ᨲᩣ, ᨲᩥᨲᩥᨠ᩠ᨡᩅᩣ ᨧ ᨡᨶ᩠ᨲᩥᨾᩣ.
ᩈᨴ᩠ᨵᩣᨿᩩᨲ᩠ᨲᩮᩣ ᨲᩩ ᩈᨴ᩠ᨵᩣᩃᩩ, ᨵᨩᩅᩣ ᨲᩩ ᨵᨩᩣᩃᩩ ᨧ [ᩃᨩ᩠ᨩᩣᩃᩩᨲᩩ ᨧ ᩃᨩ᩠ᨩᩅᩣ (ᨠ.)];
ᨶᩥᨴ᩠ᨴᩣᩃᩩ ᨶᩥᨴ᩠ᨴᩣᩈᩦᩃᩮᩣ ᨳ, ᨽᩔᩁᩮᩣ ᨽᩣᩈᩩᩁᩮᩣ ᨽᩅᩮ.
ᨶᨣ᩠ᨣᩮᩣ ᨴᩥᨣᨾ᩠ᨻᩁᩮᩣ’ᩅᨲ᩠ᨳᩮᩣ, ᨥᩈ᩠ᨾᩁᩮᩣ ᨲᩩ ᨧ ᨽᨠ᩠ᨡᨠᩮᩣ;
ᩑᩊᨾᩪᨣᩮᩣ ᨲᩩ ᩅᨲ᩠ᨲᩩᨬ᩠ᨧ, ᩈᩮᩣᨲᩩᩴ ᨧᩣ’ᨠᩩᩈᩃᩮᩣ ᨽᩅᩮ.
ᨾᩩᨡᩁᩮᩣ ᨴᩩᨾ᩠ᨾᩩᨡᩣ’ᨻᨴ᩠ᨵ, ᨾᩩᨡᩣ ᨧᩣᨸ᩠ᨸᩥᨿᩅᩣᨴᩥᨶᩥ;
ᩅᩣᨧᩣᩃᩮᩣ ᨻᩉᩩᨣᩣᩁᨿ᩠ᩉ, ᩅᨧᩮ ᩅᨲ᩠ᨲᩣ ᨲᩩ ᩈᩮᩣ ᩅᨴᩮᩣ.
ᨶᩥᨩᩮᩣ ᩈᨠᩮᩣ ᩋᨲ᩠ᨲᨶᩥᨿᩮᩣ,
ᩅᩥᨾ᩠ᩉᨿᩮᩣ’ᨧ᩠ᨨᩁᩥᨿ’ᨻ᩠ᨽᩩᨲᩮᩣ;
ᩅᩥᩉᨲ᩠ᨳᩮᩣ ᨻ᩠ᨿᩣᨠᩩᩃᩮᩣ ᨧᩣᨳ,
ᩌᨲᨲᩣᨿᩦ ᩅᨵᩩᨴ᩠ᨿᨲᩮᩣ.
ᩈᩦᩈᨧ᩠ᨨᩮᨩ᩠ᨩᨾ᩠ᩉᩥ ᩅᨩ᩠ᨫᩮᩣ ᨳ, ᨶᩥᨠᨲᩮᩣ ᨧ ᩈᨮᩮᩣ’ᨶᩩᨩᩩ;
ᩈᩪᨧᨠᩮᩣ ᨸᩥᩈᩩᨱᩮᩣ ᨠᨱ᩠ᨱᩮ,
ᨩᨸᩮᩣ ᨵᩩᨲ᩠ᨲᩮᩣ ᨲᩩ ᩅᨬ᩠ᨧᨠᩮᩣ.
ᩋᨶᩥᩈᨾ᩠ᨾ ᩉᩥ ᨿᩮᩣ ᨠᩥᨧ᩠ᨧᩴ, ᨸᩩᩁᩥᩈᩮᩣ ᩅᨵᨻᨶ᩠ᨵᨶᩣᨴᩥ ᨾᩣᨧᩁᨲᩥ;
ᩋᩅᩥᨶᩥᨧ᩠ᨨᩥᨲᨠᩣᩁᩥᨲ᩠ᨲᩣ, ᩈᩮᩣᨡᩃᩩ ᨧᨸᩃᩮᩣᨲᩥ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩮᩣ.
ᨡᩩᨴ᩠ᨴᩮᩣ ᨠᨴᩁᩥᨿᩮᩣ ᨳᨴ᩠ᨵ, ᨾᨧ᩠ᨨᩁᩦ ᨠᨸᨱᩮᩣ ᨸ᩠ᨿᨳ;
ᩋᨠᩥᨬ᩠ᨧᨶᩮᩣ ᨴᩃᩥᨴ᩠ᨴᩮᩣ ᨧ, ᨴᩦᨶᩮᩣ ᨶᩥᨴ᩠ᨵᨶ ᨴᩩᨣ᩠ᨣᨲᩣ.
ᩋᩈᨾ᩠ᨽᩣᩅᩥᨲᩈᨾ᩠ᨸᨲ᩠ᨲᩴ, ᨠᩣᨠᨲᩣᩃᩥᨿ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᩋᨳ ᨿᩣᨧᨶᨠᩮᩣ ᩋᨲ᩠ᨳᩦ, ᨿᩣᨧᨠᩮᩣ ᨧ ᩅᨶᩥᨻ᩠ᨻᨠᩮᩣ.
ᩋᨱ᩠ᨯᨩᩣ ᨸᨠ᩠ᨡᩥᩈᨸ᩠ᨸᩣᨴᩦ, ᨶᩁᩣᨴᩦ ᨲᩩ ᨩᩃᩣᨻᩩᨩᩣ;
ᩈᩮᨴᨩᩣ ᨠᩥᨾᩥᨯᩴᩈᩣᨴᩦ, ᨴᩮᩅᩣᨴᩦ ᨲ᩠ᩅᩮᩣ’ ᨸᨸᩣᨲᩥᨠᩣ.
ᨩᨱ᩠ᨱᩩᨲᨣ᩠ᨥᩮᩣ ¶ ᨩᨱ᩠ᨱᩩᨾᨲ᩠ᨲᩮᩣ, ᨠᨸ᩠ᨸᩮᩣ ᨲᩩ ᨠᩥᨬ᩠ᨧᩥᨴᩪᨶᨠᩮ;
ᩋᨶ᩠ᨲᨣ᩠ᨣᨲᩴ ᨽᩩ ᨸᩁᩥᨿᩣ, ᨸᨶ᩠ᨶ ᨾᨶ᩠ᨲᩮᩣᨣᨵᩮᩣ’ᨣᨵᩣ.
ᩁᩣᨵᩥᨲᩮᩣ ᩈᩣᨵᩥᨲᩮᩣ ᨧᩣᨳ, ᨶᩥᨸ᩠ᨸᨠ᩠ᨠᩴ ᨠᩩᨳᩥᨲᩴ ᨽᩅᩮ;
ᩌᨸᨶ᩠ᨶᩮᩣ ᨲ᩠ᩅᩣ’ᨸᨴᨸ᩠ᨸᨲ᩠ᨲᩮᩣ, ᩅᩥᩅᩈᩮᩣ ᨲ᩠ᩅᩅᩈᩮᩣ ᨽᩅᩮ.
ᨶᩩᨱ᩠ᨱᩮᩣ ᨶᩩᨲ᩠ᨲᩣ’ᨲ᩠ᨲ, ᨡᩥᨲ᩠ᨲᩣ ᨧᩮ’, ᩁᩥᨲᩣ ᩅᩥᨴ᩠ᨵᩣ ᨳ ᨠᨾ᩠ᨸᩥᨲᩮᩣ;
ᨵᩪᨲᩮᩣ ᩌᨵᩪᨲ ᨧᩃᩥᨲᩣ, ᨶᩥᩈᩥᨲᩴ ᨲᩩ ᨧ ᨲᩮᨩᩥᨲᩴ.
ᨸᨲ᩠ᨲᨻ᩠ᨻᩴ ᨣᨾ᩠ᨾ ᨾᩣᨸᨩ᩠ᨩᩴ [ᩌᩈᨩ᩠ᨩᩴ (ᨠ.)], ᨸᨠ᩠ᨠᩴ ᨸᩁᩥᨱᨲᩴ ᩈᨾᩣ;
ᩅᩮᨮᩥᨲᩴ ᨲᩩ ᩅᩃᨿᩥᨲᩴ, ᩁᩩᨴ᩠ᨵᩴ ᩈᩴᩅᩩᨲ ᨾᩣᩅᩩᨲᩴ.
ᨸᩁᩥᨠ᩠ᨡᩥᨲ᩠ᨲᨬ᩠ᨧ ᨶᩥᩅᩩᨲᩴ, ᩅᩥᩈᨭᩴ ᩅᩥᨲ᩠ᨳᨲᩴ ᨲᨲᩴ;
ᩃᩥᨲ᩠ᨲᩮᩣ ᨲᩩ ᨴᩥᨴ᩠ᨵᩮᩣ ᨣᩪᩊ᩠ᩉᩮᩣ ᨲᩩ,
ᨣᩩᨲ᩠ᨲᩮᩣ ᨸᩩᨭ᩠ᨮᩮᩣ ᨲᩩ ᨸᩮᩣᩈᩥᨲᩮᩣ.
ᩃᨩ᩠ᨩᩥᨲᩮᩣ ᩉᩦᩊᩥᨲᩮᩣ ᨧᩣᨳ, ᩈᨶᩥᨲᩴ ᨵᨶᩥᨲᩴ ᨸ᩠ᨿᨳ;
ᩈᨶ᩠ᨴᩣᨶᩥᨲᩮᩣ ᩈᩥᨲᩮᩣ ᨻᨴ᩠ᨵᩮᩣ,
ᨠᩦᩃᩥᨲᩮᩣ ᩈᩴᨿᨲᩮᩣ ᨽᩅᩮ.
ᩈᩥᨴ᩠ᨵᩮ ᨶᩥᨸ᩠ᨹᨶ᩠ᨶ ᨶᩥᨻ᩠ᨻᨲ᩠ᨲᩣ, ᨴᩣᩁᩥᨲᩮ ᨽᩥᨶ᩠ᨶ ᨽᩮᨴᩥᨲᩣ;
ᨨᨶ᩠ᨶᩮᩣ ᨲᩩ ᨨᩣᨴᩥᨲᩮ ᨧᩣᨳ, ᩅᩥᨴ᩠ᨵᩮ ᨨᩥᨴ᩠ᨴᩥᨲ ᩅᩮᨵᩥᨲᩣ.
ᩌᩉᨭᩮᩣ ᩌᨽᨲᩣ’ᨶᩦᨲᩣ,
ᨴᨶ᩠ᨲᩮᩣ ᨲᩩ ᨴᨾᩥᨲᩮᩣ ᩈᩥᨿᩣ;
ᩈᨶ᩠ᨲᩮᩣ ᨲᩩ ᩈᨾᩥᨲᩮᩣ ᨧᩮᩅ,
ᨸᩩᨱ᩠ᨱᩮᩣ ᨲᩩ ᨸᩪᩁᩥᨲᩮᩣ ᨽᩅᩮ.
ᩋᨸᨧᩣᨿᩥᨲᩮᩣ ᨾᩉᩥᨲᩮᩣ, ᨸᩪᨩᩥᨲᩣ’ᩁᩉᩥᨲᩮᩣ’ᨧ᩠ᨧᩥᨲᩮᩣ;
ᨾᩣᨶᩥᨲᩮᩣ ᨧᩣ’ᨸᨧᩥᨲᩮᩣ ᨧ, ᨲᨧ᩠ᨨᩥᨲᩴ ᨲᩩᨲᨶᩪᨠᨲᩮ.
ᩈᨶ᩠ᨲᨲ᩠ᨲᩮᩣ ᨵᩪᨸᩥᨲᩮᩣ ᨧᩮᩣᨸ,
ᨧᩁᩥᨲᩮᩣ ᨲᩩ ᩏᨸᩣᩈᩥᨲᩮᩣ;
ᨽᨭ᩠ᨮᩴ ᨲᩩ ᨣᩃᩥᨲᩴ ᨸᨶ᩠ᨶᩴ, ᨧᩩᨲᨬ᩠ᨧ ᨵᩴᩈᩥᨲᩴ ᨽᩅᩮ.
ᨸᩦᨲᩮᩣ ᨸᨾᩩᨴᩥᨲᩮᩣ ᩉᨭ᩠ᨮᩮᩣ,
ᨾᨲ᩠ᨲᩮᩣ ᨲᩩᨭ᩠ᨮᩮᩣ ᨳ ᨠᨶ᩠ᨲᩥᨲᩮᩣ;
ᩈᨬ᩠ᨨᩥᨶ᩠ᨶᩮᩣ ᩃᩪᨶ ᨴᩣᨲᩣ ᨳ,
ᨸᩈᨲ᩠ᨳᩮᩣ ᩅᨱ᩠ᨱᩥᨲᩮᩣ ᨳᩩᨲᩮᩣ.
ᨲᩥᨶ᩠ᨲᩮᩣ’ᩃ᩠ᩃ’ᨴ᩠ᨴ ¶ ᨠᩥᩃᩥᨶ᩠ᨶᩮᩣ’ᨶ᩠ᨶᩣ, ᨾᨣ᩠ᨣᩥᨲᩴ ᨸᩁᩥᨿᩮᩈᩥᨲᩴ;
ᩋᨶ᩠ᩅᩮᩈᩥᨲᩴ ᨣᩅᩮᩈᩥᨲᩴ, ᩃᨴ᩠ᨵᩴ ᨲᩩ ᨸᨲ᩠ᨲ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩁᨠ᩠ᨡᩥᨲᩴ ᨣᩮᩣᨸᩥᨲᩴ ᨣᩩᨲ᩠ᨲᩴ, ᨲᩣᨲᩴ ᨣᩮᩣᨸᩣᨿᩥᨲᩣ’ᩅᩥᨲᩣ;
ᨸᩣᩃᩥᨲᩴ ᩋᨳ ᩒᩔᨭ᩠ᨮᩴ, ᨧᨲ᩠ᨲᩴ ᩉᩦᨶᩴ ᩈᨾᩩᨩ᩠ᨫᩥᨲᩴ.
ᨽᩣᩈᩥᨲᩴ ᩃᨸᩥᨲᩴ ᩅᩩᨲ᩠ᨲᩣ, ᨽᩥᩉᩥᨲᩣ’ᨡ᩠ᨿᩣᨲ ᨩᨸ᩠ᨸᩥᨲᩣ;
ᩏᨴᩦᩁᩥᨲᨬ᩠ᨧ ᨠᨳᩥᨲᩴ, ᨣᨴᩥᨲᩴ ᨽᨱᩥᨲᩮᩣ’ᨴᩥᨲᩣ.
ᩋᩅᨬ᩠ᨬᩣᨲᩣ’ᩅᨣᨱᩥᨲᩣ, ᨸᩁᩥᨽᩪᨲᩣ’ᩅᨾᩣᨶᩥᨲᩣ;
ᨩᩥᨥᨧ᩠ᨨᩥᨲᩮᩣ ᨲᩩ ᨡᩩᨴᩥᨲᩮᩣ,
ᨨᩣᨲᩮᩣ ᨧᩮᩅ ᨻᩩᨽᩩᨠ᩠ᨡᩥᨲᩮᩣ.
ᨻᩩᨴ᩠ᨵᩴ ᨬᩣᨲᩴ ᨸᨭᩥᨸᨶ᩠ᨶᩴ, ᩅᩥᨴᩥᨲᩣ’ᩅᨣᨲᩴ ᨾᨲᩴ;
ᨣᩥᩃᩥᨲᩮᩣ ᨡᩣᨴᩥᨲᩮᩣ ᨽᩩᨲ᩠ᨲᩮᩣ,
ᨽᨠ᩠ᨡᩥᨲᩮᩣ’ᨩ᩠ᨫᩮᩣᩉᨭᩣ’ᩈᩥᨲᩣ.
ᩍᨲᩥ ᩅᩥᩈᩮᩈ᩠ᨿᩣᨵᩦᨶᩅᨣ᩠ᨣᩮᩣ.
᪒. ᩈᩴᨠᩥᨱ᩠ᨱᩅᨣ᩠ᨣ
ᨬᩮᨿ᩠ᨿᩴ ᩃᩥᨦ᩠ᨣ ᨾᩥᩉ ᨠ᩠ᩅᩣᨸᩥ, ᨸᨧ᩠ᨧᨿᨲ᩠ᨳᩅᩈᩮᨶ ᨧ;
ᨠᩕᩥᨿᩣ ᨲᩩ ᨠᩥᩁᩥᨿᩴ ᨠᨾ᩠ᨾᩴ,
ᩈᨶ᩠ᨲᩥ ᨲᩩ ᩈᨾᨳᩮᩣ ᩈᨾᩮᩣ;
ᨴᨾᩮᩣ ᨧ ᨴᨾᨳᩮᩣ ᨴᨶ᩠ᨲᩥ, ᩅᨲ᩠ᨲᩴ ᨲᩩ ᩈᩩᨴ᩠ᨵᨠᨾ᩠ᨾᨶᩥ;
ᩋᨳᩮᩣ ᩌᩈᨦ᩠ᨣᩅᨧᨶᩴ, ᨲᩦᩈᩩ ᩅᩩᨲ᩠ᨲᩴ ᨸᩁᩣᨿᨱᩴ.
ᨽᩮᨴᩮᩣ ᩅᩥᨴᩣᩁᩮᩣ ᨹᩩᨭᨶᩴ, ᨲᨸ᩠ᨸᨶᩴ ᨲᩩ ᨧ ᨸᩦᨱᨶᩴ;
ᩋᨠ᩠ᨠᩮᩣᩈᨶ ᨾᨽᩥᩈᨦ᩠ᨣᩮᩣ,
ᨽᩥᨠ᩠ᨡᩣ ᨲᩩ ᨿᩣᨧᨶᩣ’ᨲ᩠ᨳᨶᩣ.
ᨶᩥᨶ᩠ᨶᩥᨾᩥᨲ᩠ᨲᩴ ᨿᨴᩥᨧ᩠ᨨᩣ ᨳᩣ’, ᨸᩩᨧ᩠ᨨᨶᩣ ᨶᨶ᩠ᨴᨶᩣᨶᩥ ᨧ;
ᩈᨽᩣᨩᨶ ᨾᨳᩮᩣ ᨬᩣᨿᩮᩣ,
ᨶᨿᩮᩣ ᨹᩣᨲᩥ ᨲᩩ ᩅᩩᨴ᩠ᨵᩥᨿᩴ.
ᨠᩥᩃᨾᨳᩮᩣ ᨠᩥᩃᨾᨶᩴ, ᨸᩈᩅᩮᩣ ᨲᩩ ᨸᩈᩪᨲᩥᨿᩴ;
ᩏᨠ᩠ᨠᩴᩈᩮᩣ ᨲ᩠ᩅᨲᩥᩈᨿᩮᩣ ᨳ,
ᨩᨿᩮᩣ ᨧ ᨩᨿᨶᩴ ᨩᩥᨲᩥ.
ᩅᩈᩮᩣ ¶ ᨠᨶ᩠ᨲᩥ, ᨻ᩠ᨿᨵᩮᩣ ᩅᩮᨵᩮᩣ,
ᨣᩉᩮᩣ ᨣᩣᩉᩮᩣ ᩅᩁᩮᩣ ᩅᩩᨲᩥ;
ᨸᨧᩣ ᨸᩣᨠᩮᩣ ᩉᩅᩮᩣ ᩉᩩᨲᩥ [ᩉᩪᨽᩥ (ᩈᩦ. ᩋᨾᩁᨠᩮᩣᩈ)],
ᩅᩮᨴᩮᩣ ᩅᩮᨴᨶ ᨾᩥᨲ᩠ᨳᩥ ᩅᩣ.
ᨩᩦᩁᨱᩴ ᨩᩣᨶᩥ ᨲᩣᨱᩴ ᨲᩩ, ᩁᨠ᩠ᨡᨱᩴ ᨸᨾᩥᨲᩥᨸ᩠ᨸᨾᩣ;
ᩈᩥᩃᩮᩈᩮᩣ ᩈᨶ᩠ᨵᩥ ᨧ ᨡᨿᩮᩣ,
ᨲ᩠ᩅᨸᨧᨿᩮᩣ ᩁᩅᩮᩣ ᩁᨱᩮᩣ.
ᨶᩥᨣᩣᨴᩮᩣ ᨶᩥᨣᨴᩮᩣ ᨾᩣᨴᩮᩣ, ᨾᨴᩮᩣ ᨸᩈᩥᨲᩥ ᨻᨶ᩠ᨵᨶᩴ;
ᩌᨠᩁᩮᩣ ᨲ᩠ᩅᩥᨦ᩠ᨣᩥᨲᩴ ᩍᨦ᩠ᨣᩮᩣ,
ᩋᨳ’ᨲ᩠ᨳᩣᨸᨣᨾᩮᩣ ᨻ᩠ᨿᨿᩮᩣ.
ᩋᨶ᩠ᨲᩁᩣᨿᩮᩣ ᨧ ᨸᨧ᩠ᨧᩪᩉᩮᩣ,
ᩅᩥᨠᩣᩁᩮᩣ ᨲᩩ ᩅᩥᨠᨲ᩠ᨿ’ᨸᩥ;
ᨸᩅᩥᩈᩥᩃᩮᩈᩮᩣ ᩅᩥᨵᩩᩁᩴ, ᩏᨸᩅᩮᩈᨶᨾᩣᩈᨶᩴ.
ᩋᨩ᩠ᨫᩣᩈᨿᩮᩣ ᩋᨵᩥᨸ᩠ᨸᩣᨿᩮᩣ, ᩌᩈᨿᩮᩣ ᨧᩣᨽᩥᩈᨶ᩠ᨵᩥ ᨧ;
ᨽᩣᩅᩮᩣ ᨵᩥᨾᩩᨲ᩠ᨲᩥ ᨨᨶ᩠ᨴᩮᩣ ᨳ,
ᨴᩮᩣᩈᩮᩣ ᩌᨴᩦᨶᩅᩮᩣ ᨽᩅᩮ.
ᩌᨶᩥᩈᩴᩈᩮᩣ ᨣᩩᨱᩮᩣ ᨧᩣᨳ,
ᨾᨩ᩠ᨫᩴ ᩅᩮᨾᨩ᩠ᨫ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨾᨩ᩠ᨫᨶ᩠ᩉᩥᨠᩮᩣ [ᨾᨩ᩠ᨫᨶ᩠ᨲᩥᨠᩮᩣ (ᨭᩦ. ᩈᩦ. ᨸᩦ.)] ᨲᩩ ᨾᨩ᩠ᨫᨶ᩠ᩉᩮᩣ, ᩅᩮᨾᨲ᩠ᨲᩴ ᨲᩩ ᨧ ᨶᩣᨶᨲᩣ.
ᩅᩣ ᨩᩣᨣᩁᩮᩣ ᨩᩣᨣᩁᩥᨿᩴ [ᨩᩣᨣᩁᩥᨿᩮᩣ (ᨭᩦ.)], ᨸᩅᩣᩉᩮᩣ ᨲᩩ ᨸᩅᨲ᩠ᨲᩥ ᨧ;
ᨻ᩠ᨿᩣᩈᩮᩣ ᨸᨸᨬ᩠ᨧᩮᩣ ᩅᩥᨲ᩠ᨳᩣᩁᩮᩣ,
ᨿᩣᨾᩮᩣ ᨲᩩ ᩈᩴᨿᨾᩮᩣ ᨿᨾᩮᩣ.
ᩈᨾ᩠ᨻᩣᩉᨶᩴ ᨾᨴ᩠ᨴᨶᨬ᩠ᨧ, ᨸᩈᩁᩮᩣ ᨲᩩ ᩅᩥᩈᨸ᩠ᨸᨶᩴ;
ᩈᨶ᩠ᨳᩅᩮᩣ ᨲᩩ ᨸᩁᩥᨧᨿᩮᩣ,
ᨾᩮᩃᨠᩮᩣ ᩈᨦ᩠ᨣ ᩈᨦ᩠ᨣᨾᩣ.
ᩈᨶ᩠ᨶᩥᨵᩥ ᩈᨶ᩠ᨶᩥᨠᨭ᩠ᨮᨾ᩠ᩉᩥ, ᩅᩥᨶᩣᩈᩮᩣ ᨲᩩ ᩋᨴᩔᨶᩴ;
ᩃᩅᩮᩣ ᨽᩥᩃᩣᩅᩮᩣ ᩃᩅᨶᩴ,
ᨸᨲ᩠ᨳᩣᩅᩮᩣ’ᩅᩈᩁᩮᩣ ᩈᨾᩣ.
ᩒᩈᩣᨶᩴ ¶ ᨸᩁᩥᨿᩮᩣᩈᩣᨶᩴ, ᩏᨠ᩠ᨠᩴᩈᩮᩣ’ᨲᩥᩈᨿᩮᩣ ᨽᩅᩮ [ᩋᩅᩈᩣᨶᩴ ᩈᨾᩣᨸᨶᩴ (?)];
ᩈᨶ᩠ᨶᩥᩅᩮᩈᩮᩣ ᨧ ᩈᨱ᩠ᨮᩣᨶᩴ, ᩋᨳᩣ’ᨻ᩠ᨽᨶ᩠ᨲᩁ ᨾᨶ᩠ᨲᩁᩴ.
ᨸᩣᨭᩥᩉᩦᩁᩴ ᨸᩣᨭᩥᩉᩮᩁᩴ, ᨸᩣᨭᩥᩉᩣᩁᩥᨿ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨠᩥᨧ᩠ᨧᩴ ᨲᩩ ᨠᩁᨱᩦᨿᨬ᩠ᨧ, ᩈᨦ᩠ᨡᩣᩁᩮᩣ ᩅᩣᩈᨶᩣ ᨽᩅᩮ.
ᨸᩅᨶᩴ ᨸᩅ ᨶᩥᨸ᩠ᨸᩣᩅᩣ, ᨲᩈᩁᩮᩣ ᩈᩩᨲ᩠ᨲᩅᩮᨮᨶᩴ;
ᩈᨦ᩠ᨠᨾᩮᩣ ᨴᩩᨣ᩠ᨣᩈᨬ᩠ᨧᩣᩁᩮᩣ, ᨸᨠ᩠ᨠᨾᩮᩣ ᨲᩩ ᩏᨸᨠ᩠ᨠᨾᩮᩣ.
ᨸᩣᨮᩮᩣ ᨶᩥᨸᩣᨮᩮᩣ ᨶᩥᨸᨮᩮᩣ, ᩅᩥᨧᨿᩮᩣ ᨾᨣ᩠ᨣᨶᩣ ᨸᩩᨾᩮ;
ᩌᩃᩥᨦ᩠ᨣᨶᩴ ᨸᩁᩥᩔᨦ᩠ᨣᩮᩣ, ᩈᩥᩃᩮᩈᩮᩣ ᩏᨸᨣᩪᩉᨶᩴ.
ᩌᩃᩮᩣᨠᨶᨬ᩠ᨧ ᨶᩥᨩ᩠ᨫᩣᨶᩴ, ᩍᨠ᩠ᨡᨱᩴ ᨴᩔᨶᩴ ᨸ᩠ᨿᨳ;
ᨸᨧ᩠ᨧᩣᨴᩮᩈᩮᩣ ᨶᩥᩁᩈᨶᩴ, ᨸᨧ᩠ᨧᨠ᩠ᨡᩣᨶᩴ ᨶᩥᩁᩣᨠᨲᩥ.
ᩅᩥᨸᩃ᩠ᩃᩣᩈᩮᩣ’ᨬ᩠ᨬᨳᩣᨽᩣᩅᩮᩣ, ᨻ᩠ᨿᨲ᩠ᨲᨿᩮᩣ ᩅᩥᨸᩁᩦᨿᨿᩮᩣ;
ᩅᩥᨸᩁᩥᨿᩣᩈᩮᩣ’ᨲᩥᨠ᩠ᨠᨾᩮᩣ, ᨲ᩠ᩅ’ᨲᩥᨸᩣᨲᩮᩣ ᩏᨸᨧ᩠ᨧᨿᩮᩣ.
ᩍᨲᩥ ᩈᩴᨠᩥᨱ᩠ᨱᩅᨣ᩠ᨣᩮᩣ.
᪓. ᩋᨶᩮᨠᨲ᩠ᨳᩅᨣ᩠ᨣ
ᩋᨶᩮᨠᨲ᩠ᨳᩮ ᨸᩅᨠ᩠ᨡᩣᨾᩥ, ᨣᩣᨳᩣ’ᨴ᩠ᨵᨸᩣᨴᨲᩮᩣ ᨠᨾᩣ;
ᩑᨲ᩠ᨳ ᩃᩥᨦ᩠ᨣᩅᩥᩈᩮᩈᨲ᩠ᨳ, ᨾᩮᨠᩔ ᨸᩩᨶᩁᩩᨲ᩠ᨲᨲᩣ.
ᩈᨾᨿᩮᩣ ᩈᨾᩅᩣᨿᩮ ᨧ, ᩈᨾᩪᩉᩮ ᨠᩣᩁᨱᩮ ᨡᨱᩮ;
ᨸᨭᩥᩅᩮᨵᩮ ᩈᩥᨿᩣ ᨠᩣᩃᩮ, ᨸᩉᩣᨶᩮ ᩃᩣᨽ ᨴᩥᨭ᩠ᨮᩥᩈᩩ.
ᩅᨱ᩠ᨱᩮᩣ ᩈᨱ᩠ᨮᩣᨶ ᩁᩪᨸᩮᩈᩩ, ᨩᩣᨲᩥ,ᨧ᩠ᨨᩅᩦᩈᩩ ᨠᩣᩁᨱᩮ;
ᨸᨾᩣᨱᩮ ᨧ ᨸᩈᩴᩈᩣᨿᩴ, ᩋᨠ᩠ᨡᩁᩮ ᨧ ᨿᩈᩮ ᨣᩩᨱᩮ.
ᩏᨴ᩠ᨴᩮᩈᩮ ᨸᩣᨲᩥᨾᩮᩣᨠ᩠ᨡᩔ, ᨸᨱ᩠ᨱᨲ᩠ᨲᩥᨿ ᨾᩩᨸᩮᩣᩈᨳᩮᩣ;
ᩏᨸᩅᩣᩈᩮ ᨧ ᩋᨭ᩠ᨮᨦ᩠ᨣᩮ, ᩏᨸᩮᩣᩈᨳᨴᩥᨶᩮ ᩈᩥᨿᩣ.
ᩁᨳᨦ᩠ᨣᩮ ᩃᨠ᩠ᨡᨱᩮ ᨵᨾ᩠ᨾᩮᩣ, ᩁᨧᨠ᩠ᨠᩮ’ᩈ᩠ᩅᩦᩁᩥᨿᩣᨸᨳᩮ;
ᨧᨠ᩠ᨠᩴ ᩈᨾ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᨧᨠ᩠ᨠ, ᩁᨲᨶᩮ ᨾᨱ᩠ᨯᩃᩮ ᨻᩃᩮ.
ᨠᩩᩃᩣᩃᨽᨱ᩠ᨯᩮ ᩌᨱᩣᨿ, ᨾᩣᨿᩩᨵᩮ ᨴᩣᨶ ᩁᩣᩈᩥᩈᩩ;
ᨴᩣᨶᩈ᩠ᨾᩥᩴ ¶ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿ, ᨾᨸ᩠ᨸᨾᨬ᩠ᨬᩣᩈᩩ ᩈᩣᩈᨶᩮ;
ᨾᩮᨳᩩᨶᩣᩁᨲᩥᨿᩴ ᩅᩮᨿ᩠ᨿᩣ, ᩅᨧ᩠ᨧᩮ ᩈᨴᩣᩁᨲᩩᨭ᩠ᨮᩥᨿᩴ;
ᨸᨬ᩠ᨧᩈᩦᩃᩣ’ᩁᩥᨿᨾᨣ᩠ᨣᩮᩣ, ᨸᩮᩣᩈᨳᨦ᩠ᨣ ᨵᩥᨲᩦᩈᩩ [ᨮᩥᨲᩦᩈᩩ (ᨠ.)] ᨧ.
ᨵᨾ᩠ᨾᩮᩣ ᩈᨽᩣᩅᩮ ᨸᩁᩥᨿᨲ᩠ᨲᩥᨸᨬ᩠ᨬᩣ,
ᨬᩣᨿᩮᩈᩩ ᩈᨧ᩠ᨧᨸ᩠ᨸᨠᨲᩦᩈᩩ ᨸᩩᨬ᩠ᨬᩮ;
ᨬᩮᨿ᩠ᨿᩮ ᨣᩩᨱᩣ’ᨧᩣᩁ ᩈᨾᩣᨵᩥᩈᩪᨸᩥ,
ᨶᩥᩔᨲ᩠ᨲᨲᩣ’ᨸᨲ᩠ᨲᩥᩈᩩ ᨠᩣᩁᨱᩣᨴᩮᩣ.
ᩋᨲ᩠ᨳᩮᩣ ᨸᨿᩮᩣᨩᨶᩮ ᩈᨴ᩠ᨴᩣ, ᨽᩥᨵᩮᨿ᩠ᨿᩮ ᩅᩩᨴ᩠ᨵᩥᨿᩴ ᨵᨶᩮ;
ᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩥ ᨠᩣᩁᨱᩮ ᨶᩣᩈᩮ, ᩉᩥᨲᩮ ᨸᨧ᩠ᨨᩥᨾᨸᨻ᩠ᨻᨲᩮ.
ᨿᩮᨽᩩᨿ᩠ᨿᨲᩣ’ᨻ᩠ᨿᩣᨾᩥᩔᩮᩈᩩ, ᩅᩥᩈᩴᨿᩮᩣᨣᩮ ᨧ ᨠᩮᩅᩃᩴ;
ᨴᩊ᩠ᩉᨲ᩠ᨳᩮ’ᨶᨲᩥᩁᩮᨠᩮ ᨧᩣ, ᨶᩅᩈᩮᩈᨾ᩠ᩉᩥ ᨲᩴ ᨲᩥᩈᩩ.
ᨣᩩᨱᩮᩣ ᨸᨭᩃ ᩁᩣᩈᩦᩈᩩ, ᩌᨶᩥᩈᩴᩈᩮ ᨧ ᨻᨶ᩠ᨵᨶᩮ;
ᩋᨸ᩠ᨸᨵᩣᨶᩮ ᨧ ᩈᩦᩃᩣᨴᩮᩣ, ᩈᩩᨠ᩠ᨠᩣᨴᩥᨾ᩠ᩉᩥ ᨩᩥᨿᩣᨿ ᨧ.
ᩁᩩᨠ᩠ᨡᩣᨴᩮᩣ ᩅᩥᨩ᩠ᨩᨾᩣᨶᩮ ᨧᩣ, ᩁᩉᨶ᩠ᨲᩮ ᨡᨶ᩠ᨵᨸᨬ᩠ᨧᨠᩮ;
ᨽᩪᨲᩮᩣ ᩈᨲ᩠ᨲ ᨾᩉᩣᨽᩪᨲᩣ, ᨾᨶᩩᩔᩮᩈᩩ ᨶ ᨶᩣᩁᩥᨿᩴ.
ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩮᩣ ᩋᨲᩦᨲᩈ᩠ᨾᩥᩴ, ᨩᩣᨲᩮ ᨸᨲ᩠ᨲᩮ ᩈᨾᩮ ᨾᨲᩮᩣ;
ᩈᩩᨶ᩠ᨴᩁᩮ ᨴᩊ᩠ᩉᩥᨠᨾ᩠ᨾᩮ ᨧᩣ, ᨿᩣᨧᨶᩮ ᩈᨾ᩠ᨸᨭᩥᨧ᩠ᨨᨶᩮ;
ᩈᨩ᩠ᨩᨶᩮ ᩈᨾ᩠ᨸᩉᩴᩈᩣᨿᩴ, ᩈᩣᨵ᩠ᩅᩣ’ᨽᩥᨵᩮᨿ᩠ᨿᩃᩥᨦ᩠ᨣᩥᨠᩴ.
ᩋᨶ᩠ᨲᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᨾᩦᨸᩮ ᨧᩣ, ᩅᩈᩣᨶᩮ ᨸᨴᨸᩪᩁᨱᩮ;
ᨴᩮᩉᩣᩅᨿᩅᩮ ᨠᩮᩣᨭ᩠ᨮᩣᩈᩮ, ᨶᩣᩈ ᩈᩦᨾᩣᩈᩩ ᩃᩣᨾᨠᩮ.
ᨶᩥᨠᩣᨿᩮ ᩈᨶ᩠ᨵᩥ ᩈᩣᨾᨬ᩠ᨬ, ᨸ᩠ᨸᩈᩪᨲᩦᩈᩩ ᨠᩩᩃᩮ ᨽᩅᩮ;
ᩅᩥᩈᩮᩈᩮ ᩈᩩᨾᨶᩣᨿᨬ᩠ᨧ, ᨩᩣᨲᩥ ᩈᨦ᩠ᨡᨲᩃᨠ᩠ᨡᨱᩮ.
ᨽᩅᨽᩮᨴᩮ ᨸᨲᩥᨭ᩠ᨮᩣᨿᩴ, ᨶᩥᨭ᩠ᨮᩣ’ᨩ᩠ᨫᩣᩈᨿᨻᩩᨴ᩠ᨵᩥᩈᩩ;
ᩅᩣᩈᨭ᩠ᨮᩣᨶᩮ ᨧ ᨣᨾᨶᩮ, ᩅᩥᩈᨭᨲ᩠ᨲᩮ [ᩅᩥᩈᩁᨲ᩠ᨲ ᩅᩥᩈᨴᨲ᩠ᨲᩮ] ᨣᨲᩦᩁᩥᨲᩣ.
ᨹᩃᩮ ᩅᩥᨸᩔᨶᩣ ᨴᩥᨻ᩠ᨻ, ᨧᨠ᩠ᨡᩩ ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᩣᩈᩩ ᨧ;
ᨸᨧ᩠ᨧᩅᩮᨠ᩠ᨡᨱᨬᩣᨱᨾ᩠ᩉᩥ, ᨾᨣ᩠ᨣᩮ ᨧ ᨬᩣᨱᨴᩔᨶᩴ.
ᨠᨾ᩠ᨾᩣᩁᩩᨴ᩠ᨵᨶ ᩋᨦ᩠ᨣᩣᩁ, ᨠᨸᩃ᩠ᩃ ᨴᩦᨸᩥᨠᩣᩈᩩ ᨧ;
ᩈᩩᩅᨱ᩠ᨱᨠᩣᩁᨾᩪᩈᩣᨿᩴ, ᩏᨠ᩠ᨠᩣ ᩅᩮᨣᩮ ᨧ ᩅᩣᨿᩩᨶᩮᩣ.
ᨠᩮᩈᩮᩣᩉᩣᩁᨱ, ¶ ᨩᩦᩅᩥᨲ, ᩅᩩᨲ᩠ᨲᩥᩈᩩ ᩅᨸᨶᩮ ᨧ ᩅᩣᨸᩈᨾᨠᩁᨱᩮ;
ᨠᨳᨶᩮ ᨸᨾᩩᨲ᩠ᨲᨽᩣᩅ, ᨩ᩠ᨫᩮᨶᩣᨴᩮᩣ [ᨩ᩠ᨫᩮᩈᨶᩣᨴᩮᩣ (ᩈᩦ.)] ᩅᩩᨲ᩠ᨲ ᨾᨸᩥ ᨲᩦᩈᩩ.
ᨣᨾᨶᩮ ᩅᩥᩔᩩᨲᩮ ᨧᩣ’ᩅ, ᨵᩣᩁᩥᨲᩮᩣ’ᨸᨧᩥᨲᩮᩈᩩ ᨧ;
ᩋᨶᩩᨿᩮᩣᨣᩮ ᨠᩥᩃᩥᨶ᩠ᨶᩮ ᨧ, ᩈᩩᨲᩮᩣ’ ᨽᩥᨵᩮᨿ᩠ᨿᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.
ᩈᩮᩣᨲᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿ ᩈᨲ᩠ᨳᩮᩈᩩ, ᩈᩩᨲᩴ ᨸᩩᨲ᩠ᨲᩮ ᩈᩩᨲᩮᩣ ᩈᩥᨿᩣ;
ᨠᨸ᩠ᨸᩮᩣ ᨠᩣᩃᩮ ᨿᩩᨣᩮ ᩃᩮᩈᩮ, ᨸᨬ᩠ᨬᨲ᩠ᨲᩥ ᨸᩁᨾᩣᨿᩩᩈᩩ;
ᩈᨴᩥᩈᩮ ᨲᩦᩈᩩ ᩈᨾᨱ, ᩅᩮᩣᩉᩣᩁ ᨠᨸ᩠ᨸᨻᩥᨶ᩠ᨴᩩᩈᩩ;
ᩈᨾᨶ᩠ᨲᨲ᩠ᨳᩮ’ᨶ᩠ᨲᩁᨠᨸ᩠ᨸᩣ, ᨴᩥᨠᩮ ᨲᨠ᩠ᨠᩮ ᩅᩥᨵᩥᨾ᩠ᩉᩥ ᨧ.
ᨶᩥᨻ᩠ᨻᩣᨶ ᨾᨣ᩠ᨣ ᩅᩥᩁᨲᩥ, ᩈᨸᨳᩮ ᩈᨧ᩠ᨧᨽᩣᩈᩥᨲᩮ;
ᨲᨧ᩠ᨨᩮ ᨧᩣ’ᩁᩥᨿᩈᨧ᩠ᨧᨾ᩠ᩉᩥ, ᨴᩥᨭ᩠ᨮᩥᨿᩴ ᩈᨧ᩠ᨧ ᨾᩦᩁᩥᨲᩴ.
ᩈᨬ᩠ᨩᩣᨲᩥᨴᩮᩈᩮ ᩉᩮᨲᩩᨾ᩠ᩉᩥ, ᩅᩣᩈᨭ᩠ᨮᩣᨶᩣ’ᨠᩁᩮᩈᩩ ᨧ;
ᩈᨾᩮᩣᩈᩁᨱᨭ᩠ᨮᩣᨶᩮ ᨧᩣ, ᨿᨲᨶᩴ ᨸᨴᨸᩪᩁᨱᩮ.
ᩋᨶ᩠ᨲᩁᩴ ᨾᨩ᩠ᨫ ᩅᨲ᩠ᨳ’ᨬ᩠ᨬ, ᨡᨱᩮᩣ’ᨠᩣᩈᩮᩣ’ᨵᩥ ᩉᩮᨲᩩᩈᩩ;
ᨻ᩠ᨿᩅᨵᩣᨶᩮ ᩅᩥᨶᨭ᩠ᨮᩮ ᨧ, ᨽᩮᨴᩮ ᨨᩥᨴ᩠ᨴᩮ ᨾᨶᩈ᩠ᨿ’ᨸᩥ.
ᩌᩁᩮᩣᨣ᩠ᨿᩮ ᨠᩩᩈᩃᩴ ᩍᨭ᩠ᨮ, ᩅᩥᨸᩣᨠᩮ ᨠᩩᩈᩃᩮᩣ ᨲᨳᩣ;
ᩋᨶᩅᨩ᩠ᨩᨾ᩠ᩉᩥ ᨨᩮᨠᩮ ᨧ, ᨠᨳᩥᨲᩮᩣ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.
ᨴᩕᩅᩣ’ᨧᩣᩁᩮᩈᩩ ᩅᩦᩁᩥᨿᩮ, ᨾᨵᩩᩁᩣᨴᩦᩈᩩ ᨸᩣᩁᨴᩮ;
ᩈᩥᨦ᩠ᨣᩣᩁᩣᨴᩮᩣ ᨵᩣᨲᩩᨽᩮᨴᩮ, ᨠᩥᨧ᩠ᨧᩮ ᩈᨾ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᩁᩈᩮᩣ.
ᨻᩮᩣᨵᩥ ᩈᨻ᩠ᨻᨬ᩠ᨬᩩᨲᨬ᩠ᨬᩣᨱᩮ, ᩁᩥᨿᨾᨣ᩠ᨣᩮ ᨧ ᨶᩣᩁᩥᨿᩴ;
ᨸᨬ᩠ᨬᨲ᩠ᨲᩥᨿᩴ ᨸᩩᨾᩮ’ ᩔᨲ᩠ᨳ, ᩁᩩᨠ᩠ᨡᨾ᩠ᩉᩥ ᨸᩩᩁᩥᩈᩥᨲ᩠ᨳᩥᨿᩴ.
ᩈᩮᩅᩥᨲᩮᩣ ᨿᩮᨶ ᨿᩮᩣ ᨶᩥᨧ᩠ᨧᩴ, ᨲᨲ᩠ᨳᩣᨸᩥ ᩅᩥᩈᨿᩮᩣ ᩈᩥᨿᩣ;
ᩁᩪᨸᩣᨴᩥᨠᩮ ᨩᨶᨸᨴᩮ, ᨲᨳᩣ ᨴᩮᩈᩮ ᨧ ᨣᩮᩣᨧᩁᩮ.
ᨽᩣᩅᩮᩣ ᨸᨴᨲ᩠ᨳᩮ ᩈᨲ᩠ᨲᩣᨿ, ᨾᨵᩥᨸ᩠ᨸᩣᨿ ᨠᩕᩥᨿᩣᩈᩩ ᨧ;
ᩈᨽᩣᩅᩈ᩠ᨾᩥᨬ᩠ᨧ ᩃᩦᩃᩣᨿᩴ, ᨸᩩᩁᩥᩈᩥ’ᨲ᩠ᨳᩥᨶ᩠ᨴᩕᩥᨿᩮᩈᩩ ᨧ.
ᩈᩮᩣ ᨻᨶ᩠ᨵᩅᩮ’ᨲ᩠ᨲᨶᩥ ᨧ ᩈᩴ, ᩈᩮᩣ ᨵᨶᩈ᩠ᨾᩥ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ;
ᩈᩣ ᨸᩩᨾᩮ ᩈᩩᨶᨡᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨲ᩠ᨲᨶᩥᨿᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.
ᩈᩩᩅᨱ᩠ᨱᩴ ᨠᨶᨠᩮ ᩅᩩᨲ᩠ᨲᩴ, ᩈᩩᩅᨱ᩠ᨱᩮᩣ ᨣᩁᩩᩊᩮ ᨲᨳᩣ;
ᨸᨬ᩠ᨧᨵᩁᨱᨾᨲ᩠ᨲᩮ ᨧ, ᨨᩅᩥ ᩈᨾ᩠ᨸᨲ᩠ᨲᩥᨿᨾ᩠ᨸᩥ ᨧ.
ᩅᩁᩮᩣ ¶ ᨴᩮᩅᩣᨴᩥᨠᩣ [ᨴᩮᩅᩣᨴᩥᨲᩮᩣ (ᩈᩦ.)] ᩍᨭ᩠ᨮᩮ, ᨩᩣᨾᩣᨲᩁᩥ ᨸᨲᩥᨾ᩠ᩉᩥ ᨧ,
ᩏᨲ᩠ᨲᨾᩮ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩮᩣ ᩈᩮᩣ, ᩅᩁᩴ ᨾᨶ᩠ᨴᨸ᩠ᨸᩥᨿᩮ ᨻ᩠ᨿᨿᩴ.
ᨾᨠᩩᩃᩮ ᨵᨶᩁᩣᩈᩥᨾ᩠ᩉᩥ, ᩈᩥᨿᩣ ᨠᩮᩣᩈ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ;
ᨶᩮᨲ᩠ᨲᩥᩴᩈᩣᨴᩥ ᨸᩥᨵᩣᨶᩮ ᨧ, ᨵᨶᩩᨸᨬ᩠ᨧᩈᨲᩮᨸᩥ ᨧ.
ᨸᩥᨲᩣᨾᩉᩮ ᨩᩥᨶᩮ ᩈᩮᨭ᩠ᨮᩮ, ᨻᩕᩣᩉ᩠ᨾᨱᩮ ᨧ ᨸᩥᨲᩪᩈ᩠ᩅᨸᩥ;
ᨻᩕᩉ᩠ᨾᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᨲᨳᩣ ᨻᩕᩉ᩠ᨾᩴ, ᩅᩮᨴᩮ ᨲᨸᩈᩥ ᩅᩩᨧ᩠ᨧᨲᩮ.
ᩉᨲ᩠ᨳᩦᨶᩴ ᨾᨩ᩠ᨫᨻᨶ᩠ᨵᩮ ᨧ, ᨸᨠᩮᩣᨭ᩠ᨮᩮ ᨠᨧ᩠ᨨᨻᨶ᩠ᨵᨶᩮ;
ᨾᩮᨡᩃᩣᨿᩴ ᨾᨲᩣ ᨠᨧ᩠ᨨᩣ, ᨠᨧ᩠ᨨᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᩃᨲᩣᨿ ᨧ.
ᨲᨳᩮᩅ ᨻᩣᩉᩩᨾᩪᩃᨾ᩠ᩉᩥ, ᩋᨶᩪᨸᨾ᩠ᩉᩥ ᨲᩥᨱᩮᨸᩥ ᨧ;
ᨸᨾᩣᨱᩴ ᩉᩮᨲᩩ ᩈᨲ᩠ᨳᩮᩈᩩ, ᨾᩣᨶᩮ ᨧ ᩈᨧ᩠ᨧᩅᩣᨴᩥᨶᩥ;
ᨸᨾᩣᨲᩁᩥ ᨧ ᨶᩥᨧ᩠ᨧᨾ᩠ᩉᩥ, ᨾᩁᩥᨿᩣᨴᩣᨿ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩈᨲ᩠ᨲᩴ ᨴᨻ᩠ᨻ’ᨲ᩠ᨲᨽᩣᩅᩮᩈᩩ, ᨸᩣᨱᩮᩈᩩ ᨧ ᨻᩃᩮ, ᩈᩥᨿᩣ [ᨻᩃᩮ ᩈᨠ᩠ᨠᩣ (ᨭᩦ.)];
ᩈᨲ᩠ᨲᩣᨿᨬ᩠ᨧ, ᨩᨶᩮᩈᨲ᩠ᨲᩮᩣ, ᩌᩈᨲ᩠ᨲᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.
ᩈᩮᨾ᩠ᩉᩣᨴᩮᩣ ᩁᩈᩁᨲ᩠ᨲᩣᨴᩮᩣ, ᨾᩉᩣᨽᩪᨲᩮ ᨸᨽᩣᨴᩥᨠᩮ;
ᨵᩣᨲᩩ ᨴ᩠ᩅᩦᩈ᩠ᩅ’ᨭ᩠ᨮᩥᨧᨠ᩠ᨡᩣ’ᨴᩥ, ᨽ᩠ᩅᩣ’ᨴᩦᩈᩩ ᨣᩮᩁᩥᨠᩣᨴᩥᩈᩩ.
ᩋᨾᨧ᩠ᨧᩣᨴᩮᩣ ᩈᨽᩣᩅᩮ ᨧ, ᨿᩮᩣᨶᩥᨿᩴ ᨸᨠᨲᩦ’ᩁᩥᨲᩣ;
ᩈᨲ᩠ᩅᩣᨴᩥᩈᩣᨾ᩠ᨿᩣ’ᩅᨲ᩠ᨳᩣᨿᩴ, ᨸᨧ᩠ᨧᨿᩣ ᨸᨮᨾᩮᨸᩥ ᨧ.
ᨸᨴᩴ ᨮᩣᨶᩮ ᨸᩁᩥᨲ᩠ᨲᩣᨱᩮ, ᨶᩥᨻ᩠ᨻᩣᨶᨾ᩠ᩉᩥ ᨧ ᨠᩣᩁᨱᩮ;
ᩈᨴ᩠ᨴᩮ ᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩥ ᨠᩮᩣᨭ᩠ᨮᩣᩈᩮ, ᨸᩣᨴᩮ ᨲᩃ᩠ᩃᨬ᩠ᨨᨶᩮ ᨾᨲᩴ.
ᩃᩮᩣᩉᨾᩩᨣ᩠ᨣᩁ ᨾᩮᨥᩮᩈᩩ, ᨥᨶᩮᩣ, ᨲᩣᩃᩣᨴᩥᨠᩮ ᨥᨶᩴ,;
ᨶᩥᩁᨶ᩠ᨲᩁᩮ ᨧ ᨠᨮᩥᨶᩮ, ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᨡᩩᨴ᩠ᨴᩣ ᨧ ᨾᨠ᩠ᨡᩥᨠᩣᨽᩮᨴᩮ, ᨾᨵᩩᨾ᩠ᩉᩥ ᨡᩩᨴ᩠ᨴ, ᨾᨸ᩠ᨸᨠᩮ;
ᩋᨵᨾᩮ ᨠᨸᨱᩮ ᨧᩣᨸᩥ, ᨻᩉᩩᨾ᩠ᩉᩥ ᨧᨲᩪᩈᩩ ᨲ᩠ᨲᩥᩈᩩ.
ᨲᨠ᩠ᨠᩮ ᨾᩁᨱᩃᩥᨦ᩠ᨣᩮ ᨧ, ᩋᩁᩥᨭ᩠ᨮᩴ ᩋᩈᩩᨽᩮ ᩈᩩᨽᩮ,;
ᩋᩁᩥᨭ᩠ᨮᩮᩣ ᩌᩈᩅᩮ ᨠᩣᨠᩮ, ᨶᩥᨾ᩠ᨻᩮ ᨧ ᨹᩮᨶᩥᩃᨴ᩠ᨴᩩᨾᩮ.
ᨾᩣᨶᨽᨱ᩠ᨯᩮ ᨸᩃᩈᨲᩮ, ᩈᨴᩥᩈᨲ᩠ᨲᩮ ᨲᩩᩃᩣ ᨲᨳᩣ;
ᨣᩮᩉᩣᨶᩴ ᨴᩣᩁᩩᨻᨶ᩠ᨵᨲ᩠ᨳ, ᨸᩦᨮᩥᨠᩣᨿᨬ᩠ᨧ ᨴᩥᩔᨲᩥ.
ᨾᩥᨲ᩠ᨲᨠᩣᩁᩮ ¶ ᩃᨬ᩠ᨩᨴᩣᨶᩮ, ᨻᩃᩮ ᩁᩣᩈᩥ ᩅᩥᨸᨲ᩠ᨲᩥᩈᩩ [ᨻᩃᩁᩣᩈᩥ ᩅᩥᨸᨲ᩠ᨲᩥᩈᩩ (ᨠ.)];
ᨿᩩᨴ᩠ᨵᩮ ᨧᩮᩅ ᨸᨭᩥᨬ᩠ᨬᩣᨿᩴ, ᩈᨦ᩠ᨣᩁᩮᩣ ᩈᨾ᩠ᨸᨠᩣᩈᩥᨲᩮᩣ.
ᨡᨶ᩠ᨵᩮ ᨽᩅᩮ ᨶᩥᨾᩥᨲ᩠ᨲᨾ᩠ᩉᩥ, ᩁᩪᨸᩴ ᩅᨱ᩠ᨱᩮ ᨧ ᨸᨧ᩠ᨧᨿᩮ;
ᩈᨽᩣᩅ ᩈᨴ᩠ᨴ ᩈᨱ᩠ᨮᩣᨶ, ᩁᩪᨸᨩ᩠ᨫᩣᨶ ᩅᨸᩪᩈᩩ ᨧ.
ᩅᨲ᩠ᨳᩩ ᨠᩥᩃᩮᩈ ᨠᩣᨾᩮᩈᩩ, ᩍᨧ᩠ᨨᩣᨿᩴ ᨾᨴᨶᩮ ᩁᨲᩮ;
ᨠᩣᨾᩮᩣ, ᨠᩣᨾᩴ ᨶᩥᨠᩣᨾᩮ, ᨧᩣ, ᨶᩩᨬ᩠ᨬᩣᨿᩴ ᨠᩣᨾ ᨾᨻ᩠ᨿᨿᩴ.
ᨸᩮᩣᨠ᩠ᨡᩁᩴ ᨸᨴᩩᨾᩮ ᨴᩮᩉᩮ, ᩅᨩ᩠ᨩᨽᨱ᩠ᨯᨾᩩᨡᩮᨸᩥ ᨧ;
ᩈᩩᨶ᩠ᨴᩁᨲ᩠ᨲᩮ ᨧ ᩈᩃᩥᩃᩮ, ᨾᩣᨲᨦ᩠ᨣᨠᩁᨠᩮᩣᨭᩥᨿᩴ.
ᩁᩣᩈᩥᨶᩥᨧ᩠ᨧᩃ ᨾᩣᨿᩣᩈᩩ, ᨴᨾ᩠ᨽᩣ’ᩈᨧ᩠ᨧᩮᩈ᩠ᩅ’ᨿᩮᩣᨥᨶᩮ;
ᨣᩥᩁᩥᩈᩥᨦ᩠ᨣᨾ᩠ᩉᩥ ᩈᩦᩁᨦ᩠ᨣᩮ, ᨿᨶ᩠ᨲᩮ ᨠᩪᨭ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.
ᩅᩩᨴ᩠ᨵᩥᨿᩴ ᨩᨶᨶᩮ ᨠᩣᨾ, ᨵᩣᨲ᩠ᩅᩣᨴᩦᨾ᩠ᩉᩥ ᨧ ᨸᨲ᩠ᨲᩥᨿᩴ;
ᩈᨲ᩠ᨲᩣᨿᨬ᩠ᨧᩮᩅ ᩈᩴᩈᩣᩁᩮ, ᨽᩅᩮᩣ ᩈᩔᨲᨴᩥᨭ᩠ᨮᩥᨿᩴ.
ᨸᨭᩥᩅᩣᨠ᩠ᨿᩮᩣ’ᨲ᩠ᨲᩁᩣᩈᨦ᩠ᨣᩮ, ᩈᩩ’ᨲ᩠ᨲᩁᩴ ᩏᨲ᩠ᨲᩁᩮᩣ ᨲᩥᩈᩩ;
ᩈᩮᨭ᩠ᨮᩮ ᨴᩥᩈᩣᨴᩥᨽᩮᨴᩮ ᨧ, ᨸᩁᩈ᩠ᨾᩥ ᨾᩩᨸᩁᩦ’ᩁᩥᨲᩮᩣ.
ᨶᩮᨠ᩠ᨡᨾ᩠ᨾᩴ ᨸᨮᨾᨩ᩠ᨫᩣᨶᩮ, ᨸᨻ᩠ᨻᨩ᩠ᨩᩣᨿᩴ ᩅᩥᨾᩩᨲ᩠ᨲᩥᨿᩴ;
ᩅᩥᨸᩔᨶᩣᨿ ᨶᩥᩔᩮᩈ, ᨠᩩᩈᩃᨾ᩠ᩉᩥ ᨧ ᨴᩥᩔᨲᩥ.
ᩈᨦ᩠ᨡᩣᩁᩮᩣ ᩈᨦ᩠ᨡᨲᩮ ᨸᩩᨬ᩠ᨬᩣ, ᨽᩥᩈᨦ᩠ᨡᩣᩁᩣᨴᩥᨠᩮᨸᩥ ᨧ;
ᨸᨿᩮᩣᨣᩮ ᨠᩣᨿᩈᨦ᩠ᨡᩣᩁᩣ, ᨴ᩠ᨿ’ᨽᩥᩈᨦ᩠ᨡᩁᨱᩮᩈᩩ ᨧ.
ᩌᩁᨾ᩠ᨾᨱᩮ ᨧ ᩈᩴᩈᨭ᩠ᨮᩮ, ᩅᩮᩣᨠᩥᨱ᩠ᨱᩮ ᨶᩥᩔᨿᩮ ᨲᨳᩣ;
ᨲᨻ᩠ᨽᩣᩅᩮ ᨧᩣᨸ᩠ᨿᨽᩥᨵᩮᨿ᩠ᨿ, ᩃᩥᨦ᩠ᨣᩮᩣ ᩈᩉᨣᨲᩮᩣ ᨽᩅᩮ.
ᨲᩦᩈᩩ ᨨᨶ᩠ᨶᩴ ᨸᨲᩥᩁᩪᨸᩮ, ᨨᩣᨴᩥᨲᩮ ᨧ ᨶᩥᨣᩪᩉᩥᨲᩮ;
ᨶᩥᩅᩣᩈᨶ ᨸᩣᩁᩩᨸᨶᩮ, ᩁᩉᩮᩣ ᨸᨬ᩠ᨬᨲ᩠ᨲᩥᨿᩴ ᨸᩩᨾᩮ.
ᨻᩩᨴ᩠ᨵᩈᨾᨶ᩠ᨲᨧᨠ᩠ᨡᩪᩈᩩ, ᨧᨠ᩠ᨡᩩ ᨸᨬ᩠ᨬᩣᨿ ᨾᩦᩁᩥᨲᩴ;
ᨵᨾ᩠ᨾᨧᨠ᩠ᨡᩩᨾ᩠ᩉᩥ ᨧ ᨾᩴᩈ, ᨴᩥᨻ᩠ᨻᨧᨠ᩠ᨡᩩᨴ᩠ᩅᨿᩮᩈᩩ ᨧ.
ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩮᩣ ᩋᨽᩥᨠ᩠ᨠᨶ᩠ᨲᩮᩣ, ᩈᩩᨶ᩠ᨴᩁᨾ᩠ᩉᩥ ᩋᨽᩥᨠ᩠ᨠᨾᩮ;
ᩋᨽᩥᩁᩪᨸᩮ ᨡᨿᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨲᨳᩮᩅ’ᨻ᩠ᨽᨶᩩᨾᩮᩣᨴᨶᩮ.
ᨠᩣᩁᨱᩮ ᨴᩮᩈᨶᩣᨿᨬ᩠ᨧ, ᩅᩣᩁᩮ ᩅᩮᩅᨧᨶᩮᨸᩥ ᨧ;
ᨸᩣᨠᩣᩁᩈ᩠ᨾᩥᩴ [ᨸᨠᩣᩁᩈ᩠ᨾᩥᩴ (ᨠ.)] ᩋᩅᩈᩁᩮ, ᨸᩁᩥᨿᩣᨿᩮᩣ ᨠᨳᩦᨿᨲᩥ.
ᩅᩥᨬ᩠ᨬᩣᨱᩮ ¶ ᨧᩥᨲ᩠ᨲᨠᨾ᩠ᨾᩮ ᨧ, ᩅᩥᨧᩥᨲ᩠ᨲᩮ ᨧᩥᨲ᩠ᨲ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨸᨬ᩠ᨬᨲ᩠ᨲᩥ ᨧᩥᨲ᩠ᨲᨾᩣᩈᩮᩈᩩ, ᨧᩥᨲ᩠ᨲᩮᩣ, ᨲᩣᩁᨶ᩠ᨲᩁᩮ ᨳᩥᨿᩴ.
ᩈᩣᨾᩴ ᩅᩮᨴᨶ᩠ᨲᩁᩮ ᩈᩣᨶ᩠ᨲ᩠ᩅᩮ, ᨲᩴ ᨸᩦᨲᩮ ᩈᩣᨾᩃᩮ ᨲᩥᩈᩩ;
ᩈᨿᨾᨲ᩠ᨳᩮ ᨻ᩠ᨿᨿᩴ ᩈᩣᨾᩴ, ᩈᩣᨾᩣ ᨧ ᩈᩣᩁᩥᩅᩣᨿᨸᩥ.
ᨸᩩᨾᩮ ᩌᨧᩁᩥᨿᩣᨴᩥᨾ᩠ᩉᩥ, ᨣᩁᩩ [ᨣᩩᩁᩩ (ᨠ. ᨭᩦ.)] ᨾᩣᨲᩣᨸᩥᨲᩪᩈ᩠ᩅᨸᩥ;
ᨣᩁᩩ ᨲᩦᩈᩩ ᨾᩉᨶ᩠ᨲᩮ ᨧ, ᨴᩩᨩ᩠ᨩᩁᩣ’ᩃᩉᩩᨠᩮᩈᩩ ᨧ.
ᩋᨧ᩠ᨧᩥᨲᩮ ᩅᩥᨩ᩠ᨩᨾᩣᨶᩮ ᨧ, ᨸᩈᨲ᩠ᨳᩮ ᩈᨧ᩠ᨧ ᩈᩣᨵᩩᩈᩩ;
ᨡᩥᨶ᩠ᨶᩮ ᨧ ᩈᨾᩥᨲᩮ ᨧᩮᩅ, ᩈᨶ᩠ᨲᩮᩣᨽᩥᨵᩮᨿ᩠ᨿᩃᩥᨦ᩠ᨣᩥᨠᩮᩣᨲᩥ.
ᩍᨲᩥ ᨣᩣᨳᩣᩋᨶᩮᨠᨲ᩠ᨳᩅᨣ᩠ᨣᩮᩣ.
ᨴᩮᩅᩮᩣ ᩅᩥᩈᩩᨴ᩠ᨵᩥᨴᩮᩅᩣ’ᨴᩮᩣ, ᨾᩮᨥ ᨾᨧ᩠ᨧᩩ ᨶᨽᩮᩈᩩ ᨧ;
ᩋᨳᩮᩣᨸᩥ ᨲᩁᩩᨱᩮ ᩈᨲ᩠ᨲᩮ, ᨧᩮᩣᩁᩮᨸᩥ ᨾᩣᨱᩅᩮᩣ ᨽᩅᩮ.
ᩌᨴᩥ ᨠᩮᩣᨭ᩠ᨮᩣᩈ ᨠᩮᩣᨭᩦᩈᩩ, ᨸᩩᩁᨲᩮᩣ’ᨣ᩠ᨣᩴᩅᩁᩮ ᨲᩦᩈᩩ;
ᨸᨧ᩠ᨧᨶᩦᨠᩮᩣ’ᨲ᩠ᨲᨾᩮᩈ᩠ᩅ’ᨬ᩠ᨬᩮ, ᨸᨧ᩠ᨨᩣᨽᩣᨣᩮ ᨸᩁᩮᩣ ᨲᩥᩈᩩ.
ᨿᩮᩣᨶᩥ ᨠᩣᨾ ᩈᩥᩁᩥ’ᩔᩁᩮ, ᨵᨾ᩠ᨾᩩ’ᨿ᩠ᨿᩣᨾ ᨿᩈᩮ ᨽᨣᩴ;
ᩏᩊᩣᩁᩮᩣ ᨲᩦᩈᩩ ᩅᩥᨸᩩᩃᩮ, ᩈᩮᨭ᩠ᨮᩮ ᨧ ᨾᨵᩩᩁᩮ ᩈᩥᨿᩣ.
ᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ ᨲᩦᩈᩩ ᩈᨾ᩠ᨸᩩᨱ᩠ᨱᩮ, ᨾᨵᩩᩁᩮ ᨧ ᩈᨾᨦ᩠ᨣᩥᨶᩥ;
ᩈᨦ᩠ᨡᩣ ᨲᩩ ᨬᩣᨱᩮ ᨠᩮᩣᨭ᩠ᨮᩣᩈ, ᨸᨬ᩠ᨬᨲ᩠ᨲᩥ ᨣᨱᨶᩮᩈᩩ ᨧ.
ᨮᩣᨶᩴ ᩍᩔᩁᩥᨿᩮᩣ’ᨠᩣᩈ, ᩉᩮᨲᩪᩈᩩ ᨮᩥᨲᩥᨿᨾ᩠ᨸᩥ ᨧ;
ᩋᨳᩮᩣ ᨾᩣᨶᩮ ᨸᨠᩣᩁᩮᨧ, ᨠᩮᩣᨭ᩠ᨮᩣᩈᩮᨧ ᩅᩥᨵᩮᩣ ᨴ᩠ᩅᩥᩈᩩ.
ᨸᨬ᩠ᨬᩮᩣ’ᨸᩅᩣᩈ ᨡᨶ᩠ᨲᩦᩈᩩ, ᨴᨾᩮᩣ ᩍᨶ᩠ᨴᩕᩥᨿᩈᩴᩅᩁᩮ;
ᨬᩣᨱᩮ ᨧ ᩈᩮᩣᨾᨶᩔᩮᨧ, ᩅᩮᨴᩮᩣ ᨨᨶ᩠ᨴᩈᩥ ᨧᩮᩣ’ᨧ᩠ᨧᨲᩮ.
ᨡᨶ᩠ᨵᨠᩮᩣᨭ᩠ᨮᩣᩈ, ᨸᩔᩣᩅ, ᨾᨣ᩠ᨣ, ᩉᩮᨲᩪᩈᩩ ᨿᩮᩣᨶᩥ ᩈᩣ [ᨿᩮᩣᨶᩥ ᩈᩮᩣ (ᨭᩦ.)];
ᨠᩣᩃᩮ ᨲᩩ ᨠᩪᩃᩮ ᩈᩦᨾᩣᨿᩴ, ᩅᩮᩃᩣ ᩁᩣᩈᩥᨾ᩠ᩉᩥ ᨽᩣᩈᩥᨲᩣ.
ᩅᩮᩣᩉᩣᩁᩮᩣ ᩈᨴ᩠ᨴ ᨸᨱ᩠ᨱᨲ᩠ᨲᩥ, ᩅᨱᩥᨩ᩠ᨩᩣ ᨧᩮᨲᨶᩣᩈᩩ ᨧ;
ᨶᩣᨣᩮᩣ ᨲᩩ’ᩁᨣ ᩉᨲ᩠ᨳᩦᩈᩩ, ᨶᩣᨣᩁᩩᨠ᩠ᨡᩮ ᨲᨳᩩ’ᨲ᩠ᨲᨾᩮ.
ᩈᩮᨭ᩠ᨮᩣ’ᩈᩉᩣᨿ ᩈᨦ᩠ᨡ᩠ᨿᩣ’ᨬ᩠ᨬ,
ᨲᩩᩃ᩠ᨿᩮᩈ᩠ᩅᩮ’ᨠᩮᩣᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᩁᩣᨣᩮ ᨲᩩ ᨾᩣᨶᩈᩮᩣ ᨧᩥᨲ᩠ᨲᩣ, ᩁᩉᨲ᩠ᨲᩮᩈᩩ ᨧ ᨾᩣᨶᩈᩴ.
ᨾᩪᩃᩴ ¶ ᨽᩮ ᩈᨶ᩠ᨲᩥᨠᩮ ᨾᩪᩃ, ᨾᩪᩃᩮ ᩉᩮᨲᩩᨾ᩠ᩉᩥ ᨸᩣᨽᨲᩮ;
ᩁᩪᨸᩣᨴ᩠ᨿᩴ’ᩈ ᨸᨠᨱ᩠ᨯᩮᩈᩩ, ᨡᨶ᩠ᨵᩮᩣ ᩁᩣᩈᩥ ᨣᩩᨱᩮᩈᩩ ᨧ.
ᩌᩁᨾ᩠ᨽᩮᩣ ᩅᩦᩁᩥᨿᩮ ᨠᨾ᩠ᨾᩮ, ᩌᨴᩥᨠᨾ᩠ᨾᩮ ᩅᩥᨠᩮᩣᨸᨶᩮ;
ᩋᨳᩮᩣ ᩉᨴᨿᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩥ, ᨧᩥᨲ᩠ᨲᩮ ᨧ ᩉᨴᨿᩴ ᩏᩁᩮ.
ᨸᨧ᩠ᨨᩣᨲᩣᨸᩣ’ᨶᩩᨻᨶ᩠ᨵᩮᩈᩩ, ᩁᩣᨣᩣᨴᩮᩣ’ᨶᩩᩈᨿᩮᩣ ᨽᩅᩮ;
ᨾᩣᨲᨦ᩠ᨣᨾᩩᨴ᩠ᨵᨸᩥᨱ᩠ᨯᩮ ᨲᩩ, ᨥᨭᩮ ᨠᩩᨾ᩠ᨽᩮᩣ ᨴᩈᨾ᩠ᨻᨱᩮ.
ᨸᩁᩥᩅᩣᩁᩮᩣ ᨸᩁᩥᨩᨶᩮ, ᨡᨣ᩠ᨣᨠᩮᩣᩈᩮ ᨸᩁᩥᨧ᩠ᨨᨴᩮ;
ᩌᩃᨾ᩠ᨻᩁᩮᩣ ᨲᩩ ᩈᩣᩁᨾ᩠ᨽᩮ, ᨽᩮᩁᩥᨽᩮᨴᩮ ᨧ ᨴᩥᩔᨲᩥ.
ᨡᨱᩮᩣ ᨠᩣᩃᩅᩥᩈᩮᩈᩮ ᨧ, ᨶᩥᨻ᩠ᨿᩣᨸᩣᩁᨭ᩠ᨮᩥᨲᩥᨾ᩠ᩉᩥ ᨧ;
ᨠᩩᩃᩮ ᨲ᩠ᩅ’ᨽᩥᨩᨶᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩏᨸ᩠ᨸᨲ᩠ᨲᩥᨽᩪᨾᩥᨿᨾ᩠ᨸᩥ ᨧ.
ᩌᩉᩣᩁᩮᩣ ᨠᨻᩊᩦᨠᩣᩁᩣ, ᩉᩣᩁᩣᨴᩦᩈᩩ ᨧ ᨠᩣᩁᨱᩮ;
ᩅᩥᩔᩣᩈᩮ ᨿᩣᨧᨶᩣᨿᨬ᩠ᨧ, ᨸᩮᨾᩮ ᨧ ᨸᨱᨿᩮᩣ ᨾᨲᩮᩣ.
ᨱᩣᨴᩮᩣ ᩈᨴ᩠ᨵᩣ, ᨧᩦᩅᩁᩣᨴᩥ, ᩉᩮᨲ᩠ᩅᩣ’ᨵᩣᩁᩮᩈᩩ ᨸᨧ᩠ᨧᨿᩮᩣ;
ᨠᩦᩊᩣ ᨴᩥᨻ᩠ᨻᩅᩥᩉᩣᩁᩣᨴᩮᩣ, ᩅᩥᩉᩣᩁᩮᩣ ᩈᩩᨣᨲᩣᩃᨿᩮ.
ᩈᨾᨲ᩠ᨳᨶᩮ ᨾᨲᩮᩣ ᨧᩥᨲ᩠ᨲᩮ, ᨠᨣ᩠ᨣᨲᩣᨿᩴ ᩈᨾᩣᨵᩥ ᨧ;
ᨿᩮᩣᨣᩮᩣ ᩈᨦ᩠ᨣᨲᩥ [ᩈᨦ᩠ᨣᩮ ᨧ (ᨭᩦ.)] ᨠᩣᨾᩣᨴᩮᩣ,
ᨫᩣᨶᩮᩣ’ᨸᩣᨿᩮᩈᩩ ᨿᩩᨲ᩠ᨲᩥᨿᩴ.
ᨽᩮᩣᨣᩮᩣ ᩈᨸ᩠ᨸᨹᨱ’ᨦ᩠ᨣᩮᩈᩩ, ᨠᩮᩣᨭᩥᩃ᩠ᩃᩮ ᨽᩩᨬ᩠ᨩᨶᩮ ᨵᨶᩮ;
ᨽᩪᨾᩥᨽᩣᨣᩮ ᨠᩥᩃᩮᩈᩮ ᨧ, ᨾᩃᩮ ᨧᩣ’ᨦ᩠ᨣᨱ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᨵᨶᩣᨴᩥᨴᨸ᩠ᨸᩮ ᨸᨬ᩠ᨬᩣᨿ, ᩋᨽᩥᨾᩣᨶᩮᩣ ᨾᨲᩮᩣ ᨳ ᨧ;
ᩋᨸᨴᩮᩈᩮᩣ ᨶᩥᨾᩥᨲ᩠ᨲᩮ ᨧ, ᨨᩃᩮ ᨧ ᨠᨳᨶᩮ ᨾᨲᩮᩣ.
ᨧᩥᨲ᩠ᨲᩮ ᨠᩣᨿᩮ ᩈᨽᩣᩅᩮ ᨧ, ᩈᩮᩣ ᩋᨲ᩠ᨲᩣ ᨸᩁᨾ’ᨲ᩠ᨲᨶᩥ;
ᩋᨳ ᨣᩩᨾ᩠ᨻᩮᩣ ᨧ ᨳᨾ᩠ᨻᩈ᩠ᨾᩥᩴ [ᨳᨾ᩠ᨽᩈ᩠ᨾᩥᩴ (ᨭᩦ.)], ᩈᨾᩪᩉᩮ ᨻᩃᩈᨩ᩠ᨩᨶᩮ.
ᩋᨶ᩠ᨲᩮᩣᨥᩁᩮ ᨠᩩᩈᩪᩃᩮ ᨧ, ᨠᩮᩣᨭ᩠ᨮᩮᩣ ᨶ᩠ᨲᩮᩣᨠᩩᨧ᩠ᨨᩥᨿᩴ ᨸ᩠ᨿᨳ;
ᩈᩮᩣᨸᩣᨶᨦ᩠ᨣᨾ᩠ᩉᩥ ᩏᨱ᩠ᩉᩦᩈᩮᩣ, ᨾᨠᩩᨭᩮ ᩈᩦᩈᩅᩮᨮᨶᩮ.
ᨶᩥᨿ᩠ᨿᩣᩈᩮ ᩈᩮᨡᩁᩮ ᨴ᩠ᩅᩣᩁᩮ, ᨶᩥᨿ᩠ᨿᩪᩉᩮᩣ ᨶᩣᨣᨴᨶ᩠ᨲᨠᩮ;
ᩋᨳᩮᩣ ᩈᩥᨡᨱ᩠ᨯᩮ ᨲᩪᨱᩦᩁᩮ, ᨠᩃᩣᨸᩮᩣ ᨶᩥᨠᩁᩮ ᨾᨲᩮᩣ.
ᨧᩪᩊᩣ ᩈᩴᨿᨲᨠᩮᩈᩮᩈᩩ, ᨾᨠᩩᨭᩮ ᨾᩮᩣᩊᩥ ᨧ ᨴ᩠ᩅᩥᩈᩩ;
ᩈᨦ᩠ᨡᩮᩣ ᨲ᩠ᩅ’ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨠᨾ᩠ᨻᩩ, ᨶᩃᩣᨭ’ᨭ᩠ᨮᩦᩈᩩ [ᩃᩃᩣᨭᨭ᩠ᨮᩦᩈᩩ (ᩈᩦ.)] ᨣᩮᩣᨸ᩠ᨹᨠᩮ.
ᨸᨠ᩠ᨡᩮᩣ ¶ ᨠᩣᩃᩮ ᨻᩃᩮ ᩈᩣᨵ᩠ᨿᩮ, ᩈᨡᩦ ᩅᩣᨩᩮᩈᩩ ᨸᨦ᩠ᨣᩩᩃᩮ;
ᨴᩮᩈᩮ’ᨱ᩠ᨱᩅᩮ ᨸᩩᨾᩮ ᩈᩥᨶ᩠ᨵᩩ, ᩈᩁᩥᨲᩣᨿᩴ ᩈ ᨶᩣᩁᩥᨿᩴ.
ᨣᨩᩮ ᨠᩁᩮᨱᩩ ᨸᩩᩁᩥᩈᩮ, ᩈᩮᩣ ᩉᨲ᩠ᨳᩥᨶᩥᨿ ᨾᩥᨲ᩠ᨳᩥᨿᩴ;
ᩁᨲᨶᩮ ᩅᨩᩥᩁᩮᩣ ᨶᩥᨲ᩠ᨳᩦ, ᨾᨱᩥᩅᩮᨵᩥ’ᨶ᩠ᨴᩉᩮᨲᩥᩈᩩ.
ᩅᩥᩈᩣᨱᩴ ᨲᩦᩈᩩ ᨾᩣᨲᨦ᩠ᨣ, ᨴᨶ᩠ᨲᩮ ᨧ ᨸᩈᩩᩈᩥᨦ᩠ᨣᨠᩮ;
ᨠᩮᩣᨭᩥᨿᩴ ᨲᩩ ᨾᨲᩮᩣ ᨠᩮᩣᨱᩮᩣ, ᨲᨳᩣ ᩅᩣᨴᩥᨲ᩠ᨲᩅᩣᨴᨶᩮ.
ᩅᨱᩥᨸ᩠ᨸᨳᩮ ᨧ ᨶᨣᩁᩮ, ᩅᩮᨴᩮ ᨧ ᨶᩥᨣᨾᩮᩣ ᨳ ᨧ;
ᩅᩥᩅᩣᨴᩣᨴᩮᩣ’ ᨵᩥᨠᩁᨱᩴ, ᩈᩥᨿᩣ’ᨵᩣᩁᩮ ᨧ ᨠᩣᩁᨱᩮ.
ᨸᩈᩩᨾ᩠ᩉᩥ ᩅᩈᩩᨵᩣᨿᨬ᩠ᨧ, ᩅᩣᨧᩣᨴᩮᩣ ᨣᩮᩣ ᨸᩩᨾᩥᨲ᩠ᨳᩥᨿᩴ;
ᩉᩁᩥᨲᩮ ᨲᩩ ᩈᩩᩅᨱ᩠ᨱᩮ ᨧ, ᩅᩣᩈᩩᨴᩮᩅᩮ ᩉᩁᩦ’ᩁᩥᨲᩮᩣ.
ᩌᨿᨲ᩠ᨲᩮ ᨸᩁᩥᩅᩣᩁᩮ ᨧ, ᨽᩁᩥᨿᩣᨿᩴ ᨸᩁᩥᨣ᩠ᨣᩉᩮᩣ;
ᩏᨲ᩠ᨲᩴᩈᩮᩣ ᨲ᩠ᩅ’ ᩅᨲᩴᩈᩮᩣ ᨧ, ᨠᨱ᩠ᨱᨸᩪᩁᩮ ᨧ ᩈᩮᨡᩁᩮ.
ᩅᩥᨩ᩠ᨩᩩᨿᩴ ᩅᨩᩥᩁᩮ ᨧᩮᩅᩣ, ᩈᨶᩥ’ᨲ᩠ᨳᩥᨸᩩᩁᩥᩈᩮ ᨸ᩠ᨿᨳ;
ᨠᩮᩣᨱᩮ ᩈᨦ᩠ᨡ᩠ᨿᩣᩅᩥᩈᩮᩈᩈ᩠ᨾᩥᩴ, ᩏᨠ᩠ᨠᩴᩈᩮ ᨠᩮᩣᨭᩥ ᨶᩣᩁᩥᨿᩴ.
ᨧᩪᩊᩣ ᨩᩣᩃᩣ ᨸᨵᩣᨶ’ᨣ᩠ᨣ, ᨾᩮᩣᩁᨧᩪᩊᩣᩈᩩ ᩈᩣ ᩈᩥᨡᩣ;
ᩈᨸ᩠ᨸᨴᩣᨮᩣᨿ ᨾᩣᩈᩦ’ᨲ᩠ᨳᩦ, ᩍᨭ᩠ᨮᩔᩣ’ᩈᩦᩈᨶᩣᨿᨸᩥ.
ᩅᩈᩣ ᩅᩥᩃᩦᨶ ᨲᩮᩃᩈ᩠ᨾᩥᩴ, ᩅᩈᨣᩣ ᩅᨬ᩠ᨫᨣᩣᩅᩥᩈᩩ;
ᩋᨽᩥᩃᩣᩈᩮ ᨲᩩ ᨠᩥᩁᨱᩮ, ᩋᨽᩥᩈᨦ᩠ᨣᩮ ᩁᩩᨧᩥ’ᨲ᩠ᨳᩥᨿᩴ.
ᩈᨬ᩠ᨬᩣ ᩈᨬ᩠ᨩᩣᨶᨶᩮ ᨶᩣᨾᩮ, ᨧᩮᨲᨶᩣᨿᨬ᩠ᨧ ᨴᩥᩔᨲᩥ;
ᩋᩴᩈᩮ ᩈᩥᨸ᩠ᨸᩮ ᨠᩃᩣ ᨠᩣᩃᩮ, ᨽᩣᨣᩮ ᨧᨶ᩠ᨴᩔ ᩈᩮᩣᩊᩈᩮ.
ᨻᩦᨩᨠᩮᩣᩈᩮ ᨥᩁᨠᩪᨭᩮ, ᨠᨱ᩠ᨱᨽᩪᩈᩣᨿ ᨠᨱ᩠ᨱᩥᨠᩣ;
ᩌᨣᩣᨾᩥᨠᩣᩃᩮ ᨴᩦᨥᨲ᩠ᨲᩮ, ᨸᨽᩣᩅᩮ ᨧ ᨾᨲᩣ’ᨿᨲᩥ.
ᩏᨱ᩠ᨱᩣ ᨾᩮᩈᩣᨴᩥᩃᩮᩣᨾᩮ, ᨧ, ᨽᩪᨾᨩ᩠ᨫᩮ ᩁᩮᩣᨾᨵᩣᨲᩩᨿᩴ;
ᩅᩣᩁᩩᨱᩦ ᨲ᩠ᩅᩥᨲ᩠ᨳᩥᨿᩴ ᩅᩩᨲ᩠ᨲᩣ, ᨶᨭ᩠ᨭᨠᩦ ᨾᨴᩥᩁᩣᨴᩥᩈᩩ.
ᨠᩕᩥᨿᨧᩥᨲ᩠ᨲᩮ ᨧ ᨠᩁᨱᩮ, ᨠᩥᩁᩥᨿᩴ ᨠᨾ᩠ᨾᨶᩥ ᨠᩕᩥᨿᩣ;
ᩈᩩᨶᩥᩈᩣᨿᩴ ᨲᩩ ᨠᨬ᩠ᨬᩣᨿ, ᨩᩣᨿᩣᨿ ᨧ ᩅᨵᩪ ᨾᨲᩣ.
ᨸᨾᩣᨱᩥ’ᩔᩁᩥᨿᩮ ᨾᨲ᩠ᨲᩣ, ᩋᨠ᩠ᨡᩁᩣᩅᨿᩅᩮ’ᨸ᩠ᨸᨠᩮ;
ᩈᩩᨲ᩠ᨲᩴ ᨸᩣᩅᨧᨶᩮ ᩁᩥᨭ᩠ᨮᩮ [ᩈᩥᨴ᩠ᨵᩮ (ᨭᩦ.)], ᨲᨶ᩠ᨲᩮ ᨲᩴ ᩈᩩᨸᩥᨲᩮ ᨲᩥᩈᩩ.
ᩁᩣᨩᩃᩥᨦ᩠ᨣᩮᩣ’ᩈᨽᨦ᩠ᨣᩮᩈᩩ, ¶ ᩁᩩᨠ᩠ᨡᩮ ᨧ ᨠᨠᩩᨴᩮᩣ [ᨠᨠᩩᨵᩮᩣ (ᨭᩦ. ᩈᩦ.)] ᨸ᩠ᨿᨳ;
ᨶᩥᨾᩥᨲ᩠ᨲ’ᨠ᩠ᨡᩁ ᩈᩪᨸᩮᩈᩩ, ᨻ᩠ᨿᨬ᩠ᨩᨶᩴ ᨧᩥᩉᨶᩮ ᨸᨴᩮ.
ᩅᩮᩣᩉᩣᩁᩮ ᨩᩮᨲᩩ ᨾᩥᨧ᩠ᨨᩣᨿᩴ, ᨠᩦᩊᩣᨴᩮᩣ ᨧᩣᨸᩥ ᨴᩮᩅᨶᩴ;
ᨽᩁᩥᨿᩣᨿᩴ ᨲᩩ ᨠᩮᨴᩣᩁᩮ, ᩈᩁᩦᩁᩮ ᨡᩮᨲ᩠ᨲ ᨾᩦᩁᩥᨲᩴ.
ᩈᩩᩔᩪᩈᩣᨿᨬ᩠ᨧ ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ, ᩍᩔᩣᨽ᩠ᨿᩣᩈᩮ ᨸ᩠ᨿᩩ’ᨸᩣᩈᨶᩴ;
ᩈᩪᩃᩴ ᨲᩩ ᨶᩥᨲ᩠ᨳᩥᨿᩴ ᩉᩮᨲᩥ, ᨽᩮᨴᩮ ᩈᩴᨠᩩ ᩁᩩᨩᩣᩈᩩ ᨧ.
ᨲᨶ᩠ᨲᩥ ᩅᩦᨱᩣᨣᩩᨱᩮ, ᨲᨶ᩠ᨲᩴ, ᨾᩩᨡ᩠ᨿᩈᩥᨴ᩠ᨵᨶ᩠ᨲ ᨲᨶ᩠ᨲᩩᩈᩩ;
ᩁᨳᩣᨴ᩠ᨿᨦ᩠ᨣᩮ ᨲᩩ ᨧ ᨿᩩᨣᩮᩣ, ᨠᨸ᩠ᨸᨾ᩠ᩉᩥ ᨿᩩᨣᩃᩮ ᨿᩩᨣᩴ.
ᩍᨲ᩠ᨳᩥᨸᩩᨸ᩠ᨹᩮ ᨧ ᩁᩮᨱᩩᨾ᩠ᩉᩥ, ᩁᨩᩮᩣ ᨸᨠᨲᩥᨩᩮ ᨣᩩᨱᩮ;
ᨶ᩠ᨿᩣᩈᨸ᩠ᨸᨱᩮ ᨲᩩ ᨴᩣᨶᨾ᩠ᩉᩥ, ᨶᩥᨿ᩠ᨿᩣᨲᨶ ᨾᩩᨴᩦᩁᩥᨲᩴ.
ᨣᩁᩩ’ᨸᩣᨿᩣ’ᩅᨲᩣᩁᩮᩈᩩ, ᨲᩥᨲ᩠ᨳᩴ ᨸᩪᨲᨾ᩠ᨻᩩ ᨴᩥᨭ᩠ᨮᩥᩈᩩ;
ᨸᨱ᩠ᨯᨠᩮ ᨩᩮᩣᨲᩥ ᨶᨠ᩠ᨡᨲ᩠ᨲ, ᩁᩴᩈᩦᩈ᩠ᩅ’ᨣ᩠ᨣᩥᨾ᩠ᩉᩥ ᨩᩮᩣᨲᩥ ᩈᩮᩣ.
ᨠᨱ᩠ᨯᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᩈᩁᩮ ᨴᨱ᩠ᨯᩮ, ᩅᨣ᩠ᨣᩮ ᨧᩣᩅᩈᩁᩮ ᨸ᩠ᨿᨳ;
ᩏᨴ᩠ᨵᩴᨻᩣᩉᩩᨴ᩠ᩅᨿᨾᩣᨶᩮ [ᨻᩣᩉᩩᨴ᩠ᩅᨿᩩᨾ᩠ᨾᩣᨶᩮ (ᩈᩦ. ᨠ.)], ᩈᩪᩁᨲ᩠ᨲᩮᨸᩥ ᨧ ᨸᩮᩣᩁᩥᩈᩴ.
ᩏᨭ᩠ᨮᩣᨶᩴ ᨸᩮᩣᩁᩥᩈᩮ’ᩉᩣᩈᩩ, ᨶᩥᩈᩥᨶ᩠ᨶᩣᨴ᩠ᨿᩩ’ᨣ᩠ᨣᨾᩮ ᨸ᩠ᨿᨳ;
ᩋᨶᩥᩔᨿᨾᩉᩦᨽᩣᨣᩮ, ᨲ᩠ᩅᩥ’ᩁᩦᨱᩴ ᩐᩈᩁᩮ ᩈᩥᨿᩣ.
ᩌᩁᩣᨵᨶᩴ ᩈᩣᨵᨶᩮ ᨧ, ᨸᨲ᩠ᨲᩥᨿᩴ ᨸᩁᩥᨲᩮᩣᩈᨶᩮ;
ᨸᨵᩣᨶᩮ ᨲᩩ ᨧ ᩈᩣᨶᩩᨾ᩠ᩉᩥ, ᩅᩥᩈᩣᨱᩮ ᩈᩥᨦ᩠ᨣ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᨴᩥᨭ᩠ᨮᩣ’ᨴᩥᨾᨣ᩠ᨣᩮ ᨬᩣᨱ’ᨠ᩠ᨡᩥ, ᨠ᩠ᨡᨱ ᩃᨴ᩠ᨵᩦᩈᩩ ᨴᩔᨶᩴ;
ᩉᩮᨾᩮ ᨸᨬ᩠ᨧᩈᩩᩅᨱ᩠ᨱᩮ ᨧ, ᨶᩥᨠ᩠ᨡᩮᩣ ᨶᩥᨲ᩠ᨳᩦ ᨸᩈᩣᨵᨶᩮ.
ᨲᩥᨳᩥᨽᩮᨴᩮ ᨧ ᩈᩣᨡᩣᨴᩥ, ᨹᩊᩩᨾ᩠ᩉᩥ ᨸᨻ᩠ᨻ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᨶᩣᨣᩃᩮᩣᨠᩮ ᨲᩩ ᨸᩣᨲᩣᩃᩴ, ᨽᩣᩈᩥᨲᩴ ᨻᩃᩅᩣᨾᩩᨡᩮ.
ᨠᩣᨾᨩᩮ ᨠᩮᩣᨸᨩᩮ ᨴᩮᩣᩈᩮ, ᨻ᩠ᨿᩈᨶᨬ᩠ᨧ ᩅᩥᨸᨲ᩠ᨲᩥᨿᩴ;
ᩋᨳᩮᩣ’ᨸᨠᩁᨱᩮ ᩈᩥᨴ᩠ᨵᩥ, ᨠᩣᩁᨠᩮᩈᩩ ᨧ ᩈᩣᨵᨶᩴ.
ᨲᩦᩈ᩠ᩅᩦᩁᩥᨲᩮᩣ [ᨲᩦᩈ᩠ᩅᩥᨲᩮᩣ (ᨭᩦ.)] ᨴᩣᨶᩈᩦᩃᩮ, ᩅᨴᨬ᩠ᨬᩪ ᩅᨣ᩠ᨣᩩᩅᩣᨴᩥᨶᩥ;
ᨸᩩᩁᨠ᩠ᨡᨲᩮᩣ ᨽᩥᩈᩥᨲ᩠ᨲᩮ ᨧ, ᨸᩪᨩᩥᨲᩮ ᨸᩩᩁᨲᩮᩣᨠᨲᩮ.
ᨾᨶ᩠ᨴᩮᩣ ᨽᩣᨣ᩠ᨿᩅᩥᩉᩦᨶᩮ ᨧᩣ, ᨸ᩠ᨸᨠᩮ ᨾᩪᩊ᩠ᩉᩣ’ᨸᨭᩪᩈ᩠ᩅᨸᩥ;
ᩅᩩᨴ᩠ᨵᩥᨿᩩᨲ᩠ᨲᩮ ᩈᨾᩩᨶ᩠ᨶᨴ᩠ᨵᩮ, ᩏᨸ᩠ᨸᨶ᩠ᨶᩮ ᩏᩔᩥᨲᩴ ᨽᩅᩮ.
ᩁᨳᨦ᩠ᨣᩮ’ᨠ᩠ᨡᩮᩣ ¶ ᩈᩩᩅᨱ᩠ᨱᩈ᩠ᨾᩥᩴ, ᨸᩣᩈᨠᩮ, ᩋᨠ᩠ᨡ ᨾᩥᨶ᩠ᨴᩕᩥᨿᩮ;
ᩈᩔᨲᩮ ᨧ ᨵᩩᩅᩮᩣ ᨲᩦᩈᩩ, ᨵᩩᩅᩴ ᨲᨠ᩠ᨠᩮ ᨧ ᨶᩥᨧ᩠ᨨᩥᨲᩮ.
ᩉᩁᩮ ᩈᩥᩅᩮᩣ, ᩈᩥᩅᩴ ᨽᨴ᩠ᨴ, ᨾᩮᩣᨠ᩠ᨡᩮᩈᩩ, ᨩᨾ᩠ᨻᩩᨠᩮ ᩈᩥᩅᩣ;
ᩈᩮᨶᩣᨿᩴ ᩈᨲ᩠ᨲᩥᨿᨬ᩠ᨧᩮᩅ, ᨳᩪᩃᨲ᩠ᨲᩮ ᨧ ᨻᩃᩴ ᨽᩅᩮ.
ᩈᨦ᩠ᨡ᩠ᨿᩣ ᨶᩁᨠᨽᩮᨴᩮᩈᩩ, ᨸᨴᩩᨾᩴ ᩅᩣᩁᩥᨩᩮ ᨸ᩠ᨿᨳ;
ᨴᩮᩅᨽᩮᨴᩮ ᩅᩈᩩ ᨸᩩᨾᩮ, ᨸᨱ᩠ᨯᨠᩴ ᩁᨲᨶᩮ ᨵᨶᩮ.
ᨶᩥᨻ᩠ᨻᩣᨶᩴ ᩋᨲ᩠ᨳᨣᨾᨶᩮ, ᩋᨸᩅᨣ᩠ᨣᩮ ᩈᩥᨿᩣ ᨳ ᨧ;
ᩈᩮᨲᨾ᩠ᨻᩩᨩᩮ ᨸᩩᨱ᩠ᨯᩁᩦᨠᩴ, ᨻ᩠ᨿᨣ᩠ᨥᩮ ᩁᩩᨠ᩠ᨡᨶ᩠ᨲᩁᩮ ᨸᩩᨾᩮ.
ᩏᨸᩉᩣᩁᩮ ᨻᩃᩥ ᨸᩩᨾᩮ, ᨠᩁᩈ᩠ᨾᩥᩴᨧᩣ’ᩈᩩᩁᨶ᩠ᨲᩁᩮ;
ᩈᩩᨠ᩠ᨠᩴ ᨲᩩ ᩈᨾ᩠ᨽᩅᩮ, ᩈᩩᨠ᩠ᨠᩮᩣ, ᨵᩅᩃᩮ, ᨠᩩᩈᩃᩮ ᨲᩥᩈᩩ.
ᨴᩣᨿᩮᩣ ᨴᩣᨶᩮ ᩅᩥᨽᨲ᩠ᨲᨻ᩠ᨻ, ᨵᨶᩮ ᨧ ᨸᩥᨲᩩᨶᩴ ᩅᨶᩮ [ᨵᨶᩮ (ᨭᩦ.)];
ᨸᨽᩩᨲ᩠ᨲᩣ’ᨿᨲ᩠ᨲᨲᩣ’ᨿᨲ᩠ᨲᩣ’, ᨽᩥᩃᩣᩈᩮᩈᩩ ᩅᩈᩮᩣ ᨽᩅᩮ.
ᨸᩁᩥᨽᩣᩈᨶ ᨾᨠ᩠ᨠᩮᩣᩈᩮ, ᨶᩥᨿᨾᩮ ᨽᩣᩈᨶᩮ ᨳ ᨧ,
ᨵᨶᨾ᩠ᩉᩥ ᩈᩮᩊᨶᩴ ᨿᩮᩣᨵ, ᩈᩦᩉᨶᩣᨴᨾ᩠ᩉᩥ ᨴᩥᩔᨲᩥ.
ᨸᨽᩅᩮᩣ ᨩᩣᨲᩥᩉᩮᨲᩩᨾ᩠ᩉᩥ, ᨮᩣᨶᩮ ᨧᩣᨴ᩠ᨿᩩᨸᩃᨴ᩠ᨵᩥᨿᩴ;
ᩋᨳᩮᩣ’ᨲᩩ ᨶᩣᩁᩥᨸᩩᨸ᩠ᨹᩈ᩠ᨾᩥᩴ, ᩉᩮᨾᨶ᩠ᨲᩣᨴᩥᨾ᩠ᩉᩥ ᨧ ᨴ᩠ᩅᩥᩈᩩ.
ᨠᩁᨱᩴ ᩈᩣᨵᨠᨲᨾᩮ, ᨠᩕᩥᨿᩣ ᨣᨲ᩠ᨲᩮᩈᩩ ᩍᨶ᩠ᨴᩕᩥᨿᩮ;
ᨲᩣᨲᩮᩣ [ᨲᩣᩊᩮᩣ (ᩈᩦ.)] ᨲᩩ ᨠᩩᨬ᩠ᨧᩥᨠᩣᨿᨬ᩠ᨧ, ᨲᩪᩁᩥᨿᨦ᩠ᨣᩮ ᨴᩩᨾᨶ᩠ᨲᩁᩮ.
ᨸᩩᨸ᩠ᨹᩮ ᨹᩃᩮ ᨧ ᨸᩈᩅᩮᩣ, ᩏᨸ᩠ᨸᩣᨴᩮ ᨣᨻ᩠ᨽᨾᩮᩣᨧᨶᩮ;
ᨣᩣᨿᨶᩮ ᨣᩣᨿᨠᩮ ᩋᩔᩮ, ᨣᨶ᩠ᨵᨻ᩠ᨻᩮᩣ ᨴᩮᩅᨲᩣᨶ᩠ᨲᩁᩮ.
ᩅᩥᨶᩣ ᨸᩩᨸ᩠ᨹᩴ ᨹᩃᨣ᩠ᨣᩣᩉᩥ, ᩁᩩᨠ᩠ᨡᩮ ᩅᨶᨸ᩠ᨸᨲᩥ;
ᩌᩉᨲᩮ ᩉᩮᨾᩁᨩᨲᩮ, ᩁᩪᨸᩥᨿᩴ ᩁᨩᨲᩮᨸᩥ ᨧ.
ᨡᨣᩣᨴᩥᨻᨶ᩠ᨵᨶᩮ ᨸᩣᩈᩮᩣ, ᨠᩮᩈᨸᩩᨻ᩠ᨻᩮᩣ ᨧᨿᩮ ᨸ᩠ᨿᨳ;
ᨲᩣᩁᩣ’ᨠ᩠ᨡᩥᨾᨩ᩠ᨫᩮ ᨶᨠ᩠ᨡᨲ᩠ᨲᩮ, ᨲᩣᩁᩮᩣ ᩏᨧ᩠ᨧᨲᩁᩔᩁᩮ.
ᨸᨲ᩠ᨲᩮ ᨧ ᩃᩮᩣᩉᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᨠᩴᩈᩮᩣ ᨧᨲᩩᨠᩉᩣᨸᨱᩮ;
ᨾᨩ᩠ᨫᩥᨾᩮᩣ ᨴᩮᩉᨾᨩ᩠ᨫᩈ᩠ᨾᩥᩴ, ᨾᨩ᩠ᨫᨽᩅᩮ ᨧ ᩈᩮᩣ ᨲᩥᩈᩩ.
ᩌᩅᩮᩈᨶᩴᨽᩪᨲᩣᩅᩮᩈᩮ, ᩈᩥᨸ᩠ᨸᩈᩣᩃᩣ ᨥᩁᩮᩈᩩ ᨧ;
ᩈᩮᩣᨽᩣ ᩈᨾ᩠ᨸᨲ᩠ᨲᩦᩈᩩ ᩈᩥᩁᩦ, ᩃᨠ᩠ᨡᩦᨲ᩠ᨳᩦ ᨴᩮᩅᨲᩣᨿ ᨧ.
ᨠᩩᨾᩣᩁᩮᩣ ¶ ᨿᩩᩅᩁᩣᨩᩮ ᨧ, ᨡᨶ᩠ᨴᩮ ᩅᩩᨲ᩠ᨲᩮᩣ ᩈᩩᩈᩩᨾ᩠ᩉᩥ ᨧ;
ᩋᨳᩣ’ᨶᩥᨲ᩠ᨳᩦ ᨸᩅᩣᩊᩮᩣ ᨧ, ᨾᨱᩥᨽᩮᨴᩮ ᨲᨳᩣ’ᨦ᩠ᨠᩩᩁᩮ.
ᨸᨱᩮᩣ ᩅᩮᨲᨶ ᨾᩪᩃᩮᩈᩩ, ᩅᩮᩣᩉᩣᩁᩮ ᨧ ᨵᨶᩮ ᨾᨲᩮᩣ;
ᨸᨭᩥᨣ᩠ᨣᩉᩮᩣ ᨲᩩ ᨣᩉᨱᩮ, ᨠᨳᩥᨲᩮᩣ ᨽᩣᨩᨶᨶ᩠ᨲᩁᩮ.
ᩋᩈᩩᨽᩮ ᨧ ᩈᩩᨽᩮ ᨠᨾ᩠ᨾᩮ, ᨽᩣᨣ᩠ᨿᩴ ᩅᩩᨲ᩠ᨲᩴ ᨴ᩠ᩅᨿᩮ ᨸ᩠ᨿᨳ;
ᨸᩥᨸ᩠ᨹᩃᩴ ᨲᩁᩩᨽᩮᨴᩮ ᨧ, ᩅᨲ᩠ᨳᨧ᩠ᨨᩮᨴᨶᩈᨲ᩠ᨳᨠᩮ.
ᩋᨸᩅᨣ᩠ᨣᩮᩣ ᨸᩁᩥᨧ᩠ᨧᩣᨣᩣ’, ᩅᩈᩣᨶᩮᩈᩩ ᩅᩥᨾᩩᨲ᩠ᨲᩥᨿᩴ;
ᩃᩥᨦ᩠ᨣᩴ ᨲᩩ ᩋᨦ᩠ᨣᨩᩣᨲᩈ᩠ᨾᩥᩴ, ᨸᩩᨾᨲ᩠ᨲᩣᨴᩥᨾ᩠ᩉᩥ ᩃᨠ᩠ᨡᨱᩮ.
ᨧᩣᨣᩮ ᩈᨽᩣᩅᩮ ᨶᩥᨾ᩠ᨾᩣᨶᩮ, ᩈᨣ᩠ᨣᩮᩣ ᨩ᩠ᨫᩣᨿᩮ ᨴᩥᩅᩮᨸ᩠ᨿᨳ;
ᩁᩮᩣᩉᩥᨲᩮᩣ ᩃᩮᩣᩉᩥᨲᩮ ᨾᨧ᩠ᨨ, ᨽᩮᨴᩮ ᨧᩮᩅ ᨾᩥᨣᨶ᩠ᨲᩁᩮ.
ᨶᩥᨭ᩠ᨮᩣ ᨶᩥᨸ᩠ᨹᨲ᩠ᨲᩥᨿᩴ ᨧᩮᩅᩣ, ᩅᩈᩣᨶᨾ᩠ᩉᩥ ᩋᨴᩔᨶᩮ;
ᨠᨱ᩠ᨭᨠᩮᩣ ᨲᩩ ᩈᨸᨲ᩠ᨲᩈ᩠ᨾᩥᩴ, ᩁᩩᨠ᩠ᨡᨦ᩠ᨣᩮ ᩃᩮᩣᨾᩉᩴᩈᨶᩮ.
ᨾᩩᨡ᩠ᨿᩮᩣ’ᨸᩣᨿᩮᩈᩩ ᩅᨴᨶᩮ, ᩌᨴᩥᩈ᩠ᨾᩥᩴ ᨾᩩᨡ ᨾᩦᩁᩥᨲᩴ;
ᨴᨻ᩠ᨻᩴ ᨽᨻ᩠ᨻᩮ ᨣᩩᨱᩣᨵᩣᩁᩮ, ᩅᩥᨲ᩠ᨲᩮ ᨧ ᨻᩩᨵ ᨴᩣᩁᩩᩈᩩ.
ᨾᩣᨶᩴ ᨸᨾᩣᨱᩮ ᨸᨲ᩠ᨳᩣᨴᩮᩣ, ᨾᩣᨶᩮᩣ ᩅᩩᨲ᩠ᨲᩮᩣ ᩅᩥᨵᩣᨿ ᨧ;
ᩋᨳᩮᩣ ᨸᩁᩥᩔᨾᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩅᩣᨿᩣᨾᩮᩣ ᩅᩦᩁᩥᨿᩮᨸᩥ ᨧ.
ᩈᩁᩮᩣᩁᩩᩉᩮ ᩈᨲᨸᨲ᩠ᨲᩴ, ᩈᨲᨸᨲ᩠ᨲᩮᩣ ᨡᨣᨶ᩠ᨲᩁᩮ;
ᨨᩥᨴ᩠ᨴᩮ ᨲᩩ ᨨᩥᨴ᩠ᨴᩅᨶ᩠ᨲᩮ ᨧ, ᩈᩩᩈᩥᩁᩴ ᨲᩪᩁᩥᨿᨶ᩠ᨲᩁᩮ.
ᩑᨠᩈ᩠ᨾᩥᩴ ᩈᨴᩥᩈᩮ ᩈᨶ᩠ᨲᩮ, ᩈᨾᩣᨶᩴ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩴ;
ᩋᨳᩮᩣ ᨣᩣᩁᩅ ᨽᩦᨲᩦᩈᩩ, ᩈᩴᩅᩮᨣᩮ ᩈᨾ᩠ᨽᨾᩮᩣ ᨾᨲᩮᩣ.
ᨩᩩᨱ᩠ᩉᩣ ᨧᨶ᩠ᨴᨸ᩠ᨸᨽᩣᨿᨬ᩠ᨧ, ᨲᨴᩩᨸᩮᨲᨶᩥᩈᩣᨿ ᨧ;
ᩅᩥᨾᩣᨶᩴ ᨴᩮᩅᨲᩣᩅᩣᩈᩮ, ᩈᨲ᩠ᨲᨽᩪᨾᩥᨥᩁᨾ᩠ᩉᩥ ᨧ.
ᨾᩣᩈᩮ ᨩᩮᨭ᩠ᨮᩮᩣ, ᨲᩥᩅᩩᨴ᩠ᨵᩣ’ᨲᩥ, ᨸ᩠ᨸᩈᨲ᩠ᨳᩮᩈᩩ ᨧ ᨲᩦᩈᩩ ᩈᩮᩣ;
ᨵᨾ᩠ᨾᩮ ᨧ ᨾᨦ᩠ᨣᩃᩮ ᩈᩮᨿ᩠ᨿᩮᩣ, ᩈᩮᩣ ᨸᩈᨲ᩠ᨳᨲᩁᩮ ᨲᩥᩈᩩ.
ᩌᨴᩥᨧ᩠ᨧᩣᨴᩥᨾ᩠ᩉᩥ ᨣᩉᨱᩮ, ᨶᩥᨻᨶ᩠ᨵᩮ ᨧ ᨥᩁᩮ ᨣᩉᩮᩣ;
ᨠᩣᨧᩮᩣ ᨲᩩ ᨾᨲ᩠ᨲᩥᨠᩣᨽᩮᨴᩮ, ᩈᩥᨠ᩠ᨠᩣᨿᩴ ᨶᨿᨶᩣᨾᨿᩮ.
ᨲᩦᩈᩩ ᨣᩣᨾᨱᩥ ᩈᩮᨭ᩠ᨮᩈ᩠ᨾᩥᩴ, ᩋᨵᩥᨸᩮ ᨣᩣᨾᨩᩮᨭ᩠ᨮᨠᩮ;
ᨻᩥᨾ᩠ᨻᩴ ᨲᩩ ᨸᨭᩥᨻᩥᨾ᩠ᨻᩮ ᨧ, ᨾᨱ᩠ᨯᩃᩮ ᨻᩥᨾ᩠ᨻᩥᨠᩣᨹᩃᩮ.
ᨽᩣᨩᨶᩣᨴᩥ ᨸᩁᩥᨠ᩠ᨡᩣᩁᩮ, ᨽᨱ᩠ᨯᩴ ᨾᩪᩃᨵᨶᩮᨸᩥ ᨧ;
ᨾᨣ᩠ᨣᩮᩣ ᨲ᩠ᩅᩁᩥᨿᨾᨣ᩠ᨣᩮ ᨧ, ᩈᨾ᩠ᨾᩣᨴᩥᨭ᩠ᨮᩣᨴᩥᨠᩮ, ᨸᨳᩮ.
ᩈᨾᩣ ¶ ᩅᩔᩮ, ᩈᨾᩮᩣ ᨡᩮᨴ, ᩈᨶ᩠ᨲᩦᩈᩩ, ᩈᩮᩣ ᨶᩥᨽᩮ ᨲᩥᩈᩩ;
ᨧᩣᨸᩮᨲ᩠ᩅᩥᩔᩣᩈ, ᨾᩩᩈᩩᨶᩮᩣ, ᩍᩔᩣᩈᩮᩣ ᨡᩮᨸᨠᨾ᩠ᩉᩥ ᨧ.
ᨻᩣᩃᩮᩣ ᨲᩦᩈ᩠ᩅᩣ’ᨴᩥᩅᨿᩈᩣ, ᩈᨾᨦ᩠ᨣᩥᨶᩥ ᩋᨸᨱ᩠ᨯᩥᨲᩮ;
ᩁᨲ᩠ᨲᩴ ᨲᩩ ᩈᩮᩣᨱᩥᨲᩮ, ᨲᨾ᩠ᨻᩣ, ᨶᩩᩁᨲ᩠ᨲ, ᩁᨬ᩠ᨩᩥᨲᩮ ᨲᩥᩈᩩ.
ᨲᨧᩮ ᨠᩣᨿᩮ ᨧ ᨲᨶ᩠ᩅᩥᨲ᩠ᨳᩦ, ᨲᩦᩈ᩠ᩅ’ᨸ᩠ᨸᩮ ᩅᩥᩁᩊᩮ ᨠᩥᩈᩮ;
ᩏᨲᩩᨽᩮᨴᩮ ᨲᩩ ᩈᩥᩈᩥᩁᩮᩣ, ᩉᩥᨾᩮ ᩈᩮᩣ ᩈᩦᨲᩃᩮ ᨲᩥᩈᩩ.
ᩈᨠ᩠ᨡᩁᩣ ᨣᩩᩊᨽᩮᨴᩮ ᨧ, ᨠᨳᩃᩮᨸᩥ ᨧ ᨴᩥᩔᨲᩥ;
ᩋᨶᩩᨣ᩠ᨣᩉᩮ ᨲᩩ ᩈᨦ᩠ᨡᩮᨸᩮ, ᨣᩉᨱᩮ ᩈᨦ᩠ᨣᩉᩮᩣ ᨾᨲᩮᩣ.
ᨴᨠ᩠ᨡᩮ ᨧ ᨲᩥᨡᩥᨱᩮ ᨻ᩠ᨿᨲ᩠ᨲᩮ, ᩁᩮᩣᨣᨾᩩᨲ᩠ᨲᩮ ᨸᨭᩩᨲ᩠ᨲᩥᩈᩩ;
ᩁᩣᨩᩣ ᨲᩩ ᨡᨲ᩠ᨲᩥᨿᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨶᩁᨶᩣᨳᩮ ᨸᨽᩩᨾ᩠ᩉᩥ ᨧ.
ᨡᩃᨬ᩠ᨧ ᨵᨬ᩠ᨬᨠᩁᨱᩮ, ᨠᨠ᩠ᨠᩮ ᨶᩦᨧᩮ ᨡᩃᩮᩣ ᨽᩅᩮ;
ᩋᨳᩩ’ᨸ᩠ᨸᩣᨴᩮ ᩈᨾᩩᨴᨿᩮᩣ, ᩈᨾᩪᩉᩮ ᨸᨧ᩠ᨧᨿᩮᨸᩥ ᨧ.
ᨻᩕᩉ᩠ᨾᨧᩣᩁᩦ ᨣᩉᨭ᩠ᨮᩣᨴᩮᩣ, ᩋᩔᨾᩮᩣ ᨧ ᨲᨸᩮᩣᩅᨶᩮ;
ᨽᨿᨦ᩠ᨠᩁᩮ ᨲᩩ ᨠᨮᩥᨶᩮ, ᨠᩩᩁᩪᩁᩮᩣ ᨲᩦᩈᩩ ᨶᩥᨴ᩠ᨴᨿᩮ.
ᨠᨶᩥᨭ᩠ᨮᩮᩣ ᨠᨶᩥᨿᩮᩣ ᨲᩦᩈᩩ, ᩋᨲ᩠ᨿᨸ᩠ᨸᩮ’ᨲᩥᨿᩩᩅᩮ ᨸ᩠ᨿᨳ;
ᩈᩦᨥᨾ᩠ᩉᩥ ᩃᩉᩩ ᨲᩴ, ᩍᨭ᩠ᨮ, ᨶᩥᩔᩣᩁᩣ’ᨣᩁᩩᩈᩩᨲ᩠ᨲᩥᩈᩩ.
ᩋᨵᩁᩮᩣ ᨲᩦᩈ᩠ᩅᨵᩮᩣ ᩉᩦᨶᩮ, ᨸᩩᨾᩮ ᨴᨶ᩠ᨲᨧ᩠ᨨᨴᩮ ᨸ᩠ᨿᨳ;
ᩈᩩᩔᩩᩈᩣ ᩈᩮᩣᨲᩩ ᨾᩥᨧ᩠ᨨᩣᨿ, ᩈᩣ ᨸᩣᩁᩥᨧᩁᩥᨿᩣᨿ ᨧ.
ᩉᨲ᩠ᨳᩮᩣ ᨸᩣᨱᩥᨾ᩠ᩉᩥ ᩁᨲᨶᩮ, ᨣᨱᩮ ᩈᩮᩣᨱ᩠ᨯᩣᨿ ᨽᨶ᩠ᨲᩁᩮ;
ᩌᩅᩣᨭᩮ ᩏᨴᨸᩣᨶᩮ ᨧ, ᨠᩪᨸᩮᩣ ᨠᩩᨾ᩠ᨽᩮ ᨧ ᨴᩥᩔᨲᩥ.
ᩌᨴᩮᩣ ᨸᨵᩣᨶᩮ ᨸᨮᨾᩴ, ᨸᨾᩩᨡᨬ᩠ᨧ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩴ;
ᩅᨩ᩠ᨩᨽᩮᨴᩮ ᨧ ᩅᩥᨲ ᨲᩴ, ᨲᩴ ᩅᩥᨲ᩠ᨳᩣᩁᩮ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩴ.
ᩈᩣᩁᩮᩣ ᨻᩃᩮ ᨳᩥᩁᩴᩈᩮ ᨧ, ᩏᨲ᩠ᨲᨾᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᨽᩣᩁᩮᩣ ᨲᩩ ᨡᨶ᩠ᨵᨽᩣᩁᩣᨴᩮᩣ, ᨴ᩠ᩅᩥᩈᩉᩔᨸᩃᩮᨸᩥ ᨧ.
ᨾᨶ᩠ᨴᩥᩁᩮ ᩁᩮᩣᨣᨽᩮᨴᩮ ᨧ, ᨡᨿᩮᩣ ᩋᨸᨧᨿᨾ᩠ᩉᩥ ᨧ;
ᩅᩣᩊᩮᩣ ᨲᩩ ᩈᩣᨸᨴᩮ ᩈᨸ᩠ᨸᩮ, ᨠᩩᩁᩪᩁᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.
ᩈᩣᩃᩮᩣ ᩈᨩ᩠ᨩᨴ᩠ᨴᩩᨾᩮ ᩁᩩᨠ᩠ᨡᩮ, ᩈᩣᩃᩣᨣᩮᩉᩮ ᨧ ᨴᩥᩔᨲᩥ;
ᩈᩮᩣᨲᩮ ᨲᩩ ᩈᩅᨶᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨿᨩᨶᩮ ᩈᩩᨲᩥᨿᨾ᩠ᨸᩥ ᨧ.
ᨲᩦᩈᩩ ᨸᨲᩮᩣ ᨸᩁᩮᨲᩮᩣ ᨧ, ᨾᨲᩮ ᨧ ᨸᩮᨲᨿᩮᩣᨶᩥᨩᩮ;
ᨡ᩠ᨿᩣᨲᩮ ᨲᩩ ᩉᨭ᩠ᨮᩮ ᩅᩥᨬ᩠ᨬᩣᨲᩮ, ᨸᨲᩦᨲᩴ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩴ.
ᩋᨵᩥᨸ᩠ᨸᩣᨿᩮ ¶ ᨧ ᩌᨵᩣᩁᩮ, ᩌᩈᨿᩮᩣ ᨠᨳᩥᨲᩮᩣ ᨳ ᨧ;
ᨸᨲ᩠ᨲᩴ ᨸᨠ᩠ᨡᩮ ᨴᩃᩮ, ᨸᨲ᩠ᨲᩮᩣ, ᨽᩣᨩᨶᩮ ᩈᩮᩣ ᨣᨲᩮ ᨲᩥᩈᩩ.
ᨠᩩᩈᩃᩮ ᩈᩩᨠᨲᩴ, ᩈᩩᨭ᩠ᨮᩩ, ᨠᨲᩮ ᨧ ᩈᩩᨠᨲᩮᩣ ᨲᩥᩈᩩ;
ᨲᨸᩔᩦ ᨲ᩠ᩅ’ᨶᩩᨠᨾ᩠ᨸᩣᨿᩣ, ᩁᩉᩮ ᩅᩩᨲ᩠ᨲᩮᩣ ᨲᨸᩮᩣᨵᨶᩮ.
ᨲᩦᩈᩩ ᩈᩩᩁᩣᨴᩥᩃᩮᩣᩃᩈ᩠ᨾᩥᩴ, ᩈᩮᩣᨱ᩠ᨯᩮᩣ ᩉᨲ᩠ᨳᩥᨠᩁᩮ ᨴ᩠ᩅᩥᩈᩩ;
ᩋᩔᩣᨴᨶᩮ ᨲᩩ ᩁᩈᨶᩴ, ᨩᩥᩅ᩠ᩉᩣᨿᨬ᩠ᨧ ᨵᨶᩥᨾ᩠ᩉᩥ ᨧ.
ᨸᨱᩦᨲᩮᩣ ᨲᩦᩈᩩ ᨾᨵᩩᩁᩮ, ᩏᨲ᩠ᨲᨾᩮ ᩅᩥᩉᩥᨲᩮ ᨸ᩠ᨿᨳ;
ᩋᨬ᩠ᨩᩈᩮ ᩅᩥᩈᩥᨡᩣᨿᨬ᩠ᨧ, ᨸᨶ᩠ᨲᩥᨿᩴ ᩅᩦᨳᩥ ᨶᩣᩁᩥᨿᩴ.
ᨸᩣᨸᩈ᩠ᨾᩥᩴ ᨣᨣᨶᩮ ᨴᩩᨠ᩠ᨡᩮ, ᨻ᩠ᨿᩈᨶᩮ ᨧᩣ’ᨥ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᩈᨾᩪᩉᩮ ᨸᨭᩃᩴ ᨶᩮᨲ᩠ᨲ, ᩁᩮᩣᨣᩮ ᩅᩩᨲ᩠ᨲᩴ ᨨᨴᩥᨾ᩠ᩉᩥ ᨧ.
ᩈᨶ᩠ᨵᩥ ᩈᨦ᩠ᨥᨭ᩠ᨭᨶᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩈᨶ᩠ᨵᩥ’ᨲ᩠ᨳᩥ ᨸᨭᩥᩈᨶ᩠ᨵᩥᨿᩴ;
ᩈᨲ᩠ᨲᨶ᩠ᨶᩴ ᨸᩪᩁᨱᩮ ᩈᩮᨭ᩠ᨮᩮ, ᨲᩥᩈᨶ᩠ᨲᩮ ᩈᨲ᩠ᨲᨾᩮᩣ ᨲᩥᩈᩩ.
ᩒᨩᩣ ᨲᩩ ᨿᩣᨸᨶᩣᨿᨬ᩠ᨧ, ᩒᨩᩮᩣ ᨴᩥᨲ᩠ᨲᩥ ᨻᩃᩮᩈᩩ ᨧ;
ᩋᨳᩮᩣ ᨶᩥᩈᩣᨾᨶᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨴᩔᨶᩮ ᩈᩅᨶᩮᨸᩥ ᨧ.
ᨣᨻ᩠ᨽᩮᩣ ᨠᩩᨧ᩠ᨨᩥᨭ᩠ᨮᩈᨲ᩠ᨲᩮ ᨧ, ᨠᩩᨧ᩠ᨨᩥ ᩒᩅᩁᨠᩮᩈᩩ ᨧ;
ᨡᨱ᩠ᨯᨶᩮ ᨲ᩠ᩅ’ᨸᨴᩣᨶᨬ᩠ᨧ, ᩍᨲᩥᩅᩩᨲ᩠ᨲᩮ ᨧ ᨠᨾ᩠ᨾᨶᩥ.
ᨧᩥᨲ᩠ᨲᨠᩮ ᩁᩩᨠ᩠ᨡᨽᩮᨴᩮ ᨧ, ᨲᩥᩃᨠᩮᩣ ᨲᩥᩃᨠᩣᩊᨠᩮ;
ᩈᩦᩃᩣᨴᩮᩣ ᨸᨭᩥᨸᨲ᩠ᨲᩥ’ᨲ᩠ᨳᩦ, ᨻᩮᩣᨵᩮ ᨸᨲ᩠ᨲᩥ ᨸᩅᨲ᩠ᨲᩥᩈᩩ.
ᩋᩈᩩᨾ᩠ᩉᩥ [ᩌᨿᩩᨾ᩠ᩉᩥ (ᨭᩦ.), ᪔᪐᪗-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨧ ᨻᩃᩮ ᨸᩣᨱᩮᩣ, ᩈᨲ᩠ᨲᩮ ᩉᨴᨿᨣᩣ’ᨶᩥᩃᩮ;
ᨨᨶ᩠ᨴᩮᩣ ᩅᩈᩮ ᩋᨵᩥᨸ᩠ᨸᩣᨿᩮ, ᩅᩮᨴᩮ’ᨧ᩠ᨨᩣ’ᨶᩩᨭ᩠ᨮᩩᨽᩣᨴᩥᩈᩩ.
ᨠᩣᨾᩮᩣᨥᩣᨴᩮᩣ, ᩈᨾᩪᩉᩈ᩠ᨾᩥᩴ, ᩒᨥᩮᩣᩅᩮᨣᩮ ᨩᩃᩔ ᨧ;
ᨠᨸᩣᩃᩴ ᩈᩥᩁᩈᨭ᩠ᨮᩥᨾ᩠ᩉᩥ, ᨥᨭᩣᨴᩥ ᩈᨠᩃᩮᨸᩥ ᨧ.
ᩅᩮᨱ᩠ᩅᩣᨴᩥᩈᩣᨡᩣᨩᩣᩃᩈ᩠ᨾᩥᩴ, ᩃᨣ᩠ᨣᨠᩮᩈᩮ ᨩᨭᩣ’ᩃᨿᩮ;
ᩈᩁᨱᩴ ᨲᩩ ᩅᨵᩮ ᨣᩮᩉᩮ, ᩁᨠ᩠ᨡᩥᨲᩈ᩠ᨾᩥᨬ᩠ᨧ ᩁᨠ᩠ᨡᨱᩮ.
ᨳᩥᨿᩴ ᨠᨶ᩠ᨲᩣ ᨸᩥᨿᩮ, ᨠᨶ᩠ᨲᩮᩣ, ᨾᨶᩩᨬ᩠ᨬᩮ, ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᨣᩅᨠ᩠ᨡᩮ ᨲᩩ ᩈᨾᩪᩉᩮ ᨧ, ᨩᩣᩃᩴ ᨾᨧ᩠ᨨᩣᨴᩥᨻᨶ᩠ᨵᨶᩮ.
ᨸᩩᨧ᩠ᨨᩣᨿᩴ ᨣᩁᩉᩣᨿᨬ᩠ᨧᩣ, ᨶᩥᨿᨾᩮ ᨠᩥᩴ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩴ;
ᩈᩈᨴ᩠ᨵᩮ ᨲᩦᩈᩩ ᨶᩥᩅᩣᨸᩮ, ᩈᨴ᩠ᨵᩴ, ᩈᨴ᩠ᨵᩣ ᨧ ᨸᨧ᩠ᨧᨿᩮ.
ᨻᩦᨩᩴ ¶ ᩉᩮᨲᩩᨾ᩠ᩉᩥ ᩋᨭ᩠ᨮᩥᩈ᩠ᨾᩥᩴ, ᩋᨦ᩠ᨣᨩᩣᨲᩮ ᨧ ᨴᩥᩔᨲᩥ;
ᨸᩩᨻ᩠ᨻᩮᩣ ᨸᩪᨿᩮ’ᨣ᩠ᨣᨲᩮᩣ [ᩋᨣ᩠ᨣᨲᩮ (ᨭᩦ.)] ᩌᨴᩮᩣ,
ᩈᩮᩣ ᨴᩥᩈᩣᨴᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.
ᨹᩃᨧᩥᨲ᩠ᨲᩮ ᩉᩮᨲᩩᨠᨲᩮ, ᩃᩣᨽᩮ ᨵᨬ᩠ᨬᩣᨴᩥᨠᩮ ᨹᩃᩴ;
ᩌᨣᨾᨶᩮ ᨲᩩ ᨴᩦᨥᩣᨴᩥ, ᨶᩥᨠᩣᨿᩮᩈᩩ ᨧ ᩌᨣᨾᩮᩣ.
ᩈᨶ᩠ᨲᩣᨶᩮᩣ ᨴᩮᩅᩁᩩᨠ᩠ᨡᩮ ᨧ, ᩅᩩᨲ᩠ᨲᩮᩣ ᩈᨶ᩠ᨲᨲᩥᨿᩴ ᨸ᩠ᨿᨳ;
ᩏᨲ᩠ᨲᩁᩅᩥᨸᩁᩦᨲᩮ ᨧ, ᩈᩮᨭ᩠ᨮᩮ ᨧᩣ’ᨶᩩᨲ᩠ᨲᩁᩴ ᨲᩥᩈᩩ.
ᩈᨲ᩠ᨲᩥᩈᨾ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨠᨶ᩠ᨲᩥᨾᨲ᩠ᨲᩮ ᨧ ᩅᩥᨠ᩠ᨠᨾᩮᩣ;
ᨨᩣᨿᩣ ᨲᩩ ᩌᨲᨸᩣᨽᩣᩅᩮ, ᨸᨭᩥᨻᩥᨾ᩠ᨻᩮ ᨸᨽᩣᨿ ᨧ.
ᨣᩥᨾ᩠ᩉᩮ ᨥᨾ᩠ᨾᩮᩣ ᨶᩥᨴᩣᨥᩮᩣ ᨧ, ᩏᨱ᩠ᩉᩮ ᩈᩮᨴᨩᩃᩮ ᨸ᩠ᨿᨳ;
ᨠᨸ᩠ᨸᨶᩴ ᨠᨶ᩠ᨲᨶᩮ ᩅᩩᨲ᩠ᨲᩴ, ᩅᩥᨠᨸ᩠ᨸᩮ ᩈᨩ᩠ᨩᨶᩮ’ᨲ᩠ᨳᩥᨿᩴ.
ᩋᨦ᩠ᨣᩣ ᨴᩮᩈᩮ ᨻᩉᩩᨾ᩠ᩉ’ᨦ᩠ᨣᩴ, ᩋᨦ᩠ᨣᩮᩣ ᨴᩮᩈᩮ ᩅᨸᩩᨾ᩠ᩉ’[ᨦ᩠ᨣ (ᨭᩦ.)] ᨲᨳᩣ’ᩅᨿᩅᩉᩮᨲᩩᩈᩩ;
ᨴᩮᩅᩣᩃᨿᩮ ᨧ ᨳᩪᨸᩈ᩠ᨾᩥᩴ, ᨧᩮᨲᩥᨿᩴ ᨧᩮᨲᩥᨿ’ᨴ᩠ᨴᩩᨾᩮ.
ᩈᨩ᩠ᨩᨶᩮᩣ ᩈᩣᨵᩩᨸᩩᩁᩥᩈᩮ, ᩈᨩ᩠ᨩᨶᩴ ᨠᨸ᩠ᨸᨶᩮ ᨸ᩠ᨿᨳ;
ᩈᩩᨸᩥᨶᩴ ᩈᩩᨸᩥᨶᩮ ᩈᩩᨲ᩠ᨲ, ᩅᩥᨬ᩠ᨬᩣᨱᩮ ᨲ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.
ᨸᨧ᩠ᨧᨠ᩠ᨡᩮ ᩈᨶ᩠ᨶᩥᨵᩣᨶᩮ ᨧ, ᩈᨶ᩠ᨶᩥᨵᩥ ᨸᩁᩥᨠᩥᨲ᩠ᨲᩥᨲᩮᩣ;
ᨽᩥᨿ᩠ᨿᩮᩣ ᨻᩉᩩᨲᩁᨲ᩠ᨳᩮ ᩈᩮᩣ, ᨸᩩᨶᩁᨲ᩠ᨳᩮ’ᨻ᩠ᨿᨿᩴ ᨽᩅᩮ.
ᩅᩥᩈᩃᩥᨲ᩠ᨲᩈᩁᩮ ᨴᩥᨴ᩠ᨵᩮᩣ, ᨴᩥᨴ᩠ᨵᩮᩣ ᩃᩥᨲ᩠ᨲᩮ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᩅᩣᩈᩮ ᨵᩪᨾᩣᨴᩥᩈᨦ᩠ᨡᩣᩁᩮ, ᨵᩥᩅᩣᩈᩮᩣ ᩈᨾ᩠ᨸᨭᩥᨧ᩠ᨨᨶᩮ.
ᩅᩩᨲ᩠ᨲᩮᩣ ᩅᩥᩈᩣᩁᨴᩮᩣ ᨲᩦᩈᩩ, ᩈᩩᨸ᩠ᨸᨣᨻ᩠ᨽᩮ ᨧ ᨸᨱ᩠ᨯᩥᨲᩮ;
ᩋᨳ ᩈᩥᨲ᩠ᨳᩴ ᨾᨵᩩᨧ᩠ᨨᩥᨭ᩠ᨮᩮ, ᩅᩩᨲ᩠ᨲᩴ ᩒᨴᨶᩈᨾ᩠ᨽᩅᩮ.
ᨴᩕᩅᩮ ᩅᨱ᩠ᨱᩮ ᩁᩈᨽᩮᨴᩮ, ᨠᩈᩣᨿᩮᩣ ᩈᩩᩁᨽᩥᨾ᩠ᩉᩥ ᨧ;
ᩋᨳᩮᩣ ᩏᨣ᩠ᨣᨾᨶᩴ ᩅᩩᨲ᩠ᨲᩴ, ᩏᨸ᩠ᨸᨲ᩠ᨲᩩ’ᨴ᩠ᨵᨣᨲᩦᩈᩩ ᨧ.
ᩃᩪᨡᩮ ᨶᩥᨭ᩠ᨮᩩᩁᩅᩣᨧᩣᨿᩴ, ᨹᩁᩩᩈᩴ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩴ;
ᨸᩅᩣᩉᩮᩣ ᨲ᩠ᩅ’ᨾ᩠ᨻᩩᩅᩮᨣᩮ ᨧ, ᩈᨶ᩠ᨴᩥᩔᨲᩥ ᨸᩅᨲ᩠ᨲᩥᨿᩴ.
ᨶᩥᩔᨿᩮ ᨲᨸ᩠ᨸᩁᩮ ᩍᨭ᩠ᨮᩮ, ᨸᩁᩣᨿᨱᨸᨴᩴ ᨲᩥᩈᩩ;
ᨠᩅᨧᩮ ᩅᩣᩁᩅᩣᨱᩮ ᨧ, ᨶᩥᨾ᩠ᨾᩮᩣᨠᩮᨸᩥ ᨧ ᨠᨬ᩠ᨧᩩᨠᩮᩣ.
ᩃᩮᩣᩉᨽᩮᨴᩮ ¶ ᨾᨲᩴ ᨲᨾ᩠ᨻᩴ, ᨲᨾ᩠ᨻᩮᩣ ᩁᨲ᩠ᨲᩮ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᨲᩦᩈᩩ ᨲ᩠ᩅ’ᩅᩈᩥᨲᩴ ᨬᩣᨲᩮ, ᩋᩅᩈᩣᨶᨣᨲᩮ ᨾᨲᩴ.
ᨻᩮᩣᨵᨶᩮ ᨧ ᨸᨴᩣᨶᩮ ᨧ, ᩅᩥᨬ᩠ᨬᩮᨿ᩠ᨿᩴ ᨸᨭᩥᨸᩣᨴᨶᩴ;
ᩈᩮᩃᩮ ᨶᩥᨩ᩠ᨩᩃᨴᩮᩈᩮ ᨧ, ᨴᩮᩅᨲᩣᩈᩩ ᨾᩁᩪ’ᩁᩥᨲᩮᩣ.
ᩈᨲ᩠ᨳᩴ ᩌᨿᩩᨵ ᨣᨶ᩠ᨳᩮᩈᩩ, ᩃᩮᩣᩉᩮ, ᩈᨲ᩠ᨳᩮᩣ ᨧ ᩈᨬ᩠ᨧᨿᩮ;
ᨩᩦᩅᩥᨠᩣᨿᩴ ᩅᩥᩅᩁᨱᩮ, ᩅᨲ᩠ᨲᨶᩮ ᩅᩩᨲ᩠ᨲᩥ ᨶᩣᩁᩥᨿᩴ.
ᩅᩦᩁᩥᨿᩮ ᩈᩪᩁᨽᩣᩅᩮ ᨧ, ᨠᨳᩦᨿᨲᩥ ᨸᩁᨠ᩠ᨠᨾᩮᩣ;
ᩋᨳ ᨠᨾ᩠ᨻᩩ ᨾᨲᩮᩣ ᩈᨦ᩠ᨡᩮ, ᩈᩩᩅᨱ᩠ᨱᩮ ᩅᩃᨿᩮᨸᩥ ᨧ.
ᩈᩁᩮᩣ ᨠᨱ᩠ᨯᩮ ᩋᨠᩣᩁᩣᨴᩮᩣ, ᩈᨴ᩠ᨴᩮ ᩅᩣᨸᩥᨾ᩠ᩉᩥ’ᨶᩥᨲ᩠ᨳᩥᨿᩴ;
ᨴᩩᨸ᩠ᨹᩔᩮ ᨲᩥᨡᩥᨱᩮ ᨲᩦᩈᩩ, ᨣᨴᩕᨽᩮ ᨠᨠᨧᩮ ᨡᩁᩮᩣ.
ᩈᩩᩁᩣᨿᩩ’ᨸᨴ᩠ᨴᩅᩮ ᨠᩣᨾᩣ, ᩈᩅᩣᨴᩥᨾ᩠ᩉᩥ ᨧ ᩌᩈᩅᩮᩣ;
ᨴᩮᩉᩮ ᩅᩩᨲ᩠ᨲᩮᩣ ᩁᨳᨦ᩠ᨣᩮ ᨧ, ᨧᨲᩩᩁᩮᩣ’ᨸᨵᩥᩈᩪ’ᨸᨵᩥ.
ᩅᨲ᩠ᨳᩩ’ᨲ᩠ᨲᩴ ᨠᩣᩁᨱᩮ ᨴᨻ᩠ᨻᩮ, ᨽᩪᨽᩮᨴᩮ ᩁᨲᨶᨲ᩠ᨲᨿᩮ;
ᨿᨠ᩠ᨡᩮᩣ ᨴᩮᩅᩮ ᨾᩉᩣᩁᩣᨩᩮ, ᨠᩩᩅᩮᩁᩣ’ᨶᩩᨧᩁᩮ ᨶᩁᩮ.
ᨴᩣᩁᩩᨠ᩠ᨡᨶ᩠ᨵᩮ ᨸᩦᨮᩥᨠᩣᨿᩴ, ᩌᨸᨱᩮ ᨸᩦᨮ ᨾᩣᩈᨶᩮ;
ᨸᩁᩥᩅᩣᩁᩮ ᨸᩁᩥᨠ᩠ᨡᩣᩁᩮᩣ, ᩈᨾ᩠ᨽᩣᩁᩮ ᨧ ᩅᩥᨽᩪᩈᨶᩮ.
ᩅᩮᩣᩉᩣᩁᩈ᩠ᨾᩥᨬ᩠ᨧ ᨮᨸᨶᩮ, ᨸᨬ᩠ᨬᨲ᩠ᨲᩥ’ᨲ᩠ᨳᩦ ᨸᨠᩣᩈᨶᩮ;
ᨸᨭᩥᨽᩣᨶᩴ ᨲᩩ ᨸᨬ᩠ᨬᩣᨿᩴ, ᩏᨸᨭ᩠ᨮᩥᨲ ᨣᩥᩁᩣᨿ ᨧ.
ᩅᨧᨶᩣᩅᨿᩅᩮ ᨾᩪᩃᩮ, ᨠᨳᩥᨲᩮᩣ ᩉᩮᨲᩩ ᨠᩣᩁᨱᩮ;
ᩏᨴᩁᩮ ᨲᩩ ᨲᨳᩣ ᨸᩣᨧᩣ, ᨶᩃᩈ᩠ᨾᩥᩴ ᨣᩉᨱᩦ’ᨲ᩠ᨳᩥᨿᩴ.
ᨸᩥᨿᩮᩣ ᨽᨲ᩠ᨲᩁᩥ, ᨩᩣᨿᩣᨿᩴ, ᨸᩥᨿᩣ, ᩍᨭ᩠ᨮᩮ ᨸᩥᨿᩮᩣ ᨲᩥᩈᩩ;
ᨿᨾᩁᩣᨩᩮ ᨲᩩ ᨿᩩᨣᩊᩮ, ᩈᩴᨿᨾᩮ ᨧ ᨿᨾᩮᩣ ᨽᩅᩮ.
ᨾᩩᨴ᩠ᨴᩥᨠᩔ ᨧ ᨸᩩᨸ᩠ᨹᩔ, ᩁᩈᩮ ᨡᩩᨴ᩠ᨴᩮ ᨾᨵᩪ’ᩁᩥᨲᩴ;
ᩏᩃ᩠ᩃᩮᩣᨧᩮ ᨲᩩ ᨧ ᩅᩥᨲ᩠ᨳᩣᩁᩮ, ᩅᩥᨲᩣᨶᩴ ᨸᩩᨶ᩠ᨶᨸᩩᩴᩈᨠᩮ.
ᩋᨸᩅᨣ᩠ᨣᩮ ᨧ ᩈᩃᩥᩃᩮ, ᩈᩩᨵᩣᨿᩴ ᩋᨾᨲᩴ ᨾᨲᩴ;
ᨾᩮᩣᩉᩮ ᨲᩩ ᨲᩥᨾᩥᩁᩮ ᩈᨦ᩠ᨡ᩠ᨿᩣ, ᨣᩩᨱᩮ ᨲᨾ ᨾᨶᩥᨲ᩠ᨳᩥᨿᩴ.
ᨡᩁᩮ ᨧᩣ’ᨠᩣᩁᩥᨿᩮ ᨲᩦᩈᩩ, ᩁᩈᨾ᩠ᩉᩥ ᨸᩩᩁᩥᩈᩮ ᨠᨭᩩ;
ᨸᨱ᩠ᨯᨠᩮ ᩈᩩᨠᨲᩮ, ᨸᩩᨬ᩠ᨬᩴ, ᨾᨶᩩᨬ᩠ᨬᩮ ᨸᩅᨶᩮ ᨲᩥᩈᩩ.
ᩁᩩᨠ᩠ᨡᩮᩣ ᨴᩩᨾᨾ᩠ᩉᩥ, ᨹᩁᩩᩈᩣ, ᩈᩥᨶᩥᨴ᩠ᨵᩮᩈᩩ ᨧ ᩈᩮᩣ ᨲᩥᩈᩩ;
ᩏᨸ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᨲᩩ ᩉᩮᨲᩩᨾ᩠ᩉᩥ, ᩈᨦ᩠ᨣᩮ ᩈᩩᨠ᩠ᨠᩮ ᨧ ᩈᨾ᩠ᨽᩅᩮᩣ.
ᨶᩥᨾᩥᨲ᩠ᨲᩴ ¶ ᨠᩣᩁᨱᩮ ᩅᩩᨲ᩠ᨲᩴ, ᩋᨦ᩠ᨣᨩᩣᨲᩮ ᨧ ᩃᨬ᩠ᨨᨶᩮ;
ᩌᨴᩥ ᩈᩦᨾᩣᨸᨠᩣᩁᩮᩈᩩ, ᩈᨾᩦᨸᩮ’ᩅᨿᩅᩮ ᨾᨲᩮᩣ.
ᩅᩮᨴᩮ ᨧ ᨾᨶ᩠ᨲᨶᩮ ᨾᨶ᩠ᨲᩮᩣ, ᨾᨶ᩠ᨲᩣ ᨸᨬ᩠ᨬᩣᨿ ᨾᩩᨧ᩠ᨧᨲᩮ;
ᩋᨶᨿᩮᩣ ᨻ᩠ᨿᩈᨶᩮ ᨧᩮᩅ, ᩈᨶ᩠ᨴᩥᩔᨲᩥ ᩅᩥᨸᨲ᩠ᨲᩥᨿᩴ.
ᩋᩁᩩᨱᩮᩣ ᩁᩴᩈᩥᨽᩮᨴᩮ ᨧᩣ, ᨻ᩠ᨿᨲ᩠ᨲᩁᩣᨣᩮ ᨧ ᩃᩮᩣᩉᩥᨲᩮ;
ᩋᨶᩩᨻᨶ᩠ᨵᩮᩣ ᨲᩩ ᨸᨠᨲᩣ, ᨶᩥᩅᨲ᩠ᨲᩮ ᨶᩔᨶᨠ᩠ᨡᩁᩮ.
ᩋᩅᨲᩣᩁᩮᩣ’ᩅᨲᩁᨱᩮ, ᨲᩥᨲ᩠ᨳᨾ᩠ᩉᩥ ᩅᩥᩅᩁᩮ ᨸ᩠ᨿᨳ;
ᩌᨠᩣᩁᩮᩣ ᨠᩣᩁᨱᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᩈᨱ᩠ᨮᩣᨶᩮ ᩍᨦ᩠ᨣᩥᨲᩮᨸᩥ ᨧ.
ᩈᩩᨴ᩠ᨴᩥᨲ᩠ᨳᩥ ᨲᨶᨿᩮ ᨡᨲ᩠ᨲᩣ, ᩏᨣ᩠ᨣᩮᩣ, ᨲᩥᨻ᩠ᨻᨾ᩠ᩉᩥ ᩈᩮᩣ ᨲᩥᩈᩩ;
ᨸᨵᩣᨶᩴ ᨲᩩ ᨾᩉᩣᨾᨲ᩠ᨲᩮ, ᨸᨠᨲ᩠ᨿ’ᨣ᩠ᨣ’ᨵᩥᨲᩦᩈᩩ ᨧ.
ᨠᩃ᩠ᩃᩴ ᨸᨽᩣᨲᩮ, ᨶᩥᩁᩮᩣᨣ, ᩈᨩ᩠ᨩᨴᨠ᩠ᨡᩮᩈᩩ [ᨿᩩᨲ᩠ᨲᨴᨠ᩠ᨡᩮᩈᩩ (ᨠ.)] ᨲᩦᩈᩩ ᨲᩴ;
ᨠᩩᩉᨶᩣ ᨠᩪᨭᨧᩁᩥᨿᩣᨿᩴ, ᨠᩩᩉᨶᩮᩣ ᨠᩩᩉᨠᩮ ᨲᩥᩈᩩ.
ᨠᨸᩮᩣᨲᩮᩣ ᨸᨠ᩠ᨡᩥᨽᩮᨴᩮ ᨧ, ᨴᩥᨭ᩠ᨮᩮᩣ ᨸᩣᩁᩣᩅᨲᩮ ᨳ ᨧ;
ᩈᩣᩁᨴᩮᩣ ᩈᩣᩁᨴᨻ᩠ᨽᩪᨲᩮ, ᩋᨸᨣᨻ᩠ᨽᩮ ᨾᨲᩮᩣ ᨲᩥᩈᩩ.
ᨲᩦᩈᩩ ᨡᩁᩮ ᨧ ᨠᨮᩥᨶᩮ, ᨠᨠ᩠ᨠᩈᩮᩣ ᩈᩣᩉᩈᨸ᩠ᨸᩥᨿᩮ [ᩈᩣᩉᩈᨸ᩠ᨸᩥᨿᩮ=ᩈᩣᩉᩈ+ᩋᨸ᩠ᨸᩥᨿᩮ (ᨭᩦ.)];
ᩋᨠᩣᩁᩥᨿᩮ ᨲᩩ ᨣᩩᨿ᩠ᩉᨦ᩠ᨣᩮ, ᨧᩦᩁᩮ ᨠᩮᩣᨸᩦᨶ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᨾᩥᨣᨽᩮᨴᩮ ᨸᨭᩣᨠᩣᨿᩴ, ᨾᩮᩣᨧᩮ ᨧ ᨠᨴᩃᩦ’ᨲ᩠ᨳᩥᨿᩴ;
ᨴᨠ᩠ᨡᩥᨱᩣ ᨴᩣᨶᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᩅᩣᨾᨲᩮᩣ’ᨬ᩠ᨬᨾ᩠ᩉᩥ ᨴᨠ᩠ᨡᩥᨱᩮᩣ.
ᨴᩩᨲᩥᨿᩣ ᨽᩁᩥᨿᩣᨿᨬ᩠ᨧ, ᨴ᩠ᩅᩥᨶ᩠ᨶᩴ ᨸᩪᩁᨱᩥᨿᩴ ᨾᨲᩣ;
ᩋᨳᩩᨸ᩠ᨸᩣᨴᩮ ᩈᩥᨿᩣ ᨵᩪᨾ, ᨠᩮᨲᩩ ᩅᩮᩔᩣᨶᩁᩮᨸᩥ ᨧ.
ᨽᩅᨶᩥᨣ᩠ᨣᨾᨶᩮ ᨿᩣᨶᩮ, ᨴ᩠ᩅᩣᩁᩮ ᨶᩥᩔᩁᨱᩴ ᩈᩥᨿᩣ;
ᨶᩥᨿᩣᨾᨠᩮᩣ ᨸᩮᩣᨲᩅᩣᩉᩮ, ᨲᩥᩃᩥᨦ᩠ᨣᩮᩣ ᩈᩮᩣ ᨶᩥᨿᨶ᩠ᨲᩁᩥ.
ᩋᨸᩅᨣ᩠ᨣᩮ ᩅᩥᨶᩣᩈᩮ ᨧ, ᨶᩥᩁᩮᩣᨵᩮᩣ ᩁᩮᩣᨵᨶᩮ ᨸ᩠ᨿᨳ;
ᨽᨿᩮ ᨸᨭᩥᨽᨿᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨲᩥᩃᩥᨦ᩠ᨣᩴ ᨲᩴ ᨽᨿᩴᨠᩁᩮ.
ᨸᩥᨭᨠᩴ ᨽᩣᨩᨶᩮ ᩅᩩᨲ᩠ᨲᩴ, ᨲᨳᩮᩅ ᨸᩁᩥᨿᨲ᩠ᨲᩥᨿᩴ;
ᨩᩁᩣᩈᩥᨳᩥᩃᨧᨾ᩠ᨾᩈ᩠ᨾᩥᩴ, ᩏᨴᩁᨦ᩠ᨣᩮ ᨾᨲᩣ ᩅᩃᩥ.
ᨽᩥᨶ᩠ᨶᩴ ᩅᩥᨴᩣᩁᩥᨲᩮ’ᨬ᩠ᨬᩈ᩠ᨾᩥᩴ, ᨶᩥᩔᩥᨲᩮ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩴ;
ᩏᨸᨩᩣᨸᩮ ᨾᨲᩮᩣ ᨽᩮᨴᩮᩣ, ᩅᩥᩈᩮᩈᩮ ᨧ ᩅᩥᨴᩣᩁᨱᩮ.
ᨾᨱ᩠ᨯᩃᩴ ¶ ᨣᩣᨾᩈᨶ᩠ᨴᩮᩣᩉᩮ, ᨻᩥᨾ᩠ᨻᩮ ᨸᩁᩥᨵᩥᩁᩣᩈᩥᩈᩩ;
ᩌᨱᩣᨿ ᨾᩣᨣᨾᩮ ᩃᩮᨡᩮ; ᩈᩣᩈᨶᩴ ᩋᨶᩩᩈᩣᩈᨶᩮ.
ᩋᨣ᩠ᨣᩮ ᨲᩩ ᩈᩥᨡᩁᩴ ᨧᩣ’ᨿᩮᩣ, ᨾᨿᩅᩥᨩ᩠ᨫᨶᨠᨱ᩠ᨭᨠᩮ;
ᨣᩩᨱᩩᨠ᩠ᨠᩴᩈᩮ ᨧ ᩅᩥᨽᩅᩮ, ᩈᨾ᩠ᨸᨲ᩠ᨲᩥ ᨧᩮᩅ ᩈᨾ᩠ᨸᨴᩣ.
ᨽᩪᨡᨶ᩠ᨲᩦᩈᩩ ᨡᨾᩣ, ᨿᩮᩣᨣ᩠ᨿᩮ, ᩉᩥᨲᩮ ᩈᨠ᩠ᨠᩮ [ᨿᩩᨲ᩠ᨲᩮ (ᨭᩦ.) ᪑᪐᪐᪑-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨡᨾᩮᩣ ᨲᩥᩈᩩ;
ᩋᨴ᩠ᨵᩮᩣ ᨽᩣᨣᩮ ᨸᨳᩮ ᨠᩣᩃᩮ, ᩑᨠᩴᩈᩮ’ᨴ᩠ᨵᩮᩣ’ᨻ᩠ᨿᨿᩴ ᨽᩅᩮ;
ᩋᨳᩮᩣ ᨠᩁᩦᩈᩴ ᩅᨧ᩠ᨧᩈ᩠ᨾᩥᩴ, ᩅᩩᨧ᩠ᨧᨲᩮ ᨧᨲᩩᩁᨾ᩠ᨻᨱᩮ.
ᩏᩈᨽᩮᩣ’ᩈᨵ ᨣᩮᩣ [ᩏᩈᨽᩮᩣ ᩏᩈᨽᩮ (ᨭᩦ.)] ᩈᩮᨭ᩠ᨮᩮ, ᩈᩪ’ᩈᨽᩴ ᩅᩦᩈᨿᨭ᩠ᨮᩥᨿᩴ;
ᩈᩮᨲᩩᩈ᩠ᨾᩥᩴ ᨲᨶ᩠ᨲᩥ ᨸᨶ᩠ᨲᩦᩈᩩ, ᨶᩣᩁᩥᨿᩴ ᨸᩣᩊᩥ ᨠᨳ᩠ᨿᨲᩮ.
ᨠᨭᩮᩣ ᨩᨿᩮ’ᨲ᩠ᨳᩥᨶᩥᨾᩥᨲ᩠ᨲᩮ, ᨠᩥᩃᨬ᩠ᨩᩮ ᩈᩮᩣ ᨠᨲᩮ ᨲᩥᩈᩩ;
ᨾᩉᩥᨿᩴ ᨩᨣᨲᩦ ᩅᩩᨲ᩠ᨲᩣ, ᨾᨶ᩠ᨴᩥᩁᩣᩃᩥᨶ᩠ᨴᩅᨲ᩠ᨳᩩᨾ᩠ᩉᩥ.
ᩅᩥᨲᨠ᩠ᨠᩮ ᨾᨳᩥᨲᩮ ᨲᨠ᩠ᨠᩮᩣ, ᨲᨳᩣ ᩈᩪᨧᩥᨹᩃᩮ ᨾᨲᩮᩣ;
ᩈᩩᨴᩔᨶᩴ ᩈᨠ᩠ᨠᨸᩩᩁᩮ, ᨲᩦᩈᩩ ᨲᩴ ᨴᩩᨴ᩠ᨴᩈᩮ’ᨲᩁᩮ.
ᨴᩦᨸᩮᩣ’ᨶ᩠ᨲᩁᩦᨸ ᨸᨩ᩠ᨩᩮᩣᨲ, ᨸᨲᩥᨭ᩠ᨮᩣ ᨶᩥᨻ᩠ᨻᩩᨲᩦᩈᩩ ᨧ;
ᨻᨴ᩠ᨵᨶᩥᩔᩥᨲ ᩈᩮᨲᩮᩈᩩ, ᨲᩦᩈᩩ ᨲᩴ ᨾᩥᩉᩥᨲᩮ ᩈᩥᨲᩴ.
ᨳᩥᨿᩴ ᨸᨩᩣᨸᨲᩥ ᨴᩣᩁᩮ, ᨻᩕᩉ᩠ᨾᩮ ᨾᩣᩁᩮ ᩈᩩᩁᩮ ᨸᩩᨾᩮ;
ᩅᩣᩈᩩᨴᩮᩅᩮ’ᨶ᩠ᨲᨠᩮ ᨠᨱ᩠ᩉᩮᩣ, ᩈᩮᩣ ᨸᩣᨸᩮ ᩋᩈᩥᨲᩮ ᨲᩥᩈᩩ.
ᩏᨸᨧᩣᩁᩮᩣ ᩏᨸᨭ᩠ᨮᩣᨶᩮ, ᩌᩈᨶ᩠ᨶᩮ ᩋᨬ᩠ᨬᩁᩮᩣᨸᨶᩮ;
ᩈᨠ᩠ᨠᩮᩣ ᩍᨶ᩠ᨴᩮ ᨩᨶᨸᨴᩮ, ᩈᩣᨠᩥᨿᩮ, ᩈᩮᩣ ᨡᨾᩮ ᨲᩥᩈᩩ.
ᩅᨩ᩠ᨩᨶᩮ ᨸᩁᩥᩉᩣᩁᩮᩣ ᨧ, ᩈᨠ᩠ᨠᩣᩁᩮ ᨧᩮᩅ ᩁᨠ᩠ᨡᨱᩮ;
ᩈᩮᩣᨲᩣᨸᨶ᩠ᨶᩣᨴᩥᨠᩮ ᩋᨣ᩠ᨣᩮ, ᩋᩁᩥᨿᩮᩣ ᨲᩦᩈᩩ, ᨴ᩠ᩅᩥᨩᩮ ᨸᩩᨾᩮ.
ᩈᩩᩈᩩᨠᩮᩣ ᩈᩩᩈᩩᨾᩣᩁᩮ ᨧ, ᨻᩣᩃᨠᩮ ᨧ ᩏᩃᩪᨸᩥᨶᩥ;
ᩍᨶ᩠ᨴᩦᩅᩁᩴ ᨾᨲᩴ ᨶᩦᩃᩩ, ᨸ᩠ᨸᩃᩮ ᩏᨴ᩠ᨴᩣᩃᨸᩣᨴᨸᩮ.
ᩋᩈᨶᩮᩣ ᨸᩥᨿᨠᩮ ᨠᨱ᩠ᨯᩮ, ᨽᨠ᩠ᨡᨱᩮ ᨡᩥᨸᨶᩮ’ ᩈᨶᩴ;
ᨿᩩᨣᩮ’ᨵᩥᨠᩣᩁᩮ [ᩅᩥᨠᩣᩁᩮ (ᨭᩦ.)] ᩅᩦᩁᩥᨿᩮ, ᨸᨵᩣᨶᩮ ᨧᩣ’ᨶ᩠ᨲᩥᨠᩮ ᨵᩩᩁᩮᩣ.
ᨠᩣᩊᩮ ᨧ ᨽᨠ᩠ᨡᩥᨲᩮ ᨲᩦᩈᩩ, ᩃᩅᩥᨲ᩠ᨲᩮ ᩋᩈᩥᨲᩮᩣ ᨸᩩᨾᩮ;
ᨸᩅᩣᩁᨱᩣ ᨸᨭᩥᨠ᩠ᨡᩮᨸᩮ, ᨠᨳᩥᨲᩣ’ᨩ᩠ᨫᩮᩈᨶᩣᨿ ᨧ.
ᩏᨾ᩠ᨾᩣᩁᩮ ¶ ᩑᩈᩥᨠᨲ᩠ᨳᨾ᩠ᨽᩮ, ᩍᨶ᩠ᨴᨡᩦᩃᩮᩣ ᨾᨲᩮᩣ ᨳ ᨧ;
ᨸᩮᩣᨲ᩠ᨳᨠᩴ ᨾᨠᨧᩥᩅᨲ᩠ᨳᩮ, ᨣᨶ᩠ᨳᩮ ᩃᩮᨸ᩠ᨿᩣᨴᩥ ᨠᨾ᩠ᨾᨶᩥ.
ᨵᨬ᩠ᨬᩴ ᩈᩣᩃ᩠ᨿᩣᨴᩥᨠᩮ ᩅᩩᨲ᩠ᨲᩴ, ᨵᨬ᩠ᨬᩮᩣ ᨸᩩᨬ᩠ᨬᩅᨲᩥ ᨲ᩠ᨲᩥᩈᩩ;
ᨸᩣᨱᩥ ᩉᨲ᩠ᨳᩮ ᨧ ᩈᨲ᩠ᨲᩮ ᨽᩪ, ᩈᨱ᩠ᩉᨠᩁᨱᩥᨿᩴ ᨾᨲᩮᩣ.
ᨲᩦᩈᩩ ᨸᩦᨲᩴ ᩉᩃᩥᨴ᩠ᨿᩣᨽᩮ, ᩉᨭ᩠ᨮᩮ ᨧ ᨸᩣᨿᩥᨲᩮ ᩈᩥᨿᩣ;
ᨻ᩠ᨿᩪᩉᩮᩣ ᨶᩥᨻ᩠ᨻᩥᨴ᩠ᨵᩁᨧ᩠ᨨᩣᨿᩴ, ᨻᩃᨶ᩠ᨿᩣᩈᩮ ᨣᨱᩮ ᨾᨲᩮᩣ.
ᩃᩮᩣᩉᩥᨲᩣᨴᩥᨾ᩠ᩉᩥ ᩃᩮᩣᨽᩮ ᨧ, ᩁᩣᨣᩮᩣ ᨧ ᩁᨬ᩠ᨩᨶᩮ ᨾᨲᩮᩣ;
ᨸᨴᩁᩮᩣ ᨹᩃᨠᩮ ᨽᨦ᩠ᨣᩮ, ᨸᩅᩩᨴ᩠ᨵ ᨴᩁᩥᨿᩴ ᨸᩥᨧ.
ᩈᩥᨦ᩠ᨥᩣᨭᨠᩴ ᨠᩈᩮᩁᩩᩔ, ᨹᩃᩮ, ᨾᨣ᩠ᨣᩈᨾᩣᨣᨾᩮ;
ᨻᩉᩩᩃᩣᨿᨬ᩠ᨧ ᨡᩮᩊᨾ᩠ᩉᩥ, ᩑᩊᩣ, ᨴᩮᩣᩈᩮ’ᩊ ᨾᩦᩁᩥᨲᩴ.
ᩌᨵᩣᩁᩮᩣ ᨧᩣ’ᨵᩥᨠᩁᨱᩮ, ᨸᨲ᩠ᨲᩣᨵᩣᩁᩮ’ ᩃᩅᩣᩃᨠᩮ;
ᨠᩣᩁᩮᩣ’ ᨣᨽᩮᨴᩮ ᩈᨠ᩠ᨠᩣᩁᩮ, ᨠᩣᩁᩣ ᨲᩩ ᨻᨶ᩠ᨵᨶᩣᩃᨿᩮ.
ᨠᩁᨠᩣ ᨾᩮᨥᨸᩣᩈᩣᨱᩮ, ᨠᩁᨠᩮᩣ ᨠᩩᨱ᩠ᨯᩥᨠᩣᨿ ᨧ;
ᨸᩣᨸᨶᩮ ᨧ ᨸᨴᩣᨲᩥᩈ᩠ᨾᩥᩴ, ᨣᨾᨶᩮ ᨸᨲ᩠ᨲᩥ ᨶᩣᩁᩥᨿᩴ.
ᨨᩥᨴ᩠ᨴᩴ ᩁᨶ᩠ᨵᨬ᩠ᨧ ᩅᩥᩅᩁᩴ, ᩈᩩᩈᩥᩁᩮ ᨴᩪᩈᨶᩮᨸᩥ ᨧ;
ᨾᩩᨲ᩠ᨲᩣ ᨲᩩ ᨾᩩᨲ᩠ᨲᩥᨠᩮ, ᨾᩩᨲ᩠ᨲᩴ, ᨸᩔᩣᩅᩮ, ᨾᩩᨧ᩠ᨧᩥᨲᩮ ᨲᩥᩈᩩ.
ᨶᩥᩈᩮᨵᩮ ᩅᩣᩁᨱᩴ, ᩉᨲ᩠ᨳᩥ, ᩃᩥᨦ᩠ᨣ ᩉᨲ᩠ᨳᩦᩈᩩ ᩅᩣᩁᨱᩮᩣ;
ᨴᩣᨶᩴ ᨧᩣᨣᩮ ᨾᨴᩮ ᩈᩩᨴ᩠ᨵᩮ, ᨡᨱ᩠ᨯᨶᩮ ᩃᩅᨶᩮ ᨡᨿᩮ.
ᨾᨶᩮᩣᨲᩮᩣᩈᩮ ᨧ ᨶᩥᨻ᩠ᨻᩣᨶᩮ, ᨲ᩠ᨳᨦ᩠ᨣᨾᩮ ᨶᩥᨻ᩠ᨻᩩᨲᩥ’ᨲ᩠ᨳᩥᨿᩴ;
ᨶᩮᨣᨾᩮᩣ ᨶᩥᨣᨾᩩᨻ᩠ᨽᩪᨲᩮ, ᨲᨳᩣ’ᨸᨱᩮᩣᨸᨩᩦᩅᩥᨶᩥ.
ᩉᩁᩥᨲᩈ᩠ᨾᩥᨬ᩠ᨧ ᨸᨱ᩠ᨱᩮ ᨧ, ᨸᩃᩣᩈᩮᩣ ᨠᩥᩴ ᩈᩩᨠᨴ᩠ᨴᩩᨾᩮ;
ᨸᨠᩣᩈᩮᩣ ᨸᩣᨠᨭᩮᨲᩦᩈᩩ, ᩌᩃᩮᩣᨠᩈ᩠ᨾᩥᩴ ᨸᩩᨾᩮ ᨾᨲᩮᩣ.
ᨸᨠ᩠ᨠᩴ ᨹᩃᨾ᩠ᩉᩥ, ᨲᩴ ᨶᩣᩈᩩ, ᨾ᩠ᨾᩩᨡᩮ [ᨶᩣᩈᨾᩩᨡᩮ (ᨠ.)] ᨸᩁᩥᨱᨲᩮ ᨲᩥᩈᩩ;
ᨸᩥᨱ᩠ᨯᩮᩣ ᩌᨩᩦᩅᨶᩮ ᨴᩮᩉᩮ, ᨸᩥᨱ᩠ᨯᨶᩮ ᨣᩮᩣᩊᨠᩮ ᨾᨲᩮᩣ.
ᩅᨭ᩠ᨭᩮᩣ ᨸᩁᩥᨻ᩠ᨻᨿᩮ ᨠᨾ᩠ᨾᩣ, ᨴᩥᨠᩮ, ᩈᩮᩣ ᩅᨭ᩠ᨭᩩᩃᩮ ᨲᩥᩈᩩ;
ᨸᨧ᩠ᨧᩣᩉᩣᩁᩮ ᨸᨭᩥᩉᩣᩁᩮᩣ, ᨴ᩠ᩅᩣᩁᩮ ᨧ ᨴ᩠ᩅᩣᩁᨸᩣᩃᨠᩮ.
ᨶᩣᩁᩥᨿᩴ ᨽᩦᩁᩩ ᨠᨳᩥᨲᩣ, ᨽᩦᩁᩩᨠᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᩅᩥᨠᨭᩴ ᨣᩪᨳᨾᩩᨲ᩠ᨲᩣᨴᩮᩣ, ᩅᩥᨠᨭᩮᩣ ᩅᩥᨠᨲᩮ ᨲᩥᩈᩩ.
ᩅᩣᨾᩴ ¶ ᩈᨻ᩠ᨿᨾ᩠ᩉᩥ, ᨲᩴ ᨧᩣᩁᩩ, ᩅᩥᨸᩁᩦᨲᩮᩈᩩ ᨲᩦᩈ᩠ᩅ’ᨳ;
ᩈᨦ᩠ᨡ᩠ᨿᩣᨽᩮᨴᩮ ᩈᩁᨻ᩠ᨿᩮ ᨧ, ᨧᩥᩉᨱᩮ ᩃᨠ᩠ᨡ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᩈᩮᨱᩦ’ᨲ᩠ᨳᩦ ᩈᨾᩈᩥᨸ᩠ᨸᩦᨶᩴ, ᨣᨱᩮ ᨧᩣ’ᩅᩃᩥᨿᩴ ᨸᩥᨧ;
ᩈᩩᨵᩣᨿᩴ ᨵᩪᩃᩥᨿᩴ ᨧᩩᨱ᩠ᨱᩮᩣ, ᨧᩩᨱ᩠ᨱᨬ᩠ᨧ ᩅᩣᩈᨧᩩᨱ᩠ᨱᨠᩮ.
ᨩᩮᨲᨻ᩠ᨻᩮ’ᨲᩥᨸ᩠ᨸᩈᨲ᩠ᨳᩮ’ᨲᩥ, ᩅᩩᨴ᩠ᨵᩮ ᨩᩮᨿ᩠ᨿᩴ ᨲᩥᩈᩪ’ᩁᩥᨲᩴ;
ᨲᨠ᩠ᨠᩮ ᨲᩩ ᨾᨳᩥᨲᩴ ᩉᩮᩣᨲ᩠ᨿᩣ,
ᩃᩮᩣᩃᩥᨲᩮ ᨾᨳᩥᨲᩮᩣ ᨲᩥᩈᩩ.
ᩋᨻ᩠ᨽᩩᨲᩮᩣ’ᨧ᩠ᨨᩁᩥᨿᩮ ᨲᩦᩈᩩ, ᨸᨱᩮ ᨧᩮᩅᩣ’ᨻ᩠ᨽᩩᨲᩮᩣ ᨸᩩᨾᩮ;
ᨾᩮᨧᨠᩮᩣ ᨸᩩᨧ᩠ᨨᨾᩪᩃᨾ᩠ᩉᩥ, ᨠᨱ᩠ᩉᩮᨸᩥ ᨾᩮᨧᨠᩮᩣ ᨲᩥᩈᩩ.
ᩅᩈᩅᨲ᩠ᨲᩦ ᨸᩩᨾᩮ ᨾᩣᩁᩮ, ᩅᩈᩅᨲ᩠ᨲᩣᨸᨠᩮ ᨲᩥᩈᩩ;
ᩈᨾ᩠ᨽᩅᩮ ᨧᩣ’ᩈᩩᨧᩥ ᨸᩩᨾᩮ, ᩋᨾᩮᨩ᩠ᨫᩮ ᨲᩦᩈᩩ ᨴᩥᩔᨲᩥ.
ᩋᨧ᩠ᨨᩮᩣ ᩍᨠ᩠ᨠᩮ ᨸᩩᨾᩮ ᩅᩩᨲ᩠ᨲᩮᩣ, ᨸᩈᨶ᩠ᨶᨾ᩠ᩉᩥ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᨻᩊᩥᩈᩮ ᩈᩮᩃᨽᩮᨴᩮ ᨧ, ᩅᨦ᩠ᨠᩮᩣ, ᩈᩮᩣ ᨠᩩᨭᩥᩃᩮ ᨲᩥᩈᩩ.
ᨠᩩᨱᨸᨾ᩠ᩉᩥ ᨨᩅᩮᩣ ᨬᩮᨿ᩠ᨿᩮᩣ,
ᩃᩣᨾᨠᩮ ᩈᩮᩣ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᩈᨻ᩠ᨻᩈ᩠ᨾᩥᩴ ᩈᨠᩃᩮᩣ ᨲᩦᩈᩩ, ᩋᨴ᩠ᨵᨾ᩠ᩉᩥ ᨸᩩᩁᩥᩈᩮ ᩈᩥᨿᩣ.
ᨧᨶ᩠ᨴᨣ᩠ᨣᩣᩉᩣᨴᩥᨠᩮ ᨧᩮᩅᩩ, ᨸ᩠ᨸᩣᨴᩮᩣ ᩏᨸ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᨸᩥᨧ;
ᨸᨴᩩᩔᨶᩮ ᨸᨴᩮᩣᩈᩮᩣ ᨧ, ᨠᨳᩥᨲᩮᩣ ᩈᩴᩅᩁᩦᨾᩩᨡᩮ.
ᩁᩩᨵᩥᩁᩮ ᩃᩮᩣᩉᩥᨲᩴ ᩅᩩᨲ᩠ᨲᩴ, ᩁᨲ᩠ᨲᨾ᩠ᩉᩥ ᩃᩮᩣᩉᩥᨲᩮᩣ ᨲᩥᩈᩩ;
ᩏᨲ᩠ᨲᨾᨦ᩠ᨣᩮ ᨸᩩᨾᩮ ᨾᩩᨴ᩠ᨵᩣ, ᨾᩩᨴ᩠ᨵᩮᩣ ᨾᩪᩊ᩠ᩉᩮ ᨲᩥᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.
ᩁᨭ᩠ᨮᨾ᩠ᩉᩥ ᩅᩥᨩᩥᨲᩴ ᩅᩩᨲ᩠ᨲᩴ, ᨩᩥᨲᩮ ᨧ ᩅᩥᨩᩥᨲᩮᩣ ᨲᩥᩈᩩ;
ᨸᩁᩥᨲ᩠ᨲᩴ ᨲᩩ ᨸᩁᩥᨲ᩠ᨲᩣᨱᩮ, ᨸᩁᩥᨲ᩠ᨲᩮᩣ ᨲᩦᩈᩩ ᩋᨸ᩠ᨸᨠᩮ.
ᨠᩩᨾ᩠ᨽᨱ᩠ᨯᩮᩣ ᨴᩮᩅᨽᩮᨴᩮ ᨧ, ᨴᩥᩔᨲᩥ ᩅᩃ᩠ᩃᩥᨩᩣᨲᩥᨿᩴ;
ᨧᨲᩩᨲ᩠ᨳᩴᩈᩮ ᨸᨴᩮ ᨸᩣᨴᩮᩣ, ᨸᨧ᩠ᨧᨶ᩠ᨲᩈᩮᩃᩁᩴᩈᩥᩈᩩ.
ᩅᨦ᩠ᨣᩮᩣ ᩃᩮᩣᩉᨶ᩠ᨲᩁᩮ ᩅᨦ᩠ᨣᩣ, ᨴᩮᩈᩮ ᨸᩩᨾᩮ ᨻᩉᩩᨾ᩠ᩉᩥ ᨧ;
ᨠᨾ᩠ᨾᩣᩁᨽᨱ᩠ᨯᨽᩮᨴᩮ ᨧ, ᨡᨭᨠᩮ ᨾᩩᨭ᩠ᨮᩥ ᨧ ᨴ᩠ᩅᩥᩈᩩ.
ᩋᨾ᩠ᨻᨱᩴ ᨴᩮᩣᨱᩥᨿᩴ ᨧᩮ’ᨠᩣ, ᨴᩈᨴᩮᩣᨱᨸ᩠ᨸᨾᩣᨱᨠᩮ;
ᩋᨵᩥᨭ᩠ᨮᩥᨲᩥᨿ ᨾᩣᨵᩣᩁᩮ, ᨮᩣᨶᩮ’ᨵᩥᨭ᩠ᨮᩣᨶ ᨾᩩᨧ᩠ᨧᨲᩮ.
ᨸᩩᨾᩮ ᨾᩉᩮᩈᩦ ᩈᩩᨣᨲᩮ, ᨴᩮᩅᩥᨿᩴ ᨶᩣᩁᩥᨿᩴ ᨾᨲᩣ;
ᩏᨸᨴ᩠ᨴᩅᩮ ᩏᨸᩈᨣ᩠ᨣᩮᩣ, ᨴᩥᩔᨲᩥ ᨸᩣᨴᩥᨠᩮᨸᩥ ᨧ.
ᩅᨠ᩠ᨠᩴ ¶ ᨠᩮᩣᨭ᩠ᨮᩣᩈᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᩅᨠ᩠ᨠᩮᩣ ᩅᨦ᩠ᨠᩮ ᨲᩥᩈᩩ’ᨧ᩠ᨧᨲᩮ;
ᩅᩥᨩ᩠ᨩᩣ ᩅᩮᨴᩮ ᨧ ᩈᩥᨸ᩠ᨸᩮ ᨧ, ᨲᩥᩅᩥᨩ᩠ᨩᩣᨴᩮᩣ ᨧ ᨻᩩᨴ᩠ᨵᩥᨿᩴ.
ᩈᨾᩣᨵᩥᨾ᩠ᩉᩥ ᨸᩩᨾᩮ’ᨠᨣ᩠ᨣᩮᩣ, ᨶᩣᨠᩩᩃᩮ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ;
ᨸᨩ᩠ᨩᩴ ᩈᩥᩃᩮᩣᨠᩮ, ᨸᨩ᩠ᨩᩮᩣ’ᨴ᩠ᨵᩮ, ᨸᨩ᩠ᨩᩮᩣ ᨸᩣᨴᩉᩥᨲᩮ ᨲᩥᩈᩩ.
ᨠᨲᨠᩮᩣ ᩁᩩᨠ᩠ᨡᨽᩮᨴᩈ᩠ᨾᩥᩴ, ᨠᨲᨠᩮᩣ ᨠᩥᨲ᩠ᨲᩥᨾᩮ ᨲᩥᩈᩩ;
ᩅᩥᨵᩮᨿ᩠ᨿᩮ ᩋᩔᩅᩮᩣ ᨲᩦᩈᩩ, ᨸᩩᨻ᩠ᨻᨾ᩠ᩉᩦ ᨸᩩᩁᩥᩈᩮ ᩈᩥᨿᩣ.
ᨠᩃ᩠ᨿᩣᨱᩮ ᨠᨳᩥᨲᩴ ᨡᩮᨾᩴ, ᨲᩦᩈᩩ ᩃᨴ᩠ᨵᨲ᩠ᨳᩁᨠ᩠ᨡᨱᩮ;
ᩋᨳᩮᩣ ᨶᩥᨿᩮᩣᨩᨶᩮ ᩅᩩᨲ᩠ᨲᩴ, ᨠᩣᩁᩥᨿᩮᨸᩥ ᨸᨿᩮᩣᨩᨶᩴ.
ᩋᩔᨲ᩠ᨳᩮᩣ ᨲᩦᩈᩩ ᩋᩔᩣᩈ, ᨸ᩠ᨸᨲ᩠ᨲᩮ, ᨻᩮᩣᨵᩥᨴ᩠ᨴᩩᨾᩮ ᨸᩩᨾᩮ;
ᨲᩦᩈᩩ ᩃᩩᨴ᩠ᨴᩮᩣ ᨠᩩᩁᩪᩁᩮ ᨧ, ᨶᩮᩈᩣᨴᨾ᩠ᩉᩥ ᨸᩩᨾᩮ ᩈᩥᨿᩣ.
ᩅᩥᩃᨣ᩠ᨣᩮᩣ ᨲᩦᩈᩩ ᩃᨣ᩠ᨣᩈ᩠ᨾᩥᩴ, ᨸᩩᨾᩮ ᨾᨩ᩠ᨫᨾ᩠ᩉᩥ ᨴᩥᩔᨲᩥ;
ᩋᨯ᩠ᨰᩮᩣ ᨲ᩠ᩅᨶᩥᨲ᩠ᨳᩥᨿᩴ ᨽᩣᨣᩮ, ᨵᨶᩥᨾ᩠ᩉᩥ ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩥᨠᩮᩣ.
ᨠᨭ᩠ᨮᩴ ᨴᩣᩁᩩᨾ᩠ᩉᩥ, ᨲᩴ ᨠᩥᨧ᩠ᨨᩮ, ᨣᩉᨶᩮ ᨠᩈᩥᨲᩮ ᨲᩥᩈᩩ;
ᩈᩈᨶ᩠ᨲᩣᨶᩮ ᨧ ᩅᩥᩈᨿᩮ, ᨣᩮᩣᨧᩁᩮ’ ᨩ᩠ᨫᨲ᩠ᨲ ᨾᩩᨧ᩠ᨧᨲᩮᨲᩥ.
ᩍᨲᩥ ᩋᨴ᩠ᨵᩣᨶᩮᨠᨲ᩠ᨳᩅᨣ᩠ᨣᩮᩣ.
ᨽᩩᩅᨶᩮ ᨧ ᨩᨶᩮ ᩃᩮᩣᨠᩮᩣ, ᨾᩮᩣᩁᩮᨲ᩠ᩅᨣ᩠ᨣᩥᨾ᩠ᩉᩥ ᩈᩮᩣ ᩈᩥᨡᩦ;
ᩈᩥᩃᩮᩣᨠᩮᩣ ᨲᩩ ᨿᩈᩮ ᨸᨩ᩠ᨩᩮ,
ᩁᩩᨠ᩠ᨡᩮ ᨲᩩ ᩈᩣᨾᩥᨠᩮ ᨵᩅᩮᩣ.
ᩅᨭᨻ᩠ᨿᩣᨾᩮᩈᩩ ᨶᩥᨣᩕᩮᩣᨵᩮᩣ, ᨵᨦ᩠ᨠᩮᩣ ᨲᩩ ᩅᩣᨿᩈᩮ ᨻᨠᩮ;
ᩅᩣᩁᩮᩣ ᨲ᩠ᩅ’ᩅᩈᩁᩣ’ᩉᩮᩈᩩ, ᨠᩩᨧᩮᨲ᩠ᩅᨻ᩠ᨽᩮ ᨸᨿᩮᩣᨵᩁᩮᩣ.
ᩏᨧ᩠ᨨᨦ᩠ᨣᩮ ᩃᨠ᩠ᨡᨱᩮ ᨧᩣ’ᨦ᩠ᨠᩮᩣ, ᩁᩈ᩠ᨾᩥ’ᨲ᩠ᨳᩦ ᨩᩩᨲᩥ ᩁᨩ᩠ᨩᩩᩈᩩ;
ᨴᩥᨭ᩠ᨮᩮᩣ’ᨽᩣᩈᩮᩈᩩ ᩌᩃᩮᩣᨠᩮᩣ,
ᨻᩩᨴ᩠ᨵᩮᩣ ᨲᩩ ᨸᨱ᩠ᨯᩥᨲᩮ ᨩᩥᨶᩮ.
ᩈᩪᩁᩴ’ᩈᩪᩈᩩ ᨸᩩᨾᩮ ᨽᩣᨶᩪ, ᨴᨱ᩠ᨯᩮᩣ ᨲᩩ ᨾᩩᨣ᩠ᨣᩁᩮ ᨴᨾᩮ;
ᨴᩮᩅᨾᨧ᩠ᨨᩮᩈ᩠ᩅ’ᨶᩥᨾᩥᩈᩮᩣ, ᨸᨲ᩠ᨳᩮᩣ ᨲᩩ ᨾᩣᨶᩈᩣᨶᩩᩈᩩ.
ᩌᨲᨦ᩠ᨠᩮᩣ ᩁᩮᩣᨣ ᨲᩣᨸᩮᩈᩩ,
ᨾᩣᨲᨦ᩠ᨣᩮᩣ ᩈᨸᨧᩮ ᨣᨩᩮ;
ᨾᩥᨣᩮᩣ ᨸᩈᩩ ᨠᩩᩁᩩᨦ᩠ᨣᩮᩈᩩ, ᩏᩃᩪᨠᩥ’ᨶ᩠ᨴᩮᩈᩩ ᨠᩮᩣᩈᩥᨿᩮᩣ.
ᩅᩥᨣ᩠ᨣᩉᩮᩣ ¶ ᨠᩃᩉᩮ ᨠᩣᨿᩮ, ᨸᩩᩁᩥᩈᩮᩣ ᨾᩣᨱᩅ’ᨲ᩠ᨲᩈᩩ;
ᨴᩣᨿᩣᨴᩮᩣ ᨻᨶ᩠ᨵᩅᩮ ᨸᩩᨲ᩠ᨲᩮ, ᩈᩥᩁᩮ ᩈᩦᩈᩴ ᨲᩥᨸᩩᨾ᩠ᩉᩥ ᨧ.
ᨻᩃᩥᩉᨲ᩠ᨳᩴ’ᩈᩪᩈᩩ ᨠᩁᩮᩣ, ᨴᨶ᩠ᨲᩮ ᩅᩥᨸ᩠ᨸᩮ’ᨱ᩠ᨯᨩᩮ ᨴ᩠ᩅᩥᨩᩮᩣ;
ᩅᨲ᩠ᨲᩴ ᨸᨩ᩠ᨩᩣ’ᨶᨶᩣ’ᨧᩣᩁᩮ, ᨵᨬ᩠ᨬᨦ᩠ᨣᩮ ᩈᩩᨡᩩᨾᩮ ᨠᨱᩮᩣ.
ᨳᨾ᩠ᨽᩮᩣ ᨳᩪᨱ ᨩᩊᨲ᩠ᨲᩮᩈᩩ, ᩈᩪᨸᩮᩣ ᨠᩩᨾ᩠ᨾᩣᩈ ᨻ᩠ᨿᨬ᩠ᨩᨶᩮ;
ᨣᨱ᩠ᨯᩮᩣ ᨹᩮᩣᨭᩮ ᨠᨸᩮᩣᩃᨾ᩠ᩉᩥ, ᩋᨣ᩠ᨥᩮᩣ ᨾᩪᩃ᩠ᨿᩮ ᨧ ᨸᩪᨩᨶᩮ.
ᨸᨠᩣᩁᩮᩣ ᨲᩩᩃ᩠ᨿ ᨽᩮᨴᩮᩈᩩ, ᩈᨠᩩᨶ᩠ᨲᩮᩣ ᨽᩣᩈᨸᨠ᩠ᨡᩥᩈᩩ;
ᨽᩣᨣ᩠ᨿᩮ ᩅᩥᨵᩥ ᩅᩥᨵᩣᨶᩮ ᨧ, ᩈᩁᩮ ᨡᨣ᩠ᨣᩮ ᨧ ᩈᩣᨿᨠᩮᩣ.
ᩈᩣᩁᨦ᩠ᨣᩮᩣ ᨧᩣᨲᨠᩮ ᩑᨱᩮ, ᨸᨲ᩠ᨲᩦ ᨲᩩ ᩈᩁᨸᨠ᩠ᨡᩥᩈᩩ;
ᩈᩮᨴᩮ ᨸᩣᨠᩮᩣ ᩅᩥᨸᩣᨠᩮ ᨳ,
ᨽᩥᨠ᩠ᨡᩩᨽᩮᨴᩮ ᨧᨿᩮ ᨣᨱᩮᩣ.
ᩁᩣᩈᩥ ᨸᩩᨬ᩠ᨩᩮ ᨧ ᨾᩮᩈᩣ’ᨴᩮᩣ,
ᩋᩔᩮ ᩃᩮᩣᨱᩮ ᨧ ᩈᩥᨶ᩠ᨵᩅᩮᩣ;
ᩈᩴᩅᨭ᩠ᨭᩮ ᨸᩃᨿᩮᩣ ᨶᩣᩈᩮ, ᨸᩪᨣᩮᩣ ᨠᨾᩩᨠᩁᩣᩈᩥᩈᩩ.
ᩋᨾᨲᩮ ᨲᩩ ᩈᩩᨵᩣ ᩃᩮᨸᩮ, ᩋᨽᩥᨡ᩠ᨿᩣ ᨶᩣᨾ ᩁᩴᩈᩥᩈᩩ;
ᩈᨲ᩠ᨲᩥ ᩈᩣᨾᨲ᩠ᨳᩥᨿᩮ ᩈᨲ᩠ᨳᩮ, ᨾᩉᩦ ᨶᨩ᩠ᨩᨶ᩠ᨲᩁᩮ ᨽᩩᩅᩥ;
ᩃᩦᩃᩣ ᨠᩕᩥᨿᩣ ᩅᩥᩃᩣᩈᩮᩈᩩ,
ᩈᨲ᩠ᨲᩮ ᨲᩩ ᩋᨲᩕᨩᩮ ᨸᨩᩣ.
ᨬᩣᨱᩮ ᩃᩣᨽᩮ ᩏᨸᩃᨴ᩠ᨵᩥ, ᨸᩅᩮᨱᩦ ᨠᩩᨳᩅᩮᨱᩥᩈᩩ;
ᨸᩅᨲ᩠ᨲᩥ ᩅᩩᨲ᩠ᨲᩥ ᩅᨲ᩠ᨲᩣᩈᩩ, ᩅᩮᨲᨶᩮ ᨽᩁᨱᩮ ᨽᨲᩥ.
ᩌᨧᩣᩁᩮᨸᩥ ᨾᩁᩥᨿᩣᨴᩣ, ᨽᩪᨲᩥ ᩈᨲ᩠ᨲᩣ ᩈᨾᩥᨴ᩠ᨵᩥᩈᩩ;
ᩈᩮᩣᨸ᩠ᨸᩮ ᨸᨾᩣᨴᩮ ᨲᨶ᩠ᨴᩦ ᨧ, ᨿᩣᨲᩕᩣ ᨣᨾᨶ ᩅᩩᨲ᩠ᨲᩥᩈᩩ.
ᨶᩥᨶ᩠ᨴᩣ ᨠᩩᨧ᩠ᨨᩣ’ᨸᩅᩣᨴᩮᩈᩩ, ᨠᨦ᩠ᨣᩩ ᨵᨬ᩠ᨬ ᨸᩥᨿᨦ᩠ᨣᩩᩈᩩ;
ᨾᩮᩣᨠ᩠ᨡᩮᩈᩥᩅᩮ ᩈᨾᩮᩈᨶ᩠ᨲᩥ, ᩅᩥᨽᩣᨣᩮ ᨽᨲ᩠ᨲᩥ ᩈᩮᩅᨶᩮ.
ᩍᨧ᩠ᨨᩣᨿᩴ ᨩᩩᨲᩥᨿᩴ ᨠᨶ᩠ᨲᩥ, ᩁᨬ᩠ᨩᨶᩮ ᩈᩪᩁᨲᩮ ᩁᨲᩥ;
ᨣᩮᩉᩮ ᩅᩈᨲᩥ ᩅᩣᩈᩮ ᨳ, ᨶᨴᩦ ᩈᩮᨶᩣᩈᩩ ᩅᩣᩉᩥᨶᩦ.
ᨸᨲ᩠ᨳᩮ ᨶᩣᩊᩮ ᨧ ᨶᩣᩊᩥ’ᨲ᩠ᨳᩦ, ᨣᨱᩮ ᩈᨾᩥᨲᩥ ᩈᨦ᩠ᨣᨾᩮ;
ᨲᨱ᩠ᩉᩣ ᩃᩮᩣᨽᩮ ᨸᩥᨸᩣᩈᩣᨿᩴ, ᨾᨣ᩠ᨣ ᩅᩩᨲ᩠ᨲᩦᩈᩩ ᩅᨲ᩠ᨲᨶᩦ.
ᨸᩣᨱ᩠ᨿᨦ᩠ᨣᩮ ᨶᩣᨽᩥ ᨧᨠ᩠ᨠᨶ᩠ᨲᩮ, ᨿᩣᨧᩮ ᩅᩥᨬ᩠ᨬᨲ᩠ᨲᩥ ᨬᩣᨸᨶᩮ;
ᩅᩥᨲ᩠ᨲᩥ ᨲᩮᩣᩈᩮ ᩅᩮᨴᨶᩣᨿᩴ, ᨮᩣᨶᩮ ᨲᩩ ᨩᩦᩅᩥᨲᩮ ᨮᩥᨲᩥ.
ᨲᩁᨦ᩠ᨣᩮ ¶ ᨧᩣ’ᨶ᩠ᨲᩁᩮ ᩅᩦᨧᩥ, ᨵᩦᩁᨲ᩠ᨲᩮ ᨵᩣᩁᨱᩮ ᨵᩥᨲᩥ;
ᨽᩪ ᨽᩪᨾᩥᨿᨬ᩠ᨧ ᨽᨾᩩᨠᩮ, ᩈᨴ᩠ᨴᩮ ᩅᩮᨴᩮ ᩈᩅᩮ ᩈᩩᨲᩥ.
ᨣᩮᩣᨲ᩠ᨲᩴ ᨶᩣᨾᩮ ᨧ ᩅᩴᩈᩮ ᨳ, ᨶᨣᩁᩮ ᨧ ᨥᩁᩮ ᨸᩩᩁᩴ;
ᩒᨠᩴ ᨲᩩ ᨶᩥᩔᨿᩮ ᨣᩮᩉᩮ, ᨠᩩᩃᩴ ᨲᩩ ᨣᩮᩣᨲ᩠ᨲᩁᩣᩈᩥᩈᩩ.
ᩉᩮᨾᩮ ᩅᩥᨲ᩠ᨲᩮ ᩉᩥᩁᨬ᩠ᨬᨬ᩠ᨧ, ᨸᨬ᩠ᨬᩣᨱᩴ ᨲ᩠ᩅ’ᨦ᩠ᨠ ᩅᩩᨴ᩠ᨵᩥᩈᩩ;
ᩋᨳᩣ’ᨾ᩠ᨻᩁᨬ᩠ᨧ ᨡᩮ ᩅᨲ᩠ᨳᩮ, ᨣᩩᨿ᩠ᩉᩴ ᩃᩥᨦ᩠ᨣᩮ ᩁᩉᩈ᩠ᨿ’ᨸᩥ.
ᨲᨸᩮᩣ ᨵᨾ᩠ᨾᩮ ᩅᨲᩮ ᨧᩮᩅ, ᨸᩣᨸᩮ ᨲ᩠ᩅᩣ’ᨣᩩᨾ᩠ᩉᩥ ᨠᩥᨻ᩠ᨻᩥᩈᩴ;
ᩁᨲᨶᩴ ᨾᨱᩥ ᩈᩮᨭ᩠ᨮᩮᩈᩩ, ᩅᩔᩴ ᩉᩣᨿᨶ ᩅᩩᨭ᩠ᨮᩥᩈᩩ.
ᩅᨶᩴ ᩋᩁᨬ᩠ᨬ ᩅᩣᩁᩦᩈᩩ, ᨡᩦᩁᨾ᩠ᩉᩥ ᨲᩩ ᨩᩃᩮ ᨸᨿᩮᩣ;
ᩋᨠ᩠ᨡᩁᩴ ᩃᩥᨸᩥ ᨾᩮᩣᨠ᩠ᨡᩮᩈᩩ, ᨾᩮᨳᩪᨶᩴ ᩈᨦ᩠ᨣᨾᩮ ᩁᨲᩮ.
ᩈᩮᩣᨲᩴ ᨠᨱ᩠ᨱᩮ ᨸᨿᩮᩣᩅᩮᨣᩮ, ᩁᩥᨭ᩠ᨮᩴ ᨸᩣᨸᩣ’ᩈᩩᨽᩮᩈᩩ ᨧ;
ᩌᨣᩩ ᨸᩣᨸᩣ’ᨸᩁᩣᨵᩮᩈᩩ, ᨠᩮᨲᩩᨾ᩠ᩉᩥ ᨧᩥᩉᨶᩮ ᨵᨩᩮᩣ.
ᨣᩮᩣᨸᩩᩁᩴ ᨴ᩠ᩅᩣᩁᨾᨲ᩠ᨲᩮᨸᩥ, ᨾᨶ᩠ᨴᩥᩁᩴ ᨶᨣᩁᩮ ᨥᩁᩮ;
ᩅᩣᨧ᩠ᨧᩃᩥᨦ᩠ᨣᩣ ᨸᩁᨾᩥᨲᩮᩣ, ᨻ᩠ᨿᨲ᩠ᨲᩮᩣ ᨲᩩ ᨸᨱ᩠ᨯᩥᨲᩮ ᨹᩩᨭᩮ.
ᩅᩃ᩠ᩃᨽᩮᩣ ᨴᨿᩥᨲᩮ’ᨩ᩠ᨫᨠ᩠ᨡᩮ, ᨩᩃᩮ ᨳᩪᩃᩮᩣ ᨾᩉᨲ᩠ᨿᨸᩥ;
ᨠᩩᩁᩪᩁᩮ ᨽᩮᩁᩅᩮ ᨽᩦᨾᩮᩣ,
ᩃᩮᩣᩃᩮᩣ ᨲᩩ ᩃᩮᩣᩃᩩᨸᩮ ᨧᩃᩮ.
ᨻᩦᨽᨧ᩠ᨨᩮᩣ ᩅᩥᨠᨲᩮ ᨽᩦᨾᩮ, ᨠᩮᩣᨾᩃᩮ ᨲᩥᨡᩥᨱᩮ ᨾᩩᨴᩩ;
ᩍᨭ᩠ᨮᩮ ᨧ ᨾᨵᩩᩁᩮ ᩈᩣᨴᩩ, ᩈᩣᨴᩩᨾ᩠ᩉᩥ ᨾᨵᩩᩁᩮᩣ ᨸᩥᨿᩮ.
ᩈᩥᨲᩮ ᨲᩩ ᩈᩩᨴ᩠ᨵᩮ ᩒᨴᩣᨲᩮᩣ, ᨴ᩠ᩅᩥᨩᩥᩅ᩠ᩉᩮᩣ ᩈᩪᨧᨠᩣ’ᩉᩥᩈᩩ;
ᩈᨠ᩠ᨠᩮ ᩈᨾᨲ᩠ᨳᩮᩣ ᩈᨾ᩠ᨻᨶ᩠ᨵᩮ, ᩈᨾᨲ᩠ᨲᩴ ᨶᩥᨭ᩠ᨮᩥᨲᩣ’ᨡᩥᩃᩮ.
ᩈᩩᨴ᩠ᨵᩮᩣ ᨠᩮᩅᩃ ᨸᩪᨲᩮᩈᩩ, ᨩᩥᨥᨬ᩠ᨬᩮᩣ’ᨶ᩠ᨲᩣ’ᨵᨾᩮᩈᩩ ᨧ;
ᨸᩮᩣᨱᩮᩣ’ᨸᨶᨲ ᨶᩥᨶ᩠ᨶᩮᩈᩩ, ᩋᨬ᩠ᨬ ᨶᩦᨧᩮᩈᩩ ᨧᩮ’ᨲᩁᩮᩣ.
ᩈᩩᨧᩥ ᩈᩩᨴ᩠ᨵᩮ ᩈᩥᨲᩮ ᨸᩪᨲᩮ, ᨸᩮᩈᩃᩮᩣ ᨴᨠ᩠ᨡᨧᩣᩁᩩᩈᩩ;
ᩋᨵᨾᩮᩣ ᨠᩩᨧ᩠ᨨᩥᨲᩮ ᩐᨶᩮ, ᩋᨸ᩠ᨸᩥᨿᩮ ᨸ᩠ᨿ’ᩃᩥᨠᩮᩣ ᨽᩅᩮ.
ᨻ᩠ᨿᩣᨸᩮ ᩋᩈᩩᨴ᩠ᨵᩮ ᩈᩴᨠᩥᨱ᩠ᨱᩮᩣ, ᨽᨻ᩠ᨻᩴ ᨿᩮᩣᨣ᩠ᨿᩮ ᨧ ᨽᩣᩅᩥᨶᩥ;
ᩈᩩᨡᩩᨾᩮᩣ ᩋᨸ᩠ᨸᨠᩣ’ᨱᩪᩈᩩ, ᩅᩩᨴ᩠ᨵᩮᩣ ᨳᩮᩁᩮ ᨧ ᨸᨱ᩠ᨯᩥᨲᩮ.
ᩈᩩᨽᩮ ᩈᩣᨵᩩᨾ᩠ᩉᩥ ᨽᨴ᩠ᨴᩮᩣ ᨳ, ᨲ᩠ᨿᩣ’ᨴᩮᩣ ᨧ ᩅᩥᨸᩩᩃᩮ ᨻᩉᩩ;
ᨵᩦᩁᩮᩣ ᨻᩩᨵᩮ ᨵᩥᨲᩥᨾᨶ᩠ᨲᩮ, ᩅᩮᩃ᩠ᩃᩥᨲᩴ ᨠᩩᨭᩥᩃᩮ ᨵᩩᨲᩮ.
ᩅᩥᩈᨴᩮᩣ ¶ ᨻ᩠ᨿᨲ᩠ᨲ ᩈᩮᨲᩮᩈᩩ, ᨲᩁᩩᨱᩮᩣ ᨲᩩ ᨿᩩᩅᩮ ᨶᩅᩮ;
ᨿᩮᩣᨣ᩠ᨣᩴ ᨿᩣᨶᩮ, ᨡᨾᩮ ᨿᩮᩣᨣ᩠ᨣᩮᩣ,
ᨸᩥᨱ᩠ᨯᩥᨲᩴ ᨣᨱᩥᨲᩮ ᨥᨶᩮ.
ᨻᩩᨵᩮ’ᨽᩥᨩᩣᨲᩮᩣ ᨠᩩᩃᨩᩮ, ᩅᩩᨴ᩠ᨵᩮᩣ’ᩁᩪᩈᩩ ᨾᩉᩃ᩠ᩃᨠᩮᩣ;
ᨠᩃ᩠ᨿᩣᨱᩴ ᩈᩩᨶ᩠ᨴᩁᩮ ᨧᩣᨸᩥ, ᩉᩥᨾᩮᩣ ᨲᩩ ᩈᩦᨲᩃᩮᨸᩥ ᨧ.
ᩃᩮᩣᩃᩮ ᨲᩩ ᩈᩦᨥᩮ ᨧᨸᩃᩮᩣ, ᩅᩩᨲ᩠ᨲᩮ ᩏᨴᩥᨲ ᨾᩩᨣ᩠ᨣᨲᩮ;
ᩌᨴᩥᨲ᩠ᨲᩮ ᨣᨻ᩠ᨻᩥᨲᩮ ᨴᩥᨲ᩠ᨲᩮᩣ, ᨸᩥᨭ᩠ᨮᩴ ᨲᩩ ᨧᩩᨱ᩠ᨱᩥᨲᩮᨸᩥ ᨧ.
ᩅᩥᨣᨲᩮ ᩅᩣᨿᩥᨲᩮ [ᩅᩣᨿᨶᩮ (ᨠ.)] ᩅᩦᨲᩴ, ᨽᩣᩅᩥᨲᩴ ᩅᨯ᩠ᨰᩥᨲᩮᨸᩥ ᨧ;
ᨽᨩ᩠ᨩᩥᨲᩮ ᨸᨲᩥᨲᩮ ᨽᨭ᩠ᨮᩮᩣ, ᨸᩩᨭ᩠ᨮᩮᩣ ᨸᩩᨧ᩠ᨨᩥᨲ ᨸᩮᩣᩈᩥᨲᩮ.
ᨩᩣᨲᩮᩣ ᨽᩪᨲᩮ ᨧᨿᩮ ᨩᩣᨲᩴ,
ᨸᨭᩥᨽᩣᨣᩮᩣ ᩈᨾᩣ’ᩁᩥᩈᩩ;
ᩈᩪᩁᩮᩣ ᩅᩦᩁᩮ ᩁᩅᩥᩈᩪᩁᩮ, ᨴᩩᨭ᩠ᨮᩮᩣ ᨠᩩᨴ᩠ᨵᩮ ᨧ ᨴᩪᩈᩥᨲᩮ.
ᨴᩥᨭ᩠ᨮᩮᩣ’ᩁᩥᨾ᩠ᩉᩥ’ᨠ᩠ᨡᩥᨲᩮ ᨴᩥᨭ᩠ᨮᩮᩣ [ᨴᩥᨭ᩠ᨮᩴ (ᨠ.)],
ᨾᩪᩊ᩠ᩉᩮ ᨸᩮᩣᨲᩮ ᨧ ᨻᩣᩃᩥᩈᩮᩣ;
ᨶᩥᨶ᩠ᨴᩣᨿᩴ ᨡᩮᨸᨶᩮ ᨡᩮᨸᩮᩣ, ᨶᩥᨿᨾᩮᩣ ᨶᩥᨧ᩠ᨨᨿᩮ ᩅᨲᩮ.
ᩈᩃᩣᨠᩣᨿᩴ ᨠᩩᩈᩮᩣ ᨴᨻ᩠ᨽᩮ,
ᨻᩣᩃ᩠ᨿᩣᨴᩮᩣ ᨲᩩ ᨡᨿᩮ ᩅᨿᩮᩣ;
ᩃᩮᨸ ᨣᨻ᩠ᨻᩮᩈ᩠ᩅ’ᩅᩃᩮᨸᩮᩣ, ᩋᨱ᩠ᨯᨩᩮᩣ ᨾᩦᨶᨸᨠ᩠ᨡᩥᩈᩩ.
ᨻᩥᩃᩣᩃᩮ ᨶᨠᩩᩃᩮ ᨻᨻ᩠ᨻᩩ, ᨾᨶ᩠ᨳᩮᩣ ᨾᨶ᩠ᨳᨶᩈᨲ᩠ᨲᩩᩈᩩ;
ᩅᩣᩃᩮᩣ ᨠᩮᩈᩮ’ᩔᩣᨴᩥᩃᩮᩣᨾᩮ,
ᩈᨦ᩠ᨥᩣᨲᩮᩣ ᨥᩣᨲᩁᩣᩈᩥᩈᩩ.
ᨣᩮᩣᨸᨣᩣᨾᩮ ᩁᩅᩮ ᨥᩮᩣᩈᩮᩣ, ᩈᩪᨲᩮᩣ ᩈᩣᩁᨳᩥᩅᨶ᩠ᨴᩥᩈᩩ;
ᨾᩣᩃ᩠ᨿᩴ ᨲᩩ ᨸᩩᨸ᩠ᨹᩮ ᨲᨴ᩠ᨴᩣᨾᩮ, ᩅᩣᩉᩮᩣ ᨲᩩ ᩈᨠᨭᩮ ᩉᨿᩮ.
ᨡᨿᩮ’ᨧ᩠ᨧᨶᩮ ᨧᩣ’ᨸᨧᨿᩮᩣ, ᨠᩣᩃᩮᩣ ᩈᨾᨿ ᨾᨧ᩠ᨧᩩᩈᩩ;
ᨽᩮ ᨲᩣᩁᨠᩣ ᨶᩮᨲ᩠ᨲᨾᨩ᩠ᨫᩮ, ᩈᩦᨾᩣ’ ᩅᨵᩥ, ᨭ᩠ᨮᩥᨲᩦᩈᩩ ᨧ.
ᩌᨽᩮᩣᨣᩮᩣ ᨸᩩᨱ᩠ᨱᨲᩣ’ᩅᨩ᩠ᨩᩮ-
ᩈ᩠ᩅᩣ’ᩊᩥ’ᨲ᩠ᨳᩦ ᩈᨡᩥ ᩈᩮᨲᩩᩈᩩ;
ᩈᨲ᩠ᨲᩮ ᨳᩪᩃᩮ ᨲᩦᩈᩩ ᨴᩊ᩠ᩉᩮᩣ, ᩃᨲᩣ ᩈᩣᨡᩣᨿ ᩅᩃ᩠ᩃᩥᨿᩴ.
ᨾᩩᨲ᩠ᨲᩥ’ᨲ᩠ᨳᩦ ¶ ᨾᩮᩣᨧᨶᩮ ᨾᩮᩣᨠ᩠ᨡᩮ,
ᨠᩣᨿᩮᩣ ᨲᩩ ᨴᩮᩉ ᩁᩣᩈᩥᩈᩩ;
ᨶᩦᨧᩮ ᨸᩩᨳᩩᨩ᩠ᨩᨶᩮᩣ ᨾᩪᩊ᩠ᩉᩮ, ᨽᨲ᩠ᨲᩣ ᩈᩣᨾᩥᨶᩥ ᨵᩣᩁᨠᩮ.
ᩈᩥᨡᩣ, ᨸᩥᨬ᩠ᨨᩮᩈᩩ ᩈᩥᨡᨱ᩠ᨯᩮᩣ, ᩈᨲ᩠ᨲᩮ ᨲ᩠ᩅ’ᨲ᩠ᨲᨶᩥ ᨸᩩᨣ᩠ᨣᩃᩮᩣ;
ᩈᨾ᩠ᨻᩣᨵᩮᩣ ᩈᩴᨠᨭᩮ ᨣᩩᨿ᩠ᩉᩮ,
ᨶᩣᩈᩮ ᨡᩮᨸᩮ ᨸᩁᩣᨽᩅᩮᩣ.
ᩅᨧ᩠ᨧᩮᩣ ᩁᩪᨸᩮ ᨠᩁᩦᩈᩮ ᨳ, ᨩᩩᨲᩥ’ᨲ᩠ᨳᩦ ᨠᨶ᩠ᨲᩥᩁᩴᩈᩥᩈᩩ;
ᩃᨻ᩠ᨽᩴ ᨿᩩᨲ᩠ᨲᩮ ᨧ ᩃᨴ᩠ᨵᨻ᩠ᨻᩮ, ᨡᨱ᩠ᨯᩮ ᨸᨱ᩠ᨱᩮ ᨴᩃᩴ ᨾᨲᩴ;
ᩈᩃ᩠ᩃᩴ ᨠᨱ᩠ᨯᩮ ᩈᩃᩣᨠᩣᨿᩴ, ᩈᩩᨧᩥᨲ᩠ᨲᩮ ᨵᩣᩅᨶᩴ ᨣᨲᩮ;
ᨽᨶ᩠ᨲᨲ᩠ᨳᩮ ᩅᩥᨻ᩠ᨽᨾᩮᩣ ᩉᩣᩅᩮ, ᨾᩮᩣᩉᩮᩣ’ᩅᩥᨩ᩠ᨩᩣᨿ ᨾᩩᨧ᩠ᨨᨶᩮ.
ᩈᩮᨴᩮᩣ ᨥᨾ᩠ᨾᨩᩃᩮ ᨸᩣᨠᩮ,
ᨣᩮᩣᩊᩮ ᩏᨧ᩠ᨨᩩᨾᨿᩮ ᨣᩩᩊᩮᩣ;
ᨾᩥᨲ᩠ᨲᩮ ᩈᩉᩣᨿᩮ ᨧ ᩈᨡᩣ, ᩅᩥᨽᩪ ᨶᩥᨧ᩠ᨧᨸ᩠ᨸᨽᩪᩈᩩ ᩈᩮᩣ.
ᨡᨣ᩠ᨣᩮ ᨠᩩᩁᩪᩁᩮ ᨶᩮᨲ᩠ᨲᩥᩴᩈᩮᩣ, ᨸᩁᩈ᩠ᨾᩥᩴ ᩋᨲᩕ ᨲᩦᩈ᩠ᩅ’ᨾᩩ;
ᨠᩃᨦ᩠ᨠᩮᩣ’ᨦ᩠ᨠᩣ’ᨸᩅᩣᨴᩮᩈᩩ,
ᨴᩮᩈᩮ ᨩᨶᨸᨴᩮᩣ ᨩᨶᩮ.
ᨸᨩ᩠ᨩᩮ ᨣᩣᨳᩣ ᩅᨧᩦᨽᩮᨴᩮ, ᩅᩴᩈᩮᩣ ᨲ᩠ᩅ’ᨶ᩠ᩅᨿᩅᩮᨱᩩᩈᩩ;
ᨿᩣᨶᩴ ᩁᨳᩣᨴᩮᩣ ᨣᨾᨶᩮ, ᩈᩁᩪᨸᩈ᩠ᨾᩥᩴ ᩋᨵᩮᩣ ᨲᩃᩴ.
ᨾᨩ᩠ᨫᩮᩣ ᩅᩥᩃᨣ᩠ᨣᩮ ᩅᩮᨾᨩ᩠ᨫᩮ, ᨸᩩᨸ᩠ᨹᩴ ᨲᩩ ᨠᩩᩈᩩᨾᩮᩣ’ᨲᩩᩈᩩ;
ᩈᩦᩃᩴ ᩈᨽᩣᩅᩮ ᩈᩩᨻ᩠ᨻᨲᩮ, ᨸᩩᨦ᩠ᨣᩅᩮᩣ ᩏᩈᨽᩮ ᩅᩁᩮ.
ᨠᩮᩣᩈᩮ ᨡᨣᩣᨴᩥᨻᩦᨩᩮ’ᨱ᩠ᨯᩴ, ᨠᩩᩉᩁᩴ ᨣᨻ᩠ᨽᩁᩮ ᨻᩥᩃᩮ;
ᨶᩮᨲ᩠ᨲᩥᩴᩈᩮ ᨣᨱ᩠ᨯᨠᩮ ᨡᨣ᩠ᨣᩮᩣ, ᨠᨴᨾ᩠ᨻᩮᩣ ᨲᩩ ᨴᩩᨾᩮ ᨧᨿᩮ.
ᨽᩮ’ᨵᩮᨶᩩᨿᩴ ᩁᩮᩣᩉᩥᨱᩦ’ᨲ᩠ᨳᩦ, ᩅᩁᨦ᩠ᨣᩴ ᨿᩮᩣᨶᩥᨿᩴ ᩈᩥᩁᩮ;
ᩋᨠ᩠ᨠᩮᩣᩈᩮ ᩈᨸᨳᩮ ᩈᩣᨸᩮᩣ, ᨸᨦ᩠ᨠᩴ ᨸᩣᨸᩮ ᨧ ᨠᨴ᩠ᨴᨾᩮ.
ᨽᩮᩣᨣᩅᨲ᩠ᨿᩩ’ᩁᨣᩮ ᨽᩮᩣᨣᩦ, ᩔᩁᩮᩣ ᨲᩩ ᩈᩥᩅᩈᩣᨾᩥᩈᩩ;
ᨻᩃᩮ ᨸᨽᩣᩅᩮ ᩅᩦᩁᩥᨿᩴ, ᨲᩮᨩᩮᩣ ᨲᩮᩈᩩ ᨧ ᨴᩥᨲ᩠ᨲᩥᨿᩴ.
ᨵᩣᩁᩣ ᩈᨶ᩠ᨲᨲᩥ ᨡᨣ᩠ᨣᨦ᩠ᨣᩮ, ᩅᩣᨶᩴ ᨲᨱ᩠ᩉᩣᨿ ᩈᩥᨻ᩠ᨻᨶᩮ;
ᨡᨲ᩠ᨲᩣ ᩈᩪᨲᩮ ᨸᨭᩥᩉᩣᩁᩮ, ᩅᩥᨲ᩠ᨲᩥ ᨸᩦᩊᩣᩈᩩ ᩅᩮᨴᨶᩣ.
ᨳᩥᨿᩴ ¶ ᨾᨲᩥ’ᨧ᩠ᨨᩣᨸᨬ᩠ᨬᩣᩈᩩ, ᨸᩣᨸᩮ ᨿᩩᨴ᩠ᨵᩮ ᩁᩅᩮ ᩁᨱᩮᩣ;
ᩃᩅᩮᩣᨲᩩ ᨻᩥᨶ᩠ᨴᩩ’ᨧ᩠ᨨᩮᨴᩮᩈᩩ, ᨸᩃᩣᩃᩮ’ [ᨸᩃᩣᩈᩮ (ᨭᩦ.), ᨸᩃᩣᨸᩮ-ᨭᩦ (᪔᪕᪓-᪑᪑᪒᪔) ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨲᩥᩈᨿᩮ ᨽᩩᩈᩴ.
ᨻᩣᨵᩣ ᨴᩩᨠ᩠ᨡᩮ ᨶᩥᩈᩮᨵᩮ ᨧ, ᨾᩪᩃᨸᨴᩮᨸᩥ ᨾᩣᨲᩥᨠᩣ;
ᩈ᩠ᨶᩮᩉᩮᩣ ᨲᩮᩃᩮ’ᨵᩥᨠᨸ᩠ᨸᩮᨾᩮ,
ᨥᩁᩣ’ᨸᩮᨠ᩠ᨡᩣᩈᩩ ᩌᩃᨿᩮᩣ.
ᨠᩮᨲᩩᩈ᩠ᨾᩥᩴ ᨠᩮᨲᨶᩴ ᨣᩮᩉᩮ, ᨮᩣᨶᩮ ᨽᩪᨾᩥ’ᨲ᩠ᨳᩥᨿᩴ ᨽᩩᩅᩥ;
ᩃᩮᨡ᩠ᨿᩮ ᩃᩮᨡᩮᩣ ᩁᩣᨩᩥ ᩃᩮᨡᩣ, ᨸᩪᨩᩥᨲᩮ ᨽᨣᩅᩣ ᨩᩥᨶᩮ.
ᨣᨴᩣ ᩈᨲ᩠ᨳᩮ ᨣᨴᩮᩣ ᩁᩮᩣᨣᩮ, ᨶᩥᩈᨩ᩠ᨩᩣ ᨸᩦᨮᩮᩈ᩠ᩅᩣ’ᩈᨶᩴ;
ᨲᨳᩣᨣᨲᩮᩣ ᨩᩥᨶᩮ ᩈᨲ᩠ᨲᩮ,
ᨧᨿᩮ ᨴᩮᩉᩮ ᩈᨾᩩᩔᨿᩮᩣ.
ᨻᩥᩃᩴ ᨠᩮᩣᨭ᩠ᨮᩣᩈ ᨨᩥᨴ᩠ᨴᩮᩈᩩ, ᩅᨩ᩠ᨩᩴ ᨴᩮᩣᩈᩮ ᨧ ᨽᩮᩁᩥᨿᩴ;
ᨠᩣᩃᩮ ᨴᩦᨥᨬ᩠ᨩᩈᩮ’ᨴ᩠ᨵᩣᨶᩴ, ᩌᩃᩥᨿᩴ ᩈᩮᨲᩩ ᨠᩣᩁᨱᩮ.
ᩒᨠᩣᩈᩮᩣ ᨠᩣᩁᨱᩮ ᨴᩮᩈᩮ,
ᩈᨽᩣ ᨣᩮᩉᩮ ᨧ ᩈᩴᩈᨴᩮ;
ᨿᩪᨸᩮᩣ ᨳᨾ᩠ᨽᩮ ᨧ ᨸᩣᩈᩣᨴᩮ, ᩋᨿᨶᩴ ᨣᨾᨶᩮ ᨸᨳᩮ.
ᩋᨠ᩠ᨠᩮᩣ ᩁᩩᨠ᩠ᨡᨶ᩠ᨲᩁᩮ ᩈᩪᩁᩮ,
ᩋᩔᩮᩣ ᨠᩮᩣᨱᩮ ᩉᨿᩮᨸᩥ ᨧ;
ᩋᩴᩈᩮᩣ ᨡᨶ᩠ᨵᩮ ᨧ ᨠᩮᩣᨭ᩠ᨮᩣᩈᩮ,
ᨩᩣᩃᩴ ᩈᩪᩈ᩠ᩅ’ᨧ᩠ᨧᩥ ᨶᩮᩣ ᨸᩩᨾᩮ.
ᨶᩣᩈᩣ’ᩈᨲ᩠ᨲᩮᩈ᩠ᩅ’ ᨽᩣᩅᩮᩣ ᨳ,
ᩋᨶ᩠ᨶ ᨾᩮᩣᨴᨶ ᨽᩩᨲ᩠ᨲᩥᩈᩩ;
ᨩᩦᩅᩴ ᨸᩣᨶᩮ ᨩᨶᩮ ᨩᩦᩅᩮᩣ,
ᨥᩣᩈᩮᩣ ᨲ᩠ᩅ’ᨶ᩠ᨶᩮ ᨧ ᨽᨠ᩠ᨡᨱᩮ.
ᨨᨴᨶᩮ’ᨧ᩠ᨨᩣᨴᨶᩴ ᩅᨲ᩠ᨳᩮ, ᨶᩥᨠᩣᨿᩮᩣ ᨣᩮᩉᩁᩣᩈᩥᩈᩩ;
ᩋᨶ᩠ᨶᩣᨴᩮᩣ ᩌᨾᩥᩈᩴ ᨾᩴᩈᩮ; ᨴᩥᨠ᩠ᨡᩣ ᨲᩩ ᨿᨩᨶᩮ’ᨧ᩠ᨧᨶᩮ.
ᨠᩕᩥᨿᩣᨿᩴ ᨠᩣᩁᩥᨠᩣ ᨸᨩ᩠ᨩᩮ,
ᨠᩮᨲᩩ ᨲᩩ ᨧᩥᩉᨶᩮ ᨵᨩᩮ;
ᨠᩩᩈᩩᨾᩴ ᨳᩦᩁᨩᩮ ᨸᩩᨸ᩠ᨹᩮ, ᩅᩣᨶᩁᩮ ᨲᩩ ᨻᩩᨵᩮ ᨠᩅᩥ.
ᩋᨵᩁᩮ ¶ ᨡᩁᨽᩮ ᩒᨭ᩠ᨮᩮᩣ, ᩃᩩᨴ᩠ᨴᩮᩣ ᨲᩩ ᩃᩩᨴ᩠ᨴᨠᩮᨸᩥ ᨧ;
ᨠᩃᩩᩈᩴ ᨲ᩠ᩅᩣ’ᩅᩥᩃᩮ ᨸᩣᨸᩮ, ᨸᩣᨸᩮ ᨠᩃᩥ ᨸᩁᩣᨩᨿᩮ.
ᨠᨶ᩠ᨲᩣᩁᩮᩣ ᩅᨶ, ᨴᩩᨣ᩠ᨣᩮᩈᩩ, ᨧᩁᩮᩣ ᨧᩣᩁᨾ᩠ᩉᩥ ᨧᨬ᩠ᨧᩃᩮ;
ᨩᨶᩣᩅᩣᩈᩮ ᨣᨱᩮ ᨣᩣᨾᩮᩣ, ᨧᨾ᩠ᨾᩴ ᨲᩩ ᨹᩃᨠᩮ ᨲᨧᩮ.
ᩌᨾᩮᩣᨴᩮᩣ ᩉᩣᩈ ᨣᨶ᩠ᨵᩮᩈᩩ,
ᨧᩣᩁᩩ ᨲᩩ ᨠᨶᨠᩮᨸᩥ ᨧ;
ᩈᨲ᩠ᨲᩣᨿᩴ ᨽᩅᨶᩴ ᨣᩮᩉᩮ, ᩃᩮᩈᩮ ᨲᩩ ᨡᩃᩥᨲᩮ ᨨᩃᩴ.
ᩅᩮᩁᩴ ᨸᩣᨸᩮ ᨧ ᨸᨭᩥᨥᩮ, ᨲᨧᩮᩣ ᨧᨾ᩠ᨾᨶᩥ ᩅᨠ᩠ᨠᩃᩮ;
ᩏᨧ᩠ᨧᩮ’ᨵᩥᩁᩮᩣᩉᩮ ᩌᩁᩮᩣᩉᩮᩣ, ᨶᩮᨲ᩠ᨲᩴ ᩅᨲ᩠ᨳᨶ᩠ᨲᩁ’ᨠ᩠ᨡᩥᩈᩩ.
ᨸᨭᩥᩉᩣᩁᩮ ᨾᩩᨡᩮ ᨴ᩠ᩅᩣᩁᩴ, ᨸᩮᨲᩮ ᨬᩣᨲᩮ ᨾᨲᩮᩣ ᨲᩥᩈᩩ;
ᨾᩣᩈᩮᩣ ᨸᩁᨱ᩠ᨱ ᨠᩣᩃᩮᩈᩩ, ᨶᨣ᩠ᨣᩮᩣ ᨲ᩠ᩅ’ᨧᩮᩃᨠᩮᨸᩥ ᨧ.
ᨴᩮᩣᩈᩮ ᨥᩣᨲᩮ ᨧ ᨸᨭᩥᨥᩮᩣ, ᨾᩥᨣᩣᨴᩮᩣ ᨨᨣᩃᩮ ᨸᩈᩩ;
ᩋᩁᩪᨸᩮ ᨧᩣ’ᩅ᩠ᩉᨿᩮ ᨶᩣᨾᩴ, ᨴᩁᩮᩣ ᨴᩁᨳ ᨽᩦᨲᩥᩈᩩ.
ᨿᩣᨧᨶᩮ ᨽᩮᩣᨩᨶᩮ ᨽᩥᨠ᩠ᨡᩣ,
ᨽᩣᩁᩮ ᨲ᩠ᩅ’ᨲᩥᩈᨿᩮ ᨽᩁᩮᩣ;
ᨴᨻ᩠ᨻᩥ’ᨶ᩠ᨴᨩᩣᨿᩣᩈᩩ ᩈᩩᨩᩣ, ᨾᩮᨥᩮ ᨲ᩠ᩅ’ᨻ᩠ᨽᩴ ᩅᩥᩉᩣᨿᩈᩮ.
ᨾᩮᩣᨴᨠᩮᩣ ᨡᨩ᩠ᨩᨽᩮᨴᩮᨸᩥ, ᨾᨱᩥᨠᩮ ᩁᨲᨶᩮ ᨾᨱᩥ;
ᩈᩮᩃᩣ’ᩁᩣᨾᩮᩈᩩ ᨾᩃᨿᩮᩣ,
ᩈᨽᩣᩅ’ᨦ᩠ᨠᩮᩈᩩ ᩃᨠ᩠ᨡᨱᩴ.
ᩉᩅᩥ ᩈᨸ᩠ᨸᩥᨾ᩠ᩉᩥ ᩉᩮᩣᨲᨻ᩠ᨻᩮ, ᩈᩥᩁᩮᩣ ᩈᩮᨭ᩠ᨮᩮ ᨧ ᨾᩩᨴ᩠ᨵᨶᩥ;
ᩅᩥᨧᩣᩁᩮᨸᩥ ᩅᩥᩅᩮᨠᩮᩣ ᨳ, ᩈᩥᨡᩁᩦ ᨸᨻ᩠ᨻᨲᩮ ᨴᩩᨾᩮ.
ᩅᩮᨣᩮᩣ ᨩᩅᩮ ᨸᩅᩣᩉᩮ ᨧ, ᩈᨦ᩠ᨠᩩ ᨲᩩ ᨡᩥᩃᩉᩮᨲᩥᩈᩩ;
ᨶᩥᨣ᩠ᨣᩉᩦᨲᩮ ᨠᨱᩮ ᨻᩥᨶ᩠ᨴᩩ, ᩅᩁᩣᩉᩮᩣ ᩈᩪᨠᩁᩮ ᨣᨩᩮ.
ᨶᩮᨲ᩠ᨲᨶ᩠ᨲᩮ ᨧᩥᨲ᩠ᨲᨠᩮ’ᨸᩣᨦ᩠ᨣᩴ, ᩈᩥᨴ᩠ᨵᨲ᩠ᨳᩮᩣ ᩈᩣᩈᨸᩮ ᨩᩥᨶᩮ;
ᩉᩣᩁᩮᩣ ᨾᩩᨲ᩠ᨲᩣᨣᩩᨱᩮ ᨣᩣᩉᩮ,
ᨡᩣᩁᨠᩮᩣ ᨾᨠᩩᩊᩮ ᩁᩈᩮ.
ᩋᨧ᩠ᨧᨿᩮᩣ’ ᨲᩥᨠ᩠ᨠᨾᩮ ᨴᩮᩣᩈᩮ,
ᩈᩮᩃᩁᩩᨠ᩠ᨡᩮᩈ᩠ᩅ’ᨣᩮᩣ ᨶᨣᩮᩣ;
ᩈ᩠ᩅᨸ᩠ᨸᩮ’ᩅᨵᩣᩁᨱᩮ ᨾᨲ᩠ᨲᩴ, ᩋᨸᨧᩥᨲ᩠ᨿ’ᨧ᩠ᨧᨶᩮ ᨡᨿᩮ.
ᨨᩥᨴ᩠ᨴᩮᩣ’ᨲᩁᨱᩮᩈ᩠ᩅᩮᩣ’ᨲᩣᩁᩮᩣ,
ᨻᩕᩉ᩠ᨾᩮ ¶ ᨧ ᨩᨶᨠᩮ ᨸᩥᨲᩣ;
ᨸᩥᨲᩣᨾᩉᩮᩣ’ᨿ᩠ᨿᨠᩮ ᨻᩕᩉ᩠ᨾᩮ,
ᨸᩮᩣᨲᩮᩣ ᨶᩣᩅᩣᨿ ᨻᩣᩃᨠᩮ.
ᩁᩩᨠ᩠ᨡᩮ ᩅᨱ᩠ᨱᩮ ᩈᩩᨶᩮ ᩈᩮᩣᨱᩮᩣ,
ᩈᨣ᩠ᨣᩮ ᨲᩩ ᨣᨣᨶᩮ ᨴᩥᩅᩮᩣ;
ᩅᨲ᩠ᨳᩮ ᨣᨶ᩠ᨵᩮ ᨥᩁᩮ ᩅᩣᩈᩮᩣ, ᨧᩩᩃ᩠ᩃᩮᩣ ᨡᩩᨴ᩠ᨴᩮ ᨧ ᩏᨴ᩠ᨵᨶᩮ.
ᨠᨱ᩠ᨱᩮᩣ ᨠᩮᩣᨱᩮ ᨧ ᩈᩅᨱᩮ,
ᨾᩣᩃᩣ ᨸᩩᨸ᩠ᨹᩮ ᨧ ᨸᨶ᩠ᨲᩥᨿᩴ;
ᨽᩣᨣᩮᩣ ᨽᩣᨣ᩠ᨿᩮ’ᨠᨴᩮᩈᩮᩈᩩ,
ᨠᩩᨭ᩠ᨮᩴ ᩁᩮᩣᨣᩮ’ ᨩᨸᩣᩃᨠᩮ.
ᩈᩮᨿ᩠ᨿᩣ ᩈᩮᨶᩣᩈᨶᩮ ᩈᩮᨶᩮ, ᨧᩩᨶ᩠ᨴᨽᨱ᩠ᨯᨾ᩠ᩉᩥ ᨧ’ᨻ᩠ᨽᨾᩮᩣ;
ᩅᨲ᩠ᨳᩣᨴᩥᩃᩮᩣᨾᩴ’ᩈᩩ ᨠᩁᩮ, ᨶᩥᨸᩣᨲᩮᩣ ᨸᨲᨶᩮ’ᨻ᩠ᨿᨿᩮ.
ᩈᩣᨡᩣᨿᩴ ᩅᩥᨭᨸᩮᩣ ᨳᨾ᩠ᨽᩮ, ᩈᨲ᩠ᨲᩩ ᨡᨩ᩠ᨩᨶ᩠ᨲᩁᩮ ᨴᩥᩈᩮ;
ᩈᩣᨾᩥᨠᩮᩣ ᨸᨲᩥ’ᨿᩥᩁᩮᩈᩩ, ᨸᨭ᩠ᨮᩣᨶᩴ ᨣᨲᩥ ᩉᩮᨲᩩᩈᩩ.
ᩁᩣᨣᩮ ᩁᨦ᩠ᨣᩮᩣ ᨶᨧ᩠ᨧᨭ᩠ᨮᩣᨶᩮ, ᨸᩣᨶᩴ ᨸᩮᨿ᩠ᨿᩮ ᨧ ᨸᩦᨲᩥᨿᩴ;
ᩍᨱᩩ’ᨠ᩠ᨡᩮᨸᩮᩈᩩ ᩏᨴ᩠ᨵᩣᩁᩮᩣ, ᩏᨾ᩠ᨾᩣᩁᩮ ᩑᩊᨠᩮᩣ ᩋᨩᩮ.
ᨸᩉᩣᩁᩮᩣ ᨸᩮᩣᨳᨶᩮ ᨿᩣᨾᩮ,
ᩈᩁᨴᩮᩣ ᩉᩣᨿᨶᩮᩣ’ᨲᩩᩈᩩ;
ᨠᩩᨱ᩠ᨯᩥᨠᩣᨿᩣ’ᩊ᩠ᩉᨠᩮ ᨲᩩᨾ᩠ᨻᩮᩣ,
ᨸᩃᩣᩃᩮᩣ [ᨸᩃᩣᨸᩮᩣ (ᨠ.) ᪔᪕᪓-ᨣᩣᨳᩣ ᨸᩔᩥᨲᨻ᩠ᨻᩣ] ᨲᩩ ᨽᩩᩈᨾ᩠ᩉᩥ ᨧ.
ᨾᨲᩣ’ᩅᩣᨭᩮ ᨧᨿᩮ ᨠᩣᩈᩩ, ᨸᨶᩥᩈᩣ ᨠᩣᩁᨱᩮ ᩁᩉᩮᩣ;
ᨠᩣᩈᩮᩣ ᨸᩮᩣᨭᨣᩃᩮ ᩁᩮᩣᨣᩮ,
ᨴᩮᩣᩈᩮᩣ ᨠᩮᩣᨵᩮ ᨣᩩᨱᩮ’ᨲᩁᩮ.
ᨿᩩᨲ᩠ᨿ’ᨭ᩠ᨭᩣᩃ’ᨭ᩠ᨭᩥᨲᩮᩈ᩠ᩅ’ᨭ᩠ᨭᩮᩣ, ᨠᩦᩊᩣᨿᩴ ᨠᩣᨶᨶᩮ ᨴᩅᩮᩣ;
ᩏᨸ᩠ᨸᨲ᩠ᨲᩥᨿᩴ ᨧᩮᩣ’ᨸ᩠ᨸᨲᨶᩴ, ᩏᨿ᩠ᨿᩣᨶᩴ ᨣᨾᨶᩮ ᩅᨶᩮ.
ᩅᩮᩣᨠᩣᩁᩮᩣ ᩃᩣᨾᨠᩮ ᨡᨶ᩠ᨵᩮ, ᨾᩪᩃᩮᩣ’ᨸᨴᩣᩈᩩ ᨸᩣᨽᨲᩴ;
ᨴᩈᩣ’ ᩅᨲ᩠ᨳᩣ ᨸᨭᨶ᩠ᨲᩮᩈᩩ, ᨠᩣᩁᨱᩴ ᨥᩣᨲ, ᩉᩮᨲᩩᩈᩩ.
ᩉᨲ᩠ᨳᩥᨴᩣᨶᩮ ¶ ᨾᨴᩮᩣ ᨣᨻ᩠ᨻᩮ, ᨥᨭᩣ ᨥᨭᨶ ᩁᩣᩈᩥᩈᩩ;
ᩏᨸᩉᩣᩁᩮᩣ’ᨽᩥᩉᩣᩁᩮᨸᩥ, ᨧᨿᩮᩣ ᨻᨶ᩠ᨵᨶ ᩁᩣᩈᩥᩈᩩ.
ᨣᨶ᩠ᨵᩮᩣ ᨳᩮᩣᨠᩮ ᨥᩣᨿᨶᩦᨿᩮ,
ᨧᩣᨣᩮᩣ ᨲᩩ ᨴᩣᨶᩉᩣᨶᩥᩈᩩ;
ᨸᩣᨶᩮ ᨸᨾᩮᩣᨴᩮ ᨸᩦᨲᩥ’ᨲ᩠ᨳᩦ, ᩍᨱᩮ ᨣᩥᩅᩣ ᨣᩃᩮᨸᩥ ᨧ.
ᨸᨲᩥᨭ᩠ᨮᩣ ᨶᩥᩔᨿᩮ ᨮᩣᨶᩮ, ᨻᩃᨠ᩠ᨠᩣᩁᩮᨸᩥ ᩈᩣᩉᩈᩴ;
ᨽᨦ᩠ᨣᩮᩣ ᨽᩮᨴᩮ ᨸᨭᩮ ᨽᨦ᩠ᨣᩴ, ᨨᨲ᩠ᨲᩴ ᨲᩩ ᨨᩅᨠᩮᨸᩥ ᨧ.
ᨬᩣᨱᩮ ᨽᩩᩅᩥ ᨧ ᨽᩪᩁᩥ’ᨲ᩠ᨲᩦ, ᩋᨶᨦ᩠ᨣᩮ ᨾᨴᨶᩮᩣ ᨴᩩᨾᩮ;
ᨸᨾᩣᨲᩁᩥᨸᩥ ᨾᩣᨲᩣ ᨳ, ᩅᩮᨮᩩ’ᨱᩦᩈᩮᩈᩩ ᩅᩮᨮᨶᩴ.
ᨾᩣᩁᩥᩈᩮᩣ ᨲᨱ᩠ᨯᩩᩃᩮᨿ᩠ᨿᩮ’ᨿ᩠ᨿᩮ,
ᨾᩮᩣᨠ᩠ᨡᩮᩣ ᨶᩥᨻ᩠ᨻᩣᨶ ᨾᩩᨲ᩠ᨲᩥᩈᩩ;
ᩍᨶ᩠ᨴᩮᩣ’ᨵᩥᨸᨲᩥ ᩈᨠ᩠ᨠᩮᩈ᩠ᩅᩣ, ᩁᨾ᩠ᨾᨱᩴ ᩉᩮᨲᩩ ᨣᩮᩣᨧᩁᩮ.
ᩋᨦ᩠ᨠᩮ ᩈᨱ᩠ᨮᩣᨶ ᨾᩣᨠᩣᩁᩮ,
ᨡᩮᨲ᩠ᨲᩮ [ᩅᨸ᩠ᨸᩮ (ᨸᩣᨠᩣᩁᨾᩪᩃᩮ ᨶᩮᨲ᩠ᨲᨩᩃᩮ ᩏᩈᩩᨾᩮ ᨧ ᩅᨸ᩠ᨸᩮᩣ-ᨭᩦ)] ᩅᨸ᩠ᨸᩮᩣ ᨲᨭᩮᨸᩥ ᨧ;
ᩈᨾ᩠ᨾᩩᨲ᩠ᨿ’ᨶᩩᨬ᩠ᨬᩣ ᩅᩮᩣᩉᩣᩁᩮ, ᩈ᩠ᩅ’ᨳ ᩃᩣᨩᩣᩈᩩ ᨧᩣ’ᨠ᩠ᨡᨲᩴ.
ᩈᨲᩕᩴ ᨿᩣᨣᩮ ᩈᨴᩣᨴᩣᨶᩮ,
ᩈᩮᩣᨾᩮᩣ ᨲᩩ ᩒᩈᨵᩥ’ᨶ᩠ᨴᩩᩈᩩ;
ᩈᨦ᩠ᨥᩣᨲᩮᩣ ᨿᩩᨣᨣᩮᩉᨦ᩠ᨣᩮ, ᨡᩣᩁᩮᩣ ᩐᩈᩮ ᨧ ᨽᩈ᩠ᨾᨶᩥ.
ᩌᨲᩣᨸᩮᩣ ᩅᩦᩁᩥᨿᩮ ᨲᩣᨸᩮ,
ᨽᩣᨣᩮ ᩈᩦᨾᩣᨿ ᩒᨵᩥ ᨧᩣᨲᩥ.
ᩍᨲᩥ ᨸᩣᨴᩣᨶᩮᨠᨲ᩠ᨳᩅᨣ᩠ᨣᩮᩣ.
ᩋᨶᩮᨠᨲ᩠ᨳᩅᨣ᩠ᨣᩮᩣ ᨶᩥᨭ᩠ᨮᩥᨲᩮᩣ.
᪓. ᩈᩣᨾᨬ᩠ᨬᨠᨱ᩠ᨯ
᪔. ᩋᨻ᩠ᨿᨿᩅᨣ᩠ᨣ
ᩋᨻ᩠ᨿᨿᩴ ᩅᩩᨧ᩠ᨧᨲᩮ ᨴᩣᨶᩥ, ᨧᩥᩁᩔᩴ ᨲᩩ ᨧᩥᩁᩴ ᨲᨳᩣ;
ᨧᩥᩁᩮᨶ ᨧᩥᩁᩁᨲ᩠ᨲᩣᨿ, ᩈᩉ ᩈᨴ᩠ᨵᩥᩴ ᩈᨾᩴ ᩋᨾᩣ.
ᨸᩩᨶᨸ᩠ᨸᩩᨶᩴ ¶ ᩋᨽᩥᨱ᩠ᩉᨬ᩠ᨧᩣ, ᩈᨠᩥᩴ ᨧᩣ’ᨽᩥᨠ᩠ᨡᨱᩴ ᨾᩩᩉᩩᩴ;
ᩅᨩ᩠ᨩᨶᩮ ᨲᩩ ᩅᩥᨶᩣ ᨶᩣᨶᩣ, ᩋᨶ᩠ᨲᩁᩮᨶ ᩁᩥᨲᩮ ᨸᩩᨳᩩ.
ᨻᩃᩅᩴ ᩈᩩᨭ᩠ᨮᩩ ᨧᩣ’ᨲᩦᩅᩣ, ᨲᩥᩈᨿᩮ ᨠᩥᨾᩩᨲ ᩈ᩠ᩅ’ᨲᩥ;
ᩋᩉᩮᩣ ᨲᩩ ᨠᩥᩴ ᨠᩥᨾᩪ’ ᨴᩣᩉᩩ, ᩅᩥᨠᨸ᩠ᨸᩮ ᨠᩥᨾᩩᨲᩮᩣ’ᨴ ᨧ.
ᩋᩅ᩠ᩉᩣᨶᩮ ᨽᩮᩣ ᩋᩁᩮ ᩋᨾ᩠ᨽᩮᩣ,
ᩉᨾ᩠ᨽᩮᩣ ᩁᩮ ᨩᩮ’ᨦ᩠ᨣ ᩌᩅᩩᩈᩮᩣ;
ᩉᩮ ᩉᩁᩮ ᨳ ᨠᨳᩴ ᨠᩥᩴᩈᩩ, ᨶᨶᩩ ᨠᨧ᩠ᨧᩥ ᨶᩩ ᨠᩥᩴ ᩈᨾᩣ.
ᩋᨵᩩᨶᩮ’ᨲᩁᩉᩦ’ᨴᩣᨶᩥ, ᩈᨾ᩠ᨸᨲᩥ ᩋᨬ᩠ᨬᨴᨲ᩠ᨳᩩ ᨲᩩ;
ᨲᨣ᩠ᨥᩮ’ ᨠᩴᩈᩮ ᩈᩈᨠ᩠ᨠᨬ᩠ᨧᩣ, ᨴ᩠ᨵᩣ ᨠᩣᨾᩴ ᨩᩣᨲᩩ ᩅᩮ ᩉᩅᩮ.
ᨿᩣᩅᨲᩣ ᨲᩣᩅᨲᩣ ᨿᩣᩅ, ᨲᩣᩅ ᨠᩥᨲ᩠ᨲᩣᩅᨲᩣ ᨲᨳᩣ;
ᩑᨲ᩠ᨲᩣᩅᨲᩣ ᨧ ᨠᩦᩅᩮ’ᨲᩥ, ᨸᩁᩥᨧ᩠ᨨᩮᨴᨲ᩠ᨳᩅᩣᨧᨠᩣ.
ᨿᨳᩣ ᨲᨳᩣ ᨿᨳᩮᩅᩮ’ᩅᩴ, ᨿᨳᩣᨶᩣᨾ ᨿᨳᩣᩉᩥ ᨧ;
ᩈᩮᨿ᩠ᨿᨳᩣᨸ᩠ᨿᩮ’ᩅᨾᩮᩅᩴ, ᩅᩣ, ᨲᨳᩮᩅ ᨧ ᨿᨳᩣᨸᩥ ᨧ.
ᩑᩅᨾ᩠ᨸᩥ ᨧ ᩈᩮᨿ᩠ᨿᨳᩣᨸᩥ, ᨶᩣᨾ ᨿᨳᩁᩥᩅᩣ’ᨸᩥ ᨧ;
ᨸᨭᩥᨽᩣᨣᨲ᩠ᨳᩮ ᨿᨳᩣᨧ, ᩅᩥᨿ ᨲᨳᩁᩥᩅᩣ’ᨸᩥ ᨧ.
ᩈᩴ ᩈᩣᨾᨬ᩠ᨧ ᩈᨿᩴ ᨧᩣᨳ, ᩌᨾ ᩈᩣᩉᩩ ᩃᩉᩪ’ᨸᩥ ᨧ;
ᩒᨸᩣᨿᩥᨠᩴ ᨸᨲᩥᩁᩪᨸᩴ, ᩈᩣᨵ᩠ᩅᩮ’ᩅᩴ ᩈᨾ᩠ᨸᨭᩥᨧ᩠ᨨᨶᩮ.
ᨿᩴ ᨲᩴ ᨿᨲᩮᩣ ᨲᨲᩮᩣ ᨿᩮᨶ,
ᨲᩮᨶᩮ’ᨲᩥ ᨠᩣᩁᨱᩮ ᩈᩥᨿᩩᩴ;
ᩋᩈᩣᨠᩃ᩠ᨿᩮ ᨲᩩ ᨧᨶ ᨧᩥ, ᨶᩥᨸ᩠ᨹᩃᩮ ᨲᩩ ᨾᩩᨵᩣ ᨽᩅᩮ.
ᨠᨴᩣᨧᩥ ᨩᩣᨲᩩ ᨲᩩᩃ᩠ᨿᩣ’ᨳ, ᩈᨻ᩠ᨻᨲᩮᩣ ᨧ ᩈᨾᨶ᩠ᨲᨲᩮᩣ;
ᨸᩁᩥᨲᩮᩣ ᨧ ᩈᨾᨶ᩠ᨲᩣᨸᩥ, ᩋᨳ ᨾᩥᨧ᩠ᨨᩣ ᨾᩩᩈᩣ ᨽᩅᩮ.
ᨶᩥᩈᩮᨵᩮ ᨶ ᩋᨶᩮᩣᨾᩣ’ᩃᩴ, ᨶᩉᩥ ᨧᩮᨲᩩ ᩈᨧᩮ ᨿᨴᩥ;
ᩋᨶᩩᨠᩩᩃ᩠ᨿᩮ ᨲᩩ ᩈᨴ᩠ᨵᨬ᩠ᨧ,
ᨶᨲ᩠ᨲᩴ [ᩁᨲ᩠ᨲᩴ (ᨭᩦ.)] ᨴᩮᩣᩈᩮᩣ ᨴᩥᩅᩣ ᨲ᩠ᩅ’ᩉᩮ.
ᩎᩈᩴ ᨠᩥᨬ᩠ᨧᩥ ᨾᨶᩴ ᩋᨸ᩠ᨸᩮ, ᩈᩉᩈᩣ ᨲᩩ ᩋᨲᨠ᩠ᨠᩥᨲᩮ;
ᨸᩩᩁᩮ ᨣ᩠ᨣᨲᩮᩣ ᨲᩩ ᨸᩩᩁᨲᩮᩣ, ᨸᩮᨧ᩠ᨧᩣ’ᨾᩩᨲᩕᨽᩅᨶ᩠ᨲᩁᩮ.
ᩋᩉᩮᩣ ¶ ᩉᩦ ᩅᩥᨾ᩠ᩉᨿᩮ ᨲᩩᨱ᩠ᩉᩦ,
ᨲᩩ ᨾᩮᩣᨶᩮ ᨳᩣ’ᩅᩥ ᨸᩣᨲᩩ ᨧ;
ᨲᨦ᩠ᨡᨱᩮ ᩈᨩ᩠ᨩᩩ ᩈᨸᨴᩥ, ᨻᩃᨠ᩠ᨠᩣᩁᩮ ᨸᩈᨿ᩠ᩉ ᨧ.
ᩈᩩᨴᩴ ᨡᩮᩣ [ᩅᩮᩣ (ᨠ.)] ᩋᩔᩩ ᨿᨣ᩠ᨥᩮ ᩅᩮ,ᩉᩣ’ᨴᨿᩮᩣ ᨸᨴᨸᩪᩁᨱᩮ;
ᩋᨶ᩠ᨲᩁᩮᨶ’ᨶ᩠ᨲᩁᩣ ᩋᨶ᩠ᨲᩮᩣ, ᩅᩔᩴ ᨶᩪᨶ ᨧ ᨶᩥᨧ᩠ᨨᨿᩮ.
ᩌᨶᨶ᩠ᨴᩮ ᩈᨬ᩠ᨧ ᨴᩥᨭ᩠ᨮᩣ ᨳ, ᩅᩥᩁᩮᩣᨵᨠᨳᨶᩮ ᨶᨶᩩ;
ᨠᩣᨾᨸ᩠ᨸᩅᩮᨴᨶᩮ ᨠᨧ᩠ᨧᩥ, ᩏᩈᩪᨿᩮᩣᨸᨣᨾᩮ’ᨲ᩠ᨳᩩ ᨧ.
ᩑᩅᩣ’ᩅᨵᩣᩁᨱᩮ ᨬᩮᨿ᩠ᨿᩴ, ᨿᨳᩣᨲ᩠ᨲᩴ ᨲᩩ ᨿᨳᩣᨲᨳᩴ;
ᨶᩦᨧᩴ ᩋᨸ᩠ᨸᩮ, ᨾᩉᨲ᩠ᨿᩩ’ᨧ᩠ᨧᩴ, ᩋᨳ ᨸᩣᨲᩮᩣ ᨸᨣᩮ ᩈᨾᩣ.
ᨶᩥᨧ᩠ᨧᩮ ᩈᨴᩣ ᩈᨶᩴ [ᩈᨶᩣ (ᨠ.)] ᨸᩣᨿᩮᩣ,
ᨻᩣᩉᩩᩃ᩠ᨿᩮ ᨻᩣᩉᩥᩁᩴ ᨻᩉᩥ;
ᨻᩉᩥᨴ᩠ᨵᩣ ᨻᩣᩉᩥᩁᩣ ᨻᩣᩉ᩠ᨿᩮ, ᩈᩦᨥᩮᨲᩩ ᩈᨱᩥᨠᩴ ᨽᩅᩮ.
ᩋᨲ᩠ᨳᩴ ᩋᨴᩔᨶᩮ ᨴᩩᨭ᩠ᨮᩩ, ᨶᩥᨶ᩠ᨴᩣᨿᩴ, ᩅᨶ᩠ᨴᨶᩮ ᨶᨾᩮᩣ;
ᩈᨾ᩠ᨾᩣ ᩈᩩᨭ᩠ᨮᩩ ᨸᩈᩴᩈᩣᨿᩴ, ᩋᨳᩮᩣ ᩈᨲ᩠ᨲᩣᨿ ᨾᨲ᩠ᨳᩥ ᨧ.
ᩈᩣᨿᩴ ᩈᩣᨿᩮ’ᨩ᩠ᨩ ᩋᨲᩕᩣ’ᩉᩮ,
ᩈᩩᩅᩮ ᨲᩩ ᩈ᩠ᩅᩮ ᩋᨶᩣᨣᨲᩮ;
ᨲᨲᩮᩣ ᨸᩁᩮ ᨸᩁᩈᩩᩅᩮ, ᩉᩥᨿ᩠ᨿᩮᩣᨲᩩ ᨴᩥᩅᩈᩮ ᨣᨲᩮ.
ᨿᨲ᩠ᨳ ᨿᨲᩕ ᨿᩉᩥᩴᨧᩣᨳ, ᨲᨲ᩠ᨳ ᨲᨲᩕ ᨲᩉᩥᩴᨲᩉᩴ;
ᩋᨳᩮᩣ ᩏᨴ᩠ᨵᨬ᩠ᨧ ᩏᨸᩁᩥ, ᩉᩮᨭ᩠ᨮᩣ ᨲᩩ ᨧ ᩋᨵᩮᩣ ᩈᨾᩣ.
ᨧᩮᩣᨴᨶᩮ ᩍᨦ᩠ᨥ ᩉᨶ᩠ᨴᩣ’ᨳ, ᩌᩁᩣᨴᩪᩁᩣ ᨧ ᩌᩁᨠᩣ;
ᨸᩁᨾ᩠ᨾᩩᨡᩣ ᨲᩩ ᨧ ᩁᩉᩮᩣ, ᩈᨾ᩠ᨾᩩᨡᩣ ᨲ᩠ᩅᩣ’ᩅᩥ ᨸᩣᨲᩩ ᨧ.
ᩈᩴᩈᨿᨲ᩠ᨳᨾ᩠ᩉᩥ ᩋᨸ᩠ᨸᩮᩅ, ᩋᨸ᩠ᨸᩮᩅᨶᩣᨾ ᨶᩪ’ᨲᩥ ᨧ;
ᨶᩥᨴᩔᨶᩮ ᩍᨲᩥ’ᨲ᩠ᨳᨬ᩠ᨧ, ᩑᩅᩴ, ᨠᩥᨧ᩠ᨨᩮ ᨠᨳᨬ᩠ᨧᩥ ᨧ.
ᩉᩣ ᨡᩮᨴᩮ ᩈᨧ᩠ᨨᩥ ᨸᨧ᩠ᨧᨠ᩠ᨡᩮ,
ᨵᩩᩅᩴ ᨳᩥᩁᩮ’ᩅᨵᩣᩁᨱᩮ;
ᨲᩥᩁᩮᩣ ᨲᩩ ᨲᩥᩁᩥᨿᩴ ᨧᩣᨳ, ᨠᩩᨧ᩠ᨨᩣᨿᩴ ᨴᩩᨭ᩠ᨮᩩ ᨠᩩ’ᨧ᩠ᨧᨲᩮ.
ᩈᩩᩅᨲ᩠ᨳᩥ ᩌᩈᩥᨭ᩠ᨮᨲ᩠ᨳᨾ᩠ᩉᩥ, ᨶᩥᨶ᩠ᨴᩣᨿᩴ ᨲᩩ ᨵᩦ [ᨵᩥ (ᨠ.)] ᨠᨳ᩠ᨿᨲᩮ;
ᨠᩩᩉᩥᨬ᩠ᨧᨶᩴ ᨠᩩᩉᩥᩴ ᨠᩩᨲᩕ, ᨠᩩᨲ᩠ᨳ ᨠᨲ᩠ᨳ ᨠᩉᩴ ᨠ᩠ᩅ ᨳ.
ᩍᩉᩮ’ᨵᩣ’ᨲᩕ ¶ ᨲᩩ ᩑᨲ᩠ᨳᩣ’ᨲ᩠ᨳ,
ᩋᨳ ᩈᨻ᩠ᨻᨲᩕ ᩈᨻ᩠ᨻᨵᩥ;
ᨠᨴᩣ ᨠᩩᨴᩣᨧᨶᩴ ᨧᩣᨳ, ᨲᨴᩣᨶᩥ ᨧ ᨲᨴᩣ ᩈᨾᩣ.
ᩌᨴᩥᨠᨾ᩠ᨾᩮ ᨽᩩᩈᨲ᩠ᨳᩮ ᨧ, ᩈᨾ᩠ᨽᩅᩮᩣ’ᨲᩥᨱ᩠ᨱ ᨲᩥᨲ᩠ᨲᩥᩈᩩ;
ᨶᩥᨿᩮᩣᨣᩥ’ᩔᩁᩥᨿ’ᨸ᩠ᨸᩦᨲᩥ, ᨴᩣᨶ ᨸᩪᨩᩣ’ᨣ᩠ᨣ, ᩈᨶ᩠ᨲᩥᩈᩩ.
ᨴᩔᨶᩮ ᨲᨸ᩠ᨸᩁᩮ ᩈᨦ᩠ᨣᩮ, ᨸᩈᩴᩈᩣ, ᨣᨲᩥ, ᩈᩩᨴ᩠ᨵᩥᩈᩩ;
ᩉᩥᩴᩈᩣ, ᨸᨠᩣᩁᨶ᩠ᨲᩮᩣ’ᨽᩣᩅ, ᩅᩥᨿᩮᩣᨣᩣ’ᩅᨿᩅᩮᩈᩩ ᨧ;
ᨸᩮᩣ’ᨸᩈᨣ᩠ᨣᩮᩣ ᨴᩥᩈᩣᨿᩮᩣᨣᩮ, ᨸᨲ᩠ᨳᨶᩣ, ᨵᩥᨲᩥᩌᨴᩥᩈᩩ.
ᨸᩁᩣᩈᨴ᩠ᨴᩮᩣ ᨸᩁᩥᩉᩣᨶᩥ, ᨸᩁᩣᨩᨿ ᨣᨲᩦᩈᩩ ᨧ;
ᨽᩩᩈᨲ᩠ᨳᩮ ᨸᨭᩥᩃᩮᩣᨾᨲ᩠ᨳᩮ, ᩅᩥᨠ᩠ᨠᨾᩣ’ᨾᩈᨶᩣᨴᩥᩈᩩ.
ᨶᩥᩔᩮᩈᩣ’ᨽᩣᩅ ᩈᨶ᩠ᨿᩣᩈ, ᨽᩩᩈᨲ᩠ᨳ ᨾᩮᩣᨠ᩠ᨡ ᩁᩣᩈᩥᩈᩩ;
ᨣᩮᩉᩣ’ᨴᩮᩈᩮᩣ’ᨸᨾᩣᩉᩦᨶ, ᨸᩈᩣᨴᨶᩥᨣ᩠ᨣᨲᩣ’ᨧ᩠ᨧᨿᩮ.
ᨴᩔᨶᩮᩣ’ᩈᩣᨶᨶᩥᨠ᩠ᨡᨶ᩠ᨲᩣ, ᨵᩮᩣᨽᩣᨣᩮᩈ᩠ᩅ’ᩅᨵᩣᩁᨱᩮ;
ᩈᩣᨾᩦᨸ᩠ᨿᩮ ᨻᨶ᩠ᨵᨶᩮ ᨨᩮᨠ, ᨶ᩠ᨲᩮᩣᨽᩣᨣᩮᩣ’ᨸᩁᨲᩦᩈᩩ ᨧ.
ᨸᩣᨲᩩᨽᩣᩅᩮ ᩅᩥᨿᩮᩣᨣᩮ ᨧ, ᨶᩥᩈᩮᨵᩣᨴᩮᩣ ᨶᩥ ᨴᩥᩔᨲᩥ;
ᩋᨳᩮᩣ ᨶᩦᩉᩁᨱᩮ ᨧᩮᩅᩣ, ᩅᩁᨱᩣᨴᩮᩣ ᨧ ᨶᩦ ᩈᩥᨿᩣ.
ᩏᨴ᩠ᨵᨠᨾ᩠ᨾ ᩅᩥᨿᩮᩣᨣ ᨲ᩠ᨲ, ᩃᩣᨽ ᨲᩥᨲ᩠ᨲᩥ ᩈᨾᩥᨴ᩠ᨵᩥᩈᩩ;
ᨸᩣᨲᩩᨽᩣᩅ’ᨧ᩠ᨧᨿᩣᨽᩣᩅ, ᨸᨻᩃᨲ᩠ᨲᩮ ᨸᨠᩣᩈᨶᩮ;
ᨴᨠ᩠ᨡ’ᨣ᩠ᨣᨲᩣᩈᩩ ᨠᨳᨶᩮ, ᩈᨲ᩠ᨲᩥᨾᩮᩣᨠ᩠ᨡᩣᨴᩥᨠᩮ ᩏ ᨧ.
ᨴᩩ ᨠᩩᨧ᩠ᨨᩥᨲᩮ’ᩈᨴᨲ᩠ᨳᩮᩈᩩ, ᩅᩥᩁᩪᨸᨲ᩠ᨲᩮ ᨸ᩠ᨿ’ᩈᩮᩣᨽᨶᩮ;
ᩈᩥᨿᩣ’ᨽᩣᩅᩣ’ᩈᨾᩥᨴ᩠ᨵᩦᩈᩩ, ᨠᩥᨧ᩠ᨨᩮ ᨧᩣ’ᨶᨶ᩠ᨴᨶᩣᨴᩥᨠᩮ.
ᩈᩴ ᩈᨾᩮᩣᨵᩣᨶ ᩈᨦ᩠ᨡᩮᨸ, ᩈᨾᨶ᩠ᨲᨲ᩠ᨲ ᩈᨾᩥᨴ᩠ᨵᩥᩈᩩ;
ᩈᨾ᩠ᨾᩣ ᨽᩩᩈ ᩈᩉ ᨸ᩠ᨸᨲ᩠ᨳᩣ, ᨽᩥᨾᩩᨡᨲ᩠ᨳᩮᩈᩩ ᩈᨦ᩠ᨣᨲᩮ;
ᩅᩥᨵᩣᨶᩮ ᨸᨽᩅᩮ ᨸᩪᨩᩣ, ᨸᩩᨶᨸ᩠ᨸᩩᨶᨠᩕᩥᨿᩣᨴᩥᩈᩩ.
ᩅᩥᩅᩥᨵᩣ’ᨲᩥᩈᨿᩣ’ᨽᩣᩅ, ᨽᩩᩈᨲ᩠ᨲᩥ’ᩔᩁᩥᨿᩣ’ᨧ᩠ᨧᨿᩮ;
ᩅᩥᨿᩮᩣᨣᩮ ᨠᩃᩉᩮ ᨸᩣᨲᩩ, ᨽᩣᩅᩮ ᨽᩣᩈᩮ ᨧ ᨠᩩᨧ᩠ᨨᨶᩮ.
ᨴᩪᩁᩣ’ᨶᨽᩥᨾᩩᨡᨲ᩠ᨲᩮᩈᩩ, ᨾᩮᩣᩉᩣ’ᨶᩅᨭ᩠ᨮᩥᨲᩦᩈᩩ ᨧ;
ᨸᨵᩣᨶ ᨴᨠ᩠ᨡᨲᩣ ᨡᩮᨴ, ᩈᩉᨲ᩠ᨳᩣᨴᩮᩣ ᩅᩥ ᨴᩥᩔᨲᩥ.
ᩅᩥᨿᩮᩣᨣᩮ ¶ ᨩᩣᨶᨶᩮ ᨧᩣ’ᨵᩮᩣ,ᨽᩣᨣ ᨶᩥᨧ᩠ᨨᨿ [ᨽᩣᨣ’ᨶᩥᨧ᩠ᨨᨿ (ᨽᩣᨣ+ᩋᨶᩥᨧ᩠ᨨᨿ-ᨭᩦ)] ᩈᩩᨴ᩠ᨵᩥᩈᩩ;
ᩎᩈᨴᨲ᩠ᨳᩮ ᨸᩁᩥᨽᩅᩮ, ᨴᩮᩈ ᨻ᩠ᨿᩣᨸᨶ ᩉᩣᨶᩥᩈᩩ;
ᩅᨧᩮᩣᨠᩕᩥᨿᩣᨿ ᨳᩮᨿ᩠ᨿᩮ ᨧ, ᨬᩣᨱᨸ᩠ᨸᨲ᩠ᨲᩣᨴᩥᨠᩮ ᩋᩅ.
ᨸᨧ᩠ᨨᩣ ᨽᩩᩈᨲ᩠ᨲ ᩈᩣᨴᩥᩈ᩠ᨿᩣ, ᨶᩩᨸᨧ᩠ᨨᩥᨶ᩠ᨶᩣ’ᨶᩩᩅᨲ᩠ᨲᩥᩈᩩ;
ᩉᩦᨶᩮ ᨧ ᨲᨲᩥᨿᨲ᩠ᨳᩣ’ᨵᩮᩣ, ᨽᩣᨣᩮᩈ᩠ᩅ’ᨶᩩᨣᨲᩮ ᩉᩥᨲᩮ;
ᨴᩮᩈᩮ ᩃᨠ᩠ᨡᨱ ᩅᩥᨧ᩠ᨨᩮ’ᨲ᩠ᨳ, ᨾ᩠ᨽᩪᨲ ᨽᩣᨣᩣᨴᩥᨠᩮ ᩋᨶᩩ.
ᩈᨾᨶ᩠ᨲᨲ᩠ᨳᩮ ᨸᩁᩥᨧ᩠ᨨᩮᨴᩮ, ᨸᩪᨩᩣ’ᩃᩥᨦ᩠ᨣᨶ ᩅᨩ᩠ᨩᨶᩮ;
ᨴᩮᩣᩈᨠ᩠ᨡᩣᨶᩮ ᨶᩥᩅᩣᩈᨶᩣ, ᩅᨬ᩠ᨬᩣ’ᨵᩣᩁᩮᩈᩩ ᨽᩮᩣᨩᨶᩮ;
ᩈᩮᩣᨠ ᨻ᩠ᨿᩣᨸᨶ ᨲᨲ᩠ᩅᩮᩈᩩ, ᩃᨠ᩠ᨡᨱᩣᨴᩮᩣ ᩈᩥᨿᩣ ᨸᩁᩥ.
ᩌᨽᩥᨾᩩᨡ᩠ᨿ ᩅᩥᩈᩥᨭ᩠ᨮᩩ’ᨴ᩠ᨵ, ᨠᨾ᩠ᨾᩈᩣᩁᩩᨸ᩠ᨸᩅᩩᨴ᩠ᨵᩥᩈᩩ;
ᨸᩪᨩᩣ’ᨵᩥᨠ ᨠᩩᩃᩣ’ᩈᨧ᩠ᨧ, ᩃᨠ᩠ᨡᨱᩣᨴᩥᨾ᩠ᩉᩥ ᨧᩣᨸ᩠ᨿ’ᨽᩥ.
ᩋᨵᩥᨠᩥ’ᩔᩁ, ᨸᩣᨮᩣ’ᨵᩥ, ᨭ᩠ᨮᩣᨶ, ᨸᩣᨸᩩᨱᨶᩮᩈ᩠ᩅ’ᨵᩥ;
ᨶᩥᨧ᩠ᨨᨿᩮ ᨧᩮᩣᨸᩁᩥᨲ᩠ᨲᩣ’ᨵᩥ, ᨽᩅᨶᩮ ᨧ ᩅᩥᩈᩮᩈᨶᩮ.
ᨸᨭᩥᨴᩣᨶᨶᩥᩈᩮᨵᩮᩈᩩ, ᩅᩣᨾᩣ’ᨴᩣᨶᨶᩥᩅᨲ᩠ᨲᩥᩈᩩ;
ᩈᩣᨴᩥᩈᩮ ᨸᨭᩥᨶᩥᨵᩥᨾ᩠ᩉᩥ, ᩌᨽᩥᨾᩩᨡ᩠ᨿᨣᨲᩦᩈᩩ ᨧ.
ᨸᨲᩥᨻᩮᩣᨵᩮ ᨸᨲᩥᨣᨲᩮ, ᨲᨳᩣ ᨸᩩᨶᨠᩕᩥᨿᩣᨿ ᨧ;
ᩈᨾ᩠ᨽᩣᩅᨶᩮ ᨸᨭᩥᨧ᩠ᨧᨲ᩠ᨳᩮ, ᨸᨲᩦᨲᩥ ᩃᨠ᩠ᨡᨱᩣᨴᩥᨠᩮ;
ᩈᩩ ᩈᩮᩣᨽᨶᩮ ᩈᩩᨡᩮ ᩈᨾ᩠ᨾᩣ, ᨽᩩᩈ ᩈᩩᨭ᩠ᨮᩩ ᩈᨾᩥᨴ᩠ᨵᩥᩈᩩ.
ᩌᨽᩥᨾᩩᨡ᩠ᨿ, ᩈᨾᩦᨸᩣ’ᨴᩥ, ᨠᨾ᩠ᨾᩣ’ᩃᩥᨦ᩠ᨣᨶ ᨸᨲ᩠ᨲᩥᩈᩩ;
ᨾᩁᩥᨿᩣᨴᩩ’ᨴ᩠ᨵᨠᨾ᩠ᨾᩥ’ᨧ᩠ᨨᩣ, ᨻᨶ᩠ᨵᨶᩣ’ᨽᩥᩅᩥᨵᩦᩈᩩ ᩌ.
ᨶᩥᩅᩣᩈᩣ’ᩅ᩠ᩉᩣᨶ ᨣᩉᨱ, ᨠᩥᨧ᩠ᨨᩮ’ᩈᨲ᩠ᨳ ᨶᩥᩅᨲ᩠ᨲᩥᩈᩩ;
ᩋᨸ᩠ᨸᩈᩣᨴᩣ’ᩈᩥ ᩈᩁᨱ, ᨸᨲᩥᨭ᩠ᨮᩣ’ᩅᩥᨾ᩠ᩉᨿᩣᨴᩥᩈᩩ.
ᩋᨶ᩠ᨲᩮᩣᨽᩣᩅ ᨽᩩᩈᨲ᩠ᨲᩣ’ᨲᩥ, ᩈᨿ ᨸᩪᨩᩣᩈ᩠ᩅ’ᨲᩥᨠ᩠ᨠᨾᩮ;
ᨽᩪᨲᨽᩣᩅᩮ ᨸᩈᩴᩈᩣᨿᩴ, ᨴᩊ᩠ᩉᨲ᩠ᨳᩣᨴᩮᩣ ᩈᩥᨿᩣ ᩋᨲᩥ.
ᩈᨾ᩠ᨽᩣᩅᨶᩮ ᨧ ᨣᩁᩉᩣ, ᨸᩮᨠ᩠ᨡᩣᩈᩩ ᨧ ᩈᨾᩩᨧ᩠ᨧᨿᩮ;
ᨸᨬ᩠ᩉᩮ ᩈᩴᩅᩁᨱᩮ ᨧᩮᩅ, ᩌᩈᩦᩈᨲ᩠ᨳᩮ ᩋᨸᩦ’ᩁᩥᨲᩴ.
ᨶᩥᨴ᩠ᨴᩮᩈᩮ ᩅᨩ᩠ᨩᨶᩮ ᨸᩪᨩᩣ, ᨸᨣᨲᩮ ᩅᩣᩁᨱᩮᨸᩥ ᨧ;
ᨸᨴᩩᩔᨶᩮ ᨧ ᨣᩁᩉᩣ, ᨧᩮᩣᩁᩥᨠᩣ’ᨴᩮᩣ ᩈᩥᨿᩣ ᩋᨸ.
ᩈᨾᩦᨸᨸᩪᨩᩣ ¶ ᩈᩣᨴᩥᩔ, ᨴᩮᩣᩈᨠ᩠ᨡᩣᨶᩮᩣ’ᨸᨸᨲ᩠ᨲᩥᩈᩩ;
ᨽᩩᩈᨲ᩠ᨲᩮᩣ’ᨸᨣᨾᩣ’ᨵᩥᨠ᩠ᨿ, ᨸᩩᨻ᩠ᨻᨠᨾ᩠ᨾᨶᩥᩅᨲ᩠ᨲᩥᩈᩩ;
ᨣᨿ᩠ᩉᩣᨠᩣᩁᩮᩣ’ᨸᩁᩥᨲ᩠ᨲᩮᩈᩩ, ᩏᨸᩮ’ᨲ᩠ᨿ [ᩏᨸᩮᨲ᩠ᨿ=ᩏᨸ+ᩍᨲᩥ]’ᨶᩈᨶᩣ’ᨴᩥᨠᩮ.
ᩑᩅᩴ ᨶᩥᨴᩔᨶᩣ’ᨠᩣᩁᩮᩣ, ᨸᨾᩣᩈᩩ ᩈᨾ᩠ᨸᩉᩴᩈᨶᩮ;
ᩏᨸᨴᩮᩈᩮ ᨧ ᩅᨧᨶ, ᨸᨭᩥᨣ᩠ᨣᩣᩉᩮ’ᩅᨵᩣᩁᨱᩮ;
ᨣᩁᩉᩣᨿᩮ’ᨴᨾᨲ᩠ᨳᩮ ᨧ, ᨸᩁᩥᨾᩣᨶᩮ ᨧ ᨸᩩᨧ᩠ᨨᨶᩮ.
ᩈᨾᩩᨧ᩠ᨧᨿᩮ ᩈᨾᩣᩉᩣᩁᩮ, ᨶ᩠ᩅᩣᨧᨿᩮ ᨧᩮ’ᨲᩁᩦᨲᩁᩮ;
ᨸᨴᨸᩪᩁᨱᨾᨲ᩠ᨲᩮ ᨧ, ᨧᩈᨴ᩠ᨴᩮᩣ ᩋᩅᨵᩣᩁᨱᩮ.
ᩍᨲᩥ ᩉᩮᨲᩩᨸᨠᩣᩁᩮᩈᩩ, ᩌᨴᩥᨾ᩠ᩉᩥ ᨧᩣ’ᩅᨵᩣᩁᨱᩮ;
ᨶᩥᨴᩔᨶᩮ ᨸᨴᨲ᩠ᨳᩔ, ᩅᩥᨸᩃ᩠ᩃᩣᩈᩮ ᩈᨾᩣᨸᨶᩮ.
ᩈᨾᩩᨧ᩠ᨧᨿᩮ ᨧᩮᩣ’ᨸᨾᩣᨿᩴ, ᩈᩴᩈᨿᩮ ᨸᨴᨸᩪᩁᨱᩮ;
ᩅᩅᨲ᩠ᨳᩥᨲᩅᩥᨽᩣᩈᩣᨿᩴ, ᩅᩣ’ᩅᩔᨣ᩠ᨣᩮ ᩅᩥᨠᨸ᩠ᨸᨶᩮ.
ᨽᩪᩈᨶᩮ ᩅᩣᩁᨱᩮ ᨧᩣ’ᩃᩴ, ᩅᩩᨧ᩠ᨧᨲᩮ ᨸᩁᩥᨿᨲ᩠ᨲᩥᨿᩴ;
ᩋᨳᩮᩣ’ᨳᩣ’ᨶᨶ᩠ᨲᩁᩣ’ᩁᨾ᩠ᨽ, ᨸᨬ᩠ᩉᩮᩈᩩ ᨸᨴᨸᩪᩁᨱᩮ.
ᨸᩈᩴᩈᩣᨣᩁᩉᩣᩈᨬ᩠ᨬᩣ, ᩈᩦᨠᩣᩁᩣᨴᩮᩣ [ᩈ᩠ᩅᩦᨠᩣᩁ (ᨭᩦ.)] ᨸᩥ ᨶᩣᨾ ᨳ;
ᨶᩥᨧ᩠ᨨᨿᩮ ᨧᩣ’ᨶᩩᨾᩣᨶᩈ᩠ᨾᩥᩴ, ᩈᩥᨿᩣ ᨶᩪᨶ ᩅᩥᨲᨠ᩠ᨠᨶᩮ.
ᨸᩩᨧ᩠ᨨᩣ’ᩅᨵᩣᩁᨱᩣ’ᨶᩩᨬ᩠ᨬᩣ, ᩈᩣᨶ᩠ᨲ᩠ᩅᨶᩣ’ᩃᨸᨶᩮ [ᩈᨶ᩠ᨲᨶᩣᩃᨸᨶᩮ (ᨠ.)] ᨶᨶᩩ;
ᩅᨲᩮ’ᨠᩴᩈ, ᨴᨿᩣ, ᩉᩣᩈ, ᨡᩮᨴᩣ’ᩃᨸᨶ, ᩅᩥᨾ᩠ᩉᨿᩮ.
ᩅᩣᨠ᩠ᨿᩣᩁᨾ᩠ᨽ, ᩅᩥᩈᩣᨴᩮᩈᩩ, ᩉᨶ᩠ᨴ ᩉᩣᩈᩮ’ᨶᩩᨠᨾ᩠ᨸᨶᩮ;
ᨿᩣᩅ ᨲᩩ ᨲᩣᩅ ᩈᩣᨠᩃ᩠ᨿ, ᨾᩣᨶᩣ’ᩅᨵ᩠ᨿ’ᩅᨵᩣᩁᨱᩮ.
ᨸᩣᨧᩦ, ᨸᩩᩁ, ᨦ᩠ᨣᨲᩮᩣᨲ᩠ᨳᩮᩈᩩ, ᨸᩩᩁᨲ᩠ᨳᩣ ᨸᨮᨾᩮ ᨸ᩠ᨿᨳ;
ᨸᨻᨶ᩠ᨵᩮ ᨧ ᨧᩥᩁᩣᨲᩦᨲᩮ, ᨶᩥᨠᨭᩣᨣᩣᨾᩥᨠᩮ ᨸᩩᩁᩣ.
ᨶᩥᩈᩮᨵᩅᩣᨠ᩠ᨿᩣᩃᨦ᩠ᨠᩣᩁᩣ, ᩅᨵᩣᩁᨱᨸᩈᩥᨴ᩠ᨵᩥᩈᩩ;
ᨡᩃ᩠ᩅᩣ’ᩈᨶ᩠ᨶᩮ ᨲᩩ ᩋᨽᩥᨲᩮᩣ-
ᨽᩥᨾᩩᨡᩮᩣ’ᨽᨿᨲᩮᩣᨴᩥᨠᩮ.
ᨠᩣᨾᩴ ᨿᨴ᩠ᨿᨸᩥᩈᨴ᩠ᨴᨲ᩠ᨳᩮ, ᩑᨠᩴᩈᨲ᩠ᨳᩮ ᨧ ᨴᩥᩔᨲᩥ;
ᩋᨳᩮᩣ ᨸᨶ ᩅᩥᩈᩮᩈᩈ᩠ᨾᩥᩴ, ᨲᨳᩮᩅ ᨸᨴᨸᩪᩁᨱᩮ.
ᩉᩥ ¶ ᨠᩣᩁᨱᩮ ᩅᩥᩈᩮᩈᩣ’ᩅ, ᨵᩣᩁᨱᩮ ᨸᨴᨸᩪᩁᨱᩮ;
ᨲᩩ ᩉᩮᨲᩩᩅᨩ᩠ᨩᩮ ᨲᨲ᩠ᨳᩣ’ᨳ, ᨠᩩ ᨸᩣᨸᩮ’ᩈᨲ᩠ᨳ’ᨠᩩᨧ᩠ᨨᨶᩮ.
ᨶᩩ ᩈᩴᩈᨿᩮ ᨧ ᨸᨬ᩠ᩉᩮ ᨳ, ᨶᩣᨶᩣ’ ᨶᩮᨠᨲ᩠ᨳ ᩅᨩ᩠ᨩᨶᩮ;
ᨠᩥᩴ ᨲᩩ ᨸᩩᨧ᩠ᨨᩣᨩᩥᨣᩩᨧ᩠ᨨᩣᩈᩩ, ᨠᩴ ᨲᩩ ᩅᩣᩁᩥᨾ᩠ᩉᩥ ᨾᩩᨴ᩠ᨵᨶᩥ.
ᩋᨾᩣ ᩈᩉᩈᨾᩦᨸᩮ ᨳ, ᨽᩮᨴᩮ ᩋᨸ᩠ᨸᨮᨾᩮ ᨸᩩᨶ;
ᨠᩥᩁᩣ’ᨶᩩᩔᩅᩣ’ᩁᩩᨧᩥᩈᩩ, ᩏᨴᩣ’ᨸ᩠ᨿᨲ᩠ᨳᩮ ᩅᩥᨠᨸ᩠ᨸᨶᩮ.
ᨸᨲᩦᨧᩦ ᨧᩁᩥᨾᩮ ᨸᨧ᩠ᨨᩣ, ᩈᩣᨾᩥ ᨲ᩠ᩅᨴ᩠ᨵᩮ ᨩᩥᨣᩩᨧ᩠ᨨᨶᩮ;
ᨸᨠᩣᩈᩮ ᩈᨾ᩠ᨽᩅᩮ ᨸᩣᨲᩩ,
ᩋᨬ᩠ᨬᩮᩣᨬ᩠ᨬᩮ ᨲᩩ ᩁᩉᩮᩣ ᨾᩥᨳᩮᩣ.
ᩉᩣ ᨡᩮᨴᩈᩮᩣᨠᨴᩩᨠ᩠ᨡᩮᩈᩩ, ᨡᩮᨴᩮ ᨲ᩠ᩅ’ᩉᩉ ᩅᩥᨾ᩠ᩉᨿᩮ;
ᨽᩥᩴᩈᩣᨸᨶᩮ [ᩉᩥᩴᩈᩣᨸᨶᩮ (ᨭᩦ.)] ᨵᩦ [ᨵᩥ (ᨠ.)] ᨶᩥᨶ᩠ᨴᩣᨿᩴ, ᨸᩥᨵᩣᨶᩮ ᨲᩥᩁᩥᨿᩴ ᨲᩥᩁᩮᩣ.
ᨲᩩᨶ ᨲ᩠ᩅᩣᨶ ᨲᩅᩮ ᨲ᩠ᩅᩣ ᨲᩩᩴ, ᨵᩣ ᩈᩮᩣ ᨳᩣ ᨠ᩠ᨡᨲ᩠ᨲᩩ, ᨾᩮᩅ ᨧ;
ᨲᩮᩣ ᨳ ᨲᩕ ᩉᩥᨬ᩠ᨧᨶᩴ ᩉᩥᩴᩉᩴ, ᨵᩥ ᩉ ᩉᩥ ᨵ ᨵᩩᨶᩣ ᩁᩉᩥ.
ᨴᩣᨶᩥ ᩅᩮᩣᨴᩣᨧᨶᩴ ᨴᩣᨩ᩠ᨩ, ᨳᩴ ᨲᨲ᩠ᨲᩴ ᨩ᩠ᨫ ᨩ᩠ᨩᩩ ᩌᨴᨿᩮᩣ;
ᩈᨾᩣᩈᩮᩣ ᨧᩣ’ᨻ᩠ᨿᨿᩦᨽᩣᩅᩮᩣ,
ᨿᩣᨴᩮᩈᩮᩣ ᨧᩣ’ᨻ᩠ᨿᨿᩴ ᨽᩅᩮᨲᩥ.
ᩍᨲᩥ ᩋᨻ᩠ᨿᨿᩅᨣ᩠ᨣᩮᩣ.
ᩈᩣᨾᨬ᩠ᨬᨠᨱ᩠ᨯᩮᩣ ᨲᨲᩥᨿᩮᩣ.
ᩋᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩣ ᩈᨾᨲ᩠ᨲᩣ.
ᨶᩥᨣᨾᨶ
ᩈᨣ᩠ᨣᨠᨱ᩠ᨯᩮᩣ ¶ ᨧ ᨽᩪᨠᨱ᩠ᨯᩮᩣ, ᨲᨳᩣ ᩈᩣᨾᨬ᩠ᨬᨠᨱ᩠ᨯᩥᨲᩥ;
ᨠᨱ᩠ᨯᨲ᩠ᨲᨿᩣᨶ᩠ᩅᩥᨲᩣ ᩑᩈᩣ, ᩋᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩣ.
ᨲᩥᨴᩥᩅᩮ ᨾᩉᩥᨿᩴ ᨽᩩᨩᨣᩣᩅᩈᨳᩮ,
ᩈᨠᩃᨲ᩠ᨳᩈᨾᩅ᩠ᩉᨿᨴᩦᨸᨶᩥ’ᨿᩴ;
ᩍᩉ ᨿᩮᩣ ᨠᩩᩈᩃᩮᩣ ᨾᨲᩥᨾᩣ ᩈ ᨶᩁᩮᩣ,
ᨸᨭᩩ ᩉᩮᩣᨲᩥ ᨾᩉᩣᨾᩩᨶᩥᨶᩮᩣ ᩅᨧᨶᩮ.
ᨸᩁᨠ᩠ᨠᨾᨽᩩᨩᩮᩣ ᨶᩣᨾ, ᨽᩪᨸᩣᩃᩮᩣ ᨣᩩᨱᨽᩪᩈᨶᩮᩣ;
ᩃᨦ᩠ᨠᩣᨿ ᨾᩣᩈᩥ ᨲᩮᨩᩔᩦ, ᨩᨿᩦ ᨠᩮᩈᩁᩥᩅᩥᨠ᩠ᨠᨾᩮᩣ.
ᩅᩥᨽᩥᨶ᩠ᨶᩴ ᨧᩥᩁᩴ ᨽᩥᨠ᩠ᨡᩩᩈᨦ᩠ᨥᩴ ᨶᩥᨠᩣᨿ-
ᨲ᩠ᨲᨿᩈ᩠ᨾᩥᨬ᩠ᨧ ᨠᩣᩁᩮᩈᩥ ᩈᨾ᩠ᨾᩣ ᩈᨾᨣ᩠ᨣᩮ;
ᩈᨴᩮᩉᩴ’ᩅ ᨶᩥᨧ᩠ᨧᩣᨴᩁᩮᩣ ᨴᩦᨥᨠᩣᩃᩴ,
ᨾᩉᨣ᩠ᨥᩮᩉᩥ ᩁᨠ᩠ᨡᩮᩈᩥ ᨿᩮᩣ ᨸᨧ᩠ᨧᨿᩮᩉᩥ.
ᨿᩮᨶ ᩃᨦ᩠ᨠᩣ ᩅᩥᩉᩣᩁᩮᩉᩥ, ᨣᩣᨾᩣ’ᩁᩣᨾᨸᩩᩁᩦᩉᩥ ᨧ;
ᨠᩥᨲ᩠ᨲᩥᨿᩣ ᩅᩥᨿ ᩈᨾ᩠ᨻᩣᨵᩦ, ᨠᨲᩣ ᨡᩮᨲ᩠ᨲᩮᩉᩥ ᩅᩣᨸᩥᩉᩥ.
ᨿᩔᩣ’ᩈᩣᨵᩣᩁᨱᩴ ᨸᨲ᩠ᩅᩣ, ᨶᩩᨣ᩠ᨣᩉᩴ ᩈᨻ᩠ᨻᨠᩣᨾᨴᩴ;
ᩋᩉᨾ᩠ᨸᩥ ᨣᨶ᩠ᨳᨠᩣᩁᨲ᩠ᨲᩴ, ᨸᨲ᩠ᨲᩮᩣ ᩅᩥᨻᩩᨵᨣᩮᩣᨧᩁᩴ.
ᨠᩣᩁᩥᨲᩮ ᨲᩮᨶ ᨸᩣᩈᩣᨴ, ᨣᩮᩣᨸᩩᩁᩣᨴᩥᩅᩥᨽᩪᩈᩥᨲᩮ;
ᩈᨣ᩠ᨣᨡᨱ᩠ᨯᩮ’ᩅ ᨲᨲ᩠ᨲᩮᩣᨿᩣ, ᩈᨿᩈ᩠ᨾᩥᩴ ᨸᨲᩥᨻᩥᨾ᩠ᨻᩥᨲᩮ.
ᨾᩉᩣᨩᩮᨲᩅᨶᩣ’ᨡ᩠ᨿᨾ᩠ᩉᩥ, ᩅᩥᩉᩣᩁᩮ ᩈᩣᨵᩩᩈᨾ᩠ᨾᨲᩮ;
ᩈᩁᩮᩣᨣᩣᨾᩈᨾᩪᩉᨾ᩠ᩉᩥ, ᩅᩈᨲᩣ ᩈᨶ᩠ᨲᩅᩩᨲ᩠ᨲᩥᨶᩣ.
ᩈᨴ᩠ᨵᨾ᩠ᨾᨭ᩠ᨮᩥᨲᩥᨠᩣᨾᩮᨶ, ᨾᩮᩣᨣ᩠ᨣᩃ᩠ᩃᩣᨶᩮᨶ ᨵᩦᨾᨲᩣ;
ᨳᩮᩁᩮᨶ ᩁᨧᩥᨲᩣ ᩑᩈᩣ, ᩋᨽᩥᨵᩣᨶᨸ᩠ᨸᨴᩦᨸᩥᨠᩣᨲᩥ.