᪕᪔᪓. ᨽᩪᩁᩥᨴᨲ᩠ᨲᨩᩣᨲᨠᩴ (᪖)

᪗᪘᪔. ‘‘ᨿᩴ ᨠᩥᨬ᩠ᨧᩥ ᩁᨲᨶᩴ ᩋᨲ᩠ᨳᩥ, ᨵᨲᩁᨭ᩠ᨮᨶᩥᩅᩮᩈᨶᩮ;

ᩈᨻ᩠ᨻᩣᨶᩥ ᨲᩮ ᩏᨸᨿᨶ᩠ᨲᩩ, ᨵᩦᨲᩁᩴ ᨴᩮᩉᩥ ᩁᩣᨩᩥᨶᩮᩣ’’.

᪗᪘᪕. ‘‘ᨶ ᨶᩮᩣ ᩅᩥᩅᩣᩉᩮᩣ ᨶᩣᨣᩮᩉᩥ, ᨠᨲᨸᩩᨻ᩠ᨻᩮᩣ ᨠᩩᨴᩣᨧᨶᩴ;

ᨲᩴ ᩅᩥᩅᩣᩉᩴ ᩋᩈᩴᨿᩩᨲ᩠ᨲᩴ, ᨠᨳᩴ ᩋᨾ᩠ᩉᩮ ᨠᩁᩮᩣᨾᩈᩮ’’.

᪗᪘᪖. ‘‘ᨩᩦᩅᩥᨲᩴ ᨶᩪᨶ ᨲᩮ ᨧᨲ᩠ᨲᩴ, ᩁᨭ᩠ᨮᩴ ᩅᩣ ᨾᨶᩩᨩᩣᨵᩥᨸ;

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

᪗᪘᪗. ‘‘ᨿᩮᩣ ᨲ᩠ᩅᩴ ᨴᩮᩅ ᨾᨶᩩᩔᩮᩣᩈᩥ, ᩍᨴ᩠ᨵᩥᨾᨶ᩠ᨲᩴ ᩋᨶᩥᨴ᩠ᨵᩥᨾᩣ;

ᩅᩁᩩᨱᩔ ᨶᩥᨿᩴ ᨸᩩᨲ᩠ᨲᩴ, ᨿᩣᨾᩩᨶᩴ ᩋᨲᩥᨾᨬ᩠ᨬᩈᩥ’’.

᪗᪘᪘. ‘‘ᨶᩣᨲᩥᨾᨬ᩠ᨬᩣᨾᩥ ᩁᩣᨩᩣᨶᩴ, ᨵᨲᩁᨭ᩠ᨮᩴ ᨿᩈᩔᩥᨶᩴ;

ᨵᨲᩁᨭ᩠ᨮᩮᩣ ᩉᩥ ᨶᩣᨣᩣᨶᩴ, ᨻᩉᩪᨶᨾᨸᩥ ᩍᩔᩁᩮᩣ.

᪗᪘᪙. ‘‘ᩋᩉᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣᨸᩥ, ᨶ ᨾᩮ ᨵᩦᨲᩁᨾᩣᩁᩉᩮᩣ;

ᨡᨲ᩠ᨲᩥᨿᩮᩣ ᨧ ᩅᩥᨴᩮᩉᩣᨶᩴ, ᩋᨽᩥᨩᩣᨲᩣ ᩈᨾᩩᨴ᩠ᨴᨩᩣ’’.

᪗᪙᪐. ‘‘ᨠᨾ᩠ᨻᩃᩔᨲᩁᩣ ᩏᨭ᩠ᨮᩮᨶ᩠ᨲᩩ, ᩈᨻ᩠ᨻᩮ ᨶᩣᨣᩮ ᨶᩥᩅᩮᨴᨿ;

ᨻᩣᩁᩣᨱᩈᩥᩴ ᨸᩅᨩ᩠ᨩᨶ᩠ᨲᩩ, ᨾᩣ ᨧ ᨠᨬ᩠ᨧᩥ [ᨠᩥᨬ᩠ᨧᩥ (ᩈᩦ. ᨸᩦ. ᨠ.)] ᩅᩥᩉᩮᨮᨿᩩᩴ’’.

᪗᪙᪑. ‘‘ᨶᩥᩅᩮᩈᨶᩮᩈᩩ ᩈᩮᩣᨻ᩠ᨽᩮᩈᩩ, ᩁᨳᩥᨿᩣ ᨧᨧ᩠ᨧᩁᩮᩈᩩ ᨧ;

ᩁᩩᨠ᩠ᨡᨣ᩠ᨣᩮᩈᩩ ᨧ ᩃᨾ᩠ᨻᨶ᩠ᨲᩩ, ᩅᩥᨲᨲᩣ ᨲᩮᩣᩁᨱᩮᩈᩩ ᨧ.

᪗᪙᪒. ‘‘ᩋᩉᨾ᩠ᨸᩥ ᩈᨻ᩠ᨻᩈᩮᨲᩮᨶ, ᨾᩉᨲᩣ ᩈᩩᨾᩉᩴ ᨸᩩᩁᩴ;

ᨸᩁᩥᨠ᩠ᨡᩥᨸᩥᩔᩴ ᨽᩮᩣᨣᩮᩉᩥ, ᨠᩣᩈᩦᨶᩴ ᨩᨶᨿᩴ ᨽᨿᩴ’’.

᪗᪙᪓. ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩏᩁᨣᩣᨶᩮᨠᩅᨱ᩠ᨱᩥᨶᩮᩣ;

ᨻᩣᩁᩣᨱᩈᩥᩴ ᨸᩅᨩ᩠ᨩᩥᩴᩈᩩ, ᨶ ᨧ ᨠᨬ᩠ᨧᩥ ᩅᩥᩉᩮᨮᨿᩩᩴ.

᪗᪙᪔. ᨶᩥᩅᩮᩈᨶᩮᩈᩩ ᩈᩮᩣᨻ᩠ᨽᩮᩈᩩ, ᩁᨳᩥᨿᩣ ᨧᨧ᩠ᨧᩁᩮᩈᩩ ᨧ;

ᩁᩩᨠ᩠ᨡᨣ᩠ᨣᩮᩈᩩ ᨧ ᩃᨾ᩠ᨻᩥᩴᩈᩩ, ᩅᩥᨲᨲᩣ ᨲᩮᩣᩁᨱᩮᩈᩩ ᨧ.

᪗᪙᪕. ᨲᩮᩈᩩ ᨴᩥᩈ᩠ᩅᩣᨶ ᩃᨾ᩠ᨻᨶ᩠ᨲᩮ, ᨸᩩᨳᩪ ᨠᨶ᩠ᨴᩥᩴᩈᩩ ᨶᩣᩁᩥᨿᩮᩣ;

ᨶᩣᨣᩮ ᩈᩮᩣᨱ᩠ᨯᩥᨠᨲᩮ ᨴᩥᩈ᩠ᩅᩣ, ᨸᩔᩈᨶ᩠ᨲᩮ ᨾᩩᩉᩩᩴ ᨾᩩᩉᩩᩴ.

᪗᪙᪖. ᨻᩣᩁᩣᨱᩈᩦ ᨸᨻ᩠ᨿᨵᩥᨲᩣ, ᩌᨲᩩᩁᩣ ᩈᨾᨸᨩ᩠ᨩᨳ;

ᨻᩣᩉᩣ ᨸᨣ᩠ᨣᨿ᩠ᩉ ᨸᨠ᩠ᨠᨶ᩠ᨴᩩᩴ, ‘‘ᨵᩦᨲᩁᩴ ᨴᩮᩉᩥ ᩁᩣᨩᩥᨶᩮᩣ’’.

᪗᪙᪗. ‘‘ᨸᩩᨸ᩠ᨹᩣᨽᩥᩉᩣᩁᩔ ᩅᨶᩔ ᨾᨩ᩠ᨫᩮ, ᨠᩮᩣ ᩃᩮᩣᩉᩥᨲᨠ᩠ᨡᩮᩣ ᩅᩥᨲᨲᨶ᩠ᨲᩁᩴᩈᩮᩣ;

ᨠᩣ ᨠᨾ᩠ᨻᩩᨠᩣᨿᩪᩁᨵᩁᩣ ᩈᩩᩅᨲ᩠ᨳᩣ, ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ ᨶᩣᩁᩥᨿᩮᩣ ᨴᩈ ᩅᨶ᩠ᨴᨾᩣᨶᩣ.

᪗᪙᪘. ‘‘ᨠᩮᩣ ᨲ᩠ᩅᩴ ᨻᩕᩉᩣᨻᩣᩉᩩ ᩅᨶᩔ ᨾᨩ᩠ᨫᩮ, ᩅᩥᩁᩮᩣᨧᩈᩥ ᨥᨲᩈᩥᨲ᩠ᨲᩮᩣᩅ ᩋᨣ᩠ᨣᩥ;

ᨾᩉᩮᩈᨠ᩠ᨡᩮᩣ ᩋᨬ᩠ᨬᨲᩁᩮᩣᩈᩥ ᨿᨠ᩠ᨡᩮᩣ, ᩏᨴᩣᩉᩩ ᨶᩣᨣᩮᩣᩈᩥ ᨾᩉᩣᨶᩩᨽᩣᩅᩮᩣ’’.

᪗᪙᪙. ‘‘ᨶᩣᨣᩮᩣᩉᨾᩈ᩠ᨾᩥ ᩍᨴ᩠ᨵᩥᨾᩣ, ᨲᩮᨩᩔᩦ [ᨲᩮᨩᩈᩦ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ. ᨠ.)] ᨴᩩᩁᨲᩥᨠ᩠ᨠᨾᩮᩣ;

ᨯᩴᩈᩮᨿ᩠ᨿᩴ ᨲᩮᨩᩈᩣ ᨠᩩᨴ᩠ᨵᩮᩣ, ᨹᩦᨲᩴ ᨩᨶᨸᨴᩴ ᩋᨸᩥ.

᪘᪐᪐. ‘‘ᩈᨾᩩᨴ᩠ᨴᨩᩣ ᩉᩥ ᨾᩮ ᨾᩣᨲᩣ, ᨵᨲᩁᨭ᩠ᨮᩮᩣ ᨧ ᨾᩮ ᨸᩥᨲᩣ;

ᩈᩩᨴᩔᨶᨠᨶᩥᨭ᩠ᨮᩮᩣᩈ᩠ᨾᩥ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᩣᨲᩥ ᨾᩴ ᩅᩥᨴᩪ’’.

᪘᪐᪑. ‘‘ᨿᩴ ᨣᨾ᩠ᨽᩦᩁᩴ ᩈᨴᩣᩅᨭ᩠ᨭᩴ, ᩁᩉᨴᩴ ᨽᩥᩈ᩠ᨾᩴ ᨸᩮᨠ᩠ᨡᩈᩥ;

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

᪘᪐᪒. ‘‘ᨾᨿᩪᩁᨠᩮᩣᨬ᩠ᨧᩣᨽᩥᩁᩩᨴᩴ, ᨶᩦᩃᩮᩣᨴᩴ ᩅᨶᨾᨩ᩠ᨫᨲᩮᩣ;

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

᪘᪐᪓. ‘‘ᨲᨲ᩠ᨳ ᨸᨲ᩠ᨲᩮᩣ ᩈᩣᨶᩩᨧᩁᩮᩣ, ᩈᩉ ᨸᩩᨲ᩠ᨲᩮᨶ ᨻᩕᩣᩉ᩠ᨾᨱ;

ᨸᩪᨩᩥᨲᩮᩣ ᨾᨿ᩠ᩉᩴ ᨠᩣᨾᩮᩉᩥ, ᩈᩩᨡᩴ ᨻᩕᩣᩉ᩠ᨾᨱ ᩅᨧ᩠ᨨᩈᩥ’’.

᪘᪐᪔. ‘‘ᩈᨾᩣ ᩈᨾᨶ᩠ᨲᨸᩁᩥᨲᩮᩣ, ᨸᩉᩪᨲᨲᨣᩁᩣ [ᨻᩉᩩᨠᩣ ᨲᨣ᩠ᨣᩁᩣ (ᩈᩦ. ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᨾᩉᩦ;

ᩍᨶ᩠ᨴᨣᩮᩣᨸᨠᩈᨬ᩠ᨨᨶ᩠ᨶᩣ, ᩈᩮᩣᨽᨲᩥ ᩉᩁᩥᨲᩩᨲ᩠ᨲᨾᩣ.

᪘᪐᪕. ‘‘ᩁᨾ᩠ᨾᩣᨶᩥ ᩅᨶᨧᩮᨲ᩠ᨿᩣᨶᩥ, ᩁᨾ᩠ᨾᩣ ᩉᩴᩈᩪᨸᨠᩪᨩᩥᨲᩣ;

ᩒᨸᩩᨸ᩠ᨹᩣᨸᨴ᩠ᨾᩣ ᨲᩥᨭ᩠ᨮᨶ᩠ᨲᩥ, ᨸᩮᩣᨠ᩠ᨡᩁᨬ᩠ᨬᩮᩣ [ᨸᩮᩣᨠ᩠ᨡᩁᨬ᩠ᨬᩣ (ᩈ᩠ᨿᩣ. ᨸᩦ.)] ᩈᩩᨶᩥᨾ᩠ᨾᩥᨲᩣ.

᪘᪐᪖. ‘‘ᩋᨭ᩠ᨮᩴᩈᩣ ᩈᩩᨠᨲᩣ ᨳᨾ᩠ᨽᩣ, ᩈᨻ᩠ᨻᩮ ᩅᩮᩊᩩᩁᩥᨿᩣᨾᨿᩣ;

ᩈᩉᩔᨳᨾ᩠ᨽᩣ ᨸᩣᩈᩣᨴᩣ, ᨸᩪᩁᩣ ᨠᨬ᩠ᨬᩣᩉᩥ ᨩᩮᩣᨲᩁᩮ.

᪘᪐᪗. ‘‘ᩅᩥᨾᩣᨶᩴ ᩏᨸᨸᨶ᩠ᨶᩮᩣᩈᩥ, ᨴᩥᨻ᩠ᨿᩴ ᨸᩩᨬ᩠ᨬᩮᩉᩥ ᩋᨲ᩠ᨲᨶᩮᩣ;

ᩋᩈᨾ᩠ᨻᩣᨵᩴ ᩈᩥᩅᩴ ᩁᨾ᩠ᨾᩴ, ᩋᨧ᩠ᨧᨶ᩠ᨲᩈᩩᨡᩈᩴᩉᩥᨲᩴ.

᪘᪐᪘. ‘‘ᨾᨬ᩠ᨬᩮ ᩈᩉᩔᨶᩮᨲ᩠ᨲᩔ, ᩅᩥᨾᩣᨶᩴ ᨶᩣᨽᩥᨠᨦ᩠ᨡᩈᩥ;

ᩍᨴ᩠ᨵᩦ ᩉᩥ ᨲ᩠ᨿᩣᨿᩴ ᩅᩥᨸᩩᩃᩣ, ᩈᨠ᩠ᨠᩔᩮᩅ ᨩᩩᨲᩦᨾᨲᩮᩣ’’.

᪘᪐᪙. ‘‘ᨾᨶᩈᩣᨸᩥ ᨶ ᨸᨲ᩠ᨲᨻ᩠ᨻᩮᩣ, ᩌᨶᩩᨽᩣᩅᩮᩣ ᨩᩩᨲᩦᨾᨲᩮᩣ;

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

᪘᪑᪐. ‘‘ᨲᩴ ᩅᩥᨾᩣᨶᩴ ᩋᨽᩥᨩ᩠ᨫᩣᨿ, ᩋᨾᩁᩣᨶᩴ ᩈᩩᨡᩮᩈᩥᨶᩴ;

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

᪘᪑᪑. ‘‘ᩋᩉᨬ᩠ᨧ ᨾᩥᨣᨾᩮᩈᩣᨶᩮᩣ, ᩈᨸᩩᨲ᩠ᨲᩮᩣ ᨸᩣᩅᩥᩈᩥᩴ ᩅᨶᩴ;

ᨲᩴ ᨾᩴ ᨾᨲᩴ ᩅᩣ ᨩᩦᩅᩴ ᩅᩣ, ᨶᩣᨽᩥᩅᩮᨴᩮᨶ᩠ᨲᩥ ᨬᩣᨲᨠᩣ.

᪘᪑᪒. ‘‘ᩌᨾᨶ᩠ᨲᨿᩮ ᨽᩪᩁᩥᨴᨲ᩠ᨲᩴ, ᨠᩣᩈᩥᨸᩩᨲ᩠ᨲᩴ ᨿᩈᩔᩥᨶᩴ;

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

᪘᪑᪓. ‘‘ᩑᩈᩮᩣ ᩉᩥ ᩅᨲ ᨾᩮ ᨨᨶ᩠ᨴᩮᩣ, ᨿᩴ ᩅᩈᩮᩈᩥ ᨾᨾᨶ᩠ᨲᩥᨠᩮ;

ᨶ ᩉᩥ ᩑᨲᩣᨴᩥᩈᩣ ᨠᩣᨾᩣ, ᩈᩩᩃᨽᩣ ᩉᩮᩣᨶ᩠ᨲᩥ ᨾᩣᨶᩩᩈᩮ.

᪘᪑᪔. ‘‘ᩈᨧᩮ ᨲ᩠ᩅᩴ ᨶᩥᨧ᩠ᨨᩈᩮ ᩅᨲ᩠ᨳᩩᩴ, ᨾᨾ ᨠᩣᨾᩮᩉᩥ ᨸᩪᨩᩥᨲᩮᩣ;

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

᪘᪑᪕. ‘‘ᨵᩣᩁᨿᩥᨾᩴ ᨾᨱᩥᩴ ᨴᩥᨻ᩠ᨿᩴ, ᨸᩈᩩᩴ ᨸᩩᨲ᩠ᨲᩮ ᨧ ᩅᩥᨶ᩠ᨴᨲᩥ;

ᩋᩁᩮᩣᨣᩮᩣ ᩈᩩᨡᩥᨲᩮᩣ ᩉᩮᩣᨲᩥ [ᩉᩮᩣᩉᩥ (ᩈ᩠ᨿᩣ.)], ᨣᨧ᩠ᨨᩮᩅᩣᨴᩣᨿ ᨻᩕᩣᩉ᩠ᨾᨱ’’.

᪘᪑᪖. ‘‘ᨠᩩᩈᩃᩴ ᨸᨭᩥᨶᨶ᩠ᨴᩣᨾᩥ, ᨽᩪᩁᩥᨴᨲ᩠ᨲ ᩅᨧᩮᩣ ᨲᩅ;

ᨸᨻ᩠ᨻᨩᩥᩔᩣᨾᩥ ᨩᩥᨱ᩠ᨱᩮᩣᩈ᩠ᨾᩥ, ᨶ ᨠᩣᨾᩮ ᩋᨽᩥᨸᨲ᩠ᨳᨿᩮ’’.

᪘᪑᪗. ‘‘ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩔ ᨧᩮ ᨽᨦ᩠ᨣᩮᩣ, ᩉᩮᩣᨲᩥ ᨽᩮᩣᨣᩮᩉᩥ ᨠᩣᩁᩥᨿᩴ;

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

᪘᪑᪘. ‘‘ᨠᩩᩈᩃᩴ ᨸᨭᩥᨶᨶ᩠ᨴᩣᨾᩥ, ᨽᩪᩁᩥᨴᨲ᩠ᨲ ᩅᨧᩮᩣ ᨲᩅ;

ᨸᩩᨶᨸᩥ ᩌᨣᨾᩥᩔᩣᨾᩥ, ᩈᨧᩮ ᩋᨲ᩠ᨳᩮᩣ ᨽᩅᩥᩔᨲᩥ’’.

᪘᪑᪙. ‘‘ᩍᨴᩴ ᩅᨲ᩠ᩅᩣ ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᩣ, ᨸᩮᩈᩮᩈᩥ ᨧᨲᩩᩁᩮᩣ ᨩᨶᩮ;

ᩑᨳ ᨣᨧ᩠ᨨᨳ ᩏᨭ᩠ᨮᩮᨳ, ᨡᩥᨸ᩠ᨸᩴ ᨸᩣᨸᩮᨳ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

᪘᪒᪐. ᨲᩔ ᨲᩴ ᩅᨧᨶᩴ ᩈᩩᨲ᩠ᩅᩣ, ᩏᨭ᩠ᨮᩣᨿ ᨧᨲᩩᩁᩮᩣ ᨩᨶᩣ;

ᨸᩮᩈᩥᨲᩣ ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᨶ, ᨡᩥᨸ᩠ᨸᩴ ᨸᩣᨸᩮᩈᩩ ᨻᩕᩣᩉ᩠ᨾᨱᩴ.

᪘᪒᪑. ‘‘ᨾᨱᩥᩴ ᨸᨣ᩠ᨣᨿ᩠ᩉ ᨾᨦ᩠ᨣᩃ᩠ᨿᩴ, ᩈᩣᨵᩩᩅᩥᨲ᩠ᨲᩴ [ᩈᩣᨵᩩᨧᩥᨲ᩠ᨲᩴ (ᨸᩦ.)] ᨾᨶᩮᩣᩁᨾᩴ;

ᩈᩮᩃᩴ ᨻ᩠ᨿᨬ᩠ᨩᨶᩈᨾ᩠ᨸᨶ᩠ᨶᩴ, ᨠᩮᩣ ᩍᨾᩴ ᨾᨱᩥᨾᨩ᩠ᨫᨣᩣ’’.

᪘᪒᪒. ‘‘ᩃᩮᩣᩉᩥᨲᨠ᩠ᨡᩈᩉᩔᩣᩉᩥ, ᩈᨾᨶ᩠ᨲᩣ ᨸᩁᩥᩅᩣᩁᩥᨲᩴ;

ᩋᨩ᩠ᨩ ᨠᩣᩃᩴ ᨸᨳᩴ [ᨸᨴᩴ (ᩈᩦ. ᨸᩦ.)] ᨣᨧ᩠ᨨᩴ, ᩋᨩ᩠ᨫᨣᩣᩉᩴ ᨾᨱᩥᩴ ᩍᨾᩴ’’.

᪘᪒᪓. ‘‘ᩈᩩᨸᨧᩥᨱ᩠ᨱᩮᩣ ᩋᨿᩴ ᩈᩮᩃᩮᩣ, ᩋᨧ᩠ᨧᩥᨲᩮᩣ ᨾᩉᩥᨲᩮᩣ [ᨾᩣᨶᩥᨲᩮᩣ (ᨠ.)] ᩈᨴᩣ;

ᩈᩩᨵᩣᩁᩥᨲᩮᩣ ᩈᩩᨶᩥᨠ᩠ᨡᩥᨲ᩠ᨲᩮᩣ, ᩈᨻ᩠ᨻᨲ᩠ᨳᨾᨽᩥᩈᩣᨵᨿᩮ.

᪘᪒᪔. ‘‘ᩏᨸᨧᩣᩁᩅᩥᨸᨶ᩠ᨶᩔ, ᨶᩥᨠ᩠ᨡᩮᨸᩮ ᨵᩣᩁᨱᩣᨿ ᩅᩣ;

ᩋᨿᩴ ᩈᩮᩃᩮᩣ ᩅᩥᨶᩣᩈᩣᨿ, ᨸᩁᩥᨧᩥᨱ᩠ᨱᩮᩣ ᩋᨿᩮᩣᨶᩥᩈᩮᩣ.

᪘᪒᪕. ‘‘ᨶ ᩍᨾᩴ ᩋᨠᩩᩈᩃᩮᩣ [ᨠᩩᩈᩃᩴ (ᨠ.)] ᨴᩥᨻ᩠ᨿᩴ, ᨾᨱᩥᩴ ᨵᩣᩁᩮᨲᩩᨾᩣᩁᩉᩮᩣ;

ᨸᨭᩥᨸᨩ᩠ᨩ ᩈᨲᩴ ᨶᩥᨠ᩠ᨡᩴ, ᨴᩮᩉᩥᨾᩴ ᩁᨲᨶᩴ ᨾᨾ’’.

᪘᪒᪖. ‘‘ᨶ ᨧ ᨾ᩠ᨿᩣᨿᩴ ᨾᨱᩦ ᨠᩮᨿ᩠ᨿᩮᩣ, ᨣᩮᩣᩉᩥ [ᨠᩮᩉᩥ (ᨠ.)] ᩅᩣ ᩁᨲᨶᩮᩉᩥ ᩅᩣ;

ᩈᩮᩃᩮᩣ ᨻ᩠ᨿᨬ᩠ᨩᨶᩈᨾ᩠ᨸᨶ᩠ᨶᩮᩣ, ᨶᩮᩅ ᨠᩮᨿ᩠ᨿᩮᩣ ᨾᨱᩦ ᨾᨾ’’.

᪘᪒᪗. ‘‘ᨶᩮᩣ ᨧᩮ ᨲᨿᩣ ᨾᨱᩦ ᨠᩮᨿ᩠ᨿᩮᩣ, ᨣᩮᩣᩉᩥ [ᨠᩮᩉᩥ (ᨠ.)] ᩅᩣ ᩁᨲᨶᩮᩉᩥ ᩅᩣ;

ᩋᨳ ᨠᩮᨶ ᨾᨱᩦ ᨠᩮᨿ᩠ᨿᩮᩣ, ᨲᩴ ᨾᩮ ᩋᨠ᩠ᨡᩣᩉᩥ ᨸᩩᨧ᩠ᨨᩥᨲᩮᩣ’’.

᪘᪒᪘. ‘‘ᨿᩮᩣ ᨾᩮ ᩈᩴᩈᩮ ᨾᩉᩣᨶᩣᨣᩴ, ᨲᩮᨩᩔᩥᩴ ᨴᩩᩁᨲᩥᨠ᩠ᨠᨾᩴ;

ᨲᩔ ᨴᨩ᩠ᨩᩴ ᩍᨾᩴ ᩈᩮᩃᩴ, ᨩᩃᨶ᩠ᨲᨾᩥᩅ ᨲᩮᨩᩈᩣ’’.

᪘᪒᪙. ‘‘ᨠᩮᩣ ᨶᩩ ᨻᩕᩣᩉ᩠ᨾᨱᩅᨱ᩠ᨱᩮᨶ, ᩈᩩᨸᨱ᩠ᨱᩮᩣ ᨸᨲᨲᩴ ᩅᩁᩮᩣ;

ᨶᩣᨣᩴ ᨩᩥᨣᩦᩈᨾᨶ᩠ᩅᩮᩈᩥ, ᩋᨶ᩠ᩅᩮᩈᩴ ᨽᨠ᩠ᨡᨾᨲ᩠ᨲᨶᩮᩣ.

᪘᪓᪐. ‘‘ᨶᩣᩉᩴ ᨴᩥᨩᩣᨵᩥᨸᩮᩣ ᩉᩮᩣᨾᩥ, ᨶ ᨴᩥᨭ᩠ᨮᩮᩣ ᨣᩁᩩᩊᩮᩣ ᨾᨿᩣ;

ᩌᩈᩦᩅᩥᩈᩮᨶ ᩅᩥᨲ᩠ᨲᩮᩣᨲᩥ [ᩅᩥᨲ᩠ᨲᩮᩣᩈ᩠ᨾᩥ (ᩈ᩠ᨿᩣ. ᨠ.)], ᩅᨩ᩠ᨩᩮᩣ ᨻᩕᩣᩉ᩠ᨾᨱ ᨾᩴ ᩅᩥᨴᩪ’’.

᪘᪓᪑. ‘‘ᨠᩥᩴ ᨶᩩ ᨲᩩᨿ᩠ᩉᩴ ᨻᩃᩴ ᩋᨲ᩠ᨳᩥ, ᨠᩥᩴ ᩈᩥᨸ᩠ᨸᩴ ᩅᩥᨩ᩠ᨩᨲᩮ ᨲᩅ;

ᨠᩥᩈ᩠ᨾᩥᩴ ᩅᩣ ᨲ᩠ᩅᩴ ᨸᩁᨲ᩠ᨳᨴ᩠ᨵᩮᩣ, ᩏᩁᨣᩴ ᨶᩣᨸᨧᩣᨿᩈᩥ’’.

᪘᪓᪒. ‘‘ᩌᩁᨬ᩠ᨬᩥᨠᩔ ᩍᩈᩥᨶᩮᩣ, ᨧᩥᩁᩁᨲ᩠ᨲᩴ ᨲᨸᩔᩥᨶᩮᩣ;

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

᪘᪓᪓. ‘‘ᨲᩴ ᨽᩣᩅᩥᨲᨲ᩠ᨲᨬ᩠ᨬᨲᩁᩴ, ᩈᨾ᩠ᨾᨶ᩠ᨲᩴ ᨸᨻ᩠ᨻᨲᨶ᩠ᨲᩁᩮ;

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

᪘᪓᪔. ‘‘ᩈᩮᩣ ᨲᨴᩣ ᨸᩁᩥᨧᩥᨱ᩠ᨱᩮᩣ ᨾᩮ, ᩅᨲ᩠ᨲᩅᩣ ᨻᩕᩉ᩠ᨾᨧᩁᩥᨿᩅᩣ;

ᨴᩥᨻ᩠ᨻᩴ ᨸᩣᨲᩩᨠᩁᩦ ᨾᨶ᩠ᨲᩴ, ᨠᩣᨾᩈᩣ ᨽᨣᩅᩣ ᨾᨾ.

᪘᪓᪕. ‘‘ᨲ᩠ᨿᩣᩉᩴ ᨾᨶ᩠ᨲᩮ ᨸᩁᨲ᩠ᨳᨴ᩠ᨵᩮᩣ, ᨶᩣᩉᩴ ᨽᩣᨿᩣᨾᩥ ᨽᩮᩣᨣᩥᨶᩴ;

ᩌᨧᩁᩥᨿᩮᩣ ᩅᩥᩈᨥᩣᨲᩣᨶᩴ, ᩋᩃᨾ᩠ᨸᩣᨶᩮᩣᨲᩥ [ᩌᩃᨾ᩠ᨻᩣᨶᩮᩣᨲᩥ (ᩈᩦ. ᨸᩦ.), ᩌᩃᨾ᩠ᨻᩣᨿᨶᩮᩣᨲᩥ (ᩈ᩠ᨿᩣ.)] ᨾᩴ ᩅᩥᨴᩪ’’.

᪘᪓᪖. ‘‘ᨣᨱ᩠ᩉᩣᨾᩈᩮ ᨾᨱᩥᩴ ᨲᩣᨲ, ᩈᩮᩣᨾᨴᨲ᩠ᨲ ᩅᩥᨩᩣᨶᩉᩥ;

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

᪘᪓᪗. ‘‘ᩈᨠᩴ ᨶᩥᩅᩮᩈᨶᩴ ᨸᨲ᩠ᨲᩴ, ᨿᩮᩣ ᨲᩴ ᨻᩕᩣᩉ᩠ᨾᨱ ᨸᩪᨩᨿᩥ;

ᩑᩅᩴ ᨠᩃ᩠ᨿᩣᨱᨠᩣᩁᩥᩔ, ᨠᩥᩴ ᨾᩮᩣᩉᩣ ᨴᩩᨻ᩠ᨽᩥᨾᩥᨧ᩠ᨨᩈᩥ’’.

᪘᪓᪘. ‘‘ᩈᨧᩮ ᨲ᩠ᩅᩴ [ᩈᨧᩮ ᩉᩥ (ᩈᩦ. ᨸᩦ. ᨠ.)] ᨵᨶᨠᩣᨾᩮᩣᩈᩥ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᩣ ᨸᨴᩔᨲᩥ [ᨽᩪᩁᩥᨴᨲ᩠ᨲᩴ ᨸᨴᩥᩔᩈᩥ (ᨠ.)];

ᨲᨾᩮᩅ ᨣᨶ᩠ᨲ᩠ᩅᩣ ᨿᩣᨧᩔᩩ, ᨻᩉᩩᩴ ᨴᩔᨲᩥ ᨲᩮ ᨵᨶᩴ’’.

᪘᪓᪙. ‘‘ᩉᨲ᩠ᨳᨣᨲᩴ ᨸᨲ᩠ᨲᨣᨲᩴ, ᨶᩥᨠᩥᨱ᩠ᨱᩴ ᨡᩣᨴᩥᨲᩩᩴ ᩅᩁᩴ;

ᨾᩣ ᨶᩮᩣ ᩈᨶ᩠ᨴᩥᨭ᩠ᨮᩥᨠᩮᩣ ᩋᨲ᩠ᨳᩮᩣ, ᩈᩮᩣᨾᨴᨲ᩠ᨲ ᩏᨸᨧ᩠ᨧᨣᩣ’’.

᪘᪔᪐. ‘‘ᨸᨧ᩠ᨧᨲᩥ ᨶᩥᩁᨿᩮ ᨥᩮᩣᩁᩮ, ᨾᩉᩥᩔᨾᨸᩥ ᩅᩥᩅᩁᨲᩥ [ᨾᩉᩥᩔᨾᩅ ᨴᩦᨿᨲᩥ (ᩈᩦ. ᨸᩦ.), ᨾᩉᩥᨾᩔ ᩅᩥᨶ᩠ᨴᩕᩦᨿᨲᩥ (ᩈ᩠ᨿᩣ.)];

ᨾᩥᨲ᩠ᨲᨴᩩᨻ᩠ᨽᩦ ᩉᩥᨲᨧ᩠ᨧᩣᨣᩦ, ᨩᩦᩅᩁᩮᩅᩣᨸᩥ ᩈᩩᩔᨲᩥ [ᨩᩦᩅᩁᩮ ᨧᩣᨸᩥ ᩈᩩᩔᩁᩮ (ᩈᩦ. ᨸᩦ.)].

᪘᪔᪑. ‘‘ᩈᨧᩮ ᨲ᩠ᩅᩴ [ᩈᨧᩮ ᩉᩥ (ᩈᩦ. ᨸᩦ. ᨠ.)] ᨵᨶᨠᩣᨾᩮᩣᩈᩥ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᩣ ᨸᨴᩔᨲᩥ;

ᨾᨬ᩠ᨬᩮ ᩋᨲ᩠ᨲᨠᨲᩴ ᩅᩮᩁᩴ, ᨶᨧᩥᩁᩴ ᩅᩮᨴᨿᩥᩔᩈᩥ’’.

᪘᪔᪒. ‘‘ᨾᩉᩣᨿᨬ᩠ᨬᩴ ᨿᨩᩥᨲ᩠ᩅᩣᨶ, ᩑᩅᩴ ᩈᩩᨩ᩠ᨫᨶ᩠ᨲᩥ ᨻᩕᩣᩉ᩠ᨾᨱᩣ;

ᨾᩉᩣᨿᨬ᩠ᨬᩴ ᨿᨩᩥᩔᩣᨾ, ᩑᩅᩴ ᨾᩮᩣᨠ᩠ᨡᩣᨾ ᨸᩣᨸᨠᩣ’’.

᪘᪔᪓. ‘‘ᩉᨶ᩠ᨴ ᨴᩣᨶᩥ ᩋᨸᩣᨿᩣᨾᩥ, ᨶᩣᩉᩴ ᩋᨩ᩠ᨩ ᨲᨿᩣ ᩈᩉ;

ᨸᨴᨾ᩠ᨸᩮᨠᩴ [ᨸᨴᨾᩮᨠᩴ (ᩈ᩠ᨿᩣ. ᨠ.)] ᨶ ᨣᨧ᩠ᨨᩮᨿ᩠ᨿᩴ, ᩑᩅᩴ ᨠᩥᨻ᩠ᨻᩥᩈᨠᩣᩁᩥᨶᩣ’’.

᪘᪔᪔. ‘‘ᩍᨴᩴ ᩅᨲ᩠ᩅᩣᨶ ᨸᩥᨲᩁᩴ, ᩈᩮᩣᨾᨴᨲ᩠ᨲᩮᩣ ᨻᩉᩩᩔᩩᨲᩮᩣ;

ᩏᨩ᩠ᨫᩣᨸᩮᨲ᩠ᩅᩣᨶ ᨽᩪᨲᩣᨶᩥ, ᨲᨾ᩠ᩉᩣ ᨮᩣᨶᩣ ᩋᨸᨠ᩠ᨠᨾᩥ.

᪘᪔᪕. ‘‘ᨣᨱ᩠ᩉᩣᩉᩮᨲᩴ ᨾᩉᩣᨶᩣᨣᩴ, ᩌᩉᩁᩮᨲᩴ ᨾᨱᩥᩴ ᨾᨾ;

ᩍᨶ᩠ᨴᨣᩮᩣᨸᨠᩅᨱ᩠ᨱᩣᨽᩮᩣ, ᨿᩔ ᩃᩮᩣᩉᩥᨲᨠᩮᩣ ᩈᩥᩁᩮᩣ.

᪘᪔᪖. ‘‘ᨠᨸ᩠ᨸᩣᩈᨸᩥᨧᩩᩁᩣᩈᩦᩅ, ᩑᩈᩮᩣ ᨠᩣᨿᩮᩣ ᨸᨴᩥᩔᨲᩥ [ᨠᩣᨿ’ᩔ ᨴᩥᩔᨲᩥ (ᩈᩦ. ᨸᩦ.)];

ᩅᨾ᩠ᨾᩥᨠᨣ᩠ᨣᨣᨲᩮᩣ ᩈᩮᨲᩥ, ᨲᩴ ᨲ᩠ᩅᩴ ᨣᨱ᩠ᩉᩣᩉᩥ ᨻᩕᩣᩉ᩠ᨾᨱ’’.

᪘᪔᪗. ‘‘ᩋᨳᩮᩣᩈᨵᩮᩉᩥ ᨴᩥᨻ᩠ᨻᩮᩉᩥ, ᨩᨸ᩠ᨸᩴ ᨾᨶ᩠ᨲᨸᨴᩣᨶᩥ ᨧ;

ᩑᩅᩴ ᨲᩴ ᩋᩈᨠ᩠ᨡᩥ ᩈᨲ᩠ᨳᩩᩴ [ᩈᨭ᩠ᨮᩩᩴ (ᩈᩦ. ᨸᩦ.), ᨿᩩᨭ᩠ᨮᩩᩴ (ᩈ᩠ᨿᩣ.), ᩈᩩᨲ᩠ᨲᩩᩴ (ᨠ.)], ᨠᨲ᩠ᩅᩣ ᨸᩁᩥᨲ᩠ᨲᨾᨲ᩠ᨲᨶᩮᩣ’’.

᪘᪔᪘. ‘‘ᨾᨾᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᩌᨿᨶ᩠ᨲᩴ, ᩈᨻ᩠ᨻᨠᩣᨾᩈᨾᩥᨴ᩠ᨵᩥᨶᩴ;

ᩍᨶ᩠ᨴᩕᩥᨿᩣᨶᩥ ᩋᩉᨭ᩠ᨮᩣᨶᩥ, ᩈᩣᩅᩴ [ᩈᩣᨾᩴ (ᩈᩦ. ᨸᩦ.)] ᨩᩣᨲᩴ ᨾᩩᨡᩴ ᨲᩅ.

᪘᪔᪙. ‘‘ᨸᨴ᩠ᨾᩴ ᨿᨳᩣ ᩉᨲ᩠ᨳᨣᨲᩴ, ᨸᩣᨱᩥᨶᩣ ᨸᩁᩥᨾᨴ᩠ᨴᩥᨲᩴ;

ᩈᩣᩅᩴ ᨩᩣᨲᩴ [ᨿᨶ᩠ᨲᩴ (ᨠ.)] ᨾᩩᨡᩴ ᨲᩩᨿ᩠ᩉᩴ, ᨾᨾᩴ ᨴᩥᩈ᩠ᩅᩣᨶ ᩑᨴᩥᩈᩴ.

᪘᪕᪐. ‘‘ᨠᨧ᩠ᨧᩥ ᨶᩩ ᨲᩮ ᨶᩣᨽᩥᩈᩈᩥ [ᨲᩮ ᨶᩣᨽᩥᩈᨿᩥ (ᩈᩦ.), ᨲᩮ ᨶᩣᨽᩥᩔᩈᩥ (ᩈ᩠ᨿᩣ.)], ᨠᨧ᩠ᨧᩥ ᨲᩮ ᩋᨲ᩠ᨳᩥ ᩅᩮᨴᨶᩣ;

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

᪘᪕᪑. ‘‘ᩈᩩᨸᩥᨶᩴ ᨲᩣᨲ ᩋᨴ᩠ᨴᨠ᩠ᨡᩥᩴ, ᩍᨲᩮᩣ ᨾᩣᩈᩴ ᩋᨵᩮᩣᨣᨲᩴ;

ᨴᨠ᩠ᨡᩥᨱᩴ ᩅᩥᨿ ᨾᩮ ᨻᩣᩉᩩᩴ, ᨨᩮᨲ᩠ᩅᩣ ᩁᩩᩉᩥᩁᨾᨠ᩠ᨡᩥᨲᩴ;

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

᪘᪕᪒. ‘‘ᨿᨲᩮᩣᩉᩴ [ᨿᨲᩮᩣ ᨲᩴ (ᩈᩦ.)] ᩈᩩᨸᩥᨶᨾᨴ᩠ᨴᨠ᩠ᨡᩥᩴ, ᩈᩩᨴᩔᨶ ᩅᩥᨩᩣᨶᩉᩥ;

ᨲᨲᩮᩣ ᨴᩥᩅᩣ ᩅᩣ ᩁᨲ᩠ᨲᩥᩴ ᩅᩣ, ᩈᩩᨡᩴ ᨾᩮ ᨶᩮᩣᨸᩃᨻ᩠ᨽᨲᩥ’’.

᪘᪕᪓. ‘‘ᨿᩴ ᨸᩩᨻ᩠ᨻᩮ ᨸᩁᩥᩅᩣᩁᩥᩴᩈᩩ [ᨸᩁᩥᨧᩣᩁᩥᩴᩈᩩ (ᩈᩦ. ᨸᩦ.)], ᨠᨬ᩠ᨬᩣ ᩁᩩᨧᩥᩁᩅᩥᨣ᩠ᨣᩉᩣ;

ᩉᩮᨾᨩᩣᩃᨸᨭᩥᨧ᩠ᨨᨶ᩠ᨶᩣ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᩣ ᨶ ᨴᩥᩔᨲᩥ.

᪘᪕᪔. ‘‘ᨿᩴ ᨸᩩᨻ᩠ᨻᩮ ᨸᩁᩥᩅᩣᩁᩥᩴᩈᩩ [ᨸᩁᩥᨧᩣᩁᩥᩴᩈᩩ (ᩈᩦ. ᨸᩦ.)], ᨶᩮᨲ᩠ᨲᩥᩴᩈᩅᩁᨵᩣᩁᩥᨶᩮᩣ;

ᨠᨱᩥᨠᩣᩁᩣᩅ ᩈᨾ᩠ᨹᩩᩃ᩠ᩃᩣ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩮᩣ ᨶ ᨴᩥᩔᨲᩥ.

᪘᪕᪕. ‘‘ᩉᨶ᩠ᨴ ᨴᩣᨶᩥ ᨣᨾᩥᩔᩣᨾ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᨶᩥᩅᩮᩈᨶᩴ;

ᨵᨾ᩠ᨾᨭ᩠ᨮᩴ ᩈᩦᩃᩈᨾ᩠ᨸᨶ᩠ᨶᩴ, ᨸᩔᩣᨾ ᨲᩅ ᨽᩣᨲᩁᩴ’’.

᪘᪕᪖. ‘‘ᨲᨬ᩠ᨧ ᨴᩥᩈ᩠ᩅᩣᨶ ᩌᨿᨶ᩠ᨲᩥᩴ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩔ ᨾᩣᨲᩁᩴ;

ᨻᩣᩉᩣ ᨸᨣ᩠ᨣᨿ᩠ᩉ ᨸᨠ᩠ᨠᨶ᩠ᨴᩩᩴ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩔ ᨶᩣᩁᩥᨿᩮᩣ.

᪘᪕᪗. ‘‘ᨸᩩᨲ᩠ᨲᩴ ᨲᩮᨿ᩠ᨿᩮ ᨶ ᨩᩣᨶᩣᨾ, ᩍᨲᩮᩣ ᨾᩣᩈᩴ ᩋᨵᩮᩣᨣᨲᩴ;

ᨾᨲᩴ ᩅᩣ ᨿᨴᩥ ᩅᩣ ᨩᩦᩅᩴ, ᨽᩪᩁᩥᨴᨲ᩠ᨲᩴ ᨿᩈᩔᩥᨶᩴ’’.