᭕᭓᭔. ᬫᬳᬵᬳᬂᬲᬚᬵᬢᬓᬂ (᭒)

᭘᭙. ‘‘ᬏᬢᬾ ᬳᬂᬲᬵ ᬧᬓ᭄ᬓᬫᬦ᭄ᬢᬶ, ᬯᬓ᭄ᬓᬗ᭄ᬕᬵ ᬪᬬᬫᬾᬭᬶᬢᬵ;

ᬳᬭᬶᬢ᭄ᬢᬘ ᬳᬾᬫᬯᬡ᭄ᬡ, ᬓᬵᬫᬂ ᬲᬸᬫᬸᬔ ᬧᬓ᭄ᬓᬫ.

᭙᭐. ‘‘ᬑᬳᬵᬬ ᬫᬂ ᬜᬵᬢᬶᬕᬡᬵ, ᬏᬓᬂ ᬧᬵᬲᬯᬲᬂ ᬕᬢᬂ;

ᬅᬦᬧᬾᬓ᭄ᬔᬫᬵᬦᬵ ᬕᬘ᭄ᬙᬦ᭄ᬢᬶ, ᬓᬶᬂ ᬏᬓᭀ ᬅᬯᬳᬷᬬᬲᬶ.

᭙᭑. ‘‘ᬧᬢᬾᬯ ᬧᬢᬢᬂ ᬲᬾᬝ᭄ᬞ, ᬦᬢ᭄ᬣᬶ ᬩᬤ᭄ᬥᬾ ᬲᬳᬵᬬᬢᬵ;

ᬫᬵ ᬅᬦᬷᬖᬵᬬ ᬳᬵᬧᬾᬲᬶ, ᬓᬵᬫᬂ ᬲᬸᬫᬸᬔ ᬧᬓ᭄ᬓᬫ’’.

᭙᭒. ‘‘ᬦᬵᬳᬂ ᬤᬸᬓ᭄ᬔᬧᬭᬾᬢᭀᬧᬶ [ᬤᬸᬓ᭄ᬔᬧᬭᬾᬢᭀ’’ᬢᬶ (ᬚᬵ. ᭑.᭑᭕.᭑᭓᭖) ᬅᬝ᭄ᬞᬓᬣᬵᬬᭀ ᬑᬮᭀᬓᬾᬢᬩ᭄ᬩᬵ], ᬥᬢᬭᬝ᭄ᬞ ᬢᬸᬯᬂ [ᬢᬯᬂ (ᬲᬷ. ᬧᬷ.)] ᬚᬳᬾ;

ᬚᬷᬯᬶᬢᬂ ᬫᬭᬡᬂ ᬯᬵ ᬫᬾ, ᬢᬬᬵ ᬲᬤ᭄ᬥᬶᬂ ᬪᬯᬶᬲ᭄ᬲᬢᬶ.

᭙᭓. ‘‘ᬦᬵᬳᬂ ᬤᬸᬓ᭄ᬔᬧᬭᬾᬢᭀᬧᬶ, ᬥᬢᬭᬝ᭄ᬞ ᬢᬸᬯᬂ ᬚᬳᬾ;

ᬦ ᬫᬂ ᬅᬦᬭᬶᬬᬲᬂᬬᬸᬢ᭄ᬢᬾ, ᬓᬫ᭄ᬫᬾ ᬬᭀᬚᬾᬢᬸᬫᬭᬳᬲᬶ.

᭙᭔. ‘‘ᬲᬓᬸᬫᬵᬭᭀ ᬲᬔᬵ ᬢ᭄ᬬᬲ᭄ᬫᬶ, ᬲᬘᬶᬢ᭄ᬢᬾ ᬘᬲ᭄ᬫᬶ ᬢᬾ [ᬲᬫᬶᬢᬾ (ᬧᬷ.), ᬢ᭄ᬬᬲ᭄ᬫᬶ ᬢᬾ (ᬓ.)] ᬞᬶᬢᭀ;

ᬜᬵᬢᭀ ᬲᬾᬦᬵᬧᬢᬶ ᬢ᭄ᬬᬵᬳᬂ, ᬳᬂᬲᬵᬦᬂ ᬧᬯᬭᬸᬢ᭄ᬢᬫ.

᭙᭕. ‘‘ᬓᬣᬂ ᬅᬳᬂ ᬯᬶᬓᬢ᭄ᬣᬶᬲ᭄ᬲᬂ [ᬯᬶᬓᬢ᭄ᬢᬶᬲ᭄ᬲᬂ (ᬧᬷ.)], ᬜᬵᬢᬶᬫᬚ᭄ᬛᬾ ᬇᬢᭀ ᬕᬢᭀ;

ᬢᬂ ᬳᬶᬢ᭄ᬯᬵ ᬧᬢᬢᬂ ᬲᬾᬝ᭄ᬞ, ᬓᬶᬂ ᬢᬾ ᬯᬓ᭄ᬔᬵᬫᬶᬢᭀ ᬕᬢᭀ;

ᬇᬥ ᬧᬵᬡᬂ ᬘᬚᬶᬲ᭄ᬲᬵᬫᬶ, ᬦᬵᬦᬭᬶᬬᬂ [ᬦ ᬅᬦᬭᬶᬬᬂ (ᬧᬷ.)] ᬓᬢ᭄ᬢᬸᬫᬸᬲ᭄ᬲᬳᬾ’’.

᭙᭖. ‘‘ᬏᬲᭀ ᬳᬶ ᬥᬫ᭄ᬫᭀ ᬲᬸᬫᬸᬔ, ᬬᬂ ᬢ᭄ᬯᬂ ᬅᬭᬶᬬᬧᬣᬾ ᬞᬶᬢᭀ;

ᬬᭀ ᬪᬢ᭄ᬢᬵᬭᬂ ᬲᬔᬵᬭᬂ ᬫᬂ, ᬦ ᬧᬭᬶᬘ᭄ᬘᬢ᭄ᬢᬸᬫᬸᬲ᭄ᬲᬳᬾ.

᭙᭗. ‘‘ᬢᬜ᭄ᬳᬶ ᬫᬾ ᬧᬾᬓ᭄ᬔᬫᬵᬦᬲ᭄ᬲ, ᬪᬬᬂ ᬦᬢ᭄ᬯᬾᬯ ᬚᬵᬬᬢᬶ;

ᬅᬥᬶᬕᬘ᭄ᬙᬲᬶ ᬢ᭄ᬯᬂ ᬫᬬ᭄ᬳᬂ, ᬏᬯᬂ ᬪᬹᬢᬲ᭄ᬲ ᬚᬷᬯᬶᬢᬂ’’.

᭙᭘. ‘‘ᬇᬘ᭄ᬘᬾᬯᬂ [ᬇᬘ᭄ᬘᬾᬯ (ᬲᬷ. ᬧᬷ.)] ᬫᬦ᭄ᬢᬬᬦ᭄ᬢᬵᬦᬂ, ᬅᬭᬶᬬᬵᬦᬂ ᬅᬭᬶᬬᬯᬸᬢ᭄ᬢᬶᬦᬂ;

ᬤᬡ᭄ᬟᬫᬵᬤᬵᬬ ᬦᬾᬲᬵᬤᭀ, ᬆᬧᬢᬷ [ᬆᬧᬤᬷ (ᬓ.)] ᬢᬸᬭᬶᬢᭀ ᬪᬸᬲᬂ.

᭙᭙. ‘‘ᬢᬫᬵᬧᬢᬦ᭄ᬢᬂ ᬤᬶᬲ᭄ᬯᬵᬦ, ᬲᬸᬫᬸᬔᭀ ᬅᬢᬶᬩ᭄ᬭᬹᬳᬬᬶ [ᬅᬧᬭᬶᬩ᭄ᬭᬹᬳᬬᬶ (ᬲᬷ. ᬧᬷ.)];

ᬅᬝ᭄ᬞᬵᬲᬶ ᬧᬸᬭᬢᭀ ᬭᬜ᭄ᬜᭀ, ᬳᬂᬲᭀ ᬯᬶᬲ᭄ᬲᬵᬲᬬᬂ ᬩ᭄ᬬᬥᬂ [ᬩ᭄ᬬᬣᬂ (ᬲᬷ. ᬲ᭄ᬬᬵ. ᬧᬷ.)].

᭑᭐᭐. ‘‘ᬫᬵ ᬪᬵᬬᬶ ᬧᬢᬢᬂ ᬲᬾᬝ᭄ᬞ, ᬦ ᬳᬶ ᬪᬵᬬᬦ᭄ᬢᬶ ᬢᬵᬤᬶᬲᬵ;

ᬅᬳᬂ ᬬᭀᬕᬂ ᬧᬬᬸᬜ᭄ᬚᬶᬲ᭄ᬲᬂ, ᬬᬸᬢ᭄ᬢᬂ ᬥᬫ᭄ᬫᬹᬧᬲᬂᬳᬶᬢᬂ;

ᬢᬾᬦ ᬧᬭᬶᬬᬵᬧᬤᬵᬦᬾᬦ [ᬧᬭᬶᬬᬵᬤᬵᬦᬾᬦ (ᬓ.)], ᬔᬶᬧ᭄ᬧᬂ ᬧᬵᬲᬵ ᬧᬫᭀᬓ᭄ᬔᬲᬶ’’.

᭑᭐᭑. ‘‘ᬢᬲ᭄ᬲ ᬢᬂ ᬯᬘᬦᬂ ᬲᬸᬢ᭄ᬯᬵ, ᬲᬸᬫᬸᬔᬲ᭄ᬲ ᬲᬸᬪᬵᬲᬶᬢᬂ;

ᬧᬳᬝ᭄ᬞᬮᭀᬫᭀ ᬦᬾᬲᬵᬤᭀ, ᬅᬜ᭄ᬚᬮᬶᬲ᭄ᬲ ᬧᬡᬵᬫᬬᬶ.

᭑᭐᭒. ‘‘ᬦ ᬫᬾ ᬲᬸᬢᬂ ᬯᬵ ᬤᬶᬝ᭄ᬞᬂ ᬯᬵ, ᬪᬵᬲᬦ᭄ᬢᭀ ᬫᬵᬦᬸᬲᬶᬂ ᬤᬶᬚᭀ;

ᬅᬭᬶᬬᬂ ᬩ᭄ᬭᬸᬯᬵᬦᭀ [ᬩ᭄ᬭᬹᬳᬦ᭄ᬢᭀ (ᬲ᭄ᬬᬵ. ᬓ.)] ᬯᬓ᭄ᬓᬗ᭄ᬕᭀ, ᬘᬚᬦ᭄ᬢᭀ ᬫᬵᬦᬸᬲᬶᬂ ᬕᬶᬭᬂ.

᭑᭐᭓. ‘‘ᬓᬶᬦ᭄ᬦᬸ ᬢᬵᬬᬂ ᬤᬶᬚᭀ ᬳᭀᬢᬶ, ᬫᬸᬢ᭄ᬢᭀ ᬩᬤ᭄ᬥᬂ ᬉᬧᬵᬲᬲᬶ;

ᬑᬳᬵᬬ ᬲᬓᬸᬡᬵ ᬬᬦ᭄ᬢᬶ, ᬓᬶᬂ ᬏᬓᭀ ᬅᬯᬳᬷᬬᬲᬶ’’.

᭑᭐᭔. ‘‘ᬭᬵᬚᬵ ᬫᬾ ᬲᭀ ᬤᬶᬚᬵᬫᬶᬢ᭄ᬢ, ᬲᬾᬦᬵᬧᬘ᭄ᬘᬲ᭄ᬲ ᬓᬵᬭᬬᬶᬂ;

ᬢᬫᬵᬧᬤᬾ ᬧᬭᬶᬘ᭄ᬘᬢ᭄ᬢᬸᬂ, ᬦᬸᬲ᭄ᬲᬳᬾ ᬯᬶᬳᬕᬵᬥᬶᬧᬂ.

᭑᭐᭕. ‘‘ᬫᬳᬵᬕᬡᬵᬬ ᬪᬢ᭄ᬢᬵ ᬫᬾ, ᬫᬵ ᬏᬓᭀ ᬩ᭄ᬬᬲᬦᬂ ᬅᬕᬵ;

ᬢᬣᬵ ᬢᬂ ᬲᬫ᭄ᬫ ᬦᬾᬲᬵᬤ, ᬪᬢ᭄ᬢᬵᬬᬂ ᬅᬪᬶᬢᭀ ᬭᬫᬾ’’.

᭑᭐᭖. ‘‘ᬅᬭᬶᬬᬯᬢ᭄ᬢᬲᬶ ᬯᬓ᭄ᬓᬗ᭄ᬕ, ᬬᭀ ᬧᬶᬡ᭄ᬟᬫᬧᬘᬵᬬᬲᬶ;

ᬘᬚᬵᬫᬶ ᬢᬾ ᬢᬂ ᬪᬢ᭄ᬢᬵᬭᬂ, ᬕᬘ᭄ᬙᬣᬹᬪᭀ [ᬕᬘ᭄ᬙᬢᬸ ᬪᭀ (ᬧᬷ.)] ᬬᬣᬵᬲᬸᬔᬂ’’.

᭑᭐᭗. ‘‘ᬲᬘᬾ ᬅᬢ᭄ᬢᬧ᭄ᬧᬬᭀᬕᬾᬦ, ᬑᬳᬶᬢᭀ ᬳᬂᬲᬧᬓ᭄ᬔᬶᬦᬂ;

ᬧᬝᬶᬕᬡ᭄ᬳᬵᬫ ᬢᬾ ᬲᬫ᭄ᬫ, ᬏᬢᬂ ᬅᬪᬬᬤᬓ᭄ᬔᬶᬡᬂ.

᭑᭐᭘. ‘‘ᬦᭀ ᬘᬾ ᬅᬢ᭄ᬢᬧ᭄ᬧᬬᭀᬕᬾᬦ, ᬑᬳᬶᬢᭀ ᬳᬂᬲᬧᬓ᭄ᬔᬶᬦᬂ;

ᬅᬦᬶᬲ᭄ᬲᬭᭀ ᬫᬸᬜ᭄ᬘᬫᬫ᭄ᬳᬾ, ᬣᬾᬬ᭄ᬬᬂ ᬓᬬᬶᬭᬵᬲᬶ ᬮᬸᬤ᭄ᬤᬓ’’.

᭑᭐᭙. ‘‘ᬬᬲ᭄ᬲ ᬢ᭄ᬯᬂ ᬪᬢᬓᭀ [ᬪᬝᬓᭀ (ᬓ.)] ᬭᬜ᭄ᬜᭀ, ᬓᬵᬫᬂ ᬢᬲ᭄ᬲᬾᬯ ᬧᬵᬧᬬ;

ᬢᬢ᭄ᬣ ᬲᬂᬬᬫᬦᭀ [ᬲᬂᬬᬫᬵᬦᭀ (ᬧᬷ.)] ᬭᬵᬚᬵ, ᬬᬣᬵᬪᬶᬜ᭄ᬜᬂ ᬓᬭᬶᬲ᭄ᬲᬢᬶ’’.

᭑᭑᭐. ‘‘ᬇᬘ᭄ᬘᬾᬯᬂ ᬯᬸᬢ᭄ᬢᭀ ᬦᬾᬲᬵᬤᭀ, ᬳᬾᬫᬯᬡ᭄ᬡᬾ ᬳᬭᬶᬢ᭄ᬢᬘᬾ;

ᬉᬪᭀ ᬳᬢ᭄ᬣᬾᬳᬶ ᬲᬗ᭄ᬕᬬ᭄ᬳ [ᬧᬕ᭄ᬕᬬ᭄ᬳ (ᬲ᭄ᬬᬵ. ᬓ.)], ᬧᬜ᭄ᬚᬭᬾ ᬅᬚ᭄ᬛᬯᭀᬤᬳᬶ.

᭑᭑᭑. ‘‘ᬢᬾ ᬧᬜ᭄ᬚᬭᬕᬢᬾ ᬧᬓ᭄ᬔᬷ, ᬉᬪᭀ ᬪᬲ᭄ᬲᬭᬯᬡ᭄ᬡᬶᬦᬾ;

ᬲᬸᬫᬸᬔᬂ ᬥᬢᬭᬝ᭄ᬞᬜ᭄ᬘ, ᬮᬸᬤ᭄ᬤᭀ ᬆᬤᬵᬬ ᬧᬓ᭄ᬓᬫᬶ’’.

᭑᭑᭒. ‘‘ᬳᬭᬷᬬᬫᬵᬦᭀ ᬥᬢᬭᬝ᭄ᬞᭀ, ᬲᬸᬫᬸᬔᬂ ᬏᬢᬤᬩ᭄ᬭᬯᬶ;

ᬩᬵᬮ᬴᭄ᬳᬂ ᬪᬵᬬᬵᬫᬶ ᬲᬸᬫᬸᬔ, ᬲᬵᬫᬵᬬ ᬮᬓ᭄ᬔᬡᬹᬭᬸᬬᬵ;

ᬅᬲ᭄ᬫᬵᬓᬂ ᬯᬥᬫᬜ᭄ᬜᬵᬬ, ᬅᬣᬢ᭄ᬢᬵᬦᬂ ᬯᬥᬶᬲ᭄ᬲᬢᬶ.

᭑᭑᭓. ‘‘ᬧᬵᬓᬳᬂᬲᬵ ᬘ ᬲᬸᬫᬸᬔ, ᬲᬸᬳᬾᬫᬵ ᬳᬾᬫᬲᬸᬢ᭄ᬢᬘᬵ;

ᬓᭀᬜ᭄ᬘᬷ ᬲᬫᬸᬤ᭄ᬤᬢᬷᬭᬾᬯ, ᬓᬧᬡᬵ ᬦᬹᬦ ᬭᬸᬘ᭄ᬙᬢᬶ’’.

᭑᭑᭔. ‘‘ᬏᬯᬂ ᬫᬳᬦ᭄ᬢᭀ ᬮᭀᬓᬲ᭄ᬲ, ᬅᬧ᭄ᬧᬫᬾᬬ᭄ᬬᭀ ᬫᬳᬵᬕᬡᬷ;

ᬏᬓᬶᬢ᭄ᬣᬶᬫᬦᬸᬲᭀᬘᬾᬬ᭄ᬬ, ᬦᬬᬶᬤᬂ ᬧᬜ᭄ᬜᬯᬢᬵᬫᬶᬯ.

᭑᭑᭕. ‘‘ᬯᬵᬢᭀᬯ ᬕᬦ᭄ᬥᬫᬵᬤᬾᬢᬶ, ᬉᬪᬬᬂ ᬙᬾᬓᬧᬵᬧᬓᬂ;

ᬩᬵᬮᭀ ᬆᬫᬓᬧᬓ᭄ᬓᬂᬯ, ᬮᭀᬮᭀ ᬅᬦ᭄ᬥᭀᬯ ᬆᬫᬶᬲᬂ.

᭑᭑᭖. ‘‘ᬅᬯᬶᬦᬶᬘ᭄ᬙᬬᬜ᭄ᬜᬸ ᬅᬢ᭄ᬣᬾᬲᬸ, ᬫᬦ᭄ᬤᭀᬯ ᬧᬝᬶᬪᬵᬲᬶ [ᬧᬝᬶᬪᬵᬢᬶ (ᬓ.)] ᬫᬂ;

ᬓᬶᬘ᭄ᬘᬵᬓᬶᬘ᭄ᬘᬂ ᬦ ᬚᬵᬦᬵᬲᬶ, ᬲᬫ᭄ᬧᬢ᭄ᬢᭀ ᬓᬵᬮᬧᬭᬶᬬᬵᬬᬂ.

᭑᭑᭗. ‘‘ᬅᬟ᭄ᬠᬸᬫ᭄ᬫᬢ᭄ᬢᭀ ᬉᬤᬷᬭᬾᬲᬶ, ᬬᭀ ᬲᬾᬬ᭄ᬬᬵ ᬫᬜ᭄ᬜᬲᬶᬢ᭄ᬣᬶᬬᭀ;

ᬩᬳᬸᬲᬵᬥᬵᬭᬡᬵ ᬳᬾᬢᬵ, ᬲᭀᬡ᭄ᬟᬵᬦᬂᬯ ᬲᬸᬭᬵᬖᬭᬂ.

᭑᭑᭘. ‘‘ᬫᬵᬬᬵ ᬘᬾᬲᬵ ᬫᬭᬷᬘᬷ ᬘ, ᬲᭀᬓᭀ ᬭᭀᬕᭀ ᬘᬸᬧᬤ᭄ᬤᬯᭀ;

ᬔᬭᬵ ᬘ ᬩᬦ᭄ᬥᬦᬵ ᬘᬾᬢᬵ, ᬫᬘ᭄ᬘᬸᬧᬵᬲᬵ ᬕᬸᬳᬵᬲᬬᬵ [ᬧᬘ᭄ᬘᬸᬧᬵᬲᭀ ᬕᬸᬳᬵᬲᬬᭀ (ᬲᬷ. ᬧᬷ.)];

ᬢᬵᬲᬸ ᬬᭀ ᬯᬶᬲ᭄ᬲᬲᬾ ᬧᭀᬲᭀ, ᬲᭀ ᬦᬭᬾᬲᬸ ᬦᬭᬵᬥᬫᭀ’’.

᭑᭑᭙. ‘‘ᬬᬂ ᬯᬸᬤ᭄ᬥᬾᬳᬶ ᬉᬧᬜ᭄ᬜᬵᬢᬂ, ᬓᭀ ᬢᬂ ᬦᬶᬦ᭄ᬤᬶᬢᬸᬫᬭᬳᬢᬶ;

ᬫᬳᬵᬪᬹᬢᬶᬢ᭄ᬣᬶᬬᭀ ᬦᬵᬫ, ᬮᭀᬓᬲ᭄ᬫᬶᬂ ᬉᬤᬧᬚ᭄ᬚᬶᬲᬸᬂ.

᭑᭒᭐. ‘‘ᬔᬶᬟ᭄ᬟᬵ ᬧᬡᬶᬳᬶᬢᬵ ᬢ᭄ᬬᬵᬲᬸ, ᬭᬢᬶ ᬢ᭄ᬬᬵᬲᬸ ᬧᬢᬶᬝ᭄ᬞᬶᬢᬵ;

ᬩᬷᬚᬵᬦᬶ ᬢ᭄ᬬᬵᬲᬸ ᬭᬹᬳᬦ᭄ᬢᬶ, ᬬᬤᬶᬤᬂ ᬲᬢ᭄ᬢᬵ ᬧᬚᬵᬬᬭᬾ;

ᬢᬵᬲᬸ ᬓᭀ ᬦᬶᬩ᭄ᬩᬶᬤᬾ [ᬦᬶᬩ᭄ᬩᬶᬚᬾ (ᬓ.)] ᬧᭀᬲᭀ, ᬧᬵᬡᬫᬵᬲᬚ᭄ᬚ ᬧᬵᬡᬶᬪᬶ [ᬧᬵᬡᬳᬶ (ᬲᬷ.)].

᭑᭒᭑. ‘‘ᬢ᭄ᬯᬫᬾᬯ ᬦᬜ᭄ᬜᭀ ᬲᬸᬫᬸᬔ, ᬣᬷᬦᬂ ᬅᬢ᭄ᬣᬾᬲᬸ ᬬᬸᬜ᭄ᬚᬲᬶ;

ᬢᬲ᭄ᬲ ᬢ᭄ᬬᬚ᭄ᬚ ᬪᬬᬾ ᬚᬵᬢᬾ, ᬪᬷᬢᬾᬦ ᬚᬵᬬᬢᬾ ᬫᬢᬶ.

᭑᭒᭒. ‘‘ᬲᬩ᭄ᬩᭀ ᬳᬶ ᬲᬂᬲᬬᬂ ᬧᬢ᭄ᬢᭀ, ᬪᬬᬂ ᬪᬷᬭᬸ ᬢᬶᬢᬶᬓ᭄ᬔᬢᬶ;

ᬧᬡ᭄ᬟᬶᬢᬵ ᬘ ᬫᬳᬦ᭄ᬢᬵᬦᭀ [ᬫᬳᬢ᭄ᬢᬵᬦᭀ (ᬲᬷ.)], ᬅᬢ᭄ᬣᬾ ᬬᬸᬜ᭄ᬚᬦ᭄ᬢᬶ ᬤᬸᬬ᭄ᬬᬸᬚᬾ.

᭑᭒᭓. ‘‘ᬏᬢᬤᬢ᭄ᬣᬵᬬ ᬭᬵᬚᬵᬦᭀ, ᬲᬹᬭᬫᬶᬘ᭄ᬙᬦ᭄ᬢᬶ ᬫᬦ᭄ᬢᬶᬦᬂ;

ᬧᬝᬶᬩᬵᬳᬢᬶ ᬬᬂ ᬲᬹᬭᭀ, ᬆᬧᬤᬂ ᬅᬢ᭄ᬢᬧᬭᬶᬬᬵᬬᬂ.

᭑᭒᭔. ‘‘ᬫᬵ ᬦᭀ ᬅᬚ᭄ᬚ ᬯᬶᬓᬦ᭄ᬢᬶᬂᬲᬸ, ᬭᬜ᭄ᬜᭀ ᬲᬹᬤᬵ ᬫᬳᬵᬦᬲᬾ;

ᬢᬣᬵ ᬳᬶ ᬯᬡ᭄ᬡᭀ ᬧᬢ᭄ᬢᬵᬦᬂ, ᬨᬮᬂ ᬯᬾᬮ᬴ᬸᬂᬯ ᬢᬂ ᬯᬥᬶ.

᭑᭒᭕. ‘‘ᬫᬸᬢ᭄ᬢᭀᬧᬶ ᬦ ᬇᬘ᭄ᬙᬶ [ᬦᬶᬘ᭄ᬙᬲᬶ (ᬓ.)] ᬉᬟ᭄ᬟᬾᬢᬸᬂ [ᬑᬟ᭄ᬟᬾᬢᬸᬂ (ᬲᬷ.)], ᬲᬬᬂ ᬩᬦ᭄ᬥᬂ ᬉᬧᬵᬕᬫᬶ;

ᬲᭀᬧᬚ᭄ᬚ ᬲᬂᬲᬬᬂ ᬧᬢ᭄ᬢᭀ, ᬅᬢ᭄ᬣᬂ ᬕᬡ᭄ᬳᬵᬳᬶ ᬫᬵ ᬫᬸᬔᬂ’’.

᭑᭒᭖. ‘‘ᬲᭀ ᬢᬂ [ᬢ᭄ᬯᬂ (ᬲ᭄ᬬᬵ. ᬧᬷ.)] ᬬᭀᬕᬂ ᬧᬬᬸᬜ᭄ᬚᬲ᭄ᬲᬸ, ᬬᬸᬢ᭄ᬢᬂ ᬥᬫ᭄ᬫᬹᬧᬲᬂᬳᬶᬢᬂ [ᬥᬫ᭄ᬫᭀᬧᬲᬜ᭄ᬳᬶᬢᬂ (ᬓ.)];

ᬢᬯ ᬧᬭᬶᬬᬵᬧᬤᬵᬦᬾᬦ, ᬫᬫ ᬧᬵᬡᬾᬲᬦᬂ ᬘᬭ’’.

᭑᭒᭗. ‘‘ᬫᬵ ᬪᬵᬬᬶ ᬧᬢᬢᬂ ᬲᬾᬝ᭄ᬞ, ᬦ ᬳᬶ ᬪᬵᬬᬦ᭄ᬢᬶ ᬢᬵᬤᬶᬲᬵ;

ᬅᬳᬂ ᬬᭀᬕᬂ ᬧᬬᬸᬜ᭄ᬚᬶᬲ᭄ᬲᬂ, ᬬᬸᬢ᭄ᬢᬂ ᬥᬫ᭄ᬫᬹᬧᬲᬂᬳᬶᬢᬂ [ᬥᬫ᭄ᬫᭀᬧᬲᬜ᭄ᬳᬶᬢᬂ (ᬓ.)];

ᬫᬫ ᬧᬭᬶᬬᬵᬧᬤᬵᬦᬾᬦ, ᬔᬶᬧ᭄ᬧᬂ ᬧᬵᬲᬵ ᬧᬫᭀᬓ᭄ᬔᬲᬶ’’.

᭑᭒᭘. ‘‘ᬲᭀ [ᬲ (ᬲᬷ.)] ᬮᬸᬤ᭄ᬤᭀ ᬳᬂᬲᬓᬵᬚᬾᬦ [ᬳᬂᬲᬓᬵᬘᬾᬦ (ᬧᬷ.)], ᬭᬵᬚᬤ᭄ᬯᬵᬭᬂ ᬉᬧᬵᬕᬫᬶ;

ᬧᬝᬶᬯᬾᬤᬾᬣ ᬫᬂ ᬭᬜ᭄ᬜᭀ, ᬥᬢᬭᬝ᭄ᬞᬵᬬᬫᬵᬕᬢᭀ’’.

᭑᭒᭙. ‘‘ᬢᬾ ᬤᬶᬲ᭄ᬯᬵ ᬧᬸᬜ᭄ᬜᬲᬂᬓᬵᬲᬾ, ᬉᬪᭀ ᬮᬓ᭄ᬔᬡᬲᬫ᭄ᬫᬢᬾ [ᬮᬓ᭄ᬔᬜ᭄ᬜᬵᬲᬫ᭄ᬫᬢᬾ (ᬲᬷ. ᬧᬷ.)];

ᬔᬮᬸ ᬲᬂᬬᬫᬦᭀ ᬭᬵᬚᬵ, ᬅᬫᬘ᭄ᬘᬾ ᬅᬚ᭄ᬛᬪᬵᬲᬣ.

᭑᭓᭐. ‘‘ᬤᬾᬣ ᬮᬸᬤ᭄ᬤᬲ᭄ᬲ ᬯᬢ᭄ᬣᬵᬦᬶ, ᬅᬦ᭄ᬦᬂ ᬧᬵᬦᬜ᭄ᬘ ᬪᭀᬚᬦᬂ;

ᬓᬵᬫᬂ ᬓᬭᭀ ᬳᬶᬭᬜ᭄ᬜᬲ᭄ᬲ, ᬬᬵᬯᬦ᭄ᬢᭀ ᬏᬲ ᬇᬘ᭄ᬙᬢᬶ’’.

᭑᭓᭑. ‘‘ᬤᬶᬲ᭄ᬯᬵ ᬮᬸᬤ᭄ᬤᬂ ᬧᬲᬦ᭄ᬦᬢ᭄ᬢᬂ, ᬓᬵᬲᬶᬭᬵᬚᬵ ᬢᬤᬩ᭄ᬭᬯᬶ;

ᬬᬤ᭄ᬬᬵᬬᬂ [ᬬᬤᬵᬬᬂ (ᬲᬷ. ᬲ᭄ᬬᬵ. ᬧᬷ.)] ᬲᬫ᭄ᬫ ᬔᬾᬫᬓ, ᬧᬸᬡ᭄ᬡᬵ ᬳᬂᬲᬾᬳᬶ ᬢᬶᬝ᭄ᬞᬢᬶ.

᭑᭓᭒. ‘‘ᬓᬣᬂ ᬭᬸᬘᬶᬫᬚ᭄ᬛᬕᬢᬂ, ᬧᬵᬲᬳᬢ᭄ᬣᭀ ᬉᬧᬵᬕᬫᬶ;

ᬑᬓᬶᬡ᭄ᬡᬂ ᬜᬵᬢᬶᬲᬗ᭄ᬖᬾᬳᬶ, ᬦᬶᬫ᭄ᬫᬚ᭄ᬛᬶᬫᬂ [ᬦᬶᬫᬚ᭄ᬛᬶᬫᬂ (ᬲᬷ. ᬧᬷ. ᬓ.)] ᬓᬣᬂ ᬕᬳᬶ’’.

᭑᭓᭓. ‘‘ᬅᬚ᭄ᬚ ᬫᬾ ᬲᬢ᭄ᬢᬫᬵ ᬭᬢ᭄ᬢᬶ, ᬅᬤᬦᬵᬦᬶ [ᬆᬤᬵᬦᬵᬦᬶ (ᬲ᭄ᬬᬵ. ᬧᬷ. ᬓ.)] ᬉᬧᬵᬲᬢᭀ [ᬉᬧᬵᬕᬢᭀ (ᬓ.)];

ᬧᬤᬫᬾᬢᬲ᭄ᬲ ᬅᬦ᭄ᬯᬾᬲᬂ, ᬅᬧ᭄ᬧᬫᬢ᭄ᬢᭀ ᬖᬝᬲ᭄ᬲᬶᬢᭀ.

᭑᭓᭔. ‘‘ᬅᬣᬲ᭄ᬲ ᬧᬤᬫᬤ᭄ᬤᬓ᭄ᬔᬶᬂ, ᬘᬭᬢᭀ ᬅᬤᬦᬾᬲᬦᬂ;

ᬢᬢ᭄ᬣᬵᬳᬂ ᬑᬤᬳᬶᬂ ᬧᬵᬲᬂ, ᬏᬯᬂ ᬢᬂ [ᬏᬯᬾᬢᬂ (ᬲᬷ. ᬧᬷ.)] ᬤᬶᬚᬫᬕ᭄ᬕᬳᬶᬂ’’.

᭑᭓᭕. ‘‘ᬮᬸᬤ᭄ᬤ ᬤ᭄ᬯᬾ ᬇᬫᬾ ᬲᬓᬸᬡᬵ, ᬅᬣ ᬏᬓᭀᬢᬶ ᬪᬵᬲᬲᬶ;

ᬘᬶᬢ᭄ᬢᬂ ᬦᬸ ᬢᬾ ᬯᬶᬧᬭᬶᬬᬢ᭄ᬢᬂ [ᬯᬶᬧᬭᬶᬬᬢ᭄ᬣᬂ (ᬧᬷ.)], ᬅᬤᬸ ᬓᬶᬦ᭄ᬦᬸ ᬚᬶᬕᬷᬲᬲᬶ’’ [ᬚᬶᬕᬶᬂᬲᬲᬶ (ᬲᬷ. ᬧᬷ.)].

᭑᭓᭖. ‘‘ᬬᬲ᭄ᬲ ᬮᭀᬳᬶᬢᬓᬵ ᬢᬵᬮᬵ, ᬢᬧᬦᬷᬬᬦᬶᬪᬵ ᬲᬸᬪᬵ;

ᬉᬭᬂ ᬲᬂᬳᬘ᭄ᬘ ᬢᬶᬝ᭄ᬞᬦ᭄ᬢᬶ, ᬲᭀ ᬫᬾ ᬩᬦ᭄ᬥᬂ ᬉᬧᬵᬕᬫᬶ.

᭑᭓᭗. ‘‘ᬅᬣᬵᬬᬂ ᬪᬲ᭄ᬲᬭᭀ ᬧᬓ᭄ᬔᬷ, ᬅᬩᬤ᭄ᬥᭀ ᬩᬤ᭄ᬥᬫᬵᬢᬸᬭᬂ;

ᬅᬭᬶᬬᬂ ᬩ᭄ᬭᬸᬯᬵᬦᭀ ᬅᬝ᭄ᬞᬵᬲᬶ, ᬘᬚᬦ᭄ᬢᭀ ᬫᬵᬦᬸᬲᬶᬂ ᬕᬶᬭᬂ’’.

᭑᭓᭘. ‘‘ᬅᬣ ᬓᬶᬂ [ᬅᬣ ᬓᬶᬦ᭄ᬦᬸ (ᬲᬷ. ᬧᬷ.), ᬓᬣᬂ ᬦᬸ (ᬲ᭄ᬬᬵ.)] ᬤᬵᬦᬶ ᬲᬸᬫᬸᬔ, ᬳᬦᬸᬂ ᬲᬂᬳᬘ᭄ᬘ ᬢᬶᬝ᭄ᬞᬲᬶ;

ᬅᬤᬸ ᬫᬾ ᬧᬭᬶᬲᬂ ᬧᬢ᭄ᬢᭀ, ᬪᬬᬵ ᬪᬷᬢᭀ ᬦ ᬪᬵᬲᬲᬶ’’.

᭑᭓᭙. ‘‘ᬦᬵᬳᬂ ᬓᬵᬲᬶᬧᬢᬶ ᬪᬷᬢᭀ, ᬑᬕᬬ᭄ᬳ ᬧᬭᬶᬲᬂ ᬢᬯ;

ᬦᬵᬳᬂ ᬪᬬᬵ ᬦ ᬪᬵᬲᬶᬲ᭄ᬲᬂ, ᬯᬵᬓ᭄ᬬᬂ ᬅᬢ᭄ᬣᬫ᭄ᬳᬶ ᬢᬵᬤᬶᬲᬾ’’.

᭑᭔᭐. ‘‘ᬦ ᬢᬾ ᬅᬪᬶᬲᬭᬂ ᬧᬲ᭄ᬲᬾ, ᬦ ᬭᬣᬾ ᬦᬧᬶ ᬧᬢ᭄ᬢᬶᬓᬾ;

ᬦᬵᬲ᭄ᬲ ᬘᬫ᭄ᬫᬂ ᬯ ᬓᬷᬝᬂ ᬯᬵ, ᬯᬫ᭄ᬫᬶᬢᬾ ᬘ ᬥᬦᬸᬕ᭄ᬕᬳᬾ.

᭑᭔᭑. ‘‘ᬦ ᬳᬶᬭᬜ᭄ᬜᬂ ᬲᬸᬯᬡ᭄ᬡᬂ ᬯᬵ, ᬦᬕᬭᬂ ᬯᬵ ᬲᬸᬫᬵᬧᬶᬢᬂ;

ᬑᬓᬶᬡ᭄ᬡᬧᬭᬶᬔᬂ ᬤᬸᬕ᭄ᬕᬂ, ᬤᬮ᬴᭄ᬳᬫᬝ᭄ᬝᬵᬮᬓᭀᬝ᭄ᬞᬓᬂ;

ᬬᬢ᭄ᬣ ᬧᬯᬶᬝ᭄ᬞᭀ ᬲᬸᬫᬸᬔ, ᬪᬵᬬᬶᬢᬩ᭄ᬩᬂ ᬦ ᬪᬵᬬᬲᬶ’’.

᭑᭔᭒. ‘‘ᬦ ᬫᬾ ᬅᬪᬶᬲᬭᬾᬦᬢ᭄ᬣᭀ, ᬦᬕᬭᬾᬦ ᬥᬦᬾᬦ ᬯᬵ;

ᬅᬧᬣᬾᬦ ᬧᬣᬂ ᬬᬵᬫ, ᬅᬦ᭄ᬢᬮᬶᬓ᭄ᬔᬾᬘᬭᬵ ᬫᬬᬂ.

᭑᭔᭓. ‘‘ᬲᬸᬢᬵ ᬘ ᬧᬡ᭄ᬟᬶᬢᬵ ᬢ᭄ᬬᬫ᭄ᬳᬵ, ᬦᬶᬧᬸᬡᬵ ᬅᬢ᭄ᬣᬘᬶᬦ᭄ᬢᬓᬵ [ᬘᬢ᭄ᬣᬘᬶᬦ᭄ᬢᬓᬵ (ᬓ.)];

ᬪᬵᬲᬾᬫᬢ᭄ᬣᬯᬢᬶᬂ ᬯᬵᬘᬂ, ᬲᬘ᭄ᬘᬾ ᬘᬲ᭄ᬲ ᬧᬢᬶᬝ᭄ᬞᬶᬢᭀ.

᭑᭔᭔. ‘‘ᬓᬶᬜ᭄ᬘ ᬢᬸᬬ᭄ᬳᬂ ᬅᬲᬘ᭄ᬘᬲ᭄ᬲ, ᬅᬦᬭᬶᬬᬲ᭄ᬲ ᬓᬭᬶᬲ᭄ᬲᬢᬶ;

ᬫᬸᬲᬵᬯᬵᬤᬶᬲ᭄ᬲ ᬮᬸᬤ᭄ᬤᬲ᭄ᬲ, ᬪᬡᬶᬢᬫ᭄ᬧᬶ ᬲᬸᬪᬵᬲᬶᬢᬂ’’.

᭑᭔᭕. ‘‘ᬢᬂ ᬩ᭄ᬭᬵᬳ᭄ᬫᬡᬵᬦᬂ ᬯᬘᬦᬵ, ᬇᬫᬂ ᬔᬾᬫᬫᬓᬵᬭᬬᬶ [ᬔᬾᬫᬶᬓᬵᬭᬬᬶ (ᬲᬷ. ᬧᬷ.)];

ᬅᬪᬬᬜ᭄ᬘ ᬢᬬᬵ ᬖᬸᬝ᭄ᬞᬂ, ᬇᬫᬵᬬᭀ ᬤᬲᬥᬵ ᬤᬶᬲᬵ.

᭑᭔᭖. ‘‘ᬑᬕᬬ᭄ᬳ ᬢᬾ ᬧᭀᬓ᭄ᬔᬭᬡᬶᬂ, ᬯᬶᬧ᭄ᬧᬲᬦ᭄ᬦᭀᬤᬓᬂ ᬲᬸᬘᬶᬂ;

ᬧᬳᬹᬢᬂ ᬘᬵᬤᬦᬂ ᬢᬢ᭄ᬣ, ᬅᬳᬶᬂᬲᬵ ᬘᬾᬢ᭄ᬣ ᬧᬓ᭄ᬔᬶᬦᬂ.

᭑᭔᭗. ‘‘ᬇᬤᬂ ᬲᬸᬢ᭄ᬯᬵᬦ ᬦᬶᬕ᭄ᬖᭀᬲᬂ, ᬆᬕᬢᬫ᭄ᬳ ᬢᬯᬦ᭄ᬢᬶᬓᬾ;

ᬢᬾ ᬢᬾ ᬩᬦ᭄ᬥᬲ᭄ᬫ ᬧᬵᬲᬾᬦ, ᬏᬢᬂ ᬢᬾ ᬪᬵᬲᬶᬢᬂ ᬫᬸᬲᬵ.

᭑᭔᭘. ‘‘ᬫᬸᬲᬵᬯᬵᬤᬂ ᬧᬸᬭᬓ᭄ᬔᬢ᭄ᬯᬵ, ᬇᬘ᭄ᬙᬵᬮᭀᬪᬜ᭄ᬘ ᬧᬵᬧᬓᬂ;

ᬉᬪᭀ ᬲᬦ᭄ᬥᬶᬫᬢᬶᬓ᭄ᬓᬫ᭄ᬫ, ᬅᬲᬵᬢᬂ ᬉᬧᬧᬚ᭄ᬚᬢᬶ’’.

᭑᭔᭙. ‘‘ᬦᬵᬧᬭᬚ᭄ᬛᬵᬫ ᬲᬸᬫᬸᬔ, ᬦᬧᬶ ᬮᭀᬪᬵᬯ ᬫᬕ᭄ᬕᬳᬶᬂ;

ᬲᬸᬢᬵ ᬘ ᬧᬡ᭄ᬟᬶᬢᬵᬢ᭄ᬬᬢ᭄ᬣ, ᬦᬶᬧᬸᬡᬵ ᬅᬢ᭄ᬣᬘᬶᬦ᭄ᬢᬓᬵ.

᭑᭕᭐. ‘‘ᬅᬧ᭄ᬧᬾᬯᬢ᭄ᬣᬯᬢᬶᬂ ᬯᬵᬘᬂ, ᬩ᭄ᬬᬵᬳᬭᬾᬬ᭄ᬬᬸᬂ [ᬩ᭄ᬬᬵᬓᬭᬾᬬ᭄ᬬᬸᬂ (ᬲᬷ. ᬧᬷ.)] ᬇᬥᬵᬕᬢᬵ;

ᬢᬣᬵ ᬢᬂ ᬲᬫ᭄ᬫ ᬦᬾᬲᬵᬤᭀ, ᬯᬸᬢ᭄ᬢᭀ ᬲᬸᬫᬸᬔ ᬫᬕ᭄ᬕᬳᬶ’’.

᭑᭕᭑. ‘‘ᬦᬾᬯ ᬪᬷᬢᬵ [ᬪᬹᬢᬵ (ᬲ᭄ᬬᬵ. ᬓ.)] ᬓᬵᬲᬶᬧᬢᬶ, ᬉᬧᬦᬷᬢᬲ᭄ᬫᬶ ᬚᬷᬯᬶᬢᬾ;

ᬪᬵᬲᬾᬫᬢ᭄ᬣᬯᬢᬶᬂ ᬯᬵᬘᬂ, ᬲᬫ᭄ᬧᬢ᭄ᬢᬵ ᬓᬵᬮᬧᬭᬶᬬᬵᬬᬂ.

᭑᭕᭒. ‘‘ᬬᭀ ᬫᬶᬕᬾᬦ ᬫᬶᬕᬂ ᬳᬦ᭄ᬢᬶ, ᬧᬓ᭄ᬔᬶᬂ ᬯᬵ ᬧᬦ ᬧᬓ᭄ᬔᬶᬦᬵ;

ᬲᬸᬢᬾᬦ ᬯᬵ ᬲᬸᬢᬂ ᬓᬶᬡ᭄ᬬᬵ [ᬓᬶᬡᬾ (ᬲᬷ. ᬧᬷ.)], ᬓᬶᬂ ᬅᬦᬭᬶᬬᬢᬭᬂ ᬢᬢᭀ.

᭑᭕᭓. ‘‘ᬬᭀ ᬘᬵᬭᬶᬬᬭᬸᬤᬂ [ᬘ ᬅᬭᬶᬬᬭᬸᬤᬂ (ᬲᬷ. ᬧᬷ.)] ᬪᬵᬲᬾ, ᬅᬦᬭᬶᬬᬥᬫ᭄ᬫᬯᬲ᭄ᬲᬶᬢᭀ [ᬅᬦᬭᬶᬬᬥᬫ᭄ᬫᬫᬯᬲ᭄ᬲᬶᬢᭀ (ᬲᬷ.)];

ᬉᬪᭀ ᬲᭀ ᬥᬂᬲᬢᬾ ᬮᭀᬓᬵ, ᬇᬥ ᬘᬾᬯ ᬧᬭᬢ᭄ᬣ ᬘ.

᭑᭕᭔. ‘‘ᬦ ᬫᬚ᭄ᬚᬾᬣ ᬬᬲᬂ ᬧᬢ᭄ᬢᭀ, ᬦ ᬩ᭄ᬬᬵᬥᬾ [ᬩ᭄ᬬᬣᬾ (ᬲᬷ. ᬧᬷ.)] ᬧᬢ᭄ᬢᬲᬂᬲᬬᬂ;

ᬯᬵᬬᬫᬾᬣᬾᬯ ᬓᬶᬘ᭄ᬘᬾᬲᬸ, ᬲᬂᬯᬭᬾ ᬯᬶᬯᬭᬵᬦᬶ ᬘ.

᭑᭕᭕. ‘‘ᬬᬾ ᬯᬸᬤ᭄ᬥᬵ ᬅᬩ᭄ᬪᬢᬶᬓ᭄ᬓᬦ᭄ᬢᬵ [ᬦᬵᬩ᭄ᬪᬘᬶᬓ᭄ᬔᬦ᭄ᬢᬵ (ᬓ.)], ᬲᬫ᭄ᬧᬢ᭄ᬢᬵ ᬓᬵᬮᬧᬭᬶᬬᬵᬬᬂ;

ᬇᬥ ᬥᬫ᭄ᬫᬂ ᬘᬭᬶᬢ᭄ᬯᬵᬦ, ᬏᬯᬂᬢᬾ [ᬏᬯᬾᬢᬾ (ᬲᬷ. ᬧᬷ.)] ᬢᬶᬤᬶᬯᬂ ᬕᬢᬵ.

᭑᭕᭖. ‘‘ᬇᬤᬂ ᬲᬸᬢ᭄ᬯᬵ ᬓᬵᬲᬶᬧᬢᬶ, ᬥᬫ᭄ᬫᬫᬢ᭄ᬢᬦᬶ ᬧᬵᬮᬬ;

ᬥᬢᬭᬝ᭄ᬞᬜ᭄ᬘ ᬫᬸᬜ᭄ᬘᬵᬳᬶ, ᬳᬂᬲᬵᬦᬂ ᬧᬯᬭᬸᬢ᭄ᬢᬫᬂ’’.

᭑᭕᭗. ‘‘ᬆᬳᬭᬦ᭄ᬢᬸᬤᬓᬂ ᬧᬚ᭄ᬚᬂ, ᬆᬲᬦᬜ᭄ᬘ ᬫᬳᬵᬭᬳᬂ;

ᬧᬜ᭄ᬚᬭᬢᭀ ᬧᬫᭀᬓ᭄ᬔᬵᬫᬶ, ᬥᬢᬭᬝ᭄ᬞᬂ ᬬᬲᬲ᭄ᬲᬶᬦᬂ.

᭑᭕᭘. ‘‘ᬢᬜ᭄ᬘ ᬲᬾᬦᬵᬧᬢᬶᬂ ᬥᬷᬭᬂ, ᬦᬶᬧᬸᬡᬂ ᬅᬢ᭄ᬣᬘᬶᬦ᭄ᬢᬓᬂ;

ᬬᭀ ᬲᬸᬔᬾ ᬲᬸᬔᬶᬢᭀ ᬭᬜ᭄ᬜᬾ [ᬭᬜ᭄ᬜᭀ (ᬲᬷ. ᬲ᭄ᬬᬵ. ᬧᬷ. ᬓ.)], ᬤᬸᬓ᭄ᬔᬶᬢᬾ ᬳᭀᬢᬶ ᬤᬸᬓ᭄ᬔᬶᬢᭀ.

᭑᭕᭙. ‘‘ᬏᬤᬶᬲᭀ ᬔᭀ ᬅᬭᬳᬢᬶ, ᬧᬶᬡ᭄ᬟᬫᬲ᭄ᬦᬵᬢᬸ ᬪᬢ᭄ᬢᬸᬦᭀ;

ᬬᬣᬵᬬᬂ ᬲᬸᬫᬸᬔᭀ ᬭᬜ᭄ᬜᭀ, ᬧᬵᬡᬲᬵᬥᬵᬭᬡᭀ ᬲᬔᬵ’’.