𑀅𑀜𑁆𑀜 > 𑀩𑁆𑀬𑀸𑀓𑀭𑀡 𑀕𑀦𑁆𑀣-𑀲𑀗𑁆𑀕𑀳𑁄 > 𑀅𑀪𑀺𑀥𑀸𑀦𑀧𑁆𑀧𑀤𑀻𑀧𑀺𑀓𑀸𑀧𑀸𑀞

MMR Vol 0

Misc. Paragraph

𑀅𑀪𑀺𑀥𑀸𑀦𑀧𑁆𑀧𑀤𑀻𑀧𑀺𑀓𑀸

𑀩𑀼𑀤𑁆𑀥𑀧𑁆𑀧𑀡𑀸𑀫𑁄

𑀦𑀫𑁄 𑀢𑀲𑁆𑀲 𑀪𑀕𑀯𑀢𑁄 𑀅𑀭𑀳𑀢𑁄 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲

𑀢𑀣𑀸𑀕𑀢𑁄 ¶ 𑀬𑁄 𑀓𑀭𑀼𑀡𑀸𑀓𑀭𑁄 𑀓𑀭𑁄,

𑀧𑀬𑀸𑀢’𑀫𑁄𑀲𑀚𑁆𑀚 𑀲𑀼𑀔𑀧𑁆𑀧𑀤𑀁 𑀧𑀤𑀁;

𑀅𑀓𑀸 𑀧𑀭𑀢𑁆𑀣𑀁 𑀓𑀮𑀺𑀲𑀫𑁆𑀪𑀯𑁂 𑀪𑀯𑁂,

𑀦𑀫𑀸𑀫𑀺 𑀢𑀁 𑀓𑁂𑀯𑀮𑀤𑀼𑀓𑁆𑀓𑀭𑀁 𑀓𑀭𑀁.

𑀅𑀧𑀽𑀚𑀬𑀼𑀁 𑀬𑀁 𑀫𑀼𑀦𑀺𑀓𑀼𑀜𑁆𑀚𑀭𑀸 𑀚𑀭𑀸,

𑀭𑀼𑀚𑀸𑀤𑀺𑀫𑀼𑀢𑁆𑀢𑀸 𑀬𑀳𑀺𑀫𑀼𑀢𑁆𑀢𑀭𑁂 𑀢𑀭𑁂;

𑀞𑀺𑀢𑀸 𑀢𑀺𑀯𑀝𑁆𑀝𑀫𑁆𑀩𑀼𑀦𑀺𑀥𑀺𑀁 𑀦𑀭𑀸𑀦𑀭𑀸,

𑀢𑀭𑀺𑀁𑀲𑀼 𑀢𑀁 𑀥𑀫𑁆𑀫𑀫𑀖𑀧𑁆𑀧𑀳𑀁 𑀧𑀳𑀁.

𑀕𑀢𑀁 𑀫𑀼𑀦𑀺𑀦𑁆𑀤𑁄’𑀭𑀲𑀲𑀽𑀦𑀼𑀢𑀁 𑀦𑀼𑀢𑀁,

𑀲𑀼𑀧𑀼𑀜𑁆𑀜𑀔𑁂𑀢𑁆𑀢𑀁 𑀪𑀼𑀯𑀦𑁂 𑀲𑀼𑀢𑀁 𑀲𑀼𑀢𑀁;

𑀕𑀡𑀫𑁆𑀧𑀺 𑀧𑀸𑀡𑀻𑀓𑀢𑀲𑀁𑀯𑀭𑀁 𑀯𑀭𑀁,

𑀲𑀤𑀸 𑀕𑀼𑀡𑁄𑀖𑁂𑀦 𑀦𑀺𑀭𑀦𑁆𑀢𑀭’𑀦𑁆𑀢𑀭𑀁.

𑀦𑀸𑀫𑀮𑀺𑀗𑁆𑀕𑁂𑀲𑀼 𑀓𑁄𑀲𑀮𑁆𑀮, 𑀫𑀢𑁆𑀣𑀦𑀺𑀘𑁆𑀙𑀬𑀓𑀸𑀭𑀡𑀁;

𑀬𑀢𑁄 𑀫𑀳𑀩𑁆𑀩𑀮𑀁 𑀩𑀼𑀤𑁆𑀥, 𑀯𑀘𑀦𑁂 𑀧𑀸𑀝𑀯𑀢𑁆𑀣𑀺𑀦𑀁.

𑀦𑀸𑀫𑀮𑀺𑀗𑁆𑀕𑀸𑀦𑁆𑀬’𑀢𑁄 ¶ 𑀩𑀼𑀤𑁆𑀥, 𑀪𑀸𑀲𑀺𑀢𑀲𑁆𑀲𑀸’𑀭𑀳𑀸𑀦𑁆𑀬’𑀳𑀁;

𑀤𑀲𑁆𑀲𑀬𑀦𑁆𑀢𑁄 𑀧𑀓𑀸𑀲𑁂𑀲𑁆𑀲, 𑀫𑀪𑀺𑀥𑀸𑀦𑀧𑁆𑀧𑀤𑀻𑀧𑀺𑀓𑀁.

𑀪𑀺𑀬𑁆𑀬𑁄 𑀭𑀽𑀧𑀦𑁆𑀢𑀭𑀸 𑀲𑀸𑀳, 𑀘𑀭𑀺𑀬𑁂𑀦 𑀘 𑀓𑀢𑁆𑀣𑀘𑀺;

𑀓𑁆𑀯𑀘𑀸’ 𑀳𑀘𑁆𑀘𑀯𑀺𑀥𑀸𑀦𑁂𑀦 𑀜𑁂𑀬𑁆𑀬𑀁 𑀣𑀻𑀧𑀼𑀦𑁆𑀦𑀧𑀼𑀁𑀲𑀓𑀁.

𑀅𑀪𑀺𑀦𑁆𑀦𑀮𑀺𑀗𑁆𑀕𑀸𑀦𑀁𑀬𑁂𑀯, 𑀤𑁆𑀯𑀦𑁆𑀤𑁄 𑀘, 𑀮𑀺𑀗𑁆𑀕𑀯𑀸𑀘𑀓𑀸;

𑀕𑀸𑀣𑀸𑀧𑀸𑀤𑀦𑁆𑀢𑀫𑀚𑁆𑀛𑀝𑁆𑀞𑀸, 𑀧𑀼𑀩𑁆𑀩𑀁 𑀬𑀦𑁆𑀢𑁆𑀬𑀧𑀭𑁂 𑀧𑀭𑀁.

𑀧𑀼𑀫𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀧𑀤𑀁 𑀤𑁆𑀯𑀻𑀲𑀼, 𑀲𑀩𑁆𑀩𑀮𑀺𑀗𑁆𑀕𑁂 𑀘 𑀢𑀻𑀲𑁆𑀯𑀺𑀢𑀺;

𑀅𑀪𑀺𑀥𑀸𑀦𑀦𑁆𑀢𑀭𑀸𑀭𑀫𑁆𑀪𑁂, 𑀜𑁂𑀬𑁆𑀬𑀁 𑀢𑁆𑀯’𑀦𑁆𑀢 𑀫𑀣𑀸𑀤𑀺 𑀘.

𑀪𑀺𑀬𑁆𑀬𑁄 𑀧𑀬𑁄𑀕 𑀫𑀸𑀕𑀫𑁆𑀫, 𑀲𑁄𑀕𑀢𑁂 𑀆𑀕𑀫𑁂 𑀓𑁆𑀯𑀘𑀺;

𑀦𑀺𑀖𑀡𑁆𑀟𑀼 𑀬𑀼𑀢𑁆𑀢𑀺 𑀜𑁆𑀘𑀸𑀦𑀻𑀬, 𑀦𑀸𑀫𑀮𑀺𑀗𑁆𑀕𑀁 𑀓𑀣𑀻𑀬𑀢𑀻𑀢𑀺.

𑀩𑀼𑀤𑁆𑀥𑁄 𑀤𑀲𑀩𑀮𑁄 𑀲𑀢𑁆𑀣𑀸, 𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀽 𑀤𑁆𑀯𑀺𑀧𑀤𑀼𑀢𑁆𑀢𑀫𑁄;

𑀫𑀼𑀦𑀺𑀦𑁆𑀤𑁄 𑀪𑀕𑀯𑀸 𑀦𑀸𑀣𑁄, 𑀘𑀓𑁆𑀔𑀼𑀫’𑀗𑁆𑀕𑀻𑀭𑀲𑁄 𑀫𑀼𑀦𑀺.

𑀮𑁄𑀓𑀦𑀸𑀣𑁄’ 𑀦𑀥𑀺𑀯𑀭𑁄, 𑀫𑀳𑁂𑀲𑀺 𑀘 𑀯𑀺𑀦𑀸𑀬𑀓𑁄;

𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼 𑀲𑀼𑀕𑀢𑁄, 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜𑁄 𑀘 𑀫𑀸𑀭𑀚𑀺.

𑀦𑀭𑀲𑀻𑀳𑁄 𑀦𑀭𑀯𑀭𑁄, 𑀥𑀫𑁆𑀫𑀭𑀸𑀚𑀸 𑀫𑀳𑀸𑀫𑀼𑀦𑀺;

𑀤𑁂𑀯𑀤𑁂𑀯𑁄 𑀮𑁄𑀓𑀕𑀭𑀼, 𑀥𑀫𑁆𑀫𑀲𑁆𑀲𑀸𑀫𑀻 𑀢𑀣𑀸𑀕𑀢𑁄.

𑀲𑀬𑀫𑁆𑀪𑀽 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄, 𑀯𑀭𑀧𑀜𑁆𑀜𑁄 𑀘 𑀦𑀸𑀬𑀓𑁄;

𑀚𑀺𑀦𑁄, 𑀲𑀓𑁆𑀓𑁄 𑀢𑀼 𑀲𑀺𑀤𑁆𑀥𑀢𑁆𑀣𑁄, 𑀲𑀼𑀤𑁆𑀥𑁄𑀤𑀦𑀺 𑀘 𑀕𑁄𑀢𑀫𑁄.

𑀲𑀓𑁆𑀬𑀲𑀻𑀳𑁄 𑀢𑀣𑀸 𑀲𑀓𑁆𑀬, 𑀫𑀼𑀦𑀺 𑀘𑀸𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼 𑀘;

𑀫𑁄𑀓𑁆𑀔𑁄 𑀦𑀺𑀭𑁄𑀥𑁄 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀁, 𑀤𑀻𑀧𑁄 𑀢𑀡𑁆𑀳𑀓𑁆𑀔𑀬𑁄 𑀧𑀭𑀁;

𑀢𑀸𑀡𑀁 𑀮𑁂𑀡 𑀫𑀭𑀽𑀧𑀜𑁆𑀘, 𑀲𑀦𑁆𑀢𑀁 𑀲𑀘𑁆𑀘 𑀫𑀦𑀸𑀮𑀬𑀁.

𑀅𑀲𑀗𑁆𑀔𑀢𑀁 𑀲𑀺𑀯 𑀫𑀫𑀢𑀁 𑀲𑀼𑀤𑀼𑀤𑁆𑀤𑀲𑀁,

𑀧𑀭𑀸𑀬𑀡𑀁 𑀲𑀭𑀡 𑀫𑀦𑀻𑀢𑀺𑀓𑀁 𑀢𑀣𑀸;

𑀅𑀦𑀸𑀲𑀯𑀁 𑀥𑀼𑀯 𑀫𑀦𑀺𑀤𑀲𑁆𑀲𑀦𑀸’ 𑀓𑀢𑀸,

𑀧𑀮𑁄𑀓𑀺𑀢𑀁 𑀦𑀺𑀧𑀼𑀡 𑀫𑀦𑀦𑁆𑀢 𑀫𑀓𑁆𑀔𑀭𑀁.

𑀤𑀼𑀓𑁆𑀔𑀓𑁆𑀔𑀬𑁄 ¶ 𑀩𑁆𑀬𑀸𑀩𑀚𑁆𑀛𑀜𑁆𑀘 [𑀩𑁆𑀬𑀸𑀧𑀚𑁆𑀚𑀁 (𑀝𑀻𑀓𑀸)], 𑀯𑀺𑀯𑀝𑁆𑀝𑀁 𑀔𑁂𑀫 𑀓𑁂𑀯𑀮𑀁;

𑀅𑀧𑀯𑀕𑁆𑀕𑁄 𑀯𑀺𑀭𑀸𑀕𑁄 𑀘, 𑀧𑀡𑀻𑀢 𑀫𑀘𑁆𑀘𑀼𑀢𑀁 𑀧𑀤𑀁.

𑀬𑁄𑀕𑀓𑁆𑀔𑁂𑀫𑁄 𑀧𑀸𑀭 𑀫𑀧𑀺, 𑀫𑀼𑀢𑁆𑀢𑀺 𑀲𑀦𑁆𑀢𑀺 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀺𑀬𑁄;

𑀯𑀺𑀫𑀼𑀢𑁆𑀬’ 𑀲𑀗𑁆𑀔𑀢𑀥𑀸𑀢𑀼, 𑀲𑀼𑀤𑁆𑀥𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀺𑀬𑁄 𑀲𑀺𑀬𑀼𑀁.

𑀔𑀻𑀡𑀸𑀲𑀯𑁄 𑀢𑁆𑀯’𑀲𑁂𑀓𑁆𑀔𑁄 𑀘, 𑀯𑀻𑀢𑀭𑀸𑀕𑁄 𑀢𑀣𑀸’ 𑀭𑀳𑀸;

𑀤𑁂𑀯𑀮𑁄𑀓𑁄 𑀤𑀺𑀯𑁄 𑀲𑀕𑁆𑀕𑁄 [𑀦𑀸𑀓𑁄 (𑀲𑀻.)],

𑀢𑀺𑀤𑀲𑀸 𑀢𑁆𑀯’𑀫𑀭𑀸 𑀤𑁂𑀯𑀸, 𑀯𑀺𑀩𑀼𑀥𑀸 𑀘 𑀲𑀼𑀥𑀸𑀲𑀺𑀦𑁄;

𑀲𑀼𑀭𑀸 𑀫𑀭𑀽 𑀤𑀺𑀯𑁄𑀓𑀸 𑀘𑀸, 𑀫𑀢𑀧𑀸 𑀲𑀕𑁆𑀕𑀯𑀸𑀲𑀺𑀦𑁄.

𑀦𑀺𑀚𑁆𑀚𑀭𑀸’ 𑀦𑀺𑀫𑀺𑀲𑀸 𑀤𑀺𑀩𑁆𑀩𑀸, 𑀅𑀧𑀼𑀫𑁂 𑀤𑁂𑀯𑀢𑀸𑀦𑀺 𑀘 [𑀤𑁂𑀯𑀢𑀸 𑀏𑀯 𑀤𑁂𑀯𑀢𑀸𑀦𑀺, 𑀲𑀓𑀢𑁆𑀣𑁂 𑀦𑀺𑀧𑀘𑁆𑀘𑀬𑁄 (𑀝𑀻𑀓𑀸)];

𑀲𑀺𑀤𑁆𑀥𑁄 𑀪𑀽𑀢𑁄 𑀘 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀕𑀼𑀬𑁆𑀳𑀓𑁄 𑀬𑀓𑁆𑀔 𑀭𑀓𑁆𑀔𑀲𑀸;

𑀓𑀼𑀫𑁆𑀪𑀡𑁆𑀟𑁄 𑀘 𑀧𑀺𑀲𑀸𑀘𑀸’𑀤𑀻, 𑀦𑀺𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑀸 𑀤𑁂𑀯𑀬𑁄𑀦𑀺𑀬𑁄.

𑀧𑀼𑀩𑁆𑀩𑀤𑁂𑀯𑀸 𑀲𑀼𑀭𑀭𑀺𑀧𑀽, 𑀅𑀲𑀼𑀭𑀸 𑀤𑀸𑀦𑀯𑀸 𑀧𑀼𑀫𑁂;

𑀢𑀩𑁆𑀩𑀺𑀲𑁂𑀲𑀸 𑀧𑀳𑀸𑀭𑀸𑀤𑁄, 𑀲𑀫𑁆𑀩𑀭𑁄 𑀩𑀮𑀺𑀆𑀤𑀬𑁄.

𑀧𑀺𑀢𑀸𑀫𑀳𑁄 𑀧𑀺𑀢𑀸 𑀩𑁆𑀭𑀳𑁆𑀫𑀸, 𑀮𑁄𑀓𑁂𑀲𑁄 𑀓𑀫𑀮𑀸𑀲𑀦𑁄;

𑀢𑀣𑀸 𑀳𑀺𑀭𑀜𑁆𑀜𑀕𑀩𑁆𑀪𑁄 𑀘, 𑀲𑀼𑀭𑀚𑁂𑀝𑁆𑀞𑁄 𑀧𑀚𑀸𑀧𑀢𑀺.

𑀯𑀸𑀲𑀼𑀤𑁂𑀯𑁄 𑀳𑀭𑀺 [𑀳𑀭𑀻 (𑀝𑀻𑀓𑀸)] 𑀓𑀡𑁆𑀳𑁄, 𑀓𑁂𑀲𑀯𑁄 𑀘𑀓𑁆𑀓𑀧𑀸𑀡𑁆𑀬’𑀣;

𑀫𑀳𑀺𑀲𑁆𑀲𑀭𑁄 𑀲𑀺𑀯𑁄 𑀲𑀽𑀮𑀻, 𑀇𑀲𑁆𑀲𑀭𑁄 𑀧𑀲𑀼𑀧𑀢𑁆𑀬’𑀧𑀺.

𑀳𑀭𑁄 𑀯𑀼𑀢𑁆𑀢𑁄 𑀓𑀼𑀫𑀸𑀭𑁄 𑀢𑀼, 𑀔𑀦𑁆𑀥𑁄 𑀲𑀢𑁆𑀢𑀺𑀥𑀭𑁄 𑀪𑀯𑁂;

𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄 𑀤𑁂𑀯, 𑀭𑀸𑀚𑀸 𑀯𑀚𑀺𑀭𑀧𑀸𑀡𑀺 𑀘;

𑀲𑀼𑀚𑀫𑁆𑀧𑀢𑀺 𑀲𑀳𑀲𑁆𑀲𑀓𑁆𑀔𑁄, 𑀫𑀳𑀺𑀦𑁆𑀤𑁄 𑀯𑀚𑀺𑀭𑀸𑀯𑀼𑀥𑁄.

𑀯𑀸𑀲𑀯𑁄 𑀘 𑀤𑀲𑀲𑀢, 𑀦𑀬𑀦𑁄 𑀢𑀺𑀤𑀺𑀯𑀸𑀥𑀺𑀪𑀽;

𑀲𑀼𑀭𑀦𑀸𑀣𑁄 𑀘 𑀯𑀚𑀺𑀭, 𑀳𑀢𑁆𑀣𑁄 𑀘 𑀪𑀽𑀢𑀧𑀢𑁆𑀬’𑀧𑀺.

𑀫𑀖𑀯𑀸 𑀓𑁄𑀲𑀺𑀬𑁄 𑀇𑀦𑁆𑀤𑁄, 𑀯𑀢𑁆𑀭𑀪𑀽 𑀧𑀸𑀓𑀲𑀸𑀲𑀦𑁄;

𑀯𑀺𑀟𑁄𑀚𑁄 𑀣 𑀲𑀼𑀚𑀸 𑀢𑀲𑁆𑀲 [𑀲𑀼𑀚𑀸𑀢𑀸’𑀲𑁆𑀲 (𑀝𑀻𑀓𑀸)], 𑀪𑀭𑀺𑀬𑀸 𑀣 𑀧𑀼𑀭𑀁 𑀪𑀯𑁂.

𑀫𑀲𑀓𑁆𑀓𑀲𑀸𑀭𑀸 ¶ [𑀫𑀲𑀓𑁆𑀓𑀲𑀸𑀭𑁄 (𑀲𑀻.)] 𑀯𑀲𑁆𑀲𑁄𑀓, 𑀲𑀸𑀭𑀸 𑀘𑁂𑀯𑀸’ 𑀫𑀭𑀸𑀯𑀢𑀻;

𑀏𑀭𑀸𑀯𑀡𑁄 𑀕𑀚𑁄 𑀧𑀡𑁆𑀟𑀼, 𑀓𑀫𑁆𑀩𑀮𑁄 𑀢𑀼 𑀲𑀺𑀮𑀸𑀲𑀦𑀁.

𑀲𑀼𑀯𑀻𑀭𑁄𑀘𑁆𑀘𑀸𑀤𑀬𑁄 𑀧𑀼𑀢𑁆𑀢𑀸, 𑀦𑀦𑁆𑀤𑀸 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻 𑀪𑀯𑁂;

𑀦𑀦𑁆𑀤𑀦𑀁 𑀫𑀺𑀲𑁆𑀲𑀓𑀁 𑀘𑀺𑀢𑁆𑀢, 𑀮𑀢𑀸 𑀨𑀸𑀭𑀼𑀲𑀓𑀁 𑀯𑀦𑀸.

𑀅𑀲𑀦𑀺 𑀤𑁆𑀯𑀻𑀲𑀼 𑀓𑀼𑀮𑀺𑀲𑀁, 𑀯𑀚𑀺𑀭𑀁 𑀧𑀼𑀦𑁆𑀦𑀧𑀼𑀁𑀲𑀓𑁂;

𑀅𑀘𑁆𑀙𑀭𑀸𑀬𑁄𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀼𑀢𑁆𑀢𑀸, 𑀭𑀫𑁆𑀪𑀸 𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀸𑀤𑀬𑁄;

𑀤𑁂𑀯𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀣 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑀸, 𑀧𑀜𑁆𑀘𑀲𑀺𑀔𑁄𑀢𑀺 𑀆𑀤𑀬𑁄.

𑀯𑀺𑀫𑀸𑀦𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀩𑁆𑀬𑀫𑁆𑀳𑀁, 𑀧𑀻𑀬𑀽𑀲𑀁 𑀢𑁆𑀯𑀫𑀢𑀁 𑀲𑀼𑀥𑀸;

𑀲𑀺𑀦𑁂𑀭𑀼 𑀫𑁂𑀭𑀼 𑀢𑀺𑀤𑀺𑀯𑀸, 𑀥𑀸𑀭𑁄 𑀦𑁂𑀭𑀼 𑀲𑀼𑀫𑁂𑀭𑀼 𑀘.

𑀬𑀼𑀕𑀦𑁆𑀥𑀭𑁄 𑀈𑀲𑀥𑀭𑁄, 𑀓𑀭𑀯𑀻𑀓𑁄 𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑁄;

𑀦𑁂𑀫𑀺𑀦𑁆𑀥𑀭𑁄 𑀯𑀺𑀦𑀢𑀓𑁄, 𑀅𑀲𑁆𑀲𑀓𑀡𑁆𑀡𑁄 𑀓𑀼𑀮𑀸𑀘𑀮𑀸.

𑀫𑀦𑁆𑀤𑀸𑀓𑀺𑀦𑀻 𑀢𑀣𑀸’𑀓𑀸𑀲, 𑀕𑀗𑁆𑀕𑀸 𑀲𑀼𑀭𑀦𑀤𑀻 𑀧𑁆𑀬𑀣;

𑀓𑁄𑀯𑀺𑀴𑀸𑀭𑁄 𑀢𑀣𑀸 𑀧𑀸𑀭𑀺, 𑀘𑁆𑀙𑀢𑁆𑀢𑀓𑁄 𑀧𑀸𑀭𑀺𑀚𑀸𑀢𑀓𑁄;

𑀓𑀧𑁆𑀧𑀭𑀼𑀓𑁆𑀔𑁄 𑀢𑀼 𑀲𑀦𑁆𑀢𑀸𑀦𑀸, 𑀤𑀬𑁄 𑀤𑁂𑀯𑀤𑁆𑀤𑀼𑀫𑀸 𑀲𑀺𑀬𑀼𑀁.

𑀧𑀸𑀘𑀻 𑀧𑀢𑀻𑀛𑀼’ 𑀤𑀻𑀘𑀺’𑀢𑁆𑀣𑀻, 𑀧𑀼𑀩𑁆𑀩 𑀧𑀘𑁆𑀙𑀺𑀫 𑀉𑀢𑁆𑀢𑀭𑀸;

𑀤𑀺𑀲𑀸𑀣 𑀤𑀓𑁆𑀔𑀺𑀡𑀸’ 𑀧𑀸𑀘𑀻, 𑀯𑀺𑀤𑀺𑀲𑀸’𑀦𑀼𑀤𑀺𑀲𑀸 𑀪𑀯𑁂.

𑀏𑀭𑀸𑀯𑀢𑁄 [𑀏𑀭𑀸𑀯𑀡𑁄 (𑀲𑀻.), 𑀅𑀫𑀭𑀓𑁄𑀲𑁂 𑀧𑀦 𑀏𑀭𑀸𑀯𑀢𑁄 𑀏𑀯 𑀅𑀢𑁆𑀣𑀺] 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑁄, 𑀯𑀸𑀫𑀦𑁄 𑀓𑀼𑀫𑀼𑀤𑁄’ 𑀜𑁆𑀚𑀦𑁄;

𑀧𑀼𑀧𑁆𑀨𑀤𑀦𑁆𑀢𑁄 𑀲𑀩𑁆𑀩𑀪𑀼𑀫𑁆𑀫𑁄, 𑀲𑀼𑀧𑁆𑀧𑀢𑀻𑀓𑁄 𑀤𑀺𑀲𑀸𑀕𑀚𑀸.

𑀥𑀢𑀭𑀝𑁆𑀞𑁄 𑀘 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑀸, 𑀥𑀺𑀧𑁄, 𑀓𑀼𑀫𑁆𑀪𑀡𑁆𑀟𑀲𑀸𑀫𑀺 𑀢𑀼;

𑀯𑀺𑀭𑀼𑀴𑁆𑀳𑀓𑁄, 𑀯𑀺𑀭𑀽𑀧𑀓𑁆𑀔𑁄, 𑀢𑀼 𑀦𑀸𑀕𑀸𑀥𑀺𑀧𑀢𑀻𑀭𑀺𑀢𑁄.

𑀬𑀓𑁆𑀔𑀸𑀥𑀺𑀧𑁄 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑁄, 𑀓𑀼𑀯𑁂𑀭𑁄 𑀦𑀭𑀯𑀸𑀳𑀦𑁄;

𑀅𑀴𑀓𑀸 [𑀅𑀮𑀓𑀸 (𑀅𑀫𑀭𑀓𑁄𑀲)] 𑀴𑀓𑀫𑀦𑁆𑀤𑀸𑀲𑁆𑀲, 𑀧𑀼𑀭𑀻, 𑀧𑀳𑀭𑀡𑀁 𑀕𑀤𑀸;

𑀘𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑀸𑀦 𑀫𑀥𑀺𑀧𑀸, 𑀧𑀼𑀩𑁆𑀩𑀸𑀤𑀻𑀦𑀁 𑀓𑀫𑀸 𑀇𑀫𑁂.

𑀚𑀸𑀢𑀯𑁂𑀤𑁄 ¶ 𑀲𑀺𑀔𑀻 𑀚𑁄𑀢𑀺, 𑀧𑀸𑀯𑀓𑁄 𑀤𑀳𑀦𑁄’ 𑀦𑀮𑁄;

𑀳𑀼𑀢𑀸𑀯𑀳𑁄’ 𑀘𑁆𑀘𑀺𑀫𑀸 𑀥𑀽𑀫, 𑀓𑁂𑀢𑁆𑀯’𑀕𑁆𑀕𑀺 𑀕𑀺𑀦𑀺 𑀪𑀸𑀦𑀼𑀫𑀸.

𑀢𑁂𑀚𑁄 𑀥𑀽𑀫𑀲𑀺𑀔𑁄 𑀯𑀸𑀬𑀼, 𑀲𑀔𑁄 𑀘 𑀓𑀡𑁆𑀳𑀯𑀢𑁆𑀢𑀦𑀻;

𑀯𑁂𑀲𑁆𑀲𑀸𑀦𑀭𑁄 𑀳𑀼𑀢𑀸𑀲𑁄 𑀣, 𑀲𑀺𑀔𑀸𑀚𑀸𑀮’𑀘𑁆𑀘𑀺 𑀘𑀸𑀧𑀼𑀫𑁂.

𑀯𑀺𑀧𑁆𑀨𑀼𑀮𑀺𑀗𑁆𑀕𑀁 𑀨𑀼𑀮𑀺𑀗𑁆𑀕𑀜𑁆𑀘, 𑀪𑀲𑁆𑀫𑀸 [‘𑀪𑀲𑁆𑀫𑀸’ 𑀢𑀺𑀧𑀤𑀁 𑀭𑀸𑀚𑀸𑀤𑀺𑀕𑀡𑁂 𑀧𑀭𑀺𑀬𑀸𑀧𑀦𑁆𑀦𑀁 (𑀭𑀽𑀧𑀲𑀺𑀤𑁆𑀥𑀺-𑀉𑀡𑀸𑀤𑀺), 𑀪𑀲𑁆𑀫𑀁 (𑀲𑀻.)] 𑀢𑀼 𑀲𑁂𑀝𑁆𑀞𑀺 𑀙𑀸𑀭𑀺𑀓𑀸;

𑀓𑀼𑀓𑁆𑀓𑀼𑀴𑁄 𑀢𑀼’𑀡𑁆𑀳𑀪𑀲𑁆𑀫𑀲𑁆𑀫𑀺, 𑀫𑀗𑁆𑀕𑀸𑀭𑁄’𑀮𑀸𑀢 𑀫𑀼𑀫𑁆𑀫𑀼𑀓𑀁 [𑀢𑀺𑀓𑀁 𑀤𑀺𑀢𑁆𑀢𑀓𑀝𑁆𑀞𑀸𑀤𑀺𑀦𑁆𑀥𑀦𑁂 (𑀝𑀻𑀓𑀸)];

𑀲𑀫𑀺𑀥𑀸 𑀇𑀥𑀼𑀫𑀁 𑀘𑁂’𑀥𑁄, 𑀉𑀧𑀸𑀤𑀸𑀦𑀁 𑀢𑀣𑀺𑀦𑁆𑀥𑀦𑀁.

𑀫𑀸𑀮𑀼𑀢𑁄 𑀧𑀯𑀦𑁄 𑀯𑀸𑀬𑀼, 𑀯𑀸𑀢𑁄’𑀦𑀺𑀮 𑀲𑀫𑀻𑀭𑀡𑀸;

𑀕𑀦𑁆𑀥𑀯𑀸𑀳𑁄 𑀢𑀣𑀸 𑀯𑀸𑀬𑁄, 𑀲𑀫𑀻𑀭𑁄 𑀘 𑀲𑀤𑀸𑀕𑀢𑀺.

𑀯𑀸𑀬𑀼𑀪𑁂𑀤𑀸 𑀇𑀫𑁂 𑀙𑀼’𑀤𑁆𑀥, 𑀗𑁆𑀕𑀫𑁄 𑀘𑀸𑀥𑁄𑀕𑀫𑁄 𑀢𑀣𑀸;

𑀓𑀼𑀘𑁆𑀙𑀺𑀝𑁆𑀞𑁄 𑀘 𑀓𑁄𑀝𑁆𑀞𑀸𑀲𑀬𑁄, 𑀅𑀲𑁆𑀲𑀸𑀲𑀗𑁆𑀕𑀸𑀦𑀼𑀲𑀸𑀭𑀺𑀦𑁄.

𑀯𑁂𑀕𑁄 𑀚𑀯𑁄 𑀭𑀬𑁄 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀢𑀼 𑀲𑀻𑀖𑀁 𑀢𑀼𑀭𑀺𑀢𑀁 𑀮𑀳𑀼;

𑀆𑀲𑀼 𑀢𑀼𑀡𑁆𑀡 𑀫𑀭𑀁 𑀘𑀸𑀯𑀺, 𑀮𑀫𑁆𑀩𑀺𑀢𑀁 𑀢𑀼𑀯𑀝𑀁𑀧𑀺 𑀘.

𑀲𑀢𑀢𑀁 𑀦𑀺𑀘𑁆𑀘 𑀫𑀯𑀺𑀭𑀢𑀸, 𑀦𑀸𑀭𑀢 𑀲𑀦𑁆𑀢𑀢 𑀫𑀦𑀯𑀭𑀢𑀜𑁆𑀘 𑀥𑀼𑀯𑀁;

𑀪𑀼𑀲 𑀫𑀢𑀺𑀲𑀬𑁄 𑀘 𑀤𑀴𑁆𑀳𑀁, 𑀢𑀺𑀩𑁆𑀩𑁂’𑀓𑀦𑁆𑀢𑀸’𑀢𑀺𑀫𑀢𑁆𑀢, 𑀩𑀸𑀴𑁆𑀳𑀸𑀦𑀺;

𑀔𑀺𑀧𑁆𑀧𑀸𑀤𑀻 𑀧𑀡𑁆𑀟𑀓𑁂 𑀤𑀩𑁆𑀩𑁂, 𑀤𑀩𑁆𑀩𑀕𑀸 𑀢𑁂𑀲𑀼 𑀬𑁂 𑀢𑀺𑀲𑀼.

𑀅𑀯𑀺𑀕𑁆𑀕𑀳𑁄 𑀢𑀼 𑀓𑀸𑀫𑁄 𑀘, 𑀫𑀦𑁄𑀪𑀽 𑀫𑀤𑀦𑁄 𑀪𑀯𑁂;

𑀅𑀦𑁆𑀢𑀓𑁄 𑀯𑀲𑀯𑀢𑁆𑀢𑀻 𑀘, 𑀧𑀸𑀧𑀺𑀫𑀸 𑀘 𑀧𑀚𑀸𑀧𑀢𑀺.

𑀧𑀫𑀢𑁆𑀢𑀩𑀦𑁆𑀥𑀼 𑀓𑀡𑁆𑀳𑁄 𑀘, 𑀫𑀸𑀭𑁄 𑀦𑀫𑀼𑀘𑀺, 𑀢𑀲𑁆𑀲 𑀢𑀼;

𑀢𑀡𑁆𑀳𑀸’𑀭𑀢𑀻 𑀭𑀕𑀸 𑀥𑀻𑀢𑀽, 𑀳𑀢𑁆𑀣𑀻 𑀢𑀼 𑀕𑀺𑀭𑀺𑀫𑁂𑀔𑀮𑁄.

𑀬𑀫𑀭𑀸𑀚𑀸 𑀘 𑀯𑁂𑀲𑀸𑀬𑀻, 𑀬𑀫𑁄’𑀲𑁆𑀲 𑀦𑀬𑀦𑀸𑀯𑀼𑀥𑀁;

𑀯𑁂𑀧𑀘𑀺𑀢𑁆𑀢𑀺 𑀧𑀼𑀮𑁄𑀫𑁄 𑀘, 𑀓𑀺𑀫𑁆𑀧𑀼𑀭𑀺𑀲𑁄 𑀢𑀼 𑀓𑀺𑀦𑁆𑀦𑀭𑁄.

𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑀁 𑀔’𑀫𑀸𑀤𑀺𑀘𑁆𑀘, 𑀧𑀣𑁄’𑀩𑁆𑀪𑀁 𑀕𑀕𑀦’𑀫𑁆𑀩𑀭𑀁;

𑀯𑁂𑀳𑀸𑀲𑁄 𑀘𑀸𑀦𑀺𑀮𑀧𑀣𑁄, 𑀆𑀓𑀸𑀲𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀦𑀪𑀁.

𑀫𑁂𑀖𑁄 𑀯𑀮𑀸𑀳𑀓𑁄 𑀤𑁂𑀯𑁄, 𑀧𑀚𑁆𑀚𑀼𑀦𑁆𑀦𑁄’𑀫𑁆𑀩𑀼𑀥𑀭𑁄 𑀖𑀦𑁄;

𑀥𑀸𑀭𑀸𑀥𑀭𑁄 𑀘 𑀚𑀻𑀫𑀽𑀢𑁄, 𑀯𑀸𑀭𑀺𑀯𑀸𑀳𑁄 𑀢𑀣𑀸’𑀫𑁆𑀩𑀼𑀤𑁄.

𑀅𑀩𑁆𑀪𑀁 𑀢𑀻𑀲𑁆𑀯𑀣 𑀯𑀲𑁆𑀲𑀜𑁆𑀘, 𑀯𑀲𑁆𑀲𑀦𑀁 𑀯𑀼𑀝𑁆𑀞𑀺 𑀦𑀸𑀭𑀺𑀬𑀁;

𑀲𑀢𑁂𑀭𑀢𑀸’𑀓𑁆𑀔𑀡𑀸 𑀯𑀺𑀚𑁆𑀚𑀼, 𑀯𑀺𑀚𑁆𑀚𑀼𑀢𑀸 𑀘𑀸𑀘𑀺𑀭𑀧𑁆𑀧𑀪𑀸.

𑀫𑁂𑀖𑀦𑀸𑀤𑁂 𑀢𑀼 𑀥𑀦𑀺𑀢𑀁, 𑀕𑀚𑁆𑀚𑀺𑀢𑀁 𑀭𑀲𑀺𑀢𑀸𑀤𑀺 𑀘;

𑀇𑀦𑁆𑀤𑀸𑀯𑀼𑀥𑀁 𑀇𑀦𑁆𑀤𑀥𑀦𑀼, 𑀯𑀸𑀢𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀫𑁆𑀩𑀼 𑀲𑀻𑀓𑀭𑁄.

𑀤𑀼𑀤𑁆𑀤𑀺𑀦𑀁 𑀫𑁂𑀖𑀘𑁆𑀙𑀦𑁆𑀦𑀸𑀳𑁂, 𑀧𑀺𑀥𑀸𑀦𑀁 𑀢𑁆𑀯𑀧𑀥𑀸𑀭𑀡𑀁.

𑀢𑀺𑀭𑁄𑀥𑀸𑀦’𑀦𑁆𑀢𑀭𑀥𑀸𑀦𑀸, 𑀧𑀺𑀥𑀸𑀦 𑀙𑀸𑀤𑀦𑀸𑀦𑀺 𑀘;

𑀇𑀦𑁆𑀤𑀼 𑀘𑀦𑁆𑀤𑁄 𑀘 𑀦𑀓𑁆𑀔𑀢𑁆𑀢, 𑀭𑀸𑀚𑀸 𑀲𑁄𑀫𑁄 𑀦𑀺𑀲𑀸𑀓𑀭𑁄.

𑀑𑀲𑀥𑀻𑀲𑁄 𑀳𑀺𑀫𑀭𑀁𑀲𑀺, 𑀲𑀲𑀗𑁆𑀓𑁄 𑀘𑀦𑁆𑀤𑀺𑀫𑀸 𑀲𑀲𑀻;

𑀲𑀻𑀢𑀭𑀁𑀲𑀺 𑀦𑀺𑀲𑀸𑀦𑀸𑀣𑁄, 𑀉𑀴𑀼𑀭𑀸𑀚𑀸 𑀘 𑀫𑀸 𑀧𑀼𑀫𑁂.

𑀓𑀮𑀸 𑀲𑁄𑀴𑀲𑀫𑁄 𑀪𑀸𑀕𑁄, 𑀩𑀺𑀫𑁆𑀩𑀁 𑀢𑀼 𑀫𑀡𑁆𑀟𑀮𑀁 𑀪𑀯𑁂;

𑀅𑀟𑁆𑀠𑁄 𑀢𑁆𑀯𑀤𑁆𑀥𑁄 𑀉𑀧𑀟𑁆𑀠𑁄 𑀘, 𑀯𑀸 𑀔𑀡𑁆𑀟𑀁 𑀲𑀓𑀮𑀁 𑀧𑀼𑀫𑁂.

𑀅𑀤𑁆𑀥𑀁 𑀯𑀼𑀢𑁆𑀢𑀁 𑀲𑀫𑁂 𑀪𑀸𑀕𑁂, 𑀧𑀲𑀸𑀤𑁄 𑀢𑀼 𑀧𑀲𑀦𑁆𑀦𑀢𑀸;

𑀓𑁄𑀫𑀼𑀤𑀻 𑀘𑀦𑁆𑀤𑀺𑀓𑀸 𑀚𑀼𑀡𑁆𑀳𑀸, 𑀓𑀦𑁆𑀢𑀺 𑀲𑁄𑀪𑀸 𑀚𑀼𑀢𑀺 𑀘𑁆𑀙𑀯𑀺.

𑀓𑀮𑀗𑁆𑀓𑁄 𑀮𑀜𑁆𑀙𑀦𑀁 𑀮𑀓𑁆𑀔𑀁, 𑀅𑀗𑁆𑀓𑁄’𑀪𑀺𑀜𑁆𑀜𑀸𑀡 𑀮𑀓𑁆𑀔𑀡𑀁;

𑀘𑀺𑀳𑀦𑀁 𑀘𑀸𑀧𑀺 𑀲𑁄𑀪𑀸 𑀢𑀼, 𑀧𑀭𑀫𑀸 𑀲𑀼𑀲𑀫𑀸 𑀣 𑀘.

𑀲𑀻𑀢𑀁 𑀕𑀼𑀡𑁂, 𑀕𑀼𑀡𑀺𑀮𑀺𑀗𑁆𑀕𑀸, 𑀲𑀻𑀢 𑀲𑀺𑀲𑀺𑀭 𑀲𑀻𑀢𑀮𑀸;

𑀳𑀺𑀫𑀁 𑀢𑀼𑀳𑀺𑀦 𑀫𑀼𑀲𑁆𑀲𑀸𑀯𑁄, 𑀦𑀻𑀳𑀸𑀭𑁄 𑀫𑀳𑀺𑀓𑀸 𑀧𑁆𑀬𑀣.

𑀦𑀓𑁆𑀔𑀢𑁆𑀢𑀁 𑀚𑁄𑀢𑀺 𑀪𑀁 𑀢𑀸𑀭𑀸, 𑀅𑀧𑀼𑀫𑁂 𑀢𑀸𑀭𑀓𑁄’𑀴𑀼 𑀘;

𑀅𑀲𑁆𑀲𑀬𑀼𑀚𑁄 𑀪𑀭𑀡𑀺𑀢𑁆𑀣𑀻, 𑀲𑀓𑀢𑁆𑀢𑀺𑀓𑀸 𑀭𑁄𑀳𑀺𑀡𑀻 𑀧𑀺𑀘;

𑀫𑀺𑀕𑀲𑀺𑀭 [𑀫𑀕𑀲𑀺𑀭 (𑀲𑀻.)] 𑀫𑀤𑁆𑀤𑀸 𑀘 𑀧𑀼𑀦𑀩𑁆𑀩𑀲𑀼, 𑀨𑀼𑀲𑁆𑀲𑁄 [𑀧𑀼𑀲𑁆𑀲𑁄 (𑀝𑀻.)] 𑀘𑀸𑀲𑀺𑀮𑁂𑀲’𑀧𑀺.

𑀫𑀸𑀖𑀸 [𑀫𑀖 (𑀲𑀻.)] 𑀘 𑀨𑀕𑁆𑀕𑀼𑀦𑀻 𑀤𑁆𑀯𑁂 𑀘, 𑀳𑀢𑁆𑀣𑀸 𑀘𑀺𑀢𑁆𑀢𑀸 𑀘 𑀲𑁆𑀯𑀸𑀢𑀺𑀧𑀺;

𑀯𑀺𑀲𑀸𑀔𑀸’ 𑀦𑀼𑀭𑀸𑀥𑀸 𑀚𑁂𑀝𑁆𑀞𑀸, 𑀫𑀽𑀮𑀸’ 𑀲𑀸𑀴𑁆𑀳𑀸 𑀤𑀼𑀯𑁂 𑀢𑀣𑀸.

𑀲𑀯𑀡𑁄 ¶ 𑀘 𑀥𑀦𑀺𑀝𑁆𑀞𑀸 𑀘, 𑀲𑀢𑀪𑀺𑀲𑀚𑁄 𑀧𑀼𑀩𑁆𑀩𑀼’𑀢𑁆𑀢𑀭𑀪𑀤𑁆𑀤𑀧𑀤𑀸;

𑀭𑁂𑀯𑀢𑁆𑀬𑀧𑀻𑀢𑀺 𑀓𑀫𑀢𑁄, 𑀲𑀢𑁆𑀢𑀸𑀥𑀺𑀓𑀯𑀻𑀲𑀦𑀓𑁆𑀔𑀢𑁆𑀢𑀸.

𑀲𑁄𑀩𑁆𑀪𑀸𑀦𑀼 𑀓𑀣𑀺𑀢𑁄 𑀭𑀸𑀳𑀼, 𑀲𑀽𑀭𑀸𑀤𑀻 𑀢𑀼 𑀦𑀯𑀕𑁆𑀕𑀳𑀸;

𑀭𑀸𑀲𑀺 𑀫𑁂𑀲𑀸𑀤𑀺𑀓𑁄 𑀪𑀤𑁆𑀤, 𑀧𑀤𑀸 𑀧𑁄𑀝𑁆𑀞𑀧𑀤𑀸 𑀲𑀫𑀸.

𑀆𑀤𑀺𑀘𑁆𑀘𑁄 𑀲𑀽𑀭𑀺𑀬𑁄 𑀲𑀽𑀭𑁄, 𑀲𑀢𑀭𑀁𑀲𑀺 𑀤𑀺𑀯𑀸𑀓𑀭𑁄;

𑀯𑁂𑀭𑁄𑀘𑀦𑁄 𑀤𑀺𑀦𑀓𑀭𑁄, 𑀉𑀡𑁆𑀳𑀭𑀁𑀲𑀺 𑀧𑀪𑀗𑁆𑀓𑀭𑁄.

𑀅𑀁𑀲𑀼𑀫𑀸𑀮𑀻 𑀤𑀺𑀦𑀧𑀢𑀺, 𑀢𑀧𑀦𑁄 𑀭𑀯𑀺 𑀪𑀸𑀦𑀼𑀫𑀸;

𑀭𑀁𑀲𑀺𑀫𑀸 𑀪𑀸𑀓𑀭𑁄 𑀪𑀸𑀦𑀼, 𑀅𑀓𑁆𑀓𑁄 𑀲𑀳𑀲𑁆𑀲𑀭𑀁𑀲𑀺 𑀘.

𑀭𑀁𑀲𑀺 𑀆𑀪𑀸 𑀧𑀪𑀸 𑀤𑀺𑀢𑁆𑀢𑀺, 𑀭𑀼𑀘𑀺 𑀪𑀸 𑀚𑀼𑀢𑀺 𑀤𑀻𑀥𑀺𑀢𑀺;

𑀫𑀭𑀻𑀘𑀺 𑀤𑁆𑀯𑀻𑀲𑀼 𑀪𑀸𑀦𑁆𑀯𑀁’𑀲𑀼, 𑀫𑀬𑀽𑀔𑁄 𑀓𑀺𑀭𑀡𑁄 𑀓𑀭𑁄.

𑀧𑀭𑀺𑀥𑀺 𑀧𑀭𑀺𑀯𑁂𑀲𑁄 𑀣, 𑀫𑀭𑀻𑀘𑀺 𑀫𑀺𑀕𑀢𑀡𑁆𑀳𑀺𑀓𑀸;

𑀲𑀽𑀭𑀲𑁆𑀲𑁄𑀤𑀬𑀢𑁄 𑀧𑀼𑀩𑁆𑀩𑀼’, 𑀝𑁆𑀞𑀺𑀢𑀭𑀁𑀲𑀺 𑀲𑀺𑀬𑀸’ 𑀭𑀼𑀡𑁄.

𑀤𑀲 𑀔𑀡𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑁄 𑀢𑁂, 𑀤𑀺𑀯𑀲𑁄 𑀢𑀼 𑀅𑀳𑀁 𑀤𑀺𑀦𑀁.

𑀧𑀪𑀸𑀢𑀜𑁆𑀘 𑀯𑀺𑀪𑀸𑀢𑀜𑁆𑀘, 𑀧𑀘𑁆𑀘𑀽𑀲𑁄 𑀓𑀮𑁆𑀮 𑀫𑀧𑁆𑀬𑀣;

𑀦𑀺𑀲𑀸 𑀘 𑀭𑀚𑀦𑀻 𑀭𑀢𑁆𑀢𑀺, 𑀢𑀺𑀬𑀸𑀫𑀸 𑀲𑀁𑀯𑀭𑀻 𑀪𑀯𑁂;

𑀚𑀼𑀡𑁆𑀳𑀸 𑀢𑀼 𑀘𑀦𑁆𑀤𑀺𑀓𑀸𑀬𑀼𑀢𑁆𑀢𑀸, 𑀢𑀫𑀼𑀲𑁆𑀲𑀦𑁆𑀦𑀸 𑀢𑀺𑀫𑀺𑀲𑀺𑀓𑀸.

𑀦𑀺𑀲𑀻𑀣𑁄 𑀫𑀚𑁆𑀛𑀺𑀫𑀸 𑀭𑀢𑁆𑀢𑀺, 𑀅𑀟𑁆𑀠𑀭𑀢𑁆𑀢𑁄 𑀫𑀳𑀸𑀦𑀺𑀲𑀸;

𑀅𑀦𑁆𑀥𑀓𑀸𑀭𑁄 𑀢𑀫𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀢𑀺𑀫𑀺𑀲𑀁 𑀢𑀺𑀫𑀺𑀭𑀁 𑀫𑀢𑀁.

𑀘𑀢𑀼𑀭𑀗𑁆𑀕𑀢𑀫𑀁 𑀏𑀯𑀁, 𑀓𑀸𑀴𑀧𑀓𑁆𑀔𑀘𑀢𑀼𑀤𑁆𑀤𑀲𑀻;

𑀯𑀦𑀲𑀡𑁆𑀟𑁄 𑀖𑀦𑁄 𑀫𑁂𑀖, 𑀧𑀝𑀮𑀁 𑀘𑀸’𑀟𑁆𑀠𑀭𑀢𑁆𑀢𑀺 𑀘.

𑀅𑀦𑁆𑀥𑀢𑀫𑀁 ¶ 𑀖𑀦𑀢𑀫𑁂, 𑀧𑀳𑀸𑀭𑁄 𑀬𑀸𑀫, 𑀲𑀜𑁆𑀜𑀺𑀢𑁄;

𑀧𑀸𑀝𑀺𑀧𑀤𑁄 𑀢𑀼 𑀤𑀼𑀢𑀺𑀬𑀸, 𑀢𑀢𑀺𑀬𑀸𑀤𑀻 𑀢𑀺𑀣𑀻 [𑀢𑀺𑀣𑀺], 𑀢𑀸𑀬𑀢𑀺 𑀧𑀸𑀮𑁂𑀢𑀻𑀢𑀺 𑀢𑀺𑀣𑀺, 𑀢𑀸+𑀇𑀢𑀺 (𑀡𑁆𑀯𑀸𑀤𑀺) 𑀤𑁆𑀯𑀺𑀲𑀼.

𑀧𑀦𑁆𑀦𑀭𑀲𑀻 𑀧𑀜𑁆𑀘𑀤𑀲𑀻, 𑀧𑀼𑀡𑁆𑀡𑀫𑀸𑀲𑀻 𑀢𑀼 𑀧𑀼𑀡𑁆𑀡𑀫𑀸;

𑀅𑀫𑀸𑀯𑀲𑀻 𑀧𑁆𑀬𑀫𑀸𑀯𑀸𑀲𑀻, 𑀣𑀺𑀬𑀁 𑀧𑀦𑁆𑀦𑀭𑀲𑀻’ 𑀧𑀭𑀸.

𑀖𑀝𑀺𑀓𑀸 𑀲𑀝𑁆𑀞𑁆𑀬’ 𑀳𑁄𑀭𑀢𑁆𑀢𑁄, 𑀧𑀓𑁆𑀔𑁄 𑀢𑁂 𑀤𑀲 𑀧𑀜𑁆𑀘 𑀘;

𑀢𑁂 𑀢𑀼 𑀧𑀼𑀩𑁆𑀩𑀸𑀧𑀭𑀸 𑀲𑀼𑀓𑁆𑀓,

𑀘𑀺𑀢𑁆𑀢𑁄 𑀯𑁂𑀲𑀸𑀔, 𑀚𑁂𑀝𑁆𑀞𑁄 𑀘𑀸, 𑀲𑀸𑀴𑁆𑀳𑁄 𑀤𑁆𑀯𑀻𑀲𑀼 𑀘 𑀲𑀸𑀯𑀡𑁄;

𑀧𑁄𑀝𑁆𑀞𑀧𑀸𑀤’𑀲𑁆𑀲𑀬𑀼𑀚𑀸 𑀘, 𑀫𑀸𑀲𑀸 𑀤𑁆𑀯𑀸𑀤𑀲 𑀓𑀢𑁆𑀢𑀺𑀓𑁄.

𑀫𑀸𑀕𑀲𑀺𑀭𑁄 𑀢𑀣𑀸 𑀨𑀼𑀲𑁆𑀲𑁄, 𑀓𑀫𑁂𑀦 𑀫𑀸𑀖 𑀨𑀕𑁆𑀕𑀼𑀡𑀸;

𑀓𑀢𑁆𑀢𑀺𑀓’𑀲𑁆𑀲𑀬𑀼𑀚𑀸 𑀫𑀸𑀲𑀸, 𑀧𑀘𑁆𑀙𑀺𑀫 𑀧𑀼𑀩𑁆𑀩𑀓𑀢𑁆𑀢𑀺𑀓𑀸.

𑀘𑀢𑀼𑀭𑁄 𑀘𑀢𑀼𑀭𑁄 𑀫𑀸𑀲𑀸, 𑀓𑀢𑁆𑀢𑀺𑀓𑀓𑀸𑀴𑀧𑀓𑁆𑀔𑀢𑁄;

𑀓𑀫𑀸 𑀳𑁂𑀫𑀦𑁆𑀢 𑀕𑀺𑀫𑁆𑀳𑀸𑀦, 𑀯𑀲𑁆𑀲𑀸𑀦𑀸 𑀉𑀢𑀼𑀬𑁄 𑀤𑁆𑀯𑀺𑀲𑀼.

𑀙 𑀯𑀸 𑀯𑀲𑀦𑁆𑀢𑁄 𑀘 𑀕𑀺𑀫𑁆𑀳 𑀯𑀲𑁆𑀲𑀸𑀦𑀸;

𑀲𑀭𑀤𑁄𑀢𑀺 𑀓𑀫𑀸 𑀫𑀸𑀲𑀸, 𑀤𑁆𑀯𑁂 𑀤𑁆𑀯𑁂 𑀯𑀼𑀢𑁆𑀢𑀸𑀦𑀼𑀲𑀸𑀭𑁂𑀦.

𑀉𑀢𑀽𑀳𑀺 𑀢𑀻𑀳𑀺 𑀯𑀲𑁆𑀲𑀸𑀦𑀸, 𑀤𑀺𑀓𑁂𑀳𑀺 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬𑀦𑀁.

𑀉𑀢𑁆𑀢𑀭𑀸𑀬𑀦 𑀫𑀜𑁆𑀜𑁂𑀳𑀺, 𑀢𑀻𑀳𑀺 𑀯𑀲𑁆𑀲𑀸𑀬𑀦𑀤𑁆𑀯𑀬𑀁;

𑀯𑀲𑁆𑀲 𑀲𑀁𑀯𑀘𑁆𑀙𑀭𑀸 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀲𑀭𑀤𑁄 𑀳𑀸𑀬𑀦𑁄 𑀲𑀫𑀸.

𑀓𑀧𑁆𑀧𑀓𑁆𑀔𑀬𑁄 𑀢𑀼 𑀲𑀁𑀯𑀝𑁆𑀝𑁄, 𑀬𑀼𑀕𑀦𑁆𑀢 𑀧𑀮𑀬𑀸 𑀅𑀧𑀺;

𑀅𑀮𑀓𑁆𑀔𑀻 𑀓𑀸𑀮𑀓𑀡𑁆𑀡𑀺𑀢𑁆𑀣𑀻, 𑀅𑀣 𑀮𑀓𑁆𑀔𑀻 𑀲𑀺𑀭𑀺’𑀢𑁆𑀣𑀺𑀬𑀁.

𑀤𑀦𑀼 𑀤𑀸𑀦𑀯𑀫𑀸𑀢𑀸 𑀣, 𑀤𑁂𑀯𑀫𑀸𑀢𑀸 𑀧𑀦𑀸’𑀤𑀺𑀢𑀺;

𑀧𑀸𑀧𑀜𑁆𑀘 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀁 𑀯𑁂𑀭𑀸, 𑀖𑀁 𑀤𑀼𑀘𑁆𑀘𑀭𑀺𑀢 𑀤𑀼𑀓𑁆𑀓𑀝𑀁;

𑀅𑀧𑀼𑀜𑁆𑀜𑀸’𑀓𑀼𑀲𑀮𑀁 𑀓𑀡𑁆𑀳𑀁, 𑀓𑀮𑀼𑀲𑀁 𑀤𑀼𑀭𑀺𑀢𑀸’𑀕𑀼 𑀘.

𑀓𑀼𑀲𑀮𑀁 ¶ 𑀲𑀼𑀓𑀢𑀁 𑀲𑀼𑀓𑁆𑀓𑀁, 𑀧𑀼𑀜𑁆𑀜𑀁 𑀥𑀫𑁆𑀫 𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀲𑀼𑀘𑀭𑀺𑀢 𑀫𑀣𑁄 𑀤𑀺𑀝𑁆𑀞, 𑀥𑀫𑁆𑀫𑀺𑀓𑀁 𑀇𑀳𑀮𑁄𑀓𑀺𑀓𑀁.

𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓 𑀫𑀣𑁄 𑀧𑀸𑀭, 𑀮𑁄𑀓𑀺𑀓𑀁 𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑀺𑀓𑀁;

𑀳𑀸𑀲𑁄’ 𑀢𑁆𑀢𑀫𑀦𑀢𑀸 𑀧𑀻𑀢𑀺, 𑀯𑀺𑀢𑁆𑀢𑀺 𑀢𑀼𑀝𑁆𑀞𑀺 𑀘 𑀦𑀸𑀭𑀺𑀬𑀁;

𑀆𑀦𑀦𑁆𑀤𑁄 𑀧𑀫𑀼𑀤𑀸’𑀫𑁄𑀤𑁄, 𑀲𑀦𑁆𑀢𑁄𑀲𑁄 𑀦𑀦𑁆𑀤𑀺 𑀲𑀫𑁆𑀫𑀤𑁄.

𑀧𑀸𑀫𑁄𑀚𑁆𑀚𑀜𑁆𑀘 𑀧𑀫𑁄𑀤𑁄 𑀣, 𑀲𑀼𑀔𑀁 𑀲𑀸𑀢𑀜𑁆𑀘 𑀨𑀸𑀲𑁆𑀯’𑀣;

𑀪𑀤𑁆𑀤𑀁 𑀲𑁂𑀬𑁆𑀬𑁄 𑀲𑀼𑀪𑀁 𑀔𑁂𑀫𑀁, 𑀓𑀮𑁆𑀬𑀸𑀡𑀁 𑀫𑀗𑁆𑀕𑀮𑀁 𑀲𑀺𑀯𑀁.

𑀤𑀼𑀓𑁆𑀔𑀜𑁆𑀘 𑀓𑀲𑀺𑀭𑀁 𑀓𑀺𑀘𑁆𑀙𑀁, 𑀦𑀻𑀖𑁄 𑀘 𑀩𑁆𑀬𑀲𑀦𑀁 𑀅𑀖𑀁;

𑀤𑀩𑁆𑀩𑁂 𑀢𑀼 𑀧𑀸𑀧𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺, 𑀢𑀻𑀲𑁆𑀯𑀸𑀓𑀺𑀘𑁆𑀙𑀁 𑀲𑀼𑀔𑀸𑀤𑀺 𑀘.

𑀪𑀸𑀕𑁆𑀬𑀁 𑀦𑀺𑀬𑀢𑀺 𑀪𑀸𑀕𑁄 𑀘, 𑀪𑀸𑀕𑀥𑁂𑀬𑁆𑀬𑀁 𑀯𑀺𑀥𑀻’𑀭𑀺𑀢𑁄;

𑀅𑀣𑁄 𑀉𑀧𑁆𑀧𑀢𑁆𑀢𑀺 𑀦𑀺𑀩𑁆𑀩𑀢𑁆𑀢𑀺, 𑀚𑀸𑀢𑀺 𑀚𑀦𑀦 𑀫𑀼𑀩𑁆𑀪𑀯𑁄.

𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑀁 𑀓𑀸𑀭𑀡𑀁 𑀞𑀸𑀦𑀁, 𑀧𑀤𑀁 𑀩𑀻𑀚𑀁 𑀦𑀺𑀩𑀦𑁆𑀥𑀦𑀁;

𑀦𑀺𑀤𑀸𑀦𑀁 𑀧𑀪𑀯𑁄 𑀳𑁂𑀢𑀼, 𑀲𑀫𑁆𑀪𑀯𑁄 𑀲𑁂𑀢𑀼 𑀧𑀘𑁆𑀘𑀬𑁄.

𑀓𑀸𑀭𑀡𑀁 𑀬𑀁 𑀲𑀫𑀸𑀲𑀦𑁆𑀦𑀁, 𑀧𑀤𑀝𑁆𑀞𑀸𑀦𑀦𑁆𑀢𑀺 𑀢𑀁 𑀫𑀢𑀁;

𑀚𑀻𑀯𑁄 𑀢𑀼 𑀧𑀼𑀭𑀺𑀲𑁄’𑀢𑁆𑀢𑀸 𑀣, 𑀧𑀥𑀸𑀦𑀁 𑀧𑀓𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀧𑀸𑀡𑁄 𑀲𑀭𑀻𑀭𑀻 𑀪𑀽𑀢𑀁 𑀯𑀸, 𑀲𑀢𑁆𑀢𑁄 𑀤𑁂𑀳𑀻 𑀘 𑀧𑀼𑀕𑁆𑀕𑀮𑁄;

𑀭𑀽𑀧𑀁 𑀲𑀤𑁆𑀤𑁄 𑀕𑀦𑁆𑀥 𑀭𑀲𑀸, 𑀨𑀲𑁆𑀲𑁄 𑀥𑀫𑁆𑀫𑁄 𑀘 𑀕𑁄𑀘𑀭𑀸;

𑀆𑀮𑀫𑁆𑀩𑀸 𑀯𑀺𑀲𑀬𑀸 𑀢𑁂 𑀙𑀸, 𑀭𑀫𑁆𑀫𑀡𑀸 𑀮𑀫𑁆𑀩𑀡𑀸𑀦𑀺 𑀘.

𑀲𑀺𑀢𑀧𑀻𑀢𑁂𑀢𑀼 𑀧𑀡𑁆𑀟𑀼’𑀢𑁆𑀢𑁄, 𑀈𑀲𑀁𑀧𑀡𑁆𑀟𑀼𑀢𑀼 𑀥𑀽𑀲𑀭𑁄.

𑀓𑀴𑀸𑀭𑁄 𑀓𑀧𑀺𑀮𑁄 𑀦𑀻𑀮, 𑀧𑀻𑀢𑁂 𑀣 𑀭𑁄𑀘𑀦𑀧𑁆𑀧𑀪𑁂;

𑀧𑀺𑀗𑁆𑀕𑁄 𑀧𑀺𑀲𑀗𑁆𑀕𑁄 𑀧𑁆𑀬𑀣𑀯𑀸, 𑀓𑀴𑀸𑀭𑀸𑀤𑀻 𑀢𑀼 𑀧𑀺𑀗𑁆𑀕𑀮𑁂.

𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀸 𑀕𑀼𑀡𑀺𑀦𑁆𑀬𑁂𑀢𑁂, 𑀕𑀼𑀡𑁂 𑀲𑀼𑀓𑁆𑀓𑀸𑀤𑀬𑁄 𑀧𑀼𑀫𑁂.

𑀦𑀘𑁆𑀘𑀁 𑀦𑀝𑁆𑀝𑀜𑁆𑀘 𑀦𑀝𑀦𑀁, 𑀦𑀢𑁆𑀢𑀦𑀁 𑀮𑀸𑀲𑀦𑀁 𑀪𑀯𑁂;

𑀦𑀘𑁆𑀘𑀁 𑀢𑀼 𑀯𑀸𑀤𑀺𑀢𑀁 𑀕𑀻𑀢, 𑀫𑀺𑀢𑀺 𑀦𑀸𑀝𑀼𑀫𑀺𑀤𑀁 𑀢𑀬𑀁.

𑀦𑀘𑁆𑀘𑀝𑁆𑀞𑀸𑀦𑀁 𑀲𑀺𑀬𑀸 𑀭𑀗𑁆𑀕𑁄, 𑀪𑀺𑀦𑀬𑁄 𑀲𑀽𑀘𑁆𑀬𑀲𑀽𑀘𑀦𑀁;

𑀅𑀗𑁆𑀕𑀳𑀸𑀭𑁄’𑀗𑁆𑀕𑀯𑀺𑀓𑁆𑀔𑁂𑀧𑁄, 𑀦𑀝𑁆𑀝𑀓𑁄 𑀦𑀝𑀓𑁄 𑀦𑀝𑁄.

𑀲𑀺𑀗𑁆𑀕𑀸𑀭𑁄 𑀓𑀭𑀼𑀡𑁄 𑀯𑀻𑀭, 𑀩𑁆𑀪𑀼𑀢 𑀳𑀲𑁆𑀲 𑀪𑀬𑀸𑀦𑀓𑀸;

𑀲𑀦𑁆𑀢𑁄 𑀩𑀻𑀪𑀘𑁆𑀙 𑀭𑀼𑀤𑁆𑀤𑀸𑀦𑀺, 𑀦𑀯 𑀦𑀸𑀝𑁆𑀬𑀭𑀲𑀸 𑀇𑀫𑁂.

𑀧𑁄𑀲𑀲𑁆𑀲 𑀦𑀸𑀭𑀺𑀬𑀁 𑀧𑁄𑀲𑁂, 𑀇𑀢𑁆𑀣𑀺𑀬𑀸 𑀲𑀗𑁆𑀕𑀫𑀁 𑀧𑀢𑀺;

𑀬𑀸 𑀧𑀺𑀳𑀸 𑀏𑀲 𑀲𑀺𑀗𑁆𑀕𑀸𑀭𑁄, 𑀭𑀢𑀺𑀓𑀻𑀴𑀸𑀤𑀺𑀓𑀸𑀭𑀡𑁄.

𑀉𑀢𑁆𑀢𑀫 𑀧𑁆𑀧𑀓𑀢𑀺𑀧𑁆𑀧𑀸𑀬𑁄, 𑀇𑀢𑁆𑀣𑀺𑀧𑀼𑀭𑀺𑀲𑀳𑁂𑀢𑀼𑀓𑁄;

𑀪𑀸𑀲𑀺𑀢𑀁 ¶ 𑀮𑀧𑀺𑀢𑀁 𑀪𑀸𑀲𑀸, 𑀯𑁄𑀳𑀸𑀭𑁄 𑀯𑀘𑀦𑀁 𑀯𑀘𑁄;

𑀉𑀢𑁆𑀢𑀺 𑀯𑀸𑀘𑀸 𑀕𑀺𑀭𑀸 𑀯𑀸𑀡𑀻, 𑀪𑀸𑀭𑀢𑀻 𑀓𑀣𑀺𑀢𑀸 [𑀓𑀣𑀸 (𑀓𑀢𑁆𑀣𑀘𑀺)] 𑀯𑀘𑀻.

𑀏𑀓𑀸𑀔𑁆𑀬𑀸𑀢𑁄 𑀧𑀤𑀘𑀬𑁄, 𑀲𑀺𑀬𑀸 𑀯𑀸𑀓𑁆𑀬𑀁𑀲𑀓𑀸𑀭𑀓𑁄;

𑀆𑀫𑁂𑀟𑀺𑀢𑀦𑁆𑀢𑀺 𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑀁, 𑀤𑁆𑀯𑀢𑁆𑀢𑀺𑀓𑁆𑀔𑀢𑁆𑀢𑀼 𑀫𑀼𑀤𑀻𑀭𑀡𑀁.

𑀪𑀬𑁂 𑀓𑁄𑀥𑁂 𑀧𑀲𑀁𑀲𑀸𑀬𑀁, 𑀢𑀼𑀭𑀺𑀢𑁂 𑀓𑁄𑀢𑀽𑀳𑀮𑁂’𑀘𑁆𑀙𑀭𑁂;

𑀳𑀸𑀲𑁂 𑀲𑁄𑀓𑁂 𑀧𑀲𑀸𑀤𑁂 𑀘, 𑀓𑀭𑁂 𑀆𑀫𑁂𑀟𑀺𑀢𑀁 𑀩𑀼𑀥𑁄.

𑀇𑀭𑀼 𑀦𑀸𑀭𑀻 𑀬𑀚𑀼 𑀲𑀸𑀫, 𑀫𑀺𑀢𑀺 𑀯𑁂𑀤𑀸 𑀢𑀬𑁄 𑀲𑀺𑀬𑀼𑀁;

𑀏𑀢𑁂 𑀏𑀯 𑀢𑀬𑀻 𑀦𑀸𑀭𑀻, 𑀯𑁂𑀤𑁄 𑀫𑀦𑁆𑀢𑁄 𑀲𑀼𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀅𑀝𑁆𑀞𑀓𑁄 𑀯𑀸𑀫𑀓𑁄 𑀯𑀸𑀫, 𑀤𑁂𑀯𑁄 𑀘𑀗𑁆𑀕𑀻𑀭𑀲𑁄 𑀪𑀕𑀼;

𑀬𑀫𑀤𑀕𑁆𑀕𑀺 𑀘 𑀯𑀸𑀲𑀺𑀝𑁆𑀞𑁄, 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀘 𑀓𑀲𑁆𑀲𑀧𑁄;

𑀯𑁂𑀲𑁆𑀲𑀸𑀫𑀺𑀢𑁆𑀢𑁄𑀢𑀺 𑀫𑀦𑁆𑀢𑀸𑀦𑀁, 𑀓𑀢𑁆𑀢𑀸𑀭𑁄 𑀇𑀲𑀬𑁄 𑀇𑀫𑁂.

𑀓𑀧𑁆𑀧𑁄 𑀩𑁆𑀬𑀸𑀓𑀭𑀡𑀁 𑀚𑁄𑀢𑀺, 𑀲𑀢𑁆𑀣𑀁 𑀲𑀺𑀓𑁆𑀔𑀸 𑀦𑀺𑀭𑀼𑀢𑁆𑀢𑀺 𑀘;

𑀙𑀦𑁆𑀤𑁄𑀯𑀺𑀘𑀺𑀢𑀺 𑀘𑁂𑀢𑀸𑀦𑀺, 𑀯𑁂𑀤𑀗𑁆𑀕𑀸𑀦𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀙.

𑀇𑀢𑀺𑀳𑀸𑀲𑁄 𑀧𑀼𑀭𑀸𑀯𑀼𑀢𑁆𑀢, 𑀧𑁆𑀧𑀩𑀦𑁆𑀥𑁄 𑀪𑀸𑀭𑀢𑀸𑀤𑀺𑀓𑁄;

𑀦𑀸𑀫𑀧𑁆𑀧𑀓𑀸𑀲𑀓𑀁 𑀲𑀢𑁆𑀣𑀁, 𑀭𑀼𑀓𑁆𑀔𑀸𑀤𑀻𑀦𑀁 𑀦𑀺𑀖𑀡𑁆𑀟𑀼 𑀲𑁄.

𑀯𑀺𑀢𑀡𑁆𑀟𑀲𑀢𑁆𑀣𑀁 𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑀁, 𑀬𑀁 𑀢𑀁 𑀮𑁄𑀓𑀸𑀬𑀢𑀁 𑀇𑀢𑀺;

𑀓𑁂𑀝𑀼𑀪𑀁 𑀢𑀼 𑀓𑁆𑀭𑀺𑀬𑀸𑀓𑀧𑁆𑀧, 𑀯𑀺𑀓𑀧𑁆𑀧𑁄 𑀓𑀯𑀺𑀦𑀁 𑀳𑀺𑀢𑁄.

𑀆𑀔𑁆𑀬𑀸𑀬𑀺𑀓𑁄𑀧𑀮𑀤𑁆𑀥𑀢𑁆𑀣𑀸, 𑀧𑀩𑀦𑁆𑀥𑀓𑀧𑁆𑀧𑀦𑀸 𑀓𑀣𑀸;

𑀤𑀡𑁆𑀟𑀦𑀻𑀢𑁆𑀬’𑀢𑁆𑀣𑀲𑀢𑁆𑀣𑀲𑁆𑀫𑀺𑀁, 𑀯𑀼𑀢𑁆𑀢𑀦𑁆𑀢𑁄 𑀢𑀼 𑀧𑀯𑀢𑁆𑀢𑀺 𑀘.

𑀲𑀜𑁆𑀜𑀸, 𑀔𑁆𑀬𑀸, 𑀯𑁆𑀳𑀸 𑀲𑀫𑀜𑁆𑀜𑀸 𑀘𑀸, 𑀪𑀺𑀥𑀸𑀦𑀁 𑀦𑀸𑀫 𑀫𑀯𑁆𑀳𑀬𑁄;

𑀦𑀸𑀫𑀥𑁂𑀬𑁆𑀬𑀸’ 𑀥𑀺𑀯𑀘𑀦𑀁, 𑀧𑀝𑀺𑀯𑀸𑀓𑁆𑀬𑀁 𑀢𑀼 𑀉𑀢𑁆𑀢𑀭𑀁.

𑀧𑀜𑁆𑀳𑁄 𑀢𑀻𑀲𑁆𑀯 𑀦𑀼𑀬𑁄𑀕𑁄 𑀘, 𑀧𑀼𑀘𑁆𑀙𑀸 𑀧𑁆𑀬𑀣 𑀦𑀺𑀤𑀲𑁆𑀲𑀦𑀁;

𑀉𑀧𑁄𑀕𑁆𑀖𑀸𑀢𑁄 𑀘 𑀤𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑁄, 𑀢𑀣𑁄’𑀤𑀸𑀳𑀭𑀡𑀁 𑀪𑀯𑁂.

𑀲𑀫𑀸 𑀲𑀗𑁆𑀔𑁂𑀧 𑀲𑀁𑀳𑀸𑀭𑀸, 𑀲𑀫𑀸𑀲𑁄 𑀲𑀗𑁆𑀕𑀳𑁄 𑀧𑁆𑀬𑀣;

𑀲𑀢𑀁 𑀥𑀸𑀭𑀬𑀲𑀻 𑀢𑁆𑀬𑀸𑀤𑁆𑀬, 𑀩𑁆𑀪𑀓𑁆𑀔𑀸𑀦𑀁 𑀢𑀼𑀘𑁆𑀙𑀪𑀸𑀲𑀦𑀁.

𑀯𑁄𑀳𑀸𑀭𑁄 𑀢𑀼 𑀯𑀺𑀯𑀸𑀤𑁄 𑀣, 𑀲𑀧𑀦𑀁 𑀲𑀧𑀣𑁄𑀧𑀺 𑀘;

𑀧𑀝𑀺𑀖𑁄𑀲𑁄 𑀧𑀝𑀺𑀭𑀯𑁄, 𑀣𑁄’ 𑀧𑀜𑁆𑀜𑀸𑀲𑁄 𑀯𑀘𑀻𑀫𑀼𑀔𑀁;

𑀓𑀢𑁆𑀣𑀦𑀸 𑀘 𑀲𑀺𑀮𑀸𑀖𑀸 𑀘, 𑀯𑀡𑁆𑀡𑀦𑀸 𑀘 𑀦𑀼𑀢𑀺 𑀢𑁆𑀣𑀼𑀢𑀺.

𑀣𑁄𑀫𑀦𑀜𑁆𑀘 [𑀣𑁄𑀫𑀦𑀁 𑀯𑀸 (𑀓𑀢𑁆𑀣𑀘𑀺 𑀣𑁄𑀫𑀦𑀁 𑀣𑁄𑀫𑀦𑀸 𑀤𑁆𑀯𑀺𑀮𑀺𑀗𑁆𑀕𑁂)] 𑀧𑀲𑀁𑀲𑀸𑀣, 𑀓𑁂𑀓𑀸 𑀦𑀸𑀤𑁄 𑀲𑀺𑀔𑀡𑁆𑀟𑀺𑀦𑀁;

𑀧𑀭𑀺𑀬𑀸𑀬𑁄 𑀯𑁂𑀯𑀘𑀦𑀁, 𑀲𑀸𑀓𑀘𑁆𑀙𑀸 𑀢𑀼 𑀘 𑀲𑀁𑀓𑀣𑀸;

𑀉𑀧𑀯𑀸𑀤𑁄 𑀘𑀼’𑀧𑀓𑁆𑀓𑁄𑀲𑀸, 𑀯𑀡𑁆𑀡𑀯𑀸𑀤𑀸’𑀦𑀼𑀯𑀸𑀤𑁄 𑀘;

𑀚𑀦𑀯𑀸𑀤𑀸’𑀧𑀯𑀸𑀤𑀸𑀧𑀺, 𑀧𑀭𑀺𑀯𑀸𑀤𑁄 𑀘 𑀢𑀼𑀮𑁆𑀬𑀢𑁆𑀣𑀸.

𑀔𑁂𑀧𑁄 ¶ 𑀦𑀺𑀦𑁆𑀤𑀸 𑀢𑀣𑀸 𑀓𑀼𑀘𑁆𑀙𑀸, 𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀸 𑀕𑀭𑀳𑀸 𑀪𑀯𑁂;

𑀦𑀺𑀦𑁆𑀤𑀸𑀧𑀼𑀩𑁆𑀩𑁄 𑀉𑀧𑀸𑀭𑀫𑁆𑀪𑁄, 𑀧𑀭𑀺𑀪𑀸𑀲𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀅𑀝𑁆𑀞𑀸𑀦𑀭𑀺𑀬𑀯𑁄𑀳𑀸𑀭, 𑀯𑀲𑁂𑀦 𑀬𑀸 𑀧𑀯𑀢𑁆𑀢𑀺𑀢𑀸;

𑀅𑀪𑀺𑀯𑀸𑀓𑁆𑀬𑀁 𑀲𑀺𑀬𑀸 𑀯𑀸𑀘𑀸, 𑀲𑀸 𑀯𑀻𑀢𑀺𑀓𑁆𑀓𑀫𑀤𑀻𑀧𑀦𑀻.

𑀫𑀼𑀳𑀼𑀁𑀪𑀸𑀲𑀸 𑀦𑀼𑀮𑀸𑀧𑁄𑀣, 𑀧𑀮𑀸𑀧𑁄 𑀦𑀢𑁆𑀣𑀺𑀓𑀸 𑀕𑀺𑀭𑀸;

𑀯𑀺𑀧𑁆𑀧𑀮𑀸𑀧𑁄 𑀯𑀺𑀭𑁄𑀥𑁄𑀢𑁆𑀢𑀺, 𑀲𑀦𑁆𑀤𑁂𑀲𑁄𑀢𑁆𑀢𑀺 𑀢𑀼 𑀯𑀸𑀘𑀺𑀓𑀁;

𑀲𑀫𑁆𑀪𑀸𑀲𑀦𑀁 𑀢𑀼 𑀲𑀮𑁆𑀮𑀸𑀧𑁄, 𑀯𑀺𑀭𑁄𑀥𑀭𑀳𑀺𑀢𑀁 𑀫𑀺𑀣𑀼.

𑀨𑀭𑀼𑀲𑀁 𑀦𑀺𑀝𑁆𑀞𑀼𑀭𑀁 𑀯𑀸𑀓𑁆𑀬𑀁, 𑀫𑀦𑀼𑀜𑁆𑀜𑀁 𑀳𑀤𑀬𑀗𑁆𑀕𑀫𑀁;

𑀲𑀁𑀓𑀼𑀮𑀁 𑀢𑀼 𑀓𑀺𑀮𑀺𑀝𑁆𑀞𑀜𑁆𑀘, 𑀧𑀼𑀩𑁆𑀩𑀸𑀧𑀭𑀯𑀺𑀭𑁄𑀥𑀺𑀦𑀻.

𑀲𑀫𑀼𑀤𑀸𑀬𑀢𑁆𑀣𑀭𑀳𑀺𑀢𑀁, 𑀅𑀩𑀤𑁆𑀥𑀫𑀺𑀢𑀺 [𑀅𑀩𑀦𑁆𑀥 (𑀓.)] 𑀓𑀺𑀢𑁆𑀢𑀺𑀢𑀁;

𑀯𑀺𑀢𑀣𑀁 𑀢𑀼 𑀫𑀼𑀲𑀸 𑀘𑀸𑀣 [𑀆𑀳𑀢𑀁 𑀢𑀼 𑀫𑀼𑀲𑀸𑀢𑁆𑀣𑀓𑀁 (𑀓𑀢𑁆𑀣𑀘𑀺, 𑀅𑀫𑀭𑀓𑁄𑀲𑁂)], 𑀨𑀭𑀼𑀲𑀸𑀤𑀻 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀸.

𑀲𑀫𑁆𑀫𑀸 𑀩𑁆𑀬𑀬𑀜𑁆𑀘𑀸 𑀯𑀺𑀢𑀣𑀁, 𑀲𑀘𑁆𑀘𑀁 𑀢𑀘𑁆𑀙𑀁 𑀬𑀣𑀸𑀢𑀣𑀁;

𑀢𑀩𑁆𑀩𑀦𑁆𑀢𑀸 𑀢𑀻𑀲𑁆𑀯 𑀮𑀻𑀓𑀁 𑀢𑁆𑀯, 𑀲𑀘𑁆𑀘𑀁 𑀫𑀺𑀘𑁆𑀙𑀸 𑀫𑀼𑀲𑀸 𑀩𑁆𑀬𑀬𑀁.

𑀭𑀯𑁄 𑀦𑀺𑀦𑀸𑀤𑁄 𑀦𑀺𑀦𑀤𑁄 𑀘 𑀲𑀤𑁆𑀤𑁄,

𑀦𑀺𑀕𑁆𑀖𑁄𑀲 𑀦𑀸𑀤 𑀤𑁆𑀥𑀦𑀬𑁄 𑀘 𑀭𑀸𑀯𑁄;

𑀭𑀯𑀸 𑀲𑀼𑀢𑀺𑀢𑁆𑀣𑀻 𑀲𑀭 𑀦𑀺𑀲𑁆𑀲𑀦𑀸 𑀘.

𑀯𑀺𑀲𑁆𑀲𑀝𑁆𑀞 𑀫𑀜𑁆𑀚𑀼 𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑀸, 𑀲𑀯𑀦𑀻𑀬𑀸 𑀯𑀺𑀲𑀸𑀭𑀺𑀦𑁄;

𑀩𑀺𑀦𑁆𑀤𑀼 𑀕𑀫𑁆𑀪𑀻𑀭 𑀦𑀺𑀦𑁆𑀦𑀸𑀤𑀻, 𑀢𑁆𑀬𑁂𑀯 𑀫𑀝𑁆𑀞𑀗𑁆𑀕𑀺𑀓𑁄 𑀲𑀭𑁄.

𑀢𑀺𑀭𑀘𑁆𑀙𑀸𑀦𑀕𑀢𑀸𑀦𑀜𑁆𑀳𑀺, 𑀭𑀼𑀢𑀁 𑀯𑀲𑁆𑀲𑀺𑀢 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀲𑀭𑀸 𑀲𑀢𑁆𑀢 𑀢𑀬𑁄 𑀕𑀸𑀫𑀸, 𑀘𑁂𑀓𑀯𑀻𑀲𑀢𑀺 𑀫𑀼𑀘𑁆𑀙𑀦𑀸;

𑀢𑀸𑀦𑀸 [𑀞𑀸𑀦𑀸𑀦𑀺 (𑀩𑀳𑀽𑀲𑀼)] 𑀘𑁂𑀓𑀽𑀦𑀧𑀜𑁆𑀜𑀸𑀲, 𑀇𑀘𑁆𑀘𑁂𑀢𑀁 𑀲𑀭𑀫𑀡𑁆𑀟𑀮𑀁.

𑀉𑀲𑀪𑁄 𑀥𑁂𑀯𑀢𑁄 𑀘𑁂𑀯, 𑀙𑀚𑁆𑀚 𑀕𑀦𑁆𑀥𑀸𑀭 𑀫𑀚𑁆𑀛𑀺𑀫𑀸;

𑀧𑀜𑁆𑀘𑀫𑁄 𑀘 𑀦𑀺𑀲𑀸𑀤𑁄𑀢𑀺, 𑀲𑀢𑁆𑀢𑁂’𑀢𑁂 𑀕𑀤𑀺𑀢𑀸 𑀲𑀭𑀸.

𑀦𑀤𑀦𑁆𑀢𑀺 ¶ 𑀉𑀲𑀪𑀁 𑀕𑀸𑀯𑁄, 𑀢𑀼𑀭𑀕𑀸 𑀥𑁂𑀯𑀢𑀁 𑀢𑀣𑀸;

𑀙𑀚𑁆𑀚𑀁 𑀫𑀬𑀽𑀭𑀸 𑀕𑀦𑁆𑀥𑀸𑀭, 𑀫𑀚𑀸 𑀓𑁄𑀜𑁆𑀘𑀸 𑀘 𑀫𑀚𑁆𑀛𑀺𑀫𑀁.

𑀧𑀜𑁆𑀘𑀫𑀁 𑀧𑀭𑀧𑀼𑀝𑁆𑀞𑀸𑀤𑀻, 𑀦𑀺𑀲𑀸𑀤𑀫𑁆𑀧𑀺 𑀘 𑀯𑀸𑀭𑀡𑀸;

𑀙𑀚𑁆𑀚𑁄 𑀘 𑀫𑀚𑁆𑀛𑀺𑀫𑁄 𑀕𑀸𑀫𑀸,

𑀲𑀭𑁂𑀲𑀼 𑀢𑁂𑀲𑀼 𑀧𑀘𑁆𑀘𑁂𑀓𑁂, 𑀢𑀺𑀲𑁆𑀲𑁄 𑀢𑀺𑀲𑁆𑀲𑁄 𑀳𑀺 𑀫𑀼𑀘𑁆𑀙𑀦𑀸;

𑀲𑀺𑀬𑀼𑀁 𑀢𑀣𑁂𑀯 𑀢𑀸𑀦𑀸𑀦𑀺 [𑀞𑀸𑀦𑀸𑀦𑀺 (𑀩𑀳𑀽𑀲𑀼)], 𑀲𑀢𑁆𑀢 𑀲𑀢𑁆𑀢𑁂𑀯 𑀮𑀩𑁆𑀪𑀭𑁂.

𑀢𑀺𑀲𑁆𑀲𑁄 𑀤𑀼𑀯𑁂 𑀘𑀢𑀲𑁆𑀲𑁄 𑀘, 𑀘𑀢𑀲𑁆𑀲𑁄 𑀓𑀫𑀢𑁄 𑀲𑀭𑁂;

𑀢𑀺𑀲𑁆𑀲𑁄 𑀤𑀼𑀯𑁂 𑀘𑀢𑀲𑁆𑀲𑁄𑀢𑀺, 𑀤𑁆𑀯𑀸𑀯𑀻𑀲𑀢𑀺 𑀲𑀼𑀢𑀻 𑀲𑀺𑀬𑀼𑀁.

𑀉𑀘𑁆𑀘𑀢𑀭𑁂 𑀭𑀯𑁂 𑀢𑀸𑀭𑁄, 𑀣𑀸𑀩𑁆𑀬𑀢𑁆𑀢𑁂 𑀫𑀥𑀼𑀭𑁂 𑀓𑀮𑁄;

𑀕𑀫𑁆𑀪𑀻𑀭𑁂 𑀢𑀼 𑀭𑀯𑁂 𑀫𑀦𑁆𑀤𑁄, 𑀢𑀸𑀭𑀸𑀤𑀻 𑀢𑀻𑀲𑁆𑀯𑀣𑁄 𑀓𑀮𑁂;

𑀯𑀻𑀡𑀸 𑀘 𑀯𑀮𑁆𑀮𑀓𑀻 𑀲𑀢𑁆𑀢, 𑀢𑀦𑁆𑀢𑀻 𑀲𑀸 𑀧𑀭𑀺𑀯𑀸𑀤𑀺𑀦𑀻;

𑀆𑀢𑀢𑀜𑁆𑀘𑁂𑀯 𑀯𑀺𑀢𑀢, 𑀫𑀸𑀢𑀢𑀯𑀺𑀢𑀢𑀁 𑀖𑀦𑀁;

𑀲𑀼𑀲𑀺𑀭𑀁 𑀘𑁂𑀢𑀺 𑀢𑀽𑀭𑀺𑀬𑀁, 𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀺𑀓 𑀫𑀼𑀤𑀻𑀭𑀺𑀢𑀁.

𑀆𑀢𑀢𑀁 𑀦𑀸𑀫 𑀘𑀫𑁆𑀫𑀸𑀯, 𑀦𑀤𑁆𑀥𑁂𑀲𑀼 𑀪𑁂𑀭𑀺𑀬𑀸𑀤𑀺𑀲𑀼;

𑀢𑀮𑁂’𑀓𑁂𑀓𑀬𑀼𑀢𑀁 𑀓𑀼𑀫𑁆𑀪, 𑀣𑀼𑀡 𑀤𑀤𑁆𑀤𑀭𑀺𑀓𑀸𑀤𑀺𑀓𑀁.

𑀯𑀺𑀢𑀢𑀁 𑀘𑁄’𑀪𑀬𑀢𑀮𑀁, 𑀢𑀽𑀭𑀺𑀬𑀁 𑀫𑀼𑀭𑀚𑀸𑀤𑀺𑀓𑀁;

𑀆𑀢𑀢𑀯𑀺𑀢𑀢𑀁 𑀲𑀩𑁆𑀩, 𑀯𑀺𑀦𑀤𑁆𑀥𑀁 𑀧𑀡𑀯𑀸𑀤𑀺𑀓𑀁.

𑀲𑀼𑀲𑀺𑀭𑀁 𑀯𑀁𑀲𑀲𑀗𑁆𑀔𑀸𑀤𑀺, 𑀲𑀫𑁆𑀫𑀢𑀸𑀮𑀸𑀤𑀺𑀓𑀁 𑀖𑀦𑀁;

𑀆𑀢𑁄𑀚𑁆𑀚𑀁 𑀢𑀼 𑀘 𑀯𑀸𑀤𑀺𑀢𑁆𑀢𑀁, 𑀯𑀸𑀤𑀺𑀢𑀁 𑀯𑀚𑁆𑀚 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀪𑁂𑀭𑀻 (𑀪𑁂𑀭𑀺) 𑀤𑀼𑀦𑁆𑀤𑀼𑀪𑀺 𑀯𑀼𑀢𑁆𑀢𑁄 𑀣,

𑀆𑀮𑀺𑀗𑁆𑀕, 𑀗𑁆𑀓𑁆𑀬𑁄, 𑀤𑁆𑀥𑀓𑀸 𑀪𑁂𑀤𑀸,

𑀆𑀮𑀫𑁆𑀩𑀭𑁄 ¶ 𑀢𑀼 𑀧𑀡𑀯𑁄, 𑀓𑁄𑀡𑁄 𑀯𑀻𑀡𑀸𑀤𑀺𑀯𑀸𑀤𑀦𑀁;

𑀤𑀤𑁆𑀤𑀭𑀻 𑀧𑀝𑀳𑁄 𑀪𑁂𑀭𑀺, 𑀧𑁆𑀧𑀪𑁂𑀤𑀸 𑀫𑀤𑁆𑀤𑀮𑀸𑀤𑀬𑁄.

𑀚𑀦𑀧𑁆𑀧𑀺𑀬𑁂 𑀯𑀺𑀫𑀤𑁆𑀤𑀼𑀝𑁆𑀞𑁂, 𑀕𑀦𑁆𑀥𑁂 𑀧𑀭𑀺𑀫𑀮𑁄 𑀪𑀯𑁂;

𑀲𑁄 𑀢𑁆𑀯𑀸 𑀫𑁄𑀤𑁄 𑀤𑀽𑀭𑀕𑀸𑀫𑀻, 𑀯𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀸 𑀢𑀻𑀲𑁆𑀯𑀺𑀢𑁄 𑀧𑀭𑀁.

𑀇𑀝𑁆𑀞𑀕𑀦𑁆𑀥𑁄 𑀘 𑀲𑀼𑀭𑀪𑀺, 𑀲𑀼𑀕𑀦𑁆𑀥𑁄 𑀘 𑀲𑀼𑀕𑀦𑁆𑀥𑀺 𑀘;

𑀧𑀽𑀢𑀺𑀕𑀦𑁆𑀥𑀺 𑀢𑀼 𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑁄, 𑀣 𑀯𑀺𑀲𑁆𑀲𑀁 𑀆𑀫𑀕𑀦𑁆𑀥𑀺 𑀬𑀁.

𑀓𑀼𑀗𑁆𑀓𑀼𑀫𑀜𑁆𑀘𑁂𑀯 𑀬𑀯𑀦, 𑀧𑀼𑀧𑁆𑀨𑀜𑁆𑀘 𑀢𑀕𑀭𑀁 𑀢𑀣𑀸;

𑀢𑀼𑀭𑀼𑀓𑁆𑀔𑁄𑀢𑀺 𑀘𑀢𑀼𑀚𑁆𑀚𑀸𑀢𑀺, 𑀕𑀦𑁆𑀥𑀸 𑀏𑀢𑁂 𑀧𑀓𑀸𑀲𑀺𑀢𑀸.

𑀓𑀲𑀸𑀯𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀢𑀺𑀢𑁆𑀢𑁄, 𑀫𑀥𑀼𑀭𑁄 𑀮𑀯𑀡𑁄 𑀇𑀫𑁂;

𑀅𑀫𑁆𑀩𑀺𑀮𑁄 𑀓𑀝𑀼𑀓𑁄 𑀘𑁂𑀢𑀺, 𑀙 𑀭𑀲𑀸 𑀢𑀩𑁆𑀩𑀢𑀻 𑀢𑀺𑀲𑀼.

𑀲𑀺𑀬𑀸 𑀨𑀲𑁆𑀲𑁄 𑀘 𑀨𑁄𑀝𑁆𑀞𑀩𑁆𑀩𑁄,

𑀯𑀺𑀲𑀬𑀻 𑀢𑁆𑀯𑀓𑁆𑀔 𑀫𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀁;

𑀦𑀬𑀦𑀁 𑀢𑁆𑀯𑀓𑁆𑀔𑀺 𑀦𑁂𑀢𑁆𑀢𑀜𑁆𑀘, 𑀮𑁄𑀘𑀦𑀁 𑀘’𑀘𑁆𑀙𑀺 𑀘𑀓𑁆𑀔𑀼 𑀘.

𑀲𑁄𑀢𑀁 𑀲𑀤𑁆𑀤𑀕𑁆𑀕𑀳𑁄 𑀓𑀡𑁆𑀡𑁄, 𑀲𑀯𑀦𑀁 𑀲𑀼𑀢𑀺 𑀦𑀢𑁆𑀣𑀼 𑀢𑀼;

𑀦𑀸𑀲𑀸 𑀘 𑀦𑀸𑀲𑀺𑀓𑀸 𑀖𑀸𑀦𑀁, 𑀚𑀺𑀯𑁆𑀳𑀸𑀢𑀼 𑀭𑀲𑀦𑀸 𑀪𑀯𑁂.

𑀲𑀭𑀻𑀭𑀁 𑀯𑀧𑀼 𑀕𑀢𑁆𑀢𑀜𑁆𑀘𑀸, 𑀢𑁆𑀢𑀪𑀸𑀯𑁄 𑀩𑁄𑀦𑁆𑀤𑀺 𑀯𑀺𑀕𑁆𑀕𑀳𑁄;

𑀤𑁂𑀳𑀁 𑀯𑀸 𑀧𑀼𑀭𑀺𑀲𑁂 𑀓𑀸𑀬𑁄, 𑀣𑀺𑀬𑀁 𑀢𑀦𑀼 𑀓𑀴𑁂𑀯𑀭𑀁.

𑀘𑀺𑀢𑁆𑀢𑀁 𑀘𑁂𑀢𑁄 𑀫𑀦𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀁 𑀳𑀤𑀬𑀁 𑀢𑀣𑀸;

𑀫𑀸𑀦𑀲𑀁 𑀥𑀻 𑀢𑀼 𑀧𑀜𑁆𑀜𑀸 𑀘, 𑀩𑀼𑀤𑁆𑀥𑀺 𑀫𑁂𑀥𑀸 𑀫𑀢𑀺 𑀫𑀼𑀢𑀺.

𑀪𑀽𑀭𑀻 𑀫𑀦𑁆𑀢𑀸 𑀘 𑀧𑀜𑁆𑀜𑀸𑀡𑀁, 𑀜𑀸𑀡𑀁 𑀯𑀺𑀚𑁆𑀚𑀸 𑀘 𑀬𑁄𑀦𑀺 𑀘;

𑀧𑀝𑀺𑀪𑀸𑀦 𑀫𑀫𑁄𑀳𑁄 𑀣, 𑀧𑀜𑁆𑀜𑀸𑀪𑁂𑀤𑀸 𑀯𑀺𑀧𑀲𑁆𑀲𑀦𑀸.

𑀲𑀫𑁆𑀫𑀸𑀤𑀺𑀝𑁆𑀞𑀺 𑀧𑀪𑀼𑀢𑀺𑀓𑀸, 𑀯𑀻𑀫𑀁𑀲𑀸 𑀢𑀼 𑀯𑀺𑀘𑀸𑀭𑀡𑀸;

𑀲𑀫𑁆𑀧𑀚𑀜𑁆𑀜𑀁 𑀢𑀼 𑀦𑁂𑀧𑀓𑁆𑀓𑀁, 𑀯𑁂𑀤𑀬𑀺𑀢𑀁 𑀢𑀼 𑀯𑁂𑀤𑀦𑀸.

𑀢𑀓𑁆𑀓𑁄 𑀯𑀺𑀢𑀓𑁆𑀓𑁄 𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑁄,

𑀏𑀓𑀕𑁆𑀕𑀢𑀸 𑀢𑀼 𑀲𑀫𑀣𑁄, 𑀅𑀯𑀺𑀓𑁆𑀔𑁂𑀧𑁄 𑀲𑀫𑀸𑀥𑀺 𑀘.

𑀉𑀲𑁆𑀲𑀸𑀳𑀸’ 𑀢𑀧𑁆𑀧 𑀧𑀕𑁆𑀕𑀸𑀳𑀸, 𑀯𑀸𑀬𑀸𑀫𑁄 𑀘 𑀧𑀭𑀓𑁆𑀓𑀫𑁄;

𑀧𑀥𑀸𑀦𑀁 𑀯𑀻𑀭𑀺𑀬𑀁 𑀘𑁂𑀳𑀸, 𑀉𑀬𑁆𑀬𑀸𑀫𑁄 𑀘 𑀥𑀺𑀢𑀺 𑀢𑁆𑀣𑀺𑀬𑀁.

𑀘𑀢𑁆𑀢𑀸𑀭𑀺 𑀯𑀻𑀭𑀺𑀬𑀗𑁆𑀕𑀸𑀦𑀺, 𑀢𑀘𑀲𑁆𑀲 𑀘 𑀦𑀳𑀸𑀭𑀼𑀦𑁄;

𑀅𑀯𑀲𑀺𑀲𑁆𑀲𑀦 𑀫𑀝𑁆𑀞𑀺𑀲𑁆𑀲, 𑀫𑀁𑀲𑀮𑁄𑀳𑀺𑀢𑀲𑀼𑀲𑁆𑀲𑀦𑀁.

𑀉𑀲𑁆𑀲𑁄𑀴𑁆𑀳𑀻 ¶ 𑀢𑁆𑀯 𑀥𑀺𑀫𑀢𑁆𑀢𑁂𑀳𑀸, 𑀲𑀢𑀺 𑀢𑁆𑀯 𑀦𑀼𑀲𑁆𑀲𑀢𑀺 𑀢𑁆𑀣𑀺𑀬;

𑀮𑀚𑁆𑀚𑀸 𑀳𑀺𑀭𑀻 𑀲𑀫𑀸𑀦𑀸 𑀣, 𑀑𑀢𑁆𑀢𑀧𑁆𑀧𑀁 𑀧𑀸𑀧𑀪𑀻𑀭𑀼𑀢𑀸.

𑀫𑀚𑁆𑀛𑀢𑁆𑀢𑀢𑀸 𑀢𑀼’𑀧𑁂𑀓𑁆𑀔𑀸 𑀘, 𑀅𑀤𑀼𑀓𑁆𑀔𑀫𑀲𑀼𑀔𑀸 𑀲𑀺𑀬𑀸;

𑀤𑀬𑀸’ 𑀦𑀼𑀓𑀫𑁆𑀧𑀸 𑀓𑀸𑀭𑀼𑀜𑁆𑀜𑀁, 𑀓𑀭𑀼𑀡𑀸 𑀘 𑀅𑀦𑀼𑀤𑁆𑀤𑀬𑀸;

𑀣𑀺𑀬𑀁 𑀯𑁂𑀭𑀫𑀡𑀻 𑀘𑁂𑀯, 𑀯𑀺𑀭𑀢𑁆𑀬𑀸’ 𑀭𑀢𑀺 𑀘𑀸𑀧𑁆𑀬𑀣.

𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀸 𑀔𑀦𑁆𑀢𑀺 𑀔𑀫𑀦𑀁, 𑀔𑀫𑀸 𑀫𑁂𑀢𑁆𑀢𑀸 𑀢𑀼 𑀫𑁂𑀢𑁆𑀬’𑀣;

𑀤𑀲𑁆𑀲𑀦𑀁 𑀤𑀺𑀝𑁆𑀞𑀺 𑀮𑀤𑁆𑀥𑀺𑀢𑁆𑀣𑀻, 𑀲𑀺𑀤𑁆𑀥𑀦𑁆𑀢𑁄 𑀲𑀫𑀬𑁄 𑀪𑀯𑁂.

𑀢𑀡𑁆𑀳𑀸 𑀘 𑀢𑀲𑀺𑀡𑀸 𑀏𑀚𑀸, 𑀚𑀸𑀮𑀺𑀦𑀻 𑀘 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀸;

𑀙𑀦𑁆𑀤𑁄 𑀚𑀝𑀸 𑀦𑀺𑀓𑀦𑁆𑀢𑁆𑀬𑀸’𑀲𑀸, 𑀲𑀺𑀩𑁆𑀩𑀺𑀦𑀻 𑀪𑀯𑀦𑁂𑀢𑁆𑀢𑀺 𑀘.

𑀅𑀪𑀺𑀚𑁆𑀛𑀸 𑀯𑀦𑀣𑁄 𑀯𑀸𑀦𑀁, 𑀮𑁄𑀪𑁄 𑀭𑀸𑀕𑁄 𑀘 𑀆𑀮𑀬𑁄;

𑀧𑀺𑀳𑀸 𑀫𑀦𑁄𑀭𑀣𑁄 𑀇𑀘𑁆𑀙𑀸, 𑀪𑀺𑀮𑀸𑀲𑁄 𑀓𑀸𑀫 𑀤𑁄𑀳𑀴𑀸;

𑀆𑀓𑀗𑁆𑀔𑀸 𑀭𑀼𑀘𑀺 𑀯𑀼𑀢𑁆𑀢𑀸 𑀲𑀸, 𑀢𑁆𑀯𑀥𑀺𑀓𑀸 𑀮𑀸𑀮𑀲𑀸 𑀤𑁆𑀯𑀺𑀲𑀼.

𑀯𑁂𑀭𑀁 𑀯𑀺𑀭𑁄𑀥𑁄 𑀯𑀺𑀤𑁆𑀤𑁂𑀲𑁄, 𑀤𑁄𑀲𑁄 𑀘 𑀧𑀝𑀺𑀖𑀜𑁆𑀘 𑀯𑀸;

𑀩𑀤𑁆𑀥𑀯𑁂𑀭 𑀫𑀼𑀧𑀦𑀸𑀳𑁄, 𑀲𑀺𑀬𑀸 𑀲𑁄𑀓𑁄 𑀢𑀼 𑀲𑁄𑀘𑀦𑀁;

𑀭𑁄𑀤𑀺𑀢𑀁 𑀓𑀦𑁆𑀤𑀺𑀢𑀁 𑀭𑀼𑀡𑁆𑀡𑀁, 𑀧𑀭𑀺𑀤𑁂𑀯𑁄 𑀧𑀭𑀺𑀤𑁆𑀤𑀯𑁄.

𑀪𑀻𑀢𑀺𑀢𑁆𑀣𑀺 𑀪𑀬 𑀫𑀼𑀢𑁆𑀢𑀸𑀲𑁄, 𑀪𑁂𑀭𑀯𑀁 𑀢𑀼 𑀫𑀳𑀩𑁆𑀪𑀬𑀁;

𑀪𑁂𑀭𑀯𑀁 𑀪𑀻𑀲𑀦𑀁 𑀪𑀻𑀫𑀁, 𑀤𑀸𑀭𑀼𑀡𑀜𑁆𑀘 𑀪𑀬𑀸𑀦𑀓𑀁;

𑀖𑁄𑀭𑀁 𑀧𑀝𑀺𑀪𑀬𑀁 𑀪𑁂𑀲𑁆𑀫𑀁, 𑀪𑀬𑀗𑁆𑀓𑀭 𑀫𑀺𑀫𑁂 𑀢𑀻𑀲𑀼.

𑀇𑀲𑁆𑀲𑀸 𑀉𑀲𑀽𑀬𑀸 𑀫𑀘𑁆𑀙𑁂𑀭𑀁, 𑀢𑀼 𑀫𑀘𑁆𑀙𑀭𑀺𑀬 𑀫𑀘𑁆𑀙𑀭𑀁;

𑀫𑁄𑀳𑁄’𑀯𑀺𑀚𑁆𑀚𑀸 𑀢𑀣𑀸’𑀜𑀸𑀡𑀁, 𑀫𑀸𑀦𑁄 𑀯𑀺𑀥𑀸 𑀘 𑀉𑀦𑁆𑀦𑀢𑀺.

𑀉𑀤𑁆𑀥𑀘𑁆𑀘 𑀫𑀼𑀤𑁆𑀥𑀝𑀁 𑀘𑀸𑀣 [𑀉𑀤𑁆𑀥𑀯𑀁𑀉𑀤𑁆𑀥𑀁 𑀥𑀸𑀯𑀢𑀺 𑀘𑀺𑀢𑁆𑀢 𑀫𑁂𑀢𑁂𑀦𑀸𑀢𑀺 𑀉𑀤𑁆𑀥𑀯𑀁 (𑀝𑀻𑀓𑀸)], 𑀢𑀸𑀧𑁄 𑀓𑀼𑀓𑁆𑀓𑀼𑀘𑁆𑀘𑀫𑁂𑀯 𑀘;

𑀧𑀘𑁆𑀙𑀸𑀢𑀸𑀧𑁄 𑀦𑀼𑀢𑀸𑀧𑁄 𑀘, 𑀯𑀺𑀧𑁆𑀧𑀝𑀺𑀲𑀸𑀭𑁄 𑀧𑀓𑀸𑀲𑀺𑀢𑁄.

𑀫𑀦𑁄𑀯𑀺𑀮𑁂𑀔 𑀲𑀦𑁆𑀤𑁂𑀳𑀸, 𑀲𑀁𑀲𑀬𑁄 𑀘 𑀓𑀣𑀁𑀓𑀣𑀸;

𑀤𑁆𑀯𑁂𑀴𑁆𑀳𑀓𑀁 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀸 𑀘, 𑀓𑀗𑁆𑀔𑀸 𑀲𑀗𑁆𑀓𑀸 𑀯𑀺𑀫𑀢𑁆𑀬𑀧𑀺.

𑀕𑀩𑁆𑀩𑁄 ¶ 𑀪𑀺𑀫𑀸𑀦𑁄’𑀳𑀁𑀓𑀸𑀭𑁄, 𑀘𑀺𑀦𑁆𑀢𑀸𑀢𑀼 𑀛𑀸𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀦𑀺𑀘𑁆𑀙𑀬𑁄 𑀦𑀺𑀡𑁆𑀡𑀬𑁄 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀧𑀝𑀺𑀜𑁆𑀜𑀸 𑀢𑀼 𑀧𑀝𑀺𑀲𑁆𑀲𑀯𑁄.

𑀅𑀯𑀫𑀸𑀦𑀁 𑀢𑀺𑀭𑀓𑁆𑀓𑀸𑀭𑁄, 𑀧𑀭𑀺𑀪𑀯𑁄 𑀧𑁆𑀬’ 𑀦𑀸𑀤𑀭𑁄;

𑀧𑀭𑀸𑀪𑀯𑁄 𑀧𑁆𑀬’ 𑀯𑀜𑁆𑀜𑀸 𑀣, 𑀉𑀫𑁆𑀫𑀸𑀤𑁄 𑀘𑀺𑀢𑁆𑀢𑀯𑀺𑀩𑁆𑀪𑀫𑁄.

𑀧𑁂𑀫𑀁 𑀲𑀺𑀦𑁂𑀳𑁄 𑀲𑁆𑀦𑁂𑀳𑁄 𑀣, 𑀘𑀺𑀢𑁆𑀢𑀧𑀻𑀴𑀸 𑀯𑀺𑀲𑀜𑁆𑀜𑀺𑀢𑀸;

𑀧𑀫𑀸𑀤𑁄 𑀲𑀢𑀺𑀯𑁄𑀲𑁆𑀲𑀕𑁆𑀕𑁄, 𑀓𑁄𑀢𑀽𑀳𑀮𑀁 𑀓𑀼𑀢𑀽𑀳𑀮𑀁.

𑀯𑀺𑀮𑀸𑀲𑁄 𑀮𑀮𑀺𑀢𑀁 𑀮𑀻𑀮𑀸, 𑀳𑀸𑀯𑁄 𑀳𑁂𑀴𑀸 𑀘 𑀯𑀺𑀩𑁆𑀪𑀫𑁄;

𑀇𑀘𑁆𑀘𑀸𑀤𑀺𑀓𑀸 𑀲𑀺𑀬𑀼𑀁 𑀦𑀸𑀭𑀺, 𑀲𑀺𑀗𑁆𑀕𑀸𑀭𑀪𑀸𑀯𑀚𑀸 𑀓𑀺𑀭𑀺𑀬𑀸.

𑀳𑀲𑀦𑀁 𑀳𑀲𑀺𑀢𑀁 𑀳𑀸𑀲𑁄, 𑀫𑀦𑁆𑀤𑁄 𑀲𑁄 𑀫𑀺𑀳𑀺𑀢𑀁 𑀲𑀺𑀢𑀁;

𑀧𑀭𑀺𑀳𑀸𑀲𑁄 𑀤𑀯𑁄 𑀔𑀺𑀟𑁆𑀟𑀸, 𑀓𑁂𑀴𑀺 𑀓𑀻𑀴𑀸 𑀘 𑀓𑀻𑀴𑀺𑀢𑀁;

𑀦𑀺𑀤𑁆𑀤𑀸 𑀢𑀼 𑀲𑀼𑀧𑀺𑀦𑀁 𑀲𑁄𑀧𑁆𑀧𑀁, 𑀫𑀺𑀤𑁆𑀥𑀜𑁆𑀘 𑀧𑀘𑀮𑀸𑀬𑀺𑀓𑀸.

𑀣𑀺𑀬𑀁 𑀦𑀺𑀓𑀢𑀺 𑀓𑀽𑀝𑀜𑁆𑀘, 𑀤𑀫𑁆𑀪𑁄 𑀲𑀸𑀞𑁆𑀬𑀜𑁆𑀘 𑀓𑁂𑀢𑀯𑀁;

𑀲𑀪𑀸𑀯𑁄 𑀢𑀼 𑀦𑀺𑀲𑁆𑀲𑀕𑁆𑀕𑁄 𑀘, 𑀲𑀭𑀽𑀧𑀁 𑀧𑀓𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀉𑀲𑁆𑀲𑀯𑁄 𑀢𑀼 𑀙𑀡𑁄 𑀫𑀳𑁄 [𑀫𑀢𑁄 (𑀝𑀻.)].

𑀥𑀸𑀭𑁂𑀦𑁆𑀢𑁄 𑀚𑀦𑁆𑀢𑀼 𑀲𑀲𑁆𑀦𑁂𑀳, 𑀫𑀪𑀺𑀥𑀸𑀦𑀧𑁆𑀧𑀤𑀻𑀧𑀺𑀓𑀁;

𑀔𑀼𑀤𑁆𑀤𑀓𑀸𑀤𑁆𑀬𑀢𑁆𑀣𑀚𑀸𑀢𑀸𑀦𑀺 [𑀔𑀼𑀤𑁆𑀤𑀓𑀸𑀦𑁆𑀬𑀢𑁆𑀣𑀚𑀸𑀢𑀸𑀦𑀺 (𑀓.)], 𑀲𑀫𑁆𑀧𑀲𑁆𑀲𑀢𑀺 𑀬𑀣𑀸𑀲𑀼𑀔𑀁.

𑀯𑀕𑁆𑀕𑀸 𑀪𑀽𑀫𑀺, 𑀧𑀼𑀭𑀻, 𑀫𑀘𑁆𑀘, 𑀘𑀢𑀼𑀩𑁆𑀩𑀡𑁆𑀡, 𑀯𑀦𑀸𑀤𑀺𑀳𑀺;

𑀧𑀸𑀢𑀸𑀮𑁂𑀦 𑀘 𑀯𑀼𑀘𑁆𑀘𑀦𑁆𑀢𑁂, 𑀲𑀗𑁆𑀕𑁄’𑀧𑀗𑁆𑀕𑁂𑀳𑀺’𑀥’𑀓𑁆𑀓𑀫𑀸.

𑀯𑀲𑀼𑀦𑁆𑀥𑀭𑀸 𑀙𑀫𑀸 𑀪𑀽𑀫𑀺, 𑀧𑀣𑀯𑀻 𑀫𑁂𑀤𑀦𑀻 𑀫𑀳𑀻;

𑀉𑀩𑁆𑀩𑀻 𑀯𑀲𑀼𑀫𑀢𑀻 𑀕𑁄 𑀓𑀼, 𑀯𑀲𑀼𑀥𑀸 𑀥𑀭𑀡𑀻 𑀥𑀭𑀸;

𑀧𑀼𑀣𑀯𑀻 𑀚𑀕𑀢𑀻 𑀪𑀽𑀭𑀻, 𑀪𑀽 𑀘 𑀪𑀽𑀢𑀥𑀭𑀸’ 𑀯𑀦𑀻.

𑀔𑀸𑀭𑀸 ¶ 𑀢𑀼 𑀫𑀢𑁆𑀢𑀺𑀓𑀸 𑀊𑀲𑁄, 𑀊𑀲𑀯𑀸 𑀢𑀽𑀲𑀭𑁄 𑀢𑀺𑀲𑀼;

𑀣𑀮𑀁 𑀣𑀮𑀻𑀢𑁆𑀣𑀻 𑀪𑀽𑀪𑀸𑀕𑁂, 𑀣𑀤𑁆𑀥𑀮𑀽𑀔𑀫𑁆𑀳𑀺 𑀚𑀗𑁆𑀕𑀮𑁄.

𑀧𑀼𑀩𑁆𑀩𑀯𑀺𑀤𑁂𑀳𑁄 𑀘𑀸𑀧𑀭, 𑀕𑁄𑀬𑀸𑀦𑀁 𑀚𑀫𑁆𑀩𑀼𑀤𑀻𑀧𑁄 𑀘;

𑀉𑀢𑁆𑀢𑀭𑀓𑀼𑀭𑀼 𑀘𑁂𑀢𑀺 𑀲𑀺𑀬𑀼𑀁, 𑀘𑀢𑁆𑀢𑀸𑀭𑁄𑀫𑁂 𑀫𑀳𑀸𑀤𑀻𑀧𑀸.

𑀧𑀼𑀫𑁆𑀩𑀳𑀼𑀢𑁆𑀢𑁂 𑀓𑀼𑀭𑀽 𑀲𑀓𑁆𑀓𑀸, 𑀓𑁄𑀲𑀮𑀸 𑀫𑀕𑀥𑀸 𑀲𑀺𑀯𑀻;

𑀓𑀮𑀺𑀗𑁆𑀕𑀸’𑀯𑀦𑁆𑀢𑀺 𑀧𑀜𑁆𑀘𑀸𑀮𑀸, 𑀯𑀚𑁆𑀚𑀻 𑀕𑀦𑁆𑀥𑀸𑀭 𑀘𑁂𑀢𑀬𑁄.

𑀯𑀗𑁆𑀕𑀸 𑀯𑀺𑀤𑁂𑀳𑀸 𑀓𑀫𑁆𑀩𑁄𑀚𑀸, 𑀫𑀤𑁆𑀤𑀸 𑀪𑀕𑁆𑀕’𑀗𑁆𑀕 𑀲𑀻𑀳𑀴𑀸;

𑀓𑀲𑁆𑀫𑀻𑀭𑀸 𑀓𑀸𑀲𑀺 𑀧𑀡𑁆𑀟𑀯𑀸𑀤𑀻, 𑀲𑀺𑀬𑀼𑀁 𑀚𑀦𑀧𑀤𑀦𑁆𑀢𑀭𑀸.

𑀮𑁄𑀓𑁄 𑀘 𑀪𑀼𑀯𑀦𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀤𑁂𑀲𑁄 𑀢𑀼 𑀯𑀺𑀲𑀬𑁄 𑀧𑁆𑀬𑀣;

𑀫𑀺𑀮𑀓𑁆𑀔𑀤𑁂𑀲𑁄 𑀧𑀘𑁆𑀘𑀦𑁆𑀢𑁄, 𑀫𑀚𑁆𑀛𑀤𑁂𑀲𑁄 𑀢𑀼 𑀫𑀚𑁆𑀛𑀺𑀫𑁄.

𑀅𑀦𑀽𑀧𑁄 𑀲𑀮𑀺𑀮𑀧𑁆𑀧𑀸𑀬𑁄, 𑀓𑀘𑁆𑀙𑀁 𑀧𑀼𑀫 𑀦𑀧𑀼𑀁𑀲𑀓𑁂;

𑀲𑀤𑁆𑀤𑀮𑁄 𑀳𑀭𑀺𑀢𑁂 𑀤𑁂𑀲𑁂, 𑀢𑀺𑀡𑁂𑀦𑀸, 𑀪𑀺𑀦𑀯𑁂𑀦 𑀳𑀺.

𑀦𑀤𑁆𑀬𑀫𑁆𑀩𑀼𑀚𑀻𑀯𑀦𑁄 𑀤𑁂𑀲𑁄, 𑀯𑀼𑀝𑁆𑀞𑀺𑀦𑀺𑀧𑁆𑀧𑀚𑁆𑀚𑀲𑀲𑁆𑀲𑀓𑁄;

𑀢𑀻𑀲𑁆𑀯𑀦𑀽𑀧𑀸𑀤𑁆𑀬𑀣𑁄 𑀘𑀦𑁆𑀤, 𑀲𑀽𑀭𑀸𑀤𑁄 𑀲𑀲𑁆𑀲𑀢𑀻𑀭𑀺𑀢𑁄;

𑀭𑀝𑁆𑀞𑀁 𑀢𑀼 𑀯𑀺𑀚𑀺𑀢𑀜𑁆𑀘𑀸𑀣, 𑀧𑀼𑀭𑀺𑀲𑁂 𑀲𑁂𑀢𑀼 𑀆𑀮𑀺𑀬𑀁.

𑀉𑀧𑀸𑀦𑁆𑀢𑀪𑀽 𑀧𑀭𑀺𑀲𑀭𑁄, 𑀕𑁄𑀝𑁆𑀞𑀁 𑀢𑀼 𑀕𑁄𑀓𑀼𑀮𑀁 𑀯𑀚𑁄;

𑀫𑀕𑁆𑀕𑁄 𑀧𑀦𑁆𑀣𑁄 𑀧𑀣𑁄 𑀅𑀤𑁆𑀥𑀸, 𑀅𑀜𑁆𑀚𑀲𑀁 𑀯𑀝𑀼𑀫𑀁 𑀢𑀣𑀸.

𑀧𑀚𑁆𑀚𑁄 [𑀧𑀚𑁆𑀚𑀸…. (𑀓.)], 𑀬𑀦𑀜𑁆𑀘 𑀧𑀤𑀯𑀻, 𑀯𑀢𑁆𑀢𑀦𑀻 𑀧𑀤𑁆𑀥𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀢𑀩𑁆𑀪𑁂𑀤𑀸 𑀚𑀗𑁆𑀖, 𑀲𑀓𑀝, 𑀫𑀕𑁆𑀕𑀸 𑀢𑁂 𑀘 𑀫𑀳𑀤𑁆𑀥𑀦𑀺.

𑀏𑀓𑀧𑀤𑁆𑀬𑁂𑀓𑀧𑀤𑀺𑀓𑁂, 𑀓𑀦𑁆𑀢𑀸𑀭𑁄 𑀢𑀼 𑀘 𑀤𑀼𑀕𑁆𑀕𑀫𑁂;

𑀧𑀝𑀺𑀫𑀕𑁆𑀕𑁄 𑀧𑀝𑀺𑀧𑀣𑁄, 𑀅𑀤𑁆𑀥𑀸𑀦𑀁 𑀤𑀻𑀖 𑀫𑀜𑁆𑀚𑀲𑀁;

𑀲𑀼𑀧𑁆𑀧𑀣𑁄 𑀢𑀼 𑀲𑀼𑀧𑀦𑁆𑀣𑁄 𑀘, 𑀉𑀧𑁆𑀧𑀣𑀁 𑀢𑁆𑀯𑀧𑀣𑀁 𑀪𑀯𑁂.

𑀙𑀢𑁆𑀢𑀺𑀁𑀲𑀧𑀭𑀫𑀸𑀡𑀽𑀦, 𑀫𑁂𑀓𑁄 𑀡𑀼 𑀘 𑀙𑀢𑁆𑀢𑀺𑀁𑀲 𑀢𑁂;

𑀢𑀚𑁆𑀚𑀸𑀭𑀻 𑀢𑀸𑀧𑀺 𑀙𑀢𑁆𑀢𑀺𑀁𑀲, 𑀭𑀣𑀭𑁂𑀡𑀼 𑀙𑀢𑁆𑀢𑀺𑀁𑀲 𑀢𑁂.

𑀮𑀺𑀓𑁆𑀔𑀸𑀢𑀸 𑀲𑀢𑁆𑀢 𑀊𑀓𑀸 𑀢𑀸, 𑀥𑀜𑁆𑀜𑀫𑀸𑀲𑁄𑀢𑀺 𑀲𑀢𑁆𑀢 𑀢𑁂;

𑀲𑀢𑁆𑀢 𑀗𑁆𑀕𑀼𑀮’ 𑀫𑀫𑀼 𑀤𑁆𑀯𑀺𑀘𑁆𑀙, 𑀯𑀺𑀤𑀢𑁆𑀣𑀺 𑀢𑀸 𑀤𑀼𑀯𑁂 𑀲𑀺𑀬𑀼𑀁.

𑀭𑀢𑀦𑀁 ¶ 𑀢𑀸𑀦𑀺 𑀲𑀢𑁆𑀢𑁂𑀯, 𑀬𑀝𑁆𑀞𑀺 𑀢𑀸 𑀯𑀻𑀲𑀢𑀽 𑀲𑀪𑀁;

𑀕𑀸𑀯𑀼𑀢 𑀫𑀼𑀲𑀪𑀸𑀲𑀻𑀢𑀺, 𑀬𑁄𑀚𑀦𑀁 𑀘𑀢𑀼𑀕𑀸𑀯𑀼𑀢𑀁.

𑀥𑀦𑀼𑀧𑀜𑁆𑀘𑀲𑀢𑀁 𑀓𑁄𑀲𑁄, 𑀓𑀭𑀻𑀲𑀁 𑀘𑀢𑀼𑀭𑀫𑁆𑀩𑀡𑀁;

𑀅𑀩𑁆𑀪𑀦𑁆𑀢𑀭𑀁 𑀢𑀼 𑀳𑀢𑁆𑀣𑀸𑀦, 𑀫𑀝𑁆𑀞𑀯𑀻𑀲 𑀧𑀫𑀸𑀡𑀢𑁄.

𑀧𑀼𑀭𑀁 𑀦𑀕𑀭 𑀫𑀺𑀢𑁆𑀣𑀻 𑀯𑀸, 𑀞𑀸𑀦𑀻𑀬𑀁 𑀧𑀼𑀝𑀪𑁂𑀤𑀦𑀁;

𑀣𑀺𑀬𑀁 𑀢𑀼 𑀭𑀸𑀚𑀥𑀸𑀦𑀻 [𑀭𑀸𑀚𑀞𑀸𑀦𑀻 (𑀝𑀻.)] 𑀘, 𑀔𑀦𑁆𑀥𑀸𑀯𑀸𑀭𑁄 𑀪𑀯𑁂 𑀣 𑀘.

𑀲𑀸𑀔𑀸𑀦𑀕𑀭 𑀫𑀜𑁆𑀜𑀢𑁆𑀭, 𑀬𑀁 𑀢𑀁 𑀫𑀽𑀮𑀧𑀼𑀭𑀸 𑀧𑀼𑀭𑀁;

𑀩𑀸𑀭𑀸𑀡𑀲𑀻 𑀘 𑀲𑀸𑀯𑀢𑁆𑀣𑀺, 𑀯𑁂𑀲𑀸𑀮𑀻 𑀫𑀺𑀣𑀺𑀮𑀸, 𑀴𑀯𑀻.

𑀓𑁄𑀲𑀫𑁆𑀩𑀼, 𑀚𑁆𑀚𑁂𑀦𑀺𑀬𑁄 𑀢𑀓𑁆𑀓, 𑀲𑀺𑀮𑀸 𑀘𑀫𑁆𑀧𑀸 𑀘 𑀲𑀸𑀕𑀮𑀁;

𑀲𑀼𑀲𑀼𑀫𑀸𑀭𑀕𑀺𑀭𑀁 [𑀲𑀁𑀲𑀼𑀫𑀸𑀭 (𑀝𑀻𑀓𑀸)] 𑀭𑀸𑀚, 𑀕𑀳𑀁 𑀓𑀧𑀺𑀮𑀯𑀢𑁆𑀣𑀼 𑀘.

𑀲𑀸𑀓𑁂𑀢, 𑀫𑀺𑀦𑁆𑀤𑀧𑀢𑁆𑀣𑀜𑁆𑀘𑁄, 𑀓𑁆𑀓𑀝𑁆𑀞𑀸 𑀧𑀸𑀝𑀮𑀺𑀧𑀼𑀢𑁆𑀢𑀓𑀁;

𑀚𑁂𑀢𑀼𑀢𑁆𑀢𑀭𑀜𑁆𑀘 𑀲𑀗𑁆𑀓𑀲𑁆𑀲𑀁, 𑀓𑀼𑀲𑀺𑀦𑀸𑀭𑀸𑀤𑀬𑁄 𑀧𑀼𑀭𑀻.

𑀭𑀘𑁆𑀙𑀸 𑀘 𑀯𑀺𑀲𑀺𑀔𑀸 𑀯𑀼𑀢𑁆𑀢𑀸, 𑀭𑀣𑀺𑀓𑀸 𑀯𑀻𑀣𑀺 𑀘𑀸𑀧𑁆𑀬𑀣;

𑀩𑁆𑀬𑀽𑀳𑁄 𑀭𑀘𑁆𑀙𑀸 𑀅𑀦𑀺𑀩𑁆𑀩𑀺𑀤𑁆𑀥𑀸, 𑀦𑀺𑀩𑁆𑀩𑀺𑀤𑁆𑀥𑀸 𑀢𑀼 𑀧𑀣𑀤𑁆𑀥𑀺 𑀘.

𑀘𑀢𑀼𑀓𑁆𑀓𑀁 𑀘𑀘𑁆𑀘𑀭𑁂 𑀫𑀕𑁆𑀕, 𑀲𑀦𑁆𑀥𑀺 𑀲𑀺𑀗𑁆𑀖𑀸𑀝𑀓𑀁 𑀪𑀯𑁂;

𑀧𑀸𑀓𑀸𑀭𑁄 𑀯𑀭𑀡𑁄 𑀘𑀸𑀣, 𑀉𑀤𑀸𑀧𑁄 [𑀉𑀤𑁆𑀤𑀸𑀧, 𑀉𑀤𑁆𑀤𑀸𑀧] 𑀉𑀧𑀓𑀸𑀭𑀺𑀓𑀸.

𑀓𑀼𑀝𑁆𑀝𑀁 𑀢𑀼 𑀪𑀺𑀢𑁆𑀢𑀺 𑀦𑀸𑀭𑀻 𑀣, 𑀕𑁄𑀧𑀼𑀭𑀁 𑀤𑁆𑀯𑀸𑀭𑀓𑁄𑀝𑁆𑀞𑀓𑁄;

𑀏𑀲𑀺𑀓𑀸 𑀇𑀦𑁆𑀤𑀔𑀻𑀮𑁄 𑀘, 𑀅𑀝𑁆𑀝𑁄 𑀢𑁆𑀯𑀝𑁆𑀝𑀸𑀮𑀓𑁄 𑀪𑀯𑁂.

𑀢𑁄𑀭𑀡𑀁 𑀢𑀼 𑀩𑀳𑀺𑀤𑁆𑀯𑀸𑀭𑀁, 𑀧𑀭𑀺𑀔𑀸𑀢𑀼 𑀘 𑀤𑀻𑀖𑀺𑀓𑀸;

𑀫𑀦𑁆𑀤𑀺𑀭𑀁 𑀲𑀤𑀦𑀸, 𑀕𑀸𑀭𑀁, 𑀦𑀺𑀓𑀸𑀬𑁄 𑀦𑀺𑀮𑀬𑀸, 𑀮𑀬𑁄.

𑀆𑀯𑀸𑀲𑁄 𑀪𑀯𑀦𑀁 𑀯𑁂𑀲𑁆𑀫𑀁, 𑀦𑀺𑀓𑁂𑀢𑀦𑀁 𑀦𑀺𑀯𑁂𑀲𑀦𑀁;

𑀖𑀭𑀁 𑀕𑀳𑀜𑁆𑀘𑀸, 𑀯𑀲𑀣𑁄, 𑀲𑀭𑀡𑀜𑁆𑀘 𑀧𑀢𑀺𑀲𑁆𑀲𑀬𑁄.

𑀑𑀓𑀁 𑀲𑀸𑀮𑀸 𑀔𑀬𑁄 𑀯𑀸𑀲𑁄, 𑀣𑀺𑀬𑀁 𑀓𑀼𑀝𑀺 𑀯𑀲𑀢𑁆𑀬’𑀧𑀺;

𑀕𑁂𑀳𑀜𑁆𑀘𑀸, 𑀦𑀺𑀢𑁆𑀣𑀺 𑀲𑀤𑀼𑀫𑀁, 𑀘𑁂𑀢𑀺𑀬𑀸, 𑀬𑀢𑀦𑀸𑀦𑀺 𑀢𑀼.

𑀧𑀸𑀲𑀸𑀤𑁄 ¶ 𑀘𑁂𑀯 𑀬𑀽𑀧𑁄 𑀣, 𑀫𑀼𑀡𑁆𑀟𑀘𑁆𑀙𑀤𑁄 𑀘 𑀳𑀫𑁆𑀫𑀺𑀬𑀁;

𑀬𑀽𑀧𑁄𑀢𑀼 𑀕𑀚𑀓𑀼𑀫𑁆𑀪𑀫𑁆𑀳𑀺, 𑀳𑀢𑁆𑀣𑀺𑀦𑀔𑁄 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀲𑀼𑀧𑀡𑁆𑀡𑀯𑀗𑁆𑀓𑀘𑁆𑀙𑀤𑀦, 𑀫𑀟𑁆𑀠𑀬𑁄𑀕𑁄 𑀲𑀺𑀬𑀸 𑀣 𑀘;

𑀲𑀪𑀸𑀬𑀜𑁆𑀘 𑀲𑀪𑀸 𑀘𑀸𑀣, 𑀫𑀡𑁆𑀟𑀧𑀁 𑀯𑀸 𑀚𑀦𑀸𑀮𑀬𑁄;

𑀅𑀣𑁄 𑀆𑀲𑀦𑀲𑀸𑀮𑀸𑀬𑀁, 𑀧𑀝𑀺𑀓𑁆𑀓𑀫𑀦 𑀫𑀻𑀭𑀺𑀢𑀁.

𑀚𑀺𑀦𑀲𑁆𑀲 𑀯𑀸𑀲𑀪𑀯𑀦, 𑀫𑀺𑀢𑁆𑀣𑀻 𑀕𑀦𑁆𑀥𑀓𑀼𑀝𑀺 𑀧𑁆𑀬𑀣;

𑀣𑀺𑀬𑀁 𑀭𑀲𑀯𑀢𑀻 𑀧𑀸𑀓, 𑀝𑁆𑀞𑀸𑀦𑀜𑁆𑀘𑁂𑀯 𑀫𑀳𑀸𑀦𑀲𑀁.

𑀆𑀯𑁂𑀲𑀦𑀁 𑀲𑀺𑀧𑁆𑀧𑀲𑀸𑀮𑀸, 𑀲𑁄𑀡𑁆𑀟𑀸 𑀢𑀼 𑀧𑀸𑀦𑀫𑀦𑁆𑀤𑀺𑀭𑀁;

𑀯𑀘𑁆𑀘𑀝𑁆𑀞𑀸𑀦𑀁 𑀯𑀘𑁆𑀘𑀓𑀼𑀝𑀺, 𑀫𑀼𑀦𑀻𑀦𑀁 𑀞𑀸𑀦 𑀫𑀲𑁆𑀲𑀫𑁄.

𑀧𑀡𑁆𑀬𑀯𑀺𑀓𑁆𑀓𑀬𑀲𑀸𑀮𑀸 𑀓𑀼, 𑀆𑀧𑀡𑁄 𑀧𑀡𑁆𑀬𑀯𑀻𑀣𑀺𑀓𑀸;

𑀉𑀤𑁄𑀲𑀺𑀢𑁄 𑀪𑀡𑁆𑀟𑀲𑀸𑀮𑀸, 𑀘𑀗𑁆𑀓𑀫𑀦𑀁 𑀢𑀼 𑀘𑀗𑁆𑀓𑀫𑁄.

𑀚𑀦𑁆𑀢𑀸𑀖𑀭𑀁 𑀢𑁆𑀯𑀕𑁆𑀕𑀺𑀲𑀸𑀮𑀸, 𑀧𑀧𑀸 𑀧𑀸𑀦𑀻𑀬𑀲𑀸𑀮𑀺𑀓𑀸;

𑀕𑀩𑁆𑀪𑁄 𑀑𑀯𑀭𑀓𑁄 𑀯𑀸𑀲𑀸, 𑀕𑀸𑀭𑀁 𑀢𑀼 𑀲𑀬𑀦𑀺𑀕𑁆𑀕𑀳𑀁.

𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑀁 𑀢𑀼 𑀑𑀭𑁄𑀥𑁄, 𑀲𑀼𑀤𑁆𑀥𑀦𑁆𑀢𑁄’ 𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑀫𑁆𑀧𑀺 𑀘;

𑀅𑀲𑀩𑁆𑀩𑀯𑀺𑀲𑀬𑀝𑁆𑀞𑀸𑀦𑀁, 𑀭𑀜𑁆𑀜𑀁 𑀓𑀘𑁆𑀙𑀦𑁆𑀢𑀭𑀁 𑀫𑀢𑀁.

𑀯𑀸𑀢𑀧𑀸𑀦𑀁 𑀕𑀯𑀓𑁆𑀔𑁄 𑀘, 𑀚𑀸𑀮𑀜𑁆𑀘 𑀲𑀻𑀳𑀧𑀜𑁆𑀚𑀭𑀁.

𑀆𑀮𑁄𑀓𑀲𑀦𑁆𑀥𑀺 𑀯𑀼𑀢𑁆𑀢𑁄 𑀣, 𑀮𑀗𑁆𑀕𑀻’𑀢𑁆𑀣𑀻 𑀧𑀮𑀺𑀖𑁄 𑀪𑀯𑁂;

𑀓𑀧𑀺𑀲𑀻𑀲𑁄, 𑀕𑁆𑀕𑀮𑀢𑁆𑀣𑀫𑁆𑀪𑁄, 𑀦𑀺𑀩𑁆𑀩𑀁 𑀢𑀼 𑀙𑀤𑁆𑀤𑀓𑁄𑀝𑀺𑀬𑀁.

𑀙𑀤𑀦𑀁 𑀧𑀝𑀮𑀁 𑀙𑀤𑁆𑀤, 𑀫𑀚𑀺𑀭𑀁 𑀘𑀘𑁆𑀘𑀭𑁄, 𑀗𑁆𑀕𑀡𑀁;

𑀧𑀖𑀸𑀦𑁄 𑀧𑀖𑀦𑀸, 𑀮𑀺𑀦𑁆𑀤𑁄, 𑀧𑀫𑀼𑀔𑀁 𑀤𑁆𑀯𑀸𑀭𑀩𑀦𑁆𑀥𑀦𑀁.

𑀧𑀺𑀝𑁆𑀞𑀲𑀗𑁆𑀖𑀸𑀝𑀓𑀁 𑀤𑁆𑀯𑀸𑀭, 𑀩𑀸𑀳𑀸 𑀓𑀽𑀝𑀁 𑀢𑀼 𑀓𑀡𑁆𑀡𑀺𑀓𑀸;

𑀤𑁆𑀯𑀸𑀭𑀜𑁆𑀘 𑀧𑀝𑀺𑀳𑀸𑀭𑁄 𑀣, 𑀉𑀫𑁆𑀫𑀸𑀭𑁄 𑀤𑁂𑀳𑀦𑀻, 𑀢𑁆𑀣𑀺𑀬𑀁.

𑀏𑀴𑀓𑁄 𑀇𑀦𑁆𑀤𑀔𑀻𑀮𑁄 𑀣, 𑀣𑀫𑁆𑀪𑁄 𑀣𑀽𑀡𑁄 𑀧𑀼𑀫𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀧𑀸𑀝𑀺𑀓𑀸, 𑀟𑁆𑀠𑁂𑀦𑁆𑀤𑀼𑀧𑀸𑀲𑀸𑀡𑁂, 𑀕𑀺𑀜𑁆𑀚𑀓𑀸 𑀢𑀼 𑀘 𑀇𑀝𑁆𑀞𑀓𑀸.

𑀯𑀮𑀪𑀺𑀘𑁆𑀙𑀸𑀤𑀺𑀤𑀸𑀭𑀼𑀫𑁆𑀳𑀺, 𑀯𑀗𑁆𑀓𑁂 𑀕𑁄𑀧𑀸𑀦𑀲𑀻, 𑀢𑁆𑀣𑀺𑀬𑀁;

𑀓𑀧𑁄𑀢𑀧𑀸𑀮𑀺𑀓𑀸𑀬𑀁 𑀢𑀼, 𑀯𑀺𑀝𑀗𑁆𑀓𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀪𑀯𑁂.

𑀓𑀼𑀜𑁆𑀘𑀺𑀓𑀸𑀯𑀺𑀯𑀭𑀁 ¶ 𑀢𑀸𑀴, 𑀘𑁆𑀙𑀺𑀕𑁆𑀕𑀮𑁄 𑀧𑁆𑀬𑀣 𑀓𑀼𑀜𑁆𑀘𑀺𑀓𑀸;

𑀢𑀸𑀴𑁄’𑀯𑀸𑀧𑀼𑀭𑀡𑀁 𑀘𑀸𑀣, 𑀯𑁂𑀤𑀺𑀓𑀸 𑀯𑁂𑀤𑀺 𑀓𑀣𑁆𑀬𑀢𑁂.

𑀲𑀗𑁆𑀖𑀸𑀢𑁄 𑀧𑀓𑁆𑀔𑀧𑀸𑀲𑁄 𑀘, 𑀫𑀦𑁆𑀤𑀺𑀭𑀗𑁆𑀕𑀸 𑀢𑀼𑀮𑀸 𑀅𑀧𑀺;

𑀣𑀺𑀬𑀁 𑀲𑀫𑁆𑀫𑀼𑀚𑁆𑀚𑀦𑀻 𑀘𑁂𑀯, 𑀲𑀫𑁆𑀫𑀚𑁆𑀚𑀦𑀻 𑀘 𑀲𑁄𑀥𑀦𑀻.

𑀲𑀗𑁆𑀓𑀝𑀻𑀭𑀁 𑀢𑀼 𑀲𑀗𑁆𑀓𑀸𑀭, 𑀝𑁆𑀞𑀸𑀦𑀁 𑀲𑀗𑁆𑀓𑀸𑀭𑀓𑀽𑀝𑀓𑀁;

𑀅𑀣𑁄 𑀓𑀘𑀯𑀭𑁄, 𑀓𑁆𑀮𑀸𑀧𑁄, 𑀲𑀗𑁆𑀓𑀸𑀭𑁄 𑀘 𑀓𑀲𑀫𑁆𑀩𑀼𑀧𑀺.

𑀖𑀭𑀸𑀤𑀺𑀪𑀽𑀫𑀺 𑀢𑀁 𑀯𑀢𑁆𑀣𑀼, 𑀕𑀸𑀫𑁄 𑀲𑀁𑀯𑀲𑀣𑁄 𑀣 𑀲𑁄;

𑀧𑀸𑀓𑀝𑁄 𑀦𑀺𑀕𑀫𑁄 𑀪𑁄𑀕, 𑀫𑀘𑁆𑀘𑀸𑀤𑀺𑀪𑁆𑀬𑁄 𑀥𑀺 𑀢𑀽𑀤𑀺𑀢𑁄 [‘𑀅𑀥𑀺𑀪𑀽’𑀢𑀺 𑀈𑀭𑀺𑀢𑁄 𑀓𑀣𑀺𑀢𑁄 (𑀝𑀻.)].

𑀫𑀦𑀼𑀲𑁆𑀲𑁄 𑀫𑀸𑀦𑀼𑀲𑁄 𑀫𑀘𑁆𑀘𑁄, 𑀫𑀸𑀦𑀯𑁄 𑀫𑀦𑀼𑀚𑁄 𑀦𑀭𑁄;

𑀩𑀼𑀥𑁄 𑀯𑀺𑀤𑁆𑀯𑀸 𑀯𑀺𑀪𑀸𑀯𑀻 𑀘, 𑀲𑀦𑁆𑀢𑁄 𑀲𑀧𑁆𑀧𑀜𑁆𑀜 𑀓𑁄𑀯𑀺𑀤𑀸;

𑀥𑀻𑀫𑀸 𑀲𑀼𑀥𑀻 𑀓𑀯𑀺 𑀩𑁆𑀬𑀢𑁆𑀢𑁄, 𑀯𑀺𑀘𑀓𑁆𑀔𑀡𑁄 𑀯𑀺𑀲𑀸𑀭𑀤𑁄.

𑀫𑁂𑀥𑀸𑀯𑀻 𑀫𑀢𑀺𑀫𑀸 𑀧𑀜𑁆𑀜𑁄, 𑀯𑀺𑀜𑁆𑀜𑀽 𑀘 𑀯𑀺𑀤𑀽𑀭𑁄 𑀯𑀺𑀤𑀽;

𑀥𑀻𑀭𑁄 𑀯𑀺𑀧𑀲𑁆𑀲𑀻 𑀤𑁄𑀲𑀜𑁆𑀜𑀽, 𑀩𑀼𑀤𑁆𑀥𑁄 𑀘 𑀤𑀩𑁆𑀩 𑀯𑀺𑀤𑁆𑀤𑀲𑀼.

𑀇𑀢𑁆𑀣𑀻 𑀲𑀻𑀫𑀦𑁆𑀢𑀺𑀦𑀻 𑀦𑀸𑀭𑀻, 𑀣𑀻 𑀯𑀥𑀽 𑀯𑀦𑀺𑀢𑀸, 𑀗𑁆𑀕𑀦𑀸;

𑀧𑀫𑀤𑀸 𑀲𑀼𑀦𑁆𑀤𑀭𑀻 𑀓𑀦𑁆𑀢𑀸, 𑀭𑀫𑀡𑀻 𑀤𑀬𑀺𑀢𑀸, 𑀩𑀮𑀸.

𑀫𑀸𑀢𑀼𑀕𑀸𑀫𑁄 𑀘 𑀫𑀳𑀺𑀮𑀸, 𑀮𑀮𑀦𑀸 𑀪𑀻𑀭𑀼 𑀓𑀸𑀫𑀺𑀦𑀻;

𑀓𑀼𑀫𑀸𑀭𑀺𑀓𑀸 𑀢𑀼 𑀓𑀜𑁆𑀜𑀸 𑀣, 𑀬𑀼𑀯𑀢𑀻 𑀢𑀭𑀼𑀡𑀻 𑀪𑀯𑁂.

𑀥𑀯𑀢𑁆𑀣𑀺𑀦𑀻 𑀢𑀼 𑀲𑀗𑁆𑀓𑁂𑀢𑀁, 𑀬𑀸𑀢𑀺 𑀬𑀸 𑀲𑀸, 𑀪𑀺𑀲𑀸𑀭𑀺𑀓𑀸.

𑀕𑀡𑀺𑀓𑀸 ¶ 𑀯𑁂𑀲𑀺𑀬𑀸 𑀯𑀡𑁆𑀡, 𑀤𑀸𑀲𑀻 𑀦𑀕𑀭𑀲𑁄𑀪𑀺𑀦𑀻;

𑀭𑀽𑀧𑀽𑀧𑀚𑀻𑀯𑀺𑀦𑀻 𑀯𑁂𑀲𑀻, 𑀓𑀼𑀮𑀝𑀸 𑀢𑀼 𑀘 𑀩𑀦𑁆𑀥𑀓𑀻.

𑀯𑀭𑀸𑀭𑁄𑀳𑁄, 𑀢𑁆𑀢𑀫𑀸 𑀫𑀢𑁆𑀢, 𑀓𑀸𑀲𑀺𑀦𑀻 𑀯𑀭𑀯𑀡𑁆𑀡𑀺𑀦𑀻;

𑀧𑀢𑀺𑀩𑁆𑀩𑀢𑀸 𑀢𑁆𑀯𑀧𑀺 𑀲𑀢𑀻, 𑀓𑀼𑀮𑀺𑀢𑁆𑀣𑀻 𑀓𑀼𑀮𑀧𑀸𑀮𑀺𑀓𑀸.

𑀯𑀺𑀥𑀯𑀸 𑀧𑀢𑀺𑀲𑀼𑀜𑁆𑀜𑀸 𑀣, 𑀧𑀢𑀺𑀫𑁆𑀩𑀭𑀸 𑀲𑀬𑀫𑁆𑀩𑀭𑀸;

𑀯𑀺𑀚𑀸𑀢𑀸 𑀢𑀼 𑀧𑀲𑀽𑀢𑀸 𑀘, 𑀚𑀸𑀢𑀸𑀧𑀘𑁆𑀘𑀸 𑀧𑀲𑀽𑀢𑀺𑀓𑀸.

𑀤𑀽𑀢𑀻 𑀲𑀜𑁆𑀘𑀸𑀭𑀺𑀓𑀸 𑀤𑀸𑀲𑀻, 𑀢𑀼 𑀘𑁂𑀝𑀻 𑀓𑀼𑀝𑀥𑀸𑀭𑀺𑀓𑀸;

𑀯𑀸𑀭𑀼𑀡𑀻, 𑀓𑁆𑀔𑀡𑀺𑀓𑀸 𑀢𑀼𑀮𑁆𑀬𑀸, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀻 𑀢𑀼 𑀔𑀢𑁆𑀢𑀺𑀬𑀸.

𑀤𑀸𑀭𑁄 𑀚𑀸𑀬𑀸 𑀓𑀮𑀢𑁆𑀢𑀜𑁆𑀘, 𑀖𑀭𑀡𑀻 𑀪𑀭𑀺𑀬𑀸 𑀧𑀺𑀬𑀸,

𑀧𑀚𑀸𑀧𑀢𑀻 𑀘 𑀤𑀼𑀢𑀺𑀬𑀸, 𑀲𑀸 𑀧𑀸𑀤𑀧𑀭𑀺𑀘𑀸𑀭𑀺𑀓𑀸.

𑀲𑀔𑀻 𑀢𑁆𑀯𑀸’𑀮𑀻 𑀯𑀬𑀲𑁆𑀲𑀸 𑀣, 𑀚𑀸𑀭𑀻 𑀘𑁂𑀯𑀸’𑀢𑀺𑀘𑀸𑀭𑀺𑀦𑀻;

𑀧𑀼𑀫𑁂 𑀢𑀽’𑀢𑀼 𑀭𑀚𑁄 𑀧𑀼𑀧𑁆𑀨𑀁, 𑀉𑀢𑀼𑀦𑀻 𑀢𑀼 𑀭𑀚𑀲𑁆𑀲𑀮𑀸.

𑀧𑀼𑀧𑁆𑀨𑀯𑀢𑀻 𑀕𑀭𑀼𑀕𑀩𑁆𑀪𑀸, 𑀧𑀦𑁆𑀦𑀲𑀢𑁆𑀢𑀸 𑀘 𑀕𑀩𑁆𑀪𑀺𑀦𑀻;

𑀕𑀩𑁆𑀪𑀸𑀲𑀬𑁄 𑀚𑀮𑀸𑀩𑀼𑀧𑀺, 𑀓𑀮𑀮𑀁 𑀧𑀼𑀦𑁆𑀦𑀧𑀼𑀁𑀲𑀓𑁂.

𑀥𑀯𑁄𑀢𑀼 𑀲𑀸𑀫𑀺𑀓𑁄 𑀪𑀢𑁆𑀢𑀸, 𑀓𑀦𑁆𑀢𑁄 𑀧𑀢𑀺 𑀯𑀭𑁄 𑀧𑀺𑀬𑁄;

𑀧𑀘𑁆𑀘𑀁 𑀧𑀼𑀢𑁆𑀢𑁄’𑀢𑁆𑀭𑀚𑁄 𑀲𑀼𑀢𑁄.

𑀢𑀦𑀼𑀚𑁄 𑀢𑀦𑀬𑁄 𑀲𑀽𑀦𑀼, 𑀧𑀼𑀢𑁆𑀢𑀸𑀤𑀻 𑀥𑀻𑀢𑀭𑀺’𑀢𑁆𑀣𑀺𑀬𑀁;

𑀚𑀸𑀬𑀸𑀧𑀢𑀻 𑀚𑀦𑀺𑀧𑀢𑀻, 𑀚𑀬𑀫𑁆𑀧𑀢𑀻 𑀢𑀼 𑀤𑀫𑁆𑀧𑀢𑀻 [𑀤𑀫𑁆𑀧𑀢𑀻𑀢𑀺 𑀧𑀤𑀁 𑀧𑀼𑀮𑁆𑀮𑀺𑀗𑁆𑀕 𑀩𑀳𑀼𑀯𑀘𑀦𑀦𑁆𑀢𑀁 𑀇𑀓𑀸𑀭𑀦𑁆𑀢𑀁, 𑀢𑀼𑀤𑀫𑁆𑀧𑀢𑀺 (𑀝𑀻.)];

𑀅𑀣 𑀯𑀲𑁆𑀲𑀯𑀭𑁄 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀧𑀡𑁆𑀟𑀓𑁄 𑀘 𑀦𑀧𑀼𑀁𑀲𑀓𑀁.

𑀩𑀦𑁆𑀥𑀯𑁄 𑀩𑀦𑁆𑀥𑀼 𑀲𑀚𑀦𑁄, 𑀲𑀕𑁄𑀢𑁆𑀢𑁄 𑀜𑀸𑀢𑀺 𑀜𑀸𑀢𑀓𑁄;

𑀅𑀫𑁆𑀫, 𑀫𑁆𑀩𑀸 𑀚𑀦𑀦𑀻 𑀫𑀸𑀢𑀸, 𑀚𑀦𑁂𑀢𑁆𑀢𑀺 𑀚𑀦𑀺𑀓𑀸 𑀪𑀯𑁂;

𑀦𑀦𑀦𑁆𑀤𑀸 ¶ 𑀲𑀸𑀫𑀺𑀪𑀕𑀺𑀦𑀻, 𑀫𑀸𑀢𑀸𑀫𑀳𑀻 𑀢𑀼 𑀅𑀬𑁆𑀬𑀺𑀓𑀸;

𑀫𑀸𑀢𑀼𑀮𑁄 𑀫𑀸𑀢𑀼𑀪𑀸𑀢𑀸,𑀲𑁆𑀲, 𑀫𑀸𑀢𑀼𑀮𑀸𑀦𑀻 𑀧𑀚𑀸𑀧𑀢𑀺.

𑀚𑀸𑀬𑀸𑀧𑀢𑀻𑀦𑀁 𑀚𑀦𑀦𑀻, 𑀲𑀲𑁆𑀲𑀼 𑀯𑀼𑀢𑁆𑀢𑀸𑀣 𑀢𑀧𑁆𑀧𑀺𑀢𑀸;

𑀲𑀲𑀼𑀭𑁄 𑀪𑀸𑀕𑀺𑀦𑁂𑀬𑁆𑀬𑁄𑀢𑀼, 𑀧𑀼𑀢𑁆𑀢𑁄 𑀪𑀕𑀺𑀦𑀺𑀬𑀸 𑀪𑀯𑁂.

𑀦𑀢𑁆𑀢𑀸 𑀯𑀼𑀢𑁆𑀢𑁄 𑀧𑀧𑀼𑀢𑁆𑀢𑁄 𑀣, 𑀲𑀸𑀫𑀺𑀪𑀸𑀢𑀸 𑀢𑀼 𑀤𑁂𑀯𑀭𑁄;

𑀫𑀸𑀢𑀼𑀘𑁆𑀙𑀸 𑀫𑀸𑀢𑀼𑀪𑀕𑀺𑀦𑀻, 𑀧𑀺𑀢𑀼𑀘𑁆𑀙𑀸 𑀪𑀕𑀺𑀦𑀻 𑀧𑀺𑀢𑀼;

𑀲𑁄𑀤𑀭𑀺𑀬𑁄 𑀲𑀕𑀩𑁆𑀪𑁄 𑀘, 𑀲𑁄𑀤𑀭𑁄 𑀲𑀳𑀚𑁄 𑀧𑁆𑀬𑀣;

𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽 𑀢𑁂 𑀧𑀺𑀢𑀭𑁄, 𑀧𑀼𑀢𑁆𑀢𑀸 𑀢𑀼 𑀧𑀼𑀢𑁆𑀢𑀥𑀻𑀢𑀭𑁄.

𑀲𑀲𑀼𑀭𑀸 𑀲𑀲𑁆𑀲𑀼𑀲𑀲𑀼𑀭𑀸, 𑀪𑀸𑀢𑀼𑀪𑀕𑀺𑀦𑀻 𑀪𑀸𑀢𑀭𑁄;

𑀩𑀸𑀮𑀢𑁆𑀢𑀁 𑀩𑀸𑀮𑀢𑀸 𑀩𑀸𑀮𑁆𑀬𑀁, 𑀬𑁄𑀩𑁆𑀩𑀜𑁆𑀜𑀁𑀢𑀼 𑀘 𑀬𑁄𑀩𑁆𑀩𑀦𑀁.

𑀲𑀼𑀓𑁆𑀓𑀸 𑀢𑀼 𑀧𑀮𑀺𑀢𑀁 𑀓𑁂𑀲𑀸, 𑀤𑀬𑁄 𑀣 𑀚𑀭𑀢𑀸 𑀚𑀭𑀸;

𑀧𑀼𑀣𑀼𑀓𑁄 𑀧𑀺𑀮𑁆𑀮𑀓𑁄 𑀙𑀸𑀧𑁄, 𑀓𑀼𑀫𑀸𑀭𑁄 𑀩𑀸𑀮 𑀧𑁄𑀢𑀓𑀸.

𑀅𑀣𑀼’ 𑀢𑁆𑀢𑀸𑀦𑀲𑀬𑀼’𑀢𑁆𑀢𑀸𑀦, 𑀲𑁂𑀬𑁆𑀬𑀓𑀸 𑀣𑀦𑀧𑁄𑀧𑀺 𑀘;

𑀢𑀭𑀼𑀡𑁄 𑀘 𑀯𑀬𑀝𑁆𑀞𑁄 𑀘, 𑀤𑀳𑀭𑁄 𑀘 𑀬𑀼𑀯𑀸 𑀲𑀼𑀲𑀼;

𑀫𑀸𑀡𑀯𑁄𑀤𑀸𑀭𑀓𑁄𑀘𑀸𑀣, 𑀲𑀼𑀓𑀼𑀫𑀸𑀭𑁄 𑀲𑀼𑀔𑁂𑀥𑀺𑀢𑁄.

𑀫𑀳𑀮𑁆𑀮𑀓𑁄 𑀘 𑀯𑀼𑀤𑁆𑀥𑁄 𑀘, 𑀣𑁂𑀭𑁄 𑀚𑀺𑀡𑁆𑀡𑁄 𑀘 𑀚𑀺𑀡𑁆𑀡𑀓𑁄;

𑀅𑀕𑁆𑀕𑀚𑁄 𑀧𑀼𑀩𑁆𑀩𑀚𑁄 𑀚𑁂𑀝𑁆𑀞𑁄, 𑀓𑀦𑀺𑀬𑁄 𑀓𑀦𑀺𑀝𑁆𑀞𑁄 𑀦𑀼𑀚𑁄.

𑀯𑀮𑀺𑀢𑁆𑀢𑀘𑁄 𑀢𑀼 𑀯𑀮𑀺𑀦𑁄; 𑀢𑀻𑀲𑀼’𑀢𑁆𑀢𑀸𑀦𑀲𑀬𑀸𑀤𑀬𑁄;

𑀲𑀻𑀲𑁄’𑀢𑁆𑀢𑀫𑀗𑁆𑀕𑀸𑀦𑀺 𑀲𑀺𑀭𑁄, 𑀫𑀼𑀤𑁆𑀥𑀸 𑀘 𑀫𑀢𑁆𑀣𑀓𑁄 𑀪𑀯𑁂;

𑀓𑁂𑀲𑁄 𑀢𑀼 𑀓𑀼𑀦𑁆𑀢𑀮𑁄 𑀯𑀸𑀮𑁄, 𑀢𑁆𑀢𑀫𑀗𑁆𑀕𑀭𑀼𑀳 𑀫𑀼𑀤𑁆𑀥𑀚𑀸.

𑀲𑀻𑀫𑀦𑁆𑀢𑁄 𑀢𑀼 𑀫𑀢𑁄 𑀦𑀸𑀭𑀺, 𑀓𑁂𑀲𑀫𑀚𑁆𑀛𑀫𑁆𑀳𑀺 𑀧𑀤𑁆𑀥𑀢𑀺.

𑀮𑁄𑀫𑀁 ¶ 𑀢𑀦𑀼𑀭𑀼𑀳𑀁 𑀭𑁄𑀫𑀁, 𑀧𑀫𑁆𑀳𑀁 𑀧𑀔𑀼𑀫 𑀫𑀓𑁆𑀔𑀺𑀕𑀁;

𑀫𑀲𑁆𑀲𑀼 𑀯𑀼𑀢𑁆𑀢𑀁 𑀧𑀼𑀫𑀫𑀼𑀔𑁂, 𑀪𑀽 𑀢𑁆𑀯𑀺𑀢𑁆𑀣𑀻 𑀪𑀫𑀼𑀓𑁄 𑀪𑀫𑀼.

𑀩𑀧𑁆𑀧𑁄 [𑀔𑀧𑁆𑀧𑁄 (𑀝𑀻.)] 𑀦𑁂𑀢𑁆𑀢𑀚𑀮’𑀲𑁆𑀲𑀽𑀦𑀺, 𑀦𑁂𑀢𑁆𑀢𑀢𑀸𑀭𑀸 𑀓𑀦𑀻𑀦𑀺𑀓𑀸;

𑀯𑀤𑀦𑀁 𑀢𑀼 𑀫𑀼𑀔𑀁 𑀢𑀼𑀡𑁆𑀟𑀁, 𑀯𑀢𑁆𑀢𑀁 𑀮𑀧𑀦 𑀫𑀸𑀦𑀦𑀁.

𑀤𑁆𑀯𑀺𑀚𑁄 𑀮𑀧𑀦𑀚𑁄 𑀤𑀦𑁆𑀢𑁄, 𑀤𑀲𑀦𑁄 𑀭𑀤𑀦𑁄 𑀭𑀤𑁄;

𑀤𑀸𑀞𑀸 𑀢𑀼𑀤𑀦𑁆𑀢𑀪𑁂𑀤𑀲𑁆𑀫𑀺𑀁, 𑀅𑀧𑀸𑀗𑁆𑀕𑁄 𑀢𑁆𑀯𑀓𑁆𑀔𑀺𑀓𑁄𑀝𑀺𑀲𑀼.

𑀤𑀦𑁆𑀢𑀸𑀯𑀭𑀡 𑀫𑁄𑀝𑁆𑀞𑁄 𑀘𑀸, 𑀧𑁆𑀬’𑀥𑀭𑁄 𑀤𑀲𑀦𑀘𑁆𑀙𑀤𑁄;

𑀕𑀡𑁆𑀟𑁄 𑀓𑀧𑁄𑀮𑁄 𑀳𑀦𑁆𑀯𑀺𑀢𑁆𑀣𑀻 [𑀕𑀡𑁆𑀟𑀢𑁆𑀣𑀻 (𑀝𑀻.) 𑀳𑀦𑁆𑀯𑀢𑁆𑀣𑀻=𑀳𑀦𑀼+𑀇𑀢𑁆𑀣𑀻; 𑀳𑀦+𑀉 (𑀡𑁆𑀯𑀸𑀤𑀺)],

𑀕𑀮𑁄 𑀘 𑀓𑀡𑁆𑀞𑁄 𑀕𑀻𑀯𑀸 𑀘, 𑀓𑀦𑁆𑀥𑀭𑀸 𑀘 𑀲𑀺𑀭𑁄𑀥𑀭𑀸;

𑀓𑀫𑁆𑀩𑀼𑀕𑀻𑀯𑀸 𑀢𑀼 𑀬𑀸 𑀕𑀻𑀯𑀸, 𑀲𑀼𑀯𑀡𑁆𑀡𑀸𑀮𑀺𑀗𑁆𑀕𑀲𑀦𑁆𑀦𑀺𑀪𑀸;

𑀅𑀗𑁆𑀓𑀺𑀢𑀸 𑀢𑀻𑀳𑀺 𑀮𑁂𑀔𑀸𑀳𑀺, 𑀓𑀫𑁆𑀩𑀼𑀕𑀻𑀯𑀸 𑀣𑀯𑀸 𑀫𑀢𑀸.

𑀅𑀁𑀲𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀪𑀼𑀚𑀲𑀺𑀭𑁄, 𑀔𑀦𑁆𑀥𑁄 𑀢𑀲𑁆𑀲𑀦𑁆𑀥𑀺 𑀚𑀢𑁆𑀢𑀼 𑀢𑀁;

𑀩𑀸𑀳𑀼𑀫𑀽𑀮𑀁 𑀢𑀼 𑀓𑀘𑁆𑀙𑁄, 𑀥𑁄, 𑀢𑁆𑀯’𑀲𑁆𑀲 𑀧𑀲𑁆𑀲 𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀩𑀸𑀳𑀼 𑀪𑀼𑀚𑀸𑀤𑁆𑀯𑀻𑀲𑀼 𑀩𑀸𑀳𑀸, 𑀳𑀢𑁆𑀣𑁄 𑀢𑀼 𑀓𑀭 𑀧𑀸𑀡𑀬𑁄;

𑀫𑀡𑀺𑀩𑀦𑁆𑀥𑁄 𑀧𑀓𑁄𑀝𑁆𑀞𑀦𑁆𑀢𑁄, 𑀓𑀧𑁆𑀧𑀭𑁄 𑀢𑀼 𑀓𑀧𑁄𑀡𑁆𑀬’𑀣.

𑀫𑀡𑀺𑀩𑀦𑁆𑀥 𑀓𑀦𑀺𑀝𑁆𑀞𑀸𑀦𑀁, 𑀧𑀸𑀡𑀺𑀲𑁆𑀲 𑀓𑀭𑀪𑁄,𑀦𑁆𑀢𑀭𑀁;

𑀓𑀭𑀲𑀸𑀔𑀸, 𑀗𑁆𑀕𑀼𑀮𑀻 𑀢𑀸 𑀢𑀼, 𑀧𑀜𑁆𑀘, 𑀗𑁆𑀕𑀼𑀝𑁆𑀞𑁄 𑀘 𑀢𑀚𑁆𑀚𑀦𑀻;

𑀫𑀚𑁆𑀛𑀺𑀫𑀸 𑀦𑀸𑀫𑀺𑀓𑀸 𑀘𑀸𑀧𑀺, 𑀓𑀦𑀺𑀝𑁆𑀞𑀸’𑀢𑀺 𑀓𑀫𑀸 𑀲𑀺𑀬𑀼𑀁.

𑀧𑀤𑁂𑀲𑁄 𑀢𑀸𑀮𑀕𑁄𑀓𑀡𑁆𑀡𑀸, 𑀯𑀺𑀤𑀢𑁆𑀣𑀺,𑀢𑁆𑀣𑀻 𑀓𑀫𑀸 𑀢𑀢𑁂;

𑀢𑀚𑁆𑀚𑀦𑁆𑀬𑀸𑀤𑀺𑀬𑀼𑀢𑁂’𑀗𑁆𑀕𑀼𑀝𑁆𑀞𑁂, 𑀧𑀲𑀢𑁄 𑀧𑀸𑀡𑀺 𑀓𑀼𑀜𑁆𑀘𑀺𑀢𑁄.

𑀭𑀢𑀦𑀁 𑀓𑀼𑀓𑁆𑀓𑀼 𑀳𑀢𑁆𑀣𑁄 𑀣, 𑀧𑀼𑀫𑁂 𑀓𑀭𑀧𑀼𑀝𑁄,𑀜𑁆𑀚𑀮𑀺;

𑀓𑀭𑀚𑁄 𑀢𑀼 𑀦𑀔𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀔𑀝𑀓𑁄 𑀫𑀼𑀝𑁆𑀞𑀺 𑀘 𑀤𑁆𑀯𑀻𑀲𑀼.

𑀩𑁆𑀬𑀸𑀫𑁄 𑀲𑀳𑀓𑀭𑀸 𑀩𑀸𑀳𑀼, 𑀤𑁆𑀯𑁂 𑀧𑀲𑁆𑀲𑀤𑁆𑀯𑀬𑀯𑀺𑀢𑁆𑀣𑀢𑀸;

𑀉𑀤𑁆𑀥𑀦𑁆𑀢𑀢 𑀪𑀼𑀚𑀧𑁄𑀲, 𑀧𑁆𑀧𑀫𑀸𑀡𑁂 𑀧𑁄𑀭𑀺𑀲𑀁 𑀢𑀺𑀲𑀼.

𑀉𑀭𑁄 𑀘 𑀳𑀤𑀬𑀁 𑀘𑀸𑀣, 𑀣𑀦𑁄 𑀓𑀼𑀘 𑀧𑀬𑁄𑀥𑀭𑀸;

𑀘𑀽𑀘𑀼𑀓𑀁 𑀢𑀼 𑀣𑀦𑀕𑁆𑀕𑀲𑁆𑀫𑀺𑀁, 𑀧𑀺𑀝𑁆𑀞𑀁 𑀢𑀼 𑀧𑀺𑀝𑁆𑀞𑀺 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀫𑀚𑁆𑀛𑁄’𑀦𑀺𑀢𑁆𑀣𑀻 ¶ 𑀯𑀺𑀮𑀕𑁆𑀕𑁄 𑀘, 𑀫𑀚𑁆𑀛𑀺𑀫𑀁 𑀓𑀼𑀘𑁆𑀙𑀺 [𑀘𑀢𑀼𑀓𑁆𑀓𑀁 𑀉𑀤𑀭𑁂; 𑁯𑁪𑁪-𑀕𑀸𑀣𑀸𑀧𑀺 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸] 𑀢𑀼 𑀤𑁆𑀯𑀺𑀲𑀼;

𑀕𑀳𑀡𑀻𑀢𑁆𑀣𑁆𑀬𑀼𑀤𑀭𑀁 𑀕𑀩𑁆𑀪𑁄, 𑀓𑁄𑀝𑁆𑀞𑁄𑀦𑁆𑀢𑁄 𑀓𑀼𑀘𑁆𑀙𑀺𑀲𑀫𑁆𑀪𑀯𑁂.

𑀚𑀖𑀦𑀁 𑀢𑀼 𑀦𑀺𑀢𑀫𑁆𑀩𑁄 𑀘, 𑀲𑁄𑀡𑀻 𑀘 𑀓𑀝𑀺 𑀦𑀸𑀭𑀺𑀬𑀁;

𑀅𑀗𑁆𑀕𑀚𑀸𑀢𑀁 𑀭𑀳𑀲𑁆𑀲𑀗𑁆𑀕𑀁, 𑀯𑀢𑁆𑀣𑀕𑀼𑀬𑁆𑀳𑀜𑁆𑀘 𑀫𑁂𑀳𑀦𑀁.

𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑀜𑁆𑀘 𑀯𑀭𑀗𑁆𑀕𑀜𑁆𑀘, 𑀩𑀻𑀚𑀜𑁆𑀘 𑀨𑀮𑀫𑁂𑀯 𑀘;

𑀅𑀲𑀼𑀘𑀺 𑀲𑀫𑁆𑀪𑀯𑁄 𑀲𑀼𑀓𑁆𑀓𑀁, 𑀧𑀸𑀬𑀼 𑀢𑀼 𑀧𑀼𑀭𑀺𑀲𑁂 𑀕𑀼𑀤𑀁;

𑀯𑀸 𑀧𑀼𑀫𑁂 𑀕𑀽𑀣 𑀓𑀭𑀻𑀲, 𑀯𑀘𑁆𑀘𑀸𑀦𑀺 𑀘 𑀫𑀮𑀁 𑀙𑀓𑀁.

𑀉𑀘𑁆𑀘𑀸𑀭𑁄 𑀫𑀻𑀴𑁆𑀳 𑀫𑀼𑀓𑁆𑀓𑀸𑀭𑁄, 𑀧𑀲𑁆𑀲𑀸𑀯𑁄 𑀫𑀼𑀢𑁆𑀢 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀧𑀽𑀢𑀺𑀫𑀼𑀢𑁆𑀢𑀜𑁆𑀘 𑀕𑁄𑀫𑀼𑀢𑁆𑀢𑁂, 𑀲𑁆𑀲𑀸𑀤𑀻𑀦𑀁 𑀙𑀓𑀡𑀁 𑀫𑀮𑁂.

𑀤𑁆𑀯𑀻𑀲𑁆𑀯𑀥𑁄 𑀦𑀸𑀪𑀺𑀬𑀸 𑀯𑀢𑁆𑀣𑀺, 𑀉𑀘𑁆𑀙𑀗𑁆𑀕’𑀗𑁆𑀓𑀸 𑀢𑀼’𑀪𑁄 𑀧𑀼𑀫𑁂;

𑀊𑀭𑀼 𑀲𑀢𑁆𑀣𑀺 𑀧𑀼𑀫𑁂 𑀊𑀭𑀼, 𑀧𑀩𑁆𑀩𑀁 𑀢𑀼 𑀚𑀸𑀡𑀼 𑀚𑀡𑁆𑀡𑀼 𑀘.

𑀕𑁄𑀧𑁆𑀨𑀓𑁄 𑀧𑀸𑀤𑀕𑀡𑁆𑀞𑀺𑀧𑀺, 𑀧𑀼𑀫𑁂 𑀢𑀼 𑀧𑀡𑁆𑀳𑀺 𑀧𑀸𑀲𑀡𑀺;

𑀧𑀸𑀤𑀕𑁆𑀕𑀁 𑀧𑀧𑀤𑁄 𑀧𑀸𑀤𑁄, 𑀢𑀼 𑀧𑀤𑁄 𑀘𑀭𑀡𑀜𑁆𑀘 𑀯𑀸.

𑀅𑀗𑁆𑀕𑀁𑀢𑁆𑀯’𑀯𑀬𑀯𑁄 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀨𑀸𑀲𑀼𑀮𑀺𑀓𑀸 𑀢𑀼 𑀨𑀸𑀲𑀼𑀓𑀸;

𑀧𑀡𑁆𑀟𑀓𑁂 𑀅𑀝𑁆𑀞𑀺 𑀥𑀸𑀢𑁆𑀯𑀺𑀢𑁆𑀣𑀻, 𑀕𑀮𑀦𑁆𑀢𑀝𑁆𑀞𑀺 𑀢𑀼 𑀅𑀓𑁆𑀔𑀓𑁄.

𑀓𑀧𑁆𑀧𑀭𑁄 𑀢𑀼 𑀓𑀧𑀸𑀮𑀁 𑀯𑀸, 𑀓𑀡𑁆𑀟𑀭𑀸 𑀢𑀼 𑀫𑀳𑀸𑀲𑀺𑀭𑀸;

𑀧𑀼𑀫𑁂 𑀦𑁆𑀳𑀸𑀭𑀼 𑀘𑀺𑀢𑁆𑀣𑀻 𑀲𑀺𑀭𑀸, 𑀥𑀫𑀦𑀻 𑀣 𑀭𑀲𑀕𑁆𑀕𑀲𑀸.

𑀭𑀲𑀳𑀭𑀡𑁆𑀬’𑀣𑁄 𑀫𑀁𑀲, 𑀫𑀸𑀫𑀺𑀲𑀁 𑀧𑀺𑀲𑀺𑀢𑀁 𑀪𑀯𑁂;

𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁 𑀢𑀼 𑀯𑀮𑁆𑀮𑀽𑀭, 𑀫𑀼𑀢𑁆𑀢𑀢𑁆𑀢𑀁 𑀅𑀣 𑀮𑁄𑀳𑀺𑀢𑀁.

𑀭𑀼𑀥𑀺𑀭𑀁 𑀲𑁄𑀡𑀺𑀢𑀁 𑀭𑀢𑁆𑀢𑀁, 𑀮𑀸𑀮𑀸 𑀔𑁂𑀴𑁄 𑀏𑀮𑀸 𑀪𑀯𑁂;

𑀧𑀼𑀭𑀺𑀲𑁂 𑀫𑀸𑀬𑀼 𑀧𑀺𑀢𑁆𑀢𑀜𑁆𑀘, 𑀲𑁂𑀫𑁆𑀳𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀲𑀺𑀮𑁂𑀲𑀼𑀫𑁄.

𑀯𑀲𑀸 𑀯𑀺𑀮𑀻𑀦𑀲𑁆𑀦𑁂𑀳𑁄 𑀣, 𑀫𑁂𑀤𑁄 𑀘𑁂𑀯 𑀯𑀧𑀸 𑀪𑀯𑁂;

𑀆𑀓𑀧𑁆𑀧𑁄 𑀯𑁂𑀲𑁄 𑀦𑁂𑀧𑀘𑁆𑀙𑀁, 𑀫𑀡𑁆𑀟𑀦𑀁 𑀢𑀼 𑀧𑀲𑀸𑀥𑀦𑀁.

𑀯𑀺𑀪𑀽𑀲𑀦𑀁 𑀘𑀸𑀪𑀭𑀡𑀁, 𑀅𑀮𑀗𑁆𑀓𑀸𑀭𑁄 𑀧𑀺𑀮𑀦𑁆𑀥𑀦𑀁;

𑀓𑀺𑀭𑀻𑀝 𑀫𑀓𑀼𑀝𑀸’𑀦𑀺𑀢𑁆𑀣𑀻, 𑀘𑀽𑀴𑀸𑀫𑀡𑀺 𑀲𑀺𑀭𑁄𑀫𑀡𑀺.

𑀲𑀺𑀭𑁄𑀯𑁂𑀞𑀦 ¶ 𑀫𑀼𑀡𑁆𑀳𑀻𑀲𑀁, 𑀓𑀼𑀡𑁆𑀟𑀮𑀁 𑀓𑀡𑁆𑀡𑀯𑁂𑀞𑀦𑀁;

𑀓𑀡𑁆𑀡𑀺𑀓𑀸 𑀓𑀡𑁆𑀡𑀧𑀽𑀭𑁄 𑀘, 𑀲𑀺𑀬𑀸 𑀓𑀡𑁆𑀡𑀯𑀺𑀪𑀽𑀲𑀦𑀁.

𑀓𑀡𑁆𑀞𑀪𑀽𑀲𑀸 𑀢𑀼 𑀕𑀻𑀯𑁂𑀬𑁆𑀬𑀁, 𑀳𑀸𑀭𑁄 𑀫𑀼𑀢𑁆𑀢𑀸𑀯𑀮𑀺’𑀢𑁆𑀣𑀺𑀬𑀁;

𑀦𑀺𑀬𑀼𑀭𑁄 𑀯𑀮𑀬𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀓𑀝𑀓𑀁 𑀧𑀭𑀺𑀳𑀸𑀭𑀓𑀁.

𑀓𑀗𑁆𑀓𑀡𑀁 𑀓𑀭𑀪𑀽𑀲𑀸 𑀣, 𑀓𑀺𑀗𑁆𑀓𑀺𑀡𑀻 [𑀓𑀺𑀁𑀓𑀡𑀻 𑀓𑀺𑀁 𑀓𑀡𑀺𑀓𑀸 (𑀓.)] 𑀔𑀼𑀤𑁆𑀤𑀖𑀡𑁆𑀝𑀺𑀓𑀸;

𑀅𑀗𑁆𑀕𑀼𑀮𑀻𑀬𑀓 𑀫𑀗𑁆𑀕𑀼𑀮𑁆𑀬𑀸, 𑀪𑀭𑀡𑀁, 𑀲𑀸𑀓𑁆𑀔𑀭𑀁 𑀢𑀼 𑀢𑀁.

𑀫𑀼𑀤𑁆𑀤𑀺𑀓𑀸’𑀗𑁆𑀕𑀼𑀮𑀺𑀫𑀼𑀤𑁆𑀤𑀸 𑀣, 𑀭𑀲𑀦𑀸 𑀫𑁂𑀔𑀮𑀸 𑀪𑀯𑁂;

𑀓𑁂𑀬𑀽𑀭 𑀫𑀗𑁆𑀕𑀤𑀜𑁆𑀘𑁂𑀯, 𑀩𑀸𑀳𑀼𑀫𑀽𑀮𑀯𑀺𑀪𑀽𑀲𑀦𑀁.

𑀧𑀸𑀤𑀗𑁆𑀕𑀤𑀁 𑀢𑀼 𑀫𑀜𑁆𑀚𑀻𑀭𑁄, 𑀧𑀸𑀤𑀓𑀝𑀓 𑀦𑀽𑀧𑀼𑀭𑀸;

𑀅𑀮𑀗𑁆𑀓𑀸𑀭𑀧𑁆𑀧𑀪𑁂𑀤𑀸 𑀢𑀼, 𑀫𑀼𑀔𑀨𑀼𑀮𑁆𑀮𑀁 𑀢𑀣𑁄’𑀡𑁆𑀡𑀢𑀁;

𑀉𑀕𑁆𑀕𑀢𑁆𑀣𑀦𑀁 𑀕𑀺𑀗𑁆𑀕𑀫𑀓, 𑀫𑀺𑀘𑁆𑀘𑁂𑀯𑀫𑀸𑀤𑀬𑁄 𑀲𑀺𑀬𑀼𑀁.

𑀘𑁂𑀮 𑀫𑀘𑁆𑀙𑀸𑀤𑀦𑀁 𑀯𑀢𑁆𑀣𑀁, 𑀯𑀸𑀲𑁄 𑀯𑀲𑀦 𑀫𑀁𑀲𑀼𑀓𑀁;

𑀅𑀫𑁆𑀩𑀭𑀜𑁆𑀘 𑀧𑀝𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀤𑀼𑀲𑁆𑀲𑀁 𑀘𑁄𑀮𑁄 𑀘 𑀲𑀸𑀝𑀓𑁄.

𑀔𑁄𑀫𑀁 𑀤𑀼𑀓𑀽𑀮𑀁 𑀓𑁄𑀲𑁂𑀬𑁆𑀬𑀁, 𑀧𑀢𑁆𑀢𑀼𑀡𑁆𑀡𑀁 𑀓𑀫𑁆𑀩𑀮𑁄 𑀘 𑀯𑀸;

𑀲𑀸𑀡𑀁 𑀓𑁄𑀝𑀫𑁆𑀩𑀼𑀭𑀁 𑀪𑀗𑁆𑀕, 𑀦𑁆𑀢𑁆𑀬𑀸𑀤𑀺 𑀯𑀢𑁆𑀣𑀦𑁆𑀢𑀭𑀁 𑀫𑀢𑀁.

𑀦𑀺𑀯𑀸𑀲𑀦 𑀦𑁆𑀢𑀭𑀻𑀬𑀸𑀦𑁆𑀬, 𑀦𑁆𑀢𑀭𑀫𑀦𑁆𑀢𑀭𑀯𑀸𑀲𑀓𑁄;

𑀧𑀸𑀯𑀸𑀭𑁄 𑀢𑀼’𑀢𑁆𑀢𑀭𑀸𑀲𑀗𑁆𑀕𑁄, 𑀉𑀧𑀲𑀁𑀩𑁆𑀬𑀸𑀦 𑀫𑀼𑀢𑁆𑀢𑀭𑀁.

𑀉𑀢𑁆𑀢𑀭𑀻𑀬 𑀫𑀣𑁄 𑀯𑀢𑁆𑀣, 𑀫𑀳𑀢𑀦𑁆𑀢𑀺 𑀫𑀢𑀁 𑀦𑀯𑀁;

𑀦𑀦𑁆𑀢𑀓𑀁 𑀓𑀧𑁆𑀧𑀝𑁄 𑀚𑀺𑀡𑁆𑀡, 𑀯𑀲𑀦𑀁 𑀢𑀼 𑀧𑀝𑀘𑁆𑀘𑀭𑀁.

𑀓𑀜𑁆𑀘𑀼𑀓𑁄 𑀯𑀸𑀭𑀯𑀸𑀡𑀁 𑀯𑀸, 𑀣 𑀯𑀢𑁆𑀣𑀸𑀯𑀬𑀯𑁂 𑀤𑀲𑀸;

𑀦𑀸𑀮𑀺𑀧𑀝𑁆𑀝𑁄𑀢𑀺 𑀓𑀣𑀺𑀢𑁄, 𑀉𑀢𑁆𑀢𑀫𑀗𑁆𑀕𑀫𑁆𑀳𑀺 𑀓𑀜𑁆𑀘𑀼𑀓𑁄.

𑀅𑀭𑀳𑀤𑁆𑀥𑀚𑁄 𑀘 𑀓𑀸𑀲𑀸𑀬, 𑀓𑀸𑀲𑀸𑀯𑀸𑀦𑀺 𑀘 𑀘𑀻𑀯𑀭𑀁;

𑀫𑀡𑁆𑀟𑀮𑀁 𑀢𑀼 𑀢𑀤𑀗𑁆𑀕𑀸𑀦𑀺, 𑀯𑀺𑀯𑀝𑁆𑀝 𑀓𑀼𑀲𑀺𑀆𑀤𑀬𑁄.

𑀨𑀮,𑀢𑁆𑀢𑀘, 𑀓𑀺𑀫𑀺, 𑀭𑁄𑀫𑀸, 𑀦𑁆𑀬𑁂𑀢𑀸 𑀯𑀢𑁆𑀣𑀲𑁆𑀲 𑀬𑁄𑀦𑀺𑀬𑁄;

𑀨𑀸𑀮𑀁 𑀓𑀧𑁆𑀧𑀸𑀲𑀺𑀓𑀁 𑀢𑀻𑀲𑀼, 𑀔𑁄𑀫𑀸𑀤𑀻 𑀢𑀼 𑀢𑀘𑀩𑁆𑀪𑀯𑀸.

𑀓𑁄𑀲𑁂𑀬𑁆𑀬𑀁 ¶ 𑀓𑀺𑀫𑀺𑀚𑀁, 𑀭𑁄𑀫, 𑀫𑀬𑀁 𑀢𑀼 𑀓𑀫𑁆𑀩𑀮𑀁 𑀪𑀯𑁂;

𑀲𑀫𑀸𑀦𑀢𑁆𑀣𑀸 𑀚𑀯𑀦𑀺𑀓𑀸, 𑀲𑀸 𑀢𑀺𑀭𑁄𑀓𑀭𑀡𑀻 𑀧𑁆𑀬𑀣.

𑀧𑀼𑀦𑁆𑀦𑀧𑀼𑀁𑀲𑀓 𑀫𑀼𑀮𑁆𑀮𑁄𑀘𑀁, 𑀯𑀺𑀢𑀸𑀦𑀁 𑀤𑁆𑀯𑀬 𑀫𑀻𑀭𑀺𑀢𑀁;

𑀦𑀳𑀸𑀦𑀜𑁆𑀘 𑀲𑀺𑀦𑀸𑀦𑁂 𑀣𑁄, 𑀩𑁆𑀩𑀝𑁆𑀝𑀦𑀼’𑀫𑁆𑀫𑀚𑁆𑀚𑀦𑀁 𑀲𑀫𑀁.

𑀯𑀺𑀲𑁂𑀲𑀓𑁄 𑀢𑀼 𑀢𑀺𑀮𑀓𑁄, 𑀢𑁆𑀬𑀽𑀪𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀘 𑀘𑀺𑀢𑁆𑀢𑀓𑀁;

𑀘𑀦𑁆𑀤𑀦𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀕𑀦𑁆𑀥, 𑀲𑀸𑀭𑁄 𑀫𑀮𑀬𑀚𑁄 𑀧𑁆𑀬𑀣.

𑀕𑁄𑀲𑀻𑀲𑀁 𑀢𑁂𑀮𑀧𑀡𑁆𑀡𑀺𑀓𑀁, 𑀧𑀼𑀫𑁂 𑀯𑀸 𑀳𑀭𑀺𑀘𑀦𑁆𑀤𑀦𑀁;

𑀢𑀺𑀮𑀧𑀡𑁆𑀡𑀻 𑀢𑀼 𑀧𑀢𑁆𑀢𑀗𑁆𑀕, 𑀭𑀜𑁆𑀚𑀦𑀁 𑀭𑀢𑁆𑀢𑀘𑀦𑁆𑀤𑀦𑀁.

𑀓𑀸𑀴𑀸𑀦𑀼𑀲𑀸𑀭𑀻 𑀓𑀸𑀴𑀺𑀬𑀁, 𑀮𑁄𑀳𑀁 𑀢𑁆𑀯𑀸’𑀕𑀭𑀼 𑀘𑀸’𑀕𑀴𑀼;

𑀓𑀸𑀴𑀸𑀕𑀭𑀼𑀢𑀼 𑀓𑀸𑀴𑁂’𑀲𑁆𑀫𑀺𑀁, 𑀢𑀼𑀭𑀼𑀓𑁆𑀔𑁄𑀢𑀼 𑀘 𑀧𑀺𑀡𑁆𑀟𑀓𑁄.

𑀓𑀢𑁆𑀣𑀽𑀭𑀺𑀓𑀸 𑀫𑀺𑀕𑀫𑀤𑁄, 𑀓𑀼𑀝𑁆𑀞𑀁 𑀢𑀼 𑀅𑀚𑀧𑀸𑀮𑀓𑀁;

𑀮𑀯𑀗𑁆𑀕𑀁 𑀤𑁂𑀯𑀓𑀼𑀲𑀼𑀫𑀁, 𑀓𑀲𑁆𑀫𑀻𑀭𑀚𑀁 𑀢𑀼 𑀓𑀼𑀗𑁆𑀓𑀼𑀫𑀁.

𑀬𑀓𑁆𑀔𑀥𑀽𑀧𑁄 𑀲𑀚𑁆𑀚𑀼𑀮𑀲𑁄, 𑀢𑀓𑁆𑀓𑁄𑀮𑀁 𑀢𑀼 𑀘 𑀓𑁄𑀮𑀓𑀁;

𑀓𑁄𑀲𑀨𑀮 𑀫𑀣𑁄 𑀚𑀸𑀢𑀺, 𑀓𑁄𑀲𑀁 𑀚𑀸𑀢𑀺𑀨𑀮𑀁 𑀪𑀯𑁂.

𑀖𑀦𑀲𑀸𑀭𑁄 𑀲𑀺𑀢𑀩𑁆𑀪𑁄 𑀘, 𑀓𑀧𑁆𑀧𑀽𑀭𑀁 𑀧𑀼𑀦𑁆𑀦𑀧𑀼𑀁𑀲𑀓𑁂;

𑀅𑀮𑀢𑁆𑀢𑀓𑁄 𑀬𑀸𑀯𑀓𑁄 𑀘, 𑀮𑀸𑀔𑀸 𑀚𑀢𑀼 𑀦𑀧𑀼𑀁𑀲𑀓𑁂.

𑀲𑀺𑀭𑀺𑀯𑀸𑀲𑁄 𑀢𑀼 𑀲𑀭𑀮, 𑀤𑁆𑀤𑀯𑁄’ 𑀜𑁆𑀚𑀦𑀁 𑀢𑀼 𑀓𑀚𑁆𑀚𑀮𑀁;

𑀯𑀸𑀲𑀘𑀼𑀡𑁆𑀡𑀁 𑀯𑀸𑀲𑀬𑁄𑀕𑁄, 𑀯𑀡𑁆𑀡𑀓𑀁 𑀢𑀼 𑀯𑀺𑀮𑁂𑀧𑀦𑀁.

𑀕𑀦𑁆𑀥𑀫𑀸𑀮𑁆𑀬𑀸𑀤𑀺𑀲𑀗𑁆𑀔𑀸𑀭𑁄, 𑀬𑁄 𑀢𑀁 𑀯𑀸𑀲𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀫𑀸𑀮𑀸 𑀫𑀸𑀮𑁆𑀬𑀁 𑀧𑀼𑀧𑁆𑀨𑀤𑀸𑀫𑁂 [𑀧𑀼𑀧𑁆𑀨𑀁 𑀤𑀸𑀫𑀁 (𑀓.)], 𑀪𑀸𑀯𑀺𑀢𑀁 𑀯𑀸𑀲𑀺𑀢𑀁 𑀢𑀺𑀲𑀼.

𑀉𑀢𑁆𑀢𑀁𑀲𑁄 𑀲𑁂𑀔𑀭𑀸’ 𑀯𑁂𑀴𑀸, 𑀫𑀼𑀤𑁆𑀥𑀫𑀸𑀮𑁆𑀬𑁂 𑀯𑀝𑀁𑀲𑀓𑁄;

𑀲𑁂𑀬𑁆𑀬𑀸 𑀘 𑀲𑀬𑀦𑀁 𑀲𑁂𑀦𑀁, 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑁄 𑀢𑀼 𑀘 𑀫𑀜𑁆𑀘𑀓𑁄.

𑀫𑀜𑁆𑀘𑀸𑀥𑀸𑀭𑁄 𑀧𑀝𑀺𑀧𑀸𑀤𑁄, 𑀫𑀜𑁆𑀘𑀗𑁆𑀕𑁂 𑀢𑁆𑀯𑀝𑀦𑀻 𑀢𑁆𑀣𑀺𑀬𑀁,

𑀓𑀼𑀴𑀻𑀭𑀧𑀸𑀤𑁄 𑀆𑀳𑀘𑁆𑀘, 𑀧𑀸𑀤𑁄 𑀘𑁂𑀯 𑀫𑀲𑀸𑀭𑀓𑁄;

𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀩𑀼𑀦𑁆𑀤𑀺𑀓𑀸𑀩𑀤𑁆𑀥𑁄, 𑀢𑀺𑀫𑁂 𑀫𑀜𑁆𑀘𑀦𑁆𑀢𑀭𑀸 𑀲𑀺𑀬𑀼𑀁.

𑀩𑀺𑀩𑁆𑀩𑁄𑀳𑀦𑀁 𑀘𑁄’ 𑀧𑀥𑀸𑀦𑀁, 𑀧𑀻𑀞𑀺𑀓𑀸 𑀧𑀻𑀞 𑀫𑀸𑀲𑀦𑀁;

𑀓𑁄𑀘𑁆𑀙𑀁 𑀢𑀼 𑀪𑀤𑁆𑀤𑀧𑀻𑀞𑁂 𑀣𑀸, 𑀲𑀦𑁆𑀤𑀻 𑀧𑀻𑀞𑀦𑁆𑀢𑀭𑁂 𑀫𑀢𑀸.

𑀉𑀡𑁆𑀡𑀸𑀫𑀬𑀁 𑀢𑁆𑀯𑀢𑁆𑀣𑀭𑀡𑀁, 𑀘𑀺𑀢𑁆𑀢𑀓𑀁 𑀯𑀸𑀦𑀘𑀺𑀢𑁆𑀢𑀓𑀁.

𑀖𑀦𑀧𑀼𑀧𑁆𑀨𑀁 𑀧𑀝𑀮𑀺𑀓𑀸, 𑀲𑁂𑀢𑀁 𑀢𑀼 𑀧𑀝𑀺𑀓𑀸 𑀧𑁆𑀬𑀣;

𑀤𑁆𑀯𑀺𑀤𑀲𑁂𑀓𑀤𑀲𑀸𑀦𑁆𑀬𑀼’ 𑀤𑁆𑀤,𑀮𑁄𑀫𑀺 𑀏𑀓𑀦𑁆𑀢𑀮𑁄𑀫𑀺𑀦𑁄.

𑀢𑀤𑁂𑀯 𑀲𑁄𑀴𑀲𑀺𑀢𑁆𑀣𑀻𑀦𑀁, 𑀦𑀘𑁆𑀘𑀬𑁄𑀕𑁆𑀕𑀜𑁆𑀳𑀺 𑀓𑀼𑀢𑁆𑀢𑀓𑀁;

𑀲𑀻𑀳𑀩𑁆𑀬𑀕𑁆𑀖𑀸𑀤𑀺𑀭𑀽𑀧𑁂𑀳𑀺, 𑀘𑀺𑀢𑁆𑀢𑀁 𑀯𑀺𑀓𑀢𑀺𑀓𑀸 𑀪𑀯𑁂.

𑀓𑀝𑁆𑀝𑀺𑀲𑁆𑀲𑀁 𑀓𑁄𑀲𑁂𑀬𑁆𑀬𑀁 𑀭𑀢𑀦, 𑀧𑀭𑀺𑀲𑀺𑀩𑁆𑀩𑀺𑀢 𑀫𑀢𑁆𑀣𑀭𑀡𑀁 𑀓𑀫𑀸;

𑀓𑁄𑀲𑀺𑀬𑀓𑀝𑁆𑀝𑀺𑀲𑁆𑀲𑀫𑀬𑀁, 𑀓𑁄𑀲𑀺𑀬𑀲𑀼𑀢𑁆𑀢𑁂𑀦 𑀧𑀓𑀢𑀜𑁆𑀘.

𑀤𑀻𑀧𑁄 𑀧𑀤𑀻𑀧𑁄 𑀧𑀚𑁆𑀚𑁄𑀢𑁄, 𑀧𑀼𑀫𑁂 𑀢𑁆𑀯𑀸𑀤𑀸𑀲 𑀤𑀧𑁆𑀧𑀡𑀸;

𑀕𑁂𑀡𑁆𑀟𑀼𑀓𑁄 𑀓𑀡𑁆𑀟𑀼𑀓𑁄 𑀢𑀸𑀮, 𑀯𑀡𑁆𑀝𑀁 𑀢𑀼 𑀩𑀻𑀚𑀦𑀻𑀢𑁆𑀣𑀺𑀬𑀁.

𑀘𑀗𑁆𑀓𑁄𑀝𑀓𑁄 𑀓𑀭𑀡𑁆𑀟𑁄 𑀘, 𑀲𑀫𑀼𑀕𑁆𑀕𑁄 𑀲𑀫𑁆𑀧𑀼𑀝𑁄 𑀪𑀯𑁂;

𑀕𑀸𑀫𑀥𑀫𑁆𑀫𑁄 𑀅𑀲𑀤𑁆𑀥𑀫𑁆𑀫𑁄, 𑀩𑁆𑀬𑀯𑀸𑀬𑁄 𑀫𑁂𑀣𑀼𑀦𑀁 𑀭𑀢𑀺.

𑀯𑀺𑀯𑀸𑀳𑁄 𑀧𑀬𑀫𑀸 𑀧𑀸𑀡𑀺, 𑀕𑁆𑀕𑀳𑁄 𑀧𑀭𑀺𑀡𑀬𑁄 𑀧𑁆𑀬𑀣;

𑀢𑀺𑀯𑀕𑁆𑀕𑁄 𑀥𑀫𑁆𑀫, 𑀓𑀸𑀫,𑀢𑁆𑀣𑀸, 𑀘𑀢𑀼𑀯𑀕𑁆𑀕𑁄 𑀲𑀫𑁄𑀓𑁆𑀔𑀓𑀸.

𑀔𑀼𑀚𑁆𑀚𑁄 𑀘 𑀕𑀡𑁆𑀟𑀼𑀮𑁄 𑀭𑀲𑁆𑀲, 𑀯𑀸𑀫𑀦𑀸 𑀢𑀼 𑀮𑀓𑀼𑀡𑁆𑀟𑀓𑁄;

𑀧𑀗𑁆𑀕𑀼𑀮𑁄 𑀧𑀻𑀞𑀲𑀧𑁆𑀧𑀻 𑀘, 𑀧𑀗𑁆𑀕𑀼 𑀙𑀺𑀦𑁆𑀦𑀺𑀭𑀺𑀬𑀸𑀧𑀣𑁄.

𑀧𑀓𑁆𑀔𑁄 𑀔𑀜𑁆𑀚𑁄 𑀢𑀼 𑀔𑁄𑀡𑁆𑀟𑁄 𑀣,

𑀓𑀼𑀡𑀻 𑀳𑀢𑁆𑀣𑀸𑀤𑀺𑀯𑀗𑁆𑀓𑁄 𑀘, 𑀯𑀮𑀺𑀭𑁄 𑀢𑀼 𑀘 𑀓𑁂𑀓𑀭𑁄.

𑀫𑀼𑀡𑁆𑀟𑁄 𑀢𑀼 𑀪𑀡𑁆𑀟𑀼 𑀫𑀼𑀡𑁆𑀟𑀺𑀓𑁄;

𑀲𑀼𑀜𑁆𑀜𑁄 𑀅𑀦𑁆𑀥𑁄 𑀤𑁆𑀯𑀬𑁂𑀦 𑀣.

𑀩𑀥𑀺𑀭𑁄 𑀲𑀼𑀢𑀺𑀳𑀻𑀦𑁄 𑀣, 𑀕𑀺𑀮𑀸𑀦𑁄 𑀩𑁆𑀬𑀸𑀥𑀺𑀢𑀸’𑀢𑀼𑀭𑀸;

𑀉𑀫𑁆𑀫𑀸𑀤𑀯𑀢𑀺 𑀉𑀫𑁆𑀫𑀢𑁆𑀢𑁄, 𑀔𑀼𑀚𑁆𑀚𑀸𑀤𑀻 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀸.

𑀆𑀢𑀗𑁆𑀓𑁄 𑀆𑀫𑀬𑁄 𑀩𑁆𑀬𑀸𑀥𑀺, 𑀕𑀤𑁄 𑀭𑁄𑀕𑁄 𑀭𑀼𑀚𑀸𑀧𑀺 𑀘;

𑀧𑀻𑀦𑀲𑁄 [𑀧𑀻𑀦𑀸𑀲𑁄𑀢𑀺𑀧𑀺 𑀧𑀸𑀞𑁄] ¶ 𑀦𑀸𑀲𑀺𑀓𑀸𑀭𑁄𑀕𑁄,

𑀖𑀸𑀦𑁂 𑀲𑀺𑀗𑁆𑀖𑀸𑀦𑀺𑀓𑀸 𑀲𑁆𑀲𑀯𑁄;

𑀜𑁂𑀬𑁆𑀬𑀁 𑀢𑁆𑀯’𑀭𑀼 𑀯𑀡𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀨𑁄𑀝𑁄 𑀢𑀼 𑀧𑀺𑀴𑀓𑀸 𑀪𑀯𑁂.

𑀧𑀼𑀩𑁆𑀩𑁄 𑀧𑀽𑀬𑁄 𑀣 𑀭𑀢𑁆𑀢𑀸𑀢𑀺, 𑀲𑀸𑀭𑁄 𑀧𑀓𑁆𑀔𑀦𑁆𑀤𑀺𑀓𑀸 𑀧𑁆𑀬𑀣;

𑀅𑀧𑀫𑀸𑀭𑁄 𑀅𑀧𑀲𑁆𑀫𑀸𑀭𑁄, 𑀧𑀸𑀤𑀨𑁄𑀝𑁄 𑀯𑀺𑀧𑀸𑀤𑀺𑀓𑀸.

𑀯𑀼𑀟𑁆𑀠𑀺𑀭𑁄𑀕𑁄 𑀢𑀼 𑀯𑀸𑀢𑀡𑁆𑀟𑀁, 𑀲𑀻𑀧𑀤𑀁 𑀪𑀸𑀭𑀧𑀸𑀤𑀢𑀸;

𑀓𑀡𑁆𑀟𑀽 𑀓𑀡𑁆𑀟𑀽𑀢𑀺 𑀓𑀡𑁆𑀟𑀽𑀬𑀸, 𑀔𑀚𑁆𑀚𑀼 𑀓𑀡𑁆𑀟𑀽𑀯𑀦𑀁 𑀧𑁆𑀬𑀣.

𑀧𑀸𑀫𑀁 𑀯𑀺𑀢𑀘𑁆𑀙𑀺𑀓𑀸 𑀓𑀘𑁆𑀙𑀼, 𑀲𑁄𑀣𑁄 𑀢𑀼 𑀲𑀬𑀣𑀽’𑀤𑀺𑀢𑁄;

𑀤𑀼𑀦𑁆𑀦𑀸𑀫𑀓𑀜𑁆𑀘 𑀅𑀭𑀺𑀲𑀁, 𑀙𑀤𑁆𑀤𑀺𑀓𑀸 𑀯𑀫𑀣𑀽’𑀤𑀺𑀢𑁄.

𑀤𑀯𑀣𑀼 𑀧𑀭𑀺𑀢𑀸𑀧𑁄 𑀣, 𑀢𑀺𑀮𑀓𑁄 𑀢𑀺𑀮𑀓𑀸𑀴𑀓𑁄;

𑀯𑀺𑀲𑀽𑀘𑀺𑀓𑀸 𑀇𑀢𑀺 𑀫𑀳𑀸, 𑀯𑀺𑀭𑁂𑀓𑁄 𑀣 𑀪𑀕𑀦𑁆𑀤𑀮𑁄 [𑀪𑀕𑀦𑁆𑀤𑀭𑁄 (𑀓.)].

𑀫𑁂𑀳𑁄 𑀚𑀭𑁄 𑀓𑀸𑀲 𑀲𑀸𑀲𑀸, 𑀓𑀼𑀝𑁆𑀞𑀁 𑀲𑀽𑀮𑀸𑀫𑀬𑀦𑁆𑀢𑀭𑀸;

𑀯𑀼𑀢𑁆𑀢𑁄 𑀯𑁂𑀚𑁆𑀚𑁄 𑀪𑀺𑀲𑀓𑁆𑀓𑁄 𑀘, 𑀭𑁄𑀕𑀳𑀸𑀭𑀻 𑀢𑀺𑀓𑀺𑀘𑁆𑀙𑀓𑁄.

𑀲𑀮𑁆𑀮𑀯𑁂𑀚𑁆𑀚𑁄 𑀲𑀮𑁆𑀮𑀓𑀢𑁆𑀢𑁄, 𑀢𑀺𑀓𑀺𑀘𑁆𑀙𑀸 𑀢𑀼 𑀧𑀢𑀺𑀓𑁆𑀭𑀺𑀬𑀸;

𑀪𑁂𑀲𑀚𑁆𑀚 𑀫𑀕𑀤𑁄 𑀘𑁂𑀯, 𑀪𑁂𑀲𑀚𑀁 𑀫𑁄’𑀲𑀥𑀁 𑀧𑁆𑀬𑀣.

𑀓𑀼𑀮𑀁 𑀯𑀁𑀲𑁄 𑀘 𑀲𑀦𑁆𑀢𑀸𑀦𑀸, 𑀪𑀺𑀚𑀦𑀸 𑀕𑁄𑀢𑁆𑀢 𑀫𑀦𑁆𑀯𑀬𑁄;

𑀣𑀺𑀬𑀁 𑀲𑀦𑁆𑀢𑀢𑁆𑀬 𑀣𑁄 𑀯𑀡𑁆𑀡𑀸, 𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀤𑀬𑁄.

𑀭𑀸𑀚𑀸 𑀪𑀽𑀧𑀢𑀺 𑀪𑀽𑀧𑀸𑀮𑁄, 𑀧𑀢𑁆𑀣𑀺𑀯𑁄 𑀘 𑀦𑀭𑀸𑀥𑀺𑀧𑁄.

𑀪𑀽𑀦𑀸𑀣𑁄 ¶ 𑀚𑀕𑀢𑀺𑀧𑀸𑀮𑁄, 𑀤𑀺𑀲𑀫𑁆𑀧𑀢𑀺 𑀚𑀦𑀸𑀥𑀺𑀧𑁄;

𑀭𑀝𑁆𑀞𑀸𑀥𑀺𑀧𑁄 𑀦𑀭𑀤𑁂𑀯𑁄, 𑀪𑀽𑀫𑀺𑀧𑁄 𑀪𑀽𑀪𑀼𑀚𑁄 𑀧𑁆𑀬𑀣.

𑀭𑀸𑀚𑀜𑁆𑀜𑁄 𑀔𑀢𑁆𑀢𑀺𑀬𑁄 𑀔𑀢𑁆𑀢𑀁, 𑀫𑀼𑀤𑁆𑀥𑀸𑀪𑀺𑀲𑀺𑀢𑁆𑀢 𑀩𑀸𑀳𑀼𑀚𑀸;

𑀲𑀩𑁆𑀩𑀪𑀼𑀫𑁆𑀫𑁄 𑀘𑀓𑁆𑀓𑀯𑀢𑁆𑀢𑀻, 𑀪𑀽𑀧𑁄𑀜𑁆𑀜𑁄 𑀫𑀡𑁆𑀟𑀮𑀺𑀲𑁆𑀲𑀭𑁄.

𑀧𑀼𑀫𑁂 𑀮𑀺𑀘𑁆𑀙𑀯𑀺 𑀯𑀚𑁆𑀚𑀻 𑀘, 𑀲𑀓𑁆𑀬𑁄 𑀢𑀼 𑀲𑀸𑀓𑀺𑀬𑁄 𑀣 𑀘;

𑀪𑀤𑁆𑀤𑀓𑀘𑁆𑀘𑀸𑀦𑀸 [𑀪𑀤𑁆𑀤𑀸 𑀓𑀘𑁆𑀘𑀸𑀦𑀸 (𑀝𑀻.)] 𑀭𑀸𑀳𑀼𑀮, 𑀫𑀸𑀢𑀸 𑀩𑀺𑀫𑁆𑀩𑀸 𑀬𑀲𑁄𑀥𑀭𑀸.

𑀓𑁄𑀝𑀻𑀦𑀁 𑀳𑁂𑀝𑁆𑀞𑀺𑀫𑀦𑁆𑀢𑁂𑀦, 𑀲𑀢𑀁 𑀬𑁂𑀲𑀁 𑀦𑀺𑀥𑀸𑀦𑀕𑀁;

𑀓𑀳𑀸𑀧𑀡𑀸𑀦𑀁 𑀤𑀺𑀯𑀲, 𑀯𑀴𑀜𑁆𑀚𑁄 𑀯𑀻𑀲𑀢𑀫𑁆𑀩𑀡𑀁.

𑀢𑁂 𑀔𑀢𑁆𑀢𑀺𑀬𑀫𑀳𑀸𑀲𑀸𑀮𑀸, 𑀲𑀻𑀢𑀺 𑀓𑁄𑀝𑀺𑀥𑀦𑀸𑀦𑀺 𑀢𑀼;

𑀦𑀺𑀥𑀸𑀦𑀕𑀸𑀦𑀺 𑀤𑀺𑀯𑀲, 𑀯𑀴𑀜𑁆𑀚𑁄 𑀘 𑀤𑀲𑀫𑁆𑀩𑀡𑀁.

𑀬𑁂𑀲𑀁 𑀤𑁆𑀯𑀺𑀚𑀫𑀳𑀸𑀲𑀸𑀮𑀸, 𑀢𑀤𑀼𑀧𑀟𑁆𑀠𑁂 𑀦𑀺𑀥𑀸𑀦𑀕𑁂;

𑀯𑀴𑀜𑁆𑀚𑁂 𑀘 𑀕𑀳𑀧𑀢𑀺, 𑀫𑀳𑀸𑀲𑀸𑀮𑀸 𑀥𑀦𑁂 𑀲𑀺𑀬𑀼𑀁.

𑀫𑀳𑀸𑀫𑀢𑁆𑀢𑁄 𑀧𑀥𑀸𑀦𑀜𑁆𑀘, 𑀫𑀢𑀺𑀲𑀚𑀻𑀯𑁄 𑀫𑀦𑁆𑀢𑀺𑀦𑀻;

𑀲𑀚𑀻𑀯𑁄 𑀲𑀘𑀺𑀯𑀸, 𑀫𑀘𑁆𑀘𑁄, 𑀲𑁂𑀦𑀸𑀦𑀻 𑀢𑀼 𑀘𑀫𑀽𑀧𑀢𑀺.

𑀦𑁆𑀬𑀸𑀲𑀸𑀤𑀻𑀦𑀁 𑀯𑀺𑀯𑀸𑀤𑀸𑀦𑀁, 𑀅𑀓𑁆𑀔𑀤𑀲𑁆𑀲𑁄 𑀧𑀤𑀝𑁆𑀞𑀭𑀺;

𑀤𑁄𑀯𑀸𑀭𑀺𑀓𑁄 𑀧𑀢𑀻𑀳𑀸𑀭𑁄, 𑀤𑁆𑀯𑀸𑀭𑀝𑁆𑀞𑁄 𑀤𑁆𑀯𑀸𑀭𑀧𑀸𑀮𑀓𑁄.

𑀅𑀦𑀻𑀓𑀝𑁆𑀞𑁄𑀢𑀺 𑀭𑀸𑀚𑀽𑀦𑀁, 𑀅𑀗𑁆𑀕𑀭𑀓𑁆𑀔𑀕𑀡𑁄 𑀫𑀢𑁄;

𑀓𑀜𑁆𑀘𑀼𑀓𑀻 𑀲𑁄𑀯𑀺𑀤𑀮𑁆𑀮𑁄 𑀘, 𑀅𑀦𑀼𑀚𑀻𑀯𑀻 𑀢𑀼 𑀲𑁂𑀯𑀓𑁄.

𑀲𑀤𑁂𑀲𑀸𑀦𑀦𑁆𑀢𑀭𑁄 𑀲𑀢𑁆𑀢𑀼, 𑀫𑀺𑀢𑁆𑀢𑁄𑀭𑀸𑀚𑀸 𑀢𑀢𑁄 𑀧𑀭𑀁.

𑀅𑀫𑀺𑀢𑁆𑀢𑁄 𑀭𑀺𑀧𑀼 𑀯𑁂𑀭𑀻 𑀘, 𑀲𑀧𑀢𑁆𑀢𑀸 𑀭𑀸𑀢𑀺 𑀲𑀢𑁆𑀯’𑀭𑀺; (𑀲𑀢𑁆𑀢𑀼+𑀅𑀭𑀺)

𑀧𑀘𑁆𑀘𑀢𑁆𑀣𑀺𑀓𑁄 𑀧𑀭𑀺𑀧𑀦𑁆𑀣𑀻, 𑀧𑀝𑀺𑀧𑀓𑁆𑀔𑀸 𑀳𑀺𑀢𑀸𑀧𑀭𑁄.

𑀧𑀘𑁆𑀘𑀸𑀫𑀺𑀢𑁆𑀢𑁄 𑀯𑀺𑀧𑀓𑁆𑀔𑁄 𑀘, 𑀧𑀘𑁆𑀘𑀦𑀻𑀓 𑀯𑀺𑀭𑁄𑀥𑀺𑀦𑁄;

𑀯𑀺𑀤𑁆𑀤𑁂𑀲𑀻 𑀘 𑀤𑀺𑀲𑁄 𑀤𑀺𑀝𑁆𑀞𑁄,𑀣𑀸 𑀦𑀼𑀭𑁄𑀥𑁄 𑀦𑀼𑀯𑀢𑁆𑀢𑀦𑀁.

𑀫𑀺𑀢𑁆𑀢𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀯𑀬𑀲𑁆𑀲𑁄 𑀘, 𑀲𑀳𑀸𑀬𑁄 [𑀲𑀼𑀳𑀚𑁆𑀚𑁄 (𑀝𑀻.)] 𑀲𑀼𑀳𑀤𑁄 𑀲𑀔𑀸;

𑀲𑀫𑁆𑀪𑀢𑁆𑀢𑁄 𑀤𑀴𑁆𑀳𑀫𑀺𑀢𑁆𑀢𑁄 𑀣, 𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑁄 𑀤𑀺𑀝𑁆𑀞𑀫𑀢𑁆𑀢𑀓𑁄.

𑀘𑀭𑁄 𑀘 𑀕𑀼𑀴𑁆𑀳𑀧𑀼𑀭𑀺𑀲𑁄, 𑀧𑀣𑀸𑀯𑀻 𑀧𑀣𑀺𑀓𑁄’𑀤𑁆𑀥𑀕𑀽;

𑀤𑀽𑀢𑁄 𑀢𑀼 𑀲𑀦𑁆𑀤𑁂𑀲𑀳𑀭𑁄, 𑀕𑀡𑀓𑁄 𑀢𑀼 𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑀺𑀓𑁄.

𑀮𑁂𑀔𑀓𑁄 ¶ 𑀮𑀺𑀧𑀺𑀓𑀸𑀭𑁄 𑀘, 𑀯𑀡𑁆𑀡𑁄 𑀢𑀼 𑀅𑀓𑁆𑀔𑀭𑁄 𑀧𑁆𑀬𑀣;

𑀪𑁂𑀤𑁄 𑀤𑀡𑁆𑀟𑁄 𑀲𑀸𑀫 𑀤𑀸𑀦𑀸, 𑀦𑁆𑀬𑀼𑀧𑀸𑀬𑀸 𑀘𑀢𑀼𑀭𑁄 𑀇𑀫𑁂.

𑀉𑀧𑀚𑀸𑀧𑁄𑀢𑀼 𑀪𑁂𑀤𑁄 𑀘, 𑀤𑀡𑁆𑀟𑁄 𑀢𑀼 𑀲𑀸𑀳𑀲𑀁 𑀤𑀫𑁄;

𑀲𑀸𑀫𑁆𑀬’ 𑀫𑀘𑁆𑀘𑁄 𑀲𑀔𑀸 𑀓𑁄𑀲𑁄, 𑀤𑀼𑀕𑁆𑀕𑀜𑁆𑀘 𑀯𑀺𑀚𑀺𑀢𑀁 𑀩𑀮𑀁;

𑀭𑀚𑁆𑀚𑀗𑁆𑀕𑀸𑀦𑀻𑀢𑀺 𑀲𑀢𑁆𑀢𑁂𑀢𑁂, 𑀲𑀺𑀬𑀼𑀁 𑀧𑀓𑀢𑀺𑀬𑁄 𑀧𑀺𑀘.

𑀧𑀪𑀸𑀯𑀼’𑀲𑁆𑀲𑀸𑀳, 𑀫𑀦𑁆𑀢𑀸𑀦𑀁, 𑀯𑀲𑀸 𑀢𑀺𑀲𑁆𑀲𑁄 𑀳𑀺 𑀲𑀢𑁆𑀢𑀺𑀬𑁄;

𑀫𑀦𑁆𑀢𑁄 𑀘 𑀫𑀦𑁆𑀢𑀦𑀁 𑀲𑁄 𑀢𑀼, 𑀘𑀢𑀼𑀓𑁆𑀓𑀡𑁆𑀡𑁄 𑀤𑁆𑀯𑀺𑀕𑁄𑀘𑀭𑁄;

𑀢𑀺𑀕𑁄𑀘𑀭𑁄 𑀢𑀼 𑀙𑀓𑁆𑀓𑀡𑁆𑀡𑁄, 𑀭𑀳𑀲𑁆𑀲𑀁 𑀕𑀼𑀬𑁆𑀳 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀢𑀻𑀲𑀼 𑀯𑀺𑀯𑀺𑀢𑁆𑀢 𑀯𑀺𑀚𑀦, 𑀙𑀦𑁆𑀦𑀸, 𑀭𑀳𑁄 𑀭𑀳𑁄 𑀩𑁆𑀬𑀬𑀁;

𑀯𑀺𑀲𑁆𑀲𑀸𑀲𑁄 𑀢𑀼 𑀘 𑀯𑀺𑀲𑁆𑀲𑀫𑁆𑀪𑁄,

𑀬𑀼𑀢𑁆𑀢𑀁 𑀢𑁆𑀯𑁄’𑀧𑀸𑀬𑀺𑀓𑀁 𑀢𑀺𑀲𑀼.

𑀑𑀯𑀸𑀤𑁄 𑀘𑀸𑀦𑀼𑀲𑀺𑀝𑁆𑀞𑀺𑀢𑁆𑀣𑀻, 𑀧𑀼𑀫𑀯𑀚𑁆𑀚𑁂 𑀦𑀼𑀲𑀸𑀲𑀦𑀁;

𑀆𑀡𑀸 𑀘 𑀲𑀸𑀲𑀦𑀁 𑀜𑁂𑀬𑁆𑀬𑀁, 𑀉𑀤𑁆𑀤𑀸𑀦𑀁 𑀢𑀼 𑀘 𑀩𑀦𑁆𑀥𑀦𑀁.

𑀆𑀕𑀼 𑀯𑀼𑀢𑁆𑀢 [𑀫𑀦𑁆𑀢𑀼 (𑀓.)] 𑀫𑀧𑀭𑀸𑀥𑁄, 𑀓𑀭𑁄 𑀢𑀼 𑀩𑀮𑀺 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀧𑀼𑀡𑁆𑀡𑀧𑀢𑁆𑀢𑁄 𑀢𑀼𑀝𑁆𑀞𑀺𑀤𑀸𑀬𑁄, 𑀉𑀧𑀤𑀸 𑀢𑀼 𑀘 𑀧𑀸𑀪𑀢𑀁.

𑀢𑀣𑁄’𑀧𑀸𑀬𑀦 𑀫𑀼𑀓𑁆𑀓𑁄𑀘𑁄, 𑀧𑀡𑁆𑀡𑀸𑀓𑀸𑀭𑁄 𑀧𑀳𑁂𑀡𑀓𑀁;

𑀲𑀼𑀗𑁆𑀓𑀁 𑀢𑁆𑀯𑀦𑀺𑀢𑁆𑀣𑀻 𑀕𑀼𑀫𑁆𑀩𑀸𑀤𑀺, 𑀤𑁂𑀬𑁆𑀬𑁂 𑀣𑀸’𑀬𑁄 𑀥𑀦𑀸𑀕𑀫𑁄.

𑀆𑀢𑀧𑀢𑁆𑀢𑀁 𑀢𑀣𑀸 𑀙𑀢𑁆𑀢𑀁, 𑀭𑀜𑁆𑀜𑀁 𑀢𑀼 𑀳𑁂𑀫𑀫𑀸𑀲𑀦𑀁;

𑀲𑀻𑀳𑀸𑀲𑀦𑀁 𑀅𑀣𑁄 𑀯𑀸𑀴, 𑀩𑀻𑀚𑀦𑀻𑀢𑁆𑀣𑀻 𑀘 𑀘𑀸𑀫𑀭𑀁.

𑀔𑀕𑁆𑀕𑁄 𑀘 𑀙𑀢𑁆𑀢 𑀫𑀼𑀡𑁆𑀳𑀻𑀲𑀁, 𑀧𑀸𑀤𑀼𑀓𑀸 𑀯𑀸𑀮𑀩𑀻𑀚𑀦𑀻;

𑀇𑀫𑁂 𑀓𑀓𑀼𑀥𑀪𑀡𑁆𑀟𑀸𑀦𑀺, 𑀪𑀯𑀦𑁆𑀢𑀺 𑀧𑀜𑁆𑀘 𑀭𑀸𑀚𑀼𑀦𑀁.

𑀪𑀤𑁆𑀤𑀓𑀼𑀫𑁆𑀪𑁄 𑀧𑀼𑀡𑁆𑀡𑀓𑀼𑀫𑁆𑀪𑁄, 𑀪𑀺𑀗𑁆𑀓𑀸𑀭𑁄 𑀚𑀮𑀤𑀸𑀬𑀓𑁄;

𑀳𑀢𑁆𑀣𑀺,𑀲𑁆𑀲,𑀭𑀣,𑀧𑀢𑁆𑀢𑀻 𑀢𑀼, 𑀲𑁂𑀦𑀸 𑀳𑀺 𑀘𑀢𑀼𑀭𑀗𑁆𑀕𑀺𑀦𑀻.

𑀓𑀼𑀜𑁆𑀚𑀭𑁄 𑀯𑀸𑀭𑀡𑁄 𑀳𑀢𑁆𑀣𑀻, 𑀫𑀸𑀢𑀗𑁆𑀕𑁄 𑀤𑁆𑀯𑀺𑀭𑀤𑁄 𑀕𑀚𑁄;

𑀓𑀸𑀴𑀸𑀯𑀓 ¶ 𑀕𑀗𑁆𑀕𑁂𑀬𑁆𑀬𑀸, 𑀧𑀡𑁆𑀟𑀭 𑀢𑀫𑁆𑀩𑀸 𑀘 𑀧𑀺𑀗𑁆𑀕𑀮𑁄 𑀕𑀦𑁆𑀥𑁄;

𑀙𑀤𑁆𑀤𑀦𑁆𑀢𑀸 𑀕𑀚𑀓𑀼𑀮𑀸𑀦𑀺 𑀏𑀢𑀸𑀦𑀺.

𑀓𑀮𑀪𑁄 𑀘𑁂𑀯 𑀪𑀺𑀗𑁆𑀓𑁄𑀣, 𑀧𑀪𑀺𑀦𑁆𑀦𑁄 𑀫𑀢𑁆𑀢 𑀕𑀚𑁆𑀚𑀺𑀢𑀸;

𑀳𑀢𑁆𑀣𑀺𑀖𑀝𑀸 𑀢𑀼 𑀕𑀚𑀢𑀸, 𑀳𑀢𑁆𑀣𑀻𑀦𑀻 𑀢𑀼 𑀓𑀭𑁂𑀡𑀼𑀓𑀸.

𑀓𑀼𑀫𑁆𑀪𑁄 𑀳𑀢𑁆𑀣𑀺𑀲𑀺𑀭𑁄𑀧𑀺𑀡𑁆𑀟𑀸, 𑀓𑀡𑁆𑀡𑀫𑀽𑀮𑀁 𑀢𑀼 𑀘𑀽𑀮𑀺𑀓𑀸;

𑀆𑀲𑀦𑀁 𑀔𑀦𑁆𑀥𑀤𑁂𑀲𑀫𑁆𑀳𑀺, 𑀧𑀼𑀘𑁆𑀙𑀫𑀽𑀮𑀁 𑀢𑀼 𑀫𑁂𑀘𑀓𑁄.

𑀆𑀮𑀸𑀦 𑀫𑀸𑀴𑁆𑀳𑀓𑁄 𑀣𑀫𑁆𑀪𑁄, 𑀦𑀺𑀢𑁆𑀣𑀻𑀢𑀼 𑀦𑀺𑀕𑀴𑁄’𑀦𑁆𑀤𑀼𑀓𑁄;

𑀲𑁄𑀡𑁆𑀟𑁄 𑀢𑀼 𑀤𑁆𑀯𑀻𑀲𑀼 𑀳𑀢𑁆𑀣𑁄 𑀣,

𑀫𑀚𑁆𑀛𑀫𑁆𑀳𑀺 𑀩𑀦𑁆𑀥𑀦𑀁 𑀓𑀘𑁆𑀙𑀸, 𑀓𑀧𑁆𑀧𑀦𑁄 𑀢𑀼 𑀓𑀼𑀣𑀸𑀤𑀬𑁄.

𑀑𑀧𑀯𑀬𑁆𑀳𑁄 𑀭𑀸𑀚𑀯𑀬𑁆𑀳𑁄, 𑀲𑀚𑁆𑀚𑀺𑀢𑁄 𑀢𑀼 𑀘 𑀓𑀧𑁆𑀧𑀺𑀢𑁄;

𑀢𑁄𑀫𑀭𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀧𑀸𑀤𑁂, 𑀲𑀺𑀬𑀸 𑀯𑀺𑀚𑁆𑀛𑀦𑀓𑀡𑁆𑀝𑀓𑁄.

𑀢𑀼𑀢𑁆𑀢𑀁 𑀢𑀼 𑀓𑀡𑁆𑀡𑀫𑀽𑀮𑀫𑁆𑀳𑀺, 𑀫𑀢𑁆𑀣𑀓𑀫𑁆𑀳𑀺 𑀢𑀼 𑀅𑀗𑁆𑀓𑀼𑀲𑁄;

𑀳𑀢𑁆𑀣𑀸𑀭𑁄𑀳𑁄 𑀳𑀢𑁆𑀣𑀺𑀫𑁂𑀡𑁆𑀟𑁄,

𑀕𑀸𑀫𑀡𑀻𑀬𑁄 𑀢𑀼 𑀫𑀸𑀢𑀗𑁆𑀕, 𑀳𑀬𑀸𑀤𑁆𑀬𑀸𑀘𑀭𑀺𑀬𑁄 𑀪𑀯𑁂;

𑀖𑁄𑀝𑀓𑁄 𑀢𑀼 𑀔𑀴𑀼𑀗𑁆𑀓𑁄 𑀣, 𑀚𑀯𑀦𑁄 𑀘 𑀚𑀯𑀸𑀥𑀺𑀓𑁄;

𑀫𑀼𑀔𑀸𑀥𑀸𑀦𑀁 𑀔𑀮𑀻𑀦𑁄 𑀯𑀸, 𑀓𑀲𑀸 𑀢𑁆𑀯 𑀲𑁆𑀲𑀸𑀪𑀺𑀢𑀸𑀴𑀺𑀦𑀻.

𑀓𑀼𑀲𑀸 𑀢𑀼 𑀦𑀸𑀲𑀭𑀚𑁆𑀚𑀼𑀫𑁆𑀳𑀺, 𑀯𑀴𑀯𑀸’𑀲𑁆𑀲𑀸 𑀔𑀼𑀭𑁄 𑀲𑀨𑀁;

𑀧𑀼𑀘𑁆𑀙 𑀫𑀦𑀺𑀢𑁆𑀣𑀻 𑀦𑀗𑁆𑀕𑀼𑀝𑁆𑀞𑀁, 𑀯𑀸𑀮𑀳𑀢𑁆𑀣𑁄 𑀘 𑀯𑀸𑀮𑀥𑀺.

𑀲𑀦𑁆𑀤𑀦𑁄 ¶ 𑀘 𑀭𑀣𑁄 𑀨𑀼𑀲𑁆𑀲, 𑀭𑀣𑁄 𑀢𑀼 𑀦𑀭𑀡𑀸𑀬 𑀲𑁄;

𑀤𑁂𑀧𑁆𑀧𑁄 𑀩𑁆𑀬𑀕𑁆𑀖𑀲𑁆𑀲 𑀤𑀻𑀧𑀺𑀦𑁄.

𑀲𑀺𑀯𑀺𑀓𑀸 𑀬𑀸𑀧𑁆𑀬𑀬𑀸𑀦𑀜𑁆𑀘𑀸, 𑀦𑀺𑀢𑁆𑀣𑀻 𑀢𑀼 𑀲𑀓𑀝𑁄 𑀧𑁆𑀬’𑀦𑀁 [(𑀲𑀓𑀝𑁄 𑀧𑀺+𑀅𑀦𑀁)];

𑀘𑀓𑁆𑀓𑀁 𑀭𑀣𑀗𑁆𑀕 𑀫𑀸𑀔𑁆𑀬𑀸𑀢𑀁, 𑀢𑀲𑁆𑀲𑀦𑁆𑀢𑁄 𑀦𑁂𑀫𑀺 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀢𑀫𑁆𑀫𑀚𑁆𑀛𑁂 𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑀸 𑀦𑀸𑀪𑀺, 𑀓𑀼𑀩𑁆𑀩𑀭𑁄 𑀢𑀼 𑀬𑀼𑀕𑀦𑁆𑀥𑀭𑁄;

𑀅𑀓𑁆𑀔𑀕𑁆𑀕𑀓𑀻𑀮𑁂 𑀆𑀡𑀻𑀢𑁆𑀣𑀻, 𑀯𑀭𑀼𑀣𑁄 𑀭𑀣𑀕𑀼𑀢𑁆𑀬’𑀣.

𑀥𑀼𑀭𑁄 𑀫𑀼𑀔𑁂 𑀭𑀣𑀲𑁆𑀲𑀗𑁆𑀕𑀸, 𑀢𑁆𑀯 𑀓𑁆𑀔𑁄 𑀧𑀓𑁆𑀔𑀭𑀆𑀤𑀬𑁄;

𑀬𑀸𑀦𑀜𑁆𑀘 𑀯𑀸𑀳𑀦𑀁 𑀬𑁄𑀕𑁆𑀕𑀁, 𑀲𑀩𑁆𑀩𑀳𑀢𑁆𑀣𑁆𑀬𑀸𑀤𑀺𑀯𑀸𑀳𑀦𑁂.

𑀭𑀣𑀘𑀸𑀭𑀻 𑀢𑀼 𑀲𑀽𑀢𑁄 𑀘, 𑀧𑀸𑀚𑀺𑀢𑀸 𑀘𑁂𑀯 𑀲𑀸𑀭𑀣𑀻;

𑀧𑀤𑀸𑀢𑀺 𑀧𑀢𑁆𑀢𑀻 𑀢𑀼 𑀧𑀼𑀫𑁂, 𑀧𑀤𑀕𑁄 𑀧𑀤𑀺𑀓𑁄 𑀫𑀢𑁄;

𑀲𑀦𑁆𑀦𑀸𑀳𑁄 𑀓𑀗𑁆𑀓𑀝𑁄 𑀯𑀫𑁆𑀫𑀁, 𑀓𑀯𑀘𑁄 𑀯𑀸 𑀉𑀭𑀘𑁆𑀙𑀤𑁄.

𑀚𑀸𑀮𑀺𑀓𑀸 𑀣 𑀘 𑀲𑀦𑁆𑀦𑀤𑁆𑀥𑁄, 𑀲𑀚𑁆𑀚𑁄 𑀘 𑀯𑀫𑁆𑀫𑀺𑀓𑁄 𑀪𑀯𑁂;

𑀆𑀫𑀼𑀓𑁆𑀓𑁄 𑀧𑀝𑀺𑀫𑀼𑀓𑁆𑀓𑁄 𑀣, 𑀧𑀼𑀭𑁂𑀘𑀸𑀭𑀻 𑀧𑀼𑀭𑁂𑀘𑀭𑁄.

𑀧𑀼𑀩𑁆𑀩𑀗𑁆𑀕𑀫𑁄 𑀧𑀼𑀭𑁂𑀕𑀸𑀫𑀻, 𑀫𑀦𑁆𑀤𑀕𑀸𑀫𑀻 𑀢𑀼 𑀫𑀦𑁆𑀣𑀭𑁄;

𑀚𑀯𑀦𑁄 𑀢𑀼𑀭𑀺𑀢𑁄 𑀯𑁂𑀕𑀻, 𑀚𑁂𑀢𑀩𑁆𑀩𑀁 𑀚𑁂𑀬𑁆𑀬 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀲𑀽𑀭 𑀯𑀻𑀭𑀸 𑀢𑀼 𑀯𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁄, 𑀲𑀳𑀸𑀬𑁄 𑀦𑀼𑀘𑀭𑁄 𑀲𑀫𑀸;

𑀲𑀦𑁆𑀦𑀤𑁆𑀥𑀧𑁆𑀧𑀪𑀼𑀢𑀻 𑀢𑀻𑀲𑀼, 𑀧𑀸𑀣𑁂𑀬𑁆𑀬𑀁 𑀢𑀼 𑀘 𑀲𑀫𑁆𑀩𑀮𑀁.

𑀯𑀸𑀳𑀺𑀦𑀻 𑀥𑀚𑀺𑀦𑀻 𑀲𑁂𑀦𑀸, 𑀘𑀫𑀽 𑀘𑀓𑁆𑀓𑀁 𑀩𑀮𑀁 𑀢𑀣𑀸;

𑀘𑀢𑀼𑀧𑁄𑀲𑁄𑀢𑀺 𑀏𑀢𑁂𑀦, 𑀮𑀓𑁆𑀔𑀡𑁂𑀦𑀸 𑀥𑀫𑀦𑁆𑀢𑀢𑁄.

𑀳𑀢𑁆𑀣𑀸𑀦𑀻𑀓𑀁 𑀳𑀬𑀸𑀦𑀻𑀓𑀁, 𑀭𑀣𑀸𑀦𑀻𑀓𑀁 𑀢𑀬𑁄 𑀢𑀬𑁄;

𑀕𑀚𑀸𑀤𑀬𑁄 𑀲𑀲𑀢𑁆𑀣𑀸 𑀢𑀼, 𑀧𑀢𑁆𑀢𑀸𑀦𑀻𑀓𑀁 𑀘𑀢𑀼𑀚𑁆𑀚𑀦𑀸.

𑀲𑀝𑁆𑀞𑀺𑀯𑀁𑀲𑀓𑀮𑀸𑀧𑁂𑀲𑀼, ¶ 𑀧𑀘𑁆𑀘𑁂𑀓𑀁 𑀲𑀝𑁆𑀞𑀺𑀤𑀡𑁆𑀟𑀺𑀲𑀼;

𑀥𑀽𑀮𑀻𑀓𑀢𑁂𑀲𑀼 𑀲𑁂𑀦𑀸𑀬, 𑀬𑀦𑁆𑀢𑀺𑀬𑀸 𑀓𑁆𑀔𑁄𑀪𑀦𑀻 [𑀅𑀓𑁆𑀔𑁄𑀪𑀺𑀡𑀻 (𑀓.)] 𑀢𑁆𑀣𑀺𑀬𑀁.

𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀺 𑀲𑀫𑁆𑀧𑀤𑀸 𑀮𑀓𑁆𑀔𑀻, 𑀲𑀺𑀭𑀻 𑀯𑀺𑀧𑀢𑁆𑀢𑀺 𑀆𑀧𑀤𑀸;

𑀅𑀣𑀸 𑀯𑀼𑀥𑀜𑁆𑀘 [𑀆𑀬𑀼𑀥𑀦𑁆𑀢𑀺𑀧𑀺 𑀧𑀸𑀞𑁄] 𑀳𑁂𑀢𑀺’𑀢𑁆𑀣𑀻, 𑀲𑀢𑁆𑀣𑀁 𑀧𑀳𑀭𑀡𑀁 𑀪𑀯𑁂.

𑀫𑀼𑀢𑁆𑀢𑀸𑀫𑀼𑀢𑁆𑀢 𑀫𑀫𑀼𑀢𑁆𑀢𑀜𑁆𑀘, 𑀧𑀸𑀡𑀺𑀢𑁄 𑀫𑀼𑀢𑁆𑀢𑀫𑁂𑀯 𑀘;

𑀬𑀦𑁆𑀢𑀫𑀼𑀢𑁆𑀢𑀦𑁆𑀢𑀺 𑀲𑀓𑀮𑀁, 𑀆𑀬𑀼𑀥𑀁 𑀢𑀁 𑀘𑀢𑀼𑀩𑁆𑀩𑀺𑀥𑀁.

𑀫𑀼𑀢𑁆𑀢𑀸𑀫𑀼𑀢𑁆𑀢𑀜𑁆𑀘 𑀬𑀝𑁆𑀞𑁆𑀬𑀸𑀤𑀺, 𑀅𑀫𑀼𑀢𑁆𑀢𑀁 𑀙𑀼𑀭𑀺𑀓𑀸𑀤𑀺𑀓𑀁;

𑀧𑀸𑀡𑀺𑀫𑀼𑀢𑁆𑀢𑀁 𑀢𑀼 𑀲𑀢𑁆𑀬𑀸𑀤𑀺, 𑀬𑀦𑁆𑀢𑀫𑀼𑀢𑁆𑀢𑀁 𑀲𑀭𑀸𑀤𑀺𑀓𑀁.

𑀇𑀲𑁆𑀲𑀸𑀲𑁄 𑀥𑀦𑀼 𑀓𑁄𑀤𑀡𑁆𑀟𑀁, 𑀘𑀸𑀧𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀲𑀭𑀸𑀲𑀦𑀁;

𑀯𑀸𑀡𑁄 𑀓𑀡𑁆𑀟 𑀫𑀼𑀲𑀼 𑀤𑁆𑀯𑀻𑀲𑀼, 𑀔𑀼𑀭𑀧𑁆𑀧𑁄 [𑀉𑀭𑀧𑁆𑀧𑁄 (𑀓.)] 𑀢𑁂𑀚𑀦𑀸’𑀲𑀦𑀁;

𑀢𑀽𑀡𑀻𑀢𑁆𑀣𑀺𑀬𑀁 𑀓𑀮𑀸𑀧𑁄 𑀘, 𑀢𑀽𑀡𑁄 𑀢𑀽𑀡𑀻𑀭 𑀯𑀸𑀡𑀥𑀺.

𑀧𑀓𑁆𑀔𑁄 𑀢𑀼 𑀯𑀸𑀚𑁄 𑀤𑀺𑀤𑁆𑀥𑁄 𑀢𑀼, 𑀯𑀺𑀲𑀧𑁆𑀧𑀺𑀢𑁄 𑀲𑀭𑁄 𑀪𑀯𑁂;

𑀮𑀓𑁆𑀔𑀁 𑀯𑁂𑀚𑁆𑀛𑀁 𑀲𑀭𑀩𑁆𑀬𑀜𑁆𑀘, 𑀲𑀭𑀸𑀪𑁆𑀬𑀸𑀲𑁄 𑀢𑀼’𑀧𑀸𑀲𑀦𑀁.

𑀫𑀡𑁆𑀟𑀮𑀕𑁆𑀕𑁄 𑀢𑀼 𑀦𑁂𑀢𑁆𑀢𑀺𑀁𑀲𑁄, 𑀅𑀲𑀺 𑀔𑀕𑁆𑀕𑁄 𑀘 𑀲𑀸𑀬𑀓𑁄;

𑀓𑁄𑀲𑀺𑀢𑁆𑀣𑀻 𑀢𑀩𑁆𑀩𑀺𑀥𑀸𑀦𑁂 𑀣𑁄, 𑀣𑀭𑀼 𑀔𑀕𑁆𑀕𑀸𑀤𑀺𑀫𑀼𑀝𑁆𑀞𑀺𑀬𑀁.

𑀔𑁂𑀝𑀓𑀁 𑀨𑀮𑀓𑀁 𑀘𑀫𑁆𑀫𑀁, 𑀇𑀮𑁆𑀮𑀻 𑀢𑀼 𑀓𑀭𑀧𑀸𑀮𑀺𑀓𑀸;

𑀙𑀼𑀭𑀺𑀓𑀸 𑀲𑀢𑁆𑀬’𑀲𑀺𑀧𑀼𑀢𑁆𑀢𑀻, 𑀮𑀕𑀼𑀴𑁄 𑀢𑀼 𑀘 𑀫𑀼𑀕𑁆𑀕𑀭𑁄.

𑀲𑀮𑁆𑀮𑁄 𑀦𑀺𑀢𑁆𑀣𑀺 𑀲𑀗𑁆𑀓𑀼 𑀧𑀼𑀫𑁂, 𑀯𑀸𑀲𑀻 𑀢𑀼 𑀢𑀘𑁆𑀙𑀦𑀻𑀢𑁆𑀣𑀺𑀬𑀁;

𑀓𑀼𑀞𑀸𑀭𑀻 [𑀓𑀼𑀥𑀸𑀭𑀻 (𑀝𑀻.)] 𑀢𑁆𑀣𑀻𑀨𑀭𑀲𑀼𑀲𑁄, 𑀝𑀗𑁆𑀓𑁄 𑀧𑀸𑀲𑀸𑀡𑀤𑀸𑀭𑀡𑁄.

𑀓𑀡𑀬𑁄 𑀪𑀺𑀦𑁆𑀤𑀺𑀯𑀸𑀴𑁄 𑀘, 𑀘𑀓𑁆𑀓𑀁 𑀓𑀼𑀦𑁆𑀢𑁄 𑀕𑀤𑀸 𑀢𑀣𑀸;

𑀦𑀺𑀬𑁆𑀬𑀸𑀦𑀁 𑀕𑀫𑀦𑀁 𑀬𑀸𑀢𑁆𑀭𑀸, 𑀧𑀝𑁆𑀞𑀸𑀦𑀜𑁆𑀘 𑀕𑀫𑁄 𑀕𑀢𑀺;

𑀘𑀼𑀡𑁆𑀡𑁄 𑀧𑀁𑀲𑀼 𑀭𑀚𑁄 𑀘𑁂𑀯, 𑀥𑀽𑀮𑀻’𑀢𑁆𑀣𑀻 𑀭𑁂𑀡𑀼 𑀘 𑀤𑁆𑀯𑀺𑀲𑀼.

𑀫𑀸𑀕𑀥𑁄 ¶ 𑀫𑀥𑀼𑀓𑁄 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀯𑀦𑁆𑀤𑀻 𑀢𑀼 𑀣𑀼𑀢𑀺𑀧𑀸𑀞𑀓𑁄;

𑀓𑁂𑀢𑀼 𑀥𑀚𑁄 𑀧𑀝𑀸𑀓𑀸 𑀘, 𑀓𑀤𑀮𑀻 𑀓𑁂𑀢𑀦𑀁 𑀧𑁆𑀬𑀣;

𑀬𑁄’𑀳𑀁𑀓𑀸𑀭𑁄’𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀲𑁆𑀲, 𑀲𑀸’ 𑀳𑀫𑀳𑀫𑀺𑀓𑀸 𑀪𑀯𑁂.

𑀩𑀮𑀁 𑀣𑀸𑀫𑁄 𑀲𑀳𑀁 𑀲𑀢𑁆𑀢𑀺, 𑀯𑀺𑀓𑁆𑀓𑀫𑁄 𑀢𑁆𑀯𑀢𑀺𑀲𑀽𑀭𑀢𑀸;

𑀭𑀡𑁂 𑀚𑀺𑀢𑀲𑁆𑀲 𑀬𑀁 𑀧𑀸𑀦𑀁, 𑀚𑀬𑀧𑀸𑀦𑀦𑁆𑀢𑀺 𑀢𑀁 𑀫𑀢𑀁.

𑀲𑀗𑁆𑀕𑀸𑀫𑁄 𑀲𑀫𑁆𑀧𑀳𑀸𑀭𑁄 𑀘𑀸, 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀲𑀫𑀭𑀁 𑀭𑀡𑀁;

𑀆𑀚𑀺𑀢𑁆𑀣𑀻 𑀆𑀳𑀯𑁄 𑀬𑀼𑀤𑁆𑀥, 𑀫𑀸𑀬𑁄𑀥𑀦𑀜𑁆𑀘 𑀲𑀁𑀬𑀼𑀕𑀁.

𑀪𑀡𑁆𑀟𑀦𑀁 𑀢𑀼 𑀯𑀺𑀯𑀸𑀤𑁄 𑀘, 𑀯𑀺𑀕𑁆𑀕𑀳𑁄 𑀓𑀮𑀳 𑀫𑁂𑀥𑀕𑀸;

𑀉𑀧𑁆𑀧𑀸𑀤𑁄 [𑀉𑀧𑁆𑀧𑀸𑀢𑁄 (𑀓.)𑁧𑁦𑁨𑁭-𑀕𑀸𑀣𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸] 𑀪𑀽𑀢𑀯𑀺𑀓𑀢𑀺, 𑀬𑀸 𑀲𑀼𑀪𑀸𑀲𑀼𑀪𑀲𑀽𑀘𑀺𑀓𑀸;

𑀈𑀢𑀺 𑀢𑁆𑀯𑀺𑀢𑁆𑀣𑀻 𑀅𑀚𑀜𑁆𑀜𑀜𑁆𑀘, 𑀉𑀧𑀲𑀕𑁆𑀕𑁄 𑀉𑀧𑀤𑁆𑀤𑀯𑁄.

𑀦𑀺𑀩𑁆𑀩𑀼𑀤𑁆𑀥𑀁 [𑀦𑀺𑀬𑀼𑀤𑁆𑀥𑀁 (𑀓.)] 𑀫𑀮𑁆𑀮𑀬𑀼𑀤𑁆𑀥𑀫𑁆𑀳𑀺, 𑀚𑀬𑁄 𑀢𑀼 𑀯𑀺𑀚𑀬𑁄 𑀪𑀯𑁂;

𑀧𑀭𑀸𑀚𑀬𑁄 𑀭𑀡𑁂 𑀪𑀗𑁆𑀕𑁄, 𑀧𑀮𑀸𑀬𑀦 𑀫𑀧𑀓𑁆𑀓𑀫𑁄.

𑀫𑀸𑀭𑀡𑀁 𑀳𑀦𑀦𑀁 𑀖𑀸𑀢𑁄, 𑀦𑀸𑀲𑀦𑀜𑁆𑀘 𑀦𑀺𑀲𑀽𑀤𑀦𑀁;

𑀳𑀺𑀁𑀲𑀦𑀁 𑀲𑀭𑀡𑀁 𑀳𑀺𑀁𑀲𑀸, 𑀯𑀥𑁄 𑀲𑀲𑀦 𑀖𑀸𑀢𑀦𑀁.

𑀫𑀭𑀡𑀁 𑀓𑀸𑀮𑀓𑀺𑀭𑀺𑀬𑀸, 𑀧𑀮𑀬𑁄 𑀫𑀘𑁆𑀘𑀼 𑀅𑀘𑁆𑀘𑀬𑁄;

𑀦𑀺𑀥𑀦𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀦𑀸𑀲𑁄, 𑀓𑀸𑀮𑁄’𑀦𑁆𑀢𑁄 𑀘𑀯𑀦𑀁 𑀪𑀯𑁂.

𑀆𑀴𑀳𑀦𑀁 𑀲𑀼𑀲𑀸𑀦𑀜𑁆𑀘𑀸, 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀓𑀼𑀡𑀧𑁄 𑀙𑀯𑁄.

𑀓𑀩𑀦𑁆𑀥𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀤𑁂𑀳𑁄, 𑀲𑀺𑀭𑁄𑀲𑀼𑀜𑁆𑀜𑁄 𑀲𑀳𑀓𑁆𑀭𑀺𑀬𑁄;

𑀅𑀣 𑀲𑀺𑀯𑀣𑀺𑀓𑀸 𑀯𑀼𑀢𑁆𑀢𑀸, 𑀲𑀼𑀲𑀸𑀦𑀲𑁆𑀫𑀺𑀜𑁆𑀳𑀺 𑀆𑀫𑀓𑁂.

𑀯𑀦𑁆𑀤𑀻𑀢𑁆𑀣𑀺𑀬𑀁 𑀓𑀭𑀫𑀭𑁄, 𑀧𑀸𑀡𑁄 𑀢𑁆𑀯’𑀲𑀼 𑀧𑀓𑀸𑀲𑀺𑀢𑁄;

𑀓𑀸𑀭𑀸 𑀢𑀼 𑀩𑀦𑁆𑀥𑀦𑀸𑀕𑀸𑀭𑀁, 𑀓𑀸𑀭𑀡𑀸 𑀢𑀼 𑀘 𑀬𑀸𑀢𑀦𑀸.

𑀩𑁆𑀭𑀳𑁆𑀫𑀩𑀦𑁆𑀥𑀼 ¶ 𑀤𑁆𑀯𑀺𑀚𑁄 𑀯𑀺𑀧𑁆𑀧𑁄, 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀪𑁄𑀯𑀸𑀤𑀻 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

𑀲𑀺𑀲𑁆𑀲’ 𑀦𑁆𑀢𑁂𑀯𑀸𑀲𑀺𑀦𑁄 𑀧𑀼𑀫𑁂.

𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀻 𑀕𑀳𑀝𑁆𑀞𑁄 𑀘, 𑀯𑀦𑀧𑁆𑀧𑀢𑁆𑀣𑁄 𑀘 𑀪𑀺𑀓𑁆𑀔𑀼𑀢𑀺;

𑀪𑀯𑀦𑁆𑀢𑀺 𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀏𑀢𑁂, 𑀅𑀲𑁆𑀲𑀫𑀸 𑀧𑀼𑀦𑁆𑀦𑀧𑀼𑀁𑀲𑀓𑁂.

𑀘𑀭𑀦𑁆𑀢𑀸 𑀲𑀳 𑀲𑀻𑀮𑀸𑀤𑀻, 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺𑀦𑁄 𑀫𑀺𑀣𑀼;

𑀉𑀧𑀚𑁆𑀛𑀸𑀬𑁄 𑀉𑀧𑀚𑁆𑀛𑀸 𑀣𑀸, 𑀘𑀭𑀺𑀬𑁄 𑀦𑀺𑀲𑁆𑀲𑀬𑀤𑀸𑀤𑀺𑀓𑁄 [𑀦𑀺𑀲𑁆𑀲𑀬𑀤𑀸𑀬𑀓𑁄 (𑀝𑀻.)].

𑀉𑀧𑀦𑀻𑀬𑀸 𑀣𑀯𑀸 𑀧𑀼𑀩𑁆𑀩𑀁, 𑀯𑁂𑀤 𑀫𑀚𑁆𑀛𑀸𑀧𑀬𑁂 𑀤𑁆𑀯𑀺𑀚𑁄;

𑀬𑁄 𑀲𑀗𑁆𑀕𑀁 𑀲𑀭𑀳𑀲𑁆𑀲𑀜𑁆𑀘𑀸, 𑀘𑀭𑀺𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼 𑀲𑁄.

𑀧𑀸𑀭𑀫𑁆𑀧𑀭𑀺𑀬 𑀫𑁂𑀢𑀺𑀳𑁆𑀬𑀁, 𑀉𑀧𑀤𑁂𑀲𑁄 𑀢𑀣𑁂’𑀢𑀺𑀳𑀸;

𑀬𑀸𑀕𑁄 𑀢𑀼 𑀓𑀢𑀼 𑀬𑀜𑁆𑀜𑁄 𑀣, 𑀯𑁂𑀤𑀻𑀢𑁆𑀣𑀻 𑀪𑀽 𑀧𑀭𑀺𑀓𑁆𑀔𑀢𑀸.

𑀅𑀲𑁆𑀲𑀫𑁂𑀥𑁄 𑀘 𑀧𑀼𑀭𑀺𑀲, 𑀫𑁂𑀥𑁄 𑀘𑁂𑀯 𑀦𑀺𑀭𑀕𑁆𑀕𑀴𑁄;

𑀲𑀫𑁆𑀫𑀸𑀧𑀸𑀲𑁄 𑀯𑀸𑀚𑀧𑁂𑀬𑁆𑀬, 𑀫𑀺𑀢𑀺 𑀬𑀸𑀕𑀸 𑀫𑀳𑀸 𑀇𑀫𑁂.

𑀇𑀢𑁆𑀯𑀺𑀚𑁄 [𑀇𑀤𑀺𑀢𑁆𑀯𑀺𑀚𑁄 (𑀝𑀻.)] 𑀬𑀸𑀚𑀓𑁄 𑀘𑀸𑀣,

𑀧𑀭𑀺𑀲𑀸 𑀲𑀪𑀸 𑀲𑀫𑀚𑁆𑀚𑀸 𑀘, 𑀢𑀣𑀸 𑀲𑀫𑀺𑀢𑀺 𑀲𑀁𑀲𑀤𑁄.

𑀘𑀢𑀲𑁆𑀲𑁄 𑀧𑀭𑀺𑀲𑀸 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑀻 𑀘 𑀉𑀧𑀸𑀲𑀓𑀸;

𑀉𑀧𑀸𑀲𑀺𑀓𑀸𑀬𑁄𑀢𑀺 𑀇𑀫𑀸, 𑀣𑀯𑀸 𑀝𑁆𑀞 𑀧𑀭𑀺𑀲𑀸 𑀲𑀺𑀬𑀼𑀁.

𑀢𑀸𑀯𑀢𑀺𑀁𑀲,𑀤𑁆𑀯𑀺𑀚,𑀓𑁆𑀔𑀢𑁆𑀢,𑀫𑀸𑀭,𑀕𑁆𑀕𑀳𑀧𑀢𑀺𑀲𑁆𑀲 𑀘;

𑀲𑀫𑀡𑀸𑀦𑀁 𑀯𑀲𑀸 𑀘𑀸𑀢𑀼, 𑀫𑀳𑀸𑀭𑀸𑀚𑀺𑀓, 𑀩𑁆𑀭𑀳𑁆𑀫𑀼𑀦𑀁.

𑀕𑀸𑀬𑀢𑁆𑀢𑀺𑀧𑁆𑀧𑀫𑀼𑀔𑀁 𑀙𑀦𑁆𑀤𑀁, 𑀘𑀢𑀼𑀯𑀻𑀲’𑀓𑁆𑀔𑀭𑀁 𑀢𑀼 𑀬𑀁;

𑀯𑁂𑀤𑀸𑀦 𑀫𑀸𑀤𑀺𑀪𑀽𑀢𑀁 𑀲𑀸, 𑀲𑀸𑀯𑀺𑀢𑁆𑀢𑀻 𑀢𑀺𑀧𑀤𑀁 𑀲𑀺𑀬𑀸.

𑀳𑀩𑁆𑀬𑀧𑀸𑀓𑁂 𑀘𑀭𑀼 𑀫𑀢𑁄, 𑀲𑀼𑀚𑀸 𑀢𑀼 𑀳𑁄𑀫𑀤𑀩𑁆𑀩𑀺𑀬𑀁;

𑀧𑀭𑀫𑀦𑁆𑀦𑀁 𑀢𑀼 𑀧𑀸𑀬𑀸𑀲𑁄, 𑀳𑀩𑁆𑀬𑀁 𑀢𑀼 𑀳𑀯𑀺 𑀓𑀣𑁆𑀬𑀢𑁂.

𑀬𑀽𑀧𑁄 𑀣𑀽𑀡𑀸𑀬𑀁 𑀦𑀺𑀫𑁆𑀫𑀦𑁆𑀢𑁆𑀬, 𑀤𑀸𑀭𑀼𑀫𑁆𑀳𑀺 𑀢𑁆𑀯’𑀭𑀡𑀻 𑀤𑁆𑀯𑀺𑀲𑀼;

𑀕𑀸𑀳𑀧𑁆𑀧𑀘𑁆𑀘𑀸’𑀳𑀯𑀦𑀻𑀬𑁄, 𑀤𑀓𑁆𑀔𑀺𑀡𑀕𑁆𑀕𑀺 𑀢𑀬𑁄’ 𑀕𑁆𑀕𑀬𑁄.

𑀘𑀸𑀕𑁄 𑀯𑀺𑀲𑁆𑀲𑀚𑁆𑀚𑀦𑀁 𑀤𑀸𑀦𑀁, 𑀯𑁄𑀲𑁆𑀲𑀕𑁆𑀕𑁄 𑀘𑀸𑀧𑀤𑁂𑀲𑀦𑀁;

𑀯𑀺𑀲𑁆𑀲𑀸𑀡𑀦𑀁 𑀯𑀺𑀢𑀭𑀡𑀁, 𑀯𑀺𑀳𑀸𑀬𑀺𑀢𑀸 𑀧𑀯𑀚𑁆𑀚𑀦𑀁.

𑀧𑀜𑁆𑀘 ¶ 𑀫𑀳𑀸𑀧𑀭𑀺𑀘𑁆𑀘𑀸𑀕𑁄, 𑀯𑀼𑀢𑁆𑀢𑁄 𑀲𑁂𑀝𑁆𑀞, 𑀥𑀦𑀲𑁆𑀲 𑀘;

𑀯𑀲𑁂𑀦 𑀧𑀼𑀢𑁆𑀢 𑀤𑀸𑀭𑀸𑀦𑀁, 𑀭𑀚𑁆𑀚𑀲𑁆𑀲’ 𑀗𑁆𑀕𑀸𑀦 𑀫𑁂𑀯 𑀘.

𑀅𑀦𑁆𑀦𑀁 𑀧𑀸𑀦𑀁 𑀖𑀭𑀁 𑀯𑀢𑁆𑀣𑀁, 𑀬𑀸𑀦𑀁 𑀫𑀸𑀮𑀸 𑀯𑀺𑀮𑁂𑀧𑀦𑀁;

𑀕𑀦𑁆𑀥𑁄 𑀲𑁂𑀬𑁆𑀬𑀸 𑀧𑀤𑀻𑀧𑁂𑀬𑁆𑀬𑀁, 𑀤𑀸𑀦𑀯𑀢𑁆𑀣𑀽 𑀲𑀺𑀬𑀼𑀁 𑀤𑀲.

𑀫𑀢𑀢𑁆𑀣𑀁 𑀢𑀤𑀳𑁂 𑀤𑀸𑀦𑀁, 𑀢𑀻𑀲𑁆𑀯𑁂𑀢 𑀫𑀼𑀤𑁆𑀥𑀤𑁂𑀳𑀺𑀓𑀁;

𑀧𑀺𑀢𑀼𑀤𑀸𑀦𑀁 𑀢𑀼 𑀦𑀺𑀯𑀸𑀧𑁄, 𑀲𑀤𑁆𑀥𑀁 𑀢𑀼 𑀢𑀁𑀯 𑀲𑀸𑀢𑁆𑀣𑀢𑁄.

𑀧𑀼𑀫𑁂 𑀅𑀢𑀺𑀣𑀺 𑀆𑀕𑀦𑁆𑀢𑀼, 𑀧𑀸𑀳𑀼𑀦𑀸 𑀯𑁂𑀲𑀺𑀓𑀸 𑀧𑁆𑀬𑀣;

𑀅𑀜𑁆𑀜𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑀼 𑀫𑀺𑀘𑁆𑀙𑀦𑁆𑀢𑁄, 𑀕𑀫𑀺𑀓𑁄 𑀣𑀸 𑀕𑁆𑀖 𑀫𑀕𑁆𑀖𑀺𑀬𑀁.

𑀧𑀚𑁆𑀚𑀁 𑀧𑀸𑀤𑁄𑀤𑀓𑀸𑀤𑁄 𑀣, 𑀲𑀢𑁆𑀢𑀸’𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀤𑀬𑁄 𑀢𑀺𑀲𑀼;

𑀅𑀧𑀘𑀺𑀢𑁆𑀬’𑀘𑁆𑀘𑀦𑀸 𑀧𑀽𑀚𑀸, 𑀧𑀳𑀸𑀭𑁄 𑀩𑀮𑀺 𑀫𑀸𑀦𑀦𑀸.

𑀦𑀫𑀲𑁆𑀲𑀸 𑀢𑀼 𑀦𑀫𑀓𑁆𑀓𑀸𑀭𑁄, 𑀯𑀦𑁆𑀤𑀦𑀸 𑀘𑀸𑀪𑀺𑀯𑀸𑀤𑀦𑀁;

𑀧𑀢𑁆𑀣𑀦𑀸 𑀧𑀡𑀺𑀥𑀸𑀦𑀜𑁆𑀘, 𑀧𑀼𑀭𑀺𑀲𑁂 𑀧𑀡𑀺𑀥𑀻𑀭𑀺𑀢𑁄.

𑀅𑀚𑁆𑀛𑁂𑀲𑀦𑀸 𑀢𑀼 𑀲𑀓𑁆𑀓𑀸𑀭, 𑀧𑀼𑀩𑁆𑀩𑀗𑁆𑀕𑀫𑀦𑀺𑀬𑁄𑀚𑀦𑀁;

𑀧𑀭𑀺𑀬𑁂𑀲𑀦𑀸 𑀦𑁆𑀯𑁂𑀲𑀦𑀸, 𑀧𑀭𑀺𑀬𑁂𑀝𑁆𑀞𑀺 𑀕𑀯𑁂𑀲𑀦𑀸;

𑀉𑀧𑀸𑀲𑀦𑀁 𑀢𑀼 𑀲𑀼𑀲𑁆𑀲𑀽𑀲𑀸, 𑀲𑀸 𑀧𑀸𑀭𑀺𑀘𑀭𑀺𑀬𑀸 𑀪𑀯𑁂.

𑀫𑁄𑀦 𑀫𑀪𑀸𑀲𑀦𑀁 𑀢𑀼𑀡𑁆𑀳𑀻, 𑀪𑀸𑀯𑁄 𑀣 𑀧𑀝𑀺𑀧𑀸𑀝𑀺 𑀲𑀸;

𑀅𑀦𑀼𑀓𑁆𑀓𑀫𑁄 𑀧𑀭𑀺𑀬𑀸𑀬𑁄, 𑀅𑀦𑀼𑀧𑀼𑀩𑁆𑀩𑁆𑀬’𑀧𑀼𑀫𑁂 𑀓𑀫𑁄.

𑀢𑀧𑁄 𑀘 𑀲𑀁𑀬𑀫𑁄 𑀲𑀻𑀮𑀁, 𑀦𑀺𑀬𑀫𑁄 𑀢𑀼 𑀯𑀢𑀜𑁆𑀘 𑀯𑀸;

𑀯𑀻𑀢𑀺𑀓𑁆𑀓𑀫𑁄’ 𑀚𑁆𑀛𑀘𑀸𑀭𑁄 𑀣, 𑀯𑀺𑀯𑁂𑀓𑁄 𑀧𑀼𑀣𑀼𑀕𑀢𑁆𑀢𑀢𑀸.

𑀔𑀼𑀤𑁆𑀤𑀸𑀦𑀼𑀔𑀼𑀤𑁆𑀤𑀓𑀁 𑀆𑀪𑀺, 𑀲𑀫𑀸𑀘𑀸𑀭𑀺𑀓 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀆𑀤𑀺𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁 𑀢𑀼, 𑀢𑀤𑀜𑁆𑀜𑀁 𑀲𑀻𑀮 𑀫𑀻𑀭𑀺𑀢𑀁.

𑀬𑁄 𑀧𑀸𑀧𑁂𑀳𑀺 𑀉𑀧𑀸𑀯𑀢𑁆𑀢𑁄, 𑀯𑀸𑀲𑁄 𑀲𑀤𑁆𑀥𑀺𑀁 𑀕𑀼𑀡𑁂𑀳𑀺 𑀲𑁄;

𑀉𑀧𑀯𑀸𑀲𑁄𑀢𑀺 𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑁄, 𑀲𑀩𑁆𑀩𑀪𑁄𑀕𑀯𑀺𑀯𑀚𑁆𑀚𑀺𑀢𑁄.

𑀢𑀧𑀲𑁆𑀲𑀻 𑀪𑀺𑀓𑁆𑀔𑀼 𑀲𑀫𑀡𑁄, 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄 𑀢𑀧𑁄𑀥𑀦𑁄;

𑀯𑀸𑀘𑀁𑀬𑀫𑁄 𑀢𑀼 𑀫𑀼𑀦𑀺 𑀘, 𑀢𑀸𑀧𑀲𑁄 𑀢𑀼 𑀇𑀲𑀻 𑀭𑀺𑀢𑁄.

𑀬𑁂𑀲𑀁𑀬𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀕𑀡𑀸, 𑀬𑀢𑀬𑁄 𑀯𑀲𑀺𑀦𑁄 𑀘 𑀢𑁂;

𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑁄’𑀧𑀢𑀺𑀲𑁆𑀲𑁄 𑀢𑀼, 𑀥𑀫𑁆𑀫𑀲𑁂𑀦𑀸𑀧𑀢𑀻 𑀭𑀺𑀢𑁄.

𑀲𑁄𑀢𑀸𑀧𑀦𑁆𑀦𑀸𑀤𑀺𑀓𑀸 𑀲𑁂𑀔𑀸, 𑀦𑀭𑀺𑀬𑁄 𑀢𑀼 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀦𑁄.

𑀅𑀜𑁆𑀜𑀸 ¶ 𑀢𑀼 𑀅𑀭𑀳𑀢𑁆𑀢𑀜𑁆𑀘, 𑀣𑀽𑀧𑁄 𑀢𑀼 𑀘𑁂𑀢𑀺𑀬𑀁 𑀪𑀯𑁂;

𑀥𑀫𑁆𑀫𑀪𑀡𑁆𑀟𑀸𑀕𑀸𑀭𑀺𑀓𑁄 𑀘, 𑀆𑀦𑀦𑁆𑀤𑁄 𑀤𑁆𑀯𑁂 𑀲𑀫𑀸 𑀣 𑀘.

𑀯𑀺𑀲𑀸𑀔𑀸 𑀫𑀺𑀕𑀸𑀭𑀫𑀸𑀢𑀸, 𑀲𑀼𑀤𑀢𑁆𑀢𑁄’ 𑀦𑀸𑀣𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑁄;

𑀪𑀺𑀓𑁆𑀔𑀼𑀧𑀺 𑀲𑀸𑀫𑀡𑁂𑀭𑁄 𑀘, 𑀲𑀺𑀓𑁆𑀔𑀫𑀸𑀦𑀸 𑀘 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑀻;

𑀲𑀸𑀫𑀡𑁂𑀭𑀻𑀢𑀺 𑀓𑀣𑀺𑀢𑀸, 𑀧𑀜𑁆𑀘𑁂𑀢𑁂 𑀲𑀳𑀥𑀫𑁆𑀫𑀺𑀓𑀸.

𑀧𑀢𑁆𑀢𑁄 𑀢𑀺𑀘𑀻𑀯𑀭𑀁 𑀓𑀸𑀬, 𑀩𑀦𑁆𑀥𑀦𑀁 𑀯𑀸𑀲𑀺 𑀲𑀽𑀘𑀺 𑀘;

𑀧𑀭𑀺𑀲𑁆𑀲𑀸𑀯𑀦 𑀫𑀺𑀘𑁆𑀘𑁂𑀢𑁂, 𑀧𑀭𑀺𑀓𑁆𑀔𑀸𑀭𑀸’𑀝𑁆𑀞 𑀪𑀸𑀲𑀺𑀢𑀸.

𑀲𑀸𑀫𑀡𑁂𑀭𑁄 𑀘 𑀲𑀫𑀡𑀼, 𑀤𑁆𑀤𑁂𑀲𑁄 𑀘𑀸𑀣 𑀤𑀺𑀕𑀫𑁆𑀩𑀭𑁄;

𑀅𑀘𑁂𑀴𑀓𑁄 𑀦𑀺𑀕𑀡𑁆𑀞𑁄 𑀘, 𑀚𑀝𑀺𑀮𑁄 𑀢𑀼 𑀚𑀝𑀸𑀥𑀭𑁄.

𑀓𑀼𑀝𑀻𑀲𑀓𑀸𑀤𑀺𑀓𑀸 𑀘𑀢𑀼, 𑀢𑁆𑀢𑀺𑀁𑀲 𑀤𑁆𑀯𑀸𑀲𑀝𑁆𑀞𑀺 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑁄;

𑀇𑀢𑀺 𑀙𑀦𑁆𑀦𑀯𑀼𑀢𑀺 𑀏𑀢𑁂, 𑀧𑀸𑀲𑀡𑁆𑀟𑀸 𑀲𑀫𑁆𑀧𑀓𑀸𑀲𑀺𑀢𑀸.

𑀧𑀯𑀺𑀢𑁆𑀢𑁄 𑀧𑀬𑀢𑁄 𑀧𑀽𑀢𑁄, 𑀘𑀫𑁆𑀫𑀁 𑀢𑀼 𑀅𑀚𑀺𑀦𑀁 𑀧𑁆𑀬𑀣;

𑀤𑀦𑁆𑀢𑀧𑁄𑀡𑁄 𑀤𑀦𑁆𑀢𑀓𑀝𑁆𑀞𑀁, 𑀯𑀓𑁆𑀓𑀮𑁄 𑀯𑀸 𑀢𑀺𑀭𑀻𑀝𑀓𑀁.

𑀧𑀢𑁆𑀢𑁄 𑀧𑀸𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑀁𑀦𑀺𑀢𑁆𑀣𑀻, 𑀓𑀫𑀡𑁆𑀟𑀮𑀼 𑀢𑀼 𑀓𑀼𑀡𑁆𑀟𑀺𑀓𑀸;

𑀅𑀣𑀸𑀮𑀫𑁆𑀩𑀡𑀤𑀡𑁆𑀟𑀲𑁆𑀫𑀺𑀁, 𑀓𑀢𑁆𑀢𑀭𑀬𑀝𑁆𑀞𑀺 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀬𑀁 𑀤𑁂𑀳𑀲𑀸𑀥𑀦𑀸𑀧𑁂𑀓𑁆𑀔𑀁, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀓𑀫𑁆𑀫𑀫𑀬𑀁 𑀬𑀫𑁄;

𑀆𑀕𑀦𑁆𑀢𑀼𑀲𑀸𑀥𑀦𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀅𑀦𑀺𑀘𑁆𑀘𑀁 𑀦𑀺𑀬𑀫𑁄 𑀪𑀯𑁂.

𑀯𑁂𑀲𑁆𑀲𑁄 𑀘 𑀯𑁂𑀲𑀺𑀬𑀸𑀦𑁄 𑀣, 𑀚𑀻𑀯𑀦𑀁 𑀯𑀼𑀢𑁆𑀢𑀺 𑀚𑀻𑀯𑀺𑀓𑀸;

𑀆𑀚𑀻𑀯𑁄 𑀯𑀢𑁆𑀢𑀦𑀁 𑀘𑀸𑀣, 𑀓𑀲𑀺𑀓𑀫𑁆𑀫𑀁 𑀓𑀲𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀯𑀸𑀡𑀺𑀚𑁆𑀚𑀜𑁆𑀘 𑀯𑀡𑀺𑀚𑁆𑀚𑀸 𑀣, 𑀕𑁄𑀭𑀓𑁆𑀔𑀸 𑀧𑀲𑀼𑀧𑀸𑀮𑀦𑀁;

𑀯𑁂𑀲𑁆𑀲𑀲𑁆𑀲 𑀯𑀼𑀢𑁆𑀢𑀺𑀬𑁄 𑀢𑀺𑀲𑁆𑀲𑁄, 𑀕𑀳𑀝𑁆𑀞𑀸’𑀕𑀸𑀭𑀺𑀓𑀸 𑀕𑀺𑀳𑀺.

𑀔𑁂𑀢𑁆𑀢𑀸𑀚𑀻𑀯𑁄 𑀓𑀲𑁆𑀲𑀓𑁄 𑀣, 𑀔𑁂𑀢𑁆𑀢𑀁 𑀓𑁂𑀤𑀸𑀭 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀮𑁂𑀟𑁆𑀟𑀼’𑀢𑁆𑀢𑁄 𑀫𑀢𑁆𑀢𑀺𑀓𑀸𑀔𑀡𑁆𑀟𑁄, 𑀔𑀡𑀺𑀢𑁆𑀢𑀺’𑀢𑁆𑀣𑁆𑀬’𑀯𑀤𑀸𑀭𑀡𑀁.

𑀤𑀸𑀢𑁆𑀢𑀁 𑀮𑀯𑀺𑀢𑁆𑀢 𑀫𑀲𑀺𑀢𑀁 [‘‘𑀅𑀲𑀺𑀢’’ 𑀲𑀤𑁆𑀤𑁄 𑀧𑀼𑀁𑀦𑀧𑀼𑀁𑀲𑀓𑁂-𑁧𑁦𑁦𑁫-𑀕𑀸𑀣𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸], 𑀧𑀢𑁄𑀤𑁄 𑀢𑀼𑀢𑁆𑀢 𑀧𑀸𑀚𑀦𑀁;

𑀬𑁄𑀢𑁆𑀢𑀁 𑀢𑀼 𑀭𑀚𑁆𑀚𑀼 𑀭𑀲𑁆𑀫𑀺𑀢𑁆𑀣𑀻, 𑀨𑀸𑀮𑁄 𑀢𑀼 𑀓𑀲𑀓𑁄 𑀪𑀯𑁂.

𑀦𑀗𑁆𑀕𑀮𑀜𑁆𑀘 𑀳𑀮𑀁 𑀲𑀻𑀭𑁄, 𑀈𑀲𑀸 𑀦𑀗𑁆𑀕𑀮𑀤𑀡𑁆𑀟𑀓𑁄;

𑀲𑀫𑁆𑀫𑀸 𑀢𑀼 𑀬𑀼𑀕𑀓𑀻𑀮𑀲𑁆𑀫𑀺𑀁, 𑀲𑀻𑀢𑀸 𑀢𑀼 𑀳𑀮𑀧𑀤𑁆𑀥𑀢𑀺.

𑀫𑀼𑀕𑁆𑀕𑀸𑀤𑀺𑀓𑁂 ¶ 𑀧𑀭𑀡𑁆𑀡𑀜𑁆𑀘, 𑀧𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀁 𑀲𑀸𑀮𑀺𑀆𑀤𑀺𑀓𑁂;

𑀲𑀸𑀮𑀺 𑀯𑀻𑀳𑀺 𑀘 𑀓𑀼𑀤𑁆𑀭𑀽𑀲𑁄, 𑀕𑁄𑀥𑀼𑀫𑁄 𑀯𑀭𑀓𑁄 𑀬𑀯𑁄;

𑀓𑀗𑁆𑀕𑀽𑀢𑀺 𑀲𑀢𑁆𑀢 𑀥𑀜𑁆𑀜𑀸𑀦𑀺, 𑀦𑀻𑀯𑀸𑀭𑀸𑀤𑀻 𑀢𑀼 𑀢𑀩𑁆𑀪𑀺𑀤𑀸.

𑀅𑀣 𑀓𑀗𑁆𑀕𑀼 𑀧𑀺𑀬𑀗𑁆𑀕𑀼’𑀢𑁆𑀣𑀻, 𑀉𑀫𑁆𑀫𑀸 𑀢𑀼 𑀅𑀢𑀲𑀻 𑀪𑀯𑁂;

𑀓𑀺𑀝𑁆𑀞𑀜𑁆𑀘 𑀲𑀲𑁆𑀲𑀁 𑀥𑀜𑁆𑀜𑀜𑁆𑀘 [𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑀁 (𑀝𑀻.)], 𑀯𑀻𑀳𑀺 𑀣𑀫𑁆𑀩𑀓𑀭𑀻 [𑀣𑀫𑁆𑀪𑀓𑀭𑀻 (𑀓.)] 𑀭𑀺𑀢𑁄.

𑀓𑀡𑁆𑀟𑁄 𑀢𑀼 𑀦𑀸𑀴 𑀫𑀣 𑀲𑁄, 𑀧𑀮𑀸𑀮𑀁 𑀦𑀺𑀢𑁆𑀣𑀺 𑀦𑀺𑀧𑁆𑀨𑀮𑁄;

𑀪𑀼𑀲𑀁 𑀓𑀮𑀺𑀗𑁆𑀕𑀭𑁄 𑀘𑀸𑀣, 𑀣𑀼𑀲𑁄 𑀥𑀜𑁆𑀜𑀢𑁆𑀢𑀘𑁂 𑀣 𑀘.

𑀔𑀮𑁄 𑀘 𑀥𑀜𑁆𑀜𑀓𑀭𑀡𑀁, 𑀣𑀫𑁆𑀩𑁄 [𑀣𑀫𑁆𑀪𑁄 (𑀓.)] 𑀕𑀼𑀫𑁆𑀩𑁄 𑀢𑀺𑀡𑀸𑀤𑀺𑀦𑀁.

𑀅𑀬𑁄𑀕𑁆𑀕𑁄 𑀫𑀼𑀲𑀮𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀓𑀼𑀮𑁆𑀮𑁄 𑀲𑀼𑀧𑁆𑀧 𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀅𑀣𑁄’𑀤𑁆𑀥𑀦𑀜𑁆𑀘 𑀘𑀼𑀮𑁆𑀮𑀺’𑀢𑁆𑀣𑀻, 𑀓𑀺𑀮𑀜𑁆𑀚𑁄 𑀢𑀼 𑀓𑀝𑁄 𑀪𑀯𑁂.

𑀓𑀼𑀫𑁆𑀪𑀻’𑀢𑁆𑀣𑀻 𑀧𑀺𑀞𑀭𑁄 𑀓𑀼𑀡𑁆𑀟𑀁, 𑀔𑀴𑁄𑀧𑁆𑀬𑀼’𑀓𑁆𑀔𑀮𑀺 𑀣𑀸𑀮𑁆𑀬𑀼’𑀔𑀸;

𑀓𑁄𑀮𑀫𑁆𑀩𑁄 𑀘𑀸𑀣 𑀫𑀡𑀺𑀓𑀁, 𑀪𑀸𑀡𑀓𑁄 𑀘 𑀅𑀭𑀜𑁆𑀚𑀭𑁄.

𑀖𑀝𑁄 𑀤𑁆𑀯𑀻𑀲𑀼 𑀓𑀼𑀝𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀓𑀼𑀫𑁆𑀪𑁄 𑀓𑀮𑀲, 𑀯𑀸𑀭𑀓𑀸;

𑀓𑀁𑀲𑁄 𑀪𑀼𑀜𑁆𑀚𑀦𑀧𑀢𑁆𑀢𑁄 𑀣𑀸, 𑀫𑀢𑁆𑀢𑀁 𑀧𑀢𑁆𑀢𑁄 𑀘 𑀪𑀸𑀚𑀦𑀁.

𑀅𑀡𑁆𑀟𑀼𑀧𑀓𑀁 𑀘𑀼𑀫𑁆𑀩𑀝𑀓𑀁, 𑀲𑀭𑀸𑀯𑁄 𑀢𑀼 𑀘 𑀫𑀮𑁆𑀮𑀓𑁄;

𑀧𑀼𑀫𑁂 𑀓𑀝𑀘𑁆𑀙𑀼𑀤𑀩𑁆𑀩𑀺’𑀢𑁆𑀣𑀻, 𑀓𑀼𑀲𑀽𑀮𑁄 𑀓𑁄𑀝𑁆𑀞 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀲𑀸𑀓𑁄 𑀅𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀟𑀸𑀓𑁄, 𑀲𑀺𑀗𑁆𑀕𑀻𑀯𑁂𑀭𑀁𑀢𑀼 𑀅𑀤𑁆𑀤𑀓𑀁;

𑀫𑀳𑁄𑀲𑀥𑀁 𑀢𑀼 𑀢𑀁 𑀲𑀼𑀓𑁆𑀔𑀁, 𑀫𑀭𑀺𑀘𑀁 𑀢𑀼 𑀘 𑀓𑁄𑀮𑀓𑀁.

𑀲𑁄𑀯𑀻𑀭𑀁 𑀓𑀜𑁆𑀚𑀺𑀬𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀆𑀭𑀦𑀸𑀴𑀁 𑀣𑀼𑀲𑁄𑀤𑀓𑀁;

𑀥𑀜𑁆𑀜𑀫𑁆𑀩𑀺𑀮𑀁 𑀩𑀺𑀴𑀗𑁆𑀕𑁄 𑀣, 𑀮𑀯𑀡𑀁 𑀮𑁄𑀡 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀲𑀸𑀫𑀼𑀤𑁆𑀤𑀁 𑀲𑀺𑀦𑁆𑀥𑀯𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀓𑀸𑀴𑀮𑁄𑀡𑀁 𑀢𑀼 𑀉𑀩𑁆𑀪𑀺𑀤𑀁;

𑀩𑀺𑀴𑀓𑀁 [𑀩𑀺𑀴𑀸𑀮 (𑀓.)] 𑀘𑁂𑀢𑀺 𑀧𑀜𑁆𑀘𑁂𑀢𑁂, 𑀧𑀪𑁂𑀤𑀸 𑀮𑀯𑀡𑀲𑁆𑀲 𑀳𑀺.

𑀕𑀼𑀴𑁄 𑀘 𑀨𑀸𑀡𑀺𑀢𑀁 𑀔𑀡𑁆𑀟𑁄, 𑀫𑀘𑁆𑀙𑀡𑁆𑀟𑀻 𑀲𑀓𑁆𑀔𑀭𑀸 𑀇𑀢𑀺;

𑀇𑀫𑁂 𑀉𑀘𑁆𑀙𑀼𑀯𑀺𑀓𑀸𑀭𑀸 𑀣, 𑀕𑀼𑀴𑀲𑁆𑀫𑀺𑀁 𑀯𑀺𑀲𑀓𑀡𑁆𑀝𑀓𑀁.

𑀮𑀸𑀚𑀸 ¶ 𑀲𑀺𑀬𑀸’𑀓𑁆𑀔𑀢𑀁 𑀘𑀸𑀣, 𑀥𑀸𑀦𑀸 𑀪𑀝𑁆𑀞𑀬𑀯𑁂 𑀪𑀯𑁂;

𑀅𑀩𑀤𑁆𑀥𑀲𑀢𑁆𑀢𑀼 𑀫𑀦𑁆𑀣𑁄 𑀘, 𑀧𑀽𑀧𑀸’ 𑀧𑀽𑀧𑀸 𑀢𑀼 𑀧𑀺𑀝𑁆𑀞𑀓𑁄.

𑀪𑀢𑁆𑀢𑀓𑀸𑀭𑁄 𑀲𑀽𑀧𑀓𑀸𑀭𑁄, 𑀲𑀽𑀤𑁄 𑀆𑀴𑀸𑀭𑀺𑀓𑁄 𑀢𑀣𑀸;

𑀑𑀤𑀦𑀺𑀓𑁄 𑀘 𑀭𑀲𑀓𑁄, 𑀲𑀽𑀧𑁄 𑀢𑀼 𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀁 𑀪𑀯𑁂.

𑀑𑀤𑀦𑁄 𑀯𑀸 𑀓𑀼𑀭𑀁 𑀪𑀢𑁆𑀢𑀁, 𑀪𑀺𑀓𑁆𑀔𑀸 𑀘𑀸’𑀦𑁆𑀦 𑀫𑀣𑀸 𑀲𑀦𑀁;

𑀔𑀚𑁆𑀚𑀁 𑀢𑀼 𑀪𑁄𑀚𑁆𑀚 𑀮𑁂𑀬𑁆𑀬𑀸𑀦𑀺, 𑀧𑁂𑀬𑁆𑀬𑀦𑁆𑀢𑀺 𑀘𑀢𑀼𑀥𑀸’𑀲𑀦𑀁;

𑀫𑀡𑁆𑀟𑁄 𑀦𑀺𑀢𑁆𑀣𑀻𑀭𑀲𑀕𑁆𑀕𑀲𑁆𑀫𑀺𑀁, 𑀯𑀺𑀖𑀸𑀲𑁄 𑀪𑀼𑀢𑁆𑀢𑀲𑁂𑀲𑀓𑁂;

𑀯𑀺𑀖𑀸𑀲𑀸𑀤𑁄 𑀘 𑀤𑀫𑀓𑁄, 𑀧𑀺𑀧𑀸𑀲𑀸 𑀢𑀼 𑀘 𑀢𑀲𑁆𑀲𑀦𑀁.

𑀔𑀼𑀤𑁆𑀤𑀸 𑀚𑀺𑀖𑀘𑁆𑀙𑀸, 𑀫𑀁𑀲𑀲𑁆𑀲, 𑀧𑀝𑀺𑀘𑁆𑀙𑀸𑀤𑀦𑀺𑀬𑀁 𑀭𑀲𑁄;

𑀉𑀤𑁆𑀭𑁂𑀓𑁄 𑀘𑁂𑀯 𑀉𑀕𑁆𑀕𑀸𑀭𑁄, 𑀲𑁄𑀳𑀺𑀘𑁆𑀘𑀁 𑀢𑀺𑀢𑁆𑀢𑀺 𑀢𑀧𑁆𑀧𑀦𑀁.

𑀓𑀸𑀫𑀁 𑀢𑁆𑀯𑀺𑀝𑁆𑀞𑀁 𑀦𑀺𑀓𑀸𑀫𑀜𑁆𑀘, 𑀧𑀭𑀺𑀬𑀢𑁆𑀢𑀁 𑀬𑀣𑀘𑁆𑀙𑀺𑀢𑀁;

𑀓𑀬𑀯𑀺𑀓𑁆𑀓𑀬𑀺𑀓𑁄 𑀲𑀢𑁆𑀣,𑀯𑀸𑀳𑀸’ 𑀧𑀡𑀺𑀓 𑀯𑀸𑀡𑀺𑀚𑀸.

𑀉𑀢𑁆𑀢𑀫𑀡𑁆𑀡𑁄 𑀘 𑀥𑀦𑀺𑀓𑁄, 𑀥𑀫𑀡𑁆𑀡𑁄 𑀢𑀼 𑀇𑀡𑀸𑀬𑀺𑀓𑁄.

𑀉𑀤𑁆𑀥𑀸𑀭𑁄 𑀢𑀼 𑀇𑀡𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀫𑀽𑀮𑀁 𑀢𑀼 𑀧𑀸𑀪𑀢𑀁 𑀪𑀯𑁂;

𑀲𑀘𑁆𑀘𑀸𑀧𑀦𑀁 𑀲𑀘𑁆𑀘𑀁𑀓𑀸𑀭𑁄, 𑀯𑀺𑀓𑁆𑀓𑁂𑀬𑁆𑀬𑀁 𑀧𑀡𑀺𑀬𑁆𑀬𑀁 𑀢𑀺𑀲𑀼.

𑀧𑀝𑀺𑀤𑀸𑀦𑀁 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑁄, 𑀦𑁆𑀬𑀸𑀲𑁄 𑀢𑀽’𑀧𑀦𑀺𑀥𑀻 𑀭𑀺𑀢𑁄;

𑀅𑀝𑁆𑀞𑀸𑀭𑀲𑀦𑁆𑀢𑀸 𑀲𑀗𑁆𑀔𑁆𑀬𑁂𑀬𑁆𑀬𑁂, 𑀲𑀗𑁆𑀔𑁆𑀬𑀸 𑀏𑀓𑀸𑀤𑀬𑁄 𑀢𑀺𑀲𑀼;

𑀲𑀗𑁆𑀔𑁆𑀬𑀸𑀦𑁂 𑀢𑀼 𑀘 𑀲𑀗𑁆𑀔𑁆𑀬𑁂𑀬𑁆𑀬𑁂, 𑀏𑀓𑀢𑁆𑀢𑁂 𑀯𑀻𑀲𑀢𑀸𑀤𑀬𑁄;

𑀯𑀕𑁆𑀕𑀪𑁂𑀤𑁂 𑀩𑀳𑀼𑀢𑁆𑀢𑁂𑀧𑀺, 𑀢𑀸 𑀆𑀦𑀯𑀼𑀢𑀺 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀲𑀢𑀁 𑀲𑀳𑀲𑁆𑀲𑀁 𑀦𑀺𑀬𑀼𑀢𑀁 [𑀦𑀳𑀼𑀢𑀁-𑀦𑀬𑀼𑀢𑀁 (𑀓𑀢𑁆𑀣𑀘𑀺)], 𑀮𑀓𑁆𑀔𑀁 𑀓𑁄𑀝𑀺 𑀧𑀓𑁄𑀝𑀺𑀬𑁄;

𑀓𑁄𑀝𑀺𑀧𑀓𑁄𑀝𑀺 𑀦𑀳𑀼𑀢𑀁, 𑀢𑀣𑀸 𑀦𑀺𑀦𑁆𑀦𑀳𑀼𑀢𑀫𑁆𑀧𑀺 𑀘.

𑀅𑀓𑁆𑀔𑁄𑀪𑀦𑀻𑀢𑁆𑀣𑀺𑀬𑀁 ¶ [𑀅𑀓𑁆𑀔𑁄𑀪𑀺𑀡𑀻 (𑀓.)] 𑀩𑀺𑀦𑁆𑀤𑀼, 𑀅𑀩𑁆𑀩𑀼𑀤𑀜𑁆𑀘 𑀦𑀺𑀭𑀩𑁆𑀩𑀼𑀤𑀁;

𑀅𑀳𑀳𑀁 𑀅𑀩𑀩𑀁 𑀘𑁂𑀯𑀸, 𑀝𑀝𑀁 𑀲𑁄𑀕𑀦𑁆𑀥𑀺 𑀓𑀼𑀧𑁆𑀧𑀮𑀁.

𑀓𑀼𑀫𑀼𑀤𑀁 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀜𑁆𑀘, 𑀧𑀤𑀼𑀫𑀁 𑀓𑀣𑀸𑀦𑀫𑁆𑀧𑀺 𑀘;

𑀫𑀳𑀸𑀓𑀣𑀸𑀦𑀸’𑀲𑀗𑁆𑀔𑁆𑀬𑁂𑀬𑁆𑀬𑀸, 𑀦𑀺’𑀘𑁆𑀘𑁂𑀢𑀸𑀲𑀼 𑀲𑀢𑀸𑀤𑀺 𑀘.

𑀓𑁄𑀝𑁆𑀬𑀸𑀤𑀺𑀓𑀁 𑀤𑀲𑀕𑀼𑀡𑀁, 𑀲𑀢𑀮𑀓𑁆𑀔𑀕𑀼𑀡𑀁 𑀓𑀫𑀸;

𑀘𑀢𑀼𑀢𑁆𑀣𑁄’𑀟𑁆𑀠𑁂𑀦 𑀅𑀟𑁆𑀠𑀼𑀟𑁆𑀠𑁄,

𑀅𑀟𑁆𑀠𑀢𑁂𑀬𑁆𑀬𑁄 𑀤𑀺𑀬𑀟𑁆𑀠𑁄 𑀢𑀼,

𑀢𑀼𑀮𑀸, 𑀧𑀢𑁆𑀣, 𑀗𑁆𑀕𑀼𑀮𑀺, 𑀯𑀲𑀸, 𑀢𑀺𑀥𑀸 𑀫𑀸𑀦 𑀫𑀣𑁄 𑀲𑀺𑀬𑀸.

𑀤𑁆𑀯𑁂 𑀕𑀼𑀜𑁆𑀚𑀸 𑀫𑀸𑀲𑀓𑁄 𑀪𑀯𑁂;

𑀤𑁆𑀯𑁂 𑀅𑀓𑁆𑀔𑀸 𑀫𑀸𑀲𑀓𑀸 𑀧𑀜𑁆𑀘, 𑀓𑁆𑀔𑀸𑀦𑀁 𑀥𑀭𑀡𑀫𑀝𑁆𑀞𑀓𑀁.

𑀲𑀼𑀯𑀡𑁆𑀡𑁄 𑀧𑀜𑁆𑀘𑀥𑀭𑀡𑀁, 𑀦𑀺𑀓𑁆𑀔𑀁 𑀢𑁆𑀯𑀦𑀺𑀢𑁆𑀣𑀺 𑀧𑀜𑁆𑀘 𑀢𑁂;

𑀧𑀸𑀤𑁄 𑀪𑀸𑀕𑁂 𑀘𑀢𑀼𑀢𑁆𑀣𑁂 𑀣, 𑀥𑀭𑀡𑀸𑀦𑀺 𑀧𑀮𑀁 𑀤𑀲.

𑀢𑀼𑀮𑀸 𑀧𑀮𑀲𑀢𑀁 𑀘𑀸𑀣, 𑀪𑀸𑀭𑁄 𑀯𑀻𑀲𑀢𑀺 𑀢𑀸 𑀢𑀼𑀮𑀸;

𑀅𑀣𑁄 𑀓𑀳𑀸𑀧𑀡𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀓𑀣𑁆𑀬𑀢𑁂 𑀓𑀭𑀺𑀲𑀸𑀧𑀡𑁄.

𑀆𑀴𑁆𑀳𑀓𑁄 𑀘𑀢𑀼𑀭𑁄 𑀧𑀢𑁆𑀣𑀸, 𑀤𑁄𑀡𑀁 𑀯𑀸𑀘𑀢𑀼𑀭𑀸’𑀴𑁆𑀳𑀓𑀁.

𑀫𑀸𑀦𑀺𑀓𑀸 𑀘𑀢𑀼𑀭𑁄 𑀤𑁄𑀡𑀸, 𑀔𑀸𑀭𑀻𑀢𑁆𑀣𑀻 𑀘𑀢𑀼𑀫𑀸𑀦𑀺𑀓𑀸;

𑀆𑀴𑁆𑀳𑀓𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀢𑀼𑀫𑁆𑀪𑁄, 𑀧𑀢𑁆𑀣𑁄𑀢𑀼 𑀦𑀸𑀴𑀺 𑀦𑀸𑀭𑀺𑀬𑀁;

𑀤𑀩𑁆𑀩𑀁 𑀯𑀺𑀢𑁆𑀢𑀁 𑀲𑀸𑀧𑀢𑁂𑀬𑁆𑀬𑀁, 𑀯𑀲𑁆𑀯’𑀢𑁆𑀣𑁄 𑀯𑀺𑀪𑀯𑁄 𑀪𑀯𑁂.

𑀓𑁄𑀲𑁄 ¶ 𑀳𑀺𑀭𑀜𑁆𑀜𑀜𑁆𑀘 𑀓𑀢𑀸, 𑀓𑀢𑀁 𑀓𑀜𑁆𑀘𑀦, 𑀭𑀽𑀧𑀺𑀬𑀁;

𑀓𑀼𑀧𑁆𑀧𑀁 𑀢𑀤𑀜𑁆𑀜𑀁 𑀢𑀫𑁆𑀩𑀸𑀤𑀺, 𑀭𑀽𑀧𑀺𑀬𑀁 𑀤𑁆𑀯𑀬 𑀫𑀸𑀳𑀢𑀁.

𑀲𑀼𑀯𑀡𑁆𑀡𑀁 𑀓𑀦𑀓𑀁 𑀚𑀸𑀢, 𑀭𑀽𑀧𑀁 𑀲𑁄𑀡𑁆𑀡𑀜𑁆𑀘 𑀓𑀜𑁆𑀘𑀦𑀁;

𑀲𑀢𑁆𑀣𑀼𑀯𑀡𑁆𑀡𑁄 𑀳𑀭𑀻 𑀓𑀫𑁆𑀩𑀼, 𑀘𑀸𑀭𑀼 𑀳𑁂𑀫𑀜𑁆𑀘 𑀳𑀸𑀝𑀓𑀁.

𑀢𑀧𑀦𑀺𑀬𑀁 𑀳𑀺𑀭𑀜𑁆𑀜𑀁 𑀢, 𑀩𑁆𑀪𑁂𑀤𑀸 𑀘𑀸𑀫𑀻𑀓𑀭𑀫𑁆𑀧𑀺 𑀘;

𑀲𑀸𑀢𑀓𑀼𑀫𑁆𑀪𑀁 𑀢𑀣𑀸 𑀚𑀫𑁆𑀩𑀼, 𑀦𑀤𑀁 𑀲𑀺𑀗𑁆𑀕𑀻 𑀘 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀭𑀽𑀧𑀺𑀬𑀁 𑀭𑀚𑀢𑀁 𑀲𑀚𑁆𑀛𑀼, 𑀭𑀽𑀧𑀻 𑀲𑀚𑁆𑀛𑀁 𑀅𑀣𑁄 𑀯𑀲𑀼;

𑀭𑀢𑀦𑀜𑁆𑀘 𑀫𑀡𑀺 𑀤𑁆𑀯𑀻𑀲𑀼, 𑀧𑀼𑀧𑁆𑀨𑀭𑀸𑀕𑀸𑀤𑀻 𑀢𑀩𑁆𑀪𑀺𑀤𑀸.

𑀲𑀼𑀯𑀡𑁆𑀡𑀁 𑀭𑀚𑀢𑀁 𑀫𑀼𑀢𑁆𑀢𑀸, 𑀫𑀡𑀺 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀸𑀦𑀺 𑀘;

𑀯𑀚𑀺𑀭𑀜𑁆𑀘 𑀧𑀯𑀸𑀴𑀦𑁆𑀢𑀺, 𑀲𑀢𑁆𑀢𑀸’𑀳𑀼 𑀭𑀢𑀦𑀸𑀦𑀺’ 𑀫𑁂.

𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀓𑁄 𑀘 𑀧𑀤𑀼𑀫, 𑀭𑀸𑀕𑁄 𑀭𑀢𑁆𑀢𑀫𑀡𑀺 𑀧𑁆𑀬𑀣;

𑀯𑀁𑀲𑀯𑀡𑁆𑀡𑁄 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀁, 𑀧𑀯𑀸𑀴𑀁 𑀯𑀸 𑀘 𑀯𑀺𑀤𑁆𑀤𑀼𑀫𑁄.

𑀫𑀲𑀸𑀭𑀕𑀮𑁆𑀮𑀁 𑀓𑀩𑀭𑀫𑀡𑀺, 𑀅𑀣 𑀫𑀼𑀢𑁆𑀢𑀸 𑀘 𑀫𑀼𑀢𑁆𑀢𑀺𑀓𑀁;

𑀭𑀻𑀢𑀺 [𑀭𑀻𑀭𑀻 (𑀝𑀻.)] 𑀢𑁆𑀣𑀻 𑀆𑀭𑀓𑀽𑀝𑁄 𑀯𑀸, 𑀅𑀫𑀮𑀁 𑀢𑁆𑀯’𑀩𑁆𑀪𑀓𑀁 𑀪𑀯𑁂.

𑀓𑀸𑀴𑀢𑀺𑀧𑀼 𑀢𑀼 𑀲𑀻𑀲𑀜𑁆𑀘, 𑀳𑀭𑀺𑀢𑀸𑀮𑀁 𑀢𑀼 𑀧𑀻𑀢𑀦𑀁.

𑀘𑀺𑀦𑀧𑀺𑀝𑁆𑀞𑀜𑁆𑀘 𑀲𑀺𑀦𑁆𑀤𑀽𑀭𑀁, 𑀅𑀣 𑀢𑀽𑀮𑁄 𑀢𑀣𑀸 𑀧𑀺𑀘𑀼;

𑀔𑀼𑀤𑁆𑀤𑀚𑀁 𑀢𑀼 𑀫𑀥𑀼 𑀔𑀼𑀤𑁆𑀤𑀁, 𑀫𑀥𑀼𑀘𑁆𑀙𑀺𑀝𑁆𑀞𑀁 𑀢𑀼 𑀲𑀺𑀢𑁆𑀣𑀓𑀁.

𑀉𑀲𑀪𑁄 𑀩𑀮𑀻𑀩𑀤𑁆𑀥𑁄 [𑀩𑀮𑀺𑀩𑀤𑁆𑀤 (𑀓.)] 𑀘, 𑀕𑁄𑀡𑁄 𑀕𑁄𑀯𑀲𑀪𑁄 𑀯𑀼𑀲𑁄.

𑀯𑀼𑀤𑁆𑀥𑁄 𑀚𑀭𑀕𑁆𑀕𑀯𑁄 𑀲𑁄 𑀣, 𑀤𑀫𑁆𑀫𑁄 𑀯𑀘𑁆𑀙𑀢𑀭𑁄 𑀲𑀫𑀸;

𑀥𑀼𑀭𑀯𑀸𑀳𑀻 𑀢𑀼 𑀥𑁄𑀭𑀬𑁆𑀳𑁄, 𑀕𑁄𑀯𑀺𑀦𑁆𑀤𑁄 𑀥𑀺𑀓𑀢𑁄 𑀕𑀯𑀁.

𑀯𑀳𑁄 𑀘 𑀔𑀦𑁆𑀥𑀤𑁂𑀲𑁄 𑀣, 𑀓𑀓𑀼𑀥𑁄 [𑀓𑀓𑀼𑀤𑁄 (𑀓.)] 𑀓𑀓𑀼 𑀯𑀼𑀘𑁆𑀘𑀢𑁂;

𑀅𑀣𑁄 𑀯𑀺𑀲𑀸𑀡𑀁 𑀲𑀺𑀗𑁆𑀕𑀜𑁆𑀘, 𑀭𑀢𑁆𑀢𑀕𑀸𑀯𑀻 𑀢𑀼 𑀭𑁄𑀳𑀺𑀡𑀻.

𑀕𑀸𑀯𑀻 𑀘 𑀲𑀺𑀗𑁆𑀕𑀺𑀦𑀻 𑀕𑁄 𑀘, 𑀯𑀜𑁆𑀛𑀸 𑀢𑀼 𑀓𑀣𑁆𑀬𑀢𑁂 𑀯𑀲𑀸;

𑀦𑀯𑀧𑁆𑀧𑀲𑀽𑀢𑀺𑀓𑀸 𑀥𑁂𑀦𑀼, 𑀯𑀘𑁆𑀙𑀓𑀸𑀫𑀸 𑀢𑀼 𑀯𑀘𑁆𑀙𑀮𑀸.

𑀕𑀕𑁆𑀕𑀭𑀻 ¶ 𑀫𑀦𑁆𑀣𑀦𑀻𑀢𑁆𑀣𑀻 𑀤𑁆𑀯𑁂, 𑀲𑀦𑁆𑀤𑀸𑀦𑀁 𑀤𑀸𑀫𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀕𑁄𑀫𑀺𑀴𑁆𑀳𑁄 𑀕𑁄𑀫𑀬𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀅𑀣𑁄 𑀲𑀧𑁆𑀧𑀺 𑀖𑀢𑀁 𑀪𑀯𑁂.

𑀦𑀯𑀼𑀤𑁆𑀥𑀝𑀁 𑀢𑀼 𑀦𑁄𑀦𑀻𑀢𑀁, 𑀤𑀫𑀺𑀫𑀡𑁆𑀟𑀁 𑀢𑀼 𑀫𑀢𑁆𑀣𑀼 𑀘,

𑀔𑀻𑀭𑀁 𑀤𑀼𑀤𑁆𑀥𑀁 𑀧𑀬𑁄 𑀣𑀜𑁆𑀜𑀁, 𑀢𑀓𑁆𑀓𑀁 𑀢𑀼 𑀫𑀣𑀺𑀢𑀁 𑀧𑁆𑀬𑀣.

𑀔𑀻𑀭𑀁 𑀤𑀥𑀺 𑀖𑀢𑀁 𑀢𑀓𑁆𑀓𑀁, 𑀦𑁄𑀦𑀻𑀢𑀁 𑀧𑀜𑁆𑀘 𑀕𑁄𑀭𑀲𑀸;

𑀉𑀭𑀩𑁆𑀪𑁄 𑀫𑁂𑀡𑁆𑀟 𑀫𑁂𑀲𑀸 𑀘, 𑀉𑀭𑀡𑁄 𑀅𑀯𑀺 𑀏𑀴𑀓𑁄.

𑀕𑀤𑁆𑀭𑀪𑁄 𑀢𑀼 𑀔𑀭𑁄 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀉𑀭𑀡𑀻 𑀢𑀼 𑀅𑀚𑀻 𑀅𑀚𑀸.

𑀲𑀼𑀤𑁆𑀤𑁄’𑀦𑁆𑀢𑀯𑀡𑁆𑀡𑁄 𑀯𑀲𑀮𑁄, 𑀲𑀁𑀓𑀺𑀡𑁆𑀡𑀸 𑀫𑀸𑀕𑀥𑀸𑀤𑀬𑁄;

𑀫𑀸𑀕𑀥𑁄 𑀲𑀼𑀤𑁆𑀤𑀔𑀢𑁆𑀢𑀸𑀚𑁄, 𑀉𑀕𑁆𑀕𑁄 𑀲𑀼𑀤𑁆𑀤𑀸𑀬 𑀔𑀢𑁆𑀢𑀚𑁄.

𑀤𑁆𑀯𑀺𑀚𑀸𑀔𑀢𑁆𑀢𑀺𑀬𑀚𑁄 𑀲𑀽𑀢𑁄, 𑀓𑀸𑀭𑀼𑀢𑀼 𑀲𑀺𑀧𑁆𑀧𑀺𑀓𑁄𑀧𑀼𑀫𑁂;

𑀲𑀗𑁆𑀖𑀸𑀢𑁄𑀢𑀼 𑀲𑀚𑀸𑀢𑀻𑀦𑀁, 𑀢𑁂𑀲𑀁 𑀲𑁂𑀡𑀻 𑀤𑁆𑀯𑀺𑀲𑀼𑀘𑁆𑀘𑀢𑁂.

𑀢𑀘𑁆𑀙𑀓𑁄 𑀢𑀦𑁆𑀢𑀯𑀸𑀬𑁄 𑀘, 𑀭𑀚𑀓𑁄 𑀘 𑀦𑀳𑀸𑀧𑀺𑀢𑁄;

𑀧𑀜𑁆𑀘𑀫𑁄 𑀘𑀫𑁆𑀫𑀓𑀸𑀭𑁄𑀢𑀺, 𑀓𑀸𑀭𑀯𑁄 𑀧𑀜𑁆𑀘𑀺𑀫𑁂 𑀲𑀺𑀬𑀼𑀁.

𑀢𑀘𑁆𑀙𑀓𑁄 𑀯𑀟𑁆𑀠𑀓𑀻 𑀫𑀢𑁄, 𑀧𑀮𑀕𑀡𑁆𑀟𑁄 𑀣𑀧𑀢𑁆𑀬𑀧𑀺;

𑀭𑀣𑀓𑀸𑀭𑁄 𑀣 𑀲𑀼𑀯𑀡𑁆𑀡, 𑀓𑀸𑀭𑁄 𑀦𑀸𑀴𑀺𑀦𑁆𑀥𑀫𑁄 𑀪𑀯𑁂.

𑀘𑀫𑁆𑀫𑀓𑀸𑀭𑁄 𑀭𑀣𑀓𑀸𑀭𑁄, 𑀓𑀧𑁆𑀧𑀓𑁄 𑀢𑀼 𑀦𑀳𑀸𑀧𑀺𑀢𑁄;

𑀭𑀗𑁆𑀕𑀸𑀚𑀻𑀯𑁄 𑀘𑀺𑀢𑁆𑀢𑀓𑀸𑀭𑁄, 𑀧𑀼𑀓𑁆𑀓𑀼𑀲𑁄 𑀧𑀼𑀧𑁆𑀨𑀙𑀟𑁆𑀟𑀓𑁄.

𑀯𑁂𑀦𑁄 𑀯𑀺𑀮𑀻𑀯𑀓𑀸𑀭𑁄 𑀘, 𑀦𑀴𑀓𑀸𑀭𑁄 𑀲𑀫𑀸 𑀢𑀬𑁄;

𑀦𑀺𑀦𑁆𑀦𑁂𑀚𑀓𑁄 𑀘 𑀭𑀚𑀓𑁄, 𑀦𑁂𑀢𑁆𑀢𑀺𑀓𑁄 𑀉𑀤𑀳𑀸𑀭𑀓𑁄;

𑀯𑀻𑀡𑀸𑀯𑀸𑀤𑀻 𑀯𑁂𑀡𑀺𑀓𑁄 𑀣, 𑀉𑀲𑀼𑀓𑀸𑀭𑁄’ 𑀲𑀼𑀯𑀟𑁆𑀠𑀓𑀻.

𑀧𑀸𑀡𑀺𑀯𑀸𑀤𑁄 𑀢𑀼 𑀧𑀸𑀡𑀺𑀖𑁄 [𑀧𑀸𑀡𑀺𑀬𑁄 (𑀓𑀢𑁆𑀣𑀘𑀺)];

𑀧𑀽𑀧𑀺𑀬𑁄 𑀧𑀽𑀧𑀧𑀡𑀺𑀬𑁄, 𑀲𑁄𑀡𑁆𑀟𑀺𑀓𑁄 𑀫𑀚𑁆𑀚𑀯𑀺𑀓𑁆𑀓𑀬𑀻.

𑀫𑀸𑀬𑀸 𑀢𑀼 𑀲𑀫𑁆𑀩𑀭𑀻 𑀫𑀸𑀬𑀸, 𑀓𑀸𑀭𑁄 𑀢𑀼 𑀇𑀦𑁆𑀤𑀚𑀸𑀮𑀺𑀓𑁄;

𑀑𑀭𑀩𑁆𑀪𑀺𑀓𑀸 𑀲𑀽𑀓𑀭𑀺𑀓𑀸, 𑀫𑀸𑀕𑀯𑀺𑀓𑀸 𑀢𑁂 𑀘 𑀲𑀸𑀓𑀼𑀡𑀺𑀓𑀸;

𑀳𑀦𑁆𑀢𑁆𑀯𑀸 𑀚𑀻𑀯𑀦𑁆𑀢𑁂’𑀴𑀓, 𑀲𑀽𑀓𑀭, 𑀫𑀺𑀕, 𑀧𑀓𑁆𑀔𑀺𑀦𑁄 𑀓𑀫𑀢𑁄.

𑀯𑁂𑀢𑀦𑀺𑀓𑁄 𑀢𑀼 𑀪𑀢𑀓𑁄, 𑀓𑀫𑁆𑀫𑀓𑀭𑁄 𑀣 𑀓𑀺𑀁 𑀓𑀭𑁄;

𑀤𑀸𑀲𑁄 𑀘 𑀘𑁂𑀝𑀓𑁄 𑀧𑁂𑀲𑁆𑀲𑁄, 𑀪𑀘𑁆𑀘𑁄 𑀘 𑀧𑀭𑀺𑀘𑀸𑀭𑀺𑀓𑁄.

𑀅𑀦𑁆𑀢𑁄𑀚𑀸𑀢𑁄 𑀥𑀦𑀓𑁆𑀓𑀻𑀢𑁄, 𑀤𑀸𑀲𑀩𑁆𑀬𑁄’𑀧𑀕𑀢𑁄 𑀲𑀬𑀁;

𑀤𑀸𑀲𑀸 𑀓𑀭𑀫𑀭𑀸𑀦𑀻𑀢𑁄, 𑀘𑁆𑀘𑁂𑀯𑀁 𑀢𑁂 𑀘𑀢𑀼𑀥𑀸 𑀲𑀺𑀬𑀼𑀁.

𑀲𑀧𑀸𑀓𑁄 𑀘𑁂𑀯 𑀘𑀡𑁆𑀟𑀸𑀮𑁄, 𑀫𑀸𑀢𑀗𑁆𑀕𑁄 𑀲𑀧𑀘𑁄 𑀪𑀯𑁂;

𑀢𑀩𑁆𑀪𑁂𑀤𑀸 𑀫𑀺𑀮𑀓𑁆𑀔𑀚𑀸𑀢𑀻, 𑀓𑀺𑀭𑀸𑀢, 𑀲𑀯𑀭𑀸𑀤𑀬𑁄.

𑀲𑀸𑀭𑀫𑁂𑀬𑁆𑀬𑁄 𑀘 𑀲𑀼𑀦𑀔𑁄, 𑀲𑀼𑀦𑁄 𑀲𑁄𑀡𑁄 𑀘 𑀓𑀼𑀓𑁆𑀓𑀼𑀭𑁄.

𑀉𑀫𑁆𑀫𑀢𑁆𑀢𑀸𑀤𑀺𑀢 𑀫𑀸𑀧𑀦𑁆𑀦𑁄, 𑀅𑀴𑀓𑁆𑀓𑁄𑀢𑀺 𑀲𑀼𑀦𑁄 𑀫𑀢𑁄.

𑀲𑀸𑀩𑀦𑁆𑀥𑀦𑀁 𑀢𑀼 𑀕𑀤𑁆𑀤𑀽𑀮𑁄, 𑀤𑀻𑀧𑀓𑁄 𑀢𑀼 𑀘 𑀘𑁂𑀢𑀓𑁄;

𑀩𑀦𑁆𑀥𑀦𑀁 𑀕𑀡𑁆𑀞𑀺 𑀧𑀸𑀲𑁄 𑀣, 𑀯𑀸𑀕𑀼𑀭𑀸 [𑀯𑀸𑀓𑀭𑀸 (𑀲𑀻. 𑀝𑀻.)] 𑀫𑀺𑀕𑀩𑀦𑁆𑀥𑀦𑀻.

𑀣𑀺𑀬𑀁 𑀓𑀼𑀯𑁂𑀡𑀻 𑀓𑀼𑀫𑀻𑀦𑀁, 𑀆𑀦𑀬𑁄 𑀚𑀸𑀮 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀆𑀖𑀸𑀢𑀦𑀁 𑀯𑀥𑀝𑁆𑀞𑀸𑀦𑀁, 𑀲𑀽𑀦𑀸 𑀢𑀼 𑀅𑀥𑀺𑀓𑁄𑀝𑁆𑀝𑀦𑀁.

𑀲𑀼𑀢𑁆𑀢𑀁 𑀢𑀦𑁆𑀢𑀼 𑀧𑀼𑀫𑁂 𑀢𑀦𑁆𑀢𑀁, 𑀧𑁄𑀢𑁆𑀣𑀁 𑀮𑁂𑀧𑁆𑀬𑀸𑀤𑀺𑀓𑀫𑁆𑀫𑀦𑀺;

𑀧𑀜𑁆𑀘𑀸𑀮𑀺𑀓𑀸 𑀧𑁄𑀢𑁆𑀣𑀮𑀺𑀓𑀸, 𑀯𑀢𑁆𑀣𑀤𑀦𑁆𑀢𑀸𑀤𑀺𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸.

𑀉𑀕𑁆𑀖𑀸𑀝𑀦𑀁 𑀖𑀝𑀻𑀬𑀦𑁆𑀢𑀁, 𑀓𑀽𑀧𑀫𑁆𑀩𑀼𑀩𑁆𑀩𑀸𑀳𑀦𑀁 𑀪𑀯𑁂;

𑀫𑀜𑁆𑀚𑀽𑀲𑀸 𑀧𑁂𑀴𑀸 𑀧𑀺𑀝𑀓𑁄, 𑀢𑁆𑀯𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀧𑀘𑁆𑀙𑀺 𑀧𑁂𑀝𑀓𑁄.

𑀩𑁆𑀬𑀸𑀪𑀗𑁆𑀕𑀻 𑀢𑁆𑀯𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀓𑀸𑀚𑁄, 𑀲𑀺𑀓𑁆𑀓𑀸 𑀢𑁆𑀯𑀢𑁆𑀭𑀸’𑀯𑀮𑀫𑁆𑀩𑀦𑀁;

𑀉𑀧𑀸𑀳𑀦𑁄 𑀯𑀸 𑀧𑀸𑀤𑀼’𑀢𑁆𑀣𑀻, 𑀢𑀩𑁆𑀪𑁂𑀤𑀸 𑀧𑀸𑀤𑀼𑀓𑀸 𑀧𑁆𑀬𑀣.

𑀯𑀭𑀢𑁆𑀢𑀸 𑀯𑀤𑁆𑀥𑀺𑀓𑀸 𑀦𑀤𑁆𑀥𑀺, 𑀪𑀲𑁆𑀢𑀸 𑀘𑀫𑁆𑀫𑀧𑀲𑀺𑀩𑁆𑀩𑀓𑀁;

𑀲𑁄𑀡𑁆𑀡𑀸𑀤𑁆𑀬𑀸𑀯𑀢𑁆𑀢𑀦𑀻 𑀫𑀽𑀲𑀸,

𑀓𑀫𑁆𑀫𑀸𑀭𑀪𑀡𑁆𑀟𑀸 𑀲𑀡𑁆𑀟𑀸𑀲𑁄, 𑀫𑀼𑀝𑁆𑀞𑁆𑀬𑀸’𑀥𑀺𑀓𑀭𑀡𑀻𑀢𑁆𑀣𑀻𑀬𑀁;

𑀢𑀩𑁆𑀪𑀲𑁆𑀢𑀸 𑀕𑀕𑁆𑀕𑀭𑀻 𑀦𑀸𑀭𑀻, 𑀲𑀢𑁆𑀢𑀁 𑀢𑀼 𑀧𑀺𑀧𑁆𑀨𑀮𑀁 𑀪𑀯𑁂.

𑀔𑀭𑁄 𑀘 𑀓𑀓𑀘𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀲𑀺𑀧𑁆𑀧𑀁 𑀓𑀫𑁆𑀫𑀁 𑀓𑀮𑀸𑀤𑀺𑀓𑀁.

𑀧𑀝𑀺𑀫𑀸 𑀧𑀝𑀺𑀩𑀺𑀫𑁆𑀩𑀜𑁆𑀘, 𑀩𑀺𑀫𑁆𑀩𑁄 𑀧𑀝𑀺𑀦𑀺𑀥𑀻𑀭𑀺𑀢𑁄;

𑀢𑀻𑀲𑀼 𑀲𑀫𑁄 𑀧𑀝𑀺𑀪𑀸𑀕𑁄, 𑀲𑀦𑁆𑀦𑀺𑀓𑀸𑀲𑁄 𑀲𑀭𑀺𑀓𑁆𑀔𑀓𑁄.

𑀑𑀧𑀫𑁆𑀫 𑀫𑀼𑀧𑀫𑀸𑀦𑀁 𑀘𑀼, 𑀧𑀫𑀸 𑀪𑀢𑀺 𑀢𑀼 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀦𑀺𑀩𑁆𑀩𑁂𑀲𑁄 𑀯𑁂𑀢𑀦𑀁 𑀫𑀽𑀮𑁆𑀬𑀁, 𑀚𑀽𑀢𑀁 𑀢𑁆𑀯𑀦𑀺𑀢𑁆𑀣𑀺 𑀓𑁂𑀢𑀯𑀁;

𑀥𑀼𑀢𑁆𑀢𑁄’𑀓𑁆𑀔𑀥𑀼𑀢𑁆𑀢𑁄 𑀓𑀺𑀢𑀯𑁄, 𑀚𑀽𑀢𑀓𑀸𑀭, 𑀓𑁆𑀔𑀤𑁂𑀯𑀺𑀦𑁄.

𑀧𑀸𑀝𑀺𑀪𑁄𑀕𑁄𑀢𑀼 𑀧𑀝𑀺𑀪𑀽, 𑀅𑀓𑁆𑀔𑁄 𑀢𑀼 𑀧𑀸𑀲𑀓𑁄 𑀪𑀯𑁂;

𑀧𑀼𑀫𑁂𑀯𑀸’ 𑀝𑁆𑀞𑀧𑀤𑀁 [𑀅𑀝𑁆𑀞𑀸𑀧𑀤𑀁 (𑀝𑀻. 𑀲𑀻.)] 𑀲𑀸𑀭𑀺, 𑀨𑀮𑀓𑁂 𑀣 𑀧𑀡𑁄, 𑀩𑁆𑀪𑀼𑀢𑁄.

𑀓𑀺𑀡𑁆𑀡𑀁 ¶ 𑀢𑀼 𑀫𑀤𑀺𑀭𑀸𑀩𑀻𑀚𑁂, 𑀫𑀥𑀼 𑀫𑀥𑁆𑀯𑀸𑀲𑀯𑁂 𑀫𑀢𑀁;

𑀫𑀤𑀺𑀭𑀸 𑀯𑀸𑀭𑀼𑀡𑀻 𑀫𑀚𑁆𑀚𑀁, 𑀲𑀼𑀭𑀸 𑀪𑀯𑁄 𑀢𑀼 𑀫𑁂𑀭𑀬𑀁.

𑀲𑀭𑀓𑁄 𑀘𑀲𑀓𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀆𑀧𑀸𑀦𑀁 𑀧𑀸𑀦𑀫𑀡𑁆𑀟𑀮𑀁;

𑀬𑁂’𑀢𑁆𑀭 𑀪𑀽𑀭𑀺𑀧𑁆𑀧𑀬𑁄𑀕𑀢𑁆𑀢𑀸, 𑀬𑁄𑀕𑀺𑀓𑁂𑀓𑀲𑁆𑀫𑀺 𑀫𑀻𑀭𑀺𑀢𑀸;

𑀮𑀺𑀗𑁆𑀕𑀦𑁆𑀢𑀭𑁂𑀧𑀺 𑀢𑁂 𑀜𑁂𑀬𑁆𑀬𑀸, 𑀢𑀤𑁆𑀥𑀫𑁆𑀫𑀢𑁆𑀢𑀸’𑀜𑁆𑀜𑀯𑀼𑀢𑁆𑀢𑀺𑀬𑀦𑁆𑀢𑀺.

𑀘𑀢𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀯𑀕𑁆𑀕𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀅𑀭𑀜𑁆𑀜𑀁 𑀓𑀸𑀦𑀦𑀁 𑀤𑀸𑀬𑁄, 𑀕𑀳𑀦𑀁 𑀯𑀺𑀧𑀺𑀦𑀁 𑀯𑀦𑀁;

𑀅𑀝𑀯𑀻’𑀢𑁆𑀣𑀻 𑀫𑀳𑀸𑀭𑀜𑁆𑀜𑀁, 𑀢𑁆𑀯, 𑀭𑀜𑁆𑀜𑀸𑀦𑀻𑀢𑁆𑀣𑀺𑀬𑀁 𑀪𑀯𑁂.

𑀦𑀕𑀭𑀸 𑀦𑀸𑀢𑀺𑀤𑀽𑀭𑀲𑁆𑀫𑀺𑀁, 𑀲𑀦𑁆𑀢𑁂𑀳𑀺 𑀬𑁄 𑀪𑀺𑀭𑁄𑀧𑀺𑀢𑁄;

𑀢𑀭𑀼𑀲𑀡𑁆𑀟𑁄 𑀲 𑀆𑀭𑀸𑀫𑁄, 𑀢𑀣𑁄 𑀧𑀯𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀲𑀩𑁆𑀩𑀲𑀸𑀥𑀸𑀭𑀡𑀸’𑀭𑀜𑁆𑀜𑀁, 𑀭𑀜𑁆𑀜 𑀫𑀼𑀬𑁆𑀬𑀸𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀜𑁂𑀬𑁆𑀬𑀁 𑀢𑀤𑁂𑀯 𑀧𑀫𑀤, 𑀯𑀦 𑀫𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑁄𑀘𑀺𑀢𑀁.

𑀧𑀦𑁆𑀢𑀺 𑀯𑀻𑀣𑁆𑀬𑀸’𑀯𑀮𑀺 𑀲𑁂𑀡𑀻, 𑀧𑀸𑀴𑀺 𑀮𑁂𑀔𑀸 𑀢𑀼 𑀭𑀸𑀚𑀺 𑀘;

𑀧𑀸𑀤𑀧𑁄 𑀯𑀺𑀝𑀧𑀻 𑀭𑀼𑀓𑁆𑀔𑁄, 𑀅𑀕𑁄 𑀲𑀸𑀮𑁄 𑀫𑀳𑀻𑀭𑀼𑀳𑁄.

𑀤𑀼𑀫𑁄 𑀢𑀭𑀼 𑀓𑀼𑀚𑁄 𑀲𑀸𑀔𑀻, 𑀕𑀘𑁆𑀙𑁄 𑀢𑀼 𑀔𑀼𑀤𑁆𑀤𑀧𑀸𑀤𑀧𑁄;

𑀨𑀮𑀦𑁆𑀢𑀺 𑀬𑁂 𑀯𑀺𑀦𑀸 𑀧𑀼𑀧𑁆𑀨𑀁, 𑀢𑁂 𑀯𑀼𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀯𑀦𑀧𑁆𑀧𑀢𑀻.

𑀢𑀻𑀲𑀼 𑀯𑀜𑁆𑀘𑁆𑀬𑀸’𑀨𑀮𑀸 𑀘𑀸𑀣, 𑀨𑀮𑀺𑀦𑁄 𑀨𑀮𑀯𑀸 𑀨𑀮𑀻.

𑀲𑀫𑁆𑀨𑀼𑀮𑁆𑀮𑀺𑀢𑁄 𑀢𑀼 𑀯𑀺𑀓𑀘𑁄, 𑀨𑀼𑀮𑁆𑀮𑁄 𑀯𑀺𑀓𑀲𑀺𑀢𑁄 𑀢𑀺𑀲𑀼;

𑀲𑀺𑀭𑁄’𑀕𑁆𑀕𑀁 𑀲𑀺𑀔𑀭𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀲𑀸𑀔𑀸 𑀢𑀼 𑀓𑀣𑀺𑀢𑀸 𑀮𑀢𑀸.

𑀤𑀮𑀁 𑀧𑀮𑀸𑀲𑀁 𑀙𑀤𑀦𑀁, 𑀧𑀡𑁆𑀡𑀁 𑀧𑀢𑁆𑀢𑀁 𑀙𑀤𑁄 𑀧𑁆𑀬𑀣;

𑀧𑀮𑁆𑀮𑀯𑁄 𑀯𑀸 𑀓𑀺𑀲𑀮𑀬𑀁, 𑀦𑀯𑀼𑀩𑁆𑀪𑀺𑀦𑁆𑀦𑁂 𑀢𑀼 𑀅𑀗𑁆𑀓𑀼𑀭𑁄.

𑀫𑀓𑀼𑀮𑀁 𑀯𑀸 𑀓𑀼𑀝𑀼𑀫𑀮𑁄, 𑀔𑀸𑀭𑀓𑁄 𑀢𑀼 𑀘 𑀚𑀸𑀮𑀓𑀁;

𑀓𑀮𑀺𑀓𑀸 𑀓𑁄𑀭𑀓𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀯𑀡𑁆𑀝𑀁 𑀧𑀼𑀧𑁆𑀨𑀸𑀤𑀺𑀩𑀦𑁆𑀥𑀦𑀁.

𑀧𑀲𑀯𑁄 ¶ 𑀓𑀼𑀲𑀼𑀫𑀁 𑀧𑀼𑀧𑁆𑀨𑀁, 𑀧𑀭𑀸𑀕𑁄 𑀧𑀼𑀧𑁆𑀨𑀚𑁄 𑀭𑀚𑁄;

𑀫𑀓𑀭𑀦𑁆𑀤𑁄 𑀫𑀥𑀼 𑀫𑀢𑀁, 𑀣𑀯𑀓𑁄 𑀢𑀼 𑀘 𑀕𑁄𑀘𑁆𑀙𑀓𑁄.

𑀨𑀮𑁂 𑀢𑁆𑀯𑀸’𑀫𑁂 𑀲𑀮𑀸𑀝𑀼’𑀢𑁆𑀢𑁄,

𑀘𑀫𑁆𑀧𑀓’𑀫𑁆𑀩𑀸𑀤𑀺𑀓𑀼𑀲𑀼𑀫, 𑀨𑀮𑀦𑀸𑀫𑀁 𑀦𑀧𑀼𑀁𑀲𑀓𑁂.

𑀫𑀮𑁆𑀮𑀺𑀓𑀸𑀤𑀻 𑀢𑀼 𑀓𑀼𑀲𑀼𑀫𑁂, 𑀲𑀮𑀺𑀗𑁆𑀕𑀸 𑀯𑀻𑀳𑀬𑁄 𑀨𑀮𑁂;

𑀚𑀫𑁆𑀩𑀽’𑀢𑁆𑀣𑀻 𑀚𑀫𑁆𑀩𑀯𑀁 𑀚𑀫𑁆𑀩𑀽, 𑀯𑀺𑀝𑀧𑁄 𑀯𑀺𑀝𑀪𑀻’𑀢𑁆𑀣𑀺𑀬𑀁.

𑀫𑀽𑀮 𑀫𑀸𑀭𑀩𑁆𑀪 𑀲𑀸𑀔𑀦𑁆𑀢𑁄, 𑀔𑀦𑁆𑀥𑁄 𑀪𑀸𑀕𑁄 𑀢𑀭𑀼𑀲𑁆𑀲 𑀣;

𑀓𑁄𑀝𑀭𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀭𑀼𑀓𑁆𑀔, 𑀘𑁆𑀙𑀺𑀤𑁆𑀤𑁂 𑀓𑀝𑁆𑀞𑀁 𑀢𑀼 𑀤𑀸𑀭𑀼 𑀘.

𑀩𑀼𑀦𑁆𑀤𑁄 𑀫𑀽𑀮𑀜𑁆𑀘 𑀧𑀸𑀤𑁄 𑀣, 𑀲𑀗𑁆𑀓𑀼’𑀢𑁆𑀢𑁄 𑀔𑀸𑀡𑀼𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀓𑀭𑀳𑀸𑀝𑀁 𑀢𑀼 𑀓𑀦𑁆𑀤𑁄 𑀣, 𑀓𑀴𑀻𑀭𑁄 𑀫𑀢𑁆𑀣𑀓𑁄 𑀪𑀯𑁂.

𑀯𑀮𑁆𑀮𑀭𑀻 𑀫𑀜𑁆𑀚𑀭𑀻 𑀦𑀸𑀭𑀻, 𑀯𑀮𑁆𑀮𑀻 𑀢𑀼 𑀓𑀣𑀺𑀢𑀸 𑀮𑀢𑀸;

𑀣𑀫𑁆𑀪𑁄 𑀕𑀼𑀫𑁆𑀩𑁄 𑀘 𑀅𑀓𑁆𑀔𑀦𑁆𑀥𑁂, 𑀮𑀢𑀸 𑀯𑀺𑀭𑀽 𑀧𑀢𑀸𑀦𑀺𑀦𑀻.

𑀅𑀲𑁆𑀲𑀢𑁆𑀣𑁄 𑀩𑁄𑀥𑀺 𑀘 𑀤𑁆𑀯𑀻𑀲𑀼, 𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑁄 𑀢𑀼 𑀯𑀝𑁄 𑀪𑀯𑁂;

𑀓𑀩𑀺𑀝𑁆𑀞𑁄 𑀘 𑀓𑀧𑀺𑀢𑁆𑀣𑁄 𑀘, 𑀬𑀜𑁆𑀜𑀗𑁆𑀕𑁄 𑀢𑀼 𑀉𑀤𑀼𑀫𑁆𑀩𑀭𑁄.

𑀓𑁄𑀯𑀺𑀴𑀸𑀭𑁄 𑀬𑀼𑀕𑀧𑀢𑁆𑀢𑁄, 𑀉𑀤𑁆𑀤𑀸𑀮𑁄 𑀯𑀸𑀢𑀖𑀸𑀢𑀓𑁄;

𑀭𑀸𑀚𑀭𑀼𑀓𑁆𑀔𑁄 𑀓𑀢𑀫𑀸𑀮𑀻, 𑀦𑁆𑀤𑀻𑀯𑀭𑁄 𑀩𑁆𑀬𑀸𑀥𑀺𑀖𑀸𑀢𑀓𑁄.

𑀤𑀦𑁆𑀢𑀲𑀞𑁄 𑀘 𑀚𑀫𑁆𑀪𑀻𑀭𑁄, 𑀯𑀭𑀡𑁄 𑀢𑀼 𑀓𑀭𑁂𑀭𑀺 𑀘;

𑀓𑀺𑀁 𑀲𑀼𑀓𑁄 𑀧𑀸𑀮𑀺𑀪𑀤𑁆𑀤𑁄𑀣, 𑀯𑀜𑁆𑀚𑀼𑀮𑁄 𑀢𑀼 𑀘 𑀯𑁂𑀢𑀲𑁄.

𑀅𑀫𑁆𑀩𑀸𑀝𑀓𑁄𑀧𑀻𑀢𑀦𑀓𑁄, 𑀫𑀥𑀼𑀓𑁄 𑀢𑀼 𑀫𑀥𑀼𑀤𑁆𑀤𑀼𑀫𑁄;

𑀅𑀣𑁄 𑀕𑀼𑀴𑀨𑀮𑁄 𑀧𑀻𑀮𑀼, 𑀲𑁄𑀪𑀜𑁆𑀚𑀦𑁄 𑀘 𑀲𑀺𑀕𑁆𑀕𑀼 𑀘.

𑀲𑀢𑁆𑀢𑀧𑀡𑁆𑀡𑀺 𑀙𑀢𑁆𑀢𑀧𑀡𑁆𑀡𑁄, 𑀢𑀺𑀦𑀺𑀲𑁄 𑀢𑁆𑀯 𑀢𑀺𑀫𑀼𑀢𑁆𑀢𑀓𑁄;

𑀫𑀸𑀮𑀽𑀭 𑀩𑁂𑀮𑀼𑀯𑀸𑀩𑀺𑀮𑁆𑀮𑁄, 𑀧𑀼𑀦𑁆𑀦𑀸𑀕𑁄 𑀢𑀼 𑀘 𑀓𑁂𑀲𑀭𑁄;

𑀲𑀸𑀮𑀯𑁄 𑀢𑀼 𑀘 𑀮𑁄𑀤𑁆𑀤𑁄 𑀣, 𑀧𑀺𑀬𑀸𑀮𑁄 𑀲𑀦𑁆𑀦𑀓𑀤𑁆𑀤𑀼 𑀘.

𑀅𑀫𑁆𑀩𑁄 𑀘𑀽𑀢𑁄 𑀲𑀳𑁄 𑀢𑁆𑀯𑁂𑀲𑁄,

𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑁄 ¶ 𑀘 𑀲𑁂𑀢𑀫𑁆𑀩𑁄, 𑀲𑁂𑀮𑀼 𑀢𑀼 𑀩𑀳𑀼𑀯𑀸𑀭𑀓𑁄;

𑀲𑁂𑀧𑀡𑁆𑀡𑀻 𑀓𑀸𑀲𑁆𑀫𑀺𑀭𑀻 𑀘𑀸𑀣, 𑀓𑁄𑀮𑀻 𑀘 𑀩𑀤𑀭𑀻𑀢𑁆𑀣𑀺𑀬𑀁.

𑀓𑁄𑀮𑀁 𑀘𑀸𑀦𑀺𑀢𑁆𑀣𑀻 𑀩𑀤𑀭𑁄, 𑀧𑀺𑀮𑀓𑁆𑀔𑁄 𑀧𑀺𑀧𑁆𑀧𑀮𑀻’𑀢𑁆𑀣𑀺𑀬𑀁;

𑀧𑀸𑀝𑀮𑀻 𑀓𑀡𑁆𑀳𑀯𑀦𑁆𑀢𑀸 𑀘, 𑀲𑀸𑀤𑀼𑀓𑀡𑁆𑀝𑁄 𑀯𑀺𑀓𑀗𑁆𑀓𑀢𑁄.

𑀢𑀺𑀦𑁆𑀤𑀼𑀓𑁄 𑀓𑀸𑀴𑀓𑁆𑀔𑀦𑁆𑀥𑁄 𑀘, 𑀢𑀺𑀫𑁆𑀩𑀭𑀽𑀲𑀓 𑀢𑀺𑀫𑁆𑀩𑀭𑀽;

𑀏𑀭𑀸𑀯𑀢𑁄 𑀢𑀼 𑀦𑀸𑀭𑀗𑁆𑀕𑁄, 𑀓𑀼𑀮𑀓𑁄 𑀓𑀸𑀓𑀢𑀺𑀦𑁆𑀤𑀼𑀓𑁄.

𑀓𑀤𑀫𑁆𑀩𑁄 𑀧𑀺𑀬𑀓𑁄 𑀦𑀻𑀧𑁄, 𑀪𑀮𑁆𑀮𑀻 𑀪𑀮𑁆𑀮𑀸𑀢𑀓𑁄 𑀢𑀺𑀲𑀼;

𑀛𑀸𑀯𑀼𑀓𑁄 𑀧𑀺𑀘𑀼𑀮𑁄 𑀘𑀸𑀣, 𑀢𑀺𑀮𑀓𑁄 𑀔𑀼𑀭𑀓𑁄 𑀪𑀯𑁂.

𑀘𑀺𑀜𑁆𑀘𑀸 𑀘 𑀢𑀺𑀦𑁆𑀢𑀺𑀡𑀻 𑀘𑀸𑀣, 𑀕𑀤𑁆𑀤𑀪𑀡𑁆𑀟𑁄 𑀓𑀧𑀻𑀢𑀦𑁄;

𑀦𑀺𑀘𑀼𑀮𑁄 𑀫𑀼𑀘𑀮𑀺𑀦𑁆𑀤𑁄 𑀘, 𑀦𑀻𑀧𑁄 𑀣 𑀧𑀺𑀬𑀓𑁄 𑀢𑀣𑀸;

𑀔𑀻𑀭𑀺𑀓𑀸 𑀭𑀸𑀚𑀸𑀬𑀢𑀦𑀁, 𑀓𑀼𑀫𑁆𑀪𑀻 𑀓𑀼𑀫𑀼𑀤𑀺𑀓𑀸 𑀪𑀯𑁂;

𑀬𑀽𑀧𑁄 [𑀧𑀽𑀕𑁄 (𑀓.)] 𑀢𑀼 𑀓𑀫𑀼𑀓𑁄 𑀘𑀸𑀣, 𑀧𑀝𑁆𑀝𑀺 𑀮𑀸𑀔𑀸𑀧𑀲𑀸𑀤𑀦𑁄.

𑀇𑀗𑁆𑀕𑀼𑀤𑀻 𑀢𑀸𑀧𑀲𑀢𑀭𑀼, 𑀪𑀼𑀚𑀧𑀢𑁆𑀢𑁄 𑀢𑀼 𑀆𑀪𑀼𑀚𑀻;

𑀧𑀺𑀘𑁆𑀙𑀺𑀮𑀸 𑀲𑀺𑀫𑁆𑀩𑀮𑀻 𑀤𑁆𑀯𑀻𑀲𑀼, 𑀭𑁄𑀘𑀦𑁄 𑀓𑁄𑀝𑀲𑀺𑀫𑁆𑀩𑀮𑀻.

𑀧𑀓𑀺𑀭𑀺𑀬𑁄 𑀧𑀽𑀢𑀺𑀓𑁄 𑀣, 𑀭𑁄𑀳𑀻 𑀭𑁄𑀳𑀺𑀢𑀓𑁄 𑀪𑀯𑁂;

𑀏𑀭𑀡𑁆𑀟𑁄 𑀢𑀼 𑀘 𑀆𑀫𑀡𑁆𑀟𑁄, 𑀅𑀣 𑀲𑀢𑁆𑀢𑀼𑀨𑀮𑀸 𑀲𑀫𑀻.

𑀦𑀢𑁆𑀢𑀫𑀸𑀮𑁄 𑀓𑀭𑀜𑁆𑀚𑁄 𑀣, 𑀔𑀤𑀺𑀭𑁄 𑀤𑀦𑁆𑀢𑀥𑀸𑀯𑀦𑁄;

𑀲𑁄𑀫𑀯𑀓𑁆𑀓𑁄 𑀢𑀼 𑀓𑀤𑀭𑁄, 𑀲𑀮𑁆𑀮𑁄𑀢𑀼 𑀫𑀤𑀦𑁄 𑀪𑀯𑁂.

𑀅𑀣𑀸𑀧𑀺 𑀇𑀦𑁆𑀤𑀲𑀸𑀮𑁄 𑀘, 𑀲𑀮𑁆𑀮𑀓𑀻 𑀔𑀸𑀭𑀓𑁄 𑀲𑀺𑀬𑀸;

𑀤𑁂𑀯𑀤𑀸𑀭𑀼 𑀪𑀤𑁆𑀤𑀤𑀸𑀭𑀼, 𑀘𑀫𑁆𑀧𑁂𑀬𑁆𑀬𑁄 𑀢𑀼 𑀘 𑀘𑀫𑁆𑀧𑀓𑁄.

𑀧𑀦𑀲𑁄 𑀓𑀡𑁆𑀝𑀓𑀺𑀨𑀮𑁄, 𑀅𑀪𑀬𑀸 𑀢𑀼 𑀳𑀭𑀻𑀢𑀓𑀻;

𑀅𑀓𑁆𑀔𑁄 𑀯𑀺𑀪𑀻𑀢𑀓𑁄 𑀢𑀻𑀲𑀼, 𑀅𑀫𑀢𑀸’𑀫𑀮𑀓𑀻 𑀢𑀺𑀲𑀼.

𑀮𑀩𑀼𑀚𑁄 𑀮𑀺𑀓𑀼𑀘𑁄 𑀘𑀸𑀣, 𑀓𑀡𑀺𑀓𑀸𑀭𑁄 𑀤𑀼𑀫𑀼𑀧𑁆𑀧𑀮𑁄;

𑀦𑀺𑀫𑁆𑀩𑁄’𑀭𑀺𑀝𑁆𑀞𑁄 𑀧𑀼𑀘𑀺𑀫𑀦𑁆𑀤𑁄, 𑀓𑀭𑀓𑁄 𑀢𑀼 𑀘 𑀤𑀸𑀴𑀺𑀫𑁄.

𑀲𑀭𑀮𑁄 ¶ 𑀧𑀽𑀢𑀺𑀓𑀝𑁆𑀞𑀜𑁆𑀘, 𑀓𑀧𑀺𑀮𑀸 𑀢𑀼 𑀘 𑀲𑀺𑀁𑀲𑀧𑀸;

𑀲𑀸𑀫𑀸 𑀧𑀺𑀬𑀗𑁆𑀕𑀼 𑀓𑀗𑁆𑀕𑀼𑀧𑀺, 𑀲𑀺𑀭𑀻𑀲𑁄 𑀢𑀼 𑀘 𑀪𑀡𑁆𑀟𑀺𑀮𑁄.

𑀓𑀸𑀓𑁄𑀤𑀼𑀫𑁆𑀩𑀭𑀺𑀓𑀸 𑀨𑁂𑀕𑁆𑀕𑀼, 𑀦𑀸𑀕𑁄 𑀢𑀼 𑀦𑀸𑀕𑀫𑀸𑀮𑀺𑀓𑀸.

𑀅𑀲𑁄𑀓𑁄 𑀯𑀜𑁆𑀚𑀼𑀮𑁄 𑀘𑀸𑀣, 𑀢𑀓𑁆𑀓𑀸𑀭𑀻 𑀯𑁂𑀚𑀬𑀦𑁆𑀢𑀺𑀓𑀸;

𑀢𑀸𑀧𑀺𑀜𑁆𑀙𑁄 𑀘 𑀢𑀫𑀸𑀮𑁄 𑀣, 𑀓𑀼𑀝𑀚𑁄 𑀕𑀺𑀭𑀺𑀫𑀮𑁆𑀮𑀺𑀓𑀸.

𑀇𑀦𑁆𑀤𑀬𑀯𑁄 𑀨𑀮𑁂 𑀢𑀲𑁆𑀲𑀸, 𑀕𑁆𑀕𑀺𑀫𑀦𑁆𑀣𑁄 𑀓𑀡𑀺𑀓𑀸 𑀪𑀯𑁂;

𑀦𑀺𑀕𑀼𑀡𑁆𑀞𑀺’𑀢𑁆𑀣𑀻 𑀲𑀺𑀦𑁆𑀤𑀼𑀯𑀸𑀭𑁄, 𑀢𑀺𑀡𑀲𑀼𑀜𑁆𑀜𑀁 [𑀢𑀺𑀡𑀲𑀽𑀮𑀁 (𑀝𑀻.)] 𑀢𑀼 𑀫𑀮𑁆𑀮𑀺𑀓𑀸.

𑀲𑁂𑀨𑀸𑀮𑀺𑀓𑀸 𑀦𑀻𑀮𑀺𑀓𑀸 𑀣, 𑀅𑀧𑁆𑀨𑁄𑀝𑀸 𑀯𑀦𑀫𑀮𑁆𑀮𑀺𑀓𑀸;

𑀩𑀦𑁆𑀥𑀼𑀓𑁄 𑀚𑀬𑀲𑀼𑀫𑀦𑀁, 𑀪𑀡𑁆𑀟𑀺𑀓𑁄 𑀩𑀦𑁆𑀥𑀼𑀚𑀻𑀯𑀓𑁄.

𑀲𑀼𑀫𑀦𑀸 𑀚𑀸𑀢𑀺𑀲𑀼𑀫𑀦𑀸, 𑀫𑀸𑀮𑀢𑀻 𑀚𑀸𑀢𑀺 𑀯𑀲𑁆𑀲𑀺𑀓𑀻;

𑀬𑀽𑀣𑀺𑀓𑀸 𑀫𑀸𑀕𑀥𑀻 𑀘𑀸𑀣, 𑀲𑀢𑁆𑀢𑀮𑀸 𑀦𑀯𑀫𑀮𑁆𑀮𑀺𑀓𑀸.

𑀯𑀸𑀲𑀦𑁆𑀢𑀻,𑀢𑁆𑀣𑀻 𑀅𑀢𑀺𑀫𑀼𑀢𑁆𑀢𑁄, 𑀓𑀭𑀯𑀻𑀭𑁄’𑀲𑁆𑀲𑀫𑀸𑀭𑀓𑁄;

𑀫𑀸𑀢𑀼𑀮𑀼𑀗𑁆𑀕𑁄 𑀩𑀻𑀚𑀧𑀽𑀭𑁄, 𑀉𑀫𑁆𑀫𑀢𑁆𑀢𑁄 𑀢𑀼 𑀘 𑀫𑀸𑀢𑀼𑀮𑁄.

𑀓𑀭𑀫𑀦𑁆𑀤𑁄 𑀲𑀼𑀲𑁂𑀦𑁄 𑀘, 𑀓𑀼𑀦𑁆𑀤𑀁 𑀢𑀼 𑀫𑀸𑀖𑁆𑀬 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀤𑁂𑀯𑀢𑀸𑀲𑁄 [𑀤𑁂𑀯𑀢𑀸𑀟𑁄 (𑀲𑀻. 𑀅𑀫𑀭𑀓𑁄𑀲)] 𑀢𑀼 𑀚𑀻𑀫𑀽𑀢𑁄,

𑀅𑀚𑁆𑀚𑀼𑀓𑁄 𑀲𑀺𑀢𑀧𑀡𑁆𑀡𑀸𑀲𑁄, 𑀲𑀫𑀻𑀭𑀡𑁄 𑀨𑀡𑀺𑀚𑁆𑀚𑀓𑁄.

𑀚𑀧𑀸 𑀢𑀼 𑀚𑀬𑀲𑀼𑀫𑀦𑀁, 𑀓𑀭𑀻𑀭𑁄 𑀓𑀓𑀘𑁄 𑀪𑀯𑁂;

𑀭𑀼𑀓𑁆𑀔𑀸𑀤𑀦𑀻 𑀘 𑀯𑀦𑁆𑀤𑀸𑀓𑀸, 𑀘𑀺𑀢𑁆𑀢𑀓𑁄 𑀢𑁆𑀯’𑀕𑁆𑀕𑀺𑀲𑀜𑁆𑀜𑀺𑀢𑁄.

𑀢𑁆𑀯’ 𑀴𑀓𑁆𑀓𑁄 𑀲𑁂𑀢𑀧𑀼𑀧𑁆𑀨𑀓𑁂;

𑀧𑀽𑀢𑀺𑀮𑀢𑀸 𑀕𑀴𑁄𑀘𑀻 𑀘, 𑀫𑀼𑀩𑁆𑀩𑀸 𑀫𑀥𑀼𑀭𑀲𑀸 𑀧𑁆𑀬𑀣.

𑀓𑀧𑀺𑀓𑀘𑁆𑀙𑀼 𑀤𑀼𑀨𑀲𑁆𑀲𑁄 𑀣, 𑀫𑀜𑁆𑀚𑀺𑀝𑁆𑀞𑀸 𑀯𑀺𑀓𑀲𑀸 𑀪𑀯𑁂;

𑀅𑀫𑁆𑀩𑀝𑁆𑀞𑀸 𑀘 𑀢𑀣𑀸 𑀧𑀸𑀞𑀸, 𑀓𑀝𑀼𑀓𑀸 𑀓𑀝𑀼𑀭𑁄𑀳𑀺𑀡𑀻.

𑀅𑀧𑀸𑀫𑀕𑁆𑀕𑁄 ¶ 𑀲𑁂𑀔𑀭𑀺𑀓𑁄, 𑀧𑀺𑀧𑁆𑀧𑀮𑀻 𑀫𑀸𑀕𑀥𑀻 𑀫𑀢𑀸;

𑀕𑁄𑀓𑀡𑁆𑀝𑀓𑁄 𑀘 𑀲𑀺𑀗𑁆𑀖𑀸𑀝𑁄, 𑀓𑁄𑀮𑀯𑀮𑁆𑀮𑀻’𑀪𑀧𑀺𑀧𑁆𑀧𑀮𑀻.

𑀕𑁄𑀮𑁄𑀫𑀻 𑀢𑀼 𑀯𑀘𑀸 𑀘𑀸𑀣, 𑀕𑀺𑀭𑀺𑀓𑀡𑁆𑀬’𑀧𑀭𑀸𑀚𑀺𑀢𑀸;

𑀲𑀻𑀳𑀧𑀼𑀘𑁆𑀙𑀻 𑀧𑀜𑁆𑀳𑀺𑀧𑀡𑁆𑀡𑀻, 𑀲𑀸𑀮𑀧𑀡𑁆𑀡𑀻 𑀢𑀼 𑀘’𑀢𑁆𑀣𑀺𑀭𑀸; (𑀘𑀣𑀺𑀭𑀸).

𑀦𑀺𑀤𑀺𑀤𑁆𑀥𑀺𑀓𑀸 𑀢𑀼 𑀩𑁆𑀬𑀕𑁆𑀖𑀻 𑀘, 𑀅𑀣 𑀦𑀻𑀮𑀻 𑀘 𑀦𑀻𑀮𑀺𑀦𑀻;

𑀚𑀺𑀜𑁆𑀚𑀼𑀓𑁄 [𑀚𑀺𑀜𑁆𑀚𑀼𑀓𑀸 (𑀓.)] 𑀘𑁂𑀯 𑀕𑀼𑀜𑁆𑀚𑀸 𑀣, 𑀲𑀢𑀫𑀽𑀮𑀻 𑀲𑀢𑀸𑀯𑀭𑀻.

𑀫𑀳𑁄𑀲𑀥𑀁 𑀢𑁆𑀯’𑀢𑀺𑀯𑀺𑀲𑀸, 𑀩𑀸𑀓𑀼𑀘𑀻 𑀲𑁄𑀫𑀯𑀮𑁆𑀮𑀺𑀓𑀸;

𑀤𑀸𑀩𑁆𑀩𑀻 𑀤𑀸𑀭𑀼𑀳𑀮𑀺𑀤𑁆𑀤𑀸 𑀣, 𑀩𑀺𑀴𑀗𑁆𑀕𑀁 𑀘𑀺𑀢𑁆𑀭𑀢𑀡𑁆𑀟𑀼𑀮𑀸.

𑀦𑀼𑀳𑀻 𑀘𑁂𑀯 𑀫𑀳𑀸𑀦𑀸𑀫𑁄, 𑀫𑀼𑀤𑁆𑀤𑀺𑀓𑀸 𑀢𑀼 𑀫𑀥𑀼𑀭𑀲𑀸;

𑀅𑀣𑀸𑀧𑀺 𑀫𑀥𑀼𑀓𑀁 𑀬𑀝𑁆𑀞𑀺, 𑀫𑀥𑀼𑀓𑀸𑀫𑀥𑀼𑀬𑀝𑁆𑀞𑀺𑀓𑀸 [𑀫𑀥𑀼𑀮𑀝𑁆𑀞𑀺𑀓𑀸 (𑀲𑀻. 𑀝𑀻.)].

𑀯𑀸𑀢𑀺𑀗𑁆𑀕𑀡𑁄 𑀘 𑀪𑀡𑁆𑀟𑀸𑀓𑀻, 𑀯𑀸𑀢𑁆𑀢𑀸𑀓𑀻 𑀩𑁆𑀭𑀳𑀢𑀻 𑀧𑁆𑀬𑀣;

𑀦𑀸𑀕𑀩𑀮𑀸 𑀘𑁂𑀯 𑀛𑀲𑀸, 𑀮𑀸𑀗𑁆𑀕𑀮𑀻 𑀢𑀼 𑀘 𑀲𑀸𑀭𑀤𑀻.

𑀭𑀫𑁆𑀪𑀸 𑀘 𑀓𑀤𑀮𑀻 𑀫𑁄𑀘𑁄, 𑀓𑀧𑁆𑀧𑀸𑀲𑀻 𑀩𑀤𑀭𑀸 𑀪𑀯𑁂;

𑀦𑀸𑀕𑀮𑀢𑀸 𑀢𑀼 𑀢𑀫𑁆𑀩𑀽𑀮𑀻, 𑀅𑀕𑁆𑀕𑀺𑀚𑀸𑀮𑀸 𑀢𑀼 𑀥𑀸𑀢𑀓𑀻.

𑀢𑀺𑀯𑀼𑀢𑀸 𑀢𑀺𑀧𑀼𑀝𑀸 𑀘𑀸𑀣, 𑀲𑀸𑀫𑀸 𑀓𑀸𑀴𑀸 𑀘 𑀓𑀣𑁆𑀬𑀢𑁂;

𑀅𑀣𑁄 𑀲𑀺𑀗𑁆𑀕𑀻 𑀘 𑀉𑀲𑀪𑁄, 𑀭𑁂𑀡𑀼𑀓𑀸 𑀓𑀧𑀺𑀴𑀸 𑀪𑀯𑁂.

𑀳𑀺𑀭𑀺𑀯𑁂𑀭𑀜𑁆𑀘 𑀯𑀸𑀮𑀜𑁆𑀘, 𑀭𑀢𑁆𑀢𑀨𑀮𑀸 𑀢𑀼 𑀩𑀺𑀫𑁆𑀩𑀺𑀓𑀸;

𑀲𑁂𑀮𑁂𑀬𑁆𑀬’ 𑀫𑀲𑁆𑀫𑀧𑀼𑀧𑁆𑀨𑀜𑁆𑀘, 𑀏𑀮𑀸 𑀢𑀼 𑀩𑀳𑀼𑀮𑀸 𑀪𑀯𑁂.

𑀓𑀼𑀝𑁆𑀞𑀜𑁆𑀘 𑀩𑁆𑀬𑀸𑀥𑀺 𑀓𑀣𑀺𑀢𑁄, 𑀯𑀸𑀦𑁂𑀬𑁆𑀬𑀁 𑀢𑀼 𑀓𑀼𑀝𑀦𑁆𑀦𑀝𑀁;

𑀑𑀲𑀥𑀺 𑀚𑀸𑀢𑀺𑀫𑀢𑁆𑀢𑀫𑁆𑀳𑀺, 𑀑𑀲𑀥𑀁 𑀲𑀩𑁆𑀩’ 𑀫𑀚𑀸𑀢𑀺𑀬𑀁.

𑀫𑀽𑀮𑀁 𑀧𑀢𑁆𑀢𑀁 𑀓𑀴𑀻𑀭’𑀕𑁆𑀕𑀁, 𑀓𑀦𑁆𑀤𑀁 𑀫𑀺𑀜𑁆𑀚𑀸 𑀨𑀮𑀁 𑀢𑀣𑀸;

𑀢𑀘𑁄 𑀧𑀼𑀧𑁆𑀨𑀜𑁆𑀘 𑀙𑀢𑁆𑀢𑀦𑁆𑀢𑀺, 𑀲𑀸𑀓𑀁 𑀤𑀲𑀯𑀺𑀥𑀁 𑀫𑀢𑀁.

𑀢𑀡𑁆𑀟𑀼𑀮𑁂𑀬𑁆𑀬𑁄’𑀧𑁆𑀧𑀫𑀸𑀭𑀺𑀲𑁄;

𑀚𑀻𑀯𑀦𑁆𑀢𑀺 𑀚𑀻𑀯𑀦𑀻 𑀘𑀸𑀣, 𑀫𑀥𑀼𑀭𑀓𑁄 𑀘 𑀚𑀻𑀯𑀓𑁄.

𑀫𑀳𑀸𑀓𑀦𑁆𑀤𑁄 𑀘 𑀮𑀲𑀼𑀡𑀁, 𑀧𑀮𑀡𑁆𑀟𑀼 𑀢𑀼 𑀲𑀼𑀓𑀦𑁆𑀤𑀓𑁄;

𑀧𑀝𑁄𑀮𑁄 𑀢𑀺𑀢𑁆𑀢𑀓𑁄 𑀘𑀸𑀣, 𑀪𑀺𑀗𑁆𑀕𑀭𑀸𑀚𑁄 𑀘 𑀫𑀓𑁆𑀓𑀯𑁄.

𑀧𑀼𑀦𑀦𑁆𑀦𑀯𑀸 ¶ 𑀲𑁄𑀣𑀖𑀸𑀢𑀻, 𑀯𑀺𑀢𑀼𑀦𑁆𑀦𑀁 𑀲𑀼𑀦𑀺𑀲𑀡𑁆𑀡𑀓𑀁;

𑀓𑀸𑀭𑀯𑁂𑀮𑁆𑀮𑁄 𑀢𑀼 𑀲𑀼𑀲𑀯𑀻, 𑀢𑀼𑀫𑁆𑀩𑁆𑀬𑀸’𑀮𑀸𑀩𑀼 𑀘 𑀮𑀸𑀩𑀼 𑀲𑀸.

𑀏𑀴𑀸𑀮𑀼𑀓𑀜𑁆𑀘 𑀓𑀓𑁆𑀓𑀸𑀭𑀻, 𑀓𑀼𑀫𑁆𑀪𑀡𑁆𑀟𑁄 𑀢𑀼 𑀘 𑀯𑀮𑁆𑀮𑀺𑀪𑁄;

𑀇𑀦𑁆𑀤𑀯𑀸𑀭𑀼𑀡𑀻 𑀯𑀺𑀲𑀸𑀮𑀸, 𑀯𑀢𑁆𑀣𑀼𑀓𑀁 𑀯𑀢𑁆𑀣𑀼𑀮𑁂𑀬𑁆𑀬𑀓𑁄.

𑀫𑀽𑀮𑀓𑁄 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀘𑀼𑀘𑁆𑀘𑀼, 𑀢𑀫𑁆𑀩𑀓𑁄 𑀘 𑀓𑀮𑀫𑁆𑀩𑀓𑁄;

𑀲𑀸𑀓𑀪𑁂𑀤𑀸 𑀓𑀸𑀲𑀫𑀤𑁆𑀤, 𑀛𑀚𑁆𑀛𑀭𑀻 𑀨𑀕𑁆𑀕𑀯𑀸’𑀤𑀬𑁄.

𑀲𑀤𑁆𑀤𑀮𑁄 𑀘𑁂𑀯 𑀤𑀼𑀩𑁆𑀩𑀸 𑀘, 𑀕𑁄𑀮𑁄𑀫𑀻 𑀲𑀸 𑀲𑀺𑀢𑀸 𑀪𑀯𑁂;

𑀕𑀼𑀦𑁆𑀤𑀸 𑀘 𑀪𑀤𑁆𑀤𑀫𑀼𑀢𑁆𑀢𑀜𑁆𑀘, 𑀭𑀲𑀸𑀮𑁄 𑀢𑀼’𑀘𑁆𑀙𑀼 𑀯𑁂𑀴𑀼 𑀢𑀼.

𑀢𑀘𑀲𑀸𑀭𑁄 𑀯𑁂𑀡𑀼 𑀯𑀁𑀲𑁄, 𑀧𑀩𑁆𑀩𑀁 𑀢𑀼 𑀨𑀮𑀼 𑀕𑀡𑁆𑀞𑀺𑀲𑁄;

𑀓𑀻𑀘𑀓𑀸 𑀢𑁂 𑀲𑀺𑀬𑀼𑀁 𑀯𑁂𑀡𑀽, 𑀬𑁂 𑀦𑀤𑀦𑁆𑀢𑁆𑀬𑀸’𑀦𑀺𑀮𑀤𑁆𑀥𑀼𑀢𑀸.

𑀦𑀴𑁄 𑀘 𑀥𑀫𑀦𑁄 𑀧𑁄𑀝, 𑀕𑀮𑁄 𑀢𑀼 𑀓𑀸𑀲 𑀫𑀺𑀢𑁆𑀣𑀺 𑀦;

𑀢𑁂𑀚𑀦𑁄 𑀢𑀼 𑀲𑀭𑁄, 𑀫𑀽𑀮𑀁, 𑀢𑀽’ 𑀲𑀻𑀭𑀁 𑀩𑀻𑀭𑀡𑀲𑁆𑀲 𑀳𑀺.

𑀓𑀼𑀲𑁄 𑀯𑀭𑀳𑀺𑀲𑀁 𑀤𑀩𑁆𑀩𑁄, 𑀪𑀽𑀢𑀺𑀡𑀓𑀁 𑀢𑀼 𑀪𑀽𑀢𑀺𑀡𑀁;

𑀢𑀸𑀮𑁄 𑀯𑀺𑀪𑁂𑀤𑀺𑀓𑀸 𑀘𑀸𑀣, 𑀔𑀚𑁆𑀚𑀼𑀭𑀻 𑀲𑀺𑀦𑁆𑀤𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀺;

𑀳𑀺𑀦𑁆𑀢𑀸𑀮, 𑀢𑀸𑀮, 𑀔𑀚𑁆𑀚𑀽𑀭𑀻, 𑀦𑀸𑀮𑀺𑀓𑁂𑀭𑀸 𑀢𑀣𑁂𑀯 𑀘;

𑀢𑀸𑀮𑀻 𑀘 𑀓𑁂𑀢𑀓𑀻 𑀦𑀸𑀭𑀻, 𑀧𑀽𑀕𑁄 𑀘 𑀢𑀺𑀡𑀧𑀸𑀤𑀧𑀸𑀢𑀺.

𑀧𑀩𑁆𑀩𑀢𑁄 𑀕𑀺𑀭𑀺 𑀲𑁂𑀮𑁄’𑀤𑁆𑀤𑀺, 𑀦𑀕𑀸’𑀘𑀮, 𑀲𑀺𑀮𑀼𑀘𑁆𑀘𑀬𑀸;

𑀲𑀺𑀔𑀭𑀻 𑀪𑀽𑀥𑀭𑁄𑀣 𑀩𑁆𑀪, 𑀧𑀸𑀲𑀸𑀡𑀸’𑀲𑁆𑀫𑁄’𑀧𑀮𑁄 𑀲𑀺𑀮𑀸.

𑀕𑀺𑀚𑁆𑀛𑀓𑀽𑀝𑁄 𑀘 𑀯𑁂𑀪𑀸𑀭𑁄, 𑀯𑁂𑀧𑀼𑀮𑁆𑀮𑁄’𑀲𑀺𑀕𑀺𑀮𑀻 𑀦𑀕𑀸;

𑀯𑀺𑀜𑁆𑀛𑁄 𑀧𑀡𑁆𑀟𑀯 𑀯𑀗𑁆𑀓𑀸𑀤𑀻, 𑀧𑀼𑀩𑁆𑀩𑀲𑁂𑀮𑁄 𑀢𑀼 𑀘𑁄’𑀤𑀬𑁄;

𑀫𑀦𑁆𑀤𑀭𑁄 𑀧𑀭𑀲𑁂𑀮𑁄’𑀢𑁆𑀣𑁄, 𑀳𑀺𑀫𑀯𑀸 𑀢𑀼 𑀳𑀺𑀫𑀸𑀘𑀮𑁄.

𑀕𑀦𑁆𑀥𑀫𑀸𑀤𑀦 𑀓𑁂𑀮𑀸𑀲, 𑀘𑀺𑀢𑁆𑀢𑀓𑀽𑀝 𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑀸;

𑀓𑀸𑀮𑀓𑀽𑀝𑁄 𑀢𑀺𑀓𑀽𑀝𑀸’𑀲𑁆𑀲, 𑀧𑀢𑁆𑀣𑁄 𑀢𑀼 𑀲𑀸𑀦𑀼 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀓𑀽𑀝𑁄 ¶ 𑀯𑀸 𑀲𑀺𑀔𑀭𑀁 𑀲𑀺𑀗𑁆𑀕𑀁, 𑀧𑀧𑀸𑀢𑁄 𑀢𑀼 𑀢𑀝𑁄 𑀪𑀯𑁂;

𑀦𑀺𑀢𑀫𑁆𑀩𑁄 𑀓𑀝𑀓𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀦𑀺𑀚𑁆𑀛𑀭𑁄 𑀧𑀲𑀯𑁄’𑀫𑁆𑀩𑀼𑀦𑁄.

𑀤𑀭𑀻’𑀢𑁆𑀣𑀻 𑀓𑀦𑁆𑀤𑀭𑁄 𑀤𑁆𑀯𑀻𑀲𑀼, 𑀮𑁂𑀡𑀁 𑀢𑀼 𑀕𑀩𑁆𑀪𑀭𑀁 𑀕𑀼𑀳𑀸;

𑀲𑀺𑀮𑀸𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻 𑀲𑁄𑀡𑁆𑀟𑀻, 𑀓𑀼𑀜𑁆𑀚𑀁 𑀦𑀺𑀓𑀼𑀜𑁆𑀚 𑀫𑀺𑀢𑁆𑀣𑀺 𑀦.

𑀉𑀤𑁆𑀥 𑀫𑀥𑀺𑀘𑁆𑀘𑀓𑀸 𑀲𑁂𑀮, 𑀲𑁆𑀲𑀸𑀲𑀦𑁆𑀦𑀸 𑀪𑀽𑀫𑁆𑀬𑀼 𑀧𑀘𑁆𑀘𑀓𑀸;

𑀥𑀸𑀢𑀼’𑀢𑁆𑀢𑁄 𑀕𑁂𑀭𑀺𑀓𑀸𑀤𑀺𑀓𑁄.

𑀫𑀺𑀕𑀺𑀦𑁆𑀤𑁄 𑀓𑁂𑀲𑀭𑀻 𑀲𑀻𑀳𑁄, 𑀢𑀭𑀘𑁆𑀙𑁄 𑀢𑀼 𑀫𑀺𑀕𑀸𑀤𑀦𑁄;

𑀩𑁆𑀬𑀕𑁆𑀖𑁄 𑀢𑀼 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑁄 𑀣, 𑀲𑀤𑁆𑀤𑀽𑀮𑁄 𑀤𑀻𑀧𑀺𑀦𑀻’𑀭𑀺𑀢𑁄.

𑀔𑀕𑁆𑀕 𑀔𑀕𑁆𑀕𑀯𑀺𑀲𑀸𑀡𑀸 𑀢𑀼, 𑀧𑀮𑀸𑀲𑀸𑀤𑁄 𑀘 𑀕𑀡𑁆𑀟𑀓𑁄;

𑀩𑁆𑀬𑀕𑁆𑀖𑀸𑀤𑀺𑀓𑁂 𑀯𑀸𑀴𑀫𑀺𑀕𑁄, 𑀲𑀸𑀧𑀤𑁄 𑀣 𑀧𑁆𑀮𑀯𑀗𑁆𑀕𑀫𑁄.

𑀫𑀓𑁆𑀓𑀝𑁄 𑀯𑀸𑀦𑀭𑁄 𑀲𑀸𑀔𑀸, 𑀫𑀺𑀕𑁄 𑀓𑀧𑀺 𑀯𑀮𑀻𑀫𑀼𑀔𑁄;

𑀕𑁄𑀦𑀗𑁆𑀕𑀼𑀮𑁄 [𑀕𑁄𑀦𑀗𑁆𑀕𑀮𑁄 (𑀝𑀻.)] 𑀢𑀺 𑀲𑁄 𑀫𑀢𑁄.

𑀲𑀺𑀗𑁆𑀕𑀸𑀮𑁄 [𑀲𑀺𑀕𑀸𑀮𑁄 (𑀲𑀻.)] 𑀚𑀫𑁆𑀩𑀼𑀓𑁄 𑀓𑁄𑀢𑁆𑀣𑀼, 𑀪𑁂𑀭𑀯𑁄 𑀘 𑀲𑀺𑀯𑀸 𑀧𑁆𑀬𑀣;

𑀩𑀺𑀴𑀸𑀭𑁄 𑀩𑀩𑁆𑀩𑀼 𑀫𑀜𑁆𑀚𑀸𑀭𑁄, 𑀓𑁄𑀓𑁄 𑀢𑀼 𑀘 𑀯𑀓𑁄 𑀪𑀯𑁂.

𑀫𑀳𑀺𑀁𑀲𑁄 [𑀫𑀳𑀺𑀲𑁄 (𑀲𑀻.)] 𑀘 𑀮𑀼𑀮𑀸𑀬𑁄 𑀣,

𑀳𑀭𑀺𑀡𑁄 𑀫𑀺𑀕 𑀲𑀸𑀭𑀗𑁆𑀕𑀸, 𑀫𑀕𑁄 𑀅𑀚𑀺𑀦𑀬𑁄𑀦𑀺 𑀘;

𑀏𑀡𑁂𑀬𑁆𑀬𑁄 ¶ 𑀏𑀡𑀻𑀫𑀺𑀕𑁄 𑀘, 𑀧𑀫𑁆𑀧𑀝𑀓𑁄 𑀢𑀼 𑀧𑀫𑁆𑀧𑀓𑁄;

𑀯𑀸𑀢𑀫𑀺𑀕𑁄 𑀢𑀼 𑀘𑀮𑀦𑀻, 𑀫𑀽𑀲𑀺𑀓𑁄 𑀢𑁆𑀯𑀸’𑀔𑀼 𑀉𑀦𑁆𑀤𑀼𑀭𑁄.

𑀘𑀫𑀭𑁄 𑀧𑀲𑀤𑁄 𑀘𑁂𑀯, 𑀓𑀼𑀭𑀼𑀗𑁆𑀕𑁄 𑀫𑀺𑀕𑀫𑀸𑀢𑀼𑀓𑀸;

𑀭𑀼𑀭𑀼 𑀭𑀗𑁆𑀓𑀼 𑀘 𑀦𑀻𑀓𑁄 𑀘, 𑀲𑀭𑀪𑀸𑀤𑀻 𑀫𑀺𑀕𑀦𑁆𑀢𑀭𑀸.

𑀧𑀺𑀬𑀓𑁄 𑀘𑀫𑀽𑀭𑀼 𑀓𑀤𑀮𑀻, 𑀫𑀺𑀕𑀸𑀤𑀻 𑀘𑀫𑁆𑀫𑀬𑁄𑀦𑀬𑁄;

𑀫𑀺𑀕𑀸 𑀢𑀼 𑀧𑀲𑀯𑁄 𑀲𑀻𑀳𑀸, 𑀤𑀬𑁄 𑀲𑀩𑁆𑀩𑀘𑀢𑀼𑀧𑁆𑀧𑀤𑀸.

𑀮𑀽𑀢𑀸 𑀢𑀼 𑀮𑀽𑀢𑀺𑀓𑀸 𑀉𑀡𑁆𑀡, 𑀦𑀸𑀪𑀺 𑀫𑀓𑁆𑀓𑀝𑀓𑁄 𑀲𑀺𑀬𑀸;

𑀯𑀺𑀘𑁆𑀙𑀺𑀓𑁄 𑀢𑁆𑀯𑀸’𑀴𑀺 𑀓𑀣𑀺𑀢𑁄, 𑀲𑀭𑀩𑀽 𑀖𑀭𑀕𑁄𑀴𑀺𑀓𑀸.

𑀕𑁄𑀥𑀸 𑀓𑀼𑀡𑁆𑀟𑁄 𑀧𑁆𑀬𑀣𑁄 𑀓𑀡𑁆𑀡, 𑀚𑀮𑀽𑀓𑀸 𑀲𑀢𑀧𑀤𑁆𑀬𑀣;

𑀓𑀮𑀦𑁆𑀤𑀓𑁄 𑀓𑀸𑀴𑀓𑀸 𑀣, 𑀦𑀓𑀼𑀮𑁄 𑀫𑀗𑁆𑀕𑀼𑀲𑁄 𑀪𑀯𑁂.

𑀓𑀓𑀡𑁆𑀝𑀓𑁄 𑀘 𑀲𑀭𑀝𑁄, 𑀓𑀻𑀝𑁄 𑀢𑀼 𑀧𑀼𑀴𑀯𑁄 𑀓𑀺𑀫𑀺;

𑀯𑀺𑀳𑀗𑁆𑀕𑁄 𑀯𑀺𑀳𑀕𑁄 𑀧𑀓𑁆𑀔𑀻, 𑀯𑀺𑀳𑀗𑁆𑀕𑀫 𑀔𑀕’𑀡𑁆𑀟𑀚𑀸;

𑀲𑀓𑀼𑀡𑁄 𑀘 𑀲𑀓𑀼𑀦𑁆𑀢𑁄 𑀯𑀺, 𑀧𑀢𑀗𑁆𑀕𑁄 𑀲𑀓𑀼𑀡𑀻 𑀤𑁆𑀯𑀺𑀚𑁄.

𑀯𑀓𑁆𑀓𑀗𑁆𑀕𑁄 𑀧𑀢𑁆𑀢𑀬𑀸𑀦𑁄 𑀘, 𑀧𑀢𑀦𑁆𑀢𑁄 𑀦𑀻𑀴𑀚𑁄 𑀪𑀯𑁂;

𑀢𑀩𑁆𑀪𑁂𑀤𑀸 𑀯𑀝𑁆𑀝𑀓𑀸 𑀚𑀻𑀯, 𑀜𑁆𑀚𑀻𑀯𑁄 𑀘𑀓𑁄𑀭 𑀢𑀺𑀢𑁆𑀢𑀺𑀭𑀸.

𑀲𑀸𑀴𑀺𑀓𑀸 𑀓𑀭𑀯𑀻𑀓𑁄 𑀘, 𑀭𑀯𑀺𑀳𑀁𑀲𑁄 𑀓𑀼𑀓𑀼𑀢𑁆𑀣𑀓𑁄;

𑀓𑀸𑀭𑀡𑁆𑀟𑀯𑁄 𑀘 𑀧𑀺𑀮𑀯𑁄 [𑀩𑀺𑀮𑀯𑁄 (𑀝𑀻.)], 𑀧𑁄𑀓𑁆𑀔𑀭𑀲𑀸𑀢𑀓𑀸’𑀤𑀬𑁄.

𑀧𑀢𑀢𑁆𑀢𑀁 𑀧𑁂𑀔𑀼𑀡𑀁 𑀧𑀢𑁆𑀢𑀁, 𑀧𑀓𑁆𑀔𑁄 𑀧𑀺𑀜𑁆𑀙𑀁 𑀙𑀤𑁄 𑀕𑀭𑀼;

𑀅𑀡𑁆𑀟𑀁 𑀢𑀼 𑀧𑀓𑁆𑀔𑀺𑀩𑀻𑀚𑁂 𑀣, 𑀦𑀻𑀴𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀓𑀼𑀮𑀸𑀯𑀓𑀁.

𑀲𑀼𑀧𑀡𑁆𑀡𑀫𑀸𑀢𑀸 𑀯𑀺𑀦𑀢𑀸, 𑀫𑀺𑀣𑀼𑀦𑀁 𑀣𑀻𑀧𑀼𑀫𑀤𑁆𑀯𑀬𑀁;

𑀬𑀼𑀕𑀁 𑀢𑀼 𑀬𑀼𑀕𑀮𑀁 𑀤𑁆𑀯𑀦𑁆𑀤𑀁, 𑀬𑀫𑀓𑀁 𑀬𑀫𑀮𑀁 𑀬𑀫𑀁.

𑀲𑀫𑀽𑀳𑁄 𑀕𑀡 𑀲𑀗𑁆𑀖𑀸𑀢𑀸, 𑀲𑀫𑀼𑀤𑀸𑀬𑁄 𑀘 𑀲𑀜𑁆𑀘𑀬𑁄;

𑀲𑀦𑁆𑀤𑁄𑀳𑁄 𑀦𑀺𑀯𑀳𑁄 𑀑𑀖𑁄, 𑀯𑀺𑀲𑀭𑁄 𑀦𑀺𑀓𑀭𑁄 𑀘𑀬𑁄.

𑀓𑀸𑀬𑁄 𑀔𑀦𑁆𑀥𑁄 𑀲𑀫𑀼𑀤𑀬𑁄, 𑀖𑀝𑀸 𑀲𑀫𑀺𑀢𑀺 𑀲𑀁𑀳𑀢𑀺;

𑀭𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀚𑁄 𑀲𑀫𑀯𑀸𑀬𑁄, 𑀧𑀽𑀕𑁄 𑀚𑀸𑀢𑀁 𑀓𑀤𑀫𑁆𑀩𑀓𑀁.

𑀩𑁆𑀬𑀽𑀳𑁄 ¶ 𑀯𑀺𑀢𑀸𑀦 𑀕𑀼𑀫𑁆𑀩𑀸 𑀘, 𑀓𑀮𑀸𑀧𑁄 𑀚𑀸𑀮 𑀫𑀡𑁆𑀟𑀮𑀁;

𑀲𑀗𑁆𑀖𑁄 𑀲𑀢𑁆𑀣𑁄 𑀢𑀼 𑀚𑀦𑁆𑀢𑀼𑀦𑀁.

𑀲𑀚𑀸𑀢𑀺𑀓𑀸𑀦𑀁 𑀢𑀼 𑀓𑀼𑀮𑀁, 𑀦𑀺𑀓𑀸𑀬𑁄 𑀢𑀼 𑀲𑀥𑀫𑁆𑀫𑀺𑀦𑀁;

𑀬𑀽𑀣𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀲𑀚𑀸𑀢𑀺𑀬, 𑀢𑀺𑀭𑀘𑁆𑀙𑀸𑀦𑀸𑀦𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀲𑀼𑀧𑀡𑁆𑀡𑁄 𑀯𑁂𑀦𑀢𑁂𑀬𑁆𑀬𑁄 𑀘, 𑀕𑀭𑀼𑀴𑁄 𑀯𑀺𑀳𑀕𑀸𑀥𑀺𑀧𑁄;

𑀧𑀭𑀧𑀼𑀝𑁆𑀞𑁄 𑀧𑀭𑀪𑀢𑁄, 𑀓𑀼𑀡𑀸𑀮𑁄 𑀓𑁄𑀓𑀺𑀮𑁄 𑀧𑀺𑀓𑁄.

𑀫𑁄𑀭𑁄 𑀫𑀬𑀽𑀭𑁄 𑀯𑀭𑀳𑀻, 𑀦𑀻𑀮𑀕𑀻𑀯 𑀲𑀺𑀔𑀡𑁆𑀟𑀺𑀦𑁄;

𑀓𑀮𑀸𑀧𑀻 𑀘 𑀲𑀺𑀔𑀻 𑀓𑁂𑀓𑀻, 𑀘𑀽𑀴𑀸 𑀢𑀼 𑀘 𑀲𑀺𑀔𑀸 𑀪𑀯𑁂.

𑀲𑀺𑀔𑀡𑁆𑀟𑁄 𑀯𑀭𑀳𑀜𑁆𑀘𑁂𑀯, 𑀓𑀮𑀸𑀧𑁄 𑀧𑀺𑀜𑁆𑀙 𑀫𑀧𑁆𑀬𑀣;

𑀘𑀦𑁆𑀤𑀓𑁄 𑀫𑁂𑀘𑀓𑁄 𑀘𑀸𑀣, 𑀙𑀧𑁆𑀧𑀤𑁄 𑀘 𑀫𑀥𑀼𑀩𑁆𑀩𑀢𑁄.

𑀫𑀥𑀼𑀮𑀻𑀳𑁄 𑀫𑀥𑀼𑀓𑀭𑁄, 𑀫𑀥𑀼𑀧𑁄 𑀪𑀫𑀭𑁄 𑀅𑀮𑀺;

𑀧𑀸𑀭𑀸𑀯𑀢𑁄 𑀓𑀧𑁄𑀢𑁄 𑀘, 𑀓𑀓𑀼𑀝𑁄 𑀘 𑀧𑀸𑀭𑁂𑀯𑀢𑁄.

𑀕𑀺𑀚𑁆𑀛𑁄 𑀕𑀤𑁆𑀥𑁄𑀣 𑀓𑀼𑀮𑀮𑁄, 𑀲𑁂𑀦𑁄 𑀩𑁆𑀬𑀕𑁆𑀖𑀻𑀦𑀲𑁄 𑀧𑁆𑀬𑀣;

𑀢𑀩𑁆𑀪𑁂𑀤𑀸 𑀲𑀓𑀼𑀡𑀕𑁆𑀖𑀺’𑀢𑁆𑀣𑀻, 𑀆𑀝𑁄 𑀤𑀩𑁆𑀩𑀺𑀫𑀼𑀔𑀤𑁆𑀯𑀺𑀚𑁄.

𑀉𑀳𑀼𑀗𑁆𑀓𑀸𑀭𑁄 𑀉𑀮𑀽𑀓𑁄 𑀘, 𑀓𑁄𑀲𑀺𑀬𑁄 𑀯𑀸𑀬𑀲𑀸𑀭𑀺 𑀘;

𑀓𑀸𑀓𑁄 𑀢𑁆𑀯’𑀭𑀺𑀝𑁆𑀞𑁄 𑀥𑀗𑁆𑀓𑁄 𑀘, 𑀩𑀮𑀺𑀧𑀼𑀝𑁆𑀞𑁄 𑀘 𑀯𑀸𑀬𑀲𑁄.

𑀯𑀸𑀭𑀡𑁄 𑀳𑀢𑁆𑀣𑀺𑀮𑀺𑀗𑁆𑀕𑁄 𑀘, 𑀳𑀢𑁆𑀣𑀺𑀲𑁄𑀡𑁆𑀟𑀯𑀺𑀳𑀗𑁆𑀕𑀫𑁄.

𑀉𑀓𑁆𑀓𑀼𑀲𑁄 𑀓𑀼𑀭𑀭𑁄 𑀓𑁄𑀮,𑀝𑁆𑀞𑀺𑀧𑀓𑁆𑀔𑀺𑀫𑁆𑀳𑀺 𑀘 𑀓𑀼𑀓𑁆𑀓𑀼𑀳𑁄;

𑀲𑀼𑀯𑁄 𑀢𑀼 𑀓𑀻𑀭𑁄 𑀘 𑀲𑀼𑀓𑁄, 𑀢𑀫𑁆𑀩𑀘𑀽𑀴𑁄 𑀢𑀼 𑀓𑀼𑀓𑁆𑀓𑀼𑀝𑁄.

𑀯𑀦𑀓𑀼𑀓𑁆𑀓𑀼𑀝𑁄 𑀘 𑀦𑀺𑀚𑁆𑀚𑀺𑀯𑁆𑀳𑁄, 𑀅𑀣 𑀓𑁄𑀜𑁆𑀘𑀸 𑀘 𑀓𑀼𑀦𑁆𑀢𑀦𑀻;

𑀘𑀓𑁆𑀓𑀯𑀸𑀓𑁄 𑀢𑀼 𑀘𑀓𑁆𑀓𑀯𑁆𑀳𑁄, 𑀲𑀸𑀭𑀗𑁆𑀕𑁄𑀢𑀼 𑀘 𑀘𑀸𑀢𑀓𑁄.

𑀮𑁄𑀳𑀧𑀺𑀝𑁆𑀞𑁄 𑀢𑀣𑀸 𑀓𑀗𑁆𑀓𑁄, 𑀔𑀜𑁆𑀚𑀭𑀻𑀝𑁄 𑀢𑀼 𑀔𑀜𑁆𑀚𑀦𑁄;

𑀓𑀮𑀯𑀺𑀗𑁆𑀓𑁄 𑀢𑀼 𑀘𑀸𑀝𑀓𑁄, 𑀤𑀺𑀦𑁆𑀤𑀺𑀪𑁄 𑀢𑀼 𑀓𑀺𑀓𑀻 𑀪𑀯𑁂.

𑀓𑀸𑀤𑀫𑁆𑀩𑁄 ¶ 𑀓𑀸𑀴𑀳𑀁𑀲𑁄𑀣, 𑀲𑀓𑀼𑀦𑁆𑀢𑁄 𑀪𑀸𑀲𑀧𑀓𑁆𑀔𑀺𑀦𑀺;

𑀔𑀼𑀤𑁆𑀤𑀸𑀤𑀻 𑀫𑀓𑁆𑀔𑀺𑀓𑀸𑀪𑁂𑀤𑀸, 𑀟𑀁𑀲𑁄 𑀧𑀺𑀗𑁆𑀕𑀮𑀫𑀓𑁆𑀔𑀺𑀓𑀸;

𑀆𑀲𑀸𑀝𑀺𑀓𑀸 𑀫𑀓𑁆𑀔𑀺𑀓𑀸𑀡𑁆𑀟𑀁, 𑀧𑀢𑀗𑁆𑀕𑁄 𑀲𑀮𑀪𑁄 𑀪𑀯𑁂.

𑀲𑀽𑀘𑀺𑀫𑀼𑀔𑁄 𑀘 𑀫𑀓𑀲𑁄, 𑀘𑀻𑀭𑀻 𑀢𑀼 𑀛𑀮𑁆𑀮𑀺𑀓𑀸 [𑀛𑀺𑀮𑁆𑀮𑀺𑀓𑀸 (𑀓.)] 𑀣 𑀘;

𑀚𑀢𑀼𑀓𑀸 𑀚𑀺𑀦𑀧𑀢𑁆𑀢𑀸 𑀣, 𑀳𑀁𑀲𑁄 𑀲𑁂𑀢𑀘𑁆𑀙𑀤𑁄 𑀪𑀯𑁂.

𑀢𑁂 𑀭𑀸𑀚𑀳𑀁𑀲𑀸 𑀭𑀢𑁆𑀢𑁂𑀳𑀺, 𑀧𑀸𑀤𑀢𑀼𑀡𑁆𑀟𑁂𑀳𑀺 𑀪𑀸𑀲𑀺𑀢𑀸;

𑀫𑀮𑁆𑀮𑀺𑀓𑀸’𑀔𑁆𑀬𑀸 𑀥𑀢𑀭𑀝𑁆𑀞𑀸, 𑀫𑀮𑀻𑀦𑁂𑀳𑁆𑀬’𑀲𑀺𑀢𑁂𑀳𑀺 𑀘.

𑁬𑁪𑁮. 𑀢𑀺𑀭𑀘𑁆𑀙𑁄 𑀢𑀼 𑀢𑀺𑀭𑀘𑁆𑀙𑀸𑀦𑁄, 𑀢𑀺𑀭𑀘𑁆𑀙𑀸𑀦𑀕𑀢𑁄 𑀲𑀺𑀬𑀸𑀢𑀺.

𑀅𑀥𑁄𑀪𑀼𑀯𑀦𑀁 𑀧𑀸𑀢𑀸𑀮𑀁, 𑀦𑀸𑀕𑀮𑁄𑀓𑁄 𑀭𑀲𑀸𑀢𑀮𑀁;

𑀭𑀦𑁆𑀥𑀁 𑀢𑀼 𑀯𑀺𑀯𑀭𑀁 𑀙𑀺𑀤𑁆𑀤𑀁, 𑀓𑀼𑀳𑀭𑀁 𑀲𑀼𑀲𑀺𑀭𑀁 𑀩𑀺𑀮𑀁.

𑀲𑀼𑀲𑀺’𑀢𑁆𑀣𑀻 𑀙𑀺𑀕𑁆𑀕𑀮𑀁 𑀲𑁄𑀩𑁆𑀪𑀁, 𑀲𑀘𑁆𑀙𑀺𑀤𑁆𑀤𑁂 𑀲𑀼𑀲𑀺𑀭𑀁 𑀢𑀺𑀲𑀼;

𑀣𑀺𑀬𑀁 𑀢𑀼 𑀓𑀸𑀲𑀼 𑀆𑀯𑀸𑀝𑁄, 𑀲𑀧𑁆𑀧𑀭𑀸𑀚𑀸 𑀢𑀼 𑀯𑀸𑀲𑀼𑀓𑀻.

𑀅𑀦𑀦𑁆𑀢𑁄 𑀦𑀸𑀕𑀭𑀸𑀚𑀸 𑀣, 𑀯𑀸𑀳𑀲𑁄’𑀚𑀕𑀭𑁄 𑀪𑀯𑁂;

𑀓𑀫𑁆𑀩𑀮𑁄’𑀲𑁆𑀲𑀢𑀭𑁄 𑀫𑁂𑀭𑀼, 𑀧𑀸𑀤𑁂 𑀦𑀸𑀕𑀸𑀣 𑀥𑀫𑁆𑀫𑀦𑀻;

𑀲𑀺𑀮𑀼𑀢𑁆𑀢𑁄 𑀖𑀭𑀲𑀧𑁆𑀧𑁄 𑀣, 𑀦𑀻𑀮𑀲𑀧𑁆𑀧𑁄 𑀲𑀺𑀮𑀸𑀪𑀼 𑀘.

𑀆𑀲𑀺𑀯𑀺𑀲𑁄 𑀪𑀼𑀚𑀗𑁆𑀕𑁄’𑀳𑀺, 𑀪𑀼𑀚𑀕𑁄 𑀘 𑀪𑀼𑀚𑀗𑁆𑀕𑀫𑁄;

𑀲𑀭𑀻𑀲𑀧𑁄 𑀨𑀡𑀻 𑀲𑀧𑁆𑀧𑀸, 𑀮𑀕𑀤𑁆𑀤𑀸 𑀪𑁄𑀕𑀺 𑀧𑀦𑁆𑀦𑀕𑀸.

𑀤𑁆𑀯𑀺𑀚𑀺𑀯𑁆𑀳𑁄 𑀉𑀭𑀕𑁄 𑀯𑀸𑀴𑁄, 𑀤𑀻𑀖𑁄 𑀘 𑀤𑀻𑀖𑀧𑀺𑀝𑁆𑀞𑀺𑀓𑁄;

𑀧𑀸𑀤𑀽𑀤𑀭𑁄 𑀯𑀺𑀲𑀥𑀭𑁄, 𑀪𑁄𑀕𑁄 𑀢𑀼 𑀨𑀡𑀺𑀦𑁄 𑀢𑀦𑀼.

𑀆𑀲𑀻’𑀢𑁆𑀣𑀻 ¶ 𑀲𑀧𑁆𑀧𑀤𑀸𑀞𑀸 𑀣, 𑀦𑀺𑀫𑁆𑀫𑁄𑀓𑁄 𑀓𑀜𑁆𑀘𑀼𑀓𑁄 𑀲𑀫𑀸;

𑀯𑀺𑀲𑀁 𑀢𑁆𑀯’𑀦𑀺𑀢𑁆𑀣𑀻 𑀕𑀭𑀴𑀁, 𑀢𑀩𑁆𑀪𑁂𑀤𑀸 𑀯𑀸 𑀳𑀮𑀸𑀳𑀮𑁄.

𑀓𑀸𑀴𑀓𑀽𑀝𑀸𑀤𑀬𑁄 𑀘𑀸𑀣, 𑀯𑀸𑀴𑀕𑁆𑀕𑀸𑀢𑁆𑀬’𑀳𑀺𑀢𑀼𑀡𑁆𑀟𑀺𑀓𑁄;

𑀦𑀺𑀭𑀬𑁄 𑀤𑀼𑀕𑁆𑀕𑀢𑀺’𑀢𑁆𑀣𑀻 𑀘, 𑀦𑀭𑀓𑁄, 𑀲𑁄 𑀫𑀳𑀸’𑀝𑁆𑀞𑀥𑀸;

𑀲𑀜𑁆𑀚𑀻𑀯𑁄 𑀓𑀸𑀴𑀲𑀼𑀢𑁆𑀢𑁄 𑀘, 𑀫𑀳𑀸𑀭𑁄𑀭𑀼𑀯 𑀭𑁄𑀭𑀼𑀯𑀸;

𑀧𑀢𑀸𑀧𑀦𑁄 𑀅𑀯𑀻𑀘𑀺’𑀢𑁆𑀣𑀻, 𑀲𑀗𑁆𑀖𑀸𑀢𑁄 𑀢𑀸𑀧𑀦𑁄 𑀇𑀢𑀺.

𑀣𑀺𑀬𑀁 𑀯𑁂𑀢𑀭𑀡𑀻 𑀮𑁄𑀳, 𑀓𑀼𑀫𑁆𑀪𑀻 𑀢𑀢𑁆𑀣 𑀚𑀮𑀸𑀲𑀬𑀸;

𑀅𑀡𑁆𑀡𑀯𑁄 𑀲𑀸𑀕𑀭𑁄 𑀲𑀺𑀦𑁆𑀥𑀼, 𑀲𑀫𑀼𑀤𑁆𑀤𑁄 𑀭𑀢𑀦𑀸𑀓𑀭𑁄;

𑀚𑀮𑀦𑀺𑀛𑀼’ 𑀤𑀥𑀺, 𑀢𑀲𑁆𑀲, 𑀪𑁂𑀤𑀸 𑀔𑀻𑀭𑀡𑁆𑀡𑀯𑀸𑀤𑀬𑁄.

𑀣𑁂𑀯𑁄 𑀢𑀼 𑀩𑀺𑀦𑁆𑀤𑀼 𑀨𑀼𑀲𑀺𑀢𑀁, 𑀪𑀫𑁄 𑀢𑀼 𑀚𑀮𑀦𑀺𑀕𑁆𑀕𑀫𑁄.

𑀆𑀧𑁄 𑀧𑀬𑁄 𑀚𑀮𑀁 𑀯𑀸𑀭𑀺, 𑀧𑀸𑀦𑀻𑀬𑀁 𑀲𑀮𑀺𑀮𑀁 𑀤𑀓𑀁;

𑀅𑀡𑁆𑀡𑁄 𑀦𑀻𑀭𑀁 𑀯𑀦𑀁 𑀯𑀸𑀮𑀁, 𑀢𑁄𑀬𑀁 𑀅𑀫𑁆𑀩𑀼’𑀤𑀓𑀜𑁆𑀘 𑀓𑀁.

𑀢𑀭𑀗𑁆𑀕𑁄 𑀘 𑀢𑀣𑀸 𑀪𑀗𑁆𑀕𑁄, 𑀊𑀫𑀺 𑀯𑀻𑀘𑀺 𑀧𑀼𑀫𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀉𑀮𑁆𑀮𑁄𑀮𑁄 𑀢𑀼 𑀘 𑀓𑀮𑁆𑀮𑁄𑀮𑁄, 𑀫𑀳𑀸𑀯𑀻𑀘𑀻𑀲𑀼 𑀓𑀣𑁆𑀬𑀢𑁂.

𑀚𑀫𑁆𑀩𑀸𑀮𑁄 𑀓𑀮𑀮𑀁 𑀧𑀗𑁆𑀓𑁄, 𑀘𑀺𑀓𑁆𑀔𑀮𑁆𑀮𑀁 𑀓𑀤𑁆𑀤𑀫𑁄 𑀧𑁆𑀬𑀣;

𑀧𑀼𑀮𑀺𑀦𑀁 𑀯𑀸𑀮𑀼𑀓𑀸 𑀯𑀡𑁆𑀡𑀼, 𑀫𑀭𑀽’𑀭𑀼 𑀲𑀺𑀓𑀢𑀸 𑀪𑀯𑁂.

𑀅𑀦𑁆𑀢𑀭𑀻𑀧𑀜𑁆𑀘 𑀤𑀻𑀧𑁄 𑀯𑀸, 𑀚𑀮𑀫𑀚𑁆𑀛𑀕𑀢𑀁 𑀣𑀮𑀁;

𑀢𑀻𑀭𑀁 𑀢𑀼 𑀓𑀽𑀮𑀁 𑀭𑁄𑀥𑀜𑁆𑀘, 𑀧𑀢𑀻𑀭𑀜𑁆𑀘 𑀢𑀝𑀁 𑀢𑀺𑀲𑀼.

𑀧𑀸𑀭𑀁 𑀧𑀭𑀫𑁆𑀳𑀺 𑀢𑀻𑀭𑀫𑁆𑀳𑀺, 𑀑𑀭𑀁 𑀢𑁆𑀯’𑀧𑀸𑀭 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀉𑀴𑀼𑀫𑁆𑀧𑁄 [𑀉𑀴𑀼𑀧𑁄 (𑀓.)] 𑀢𑀼 𑀧𑁆𑀮𑀯𑁄 𑀓𑀼𑀮𑁆𑀮𑁄, 𑀢𑀭𑁄 𑀘 𑀧𑀘𑁆𑀘𑀭𑀻’𑀢𑁆𑀣𑀺𑀬𑀁.

𑀢𑀭𑀡𑀻 𑀢𑀭𑀺 𑀦𑀸𑀯𑀸 𑀘, 𑀓𑀽𑀧𑀓𑁄 𑀢𑀼 𑀘 𑀓𑀼𑀫𑁆𑀪𑀓𑀁;

𑀧𑀘𑁆𑀙𑀸𑀩𑀦𑁆𑀥𑁄 𑀕𑁄𑀝𑀯𑀺𑀲𑁄, 𑀓𑀡𑁆𑀡𑀥𑀸𑀭𑁄 𑀢𑀼 𑀦𑀸𑀯𑀺𑀓𑁄.

𑀲𑀁𑀬𑀢𑁆𑀢𑀺𑀓𑀸 𑀢𑀼 𑀦𑀸𑀯𑀸𑀬, 𑀯𑀸𑀡𑀺𑀚𑁆𑀚𑀫𑀸𑀘𑀭𑀦𑁆𑀢𑀺 𑀬𑁂.

𑀦𑀸𑀯𑀸𑀬’𑀗𑁆𑀕𑀸’ ¶ 𑀮𑀗𑁆𑀓𑀸𑀭𑁄 𑀘, 𑀯𑀝𑀸𑀓𑀸𑀭𑁄 𑀨𑀺𑀬𑀸𑀤𑀬𑁄;

𑀧𑁄𑀢𑁄 𑀧𑀯𑀳𑀦𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀤𑁄𑀡𑀺 𑀢𑁆𑀯𑀺’𑀢𑁆𑀣𑀻 𑀢𑀣𑀸’𑀫𑁆𑀩𑀡𑀁 [𑀅𑀫𑁆𑀫𑀡𑀁 (𑀲𑀻.)].

𑀕𑀪𑀻𑀭 𑀦𑀺𑀦𑁆𑀦 𑀕𑀫𑁆𑀪𑀻𑀭𑀸, 𑀣𑁄 𑀢𑁆𑀢𑀸𑀦𑀁 𑀢𑀩𑁆𑀩𑀺𑀧𑀓𑁆𑀔𑀓𑁂;

𑀅𑀕𑀸𑀥𑀁 𑀢𑁆𑀯’𑀢𑀮𑀫𑁆𑀨𑀲𑁆𑀲𑀁, 𑀅𑀦𑀘𑁆𑀙𑁄 𑀓𑀮𑀼𑀲𑀸’𑀯𑀺𑀮𑀸.

𑀅𑀘𑁆𑀙𑁄 𑀧𑀲𑀦𑁆𑀦𑁄 𑀯𑀺𑀫𑀮𑁄, 𑀕𑀪𑀻𑀭𑀧𑁆𑀧𑀪𑀼𑀢𑀻 𑀢𑀺𑀲𑀼;

𑀥𑀻𑀯𑀭𑁄 𑀫𑀘𑁆𑀙𑀺𑀓𑁄 𑀫𑀘𑁆𑀙, 𑀩𑀦𑁆𑀥 𑀓𑁂𑀯𑀝𑁆𑀝 𑀚𑀸𑀮𑀺𑀓𑀸.

𑀫𑀘𑁆𑀙𑁄 𑀫𑀻𑀦𑁄 𑀚𑀮𑀘𑀭𑁄, 𑀧𑀼𑀣𑀼𑀮𑁄𑀫𑁄’𑀫𑁆𑀩𑀼𑀚𑁄 𑀛𑀲𑁄;

𑀭𑁄𑀳𑀺𑀢𑁄 𑀫𑀕𑁆𑀕𑀼𑀭𑁄 𑀲𑀺𑀗𑁆𑀕𑀻, 𑀩𑀮𑀚𑁄 𑀫𑀼𑀜𑁆𑀚 𑀧𑀸𑀯𑀼𑀲𑀸.

𑀲𑀢𑁆𑀢𑀯𑀗𑁆𑀓𑁄 𑀲𑀯𑀗𑁆𑀓𑁄 𑀘, 𑀦𑀴𑀫𑀻𑀦𑁄 𑀘 𑀕𑀡𑁆𑀟𑀓𑁄;

𑀲𑀼𑀲𑀼𑀓𑀸 𑀲𑀨𑀭𑀻 𑀫𑀘𑁆𑀙, 𑀧𑁆𑀧𑀪𑁂𑀤𑀸 𑀫𑀓𑀭𑀸𑀤𑀬𑁄.

𑀫𑀳𑀸𑀫𑀘𑁆𑀙𑀸 𑀢𑀺𑀫𑀺 𑀢𑀺𑀫𑀺, 𑀗𑁆𑀕𑀮𑁄 𑀢𑀺𑀫𑀺𑀭𑀧𑀺𑀗𑁆𑀕𑀮𑁄;

𑀆𑀦𑀦𑁆𑀤𑁄 𑀢𑀺𑀫𑀺𑀦𑀦𑁆𑀤𑁄 𑀘, 𑀅𑀚𑁆𑀛𑀸𑀭𑁄𑀳𑁄 𑀫𑀳𑀸𑀢𑀺𑀫𑀺.

𑀧𑀸𑀲𑀸𑀡𑀫𑀘𑁆𑀙𑁄 𑀧𑀸𑀞𑀻𑀦𑁄, 𑀯𑀗𑁆𑀓𑁄 𑀢𑀼 𑀩𑀴𑀺𑀲𑁄 𑀪𑀯𑁂;

𑀲𑀼𑀲𑀼𑀫𑀸𑀭𑁄 [𑀲𑀁𑀲𑀼𑀫𑀸𑀭𑁄 (𑀝𑀻.), 𑀲𑀼𑀁𑀲𑀼𑀫𑀸𑀭𑁄 (𑀲𑀻.)] 𑀢𑀼 𑀓𑀼𑀫𑁆𑀪𑀻𑀮𑁄,

𑀦𑀓𑁆𑀓𑁄 𑀓𑀼𑀫𑁆𑀫𑁄 𑀢𑀼 𑀓𑀘𑁆𑀙𑀧𑁄.

𑀓𑀓𑁆𑀓𑀝𑀓𑁄 𑀓𑀼𑀴𑀻𑀭𑁄 𑀘, 𑀚𑀮𑀽𑀓𑀸 𑀢𑀼 𑀘 𑀭𑀢𑁆𑀢𑀧𑀸;

𑀅𑀣 𑀲𑀺𑀧𑁆𑀧𑀻 𑀘 𑀲𑀼𑀢𑁆𑀢𑀺’𑀢𑁆𑀣𑀻, 𑀲𑀗𑁆𑀔𑁂 𑀢𑀼 𑀓𑀫𑁆𑀩𑀼’𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀔𑀼𑀤𑁆𑀤𑀲𑀗𑁆𑀔𑁆𑀬𑁂 𑀲𑀗𑁆𑀔𑀦𑀔𑁄, 𑀚𑀮𑀲𑀼𑀢𑁆𑀢𑀺 𑀘 𑀲𑀫𑁆𑀩𑀼𑀓𑁄.

𑀚𑀮𑀸𑀲𑀬𑁄 𑀚𑀮𑀸𑀥𑀸𑀭𑁄, 𑀕𑀫𑁆𑀪𑀻𑀭𑁄 𑀭𑀳𑀤𑁄 𑀣 𑀘;

𑀉𑀤𑀧𑀸𑀦𑁄 𑀧𑀸𑀦𑀓𑀽𑀧𑁄, 𑀔𑀸𑀢𑀁 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻’𑀢𑁆𑀣𑀺𑀬𑀁.

𑀢𑀴𑀸𑀓𑁄 𑀘 𑀲𑀭𑁄’𑀦𑀺𑀢𑁆𑀣𑀻, 𑀯𑀸𑀧𑀻 𑀘 𑀲𑀭𑀲𑀻’𑀢𑁆𑀣𑀺𑀬𑀁;

𑀤𑀳𑁄’𑀫𑁆𑀩𑀼𑀚𑀸𑀓𑀭𑁄 𑀘𑀸𑀣, 𑀧𑀮𑁆𑀮𑀮𑀁 𑀔𑀼𑀤𑁆𑀤𑀓𑁄 𑀲𑀭𑁄.

𑀅𑀦𑁄𑀢𑀢𑁆𑀢𑁄 𑀢𑀣𑀸 𑀓𑀡𑁆𑀡, 𑀫𑀼𑀡𑁆𑀟𑁄 𑀘 𑀭𑀣𑀓𑀸𑀭𑀓𑁄;

𑀙𑀤𑁆𑀤𑀦𑁆𑀢𑁄 𑀘 𑀓𑀼𑀡𑀸𑀮𑁄 𑀘, 𑀯𑀼𑀢𑁆𑀢𑀸 𑀫𑀦𑁆𑀤𑀸𑀓𑀺𑀦𑀻’𑀢𑁆𑀣𑀺𑀬𑀁.

𑀢𑀣𑀸 𑀲𑀻𑀳𑀧𑁆𑀧𑀧𑀸𑀢𑁄𑀢𑀺, 𑀏𑀢𑁂 𑀲𑀢𑁆𑀢 𑀫𑀳𑀸𑀲𑀭𑀸;

𑀆𑀳𑀸𑀯𑁄 𑀢𑀼 𑀦𑀺𑀧𑀸𑀦𑀜𑁆𑀘𑀸, 𑀔𑀸𑀢𑀁 𑀢𑀼 𑀤𑁂𑀯𑀔𑀸𑀢𑀓𑀁.

𑀲𑀯𑀦𑁆𑀢𑀻 ¶ 𑀦𑀺𑀦𑁆𑀦𑀕𑀸 𑀲𑀺𑀦𑁆𑀥𑀼, 𑀲𑀭𑀺𑀢𑀸 𑀆𑀧𑀕𑀸 𑀦𑀤𑀻;

𑀪𑀸𑀕𑀻𑀭𑀣𑀻 𑀢𑀼 𑀕𑀗𑁆𑀕𑀸 𑀣, 𑀲𑀫𑁆𑀪𑁂𑀤𑁄 𑀲𑀺𑀦𑁆𑀥𑀼𑀲𑀗𑁆𑀕𑀫𑁄.

𑀕𑀗𑁆𑀕𑀸’𑀘𑀺𑀭𑀯𑀢𑀻 𑀘𑁂𑀯, 𑀬𑀫𑀼𑀦𑀸 𑀲𑀭𑀪𑀽 (𑀲𑀭𑀩𑀽 [𑀲𑀭𑀬𑀽 (𑀓.)] ) 𑀫𑀳𑀻;

𑀇𑀫𑀸 𑀫𑀳𑀸𑀦𑀤𑀻 𑀧𑀜𑁆𑀘, 𑀘𑀦𑁆𑀤𑀪𑀸𑀕𑀸 𑀲𑀭𑀲𑁆𑀲𑀢𑀻 [𑀲𑀭𑀲𑁆𑀯𑀢𑀻 (𑀲𑀻. 𑀝𑀻.)].

𑀦𑁂𑀭𑀜𑁆𑀚𑀭𑀸 𑀘 𑀓𑀸𑀯𑁂𑀭𑀻, 𑀦𑀫𑁆𑀫𑀤𑀸𑀤𑀻 𑀘 𑀦𑀺𑀦𑁆𑀦𑀕𑀸;

𑀯𑀸𑀭𑀺𑀫𑀕𑁆𑀕𑁄 𑀧𑀡𑀸𑀮𑀻’𑀢𑁆𑀣𑀻 [𑀧𑀦𑀸𑀴𑀻 (𑀝𑀻.)], 𑀧𑀼𑀫𑁂 𑀘𑀦𑁆𑀤𑀦𑀺𑀓𑀸 𑀢𑀼 𑀘.

𑀚𑀫𑁆𑀩𑀸𑀮𑀻 𑀑𑀮𑀺𑀕𑀮𑁆𑀮𑁄 𑀘, 𑀕𑀸𑀫𑀤𑁆𑀯𑀸𑀭𑀫𑁆𑀳𑀺 𑀓𑀸𑀲𑀼𑀬𑀁;

𑀲𑀭𑁄𑀭𑀼𑀳𑀁 𑀲𑀢𑀧𑀢𑁆𑀢𑀁, 𑀅𑀭𑀯𑀺𑀦𑁆𑀤𑀜𑁆𑀘 𑀯𑀸𑀭𑀺𑀚𑀁.

𑀅𑀦𑀺𑀢𑁆𑀣𑀻 𑀧𑀤𑀼𑀫𑀁 𑀧𑀗𑁆𑀓𑁂, 𑀭𑀼𑀳𑀁 𑀦𑀮𑀺𑀦 𑀧𑁄𑀓𑁆𑀔𑀭𑀁;

𑀫𑀼𑀴𑀸𑀮𑀧𑀼𑀧𑁆𑀨𑀁 𑀓𑀫𑀮𑀁, 𑀪𑀺𑀲𑀧𑀼𑀧𑁆𑀨𑀁 𑀓𑀼𑀲𑁂𑀲𑀬𑀁.

𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀁 𑀲𑀺𑀢𑀁, 𑀭𑀢𑁆𑀢𑀁, 𑀓𑁄𑀓𑀦𑀤𑀁 𑀓𑁄𑀓𑀸𑀲𑀓𑁄;

𑀓𑀺𑀜𑁆𑀚𑀓𑁆𑀔𑁄 𑀓𑁂𑀲𑀭𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀤𑀡𑁆𑀟𑁄 𑀢𑀼 𑀦𑀸𑀮 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀪𑀺𑀲𑀁 𑀫𑀼𑀴𑀸𑀮𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀘, 𑀩𑀻𑀚𑀓𑁄𑀲𑁄 𑀢𑀼 𑀓𑀡𑁆𑀡𑀺𑀓𑀸;

𑀧𑀤𑀼𑀫𑀸𑀤𑀺𑀲𑀫𑀽𑀳𑁂 𑀢𑀼, 𑀪𑀯𑁂 𑀲𑀡𑁆𑀟𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀉𑀧𑁆𑀧𑀮𑀁 𑀓𑀼𑀯𑀮𑀬𑀜𑁆𑀘, 𑀦𑀻𑀮𑀁 𑀢𑁆𑀯𑀺’𑀦𑁆𑀤𑀻𑀯𑀭𑀁 𑀲𑀺𑀬𑀸;

𑀲𑁂𑀢𑁂𑀢𑀼 𑀓𑀼𑀫𑀼𑀤𑀜𑁆𑀘𑀲𑁆𑀲, 𑀓𑀦𑁆𑀤𑁄 𑀲𑀸𑀮𑀽𑀓 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀲𑁄𑀕𑀦𑁆𑀥𑀺𑀓𑀁 𑀓𑀮𑁆𑀮𑀳𑀸𑀭𑀁, 𑀤𑀓𑀲𑀻𑀢𑀮𑀺𑀓𑀁 𑀧𑁆𑀬𑀣;

𑀲𑁂𑀯𑀸𑀮𑁄 𑀦𑀻𑀮𑀺𑀓𑀸 𑀘𑀸𑀣, 𑀪𑀺𑀲𑀺𑀦𑁆𑀬’𑀫𑁆𑀩𑀼𑀚𑀺𑀦𑀻 𑀪𑀯𑁂.

𑁬𑁯𑁦. 𑀲𑁂𑀯𑀸𑀮𑀸 𑀢𑀺𑀮𑀩𑀻𑀚𑀜𑁆𑀘, 𑀲𑀗𑁆𑀔𑁂 𑀘 𑀧𑀡𑀓𑀸𑀤𑀬𑁄𑀢𑀺.

𑀯𑀺𑀲𑁂𑀲𑁆𑀬𑀸𑀥𑀻𑀦 𑀲𑀁𑀓𑀺𑀡𑁆𑀡𑀸, 𑀦𑁂𑀓𑀢𑁆𑀣𑁂𑀳𑁆𑀬’𑀩𑁆𑀬𑀬𑁂𑀳𑀺 𑀘;

𑀲𑀸’𑀗𑁆𑀕𑁄’𑀧𑀸𑀗𑁆𑀕𑁂𑀳𑀺 𑀓𑀣𑁆𑀬𑀦𑁆𑀢𑁂, 𑀓𑀡𑁆𑀟𑁂 𑀯𑀕𑁆𑀕𑀸 𑀇𑀳 𑀓𑁆𑀓𑀫𑀸.

𑀕𑀼𑀡𑀤𑀩𑁆𑀩𑀓𑁆𑀭𑀺𑀬𑀸𑀲𑀤𑁆𑀤𑀸, ¶ 𑀲𑀺𑀬𑀼𑀁 𑀲𑀩𑁆𑀩𑁂 𑀯𑀺𑀲𑁂𑀲𑀦𑀸;

𑀯𑀺𑀲𑁂𑀲𑁆𑀬𑀸𑀥𑀻𑀦𑀪𑀸𑀯𑁂𑀦, 𑀯𑀺𑀲𑁂𑀲𑁆𑀬𑀲𑀫𑀮𑀺𑀗𑁆𑀕𑀺𑀦𑁄.

𑀲𑁄𑀪𑀦𑀁 𑀭𑀼𑀘𑀺𑀭𑀁 𑀲𑀸𑀥𑀼, 𑀫𑀦𑀼𑀜𑁆𑀜𑀁 𑀘𑀸𑀭𑀼 𑀲𑀼𑀦𑁆𑀤𑀭𑀁;

𑀯𑀕𑁆𑀕𑀼 𑀫𑀦𑁄𑀭𑀫𑀁 𑀓𑀦𑁆𑀢𑀁, 𑀳𑀸𑀭𑀻 𑀫𑀜𑁆𑀚𑀼 𑀘 𑀧𑁂𑀲𑀮𑀁.

𑀪𑀤𑁆𑀤𑀁 𑀯𑀸𑀫𑀜𑁆𑀘 𑀓𑀮𑁆𑀬𑀸𑀡𑀁, 𑀫𑀦𑀸𑀧𑀁 𑀮𑀤𑁆𑀥𑀓𑀁 𑀲𑀼𑀪𑀁;

𑀉𑀢𑁆𑀢𑀫𑁄 𑀧𑀯𑀭𑁄 𑀚𑁂𑀝𑁆𑀞𑁄, 𑀧𑀫𑀼𑀔𑀸’𑀦𑀼𑀢𑁆𑀢𑀭𑁄 𑀯𑀭𑁄.

𑀫𑀼𑀔𑁆𑀬𑁄 𑀧𑀥𑀸𑀦𑀁 𑀧𑀸𑀫𑁄𑀓𑁆𑀔𑁄, 𑀧𑀭 𑀫𑀕𑁆𑀕𑀜𑁆𑀜 𑀫𑀼𑀢𑁆𑀢𑀭𑀁;

𑀧𑀡𑀻𑀢𑀁 𑀧𑀭𑀫𑀁 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀕𑀸𑀫𑀡𑀻 𑀲𑁂𑀝𑁆𑀞 𑀲𑀢𑁆𑀢𑀫𑀸.

𑀯𑀺𑀲𑀺𑀝𑁆𑀞𑀸’𑀭𑀺𑀬 𑀦𑀸𑀕𑁂’𑀓𑁄, 𑀲𑀪𑀕𑁆𑀕𑀸 𑀫𑁄𑀓𑁆𑀔 𑀧𑀼𑀗𑁆𑀕𑀯𑀸;

𑀲𑀻𑀳 𑀓𑀼𑀜𑁆𑀚𑀭 𑀲𑀤𑁆𑀤𑀽𑀮𑀸, 𑀤𑀻 𑀢𑀼 𑀲𑀫𑀸𑀲𑀕𑀸 𑀧𑀼𑀫𑁂.

𑀘𑀺𑀢𑁆𑀢’𑀓𑁆𑀔𑀺 𑀧𑀻𑀢𑀺𑀚𑀦𑀦, 𑀫𑀩𑁆𑀬𑀸𑀲𑁂𑀓 𑀫𑀲𑁂𑀘𑀦𑀁;

𑀇𑀝𑁆𑀞𑀁 𑀢𑀼 𑀲𑀼𑀪𑀕𑀁 𑀳𑀚𑁆𑀚𑀁, 𑀤𑀬𑀺𑀢𑀁 𑀯𑀮𑁆𑀮𑀪𑀁 𑀧𑀺𑀬𑀁.

𑀢𑀼𑀘𑁆𑀙𑀜𑁆𑀘 𑀭𑀺𑀢𑁆𑀢𑀓𑀁 𑀲𑀼𑀜𑁆𑀜𑀁, 𑀅𑀣𑀸’𑀲𑀸𑀭𑀜𑁆𑀘 𑀨𑁂𑀕𑁆𑀕𑀼 𑀘;

𑀫𑁂𑀚𑁆𑀛𑀁 𑀧𑀽𑀢𑀁 𑀧𑀯𑀺𑀢𑁆𑀢𑁄 𑀣, 𑀅𑀯𑀺𑀭𑀤𑁆𑀥𑁄 𑀅𑀧𑀡𑁆𑀡𑀓𑁄.

𑀉𑀓𑁆𑀓𑀝𑁆𑀞𑁄 𑀘 𑀧𑀓𑀝𑁆𑀞𑁄 𑀣, 𑀦𑀺𑀳𑀻𑀦𑁄 𑀳𑀻𑀦 𑀮𑀸𑀫𑀓𑀸;

𑀧𑀢𑀺𑀓𑀺𑀝𑁆𑀞𑀁 𑀦𑀺𑀓𑀺𑀝𑁆𑀞𑀜𑁆𑀘, 𑀇𑀢𑁆𑀢𑀭𑀸’𑀯𑀚𑁆𑀚 𑀓𑀼𑀘𑁆𑀙𑀺𑀢𑀸.

𑀩𑁆𑀭𑀳𑀸 𑀫𑀳𑀦𑁆𑀢𑀁 𑀯𑀺𑀧𑀼𑀮𑀁, 𑀯𑀺𑀲𑀸𑀮𑀁 𑀧𑀼𑀣𑀼𑀮𑀁 𑀧𑀼𑀣𑀼.

𑀕𑀭𑀼’𑀭𑀼 𑀯𑀺𑀢𑁆𑀣𑀺𑀡𑁆𑀡 𑀫𑀣𑁄, 𑀧𑀻𑀦𑀁 𑀣𑀽𑀮𑀜𑁆𑀘 𑀧𑀻𑀯𑀭𑀁;

𑀣𑀼𑀮𑁆𑀮𑀜𑁆𑀘 𑀯𑀞𑀭𑀜𑁆𑀘𑀸 𑀣, 𑀆𑀘𑀺𑀢𑀁 𑀦𑀺𑀘𑀺𑀢𑀁 𑀪𑀯𑁂.

𑀲𑀩𑁆𑀩𑀁 𑀲𑀫𑀢𑁆𑀢 𑀫𑀔𑀺𑀮𑀁, 𑀦𑀺𑀔𑀺𑀮𑀁 𑀲𑀓𑀮𑀁 𑀢𑀣𑀸;

𑀦𑀺𑀲𑁆𑀲𑁂𑀲𑀁 𑀓𑀲𑀺𑀡𑀸’𑀲𑁂𑀲𑀁, 𑀲𑀫𑀕𑁆𑀕𑀜𑁆𑀘 𑀅𑀦𑀽𑀦𑀓𑀁,

𑀪𑀽𑀭𑀺 𑀧𑀳𑀼𑀢𑀁 𑀧𑀘𑀼𑀭𑀁, 𑀪𑀺𑀬𑁆𑀬𑁄 𑀲𑀫𑁆𑀩𑀳𑀼𑀮𑀁 𑀩𑀳𑀼;

𑀬𑁂𑀪𑀼𑀬𑁆𑀬𑀁 𑀩𑀳𑀼𑀮𑀁 𑀘𑀸𑀣, 𑀩𑀸𑀳𑀺𑀭𑀁 𑀧𑀭𑀺𑀩𑀸𑀳𑀺𑀭𑀁.

𑀧𑀭𑁄𑀲𑀢𑀸𑀤𑀻 𑀢𑁂, 𑀬𑁂𑀲𑀁, 𑀧𑀭𑀁 𑀫𑀢𑁆𑀢𑀁 𑀲𑀢𑀸𑀤𑀺𑀢𑁄;

𑀧𑀭𑀺𑀢𑁆𑀢𑀁 𑀲𑀼𑀔𑀼𑀫𑀁 𑀔𑀼𑀤𑁆𑀤𑀁, 𑀣𑁄𑀓 𑀫𑀧𑁆𑀧𑀁 𑀓𑀺𑀲𑀁 𑀢𑀦𑀼.

𑀘𑀼𑀮𑁆𑀮𑀁 𑀫𑀢𑁆𑀢𑁂’𑀢𑁆𑀣𑀺𑀬𑀁 𑀮𑁂𑀲,

𑀲𑀫𑀻𑀧𑀁 𑀦𑀺𑀓𑀝𑀸’𑀲𑀦𑁆𑀦𑁄, 𑀧𑀓𑀝𑁆𑀞𑀸’𑀪𑁆𑀬𑀸𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑀁.

𑀅𑀯𑀺𑀤𑀽𑀭𑀜𑁆𑀘 ¶ 𑀲𑀸𑀫𑀦𑁆𑀢𑀁, 𑀲𑀦𑁆𑀦𑀺𑀓𑀝𑁆𑀞 𑀫𑀼𑀧𑀦𑁆𑀢𑀺𑀓𑀁;

𑀲𑀓𑀸𑀲𑀁 𑀅𑀦𑁆𑀢𑀺𑀓𑀁 𑀜𑀢𑁆𑀢𑀁, 𑀤𑀽𑀭𑀁 𑀢𑀼 𑀯𑀺𑀧𑁆𑀧𑀓𑀝𑁆𑀞𑀓𑀁.

𑀦𑀺𑀭𑀦𑁆𑀢𑀭𑀁 𑀖𑀦𑀁 𑀲𑀦𑁆𑀤𑀁, 𑀯𑀺𑀭𑀴𑀁 𑀧𑁂𑀮𑀯𑀁 𑀢𑀦𑀼;

𑀅𑀣𑀸 𑀬𑀢𑀁 𑀤𑀻𑀖 𑀫𑀣𑁄, 𑀦𑀺𑀢𑁆𑀢𑀮𑀁 𑀯𑀝𑁆𑀝 𑀯𑀝𑁆𑀝𑀼𑀮𑀁.

𑀉𑀘𑁆𑀘𑁄 𑀢𑀼 𑀉𑀦𑁆𑀦𑀢𑁄 𑀢𑀼𑀗𑁆𑀕𑁄, 𑀉𑀤𑀕𑁆𑀕𑁄 𑀘𑁂𑀯 𑀉𑀘𑁆𑀙𑀺𑀢𑁄;

𑀦𑀻𑀘𑁄 𑀭𑀲𑁆𑀲𑁄 𑀯𑀸𑀫𑀦𑁄 𑀣, 𑀅𑀚𑀺𑀫𑁆𑀳𑁄 𑀧𑀕𑀼𑀡𑁄 𑀉𑀚𑀼.

𑀅𑀴𑀸𑀭𑀁 𑀯𑁂𑀮𑁆𑀮𑀺𑀢𑀁 𑀯𑀗𑁆𑀓𑀁, 𑀓𑀼𑀝𑀺𑀮𑀁 𑀚𑀺𑀫𑁆𑀳 𑀓𑀼𑀜𑁆𑀘𑀺𑀢𑀁;

𑀥𑀼𑀯𑁄 𑀘 𑀲𑀲𑁆𑀲𑀢𑁄 𑀦𑀺𑀘𑁆𑀘𑁄, 𑀲𑀤𑀸𑀢𑀦 𑀲𑀦𑀦𑁆𑀢𑀦𑀸.

𑀓𑀽𑀝𑀝𑁆𑀞𑁄 𑀢𑁆𑀯𑁂’𑀓𑀭𑀽𑀧𑁂𑀦, 𑀓𑀸𑀮𑀩𑁆𑀬𑀸𑀧𑀻 𑀧𑀓𑀸𑀲𑀺𑀢𑁄;

𑀮𑀳𑀼 𑀲𑀮𑁆𑀮𑀳𑀼𑀓𑀁 𑀘𑀸𑀣, 𑀲𑀗𑁆𑀔𑁆𑀬𑀸𑀢𑀁 𑀕𑀡𑀺𑀢𑀁 𑀫𑀺𑀢𑀁.

𑀢𑀺𑀡𑁆𑀳𑀁 𑀢𑀼 𑀢𑀺𑀔𑀺𑀡𑀁 𑀢𑀺𑀩𑁆𑀩𑀁, 𑀘𑀡𑁆𑀟𑀁 𑀉𑀕𑁆𑀕𑀁 𑀔𑀭𑀁 𑀪𑀯𑁂;

𑀚𑀗𑁆𑀕𑀫𑀜𑁆𑀘 𑀘𑀭𑀜𑁆𑀘𑁂𑀯, 𑀢𑀲𑀁 𑀜𑁂𑀬𑁆𑀬𑀁 𑀘𑀭𑀸𑀘𑀭𑀁.

𑀓𑀫𑁆𑀧𑀦𑀁 𑀘𑀮𑀦𑀁 𑀘𑀸𑀣, 𑀅𑀢𑀺𑀭𑀺𑀢𑁆𑀢𑁄 𑀢𑀣𑀸’𑀥𑀺𑀓𑁄;

𑀣𑀸𑀯𑀭𑁄 𑀚𑀗𑁆𑀕𑀫𑀸 𑀅𑀜𑁆𑀜𑁄, 𑀮𑁄𑀮𑀁 𑀢𑀼 𑀘𑀜𑁆𑀘𑀮𑀁 𑀘𑀮𑀁.

𑀢𑀭𑀮𑀜𑁆𑀘 𑀧𑀼𑀭𑀸𑀡𑁄 𑀢𑀼, 𑀧𑀼𑀭𑀸𑀢𑀦 𑀲𑀦𑀦𑁆𑀢𑀦𑀸;

𑀘𑀺𑀭𑀦𑁆𑀢𑀦𑁄 𑀣 𑀧𑀘𑁆𑀘𑀕𑁆𑀖𑁄, 𑀦𑀽𑀢𑀦𑁄’𑀪𑀺𑀦𑀯𑁄 𑀦𑀯𑁄.

𑀓𑀼𑀭𑀽𑀭𑀁 𑀓𑀞𑀺𑀦𑀁 𑀤𑀴𑁆𑀳𑀁, 𑀦𑀺𑀝𑁆𑀞𑀼𑀭𑀁 𑀓𑀓𑁆𑀔𑀴𑀁 𑀪𑀯𑁂;

𑀅𑀦𑀺𑀢𑁆𑀣𑁆𑀬’𑀦𑁆𑀢𑁄 𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑁄, 𑀧𑀦𑁆𑀢𑁄 𑀘 𑀧𑀘𑁆𑀙𑀺𑀫’𑀦𑁆𑀢𑀺𑀫𑀸.

𑀚𑀺𑀖𑀜𑁆𑀜𑀁 𑀘𑀭𑀺𑀫𑀁 𑀧𑀼𑀩𑁆𑀩𑀁, 𑀢𑁆𑀯’𑀕𑁆𑀕𑀁 𑀧𑀞𑀫 𑀫𑀸𑀤𑀺 𑀲𑁄;

𑀧𑀢𑀺𑀭𑀽𑀧𑁄 𑀦𑀼𑀘𑁆𑀙𑀯𑀺𑀓𑀁, 𑀅𑀣 𑀫𑁄𑀖𑀁 𑀦𑀺𑀭𑀢𑁆𑀣𑀓𑀁.

𑀩𑁆𑀬𑀢𑁆𑀢𑀁 𑀧𑀼𑀝 [𑀨𑀼𑀝𑀁 (𑀲𑀻.)] 𑀜𑁆𑀘 𑀫𑀼𑀤𑀼 𑀢𑀼, 𑀲𑀼𑀓𑀼𑀫𑀸𑀭𑀜𑁆𑀘 𑀓𑁄𑀫𑀮𑀁;

𑀧𑀘𑁆𑀘𑀓𑁆𑀔𑀁 𑀇𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀕𑁆𑀕𑀬𑁆𑀳𑀁, 𑀅𑀧𑀘𑁆𑀘𑀓𑁆𑀔𑀁 𑀅𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀁.

𑀇𑀢𑀭𑀸’𑀜𑁆𑀜𑀢𑀭𑁄 𑀏𑀓𑁄, 𑀅𑀜𑁆𑀜𑁄 𑀩𑀳𑀼𑀯𑀺𑀥𑁄 𑀢𑀼 𑀘;

𑀦𑀸𑀦𑀸𑀭𑀽𑀧𑁄 𑀘 𑀯𑀺𑀯𑀺𑀥𑁄, 𑀅𑀩𑀸𑀥𑀁 𑀢𑀼 𑀦𑀺𑀭𑀕𑁆𑀕𑀮𑀁.

𑀅𑀣𑁂’𑀓𑀸𑀓𑀻 𑀘 𑀏𑀓𑀘𑁆𑀘𑁄, 𑀏𑀓𑁄 𑀘 𑀏𑀓𑀓𑁄 𑀲𑀫𑀸;

𑀲𑀸𑀥𑀸𑀭𑀡𑀜𑁆𑀘 𑀲𑀸𑀫𑀜𑁆𑀜𑀁, 𑀲𑀫𑁆𑀩𑀸𑀥𑁄 𑀢𑀼 𑀘 𑀲𑀁𑀓𑀝𑀁.

𑀯𑀸𑀫𑀁 𑀓𑀴𑁂𑀯𑀭𑀁 𑀲𑀩𑁆𑀬𑀁; 𑀅𑀧𑀲𑀩𑁆𑀬𑀁 𑀢𑀼 𑀤𑀓𑁆𑀔𑀺𑀡𑀁;

𑀧𑀝𑀺𑀓𑀽𑀮𑀁 𑀢𑁆𑀯’𑀧𑀲𑀩𑁆𑀬𑀁, 𑀕𑀳𑀦𑀁 𑀓𑀮𑀺𑀮𑀁 𑀲𑀫𑀸.

𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑀁 ¶ 𑀩𑀳𑀼𑀪𑁂𑀤𑀁, 𑀲𑀁𑀓𑀺𑀡𑁆𑀡𑀸’ 𑀓𑀺𑀡𑁆𑀡 𑀲𑀁𑀓𑀼𑀮𑀸;

𑀓𑀢𑀳𑀢𑁆𑀣𑁄 𑀘 𑀓𑀼𑀲𑀮𑁄, 𑀧𑀯𑀻𑀡𑀸’𑀪𑀺𑀜𑁆𑀜 𑀲𑀺𑀓𑁆𑀔𑀺𑀢𑀸.

𑀦𑀺𑀧𑀼𑀡𑁄 𑀘 𑀧𑀝𑀼 𑀙𑁂𑀓𑁄, 𑀘𑀸𑀢𑀼𑀭𑁄 𑀤𑀓𑁆𑀔 𑀧𑁂𑀲𑀮𑀸;

𑀩𑀸𑀮𑁄 𑀤𑀢𑁆𑀢𑀼 𑀚𑀮𑁄 𑀫𑀽𑀴𑁆𑀳𑁄, 𑀫𑀦𑁆𑀤𑁄 𑀯𑀺𑀜𑁆𑀜𑀽 𑀘 𑀩𑀸𑀮𑀺𑀲𑁄.

𑀧𑀼𑀜𑁆𑀜𑀯𑀸 𑀲𑀼𑀓𑀢𑀻 𑀥𑀜𑁆𑀜𑁄, 𑀫𑀳𑀼𑀲𑁆𑀲𑀸𑀳𑁄 𑀫𑀳𑀸𑀥𑀺𑀢𑀺;

𑀫𑀳𑀸𑀢𑀡𑁆𑀳𑁄 𑀫𑀳𑀺𑀘𑁆𑀙𑁄 𑀣, 𑀳𑀤𑀬𑀻 𑀳𑀤𑀬𑀸𑀮𑀼 𑀘.

𑀲𑀼𑀫𑀦𑁄 𑀳𑀝𑁆𑀞𑀘𑀺𑀢𑁆𑀢𑁄 𑀣, 𑀤𑀼𑀫𑁆𑀫𑀦𑁄 𑀯𑀺𑀫𑀦𑁄 𑀧𑁆𑀬𑀣;

𑀯𑀤𑀸𑀦𑀺𑀬𑁄 𑀯𑀤𑀜𑁆𑀜𑀽 𑀘, 𑀤𑀸𑀦𑀲𑁄𑀡𑁆𑀟𑁄 𑀩𑀳𑀼𑀧𑁆𑀧𑀤𑁄.

𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑁄 𑀯𑀺𑀤𑀺𑀢𑁄 𑀘𑁂𑀯, 𑀧𑀲𑀺𑀤𑁆𑀥𑁄 𑀧𑀸𑀓𑀝𑁄 𑀪𑀯𑁂.

𑀇𑀲𑁆𑀲𑀭𑁄 𑀦𑀸𑀬𑀓𑁄 𑀲𑀸𑀫𑀻, 𑀧𑀢𑀻’𑀲𑀸’𑀥𑀺𑀧𑀢𑀻 𑀧𑀪𑀽;

𑀤𑀸𑀦𑀸𑀭𑀳𑁄 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑁄, 𑀲𑀺𑀦𑀺𑀤𑁆𑀥𑁄 𑀢𑀼 𑀘 𑀯𑀘𑁆𑀙𑀮𑁄;

𑀓𑀸𑀭𑀼𑀡𑀺𑀓𑁄 𑀤𑀬𑀸𑀮𑀼𑀧𑀺, 𑀲𑀽𑀭𑀢𑁄 𑀉𑀲𑁆𑀲𑀼𑀓𑁄 𑀢𑀼 𑀘;

𑀇𑀝𑁆𑀞𑀢𑁆𑀣𑁂 𑀉𑀬𑁆𑀬𑀼𑀢𑁄 𑀘𑀸𑀣, 𑀤𑀻𑀖𑀲𑀼𑀢𑁆𑀢𑁄 𑀘𑀺𑀭𑀓𑁆𑀭𑀺𑀬𑁄.

𑀧𑀭𑀸𑀥𑀻𑀦𑁄 𑀧𑀭𑀸𑀬𑀢𑁆𑀢𑁄, 𑀆𑀬𑀢𑁆𑀢𑁄 𑀢𑀼 𑀘 𑀲𑀦𑁆𑀢𑀓𑁄;

𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑁄 𑀅𑀥𑀻𑀦𑁄 𑀘, 𑀲𑀘𑁆𑀙𑀦𑁆𑀤𑁄 𑀢𑀼 𑀘 𑀲𑁂𑀭𑀺𑀦𑀺.

𑀅𑀦𑀺𑀲𑀫𑁆𑀫𑀓𑀸𑀭𑀻 𑀚𑀫𑁆𑀫𑁄, 𑀅𑀢𑀺𑀢𑀡𑁆𑀳𑁄 𑀢𑀼 𑀮𑁄𑀮𑀼𑀧𑁄;

𑀕𑀺𑀤𑁆𑀥𑁄 𑀢𑀼 𑀮𑀼𑀤𑁆𑀥𑁄 𑀮𑁄𑀮𑁄 𑀣,

𑀓𑀼𑀡𑁆𑀞𑁄 𑀫𑀦𑁆𑀤𑁄 𑀓𑁆𑀭𑀺𑀬𑀸𑀲𑀼 𑀳𑀺.

𑀓𑀸𑀫𑀬𑀺𑀢𑀸 𑀢𑀼 𑀓𑀫𑀺𑀢𑀸, 𑀓𑀸𑀫𑀦𑁄 𑀓𑀸𑀫𑀺 𑀓𑀸𑀫𑀼𑀓𑁄;

𑀲𑁄𑀡𑁆𑀟𑁄 𑀫𑀢𑁆𑀢𑁄 𑀯𑀺𑀥𑁂𑀬𑁆𑀬𑁄 𑀢𑀼,

𑀧𑀕𑀩𑁆𑀪𑁄 ¶ 𑀧𑀝𑀺𑀪𑀸𑀬𑀼𑀢𑁆𑀢𑁄, 𑀪𑀻𑀲𑀻𑀮𑁄 𑀪𑀻𑀭𑀼 𑀪𑀻𑀭𑀼𑀓𑁄;

𑀅𑀥𑀻𑀭𑁄 [𑀅𑀯𑀻𑀭𑁄 (𑀝𑀻.)] 𑀓𑀸𑀢𑀭𑁄 𑀘𑀸𑀣,

𑀓𑁄𑀥𑀦𑁄 𑀭𑁄𑀲𑀦𑁄 [𑀤𑁄𑀲𑀦𑁄 (𑀲𑀻.)] 𑀓𑁄𑀧𑀻,

𑀲𑀳𑀦𑁄 𑀔𑀫𑀦𑁄 𑀔𑀦𑁆𑀢𑀸, 𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀯𑀸 𑀘 𑀔𑀦𑁆𑀢𑀺𑀫𑀸.

𑀲𑀤𑁆𑀥𑀸𑀬𑀼𑀢𑁆𑀢𑁄 𑀢𑀼 𑀲𑀤𑁆𑀥𑀸𑀮𑀼, 𑀥𑀚𑀯𑀸 𑀢𑀼 𑀥𑀚𑀸𑀮𑀼 𑀘 [𑀮𑀚𑁆𑀚𑀸𑀮𑀼𑀢𑀼 𑀘 𑀮𑀚𑁆𑀚𑀯𑀸 (𑀓.)];

𑀦𑀺𑀤𑁆𑀤𑀸𑀮𑀼 𑀦𑀺𑀤𑁆𑀤𑀸𑀲𑀻𑀮𑁄 𑀣, 𑀪𑀲𑁆𑀲𑀭𑁄 𑀪𑀸𑀲𑀼𑀭𑁄 𑀪𑀯𑁂.

𑀦𑀕𑁆𑀕𑁄 𑀤𑀺𑀕𑀫𑁆𑀩𑀭𑁄’𑀯𑀢𑁆𑀣𑁄, 𑀖𑀲𑁆𑀫𑀭𑁄 𑀢𑀼 𑀘 𑀪𑀓𑁆𑀔𑀓𑁄;

𑀏𑀴𑀫𑀽𑀕𑁄 𑀢𑀼 𑀯𑀢𑁆𑀢𑀼𑀜𑁆𑀘, 𑀲𑁄𑀢𑀼𑀁 𑀘𑀸’𑀓𑀼𑀲𑀮𑁄 𑀪𑀯𑁂.

𑀫𑀼𑀔𑀭𑁄 𑀤𑀼𑀫𑁆𑀫𑀼𑀔𑀸’𑀩𑀤𑁆𑀥, 𑀫𑀼𑀔𑀸 𑀘𑀸𑀧𑁆𑀧𑀺𑀬𑀯𑀸𑀤𑀺𑀦𑀺;

𑀯𑀸𑀘𑀸𑀮𑁄 𑀩𑀳𑀼𑀕𑀸𑀭𑀬𑁆𑀳, 𑀯𑀘𑁂 𑀯𑀢𑁆𑀢𑀸 𑀢𑀼 𑀲𑁄 𑀯𑀤𑁄.

𑀯𑀺𑀫𑁆𑀳𑀬𑁄’𑀘𑁆𑀙𑀭𑀺𑀬’𑀩𑁆𑀪𑀼𑀢𑁄;

𑀲𑀻𑀲𑀘𑁆𑀙𑁂𑀚𑁆𑀚𑀫𑁆𑀳𑀺 𑀯𑀚𑁆𑀛𑁄 𑀣, 𑀦𑀺𑀓𑀢𑁄 𑀘 𑀲𑀞𑁄’𑀦𑀼𑀚𑀼;

𑀅𑀦𑀺𑀲𑀫𑁆𑀫 𑀳𑀺 𑀬𑁄 𑀓𑀺𑀘𑁆𑀘𑀁, 𑀧𑀼𑀭𑀺𑀲𑁄 𑀯𑀥𑀩𑀦𑁆𑀥𑀦𑀸𑀤𑀺 𑀫𑀸𑀘𑀭𑀢𑀺;

𑀅𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀺𑀢𑀓𑀸𑀭𑀺𑀢𑁆𑀢𑀸, 𑀲𑁄𑀔𑀮𑀼 𑀘𑀧𑀮𑁄𑀢𑀺 𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑁄.

𑀔𑀼𑀤𑁆𑀤𑁄 𑀓𑀤𑀭𑀺𑀬𑁄 𑀣𑀤𑁆𑀥, 𑀫𑀘𑁆𑀙𑀭𑀻 𑀓𑀧𑀡𑁄 𑀧𑁆𑀬𑀣;

𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑁄 𑀤𑀮𑀺𑀤𑁆𑀤𑁄 𑀘, 𑀤𑀻𑀦𑁄 𑀦𑀺𑀤𑁆𑀥𑀦 𑀤𑀼𑀕𑁆𑀕𑀢𑀸.

𑀅𑀲𑀫𑁆𑀪𑀸𑀯𑀺𑀢𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀁, 𑀓𑀸𑀓𑀢𑀸𑀮𑀺𑀬 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀅𑀣 𑀬𑀸𑀘𑀦𑀓𑁄 𑀅𑀢𑁆𑀣𑀻, 𑀬𑀸𑀘𑀓𑁄 𑀘 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑁄.

𑀅𑀡𑁆𑀟𑀚𑀸 𑀧𑀓𑁆𑀔𑀺𑀲𑀧𑁆𑀧𑀸𑀤𑀻, 𑀦𑀭𑀸𑀤𑀻 𑀢𑀼 𑀚𑀮𑀸𑀩𑀼𑀚𑀸;

𑀲𑁂𑀤𑀚𑀸 𑀓𑀺𑀫𑀺𑀟𑀁𑀲𑀸𑀤𑀻, 𑀤𑁂𑀯𑀸𑀤𑀻 𑀢𑁆𑀯𑁄’ 𑀧𑀧𑀸𑀢𑀺𑀓𑀸.

𑀚𑀡𑁆𑀡𑀼𑀢𑀕𑁆𑀖𑁄 ¶ 𑀚𑀡𑁆𑀡𑀼𑀫𑀢𑁆𑀢𑁄, 𑀓𑀧𑁆𑀧𑁄 𑀢𑀼 𑀓𑀺𑀜𑁆𑀘𑀺𑀤𑀽𑀦𑀓𑁂;

𑀅𑀦𑁆𑀢𑀕𑁆𑀕𑀢𑀁 𑀪𑀼 𑀧𑀭𑀺𑀬𑀸, 𑀧𑀦𑁆𑀦 𑀫𑀦𑁆𑀢𑁄𑀕𑀥𑁄’𑀕𑀥𑀸.

𑀭𑀸𑀥𑀺𑀢𑁄 𑀲𑀸𑀥𑀺𑀢𑁄 𑀘𑀸𑀣, 𑀦𑀺𑀧𑁆𑀧𑀓𑁆𑀓𑀁 𑀓𑀼𑀣𑀺𑀢𑀁 𑀪𑀯𑁂;

𑀆𑀧𑀦𑁆𑀦𑁄 𑀢𑁆𑀯𑀸’𑀧𑀤𑀧𑁆𑀧𑀢𑁆𑀢𑁄, 𑀯𑀺𑀯𑀲𑁄 𑀢𑁆𑀯𑀯𑀲𑁄 𑀪𑀯𑁂.

𑀦𑀼𑀡𑁆𑀡𑁄 𑀦𑀼𑀢𑁆𑀢𑀸’𑀢𑁆𑀢, 𑀔𑀺𑀢𑁆𑀢𑀸 𑀘𑁂’, 𑀭𑀺𑀢𑀸 𑀯𑀺𑀤𑁆𑀥𑀸 𑀣 𑀓𑀫𑁆𑀧𑀺𑀢𑁄;

𑀥𑀽𑀢𑁄 𑀆𑀥𑀽𑀢 𑀘𑀮𑀺𑀢𑀸, 𑀦𑀺𑀲𑀺𑀢𑀁 𑀢𑀼 𑀘 𑀢𑁂𑀚𑀺𑀢𑀁.

𑀧𑀢𑁆𑀢𑀩𑁆𑀩𑀁 𑀕𑀫𑁆𑀫 𑀫𑀸𑀧𑀚𑁆𑀚𑀁 [𑀆𑀲𑀚𑁆𑀚𑀁 (𑀓.)], 𑀧𑀓𑁆𑀓𑀁 𑀧𑀭𑀺𑀡𑀢𑀁 𑀲𑀫𑀸;

𑀯𑁂𑀞𑀺𑀢𑀁 𑀢𑀼 𑀯𑀮𑀬𑀺𑀢𑀁, 𑀭𑀼𑀤𑁆𑀥𑀁 𑀲𑀁𑀯𑀼𑀢 𑀫𑀸𑀯𑀼𑀢𑀁.

𑀧𑀭𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀜𑁆𑀘 𑀦𑀺𑀯𑀼𑀢𑀁, 𑀯𑀺𑀲𑀝𑀁 𑀯𑀺𑀢𑁆𑀣𑀢𑀁 𑀢𑀢𑀁;

𑀮𑀺𑀢𑁆𑀢𑁄 𑀢𑀼 𑀤𑀺𑀤𑁆𑀥𑁄 𑀕𑀽𑀴𑁆𑀳𑁄 𑀢𑀼,

𑀕𑀼𑀢𑁆𑀢𑁄 𑀧𑀼𑀝𑁆𑀞𑁄 𑀢𑀼 𑀧𑁄𑀲𑀺𑀢𑁄.

𑀮𑀚𑁆𑀚𑀺𑀢𑁄 𑀳𑀻𑀴𑀺𑀢𑁄 𑀘𑀸𑀣, 𑀲𑀦𑀺𑀢𑀁 𑀥𑀦𑀺𑀢𑀁 𑀧𑁆𑀬𑀣;

𑀲𑀺𑀤𑁆𑀥𑁂 𑀦𑀺𑀧𑁆𑀨𑀦𑁆𑀦 𑀦𑀺𑀩𑁆𑀩𑀢𑁆𑀢𑀸, 𑀤𑀸𑀭𑀺𑀢𑁂 𑀪𑀺𑀦𑁆𑀦 𑀪𑁂𑀤𑀺𑀢𑀸;

𑀙𑀦𑁆𑀦𑁄 𑀢𑀼 𑀙𑀸𑀤𑀺𑀢𑁂 𑀘𑀸𑀣, 𑀯𑀺𑀤𑁆𑀥𑁂 𑀙𑀺𑀤𑁆𑀤𑀺𑀢 𑀯𑁂𑀥𑀺𑀢𑀸.

𑀅𑀧𑀘𑀸𑀬𑀺𑀢𑁄 𑀫𑀳𑀺𑀢𑁄, 𑀧𑀽𑀚𑀺𑀢𑀸’𑀭𑀳𑀺𑀢𑁄’𑀘𑁆𑀘𑀺𑀢𑁄;

𑀫𑀸𑀦𑀺𑀢𑁄 𑀘𑀸’𑀧𑀘𑀺𑀢𑁄 𑀘, 𑀢𑀘𑁆𑀙𑀺𑀢𑀁 𑀢𑀼𑀢𑀦𑀽𑀓𑀢𑁂.

𑀪𑀝𑁆𑀞𑀁 𑀢𑀼 𑀕𑀮𑀺𑀢𑀁 𑀧𑀦𑁆𑀦𑀁, 𑀘𑀼𑀢𑀜𑁆𑀘 𑀥𑀁𑀲𑀺𑀢𑀁 𑀪𑀯𑁂.

𑀫𑀢𑁆𑀢𑁄 𑀢𑀼𑀝𑁆𑀞𑁄 𑀣 𑀓𑀦𑁆𑀢𑀺𑀢𑁄;

𑀢𑀺𑀦𑁆𑀢𑁄’𑀮𑁆𑀮’𑀤𑁆𑀤 ¶ 𑀓𑀺𑀮𑀺𑀦𑁆𑀦𑁄’𑀦𑁆𑀦𑀸, 𑀫𑀕𑁆𑀕𑀺𑀢𑀁 𑀧𑀭𑀺𑀬𑁂𑀲𑀺𑀢𑀁;

𑀅𑀦𑁆𑀯𑁂𑀲𑀺𑀢𑀁 𑀕𑀯𑁂𑀲𑀺𑀢𑀁, 𑀮𑀤𑁆𑀥𑀁 𑀢𑀼 𑀧𑀢𑁆𑀢 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀭𑀓𑁆𑀔𑀺𑀢𑀁 𑀕𑁄𑀧𑀺𑀢𑀁 𑀕𑀼𑀢𑁆𑀢𑀁, 𑀢𑀸𑀢𑀁 𑀕𑁄𑀧𑀸𑀬𑀺𑀢𑀸’𑀯𑀺𑀢𑀸;

𑀧𑀸𑀮𑀺𑀢𑀁 𑀅𑀣 𑀑𑀲𑁆𑀲𑀝𑁆𑀞𑀁, 𑀘𑀢𑁆𑀢𑀁 𑀳𑀻𑀦𑀁 𑀲𑀫𑀼𑀚𑁆𑀛𑀺𑀢𑀁.

𑀪𑀸𑀲𑀺𑀢𑀁 𑀮𑀧𑀺𑀢𑀁 𑀯𑀼𑀢𑁆𑀢𑀸, 𑀪𑀺𑀳𑀺𑀢𑀸’𑀔𑁆𑀬𑀸𑀢 𑀚𑀧𑁆𑀧𑀺𑀢𑀸;

𑀉𑀤𑀻𑀭𑀺𑀢𑀜𑁆𑀘 𑀓𑀣𑀺𑀢𑀁, 𑀕𑀤𑀺𑀢𑀁 𑀪𑀡𑀺𑀢𑁄’𑀤𑀺𑀢𑀸.

𑀅𑀯𑀜𑁆𑀜𑀸𑀢𑀸’𑀯𑀕𑀡𑀺𑀢𑀸, 𑀧𑀭𑀺𑀪𑀽𑀢𑀸’𑀯𑀫𑀸𑀦𑀺𑀢𑀸;

𑀩𑀼𑀤𑁆𑀥𑀁 𑀜𑀸𑀢𑀁 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀁, 𑀯𑀺𑀤𑀺𑀢𑀸’𑀯𑀕𑀢𑀁 𑀫𑀢𑀁;

𑀜𑁂𑀬𑁆𑀬𑀁 𑀮𑀺𑀗𑁆𑀕 𑀫𑀺𑀳 𑀓𑁆𑀯𑀸𑀧𑀺, 𑀧𑀘𑁆𑀘𑀬𑀢𑁆𑀣𑀯𑀲𑁂𑀦 𑀘;

𑀓𑁆𑀭𑀺𑀬𑀸 𑀢𑀼 𑀓𑀺𑀭𑀺𑀬𑀁 𑀓𑀫𑁆𑀫𑀁,

𑀤𑀫𑁄 𑀘 𑀤𑀫𑀣𑁄 𑀤𑀦𑁆𑀢𑀺, 𑀯𑀢𑁆𑀢𑀁 𑀢𑀼 𑀲𑀼𑀤𑁆𑀥𑀓𑀫𑁆𑀫𑀦𑀺;

𑀅𑀣𑁄 𑀆𑀲𑀗𑁆𑀕𑀯𑀘𑀦𑀁, 𑀢𑀻𑀲𑀼 𑀯𑀼𑀢𑁆𑀢𑀁 𑀧𑀭𑀸𑀬𑀡𑀁.

𑀪𑁂𑀤𑁄 𑀯𑀺𑀤𑀸𑀭𑁄 𑀨𑀼𑀝𑀦𑀁, 𑀢𑀧𑁆𑀧𑀦𑀁 𑀢𑀼 𑀘 𑀧𑀻𑀡𑀦𑀁;

𑀦𑀺𑀦𑁆𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑀁 𑀬𑀤𑀺𑀘𑁆𑀙𑀸 𑀣𑀸’, 𑀧𑀼𑀘𑁆𑀙𑀦𑀸 𑀦𑀦𑁆𑀤𑀦𑀸𑀦𑀺 𑀘;

𑀓𑀺𑀮𑀫𑀣𑁄 𑀓𑀺𑀮𑀫𑀦𑀁, 𑀧𑀲𑀯𑁄 𑀢𑀼 𑀧𑀲𑀽𑀢𑀺𑀬𑀁;

𑀧𑀘𑀸 𑀧𑀸𑀓𑁄 𑀳𑀯𑁄 𑀳𑀼𑀢𑀺 [𑀳𑀽𑀪𑀺 (𑀲𑀻. 𑀅𑀫𑀭𑀓𑁄𑀲)],

𑀚𑀻𑀭𑀡𑀁 𑀚𑀸𑀦𑀺 𑀢𑀸𑀡𑀁 𑀢𑀼, 𑀭𑀓𑁆𑀔𑀡𑀁 𑀧𑀫𑀺𑀢𑀺𑀧𑁆𑀧𑀫𑀸;

𑀦𑀺𑀕𑀸𑀤𑁄 𑀦𑀺𑀕𑀤𑁄 𑀫𑀸𑀤𑁄, 𑀫𑀤𑁄 𑀧𑀲𑀺𑀢𑀺 𑀩𑀦𑁆𑀥𑀦𑀁;

𑀧𑀯𑀺𑀲𑀺𑀮𑁂𑀲𑁄 𑀯𑀺𑀥𑀼𑀭𑀁, 𑀉𑀧𑀯𑁂𑀲𑀦𑀫𑀸𑀲𑀦𑀁.

𑀅𑀚𑁆𑀛𑀸𑀲𑀬𑁄 𑀅𑀥𑀺𑀧𑁆𑀧𑀸𑀬𑁄, 𑀆𑀲𑀬𑁄 𑀘𑀸𑀪𑀺𑀲𑀦𑁆𑀥𑀺 𑀘;

𑀫𑀚𑁆𑀛𑀦𑁆𑀳𑀺𑀓𑁄 [𑀫𑀚𑁆𑀛𑀦𑁆𑀢𑀺𑀓𑁄 (𑀝𑀻. 𑀲𑀻. 𑀧𑀻.)] 𑀢𑀼 𑀫𑀚𑁆𑀛𑀦𑁆𑀳𑁄, 𑀯𑁂𑀫𑀢𑁆𑀢𑀁 𑀢𑀼 𑀘 𑀦𑀸𑀦𑀢𑀸.

𑀯𑀸 𑀚𑀸𑀕𑀭𑁄 𑀚𑀸𑀕𑀭𑀺𑀬𑀁 [𑀚𑀸𑀕𑀭𑀺𑀬𑁄 (𑀝𑀻.)], 𑀧𑀯𑀸𑀳𑁄 𑀢𑀼 𑀧𑀯𑀢𑁆𑀢𑀺 𑀘;

𑀩𑁆𑀬𑀸𑀲𑁄 𑀧𑀧𑀜𑁆𑀘𑁄 𑀯𑀺𑀢𑁆𑀣𑀸𑀭𑁄,

𑀲𑀫𑁆𑀩𑀸𑀳𑀦𑀁 𑀫𑀤𑁆𑀤𑀦𑀜𑁆𑀘, 𑀧𑀲𑀭𑁄 𑀢𑀼 𑀯𑀺𑀲𑀧𑁆𑀧𑀦𑀁;

𑀲𑀦𑁆𑀦𑀺𑀥𑀺 𑀲𑀦𑁆𑀦𑀺𑀓𑀝𑁆𑀞𑀫𑁆𑀳𑀺, 𑀯𑀺𑀦𑀸𑀲𑁄 𑀢𑀼 𑀅𑀤𑀲𑁆𑀲𑀦𑀁;

𑀑𑀲𑀸𑀦𑀁 ¶ 𑀧𑀭𑀺𑀬𑁄𑀲𑀸𑀦𑀁, 𑀉𑀓𑁆𑀓𑀁𑀲𑁄’𑀢𑀺𑀲𑀬𑁄 𑀪𑀯𑁂 [𑀅𑀯𑀲𑀸𑀦𑀁 𑀲𑀫𑀸𑀧𑀦𑀁 (?)];

𑀲𑀦𑁆𑀦𑀺𑀯𑁂𑀲𑁄 𑀘 𑀲𑀡𑁆𑀞𑀸𑀦𑀁, 𑀅𑀣𑀸’𑀩𑁆𑀪𑀦𑁆𑀢𑀭 𑀫𑀦𑁆𑀢𑀭𑀁.

𑀧𑀸𑀝𑀺𑀳𑀻𑀭𑀁 𑀧𑀸𑀝𑀺𑀳𑁂𑀭𑀁, 𑀧𑀸𑀝𑀺𑀳𑀸𑀭𑀺𑀬 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀓𑀺𑀘𑁆𑀘𑀁 𑀢𑀼 𑀓𑀭𑀡𑀻𑀬𑀜𑁆𑀘, 𑀲𑀗𑁆𑀔𑀸𑀭𑁄 𑀯𑀸𑀲𑀦𑀸 𑀪𑀯𑁂.

𑀧𑀯𑀦𑀁 𑀧𑀯 𑀦𑀺𑀧𑁆𑀧𑀸𑀯𑀸, 𑀢𑀲𑀭𑁄 𑀲𑀼𑀢𑁆𑀢𑀯𑁂𑀞𑀦𑀁;

𑀲𑀗𑁆𑀓𑀫𑁄 𑀤𑀼𑀕𑁆𑀕𑀲𑀜𑁆𑀘𑀸𑀭𑁄, 𑀧𑀓𑁆𑀓𑀫𑁄 𑀢𑀼 𑀉𑀧𑀓𑁆𑀓𑀫𑁄.

𑀧𑀸𑀞𑁄 𑀦𑀺𑀧𑀸𑀞𑁄 𑀦𑀺𑀧𑀞𑁄, 𑀯𑀺𑀘𑀬𑁄 𑀫𑀕𑁆𑀕𑀦𑀸 𑀧𑀼𑀫𑁂;

𑀆𑀮𑀺𑀗𑁆𑀕𑀦𑀁 𑀧𑀭𑀺𑀲𑁆𑀲𑀗𑁆𑀕𑁄, 𑀲𑀺𑀮𑁂𑀲𑁄 𑀉𑀧𑀕𑀽𑀳𑀦𑀁.

𑀆𑀮𑁄𑀓𑀦𑀜𑁆𑀘 𑀦𑀺𑀚𑁆𑀛𑀸𑀦𑀁, 𑀇𑀓𑁆𑀔𑀡𑀁 𑀤𑀲𑁆𑀲𑀦𑀁 𑀧𑁆𑀬𑀣;

𑀧𑀘𑁆𑀘𑀸𑀤𑁂𑀲𑁄 𑀦𑀺𑀭𑀲𑀦𑀁, 𑀧𑀘𑁆𑀘𑀓𑁆𑀔𑀸𑀦𑀁 𑀦𑀺𑀭𑀸𑀓𑀢𑀺.

𑀯𑀺𑀧𑀮𑁆𑀮𑀸𑀲𑁄’𑀜𑁆𑀜𑀣𑀸𑀪𑀸𑀯𑁄, 𑀩𑁆𑀬𑀢𑁆𑀢𑀬𑁄 𑀯𑀺𑀧𑀭𑀻𑀬𑀬𑁄;

𑀯𑀺𑀧𑀭𑀺𑀬𑀸𑀲𑁄’𑀢𑀺𑀓𑁆𑀓𑀫𑁄, 𑀢𑁆𑀯’𑀢𑀺𑀧𑀸𑀢𑁄 𑀉𑀧𑀘𑁆𑀘𑀬𑁄.

𑀅𑀦𑁂𑀓𑀢𑁆𑀣𑁂 𑀧𑀯𑀓𑁆𑀔𑀸𑀫𑀺, 𑀕𑀸𑀣𑀸’𑀤𑁆𑀥𑀧𑀸𑀤𑀢𑁄 𑀓𑀫𑀸;

𑀏𑀢𑁆𑀣 𑀮𑀺𑀗𑁆𑀕𑀯𑀺𑀲𑁂𑀲𑀢𑁆𑀣, 𑀫𑁂𑀓𑀲𑁆𑀲 𑀧𑀼𑀦𑀭𑀼𑀢𑁆𑀢𑀢𑀸.

𑀲𑀫𑀬𑁄 𑀲𑀫𑀯𑀸𑀬𑁂 𑀘, 𑀲𑀫𑀽𑀳𑁂 𑀓𑀸𑀭𑀡𑁂 𑀔𑀡𑁂;

𑀧𑀝𑀺𑀯𑁂𑀥𑁂 𑀲𑀺𑀬𑀸 𑀓𑀸𑀮𑁂, 𑀧𑀳𑀸𑀦𑁂 𑀮𑀸𑀪 𑀤𑀺𑀝𑁆𑀞𑀺𑀲𑀼.

𑀯𑀡𑁆𑀡𑁄 𑀲𑀡𑁆𑀞𑀸𑀦 𑀭𑀽𑀧𑁂𑀲𑀼, 𑀚𑀸𑀢𑀺,𑀘𑁆𑀙𑀯𑀻𑀲𑀼 𑀓𑀸𑀭𑀡𑁂;

𑀧𑀫𑀸𑀡𑁂 𑀘 𑀧𑀲𑀁𑀲𑀸𑀬𑀁, 𑀅𑀓𑁆𑀔𑀭𑁂 𑀘 𑀬𑀲𑁂 𑀕𑀼𑀡𑁂.

𑀉𑀤𑁆𑀤𑁂𑀲𑁂 𑀧𑀸𑀢𑀺𑀫𑁄𑀓𑁆𑀔𑀲𑁆𑀲, 𑀧𑀡𑁆𑀡𑀢𑁆𑀢𑀺𑀬 𑀫𑀼𑀧𑁄𑀲𑀣𑁄;

𑀉𑀧𑀯𑀸𑀲𑁂 𑀘 𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑁂, 𑀉𑀧𑁄𑀲𑀣𑀤𑀺𑀦𑁂 𑀲𑀺𑀬𑀸.

𑀭𑀣𑀗𑁆𑀕𑁂 𑀮𑀓𑁆𑀔𑀡𑁂 𑀥𑀫𑁆𑀫𑁄, 𑀭𑀘𑀓𑁆𑀓𑁂’𑀲𑁆𑀯𑀻𑀭𑀺𑀬𑀸𑀧𑀣𑁂;

𑀘𑀓𑁆𑀓𑀁 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀺𑀬𑀁 𑀘𑀓𑁆𑀓, 𑀭𑀢𑀦𑁂 𑀫𑀡𑁆𑀟𑀮𑁂 𑀩𑀮𑁂.

𑀓𑀼𑀮𑀸𑀮𑀪𑀡𑁆𑀟𑁂 𑀆𑀡𑀸𑀬, 𑀫𑀸𑀬𑀼𑀥𑁂 𑀤𑀸𑀦 𑀭𑀸𑀲𑀺𑀲𑀼;

𑀤𑀸𑀦𑀲𑁆𑀫𑀺𑀁 ¶ 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬, 𑀫𑀧𑁆𑀧𑀫𑀜𑁆𑀜𑀸𑀲𑀼 𑀲𑀸𑀲𑀦𑁂;

𑀫𑁂𑀣𑀼𑀦𑀸𑀭𑀢𑀺𑀬𑀁 𑀯𑁂𑀬𑁆𑀬𑀸, 𑀯𑀘𑁆𑀘𑁂 𑀲𑀤𑀸𑀭𑀢𑀼𑀝𑁆𑀞𑀺𑀬𑀁;

𑀧𑀜𑁆𑀘𑀲𑀻𑀮𑀸’𑀭𑀺𑀬𑀫𑀕𑁆𑀕𑁄, 𑀧𑁄𑀲𑀣𑀗𑁆𑀕 𑀥𑀺𑀢𑀻𑀲𑀼 [𑀞𑀺𑀢𑀻𑀲𑀼 (𑀓.)] 𑀘.

𑀥𑀫𑁆𑀫𑁄 𑀲𑀪𑀸𑀯𑁂 𑀧𑀭𑀺𑀬𑀢𑁆𑀢𑀺𑀧𑀜𑁆𑀜𑀸,

𑀜𑀸𑀬𑁂𑀲𑀼 𑀲𑀘𑁆𑀘𑀧𑁆𑀧𑀓𑀢𑀻𑀲𑀼 𑀧𑀼𑀜𑁆𑀜𑁂;

𑀜𑁂𑀬𑁆𑀬𑁂 𑀕𑀼𑀡𑀸’𑀘𑀸𑀭 𑀲𑀫𑀸𑀥𑀺𑀲𑀽𑀧𑀺,

𑀦𑀺𑀲𑁆𑀲𑀢𑁆𑀢𑀢𑀸’𑀧𑀢𑁆𑀢𑀺𑀲𑀼 𑀓𑀸𑀭𑀡𑀸𑀤𑁄.

𑀅𑀢𑁆𑀣𑁄 𑀧𑀬𑁄𑀚𑀦𑁂 𑀲𑀤𑁆𑀤𑀸, 𑀪𑀺𑀥𑁂𑀬𑁆𑀬𑁂 𑀯𑀼𑀤𑁆𑀥𑀺𑀬𑀁 𑀥𑀦𑁂;

𑀯𑀢𑁆𑀣𑀼𑀫𑁆𑀳𑀺 𑀓𑀸𑀭𑀡𑁂 𑀦𑀸𑀲𑁂, 𑀳𑀺𑀢𑁂 𑀧𑀘𑁆𑀙𑀺𑀫𑀧𑀩𑁆𑀩𑀢𑁂.

𑀬𑁂𑀪𑀼𑀬𑁆𑀬𑀢𑀸’𑀩𑁆𑀬𑀸𑀫𑀺𑀲𑁆𑀲𑁂𑀲𑀼, 𑀯𑀺𑀲𑀁𑀬𑁄𑀕𑁂 𑀘 𑀓𑁂𑀯𑀮𑀁;

𑀤𑀴𑁆𑀳𑀢𑁆𑀣𑁂’𑀦𑀢𑀺𑀭𑁂𑀓𑁂 𑀘𑀸, 𑀦𑀯𑀲𑁂𑀲𑀫𑁆𑀳𑀺 𑀢𑀁 𑀢𑀺𑀲𑀼.

𑀕𑀼𑀡𑁄 𑀧𑀝𑀮 𑀭𑀸𑀲𑀻𑀲𑀼, 𑀆𑀦𑀺𑀲𑀁𑀲𑁂 𑀘 𑀩𑀦𑁆𑀥𑀦𑁂;

𑀅𑀧𑁆𑀧𑀥𑀸𑀦𑁂 𑀘 𑀲𑀻𑀮𑀸𑀤𑁄, 𑀲𑀼𑀓𑁆𑀓𑀸𑀤𑀺𑀫𑁆𑀳𑀺 𑀚𑀺𑀬𑀸𑀬 𑀘.

𑀭𑀼𑀓𑁆𑀔𑀸𑀤𑁄 𑀯𑀺𑀚𑁆𑀚𑀫𑀸𑀦𑁂 𑀘𑀸, 𑀭𑀳𑀦𑁆𑀢𑁂 𑀔𑀦𑁆𑀥𑀧𑀜𑁆𑀘𑀓𑁂;

𑀪𑀽𑀢𑁄 𑀲𑀢𑁆𑀢 𑀫𑀳𑀸𑀪𑀽𑀢𑀸, 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀦 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑁄 𑀅𑀢𑀻𑀢𑀲𑁆𑀫𑀺𑀁, 𑀚𑀸𑀢𑁂 𑀧𑀢𑁆𑀢𑁂 𑀲𑀫𑁂 𑀫𑀢𑁄;

𑀲𑀼𑀦𑁆𑀤𑀭𑁂 𑀤𑀴𑁆𑀳𑀺𑀓𑀫𑁆𑀫𑁂 𑀘𑀸, 𑀬𑀸𑀘𑀦𑁂 𑀲𑀫𑁆𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁂;

𑀲𑀚𑁆𑀚𑀦𑁂 𑀲𑀫𑁆𑀧𑀳𑀁𑀲𑀸𑀬𑀁, 𑀲𑀸𑀥𑁆𑀯𑀸’𑀪𑀺𑀥𑁂𑀬𑁆𑀬𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁.

𑀅𑀦𑁆𑀢𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀲𑀫𑀻𑀧𑁂 𑀘𑀸, 𑀯𑀲𑀸𑀦𑁂 𑀧𑀤𑀧𑀽𑀭𑀡𑁂;

𑀤𑁂𑀳𑀸𑀯𑀬𑀯𑁂 𑀓𑁄𑀝𑁆𑀞𑀸𑀲𑁂, 𑀦𑀸𑀲 𑀲𑀻𑀫𑀸𑀲𑀼 𑀮𑀸𑀫𑀓𑁂.

𑀦𑀺𑀓𑀸𑀬𑁂 𑀲𑀦𑁆𑀥𑀺 𑀲𑀸𑀫𑀜𑁆𑀜, 𑀧𑁆𑀧𑀲𑀽𑀢𑀻𑀲𑀼 𑀓𑀼𑀮𑁂 𑀪𑀯𑁂;

𑀯𑀺𑀲𑁂𑀲𑁂 𑀲𑀼𑀫𑀦𑀸𑀬𑀜𑁆𑀘, 𑀚𑀸𑀢𑀺 𑀲𑀗𑁆𑀔𑀢𑀮𑀓𑁆𑀔𑀡𑁂.

𑀪𑀯𑀪𑁂𑀤𑁂 𑀧𑀢𑀺𑀝𑁆𑀞𑀸𑀬𑀁, 𑀦𑀺𑀝𑁆𑀞𑀸’𑀚𑁆𑀛𑀸𑀲𑀬𑀩𑀼𑀤𑁆𑀥𑀺𑀲𑀼;

𑀯𑀸𑀲𑀝𑁆𑀞𑀸𑀦𑁂 𑀘 𑀕𑀫𑀦𑁂, 𑀯𑀺𑀲𑀝𑀢𑁆𑀢𑁂 [𑀯𑀺𑀲𑀭𑀢𑁆𑀢 𑀯𑀺𑀲𑀤𑀢𑁆𑀢𑁂] 𑀕𑀢𑀻𑀭𑀺𑀢𑀸.

𑀨𑀮𑁂 𑀯𑀺𑀧𑀲𑁆𑀲𑀦𑀸 𑀤𑀺𑀩𑁆𑀩, 𑀘𑀓𑁆𑀔𑀼 𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀸𑀲𑀼 𑀘;

𑀧𑀘𑁆𑀘𑀯𑁂𑀓𑁆𑀔𑀡𑀜𑀸𑀡𑀫𑁆𑀳𑀺, 𑀫𑀕𑁆𑀕𑁂 𑀘 𑀜𑀸𑀡𑀤𑀲𑁆𑀲𑀦𑀁.

𑀓𑀫𑁆𑀫𑀸𑀭𑀼𑀤𑁆𑀥𑀦 𑀅𑀗𑁆𑀕𑀸𑀭, 𑀓𑀧𑀮𑁆𑀮 𑀤𑀻𑀧𑀺𑀓𑀸𑀲𑀼 𑀘;

𑀲𑀼𑀯𑀡𑁆𑀡𑀓𑀸𑀭𑀫𑀽𑀲𑀸𑀬𑀁, 𑀉𑀓𑁆𑀓𑀸 𑀯𑁂𑀕𑁂 𑀘 𑀯𑀸𑀬𑀼𑀦𑁄.

𑀓𑁂𑀲𑁄𑀳𑀸𑀭𑀡, ¶ 𑀚𑀻𑀯𑀺𑀢, 𑀯𑀼𑀢𑁆𑀢𑀺𑀲𑀼 𑀯𑀧𑀦𑁂 𑀘 𑀯𑀸𑀧𑀲𑀫𑀓𑀭𑀡𑁂;

𑀓𑀣𑀦𑁂 𑀧𑀫𑀼𑀢𑁆𑀢𑀪𑀸𑀯, 𑀚𑁆𑀛𑁂𑀦𑀸𑀤𑁄 [𑀚𑁆𑀛𑁂𑀲𑀦𑀸𑀤𑁄 (𑀲𑀻.)] 𑀯𑀼𑀢𑁆𑀢 𑀫𑀧𑀺 𑀢𑀻𑀲𑀼.

𑀕𑀫𑀦𑁂 𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑁂 𑀘𑀸’𑀯, 𑀥𑀸𑀭𑀺𑀢𑁄’𑀧𑀘𑀺𑀢𑁂𑀲𑀼 𑀘;

𑀅𑀦𑀼𑀬𑁄𑀕𑁂 𑀓𑀺𑀮𑀺𑀦𑁆𑀦𑁂 𑀘, 𑀲𑀼𑀢𑁄’ 𑀪𑀺𑀥𑁂𑀬𑁆𑀬𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄.

𑀲𑁄𑀢𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬 𑀲𑀢𑁆𑀣𑁂𑀲𑀼, 𑀲𑀼𑀢𑀁 𑀧𑀼𑀢𑁆𑀢𑁂 𑀲𑀼𑀢𑁄 𑀲𑀺𑀬𑀸;

𑀓𑀧𑁆𑀧𑁄 𑀓𑀸𑀮𑁂 𑀬𑀼𑀕𑁂 𑀮𑁂𑀲𑁂, 𑀧𑀜𑁆𑀜𑀢𑁆𑀢𑀺 𑀧𑀭𑀫𑀸𑀬𑀼𑀲𑀼;

𑀲𑀤𑀺𑀲𑁂 𑀢𑀻𑀲𑀼 𑀲𑀫𑀡, 𑀯𑁄𑀳𑀸𑀭 𑀓𑀧𑁆𑀧𑀩𑀺𑀦𑁆𑀤𑀼𑀲𑀼;

𑀲𑀫𑀦𑁆𑀢𑀢𑁆𑀣𑁂’𑀦𑁆𑀢𑀭𑀓𑀧𑁆𑀧𑀸, 𑀤𑀺𑀓𑁂 𑀢𑀓𑁆𑀓𑁂 𑀯𑀺𑀥𑀺𑀫𑁆𑀳𑀺 𑀘.

𑀦𑀺𑀩𑁆𑀩𑀸𑀦 𑀫𑀕𑁆𑀕 𑀯𑀺𑀭𑀢𑀺, 𑀲𑀧𑀣𑁂 𑀲𑀘𑁆𑀘𑀪𑀸𑀲𑀺𑀢𑁂;

𑀢𑀘𑁆𑀙𑁂 𑀘𑀸’𑀭𑀺𑀬𑀲𑀘𑁆𑀘𑀫𑁆𑀳𑀺, 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀁 𑀲𑀘𑁆𑀘 𑀫𑀻𑀭𑀺𑀢𑀁.

𑀲𑀜𑁆𑀚𑀸𑀢𑀺𑀤𑁂𑀲𑁂 𑀳𑁂𑀢𑀼𑀫𑁆𑀳𑀺, 𑀯𑀸𑀲𑀝𑁆𑀞𑀸𑀦𑀸’𑀓𑀭𑁂𑀲𑀼 𑀘;

𑀲𑀫𑁄𑀲𑀭𑀡𑀝𑁆𑀞𑀸𑀦𑁂 𑀘𑀸, 𑀬𑀢𑀦𑀁 𑀧𑀤𑀧𑀽𑀭𑀡𑁂.

𑀅𑀦𑁆𑀢𑀭𑀁 𑀫𑀚𑁆𑀛 𑀯𑀢𑁆𑀣’𑀜𑁆𑀜, 𑀔𑀡𑁄’𑀓𑀸𑀲𑁄’𑀥𑀺 𑀳𑁂𑀢𑀼𑀲𑀼;

𑀩𑁆𑀬𑀯𑀥𑀸𑀦𑁂 𑀯𑀺𑀦𑀝𑁆𑀞𑁂 𑀘, 𑀪𑁂𑀤𑁂 𑀙𑀺𑀤𑁆𑀤𑁂 𑀫𑀦𑀲𑁆𑀬’𑀧𑀺.

𑀆𑀭𑁄𑀕𑁆𑀬𑁂 𑀓𑀼𑀲𑀮𑀁 𑀇𑀝𑁆𑀞, 𑀯𑀺𑀧𑀸𑀓𑁂 𑀓𑀼𑀲𑀮𑁄 𑀢𑀣𑀸;

𑀅𑀦𑀯𑀚𑁆𑀚𑀫𑁆𑀳𑀺 𑀙𑁂𑀓𑁂 𑀘, 𑀓𑀣𑀺𑀢𑁄 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄.

𑀤𑁆𑀭𑀯𑀸’𑀘𑀸𑀭𑁂𑀲𑀼 𑀯𑀻𑀭𑀺𑀬𑁂, 𑀫𑀥𑀼𑀭𑀸𑀤𑀻𑀲𑀼 𑀧𑀸𑀭𑀤𑁂;

𑀲𑀺𑀗𑁆𑀕𑀸𑀭𑀸𑀤𑁄 𑀥𑀸𑀢𑀼𑀪𑁂𑀤𑁂, 𑀓𑀺𑀘𑁆𑀘𑁂 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀺𑀬𑀁 𑀭𑀲𑁄.

𑀩𑁄𑀥𑀺 𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀜𑁆𑀜𑀸𑀡𑁂, 𑀭𑀺𑀬𑀫𑀕𑁆𑀕𑁂 𑀘 𑀦𑀸𑀭𑀺𑀬𑀁;

𑀧𑀜𑁆𑀜𑀢𑁆𑀢𑀺𑀬𑀁 𑀧𑀼𑀫𑁂’ 𑀲𑁆𑀲𑀢𑁆𑀣, 𑀭𑀼𑀓𑁆𑀔𑀫𑁆𑀳𑀺 𑀧𑀼𑀭𑀺𑀲𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀲𑁂𑀯𑀺𑀢𑁄 𑀬𑁂𑀦 𑀬𑁄 𑀦𑀺𑀘𑁆𑀘𑀁, 𑀢𑀢𑁆𑀣𑀸𑀧𑀺 𑀯𑀺𑀲𑀬𑁄 𑀲𑀺𑀬𑀸;

𑀭𑀽𑀧𑀸𑀤𑀺𑀓𑁂 𑀚𑀦𑀧𑀤𑁂, 𑀢𑀣𑀸 𑀤𑁂𑀲𑁂 𑀘 𑀕𑁄𑀘𑀭𑁂.

𑀪𑀸𑀯𑁄 𑀧𑀤𑀢𑁆𑀣𑁂 𑀲𑀢𑁆𑀢𑀸𑀬, 𑀫𑀥𑀺𑀧𑁆𑀧𑀸𑀬 𑀓𑁆𑀭𑀺𑀬𑀸𑀲𑀼 𑀘;

𑀲𑀪𑀸𑀯𑀲𑁆𑀫𑀺𑀜𑁆𑀘 𑀮𑀻𑀮𑀸𑀬𑀁, 𑀧𑀼𑀭𑀺𑀲𑀺’𑀢𑁆𑀣𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁂𑀲𑀼 𑀘.

𑀲𑁄 𑀩𑀦𑁆𑀥𑀯𑁂’𑀢𑁆𑀢𑀦𑀺 𑀘 𑀲𑀁, 𑀲𑁄 𑀥𑀦𑀲𑁆𑀫𑀺 𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀲𑀸 𑀧𑀼𑀫𑁂 𑀲𑀼𑀦𑀔𑁂 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀢𑁆𑀢𑀦𑀺𑀬𑁂 𑀲𑁄 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄.

𑀲𑀼𑀯𑀡𑁆𑀡𑀁 𑀓𑀦𑀓𑁂 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀲𑀼𑀯𑀡𑁆𑀡𑁄 𑀕𑀭𑀼𑀴𑁂 𑀢𑀣𑀸;

𑀧𑀜𑁆𑀘𑀥𑀭𑀡𑀫𑀢𑁆𑀢𑁂 𑀘, 𑀙𑀯𑀺 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀘.

𑀯𑀭𑁄 ¶ 𑀤𑁂𑀯𑀸𑀤𑀺𑀓𑀸 [𑀤𑁂𑀯𑀸𑀤𑀺𑀢𑁄 (𑀲𑀻.)] 𑀇𑀝𑁆𑀞𑁂, 𑀚𑀸𑀫𑀸𑀢𑀭𑀺 𑀧𑀢𑀺𑀫𑁆𑀳𑀺 𑀘,

𑀉𑀢𑁆𑀢𑀫𑁂 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑁄 𑀲𑁄, 𑀯𑀭𑀁 𑀫𑀦𑁆𑀤𑀧𑁆𑀧𑀺𑀬𑁂 𑀩𑁆𑀬𑀬𑀁.

𑀫𑀓𑀼𑀮𑁂 𑀥𑀦𑀭𑀸𑀲𑀺𑀫𑁆𑀳𑀺, 𑀲𑀺𑀬𑀸 𑀓𑁄𑀲 𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀦𑁂𑀢𑁆𑀢𑀺𑀁𑀲𑀸𑀤𑀺 𑀧𑀺𑀥𑀸𑀦𑁂 𑀘, 𑀥𑀦𑀼𑀧𑀜𑁆𑀘𑀲𑀢𑁂𑀧𑀺 𑀘.

𑀧𑀺𑀢𑀸𑀫𑀳𑁂 𑀚𑀺𑀦𑁂 𑀲𑁂𑀝𑁆𑀞𑁂, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂 𑀘 𑀧𑀺𑀢𑀽𑀲𑁆𑀯𑀧𑀺;

𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀯𑀼𑀢𑁆𑀢𑁄 𑀢𑀣𑀸 𑀩𑁆𑀭𑀳𑁆𑀫𑀁, 𑀯𑁂𑀤𑁂 𑀢𑀧𑀲𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑁂.

𑀳𑀢𑁆𑀣𑀻𑀦𑀁 𑀫𑀚𑁆𑀛𑀩𑀦𑁆𑀥𑁂 𑀘, 𑀧𑀓𑁄𑀝𑁆𑀞𑁂 𑀓𑀘𑁆𑀙𑀩𑀦𑁆𑀥𑀦𑁂;

𑀫𑁂𑀔𑀮𑀸𑀬𑀁 𑀫𑀢𑀸 𑀓𑀘𑁆𑀙𑀸, 𑀓𑀘𑁆𑀙𑁄 𑀯𑀼𑀢𑁆𑀢𑁄 𑀮𑀢𑀸𑀬 𑀘.

𑀢𑀣𑁂𑀯 𑀩𑀸𑀳𑀼𑀫𑀽𑀮𑀫𑁆𑀳𑀺, 𑀅𑀦𑀽𑀧𑀫𑁆𑀳𑀺 𑀢𑀺𑀡𑁂𑀧𑀺 𑀘;

𑀧𑀫𑀸𑀡𑀁 𑀳𑁂𑀢𑀼 𑀲𑀢𑁆𑀣𑁂𑀲𑀼, 𑀫𑀸𑀦𑁂 𑀘 𑀲𑀘𑁆𑀘𑀯𑀸𑀤𑀺𑀦𑀺;

𑀧𑀫𑀸𑀢𑀭𑀺 𑀘 𑀦𑀺𑀘𑁆𑀘𑀫𑁆𑀳𑀺, 𑀫𑀭𑀺𑀬𑀸𑀤𑀸𑀬 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀲𑀢𑁆𑀢𑀁 𑀤𑀩𑁆𑀩’𑀢𑁆𑀢𑀪𑀸𑀯𑁂𑀲𑀼, 𑀧𑀸𑀡𑁂𑀲𑀼 𑀘 𑀩𑀮𑁂, 𑀲𑀺𑀬𑀸 [𑀩𑀮𑁂 𑀲𑀓𑁆𑀓𑀸 (𑀝𑀻.)];

𑀲𑀢𑁆𑀢𑀸𑀬𑀜𑁆𑀘, 𑀚𑀦𑁂𑀲𑀢𑁆𑀢𑁄, 𑀆𑀲𑀢𑁆𑀢𑁂 𑀲𑁄 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄.

𑀲𑁂𑀫𑁆𑀳𑀸𑀤𑁄 𑀭𑀲𑀭𑀢𑁆𑀢𑀸𑀤𑁄, 𑀫𑀳𑀸𑀪𑀽𑀢𑁂 𑀧𑀪𑀸𑀤𑀺𑀓𑁂;

𑀥𑀸𑀢𑀼 𑀤𑁆𑀯𑀻𑀲𑁆𑀯’𑀝𑁆𑀞𑀺𑀘𑀓𑁆𑀔𑀸’𑀤𑀺, 𑀪𑁆𑀯𑀸’𑀤𑀻𑀲𑀼 𑀕𑁂𑀭𑀺𑀓𑀸𑀤𑀺𑀲𑀼.

𑀅𑀫𑀘𑁆𑀘𑀸𑀤𑁄 𑀲𑀪𑀸𑀯𑁂 𑀘, 𑀬𑁄𑀦𑀺𑀬𑀁 𑀧𑀓𑀢𑀻’𑀭𑀺𑀢𑀸;

𑀲𑀢𑁆𑀯𑀸𑀤𑀺𑀲𑀸𑀫𑁆𑀬𑀸’𑀯𑀢𑁆𑀣𑀸𑀬𑀁, 𑀧𑀘𑁆𑀘𑀬𑀸 𑀧𑀞𑀫𑁂𑀧𑀺 𑀘.

𑀧𑀤𑀁 𑀞𑀸𑀦𑁂 𑀧𑀭𑀺𑀢𑁆𑀢𑀸𑀡𑁂, 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀫𑁆𑀳𑀺 𑀘 𑀓𑀸𑀭𑀡𑁂;

𑀲𑀤𑁆𑀤𑁂 𑀯𑀢𑁆𑀣𑀼𑀫𑁆𑀳𑀺 𑀓𑁄𑀝𑁆𑀞𑀸𑀲𑁂, 𑀧𑀸𑀤𑁂 𑀢𑀮𑁆𑀮𑀜𑁆𑀙𑀦𑁂 𑀫𑀢𑀁.

𑀮𑁄𑀳𑀫𑀼𑀕𑁆𑀕𑀭 𑀫𑁂𑀖𑁂𑀲𑀼, 𑀖𑀦𑁄, 𑀢𑀸𑀮𑀸𑀤𑀺𑀓𑁂 𑀖𑀦𑀁,;

𑀦𑀺𑀭𑀦𑁆𑀢𑀭𑁂 𑀘 𑀓𑀞𑀺𑀦𑁂, 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀔𑀼𑀤𑁆𑀤𑀸 𑀘 𑀫𑀓𑁆𑀔𑀺𑀓𑀸𑀪𑁂𑀤𑁂, 𑀫𑀥𑀼𑀫𑁆𑀳𑀺 𑀔𑀼𑀤𑁆𑀤, 𑀫𑀧𑁆𑀧𑀓𑁂;

𑀅𑀥𑀫𑁂 𑀓𑀧𑀡𑁂 𑀘𑀸𑀧𑀺, 𑀩𑀳𑀼𑀫𑁆𑀳𑀺 𑀘𑀢𑀽𑀲𑀼 𑀢𑁆𑀢𑀺𑀲𑀼.

𑀢𑀓𑁆𑀓𑁂 𑀫𑀭𑀡𑀮𑀺𑀗𑁆𑀕𑁂 𑀘, 𑀅𑀭𑀺𑀝𑁆𑀞𑀁 𑀅𑀲𑀼𑀪𑁂 𑀲𑀼𑀪𑁂,;

𑀅𑀭𑀺𑀝𑁆𑀞𑁄 𑀆𑀲𑀯𑁂 𑀓𑀸𑀓𑁂, 𑀦𑀺𑀫𑁆𑀩𑁂 𑀘 𑀨𑁂𑀦𑀺𑀮𑀤𑁆𑀤𑀼𑀫𑁂.

𑀫𑀸𑀦𑀪𑀡𑁆𑀟𑁂 𑀧𑀮𑀲𑀢𑁂, 𑀲𑀤𑀺𑀲𑀢𑁆𑀢𑁂 𑀢𑀼𑀮𑀸 𑀢𑀣𑀸;

𑀕𑁂𑀳𑀸𑀦𑀁 𑀤𑀸𑀭𑀼𑀩𑀦𑁆𑀥𑀢𑁆𑀣, 𑀧𑀻𑀞𑀺𑀓𑀸𑀬𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑀫𑀺𑀢𑁆𑀢𑀓𑀸𑀭𑁂 ¶ 𑀮𑀜𑁆𑀚𑀤𑀸𑀦𑁂, 𑀩𑀮𑁂 𑀭𑀸𑀲𑀺 𑀯𑀺𑀧𑀢𑁆𑀢𑀺𑀲𑀼 [𑀩𑀮𑀭𑀸𑀲𑀺 𑀯𑀺𑀧𑀢𑁆𑀢𑀺𑀲𑀼 (𑀓.)];

𑀬𑀼𑀤𑁆𑀥𑁂 𑀘𑁂𑀯 𑀧𑀝𑀺𑀜𑁆𑀜𑀸𑀬𑀁, 𑀲𑀗𑁆𑀕𑀭𑁄 𑀲𑀫𑁆𑀧𑀓𑀸𑀲𑀺𑀢𑁄.

𑀔𑀦𑁆𑀥𑁂 𑀪𑀯𑁂 𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑀫𑁆𑀳𑀺, 𑀭𑀽𑀧𑀁 𑀯𑀡𑁆𑀡𑁂 𑀘 𑀧𑀘𑁆𑀘𑀬𑁂;

𑀲𑀪𑀸𑀯 𑀲𑀤𑁆𑀤 𑀲𑀡𑁆𑀞𑀸𑀦, 𑀭𑀽𑀧𑀚𑁆𑀛𑀸𑀦 𑀯𑀧𑀽𑀲𑀼 𑀘.

𑀯𑀢𑁆𑀣𑀼 𑀓𑀺𑀮𑁂𑀲 𑀓𑀸𑀫𑁂𑀲𑀼, 𑀇𑀘𑁆𑀙𑀸𑀬𑀁 𑀫𑀤𑀦𑁂 𑀭𑀢𑁂;

𑀓𑀸𑀫𑁄, 𑀓𑀸𑀫𑀁 𑀦𑀺𑀓𑀸𑀫𑁂, 𑀘𑀸, 𑀦𑀼𑀜𑁆𑀜𑀸𑀬𑀁 𑀓𑀸𑀫 𑀫𑀩𑁆𑀬𑀬𑀁.

𑀧𑁄𑀓𑁆𑀔𑀭𑀁 𑀧𑀤𑀼𑀫𑁂 𑀤𑁂𑀳𑁂, 𑀯𑀚𑁆𑀚𑀪𑀡𑁆𑀟𑀫𑀼𑀔𑁂𑀧𑀺 𑀘;

𑀲𑀼𑀦𑁆𑀤𑀭𑀢𑁆𑀢𑁂 𑀘 𑀲𑀮𑀺𑀮𑁂, 𑀫𑀸𑀢𑀗𑁆𑀕𑀓𑀭𑀓𑁄𑀝𑀺𑀬𑀁.

𑀭𑀸𑀲𑀺𑀦𑀺𑀘𑁆𑀘𑀮 𑀫𑀸𑀬𑀸𑀲𑀼, 𑀤𑀫𑁆𑀪𑀸’𑀲𑀘𑁆𑀘𑁂𑀲𑁆𑀯’𑀬𑁄𑀖𑀦𑁂;

𑀕𑀺𑀭𑀺𑀲𑀺𑀗𑁆𑀕𑀫𑁆𑀳𑀺 𑀲𑀻𑀭𑀗𑁆𑀕𑁂, 𑀬𑀦𑁆𑀢𑁂 𑀓𑀽𑀝 𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀯𑀼𑀤𑁆𑀥𑀺𑀬𑀁 𑀚𑀦𑀦𑁂 𑀓𑀸𑀫, 𑀥𑀸𑀢𑁆𑀯𑀸𑀤𑀻𑀫𑁆𑀳𑀺 𑀘 𑀧𑀢𑁆𑀢𑀺𑀬𑀁;

𑀲𑀢𑁆𑀢𑀸𑀬𑀜𑁆𑀘𑁂𑀯 𑀲𑀁𑀲𑀸𑀭𑁂, 𑀪𑀯𑁄 𑀲𑀲𑁆𑀲𑀢𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀁.

𑀧𑀝𑀺𑀯𑀸𑀓𑁆𑀬𑁄’𑀢𑁆𑀢𑀭𑀸𑀲𑀗𑁆𑀕𑁂, 𑀲𑀼’𑀢𑁆𑀢𑀭𑀁 𑀉𑀢𑁆𑀢𑀭𑁄 𑀢𑀺𑀲𑀼;

𑀲𑁂𑀝𑁆𑀞𑁂 𑀤𑀺𑀲𑀸𑀤𑀺𑀪𑁂𑀤𑁂 𑀘, 𑀧𑀭𑀲𑁆𑀫𑀺 𑀫𑀼𑀧𑀭𑀻’𑀭𑀺𑀢𑁄.

𑀦𑁂𑀓𑁆𑀔𑀫𑁆𑀫𑀁 𑀧𑀞𑀫𑀚𑁆𑀛𑀸𑀦𑁂, 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀸𑀬𑀁 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀺𑀬𑀁;

𑀯𑀺𑀧𑀲𑁆𑀲𑀦𑀸𑀬 𑀦𑀺𑀲𑁆𑀲𑁂𑀲, 𑀓𑀼𑀲𑀮𑀫𑁆𑀳𑀺 𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑀲𑀗𑁆𑀔𑀸𑀭𑁄 𑀲𑀗𑁆𑀔𑀢𑁂 𑀧𑀼𑀜𑁆𑀜𑀸, 𑀪𑀺𑀲𑀗𑁆𑀔𑀸𑀭𑀸𑀤𑀺𑀓𑁂𑀧𑀺 𑀘;

𑀧𑀬𑁄𑀕𑁂 𑀓𑀸𑀬𑀲𑀗𑁆𑀔𑀸𑀭𑀸, 𑀤𑁆𑀬’𑀪𑀺𑀲𑀗𑁆𑀔𑀭𑀡𑁂𑀲𑀼 𑀘.

𑀆𑀭𑀫𑁆𑀫𑀡𑁂 𑀘 𑀲𑀁𑀲𑀝𑁆𑀞𑁂, 𑀯𑁄𑀓𑀺𑀡𑁆𑀡𑁂 𑀦𑀺𑀲𑁆𑀲𑀬𑁂 𑀢𑀣𑀸;

𑀢𑀩𑁆𑀪𑀸𑀯𑁂 𑀘𑀸𑀧𑁆𑀬𑀪𑀺𑀥𑁂𑀬𑁆𑀬, 𑀮𑀺𑀗𑁆𑀕𑁄 𑀲𑀳𑀕𑀢𑁄 𑀪𑀯𑁂.

𑀢𑀻𑀲𑀼 𑀙𑀦𑁆𑀦𑀁 𑀧𑀢𑀺𑀭𑀽𑀧𑁂, 𑀙𑀸𑀤𑀺𑀢𑁂 𑀘 𑀦𑀺𑀕𑀽𑀳𑀺𑀢𑁂;

𑀦𑀺𑀯𑀸𑀲𑀦 𑀧𑀸𑀭𑀼𑀧𑀦𑁂, 𑀭𑀳𑁄 𑀧𑀜𑁆𑀜𑀢𑁆𑀢𑀺𑀬𑀁 𑀧𑀼𑀫𑁂.

𑀩𑀼𑀤𑁆𑀥𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀽𑀲𑀼, 𑀘𑀓𑁆𑀔𑀼 𑀧𑀜𑁆𑀜𑀸𑀬 𑀫𑀻𑀭𑀺𑀢𑀁;

𑀥𑀫𑁆𑀫𑀘𑀓𑁆𑀔𑀼𑀫𑁆𑀳𑀺 𑀘 𑀫𑀁𑀲, 𑀤𑀺𑀩𑁆𑀩𑀘𑀓𑁆𑀔𑀼𑀤𑁆𑀯𑀬𑁂𑀲𑀼 𑀘.

𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑁄 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁄, 𑀲𑀼𑀦𑁆𑀤𑀭𑀫𑁆𑀳𑀺 𑀅𑀪𑀺𑀓𑁆𑀓𑀫𑁂;

𑀅𑀪𑀺𑀭𑀽𑀧𑁂 𑀔𑀬𑁂 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀢𑀣𑁂𑀯’𑀩𑁆𑀪𑀦𑀼𑀫𑁄𑀤𑀦𑁂.

𑀓𑀸𑀭𑀡𑁂 𑀤𑁂𑀲𑀦𑀸𑀬𑀜𑁆𑀘, 𑀯𑀸𑀭𑁂 𑀯𑁂𑀯𑀘𑀦𑁂𑀧𑀺 𑀘;

𑀧𑀸𑀓𑀸𑀭𑀲𑁆𑀫𑀺𑀁 [𑀧𑀓𑀸𑀭𑀲𑁆𑀫𑀺𑀁 (𑀓.)] 𑀅𑀯𑀲𑀭𑁂, 𑀧𑀭𑀺𑀬𑀸𑀬𑁄 𑀓𑀣𑀻𑀬𑀢𑀺.

𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑁂 ¶ 𑀘𑀺𑀢𑁆𑀢𑀓𑀫𑁆𑀫𑁂 𑀘, 𑀯𑀺𑀘𑀺𑀢𑁆𑀢𑁂 𑀘𑀺𑀢𑁆𑀢 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀧𑀜𑁆𑀜𑀢𑁆𑀢𑀺 𑀘𑀺𑀢𑁆𑀢𑀫𑀸𑀲𑁂𑀲𑀼, 𑀘𑀺𑀢𑁆𑀢𑁄, 𑀢𑀸𑀭𑀦𑁆𑀢𑀭𑁂 𑀣𑀺𑀬𑀁.

𑀲𑀸𑀫𑀁 𑀯𑁂𑀤𑀦𑁆𑀢𑀭𑁂 𑀲𑀸𑀦𑁆𑀢𑁆𑀯𑁂, 𑀢𑀁 𑀧𑀻𑀢𑁂 𑀲𑀸𑀫𑀮𑁂 𑀢𑀺𑀲𑀼;

𑀲𑀬𑀫𑀢𑁆𑀣𑁂 𑀩𑁆𑀬𑀬𑀁 𑀲𑀸𑀫𑀁, 𑀲𑀸𑀫𑀸 𑀘 𑀲𑀸𑀭𑀺𑀯𑀸𑀬𑀧𑀺.

𑀧𑀼𑀫𑁂 𑀆𑀘𑀭𑀺𑀬𑀸𑀤𑀺𑀫𑁆𑀳𑀺, 𑀕𑀭𑀼 [𑀕𑀼𑀭𑀼 (𑀓. 𑀝𑀻.)] 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽𑀲𑁆𑀯𑀧𑀺;

𑀕𑀭𑀼 𑀢𑀻𑀲𑀼 𑀫𑀳𑀦𑁆𑀢𑁂 𑀘, 𑀤𑀼𑀚𑁆𑀚𑀭𑀸’𑀮𑀳𑀼𑀓𑁂𑀲𑀼 𑀘.

𑀅𑀘𑁆𑀘𑀺𑀢𑁂 𑀯𑀺𑀚𑁆𑀚𑀫𑀸𑀦𑁂 𑀘, 𑀧𑀲𑀢𑁆𑀣𑁂 𑀲𑀘𑁆𑀘 𑀲𑀸𑀥𑀼𑀲𑀼;

𑀔𑀺𑀦𑁆𑀦𑁂 𑀘 𑀲𑀫𑀺𑀢𑁂 𑀘𑁂𑀯, 𑀲𑀦𑁆𑀢𑁄𑀪𑀺𑀥𑁂𑀬𑁆𑀬𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄𑀢𑀺.

𑀤𑁂𑀯𑁄 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀺𑀤𑁂𑀯𑀸’𑀤𑁄, 𑀫𑁂𑀖 𑀫𑀘𑁆𑀘𑀼 𑀦𑀪𑁂𑀲𑀼 𑀘;

𑀅𑀣𑁄𑀧𑀺 𑀢𑀭𑀼𑀡𑁂 𑀲𑀢𑁆𑀢𑁂, 𑀘𑁄𑀭𑁂𑀧𑀺 𑀫𑀸𑀡𑀯𑁄 𑀪𑀯𑁂.

𑀆𑀤𑀺 𑀓𑁄𑀝𑁆𑀞𑀸𑀲 𑀓𑁄𑀝𑀻𑀲𑀼, 𑀧𑀼𑀭𑀢𑁄’𑀕𑁆𑀕𑀁𑀯𑀭𑁂 𑀢𑀻𑀲𑀼;

𑀧𑀘𑁆𑀘𑀦𑀻𑀓𑁄’𑀢𑁆𑀢𑀫𑁂𑀲𑁆𑀯’𑀜𑁆𑀜𑁂, 𑀧𑀘𑁆𑀙𑀸𑀪𑀸𑀕𑁂 𑀧𑀭𑁄 𑀢𑀺𑀲𑀼.

𑀬𑁄𑀦𑀺 𑀓𑀸𑀫 𑀲𑀺𑀭𑀺’𑀲𑁆𑀲𑀭𑁂, 𑀥𑀫𑁆𑀫𑀼’𑀬𑁆𑀬𑀸𑀫 𑀬𑀲𑁂 𑀪𑀕𑀁;

𑀉𑀴𑀸𑀭𑁄 𑀢𑀻𑀲𑀼 𑀯𑀺𑀧𑀼𑀮𑁂, 𑀲𑁂𑀝𑁆𑀞𑁂 𑀘 𑀫𑀥𑀼𑀭𑁂 𑀲𑀺𑀬𑀸.

𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄 𑀢𑀻𑀲𑀼 𑀲𑀫𑁆𑀧𑀼𑀡𑁆𑀡𑁂, 𑀫𑀥𑀼𑀭𑁂 𑀘 𑀲𑀫𑀗𑁆𑀕𑀺𑀦𑀺;

𑀲𑀗𑁆𑀔𑀸 𑀢𑀼 𑀜𑀸𑀡𑁂 𑀓𑁄𑀝𑁆𑀞𑀸𑀲, 𑀧𑀜𑁆𑀜𑀢𑁆𑀢𑀺 𑀕𑀡𑀦𑁂𑀲𑀼 𑀘.

𑀞𑀸𑀦𑀁 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑁄’𑀓𑀸𑀲, 𑀳𑁂𑀢𑀽𑀲𑀼 𑀞𑀺𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀘;

𑀅𑀣𑁄 𑀫𑀸𑀦𑁂 𑀧𑀓𑀸𑀭𑁂𑀘, 𑀓𑁄𑀝𑁆𑀞𑀸𑀲𑁂𑀘 𑀯𑀺𑀥𑁄 𑀤𑁆𑀯𑀺𑀲𑀼.

𑀧𑀜𑁆𑀜𑁄’𑀧𑀯𑀸𑀲 𑀔𑀦𑁆𑀢𑀻𑀲𑀼, 𑀤𑀫𑁄 𑀇𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀲𑀁𑀯𑀭𑁂;

𑀜𑀸𑀡𑁂 𑀘 𑀲𑁄𑀫𑀦𑀲𑁆𑀲𑁂𑀘, 𑀯𑁂𑀤𑁄 𑀙𑀦𑁆𑀤𑀲𑀺 𑀘𑁄’𑀘𑁆𑀘𑀢𑁂.

𑀔𑀦𑁆𑀥𑀓𑁄𑀝𑁆𑀞𑀸𑀲, 𑀧𑀲𑁆𑀲𑀸𑀯, 𑀫𑀕𑁆𑀕, 𑀳𑁂𑀢𑀽𑀲𑀼 𑀬𑁄𑀦𑀺 𑀲𑀸 [𑀬𑁄𑀦𑀺 𑀲𑁄 (𑀝𑀻.)];

𑀓𑀸𑀮𑁂 𑀢𑀼 𑀓𑀽𑀮𑁂 𑀲𑀻𑀫𑀸𑀬𑀁, 𑀯𑁂𑀮𑀸 𑀭𑀸𑀲𑀺𑀫𑁆𑀳𑀺 𑀪𑀸𑀲𑀺𑀢𑀸.

𑀯𑁄𑀳𑀸𑀭𑁄 𑀲𑀤𑁆𑀤 𑀧𑀡𑁆𑀡𑀢𑁆𑀢𑀺, 𑀯𑀡𑀺𑀚𑁆𑀚𑀸 𑀘𑁂𑀢𑀦𑀸𑀲𑀼 𑀘;

𑀦𑀸𑀕𑁄 𑀢𑀼’𑀭𑀕 𑀳𑀢𑁆𑀣𑀻𑀲𑀼, 𑀦𑀸𑀕𑀭𑀼𑀓𑁆𑀔𑁂 𑀢𑀣𑀼’𑀢𑁆𑀢𑀫𑁂.

𑀲𑁂𑀝𑁆𑀞𑀸’𑀲𑀳𑀸𑀬 𑀲𑀗𑁆𑀔𑁆𑀬𑀸’𑀜𑁆𑀜,

𑀢𑀼𑀮𑁆𑀬𑁂𑀲𑁆𑀯𑁂’𑀓𑁄𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄;

𑀭𑀸𑀕𑁂 𑀢𑀼 𑀫𑀸𑀦𑀲𑁄 𑀘𑀺𑀢𑁆𑀢𑀸, 𑀭𑀳𑀢𑁆𑀢𑁂𑀲𑀼 𑀘 𑀫𑀸𑀦𑀲𑀁.

𑀫𑀽𑀮𑀁 ¶ 𑀪𑁂 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀫𑀽𑀮, 𑀫𑀽𑀮𑁂 𑀳𑁂𑀢𑀼𑀫𑁆𑀳𑀺 𑀧𑀸𑀪𑀢𑁂;

𑀭𑀽𑀧𑀸𑀤𑁆𑀬𑀁’𑀲 𑀧𑀓𑀡𑁆𑀟𑁂𑀲𑀼, 𑀔𑀦𑁆𑀥𑁄 𑀭𑀸𑀲𑀺 𑀕𑀼𑀡𑁂𑀲𑀼 𑀘.

𑀆𑀭𑀫𑁆𑀪𑁄 𑀯𑀻𑀭𑀺𑀬𑁂 𑀓𑀫𑁆𑀫𑁂, 𑀆𑀤𑀺𑀓𑀫𑁆𑀫𑁂 𑀯𑀺𑀓𑁄𑀧𑀦𑁂;

𑀅𑀣𑁄 𑀳𑀤𑀬𑀯𑀢𑁆𑀣𑀼𑀫𑁆𑀳𑀺, 𑀘𑀺𑀢𑁆𑀢𑁂 𑀘 𑀳𑀤𑀬𑀁 𑀉𑀭𑁂.

𑀧𑀘𑁆𑀙𑀸𑀢𑀸𑀧𑀸’𑀦𑀼𑀩𑀦𑁆𑀥𑁂𑀲𑀼, 𑀭𑀸𑀕𑀸𑀤𑁄’𑀦𑀼𑀲𑀬𑁄 𑀪𑀯𑁂;

𑀫𑀸𑀢𑀗𑁆𑀕𑀫𑀼𑀤𑁆𑀥𑀧𑀺𑀡𑁆𑀟𑁂 𑀢𑀼, 𑀖𑀝𑁂 𑀓𑀼𑀫𑁆𑀪𑁄 𑀤𑀲𑀫𑁆𑀩𑀡𑁂.

𑀧𑀭𑀺𑀯𑀸𑀭𑁄 𑀧𑀭𑀺𑀚𑀦𑁂, 𑀔𑀕𑁆𑀕𑀓𑁄𑀲𑁂 𑀧𑀭𑀺𑀘𑁆𑀙𑀤𑁂;

𑀆𑀮𑀫𑁆𑀩𑀭𑁄 𑀢𑀼 𑀲𑀸𑀭𑀫𑁆𑀪𑁂, 𑀪𑁂𑀭𑀺𑀪𑁂𑀤𑁂 𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑀔𑀡𑁄 𑀓𑀸𑀮𑀯𑀺𑀲𑁂𑀲𑁂 𑀘, 𑀦𑀺𑀩𑁆𑀬𑀸𑀧𑀸𑀭𑀝𑁆𑀞𑀺𑀢𑀺𑀫𑁆𑀳𑀺 𑀘;

𑀓𑀼𑀮𑁂 𑀢𑁆𑀯’𑀪𑀺𑀚𑀦𑁄 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀉𑀧𑁆𑀧𑀢𑁆𑀢𑀺𑀪𑀽𑀫𑀺𑀬𑀫𑁆𑀧𑀺 𑀘.

𑀆𑀳𑀸𑀭𑁄 𑀓𑀩𑀴𑀻𑀓𑀸𑀭𑀸, 𑀳𑀸𑀭𑀸𑀤𑀻𑀲𑀼 𑀘 𑀓𑀸𑀭𑀡𑁂;

𑀯𑀺𑀲𑁆𑀲𑀸𑀲𑁂 𑀬𑀸𑀘𑀦𑀸𑀬𑀜𑁆𑀘, 𑀧𑁂𑀫𑁂 𑀘 𑀧𑀡𑀬𑁄 𑀫𑀢𑁄.

𑀡𑀸𑀤𑁄 𑀲𑀤𑁆𑀥𑀸, 𑀘𑀻𑀯𑀭𑀸𑀤𑀺, 𑀳𑁂𑀢𑁆𑀯𑀸’𑀥𑀸𑀭𑁂𑀲𑀼 𑀧𑀘𑁆𑀘𑀬𑁄;

𑀓𑀻𑀴𑀸 𑀤𑀺𑀩𑁆𑀩𑀯𑀺𑀳𑀸𑀭𑀸𑀤𑁄, 𑀯𑀺𑀳𑀸𑀭𑁄 𑀲𑀼𑀕𑀢𑀸𑀮𑀬𑁂.

𑀲𑀫𑀢𑁆𑀣𑀦𑁂 𑀫𑀢𑁄 𑀘𑀺𑀢𑁆𑀢𑁂, 𑀓𑀕𑁆𑀕𑀢𑀸𑀬𑀁 𑀲𑀫𑀸𑀥𑀺 𑀘;

𑀬𑁄𑀕𑁄 𑀲𑀗𑁆𑀕𑀢𑀺 [𑀲𑀗𑁆𑀕𑁂 𑀘 (𑀝𑀻.)] 𑀓𑀸𑀫𑀸𑀤𑁄,

𑀪𑁄𑀕𑁄 𑀲𑀧𑁆𑀧𑀨𑀡’𑀗𑁆𑀕𑁂𑀲𑀼, 𑀓𑁄𑀝𑀺𑀮𑁆𑀮𑁂 𑀪𑀼𑀜𑁆𑀚𑀦𑁂 𑀥𑀦𑁂;

𑀪𑀽𑀫𑀺𑀪𑀸𑀕𑁂 𑀓𑀺𑀮𑁂𑀲𑁂 𑀘, 𑀫𑀮𑁂 𑀘𑀸’𑀗𑁆𑀕𑀡 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀥𑀦𑀸𑀤𑀺𑀤𑀧𑁆𑀧𑁂 𑀧𑀜𑁆𑀜𑀸𑀬, 𑀅𑀪𑀺𑀫𑀸𑀦𑁄 𑀫𑀢𑁄 𑀣 𑀘;

𑀅𑀧𑀤𑁂𑀲𑁄 𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑁂 𑀘, 𑀙𑀮𑁂 𑀘 𑀓𑀣𑀦𑁂 𑀫𑀢𑁄.

𑀘𑀺𑀢𑁆𑀢𑁂 𑀓𑀸𑀬𑁂 𑀲𑀪𑀸𑀯𑁂 𑀘, 𑀲𑁄 𑀅𑀢𑁆𑀢𑀸 𑀧𑀭𑀫’𑀢𑁆𑀢𑀦𑀺;

𑀅𑀣 𑀕𑀼𑀫𑁆𑀩𑁄 𑀘 𑀣𑀫𑁆𑀩𑀲𑁆𑀫𑀺𑀁 [𑀣𑀫𑁆𑀪𑀲𑁆𑀫𑀺𑀁 (𑀝𑀻.)], 𑀲𑀫𑀽𑀳𑁂 𑀩𑀮𑀲𑀚𑁆𑀚𑀦𑁂.

𑀅𑀦𑁆𑀢𑁄𑀖𑀭𑁂 𑀓𑀼𑀲𑀽𑀮𑁂 𑀘, 𑀓𑁄𑀝𑁆𑀞𑁄 𑀦𑁆𑀢𑁄𑀓𑀼𑀘𑁆𑀙𑀺𑀬𑀁 𑀧𑁆𑀬𑀣;

𑀲𑁄𑀧𑀸𑀦𑀗𑁆𑀕𑀫𑁆𑀳𑀺 𑀉𑀡𑁆𑀳𑀻𑀲𑁄, 𑀫𑀓𑀼𑀝𑁂 𑀲𑀻𑀲𑀯𑁂𑀞𑀦𑁂.

𑀦𑀺𑀬𑁆𑀬𑀸𑀲𑁂 𑀲𑁂𑀔𑀭𑁂 𑀤𑁆𑀯𑀸𑀭𑁂, 𑀦𑀺𑀬𑁆𑀬𑀽𑀳𑁄 𑀦𑀸𑀕𑀤𑀦𑁆𑀢𑀓𑁂;

𑀅𑀣𑁄 𑀲𑀺𑀔𑀡𑁆𑀟𑁂 𑀢𑀽𑀡𑀻𑀭𑁂, 𑀓𑀮𑀸𑀧𑁄 𑀦𑀺𑀓𑀭𑁂 𑀫𑀢𑁄.

𑀘𑀽𑀴𑀸 𑀲𑀁𑀬𑀢𑀓𑁂𑀲𑁂𑀲𑀼, 𑀫𑀓𑀼𑀝𑁂 𑀫𑁄𑀴𑀺 𑀘 𑀤𑁆𑀯𑀺𑀲𑀼;

𑀲𑀗𑁆𑀔𑁄 𑀢𑁆𑀯’𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀓𑀫𑁆𑀩𑀼, 𑀦𑀮𑀸𑀝’𑀝𑁆𑀞𑀻𑀲𑀼 [𑀮𑀮𑀸𑀝𑀝𑁆𑀞𑀻𑀲𑀼 (𑀲𑀻.)] 𑀕𑁄𑀧𑁆𑀨𑀓𑁂.

𑀧𑀓𑁆𑀔𑁄 ¶ 𑀓𑀸𑀮𑁂 𑀩𑀮𑁂 𑀲𑀸𑀥𑁆𑀬𑁂, 𑀲𑀔𑀻 𑀯𑀸𑀚𑁂𑀲𑀼 𑀧𑀗𑁆𑀕𑀼𑀮𑁂;

𑀤𑁂𑀲𑁂’𑀡𑁆𑀡𑀯𑁂 𑀧𑀼𑀫𑁂 𑀲𑀺𑀦𑁆𑀥𑀼, 𑀲𑀭𑀺𑀢𑀸𑀬𑀁 𑀲 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀕𑀚𑁂 𑀓𑀭𑁂𑀡𑀼 𑀧𑀼𑀭𑀺𑀲𑁂, 𑀲𑁄 𑀳𑀢𑁆𑀣𑀺𑀦𑀺𑀬 𑀫𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀭𑀢𑀦𑁂 𑀯𑀚𑀺𑀭𑁄 𑀦𑀺𑀢𑁆𑀣𑀻, 𑀫𑀡𑀺𑀯𑁂𑀥𑀺’𑀦𑁆𑀤𑀳𑁂𑀢𑀺𑀲𑀼.

𑀯𑀺𑀲𑀸𑀡𑀁 𑀢𑀻𑀲𑀼 𑀫𑀸𑀢𑀗𑁆𑀕, 𑀤𑀦𑁆𑀢𑁂 𑀘 𑀧𑀲𑀼𑀲𑀺𑀗𑁆𑀕𑀓𑁂;

𑀓𑁄𑀝𑀺𑀬𑀁 𑀢𑀼 𑀫𑀢𑁄 𑀓𑁄𑀡𑁄, 𑀢𑀣𑀸 𑀯𑀸𑀤𑀺𑀢𑁆𑀢𑀯𑀸𑀤𑀦𑁂.

𑀯𑀡𑀺𑀧𑁆𑀧𑀣𑁂 𑀘 𑀦𑀕𑀭𑁂, 𑀯𑁂𑀤𑁂 𑀘 𑀦𑀺𑀕𑀫𑁄 𑀣 𑀘;

𑀯𑀺𑀯𑀸𑀤𑀸𑀤𑁄’ 𑀥𑀺𑀓𑀭𑀡𑀁, 𑀲𑀺𑀬𑀸’𑀥𑀸𑀭𑁂 𑀘 𑀓𑀸𑀭𑀡𑁂.

𑀧𑀲𑀼𑀫𑁆𑀳𑀺 𑀯𑀲𑀼𑀥𑀸𑀬𑀜𑁆𑀘, 𑀯𑀸𑀘𑀸𑀤𑁄 𑀕𑁄 𑀧𑀼𑀫𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀳𑀭𑀺𑀢𑁂 𑀢𑀼 𑀲𑀼𑀯𑀡𑁆𑀡𑁂 𑀘, 𑀯𑀸𑀲𑀼𑀤𑁂𑀯𑁂 𑀳𑀭𑀻’𑀭𑀺𑀢𑁄.

𑀆𑀬𑀢𑁆𑀢𑁂 𑀧𑀭𑀺𑀯𑀸𑀭𑁂 𑀘, 𑀪𑀭𑀺𑀬𑀸𑀬𑀁 𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑁄;

𑀉𑀢𑁆𑀢𑀁𑀲𑁄 𑀢𑁆𑀯’ 𑀯𑀢𑀁𑀲𑁄 𑀘, 𑀓𑀡𑁆𑀡𑀧𑀽𑀭𑁂 𑀘 𑀲𑁂𑀔𑀭𑁂.

𑀯𑀺𑀚𑁆𑀚𑀼𑀬𑀁 𑀯𑀚𑀺𑀭𑁂 𑀘𑁂𑀯𑀸, 𑀲𑀦𑀺’𑀢𑁆𑀣𑀺𑀧𑀼𑀭𑀺𑀲𑁂 𑀧𑁆𑀬𑀣;

𑀓𑁄𑀡𑁂 𑀲𑀗𑁆𑀔𑁆𑀬𑀸𑀯𑀺𑀲𑁂𑀲𑀲𑁆𑀫𑀺𑀁, 𑀉𑀓𑁆𑀓𑀁𑀲𑁂 𑀓𑁄𑀝𑀺 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀘𑀽𑀴𑀸 𑀚𑀸𑀮𑀸 𑀧𑀥𑀸𑀦’𑀕𑁆𑀕, 𑀫𑁄𑀭𑀘𑀽𑀴𑀸𑀲𑀼 𑀲𑀸 𑀲𑀺𑀔𑀸;

𑀲𑀧𑁆𑀧𑀤𑀸𑀞𑀸𑀬 𑀫𑀸𑀲𑀻’𑀢𑁆𑀣𑀻, 𑀇𑀝𑁆𑀞𑀲𑁆𑀲𑀸’𑀲𑀻𑀲𑀦𑀸𑀬𑀧𑀺.

𑀯𑀲𑀸 𑀯𑀺𑀮𑀻𑀦 𑀢𑁂𑀮𑀲𑁆𑀫𑀺𑀁, 𑀯𑀲𑀕𑀸 𑀯𑀜𑁆𑀛𑀕𑀸𑀯𑀺𑀲𑀼;

𑀅𑀪𑀺𑀮𑀸𑀲𑁂 𑀢𑀼 𑀓𑀺𑀭𑀡𑁂, 𑀅𑀪𑀺𑀲𑀗𑁆𑀕𑁂 𑀭𑀼𑀘𑀺’𑀢𑁆𑀣𑀺𑀬𑀁.

𑀲𑀜𑁆𑀜𑀸 𑀲𑀜𑁆𑀚𑀸𑀦𑀦𑁂 𑀦𑀸𑀫𑁂, 𑀘𑁂𑀢𑀦𑀸𑀬𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀅𑀁𑀲𑁂 𑀲𑀺𑀧𑁆𑀧𑁂 𑀓𑀮𑀸 𑀓𑀸𑀮𑁂, 𑀪𑀸𑀕𑁂 𑀘𑀦𑁆𑀤𑀲𑁆𑀲 𑀲𑁄𑀴𑀲𑁂.

𑀩𑀻𑀚𑀓𑁄𑀲𑁂 𑀖𑀭𑀓𑀽𑀝𑁂, 𑀓𑀡𑁆𑀡𑀪𑀽𑀲𑀸𑀬 𑀓𑀡𑁆𑀡𑀺𑀓𑀸;

𑀆𑀕𑀸𑀫𑀺𑀓𑀸𑀮𑁂 𑀤𑀻𑀖𑀢𑁆𑀢𑁂, 𑀧𑀪𑀸𑀯𑁂 𑀘 𑀫𑀢𑀸’𑀬𑀢𑀺.

𑀉𑀡𑁆𑀡𑀸 𑀫𑁂𑀲𑀸𑀤𑀺𑀮𑁄𑀫𑁂, 𑀘, 𑀪𑀽𑀫𑀚𑁆𑀛𑁂 𑀭𑁄𑀫𑀥𑀸𑀢𑀼𑀬𑀁;

𑀯𑀸𑀭𑀼𑀡𑀻 𑀢𑁆𑀯𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀼𑀢𑁆𑀢𑀸, 𑀦𑀝𑁆𑀝𑀓𑀻 𑀫𑀤𑀺𑀭𑀸𑀤𑀺𑀲𑀼.

𑀓𑁆𑀭𑀺𑀬𑀘𑀺𑀢𑁆𑀢𑁂 𑀘 𑀓𑀭𑀡𑁂, 𑀓𑀺𑀭𑀺𑀬𑀁 𑀓𑀫𑁆𑀫𑀦𑀺 𑀓𑁆𑀭𑀺𑀬𑀸;

𑀲𑀼𑀦𑀺𑀲𑀸𑀬𑀁 𑀢𑀼 𑀓𑀜𑁆𑀜𑀸𑀬, 𑀚𑀸𑀬𑀸𑀬 𑀘 𑀯𑀥𑀽 𑀫𑀢𑀸.

𑀧𑀫𑀸𑀡𑀺’𑀲𑁆𑀲𑀭𑀺𑀬𑁂 𑀫𑀢𑁆𑀢𑀸, 𑀅𑀓𑁆𑀔𑀭𑀸𑀯𑀬𑀯𑁂’𑀧𑁆𑀧𑀓𑁂;

𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀸𑀯𑀘𑀦𑁂 𑀭𑀺𑀝𑁆𑀞𑁂 [𑀲𑀺𑀤𑁆𑀥𑁂 (𑀝𑀻.)], 𑀢𑀦𑁆𑀢𑁂 𑀢𑀁 𑀲𑀼𑀧𑀺𑀢𑁂 𑀢𑀺𑀲𑀼.

𑀭𑀸𑀚𑀮𑀺𑀗𑁆𑀕𑁄’𑀲𑀪𑀗𑁆𑀕𑁂𑀲𑀼, ¶ 𑀭𑀼𑀓𑁆𑀔𑁂 𑀘 𑀓𑀓𑀼𑀤𑁄 [𑀓𑀓𑀼𑀥𑁄 (𑀝𑀻. 𑀲𑀻.)] 𑀧𑁆𑀬𑀣;

𑀦𑀺𑀫𑀺𑀢𑁆𑀢’𑀓𑁆𑀔𑀭 𑀲𑀽𑀧𑁂𑀲𑀼, 𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀁 𑀘𑀺𑀳𑀦𑁂 𑀧𑀤𑁂.

𑀯𑁄𑀳𑀸𑀭𑁂 𑀚𑁂𑀢𑀼 𑀫𑀺𑀘𑁆𑀙𑀸𑀬𑀁, 𑀓𑀻𑀴𑀸𑀤𑁄 𑀘𑀸𑀧𑀺 𑀤𑁂𑀯𑀦𑀁;

𑀪𑀭𑀺𑀬𑀸𑀬𑀁 𑀢𑀼 𑀓𑁂𑀤𑀸𑀭𑁂, 𑀲𑀭𑀻𑀭𑁂 𑀔𑁂𑀢𑁆𑀢 𑀫𑀻𑀭𑀺𑀢𑀁.

𑀲𑀼𑀲𑁆𑀲𑀽𑀲𑀸𑀬𑀜𑁆𑀘 𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑀁, 𑀇𑀲𑁆𑀲𑀸𑀪𑁆𑀬𑀸𑀲𑁂 𑀧𑁆𑀬𑀼’𑀧𑀸𑀲𑀦𑀁;

𑀲𑀽𑀮𑀁 𑀢𑀼 𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀳𑁂𑀢𑀺, 𑀪𑁂𑀤𑁂 𑀲𑀁𑀓𑀼 𑀭𑀼𑀚𑀸𑀲𑀼 𑀘.

𑀢𑀦𑁆𑀢𑀺 𑀯𑀻𑀡𑀸𑀕𑀼𑀡𑁂, 𑀢𑀦𑁆𑀢𑀁, 𑀫𑀼𑀔𑁆𑀬𑀲𑀺𑀤𑁆𑀥𑀦𑁆𑀢 𑀢𑀦𑁆𑀢𑀼𑀲𑀼;

𑀭𑀣𑀸𑀤𑁆𑀬𑀗𑁆𑀕𑁂 𑀢𑀼 𑀘 𑀬𑀼𑀕𑁄, 𑀓𑀧𑁆𑀧𑀫𑁆𑀳𑀺 𑀬𑀼𑀕𑀮𑁂 𑀬𑀼𑀕𑀁.

𑀇𑀢𑁆𑀣𑀺𑀧𑀼𑀧𑁆𑀨𑁂 𑀘 𑀭𑁂𑀡𑀼𑀫𑁆𑀳𑀺, 𑀭𑀚𑁄 𑀧𑀓𑀢𑀺𑀚𑁂 𑀕𑀼𑀡𑁂;

𑀦𑁆𑀬𑀸𑀲𑀧𑁆𑀧𑀡𑁂 𑀢𑀼 𑀤𑀸𑀦𑀫𑁆𑀳𑀺, 𑀦𑀺𑀬𑁆𑀬𑀸𑀢𑀦 𑀫𑀼𑀤𑀻𑀭𑀺𑀢𑀁.

𑀕𑀭𑀼’𑀧𑀸𑀬𑀸’𑀯𑀢𑀸𑀭𑁂𑀲𑀼, 𑀢𑀺𑀢𑁆𑀣𑀁 𑀧𑀽𑀢𑀫𑁆𑀩𑀼 𑀤𑀺𑀝𑁆𑀞𑀺𑀲𑀼;

𑀧𑀡𑁆𑀟𑀓𑁂 𑀚𑁄𑀢𑀺 𑀦𑀓𑁆𑀔𑀢𑁆𑀢, 𑀭𑀁𑀲𑀻𑀲𑁆𑀯’𑀕𑁆𑀕𑀺𑀫𑁆𑀳𑀺 𑀚𑁄𑀢𑀺 𑀲𑁄.

𑀓𑀡𑁆𑀟𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀲𑀭𑁂 𑀤𑀡𑁆𑀟𑁂, 𑀯𑀕𑁆𑀕𑁂 𑀘𑀸𑀯𑀲𑀭𑁂 𑀧𑁆𑀬𑀣;

𑀉𑀤𑁆𑀥𑀁𑀩𑀸𑀳𑀼𑀤𑁆𑀯𑀬𑀫𑀸𑀦𑁂 [𑀩𑀸𑀳𑀼𑀤𑁆𑀯𑀬𑀼𑀫𑁆𑀫𑀸𑀦𑁂 (𑀲𑀻. 𑀓.)], 𑀲𑀽𑀭𑀢𑁆𑀢𑁂𑀧𑀺 𑀘 𑀧𑁄𑀭𑀺𑀲𑀁.

𑀉𑀝𑁆𑀞𑀸𑀦𑀁 𑀧𑁄𑀭𑀺𑀲𑁂’𑀳𑀸𑀲𑀼, 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀸𑀤𑁆𑀬𑀼’𑀕𑁆𑀕𑀫𑁂 𑀧𑁆𑀬𑀣;

𑀅𑀦𑀺𑀲𑁆𑀲𑀬𑀫𑀳𑀻𑀪𑀸𑀕𑁂, 𑀢𑁆𑀯𑀺’𑀭𑀻𑀡𑀁 𑀊𑀲𑀭𑁂 𑀲𑀺𑀬𑀸.

𑀆𑀭𑀸𑀥𑀦𑀁 𑀲𑀸𑀥𑀦𑁂 𑀘, 𑀧𑀢𑁆𑀢𑀺𑀬𑀁 𑀧𑀭𑀺𑀢𑁄𑀲𑀦𑁂;

𑀧𑀥𑀸𑀦𑁂 𑀢𑀼 𑀘 𑀲𑀸𑀦𑀼𑀫𑁆𑀳𑀺, 𑀯𑀺𑀲𑀸𑀡𑁂 𑀲𑀺𑀗𑁆𑀕 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀤𑀺𑀝𑁆𑀞𑀸’𑀤𑀺𑀫𑀕𑁆𑀕𑁂 𑀜𑀸𑀡’𑀓𑁆𑀔𑀺, 𑀓𑁆𑀔𑀡 𑀮𑀤𑁆𑀥𑀻𑀲𑀼 𑀤𑀲𑁆𑀲𑀦𑀁;

𑀳𑁂𑀫𑁂 𑀧𑀜𑁆𑀘𑀲𑀼𑀯𑀡𑁆𑀡𑁂 𑀘, 𑀦𑀺𑀓𑁆𑀔𑁄 𑀦𑀺𑀢𑁆𑀣𑀻 𑀧𑀲𑀸𑀥𑀦𑁂.

𑀢𑀺𑀣𑀺𑀪𑁂𑀤𑁂 𑀘 𑀲𑀸𑀔𑀸𑀤𑀺, 𑀨𑀴𑀼𑀫𑁆𑀳𑀺 𑀧𑀩𑁆𑀩 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀦𑀸𑀕𑀮𑁄𑀓𑁂 𑀢𑀼 𑀧𑀸𑀢𑀸𑀮𑀁, 𑀪𑀸𑀲𑀺𑀢𑀁 𑀩𑀮𑀯𑀸𑀫𑀼𑀔𑁂.

𑀓𑀸𑀫𑀚𑁂 𑀓𑁄𑀧𑀚𑁂 𑀤𑁄𑀲𑁂, 𑀩𑁆𑀬𑀲𑀦𑀜𑁆𑀘 𑀯𑀺𑀧𑀢𑁆𑀢𑀺𑀬𑀁;

𑀅𑀣𑁄’𑀧𑀓𑀭𑀡𑁂 𑀲𑀺𑀤𑁆𑀥𑀺, 𑀓𑀸𑀭𑀓𑁂𑀲𑀼 𑀘 𑀲𑀸𑀥𑀦𑀁.

𑀢𑀻𑀲𑁆𑀯𑀻𑀭𑀺𑀢𑁄 [𑀢𑀻𑀲𑁆𑀯𑀺𑀢𑁄 (𑀝𑀻.)] 𑀤𑀸𑀦𑀲𑀻𑀮𑁂, 𑀯𑀤𑀜𑁆𑀜𑀽 𑀯𑀕𑁆𑀕𑀼𑀯𑀸𑀤𑀺𑀦𑀺;

𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄 𑀪𑀺𑀲𑀺𑀢𑁆𑀢𑁂 𑀘, 𑀧𑀽𑀚𑀺𑀢𑁂 𑀧𑀼𑀭𑀢𑁄𑀓𑀢𑁂.

𑀫𑀦𑁆𑀤𑁄 𑀪𑀸𑀕𑁆𑀬𑀯𑀺𑀳𑀻𑀦𑁂 𑀘𑀸, 𑀧𑁆𑀧𑀓𑁂 𑀫𑀽𑀴𑁆𑀳𑀸’𑀧𑀝𑀽𑀲𑁆𑀯𑀧𑀺;

𑀯𑀼𑀤𑁆𑀥𑀺𑀬𑀼𑀢𑁆𑀢𑁂 𑀲𑀫𑀼𑀦𑁆𑀦𑀤𑁆𑀥𑁂, 𑀉𑀧𑁆𑀧𑀦𑁆𑀦𑁂 𑀉𑀲𑁆𑀲𑀺𑀢𑀁 𑀪𑀯𑁂.

𑀭𑀣𑀗𑁆𑀕𑁂’𑀓𑁆𑀔𑁄 ¶ 𑀲𑀼𑀯𑀡𑁆𑀡𑀲𑁆𑀫𑀺𑀁, 𑀧𑀸𑀲𑀓𑁂, 𑀅𑀓𑁆𑀔 𑀫𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁂;

𑀲𑀲𑁆𑀲𑀢𑁂 𑀘 𑀥𑀼𑀯𑁄 𑀢𑀻𑀲𑀼, 𑀥𑀼𑀯𑀁 𑀢𑀓𑁆𑀓𑁂 𑀘 𑀦𑀺𑀘𑁆𑀙𑀺𑀢𑁂.

𑀳𑀭𑁂 𑀲𑀺𑀯𑁄, 𑀲𑀺𑀯𑀁 𑀪𑀤𑁆𑀤, 𑀫𑁄𑀓𑁆𑀔𑁂𑀲𑀼, 𑀚𑀫𑁆𑀩𑀼𑀓𑁂 𑀲𑀺𑀯𑀸;

𑀲𑁂𑀦𑀸𑀬𑀁 𑀲𑀢𑁆𑀢𑀺𑀬𑀜𑁆𑀘𑁂𑀯, 𑀣𑀽𑀮𑀢𑁆𑀢𑁂 𑀘 𑀩𑀮𑀁 𑀪𑀯𑁂.

𑀲𑀗𑁆𑀔𑁆𑀬𑀸 𑀦𑀭𑀓𑀪𑁂𑀤𑁂𑀲𑀼, 𑀧𑀤𑀼𑀫𑀁 𑀯𑀸𑀭𑀺𑀚𑁂 𑀧𑁆𑀬𑀣;

𑀤𑁂𑀯𑀪𑁂𑀤𑁂 𑀯𑀲𑀼 𑀧𑀼𑀫𑁂, 𑀧𑀡𑁆𑀟𑀓𑀁 𑀭𑀢𑀦𑁂 𑀥𑀦𑁂.

𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀁 𑀅𑀢𑁆𑀣𑀕𑀫𑀦𑁂, 𑀅𑀧𑀯𑀕𑁆𑀕𑁂 𑀲𑀺𑀬𑀸 𑀣 𑀘;

𑀲𑁂𑀢𑀫𑁆𑀩𑀼𑀚𑁂 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀁, 𑀩𑁆𑀬𑀕𑁆𑀖𑁂 𑀭𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑀭𑁂 𑀧𑀼𑀫𑁂.

𑀉𑀧𑀳𑀸𑀭𑁂 𑀩𑀮𑀺 𑀧𑀼𑀫𑁂, 𑀓𑀭𑀲𑁆𑀫𑀺𑀁𑀘𑀸’𑀲𑀼𑀭𑀦𑁆𑀢𑀭𑁂;

𑀲𑀼𑀓𑁆𑀓𑀁 𑀢𑀼 𑀲𑀫𑁆𑀪𑀯𑁂, 𑀲𑀼𑀓𑁆𑀓𑁄, 𑀥𑀯𑀮𑁂, 𑀓𑀼𑀲𑀮𑁂 𑀢𑀺𑀲𑀼.

𑀤𑀸𑀬𑁄 𑀤𑀸𑀦𑁂 𑀯𑀺𑀪𑀢𑁆𑀢𑀩𑁆𑀩, 𑀥𑀦𑁂 𑀘 𑀧𑀺𑀢𑀼𑀦𑀁 𑀯𑀦𑁂 [𑀥𑀦𑁂 (𑀝𑀻.)];

𑀧𑀪𑀼𑀢𑁆𑀢𑀸’𑀬𑀢𑁆𑀢𑀢𑀸’𑀬𑀢𑁆𑀢𑀸’, 𑀪𑀺𑀮𑀸𑀲𑁂𑀲𑀼 𑀯𑀲𑁄 𑀪𑀯𑁂.

𑀧𑀭𑀺𑀪𑀸𑀲𑀦 𑀫𑀓𑁆𑀓𑁄𑀲𑁂, 𑀦𑀺𑀬𑀫𑁂 𑀪𑀸𑀲𑀦𑁂 𑀣 𑀘,

𑀥𑀦𑀫𑁆𑀳𑀺 𑀲𑁂𑀴𑀦𑀁 𑀬𑁄𑀥, 𑀲𑀻𑀳𑀦𑀸𑀤𑀫𑁆𑀳𑀺 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑀧𑀪𑀯𑁄 𑀚𑀸𑀢𑀺𑀳𑁂𑀢𑀼𑀫𑁆𑀳𑀺, 𑀞𑀸𑀦𑁂 𑀘𑀸𑀤𑁆𑀬𑀼𑀧𑀮𑀤𑁆𑀥𑀺𑀬𑀁;

𑀅𑀣𑁄’𑀢𑀼 𑀦𑀸𑀭𑀺𑀧𑀼𑀧𑁆𑀨𑀲𑁆𑀫𑀺𑀁, 𑀳𑁂𑀫𑀦𑁆𑀢𑀸𑀤𑀺𑀫𑁆𑀳𑀺 𑀘 𑀤𑁆𑀯𑀺𑀲𑀼.

𑀓𑀭𑀡𑀁 𑀲𑀸𑀥𑀓𑀢𑀫𑁂, 𑀓𑁆𑀭𑀺𑀬𑀸 𑀕𑀢𑁆𑀢𑁂𑀲𑀼 𑀇𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁂;

𑀢𑀸𑀢𑁄 [𑀢𑀸𑀴𑁄 (𑀲𑀻.)] 𑀢𑀼 𑀓𑀼𑀜𑁆𑀘𑀺𑀓𑀸𑀬𑀜𑁆𑀘, 𑀢𑀽𑀭𑀺𑀬𑀗𑁆𑀕𑁂 𑀤𑀼𑀫𑀦𑁆𑀢𑀭𑁂.

𑀧𑀼𑀧𑁆𑀨𑁂 𑀨𑀮𑁂 𑀘 𑀧𑀲𑀯𑁄, 𑀉𑀧𑁆𑀧𑀸𑀤𑁂 𑀕𑀩𑁆𑀪𑀫𑁄𑀘𑀦𑁂;

𑀕𑀸𑀬𑀦𑁂 𑀕𑀸𑀬𑀓𑁂 𑀅𑀲𑁆𑀲𑁂, 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄 𑀤𑁂𑀯𑀢𑀸𑀦𑁆𑀢𑀭𑁂.

𑀯𑀺𑀦𑀸 𑀧𑀼𑀧𑁆𑀨𑀁 𑀨𑀮𑀕𑁆𑀕𑀸𑀳𑀺, 𑀭𑀼𑀓𑁆𑀔𑁂 𑀯𑀦𑀧𑁆𑀧𑀢𑀺;

𑀆𑀳𑀢𑁂 𑀳𑁂𑀫𑀭𑀚𑀢𑁂, 𑀭𑀽𑀧𑀺𑀬𑀁 𑀭𑀚𑀢𑁂𑀧𑀺 𑀘.

𑀔𑀕𑀸𑀤𑀺𑀩𑀦𑁆𑀥𑀦𑁂 𑀧𑀸𑀲𑁄, 𑀓𑁂𑀲𑀧𑀼𑀩𑁆𑀩𑁄 𑀘𑀬𑁂 𑀧𑁆𑀬𑀣;

𑀢𑀸𑀭𑀸’𑀓𑁆𑀔𑀺𑀫𑀚𑁆𑀛𑁂 𑀦𑀓𑁆𑀔𑀢𑁆𑀢𑁂, 𑀢𑀸𑀭𑁄 𑀉𑀘𑁆𑀘𑀢𑀭𑀲𑁆𑀲𑀭𑁂.

𑀧𑀢𑁆𑀢𑁂 𑀘 𑀮𑁄𑀳𑀪𑁂𑀤𑀲𑁆𑀫𑀺𑀁, 𑀓𑀁𑀲𑁄 𑀘𑀢𑀼𑀓𑀳𑀸𑀧𑀡𑁂;

𑀫𑀚𑁆𑀛𑀺𑀫𑁄 𑀤𑁂𑀳𑀫𑀚𑁆𑀛𑀲𑁆𑀫𑀺𑀁, 𑀫𑀚𑁆𑀛𑀪𑀯𑁂 𑀘 𑀲𑁄 𑀢𑀺𑀲𑀼.

𑀆𑀯𑁂𑀲𑀦𑀁𑀪𑀽𑀢𑀸𑀯𑁂𑀲𑁂, 𑀲𑀺𑀧𑁆𑀧𑀲𑀸𑀮𑀸 𑀖𑀭𑁂𑀲𑀼 𑀘;

𑀲𑁄𑀪𑀸 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀻𑀲𑀼 𑀲𑀺𑀭𑀻, 𑀮𑀓𑁆𑀔𑀻𑀢𑁆𑀣𑀻 𑀤𑁂𑀯𑀢𑀸𑀬 𑀘.

𑀓𑀼𑀫𑀸𑀭𑁄 ¶ 𑀬𑀼𑀯𑀭𑀸𑀚𑁂 𑀘, 𑀔𑀦𑁆𑀤𑁂 𑀯𑀼𑀢𑁆𑀢𑁄 𑀲𑀼𑀲𑀼𑀫𑁆𑀳𑀺 𑀘;

𑀅𑀣𑀸’𑀦𑀺𑀢𑁆𑀣𑀻 𑀧𑀯𑀸𑀴𑁄 𑀘, 𑀫𑀡𑀺𑀪𑁂𑀤𑁂 𑀢𑀣𑀸’𑀗𑁆𑀓𑀼𑀭𑁂.

𑀧𑀡𑁄 𑀯𑁂𑀢𑀦 𑀫𑀽𑀮𑁂𑀲𑀼, 𑀯𑁄𑀳𑀸𑀭𑁂 𑀘 𑀥𑀦𑁂 𑀫𑀢𑁄;

𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑁄 𑀢𑀼 𑀕𑀳𑀡𑁂, 𑀓𑀣𑀺𑀢𑁄 𑀪𑀸𑀚𑀦𑀦𑁆𑀢𑀭𑁂.

𑀅𑀲𑀼𑀪𑁂 𑀘 𑀲𑀼𑀪𑁂 𑀓𑀫𑁆𑀫𑁂, 𑀪𑀸𑀕𑁆𑀬𑀁 𑀯𑀼𑀢𑁆𑀢𑀁 𑀤𑁆𑀯𑀬𑁂 𑀧𑁆𑀬𑀣;

𑀧𑀺𑀧𑁆𑀨𑀮𑀁 𑀢𑀭𑀼𑀪𑁂𑀤𑁂 𑀘, 𑀯𑀢𑁆𑀣𑀘𑁆𑀙𑁂𑀤𑀦𑀲𑀢𑁆𑀣𑀓𑁂.

𑀅𑀧𑀯𑀕𑁆𑀕𑁄 𑀧𑀭𑀺𑀘𑁆𑀘𑀸𑀕𑀸’, 𑀯𑀲𑀸𑀦𑁂𑀲𑀼 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀺𑀬𑀁;

𑀮𑀺𑀗𑁆𑀕𑀁 𑀢𑀼 𑀅𑀗𑁆𑀕𑀚𑀸𑀢𑀲𑁆𑀫𑀺𑀁, 𑀧𑀼𑀫𑀢𑁆𑀢𑀸𑀤𑀺𑀫𑁆𑀳𑀺 𑀮𑀓𑁆𑀔𑀡𑁂.

𑀘𑀸𑀕𑁂 𑀲𑀪𑀸𑀯𑁂 𑀦𑀺𑀫𑁆𑀫𑀸𑀦𑁂, 𑀲𑀕𑁆𑀕𑁄 𑀚𑁆𑀛𑀸𑀬𑁂 𑀤𑀺𑀯𑁂𑀧𑁆𑀬𑀣;

𑀭𑁄𑀳𑀺𑀢𑁄 𑀮𑁄𑀳𑀺𑀢𑁂 𑀫𑀘𑁆𑀙, 𑀪𑁂𑀤𑁂 𑀘𑁂𑀯 𑀫𑀺𑀕𑀦𑁆𑀢𑀭𑁂.

𑀦𑀺𑀝𑁆𑀞𑀸 𑀦𑀺𑀧𑁆𑀨𑀢𑁆𑀢𑀺𑀬𑀁 𑀘𑁂𑀯𑀸, 𑀯𑀲𑀸𑀦𑀫𑁆𑀳𑀺 𑀅𑀤𑀲𑁆𑀲𑀦𑁂;

𑀓𑀡𑁆𑀝𑀓𑁄 𑀢𑀼 𑀲𑀧𑀢𑁆𑀢𑀲𑁆𑀫𑀺𑀁, 𑀭𑀼𑀓𑁆𑀔𑀗𑁆𑀕𑁂 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑁂.

𑀫𑀼𑀔𑁆𑀬𑁄’𑀧𑀸𑀬𑁂𑀲𑀼 𑀯𑀤𑀦𑁂, 𑀆𑀤𑀺𑀲𑁆𑀫𑀺𑀁 𑀫𑀼𑀔 𑀫𑀻𑀭𑀺𑀢𑀁;

𑀤𑀩𑁆𑀩𑀁 𑀪𑀩𑁆𑀩𑁂 𑀕𑀼𑀡𑀸𑀥𑀸𑀭𑁂, 𑀯𑀺𑀢𑁆𑀢𑁂 𑀘 𑀩𑀼𑀥 𑀤𑀸𑀭𑀼𑀲𑀼.

𑀫𑀸𑀦𑀁 𑀧𑀫𑀸𑀡𑁂 𑀧𑀢𑁆𑀣𑀸𑀤𑁄, 𑀫𑀸𑀦𑁄 𑀯𑀼𑀢𑁆𑀢𑁄 𑀯𑀺𑀥𑀸𑀬 𑀘;

𑀅𑀣𑁄 𑀧𑀭𑀺𑀲𑁆𑀲𑀫𑁂 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀯𑀸𑀬𑀸𑀫𑁄 𑀯𑀻𑀭𑀺𑀬𑁂𑀧𑀺 𑀘.

𑀲𑀭𑁄𑀭𑀼𑀳𑁂 𑀲𑀢𑀧𑀢𑁆𑀢𑀁, 𑀲𑀢𑀧𑀢𑁆𑀢𑁄 𑀔𑀕𑀦𑁆𑀢𑀭𑁂;

𑀙𑀺𑀤𑁆𑀤𑁂 𑀢𑀼 𑀙𑀺𑀤𑁆𑀤𑀯𑀦𑁆𑀢𑁂 𑀘, 𑀲𑀼𑀲𑀺𑀭𑀁 𑀢𑀽𑀭𑀺𑀬𑀦𑁆𑀢𑀭𑁂.

𑀏𑀓𑀲𑁆𑀫𑀺𑀁 𑀲𑀤𑀺𑀲𑁂 𑀲𑀦𑁆𑀢𑁂, 𑀲𑀫𑀸𑀦𑀁 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁;

𑀅𑀣𑁄 𑀕𑀸𑀭𑀯 𑀪𑀻𑀢𑀻𑀲𑀼, 𑀲𑀁𑀯𑁂𑀕𑁂 𑀲𑀫𑁆𑀪𑀫𑁄 𑀫𑀢𑁄.

𑀚𑀼𑀡𑁆𑀳𑀸 𑀘𑀦𑁆𑀤𑀧𑁆𑀧𑀪𑀸𑀬𑀜𑁆𑀘, 𑀢𑀤𑀼𑀧𑁂𑀢𑀦𑀺𑀲𑀸𑀬 𑀘;

𑀯𑀺𑀫𑀸𑀦𑀁 𑀤𑁂𑀯𑀢𑀸𑀯𑀸𑀲𑁂, 𑀲𑀢𑁆𑀢𑀪𑀽𑀫𑀺𑀖𑀭𑀫𑁆𑀳𑀺 𑀘.

𑀫𑀸𑀲𑁂 𑀚𑁂𑀝𑁆𑀞𑁄, 𑀢𑀺𑀯𑀼𑀤𑁆𑀥𑀸’𑀢𑀺, 𑀧𑁆𑀧𑀲𑀢𑁆𑀣𑁂𑀲𑀼 𑀘 𑀢𑀻𑀲𑀼 𑀲𑁄;

𑀥𑀫𑁆𑀫𑁂 𑀘 𑀫𑀗𑁆𑀕𑀮𑁂 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀲𑁄 𑀧𑀲𑀢𑁆𑀣𑀢𑀭𑁂 𑀢𑀺𑀲𑀼.

𑀆𑀤𑀺𑀘𑁆𑀘𑀸𑀤𑀺𑀫𑁆𑀳𑀺 𑀕𑀳𑀡𑁂, 𑀦𑀺𑀩𑀦𑁆𑀥𑁂 𑀘 𑀖𑀭𑁂 𑀕𑀳𑁄;

𑀓𑀸𑀘𑁄 𑀢𑀼 𑀫𑀢𑁆𑀢𑀺𑀓𑀸𑀪𑁂𑀤𑁂, 𑀲𑀺𑀓𑁆𑀓𑀸𑀬𑀁 𑀦𑀬𑀦𑀸𑀫𑀬𑁂.

𑀢𑀻𑀲𑀼 𑀕𑀸𑀫𑀡𑀺 𑀲𑁂𑀝𑁆𑀞𑀲𑁆𑀫𑀺𑀁, 𑀅𑀥𑀺𑀧𑁂 𑀕𑀸𑀫𑀚𑁂𑀝𑁆𑀞𑀓𑁂;

𑀩𑀺𑀫𑁆𑀩𑀁 𑀢𑀼 𑀧𑀝𑀺𑀩𑀺𑀫𑁆𑀩𑁂 𑀘, 𑀫𑀡𑁆𑀟𑀮𑁂 𑀩𑀺𑀫𑁆𑀩𑀺𑀓𑀸𑀨𑀮𑁂.

𑀪𑀸𑀚𑀦𑀸𑀤𑀺 𑀧𑀭𑀺𑀓𑁆𑀔𑀸𑀭𑁂, 𑀪𑀡𑁆𑀟𑀁 𑀫𑀽𑀮𑀥𑀦𑁂𑀧𑀺 𑀘;

𑀫𑀕𑁆𑀕𑁄 𑀢𑁆𑀯𑀭𑀺𑀬𑀫𑀕𑁆𑀕𑁂 𑀘, 𑀲𑀫𑁆𑀫𑀸𑀤𑀺𑀝𑁆𑀞𑀸𑀤𑀺𑀓𑁂, 𑀧𑀣𑁂.

𑀲𑀫𑀸 ¶ 𑀯𑀲𑁆𑀲𑁂, 𑀲𑀫𑁄 𑀔𑁂𑀤, 𑀲𑀦𑁆𑀢𑀻𑀲𑀼, 𑀲𑁄 𑀦𑀺𑀪𑁂 𑀢𑀺𑀲𑀼;

𑀘𑀸𑀧𑁂𑀢𑁆𑀯𑀺𑀲𑁆𑀲𑀸𑀲, 𑀫𑀼𑀲𑀼𑀦𑁄, 𑀇𑀲𑁆𑀲𑀸𑀲𑁄 𑀔𑁂𑀧𑀓𑀫𑁆𑀳𑀺 𑀘.

𑀩𑀸𑀮𑁄 𑀢𑀻𑀲𑁆𑀯𑀸’𑀤𑀺𑀯𑀬𑀲𑀸, 𑀲𑀫𑀗𑁆𑀕𑀺𑀦𑀺 𑀅𑀧𑀡𑁆𑀟𑀺𑀢𑁂;

𑀭𑀢𑁆𑀢𑀁 𑀢𑀼 𑀲𑁄𑀡𑀺𑀢𑁂, 𑀢𑀫𑁆𑀩𑀸, 𑀦𑀼𑀭𑀢𑁆𑀢, 𑀭𑀜𑁆𑀚𑀺𑀢𑁂 𑀢𑀺𑀲𑀼.

𑀢𑀘𑁂 𑀓𑀸𑀬𑁂 𑀘 𑀢𑀦𑁆𑀯𑀺𑀢𑁆𑀣𑀻, 𑀢𑀻𑀲𑁆𑀯’𑀧𑁆𑀧𑁂 𑀯𑀺𑀭𑀴𑁂 𑀓𑀺𑀲𑁂;

𑀉𑀢𑀼𑀪𑁂𑀤𑁂 𑀢𑀼 𑀲𑀺𑀲𑀺𑀭𑁄, 𑀳𑀺𑀫𑁂 𑀲𑁄 𑀲𑀻𑀢𑀮𑁂 𑀢𑀺𑀲𑀼.

𑀲𑀓𑁆𑀔𑀭𑀸 𑀕𑀼𑀴𑀪𑁂𑀤𑁂 𑀘, 𑀓𑀣𑀮𑁂𑀧𑀺 𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀅𑀦𑀼𑀕𑁆𑀕𑀳𑁂 𑀢𑀼 𑀲𑀗𑁆𑀔𑁂𑀧𑁂, 𑀕𑀳𑀡𑁂 𑀲𑀗𑁆𑀕𑀳𑁄 𑀫𑀢𑁄.

𑀤𑀓𑁆𑀔𑁂 𑀘 𑀢𑀺𑀔𑀺𑀡𑁂 𑀩𑁆𑀬𑀢𑁆𑀢𑁂, 𑀭𑁄𑀕𑀫𑀼𑀢𑁆𑀢𑁂 𑀧𑀝𑀼𑀢𑁆𑀢𑀺𑀲𑀼;

𑀭𑀸𑀚𑀸 𑀢𑀼 𑀔𑀢𑁆𑀢𑀺𑀬𑁂 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀦𑀭𑀦𑀸𑀣𑁂 𑀧𑀪𑀼𑀫𑁆𑀳𑀺 𑀘.

𑀔𑀮𑀜𑁆𑀘 𑀥𑀜𑁆𑀜𑀓𑀭𑀡𑁂, 𑀓𑀓𑁆𑀓𑁂 𑀦𑀻𑀘𑁂 𑀔𑀮𑁄 𑀪𑀯𑁂;

𑀅𑀣𑀼’𑀧𑁆𑀧𑀸𑀤𑁂 𑀲𑀫𑀼𑀤𑀬𑁄, 𑀲𑀫𑀽𑀳𑁂 𑀧𑀘𑁆𑀘𑀬𑁂𑀧𑀺 𑀘.

𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀻 𑀕𑀳𑀝𑁆𑀞𑀸𑀤𑁄, 𑀅𑀲𑁆𑀲𑀫𑁄 𑀘 𑀢𑀧𑁄𑀯𑀦𑁂;

𑀪𑀬𑀗𑁆𑀓𑀭𑁂 𑀢𑀼 𑀓𑀞𑀺𑀦𑁂, 𑀓𑀼𑀭𑀽𑀭𑁄 𑀢𑀻𑀲𑀼 𑀦𑀺𑀤𑁆𑀤𑀬𑁂.

𑀓𑀦𑀺𑀝𑁆𑀞𑁄 𑀓𑀦𑀺𑀬𑁄 𑀢𑀻𑀲𑀼, 𑀅𑀢𑁆𑀬𑀧𑁆𑀧𑁂’𑀢𑀺𑀬𑀼𑀯𑁂 𑀧𑁆𑀬𑀣;

𑀲𑀻𑀖𑀫𑁆𑀳𑀺 𑀮𑀳𑀼 𑀢𑀁, 𑀇𑀝𑁆𑀞, 𑀦𑀺𑀲𑁆𑀲𑀸𑀭𑀸’𑀕𑀭𑀼𑀲𑀼𑀢𑁆𑀢𑀺𑀲𑀼.

𑀅𑀥𑀭𑁄 𑀢𑀻𑀲𑁆𑀯𑀥𑁄 𑀳𑀻𑀦𑁂, 𑀧𑀼𑀫𑁂 𑀤𑀦𑁆𑀢𑀘𑁆𑀙𑀤𑁂 𑀧𑁆𑀬𑀣;

𑀲𑀼𑀲𑁆𑀲𑀼𑀲𑀸 𑀲𑁄𑀢𑀼 𑀫𑀺𑀘𑁆𑀙𑀸𑀬, 𑀲𑀸 𑀧𑀸𑀭𑀺𑀘𑀭𑀺𑀬𑀸𑀬 𑀘.

𑀳𑀢𑁆𑀣𑁄 𑀧𑀸𑀡𑀺𑀫𑁆𑀳𑀺 𑀭𑀢𑀦𑁂, 𑀕𑀡𑁂 𑀲𑁄𑀡𑁆𑀟𑀸𑀬 𑀪𑀦𑁆𑀢𑀭𑁂;

𑀆𑀯𑀸𑀝𑁂 𑀉𑀤𑀧𑀸𑀦𑁂 𑀘, 𑀓𑀽𑀧𑁄 𑀓𑀼𑀫𑁆𑀪𑁂 𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑀆𑀤𑁄 𑀧𑀥𑀸𑀦𑁂 𑀧𑀞𑀫𑀁, 𑀧𑀫𑀼𑀔𑀜𑁆𑀘 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁;

𑀯𑀚𑁆𑀚𑀪𑁂𑀤𑁂 𑀘 𑀯𑀺𑀢 𑀢𑀁, 𑀢𑀁 𑀯𑀺𑀢𑁆𑀣𑀸𑀭𑁂 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁.

𑀲𑀸𑀭𑁄 𑀩𑀮𑁂 𑀣𑀺𑀭𑀁𑀲𑁂 𑀘, 𑀉𑀢𑁆𑀢𑀫𑁂 𑀲𑁄 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄;

𑀪𑀸𑀭𑁄 𑀢𑀼 𑀔𑀦𑁆𑀥𑀪𑀸𑀭𑀸𑀤𑁄, 𑀤𑁆𑀯𑀺𑀲𑀳𑀲𑁆𑀲𑀧𑀮𑁂𑀧𑀺 𑀘.

𑀫𑀦𑁆𑀤𑀺𑀭𑁂 𑀭𑁄𑀕𑀪𑁂𑀤𑁂 𑀘, 𑀔𑀬𑁄 𑀅𑀧𑀘𑀬𑀫𑁆𑀳𑀺 𑀘;

𑀯𑀸𑀴𑁄 𑀢𑀼 𑀲𑀸𑀧𑀤𑁂 𑀲𑀧𑁆𑀧𑁂, 𑀓𑀼𑀭𑀽𑀭𑁂 𑀲𑁄 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄.

𑀲𑀸𑀮𑁄 𑀲𑀚𑁆𑀚𑀤𑁆𑀤𑀼𑀫𑁂 𑀭𑀼𑀓𑁆𑀔𑁂, 𑀲𑀸𑀮𑀸𑀕𑁂𑀳𑁂 𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀲𑁄𑀢𑁂 𑀢𑀼 𑀲𑀯𑀦𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀬𑀚𑀦𑁂 𑀲𑀼𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀘.

𑀢𑀻𑀲𑀼 𑀧𑀢𑁄 𑀧𑀭𑁂𑀢𑁄 𑀘, 𑀫𑀢𑁂 𑀘 𑀧𑁂𑀢𑀬𑁄𑀦𑀺𑀚𑁂;

𑀔𑁆𑀬𑀸𑀢𑁂 𑀢𑀼 𑀳𑀝𑁆𑀞𑁂 𑀯𑀺𑀜𑁆𑀜𑀸𑀢𑁂, 𑀧𑀢𑀻𑀢𑀁 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁.

𑀅𑀥𑀺𑀧𑁆𑀧𑀸𑀬𑁂 ¶ 𑀘 𑀆𑀥𑀸𑀭𑁂, 𑀆𑀲𑀬𑁄 𑀓𑀣𑀺𑀢𑁄 𑀣 𑀘;

𑀧𑀢𑁆𑀢𑀁 𑀧𑀓𑁆𑀔𑁂 𑀤𑀮𑁂, 𑀧𑀢𑁆𑀢𑁄, 𑀪𑀸𑀚𑀦𑁂 𑀲𑁄 𑀕𑀢𑁂 𑀢𑀺𑀲𑀼.

𑀓𑀼𑀲𑀮𑁂 𑀲𑀼𑀓𑀢𑀁, 𑀲𑀼𑀝𑁆𑀞𑀼, 𑀓𑀢𑁂 𑀘 𑀲𑀼𑀓𑀢𑁄 𑀢𑀺𑀲𑀼;

𑀢𑀧𑀲𑁆𑀲𑀻 𑀢𑁆𑀯’𑀦𑀼𑀓𑀫𑁆𑀧𑀸𑀬𑀸, 𑀭𑀳𑁂 𑀯𑀼𑀢𑁆𑀢𑁄 𑀢𑀧𑁄𑀥𑀦𑁂.

𑀢𑀻𑀲𑀼 𑀲𑀼𑀭𑀸𑀤𑀺𑀮𑁄𑀮𑀲𑁆𑀫𑀺𑀁, 𑀲𑁄𑀡𑁆𑀟𑁄 𑀳𑀢𑁆𑀣𑀺𑀓𑀭𑁂 𑀤𑁆𑀯𑀺𑀲𑀼;

𑀅𑀲𑁆𑀲𑀸𑀤𑀦𑁂 𑀢𑀼 𑀭𑀲𑀦𑀁, 𑀚𑀺𑀯𑁆𑀳𑀸𑀬𑀜𑁆𑀘 𑀥𑀦𑀺𑀫𑁆𑀳𑀺 𑀘.

𑀧𑀡𑀻𑀢𑁄 𑀢𑀻𑀲𑀼 𑀫𑀥𑀼𑀭𑁂, 𑀉𑀢𑁆𑀢𑀫𑁂 𑀯𑀺𑀳𑀺𑀢𑁂 𑀧𑁆𑀬𑀣;

𑀅𑀜𑁆𑀚𑀲𑁂 𑀯𑀺𑀲𑀺𑀔𑀸𑀬𑀜𑁆𑀘, 𑀧𑀦𑁆𑀢𑀺𑀬𑀁 𑀯𑀻𑀣𑀺 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀧𑀸𑀧𑀲𑁆𑀫𑀺𑀁 𑀕𑀕𑀦𑁂 𑀤𑀼𑀓𑁆𑀔𑁂, 𑀩𑁆𑀬𑀲𑀦𑁂 𑀘𑀸’𑀖 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀲𑀫𑀽𑀳𑁂 𑀧𑀝𑀮𑀁 𑀦𑁂𑀢𑁆𑀢, 𑀭𑁄𑀕𑁂 𑀯𑀼𑀢𑁆𑀢𑀁 𑀙𑀤𑀺𑀫𑁆𑀳𑀺 𑀘.

𑀲𑀦𑁆𑀥𑀺 𑀲𑀗𑁆𑀖𑀝𑁆𑀝𑀦𑁂 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀲𑀦𑁆𑀥𑀺’𑀢𑁆𑀣𑀺 𑀧𑀝𑀺𑀲𑀦𑁆𑀥𑀺𑀬𑀁;

𑀲𑀢𑁆𑀢𑀦𑁆𑀦𑀁 𑀧𑀽𑀭𑀡𑁂 𑀲𑁂𑀝𑁆𑀞𑁂, 𑀢𑀺𑀲𑀦𑁆𑀢𑁂 𑀲𑀢𑁆𑀢𑀫𑁄 𑀢𑀺𑀲𑀼.

𑀑𑀚𑀸 𑀢𑀼 𑀬𑀸𑀧𑀦𑀸𑀬𑀜𑁆𑀘, 𑀑𑀚𑁄 𑀤𑀺𑀢𑁆𑀢𑀺 𑀩𑀮𑁂𑀲𑀼 𑀘;

𑀅𑀣𑁄 𑀦𑀺𑀲𑀸𑀫𑀦𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀤𑀲𑁆𑀲𑀦𑁂 𑀲𑀯𑀦𑁂𑀧𑀺 𑀘.

𑀕𑀩𑁆𑀪𑁄 𑀓𑀼𑀘𑁆𑀙𑀺𑀝𑁆𑀞𑀲𑀢𑁆𑀢𑁂 𑀘, 𑀓𑀼𑀘𑁆𑀙𑀺 𑀑𑀯𑀭𑀓𑁂𑀲𑀼 𑀘;

𑀔𑀡𑁆𑀟𑀦𑁂 𑀢𑁆𑀯’𑀧𑀤𑀸𑀦𑀜𑁆𑀘, 𑀇𑀢𑀺𑀯𑀼𑀢𑁆𑀢𑁂 𑀘 𑀓𑀫𑁆𑀫𑀦𑀺.

𑀘𑀺𑀢𑁆𑀢𑀓𑁂 𑀭𑀼𑀓𑁆𑀔𑀪𑁂𑀤𑁂 𑀘, 𑀢𑀺𑀮𑀓𑁄 𑀢𑀺𑀮𑀓𑀸𑀴𑀓𑁂;

𑀲𑀻𑀮𑀸𑀤𑁄 𑀧𑀝𑀺𑀧𑀢𑁆𑀢𑀺’𑀢𑁆𑀣𑀻, 𑀩𑁄𑀥𑁂 𑀧𑀢𑁆𑀢𑀺 𑀧𑀯𑀢𑁆𑀢𑀺𑀲𑀼.

𑀅𑀲𑀼𑀫𑁆𑀳𑀺 [𑀆𑀬𑀼𑀫𑁆𑀳𑀺 (𑀝𑀻.), 𑁪𑁦𑁭-𑀕𑀸𑀣𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸] 𑀘 𑀩𑀮𑁂 𑀧𑀸𑀡𑁄, 𑀲𑀢𑁆𑀢𑁂 𑀳𑀤𑀬𑀕𑀸’𑀦𑀺𑀮𑁂;

𑀙𑀦𑁆𑀤𑁄 𑀯𑀲𑁂 𑀅𑀥𑀺𑀧𑁆𑀧𑀸𑀬𑁂, 𑀯𑁂𑀤𑁂’𑀘𑁆𑀙𑀸’𑀦𑀼𑀝𑁆𑀞𑀼𑀪𑀸𑀤𑀺𑀲𑀼.

𑀓𑀸𑀫𑁄𑀖𑀸𑀤𑁄, 𑀲𑀫𑀽𑀳𑀲𑁆𑀫𑀺𑀁, 𑀑𑀖𑁄𑀯𑁂𑀕𑁂 𑀚𑀮𑀲𑁆𑀲 𑀘;

𑀓𑀧𑀸𑀮𑀁 𑀲𑀺𑀭𑀲𑀝𑁆𑀞𑀺𑀫𑁆𑀳𑀺, 𑀖𑀝𑀸𑀤𑀺 𑀲𑀓𑀮𑁂𑀧𑀺 𑀘.

𑀯𑁂𑀡𑁆𑀯𑀸𑀤𑀺𑀲𑀸𑀔𑀸𑀚𑀸𑀮𑀲𑁆𑀫𑀺𑀁, 𑀮𑀕𑁆𑀕𑀓𑁂𑀲𑁂 𑀚𑀝𑀸’𑀮𑀬𑁂;

𑀲𑀭𑀡𑀁 𑀢𑀼 𑀯𑀥𑁂 𑀕𑁂𑀳𑁂, 𑀭𑀓𑁆𑀔𑀺𑀢𑀲𑁆𑀫𑀺𑀜𑁆𑀘 𑀭𑀓𑁆𑀔𑀡𑁂.

𑀣𑀺𑀬𑀁 𑀓𑀦𑁆𑀢𑀸 𑀧𑀺𑀬𑁂, 𑀓𑀦𑁆𑀢𑁄, 𑀫𑀦𑀼𑀜𑁆𑀜𑁂, 𑀲𑁄 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄;

𑀕𑀯𑀓𑁆𑀔𑁂 𑀢𑀼 𑀲𑀫𑀽𑀳𑁂 𑀘, 𑀚𑀸𑀮𑀁 𑀫𑀘𑁆𑀙𑀸𑀤𑀺𑀩𑀦𑁆𑀥𑀦𑁂.

𑀧𑀼𑀘𑁆𑀙𑀸𑀬𑀁 𑀕𑀭𑀳𑀸𑀬𑀜𑁆𑀘𑀸, 𑀦𑀺𑀬𑀫𑁂 𑀓𑀺𑀁 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁;

𑀲𑀲𑀤𑁆𑀥𑁂 𑀢𑀻𑀲𑀼 𑀦𑀺𑀯𑀸𑀧𑁂, 𑀲𑀤𑁆𑀥𑀁, 𑀲𑀤𑁆𑀥𑀸 𑀘 𑀧𑀘𑁆𑀘𑀬𑁂.

𑀩𑀻𑀚𑀁 ¶ 𑀳𑁂𑀢𑀼𑀫𑁆𑀳𑀺 𑀅𑀝𑁆𑀞𑀺𑀲𑁆𑀫𑀺𑀁, 𑀅𑀗𑁆𑀕𑀚𑀸𑀢𑁂 𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀧𑀼𑀩𑁆𑀩𑁄 𑀧𑀽𑀬𑁂’𑀕𑁆𑀕𑀢𑁄 [𑀅𑀕𑁆𑀕𑀢𑁂 (𑀝𑀻.)] 𑀆𑀤𑁄,

𑀨𑀮𑀘𑀺𑀢𑁆𑀢𑁂 𑀳𑁂𑀢𑀼𑀓𑀢𑁂, 𑀮𑀸𑀪𑁂 𑀥𑀜𑁆𑀜𑀸𑀤𑀺𑀓𑁂 𑀨𑀮𑀁;

𑀆𑀕𑀫𑀦𑁂 𑀢𑀼 𑀤𑀻𑀖𑀸𑀤𑀺, 𑀦𑀺𑀓𑀸𑀬𑁂𑀲𑀼 𑀘 𑀆𑀕𑀫𑁄.

𑀲𑀦𑁆𑀢𑀸𑀦𑁄 𑀤𑁂𑀯𑀭𑀼𑀓𑁆𑀔𑁂 𑀘, 𑀯𑀼𑀢𑁆𑀢𑁄 𑀲𑀦𑁆𑀢𑀢𑀺𑀬𑀁 𑀧𑁆𑀬𑀣;

𑀉𑀢𑁆𑀢𑀭𑀯𑀺𑀧𑀭𑀻𑀢𑁂 𑀘, 𑀲𑁂𑀝𑁆𑀞𑁂 𑀘𑀸’𑀦𑀼𑀢𑁆𑀢𑀭𑀁 𑀢𑀺𑀲𑀼.

𑀲𑀢𑁆𑀢𑀺𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀺𑀬𑀁 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀓𑀦𑁆𑀢𑀺𑀫𑀢𑁆𑀢𑁂 𑀘 𑀯𑀺𑀓𑁆𑀓𑀫𑁄;

𑀙𑀸𑀬𑀸 𑀢𑀼 𑀆𑀢𑀧𑀸𑀪𑀸𑀯𑁂, 𑀧𑀝𑀺𑀩𑀺𑀫𑁆𑀩𑁂 𑀧𑀪𑀸𑀬 𑀘.

𑀕𑀺𑀫𑁆𑀳𑁂 𑀖𑀫𑁆𑀫𑁄 𑀦𑀺𑀤𑀸𑀖𑁄 𑀘, 𑀉𑀡𑁆𑀳𑁂 𑀲𑁂𑀤𑀚𑀮𑁂 𑀧𑁆𑀬𑀣;

𑀓𑀧𑁆𑀧𑀦𑀁 𑀓𑀦𑁆𑀢𑀦𑁂 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀯𑀺𑀓𑀧𑁆𑀧𑁂 𑀲𑀚𑁆𑀚𑀦𑁂’𑀢𑁆𑀣𑀺𑀬𑀁.

𑀅𑀗𑁆𑀕𑀸 𑀤𑁂𑀲𑁂 𑀩𑀳𑀼𑀫𑁆𑀳’𑀗𑁆𑀕𑀁, 𑀅𑀗𑁆𑀕𑁄 𑀤𑁂𑀲𑁂 𑀯𑀧𑀼𑀫𑁆𑀳’[𑀗𑁆𑀕 (𑀝𑀻.)] 𑀢𑀣𑀸’𑀯𑀬𑀯𑀳𑁂𑀢𑀼𑀲𑀼;

𑀤𑁂𑀯𑀸𑀮𑀬𑁂 𑀘 𑀣𑀽𑀧𑀲𑁆𑀫𑀺𑀁, 𑀘𑁂𑀢𑀺𑀬𑀁 𑀘𑁂𑀢𑀺𑀬’𑀤𑁆𑀤𑀼𑀫𑁂.

𑀲𑀚𑁆𑀚𑀦𑁄 𑀲𑀸𑀥𑀼𑀧𑀼𑀭𑀺𑀲𑁂, 𑀲𑀚𑁆𑀚𑀦𑀁 𑀓𑀧𑁆𑀧𑀦𑁂 𑀧𑁆𑀬𑀣;

𑀲𑀼𑀧𑀺𑀦𑀁 𑀲𑀼𑀧𑀺𑀦𑁂 𑀲𑀼𑀢𑁆𑀢, 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑁂 𑀢 𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀧𑀘𑁆𑀘𑀓𑁆𑀔𑁂 𑀲𑀦𑁆𑀦𑀺𑀥𑀸𑀦𑁂 𑀘, 𑀲𑀦𑁆𑀦𑀺𑀥𑀺 𑀧𑀭𑀺𑀓𑀺𑀢𑁆𑀢𑀺𑀢𑁄;

𑀪𑀺𑀬𑁆𑀬𑁄 𑀩𑀳𑀼𑀢𑀭𑀢𑁆𑀣𑁂 𑀲𑁄, 𑀧𑀼𑀦𑀭𑀢𑁆𑀣𑁂’𑀩𑁆𑀬𑀬𑀁 𑀪𑀯𑁂.

𑀯𑀺𑀲𑀮𑀺𑀢𑁆𑀢𑀲𑀭𑁂 𑀤𑀺𑀤𑁆𑀥𑁄, 𑀤𑀺𑀤𑁆𑀥𑁄 𑀮𑀺𑀢𑁆𑀢𑁂 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄;

𑀯𑀸𑀲𑁂 𑀥𑀽𑀫𑀸𑀤𑀺𑀲𑀗𑁆𑀔𑀸𑀭𑁂, 𑀥𑀺𑀯𑀸𑀲𑁄 𑀲𑀫𑁆𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁂.

𑀯𑀼𑀢𑁆𑀢𑁄 𑀯𑀺𑀲𑀸𑀭𑀤𑁄 𑀢𑀻𑀲𑀼, 𑀲𑀼𑀧𑁆𑀧𑀕𑀩𑁆𑀪𑁂 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑁂;

𑀅𑀣 𑀲𑀺𑀢𑁆𑀣𑀁 𑀫𑀥𑀼𑀘𑁆𑀙𑀺𑀝𑁆𑀞𑁂, 𑀯𑀼𑀢𑁆𑀢𑀁 𑀑𑀤𑀦𑀲𑀫𑁆𑀪𑀯𑁂.

𑀤𑁆𑀭𑀯𑁂 𑀯𑀡𑁆𑀡𑁂 𑀭𑀲𑀪𑁂𑀤𑁂, 𑀓𑀲𑀸𑀬𑁄 𑀲𑀼𑀭𑀪𑀺𑀫𑁆𑀳𑀺 𑀘;

𑀅𑀣𑁄 𑀉𑀕𑁆𑀕𑀫𑀦𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀉𑀧𑁆𑀧𑀢𑁆𑀢𑀼’𑀤𑁆𑀥𑀕𑀢𑀻𑀲𑀼 𑀘.

𑀮𑀽𑀔𑁂 𑀦𑀺𑀝𑁆𑀞𑀼𑀭𑀯𑀸𑀘𑀸𑀬𑀁, 𑀨𑀭𑀼𑀲𑀁 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁;

𑀧𑀯𑀸𑀳𑁄 𑀢𑁆𑀯’𑀫𑁆𑀩𑀼𑀯𑁂𑀕𑁂 𑀘, 𑀲𑀦𑁆𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀧𑀯𑀢𑁆𑀢𑀺𑀬𑀁.

𑀦𑀺𑀲𑁆𑀲𑀬𑁂 𑀢𑀧𑁆𑀧𑀭𑁂 𑀇𑀝𑁆𑀞𑁂, 𑀧𑀭𑀸𑀬𑀡𑀧𑀤𑀁 𑀢𑀺𑀲𑀼;

𑀓𑀯𑀘𑁂 𑀯𑀸𑀭𑀯𑀸𑀡𑁂 𑀘, 𑀦𑀺𑀫𑁆𑀫𑁄𑀓𑁂𑀧𑀺 𑀘 𑀓𑀜𑁆𑀘𑀼𑀓𑁄.

𑀮𑁄𑀳𑀪𑁂𑀤𑁂 ¶ 𑀫𑀢𑀁 𑀢𑀫𑁆𑀩𑀁, 𑀢𑀫𑁆𑀩𑁄 𑀭𑀢𑁆𑀢𑁂 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄;

𑀢𑀻𑀲𑀼 𑀢𑁆𑀯’𑀯𑀲𑀺𑀢𑀁 𑀜𑀸𑀢𑁂, 𑀅𑀯𑀲𑀸𑀦𑀕𑀢𑁂 𑀫𑀢𑀁.

𑀩𑁄𑀥𑀦𑁂 𑀘 𑀧𑀤𑀸𑀦𑁂 𑀘, 𑀯𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑀁 𑀧𑀝𑀺𑀧𑀸𑀤𑀦𑀁;

𑀲𑁂𑀮𑁂 𑀦𑀺𑀚𑁆𑀚𑀮𑀤𑁂𑀲𑁂 𑀘, 𑀤𑁂𑀯𑀢𑀸𑀲𑀼 𑀫𑀭𑀽’𑀭𑀺𑀢𑁄.

𑀲𑀢𑁆𑀣𑀁 𑀆𑀬𑀼𑀥 𑀕𑀦𑁆𑀣𑁂𑀲𑀼, 𑀮𑁄𑀳𑁂, 𑀲𑀢𑁆𑀣𑁄 𑀘 𑀲𑀜𑁆𑀘𑀬𑁂;

𑀚𑀻𑀯𑀺𑀓𑀸𑀬𑀁 𑀯𑀺𑀯𑀭𑀡𑁂, 𑀯𑀢𑁆𑀢𑀦𑁂 𑀯𑀼𑀢𑁆𑀢𑀺 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀯𑀻𑀭𑀺𑀬𑁂 𑀲𑀽𑀭𑀪𑀸𑀯𑁂 𑀘, 𑀓𑀣𑀻𑀬𑀢𑀺 𑀧𑀭𑀓𑁆𑀓𑀫𑁄;

𑀅𑀣 𑀓𑀫𑁆𑀩𑀼 𑀫𑀢𑁄 𑀲𑀗𑁆𑀔𑁂, 𑀲𑀼𑀯𑀡𑁆𑀡𑁂 𑀯𑀮𑀬𑁂𑀧𑀺 𑀘.

𑀲𑀭𑁄 𑀓𑀡𑁆𑀟𑁂 𑀅𑀓𑀸𑀭𑀸𑀤𑁄, 𑀲𑀤𑁆𑀤𑁂 𑀯𑀸𑀧𑀺𑀫𑁆𑀳𑀺’𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁;

𑀤𑀼𑀧𑁆𑀨𑀲𑁆𑀲𑁂 𑀢𑀺𑀔𑀺𑀡𑁂 𑀢𑀻𑀲𑀼, 𑀕𑀤𑁆𑀭𑀪𑁂 𑀓𑀓𑀘𑁂 𑀔𑀭𑁄.

𑀲𑀼𑀭𑀸𑀬𑀼’𑀧𑀤𑁆𑀤𑀯𑁂 𑀓𑀸𑀫𑀸, 𑀲𑀯𑀸𑀤𑀺𑀫𑁆𑀳𑀺 𑀘 𑀆𑀲𑀯𑁄;

𑀤𑁂𑀳𑁂 𑀯𑀼𑀢𑁆𑀢𑁄 𑀭𑀣𑀗𑁆𑀕𑁂 𑀘, 𑀘𑀢𑀼𑀭𑁄’𑀧𑀥𑀺𑀲𑀽’𑀧𑀥𑀺.

𑀯𑀢𑁆𑀣𑀼’𑀢𑁆𑀢𑀁 𑀓𑀸𑀭𑀡𑁂 𑀤𑀩𑁆𑀩𑁂, 𑀪𑀽𑀪𑁂𑀤𑁂 𑀭𑀢𑀦𑀢𑁆𑀢𑀬𑁂;

𑀬𑀓𑁆𑀔𑁄 𑀤𑁂𑀯𑁂 𑀫𑀳𑀸𑀭𑀸𑀚𑁂, 𑀓𑀼𑀯𑁂𑀭𑀸’𑀦𑀼𑀘𑀭𑁂 𑀦𑀭𑁂.

𑀤𑀸𑀭𑀼𑀓𑁆𑀔𑀦𑁆𑀥𑁂 𑀧𑀻𑀞𑀺𑀓𑀸𑀬𑀁, 𑀆𑀧𑀡𑁂 𑀧𑀻𑀞 𑀫𑀸𑀲𑀦𑁂;

𑀧𑀭𑀺𑀯𑀸𑀭𑁂 𑀧𑀭𑀺𑀓𑁆𑀔𑀸𑀭𑁄, 𑀲𑀫𑁆𑀪𑀸𑀭𑁂 𑀘 𑀯𑀺𑀪𑀽𑀲𑀦𑁂.

𑀯𑁄𑀳𑀸𑀭𑀲𑁆𑀫𑀺𑀜𑁆𑀘 𑀞𑀧𑀦𑁂, 𑀧𑀜𑁆𑀜𑀢𑁆𑀢𑀺’𑀢𑁆𑀣𑀻 𑀧𑀓𑀸𑀲𑀦𑁂;

𑀧𑀝𑀺𑀪𑀸𑀦𑀁 𑀢𑀼 𑀧𑀜𑁆𑀜𑀸𑀬𑀁, 𑀉𑀧𑀝𑁆𑀞𑀺𑀢 𑀕𑀺𑀭𑀸𑀬 𑀘.

𑀯𑀘𑀦𑀸𑀯𑀬𑀯𑁂 𑀫𑀽𑀮𑁂, 𑀓𑀣𑀺𑀢𑁄 𑀳𑁂𑀢𑀼 𑀓𑀸𑀭𑀡𑁂;

𑀉𑀤𑀭𑁂 𑀢𑀼 𑀢𑀣𑀸 𑀧𑀸𑀘𑀸, 𑀦𑀮𑀲𑁆𑀫𑀺𑀁 𑀕𑀳𑀡𑀻’𑀢𑁆𑀣𑀺𑀬𑀁.

𑀧𑀺𑀬𑁄 𑀪𑀢𑁆𑀢𑀭𑀺, 𑀚𑀸𑀬𑀸𑀬𑀁, 𑀧𑀺𑀬𑀸, 𑀇𑀝𑁆𑀞𑁂 𑀧𑀺𑀬𑁄 𑀢𑀺𑀲𑀼;

𑀬𑀫𑀭𑀸𑀚𑁂 𑀢𑀼 𑀬𑀼𑀕𑀴𑁂, 𑀲𑀁𑀬𑀫𑁂 𑀘 𑀬𑀫𑁄 𑀪𑀯𑁂.

𑀫𑀼𑀤𑁆𑀤𑀺𑀓𑀲𑁆𑀲 𑀘 𑀧𑀼𑀧𑁆𑀨𑀲𑁆𑀲, 𑀭𑀲𑁂 𑀔𑀼𑀤𑁆𑀤𑁂 𑀫𑀥𑀽’𑀭𑀺𑀢𑀁;

𑀉𑀮𑁆𑀮𑁄𑀘𑁂 𑀢𑀼 𑀘 𑀯𑀺𑀢𑁆𑀣𑀸𑀭𑁂, 𑀯𑀺𑀢𑀸𑀦𑀁 𑀧𑀼𑀦𑁆𑀦𑀧𑀼𑀁𑀲𑀓𑁂.

𑀅𑀧𑀯𑀕𑁆𑀕𑁂 𑀘 𑀲𑀮𑀺𑀮𑁂, 𑀲𑀼𑀥𑀸𑀬𑀁 𑀅𑀫𑀢𑀁 𑀫𑀢𑀁;

𑀫𑁄𑀳𑁂 𑀢𑀼 𑀢𑀺𑀫𑀺𑀭𑁂 𑀲𑀗𑁆𑀔𑁆𑀬𑀸, 𑀕𑀼𑀡𑁂 𑀢𑀫 𑀫𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁.

𑀔𑀭𑁂 𑀘𑀸’𑀓𑀸𑀭𑀺𑀬𑁂 𑀢𑀻𑀲𑀼, 𑀭𑀲𑀫𑁆𑀳𑀺 𑀧𑀼𑀭𑀺𑀲𑁂 𑀓𑀝𑀼;

𑀧𑀡𑁆𑀟𑀓𑁂 𑀲𑀼𑀓𑀢𑁂, 𑀧𑀼𑀜𑁆𑀜𑀁, 𑀫𑀦𑀼𑀜𑁆𑀜𑁂 𑀧𑀯𑀦𑁂 𑀢𑀺𑀲𑀼.

𑀭𑀼𑀓𑁆𑀔𑁄 𑀤𑀼𑀫𑀫𑁆𑀳𑀺, 𑀨𑀭𑀼𑀲𑀸, 𑀲𑀺𑀦𑀺𑀤𑁆𑀥𑁂𑀲𑀼 𑀘 𑀲𑁄 𑀢𑀺𑀲𑀼;

𑀉𑀧𑁆𑀧𑀢𑁆𑀢𑀺𑀬𑀁 𑀢𑀼 𑀳𑁂𑀢𑀼𑀫𑁆𑀳𑀺, 𑀲𑀗𑁆𑀕𑁂 𑀲𑀼𑀓𑁆𑀓𑁂 𑀘 𑀲𑀫𑁆𑀪𑀯𑁄.

𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑀁 ¶ 𑀓𑀸𑀭𑀡𑁂 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀅𑀗𑁆𑀕𑀚𑀸𑀢𑁂 𑀘 𑀮𑀜𑁆𑀙𑀦𑁂;

𑀆𑀤𑀺 𑀲𑀻𑀫𑀸𑀧𑀓𑀸𑀭𑁂𑀲𑀼, 𑀲𑀫𑀻𑀧𑁂’𑀯𑀬𑀯𑁂 𑀫𑀢𑁄.

𑀯𑁂𑀤𑁂 𑀘 𑀫𑀦𑁆𑀢𑀦𑁂 𑀫𑀦𑁆𑀢𑁄, 𑀫𑀦𑁆𑀢𑀸 𑀧𑀜𑁆𑀜𑀸𑀬 𑀫𑀼𑀘𑁆𑀘𑀢𑁂;

𑀅𑀦𑀬𑁄 𑀩𑁆𑀬𑀲𑀦𑁂 𑀘𑁂𑀯, 𑀲𑀦𑁆𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀯𑀺𑀧𑀢𑁆𑀢𑀺𑀬𑀁.

𑀅𑀭𑀼𑀡𑁄 𑀭𑀁𑀲𑀺𑀪𑁂𑀤𑁂 𑀘𑀸, 𑀩𑁆𑀬𑀢𑁆𑀢𑀭𑀸𑀕𑁂 𑀘 𑀮𑁄𑀳𑀺𑀢𑁂;

𑀅𑀦𑀼𑀩𑀦𑁆𑀥𑁄 𑀢𑀼 𑀧𑀓𑀢𑀸, 𑀦𑀺𑀯𑀢𑁆𑀢𑁂 𑀦𑀲𑁆𑀲𑀦𑀓𑁆𑀔𑀭𑁂.

𑀅𑀯𑀢𑀸𑀭𑁄’𑀯𑀢𑀭𑀡𑁂, 𑀢𑀺𑀢𑁆𑀣𑀫𑁆𑀳𑀺 𑀯𑀺𑀯𑀭𑁂 𑀧𑁆𑀬𑀣;

𑀆𑀓𑀸𑀭𑁄 𑀓𑀸𑀭𑀡𑁂 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀲𑀡𑁆𑀞𑀸𑀦𑁂 𑀇𑀗𑁆𑀕𑀺𑀢𑁂𑀧𑀺 𑀘.

𑀲𑀼𑀤𑁆𑀤𑀺𑀢𑁆𑀣𑀺 𑀢𑀦𑀬𑁂 𑀔𑀢𑁆𑀢𑀸, 𑀉𑀕𑁆𑀕𑁄, 𑀢𑀺𑀩𑁆𑀩𑀫𑁆𑀳𑀺 𑀲𑁄 𑀢𑀺𑀲𑀼;

𑀧𑀥𑀸𑀦𑀁 𑀢𑀼 𑀫𑀳𑀸𑀫𑀢𑁆𑀢𑁂, 𑀧𑀓𑀢𑁆𑀬’𑀕𑁆𑀕’𑀥𑀺𑀢𑀻𑀲𑀼 𑀘.

𑀓𑀮𑁆𑀮𑀁 𑀧𑀪𑀸𑀢𑁂, 𑀦𑀺𑀭𑁄𑀕, 𑀲𑀚𑁆𑀚𑀤𑀓𑁆𑀔𑁂𑀲𑀼 [𑀬𑀼𑀢𑁆𑀢𑀤𑀓𑁆𑀔𑁂𑀲𑀼 (𑀓.)] 𑀢𑀻𑀲𑀼 𑀢𑀁;

𑀓𑀼𑀳𑀦𑀸 𑀓𑀽𑀝𑀘𑀭𑀺𑀬𑀸𑀬𑀁, 𑀓𑀼𑀳𑀦𑁄 𑀓𑀼𑀳𑀓𑁂 𑀢𑀺𑀲𑀼.

𑀓𑀧𑁄𑀢𑁄 𑀧𑀓𑁆𑀔𑀺𑀪𑁂𑀤𑁂 𑀘, 𑀤𑀺𑀝𑁆𑀞𑁄 𑀧𑀸𑀭𑀸𑀯𑀢𑁂 𑀣 𑀘;

𑀲𑀸𑀭𑀤𑁄 𑀲𑀸𑀭𑀤𑀩𑁆𑀪𑀽𑀢𑁂, 𑀅𑀧𑀕𑀩𑁆𑀪𑁂 𑀫𑀢𑁄 𑀢𑀺𑀲𑀼.

𑀢𑀻𑀲𑀼 𑀔𑀭𑁂 𑀘 𑀓𑀞𑀺𑀦𑁂, 𑀓𑀓𑁆𑀓𑀲𑁄 𑀲𑀸𑀳𑀲𑀧𑁆𑀧𑀺𑀬𑁂 [𑀲𑀸𑀳𑀲𑀧𑁆𑀧𑀺𑀬𑁂=𑀲𑀸𑀳𑀲+𑀅𑀧𑁆𑀧𑀺𑀬𑁂 (𑀝𑀻.)];

𑀅𑀓𑀸𑀭𑀺𑀬𑁂 𑀢𑀼 𑀕𑀼𑀬𑁆𑀳𑀗𑁆𑀕𑁂, 𑀘𑀻𑀭𑁂 𑀓𑁄𑀧𑀻𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀫𑀺𑀕𑀪𑁂𑀤𑁂 𑀧𑀝𑀸𑀓𑀸𑀬𑀁, 𑀫𑁄𑀘𑁂 𑀘 𑀓𑀤𑀮𑀻’𑀢𑁆𑀣𑀺𑀬𑀁;

𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀤𑀸𑀦𑀪𑁂𑀤𑀲𑁆𑀫𑀺𑀁, 𑀯𑀸𑀫𑀢𑁄’𑀜𑁆𑀜𑀫𑁆𑀳𑀺 𑀤𑀓𑁆𑀔𑀺𑀡𑁄.

𑀤𑀼𑀢𑀺𑀬𑀸 𑀪𑀭𑀺𑀬𑀸𑀬𑀜𑁆𑀘, 𑀤𑁆𑀯𑀺𑀦𑁆𑀦𑀁 𑀧𑀽𑀭𑀡𑀺𑀬𑀁 𑀫𑀢𑀸;

𑀅𑀣𑀼𑀧𑁆𑀧𑀸𑀤𑁂 𑀲𑀺𑀬𑀸 𑀥𑀽𑀫, 𑀓𑁂𑀢𑀼 𑀯𑁂𑀲𑁆𑀲𑀸𑀦𑀭𑁂𑀧𑀺 𑀘.

𑀪𑀯𑀦𑀺𑀕𑁆𑀕𑀫𑀦𑁂 𑀬𑀸𑀦𑁂, 𑀤𑁆𑀯𑀸𑀭𑁂 𑀦𑀺𑀲𑁆𑀲𑀭𑀡𑀁 𑀲𑀺𑀬𑀸;

𑀦𑀺𑀬𑀸𑀫𑀓𑁄 𑀧𑁄𑀢𑀯𑀸𑀳𑁂, 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑁄 𑀲𑁄 𑀦𑀺𑀬𑀦𑁆𑀢𑀭𑀺.

𑀅𑀧𑀯𑀕𑁆𑀕𑁂 𑀯𑀺𑀦𑀸𑀲𑁂 𑀘, 𑀦𑀺𑀭𑁄𑀥𑁄 𑀭𑁄𑀥𑀦𑁂 𑀧𑁆𑀬𑀣;

𑀪𑀬𑁂 𑀧𑀝𑀺𑀪𑀬𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀁 𑀢𑀁 𑀪𑀬𑀁𑀓𑀭𑁂.

𑀧𑀺𑀝𑀓𑀁 𑀪𑀸𑀚𑀦𑁂 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀢𑀣𑁂𑀯 𑀧𑀭𑀺𑀬𑀢𑁆𑀢𑀺𑀬𑀁;

𑀚𑀭𑀸𑀲𑀺𑀣𑀺𑀮𑀘𑀫𑁆𑀫𑀲𑁆𑀫𑀺𑀁, 𑀉𑀤𑀭𑀗𑁆𑀕𑁂 𑀫𑀢𑀸 𑀯𑀮𑀺.

𑀪𑀺𑀦𑁆𑀦𑀁 𑀯𑀺𑀤𑀸𑀭𑀺𑀢𑁂’𑀜𑁆𑀜𑀲𑁆𑀫𑀺𑀁, 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁂 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑀁;

𑀉𑀧𑀚𑀸𑀧𑁂 𑀫𑀢𑁄 𑀪𑁂𑀤𑁄, 𑀯𑀺𑀲𑁂𑀲𑁂 𑀘 𑀯𑀺𑀤𑀸𑀭𑀡𑁂.

𑀫𑀡𑁆𑀟𑀮𑀁 ¶ 𑀕𑀸𑀫𑀲𑀦𑁆𑀤𑁄𑀳𑁂, 𑀩𑀺𑀫𑁆𑀩𑁂 𑀧𑀭𑀺𑀥𑀺𑀭𑀸𑀲𑀺𑀲𑀼;

𑀆𑀡𑀸𑀬 𑀫𑀸𑀕𑀫𑁂 𑀮𑁂𑀔𑁂; 𑀲𑀸𑀲𑀦𑀁 𑀅𑀦𑀼𑀲𑀸𑀲𑀦𑁂.

𑀅𑀕𑁆𑀕𑁂 𑀢𑀼 𑀲𑀺𑀔𑀭𑀁 𑀘𑀸’𑀬𑁄, 𑀫𑀬𑀯𑀺𑀚𑁆𑀛𑀦𑀓𑀡𑁆𑀝𑀓𑁂;

𑀕𑀼𑀡𑀼𑀓𑁆𑀓𑀁𑀲𑁂 𑀘 𑀯𑀺𑀪𑀯𑁂, 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀺 𑀘𑁂𑀯 𑀲𑀫𑁆𑀧𑀤𑀸.

𑀪𑀽𑀔𑀦𑁆𑀢𑀻𑀲𑀼 𑀔𑀫𑀸, 𑀬𑁄𑀕𑁆𑀬𑁂, 𑀳𑀺𑀢𑁂 𑀲𑀓𑁆𑀓𑁂 [𑀬𑀼𑀢𑁆𑀢𑁂 (𑀝𑀻.) 𑁧𑁦𑁦𑁧-𑀕𑀸𑀣𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸] 𑀔𑀫𑁄 𑀢𑀺𑀲𑀼;

𑀅𑀤𑁆𑀥𑁄 𑀪𑀸𑀕𑁂 𑀧𑀣𑁂 𑀓𑀸𑀮𑁂, 𑀏𑀓𑀁𑀲𑁂’𑀤𑁆𑀥𑁄’𑀩𑁆𑀬𑀬𑀁 𑀪𑀯𑁂;

𑀅𑀣𑁄 𑀓𑀭𑀻𑀲𑀁 𑀯𑀘𑁆𑀘𑀲𑁆𑀫𑀺𑀁, 𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀘𑀢𑀼𑀭𑀫𑁆𑀩𑀡𑁂.

𑀉𑀲𑀪𑁄’𑀲𑀥 𑀕𑁄 [𑀉𑀲𑀪𑁄 𑀉𑀲𑀪𑁂 (𑀝𑀻.)] 𑀲𑁂𑀝𑁆𑀞𑁂, 𑀲𑀽’𑀲𑀪𑀁 𑀯𑀻𑀲𑀬𑀝𑁆𑀞𑀺𑀬𑀁;

𑀲𑁂𑀢𑀼𑀲𑁆𑀫𑀺𑀁 𑀢𑀦𑁆𑀢𑀺 𑀧𑀦𑁆𑀢𑀻𑀲𑀼, 𑀦𑀸𑀭𑀺𑀬𑀁 𑀧𑀸𑀴𑀺 𑀓𑀣𑁆𑀬𑀢𑁂.

𑀓𑀝𑁄 𑀚𑀬𑁂’𑀢𑁆𑀣𑀺𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑁂, 𑀓𑀺𑀮𑀜𑁆𑀚𑁂 𑀲𑁄 𑀓𑀢𑁂 𑀢𑀺𑀲𑀼;

𑀫𑀳𑀺𑀬𑀁 𑀚𑀕𑀢𑀻 𑀯𑀼𑀢𑁆𑀢𑀸, 𑀫𑀦𑁆𑀤𑀺𑀭𑀸𑀮𑀺𑀦𑁆𑀤𑀯𑀢𑁆𑀣𑀼𑀫𑁆𑀳𑀺.

𑀯𑀺𑀢𑀓𑁆𑀓𑁂 𑀫𑀣𑀺𑀢𑁂 𑀢𑀓𑁆𑀓𑁄, 𑀢𑀣𑀸 𑀲𑀽𑀘𑀺𑀨𑀮𑁂 𑀫𑀢𑁄;

𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑀁 𑀲𑀓𑁆𑀓𑀧𑀼𑀭𑁂, 𑀢𑀻𑀲𑀼 𑀢𑀁 𑀤𑀼𑀤𑁆𑀤𑀲𑁂’𑀢𑀭𑁂.

𑀤𑀻𑀧𑁄’𑀦𑁆𑀢𑀭𑀻𑀧 𑀧𑀚𑁆𑀚𑁄𑀢, 𑀧𑀢𑀺𑀝𑁆𑀞𑀸 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀻𑀲𑀼 𑀘;

𑀩𑀤𑁆𑀥𑀦𑀺𑀲𑁆𑀲𑀺𑀢 𑀲𑁂𑀢𑁂𑀲𑀼, 𑀢𑀻𑀲𑀼 𑀢𑀁 𑀫𑀺𑀳𑀺𑀢𑁂 𑀲𑀺𑀢𑀁.

𑀣𑀺𑀬𑀁 𑀧𑀚𑀸𑀧𑀢𑀺 𑀤𑀸𑀭𑁂, 𑀩𑁆𑀭𑀳𑁆𑀫𑁂 𑀫𑀸𑀭𑁂 𑀲𑀼𑀭𑁂 𑀧𑀼𑀫𑁂;

𑀯𑀸𑀲𑀼𑀤𑁂𑀯𑁂’𑀦𑁆𑀢𑀓𑁂 𑀓𑀡𑁆𑀳𑁄, 𑀲𑁄 𑀧𑀸𑀧𑁂 𑀅𑀲𑀺𑀢𑁂 𑀢𑀺𑀲𑀼.

𑀉𑀧𑀘𑀸𑀭𑁄 𑀉𑀧𑀝𑁆𑀞𑀸𑀦𑁂, 𑀆𑀲𑀦𑁆𑀦𑁂 𑀅𑀜𑁆𑀜𑀭𑁄𑀧𑀦𑁂;

𑀲𑀓𑁆𑀓𑁄 𑀇𑀦𑁆𑀤𑁂 𑀚𑀦𑀧𑀤𑁂, 𑀲𑀸𑀓𑀺𑀬𑁂, 𑀲𑁄 𑀔𑀫𑁂 𑀢𑀺𑀲𑀼.

𑀯𑀚𑁆𑀚𑀦𑁂 𑀧𑀭𑀺𑀳𑀸𑀭𑁄 𑀘, 𑀲𑀓𑁆𑀓𑀸𑀭𑁂 𑀘𑁂𑀯 𑀭𑀓𑁆𑀔𑀡𑁂;

𑀲𑁄𑀢𑀸𑀧𑀦𑁆𑀦𑀸𑀤𑀺𑀓𑁂 𑀅𑀕𑁆𑀕𑁂, 𑀅𑀭𑀺𑀬𑁄 𑀢𑀻𑀲𑀼, 𑀤𑁆𑀯𑀺𑀚𑁂 𑀧𑀼𑀫𑁂.

𑀲𑀼𑀲𑀼𑀓𑁄 𑀲𑀼𑀲𑀼𑀫𑀸𑀭𑁂 𑀘, 𑀩𑀸𑀮𑀓𑁂 𑀘 𑀉𑀮𑀽𑀧𑀺𑀦𑀺;

𑀇𑀦𑁆𑀤𑀻𑀯𑀭𑀁 𑀫𑀢𑀁 𑀦𑀻𑀮𑀼, 𑀧𑁆𑀧𑀮𑁂 𑀉𑀤𑁆𑀤𑀸𑀮𑀧𑀸𑀤𑀧𑁂.

𑀅𑀲𑀦𑁄 𑀧𑀺𑀬𑀓𑁂 𑀓𑀡𑁆𑀟𑁂, 𑀪𑀓𑁆𑀔𑀡𑁂 𑀔𑀺𑀧𑀦𑁂’ 𑀲𑀦𑀁;

𑀬𑀼𑀕𑁂’𑀥𑀺𑀓𑀸𑀭𑁂 [𑀯𑀺𑀓𑀸𑀭𑁂 (𑀝𑀻.)] 𑀯𑀻𑀭𑀺𑀬𑁂, 𑀧𑀥𑀸𑀦𑁂 𑀘𑀸’𑀦𑁆𑀢𑀺𑀓𑁂 𑀥𑀼𑀭𑁄.

𑀓𑀸𑀴𑁂 𑀘 𑀪𑀓𑁆𑀔𑀺𑀢𑁂 𑀢𑀻𑀲𑀼, 𑀮𑀯𑀺𑀢𑁆𑀢𑁂 𑀅𑀲𑀺𑀢𑁄 𑀧𑀼𑀫𑁂;

𑀧𑀯𑀸𑀭𑀡𑀸 𑀧𑀝𑀺𑀓𑁆𑀔𑁂𑀧𑁂, 𑀓𑀣𑀺𑀢𑀸’𑀚𑁆𑀛𑁂𑀲𑀦𑀸𑀬 𑀘.

𑀉𑀫𑁆𑀫𑀸𑀭𑁂 ¶ 𑀏𑀲𑀺𑀓𑀢𑁆𑀣𑀫𑁆𑀪𑁂, 𑀇𑀦𑁆𑀤𑀔𑀻𑀮𑁄 𑀫𑀢𑁄 𑀣 𑀘;

𑀧𑁄𑀢𑁆𑀣𑀓𑀁 𑀫𑀓𑀘𑀺𑀯𑀢𑁆𑀣𑁂, 𑀕𑀦𑁆𑀣𑁂 𑀮𑁂𑀧𑁆𑀬𑀸𑀤𑀺 𑀓𑀫𑁆𑀫𑀦𑀺.

𑀥𑀜𑁆𑀜𑀁 𑀲𑀸𑀮𑁆𑀬𑀸𑀤𑀺𑀓𑁂 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀥𑀜𑁆𑀜𑁄 𑀧𑀼𑀜𑁆𑀜𑀯𑀢𑀺 𑀢𑁆𑀢𑀺𑀲𑀼;

𑀧𑀸𑀡𑀺 𑀳𑀢𑁆𑀣𑁂 𑀘 𑀲𑀢𑁆𑀢𑁂 𑀪𑀽, 𑀲𑀡𑁆𑀳𑀓𑀭𑀡𑀺𑀬𑀁 𑀫𑀢𑁄.

𑀢𑀻𑀲𑀼 𑀧𑀻𑀢𑀁 𑀳𑀮𑀺𑀤𑁆𑀬𑀸𑀪𑁂, 𑀳𑀝𑁆𑀞𑁂 𑀘 𑀧𑀸𑀬𑀺𑀢𑁂 𑀲𑀺𑀬𑀸;

𑀩𑁆𑀬𑀽𑀳𑁄 𑀦𑀺𑀩𑁆𑀩𑀺𑀤𑁆𑀥𑀭𑀘𑁆𑀙𑀸𑀬𑀁, 𑀩𑀮𑀦𑁆𑀬𑀸𑀲𑁂 𑀕𑀡𑁂 𑀫𑀢𑁄.

𑀮𑁄𑀳𑀺𑀢𑀸𑀤𑀺𑀫𑁆𑀳𑀺 𑀮𑁄𑀪𑁂 𑀘, 𑀭𑀸𑀕𑁄 𑀘 𑀭𑀜𑁆𑀚𑀦𑁂 𑀫𑀢𑁄;

𑀧𑀤𑀭𑁄 𑀨𑀮𑀓𑁂 𑀪𑀗𑁆𑀕𑁂, 𑀧𑀯𑀼𑀤𑁆𑀥 𑀤𑀭𑀺𑀬𑀁 𑀧𑀺𑀘.

𑀲𑀺𑀗𑁆𑀖𑀸𑀝𑀓𑀁 𑀓𑀲𑁂𑀭𑀼𑀲𑁆𑀲, 𑀨𑀮𑁂, 𑀫𑀕𑁆𑀕𑀲𑀫𑀸𑀕𑀫𑁂;

𑀩𑀳𑀼𑀮𑀸𑀬𑀜𑁆𑀘 𑀔𑁂𑀴𑀫𑁆𑀳𑀺, 𑀏𑀴𑀸, 𑀤𑁄𑀲𑁂’𑀴 𑀫𑀻𑀭𑀺𑀢𑀁.

𑀆𑀥𑀸𑀭𑁄 𑀘𑀸’𑀥𑀺𑀓𑀭𑀡𑁂, 𑀧𑀢𑁆𑀢𑀸𑀥𑀸𑀭𑁂’ 𑀮𑀯𑀸𑀮𑀓𑁂;

𑀓𑀸𑀭𑁄’ 𑀕𑀪𑁂𑀤𑁂 𑀲𑀓𑁆𑀓𑀸𑀭𑁂, 𑀓𑀸𑀭𑀸 𑀢𑀼 𑀩𑀦𑁆𑀥𑀦𑀸𑀮𑀬𑁂.

𑀓𑀭𑀓𑀸 𑀫𑁂𑀖𑀧𑀸𑀲𑀸𑀡𑁂, 𑀓𑀭𑀓𑁄 𑀓𑀼𑀡𑁆𑀟𑀺𑀓𑀸𑀬 𑀘;

𑀧𑀸𑀧𑀦𑁂 𑀘 𑀧𑀤𑀸𑀢𑀺𑀲𑁆𑀫𑀺𑀁, 𑀕𑀫𑀦𑁂 𑀧𑀢𑁆𑀢𑀺 𑀦𑀸𑀭𑀺𑀬𑀁.

𑀙𑀺𑀤𑁆𑀤𑀁 𑀭𑀦𑁆𑀥𑀜𑁆𑀘 𑀯𑀺𑀯𑀭𑀁, 𑀲𑀼𑀲𑀺𑀭𑁂 𑀤𑀽𑀲𑀦𑁂𑀧𑀺 𑀘;

𑀫𑀼𑀢𑁆𑀢𑀸 𑀢𑀼 𑀫𑀼𑀢𑁆𑀢𑀺𑀓𑁂, 𑀫𑀼𑀢𑁆𑀢𑀁, 𑀧𑀲𑁆𑀲𑀸𑀯𑁂, 𑀫𑀼𑀘𑁆𑀘𑀺𑀢𑁂 𑀢𑀺𑀲𑀼.

𑀦𑀺𑀲𑁂𑀥𑁂 𑀯𑀸𑀭𑀡𑀁, 𑀳𑀢𑁆𑀣𑀺, 𑀮𑀺𑀗𑁆𑀕 𑀳𑀢𑁆𑀣𑀻𑀲𑀼 𑀯𑀸𑀭𑀡𑁄;

𑀤𑀸𑀦𑀁 𑀘𑀸𑀕𑁂 𑀫𑀤𑁂 𑀲𑀼𑀤𑁆𑀥𑁂, 𑀔𑀡𑁆𑀟𑀦𑁂 𑀮𑀯𑀦𑁂 𑀔𑀬𑁂.

𑀫𑀦𑁄𑀢𑁄𑀲𑁂 𑀘 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑁂, 𑀢𑁆𑀣𑀗𑁆𑀕𑀫𑁂 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀺’𑀢𑁆𑀣𑀺𑀬𑀁;

𑀦𑁂𑀕𑀫𑁄 𑀦𑀺𑀕𑀫𑀼𑀩𑁆𑀪𑀽𑀢𑁂, 𑀢𑀣𑀸’𑀧𑀡𑁄𑀧𑀚𑀻𑀯𑀺𑀦𑀺.

𑀳𑀭𑀺𑀢𑀲𑁆𑀫𑀺𑀜𑁆𑀘 𑀧𑀡𑁆𑀡𑁂 𑀘, 𑀧𑀮𑀸𑀲𑁄 𑀓𑀺𑀁 𑀲𑀼𑀓𑀤𑁆𑀤𑀼𑀫𑁂;

𑀧𑀓𑀸𑀲𑁄 𑀧𑀸𑀓𑀝𑁂𑀢𑀻𑀲𑀼, 𑀆𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀧𑀼𑀫𑁂 𑀫𑀢𑁄.

𑀧𑀓𑁆𑀓𑀁 𑀨𑀮𑀫𑁆𑀳𑀺, 𑀢𑀁 𑀦𑀸𑀲𑀼, 𑀫𑁆𑀫𑀼𑀔𑁂 [𑀦𑀸𑀲𑀫𑀼𑀔𑁂 (𑀓.)] 𑀧𑀭𑀺𑀡𑀢𑁂 𑀢𑀺𑀲𑀼;

𑀧𑀺𑀡𑁆𑀟𑁄 𑀆𑀚𑀻𑀯𑀦𑁂 𑀤𑁂𑀳𑁂, 𑀧𑀺𑀡𑁆𑀟𑀦𑁂 𑀕𑁄𑀴𑀓𑁂 𑀫𑀢𑁄.

𑀯𑀝𑁆𑀝𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀬𑁂 𑀓𑀫𑁆𑀫𑀸, 𑀤𑀺𑀓𑁂, 𑀲𑁄 𑀯𑀝𑁆𑀝𑀼𑀮𑁂 𑀢𑀺𑀲𑀼;

𑀧𑀘𑁆𑀘𑀸𑀳𑀸𑀭𑁂 𑀧𑀝𑀺𑀳𑀸𑀭𑁄, 𑀤𑁆𑀯𑀸𑀭𑁂 𑀘 𑀤𑁆𑀯𑀸𑀭𑀧𑀸𑀮𑀓𑁂.

𑀦𑀸𑀭𑀺𑀬𑀁 𑀪𑀻𑀭𑀼 𑀓𑀣𑀺𑀢𑀸, 𑀪𑀻𑀭𑀼𑀓𑁂 𑀲𑁄 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄;

𑀯𑀺𑀓𑀝𑀁 𑀕𑀽𑀣𑀫𑀼𑀢𑁆𑀢𑀸𑀤𑁄, 𑀯𑀺𑀓𑀝𑁄 𑀯𑀺𑀓𑀢𑁂 𑀢𑀺𑀲𑀼.

𑀯𑀸𑀫𑀁 ¶ 𑀲𑀩𑁆𑀬𑀫𑁆𑀳𑀺, 𑀢𑀁 𑀘𑀸𑀭𑀼, 𑀯𑀺𑀧𑀭𑀻𑀢𑁂𑀲𑀼 𑀢𑀻𑀲𑁆𑀯’𑀣;

𑀲𑀗𑁆𑀔𑁆𑀬𑀸𑀪𑁂𑀤𑁂 𑀲𑀭𑀩𑁆𑀬𑁂 𑀘, 𑀘𑀺𑀳𑀡𑁂 𑀮𑀓𑁆𑀔 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀲𑁂𑀡𑀻’𑀢𑁆𑀣𑀻 𑀲𑀫𑀲𑀺𑀧𑁆𑀧𑀻𑀦𑀁, 𑀕𑀡𑁂 𑀘𑀸’𑀯𑀮𑀺𑀬𑀁 𑀧𑀺𑀘;

𑀲𑀼𑀥𑀸𑀬𑀁 𑀥𑀽𑀮𑀺𑀬𑀁 𑀘𑀼𑀡𑁆𑀡𑁄, 𑀘𑀼𑀡𑁆𑀡𑀜𑁆𑀘 𑀯𑀸𑀲𑀘𑀼𑀡𑁆𑀡𑀓𑁂.

𑀚𑁂𑀢𑀩𑁆𑀩𑁂’𑀢𑀺𑀧𑁆𑀧𑀲𑀢𑁆𑀣𑁂’𑀢𑀺, 𑀯𑀼𑀤𑁆𑀥𑁂 𑀚𑁂𑀬𑁆𑀬𑀁 𑀢𑀺𑀲𑀽’𑀭𑀺𑀢𑀁;

𑀢𑀓𑁆𑀓𑁂 𑀢𑀼 𑀫𑀣𑀺𑀢𑀁 𑀳𑁄𑀢𑁆𑀬𑀸,

𑀅𑀩𑁆𑀪𑀼𑀢𑁄’𑀘𑁆𑀙𑀭𑀺𑀬𑁂 𑀢𑀻𑀲𑀼, 𑀧𑀡𑁂 𑀘𑁂𑀯𑀸’𑀩𑁆𑀪𑀼𑀢𑁄 𑀧𑀼𑀫𑁂;

𑀫𑁂𑀘𑀓𑁄 𑀧𑀼𑀘𑁆𑀙𑀫𑀽𑀮𑀫𑁆𑀳𑀺, 𑀓𑀡𑁆𑀳𑁂𑀧𑀺 𑀫𑁂𑀘𑀓𑁄 𑀢𑀺𑀲𑀼.

𑀯𑀲𑀯𑀢𑁆𑀢𑀻 𑀧𑀼𑀫𑁂 𑀫𑀸𑀭𑁂, 𑀯𑀲𑀯𑀢𑁆𑀢𑀸𑀧𑀓𑁂 𑀢𑀺𑀲𑀼;

𑀲𑀫𑁆𑀪𑀯𑁂 𑀘𑀸’𑀲𑀼𑀘𑀺 𑀧𑀼𑀫𑁂, 𑀅𑀫𑁂𑀚𑁆𑀛𑁂 𑀢𑀻𑀲𑀼 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑀅𑀘𑁆𑀙𑁄 𑀇𑀓𑁆𑀓𑁂 𑀧𑀼𑀫𑁂 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀧𑀲𑀦𑁆𑀦𑀫𑁆𑀳𑀺 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄;

𑀩𑀴𑀺𑀲𑁂 𑀲𑁂𑀮𑀪𑁂𑀤𑁂 𑀘, 𑀯𑀗𑁆𑀓𑁄, 𑀲𑁄 𑀓𑀼𑀝𑀺𑀮𑁂 𑀢𑀺𑀲𑀼.

𑀲𑀩𑁆𑀩𑀲𑁆𑀫𑀺𑀁 𑀲𑀓𑀮𑁄 𑀢𑀻𑀲𑀼, 𑀅𑀤𑁆𑀥𑀫𑁆𑀳𑀺 𑀧𑀼𑀭𑀺𑀲𑁂 𑀲𑀺𑀬𑀸.

𑀘𑀦𑁆𑀤𑀕𑁆𑀕𑀸𑀳𑀸𑀤𑀺𑀓𑁂 𑀘𑁂𑀯𑀼, 𑀧𑁆𑀧𑀸𑀤𑁄 𑀉𑀧𑁆𑀧𑀢𑁆𑀢𑀺𑀬𑀁 𑀧𑀺𑀘;

𑀧𑀤𑀼𑀲𑁆𑀲𑀦𑁂 𑀧𑀤𑁄𑀲𑁄 𑀘, 𑀓𑀣𑀺𑀢𑁄 𑀲𑀁𑀯𑀭𑀻𑀫𑀼𑀔𑁂.

𑀭𑀼𑀥𑀺𑀭𑁂 𑀮𑁄𑀳𑀺𑀢𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀭𑀢𑁆𑀢𑀫𑁆𑀳𑀺 𑀮𑁄𑀳𑀺𑀢𑁄 𑀢𑀺𑀲𑀼;

𑀉𑀢𑁆𑀢𑀫𑀗𑁆𑀕𑁂 𑀧𑀼𑀫𑁂 𑀫𑀼𑀤𑁆𑀥𑀸, 𑀫𑀼𑀤𑁆𑀥𑁄 𑀫𑀽𑀴𑁆𑀳𑁂 𑀢𑀺𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄.

𑀭𑀝𑁆𑀞𑀫𑁆𑀳𑀺 𑀯𑀺𑀚𑀺𑀢𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀚𑀺𑀢𑁂 𑀘 𑀯𑀺𑀚𑀺𑀢𑁄 𑀢𑀺𑀲𑀼;

𑀧𑀭𑀺𑀢𑁆𑀢𑀁 𑀢𑀼 𑀧𑀭𑀺𑀢𑁆𑀢𑀸𑀡𑁂, 𑀧𑀭𑀺𑀢𑁆𑀢𑁄 𑀢𑀻𑀲𑀼 𑀅𑀧𑁆𑀧𑀓𑁂.

𑀓𑀼𑀫𑁆𑀪𑀡𑁆𑀟𑁄 𑀤𑁂𑀯𑀪𑁂𑀤𑁂 𑀘, 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀯𑀮𑁆𑀮𑀺𑀚𑀸𑀢𑀺𑀬𑀁;

𑀘𑀢𑀼𑀢𑁆𑀣𑀁𑀲𑁂 𑀧𑀤𑁂 𑀧𑀸𑀤𑁄, 𑀧𑀘𑁆𑀘𑀦𑁆𑀢𑀲𑁂𑀮𑀭𑀁𑀲𑀺𑀲𑀼.

𑀯𑀗𑁆𑀕𑁄 𑀮𑁄𑀳𑀦𑁆𑀢𑀭𑁂 𑀯𑀗𑁆𑀕𑀸, 𑀤𑁂𑀲𑁂 𑀧𑀼𑀫𑁂 𑀩𑀳𑀼𑀫𑁆𑀳𑀺 𑀘;

𑀓𑀫𑁆𑀫𑀸𑀭𑀪𑀡𑁆𑀟𑀪𑁂𑀤𑁂 𑀘, 𑀔𑀝𑀓𑁂 𑀫𑀼𑀝𑁆𑀞𑀺 𑀘 𑀤𑁆𑀯𑀺𑀲𑀼.

𑀅𑀫𑁆𑀩𑀡𑀁 𑀤𑁄𑀡𑀺𑀬𑀁 𑀘𑁂’𑀓𑀸, 𑀤𑀲𑀤𑁄𑀡𑀧𑁆𑀧𑀫𑀸𑀡𑀓𑁂;

𑀅𑀥𑀺𑀝𑁆𑀞𑀺𑀢𑀺𑀬 𑀫𑀸𑀥𑀸𑀭𑁂, 𑀞𑀸𑀦𑁂’𑀥𑀺𑀝𑁆𑀞𑀸𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑁂.

𑀧𑀼𑀫𑁂 𑀫𑀳𑁂𑀲𑀻 𑀲𑀼𑀕𑀢𑁂, 𑀤𑁂𑀯𑀺𑀬𑀁 𑀦𑀸𑀭𑀺𑀬𑀁 𑀫𑀢𑀸;

𑀉𑀧𑀤𑁆𑀤𑀯𑁂 𑀉𑀧𑀲𑀕𑁆𑀕𑁄, 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀧𑀸𑀤𑀺𑀓𑁂𑀧𑀺 𑀘.

𑀯𑀓𑁆𑀓𑀁 ¶ 𑀓𑁄𑀝𑁆𑀞𑀸𑀲𑀪𑁂𑀤𑀲𑁆𑀫𑀺𑀁, 𑀯𑀓𑁆𑀓𑁄 𑀯𑀗𑁆𑀓𑁂 𑀢𑀺𑀲𑀼’𑀘𑁆𑀘𑀢𑁂;

𑀯𑀺𑀚𑁆𑀚𑀸 𑀯𑁂𑀤𑁂 𑀘 𑀲𑀺𑀧𑁆𑀧𑁂 𑀘, 𑀢𑀺𑀯𑀺𑀚𑁆𑀚𑀸𑀤𑁄 𑀘 𑀩𑀼𑀤𑁆𑀥𑀺𑀬𑀁.

𑀲𑀫𑀸𑀥𑀺𑀫𑁆𑀳𑀺 𑀧𑀼𑀫𑁂’𑀓𑀕𑁆𑀕𑁄, 𑀦𑀸𑀓𑀼𑀮𑁂 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄;

𑀧𑀚𑁆𑀚𑀁 𑀲𑀺𑀮𑁄𑀓𑁂, 𑀧𑀚𑁆𑀚𑁄’𑀤𑁆𑀥𑁂, 𑀧𑀚𑁆𑀚𑁄 𑀧𑀸𑀤𑀳𑀺𑀢𑁂 𑀢𑀺𑀲𑀼.

𑀓𑀢𑀓𑁄 𑀭𑀼𑀓𑁆𑀔𑀪𑁂𑀤𑀲𑁆𑀫𑀺𑀁, 𑀓𑀢𑀓𑁄 𑀓𑀺𑀢𑁆𑀢𑀺𑀫𑁂 𑀢𑀺𑀲𑀼;

𑀯𑀺𑀥𑁂𑀬𑁆𑀬𑁂 𑀅𑀲𑁆𑀲𑀯𑁄 𑀢𑀻𑀲𑀼, 𑀧𑀼𑀩𑁆𑀩𑀫𑁆𑀳𑀻 𑀧𑀼𑀭𑀺𑀲𑁂 𑀲𑀺𑀬𑀸.

𑀓𑀮𑁆𑀬𑀸𑀡𑁂 𑀓𑀣𑀺𑀢𑀁 𑀔𑁂𑀫𑀁, 𑀢𑀻𑀲𑀼 𑀮𑀤𑁆𑀥𑀢𑁆𑀣𑀭𑀓𑁆𑀔𑀡𑁂;

𑀅𑀣𑁄 𑀦𑀺𑀬𑁄𑀚𑀦𑁂 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀓𑀸𑀭𑀺𑀬𑁂𑀧𑀺 𑀧𑀬𑁄𑀚𑀦𑀁.

𑀅𑀲𑁆𑀲𑀢𑁆𑀣𑁄 𑀢𑀻𑀲𑀼 𑀅𑀲𑁆𑀲𑀸𑀲, 𑀧𑁆𑀧𑀢𑁆𑀢𑁂, 𑀩𑁄𑀥𑀺𑀤𑁆𑀤𑀼𑀫𑁂 𑀧𑀼𑀫𑁂;

𑀢𑀻𑀲𑀼 𑀮𑀼𑀤𑁆𑀤𑁄 𑀓𑀼𑀭𑀽𑀭𑁂 𑀘, 𑀦𑁂𑀲𑀸𑀤𑀫𑁆𑀳𑀺 𑀧𑀼𑀫𑁂 𑀲𑀺𑀬𑀸.

𑀯𑀺𑀮𑀕𑁆𑀕𑁄 𑀢𑀻𑀲𑀼 𑀮𑀕𑁆𑀕𑀲𑁆𑀫𑀺𑀁, 𑀧𑀼𑀫𑁂 𑀫𑀚𑁆𑀛𑀫𑁆𑀳𑀺 𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀅𑀟𑁆𑀠𑁄 𑀢𑁆𑀯𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀁 𑀪𑀸𑀕𑁂, 𑀥𑀦𑀺𑀫𑁆𑀳𑀺 𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀺𑀓𑁄.

𑀓𑀝𑁆𑀞𑀁 𑀤𑀸𑀭𑀼𑀫𑁆𑀳𑀺, 𑀢𑀁 𑀓𑀺𑀘𑁆𑀙𑁂, 𑀕𑀳𑀦𑁂 𑀓𑀲𑀺𑀢𑁂 𑀢𑀺𑀲𑀼;

𑀲𑀲𑀦𑁆𑀢𑀸𑀦𑁂 𑀘 𑀯𑀺𑀲𑀬𑁂, 𑀕𑁄𑀘𑀭𑁂’ 𑀚𑁆𑀛𑀢𑁆𑀢 𑀫𑀼𑀘𑁆𑀘𑀢𑁂𑀢𑀺.

𑀪𑀼𑀯𑀦𑁂 𑀘 𑀚𑀦𑁂 𑀮𑁄𑀓𑁄, 𑀫𑁄𑀭𑁂𑀢𑁆𑀯𑀕𑁆𑀕𑀺𑀫𑁆𑀳𑀺 𑀲𑁄 𑀲𑀺𑀔𑀻;

𑀯𑀝𑀩𑁆𑀬𑀸𑀫𑁂𑀲𑀼 𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑁄, 𑀥𑀗𑁆𑀓𑁄 𑀢𑀼 𑀯𑀸𑀬𑀲𑁂 𑀩𑀓𑁂;

𑀯𑀸𑀭𑁄 𑀢𑁆𑀯’𑀯𑀲𑀭𑀸’𑀳𑁂𑀲𑀼, 𑀓𑀼𑀘𑁂𑀢𑁆𑀯𑀩𑁆𑀪𑁂 𑀧𑀬𑁄𑀥𑀭𑁄.

𑀉𑀘𑁆𑀙𑀗𑁆𑀕𑁂 𑀮𑀓𑁆𑀔𑀡𑁂 𑀘𑀸’𑀗𑁆𑀓𑁄, 𑀭𑀲𑁆𑀫𑀺’𑀢𑁆𑀣𑀻 𑀚𑀼𑀢𑀺 𑀭𑀚𑁆𑀚𑀼𑀲𑀼;

𑀩𑀼𑀤𑁆𑀥𑁄 𑀢𑀼 𑀧𑀡𑁆𑀟𑀺𑀢𑁂 𑀚𑀺𑀦𑁂.

𑀲𑀽𑀭𑀁’𑀲𑀽𑀲𑀼 𑀧𑀼𑀫𑁂 𑀪𑀸𑀦𑀽, 𑀤𑀡𑁆𑀟𑁄 𑀢𑀼 𑀫𑀼𑀕𑁆𑀕𑀭𑁂 𑀤𑀫𑁂;

𑀤𑁂𑀯𑀫𑀘𑁆𑀙𑁂𑀲𑁆𑀯’𑀦𑀺𑀫𑀺𑀲𑁄, 𑀧𑀢𑁆𑀣𑁄 𑀢𑀼 𑀫𑀸𑀦𑀲𑀸𑀦𑀼𑀲𑀼.

𑀫𑀺𑀕𑁄 𑀧𑀲𑀼 𑀓𑀼𑀭𑀼𑀗𑁆𑀕𑁂𑀲𑀼, 𑀉𑀮𑀽𑀓𑀺’𑀦𑁆𑀤𑁂𑀲𑀼 𑀓𑁄𑀲𑀺𑀬𑁄.

𑀯𑀺𑀕𑁆𑀕𑀳𑁄 ¶ 𑀓𑀮𑀳𑁂 𑀓𑀸𑀬𑁂, 𑀧𑀼𑀭𑀺𑀲𑁄 𑀫𑀸𑀡𑀯’𑀢𑁆𑀢𑀲𑀼;

𑀤𑀸𑀬𑀸𑀤𑁄 𑀩𑀦𑁆𑀥𑀯𑁂 𑀧𑀼𑀢𑁆𑀢𑁂, 𑀲𑀺𑀭𑁂 𑀲𑀻𑀲𑀁 𑀢𑀺𑀧𑀼𑀫𑁆𑀳𑀺 𑀘.

𑀩𑀮𑀺𑀳𑀢𑁆𑀣𑀁’𑀲𑀽𑀲𑀼 𑀓𑀭𑁄, 𑀤𑀦𑁆𑀢𑁂 𑀯𑀺𑀧𑁆𑀧𑁂’𑀡𑁆𑀟𑀚𑁂 𑀤𑁆𑀯𑀺𑀚𑁄;

𑀯𑀢𑁆𑀢𑀁 𑀧𑀚𑁆𑀚𑀸’𑀦𑀦𑀸’𑀘𑀸𑀭𑁂, 𑀥𑀜𑁆𑀜𑀗𑁆𑀕𑁂 𑀲𑀼𑀔𑀼𑀫𑁂 𑀓𑀡𑁄.

𑀣𑀫𑁆𑀪𑁄 𑀣𑀽𑀡 𑀚𑀴𑀢𑁆𑀢𑁂𑀲𑀼, 𑀲𑀽𑀧𑁄 𑀓𑀼𑀫𑁆𑀫𑀸𑀲 𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑁂;

𑀕𑀡𑁆𑀟𑁄 𑀨𑁄𑀝𑁂 𑀓𑀧𑁄𑀮𑀫𑁆𑀳𑀺, 𑀅𑀕𑁆𑀖𑁄 𑀫𑀽𑀮𑁆𑀬𑁂 𑀘 𑀧𑀽𑀚𑀦𑁂.

𑀧𑀓𑀸𑀭𑁄 𑀢𑀼𑀮𑁆𑀬 𑀪𑁂𑀤𑁂𑀲𑀼, 𑀲𑀓𑀼𑀦𑁆𑀢𑁄 𑀪𑀸𑀲𑀧𑀓𑁆𑀔𑀺𑀲𑀼;

𑀪𑀸𑀕𑁆𑀬𑁂 𑀯𑀺𑀥𑀺 𑀯𑀺𑀥𑀸𑀦𑁂 𑀘, 𑀲𑀭𑁂 𑀔𑀕𑁆𑀕𑁂 𑀘 𑀲𑀸𑀬𑀓𑁄.

𑀲𑀸𑀭𑀗𑁆𑀕𑁄 𑀘𑀸𑀢𑀓𑁂 𑀏𑀡𑁂, 𑀧𑀢𑁆𑀢𑀻 𑀢𑀼 𑀲𑀭𑀧𑀓𑁆𑀔𑀺𑀲𑀼;

𑀲𑀁𑀯𑀝𑁆𑀝𑁂 𑀧𑀮𑀬𑁄 𑀦𑀸𑀲𑁂, 𑀧𑀽𑀕𑁄 𑀓𑀫𑀼𑀓𑀭𑀸𑀲𑀺𑀲𑀼.

𑀅𑀫𑀢𑁂 𑀢𑀼 𑀲𑀼𑀥𑀸 𑀮𑁂𑀧𑁂, 𑀅𑀪𑀺𑀔𑁆𑀬𑀸 𑀦𑀸𑀫 𑀭𑀁𑀲𑀺𑀲𑀼;

𑀲𑀢𑁆𑀢𑀺 𑀲𑀸𑀫𑀢𑁆𑀣𑀺𑀬𑁂 𑀲𑀢𑁆𑀣𑁂, 𑀫𑀳𑀻 𑀦𑀚𑁆𑀚𑀦𑁆𑀢𑀭𑁂 𑀪𑀼𑀯𑀺;

𑀜𑀸𑀡𑁂 𑀮𑀸𑀪𑁂 𑀉𑀧𑀮𑀤𑁆𑀥𑀺, 𑀧𑀯𑁂𑀡𑀻 𑀓𑀼𑀣𑀯𑁂𑀡𑀺𑀲𑀼;

𑀧𑀯𑀢𑁆𑀢𑀺 𑀯𑀼𑀢𑁆𑀢𑀺 𑀯𑀢𑁆𑀢𑀸𑀲𑀼, 𑀯𑁂𑀢𑀦𑁂 𑀪𑀭𑀡𑁂 𑀪𑀢𑀺.

𑀆𑀘𑀸𑀭𑁂𑀧𑀺 𑀫𑀭𑀺𑀬𑀸𑀤𑀸, 𑀪𑀽𑀢𑀺 𑀲𑀢𑁆𑀢𑀸 𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀲𑀼;

𑀲𑁄𑀧𑁆𑀧𑁂 𑀧𑀫𑀸𑀤𑁂 𑀢𑀦𑁆𑀤𑀻 𑀘, 𑀬𑀸𑀢𑁆𑀭𑀸 𑀕𑀫𑀦 𑀯𑀼𑀢𑁆𑀢𑀺𑀲𑀼.

𑀦𑀺𑀦𑁆𑀤𑀸 𑀓𑀼𑀘𑁆𑀙𑀸’𑀧𑀯𑀸𑀤𑁂𑀲𑀼, 𑀓𑀗𑁆𑀕𑀼 𑀥𑀜𑁆𑀜 𑀧𑀺𑀬𑀗𑁆𑀕𑀼𑀲𑀼;

𑀫𑁄𑀓𑁆𑀔𑁂𑀲𑀺𑀯𑁂 𑀲𑀫𑁂𑀲𑀦𑁆𑀢𑀺, 𑀯𑀺𑀪𑀸𑀕𑁂 𑀪𑀢𑁆𑀢𑀺 𑀲𑁂𑀯𑀦𑁂.

𑀇𑀘𑁆𑀙𑀸𑀬𑀁 𑀚𑀼𑀢𑀺𑀬𑀁 𑀓𑀦𑁆𑀢𑀺, 𑀭𑀜𑁆𑀚𑀦𑁂 𑀲𑀽𑀭𑀢𑁂 𑀭𑀢𑀺;

𑀕𑁂𑀳𑁂 𑀯𑀲𑀢𑀺 𑀯𑀸𑀲𑁂 𑀣, 𑀦𑀤𑀻 𑀲𑁂𑀦𑀸𑀲𑀼 𑀯𑀸𑀳𑀺𑀦𑀻.

𑀧𑀢𑁆𑀣𑁂 𑀦𑀸𑀴𑁂 𑀘 𑀦𑀸𑀴𑀺’𑀢𑁆𑀣𑀻, 𑀕𑀡𑁂 𑀲𑀫𑀺𑀢𑀺 𑀲𑀗𑁆𑀕𑀫𑁂;

𑀢𑀡𑁆𑀳𑀸 𑀮𑁄𑀪𑁂 𑀧𑀺𑀧𑀸𑀲𑀸𑀬𑀁, 𑀫𑀕𑁆𑀕 𑀯𑀼𑀢𑁆𑀢𑀻𑀲𑀼 𑀯𑀢𑁆𑀢𑀦𑀻.

𑀧𑀸𑀡𑁆𑀬𑀗𑁆𑀕𑁂 𑀦𑀸𑀪𑀺 𑀘𑀓𑁆𑀓𑀦𑁆𑀢𑁂, 𑀬𑀸𑀘𑁂 𑀯𑀺𑀜𑁆𑀜𑀢𑁆𑀢𑀺 𑀜𑀸𑀧𑀦𑁂;

𑀯𑀺𑀢𑁆𑀢𑀺 𑀢𑁄𑀲𑁂 𑀯𑁂𑀤𑀦𑀸𑀬𑀁, 𑀞𑀸𑀦𑁂 𑀢𑀼 𑀚𑀻𑀯𑀺𑀢𑁂 𑀞𑀺𑀢𑀺.

𑀢𑀭𑀗𑁆𑀕𑁂 ¶ 𑀘𑀸’𑀦𑁆𑀢𑀭𑁂 𑀯𑀻𑀘𑀺, 𑀥𑀻𑀭𑀢𑁆𑀢𑁂 𑀥𑀸𑀭𑀡𑁂 𑀥𑀺𑀢𑀺;

𑀪𑀽 𑀪𑀽𑀫𑀺𑀬𑀜𑁆𑀘 𑀪𑀫𑀼𑀓𑁂, 𑀲𑀤𑁆𑀤𑁂 𑀯𑁂𑀤𑁂 𑀲𑀯𑁂 𑀲𑀼𑀢𑀺.

𑀕𑁄𑀢𑁆𑀢𑀁 𑀦𑀸𑀫𑁂 𑀘 𑀯𑀁𑀲𑁂 𑀣, 𑀦𑀕𑀭𑁂 𑀘 𑀖𑀭𑁂 𑀧𑀼𑀭𑀁;

𑀑𑀓𑀁 𑀢𑀼 𑀦𑀺𑀲𑁆𑀲𑀬𑁂 𑀕𑁂𑀳𑁂, 𑀓𑀼𑀮𑀁 𑀢𑀼 𑀕𑁄𑀢𑁆𑀢𑀭𑀸𑀲𑀺𑀲𑀼.

𑀳𑁂𑀫𑁂 𑀯𑀺𑀢𑁆𑀢𑁂 𑀳𑀺𑀭𑀜𑁆𑀜𑀜𑁆𑀘, 𑀧𑀜𑁆𑀜𑀸𑀡𑀁 𑀢𑁆𑀯’𑀗𑁆𑀓 𑀯𑀼𑀤𑁆𑀥𑀺𑀲𑀼;

𑀅𑀣𑀸’𑀫𑁆𑀩𑀭𑀜𑁆𑀘 𑀔𑁂 𑀯𑀢𑁆𑀣𑁂, 𑀕𑀼𑀬𑁆𑀳𑀁 𑀮𑀺𑀗𑁆𑀕𑁂 𑀭𑀳𑀲𑁆𑀬’𑀧𑀺.

𑀢𑀧𑁄 𑀥𑀫𑁆𑀫𑁂 𑀯𑀢𑁂 𑀘𑁂𑀯, 𑀧𑀸𑀧𑁂 𑀢𑁆𑀯𑀸’𑀕𑀼𑀫𑁆𑀳𑀺 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀁;

𑀭𑀢𑀦𑀁 𑀫𑀡𑀺 𑀲𑁂𑀝𑁆𑀞𑁂𑀲𑀼, 𑀯𑀲𑁆𑀲𑀁 𑀳𑀸𑀬𑀦 𑀯𑀼𑀝𑁆𑀞𑀺𑀲𑀼.

𑀯𑀦𑀁 𑀅𑀭𑀜𑁆𑀜 𑀯𑀸𑀭𑀻𑀲𑀼, 𑀔𑀻𑀭𑀫𑁆𑀳𑀺 𑀢𑀼 𑀚𑀮𑁂 𑀧𑀬𑁄;

𑀅𑀓𑁆𑀔𑀭𑀁 𑀮𑀺𑀧𑀺 𑀫𑁄𑀓𑁆𑀔𑁂𑀲𑀼, 𑀫𑁂𑀣𑀽𑀦𑀁 𑀲𑀗𑁆𑀕𑀫𑁂 𑀭𑀢𑁂.

𑀲𑁄𑀢𑀁 𑀓𑀡𑁆𑀡𑁂 𑀧𑀬𑁄𑀯𑁂𑀕𑁂, 𑀭𑀺𑀝𑁆𑀞𑀁 𑀧𑀸𑀧𑀸’𑀲𑀼𑀪𑁂𑀲𑀼 𑀘;

𑀆𑀕𑀼 𑀧𑀸𑀧𑀸’𑀧𑀭𑀸𑀥𑁂𑀲𑀼, 𑀓𑁂𑀢𑀼𑀫𑁆𑀳𑀺 𑀘𑀺𑀳𑀦𑁂 𑀥𑀚𑁄.

𑀕𑁄𑀧𑀼𑀭𑀁 𑀤𑁆𑀯𑀸𑀭𑀫𑀢𑁆𑀢𑁂𑀧𑀺, 𑀫𑀦𑁆𑀤𑀺𑀭𑀁 𑀦𑀕𑀭𑁂 𑀖𑀭𑁂;

𑀯𑀸𑀘𑁆𑀘𑀮𑀺𑀗𑁆𑀕𑀸 𑀧𑀭𑀫𑀺𑀢𑁄, 𑀩𑁆𑀬𑀢𑁆𑀢𑁄 𑀢𑀼 𑀧𑀡𑁆𑀟𑀺𑀢𑁂 𑀨𑀼𑀝𑁂.

𑀯𑀮𑁆𑀮𑀪𑁄 𑀤𑀬𑀺𑀢𑁂’𑀚𑁆𑀛𑀓𑁆𑀔𑁂, 𑀚𑀮𑁂 𑀣𑀽𑀮𑁄 𑀫𑀳𑀢𑁆𑀬𑀧𑀺;

𑀩𑀻𑀪𑀘𑁆𑀙𑁄 𑀯𑀺𑀓𑀢𑁂 𑀪𑀻𑀫𑁂, 𑀓𑁄𑀫𑀮𑁂 𑀢𑀺𑀔𑀺𑀡𑁂 𑀫𑀼𑀤𑀼;

𑀇𑀝𑁆𑀞𑁂 𑀘 𑀫𑀥𑀼𑀭𑁂 𑀲𑀸𑀤𑀼, 𑀲𑀸𑀤𑀼𑀫𑁆𑀳𑀺 𑀫𑀥𑀼𑀭𑁄 𑀧𑀺𑀬𑁂.

𑀲𑀺𑀢𑁂 𑀢𑀼 𑀲𑀼𑀤𑁆𑀥𑁂 𑀑𑀤𑀸𑀢𑁄, 𑀤𑁆𑀯𑀺𑀚𑀺𑀯𑁆𑀳𑁄 𑀲𑀽𑀘𑀓𑀸’𑀳𑀺𑀲𑀼;

𑀲𑀓𑁆𑀓𑁂 𑀲𑀫𑀢𑁆𑀣𑁄 𑀲𑀫𑁆𑀩𑀦𑁆𑀥𑁂, 𑀲𑀫𑀢𑁆𑀢𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸’𑀔𑀺𑀮𑁂.

𑀲𑀼𑀤𑁆𑀥𑁄 𑀓𑁂𑀯𑀮 𑀧𑀽𑀢𑁂𑀲𑀼, 𑀚𑀺𑀖𑀜𑁆𑀜𑁄’𑀦𑁆𑀢𑀸’𑀥𑀫𑁂𑀲𑀼 𑀘;

𑀧𑁄𑀡𑁄’𑀧𑀦𑀢 𑀦𑀺𑀦𑁆𑀦𑁂𑀲𑀼, 𑀅𑀜𑁆𑀜 𑀦𑀻𑀘𑁂𑀲𑀼 𑀘𑁂’𑀢𑀭𑁄.

𑀲𑀼𑀘𑀺 𑀲𑀼𑀤𑁆𑀥𑁂 𑀲𑀺𑀢𑁂 𑀧𑀽𑀢𑁂, 𑀧𑁂𑀲𑀮𑁄 𑀤𑀓𑁆𑀔𑀘𑀸𑀭𑀼𑀲𑀼;

𑀅𑀥𑀫𑁄 𑀓𑀼𑀘𑁆𑀙𑀺𑀢𑁂 𑀊𑀦𑁂, 𑀅𑀧𑁆𑀧𑀺𑀬𑁂 𑀧𑁆𑀬’𑀮𑀺𑀓𑁄 𑀪𑀯𑁂.

𑀩𑁆𑀬𑀸𑀧𑁂 𑀅𑀲𑀼𑀤𑁆𑀥𑁂 𑀲𑀁𑀓𑀺𑀡𑁆𑀡𑁄, 𑀪𑀩𑁆𑀩𑀁 𑀬𑁄𑀕𑁆𑀬𑁂 𑀘 𑀪𑀸𑀯𑀺𑀦𑀺;

𑀲𑀼𑀔𑀼𑀫𑁄 𑀅𑀧𑁆𑀧𑀓𑀸’𑀡𑀽𑀲𑀼, 𑀯𑀼𑀤𑁆𑀥𑁄 𑀣𑁂𑀭𑁂 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑁂.

𑀲𑀼𑀪𑁂 𑀲𑀸𑀥𑀼𑀫𑁆𑀳𑀺 𑀪𑀤𑁆𑀤𑁄 𑀣, 𑀢𑁆𑀬𑀸’𑀤𑁄 𑀘 𑀯𑀺𑀧𑀼𑀮𑁂 𑀩𑀳𑀼;

𑀥𑀻𑀭𑁄 𑀩𑀼𑀥𑁂 𑀥𑀺𑀢𑀺𑀫𑀦𑁆𑀢𑁂, 𑀯𑁂𑀮𑁆𑀮𑀺𑀢𑀁 𑀓𑀼𑀝𑀺𑀮𑁂 𑀥𑀼𑀢𑁂.

𑀯𑀺𑀲𑀤𑁄 ¶ 𑀩𑁆𑀬𑀢𑁆𑀢 𑀲𑁂𑀢𑁂𑀲𑀼, 𑀢𑀭𑀼𑀡𑁄 𑀢𑀼 𑀬𑀼𑀯𑁂 𑀦𑀯𑁂;

𑀬𑁄𑀕𑁆𑀕𑀁 𑀬𑀸𑀦𑁂, 𑀔𑀫𑁂 𑀬𑁄𑀕𑁆𑀕𑁄,

𑀩𑀼𑀥𑁂’𑀪𑀺𑀚𑀸𑀢𑁄 𑀓𑀼𑀮𑀚𑁂, 𑀯𑀼𑀤𑁆𑀥𑁄’𑀭𑀽𑀲𑀼 𑀫𑀳𑀮𑁆𑀮𑀓𑁄;

𑀓𑀮𑁆𑀬𑀸𑀡𑀁 𑀲𑀼𑀦𑁆𑀤𑀭𑁂 𑀘𑀸𑀧𑀺, 𑀳𑀺𑀫𑁄 𑀢𑀼 𑀲𑀻𑀢𑀮𑁂𑀧𑀺 𑀘.

𑀮𑁄𑀮𑁂 𑀢𑀼 𑀲𑀻𑀖𑁂 𑀘𑀧𑀮𑁄, 𑀯𑀼𑀢𑁆𑀢𑁂 𑀉𑀤𑀺𑀢 𑀫𑀼𑀕𑁆𑀕𑀢𑁂;

𑀆𑀤𑀺𑀢𑁆𑀢𑁂 𑀕𑀩𑁆𑀩𑀺𑀢𑁂 𑀤𑀺𑀢𑁆𑀢𑁄, 𑀧𑀺𑀝𑁆𑀞𑀁 𑀢𑀼 𑀘𑀼𑀡𑁆𑀡𑀺𑀢𑁂𑀧𑀺 𑀘.

𑀯𑀺𑀕𑀢𑁂 𑀯𑀸𑀬𑀺𑀢𑁂 [𑀯𑀸𑀬𑀦𑁂 (𑀓.)] 𑀯𑀻𑀢𑀁, 𑀪𑀸𑀯𑀺𑀢𑀁 𑀯𑀟𑁆𑀠𑀺𑀢𑁂𑀧𑀺 𑀘;

𑀪𑀚𑁆𑀚𑀺𑀢𑁂 𑀧𑀢𑀺𑀢𑁂 𑀪𑀝𑁆𑀞𑁄, 𑀧𑀼𑀝𑁆𑀞𑁄 𑀧𑀼𑀘𑁆𑀙𑀺𑀢 𑀧𑁄𑀲𑀺𑀢𑁂.

𑀲𑀽𑀭𑁄 𑀯𑀻𑀭𑁂 𑀭𑀯𑀺𑀲𑀽𑀭𑁂, 𑀤𑀼𑀝𑁆𑀞𑁄 𑀓𑀼𑀤𑁆𑀥𑁂 𑀘 𑀤𑀽𑀲𑀺𑀢𑁂.

𑀤𑀺𑀝𑁆𑀞𑁄’𑀭𑀺𑀫𑁆𑀳𑀺’𑀓𑁆𑀔𑀺𑀢𑁂 𑀤𑀺𑀝𑁆𑀞𑁄 [𑀤𑀺𑀝𑁆𑀞𑀁 (𑀓.)],

𑀦𑀺𑀦𑁆𑀤𑀸𑀬𑀁 𑀔𑁂𑀧𑀦𑁂 𑀔𑁂𑀧𑁄, 𑀦𑀺𑀬𑀫𑁄 𑀦𑀺𑀘𑁆𑀙𑀬𑁂 𑀯𑀢𑁂.

𑀮𑁂𑀧 𑀕𑀩𑁆𑀩𑁂𑀲𑁆𑀯’𑀯𑀮𑁂𑀧𑁄, 𑀅𑀡𑁆𑀟𑀚𑁄 𑀫𑀻𑀦𑀧𑀓𑁆𑀔𑀺𑀲𑀼.

𑀩𑀺𑀮𑀸𑀮𑁂 𑀦𑀓𑀼𑀮𑁂 𑀩𑀩𑁆𑀩𑀼, 𑀫𑀦𑁆𑀣𑁄 𑀫𑀦𑁆𑀣𑀦𑀲𑀢𑁆𑀢𑀼𑀲𑀼;

𑀯𑀸𑀮𑁄 𑀓𑁂𑀲𑁂’𑀲𑁆𑀲𑀸𑀤𑀺𑀮𑁄𑀫𑁂,

𑀕𑁄𑀧𑀕𑀸𑀫𑁂 𑀭𑀯𑁂 𑀖𑁄𑀲𑁄, 𑀲𑀽𑀢𑁄 𑀲𑀸𑀭𑀣𑀺𑀯𑀦𑁆𑀤𑀺𑀲𑀼;

𑀫𑀸𑀮𑁆𑀬𑀁 𑀢𑀼 𑀧𑀼𑀧𑁆𑀨𑁂 𑀢𑀤𑁆𑀤𑀸𑀫𑁂, 𑀯𑀸𑀳𑁄 𑀢𑀼 𑀲𑀓𑀝𑁂 𑀳𑀬𑁂.

𑀔𑀬𑁂’𑀘𑁆𑀘𑀦𑁂 𑀘𑀸’𑀧𑀘𑀬𑁄, 𑀓𑀸𑀮𑁄 𑀲𑀫𑀬 𑀫𑀘𑁆𑀘𑀼𑀲𑀼;

𑀪𑁂 𑀢𑀸𑀭𑀓𑀸 𑀦𑁂𑀢𑁆𑀢𑀫𑀚𑁆𑀛𑁂, 𑀲𑀻𑀫𑀸’ 𑀯𑀥𑀺, 𑀝𑁆𑀞𑀺𑀢𑀻𑀲𑀼 𑀘.

𑀲𑁆𑀯𑀸’𑀴𑀺’𑀢𑁆𑀣𑀻 𑀲𑀔𑀺 𑀲𑁂𑀢𑀼𑀲𑀼;

𑀲𑀢𑁆𑀢𑁂 𑀣𑀽𑀮𑁂 𑀢𑀻𑀲𑀼 𑀤𑀴𑁆𑀳𑁄, 𑀮𑀢𑀸 𑀲𑀸𑀔𑀸𑀬 𑀯𑀮𑁆𑀮𑀺𑀬𑀁.

𑀫𑀼𑀢𑁆𑀢𑀺’𑀢𑁆𑀣𑀻 ¶ 𑀫𑁄𑀘𑀦𑁂 𑀫𑁄𑀓𑁆𑀔𑁂,

𑀦𑀻𑀘𑁂 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀦𑁄 𑀫𑀽𑀴𑁆𑀳𑁂, 𑀪𑀢𑁆𑀢𑀸 𑀲𑀸𑀫𑀺𑀦𑀺 𑀥𑀸𑀭𑀓𑁂.

𑀲𑀺𑀔𑀸, 𑀧𑀺𑀜𑁆𑀙𑁂𑀲𑀼 𑀲𑀺𑀔𑀡𑁆𑀟𑁄, 𑀲𑀢𑁆𑀢𑁂 𑀢𑁆𑀯’𑀢𑁆𑀢𑀦𑀺 𑀧𑀼𑀕𑁆𑀕𑀮𑁄;

𑀯𑀘𑁆𑀘𑁄 𑀭𑀽𑀧𑁂 𑀓𑀭𑀻𑀲𑁂 𑀣, 𑀚𑀼𑀢𑀺’𑀢𑁆𑀣𑀻 𑀓𑀦𑁆𑀢𑀺𑀭𑀁𑀲𑀺𑀲𑀼;

𑀮𑀩𑁆𑀪𑀁 𑀬𑀼𑀢𑁆𑀢𑁂 𑀘 𑀮𑀤𑁆𑀥𑀩𑁆𑀩𑁂, 𑀔𑀡𑁆𑀟𑁂 𑀧𑀡𑁆𑀡𑁂 𑀤𑀮𑀁 𑀫𑀢𑀁;

𑀲𑀮𑁆𑀮𑀁 𑀓𑀡𑁆𑀟𑁂 𑀲𑀮𑀸𑀓𑀸𑀬𑀁, 𑀲𑀼𑀘𑀺𑀢𑁆𑀢𑁂 𑀥𑀸𑀯𑀦𑀁 𑀕𑀢𑁂;

𑀪𑀦𑁆𑀢𑀢𑁆𑀣𑁂 𑀯𑀺𑀩𑁆𑀪𑀫𑁄 𑀳𑀸𑀯𑁂, 𑀫𑁄𑀳𑁄’𑀯𑀺𑀚𑁆𑀚𑀸𑀬 𑀫𑀼𑀘𑁆𑀙𑀦𑁂.

𑀫𑀺𑀢𑁆𑀢𑁂 𑀲𑀳𑀸𑀬𑁂 𑀘 𑀲𑀔𑀸, 𑀯𑀺𑀪𑀽 𑀦𑀺𑀘𑁆𑀘𑀧𑁆𑀧𑀪𑀽𑀲𑀼 𑀲𑁄.

𑀔𑀕𑁆𑀕𑁂 𑀓𑀼𑀭𑀽𑀭𑁂 𑀦𑁂𑀢𑁆𑀢𑀺𑀁𑀲𑁄, 𑀧𑀭𑀲𑁆𑀫𑀺𑀁 𑀅𑀢𑁆𑀭 𑀢𑀻𑀲𑁆𑀯’𑀫𑀼;

𑀧𑀚𑁆𑀚𑁂 𑀕𑀸𑀣𑀸 𑀯𑀘𑀻𑀪𑁂𑀤𑁂, 𑀯𑀁𑀲𑁄 𑀢𑁆𑀯’𑀦𑁆𑀯𑀬𑀯𑁂𑀡𑀼𑀲𑀼;

𑀬𑀸𑀦𑀁 𑀭𑀣𑀸𑀤𑁄 𑀕𑀫𑀦𑁂, 𑀲𑀭𑀽𑀧𑀲𑁆𑀫𑀺𑀁 𑀅𑀥𑁄 𑀢𑀮𑀁.

𑀫𑀚𑁆𑀛𑁄 𑀯𑀺𑀮𑀕𑁆𑀕𑁂 𑀯𑁂𑀫𑀚𑁆𑀛𑁂, 𑀧𑀼𑀧𑁆𑀨𑀁 𑀢𑀼 𑀓𑀼𑀲𑀼𑀫𑁄’𑀢𑀼𑀲𑀼;

𑀲𑀻𑀮𑀁 𑀲𑀪𑀸𑀯𑁂 𑀲𑀼𑀩𑁆𑀩𑀢𑁂, 𑀧𑀼𑀗𑁆𑀕𑀯𑁄 𑀉𑀲𑀪𑁂 𑀯𑀭𑁂.

𑀓𑁄𑀲𑁂 𑀔𑀕𑀸𑀤𑀺𑀩𑀻𑀚𑁂’𑀡𑁆𑀟𑀁, 𑀓𑀼𑀳𑀭𑀁 𑀕𑀩𑁆𑀪𑀭𑁂 𑀩𑀺𑀮𑁂;

𑀦𑁂𑀢𑁆𑀢𑀺𑀁𑀲𑁂 𑀕𑀡𑁆𑀟𑀓𑁂 𑀔𑀕𑁆𑀕𑁄, 𑀓𑀤𑀫𑁆𑀩𑁄 𑀢𑀼 𑀤𑀼𑀫𑁂 𑀘𑀬𑁂.

𑀪𑁂’𑀥𑁂𑀦𑀼𑀬𑀁 𑀭𑁄𑀳𑀺𑀡𑀻’𑀢𑁆𑀣𑀻, 𑀯𑀭𑀗𑁆𑀕𑀁 𑀬𑁄𑀦𑀺𑀬𑀁 𑀲𑀺𑀭𑁂;

𑀅𑀓𑁆𑀓𑁄𑀲𑁂 𑀲𑀧𑀣𑁂 𑀲𑀸𑀧𑁄, 𑀧𑀗𑁆𑀓𑀁 𑀧𑀸𑀧𑁂 𑀘 𑀓𑀤𑁆𑀤𑀫𑁂.

𑀪𑁄𑀕𑀯𑀢𑁆𑀬𑀼’𑀭𑀕𑁂 𑀪𑁄𑀕𑀻, 𑀲𑁆𑀲𑀭𑁄 𑀢𑀼 𑀲𑀺𑀯𑀲𑀸𑀫𑀺𑀲𑀼;

𑀩𑀮𑁂 𑀧𑀪𑀸𑀯𑁂 𑀯𑀻𑀭𑀺𑀬𑀁, 𑀢𑁂𑀚𑁄 𑀢𑁂𑀲𑀼 𑀘 𑀤𑀺𑀢𑁆𑀢𑀺𑀬𑀁.

𑀥𑀸𑀭𑀸 𑀲𑀦𑁆𑀢𑀢𑀺 𑀔𑀕𑁆𑀕𑀗𑁆𑀕𑁂, 𑀯𑀸𑀦𑀁 𑀢𑀡𑁆𑀳𑀸𑀬 𑀲𑀺𑀩𑁆𑀩𑀦𑁂;

𑀔𑀢𑁆𑀢𑀸 𑀲𑀽𑀢𑁂 𑀧𑀝𑀺𑀳𑀸𑀭𑁂, 𑀯𑀺𑀢𑁆𑀢𑀺 𑀧𑀻𑀴𑀸𑀲𑀼 𑀯𑁂𑀤𑀦𑀸.

𑀣𑀺𑀬𑀁 ¶ 𑀫𑀢𑀺’𑀘𑁆𑀙𑀸𑀧𑀜𑁆𑀜𑀸𑀲𑀼, 𑀧𑀸𑀧𑁂 𑀬𑀼𑀤𑁆𑀥𑁂 𑀭𑀯𑁂 𑀭𑀡𑁄;

𑀮𑀯𑁄𑀢𑀼 𑀩𑀺𑀦𑁆𑀤𑀼’𑀘𑁆𑀙𑁂𑀤𑁂𑀲𑀼, 𑀧𑀮𑀸𑀮𑁂’ [𑀧𑀮𑀸𑀲𑁂 (𑀝𑀻.), 𑀧𑀮𑀸𑀧𑁂-𑀝𑀻 (𑁪𑁫𑁩-𑁧𑁧𑁨𑁪) 𑀕𑀸𑀣𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸] 𑀢𑀺𑀲𑀬𑁂 𑀪𑀼𑀲𑀁.

𑀩𑀸𑀥𑀸 𑀤𑀼𑀓𑁆𑀔𑁂 𑀦𑀺𑀲𑁂𑀥𑁂 𑀘, 𑀫𑀽𑀮𑀧𑀤𑁂𑀧𑀺 𑀫𑀸𑀢𑀺𑀓𑀸;

𑀲𑁆𑀦𑁂𑀳𑁄 𑀢𑁂𑀮𑁂’𑀥𑀺𑀓𑀧𑁆𑀧𑁂𑀫𑁂,

𑀓𑁂𑀢𑀼𑀲𑁆𑀫𑀺𑀁 𑀓𑁂𑀢𑀦𑀁 𑀕𑁂𑀳𑁂, 𑀞𑀸𑀦𑁂 𑀪𑀽𑀫𑀺’𑀢𑁆𑀣𑀺𑀬𑀁 𑀪𑀼𑀯𑀺;

𑀮𑁂𑀔𑁆𑀬𑁂 𑀮𑁂𑀔𑁄 𑀭𑀸𑀚𑀺 𑀮𑁂𑀔𑀸, 𑀧𑀽𑀚𑀺𑀢𑁂 𑀪𑀕𑀯𑀸 𑀚𑀺𑀦𑁂.

𑀕𑀤𑀸 𑀲𑀢𑁆𑀣𑁂 𑀕𑀤𑁄 𑀭𑁄𑀕𑁂, 𑀦𑀺𑀲𑀚𑁆𑀚𑀸 𑀧𑀻𑀞𑁂𑀲𑁆𑀯𑀸’𑀲𑀦𑀁;

𑀩𑀺𑀮𑀁 𑀓𑁄𑀝𑁆𑀞𑀸𑀲 𑀙𑀺𑀤𑁆𑀤𑁂𑀲𑀼, 𑀯𑀚𑁆𑀚𑀁 𑀤𑁄𑀲𑁂 𑀘 𑀪𑁂𑀭𑀺𑀬𑀁;

𑀓𑀸𑀮𑁂 𑀤𑀻𑀖𑀜𑁆𑀚𑀲𑁂’𑀤𑁆𑀥𑀸𑀦𑀁, 𑀆𑀮𑀺𑀬𑀁 𑀲𑁂𑀢𑀼 𑀓𑀸𑀭𑀡𑁂.

𑀬𑀽𑀧𑁄 𑀣𑀫𑁆𑀪𑁂 𑀘 𑀧𑀸𑀲𑀸𑀤𑁂, 𑀅𑀬𑀦𑀁 𑀕𑀫𑀦𑁂 𑀧𑀣𑁂.

𑀅𑀓𑁆𑀓𑁄 𑀭𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑀭𑁂 𑀲𑀽𑀭𑁂,

𑀅𑀁𑀲𑁄 𑀔𑀦𑁆𑀥𑁂 𑀘 𑀓𑁄𑀝𑁆𑀞𑀸𑀲𑁂,

𑀚𑀸𑀮𑀁 𑀲𑀽𑀲𑁆𑀯’𑀘𑁆𑀘𑀺 𑀦𑁄 𑀧𑀼𑀫𑁂.

𑀦𑀸𑀲𑀸’𑀲𑀢𑁆𑀢𑁂𑀲𑁆𑀯’ 𑀪𑀸𑀯𑁄 𑀣,

𑀖𑀸𑀲𑁄 𑀢𑁆𑀯’𑀦𑁆𑀦𑁂 𑀘 𑀪𑀓𑁆𑀔𑀡𑁂.

𑀙𑀤𑀦𑁂’𑀘𑁆𑀙𑀸𑀤𑀦𑀁 𑀯𑀢𑁆𑀣𑁂, 𑀦𑀺𑀓𑀸𑀬𑁄 𑀕𑁂𑀳𑀭𑀸𑀲𑀺𑀲𑀼;

𑀅𑀦𑁆𑀦𑀸𑀤𑁄 𑀆𑀫𑀺𑀲𑀁 𑀫𑀁𑀲𑁂; 𑀤𑀺𑀓𑁆𑀔𑀸 𑀢𑀼 𑀬𑀚𑀦𑁂’𑀘𑁆𑀘𑀦𑁂.

𑀓𑁆𑀭𑀺𑀬𑀸𑀬𑀁 𑀓𑀸𑀭𑀺𑀓𑀸 𑀧𑀚𑁆𑀚𑁂,

𑀓𑀼𑀲𑀼𑀫𑀁 𑀣𑀻𑀭𑀚𑁂 𑀧𑀼𑀧𑁆𑀨𑁂, 𑀯𑀸𑀦𑀭𑁂 𑀢𑀼 𑀩𑀼𑀥𑁂 𑀓𑀯𑀺.

𑀅𑀥𑀭𑁂 ¶ 𑀔𑀭𑀪𑁂 𑀑𑀝𑁆𑀞𑁄, 𑀮𑀼𑀤𑁆𑀤𑁄 𑀢𑀼 𑀮𑀼𑀤𑁆𑀤𑀓𑁂𑀧𑀺 𑀘;

𑀓𑀮𑀼𑀲𑀁 𑀢𑁆𑀯𑀸’𑀯𑀺𑀮𑁂 𑀧𑀸𑀧𑁂, 𑀧𑀸𑀧𑁂 𑀓𑀮𑀺 𑀧𑀭𑀸𑀚𑀬𑁂.

𑀓𑀦𑁆𑀢𑀸𑀭𑁄 𑀯𑀦, 𑀤𑀼𑀕𑁆𑀕𑁂𑀲𑀼, 𑀘𑀭𑁄 𑀘𑀸𑀭𑀫𑁆𑀳𑀺 𑀘𑀜𑁆𑀘𑀮𑁂;

𑀚𑀦𑀸𑀯𑀸𑀲𑁂 𑀕𑀡𑁂 𑀕𑀸𑀫𑁄, 𑀘𑀫𑁆𑀫𑀁 𑀢𑀼 𑀨𑀮𑀓𑁂 𑀢𑀘𑁂.

𑀲𑀢𑁆𑀢𑀸𑀬𑀁 𑀪𑀯𑀦𑀁 𑀕𑁂𑀳𑁂, 𑀮𑁂𑀲𑁂 𑀢𑀼 𑀔𑀮𑀺𑀢𑁂 𑀙𑀮𑀁.

𑀯𑁂𑀭𑀁 𑀧𑀸𑀧𑁂 𑀘 𑀧𑀝𑀺𑀖𑁂, 𑀢𑀘𑁄 𑀘𑀫𑁆𑀫𑀦𑀺 𑀯𑀓𑁆𑀓𑀮𑁂;

𑀉𑀘𑁆𑀘𑁂’𑀥𑀺𑀭𑁄𑀳𑁂 𑀆𑀭𑁄𑀳𑁄, 𑀦𑁂𑀢𑁆𑀢𑀁 𑀯𑀢𑁆𑀣𑀦𑁆𑀢𑀭’𑀓𑁆𑀔𑀺𑀲𑀼.

𑀧𑀝𑀺𑀳𑀸𑀭𑁂 𑀫𑀼𑀔𑁂 𑀤𑁆𑀯𑀸𑀭𑀁, 𑀧𑁂𑀢𑁂 𑀜𑀸𑀢𑁂 𑀫𑀢𑁄 𑀢𑀺𑀲𑀼;

𑀫𑀸𑀲𑁄 𑀧𑀭𑀡𑁆𑀡 𑀓𑀸𑀮𑁂𑀲𑀼, 𑀦𑀕𑁆𑀕𑁄 𑀢𑁆𑀯’𑀘𑁂𑀮𑀓𑁂𑀧𑀺 𑀘.

𑀤𑁄𑀲𑁂 𑀖𑀸𑀢𑁂 𑀘 𑀧𑀝𑀺𑀖𑁄, 𑀫𑀺𑀕𑀸𑀤𑁄 𑀙𑀕𑀮𑁂 𑀧𑀲𑀼;

𑀅𑀭𑀽𑀧𑁂 𑀘𑀸’𑀯𑁆𑀳𑀬𑁂 𑀦𑀸𑀫𑀁, 𑀤𑀭𑁄 𑀤𑀭𑀣 𑀪𑀻𑀢𑀺𑀲𑀼.

𑀤𑀩𑁆𑀩𑀺’𑀦𑁆𑀤𑀚𑀸𑀬𑀸𑀲𑀼 𑀲𑀼𑀚𑀸, 𑀫𑁂𑀖𑁂 𑀢𑁆𑀯’𑀩𑁆𑀪𑀁 𑀯𑀺𑀳𑀸𑀬𑀲𑁂.

𑀫𑁄𑀤𑀓𑁄 𑀔𑀚𑁆𑀚𑀪𑁂𑀤𑁂𑀧𑀺, 𑀫𑀡𑀺𑀓𑁂 𑀭𑀢𑀦𑁂 𑀫𑀡𑀺;

𑀳𑀯𑀺 𑀲𑀧𑁆𑀧𑀺𑀫𑁆𑀳𑀺 𑀳𑁄𑀢𑀩𑁆𑀩𑁂, 𑀲𑀺𑀭𑁄 𑀲𑁂𑀝𑁆𑀞𑁂 𑀘 𑀫𑀼𑀤𑁆𑀥𑀦𑀺;

𑀯𑀺𑀘𑀸𑀭𑁂𑀧𑀺 𑀯𑀺𑀯𑁂𑀓𑁄 𑀣, 𑀲𑀺𑀔𑀭𑀻 𑀧𑀩𑁆𑀩𑀢𑁂 𑀤𑀼𑀫𑁂.

𑀯𑁂𑀕𑁄 𑀚𑀯𑁂 𑀧𑀯𑀸𑀳𑁂 𑀘, 𑀲𑀗𑁆𑀓𑀼 𑀢𑀼 𑀔𑀺𑀮𑀳𑁂𑀢𑀺𑀲𑀼;

𑀦𑀺𑀕𑁆𑀕𑀳𑀻𑀢𑁂 𑀓𑀡𑁂 𑀩𑀺𑀦𑁆𑀤𑀼, 𑀯𑀭𑀸𑀳𑁄 𑀲𑀽𑀓𑀭𑁂 𑀕𑀚𑁂.

𑀦𑁂𑀢𑁆𑀢𑀦𑁆𑀢𑁂 𑀘𑀺𑀢𑁆𑀢𑀓𑁂’𑀧𑀸𑀗𑁆𑀕𑀁, 𑀲𑀺𑀤𑁆𑀥𑀢𑁆𑀣𑁄 𑀲𑀸𑀲𑀧𑁂 𑀚𑀺𑀦𑁂;

𑀲𑁆𑀯𑀧𑁆𑀧𑁂’𑀯𑀥𑀸𑀭𑀡𑁂 𑀫𑀢𑁆𑀢𑀁, 𑀅𑀧𑀘𑀺𑀢𑁆𑀬’𑀘𑁆𑀘𑀦𑁂 𑀔𑀬𑁂.

𑀙𑀺𑀤𑁆𑀤𑁄’𑀢𑀭𑀡𑁂𑀲𑁆𑀯𑁄’𑀢𑀸𑀭𑁄,

𑀧𑀺𑀢𑀸𑀫𑀳𑁄’𑀬𑁆𑀬𑀓𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑁂,

𑀭𑀼𑀓𑁆𑀔𑁂 𑀯𑀡𑁆𑀡𑁂 𑀲𑀼𑀦𑁂 𑀲𑁄𑀡𑁄,

𑀯𑀢𑁆𑀣𑁂 𑀕𑀦𑁆𑀥𑁂 𑀖𑀭𑁂 𑀯𑀸𑀲𑁄, 𑀘𑀼𑀮𑁆𑀮𑁄 𑀔𑀼𑀤𑁆𑀤𑁂 𑀘 𑀉𑀤𑁆𑀥𑀦𑁂.

𑀫𑀸𑀮𑀸 𑀧𑀼𑀧𑁆𑀨𑁂 𑀘 𑀧𑀦𑁆𑀢𑀺𑀬𑀁;

𑀲𑁂𑀬𑁆𑀬𑀸 𑀲𑁂𑀦𑀸𑀲𑀦𑁂 𑀲𑁂𑀦𑁂, 𑀘𑀼𑀦𑁆𑀤𑀪𑀡𑁆𑀟𑀫𑁆𑀳𑀺 𑀘’𑀩𑁆𑀪𑀫𑁄;

𑀯𑀢𑁆𑀣𑀸𑀤𑀺𑀮𑁄𑀫𑀁’𑀲𑀼 𑀓𑀭𑁂, 𑀦𑀺𑀧𑀸𑀢𑁄 𑀧𑀢𑀦𑁂’𑀩𑁆𑀬𑀬𑁂.

𑀲𑀸𑀔𑀸𑀬𑀁 𑀯𑀺𑀝𑀧𑁄 𑀣𑀫𑁆𑀪𑁂, 𑀲𑀢𑁆𑀢𑀼 𑀔𑀚𑁆𑀚𑀦𑁆𑀢𑀭𑁂 𑀤𑀺𑀲𑁂;

𑀲𑀸𑀫𑀺𑀓𑁄 𑀧𑀢𑀺’𑀬𑀺𑀭𑁂𑀲𑀼, 𑀧𑀝𑁆𑀞𑀸𑀦𑀁 𑀕𑀢𑀺 𑀳𑁂𑀢𑀼𑀲𑀼.

𑀭𑀸𑀕𑁂 𑀭𑀗𑁆𑀕𑁄 𑀦𑀘𑁆𑀘𑀝𑁆𑀞𑀸𑀦𑁂, 𑀧𑀸𑀦𑀁 𑀧𑁂𑀬𑁆𑀬𑁂 𑀘 𑀧𑀻𑀢𑀺𑀬𑀁;

𑀇𑀡𑀼’𑀓𑁆𑀔𑁂𑀧𑁂𑀲𑀼 𑀉𑀤𑁆𑀥𑀸𑀭𑁄, 𑀉𑀫𑁆𑀫𑀸𑀭𑁂 𑀏𑀴𑀓𑁄 𑀅𑀚𑁂.

𑀓𑀼𑀡𑁆𑀟𑀺𑀓𑀸𑀬𑀸’𑀴𑁆𑀳𑀓𑁂 𑀢𑀼𑀫𑁆𑀩𑁄,

𑀧𑀮𑀸𑀮𑁄 [𑀧𑀮𑀸𑀧𑁄 (𑀓.) 𑁪𑁫𑁩-𑀕𑀸𑀣𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸] 𑀢𑀼 𑀪𑀼𑀲𑀫𑁆𑀳𑀺 𑀘.

𑀫𑀢𑀸’𑀯𑀸𑀝𑁂 𑀘𑀬𑁂 𑀓𑀸𑀲𑀼, 𑀧𑀦𑀺𑀲𑀸 𑀓𑀸𑀭𑀡𑁂 𑀭𑀳𑁄;

𑀬𑀼𑀢𑁆𑀬’𑀝𑁆𑀝𑀸𑀮’𑀝𑁆𑀝𑀺𑀢𑁂𑀲𑁆𑀯’𑀝𑁆𑀝𑁄, 𑀓𑀻𑀴𑀸𑀬𑀁 𑀓𑀸𑀦𑀦𑁂 𑀤𑀯𑁄;

𑀉𑀧𑁆𑀧𑀢𑁆𑀢𑀺𑀬𑀁 𑀘𑁄’𑀧𑁆𑀧𑀢𑀦𑀁, 𑀉𑀬𑁆𑀬𑀸𑀦𑀁 𑀕𑀫𑀦𑁂 𑀯𑀦𑁂.

𑀯𑁄𑀓𑀸𑀭𑁄 𑀮𑀸𑀫𑀓𑁂 𑀔𑀦𑁆𑀥𑁂, 𑀫𑀽𑀮𑁄’𑀧𑀤𑀸𑀲𑀼 𑀧𑀸𑀪𑀢𑀁;

𑀤𑀲𑀸’ 𑀯𑀢𑁆𑀣𑀸 𑀧𑀝𑀦𑁆𑀢𑁂𑀲𑀼, 𑀓𑀸𑀭𑀡𑀁 𑀖𑀸𑀢, 𑀳𑁂𑀢𑀼𑀲𑀼.

𑀳𑀢𑁆𑀣𑀺𑀤𑀸𑀦𑁂 ¶ 𑀫𑀤𑁄 𑀕𑀩𑁆𑀩𑁂, 𑀖𑀝𑀸 𑀖𑀝𑀦 𑀭𑀸𑀲𑀺𑀲𑀼;

𑀉𑀧𑀳𑀸𑀭𑁄’𑀪𑀺𑀳𑀸𑀭𑁂𑀧𑀺, 𑀘𑀬𑁄 𑀩𑀦𑁆𑀥𑀦 𑀭𑀸𑀲𑀺𑀲𑀼.

𑀧𑀸𑀦𑁂 𑀧𑀫𑁄𑀤𑁂 𑀧𑀻𑀢𑀺’𑀢𑁆𑀣𑀻, 𑀇𑀡𑁂 𑀕𑀺𑀯𑀸 𑀕𑀮𑁂𑀧𑀺 𑀘.

𑀧𑀢𑀺𑀝𑁆𑀞𑀸 𑀦𑀺𑀲𑁆𑀲𑀬𑁂 𑀞𑀸𑀦𑁂, 𑀩𑀮𑀓𑁆𑀓𑀸𑀭𑁂𑀧𑀺 𑀲𑀸𑀳𑀲𑀁;

𑀪𑀗𑁆𑀕𑁄 𑀪𑁂𑀤𑁂 𑀧𑀝𑁂 𑀪𑀗𑁆𑀕𑀁, 𑀙𑀢𑁆𑀢𑀁 𑀢𑀼 𑀙𑀯𑀓𑁂𑀧𑀺 𑀘.

𑀜𑀸𑀡𑁂 𑀪𑀼𑀯𑀺 𑀘 𑀪𑀽𑀭𑀺’𑀢𑁆𑀢𑀻, 𑀅𑀦𑀗𑁆𑀕𑁂 𑀫𑀤𑀦𑁄 𑀤𑀼𑀫𑁂;

𑀧𑀫𑀸𑀢𑀭𑀺𑀧𑀺 𑀫𑀸𑀢𑀸 𑀣, 𑀯𑁂𑀞𑀼’𑀡𑀻𑀲𑁂𑀲𑀼 𑀯𑁂𑀞𑀦𑀁.

𑀫𑀸𑀭𑀺𑀲𑁄 𑀢𑀡𑁆𑀟𑀼𑀮𑁂𑀬𑁆𑀬𑁂’𑀬𑁆𑀬𑁂,

𑀫𑁄𑀓𑁆𑀔𑁄 𑀦𑀺𑀩𑁆𑀩𑀸𑀦 𑀫𑀼𑀢𑁆𑀢𑀺𑀲𑀼;

𑀇𑀦𑁆𑀤𑁄’𑀥𑀺𑀧𑀢𑀺 𑀲𑀓𑁆𑀓𑁂𑀲𑁆𑀯𑀸, 𑀭𑀫𑁆𑀫𑀡𑀁 𑀳𑁂𑀢𑀼 𑀕𑁄𑀘𑀭𑁂.

𑀔𑁂𑀢𑁆𑀢𑁂 [𑀯𑀧𑁆𑀧𑁂 (𑀧𑀸𑀓𑀸𑀭𑀫𑀽𑀮𑁂 𑀦𑁂𑀢𑁆𑀢𑀚𑀮𑁂 𑀉𑀲𑀼𑀫𑁂 𑀘 𑀯𑀧𑁆𑀧𑁄-𑀝𑀻)] 𑀯𑀧𑁆𑀧𑁄 𑀢𑀝𑁂𑀧𑀺 𑀘;

𑀲𑀫𑁆𑀫𑀼𑀢𑁆𑀬’𑀦𑀼𑀜𑁆𑀜𑀸 𑀯𑁄𑀳𑀸𑀭𑁂, 𑀲𑁆𑀯’𑀣 𑀮𑀸𑀚𑀸𑀲𑀼 𑀘𑀸’𑀓𑁆𑀔𑀢𑀁.

𑀲𑀗𑁆𑀖𑀸𑀢𑁄 𑀬𑀼𑀕𑀕𑁂𑀳𑀗𑁆𑀕𑁂, 𑀔𑀸𑀭𑁄 𑀊𑀲𑁂 𑀘 𑀪𑀲𑁆𑀫𑀦𑀺.

𑀅𑀦𑁂𑀓𑀢𑁆𑀣𑀯𑀕𑁆𑀕𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀅𑀩𑁆𑀬𑀬𑀁 𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀤𑀸𑀦𑀺, 𑀘𑀺𑀭𑀲𑁆𑀲𑀁 𑀢𑀼 𑀘𑀺𑀭𑀁 𑀢𑀣𑀸;

𑀘𑀺𑀭𑁂𑀦 𑀘𑀺𑀭𑀭𑀢𑁆𑀢𑀸𑀬, 𑀲𑀳 𑀲𑀤𑁆𑀥𑀺𑀁 𑀲𑀫𑀁 𑀅𑀫𑀸.

𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁 ¶ 𑀅𑀪𑀺𑀡𑁆𑀳𑀜𑁆𑀘𑀸, 𑀲𑀓𑀺𑀁 𑀘𑀸’𑀪𑀺𑀓𑁆𑀔𑀡𑀁 𑀫𑀼𑀳𑀼𑀁;

𑀯𑀚𑁆𑀚𑀦𑁂 𑀢𑀼 𑀯𑀺𑀦𑀸 𑀦𑀸𑀦𑀸, 𑀅𑀦𑁆𑀢𑀭𑁂𑀦 𑀭𑀺𑀢𑁂 𑀧𑀼𑀣𑀼.

𑀩𑀮𑀯𑀁 𑀲𑀼𑀝𑁆𑀞𑀼 𑀘𑀸’𑀢𑀻𑀯𑀸, 𑀢𑀺𑀲𑀬𑁂 𑀓𑀺𑀫𑀼𑀢 𑀲𑁆𑀯’𑀢𑀺;

𑀅𑀳𑁄 𑀢𑀼 𑀓𑀺𑀁 𑀓𑀺𑀫𑀽’ 𑀤𑀸𑀳𑀼, 𑀯𑀺𑀓𑀧𑁆𑀧𑁂 𑀓𑀺𑀫𑀼𑀢𑁄’𑀤 𑀘.

𑀳𑁂 𑀳𑀭𑁂 𑀣 𑀓𑀣𑀁 𑀓𑀺𑀁𑀲𑀼, 𑀦𑀦𑀼 𑀓𑀘𑁆𑀘𑀺 𑀦𑀼 𑀓𑀺𑀁 𑀲𑀫𑀸.

𑀅𑀥𑀼𑀦𑁂’𑀢𑀭𑀳𑀻’𑀤𑀸𑀦𑀺, 𑀲𑀫𑁆𑀧𑀢𑀺 𑀅𑀜𑁆𑀜𑀤𑀢𑁆𑀣𑀼 𑀢𑀼;

𑀢𑀕𑁆𑀖𑁂’ 𑀓𑀁𑀲𑁂 𑀲𑀲𑀓𑁆𑀓𑀜𑁆𑀘𑀸, 𑀤𑁆𑀥𑀸 𑀓𑀸𑀫𑀁 𑀚𑀸𑀢𑀼 𑀯𑁂 𑀳𑀯𑁂.

𑀬𑀸𑀯𑀢𑀸 𑀢𑀸𑀯𑀢𑀸 𑀬𑀸𑀯, 𑀢𑀸𑀯 𑀓𑀺𑀢𑁆𑀢𑀸𑀯𑀢𑀸 𑀢𑀣𑀸;

𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀸 𑀘 𑀓𑀻𑀯𑁂’𑀢𑀺, 𑀧𑀭𑀺𑀘𑁆𑀙𑁂𑀤𑀢𑁆𑀣𑀯𑀸𑀘𑀓𑀸.

𑀬𑀣𑀸 𑀢𑀣𑀸 𑀬𑀣𑁂𑀯𑁂’𑀯𑀁, 𑀬𑀣𑀸𑀦𑀸𑀫 𑀬𑀣𑀸𑀳𑀺 𑀘;

𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑁆𑀬𑁂’𑀯𑀫𑁂𑀯𑀁, 𑀯𑀸, 𑀢𑀣𑁂𑀯 𑀘 𑀬𑀣𑀸𑀧𑀺 𑀘.

𑀏𑀯𑀫𑁆𑀧𑀺 𑀘 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀦𑀸𑀫 𑀬𑀣𑀭𑀺𑀯𑀸’𑀧𑀺 𑀘;

𑀧𑀝𑀺𑀪𑀸𑀕𑀢𑁆𑀣𑁂 𑀬𑀣𑀸𑀘, 𑀯𑀺𑀬 𑀢𑀣𑀭𑀺𑀯𑀸’𑀧𑀺 𑀘.

𑀲𑀁 𑀲𑀸𑀫𑀜𑁆𑀘 𑀲𑀬𑀁 𑀘𑀸𑀣, 𑀆𑀫 𑀲𑀸𑀳𑀼 𑀮𑀳𑀽’𑀧𑀺 𑀘;

𑀑𑀧𑀸𑀬𑀺𑀓𑀁 𑀧𑀢𑀺𑀭𑀽𑀧𑀁, 𑀲𑀸𑀥𑁆𑀯𑁂’𑀯𑀁 𑀲𑀫𑁆𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁂.

𑀅𑀲𑀸𑀓𑀮𑁆𑀬𑁂 𑀢𑀼 𑀘𑀦 𑀘𑀺, 𑀦𑀺𑀧𑁆𑀨𑀮𑁂 𑀢𑀼 𑀫𑀼𑀥𑀸 𑀪𑀯𑁂.

𑀓𑀤𑀸𑀘𑀺 𑀚𑀸𑀢𑀼 𑀢𑀼𑀮𑁆𑀬𑀸’𑀣, 𑀲𑀩𑁆𑀩𑀢𑁄 𑀘 𑀲𑀫𑀦𑁆𑀢𑀢𑁄;

𑀧𑀭𑀺𑀢𑁄 𑀘 𑀲𑀫𑀦𑁆𑀢𑀸𑀧𑀺, 𑀅𑀣 𑀫𑀺𑀘𑁆𑀙𑀸 𑀫𑀼𑀲𑀸 𑀪𑀯𑁂.

𑀦𑀺𑀲𑁂𑀥𑁂 𑀦 𑀅𑀦𑁄𑀫𑀸’𑀮𑀁, 𑀦𑀳𑀺 𑀘𑁂𑀢𑀼 𑀲𑀘𑁂 𑀬𑀤𑀺;

𑀦𑀢𑁆𑀢𑀁 [𑀭𑀢𑁆𑀢𑀁 (𑀝𑀻.)] 𑀤𑁄𑀲𑁄 𑀤𑀺𑀯𑀸 𑀢𑁆𑀯’𑀳𑁂.

𑀈𑀲𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀫𑀦𑀁 𑀅𑀧𑁆𑀧𑁂, 𑀲𑀳𑀲𑀸 𑀢𑀼 𑀅𑀢𑀓𑁆𑀓𑀺𑀢𑁂;

𑀧𑀼𑀭𑁂 𑀕𑁆𑀕𑀢𑁄 𑀢𑀼 𑀧𑀼𑀭𑀢𑁄, 𑀧𑁂𑀘𑁆𑀘𑀸’𑀫𑀼𑀢𑁆𑀭𑀪𑀯𑀦𑁆𑀢𑀭𑁂.

𑀅𑀳𑁄 ¶ 𑀳𑀻 𑀯𑀺𑀫𑁆𑀳𑀬𑁂 𑀢𑀼𑀡𑁆𑀳𑀻,

𑀢𑀗𑁆𑀔𑀡𑁂 𑀲𑀚𑁆𑀚𑀼 𑀲𑀧𑀤𑀺, 𑀩𑀮𑀓𑁆𑀓𑀸𑀭𑁂 𑀧𑀲𑀬𑁆𑀳 𑀘.

𑀲𑀼𑀤𑀁 𑀔𑁄 [𑀯𑁄 (𑀓.)] 𑀅𑀲𑁆𑀲𑀼 𑀬𑀕𑁆𑀖𑁂 𑀯𑁂,𑀳𑀸’𑀤𑀬𑁄 𑀧𑀤𑀧𑀽𑀭𑀡𑁂;

𑀅𑀦𑁆𑀢𑀭𑁂𑀦’𑀦𑁆𑀢𑀭𑀸 𑀅𑀦𑁆𑀢𑁄, 𑀯𑀲𑁆𑀲𑀁 𑀦𑀽𑀦 𑀘 𑀦𑀺𑀘𑁆𑀙𑀬𑁂.

𑀆𑀦𑀦𑁆𑀤𑁂 𑀲𑀜𑁆𑀘 𑀤𑀺𑀝𑁆𑀞𑀸 𑀣, 𑀯𑀺𑀭𑁄𑀥𑀓𑀣𑀦𑁂 𑀦𑀦𑀼;

𑀓𑀸𑀫𑀧𑁆𑀧𑀯𑁂𑀤𑀦𑁂 𑀓𑀘𑁆𑀘𑀺, 𑀉𑀲𑀽𑀬𑁄𑀧𑀕𑀫𑁂’𑀢𑁆𑀣𑀼 𑀘.

𑀏𑀯𑀸’𑀯𑀥𑀸𑀭𑀡𑁂 𑀜𑁂𑀬𑁆𑀬𑀁, 𑀬𑀣𑀸𑀢𑁆𑀢𑀁 𑀢𑀼 𑀬𑀣𑀸𑀢𑀣𑀁;

𑀦𑀻𑀘𑀁 𑀅𑀧𑁆𑀧𑁂, 𑀫𑀳𑀢𑁆𑀬𑀼’𑀘𑁆𑀘𑀁, 𑀅𑀣 𑀧𑀸𑀢𑁄 𑀧𑀕𑁂 𑀲𑀫𑀸.

𑀦𑀺𑀘𑁆𑀘𑁂 𑀲𑀤𑀸 𑀲𑀦𑀁 [𑀲𑀦𑀸 (𑀓.)] 𑀧𑀸𑀬𑁄,

𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀩𑀸𑀳𑀺𑀭𑀸 𑀩𑀸𑀳𑁆𑀬𑁂, 𑀲𑀻𑀖𑁂𑀢𑀼 𑀲𑀡𑀺𑀓𑀁 𑀪𑀯𑁂.

𑀅𑀢𑁆𑀣𑀁 𑀅𑀤𑀲𑁆𑀲𑀦𑁂 𑀤𑀼𑀝𑁆𑀞𑀼, 𑀦𑀺𑀦𑁆𑀤𑀸𑀬𑀁, 𑀯𑀦𑁆𑀤𑀦𑁂 𑀦𑀫𑁄;

𑀲𑀫𑁆𑀫𑀸 𑀲𑀼𑀝𑁆𑀞𑀼 𑀧𑀲𑀁𑀲𑀸𑀬𑀁, 𑀅𑀣𑁄 𑀲𑀢𑁆𑀢𑀸𑀬 𑀫𑀢𑁆𑀣𑀺 𑀘.

𑀲𑀸𑀬𑀁 𑀲𑀸𑀬𑁂’𑀚𑁆𑀚 𑀅𑀢𑁆𑀭𑀸’𑀳𑁂,

𑀢𑀢𑁄 𑀧𑀭𑁂 𑀧𑀭𑀲𑀼𑀯𑁂, 𑀳𑀺𑀬𑁆𑀬𑁄𑀢𑀼 𑀤𑀺𑀯𑀲𑁂 𑀕𑀢𑁂.

𑀬𑀢𑁆𑀣 𑀬𑀢𑁆𑀭 𑀬𑀳𑀺𑀁𑀘𑀸𑀣, 𑀢𑀢𑁆𑀣 𑀢𑀢𑁆𑀭 𑀢𑀳𑀺𑀁𑀢𑀳𑀁;

𑀅𑀣𑁄 𑀉𑀤𑁆𑀥𑀜𑁆𑀘 𑀉𑀧𑀭𑀺, 𑀳𑁂𑀝𑁆𑀞𑀸 𑀢𑀼 𑀘 𑀅𑀥𑁄 𑀲𑀫𑀸.

𑀘𑁄𑀤𑀦𑁂 𑀇𑀗𑁆𑀖 𑀳𑀦𑁆𑀤𑀸’𑀣, 𑀆𑀭𑀸𑀤𑀽𑀭𑀸 𑀘 𑀆𑀭𑀓𑀸;

𑀧𑀭𑀫𑁆𑀫𑀼𑀔𑀸 𑀢𑀼 𑀘 𑀭𑀳𑁄, 𑀲𑀫𑁆𑀫𑀼𑀔𑀸 𑀢𑁆𑀯𑀸’𑀯𑀺 𑀧𑀸𑀢𑀼 𑀘.

𑀲𑀁𑀲𑀬𑀢𑁆𑀣𑀫𑁆𑀳𑀺 𑀅𑀧𑁆𑀧𑁂𑀯, 𑀅𑀧𑁆𑀧𑁂𑀯𑀦𑀸𑀫 𑀦𑀽’𑀢𑀺 𑀘;

𑀦𑀺𑀤𑀲𑁆𑀲𑀦𑁂 𑀇𑀢𑀺’𑀢𑁆𑀣𑀜𑁆𑀘, 𑀏𑀯𑀁, 𑀓𑀺𑀘𑁆𑀙𑁂 𑀓𑀣𑀜𑁆𑀘𑀺 𑀘.

𑀳𑀸 𑀔𑁂𑀤𑁂 𑀲𑀘𑁆𑀙𑀺 𑀧𑀘𑁆𑀘𑀓𑁆𑀔𑁂,

𑀢𑀺𑀭𑁄 𑀢𑀼 𑀢𑀺𑀭𑀺𑀬𑀁 𑀘𑀸𑀣, 𑀓𑀼𑀘𑁆𑀙𑀸𑀬𑀁 𑀤𑀼𑀝𑁆𑀞𑀼 𑀓𑀼’𑀘𑁆𑀘𑀢𑁂.

𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀆𑀲𑀺𑀝𑁆𑀞𑀢𑁆𑀣𑀫𑁆𑀳𑀺, 𑀦𑀺𑀦𑁆𑀤𑀸𑀬𑀁 𑀢𑀼 𑀥𑀻 [𑀥𑀺 (𑀓.)] 𑀓𑀣𑁆𑀬𑀢𑁂;

𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀦𑀁 𑀓𑀼𑀳𑀺𑀁 𑀓𑀼𑀢𑁆𑀭, 𑀓𑀼𑀢𑁆𑀣 𑀓𑀢𑁆𑀣 𑀓𑀳𑀁 𑀓𑁆𑀯 𑀣.

𑀇𑀳𑁂’𑀥𑀸’𑀢𑁆𑀭 ¶ 𑀢𑀼 𑀏𑀢𑁆𑀣𑀸’𑀢𑁆𑀣,

𑀓𑀤𑀸 𑀓𑀼𑀤𑀸𑀘𑀦𑀁 𑀘𑀸𑀣, 𑀢𑀤𑀸𑀦𑀺 𑀘 𑀢𑀤𑀸 𑀲𑀫𑀸.

𑀆𑀤𑀺𑀓𑀫𑁆𑀫𑁂 𑀪𑀼𑀲𑀢𑁆𑀣𑁂 𑀘, 𑀲𑀫𑁆𑀪𑀯𑁄’𑀢𑀺𑀡𑁆𑀡 𑀢𑀺𑀢𑁆𑀢𑀺𑀲𑀼;

𑀦𑀺𑀬𑁄𑀕𑀺’𑀲𑁆𑀲𑀭𑀺𑀬’𑀧𑁆𑀧𑀻𑀢𑀺, 𑀤𑀸𑀦 𑀧𑀽𑀚𑀸’𑀕𑁆𑀕, 𑀲𑀦𑁆𑀢𑀺𑀲𑀼.

𑀤𑀲𑁆𑀲𑀦𑁂 𑀢𑀧𑁆𑀧𑀭𑁂 𑀲𑀗𑁆𑀕𑁂, 𑀧𑀲𑀁𑀲𑀸, 𑀕𑀢𑀺, 𑀲𑀼𑀤𑁆𑀥𑀺𑀲𑀼;

𑀳𑀺𑀁𑀲𑀸, 𑀧𑀓𑀸𑀭𑀦𑁆𑀢𑁄’𑀪𑀸𑀯, 𑀯𑀺𑀬𑁄𑀕𑀸’𑀯𑀬𑀯𑁂𑀲𑀼 𑀘;

𑀧𑁄’𑀧𑀲𑀕𑁆𑀕𑁄 𑀤𑀺𑀲𑀸𑀬𑁄𑀕𑁂, 𑀧𑀢𑁆𑀣𑀦𑀸, 𑀥𑀺𑀢𑀺𑀆𑀤𑀺𑀲𑀼.

𑀧𑀭𑀸𑀲𑀤𑁆𑀤𑁄 𑀧𑀭𑀺𑀳𑀸𑀦𑀺, 𑀧𑀭𑀸𑀚𑀬 𑀕𑀢𑀻𑀲𑀼 𑀘;

𑀪𑀼𑀲𑀢𑁆𑀣𑁂 𑀧𑀝𑀺𑀮𑁄𑀫𑀢𑁆𑀣𑁂, 𑀯𑀺𑀓𑁆𑀓𑀫𑀸’𑀫𑀲𑀦𑀸𑀤𑀺𑀲𑀼.

𑀦𑀺𑀲𑁆𑀲𑁂𑀲𑀸’𑀪𑀸𑀯 𑀲𑀦𑁆𑀬𑀸𑀲, 𑀪𑀼𑀲𑀢𑁆𑀣 𑀫𑁄𑀓𑁆𑀔 𑀭𑀸𑀲𑀺𑀲𑀼;

𑀕𑁂𑀳𑀸’𑀤𑁂𑀲𑁄’𑀧𑀫𑀸𑀳𑀻𑀦, 𑀧𑀲𑀸𑀤𑀦𑀺𑀕𑁆𑀕𑀢𑀸’𑀘𑁆𑀘𑀬𑁂.

𑀤𑀲𑁆𑀲𑀦𑁄’𑀲𑀸𑀦𑀦𑀺𑀓𑁆𑀔𑀦𑁆𑀢𑀸, 𑀥𑁄𑀪𑀸𑀕𑁂𑀲𑁆𑀯’𑀯𑀥𑀸𑀭𑀡𑁂;

𑀲𑀸𑀫𑀻𑀧𑁆𑀬𑁂 𑀩𑀦𑁆𑀥𑀦𑁂 𑀙𑁂𑀓, 𑀦𑁆𑀢𑁄𑀪𑀸𑀕𑁄’𑀧𑀭𑀢𑀻𑀲𑀼 𑀘.

𑀧𑀸𑀢𑀼𑀪𑀸𑀯𑁂 𑀯𑀺𑀬𑁄𑀕𑁂 𑀘, 𑀦𑀺𑀲𑁂𑀥𑀸𑀤𑁄 𑀦𑀺 𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀅𑀣𑁄 𑀦𑀻𑀳𑀭𑀡𑁂 𑀘𑁂𑀯𑀸, 𑀯𑀭𑀡𑀸𑀤𑁄 𑀘 𑀦𑀻 𑀲𑀺𑀬𑀸.

𑀉𑀤𑁆𑀥𑀓𑀫𑁆𑀫 𑀯𑀺𑀬𑁄𑀕 𑀢𑁆𑀢, 𑀮𑀸𑀪 𑀢𑀺𑀢𑁆𑀢𑀺 𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀲𑀼;

𑀧𑀸𑀢𑀼𑀪𑀸𑀯’𑀘𑁆𑀘𑀬𑀸𑀪𑀸𑀯, 𑀧𑀩𑀮𑀢𑁆𑀢𑁂 𑀧𑀓𑀸𑀲𑀦𑁂;

𑀤𑀓𑁆𑀔’𑀕𑁆𑀕𑀢𑀸𑀲𑀼 𑀓𑀣𑀦𑁂, 𑀲𑀢𑁆𑀢𑀺𑀫𑁄𑀓𑁆𑀔𑀸𑀤𑀺𑀓𑁂 𑀉 𑀘.

𑀤𑀼 𑀓𑀼𑀘𑁆𑀙𑀺𑀢𑁂’𑀲𑀤𑀢𑁆𑀣𑁂𑀲𑀼, 𑀯𑀺𑀭𑀽𑀧𑀢𑁆𑀢𑁂 𑀧𑁆𑀬’𑀲𑁄𑀪𑀦𑁂;

𑀲𑀺𑀬𑀸’𑀪𑀸𑀯𑀸’𑀲𑀫𑀺𑀤𑁆𑀥𑀻𑀲𑀼, 𑀓𑀺𑀘𑁆𑀙𑁂 𑀘𑀸’𑀦𑀦𑁆𑀤𑀦𑀸𑀤𑀺𑀓𑁂.

𑀲𑀁 𑀲𑀫𑁄𑀥𑀸𑀦 𑀲𑀗𑁆𑀔𑁂𑀧, 𑀲𑀫𑀦𑁆𑀢𑀢𑁆𑀢 𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀲𑀼;

𑀲𑀫𑁆𑀫𑀸 𑀪𑀼𑀲 𑀲𑀳 𑀧𑁆𑀧𑀢𑁆𑀣𑀸, 𑀪𑀺𑀫𑀼𑀔𑀢𑁆𑀣𑁂𑀲𑀼 𑀲𑀗𑁆𑀕𑀢𑁂;

𑀯𑀺𑀥𑀸𑀦𑁂 𑀧𑀪𑀯𑁂 𑀧𑀽𑀚𑀸, 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀓𑁆𑀭𑀺𑀬𑀸𑀤𑀺𑀲𑀼.

𑀯𑀺𑀯𑀺𑀥𑀸’𑀢𑀺𑀲𑀬𑀸’𑀪𑀸𑀯, 𑀪𑀼𑀲𑀢𑁆𑀢𑀺’𑀲𑁆𑀲𑀭𑀺𑀬𑀸’𑀘𑁆𑀘𑀬𑁂;

𑀯𑀺𑀬𑁄𑀕𑁂 𑀓𑀮𑀳𑁂 𑀧𑀸𑀢𑀼, 𑀪𑀸𑀯𑁂 𑀪𑀸𑀲𑁂 𑀘 𑀓𑀼𑀘𑁆𑀙𑀦𑁂.

𑀤𑀽𑀭𑀸’𑀦𑀪𑀺𑀫𑀼𑀔𑀢𑁆𑀢𑁂𑀲𑀼, 𑀫𑁄𑀳𑀸’𑀦𑀯𑀝𑁆𑀞𑀺𑀢𑀻𑀲𑀼 𑀘;

𑀧𑀥𑀸𑀦 𑀤𑀓𑁆𑀔𑀢𑀸 𑀔𑁂𑀤, 𑀲𑀳𑀢𑁆𑀣𑀸𑀤𑁄 𑀯𑀺 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑀯𑀺𑀬𑁄𑀕𑁂 ¶ 𑀚𑀸𑀦𑀦𑁂 𑀘𑀸’𑀥𑁄,𑀪𑀸𑀕 𑀦𑀺𑀘𑁆𑀙𑀬 [𑀪𑀸𑀕’𑀦𑀺𑀘𑁆𑀙𑀬 (𑀪𑀸𑀕+𑀅𑀦𑀺𑀘𑁆𑀙𑀬-𑀝𑀻)] 𑀲𑀼𑀤𑁆𑀥𑀺𑀲𑀼;

𑀈𑀲𑀤𑀢𑁆𑀣𑁂 𑀧𑀭𑀺𑀪𑀯𑁂, 𑀤𑁂𑀲 𑀩𑁆𑀬𑀸𑀧𑀦 𑀳𑀸𑀦𑀺𑀲𑀼;

𑀯𑀘𑁄𑀓𑁆𑀭𑀺𑀬𑀸𑀬 𑀣𑁂𑀬𑁆𑀬𑁂 𑀘, 𑀜𑀸𑀡𑀧𑁆𑀧𑀢𑁆𑀢𑀸𑀤𑀺𑀓𑁂 𑀅𑀯.

𑀧𑀘𑁆𑀙𑀸 𑀪𑀼𑀲𑀢𑁆𑀢 𑀲𑀸𑀤𑀺𑀲𑁆𑀬𑀸, 𑀦𑀼𑀧𑀘𑁆𑀙𑀺𑀦𑁆𑀦𑀸’𑀦𑀼𑀯𑀢𑁆𑀢𑀺𑀲𑀼;

𑀳𑀻𑀦𑁂 𑀘 𑀢𑀢𑀺𑀬𑀢𑁆𑀣𑀸’𑀥𑁄, 𑀪𑀸𑀕𑁂𑀲𑁆𑀯’𑀦𑀼𑀕𑀢𑁂 𑀳𑀺𑀢𑁂;

𑀤𑁂𑀲𑁂 𑀮𑀓𑁆𑀔𑀡 𑀯𑀺𑀘𑁆𑀙𑁂’𑀢𑁆𑀣, 𑀫𑁆𑀪𑀽𑀢 𑀪𑀸𑀕𑀸𑀤𑀺𑀓𑁂 𑀅𑀦𑀼.

𑀲𑀫𑀦𑁆𑀢𑀢𑁆𑀣𑁂 𑀧𑀭𑀺𑀘𑁆𑀙𑁂𑀤𑁂, 𑀧𑀽𑀚𑀸’𑀮𑀺𑀗𑁆𑀕𑀦 𑀯𑀚𑁆𑀚𑀦𑁂;

𑀤𑁄𑀲𑀓𑁆𑀔𑀸𑀦𑁂 𑀦𑀺𑀯𑀸𑀲𑀦𑀸, 𑀯𑀜𑁆𑀜𑀸’𑀥𑀸𑀭𑁂𑀲𑀼 𑀪𑁄𑀚𑀦𑁂;

𑀲𑁄𑀓 𑀩𑁆𑀬𑀸𑀧𑀦 𑀢𑀢𑁆𑀯𑁂𑀲𑀼, 𑀮𑀓𑁆𑀔𑀡𑀸𑀤𑁄 𑀲𑀺𑀬𑀸 𑀧𑀭𑀺.

𑀆𑀪𑀺𑀫𑀼𑀔𑁆𑀬 𑀯𑀺𑀲𑀺𑀝𑁆𑀞𑀼’𑀤𑁆𑀥, 𑀓𑀫𑁆𑀫𑀲𑀸𑀭𑀼𑀧𑁆𑀧𑀯𑀼𑀤𑁆𑀥𑀺𑀲𑀼;

𑀧𑀽𑀚𑀸’𑀥𑀺𑀓 𑀓𑀼𑀮𑀸’𑀲𑀘𑁆𑀘, 𑀮𑀓𑁆𑀔𑀡𑀸𑀤𑀺𑀫𑁆𑀳𑀺 𑀘𑀸𑀧𑁆𑀬’𑀪𑀺.

𑀅𑀥𑀺𑀓𑀺’𑀲𑁆𑀲𑀭, 𑀧𑀸𑀞𑀸’𑀥𑀺, 𑀝𑁆𑀞𑀸𑀦, 𑀧𑀸𑀧𑀼𑀡𑀦𑁂𑀲𑁆𑀯’𑀥𑀺;

𑀦𑀺𑀘𑁆𑀙𑀬𑁂 𑀘𑁄𑀧𑀭𑀺𑀢𑁆𑀢𑀸’𑀥𑀺, 𑀪𑀯𑀦𑁂 𑀘 𑀯𑀺𑀲𑁂𑀲𑀦𑁂.

𑀧𑀝𑀺𑀤𑀸𑀦𑀦𑀺𑀲𑁂𑀥𑁂𑀲𑀼, 𑀯𑀸𑀫𑀸’𑀤𑀸𑀦𑀦𑀺𑀯𑀢𑁆𑀢𑀺𑀲𑀼;

𑀲𑀸𑀤𑀺𑀲𑁂 𑀧𑀝𑀺𑀦𑀺𑀥𑀺𑀫𑁆𑀳𑀺, 𑀆𑀪𑀺𑀫𑀼𑀔𑁆𑀬𑀕𑀢𑀻𑀲𑀼 𑀘.

𑀧𑀢𑀺𑀩𑁄𑀥𑁂 𑀧𑀢𑀺𑀕𑀢𑁂, 𑀢𑀣𑀸 𑀧𑀼𑀦𑀓𑁆𑀭𑀺𑀬𑀸𑀬 𑀘;

𑀲𑀫𑁆𑀪𑀸𑀯𑀦𑁂 𑀧𑀝𑀺𑀘𑁆𑀘𑀢𑁆𑀣𑁂, 𑀧𑀢𑀻𑀢𑀺 𑀮𑀓𑁆𑀔𑀡𑀸𑀤𑀺𑀓𑁂;

𑀲𑀼 𑀲𑁄𑀪𑀦𑁂 𑀲𑀼𑀔𑁂 𑀲𑀫𑁆𑀫𑀸, 𑀪𑀼𑀲 𑀲𑀼𑀝𑁆𑀞𑀼 𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀲𑀼.

𑀆𑀪𑀺𑀫𑀼𑀔𑁆𑀬, 𑀲𑀫𑀻𑀧𑀸’𑀤𑀺, 𑀓𑀫𑁆𑀫𑀸’𑀮𑀺𑀗𑁆𑀕𑀦 𑀧𑀢𑁆𑀢𑀺𑀲𑀼;

𑀫𑀭𑀺𑀬𑀸𑀤𑀼’𑀤𑁆𑀥𑀓𑀫𑁆𑀫𑀺’𑀘𑁆𑀙𑀸, 𑀩𑀦𑁆𑀥𑀦𑀸’𑀪𑀺𑀯𑀺𑀥𑀻𑀲𑀼 𑀆.

𑀦𑀺𑀯𑀸𑀲𑀸’𑀯𑁆𑀳𑀸𑀦 𑀕𑀳𑀡, 𑀓𑀺𑀘𑁆𑀙𑁂’𑀲𑀢𑁆𑀣 𑀦𑀺𑀯𑀢𑁆𑀢𑀺𑀲𑀼;

𑀅𑀧𑁆𑀧𑀲𑀸𑀤𑀸’𑀲𑀺 𑀲𑀭𑀡, 𑀧𑀢𑀺𑀝𑁆𑀞𑀸’𑀯𑀺𑀫𑁆𑀳𑀬𑀸𑀤𑀺𑀲𑀼.

𑀅𑀦𑁆𑀢𑁄𑀪𑀸𑀯 𑀪𑀼𑀲𑀢𑁆𑀢𑀸’𑀢𑀺, 𑀲𑀬 𑀧𑀽𑀚𑀸𑀲𑁆𑀯’𑀢𑀺𑀓𑁆𑀓𑀫𑁂;

𑀪𑀽𑀢𑀪𑀸𑀯𑁂 𑀧𑀲𑀁𑀲𑀸𑀬𑀁, 𑀤𑀴𑁆𑀳𑀢𑁆𑀣𑀸𑀤𑁄 𑀲𑀺𑀬𑀸 𑀅𑀢𑀺.

𑀲𑀫𑁆𑀪𑀸𑀯𑀦𑁂 𑀘 𑀕𑀭𑀳𑀸, 𑀧𑁂𑀓𑁆𑀔𑀸𑀲𑀼 𑀘 𑀲𑀫𑀼𑀘𑁆𑀘𑀬𑁂;

𑀧𑀜𑁆𑀳𑁂 𑀲𑀁𑀯𑀭𑀡𑁂 𑀘𑁂𑀯, 𑀆𑀲𑀻𑀲𑀢𑁆𑀣𑁂 𑀅𑀧𑀻’𑀭𑀺𑀢𑀁.

𑀦𑀺𑀤𑁆𑀤𑁂𑀲𑁂 𑀯𑀚𑁆𑀚𑀦𑁂 𑀧𑀽𑀚𑀸, 𑀧𑀕𑀢𑁂 𑀯𑀸𑀭𑀡𑁂𑀧𑀺 𑀘;

𑀧𑀤𑀼𑀲𑁆𑀲𑀦𑁂 𑀘 𑀕𑀭𑀳𑀸, 𑀘𑁄𑀭𑀺𑀓𑀸’𑀤𑁄 𑀲𑀺𑀬𑀸 𑀅𑀧.

𑀲𑀫𑀻𑀧𑀧𑀽𑀚𑀸 ¶ 𑀲𑀸𑀤𑀺𑀲𑁆𑀲, 𑀤𑁄𑀲𑀓𑁆𑀔𑀸𑀦𑁄’𑀧𑀧𑀢𑁆𑀢𑀺𑀲𑀼;

𑀪𑀼𑀲𑀢𑁆𑀢𑁄’𑀧𑀕𑀫𑀸’𑀥𑀺𑀓𑁆𑀬, 𑀧𑀼𑀩𑁆𑀩𑀓𑀫𑁆𑀫𑀦𑀺𑀯𑀢𑁆𑀢𑀺𑀲𑀼;

𑀕𑀬𑁆𑀳𑀸𑀓𑀸𑀭𑁄’𑀧𑀭𑀺𑀢𑁆𑀢𑁂𑀲𑀼, 𑀉𑀧𑁂’𑀢𑁆𑀬 [𑀉𑀧𑁂𑀢𑁆𑀬=𑀉𑀧+𑀇𑀢𑀺]’𑀦𑀲𑀦𑀸’𑀤𑀺𑀓𑁂.

𑀏𑀯𑀁 𑀦𑀺𑀤𑀲𑁆𑀲𑀦𑀸’𑀓𑀸𑀭𑁄, 𑀧𑀫𑀸𑀲𑀼 𑀲𑀫𑁆𑀧𑀳𑀁𑀲𑀦𑁂;

𑀉𑀧𑀤𑁂𑀲𑁂 𑀘 𑀯𑀘𑀦, 𑀧𑀝𑀺𑀕𑁆𑀕𑀸𑀳𑁂’𑀯𑀥𑀸𑀭𑀡𑁂;

𑀕𑀭𑀳𑀸𑀬𑁂’𑀤𑀫𑀢𑁆𑀣𑁂 𑀘, 𑀧𑀭𑀺𑀫𑀸𑀦𑁂 𑀘 𑀧𑀼𑀘𑁆𑀙𑀦𑁂.

𑀲𑀫𑀼𑀘𑁆𑀘𑀬𑁂 𑀲𑀫𑀸𑀳𑀸𑀭𑁂, 𑀦𑁆𑀯𑀸𑀘𑀬𑁂 𑀘𑁂’𑀢𑀭𑀻𑀢𑀭𑁂;

𑀧𑀤𑀧𑀽𑀭𑀡𑀫𑀢𑁆𑀢𑁂 𑀘, 𑀘𑀲𑀤𑁆𑀤𑁄 𑀅𑀯𑀥𑀸𑀭𑀡𑁂.

𑀇𑀢𑀺 𑀳𑁂𑀢𑀼𑀧𑀓𑀸𑀭𑁂𑀲𑀼, 𑀆𑀤𑀺𑀫𑁆𑀳𑀺 𑀘𑀸’𑀯𑀥𑀸𑀭𑀡𑁂;

𑀦𑀺𑀤𑀲𑁆𑀲𑀦𑁂 𑀧𑀤𑀢𑁆𑀣𑀲𑁆𑀲, 𑀯𑀺𑀧𑀮𑁆𑀮𑀸𑀲𑁂 𑀲𑀫𑀸𑀧𑀦𑁂.

𑀲𑀫𑀼𑀘𑁆𑀘𑀬𑁂 𑀘𑁄’𑀧𑀫𑀸𑀬𑀁, 𑀲𑀁𑀲𑀬𑁂 𑀧𑀤𑀧𑀽𑀭𑀡𑁂;

𑀯𑀯𑀢𑁆𑀣𑀺𑀢𑀯𑀺𑀪𑀸𑀲𑀸𑀬𑀁, 𑀯𑀸’𑀯𑀲𑁆𑀲𑀕𑁆𑀕𑁂 𑀯𑀺𑀓𑀧𑁆𑀧𑀦𑁂.

𑀪𑀽𑀲𑀦𑁂 𑀯𑀸𑀭𑀡𑁂 𑀘𑀸’𑀮𑀁, 𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀧𑀭𑀺𑀬𑀢𑁆𑀢𑀺𑀬𑀁;

𑀅𑀣𑁄’𑀣𑀸’𑀦𑀦𑁆𑀢𑀭𑀸’𑀭𑀫𑁆𑀪, 𑀧𑀜𑁆𑀳𑁂𑀲𑀼 𑀧𑀤𑀧𑀽𑀭𑀡𑁂.

𑀧𑀲𑀁𑀲𑀸𑀕𑀭𑀳𑀸𑀲𑀜𑁆𑀜𑀸, 𑀲𑀻𑀓𑀸𑀭𑀸𑀤𑁄 [𑀲𑁆𑀯𑀻𑀓𑀸𑀭 (𑀝𑀻.)] 𑀧𑀺 𑀦𑀸𑀫 𑀣;

𑀦𑀺𑀘𑁆𑀙𑀬𑁂 𑀘𑀸’𑀦𑀼𑀫𑀸𑀦𑀲𑁆𑀫𑀺𑀁, 𑀲𑀺𑀬𑀸 𑀦𑀽𑀦 𑀯𑀺𑀢𑀓𑁆𑀓𑀦𑁂.

𑀧𑀼𑀘𑁆𑀙𑀸’𑀯𑀥𑀸𑀭𑀡𑀸’𑀦𑀼𑀜𑁆𑀜𑀸, 𑀲𑀸𑀦𑁆𑀢𑁆𑀯𑀦𑀸’𑀮𑀧𑀦𑁂 [𑀲𑀦𑁆𑀢𑀦𑀸𑀮𑀧𑀦𑁂 (𑀓.)] 𑀦𑀦𑀼;

𑀯𑀢𑁂’𑀓𑀁𑀲, 𑀤𑀬𑀸, 𑀳𑀸𑀲, 𑀔𑁂𑀤𑀸’𑀮𑀧𑀦, 𑀯𑀺𑀫𑁆𑀳𑀬𑁂.

𑀯𑀸𑀓𑁆𑀬𑀸𑀭𑀫𑁆𑀪, 𑀯𑀺𑀲𑀸𑀤𑁂𑀲𑀼, 𑀳𑀦𑁆𑀤 𑀳𑀸𑀲𑁂’𑀦𑀼𑀓𑀫𑁆𑀧𑀦𑁂;

𑀬𑀸𑀯 𑀢𑀼 𑀢𑀸𑀯 𑀲𑀸𑀓𑀮𑁆𑀬, 𑀫𑀸𑀦𑀸’𑀯𑀥𑁆𑀬’𑀯𑀥𑀸𑀭𑀡𑁂.

𑀧𑀸𑀘𑀻, 𑀧𑀼𑀭, 𑀗𑁆𑀕𑀢𑁄𑀢𑁆𑀣𑁂𑀲𑀼, 𑀧𑀼𑀭𑀢𑁆𑀣𑀸 𑀧𑀞𑀫𑁂 𑀧𑁆𑀬𑀣;

𑀧𑀩𑀦𑁆𑀥𑁂 𑀘 𑀘𑀺𑀭𑀸𑀢𑀻𑀢𑁂, 𑀦𑀺𑀓𑀝𑀸𑀕𑀸𑀫𑀺𑀓𑁂 𑀧𑀼𑀭𑀸.

𑀦𑀺𑀲𑁂𑀥𑀯𑀸𑀓𑁆𑀬𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀸, 𑀯𑀥𑀸𑀭𑀡𑀧𑀲𑀺𑀤𑁆𑀥𑀺𑀲𑀼;

𑀔𑀮𑁆𑀯𑀸’𑀲𑀦𑁆𑀦𑁂 𑀢𑀼 𑀅𑀪𑀺𑀢𑁄-

𑀓𑀸𑀫𑀁 𑀬𑀤𑁆𑀬𑀧𑀺𑀲𑀤𑁆𑀤𑀢𑁆𑀣𑁂, 𑀏𑀓𑀁𑀲𑀢𑁆𑀣𑁂 𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀅𑀣𑁄 𑀧𑀦 𑀯𑀺𑀲𑁂𑀲𑀲𑁆𑀫𑀺𑀁, 𑀢𑀣𑁂𑀯 𑀧𑀤𑀧𑀽𑀭𑀡𑁂.

𑀳𑀺 ¶ 𑀓𑀸𑀭𑀡𑁂 𑀯𑀺𑀲𑁂𑀲𑀸’𑀯, 𑀥𑀸𑀭𑀡𑁂 𑀧𑀤𑀧𑀽𑀭𑀡𑁂;

𑀢𑀼 𑀳𑁂𑀢𑀼𑀯𑀚𑁆𑀚𑁂 𑀢𑀢𑁆𑀣𑀸’𑀣, 𑀓𑀼 𑀧𑀸𑀧𑁂’𑀲𑀢𑁆𑀣’𑀓𑀼𑀘𑁆𑀙𑀦𑁂.

𑀦𑀼 𑀲𑀁𑀲𑀬𑁂 𑀘 𑀧𑀜𑁆𑀳𑁂 𑀣, 𑀦𑀸𑀦𑀸’ 𑀦𑁂𑀓𑀢𑁆𑀣 𑀯𑀚𑁆𑀚𑀦𑁂;

𑀓𑀺𑀁 𑀢𑀼 𑀧𑀼𑀘𑁆𑀙𑀸𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀸𑀲𑀼, 𑀓𑀁 𑀢𑀼 𑀯𑀸𑀭𑀺𑀫𑁆𑀳𑀺 𑀫𑀼𑀤𑁆𑀥𑀦𑀺.

𑀅𑀫𑀸 𑀲𑀳𑀲𑀫𑀻𑀧𑁂 𑀣, 𑀪𑁂𑀤𑁂 𑀅𑀧𑁆𑀧𑀞𑀫𑁂 𑀧𑀼𑀦;

𑀓𑀺𑀭𑀸’𑀦𑀼𑀲𑁆𑀲𑀯𑀸’𑀭𑀼𑀘𑀺𑀲𑀼, 𑀉𑀤𑀸’𑀧𑁆𑀬𑀢𑁆𑀣𑁂 𑀯𑀺𑀓𑀧𑁆𑀧𑀦𑁂.

𑀧𑀢𑀻𑀘𑀻 𑀘𑀭𑀺𑀫𑁂 𑀧𑀘𑁆𑀙𑀸, 𑀲𑀸𑀫𑀺 𑀢𑁆𑀯𑀤𑁆𑀥𑁂 𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀦𑁂;

𑀅𑀜𑁆𑀜𑁄𑀜𑁆𑀜𑁂 𑀢𑀼 𑀭𑀳𑁄 𑀫𑀺𑀣𑁄.

𑀳𑀸 𑀔𑁂𑀤𑀲𑁄𑀓𑀤𑀼𑀓𑁆𑀔𑁂𑀲𑀼, 𑀔𑁂𑀤𑁂 𑀢𑁆𑀯’𑀳𑀳 𑀯𑀺𑀫𑁆𑀳𑀬𑁂;

𑀪𑀺𑀁𑀲𑀸𑀧𑀦𑁂 [𑀳𑀺𑀁𑀲𑀸𑀧𑀦𑁂 (𑀝𑀻.)] 𑀥𑀻 [𑀥𑀺 (𑀓.)] 𑀦𑀺𑀦𑁆𑀤𑀸𑀬𑀁, 𑀧𑀺𑀥𑀸𑀦𑁂 𑀢𑀺𑀭𑀺𑀬𑀁 𑀢𑀺𑀭𑁄.

𑀢𑀼𑀦 𑀢𑁆𑀯𑀸𑀦 𑀢𑀯𑁂 𑀢𑁆𑀯𑀸 𑀢𑀼𑀁, 𑀥𑀸 𑀲𑁄 𑀣𑀸 𑀓𑁆𑀔𑀢𑁆𑀢𑀼, 𑀫𑁂𑀯 𑀘;

𑀢𑁄 𑀣 𑀢𑁆𑀭 𑀳𑀺𑀜𑁆𑀘𑀦𑀁 𑀳𑀺𑀁𑀳𑀁, 𑀥𑀺 𑀳 𑀳𑀺 𑀥 𑀥𑀼𑀦𑀸 𑀭𑀳𑀺.

𑀤𑀸𑀦𑀺 𑀯𑁄𑀤𑀸𑀘𑀦𑀁 𑀤𑀸𑀚𑁆𑀚, 𑀣𑀁 𑀢𑀢𑁆𑀢𑀁 𑀚𑁆𑀛 𑀚𑁆𑀚𑀼 𑀆𑀤𑀬𑁄;

𑀅𑀪𑀺𑀥𑀸𑀦𑀧𑁆𑀧𑀤𑀻𑀧𑀺𑀓𑀸 𑀲𑀫𑀢𑁆𑀢𑀸.

𑀲𑀕𑁆𑀕𑀓𑀡𑁆𑀟𑁄 ¶ 𑀘 𑀪𑀽𑀓𑀡𑁆𑀟𑁄, 𑀢𑀣𑀸 𑀲𑀸𑀫𑀜𑁆𑀜𑀓𑀡𑁆𑀟𑀺𑀢𑀺;

𑀓𑀡𑁆𑀟𑀢𑁆𑀢𑀬𑀸𑀦𑁆𑀯𑀺𑀢𑀸 𑀏𑀲𑀸, 𑀅𑀪𑀺𑀥𑀸𑀦𑀧𑁆𑀧𑀤𑀻𑀧𑀺𑀓𑀸.

𑀢𑀺𑀤𑀺𑀯𑁂 𑀫𑀳𑀺𑀬𑀁 𑀪𑀼𑀚𑀕𑀸𑀯𑀲𑀣𑁂,

𑀲𑀓𑀮𑀢𑁆𑀣𑀲𑀫𑀯𑁆𑀳𑀬𑀤𑀻𑀧𑀦𑀺’𑀬𑀁;

𑀧𑀝𑀼 𑀳𑁄𑀢𑀺 𑀫𑀳𑀸𑀫𑀼𑀦𑀺𑀦𑁄 𑀯𑀘𑀦𑁂.

𑀧𑀭𑀓𑁆𑀓𑀫𑀪𑀼𑀚𑁄 𑀦𑀸𑀫, 𑀪𑀽𑀧𑀸𑀮𑁄 𑀕𑀼𑀡𑀪𑀽𑀲𑀦𑁄;

𑀮𑀗𑁆𑀓𑀸𑀬 𑀫𑀸𑀲𑀺 𑀢𑁂𑀚𑀲𑁆𑀲𑀻, 𑀚𑀬𑀻 𑀓𑁂𑀲𑀭𑀺𑀯𑀺𑀓𑁆𑀓𑀫𑁄.

𑀯𑀺𑀪𑀺𑀦𑁆𑀦𑀁 𑀘𑀺𑀭𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀁 𑀦𑀺𑀓𑀸𑀬-

𑀢𑁆𑀢𑀬𑀲𑁆𑀫𑀺𑀜𑁆𑀘 𑀓𑀸𑀭𑁂𑀲𑀺 𑀲𑀫𑁆𑀫𑀸 𑀲𑀫𑀕𑁆𑀕𑁂;

𑀲𑀤𑁂𑀳𑀁’𑀯 𑀦𑀺𑀘𑁆𑀘𑀸𑀤𑀭𑁄 𑀤𑀻𑀖𑀓𑀸𑀮𑀁,

𑀫𑀳𑀕𑁆𑀖𑁂𑀳𑀺 𑀭𑀓𑁆𑀔𑁂𑀲𑀺 𑀬𑁄 𑀧𑀘𑁆𑀘𑀬𑁂𑀳𑀺.

𑀬𑁂𑀦 𑀮𑀗𑁆𑀓𑀸 𑀯𑀺𑀳𑀸𑀭𑁂𑀳𑀺, 𑀕𑀸𑀫𑀸’𑀭𑀸𑀫𑀧𑀼𑀭𑀻𑀳𑀺 𑀘;

𑀓𑀺𑀢𑁆𑀢𑀺𑀬𑀸 𑀯𑀺𑀬 𑀲𑀫𑁆𑀩𑀸𑀥𑀻, 𑀓𑀢𑀸 𑀔𑁂𑀢𑁆𑀢𑁂𑀳𑀺 𑀯𑀸𑀧𑀺𑀳𑀺.

𑀬𑀲𑁆𑀲𑀸’𑀲𑀸𑀥𑀸𑀭𑀡𑀁 𑀧𑀢𑁆𑀯𑀸, 𑀦𑀼𑀕𑁆𑀕𑀳𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀤𑀁;

𑀅𑀳𑀫𑁆𑀧𑀺 𑀕𑀦𑁆𑀣𑀓𑀸𑀭𑀢𑁆𑀢𑀁, 𑀧𑀢𑁆𑀢𑁄 𑀯𑀺𑀩𑀼𑀥𑀕𑁄𑀘𑀭𑀁.

𑀓𑀸𑀭𑀺𑀢𑁂 𑀢𑁂𑀦 𑀧𑀸𑀲𑀸𑀤, 𑀕𑁄𑀧𑀼𑀭𑀸𑀤𑀺𑀯𑀺𑀪𑀽𑀲𑀺𑀢𑁂;

𑀲𑀕𑁆𑀕𑀔𑀡𑁆𑀟𑁂’𑀯 𑀢𑀢𑁆𑀢𑁄𑀬𑀸, 𑀲𑀬𑀲𑁆𑀫𑀺𑀁 𑀧𑀢𑀺𑀩𑀺𑀫𑁆𑀩𑀺𑀢𑁂.

𑀫𑀳𑀸𑀚𑁂𑀢𑀯𑀦𑀸’𑀔𑁆𑀬𑀫𑁆𑀳𑀺, 𑀯𑀺𑀳𑀸𑀭𑁂 𑀲𑀸𑀥𑀼𑀲𑀫𑁆𑀫𑀢𑁂;

𑀲𑀭𑁄𑀕𑀸𑀫𑀲𑀫𑀽𑀳𑀫𑁆𑀳𑀺, 𑀯𑀲𑀢𑀸 𑀲𑀦𑁆𑀢𑀯𑀼𑀢𑁆𑀢𑀺𑀦𑀸.

𑀲𑀤𑁆𑀥𑀫𑁆𑀫𑀝𑁆𑀞𑀺𑀢𑀺𑀓𑀸𑀫𑁂𑀦, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀥𑀻𑀫𑀢𑀸;

𑀣𑁂𑀭𑁂𑀦 𑀭𑀘𑀺𑀢𑀸 𑀏𑀲𑀸, 𑀅𑀪𑀺𑀥𑀸𑀦𑀧𑁆𑀧𑀤𑀻𑀧𑀺𑀓𑀸𑀢𑀺.