𑀫𑀽𑀮 > 𑀲𑀼𑀢𑁆𑀢𑀧𑀺𑀝𑀓 > 𑀔𑀼𑀤𑁆𑀤𑀓𑀦𑀺𑀓𑀸𑀬

𑀏𑀯𑀁 ¶ ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀫𑀕𑀥𑁂𑀲𑀼 𑀯𑀺𑀳𑀭𑀢𑀺 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀕𑀺𑀭𑀺𑀲𑁆𑀫𑀺𑀁 ¶ [𑀤𑀓𑁆𑀔𑀺𑀡𑀕𑀺𑀭𑀺𑀲𑁆𑀫𑀺𑀁 (𑀓.)] 𑀏𑀓𑀦𑀸𑀴𑀸𑀬𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀕𑀸𑀫𑁂. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀧𑀜𑁆𑀘𑀫𑀢𑁆𑀢𑀸𑀦𑀺 𑀦𑀗𑁆𑀕𑀮𑀲𑀢𑀸𑀦𑀺 𑀧𑀬𑀼𑀢𑁆𑀢𑀸𑀦𑀺 𑀳𑁄𑀦𑁆𑀢𑀺 𑀯𑀧𑁆𑀧𑀓𑀸𑀮𑁂. 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀧𑀼𑀩𑁆𑀩𑀡𑁆𑀳𑀲𑀫𑀬𑀁 𑀦𑀺𑀯𑀸𑀲𑁂𑀢𑁆𑀯𑀸 𑀧𑀢𑁆𑀢𑀘𑀻𑀯𑀭𑀫𑀸𑀤𑀸𑀬 𑀬𑁂𑀦 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀦𑁆𑀢𑁄 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀧𑀭𑀺𑀯𑁂𑀲𑀦𑀸 𑀯𑀢𑁆𑀢𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀬𑁂𑀦 𑀧𑀭𑀺𑀯𑁂𑀲𑀦𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀅𑀝𑁆𑀞𑀸𑀲𑀺.

𑀅𑀤𑁆𑀤𑀲𑀸 𑀔𑁄 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀞𑀺𑀢𑀁. 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀅𑀳𑀁 𑀔𑁄, 𑀲𑀫𑀡, 𑀓𑀲𑀸𑀫𑀺 𑀘 𑀯𑀧𑀸𑀫𑀺 𑀘; 𑀓𑀲𑀺𑀢𑁆𑀯𑀸 𑀘 𑀯𑀧𑀺𑀢𑁆𑀯𑀸 𑀘 𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀺. 𑀢𑁆𑀯𑀫𑁆𑀧𑀺, 𑀲𑀫𑀡, 𑀓𑀲𑀲𑁆𑀲𑀼 𑀘 𑀯𑀧𑀲𑁆𑀲𑀼 𑀘; 𑀓𑀲𑀺𑀢𑁆𑀯𑀸 𑀘 𑀯𑀧𑀺𑀢𑁆𑀯𑀸 𑀘 𑀪𑀼𑀜𑁆𑀚𑀲𑁆𑀲𑀽’’𑀢𑀺.

‘‘𑀅𑀳𑀫𑁆𑀧𑀺 𑀔𑁄, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡, 𑀓𑀲𑀸𑀫𑀺 𑀘 𑀯𑀧𑀸𑀫𑀺 𑀘; 𑀓𑀲𑀺𑀢𑁆𑀯𑀸 𑀘 𑀯𑀧𑀺𑀢𑁆𑀯𑀸 𑀘 𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀻’’𑀢𑀺. ‘‘𑀦 𑀔𑁄 𑀧𑀦 𑀫𑀬𑀁 [𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀡 (𑀲𑁆𑀬𑀸.)] 𑀧𑀲𑁆𑀲𑀸𑀫 𑀪𑁄𑀢𑁄 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀼𑀕𑀁 𑀯𑀸 𑀦𑀗𑁆𑀕𑀮𑀁 𑀯𑀸 𑀨𑀸𑀮𑀁 𑀯𑀸 𑀧𑀸𑀘𑀦𑀁 𑀯𑀸 𑀩𑀮𑀺𑀩𑀤𑁆𑀤𑁂 [𑀩𑀮𑀺𑀯𑀤𑁆𑀤𑁂 (𑀲𑀻. 𑀧𑀻.), 𑀩𑀮𑀻𑀩𑀤𑁆𑀤𑁂 (?)] 𑀯𑀸. 𑀅𑀣 𑀘 𑀧𑀦 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀏𑀯𑀫𑀸𑀳 𑁋 ‘𑀅𑀳𑀫𑁆𑀧𑀺 𑀔𑁄, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡, 𑀓𑀲𑀸𑀫𑀺 𑀘 𑀯𑀧𑀸𑀫𑀺 ¶ 𑀘; 𑀓𑀲𑀺𑀢𑁆𑀯𑀸 𑀘 𑀯𑀧𑀺𑀢𑁆𑀯𑀸 𑀘 𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀻’’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀓𑀲𑁆𑀲𑀓𑁄 ¶ 𑀧𑀝𑀺𑀚𑀸𑀦𑀸𑀲𑀺, 𑀦 𑀘 𑀧𑀲𑁆𑀲𑀸𑀫 𑀢𑁂 𑀓𑀲𑀺𑀁;

𑀓𑀲𑀺𑀁 𑀦𑁄 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀬𑀣𑀸 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑁂 𑀓𑀲𑀺𑀁’’.

‘‘𑀲𑀤𑁆𑀥𑀸 𑀩𑀻𑀚𑀁 𑀢𑀧𑁄 𑀯𑀼𑀝𑁆𑀞𑀺, 𑀧𑀜𑁆𑀜𑀸 𑀫𑁂 𑀬𑀼𑀕𑀦𑀗𑁆𑀕𑀮𑀁;

𑀳𑀺𑀭𑀻 𑀈𑀲𑀸 𑀫𑀦𑁄 𑀬𑁄𑀢𑁆𑀢𑀁, 𑀲𑀢𑀺 𑀫𑁂 𑀨𑀸𑀮𑀧𑀸𑀘𑀦𑀁.

‘‘𑀓𑀸𑀬𑀕𑀼𑀢𑁆𑀢𑁄 ¶ 𑀯𑀘𑀻𑀕𑀼𑀢𑁆𑀢𑁄, 𑀆𑀳𑀸𑀭𑁂 𑀉𑀤𑀭𑁂 𑀬𑀢𑁄;

𑀲𑀘𑁆𑀘𑀁 𑀓𑀭𑁄𑀫𑀺 𑀦𑀺𑀤𑁆𑀤𑀸𑀦𑀁, 𑀲𑁄𑀭𑀘𑁆𑀘𑀁 𑀫𑁂 𑀧𑀫𑁄𑀘𑀦𑀁.

‘‘𑀯𑀻𑀭𑀺𑀬𑀁 𑀫𑁂 𑀥𑀼𑀭𑀥𑁄𑀭𑀬𑁆𑀳𑀁, 𑀬𑁄𑀕𑀓𑁆𑀔𑁂𑀫𑀸𑀥𑀺𑀯𑀸𑀳𑀦𑀁;

𑀕𑀘𑁆𑀙𑀢𑀺 𑀅𑀦𑀺𑀯𑀢𑁆𑀢𑀦𑁆𑀢𑀁, 𑀬𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀦 𑀲𑁄𑀘𑀢𑀺.

‘‘𑀏𑀯𑀫𑁂𑀲𑀸 ¶ 𑀓𑀲𑀻 𑀓𑀝𑁆𑀞𑀸, 𑀲𑀸 𑀳𑁄𑀢𑀺 𑀅𑀫𑀢𑀧𑁆𑀨𑀮𑀸;

𑀏𑀢𑀁 𑀓𑀲𑀺𑀁 𑀓𑀲𑀺𑀢𑁆𑀯𑀸𑀦, 𑀲𑀩𑁆𑀩𑀤𑀼𑀓𑁆𑀔𑀸 𑀧𑀫𑀼𑀘𑁆𑀘𑀢𑀻’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀫𑀳𑀢𑀺𑀬𑀸 𑀓𑀁𑀲𑀧𑀸𑀢𑀺𑀬𑀸 𑀧𑀸𑀬𑀲𑀁 [𑀧𑀸𑀬𑀸𑀲𑀁 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)] 𑀯𑀟𑁆𑀠𑁂𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑁄 𑀉𑀧𑀦𑀸𑀫𑁂𑀲𑀺 𑁋 ‘‘𑀪𑀼𑀜𑁆𑀚𑀢𑀼 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀧𑀸𑀬𑀲𑀁. 𑀓𑀲𑁆𑀲𑀓𑁄 𑀪𑀯𑀁; 𑀬𑀁 𑀳𑀺 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀅𑀫𑀢𑀧𑁆𑀨𑀮𑀁 [𑀅𑀫𑀢𑀧𑁆𑀨𑀮𑀫𑁆𑀧𑀺 (𑀲𑀁. 𑀦𑀺. 𑁧.𑁧𑁯𑁭)] 𑀓𑀲𑀺𑀁 𑀓𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀕𑀸𑀣𑀸𑀪𑀺𑀕𑀻𑀢𑀁 𑀫𑁂 𑀅𑀪𑁄𑀚𑀦𑁂𑀬𑁆𑀬𑀁, 𑀲𑀫𑁆𑀧𑀲𑁆𑀲𑀢𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀦𑁂𑀲 𑀥𑀫𑁆𑀫𑁄;

𑀕𑀸𑀣𑀸𑀪𑀺𑀕𑀻𑀢𑀁 𑀧𑀦𑀼𑀤𑀦𑁆𑀢𑀺 𑀩𑀼𑀤𑁆𑀥𑀸, 𑀥𑀫𑁆𑀫𑁂 𑀲𑀢𑀻 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀯𑀼𑀢𑁆𑀢𑀺𑀭𑁂𑀲𑀸.

‘‘𑀅𑀜𑁆𑀜𑁂𑀦 ¶ 𑀘 𑀓𑁂𑀯𑀮𑀺𑀦𑀁 𑀫𑀳𑁂𑀲𑀺𑀁, 𑀔𑀻𑀡𑀸𑀲𑀯𑀁 𑀓𑀼𑀓𑁆𑀓𑀼𑀘𑁆𑀘𑀯𑀽𑀧𑀲𑀦𑁆𑀢𑀁;

𑀅𑀦𑁆𑀦𑁂𑀦 𑀧𑀸𑀦𑁂𑀦 𑀉𑀧𑀝𑁆𑀞𑀳𑀲𑁆𑀲𑀼, 𑀔𑁂𑀢𑁆𑀢𑀁 𑀳𑀺 𑀢𑀁 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑀲𑁆𑀲 𑀳𑁄𑀢𑀻’’𑀢𑀺.

‘‘𑀅𑀣 ¶ 𑀓𑀲𑁆𑀲 𑀘𑀸𑀳𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀇𑀫𑀁 𑀧𑀸𑀬𑀲𑀁 𑀤𑀫𑁆𑀫𑀻’’𑀢𑀺? ‘‘𑀦 𑀔𑁆𑀯𑀸𑀳𑀁 𑀢𑀁, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡, 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀲𑀤𑁂𑀯𑀓𑁂 𑀮𑁄𑀓𑁂 𑀲𑀫𑀸𑀭𑀓𑁂 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑁂 𑀲𑀲𑁆𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀺𑀬𑀸 𑀧𑀚𑀸𑀬 𑀲𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀬, 𑀬𑀲𑁆𑀲 𑀲𑁄 𑀧𑀸𑀬𑀲𑁄 𑀪𑀼𑀢𑁆𑀢𑁄 𑀲𑀫𑁆𑀫𑀸 𑀧𑀭𑀺𑀡𑀸𑀫𑀁 𑀕𑀘𑁆𑀙𑁂𑀬𑁆𑀬, 𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲 𑀯𑀸 𑀢𑀣𑀸𑀕𑀢𑀲𑀸𑀯𑀓𑀲𑁆𑀲 𑀯𑀸. 𑀢𑁂𑀦 𑀳𑀺 𑀢𑁆𑀯𑀁, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡, 𑀢𑀁 𑀧𑀸𑀬𑀲𑀁 𑀅𑀧𑁆𑀧𑀳𑀭𑀺𑀢𑁂 𑀯𑀸 𑀙𑀟𑁆𑀟𑁂𑀳𑀺 𑀅𑀧𑁆𑀧𑀸𑀡𑀓𑁂 𑀯𑀸 𑀉𑀤𑀓𑁂 𑀑𑀧𑀺𑀮𑀸𑀧𑁂𑀳𑀻’’𑀢𑀺.

𑀅𑀣 ¶ 𑀔𑁄 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀢𑀁 𑀧𑀸𑀬𑀲𑀁 𑀅𑀧𑁆𑀧𑀸𑀡𑀓𑁂 𑀉𑀤𑀓𑁂 𑀑𑀧𑀺𑀮𑀸𑀧𑁂𑀲𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑁄 𑀧𑀸𑀬𑀲𑁄 𑀉𑀤𑀓𑁂 𑀧𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑁄 𑀘𑀺𑀘𑁆𑀘𑀺𑀝𑀸𑀬𑀢𑀺 𑀘𑀺𑀝𑀺𑀘𑀺𑀝𑀸𑀬𑀢𑀺 𑀲𑀦𑁆𑀥𑀽𑀧𑀸𑀬𑀢𑀺 𑀲𑀫𑁆𑀧𑀥𑀽𑀧𑀸𑀬𑀢𑀺 [𑀲𑀦𑁆𑀥𑀽𑀫𑀸𑀬𑀢𑀺 𑀲𑀫𑁆𑀧𑀥𑀽𑀫𑀸𑀬𑀢𑀺 (𑀲𑁆𑀬𑀸.)]. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺 𑀦𑀸𑀫 𑀨𑀸𑀮𑁄 𑀤𑀺𑀯𑀲𑀁 𑀲𑀦𑁆𑀢𑀢𑁆𑀢𑁄 [𑀤𑀺𑀯𑀲𑀲𑀦𑁆𑀢𑀢𑁆𑀢𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀉𑀤𑀓𑁂 𑀧𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑁄 𑀘𑀺𑀘𑁆𑀘𑀺𑀝𑀸𑀬𑀢𑀺 𑀘𑀺𑀝𑀺𑀘𑀺𑀝𑀸𑀬𑀢𑀺 𑀲𑀦𑁆𑀥𑀽𑀧𑀸𑀬𑀢𑀺 𑀲𑀫𑁆𑀧𑀥𑀽𑀧𑀸𑀬𑀢𑀺; 𑀏𑀯𑀫𑁂𑀯 𑀲𑁄 𑀧𑀸𑀬𑀲𑁄 𑀉𑀤𑀓𑁂 𑀧𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑁄 𑀘𑀺𑀘𑁆𑀘𑀺𑀝𑀸𑀬𑀢𑀺 𑀘𑀺𑀝𑀺𑀘𑀺𑀝𑀸𑀬𑀢𑀺 𑀲𑀦𑁆𑀥𑀽𑀧𑀸𑀬𑀢𑀺 𑀲𑀫𑁆𑀧𑀥𑀽𑀧𑀸𑀬𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀲𑀁𑀯𑀺𑀕𑁆𑀕𑁄 𑀮𑁄𑀫𑀳𑀝𑁆𑀞𑀚𑀸𑀢𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑁄 𑀧𑀸𑀤𑁂𑀲𑀼 𑀲𑀺𑀭𑀲𑀸 𑀦𑀺𑀧𑀢𑀺𑀢𑁆𑀯𑀸 ¶ 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁 ¶ , 𑀪𑁄 𑀕𑁄𑀢𑀫! 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀦𑀺𑀓𑁆𑀓𑀼𑀚𑁆𑀚𑀺𑀢𑀁 𑀯𑀸 𑀉𑀓𑁆𑀓𑀼𑀚𑁆𑀚𑁂𑀬𑁆𑀬, 𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑀁 𑀯𑀸 𑀯𑀺𑀯𑀭𑁂𑀬𑁆𑀬, 𑀫𑀽𑀴𑁆𑀳𑀲𑁆𑀲 𑀯𑀸 𑀫𑀕𑁆𑀕𑀁 𑀆𑀘𑀺𑀓𑁆𑀔𑁂𑀬𑁆𑀬, 𑀅𑀦𑁆𑀥𑀓𑀸𑀭𑁂 𑀯𑀸 𑀢𑁂𑀮𑀧𑀚𑁆𑀚𑁄𑀢𑀁 𑀥𑀸𑀭𑁂𑀬𑁆𑀬, 𑀘𑀓𑁆𑀔𑀼𑀫𑀦𑁆𑀢𑁄 𑀭𑀽𑀧𑀸𑀦𑀺 𑀤𑀓𑁆𑀔𑀦𑁆𑀢𑀻𑀢𑀺 [𑀤𑀓𑁆𑀔𑀺𑀦𑁆𑀢𑀻𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)]; 𑀏𑀯𑀫𑁂𑀯𑀁 𑀪𑁄𑀢𑀸 𑀕𑁄𑀢𑀫𑁂𑀦 𑀅𑀦𑁂𑀓𑀧𑀭𑀺𑀬𑀸𑀬𑁂𑀦 𑀥𑀫𑁆𑀫𑁄 𑀧𑀓𑀸𑀲𑀺𑀢𑁄. 𑀏𑀲𑀸𑀳𑀁 𑀪𑀯𑀦𑁆𑀢𑀁 𑀕𑁄𑀢𑀫𑀁 𑀲𑀭𑀡𑀁 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 ¶ 𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀜𑁆𑀘, 𑀮𑀪𑁂𑀬𑁆𑀬𑀸𑀳𑀁 𑀪𑁄𑀢𑁄 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁, 𑀮𑀪𑁂𑀬𑁆𑀬𑀁 𑀉𑀧𑀲𑀫𑁆𑀧𑀤’’𑀦𑁆𑀢𑀺.

𑀅𑀮𑀢𑁆𑀣 𑀔𑁄 𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀢𑁄 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁, 𑀅𑀮𑀢𑁆𑀣 𑀉𑀧𑀲𑀫𑁆𑀧𑀤𑀁. 𑀅𑀘𑀺𑀭𑀽𑀧𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄 𑀔𑁄 𑀧𑀦𑀸𑀬𑀲𑁆𑀫𑀸 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀏𑀓𑁄 𑀯𑀽𑀧𑀓𑀝𑁆𑀞𑁄 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄 𑀆𑀢𑀸𑀧𑀻 𑀧𑀳𑀺𑀢𑀢𑁆𑀢𑁄 𑀯𑀺𑀳𑀭𑀦𑁆𑀢𑁄 𑀦𑀘𑀺𑀭𑀲𑁆𑀲𑁂𑀯 𑁋 𑀬𑀲𑁆𑀲𑀢𑁆𑀣𑀸𑀬 𑀓𑀼𑀮𑀧𑀼𑀢𑁆𑀢𑀸 𑀲𑀫𑁆𑀫𑀤𑁂𑀯 𑀅𑀕𑀸𑀭𑀲𑁆𑀫𑀸 𑀅𑀦𑀕𑀸𑀭𑀺𑀬𑀁 𑀧𑀩𑁆𑀩𑀚𑀦𑁆𑀢𑀺, 𑀢𑀤𑀦𑀼𑀢𑁆𑀢𑀭𑀁 𑁋 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀧𑀭𑀺𑀬𑁄𑀲𑀸𑀦𑀁 𑀤𑀺𑀝𑁆𑀞𑁂𑀯 𑀥𑀫𑁆𑀫𑁂 𑀲𑀬𑀁 𑀅𑀪𑀺𑀜𑁆𑀜𑀸 𑀲𑀘𑁆𑀙𑀺𑀓𑀢𑁆𑀯𑀸 𑀉𑀧𑀲𑀫𑁆𑀧𑀚𑁆𑀚 𑀯𑀺𑀳𑀸𑀲𑀺. ‘‘𑀔𑀻𑀡𑀸 𑀚𑀸𑀢𑀺, 𑀯𑀼𑀲𑀺𑀢𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, 𑀓𑀢𑀁 𑀓𑀭𑀡𑀻𑀬𑀁, 𑀦𑀸𑀧𑀭𑀁 𑀇𑀢𑁆𑀣𑀢𑁆𑀢𑀸𑀬𑀸’’𑀢𑀺 𑀅𑀩𑁆𑀪𑀜𑁆𑀜𑀸𑀲𑀺. 𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀘 [𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀘 𑀔𑁄 (𑀲𑀻. 𑀧𑀻.), 𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀔𑁄 (𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀓.)] 𑀧𑀦𑀸𑀬𑀲𑁆𑀫𑀸 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀅𑀭𑀳𑀢𑀁 𑀅𑀳𑁄𑀲𑀻𑀢𑀺.

𑀓𑀲𑀺𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑀼𑀢𑁆𑀢𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 ¶ 𑀫𑀼𑀦𑀺𑀁 𑀧𑀳𑀽𑀢𑀧𑀜𑁆𑀜𑀁, (𑀇𑀢𑀺 𑀘𑀼𑀦𑁆𑀤𑁄 𑀓𑀫𑁆𑀫𑀸𑀭𑀧𑀼𑀢𑁆𑀢𑁄)

𑀩𑀼𑀤𑁆𑀥𑀁 𑀥𑀫𑁆𑀫𑀲𑁆𑀲𑀸𑀫𑀺𑀁 𑀯𑀻𑀢𑀢𑀡𑁆𑀳𑀁;

𑀤𑁆𑀯𑀺𑀧𑀤𑀼𑀢𑁆𑀢𑀫𑀁 [𑀤𑀺𑀧𑀤𑀼𑀢𑁆𑀢𑀫𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀲𑀸𑀭𑀣𑀻𑀦𑀁 𑀧𑀯𑀭𑀁, 𑀓𑀢𑀺 𑀮𑁄𑀓𑁂 𑀲𑀫𑀡𑀸 𑀢𑀤𑀺𑀗𑁆𑀖 𑀩𑁆𑀭𑀽𑀳𑀺’’.

‘‘𑀘𑀢𑀼𑀭𑁄 ¶ 𑀲𑀫𑀡𑀸 𑀦 𑀧𑀜𑁆𑀘𑀫𑀢𑁆𑀣𑀺, (𑀘𑀼𑀦𑁆𑀤𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀢𑁂 ¶ 𑀢𑁂 𑀆𑀯𑀺𑀓𑀭𑁄𑀫𑀺 𑀲𑀓𑁆𑀔𑀺𑀧𑀼𑀝𑁆𑀞𑁄;

𑀫𑀕𑁆𑀕𑀚𑀺𑀦𑁄 𑀫𑀕𑁆𑀕𑀤𑁂𑀲𑀓𑁄 𑀘, 𑀫𑀕𑁆𑀕𑁂 𑀚𑀻𑀯𑀢𑀺 𑀬𑁄 𑀘 𑀫𑀕𑁆𑀕𑀤𑀽𑀲𑀻’’.

‘‘𑀓𑀁 ¶ 𑀫𑀕𑁆𑀕𑀚𑀺𑀦𑀁 𑀯𑀤𑀦𑁆𑀢𑀺 𑀩𑀼𑀤𑁆𑀥𑀸, (𑀇𑀢𑀺 𑀘𑀼𑀦𑁆𑀤𑁄 𑀓𑀫𑁆𑀫𑀸𑀭𑀧𑀼𑀢𑁆𑀢𑁄)

𑀫𑀕𑁆𑀕𑀓𑁆𑀔𑀸𑀬𑀻 𑀓𑀣𑀁 𑀅𑀢𑀼𑀮𑁆𑀬𑁄 𑀳𑁄𑀢𑀺;

𑀫𑀕𑁆𑀕𑁂 𑀚𑀻𑀯𑀢𑀺 𑀫𑁂 𑀩𑁆𑀭𑀽𑀳𑀺 𑀧𑀼𑀝𑁆𑀞𑁄, 𑀅𑀣 𑀫𑁂 𑀆𑀯𑀺𑀓𑀭𑁄𑀳𑀺 𑀫𑀕𑁆𑀕𑀤𑀽𑀲𑀺𑀁’’ [𑀫𑀕𑁆𑀕𑀤𑀽𑀲𑀻 (𑀓.)].

‘‘𑀬𑁄 𑀢𑀺𑀡𑁆𑀡𑀓𑀣𑀁𑀓𑀣𑁄 𑀯𑀺𑀲𑀮𑁆𑀮𑁄, 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀸𑀪𑀺𑀭𑀢𑁄 𑀅𑀦𑀸𑀦𑀼𑀕𑀺𑀤𑁆𑀥𑁄;

𑀮𑁄𑀓𑀲𑁆𑀲 𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲 𑀦𑁂𑀢𑀸, 𑀢𑀸𑀤𑀺𑀁 𑀫𑀕𑁆𑀕𑀚𑀺𑀦𑀁 𑀯𑀤𑀦𑁆𑀢𑀺 𑀩𑀼𑀤𑁆𑀥𑀸.

‘‘𑀧𑀭𑀫𑀁 𑀧𑀭𑀫𑀦𑁆𑀢𑀺 𑀬𑁄𑀥 𑀜𑀢𑁆𑀯𑀸, 𑀅𑀓𑁆𑀔𑀸𑀢𑀺 ¶ 𑀯𑀺𑀪𑀚𑀢𑁂 𑀇𑀥𑁂𑀯 𑀥𑀫𑁆𑀫𑀁;

𑀢𑀁 𑀓𑀗𑁆𑀔𑀙𑀺𑀤𑀁 𑀫𑀼𑀦𑀺𑀁 𑀅𑀦𑁂𑀚𑀁, 𑀤𑀼𑀢𑀺𑀬𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑀫𑀸𑀳𑀼 𑀫𑀕𑁆𑀕𑀤𑁂𑀲𑀺𑀁.

‘‘𑀬𑁄 𑀥𑀫𑁆𑀫𑀧𑀤𑁂 𑀲𑀼𑀤𑁂𑀲𑀺𑀢𑁂, 𑀫𑀕𑁆𑀕𑁂 𑀚𑀻𑀯𑀢𑀺 𑀲𑀜𑁆𑀜𑀢𑁄 𑀲𑀢𑀻𑀫𑀸;

𑀅𑀦𑀯𑀚𑁆𑀚𑀧𑀤𑀸𑀦𑀺 𑀲𑁂𑀯𑀫𑀸𑀦𑁄, 𑀢𑀢𑀺𑀬𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑀫𑀸𑀳𑀼 𑀫𑀕𑁆𑀕𑀚𑀻𑀯𑀺𑀁.

‘‘𑀙𑀤𑀦𑀁 𑀓𑀢𑁆𑀯𑀸𑀦 𑀲𑀼𑀩𑁆𑀩𑀢𑀸𑀦𑀁, 𑀧𑀓𑁆𑀔𑀦𑁆𑀤𑀻 𑀓𑀼𑀮𑀤𑀽𑀲𑀓𑁄 𑀧𑀕𑀩𑁆𑀪𑁄;

𑀫𑀸𑀬𑀸𑀯𑀻 𑀅𑀲𑀜𑁆𑀜𑀢𑁄 𑀧𑀮𑀸𑀧𑁄, 𑀧𑀢𑀺𑀭𑀽𑀧𑁂𑀦 𑀘𑀭𑀁 𑀲 𑀫𑀕𑁆𑀕𑀤𑀽𑀲𑀻.

‘‘𑀏𑀢𑁂 𑀘 𑀧𑀝𑀺𑀯𑀺𑀚𑁆𑀛𑀺 𑀬𑁄 𑀕𑀳𑀝𑁆𑀞𑁄, 𑀲𑀼𑀢𑀯𑀸 𑀅𑀭𑀺𑀬𑀲𑀸𑀯𑀓𑁄 𑀲𑀧𑀜𑁆𑀜𑁄;

𑀲𑀩𑁆𑀩𑁂 ¶ 𑀦𑁂𑀢𑀸𑀤𑀺𑀲𑀸𑀢𑀺 [𑀲𑀩𑁆𑀩𑁂 𑀦𑁂 𑀢𑀸𑀤𑀺𑀲𑀸𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀜𑀢𑁆𑀯𑀸, 𑀇𑀢𑀺 𑀤𑀺𑀲𑁆𑀯𑀸 𑀦 𑀳𑀸𑀧𑁂𑀢𑀺 𑀢𑀲𑁆𑀲 𑀲𑀤𑁆𑀥𑀸;

𑀓𑀣𑀁 𑀳𑀺 𑀤𑀼𑀝𑁆𑀞𑁂𑀦 𑀅𑀲𑀫𑁆𑀧𑀤𑀼𑀝𑁆𑀞𑀁, 𑀲𑀼𑀤𑁆𑀥𑀁 𑀅𑀲𑀼𑀤𑁆𑀥𑁂𑀦 𑀲𑀫𑀁 𑀓𑀭𑁂𑀬𑁆𑀬𑀸’’𑀢𑀺.

𑀘𑀼𑀦𑁆𑀤𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀜𑁆𑀘𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ ¶ ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀚𑁂𑀢𑀯𑀦𑁂 𑀅𑀦𑀸𑀣𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑀲𑁆𑀲 𑀆𑀭𑀸𑀫𑁂. 𑀅𑀣 𑀔𑁄 𑀅𑀜𑁆𑀜𑀢𑀭𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀸𑀬 𑀭𑀢𑁆𑀢𑀺𑀬𑀸 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀯𑀡𑁆𑀡𑀸 𑀓𑁂𑀯𑀮𑀓𑀧𑁆𑀧𑀁 𑀚𑁂𑀢𑀯𑀦𑀁 𑀑𑀪𑀸𑀲𑁂𑀢𑁆𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀅𑀝𑁆𑀞𑀸𑀲𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀞𑀺𑀢𑀸 𑀔𑁄 𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀧𑀭𑀸𑀪𑀯𑀦𑁆𑀢𑀁 𑀧𑀼𑀭𑀺𑀲𑀁, 𑀫𑀬𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫 𑀕𑁄𑀢𑀫 [𑀕𑁄𑀢𑀫𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)];

𑀪𑀕𑀯𑀦𑁆𑀢𑀁 [𑀪𑀯𑀦𑁆𑀢𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀧𑀼𑀝𑁆𑀞𑀼𑀫𑀸𑀕𑀫𑁆𑀫, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀲𑀼𑀯𑀺𑀚𑀸𑀦𑁄 𑀪𑀯𑀁 𑀳𑁄𑀢𑀺, 𑀲𑀼𑀯𑀺𑀚𑀸𑀦𑁄 [𑀤𑀼𑀯𑀺𑀚𑀸𑀦𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀥𑀫𑁆𑀫𑀓𑀸𑀫𑁄 𑀪𑀯𑀁 𑀳𑁄𑀢𑀺, 𑀥𑀫𑁆𑀫𑀤𑁂𑀲𑁆𑀲𑀻 𑀧𑀭𑀸𑀪𑀯𑁄’’.

‘‘𑀇𑀢𑀺 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀧𑀞𑀫𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀤𑀼𑀢𑀺𑀬𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀅𑀲𑀦𑁆𑀢𑀲𑁆𑀲 𑀧𑀺𑀬𑀸 𑀳𑁄𑀦𑁆𑀢𑀺, 𑀲𑀦𑁆𑀢𑁂 𑀦 𑀓𑀼𑀭𑀼𑀢𑁂 𑀧𑀺𑀬𑀁;

𑀅𑀲𑀢𑀁 𑀥𑀫𑁆𑀫𑀁 𑀭𑁄𑀘𑁂𑀢𑀺, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀤𑀼𑀢𑀺𑀬𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀢𑀢𑀺𑀬𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀦𑀺𑀤𑁆𑀤𑀸𑀲𑀻𑀮𑀻 ¶ 𑀲𑀪𑀸𑀲𑀻𑀮𑀻, 𑀅𑀦𑀼𑀝𑁆𑀞𑀸𑀢𑀸 𑀘 𑀬𑁄 𑀦𑀭𑁄;

𑀅𑀮𑀲𑁄 𑀓𑁄𑀥𑀧𑀜𑁆𑀜𑀸𑀡𑁄, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 ¶ 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀢𑀢𑀺𑀬𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀬𑁄 ¶ 𑀫𑀸𑀢𑀭𑀁 [𑀬𑁄 𑀫𑀸𑀢𑀭𑀁 𑀯𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀧𑀺𑀢𑀭𑀁 𑀯𑀸, 𑀚𑀺𑀡𑁆𑀡𑀓𑀁 𑀕𑀢𑀬𑁄𑀩𑁆𑀩𑀦𑀁;

𑀧𑀳𑀼 𑀲𑀦𑁆𑀢𑁄 𑀦 𑀪𑀭𑀢𑀺, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀘𑀢𑀼𑀢𑁆𑀣𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀧𑀜𑁆𑀘𑀫𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 [𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀯𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀲𑀫𑀡𑀁 𑀯𑀸, 𑀅𑀜𑁆𑀜𑀁 𑀯𑀸𑀧𑀺 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑀁;

𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑁂𑀦 𑀯𑀜𑁆𑀘𑁂𑀢𑀺, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 ¶ 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀧𑀜𑁆𑀘𑀫𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀙𑀝𑁆𑀞𑀫𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀧𑀳𑀽𑀢𑀯𑀺𑀢𑁆𑀢𑁄 𑀧𑀼𑀭𑀺𑀲𑁄, 𑀲𑀳𑀺𑀭𑀜𑁆𑀜𑁄 𑀲𑀪𑁄𑀚𑀦𑁄;

𑀏𑀓𑁄 𑀪𑀼𑀜𑁆𑀚𑀢𑀺 𑀲𑀸𑀤𑀽𑀦𑀺, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀙𑀝𑁆𑀞𑀫𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀲𑀢𑁆𑀢𑀫𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀚𑀸𑀢𑀺𑀢𑁆𑀣𑀤𑁆𑀥𑁄 𑀥𑀦𑀢𑁆𑀣𑀤𑁆𑀥𑁄, 𑀕𑁄𑀢𑁆𑀢𑀢𑁆𑀣𑀤𑁆𑀥𑁄 𑀘 𑀬𑁄 𑀦𑀭𑁄;

𑀲𑀜𑁆𑀜𑀸𑀢𑀺𑀁 𑀅𑀢𑀺𑀫𑀜𑁆𑀜𑁂𑀢𑀺, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀲𑀢𑁆𑀢𑀫𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀅𑀝𑁆𑀞𑀫𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑁆𑀣𑀺𑀥𑀼𑀢𑁆𑀢𑁄 𑀲𑀼𑀭𑀸𑀥𑀼𑀢𑁆𑀢𑁄, 𑀅𑀓𑁆𑀔𑀥𑀼𑀢𑁆𑀢𑁄 𑀘 𑀬𑁄 𑀦𑀭𑁄;

𑀮𑀤𑁆𑀥𑀁 𑀮𑀤𑁆𑀥𑀁 𑀯𑀺𑀦𑀸𑀲𑁂𑀢𑀺, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 ¶ ¶ 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀅𑀝𑁆𑀞𑀫𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀦𑀯𑀫𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀲𑁂𑀳𑀺 ¶ 𑀤𑀸𑀭𑁂𑀳𑀺 𑀅𑀲𑀦𑁆𑀢𑀼𑀝𑁆𑀞𑁄 [𑀤𑀸𑀭𑁂𑀳𑁆𑀬𑀲𑀦𑁆𑀢𑀼𑀝𑁆𑀞𑁄 (𑀓.)], 𑀯𑁂𑀲𑀺𑀬𑀸𑀲𑀼 𑀧𑀤𑀼𑀲𑁆𑀲𑀢𑀺 [𑀧𑀤𑀺𑀲𑁆𑀲𑀢𑀺 (𑀲𑀻.)];

𑀤𑀼𑀲𑁆𑀲𑀢𑀺 [𑀤𑀺𑀲𑁆𑀲𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀭𑀤𑀸𑀭𑁂𑀲𑀼, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀦𑀯𑀫𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀤𑀲𑀫𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀅𑀢𑀻𑀢𑀬𑁄𑀩𑁆𑀩𑀦𑁄 𑀧𑁄𑀲𑁄, 𑀆𑀦𑁂𑀢𑀺 𑀢𑀺𑀫𑁆𑀩𑀭𑀼𑀢𑁆𑀣𑀦𑀺𑀁;

𑀢𑀲𑁆𑀲𑀸 𑀇𑀲𑁆𑀲𑀸 𑀦 𑀲𑀼𑀧𑀢𑀺, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀤𑀲𑀫𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀏𑀓𑀸𑀤𑀲𑀫𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑁆𑀣𑀺𑀁 𑀲𑁄𑀡𑁆𑀟𑀺𑀁 𑀯𑀺𑀓𑀺𑀭𑀡𑀺𑀁, 𑀧𑀼𑀭𑀺𑀲𑀁 𑀯𑀸𑀧𑀺 𑀢𑀸𑀤𑀺𑀲𑀁;

𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑀲𑁆𑀫𑀺𑀁 𑀞𑀧𑁂𑀢𑀺 [𑀞𑀸𑀧𑁂𑀢𑀺 (𑀲𑀻. 𑀧𑀻.), 𑀣𑀧𑁂𑀢𑀺 (𑀓.)], 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀇𑀢𑀺 ¶ 𑀳𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀸𑀫, 𑀏𑀓𑀸𑀤𑀲𑀫𑁄 𑀲𑁄 𑀧𑀭𑀸𑀪𑀯𑁄;

𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀺𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀅𑀧𑁆𑀧𑀪𑁄𑀕𑁄 𑀫𑀳𑀸𑀢𑀡𑁆𑀳𑁄, 𑀔𑀢𑁆𑀢𑀺𑀬𑁂 𑀚𑀸𑀬𑀢𑁂 𑀓𑀼𑀮𑁂;

𑀲𑁄 𑀘 𑀭𑀚𑁆𑀚𑀁 𑀧𑀢𑁆𑀣𑀬𑀢𑀺, 𑀢𑀁 𑀧𑀭𑀸𑀪𑀯𑀢𑁄 𑀫𑀼𑀔𑀁’’.

‘‘𑀏𑀢𑁂 𑀧𑀭𑀸𑀪𑀯𑁂 𑀮𑁄𑀓𑁂, 𑀧𑀡𑁆𑀟𑀺𑀢𑁄 𑀲𑀫𑀯𑁂𑀓𑁆𑀔𑀺𑀬;

𑀅𑀭𑀺𑀬𑁄 𑀤𑀲𑁆𑀲𑀦𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀲 𑀮𑁄𑀓𑀁 𑀪𑀚𑀢𑁂 𑀲𑀺𑀯’’𑀦𑁆𑀢𑀺.

𑀧𑀭𑀸𑀪𑀯𑀲𑀼𑀢𑁆𑀢𑀁 𑀙𑀝𑁆𑀞𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ ¶ ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀚𑁂𑀢𑀯𑀦𑁂 𑀅𑀦𑀸𑀣𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑀲𑁆𑀲 𑀆𑀭𑀸𑀫𑁂. 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀧𑀼𑀩𑁆𑀩𑀡𑁆𑀳𑀲𑀫𑀬𑀁 𑀦𑀺𑀯𑀸𑀲𑁂𑀢𑁆𑀯𑀸 𑀧𑀢𑁆𑀢𑀘𑀻𑀯𑀭𑀫𑀸𑀤𑀸𑀬 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀁 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀧𑀸𑀯𑀺𑀲𑀺. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀅𑀕𑁆𑀕𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀦𑀺𑀯𑁂𑀲𑀦𑁂 𑀅𑀕𑁆𑀕𑀺 𑀧𑀚𑁆𑀚𑀮𑀺𑀢𑁄 𑀳𑁄𑀢𑀺 𑀆𑀳𑀼𑀢𑀺 𑀧𑀕𑁆𑀕𑀳𑀺𑀢𑀸. 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀲𑀧𑀤𑀸𑀦𑀁 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀫𑀸𑀦𑁄 𑀬𑁂𑀦 𑀅𑀕𑁆𑀕𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀦𑀺𑀯𑁂𑀲𑀦𑀁 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺.

𑀅𑀤𑁆𑀤𑀲𑀸 𑀔𑁄 𑀅𑀕𑁆𑀕𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀤𑀽𑀭𑀢𑁄𑀯 𑀆𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀁. 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀢𑀢𑁆𑀭𑁂𑀯 [𑀅𑀢𑁆𑀭𑁂𑀯 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀫𑀼𑀡𑁆𑀟𑀓; 𑀢𑀢𑁆𑀭𑁂𑀯, 𑀲𑀫𑀡𑀓; 𑀢𑀢𑁆𑀭𑁂𑀯, 𑀯𑀲𑀮𑀓 𑀢𑀺𑀝𑁆𑀞𑀸𑀳𑀻’’𑀢𑀺.

𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀪𑀕𑀯𑀸 𑀅𑀕𑁆𑀕𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀚𑀸𑀦𑀸𑀲𑀺 𑀧𑀦 𑀢𑁆𑀯𑀁, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡, 𑀯𑀲𑀮𑀁 𑀯𑀸 𑀯𑀲𑀮𑀓𑀭𑀡𑁂 𑀯𑀸 𑀥𑀫𑁆𑀫𑁂’’𑀢𑀺? ‘‘𑀦 𑀔𑁆𑀯𑀸𑀳𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀚𑀸𑀦𑀸𑀫𑀺 𑀯𑀲𑀮𑀁 𑀯𑀸 𑀯𑀲𑀮𑀓𑀭𑀡𑁂 𑀯𑀸 𑀥𑀫𑁆𑀫𑁂; 𑀲𑀸𑀥𑀼 𑀫𑁂 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀢𑀣𑀸 𑀥𑀫𑁆𑀫𑀁 𑀤𑁂𑀲𑁂𑀢𑀼, 𑀬𑀣𑀸𑀳𑀁 𑀚𑀸𑀦𑁂𑀬𑁆𑀬𑀁 𑀯𑀲𑀮𑀁 𑀯𑀸 𑀯𑀲𑀮𑀓𑀭𑀡𑁂 𑀯𑀸 𑀥𑀫𑁆𑀫𑁂’’𑀢𑀺. ‘‘𑀢𑁂𑀦 𑀳𑀺, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡, 𑀲𑀼𑀡𑀸𑀳𑀺, 𑀲𑀸𑀥𑀼𑀓𑀁 𑀫𑀦𑀲𑀺 𑀓𑀭𑁄𑀳𑀺; 𑀪𑀸𑀲𑀺𑀲𑁆𑀲𑀸𑀫𑀻’’𑀢𑀺. ‘‘𑀏𑀯𑀁, 𑀪𑁄’’𑀢𑀺 𑀔𑁄 𑀅𑀕𑁆𑀕𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀢𑁄 𑀧𑀘𑁆𑀘𑀲𑁆𑀲𑁄𑀲𑀺. 𑀪𑀕𑀯𑀸 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋

‘‘𑀓𑁄𑀥𑀦𑁄 ¶ 𑀉𑀧𑀦𑀸𑀳𑀻 𑀘, 𑀧𑀸𑀧𑀫𑀓𑁆𑀔𑀻 𑀘 𑀬𑁄 𑀦𑀭𑁄;

𑀯𑀺𑀧𑀦𑁆𑀦𑀤𑀺𑀝𑁆𑀞𑀺 ¶ 𑀫𑀸𑀬𑀸𑀯𑀻, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀏𑀓𑀚𑀁 𑀯𑀸 𑀤𑁆𑀯𑀺𑀚𑀁 [𑀤𑀺𑀚𑀁 (𑀧𑀻.)] 𑀯𑀸𑀧𑀺, 𑀬𑁄𑀥 𑀧𑀸𑀡𑀁 𑀯𑀺𑀳𑀺𑀁𑀲𑀢𑀺;

𑀬𑀲𑁆𑀲 𑀧𑀸𑀡𑁂 𑀤𑀬𑀸 𑀦𑀢𑁆𑀣𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 ¶ 𑀳𑀦𑁆𑀢𑀺 𑀧𑀭𑀺𑀭𑀼𑀦𑁆𑀥𑀢𑀺 [𑀉𑀧𑀭𑀼𑀦𑁆𑀥𑁂𑀢𑀺 (𑀲𑁆𑀬𑀸.), 𑀉𑀧𑀭𑀼𑀦𑁆𑀥𑀢𑀺 (𑀓.)], 𑀕𑀸𑀫𑀸𑀦𑀺 𑀦𑀺𑀕𑀫𑀸𑀦𑀺 𑀘;

𑀦𑀺𑀕𑁆𑀕𑀸𑀳𑀓𑁄 [𑀦𑀺𑀕𑁆𑀖𑀸𑀢𑀓𑁄 (?)] 𑀲𑀫𑀜𑁆𑀜𑀸𑀢𑁄, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀕𑀸𑀫𑁂 𑀯𑀸 𑀬𑀤𑀺 𑀯𑀸 𑀭𑀜𑁆𑀜𑁂, 𑀬𑀁 𑀧𑀭𑁂𑀲𑀁 𑀫𑀫𑀸𑀬𑀺𑀢𑀁;

𑀣𑁂𑀬𑁆𑀬𑀸 𑀅𑀤𑀺𑀦𑁆𑀦𑀫𑀸𑀤𑁂𑀢𑀺 [𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀆𑀤𑀺𑀬𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)], 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 ¶ 𑀳𑀯𑁂 𑀇𑀡𑀫𑀸𑀤𑀸𑀬, 𑀘𑀼𑀚𑁆𑀚𑀫𑀸𑀦𑁄 [𑀪𑀼𑀜𑁆𑀚𑀫𑀸𑀦𑁄 (?)] 𑀧𑀮𑀸𑀬𑀢𑀺;

𑀦 𑀳𑀺 𑀢𑁂 𑀇𑀡𑀫𑀢𑁆𑀣𑀻𑀢𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀯𑁂 𑀓𑀺𑀜𑁆𑀘𑀺𑀓𑁆𑀔𑀓𑀫𑁆𑀬𑀢𑀸, 𑀧𑀦𑁆𑀣𑀲𑁆𑀫𑀺𑀁 𑀯𑀚𑀦𑁆𑀢𑀁 𑀚𑀦𑀁;

𑀳𑀦𑁆𑀢𑁆𑀯𑀸 𑀓𑀺𑀜𑁆𑀘𑀺𑀓𑁆𑀔𑀫𑀸𑀤𑁂𑀢𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀅𑀢𑁆𑀢𑀳𑁂𑀢𑀼 𑀧𑀭𑀳𑁂𑀢𑀼, 𑀥𑀦𑀳𑁂𑀢𑀼 𑀘 [𑀥𑀦𑀳𑁂𑀢𑀼 𑀯 (𑀓.)] 𑀬𑁄 𑀦𑀭𑁄;

𑀲𑀓𑁆𑀔𑀺𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑀼𑀲𑀸 𑀩𑁆𑀭𑀽𑀢𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀜𑀸𑀢𑀻𑀦𑀁 𑀲𑀔𑀻𑀦𑀁 𑀯𑀸, 𑀤𑀸𑀭𑁂𑀲𑀼 𑀧𑀝𑀺𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀲𑀸𑀳𑀲𑀸 [𑀲𑀳𑀲𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀲𑀫𑁆𑀧𑀺𑀬𑁂𑀦 𑀯𑀸, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀫𑀸𑀢𑀭𑀁 𑀧𑀺𑀢𑀭𑀁 𑀯𑀸, 𑀚𑀺𑀡𑁆𑀡𑀓𑀁 𑀕𑀢𑀬𑁄𑀩𑁆𑀩𑀦𑀁;

𑀧𑀳𑀼 𑀲𑀦𑁆𑀢𑁄 𑀦 𑀪𑀭𑀢𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀫𑀸𑀢𑀭𑀁 𑀧𑀺𑀢𑀭𑀁 𑀯𑀸, 𑀪𑀸𑀢𑀭𑀁 𑀪𑀕𑀺𑀦𑀺𑀁 𑀲𑀲𑀼𑀁;

𑀳𑀦𑁆𑀢𑀺 𑀭𑁄𑀲𑁂𑀢𑀺 𑀯𑀸𑀘𑀸𑀬, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀅𑀢𑁆𑀣𑀁 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀲𑀦𑁆𑀢𑁄, 𑀅𑀦𑀢𑁆𑀣𑀫𑀦𑀼𑀲𑀸𑀲𑀢𑀺;

𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑁂𑀦 ¶ 𑀫𑀦𑁆𑀢𑁂𑀢𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀓𑀢𑁆𑀯𑀸 𑀧𑀸𑀧𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀫𑀸 𑀫𑀁 𑀚𑀜𑁆𑀜𑀸𑀢𑀺 𑀇𑀘𑁆𑀙𑀢𑀺 [𑀯𑀺𑀪. 𑁮𑁯𑁪 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀁];

𑀬𑁄 𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑀓𑀫𑁆𑀫𑀦𑁆𑀢𑁄, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 ¶ 𑀯𑁂 𑀧𑀭𑀓𑀼𑀮𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀪𑀼𑀢𑁆𑀯𑀸𑀦 [𑀲𑀼𑀢𑁆𑀯𑀸 𑀘 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀲𑀼𑀘𑀺𑀪𑁄𑀚𑀦𑀁;

𑀆𑀕𑀢𑀁 𑀦𑀧𑁆𑀧𑀝𑀺𑀧𑀽𑀚𑁂𑀢𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀲𑀫𑀡𑀁 𑀯𑀸, 𑀅𑀜𑁆𑀜𑀁 𑀯𑀸𑀧𑀺 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑀁;

𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑁂𑀦 𑀯𑀜𑁆𑀘𑁂𑀢𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 ¶ ¶ 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀲𑀫𑀡𑀁 𑀯𑀸, 𑀪𑀢𑁆𑀢𑀓𑀸𑀮𑁂 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑁂;

𑀭𑁄𑀲𑁂𑀢𑀺 𑀯𑀸𑀘𑀸 𑀦 𑀘 𑀤𑁂𑀢𑀺, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀅𑀲𑀢𑀁 𑀬𑁄𑀥 𑀧𑀩𑁆𑀭𑀽𑀢𑀺, 𑀫𑁄𑀳𑁂𑀦 𑀧𑀮𑀺𑀕𑀼𑀡𑁆𑀞𑀺𑀢𑁄;

𑀓𑀺𑀜𑁆𑀘𑀺𑀓𑁆𑀔𑀁 𑀦𑀺𑀚𑀺𑀕𑀻𑀲𑀸𑀦𑁄 [𑀦𑀺𑀚𑀺𑀕𑀺𑀁𑀲𑀸𑀦𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)], 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀘𑀢𑁆𑀢𑀸𑀦𑀁 𑀲𑀫𑀼𑀓𑁆𑀓𑀁𑀲𑁂, 𑀧𑀭𑁂 𑀘 𑀫𑀯𑀚𑀸𑀦𑀸𑀢𑀺 [𑀫𑀯𑀚𑀸𑀦𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀦𑀺𑀳𑀻𑀦𑁄 𑀲𑁂𑀦 𑀫𑀸𑀦𑁂𑀦, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀭𑁄𑀲𑀓𑁄 𑀓𑀤𑀭𑀺𑀬𑁄 𑀘, 𑀧𑀸𑀧𑀺𑀘𑁆𑀙𑁄 𑀫𑀘𑁆𑀙𑀭𑀻 𑀲𑀞𑁄;

𑀅𑀳𑀺𑀭𑀺𑀓𑁄 𑀅𑀦𑁄𑀢𑁆𑀢𑀧𑁆𑀧𑀻, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀩𑀼𑀤𑁆𑀥𑀁 𑀧𑀭𑀺𑀪𑀸𑀲𑀢𑀺, 𑀅𑀣 𑀯𑀸 𑀢𑀲𑁆𑀲 𑀲𑀸𑀯𑀓𑀁;

𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀁 [𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑀁 (𑀓.), 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀁 (𑀲𑁆𑀬𑀸. 𑀓𑀁.)] 𑀕𑀳𑀝𑁆𑀞𑀁 𑀯𑀸, 𑀢𑀁 𑀚𑀜𑁆𑀜𑀸 𑀯𑀲𑀮𑁄 𑀇𑀢𑀺.

‘‘𑀬𑁄 𑀯𑁂 𑀅𑀦𑀭𑀳𑀁 [𑀅𑀦𑀭𑀳𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀦𑁆𑀢𑁄, 𑀅𑀭𑀳𑀁 𑀧𑀝𑀺𑀚𑀸𑀦𑀸𑀢𑀺 [𑀧𑀝𑀺𑀚𑀸𑀦𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀘𑁄𑀭𑁄 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑁂 𑀮𑁄𑀓𑁂, 𑀏𑀲𑁄 𑀔𑁄 𑀯𑀲𑀮𑀸𑀥𑀫𑁄.

‘‘𑀏𑀢𑁂 𑀔𑁄 𑀯𑀲𑀮𑀸 𑀯𑀼𑀢𑁆𑀢𑀸, 𑀫𑀬𑀸 𑀬𑁂𑀢𑁂 𑀧𑀓𑀸𑀲𑀺𑀢𑀸;

𑀦 ¶ 𑀚𑀘𑁆𑀘𑀸 𑀯𑀲𑀮𑁄 𑀳𑁄𑀢𑀺, 𑀦 𑀚𑀘𑁆𑀘𑀸 𑀳𑁄𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

𑀓𑀫𑁆𑀫𑀼𑀦𑀸 [𑀓𑀫𑁆𑀫𑀦𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑀲𑀮𑁄 𑀳𑁄𑀢𑀺, 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀳𑁄𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

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

𑀘𑀡𑁆𑀟𑀸𑀮𑀧𑀼𑀢𑁆𑀢𑁄 𑀲𑁄𑀧𑀸𑀓𑁄 [𑀲𑀧𑀸𑀓𑁄 (?)], 𑀫𑀸𑀢𑀗𑁆𑀕𑁄 𑀇𑀢𑀺 𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑁄.

‘‘𑀲𑁄 ¶ ¶ 𑀬𑀲𑀁 𑀧𑀭𑀫𑀁 𑀧𑀢𑁆𑀢𑁄 [𑀲𑁄 𑀬𑀲𑀧𑁆𑀧𑀭𑀫𑀧𑁆𑀧𑀢𑁆𑀢𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀫𑀸𑀢𑀗𑁆𑀕𑁄 𑀬𑀁 𑀲𑀼𑀤𑀼𑀮𑁆𑀮𑀪𑀁;

𑀆𑀕𑀘𑁆𑀙𑀼𑀁 𑀢𑀲𑁆𑀲𑀼𑀧𑀝𑁆𑀞𑀸𑀦𑀁, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀩𑀳𑀽.

‘‘𑀤𑁂𑀯𑀬𑀸𑀦𑀁 ¶ 𑀅𑀪𑀺𑀭𑀼𑀬𑁆𑀳, 𑀯𑀺𑀭𑀚𑀁 𑀲𑁄 𑀫𑀳𑀸𑀧𑀣𑀁;

𑀓𑀸𑀫𑀭𑀸𑀕𑀁 𑀯𑀺𑀭𑀸𑀚𑁂𑀢𑁆𑀯𑀸, 𑀩𑁆𑀭𑀳𑁆𑀫𑀮𑁄𑀓𑀽𑀧𑀕𑁄 𑀅𑀳𑀼;

𑀦 𑀦𑀁 𑀚𑀸𑀢𑀺 𑀦𑀺𑀯𑀸𑀭𑁂𑀲𑀺, 𑀩𑁆𑀭𑀳𑁆𑀫𑀮𑁄𑀓𑀽𑀧𑀧𑀢𑁆𑀢𑀺𑀬𑀸.

‘‘𑀅𑀚𑁆𑀛𑀸𑀬𑀓𑀓𑀼𑀮𑁂 𑀚𑀸𑀢𑀸, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀫𑀦𑁆𑀢𑀩𑀦𑁆𑀥𑀯𑀸;

𑀢𑁂 𑀘 𑀧𑀸𑀧𑁂𑀲𑀼 𑀓𑀫𑁆𑀫𑁂𑀲𑀼, 𑀅𑀪𑀺𑀡𑁆𑀳𑀫𑀼𑀧𑀤𑀺𑀲𑁆𑀲𑀭𑁂.

‘‘𑀤𑀺𑀝𑁆𑀞𑁂𑀯 𑀥𑀫𑁆𑀫𑁂 𑀕𑀸𑀭𑀬𑁆𑀳𑀸, 𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑁂 𑀘 𑀤𑀼𑀕𑁆𑀕𑀢𑀺;

𑀦 𑀦𑁂 𑀚𑀸𑀢𑀺 𑀦𑀺𑀯𑀸𑀭𑁂𑀢𑀺, 𑀤𑀼𑀕𑁆𑀕𑀢𑁆𑀬𑀸 [𑀤𑀼𑀕𑁆𑀕𑀘𑁆𑀘𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀕𑀭𑀳𑀸𑀬 𑀯𑀸.

‘‘𑀦 𑀚𑀘𑁆𑀘𑀸 𑀯𑀲𑀮𑁄 𑀳𑁄𑀢𑀺, 𑀦 𑀚𑀘𑁆𑀘𑀸 𑀳𑁄𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀯𑀲𑀮𑁄 𑀳𑁄𑀢𑀺, 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀳𑁄𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄’’𑀢𑀺.

𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀅𑀕𑁆𑀕𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫…𑀧𑁂… ¶ ¶ 𑀉𑀧𑀸𑀲𑀓𑀁 𑀫𑀁 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀥𑀸𑀭𑁂𑀢𑀼 𑀅𑀚𑁆𑀚𑀢𑀕𑁆𑀕𑁂 𑀧𑀸𑀡𑀼𑀧𑁂𑀢𑀁 𑀲𑀭𑀡𑀁 𑀕𑀢’’𑀦𑁆𑀢𑀺.

𑀯𑀲𑀮𑀲𑀼𑀢𑁆𑀢𑀁 𑀲𑀢𑁆𑀢𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀓𑀭𑀡𑀻𑀬𑀫𑀢𑁆𑀣𑀓𑀼𑀲𑀮𑁂𑀦, 𑀬𑀦𑁆𑀢 𑀲𑀦𑁆𑀢𑀁 𑀧𑀤𑀁 𑀅𑀪𑀺𑀲𑀫𑁂𑀘𑁆𑀘;

𑀲𑀓𑁆𑀓𑁄 𑀉𑀚𑀽 𑀘 𑀲𑀼𑀳𑀼𑀚𑀽 [𑀲𑀽𑀚𑀽 (𑀲𑀻.)] 𑀘, 𑀲𑀽𑀯𑀘𑁄 𑀘𑀲𑁆𑀲 𑀫𑀼𑀤𑀼 𑀅𑀦𑀢𑀺𑀫𑀸𑀦𑀻.

𑀲𑀦𑁆𑀢𑀼𑀲𑁆𑀲𑀓𑁄 𑀘 𑀲𑀼𑀪𑀭𑁄 𑀘, 𑀅𑀧𑁆𑀧𑀓𑀺𑀘𑁆𑀘𑁄 𑀘 𑀲𑀮𑁆𑀮𑀳𑀼𑀓𑀯𑀼𑀢𑁆𑀢𑀺;

𑀲𑀦𑁆𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁄 𑀘 𑀦𑀺𑀧𑀓𑁄 𑀘, 𑀅𑀧𑁆𑀧𑀕𑀩𑁆𑀪𑁄 𑀓𑀼𑀮𑁂𑀲𑁆𑀯𑀦𑀦𑀼𑀕𑀺𑀤𑁆𑀥𑁄.

𑀦 ¶ 𑀘 𑀔𑀼𑀤𑁆𑀤𑀫𑀸𑀘𑀭𑁂 𑀓𑀺𑀜𑁆𑀘𑀺, 𑀬𑁂𑀦 𑀯𑀺𑀜𑁆𑀜𑀽 𑀧𑀭𑁂 𑀉𑀧𑀯𑀤𑁂𑀬𑁆𑀬𑀼𑀁;

𑀲𑀼𑀔𑀺𑀦𑁄 𑀯 𑀔𑁂𑀫𑀺𑀦𑁄 𑀳𑁄𑀦𑁆𑀢𑀼, 𑀲𑀩𑁆𑀩𑀲𑀢𑁆𑀢𑀸 [𑀲𑀩𑁆𑀩𑁂 𑀲𑀢𑁆𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀪𑀯𑀦𑁆𑀢𑀼 𑀲𑀼𑀔𑀺𑀢𑀢𑁆𑀢𑀸.

𑀬𑁂 ¶ 𑀓𑁂𑀘𑀺 𑀧𑀸𑀡𑀪𑀽𑀢𑀢𑁆𑀣𑀺, 𑀢𑀲𑀸 ¶ 𑀯𑀸 𑀣𑀸𑀯𑀭𑀸 𑀯𑀦𑀯𑀲𑁂𑀲𑀸;

𑀤𑀻𑀖𑀸 𑀯𑀸 𑀬𑁂 𑀯 𑀫𑀳𑀦𑁆𑀢𑀸 [𑀫𑀳𑀦𑁆𑀢 (?)], 𑀫𑀚𑁆𑀛𑀺𑀫𑀸 𑀭𑀲𑁆𑀲𑀓𑀸 𑀅𑀡𑀼𑀓𑀣𑀽𑀮𑀸.

𑀤𑀺𑀝𑁆𑀞𑀸 ¶ 𑀯𑀸 𑀬𑁂 𑀯 𑀅𑀤𑀺𑀝𑁆𑀞𑀸 [𑀅𑀤𑀺𑀝𑁆𑀞 (?)], 𑀬𑁂 𑀯 [𑀬𑁂 𑀘 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀤𑀽𑀭𑁂 𑀯𑀲𑀦𑁆𑀢𑀺 𑀅𑀯𑀺𑀤𑀽𑀭𑁂;

𑀪𑀽𑀢𑀸 𑀯 𑀲𑀫𑁆𑀪𑀯𑁂𑀲𑀻 𑀯 [𑀪𑀽𑀢𑀸 𑀯𑀸 𑀲𑀫𑁆𑀪𑀯𑁂𑀲𑀻 𑀯𑀸 (𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻. 𑀓.)], 𑀲𑀩𑁆𑀩𑀲𑀢𑁆𑀢𑀸 𑀪𑀯𑀦𑁆𑀢𑀼 𑀲𑀼𑀔𑀺𑀢𑀢𑁆𑀢𑀸.

𑀦 𑀧𑀭𑁄 𑀧𑀭𑀁 𑀦𑀺𑀓𑀼𑀩𑁆𑀩𑁂𑀣, 𑀦𑀸𑀢𑀺𑀫𑀜𑁆𑀜𑁂𑀣 𑀓𑀢𑁆𑀣𑀘𑀺 𑀦 𑀓𑀜𑁆𑀘𑀺 [𑀦𑀁 𑀓𑀜𑁆𑀘𑀺 (𑀲𑀻. 𑀧𑀻.), 𑀦𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 (𑀲𑁆𑀬𑀸.), 𑀦 𑀓𑀺𑀜𑁆𑀘𑀺 (𑀓.)];

𑀩𑁆𑀬𑀸𑀭𑁄𑀲𑀦𑀸 𑀧𑀝𑀺𑀖𑀲𑀜𑁆𑀜𑀸, 𑀦𑀸𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀲𑁆𑀲 𑀤𑀼𑀓𑁆𑀔𑀫𑀺𑀘𑁆𑀙𑁂𑀬𑁆𑀬.

𑀫𑀸𑀢𑀸 𑀬𑀣𑀸 𑀦𑀺𑀬𑀁 𑀧𑀼𑀢𑁆𑀢𑀫𑀸𑀬𑀼𑀲𑀸 𑀏𑀓𑀧𑀼𑀢𑁆𑀢𑀫𑀦𑀼𑀭𑀓𑁆𑀔𑁂;

𑀏𑀯𑀫𑁆𑀧𑀺 𑀲𑀩𑁆𑀩𑀪𑀽𑀢𑁂𑀲𑀼, 𑀫𑀸𑀦𑀲𑀁 𑀪𑀸𑀯𑀬𑁂 𑀅𑀧𑀭𑀺𑀫𑀸𑀡𑀁.

𑀫𑁂𑀢𑁆𑀢𑀜𑁆𑀘 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀲𑁆𑀫𑀺, 𑀫𑀸𑀦𑀲𑀁 𑀪𑀸𑀯𑀬𑁂 𑀅𑀧𑀭𑀺𑀫𑀸𑀡𑀁;

𑀉𑀤𑁆𑀥𑀁 𑀅𑀥𑁄 𑀘 𑀢𑀺𑀭𑀺𑀬𑀜𑁆𑀘, 𑀅𑀲𑀫𑁆𑀩𑀸𑀥𑀁 𑀅𑀯𑁂𑀭𑀫𑀲𑀧𑀢𑁆𑀢𑀁.

𑀢𑀺𑀝𑁆𑀞𑀁 ¶ 𑀘𑀭𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀯 [𑀯𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)], 𑀲𑀬𑀸𑀦𑁄 ¶ 𑀬𑀸𑀯𑀢𑀸𑀲𑁆𑀲 𑀯𑀺𑀢𑀫𑀺𑀤𑁆𑀥𑁄 [𑀯𑀺𑀕𑀢𑀫𑀺𑀤𑁆𑀥𑁄 (𑀩𑀳𑀽𑀲𑀼)];

𑀏𑀢𑀁 𑀲𑀢𑀺𑀁 𑀅𑀥𑀺𑀝𑁆𑀞𑁂𑀬𑁆𑀬, 𑀩𑁆𑀭𑀳𑁆𑀫𑀫𑁂𑀢𑀁 𑀯𑀺𑀳𑀸𑀭𑀫𑀺𑀥𑀫𑀸𑀳𑀼.

𑀤𑀺𑀝𑁆𑀞𑀺𑀜𑁆𑀘 𑀅𑀦𑀼𑀧𑀕𑁆𑀕𑀫𑁆𑀫, 𑀲𑀻𑀮𑀯𑀸 𑀤𑀲𑁆𑀲𑀦𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄;

𑀓𑀸𑀫𑁂𑀲𑀼 𑀯𑀺𑀦𑀬 [𑀯𑀺𑀦𑁂𑀬𑁆𑀬 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀕𑁂𑀥𑀁, 𑀦 𑀳𑀺 𑀚𑀸𑀢𑀼𑀕𑁆𑀕𑀩𑁆𑀪𑀲𑁂𑀬𑁆𑀬 𑀧𑀼𑀦𑀭𑁂𑀢𑀻𑀢𑀺.

𑀫𑁂𑀢𑁆𑀢𑀲𑀼𑀢𑁆𑀢𑀁 𑀅𑀝𑁆𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀅𑀚𑁆𑀚 ¶ 𑀧𑀦𑁆𑀦𑀭𑀲𑁄 𑀉𑀧𑁄𑀲𑀣𑁄, (𑀇𑀢𑀺 𑀲𑀸𑀢𑀸𑀕𑀺𑀭𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀤𑀺𑀩𑁆𑀩𑀸 [𑀤𑀺𑀩𑁆𑀬𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀭𑀢𑁆𑀢𑀺 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸;

𑀅𑀦𑁄𑀫𑀦𑀸𑀫𑀁 𑀲𑀢𑁆𑀣𑀸𑀭𑀁, 𑀳𑀦𑁆𑀤 𑀧𑀲𑁆𑀲𑀸𑀫 𑀕𑁄𑀢𑀫𑀁’’.

‘‘𑀓𑀘𑁆𑀘𑀺 ¶ 𑀫𑀦𑁄 𑀲𑀼𑀧𑀡𑀺𑀳𑀺𑀢𑁄, (𑀇𑀢𑀺 𑀳𑁂𑀫𑀯𑀢𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀓𑀘𑁆𑀘𑀺 𑀇𑀝𑁆𑀞𑁂 𑀅𑀦𑀺𑀝𑁆𑀞𑁂 𑀘, 𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑀲𑁆𑀲 𑀯𑀲𑀻𑀓𑀢𑀸’’.

‘‘𑀫𑀦𑁄 𑀘𑀲𑁆𑀲 𑀲𑀼𑀧𑀡𑀺𑀳𑀺𑀢𑁄, (𑀇𑀢𑀺 𑀲𑀸𑀢𑀸𑀕𑀺𑀭𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀅𑀣𑁄 𑀇𑀝𑁆𑀞𑁂 𑀅𑀦𑀺𑀝𑁆𑀞𑁂 𑀘, 𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑀲𑁆𑀲 𑀯𑀲𑀻𑀓𑀢𑀸’’.

‘‘𑀓𑀘𑁆𑀘𑀺 ¶ 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀦𑀸𑀤𑀺𑀬𑀢𑀺, (𑀇𑀢𑀺 𑀳𑁂𑀫𑀯𑀢𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀓𑀘𑁆𑀘𑀺 𑀆𑀭𑀸 𑀧𑀫𑀸𑀤𑀫𑁆𑀳𑀸, 𑀓𑀘𑁆𑀘𑀺 𑀛𑀸𑀦𑀁 𑀦 𑀭𑀺𑀜𑁆𑀘𑀢𑀺’’.

‘‘𑀦 ¶ 𑀲𑁄 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀆𑀤𑀺𑀬𑀢𑀺, (𑀇𑀢𑀺 𑀲𑀸𑀢𑀸𑀕𑀺𑀭𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀅𑀣𑁄 𑀆𑀭𑀸 𑀧𑀫𑀸𑀤𑀫𑁆𑀳𑀸, 𑀩𑀼𑀤𑁆𑀥𑁄 𑀛𑀸𑀦𑀁 𑀦 𑀭𑀺𑀜𑁆𑀘𑀢𑀺’’.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀫𑀼𑀲𑀸 𑀦 𑀪𑀡𑀢𑀺, (𑀇𑀢𑀺 𑀳𑁂𑀫𑀯𑀢𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀓𑀘𑁆𑀘𑀺 ¶ 𑀯𑁂𑀪𑀽𑀢𑀺𑀬𑀁 𑀦𑀸𑀳, 𑀓𑀘𑁆𑀘𑀺 𑀲𑀫𑁆𑀨𑀁 𑀦 𑀪𑀸𑀲𑀢𑀺’’.

‘‘𑀫𑀼𑀲𑀸 𑀘 𑀲𑁄 𑀦 𑀪𑀡𑀢𑀺, (𑀇𑀢𑀺 𑀲𑀸𑀢𑀸𑀕𑀺𑀭𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀅𑀣𑁄 𑀯𑁂𑀪𑀽𑀢𑀺𑀬𑀁 𑀦𑀸𑀳, 𑀫𑀦𑁆𑀢𑀸 𑀅𑀢𑁆𑀣𑀁 𑀘 [𑀅𑀢𑁆𑀣𑀁 𑀲𑁄 (𑀲𑀻. 𑀧𑀻. 𑀓.)] 𑀪𑀸𑀲𑀢𑀺’’.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀦 𑀭𑀚𑁆𑀚𑀢𑀺 𑀓𑀸𑀫𑁂𑀲𑀼, (𑀇𑀢𑀺 𑀳𑁂𑀫𑀯𑀢𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀓𑀘𑁆𑀘𑀺 𑀫𑁄𑀳𑀁 𑀅𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁄, 𑀓𑀘𑁆𑀘𑀺 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀘𑀓𑁆𑀔𑀼𑀫𑀸’’.

‘‘𑀦 ¶ 𑀲𑁄 𑀭𑀚𑁆𑀚𑀢𑀺 𑀓𑀸𑀫𑁂𑀲𑀼, (𑀇𑀢𑀺 𑀲𑀸𑀢𑀸𑀕𑀺𑀭𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀲𑀩𑁆𑀩𑀫𑁄𑀳𑀁 𑀅𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁄, 𑀩𑀼𑀤𑁆𑀥𑁄 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀘𑀓𑁆𑀔𑀼𑀫𑀸’’.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀯𑀺𑀚𑁆𑀚𑀸𑀬 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, (𑀇𑀢𑀺 𑀳𑁂𑀫𑀯𑀢𑁄 𑀬𑀓𑁆𑀔𑁄 )

𑀓𑀘𑁆𑀘𑀺𑀲𑁆𑀲 ¶ 𑀆𑀲𑀯𑀸 𑀔𑀻𑀡𑀸, 𑀓𑀘𑁆𑀘𑀺 𑀦𑀢𑁆𑀣𑀺 𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑁄’’.

‘‘𑀯𑀺𑀚𑁆𑀚𑀸𑀬 ¶ 𑀘𑁂𑀯 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, (𑀇𑀢𑀺 𑀲𑀸𑀢𑀸𑀕𑀺𑀭𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀲𑀩𑁆𑀩𑀲𑁆𑀲 𑀆𑀲𑀯𑀸 𑀔𑀻𑀡𑀸, 𑀦𑀢𑁆𑀣𑀺 𑀢𑀲𑁆𑀲 𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑁄’’.

‘‘𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁 ¶ 𑀫𑀼𑀦𑀺𑀦𑁄 𑀘𑀺𑀢𑁆𑀢𑀁, 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀩𑁆𑀬𑀧𑁆𑀧𑀣𑁂𑀦 𑀘;

𑀯𑀺𑀚𑁆𑀚𑀸𑀘𑀭𑀡𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁, 𑀥𑀫𑁆𑀫𑀢𑁄 𑀦𑀁 𑀧𑀲𑀁𑀲𑀢𑀺’’.

‘‘𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁 𑀫𑀼𑀦𑀺𑀦𑁄 𑀘𑀺𑀢𑁆𑀢𑀁, 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀩𑁆𑀬𑀧𑁆𑀧𑀣𑁂𑀦 𑀘;

𑀯𑀺𑀚𑁆𑀚𑀸𑀘𑀭𑀡𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁, 𑀥𑀫𑁆𑀫𑀢𑁄 𑀅𑀦𑀼𑀫𑁄𑀤𑀲𑀺’’.

‘‘𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁 𑀫𑀼𑀦𑀺𑀦𑁄 𑀘𑀺𑀢𑁆𑀢𑀁, 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀩𑁆𑀬𑀧𑁆𑀧𑀣𑁂𑀦 𑀘;

𑀯𑀺𑀚𑁆𑀚𑀸𑀘𑀭𑀡𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁, 𑀳𑀦𑁆𑀤 𑀧𑀲𑁆𑀲𑀸𑀫 𑀕𑁄𑀢𑀫𑀁.

‘‘𑀏𑀡𑀺𑀚𑀗𑁆𑀖𑀁 𑀓𑀺𑀲𑀁 𑀯𑀻𑀭𑀁 [𑀥𑀻𑀭𑀁 (𑀲𑁆𑀬𑀸.)], 𑀅𑀧𑁆𑀧𑀸𑀳𑀸𑀭𑀁 𑀅𑀮𑁄𑀮𑀼𑀧𑀁;

𑀫𑀼𑀦𑀺𑀁 𑀯𑀦𑀲𑁆𑀫𑀺𑀁 𑀛𑀸𑀬𑀦𑁆𑀢𑀁, 𑀏𑀳𑀺 𑀧𑀲𑁆𑀲𑀸𑀫 𑀕𑁄𑀢𑀫𑀁.

‘‘𑀲𑀻𑀳𑀁𑀯𑁂𑀓𑀘𑀭𑀁 𑀦𑀸𑀕𑀁, 𑀓𑀸𑀫𑁂𑀲𑀼 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑀺𑀦𑀁;

𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑁆𑀫 𑀧𑀼𑀘𑁆𑀙𑀸𑀫, 𑀫𑀘𑁆𑀘𑀼𑀧𑀸𑀲𑀧𑁆𑀧𑀫𑁄𑀘𑀦𑀁.

‘‘𑀅𑀓𑁆𑀔𑀸𑀢𑀸𑀭𑀁 𑀧𑀯𑀢𑁆𑀢𑀸𑀭𑀁, 𑀲𑀩𑁆𑀩𑀥𑀫𑁆𑀫𑀸𑀦 𑀧𑀸𑀭𑀕𑀼𑀁;

𑀩𑀼𑀤𑁆𑀥𑀁 𑀯𑁂𑀭𑀪𑀬𑀸𑀢𑀻𑀢𑀁, 𑀫𑀬𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫 𑀕𑁄𑀢𑀫𑀁’’.

‘‘𑀓𑀺𑀲𑁆𑀫𑀺𑀁 ¶ 𑀮𑁄𑀓𑁄 𑀲𑀫𑀼𑀧𑁆𑀧𑀦𑁆𑀦𑁄, (𑀇𑀢𑀺 𑀳𑁂𑀫𑀯𑀢𑁄 𑀬𑀓𑁆𑀔𑁄)

𑀓𑀺𑀲𑁆𑀫𑀺𑀁 𑀓𑀼𑀩𑁆𑀩𑀢𑀺 𑀲𑀦𑁆𑀣𑀯𑀁 [𑀲𑀦𑁆𑀥𑀯𑀁 (𑀓.)];

𑀓𑀺𑀲𑁆𑀲 𑀮𑁄𑀓𑁄 𑀉𑀧𑀸𑀤𑀸𑀬, 𑀓𑀺𑀲𑁆𑀫𑀺𑀁 𑀮𑁄𑀓𑁄 𑀯𑀺𑀳𑀜𑁆𑀜𑀢𑀺’’.

‘‘𑀙𑀲𑀼 ¶ ¶ [𑀙𑀲𑁆𑀲𑀼 (𑀲𑀻. 𑀧𑀻.)] 𑀮𑁄𑀓𑁄 𑀲𑀫𑀼𑀧𑁆𑀧𑀦𑁆𑀦𑁄, (𑀳𑁂𑀫𑀯𑀢𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀙𑀦𑁆𑀦𑀫𑁂𑀯 𑀉𑀧𑀸𑀤𑀸𑀬, 𑀙𑀲𑀼 𑀮𑁄𑀓𑁄 𑀯𑀺𑀳𑀜𑁆𑀜𑀢𑀺’’.

‘‘𑀓𑀢𑀫𑀁 𑀢𑀁 𑀉𑀧𑀸𑀤𑀸𑀦𑀁, 𑀬𑀢𑁆𑀣 𑀮𑁄𑀓𑁄 𑀯𑀺𑀳𑀜𑁆𑀜𑀢𑀺;

𑀦𑀺𑀬𑁆𑀬𑀸𑀦𑀁 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀣𑀁 𑀤𑀼𑀓𑁆𑀔𑀸 𑀧𑀫𑀼𑀘𑁆𑀘𑀢𑀺’’ [𑀧𑀫𑀼𑀜𑁆𑀘𑀢𑀺 (𑀲𑁆𑀬𑀸.)].

‘‘𑀧𑀜𑁆𑀘 𑀓𑀸𑀫𑀕𑀼𑀡𑀸 𑀮𑁄𑀓𑁂, 𑀫𑀦𑁄𑀙𑀝𑁆𑀞𑀸 𑀧𑀯𑁂𑀤𑀺𑀢𑀸;

𑀏𑀢𑁆𑀣 𑀙𑀦𑁆𑀤𑀁 𑀯𑀺𑀭𑀸𑀚𑁂𑀢𑁆𑀯𑀸, 𑀏𑀯𑀁 𑀤𑀼𑀓𑁆𑀔𑀸 𑀧𑀫𑀼𑀘𑁆𑀘𑀢𑀺.

‘‘𑀏𑀢𑀁 𑀮𑁄𑀓𑀲𑁆𑀲 𑀦𑀺𑀬𑁆𑀬𑀸𑀦𑀁, 𑀅𑀓𑁆𑀔𑀸𑀢𑀁 𑀯𑁄 𑀬𑀣𑀸𑀢𑀣𑀁;

𑀏𑀢𑀁 𑀯𑁄 𑀅𑀳𑀫𑀓𑁆𑀔𑀸𑀫𑀺, 𑀏𑀯𑀁 𑀤𑀼𑀓𑁆𑀔𑀸 𑀧𑀫𑀼𑀘𑁆𑀘𑀢𑀺’’.

‘‘𑀓𑁄 ¶ 𑀲𑀽𑀥 𑀢𑀭𑀢𑀺 𑀑𑀖𑀁, 𑀓𑁄𑀥 𑀢𑀭𑀢𑀺 𑀅𑀡𑁆𑀡𑀯𑀁;

𑀅𑀧𑁆𑀧𑀢𑀺𑀝𑁆𑀞𑁂 𑀅𑀦𑀸𑀮𑀫𑁆𑀩𑁂, 𑀓𑁄 𑀕𑀫𑁆𑀪𑀻𑀭𑁂 𑀦 𑀲𑀻𑀤𑀢𑀺’’.

‘‘𑀲𑀩𑁆𑀩𑀤𑀸 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀧𑀜𑁆𑀜𑀯𑀸 𑀲𑀼𑀲𑀫𑀸𑀳𑀺𑀢𑁄;

𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀘𑀺𑀦𑁆𑀢𑀻 [𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀲𑀜𑁆𑀜𑀻 (𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀓.)] 𑀲𑀢𑀺𑀫𑀸, 𑀑𑀖𑀁 𑀢𑀭𑀢𑀺 𑀤𑀼𑀢𑁆𑀢𑀭𑀁.

‘‘𑀯𑀺𑀭𑀢𑁄 𑀓𑀸𑀫𑀲𑀜𑁆𑀜𑀸𑀬, 𑀲𑀩𑁆𑀩𑀲𑀁𑀬𑁄𑀚𑀦𑀸𑀢𑀺𑀕𑁄;

𑀦𑀦𑁆𑀤𑀻𑀪𑀯𑀧𑀭𑀺𑀓𑁆𑀔𑀻𑀡𑁄, 𑀲𑁄 𑀕𑀫𑁆𑀪𑀻𑀭𑁂 𑀦 𑀲𑀻𑀤𑀢𑀺’’.

‘‘𑀕𑀩𑁆𑀪𑀻𑀭𑀧𑀜𑁆𑀜𑀁 𑀦𑀺𑀧𑀼𑀡𑀢𑁆𑀣𑀤𑀲𑁆𑀲𑀺𑀁, 𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀁 𑀓𑀸𑀫𑀪𑀯𑁂 𑀅𑀲𑀢𑁆𑀢𑀁;

𑀢𑀁 𑀧𑀲𑁆𑀲𑀣 𑀲𑀩𑁆𑀩𑀥𑀺 𑀯𑀺𑀧𑁆𑀧𑀫𑀼𑀢𑁆𑀢𑀁, 𑀤𑀺𑀩𑁆𑀩𑁂 𑀧𑀣𑁂 𑀓𑀫𑀫𑀸𑀦𑀁 𑀫𑀳𑁂𑀲𑀺𑀁.

‘‘𑀅𑀦𑁄𑀫𑀦𑀸𑀫𑀁 ¶ 𑀦𑀺𑀧𑀼𑀡𑀢𑁆𑀣𑀤𑀲𑁆𑀲𑀺𑀁, 𑀧𑀜𑁆𑀜𑀸𑀤𑀤𑀁 ¶ 𑀓𑀸𑀫𑀸𑀮𑀬𑁂 𑀅𑀲𑀢𑁆𑀢𑀁;

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

‘‘𑀲𑀼𑀤𑀺𑀝𑁆𑀞𑀁 𑀯𑀢 𑀦𑁄 𑀅𑀚𑁆𑀚, 𑀲𑀼𑀧𑁆𑀧𑀪𑀸𑀢𑀁 𑀲𑀼𑀳𑀼𑀝𑁆𑀞𑀺𑀢𑀁;

𑀬𑀁 𑀅𑀤𑁆𑀤𑀲𑀸𑀫 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁, 𑀑𑀖𑀢𑀺𑀡𑁆𑀡𑀫𑀦𑀸𑀲𑀯𑀁.

‘‘𑀇𑀫𑁂 𑀤𑀲𑀲𑀢𑀸 𑀬𑀓𑁆𑀔𑀸, 𑀇𑀤𑁆𑀥𑀺𑀫𑀦𑁆𑀢𑁄 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄;

𑀲𑀩𑁆𑀩𑁂 𑀢𑀁 𑀲𑀭𑀡𑀁 𑀬𑀦𑁆𑀢𑀺, 𑀢𑁆𑀯𑀁 𑀦𑁄 𑀲𑀢𑁆𑀣𑀸 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑁄.

‘‘𑀢𑁂 𑀫𑀬𑀁 𑀯𑀺𑀘𑀭𑀺𑀲𑁆𑀲𑀸𑀫, 𑀕𑀸𑀫𑀸 𑀕𑀸𑀫𑀁 𑀦𑀕𑀸 𑀦𑀕𑀁;

𑀦𑀫𑀲𑁆𑀲𑀫𑀸𑀦𑀸 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁, 𑀥𑀫𑁆𑀫𑀲𑁆𑀲 𑀘 𑀲𑀼𑀥𑀫𑁆𑀫𑀢’’𑀦𑁆𑀢𑀺.

𑀳𑁂𑀫𑀯𑀢𑀲𑀼𑀢𑁆𑀢𑀁 𑀦𑀯𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀆𑀴𑀯𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀆𑀴𑀯𑀓𑀲𑁆𑀲 𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀪𑀯𑀦𑁂. 𑀅𑀣 𑀔𑁄 𑀆𑀴𑀯𑀓𑁄 𑀬𑀓𑁆𑀔𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀦𑀺𑀓𑁆𑀔𑀫, 𑀲𑀫𑀡𑀸’’𑀢𑀺. ‘‘𑀲𑀸𑀥𑀸𑀯𑀼𑀲𑁄’’𑀢𑀺 ¶ 𑀪𑀕𑀯𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑀺. ‘‘𑀧𑀯𑀺𑀲, 𑀲𑀫𑀡𑀸’’𑀢𑀺. ‘‘𑀲𑀸𑀥𑀸𑀯𑀼𑀲𑁄’’𑀢𑀺 𑀪𑀕𑀯𑀸 𑀧𑀸𑀯𑀺𑀲𑀺.

𑀤𑀼𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀔𑁄…𑀧𑁂… 𑀢𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀔𑁄 𑀆𑀴𑀯𑀓𑁄 𑀬𑀓𑁆𑀔𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀦𑀺𑀓𑁆𑀔𑀫, 𑀲𑀫𑀡𑀸’’𑀢𑀺. ‘‘𑀲𑀸𑀥𑀸𑀯𑀼𑀲𑁄’’𑀢𑀺 ¶ 𑀪𑀕𑀯𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑀺. ‘‘𑀧𑀯𑀺𑀲, 𑀲𑀫𑀡𑀸’’𑀢𑀺. ‘‘𑀲𑀸𑀥𑀸𑀯𑀼𑀲𑁄’’𑀢𑀺 𑀪𑀕𑀯𑀸 𑀧𑀸𑀯𑀺𑀲𑀺.

𑀘𑀢𑀼𑀢𑁆𑀣𑀫𑁆𑀧𑀺 𑀔𑁄 𑀆𑀴𑀯𑀓𑁄 𑀬𑀓𑁆𑀔𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀦𑀺𑀓𑁆𑀔𑀫, 𑀲𑀫𑀡𑀸’’𑀢𑀺. ‘‘𑀦 𑀔𑁆𑀯𑀸𑀳𑀁 𑀢𑀁 ¶ , 𑀆𑀯𑀼𑀲𑁄, 𑀦𑀺𑀓𑁆𑀔𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺. 𑀬𑀁 𑀢𑁂 𑀓𑀭𑀡𑀻𑀬𑀁, 𑀢𑀁 𑀓𑀭𑁄𑀳𑀻’’𑀢𑀺.

‘‘𑀧𑀜𑁆𑀳𑀁 ¶ 𑀢𑀁, 𑀲𑀫𑀡, 𑀧𑀼𑀘𑁆𑀙𑀺𑀲𑁆𑀲𑀸𑀫𑀺. 𑀲𑀘𑁂 𑀫𑁂 𑀦 𑀩𑁆𑀬𑀸𑀓𑀭𑀺𑀲𑁆𑀲𑀲𑀺, 𑀘𑀺𑀢𑁆𑀢𑀁 𑀯𑀸 𑀢𑁂 𑀔𑀺𑀧𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀳𑀤𑀬𑀁 𑀯𑀸 𑀢𑁂 𑀨𑀸𑀮𑁂𑀲𑁆𑀲𑀸𑀫𑀺, 𑀧𑀸𑀤𑁂𑀲𑀼 𑀯𑀸 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀧𑀸𑀭𑀕𑀗𑁆𑀕𑀸𑀬 𑀔𑀺𑀧𑀺𑀲𑁆𑀲𑀸𑀫𑀻’’𑀢𑀺.

‘‘𑀦 𑀔𑁆𑀯𑀸𑀳𑀁 𑀢𑀁, 𑀆𑀯𑀼𑀲𑁄, 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀲𑀤𑁂𑀯𑀓𑁂 𑀮𑁄𑀓𑁂 𑀲𑀫𑀸𑀭𑀓𑁂 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑁂 𑀲𑀲𑁆𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀺𑀬𑀸 𑀧𑀚𑀸𑀬 𑀲𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀬 𑀬𑁄 𑀫𑁂 𑀘𑀺𑀢𑁆𑀢𑀁 𑀯𑀸 𑀔𑀺𑀧𑁂𑀬𑁆𑀬 𑀳𑀤𑀬𑀁 𑀯𑀸 𑀨𑀸𑀮𑁂𑀬𑁆𑀬 𑀧𑀸𑀤𑁂𑀲𑀼 𑀯𑀸 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀧𑀸𑀭𑀕𑀗𑁆𑀕𑀸𑀬 𑀔𑀺𑀧𑁂𑀬𑁆𑀬. 𑀅𑀧𑀺 𑀘 𑀢𑁆𑀯𑀁, 𑀆𑀯𑀼𑀲𑁄, 𑀧𑀼𑀘𑁆𑀙 𑀬𑀤𑀸𑀓𑀗𑁆𑀔𑀲𑀻’’𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀆𑀴𑀯𑀓𑁄 𑀬𑀓𑁆𑀔𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀓𑀺𑀁 𑀲𑀽𑀥 𑀯𑀺𑀢𑁆𑀢𑀁 𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 𑀲𑁂𑀝𑁆𑀞𑀁, 𑀓𑀺𑀁 𑀲𑀼 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑀁 𑀲𑀼𑀔𑀫𑀸𑀯𑀳𑀸𑀢𑀺;

𑀓𑀺𑀁 𑀲𑀼 [𑀓𑀺𑀁 𑀲𑀽 (𑀲𑀻.)] 𑀳𑀯𑁂 𑀲𑀸𑀤𑀼𑀢𑀭𑀁 𑀭𑀲𑀸𑀦𑀁, 𑀓𑀣𑀁 𑀚𑀻𑀯𑀺𑀁 𑀚𑀻𑀯𑀺𑀢𑀫𑀸𑀳𑀼 𑀲𑁂𑀝𑁆𑀞𑀁’’.

‘‘𑀲𑀤𑁆𑀥𑀻𑀥 𑀯𑀺𑀢𑁆𑀢𑀁 𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 𑀲𑁂𑀝𑁆𑀞𑀁, 𑀥𑀫𑁆𑀫𑁄 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑁄 𑀲𑀼𑀔𑀫𑀸𑀯𑀳𑀸𑀢𑀺;

𑀲𑀘𑁆𑀘𑀁 𑀳𑀯𑁂 𑀲𑀸𑀤𑀼𑀢𑀭𑀁 𑀭𑀲𑀸𑀦𑀁, 𑀧𑀜𑁆𑀜𑀸𑀚𑀻𑀯𑀺𑀁 𑀚𑀻𑀯𑀺𑀢𑀫𑀸𑀳𑀼 𑀲𑁂𑀝𑁆𑀞𑀁’’.

‘‘𑀓𑀣𑀁 𑀲𑀼 𑀢𑀭𑀢𑀺 𑀑𑀖𑀁, 𑀓𑀣𑀁 𑀲𑀼 𑀢𑀭𑀢𑀺 𑀅𑀡𑁆𑀡𑀯𑀁;

𑀓𑀣𑀁 ¶ 𑀲𑀼 𑀤𑀼𑀓𑁆𑀔𑀫𑀘𑁆𑀘𑁂𑀢𑀺, 𑀓𑀣𑀁 𑀲𑀼 𑀧𑀭𑀺𑀲𑀼𑀚𑁆𑀛𑀢𑀺’’.

‘‘𑀲𑀤𑁆𑀥𑀸 ¶ 𑀢𑀭𑀢𑀺 𑀑𑀖𑀁, 𑀅𑀧𑁆𑀧𑀫𑀸𑀤𑁂𑀦 𑀅𑀡𑁆𑀡𑀯𑀁;

𑀯𑀻𑀭𑀺𑀬𑁂𑀦 [𑀯𑀺𑀭𑀺𑀬𑁂𑀦 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀤𑀼𑀓𑁆𑀔𑀫𑀘𑁆𑀘𑁂𑀢𑀺, 𑀧𑀜𑁆𑀜𑀸𑀬 𑀧𑀭𑀺𑀲𑀼𑀚𑁆𑀛𑀢𑀺’’.

‘‘𑀓𑀣𑀁 ¶ 𑀲𑀼 𑀮𑀪𑀢𑁂 𑀧𑀜𑁆𑀜𑀁, 𑀓𑀣𑀁 𑀲𑀼 𑀯𑀺𑀦𑁆𑀤𑀢𑁂 𑀥𑀦𑀁;

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

𑀅𑀲𑁆𑀫𑀸 𑀮𑁄𑀓𑀸 𑀧𑀭𑀁 𑀮𑁄𑀓𑀁, 𑀓𑀣𑀁 𑀧𑁂𑀘𑁆𑀘 𑀦 𑀲𑁄𑀘𑀢𑀺’’.

‘‘𑀲𑀤𑁆𑀤𑀳𑀸𑀦𑁄 𑀅𑀭𑀳𑀢𑀁, 𑀥𑀫𑁆𑀫𑀁 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀧𑀢𑁆𑀢𑀺𑀬𑀸;

𑀲𑀼𑀲𑁆𑀲𑀽𑀲𑀁 [𑀲𑀼𑀲𑁆𑀲𑀽𑀲𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀮𑀪𑀢𑁂 𑀧𑀜𑁆𑀜𑀁, 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄 𑀯𑀺𑀘𑀓𑁆𑀔𑀡𑁄.

‘‘𑀧𑀢𑀺𑀭𑀽𑀧𑀓𑀸𑀭𑀻 𑀥𑀼𑀭𑀯𑀸, 𑀉𑀝𑁆𑀞𑀸𑀢𑀸 𑀯𑀺𑀦𑁆𑀤𑀢𑁂 𑀥𑀦𑀁;

𑀲𑀘𑁆𑀘𑁂𑀦 𑀓𑀺𑀢𑁆𑀢𑀺𑀁 𑀧𑀧𑁆𑀧𑁄𑀢𑀺, 𑀤𑀤𑀁 𑀫𑀺𑀢𑁆𑀢𑀸𑀦𑀺 𑀕𑀦𑁆𑀣𑀢𑀺.

‘‘𑀬𑀲𑁆𑀲𑁂𑀢𑁂 ¶ 𑀘𑀢𑀼𑀭𑁄 𑀥𑀫𑁆𑀫𑀸, 𑀲𑀤𑁆𑀥𑀲𑁆𑀲 𑀖𑀭𑀫𑁂𑀲𑀺𑀦𑁄;

𑀲𑀘𑁆𑀘𑀁 𑀥𑀫𑁆𑀫𑁄 [𑀤𑀫𑁄 (?)] 𑀥𑀺𑀢𑀺 𑀘𑀸𑀕𑁄, 𑀲 𑀯𑁂 𑀧𑁂𑀘𑁆𑀘 𑀦 𑀲𑁄𑀘𑀢𑀺.

‘‘𑀇𑀗𑁆𑀖 𑀅𑀜𑁆𑀜𑁂𑀧𑀺 𑀧𑀼𑀘𑁆𑀙𑀲𑁆𑀲𑀼, 𑀧𑀼𑀣𑀽 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂;

𑀬𑀤𑀺 𑀲𑀘𑁆𑀘𑀸 𑀤𑀫𑀸 𑀘𑀸𑀕𑀸, 𑀔𑀦𑁆𑀢𑁆𑀬𑀸 𑀪𑀺𑀬𑁆𑀬𑁄𑀥 𑀯𑀺𑀚𑁆𑀚𑀢𑀺’’.

‘‘𑀓𑀣𑀁 𑀦𑀼 𑀤𑀸𑀦𑀺 𑀧𑀼𑀘𑁆𑀙𑁂𑀬𑁆𑀬𑀁, 𑀧𑀼𑀣𑀽 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂;

𑀬𑁄𑀳𑀁 [𑀲𑁄𑀳𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀅𑀚𑁆𑀚 𑀧𑀚𑀸𑀦𑀸𑀫𑀺, 𑀬𑁄 𑀅𑀢𑁆𑀣𑁄 𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑀺𑀓𑁄.

‘‘𑀅𑀢𑁆𑀣𑀸𑀬 𑀯𑀢 𑀫𑁂 𑀩𑀼𑀤𑁆𑀥𑁄, 𑀯𑀸𑀲𑀸𑀬𑀸𑀴𑀯𑀺𑀫𑀸𑀕𑀫𑀸;

𑀬𑁄𑀳𑀁 [𑀅𑀝𑁆𑀞𑀺𑀦𑁆𑀳𑀸𑀭𑀽𑀳𑀺 𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀅𑀚𑁆𑀚 𑀧𑀚𑀸𑀦𑀸𑀫𑀺, 𑀬𑀢𑁆𑀣 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

‘‘𑀲𑁄 𑀅𑀳𑀁 𑀯𑀺𑀘𑀭𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀕𑀸𑀫𑀸 𑀕𑀸𑀫𑀁 𑀧𑀼𑀭𑀸 𑀧𑀼𑀭𑀁;

𑀦𑀫𑀲𑁆𑀲𑀫𑀸𑀦𑁄 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁, 𑀥𑀫𑁆𑀫𑀲𑁆𑀲 𑀘 𑀲𑀼𑀥𑀫𑁆𑀫𑀢’’𑀦𑁆𑀢𑀺.

𑀆𑀴𑀯𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀘𑀭𑀁 ¶ ¶ 𑀯𑀸 𑀬𑀤𑀺 𑀯𑀸 𑀢𑀺𑀝𑁆𑀞𑀁, 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀉𑀤 𑀯𑀸 𑀲𑀬𑀁;

𑀲𑀫𑀺𑀜𑁆𑀚𑁂𑀢𑀺 𑀧𑀲𑀸𑀭𑁂𑀢𑀺, 𑀏𑀲𑀸 𑀓𑀸𑀬𑀲𑁆𑀲 𑀇𑀜𑁆𑀚𑀦𑀸.

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

𑀙𑀯𑀺𑀬𑀸 𑀓𑀸𑀬𑁄 𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑁄, 𑀬𑀣𑀸𑀪𑀽𑀢𑀁 𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑀅𑀦𑁆𑀢𑀧𑀽𑀭𑁄 ¶ 𑀉𑀤𑀭𑀧𑀽𑀭𑁄, 𑀬𑀓𑀦𑀧𑁂𑀴𑀲𑁆𑀲 [𑀬𑀓𑀧𑁂𑀴𑀲𑁆𑀲 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀯𑀢𑁆𑀣𑀺𑀦𑁄;

𑀳𑀤𑀬𑀲𑁆𑀲 𑀧𑀧𑁆𑀨𑀸𑀲𑀲𑁆𑀲, 𑀯𑀓𑁆𑀓𑀲𑁆𑀲 𑀧𑀺𑀳𑀓𑀲𑁆𑀲 𑀘.

𑀲𑀺𑀗𑁆𑀖𑀸𑀡𑀺𑀓𑀸𑀬 ¶ 𑀔𑁂𑀴𑀲𑁆𑀲, 𑀲𑁂𑀤𑀲𑁆𑀲 𑀘 𑀫𑁂𑀤𑀲𑁆𑀲 𑀘;

𑀮𑁄𑀳𑀺𑀢𑀲𑁆𑀲 𑀮𑀲𑀺𑀓𑀸𑀬, 𑀧𑀺𑀢𑁆𑀢𑀲𑁆𑀲 𑀘 𑀯𑀲𑀸𑀬 𑀘.

𑀅𑀣𑀲𑁆𑀲 𑀦𑀯𑀳𑀺 𑀲𑁄𑀢𑁂𑀳𑀺, 𑀅𑀲𑀼𑀘𑀻 𑀲𑀯𑀢𑀺 𑀲𑀩𑁆𑀩𑀤𑀸;

𑀅𑀓𑁆𑀔𑀺𑀫𑁆𑀳𑀸 𑀅𑀓𑁆𑀔𑀺𑀕𑀽𑀣𑀓𑁄, 𑀓𑀡𑁆𑀡𑀫𑁆𑀳𑀸 𑀓𑀡𑁆𑀡𑀕𑀽𑀣𑀓𑁄.

𑀲𑀺𑀗𑁆𑀖𑀸𑀡𑀺𑀓𑀸 𑀘 𑀦𑀸𑀲𑀢𑁄, 𑀫𑀼𑀔𑁂𑀦 𑀯𑀫𑀢𑁂𑀓𑀤𑀸;

𑀧𑀺𑀢𑁆𑀢𑀁 𑀲𑁂𑀫𑁆𑀳𑀜𑁆𑀘 𑀯𑀫𑀢𑀺, 𑀓𑀸𑀬𑀫𑁆𑀳𑀸 𑀲𑁂𑀤𑀚𑀮𑁆𑀮𑀺𑀓𑀸.

𑀅𑀣𑀲𑁆𑀲 𑀲𑀼𑀲𑀺𑀭𑀁 𑀲𑀻𑀲𑀁, 𑀫𑀢𑁆𑀣𑀮𑀼𑀗𑁆𑀕𑀲𑁆𑀲 𑀧𑀽𑀭𑀺𑀢𑀁;

𑀲𑀼𑀪𑀢𑁄 𑀦𑀁 𑀫𑀜𑁆𑀜𑀢𑀺, 𑀩𑀸𑀮𑁄 𑀅𑀯𑀺𑀚𑁆𑀚𑀸𑀬 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄.

𑀬𑀤𑀸 𑀘 𑀲𑁄 𑀫𑀢𑁄 𑀲𑁂𑀢𑀺, 𑀉𑀤𑁆𑀥𑀼𑀫𑀸𑀢𑁄 𑀯𑀺𑀦𑀻𑀮𑀓𑁄;

𑀅𑀧𑀯𑀺𑀤𑁆𑀥𑁄 𑀲𑀼𑀲𑀸𑀦𑀲𑁆𑀫𑀺𑀁, 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑀸 𑀳𑁄𑀦𑁆𑀢𑀺 𑀜𑀸𑀢𑀬𑁄.

𑀔𑀸𑀤𑀦𑁆𑀢𑀺 𑀦𑀁 𑀲𑀼𑀯𑀸𑀦𑀸 [𑀲𑀼𑀧𑀸𑀡𑀸 (𑀧𑀻.)] 𑀘, 𑀲𑀺𑀗𑁆𑀕𑀸𑀮𑀸 [𑀲𑀺𑀕𑀸𑀮𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀯𑀓𑀸 𑀓𑀺𑀫𑀻;

𑀓𑀸𑀓𑀸 ¶ 𑀕𑀺𑀚𑁆𑀛𑀸 𑀘 𑀔𑀸𑀤𑀦𑁆𑀢𑀺, 𑀬𑁂 𑀘𑀜𑁆𑀜𑁂 𑀲𑀦𑁆𑀢𑀺 𑀧𑀸𑀡𑀺𑀦𑁄.

𑀲𑀼𑀢𑁆𑀯𑀸𑀦 ¶ 𑀩𑀼𑀤𑁆𑀥𑀯𑀘𑀦𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀜𑁆𑀜𑀸𑀡𑀯𑀸 𑀇𑀥;

𑀲𑁄 𑀔𑁄 𑀦𑀁 𑀧𑀭𑀺𑀚𑀸𑀦𑀸𑀢𑀺, 𑀬𑀣𑀸𑀪𑀽𑀢𑀜𑁆𑀳𑀺 𑀧𑀲𑁆𑀲𑀢𑀺.

𑀬𑀣𑀸 𑀇𑀤𑀁 𑀢𑀣𑀸 𑀏𑀢𑀁, 𑀬𑀣𑀸 𑀏𑀢𑀁 𑀢𑀣𑀸 𑀇𑀤𑀁;

𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀜𑁆𑀘 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘, 𑀓𑀸𑀬𑁂 𑀙𑀦𑁆𑀤𑀁 𑀯𑀺𑀭𑀸𑀚𑀬𑁂.

𑀙𑀦𑁆𑀤𑀭𑀸𑀕𑀯𑀺𑀭𑀢𑁆𑀢𑁄 𑀲𑁄, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀜𑁆𑀜𑀸𑀡𑀯𑀸 𑀇𑀥;

𑀅𑀚𑁆𑀛𑀕𑀸 𑀅𑀫𑀢𑀁 𑀲𑀦𑁆𑀢𑀺𑀁, 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀁 𑀧𑀤𑀫𑀘𑁆𑀘𑀼𑀢𑀁.

𑀤𑁆𑀯𑀺𑀧𑀸𑀤𑀓𑁄𑀬𑀁 [𑀤𑀺𑀧𑀸𑀤𑀓𑁄𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀅𑀲𑀼𑀘𑀺, 𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑁄 𑀧𑀭𑀺𑀳𑀸𑀭𑀢𑀺 [𑀧𑀭𑀺𑀳𑀻𑀭𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)];

𑀦𑀸𑀦𑀸𑀓𑀼𑀡𑀧𑀧𑀭𑀺𑀧𑀽𑀭𑁄, 𑀯𑀺𑀲𑁆𑀲𑀯𑀦𑁆𑀢𑁄 𑀢𑀢𑁄 𑀢𑀢𑁄.

𑀏𑀢𑀸𑀤𑀺𑀲𑁂𑀦 ¶ 𑀓𑀸𑀬𑁂𑀦, 𑀬𑁄 𑀫𑀜𑁆𑀜𑁂 𑀉𑀡𑁆𑀡𑀫𑁂𑀢𑀯𑁂 [𑀉𑀦𑁆𑀦𑀫𑁂𑀢𑀯𑁂 (?)];

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

𑀯𑀺𑀚𑀬𑀲𑀼𑀢𑁆𑀢𑀁 𑀏𑀓𑀸𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀲𑀦𑁆𑀣𑀯𑀸𑀢𑁄 ¶ [𑀲𑀦𑁆𑀥𑀯𑀢𑁄 (𑀓.)] 𑀪𑀬𑀁 𑀚𑀸𑀢𑀁, 𑀦𑀺𑀓𑁂𑀢𑀸 𑀚𑀸𑀬𑀢𑁂 𑀭𑀚𑁄;

𑀅𑀦𑀺𑀓𑁂𑀢𑀫𑀲𑀦𑁆𑀣𑀯𑀁, 𑀏𑀢𑀁 𑀯𑁂 𑀫𑀼𑀦𑀺𑀤𑀲𑁆𑀲𑀦𑀁.

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

𑀢𑀫𑀸𑀳𑀼 𑀏𑀓𑀁 𑀫𑀼𑀦𑀺𑀦𑀁 𑀘𑀭𑀦𑁆𑀢𑀁, 𑀅𑀤𑁆𑀤𑀓𑁆𑀔𑀺 ¶ 𑀲𑁄 𑀲𑀦𑁆𑀢𑀺𑀧𑀤𑀁 𑀫𑀳𑁂𑀲𑀺.

𑀲𑀗𑁆𑀔𑀸𑀬 ¶ 𑀯𑀢𑁆𑀣𑀽𑀦𑀺 𑀧𑀫𑀸𑀬 [𑀧𑀳𑀸𑀬 (𑀓. 𑀲𑀻. 𑀓.), 𑀲𑀫𑀸𑀬 (𑀓.) 𑀧 + 𑀫𑀻 + 𑀢𑁆𑀯𑀸 = 𑀧𑀫𑀸𑀬, 𑀬𑀣𑀸 𑀦𑀺𑀲𑁆𑀲𑀸𑀬𑀸𑀢𑀺𑀧𑀤𑀁] 𑀩𑀻𑀚𑀁, 𑀲𑀺𑀦𑁂𑀳𑀫𑀲𑁆𑀲 𑀦𑀸𑀦𑀼𑀧𑁆𑀧𑀯𑁂𑀘𑁆𑀙𑁂;

𑀲 𑀯𑁂 𑀫𑀼𑀦𑀻 𑀚𑀸𑀢𑀺𑀔𑀬𑀦𑁆𑀢𑀤𑀲𑁆𑀲𑀻, 𑀢𑀓𑁆𑀓𑀁 𑀧𑀳𑀸𑀬 𑀦 𑀉𑀧𑁂𑀢𑀺 𑀲𑀗𑁆𑀔𑀁.

𑀅𑀜𑁆𑀜𑀸𑀬 𑀲𑀩𑁆𑀩𑀸𑀦𑀺 𑀦𑀺𑀯𑁂𑀲𑀦𑀸𑀦𑀺, 𑀅𑀦𑀺𑀓𑀸𑀫𑀬𑀁 𑀅𑀜𑁆𑀜𑀢𑀭𑀫𑁆𑀧𑀺 𑀢𑁂𑀲𑀁;

𑀲 𑀯𑁂 𑀫𑀼𑀦𑀻 𑀯𑀻𑀢𑀕𑁂𑀥𑁄 𑀅𑀕𑀺𑀤𑁆𑀥𑁄, 𑀦𑀸𑀬𑀽𑀳𑀢𑀻 𑀧𑀸𑀭𑀕𑀢𑁄 𑀳𑀺 𑀳𑁄𑀢𑀺.

𑀲𑀩𑁆𑀩𑀸𑀪𑀺𑀪𑀼𑀁 𑀲𑀩𑁆𑀩𑀯𑀺𑀤𑀼𑀁 𑀲𑀼𑀫𑁂𑀥𑀁, 𑀲𑀩𑁆𑀩𑁂𑀲𑀼 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀅𑀦𑀽𑀧𑀮𑀺𑀢𑁆𑀢𑀁;

𑀲𑀩𑁆𑀩𑀜𑁆𑀚𑀳𑀁 𑀢𑀡𑁆𑀳𑀓𑁆𑀔𑀬𑁂 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀁, 𑀢𑀁 𑀯𑀸𑀧𑀺 𑀥𑀻𑀭𑀸 𑀫𑀼𑀦𑀺 [𑀫𑀼𑀦𑀺𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑀧𑀜𑁆𑀜𑀸𑀩𑀮𑀁 𑀲𑀻𑀮𑀯𑀢𑀽𑀧𑀧𑀦𑁆𑀦𑀁, 𑀲𑀫𑀸𑀳𑀺𑀢𑀁 𑀛𑀸𑀦𑀭𑀢𑀁 𑀲𑀢𑀻𑀫𑀁;

𑀲𑀗𑁆𑀕𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑀁 𑀅𑀔𑀺𑀮𑀁 𑀅𑀦𑀸𑀲𑀯𑀁, 𑀢𑀁 𑀯𑀸𑀧𑀺 𑀥𑀻𑀭𑀸 𑀫𑀼𑀦𑀺 𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑀏𑀓𑀁 ¶ 𑀘𑀭𑀦𑁆𑀢𑀁 𑀫𑀼𑀦𑀺𑀫𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀁, 𑀦𑀺𑀦𑁆𑀤𑀸𑀧𑀲𑀁𑀲𑀸𑀲𑀼 𑀅𑀯𑁂𑀥𑀫𑀸𑀦𑀁;

𑀲𑀻𑀳𑀁𑀯 𑀲𑀤𑁆𑀤𑁂𑀲𑀼 𑀅𑀲𑀦𑁆𑀢𑀲𑀦𑁆𑀢𑀁, 𑀯𑀸𑀢𑀁𑀯 ¶ 𑀚𑀸𑀮𑀫𑁆𑀳𑀺 𑀅𑀲𑀚𑁆𑀚𑀫𑀸𑀦𑀁;

𑀧𑀤𑁆𑀫𑀁𑀯 ¶ [𑀧𑀤𑀼𑀫𑀁𑀯 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀢𑁄𑀬𑁂𑀦 𑀅𑀮𑀺𑀧𑁆𑀧𑀫𑀸𑀦𑀁 [𑀅𑀮𑀺𑀫𑁆𑀧𑀫𑀸𑀦𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀦𑁂𑀢𑀸𑀭𑀫𑀜𑁆𑀜𑁂𑀲𑀫𑀦𑀜𑁆𑀜𑀦𑁂𑀬𑁆𑀬𑀁;

𑀢𑀁 𑀯𑀸𑀧𑀺 𑀥𑀻𑀭𑀸 𑀫𑀼𑀦𑀺 𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑀬𑁄 ¶ 𑀑𑀕𑀳𑀡𑁂 𑀣𑀫𑁆𑀪𑁄𑀭𑀺𑀯𑀸𑀪𑀺𑀚𑀸𑀬𑀢𑀺, 𑀬𑀲𑁆𑀫𑀺𑀁 𑀧𑀭𑁂 𑀯𑀸𑀘𑀸𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀁 [𑀯𑀸𑀘𑀁 𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀁 (𑀓.)] 𑀯𑀤𑀦𑁆𑀢𑀺;

𑀢𑀁 𑀯𑀻𑀢𑀭𑀸𑀕𑀁 𑀲𑀼𑀲𑀫𑀸𑀳𑀺𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀁, 𑀢𑀁 𑀯𑀸𑀧𑀺 𑀥𑀻𑀭𑀸 𑀫𑀼𑀦𑀺 𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑀬𑁄 𑀯𑁂 𑀞𑀺𑀢𑀢𑁆𑀢𑁄 𑀢𑀲𑀭𑀁𑀯 𑀉𑀚𑁆𑀚𑀼, 𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀢𑀺 𑀓𑀫𑁆𑀫𑁂𑀳𑀺 𑀧𑀸𑀧𑀓𑁂𑀳𑀺;

𑀯𑀻𑀫𑀁𑀲𑀫𑀸𑀦𑁄 𑀯𑀺𑀲𑀫𑀁 𑀲𑀫𑀜𑁆𑀘, 𑀢𑀁 𑀯𑀸𑀧𑀺 𑀥𑀻𑀭𑀸 𑀫𑀼𑀦𑀺 𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑀬𑁄 𑀲𑀜𑁆𑀜𑀢𑀢𑁆𑀢𑁄 𑀦 𑀓𑀭𑁄𑀢𑀺 𑀧𑀸𑀧𑀁, 𑀤𑀳𑀭𑁄 𑀫𑀚𑁆𑀛𑀺𑀫𑁄 𑀘 𑀫𑀼𑀦𑀺 [𑀤𑀳𑀭𑁄 𑀘 𑀫𑀚𑁆𑀛𑁄 𑀘 𑀫𑀼𑀦𑀻 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀬𑀢𑀢𑁆𑀢𑁄;

𑀅𑀭𑁄𑀲𑀦𑁂𑀬𑁆𑀬𑁄 𑀦 𑀲𑁄 𑀭𑁄𑀲𑁂𑀢𑀺 𑀓𑀜𑁆𑀘𑀺 [𑀦 𑀭𑁄𑀲𑁂𑀢𑀺 (𑀲𑁆𑀬𑀸.)], 𑀢𑀁 𑀯𑀸𑀧𑀺 𑀥𑀻𑀭𑀸 𑀫𑀼𑀦𑀺 𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑀬𑀤𑀕𑁆𑀕𑀢𑁄 𑀫𑀚𑁆𑀛𑀢𑁄 𑀲𑁂𑀲𑀢𑁄 𑀯𑀸, 𑀧𑀺𑀡𑁆𑀟𑀁 𑀮𑀪𑁂𑀣 𑀧𑀭𑀤𑀢𑁆𑀢𑀽𑀧𑀚𑀻𑀯𑀻;

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

𑀫𑀼𑀦𑀺𑀁 ¶ 𑀘𑀭𑀦𑁆𑀢𑀁 𑀯𑀺𑀭𑀢𑀁 𑀫𑁂𑀣𑀼𑀦𑀲𑁆𑀫𑀸, 𑀬𑁄 𑀬𑁄𑀩𑁆𑀩𑀦𑁂 𑀦𑁄𑀧𑀦𑀺𑀩𑀚𑁆𑀛𑀢𑁂 𑀓𑁆𑀯𑀘𑀺;

𑀫𑀤𑀧𑁆𑀧𑀫𑀸𑀤𑀸 𑀯𑀺𑀭𑀢𑀁 𑀯𑀺𑀧𑁆𑀧𑀫𑀼𑀢𑁆𑀢𑀁, 𑀢𑀁 𑀯𑀸𑀧𑀺 𑀥𑀻𑀭𑀸 𑀫𑀼𑀦𑀺 𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑀅𑀜𑁆𑀜𑀸𑀬 ¶ 𑀮𑁄𑀓𑀁 𑀧𑀭𑀫𑀢𑁆𑀣𑀤𑀲𑁆𑀲𑀺𑀁, 𑀑𑀖𑀁 𑀲𑀫𑀼𑀤𑁆𑀤𑀁 𑀅𑀢𑀺𑀢𑀭𑀺𑀬 𑀢𑀸𑀤𑀺𑀁;

𑀢𑀁 ¶ 𑀙𑀺𑀦𑁆𑀦𑀕𑀦𑁆𑀣𑀁 𑀅𑀲𑀺𑀢𑀁 𑀅𑀦𑀸𑀲𑀯𑀁, 𑀢𑀁 𑀯𑀸𑀧𑀺 𑀥𑀻𑀭𑀸 𑀫𑀼𑀦𑀺 𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑀅𑀲𑀫𑀸 𑀉𑀪𑁄 𑀤𑀽𑀭𑀯𑀺𑀳𑀸𑀭𑀯𑀼𑀢𑁆𑀢𑀺𑀦𑁄, 𑀕𑀺𑀳𑀻 [𑀕𑀺𑀳𑀺 (𑀓.)] 𑀤𑀸𑀭𑀧𑁄𑀲𑀻 𑀅𑀫𑀫𑁄 𑀘 𑀲𑀼𑀩𑁆𑀩𑀢𑁄;

𑀧𑀭𑀧𑀸𑀡𑀭𑁄𑀥𑀸𑀬 𑀕𑀺𑀳𑀻 𑀅𑀲𑀜𑁆𑀜𑀢𑁄, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀫𑀼𑀦𑀻 𑀭𑀓𑁆𑀔𑀢𑀺 𑀧𑀸𑀡𑀺𑀦𑁂 [𑀧𑀸𑀡𑀺𑀦𑁄 (𑀲𑀻.)] 𑀬𑀢𑁄.

𑀲𑀺𑀔𑀻 𑀬𑀣𑀸 𑀦𑀻𑀮𑀕𑀻𑀯𑁄 [𑀦𑀻𑀮𑀕𑀺𑀯𑁄 (𑀲𑁆𑀬𑀸.)] 𑀯𑀺𑀳𑀗𑁆𑀕𑀫𑁄, 𑀳𑀁𑀲𑀲𑁆𑀲 𑀦𑁄𑀧𑁂𑀢𑀺 𑀚𑀯𑀁 𑀓𑀼𑀤𑀸𑀘𑀦𑀁;

𑀏𑀯𑀁 𑀕𑀺𑀳𑀻 𑀦𑀸𑀦𑀼𑀓𑀭𑁄𑀢𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄, 𑀫𑀼𑀦𑀺𑀦𑁄 𑀯𑀺𑀯𑀺𑀢𑁆𑀢𑀲𑁆𑀲 𑀯𑀦𑀫𑁆𑀳𑀺 𑀛𑀸𑀬𑀢𑁄𑀢𑀺.

𑀫𑀼𑀦𑀺𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀉𑀭𑀕𑀯𑀕𑁆𑀕𑁄 𑀧𑀞𑀫𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀉𑀭𑀕𑁄 𑀥𑀦𑀺𑀬𑁄 𑀘𑁂𑀯, 𑀯𑀺𑀲𑀸𑀡𑀜𑁆𑀘 𑀢𑀣𑀸 𑀓𑀲𑀺;

𑀘𑀼𑀦𑁆𑀤𑁄 𑀧𑀭𑀸𑀪𑀯𑁄 ¶ 𑀘𑁂𑀯, 𑀯𑀲𑀮𑁄 𑀫𑁂𑀢𑁆𑀢𑀪𑀸𑀯𑀦𑀸.

𑀲𑀸𑀢𑀸𑀕𑀺𑀭𑁄 𑀆𑀴𑀯𑀓𑁄, 𑀯𑀺𑀚𑀬𑁄 𑀘 𑀢𑀣𑀸 𑀫𑀼𑀦𑀺;

𑀤𑁆𑀯𑀸𑀤𑀲𑁂𑀢𑀸𑀦𑀺 𑀲𑀼𑀢𑁆𑀢𑀸𑀦𑀺, 𑀉𑀭𑀕𑀯𑀕𑁆𑀕𑁄𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀻𑀢𑀺.

𑀬𑀸𑀦𑀻𑀥 ¶ ¶ ¶ 𑀪𑀽𑀢𑀸𑀦𑀺 𑀲𑀫𑀸𑀕𑀢𑀸𑀦𑀺, 𑀪𑀼𑀫𑁆𑀫𑀸𑀦𑀺 [𑀪𑀽𑀫𑀸𑀦𑀺 (𑀓.)] 𑀯𑀸 𑀬𑀸𑀦𑀺 𑀯 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂;

𑀲𑀩𑁆𑀩𑁂𑀯 𑀪𑀽𑀢𑀸 𑀲𑀼𑀫𑀦𑀸 𑀪𑀯𑀦𑁆𑀢𑀼, 𑀅𑀣𑁄𑀧𑀺 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀲𑀼𑀡𑀦𑁆𑀢𑀼 𑀪𑀸𑀲𑀺𑀢𑀁.

𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀪𑀽𑀢𑀸 𑀦𑀺𑀲𑀸𑀫𑁂𑀣 𑀲𑀩𑁆𑀩𑁂, 𑀫𑁂𑀢𑁆𑀢𑀁 𑀓𑀭𑁄𑀣 𑀫𑀸𑀦𑀼𑀲𑀺𑀬𑀸 𑀧𑀚𑀸𑀬;

𑀤𑀺𑀯𑀸 𑀘 𑀭𑀢𑁆𑀢𑁄 𑀘 𑀳𑀭𑀦𑁆𑀢𑀺 𑀬𑁂 𑀩𑀮𑀺𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀦𑁂 𑀭𑀓𑁆𑀔𑀣 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀸.

𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀯𑀺𑀢𑁆𑀢𑀁 𑀇𑀥 𑀯𑀸 𑀳𑀼𑀭𑀁 𑀯𑀸, 𑀲𑀕𑁆𑀕𑁂𑀲𑀼 𑀯𑀸 𑀬𑀁 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁;

𑀦 𑀦𑁄 𑀲𑀫𑀁 𑀅𑀢𑁆𑀣𑀺 𑀢𑀣𑀸𑀕𑀢𑁂𑀦, 𑀇𑀤𑀫𑁆𑀧𑀺 𑀩𑀼𑀤𑁆𑀥𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁;

𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀔𑀬𑀁 𑀯𑀺𑀭𑀸𑀕𑀁 𑀅𑀫𑀢𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀬𑀤𑀚𑁆𑀛𑀕𑀸 ¶ 𑀲𑀓𑁆𑀬𑀫𑀼𑀦𑀻 𑀲𑀫𑀸𑀳𑀺𑀢𑁄;

𑀦 𑀢𑁂𑀦 𑀥𑀫𑁆𑀫𑁂𑀦 𑀲𑀫𑀢𑁆𑀣𑀺 𑀓𑀺𑀜𑁆𑀘𑀺, 𑀇𑀤𑀫𑁆𑀧𑀺 𑀥𑀫𑁆𑀫𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁;

𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

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

𑀲𑀫𑀸𑀥𑀺𑀦𑀸 ¶ 𑀢𑁂𑀦 𑀲𑀫𑁄 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺, 𑀇𑀤𑀫𑁆𑀧𑀺 𑀥𑀫𑁆𑀫𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁;

𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀬𑁂 ¶ 𑀧𑀼𑀕𑁆𑀕𑀮𑀸 𑀅𑀝𑁆𑀞 𑀲𑀢𑀁 𑀧𑀲𑀢𑁆𑀣𑀸, 𑀘𑀢𑁆𑀢𑀸𑀭𑀺 𑀏𑀢𑀸𑀦𑀺 𑀬𑀼𑀕𑀸𑀦𑀺 𑀳𑁄𑀦𑁆𑀢𑀺;

𑀢𑁂 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑀸 𑀲𑀼𑀕𑀢𑀲𑁆𑀲 𑀲𑀸𑀯𑀓𑀸, 𑀏𑀢𑁂𑀲𑀼 𑀤𑀺𑀦𑁆𑀦𑀸𑀦𑀺 𑀫𑀳𑀧𑁆𑀨𑀮𑀸𑀦𑀺;

𑀇𑀤𑀫𑁆𑀧𑀺 𑀲𑀗𑁆𑀖𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 ¶ 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀬𑁂 ¶ 𑀲𑀼𑀧𑁆𑀧𑀬𑀼𑀢𑁆𑀢𑀸 𑀫𑀦𑀲𑀸 𑀤𑀴𑁆𑀳𑁂𑀦, 𑀦𑀺𑀓𑁆𑀓𑀸𑀫𑀺𑀦𑁄 𑀕𑁄𑀢𑀫𑀲𑀸𑀲𑀦𑀫𑁆𑀳𑀺;

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

𑀇𑀤𑀫𑁆𑀧𑀺 𑀲𑀗𑁆𑀖𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀬𑀣𑀺𑀦𑁆𑀤𑀔𑀻𑀮𑁄 𑀧𑀣𑀯𑀺𑀲𑁆𑀲𑀺𑀢𑁄 [𑀧𑀤𑀯𑀺𑀲𑁆𑀲𑀺𑀢𑁄 (𑀓. 𑀲𑀻.), 𑀧𑀞𑀯𑀺𑀁 𑀲𑀺𑀢𑁄 (𑀓. 𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀲𑀺𑀬𑀸, 𑀘𑀢𑀼𑀩𑁆𑀪𑀺 𑀯𑀸𑀢𑁂𑀳𑀺 𑀅𑀲𑀫𑁆𑀧𑀓𑀫𑁆𑀧𑀺𑀬𑁄;

𑀢𑀣𑀽𑀧𑀫𑀁 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀁 𑀯𑀤𑀸𑀫𑀺, 𑀬𑁄 𑀅𑀭𑀺𑀬𑀲𑀘𑁆𑀘𑀸𑀦𑀺 𑀅𑀯𑁂𑀘𑁆𑀘 𑀧𑀲𑁆𑀲𑀢𑀺;

𑀇𑀤𑀫𑁆𑀧𑀺 𑀲𑀗𑁆𑀖𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀬𑁂 𑀅𑀭𑀺𑀬𑀲𑀘𑁆𑀘𑀸𑀦𑀺 𑀯𑀺𑀪𑀸𑀯𑀬𑀦𑁆𑀢𑀺, 𑀕𑀫𑁆𑀪𑀻𑀭𑀧𑀜𑁆𑀜𑁂𑀦 𑀲𑀼𑀤𑁂𑀲𑀺𑀢𑀸𑀦𑀺;

𑀓𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀢𑁂 𑀳𑁄𑀦𑁆𑀢𑀺 𑀪𑀼𑀲𑀁 𑀧𑀫𑀢𑁆𑀢𑀸, 𑀦 𑀢𑁂 𑀪𑀯𑀁 𑀅𑀝𑁆𑀞𑀫𑀫𑀸𑀤𑀺𑀬𑀦𑁆𑀢𑀺;

𑀇𑀤𑀫𑁆𑀧𑀺 𑀲𑀗𑁆𑀖𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 ¶ 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀲𑀳𑀸𑀯𑀲𑁆𑀲 𑀤𑀲𑁆𑀲𑀦𑀲𑀫𑁆𑀧𑀤𑀸𑀬 [𑀲𑀳𑀸𑀯𑀲𑀤𑁆𑀤𑀲𑁆𑀲𑀦𑀲𑀫𑁆𑀧𑀤𑀸𑀬 (𑀓.)], 𑀢𑀬𑀲𑁆𑀲𑀼 𑀥𑀫𑁆𑀫𑀸 𑀚𑀳𑀺𑀢𑀸 𑀪𑀯𑀦𑁆𑀢𑀺;

𑀲𑀓𑁆𑀓𑀸𑀬𑀤𑀺𑀝𑁆𑀞𑀺 ¶ 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀺𑀢𑀜𑁆𑀘, 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑀁 𑀯𑀸𑀧𑀺 𑀬𑀤𑀢𑁆𑀣𑀺 𑀓𑀺𑀜𑁆𑀘𑀺.

𑀘𑀢𑀽𑀳𑀧𑀸𑀬𑁂𑀳𑀺 ¶ 𑀘 𑀯𑀺𑀧𑁆𑀧𑀫𑀼𑀢𑁆𑀢𑁄, 𑀙𑀘𑁆𑀘𑀸𑀪𑀺𑀞𑀸𑀦𑀸𑀦𑀺 [𑀙 𑀘𑀸𑀪𑀺𑀞𑀸𑀦𑀸𑀦𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀪𑀩𑁆𑀩 𑀓𑀸𑀢𑀼𑀁 [𑀅𑀪𑀩𑁆𑀩𑁄 𑀓𑀸𑀢𑀼𑀁 (𑀲𑀻.)];

𑀇𑀤𑀫𑁆𑀧𑀺 𑀲𑀗𑁆𑀖𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀓𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀲𑁄 𑀓𑀫𑁆𑀫 [𑀓𑀫𑁆𑀫𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀓𑀭𑁄𑀢𑀺 𑀧𑀸𑀧𑀓𑀁, 𑀓𑀸𑀬𑁂𑀦 𑀯𑀸𑀘𑀸 𑀉𑀤 𑀘𑁂𑀢𑀲𑀸 𑀯𑀸;

𑀅𑀪𑀩𑁆𑀩 [𑀅𑀪𑀩𑁆𑀩𑁄 (𑀩𑀳𑀽𑀲𑀼)] 𑀲𑁄 𑀢𑀲𑁆𑀲 𑀧𑀝𑀺𑀘𑁆𑀙𑀤𑀸𑀬 [𑀧𑀝𑀺𑀘𑁆𑀙𑀸𑀤𑀸𑀬 (𑀲𑀻.)], 𑀅𑀪𑀩𑁆𑀩𑀢𑀸 𑀤𑀺𑀝𑁆𑀞𑀧𑀤𑀲𑁆𑀲 𑀯𑀼𑀢𑁆𑀢𑀸;

𑀇𑀤𑀫𑁆𑀧𑀺 𑀲𑀗𑁆𑀖𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀯𑀦𑀧𑁆𑀧𑀕𑀼𑀫𑁆𑀩𑁂 𑀬𑀣 [𑀬𑀣𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀨𑀼𑀲𑁆𑀲𑀺𑀢𑀕𑁆𑀕𑁂, 𑀕𑀺𑀫𑁆𑀳𑀸𑀦𑀫𑀸𑀲𑁂 𑀧𑀞𑀫𑀲𑁆𑀫𑀺𑀁 [𑀧𑀞𑀫𑀲𑁆𑀫𑀺 (?)] 𑀕𑀺𑀫𑁆𑀳𑁂;

𑀢𑀣𑀽𑀧𑀫𑀁 𑀥𑀫𑁆𑀫𑀯𑀭𑀁 𑀅𑀤𑁂𑀲𑀬𑀺 [𑀅𑀤𑁂𑀲𑀬𑀻 (𑀲𑀻.)], 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀕𑀸𑀫𑀺𑀁 𑀧𑀭𑀫𑀁 𑀳𑀺𑀢𑀸𑀬;

𑀇𑀤𑀫𑁆𑀧𑀺 𑀩𑀼𑀤𑁆𑀥𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀯𑀭𑁄 𑀯𑀭𑀜𑁆𑀜𑀽 𑀯𑀭𑀤𑁄 𑀯𑀭𑀸𑀳𑀭𑁄, 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑁄 𑀥𑀫𑁆𑀫𑀯𑀭𑀁 𑀅𑀤𑁂𑀲𑀬𑀺;

𑀇𑀤𑀫𑁆𑀧𑀺 𑀩𑀼𑀤𑁆𑀥𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀔𑀻𑀡𑀁 ¶ 𑀧𑀼𑀭𑀸𑀡𑀁 𑀦𑀯 𑀦𑀢𑁆𑀣𑀺 𑀲𑀫𑁆𑀪𑀯𑀁, 𑀯𑀺𑀭𑀢𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑀸𑀬𑀢𑀺𑀓𑁂 𑀪𑀯𑀲𑁆𑀫𑀺𑀁;

𑀢𑁂 𑀔𑀻𑀡𑀩𑀻𑀚𑀸 𑀅𑀯𑀺𑀭𑀽𑀴𑁆𑀳𑀺𑀙𑀦𑁆𑀤𑀸, 𑀦𑀺𑀩𑁆𑀩𑀦𑁆𑀢𑀺 ¶ ¶ 𑀥𑀻𑀭𑀸 𑀬𑀣𑀸𑀬𑀁 [𑀬𑀣𑀬𑀁 (𑀓.)] 𑀧𑀤𑀻𑀧𑁄;

𑀇𑀤𑀫𑁆𑀧𑀺 𑀲𑀗𑁆𑀖𑁂 𑀭𑀢𑀦𑀁 𑀧𑀡𑀻𑀢𑀁, 𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀬𑀸𑀦𑀻𑀥 ¶ 𑀪𑀽𑀢𑀸𑀦𑀺 𑀲𑀫𑀸𑀕𑀢𑀸𑀦𑀺, 𑀪𑀼𑀫𑁆𑀫𑀸𑀦𑀺 𑀯𑀸 𑀬𑀸𑀦𑀺 𑀯 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂;

𑀢𑀣𑀸𑀕𑀢𑀁 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀧𑀽𑀚𑀺𑀢𑀁, 𑀩𑀼𑀤𑁆𑀥𑀁 𑀦𑀫𑀲𑁆𑀲𑀸𑀫 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀬𑀸𑀦𑀻𑀥 𑀪𑀽𑀢𑀸𑀦𑀺 𑀲𑀫𑀸𑀕𑀢𑀸𑀦𑀺, 𑀪𑀼𑀫𑁆𑀫𑀸𑀦𑀺 𑀯𑀸 𑀬𑀸𑀦𑀺 𑀯 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂;

𑀢𑀣𑀸𑀕𑀢𑀁 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀧𑀽𑀚𑀺𑀢𑀁, 𑀥𑀫𑁆𑀫𑀁 𑀦𑀫𑀲𑁆𑀲𑀸𑀫 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼.

𑀬𑀸𑀦𑀻𑀥 𑀪𑀽𑀢𑀸𑀦𑀺 𑀲𑀫𑀸𑀕𑀢𑀸𑀦𑀺, 𑀪𑀼𑀫𑁆𑀫𑀸𑀦𑀺 𑀯𑀸 𑀬𑀸𑀦𑀺 𑀯 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂;

𑀢𑀣𑀸𑀕𑀢𑀁 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀧𑀽𑀚𑀺𑀢𑀁, 𑀲𑀗𑁆𑀖𑀁 𑀦𑀫𑀲𑁆𑀲𑀸𑀫 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀽𑀢𑀺.

𑀭𑀢𑀦𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀲𑀸𑀫𑀸𑀓𑀘𑀺𑀗𑁆𑀕𑀽𑀮𑀓𑀘𑀻𑀦𑀓𑀸𑀦𑀺 ¶ 𑀘, 𑀧𑀢𑁆𑀢𑀧𑁆𑀨𑀮𑀁 𑀫𑀽𑀮𑀨𑀮𑀁 𑀕𑀯𑀺𑀧𑁆𑀨𑀮𑀁;

𑀥𑀫𑁆𑀫𑁂𑀦 𑀮𑀤𑁆𑀥𑀁 𑀲𑀢𑀫𑀲𑁆𑀦𑀫𑀸𑀦𑀸 [𑀲𑀢𑀫𑀲𑀫𑀸𑀦𑀸 (𑀲𑀻. 𑀧𑀻.), 𑀲𑀢𑀫𑀲𑁆𑀲𑀫𑀸𑀦𑀸 (𑀲𑁆𑀬𑀸. 𑀓𑀁.)], 𑀦 𑀓𑀸𑀫𑀓𑀸𑀫𑀸 𑀅𑀮𑀺𑀓𑀁 𑀪𑀡𑀦𑁆𑀢𑀺.

‘‘𑀬𑀤𑀲𑁆𑀦𑀫𑀸𑀦𑁄 𑀲𑀼𑀓𑀢𑀁 𑀲𑀼𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁, 𑀧𑀭𑁂𑀳𑀺 𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀬𑀢𑀁 𑀧𑀡𑀻𑀢𑀁;

𑀲𑀸𑀮𑀻𑀦𑀫𑀦𑁆𑀦𑀁 ¶ 𑀧𑀭𑀺𑀪𑀼𑀜𑁆𑀚𑀫𑀸𑀦𑁄, 𑀲𑁄 𑀪𑀼𑀜𑁆𑀚𑀲𑀻 𑀓𑀲𑁆𑀲𑀧 𑀆𑀫𑀕𑀦𑁆𑀥𑀁.

‘‘𑀦 ¶ 𑀆𑀫𑀕𑀦𑁆𑀥𑁄 𑀫𑀫 𑀓𑀧𑁆𑀧𑀢𑀻𑀢𑀺, 𑀇𑀘𑁆𑀘𑁂𑀯 𑀢𑁆𑀯𑀁 𑀪𑀸𑀲𑀲𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀩𑀦𑁆𑀥𑀼;

𑀲𑀸𑀮𑀻𑀦𑀫𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀪𑀼𑀜𑁆𑀚𑀫𑀸𑀦𑁄, 𑀲𑀓𑀼𑀦𑁆𑀢𑀫𑀁𑀲𑁂𑀳𑀺 𑀲𑀼𑀲𑀗𑁆𑀔𑀢𑁂𑀳𑀺;

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀓𑀲𑁆𑀲𑀧 𑀏𑀢𑀫𑀢𑁆𑀣𑀁, 𑀓𑀣𑀁 𑀧𑀓𑀸𑀭𑁄 𑀢𑀯 𑀆𑀫𑀕𑀦𑁆𑀥𑁄’’.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑁄 ¶ 𑀯𑀥𑀙𑁂𑀤𑀩𑀦𑁆𑀥𑀦𑀁, 𑀣𑁂𑀬𑁆𑀬𑀁 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑁄 𑀦𑀺𑀓𑀢𑀺𑀯𑀜𑁆𑀘𑀦𑀸𑀦𑀺 𑀘;

𑀅𑀚𑁆𑀛𑁂𑀦𑀓𑀼𑀢𑁆𑀢𑀁 [𑀅𑀚𑁆𑀛𑁂𑀦 𑀓𑀼𑀚𑁆𑀚𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀭𑀤𑀸𑀭𑀲𑁂𑀯𑀦𑀸, 𑀏𑀲𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀦 𑀳𑀺 𑀫𑀁𑀲𑀪𑁄𑀚𑀦𑀁.

‘‘𑀬𑁂 ¶ 𑀇𑀥 𑀓𑀸𑀫𑁂𑀲𑀼 𑀅𑀲𑀜𑁆𑀜𑀢𑀸 𑀚𑀦𑀸, 𑀭𑀲𑁂𑀲𑀼 𑀕𑀺𑀤𑁆𑀥𑀸 𑀅𑀲𑀼𑀘𑀺𑀪𑀸𑀯𑀫𑀲𑁆𑀲𑀺𑀢𑀸 [𑀅𑀲𑀼𑀘𑀻𑀓𑀫𑀺𑀲𑁆𑀲𑀺𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)];

𑀦𑀢𑁆𑀣𑀺𑀓𑀤𑀺𑀝𑁆𑀞𑀻 𑀯𑀺𑀲𑀫𑀸 𑀤𑀼𑀭𑀦𑁆𑀦𑀬𑀸, 𑀏𑀲𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀦 𑀳𑀺 𑀫𑀁𑀲𑀪𑁄𑀚𑀦𑀁.

‘‘𑀬𑁂 𑀮𑀽𑀔𑀲𑀸 𑀤𑀸𑀭𑀼𑀡𑀸 𑀧𑀺𑀝𑁆𑀞𑀺𑀫𑀁𑀲𑀺𑀓𑀸 [𑀬𑁂 𑀮𑀽𑀔𑀭𑀲𑀸 𑀤𑀸𑀭𑀼𑀡𑀸 𑀧𑀭𑀧𑀺𑀝𑁆𑀞𑀺𑀫𑀁𑀲𑀺𑀓𑀸 (𑀓.)], 𑀫𑀺𑀢𑁆𑀢𑀤𑁆𑀤𑀼𑀦𑁄 𑀦𑀺𑀓𑁆𑀓𑀭𑀼𑀡𑀸𑀢𑀺𑀫𑀸𑀦𑀺𑀦𑁄;

𑀅𑀤𑀸𑀦𑀲𑀻𑀮𑀸 𑀦 𑀘 𑀤𑁂𑀦𑁆𑀢𑀺 𑀓𑀲𑁆𑀲𑀘𑀺, 𑀏𑀲𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀦 𑀳𑀺 𑀫𑀁𑀲𑀪𑁄𑀚𑀦𑀁.

‘‘𑀓𑁄𑀥𑁄 ¶ 𑀫𑀤𑁄 𑀣𑀫𑁆𑀪𑁄 𑀧𑀘𑁆𑀘𑀼𑀧𑀝𑁆𑀞𑀸𑀧𑀦𑀸 [𑀧𑀘𑁆𑀘𑀼𑀝𑁆𑀞𑀸𑀧𑀦𑀸 𑀘 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀧𑀘𑁆𑀘𑀼𑀝𑁆𑀞𑀸𑀧𑀦𑀸 (𑀧𑀻.)], 𑀫𑀸𑀬𑀸 𑀉𑀲𑀽𑀬𑀸 𑀪𑀲𑁆𑀲𑀲𑀫𑀼𑀲𑁆𑀲𑀬𑁄 𑀘;

𑀫𑀸𑀦𑀸𑀢𑀺𑀫𑀸𑀦𑁄 𑀘 𑀅𑀲𑀩𑁆𑀪𑀺 𑀲𑀦𑁆𑀣𑀯𑁄, 𑀏𑀲𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀦 𑀳𑀺 𑀫𑀁𑀲𑀪𑁄𑀚𑀦𑀁.

‘‘𑀬𑁂 𑀧𑀸𑀧𑀲𑀻𑀮𑀸 𑀇𑀡𑀖𑀸𑀢𑀲𑀽𑀘𑀓𑀸, 𑀯𑁄𑀳𑀸𑀭𑀓𑀽𑀝𑀸 𑀇𑀥 𑀧𑀸𑀝𑀺𑀭𑀽𑀧𑀺𑀓𑀸 [𑀧𑀸𑀢𑀺𑀭𑀽𑀧𑀺𑀓𑀸 (?)];

𑀦𑀭𑀸𑀥𑀫𑀸 𑀬𑁂𑀥 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀁, 𑀏𑀲𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀦 𑀳𑀺 𑀫𑀁𑀲𑀪𑁄𑀚𑀦𑀁.

‘‘𑀬𑁂 ¶ 𑀇𑀥 𑀧𑀸𑀡𑁂𑀲𑀼 𑀅𑀲𑀜𑁆𑀜𑀢𑀸 𑀚𑀦𑀸, 𑀧𑀭𑁂𑀲𑀫𑀸𑀤𑀸𑀬 𑀯𑀺𑀳𑁂𑀲𑀫𑀼𑀬𑁆𑀬𑀼𑀢𑀸;

𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑀮𑀼𑀤𑁆𑀤𑀸 𑀨𑀭𑀼𑀲𑀸 𑀅𑀦𑀸𑀤𑀭𑀸, 𑀏𑀲𑀸𑀫𑀕𑀦𑁆𑀥𑁄 ¶ 𑀦 𑀳𑀺 𑀫𑀁𑀲𑀪𑁄𑀚𑀦𑀁.

‘‘𑀏𑀢𑁂𑀲𑀼 𑀕𑀺𑀤𑁆𑀥𑀸 𑀯𑀺𑀭𑀼𑀤𑁆𑀥𑀸𑀢𑀺𑀧𑀸𑀢𑀺𑀦𑁄, 𑀦𑀺𑀘𑁆𑀘𑀼𑀬𑁆𑀬𑀼𑀢𑀸 𑀧𑁂𑀘𑁆𑀘 𑀢𑀫𑀁 𑀯𑀚𑀦𑁆𑀢𑀺 𑀬𑁂;

𑀧𑀢𑀦𑁆𑀢𑀺 𑀲𑀢𑁆𑀢𑀸 𑀦𑀺𑀭𑀬𑀁 𑀅𑀯𑀁𑀲𑀺𑀭𑀸, 𑀏𑀲𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀦 𑀳𑀺 𑀫𑀁𑀲𑀪𑁄𑀚𑀦𑀁.

‘‘𑀦 𑀫𑀘𑁆𑀙𑀫𑀁𑀲𑀸𑀦𑀫𑀦𑀸𑀲𑀓𑀢𑁆𑀢𑀁 [𑀦 𑀫𑀘𑁆𑀙𑀫𑀁𑀲𑀁 𑀦 𑀅𑀦𑀸𑀲𑀓𑀢𑁆𑀢𑀁 (𑀲𑀻. 𑀅𑀝𑁆𑀞 𑀫𑀽𑀮𑀧𑀸𑀞𑁄), 𑀦 𑀫𑀁𑀘𑁆𑀙𑀫𑀁𑀲𑀸𑀦𑀸𑀦𑀸𑀲𑀓𑀢𑁆𑀢𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀦 𑀦𑀕𑁆𑀕𑀺𑀬𑀁 𑀦 𑀫𑀼𑀡𑁆𑀟𑀺𑀬𑀁 𑀚𑀝𑀸𑀚𑀮𑁆𑀮𑀁;

𑀔𑀭𑀸𑀚𑀺𑀦𑀸𑀦𑀺 𑀦𑀸𑀕𑁆𑀕𑀺𑀳𑀼𑀢𑁆𑀢𑀲𑁆𑀲𑀼𑀧𑀲𑁂𑀯𑀦𑀸, 𑀬𑁂 𑀯𑀸𑀧𑀺 𑀮𑁄𑀓𑁂 𑀅𑀫𑀭𑀸 𑀩𑀳𑀽 𑀢𑀧𑀸;

𑀫𑀦𑁆𑀢𑀸𑀳𑀼𑀢𑀻 𑀬𑀜𑁆𑀜𑀫𑀼𑀢𑀽𑀧𑀲𑁂𑀯𑀦𑀸, 𑀲𑁄𑀥𑁂𑀦𑁆𑀢𑀺 𑀫𑀘𑁆𑀘𑀁 𑀅𑀯𑀺𑀢𑀺𑀡𑁆𑀡𑀓𑀗𑁆𑀔𑀁.

‘‘𑀬𑁄 𑀢𑁂𑀲𑀼 ¶ [𑀲𑁄𑀢𑁂𑀲𑀼 (𑀲𑀻. 𑀧𑀻.)] 𑀕𑀼𑀢𑁆𑀢𑁄 𑀯𑀺𑀤𑀺𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁄 𑀘𑀭𑁂, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀅𑀚𑁆𑀚𑀯𑀫𑀤𑁆𑀤𑀯𑁂 𑀭𑀢𑁄;

𑀲𑀗𑁆𑀕𑀸𑀢𑀺𑀕𑁄 𑀲𑀩𑁆𑀩𑀤𑀼𑀓𑁆𑀔𑀧𑁆𑀧𑀳𑀻𑀦𑁄, 𑀦 𑀮𑀺𑀧𑁆𑀧𑀢𑀺 [𑀦 𑀮𑀺𑀫𑁆𑀧𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓𑀁 𑀓.)] 𑀤𑀺𑀝𑁆𑀞𑀲𑀼𑀢𑁂𑀲𑀼 𑀥𑀻𑀭𑁄’’.

𑀇𑀘𑁆𑀘𑁂𑀢𑀫𑀢𑁆𑀣𑀁 𑀪𑀕𑀯𑀸 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁, 𑀅𑀓𑁆𑀔𑀸𑀲𑀺 𑀦𑀁 [𑀢𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑁂𑀤𑀬𑀺 𑀫𑀦𑁆𑀢𑀧𑀸𑀭𑀕𑀽;

𑀘𑀺𑀢𑁆𑀭𑀸𑀳𑀺 𑀕𑀸𑀣𑀸𑀳𑀺 𑀫𑀼𑀦𑀻 𑀧𑀓𑀸𑀲𑀬𑀺, 𑀦𑀺𑀭𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀅𑀲𑀺𑀢𑁄 𑀤𑀼𑀭𑀦𑁆𑀦𑀬𑁄.

𑀲𑀼𑀢𑁆𑀯𑀸𑀦 ¶ 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 𑀧𑀤𑀁, 𑀦𑀺𑀭𑀸𑀫𑀕𑀦𑁆𑀥𑀁 ¶ 𑀲𑀩𑁆𑀩𑀤𑀼𑀓𑁆𑀔𑀧𑁆𑀧𑀦𑀽𑀤𑀦𑀁;

𑀦𑀻𑀘𑀫𑀦𑁄 𑀯𑀦𑁆𑀤𑀺 𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲, 𑀢𑀢𑁆𑀣𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀫𑀭𑁄𑀘𑀬𑀺𑀢𑁆𑀣𑀸𑀢𑀺.

𑀆𑀫𑀕𑀦𑁆𑀥𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑀼𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀳𑀺𑀭𑀺𑀁 ¶ 𑀢𑀭𑀦𑁆𑀢𑀁 𑀯𑀺𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀫𑀸𑀦𑀁, 𑀢𑀯𑀸𑀳𑀫𑀲𑁆𑀫𑀺 [𑀲𑀔𑀸𑀳𑀫𑀲𑁆𑀫𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀇𑀢𑀺 𑀪𑀸𑀲𑀫𑀸𑀦𑀁;

𑀲𑀬𑁆𑀳𑀸𑀦𑀺 𑀓𑀫𑁆𑀫𑀸𑀦𑀺 𑀅𑀦𑀸𑀤𑀺𑀬𑀦𑁆𑀢𑀁, 𑀦𑁂𑀲𑁄 𑀫𑀫𑀦𑁆𑀢𑀺 𑀇𑀢𑀺 𑀦𑀁 𑀯𑀺𑀚𑀜𑁆𑀜𑀸.

𑀅𑀦𑀦𑁆𑀯𑀬𑀁 [𑀅𑀢𑁆𑀣𑀦𑁆𑀯𑀬𑀁 (𑀓.)] 𑀧𑀺𑀬𑀁 𑀯𑀸𑀘𑀁, 𑀬𑁄 𑀫𑀺𑀢𑁆𑀢𑁂𑀲𑀼 𑀧𑀓𑀼𑀩𑁆𑀩𑀢𑀺;

𑀅𑀓𑀭𑁄𑀦𑁆𑀢𑀁 𑀪𑀸𑀲𑀫𑀸𑀦𑀁, 𑀧𑀭𑀺𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑀸.

𑀦 ¶ 𑀲𑁄 𑀫𑀺𑀢𑁆𑀢𑁄 𑀬𑁄 𑀲𑀤𑀸 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄, 𑀪𑁂𑀤𑀸𑀲𑀗𑁆𑀓𑀻 𑀭𑀦𑁆𑀥𑀫𑁂𑀯𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀻;

𑀬𑀲𑁆𑀫𑀺𑀜𑁆𑀘 𑀲𑁂𑀢𑀺 𑀉𑀭𑀲𑀻𑀯 𑀧𑀼𑀢𑁆𑀢𑁄, 𑀲 𑀯𑁂 𑀫𑀺𑀢𑁆𑀢𑁄 𑀬𑁄 𑀧𑀭𑁂𑀳𑀺 𑀅𑀪𑁂𑀚𑁆𑀚𑁄.

𑀧𑀸𑀫𑀼𑀚𑁆𑀚𑀓𑀭𑀡𑀁 𑀞𑀸𑀦𑀁, 𑀧𑀲𑀁𑀲𑀸𑀯𑀳𑀦𑀁 𑀲𑀼𑀔𑀁;

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

𑀧𑀯𑀺𑀯𑁂𑀓𑀭𑀲𑀁 𑀧𑀺𑀢𑁆𑀯𑀸, 𑀭𑀲𑀁 𑀉𑀧𑀲𑀫𑀲𑁆𑀲 𑀘;

𑀦𑀺𑀤𑁆𑀤𑀭𑁄 ¶ 𑀳𑁄𑀢𑀺 𑀦𑀺𑀧𑁆𑀧𑀸𑀧𑁄, 𑀥𑀫𑁆𑀫𑀧𑀻𑀢𑀺𑀭𑀲𑀁 𑀧𑀺𑀯𑀦𑁆𑀢𑀺.

𑀳𑀺𑀭𑀺𑀲𑀼𑀢𑁆𑀢𑀁 𑀢𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀚𑁂𑀢𑀯𑀦𑁂 𑀅𑀦𑀸𑀣𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑀲𑁆𑀲 𑀆𑀭𑀸𑀫𑁂. 𑀅𑀣 𑀔𑁄 𑀅𑀜𑁆𑀜𑀢𑀭𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀸𑀬 𑀭𑀢𑁆𑀢𑀺𑀬𑀸 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀯𑀡𑁆𑀡𑀸 𑀓𑁂𑀯𑀮𑀓𑀧𑁆𑀧𑀁 𑀚𑁂𑀢𑀯𑀦𑀁 𑀑𑀪𑀸𑀲𑁂𑀢𑁆𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀅𑀝𑁆𑀞𑀸𑀲𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀞𑀺𑀢𑀸 𑀔𑁄 𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀩𑀳𑀽 𑀤𑁂𑀯𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀸 𑀘, 𑀫𑀗𑁆𑀕𑀮𑀸𑀦𑀺 𑀅𑀘𑀺𑀦𑁆𑀢𑀬𑀼𑀁;

𑀆𑀓𑀗𑁆𑀔𑀫𑀸𑀦𑀸 𑀲𑁄𑀢𑁆𑀣𑀸𑀦𑀁, 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁’’.

‘‘𑀅𑀲𑁂𑀯𑀦𑀸 ¶ 𑀘 𑀩𑀸𑀮𑀸𑀦𑀁, 𑀧𑀡𑁆𑀟𑀺𑀢𑀸𑀦𑀜𑁆𑀘 𑀲𑁂𑀯𑀦𑀸;

𑀧𑀽𑀚𑀸 𑀘 𑀧𑀽𑀚𑀦𑁂𑀬𑁆𑀬𑀸𑀦𑀁 [𑀧𑀽𑀚𑀦𑀻𑀬𑀸𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)], 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀧𑀢𑀺𑀭𑀽𑀧𑀤𑁂𑀲𑀯𑀸𑀲𑁄 𑀘, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀘 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀢𑀸;

𑀅𑀢𑁆𑀢𑀲𑀫𑁆𑀫𑀸𑀧𑀡𑀺𑀥𑀺 [𑀅𑀢𑁆𑀢𑀲𑀫𑁆𑀫𑀸𑀧𑀡𑀻𑀥𑀻 (𑀓𑀢𑁆𑀣𑀘𑀺)] 𑀘, 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀩𑀸𑀳𑀼𑀲𑀘𑁆𑀘𑀜𑁆𑀘 ¶ 𑀲𑀺𑀧𑁆𑀧𑀜𑁆𑀘, 𑀯𑀺𑀦𑀬𑁄 𑀘 𑀲𑀼𑀲𑀺𑀓𑁆𑀔𑀺𑀢𑁄;

𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸 𑀘 𑀬𑀸 𑀯𑀸𑀘𑀸, 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀼 𑀉𑀧𑀝𑁆𑀞𑀸𑀦𑀁, 𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑀲𑁆𑀲 𑀲𑀗𑁆𑀕𑀳𑁄;

𑀅𑀦𑀸𑀓𑀼𑀮𑀸 ¶ 𑀘 𑀓𑀫𑁆𑀫𑀦𑁆𑀢𑀸, 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀤𑀸𑀦𑀜𑁆𑀘 𑀥𑀫𑁆𑀫𑀘𑀭𑀺𑀬𑀸 𑀘, 𑀜𑀸𑀢𑀓𑀸𑀦𑀜𑁆𑀘 𑀲𑀗𑁆𑀕𑀳𑁄;

𑀅𑀦𑀯𑀚𑁆𑀚𑀸𑀦𑀺 𑀓𑀫𑁆𑀫𑀸𑀦𑀺, 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀆𑀭𑀢𑀻 𑀯𑀺𑀭𑀢𑀻 𑀧𑀸𑀧𑀸, 𑀫𑀚𑁆𑀚𑀧𑀸𑀦𑀸 𑀘 𑀲𑀁𑀬𑀫𑁄;

𑀅𑀧𑁆𑀧𑀫𑀸𑀤𑁄 𑀘 𑀥𑀫𑁆𑀫𑁂𑀲𑀼, 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀕𑀸𑀭𑀯𑁄 ¶ 𑀘 𑀦𑀺𑀯𑀸𑀢𑁄 𑀘, 𑀲𑀦𑁆𑀢𑀼𑀝𑁆𑀞𑀺 𑀘 𑀓𑀢𑀜𑁆𑀜𑀼𑀢𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀥𑀫𑁆𑀫𑀲𑁆𑀲𑀯𑀦𑀁 [𑀥𑀫𑁆𑀫𑀲𑀯𑀡𑀁 (𑀓𑀢𑁆𑀣𑀘𑀺), 𑀥𑀫𑁆𑀫𑀲𑀯𑀦𑀁 (𑀲𑀻. 𑀓.)], 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀔𑀦𑁆𑀢𑀻 𑀘 𑀲𑁄𑀯𑀘𑀲𑁆𑀲𑀢𑀸, 𑀲𑀫𑀡𑀸𑀦𑀜𑁆𑀘 𑀤𑀲𑁆𑀲𑀦𑀁;

𑀓𑀸𑀮𑁂𑀦 𑀥𑀫𑁆𑀫𑀲𑀸𑀓𑀘𑁆𑀙𑀸, 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀢𑀧𑁄 𑀘 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀜𑁆𑀘, 𑀅𑀭𑀺𑀬𑀲𑀘𑁆𑀘𑀸𑀦 𑀤𑀲𑁆𑀲𑀦𑀁;

𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀲𑀘𑁆𑀙𑀺𑀓𑀺𑀭𑀺𑀬𑀸 𑀘, 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀨𑀼𑀝𑁆𑀞𑀲𑁆𑀲 𑀮𑁄𑀓𑀥𑀫𑁆𑀫𑁂𑀳𑀺, 𑀘𑀺𑀢𑁆𑀢𑀁 𑀬𑀲𑁆𑀲 𑀦 𑀓𑀫𑁆𑀧𑀢𑀺;

𑀅𑀲𑁄𑀓𑀁 𑀯𑀺𑀭𑀚𑀁 𑀔𑁂𑀫𑀁, 𑀏𑀢𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀸𑀦𑀺 𑀓𑀢𑁆𑀯𑀸𑀦, 𑀲𑀩𑁆𑀩𑀢𑁆𑀣𑀫𑀧𑀭𑀸𑀚𑀺𑀢𑀸;

𑀲𑀩𑁆𑀩𑀢𑁆𑀣 𑀲𑁄𑀢𑁆𑀣𑀺𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀢𑀁 𑀢𑁂𑀲𑀁 𑀫𑀗𑁆𑀕𑀮𑀫𑀼𑀢𑁆𑀢𑀫’’𑀦𑁆𑀢𑀺.

𑀫𑀗𑁆𑀕𑀮𑀲𑀼𑀢𑁆𑀢𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀕𑀬𑀸𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀝𑀗𑁆𑀓𑀺𑀢𑀫𑀜𑁆𑀘𑁂 𑀲𑀽𑀘𑀺𑀮𑁄𑀫𑀲𑁆𑀲 𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀪𑀯𑀦𑁂. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 ¶ 𑀔𑀭𑁄 𑀘 𑀬𑀓𑁆𑀔𑁄 𑀲𑀽𑀘𑀺𑀮𑁄𑀫𑁄 𑀘 𑀬𑀓𑁆𑀔𑁄 𑀪𑀕𑀯𑀢𑁄 𑀅𑀯𑀺𑀤𑀽𑀭𑁂 𑀅𑀢𑀺𑀓𑁆𑀓𑀫𑀦𑁆𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀔𑀭𑁄 𑀬𑀓𑁆𑀔𑁄 𑀲𑀽𑀘𑀺𑀮𑁄𑀫𑀁 𑀬𑀓𑁆𑀔𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀏𑀲𑁄 𑀲𑀫𑀡𑁄’’𑀢𑀺. ‘‘𑀦𑁂𑀲𑁄 𑀲𑀫𑀡𑁄, 𑀲𑀫𑀡𑀓𑁄 𑀏𑀲𑁄. 𑀬𑀸𑀯𑀸𑀳𑀁 𑀚𑀸𑀦𑀸𑀫𑀺 [𑀬𑀸𑀯 𑀚𑀸𑀦𑀸𑀫𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀬𑀤𑀺 𑀯𑀸 𑀲𑁄 𑀲𑀫𑀡𑁄 [𑀬𑀤𑀺 𑀯𑀸 𑀲𑀫𑀡𑁄 (𑀲𑁆𑀬𑀸.)], 𑀬𑀤𑀺 𑀯𑀸 𑀲𑁄 𑀲𑀫𑀡𑀓𑁄’’𑀢𑀺 [𑀬𑀤𑀺 𑀯𑀸 𑀲𑀫𑀡𑀓𑁄𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑀅𑀣 𑀔𑁄 𑀲𑀽𑀘𑀺𑀮𑁄𑀫𑁄 𑀬𑀓𑁆𑀔𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑁄 𑀓𑀸𑀬𑀁 𑀉𑀧𑀦𑀸𑀫𑁂𑀲𑀺. 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀓𑀸𑀬𑀁 𑀅𑀧𑀦𑀸𑀫𑁂𑀲𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑀽𑀘𑀺𑀮𑁄𑀫𑁄 𑀬𑀓𑁆𑀔𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 ¶ 𑁋 ‘‘𑀪𑀸𑀬𑀲𑀺 𑀫𑀁, 𑀲𑀫𑀡𑀸’’𑀢𑀺? ‘‘𑀦 𑀔𑁆𑀯𑀸𑀳𑀁 𑀢𑀁, 𑀆𑀯𑀼𑀲𑁄, 𑀪𑀸𑀬𑀸𑀫𑀺; 𑀅𑀧𑀺 𑀘 𑀢𑁂 𑀲𑀧𑁆𑀨𑀲𑁆𑀲𑁄 𑀧𑀸𑀧𑀓𑁄’’𑀢𑀺.

‘‘𑀧𑀜𑁆𑀳𑀁 𑀢𑀁, 𑀲𑀫𑀡, 𑀧𑀼𑀘𑁆𑀙𑀺𑀲𑁆𑀲𑀸𑀫𑀺. 𑀲𑀘𑁂 𑀫𑁂 𑀦 𑀩𑁆𑀬𑀸𑀓𑀭𑀺𑀲𑁆𑀲𑀲𑀺, 𑀘𑀺𑀢𑁆𑀢𑀁 𑀯𑀸 𑀢𑁂 𑀔𑀺𑀧𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀳𑀤𑀬𑀁 𑀯𑀸 𑀢𑁂 𑀨𑀸𑀮𑁂𑀲𑁆𑀲𑀸𑀫𑀺, 𑀧𑀸𑀤𑁂𑀲𑀼 𑀯𑀸 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀧𑀸𑀭𑀕𑀗𑁆𑀕𑀸𑀬 𑀔𑀺𑀧𑀺𑀲𑁆𑀲𑀸𑀫𑀻’’𑀢𑀺.

‘‘𑀦 𑀔𑁆𑀯𑀸𑀳𑀁 𑀢𑀁, 𑀆𑀯𑀼𑀲𑁄, 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀲𑀤𑁂𑀯𑀓𑁂 𑀮𑁄𑀓𑁂 𑀲𑀫𑀸𑀭𑀓𑁂 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑁂 𑀲𑀲𑁆𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀺𑀬𑀸 𑀧𑀚𑀸𑀬 𑀲𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀬 𑀬𑁄 𑀫𑁂 𑀘𑀺𑀢𑁆𑀢𑀁 𑀯𑀸 𑀔𑀺𑀧𑁂𑀬𑁆𑀬 𑀳𑀤𑀬𑀁 𑀯𑀸 𑀨𑀸𑀮𑁂𑀬𑁆𑀬 𑀧𑀸𑀤𑁂𑀲𑀼 𑀯𑀸 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀧𑀸𑀭𑀕𑀗𑁆𑀕𑀸𑀬 𑀔𑀺𑀧𑁂𑀬𑁆𑀬. 𑀅𑀧𑀺 𑀘 𑀢𑁆𑀯𑀁, 𑀆𑀯𑀼𑀲𑁄, 𑀧𑀼𑀘𑁆𑀙 𑀬𑀤𑀸𑀓𑀗𑁆𑀔𑀲𑀻’’𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑀽𑀘𑀺𑀮𑁄𑀫𑁄 𑀬𑀓𑁆𑀔𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀭𑀸𑀕𑁄 𑀘 𑀤𑁄𑀲𑁄 𑀘 𑀓𑀼𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀸, 𑀅𑀭𑀢𑀻 ¶ 𑀭𑀢𑀻 𑀮𑁄𑀫𑀳𑀁𑀲𑁄 𑀓𑀼𑀢𑁄𑀚𑀸;

𑀓𑀼𑀢𑁄 𑀲𑀫𑀼𑀝𑁆𑀞𑀸𑀬 𑀫𑀦𑁄𑀯𑀺𑀢𑀓𑁆𑀓𑀸, 𑀓𑀼𑀫𑀸𑀭𑀓𑀸 𑀥𑀗𑁆𑀓𑀫𑀺𑀯𑁄𑀲𑁆𑀲𑀚𑀦𑁆𑀢𑀺’’.

‘‘𑀭𑀸𑀕𑁄 𑀘 𑀤𑁄𑀲𑁄 𑀘 𑀇𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀸, 𑀅𑀭𑀢𑀻 𑀭𑀢𑀻 𑀮𑁄𑀫𑀳𑀁𑀲𑁄 𑀇𑀢𑁄𑀚𑀸;

𑀇𑀢𑁄 𑀲𑀫𑀼𑀝𑁆𑀞𑀸𑀬 𑀫𑀦𑁄𑀯𑀺𑀢𑀓𑁆𑀓𑀸, 𑀓𑀼𑀫𑀸𑀭𑀓𑀸 𑀥𑀗𑁆𑀓𑀫𑀺𑀯𑁄𑀲𑁆𑀲𑀚𑀦𑁆𑀢𑀺.

‘‘𑀲𑁆𑀦𑁂𑀳𑀚𑀸 ¶ ¶ 𑀅𑀢𑁆𑀢𑀲𑀫𑁆𑀪𑀽𑀢𑀸, 𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑀲𑁆𑀲𑁂𑀯 𑀔𑀦𑁆𑀥𑀚𑀸;

𑀧𑀼𑀣𑀽 𑀯𑀺𑀲𑀢𑁆𑀢𑀸 𑀓𑀸𑀫𑁂𑀲𑀼, 𑀫𑀸𑀮𑀼𑀯𑀸𑀯 𑀯𑀺𑀢𑀢𑀸𑀯𑀦𑁂.

‘‘𑀬𑁂 𑀦𑀁 𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀬𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀁, 𑀢𑁂 𑀦𑀁 𑀯𑀺𑀦𑁄𑀤𑁂𑀦𑁆𑀢𑀺 𑀲𑀼𑀡𑁄𑀳𑀺 𑀬𑀓𑁆𑀔;

𑀢𑁂 𑀤𑀼𑀢𑁆𑀢𑀭𑀁 𑀑𑀖𑀫𑀺𑀫𑀁 𑀢𑀭𑀦𑁆𑀢𑀺, 𑀅𑀢𑀺𑀡𑁆𑀡𑀧𑀼𑀩𑁆𑀩𑀁 𑀅𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑀸𑀬𑀸’’𑀢𑀺.

𑀲𑀽𑀘𑀺𑀮𑁄𑀫𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀜𑁆𑀘𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀥𑀫𑁆𑀫𑀘𑀭𑀺𑀬𑀁 ¶ 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, 𑀏𑀢𑀤𑀸𑀳𑀼 𑀯𑀲𑀼𑀢𑁆𑀢𑀫𑀁;

𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄𑀧𑀺 𑀘𑁂 𑀳𑁄𑀢𑀺, 𑀅𑀕𑀸𑀭𑀸 𑀅𑀦𑀕𑀸𑀭𑀺𑀬𑀁.

𑀲𑁄 𑀘𑁂 𑀫𑀼𑀔𑀭𑀚𑀸𑀢𑀺𑀓𑁄, 𑀯𑀺𑀳𑁂𑀲𑀸𑀪𑀺𑀭𑀢𑁄 𑀫𑀕𑁄;

𑀚𑀻𑀯𑀺𑀢𑀁 ¶ 𑀢𑀲𑁆𑀲 𑀧𑀸𑀧𑀺𑀬𑁄, 𑀭𑀚𑀁 𑀯𑀟𑁆𑀠𑁂𑀢𑀺 𑀅𑀢𑁆𑀢𑀦𑁄.

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

𑀅𑀓𑁆𑀔𑀸𑀢𑀫𑁆𑀧𑀺 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀥𑀫𑁆𑀫𑀁 𑀩𑀼𑀤𑁆𑀥𑁂𑀦 𑀤𑁂𑀲𑀺𑀢𑀁.

𑀯𑀺𑀳𑁂𑀲𑀁 𑀪𑀸𑀯𑀺𑀢𑀢𑁆𑀢𑀸𑀦𑀁, 𑀅𑀯𑀺𑀚𑁆𑀚𑀸𑀬 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄;

𑀲𑀁𑀓𑀺𑀮𑁂𑀲𑀁 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀫𑀕𑁆𑀕𑀁 𑀦𑀺𑀭𑀬𑀕𑀸𑀫𑀺𑀦𑀁.

𑀯𑀺𑀦𑀺𑀧𑀸𑀢𑀁 𑀲𑀫𑀸𑀧𑀦𑁆𑀦𑁄, 𑀕𑀩𑁆𑀪𑀸 𑀕𑀩𑁆𑀪𑀁 𑀢𑀫𑀸 𑀢𑀫𑀁;

𑀲 𑀯𑁂 𑀢𑀸𑀤𑀺𑀲𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀧𑁂𑀘𑁆𑀘 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀢𑀺.

𑀕𑀽𑀣𑀓𑀽𑀧𑁄 𑀬𑀣𑀸 𑀅𑀲𑁆𑀲, 𑀲𑀫𑁆𑀧𑀼𑀡𑁆𑀡𑁄 𑀕𑀡𑀯𑀲𑁆𑀲𑀺𑀓𑁄;

𑀬𑁄 𑀘 𑀏𑀯𑀭𑀽𑀧𑁄 𑀅𑀲𑁆𑀲, 𑀤𑀼𑀩𑁆𑀩𑀺𑀲𑁄𑀥𑁄 𑀳𑀺 𑀲𑀸𑀗𑁆𑀕𑀡𑁄.

𑀬𑀁 𑀏𑀯𑀭𑀽𑀧𑀁 𑀚𑀸𑀦𑀸𑀣, 𑀪𑀺𑀓𑁆𑀔𑀯𑁄 𑀕𑁂𑀳𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁;

𑀧𑀸𑀧𑀺𑀘𑁆𑀙𑀁 𑀧𑀸𑀧𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑀁, 𑀧𑀸𑀧𑀆𑀘𑀸𑀭𑀕𑁄𑀘𑀭𑀁.

𑀲𑀩𑁆𑀩𑁂 ¶ ¶ 𑀲𑀫𑀕𑁆𑀕𑀸 𑀳𑀼𑀢𑁆𑀯𑀸𑀦, 𑀅𑀪𑀺𑀦𑀺𑀩𑁆𑀩𑀚𑁆𑀚𑀺𑀬𑀸𑀣 [𑀅𑀪𑀺𑀦𑀺𑀩𑁆𑀩𑀚𑁆𑀚𑀬𑀸𑀣 (𑀲𑀻. 𑀧𑀻. 𑀅. 𑀦𑀺. 𑁮.𑁧𑁦)] 𑀦𑀁;

𑀓𑀸𑀭𑀡𑁆𑀟𑀯𑀁 [𑀓𑀸𑀭𑀡𑁆𑀟𑀁 𑀯 (𑀲𑁆𑀬𑀸. 𑀓.) 𑀅. 𑀦𑀺. 𑁮.𑁧𑁦] 𑀦𑀺𑀤𑁆𑀥𑀫𑀣, 𑀓𑀲𑀫𑁆𑀩𑀼𑀁 𑀅𑀧𑀓𑀲𑁆𑀲𑀣 [𑀅𑀯𑀓𑀲𑁆𑀲𑀣 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)].

𑀢𑀢𑁄 𑀧𑀮𑀸𑀧𑁂 [𑀧𑀮𑀸𑀲𑁂 (𑀓.)] 𑀯𑀸𑀳𑁂𑀣, 𑀅𑀲𑁆𑀲𑀫𑀡𑁂 𑀲𑀫𑀡𑀫𑀸𑀦𑀺𑀦𑁂;

𑀦𑀺𑀤𑁆𑀥𑀫𑀺𑀢𑁆𑀯𑀸𑀦 𑀧𑀸𑀧𑀺𑀘𑁆𑀙𑁂, 𑀧𑀸𑀧𑀆𑀘𑀸𑀭𑀕𑁄𑀘𑀭𑁂.

𑀲𑀼𑀤𑁆𑀥𑀸 ¶ 𑀲𑀼𑀤𑁆𑀥𑁂𑀳𑀺 𑀲𑀁𑀯𑀸𑀲𑀁, 𑀓𑀧𑁆𑀧𑀬𑀯𑁆𑀳𑁄 𑀧𑀢𑀺𑀲𑁆𑀲𑀢𑀸;

𑀢𑀢𑁄 𑀲𑀫𑀕𑁆𑀕𑀸 𑀦𑀺𑀧𑀓𑀸, 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲𑀦𑁆𑀢𑀁 𑀓𑀭𑀺𑀲𑁆𑀲𑀣𑀸𑀢𑀺.

𑀥𑀫𑁆𑀫𑀘𑀭𑀺𑀬𑀲𑀼𑀢𑁆𑀢𑀁 [𑀓𑀧𑀺𑀮𑀲𑀼𑀢𑁆𑀢𑀁 (𑀅𑀝𑁆𑀞.)] 𑀙𑀝𑁆𑀞𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁭. 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀥𑀫𑁆𑀫𑀺𑀓𑀲𑀼𑀢𑁆𑀢𑀁

𑀏𑀯𑀁 ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀚𑁂𑀢𑀯𑀦𑁂 𑀅𑀦𑀸𑀣𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑀲𑁆𑀲 𑀆𑀭𑀸𑀫𑁂. 𑀅𑀣 𑀔𑁄 𑀲𑀫𑁆𑀩𑀳𑀼𑀮𑀸 𑀓𑁄𑀲𑀮𑀓𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀳𑀸𑀲𑀸𑀮𑀸 𑀚𑀺𑀡𑁆𑀡𑀸 𑀯𑀼𑀟𑁆𑀠𑀸 𑀫𑀳𑀮𑁆𑀮𑀓𑀸 𑀅𑀤𑁆𑀥𑀕𑀢𑀸 𑀯𑀬𑁄𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀁𑀲𑀼; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑀸 𑀲𑀤𑁆𑀥𑀺𑀁 𑀲𑀫𑁆𑀫𑁄𑀤𑀺𑀁𑀲𑀼. 𑀲𑀫𑁆𑀫𑁄𑀤𑀦𑀻𑀬𑀁 𑀓𑀣𑀁 𑀲𑀸𑀭𑀡𑀻𑀬𑀁 𑀯𑀻𑀢𑀺𑀲𑀸𑀭𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺𑀁𑀲𑀼. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀸 𑀔𑁄 𑀢𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀳𑀸𑀲𑀸𑀮𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘𑀼𑀁 𑁋 ‘‘𑀲𑀦𑁆𑀤𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀦𑀼 𑀔𑁄, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀏𑀢𑀭𑀳𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀧𑁄𑀭𑀸𑀡𑀸𑀦𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀥𑀫𑁆𑀫𑁂’’𑀢𑀺? ‘‘𑀦 𑀔𑁄, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸, 𑀲𑀦𑁆𑀤𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀏𑀢𑀭𑀳𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀧𑁄𑀭𑀸𑀡𑀸𑀦𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀥𑀫𑁆𑀫𑁂’’𑀢𑀺. ‘‘𑀲𑀸𑀥𑀼 𑀦𑁄 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀧𑁄𑀭𑀸𑀡𑀸𑀦𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀥𑀫𑁆𑀫𑀁 𑀪𑀸𑀲𑀢𑀼, 𑀲𑀘𑁂 𑀪𑁄𑀢𑁄 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀅𑀕𑀭𑀽’’𑀢𑀺. ‘‘𑀢𑁂𑀦 𑀳𑀺, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸, 𑀲𑀼𑀡𑀸𑀣, 𑀲𑀸𑀥𑀼𑀓𑀁 𑀫𑀦𑀲𑀺 𑀓𑀭𑁄𑀣, 𑀪𑀸𑀲𑀺𑀲𑁆𑀲𑀸𑀫𑀻’’𑀢𑀺. ‘‘𑀏𑀯𑀁, 𑀪𑁄’’𑀢𑀺 𑀔𑁄 𑀢𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀳𑀸𑀲𑀸𑀮𑀸 𑀪𑀕𑀯𑀢𑁄 𑀧𑀘𑁆𑀘𑀲𑁆𑀲𑁄𑀲𑀼𑀁. 𑀪𑀕𑀯𑀸 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋

‘‘𑀇𑀲𑀬𑁄 𑀧𑀼𑀩𑁆𑀩𑀓𑀸 𑀆𑀲𑀼𑀁, 𑀲𑀜𑁆𑀜𑀢𑀢𑁆𑀢𑀸 𑀢𑀧𑀲𑁆𑀲𑀺𑀦𑁄;

𑀧𑀜𑁆𑀘 𑀓𑀸𑀫𑀕𑀼𑀡𑁂 𑀳𑀺𑀢𑁆𑀯𑀸, 𑀅𑀢𑁆𑀢𑀤𑀢𑁆𑀣𑀫𑀘𑀸𑀭𑀺𑀲𑀼𑀁.

‘‘𑀦 ¶ 𑀧𑀲𑀽 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀸𑀲𑀼𑀁, 𑀦 𑀳𑀺𑀭𑀜𑁆𑀜𑀁 𑀦 𑀥𑀸𑀦𑀺𑀬𑀁;

𑀲𑀚𑁆𑀛𑀸𑀬𑀥𑀦𑀥𑀜𑁆𑀜𑀸𑀲𑀼𑀁, 𑀩𑁆𑀭𑀳𑁆𑀫𑀁 𑀦𑀺𑀥𑀺𑀫𑀧𑀸𑀮𑀬𑀼𑀁.

‘‘𑀬𑀁 ¶ ¶ 𑀦𑁂𑀲𑀁 𑀧𑀓𑀢𑀁 𑀆𑀲𑀺, 𑀤𑁆𑀯𑀸𑀭𑀪𑀢𑁆𑀢𑀁 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀁;

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

‘‘𑀦𑀸𑀦𑀸𑀭𑀢𑁆𑀢𑁂𑀳𑀺 ¶ 𑀯𑀢𑁆𑀣𑁂𑀳𑀺, 𑀲𑀬𑀦𑁂𑀳𑀸𑀯𑀲𑀣𑁂𑀳𑀺 𑀘;

𑀨𑀻𑀢𑀸 𑀚𑀦𑀧𑀤𑀸 𑀭𑀝𑁆𑀞𑀸, 𑀢𑁂 𑀦𑀫𑀲𑁆𑀲𑀺𑀁𑀲𑀼 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂.

‘‘𑀅𑀯𑀚𑁆𑀛𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀆𑀲𑀼𑀁, 𑀅𑀚𑁂𑀬𑁆𑀬𑀸 𑀥𑀫𑁆𑀫𑀭𑀓𑁆𑀔𑀺𑀢𑀸;

𑀦 𑀦𑁂 𑀓𑁄𑀘𑀺 𑀦𑀺𑀯𑀸𑀭𑁂𑀲𑀺, 𑀓𑀼𑀮𑀤𑁆𑀯𑀸𑀭𑁂𑀲𑀼 𑀲𑀩𑁆𑀩𑀲𑁄.

‘‘𑀅𑀝𑁆𑀞𑀘𑀢𑁆𑀢𑀸𑀮𑀻𑀲𑀁 𑀯𑀲𑁆𑀲𑀸𑀦𑀺, (𑀓𑁄𑀫𑀸𑀭) 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁 𑀘𑀭𑀺𑀁𑀲𑀼 𑀢𑁂;

𑀯𑀺𑀚𑁆𑀚𑀸𑀘𑀭𑀡𑀧𑀭𑀺𑀬𑁂𑀝𑁆𑀞𑀺𑀁, 𑀅𑀘𑀭𑀼𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀧𑀼𑀭𑁂.

‘‘𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀅𑀜𑁆𑀜𑀫𑀕𑀫𑀼𑀁, 𑀦𑀧𑀺 𑀪𑀭𑀺𑀬𑀁 𑀓𑀺𑀡𑀺𑀁𑀲𑀼 𑀢𑁂;

𑀲𑀫𑁆𑀧𑀺𑀬𑁂𑀦𑁂𑀯 𑀲𑀁𑀯𑀸𑀲𑀁, 𑀲𑀗𑁆𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀲𑀫𑀭𑁄𑀘𑀬𑀼𑀁.

‘‘𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀢𑀫𑁆𑀳𑀸 𑀲𑀫𑀬𑀸, 𑀉𑀢𑀼𑀯𑁂𑀭𑀫𑀡𑀺𑀁 𑀧𑀢𑀺;

𑀅𑀦𑁆𑀢𑀭𑀸 𑀫𑁂𑀣𑀼𑀦𑀁 𑀥𑀫𑁆𑀫𑀁, 𑀦𑀸𑀲𑁆𑀲𑀼 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸.

‘‘𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀜𑁆𑀘 𑀲𑀻𑀮𑀜𑁆𑀘, 𑀅𑀚𑁆𑀚𑀯𑀁 𑀫𑀤𑁆𑀤𑀯𑀁 𑀢𑀧𑀁;

𑀲𑁄𑀭𑀘𑁆𑀘𑀁 𑀅𑀯𑀺𑀳𑀺𑀁𑀲𑀜𑁆𑀘, 𑀔𑀦𑁆𑀢𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀅𑀯𑀡𑁆𑀡𑀬𑀼𑀁.

‘‘𑀬𑁄 ¶ 𑀦𑁂𑀲𑀁 𑀧𑀭𑀫𑁄 𑀆𑀲𑀺, 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀤𑀴𑁆𑀳𑀧𑀭𑀓𑁆𑀓𑀫𑁄;

𑀲 𑀯𑀸𑀧𑀺 𑀫𑁂𑀣𑀼𑀦𑀁 𑀥𑀫𑁆𑀫𑀁, 𑀲𑀼𑀧𑀺𑀦𑀦𑁆𑀢𑁂𑀧𑀺 𑀦𑀸𑀕𑀫𑀸.

‘‘𑀢𑀲𑁆𑀲 𑀯𑀢𑁆𑀢𑀫𑀦𑀼𑀲𑀺𑀓𑁆𑀔𑀦𑁆𑀢𑀸, 𑀇𑀥𑁂𑀓𑁂 𑀯𑀺𑀜𑁆𑀜𑀼𑀚𑀸𑀢𑀺𑀓𑀸;

𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀜𑁆𑀘 𑀲𑀻𑀮𑀜𑁆𑀘, 𑀔𑀦𑁆𑀢𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀅𑀯𑀡𑁆𑀡𑀬𑀼𑀁.

‘‘𑀢𑀡𑁆𑀟𑀼𑀮𑀁 𑀲𑀬𑀦𑀁 𑀯𑀢𑁆𑀣𑀁, 𑀲𑀧𑁆𑀧𑀺𑀢𑁂𑀮𑀜𑁆𑀘 𑀬𑀸𑀘𑀺𑀬;

𑀥𑀫𑁆𑀫𑁂𑀦 𑀲𑀫𑁄𑀥𑀸𑀦𑁂𑀢𑁆𑀯𑀸, 𑀢𑀢𑁄 𑀬𑀜𑁆𑀜𑀫𑀓𑀧𑁆𑀧𑀬𑀼𑀁.

‘‘𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀲𑁆𑀫𑀺𑀁 ¶ 𑀬𑀜𑁆𑀜𑀲𑁆𑀫𑀺𑀁, 𑀦𑀸𑀲𑁆𑀲𑀼 𑀕𑀸𑀯𑁄 𑀳𑀦𑀺𑀁𑀲𑀼 𑀢𑁂;

𑀬𑀣𑀸 𑀫𑀸𑀢𑀸 𑀧𑀺𑀢𑀸 𑀪𑀸𑀢𑀸, 𑀅𑀜𑁆𑀜𑁂 𑀯𑀸𑀧𑀺 𑀘 𑀜𑀸𑀢𑀓𑀸;

𑀕𑀸𑀯𑁄 𑀦𑁄 𑀧𑀭𑀫𑀸 𑀫𑀺𑀢𑁆𑀢𑀸, 𑀬𑀸𑀲𑀼 𑀚𑀸𑀬𑀦𑁆𑀢𑀺 𑀑𑀲𑀥𑀸.

‘‘𑀅𑀦𑁆𑀦𑀤𑀸 ¶ 𑀩𑀮𑀤𑀸 𑀘𑁂𑀢𑀸, 𑀯𑀡𑁆𑀡𑀤𑀸 𑀲𑀼𑀔𑀤𑀸 𑀢𑀣𑀸 [𑀲𑀼𑀔𑀤𑀸 𑀘 𑀢𑀸 (𑀓.)];

𑀏𑀢𑀫𑀢𑁆𑀣𑀯𑀲𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀦𑀸𑀲𑁆𑀲𑀼 𑀕𑀸𑀯𑁄 𑀳𑀦𑀺𑀁𑀲𑀼 𑀢𑁂.

‘‘𑀲𑀼𑀔𑀼𑀫𑀸𑀮𑀸 ¶ 𑀫𑀳𑀸𑀓𑀸𑀬𑀸, 𑀯𑀡𑁆𑀡𑀯𑀦𑁆𑀢𑁄 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄;

𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀲𑁂𑀳𑀺 𑀥𑀫𑁆𑀫𑁂𑀳𑀺, 𑀓𑀺𑀘𑁆𑀘𑀸𑀓𑀺𑀘𑁆𑀘𑁂𑀲𑀼 𑀉𑀲𑁆𑀲𑀼𑀓𑀸;

𑀬𑀸𑀯 𑀮𑁄𑀓𑁂 𑀅𑀯𑀢𑁆𑀢𑀺𑀁𑀲𑀼, 𑀲𑀼𑀔𑀫𑁂𑀥𑀺𑀢𑁆𑀣𑀬𑀁 𑀧𑀚𑀸.

‘‘𑀢𑁂𑀲𑀁 𑀆𑀲𑀺 𑀯𑀺𑀧𑀮𑁆𑀮𑀸𑀲𑁄, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀅𑀡𑀼𑀢𑁄 𑀅𑀡𑀼𑀁;

𑀭𑀸𑀚𑀺𑀦𑁄 𑀘 𑀯𑀺𑀬𑀸𑀓𑀸𑀭𑀁, 𑀦𑀸𑀭𑀺𑀬𑁄 𑀲𑀫𑀮𑀗𑁆𑀓𑀢𑀸.

‘‘𑀭𑀣𑁂 𑀘𑀸𑀚𑀜𑁆𑀜𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑁂, 𑀲𑀼𑀓𑀢𑁂 𑀘𑀺𑀢𑁆𑀢𑀲𑀺𑀩𑁆𑀩𑀦𑁂;

𑀦𑀺𑀯𑁂𑀲𑀦𑁂 𑀦𑀺𑀯𑁂𑀲𑁂 𑀘, 𑀯𑀺𑀪𑀢𑁆𑀢𑁂 𑀪𑀸𑀕𑀲𑁄 𑀫𑀺𑀢𑁂.

‘‘𑀕𑁄𑀫𑀡𑁆𑀟𑀮𑀧𑀭𑀺𑀩𑁆𑀬𑀽𑀴𑁆𑀳𑀁, 𑀦𑀸𑀭𑀻𑀯𑀭𑀕𑀡𑀸𑀬𑀼𑀢𑀁;

𑀉𑀴𑀸𑀭𑀁 𑀫𑀸𑀦𑀼𑀲𑀁 𑀪𑁄𑀕𑀁, 𑀅𑀪𑀺𑀚𑁆𑀛𑀸𑀬𑀺𑀁𑀲𑀼 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸.

‘‘𑀢𑁂 𑀢𑀢𑁆𑀣 𑀫𑀦𑁆𑀢𑁂 𑀕𑀦𑁆𑀣𑁂𑀢𑁆𑀯𑀸, 𑀑𑀓𑁆𑀓𑀸𑀓𑀁 𑀢𑀤𑀼𑀧𑀸𑀕𑀫𑀼𑀁;

𑀧𑀳𑀽𑀢𑀥𑀦𑀥𑀜𑁆𑀜𑁄𑀲𑀺 ¶ , 𑀬𑀚𑀲𑁆𑀲𑀼 𑀩𑀳𑀼 𑀢𑁂 𑀯𑀺𑀢𑁆𑀢𑀁;

‘‘𑀢𑀢𑁄 𑀘 𑀭𑀸𑀚𑀸 𑀲𑀜𑁆𑀜𑀢𑁆𑀢𑁄, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀳𑀺 𑀭𑀣𑁂𑀲𑀪𑁄;

𑀅𑀲𑁆𑀲𑀫𑁂𑀥𑀁 𑀧𑀼𑀭𑀺𑀲𑀫𑁂𑀥𑀁, 𑀲𑀫𑁆𑀫𑀸𑀧𑀸𑀲𑀁 𑀯𑀸𑀚𑀧𑁂𑀬𑁆𑀬𑀁 𑀦𑀺𑀭𑀕𑁆𑀕𑀴𑀁;

𑀏𑀢𑁂 ¶ 𑀬𑀸𑀕𑁂 𑀬𑀚𑀺𑀢𑁆𑀯𑀸𑀦, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀫𑀤𑀸 𑀥𑀦𑀁.

‘‘𑀕𑀸𑀯𑁄 𑀲𑀬𑀦𑀜𑁆𑀘 𑀯𑀢𑁆𑀣𑀜𑁆𑀘, 𑀦𑀸𑀭𑀺𑀬𑁄 𑀲𑀫𑀮𑀗𑁆𑀓𑀢𑀸;

𑀭𑀣𑁂 𑀘𑀸𑀚𑀜𑁆𑀜𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑁂, 𑀲𑀼𑀓𑀢𑁂 𑀘𑀺𑀢𑁆𑀢𑀲𑀺𑀩𑁆𑀩𑀦𑁂.

‘‘𑀦𑀺𑀯𑁂𑀲𑀦𑀸𑀦𑀺 𑀭𑀫𑁆𑀫𑀸𑀦𑀺, 𑀲𑀼𑀯𑀺𑀪𑀢𑁆𑀢𑀸𑀦𑀺 𑀪𑀸𑀕𑀲𑁄;

𑀦𑀸𑀦𑀸𑀥𑀜𑁆𑀜𑀲𑁆𑀲 𑀧𑀽𑀭𑁂𑀢𑁆𑀯𑀸, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀫𑀤𑀸 𑀥𑀦𑀁.

‘‘𑀢𑁂 ¶ 𑀘 𑀢𑀢𑁆𑀣 𑀥𑀦𑀁 𑀮𑀤𑁆𑀥𑀸, 𑀲𑀦𑁆𑀦𑀺𑀥𑀺𑀁 𑀲𑀫𑀭𑁄𑀘𑀬𑀼𑀁;

𑀢𑁂𑀲𑀁 𑀇𑀘𑁆𑀙𑀸𑀯𑀢𑀺𑀡𑁆𑀡𑀸𑀦𑀁, 𑀪𑀺𑀬𑁆𑀬𑁄 𑀢𑀡𑁆𑀳𑀸 𑀧𑀯𑀟𑁆𑀠𑀣;

𑀢𑁂 𑀢𑀢𑁆𑀣 𑀫𑀦𑁆𑀢𑁂 𑀕𑀦𑁆𑀣𑁂𑀢𑁆𑀯𑀸, 𑀑𑀓𑁆𑀓𑀸𑀓𑀁 𑀧𑀼𑀦𑀫𑀼𑀧𑀸𑀕𑀫𑀼𑀁.

‘‘𑀬𑀣𑀸 𑀆𑀧𑁄 𑀘 𑀧𑀣𑀯𑀻 𑀘, 𑀳𑀺𑀭𑀜𑁆𑀜𑀁 𑀥𑀦𑀥𑀸𑀦𑀺𑀬𑀁;

𑀏𑀯𑀁 𑀕𑀸𑀯𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁, 𑀧𑀭𑀺𑀓𑁆𑀔𑀸𑀭𑁄 𑀲𑁄 𑀳𑀺 𑀧𑀸𑀡𑀺𑀦𑀁;

𑀬𑀚𑀲𑁆𑀲𑀼 𑀩𑀳𑀼 𑀢𑁂 𑀯𑀺𑀢𑁆𑀢𑀁, 𑀬𑀚𑀲𑁆𑀲𑀼 𑀩𑀳𑀼 𑀢𑁂 𑀥𑀦𑀁.

‘‘𑀢𑀢𑁄 𑀘 𑀭𑀸𑀚𑀸 𑀲𑀜𑁆𑀜𑀢𑁆𑀢𑁄, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀳𑀺 𑀭𑀣𑁂𑀲𑀪𑁄;

𑀦𑁂𑀓𑀸 𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀺𑀬𑁄, 𑀕𑀸𑀯𑁄 𑀬𑀜𑁆𑀜𑁂 𑀅𑀖𑀸𑀢𑀬𑀺.

‘‘𑀦 ¶ 𑀧𑀸𑀤𑀸 𑀦 𑀯𑀺𑀲𑀸𑀡𑁂𑀦, 𑀦𑀸𑀲𑁆𑀲𑀼 𑀳𑀺𑀁𑀲𑀦𑁆𑀢𑀺 𑀓𑁂𑀦𑀘𑀺;

𑀕𑀸𑀯𑁄 𑀏𑀴𑀓𑀲𑀫𑀸𑀦𑀸, 𑀲𑁄𑀭𑀢𑀸 𑀓𑀼𑀫𑁆𑀪𑀤𑀽𑀳𑀦𑀸;

𑀢𑀸 𑀯𑀺𑀲𑀸𑀡𑁂 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚𑀸 𑀲𑀢𑁆𑀣𑁂𑀦 𑀖𑀸𑀢𑀬𑀺.

‘‘𑀢𑀢𑁄 ¶ 𑀤𑁂𑀯𑀸 𑀧𑀺𑀢𑀭𑁄 𑀘 [𑀢𑀢𑁄 𑀘 𑀤𑁂𑀯𑀸 𑀧𑀺𑀢𑀭𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀇𑀦𑁆𑀤𑁄 𑀅𑀲𑀼𑀭𑀭𑀓𑁆𑀔𑀲𑀸;

𑀅𑀥𑀫𑁆𑀫𑁄 𑀇𑀢𑀺 𑀧𑀓𑁆𑀓𑀦𑁆𑀤𑀼𑀁, 𑀬𑀁 𑀲𑀢𑁆𑀣𑀁 𑀦𑀺𑀧𑀢𑀻 𑀕𑀯𑁂.

‘‘𑀢𑀬𑁄 𑀭𑁄𑀕𑀸 𑀧𑀼𑀭𑁂 𑀆𑀲𑀼𑀁, 𑀇𑀘𑁆𑀙𑀸 𑀅𑀦𑀲𑀦𑀁 𑀚𑀭𑀸;

𑀧𑀲𑀽𑀦𑀜𑁆𑀘 𑀲𑀫𑀸𑀭𑀫𑁆𑀪𑀸, 𑀅𑀝𑁆𑀞𑀸𑀦𑀯𑀼𑀢𑀺𑀫𑀸𑀕𑀫𑀼𑀁.

‘‘𑀏𑀲𑁄 ¶ 𑀅𑀥𑀫𑁆𑀫𑁄 𑀤𑀡𑁆𑀟𑀸𑀦𑀁, 𑀑𑀓𑁆𑀓𑀦𑁆𑀢𑁄 𑀧𑀼𑀭𑀸𑀡𑁄 𑀅𑀳𑀼;

𑀅𑀤𑀽𑀲𑀺𑀓𑀸𑀬𑁄 𑀳𑀜𑁆𑀜𑀦𑁆𑀢𑀺, 𑀥𑀫𑁆𑀫𑀸 𑀥𑀁𑀲𑀦𑁆𑀢𑀺 [𑀥𑀁𑀲𑁂𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀬𑀸𑀚𑀓𑀸.

‘‘𑀏𑀯𑀫𑁂𑀲𑁄 𑀅𑀡𑀼𑀥𑀫𑁆𑀫𑁄, 𑀧𑁄𑀭𑀸𑀡𑁄 𑀯𑀺𑀜𑁆𑀜𑀼𑀕𑀭𑀳𑀺𑀢𑁄;

𑀬𑀢𑁆𑀣 𑀏𑀤𑀺𑀲𑀓𑀁 𑀧𑀲𑁆𑀲𑀢𑀺, 𑀬𑀸𑀚𑀓𑀁 𑀕𑀭𑀳𑀢𑀻 [𑀕𑀭𑀳𑀻 (𑀓.)] 𑀚𑀦𑁄.

‘‘𑀏𑀯𑀁 𑀥𑀫𑁆𑀫𑁂 𑀯𑀺𑀬𑀸𑀧𑀦𑁆𑀦𑁂, 𑀯𑀺𑀪𑀺𑀦𑁆𑀦𑀸 𑀲𑀼𑀤𑁆𑀤𑀯𑁂𑀲𑁆𑀲𑀺𑀓𑀸;

𑀧𑀼𑀣𑀽 𑀯𑀺𑀪𑀺𑀦𑁆𑀦𑀸 𑀔𑀢𑁆𑀢𑀺𑀬𑀸, 𑀧𑀢𑀺𑀁 𑀪𑀭𑀺𑀬𑀸𑀯𑀫𑀜𑁆𑀜𑀣.

‘‘𑀔𑀢𑁆𑀢𑀺𑀬𑀸 ¶ 𑀩𑁆𑀭𑀳𑁆𑀫𑀩𑀦𑁆𑀥𑀽 𑀘, 𑀬𑁂 𑀘𑀜𑁆𑀜𑁂 𑀕𑁄𑀢𑁆𑀢𑀭𑀓𑁆𑀔𑀺𑀢𑀸;

𑀚𑀸𑀢𑀺𑀯𑀸𑀤𑀁 𑀦𑀺𑀭𑀁𑀓𑀢𑁆𑀯𑀸 [𑀦𑀺𑀭𑀸𑀓𑀢𑁆𑀯𑀸 (?) 𑀬𑀣𑀸 𑀅𑀦𑀺𑀭𑀸𑀓𑀢𑀚𑁆𑀛𑀸𑀦𑁄𑀢𑀺], 𑀓𑀸𑀫𑀸𑀦𑀁 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀼’’𑀦𑁆𑀢𑀺.

𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀢𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀳𑀸𑀲𑀸𑀮𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘𑀼𑀁 𑁋 ‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫…𑀧𑁂. ¶ … 𑀉𑀧𑀸𑀲𑀓𑁂 𑀦𑁄 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀥𑀸𑀭𑁂𑀢𑀼 𑀅𑀚𑁆𑀚𑀢𑀕𑁆𑀕𑁂 𑀧𑀸𑀡𑀼𑀧𑁂𑀢𑁂 𑀲𑀭𑀡𑀁 𑀕𑀢𑁂’’𑀢𑀺.

𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀥𑀫𑁆𑀫𑀺𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀲𑀢𑁆𑀢𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀬𑀲𑁆𑀫𑀸 ¶ 𑀳𑀺 𑀥𑀫𑁆𑀫𑀁 𑀧𑀼𑀭𑀺𑀲𑁄 𑀯𑀺𑀚𑀜𑁆𑀜𑀸, 𑀇𑀦𑁆𑀤𑀁𑀯 𑀦𑀁 𑀤𑁂𑀯𑀢𑀸 𑀧𑀽𑀚𑀬𑁂𑀬𑁆𑀬;

𑀲𑁄 𑀧𑀽𑀚𑀺𑀢𑁄 𑀢𑀲𑁆𑀫𑀺 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁄 𑀧𑀸𑀢𑀼𑀓𑀭𑁄𑀢𑀺 𑀥𑀫𑁆𑀫𑀁.

𑀢𑀤𑀝𑁆𑀞𑀺𑀓𑀢𑁆𑀯𑀸𑀦 ¶ 𑀦𑀺𑀲𑀫𑁆𑀫 𑀥𑀻𑀭𑁄, 𑀥𑀫𑁆𑀫𑀸𑀦𑀼𑀥𑀫𑁆𑀫𑀁 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑀫𑀸𑀦𑁄;

𑀯𑀺𑀜𑁆𑀜𑀽 𑀯𑀺𑀪𑀸𑀯𑀻 𑀦𑀺𑀧𑀼𑀡𑁄 𑀘 𑀳𑁄𑀢𑀺, 𑀬𑁄 𑀢𑀸𑀤𑀺𑀲𑀁 𑀪𑀚𑀢𑀺 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄.

𑀔𑀼𑀤𑁆𑀤𑀜𑁆𑀘 𑀩𑀸𑀮𑀁 𑀉𑀧𑀲𑁂𑀯𑀫𑀸𑀦𑁄, 𑀅𑀦𑀸𑀕𑀢𑀢𑁆𑀣𑀜𑁆𑀘 𑀉𑀲𑀽𑀬𑀓𑀜𑁆𑀘;

𑀇𑀥𑁂𑀯 𑀥𑀫𑁆𑀫𑀁 𑀅𑀯𑀺𑀪𑀸𑀯𑀬𑀺𑀢𑁆𑀯𑀸, 𑀅𑀯𑀺𑀢𑀺𑀡𑁆𑀡𑀓𑀗𑁆𑀔𑁄 𑀫𑀭𑀡𑀁 𑀉𑀧𑁂𑀢𑀺.

𑀬𑀣𑀸 𑀦𑀭𑁄 𑀆𑀧𑀕𑀫𑁄𑀢𑀭𑀺𑀢𑁆𑀯𑀸, 𑀫𑀳𑁄𑀤𑀓𑀁 𑀲𑀮𑀺𑀮𑀁 𑀲𑀻𑀖𑀲𑁄𑀢𑀁;

𑀲𑁄 𑀯𑀼𑀬𑁆𑀳𑀫𑀸𑀦𑁄 𑀅𑀦𑀼𑀲𑁄𑀢𑀕𑀸𑀫𑀻, 𑀓𑀺𑀁 𑀲𑁄 𑀧𑀭𑁂 𑀲𑀓𑁆𑀔𑀢𑀺 𑀢𑀸𑀭𑀬𑁂𑀢𑀼𑀁.

𑀢𑀣𑁂𑀯 𑀥𑀫𑁆𑀫𑀁 𑀅𑀯𑀺𑀪𑀸𑀯𑀬𑀺𑀢𑁆𑀯𑀸, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑀸𑀦𑀁 𑀅𑀦𑀺𑀲𑀸𑀫𑀬𑀢𑁆𑀣𑀁;

𑀲𑀬𑀁 𑀅𑀚𑀸𑀦𑀁 𑀅𑀯𑀺𑀢𑀺𑀡𑁆𑀡𑀓𑀗𑁆𑀔𑁄, 𑀓𑀺𑀁 ¶ 𑀲𑁄 𑀧𑀭𑁂 𑀲𑀓𑁆𑀔𑀢𑀺 𑀦𑀺𑀚𑁆𑀛𑀧𑁂𑀢𑀼𑀁.

𑀬𑀣𑀸𑀧𑀺 ¶ 𑀦𑀸𑀯𑀁 𑀤𑀴𑁆𑀳𑀫𑀸𑀭𑀼𑀳𑀺𑀢𑁆𑀯𑀸, 𑀨𑀺𑀬𑁂𑀦 [𑀧𑀺𑀬𑁂𑀦 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀭𑀺𑀢𑁆𑀢𑁂𑀦 𑀲𑀫𑀗𑁆𑀕𑀺𑀪𑀽𑀢𑁄;

𑀲𑁄 𑀢𑀸𑀭𑀬𑁂 𑀢𑀢𑁆𑀣 𑀩𑀳𑀽𑀧𑀺 𑀅𑀜𑁆𑀜𑁂, 𑀢𑀢𑁆𑀭𑀽𑀧𑀬𑀜𑁆𑀜𑀽 𑀓𑀼𑀲𑀮𑁄 𑀫𑀼𑀢𑀻𑀫𑀸 [𑀫𑀢𑀻𑀫𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑀏𑀯𑀫𑁆𑀧𑀺 ¶ 𑀬𑁄 𑀯𑁂𑀤𑀕𑀼 𑀪𑀸𑀯𑀺𑀢𑀢𑁆𑀢𑁄, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁄 𑀳𑁄𑀢𑀺 𑀅𑀯𑁂𑀥𑀥𑀫𑁆𑀫𑁄;

𑀲𑁄 𑀔𑁄 𑀧𑀭𑁂 𑀦𑀺𑀚𑁆𑀛𑀧𑀬𑁂 𑀧𑀚𑀸𑀦𑀁, 𑀲𑁄𑀢𑀸𑀯𑀥𑀸𑀦𑀽𑀧𑀦𑀺𑀲𑀽𑀧𑀧𑀦𑁆𑀦𑁂.

𑀢𑀲𑁆𑀫𑀸 𑀳𑀯𑁂 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀁 𑀪𑀚𑁂𑀣, 𑀫𑁂𑀥𑀸𑀯𑀺𑀦𑀜𑁆𑀘𑁂𑀯 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑀜𑁆𑀘;

𑀅𑀜𑁆𑀜𑀸𑀬 𑀅𑀢𑁆𑀣𑀁 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑀫𑀸𑀦𑁄, 𑀯𑀺𑀜𑁆𑀜𑀸𑀢𑀥𑀫𑁆𑀫𑁄 𑀲 𑀲𑀼𑀔𑀁 [𑀲𑁄 𑀲𑀼𑀔𑀁 (𑀲𑀻.)] 𑀮𑀪𑁂𑀣𑀸𑀢𑀺.

𑀦𑀸𑀯𑀸𑀲𑀼𑀢𑁆𑀢𑀁 𑀅𑀝𑁆𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀓𑀺𑀁𑀲𑀻𑀮𑁄 ¶ 𑀓𑀺𑀁𑀲𑀫𑀸𑀘𑀸𑀭𑁄, 𑀓𑀸𑀦𑀺 𑀓𑀫𑁆𑀫𑀸𑀦𑀺 𑀩𑁆𑀭𑀽𑀳𑀬𑀁;

𑀦𑀭𑁄 𑀲𑀫𑁆𑀫𑀸 𑀦𑀺𑀯𑀺𑀝𑁆𑀞𑀲𑁆𑀲, 𑀉𑀢𑁆𑀢𑀫𑀢𑁆𑀣𑀜𑁆𑀘 𑀧𑀸𑀧𑀼𑀡𑁂’’.

‘‘𑀯𑀼𑀟𑁆𑀠𑀸𑀧𑀘𑀸𑀬𑀻 𑀅𑀦𑀼𑀲𑀽𑀬𑀓𑁄 𑀲𑀺𑀬𑀸, 𑀓𑀸𑀮𑀜𑁆𑀜𑀽 ¶ [𑀓𑀸𑀮𑀜𑁆𑀜𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀘𑀲𑁆𑀲 𑀕𑀭𑀽𑀦𑀁 [𑀕𑀭𑀽𑀦𑀁 (𑀲𑀻.)] 𑀤𑀲𑁆𑀲𑀦𑀸𑀬;

𑀥𑀫𑁆𑀫𑀺𑀁 𑀓𑀣𑀁 𑀏𑀭𑀬𑀺𑀢𑀁 𑀔𑀡𑀜𑁆𑀜𑀽, 𑀲𑀼𑀡𑁂𑀬𑁆𑀬 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸𑀦𑀺.

‘‘𑀓𑀸𑀮𑁂𑀦 𑀕𑀘𑁆𑀙𑁂 𑀕𑀭𑀽𑀦𑀁 𑀲𑀓𑀸𑀲𑀁, 𑀣𑀫𑁆𑀪𑀁 𑀦𑀺𑀭𑀁𑀓𑀢𑁆𑀯𑀸 [𑀦𑀺𑀭𑀸𑀓𑀢𑁆𑀯𑀸 (?) 𑀦𑀺 + 𑀆 + 𑀓𑀭 + 𑀢𑁆𑀯𑀸] 𑀦𑀺𑀯𑀸𑀢𑀯𑀼𑀢𑁆𑀢𑀺;

𑀅𑀢𑁆𑀣𑀁 ¶ 𑀥𑀫𑁆𑀫𑀁 𑀲𑀁𑀬𑀫𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, 𑀅𑀦𑀼𑀲𑁆𑀲𑀭𑁂 𑀘𑁂𑀯 𑀲𑀫𑀸𑀘𑀭𑁂 𑀘.

‘‘𑀥𑀫𑁆𑀫𑀸𑀭𑀸𑀫𑁄 𑀥𑀫𑁆𑀫𑀭𑀢𑁄, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀥𑀫𑁆𑀫𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑀜𑁆𑀜𑀽;

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

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

𑀲𑀸𑀭𑀫𑁆𑀪𑀁 𑀓𑀓𑁆𑀓𑀲𑀁 𑀓𑀲𑀸𑀯𑀜𑁆𑀘 𑀫𑀼𑀘𑁆𑀙𑀁 [𑀲𑀸𑀭𑀫𑁆𑀪 𑀓𑀓𑁆𑀓𑀲𑁆𑀲 𑀓𑀲𑀸𑀯 𑀫𑀼𑀘𑁆𑀙𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀳𑀺𑀢𑁆𑀯𑀸 𑀘𑀭𑁂 𑀯𑀻𑀢𑀫𑀤𑁄 𑀞𑀺𑀢𑀢𑁆𑀢𑁄.

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

𑀦 𑀢𑀲𑁆𑀲 𑀧𑀜𑁆𑀜𑀸 𑀘 𑀲𑀼𑀢𑀜𑁆𑀘 𑀯𑀟𑁆𑀠𑀢𑀺, 𑀬𑁄 𑀲𑀸𑀳𑀲𑁄 𑀳𑁄𑀢𑀺 𑀦𑀭𑁄 𑀧𑀫𑀢𑁆𑀢𑁄.

‘‘𑀥𑀫𑁆𑀫𑁂 ¶ ¶ 𑀘 𑀬𑁂 𑀅𑀭𑀺𑀬𑀧𑀯𑁂𑀤𑀺𑀢𑁂 𑀭𑀢𑀸,

𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑀸 ¶ 𑀢𑁂 𑀯𑀘𑀲𑀸 𑀫𑀦𑀲𑀸 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀘;

𑀢𑁂 𑀲𑀦𑁆𑀢𑀺𑀲𑁄𑀭𑀘𑁆𑀘𑀲𑀫𑀸𑀥𑀺𑀲𑀡𑁆𑀞𑀺𑀢𑀸,

𑀲𑀼𑀢𑀲𑁆𑀲 𑀧𑀜𑁆𑀜𑀸𑀬 𑀘 𑀲𑀸𑀭𑀫𑀚𑁆𑀛𑀕𑀽’’𑀢𑀺.

𑀓𑀺𑀁𑀲𑀻𑀮𑀲𑀼𑀢𑁆𑀢𑀁 𑀦𑀯𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀉𑀝𑁆𑀞𑀳𑀣 𑀦𑀺𑀲𑀻𑀤𑀣, 𑀓𑁄 𑀅𑀢𑁆𑀣𑁄 𑀲𑀼𑀧𑀺𑀢𑁂𑀦 𑀯𑁄;

𑀆𑀢𑀼𑀭𑀸𑀦𑀜𑁆𑀳𑀺 𑀓𑀸 𑀦𑀺𑀤𑁆𑀤𑀸, 𑀲𑀮𑁆𑀮𑀯𑀺𑀤𑁆𑀥𑀸𑀦 𑀭𑀼𑀧𑁆𑀧𑀢𑀁.

𑀉𑀝𑁆𑀞𑀳𑀣 ¶ 𑀦𑀺𑀲𑀻𑀤𑀣, 𑀤𑀴𑁆𑀳𑀁 𑀲𑀺𑀓𑁆𑀔𑀣 𑀲𑀦𑁆𑀢𑀺𑀬𑀸;

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

𑀬𑀸𑀬 𑀤𑁂𑀯𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀸 𑀘, 𑀲𑀺𑀢𑀸 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺 𑀅𑀢𑁆𑀣𑀺𑀓𑀸;

𑀢𑀭𑀣𑁂𑀢𑀁 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀁, 𑀔𑀡𑁄 𑀯𑁄 [𑀔𑀡𑁄 𑀯𑁂 (𑀧𑀻. 𑀓.)] 𑀫𑀸 𑀉𑀧𑀘𑁆𑀘𑀕𑀸;

𑀔𑀡𑀸𑀢𑀻𑀢𑀸 𑀳𑀺 𑀲𑁄𑀘𑀦𑁆𑀢𑀺, 𑀦𑀺𑀭𑀬𑀫𑁆𑀳𑀺 𑀲𑀫𑀧𑁆𑀧𑀺𑀢𑀸.

𑀧𑀫𑀸𑀤𑁄 𑀭𑀚𑁄 𑀧𑀫𑀸𑀤𑁄, 𑀧𑀫𑀸𑀤𑀸𑀦𑀼𑀧𑀢𑀺𑀢𑁄 𑀭𑀚𑁄;

𑀅𑀧𑁆𑀧𑀫𑀸𑀤𑁂𑀦 𑀯𑀺𑀚𑁆𑀚𑀸𑀬, 𑀅𑀩𑁆𑀩𑀳𑁂 [𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑁂 (𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀅𑀩𑁆𑀩𑀼𑀳𑁂 (𑀓. 𑀅𑀝𑁆𑀞.)] 𑀲𑀮𑁆𑀮𑀫𑀢𑁆𑀢𑀦𑁄𑀢𑀺.

𑀉𑀝𑁆𑀞𑀸𑀦𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀓𑀘𑁆𑀘𑀺 ¶ ¶ 𑀅𑀪𑀺𑀡𑁆𑀳𑀲𑀁𑀯𑀸𑀲𑀸, 𑀦𑀸𑀯𑀚𑀸𑀦𑀸𑀲𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑀁;

𑀉𑀓𑁆𑀓𑀸𑀥𑀸𑀭𑁄 [𑀑𑀓𑁆𑀓𑀸𑀥𑀸𑀭𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁, 𑀓𑀘𑁆𑀘𑀺 𑀅𑀧𑀘𑀺𑀢𑁄 𑀢𑀬𑀸’’ [𑀢𑀯 (𑀲𑀻. 𑀅𑀝𑁆𑀞.)].

‘‘𑀦𑀸𑀳𑀁 𑀅𑀪𑀺𑀡𑁆𑀳𑀲𑀁𑀯𑀸𑀲𑀸, 𑀅𑀯𑀚𑀸𑀦𑀸𑀫𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑀁;

𑀉𑀓𑁆𑀓𑀸𑀥𑀸𑀭𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀅𑀧𑀘𑀺𑀢𑁄 𑀫𑀬𑀸’’.

‘‘𑀧𑀜𑁆𑀘 ¶ 𑀓𑀸𑀫𑀕𑀼𑀡𑁂 𑀳𑀺𑀢𑁆𑀯𑀸, 𑀧𑀺𑀬𑀭𑀽𑀧𑁂 𑀫𑀦𑁄𑀭𑀫𑁂;

𑀲𑀤𑁆𑀥𑀸𑀬 𑀖𑀭𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫, 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲𑀦𑁆𑀢𑀓𑀭𑁄 𑀪𑀯.

‘‘𑀫𑀺𑀢𑁆𑀢𑁂 𑀪𑀚𑀲𑁆𑀲𑀼 𑀓𑀮𑁆𑀬𑀸𑀡𑁂, 𑀧𑀦𑁆𑀢𑀜𑁆𑀘 𑀲𑀬𑀦𑀸𑀲𑀦𑀁;

𑀯𑀺𑀯𑀺𑀢𑁆𑀢𑀁 𑀅𑀧𑁆𑀧𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑀁, 𑀫𑀢𑁆𑀢𑀜𑁆𑀜𑀽 𑀳𑁄𑀳𑀺 𑀪𑁄𑀚𑀦𑁂.

‘‘𑀘𑀻𑀯𑀭𑁂 ¶ 𑀧𑀺𑀡𑁆𑀟𑀧𑀸𑀢𑁂 𑀘, 𑀧𑀘𑁆𑀘𑀬𑁂 𑀲𑀬𑀦𑀸𑀲𑀦𑁂;

𑀏𑀢𑁂𑀲𑀼 𑀢𑀡𑁆𑀳𑀁 𑀫𑀸𑀓𑀸𑀲𑀺, 𑀫𑀸 𑀮𑁄𑀓𑀁 𑀧𑀼𑀦𑀭𑀸𑀕𑀫𑀺.

‘‘𑀲𑀁𑀯𑀼𑀢𑁄 𑀧𑀸𑀢𑀺𑀫𑁄𑀓𑁆𑀔𑀲𑁆𑀫𑀺𑀁, 𑀇𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁂𑀲𑀼 𑀘 𑀧𑀜𑁆𑀘𑀲𑀼;

𑀲𑀢𑀺 𑀓𑀸𑀬𑀕𑀢𑀸𑀢𑁆𑀬𑀢𑁆𑀣𑀼, 𑀦𑀺𑀩𑁆𑀩𑀺𑀤𑀸𑀩𑀳𑀼𑀮𑁄 𑀪𑀯.

‘‘𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑁂𑀳𑀺, 𑀲𑀼𑀪𑀁 𑀭𑀸𑀕𑀽𑀧𑀲𑀜𑁆𑀳𑀺𑀢𑀁;

𑀅𑀲𑀼𑀪𑀸𑀬 𑀘𑀺𑀢𑁆𑀢𑀁 𑀪𑀸𑀯𑁂𑀳𑀺, 𑀏𑀓𑀕𑁆𑀕𑀁 𑀲𑀼𑀲𑀫𑀸𑀳𑀺𑀢𑀁.

‘‘𑀅𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑀜𑁆𑀘 𑀪𑀸𑀯𑁂𑀳𑀺, 𑀫𑀸𑀦𑀸𑀦𑀼𑀲𑀬𑀫𑀼𑀚𑁆𑀚𑀳;

𑀢𑀢𑁄 𑀫𑀸𑀦𑀸𑀪𑀺𑀲𑀫𑀬𑀸, 𑀉𑀧𑀲𑀦𑁆𑀢𑁄 𑀘𑀭𑀺𑀲𑁆𑀲𑀢𑀻’’𑀢𑀺.

𑀇𑀢𑁆𑀣𑀁 𑀲𑀼𑀤𑀁 𑀪𑀕𑀯𑀸 𑀆𑀬𑀲𑁆𑀫𑀦𑁆𑀢𑀁 𑀭𑀸𑀳𑀼𑀮𑀁 𑀇𑀫𑀸𑀳𑀺 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀪𑀺𑀡𑁆𑀳𑀁 𑀑𑀯𑀤𑀢𑀻𑀢𑀺.

𑀭𑀸𑀳𑀼𑀮𑀲𑀼𑀢𑁆𑀢𑀁 𑀏𑀓𑀸𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀆𑀴𑀯𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀅𑀕𑁆𑀕𑀸𑀴𑀯𑁂 𑀘𑁂𑀢𑀺𑀬𑁂. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀆𑀬𑀲𑁆𑀫𑀢𑁄 𑀯𑀗𑁆𑀕𑀻𑀲𑀲𑁆𑀲 𑀉𑀧𑀚𑁆𑀛𑀸𑀬𑁄 𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑀓𑀧𑁆𑀧𑁄 𑀦𑀸𑀫 𑀣𑁂𑀭𑁄 𑀅𑀕𑁆𑀕𑀸𑀴𑀯𑁂 𑀘𑁂𑀢𑀺𑀬𑁂 𑀅𑀘𑀺𑀭𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 𑀳𑁄𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀆𑀬𑀲𑁆𑀫𑀢𑁄 𑀯𑀗𑁆𑀕𑀻𑀲𑀲𑁆𑀲 𑀭𑀳𑁄𑀕𑀢𑀲𑁆𑀲 𑀧𑀝𑀺𑀲𑀮𑁆𑀮𑀻𑀦𑀲𑁆𑀲 𑀏𑀯𑀁 𑀘𑁂𑀢𑀲𑁄 𑀧𑀭𑀺𑀯𑀺𑀢𑀓𑁆𑀓𑁄 𑀉𑀤𑀧𑀸𑀤𑀺 𑁋 ‘‘𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 𑀦𑀼 𑀔𑁄 𑀫𑁂 𑀉𑀧𑀚𑁆𑀛𑀸𑀬𑁄 𑀉𑀤𑀸𑀳𑀼 𑀦𑁄 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄’’𑀢𑀺? 𑀅𑀣 𑀔𑁄 𑀆𑀬𑀲𑁆𑀫𑀸 𑀯𑀗𑁆𑀕𑀻𑀲𑁄 𑀲𑀸𑀬𑀦𑁆𑀳𑀲𑀫𑀬𑀁 𑀧𑀝𑀺𑀲𑀮𑁆𑀮𑀸𑀦𑀸 𑀯𑀼𑀝𑁆𑀞𑀺𑀢𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 ¶ 𑀦𑀺𑀲𑀻𑀤𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀔𑁄 𑀆𑀬𑀲𑁆𑀫𑀸 𑀯𑀗𑁆𑀕𑀻𑀲𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀇𑀥 𑀫𑀬𑁆𑀳𑀁, 𑀪𑀦𑁆𑀢𑁂, 𑀭𑀳𑁄𑀕𑀢𑀲𑁆𑀲 𑀧𑀝𑀺𑀲𑀮𑁆𑀮𑀻𑀦𑀲𑁆𑀲 𑀏𑀯𑀁 𑀘𑁂𑀢𑀲𑁄 𑀧𑀭𑀺𑀯𑀺𑀢𑀓𑁆𑀓𑁄 𑀉𑀤𑀧𑀸𑀤𑀺 𑁋 ‘𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 ¶ 𑀦𑀼 𑀔𑁄 𑀫𑁂 𑀉𑀧𑀚𑁆𑀛𑀸𑀬𑁄, 𑀉𑀤𑀸𑀳𑀼 𑀦𑁄 𑀧𑀭𑀺𑀦𑀩𑁆𑀩𑀼𑀢𑁄’’’𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀆𑀬𑀲𑁆𑀫𑀸 𑀯𑀗𑁆𑀕𑀻𑀲𑁄 𑀉𑀝𑁆𑀞𑀸𑀬𑀸𑀲𑀦𑀸 𑀏𑀓𑀁𑀲𑀁 𑀘𑀻𑀯𑀭𑀁 𑀓𑀢𑁆𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀜𑁆𑀚𑀮𑀺𑀁 𑀧𑀡𑀸𑀫𑁂𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫 [𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 (𑀓.)] 𑀲𑀢𑁆𑀣𑀸𑀭𑀫𑀦𑁄𑀫𑀧𑀜𑁆𑀜𑀁, 𑀤𑀺𑀝𑁆𑀞𑁂𑀯 𑀥𑀫𑁆𑀫𑁂 𑀬𑁄 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀸𑀦𑀁 𑀙𑁂𑀢𑁆𑀢𑀸;

𑀅𑀕𑁆𑀕𑀸𑀴𑀯𑁂 𑀓𑀸𑀮𑀫𑀓𑀸𑀲𑀺 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀜𑀸𑀢𑁄 𑀬𑀲𑀲𑁆𑀲𑀻 𑀅𑀪𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀢𑁆𑀢𑁄.

‘‘𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑀓𑀧𑁆𑀧𑁄 ¶ 𑀇𑀢𑀺 𑀢𑀲𑁆𑀲 𑀦𑀸𑀫𑀁, 𑀢𑀬𑀸 𑀓𑀢𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲;

𑀲𑁄 𑀢𑀁 𑀦𑀫𑀲𑁆𑀲𑀁 𑀅𑀘𑀭𑀺 𑀫𑀼𑀢𑁆𑀬𑀧𑁂𑀓𑁆𑀔𑁄, 𑀆𑀭𑀤𑁆𑀥𑀯𑀻𑀭𑀺𑀬𑁄 𑀤𑀴𑁆𑀳𑀥𑀫𑁆𑀫𑀤𑀲𑁆𑀲𑀻.

‘‘𑀢𑀁 𑀲𑀸𑀯𑀓𑀁 𑀲𑀓𑁆𑀬 [𑀲𑀓𑁆𑀓 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀬𑀫𑁆𑀧𑀺 𑀲𑀩𑁆𑀩𑁂, 𑀅𑀜𑁆𑀜𑀸𑀢𑀼𑀫𑀺𑀘𑁆𑀙𑀸𑀫 𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼;

𑀲𑀫𑀯𑀝𑁆𑀞𑀺𑀢𑀸 𑀦𑁄 𑀲𑀯𑀦𑀸𑀬 𑀲𑁄𑀢𑀸, 𑀢𑀼𑀯𑀁 𑀦𑁄 𑀲𑀢𑁆𑀣𑀸 𑀢𑁆𑀯𑀫𑀦𑀼𑀢𑁆𑀢𑀭𑁄𑀲𑀺.

‘‘𑀙𑀺𑀦𑁆𑀤𑁂𑀯 𑀦𑁄 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀁 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂𑀢𑀁, 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀁 𑀯𑁂𑀤𑀬 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜;

𑀫𑀚𑁆𑀛𑁂𑀯 [𑀫𑀚𑁆𑀛𑁂 𑀘 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀦𑁄 𑀪𑀸𑀲 𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼, 𑀲𑀓𑁆𑀓𑁄𑀯 𑀤𑁂𑀯𑀸𑀦 𑀲𑀳𑀲𑁆𑀲𑀦𑁂𑀢𑁆𑀢𑁄.

‘‘𑀬𑁂 𑀓𑁂𑀘𑀺 𑀕𑀦𑁆𑀣𑀸 𑀇𑀥 𑀫𑁄𑀳𑀫𑀕𑁆𑀕𑀸, 𑀅𑀜𑁆𑀜𑀸𑀡𑀧𑀓𑁆𑀔𑀸 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀞𑀸𑀦𑀸;

𑀢𑀣𑀸𑀕𑀢𑀁 ¶ 𑀧𑀢𑁆𑀯𑀸 𑀦 𑀢𑁂 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀘𑀓𑁆𑀔𑀼𑀜𑁆𑀳𑀺 𑀏𑀢𑀁 𑀧𑀭𑀫𑀁 𑀦𑀭𑀸𑀦𑀁.

‘‘𑀦𑁄 ¶ 𑀘𑁂 𑀳𑀺 𑀚𑀸𑀢𑀼 𑀧𑀼𑀭𑀺𑀲𑁄 𑀓𑀺𑀮𑁂𑀲𑁂, 𑀯𑀸𑀢𑁄 𑀬𑀣𑀸 𑀅𑀩𑁆𑀪𑀥𑀦𑀁 𑀯𑀺𑀳𑀸𑀦𑁂;

𑀢𑀫𑁄𑀯𑀲𑁆𑀲 𑀦𑀺𑀯𑀼𑀢𑁄 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑁄, 𑀦 ¶ 𑀚𑁄𑀢𑀺𑀫𑀦𑁆𑀢𑁄𑀧𑀺 𑀦𑀭𑀸 𑀢𑀧𑁂𑀬𑁆𑀬𑀼𑀁.

‘‘𑀥𑀻𑀭𑀸 ¶ 𑀘 𑀧𑀚𑁆𑀚𑁄𑀢𑀓𑀭𑀸 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀢𑀁 𑀢𑀁 𑀅𑀳𑀁 𑀯𑀻𑀭 [𑀥𑀻𑀭 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀢𑀣𑁂𑀯 𑀫𑀜𑁆𑀜𑁂;

𑀯𑀺𑀧𑀲𑁆𑀲𑀺𑀦𑀁 𑀚𑀸𑀦𑀫𑀼𑀧𑀸𑀕𑀫𑀼𑀫𑁆𑀳𑀸 [𑀚𑀸𑀦𑀫𑀼𑀧𑀕𑀫𑀫𑁆𑀳𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀧𑀭𑀺𑀲𑀸𑀲𑀼 𑀦𑁄 𑀆𑀯𑀺𑀓𑀭𑁄𑀳𑀺 𑀓𑀧𑁆𑀧𑀁.

‘‘𑀔𑀺𑀧𑁆𑀧𑀁 𑀕𑀺𑀭𑀁 𑀏𑀭𑀬 𑀯𑀕𑁆𑀕𑀼 𑀯𑀕𑁆𑀕𑀼𑀁, 𑀳𑀁𑀲𑁄𑀯 𑀧𑀕𑁆𑀕𑀬𑁆𑀳 𑀲𑀡𑀺𑀓𑀁 [𑀲𑀡𑀺𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀦𑀺𑀓𑀽𑀚;

𑀩𑀺𑀦𑁆𑀤𑀼𑀲𑁆𑀲𑀭𑁂𑀦 𑀲𑀼𑀯𑀺𑀓𑀧𑁆𑀧𑀺𑀢𑁂𑀦, 𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀉𑀚𑁆𑀚𑀼𑀕𑀢𑀸 𑀲𑀼𑀡𑁄𑀫.

‘‘𑀧𑀳𑀻𑀦𑀚𑀸𑀢𑀺𑀫𑀭𑀡𑀁 𑀅𑀲𑁂𑀲𑀁, 𑀦𑀺𑀕𑁆𑀕𑀬𑁆𑀳 𑀥𑁄𑀦𑀁 [𑀥𑁄𑀢𑀁 (𑀲𑀻.)] 𑀯𑀤𑁂𑀲𑁆𑀲𑀸𑀫𑀺 𑀥𑀫𑁆𑀫𑀁;

𑀦 𑀓𑀸𑀫𑀓𑀸𑀭𑁄 𑀳𑀺 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀦𑀸𑀦𑀁, 𑀲𑀗𑁆𑀔𑁂𑀬𑁆𑀬𑀓𑀸𑀭𑁄 𑀘 [𑀲𑀗𑁆𑀔𑀬𑁆𑀬𑀓𑀸𑀭𑁄𑀯 (𑀓.)] 𑀢𑀣𑀸𑀕𑀢𑀸𑀦𑀁.

‘‘𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀯𑁂𑀬𑁆𑀬𑀸𑀓𑀭𑀡𑀁 𑀢𑀯𑁂𑀤𑀁, 𑀲𑀫𑀼𑀚𑁆𑀚𑀼𑀧𑀜𑁆𑀜𑀲𑁆𑀲 [𑀲𑀫𑀼𑀚𑁆𑀚𑀧𑀜𑁆𑀜𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀲𑀫𑀼𑀕𑁆𑀕𑀳𑀻𑀢𑀁;

𑀅𑀬𑀫𑀜𑁆𑀚𑀮𑀻 𑀧𑀘𑁆𑀙𑀺𑀫𑁄 𑀲𑀼𑀧𑁆𑀧𑀡𑀸𑀫𑀺𑀢𑁄, 𑀫𑀸 𑀫𑁄𑀳𑀬𑀻 𑀚𑀸𑀦𑀫𑀦𑁄𑀫𑀧𑀜𑁆𑀜.

‘‘𑀧𑀭𑁄𑀯𑀭𑀁 [𑀯𑀭𑀸𑀯𑀭𑀁 (𑀓𑀢𑁆𑀣𑀘𑀺)] 𑀅𑀭𑀺𑀬𑀥𑀫𑁆𑀫𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸, 𑀫𑀸 𑀫𑁄𑀳𑀬𑀻 𑀚𑀸𑀦𑀫𑀦𑁄𑀫𑀯𑀻𑀭;

𑀯𑀸𑀭𑀺𑀁 𑀬𑀣𑀸 ¶ 𑀖𑀫𑁆𑀫𑀦𑀺 𑀖𑀫𑁆𑀫𑀢𑀢𑁆𑀢𑁄, 𑀯𑀸𑀘𑀸𑀪𑀺𑀓𑀗𑁆𑀔𑀸𑀫𑀺 ¶ 𑀲𑀼𑀢𑀁 𑀧𑀯𑀲𑁆𑀲 [𑀲𑀼𑀢𑀲𑁆𑀲 𑀯𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸.)].

‘‘𑀬𑀤𑀢𑁆𑀣𑀺𑀓𑀁 [𑀬𑀤𑀢𑁆𑀣𑀺𑀬𑀁 (𑀧𑀻.), 𑀬𑀤𑀢𑁆𑀣𑀺𑀢𑀁 (𑀓.)] 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁 𑀅𑀘𑀭𑀻, 𑀓𑀧𑁆𑀧𑀸𑀬𑀦𑁄 𑀓𑀘𑁆𑀘𑀺𑀲𑁆𑀲 𑀢𑀁 𑀅𑀫𑁄𑀖𑀁;

𑀦𑀺𑀩𑁆𑀩𑀸𑀬𑀺 𑀲𑁄 𑀆𑀤𑀼 𑀲𑀉𑀧𑀸𑀤𑀺𑀲𑁂𑀲𑁄, 𑀬𑀣𑀸 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄 𑀅𑀳𑀼 𑀢𑀁 𑀲𑀼𑀡𑁄𑀫’’.

‘‘𑀅𑀘𑁆𑀙𑁂𑀘𑁆𑀙𑀺 ¶ [𑀅𑀙𑁂𑀚𑁆𑀚𑀺 (𑀓.)] 𑀢𑀡𑁆𑀳𑀁 𑀇𑀥 𑀦𑀸𑀫𑀭𑀽𑀧𑁂, (𑀇𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀓𑀡𑁆𑀳𑀲𑁆𑀲 [𑀢𑀡𑁆𑀳𑀸𑀬 (𑀓.)] 𑀲𑁄𑀢𑀁 𑀤𑀻𑀖𑀭𑀢𑁆𑀢𑀸𑀦𑀼𑀲𑀬𑀺𑀢𑀁;

𑀅𑀢𑀸𑀭𑀺 𑀚𑀸𑀢𑀺𑀁 𑀫𑀭𑀡𑀁 𑀅𑀲𑁂𑀲𑀁,’’

𑀇𑀘𑁆𑀘𑀩𑁆𑀭𑀯𑀻 𑀪𑀕𑀯𑀸 𑀧𑀜𑁆𑀘𑀲𑁂𑀝𑁆𑀞𑁄.

‘‘𑀏𑀲 𑀲𑀼𑀢𑁆𑀯𑀸 𑀧𑀲𑀻𑀤𑀸𑀫𑀺, 𑀯𑀘𑁄 𑀢𑁂 𑀇𑀲𑀺𑀲𑀢𑁆𑀢𑀫;

𑀅𑀫𑁄𑀖𑀁 𑀓𑀺𑀭 𑀫𑁂 𑀧𑀼𑀝𑁆𑀞𑀁, 𑀦 𑀫𑀁 𑀯𑀜𑁆𑀘𑁂𑀲𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀬𑀣𑀸𑀯𑀸𑀤𑀻 ¶ 𑀢𑀣𑀸𑀓𑀸𑀭𑀻, 𑀅𑀳𑀼 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀲𑀸𑀯𑀓𑁄;

𑀅𑀘𑁆𑀙𑀺𑀤𑀸 𑀫𑀘𑁆𑀘𑀼𑀦𑁄 𑀚𑀸𑀮𑀁, 𑀢𑀢𑀁 𑀫𑀸𑀬𑀸𑀯𑀺𑀦𑁄 𑀤𑀴𑁆𑀳𑀁.

‘‘𑀅𑀤𑁆𑀤𑀲𑀸 𑀪𑀕𑀯𑀸 𑀆𑀤𑀺𑀁, 𑀉𑀧𑀸𑀤𑀸𑀦𑀲𑁆𑀲 𑀓𑀧𑁆𑀧𑀺𑀬𑁄;

𑀅𑀘𑁆𑀘𑀕𑀸 𑀯𑀢 𑀓𑀧𑁆𑀧𑀸𑀬𑀦𑁄, 𑀫𑀘𑁆𑀘𑀼𑀥𑁂𑀬𑁆𑀬𑀁 𑀲𑀼𑀤𑀼𑀢𑁆𑀢𑀭’’𑀦𑁆𑀢𑀺.

𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑀓𑀧𑁆𑀧𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁧𑁩. 𑀲𑀫𑁆𑀫𑀸𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀦𑀻𑀬𑀲𑀼𑀢𑁆𑀢𑀁

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 ¶ ¶ 𑀫𑀼𑀦𑀺𑀁 𑀧𑀳𑀽𑀢𑀧𑀜𑁆𑀜𑀁,

𑀢𑀺𑀡𑁆𑀡𑀁 𑀧𑀸𑀭𑀗𑁆𑀕𑀢𑀁 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀁 𑀞𑀺𑀢𑀢𑁆𑀢𑀁;

𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫 𑀖𑀭𑀸 𑀧𑀦𑀼𑀚𑁆𑀚 𑀓𑀸𑀫𑁂, 𑀓𑀣𑀁 𑀪𑀺𑀓𑁆𑀔𑀼

𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬’’.

‘‘𑀬𑀲𑁆𑀲 𑀫𑀗𑁆𑀕𑀮𑀸 𑀲𑀫𑀽𑀳𑀢𑀸, (𑀇𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀉𑀧𑁆𑀧𑀸𑀢𑀸 𑀲𑀼𑀧𑀺𑀦𑀸 𑀘 𑀮𑀓𑁆𑀔𑀡𑀸 𑀘;

𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀭𑀸𑀕𑀁 𑀯𑀺𑀦𑀬𑁂𑀣 𑀫𑀸𑀦𑀼𑀲𑁂𑀲𑀼, 𑀤𑀺𑀩𑁆𑀩𑁂𑀲𑀼 𑀓𑀸𑀫𑁂𑀲𑀼 𑀘𑀸𑀧𑀺 𑀪𑀺𑀓𑁆𑀔𑀼;

𑀅𑀢𑀺𑀓𑁆𑀓𑀫𑁆𑀫 𑀪𑀯𑀁 𑀲𑀫𑁂𑀘𑁆𑀘 𑀥𑀫𑁆𑀫𑀁, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀯𑀺𑀧𑀺𑀝𑁆𑀞𑀺𑀓𑀢𑁆𑀯𑀸𑀦 ¶ 𑀧𑁂𑀲𑀼𑀡𑀸𑀦𑀺, 𑀓𑁄𑀥𑀁 𑀓𑀤𑀭𑀺𑀬𑀁 𑀚𑀳𑁂𑀬𑁆𑀬 𑀪𑀺𑀓𑁆𑀔𑀼;

𑀅𑀦𑀼𑀭𑁄𑀥𑀯𑀺𑀭𑁄𑀥𑀯𑀺𑀧𑁆𑀧𑀳𑀻𑀦𑁄, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀳𑀺𑀢𑁆𑀯𑀸𑀦 ¶ 𑀧𑀺𑀬𑀜𑁆𑀘 𑀅𑀧𑁆𑀧𑀺𑀬𑀜𑁆𑀘, 𑀅𑀦𑀼𑀧𑀸𑀤𑀸𑀬 𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺;

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

‘‘𑀦 ¶ 𑀲𑁄 𑀉𑀧𑀥𑀻𑀲𑀼 𑀲𑀸𑀭𑀫𑁂𑀢𑀺, 𑀆𑀤𑀸𑀦𑁂𑀲𑀼 𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀙𑀦𑁆𑀤𑀭𑀸𑀕𑀁;

𑀲𑁄 𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀅𑀦𑀜𑁆𑀜𑀦𑁂𑀬𑁆𑀬𑁄, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀯𑀘𑀲𑀸 ¶ 𑀫𑀦𑀲𑀸 𑀘 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀘, 𑀅𑀯𑀺𑀭𑀼𑀤𑁆𑀥𑁄 𑀲𑀫𑁆𑀫𑀸 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀁;

𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀧𑀤𑀸𑀪𑀺𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑁄, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀬𑁄 𑀯𑀦𑁆𑀤𑀢𑀺 𑀫𑀦𑁆𑀢𑀺 𑀦𑀼𑀡𑁆𑀡𑀫𑁂𑀬𑁆𑀬 [𑀦𑀼𑀦𑁆𑀦𑀫𑁂𑀬𑁆𑀬 (?)], 𑀅𑀓𑁆𑀓𑀼𑀝𑁆𑀞𑁄𑀧𑀺 𑀦 𑀲𑀦𑁆𑀥𑀺𑀬𑁂𑀣 𑀪𑀺𑀓𑁆𑀔𑀼;

𑀮𑀤𑁆𑀥𑀸 𑀧𑀭𑀪𑁄𑀚𑀦𑀁 𑀦 𑀫𑀚𑁆𑀚𑁂, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀮𑁄𑀪𑀜𑁆𑀘 𑀪𑀯𑀜𑁆𑀘 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀬, 𑀯𑀺𑀭𑀢𑁄 𑀙𑁂𑀤𑀦𑀩𑀦𑁆𑀥𑀦𑀸 𑀘 [𑀙𑁂𑀤𑀦𑀩𑀦𑁆𑀥𑀦𑀢𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀪𑀺𑀓𑁆𑀔𑀼;

𑀲𑁄 𑀢𑀺𑀡𑁆𑀡𑀓𑀣𑀁𑀓𑀣𑁄 𑀯𑀺𑀲𑀮𑁆𑀮𑁄, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀲𑀸𑀭𑀼𑀧𑁆𑀧𑀁 ¶ 𑀅𑀢𑁆𑀢𑀦𑁄 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸, 𑀦𑁄 𑀘 𑀪𑀺𑀓𑁆𑀔𑀼 𑀳𑀺𑀁𑀲𑁂𑀬𑁆𑀬 𑀓𑀜𑁆𑀘𑀺 𑀮𑁄𑀓𑁂;

𑀬𑀣𑀸 𑀢𑀣𑀺𑀬𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀁, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀬𑀲𑁆𑀲𑀸𑀦𑀼𑀲𑀬𑀸 ¶ 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀓𑁂𑀘𑀺, 𑀫𑀽𑀮𑀸 𑀘 [𑀫𑀽𑀮𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀅𑀓𑀼𑀲𑀮𑀸 𑀲𑀫𑀽𑀳𑀢𑀸𑀲𑁂;

𑀲𑁄 𑀦𑀺𑀭𑀸𑀲𑁄 [𑀦𑀺𑀭𑀸𑀲𑀬𑁄 (𑀲𑀻.), 𑀦𑀺𑀭𑀸𑀲𑀲𑁄 (𑀲𑁆𑀬𑀸.)] 𑀅𑀦𑀸𑀲𑀺𑀲𑀸𑀦𑁄 [𑀅𑀦𑀸𑀲𑀬𑀸𑀦𑁄 (𑀲𑀻. 𑀧𑀻.), 𑀅𑀦𑀸𑀲𑀲𑀸𑀦𑁄 (𑀲𑁆𑀬𑀸.)], 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀆𑀲𑀯𑀔𑀻𑀡𑁄 ¶ 𑀧𑀳𑀻𑀦𑀫𑀸𑀦𑁄, 𑀲𑀩𑁆𑀩𑀁 𑀭𑀸𑀕𑀧𑀣𑀁 𑀉𑀧𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑁄;

𑀤𑀦𑁆𑀢𑁄 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 𑀞𑀺𑀢𑀢𑁆𑀢𑁄, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀲𑀤𑁆𑀥𑁄 𑀲𑀼𑀢𑀯𑀸 𑀦𑀺𑀬𑀸𑀫𑀤𑀲𑁆𑀲𑀻, 𑀯𑀕𑁆𑀕𑀕𑀢𑁂𑀲𑀼 𑀦 𑀯𑀕𑁆𑀕𑀲𑀸𑀭𑀺 𑀥𑀻𑀭𑁄;

𑀮𑁄𑀪𑀁 𑀤𑁄𑀲𑀁 𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀧𑀝𑀺𑀖𑀁, 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀲𑀁𑀲𑀼𑀤𑁆𑀥𑀚𑀺𑀦𑁄 𑀯𑀺𑀯𑀝𑁆𑀝𑀘𑁆𑀙𑀤𑁄, 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀯𑀲𑀻 𑀧𑀸𑀭𑀕𑀽 𑀅𑀦𑁂𑀚𑁄;

𑀲𑀗𑁆𑀔𑀸𑀭𑀦𑀺𑀭𑁄𑀥𑀜𑀸𑀡𑀓𑀼𑀲𑀮𑁄 ¶ , 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬.

‘‘𑀅𑀢𑀻𑀢𑁂𑀲𑀼 𑀅𑀦𑀸𑀕𑀢𑁂𑀲𑀼 𑀘𑀸𑀧𑀺, 𑀓𑀧𑁆𑀧𑀸𑀢𑀻𑀢𑁄 𑀅𑀢𑀺𑀘𑁆𑀘𑀲𑀼𑀤𑁆𑀥𑀺𑀧𑀜𑁆𑀜𑁄;

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

‘‘𑀅𑀜𑁆𑀜𑀸𑀬 ¶ 𑀧𑀤𑀁 𑀲𑀫𑁂𑀘𑁆𑀘 𑀥𑀫𑁆𑀫𑀁, 𑀯𑀺𑀯𑀝𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀧𑀳𑀸𑀦𑀫𑀸𑀲𑀯𑀸𑀦𑀁;

𑀲𑀩𑁆𑀩𑀼𑀧𑀥𑀻𑀦𑀁 𑀧𑀭𑀺𑀓𑁆𑀔𑀬𑀸𑀦𑁄 [𑀧𑀭𑀺𑀓𑁆𑀔𑀬𑀸 (𑀧𑀻.)], 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬’’.

‘‘𑀅𑀤𑁆𑀥𑀸 ¶ 𑀳𑀺 𑀪𑀕𑀯𑀸 𑀢𑀣𑁂𑀯 𑀏𑀢𑀁, 𑀬𑁄 𑀲𑁄 𑀏𑀯𑀁𑀯𑀺𑀳𑀸𑀭𑀻 𑀤𑀦𑁆𑀢𑁄 𑀪𑀺𑀓𑁆𑀔𑀼;

𑀲𑀩𑁆𑀩𑀲𑀁𑀬𑁄𑀚𑀦𑀬𑁄𑀕𑀯𑀻𑀢𑀺𑀯𑀢𑁆𑀢𑁄 ¶ [𑀲𑀩𑁆𑀩𑀲𑀁𑀬𑁄𑀚𑀦𑀺𑀬𑁂 𑀘 𑀯𑀻𑀢𑀺𑀯𑀢𑁆𑀢𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀲𑀫𑁆𑀫𑀸 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬𑀸’’𑀢𑀺.

𑀲𑀫𑁆𑀫𑀸𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀦𑀻𑀬𑀲𑀼𑀢𑁆𑀢𑀁 𑀢𑁂𑀭𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀚𑁂𑀢𑀯𑀦𑁂 𑀅𑀦𑀸𑀣𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑀲𑁆𑀲 𑀆𑀭𑀸𑀫𑁂. 𑀅𑀣 𑀔𑁄 𑀥𑀫𑁆𑀫𑀺𑀓𑁄 𑀉𑀧𑀸𑀲𑀓𑁄 ¶ 𑀧𑀜𑁆𑀘𑀳𑀺 𑀉𑀧𑀸𑀲𑀓𑀲𑀢𑁂𑀳𑀺 𑀲𑀤𑁆𑀥𑀺𑀁 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀔𑁄 𑀥𑀫𑁆𑀫𑀺𑀓𑁄 𑀉𑀧𑀸𑀲𑀓𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀕𑁄𑀢𑀫 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜, 𑀓𑀣𑀁𑀓𑀭𑁄 𑀲𑀸𑀯𑀓𑁄 𑀲𑀸𑀥𑀼 𑀳𑁄𑀢𑀺;

𑀬𑁄 𑀯𑀸 𑀅𑀕𑀸𑀭𑀸 𑀅𑀦𑀕𑀸𑀭𑀫𑁂𑀢𑀺, 𑀅𑀕𑀸𑀭𑀺𑀦𑁄 𑀯𑀸 𑀧𑀦𑀼𑀧𑀸𑀲𑀓𑀸𑀲𑁂.

‘‘𑀢𑀼𑀯𑀜𑁆𑀳𑀺 𑀮𑁄𑀓𑀲𑁆𑀲 𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲, 𑀕𑀢𑀺𑀁 𑀧𑀚𑀸𑀦𑀸𑀲𑀺 𑀧𑀭𑀸𑀬𑀡𑀜𑁆𑀘;

𑀦 𑀘𑀢𑁆𑀣𑀺 𑀢𑀼𑀮𑁆𑀬𑁄 𑀦𑀺𑀧𑀼𑀡𑀢𑁆𑀣𑀤𑀲𑁆𑀲𑀻, 𑀢𑀼𑀯𑀜𑁆𑀳𑀺 𑀩𑀼𑀤𑁆𑀥𑀁 𑀧𑀯𑀭𑀁 𑀯𑀤𑀦𑁆𑀢𑀺.

‘‘𑀲𑀩𑁆𑀩𑀁 𑀢𑀼𑀯𑀁 𑀜𑀸𑀡𑀫𑀯𑁂𑀘𑁆𑀘 𑀥𑀫𑁆𑀫𑀁, 𑀧𑀓𑀸𑀲𑁂𑀲𑀺 𑀲𑀢𑁆𑀢𑁂 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀫𑀸𑀦𑁄;

𑀯𑀺𑀯𑀝𑁆𑀝𑀘𑁆𑀙𑀤𑁄𑀲𑀺 𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼, 𑀯𑀺𑀭𑁄𑀘𑀲𑀺 𑀯𑀺𑀫𑀮𑁄 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑁂.

‘‘𑀆𑀕𑀜𑁆𑀙𑀺 ¶ 𑀢𑁂 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀦𑀸𑀕𑀭𑀸𑀚𑀸, 𑀏𑀭𑀸𑀯𑀡𑁄 𑀦𑀸𑀫 𑀚𑀺𑀦𑁄𑀢𑀺 𑀲𑀼𑀢𑁆𑀯𑀸;

𑀲𑁄𑀧𑀺 𑀢𑀬𑀸 𑀫𑀦𑁆𑀢𑀬𑀺𑀢𑁆𑀯𑀸𑀚𑁆𑀛𑀕𑀫𑀸, 𑀲𑀸𑀥𑀽𑀢𑀺 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀧𑀢𑀻𑀢𑀭𑀽𑀧𑁄.

‘‘𑀭𑀸𑀚𑀸𑀧𑀺 ¶ ¶ ¶ 𑀢𑀁 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑁄 𑀓𑀼𑀯𑁂𑀭𑁄, 𑀉𑀧𑁂𑀢𑀺 𑀥𑀫𑁆𑀫𑀁 𑀧𑀭𑀺𑀧𑀼𑀘𑁆𑀙𑀫𑀸𑀦𑁄;

𑀢𑀲𑁆𑀲𑀸𑀧𑀺 𑀢𑁆𑀯𑀁 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀩𑁆𑀭𑀽𑀲𑀺 𑀥𑀻𑀭, 𑀲𑁄 𑀘𑀸𑀧𑀺 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀧𑀢𑀻𑀢𑀭𑀽𑀧𑁄.

‘‘𑀬𑁂 𑀓𑁂𑀘𑀺𑀫𑁂 𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑀸 𑀯𑀸𑀤𑀲𑀻𑀮𑀸, 𑀆𑀚𑀻𑀯𑀓𑀸 𑀯𑀸 𑀬𑀤𑀺 𑀯𑀸 𑀦𑀺𑀕𑀡𑁆𑀞𑀸;

𑀧𑀜𑁆𑀜𑀸𑀬 𑀢𑀁 𑀦𑀸𑀢𑀺𑀢𑀭𑀦𑁆𑀢𑀺 𑀲𑀩𑁆𑀩𑁂, 𑀞𑀺𑀢𑁄 𑀯𑀚𑀦𑁆𑀢𑀁 𑀯𑀺𑀬 𑀲𑀻𑀖𑀕𑀸𑀫𑀺𑀁.

‘‘𑀬𑁂 𑀓𑁂𑀘𑀺𑀫𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀯𑀸𑀤𑀲𑀻𑀮𑀸, 𑀯𑀼𑀤𑁆𑀥𑀸 𑀘𑀸𑀧𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀲𑀦𑁆𑀢𑀺 𑀓𑁂𑀘𑀺;

𑀲𑀩𑁆𑀩𑁂 𑀢𑀬𑀺 𑀅𑀢𑁆𑀣𑀩𑀤𑁆𑀥𑀸 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀬𑁂 𑀘𑀸𑀧𑀺 𑀅𑀜𑁆𑀜𑁂 𑀯𑀸𑀤𑀺𑀦𑁄 𑀫𑀜𑁆𑀜𑀫𑀸𑀦𑀸.

‘‘𑀅𑀬𑀜𑁆𑀳𑀺 𑀥𑀫𑁆𑀫𑁄 𑀦𑀺𑀧𑀼𑀡𑁄 𑀲𑀼𑀔𑁄 𑀘, 𑀬𑁄𑀬𑀁 𑀢𑀬𑀸 𑀪𑀕𑀯𑀸 𑀲𑀼𑀧𑁆𑀧𑀯𑀼𑀢𑁆𑀢𑁄;

𑀢𑀫𑁂𑀯 𑀲𑀩𑁆𑀩𑁂𑀧𑀺 [𑀲𑀩𑁆𑀩𑁂 𑀫𑀬𑀁 (𑀲𑁆𑀬𑀸.)] 𑀲𑀼𑀲𑁆𑀲𑀽𑀲𑀫𑀸𑀦𑀸, 𑀢𑀁 𑀦𑁄 𑀯𑀤 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀩𑀼𑀤𑁆𑀥𑀲𑁂𑀝𑁆𑀞.

‘‘𑀲𑀩𑁆𑀩𑁂𑀧𑀺 𑀫𑁂 𑀪𑀺𑀓𑁆𑀔𑀯𑁄 𑀲𑀦𑁆𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀸, 𑀉𑀧𑀸𑀲𑀓𑀸 𑀘𑀸𑀧𑀺 𑀢𑀣𑁂𑀯 𑀲𑁄𑀢𑀼𑀁;

𑀲𑀼𑀡𑀦𑁆𑀢𑀼 𑀥𑀫𑁆𑀫𑀁 𑀯𑀺𑀫𑀮𑁂𑀦𑀸𑀦𑀼𑀩𑀼𑀤𑁆𑀥𑀁, 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 ¶ 𑀯𑀸𑀲𑀯𑀲𑁆𑀲𑁂𑀯 𑀤𑁂𑀯𑀸’’.

‘‘𑀲𑀼𑀡𑀸𑀣 𑀫𑁂 𑀪𑀺𑀓𑁆𑀔𑀯𑁄 𑀲𑀸𑀯𑀬𑀸𑀫𑀺 𑀯𑁄, 𑀥𑀫𑁆𑀫𑀁 𑀥𑀼𑀢𑀁 𑀢𑀜𑁆𑀘 𑀘𑀭𑀸𑀣 𑀲𑀩𑁆𑀩𑁂;

𑀇𑀭𑀺𑀬𑀸𑀧𑀣𑀁 ¶ 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀸𑀦𑀼𑀮𑁄𑀫𑀺𑀓𑀁, 𑀲𑁂𑀯𑁂𑀣 𑀦𑀁 𑀅𑀢𑁆𑀣𑀤𑀲𑁄 𑀫𑀼𑀢𑀻𑀫𑀸.

‘‘𑀦𑁄 𑀯𑁂 𑀯𑀺𑀓𑀸𑀮𑁂 𑀯𑀺𑀘𑀭𑁂𑀬𑁆𑀬 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀕𑀸𑀫𑁂 𑀘 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑁂𑀬𑁆𑀬 𑀓𑀸𑀮𑁂;

𑀅𑀓𑀸𑀮𑀘𑀸𑀭𑀺𑀜𑁆𑀳𑀺 𑀲𑀚𑀦𑁆𑀢𑀺 𑀲𑀗𑁆𑀕𑀸, 𑀢𑀲𑁆𑀫𑀸 𑀯𑀺𑀓𑀸𑀮𑁂 𑀦 𑀘𑀭𑀦𑁆𑀢𑀺 𑀩𑀼𑀤𑁆𑀥𑀸.

‘‘𑀭𑀽𑀧𑀸 ¶ 𑀘 𑀲𑀤𑁆𑀤𑀸 𑀘 𑀭𑀲𑀸 𑀘 𑀕𑀦𑁆𑀥𑀸, 𑀨𑀲𑁆𑀲𑀸 𑀘 𑀬𑁂 𑀲𑀫𑁆𑀫𑀤𑀬𑀦𑁆𑀢𑀺 𑀲𑀢𑁆𑀢𑁂;

𑀏𑀢𑁂𑀲𑀼 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀙𑀦𑁆𑀤𑀁, 𑀓𑀸𑀮𑁂𑀦 𑀲𑁄 𑀧𑀯𑀺𑀲𑁂 𑀧𑀸𑀢𑀭𑀸𑀲𑀁.

‘‘𑀧𑀺𑀡𑁆𑀟𑀜𑁆𑀘 𑀪𑀺𑀓𑁆𑀔𑀼 𑀲𑀫𑀬𑁂𑀦 𑀮𑀤𑁆𑀥𑀸, 𑀏𑀓𑁄 𑀧𑀝𑀺𑀓𑁆𑀓𑀫𑁆𑀫 𑀭𑀳𑁄 𑀦𑀺𑀲𑀻𑀤𑁂;

𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀘𑀺𑀦𑁆𑀢𑀻 𑀦 𑀫𑀦𑁄 𑀩𑀳𑀺𑀤𑁆𑀥𑀸, 𑀦𑀺𑀘𑁆𑀙𑀸𑀭𑀬𑁂 𑀲𑀗𑁆𑀕𑀳𑀺𑀢𑀢𑁆𑀢𑀪𑀸𑀯𑁄.

‘‘𑀲𑀘𑁂𑀧𑀺 𑀲𑁄 𑀲𑀮𑁆𑀮𑀧𑁂 𑀲𑀸𑀯𑀓𑁂𑀦, 𑀅𑀜𑁆𑀜𑁂𑀦 𑀯𑀸 𑀓𑁂𑀦𑀘𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑀸 𑀯𑀸;

𑀥𑀫𑁆𑀫𑀁 ¶ 𑀧𑀡𑀻𑀢𑀁 𑀢𑀫𑀼𑀤𑀸𑀳𑀭𑁂𑀬𑁆𑀬, 𑀦 𑀧𑁂𑀲𑀼𑀡𑀁 𑀦𑁄𑀧𑀺 𑀧𑀭𑀽𑀧𑀯𑀸𑀤𑀁.

‘‘𑀯𑀸𑀤𑀜𑁆𑀳𑀺 ¶ 𑀏𑀓𑁂 𑀧𑀝𑀺𑀲𑁂𑀦𑀺𑀬𑀦𑁆𑀢𑀺, 𑀦 𑀢𑁂 𑀧𑀲𑀁𑀲𑀸𑀫 𑀧𑀭𑀺𑀢𑁆𑀢𑀧𑀜𑁆𑀜𑁂;

𑀢𑀢𑁄 𑀢𑀢𑁄 𑀦𑁂 𑀧𑀲𑀚𑀦𑁆𑀢𑀺 𑀲𑀗𑁆𑀕𑀸, 𑀘𑀺𑀢𑁆𑀢𑀜𑁆𑀳𑀺 𑀢𑁂 𑀢𑀢𑁆𑀣 𑀕𑀫𑁂𑀦𑁆𑀢𑀺 𑀤𑀽𑀭𑁂.

‘‘𑀧𑀺𑀡𑁆𑀟𑀁 𑀯𑀺𑀳𑀸𑀭𑀁 𑀲𑀬𑀦𑀸𑀲𑀦𑀜𑁆𑀘, 𑀆𑀧𑀜𑁆𑀘 𑀲𑀗𑁆𑀖𑀸𑀝𑀺𑀭𑀚𑀽𑀧𑀯𑀸𑀳𑀦𑀁;

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

‘‘𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀧𑀺𑀡𑁆𑀟𑁂 𑀲𑀬𑀦𑀸𑀲𑀦𑁂 𑀘, 𑀆𑀧𑁂 𑀘 𑀲𑀗𑁆𑀖𑀸𑀝𑀺𑀭𑀚𑀽𑀧𑀯𑀸𑀳𑀦𑁂;

𑀏𑀢𑁂𑀲𑀼 ¶ 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀅𑀦𑀽𑀧𑀮𑀺𑀢𑁆𑀢𑁄, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀬𑀣𑀸 𑀧𑁄𑀓𑁆𑀔𑀭𑁂 𑀯𑀸𑀭𑀺𑀩𑀺𑀦𑁆𑀤𑀼.

‘‘𑀕𑀳𑀝𑁆𑀞𑀯𑀢𑁆𑀢𑀁 𑀧𑀦 𑀯𑁄 𑀯𑀤𑀸𑀫𑀺, 𑀬𑀣𑀸𑀓𑀭𑁄 𑀲𑀸𑀯𑀓𑁄 𑀲𑀸𑀥𑀼 𑀳𑁄𑀢𑀺;

𑀦 𑀳𑁂𑀲 [𑀦 𑀳𑁂𑀲𑁄 (𑀲𑀻.)] 𑀮𑀩𑁆𑀪𑀸 𑀲𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑁂𑀦, 𑀨𑀲𑁆𑀲𑁂𑀢𑀼𑀁 𑀬𑁄 𑀓𑁂𑀯𑀮𑁄 𑀪𑀺𑀓𑁆𑀔𑀼𑀥𑀫𑁆𑀫𑁄.

‘‘𑀧𑀸𑀡𑀁 ¶ 𑀦 𑀳𑀦𑁂 [𑀦 𑀳𑀸𑀦𑁂 (𑀲𑀻.)] 𑀦 𑀘 𑀖𑀸𑀢𑀬𑁂𑀬𑁆𑀬, 𑀦 𑀘𑀸𑀦𑀼𑀚𑀜𑁆𑀜𑀸 𑀳𑀦𑀢𑀁 𑀧𑀭𑁂𑀲𑀁;

𑀲𑀩𑁆𑀩𑁂𑀲𑀼 ¶ 𑀪𑀽𑀢𑁂𑀲𑀼 𑀦𑀺𑀥𑀸𑀬 𑀤𑀡𑁆𑀟𑀁, 𑀬𑁂 𑀣𑀸𑀯𑀭𑀸 𑀬𑁂 𑀘 𑀢𑀲𑀸 𑀲𑀦𑁆𑀢𑀺 [𑀢𑀲𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀮𑁄𑀓𑁂.

‘‘𑀢𑀢𑁄 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑁂𑀬𑁆𑀬, 𑀓𑀺𑀜𑁆𑀘𑀺 𑀓𑁆𑀯𑀘𑀺 𑀲𑀸𑀯𑀓𑁄 𑀩𑀼𑀚𑁆𑀛𑀫𑀸𑀦𑁄;

𑀦 𑀳𑀸𑀭𑀬𑁂 𑀳𑀭𑀢𑀁 𑀦𑀸𑀦𑀼𑀚𑀜𑁆𑀜𑀸, 𑀲𑀩𑁆𑀩𑀁 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑁂𑀬𑁆𑀬.

‘‘𑀅𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑁂𑀬𑁆𑀬, 𑀅𑀗𑁆𑀕𑀸𑀭𑀓𑀸𑀲𑀼𑀁 𑀚𑀮𑀺𑀢𑀁𑀯 𑀯𑀺𑀜𑁆𑀜𑀽;

𑀅𑀲𑀫𑁆𑀪𑀼𑀡𑀦𑁆𑀢𑁄 𑀧𑀦 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, 𑀧𑀭𑀲𑁆𑀲 𑀤𑀸𑀭𑀁 𑀦 𑀅𑀢𑀺𑀓𑁆𑀓𑀫𑁂𑀬𑁆𑀬.

‘‘𑀲𑀪𑀕𑁆𑀕𑀢𑁄 𑀯𑀸 𑀧𑀭𑀺𑀲𑀕𑁆𑀕𑀢𑁄 𑀯𑀸, 𑀏𑀓𑀲𑁆𑀲 𑀯𑁂𑀓𑁄 [𑀘𑁂𑀢𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀦 𑀫𑀼𑀲𑀸 𑀪𑀡𑁂𑀬𑁆𑀬;

𑀦 𑀪𑀸𑀡𑀬𑁂 𑀪𑀡𑀢𑀁 𑀦𑀸𑀦𑀼𑀚𑀜𑁆𑀜𑀸, 𑀲𑀩𑁆𑀩𑀁 𑀅𑀪𑀽𑀢𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑁂𑀬𑁆𑀬.

‘‘𑀫𑀚𑁆𑀚𑀜𑁆𑀘 𑀧𑀸𑀦𑀁 𑀦 𑀲𑀫𑀸𑀘𑀭𑁂𑀬𑁆𑀬, 𑀥𑀫𑁆𑀫𑀁 𑀇𑀫𑀁 𑀭𑁄𑀘𑀬𑁂 𑀬𑁄 𑀕𑀳𑀝𑁆𑀞𑁄;

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

‘‘𑀫𑀤𑀸 𑀳𑀺 𑀧𑀸𑀧𑀸𑀦𑀺 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀩𑀸𑀮𑀸, 𑀓𑀸𑀭𑁂𑀦𑁆𑀢𑀺 𑀘𑀜𑁆𑀜𑁂𑀧𑀺 𑀚𑀦𑁂 𑀧𑀫𑀢𑁆𑀢𑁂;

𑀏𑀢𑀁 ¶ ¶ 𑀅𑀧𑀼𑀜𑁆𑀜𑀸𑀬𑀢𑀦𑀁 𑀯𑀺𑀯𑀚𑁆𑀚𑀬𑁂, 𑀉𑀫𑁆𑀫𑀸𑀤𑀦𑀁 𑀫𑁄𑀳𑀦𑀁 𑀩𑀸𑀮𑀓𑀦𑁆𑀢𑀁.

‘‘𑀧𑀸𑀡𑀁 ¶ 𑀦 𑀳𑀦𑁂 𑀦 𑀘𑀸𑀤𑀺𑀦𑁆𑀦𑀫𑀸𑀤𑀺𑀬𑁂, 𑀫𑀼𑀲𑀸 𑀦 𑀪𑀸𑀲𑁂 𑀦 𑀘 𑀫𑀚𑁆𑀚𑀧𑁄 𑀲𑀺𑀬𑀸;

𑀅𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀸 𑀯𑀺𑀭𑀫𑁂𑀬𑁆𑀬 𑀫𑁂𑀣𑀼𑀦𑀸, 𑀭𑀢𑁆𑀢𑀺𑀁 𑀦 𑀪𑀼𑀜𑁆𑀚𑁂𑀬𑁆𑀬 𑀯𑀺𑀓𑀸𑀮𑀪𑁄𑀚𑀦𑀁.

‘‘𑀫𑀸𑀮𑀁 ¶ 𑀦 𑀥𑀸𑀭𑁂 𑀦 𑀘 𑀕𑀦𑁆𑀥𑀫𑀸𑀘𑀭𑁂, 𑀫𑀜𑁆𑀘𑁂 𑀙𑀫𑀸𑀬𑀁 𑀯 𑀲𑀬𑁂𑀣 𑀲𑀦𑁆𑀣𑀢𑁂;

𑀏𑀢𑀜𑁆𑀳𑀺 𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑀺𑀓𑀫𑀸𑀳𑀼𑀧𑁄𑀲𑀣𑀁, 𑀩𑀼𑀤𑁆𑀥𑁂𑀦 𑀤𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑀕𑀼𑀦𑀸 𑀧𑀓𑀸𑀲𑀺𑀢𑀁.

‘‘𑀢𑀢𑁄 𑀘 𑀧𑀓𑁆𑀔𑀲𑁆𑀲𑀼𑀧𑀯𑀲𑁆𑀲𑀼𑀧𑁄𑀲𑀣𑀁, 𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀲𑀺𑀁 𑀧𑀜𑁆𑀘𑀤𑀲𑀺𑀜𑁆𑀘 𑀅𑀝𑁆𑀞𑀫𑀺𑀁;

𑀧𑀸𑀝𑀺𑀳𑀸𑀭𑀺𑀬𑀧𑀓𑁆𑀔𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀫𑀸𑀦𑀲𑁄, 𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑀼𑀧𑁂𑀢𑀁 𑀲𑀼𑀲𑀫𑀢𑁆𑀢𑀭𑀽𑀧𑀁.

‘‘𑀢𑀢𑁄 𑀘 𑀧𑀸𑀢𑁄 𑀉𑀧𑀯𑀼𑀢𑁆𑀣𑀼𑀧𑁄𑀲𑀣𑁄, 𑀅𑀦𑁆𑀦𑁂𑀦 𑀧𑀸𑀦𑁂𑀦 𑀘 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀁;

𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄 𑀅𑀦𑀼𑀫𑁄𑀤𑀫𑀸𑀦𑁄, 𑀬𑀣𑀸𑀭𑀳𑀁 𑀲𑀁𑀯𑀺𑀪𑀚𑁂𑀣 𑀯𑀺𑀜𑁆𑀜𑀽.

‘‘𑀥𑀫𑁆𑀫𑁂𑀦 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀭𑁄 𑀪𑀭𑁂𑀬𑁆𑀬, 𑀧𑀬𑁄𑀚𑀬𑁂 𑀥𑀫𑁆𑀫𑀺𑀓𑀁 𑀲𑁄 𑀯𑀡𑀺𑀚𑁆𑀚𑀁;

𑀏𑀢𑀁 ¶ 𑀕𑀺𑀳𑀻 𑀯𑀢𑁆𑀢𑀬𑀫𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄, 𑀲𑀬𑀫𑁆𑀧𑀪𑁂 𑀦𑀸𑀫 𑀉𑀧𑁂𑀢𑀺 𑀤𑁂𑀯𑁂’’𑀢𑀺.

𑀥𑀫𑁆𑀫𑀺𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀘𑀼𑀤𑁆𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀘𑀽𑀴𑀯𑀕𑁆𑀕𑁄 𑀤𑀼𑀢𑀺𑀬𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀭𑀢𑀦𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀳𑀺𑀭𑀺 𑀘, 𑀫𑀗𑁆𑀕𑀮𑀁 𑀲𑀽𑀘𑀺𑀮𑁄𑀫𑁂𑀦;

𑀥𑀫𑁆𑀫𑀘𑀭𑀺𑀬𑀜𑁆𑀘 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 [𑀓𑀧𑀺𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄𑀧𑀺 𑀘 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀦𑀸𑀯𑀸 𑀓𑀺𑀁𑀲𑀻𑀮𑀫𑀼𑀝𑁆𑀞𑀸𑀦𑀁.

𑀭𑀸𑀳𑀼𑀮𑁄 𑀧𑀼𑀦 𑀓𑀧𑁆𑀧𑁄 𑀘, 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀦𑀺𑀬𑀁 𑀢𑀣𑀸;

𑀥𑀫𑁆𑀫𑀺𑀓𑀜𑁆𑀘 𑀯𑀺𑀤𑀼𑀦𑁄 𑀆𑀳𑀼, 𑀘𑀽𑀴𑀯𑀕𑁆𑀕𑀦𑁆𑀢𑀺 𑀘𑀼𑀤𑁆𑀤𑀲𑀸𑀢𑀺.

𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁 ¶ ¶ ¶ 𑀓𑀺𑀢𑁆𑀢𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀬𑀣𑀸 𑀧𑀩𑁆𑀩𑀚𑀺 𑀘𑀓𑁆𑀔𑀼𑀫𑀸;

𑀬𑀣𑀸 𑀯𑀻𑀫𑀁𑀲𑀫𑀸𑀦𑁄 𑀲𑁄, 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁 𑀲𑀫𑀭𑁄𑀘𑀬𑀺.

𑀲𑀫𑁆𑀩𑀸𑀥𑁄𑀬𑀁 𑀖𑀭𑀸𑀯𑀸𑀲𑁄, 𑀭𑀚𑀲𑁆𑀲𑀸𑀬𑀢𑀦𑀁 𑀇𑀢𑀺;

𑀅𑀩𑁆𑀪𑁄𑀓𑀸𑀲𑁄𑀯 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀸, 𑀇𑀢𑀺 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀧𑀩𑁆𑀩𑀚𑀺.

𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁆𑀯𑀸𑀦 𑀓𑀸𑀬𑁂𑀦, 𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀯𑀺𑀯𑀚𑁆𑀚𑀬𑀺;

𑀯𑀘𑀻𑀤𑀼𑀘𑁆𑀘𑀭𑀺𑀢𑀁 ¶ 𑀳𑀺𑀢𑁆𑀯𑀸, 𑀆𑀚𑀻𑀯𑀁 𑀧𑀭𑀺𑀲𑁄𑀥𑀬𑀺.

𑀅𑀕𑀫𑀸 𑀭𑀸𑀚𑀕𑀳𑀁 𑀩𑀼𑀤𑁆𑀥𑁄, 𑀫𑀕𑀥𑀸𑀦𑀁 𑀕𑀺𑀭𑀺𑀩𑁆𑀩𑀚𑀁;

𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀅𑀪𑀺𑀳𑀸𑀭𑁂𑀲𑀺, 𑀆𑀓𑀺𑀡𑁆𑀡𑀯𑀭𑀮𑀓𑁆𑀔𑀡𑁄.

𑀢𑀫𑀤𑁆𑀤𑀲𑀸 𑀩𑀺𑀫𑁆𑀩𑀺𑀲𑀸𑀭𑁄, 𑀧𑀸𑀲𑀸𑀤𑀲𑁆𑀫𑀺𑀁 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑁄;

𑀤𑀺𑀲𑁆𑀯𑀸 𑀮𑀓𑁆𑀔𑀡𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁, 𑀇𑀫𑀫𑀢𑁆𑀣𑀁 𑀅𑀪𑀸𑀲𑀣.

‘‘𑀇𑀫𑀁 𑀪𑁄𑀦𑁆𑀢𑁄 𑀦𑀺𑀲𑀸𑀫𑁂𑀣, 𑀅𑀪𑀺𑀭𑀽𑀧𑁄 𑀩𑁆𑀭𑀳𑀸 𑀲𑀼𑀘𑀺;

𑀘𑀭𑀡𑁂𑀦 𑀘 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀬𑀼𑀕𑀫𑀢𑁆𑀢𑀜𑁆𑀘 𑀧𑁂𑀓𑁆𑀔𑀢𑀺.

‘‘𑀑𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀘𑀓𑁆𑀔𑀼 𑀲𑀢𑀺𑀫𑀸, 𑀦𑀸𑀬𑀁 𑀦𑀻𑀘𑀓𑀼𑀮𑀸𑀫𑀺𑀯;

𑀭𑀸𑀚𑀤𑀽𑀢𑀸𑀪𑀺𑀥𑀸𑀯𑀦𑁆𑀢𑀼, 𑀓𑀼𑀳𑀺𑀁 𑀪𑀺𑀓𑁆𑀔𑀼 𑀕𑀫𑀺𑀲𑁆𑀲𑀢𑀺’’.

𑀢𑁂 𑀧𑁂𑀲𑀺𑀢𑀸 𑀭𑀸𑀚𑀤𑀽𑀢𑀸, 𑀧𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀅𑀦𑀼𑀩𑀦𑁆𑀥𑀺𑀲𑀼𑀁;

𑀓𑀼𑀳𑀺𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀢𑀺 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀓𑀢𑁆𑀣 𑀯𑀸𑀲𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺.

𑀲𑀧𑀤𑀸𑀦𑀁 ¶ 𑀘𑀭𑀫𑀸𑀦𑁄, 𑀕𑀼𑀢𑁆𑀢𑀤𑁆𑀯𑀸𑀭𑁄 𑀲𑀼𑀲𑀁𑀯𑀼𑀢𑁄;

𑀔𑀺𑀧𑁆𑀧𑀁 𑀧𑀢𑁆𑀢𑀁 𑀅𑀧𑀽𑀭𑁂𑀲𑀺, 𑀲𑀫𑁆𑀧𑀚𑀸𑀦𑁄 𑀧𑀝𑀺𑀲𑁆𑀲𑀢𑁄.

𑀧𑀺𑀡𑁆𑀟𑀘𑀸𑀭𑀁 ¶ 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫 𑀦𑀕𑀭𑀸 𑀫𑀼𑀦𑀺;

𑀧𑀡𑁆𑀟𑀯𑀁 𑀅𑀪𑀺𑀳𑀸𑀭𑁂𑀲𑀺, 𑀏𑀢𑁆𑀣 𑀯𑀸𑀲𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺.

𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀯𑀸𑀲𑀽𑀧𑀕𑀢𑀁, 𑀢𑀬𑁄 [𑀢𑀢𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀤𑀽𑀢𑀸 𑀉𑀧𑀸𑀯𑀺𑀲𑀼𑀁;

𑀢𑁂𑀲𑀼 𑀏𑀓𑁄𑀯 [𑀏𑀓𑁄 𑀘 𑀤𑀽𑀢𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀆𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀭𑀸𑀚𑀺𑀦𑁄 𑀧𑀝𑀺𑀯𑁂𑀤𑀬𑀺.

‘‘𑀏𑀲 ¶ 𑀪𑀺𑀓𑁆𑀔𑀼 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀧𑀡𑁆𑀟𑀯𑀲𑁆𑀲 𑀧𑀼𑀭𑀢𑁆𑀣𑀢𑁄 [𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀩𑁆𑀬𑀕𑁆𑀖𑀼𑀲𑀪𑁄𑀯, 𑀲𑀻𑀳𑁄𑀯 𑀕𑀺𑀭𑀺𑀕𑀩𑁆𑀪𑀭𑁂’’.

𑀲𑀼𑀢𑁆𑀯𑀸𑀦 ¶ 𑀤𑀽𑀢𑀯𑀘𑀦𑀁, 𑀪𑀤𑁆𑀤𑀬𑀸𑀦𑁂𑀦 𑀔𑀢𑁆𑀢𑀺𑀬𑁄;

𑀢𑀭𑀫𑀸𑀦𑀭𑀽𑀧𑁄 𑀦𑀺𑀬𑁆𑀬𑀸𑀲𑀺, 𑀬𑁂𑀦 𑀧𑀡𑁆𑀟𑀯𑀧𑀩𑁆𑀩𑀢𑁄.

𑀲 𑀬𑀸𑀦𑀪𑀽𑀫𑀺𑀁 𑀬𑀸𑀬𑀺𑀢𑁆𑀯𑀸, 𑀬𑀸𑀦𑀸 𑀑𑀭𑀼𑀬𑁆𑀳 𑀔𑀢𑁆𑀢𑀺𑀬𑁄;

𑀧𑀢𑁆𑀢𑀺𑀓𑁄 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑁆𑀫, 𑀆𑀲𑀚𑁆𑀚 𑀦𑀁 𑀉𑀧𑀸𑀯𑀺𑀲𑀺.

𑀦𑀺𑀲𑀚𑁆𑀚 𑀭𑀸𑀚𑀸 𑀲𑀫𑁆𑀫𑁄𑀤𑀺, 𑀓𑀣𑀁 𑀲𑀸𑀭𑀡𑀻𑀬𑀁 𑀢𑀢𑁄;

𑀓𑀣𑀁 𑀲𑁄 𑀯𑀻𑀢𑀺𑀲𑀸𑀭𑁂𑀢𑁆𑀯𑀸, 𑀇𑀫𑀫𑀢𑁆𑀣𑀁 𑀅𑀪𑀸𑀲𑀣.

‘‘𑀬𑀼𑀯𑀸 𑀘 𑀤𑀳𑀭𑁄 𑀘𑀸𑀲𑀺, 𑀧𑀞𑀫𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑀺𑀓𑁄 [𑀧𑀞𑀫𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑀺𑀬𑀸 (𑀲𑀻.), 𑀧𑀞𑀫𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑀺𑀢𑁄 (𑀲𑁆𑀬𑀸.)] 𑀲𑀼𑀲𑀼;

𑀯𑀡𑁆𑀡𑀸𑀭𑁄𑀳𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀚𑀸𑀢𑀺𑀫𑀸 𑀯𑀺𑀬 𑀔𑀢𑁆𑀢𑀺𑀬𑁄.

‘‘𑀲𑁄𑀪𑀬𑀦𑁆𑀢𑁄 𑀅𑀦𑀻𑀓𑀕𑁆𑀕𑀁, 𑀦𑀸𑀕𑀲𑀗𑁆𑀖𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄;

𑀤𑀤𑀸𑀫𑀺 𑀪𑁄𑀕𑁂 𑀪𑀼𑀜𑁆𑀚𑀲𑁆𑀲𑀼, 𑀚𑀸𑀢𑀺𑀁 𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄’’.

‘‘𑀉𑀚𑀼𑀁 𑀚𑀦𑀧𑀤𑁄 𑀭𑀸𑀚, 𑀳𑀺𑀫𑀯𑀦𑁆𑀢𑀲𑁆𑀲 𑀧𑀲𑁆𑀲𑀢𑁄;

𑀥𑀦𑀯𑀻𑀭𑀺𑀬𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀓𑁄𑀲𑀮𑁂𑀲𑀼 [𑀓𑁄𑀲𑀮𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀦𑀺𑀓𑁂𑀢𑀺𑀦𑁄.

‘‘𑀆𑀤𑀺𑀘𑁆𑀘𑀸 ¶ ¶ [𑀆𑀤𑀺𑀘𑁆𑀘𑁄 (𑀓.)] 𑀦𑀸𑀫 𑀕𑁄𑀢𑁆𑀢𑁂𑀦, 𑀲𑀸𑀓𑀺𑀬𑀸 [𑀲𑀸𑀓𑀺𑀬𑁄 (𑀓.)] 𑀦𑀸𑀫 𑀚𑀸𑀢𑀺𑀬𑀸;

𑀢𑀫𑁆𑀳𑀸 𑀓𑀼𑀮𑀸 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄𑀫𑁆𑀳𑀺, 𑀦 𑀓𑀸𑀫𑁂 𑀅𑀪𑀺𑀧𑀢𑁆𑀣𑀬𑀁.

‘‘𑀓𑀸𑀫𑁂𑀲𑁆𑀯𑀸𑀤𑀻𑀦𑀯𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀦𑁂𑀓𑁆𑀔𑀫𑁆𑀫𑀁 𑀤𑀝𑁆𑀞𑀼 𑀔𑁂𑀫𑀢𑁄;

𑀧𑀥𑀸𑀦𑀸𑀬 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀏𑀢𑁆𑀣 𑀫𑁂 𑀭𑀜𑁆𑀚𑀢𑀻 𑀫𑀦𑁄’’𑀢𑀺.

𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀸𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀢𑀁 ¶ 𑀫𑀁 𑀧𑀥𑀸𑀦𑀧𑀳𑀺𑀢𑀢𑁆𑀢𑀁, 𑀦𑀤𑀺𑀁 𑀦𑁂𑀭𑀜𑁆𑀚𑀭𑀁 𑀧𑀢𑀺;

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

‘‘𑀦𑀫𑀼𑀘𑀻 𑀓𑀭𑀼𑀡𑀁 𑀯𑀸𑀘𑀁, 𑀪𑀸𑀲𑀫𑀸𑀦𑁄 𑀉𑀧𑀸𑀕𑀫𑀺;

‘𑀓𑀺𑀲𑁄 𑀢𑁆𑀯𑀫𑀲𑀺 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑁄, 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀫𑀭𑀡𑀁 𑀢𑀯.

‘‘‘𑀲𑀳𑀲𑁆𑀲𑀪𑀸𑀕𑁄 ¶ 𑀫𑀭𑀡𑀲𑁆𑀲, 𑀏𑀓𑀁𑀲𑁄 𑀢𑀯 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀚𑀻𑀯 𑀪𑁄 𑀚𑀻𑀯𑀺𑀢𑀁 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀚𑀻𑀯𑀁 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺 𑀓𑀸𑀳𑀲𑀺.

‘‘‘𑀘𑀭𑀢𑁄 ¶ 𑀘 𑀢𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, 𑀅𑀕𑁆𑀕𑀺𑀳𑀼𑀢𑁆𑀢𑀜𑁆𑀘 𑀚𑀽𑀳𑀢𑁄;

𑀧𑀳𑀽𑀢𑀁 𑀘𑀻𑀬𑀢𑁂 𑀧𑀼𑀜𑁆𑀜𑀁, 𑀓𑀺𑀁 𑀧𑀥𑀸𑀦𑁂𑀦 𑀓𑀸𑀳𑀲𑀺.

‘‘‘𑀤𑀼𑀕𑁆𑀕𑁄 𑀫𑀕𑁆𑀕𑁄 𑀧𑀥𑀸𑀦𑀸𑀬, 𑀤𑀼𑀓𑁆𑀓𑀭𑁄 𑀤𑀼𑀭𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑁄’’’;

𑀇𑀫𑀸 𑀕𑀸𑀣𑀸 𑀪𑀡𑀁 𑀫𑀸𑀭𑁄, 𑀅𑀝𑁆𑀞𑀸 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂.

𑀢𑀁 𑀢𑀣𑀸𑀯𑀸𑀤𑀺𑀦𑀁 𑀫𑀸𑀭𑀁, 𑀪𑀕𑀯𑀸 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

‘‘𑀧𑀫𑀢𑁆𑀢𑀩𑀦𑁆𑀥𑀼 𑀧𑀸𑀧𑀺𑀫, 𑀬𑁂𑀦𑀢𑁆𑀣𑁂𑀦 [𑀲𑁂𑀦𑀢𑁆𑀣𑁂𑀦 (?), 𑀅𑀢𑁆𑀢𑀦𑁄 𑀅𑀢𑁆𑀣𑁂𑀦 (𑀅𑀝𑁆𑀞. 𑀲𑀁𑀯𑀡𑁆𑀡𑀦𑀸)] 𑀇𑀥𑀸𑀕𑀢𑁄.

‘‘𑀅𑀡𑀼𑀫𑀢𑁆𑀢𑁄𑀧𑀺 ¶ [𑀅𑀡𑀼𑀫𑀢𑁆𑀢𑁂𑀦𑀧𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀧𑀼𑀜𑁆𑀜𑁂𑀦, 𑀅𑀢𑁆𑀣𑁄 𑀫𑀬𑁆𑀳𑀁 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

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

‘‘𑀅𑀢𑁆𑀣𑀺 𑀲𑀤𑁆𑀥𑀸 𑀢𑀣𑀸 [𑀢𑀢𑁄 (𑀲𑀻. 𑀧𑀻.), 𑀢𑀧𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀻𑀭𑀺𑀬𑀁, 𑀧𑀜𑁆𑀜𑀸 𑀘 𑀫𑀫 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀏𑀯𑀁 𑀫𑀁 𑀧𑀳𑀺𑀢𑀢𑁆𑀢𑀫𑁆𑀧𑀺, 𑀓𑀺𑀁 𑀚𑀻𑀯𑀫𑀦𑀼𑀧𑀼𑀘𑁆𑀙𑀲𑀺.

‘‘𑀦𑀤𑀻𑀦𑀫𑀧𑀺 𑀲𑁄𑀢𑀸𑀦𑀺, 𑀅𑀬𑀁 𑀯𑀸𑀢𑁄 𑀯𑀺𑀲𑁄𑀲𑀬𑁂;

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

‘‘𑀮𑁄𑀳𑀺𑀢𑁂 𑀲𑀼𑀲𑁆𑀲𑀫𑀸𑀦𑀫𑁆𑀳𑀺, 𑀧𑀺𑀢𑁆𑀢𑀁 𑀲𑁂𑀫𑁆𑀳𑀜𑁆𑀘 𑀲𑀼𑀲𑁆𑀲𑀢𑀺;

𑀫𑀁𑀲𑁂𑀲𑀼 𑀔𑀻𑀬𑀫𑀸𑀦𑁂𑀲𑀼, 𑀪𑀺𑀬𑁆𑀬𑁄 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀲𑀻𑀤𑀢𑀺;

𑀪𑀺𑀬𑁆𑀬𑁄 𑀲𑀢𑀺 𑀘 𑀧𑀜𑁆𑀜𑀸 𑀘, 𑀲𑀫𑀸𑀥𑀺 𑀫𑀫 𑀢𑀺𑀝𑁆𑀞𑀢𑀺.

‘‘𑀢𑀲𑁆𑀲 𑀫𑁂𑀯𑀁 𑀯𑀺𑀳𑀭𑀢𑁄, 𑀧𑀢𑁆𑀢𑀲𑁆𑀲𑀼𑀢𑁆𑀢𑀫𑀯𑁂𑀤𑀦𑀁;

𑀓𑀸𑀫𑁂𑀲𑀼 [𑀓𑀸𑀫𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀦𑀸𑀧𑁂𑀓𑁆𑀔𑀢𑁂 𑀘𑀺𑀢𑁆𑀢𑀁, 𑀧𑀲𑁆𑀲 𑀲𑀢𑁆𑀢𑀲𑁆𑀲 𑀲𑀼𑀤𑁆𑀥𑀢𑀁.

‘‘𑀓𑀸𑀫𑀸 ¶ 𑀢𑁂 𑀧𑀞𑀫𑀸 𑀲𑁂𑀦𑀸, 𑀤𑀼𑀢𑀺𑀬𑀸 𑀅𑀭𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀺;

𑀢𑀢𑀺𑀬𑀸 𑀔𑀼𑀧𑁆𑀧𑀺𑀧𑀸𑀲𑀸 𑀢𑁂, 𑀘𑀢𑀼𑀢𑁆𑀣𑀻 𑀢𑀡𑁆𑀳𑀸 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

‘‘𑀧𑀜𑁆𑀘𑀫𑀁 [𑀧𑀜𑁆𑀘𑀫𑀻 (𑀲𑀻. 𑀧𑀻.)] 𑀣𑀺𑀦𑀫𑀺𑀤𑁆𑀥𑀁 𑀢𑁂, 𑀙𑀝𑁆𑀞𑀸 𑀪𑀻𑀭𑀽 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀺;

𑀲𑀢𑁆𑀢𑀫𑀻 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀸 𑀢𑁂, 𑀫𑀓𑁆𑀔𑁄 𑀣𑀫𑁆𑀪𑁄 𑀢𑁂 𑀅𑀝𑁆𑀞𑀫𑁄.

‘‘𑀮𑀸𑀪𑁄 𑀲𑀺𑀮𑁄𑀓𑁄 𑀲𑀓𑁆𑀓𑀸𑀭𑁄, 𑀫𑀺𑀘𑁆𑀙𑀸𑀮𑀤𑁆𑀥𑁄 𑀘 𑀬𑁄 𑀬𑀲𑁄;

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

‘‘𑀏𑀲𑀸 ¶ 𑀦𑀫𑀼𑀘𑀺 𑀢𑁂 𑀲𑁂𑀦𑀸, 𑀓𑀡𑁆𑀳𑀲𑁆𑀲𑀸𑀪𑀺𑀧𑁆𑀧𑀳𑀸𑀭𑀺𑀦𑀻;

𑀦 𑀦𑀁 𑀅𑀲𑀽𑀭𑁄 𑀚𑀺𑀦𑀸𑀢𑀺, 𑀚𑁂𑀢𑁆𑀯𑀸 𑀘 𑀮𑀪𑀢𑁂 𑀲𑀼𑀔𑀁.

‘‘𑀏𑀲 𑀫𑀼𑀜𑁆𑀚𑀁 𑀧𑀭𑀺𑀳𑀭𑁂, 𑀥𑀺𑀭𑀢𑁆𑀣𑀼 𑀫𑀫 [𑀇𑀤 (𑀓.)] 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀲𑀗𑁆𑀕𑀸𑀫𑁂 𑀫𑁂 𑀫𑀢𑀁 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀬𑀁 𑀘𑁂 𑀚𑀻𑀯𑁂 𑀧𑀭𑀸𑀚𑀺𑀢𑁄.

‘‘𑀧𑀕𑀸𑀴𑁆𑀳𑁂𑀢𑁆𑀣 ¶ 𑀦 𑀤𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺, 𑀏𑀓𑁂 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸;

𑀢𑀜𑁆𑀘 𑀫𑀕𑁆𑀕𑀁 𑀦 𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀬𑁂𑀦 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀲𑀼𑀩𑁆𑀩𑀢𑀸.

‘‘𑀲𑀫𑀦𑁆𑀢𑀸 𑀥𑀚𑀺𑀦𑀺𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀬𑀼𑀢𑁆𑀢𑀁 𑀫𑀸𑀭𑀁 𑀲𑀯𑀸𑀳𑀦𑀁;

𑀬𑀼𑀤𑁆𑀥𑀸𑀬 𑀧𑀘𑁆𑀘𑀼𑀕𑁆𑀕𑀘𑁆𑀙𑀸𑀫𑀺, 𑀫𑀸 𑀫𑀁 𑀞𑀸𑀦𑀸 𑀅𑀘𑀸𑀯𑀬𑀺.

‘‘𑀬𑀁 ¶ 𑀢𑁂 𑀢𑀁 𑀦𑀧𑁆𑀧𑀲𑀳𑀢𑀺, 𑀲𑁂𑀦𑀁 𑀮𑁄𑀓𑁄 𑀲𑀤𑁂𑀯𑀓𑁄;

𑀢𑀁 ¶ 𑀢𑁂 𑀧𑀜𑁆𑀜𑀸𑀬 𑀪𑁂𑀘𑁆𑀙𑀸𑀫𑀺 [𑀕𑀘𑁆𑀙𑀸𑀫𑀺 (𑀲𑀻.), 𑀯𑁂𑀘𑁆𑀙𑀸𑀫𑀺 (𑀲𑁆𑀬𑀸.), 𑀯𑀚𑁆𑀛𑀸𑀫𑀺 (𑀓.)], 𑀆𑀫𑀁 𑀧𑀢𑁆𑀢𑀁𑀯 𑀅𑀲𑁆𑀫𑀦𑀸 [𑀧𑀓𑁆𑀓𑀁𑀯 𑀅𑀫𑀼𑀦𑀸 (𑀓.)].

‘‘𑀯𑀲𑀻𑀓𑀭𑀺𑀢𑁆𑀯𑀸 [𑀯𑀲𑀺𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸 (𑀩𑀳𑀽𑀲𑀼)] 𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑀁, 𑀲𑀢𑀺𑀜𑁆𑀘 𑀲𑀽𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀁;

𑀭𑀝𑁆𑀞𑀸 𑀭𑀝𑁆𑀞𑀁 𑀯𑀺𑀘𑀭𑀺𑀲𑁆𑀲𑀁, 𑀲𑀸𑀯𑀓𑁂 𑀯𑀺𑀦𑀬𑀁 𑀧𑀼𑀣𑀽.

‘‘𑀢𑁂 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀸 𑀧𑀳𑀺𑀢𑀢𑁆𑀢𑀸, 𑀫𑀫 𑀲𑀸𑀲𑀦𑀓𑀸𑀭𑀓𑀸;

𑀅𑀓𑀸𑀫𑀲𑁆𑀲 [𑀅𑀓𑀸𑀫𑀸 (𑀓.)] 𑀢𑁂 𑀕𑀫𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺, 𑀬𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀦 𑀲𑁄𑀘𑀭𑁂’’.

‘‘𑀲𑀢𑁆𑀢 𑀯𑀲𑁆𑀲𑀸𑀦𑀺 𑀪𑀕𑀯𑀦𑁆𑀢𑀁, 𑀅𑀦𑀼𑀩𑀦𑁆𑀥𑀺𑀁 𑀧𑀤𑀸𑀧𑀤𑀁;

𑀑𑀢𑀸𑀭𑀁 𑀦𑀸𑀥𑀺𑀕𑀘𑁆𑀙𑀺𑀲𑁆𑀲𑀁, 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀲𑀢𑀻𑀫𑀢𑁄.

‘‘𑀫𑁂𑀤𑀯𑀡𑁆𑀡𑀁𑀯 𑀧𑀸𑀲𑀸𑀡𑀁, 𑀯𑀸𑀬𑀲𑁄 𑀅𑀦𑀼𑀧𑀭𑀺𑀬𑀕𑀸;

𑀅𑀧𑁂𑀢𑁆𑀣 𑀫𑀼𑀤𑀼𑀁 [𑀫𑀼𑀤𑀼 (𑀲𑀻.)] 𑀯𑀺𑀦𑁆𑀤𑁂𑀫, 𑀅𑀧𑀺 𑀅𑀲𑁆𑀲𑀸𑀤𑀦𑀸 𑀲𑀺𑀬𑀸.

‘‘𑀅𑀮𑀤𑁆𑀥𑀸 𑀢𑀢𑁆𑀣 𑀅𑀲𑁆𑀲𑀸𑀤𑀁, 𑀯𑀸𑀬𑀲𑁂𑀢𑁆𑀢𑁄 𑀅𑀧𑀓𑁆𑀓𑀫𑀺;

𑀓𑀸𑀓𑁄𑀯 𑀲𑁂𑀮𑀫𑀸𑀲𑀚𑁆𑀚, 𑀦𑀺𑀩𑁆𑀩𑀺𑀚𑁆𑀚𑀸𑀧𑁂𑀫 𑀕𑁄𑀢𑀫𑀁’’.

𑀢𑀲𑁆𑀲 ¶ 𑀲𑁄𑀓𑀧𑀭𑁂𑀢𑀲𑁆𑀲, 𑀯𑀻𑀡𑀸 𑀓𑀘𑁆𑀙𑀸 𑀅𑀪𑀲𑁆𑀲𑀣;

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

𑀧𑀥𑀸𑀦𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑀼𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀚𑁂𑀢𑀯𑀦𑁂 𑀅𑀦𑀸𑀣𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑀲𑁆𑀲 𑀆𑀭𑀸𑀫𑁂. 𑀢𑀢𑁆𑀭 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀪𑀺𑀓𑁆𑀔𑀽 ¶ 𑀆𑀫𑀦𑁆𑀢𑁂𑀲𑀺 𑁋 ‘‘𑀪𑀺𑀓𑁆𑀔𑀯𑁄’’𑀢𑀺. ‘‘𑀪𑀤𑀦𑁆𑀢𑁂’’𑀢𑀺 𑀢𑁂 𑀪𑀺𑀓𑁆𑀔𑀽 𑀪𑀕𑀯𑀢𑁄 𑀧𑀘𑁆𑀘𑀲𑁆𑀲𑁄𑀲𑀼𑀁. 𑀪𑀕𑀯𑀸 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋

‘‘𑀘𑀢𑀽𑀳𑀺, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀅𑀗𑁆𑀕𑁂𑀳𑀺 𑀲𑀫𑀦𑁆𑀦𑀸𑀕𑀢𑀸 𑀯𑀸𑀘𑀸 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸 𑀳𑁄𑀢𑀺, 𑀦 𑀤𑀼𑀩𑁆𑀪𑀸𑀲𑀺𑀢𑀸, 𑀅𑀦𑀯𑀚𑁆𑀚𑀸 𑀘 𑀅𑀦𑀦𑀼𑀯𑀚𑁆𑀚𑀸 𑀘 𑀯𑀺𑀜𑁆𑀜𑀽𑀦𑀁. 𑀓𑀢𑀫𑁂𑀳𑀺 𑀘𑀢𑀽𑀳𑀺? 𑀇𑀥, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁𑀬𑁂𑀯 𑀪𑀸𑀲𑀢𑀺 𑀦𑁄 𑀤𑀼𑀩𑁆𑀪𑀸𑀲𑀺𑀢𑀁, 𑀥𑀫𑁆𑀫𑀁𑀬𑁂𑀯 𑀪𑀸𑀲𑀢𑀺 𑀦𑁄 𑀅𑀥𑀫𑁆𑀫𑀁, 𑀧𑀺𑀬𑀁𑀬𑁂𑀯 𑀪𑀸𑀲𑀢𑀺 𑀦𑁄 𑀅𑀧𑁆𑀧𑀺𑀬𑀁, 𑀲𑀘𑁆𑀘𑀁𑀬𑁂𑀯 𑀪𑀸𑀲𑀢𑀺 𑀦𑁄 𑀅𑀮𑀺𑀓𑀁. 𑀇𑀫𑁂𑀳𑀺 𑀔𑁄, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀘𑀢𑀽𑀳𑀺 𑀅𑀗𑁆𑀕𑁂𑀳𑀺 𑀲𑀫𑀦𑁆𑀦𑀸𑀕𑀢𑀸 𑀯𑀸𑀘𑀸 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸 𑀳𑁄𑀢𑀺, 𑀦𑁄 𑀤𑀼𑀩𑁆𑀪𑀸𑀲𑀺𑀢𑀸, 𑀅𑀦𑀯𑀚𑁆𑀚𑀸 𑀘 𑀅𑀦𑀦𑀼𑀯𑀚𑁆𑀚𑀸 𑀘 𑀯𑀺𑀜𑁆𑀜𑀽𑀦’’𑀦𑁆𑀢𑀺. 𑀇𑀤𑀫𑀯𑁄𑀘 𑀪𑀕𑀯𑀸. 𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀲𑀼𑀕𑀢𑁄 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 𑀉𑀢𑁆𑀢𑀫𑀫𑀸𑀳𑀼 𑀲𑀦𑁆𑀢𑁄, 𑀥𑀫𑁆𑀫𑀁 𑀪𑀡𑁂 𑀦𑀸𑀥𑀫𑁆𑀫𑀁 𑀢𑀁 𑀤𑀼𑀢𑀺𑀬𑀁;

𑀧𑀺𑀬𑀁 𑀪𑀡𑁂 𑀦𑀸𑀧𑁆𑀧𑀺𑀬𑀁 𑀢𑀁 𑀢𑀢𑀺𑀬𑀁, 𑀲𑀘𑁆𑀘𑀁 𑀪𑀡𑁂 𑀦𑀸𑀮𑀺𑀓𑀁 𑀢𑀁 𑀘𑀢𑀼𑀢𑁆𑀣’’𑀦𑁆𑀢𑀺.

𑀅𑀣 ¶ 𑀔𑁄 𑀆𑀬𑀲𑁆𑀫𑀸 𑀯𑀗𑁆𑀕𑀻𑀲𑁄 𑀉𑀝𑁆𑀞𑀸𑀬𑀸𑀲𑀦𑀸 𑀏𑀓𑀁𑀲𑀁 𑀘𑀻𑀯𑀭𑀁 𑀓𑀢𑁆𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀜𑁆𑀚𑀮𑀺𑀁 𑀧𑀡𑀸𑀫𑁂𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀧𑀝𑀺𑀪𑀸𑀢𑀺 𑀫𑀁 𑀪𑀕𑀯𑀸, 𑀧𑀝𑀺𑀪𑀸𑀢𑀺 𑀫𑀁 𑀲𑀼𑀕𑀢𑀸’’𑀢𑀺. ‘‘𑀧𑀝𑀺𑀪𑀸𑀢𑀼 𑀢𑀁 𑀯𑀗𑁆𑀕𑀻𑀲𑀸’’𑀢𑀺 𑀪𑀕𑀯𑀸 𑀅𑀯𑁄𑀘. 𑀅𑀣 𑀔𑁄 𑀆𑀬𑀲𑁆𑀫𑀸 𑀯𑀗𑁆𑀕𑀻𑀲𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀲𑀫𑁆𑀫𑀼𑀔𑀸 𑀲𑀸𑀭𑀼𑀧𑁆𑀧𑀸𑀳𑀺 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀪𑀺𑀢𑁆𑀣𑀯𑀺 𑁋

‘‘𑀢𑀫𑁂𑀯 𑀯𑀸𑀘𑀁 𑀪𑀸𑀲𑁂𑀬𑁆𑀬, 𑀬𑀸𑀬𑀢𑁆𑀢𑀸𑀦𑀁 𑀦 𑀢𑀸𑀧𑀬𑁂;

𑀧𑀭𑁂 ¶ 𑀘 𑀦 𑀯𑀺𑀳𑀺𑀁𑀲𑁂𑀬𑁆𑀬, 𑀲𑀸 𑀯𑁂 𑀯𑀸𑀘𑀸 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸.

‘‘𑀧𑀺𑀬𑀯𑀸𑀘𑀫𑁂𑀯 𑀪𑀸𑀲𑁂𑀬𑁆𑀬, 𑀬𑀸 𑀯𑀸𑀘𑀸 𑀧𑀝𑀺𑀦𑀦𑁆𑀤𑀺𑀢𑀸;

𑀬𑀁 𑀅𑀦𑀸𑀤𑀸𑀬 𑀧𑀸𑀧𑀸𑀦𑀺, 𑀧𑀭𑁂𑀲𑀁 𑀪𑀸𑀲𑀢𑁂 𑀧𑀺𑀬𑀁.

‘‘𑀲𑀘𑁆𑀘𑀁 𑀯𑁂 𑀅𑀫𑀢𑀸 𑀯𑀸𑀘𑀸, 𑀏𑀲 𑀥𑀫𑁆𑀫𑁄 𑀲𑀦𑀦𑁆𑀢𑀦𑁄;

𑀲𑀘𑁆𑀘𑁂 𑀅𑀢𑁆𑀣𑁂 𑀘 𑀥𑀫𑁆𑀫𑁂 𑀘, 𑀆𑀳𑀼 𑀲𑀦𑁆𑀢𑁄 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀬𑀁 ¶ ¶ 𑀩𑀼𑀤𑁆𑀥𑁄 𑀪𑀸𑀲𑀢𑀺 𑀯𑀸𑀘𑀁, 𑀔𑁂𑀫𑀁 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀧𑀢𑁆𑀢𑀺𑀬𑀸;

𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲𑀦𑁆𑀢𑀓𑀺𑀭𑀺𑀬𑀸𑀬, 𑀲𑀸 𑀯𑁂 𑀯𑀸𑀘𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑀸’’𑀢𑀺.

𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀲𑀼𑀢𑁆𑀢𑀁 𑀢𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁪. 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑀼𑀢𑁆𑀢𑀁

𑀏𑀯𑀁 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀓𑁄𑀲𑀮𑁂𑀲𑀼 𑀯𑀺𑀳𑀭𑀢𑀺 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀸𑀬 𑀦𑀤𑀺𑀬𑀸 𑀢𑀻𑀭𑁂. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀸𑀬 𑀦𑀤𑀺𑀬𑀸 𑀢𑀻𑀭𑁂 𑀅𑀕𑁆𑀕𑀺𑀁 𑀚𑀼𑀳𑀢𑀺, 𑀅𑀕𑁆𑀕𑀺𑀳𑀼𑀢𑁆𑀢𑀁 𑀧𑀭𑀺𑀘𑀭𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀅𑀕𑁆𑀕𑀺𑀁 𑀚𑀼𑀳𑀺𑀢𑁆𑀯𑀸 𑀅𑀕𑁆𑀕𑀺𑀳𑀼𑀢𑁆𑀢𑀁 𑀧𑀭𑀺𑀘𑀭𑀺𑀢𑁆𑀯𑀸 𑀉𑀝𑁆𑀞𑀸𑀬𑀸𑀲𑀦𑀸 𑀲𑀫𑀦𑁆𑀢𑀸 𑀘𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑀸 𑀅𑀦𑀼𑀯𑀺𑀮𑁄𑀓𑁂𑀲𑀺 𑁋 ‘‘𑀓𑁄 𑀦𑀼 𑀔𑁄 𑀇𑀫𑀁 𑀳𑀩𑁆𑀬𑀲𑁂𑀲𑀁 𑀪𑀼𑀜𑁆𑀚𑁂𑀬𑁆𑀬𑀸’’𑀢𑀺? 𑀅𑀤𑁆𑀤𑀲𑀸 𑀔𑁄 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 ¶ 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀅𑀯𑀺𑀤𑀽𑀭𑁂 𑀅𑀜𑁆𑀜𑀢𑀭𑀲𑁆𑀫𑀺𑀁 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑁂 𑀲𑀲𑀻𑀲𑀁 𑀧𑀸𑀭𑀼𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁; 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀯𑀸𑀫𑁂𑀦 𑀳𑀢𑁆𑀣𑁂𑀦 𑀳𑀩𑁆𑀬𑀲𑁂𑀲𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀦 𑀳𑀢𑁆𑀣𑁂𑀦 𑀓𑀫𑀡𑁆𑀟𑀮𑀼𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺.

𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀧𑀤𑀲𑀤𑁆𑀤𑁂𑀦 𑀲𑀻𑀲𑀁 ¶ 𑀯𑀺𑀯𑀭𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑁋 ‘‘𑀫𑀼𑀡𑁆𑀟𑁄 𑀅𑀬𑀁 𑀪𑀯𑀁, 𑀫𑀼𑀡𑁆𑀟𑀓𑁄 𑀅𑀬𑀁 𑀪𑀯’’𑀦𑁆𑀢𑀺 𑀢𑀢𑁄𑀯 𑀧𑀼𑀦 𑀦𑀺𑀯𑀢𑁆𑀢𑀺𑀢𑀼𑀓𑀸𑀫𑁄 𑀅𑀳𑁄𑀲𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀫𑀼𑀡𑁆𑀟𑀸𑀧𑀺 𑀳𑀺 𑀇𑀥𑁂𑀓𑀘𑁆𑀘𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀬𑀁𑀦𑀽𑀦𑀸𑀳𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀚𑀸𑀢𑀺𑀁 𑀧𑀼𑀘𑁆𑀙𑁂𑀬𑁆𑀬’’𑀦𑁆𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀓𑀺𑀁𑀚𑀘𑁆𑀘𑁄 𑀪𑀯’’𑀦𑁆𑀢𑀺?

𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀦𑁄𑀫𑁆𑀳𑀺 𑀦 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑁄, 𑀦 𑀯𑁂𑀲𑁆𑀲𑀸𑀬𑀦𑁄 𑀉𑀤 𑀓𑁄𑀘𑀺 𑀦𑁄𑀫𑁆𑀳𑀺;

𑀕𑁄𑀢𑁆𑀢𑀁 𑀧𑀭𑀺𑀜𑁆𑀜𑀸𑀬 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀦𑀸𑀦𑀁, 𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑁄 𑀫𑀦𑁆𑀢 𑀘𑀭𑀸𑀫𑀺 𑀮𑁄𑀓𑁂.

‘‘𑀲𑀗𑁆𑀖𑀸𑀝𑀺𑀯𑀸𑀲𑀻 ¶ ¶ 𑀅𑀕𑀳𑁄 𑀘𑀭𑀸𑀫𑀺 [𑀅𑀕𑀺𑀳𑁄 (𑀓. 𑀲𑀻. 𑀧𑀻.) 𑀅𑀕𑁂𑀳𑁄 (𑀓𑀢𑁆𑀣𑀘𑀺)], 𑀦𑀺𑀯𑀼𑀢𑁆𑀢𑀓𑁂𑀲𑁄 𑀅𑀪𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀢𑁆𑀢𑁄;

𑀅𑀮𑀺𑀧𑁆𑀧𑀫𑀸𑀦𑁄 𑀇𑀥 𑀫𑀸𑀡𑀯𑁂𑀳𑀺, 𑀅𑀓𑀮𑁆𑀮𑀁 𑀫𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀧𑀼𑀘𑁆𑀙𑀲𑀺 𑀕𑁄𑀢𑁆𑀢𑀧𑀜𑁆𑀳𑀁’’.

‘‘𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀺 ¶ 𑀯𑁂 𑀪𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀪𑀺 𑀲𑀳 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀦𑁄 𑀪𑀯’’𑀦𑁆𑀢𑀺.

‘‘𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑀺 𑀘𑁂 𑀢𑁆𑀯𑀁 𑀩𑁆𑀭𑀽𑀲𑀺, 𑀫𑀜𑁆𑀘 𑀩𑁆𑀭𑀽𑀲𑀺 𑀅𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁;

𑀢𑀁 𑀢𑀁 𑀲𑀸𑀯𑀺𑀢𑁆𑀢𑀺𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺, 𑀢𑀺𑀧𑀤𑀁 𑀘𑀢𑀼𑀯𑀻𑀲𑀢𑀓𑁆𑀔𑀭𑀁.

‘‘𑀓𑀺𑀁 ¶ 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸 𑀇𑀲𑀬𑁄 𑀫𑀦𑀼𑀚𑀸, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 [𑀧𑀞𑀫𑀧𑀸𑀤𑀦𑁆𑀢𑁄] 𑀤𑁂𑀯𑀢𑀸𑀦𑀁;

𑀬𑀜𑁆𑀜𑀫𑀓𑀧𑁆𑀧𑀬𑀺𑀁𑀲𑀼 𑀧𑀼𑀣𑀽 𑀇𑀥 𑀮𑁄𑀓𑁂 [𑀤𑀼𑀢𑀺𑀬𑀧𑀸𑀤𑀦𑁆𑀢𑁄 (𑀲𑀻.)].

‘‘𑀬𑀤𑀦𑁆𑀢𑀕𑀽 𑀯𑁂𑀤𑀕𑀽 𑀬𑀜𑁆𑀜𑀓𑀸𑀮𑁂, 𑀬𑀲𑁆𑀲𑀸𑀳𑀼𑀢𑀺𑀁 𑀮𑀪𑁂 𑀢𑀲𑁆𑀲𑀺𑀚𑁆𑀛𑁂𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀺’’.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀳𑀺 𑀢𑀲𑁆𑀲 𑀳𑀼𑀢𑀫𑀺𑀚𑁆𑀛𑁂, (𑀇𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄)

𑀬𑀁 𑀢𑀸𑀤𑀺𑀲𑀁 𑀯𑁂𑀤𑀕𑀼𑀫𑀤𑁆𑀤𑀲𑀸𑀫;

𑀢𑀼𑀫𑁆𑀳𑀸𑀤𑀺𑀲𑀸𑀦𑀜𑁆𑀳𑀺 𑀅𑀤𑀲𑁆𑀲𑀦𑁂𑀦, 𑀅𑀜𑁆𑀜𑁄 𑀚𑀦𑁄 𑀪𑀼𑀜𑁆𑀚𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁’’.

‘‘𑀢𑀲𑁆𑀫𑀸𑀢𑀺𑀳 𑀢𑁆𑀯𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀅𑀢𑁆𑀣𑁂𑀦, 𑀅𑀢𑁆𑀣𑀺𑀓𑁄 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑁆𑀫 𑀧𑀼𑀘𑁆𑀙;

𑀲𑀦𑁆𑀢𑀁 𑀯𑀺𑀥𑀽𑀫𑀁 𑀅𑀦𑀻𑀖𑀁 𑀦𑀺𑀭𑀸𑀲𑀁, 𑀅𑀧𑁆𑀧𑁂𑀯𑀺𑀥 𑀅𑀪𑀺𑀯𑀺𑀦𑁆𑀤𑁂 𑀲𑀼𑀫𑁂𑀥𑀁’’.

‘‘𑀬𑀜𑁆𑀜𑁂 𑀭𑀢𑁄𑀳𑀁 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀬𑀜𑁆𑀜𑀁 𑀬𑀺𑀝𑁆𑀞𑀼𑀓𑀸𑀫𑁄 𑀦𑀸𑀳𑀁 𑀧𑀚𑀸𑀦𑀸𑀫𑀺;

𑀅𑀦𑀼𑀲𑀸𑀲𑀢𑀼 𑀫𑀁 𑀪𑀯𑀁, 𑀬𑀢𑁆𑀣 ¶ 𑀳𑀼𑀢𑀁 𑀇𑀚𑁆𑀛𑀢𑁂 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀢𑀁’’.

‘‘𑀢𑁂𑀦 𑀳𑀺 𑀢𑁆𑀯𑀁, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡, 𑀑𑀤𑀳𑀲𑁆𑀲𑀼 𑀲𑁄𑀢𑀁; 𑀥𑀫𑁆𑀫𑀁 𑀢𑁂 𑀤𑁂𑀲𑁂𑀲𑁆𑀲𑀸𑀫𑀺 𑁋

‘‘𑀫𑀸 ¶ 𑀚𑀸𑀢𑀺𑀁 𑀧𑀼𑀘𑁆𑀙𑀻 𑀘𑀭𑀡𑀜𑁆𑀘 𑀧𑀼𑀘𑁆𑀙, 𑀓𑀝𑁆𑀞𑀸 𑀳𑀯𑁂 𑀚𑀸𑀬𑀢𑀺 𑀚𑀸𑀢𑀯𑁂𑀤𑁄;

𑀦𑀻𑀘𑀸𑀓𑀼𑀮𑀻𑀦𑁄𑀧𑀺 ¶ 𑀫𑀼𑀦𑀻 𑀥𑀺𑀢𑀻𑀫𑀸, 𑀆𑀚𑀸𑀦𑀺𑀬𑁄 𑀳𑁄𑀢𑀺 𑀳𑀺𑀭𑀻𑀦𑀺𑀲𑁂𑀥𑁄.

‘‘𑀲𑀘𑁆𑀘𑁂𑀦 𑀤𑀦𑁆𑀢𑁄 𑀤𑀫𑀲𑀸 𑀉𑀧𑁂𑀢𑁄, 𑀯𑁂𑀤𑀦𑁆𑀢𑀕𑀽 𑀯𑀽𑀲𑀺𑀢𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑁄;

𑀓𑀸𑀮𑁂𑀦 𑀢𑀫𑁆𑀳𑀺 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 [𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀔𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂 ¶ 𑀓𑀸𑀫𑁂 𑀳𑀺𑀢𑁆𑀯𑀸 𑀅𑀕𑀳𑀸 𑀘𑀭𑀦𑁆𑀢𑀺, 𑀲𑀼𑀲𑀜𑁆𑀜𑀢𑀢𑁆𑀢𑀸 𑀢𑀲𑀭𑀁𑀯 𑀉𑀚𑁆𑀚𑀼𑀁;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

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

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀅𑀲𑀚𑁆𑀚𑀫𑀸𑀦𑀸 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂, 𑀲𑀤𑀸 𑀲𑀢𑀸 𑀳𑀺𑀢𑁆𑀯𑀸 𑀫𑀫𑀸𑀬𑀺𑀢𑀸𑀦𑀺;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁄 𑀓𑀸𑀫𑁂 𑀳𑀺𑀢𑁆𑀯𑀸 𑀅𑀪𑀺𑀪𑀼𑀬𑁆𑀬𑀘𑀸𑀭𑀻, 𑀬𑁄 𑀯𑁂𑀤𑀺 𑀚𑀸𑀢𑀻𑀫𑀭𑀡𑀲𑁆𑀲 𑀅𑀦𑁆𑀢𑀁;

𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 ¶ 𑀉𑀤𑀓𑀭𑀳𑀤𑁄𑀯 𑀲𑀻𑀢𑁄, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀲𑀫𑁄 ¶ 𑀲𑀫𑁂𑀳𑀺 𑀯𑀺𑀲𑀫𑁂𑀳𑀺 𑀤𑀽𑀭𑁂, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀳𑁄𑀢𑀺 𑀅𑀦𑀦𑁆𑀢𑀧𑀜𑁆𑀜𑁄;

𑀅𑀦𑀽𑀧𑀮𑀺𑀢𑁆𑀢𑁄 𑀇𑀥 𑀯𑀸 𑀳𑀼𑀭𑀁 𑀯𑀸, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀬𑀫𑁆𑀳𑀺 ¶ 𑀦 𑀫𑀸𑀬𑀸 𑀯𑀲𑀢𑀺 𑀦 𑀫𑀸𑀦𑁄, 𑀬𑁄 𑀯𑀻𑀢𑀮𑁄𑀪𑁄 𑀅𑀫𑀫𑁄 𑀦𑀺𑀭𑀸𑀲𑁄;

𑀧𑀦𑀼𑀡𑁆𑀡𑀓𑁄𑀥𑁄 𑀅𑀪𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀢𑁆𑀢𑁄, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀲𑁄𑀓𑀫𑀮𑀁 𑀅𑀳𑀸𑀲𑀺;

‘‘𑀦𑀺𑀯𑁂𑀲𑀦𑀁 𑀬𑁄 𑀫𑀦𑀲𑁄 𑀅𑀳𑀸𑀲𑀺, 𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑀸 𑀬𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀓𑁂𑀘𑀺;

𑀅𑀦𑀼𑀧𑀸𑀤𑀺𑀬𑀸𑀦𑁄 𑀇𑀥 𑀯𑀸 𑀳𑀼𑀭𑀁 𑀯𑀸, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀲𑀫𑀸𑀳𑀺𑀢𑁄 𑀬𑁄 𑀉𑀤𑀢𑀸𑀭𑀺 𑀑𑀖𑀁, 𑀥𑀫𑁆𑀫𑀁 𑀘𑀜𑁆𑀜𑀸𑀲𑀺 𑀧𑀭𑀫𑀸𑀬 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸;

𑀔𑀻𑀡𑀸𑀲𑀯𑁄 𑀅𑀦𑁆𑀢𑀺𑀫𑀤𑁂𑀳𑀥𑀸𑀭𑀻, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀪𑀯𑀸𑀲𑀯𑀸 𑀬𑀲𑁆𑀲 𑀯𑀘𑀻 𑀔𑀭𑀸 𑀘, 𑀯𑀺𑀥𑀽𑀧𑀺𑀢𑀸 𑀅𑀢𑁆𑀣𑀕𑀢𑀸 𑀦 𑀲𑀦𑁆𑀢𑀺;

𑀲 𑀯𑁂𑀤𑀕𑀽 𑀲𑀩𑁆𑀩𑀥𑀺 𑀯𑀺𑀧𑁆𑀧𑀫𑀼𑀢𑁆𑀢𑁄, 𑀢𑀣𑀸𑀕𑀢𑁄 ¶ 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀲𑀗𑁆𑀕𑀸𑀢𑀺𑀕𑁄 𑀬𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀲𑀗𑁆𑀕𑀸, 𑀬𑁄 𑀫𑀸𑀦𑀲𑀢𑁆𑀢𑁂𑀲𑀼 𑀅𑀫𑀸𑀦𑀲𑀢𑁆𑀢𑁄;

𑀤𑀼𑀓𑁆𑀔𑀁 ¶ 𑀧𑀭𑀺𑀜𑁆𑀜𑀸𑀬 𑀲𑀔𑁂𑀢𑁆𑀢𑀯𑀢𑁆𑀣𑀼𑀁, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀆𑀲𑀁 ¶ 𑀅𑀦𑀺𑀲𑁆𑀲𑀸𑀬 𑀯𑀺𑀯𑁂𑀓𑀤𑀲𑁆𑀲𑀻, 𑀧𑀭𑀯𑁂𑀤𑀺𑀬𑀁 𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑀼𑀧𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑁄;

𑀆𑀭𑀫𑁆𑀫𑀡𑀸 𑀬𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀓𑁂𑀘𑀺, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀧𑀭𑁄𑀧𑀭𑀸 [𑀧𑀭𑁄𑀯𑀭𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀬𑀲𑁆𑀲 𑀲𑀫𑁂𑀘𑁆𑀘 𑀥𑀫𑁆𑀫𑀸, 𑀯𑀺𑀥𑀽𑀧𑀺𑀢𑀸 𑀅𑀢𑁆𑀣𑀕𑀢𑀸 𑀦 𑀲𑀦𑁆𑀢𑀺;

𑀲𑀦𑁆𑀢𑁄 𑀉𑀧𑀸𑀤𑀸𑀦𑀔𑀬𑁂 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀲𑀁𑀬𑁄𑀚𑀦𑀁 ¶ 𑀚𑀸𑀢𑀺𑀔𑀬𑀦𑁆𑀢𑀤𑀲𑁆𑀲𑀻, 𑀬𑁄𑀧𑀸𑀦𑀼𑀤𑀺 𑀭𑀸𑀕𑀧𑀣𑀁 𑀅𑀲𑁂𑀲𑀁;

𑀲𑀼𑀤𑁆𑀥𑁄 𑀦𑀺𑀤𑁄𑀲𑁄 𑀯𑀺𑀫𑀮𑁄 𑀅𑀓𑀸𑀘𑁄 [𑀅𑀓𑀸𑀫𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀢𑀣𑀸𑀕𑀢𑁄 ¶ 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀬𑁄 𑀅𑀢𑁆𑀢𑀦𑁄 𑀅𑀢𑁆𑀢𑀸𑀦𑀁 [𑀅𑀢𑁆𑀢𑀦𑀸𑀢𑁆𑀢𑀸𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀦𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀢𑀺, 𑀲𑀫𑀸𑀳𑀺𑀢𑁄 𑀉𑀚𑁆𑀚𑀼𑀕𑀢𑁄 𑀞𑀺𑀢𑀢𑁆𑀢𑁄;

𑀲 𑀯𑁂 𑀅𑀦𑁂𑀚𑁄 𑀅𑀔𑀺𑀮𑁄 𑀅𑀓𑀗𑁆𑀔𑁄, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁.

‘‘𑀫𑁄𑀳𑀦𑁆𑀢𑀭𑀸 𑀬𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀓𑁂𑀘𑀺, 𑀲𑀩𑁆𑀩𑁂𑀲𑀼 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀘 𑀜𑀸𑀡𑀤𑀲𑁆𑀲𑀻;

𑀲𑀭𑀻𑀭𑀜𑁆𑀘 𑀅𑀦𑁆𑀢𑀺𑀫𑀁 𑀥𑀸𑀭𑁂𑀢𑀺, 𑀧𑀢𑁆𑀢𑁄 𑀘 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀫𑀦𑀼𑀢𑁆𑀢𑀭𑀁 𑀲𑀺𑀯𑀁;

𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀸 𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀼𑀤𑁆𑀥𑀺, 𑀢𑀣𑀸𑀕𑀢𑁄 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁’’.

‘‘𑀳𑀼𑀢𑀜𑁆𑀘 ¶ [𑀳𑀼𑀢𑁆𑀢𑀜𑁆𑀘 (𑀲𑀻. 𑀓.)] 𑀫𑀬𑁆𑀳𑀁 𑀳𑀼𑀢𑀫𑀢𑁆𑀣𑀼 𑀲𑀘𑁆𑀘𑀁, 𑀬𑀁 𑀢𑀸𑀤𑀺𑀲𑀁 𑀯𑁂𑀤𑀕𑀼𑀦𑀁 𑀅𑀮𑀢𑁆𑀣𑀁;

𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀳𑀺 𑀲𑀓𑁆𑀔𑀺 𑀧𑀝𑀺𑀕𑀡𑁆𑀳𑀸𑀢𑀼 𑀫𑁂 𑀪𑀕𑀯𑀸, 𑀪𑀼𑀜𑁆𑀚𑀢𑀼 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀧𑀽𑀭𑀴𑀸𑀲𑀁’’.

‘‘𑀅𑀜𑁆𑀜𑁂𑀦 𑀘 𑀓𑁂𑀯𑀮𑀺𑀦𑀁 𑀫𑀳𑁂𑀲𑀺𑀁, 𑀔𑀻𑀡𑀸𑀲𑀯𑀁 𑀓𑀼𑀓𑁆𑀓𑀼𑀘𑁆𑀘𑀯𑀽𑀧𑀲𑀦𑁆𑀢𑀁;

𑀅𑀦𑁆𑀦𑁂𑀦 𑀧𑀸𑀦𑁂𑀦 𑀉𑀧𑀝𑁆𑀞𑀳𑀲𑁆𑀲𑀼, 𑀔𑁂𑀢𑁆𑀢𑀜𑁆𑀳𑀺 𑀢𑀁 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑀲𑁆𑀲 𑀳𑁄𑀢𑀺’’.

‘‘𑀲𑀸𑀥𑀸𑀳𑀁 ¶ ¶ 𑀪𑀕𑀯𑀸 𑀢𑀣𑀸 𑀯𑀺𑀚𑀜𑁆𑀜𑀁, 𑀬𑁄 𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀪𑀼𑀜𑁆𑀚𑁂𑀬𑁆𑀬 𑀫𑀸𑀤𑀺𑀲𑀲𑁆𑀲;

𑀬𑀁 𑀬𑀜𑁆𑀜𑀓𑀸𑀮𑁂 𑀧𑀭𑀺𑀬𑁂𑀲𑀫𑀸𑀦𑁄, 𑀧𑀧𑁆𑀧𑀼𑀬𑁆𑀬 𑀢𑀯 𑀲𑀸𑀲𑀦𑀁’’.

‘‘𑀲𑀸𑀭𑀫𑁆𑀪𑀸 𑀬𑀲𑁆𑀲 𑀯𑀺𑀕𑀢𑀸, 𑀘𑀺𑀢𑁆𑀢𑀁 𑀬𑀲𑁆𑀲 𑀅𑀦𑀸𑀯𑀺𑀮𑀁;

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

‘‘𑀲𑀻𑀫𑀦𑁆𑀢𑀸𑀦𑀁 ¶ 𑀯𑀺𑀦𑁂𑀢𑀸𑀭𑀁, 𑀚𑀸𑀢𑀺𑀫𑀭𑀡𑀓𑁄𑀯𑀺𑀤𑀁;

𑀫𑀼𑀦𑀺𑀁 𑀫𑁄𑀦𑁂𑀬𑁆𑀬𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁, 𑀢𑀸𑀤𑀺𑀲𑀁 𑀬𑀜𑁆𑀜𑀫𑀸𑀕𑀢𑀁.

‘‘𑀪𑀓𑀼𑀝𑀺𑀁 [𑀪𑀽𑀓𑀼𑀝𑀺𑀁 (𑀓. 𑀲𑀻.), 𑀪𑀸𑀓𑀼𑀝𑀺𑀁 (𑀓. 𑀲𑀻., 𑀫. 𑀦𑀺. 𑁧.𑁨𑁨𑁬)] 𑀯𑀺𑀦𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀦𑀫𑀲𑁆𑀲𑀣;

𑀧𑀽𑀚𑁂𑀣 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑁂𑀦, 𑀏𑀯𑀁 𑀇𑀚𑁆𑀛𑀦𑁆𑀢𑀺 𑀤𑀓𑁆𑀔𑀺𑀡𑀸.

‘‘𑀩𑀼𑀤𑁆𑀥𑁄 ¶ 𑀪𑀯𑀁 𑀅𑀭𑀳𑀢𑀺 𑀧𑀽𑀭𑀴𑀸𑀲𑀁, 𑀧𑀼𑀜𑁆𑀜𑀔𑁂𑀢𑁆𑀢𑀫𑀦𑀼𑀢𑁆𑀢𑀭𑀁;

𑀆𑀬𑀸𑀕𑁄 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀲𑁆𑀲, 𑀪𑁄𑀢𑁄 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮’’𑀦𑁆𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫! 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀦𑀺𑀓𑁆𑀓𑀼𑀚𑁆𑀚𑀺𑀢𑀁 𑀯𑀸 𑀉𑀓𑁆𑀓𑀼𑀚𑁆𑀚𑁂𑀬𑁆𑀬, 𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑀁 𑀯𑀸 𑀯𑀺𑀯𑀭𑁂𑀬𑁆𑀬, 𑀫𑀽𑀴𑁆𑀳𑀲𑁆𑀲 𑀯𑀸 𑀫𑀕𑁆𑀕𑀁 𑀆𑀘𑀺𑀓𑁆𑀔𑁂𑀬𑁆𑀬, 𑀅𑀦𑁆𑀥𑀓𑀸𑀭𑁂 𑀯𑀸 𑀢𑁂𑀮𑀧𑀚𑁆𑀚𑁄𑀢𑀁 𑀥𑀸𑀭𑁂𑀬𑁆𑀬 𑁋 𑀘𑀓𑁆𑀔𑀼𑀫𑀦𑁆𑀢𑁄 𑀭𑀽𑀧𑀸𑀦𑀺 𑀤𑀓𑁆𑀔𑀦𑁆𑀢𑀻𑀢𑀺; 𑀏𑀯𑀫𑁂𑀯𑀁 𑀪𑁄𑀢𑀸 𑀕𑁄𑀢𑀫𑁂𑀦 𑀅𑀦𑁂𑀓𑀧𑀭𑀺𑀬𑀸𑀬𑁂𑀦 𑀥𑀫𑁆𑀫𑁄 𑀧𑀓𑀸𑀲𑀺𑀢𑁄. 𑀏𑀲𑀸𑀳𑀁 𑀪𑀯𑀦𑁆𑀢𑀁 𑀕𑁄𑀢𑀫𑀁 𑀲𑀭𑀡𑀁 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀜𑁆𑀘. 𑀮𑀪𑁂𑀬𑁆𑀬𑀸𑀳𑀁 𑀪𑁄𑀢𑁄 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁, 𑀮𑀪𑁂𑀬𑁆𑀬𑀁 𑀉𑀧𑀲𑀫𑁆𑀧𑀤’’𑀦𑁆𑀢𑀺. 𑀅𑀮𑀢𑁆𑀣 𑀔𑁄 ¶ 𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄…𑀧𑁂… 𑀅𑀭𑀳𑀢𑀁 𑀅𑀳𑁄𑀲𑀻𑀢𑀺.

𑀲𑀼𑀦𑁆𑀤𑀭𑀺𑀓𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀲𑀼𑀢𑁆𑀢𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀭𑀸𑀚𑀕𑀳𑁂 𑀯𑀺𑀳𑀭𑀢𑀺 𑀕𑀺𑀚𑁆𑀛𑀓𑀽𑀝𑁂 𑀧𑀩𑁆𑀩𑀢𑁂. 𑀅𑀣 𑀔𑁄 𑀫𑀸𑀖𑁄 𑀫𑀸𑀡𑀯𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 ¶ 𑀪𑀕𑀯𑀢𑀸 𑀲𑀤𑁆𑀥𑀺𑀁 𑀲𑀫𑁆𑀫𑁄𑀤𑀺. 𑀲𑀫𑁆𑀫𑁄𑀤𑀦𑀻𑀬𑀁 𑀓𑀣𑀁 𑀲𑀸𑀭𑀡𑀻𑀬𑀁 𑀯𑀻𑀢𑀺𑀲𑀸𑀭𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀔𑁄 𑀫𑀸𑀖𑁄 𑀫𑀸𑀡𑀯𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 ¶ 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋

‘‘𑀅𑀳𑀜𑁆𑀳𑀺, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀤𑀸𑀬𑀓𑁄 𑀤𑀸𑀦𑀧𑀢𑀺 𑀯𑀤𑀜𑁆𑀜𑀽 𑀬𑀸𑀘𑀬𑁄𑀕𑁄; 𑀥𑀫𑁆𑀫𑁂𑀦 𑀪𑁄𑀕𑁂 𑀧𑀭𑀺𑀬𑁂𑀲𑀸𑀫𑀺; 𑀥𑀫𑁆𑀫𑁂𑀦 𑀪𑁄𑀕𑁂 𑀧𑀭𑀺𑀬𑁂𑀲𑀺𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀮𑀤𑁆𑀥𑁂𑀳𑀺 𑀪𑁄𑀕𑁂𑀳𑀺 𑀥𑀫𑁆𑀫𑀸𑀥𑀺𑀕𑀢𑁂𑀳𑀺 𑀏𑀓𑀲𑁆𑀲𑀧𑀺 𑀤𑀤𑀸𑀫𑀺 𑀤𑁆𑀯𑀺𑀦𑁆𑀦𑀫𑁆𑀧𑀺 ¶ 𑀢𑀺𑀡𑁆𑀡𑀫𑁆𑀧𑀺 𑀘𑀢𑀼𑀦𑁆𑀦𑀫𑁆𑀧𑀺 𑀧𑀜𑁆𑀘𑀦𑁆𑀦𑀫𑁆𑀧𑀺 𑀙𑀦𑁆𑀦𑀫𑁆𑀧𑀺 𑀲𑀢𑁆𑀢𑀦𑁆𑀦𑀫𑁆𑀧𑀺 𑀅𑀝𑁆𑀞𑀦𑁆𑀦𑀫𑁆𑀧𑀺 𑀦𑀯𑀦𑁆𑀦𑀫𑁆𑀧𑀺 𑀤𑀲𑀦𑁆𑀦𑀫𑁆𑀧𑀺 𑀤𑀤𑀸𑀫𑀺, 𑀯𑀻𑀲𑀸𑀬𑀧𑀺 𑀢𑀺𑀁𑀲𑀸𑀬𑀧𑀺 𑀘𑀢𑁆𑀢𑀸𑀮𑀻𑀲𑀸𑀬𑀧𑀺 𑀧𑀜𑁆𑀜𑀸𑀲𑀸𑀬𑀧𑀺 𑀤𑀤𑀸𑀫𑀺, 𑀲𑀢𑀲𑁆𑀲𑀧𑀺 𑀤𑀤𑀸𑀫𑀺, 𑀪𑀺𑀬𑁆𑀬𑁄𑀧𑀺 𑀤𑀤𑀸𑀫𑀺. 𑀓𑀘𑁆𑀘𑀸𑀳𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀏𑀯𑀁 𑀤𑀤𑀦𑁆𑀢𑁄 𑀏𑀯𑀁 𑀬𑀚𑀦𑁆𑀢𑁄 𑀩𑀳𑀼𑀁 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀲𑀯𑀸𑀫𑀻’’𑀢𑀺 ¶ ?

‘‘𑀢𑀕𑁆𑀖 𑀢𑁆𑀯𑀁, 𑀫𑀸𑀡𑀯, 𑀏𑀯𑀁 𑀤𑀤𑀦𑁆𑀢𑁄 𑀏𑀯𑀁 𑀬𑀚𑀦𑁆𑀢𑁄 𑀩𑀳𑀼𑀁 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀲𑀯𑀲𑀺. 𑀬𑁄 𑀔𑁄, 𑀫𑀸𑀡𑀯, 𑀤𑀸𑀬𑀓𑁄 𑀤𑀸𑀦𑀧𑀢𑀺 𑀯𑀤𑀜𑁆𑀜𑀽 𑀬𑀸𑀘𑀬𑁄𑀕𑁄; 𑀥𑀫𑁆𑀫𑁂𑀦 𑀪𑁄𑀕𑁂 𑀧𑀭𑀺𑀬𑁂𑀲𑀢𑀺; 𑀥𑀫𑁆𑀫𑁂𑀦 𑀪𑁄𑀕𑁂 𑀧𑀭𑀺𑀬𑁂𑀲𑀺𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀮𑀤𑁆𑀥𑁂𑀳𑀺 𑀪𑁄𑀕𑁂𑀳𑀺 𑀥𑀫𑁆𑀫𑀸𑀥𑀺𑀕𑀢𑁂𑀳𑀺 𑀏𑀓𑀲𑁆𑀲𑀧𑀺 𑀤𑀤𑀸𑀢𑀺…𑀧𑁂… 𑀲𑀢𑀲𑁆𑀲𑀧𑀺 𑀤𑀤𑀸𑀢𑀺, 𑀪𑀺𑀬𑁆𑀬𑁄𑀧𑀺 𑀤𑀤𑀸𑀢𑀺, 𑀩𑀳𑀼𑀁 𑀲𑁄 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀲𑀯𑀢𑀻’’𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀫𑀸𑀖𑁄 𑀫𑀸𑀡𑀯𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀳𑀁 𑀕𑁄𑀢𑀫𑀁 𑀯𑀤𑀜𑁆𑀜𑀼𑀁, (𑀇𑀢𑀺 𑀫𑀸𑀖𑁄 𑀫𑀸𑀡𑀯𑁄)

𑀓𑀸𑀲𑀸𑀬𑀯𑀸𑀲𑀺𑀁 𑀅𑀕𑀳𑀁 [𑀅𑀕𑀺𑀳𑀁 (𑀲𑀻.), 𑀅𑀕𑁂𑀳𑀁 (𑀧𑀻.)] 𑀘𑀭𑀦𑁆𑀢𑀁;

𑀬𑁄 𑀬𑀸𑀘𑀬𑁄𑀕𑁄 𑀤𑀸𑀦𑀧𑀢𑀺 [𑀤𑀸𑀦𑀧𑀢𑀻 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀕𑀳𑀝𑁆𑀞𑁄, 𑀧𑀼𑀜𑁆𑀜𑀢𑁆𑀣𑀺𑀓𑁄 [𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀔𑁄 (𑀲𑀻. 𑀧𑀻. 𑀓.)] 𑀬𑀚𑀢𑀺 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄;

𑀤𑀤𑀁 ¶ 𑀧𑀭𑁂𑀲𑀁 𑀇𑀥 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑀁, 𑀓𑀣𑀁 𑀳𑀼𑀢𑀁 𑀬𑀚𑀫𑀸𑀦𑀲𑁆𑀲 𑀲𑀼𑀚𑁆𑀛𑁂’’.

‘‘𑀬𑁄 𑀬𑀸𑀘𑀬𑁄𑀕𑁄 𑀤𑀸𑀦𑀧𑀢𑀺 𑀕𑀳𑀝𑁆𑀞𑁄, (𑀫𑀸𑀖𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀧𑀼𑀜𑁆𑀜𑀢𑁆𑀣𑀺𑀓𑁄 𑀬𑀚𑀢𑀺 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄;

𑀤𑀤𑀁 𑀧𑀭𑁂𑀲𑀁 𑀇𑀥 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑀁, 𑀆𑀭𑀸𑀥𑀬𑁂 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑁂𑀪𑀺 𑀢𑀸𑀤𑀺’’.

‘‘𑀬𑁄 ¶ 𑀬𑀸𑀘𑀬𑁄𑀕𑁄 𑀤𑀸𑀦𑀧𑀢𑀺 𑀕𑀳𑀝𑁆𑀞𑁄, (𑀇𑀢𑀺 𑀫𑀸𑀖𑁄 𑀫𑀸𑀡𑀯𑁄)

𑀧𑀼𑀜𑁆𑀜𑀢𑁆𑀣𑀺𑀓𑁄 𑀬𑀚𑀢𑀺 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄;

𑀤𑀤𑀁 𑀧𑀭𑁂𑀲𑀁 𑀇𑀥 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑀁, 𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑁂’’.

‘‘𑀬𑁂 ¶ 𑀯𑁂 𑀅𑀲𑀢𑁆𑀢𑀸 [𑀅𑀮𑀕𑁆𑀕𑀸 (𑀲𑁆𑀬𑀸.)] 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂, 𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀸 𑀓𑁂𑀯𑀮𑀺𑀦𑁄 𑀬𑀢𑀢𑁆𑀢𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂 𑀲𑀩𑁆𑀩𑀲𑀁𑀬𑁄𑀚𑀦𑀩𑀦𑁆𑀥𑀦𑀘𑁆𑀙𑀺𑀤𑀸, 𑀤𑀦𑁆𑀢𑀸 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀸 𑀅𑀦𑀻𑀖𑀸 𑀦𑀺𑀭𑀸𑀲𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂 ¶ 𑀲𑀩𑁆𑀩𑀲𑀁𑀬𑁄𑀚𑀦𑀯𑀺𑀧𑁆𑀧𑀫𑀼𑀢𑁆𑀢𑀸, 𑀤𑀦𑁆𑀢𑀸 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀸 𑀅𑀦𑀻𑀖𑀸 𑀦𑀺𑀭𑀸𑀲𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀭𑀸𑀕𑀜𑁆𑀘 𑀤𑁄𑀲𑀜𑁆𑀘 𑀧𑀳𑀸𑀬 𑀫𑁄𑀳𑀁, 𑀔𑀻𑀡𑀸𑀲𑀯𑀸 𑀯𑀽𑀲𑀺𑀢𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂𑀲𑀼 𑀦 𑀫𑀸𑀬𑀸 𑀯𑀲𑀢𑀺 𑀦 𑀫𑀸𑀦𑁄, 𑀔𑀻𑀡𑀸𑀲𑀯𑀸 𑀯𑀽𑀲𑀺𑀢𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂 ¶ ¶ 𑀯𑀻𑀢𑀮𑁄𑀪𑀸 𑀅𑀫𑀫𑀸 𑀦𑀺𑀭𑀸𑀲𑀸, 𑀔𑀻𑀡𑀸𑀲𑀯𑀸 𑀯𑀽𑀲𑀺𑀢𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂 ¶ 𑀯𑁂 𑀦 𑀢𑀡𑁆𑀳𑀸𑀲𑀼 𑀉𑀧𑀸𑀢𑀺𑀧𑀦𑁆𑀦𑀸, 𑀯𑀺𑀢𑀭𑁂𑀬𑁆𑀬 𑀑𑀖𑀁 𑀅𑀫𑀫𑀸 𑀘𑀭𑀦𑁆𑀢𑀺;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂𑀲𑀁 𑀢𑀡𑁆𑀳𑀸 𑀦𑀢𑁆𑀣𑀺 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺 𑀮𑁄𑀓𑁂, 𑀪𑀯𑀸𑀪𑀯𑀸𑀬 𑀇𑀥 𑀯𑀸 𑀳𑀼𑀭𑀁 𑀯𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂 𑀓𑀸𑀫𑁂 𑀳𑀺𑀢𑁆𑀯𑀸 𑀅𑀕𑀳𑀸 𑀘𑀭𑀦𑁆𑀢𑀺, 𑀲𑀼𑀲𑀜𑁆𑀜𑀢𑀢𑁆𑀢𑀸 𑀢𑀲𑀭𑀁𑀯 𑀉𑀚𑁆𑀚𑀼𑀁;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀲𑀫𑀺𑀢𑀸𑀯𑀺𑀦𑁄 𑀯𑀻𑀢𑀭𑀸𑀕𑀸 𑀅𑀓𑁄𑀧𑀸, 𑀬𑁂𑀲𑀁 𑀕𑀢𑀻 𑀦𑀢𑁆𑀣𑀺𑀥 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀬;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀚𑀳𑀺𑀢𑁆𑀯𑀸 𑀚𑀸𑀢𑀺𑀫𑀭𑀡𑀁 𑀅𑀲𑁂𑀲𑀁, 𑀓𑀣𑀁𑀓𑀣𑀺𑀁 𑀲𑀩𑁆𑀩𑀫𑀼𑀧𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑀸;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂 ¶ ¶ 𑀅𑀢𑁆𑀢𑀤𑀻𑀧𑀸 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂, 𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀸 𑀲𑀩𑁆𑀩𑀥𑀺 𑀯𑀺𑀧𑁆𑀧𑀫𑀼𑀢𑁆𑀢𑀸;

𑀓𑀸𑀮𑁂𑀦 ¶ 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁂 𑀳𑁂𑀢𑁆𑀣 𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀬𑀣𑀸 𑀢𑀣𑀸 𑀇𑀤𑀁, 𑀅𑀬𑀫𑀦𑁆𑀢𑀺𑀫𑀸 𑀦𑀢𑁆𑀣𑀺 𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑁄𑀢𑀺;

𑀓𑀸𑀮𑁂𑀦 𑀢𑁂𑀲𑀼 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣.

‘‘𑀬𑁄 ¶ 𑀯𑁂𑀤𑀕𑀽 𑀛𑀸𑀦𑀭𑀢𑁄 𑀲𑀢𑀻𑀫𑀸, 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀧𑀢𑁆𑀢𑁄 𑀲𑀭𑀡𑀁 𑀩𑀳𑀽𑀦𑀁;

𑀓𑀸𑀮𑁂𑀦 𑀢𑀫𑁆𑀳𑀺 𑀳𑀩𑁆𑀬𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄 𑀬𑀚𑁂𑀣’’.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀅𑀫𑁄𑀖𑀸 𑀫𑀫 𑀧𑀼𑀘𑁆𑀙𑀦𑀸 𑀅𑀳𑀼, 𑀅𑀓𑁆𑀔𑀸𑀲𑀺 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑁂;

𑀢𑁆𑀯𑀜𑁆𑀳𑁂𑀢𑁆𑀣 𑀚𑀸𑀦𑀸𑀲𑀺 𑀬𑀣𑀸 𑀢𑀣𑀸 𑀇𑀤𑀁, 𑀢𑀣𑀸 𑀳𑀺 𑀢𑁂 𑀯𑀺𑀤𑀺𑀢𑁄 𑀏𑀲 𑀥𑀫𑁆𑀫𑁄.

‘‘𑀬𑁄 𑀬𑀸𑀘𑀬𑁄𑀕𑁄 𑀤𑀸𑀦𑀧𑀢𑀺 𑀕𑀳𑀝𑁆𑀞𑁄, (𑀇𑀢𑀺 𑀫𑀸𑀖𑁄 𑀫𑀸𑀡𑀯𑁄)

𑀧𑀼𑀜𑁆𑀜𑀢𑁆𑀣𑀺𑀓𑁄 𑀬𑀚𑀢𑀺 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑁄;

𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀬𑀜𑁆𑀜𑀲𑀫𑁆𑀧𑀤𑀁’’.

‘‘𑀬𑀚𑀲𑁆𑀲𑀼 𑀬𑀚𑀫𑀸𑀦𑁄 𑀫𑀸𑀖𑀸𑀢𑀺 𑀪𑀕𑀯𑀸, 𑀲𑀩𑁆𑀩𑀢𑁆𑀣 𑀘 𑀯𑀺𑀧𑁆𑀧𑀲𑀸𑀤𑁂𑀳𑀺 𑀘𑀺𑀢𑁆𑀢𑀁;

𑀆𑀭𑀫𑁆𑀫𑀡𑀁 𑀬𑀚𑀫𑀸𑀦𑀲𑁆𑀲 𑀬𑀜𑁆𑀜𑁄, 𑀏𑀢𑁆𑀣𑀧𑁆𑀧𑀢𑀺𑀝𑁆𑀞𑀸𑀬 𑀚𑀳𑀸𑀢𑀺 𑀤𑁄𑀲𑀁.

‘‘𑀲𑁄 ¶ 𑀯𑀻𑀢𑀭𑀸𑀕𑁄 𑀧𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀤𑁄𑀲𑀁, 𑀫𑁂𑀢𑁆𑀢𑀁 𑀘𑀺𑀢𑁆𑀢𑀁 𑀪𑀸𑀯𑀬𑀫𑀧𑁆𑀧𑀫𑀸𑀡𑀁;

𑀭𑀢𑁆𑀢𑀺𑀦𑁆𑀤𑀺𑀯𑀁 𑀲𑀢𑀢𑀫𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄, 𑀲𑀩𑁆𑀩𑀸 𑀤𑀺𑀲𑀸 𑀨𑀭𑀢𑀺 𑀅𑀧𑁆𑀧𑀫𑀜𑁆𑀜𑀁’’.

‘‘𑀓𑁄 ¶ 𑀲𑀼𑀚𑁆𑀛𑀢𑀺 𑀫𑀼𑀘𑁆𑀘𑀢𑀺 𑀩𑀚𑁆𑀛𑀢𑀻 𑀘, 𑀓𑁂𑀦𑀢𑁆𑀢𑀦𑀸 𑀕𑀘𑁆𑀙𑀢𑀺 [𑀓𑁂𑀦𑀢𑁆𑀣𑁂𑀦𑀸 𑀕𑀘𑁆𑀙𑀢𑀺 (𑀓.)] 𑀩𑁆𑀭𑀳𑁆𑀫𑀮𑁄𑀓𑀁;

𑀅𑀚𑀸𑀦𑀢𑁄 𑀫𑁂 𑀫𑀼𑀦𑀺 𑀩𑁆𑀭𑀽𑀳𑀺 𑀧𑀼𑀝𑁆𑀞𑁄, 𑀪𑀕𑀯𑀸 𑀳𑀺 𑀫𑁂 𑀲𑀓𑁆𑀔𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀚𑁆𑀚𑀤𑀺𑀝𑁆𑀞𑁄;

𑀢𑀼𑀯𑀜𑁆𑀳𑀺 ¶ 𑀦𑁄 𑀩𑁆𑀭𑀳𑁆𑀫𑀲𑀫𑁄𑀲𑀺 𑀲𑀘𑁆𑀘𑀁, 𑀓𑀣𑀁 𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀮𑁄𑀓𑀁 𑀚𑀼𑀢𑀺𑀫’’.

‘‘𑀬𑁄 𑀬𑀚𑀢𑀺 𑀢𑀺𑀯𑀺𑀥𑀁 𑀬𑀜𑁆𑀜𑀲𑀫𑁆𑀧𑀤𑀁, (𑀫𑀸𑀖𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀆𑀭𑀸𑀥𑀬𑁂 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑁂𑀪𑀺 𑀢𑀸𑀤𑀺;

𑀏𑀯𑀁 ¶ 𑀬𑀚𑀺𑀢𑁆𑀯𑀸 𑀲𑀫𑁆𑀫𑀸 𑀬𑀸𑀘𑀬𑁄𑀕𑁄,

𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀮𑁄𑀓𑀦𑁆𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀻’’𑀢𑀺.

𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀫𑀸𑀖𑁄 𑀫𑀸𑀡𑀯𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫…𑀧𑁂… 𑀅𑀚𑁆𑀚𑀢𑀕𑁆𑀕𑁂 𑀧𑀸𑀡𑀼𑀧𑁂𑀢𑀁 𑀲𑀭𑀡𑀁 𑀕𑀢’’𑀦𑁆𑀢𑀺.

𑀫𑀸𑀖𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀜𑁆𑀘𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀭𑀸𑀚𑀕𑀳𑁂 𑀯𑀺𑀳𑀭𑀢𑀺 𑀯𑁂𑀴𑀼𑀯𑀦𑁂 𑀓𑀮𑀦𑁆𑀤𑀓𑀦𑀺𑀯𑀸𑀧𑁂. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀲𑀪𑀺𑀬𑀲𑁆𑀲 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀲𑁆𑀲 𑀧𑀼𑀭𑀸𑀡𑀲𑀸𑀮𑁄𑀳𑀺𑀢𑀸𑀬 𑀤𑁂𑀯𑀢𑀸𑀬 𑀧𑀜𑁆𑀳𑀸 𑀉𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑀸 𑀳𑁄𑀦𑁆𑀢𑀺 𑁋 ‘‘𑀬𑁄 𑀢𑁂, 𑀲𑀪𑀺𑀬, 𑀲𑀫𑀡𑁄 𑀯𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀯𑀸 𑀇𑀫𑁂 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀝𑁆𑀞𑁄 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀢𑀺 𑀢𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁 𑀘𑀭𑁂𑀬𑁆𑀬𑀸𑀲𑀻’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄 𑀢𑀲𑁆𑀲𑀸 𑀤𑁂𑀯𑀢𑀸𑀬 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀢𑁂 𑀧𑀜𑁆𑀳𑁂 𑀉𑀕𑁆𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀬𑁂 𑀢𑁂 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀲𑀗𑁆𑀖𑀺𑀦𑁄 𑀕𑀡𑀺𑀦𑁄 𑀕𑀡𑀸𑀘𑀭𑀺𑀬𑀸 𑀜𑀸𑀢𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄 𑀢𑀺𑀢𑁆𑀣𑀓𑀭𑀸 𑀲𑀸𑀥𑀼𑀲𑀫𑁆𑀫𑀢𑀸 ¶ 𑀩𑀳𑀼𑀚𑀦𑀲𑁆𑀲, 𑀲𑁂𑀬𑁆𑀬𑀣𑀺𑀤𑀁 𑁋 𑀧𑀽𑀭𑀡𑁄 𑀓𑀲𑁆𑀲𑀧𑁄 𑀫𑀓𑁆𑀔𑀮𑀺𑀕𑁄𑀲𑀸𑀮𑁄 𑀅𑀚𑀺𑀢𑁄 𑀓𑁂𑀲𑀓𑀫𑁆𑀩𑀮𑁄 𑀧𑀓𑀼𑀥𑁄 [𑀓𑀓𑀼𑀥𑁄 (𑀲𑀻.) 𑀧𑀓𑀼𑀤𑁆𑀥𑁄 (𑀲𑁆𑀬𑀸. 𑀓𑀁.)] 𑀓𑀘𑁆𑀘𑀸𑀦𑁄 𑀲𑀜𑁆𑀘𑀬𑁄 [𑀲𑀜𑁆𑀚𑀬𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)] 𑀩𑁂𑀮𑀝𑁆𑀞𑀧𑀼𑀢𑁆𑀢𑁄 [𑀩𑁂𑀮𑁆𑀮𑀝𑁆𑀞𑀺𑀧𑀼𑀢𑁆𑀢𑁄 (𑀲𑀻. 𑀧𑀻.), 𑀯𑁂𑀴𑀝𑁆𑀞𑀧𑀼𑀢𑁆𑀢𑁄 (𑀲𑁆𑀬𑀸.)] 𑀦𑀺𑀕𑀡𑁆𑀞𑁄 𑀦𑀸𑀝𑀧𑀼𑀢𑁆𑀢𑁄 [𑀦𑀸𑀢𑀧𑀼𑀢𑁆𑀢𑁄 (𑀲𑀻. 𑀧𑀻.)], 𑀢𑁂 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀢𑁂 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀘𑁆𑀙𑀢𑀺. 𑀢𑁂 𑀲𑀪𑀺𑀬𑁂𑀦 ¶ 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁂𑀦 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀝𑁆𑀞𑀸 𑀦 𑀲𑀫𑁆𑀧𑀸𑀬𑀦𑁆𑀢𑀺; 𑀅𑀲𑀫𑁆𑀧𑀸𑀬𑀦𑁆𑀢𑀸 𑀓𑁄𑀧𑀜𑁆𑀘 𑀤𑁄𑀲𑀜𑁆𑀘 𑀅𑀧𑁆𑀧𑀘𑁆𑀘𑀬𑀜𑁆𑀘 𑀧𑀸𑀢𑀼𑀓𑀭𑁄𑀦𑁆𑀢𑀺. 𑀅𑀧𑀺 𑀘 𑀲𑀪𑀺𑀬𑀁 𑀬𑁂𑀯 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀁 𑀧𑀝𑀺𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑀲𑁆𑀲 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀲𑁆𑀲 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀬𑁂 𑀔𑁄 𑀢𑁂 𑀪𑁄𑀦𑁆𑀢𑁄 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀲𑀗𑁆𑀖𑀺𑀦𑁄 𑀕𑀡𑀺𑀦𑁄 𑀕𑀡𑀸𑀘𑀭𑀺𑀬𑀸 𑀜𑀸𑀢𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄 𑀢𑀺𑀢𑁆𑀣𑀓𑀭𑀸 𑀲𑀸𑀥𑀼𑀲𑀫𑁆𑀫𑀢𑀸 𑀩𑀳𑀼𑀚𑀦𑀲𑁆𑀲, 𑀲𑁂𑀬𑁆𑀬𑀣𑀺𑀤𑀁 𑁋 𑀧𑀽𑀭𑀡𑁄 𑀓𑀲𑁆𑀲𑀧𑁄…𑀧𑁂… 𑀦𑀺𑀕𑀡𑁆𑀞𑁄 𑀦𑀸𑀝𑀧𑀼𑀢𑁆𑀢𑁄, 𑀢𑁂 𑀫𑀬𑀸 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀝𑁆𑀞𑀸 𑀦 𑀲𑀫𑁆𑀧𑀸𑀬𑀦𑁆𑀢𑀺, 𑀅𑀲𑀫𑁆𑀧𑀸𑀬𑀦𑁆𑀢𑀸 𑀓𑁄𑀧𑀜𑁆𑀘 𑀤𑁄𑀲𑀜𑁆𑀘 𑀅𑀧𑁆𑀧𑀘𑁆𑀘𑀬𑀜𑁆𑀘 𑀧𑀸𑀢𑀼𑀓𑀭𑁄𑀦𑁆𑀢𑀺; 𑀅𑀧𑀺 ¶ 𑀘 𑀫𑀜𑁆𑀜𑁂𑀯𑁂𑀢𑁆𑀣 𑀧𑀝𑀺𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀺. 𑀬𑀦𑁆𑀦𑀽𑀦𑁆𑀦𑀸𑀳𑀁 𑀳𑀻𑀦𑀸𑀬𑀸𑀯𑀢𑁆𑀢𑀺𑀢𑁆𑀯𑀸 𑀓𑀸𑀫𑁂 𑀧𑀭𑀺𑀪𑀼𑀜𑁆𑀚𑁂𑀬𑁆𑀬’’𑀦𑁆𑀢𑀺.

𑀅𑀣 ¶ 𑀔𑁄 𑀲𑀪𑀺𑀬𑀲𑁆𑀲 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀲𑁆𑀲 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀅𑀬𑀫𑁆𑀧𑀺 𑀔𑁄 𑀲𑀫𑀡𑁄 𑀕𑁄𑀢𑀫𑁄 𑀲𑀗𑁆𑀖𑀻 𑀘𑁂𑀯 𑀕𑀡𑀻 𑀘 𑀕𑀡𑀸𑀘𑀭𑀺𑀬𑁄 𑀘 𑀜𑀸𑀢𑁄 𑀬𑀲𑀲𑁆𑀲𑀻 𑀢𑀺𑀢𑁆𑀣𑀓𑀭𑁄 𑀲𑀸𑀥𑀼𑀲𑀫𑁆𑀫𑀢𑁄 𑀩𑀳𑀼𑀚𑀦𑀲𑁆𑀲; 𑀬𑀁𑀦𑀽𑀦𑀸𑀳𑀁 𑀲𑀫𑀡𑀁 𑀕𑁄𑀢𑀫𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀇𑀫𑁂 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀘𑁆𑀙𑁂𑀬𑁆𑀬’’𑀦𑁆𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑀲𑁆𑀲 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀲𑁆𑀲 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀬𑁂𑀧𑀺 𑀔𑁄 𑀢𑁂 [𑀬𑁂 𑀔𑁄 𑀢𑁂 (𑀲𑁆𑀬𑀸.), 𑀬𑀁 𑀔𑁄 𑀢𑁂 (𑀓.)] 𑀪𑁄𑀦𑁆𑀢𑁄 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀚𑀺𑀡𑁆𑀡𑀸 𑀯𑀼𑀟𑁆𑀠𑀸 𑀫𑀳𑀮𑁆𑀮𑀓𑀸 𑀅𑀤𑁆𑀥𑀕𑀢𑀸 𑀯𑀬𑁄𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑀸 𑀣𑁂𑀭𑀸 𑀭𑀢𑁆𑀢𑀜𑁆𑀜𑀽 𑀘𑀺𑀭𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀸 𑀲𑀗𑁆𑀖𑀺𑀦𑁄 𑀕𑀡𑀺𑀦𑁄 𑀕𑀡𑀸𑀘𑀭𑀺𑀬𑀸 𑀜𑀸𑀢𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄 𑀢𑀺𑀢𑁆𑀣𑀓𑀭𑀸 𑀲𑀸𑀥𑀼𑀲𑀫𑁆𑀫𑀢𑀸 𑀩𑀳𑀼𑀚𑀦𑀲𑁆𑀲, 𑀲𑁂𑀬𑁆𑀬𑀣𑀺𑀤𑀁 𑁋 𑀧𑀽𑀭𑀡𑁄 𑀓𑀲𑁆𑀲𑀧𑁄…𑀧𑁂. ¶ … 𑀦𑀺𑀕𑀡𑁆𑀞𑁄 𑀦𑀸𑀝𑀧𑀼𑀢𑁆𑀢𑁄, 𑀢𑁂𑀧𑀺 𑀫𑀬𑀸 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀝𑁆𑀞𑀸 𑀦 𑀲𑀫𑁆𑀧𑀸𑀬𑀦𑁆𑀢𑀺, 𑀅𑀲𑀫𑁆𑀧𑀸𑀬𑀦𑁆𑀢𑀸 𑀓𑁄𑀧𑀜𑁆𑀘 𑀤𑁄𑀲𑀜𑁆𑀘 𑀅𑀧𑁆𑀧𑀘𑁆𑀘𑀬𑀜𑁆𑀘 𑀧𑀸𑀢𑀼𑀓𑀭𑁄𑀦𑁆𑀢𑀺, 𑀅𑀧𑀺 𑀘 𑀫𑀜𑁆𑀜𑁂𑀯𑁂𑀢𑁆𑀣 𑀧𑀝𑀺𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀺; 𑀓𑀺𑀁 𑀧𑀦 𑀫𑁂 𑀲𑀫𑀡𑁄 𑀕𑁄𑀢𑀫𑁄 𑀇𑀫𑁂 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀝𑁆𑀞𑁄 𑀩𑁆𑀬𑀸𑀓𑀭𑀺𑀲𑁆𑀲𑀢𑀺! 𑀲𑀫𑀡𑁄 𑀳𑀺 𑀕𑁄𑀢𑀫𑁄 𑀤𑀳𑀭𑁄 𑀘𑁂𑀯 𑀚𑀸𑀢𑀺𑀬𑀸, 𑀦𑀯𑁄 𑀘 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀸𑀬𑀸’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑀲𑁆𑀲 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀲𑁆𑀲 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀲𑀫𑀡𑁄 𑀔𑁄 [𑀲𑀫𑀡𑁄 𑀔𑁄 𑀕𑁄𑀢𑀫𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀤𑀳𑀭𑁄𑀢𑀺 𑀦 𑀉𑀜𑁆𑀜𑀸𑀢𑀩𑁆𑀩𑁄 𑀦 𑀧𑀭𑀺𑀪𑁄𑀢𑀩𑁆𑀩𑁄. 𑀤𑀳𑀭𑁄𑀧𑀺 𑀘𑁂𑀲 𑀲𑀫𑀡𑁄 𑀕𑁄𑀢𑀫𑁄 𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑁄 𑀳𑁄𑀢𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀬𑀁𑀦𑀽𑀦𑀸𑀳𑀁 𑀲𑀫𑀡𑀁 𑀕𑁄𑀢𑀫𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀇𑀫𑁂 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀘𑁆𑀙𑁂𑀬𑁆𑀬’’𑀦𑁆𑀢𑀺.

𑀅𑀣 ¶ 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄 𑀬𑁂𑀦 𑀭𑀸𑀚𑀕𑀳𑀁 𑀢𑁂𑀦 𑀘𑀸𑀭𑀺𑀓𑀁 𑀧𑀓𑁆𑀓𑀸𑀫𑀺. 𑀅𑀦𑀼𑀧𑀼𑀩𑁆𑀩𑁂𑀦 𑀘𑀸𑀭𑀺𑀓𑀁 𑀘𑀭𑀫𑀸𑀦𑁄 𑀬𑁂𑀦 𑀭𑀸𑀚𑀕𑀳𑀁 𑀯𑁂𑀴𑀼𑀯𑀦𑀁 𑀓𑀮𑀦𑁆𑀤𑀓𑀦𑀺𑀯𑀸𑀧𑁄, 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑀸 𑀲𑀤𑁆𑀥𑀺𑀁 ¶ 𑀲𑀫𑁆𑀫𑁄𑀤𑀺. 𑀲𑀫𑁆𑀫𑁄𑀤𑀦𑀻𑀬𑀁 𑀓𑀣𑀁 𑀲𑀸𑀭𑀡𑀻𑀬𑀁 𑀯𑀻𑀢𑀺𑀲𑀸𑀭𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀓𑀗𑁆𑀔𑀻 𑀯𑁂𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀻 𑀆𑀕𑀫𑀁, (𑀇𑀢𑀺 𑀲𑀪𑀺𑀬𑁄)

𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀼𑀁 𑀅𑀪𑀺𑀓𑀗𑁆𑀔𑀫𑀸𑀦𑁄;

𑀢𑁂𑀲𑀦𑁆𑀢𑀓𑀭𑁄 𑀪𑀯𑀸𑀳𑀺 [𑀪𑀯𑀸𑀳𑀺 𑀫𑁂 (𑀧𑀻. 𑀓.)] 𑀧𑀜𑁆𑀳𑁂 𑀫𑁂 𑀧𑀼𑀝𑁆𑀞𑁄,

𑀅𑀦𑀼𑀧𑀼𑀩𑁆𑀩𑀁 𑀅𑀦𑀼𑀥𑀫𑁆𑀫𑀁 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀳𑀺 𑀫𑁂’’.

‘‘𑀤𑀽𑀭𑀢𑁄 ¶ 𑀆𑀕𑀢𑁄𑀲𑀺 𑀲𑀪𑀺𑀬, (𑀇𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀼𑀁 𑀅𑀪𑀺𑀓𑀗𑁆𑀔𑀫𑀸𑀦𑁄;

𑀢𑁂𑀲𑀦𑁆𑀢𑀓𑀭𑁄 𑀪𑀯𑀸𑀫𑀺 [𑀢𑁂𑀲𑀫𑀦𑁆𑀢𑀓𑀭𑁄𑀫𑀺 𑀢𑁂 (𑀓.)] 𑀧𑀜𑁆𑀳𑁂 𑀢𑁂 𑀧𑀼𑀝𑁆𑀞𑁄,

𑀅𑀦𑀼𑀧𑀼𑀩𑁆𑀩𑀁 𑀅𑀦𑀼𑀥𑀫𑁆𑀫𑀁 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀫𑀺 𑀢𑁂.

‘‘𑀧𑀼𑀘𑁆𑀙 ¶ 𑀫𑀁 𑀲𑀪𑀺𑀬 𑀧𑀜𑁆𑀳𑀁, 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀫𑀦𑀲𑀺𑀘𑁆𑀙𑀲𑀺;

𑀢𑀲𑁆𑀲 𑀢𑀲𑁆𑀲𑁂𑀯 𑀧𑀜𑁆𑀳𑀲𑁆𑀲, 𑀅𑀳𑀁 𑀅𑀦𑁆𑀢𑀁 𑀓𑀭𑁄𑀫𑀺 𑀢𑁂’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑀲𑁆𑀲 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀲𑁆𑀲 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀅𑀘𑁆𑀙𑀭𑀺𑀬𑀁 𑀯𑀢, 𑀪𑁄, 𑀅𑀩𑁆𑀪𑀼𑀢𑀁 𑀯𑀢, 𑀪𑁄! 𑀬𑀁 𑀯𑀢𑀸𑀳𑀁 𑀅𑀜𑁆𑀜𑁂𑀲𑀼 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼 𑀑𑀓𑀸𑀲𑀓𑀫𑁆𑀫𑀫𑀢𑁆𑀢𑀫𑁆𑀧𑀺 [𑀑𑀓𑀸𑀲𑀫𑀢𑁆𑀢𑀫𑁆𑀧𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀦𑀸𑀮𑀢𑁆𑀣𑀁 𑀢𑀁 𑀫𑁂 𑀇𑀤𑀁 𑀲𑀫𑀡𑁂𑀦 𑀕𑁄𑀢𑀫𑁂𑀦 𑀑𑀓𑀸𑀲𑀓𑀫𑁆𑀫𑀁 𑀓𑀢’’𑀦𑁆𑀢𑀺. 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀧𑀫𑀼𑀤𑀺𑀢𑁄 𑀉𑀤𑀕𑁆𑀕𑁄 𑀧𑀻𑀢𑀺𑀲𑁄𑀫𑀦𑀲𑁆𑀲𑀚𑀸𑀢𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 ¶ 𑀧𑀜𑁆𑀳𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺 𑁋

‘‘𑀓𑀺𑀁 𑀧𑀢𑁆𑀢𑀺𑀦𑀫𑀸𑀳𑀼 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑀁, (𑀇𑀢𑀺 𑀲𑀪𑀺𑀬𑁄)

𑀲𑁄𑀭𑀢𑀁 𑀓𑁂𑀦 𑀓𑀣𑀜𑁆𑀘 𑀤𑀦𑁆𑀢𑀫𑀸𑀳𑀼;

𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀳𑀺’’.

‘‘𑀧𑀚𑁆𑀚𑁂𑀦 ¶ 𑀓𑀢𑁂𑀦 𑀅𑀢𑁆𑀢𑀦𑀸, (𑀲𑀪𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀕𑀢𑁄 𑀯𑀺𑀢𑀺𑀡𑁆𑀡𑀓𑀗𑁆𑀔𑁄;

𑀯𑀺𑀪𑀯𑀜𑁆𑀘 𑀪𑀯𑀜𑁆𑀘 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀬,

𑀯𑀼𑀲𑀺𑀢𑀯𑀸 𑀔𑀻𑀡𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑁄 𑀲 𑀪𑀺𑀓𑁆𑀔𑀼.

‘‘𑀲𑀩𑁆𑀩𑀢𑁆𑀣 ¶ 𑀉𑀧𑁂𑀓𑁆𑀔𑀓𑁄 𑀲𑀢𑀺𑀫𑀸, 𑀦 𑀲𑁄 𑀳𑀺𑀁𑀲𑀢𑀺 𑀓𑀜𑁆𑀘𑀺 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑁂;

𑀢𑀺𑀡𑁆𑀡𑁄 𑀲𑀫𑀡𑁄 𑀅𑀦𑀸𑀯𑀺𑀮𑁄, 𑀉𑀲𑁆𑀲𑀤𑀸 𑀬𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀲𑁄𑀭𑀢𑁄 𑀲𑁄.

‘‘𑀬𑀲𑁆𑀲𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀸𑀦𑀺 𑀪𑀸𑀯𑀺𑀢𑀸𑀦𑀺, 𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑁂;

𑀦𑀺𑀩𑁆𑀩𑀺𑀚𑁆𑀛 𑀇𑀫𑀁 𑀧𑀭𑀜𑁆𑀘 𑀮𑁄𑀓𑀁, 𑀓𑀸𑀮𑀁 𑀓𑀗𑁆𑀔𑀢𑀺 𑀪𑀸𑀯𑀺𑀢𑁄 𑀲 𑀤𑀦𑁆𑀢𑁄.

‘‘𑀓𑀧𑁆𑀧𑀸𑀦𑀺 𑀯𑀺𑀘𑁂𑀬𑁆𑀬 𑀓𑁂𑀯𑀮𑀸𑀦𑀺, 𑀲𑀁𑀲𑀸𑀭𑀁 𑀤𑀼𑀪𑀬𑀁 𑀘𑀼𑀢𑀽𑀧𑀧𑀸𑀢𑀁;

𑀯𑀺𑀕𑀢𑀭𑀚𑀫𑀦𑀗𑁆𑀕𑀡𑀁 ¶ 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀁, 𑀧𑀢𑁆𑀢𑀁 𑀚𑀸𑀢𑀺𑀔𑀬𑀁 𑀢𑀫𑀸𑀳𑀼 𑀩𑀼𑀤𑁆𑀥’’𑀦𑁆𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄 𑀪𑀕𑀯𑀢𑁄 𑀪𑀸𑀲𑀺𑀢𑀁 𑀅𑀪𑀺𑀦𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸 𑀅𑀦𑀼𑀫𑁄𑀤𑀺𑀢𑁆𑀯𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀧𑀫𑀼𑀤𑀺𑀢𑁄 𑀉𑀤𑀕𑁆𑀕𑁄 𑀧𑀻𑀢𑀺𑀲𑁄𑀫𑀦𑀲𑁆𑀲𑀚𑀸𑀢𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀉𑀢𑁆𑀢𑀭𑀺𑀁 [𑀉𑀢𑁆𑀢𑀭𑀺 (𑀓.)] 𑀧𑀜𑁆𑀳𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺 𑁋

‘‘𑀓𑀺𑀁 ¶ 𑀧𑀢𑁆𑀢𑀺𑀦𑀫𑀸𑀳𑀼 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁, (𑀇𑀢𑀺 𑀲𑀪𑀺𑀬𑁄)

𑀲𑀫𑀡𑀁 𑀓𑁂𑀦 𑀓𑀣𑀜𑁆𑀘 𑀦𑁆𑀳𑀸𑀢𑀓𑁄𑀢𑀺;

𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀳𑀺’’.

‘‘𑀩𑀸𑀳𑀺𑀢𑁆𑀯𑀸 𑀲𑀩𑁆𑀩𑀧𑀸𑀧𑀓𑀸𑀦𑀺, (𑀲𑀪𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀯𑀺𑀫𑀮𑁄 𑀲𑀸𑀥𑀼𑀲𑀫𑀸𑀳𑀺𑀢𑁄 𑀞𑀺𑀢𑀢𑁆𑀢𑁄;

𑀅𑀲𑀺𑀢𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀲 𑀩𑁆𑀭𑀳𑁆𑀫𑀸.

‘‘𑀲𑀫𑀺𑀢𑀸𑀯𑀺 𑀧𑀳𑀸𑀬 𑀧𑀼𑀜𑁆𑀜𑀧𑀸𑀧𑀁, 𑀯𑀺𑀭𑀚𑁄 𑀜𑀢𑁆𑀯𑀸 𑀇𑀫𑀁 𑀧𑀭𑀜𑁆𑀘 𑀮𑁄𑀓𑀁;

𑀚𑀸𑀢𑀺𑀫𑀭𑀡𑀁 𑀉𑀧𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑁄, 𑀲𑀫𑀡𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀢𑀣𑀢𑁆𑀢𑀸.

‘‘𑀦𑀺𑀦𑁆𑀳𑀸𑀬 ¶ [𑀦𑀺𑀦𑀳𑀸𑀬 (𑀲𑁆𑀬𑀸.)] 𑀲𑀩𑁆𑀩𑀧𑀸𑀧𑀓𑀸𑀦𑀺, 𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑁂;

𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 ¶ 𑀓𑀧𑁆𑀧𑀺𑀬𑁂𑀲𑀼, 𑀓𑀧𑁆𑀧𑀁 𑀦𑁂𑀢𑀺 𑀢𑀫𑀸𑀳𑀼 𑀦𑁆𑀳𑀸𑀢𑀓𑁄’’𑀢𑀺.

‘‘𑀆𑀕𑀼𑀁 𑀦 𑀓𑀭𑁄𑀢𑀺 𑀓𑀺𑀜𑁆𑀘𑀺 𑀮𑁄𑀓𑁂, 𑀲𑀩𑁆𑀩𑀲𑀁𑀬𑁄𑀕𑁂 [𑀲𑀩𑁆𑀩𑀬𑁄𑀕𑁂 (𑀓.)] 𑀯𑀺𑀲𑀚𑁆𑀚 𑀩𑀦𑁆𑀥𑀦𑀸𑀦𑀺;

𑀲𑀩𑁆𑀩𑀢𑁆𑀣 𑀦 𑀲𑀚𑁆𑀚𑀢𑀻 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄, 𑀦𑀸𑀕𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀢𑀣𑀢𑁆𑀢𑀸’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄…𑀧𑁂… 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀉𑀢𑁆𑀢𑀭𑀺𑀁 𑀧𑀜𑁆𑀳𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺 𑁋

‘‘𑀓𑀁 𑀔𑁂𑀢𑁆𑀢𑀚𑀺𑀦𑀁 𑀯𑀤𑀦𑁆𑀢𑀺 𑀩𑀼𑀤𑁆𑀥𑀸, (𑀇𑀢𑀺 𑀲𑀪𑀺𑀬𑁄)

𑀓𑀼𑀲𑀮𑀁 𑀓𑁂𑀦 𑀓𑀣𑀜𑁆𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑁄𑀢𑀺;

𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀳𑀺’’.

‘‘𑀔𑁂𑀢𑁆𑀢𑀸𑀦𑀺 𑀯𑀺𑀘𑁂𑀬𑁆𑀬 𑀓𑁂𑀯𑀮𑀸𑀦𑀺, (𑀲𑀪𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀤𑀺𑀩𑁆𑀩𑀁 𑀫𑀸𑀦𑀼𑀲𑀓𑀜𑁆𑀘 𑀩𑁆𑀭𑀳𑁆𑀫𑀔𑁂𑀢𑁆𑀢𑀁;

𑀲𑀩𑁆𑀩𑀔𑁂𑀢𑁆𑀢𑀫𑀽𑀮𑀩𑀦𑁆𑀥𑀦𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑁄,

𑀔𑁂𑀢𑁆𑀢𑀚𑀺𑀦𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀢𑀣𑀢𑁆𑀢𑀸.

‘‘𑀓𑁄𑀲𑀸𑀦𑀺 ¶ 𑀯𑀺𑀘𑁂𑀬𑁆𑀬 𑀓𑁂𑀯𑀮𑀸𑀦𑀺, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀫𑀸𑀦𑀼𑀲𑀓𑀜𑁆𑀘 𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑁄𑀲𑀁;

𑀲𑀩𑁆𑀩𑀓𑁄𑀲𑀫𑀽𑀮𑀩𑀦𑁆𑀥𑀦𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑁄, 𑀓𑀼𑀲𑀮𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀢𑀣𑀢𑁆𑀢𑀸.

‘‘𑀤𑀼𑀪𑀬𑀸𑀦𑀺 ¶ 𑀯𑀺𑀘𑁂𑀬𑁆𑀬 𑀧𑀡𑁆𑀟𑀭𑀸𑀦𑀺, 𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘 𑀲𑀼𑀤𑁆𑀥𑀺𑀧𑀜𑁆𑀜𑁄;

𑀓𑀡𑁆𑀳𑀁 𑀲𑀼𑀓𑁆𑀓𑀁 𑀉𑀧𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑁄, 𑀧𑀡𑁆𑀟𑀺𑀢𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀢𑀣𑀢𑁆𑀢𑀸.

‘‘𑀅𑀲𑀢𑀜𑁆𑀘 ¶ 𑀲𑀢𑀜𑁆𑀘 𑀜𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀁, 𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑁂;

𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀳𑀺 𑀧𑀽𑀚𑀦𑀻𑀬𑁄, 𑀲𑀗𑁆𑀕𑀁 𑀚𑀸𑀮𑀫𑀢𑀺𑀘𑁆𑀘 𑀲𑁄 𑀫𑀼𑀦𑀻’’𑀢𑀺.

‘‘𑀓𑀺𑀁 𑀧𑀢𑁆𑀢𑀺𑀦𑀫𑀸𑀳𑀼 ¶ 𑀯𑁂𑀤𑀕𑀼𑀁, (𑀇𑀢𑀺 𑀲𑀪𑀺𑀬𑁄)

𑀅𑀦𑀼𑀯𑀺𑀤𑀺𑀢𑀁 𑀓𑁂𑀦 𑀓𑀣𑀜𑁆𑀘 𑀯𑀻𑀭𑀺𑀬𑀯𑀸𑀢𑀺;

𑀆𑀚𑀸𑀦𑀺𑀬𑁄 𑀓𑀺𑀦𑁆𑀢𑀺 𑀦𑀸𑀫 𑀳𑁄𑀢𑀺,

𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀳𑀺’’.

‘‘𑀯𑁂𑀤𑀸𑀦𑀺 𑀯𑀺𑀘𑁂𑀬𑁆𑀬 𑀓𑁂𑀯𑀮𑀸𑀦𑀺, (𑀲𑀪𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀲𑀫𑀡𑀸𑀦𑀁 𑀬𑀸𑀦𑀺𑀥𑀢𑁆𑀣𑀺 [𑀬𑀸𑀦𑀺𑀧𑀢𑁆𑀣𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁;

𑀲𑀩𑁆𑀩𑀁 𑀯𑁂𑀤𑀫𑀢𑀺𑀘𑁆𑀘 𑀯𑁂𑀤𑀕𑀽 𑀲𑁄.

‘‘𑀅𑀦𑀼𑀯𑀺𑀘𑁆𑀘 𑀧𑀧𑀜𑁆𑀘𑀦𑀸𑀫𑀭𑀽𑀧𑀁, 𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁 ¶ 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘 𑀭𑁄𑀕𑀫𑀽𑀮𑀁;

𑀲𑀩𑁆𑀩𑀭𑁄𑀕𑀫𑀽𑀮𑀩𑀦𑁆𑀥𑀦𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑁄, 𑀅𑀦𑀼𑀯𑀺𑀤𑀺𑀢𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀢𑀣𑀢𑁆𑀢𑀸.

‘‘𑀯𑀺𑀭𑀢𑁄 𑀇𑀥 𑀲𑀩𑁆𑀩𑀧𑀸𑀧𑀓𑁂𑀳𑀺, 𑀦𑀺𑀭𑀬𑀤𑀼𑀓𑁆𑀔𑀁 𑀅𑀢𑀺𑀘𑁆𑀘 𑀯𑀻𑀭𑀺𑀬𑀯𑀸 𑀲𑁄;

𑀲𑁄 𑀯𑀻𑀭𑀺𑀬𑀯𑀸 𑀧𑀥𑀸𑀦𑀯𑀸, 𑀥𑀻𑀭𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀢𑀣𑀢𑁆𑀢𑀸.

‘‘𑀬𑀲𑁆𑀲𑀲𑁆𑀲𑀼 𑀮𑀼𑀦𑀸𑀦𑀺 𑀩𑀦𑁆𑀥𑀦𑀸𑀦𑀺, 𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘 𑀲𑀗𑁆𑀕𑀫𑀽𑀮𑀁;

𑀲𑀩𑁆𑀩𑀲𑀗𑁆𑀕𑀫𑀽𑀮𑀩𑀦𑁆𑀥𑀦𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑁄, 𑀆𑀚𑀸𑀦𑀺𑀬𑁄 𑀢𑀸𑀤𑀺 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀢𑀣𑀢𑁆𑀢𑀸’’𑀢𑀺.

𑀅𑀣 ¶ ¶ 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄…𑀧𑁂… 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀉𑀢𑁆𑀢𑀭𑀺𑀁 𑀧𑀜𑁆𑀳𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺 𑁋

‘‘𑀓𑀺𑀁 𑀧𑀢𑁆𑀢𑀺𑀦𑀫𑀸𑀳𑀼 𑀲𑁄𑀢𑁆𑀢𑀺𑀬𑀁, (𑀇𑀢𑀺 𑀲𑀪𑀺𑀬𑁄)

𑀅𑀭𑀺𑀬𑀁 ¶ 𑀓𑁂𑀦 𑀓𑀣𑀜𑁆𑀘 𑀘𑀭𑀡𑀯𑀸𑀢𑀺;

𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄 𑀓𑀺𑀦𑁆𑀢𑀺 𑀦𑀸𑀫 𑀳𑁄𑀢𑀺,

𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑁂 𑀪𑀕𑀯𑀸 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀳𑀺’’.

‘‘𑀲𑀼𑀢𑁆𑀯𑀸 𑀲𑀩𑁆𑀩𑀥𑀫𑁆𑀫𑀁 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀬 𑀮𑁄𑀓𑁂, (𑀲𑀪𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀲𑀸𑀯𑀚𑁆𑀚𑀸𑀦𑀯𑀚𑁆𑀚𑀁 𑀬𑀤𑀢𑁆𑀣𑀺 𑀓𑀺𑀜𑁆𑀘𑀺;

𑀅𑀪𑀺𑀪𑀼𑀁 𑀅𑀓𑀣𑀁𑀓𑀣𑀺𑀁 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀁,

𑀅𑀦𑀺𑀖𑀁 ¶ 𑀲𑀩𑁆𑀩𑀥𑀺𑀫𑀸𑀳𑀼 𑀲𑁄𑀢𑁆𑀢𑀺𑀬𑁄𑀢𑀺.

‘‘𑀙𑁂𑀢𑁆𑀯𑀸 𑀆𑀲𑀯𑀸𑀦𑀺 𑀆𑀮𑀬𑀸𑀦𑀺, 𑀯𑀺𑀤𑁆𑀯𑀸 𑀲𑁄 𑀦 𑀉𑀧𑁂𑀢𑀺 𑀕𑀩𑁆𑀪𑀲𑁂𑀬𑁆𑀬𑀁;

𑀲𑀜𑁆𑀜𑀁 𑀢𑀺𑀯𑀺𑀥𑀁 𑀧𑀦𑀼𑀚𑁆𑀚 𑀧𑀗𑁆𑀓𑀁, 𑀓𑀧𑁆𑀧𑀁 𑀦𑁂𑀢𑀺 𑀢𑀫𑀸𑀳𑀼 𑀅𑀭𑀺𑀬𑁄𑀢𑀺.

‘‘𑀬𑁄 𑀇𑀥 𑀘𑀭𑀡𑁂𑀲𑀼 𑀧𑀢𑁆𑀢𑀺𑀧𑀢𑁆𑀢𑁄, 𑀓𑀼𑀲𑀮𑁄 𑀲𑀩𑁆𑀩𑀤𑀸 𑀆𑀚𑀸𑀦𑀸𑀢𑀺 [𑀆𑀚𑀸𑀦𑀺 (𑀲𑁆𑀬𑀸.)] 𑀥𑀫𑁆𑀫𑀁;

𑀲𑀩𑁆𑀩𑀢𑁆𑀣 𑀦 𑀲𑀚𑁆𑀚𑀢𑀺 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑁄 [𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄 (𑀲𑀻.)], 𑀧𑀝𑀺𑀖𑀸 𑀬𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀘𑀭𑀡𑀯𑀸 𑀲𑁄.

‘‘𑀤𑀼𑀓𑁆𑀔𑀯𑁂𑀧𑀓𑁆𑀓𑀁 𑀬𑀤𑀢𑁆𑀣𑀺 𑀓𑀫𑁆𑀫𑀁, 𑀉𑀤𑁆𑀥𑀫𑀥𑁄 𑀢𑀺𑀭𑀺𑀬𑀁 𑀯𑀸𑀧𑀺 [𑀢𑀺𑀭𑀺𑀬𑀜𑁆𑀘𑀸𑀧𑀺 (𑀲𑁆𑀬𑀸.)] 𑀫𑀚𑁆𑀛𑁂;

𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀬𑀺𑀢𑁆𑀯𑀸 𑀧𑀭𑀺𑀜𑁆𑀜𑀘𑀸𑀭𑀻, 𑀫𑀸𑀬𑀁 𑀫𑀸𑀦𑀫𑀣𑁄𑀧𑀺 𑀮𑁄𑀪𑀓𑁄𑀥𑀁;

𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀫𑀓𑀸𑀲𑀺 𑀦𑀸𑀫𑀭𑀽𑀧𑀁, 𑀢𑀁 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑀫𑀸𑀳𑀼 𑀧𑀢𑁆𑀢𑀺𑀧𑀢𑁆𑀢’’𑀦𑁆𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄 𑀪𑀕𑀯𑀢𑁄 𑀪𑀸𑀲𑀺𑀢𑀁 𑀅𑀪𑀺𑀦𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸 𑀅𑀦𑀼𑀫𑁄𑀤𑀺𑀢𑁆𑀯𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀧𑀫𑀼𑀤𑀺𑀢𑁄 𑀉𑀤𑀕𑁆𑀕𑁄 𑀧𑀻𑀢𑀺𑀲𑁄𑀫𑀦𑀲𑁆𑀲𑀚𑀸𑀢𑁄 ¶ 𑀉𑀝𑁆𑀞𑀸𑀬𑀸𑀲𑀦𑀸 𑀏𑀓𑀁𑀲𑀁 𑀉𑀢𑁆𑀢𑀭𑀸𑀲𑀗𑁆𑀕𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀜𑁆𑀚𑀮𑀺𑀁 𑀧𑀡𑀸𑀫𑁂𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀲𑀫𑁆𑀫𑀼𑀔𑀸 𑀲𑀸𑀭𑀼𑀧𑁆𑀧𑀸𑀳𑀺 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀪𑀺𑀢𑁆𑀣𑀯𑀺 𑁋

‘‘𑀬𑀸𑀦𑀺 ¶ ¶ 𑀘 𑀢𑀻𑀡𑀺 𑀬𑀸𑀦𑀺 𑀘 𑀲𑀝𑁆𑀞𑀺, 𑀲𑀫𑀡𑀧𑁆𑀧𑀯𑀸𑀤𑀲𑀺𑀢𑀸𑀦𑀺 [𑀲𑀫𑀡𑀧𑁆𑀧𑀯𑀸𑀤𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸𑀦𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜;

𑀲𑀜𑁆𑀜𑀓𑁆𑀔𑀭𑀲𑀜𑁆𑀜𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸𑀦𑀺, 𑀑𑀲𑀭𑀡𑀸𑀦𑀺 𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀑𑀖𑀢𑀫𑀕𑀸.

‘‘𑀅𑀦𑁆𑀢𑀕𑀽𑀲𑀺 ¶ 𑀧𑀸𑀭𑀕𑀽 [𑀧𑀸𑀭𑀕𑀽𑀲𑀺 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)] 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲, 𑀅𑀭𑀳𑀸𑀲𑀺 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄 𑀔𑀻𑀡𑀸𑀲𑀯𑀁 𑀢𑀁 𑀫𑀜𑁆𑀜𑁂;

𑀚𑀼𑀢𑀺𑀫𑀸 𑀫𑀼𑀢𑀺𑀫𑀸 𑀧𑀳𑀽𑀢𑀧𑀜𑁆𑀜𑁄, 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲𑀦𑁆𑀢𑀓𑀭𑀁 𑀅𑀢𑀸𑀭𑁂𑀲𑀺 𑀫𑀁.

‘‘𑀬𑀁 𑀫𑁂 𑀓𑀗𑁆𑀔𑀺𑀢𑀫𑀜𑁆𑀜𑀸𑀲𑀺, 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀸 𑀫𑀁 𑀢𑀸𑀭𑀬𑀺 𑀦𑀫𑁄 𑀢𑁂;

𑀫𑀼𑀦𑀺 𑀫𑁄𑀦𑀧𑀣𑁂𑀲𑀼 𑀧𑀢𑁆𑀢𑀺𑀧𑀢𑁆𑀢, 𑀅𑀔𑀺𑀮 𑀆𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼 𑀲𑁄𑀭𑀢𑁄𑀲𑀺.

‘‘𑀬𑀸 ¶ 𑀫𑁂 𑀓𑀗𑁆𑀔𑀸 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺, 𑀢𑀁 𑀫𑁂 𑀩𑁆𑀬𑀸𑀓𑀸𑀲𑀺 𑀘𑀓𑁆𑀔𑀼𑀫𑀸;

𑀅𑀤𑁆𑀥𑀸 𑀫𑀼𑀦𑀻𑀲𑀺 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄, 𑀦𑀢𑁆𑀣𑀺 𑀦𑀻𑀯𑀭𑀡𑀸 𑀢𑀯.

‘‘𑀉𑀧𑀸𑀬𑀸𑀲𑀸 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑁂, 𑀯𑀺𑀤𑁆𑀥𑀲𑁆𑀢𑀸 𑀯𑀺𑀦𑀴𑀻𑀓𑀢𑀸;

𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑁄 𑀤𑀫𑀧𑁆𑀧𑀢𑁆𑀢𑁄, 𑀥𑀺𑀢𑀺𑀫𑀸 𑀲𑀘𑁆𑀘𑀦𑀺𑀓𑁆𑀓𑀫𑁄.

‘‘𑀢𑀲𑁆𑀲 𑀢𑁂 𑀦𑀸𑀕𑀦𑀸𑀕𑀲𑁆𑀲, 𑀫𑀳𑀸𑀯𑀻𑀭𑀲𑁆𑀲 𑀪𑀸𑀲𑀢𑁄;

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

‘‘𑀦𑀫𑁄 𑀢𑁂 𑀧𑀼𑀭𑀺𑀲𑀸𑀚𑀜𑁆𑀜, 𑀦𑀫𑁄 𑀢𑁂 𑀧𑀼𑀭𑀺𑀲𑀼𑀢𑁆𑀢𑀫;

𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀫𑀺𑀁 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁, 𑀦𑀢𑁆𑀣𑀺 𑀢𑁂 𑀧𑀝𑀺𑀧𑀼𑀕𑁆𑀕𑀮𑁄.

‘‘𑀢𑀼𑀯𑀁 ¶ 𑀩𑀼𑀤𑁆𑀥𑁄 𑀢𑀼𑀯𑀁 𑀲𑀢𑁆𑀣𑀸, 𑀢𑀼𑀯𑀁 𑀫𑀸𑀭𑀸𑀪𑀺𑀪𑀽 𑀫𑀼𑀦𑀺;

𑀢𑀼𑀯𑀁 𑀅𑀦𑀼𑀲𑀬𑁂 𑀙𑁂𑀢𑁆𑀯𑀸, 𑀢𑀺𑀡𑁆𑀡𑁄 𑀢𑀸𑀭𑁂𑀲𑀺 𑀫𑀁 𑀧𑀚𑀁.

‘‘𑀉𑀧𑀥𑀻 𑀢𑁂 𑀲𑀫𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀸, 𑀆𑀲𑀯𑀸 𑀢𑁂 𑀧𑀤𑀸𑀮𑀺𑀢𑀸;

𑀲𑀻𑀳𑁄𑀲𑀺 𑀅𑀦𑀼𑀧𑀸𑀤𑀸𑀦𑁄, 𑀧𑀳𑀻𑀦𑀪𑀬𑀪𑁂𑀭𑀯𑁄.

‘‘𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀁 ¶ 𑀬𑀣𑀸 𑀯𑀕𑁆𑀕𑀼, 𑀢𑁄𑀬𑁂 𑀦 𑀉𑀧𑀮𑀺𑀫𑁆𑀧𑀢𑀺 [𑀢𑁄𑀬𑁂𑀦 𑀦 𑀉𑀧𑀮𑀺𑀧𑁆𑀧𑀢𑀺 (𑀲𑀻.), 𑀢𑁄𑀬𑁂 𑀦 𑀉𑀧𑀮𑀺𑀧𑁆𑀧𑀢𑀺 (𑀧𑀻.), 𑀢𑁄𑀬𑁂𑀦 𑀦 𑀉𑀧𑀮𑀺𑀫𑁆𑀧𑀢𑀺 (𑀓.)];

𑀏𑀯𑀁 𑀧𑀼𑀜𑁆𑀜𑁂 𑀘 𑀧𑀸𑀧𑁂 𑀘, 𑀉𑀪𑀬𑁂 𑀢𑁆𑀯𑀁 𑀦 𑀮𑀺𑀫𑁆𑀧𑀲𑀺;

𑀧𑀸𑀤𑁂 𑀯𑀻𑀭 𑀧𑀲𑀸𑀭𑁂𑀳𑀺, 𑀲𑀪𑀺𑀬𑁄 𑀯𑀦𑁆𑀤𑀢𑀺 𑀲𑀢𑁆𑀣𑀼𑀦𑁄’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄 𑀪𑀕𑀯𑀢𑁄 𑀧𑀸𑀤𑁂𑀲𑀼 𑀲𑀺𑀭𑀲𑀸 𑀦𑀺𑀧𑀢𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 ¶ 𑁋 ‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀪𑀦𑁆𑀢𑁂…𑀧𑁂… 𑀏𑀲𑀸𑀳𑀁 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀲𑀭𑀡𑀁 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀜𑁆𑀘; 𑀮𑀪𑁂𑀬𑁆𑀬𑀸𑀳𑀁, 𑀪𑀦𑁆𑀢𑁂, 𑀪𑀕𑀯𑀢𑁄 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁, 𑀮𑀪𑁂𑀬𑁆𑀬𑀁 𑀉𑀧𑀲𑀫𑁆𑀧𑀤’’𑀦𑁆𑀢𑀺 ¶ .

‘‘𑀬𑁄 𑀔𑁄, 𑀲𑀪𑀺𑀬, 𑀅𑀜𑁆𑀜𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑀧𑀼𑀩𑁆𑀩𑁄 𑀇𑀫𑀲𑁆𑀫𑀺𑀁 𑀥𑀫𑁆𑀫𑀯𑀺𑀦𑀬𑁂 𑀆𑀓𑀗𑁆𑀔𑀢𑀺 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁, 𑀆𑀓𑀗𑁆𑀔𑀢𑀺 𑀉𑀧𑀲𑀫𑁆𑀧𑀤𑀁, 𑀲𑁄 𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀫𑀸𑀲𑁂 𑀧𑀭𑀺𑀯𑀲𑀢𑀺; 𑀘𑀢𑀼𑀦𑁆𑀦𑀁 𑀫𑀸𑀲𑀸𑀦𑀁 𑀅𑀘𑁆𑀘𑀬𑁂𑀦 𑀆𑀭𑀤𑁆𑀥𑀘𑀺𑀢𑁆𑀢𑀸 𑀪𑀺𑀓𑁆𑀔𑀽 𑀧𑀩𑁆𑀩𑀸𑀚𑁂𑀦𑁆𑀢𑀺, 𑀉𑀧𑀲𑀫𑁆𑀧𑀸𑀤𑁂𑀦𑁆𑀢𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀪𑀸𑀯𑀸𑀬. 𑀅𑀧𑀺 𑀘 𑀫𑁂𑀢𑁆𑀣 𑀧𑀼𑀕𑁆𑀕𑀮𑀯𑁂𑀫𑀢𑁆𑀢𑀢𑀸 𑀯𑀺𑀤𑀺𑀢𑀸’’𑀢𑀺.

‘‘𑀲𑀘𑁂, 𑀪𑀦𑁆𑀢𑁂, 𑀅𑀜𑁆𑀜𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑀧𑀼𑀩𑁆𑀩𑀸 𑀇𑀫𑀲𑁆𑀫𑀺𑀁 𑀥𑀫𑁆𑀫𑀯𑀺𑀦𑀬𑁂 𑀆𑀓𑀗𑁆𑀔𑀦𑁆𑀢𑀸 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁, 𑀆𑀓𑀗𑁆𑀔𑀦𑁆𑀢𑀸 ¶ 𑀉𑀧𑀲𑀫𑁆𑀧𑀤𑀁 𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀫𑀸𑀲𑁂 𑀧𑀭𑀺𑀯𑀲𑀦𑁆𑀢𑀺, 𑀘𑀢𑀼𑀦𑁆𑀦𑀁 𑀫𑀸𑀲𑀸𑀦𑀁 𑀅𑀘𑁆𑀘𑀬𑁂𑀦 𑀆𑀭𑀤𑁆𑀥𑀘𑀺𑀢𑁆𑀢𑀸 𑀪𑀺𑀓𑁆𑀔𑀽 𑀧𑀩𑁆𑀩𑀸𑀚𑁂𑀦𑁆𑀢𑀺, 𑀉𑀧𑀲𑀫𑁆𑀧𑀸𑀤𑁂𑀦𑁆𑀢𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀪𑀸𑀯𑀸𑀬, 𑀅𑀳𑀁 𑀘𑀢𑁆𑀢𑀸𑀭𑀺 𑀯𑀲𑁆𑀲𑀸𑀦𑀺 𑀧𑀭𑀺𑀯𑀲𑀺𑀲𑁆𑀲𑀸𑀫𑀺; 𑀘𑀢𑀼𑀦𑁆𑀦𑀁 𑀯𑀲𑁆𑀲𑀸𑀦𑀁 𑀅𑀘𑁆𑀘𑀬𑁂𑀦 𑀆𑀭𑀤𑁆𑀥𑀘𑀺𑀢𑁆𑀢𑀸 𑀪𑀺𑀓𑁆𑀔𑀽 𑀧𑀩𑁆𑀩𑀸𑀚𑁂𑀦𑁆𑀢𑀼 𑀉𑀧𑀲𑀫𑁆𑀧𑀸𑀤𑁂𑀦𑁆𑀢𑀼 𑀪𑀺𑀓𑁆𑀔𑀼𑀪𑀸𑀯𑀸𑀬𑀸’’𑀢𑀺. 𑀅𑀮𑀢𑁆𑀣 𑀔𑁄 𑀲𑀪𑀺𑀬𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀓𑁄 𑀪𑀕𑀯𑀢𑁄 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁 𑀅𑀮𑀢𑁆𑀣 𑀉𑀧𑀲𑀫𑁆𑀧𑀤𑀁…𑀧𑁂… 𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀔𑁄 𑀧𑀦𑀸𑀬𑀲𑁆𑀫𑀸 𑀲𑀪𑀺𑀬𑁄 𑀅𑀭𑀳𑀢𑀁 𑀅𑀳𑁄𑀲𑀻𑀢𑀺.

𑀲𑀪𑀺𑀬𑀲𑀼𑀢𑁆𑀢𑀁 𑀙𑀝𑁆𑀞𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀅𑀗𑁆𑀕𑀼𑀢𑁆𑀢𑀭𑀸𑀧𑁂𑀲𑀼 𑀘𑀸𑀭𑀺𑀓𑀁 𑀘𑀭𑀫𑀸𑀦𑁄 𑀫𑀳𑀢𑀸 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦 𑀲𑀤𑁆𑀥𑀺𑀁 𑀅𑀟𑁆𑀠𑀢𑁂𑀴𑀲𑁂𑀳𑀺 ¶ 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀢𑁂𑀳𑀺 𑀬𑁂𑀦 𑀆𑀧𑀡𑀁 𑀦𑀸𑀫 𑀅𑀗𑁆𑀕𑀼𑀢𑁆𑀢𑀭𑀸𑀧𑀸𑀦𑀁 𑀦𑀺𑀕𑀫𑁄 𑀢𑀤𑀯𑀲𑀭𑀺. 𑀅𑀲𑁆𑀲𑁄𑀲𑀺 ¶ 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 ‘‘𑀲𑀫𑀡𑁄 𑀔𑀮𑀼, 𑀪𑁄, 𑀕𑁄𑀢𑀫𑁄 𑀲𑀓𑁆𑀬𑀧𑀼𑀢𑁆𑀢𑁄 𑀲𑀓𑁆𑀬𑀓𑀼𑀮𑀸 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄 𑀅𑀗𑁆𑀕𑀼𑀢𑁆𑀢𑀭𑀸𑀧𑁂𑀲𑀼 𑀘𑀸𑀭𑀺𑀓𑀁 𑀘𑀭𑀫𑀸𑀦𑁄 𑀫𑀳𑀢𑀸 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦 𑀲𑀤𑁆𑀥𑀺𑀁 𑀅𑀟𑁆𑀠𑀢𑁂𑀴𑀲𑁂𑀳𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀢𑁂𑀳𑀺 𑀆𑀧𑀡𑀁 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁄. 𑀢𑀁 𑀔𑁄 𑀧𑀦 𑀪𑀯𑀦𑁆𑀢𑀁 𑀕𑁄𑀢𑀫𑀁 ¶ 𑀏𑀯𑀁 𑀓𑀮𑁆𑀬𑀸𑀡𑁄 𑀓𑀺𑀢𑁆𑀢𑀺𑀲𑀤𑁆𑀤𑁄 𑀅𑀩𑁆𑀪𑀼𑀕𑁆𑀕𑀢𑁄 𑁋 ‘𑀇𑀢𑀺𑀧𑀺 𑀲𑁄 𑀪𑀕𑀯𑀸 𑀅𑀭𑀳𑀁 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄 𑀯𑀺𑀚𑁆𑀚𑀸𑀘𑀭𑀡𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄 𑀲𑀼𑀕𑀢𑁄 𑀮𑁄𑀓𑀯𑀺𑀤𑀽 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑁄 𑀧𑀼𑀭𑀺𑀲𑀤𑀫𑁆𑀫𑀲𑀸𑀭𑀣𑀺 𑀲𑀢𑁆𑀣𑀸 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁 𑀩𑀼𑀤𑁆𑀥𑁄 𑀪𑀕𑀯𑀸’𑀢𑀺 [𑀪𑀕𑀯𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)]. 𑀲𑁄 𑀇𑀫𑀁 𑀮𑁄𑀓𑀁 𑀲𑀤𑁂𑀯𑀓𑀁 𑀲𑀫𑀸𑀭𑀓𑀁 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑀁 𑀲𑀲𑁆𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀺𑀁 𑀧𑀚𑀁 𑀲𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀁 𑀲𑀬𑀁 𑀅𑀪𑀺𑀜𑁆𑀜𑀸 𑀲𑀘𑁆𑀙𑀺𑀓𑀢𑁆𑀯𑀸 𑀧𑀯𑁂𑀤𑁂𑀢𑀺. 𑀲𑁄 𑀥𑀫𑁆𑀫𑀁 𑀤𑁂𑀲𑀢𑀺 𑀆𑀤𑀺𑀓𑀮𑁆𑀬𑀸𑀡𑀁 𑀫𑀚𑁆𑀛𑁂𑀓𑀮𑁆𑀬𑀸𑀡𑀁 𑀧𑀭𑀺𑀬𑁄𑀲𑀸𑀦𑀓𑀮𑁆𑀬𑀸𑀡𑀁 𑀲𑀸𑀢𑁆𑀣𑀁 𑀲𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀁, 𑀓𑁂𑀯𑀮𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀁 ¶ 𑀧𑀭𑀺𑀲𑀼𑀤𑁆𑀥𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁 𑀧𑀓𑀸𑀲𑁂𑀢𑀺. 𑀲𑀸𑀥𑀼 𑀔𑁄 𑀧𑀦 𑀢𑀣𑀸𑀭𑀽𑀧𑀸𑀦𑀁 𑀅𑀭𑀳𑀢𑀁 𑀤𑀲𑁆𑀲𑀦𑀁 𑀳𑁄𑀢𑀻’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑀸 𑀲𑀤𑁆𑀥𑀺𑀁 𑀲𑀫𑁆𑀫𑁄𑀤𑀺. 𑀲𑀫𑁆𑀫𑁄𑀤𑀦𑀻𑀬𑀁 𑀓𑀣𑀁 𑀲𑀸𑀭𑀡𑀻𑀬𑀁 𑀯𑀻𑀢𑀺𑀲𑀸𑀭𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑀁 𑀚𑀝𑀺𑀮𑀁 𑀪𑀕𑀯𑀸 𑀥𑀫𑁆𑀫𑀺𑀬𑀸 𑀓𑀣𑀸𑀬 𑀲𑀦𑁆𑀤𑀲𑁆𑀲𑁂𑀲𑀺 𑀲𑀫𑀸𑀤𑀧𑁂𑀲𑀺 𑀲𑀫𑀼𑀢𑁆𑀢𑁂𑀚𑁂𑀲𑀺 𑀲𑀫𑁆𑀧𑀳𑀁𑀲𑁂𑀲𑀺. 𑀅𑀣 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀪𑀕𑀯𑀢𑀸 𑀥𑀫𑁆𑀫𑀺𑀬𑀸 𑀓𑀣𑀸𑀬 𑀲𑀦𑁆𑀤𑀲𑁆𑀲𑀺𑀢𑁄 𑀲𑀫𑀸𑀤𑀧𑀺𑀢𑁄 𑀲𑀫𑀼𑀢𑁆𑀢𑁂𑀚𑀺𑀢𑁄 𑀲𑀫𑁆𑀧𑀳𑀁𑀲𑀺𑀢𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀅𑀥𑀺𑀯𑀸𑀲𑁂𑀢𑀼 𑀫𑁂 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀲𑁆𑀯𑀸𑀢𑀦𑀸𑀬 𑀪𑀢𑁆𑀢𑀁 𑀲𑀤𑁆𑀥𑀺𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦𑀸’’𑀢𑀺. 𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀪𑀕𑀯𑀸 𑀓𑁂𑀡𑀺𑀬𑀁 𑀚𑀝𑀺𑀮𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀫𑀳𑀸 𑀔𑁄, 𑀓𑁂𑀡𑀺𑀬, 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁄 ¶ 𑀅𑀟𑁆𑀠𑀢𑁂𑀴𑀲𑀸𑀦𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀢𑀸𑀦𑀺; 𑀢𑁆𑀯𑀜𑁆𑀘 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼 ¶ 𑀅𑀪𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁄’’𑀢𑀺.

𑀤𑀼𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀓𑀺𑀜𑁆𑀘𑀸𑀧𑀺, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀫𑀳𑀸 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁄 𑀅𑀟𑁆𑀠𑀢𑁂𑀴𑀲𑀸𑀦𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀢𑀸𑀦𑀺, 𑀅𑀳𑀜𑁆𑀘 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼 𑀅𑀪𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁄; 𑀅𑀥𑀺𑀯𑀸𑀲𑁂𑀢𑀼 𑀫𑁂 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀲𑁆𑀯𑀸𑀢𑀦𑀸𑀬 𑀪𑀢𑁆𑀢𑀁 𑀲𑀤𑁆𑀥𑀺𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦𑀸’’𑀢𑀺. 𑀤𑀼𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀓𑁂𑀡𑀺𑀬𑀁 𑀚𑀝𑀺𑀮𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀫𑀳𑀸 𑀔𑁄, 𑀓𑁂𑀡𑀺𑀬, 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁄 𑀅𑀟𑁆𑀠𑀢𑁂𑀴𑀲𑀸𑀦𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀢𑀸𑀦𑀺; 𑀢𑁆𑀯𑀜𑁆𑀘 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼 𑀅𑀪𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁄’’𑀢𑀺.

𑀢𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀓𑀺𑀜𑁆𑀘𑀸𑀧𑀺, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀫𑀳𑀸 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁄 𑀅𑀟𑁆𑀠𑀢𑁂𑀴𑀲𑀸𑀦𑀺 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀢𑀸𑀦𑀺, 𑀅𑀳𑀜𑁆𑀘 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼 𑀅𑀪𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁄, 𑀅𑀥𑀺𑀯𑀸𑀲𑁂𑀢𑀼 [𑀅𑀥𑀺𑀯𑀸𑀲𑁂𑀢𑁆𑀯𑁂𑀯 (𑀲𑀻.)] 𑀫𑁂 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀲𑁆𑀯𑀸𑀢𑀦𑀸𑀬 𑀪𑀢𑁆𑀢𑀁 𑀲𑀤𑁆𑀥𑀺𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦𑀸’’𑀢𑀺. 𑀅𑀥𑀺𑀯𑀸𑀲𑁂𑀲𑀺 𑀪𑀕𑀯𑀸 𑀢𑀼𑀡𑁆𑀳𑀻𑀪𑀸𑀯𑁂𑀦. 𑀅𑀣 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀪𑀕𑀯𑀢𑁄 𑀅𑀥𑀺𑀯𑀸𑀲𑀦𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 ¶ 𑀉𑀝𑁆𑀞𑀸𑀬𑀸𑀲𑀦𑀸 𑀬𑁂𑀦 𑀲𑀓𑁄 𑀅𑀲𑁆𑀲𑀫𑁄 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀫𑀺𑀢𑁆𑀢𑀸𑀫𑀘𑁆𑀘𑁂 𑀜𑀸𑀢𑀺𑀲𑀸𑀮𑁄𑀳𑀺𑀢𑁂 𑀆𑀫𑀦𑁆𑀢𑁂𑀲𑀺 𑁋 ‘‘𑀲𑀼𑀡𑀦𑁆𑀢𑀼 𑀫𑁂 𑀪𑀯𑀦𑁆𑀢𑁄 𑀫𑀺𑀢𑁆𑀢𑀸𑀫𑀘𑁆𑀘𑀸 𑀜𑀸𑀢𑀺𑀲𑀸𑀮𑁄𑀳𑀺𑀢𑀸, 𑀲𑀫𑀡𑁄 𑀫𑁂 𑀕𑁄𑀢𑀫𑁄 𑀦𑀺𑀫𑀦𑁆𑀢𑀺𑀢𑁄 𑀲𑁆𑀯𑀸𑀢𑀦𑀸𑀬 𑀪𑀢𑁆𑀢𑀁 𑀲𑀤𑁆𑀥𑀺𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦, 𑀬𑁂𑀦 𑀫𑁂 𑀓𑀸𑀬𑀯𑁂𑀬𑁆𑀬𑀸𑀯𑀝𑀺𑀓𑀁 𑀓𑀭𑁂𑀬𑁆𑀬𑀸𑀣𑀸’’𑀢𑀺. ‘‘𑀏𑀯𑀁, 𑀪𑁄’’𑀢𑀺 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑀲𑁆𑀲 𑀚𑀝𑀺𑀮𑀲𑁆𑀲 𑀫𑀺𑀢𑁆𑀢𑀸𑀫𑀘𑁆𑀘𑀸 𑀜𑀸𑀢𑀺𑀲𑀸𑀮𑁄𑀳𑀺𑀢𑀸 𑀓𑁂𑀡𑀺𑀬𑀲𑁆𑀲 𑀚𑀝𑀺𑀮𑀲𑁆𑀲 𑀧𑀝𑀺𑀲𑁆𑀲𑀼𑀢𑁆𑀯𑀸 𑀅𑀧𑁆𑀧𑁂𑀓𑀘𑁆𑀘𑁂 𑀉𑀤𑁆𑀥𑀦𑀸𑀦𑀺 𑀔𑀡𑀦𑁆𑀢𑀺, 𑀅𑀧𑁆𑀧𑁂𑀓𑀘𑁆𑀘𑁂 𑀓𑀝𑁆𑀞𑀸𑀦𑀺 𑀨𑀸𑀮𑁂𑀦𑁆𑀢𑀺, 𑀅𑀧𑁆𑀧𑁂𑀓𑀘𑁆𑀘𑁂 𑀪𑀸𑀚𑀦𑀸𑀦𑀺 𑀥𑁄𑀯𑀦𑁆𑀢𑀺, 𑀅𑀧𑁆𑀧𑁂𑀓𑀘𑁆𑀘𑁂 𑀉𑀤𑀓𑀫𑀡𑀺𑀓𑀁 𑀧𑀢𑀺𑀝𑁆𑀞𑀸𑀧𑁂𑀦𑁆𑀢𑀺, 𑀅𑀧𑁆𑀧𑁂𑀓𑀘𑁆𑀘𑁂 𑀆𑀲𑀦𑀸𑀦𑀺 𑀧𑀜𑁆𑀜𑀸𑀧𑁂𑀦𑁆𑀢𑀺. 𑀓𑁂𑀡𑀺𑀬𑁄 𑀧𑀦 𑀚𑀝𑀺𑀮𑁄 𑀲𑀸𑀫𑀁𑀬𑁂𑀯 𑀫𑀡𑁆𑀟𑀮𑀫𑀸𑀴𑀁 ¶ 𑀧𑀝𑀺𑀬𑀸𑀤𑁂𑀢𑀺.

𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀆𑀧𑀡𑁂 𑀧𑀝𑀺𑀯𑀲𑀢𑀺, 𑀢𑀺𑀡𑁆𑀡𑀁 ¶ 𑀯𑁂𑀤𑀸𑀦𑀁 𑀧𑀸𑀭𑀕𑀽 𑀲𑀦𑀺𑀖𑀡𑁆𑀟𑀼𑀓𑁂𑀝𑀼𑀪𑀸𑀦𑀁 ¶ 𑀲𑀸𑀓𑁆𑀔𑀭𑀧𑁆𑀧𑀪𑁂𑀤𑀸𑀦𑀁 𑀇𑀢𑀺𑀳𑀸𑀲𑀧𑀜𑁆𑀘𑀫𑀸𑀦𑀁 𑀧𑀤𑀓𑁄 𑀯𑁂𑀬𑁆𑀬𑀸𑀓𑀭𑀡𑁄 𑀮𑁄𑀓𑀸𑀬𑀢𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑁂𑀲𑀼 𑀅𑀦𑀯𑀬𑁄, 𑀢𑀻𑀡𑀺 𑀘 𑀫𑀸𑀡𑀯𑀓𑀲𑀢𑀸𑀦𑀺 𑀫𑀦𑁆𑀢𑁂 𑀯𑀸𑀘𑁂𑀢𑀺.

𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀲𑁂𑀮𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂 𑀅𑀪𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁄 𑀳𑁄𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀢𑀻𑀳𑀺 𑀫𑀸𑀡𑀯𑀓𑀲𑀢𑁂𑀳𑀺 𑀧𑀭𑀺𑀯𑀼𑀢𑁄 𑀚𑀗𑁆𑀖𑀸𑀯𑀺𑀳𑀸𑀭𑀁 𑀅𑀦𑀼𑀘𑀗𑁆𑀓𑀫𑀫𑀸𑀦𑁄 𑀅𑀦𑀼𑀯𑀺𑀘𑀭𑀫𑀸𑀦𑁄 𑀬𑁂𑀦 𑀓𑁂𑀡𑀺𑀬𑀲𑁆𑀲 𑀚𑀝𑀺𑀮𑀲𑁆𑀲 𑀅𑀲𑁆𑀲𑀫𑁄 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺. 𑀅𑀤𑁆𑀤𑀲𑀸 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀓𑁂𑀡𑀺𑀬𑀲𑁆𑀲 𑀚𑀝𑀺𑀮𑀲𑁆𑀲 𑀅𑀲𑁆𑀲𑀫𑁂 [𑀓𑁂𑀡𑀺𑀲𑁆𑀲𑀫𑀺𑀬𑁂 𑀚𑀝𑀺𑀮𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀅𑀧𑁆𑀧𑁂𑀓𑀘𑁆𑀘𑁂 𑀉𑀤𑁆𑀥𑀦𑀸𑀦𑀺 𑀔𑀡𑀦𑁆𑀢𑁂…𑀧𑁂… 𑀅𑀧𑁆𑀧𑁂𑀓𑀘𑁆𑀘𑁂 𑀆𑀲𑀦𑀸𑀦𑀺 𑀧𑀜𑁆𑀜𑀧𑁂𑀦𑁆𑀢𑁂, 𑀓𑁂𑀡𑀺𑀬𑀁 𑀧𑀦 𑀚𑀝𑀺𑀮𑀁 𑀲𑀸𑀫𑀁𑀬𑁂𑀯 𑀫𑀡𑁆𑀟𑀮𑀫𑀸𑀴𑀁 𑀧𑀝𑀺𑀬𑀸𑀤𑁂𑀦𑁆𑀢𑀁. 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀓𑁂𑀡𑀺𑀬𑀁 𑀚𑀝𑀺𑀮𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀓𑀺𑀁 𑀦𑀼 𑀔𑁄 𑀪𑁄𑀢𑁄 𑀓𑁂𑀡𑀺𑀬𑀲𑁆𑀲 𑀆𑀯𑀸𑀳𑁄 𑀯𑀸 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺, 𑀯𑀺𑀯𑀸𑀳𑁄 𑀯𑀸 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺, 𑀫𑀳𑀸𑀬𑀜𑁆𑀜𑁄 𑀯𑀸 𑀧𑀘𑁆𑀘𑀼𑀧𑀝𑁆𑀞𑀺𑀢𑁄, 𑀭𑀸𑀚𑀸 𑀯𑀸 𑀫𑀸𑀕𑀥𑁄 𑀲𑁂𑀦𑀺𑀬𑁄 𑀩𑀺𑀫𑁆𑀩𑀺𑀲𑀸𑀭𑁄 𑀦𑀺𑀫𑀦𑁆𑀢𑀺𑀢𑁄 𑀲𑁆𑀯𑀸𑀢𑀦𑀸𑀬 𑀲𑀤𑁆𑀥𑀺𑀁 𑀩𑀮𑀓𑀸𑀬𑁂𑀦𑀸’’𑀢𑀺?

‘‘𑀦 𑀫𑁂, 𑀪𑁄 𑀲𑁂𑀮, 𑀆𑀯𑀸𑀳𑁄 𑀯𑀸 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺 𑀯𑀺𑀯𑀸𑀳𑁄 𑀯𑀸, 𑀦𑀸𑀧𑀺 𑀭𑀸𑀚𑀸 𑀫𑀸𑀕𑀥𑁄 𑀲𑁂𑀦𑀺𑀬𑁄 𑀩𑀺𑀫𑁆𑀩𑀺𑀲𑀸𑀭𑁄 𑀦𑀺𑀫𑀦𑁆𑀢𑀺𑀢𑁄 𑀲𑁆𑀯𑀸𑀢𑀦𑀸𑀬 𑀲𑀤𑁆𑀥𑀺𑀁 𑀩𑀮𑀓𑀸𑀬𑁂𑀦; 𑀅𑀧𑀺 𑀘 𑀔𑁄 𑀫𑁂 𑀫𑀳𑀸𑀬𑀜𑁆𑀜𑁄 𑀧𑀘𑁆𑀘𑀼𑀧𑀝𑁆𑀞𑀺𑀢𑁄. 𑀅𑀢𑁆𑀣𑀺 𑀲𑀫𑀡𑁄 𑀕𑁄𑀢𑀫𑁄 𑀲𑀓𑁆𑀬𑀧𑀼𑀢𑁆𑀢𑁄 𑀲𑀓𑁆𑀬𑀓𑀼𑀮𑀸 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄 𑀅𑀗𑁆𑀕𑀼𑀢𑁆𑀢𑀭𑀸𑀧𑁂𑀲𑀼 𑀘𑀸𑀭𑀺𑀓𑀁 ¶ 𑀘𑀭𑀫𑀸𑀦𑁄 𑀫𑀳𑀢𑀸 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦 𑀲𑀤𑁆𑀥𑀺𑀁 𑀅𑀟𑁆𑀠𑀢𑁂𑀴𑀲𑁂𑀳𑀺 ¶ 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀢𑁂𑀳𑀺 𑀆𑀧𑀡𑀁 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁄. 𑀢𑀁 𑀔𑁄 𑀧𑀦 ¶ 𑀪𑀯𑀦𑁆𑀢𑀁 𑀕𑁄𑀢𑀫𑀁…𑀧𑁂… 𑀩𑀼𑀤𑁆𑀥𑁄 𑀪𑀕𑀯𑀸𑀢𑀺. 𑀲𑁄 𑀫𑁂 𑀦𑀺𑀫𑀦𑁆𑀢𑀺𑀢𑁄 𑀲𑁆𑀯𑀸𑀢𑀦𑀸𑀬 𑀪𑀢𑁆𑀢𑀁 𑀲𑀤𑁆𑀥𑀺𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦𑀸’’𑀢𑀺. ‘‘𑀩𑀼𑀤𑁆𑀥𑁄𑀢𑀺, 𑀪𑁄 𑀓𑁂𑀡𑀺𑀬, 𑀯𑀤𑁂𑀲𑀺’’? ‘‘𑀩𑀼𑀤𑁆𑀥𑁄𑀢𑀺, 𑀪𑁄 𑀲𑁂𑀮, 𑀯𑀤𑀸𑀫𑀺’’. ‘‘𑀩𑀼𑀤𑁆𑀥𑁄𑀢𑀺, 𑀪𑁄 𑀓𑁂𑀡𑀺𑀬, 𑀯𑀤𑁂𑀲𑀺’’? ‘‘𑀩𑀼𑀤𑁆𑀥𑁄𑀢𑀺, 𑀪𑁄 𑀲𑁂𑀮, 𑀯𑀤𑀸𑀫𑀻’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑁂𑀮𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀖𑁄𑀲𑁄𑀧𑀺 𑀔𑁄 𑀏𑀲𑁄 𑀤𑀼𑀮𑁆𑀮𑀪𑁄 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀬𑀤𑀺𑀤𑀁 𑀩𑀼𑀤𑁆𑀥𑁄𑀢𑀺. 𑀆𑀕𑀢𑀸𑀦𑀺 𑀔𑁄 𑀧𑀦𑀫𑁆𑀳𑀸𑀓𑀁 𑀫𑀦𑁆𑀢𑁂𑀲𑀼 𑀤𑁆𑀯𑀢𑁆𑀢𑀺𑀁𑀲𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑀸𑀦𑀺, 𑀬𑁂𑀳𑀺 𑀲𑀫𑀦𑁆𑀦𑀸𑀕𑀢𑀲𑁆𑀲 𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 𑀤𑁆𑀯𑁂𑀯 𑀕𑀢𑀺𑀬𑁄 𑀪𑀯𑀦𑁆𑀢𑀺 𑀅𑀦𑀜𑁆𑀜𑀸. 𑀲𑀘𑁂 𑀅𑀕𑀸𑀭𑀁 𑀅𑀚𑁆𑀛𑀸𑀯𑀲𑀢𑀺 𑀭𑀸𑀚𑀸 𑀳𑁄𑀢𑀺 𑀘𑀓𑁆𑀓𑀯𑀢𑁆𑀢𑀺 𑀥𑀫𑁆𑀫𑀺𑀓𑁄 𑀥𑀫𑁆𑀫𑀭𑀸𑀚𑀸 𑀘𑀸𑀢𑀼𑀭𑀦𑁆𑀢𑁄 𑀯𑀺𑀚𑀺𑀢𑀸𑀯𑀻 𑀚𑀦𑀧𑀤𑀢𑁆𑀣𑀸𑀯𑀭𑀺𑀬𑀧𑁆𑀧𑀢𑁆𑀢𑁄 𑀲𑀢𑁆𑀢𑀭𑀢𑀦𑀲𑀫𑀦𑁆𑀦𑀸𑀕𑀢𑁄. 𑀢𑀲𑁆𑀲𑀺𑀫𑀸𑀦𑀺 𑀲𑀢𑁆𑀢 𑀭𑀢𑀦𑀸𑀦𑀺 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀲𑁂𑀬𑁆𑀬𑀣𑀺𑀤𑀁 𑁋 𑀘𑀓𑁆𑀓𑀭𑀢𑀦𑀁, 𑀳𑀢𑁆𑀣𑀺𑀭𑀢𑀦𑀁, 𑀅𑀲𑁆𑀲𑀭𑀢𑀦𑀁, 𑀫𑀡𑀺𑀭𑀢𑀦𑀁, 𑀇𑀢𑁆𑀣𑀺𑀭𑀢𑀦𑀁, 𑀕𑀳𑀧𑀢𑀺𑀭𑀢𑀦𑀁, 𑀧𑀭𑀺𑀡𑀸𑀬𑀓𑀭𑀢𑀦𑀫𑁂𑀯 𑀲𑀢𑁆𑀢𑀫𑀁. 𑀧𑀭𑁄𑀲𑀳𑀲𑁆𑀲𑀁 𑀔𑁄 𑀧𑀦𑀲𑁆𑀲 𑀧𑀼𑀢𑁆𑀢𑀸 𑀪𑀯𑀦𑁆𑀢𑀺 𑀲𑀽𑀭𑀸 𑀯𑀻𑀭𑀗𑁆𑀕𑀭𑀽𑀧𑀸 𑀧𑀭𑀲𑁂𑀦𑀧𑁆𑀧𑀫𑀤𑁆𑀤𑀦𑀸. 𑀲𑁄 𑀇𑀫𑀁 𑀧𑀣𑀯𑀺𑀁 𑀲𑀸𑀕𑀭𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀁 𑀅𑀤𑀡𑁆𑀟𑁂𑀦 𑀅𑀲𑀢𑁆𑀣𑁂𑀦 𑀥𑀫𑁆𑀫𑁂𑀦 𑀅𑀪𑀺𑀯𑀺𑀚𑀺𑀬 𑀅𑀚𑁆𑀛𑀸𑀯𑀲𑀢𑀺. 𑀲𑀘𑁂 𑀔𑁄 𑀧𑀦 𑀅𑀕𑀸𑀭𑀲𑁆𑀫𑀸 𑀅𑀦𑀕𑀸𑀭𑀺𑀬𑀁 𑀧𑀩𑁆𑀩𑀚𑀢𑀺, 𑀅𑀭𑀳𑀁 𑀳𑁄𑀢𑀺 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄 𑀮𑁄𑀓𑁂 𑀯𑀺𑀯𑀝𑁆𑀝𑀘𑁆𑀙𑀤𑁄 [𑀯𑀺𑀯𑀢𑁆𑀢𑀘𑁆𑀙𑀤𑁆𑀤𑁄 (𑀲𑀻. 𑀧𑀻.)]. 𑀓𑀳𑀁 𑀧𑀦, 𑀪𑁄 𑀓𑁂𑀡𑀺𑀬, 𑀏𑀢𑀭𑀳𑀺 𑀲𑁄 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀯𑀺𑀳𑀭𑀢𑀺 ¶ 𑀅𑀭𑀳𑀁 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄’’𑀢𑀺?

𑀏𑀯𑀁 ¶ 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀩𑀸𑀳𑀼𑀁 𑀧𑀕𑁆𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀲𑁂𑀮𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀬𑁂𑀦𑁂𑀲𑀸 ¶ , 𑀪𑁄 𑀲𑁂𑀮, 𑀦𑀻𑀮𑀯𑀦𑀭𑀸𑀚𑀻’’𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀢𑀻𑀳𑀺 𑀫𑀸𑀡𑀯𑀓𑀲𑀢𑁂𑀳𑀺 𑀲𑀤𑁆𑀥𑀺𑀁 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀢𑁂 𑀫𑀸𑀡𑀯𑀓𑁂 𑀆𑀫𑀦𑁆𑀢𑁂𑀲𑀺 𑁋 ‘‘𑀅𑀧𑁆𑀧𑀲𑀤𑁆𑀤𑀸 𑀪𑁄𑀦𑁆𑀢𑁄 𑀆𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀼, 𑀧𑀤𑁂 𑀧𑀤𑀁 𑀦𑀺𑀓𑁆𑀔𑀺𑀧𑀦𑁆𑀢𑀸. 𑀤𑀼𑀭𑀸𑀲𑀤𑀸 𑀳𑀺 𑀢𑁂 𑀪𑀕𑀯𑀦𑁆𑀢𑁄 [𑀪𑀯𑀦𑁆𑀢𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀲𑀻𑀳𑀸𑀯 𑀏𑀓𑀘𑀭𑀸. 𑀬𑀤𑀸 𑀘𑀸𑀳𑀁, 𑀪𑁄, 𑀲𑀫𑀡𑁂𑀦 𑀕𑁄𑀢𑀫𑁂𑀦 𑀲𑀤𑁆𑀥𑀺𑀁 𑀫𑀦𑁆𑀢𑁂𑀬𑁆𑀬𑀼𑀁, 𑀫𑀸 𑀫𑁂 𑀪𑁄𑀦𑁆𑀢𑁄 𑀅𑀦𑁆𑀢𑀭𑀦𑁆𑀢𑀭𑀸 𑀓𑀣𑀁 𑀑𑀧𑀸𑀢𑁂𑀣; 𑀓𑀣𑀸𑀧𑀭𑀺𑀬𑁄𑀲𑀸𑀦𑀁 𑀫𑁂 𑀪𑀯𑀦𑁆𑀢𑁄 𑀆𑀕𑀫𑁂𑀦𑁆𑀢𑀽’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑀸 𑀲𑀤𑁆𑀥𑀺𑀁 𑀲𑀫𑁆𑀫𑁄𑀤𑀺. 𑀲𑀫𑁆𑀫𑁄𑀤𑀦𑀻𑀬𑀁 𑀓𑀣𑀁 𑀲𑀸𑀭𑀡𑀻𑀬𑀁 𑀯𑀻𑀢𑀺𑀲𑀸𑀭𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀢𑁄 ¶ 𑀓𑀸𑀬𑁂 𑀤𑁆𑀯𑀢𑁆𑀢𑀺𑀁𑀲𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑀸𑀦𑀺 𑀲𑀫𑀦𑁆𑀦𑁂𑀲𑀺 [𑀲𑀫𑁆𑀫𑀦𑁆𑀦𑁂𑀲𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)]. 𑀅𑀤𑁆𑀤𑀲𑀸 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀢𑁄 𑀓𑀸𑀬𑁂 𑀤𑁆𑀯𑀢𑁆𑀢𑀺𑀁𑀲𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑀸𑀦𑀺 𑀬𑁂𑀪𑀼𑀬𑁆𑀬𑁂𑀦 𑀞𑀧𑁂𑀢𑁆𑀯𑀸 𑀤𑁆𑀯𑁂. 𑀤𑁆𑀯𑀻𑀲𑀼 𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑁂𑀲𑀼 𑀓𑀗𑁆𑀔𑀢𑀺 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀢𑀺 𑀦𑀸𑀥𑀺𑀫𑀼𑀘𑁆𑀘𑀢𑀺 𑀦 𑀲𑀫𑁆𑀧𑀲𑀻𑀤𑀢𑀺 𑁋 𑀓𑁄𑀲𑁄𑀳𑀺𑀢𑁂 𑀘 𑀯𑀢𑁆𑀣𑀕𑀼𑀬𑁆𑀳𑁂, 𑀧𑀳𑀽𑀢𑀚𑀺𑀯𑁆𑀳𑀢𑀸𑀬 𑀘𑀸𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀢𑁄 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀧𑀲𑁆𑀲𑀢𑀺 𑀔𑁄 𑀫𑁂 𑀅𑀬𑀁 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀤𑁆𑀯𑀢𑁆𑀢𑀺𑀁𑀲𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑀸𑀦𑀺 𑀬𑁂𑀪𑀼𑀬𑁆𑀬𑁂𑀦 𑀞𑀧𑁂𑀢𑁆𑀯𑀸 𑀤𑁆𑀯𑁂. 𑀤𑁆𑀯𑀻𑀲𑀼 𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑁂𑀲𑀼 𑀓𑀗𑁆𑀔𑀢𑀺 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀢𑀺 𑀦𑀸𑀥𑀺𑀫𑀼𑀘𑁆𑀘𑀢𑀺 𑀦 𑀲𑀫𑁆𑀧𑀲𑀻𑀤𑀢𑀺 𑁋 𑀓𑁄𑀲𑁄𑀳𑀺𑀢𑁂 𑀘 𑀯𑀢𑁆𑀣𑀕𑀼𑀬𑁆𑀳𑁂, 𑀧𑀳𑀽𑀢𑀚𑀺𑀯𑁆𑀳𑀢𑀸𑀬 ¶ 𑀘𑀸’’𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀢𑀣𑀸𑀭𑀽𑀧𑀁 𑀇𑀤𑁆𑀥𑀸𑀪𑀺𑀲𑀗𑁆𑀔𑀸𑀭𑀁 𑀅𑀪𑀺𑀲𑀗𑁆𑀔𑀸𑀲𑀺 [𑀅𑀪𑀺𑀲𑀗𑁆𑀔𑀸𑀭𑁂𑀲𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀬𑀣𑀸 𑀅𑀤𑁆𑀤𑀲 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀢𑁄 𑀓𑁄𑀲𑁄𑀳𑀺𑀢𑀁 𑀯𑀢𑁆𑀣𑀕𑀼𑀬𑁆𑀳𑀁 ¶ . 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀚𑀺𑀯𑁆𑀳𑀁 𑀦𑀺𑀦𑁆𑀦𑀸𑀫𑁂𑀢𑁆𑀯𑀸 𑀉𑀪𑁄𑀧𑀺 𑀓𑀡𑁆𑀡𑀲𑁄𑀢𑀸𑀦𑀺 𑀅𑀦𑀼𑀫𑀲𑀺 𑀧𑀝𑀺𑀫𑀲𑀺, 𑀉𑀪𑁄𑀧𑀺 𑀦𑀸𑀲𑀺𑀓𑀲𑁄𑀢𑀸𑀦𑀺 𑀅𑀦𑀼𑀫𑀲𑀺 𑀧𑀝𑀺𑀫𑀲𑀺, 𑀓𑁂𑀯𑀮𑀫𑁆𑀧𑀺 𑀦𑀮𑀸𑀝𑀫𑀡𑁆𑀟𑀮𑀁 𑀚𑀺𑀯𑁆𑀳𑀸𑀬 𑀙𑀸𑀤𑁂𑀲𑀺.

𑀅𑀣 𑀔𑁄 𑀲𑁂𑀮𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀏𑀢𑀤𑀳𑁄𑀲𑀺 𑁋 ‘‘𑀲𑀫𑀦𑁆𑀦𑀸𑀕𑀢𑁄 𑀔𑁄 𑀲𑀫𑀡𑁄 𑀕𑁄𑀢𑀫𑁄 𑀤𑁆𑀯𑀢𑁆𑀢𑀺𑀁𑀲𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑁂𑀳𑀺 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑁂𑀳𑀺, 𑀦𑁄 𑀅𑀧𑀼𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑁂𑀳𑀺. 𑀦𑁄 𑀘 𑀔𑁄 𑀦𑀁 𑀚𑀸𑀦𑀸𑀫𑀺 𑀩𑀼𑀤𑁆𑀥𑁄 𑀯𑀸 𑀦𑁄 𑀯𑀸. 𑀲𑀼𑀢𑀁 𑀔𑁄 𑀧𑀦 𑀫𑁂𑀢𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀯𑀼𑀟𑁆𑀠𑀸𑀦𑀁 𑀫𑀳𑀮𑁆𑀮𑀓𑀸𑀦𑀁 𑀆𑀘𑀭𑀺𑀬𑀧𑀸𑀘𑀭𑀺𑀬𑀸𑀦𑀁 𑀪𑀸𑀲𑀫𑀸𑀦𑀸𑀦𑀁 𑁋 ‘𑀬𑁂 𑀢𑁂 𑀪𑀯𑀦𑁆𑀢𑀺 𑀅𑀭𑀳𑀦𑁆𑀢𑁄 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀸, 𑀢𑁂 𑀲𑀓𑁂 𑀯𑀡𑁆𑀡𑁂 𑀪𑀜𑁆𑀜𑀫𑀸𑀦𑁂 𑀅𑀢𑁆𑀢𑀸𑀦𑀁 𑀧𑀸𑀢𑀼𑀓𑀭𑁄𑀦𑁆𑀢𑀻’𑀢𑀺. 𑀬𑀁𑀦𑀽𑀦𑀸𑀳𑀁 𑀲𑀫𑀡𑀁 𑀕𑁄𑀢𑀫𑀁 𑀲𑀫𑁆𑀫𑀼𑀔𑀸 𑀲𑀸𑀭𑀼𑀧𑁆𑀧𑀸𑀳𑀺 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀪𑀺𑀢𑁆𑀣𑀯𑁂𑀬𑁆𑀬’’𑀦𑁆𑀢𑀺. 𑀅𑀣 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀲𑀫𑁆𑀫𑀼𑀔𑀸 𑀲𑀸𑀭𑀼𑀧𑁆𑀧𑀸𑀳𑀺 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀪𑀺𑀢𑁆𑀣𑀯𑀺 𑁋

‘‘𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀓𑀸𑀬𑁄 𑀲𑀼𑀭𑀼𑀘𑀺, 𑀲𑀼𑀚𑀸𑀢𑁄 𑀘𑀸𑀭𑀼𑀤𑀲𑁆𑀲𑀦𑁄;

𑀲𑀼𑀯𑀡𑁆𑀡𑀯𑀡𑁆𑀡𑁄𑀲𑀺 𑀪𑀕𑀯𑀸, 𑀲𑀼𑀲𑀼𑀓𑁆𑀓𑀤𑀸𑀞𑁄𑀲𑀺 𑀯𑀻𑀭𑀺𑀬𑀯𑀸.

‘‘𑀦𑀭𑀲𑁆𑀲 ¶ 𑀳𑀺 𑀲𑀼𑀚𑀸𑀢𑀲𑁆𑀲, 𑀬𑁂 𑀪𑀯𑀦𑁆𑀢𑀺 𑀯𑀺𑀬𑀜𑁆𑀚𑀦𑀸;

𑀲𑀩𑁆𑀩𑁂 𑀢𑁂 𑀢𑀯 𑀓𑀸𑀬𑀲𑁆𑀫𑀺𑀁, 𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑀸.

‘‘𑀧𑀲𑀦𑁆𑀦𑀦𑁂𑀢𑁆𑀢𑁄 𑀲𑀼𑀫𑀼𑀔𑁄, 𑀩𑁆𑀭𑀳𑀸 𑀉𑀚𑀼 𑀧𑀢𑀸𑀧𑀯𑀸;

𑀫𑀚𑁆𑀛𑁂 ¶ 𑀲𑀫𑀡𑀲𑀗𑁆𑀖𑀲𑁆𑀲, 𑀆𑀤𑀺𑀘𑁆𑀘𑁄𑀯 𑀯𑀺𑀭𑁄𑀘𑀲𑀺.

‘‘𑀓𑀮𑁆𑀬𑀸𑀡𑀤𑀲𑁆𑀲𑀦𑁄 ¶ 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀓𑀜𑁆𑀘𑀦𑀲𑀦𑁆𑀦𑀺𑀪𑀢𑁆𑀢𑀘𑁄;

𑀓𑀺𑀁 𑀢𑁂 𑀲𑀫𑀡𑀪𑀸𑀯𑁂𑀦, 𑀏𑀯𑀁 𑀉𑀢𑁆𑀢𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑁄.

‘‘𑀭𑀸𑀚𑀸 𑀅𑀭𑀳𑀲𑀺 𑀪𑀯𑀺𑀢𑀼𑀁, 𑀘𑀓𑁆𑀓𑀯𑀢𑁆𑀢𑀻 𑀭𑀣𑁂𑀲𑀪𑁄;

𑀘𑀸𑀢𑀼𑀭𑀦𑁆𑀢𑁄 𑀯𑀺𑀚𑀺𑀢𑀸𑀯𑀻, 𑀚𑀫𑁆𑀩𑀼𑀲𑀡𑁆𑀟𑀲𑁆𑀲 [𑀚𑀫𑁆𑀩𑀼𑀫𑀡𑁆𑀟𑀲𑁆𑀲 (𑀓.)] 𑀇𑀲𑁆𑀲𑀭𑁄.

‘‘𑀔𑀢𑁆𑀢𑀺𑀬𑀸 ¶ 𑀪𑁄𑀕𑀺𑀭𑀸𑀚𑀸𑀦𑁄 [𑀪𑁄𑀚𑀭𑀸𑀚𑀸𑀦𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀅𑀦𑀼𑀬𑀦𑁆𑀢𑀸 [𑀅𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑀸 (𑀲𑀻.)] 𑀪𑀯𑀦𑁆𑀢𑀼 𑀢𑁂;

𑀭𑀸𑀚𑀸𑀪𑀺𑀭𑀸𑀚𑀸 𑀫𑀦𑀼𑀚𑀺𑀦𑁆𑀤𑁄, 𑀭𑀚𑁆𑀚𑀁 𑀓𑀸𑀭𑁂𑀳𑀺 𑀕𑁄𑀢𑀫’’.

‘‘𑀭𑀸𑀚𑀸𑀳𑀫𑀲𑁆𑀫𑀺 𑀲𑁂𑀮𑀸𑀢𑀺, (𑀪𑀕𑀯𑀸) 𑀥𑀫𑁆𑀫𑀭𑀸𑀚𑀸 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑁄;

𑀥𑀫𑁆𑀫𑁂𑀦 𑀘𑀓𑁆𑀓𑀁 𑀯𑀢𑁆𑀢𑁂𑀫𑀺, 𑀘𑀓𑁆𑀓𑀁 𑀅𑀧𑁆𑀧𑀝𑀺𑀯𑀢𑁆𑀢𑀺𑀬𑀁’’.

‘‘𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄 𑀧𑀝𑀺𑀚𑀸𑀦𑀸𑀲𑀺, (𑀇𑀢𑀺 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄) 𑀥𑀫𑁆𑀫𑀭𑀸𑀚𑀸 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑁄;

‘𑀥𑀫𑁆𑀫𑁂𑀦 𑀘𑀓𑁆𑀓𑀁 𑀯𑀢𑁆𑀢𑁂𑀫𑀺’, 𑀇𑀢𑀺 𑀪𑀸𑀲𑀲𑀺 𑀕𑁄𑀢𑀫.

‘‘𑀓𑁄 𑀦𑀼 𑀲𑁂𑀦𑀸𑀧𑀢𑀺 𑀪𑁄𑀢𑁄, 𑀲𑀸𑀯𑀓𑁄 𑀲𑀢𑁆𑀣𑀼𑀭𑀦𑁆𑀯𑀬𑁄;

𑀓𑁄 𑀢𑁂 𑀢𑀫𑀦𑀼𑀯𑀢𑁆𑀢𑁂𑀢𑀺, 𑀥𑀫𑁆𑀫𑀘𑀓𑁆𑀓𑀁 𑀧𑀯𑀢𑁆𑀢𑀺𑀢𑀁’’.

‘‘𑀫𑀬𑀸 𑀧𑀯𑀢𑁆𑀢𑀺𑀢𑀁 𑀘𑀓𑁆𑀓𑀁, (𑀲𑁂𑀮𑀸𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀥𑀫𑁆𑀫𑀘𑀓𑁆𑀓𑀁 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑀁;

𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀦𑀼𑀯𑀢𑁆𑀢𑁂𑀢𑀺, 𑀅𑀦𑀼𑀚𑀸𑀢𑁄 𑀢𑀣𑀸𑀕𑀢𑀁.

‘‘𑀅𑀪𑀺𑀜𑁆𑀜𑁂𑀬𑁆𑀬𑀁 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀢𑀁, 𑀪𑀸𑀯𑁂𑀢𑀩𑁆𑀩𑀜𑁆𑀘 𑀪𑀸𑀯𑀺𑀢𑀁;

𑀧𑀳𑀸𑀢𑀩𑁆𑀩𑀁 𑀧𑀳𑀻𑀦𑀁 𑀫𑁂, 𑀢𑀲𑁆𑀫𑀸 𑀩𑀼𑀤𑁆𑀥𑁄𑀲𑁆𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡.

‘‘𑀯𑀺𑀦𑀬𑀲𑁆𑀲𑀼 ¶ 𑀫𑀬𑀺 𑀓𑀗𑁆𑀔𑀁, 𑀅𑀥𑀺𑀫𑀼𑀘𑁆𑀘𑀲𑁆𑀲𑀼 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡;

𑀤𑀼𑀮𑁆𑀮𑀪𑀁 𑀤𑀲𑁆𑀲𑀦𑀁 𑀳𑁄𑀢𑀺, 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀸𑀦𑀁 𑀅𑀪𑀺𑀡𑁆𑀳𑀲𑁄.

‘‘𑀬𑁂𑀲𑀁 ¶ ¶ ¶ 𑀯𑁂 [𑀬𑁂𑀲𑀁 𑀯𑁄 (𑀧𑀻.), 𑀬𑀲𑁆𑀲 𑀯𑁂 (𑀲𑁆𑀬𑀸.)] 𑀤𑀼𑀮𑁆𑀮𑀪𑁄 𑀮𑁄𑀓𑁂, 𑀧𑀸𑀢𑀼𑀪𑀸𑀯𑁄 𑀅𑀪𑀺𑀡𑁆𑀳𑀲𑁄;

𑀲𑁄𑀳𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄, 𑀲𑀮𑁆𑀮𑀓𑀢𑁆𑀢𑁄 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑁄.

‘‘𑀩𑁆𑀭𑀳𑁆𑀫𑀪𑀽𑀢𑁄 𑀅𑀢𑀺𑀢𑀼𑀮𑁄, 𑀫𑀸𑀭𑀲𑁂𑀦𑀧𑁆𑀧𑀫𑀤𑁆𑀤𑀦𑁄;

𑀲𑀩𑁆𑀩𑀸𑀫𑀺𑀢𑁆𑀢𑁂 𑀯𑀲𑀻𑀓𑀢𑁆𑀯𑀸, 𑀫𑁄𑀤𑀸𑀫𑀺 𑀅𑀓𑀼𑀢𑁄𑀪𑀬𑁄’’.

‘‘𑀇𑀫𑀁 𑀪𑀯𑀦𑁆𑀢𑁄 𑀦𑀺𑀲𑀸𑀫𑁂𑀣, 𑀬𑀣𑀸 𑀪𑀸𑀲𑀢𑀺 𑀘𑀓𑁆𑀔𑀼𑀫𑀸;

𑀲𑀮𑁆𑀮𑀓𑀢𑁆𑀢𑁄 𑀫𑀳𑀸𑀯𑀻𑀭𑁄, 𑀲𑀻𑀳𑁄𑀯 𑀦𑀤𑀢𑀻 𑀯𑀦𑁂.

‘‘𑀩𑁆𑀭𑀳𑁆𑀫𑀪𑀽𑀢𑀁 𑀅𑀢𑀺𑀢𑀼𑀮𑀁, 𑀫𑀸𑀭𑀲𑁂𑀦𑀧𑁆𑀧𑀫𑀤𑁆𑀤𑀦𑀁;

𑀓𑁄 𑀤𑀺𑀲𑁆𑀯𑀸 𑀦𑀧𑁆𑀧𑀲𑀻𑀤𑁂𑀬𑁆𑀬, 𑀅𑀧𑀺 𑀓𑀡𑁆𑀳𑀸𑀪𑀺𑀚𑀸𑀢𑀺𑀓𑁄.

‘‘𑀬𑁄 𑀫𑀁 𑀇𑀘𑁆𑀙𑀢𑀺 𑀅𑀦𑁆𑀯𑁂𑀢𑀼, 𑀬𑁄 𑀯𑀸 𑀦𑀺𑀘𑁆𑀙𑀢𑀺 𑀕𑀘𑁆𑀙𑀢𑀼;

𑀇𑀥𑀸𑀳𑀁 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀯𑀭𑀧𑀜𑁆𑀜𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂’’.

‘‘𑀏𑀯𑀜𑁆𑀘𑁂 [𑀏𑀢𑀜𑁆𑀘𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀭𑀼𑀘𑁆𑀘𑀢𑀺 𑀪𑁄𑀢𑁄, 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀲𑀸𑀲𑀦𑁂 [𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀲𑀸𑀲𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓𑀁. 𑀧𑀻.)];

𑀫𑀬𑀫𑁆𑀧𑀺 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫, 𑀯𑀭𑀧𑀜𑁆𑀜𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂’’.

‘‘𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀢𑀺𑀲𑀢𑀸 𑀇𑀫𑁂, 𑀬𑀸𑀘𑀦𑁆𑀢𑀺 𑀧𑀜𑁆𑀚𑀮𑀻𑀓𑀢𑀸;

𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁 𑀘𑀭𑀺𑀲𑁆𑀲𑀸𑀫, 𑀪𑀕𑀯𑀸 𑀢𑀯 𑀲𑀦𑁆𑀢𑀺𑀓𑁂’’.

‘‘𑀲𑁆𑀯𑀸𑀓𑁆𑀔𑀸𑀢𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, (𑀲𑁂𑀮𑀸𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓𑀫𑀓𑀸𑀮𑀺𑀓𑀁;

𑀬𑀢𑁆𑀣 𑀅𑀫𑁄𑀖𑀸 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀸, 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀲𑁆𑀲 𑀲𑀺𑀓𑁆𑀔𑀢𑁄’’𑀢𑀺.

𑀅𑀮𑀢𑁆𑀣 𑀔𑁄 𑀲𑁂𑀮𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀲𑀧𑀭𑀺𑀲𑁄 𑀪𑀕𑀯𑀢𑁄 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁, 𑀅𑀮𑀢𑁆𑀣 𑀉𑀧𑀲𑀫𑁆𑀧𑀤𑀁. 𑀅𑀣 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀢𑀲𑁆𑀲𑀸 ¶ 𑀭𑀢𑁆𑀢𑀺𑀬𑀸 𑀅𑀘𑁆𑀘𑀬𑁂𑀦 𑀲𑀓𑁂 𑀅𑀲𑁆𑀲𑀫𑁂 𑀧𑀡𑀻𑀢𑀁 𑀔𑀸𑀤𑀦𑀻𑀬𑀁 𑀪𑁄𑀚𑀦𑀻𑀬𑀁 𑀧𑀝𑀺𑀬𑀸𑀤𑀸𑀧𑁂𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑁄 ¶ 𑀓𑀸𑀮𑀁 𑀆𑀭𑁄𑀘𑀸𑀧𑁂𑀲𑀺 𑁋 ‘‘𑀓𑀸𑀮𑁄, 𑀪𑁄 𑀕𑁄𑀢𑀫, 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁 𑀪𑀢𑁆𑀢’’𑀦𑁆𑀢𑀺 ¶ . 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀧𑀼𑀩𑁆𑀩𑀡𑁆𑀳𑀲𑀫𑀬𑀁 𑀦𑀺𑀯𑀸𑀲𑁂𑀢𑁆𑀯𑀸 𑀧𑀢𑁆𑀢𑀘𑀻𑀯𑀭𑀫𑀸𑀤𑀸𑀬 𑀬𑁂𑀦 𑀓𑁂𑀡𑀺𑀬𑀲𑁆𑀲 𑀚𑀝𑀺𑀮𑀲𑁆𑀲 𑀅𑀲𑁆𑀲𑀫𑁄 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀧𑀜𑁆𑀜𑀢𑁆𑀢𑁂 𑀆𑀲𑀦𑁂 𑀦𑀺𑀲𑀻𑀤𑀺 𑀲𑀤𑁆𑀥𑀺𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑁂𑀦.

𑀅𑀣 ¶ 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀩𑀼𑀤𑁆𑀥𑀧𑁆𑀧𑀫𑀼𑀔𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀁 𑀧𑀡𑀻𑀢𑁂𑀦 𑀔𑀸𑀤𑀦𑀻𑀬𑁂𑀦 𑀪𑁄𑀚𑀦𑀻𑀬𑁂𑀦 𑀲𑀳𑀢𑁆𑀣𑀸 𑀲𑀦𑁆𑀢𑀧𑁆𑀧𑁂𑀲𑀺 𑀲𑀫𑁆𑀧𑀯𑀸𑀭𑁂𑀲𑀺. 𑀅𑀣 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑁄 𑀚𑀝𑀺𑀮𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀪𑀼𑀢𑁆𑀢𑀸𑀯𑀺𑀁 𑀑𑀦𑀻𑀢𑀧𑀢𑁆𑀢𑀧𑀸𑀡𑀺𑀁 𑀅𑀜𑁆𑀜𑀢𑀭𑀁 𑀦𑀻𑀘𑀁 𑀆𑀲𑀦𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁 𑀔𑁄 𑀓𑁂𑀡𑀺𑀬𑀁 𑀚𑀝𑀺𑀮𑀁 𑀪𑀕𑀯𑀸 𑀇𑀫𑀸𑀳𑀺 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀦𑀼𑀫𑁄𑀤𑀺 𑁋

‘‘𑀅𑀕𑁆𑀕𑀺𑀳𑀼𑀢𑁆𑀢𑀫𑀼𑀔𑀸 𑀬𑀜𑁆𑀜𑀸, 𑀲𑀸𑀯𑀺𑀢𑁆𑀢𑀻 𑀙𑀦𑁆𑀤𑀲𑁄 𑀫𑀼𑀔𑀁;

𑀭𑀸𑀚𑀸 𑀫𑀼𑀔𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁, 𑀦𑀤𑀻𑀦𑀁 𑀲𑀸𑀕𑀭𑁄 𑀫𑀼𑀔𑀁.

‘‘𑀦𑀓𑁆𑀔𑀢𑁆𑀢𑀸𑀦𑀁 𑀫𑀼𑀔𑀁 𑀘𑀦𑁆𑀤𑁄, 𑀆𑀤𑀺𑀘𑁆𑀘𑁄 𑀢𑀧𑀢𑀁 𑀫𑀼𑀔𑀁;

𑀧𑀼𑀜𑁆𑀜𑀁 𑀆𑀓𑀗𑁆𑀔𑀫𑀸𑀦𑀸𑀦𑀁, 𑀲𑀗𑁆𑀖𑁄 𑀯𑁂 𑀬𑀚𑀢𑀁 𑀫𑀼𑀔’’𑀦𑁆𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀓𑁂𑀡𑀺𑀬𑀁 𑀚𑀝𑀺𑀮𑀁 𑀇𑀫𑀸𑀳𑀺 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀦𑀼𑀫𑁄𑀤𑀺𑀢𑁆𑀯𑀸 𑀉𑀝𑁆𑀞𑀸𑀬𑀸𑀲𑀦𑀸 𑀧𑀓𑁆𑀓𑀸𑀫𑀺. 𑀅𑀣 𑀔𑁄 𑀆𑀬𑀲𑁆𑀫𑀸 𑀲𑁂𑀮𑁄 𑀲𑀧𑀭𑀺𑀲𑁄 𑀏𑀓𑁄 𑀯𑀽𑀧𑀓𑀝𑁆𑀞𑁄 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄 𑀆𑀢𑀸𑀧𑀻 𑀧𑀳𑀺𑀢𑀢𑁆𑀢𑁄 𑀯𑀺𑀳𑀭𑀦𑁆𑀢𑁄 𑀦𑀘𑀺𑀭𑀲𑁆𑀲𑁂 ¶ …𑀧𑁂… ¶ 𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀔𑁄 𑀧𑀦𑀸𑀧𑀲𑁆𑀫𑀸 𑀲𑁂𑀮𑁄 𑀲𑀧𑀭𑀺𑀲𑁄 𑀅𑀭𑀳𑀢𑀁 𑀅𑀳𑁄𑀲𑀺.

𑀅𑀣 𑀔𑁄 𑀆𑀬𑀲𑁆𑀫𑀸 𑀲𑁂𑀮𑁄 𑀲𑀧𑀭𑀺𑀲𑁄 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺, 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀏𑀓𑀁𑀲𑀁 𑀘𑀻𑀯𑀭𑀁 𑀓𑀢𑁆𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀜𑁆𑀚𑀮𑀺𑀁 𑀧𑀡𑀸𑀫𑁂𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀬 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀬𑀁 𑀢𑀁 𑀲𑀭𑀡𑀫𑀸𑀕𑀫𑁆𑀳 [𑀫𑀸𑀕𑀫𑁆𑀫 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)], 𑀇𑀢𑁄 𑀅𑀝𑁆𑀞𑀫𑀺 𑀘𑀓𑁆𑀔𑀼𑀫;

𑀲𑀢𑁆𑀢𑀭𑀢𑁆𑀢𑁂𑀦 𑀪𑀕𑀯𑀸, 𑀤𑀦𑁆𑀢𑀫𑁆𑀳 𑀢𑀯 𑀲𑀸𑀲𑀦𑁂.

‘‘𑀢𑀼𑀯𑀁 𑀩𑀼𑀤𑁆𑀥𑁄 𑀢𑀼𑀯𑀁 𑀲𑀢𑁆𑀣𑀸, 𑀢𑀼𑀯𑀁 𑀫𑀸𑀭𑀸𑀪𑀺𑀪𑀽 𑀫𑀼𑀦𑀺;

𑀢𑀼𑀯𑀁 𑀅𑀦𑀼𑀲𑀬𑁂 𑀙𑁂𑀢𑁆𑀯𑀸, 𑀢𑀺𑀡𑁆𑀡𑁄 𑀢𑀸𑀭𑁂𑀲𑀺𑀫𑀁 𑀧𑀚𑀁.

‘‘𑀉𑀧𑀥𑀻 𑀢𑁂 𑀲𑀫𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀸, 𑀆𑀲𑀯𑀸 𑀢𑁂 𑀧𑀤𑀸𑀮𑀺𑀢𑀸;

𑀲𑀻𑀳𑁄𑀲𑀺 [𑀲𑀻𑀳𑁄𑀯 (𑀫. 𑀦𑀺. 𑁨.𑁪𑁦𑁧)] 𑀅𑀦𑀼𑀧𑀸𑀤𑀸𑀦𑁄, 𑀧𑀳𑀻𑀦𑀪𑀬𑀪𑁂𑀭𑀯𑁄.

‘‘𑀪𑀺𑀓𑁆𑀔𑀯𑁄 ¶ 𑀢𑀺𑀲𑀢𑀸 𑀇𑀫𑁂, 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺 𑀧𑀜𑁆𑀚𑀮𑀻𑀓𑀢𑀸;

𑀧𑀸𑀤𑁂 𑀯𑀻𑀭 𑀧𑀲𑀸𑀭𑁂𑀳𑀺, 𑀦𑀸𑀕𑀸 𑀯𑀦𑁆𑀤𑀦𑁆𑀢𑀼 𑀲𑀢𑁆𑀣𑀼𑀦𑁄’’𑀢𑀺.

𑀲𑁂𑀮𑀲𑀼𑀢𑁆𑀢𑀁 𑀲𑀢𑁆𑀢𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀅𑀦𑀺𑀫𑀺𑀢𑁆𑀢𑀫𑀦𑀜𑁆𑀜𑀸𑀢𑀁 ¶ , 𑀫𑀘𑁆𑀘𑀸𑀦𑀁 𑀇𑀥 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀓𑀲𑀺𑀭𑀜𑁆𑀘 𑀧𑀭𑀺𑀢𑁆𑀢𑀜𑁆𑀘, 𑀢𑀜𑁆𑀘 𑀤𑀼𑀓𑁆𑀔𑁂𑀦 𑀲𑀁𑀬𑀼𑀢𑀁.

𑀦 ¶ 𑀳𑀺 𑀲𑁄 𑀉𑀧𑀓𑁆𑀓𑀫𑁄 𑀅𑀢𑁆𑀣𑀺, 𑀬𑁂𑀦 𑀚𑀸𑀢𑀸 𑀦 𑀫𑀺𑀬𑁆𑀬𑀭𑁂;

𑀚𑀭𑀫𑁆𑀧𑀺 ¶ 𑀧𑀢𑁆𑀯𑀸 𑀫𑀭𑀡𑀁, 𑀏𑀯𑀁𑀥𑀫𑁆𑀫𑀸 𑀳𑀺 𑀧𑀸𑀡𑀺𑀦𑁄.

𑀨𑀮𑀸𑀦𑀫𑀺𑀯 𑀧𑀓𑁆𑀓𑀸𑀦𑀁, 𑀧𑀸𑀢𑁄 𑀧𑀢𑀦𑀢𑁄 [𑀧𑀧𑀢𑀢𑁄 (𑀲𑀻. 𑀧𑀻. 𑀅𑀝𑁆𑀞.)] 𑀪𑀬𑀁;

𑀏𑀯𑀁 𑀚𑀸𑀢𑀸𑀦 𑀫𑀘𑁆𑀘𑀸𑀦𑀁, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀫𑀭𑀡𑀢𑁄 𑀪𑀬𑀁.

𑀬𑀣𑀸𑀧𑀺 𑀓𑀼𑀫𑁆𑀪𑀓𑀸𑀭𑀲𑁆𑀲, 𑀓𑀢𑀸 𑀫𑀢𑁆𑀢𑀺𑀓𑀪𑀸𑀚𑀦𑀸;

𑀲𑀩𑁆𑀩𑁂 𑀪𑁂𑀤𑀦𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀸 [𑀪𑁂𑀤𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀸 (𑀲𑁆𑀬𑀸.)], 𑀏𑀯𑀁 𑀫𑀘𑁆𑀘𑀸𑀦 𑀚𑀻𑀯𑀺𑀢𑀁.

𑀤𑀳𑀭𑀸 𑀘 𑀫𑀳𑀦𑁆𑀢𑀸 𑀘, 𑀬𑁂 𑀩𑀸𑀮𑀸 𑀬𑁂 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

𑀲𑀩𑁆𑀩𑁂 𑀫𑀘𑁆𑀘𑀼𑀯𑀲𑀁 𑀬𑀦𑁆𑀢𑀺, 𑀲𑀩𑁆𑀩𑁂 𑀫𑀘𑁆𑀘𑀼𑀧𑀭𑀸𑀬𑀡𑀸.

𑀢𑁂𑀲𑀁 𑀫𑀘𑁆𑀘𑀼𑀧𑀭𑁂𑀢𑀸𑀦𑀁, 𑀕𑀘𑁆𑀙𑀢𑀁 𑀧𑀭𑀮𑁄𑀓𑀢𑁄;

𑀦 𑀧𑀺𑀢𑀸 𑀢𑀸𑀬𑀢𑁂 𑀧𑀼𑀢𑁆𑀢𑀁, 𑀜𑀸𑀢𑀻 𑀯𑀸 𑀧𑀦 𑀜𑀸𑀢𑀓𑁂.

𑀧𑁂𑀓𑁆𑀔𑀢𑀁 𑀬𑁂𑀯 𑀜𑀸𑀢𑀻𑀦𑀁, 𑀧𑀲𑁆𑀲 𑀮𑀸𑀮𑀧𑀢𑀁 𑀧𑀼𑀣𑀼;

𑀏𑀓𑀫𑁂𑀓𑁄𑀯 𑀫𑀘𑁆𑀘𑀸𑀦𑀁, 𑀕𑁄𑀯𑀚𑁆𑀛𑁄 𑀯𑀺𑀬 𑀦𑀻𑀬𑀢𑀺 [𑀦𑀺𑀬𑁆𑀬𑀢𑀺 (𑀩𑀳𑀽𑀲𑀼)].

𑀏𑀯𑀫𑀩𑁆𑀪𑀸𑀳𑀢𑁄 ¶ 𑀮𑁄𑀓𑁄, 𑀫𑀘𑁆𑀘𑀼𑀦𑀸 𑀘 𑀚𑀭𑀸𑀬 𑀘;

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

𑀬𑀲𑁆𑀲 𑀫𑀕𑁆𑀕𑀁 𑀦 𑀚𑀸𑀦𑀸𑀲𑀺, 𑀆𑀕𑀢𑀲𑁆𑀲 𑀕𑀢𑀲𑁆𑀲 𑀯𑀸;

𑀉𑀪𑁄 𑀅𑀦𑁆𑀢𑁂 𑀅𑀲𑀫𑁆𑀧𑀲𑁆𑀲𑀁, 𑀦𑀺𑀭𑀢𑁆𑀣𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀲𑀺.

𑀧𑀭𑀺𑀤𑁂𑀯𑀬𑀫𑀸𑀦𑁄 𑀘𑁂, 𑀓𑀺𑀜𑁆𑀘𑀺𑀤𑀢𑁆𑀣𑀁 𑀉𑀤𑀩𑁆𑀩𑀳𑁂;

𑀲𑀫𑁆𑀫𑀽𑀴𑁆𑀳𑁄 𑀳𑀺𑀁𑀲𑀫𑀢𑁆𑀢𑀸𑀦𑀁, 𑀓𑀬𑀺𑀭𑀸 𑀘𑁂 𑀦𑀁 𑀯𑀺𑀘𑀓𑁆𑀔𑀡𑁄.

𑀦 𑀳𑀺 𑀭𑀼𑀡𑁆𑀡𑁂𑀦 𑀲𑁄𑀓𑁂𑀦, 𑀲𑀦𑁆𑀢𑀺𑀁 𑀧𑀧𑁆𑀧𑁄𑀢𑀺 𑀘𑁂𑀢𑀲𑁄;

𑀪𑀺𑀬𑁆𑀬𑀲𑁆𑀲𑀼𑀧𑁆𑀧𑀚𑁆𑀚𑀢𑁂 𑀤𑀼𑀓𑁆𑀔𑀁, 𑀲𑀭𑀻𑀭𑀁 𑀘𑀼𑀧𑀳𑀜𑁆𑀜𑀢𑀺.

𑀓𑀺𑀲𑁄 ¶ 𑀯𑀺𑀯𑀡𑁆𑀡𑁄 𑀪𑀯𑀢𑀺, 𑀳𑀺𑀁𑀲𑀫𑀢𑁆𑀢𑀸𑀦𑀫𑀢𑁆𑀢𑀦𑀸;

𑀦 ¶ 𑀢𑁂𑀦 𑀧𑁂𑀢𑀸 𑀧𑀸𑀮𑁂𑀦𑁆𑀢𑀺, 𑀦𑀺𑀭𑀢𑁆𑀣𑀸 𑀧𑀭𑀺𑀤𑁂𑀯𑀦𑀸.

𑀲𑁄𑀓𑀫𑀧𑁆𑀧𑀚𑀳𑀁 ¶ 𑀚𑀦𑁆𑀢𑀼, 𑀪𑀺𑀬𑁆𑀬𑁄 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀢𑀺;

𑀅𑀦𑀼𑀢𑁆𑀣𑀼𑀦𑀦𑁆𑀢𑁄 𑀓𑀸𑀮𑀗𑁆𑀓𑀢𑀁 [𑀓𑀸𑀮𑀓𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀲𑁄𑀓𑀲𑁆𑀲 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀽.

𑀅𑀜𑁆𑀜𑁂𑀧𑀺 𑀧𑀲𑁆𑀲 𑀕𑀫𑀺𑀦𑁂, 𑀬𑀣𑀸𑀓𑀫𑁆𑀫𑀽𑀧𑀕𑁂 𑀦𑀭𑁂;

𑀫𑀘𑁆𑀘𑀼𑀦𑁄 𑀯𑀲𑀫𑀸𑀕𑀫𑁆𑀫, 𑀨𑀦𑁆𑀤𑀦𑁆𑀢𑁂𑀯𑀺𑀥 𑀧𑀸𑀡𑀺𑀦𑁄.

𑀬𑁂𑀦 𑀬𑁂𑀦 𑀳𑀺 𑀫𑀜𑁆𑀜𑀦𑁆𑀢𑀺, 𑀢𑀢𑁄 𑀢𑀁 𑀳𑁄𑀢𑀺 𑀅𑀜𑁆𑀜𑀣𑀸;

𑀏𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀺𑀦𑀸𑀪𑀸𑀯𑁄, 𑀧𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲 𑀧𑀭𑀺𑀬𑀸𑀬𑀁.

𑀅𑀧𑀺 𑀯𑀲𑁆𑀲𑀲𑀢𑀁 𑀚𑀻𑀯𑁂, 𑀪𑀺𑀬𑁆𑀬𑁄 𑀯𑀸 𑀧𑀦 𑀫𑀸𑀡𑀯𑁄;

𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑀸 𑀯𑀺𑀦𑀸 𑀳𑁄𑀢𑀺, 𑀚𑀳𑀸𑀢𑀺 𑀇𑀥 𑀚𑀻𑀯𑀺𑀢𑀁.

𑀢𑀲𑁆𑀫𑀸 𑀅𑀭𑀳𑀢𑁄 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀧𑀭𑀺𑀤𑁂𑀯𑀺𑀢𑀁;

𑀧𑁂𑀢𑀁 𑀓𑀸𑀮𑀗𑁆𑀓𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀦𑁂𑀲𑁄 𑀮𑀩𑁆𑀪𑀸 𑀫𑀬𑀸 𑀇𑀢𑀺.

𑀬𑀣𑀸 ¶ 𑀲𑀭𑀡𑀫𑀸𑀤𑀺𑀢𑁆𑀢𑀁, 𑀯𑀸𑀭𑀺𑀦𑀸 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀬𑁂 [𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 (𑀲𑀻. 𑀓.)];

𑀏𑀯𑀫𑁆𑀧𑀺 𑀥𑀻𑀭𑁄 𑀲𑀧𑀜𑁆𑀜𑁄, 𑀧𑀡𑁆𑀟𑀺𑀢𑁄 𑀓𑀼𑀲𑀮𑁄 𑀦𑀭𑁄;

𑀔𑀺𑀧𑁆𑀧𑀫𑀼𑀧𑁆𑀧𑀢𑀺𑀢𑀁 𑀲𑁄𑀓𑀁, 𑀯𑀸𑀢𑁄 𑀢𑀽𑀮𑀁𑀯 𑀥𑀁𑀲𑀬𑁂.

𑀧𑀭𑀺𑀤𑁂𑀯𑀁 𑀧𑀚𑀧𑁆𑀧𑀜𑁆𑀘, 𑀤𑁄𑀫𑀦𑀲𑁆𑀲𑀜𑁆𑀘 𑀅𑀢𑁆𑀢𑀦𑁄;

𑀅𑀢𑁆𑀢𑀦𑁄 𑀲𑀼𑀔𑀫𑁂𑀲𑀸𑀦𑁄, 𑀅𑀩𑁆𑀩𑀳𑁂 𑀲𑀮𑁆𑀮𑀫𑀢𑁆𑀢𑀦𑁄.

𑀅𑀩𑁆𑀩𑀼𑀴𑁆𑀳𑀲𑀮𑁆𑀮𑁄 𑀅𑀲𑀺𑀢𑁄, 𑀲𑀦𑁆𑀢𑀺𑀁 𑀧𑀧𑁆𑀧𑀼𑀬𑁆𑀬 𑀘𑁂𑀢𑀲𑁄;

𑀲𑀩𑁆𑀩𑀲𑁄𑀓𑀁 𑀅𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁄, 𑀅𑀲𑁄𑀓𑁄 𑀳𑁄𑀢𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄𑀢𑀺.

𑀲𑀮𑁆𑀮𑀲𑀼𑀢𑁆𑀢𑀁 𑀅𑀝𑁆𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀇𑀘𑁆𑀙𑀸𑀦𑀗𑁆𑀕𑀮𑁂 𑀯𑀺𑀳𑀭𑀢𑀺 𑀇𑀘𑁆𑀙𑀸𑀦𑀗𑁆𑀕𑀮𑀯𑀦𑀲𑀡𑁆𑀟𑁂. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀲𑀫𑁆𑀩𑀳𑀼𑀮𑀸 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀢𑀸 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀢𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀳𑀸𑀲𑀸𑀮𑀸 𑀇𑀘𑁆𑀙𑀸𑀦𑀗𑁆𑀕𑀮𑁂 𑀧𑀝𑀺𑀯𑀲𑀦𑁆𑀢𑀺, 𑀲𑁂𑀬𑁆𑀬𑀣𑀺𑀤𑀁 𑁋 𑀘𑀗𑁆𑀓𑀻 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄, 𑀢𑀸𑀭𑀼𑀓𑁆𑀔𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄, 𑀧𑁄𑀓𑁆𑀔𑀭𑀲𑀸𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄, 𑀚𑀸𑀡𑀼𑀲𑁆𑀲𑁄𑀡𑀺 [𑀚𑀸𑀡𑀼𑀲𑁄𑀡𑀺 (𑀓.)] 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄, 𑀢𑁄𑀤𑁂𑀬𑁆𑀬𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄, 𑀅𑀜𑁆𑀜𑁂 𑀘 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀢𑀸 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀢𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀳𑀸𑀲𑀸𑀮𑀸. 𑀅𑀣 𑀔𑁄 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀸𑀦𑀁 𑀫𑀸𑀡𑀯𑀸𑀦𑀁 ¶ 𑀚𑀗𑁆𑀖𑀸𑀯𑀺𑀳𑀸𑀭𑀁 𑀅𑀦𑀼𑀘𑀗𑁆𑀓𑀫𑀦𑁆𑀢𑀸𑀦𑀁 𑀅𑀦𑀼𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀸𑀦𑀁 [𑀅𑀦𑀼𑀘𑀗𑁆𑀓𑀫𑀫𑀸𑀦𑀸𑀦𑀁 𑀅𑀦𑀼𑀯𑀺𑀘𑀭𑀫𑀸𑀦𑀸𑀦𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀅𑀬𑀫𑀦𑁆𑀢𑀭𑀸𑀓𑀣𑀸 𑀉𑀤𑀧𑀸𑀤𑀺 𑁋 ‘‘𑀓𑀣𑀁, 𑀪𑁄, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑁄𑀢𑀻’’𑀢𑀺?

𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀫𑀸𑀡𑀯𑁄 𑀏𑀯𑀫𑀸𑀳 𑁋 ‘‘𑀬𑀢𑁄 𑀔𑁄, 𑀪𑁄, 𑀉𑀪𑀢𑁄 𑀲𑀼𑀚𑀸𑀢𑁄 𑀳𑁄𑀢𑀺 𑀫𑀸𑀢𑀺𑀢𑁄 𑀘 𑀧𑀺𑀢𑀺𑀢𑁄 𑀘 𑀲𑀁𑀲𑀼𑀤𑁆𑀥𑀕𑀳𑀡𑀺𑀓𑁄 𑀬𑀸𑀯 𑀲𑀢𑁆𑀢𑀫𑀸 𑀧𑀺𑀢𑀸𑀫𑀳𑀬𑀼𑀕𑀸 𑀅𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑁄 𑀅𑀦𑀼𑀧𑀓𑁆𑀓𑀼𑀝𑁆𑀞𑁄 𑀚𑀸𑀢𑀺𑀯𑀸𑀤𑁂𑀦, 𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀸 𑀔𑁄 𑀪𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑁄𑀢𑀻’’𑀢𑀺.

𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑁄 𑀫𑀸𑀡𑀯𑁄 𑀏𑀯𑀫𑀸𑀳 𑁋 ‘‘𑀬𑀢𑁄 𑀔𑁄, 𑀪𑁄, 𑀲𑀻𑀮𑀯𑀸 𑀘 𑀳𑁄𑀢𑀺 𑀯𑀢𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄 [𑀯𑀢𑁆𑀢𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀫. 𑀦𑀺. 𑁨.𑁪𑁫𑁪)] 𑀘, 𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀸 𑀔𑁄, 𑀪𑁄, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑁄𑀢𑀻’’𑀢𑀺. 𑀦𑁂𑀯 𑀔𑁄 𑀅𑀲𑀓𑁆𑀔𑀺 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀫𑀸𑀡𑀯𑁄 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑀁 ¶ 𑀫𑀸𑀡𑀯𑀁 𑀲𑀜𑁆𑀜𑀸𑀧𑁂𑀢𑀼𑀁, 𑀦 𑀧𑀦 𑀅𑀲𑀓𑁆𑀔𑀺 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑁄 𑀫𑀸𑀡𑀯𑁄 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀁 𑀫𑀸𑀡𑀯𑀁 𑀲𑀜𑁆𑀜𑀸𑀧𑁂𑀢𑀼𑀁.

𑀅𑀣 ¶ 𑀔𑁄 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑁄 𑀫𑀸𑀡𑀯𑁄 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀁 𑀫𑀸𑀡𑀯𑀁 𑀆𑀫𑀦𑁆𑀢𑁂𑀲𑀺 𑁋 ‘‘𑀅𑀬𑀁 𑀔𑁄, 𑀪𑁄 [𑀅𑀬𑀁 𑀪𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.), 𑀅𑀬𑀁 𑀔𑁄 (𑀧𑀻.)] 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚, 𑀲𑀫𑀡𑁄 𑀕𑁄𑀢𑀫𑁄 𑀲𑀓𑁆𑀬𑀧𑀼𑀢𑁆𑀢𑁄 𑀲𑀓𑁆𑀬𑀓𑀼𑀮𑀸 ¶ 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄 𑀇𑀘𑁆𑀙𑀸𑀦𑀗𑁆𑀕𑀮𑁂 𑀯𑀺𑀳𑀭𑀢𑀺 𑀇𑀘𑁆𑀙𑀸𑀦𑀗𑁆𑀕𑀮𑀯𑀦𑀲𑀡𑁆𑀟𑁂; 𑀢𑀁 𑀔𑁄 𑀧𑀦 𑀪𑀯𑀦𑁆𑀢𑀁 𑀕𑁄𑀢𑀫𑀁 𑀏𑀯𑀁 𑀓𑀮𑁆𑀬𑀸𑀡𑁄 𑀓𑀺𑀢𑁆𑀢𑀺𑀲𑀤𑁆𑀤𑁄 𑀅𑀩𑁆𑀪𑀼𑀕𑁆𑀕𑀢𑁄 𑁋 ‘𑀇𑀢𑀺𑀧𑀺…𑀧𑁂… 𑀩𑀼𑀤𑁆𑀥𑁄 𑀪𑀕𑀯𑀸’𑀢𑀺. 𑀆𑀬𑀸𑀫, 𑀪𑁄 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚, 𑀬𑁂𑀦 𑀲𑀫𑀡𑁄 𑀕𑁄𑀢𑀫𑁄 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀲𑁆𑀲𑀸𑀫; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀲𑀫𑀡𑀁 𑀕𑁄𑀢𑀫𑀁 𑀏𑀢𑀫𑀢𑁆𑀣𑀁 𑀧𑀼𑀘𑁆𑀙𑀺𑀲𑁆𑀲𑀸𑀫. 𑀬𑀣𑀸 𑀦𑁄 𑀲𑀫𑀡𑁄 𑀕𑁄𑀢𑀫𑁄 𑀩𑁆𑀬𑀸𑀓𑀭𑀺𑀲𑁆𑀲𑀢𑀺 𑀢𑀣𑀸 𑀦𑀁 𑀥𑀸𑀭𑁂𑀲𑁆𑀲𑀸𑀫𑀸’’𑀢𑀺. ‘‘𑀏𑀯𑀁, 𑀪𑁄’’𑀢𑀺 𑀔𑁄 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀫𑀸𑀡𑀯𑁄 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑀲𑁆𑀲 𑀫𑀸𑀡𑀯𑀲𑁆𑀲 𑀧𑀘𑁆𑀘𑀲𑁆𑀲𑁄𑀲𑀺.

𑀅𑀣 𑀔𑁄 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀸 𑀫𑀸𑀡𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀁𑀲𑀼; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀢𑀸 𑀲𑀤𑁆𑀥𑀺𑀁 𑀲𑀫𑁆𑀫𑁄𑀤𑀺𑀁𑀲𑀼. 𑀲𑀫𑁆𑀫𑁄𑀤𑀦𑀻𑀬𑀁 𑀓𑀣𑀁 𑀲𑀸𑀭𑀡𑀻𑀬𑀁 𑀯𑀻𑀢𑀺𑀲𑀸𑀭𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺𑀁𑀲𑀼. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀔𑁄 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑁄 𑀫𑀸𑀡𑀯𑁄 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀕𑀸𑀣𑀸𑀳𑀺 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀺 𑁋

‘‘𑀅𑀦𑀼𑀜𑁆𑀜𑀸𑀢𑀧𑀝𑀺𑀜𑁆𑀜𑀸𑀢𑀸, 𑀢𑁂𑀯𑀺𑀚𑁆𑀚𑀸 𑀫𑀬𑀫𑀲𑁆𑀫𑀼𑀪𑁄;

𑀅𑀳𑀁 𑀧𑁄𑀓𑁆𑀔𑀭𑀲𑀸𑀢𑀺𑀲𑁆𑀲, 𑀢𑀸𑀭𑀼𑀓𑁆𑀔𑀲𑁆𑀲𑀸𑀬𑀁 𑀫𑀸𑀡𑀯𑁄.

‘‘𑀢𑁂𑀯𑀺𑀚𑁆𑀚𑀸𑀦𑀁 𑀬𑀤𑀓𑁆𑀔𑀸𑀢𑀁, 𑀢𑀢𑁆𑀭 𑀓𑁂𑀯𑀮𑀺𑀦𑁄𑀲𑁆𑀫𑀲𑁂;

𑀧𑀤𑀓𑀲𑁆𑀫 𑀯𑁂𑀬𑁆𑀬𑀸𑀓𑀭𑀡𑀸, 𑀚𑀧𑁆𑀧𑁂 𑀆𑀘𑀭𑀺𑀬𑀲𑀸𑀤𑀺𑀲𑀸.

‘‘𑀢𑁂𑀲𑀁 ¶ ¶ 𑀦𑁄 𑀚𑀸𑀢𑀺𑀯𑀸𑀤𑀲𑁆𑀫𑀺𑀁, 𑀯𑀺𑀯𑀸𑀤𑁄 𑀅𑀢𑁆𑀣𑀺 𑀕𑁄𑀢𑀫;

𑀚𑀸𑀢𑀺𑀬𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑁄𑀢𑀺, 𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑁄 𑀇𑀢𑀺 𑀪𑀸𑀲𑀢𑀺;

𑀅𑀳𑀜𑁆𑀘 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 [𑀓𑀫𑁆𑀫𑀦𑀸 (𑀲𑀻. 𑀧𑀻.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] 𑀩𑁆𑀭𑀽𑀫𑀺, 𑀏𑀯𑀁 𑀚𑀸𑀦𑀸𑀳𑀺 𑀘𑀓𑁆𑀔𑀼𑀫.

‘‘𑀢𑁂 𑀦 𑀲𑀓𑁆𑀓𑁄𑀫 𑀲𑀜𑁆𑀜𑀸𑀧𑁂𑀢𑀼𑀁, 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀁 𑀫𑀬𑀁 𑀉𑀪𑁄;

𑀪𑀯𑀦𑁆𑀢𑀁 [𑀪𑀕𑀯𑀦𑁆𑀢𑀁 (𑀓.)] 𑀧𑀼𑀝𑁆𑀞𑀼𑀫𑀸𑀕𑀫𑁆𑀳𑀸, 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁 𑀇𑀢𑀺 𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑀁.

‘‘𑀘𑀦𑁆𑀤𑀁 ¶ 𑀬𑀣𑀸 𑀔𑀬𑀸𑀢𑀻𑀢𑀁, 𑀧𑁂𑀘𑁆𑀘 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀚𑀦𑀸;

𑀯𑀦𑁆𑀤𑀫𑀸𑀦𑀸 𑀦𑀫𑀲𑁆𑀲𑀦𑁆𑀢𑀺, 𑀏𑀯𑀁 𑀮𑁄𑀓𑀲𑁆𑀫𑀺 𑀕𑁄𑀢𑀫𑀁.

‘‘𑀘𑀓𑁆𑀔𑀼𑀁 𑀮𑁄𑀓𑁂 𑀲𑀫𑀼𑀧𑁆𑀧𑀦𑁆𑀦𑀁, 𑀫𑀬𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫 𑀕𑁄𑀢𑀫𑀁;

𑀚𑀸𑀢𑀺𑀬𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑁄𑀢𑀺, 𑀉𑀤𑀸𑀳𑀼 𑀪𑀯𑀢𑀺 𑀓𑀫𑁆𑀫𑀼𑀦𑀸;

𑀅𑀚𑀸𑀦𑀢𑀁 𑀦𑁄 𑀧𑀩𑁆𑀭𑀽𑀳𑀺, 𑀬𑀣𑀸 𑀚𑀸𑀦𑁂𑀲𑀼 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁’’.

‘‘𑀢𑁂𑀲𑀁 ¶ 𑀯𑁄 𑀅𑀳𑀁 𑀩𑁆𑀬𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁, (𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑀸𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀅𑀦𑀼𑀧𑀼𑀩𑁆𑀩𑀁 𑀬𑀣𑀸𑀢𑀣𑀁;

𑀚𑀸𑀢𑀺𑀯𑀺𑀪𑀗𑁆𑀕𑀁 𑀧𑀸𑀡𑀸𑀦𑀁, 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀸 𑀳𑀺 𑀚𑀸𑀢𑀺𑀬𑁄.

‘‘𑀢𑀺𑀡𑀭𑀼𑀓𑁆𑀔𑁂𑀧𑀺 𑀚𑀸𑀦𑀸𑀣, 𑀦 𑀘𑀸𑀧𑀺 𑀧𑀝𑀺𑀚𑀸𑀦𑀭𑁂;

𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀢𑁂𑀲𑀁, 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀸 𑀳𑀺 𑀚𑀸𑀢𑀺𑀬𑁄.

‘‘𑀢𑀢𑁄 ¶ 𑀓𑀻𑀝𑁂 𑀧𑀝𑀗𑁆𑀕𑁂 𑀘, 𑀬𑀸𑀯 𑀓𑀼𑀦𑁆𑀣𑀓𑀺𑀧𑀺𑀮𑁆𑀮𑀺𑀓𑁂;

𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀢𑁂𑀲𑀁, 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀸 𑀳𑀺 𑀚𑀸𑀢𑀺𑀬𑁄.

‘‘𑀘𑀢𑀼𑀧𑁆𑀧𑀤𑁂𑀧𑀺 𑀚𑀸𑀦𑀸𑀣, 𑀔𑀼𑀤𑁆𑀤𑀓𑁂 𑀘 𑀫𑀳𑀮𑁆𑀮𑀓𑁂;

𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀢𑁂𑀲𑀁, 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀸 𑀳𑀺 𑀚𑀸𑀢𑀺𑀬𑁄.

‘‘𑀧𑀸𑀤𑀽𑀤𑀭𑁂𑀧𑀺 𑀚𑀸𑀦𑀸𑀣, 𑀉𑀭𑀕𑁂 𑀤𑀻𑀖𑀧𑀺𑀝𑁆𑀞𑀺𑀓𑁂;

𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀢𑁂𑀲𑀁, 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀸 𑀳𑀺 𑀚𑀸𑀢𑀺𑀬𑁄.

‘‘𑀢𑀢𑁄 𑀫𑀘𑁆𑀙𑁂𑀧𑀺 𑀚𑀸𑀦𑀸𑀣, 𑀑𑀤𑀓𑁂 𑀯𑀸𑀭𑀺𑀕𑁄𑀘𑀭𑁂;

𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀢𑁂𑀲𑀁, 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀸 𑀳𑀺 𑀚𑀸𑀢𑀺𑀬𑁄.

‘‘𑀢𑀢𑁄 𑀧𑀓𑁆𑀔𑀻𑀧𑀺 𑀚𑀸𑀦𑀸𑀣, 𑀧𑀢𑁆𑀢𑀬𑀸𑀦𑁂 𑀯𑀺𑀳𑀗𑁆𑀕𑀫𑁂;

𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀢𑁂𑀲𑀁, 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀸 𑀳𑀺 𑀚𑀸𑀢𑀺𑀬𑁄.

‘‘𑀬𑀣𑀸 ¶ ¶ 𑀏𑀢𑀸𑀲𑀼 𑀚𑀸𑀢𑀻𑀲𑀼, 𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀧𑀼𑀣𑀼;

𑀏𑀯𑀁 𑀦𑀢𑁆𑀣𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀧𑀼𑀣𑀼.

‘‘𑀦 𑀓𑁂𑀲𑁂𑀳𑀺 𑀦 𑀲𑀻𑀲𑁂𑀦, 𑀦 𑀓𑀡𑁆𑀡𑁂𑀳𑀺 𑀦 𑀅𑀓𑁆𑀔𑀺𑀪𑀺;

𑀦 𑀫𑀼𑀔𑁂𑀦 𑀦 𑀦𑀸𑀲𑀸𑀬, 𑀦 𑀑𑀝𑁆𑀞𑁂𑀳𑀺 𑀪𑀫𑀽𑀳𑀺 𑀯𑀸.

‘‘𑀦 𑀕𑀻𑀯𑀸𑀬 𑀦 𑀅𑀁𑀲𑁂𑀳𑀺, 𑀦 𑀉𑀤𑀭𑁂𑀦 𑀦 𑀧𑀺𑀝𑁆𑀞𑀺𑀬𑀸;

𑀦 𑀲𑁄𑀡𑀺𑀬𑀸 𑀦 𑀉𑀭𑀲𑀸, 𑀦 𑀲𑀫𑁆𑀩𑀸𑀥𑁂 𑀦 𑀫𑁂𑀣𑀼𑀦𑁂 [𑀦 𑀲𑀫𑁆𑀩𑀸𑀥𑀸 𑀦 𑀫𑁂𑀣𑀼𑀦𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)].

‘‘𑀦 ¶ 𑀳𑀢𑁆𑀣𑁂𑀳𑀺 𑀦 𑀧𑀸𑀤𑁂𑀳𑀺, 𑀦𑀸𑀗𑁆𑀕𑀼𑀮𑀻𑀳𑀺 𑀦𑀔𑁂𑀳𑀺 𑀯𑀸;

𑀦 𑀚𑀗𑁆𑀖𑀸𑀳𑀺 𑀦 𑀊𑀭𑀽𑀳𑀺, 𑀦 𑀯𑀡𑁆𑀡𑁂𑀦 𑀲𑀭𑁂𑀦 𑀯𑀸;

𑀮𑀺𑀗𑁆𑀕𑀁 𑀚𑀸𑀢𑀺𑀫𑀬𑀁 𑀦𑁂𑀯, 𑀬𑀣𑀸 𑀅𑀜𑁆𑀜𑀸𑀲𑀼 𑀚𑀸𑀢𑀺𑀲𑀼.

‘‘𑀧𑀘𑁆𑀘𑀢𑁆𑀢𑀜𑁆𑀘 ¶ 𑀲𑀭𑀻𑀭𑁂𑀲𑀼 [𑀧𑀘𑁆𑀘𑀢𑁆𑀢𑀁 𑀲𑀲𑀭𑀻𑀭𑁂𑀲𑀼 (𑀲𑀻. 𑀧𑀻.)], 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑁆𑀯𑁂𑀢𑀁 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

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

‘‘𑀬𑁄 𑀳𑀺 𑀓𑁄𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀕𑁄𑀭𑀓𑁆𑀔𑀁 𑀉𑀧𑀚𑀻𑀯𑀢𑀺;

𑀏𑀯𑀁 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀓𑀲𑁆𑀲𑀓𑁄 𑀲𑁄 𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀬𑁄 𑀳𑀺 𑀓𑁄𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀧𑀼𑀣𑀼𑀲𑀺𑀧𑁆𑀧𑁂𑀦 𑀚𑀻𑀯𑀢𑀺;

𑀏𑀯𑀁 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀲𑀺𑀧𑁆𑀧𑀺𑀓𑁄 𑀲𑁄 𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀬𑁄 𑀳𑀺 𑀓𑁄𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀯𑁄𑀳𑀸𑀭𑀁 𑀉𑀧𑀚𑀻𑀯𑀢𑀺;

𑀏𑀯𑀁 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀯𑀸𑀡𑀺𑀚𑁄 𑀲𑁄 𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀬𑁄 𑀳𑀺 𑀓𑁄𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀧𑀭𑀧𑁂𑀲𑁆𑀲𑁂𑀦 𑀚𑀻𑀯𑀢𑀺;

𑀏𑀯𑀁 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀧𑁂𑀲𑁆𑀲𑀺𑀓𑁄 [𑀧𑁂𑀲𑁆𑀲𑀓𑁄 (𑀓.)] 𑀲𑁄 𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀬𑁄 𑀳𑀺 𑀓𑁄𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀉𑀧𑀚𑀻𑀯𑀢𑀺;

𑀏𑀯𑀁 ¶ 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀘𑁄𑀭𑁄 𑀏𑀲𑁄 𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀬𑁄 𑀳𑀺 𑀓𑁄𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀇𑀲𑁆𑀲𑀢𑁆𑀣𑀁 𑀉𑀧𑀚𑀻𑀯𑀢𑀺;

𑀏𑀯𑀁 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀬𑁄𑀥𑀸𑀚𑀻𑀯𑁄 𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀬𑁄 𑀳𑀺 𑀓𑁄𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀧𑁄𑀭𑁄𑀳𑀺𑀘𑁆𑀘𑁂𑀦 𑀚𑀻𑀯𑀢𑀺;

𑀏𑀯𑀁 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀬𑀸𑀚𑀓𑁄 𑀏𑀲𑁄 𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀬𑁄 ¶ 𑀳𑀺 𑀓𑁄𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀕𑀸𑀫𑀁 𑀭𑀝𑁆𑀞𑀜𑁆𑀘 𑀪𑀼𑀜𑁆𑀚𑀢𑀺;

𑀏𑀯𑀁 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀭𑀸𑀚𑀸 𑀏𑀲𑁄 𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀦 ¶ 𑀘𑀸𑀳𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀩𑁆𑀭𑀽𑀫𑀺, 𑀬𑁄𑀦𑀺𑀚𑀁 𑀫𑀢𑁆𑀢𑀺𑀲𑀫𑁆𑀪𑀯𑀁;

𑀪𑁄𑀯𑀸𑀤𑀺 𑀦𑀸𑀫 𑀲𑁄 𑀳𑁄𑀢𑀺, 𑀲𑀘𑁂 [𑀲 𑀯𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀳𑁄𑀢𑀺 𑀲𑀓𑀺𑀜𑁆𑀘𑀦𑁄;

𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀁 𑀅𑀦𑀸𑀤𑀸𑀦𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀲𑀩𑁆𑀩𑀲𑀁𑀬𑁄𑀚𑀦𑀁 𑀙𑁂𑀢𑁆𑀯𑀸, 𑀲𑁄 𑀯𑁂 𑀦 𑀧𑀭𑀺𑀢𑀲𑁆𑀲𑀢𑀺;

𑀲𑀗𑁆𑀕𑀸𑀢𑀺𑀕𑀁 𑀯𑀺𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀙𑁂𑀢𑁆𑀯𑀸 ¶ 𑀦𑀤𑁆𑀥𑀺𑀁 𑀯𑀭𑀢𑁆𑀢𑀜𑁆𑀘, 𑀲𑀦𑁆𑀤𑀸𑀦𑀁 𑀲𑀳𑀦𑀼𑀓𑁆𑀓𑀫𑀁;

𑀉𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀧𑀮𑀺𑀖𑀁 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀅𑀓𑁆𑀓𑁄𑀲𑀁 𑀯𑀥𑀩𑀦𑁆𑀥𑀜𑁆𑀘, 𑀅𑀤𑀼𑀝𑁆𑀞𑁄 𑀬𑁄 𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀢𑀺;

𑀔𑀦𑁆𑀢𑀻𑀩𑀮𑀁 𑀩𑀮𑀸𑀦𑀻𑀓𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀅𑀓𑁆𑀓𑁄𑀥𑀦𑀁 𑀯𑀢𑀯𑀦𑁆𑀢𑀁, 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑀁 𑀅𑀦𑀼𑀲𑁆𑀲𑀤𑀁;

𑀤𑀦𑁆𑀢𑀁 𑀅𑀦𑁆𑀢𑀺𑀫𑀲𑀸𑀭𑀻𑀭𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀯𑀸𑀭𑀺 𑀧𑁄𑀓𑁆𑀔𑀭𑀧𑀢𑁆𑀢𑁂𑀯, 𑀆𑀭𑀕𑁆𑀕𑁂𑀭𑀺𑀯 𑀲𑀸𑀲𑀧𑁄;

𑀬𑁄 𑀦 𑀮𑀺𑀫𑁆𑀧𑀢𑀺 𑀓𑀸𑀫𑁂𑀲𑀼, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑁄 ¶ 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀧𑀚𑀸𑀦𑀸𑀢𑀺, 𑀇𑀥𑁂𑀯 𑀔𑀬𑀫𑀢𑁆𑀢𑀦𑁄;

𑀧𑀦𑁆𑀦𑀪𑀸𑀭𑀁 𑀯𑀺𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀕𑀫𑁆𑀪𑀻𑀭𑀧𑀜𑁆𑀜𑀁 𑀫𑁂𑀥𑀸𑀯𑀺𑀁, 𑀫𑀕𑁆𑀕𑀸𑀫𑀕𑁆𑀕𑀲𑁆𑀲 𑀓𑁄𑀯𑀺𑀤𑀁;

𑀉𑀢𑁆𑀢𑀫𑀢𑁆𑀣𑀫𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀅𑀲𑀁𑀲𑀝𑁆𑀞𑀁 𑀕𑀳𑀝𑁆𑀞𑁂𑀳𑀺, 𑀅𑀦𑀸𑀕𑀸𑀭𑁂𑀳𑀺 𑀘𑀽𑀪𑀬𑀁;

𑀅𑀦𑁄𑀓𑀲𑀸𑀭𑀺𑀫𑀧𑁆𑀧𑀺𑀘𑁆𑀙𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀦𑀺𑀥𑀸𑀬 𑀤𑀡𑁆𑀟𑀁 𑀪𑀽𑀢𑁂𑀲𑀼, 𑀢𑀲𑁂𑀲𑀼 𑀣𑀸𑀯𑀭𑁂𑀲𑀼 𑀘;

𑀬𑁄 𑀦 𑀳𑀦𑁆𑀢𑀺 𑀦 𑀖𑀸𑀢𑁂𑀢𑀺, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀅𑀯𑀺𑀭𑀼𑀤𑁆𑀥𑀁 ¶ 𑀯𑀺𑀭𑀼𑀤𑁆𑀥𑁂𑀲𑀼, 𑀅𑀢𑁆𑀢𑀤𑀡𑁆𑀟𑁂𑀲𑀼 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀁;

𑀲𑀸𑀤𑀸𑀦𑁂𑀲𑀼 𑀅𑀦𑀸𑀤𑀸𑀦𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑀲𑁆𑀲 ¶ 𑀭𑀸𑀕𑁄 𑀘 𑀤𑁄𑀲𑁄 𑀘, 𑀫𑀸𑀦𑁄 𑀫𑀓𑁆𑀔𑁄 𑀘 𑀧𑀸𑀢𑀺𑀢𑁄;

𑀲𑀸𑀲𑀧𑁄𑀭𑀺𑀯 𑀆𑀭𑀕𑁆𑀕𑀸, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀅𑀓𑀓𑁆𑀓𑀲𑀁 ¶ 𑀯𑀺𑀜𑁆𑀜𑀸𑀧𑀦𑀺𑀁, 𑀕𑀺𑀭𑀁 𑀲𑀘𑁆𑀘𑀫𑀼𑀤𑀻𑀭𑀬𑁂;

𑀬𑀸𑀬 𑀦𑀸𑀪𑀺𑀲𑀚𑁂 𑀓𑀜𑁆𑀘𑀺, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑁄𑀥 𑀤𑀻𑀖𑀁 𑀯 𑀭𑀲𑁆𑀲𑀁 𑀯𑀸, 𑀅𑀡𑀼𑀁 𑀣𑀽𑀮𑀁 𑀲𑀼𑀪𑀸𑀲𑀼𑀪𑀁;

𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀦𑀸𑀤𑀺𑀬𑀢𑀺, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀆𑀲𑀸 𑀬𑀲𑁆𑀲 𑀦 𑀯𑀺𑀚𑁆𑀚𑀦𑁆𑀢𑀺, 𑀅𑀲𑁆𑀫𑀺𑀁 𑀮𑁄𑀓𑁂 𑀧𑀭𑀫𑁆𑀳𑀺 𑀘;

𑀦𑀺𑀭𑀸𑀲𑀸𑀲𑀁 [𑀦𑀺𑀭𑀸𑀲𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀦𑀺𑀭𑀸𑀲𑀓𑀁 (?)] 𑀯𑀺𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑀲𑁆𑀲𑀸𑀮𑀬𑀸 𑀦 𑀯𑀺𑀚𑁆𑀚𑀦𑁆𑀢𑀺, 𑀅𑀜𑁆𑀜𑀸𑀬 𑀅𑀓𑀣𑀁𑀓𑀣𑀻;

𑀅𑀫𑀢𑁄𑀕𑀥𑀫𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑁄𑀥 ¶ 𑀧𑀼𑀜𑁆𑀜𑀜𑁆𑀘 𑀧𑀸𑀧𑀜𑁆𑀘, 𑀉𑀪𑁄 𑀲𑀗𑁆𑀕𑀫𑀼𑀧𑀘𑁆𑀘𑀕𑀸;

𑀅𑀲𑁄𑀓𑀁 𑀯𑀺𑀭𑀚𑀁 𑀲𑀼𑀤𑁆𑀥𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀘𑀦𑁆𑀤𑀁𑀯 𑀯𑀺𑀫𑀮𑀁 𑀲𑀼𑀤𑁆𑀥𑀁, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀫𑀦𑀸𑀯𑀺𑀮𑀁;

𑀦𑀦𑁆𑀤𑀻𑀪𑀯𑀧𑀭𑀺𑀓𑁆𑀔𑀻𑀡𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑁄𑀫𑀁 𑀧𑀮𑀺𑀧𑀣𑀁 𑀤𑀼𑀕𑁆𑀕𑀁, 𑀲𑀁𑀲𑀸𑀭𑀁 𑀫𑁄𑀳𑀫𑀘𑁆𑀘𑀕𑀸;

𑀢𑀺𑀡𑁆𑀡𑁄 𑀧𑀸𑀭𑀗𑁆𑀕𑀢𑁄 𑀛𑀸𑀬𑀻, 𑀅𑀦𑁂𑀚𑁄 𑀅𑀓𑀣𑀁𑀓𑀣𑀻;

𑀅𑀦𑀼𑀧𑀸𑀤𑀸𑀬 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑁄𑀥 𑀓𑀸𑀫𑁂 𑀧𑀳𑀦𑁆𑀢𑁆𑀯𑀸𑀦, 𑀅𑀦𑀸𑀕𑀸𑀭𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂;

𑀓𑀸𑀫𑀪𑀯𑀧𑀭𑀺𑀓𑁆𑀔𑀻𑀡𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑁄𑀥 ¶ 𑀢𑀡𑁆𑀳𑀁 𑀧𑀳𑀦𑁆𑀢𑁆𑀯𑀸𑀦, 𑀅𑀦𑀸𑀕𑀸𑀭𑁄 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂;

𑀢𑀡𑁆𑀳𑀸𑀪𑀯𑀧𑀭𑀺𑀓𑁆𑀔𑀻𑀡𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀳𑀺𑀢𑁆𑀯𑀸 𑀫𑀸𑀦𑀼𑀲𑀓𑀁 𑀬𑁄𑀕𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀬𑁄𑀕𑀁 𑀉𑀧𑀘𑁆𑀘𑀕𑀸;

𑀲𑀩𑁆𑀩𑀬𑁄𑀕𑀯𑀺𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀳𑀺𑀢𑁆𑀯𑀸 𑀭𑀢𑀺𑀜𑁆𑀘 𑀅𑀭𑀢𑀺𑀁, 𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑀁 𑀦𑀺𑀭𑀽𑀧𑀥𑀺𑀁;

𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀸𑀪𑀺𑀪𑀼𑀁 𑀯𑀻𑀭𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀘𑀼𑀢𑀺𑀁 ¶ ¶ 𑀬𑁄 𑀯𑁂𑀤𑀺 [𑀬𑁄’𑀯𑁂𑀢𑀺 (?) 𑀇𑀢𑀺𑀯𑀼𑀢𑁆𑀢𑀓𑁂 𑁯𑁯 𑀅𑀝𑁆𑀞𑀓𑀣𑀸𑀲𑀁𑀯𑀡𑀦𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸] 𑀢𑁆𑀢𑀸𑀦𑀁, 𑀉𑀧𑀧𑀢𑁆𑀢𑀺𑀜𑁆𑀘 𑀲𑀩𑁆𑀩𑀲𑁄;

𑀅𑀲𑀢𑁆𑀢𑀁 𑀲𑀼𑀕𑀢𑀁 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑀲𑁆𑀲 𑀕𑀢𑀺𑀁 𑀦 𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀤𑁂𑀯𑀸 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑀫𑀸𑀦𑀼𑀲𑀸;

𑀔𑀻𑀡𑀸𑀲𑀯𑀁 𑀅𑀭𑀳𑀦𑁆𑀢𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀬𑀲𑁆𑀲 𑀧𑀼𑀭𑁂 𑀘 𑀧𑀘𑁆𑀙𑀸 𑀘, 𑀫𑀚𑁆𑀛𑁂 𑀘 𑀦𑀢𑁆𑀣𑀺 𑀓𑀺𑀜𑁆𑀘𑀦𑀁;

𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀁 ¶ 𑀅𑀦𑀸𑀤𑀸𑀦𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀉𑀲𑀪𑀁 𑀧𑀯𑀭𑀁 𑀯𑀻𑀭𑀁, 𑀫𑀳𑁂𑀲𑀺𑀁 𑀯𑀺𑀚𑀺𑀢𑀸𑀯𑀺𑀦𑀁;

𑀅𑀦𑁂𑀚𑀁 𑀦𑁆𑀳𑀸𑀢𑀓𑀁 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀧𑀼𑀩𑁆𑀩𑁂𑀦𑀺𑀯𑀸𑀲𑀁 𑀬𑁄 𑀯𑁂𑀤𑀺 [𑀬𑁄’𑀯𑁂𑀢𑀺 (?) 𑀇𑀢𑀺𑀯𑀼𑀢𑁆𑀢𑀓𑁂 𑁯𑁯 𑀅𑀝𑁆𑀞𑀓𑀣𑀸𑀲𑀁𑀯𑀡𑀦𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸], 𑀲𑀕𑁆𑀕𑀸𑀧𑀸𑀬𑀜𑁆𑀘 𑀧𑀲𑁆𑀲𑀢𑀺;

𑀅𑀣𑁄 𑀚𑀸𑀢𑀺𑀓𑁆𑀔𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀢𑀫𑀳𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

‘‘𑀲𑀫𑀜𑁆𑀜𑀸 𑀳𑁂𑀲𑀸 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁, 𑀦𑀸𑀫𑀕𑁄𑀢𑁆𑀢𑀁 𑀧𑀓𑀧𑁆𑀧𑀺𑀢𑀁;

𑀲𑀫𑁆𑀫𑀼𑀘𑁆𑀘𑀸 𑀲𑀫𑀼𑀤𑀸𑀕𑀢𑀁, 𑀢𑀢𑁆𑀣 𑀢𑀢𑁆𑀣 𑀧𑀓𑀧𑁆𑀧𑀺𑀢𑀁.

‘‘𑀤𑀻𑀖𑀭𑀢𑁆𑀢𑀫𑀦𑀼𑀲𑀬𑀺𑀢𑀁, 𑀤𑀺𑀝𑁆𑀞𑀺𑀕𑀢𑀫𑀚𑀸𑀦𑀢𑀁;

𑀅𑀚𑀸𑀦𑀦𑁆𑀢𑀸 𑀦𑁄 [𑀅𑀚𑀸𑀦𑀦𑁆𑀢𑀸 𑀢𑁂 (𑀅𑀝𑁆𑀞.) 𑀫. 𑀦𑀺. 𑁨.𑁪𑁬𑁦] 𑀧𑀩𑁆𑀭𑀼𑀯𑀦𑁆𑀢𑀺, 𑀚𑀸𑀢𑀺𑀬𑀸 𑀳𑁄𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀦 ¶ 𑀚𑀘𑁆𑀘𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑁄𑀢𑀺, 𑀦 𑀚𑀘𑁆𑀘𑀸 𑀳𑁄𑀢𑀺 𑀅𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑁄𑀢𑀺, 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀳𑁄𑀢𑀺 𑀅𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀓𑀲𑁆𑀲𑀓𑁄 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀳𑁄𑀢𑀺, 𑀲𑀺𑀧𑁆𑀧𑀺𑀓𑁄 𑀳𑁄𑀢𑀺 𑀓𑀫𑁆𑀫𑀼𑀦𑀸;

𑀯𑀸𑀡𑀺𑀚𑁄 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀳𑁄𑀢𑀺, 𑀧𑁂𑀲𑁆𑀲𑀺𑀓𑁄 𑀳𑁄𑀢𑀺 𑀓𑀫𑁆𑀫𑀼𑀦𑀸.

‘‘𑀘𑁄𑀭𑁄𑀧𑀺 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀳𑁄𑀢𑀺, 𑀬𑁄𑀥𑀸𑀚𑀻𑀯𑁄𑀧𑀺 𑀓𑀫𑁆𑀫𑀼𑀦𑀸;

𑀬𑀸𑀚𑀓𑁄 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀳𑁄𑀢𑀺, 𑀭𑀸𑀚𑀸𑀧𑀺 𑀳𑁄𑀢𑀺 𑀓𑀫𑁆𑀫𑀼𑀦𑀸.

‘‘𑀏𑀯𑀫𑁂𑀢𑀁 ¶ ¶ 𑀬𑀣𑀸𑀪𑀽𑀢𑀁, 𑀓𑀫𑁆𑀫𑀁 𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

𑀧𑀝𑀺𑀘𑁆𑀘𑀲𑀫𑀼𑀧𑁆𑀧𑀸𑀤𑀤𑀲𑁆𑀲𑀸, 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑀓𑁄𑀯𑀺𑀤𑀸.

‘‘𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀯𑀢𑁆𑀢𑀢𑀺 𑀮𑁄𑀓𑁄, 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀯𑀢𑁆𑀢𑀢𑀺 𑀧𑀚𑀸;

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

‘‘𑀢𑀧𑁂𑀦 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑁂𑀦, 𑀲𑀁𑀬𑀫𑁂𑀦 𑀤𑀫𑁂𑀦 𑀘;

𑀏𑀢𑁂𑀦 ¶ 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀳𑁄𑀢𑀺, 𑀏𑀢𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀢𑀻𑀳𑀺 𑀯𑀺𑀚𑁆𑀚𑀸𑀳𑀺 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀲𑀦𑁆𑀢𑁄 𑀔𑀻𑀡𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑁄;

𑀏𑀯𑀁 𑀯𑀸𑀲𑁂𑀝𑁆𑀞 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀲𑀓𑁆𑀓𑁄 𑀯𑀺𑀚𑀸𑀦𑀢’’𑀦𑁆𑀢𑀺.

𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑀪𑀸𑀭𑀤𑁆𑀯𑀸𑀚𑀸 𑀫𑀸𑀡𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘𑀼𑀁 𑁋 ‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀪𑁄 𑀕𑁄𑀢𑀫…𑀧𑁂… 𑀉𑀧𑀸𑀲𑀓𑁂 𑀦𑁄 𑀪𑀯𑀁 𑀕𑁄𑀢𑀫𑁄 𑀥𑀸𑀭𑁂𑀢𑀼 𑀅𑀚𑁆𑀚𑀢𑀕𑁆𑀕𑁂 𑀧𑀸𑀡𑀼𑀧𑁂𑀢𑁂 [𑀧𑀸𑀡𑀼𑀧𑁂𑀢𑀁 (𑀓.)] 𑀲𑀭𑀡𑀁 𑀕𑀢𑁂’’𑀢𑀺.

𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑀲𑀼𑀢𑁆𑀢𑀁 𑀦𑀯𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀏𑀯𑀁 ¶ 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀚𑁂𑀢𑀯𑀦𑁂 𑀅𑀦𑀸𑀣𑀧𑀺𑀡𑁆𑀟𑀺𑀓𑀲𑁆𑀲 𑀆𑀭𑀸𑀫𑁂. 𑀅𑀣 𑀔𑁄 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 ¶ 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀻𑀤𑀺. 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀔𑁄 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀧𑀸𑀧𑀺𑀘𑁆𑀙𑀸, 𑀪𑀦𑁆𑀢𑁂, 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑀸, 𑀧𑀸𑀧𑀺𑀓𑀸𑀦𑀁 𑀇𑀘𑁆𑀙𑀸𑀦𑀁 𑀯𑀲𑀁 𑀕𑀢𑀸’’𑀢𑀺.

𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀪𑀕𑀯𑀸 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀫𑀸 𑀳𑁂𑀯𑀁, 𑀓𑁄𑀓𑀸𑀮𑀺𑀓, 𑀫𑀸 𑀳𑁂𑀯𑀁, 𑀓𑁄𑀓𑀸𑀮𑀺𑀓! 𑀧𑀲𑀸𑀤𑁂𑀳𑀺, 𑀓𑁄𑀓𑀸𑀮𑀺𑀓, 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀲𑀼 𑀘𑀺𑀢𑁆𑀢𑀁. 𑀧𑁂𑀲𑀮𑀸 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑀸’’𑀢𑀺.

𑀤𑀼𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀔𑁄…𑀧𑁂… ¶ 𑀢𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀔𑁄 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀓𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀫𑁂, 𑀪𑀦𑁆𑀢𑁂, 𑀪𑀕𑀯𑀸 𑀲𑀤𑁆𑀥𑀸𑀬𑀺𑀓𑁄 𑀧𑀘𑁆𑀘𑀬𑀺𑀓𑁄, 𑀅𑀣 𑀔𑁄 𑀧𑀸𑀧𑀺𑀘𑁆𑀙𑀸𑀯 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑀸, 𑀧𑀸𑀧𑀺𑀓𑀸𑀦𑀁 𑀇𑀘𑁆𑀙𑀸𑀦𑀁 𑀯𑀲𑀁 𑀕𑀢𑀸’’𑀢𑀺. 𑀢𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀫𑀸 𑀳𑁂𑀯𑀁, 𑀓𑁄𑀓𑀸𑀮𑀺𑀓 ¶ , 𑀫𑀸 𑀳𑁂𑀯𑀁, 𑀓𑁄𑀓𑀸𑀮𑀺𑀓! 𑀧𑀲𑀸𑀤𑁂𑀳𑀺, 𑀓𑁄𑀓𑀸𑀮𑀺𑀓, 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀲𑀼 𑀘𑀺𑀢𑁆𑀢𑀁. 𑀧𑁂𑀲𑀮𑀸 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑀸’’𑀢𑀺.

𑀅𑀣 𑀔𑁄 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀉𑀝𑁆𑀞𑀸𑀬𑀸𑀲𑀦𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸 𑀧𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀓𑀢𑁆𑀯𑀸 𑀧𑀓𑁆𑀓𑀸𑀫𑀺. 𑀅𑀘𑀺𑀭𑀧𑁆𑀧𑀓𑁆𑀓𑀦𑁆𑀢𑀲𑁆𑀲 𑀘 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀲𑀸𑀲𑀧𑀫𑀢𑁆𑀢𑀻𑀳𑀺 𑀧𑀺𑀴𑀓𑀸𑀳𑀺 𑀲𑀩𑁆𑀩𑁄 𑀓𑀸𑀬𑁄 𑀨𑀼𑀝𑁄 [𑀨𑀼𑀝𑁆𑀞𑁄 (𑀲𑁆𑀬𑀸.)] 𑀅𑀳𑁄𑀲𑀺; 𑀲𑀸𑀲𑀧𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀳𑀼𑀢𑁆𑀯𑀸 𑀫𑀼𑀕𑁆𑀕𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀅𑀳𑁂𑀲𑀼𑀁; 𑀫𑀼𑀕𑁆𑀕𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀳𑀼𑀢𑁆𑀯𑀸 𑀓𑀴𑀸𑀬𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀅𑀳𑁂𑀲𑀼𑀁; 𑀓𑀴𑀸𑀬𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀳𑀼𑀢𑁆𑀯𑀸 𑀓𑁄𑀮𑀝𑁆𑀞𑀺𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀅𑀳𑁂𑀲𑀼𑀁; 𑀓𑁄𑀮𑀝𑁆𑀞𑀺𑀫𑀢𑁆𑀢𑀺𑀬𑁄 ¶ 𑀳𑀼𑀢𑁆𑀯𑀸 𑀓𑁄𑀮𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀅𑀳𑁂𑀲𑀼𑀁; 𑀓𑁄𑀮𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀳𑀼𑀢𑁆𑀯𑀸 𑀆𑀫𑀮𑀓𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀅𑀳𑁂𑀲𑀼𑀁; 𑀆𑀫𑀮𑀓𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀳𑀼𑀢𑁆𑀯𑀸 𑀩𑁂𑀴𑀼𑀯𑀲𑀮𑀸𑀝𑀼𑀓𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀅𑀳𑁂𑀲𑀼𑀁; 𑀩𑁂𑀴𑀼𑀯𑀲𑀮𑀸𑀝𑀼𑀓𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀳𑀼𑀢𑁆𑀯𑀸 𑀩𑀺𑀮𑁆𑀮𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀅𑀳𑁂𑀲𑀼𑀁; 𑀩𑀺𑀮𑁆𑀮𑀫𑀢𑁆𑀢𑀺𑀬𑁄 𑀳𑀼𑀢𑁆𑀯𑀸 𑀧𑀪𑀺𑀚𑁆𑀚𑀺𑀁𑀲𑀼; 𑀧𑀼𑀩𑁆𑀩𑀜𑁆𑀘 𑀮𑁄𑀳𑀺𑀢𑀜𑁆𑀘 𑀧𑀕𑁆𑀖𑀭𑀺𑀁𑀲𑀼. 𑀅𑀣 𑀔𑁄 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀢𑁂𑀦𑁂𑀯𑀸𑀩𑀸𑀥𑁂𑀦 𑀓𑀸𑀮𑀫𑀓𑀸𑀲𑀺. 𑀓𑀸𑀮𑀗𑁆𑀓𑀢𑁄 𑀘 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀤𑀼𑀫𑀁 𑀦𑀺𑀭𑀬𑀁 𑀉𑀧𑀧𑀚𑁆𑀚𑀺 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀲𑀼 𑀘𑀺𑀢𑁆𑀢𑀁 𑀆𑀖𑀸𑀢𑁂𑀢𑁆𑀯𑀸 ¶ .

𑀅𑀣 𑀔𑁄 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀲𑀳𑀫𑁆𑀧𑀢𑀺 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀸𑀬 𑀭𑀢𑁆𑀢𑀺𑀬𑀸 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀯𑀡𑁆𑀡𑁄 𑀓𑁂𑀯𑀮𑀓𑀧𑁆𑀧𑀁 𑀚𑁂𑀢𑀯𑀦𑀁 𑀑𑀪𑀸𑀲𑁂𑀢𑁆𑀯𑀸 𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑁂𑀦𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺; 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀅𑀝𑁆𑀞𑀸𑀲𑀺 ¶ . 𑀏𑀓𑀫𑀦𑁆𑀢𑀁, 𑀞𑀺𑀢𑁄 𑀔𑁄 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀲𑀳𑀫𑁆𑀧𑀢𑀺 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄, 𑀪𑀦𑁆𑀢𑁂, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀓𑀸𑀮𑀗𑁆𑀓𑀢𑁄; 𑀓𑀸𑀮𑀗𑁆𑀓𑀢𑁄 𑀘, 𑀪𑀦𑁆𑀢𑁂, 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀤𑀼𑀫𑀁 𑀦𑀺𑀭𑀬𑀁 𑀉𑀧𑀧𑀦𑁆𑀦𑁄 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀲𑀼 𑀘𑀺𑀢𑁆𑀢𑀁 𑀆𑀖𑀸𑀢𑁂𑀢𑁆𑀯𑀸’’𑀢𑀺. 𑀇𑀤𑀫𑀯𑁄𑀘 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀲𑀳𑀫𑁆𑀧𑀢𑀺; 𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸 𑀧𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀓𑀢𑁆𑀯𑀸 𑀢𑀢𑁆𑀣𑁂𑀯𑀦𑁆𑀢𑀭𑀥𑀸𑀬𑀺.

𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀢𑀲𑁆𑀲𑀸 𑀭𑀢𑁆𑀢𑀺𑀬𑀸 𑀅𑀘𑁆𑀘𑀬𑁂𑀦 𑀪𑀺𑀓𑁆𑀔𑀽 𑀆𑀫𑀦𑁆𑀢𑁂𑀲𑀺 𑁋 ‘‘𑀇𑀫𑀁, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀭𑀢𑁆𑀢𑀺𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀲𑀳𑀫𑁆𑀧𑀢𑀺 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀸𑀬 𑀭𑀢𑁆𑀢𑀺𑀬𑀸…𑀧𑁂… 𑀇𑀤𑀫𑀯𑁄𑀘, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀲𑀳𑀫𑁆𑀧𑀢𑀺, 𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸 𑀫𑀁 𑀧𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀓𑀢𑁆𑀯𑀸 𑀢𑀢𑁆𑀣𑁂𑀯𑀦𑁆𑀢𑀭𑀥𑀸𑀬𑀻’’𑀢𑀺.

𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀪𑀕𑀯𑀦𑁆𑀢𑀁 ¶ 𑀏𑀢𑀤𑀯𑁄𑀘 𑁋 ‘‘𑀓𑀻𑀯𑀤𑀻𑀖𑀁 𑀦𑀼 𑀔𑁄, 𑀪𑀦𑁆𑀢𑁂, 𑀧𑀤𑀼𑀫𑁂 𑀦𑀺𑀭𑀬𑁂 𑀆𑀬𑀼𑀧𑁆𑀧𑀫𑀸𑀡’’𑀦𑁆𑀢𑀺? ‘‘𑀤𑀻𑀖𑀁 𑀔𑁄, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀧𑀤𑀼𑀫𑁂 𑀦𑀺𑀭𑀬𑁂 𑀆𑀬𑀼𑀧𑁆𑀧𑀫𑀸𑀡𑀁; 𑀢𑀁 𑀦 𑀲𑀼𑀓𑀭𑀁 𑀲𑀗𑁆𑀔𑀸𑀢𑀼𑀁 𑀏𑀢𑁆𑀢𑀓𑀸𑀦𑀺 𑀯𑀲𑁆𑀲𑀸𑀦𑀺 𑀇𑀢𑀺 𑀯𑀸 𑀏𑀢𑁆𑀢𑀓𑀸𑀦𑀺 𑀯𑀲𑁆𑀲𑀲𑀢𑀸𑀦𑀺 𑀇𑀢𑀺 𑀯𑀸 𑀏𑀢𑁆𑀢𑀓𑀸𑀦𑀺 𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 ¶ 𑀇𑀢𑀺 𑀯𑀸 𑀏𑀢𑁆𑀢𑀓𑀸𑀦𑀺 𑀯𑀲𑁆𑀲𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 𑀇𑀢𑀺 𑀯𑀸’’𑀢𑀺. ‘‘𑀲𑀓𑁆𑀓𑀸 𑀧𑀦, 𑀪𑀦𑁆𑀢𑁂, 𑀉𑀧𑀫𑀸 [𑀉𑀧𑀫𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)] 𑀓𑀸𑀢𑀼’’𑀦𑁆𑀢𑀺? ‘‘𑀲𑀓𑁆𑀓𑀸, 𑀪𑀺𑀓𑁆𑀔𑀽’’𑀢𑀺 𑀪𑀕𑀯𑀸 𑀅𑀯𑁄𑀘 𑁋

‘‘𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺𑀔𑀸𑀭𑀺𑀓𑁄 𑀓𑁄𑀲𑀮𑀓𑁄 𑀢𑀺𑀮𑀯𑀸𑀳𑁄; 𑀢𑀢𑁄 𑀧𑀼𑀭𑀺𑀲𑁄 𑀯𑀲𑁆𑀲𑀲𑀢𑀲𑁆𑀲 𑀯𑀲𑁆𑀲𑀲𑀢𑀲𑁆𑀲 𑀅𑀘𑁆𑀘𑀬𑁂𑀦 𑀏𑀓𑀫𑁂𑀓𑀁 𑀢𑀺𑀮𑀁 𑀉𑀤𑁆𑀥𑀭𑁂𑀬𑁆𑀬. 𑀔𑀺𑀧𑁆𑀧𑀢𑀭𑀁 𑀔𑁄 𑀲𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀯𑀻𑀲𑀢𑀺𑀔𑀸𑀭𑀺𑀓𑁄 𑀓𑁄𑀲𑀮𑀓𑁄 𑀢𑀺𑀮𑀯𑀸𑀳𑁄 ¶ 𑀇𑀫𑀺𑀦𑀸 𑀉𑀧𑀓𑁆𑀓𑀫𑁂𑀦 𑀧𑀭𑀺𑀓𑁆𑀔𑀬𑀁 𑀧𑀭𑀺𑀬𑀸𑀤𑀸𑀦𑀁 𑀕𑀘𑁆𑀙𑁂𑀬𑁆𑀬, 𑀦𑀢𑁆𑀯𑁂𑀯 𑀏𑀓𑁄 𑀅𑀩𑁆𑀩𑀼𑀤𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀅𑀩𑁆𑀩𑀼𑀤𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀦𑀺𑀭𑀩𑁆𑀩𑀼𑀤𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀦𑀺𑀭𑀩𑁆𑀩𑀼𑀤𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀅𑀩𑀩𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀅𑀩𑀩𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀅𑀳𑀳𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀅𑀳𑀳𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀅𑀝𑀝𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀅𑀝𑀝𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀓𑀼𑀫𑀼𑀤𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀓𑀼𑀫𑀼𑀤𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀲𑁄𑀕𑀦𑁆𑀥𑀺𑀓𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀲𑁄𑀕𑀦𑁆𑀥𑀺𑀓𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀉𑀧𑁆𑀧𑀮𑀓𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀉𑀧𑁆𑀧𑀮𑀓𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀲𑁂𑀬𑁆𑀬𑀣𑀸𑀧𑀺, 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀯𑀻𑀲𑀢𑀺 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀸 𑀦𑀺𑀭𑀬𑀸 𑀏𑀯𑀫𑁂𑀓𑁄 𑀧𑀤𑀼𑀫𑁄 𑀦𑀺𑀭𑀬𑁄. 𑀧𑀤𑀼𑀫𑀁 𑀔𑁄 𑀧𑀦 𑀪𑀺𑀓𑁆𑀔𑀼 𑀦𑀺𑀭𑀬𑀁 𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀉𑀧𑀧𑀦𑁆𑀦𑁄 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀲𑀼 𑀘𑀺𑀢𑁆𑀢𑀁 𑀆𑀖𑀸𑀢𑁂𑀢𑁆𑀯𑀸’’𑀢𑀺. 𑀇𑀤𑀫𑀯𑁄𑀘 𑀪𑀕𑀯𑀸, 𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀲𑀼𑀕𑀢𑁄 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 ¶ ¶ 𑀳𑀺 𑀚𑀸𑀢𑀲𑁆𑀲, 𑀓𑀼𑀞𑀸𑀭𑀻 [𑀓𑀼𑀥𑀸𑀭𑀻 (𑀓.)] 𑀚𑀸𑀬𑀢𑁂 𑀫𑀼𑀔𑁂;

𑀬𑀸𑀬 𑀙𑀺𑀦𑁆𑀤𑀢𑀺 𑀅𑀢𑁆𑀢𑀸𑀦𑀁, 𑀩𑀸𑀮𑁄 𑀤𑀼𑀩𑁆𑀪𑀸𑀲𑀺𑀢𑀁 𑀪𑀡𑀁.

‘‘𑀬𑁄 𑀦𑀺𑀦𑁆𑀤𑀺𑀬𑀁 𑀧𑀲𑀁𑀲𑀢𑀺, 𑀢𑀁 𑀯𑀸 𑀦𑀺𑀦𑁆𑀤𑀢𑀺 𑀬𑁄 𑀧𑀲𑀁𑀲𑀺𑀬𑁄;

𑀯𑀺𑀘𑀺𑀦𑀸𑀢𑀺 𑀫𑀼𑀔𑁂𑀦 𑀲𑁄 𑀓𑀮𑀺𑀁, 𑀓𑀮𑀺𑀦𑀸 ¶ 𑀢𑁂𑀦 𑀲𑀼𑀔𑀁 𑀦 𑀯𑀺𑀦𑁆𑀤𑀢𑀺.

‘‘𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄 ¶ 𑀅𑀬𑀁 𑀓𑀮𑀺, 𑀬𑁄 𑀅𑀓𑁆𑀔𑁂𑀲𑀼 𑀥𑀦𑀧𑀭𑀸𑀚𑀬𑁄;

𑀲𑀩𑁆𑀩𑀲𑁆𑀲𑀸𑀧𑀺 𑀲𑀳𑀸𑀧𑀺 𑀅𑀢𑁆𑀢𑀦𑀸, 𑀅𑀬𑀫𑁂𑀯 𑀫𑀳𑀢𑁆𑀢𑀭𑁄 [𑀫𑀳𑀦𑁆𑀢𑀓𑀭𑁄 (𑀲𑀻.)] 𑀓𑀮𑀺;

‘‘𑀲𑀢𑀁 𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀁 𑀦𑀺𑀭𑀩𑁆𑀩𑀼𑀤𑀸𑀦𑀁, 𑀙𑀢𑁆𑀢𑀺𑀁𑀲𑀢𑀺 𑀧𑀜𑁆𑀘 𑀘 𑀅𑀩𑁆𑀩𑀼𑀤𑀸𑀦𑀺 [𑀅𑀩𑁆𑀩𑀼𑀤𑀸𑀦𑀁 (𑀓.)];

𑀬𑀫𑀭𑀺𑀬𑀕𑀭𑀳𑀻 𑀦𑀺𑀭𑀬𑀁 𑀉𑀧𑁂𑀢𑀺, 𑀯𑀸𑀘𑀁 𑀫𑀦𑀜𑁆𑀘 𑀧𑀡𑀺𑀥𑀸𑀬 𑀧𑀸𑀧𑀓𑀁.

‘‘𑀅𑀪𑀽𑀢𑀯𑀸𑀤𑀻 𑀦𑀺𑀭𑀬𑀁 𑀉𑀧𑁂𑀢𑀺, 𑀬𑁄 𑀯𑀸𑀧𑀺 𑀓𑀢𑁆𑀯𑀸 𑀦 𑀓𑀭𑁄𑀫𑀺𑀘𑀸𑀳;

𑀉𑀪𑁄𑀧𑀺 𑀢𑁂 𑀧𑁂𑀘𑁆𑀘 𑀲𑀫𑀸 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀦𑀺𑀳𑀻𑀦𑀓𑀫𑁆𑀫𑀸 𑀫𑀦𑀼𑀚𑀸 𑀧𑀭𑀢𑁆𑀣.

‘‘𑀬𑁄 𑀅𑀧𑁆𑀧𑀤𑀼𑀝𑁆𑀞𑀲𑁆𑀲 𑀦𑀭𑀲𑁆𑀲 𑀤𑀼𑀲𑁆𑀲𑀢𑀺, 𑀲𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀧𑁄𑀲𑀲𑁆𑀲 𑀅𑀦𑀗𑁆𑀕𑀡𑀲𑁆𑀲;

𑀢𑀫𑁂𑀯 𑀩𑀸𑀮𑀁 𑀧𑀘𑁆𑀘𑁂𑀢𑀺 𑀧𑀸𑀧𑀁, 𑀲𑀼𑀔𑀼𑀫𑁄 𑀭𑀚𑁄 𑀧𑀝𑀺𑀯𑀸𑀢𑀁𑀯 𑀔𑀺𑀢𑁆𑀢𑁄.

‘‘𑀬𑁄 𑀮𑁄𑀪𑀕𑀼𑀡𑁂 𑀅𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑁄, 𑀲𑁄 𑀯𑀘𑀲𑀸 𑀧𑀭𑀺𑀪𑀸𑀲𑀢𑀺 𑀅𑀜𑁆𑀜𑁂;

𑀅𑀲𑀤𑁆𑀥𑁄 ¶ ¶ 𑀓𑀤𑀭𑀺𑀬𑁄 𑀅𑀯𑀤𑀜𑁆𑀜𑀽, 𑀫𑀘𑁆𑀙𑀭𑀺 𑀧𑁂𑀲𑀼𑀡𑀺𑀬𑀁 [𑀧𑁂𑀲𑀼𑀡𑀺𑀬𑀲𑁆𑀫𑀺𑀁 (𑀩𑀳𑀽𑀲𑀼)] 𑀅𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑁄.

‘‘𑀫𑀼𑀔𑀤𑀼𑀕𑁆𑀕 𑀯𑀺𑀪𑀽𑀢 𑀅𑀦𑀭𑀺𑀬, 𑀪𑀽𑀦𑀳𑀼 [𑀪𑀼𑀦𑀳𑀢 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀧𑀸𑀧𑀓 𑀤𑀼𑀓𑁆𑀓𑀝𑀓𑀸𑀭𑀺;

𑀧𑀼𑀭𑀺𑀲𑀦𑁆𑀢 𑀓𑀮𑀻 𑀅𑀯𑀚𑀸𑀢, 𑀫𑀸 𑀩𑀳𑀼𑀪𑀸𑀡𑀺𑀥 𑀦𑁂𑀭𑀬𑀺𑀓𑁄𑀲𑀺.

‘‘𑀭𑀚𑀫𑀸𑀓𑀺𑀭𑀲𑀻 ¶ 𑀅𑀳𑀺𑀢𑀸𑀬, 𑀲𑀦𑁆𑀢𑁂 𑀕𑀭𑀳𑀲𑀺 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀓𑀸𑀭𑀻;

𑀩𑀳𑀽𑀦𑀺 𑀤𑀼𑀘𑁆𑀘𑀭𑀺𑀢𑀸𑀦𑀺 𑀘𑀭𑀺𑀢𑁆𑀯𑀸, 𑀕𑀘𑁆𑀙𑀲𑀺 𑀔𑁄 𑀧𑀧𑀢𑀁 𑀘𑀺𑀭𑀭𑀢𑁆𑀢𑀁.

‘‘𑀦 𑀳𑀺 𑀦𑀲𑁆𑀲𑀢𑀺 𑀓𑀲𑁆𑀲𑀘𑀺 𑀓𑀫𑁆𑀫𑀁, 𑀏𑀢𑀺 𑀳𑀢𑀁 𑀮𑀪𑀢𑁂𑀯 𑀲𑀼𑀯𑀸𑀫𑀺;

𑀤𑀼𑀓𑁆𑀔𑀁 𑀫𑀦𑁆𑀤𑁄 𑀧𑀭𑀮𑁄𑀓𑁂, 𑀅𑀢𑁆𑀢𑀦𑀺 𑀧𑀲𑁆𑀲𑀢𑀺 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀓𑀸𑀭𑀻.

‘‘𑀅𑀬𑁄𑀲𑀗𑁆𑀓𑀼𑀲𑀫𑀸𑀳𑀢𑀝𑁆𑀞𑀸𑀦𑀁 ¶ , 𑀢𑀺𑀡𑁆𑀳𑀥𑀸𑀭𑀫𑀬𑀲𑀽𑀮𑀫𑀼𑀧𑁂𑀢𑀺;

𑀅𑀣 ¶ 𑀢𑀢𑁆𑀢𑀅𑀬𑁄𑀕𑀼𑀴𑀲𑀦𑁆𑀦𑀺𑀪𑀁, 𑀪𑁄𑀚𑀦𑀫𑀢𑁆𑀣𑀺 𑀢𑀣𑀸 𑀧𑀢𑀺𑀭𑀽𑀧𑀁.

‘‘𑀦 𑀳𑀺 𑀯𑀕𑁆𑀕𑀼 𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀤𑀦𑁆𑀢𑀸, 𑀦𑀸𑀪𑀺𑀚𑀯𑀦𑁆𑀢𑀺 𑀦 𑀢𑀸𑀡𑀫𑀼𑀧𑁂𑀦𑁆𑀢𑀺;

𑀅𑀗𑁆𑀕𑀸𑀭𑁂 ¶ 𑀲𑀦𑁆𑀣𑀢𑁂 𑀲𑀬𑀦𑁆𑀢𑀺 [𑀲𑁂𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀕𑀺𑀦𑀺𑀲𑀫𑁆𑀧𑀚𑁆𑀚𑀮𑀺𑀢𑀁 𑀧𑀯𑀺𑀲𑀦𑁆𑀢𑀺.

‘‘𑀚𑀸𑀮𑁂𑀦 𑀘 𑀑𑀦𑀳𑀺𑀬𑀸𑀦, 𑀢𑀢𑁆𑀣 𑀳𑀦𑀦𑁆𑀢𑀺 𑀅𑀬𑁄𑀫𑀬𑀓𑀼𑀝𑁂𑀪𑀺 [𑀅𑀬𑁄𑀫𑀬𑀓𑀽𑀝𑁂𑀳𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀅𑀦𑁆𑀥𑀁𑀯 𑀢𑀺𑀫𑀺𑀲𑀫𑀸𑀬𑀦𑁆𑀢𑀺, 𑀢𑀁 𑀯𑀺𑀢𑀢𑀜𑁆𑀳𑀺 𑀬𑀣𑀸 𑀫𑀳𑀺𑀓𑀸𑀬𑁄.

‘‘𑀅𑀣 𑀮𑁄𑀳𑀫𑀬𑀁 𑀧𑀦 𑀓𑀼𑀫𑁆𑀪𑀺𑀁, 𑀕𑀺𑀦𑀺𑀲𑀫𑁆𑀧𑀚𑁆𑀚𑀮𑀺𑀢𑀁 𑀧𑀯𑀺𑀲𑀦𑁆𑀢𑀺;

𑀧𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀳𑀺 𑀢𑀸𑀲𑀼 𑀘𑀺𑀭𑀭𑀢𑁆𑀢𑀁, 𑀅𑀕𑁆𑀕𑀺𑀦𑀺𑀲𑀫𑀸𑀲𑀼 [𑀕𑀺𑀦𑀺𑀲𑁆𑀲𑀫𑀸𑀲𑀼 (𑀓.)] 𑀲𑀫𑀼𑀧𑁆𑀧𑀺𑀮𑀯𑀸𑀢𑁂.

‘‘𑀅𑀣 𑀧𑀼𑀩𑁆𑀩𑀮𑁄𑀳𑀺𑀢𑀫𑀺𑀲𑁆𑀲𑁂, 𑀢𑀢𑁆𑀣 𑀓𑀺𑀁 𑀧𑀘𑁆𑀘𑀢𑀺 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀓𑀸𑀭𑀻;

𑀬𑀁 𑀬𑀁 ¶ 𑀤𑀺𑀲𑀓𑀁 [𑀤𑀺𑀲𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀅𑀥𑀺𑀲𑁂𑀢𑀺, 𑀢𑀢𑁆𑀣 𑀓𑀺𑀮𑀺𑀲𑁆𑀲𑀢𑀺 𑀲𑀫𑁆𑀨𑀼𑀲𑀫𑀸𑀦𑁄.

‘‘𑀧𑀼𑀴𑀯𑀸𑀯𑀲𑀣𑁂 ¶ 𑀲𑀮𑀺𑀮𑀲𑁆𑀫𑀺𑀁, 𑀢𑀢𑁆𑀣 𑀓𑀺𑀁 𑀧𑀘𑁆𑀘𑀢𑀺 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀓𑀸𑀭𑀻;

𑀕𑀦𑁆𑀢𑀼𑀁 𑀦 𑀳𑀺 𑀢𑀻𑀭𑀫𑀧𑀢𑁆𑀣𑀺, 𑀲𑀩𑁆𑀩𑀲𑀫𑀸 𑀳𑀺 𑀲𑀫𑀦𑁆𑀢𑀓𑀧𑀮𑁆𑀮𑀸.

‘‘𑀅𑀲𑀺𑀧𑀢𑁆𑀢𑀯𑀦𑀁 𑀧𑀦 𑀢𑀺𑀡𑁆𑀳𑀁, 𑀢𑀁 𑀧𑀯𑀺𑀲𑀦𑁆𑀢𑀺 𑀲𑀫𑀼𑀘𑁆𑀙𑀺𑀤𑀕𑀢𑁆𑀢𑀸;

𑀚𑀺𑀯𑁆𑀳𑀁 ¶ 𑀩𑀮𑀺𑀲𑁂𑀦 𑀕𑀳𑁂𑀢𑁆𑀯𑀸, 𑀆𑀭𑀚𑀬𑀸𑀭𑀚𑀬𑀸 𑀯𑀺𑀳𑀦𑀦𑁆𑀢𑀺.

‘‘𑀅𑀣 𑀯𑁂𑀢𑀭𑀡𑀺𑀁 𑀧𑀦 𑀤𑀼𑀕𑁆𑀕𑀁, 𑀢𑀺𑀡𑁆𑀳𑀥𑀸𑀭𑀔𑀼𑀭𑀥𑀸𑀭𑀫𑀼𑀧𑁂𑀦𑁆𑀢𑀺;

𑀢𑀢𑁆𑀣 𑀫𑀦𑁆𑀤𑀸 𑀧𑀧𑀢𑀦𑁆𑀢𑀺, 𑀧𑀸𑀧𑀓𑀭𑀸 𑀧𑀸𑀧𑀸𑀦𑀺 𑀓𑀭𑀺𑀢𑁆𑀯𑀸.

‘‘𑀔𑀸𑀤𑀦𑁆𑀢𑀺 ¶ 𑀳𑀺 𑀢𑀢𑁆𑀣 𑀭𑀼𑀤𑀦𑁆𑀢𑁂, 𑀲𑀸𑀫𑀸 𑀲𑀩𑀮𑀸 𑀓𑀸𑀓𑁄𑀮𑀕𑀡𑀸 𑀘;

𑀲𑁄𑀡𑀸 𑀲𑀺𑀗𑁆𑀕𑀸𑀮𑀸 [𑀲𑀺𑀕𑀸𑀮𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀝𑀺𑀕𑀺𑀤𑁆𑀥𑀸 [𑀧𑀝𑀺𑀕𑀺𑀚𑁆𑀛𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀓𑀼𑀮𑀮𑀸 𑀯𑀸𑀬𑀲𑀸 𑀘 [𑀓𑀼𑀮𑀮𑀸 𑀘 𑀯𑀸𑀬𑀲𑀸 (?)] 𑀯𑀺𑀢𑀼𑀤𑀦𑁆𑀢𑀺.

‘‘𑀓𑀺𑀘𑁆𑀙𑀸 𑀯𑀢𑀬𑀁 𑀇𑀥 𑀯𑀼𑀢𑁆𑀢𑀺, 𑀬𑀁 𑀚𑀦𑁄 𑀨𑀼𑀲𑀢𑀺 [𑀧𑀲𑁆𑀲𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀓𑀸𑀭𑀻;

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

‘‘𑀢𑁂 ¶ 𑀕𑀡𑀺𑀢𑀸 𑀯𑀺𑀤𑀽𑀳𑀺 𑀢𑀺𑀮𑀯𑀸𑀳𑀸, 𑀬𑁂 𑀧𑀤𑀼𑀫𑁂 𑀦𑀺𑀭𑀬𑁂 𑀉𑀧𑀦𑀻𑀢𑀸;

𑀦𑀳𑀼𑀢𑀸𑀦𑀺 𑀳𑀺 𑀓𑁄𑀝𑀺𑀬𑁄 𑀧𑀜𑁆𑀘 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀤𑁆𑀯𑀸𑀤𑀲 𑀓𑁄𑀝𑀺𑀲𑀢𑀸𑀦𑀺 𑀧𑀼𑀦𑀜𑁆𑀜𑀸 [𑀧𑀦𑀬𑁆𑀬𑁂 (𑀓.)].

‘‘𑀬𑀸𑀯 ¶ 𑀤𑀼𑀔𑀸 [𑀤𑀼𑀓𑁆𑀔𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀤𑀼𑀓𑁆𑀔 (𑀧𑀻. 𑀓.)] 𑀦𑀺𑀭𑀬𑀸 𑀇𑀥 𑀯𑀼𑀢𑁆𑀢𑀸, 𑀢𑀢𑁆𑀣𑀧𑀺 𑀢𑀸𑀯 𑀘𑀺𑀭𑀁 𑀯𑀲𑀺𑀢𑀩𑁆𑀩𑀁;

𑀢𑀲𑁆𑀫𑀸 ¶ 𑀲𑀼𑀘𑀺𑀧𑁂𑀲𑀮𑀲𑀸𑀥𑀼𑀕𑀼𑀡𑁂𑀲𑀼, 𑀯𑀸𑀘𑀁 𑀫𑀦𑀁 𑀲𑀢𑀢𑀁 [𑀧𑀓𑀢𑀁 (𑀲𑁆𑀬𑀸.)] 𑀧𑀭𑀺𑀭𑀓𑁆𑀔𑁂’’𑀢𑀺.

𑀓𑁄𑀓𑀸𑀮𑀺𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀆𑀦𑀦𑁆𑀤𑀚𑀸𑀢𑁂 𑀢𑀺𑀤𑀲𑀕𑀡𑁂 𑀧𑀢𑀻𑀢𑁂, 𑀲𑀓𑁆𑀓𑀜𑁆𑀘 𑀇𑀦𑁆𑀤𑀁 𑀲𑀼𑀘𑀺𑀯𑀲𑀦𑁂 𑀘 𑀤𑁂𑀯𑁂;

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

𑀤𑀺𑀲𑁆𑀯𑀸𑀦 ¶ 𑀤𑁂𑀯𑁂 𑀫𑀼𑀤𑀺𑀢𑀫𑀦𑁂 𑀉𑀤𑀕𑁆𑀕𑁂, 𑀘𑀺𑀢𑁆𑀢𑀺𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦 𑀇𑀤𑀫𑀯𑁄𑀘 [𑀓𑀭𑀺𑀢𑁆𑀯𑀸 𑀇𑀤𑀫𑀯𑁄𑀘𑀸𑀲𑀺 (𑀲𑀻.)] 𑀢𑀢𑁆𑀣;

‘‘𑀓𑀺𑀁 𑀤𑁂𑀯𑀲𑀗𑁆𑀖𑁄 𑀅𑀢𑀺𑀭𑀺𑀯 𑀓𑀮𑁆𑀬𑀭𑀽𑀧𑁄, 𑀤𑀼𑀲𑁆𑀲𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀭𑀫𑀬𑀣 [𑀪𑀫𑀬𑀣 (𑀲𑀻.)] 𑀓𑀺𑀁 𑀧𑀝𑀺𑀘𑁆𑀘.

‘‘𑀬𑀤𑀸𑀧𑀺 𑀆𑀲𑀻 𑀅𑀲𑀼𑀭𑁂𑀳𑀺 𑀲𑀗𑁆𑀕𑀫𑁄, 𑀚𑀬𑁄 𑀲𑀼𑀭𑀸𑀦𑀁 𑀅𑀲𑀼𑀭𑀸 𑀧𑀭𑀸𑀚𑀺𑀢𑀸.

𑀢𑀤𑀸𑀧𑀺 𑀦𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑁄, 𑀓𑀺𑀫𑀩𑁆𑀪𑀼𑀢𑀁 𑀤𑀝𑁆𑀞𑀼 𑀫𑀭𑀽 𑀧𑀫𑁄𑀤𑀺𑀢𑀸.

‘‘𑀲𑁂𑀴𑁂𑀦𑁆𑀢𑀺 𑀕𑀸𑀬𑀦𑁆𑀢𑀺 𑀘 𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺 𑀘, 𑀪𑀼𑀚𑀸𑀦𑀺 𑀨𑁄𑀝𑁂𑀦𑁆𑀢𑀺 [𑀧𑁄𑀞𑁂𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.), 𑀧𑁄𑀣𑁂𑀦𑁆𑀢𑀺 (𑀓.)] 𑀘 𑀦𑀘𑁆𑀘𑀬𑀦𑁆𑀢𑀺 𑀘;

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 ¶ 𑀯𑁄𑀳𑀁 𑀫𑁂𑀭𑀼𑀫𑀼𑀤𑁆𑀥𑀯𑀸𑀲𑀺𑀦𑁂, 𑀥𑀼𑀦𑀸𑀣 𑀫𑁂 𑀲𑀁𑀲𑀬𑀁 𑀔𑀺𑀧𑁆𑀧 𑀫𑀸𑀭𑀺𑀲𑀸’’.

‘‘𑀲𑁄 ¶ 𑀩𑁄𑀥𑀺𑀲𑀢𑁆𑀢𑁄 𑀭𑀢𑀦𑀯𑀭𑁄 𑀅𑀢𑀼𑀮𑁆𑀬𑁄, 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂 𑀳𑀺𑀢𑀲𑀼𑀔𑀢𑁆𑀣𑀸𑀬 [𑀳𑀺𑀢𑀲𑀼𑀔𑀢𑀸𑀬 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀚𑀸𑀢𑁄;

𑀲𑀓𑁆𑀬𑀸𑀦 𑀕𑀸𑀫𑁂 𑀚𑀦𑀧𑀤𑁂 𑀮𑀼𑀫𑁆𑀩𑀺𑀦𑁂𑀬𑁆𑀬𑁂, 𑀢𑁂𑀦𑀫𑁆𑀳 𑀢𑀼𑀝𑁆𑀞𑀸 𑀅𑀢𑀺𑀭𑀺𑀯 𑀓𑀮𑁆𑀬𑀭𑀽𑀧𑀸.

‘‘𑀲𑁄 𑀲𑀩𑁆𑀩𑀲𑀢𑁆𑀢𑀼𑀢𑁆𑀢𑀫𑁄 𑀅𑀕𑁆𑀕𑀧𑀼𑀕𑁆𑀕𑀮𑁄, 𑀦𑀭𑀸𑀲𑀪𑁄 𑀲𑀩𑁆𑀩𑀧𑀚𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑁄;

𑀯𑀢𑁆𑀢𑁂𑀲𑁆𑀲𑀢𑀺 ¶ 𑀘𑀓𑁆𑀓𑀫𑀺𑀲𑀺𑀯𑁆𑀳𑀬𑁂 𑀯𑀦𑁂, 𑀦𑀤𑀁𑀯 𑀲𑀻𑀳𑁄 𑀩𑀮𑀯𑀸 𑀫𑀺𑀕𑀸𑀪𑀺𑀪𑀽’’.

𑀢𑀁 ¶ 𑀲𑀤𑁆𑀤𑀁 𑀲𑀼𑀢𑁆𑀯𑀸 𑀢𑀼𑀭𑀺𑀢𑀫𑀯𑀲𑀭𑀻 𑀲𑁄, 𑀲𑀼𑀤𑁆𑀥𑁄𑀤𑀦𑀲𑁆𑀲 𑀢𑀤 𑀪𑀯𑀦𑀁 𑀉𑀧𑀸𑀯𑀺𑀲𑀺 [𑀉𑀧𑀸𑀕𑀫𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀦𑀺𑀲𑀚𑁆𑀚 𑀢𑀢𑁆𑀣 𑀇𑀤𑀫𑀯𑁄𑀘𑀸𑀲𑀺 𑀲𑀓𑁆𑀬𑁂, ‘‘𑀓𑀼𑀳𑀺𑀁 𑀓𑀼𑀫𑀸𑀭𑁄 𑀅𑀳𑀫𑀧𑀺 𑀤𑀝𑁆𑀞𑀼𑀓𑀸𑀫𑁄’’.

𑀢𑀢𑁄 𑀓𑀼𑀫𑀸𑀭𑀁 𑀚𑀮𑀺𑀢𑀫𑀺𑀯 𑀲𑀼𑀯𑀡𑁆𑀡𑀁, 𑀉𑀓𑁆𑀓𑀸𑀫𑀼𑀔𑁂𑀯 𑀲𑀼𑀓𑀼𑀲𑀮𑀲𑀫𑁆𑀧𑀳𑀝𑁆𑀞𑀁 [𑀲𑀼𑀓𑀼𑀲𑀮𑁂𑀦 𑀲𑀫𑁆𑀧𑀳𑀝𑁆𑀞𑀁 (𑀓.)];

𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀁 [𑀤𑀤𑁆𑀤𑀴𑁆𑀳𑀫𑀸𑀦𑀁 (𑀓.)] 𑀲𑀺𑀭𑀺𑀬𑀸 𑀅𑀦𑁄𑀫𑀯𑀡𑁆𑀡𑀁, 𑀤𑀲𑁆𑀲𑁂𑀲𑀼 𑀧𑀼𑀢𑁆𑀢𑀁 𑀅𑀲𑀺𑀢𑀯𑁆𑀳𑀬𑀲𑁆𑀲 𑀲𑀓𑁆𑀬𑀸.

𑀤𑀺𑀲𑁆𑀯𑀸 𑀓𑀼𑀫𑀸𑀭𑀁 𑀲𑀺𑀔𑀺𑀫𑀺𑀯 𑀧𑀚𑁆𑀚𑀮𑀦𑁆𑀢𑀁, 𑀢𑀸𑀭𑀸𑀲𑀪𑀁𑀯 ¶ 𑀦𑀪𑀲𑀺𑀕𑀫𑀁 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀁;

𑀲𑀽𑀭𑀺𑀬𑀁 𑀢𑀧𑀦𑁆𑀢𑀁 𑀲𑀭𑀤𑀭𑀺𑀯𑀩𑁆𑀪𑀫𑀼𑀢𑁆𑀢𑀁, 𑀆𑀦𑀦𑁆𑀤𑀚𑀸𑀢𑁄 𑀯𑀺𑀧𑀼𑀮𑀫𑀮𑀢𑁆𑀣 𑀧𑀻𑀢𑀺𑀁.

𑀅𑀦𑁂𑀓𑀲𑀸𑀔𑀜𑁆𑀘 𑀲𑀳𑀲𑁆𑀲𑀫𑀡𑁆𑀟𑀮𑀁, 𑀙𑀢𑁆𑀢𑀁 𑀫𑀭𑀽 𑀥𑀸𑀭𑀬𑀼𑀫𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂;

𑀲𑀼𑀯𑀡𑁆𑀡𑀤𑀡𑁆𑀟𑀸 𑀯𑀻𑀢𑀺𑀧𑀢𑀦𑁆𑀢𑀺 𑀘𑀸𑀫𑀭𑀸, 𑀦 𑀤𑀺𑀲𑁆𑀲𑀭𑁂 𑀘𑀸𑀫𑀭𑀙𑀢𑁆𑀢𑀕𑀸𑀳𑀓𑀸.

𑀤𑀺𑀲𑁆𑀯𑀸 ¶ ¶ 𑀚𑀝𑀻 𑀓𑀡𑁆𑀳𑀲𑀺𑀭𑀺𑀯𑁆𑀳𑀬𑁄 𑀇𑀲𑀺, 𑀲𑀼𑀯𑀡𑁆𑀡𑀦𑀺𑀓𑁆𑀔𑀁 𑀯𑀺𑀬 𑀧𑀡𑁆𑀟𑀼𑀓𑀫𑁆𑀩𑀮𑁂;

𑀲𑁂𑀢𑀜𑁆𑀘 𑀙𑀢𑁆𑀢𑀁 𑀥𑀭𑀺𑀬𑀦𑁆𑀢 [𑀥𑀸𑀭𑀺𑀬𑀦𑁆𑀢 (𑀲𑁆𑀬𑀸.), 𑀥𑀸𑀭𑀬𑀦𑁆𑀢𑀁 (𑀲𑀻. 𑀓.)] 𑀫𑀼𑀤𑁆𑀥𑀦𑀺, 𑀉𑀤𑀕𑁆𑀕𑀘𑀺𑀢𑁆𑀢𑁄 𑀲𑀼𑀫𑀦𑁄 𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑁂.

𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀧𑀦 𑀲𑀓𑁆𑀬𑀧𑀼𑀗𑁆𑀕𑀯𑀁, 𑀚𑀺𑀕𑀻𑀲𑀢𑁄 [𑀚𑀺𑀕𑀺𑀁𑀲𑀓𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀮𑀓𑁆𑀔𑀡𑀫𑀦𑁆𑀢𑀧𑀸𑀭𑀕𑀽;

𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄 𑀕𑀺𑀭𑀫𑀩𑁆𑀪𑀼𑀤𑀻𑀭𑀬𑀺, ‘‘𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑀸𑀬𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑁄’’ [𑀤𑀺𑀧𑀤𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑀅𑀣𑀢𑁆𑀢𑀦𑁄 𑀕𑀫𑀦𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀦𑁆𑀢𑁄, 𑀅𑀓𑀮𑁆𑀬𑀭𑀽𑀧𑁄 𑀕𑀴𑀬𑀢𑀺 𑀅𑀲𑁆𑀲𑀼𑀓𑀸𑀦𑀺;

𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀲𑀓𑁆𑀬𑀸 𑀇𑀲𑀺𑀫𑀯𑁄𑀘𑀼𑀁 𑀭𑀼𑀤𑀦𑁆𑀢𑀁,

‘‘𑀦𑁄 𑀘𑁂 𑀓𑀼𑀫𑀸𑀭𑁂 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺 𑀅𑀦𑁆𑀢𑀭𑀸𑀬𑁄’’.

𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀲𑀓𑁆𑀬𑁂 𑀇𑀲𑀺𑀫𑀯𑁄𑀘 𑀅𑀓𑀮𑁆𑀬𑁂, ‘‘𑀦𑀸𑀳𑀁 ¶ 𑀓𑀼𑀫𑀸𑀭𑁂 𑀅𑀳𑀺𑀢𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀸𑀫𑀺;

𑀦 𑀘𑀸𑀧𑀺𑀫𑀲𑁆𑀲 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺 𑀅𑀦𑁆𑀢𑀭𑀸𑀬𑁄, 𑀦 𑀑𑀭𑀓𑀸𑀬𑀁 𑀅𑀥𑀺𑀫𑀸𑀦𑀲𑀸 [𑀅𑀥𑀺𑀫𑀦𑀲𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀪𑀯𑀸𑀣.

‘‘𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀬𑀕𑁆𑀕𑀁 𑀨𑀼𑀲𑀺𑀲𑁆𑀲𑀢𑀸𑀬𑀁 𑀓𑀼𑀫𑀸𑀭𑁄, 𑀲𑁄 𑀥𑀫𑁆𑀫𑀘𑀓𑁆𑀓𑀁 𑀧𑀭𑀫𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀤𑀲𑁆𑀲𑀻;

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

‘‘𑀫𑀫𑀜𑁆𑀘 ¶ 𑀆𑀬𑀼 𑀦 𑀘𑀺𑀭𑀫𑀺𑀥𑀸𑀯𑀲𑁂𑀲𑁄, 𑀅𑀣𑀦𑁆𑀢𑀭𑀸 𑀫𑁂 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺 𑀓𑀸𑀮𑀓𑀺𑀭𑀺𑀬𑀸;

𑀲𑁄𑀳𑀁 𑀦 𑀲𑁄𑀲𑁆𑀲𑀁 [𑀲𑀼𑀲𑁆𑀲𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀅𑀲𑀫𑀥𑀼𑀭𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑀁, 𑀢𑁂𑀦𑀫𑁆𑀳𑀺 𑀅𑀝𑁆𑀝𑁄 𑀩𑁆𑀬𑀲𑀦𑀁𑀕𑀢𑁄 𑀅𑀖𑀸𑀯𑀻’’.

𑀲𑁄 ¶ ¶ 𑀲𑀸𑀓𑀺𑀬𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀚𑀦𑁂𑀢𑁆𑀯𑀸 𑀧𑀻𑀢𑀺𑀁, 𑀅𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑀫𑁆𑀳𑀸 𑀦𑀺𑀕𑁆𑀕𑀫𑀸 [𑀦𑀺𑀭𑀕𑀫𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀦𑀺𑀕𑀫𑀸 (𑀓. 𑀲𑀻.), 𑀦𑀺𑀭𑀕𑀫 (𑀧𑀻.)] 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀻;

𑀲𑁄 𑀪𑀸𑀕𑀺𑀦𑁂𑀬𑁆𑀬𑀁 𑀲𑀬𑀁 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀫𑀸𑀦𑁄, 𑀲𑀫𑀸𑀤𑀧𑁂𑀲𑀺 𑀅𑀲𑀫𑀥𑀼𑀭𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑁂.

‘‘𑀩𑀼𑀤𑁆𑀥𑁄𑀢𑀺 𑀖𑁄𑀲𑀁 𑀬𑀤 [𑀬𑀤𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀧𑀭𑀢𑁄 𑀲𑀼𑀡𑀸𑀲𑀺, 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀧𑀢𑁆𑀢𑁄 𑀯𑀺𑀯𑀭𑀢𑀺 𑀥𑀫𑁆𑀫𑀫𑀕𑁆𑀕𑀁;

𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀢𑀢𑁆𑀣 𑀲𑀫𑀬𑀁 𑀧𑀭𑀺𑀧𑀼𑀘𑁆𑀙𑀫𑀸𑀦𑁄 [𑀲𑀬𑀁 𑀧𑀭𑀺𑀧𑀼𑀘𑁆𑀙𑀺𑀬𑀸𑀦𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀘𑀭𑀲𑁆𑀲𑀼 𑀢𑀲𑁆𑀫𑀺𑀁 𑀪𑀕𑀯𑀢𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁’’.

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

𑀲𑁄 𑀦𑀸𑀮𑀓𑁄 𑀉𑀧𑀘𑀺𑀢𑀧𑀼𑀜𑁆𑀜𑀲𑀜𑁆𑀘𑀬𑁄, 𑀚𑀺𑀦𑀁 𑀧𑀢𑀺𑀓𑁆𑀔𑀁 [𑀧𑀢𑀺 + 𑀇𑀓𑁆𑀔𑀁 = 𑀧𑀢𑀺𑀓𑁆𑀔𑀁] 𑀧𑀭𑀺𑀯𑀲𑀺 𑀭𑀓𑁆𑀔𑀺𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁄.

𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀖𑁄𑀲𑀁 𑀚𑀺𑀦𑀯𑀭𑀘𑀓𑁆𑀓𑀯𑀢𑁆𑀢𑀦𑁂, 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀤𑀺𑀲𑁆𑀯𑀸 𑀇𑀲𑀺𑀦𑀺𑀲𑀪𑀁 𑀧𑀲𑀦𑁆𑀦𑁄;

𑀫𑁄𑀦𑁂𑀬𑁆𑀬𑀲𑁂𑀝𑁆𑀞𑀁 ¶ 𑀫𑀼𑀦𑀺𑀧𑀯𑀭𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺, 𑀲𑀫𑀸𑀕𑀢𑁂 𑀅𑀲𑀺𑀢𑀸𑀯𑁆𑀳𑀬𑀲𑁆𑀲 𑀲𑀸𑀲𑀦𑁂𑀢𑀺.

‘‘𑀅𑀜𑁆𑀜𑀸𑀢𑀫𑁂𑀢𑀁 𑀯𑀘𑀦𑀁, 𑀅𑀲𑀺𑀢𑀲𑁆𑀲 𑀬𑀣𑀸𑀢𑀣𑀁;

𑀢𑀁 𑀢𑀁 𑀕𑁄𑀢𑀫 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺, 𑀲𑀩𑁆𑀩𑀥𑀫𑁆𑀫𑀸𑀦 𑀧𑀸𑀭𑀕𑀼𑀁.

‘‘𑀅𑀦𑀕𑀸𑀭𑀺𑀬𑀼𑀧𑁂𑀢𑀲𑁆𑀲, 𑀪𑀺𑀓𑁆𑀔𑀸𑀘𑀭𑀺𑀬𑀁 𑀚𑀺𑀕𑀻𑀲𑀢𑁄;

𑀫𑀼𑀦𑀺 𑀧𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀧𑀼𑀝𑁆𑀞𑁄, 𑀫𑁄𑀦𑁂𑀬𑁆𑀬𑀁 𑀉𑀢𑁆𑀢𑀫𑀁 𑀧𑀤𑀁’’.

‘‘𑀫𑁄𑀦𑁂𑀬𑁆𑀬𑀁 𑀢𑁂 𑀉𑀧𑀜𑁆𑀜𑀺𑀲𑁆𑀲𑀁, (𑀇𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀤𑀼𑀓𑁆𑀓𑀭𑀁 𑀤𑀼𑀭𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑀁;

𑀳𑀦𑁆𑀤 𑀢𑁂 𑀦𑀁 𑀧𑀯𑀓𑁆𑀔𑀸𑀫𑀺, 𑀲𑀦𑁆𑀣𑀫𑁆𑀪𑀲𑁆𑀲𑀼 𑀤𑀴𑁆𑀳𑁄 𑀪𑀯.

‘‘𑀲𑀫𑀸𑀦𑀪𑀸𑀕𑀁 ¶ 𑀓𑀼𑀩𑁆𑀩𑁂𑀣, 𑀕𑀸𑀫𑁂 𑀅𑀓𑁆𑀓𑀼𑀝𑁆𑀞𑀯𑀦𑁆𑀤𑀺𑀢𑀁;

𑀫𑀦𑁄𑀧𑀤𑁄𑀲𑀁 𑀭𑀓𑁆𑀔𑁂𑀬𑁆𑀬, 𑀲𑀦𑁆𑀢𑁄 𑀅𑀦𑀼𑀡𑁆𑀡𑀢𑁄 𑀘𑀭𑁂.

‘‘𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑀸 ¶ ¶ 𑀦𑀺𑀘𑁆𑀙𑀭𑀦𑁆𑀢𑀺, 𑀤𑀸𑀬𑁂 𑀅𑀕𑁆𑀕𑀺𑀲𑀺𑀔𑀽𑀧𑀫𑀸;

𑀦𑀸𑀭𑀺𑀬𑁄 𑀫𑀼𑀦𑀺𑀁 𑀧𑀮𑁄𑀪𑁂𑀦𑁆𑀢𑀺, 𑀢𑀸𑀲𑀼 𑀢𑀁 𑀫𑀸 𑀧𑀮𑁄𑀪𑀬𑀼𑀁.

‘‘𑀯𑀺𑀭𑀢𑁄 𑀫𑁂𑀣𑀼𑀦𑀸 𑀥𑀫𑁆𑀫𑀸, 𑀳𑀺𑀢𑁆𑀯𑀸 𑀓𑀸𑀫𑁂 𑀧𑀭𑁄𑀧𑀭𑁂 [𑀧𑀭𑁄𑀯𑀭𑁂 (𑀲𑀻. 𑀧𑀻.), 𑀯𑀭𑀸𑀯𑀭𑁂 (𑀲𑁆𑀬𑀸.)];

𑀅𑀯𑀺𑀭𑀼𑀤𑁆𑀥𑁄 ¶ 𑀅𑀲𑀸𑀭𑀢𑁆𑀢𑁄, 𑀧𑀸𑀡𑁂𑀲𑀼 𑀢𑀲𑀣𑀸𑀯𑀭𑁂.

‘‘𑀬𑀣𑀸 𑀅𑀳𑀁 𑀢𑀣𑀸 𑀏𑀢𑁂, 𑀬𑀣𑀸 𑀏𑀢𑁂 𑀢𑀣𑀸 𑀅𑀳𑀁;

𑀅𑀢𑁆𑀢𑀸𑀦𑀁 𑀉𑀧𑀫𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀦 𑀳𑀦𑁂𑀬𑁆𑀬 𑀦 𑀖𑀸𑀢𑀬𑁂.

‘‘𑀳𑀺𑀢𑁆𑀯𑀸 𑀇𑀘𑁆𑀙𑀜𑁆𑀘 𑀮𑁄𑀪𑀜𑁆𑀘, 𑀬𑀢𑁆𑀣 𑀲𑀢𑁆𑀢𑁄 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀦𑁄;

𑀘𑀓𑁆𑀔𑀼𑀫𑀸 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑁂𑀬𑁆𑀬, 𑀢𑀭𑁂𑀬𑁆𑀬 𑀦𑀭𑀓𑀁 𑀇𑀫𑀁.

‘‘𑀊𑀦𑀽𑀤𑀭𑁄 𑀫𑀺𑀢𑀸𑀳𑀸𑀭𑁄, 𑀅𑀧𑁆𑀧𑀺𑀘𑁆𑀙𑀲𑁆𑀲 𑀅𑀮𑁄𑀮𑀼𑀧𑁄;

𑀲𑀤𑀸 [𑀲 𑀯𑁂 (𑀧𑀻.)] 𑀇𑀘𑁆𑀙𑀸𑀬 𑀦𑀺𑀘𑁆𑀙𑀸𑀢𑁄, 𑀅𑀦𑀺𑀘𑁆𑀙𑁄 𑀳𑁄𑀢𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄.

‘‘𑀲 𑀧𑀺𑀡𑁆𑀟𑀘𑀸𑀭𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸, 𑀯𑀦𑀦𑁆𑀢𑀫𑀪𑀺𑀳𑀸𑀭𑀬𑁂;

𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑁄 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀲𑁆𑀫𑀺𑀁, 𑀆𑀲𑀦𑀽𑀧𑀕𑀢𑁄 𑀫𑀼𑀦𑀺.

‘‘𑀲 𑀛𑀸𑀦𑀧𑀲𑀼𑀢𑁄 𑀥𑀻𑀭𑁄, 𑀯𑀦𑀦𑁆𑀢𑁂 𑀭𑀫𑀺𑀢𑁄 𑀲𑀺𑀬𑀸;

𑀛𑀸𑀬𑁂𑀣 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀲𑁆𑀫𑀺𑀁, 𑀅𑀢𑁆𑀢𑀸𑀦𑀫𑀪𑀺𑀢𑁄𑀲𑀬𑀁.

‘‘𑀢𑀢𑁄 𑀭𑀢𑁆𑀬𑀸 𑀯𑀺𑀯𑀲𑀸𑀦𑁂 [𑀯𑀺𑀯𑀲𑀦𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀕𑀸𑀫𑀦𑁆𑀢𑀫𑀪𑀺𑀳𑀸𑀭𑀬𑁂;

𑀅𑀯𑁆𑀳𑀸𑀦𑀁 𑀦𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑁂𑀬𑁆𑀬, 𑀅𑀪𑀺𑀳𑀸𑀭𑀜𑁆𑀘 𑀕𑀸𑀫𑀢𑁄.

‘‘𑀦 𑀫𑀼𑀦𑀻 𑀕𑀸𑀫𑀫𑀸𑀕𑀫𑁆𑀫, 𑀓𑀼𑀮𑁂𑀲𑀼 𑀲𑀳𑀲𑀸 𑀘𑀭𑁂;

𑀖𑀸𑀲𑁂𑀲𑀦𑀁 𑀙𑀺𑀦𑁆𑀦𑀓𑀣𑁄, 𑀦 𑀯𑀸𑀘𑀁 𑀧𑀬𑀼𑀢𑀁 𑀪𑀡𑁂.

‘‘𑀅𑀮𑀢𑁆𑀣𑀁 𑀬𑀤𑀺𑀤𑀁 𑀲𑀸𑀥𑀼, 𑀦𑀸𑀮𑀢𑁆𑀣𑀁 𑀓𑀼𑀲𑀮𑀁 𑀇𑀢𑀺;

𑀉𑀪𑀬𑁂𑀦𑁂𑀯 𑀲𑁄 𑀢𑀸𑀤𑀻, 𑀭𑀼𑀓𑁆𑀔𑀁𑀯𑀼𑀧𑀦𑀺𑀯𑀢𑁆𑀢𑀢𑀺 [𑀭𑀼𑀓𑁆𑀔𑀁𑀯𑀼’𑀧𑀢𑀺𑀯𑀢𑁆𑀢𑀢𑀺 (𑀓.), 𑀭𑀼𑀓𑁆𑀔𑀁𑀯 𑀉𑀧𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑀢𑀺 (𑀲𑁆𑀬𑀸.)].

‘‘𑀲 ¶ ¶ 𑀧𑀢𑁆𑀢𑀧𑀸𑀡𑀺 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑁄, 𑀅𑀫𑀽𑀕𑁄 𑀫𑀽𑀕𑀲𑀫𑁆𑀫𑀢𑁄;

𑀅𑀧𑁆𑀧𑀁 𑀤𑀸𑀦𑀁 𑀦 𑀳𑀻𑀴𑁂𑀬𑁆𑀬, 𑀤𑀸𑀢𑀸𑀭𑀁 𑀦𑀸𑀯𑀚𑀸𑀦𑀺𑀬𑀸.

‘‘𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑀸 ¶ 𑀳𑀺 𑀧𑀝𑀺𑀧𑀤𑀸, 𑀲𑀫𑀡𑁂𑀦 𑀧𑀓𑀸𑀲𑀺𑀢𑀸;

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

‘‘𑀬𑀲𑁆𑀲 𑀘 𑀯𑀺𑀲𑀢𑀸 𑀦𑀢𑁆𑀣𑀺, 𑀙𑀺𑀦𑁆𑀦𑀲𑁄𑀢𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄;

𑀓𑀺𑀘𑁆𑀘𑀸𑀓𑀺𑀘𑁆𑀘𑀧𑁆𑀧𑀳𑀻𑀦𑀲𑁆𑀲, 𑀧𑀭𑀺𑀴𑀸𑀳𑁄 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺.

‘‘𑀫𑁄𑀦𑁂𑀬𑁆𑀬𑀁 𑀢𑁂 𑀉𑀧𑀜𑁆𑀜𑀺𑀲𑁆𑀲𑀁, 𑀔𑀼𑀭𑀥𑀸𑀭𑀽𑀧𑀫𑁄 𑀪𑀯𑁂;

𑀚𑀺𑀯𑁆𑀳𑀸𑀬 𑀢𑀸𑀮𑀼𑀫𑀸𑀳𑀘𑁆𑀘, 𑀉𑀤𑀭𑁂 𑀲𑀜𑁆𑀜𑀢𑁄 𑀲𑀺𑀬𑀸.

‘‘𑀅𑀮𑀻𑀦𑀘𑀺𑀢𑁆𑀢𑁄 𑀘 𑀲𑀺𑀬𑀸, 𑀦 𑀘𑀸𑀧𑀺 𑀩𑀳𑀼 𑀘𑀺𑀦𑁆𑀢𑀬𑁂;

𑀦𑀺𑀭𑀸𑀫𑀕𑀦𑁆𑀥𑁄 𑀅𑀲𑀺𑀢𑁄, 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀧𑀭𑀸𑀬𑀡𑁄.

‘‘𑀏𑀓𑀸𑀲𑀦𑀲𑁆𑀲 𑀲𑀺𑀓𑁆𑀔𑁂𑀣, 𑀲𑀫𑀡𑀽𑀧𑀸𑀲𑀦𑀲𑁆𑀲 𑀘;

𑀏𑀓𑀢𑁆𑀢𑀁 𑀫𑁄𑀦𑀫𑀓𑁆𑀔𑀸𑀢𑀁, 𑀏𑀓𑁄 𑀘𑁂 𑀅𑀪𑀺𑀭𑀫𑀺𑀲𑁆𑀲𑀲𑀺;

𑀅𑀣 𑀪𑀸𑀳𑀺𑀲𑀺 [𑀪𑀸𑀲𑀺𑀳𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀤𑀲𑀤𑀺𑀲𑀸.

‘‘𑀲𑀼𑀢𑁆𑀯𑀸 𑀥𑀻𑀭𑀸𑀦𑀁 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑀁, 𑀛𑀸𑀬𑀻𑀦𑀁 𑀓𑀸𑀫𑀘𑀸𑀕𑀺𑀦𑀁;

𑀢𑀢𑁄 𑀳𑀺𑀭𑀺𑀜𑁆𑀘 𑀲𑀤𑁆𑀥𑀜𑁆𑀘, 𑀪𑀺𑀬𑁆𑀬𑁄 𑀓𑀼𑀩𑁆𑀩𑁂𑀣 𑀫𑀸𑀫𑀓𑁄.

‘‘𑀢𑀁 ¶ 𑀦𑀤𑀻𑀳𑀺 𑀯𑀺𑀚𑀸𑀦𑀸𑀣, 𑀲𑁄𑀩𑁆𑀪𑁂𑀲𑀼 𑀧𑀤𑀭𑁂𑀲𑀼 𑀘;

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

‘‘𑀬𑀤𑀽𑀦𑀓𑀁 𑀢𑀁 𑀲𑀡𑀢𑀺, 𑀬𑀁 𑀧𑀽𑀭𑀁 𑀲𑀦𑁆𑀢𑀫𑁂𑀯 𑀢𑀁;

𑀅𑀟𑁆𑀠𑀓𑀼𑀫𑁆𑀪𑀽𑀧𑀫𑁄 𑀩𑀸𑀮𑁄, 𑀭𑀳𑀤𑁄 𑀧𑀽𑀭𑁄𑀯 𑀧𑀡𑁆𑀟𑀺𑀢𑁄.

‘‘𑀬𑀁 𑀲𑀫𑀡𑁄 𑀩𑀳𑀼𑀁 𑀪𑀸𑀲𑀢𑀺, 𑀉𑀧𑁂𑀢𑀁 𑀅𑀢𑁆𑀣𑀲𑀜𑁆𑀳𑀺𑀢𑀁;

𑀚𑀸𑀦𑀁 𑀲𑁄 𑀥𑀫𑁆𑀫𑀁 𑀤𑁂𑀲𑁂𑀢𑀺, 𑀚𑀸𑀦𑀁 𑀲𑁄 𑀩𑀳𑀼 𑀪𑀸𑀲𑀢𑀺.

‘‘𑀬𑁄 ¶ 𑀘 𑀚𑀸𑀦𑀁 𑀲𑀁𑀬𑀢𑀢𑁆𑀢𑁄, 𑀚𑀸𑀦𑀁 𑀦 𑀩𑀳𑀼 𑀪𑀸𑀲𑀢𑀺;

𑀲 ¶ 𑀫𑀼𑀦𑀻 𑀫𑁄𑀦𑀫𑀭𑀳𑀢𑀺, 𑀲 𑀫𑀼𑀦𑀻 𑀫𑁄𑀦𑀫𑀚𑁆𑀛𑀕𑀸’’𑀢𑀺.

𑀦𑀸𑀮𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀏𑀓𑀸𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁧𑁨. 𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸𑀲𑀼𑀢𑁆𑀢𑀁

𑀏𑀯𑀁 𑀫𑁂 𑀲𑀼𑀢𑀁 𑁋 𑀏𑀓𑀁 𑀲𑀫𑀬𑀁 𑀪𑀕𑀯𑀸 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀯𑀺𑀳𑀭𑀢𑀺 𑀧𑀼𑀩𑁆𑀩𑀸𑀭𑀸𑀫𑁂 𑀫𑀺𑀕𑀸𑀭𑀫𑀸𑀢𑀼𑀧𑀸𑀲𑀸𑀤𑁂. 𑀢𑁂𑀦 𑀔𑁄 𑀧𑀦 𑀲𑀫𑀬𑁂𑀦 𑀪𑀕𑀯𑀸 𑀢𑀤𑀳𑀼𑀧𑁄𑀲𑀣𑁂 𑀧𑀦𑁆𑀦𑀭𑀲𑁂 ¶ 𑀧𑀼𑀡𑁆𑀡𑀸𑀬 𑀧𑀼𑀡𑁆𑀡𑀫𑀸𑀬 𑀭𑀢𑁆𑀢𑀺𑀬𑀸 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀧𑀭𑀺𑀯𑀼𑀢𑁄 𑀅𑀩𑁆𑀪𑁄𑀓𑀸𑀲𑁂 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀳𑁄𑀢𑀺 ¶ . 𑀅𑀣 𑀔𑁄 𑀪𑀕𑀯𑀸 𑀢𑀼𑀡𑁆𑀳𑀻𑀪𑀽𑀢𑀁 𑀢𑀼𑀡𑁆𑀳𑀻𑀪𑀽𑀢𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀁 𑀅𑀦𑀼𑀯𑀺𑀮𑁄𑀓𑁂𑀢𑁆𑀯𑀸 𑀪𑀺𑀓𑁆𑀔𑀽 𑀆𑀫𑀦𑁆𑀢𑁂𑀲𑀺 𑁋

‘‘‘𑀬𑁂 𑀢𑁂, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀓𑀼𑀲𑀮𑀸 𑀥𑀫𑁆𑀫𑀸 𑀅𑀭𑀺𑀬𑀸 𑀦𑀺𑀬𑁆𑀬𑀸𑀦𑀺𑀓𑀸 𑀲𑀫𑁆𑀩𑁄𑀥𑀕𑀸𑀫𑀺𑀦𑁄, 𑀢𑁂𑀲𑀁 𑀯𑁄, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀓𑀼𑀲𑀮𑀸𑀦𑀁 𑀥𑀫𑁆𑀫𑀸𑀦𑀁 𑀅𑀭𑀺𑀬𑀸𑀦𑀁 𑀦𑀺𑀬𑁆𑀬𑀸𑀦𑀺𑀓𑀸𑀦𑀁 𑀲𑀫𑁆𑀩𑁄𑀥𑀕𑀸𑀫𑀻𑀦𑀁 𑀓𑀸 𑀉𑀧𑀦𑀺𑀲𑀸 𑀲𑀯𑀦𑀸𑀬𑀸’𑀢𑀺 𑀇𑀢𑀺 𑀘𑁂, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀭𑁄 𑀅𑀲𑁆𑀲𑀼, 𑀢𑁂 𑀏𑀯𑀫𑀲𑁆𑀲𑀼 𑀯𑀘𑀦𑀻𑀬𑀸 𑁋 ‘𑀬𑀸𑀯𑀤𑁂𑀯 𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀁 𑀥𑀫𑁆𑀫𑀸𑀦𑀁 𑀬𑀣𑀸𑀪𑀽𑀢𑀁 𑀜𑀸𑀡𑀸𑀬𑀸’𑀢𑀺. 𑀓𑀺𑀜𑁆𑀘 𑀤𑁆𑀯𑀬𑀢𑀁 𑀯𑀤𑁂𑀣?

(𑁧) ‘‘𑀇𑀤𑀁 𑀤𑀼𑀓𑁆𑀔𑀁, 𑀅𑀬𑀁 𑀤𑀼𑀓𑁆𑀔𑀲𑀫𑀼𑀤𑀬𑁄𑀢𑀺 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀅𑀬𑀁 𑀤𑀼𑀓𑁆𑀔𑀦𑀺𑀭𑁄𑀥𑁄, 𑀅𑀬𑀁 𑀤𑀼𑀓𑁆𑀔𑀦𑀺𑀭𑁄𑀥𑀕𑀸𑀫𑀺𑀦𑀻 𑀧𑀝𑀺𑀧𑀤𑀸𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸 𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀺𑀦𑁄 𑀔𑁄, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀲𑁆𑀲 𑀆𑀢𑀸𑀧𑀺𑀦𑁄 𑀧𑀳𑀺𑀢𑀢𑁆𑀢𑀲𑁆𑀲 𑀯𑀺𑀳𑀭𑀢𑁄 𑀤𑁆𑀯𑀺𑀦𑁆𑀦𑀁 𑀨𑀮𑀸𑀦𑀁 𑀅𑀜𑁆𑀜𑀢𑀭𑀁 𑀨𑀮𑀁 𑀧𑀸𑀝𑀺𑀓𑀗𑁆𑀔𑀁 𑁋 𑀤𑀺𑀝𑁆𑀞𑁂𑀯 𑀥𑀫𑁆𑀫𑁂 𑀅𑀜𑁆𑀜𑀸, 𑀲𑀢𑀺 𑀯𑀸 ¶ 𑀉𑀧𑀸𑀤𑀺𑀲𑁂𑀲𑁂 𑀅𑀦𑀸𑀕𑀸𑀫𑀺𑀢𑀸’’𑀢𑀺.

𑀇𑀤𑀫𑀯𑁄𑀘 𑀪𑀕𑀯𑀸. 𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀲𑀼𑀕𑀢𑁄 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀬𑁂 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀧𑁆𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀅𑀣𑁄 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑀁;

𑀬𑀢𑁆𑀣 𑀘 𑀲𑀩𑁆𑀩𑀲𑁄 𑀤𑀼𑀓𑁆𑀔𑀁, 𑀅𑀲𑁂𑀲𑀁 𑀉𑀧𑀭𑀼𑀚𑁆𑀛𑀢𑀺;

𑀢𑀜𑁆𑀘 𑀫𑀕𑁆𑀕𑀁 𑀦 𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀤𑀼𑀓𑁆𑀔𑀽𑀧𑀲𑀫𑀕𑀸𑀫𑀺𑀦𑀁.

‘‘𑀘𑁂𑀢𑁄𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀺𑀳𑀻𑀦𑀸 𑀢𑁂, 𑀅𑀣𑁄 𑀧𑀜𑁆𑀜𑀸𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀺𑀬𑀸;

𑀅𑀪𑀩𑁆𑀩𑀸 𑀢𑁂 𑀅𑀦𑁆𑀢𑀓𑀺𑀭𑀺𑀬𑀸𑀬, 𑀢𑁂 𑀯𑁂 𑀚𑀸𑀢𑀺𑀚𑀭𑀽𑀧𑀕𑀸.

‘‘𑀬𑁂 ¶ 𑀘 𑀤𑀼𑀓𑁆𑀔𑀁 𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀅𑀣𑁄 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑀁;

𑀬𑀢𑁆𑀣 𑀘 𑀲𑀩𑁆𑀩𑀲𑁄 𑀤𑀼𑀓𑁆𑀔𑀁, 𑀅𑀲𑁂𑀲𑀁 𑀉𑀧𑀭𑀼𑀚𑁆𑀛𑀢𑀺;

𑀢𑀜𑁆𑀘 ¶ 𑀫𑀕𑁆𑀕𑀁 𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀤𑀼𑀓𑁆𑀔𑀽𑀧𑀲𑀫𑀕𑀸𑀫𑀺𑀦𑀁.

‘‘𑀘𑁂𑀢𑁄𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀺𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀅𑀣𑁄 𑀧𑀜𑁆𑀜𑀸𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀺𑀬𑀸;

𑀪𑀩𑁆𑀩𑀸 𑀢𑁂 𑀅𑀦𑁆𑀢𑀓𑀺𑀭𑀺𑀬𑀸𑀬, 𑀦 𑀢𑁂 𑀚𑀸𑀢𑀺𑀚𑀭𑀽𑀧𑀕𑀸’’𑀢𑀺.

(𑁨) ‘‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺 𑀧𑀭𑀺𑀬𑀸𑀬𑁂𑀦 𑀲𑀫𑁆𑀫𑀸 𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸’𑀢𑀺, 𑀇𑀢𑀺 𑀘𑁂, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀭𑁄 𑀅𑀲𑁆𑀲𑀼; ‘𑀲𑀺𑀬𑀸’𑀢𑀺𑀲𑁆𑀲𑀼 𑀯𑀘𑀦𑀻𑀬𑀸. 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀉𑀧𑀥𑀺𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀉𑀧𑀥𑀻𑀦𑀁 ¶ 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀉𑀧𑀥𑀺𑀦𑀺𑀤𑀸𑀦𑀸 𑀧𑀪𑀯𑀦𑁆𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑀸, 𑀬𑁂 ¶ 𑀓𑁂𑀘𑀺 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀫𑀦𑁂𑀓𑀭𑀽𑀧𑀸;

𑀬𑁄 𑀯𑁂 𑀅𑀯𑀺𑀤𑁆𑀯𑀸 𑀉𑀧𑀥𑀺𑀁 𑀓𑀭𑁄𑀢𑀺, 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁 𑀤𑀼𑀓𑁆𑀔𑀫𑀼𑀧𑁂𑀢𑀺 𑀫𑀦𑁆𑀤𑁄;

𑀢𑀲𑁆𑀫𑀸 𑀧𑀚𑀸𑀦𑀁 𑀉𑀧𑀥𑀺𑀁 𑀦 𑀓𑀬𑀺𑀭𑀸, 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀚𑀸𑀢𑀺𑀧𑁆𑀧𑀪𑀯𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀻’’𑀢𑀺.

(𑁩) ‘‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺 𑀧𑀭𑀺𑀬𑀸𑀬𑁂𑀦 𑀲𑀫𑁆𑀫𑀸 𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸’𑀢𑀺, 𑀇𑀢𑀺 𑀘𑁂, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀭𑁄 𑀅𑀲𑁆𑀲𑀼; ‘𑀲𑀺𑀬𑀸’𑀢𑀺𑀲𑁆𑀲𑀼 𑀯𑀘𑀦𑀻𑀬𑀸. 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀅𑀯𑀺𑀚𑁆𑀚𑀸𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀅𑀯𑀺𑀚𑁆𑀚𑀸𑀬 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀚𑀸𑀢𑀺𑀫𑀭𑀡𑀲𑀁𑀲𑀸𑀭𑀁 ¶ , 𑀬𑁂 𑀯𑀚𑀦𑁆𑀢𑀺 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁;

𑀇𑀢𑁆𑀣𑀪𑀸𑀯𑀜𑁆𑀜𑀣𑀸𑀪𑀸𑀯𑀁, 𑀅𑀯𑀺𑀚𑁆𑀚𑀸𑀬𑁂𑀯 𑀲𑀸 𑀕𑀢𑀺.

‘‘𑀅𑀯𑀺𑀚𑁆𑀚𑀸 𑀳𑀸𑀬𑀁 𑀫𑀳𑀸𑀫𑁄𑀳𑁄, 𑀬𑁂𑀦𑀺𑀤𑀁 𑀲𑀁𑀲𑀺𑀢𑀁 𑀘𑀺𑀭𑀁;

𑀯𑀺𑀚𑁆𑀚𑀸𑀕𑀢𑀸 𑀘 𑀬𑁂 𑀲𑀢𑁆𑀢𑀸, 𑀦 𑀢𑁂 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 [𑀦𑀸𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀼𑀦𑀩𑁆𑀪𑀯’’𑀦𑁆𑀢𑀺.

(𑁪) ‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀲𑀗𑁆𑀔𑀸𑀭𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀲𑀗𑁆𑀔𑀸𑀭𑀸𑀦𑀁 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀬𑀁 ¶ ¶ 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺, 𑀲𑀩𑁆𑀩𑀁 𑀲𑀗𑁆𑀔𑀸𑀭𑀧𑀘𑁆𑀘𑀬𑀸;

𑀲𑀗𑁆𑀔𑀸𑀭𑀸𑀦𑀁 𑀦𑀺𑀭𑁄𑀥𑁂𑀦, 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄.

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀗𑁆𑀔𑀸𑀭𑀧𑀘𑁆𑀘𑀬𑀸;

𑀲𑀩𑁆𑀩𑀲𑀗𑁆𑀔𑀸𑀭𑀲𑀫𑀣𑀸, 𑀲𑀜𑁆𑀜𑀸𑀦𑀁 𑀉𑀧𑀭𑁄𑀥𑀦𑀸;

𑀏𑀯𑀁 𑀤𑀼𑀓𑁆𑀔𑀓𑁆𑀔𑀬𑁄 𑀳𑁄𑀢𑀺, 𑀏𑀢𑀁 𑀜𑀢𑁆𑀯𑀸 𑀬𑀣𑀸𑀢𑀣𑀁.

‘‘𑀲𑀫𑁆𑀫𑀤𑁆𑀤𑀲𑀸 𑀯𑁂𑀤𑀕𑀼𑀦𑁄, 𑀲𑀫𑁆𑀫𑀤𑀜𑁆𑀜𑀸𑀬 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

𑀅𑀪𑀺𑀪𑀼𑀬𑁆𑀬 𑀫𑀸𑀭𑀲𑀁𑀬𑁄𑀕𑀁, 𑀦 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 [𑀦𑀸𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀼𑀦𑀩𑁆𑀪𑀯’’𑀦𑁆𑀢𑀺.

(𑁫) ‘‘𑀲𑀺𑀬𑀸 ¶ ¶ 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀲𑁆𑀲 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺, 𑀲𑀩𑁆𑀩𑀁 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀧𑀘𑁆𑀘𑀬𑀸;

𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀲𑁆𑀲 𑀦𑀺𑀭𑁄𑀥𑁂𑀦, 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄.

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀧𑀘𑁆𑀘𑀬𑀸;

𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀽𑀧𑀲𑀫𑀸 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀦𑀺𑀘𑁆𑀙𑀸𑀢𑁄 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄’’𑀢𑀺.

(𑁬) ‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀨𑀲𑁆𑀲𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀨𑀲𑁆𑀲𑀲𑁆𑀲 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 ¶ 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀢𑁂𑀲𑀁 𑀨𑀲𑁆𑀲𑀧𑀭𑁂𑀢𑀸𑀦𑀁, 𑀪𑀯𑀲𑁄𑀢𑀸𑀦𑀼𑀲𑀸𑀭𑀺𑀦𑀁;

𑀓𑀼𑀫𑁆𑀫𑀕𑁆𑀕𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀸𑀦𑀁, 𑀆𑀭𑀸 𑀲𑀁𑀬𑁄𑀚𑀦𑀓𑁆𑀔𑀬𑁄.

‘‘𑀬𑁂 𑀘 𑀨𑀲𑁆𑀲𑀁 𑀧𑀭𑀺𑀜𑁆𑀜𑀸𑀬, 𑀅𑀜𑁆𑀜𑀸𑀬𑀼𑀧𑀲𑀫𑁂 [𑀧𑀜𑁆𑀜𑀸𑀬 𑀉𑀧𑀲𑀫𑁂 (𑀲𑁆𑀬𑀸.)] 𑀭𑀢𑀸;

𑀢𑁂 𑀯𑁂 𑀨𑀲𑁆𑀲𑀸𑀪𑀺𑀲𑀫𑀬𑀸, 𑀦𑀺𑀘𑁆𑀙𑀸𑀢𑀸 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀸’’𑀢𑀺.

(𑁭) ‘‘𑀲𑀺𑀬𑀸 ¶ 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀯𑁂𑀤𑀦𑀸𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀯𑁂𑀤𑀦𑀸𑀦𑀁 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀲𑀼𑀔𑀁 ¶ 𑀯𑀸 𑀬𑀤𑀺 𑀯𑀸 𑀤𑀼𑀓𑁆𑀔𑀁, 𑀅𑀤𑀼𑀓𑁆𑀔𑀫𑀲𑀼𑀔𑀁 𑀲𑀳;

𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀜𑁆𑀘 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘, 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀅𑀢𑁆𑀣𑀺 𑀯𑁂𑀤𑀺𑀢𑀁.

‘‘𑀏𑀢𑀁 𑀤𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑀺 𑀜𑀢𑁆𑀯𑀸𑀦, 𑀫𑁄𑀲𑀥𑀫𑁆𑀫𑀁 𑀧𑀮𑁄𑀓𑀺𑀦𑀁 [𑀧𑀮𑁄𑀓𑀺𑀢𑀁 (𑀲𑀻.)];

𑀨𑀼𑀲𑁆𑀲 𑀨𑀼𑀲𑁆𑀲 𑀯𑀬𑀁 𑀧𑀲𑁆𑀲𑀁, 𑀏𑀯𑀁 𑀢𑀢𑁆𑀣 𑀯𑀺𑀚𑀸𑀦𑀢𑀺 [𑀯𑀺𑀭𑀚𑁆𑀚𑀢𑀺 (𑀓. 𑀲𑀻.)];

𑀯𑁂𑀤𑀦𑀸𑀦𑀁 𑀔𑀬𑀸 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀦𑀺𑀘𑁆𑀙𑀸𑀢𑁄 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄’’𑀢𑀺.

(𑁮) ‘‘𑀲𑀺𑀬𑀸 ¶ 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀢𑀡𑁆𑀳𑀸𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀢𑀡𑁆𑀳𑀸𑀬 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀢𑀡𑁆𑀳𑀸𑀤𑀼𑀢𑀺𑀬𑁄 ¶ 𑀧𑀼𑀭𑀺𑀲𑁄, 𑀤𑀻𑀖𑀫𑀤𑁆𑀥𑀸𑀦 𑀲𑀁𑀲𑀭𑀁;

𑀇𑀢𑁆𑀣𑀪𑀸𑀯𑀜𑁆𑀜𑀣𑀸𑀪𑀸𑀯𑀁, 𑀲𑀁𑀲𑀸𑀭𑀁 𑀦𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑀢𑀺.

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀢𑀡𑁆𑀳𑀁 [𑀢𑀡𑁆𑀳𑀸 (𑀩𑀳𑀽𑀲𑀼) 𑀇𑀢𑀺𑀯𑀼𑀢𑁆𑀢𑀓𑁂 𑁧𑁫 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀁] 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑀁;

𑀯𑀻𑀢𑀢𑀡𑁆𑀳𑁄 𑀅𑀦𑀸𑀤𑀸𑀦𑁄, 𑀲𑀢𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂’’𑀢𑀺.

(𑁯) ‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀉𑀧𑀸𑀤𑀸𑀦𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀉𑀧𑀸𑀤𑀸𑀦𑀸𑀦𑀁 [𑀉𑀧𑀸𑀤𑀸𑀦𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀉𑀧𑀸𑀤𑀸𑀦𑀧𑀘𑁆𑀘𑀬𑀸 𑀪𑀯𑁄, 𑀪𑀽𑀢𑁄 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀢𑀺;

𑀚𑀸𑀢𑀲𑁆𑀲 𑀫𑀭𑀡𑀁 𑀳𑁄𑀢𑀺, 𑀏𑀲𑁄 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄.

‘‘𑀢𑀲𑁆𑀫𑀸 𑀉𑀧𑀸𑀤𑀸𑀦𑀓𑁆𑀔𑀬𑀸, 𑀲𑀫𑁆𑀫𑀤𑀜𑁆𑀜𑀸𑀬 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

𑀚𑀸𑀢𑀺𑀓𑁆𑀔𑀬𑀁 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀬, 𑀦 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀧𑀼𑀦𑀩𑁆𑀪𑀯’’𑀦𑁆𑀢𑀺.

(𑁧𑁦) ‘‘𑀲𑀺𑀬𑀸 ¶ ¶ 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀆𑀭𑀫𑁆𑀪𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀆𑀭𑀫𑁆𑀪𑀸𑀦𑀁 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺, 𑀲𑀩𑁆𑀩𑀁 𑀆𑀭𑀫𑁆𑀪𑀧𑀘𑁆𑀘𑀬𑀸;

𑀆𑀭𑀫𑁆𑀪𑀸𑀦𑀁 𑀦𑀺𑀭𑁄𑀥𑁂𑀦, 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄.

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 ¶ 𑀜𑀢𑁆𑀯𑀸, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀆𑀭𑀫𑁆𑀪𑀧𑀘𑁆𑀘𑀬𑀸;

𑀲𑀩𑁆𑀩𑀸𑀭𑀫𑁆𑀪𑀁 𑀧𑀝𑀺𑀦𑀺𑀲𑁆𑀲𑀚𑁆𑀚, 𑀅𑀦𑀸𑀭𑀫𑁆𑀪𑁂 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀺𑀦𑁄.

‘‘𑀉𑀘𑁆𑀙𑀺𑀦𑁆𑀦𑀪𑀯𑀢𑀡𑁆𑀳𑀲𑁆𑀲, 𑀲𑀦𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄;

𑀯𑀺𑀓𑁆𑀔𑀻𑀡𑁄 [𑀯𑀺𑀢𑀺𑀡𑁆𑀡𑁄 (𑀲𑀻.)] 𑀚𑀸𑀢𑀺𑀲𑀁𑀲𑀸𑀭𑁄, 𑀦𑀢𑁆𑀣𑀺 𑀢𑀲𑁆𑀲 𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑁄’’𑀢𑀺.

(𑁧𑁧) ‘‘𑀲𑀺𑀬𑀸 ¶ 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀆𑀳𑀸𑀭𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀆𑀳𑀸𑀭𑀸𑀦𑀁 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺, 𑀲𑀩𑁆𑀩𑀁 𑀆𑀳𑀸𑀭𑀧𑀘𑁆𑀘𑀬𑀸;

𑀆𑀳𑀸𑀭𑀸𑀦𑀁 𑀦𑀺𑀭𑁄𑀥𑁂𑀦, 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄.

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀆𑀳𑀸𑀭𑀧𑀘𑁆𑀘𑀬𑀸;

𑀲𑀩𑁆𑀩𑀸𑀳𑀸𑀭𑀁 𑀧𑀭𑀺𑀜𑁆𑀜𑀸𑀬, 𑀲𑀩𑁆𑀩𑀸𑀳𑀸𑀭𑀫𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄.

‘‘𑀆𑀭𑁄𑀕𑁆𑀬𑀁 ¶ 𑀲𑀫𑁆𑀫𑀤𑀜𑁆𑀜𑀸𑀬, 𑀆𑀲𑀯𑀸𑀦𑀁 𑀧𑀭𑀺𑀓𑁆𑀔𑀬𑀸;

𑀲𑀗𑁆𑀔𑀸𑀬 𑀲𑁂𑀯𑀻 𑀥𑀫𑁆𑀫𑀝𑁆𑀞𑁄, 𑀲𑀗𑁆𑀔𑁆𑀬𑀁 [𑀲𑀗𑁆𑀔𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀦𑁄𑀧𑁂𑀢𑀺 𑀯𑁂𑀤𑀕𑀽’’𑀢𑀺.

(𑁧𑁨) ‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺 𑀲𑀩𑁆𑀩𑀁 𑀇𑀜𑁆𑀚𑀺𑀢𑀧𑀘𑁆𑀘𑀬𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀇𑀜𑁆𑀚𑀺𑀢𑀸𑀦𑀁 𑀢𑁆𑀯𑁂𑀯 𑀅𑀲𑁂𑀲𑀯𑀺𑀭𑀸𑀕𑀦𑀺𑀭𑁄𑀥𑀸 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀬𑀁 ¶ ¶ 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀲𑀫𑁆𑀪𑁄𑀢𑀺, 𑀲𑀩𑁆𑀩𑀁 𑀇𑀜𑁆𑀚𑀺𑀢𑀧𑀘𑁆𑀘𑀬𑀸;

𑀇𑀜𑁆𑀚𑀺𑀢𑀸𑀦𑀁 𑀦𑀺𑀭𑁄𑀥𑁂𑀦, 𑀦𑀢𑁆𑀣𑀺 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄.

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀇𑀜𑁆𑀚𑀺𑀢𑀧𑀘𑁆𑀘𑀬𑀸;

𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀏𑀚𑀁 𑀯𑁄𑀲𑁆𑀲𑀚𑁆𑀚, 𑀲𑀗𑁆𑀔𑀸𑀭𑁂 𑀉𑀧𑀭𑀼𑀦𑁆𑀥𑀺𑀬;

𑀅𑀦𑁂𑀚𑁄 𑀅𑀦𑀼𑀧𑀸𑀤𑀸𑀦𑁄, 𑀲𑀢𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂’’𑀢𑀺.

(𑁧𑁩) ‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀲𑁆𑀲 𑀘𑀮𑀺𑀢𑀁 𑀳𑁄𑀢𑀻𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀦 𑀘𑀮𑀢𑀻𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀦 𑀘𑀮𑀢𑀺, 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀘 𑀉𑀧𑀸𑀤𑀺𑀬𑀁;

𑀇𑀢𑁆𑀣𑀪𑀸𑀯𑀜𑁆𑀜𑀣𑀸𑀪𑀸𑀯𑀁, 𑀲𑀁𑀲𑀸𑀭𑀁 𑀦𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑀢𑀺.

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀦𑀺𑀲𑁆𑀲𑀬𑁂𑀲𑀼 𑀫𑀳𑀩𑁆𑀪𑀬𑀁;

𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀅𑀦𑀼𑀧𑀸𑀤𑀸𑀦𑁄, 𑀲𑀢𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂’’𑀢𑀺.

(𑁧𑁪) ‘‘𑀲𑀺𑀬𑀸 ¶ 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀭𑀽𑀧𑁂𑀳𑀺, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀅𑀭𑀽𑀧𑀸 [𑀆𑀭𑀼𑀧𑁆𑀧𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀦𑁆𑀢𑀢𑀭𑀸𑀢𑀺, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀅𑀭𑀽𑀧𑁂𑀳𑀺 ¶ 𑀦𑀺𑀭𑁄𑀥𑁄 𑀲𑀦𑁆𑀢𑀢𑀭𑁄𑀢𑀺, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀬𑁂 𑀘 𑀭𑀽𑀧𑀽𑀧𑀕𑀸 𑀲𑀢𑁆𑀢𑀸, 𑀬𑁂 𑀘 𑀅𑀭𑀽𑀧𑀝𑁆𑀞𑀸𑀬𑀺𑀦𑁄 [𑀆𑀭𑀼𑀧𑁆𑀧𑀯𑀸𑀲𑀺𑀦𑁄 (𑀲𑀻. 𑀧𑀻.)];

𑀦𑀺𑀭𑁄𑀥𑀁 𑀅𑀧𑁆𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀸, 𑀆𑀕𑀦𑁆𑀢𑀸𑀭𑁄 𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑀁.

‘‘𑀬𑁂 𑀘 𑀭𑀽𑀧𑁂 𑀧𑀭𑀺𑀜𑁆𑀜𑀸𑀬, 𑀅𑀭𑀽𑀧𑁂𑀲𑀼 𑀅𑀲𑀡𑁆𑀞𑀺𑀢𑀸 [𑀲𑀼𑀲𑀡𑁆𑀞𑀺𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀦𑀺𑀭𑁄𑀥𑁂 ¶ 𑀬𑁂 𑀯𑀺𑀫𑀼𑀘𑁆𑀘𑀦𑁆𑀢𑀺, 𑀢𑁂 𑀚𑀦𑀸 𑀫𑀘𑁆𑀘𑀼𑀳𑀸𑀬𑀺𑀦𑁄’’𑀢𑀺.

(𑁧𑁫) ‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺…𑀧𑁂… 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲 𑀲𑀫𑀸𑀭𑀓𑀲𑁆𑀲 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑀲𑁆𑀲 𑀲𑀲𑁆𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀺𑀬𑀸 𑀧𑀚𑀸𑀬 𑀲𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀬 𑀇𑀤𑀁 𑀲𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀉𑀧𑀦𑀺𑀚𑁆𑀛𑀸𑀬𑀺𑀢𑀁 𑀢𑀤𑀫𑀭𑀺𑀬𑀸𑀦𑀁 𑀏𑀢𑀁 𑀫𑀼𑀲𑀸𑀢𑀺 𑀬𑀣𑀸𑀪𑀽𑀢𑀁 𑀲𑀫𑁆𑀫𑀧𑁆𑀧𑀜𑁆𑀜𑀸𑀬 𑀲𑀼𑀤𑀺𑀝𑁆𑀞𑀁, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀬𑀁 ¶ , 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲…𑀧𑁂… 𑀲𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀬 𑀇𑀤𑀁 𑀫𑀼𑀲𑀸𑀢𑀺 𑀉𑀧𑀦𑀺𑀚𑁆𑀛𑀸𑀬𑀺𑀢𑀁, 𑀢𑀤𑀫𑀭𑀺𑀬𑀸𑀦𑀁 𑀏𑀢𑀁 𑀲𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀬𑀣𑀸𑀪𑀽𑀢𑀁 𑀲𑀫𑁆𑀫𑀧𑁆𑀧𑀜𑁆𑀜𑀸𑀬 𑀲𑀼𑀤𑀺𑀝𑁆𑀞𑀁, 𑀅𑀬𑀁 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸…𑀧𑁂… 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀅𑀦𑀢𑁆𑀢𑀦𑀺 𑀅𑀢𑁆𑀢𑀫𑀸𑀦𑀺𑀁 [𑀅𑀢𑁆𑀢𑀫𑀸𑀦𑀻 (𑀲𑁆𑀬𑀸.), 𑀅𑀢𑁆𑀢𑀫𑀸𑀦𑀁 (𑀧𑀻. 𑀓.)], 𑀧𑀲𑁆𑀲 𑀮𑁄𑀓𑀁 𑀲𑀤𑁂𑀯𑀓𑀁;

𑀦𑀺𑀯𑀺𑀝𑁆𑀞𑀁 𑀦𑀸𑀫𑀭𑀽𑀧𑀲𑁆𑀫𑀺𑀁, 𑀇𑀤𑀁 𑀲𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀫𑀜𑁆𑀜𑀢𑀺.

‘‘𑀬𑁂𑀦 𑀬𑁂𑀦 𑀳𑀺 𑀫𑀜𑁆𑀜𑀦𑁆𑀢𑀺, 𑀢𑀢𑁄 𑀢𑀁 𑀳𑁄𑀢𑀺 𑀅𑀜𑁆𑀜𑀣𑀸;

𑀢𑀜𑁆𑀳𑀺 𑀢𑀲𑁆𑀲 𑀫𑀼𑀲𑀸 𑀳𑁄𑀢𑀺, 𑀫𑁄𑀲𑀥𑀫𑁆𑀫𑀜𑁆𑀳𑀺 𑀇𑀢𑁆𑀢𑀭𑀁.

‘‘𑀅𑀫𑁄𑀲𑀥𑀫𑁆𑀫𑀁 ¶ 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀁, 𑀢𑀤𑀭𑀺𑀬𑀸 𑀲𑀘𑁆𑀘𑀢𑁄 𑀯𑀺𑀤𑀽;

𑀢𑁂 𑀯𑁂 𑀲𑀘𑁆𑀘𑀸𑀪𑀺𑀲𑀫𑀬𑀸, 𑀦𑀺𑀘𑁆𑀙𑀸𑀢𑀸 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀸’’𑀢𑀺.

(𑁧𑁬) ‘‘‘𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑁂𑀦𑀧𑀺 𑀧𑀭𑀺𑀬𑀸𑀬𑁂𑀦 𑀲𑀫𑁆𑀫𑀸 𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸’𑀢𑀺, 𑀇𑀢𑀺 𑀘𑁂, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀭𑁄 𑀅𑀲𑁆𑀲𑀼; ‘𑀲𑀺𑀬𑀸’𑀢𑀺𑀲𑁆𑀲𑀼 𑀯𑀘𑀦𑀻𑀬𑀸. 𑀓𑀣𑀜𑁆𑀘 𑀲𑀺𑀬𑀸? 𑀬𑀁, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲 𑀲𑀫𑀸𑀭𑀓𑀲𑁆𑀲 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑀲𑁆𑀲 𑀲𑀲𑁆𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀺𑀬𑀸 𑀧𑀚𑀸𑀬 𑀲𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀬 𑀇𑀤𑀁 𑀲𑀼𑀔𑀦𑁆𑀢𑀺 𑀉𑀧𑀦𑀺𑀚𑁆𑀛𑀸𑀬𑀺𑀢𑀁, 𑀢𑀤𑀫𑀭𑀺𑀬𑀸𑀦𑀁 𑀏𑀢𑀁 𑀤𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑀺 𑀬𑀣𑀸𑀪𑀽𑀢𑀁 𑀲𑀫𑁆𑀫𑀧𑁆𑀧𑀜𑁆𑀜𑀸𑀬 𑀲𑀼𑀤𑀺𑀝𑁆𑀞𑀁, 𑀅𑀬𑀫𑁂𑀓𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸 ¶ . 𑀬𑀁, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲…𑀧𑁂… 𑀲𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀬 𑀇𑀤𑀁 𑀤𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑀺 𑀉𑀧𑀦𑀺𑀚𑁆𑀛𑀸𑀬𑀺𑀢𑀁 𑀢𑀤𑀫𑀭𑀺𑀬𑀸𑀦𑀁 𑀏𑀢𑀁 𑀲𑀼𑀔𑀦𑁆𑀢𑀺 𑀬𑀣𑀸𑀪𑀽𑀢𑀁 𑀲𑀫𑁆𑀫𑀧𑁆𑀧𑀜𑁆𑀜𑀸𑀬 𑀲𑀼𑀤𑀺𑀝𑁆𑀞𑀁, 𑀅𑀬𑀁 ¶ 𑀤𑀼𑀢𑀺𑀬𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸. 𑀏𑀯𑀁 𑀲𑀫𑁆𑀫𑀸 𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀺𑀦𑁄 𑀔𑁄, 𑀪𑀺𑀓𑁆𑀔𑀯𑁂, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀲𑁆𑀲 𑀆𑀢𑀸𑀧𑀺𑀦𑁄 𑀧𑀳𑀺𑀢𑀢𑁆𑀢𑀲𑁆𑀲 𑀯𑀺𑀳𑀭𑀢𑁄 𑀤𑁆𑀯𑀺𑀦𑁆𑀦𑀁 𑀨𑀮𑀸𑀦𑀁 𑀅𑀜𑁆𑀜𑀢𑀭𑀁 𑀨𑀮𑀁 𑀧𑀸𑀝𑀺𑀓𑀗𑁆𑀔𑀁 𑁋 𑀤𑀺𑀝𑁆𑀞𑁂𑀯 𑀥𑀫𑁆𑀫𑁂 𑀅𑀜𑁆𑀜𑀸, 𑀲𑀢𑀺 𑀯𑀸 𑀉𑀧𑀸𑀤𑀺𑀲𑁂𑀲𑁂 𑀅𑀦𑀸𑀕𑀸𑀫𑀺𑀢𑀸𑀢𑀺. 𑀇𑀤𑀫𑀯𑁄𑀘 𑀪𑀕𑀯𑀸. 𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀲𑀼𑀕𑀢𑁄 𑀅𑀣𑀸𑀧𑀭𑀁 𑀏𑀢𑀤𑀯𑁄𑀘 𑀲𑀢𑁆𑀣𑀸 𑁋

‘‘𑀭𑀽𑀧𑀸 𑀲𑀤𑁆𑀤𑀸 𑀭𑀲𑀸 𑀕𑀦𑁆𑀥𑀸, 𑀨𑀲𑁆𑀲𑀸 𑀥𑀫𑁆𑀫𑀸 𑀘 𑀓𑁂𑀯𑀮𑀸;

𑀇𑀝𑁆𑀞𑀸 𑀓𑀦𑁆𑀢𑀸 𑀫𑀦𑀸𑀧𑀸 𑀘, 𑀬𑀸𑀯𑀢𑀢𑁆𑀣𑀻𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

‘‘𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀏𑀢𑁂 𑀯𑁄 𑀲𑀼𑀔𑀲𑀫𑁆𑀫𑀢𑀸;

𑀬𑀢𑁆𑀣 𑀘𑁂𑀢𑁂 𑀦𑀺𑀭𑀼𑀚𑁆𑀛𑀦𑁆𑀢𑀺, 𑀢𑀁 𑀦𑁂𑀲𑀁 𑀤𑀼𑀓𑁆𑀔𑀲𑀫𑁆𑀫𑀢𑀁.

‘‘𑀲𑀼𑀔𑀦𑁆𑀢𑀺 ¶ 𑀤𑀺𑀝𑁆𑀞𑀫𑀭𑀺𑀬𑁂𑀳𑀺, 𑀲𑀓𑁆𑀓𑀸𑀬𑀲𑁆𑀲𑀼𑀧𑀭𑁄𑀥𑀦𑀁;

𑀧𑀘𑁆𑀘𑀦𑀻𑀓𑀫𑀺𑀤𑀁 𑀳𑁄𑀢𑀺, 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑁂𑀦 𑀧𑀲𑁆𑀲𑀢𑀁.

‘‘𑀬𑀁 ¶ 𑀧𑀭𑁂 𑀲𑀼𑀔𑀢𑁄 𑀆𑀳𑀼, 𑀢𑀤𑀭𑀺𑀬𑀸 𑀆𑀳𑀼 𑀤𑀼𑀓𑁆𑀔𑀢𑁄;

𑀬𑀁 𑀧𑀭𑁂 𑀤𑀼𑀓𑁆𑀔𑀢𑁄 𑀆𑀳𑀼, 𑀢𑀤𑀭𑀺𑀬𑀸 𑀲𑀼𑀔𑀢𑁄 𑀯𑀺𑀤𑀽.

‘‘𑀧𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑀁 𑀤𑀼𑀭𑀸𑀚𑀸𑀦𑀁, 𑀲𑀫𑁆𑀧𑀫𑀽𑀴𑁆𑀳𑁂𑀢𑁆𑀣𑀯𑀺𑀤𑁆𑀤𑀲𑀼 [𑀲𑀫𑁆𑀧𑀫𑀽𑀴𑁆𑀳𑁂𑀢𑁆𑀣 𑀅𑀯𑀺𑀤𑁆𑀤𑀲𑀼 (𑀲𑀻. 𑀧𑀻.), 𑀲𑀫𑁆𑀫𑀽𑀴𑁆𑀳𑁂𑀢𑁆𑀣 𑀅𑀯𑀺𑀤𑁆𑀤𑀲𑀼 (?)];

𑀦𑀺𑀯𑀼𑀢𑀸𑀦𑀁 𑀢𑀫𑁄 𑀳𑁄𑀢𑀺, 𑀅𑀦𑁆𑀥𑀓𑀸𑀭𑁄 𑀅𑀧𑀲𑁆𑀲𑀢𑀁.

‘‘𑀲𑀢𑀜𑁆𑀘 𑀯𑀺𑀯𑀝𑀁 𑀳𑁄𑀢𑀺, 𑀆𑀮𑁄𑀓𑁄 𑀧𑀲𑁆𑀲𑀢𑀸𑀫𑀺𑀯;

𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀦 𑀯𑀺𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀫𑀕𑁆𑀕𑀸 𑀥𑀫𑁆𑀫𑀲𑁆𑀲 𑀓𑁄𑀯𑀺𑀤𑀸.

‘‘𑀪𑀯𑀭𑀸𑀕𑀧𑀭𑁂𑀢𑁂𑀳𑀺 ¶ , 𑀪𑀯𑀲𑁄𑀢𑀸𑀦𑀼𑀲𑀸𑀭𑀺𑀪𑀺;

𑀫𑀸𑀭𑀥𑁂𑀬𑁆𑀬𑀸𑀦𑀼𑀧𑀦𑁆𑀦𑁂𑀳𑀺, 𑀦𑀸𑀬𑀁 𑀥𑀫𑁆𑀫𑁄 𑀲𑀼𑀲𑀫𑁆𑀩𑀼𑀥𑁄.

‘‘𑀓𑁄 𑀦𑀼 𑀅𑀜𑁆𑀜𑀢𑁆𑀭𑀫𑀭𑀺𑀬𑁂𑀳𑀺, 𑀧𑀤𑀁 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀼𑀫𑀭𑀳𑀢𑀺;

𑀬𑀁 𑀧𑀤𑀁 𑀲𑀫𑁆𑀫𑀤𑀜𑁆𑀜𑀸𑀬, 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀦𑁆𑀢𑀺 𑀅𑀦𑀸𑀲𑀯𑀸’’𑀢𑀺.

𑀇𑀤𑀫𑀯𑁄𑀘 𑀪𑀕𑀯𑀸. 𑀅𑀢𑁆𑀢𑀫𑀦𑀸 𑀢𑁂 𑀪𑀺𑀓𑁆𑀔𑀽 𑀪𑀕𑀯𑀢𑁄 𑀪𑀸𑀲𑀺𑀢𑀁 𑀅𑀪𑀺𑀦𑀦𑁆𑀤𑀼𑀦𑁆𑀢𑀺. 𑀇𑀫𑀲𑁆𑀫𑀺𑀁 𑀘 [𑀇𑀫𑀲𑁆𑀫𑀺𑀁 𑀔𑁄 (𑀲𑀻.)] 𑀧𑀦 𑀯𑁂𑀬𑁆𑀬𑀸𑀓𑀭𑀡𑀲𑁆𑀫𑀺𑀁 𑀪𑀜𑁆𑀜𑀫𑀸𑀦𑁂 𑀲𑀝𑁆𑀞𑀺𑀫𑀢𑁆𑀢𑀸𑀦𑀁 𑀪𑀺𑀓𑁆𑀔𑀽𑀦𑀁 𑀅𑀦𑀼𑀧𑀸𑀤𑀸𑀬 𑀆𑀲𑀯𑁂𑀳𑀺 𑀘𑀺𑀢𑁆𑀢𑀸𑀦𑀺 𑀯𑀺𑀫𑀼𑀘𑁆𑀘𑀺𑀁𑀲𑀽𑀢𑀺.

𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀲𑀘𑁆𑀘𑀁 ¶ 𑀉𑀧𑀥𑀺 𑀅𑀯𑀺𑀚𑁆𑀚𑀸 𑀘, 𑀲𑀗𑁆𑀔𑀸𑀭𑁂 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀧𑀜𑁆𑀘𑀫𑀁;

𑀨𑀲𑁆𑀲𑀯𑁂𑀤𑀦𑀺𑀬𑀸 𑀢𑀡𑁆𑀳𑀸, 𑀉𑀧𑀸𑀤𑀸𑀦𑀸𑀭𑀫𑁆𑀪𑀆𑀳𑀸𑀭𑀸;

𑀇𑀜𑁆𑀚𑀺𑀢𑀁 𑀘𑀮𑀺𑀢𑀁 𑀭𑀽𑀧𑀁, 𑀲𑀘𑁆𑀘𑀁 𑀤𑀼𑀓𑁆𑀔𑁂𑀦 𑀲𑁄𑀴𑀲𑀸𑀢𑀺.

𑀫𑀳𑀸𑀯𑀕𑁆𑀕𑁄 𑀢𑀢𑀺𑀬𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀸 𑀘 𑀧𑀥𑀸𑀦𑀜𑁆𑀘, 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀜𑁆𑀘 𑀲𑀼𑀦𑁆𑀤𑀭𑀺;

𑀫𑀸𑀖𑀲𑀼𑀢𑁆𑀢𑀁 𑀲𑀪𑀺𑀬𑁄 𑀘, 𑀲𑁂𑀮𑁄 𑀲𑀮𑁆𑀮𑀜𑁆𑀘 𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑁄 𑀘𑀸𑀧𑀺 𑀓𑁄𑀓𑀸𑀮𑀺, 𑀦𑀸𑀮𑀓𑁄 𑀤𑁆𑀯𑀬𑀢𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀦𑀸;

𑀤𑁆𑀯𑀸𑀤𑀲𑁂𑀢𑀸𑀦𑀺 𑀲𑀼𑀢𑁆𑀢𑀸𑀦𑀺, 𑀫𑀳𑀸𑀯𑀕𑁆𑀕𑁄𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀻𑀢𑀺.

𑀓𑀸𑀫𑀁 ¶ ¶ ¶ ¶ 𑀓𑀸𑀫𑀬𑀫𑀸𑀦𑀲𑁆𑀲, 𑀢𑀲𑁆𑀲 𑀘𑁂 𑀢𑀁 𑀲𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀅𑀤𑁆𑀥𑀸 𑀧𑀻𑀢𑀺𑀫𑀦𑁄 𑀳𑁄𑀢𑀺, 𑀮𑀤𑁆𑀥𑀸 𑀫𑀘𑁆𑀘𑁄 𑀬𑀤𑀺𑀘𑁆𑀙𑀢𑀺.

𑀢𑀲𑁆𑀲 𑀘𑁂 𑀓𑀸𑀫𑀬𑀸𑀦𑀲𑁆𑀲 [𑀓𑀸𑀫𑀬𑀫𑀸𑀦𑀲𑁆𑀲 (𑀓.)], 𑀙𑀦𑁆𑀤𑀚𑀸𑀢𑀲𑁆𑀲 𑀚𑀦𑁆𑀢𑀼𑀦𑁄;

𑀢𑁂 𑀓𑀸𑀫𑀸 𑀧𑀭𑀺𑀳𑀸𑀬𑀦𑁆𑀢𑀺, 𑀲𑀮𑁆𑀮𑀯𑀺𑀤𑁆𑀥𑁄𑀯 𑀭𑀼𑀧𑁆𑀧𑀢𑀺.

𑀬𑁄 𑀓𑀸𑀫𑁂 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑁂𑀢𑀺, 𑀲𑀧𑁆𑀧𑀲𑁆𑀲𑁂𑀯 𑀧𑀤𑀸 𑀲𑀺𑀭𑁄;

𑀲𑁄𑀫𑀁 [𑀲𑁄 𑀇𑀫𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀁 𑀮𑁄𑀓𑁂, 𑀲𑀢𑁄 𑀲𑀫𑀢𑀺𑀯𑀢𑁆𑀢𑀢𑀺.

𑀔𑁂𑀢𑁆𑀢𑀁 𑀯𑀢𑁆𑀣𑀼𑀁 𑀳𑀺𑀭𑀜𑁆𑀜𑀁 𑀯𑀸, 𑀕𑀯𑀲𑁆𑀲𑀁 [𑀕𑀯𑀸𑀲𑁆𑀲𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀤𑀸𑀲𑀧𑁄𑀭𑀺𑀲𑀁;

𑀣𑀺𑀬𑁄 𑀩𑀦𑁆𑀥𑀽 𑀧𑀼𑀣𑀼 𑀓𑀸𑀫𑁂, 𑀬𑁄 𑀦𑀭𑁄 𑀅𑀦𑀼𑀕𑀺𑀚𑁆𑀛𑀢𑀺.

𑀅𑀩𑀮𑀸 𑀦𑀁 𑀩𑀮𑀻𑀬𑀦𑁆𑀢𑀺, 𑀫𑀤𑁆𑀤𑀦𑁆𑀢𑁂𑀦𑀁 𑀧𑀭𑀺𑀲𑁆𑀲𑀬𑀸;

𑀢𑀢𑁄 𑀦𑀁 𑀤𑀼𑀓𑁆𑀔𑀫𑀦𑁆𑀯𑁂𑀢𑀺, 𑀦𑀸𑀯𑀁 𑀪𑀺𑀦𑁆𑀦𑀫𑀺𑀯𑁄𑀤𑀓𑀁.

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

𑀢𑁂 𑀧𑀳𑀸𑀬 𑀢𑀭𑁂 𑀑𑀖𑀁, 𑀦𑀸𑀯𑀁 𑀲𑀺𑀢𑁆𑀯𑀸𑀯 [𑀲𑀺𑀜𑁆𑀘𑀺𑀢𑁆𑀯𑀸 (𑀲𑀻.)] 𑀧𑀸𑀭𑀕𑀽𑀢𑀺.

𑀓𑀸𑀫𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀲𑀢𑁆𑀢𑁄 ¶ ¶ 𑀕𑀼𑀳𑀸𑀬𑀁 𑀩𑀳𑀼𑀦𑀸𑀪𑀺𑀙𑀦𑁆𑀦𑁄, 𑀢𑀺𑀝𑁆𑀞𑀁 𑀦𑀭𑁄 𑀫𑁄𑀳𑀦𑀲𑁆𑀫𑀺𑀁 𑀧𑀕𑀸𑀴𑁆𑀳𑁄;

𑀤𑀽𑀭𑁂 ¶ 𑀯𑀺𑀯𑁂𑀓𑀸 𑀳𑀺 𑀢𑀣𑀸𑀯𑀺𑀥𑁄 𑀲𑁄, 𑀓𑀸𑀫𑀸 𑀳𑀺 𑀮𑁄𑀓𑁂 𑀦 𑀳𑀺 𑀲𑀼𑀧𑁆𑀧𑀳𑀸𑀬𑀸.

𑀇𑀘𑁆𑀙𑀸𑀦𑀺𑀤𑀸𑀦𑀸 ¶ 𑀪𑀯𑀲𑀸𑀢𑀩𑀤𑁆𑀥𑀸, 𑀢𑁂 𑀤𑀼𑀧𑁆𑀧𑀫𑀼𑀜𑁆𑀘𑀸 𑀦 𑀳𑀺 𑀅𑀜𑁆𑀜𑀫𑁄𑀓𑁆𑀔𑀸;

𑀧𑀘𑁆𑀙𑀸 𑀧𑀼𑀭𑁂 𑀯𑀸𑀧𑀺 𑀅𑀧𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑀸, 𑀇𑀫𑁂𑀯 𑀓𑀸𑀫𑁂 𑀧𑀼𑀭𑀺𑀫𑁂𑀯 𑀚𑀧𑁆𑀧𑀁.

𑀓𑀸𑀫𑁂𑀲𑀼 𑀕𑀺𑀤𑁆𑀥𑀸 𑀧𑀲𑀼𑀢𑀸 𑀧𑀫𑀽𑀴𑁆𑀳𑀸, 𑀅𑀯𑀤𑀸𑀦𑀺𑀬𑀸 𑀢𑁂 𑀯𑀺𑀲𑀫𑁂 𑀦𑀺𑀯𑀺𑀝𑁆𑀞𑀸;

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

𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀲𑀺𑀓𑁆𑀔𑁂𑀣 𑀇𑀥𑁂𑀯 𑀚𑀦𑁆𑀢𑀼, 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀚𑀜𑁆𑀜𑀸 𑀯𑀺𑀲𑀫𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂;

𑀦 𑀢𑀲𑁆𑀲 𑀳𑁂𑀢𑀽 𑀯𑀺𑀲𑀫𑀁 𑀘𑀭𑁂𑀬𑁆𑀬, 𑀅𑀧𑁆𑀧𑀜𑁆𑀳𑀺𑀤𑀁 𑀚𑀻𑀯𑀺𑀢𑀫𑀸𑀳𑀼 𑀥𑀻𑀭𑀸.

𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀮𑁄𑀓𑁂 𑀧𑀭𑀺𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑀁, 𑀧𑀚𑀁 𑀇𑀫𑀁 𑀢𑀡𑁆𑀳𑀕𑀢𑀁 𑀪𑀯𑁂𑀲𑀼;

𑀳𑀻𑀦𑀸 ¶ 𑀦𑀭𑀸 𑀫𑀘𑁆𑀘𑀼𑀫𑀼𑀔𑁂 𑀮𑀧𑀦𑁆𑀢𑀺, 𑀅𑀯𑀻𑀢𑀢𑀡𑁆𑀳𑀸𑀲𑁂 𑀪𑀯𑀸𑀪𑀯𑁂𑀲𑀼.

𑀫𑀫𑀸𑀬𑀺𑀢𑁂 𑀧𑀲𑁆𑀲𑀣 𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑁂, 𑀫𑀘𑁆𑀙𑁂𑀯 𑀅𑀧𑁆𑀧𑁄𑀤𑀓𑁂 𑀔𑀻𑀡𑀲𑁄𑀢𑁂;

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

𑀉𑀪𑁄𑀲𑀼 𑀅𑀦𑁆𑀢𑁂𑀲𑀼 𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀙𑀦𑁆𑀤𑀁, 𑀨𑀲𑁆𑀲𑀁 𑀧𑀭𑀺𑀜𑁆𑀜𑀸𑀬 𑀅𑀦𑀸𑀦𑀼𑀕𑀺𑀤𑁆𑀥𑁄;

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

𑀲𑀜𑁆𑀜𑀁 ¶ 𑀧𑀭𑀺𑀜𑁆𑀜𑀸 𑀯𑀺𑀢𑀭𑁂𑀬𑁆𑀬 𑀑𑀖𑀁, 𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑁂𑀲𑀼 𑀫𑀼𑀦𑀺 𑀦𑁄𑀧𑀮𑀺𑀢𑁆𑀢𑁄;

𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀲𑀮𑁆𑀮𑁄 𑀘𑀭𑀫𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄, 𑀦𑀸𑀲𑀻𑀲𑀢𑀻 [𑀦𑀸𑀲𑀺𑀁𑀲𑀢𑀻 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀮𑁄𑀓𑀫𑀺𑀫𑀁 𑀧𑀭𑀜𑁆𑀘𑀸𑀢𑀺.

𑀕𑀼𑀳𑀝𑁆𑀞𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑀼𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀯𑀤𑀦𑁆𑀢𑀺 ¶ ¶ ¶ 𑀯𑁂 𑀤𑀼𑀝𑁆𑀞𑀫𑀦𑀸𑀧𑀺 𑀏𑀓𑁂, 𑀅𑀣𑁄𑀧𑀺 𑀯𑁂 𑀲𑀘𑁆𑀘𑀫𑀦𑀸 𑀯𑀤𑀦𑁆𑀢𑀺;

𑀯𑀸𑀤𑀜𑁆𑀘 𑀚𑀸𑀢𑀁 𑀫𑀼𑀦𑀺 𑀦𑁄 𑀉𑀧𑁂𑀢𑀺, 𑀢𑀲𑁆𑀫𑀸 𑀫𑀼𑀦𑀻 𑀦𑀢𑁆𑀣𑀺 𑀔𑀺𑀮𑁄 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺.

𑀲𑀓𑀜𑁆𑀳𑀺 𑀤𑀺𑀝𑁆𑀞𑀺𑀁 𑀓𑀣𑀫𑀘𑁆𑀘𑀬𑁂𑀬𑁆𑀬, 𑀙𑀦𑁆𑀤𑀸𑀦𑀼𑀦𑀻𑀢𑁄 𑀭𑀼𑀘𑀺𑀬𑀸 𑀦𑀺𑀯𑀺𑀝𑁆𑀞𑁄;

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

𑀬𑁄 𑀅𑀢𑁆𑀢𑀦𑁄 𑀲𑀻𑀮𑀯𑀢𑀸𑀦𑀺 𑀚𑀦𑁆𑀢𑀼, 𑀅𑀦𑀸𑀦𑀼𑀧𑀼𑀝𑁆𑀞𑁄𑀯 𑀧𑀭𑁂𑀲 [𑀧𑀭𑀲𑁆𑀲 (𑀓.)] 𑀧𑀸𑀯 [𑀧𑀸𑀯𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀅𑀦𑀭𑀺𑀬𑀥𑀫𑁆𑀫𑀁 𑀓𑀼𑀲𑀮𑀸 𑀢𑀫𑀸𑀳𑀼, 𑀬𑁄 𑀆𑀢𑀼𑀫𑀸𑀦𑀁 𑀲𑀬𑀫𑁂𑀯 𑀧𑀸𑀯.

𑀲𑀦𑁆𑀢𑁄 𑀘 𑀪𑀺𑀓𑁆𑀔𑀼 𑀅𑀪𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀢𑁆𑀢𑁄, 𑀇𑀢𑀺𑀳𑀦𑁆𑀢𑀺 𑀲𑀻𑀮𑁂𑀲𑀼 𑀅𑀓𑀢𑁆𑀣𑀫𑀸𑀦𑁄;

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

𑀧𑀓𑀧𑁆𑀧𑀺𑀢𑀸 ¶ 𑀲𑀗𑁆𑀔𑀢𑀸 𑀬𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑀸, 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑀸 [𑀧𑀼𑀭𑁂𑀓𑁆𑀔𑀢𑀸 (𑀲𑀻.)] 𑀲𑀦𑁆𑀢𑀺 𑀅𑀯𑀻𑀯𑀤𑀸𑀢𑀸;

𑀬𑀤𑀢𑁆𑀢𑀦𑀺 ¶ 𑀧𑀲𑁆𑀲𑀢𑀺 𑀆𑀦𑀺𑀲𑀁𑀲𑀁, 𑀢𑀁 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀓𑀼𑀧𑁆𑀧𑀧𑀝𑀺𑀘𑁆𑀘 𑀲𑀦𑁆𑀢𑀺𑀁.

𑀤𑀺𑀝𑁆𑀞𑀻𑀦𑀺𑀯𑁂𑀲𑀸 𑀦 𑀳𑀺 𑀲𑁆𑀯𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑀸, 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀦𑀺𑀘𑁆𑀙𑁂𑀬𑁆𑀬 𑀲𑀫𑀼𑀕𑁆𑀕𑀳𑀻𑀢𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀦𑀭𑁄 𑀢𑁂𑀲𑀼 𑀦𑀺𑀯𑁂𑀲𑀦𑁂𑀲𑀼, 𑀦𑀺𑀭𑀲𑁆𑀲𑀢𑀻 𑀆𑀤𑀺𑀬𑀢𑀻 𑀘 𑀥𑀫𑁆𑀫𑀁.

𑀥𑁄𑀦𑀲𑁆𑀲 ¶ 𑀳𑀺 𑀦𑀢𑁆𑀣𑀺 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺 𑀮𑁄𑀓𑁂, 𑀧𑀓𑀧𑁆𑀧𑀺𑀢𑀸 𑀤𑀺𑀝𑁆𑀞𑀺 𑀪𑀯𑀸𑀪𑀯𑁂𑀲𑀼;

𑀫𑀸𑀬𑀜𑁆𑀘 𑀫𑀸𑀦𑀜𑁆𑀘 𑀧𑀳𑀸𑀬 𑀥𑁄𑀦𑁄, 𑀲 𑀓𑁂𑀦 𑀕𑀘𑁆𑀙𑁂𑀬𑁆𑀬 𑀅𑀦𑀽𑀧𑀬𑁄 𑀲𑁄.

𑀉𑀧𑀬𑁄 𑀳𑀺 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀉𑀧𑁂𑀢𑀺 𑀯𑀸𑀤𑀁, 𑀅𑀦𑀽𑀧𑀬𑀁 𑀓𑁂𑀦 𑀓𑀣𑀁 𑀯𑀤𑁂𑀬𑁆𑀬;

𑀅𑀢𑁆𑀢𑀸 𑀦𑀺𑀭𑀢𑁆𑀢𑀸 [𑀅𑀢𑁆𑀢𑀁 𑀦𑀺𑀭𑀢𑁆𑀢𑀁 (𑀩𑀳𑀽𑀲𑀼)] 𑀦 𑀳𑀺 𑀢𑀲𑁆𑀲 𑀅𑀢𑁆𑀣𑀺, 𑀅𑀥𑁄𑀲𑀺 𑀲𑁄 𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑀺𑀥𑁂𑀯 𑀲𑀩𑁆𑀩𑀦𑁆𑀢𑀺.

𑀤𑀼𑀝𑁆𑀞𑀝𑁆𑀞𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀢𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀧𑀲𑁆𑀲𑀸𑀫𑀺 ¶ 𑀲𑀼𑀤𑁆𑀥𑀁 𑀧𑀭𑀫𑀁 𑀅𑀭𑁄𑀕𑀁, 𑀤𑀺𑀝𑁆𑀞𑁂𑀦 𑀲𑀁𑀲𑀼𑀤𑁆𑀥𑀺 𑀦𑀭𑀲𑁆𑀲 𑀳𑁄𑀢𑀺;

𑀏𑀯𑀸𑀪𑀺𑀚𑀸𑀦𑀁 ¶ [𑀏𑀢𑀸𑀪𑀺𑀚𑀸𑀦𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀭𑀫𑀦𑁆𑀢𑀺 𑀜𑀢𑁆𑀯𑀸, 𑀲𑀼𑀤𑁆𑀥𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀻𑀢𑀺 𑀧𑀘𑁆𑀘𑁂𑀢𑀺 𑀜𑀸𑀡𑀁.

𑀤𑀺𑀝𑁆𑀞𑁂𑀦 ¶ 𑀘𑁂 𑀲𑀼𑀤𑁆𑀥𑀺 𑀦𑀭𑀲𑁆𑀲 𑀳𑁄𑀢𑀺, 𑀜𑀸𑀡𑁂𑀦 𑀯𑀸 𑀲𑁄 𑀧𑀚𑀳𑀸𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑀁;

𑀅𑀜𑁆𑀜𑁂𑀦 𑀲𑁄 𑀲𑀼𑀚𑁆𑀛𑀢𑀺 𑀲𑁄𑀧𑀥𑀻𑀓𑁄, 𑀤𑀺𑀝𑁆𑀞𑀻 𑀳𑀺 𑀦𑀁 𑀧𑀸𑀯 𑀢𑀣𑀸 𑀯𑀤𑀸𑀦𑀁.

𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀅𑀜𑁆𑀜𑀢𑁄 𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀸𑀳, 𑀤𑀺𑀝𑁆𑀞𑁂 𑀲𑀼𑀢𑁂 𑀲𑀻𑀮𑀯𑀢𑁂 𑀫𑀼𑀢𑁂 𑀯𑀸;

𑀧𑀼𑀜𑁆𑀜𑁂 𑀘 𑀧𑀸𑀧𑁂 𑀘 𑀅𑀦𑀽𑀧𑀮𑀺𑀢𑁆𑀢𑁄, 𑀅𑀢𑁆𑀢𑀜𑁆𑀚𑀳𑁄 𑀦𑀬𑀺𑀥 𑀧𑀓𑀼𑀩𑁆𑀩𑀫𑀸𑀦𑁄.

𑀧𑀼𑀭𑀺𑀫𑀁 𑀧𑀳𑀸𑀬 𑀅𑀧𑀭𑀁 𑀲𑀺𑀢𑀸𑀲𑁂, 𑀏𑀚𑀸𑀦𑀼𑀕𑀸 𑀢𑁂 𑀦 𑀢𑀭𑀦𑁆𑀢𑀺 𑀲𑀗𑁆𑀕𑀁;

𑀢𑁂 𑀉𑀕𑁆𑀕𑀳𑀸𑀬𑀦𑁆𑀢𑀺 𑀦𑀺𑀭𑀲𑁆𑀲𑀚𑀦𑁆𑀢𑀺, 𑀓𑀧𑀻𑀯 𑀲𑀸𑀔𑀁 𑀧𑀫𑀼𑀜𑁆𑀘𑀁 𑀕𑀳𑀸𑀬𑀁 [𑀧𑀫𑀼𑀔𑀁 𑀕𑀳𑀸𑀬 (𑀲𑁆𑀬𑀸.), 𑀧𑀫𑀼𑀜𑁆𑀘 𑀕𑀳𑀸𑀬 (𑀓.)].

𑀲𑀬𑀁 ¶ 𑀲𑀫𑀸𑀤𑀸𑀬 𑀯𑀢𑀸𑀦𑀺 𑀚𑀦𑁆𑀢𑀼, 𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀲𑀜𑁆𑀜𑀲𑀢𑁆𑀢𑁄;

𑀯𑀺𑀤𑁆𑀯𑀸 𑀘 𑀯𑁂𑀤𑁂𑀳𑀺 𑀲𑀫𑁂𑀘𑁆𑀘 𑀥𑀫𑁆𑀫𑀁, 𑀦 𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜𑁄.

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

𑀢𑀫𑁂𑀯 ¶ 𑀤𑀲𑁆𑀲𑀺𑀁 𑀯𑀺𑀯𑀝𑀁 𑀘𑀭𑀦𑁆𑀢𑀁, 𑀓𑁂𑀦𑀻𑀥 𑀮𑁄𑀓𑀲𑁆𑀫𑀺 𑀯𑀺𑀓𑀧𑁆𑀧𑀬𑁂𑀬𑁆𑀬.

𑀦 𑀓𑀧𑁆𑀧𑀬𑀦𑁆𑀢𑀺 𑀦 𑀧𑀼𑀭𑁂𑀓𑁆𑀔𑀭𑁄𑀦𑁆𑀢𑀺, 𑀅𑀘𑁆𑀘𑀦𑁆𑀢𑀲𑀼𑀤𑁆𑀥𑀻𑀢𑀺 𑀦 𑀢𑁂 𑀯𑀤𑀦𑁆𑀢𑀺;

𑀆𑀤𑀸𑀦𑀕𑀦𑁆𑀣𑀁 ¶ 𑀕𑀣𑀺𑀢𑀁 𑀯𑀺𑀲𑀚𑁆𑀚, 𑀆𑀲𑀁 𑀦 𑀓𑀼𑀩𑁆𑀩𑀦𑁆𑀢𑀺 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺 𑀮𑁄𑀓𑁂.

𑀲𑀻𑀫𑀸𑀢𑀺𑀕𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀢𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺, 𑀜𑀢𑁆𑀯𑀸 𑀯 𑀤𑀺𑀲𑁆𑀯𑀸 𑀯 [𑀜𑀢𑁆𑀯𑀸 𑀘 𑀤𑀺𑀲𑁆𑀯𑀸 𑀘 (𑀓. 𑀲𑀻. 𑀓.)] 𑀲𑀫𑀼𑀕𑁆𑀕𑀳𑀻𑀢𑀁;

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

𑀲𑀼𑀤𑁆𑀥𑀝𑁆𑀞𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀧𑀭𑀫𑀦𑁆𑀢𑀺 ¶ 𑀤𑀺𑀝𑁆𑀞𑀻𑀲𑀼 𑀧𑀭𑀺𑀩𑁆𑀩𑀲𑀸𑀦𑁄, 𑀬𑀤𑀼𑀢𑁆𑀢𑀭𑀺 𑀓𑀼𑀭𑀼𑀢𑁂 𑀚𑀦𑁆𑀢𑀼 𑀮𑁄𑀓𑁂;

𑀳𑀻𑀦𑀸𑀢𑀺 𑀅𑀜𑁆𑀜𑁂 𑀢𑀢𑁄 𑀲𑀩𑁆𑀩𑀫𑀸𑀳, 𑀢𑀲𑁆𑀫𑀸 𑀯𑀺𑀯𑀸𑀤𑀸𑀦𑀺 𑀅𑀯𑀻𑀢𑀺𑀯𑀢𑁆𑀢𑁄.

𑀬𑀤𑀢𑁆𑀢𑀦𑀻 𑀧𑀲𑁆𑀲𑀢𑀺 𑀆𑀦𑀺𑀲𑀁𑀲𑀁, 𑀤𑀺𑀝𑁆𑀞𑁂 ¶ 𑀲𑀼𑀢𑁂 𑀲𑀻𑀮𑀯𑀢𑁂 [𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑁂 (𑀲𑁆𑀬𑀸.)] 𑀫𑀼𑀢𑁂 𑀯𑀸;

𑀢𑀤𑁂𑀯 𑀲𑁄 𑀢𑀢𑁆𑀣 𑀲𑀫𑀼𑀕𑁆𑀕𑀳𑀸𑀬, 𑀦𑀺𑀳𑀻𑀦𑀢𑁄 𑀧𑀲𑁆𑀲𑀢𑀺 𑀲𑀩𑁆𑀩𑀫𑀜𑁆𑀜𑀁.

𑀢𑀁 ¶ 𑀯𑀸𑀧𑀺 𑀕𑀦𑁆𑀣𑀁 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀦𑁆𑀢𑀺, 𑀬𑀁 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀧𑀲𑁆𑀲𑀢𑀺 𑀳𑀻𑀦𑀫𑀜𑁆𑀜𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀤𑀺𑀝𑁆𑀞𑀁 𑀯 𑀲𑀼𑀢𑀁 𑀫𑀼𑀢𑀁 𑀯𑀸, 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑀁 𑀪𑀺𑀓𑁆𑀔𑀼 𑀦 𑀦𑀺𑀲𑁆𑀲𑀬𑁂𑀬𑁆𑀬.

𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑁆𑀧𑀺 ¶ 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀦 𑀓𑀧𑁆𑀧𑀬𑁂𑀬𑁆𑀬, 𑀜𑀸𑀡𑁂𑀦 𑀯𑀸 𑀲𑀻𑀮𑀯𑀢𑁂𑀦 𑀯𑀸𑀧𑀺;

𑀲𑀫𑁄𑀢𑀺 𑀅𑀢𑁆𑀢𑀸𑀦𑀫𑀦𑀽𑀧𑀦𑁂𑀬𑁆𑀬, 𑀳𑀻𑀦𑁄 𑀦 𑀫𑀜𑁆𑀜𑁂𑀣 𑀯𑀺𑀲𑁂𑀲𑀺 𑀯𑀸𑀧𑀺.

𑀅𑀢𑁆𑀢𑀁 𑀧𑀳𑀸𑀬 𑀅𑀦𑀼𑀧𑀸𑀤𑀺𑀬𑀸𑀦𑁄, 𑀜𑀸𑀡𑁂𑀧𑀺 𑀲𑁄 𑀦𑀺𑀲𑁆𑀲𑀬𑀁 𑀦𑁄 𑀓𑀭𑁄𑀢𑀺;

𑀲 𑀯𑁂 𑀯𑀺𑀬𑀢𑁆𑀢𑁂𑀲𑀼 [𑀯𑀺𑀬𑀼𑀢𑁆𑀢𑁂𑀲𑀼 (𑀲𑀻. 𑀅𑀝𑁆𑀞.), 𑀤𑁆𑀯𑀺𑀬𑀢𑁆𑀢𑁂𑀲𑀼 (𑀓.)] 𑀦 𑀯𑀕𑁆𑀕𑀲𑀸𑀭𑀻, 𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑁆𑀧𑀺 [𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑀧𑀺 (𑀓.)] 𑀲𑁄 𑀦 𑀧𑀘𑁆𑀘𑁂𑀢𑀺 𑀓𑀺𑀜𑁆𑀘𑀺.

𑀬𑀲𑁆𑀲𑀽𑀪𑀬𑀦𑁆𑀢𑁂 𑀧𑀡𑀺𑀥𑀻𑀥 𑀦𑀢𑁆𑀣𑀺, 𑀪𑀯𑀸𑀪𑀯𑀸𑀬 𑀇𑀥 𑀯𑀸 𑀳𑀼𑀭𑀁 𑀯𑀸;

𑀦𑀺𑀯𑁂𑀲𑀦𑀸 𑀢𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀓𑁂𑀘𑀺, 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀦𑀺𑀘𑁆𑀙𑁂𑀬𑁆𑀬 𑀲𑀫𑀼𑀕𑁆𑀕𑀳𑀻𑀢𑀁.

𑀢𑀲𑁆𑀲𑀻𑀥 𑀤𑀺𑀝𑁆𑀞𑁂 𑀯 𑀲𑀼𑀢𑁂 𑀫𑀼𑀢𑁂 𑀯𑀸, 𑀧𑀓𑀧𑁆𑀧𑀺𑀢𑀸 ¶ 𑀦𑀢𑁆𑀣𑀺 𑀅𑀡𑀽𑀧𑀺 𑀲𑀜𑁆𑀜𑀸;

𑀢𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑀦𑀸𑀤𑀺𑀬𑀸𑀦𑀁, 𑀓𑁂𑀦𑀻𑀥 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀯𑀺𑀓𑀧𑁆𑀧𑀬𑁂𑀬𑁆𑀬.

𑀦 𑀓𑀧𑁆𑀧𑀬𑀦𑁆𑀢𑀺 𑀦 𑀧𑀼𑀭𑁂𑀓𑁆𑀔𑀭𑁄𑀦𑁆𑀢𑀺, 𑀥𑀫𑁆𑀫𑀸𑀧𑀺 𑀢𑁂𑀲𑀁 𑀦 𑀧𑀝𑀺𑀘𑁆𑀙𑀺𑀢𑀸𑀲𑁂;

𑀦 ¶ 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀲𑀻𑀮𑀯𑀢𑁂𑀦 𑀦𑁂𑀬𑁆𑀬𑁄, 𑀧𑀸𑀭𑀗𑁆𑀕𑀢𑁄 𑀦 𑀧𑀘𑁆𑀘𑁂𑀢𑀺 𑀢𑀸𑀤𑀻𑀢𑀺.

𑀧𑀭𑀫𑀝𑁆𑀞𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀜𑁆𑀘𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀅𑀧𑁆𑀧𑀁 ¶ ¶ 𑀯𑀢 𑀚𑀻𑀯𑀺𑀢𑀁 𑀇𑀤𑀁, 𑀑𑀭𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀸𑀧𑀺 𑀫𑀺𑀬𑁆𑀬𑀢𑀺 [𑀫𑀻𑀬𑀢𑀺 (𑀲𑀻. 𑀅𑀝𑁆𑀞.)];

𑀬𑁄 𑀘𑁂𑀧𑀺 𑀅𑀢𑀺𑀘𑁆𑀘 𑀚𑀻𑀯𑀢𑀺, 𑀅𑀣 𑀔𑁄 𑀲𑁄 𑀚𑀭𑀲𑀸𑀧𑀺 𑀫𑀺𑀬𑁆𑀬𑀢𑀺.

𑀲𑁄𑀘𑀦𑁆𑀢𑀺 𑀚𑀦𑀸 𑀫𑀫𑀸𑀬𑀺𑀢𑁂, 𑀦 𑀳𑀺 𑀲𑀦𑁆𑀢𑀺 [𑀦 𑀳𑀺 𑀲𑀦𑁆𑀢𑀸 (𑀲𑀻.), 𑀦 𑀳𑀻 𑀲𑀦𑁆𑀢𑀺 (𑀓𑀢𑁆𑀣𑀘𑀺)] 𑀦𑀺𑀘𑁆𑀘𑀸 𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑀸;

𑀯𑀺𑀦𑀸𑀪𑀸𑀯𑀲𑀦𑁆𑀢𑀫𑁂𑀯𑀺𑀤𑀁, 𑀇𑀢𑀺 𑀤𑀺𑀲𑁆𑀯𑀸 𑀦𑀸𑀕𑀸𑀭𑀫𑀸𑀯𑀲𑁂.

𑀫𑀭𑀡𑁂𑀦𑀧𑀺 𑀢𑀁 𑀧𑀳𑀻𑀬𑀢𑀺 [𑀧𑀳𑀺𑀬𑁆𑀬𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)], 𑀬𑀁 𑀧𑀼𑀭𑀺𑀲𑁄 𑀫𑀫𑀺𑀤𑀦𑁆𑀢𑀺 [𑀫𑀫𑀬𑀺𑀤𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.), 𑀫𑀫𑀸𑀬𑀦𑁆𑀢𑀺 (𑀓.)] 𑀫𑀜𑁆𑀜𑀢𑀺;

𑀏𑀢𑀫𑁆𑀧𑀺 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 [𑀏𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲𑁂), 𑀏𑀢𑀫𑁆𑀧𑀺 𑀯𑀺𑀤𑀺𑀢𑁆𑀯 (?)] 𑀧𑀡𑁆𑀟𑀺𑀢𑁄, 𑀦 𑀫𑀫𑀢𑁆𑀢𑀸𑀬 𑀦𑀫𑁂𑀣 𑀫𑀸𑀫𑀓𑁄.

𑀲𑀼𑀧𑀺𑀦𑁂𑀦 𑀬𑀣𑀸𑀧𑀺 𑀲𑀗𑁆𑀕𑀢𑀁, 𑀧𑀝𑀺𑀩𑀼𑀤𑁆𑀥𑁄 𑀧𑀼𑀭𑀺𑀲𑁄 𑀦 𑀧𑀲𑁆𑀲𑀢𑀺;

𑀏𑀯𑀫𑁆𑀧𑀺 ¶ 𑀧𑀺𑀬𑀸𑀬𑀺𑀢𑀁 𑀚𑀦𑀁, 𑀧𑁂𑀢𑀁 𑀓𑀸𑀮𑀓𑀢𑀁 𑀦 𑀧𑀲𑁆𑀲𑀢𑀺.

𑀤𑀺𑀝𑁆𑀞𑀸𑀧𑀺 ¶ 𑀲𑀼𑀢𑀸𑀧𑀺 𑀢𑁂 𑀚𑀦𑀸, 𑀬𑁂𑀲𑀁 𑀦𑀸𑀫𑀫𑀺𑀤𑀁 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀺 [𑀦𑀸𑀫𑀫𑁂𑀯𑀸 𑀯𑀲𑀺𑀲𑁆𑀲𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

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

𑀲𑁄𑀓𑀧𑁆𑀧𑀭𑀺𑀤𑁂𑀯𑀫𑀘𑁆𑀙𑀭𑀁 [𑀲𑁄𑀓𑀧𑀭𑀺𑀤𑁂𑀯𑀫𑀘𑁆𑀙𑀭𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀲𑁄𑀓𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀫𑀘𑁆𑀙𑀭𑀁 (?)], 𑀦 𑀚𑀳𑀦𑁆𑀢𑀺 𑀕𑀺𑀤𑁆𑀥𑀸 𑀫𑀫𑀸𑀬𑀺𑀢𑁂;

𑀢𑀲𑁆𑀫𑀸 𑀫𑀼𑀦𑀬𑁄 𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑀁, 𑀳𑀺𑀢𑁆𑀯𑀸 𑀅𑀘𑀭𑀺𑀁𑀲𑀼 𑀔𑁂𑀫𑀤𑀲𑁆𑀲𑀺𑀦𑁄.

𑀧𑀢𑀺𑀮𑀻𑀦𑀘𑀭𑀲𑁆𑀲 ¶ 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄, 𑀪𑀚𑀫𑀸𑀦𑀲𑁆𑀲 𑀯𑀺𑀯𑀺𑀢𑁆𑀢𑀫𑀸𑀲𑀦𑀁;

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

𑀲𑀩𑁆𑀩𑀢𑁆𑀣 𑀫𑀼𑀦𑀻 𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄, 𑀦 𑀧𑀺𑀬𑀁 𑀓𑀼𑀩𑁆𑀩𑀢𑀺 𑀦𑁄𑀧𑀺 𑀅𑀧𑁆𑀧𑀺𑀬𑀁;

𑀢𑀲𑁆𑀫𑀺𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀫𑀘𑁆𑀙𑀭𑀁, 𑀧𑀡𑁆𑀡𑁂 𑀯𑀸𑀭𑀺 𑀬𑀣𑀸 𑀦 𑀮𑀺𑀫𑁆𑀧𑀢𑀺 [𑀮𑀺𑀧𑁆𑀧𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)].

𑀉𑀤𑀩𑀺𑀦𑁆𑀤𑀼 𑀬𑀣𑀸𑀧𑀺 𑀧𑁄𑀓𑁆𑀔𑀭𑁂, 𑀧𑀤𑀼𑀫𑁂 𑀯𑀸𑀭𑀺 𑀬𑀣𑀸 𑀦 𑀮𑀺𑀫𑁆𑀧𑀢𑀺;

𑀏𑀯𑀁 𑀫𑀼𑀦𑀺 𑀦𑁄𑀧𑀮𑀺𑀫𑁆𑀧𑀢𑀺, 𑀬𑀤𑀺𑀤𑀁 𑀤𑀺𑀝𑁆𑀞𑀲𑀼𑀢𑀁 𑀫𑀼𑀢𑁂𑀲𑀼 𑀯𑀸.

𑀥𑁄𑀦𑁄 ¶ ¶ 𑀦 𑀳𑀺 𑀢𑁂𑀦 𑀫𑀜𑁆𑀜𑀢𑀺, 𑀬𑀤𑀺𑀤𑀁 𑀤𑀺𑀝𑁆𑀞𑀲𑀼𑀢𑀁 𑀫𑀼𑀢𑁂𑀲𑀼 𑀯𑀸;

𑀦𑀸𑀜𑁆𑀜𑁂𑀦 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀺𑀘𑁆𑀙𑀢𑀺, 𑀦 𑀳𑀺 𑀲𑁄 𑀭𑀚𑁆𑀚𑀢𑀺 𑀦𑁄 𑀯𑀺𑀭𑀚𑁆𑀚𑀢𑀻𑀢𑀺.

𑀚𑀭𑀸𑀲𑀼𑀢𑁆𑀢𑀁 𑀙𑀝𑁆𑀞𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁭. 𑀢𑀺𑀲𑁆𑀲𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑀲𑀼𑀢𑁆𑀢𑀁

‘‘𑀫𑁂𑀣𑀼𑀦𑀫𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑀲𑁆𑀲, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀢𑀺𑀲𑁆𑀲𑁄 𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑁄) 𑀯𑀺𑀖𑀸𑀢𑀁 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑀸𑀭𑀺𑀲;

𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀢𑀯 𑀲𑀸𑀲𑀦𑀁, 𑀯𑀺𑀯𑁂𑀓𑁂 𑀲𑀺𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀸𑀫𑀲𑁂.

‘‘𑀫𑁂𑀣𑀼𑀦𑀫𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑀲𑁆𑀲, (𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀫𑀼𑀲𑁆𑀲𑀢𑁂 𑀯𑀸𑀧𑀺 𑀲𑀸𑀲𑀦𑀁;

𑀫𑀺𑀘𑁆𑀙𑀸 ¶ 𑀘 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑀢𑀺, 𑀏𑀢𑀁 𑀢𑀲𑁆𑀫𑀺𑀁 𑀅𑀦𑀸𑀭𑀺𑀬𑀁.

‘‘𑀏𑀓𑁄 ¶ 𑀧𑀼𑀩𑁆𑀩𑁂 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀫𑁂𑀣𑀼𑀦𑀁 𑀬𑁄 𑀦𑀺𑀲𑁂𑀯𑀢𑀺;

𑀬𑀸𑀦𑀁 𑀪𑀦𑁆𑀢𑀁 𑀯 𑀢𑀁 𑀮𑁄𑀓𑁂, 𑀳𑀻𑀦𑀫𑀸𑀳𑀼 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀦𑀁.

‘‘𑀬𑀲𑁄 𑀓𑀺𑀢𑁆𑀢𑀺 𑀘 𑀬𑀸 𑀧𑀼𑀩𑁆𑀩𑁂, 𑀳𑀸𑀬𑀢𑁂 𑀯𑀸𑀧𑀺 𑀢𑀲𑁆𑀲 𑀲𑀸;

𑀏𑀢𑀫𑁆𑀧𑀺 𑀤𑀺𑀲𑁆𑀯𑀸 𑀲𑀺𑀓𑁆𑀔𑁂𑀣, 𑀫𑁂𑀣𑀼𑀦𑀁 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀢𑀯𑁂.

‘‘𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑁂𑀳𑀺 𑀧𑀭𑁂𑀢𑁄 𑀲𑁄, 𑀓𑀧𑀡𑁄 𑀯𑀺𑀬 𑀛𑀸𑀬𑀢𑀺;

𑀲𑀼𑀢𑁆𑀯𑀸 𑀧𑀭𑁂𑀲𑀁 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑀁, 𑀫𑀗𑁆𑀓𑀼 𑀳𑁄𑀢𑀺 𑀢𑀣𑀸𑀯𑀺𑀥𑁄.

‘‘𑀅𑀣 𑀲𑀢𑁆𑀣𑀸𑀦𑀺 𑀓𑀼𑀭𑀼𑀢𑁂, 𑀧𑀭𑀯𑀸𑀤𑁂𑀳𑀺 𑀘𑁄𑀤𑀺𑀢𑁄;

𑀏𑀲 𑀔𑁆𑀯𑀲𑁆𑀲 𑀫𑀳𑀸𑀕𑁂𑀥𑁄, 𑀫𑁄𑀲𑀯𑀚𑁆𑀚𑀁 𑀧𑀕𑀸𑀳𑀢𑀺.

‘‘𑀧𑀡𑁆𑀟𑀺𑀢𑁄𑀢𑀺 𑀲𑀫𑀜𑁆𑀜𑀸𑀢𑁄, 𑀏𑀓𑀘𑀭𑀺𑀬𑀁 𑀅𑀥𑀺𑀝𑁆𑀞𑀺𑀢𑁄;

𑀅𑀣𑀸𑀧𑀺 [𑀲 𑀘𑀸𑀧𑀺 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲𑁂)] 𑀫𑁂𑀣𑀼𑀦𑁂 𑀬𑀼𑀢𑁆𑀢𑁄, 𑀫𑀦𑁆𑀤𑁄𑀯 𑀧𑀭𑀺𑀓𑀺𑀲𑁆𑀲𑀢𑀺 [𑀧𑀭𑀺𑀓𑀺𑀮𑀺𑀲𑁆𑀲𑀢𑀺 (𑀲𑀻.)].

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 ¶ ¶ 𑀜𑀢𑁆𑀯𑀸, 𑀫𑀼𑀦𑀺 𑀧𑀼𑀩𑁆𑀩𑀸𑀧𑀭𑁂 𑀇𑀥;

𑀏𑀓𑀘𑀭𑀺𑀬𑀁 𑀤𑀴𑁆𑀳𑀁 𑀓𑀬𑀺𑀭𑀸, 𑀦 𑀦𑀺𑀲𑁂𑀯𑁂𑀣 𑀫𑁂𑀣𑀼𑀦𑀁.

‘‘𑀯𑀺𑀯𑁂𑀓𑀜𑁆𑀜𑁂𑀯 𑀲𑀺𑀓𑁆𑀔𑁂𑀣, 𑀏𑀢𑀤𑀭𑀺𑀬𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀦 𑀢𑁂𑀦 𑀲𑁂𑀝𑁆𑀞𑁄 𑀫𑀜𑁆𑀜𑁂𑀣, 𑀲 𑀯𑁂 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀲𑀦𑁆𑀢𑀺𑀓𑁂.

‘‘𑀭𑀺𑀢𑁆𑀢𑀲𑁆𑀲 𑀫𑀼𑀦𑀺𑀦𑁄 𑀘𑀭𑀢𑁄, 𑀓𑀸𑀫𑁂𑀲𑀼 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑀺𑀦𑁄;

𑀑𑀖𑀢𑀺𑀡𑁆𑀡𑀲𑁆𑀲 𑀧𑀺𑀳𑀬𑀦𑁆𑀢𑀺, 𑀓𑀸𑀫𑁂𑀲𑀼 𑀕𑀥𑀺𑀢𑀸 [𑀕𑀣𑀺𑀢𑀸 (𑀲𑀻.)] 𑀧𑀚𑀸’’𑀢𑀺.

𑀢𑀺𑀲𑁆𑀲𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑀲𑀼𑀢𑁆𑀢𑀁 𑀲𑀢𑁆𑀢𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀇𑀥𑁂𑀯 ¶ 𑀲𑀼𑀤𑁆𑀥𑀺 𑀇𑀢𑀺 𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺 [𑀯𑀺𑀤𑀺𑀬𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)], 𑀦𑀸𑀜𑁆𑀜𑁂𑀲𑀼 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀸𑀳𑀼;

𑀬𑀁 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸 𑀢𑀢𑁆𑀣 𑀲𑀼𑀪𑀁 𑀯𑀤𑀸𑀦𑀸, 𑀧𑀘𑁆𑀘𑁂𑀓𑀲𑀘𑁆𑀘𑁂𑀲𑀼 𑀧𑀼𑀣𑀽 𑀦𑀺𑀯𑀺𑀝𑁆𑀞𑀸.

𑀢𑁂 ¶ 𑀯𑀸𑀤𑀓𑀸𑀫𑀸 𑀧𑀭𑀺𑀲𑀁 𑀯𑀺𑀕𑀬𑁆𑀳, 𑀩𑀸𑀮𑀁 𑀤𑀳𑀦𑁆𑀢𑀻 𑀫𑀺𑀣𑀼 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀁;

𑀯𑀤𑀦𑁆𑀢𑀺 𑀢𑁂 𑀅𑀜𑁆𑀜𑀲𑀺𑀢𑀸 𑀓𑀣𑁄𑀚𑁆𑀚𑀁, 𑀧𑀲𑀁𑀲𑀓𑀸𑀫𑀸 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀸𑀦𑀸.

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

𑀅𑀧𑀸𑀳𑀢𑀲𑁆𑀫𑀺𑀁 𑀧𑀦 𑀫𑀗𑁆𑀓𑀼 𑀳𑁄𑀢𑀺, 𑀦𑀺𑀦𑁆𑀤𑀸𑀬 𑀲𑁄 𑀓𑀼𑀧𑁆𑀧𑀢𑀺 𑀭𑀦𑁆𑀥𑀫𑁂𑀲𑀻.

𑀬𑀫𑀲𑁆𑀲 ¶ 𑀯𑀸𑀤𑀁 𑀧𑀭𑀺𑀳𑀻𑀦𑀫𑀸𑀳𑀼, 𑀅𑀧𑀸𑀳𑀢𑀁 𑀧𑀜𑁆𑀳𑀯𑀺𑀫𑀁𑀲𑀓𑀸𑀲𑁂;

𑀧𑀭𑀺𑀤𑁂𑀯𑀢𑀺 𑀲𑁄𑀘𑀢𑀺 𑀳𑀻𑀦𑀯𑀸𑀤𑁄, 𑀉𑀧𑀘𑁆𑀘𑀕𑀸 𑀫𑀦𑁆𑀢𑀺 𑀅𑀦𑀼𑀢𑁆𑀣𑀼𑀦𑀸𑀢𑀺.

𑀏𑀢𑁂 𑀯𑀺𑀯𑀸𑀤𑀸 𑀲𑀫𑀡𑁂𑀲𑀼 𑀚𑀸𑀢𑀸, 𑀏𑀢𑁂𑀲𑀼 𑀉𑀕𑁆𑀖𑀸𑀢𑀺 𑀦𑀺𑀖𑀸𑀢𑀺 𑀳𑁄𑀢𑀺;

𑀏𑀢𑀫𑁆𑀧𑀺 ¶ 𑀤𑀺𑀲𑁆𑀯𑀸 𑀯𑀺𑀭𑀫𑁂 𑀓𑀣𑁄𑀚𑁆𑀚𑀁, 𑀦 𑀳𑀜𑁆𑀜𑀤𑀢𑁆𑀣𑀢𑁆𑀣𑀺𑀧𑀲𑀁𑀲𑀮𑀸𑀪𑀸.

𑀧𑀲𑀁𑀲𑀺𑀢𑁄 ¶ 𑀯𑀸 𑀧𑀦 𑀢𑀢𑁆𑀣 𑀳𑁄𑀢𑀺, 𑀅𑀓𑁆𑀔𑀸𑀬 𑀯𑀸𑀤𑀁 𑀧𑀭𑀺𑀲𑀸𑀬 𑀫𑀚𑁆𑀛𑁂;

𑀲𑁄 𑀳𑀲𑁆𑀲𑀢𑀻 𑀉𑀡𑁆𑀡𑀫𑀢𑀻 [𑀉𑀦𑁆𑀦𑀫𑀢𑀻 (?)] 𑀘 𑀢𑁂𑀦, 𑀧𑀧𑁆𑀧𑀼𑀬𑁆𑀬 𑀢𑀫𑀢𑁆𑀣𑀁 𑀬𑀣𑀸 𑀫𑀦𑁄 𑀅𑀳𑀼.

𑀬𑀸 𑀉𑀡𑁆𑀡𑀢𑀻 [𑀉𑀦𑁆𑀦𑀢𑀻 (?)] 𑀲𑀸𑀲𑁆𑀲 𑀯𑀺𑀖𑀸𑀢𑀪𑀽𑀫𑀺, 𑀫𑀸𑀦𑀸𑀢𑀺𑀫𑀸𑀦𑀁 𑀯𑀤𑀢𑁂 𑀧𑀦𑁂𑀲𑁄;

𑀏𑀢𑀫𑁆𑀧𑀺 𑀤𑀺𑀲𑁆𑀯𑀸 𑀦 𑀯𑀺𑀯𑀸𑀤𑀬𑁂𑀣, 𑀦 𑀳𑀺 𑀢𑁂𑀦 𑀲𑀼𑀤𑁆𑀥𑀺𑀁 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀦𑁆𑀢𑀺.

𑀲𑀽𑀭𑁄 𑀬𑀣𑀸 𑀭𑀸𑀚𑀔𑀸𑀤𑀸𑀬 𑀧𑀼𑀝𑁆𑀞𑁄, 𑀅𑀪𑀺𑀕𑀚𑁆𑀚𑀫𑁂𑀢𑀺 𑀧𑀝𑀺𑀲𑀽𑀭𑀫𑀺𑀘𑁆𑀙𑀁;

𑀬𑁂𑀦𑁂𑀯 𑀲𑁄 𑀢𑁂𑀦 𑀧𑀮𑁂𑀳𑀺 𑀲𑀽𑀭, 𑀧𑀼𑀩𑁆𑀩𑁂𑀯 𑀦𑀢𑁆𑀣𑀺 𑀬𑀤𑀺𑀤𑀁 𑀬𑀼𑀥𑀸𑀬.

𑀬𑁂 ¶ 𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑀼𑀕𑁆𑀕𑀬𑁆𑀳 𑀯𑀺𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺 [𑀯𑀺𑀯𑀸𑀤𑀺𑀬𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)], 𑀇𑀤𑀫𑁂𑀯 𑀲𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀘 𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺;

𑀢𑁂 ¶ 𑀢𑁆𑀯𑀁 𑀯𑀤𑀲𑁆𑀲𑀽 𑀦 𑀳𑀺 𑀢𑁂𑀥 𑀅𑀢𑁆𑀣𑀺, 𑀯𑀸𑀤𑀫𑁆𑀳𑀺 𑀚𑀸𑀢𑁂 𑀧𑀝𑀺𑀲𑁂𑀦𑀺𑀓𑀢𑁆𑀢𑀸.

𑀯𑀺𑀲𑁂𑀦𑀺𑀓𑀢𑁆𑀯𑀸 𑀧𑀦 𑀬𑁂 𑀘𑀭𑀦𑁆𑀢𑀺, 𑀤𑀺𑀝𑁆𑀞𑀻𑀳𑀺 𑀤𑀺𑀝𑁆𑀞𑀺𑀁 𑀅𑀯𑀺𑀭𑀼𑀚𑁆𑀛𑀫𑀸𑀦𑀸;

𑀢𑁂𑀲𑀼 ¶ 𑀢𑁆𑀯𑀁 𑀓𑀺𑀁 𑀮𑀪𑁂𑀣𑁄 𑀧𑀲𑀽𑀭, 𑀬𑁂𑀲𑀻𑀥 𑀦𑀢𑁆𑀣𑀻 𑀧𑀭𑀫𑀼𑀕𑁆𑀕𑀳𑀻𑀢𑀁.

𑀅𑀣 𑀢𑁆𑀯𑀁 𑀧𑀯𑀺𑀢𑀓𑁆𑀓𑀫𑀸𑀕𑀫𑀸, 𑀫𑀦𑀲𑀸 𑀤𑀺𑀝𑁆𑀞𑀺𑀕𑀢𑀸𑀦𑀺 𑀘𑀺𑀦𑁆𑀢𑀬𑀦𑁆𑀢𑁄;

𑀥𑁄𑀦𑁂𑀦 𑀬𑀼𑀕𑀁 𑀲𑀫𑀸𑀕𑀫𑀸, 𑀦 𑀳𑀺 𑀢𑁆𑀯𑀁 𑀲𑀓𑁆𑀔𑀲𑀺 𑀲𑀫𑁆𑀧𑀬𑀸𑀢𑀯𑁂𑀢𑀺.

𑀧𑀲𑀽𑀭𑀲𑀼𑀢𑁆𑀢𑀁 𑀅𑀝𑁆𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀢𑀡𑁆𑀳𑀁 𑀅𑀭𑀢𑀺𑀁 𑀭𑀕𑀜𑁆𑀘 [𑀅𑀭𑀢𑀺𑀜𑁆𑀘 𑀭𑀸𑀕𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀦𑀸𑀳𑁄𑀲𑀺 𑀙𑀦𑁆𑀤𑁄 𑀅𑀧𑀺 𑀫𑁂𑀣𑀼𑀦𑀲𑁆𑀫𑀺𑀁;

𑀓𑀺𑀫𑁂𑀯𑀺𑀤𑀁 𑀫𑀼𑀢𑁆𑀢𑀓𑀭𑀻𑀲𑀧𑀼𑀡𑁆𑀡𑀁, 𑀧𑀸𑀤𑀸𑀧𑀺 𑀦𑀁 𑀲𑀫𑁆𑀨𑀼𑀲𑀺𑀢𑀼𑀁 𑀦 𑀇𑀘𑁆𑀙𑁂’’.

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 ¶ 𑀘𑁂 𑀭𑀢𑀦𑀁 𑀦 𑀇𑀘𑁆𑀙𑀲𑀺, 𑀦𑀸𑀭𑀺𑀁 𑀦𑀭𑀺𑀦𑁆𑀤𑁂𑀳𑀺 𑀩𑀳𑀽𑀳𑀺 𑀧𑀢𑁆𑀣𑀺𑀢𑀁;

𑀤𑀺𑀝𑁆𑀞𑀺𑀕𑀢𑀁 𑀲𑀻𑀮𑀯𑀢𑀁 𑀦𑀼 𑀚𑀻𑀯𑀺𑀢𑀁 [𑀲𑀻𑀮𑀯𑀢𑀸𑀦𑀼𑀚𑀻𑀯𑀺𑀢𑀁 (𑀲𑀻. 𑀧𑀻. 𑀓.)], 𑀪𑀯𑀽𑀧𑀧𑀢𑁆𑀢𑀺𑀜𑁆𑀘 𑀯𑀤𑁂𑀲𑀺 𑀓𑀻𑀤𑀺𑀲𑀁’’.

‘‘𑀇𑀤𑀁 ¶ 𑀯𑀤𑀸𑀫𑀻𑀢𑀺 𑀦 𑀢𑀲𑁆𑀲 𑀳𑁄𑀢𑀺, (𑀫𑀸𑀕𑀡𑁆𑀟𑀺𑀬𑀸𑀢𑀺 [𑀫𑀸𑀕𑀦𑁆𑀤𑀺𑀬𑀸𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀪𑀕𑀯𑀸)

𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀦𑀺𑀘𑁆𑀙𑁂𑀬𑁆𑀬 𑀲𑀫𑀼𑀕𑁆𑀕𑀳𑀻𑀢𑀁;

𑀧𑀲𑁆𑀲𑀜𑁆𑀘 ¶ 𑀤𑀺𑀝𑁆𑀞𑀻𑀲𑀼 𑀅𑀦𑀼𑀕𑁆𑀕𑀳𑀸𑀬,

𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀲𑀦𑁆𑀢𑀺𑀁 𑀧𑀘𑀺𑀦𑀁 𑀅𑀤𑀲𑁆𑀲𑀁’’.

‘‘𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑀸 ¶ 𑀬𑀸𑀦𑀺 𑀧𑀓𑀧𑁆𑀧𑀺𑀢𑀸𑀦𑀺, (𑀇𑀢𑀺 𑀫𑀸𑀕𑀡𑁆𑀟𑀺𑀬𑁄 [𑀫𑀸𑀕𑀦𑁆𑀤𑀺𑀬𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] )

𑀢𑁂 𑀯𑁂 𑀫𑀼𑀦𑀻 𑀩𑁆𑀭𑀽𑀲𑀺 𑀅𑀦𑀼𑀕𑁆𑀕𑀳𑀸𑀬;

𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀲𑀦𑁆𑀢𑀻𑀢𑀺 𑀬𑀫𑁂𑀢𑀫𑀢𑁆𑀣𑀁,

𑀓𑀣𑀁 𑀦𑀼 𑀥𑀻𑀭𑁂𑀳𑀺 𑀧𑀯𑁂𑀤𑀺𑀢𑀁 𑀢𑀁’’.

‘‘𑀦 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 𑀦 𑀲𑀼𑀢𑀺𑀬𑀸 𑀦 𑀜𑀸𑀡𑁂𑀦, (𑀫𑀸𑀕𑀡𑁆𑀟𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑁂𑀦𑀸𑀧𑀺 𑀦 𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀸𑀳;

𑀅𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 𑀅𑀲𑁆𑀲𑀼𑀢𑀺𑀬𑀸 𑀅𑀜𑀸𑀡𑀸,

𑀅𑀲𑀻𑀮𑀢𑀸 𑀅𑀩𑁆𑀩𑀢𑀸 𑀦𑁄𑀧𑀺 𑀢𑁂𑀦;

𑀏𑀢𑁂 𑀘 𑀦𑀺𑀲𑁆𑀲𑀚𑁆𑀚 𑀅𑀦𑀼𑀕𑁆𑀕𑀳𑀸𑀬,

𑀲𑀦𑁆𑀢𑁄 𑀅𑀦𑀺𑀲𑁆𑀲𑀸𑀬 𑀪𑀯𑀁 𑀦 𑀚𑀧𑁆𑀧𑁂’’.

‘‘𑀦𑁄 𑀘𑁂 𑀓𑀺𑀭 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 𑀦 𑀲𑀼𑀢𑀺𑀬𑀸 𑀦 𑀜𑀸𑀡𑁂𑀦, (𑀇𑀢𑀺 𑀫𑀸𑀕𑀡𑁆𑀟𑀺𑀬𑁄)

𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑁂𑀦𑀸𑀧𑀺 𑀦 𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀸𑀳;

𑀅𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 ¶ 𑀅𑀲𑁆𑀲𑀼𑀢𑀺𑀬𑀸 𑀅𑀜𑀸𑀡𑀸,

𑀅𑀲𑀻𑀮𑀢𑀸 𑀅𑀩𑁆𑀩𑀢𑀸 𑀦𑁄𑀧𑀺 𑀢𑁂𑀦;

𑀫𑀜𑁆𑀜𑀸𑀫𑀳𑀁 𑀫𑁄𑀫𑀼𑀳𑀫𑁂𑀯 𑀥𑀫𑁆𑀫𑀁,

𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 𑀏𑀓𑁂 𑀧𑀘𑁆𑀘𑁂𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁’’.

‘‘𑀤𑀺𑀝𑁆𑀞𑀜𑁆𑀘 𑀦𑀺𑀲𑁆𑀲𑀸𑀬 𑀅𑀦𑀼𑀧𑀼𑀘𑁆𑀙𑀫𑀸𑀦𑁄, (𑀫𑀸𑀕𑀡𑁆𑀟𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀲𑀫𑀼𑀕𑁆𑀕𑀳𑀻𑀢𑁂𑀲𑀼 𑀧𑀫𑁄𑀳𑀫𑀸𑀕𑀸 [𑀲𑀫𑁄𑀳𑀫𑀸𑀕𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀇𑀢𑁄 ¶ 𑀘 𑀦𑀸𑀤𑁆𑀤𑀓𑁆𑀔𑀺 𑀅𑀡𑀼𑀫𑁆𑀧𑀺 𑀲𑀜𑁆𑀜𑀁,

𑀢𑀲𑁆𑀫𑀸 𑀢𑀼𑀯𑀁 𑀫𑁄𑀫𑀼𑀳𑀢𑁄 𑀤𑀳𑀸𑀲𑀺.

‘‘𑀲𑀫𑁄 ¶ 𑀯𑀺𑀲𑁂𑀲𑀻 𑀉𑀤 𑀯𑀸 𑀦𑀺𑀳𑀻𑀦𑁄, 𑀬𑁄 𑀫𑀜𑁆𑀜𑀢𑀻 𑀲𑁄 𑀯𑀺𑀯𑀤𑁂𑀣 𑀢𑁂𑀦;

𑀢𑀻𑀲𑀼 𑀯𑀺𑀥𑀸𑀲𑀼 𑀅𑀯𑀺𑀓𑀫𑁆𑀧𑀫𑀸𑀦𑁄, 𑀲𑀫𑁄 𑀯𑀺𑀲𑁂𑀲𑀻𑀢𑀺 𑀦 𑀢𑀲𑁆𑀲 𑀳𑁄𑀢𑀺.

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

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

‘‘𑀑𑀓𑀁 ¶ 𑀧𑀳𑀸𑀬 𑀅𑀦𑀺𑀓𑁂𑀢𑀲𑀸𑀭𑀻, 𑀕𑀸𑀫𑁂 𑀅𑀓𑀼𑀩𑁆𑀩𑀁 𑀫𑀼𑀦𑀺 𑀲𑀦𑁆𑀣𑀯𑀸𑀦𑀺 [𑀲𑀦𑁆𑀥𑀯𑀸𑀦𑀺 (𑀓.)];

𑀓𑀸𑀫𑁂𑀳𑀺 𑀭𑀺𑀢𑁆𑀢𑁄 𑀅𑀧𑀼𑀭𑁂𑀓𑁆𑀔𑀭𑀸𑀦𑁄, 𑀓𑀣𑀁 𑀦 𑀯𑀺𑀕𑁆𑀕𑀬𑁆𑀳 𑀚𑀦𑁂𑀦 𑀓𑀬𑀺𑀭𑀸.

‘‘𑀬𑁂𑀳𑀺 𑀯𑀺𑀯𑀺𑀢𑁆𑀢𑁄 𑀯𑀺𑀘𑀭𑁂𑀬𑁆𑀬 𑀮𑁄𑀓𑁂, 𑀦 𑀢𑀸𑀦𑀺 𑀉𑀕𑁆𑀕𑀬𑁆𑀳 𑀯𑀤𑁂𑀬𑁆𑀬 𑀦𑀸𑀕𑁄;

𑀚𑀮𑀫𑁆𑀩𑀼𑀚𑀁 ¶ [𑀏𑀮𑀫𑁆𑀩𑀼𑀚𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀓𑀡𑁆𑀟𑀓𑀁 𑀯𑀸𑀭𑀺𑀚𑀁 𑀬𑀣𑀸, 𑀚𑀮𑁂𑀦 𑀧𑀗𑁆𑀓𑁂𑀦 𑀘𑀦𑀽𑀧𑀮𑀺𑀢𑁆𑀢𑀁;

𑀏𑀯𑀁 𑀫𑀼𑀦𑀻 𑀲𑀦𑁆𑀢𑀺𑀯𑀸𑀤𑁄 𑀅𑀕𑀺𑀤𑁆𑀥𑁄, 𑀓𑀸𑀫𑁂 𑀘 𑀮𑁄𑀓𑁂 𑀘 𑀅𑀦𑀽𑀧𑀮𑀺𑀢𑁆𑀢𑁄.

‘‘𑀦 ¶ 𑀯𑁂𑀤𑀕𑀽 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸𑀬𑀓𑁄 [𑀦 𑀯𑁂𑀤𑀕𑀽 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 (𑀓. 𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀦 𑀫𑀼𑀢𑀺𑀬𑀸, 𑀲 𑀫𑀸𑀦𑀫𑁂𑀢𑀺 𑀦 𑀳𑀺 𑀢𑀫𑁆𑀫𑀬𑁄 𑀲𑁄;

𑀦 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀦𑁄𑀧𑀺 𑀲𑀼𑀢𑁂𑀦 𑀦𑁂𑀬𑁆𑀬𑁄, 𑀅𑀦𑀽𑀧𑀦𑀻𑀢𑁄 𑀲 𑀦𑀺𑀯𑁂𑀲𑀦𑁂𑀲𑀼.

‘‘𑀲𑀜𑁆𑀜𑀸𑀯𑀺𑀭𑀢𑁆𑀢𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀕𑀦𑁆𑀣𑀸, 𑀧𑀜𑁆𑀜𑀸𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀲𑁆𑀲 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀫𑁄𑀳𑀸;

𑀲𑀜𑁆𑀜𑀜𑁆𑀘 𑀤𑀺𑀝𑁆𑀞𑀺𑀜𑁆𑀘 𑀬𑁂 𑀅𑀕𑁆𑀕𑀳𑁂𑀲𑀼𑀁, 𑀢𑁂 𑀖𑀝𑁆𑀝𑀬𑀦𑁆𑀢𑀸 [𑀖𑀝𑁆𑀝𑀫𑀸𑀦𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂’’𑀢𑀺.

𑀫𑀸𑀕𑀡𑁆𑀟𑀺𑀬𑀲𑀼𑀢𑁆𑀢𑀁 𑀦𑀯𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀓𑀣𑀁𑀤𑀲𑁆𑀲𑀻 𑀓𑀣𑀁𑀲𑀻𑀮𑁄, 𑀉𑀧𑀲𑀦𑁆𑀢𑁄𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀺;

𑀢𑀁 𑀫𑁂 𑀕𑁄𑀢𑀫 𑀧𑀩𑁆𑀭𑀽𑀳𑀺, 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀉𑀢𑁆𑀢𑀫𑀁 𑀦𑀭𑀁’’.

‘‘𑀯𑀻𑀢𑀢𑀡𑁆𑀳𑁄 𑀧𑀼𑀭𑀸 𑀪𑁂𑀤𑀸, (𑀇𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀧𑀼𑀩𑁆𑀩𑀫𑀦𑁆𑀢𑀫𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄;

𑀯𑁂𑀫𑀚𑁆𑀛𑁂 𑀦𑀼𑀧𑀲𑀗𑁆𑀔𑁂𑀬𑁆𑀬𑁄, 𑀢𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑀁.

‘‘𑀅𑀓𑁆𑀓𑁄𑀥𑀦𑁄 ¶ ¶ ¶ 𑀅𑀲𑀦𑁆𑀢𑀸𑀲𑀻, 𑀅𑀯𑀺𑀓𑀢𑁆𑀣𑀻 𑀅𑀓𑀼𑀓𑁆𑀓𑀼𑀘𑁄;

𑀫𑀦𑁆𑀢𑀪𑀸𑀡𑀻 [𑀫𑀦𑁆𑀢𑀸𑀪𑀸𑀡𑀻 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀅𑀦𑀼𑀤𑁆𑀥𑀢𑁄, 𑀲 𑀯𑁂 𑀯𑀸𑀘𑀸𑀬𑀢𑁄 𑀫𑀼𑀦𑀺.

‘‘𑀦𑀺𑀭𑀸𑀲𑀢𑁆𑀢𑀺 𑀅𑀦𑀸𑀕𑀢𑁂, 𑀅𑀢𑀻𑀢𑀁 𑀦𑀸𑀦𑀼𑀲𑁄𑀘𑀢𑀺;

𑀯𑀺𑀯𑁂𑀓𑀤𑀲𑁆𑀲𑀻 𑀨𑀲𑁆𑀲𑁂𑀲𑀼, 𑀤𑀺𑀝𑁆𑀞𑀻𑀲𑀼 𑀘 𑀦 𑀦𑀻𑀬𑀢𑀺 [𑀦𑀺𑀬𑁆𑀬𑀢𑀺 (𑀩𑀳𑀽𑀲𑀼)].

‘‘𑀧𑀢𑀺𑀮𑀻𑀦𑁄 𑀅𑀓𑀼𑀳𑀓𑁄, 𑀅𑀧𑀺𑀳𑀸𑀮𑀼 𑀅𑀫𑀘𑁆𑀙𑀭𑀻;

𑀅𑀧𑁆𑀧𑀕𑀩𑁆𑀪𑁄 ¶ 𑀅𑀚𑁂𑀕𑀼𑀘𑁆𑀙𑁄, 𑀧𑁂𑀲𑀼𑀡𑁂𑀬𑁆𑀬𑁂 𑀘 𑀦𑁄 𑀬𑀼𑀢𑁄.

‘‘𑀲𑀸𑀢𑀺𑀬𑁂𑀲𑀼 𑀅𑀦𑀲𑁆𑀲𑀸𑀯𑀻, 𑀅𑀢𑀺𑀫𑀸𑀦𑁂 𑀘 𑀦𑁄 𑀬𑀼𑀢𑁄;

𑀲𑀡𑁆𑀳𑁄 𑀘 𑀧𑀝𑀺𑀪𑀸𑀦𑀯𑀸 [𑀧𑀝𑀺𑀪𑀸𑀡𑀯𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀦 𑀲𑀤𑁆𑀥𑁄 𑀦 𑀯𑀺𑀭𑀚𑁆𑀚𑀢𑀺.

‘‘𑀮𑀸𑀪𑀓𑀫𑁆𑀬𑀸 𑀦 𑀲𑀺𑀓𑁆𑀔𑀢𑀺, 𑀅𑀮𑀸𑀪𑁂 𑀘 𑀦 𑀓𑀼𑀧𑁆𑀧𑀢𑀺;

𑀅𑀯𑀺𑀭𑀼𑀤𑁆𑀥𑁄 𑀘 𑀢𑀡𑁆𑀳𑀸𑀬, 𑀭𑀲𑁂𑀲𑀼 𑀦𑀸𑀦𑀼𑀕𑀺𑀚𑁆𑀛𑀢𑀺.

‘‘𑀉𑀧𑁂𑀓𑁆𑀔𑀓𑁄 𑀲𑀤𑀸 𑀲𑀢𑁄, 𑀦 𑀮𑁄𑀓𑁂 𑀫𑀜𑁆𑀜𑀢𑁂 𑀲𑀫𑀁;

𑀦 𑀯𑀺𑀲𑁂𑀲𑀻 𑀦 𑀦𑀻𑀘𑁂𑀬𑁆𑀬𑁄, 𑀢𑀲𑁆𑀲 𑀦𑁄 𑀲𑀦𑁆𑀢𑀺 𑀉𑀲𑁆𑀲𑀤𑀸.

‘‘𑀬𑀲𑁆𑀲 𑀦𑀺𑀲𑁆𑀲𑀬𑀦𑀸 [𑀦𑀺𑀲𑁆𑀲𑀬𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀦𑀢𑁆𑀣𑀺, 𑀜𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀁 𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄;

𑀪𑀯𑀸𑀬 𑀯𑀺𑀪𑀯𑀸𑀬 𑀯𑀸, 𑀢𑀡𑁆𑀳𑀸 𑀬𑀲𑁆𑀲 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺.

‘‘𑀢𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀉𑀧𑀲𑀦𑁆𑀢𑁄𑀢𑀺, 𑀓𑀸𑀫𑁂𑀲𑀼 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑀺𑀦𑀁;

𑀕𑀦𑁆𑀣𑀸 𑀢𑀲𑁆𑀲 𑀦 𑀯𑀺𑀚𑁆𑀚𑀦𑁆𑀢𑀺, 𑀅𑀢𑀭𑀻 𑀲𑁄 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀁.

‘‘𑀦 𑀢𑀲𑁆𑀲 𑀧𑀼𑀢𑁆𑀢𑀸 𑀧𑀲𑀯𑁄, 𑀔𑁂𑀢𑁆𑀢𑀁 𑀯𑀢𑁆𑀣𑀼𑀜𑁆𑀘 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀅𑀢𑁆𑀢𑀸 ¶ 𑀯𑀸𑀧𑀺 𑀦𑀺𑀭𑀢𑁆𑀢𑀸 𑀯𑀸 [𑀅𑀢𑁆𑀢𑀁 𑀯𑀸𑀧𑀺 𑀦𑀺𑀭𑀢𑁆𑀢𑀁 𑀯𑀸 (𑀩𑀳𑀽𑀲𑀼)], 𑀦 𑀢𑀲𑁆𑀫𑀺𑀁 𑀉𑀧𑀮𑀩𑁆𑀪𑀢𑀺.

‘‘𑀬𑁂𑀦 𑀦𑀁 𑀯𑀚𑁆𑀚𑀼𑀁 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀦𑀸, 𑀅𑀣𑁄 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸;

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

‘‘𑀯𑀻𑀢𑀕𑁂𑀥𑁄 ¶ 𑀅𑀫𑀘𑁆𑀙𑀭𑀻, 𑀦 𑀉𑀲𑁆𑀲𑁂𑀲𑀼 𑀯𑀤𑀢𑁂 𑀫𑀼𑀦𑀺;

𑀦 𑀲𑀫𑁂𑀲𑀼 𑀦 𑀑𑀫𑁂𑀲𑀼, 𑀓𑀧𑁆𑀧𑀁 𑀦𑁂𑀢𑀺 𑀅𑀓𑀧𑁆𑀧𑀺𑀬𑁄.

‘‘𑀬𑀲𑁆𑀲 𑀮𑁄𑀓𑁂 𑀲𑀓𑀁 𑀦𑀢𑁆𑀣𑀺, 𑀅𑀲𑀢𑀸 𑀘 𑀦 𑀲𑁄𑀘𑀢𑀺;

𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀘 𑀦 𑀕𑀘𑁆𑀙𑀢𑀺, 𑀲 𑀯𑁂 𑀲𑀦𑁆𑀢𑁄𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀻’’𑀢𑀺.

𑀧𑀼𑀭𑀸𑀪𑁂𑀤𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀓𑀼𑀢𑁄𑀧𑀳𑀽𑀢𑀸 ¶ ¶ 𑀓𑀮𑀳𑀸 𑀯𑀺𑀯𑀸𑀤𑀸, 𑀧𑀭𑀺𑀤𑁂𑀯𑀲𑁄𑀓𑀸 𑀲𑀳𑀫𑀘𑁆𑀙𑀭𑀸 𑀘;

𑀫𑀸𑀦𑀸𑀢𑀺𑀫𑀸𑀦𑀸 𑀲𑀳𑀧𑁂𑀲𑀼𑀡𑀸 𑀘, 𑀓𑀼𑀢𑁄𑀧𑀳𑀽𑀢𑀸 𑀢𑁂 𑀢𑀤𑀺𑀗𑁆𑀖 𑀩𑁆𑀭𑀽𑀳𑀺’’.

‘‘𑀧𑀺𑀬𑀧𑁆𑀧𑀳𑀽𑀢𑀸 𑀓𑀮𑀳𑀸 𑀯𑀺𑀯𑀸𑀤𑀸,

𑀫𑀘𑁆𑀙𑁂𑀭𑀬𑀼𑀢𑁆𑀢𑀸 𑀓𑀮𑀳𑀸 𑀯𑀺𑀯𑀸𑀤𑀸;

𑀯𑀺𑀯𑀸𑀤𑀚𑀸𑀢𑁂𑀲𑀼 𑀘 𑀧𑁂𑀲𑀼𑀡𑀸𑀦𑀺’’.

‘‘𑀧𑀺𑀬𑀸 ¶ 𑀲𑀼 [𑀧𑀺𑀬𑀸𑀦𑀼 (𑀲𑁆𑀬𑀸.), 𑀧𑀺𑀬𑀲𑁆𑀲𑀼 (𑀓.)] 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀓𑀼𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀸, 𑀬𑁂 𑀘𑀸𑀧𑀺 [𑀬𑁂 𑀯𑀸𑀧𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀮𑁄𑀪𑀸 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂;

𑀆𑀲𑀸 𑀘 𑀦𑀺𑀝𑁆𑀞𑀸 𑀘 𑀓𑀼𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀸, 𑀬𑁂 𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑀸𑀬 𑀦𑀭𑀲𑁆𑀲 𑀳𑁄𑀦𑁆𑀢𑀺’’.

‘‘𑀙𑀦𑁆𑀤𑀸𑀦𑀺𑀤𑀸𑀦𑀸𑀦𑀺 𑀧𑀺𑀬𑀸𑀦𑀺 𑀮𑁄𑀓𑁂, 𑀬𑁂 𑀘𑀸𑀧𑀺 𑀮𑁄𑀪𑀸 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂;

𑀆𑀲𑀸 𑀘 𑀦𑀺𑀝𑁆𑀞𑀸 𑀘 𑀇𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀸, 𑀬𑁂 𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑀸𑀬 𑀦𑀭𑀲𑁆𑀲 𑀳𑁄𑀦𑁆𑀢𑀺’’.

‘‘𑀙𑀦𑁆𑀤𑁄 ¶ 𑀦𑀼 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀓𑀼𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑁄, 𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑀸 𑀘𑀸𑀧𑀺 [𑀯𑀸𑀧𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀓𑀼𑀢𑁄𑀧𑀳𑀽𑀢𑀸;

𑀓𑁄𑀥𑁄 𑀫𑁄𑀲𑀯𑀚𑁆𑀚𑀜𑁆𑀘 𑀓𑀣𑀁𑀓𑀣𑀸 𑀘, 𑀬𑁂 𑀯𑀸𑀧𑀺 𑀥𑀫𑁆𑀫𑀸 𑀲𑀫𑀡𑁂𑀦 𑀯𑀼𑀢𑁆𑀢𑀸’’.

‘‘𑀲𑀸𑀢𑀁 ¶ 𑀅𑀲𑀸𑀢𑀦𑁆𑀢𑀺 𑀬𑀫𑀸𑀳𑀼 𑀮𑁄𑀓𑁂, 𑀢𑀫𑀽𑀧𑀦𑀺𑀲𑁆𑀲𑀸𑀬 𑀧𑀳𑁄𑀢𑀺 𑀙𑀦𑁆𑀤𑁄;

𑀭𑀽𑀧𑁂𑀲𑀼 𑀤𑀺𑀲𑁆𑀯𑀸 𑀯𑀺𑀪𑀯𑀁 𑀪𑀯𑀜𑁆𑀘, 𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑀁 𑀓𑀼𑀩𑁆𑀩𑀢𑀺 [𑀓𑀼𑀭𑀼𑀢𑁂 (𑀩𑀳𑀽𑀲𑀼)] 𑀚𑀦𑁆𑀢𑀼 𑀮𑁄𑀓𑁂.

‘‘𑀓𑁄𑀥𑁄 ¶ 𑀫𑁄𑀲𑀯𑀚𑁆𑀚𑀜𑁆𑀘 𑀓𑀣𑀁𑀓𑀣𑀸 𑀘, 𑀏𑀢𑁂𑀧𑀺 𑀥𑀫𑁆𑀫𑀸 𑀤𑁆𑀯𑀬𑀫𑁂𑀯 𑀲𑀦𑁆𑀢𑁂;

𑀓𑀣𑀁𑀓𑀣𑀻 𑀜𑀸𑀡𑀧𑀣𑀸𑀬 𑀲𑀺𑀓𑁆𑀔𑁂, 𑀜𑀢𑁆𑀯𑀸 𑀧𑀯𑀼𑀢𑁆𑀢𑀸 𑀲𑀫𑀡𑁂𑀦 𑀥𑀫𑁆𑀫𑀸’’.

‘‘𑀲𑀸𑀢𑀁 𑀅𑀲𑀸𑀢𑀜𑁆𑀘 𑀓𑀼𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀸, 𑀓𑀺𑀲𑁆𑀫𑀺𑀁 𑀅𑀲𑀦𑁆𑀢𑁂 𑀦 𑀪𑀯𑀦𑁆𑀢𑀺 𑀳𑁂𑀢𑁂;

𑀯𑀺𑀪𑀯𑀁 𑀪𑀯𑀜𑁆𑀘𑀸𑀧𑀺 𑀬𑀫𑁂𑀢𑀫𑀢𑁆𑀣𑀁, 𑀏𑀢𑀁 𑀫𑁂 𑀧𑀩𑁆𑀭𑀽𑀳𑀺 𑀬𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀁’’.

‘‘𑀨𑀲𑁆𑀲𑀦𑀺𑀤𑀸𑀦𑀁 𑀲𑀸𑀢𑀁 𑀅𑀲𑀸𑀢𑀁, 𑀨𑀲𑁆𑀲𑁂 𑀅𑀲𑀦𑁆𑀢𑁂 𑀦 𑀪𑀯𑀦𑁆𑀢𑀺 𑀳𑁂𑀢𑁂;

𑀯𑀺𑀪𑀯𑀁 ¶ 𑀪𑀯𑀜𑁆𑀘𑀸𑀧𑀺 𑀬𑀫𑁂𑀢𑀫𑀢𑁆𑀣𑀁, 𑀏𑀢𑀁 𑀢𑁂 𑀧𑀩𑁆𑀭𑀽𑀫𑀺 𑀇𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑀁’’.

‘‘𑀨𑀲𑁆𑀲𑁄 ¶ 𑀦𑀼 𑀮𑁄𑀓𑀲𑁆𑀫𑀺 𑀓𑀼𑀢𑁄𑀦𑀺𑀤𑀸𑀦𑁄, 𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑀸 𑀘𑀸𑀧𑀺 𑀓𑀼𑀢𑁄𑀧𑀳𑀽𑀢𑀸;

𑀓𑀺𑀲𑁆𑀫𑀺𑀁 𑀅𑀲𑀦𑁆𑀢𑁂 𑀦 𑀫𑀫𑀢𑁆𑀢𑀫𑀢𑁆𑀣𑀺, 𑀓𑀺𑀲𑁆𑀫𑀺𑀁 𑀯𑀺𑀪𑀽𑀢𑁂 𑀦 𑀨𑀼𑀲𑀦𑁆𑀢𑀺 𑀨𑀲𑁆𑀲𑀸’’.

‘‘𑀦𑀸𑀫𑀜𑁆𑀘 𑀭𑀽𑀧𑀜𑁆𑀘 𑀧𑀝𑀺𑀘𑁆𑀘 𑀨𑀲𑁆𑀲𑁄, 𑀇𑀘𑁆𑀙𑀸𑀦𑀺𑀤𑀸𑀦𑀸𑀦𑀺 𑀧𑀭𑀺𑀕𑁆𑀕𑀳𑀸𑀦𑀺;

𑀇𑀘𑁆𑀙𑀸𑀬𑀲𑀦𑁆𑀢𑁆𑀬𑀸 𑀦 𑀫𑀫𑀢𑁆𑀢𑀫𑀢𑁆𑀣𑀺, 𑀭𑀽𑀧𑁂 𑀯𑀺𑀪𑀽𑀢𑁂 𑀦 𑀨𑀼𑀲𑀦𑁆𑀢𑀺 𑀨𑀲𑁆𑀲𑀸’’.

‘‘𑀓𑀣𑀁𑀲𑀫𑁂𑀢𑀲𑁆𑀲 𑀯𑀺𑀪𑁄𑀢𑀺 𑀭𑀽𑀧𑀁, 𑀲𑀼𑀔𑀁 𑀤𑀼𑀔𑀜𑁆𑀘𑀸𑀧𑀺 [𑀤𑀼𑀔𑀁 𑀯𑀸𑀧𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀓𑀣𑀁 𑀯𑀺𑀪𑁄𑀢𑀺;

𑀏𑀢𑀁 𑀫𑁂 𑀧𑀩𑁆𑀭𑀽𑀳𑀺 𑀬𑀣𑀸 𑀯𑀺𑀪𑁄𑀢𑀺, 𑀢𑀁 𑀚𑀸𑀦𑀺𑀬𑀸𑀫𑀸𑀢𑀺 [𑀚𑀸𑀦𑀺𑀲𑁆𑀲𑀸𑀫𑀸𑀢𑀺 (𑀲𑀻. 𑀓.)] 𑀫𑁂 𑀫𑀦𑁄 𑀅𑀳𑀼’’.

‘‘𑀦 𑀲𑀜𑁆𑀜𑀲𑀜𑁆𑀜𑀻 𑀦 𑀯𑀺𑀲𑀜𑁆𑀜𑀲𑀜𑁆𑀜𑀻, 𑀦𑁄𑀧𑀺 𑀅𑀲𑀜𑁆𑀜𑀻 𑀦 𑀯𑀺𑀪𑀽𑀢𑀲𑀜𑁆𑀜𑀻;

𑀏𑀯𑀁𑀲𑀫𑁂𑀢𑀲𑁆𑀲 𑀯𑀺𑀪𑁄𑀢𑀺 𑀭𑀽𑀧𑀁, 𑀲𑀜𑁆𑀜𑀸𑀦𑀺𑀤𑀸𑀦𑀸 𑀳𑀺 𑀧𑀧𑀜𑁆𑀘𑀲𑀗𑁆𑀔𑀸’’.

‘‘𑀬𑀁 ¶ 𑀢𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺𑀫𑁆𑀳 𑀅𑀓𑀺𑀢𑁆𑀢𑀬𑀻 𑀦𑁄,

𑀅𑀜𑁆𑀜𑀁 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫 𑀢𑀤𑀺𑀗𑁆𑀖 𑀩𑁆𑀭𑀽𑀳𑀺;

𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀕𑁆𑀕𑀁 ¶ 𑀦𑀼 [𑀦𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀯𑀤𑀦𑁆𑀢𑀺 𑀳𑁂𑀓𑁂,

𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀼𑀤𑁆𑀥𑀺𑀁 𑀇𑀥 𑀧𑀡𑁆𑀟𑀺𑀢𑀸𑀲𑁂;

𑀉𑀤𑀸𑀳𑀼 ¶ 𑀅𑀜𑁆𑀜𑀫𑁆𑀧𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀏𑀢𑁆𑀢𑁄.

‘‘𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀕𑁆𑀕𑀫𑁆𑀧𑀺 ¶ 𑀯𑀤𑀦𑁆𑀢𑀺 𑀳𑁂𑀓𑁂, 𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀼𑀤𑁆𑀥𑀺𑀁 𑀇𑀥 𑀧𑀡𑁆𑀟𑀺𑀢𑀸𑀲𑁂;

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

‘‘𑀏𑀢𑁂 𑀘 𑀜𑀢𑁆𑀯𑀸 𑀉𑀧𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸𑀢𑀺, 𑀜𑀢𑁆𑀯𑀸 𑀫𑀼𑀦𑀻 𑀦𑀺𑀲𑁆𑀲𑀬𑁂 𑀲𑁄 𑀯𑀺𑀫𑀁𑀲𑀻;

𑀜𑀢𑁆𑀯𑀸 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄 𑀦 𑀯𑀺𑀯𑀸𑀤𑀫𑁂𑀢𑀺, 𑀪𑀯𑀸𑀪𑀯𑀸𑀬 𑀦 𑀲𑀫𑁂𑀢𑀺 𑀥𑀻𑀭𑁄’’𑀢𑀺.

𑀓𑀮𑀳𑀯𑀺𑀯𑀸𑀤𑀲𑀼𑀢𑁆𑀢𑀁 𑀏𑀓𑀸𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁧𑁨. 𑀘𑀽𑀴𑀩𑁆𑀬𑀽𑀳𑀲𑀼𑀢𑁆𑀢𑀁 [𑀘𑀽𑀴𑀯𑀺𑀬𑀽𑀳𑀲𑀼𑀢𑁆𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀦𑀺𑀤𑁆𑀤𑁂𑀲)]

𑀲𑀓𑀁𑀲𑀓𑀁𑀤𑀺𑀝𑁆𑀞𑀺𑀧𑀭𑀺𑀩𑁆𑀩𑀲𑀸𑀦𑀸, 𑀯𑀺𑀕𑁆𑀕𑀬𑁆𑀳 𑀦𑀸𑀦𑀸 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀦𑁆𑀢𑀺;

𑀬𑁄 𑀏𑀯𑀁 𑀚𑀸𑀦𑀸𑀢𑀺 𑀲 𑀯𑁂𑀤𑀺 𑀥𑀫𑁆𑀫𑀁, 𑀇𑀤𑀁 𑀧𑀝𑀺𑀓𑁆𑀓𑁄𑀲𑀫𑀓𑁂𑀯𑀮𑀻 𑀲𑁄.

𑀏𑀯𑀫𑁆𑀧𑀺 𑀯𑀺𑀕𑁆𑀕𑀬𑁆𑀳 𑀯𑀺𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺, 𑀩𑀸𑀮𑁄 𑀧𑀭𑁄 𑀅𑀓𑁆𑀓𑀼𑀲𑀮𑁄𑀢𑀺 [𑀅𑀓𑀼𑀲𑀮𑁄𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀘𑀸𑀳𑀼;

𑀲𑀘𑁆𑀘𑁄 𑀦𑀼 𑀯𑀸𑀤𑁄 𑀓𑀢𑀫𑁄 𑀇𑀫𑁂𑀲𑀁, 𑀲𑀩𑁆𑀩𑁂𑀯 ¶ 𑀳𑀻𑀫𑁂 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀸𑀦𑀸.

𑀧𑀭𑀲𑁆𑀲 ¶ ¶ 𑀘𑁂 𑀥𑀫𑁆𑀫𑀫𑀦𑀸𑀦𑀼𑀚𑀸𑀦𑀁, 𑀩𑀸𑀮𑁄𑀫𑀓𑁄 [𑀩𑀸𑀮𑁄 𑀫𑀕𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)] 𑀳𑁄𑀢𑀺 𑀦𑀺𑀳𑀻𑀦𑀧𑀜𑁆𑀜𑁄;

𑀲𑀩𑁆𑀩𑁂𑀯 𑀩𑀸𑀮𑀸 𑀲𑀼𑀦𑀺𑀳𑀻𑀦𑀧𑀜𑁆𑀜𑀸, 𑀲𑀩𑁆𑀩𑁂𑀯𑀺𑀫𑁂 𑀤𑀺𑀝𑁆𑀞𑀺𑀧𑀭𑀺𑀩𑁆𑀩𑀲𑀸𑀦𑀸.

𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 𑀘𑁂𑀯 𑀦 𑀯𑀻𑀯𑀤𑀸𑀢𑀸, 𑀲𑀁𑀲𑀼𑀤𑁆𑀥𑀧𑀜𑁆𑀜𑀸 𑀓𑀼𑀲𑀮𑀸 𑀫𑀼𑀢𑀻𑀫𑀸;

𑀦 𑀢𑁂𑀲𑀁 𑀓𑁄𑀘𑀺 𑀧𑀭𑀺𑀳𑀻𑀦𑀧𑀜𑁆𑀜𑁄 [𑀓𑁄𑀘𑀺𑀧𑀺 𑀦𑀺𑀳𑀻𑀦𑀧𑀜𑁆𑀜𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)], 𑀤𑀺𑀝𑁆𑀞𑀻 𑀳𑀺 𑀢𑁂𑀲𑀫𑁆𑀧𑀺 𑀢𑀣𑀸 𑀲𑀫𑀢𑁆𑀢𑀸.

𑀦 𑀯𑀸𑀳𑀫𑁂𑀢𑀁 𑀢𑀣𑀺𑀬𑀦𑁆𑀢𑀺 [𑀢𑀣𑀺𑀯𑀦𑁆𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀩𑁆𑀭𑀽𑀫𑀺, 𑀬𑀫𑀸𑀳𑀼 𑀩𑀸𑀮𑀸 𑀫𑀺𑀣𑀼 𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀁;

𑀲𑀓𑀁𑀲𑀓𑀁𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑀓𑀁𑀲𑀼 𑀲𑀘𑁆𑀘𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀩𑀸𑀮𑁄𑀢𑀺 𑀧𑀭𑀁 𑀤𑀳𑀦𑁆𑀢𑀺.

𑀬𑀫𑀸𑀳𑀼 𑀲𑀘𑁆𑀘𑀁 𑀢𑀣𑀺𑀬𑀦𑁆𑀢𑀺 𑀏𑀓𑁂, 𑀢𑀫𑀸𑀳𑀼 𑀅𑀜𑁆𑀜𑁂 [𑀅𑀜𑁆𑀜𑁂𑀧𑀺 (𑀲𑁆𑀬𑀸.), 𑀅𑀜𑁆𑀜𑁂 𑀘 (?)] 𑀢𑀼𑀘𑁆𑀙𑀁 𑀫𑀼𑀲𑀸𑀢𑀺;

𑀏𑀯𑀫𑁆𑀧𑀺 𑀯𑀺𑀕𑀬𑁆𑀳 𑀯𑀺𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺, 𑀓𑀲𑁆𑀫𑀸 𑀦 𑀏𑀓𑀁 𑀲𑀫𑀡𑀸 𑀯𑀤𑀦𑁆𑀢𑀺.

𑀏𑀓𑀜𑁆𑀳𑀺 ¶ 𑀲𑀘𑁆𑀘𑀁 𑀦 𑀤𑀼𑀢𑀻𑀬𑀫𑀢𑁆𑀣𑀺, 𑀬𑀲𑁆𑀫𑀺𑀁 𑀧𑀚𑀸 𑀦𑁄 𑀯𑀺𑀯𑀤𑁂 𑀧𑀚𑀸𑀦𑀁;

𑀦𑀸𑀦𑀸 𑀢𑁂 [𑀦𑀸𑀦𑀸𑀢𑁄 (𑀓.)] 𑀲𑀘𑁆𑀘𑀸𑀦𑀺 𑀲𑀬𑀁 𑀣𑀼𑀦𑀦𑁆𑀢𑀺, 𑀢𑀲𑁆𑀫𑀸 ¶ 𑀦 𑀏𑀓𑀁 𑀲𑀫𑀡𑀸 𑀯𑀤𑀦𑁆𑀢𑀺.

𑀓𑀲𑁆𑀫𑀸 ¶ 𑀦𑀼 𑀲𑀘𑁆𑀘𑀸𑀦𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀦𑀸𑀦𑀸, 𑀧𑀯𑀸𑀤𑀺𑀬𑀸𑀲𑁂 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀸𑀦𑀸;

𑀲𑀘𑁆𑀘𑀸𑀦𑀺 𑀲𑀼𑀢𑀸𑀦𑀺 𑀩𑀳𑀽𑀦𑀺 𑀦𑀸𑀦𑀸, 𑀉𑀤𑀸𑀳𑀼 𑀢𑁂 𑀢𑀓𑁆𑀓𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀦𑁆𑀢𑀺.

𑀦 𑀳𑁂𑀯 𑀲𑀘𑁆𑀘𑀸𑀦𑀺 𑀩𑀳𑀽𑀦𑀺 𑀦𑀸𑀦𑀸, 𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀲𑀜𑁆𑀜𑀸𑀬 𑀦𑀺𑀘𑁆𑀘𑀸𑀦𑀺 𑀮𑁄𑀓𑁂;

𑀢𑀓𑁆𑀓𑀜𑁆𑀘 𑀤𑀺𑀝𑁆𑀞𑀻𑀲𑀼 𑀧𑀓𑀧𑁆𑀧𑀬𑀺𑀢𑁆𑀯𑀸, 𑀲𑀘𑁆𑀘𑀁 𑀫𑀼𑀲𑀸𑀢𑀺 𑀤𑁆𑀯𑀬𑀥𑀫𑁆𑀫𑀫𑀸𑀳𑀼.

𑀤𑀺𑀝𑁆𑀞𑁂 ¶ 𑀲𑀼𑀢𑁂 𑀲𑀻𑀮𑀯𑀢𑁂 𑀫𑀼𑀢𑁂 𑀯𑀸, 𑀏𑀢𑁂 𑀘 𑀦𑀺𑀲𑁆𑀲𑀸𑀬 𑀯𑀺𑀫𑀸𑀦𑀤𑀲𑁆𑀲𑀻;

𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑁂 𑀞𑀢𑁆𑀯𑀸 𑀧𑀳𑀲𑁆𑀲𑀫𑀸𑀦𑁄, 𑀩𑀸𑀮𑁄 𑀧𑀭𑁄 𑀅𑀓𑁆𑀓𑀼𑀲𑀮𑁄𑀢𑀺 𑀘𑀸𑀳.

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

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

𑀅𑀢𑀺𑀲𑀸𑀭𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸𑀯 𑀲𑁄 𑀲𑀫𑀢𑁆𑀢𑁄, 𑀫𑀸𑀦𑁂𑀦 𑀫𑀢𑁆𑀢𑁄 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀫𑀸𑀦𑀻;

𑀲𑀬𑀫𑁂𑀯 𑀲𑀸𑀫𑀁 𑀫𑀦𑀲𑀸𑀪𑀺𑀲𑀺𑀢𑁆𑀢𑁄, 𑀤𑀺𑀝𑁆𑀞𑀻 ¶ 𑀳𑀺 𑀲𑀸 𑀢𑀲𑁆𑀲 𑀢𑀣𑀸 𑀲𑀫𑀢𑁆𑀢𑀸.

𑀧𑀭𑀲𑁆𑀲 𑀘𑁂 𑀳𑀺 𑀯𑀘𑀲𑀸 𑀦𑀺𑀳𑀻𑀦𑁄, 𑀢𑀼𑀫𑁄 𑀲𑀳𑀸 𑀳𑁄𑀢𑀺 𑀦𑀺𑀳𑀻𑀦𑀧𑀜𑁆𑀜𑁄;

𑀅𑀣 𑀘𑁂 𑀲𑀬𑀁 𑀯𑁂𑀤𑀕𑀽 𑀳𑁄𑀢𑀺 𑀥𑀻𑀭𑁄, 𑀦 𑀓𑁄𑀘𑀺 𑀩𑀸𑀮𑁄 𑀲𑀫𑀡𑁂𑀲𑀼 𑀅𑀢𑁆𑀣𑀺.

𑀅𑀜𑁆𑀜𑀁 ¶ 𑀇𑀢𑁄 𑀬𑀸𑀪𑀺𑀯𑀤𑀦𑁆𑀢𑀺 𑀥𑀫𑁆𑀫𑀁, 𑀅𑀧𑀭𑀤𑁆𑀥𑀸 𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀓𑁂𑀯𑀮𑀻 𑀢𑁂 [𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀓𑁂𑀯𑀮𑀻𑀦𑁄 (𑀲𑀻.)];

𑀏𑀯𑀫𑁆𑀧𑀺 𑀢𑀺𑀢𑁆𑀣𑁆𑀬𑀸 𑀧𑀼𑀣𑀼𑀲𑁄 𑀯𑀤𑀦𑁆𑀢𑀺, 𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀭𑀸𑀕𑁂𑀦 𑀳𑀺 𑀢𑁂𑀪𑀺𑀭𑀢𑁆𑀢𑀸 [𑀢𑁆𑀬𑀸𑀪𑀺𑀭𑀢𑁆𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑀇𑀥𑁂𑀯 𑀲𑀼𑀤𑁆𑀥𑀺 𑀇𑀢𑀺 𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺, 𑀦𑀸𑀜𑁆𑀜𑁂𑀲𑀼 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀸𑀳𑀼;

𑀏𑀯𑀫𑁆𑀧𑀺 𑀢𑀺𑀢𑁆𑀣𑁆𑀬𑀸 𑀧𑀼𑀣𑀼𑀲𑁄 𑀦𑀺𑀯𑀺𑀝𑁆𑀞𑀸, 𑀲𑀓𑀸𑀬𑀦𑁂 𑀢𑀢𑁆𑀣 𑀤𑀴𑁆𑀳𑀁 𑀯𑀤𑀸𑀦𑀸.

𑀲𑀓𑀸𑀬𑀦𑁂 𑀯𑀸𑀧𑀺 𑀤𑀴𑁆𑀳𑀁 𑀯𑀤𑀸𑀦𑁄, 𑀓𑀫𑁂𑀢𑁆𑀣 𑀩𑀸𑀮𑁄𑀢𑀺 𑀧𑀭𑀁 𑀤𑀳𑁂𑀬𑁆𑀬;

𑀲𑀬𑀫𑁂𑀯 𑀲𑁄 𑀫𑁂𑀥𑀕𑀫𑀸𑀯𑀳𑁂𑀬𑁆𑀬 [𑀫𑁂𑀥𑀓𑀁 𑀆𑀯𑀳𑁂𑀬𑁆𑀬 (𑀲𑀻. 𑀧𑀻.)], 𑀧𑀭𑀁 𑀯𑀤𑀁 𑀩𑀸𑀮𑀫𑀲𑀼𑀤𑁆𑀥𑀺𑀥𑀫𑁆𑀫𑀁.

𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑁂 ¶ ¶ 𑀞𑀢𑁆𑀯𑀸 𑀲𑀬𑀁 𑀧𑀫𑀸𑀬, 𑀉𑀤𑁆𑀥𑀁 𑀲 [𑀉𑀤𑁆𑀤𑀁 𑀲𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀯𑀺𑀯𑀸𑀤𑀫𑁂𑀢𑀺;

𑀳𑀺𑀢𑁆𑀯𑀸𑀦 𑀲𑀩𑁆𑀩𑀸𑀦𑀺 𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑀸𑀦𑀺, 𑀦 ¶ 𑀫𑁂𑀥𑀕𑀁 𑀓𑀼𑀩𑁆𑀩𑀢𑀺 𑀚𑀦𑁆𑀢𑀼 𑀮𑁄𑀓𑁂𑀢𑀺.

𑀘𑀽𑀴𑀩𑁆𑀬𑀽𑀳𑀲𑀼𑀢𑁆𑀢𑀁 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀬𑁂 𑀓𑁂𑀘𑀺𑀫𑁂 𑀤𑀺𑀝𑁆𑀞𑀺𑀧𑀭𑀺𑀩𑁆𑀩𑀲𑀸𑀦𑀸, 𑀇𑀤𑀫𑁂𑀯 𑀲𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀯𑀺𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺 [𑀯𑀺𑀯𑀸𑀤𑀺𑀬𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀦𑀺𑀦𑁆𑀤𑀫𑀦𑁆𑀯𑀸𑀦𑀬𑀦𑁆𑀢𑀺, 𑀅𑀣𑁄 𑀧𑀲𑀁𑀲𑀫𑁆𑀧𑀺 𑀮𑀪𑀦𑁆𑀢𑀺 𑀢𑀢𑁆𑀣.

𑀅𑀧𑁆𑀧𑀜𑁆𑀳𑀺 ¶ 𑀏𑀢𑀁 𑀦 𑀅𑀮𑀁 𑀲𑀫𑀸𑀬, 𑀤𑀼𑀯𑁂 𑀯𑀺𑀯𑀸𑀤𑀲𑁆𑀲 𑀨𑀮𑀸𑀦𑀺 𑀩𑁆𑀭𑀽𑀫𑀺;

𑀏𑀢𑀫𑁆𑀧𑀺 𑀤𑀺𑀲𑁆𑀯𑀸 𑀦 𑀯𑀺𑀯𑀸𑀤𑀬𑁂𑀣, 𑀔𑁂𑀫𑀸𑀪𑀺𑀧𑀲𑁆𑀲𑀁 𑀅𑀯𑀺𑀯𑀸𑀤𑀪𑀽𑀫𑀺𑀁.

𑀬𑀸 𑀓𑀸𑀘𑀺𑀫𑀸 𑀲𑀫𑁆𑀫𑀼𑀢𑀺𑀬𑁄 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀸, 𑀲𑀩𑁆𑀩𑀸𑀯 𑀏𑀢𑀸 𑀦 𑀉𑀧𑁂𑀢𑀺 𑀯𑀺𑀤𑁆𑀯𑀸;

𑀅𑀦𑀽𑀧𑀬𑁄 𑀲𑁄 𑀉𑀧𑀬𑀁 𑀓𑀺𑀫𑁂𑀬𑁆𑀬, 𑀤𑀺𑀝𑁆𑀞𑁂 𑀲𑀼𑀢𑁂 𑀔𑀦𑁆𑀢𑀺𑀫𑀓𑀼𑀩𑁆𑀩𑀫𑀸𑀦𑁄.

𑀲𑀻𑀮𑀼𑀢𑁆𑀢𑀫𑀸 𑀲𑀜𑁆𑀜𑀫𑁂𑀦𑀸𑀳𑀼 𑀲𑀼𑀤𑁆𑀥𑀺𑀁, 𑀯𑀢𑀁 𑀲𑀫𑀸𑀤𑀸𑀬 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸𑀲𑁂;

𑀇𑀥𑁂𑀯 𑀲𑀺𑀓𑁆𑀔𑁂𑀫 𑀅𑀣𑀲𑁆𑀲 𑀲𑀼𑀤𑁆𑀥𑀺𑀁, 𑀪𑀯𑀽𑀧𑀦𑀻𑀢𑀸 ¶ 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀸𑀦𑀸.

𑀲𑀘𑁂 𑀘𑀼𑀢𑁄 𑀲𑀻𑀮𑀯𑀢𑀢𑁄 𑀳𑁄𑀢𑀺, 𑀧𑀯𑁂𑀥𑀢𑀻 [𑀲 𑀯𑁂𑀥𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀓𑀫𑁆𑀫 𑀯𑀺𑀭𑀸𑀥𑀬𑀺𑀢𑁆𑀯𑀸;

𑀧𑀚𑀧𑁆𑀧𑀢𑀻 𑀧𑀢𑁆𑀣𑀬𑀢𑀻 𑀘 𑀲𑀼𑀤𑁆𑀥𑀺𑀁, 𑀲𑀢𑁆𑀣𑀸𑀯 𑀳𑀻𑀦𑁄 𑀧𑀯𑀲𑀁 𑀖𑀭𑀫𑁆𑀳𑀸.

𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑀁 ¶ 𑀯𑀸𑀧𑀺 𑀧𑀳𑀸𑀬 𑀲𑀩𑁆𑀩𑀁, 𑀓𑀫𑁆𑀫𑀜𑁆𑀘 𑀲𑀸𑀯𑀚𑁆𑀚𑀦𑀯𑀚𑁆𑀚𑀫𑁂𑀢𑀁;

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

𑀢𑀫𑀽𑀧𑀦𑀺𑀲𑁆𑀲𑀸𑀬 𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀺𑀢𑀁 𑀯𑀸, 𑀅𑀣𑀯𑀸𑀧𑀺 𑀤𑀺𑀝𑁆𑀞𑀁 𑀯 𑀲𑀼𑀢𑀁 𑀫𑀼𑀢𑀁 𑀯𑀸;

𑀉𑀤𑁆𑀥𑀁𑀲𑀭𑀸 𑀲𑀼𑀤𑁆𑀥𑀺𑀫𑀦𑀼𑀢𑁆𑀣𑀼𑀦𑀦𑁆𑀢𑀺, 𑀅𑀯𑀻𑀢𑀢𑀡𑁆𑀳𑀸𑀲𑁂 𑀪𑀯𑀸𑀪𑀯𑁂𑀲𑀼.

𑀧𑀢𑁆𑀣𑀬𑀫𑀸𑀦𑀲𑁆𑀲 ¶ 𑀳𑀺 𑀚𑀧𑁆𑀧𑀺𑀢𑀸𑀦𑀺, 𑀧𑀯𑁂𑀥𑀺𑀢𑀁 𑀯𑀸𑀧𑀺 𑀧𑀓𑀧𑁆𑀧𑀺𑀢𑁂𑀲𑀼;

𑀘𑀼𑀢𑀽𑀧𑀧𑀸𑀢𑁄 𑀇𑀥 𑀬𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺, 𑀲 𑀓𑁂𑀦 𑀯𑁂𑀥𑁂𑀬𑁆𑀬 𑀓𑀼𑀳𑀺𑀁𑀯 𑀚𑀧𑁆𑀧𑁂 [𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺 𑀚𑀧𑁆𑀧𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.), 𑀓𑀼𑀳𑀺𑀁 𑀧𑀚𑀧𑁆𑀧𑁂 (𑀧𑀻.) 𑀦𑀺𑀤𑁆𑀤𑁂𑀲𑁄 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑁄].

𑀬𑀫𑀸𑀳𑀼 𑀥𑀫𑁆𑀫𑀁 𑀧𑀭𑀫𑀦𑁆𑀢𑀺 𑀏𑀓𑁂, 𑀢𑀫𑁂𑀯 𑀳𑀻𑀦𑀦𑁆𑀢𑀺 𑀧𑀦𑀸𑀳𑀼 𑀅𑀜𑁆𑀜𑁂;

𑀲𑀘𑁆𑀘𑁄 𑀦𑀼 𑀯𑀸𑀤𑁄 𑀓𑀢𑀫𑁄 𑀇𑀫𑁂𑀲𑀁, 𑀲𑀩𑁆𑀩𑁂𑀯 ¶ 𑀳𑀻𑀫𑁂 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀸𑀦𑀸.

𑀲𑀓𑀜𑁆𑀳𑀺 𑀥𑀫𑁆𑀫𑀁 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀫𑀸𑀳𑀼, 𑀅𑀜𑁆𑀜𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑀁 𑀧𑀦 𑀳𑀻𑀦𑀫𑀸𑀳𑀼;

𑀏𑀯𑀫𑁆𑀧𑀺 𑀯𑀺𑀕𑁆𑀕𑀬𑁆𑀳 𑀯𑀺𑀯𑀸𑀤𑀬𑀦𑁆𑀢𑀺, 𑀲𑀓𑀁 𑀲𑀓𑀁 𑀲𑀫𑁆𑀫𑀼𑀢𑀺𑀫𑀸𑀳𑀼 𑀲𑀘𑁆𑀘𑀁.

𑀧𑀭𑀲𑁆𑀲 𑀘𑁂 𑀯𑀫𑁆𑀪𑀬𑀺𑀢𑁂𑀦 𑀳𑀻𑀦𑁄, 𑀦 𑀓𑁄𑀘𑀺 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀯𑀺𑀲𑁂𑀲𑀺 𑀅𑀲𑁆𑀲;

𑀧𑀼𑀣𑀽 𑀳𑀺 𑀅𑀜𑁆𑀜𑀲𑁆𑀲 𑀯𑀤𑀦𑁆𑀢𑀺 𑀥𑀫𑁆𑀫𑀁, 𑀦𑀺𑀳𑀻𑀦𑀢𑁄 𑀲𑀫𑁆𑀳𑀺 𑀤𑀴𑁆𑀳𑀁 𑀯𑀤𑀸𑀦𑀸.

𑀲𑀤𑁆𑀥𑀫𑁆𑀫𑀧𑀽𑀚𑀸𑀧𑀺 ¶ 𑀦𑁂𑀲𑀁 𑀢𑀣𑁂𑀯, 𑀬𑀣𑀸 𑀧𑀲𑀁𑀲𑀦𑁆𑀢𑀺 𑀲𑀓𑀸𑀬𑀦𑀸𑀦𑀺;

𑀲𑀩𑁆𑀩𑁂𑀯 𑀯𑀸𑀤𑀸 [𑀲𑀩𑁆𑀩𑁂 𑀧𑀯𑀸𑀤𑀸 (𑀲𑁆𑀬𑀸.)] 𑀢𑀣𑀺𑀬𑀸 [𑀢𑀣𑀺𑀯𑀸 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)] 𑀪𑀯𑁂𑀬𑁆𑀬𑀼𑀁, 𑀲𑀼𑀤𑁆𑀥𑀻 𑀳𑀺 𑀦𑁂𑀲𑀁 𑀧𑀘𑁆𑀘𑀢𑁆𑀢𑀫𑁂𑀯.

𑀦 ¶ 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀧𑀭𑀦𑁂𑀬𑁆𑀬𑀫𑀢𑁆𑀣𑀺, 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀦𑀺𑀘𑁆𑀙𑁂𑀬𑁆𑀬 𑀲𑀫𑀼𑀕𑁆𑀕𑀳𑀻𑀢𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀯𑀺𑀯𑀸𑀤𑀸𑀦𑀺 𑀉𑀧𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑁄, 𑀦 𑀳𑀺 𑀲𑁂𑀝𑁆𑀞𑀢𑁄 𑀧𑀲𑁆𑀲𑀢𑀺 𑀥𑀫𑁆𑀫𑀫𑀜𑁆𑀜𑀁.

𑀚𑀸𑀦𑀸𑀫𑀺 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀢𑀣𑁂𑀯 𑀏𑀢𑀁, 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 𑀏𑀓𑁂 𑀧𑀘𑁆𑀘𑁂𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁;

𑀅𑀤𑁆𑀤𑀓𑁆𑀔𑀺 𑀘𑁂 𑀓𑀺𑀜𑁆𑀳𑀺 𑀢𑀼𑀫𑀲𑁆𑀲 𑀢𑁂𑀦, 𑀅𑀢𑀺𑀲𑀺𑀢𑁆𑀯𑀸 ¶ 𑀅𑀜𑁆𑀜𑁂𑀦 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁.

𑀧𑀲𑁆𑀲𑀁 𑀦𑀭𑁄 𑀤𑀓𑁆𑀔𑀢𑀺 [𑀤𑀓𑁆𑀔𑀺𑀢𑀺 (𑀲𑀻.)] 𑀦𑀸𑀫𑀭𑀽𑀧𑀁, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀯𑀸 𑀜𑀲𑁆𑀲𑀢𑀺 𑀢𑀸𑀦𑀺𑀫𑁂𑀯;

𑀓𑀸𑀫𑀁 𑀩𑀳𑀼𑀁 𑀧𑀲𑁆𑀲𑀢𑀼 𑀅𑀧𑁆𑀧𑀓𑀁 𑀯𑀸, 𑀦 𑀳𑀺 𑀢𑁂𑀦 𑀲𑀼𑀤𑁆𑀥𑀺𑀁 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀦𑁆𑀢𑀺.

𑀦𑀺𑀯𑀺𑀲𑁆𑀲𑀯𑀸𑀤𑀻 𑀦 𑀳𑀺 𑀲𑀼𑀩𑁆𑀩𑀺𑀦𑀸𑀬𑁄, 𑀧𑀓𑀧𑁆𑀧𑀺𑀢𑀁 𑀤𑀺𑀝𑁆𑀞𑀺 𑀧𑀼𑀭𑁂𑀓𑁆𑀔𑀭𑀸𑀦𑁄;

𑀬𑀁 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀢𑀢𑁆𑀣 𑀲𑀼𑀪𑀁 𑀯𑀤𑀸𑀦𑁄, 𑀲𑀼𑀤𑁆𑀥𑀺𑀁𑀯𑀤𑁄 𑀢𑀢𑁆𑀣 𑀢𑀣𑀤𑁆𑀤𑀲𑀸 𑀲𑁄.

𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀓𑀧𑁆𑀧𑀫𑀼𑀧𑁂𑀢𑀺 𑀲𑀗𑁆𑀔𑀸 [𑀲𑀗𑁆𑀔𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀦 𑀤𑀺𑀝𑁆𑀞𑀺𑀲𑀸𑀭𑀻 𑀦𑀧𑀺 𑀜𑀸𑀡𑀩𑀦𑁆𑀥𑀼;

𑀜𑀢𑁆𑀯𑀸 ¶ 𑀘 𑀲𑁄 𑀲𑀫𑁆𑀫𑀼𑀢𑀺𑀬𑁄 [𑀲𑀫𑁆𑀫𑀢𑀺𑀬𑁄 (𑀲𑁆𑀬𑀸.)] 𑀧𑀼𑀣𑀼𑀚𑁆𑀚𑀸, 𑀉𑀧𑁂𑀓𑁆𑀔𑀢𑀻 𑀉𑀕𑁆𑀕𑀳𑀡𑀦𑁆𑀢𑀺 𑀫𑀜𑁆𑀜𑁂.

𑀯𑀺𑀲𑁆𑀲𑀚𑁆𑀚 ¶ 𑀕𑀦𑁆𑀣𑀸𑀦𑀺 𑀫𑀼𑀦𑀻𑀥 𑀮𑁄𑀓𑁂, 𑀯𑀺𑀯𑀸𑀤𑀚𑀸𑀢𑁂𑀲𑀼 𑀦 𑀯𑀕𑁆𑀕𑀲𑀸𑀭𑀻;

𑀲𑀦𑁆𑀢𑁄 𑀅𑀲𑀦𑁆𑀢𑁂𑀲𑀼 𑀉𑀧𑁂𑀓𑁆𑀔𑀓𑁄 𑀲𑁄, 𑀅𑀦𑀼𑀕𑁆𑀕𑀳𑁄 𑀉𑀕𑁆𑀕𑀳𑀡𑀦𑁆𑀢𑀺 𑀫𑀜𑁆𑀜𑁂.

𑀧𑀼𑀩𑁆𑀩𑀸𑀲𑀯𑁂 𑀳𑀺𑀢𑁆𑀯𑀸 𑀦𑀯𑁂 𑀅𑀓𑀼𑀩𑁆𑀩𑀁, 𑀦 𑀙𑀦𑁆𑀤𑀕𑀽 𑀦𑁄𑀧𑀺 𑀦𑀺𑀯𑀺𑀲𑁆𑀲𑀯𑀸𑀤𑀻;

𑀲 𑀯𑀺𑀧𑁆𑀧𑀫𑀼𑀢𑁆𑀢𑁄 𑀤𑀺𑀝𑁆𑀞𑀺𑀕𑀢𑁂𑀳𑀺 𑀥𑀻𑀭𑁄, 𑀦 ¶ 𑀮𑀺𑀫𑁆𑀧𑀢𑀺 [𑀦 𑀮𑀺𑀧𑁆𑀧𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀮𑁄𑀓𑁂 𑀅𑀦𑀢𑁆𑀢𑀕𑀭𑀳𑀻.

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

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

𑀫𑀳𑀸𑀩𑁆𑀬𑀽𑀳𑀲𑀼𑀢𑁆𑀢𑀁 𑀢𑁂𑀭𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 ¶ 𑀢𑀁 𑀆𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼 [𑀆𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀯𑀺𑀯𑁂𑀓𑀁 𑀲𑀦𑁆𑀢𑀺𑀧𑀤𑀜𑁆𑀘 𑀫𑀳𑁂𑀲𑀺;

𑀓𑀣𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀦𑀺𑀩𑁆𑀩𑀸𑀢𑀺 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀅𑀦𑀼𑀧𑀸𑀤𑀺𑀬𑀸𑀦𑁄 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀓𑀺𑀜𑁆𑀘𑀺’’.

‘‘𑀫𑀽𑀮𑀁 𑀧𑀧𑀜𑁆𑀘𑀲𑀗𑁆𑀔𑀸𑀬, (𑀇𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀫𑀦𑁆𑀢𑀸 𑀅𑀲𑁆𑀫𑀻𑀢𑀺 𑀲𑀩𑁆𑀩𑀫𑀼𑀧𑀭𑀼𑀦𑁆𑀥𑁂 [𑀲𑀩𑁆𑀩𑀫𑀼𑀧𑀭𑀼𑀤𑁆𑀥𑁂 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)];

𑀬𑀸 𑀓𑀸𑀘𑀺 𑀢𑀡𑁆𑀳𑀸 𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁,

𑀢𑀸𑀲𑀁 𑀯𑀺𑀦𑀬𑀸 [𑀯𑀺𑀦𑀬𑀸𑀬 (?)] 𑀲𑀤𑀸 𑀲𑀢𑁄 𑀲𑀺𑀓𑁆𑀔𑁂.

‘‘𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀥𑀫𑁆𑀫𑀫𑀪𑀺𑀚𑀜𑁆𑀜𑀸, 𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁 𑀅𑀣𑀯𑀸𑀧𑀺 𑀩𑀳𑀺𑀤𑁆𑀥𑀸;

𑀦 𑀢𑁂𑀦 𑀣𑀸𑀫𑀁 [𑀫𑀸𑀦𑀁 (𑀲𑀻. 𑀓.)] 𑀓𑀼𑀩𑁆𑀩𑁂𑀣, 𑀦 ¶ 𑀳𑀺 𑀲𑀸 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀺 𑀲𑀢𑀁 𑀯𑀼𑀢𑁆𑀢𑀸.

‘‘𑀲𑁂𑀬𑁆𑀬𑁄 𑀦 𑀢𑁂𑀦 𑀫𑀜𑁆𑀜𑁂𑀬𑁆𑀬, 𑀦𑀻𑀘𑁂𑀬𑁆𑀬𑁄 𑀅𑀣𑀯𑀸𑀧𑀺 𑀲𑀭𑀺𑀓𑁆𑀔𑁄;

𑀨𑀼𑀝𑁆𑀞𑁄 [𑀧𑀼𑀝𑁆𑀞𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)] 𑀅𑀦𑁂𑀓𑀭𑀽𑀧𑁂𑀳𑀺, 𑀦𑀸𑀢𑀼𑀫𑀸𑀦𑀁 𑀯𑀺𑀓𑀧𑁆𑀧𑀬𑀁 𑀢𑀺𑀝𑁆𑀞𑁂.

‘‘𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀫𑁂𑀯𑀼𑀧𑀲𑀫𑁂 ¶ , 𑀦 𑀅𑀜𑁆𑀜𑀢𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀲𑀦𑁆𑀢𑀺𑀫𑁂𑀲𑁂𑀬𑁆𑀬;

𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀁 𑀉𑀧𑀲𑀦𑁆𑀢𑀲𑁆𑀲, 𑀦𑀢𑁆𑀣𑀺 𑀅𑀢𑁆𑀢𑀸 𑀓𑀼𑀢𑁄 𑀦𑀺𑀭𑀢𑁆𑀢𑀸 𑀯𑀸.

‘‘𑀫𑀚𑁆𑀛𑁂 ¶ ¶ 𑀬𑀣𑀸 𑀲𑀫𑀼𑀤𑁆𑀤𑀲𑁆𑀲, 𑀊𑀫𑀺 𑀦𑁄 𑀚𑀸𑀬𑀢𑀻 𑀞𑀺𑀢𑁄 𑀳𑁄𑀢𑀺;

𑀏𑀯𑀁 𑀞𑀺𑀢𑁄 𑀅𑀦𑁂𑀚𑀲𑁆𑀲, 𑀉𑀲𑁆𑀲𑀤𑀁 𑀪𑀺𑀓𑁆𑀔𑀼 𑀦 𑀓𑀭𑁂𑀬𑁆𑀬 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺’’.

‘‘𑀅𑀓𑀺𑀢𑁆𑀢𑀬𑀻 𑀯𑀺𑀯𑀝𑀘𑀓𑁆𑀔𑀼, 𑀲𑀓𑁆𑀔𑀺𑀥𑀫𑁆𑀫𑀁 𑀧𑀭𑀺𑀲𑁆𑀲𑀬𑀯𑀺𑀦𑀬𑀁;

𑀧𑀝𑀺𑀧𑀤𑀁 𑀯𑀤𑁂𑀳𑀺 𑀪𑀤𑁆𑀤𑀦𑁆𑀢𑁂, 𑀧𑀸𑀢𑀺𑀫𑁄𑀓𑁆𑀔𑀁 𑀅𑀣𑀯𑀸𑀧𑀺 𑀲𑀫𑀸𑀥𑀺𑀁’’.

‘‘𑀘𑀓𑁆𑀔𑀽𑀳𑀺 𑀦𑁂𑀯 𑀮𑁄𑀮𑀲𑁆𑀲, 𑀕𑀸𑀫𑀓𑀣𑀸𑀬 𑀆𑀯𑀭𑀬𑁂 𑀲𑁄𑀢𑀁;

𑀭𑀲𑁂 𑀘 𑀦𑀸𑀦𑀼𑀕𑀺𑀚𑁆𑀛𑁂𑀬𑁆𑀬, 𑀦 ¶ 𑀘 𑀫𑀫𑀸𑀬𑁂𑀣 𑀓𑀺𑀜𑁆𑀘𑀺 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁.

‘‘𑀨𑀲𑁆𑀲𑁂𑀦 𑀬𑀤𑀸 𑀨𑀼𑀝𑁆𑀞𑀲𑁆𑀲, 𑀧𑀭𑀺𑀤𑁂𑀯𑀁 𑀪𑀺𑀓𑁆𑀔𑀼 𑀦 𑀓𑀭𑁂𑀬𑁆𑀬 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺;

𑀪𑀯𑀜𑁆𑀘 𑀦𑀸𑀪𑀺𑀚𑀧𑁆𑀧𑁂𑀬𑁆𑀬, 𑀪𑁂𑀭𑀯𑁂𑀲𑀼 𑀘 𑀦 𑀲𑀫𑁆𑀧𑀯𑁂𑀥𑁂𑀬𑁆𑀬.

‘‘𑀅𑀦𑁆𑀦𑀸𑀦𑀫𑀣𑁄 𑀧𑀸𑀦𑀸𑀦𑀁, 𑀔𑀸𑀤𑀦𑀻𑀬𑀸𑀦𑀁 𑀅𑀣𑁄𑀧𑀺 𑀯𑀢𑁆𑀣𑀸𑀦𑀁;

𑀮𑀤𑁆𑀥𑀸 𑀦 𑀲𑀦𑁆𑀦𑀺𑀥𑀺𑀁 𑀓𑀬𑀺𑀭𑀸, 𑀦 𑀘 𑀧𑀭𑀺𑀢𑁆𑀢𑀲𑁂 𑀢𑀸𑀦𑀺 𑀅𑀮𑀪𑀫𑀸𑀦𑁄.

‘‘𑀛𑀸𑀬𑀻 𑀦 𑀧𑀸𑀤𑀮𑁄𑀮𑀲𑁆𑀲, 𑀯𑀺𑀭𑀫𑁂 𑀓𑀼𑀓𑁆𑀓𑀼𑀘𑁆𑀘𑀸 𑀦𑀧𑁆𑀧𑀫𑀚𑁆𑀚𑁂𑀬𑁆𑀬;

𑀅𑀣𑀸𑀲𑀦𑁂𑀲𑀼 𑀲𑀬𑀦𑁂𑀲𑀼, 𑀅𑀧𑁆𑀧𑀲𑀤𑁆𑀤𑁂𑀲𑀼 𑀪𑀺𑀓𑁆𑀔𑀼 𑀯𑀺𑀳𑀭𑁂𑀬𑁆𑀬.

‘‘𑀦𑀺𑀤𑁆𑀤𑀁 ¶ 𑀦 𑀩𑀳𑀼𑀮𑀻𑀓𑀭𑁂𑀬𑁆𑀬, 𑀚𑀸𑀕𑀭𑀺𑀬𑀁 𑀪𑀚𑁂𑀬𑁆𑀬 𑀆𑀢𑀸𑀧𑀻;

𑀢𑀦𑁆𑀤𑀺𑀁 𑀫𑀸𑀬𑀁 𑀳𑀲𑁆𑀲𑀁 𑀔𑀺𑀟𑁆𑀟𑀁, 𑀫𑁂𑀣𑀼𑀦𑀁 𑀯𑀺𑀧𑁆𑀧𑀚𑀳𑁂 𑀲𑀯𑀺𑀪𑀽𑀲𑀁.

‘‘𑀆𑀣𑀩𑁆𑀩𑀡𑀁 ¶ 𑀲𑀼𑀧𑀺𑀦𑀁 𑀮𑀓𑁆𑀔𑀡𑀁, 𑀦𑁄 𑀯𑀺𑀤𑀳𑁂 𑀅𑀣𑁄𑀧𑀺 𑀦𑀓𑁆𑀔𑀢𑁆𑀢𑀁;

𑀯𑀺𑀭𑀼𑀢𑀜𑁆𑀘 𑀕𑀩𑁆𑀪𑀓𑀭𑀡𑀁, 𑀢𑀺𑀓𑀺𑀘𑁆𑀙𑀁 ¶ 𑀫𑀸𑀫𑀓𑁄 𑀦 𑀲𑁂𑀯𑁂𑀬𑁆𑀬.

‘‘𑀦𑀺𑀦𑁆𑀤𑀸𑀬 𑀦𑀧𑁆𑀧𑀯𑁂𑀥𑁂𑀬𑁆𑀬, 𑀦 𑀉𑀡𑁆𑀡𑀫𑁂𑀬𑁆𑀬 𑀧𑀲𑀁𑀲𑀺𑀢𑁄 𑀪𑀺𑀓𑁆𑀔𑀼;

𑀮𑁄𑀪𑀁 𑀲𑀳 𑀫𑀘𑁆𑀙𑀭𑀺𑀬𑁂𑀦, 𑀓𑁄𑀥𑀁 𑀧𑁂𑀲𑀼𑀡𑀺𑀬𑀜𑁆𑀘 𑀧𑀦𑀼𑀤𑁂𑀬𑁆𑀬.

‘‘𑀓𑀬𑀯𑀺𑀓𑁆𑀓𑀬𑁂 ¶ 𑀦 𑀢𑀺𑀝𑁆𑀞𑁂𑀬𑁆𑀬, 𑀉𑀧𑀯𑀸𑀤𑀁 𑀪𑀺𑀓𑁆𑀔𑀼 𑀦 𑀓𑀭𑁂𑀬𑁆𑀬 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺;

𑀕𑀸𑀫𑁂 𑀘 𑀦𑀸𑀪𑀺𑀲𑀚𑁆𑀚𑁂𑀬𑁆𑀬, 𑀮𑀸𑀪𑀓𑀫𑁆𑀬𑀸 𑀚𑀦𑀁 𑀦 𑀮𑀧𑀬𑁂𑀬𑁆𑀬.

‘‘𑀦 𑀘 𑀓𑀢𑁆𑀣𑀺𑀢𑀸 𑀲𑀺𑀬𑀸 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀦 𑀘 𑀯𑀸𑀘𑀁 𑀧𑀬𑀼𑀢𑁆𑀢𑀁 𑀪𑀸𑀲𑁂𑀬𑁆𑀬;

𑀧𑀸𑀕𑀩𑁆𑀪𑀺𑀬𑀁 𑀦 𑀲𑀺𑀓𑁆𑀔𑁂𑀬𑁆𑀬, 𑀓𑀣𑀁 𑀯𑀺𑀕𑁆𑀕𑀸𑀳𑀺𑀓𑀁 𑀦 𑀓𑀣𑀬𑁂𑀬𑁆𑀬.

‘‘𑀫𑁄𑀲𑀯𑀚𑁆𑀚𑁂 𑀦 𑀦𑀻𑀬𑁂𑀣, 𑀲𑀫𑁆𑀧𑀚𑀸𑀦𑁄 𑀲𑀞𑀸𑀦𑀺 𑀦 𑀓𑀬𑀺𑀭𑀸;

𑀅𑀣 ¶ 𑀚𑀻𑀯𑀺𑀢𑁂𑀦 𑀧𑀜𑁆𑀜𑀸𑀬, 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑁂𑀦 𑀦𑀸𑀜𑁆𑀜𑀫𑀢𑀺𑀫𑀜𑁆𑀜𑁂.

‘‘𑀲𑀼𑀢𑁆𑀯𑀸 𑀭𑀼𑀲𑀺𑀢𑁄 𑀩𑀳𑀼𑀁 𑀯𑀸𑀘𑀁, 𑀲𑀫𑀡𑀸𑀦𑀁 𑀯𑀸 𑀧𑀼𑀣𑀼𑀚𑀦𑀸𑀦𑀁 [𑀧𑀼𑀣𑀼𑀯𑀘𑀦𑀸𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀨𑀭𑀼𑀲𑁂𑀦 𑀦𑁂 𑀦 𑀧𑀝𑀺𑀯𑀚𑁆𑀚𑀸, 𑀦 ¶ 𑀳𑀺 𑀲𑀦𑁆𑀢𑁄 𑀧𑀝𑀺𑀲𑁂𑀦𑀺𑀓𑀭𑁄𑀦𑁆𑀢𑀺.

‘‘𑀏𑀢𑀜𑁆𑀘 𑀥𑀫𑁆𑀫𑀫𑀜𑁆𑀜𑀸𑀬, 𑀯𑀺𑀘𑀺𑀦𑀁 𑀪𑀺𑀓𑁆𑀔𑀼 𑀲𑀤𑀸 𑀲𑀢𑁄 𑀲𑀺𑀓𑁆𑀔𑁂;

𑀲𑀦𑁆𑀢𑀻𑀢𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀺𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀲𑀸𑀲𑀦𑁂 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀦 𑀧𑀫𑀚𑁆𑀚𑁂𑀬𑁆𑀬.

‘‘𑀅𑀪𑀺𑀪𑀽 ¶ 𑀳𑀺 𑀲𑁄 𑀅𑀦𑀪𑀺𑀪𑀽𑀢𑁄, 𑀲𑀓𑁆𑀔𑀺𑀥𑀫𑁆𑀫𑀫𑀦𑀻𑀢𑀺𑀳𑀫𑀤𑀲𑁆𑀲𑀻;

𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀢𑀲𑁆𑀲 𑀪𑀕𑀯𑀢𑁄 𑀲𑀸𑀲𑀦𑁂, 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄 𑀲𑀤𑀸 𑀦𑀫𑀲𑁆𑀲𑀫𑀦𑀼𑀲𑀺𑀓𑁆𑀔𑁂’’𑀢𑀺.

𑀢𑀼𑀯𑀝𑀓𑀲𑀼𑀢𑁆𑀢𑀁 𑀘𑀼𑀤𑁆𑀤𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀅𑀢𑁆𑀢𑀤𑀡𑁆𑀟𑀸 𑀪𑀬𑀁 𑀚𑀸𑀢𑀁, 𑀚𑀦𑀁 𑀧𑀲𑁆𑀲𑀣 𑀫𑁂𑀥𑀕𑀁;

𑀲𑀁𑀯𑁂𑀕𑀁 𑀓𑀺𑀢𑁆𑀢𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀬𑀣𑀸 𑀲𑀁𑀯𑀺𑀚𑀺𑀢𑀁 𑀫𑀬𑀸.

‘‘𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑀁 ¶ 𑀧𑀚𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀫𑀘𑁆𑀙𑁂 𑀅𑀧𑁆𑀧𑁄𑀤𑀓𑁂 𑀬𑀣𑀸;

𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑁂𑀳𑀺 𑀩𑁆𑀬𑀸𑀭𑀼𑀤𑁆𑀥𑁂, 𑀤𑀺𑀲𑁆𑀯𑀸 𑀫𑀁 𑀪𑀬𑀫𑀸𑀯𑀺𑀲𑀺.

‘‘𑀲𑀫𑀦𑁆𑀢𑀫𑀲𑀸𑀭𑁄 ¶ 𑀮𑁄𑀓𑁄, 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸 𑀲𑀫𑁂𑀭𑀺𑀢𑀸;

𑀇𑀘𑁆𑀙𑀁 𑀪𑀯𑀦𑀫𑀢𑁆𑀢𑀦𑁄, 𑀦𑀸𑀤𑁆𑀤𑀲𑀸𑀲𑀺𑀁 𑀅𑀦𑁄𑀲𑀺𑀢𑀁.

‘‘𑀑𑀲𑀸𑀦𑁂𑀢𑁆𑀯𑁂𑀯 ¶ 𑀩𑁆𑀬𑀸𑀭𑀼𑀤𑁆𑀥𑁂, 𑀤𑀺𑀲𑁆𑀯𑀸 𑀫𑁂 𑀅𑀭𑀢𑀻 𑀅𑀳𑀼;

𑀅𑀣𑁂𑀢𑁆𑀣 𑀲𑀮𑁆𑀮𑀫𑀤𑁆𑀤𑀓𑁆𑀔𑀺𑀁, 𑀤𑀼𑀤𑁆𑀤𑀲𑀁 𑀳𑀤𑀬𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁.

‘‘𑀬𑁂𑀦 𑀲𑀮𑁆𑀮𑁂𑀦 𑀑𑀢𑀺𑀡𑁆𑀡𑁄, 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸 𑀯𑀺𑀥𑀸𑀯𑀢𑀺;

𑀢𑀫𑁂𑀯 𑀲𑀮𑁆𑀮𑀫𑀩𑁆𑀩𑀼𑀬𑁆𑀳, 𑀦 𑀥𑀸𑀯𑀢𑀺 𑀦 𑀲𑀻𑀤𑀢𑀺.

‘‘𑀢𑀢𑁆𑀣 𑀲𑀺𑀓𑁆𑀔𑀸𑀦𑀼𑀕𑀻𑀬𑀦𑁆𑀢𑀺 [𑀲𑀺𑀓𑁆𑀔𑀸𑀦𑀼𑀓𑀺𑀭𑀺𑀬𑀦𑁆𑀢𑀺 (𑀓.)], 𑀬𑀸𑀦𑀺 𑀮𑁄𑀓𑁂 𑀕𑀥𑀺𑀢𑀸𑀦𑀺;

𑀦 𑀢𑁂𑀲𑀼 𑀧𑀲𑀼𑀢𑁄 𑀲𑀺𑀬𑀸, 𑀦𑀺𑀩𑁆𑀩𑀺𑀚𑁆𑀛 𑀲𑀩𑁆𑀩𑀲𑁄 𑀓𑀸𑀫𑁂;

‘‘𑀲𑀘𑁆𑀘𑁄 𑀲𑀺𑀬𑀸 𑀅𑀧𑁆𑀧𑀕𑀩𑁆𑀪𑁄, 𑀅𑀫𑀸𑀬𑁄 𑀭𑀺𑀢𑁆𑀢𑀧𑁂𑀲𑀼𑀡𑁄;

𑀅𑀓𑁆𑀓𑁄𑀥𑀦𑁄 𑀮𑁄𑀪𑀧𑀸𑀧𑀁, 𑀯𑁂𑀯𑀺𑀘𑁆𑀙𑀁 𑀯𑀺𑀢𑀭𑁂 𑀫𑀼𑀦𑀺.

‘‘𑀦𑀺𑀤𑁆𑀤𑀁 𑀢𑀦𑁆𑀤𑀺𑀁 𑀲𑀳𑁂 𑀣𑀻𑀦𑀁, 𑀧𑀫𑀸𑀤𑁂𑀦 𑀦 𑀲𑀁𑀯𑀲𑁂;

𑀅𑀢𑀺𑀫𑀸𑀦𑁂 𑀦 𑀢𑀺𑀝𑁆𑀞𑁂𑀬𑁆𑀬, 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀫𑀦𑀲𑁄 𑀦𑀭𑁄.

‘‘𑀫𑁄𑀲𑀯𑀚𑁆𑀚𑁂 ¶ ¶ 𑀦 𑀦𑀻𑀬𑁂𑀣, 𑀭𑀽𑀧𑁂 𑀲𑁆𑀦𑁂𑀳𑀁 𑀦 𑀓𑀼𑀩𑁆𑀩𑀬𑁂;

𑀫𑀸𑀦𑀜𑁆𑀘 𑀧𑀭𑀺𑀚𑀸𑀦𑁂𑀬𑁆𑀬, 𑀲𑀸𑀳𑀲𑀸 𑀯𑀺𑀭𑀢𑁄 𑀘𑀭𑁂.

‘‘𑀧𑀼𑀭𑀸𑀡𑀁 𑀦𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑁂𑀬𑁆𑀬, 𑀦𑀯𑁂 𑀔𑀦𑁆𑀢𑀺𑀁 𑀦 𑀓𑀼𑀩𑁆𑀩𑀬𑁂;

𑀳𑀺𑀬𑁆𑀬𑀫𑀸𑀦𑁂 𑀦 𑀲𑁄𑀘𑁂𑀬𑁆𑀬, 𑀆𑀓𑀸𑀲𑀁 𑀦 𑀲𑀺𑀢𑁄 𑀲𑀺𑀬𑀸.

‘‘𑀕𑁂𑀥𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀫𑀳𑁄𑀖𑁄𑀢𑀺, 𑀆𑀚𑀯𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀚𑀧𑁆𑀧𑀦𑀁;

𑀆𑀭𑀫𑁆𑀫𑀡𑀁 𑀧𑀓𑀧𑁆𑀧𑀦𑀁, 𑀓𑀸𑀫𑀧𑀗𑁆𑀓𑁄 𑀤𑀼𑀭𑀘𑁆𑀘𑀬𑁄.

‘‘𑀲𑀘𑁆𑀘𑀸 𑀅𑀯𑁄𑀓𑁆𑀓𑀫𑁆𑀫 [𑀅𑀯𑁄𑀓𑁆𑀓𑀫𑀁 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲)] 𑀫𑀼𑀦𑀺, 𑀣𑀮𑁂 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

𑀲𑀩𑁆𑀩𑀁 𑀲𑁄 [𑀲𑀩𑁆𑀩𑀲𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀧𑀝𑀺𑀦𑀺𑀲𑁆𑀲𑀚𑁆𑀚, 𑀲 𑀯𑁂 𑀲𑀦𑁆𑀢𑁄𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

‘‘𑀲 ¶ 𑀯𑁂 𑀯𑀺𑀤𑁆𑀯𑀸 𑀲 𑀯𑁂𑀤𑀕𑀽, 𑀜𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀁 𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄;

𑀲𑀫𑁆𑀫𑀸 ¶ 𑀲𑁄 𑀮𑁄𑀓𑁂 𑀇𑀭𑀺𑀬𑀸𑀦𑁄, 𑀦 𑀧𑀺𑀳𑁂𑀢𑀻𑀥 𑀓𑀲𑁆𑀲𑀘𑀺.

‘‘𑀬𑁄𑀥 𑀓𑀸𑀫𑁂 𑀅𑀘𑁆𑀘𑀢𑀭𑀺, 𑀲𑀗𑁆𑀕𑀁 𑀮𑁄𑀓𑁂 𑀤𑀼𑀭𑀘𑁆𑀘𑀬𑀁;

𑀦 𑀲𑁄 𑀲𑁄𑀘𑀢𑀺 𑀦𑀸𑀚𑁆𑀛𑁂𑀢𑀺, 𑀙𑀺𑀦𑁆𑀦𑀲𑁄𑀢𑁄 𑀅𑀩𑀦𑁆𑀥𑀦𑁄.

‘‘𑀬𑀁 𑀧𑀼𑀩𑁆𑀩𑁂 𑀢𑀁 𑀯𑀺𑀲𑁄𑀲𑁂𑀳𑀺, 𑀧𑀘𑁆𑀙𑀸 𑀢𑁂 𑀫𑀸𑀳𑀼 𑀓𑀺𑀜𑁆𑀘𑀦𑀁;

𑀫𑀚𑁆𑀛𑁂 𑀘𑁂 𑀦𑁄 𑀕𑀳𑁂𑀲𑁆𑀲𑀲𑀺, 𑀉𑀧𑀲𑀦𑁆𑀢𑁄 𑀘𑀭𑀺𑀲𑁆𑀲𑀲𑀺.

‘‘𑀲𑀩𑁆𑀩𑀲𑁄 𑀦𑀸𑀫𑀭𑀽𑀧𑀲𑁆𑀫𑀺𑀁, 𑀬𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺 𑀫𑀫𑀸𑀬𑀺𑀢𑀁;

𑀅𑀲𑀢𑀸 𑀘 𑀦 𑀲𑁄𑀘𑀢𑀺, 𑀲 𑀯𑁂 𑀮𑁄𑀓𑁂 𑀦 𑀚𑀻𑀬𑀢𑀺.

‘‘𑀬𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺 𑀇𑀤𑀁 𑀫𑁂𑀢𑀺, 𑀧𑀭𑁂𑀲𑀁 𑀯𑀸𑀧𑀺 𑀓𑀺𑀜𑁆𑀘𑀦𑀁;

𑀫𑀫𑀢𑁆𑀢𑀁 𑀲𑁄 𑀅𑀲𑀁𑀯𑀺𑀦𑁆𑀤𑀁, 𑀦𑀢𑁆𑀣𑀺 𑀫𑁂𑀢𑀺 𑀦 𑀲𑁄𑀘𑀢𑀺.

‘‘𑀅𑀦𑀺𑀝𑁆𑀞𑀼𑀭𑀻 ¶ 𑀅𑀦𑀦𑀼𑀕𑀺𑀤𑁆𑀥𑁄, 𑀅𑀦𑁂𑀚𑁄 𑀲𑀩𑁆𑀩𑀥𑀻 𑀲𑀫𑁄;

𑀢𑀫𑀸𑀦𑀺𑀲𑀁𑀲𑀁 𑀧𑀩𑁆𑀭𑀽𑀫𑀺, 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀅𑀯𑀺𑀓𑀫𑁆𑀧𑀺𑀦𑀁.

‘‘𑀅𑀦𑁂𑀚𑀲𑁆𑀲 𑀯𑀺𑀚𑀸𑀦𑀢𑁄, 𑀦𑀢𑁆𑀣𑀺 𑀓𑀸𑀘𑀺 𑀦𑀺𑀲𑀗𑁆𑀔𑀢𑀺 [𑀦𑀺𑀲𑀗𑁆𑀔𑀺𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)].

𑀯𑀺𑀭𑀢𑁄 𑀲𑁄 𑀯𑀺𑀬𑀸𑀭𑀩𑁆𑀪𑀸, 𑀔𑁂𑀫𑀁 𑀧𑀲𑁆𑀲𑀢𑀺 𑀲𑀩𑁆𑀩𑀥𑀺.

‘‘𑀦 𑀲𑀫𑁂𑀲𑀼 𑀦 𑀑𑀫𑁂𑀲𑀼, 𑀦 𑀉𑀲𑁆𑀲𑁂𑀲𑀼 𑀯𑀤𑀢𑁂 𑀫𑀼𑀦𑀺;

𑀲𑀦𑁆𑀢𑁄 𑀲𑁄 𑀯𑀻𑀢𑀫𑀘𑁆𑀙𑀭𑁄, 𑀦𑀸𑀤𑁂𑀢𑀺 𑀦 𑀦𑀺𑀭𑀲𑁆𑀲𑀢𑀻’’𑀢𑀺.

𑀅𑀢𑁆𑀢𑀤𑀡𑁆𑀟𑀲𑀼𑀢𑁆𑀢𑀁 𑀧𑀦𑁆𑀦𑀭𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

‘‘𑀦 ¶ ¶ ¶ 𑀫𑁂 𑀤𑀺𑀝𑁆𑀞𑁄 𑀇𑀢𑁄 𑀧𑀼𑀩𑁆𑀩𑁂, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑁄)

‘‘𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀬𑀣𑀸 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀘𑀓𑁆𑀔𑀼𑀫𑀸;

𑀲𑀩𑁆𑀩𑀁 𑀢𑀫𑀁 𑀯𑀺𑀦𑁄𑀤𑁂𑀢𑁆𑀯𑀸, 𑀏𑀓𑁄𑀯 𑀭𑀢𑀺𑀫𑀚𑁆𑀛𑀕𑀸.

‘‘𑀢𑀁 ¶ 𑀩𑀼𑀤𑁆𑀥𑀁 𑀅𑀲𑀺𑀢𑀁 𑀢𑀸𑀤𑀺𑀁, 𑀅𑀓𑀼𑀳𑀁 𑀕𑀡𑀺𑀫𑀸𑀕𑀢𑀁;

𑀩𑀳𑀽𑀦𑀫𑀺𑀥 𑀩𑀤𑁆𑀥𑀸𑀦𑀁, 𑀅𑀢𑁆𑀣𑀺 𑀧𑀜𑁆𑀳𑁂𑀦 𑀆𑀕𑀫𑀁.

‘‘𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀯𑀺𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀢𑁄, 𑀪𑀚𑀢𑁄 𑀭𑀺𑀢𑁆𑀢𑀫𑀸𑀲𑀦𑀁;

𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀁 𑀲𑀼𑀲𑀸𑀦𑀁 𑀯𑀸, 𑀧𑀩𑁆𑀩𑀢𑀸𑀦𑀁 𑀕𑀼𑀳𑀸𑀲𑀼 𑀯𑀸.

‘‘𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑁂𑀲𑀼 𑀲𑀬𑀦𑁂𑀲𑀼, 𑀓𑀻𑀯𑀦𑁆𑀢𑁄 𑀢𑀢𑁆𑀣 𑀪𑁂𑀭𑀯𑀸;

𑀬𑁂𑀳𑀺 𑀪𑀺𑀓𑁆𑀔𑀼 𑀦 𑀯𑁂𑀥𑁂𑀬𑁆𑀬, 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑁂 𑀲𑀬𑀦𑀸𑀲𑀦𑁂.

‘‘𑀓𑀢𑀻 𑀧𑀭𑀺𑀲𑁆𑀲𑀬𑀸 𑀮𑁄𑀓𑁂, 𑀕𑀘𑁆𑀙𑀢𑁄 𑀅𑀕𑀢𑀁 𑀤𑀺𑀲𑀁;

𑀬𑁂 𑀪𑀺𑀓𑁆𑀔𑀼 𑀅𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑁂, 𑀧𑀦𑁆𑀢𑀫𑁆𑀳𑀺 𑀲𑀬𑀦𑀸𑀲𑀦𑁂.

‘‘𑀓𑁆𑀬𑀸𑀲𑁆𑀲 𑀩𑁆𑀬𑀧𑁆𑀧𑀣𑀬𑁄 𑀅𑀲𑁆𑀲𑀼, 𑀓𑁆𑀬𑀸𑀲𑁆𑀲𑀲𑁆𑀲𑀼 𑀇𑀥 𑀕𑁄𑀘𑀭𑀸;

𑀓𑀸𑀦𑀺 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑀸𑀦𑀸𑀲𑁆𑀲𑀼, 𑀧𑀳𑀺𑀢𑀢𑁆𑀢𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄.

‘‘𑀓𑀁 𑀲𑁄 𑀲𑀺𑀓𑁆𑀔𑀁 𑀲𑀫𑀸𑀤𑀸𑀬, 𑀏𑀓𑁄𑀤𑀺 𑀦𑀺𑀧𑀓𑁄 𑀲𑀢𑁄;

𑀓𑀫𑁆𑀫𑀸𑀭𑁄 𑀭𑀚𑀢𑀲𑁆𑀲𑁂𑀯, 𑀦𑀺𑀤𑁆𑀥𑀫𑁂 𑀫𑀮𑀫𑀢𑁆𑀢𑀦𑁄’’.

‘‘𑀯𑀺𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀫𑀸𑀦𑀲𑁆𑀲 ¶ ¶ 𑀬𑀤𑀺𑀤𑀁 𑀨𑀸𑀲𑀼, (𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀭𑀺𑀢𑁆𑀢𑀸𑀲𑀦𑀁 𑀲𑀬𑀦𑀁 𑀲𑁂𑀯𑀢𑁄 𑀘𑁂;

𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀓𑀸𑀫𑀲𑁆𑀲 𑀬𑀣𑀸𑀦𑀼𑀥𑀫𑁆𑀫𑀁,

𑀢𑀁 𑀢𑁂 𑀧𑀯𑀓𑁆𑀔𑀸𑀫𑀺 𑀬𑀣𑀸 𑀧𑀚𑀸𑀦𑀁.

‘‘𑀧𑀜𑁆𑀘𑀦𑁆𑀦𑀁 𑀥𑀻𑀭𑁄 𑀪𑀬𑀸𑀦𑀁 𑀦 𑀪𑀸𑀬𑁂, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀲𑀢𑁄 𑀲𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀘𑀸𑀭𑀻;

𑀟𑀁𑀲𑀸𑀥𑀺𑀧𑀸𑀢𑀸𑀦𑀁 𑀲𑀭𑀻𑀲𑀧𑀸𑀦𑀁, 𑀫𑀦𑀼𑀲𑁆𑀲𑀨𑀲𑁆𑀲𑀸𑀦𑀁 𑀘𑀢𑀼𑀧𑁆𑀧𑀤𑀸𑀦𑀁.

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

𑀅𑀣𑀸𑀧𑀭𑀸𑀦𑀺 𑀅𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑁂𑀬𑁆𑀬, 𑀧𑀭𑀺𑀲𑁆𑀲𑀬𑀸𑀦𑀺 𑀓𑀼𑀲𑀮𑀸𑀦𑀼𑀏𑀲𑀻.

‘‘𑀆𑀢𑀗𑁆𑀓𑀨𑀲𑁆𑀲𑁂𑀦 𑀔𑀼𑀤𑀸𑀬 𑀨𑀼𑀝𑁆𑀞𑁄, 𑀲𑀻𑀢𑀁 𑀅𑀢𑀼𑀡𑁆𑀳𑀁 [𑀅𑀘𑁆𑀘𑀼𑀡𑁆𑀳𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀅𑀥𑀺𑀯𑀸𑀲𑀬𑁂𑀬𑁆𑀬;

𑀲𑁄 𑀢𑁂𑀳𑀺 𑀨𑀼𑀝𑁆𑀞𑁄 𑀩𑀳𑀼𑀥𑀸 𑀅𑀦𑁄𑀓𑁄, 𑀯𑀻𑀭𑀺𑀬𑀁 𑀧𑀭𑀓𑁆𑀓𑀫𑁆𑀫𑀤𑀴𑁆𑀳𑀁 𑀓𑀭𑁂𑀬𑁆𑀬.

‘‘𑀣𑁂𑀬𑁆𑀬𑀁 𑀦 𑀓𑀸𑀭𑁂 [𑀦 𑀓𑀭𑁂𑀬𑁆𑀬 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)] 𑀦 𑀫𑀼𑀲𑀸 𑀪𑀡𑁂𑀬𑁆𑀬, 𑀫𑁂𑀢𑁆𑀢𑀸𑀬 𑀨𑀲𑁆𑀲𑁂 𑀢𑀲𑀣𑀸𑀯𑀭𑀸𑀦𑀺;

𑀬𑀤𑀸𑀯𑀺𑀮𑀢𑁆𑀢𑀁 𑀫𑀦𑀲𑁄 𑀯𑀺𑀚𑀜𑁆𑀜𑀸, 𑀓𑀡𑁆𑀳𑀲𑁆𑀲 𑀧𑀓𑁆𑀔𑁄𑀢𑀺 𑀯𑀺𑀦𑁄𑀤𑀬𑁂𑀬𑁆𑀬.

‘‘𑀓𑁄𑀥𑀸𑀢𑀺𑀫𑀸𑀦𑀲𑁆𑀲 ¶ 𑀯𑀲𑀁 𑀦 𑀕𑀘𑁆𑀙𑁂, 𑀫𑀽𑀮𑀫𑁆𑀧𑀺 𑀢𑁂𑀲𑀁 𑀧𑀮𑀺𑀔𑀜𑁆𑀜 𑀢𑀺𑀝𑁆𑀞𑁂;

𑀅𑀣𑀧𑁆𑀧𑀺𑀬𑀁 𑀯𑀸 𑀧𑀦 𑀅𑀧𑁆𑀧𑀺𑀬𑀁 𑀯𑀸, 𑀅𑀤𑁆𑀥𑀸 𑀪𑀯𑀦𑁆𑀢𑁄 𑀅𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑁂𑀬𑁆𑀬.

‘‘𑀧𑀜𑁆𑀜𑀁 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁆𑀯𑀸 𑀓𑀮𑁆𑀬𑀸𑀡𑀧𑀻𑀢𑀺, 𑀯𑀺𑀓𑁆𑀔𑀫𑁆𑀪𑀬𑁂 𑀢𑀸𑀦𑀺 𑀧𑀭𑀺𑀲𑁆𑀲𑀬𑀸𑀦𑀺;

𑀅𑀭𑀢𑀺𑀁 𑀲𑀳𑁂𑀣 𑀲𑀬𑀦𑀫𑁆𑀳𑀺 𑀧𑀦𑁆𑀢𑁂, 𑀘𑀢𑀼𑀭𑁄 𑀲𑀳𑁂𑀣 𑀧𑀭𑀺𑀤𑁂𑀯𑀥𑀫𑁆𑀫𑁂.

‘‘𑀓𑀺𑀁𑀲𑀽 𑀅𑀲𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀓𑀼𑀯𑀁 𑀯𑀸 [𑀓𑀼𑀥 𑀯𑀸 (𑀓.), 𑀓𑀼𑀣 𑀯𑀸 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲)] 𑀅𑀲𑀺𑀲𑁆𑀲𑀁, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀯𑀢 𑀲𑁂𑀢𑁆𑀣 𑀓𑁆𑀯𑀚𑁆𑀚 𑀲𑁂𑀲𑁆𑀲𑀁;

𑀏𑀢𑁂 𑀯𑀺𑀢𑀓𑁆𑀓𑁂 𑀧𑀭𑀺𑀤𑁂𑀯𑀦𑁂𑀬𑁆𑀬𑁂, 𑀯𑀺𑀦𑀬𑁂𑀣 𑀲𑁂𑀔𑁄 𑀅𑀦𑀺𑀓𑁂𑀢𑀘𑀸𑀭𑀻.

‘‘𑀅𑀦𑁆𑀦𑀜𑁆𑀘 ¶ 𑀮𑀤𑁆𑀥𑀸 𑀯𑀲𑀦𑀜𑁆𑀘 𑀓𑀸𑀮𑁂, 𑀫𑀢𑁆𑀢𑀁 𑀲𑁄 𑀚𑀜𑁆𑀜𑀸 𑀇𑀥 𑀢𑁄𑀲𑀦𑀢𑁆𑀣𑀁;

𑀲𑁄 𑀢𑁂𑀲𑀼 𑀕𑀼𑀢𑁆𑀢𑁄 𑀬𑀢𑀘𑀸𑀭𑀺 𑀕𑀸𑀫𑁂, 𑀭𑀼𑀲𑀺𑀢𑁄𑀧𑀺 𑀯𑀸𑀘𑀁 𑀨𑀭𑀼𑀲𑀁 𑀦 𑀯𑀚𑁆𑀚𑀸.

‘‘𑀑𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀘𑀓𑁆𑀔𑀼 ¶ ¶ 𑀦 𑀘 𑀧𑀸𑀤𑀮𑁄𑀮𑁄, 𑀛𑀸𑀦𑀸𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑁄 𑀩𑀳𑀼𑀚𑀸𑀕𑀭𑀲𑁆𑀲;

𑀉𑀧𑁂𑀓𑁆𑀔𑀫𑀸𑀭𑀩𑁆𑀪 𑀲𑀫𑀸𑀳𑀺𑀢𑀢𑁆𑀢𑁄, 𑀢𑀓𑁆𑀓𑀸𑀲𑀬𑀁 𑀓𑀼𑀓𑁆𑀓𑀼𑀘𑁆𑀘𑀺𑀬𑀽𑀧𑀙𑀺𑀦𑁆𑀤𑁂.

‘‘𑀘𑀼𑀤𑀺𑀢𑁄 ¶ 𑀯𑀘𑀻𑀪𑀺 𑀲𑀢𑀺𑀫𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑁂, 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀻𑀲𑀼 𑀔𑀺𑀮𑀁 𑀧𑀪𑀺𑀦𑁆𑀤𑁂;

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

‘‘𑀅𑀣𑀸𑀧𑀭𑀁 𑀧𑀜𑁆𑀘 𑀭𑀚𑀸𑀦𑀺 𑀮𑁄𑀓𑁂, 𑀬𑁂𑀲𑀁 𑀲𑀢𑀻𑀫𑀸 𑀯𑀺𑀦𑀬𑀸𑀬 𑀲𑀺𑀓𑁆𑀔𑁂;

𑀭𑀽𑀧𑁂𑀲𑀼 𑀲𑀤𑁆𑀤𑁂𑀲𑀼 𑀅𑀣𑁄 𑀭𑀲𑁂𑀲𑀼, 𑀕𑀦𑁆𑀥𑁂𑀲𑀼 𑀨𑀲𑁆𑀲𑁂𑀲𑀼 𑀲𑀳𑁂𑀣 𑀭𑀸𑀕𑀁.

‘‘𑀏𑀢𑁂𑀲𑀼 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀙𑀦𑁆𑀤𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀲𑀢𑀺𑀫𑀸 𑀲𑀼𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑁄;

𑀓𑀸𑀮𑁂𑀦 ¶ 𑀲𑁄 𑀲𑀫𑁆𑀫𑀸 𑀥𑀫𑁆𑀫𑀁 𑀧𑀭𑀺𑀯𑀻𑀫𑀁𑀲𑀫𑀸𑀦𑁄,

𑀏𑀓𑁄𑀤𑀺𑀪𑀽𑀢𑁄 𑀯𑀺𑀳𑀦𑁂 𑀢𑀫𑀁 𑀲𑁄’’𑀢𑀺.

𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀲𑀼𑀢𑁆𑀢𑀁 𑀲𑁄𑀴𑀲𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀓𑀸𑀫𑀁 𑀕𑀼𑀳𑀜𑁆𑀘 𑀤𑀼𑀝𑁆𑀞𑀸 𑀘, 𑀲𑀼𑀤𑁆𑀥𑀜𑁆𑀘 𑀧𑀭𑀫𑀸 𑀚𑀭𑀸;

𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑁄 𑀘 𑀧𑀲𑀽𑀭𑁄 𑀘, 𑀫𑀸𑀕𑀡𑁆𑀟𑀺 𑀧𑀼𑀭𑀸𑀪𑁂𑀤𑀦𑀁.

𑀓𑀮𑀳𑀁 𑀤𑁆𑀯𑁂 𑀘 𑀩𑁆𑀬𑀽𑀳𑀸𑀦𑀺 [𑀩𑁆𑀬𑀽𑀳𑀸𑀦𑀺 (𑀲𑀻.)], 𑀧𑀼𑀦𑀤𑁂𑀯 𑀢𑀼𑀯𑀝𑁆𑀝𑀓𑀁;

𑀅𑀢𑁆𑀢𑀤𑀡𑁆𑀟𑀯𑀭𑀁 𑀲𑀼𑀢𑁆𑀢𑀁, 𑀣𑁂𑀭𑀧𑀼𑀝𑁆𑀞𑁂𑀦 [𑀣𑁂𑀭𑀧𑀜𑁆𑀳𑁂𑀦 (𑀲𑀻.), 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑁂𑀦 (𑀲𑁆𑀬𑀸.)] 𑀲𑁄𑀴𑀲;

𑀇𑀢𑀺 𑀏𑀢𑀸𑀦𑀺 𑀲𑀼𑀢𑁆𑀢𑀸𑀦𑀺, 𑀲𑀩𑁆𑀩𑀸𑀦𑀝𑁆𑀞𑀓𑀯𑀕𑁆𑀕𑀺𑀓𑀸𑀢𑀺.

𑀓𑁄𑀲𑀮𑀸𑀦𑀁 ¶ ¶ ¶ ¶ 𑀧𑀼𑀭𑀸 𑀭𑀫𑁆𑀫𑀸, 𑀅𑀕𑀫𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀧𑀣𑀁;

𑀆𑀓𑀺𑀜𑁆𑀘𑀜𑁆𑀜𑀁 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑁄, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀫𑀦𑁆𑀢𑀧𑀸𑀭𑀕𑀽.

𑀲𑁄 𑀅𑀲𑁆𑀲𑀓𑀲𑁆𑀲 𑀯𑀺𑀲𑀬𑁂, 𑀅𑀴𑀓𑀲𑁆𑀲 [𑀫𑀼𑀴𑀓𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸.), 𑀫𑀽𑀴𑁆𑀳𑀓𑀲𑁆𑀲 (𑀓.), 𑀫𑀴𑀓𑀲𑁆𑀲 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲)] 𑀲𑀫𑀸𑀲𑀦𑁂;

𑀯𑀲𑀺 𑀕𑁄𑀥𑀸𑀯𑀭𑀻𑀓𑀽𑀮𑁂, 𑀉𑀜𑁆𑀙𑁂𑀦 𑀘 𑀨𑀮𑁂𑀦 𑀘.

𑀢𑀲𑁆𑀲𑁂𑀯 𑀉𑀧𑀦𑀺𑀲𑁆𑀲𑀸𑀬, 𑀕𑀸𑀫𑁄 𑀘 𑀯𑀺𑀧𑀼𑀮𑁄 𑀅𑀳𑀼;

𑀢𑀢𑁄 𑀚𑀸𑀢𑁂𑀦 𑀆𑀬𑁂𑀦, 𑀫𑀳𑀸𑀬𑀜𑁆𑀜𑀫𑀓𑀧𑁆𑀧𑀬𑀺.

𑀫𑀳𑀸𑀬𑀜𑁆𑀜𑀁 𑀬𑀚𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑀼𑀦 𑀧𑀸𑀯𑀺𑀲𑀺 𑀅𑀲𑁆𑀲𑀫𑀁;

𑀢𑀲𑁆𑀫𑀺𑀁 𑀧𑀝𑀺𑀧𑀯𑀺𑀝𑁆𑀞𑀫𑁆𑀳𑀺, 𑀅𑀜𑁆𑀜𑁄 𑀆𑀕𑀜𑁆𑀙𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

𑀉𑀕𑁆𑀖𑀝𑁆𑀝𑀧𑀸𑀤𑁄 𑀢𑀲𑀺𑀢𑁄 [𑀢𑀲𑁆𑀲𑀺𑀢𑁄 (𑀓.)], 𑀧𑀗𑁆𑀓𑀤𑀦𑁆𑀢𑁄 𑀭𑀚𑀲𑁆𑀲𑀺𑀭𑁄;

𑀲𑁄 𑀘 𑀦𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑁆𑀫, 𑀲𑀢𑀸𑀦𑀺 𑀧𑀜𑁆𑀘 𑀬𑀸𑀘𑀢𑀺.

𑀢𑀫𑁂𑀦𑀁 𑀩𑀸𑀯𑀭𑀻 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀆𑀲𑀦𑁂𑀦 𑀦𑀺𑀫𑀦𑁆𑀢𑀬𑀺;

𑀲𑀼𑀔𑀜𑁆𑀘 𑀓𑀼𑀲𑀮𑀁 𑀧𑀼𑀘𑁆𑀙𑀺, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺.

‘‘𑀬𑀁 𑀔𑁄 𑀫𑀫 𑀤𑁂𑀬𑁆𑀬𑀥𑀫𑁆𑀫𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀯𑀺𑀲𑀚𑁆𑀚𑀺𑀢𑀁 𑀫𑀬𑀸;

𑀅𑀦𑀼𑀚𑀸𑀦𑀸𑀳𑀺 𑀫𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑁂, 𑀦𑀢𑁆𑀣𑀺 𑀧𑀜𑁆𑀘𑀲𑀢𑀸𑀦𑀺 𑀫𑁂’’.

‘‘𑀲𑀘𑁂 ¶ 𑀫𑁂 𑀬𑀸𑀘𑀫𑀸𑀦𑀲𑁆𑀲, 𑀪𑀯𑀁 𑀦𑀸𑀦𑀼𑀧𑀤𑀲𑁆𑀲𑀢𑀺;

𑀲𑀢𑁆𑀢𑀫𑁂 𑀤𑀺𑀯𑀲𑁂 𑀢𑀼𑀬𑁆𑀳𑀁, 𑀫𑀼𑀤𑁆𑀥𑀸 𑀨𑀮𑀢𑀼 𑀲𑀢𑁆𑀢𑀥𑀸’’.

𑀅𑀪𑀺𑀲𑀗𑁆𑀔𑀭𑀺𑀢𑁆𑀯𑀸 ¶ ¶ 𑀓𑀼𑀳𑀓𑁄, 𑀪𑁂𑀭𑀯𑀁 𑀲𑁄 𑀅𑀓𑀺𑀢𑁆𑀢𑀬𑀺;

𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀩𑀸𑀯𑀭𑀻 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁄 𑀅𑀳𑀼.

𑀉𑀲𑁆𑀲𑀼𑀲𑁆𑀲𑀢𑀺 𑀅𑀦𑀸𑀳𑀸𑀭𑁄, 𑀲𑁄𑀓𑀲𑀮𑁆𑀮𑀲𑀫𑀧𑁆𑀧𑀺𑀢𑁄;

𑀅𑀣𑁄𑀧𑀺 𑀏𑀯𑀁 𑀘𑀺𑀢𑁆𑀢𑀲𑁆𑀲, 𑀛𑀸𑀦𑁂 𑀦 𑀭𑀫𑀢𑀻 𑀫𑀦𑁄.

𑀉𑀢𑁆𑀭𑀲𑁆𑀢𑀁 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑀺𑀦𑀻;

𑀩𑀸𑀯𑀭𑀺𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑁆𑀫, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺.

‘‘𑀦 ¶ 𑀲𑁄 𑀫𑀼𑀤𑁆𑀥𑀁 𑀧𑀚𑀸𑀦𑀸𑀢𑀺, 𑀓𑀼𑀳𑀓𑁄 𑀲𑁄 𑀥𑀦𑀢𑁆𑀣𑀺𑀓𑁄;

𑀫𑀼𑀤𑁆𑀥𑀦𑀺 𑀫𑀼𑀤𑁆𑀥𑀧𑀸𑀢𑁂 𑀯𑀸, 𑀜𑀸𑀡𑀁 𑀢𑀲𑁆𑀲 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺’’.

‘‘𑀪𑁄𑀢𑀻 𑀘𑀭𑀳𑀺 𑀚𑀸𑀦𑀸𑀲𑀺, 𑀢𑀁 𑀫𑁂 𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸;

𑀫𑀼𑀤𑁆𑀥𑀁 𑀫𑀼𑀤𑁆𑀥𑀸𑀥𑀺𑀧𑀸𑀢𑀜𑁆𑀘, 𑀢𑀁 𑀲𑀼𑀡𑁄𑀫 𑀯𑀘𑁄 𑀢𑀯’’.

‘‘𑀅𑀳𑀫𑁆𑀧𑁂𑀢𑀁 𑀦 𑀚𑀸𑀦𑀸𑀫𑀺, 𑀜𑀸𑀡𑀫𑁂𑀢𑁆𑀣 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀫𑀼𑀤𑁆𑀥𑀦𑀺 𑀫𑀼𑀤𑁆𑀥𑀸𑀥𑀺𑀧𑀸𑀢𑁂 𑀘, 𑀚𑀺𑀦𑀸𑀦𑀁 𑀳𑁂𑀢𑁆𑀣 [𑀫𑀼𑀤𑁆𑀥𑀁 𑀫𑀼𑀤𑁆𑀥𑀸𑀥𑀺𑀧𑀸𑀢𑁄 𑀘, 𑀚𑀺𑀦𑀸𑀦𑀁 𑀳𑁂𑀢 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀤𑀲𑁆𑀲𑀦𑀁’’.

‘‘𑀅𑀣 𑀓𑁄 𑀘𑀭𑀳𑀺 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀅𑀲𑁆𑀫𑀺𑀁 𑀧𑀣𑀯𑀺𑀫𑀡𑁆𑀟𑀮𑁂 [𑀧𑀼𑀣𑀯𑀺𑀫𑀡𑁆𑀟𑀮𑁂 (𑀲𑀻. 𑀧𑀻.)];

𑀫𑀼𑀤𑁆𑀥𑀁 𑀫𑀼𑀤𑁆𑀥𑀸𑀥𑀺𑀧𑀸𑀢𑀜𑁆𑀘, 𑀢𑀁 𑀫𑁂 𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀤𑁂𑀯𑀢𑁂’’.

‘‘𑀧𑀼𑀭𑀸 ¶ 𑀓𑀧𑀺𑀮𑀯𑀢𑁆𑀣𑀼𑀫𑁆𑀳𑀸, 𑀦𑀺𑀓𑁆𑀔𑀦𑁆𑀢𑁄 𑀮𑁄𑀓𑀦𑀸𑀬𑀓𑁄;

𑀅𑀧𑀘𑁆𑀘𑁄 𑀑𑀓𑁆𑀓𑀸𑀓𑀭𑀸𑀚𑀲𑁆𑀲, 𑀲𑀓𑁆𑀬𑀧𑀼𑀢𑁆𑀢𑁄 𑀧𑀪𑀗𑁆𑀓𑀭𑁄.

‘‘𑀲𑁄 𑀳𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄, 𑀲𑀩𑁆𑀩𑀥𑀫𑁆𑀫𑀸𑀦 𑀧𑀸𑀭𑀕𑀽;

𑀲𑀩𑁆𑀩𑀸𑀪𑀺𑀜𑁆𑀜𑀸𑀩𑀮𑀧𑁆𑀧𑀢𑁆𑀢𑁄, 𑀲𑀩𑁆𑀩𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀘𑀓𑁆𑀔𑀼𑀫𑀸;

𑀲𑀩𑁆𑀩𑀓𑀫𑁆𑀫𑀓𑁆𑀔𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄 𑀉𑀧𑀥𑀺𑀓𑁆𑀔𑀬𑁂.

‘‘𑀩𑀼𑀤𑁆𑀥𑁄 𑀲𑁄 𑀪𑀕𑀯𑀸 𑀮𑁄𑀓𑁂, 𑀥𑀫𑁆𑀫𑀁 𑀤𑁂𑀲𑁂𑀢𑀺 𑀘𑀓𑁆𑀔𑀼𑀫𑀸;

𑀢𑀁 ¶ 𑀢𑁆𑀯𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀧𑀼𑀘𑁆𑀙𑀲𑁆𑀲𑀼, 𑀲𑁄 𑀢𑁂 𑀢𑀁 𑀩𑁆𑀬𑀸𑀓𑀭𑀺𑀲𑁆𑀲𑀢𑀺’’.

𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄𑀢𑀺 ¶ 𑀯𑀘𑁄 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀉𑀤𑀕𑁆𑀕𑁄 𑀩𑀸𑀯𑀭𑀻 𑀅𑀳𑀼;

𑀲𑁄𑀓𑀲𑁆𑀲 𑀢𑀦𑀼𑀓𑁄 𑀆𑀲𑀺, 𑀧𑀻𑀢𑀺𑀜𑁆𑀘 𑀯𑀺𑀧𑀼𑀮𑀁 𑀮𑀪𑀺.

𑀲𑁄 𑀩𑀸𑀯𑀭𑀻 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀉𑀤𑀕𑁆𑀕𑁄, 𑀢𑀁 𑀤𑁂𑀯𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀢𑀺 𑀯𑁂𑀤𑀚𑀸𑀢𑁄;

‘‘𑀓𑀢𑀫𑀫𑁆𑀳𑀺 𑀕𑀸𑀫𑁂 𑀦𑀺𑀕𑀫𑀫𑁆𑀳𑀺 𑀯𑀸 𑀧𑀦, 𑀓𑀢𑀫𑀫𑁆𑀳𑀺 𑀯𑀸 𑀚𑀦𑀧𑀤𑁂 𑀮𑁄𑀓𑀦𑀸𑀣𑁄;

𑀬𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀧𑀲𑁆𑀲𑁂𑀫𑀼 [𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀦𑀫𑀲𑁆𑀲𑁂𑀫𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀼𑀢𑁆𑀢𑀫𑀁’’ [𑀤𑁆𑀯𑀺𑀧𑀤𑀼𑀢𑁆𑀢𑀫𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)],.

‘‘𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 𑀓𑁄𑀲𑀮𑀫𑀦𑁆𑀤𑀺𑀭𑁂 𑀚𑀺𑀦𑁄, 𑀧𑀳𑀽𑀢𑀧𑀜𑁆𑀜𑁄 𑀯𑀭𑀪𑀽𑀭𑀺𑀫𑁂𑀥𑀲𑁄;

𑀲𑁄 𑀲𑀓𑁆𑀬𑀧𑀼𑀢𑁆𑀢𑁄 𑀯𑀺𑀥𑀼𑀭𑁄 𑀅𑀦𑀸𑀲𑀯𑁄, 𑀫𑀼𑀤𑁆𑀥𑀸𑀥𑀺𑀧𑀸𑀢𑀲𑁆𑀲 𑀯𑀺𑀤𑀽 𑀦𑀭𑀸𑀲𑀪𑁄’’.

𑀢𑀢𑁄 ¶ 𑀆𑀫𑀦𑁆𑀢𑀬𑀻 𑀲𑀺𑀲𑁆𑀲𑁂, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂 𑀫𑀦𑁆𑀢𑀧𑀸𑀭𑀕𑁂;

‘‘𑀏𑀣 𑀫𑀸𑀡𑀯𑀸 𑀅𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁, 𑀲𑀼𑀡𑀸𑀣 𑀯𑀘𑀦𑀁 𑀫𑀫.

‘‘𑀬𑀲𑁆𑀲𑁂𑀲𑁄 ¶ 𑀤𑀼𑀮𑁆𑀮𑀪𑁄 𑀮𑁄𑀓𑁂, 𑀧𑀸𑀢𑀼𑀪𑀸𑀯𑁄 𑀅𑀪𑀺𑀡𑁆𑀳𑀲𑁄;

𑀲𑁆𑀯𑀸𑀚𑁆𑀚 𑀮𑁄𑀓𑀫𑁆𑀳𑀺 𑀉𑀧𑁆𑀧𑀦𑁆𑀦𑁄, 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄 𑀇𑀢𑀺 𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑁄;

𑀔𑀺𑀧𑁆𑀧𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀁, 𑀧𑀲𑁆𑀲𑀯𑁆𑀳𑁄 𑀤𑁆𑀯𑀺𑀧𑀤𑀼𑀢𑁆𑀢𑀫𑀁’’.

‘‘𑀓𑀣𑀁 𑀘𑀭𑀳𑀺 𑀚𑀸𑀦𑁂𑀫𑀼, 𑀤𑀺𑀲𑁆𑀯𑀸 𑀩𑀼𑀤𑁆𑀥𑁄𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡;

𑀅𑀚𑀸𑀦𑀢𑀁 𑀦𑁄 𑀧𑀩𑁆𑀭𑀽𑀳𑀺, 𑀬𑀣𑀸 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑀁 𑀫𑀬𑀁’’.

‘‘𑀆𑀕𑀢𑀸𑀦𑀺 ¶ 𑀳𑀺 𑀫𑀦𑁆𑀢𑁂𑀲𑀼, 𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑀸;

𑀤𑁆𑀯𑀢𑁆𑀢𑀺𑀁𑀲𑀸𑀦𑀺 𑀘 [𑀤𑁆𑀯𑀺𑀢𑁆𑀢𑀺𑀁𑀲𑀸 𑀘 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀤𑁆𑀯𑀺𑀢𑁆𑀢𑀺𑀁𑀲 𑀢𑀸𑀦𑀺 (?)] 𑀩𑁆𑀬𑀸𑀓𑁆𑀔𑀸𑀢𑀸, 𑀲𑀫𑀢𑁆𑀢𑀸 𑀅𑀦𑀼𑀧𑀼𑀩𑁆𑀩𑀲𑁄.

‘‘𑀬𑀲𑁆𑀲𑁂𑀢𑁂 𑀳𑁄𑀦𑁆𑀢𑀺 𑀕𑀢𑁆𑀢𑁂𑀲𑀼, 𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑀮𑀓𑁆𑀔𑀡𑀸;

𑀤𑁆𑀯𑁂𑀬𑁂𑀯 𑀢𑀲𑁆𑀲 𑀕𑀢𑀺𑀬𑁄, 𑀢𑀢𑀺𑀬𑀸 𑀳𑀺 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺.

‘‘𑀲𑀘𑁂 𑀅𑀕𑀸𑀭𑀁 𑀆𑀯𑀲𑀢𑀺 [𑀅𑀚𑁆𑀛𑀸𑀯𑀲𑀢𑀺 (𑀓.)], 𑀯𑀺𑀚𑁂𑀬𑁆𑀬 𑀧𑀣𑀯𑀺𑀁 𑀇𑀫𑀁;

𑀅𑀤𑀡𑁆𑀟𑁂𑀦 𑀅𑀲𑀢𑁆𑀣𑁂𑀦, 𑀥𑀫𑁆𑀫𑁂𑀦𑀫𑀦𑀼𑀲𑀸𑀲𑀢𑀺.

‘‘𑀲𑀘𑁂 ¶ 𑀘 𑀲𑁄 𑀧𑀩𑁆𑀩𑀚𑀢𑀺, 𑀅𑀕𑀸𑀭𑀸 𑀅𑀦𑀕𑀸𑀭𑀺𑀬𑀁;

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

‘‘𑀚𑀸𑀢𑀺𑀁 𑀕𑁄𑀢𑁆𑀢𑀜𑁆𑀘 𑀮𑀓𑁆𑀔𑀡𑀁, 𑀫𑀦𑁆𑀢𑁂 𑀲𑀺𑀲𑁆𑀲𑁂 𑀧𑀼𑀦𑀸𑀧𑀭𑁂;

𑀫𑀼𑀤𑁆𑀥𑀁 𑀫𑀼𑀤𑁆𑀥𑀸𑀥𑀺𑀧𑀸𑀢𑀜𑁆𑀘, 𑀫𑀦𑀲𑀸𑀬𑁂𑀯 𑀧𑀼𑀘𑁆𑀙𑀣.

‘‘𑀅𑀦𑀸𑀯𑀭𑀡𑀤𑀲𑁆𑀲𑀸𑀯𑀻, 𑀬𑀤𑀺 𑀩𑀼𑀤𑁆𑀥𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺;

𑀫𑀦𑀲𑀸 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁂 𑀧𑀜𑁆𑀳𑁂, 𑀯𑀸𑀘𑀸𑀬 𑀯𑀺𑀲𑁆𑀲𑀚𑁂𑀲𑁆𑀲𑀢𑀺’’.

𑀩𑀸𑀯𑀭𑀺𑀲𑁆𑀲 𑀯𑀘𑁄 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀲𑀺𑀲𑁆𑀲𑀸 𑀲𑁄𑀴𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸;

𑀅𑀚𑀺𑀢𑁄 𑀢𑀺𑀲𑁆𑀲𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑁄, 𑀧𑀼𑀡𑁆𑀡𑀓𑁄 𑀅𑀣 𑀫𑁂𑀢𑁆𑀢𑀕𑀽.

𑀥𑁄𑀢𑀓𑁄 ¶ 𑀉𑀧𑀲𑀻𑀯𑁄 𑀘, 𑀦𑀦𑁆𑀤𑁄 𑀘 𑀅𑀣 𑀳𑁂𑀫𑀓𑁄;

𑀢𑁄𑀤𑁂𑀬𑁆𑀬𑀓𑀧𑁆𑀧𑀸 𑀤𑀼𑀪𑀬𑁄, 𑀚𑀢𑀼𑀓𑀡𑁆𑀡𑀻 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑁄.

𑀪𑀤𑁆𑀭𑀸𑀯𑀼𑀥𑁄 ¶ 𑀉𑀤𑀬𑁄 𑀘, 𑀧𑁄𑀲𑀸𑀮𑁄 𑀘𑀸𑀧𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

𑀫𑁄𑀖𑀭𑀸𑀚𑀸 𑀘 𑀫𑁂𑀥𑀸𑀯𑀻, 𑀧𑀺𑀗𑁆𑀕𑀺𑀬𑁄 𑀘 𑀫𑀳𑀸𑀇𑀲𑀺.

𑀧𑀘𑁆𑀘𑁂𑀓𑀕𑀡𑀺𑀦𑁄 𑀲𑀩𑁆𑀩𑁂, 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀲𑁆𑀲 𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑀸;

𑀛𑀸𑀬𑀻 𑀛𑀸𑀦𑀭𑀢𑀸 𑀥𑀻𑀭𑀸, 𑀧𑀼𑀩𑁆𑀩𑀯𑀸𑀲𑀦𑀯𑀸𑀲𑀺𑀢𑀸.

𑀩𑀸𑀯𑀭𑀺𑀁 ¶ 𑀅𑀪𑀺𑀯𑀸𑀤𑁂𑀢𑁆𑀯𑀸, 𑀓𑀢𑁆𑀯𑀸 𑀘 𑀦𑀁 𑀧𑀤𑀓𑁆𑀔𑀺𑀡𑀁;

𑀚𑀝𑀸𑀚𑀺𑀦𑀥𑀭𑀸 𑀲𑀩𑁆𑀩𑁂, 𑀧𑀓𑁆𑀓𑀸𑀫𑀼𑀁 𑀉𑀢𑁆𑀢𑀭𑀸𑀫𑀼𑀔𑀸.

𑀅𑀴𑀓𑀲𑁆𑀲 𑀧𑀢𑀺𑀝𑁆𑀞𑀸𑀦𑀁, 𑀧𑀼𑀭𑀺𑀫𑀸𑀳𑀺𑀲𑁆𑀲𑀢𑀺𑀁 [𑀧𑀼𑀭𑀺𑀫𑀁 𑀫𑀸𑀳𑀺𑀲𑁆𑀲𑀢𑀺𑀁 (𑀲𑀻. 𑀧𑀻.), 𑀧𑀼𑀭𑀁 𑀫𑀸𑀳𑀺𑀲𑁆𑀲𑀢𑀺𑀁 (𑀲𑁆𑀬𑀸.)] 𑀢𑀤𑀸;

𑀉𑀚𑁆𑀚𑁂𑀦𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀕𑁄𑀦𑀤𑁆𑀥𑀁, 𑀯𑁂𑀤𑀺𑀲𑀁 𑀯𑀦𑀲𑀯𑁆𑀳𑀬𑀁.

𑀓𑁄𑀲𑀫𑁆𑀩𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀲𑀸𑀓𑁂𑀢𑀁, 𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀜𑁆𑀘 𑀧𑀼𑀭𑀼𑀢𑁆𑀢𑀫𑀁;

𑀲𑁂𑀢𑀩𑁆𑀬𑀁 𑀓𑀧𑀺𑀮𑀯𑀢𑁆𑀣𑀼𑀁, 𑀓𑀼𑀲𑀺𑀦𑀸𑀭𑀜𑁆𑀘 𑀫𑀦𑁆𑀤𑀺𑀭𑀁.

𑀧𑀸𑀯𑀜𑁆𑀘 ¶ 𑀪𑁄𑀕𑀦𑀕𑀭𑀁, 𑀯𑁂𑀲𑀸𑀮𑀺𑀁 𑀫𑀸𑀕𑀥𑀁 𑀧𑀼𑀭𑀁;

𑀧𑀸𑀲𑀸𑀡𑀓𑀁 𑀘𑁂𑀢𑀺𑀬𑀜𑁆𑀘, 𑀭𑀫𑀡𑀻𑀬𑀁 𑀫𑀦𑁄𑀭𑀫𑀁.

𑀢𑀲𑀺𑀢𑁄𑀯𑀼𑀤𑀓𑀁 ¶ 𑀲𑀻𑀢𑀁, 𑀫𑀳𑀸𑀮𑀸𑀪𑀁𑀯 𑀯𑀸𑀡𑀺𑀚𑁄;

𑀙𑀸𑀬𑀁 𑀖𑀫𑁆𑀫𑀸𑀪𑀺𑀢𑀢𑁆𑀢𑁄𑀯, 𑀢𑀼𑀭𑀺𑀢𑀸 𑀧𑀩𑁆𑀩𑀢𑀫𑀸𑀭𑀼𑀳𑀼𑀁.

𑀪𑀕𑀯𑀸 𑀢𑀫𑁆𑀳𑀺 𑀲𑀫𑀬𑁂, 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄;

𑀪𑀺𑀓𑁆𑀔𑀽𑀦𑀁 𑀥𑀫𑁆𑀫𑀁 𑀤𑁂𑀲𑁂𑀢𑀺, 𑀲𑀻𑀳𑁄𑀯 𑀦𑀤𑀢𑀻 𑀯𑀦𑁂.

𑀅𑀚𑀺𑀢𑁄 𑀅𑀤𑁆𑀤𑀲 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀲𑀢𑀭𑀁𑀲𑀺𑀁 [𑀯𑀻𑀢𑀭𑀁𑀲𑀺𑀁𑀯 (𑀲𑁆𑀬𑀸.), 𑀲𑀢𑀭𑀁𑀲𑀻𑀯 (𑀓.), 𑀧𑀻𑀢𑀭𑀁𑀲𑀻𑀯 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲)] 𑀯 𑀪𑀸𑀡𑀼𑀫𑀁;

𑀘𑀦𑁆𑀤𑀁 𑀬𑀣𑀸 𑀧𑀦𑁆𑀦𑀭𑀲𑁂, 𑀧𑀸𑀭𑀺𑀧𑀽𑀭𑀺𑀁 𑀉𑀧𑀸𑀕𑀢𑀁.

𑀅𑀣𑀲𑁆𑀲 𑀕𑀢𑁆𑀢𑁂 𑀤𑀺𑀲𑁆𑀯𑀸𑀦, 𑀧𑀭𑀺𑀧𑀽𑀭𑀜𑁆𑀘 𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀁;

𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀞𑀺𑀢𑁄 𑀳𑀝𑁆𑀞𑁄, 𑀫𑀦𑁄𑀧𑀜𑁆𑀳𑁂 𑀅𑀧𑀼𑀘𑁆𑀙𑀣.

‘‘𑀆𑀤𑀺𑀲𑁆𑀲 𑀚𑀫𑁆𑀫𑀦𑀁 [𑀚𑀧𑁆𑀧𑀦𑀁 (𑀓.)] 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀕𑁄𑀢𑁆𑀢𑀁 𑀩𑁆𑀭𑀽𑀳𑀺 𑀲𑀮𑀓𑁆𑀔𑀡𑀁 [𑀩𑁆𑀭𑀽𑀳𑀺𑀲𑁆𑀲 𑀮𑀓𑁆𑀔𑀡𑀁 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲)];

𑀫𑀦𑁆𑀢𑁂𑀲𑀼 𑀧𑀸𑀭𑀫𑀺𑀁 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀢𑀺 𑀯𑀸𑀘𑁂𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄’’.

‘‘𑀯𑀻𑀲𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀁 𑀆𑀬𑀼, 𑀲𑁄 𑀘 𑀕𑁄𑀢𑁆𑀢𑁂𑀦 𑀩𑀸𑀯𑀭𑀻;

𑀢𑀻𑀡𑀺𑀲𑁆𑀲 𑀮𑀓𑁆𑀔𑀡𑀸 𑀕𑀢𑁆𑀢𑁂, 𑀢𑀺𑀡𑁆𑀡𑀁 𑀯𑁂𑀤𑀸𑀦 𑀧𑀸𑀭𑀕𑀽.

‘‘𑀮𑀓𑁆𑀔𑀡𑁂 ¶ ¶ 𑀇𑀢𑀺𑀳𑀸𑀲𑁂 𑀘, 𑀲𑀦𑀺𑀖𑀡𑁆𑀟𑀼𑀲𑀓𑁂𑀝𑀼𑀪𑁂;

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

‘‘𑀮𑀓𑁆𑀔𑀡𑀸𑀦𑀁 ¶ 𑀧𑀯𑀺𑀘𑀬𑀁, 𑀩𑀸𑀯𑀭𑀺𑀲𑁆𑀲 𑀦𑀭𑀼𑀢𑁆𑀢𑀫;

𑀓𑀗𑁆𑀔𑀘𑁆𑀙𑀺𑀤 [𑀢𑀡𑁆𑀳𑀘𑁆𑀙𑀺𑀤 (𑀩𑀳𑀽𑀲𑀼)] 𑀧𑀓𑀸𑀲𑁂𑀳𑀺, 𑀫𑀸 𑀦𑁄 𑀓𑀗𑁆𑀔𑀸𑀬𑀺𑀢𑀁 𑀅𑀳𑀼’’.

‘‘𑀫𑀼𑀔𑀁 𑀚𑀺𑀯𑁆𑀳𑀸𑀬 𑀙𑀸𑀤𑁂𑀢𑀺, 𑀉𑀡𑁆𑀡𑀲𑁆𑀲 𑀪𑀫𑀼𑀓𑀦𑁆𑀢𑀭𑁂;

𑀓𑁄𑀲𑁄𑀳𑀺𑀢𑀁 𑀯𑀢𑁆𑀣𑀕𑀼𑀬𑁆𑀳𑀁, 𑀏𑀯𑀁 𑀚𑀸𑀦𑀸𑀳𑀺 𑀫𑀸𑀡𑀯’’.

𑀧𑀼𑀘𑁆𑀙𑀜𑁆𑀳𑀺 ¶ 𑀓𑀺𑀜𑁆𑀘𑀺 𑀅𑀲𑀼𑀡𑀦𑁆𑀢𑁄, 𑀲𑀼𑀢𑁆𑀯𑀸 𑀧𑀜𑁆𑀳𑁂 𑀯𑀺𑀬𑀸𑀓𑀢𑁂;

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

‘‘𑀓𑁄 𑀦𑀼 𑀤𑁂𑀯𑁄 𑀯𑀸 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀯𑀸, 𑀇𑀦𑁆𑀤𑁄 𑀯𑀸𑀧𑀺 𑀲𑀼𑀚𑀫𑁆𑀧𑀢𑀺;

𑀫𑀦𑀲𑀸 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁂 𑀧𑀜𑁆𑀳𑁂, 𑀓𑀫𑁂𑀢𑀁 𑀧𑀝𑀺𑀪𑀸𑀲𑀢𑀺.

‘‘𑀫𑀼𑀤𑁆𑀥𑀁 𑀫𑀼𑀤𑁆𑀥𑀸𑀥𑀺𑀧𑀸𑀢𑀜𑁆𑀘, 𑀩𑀸𑀯𑀭𑀻 𑀧𑀭𑀺𑀧𑀼𑀘𑁆𑀙𑀢𑀺;

𑀢𑀁 𑀩𑁆𑀬𑀸𑀓𑀭𑁄𑀳𑀺 𑀪𑀕𑀯𑀸, 𑀓𑀗𑁆𑀔𑀁 𑀯𑀺𑀦𑀬 𑀦𑁄 𑀇𑀲𑁂’’.

‘‘𑀅𑀯𑀺𑀚𑁆𑀚𑀸 𑀫𑀼𑀤𑁆𑀥𑀸𑀢𑀺 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀯𑀺𑀚𑁆𑀚𑀸 𑀫𑀼𑀤𑁆𑀥𑀸𑀥𑀺𑀧𑀸𑀢𑀺𑀦𑀻;

𑀲𑀤𑁆𑀥𑀸𑀲𑀢𑀺𑀲𑀫𑀸𑀥𑀻𑀳𑀺, 𑀙𑀦𑁆𑀤𑀯𑀻𑀭𑀺𑀬𑁂𑀦 𑀲𑀁𑀬𑀼𑀢𑀸’’.

𑀢𑀢𑁄 𑀯𑁂𑀤𑁂𑀦 𑀫𑀳𑀢𑀸, 𑀲𑀦𑁆𑀣𑀫𑁆𑀪𑀺𑀢𑁆𑀯𑀸𑀦 𑀫𑀸𑀡𑀯𑁄;

𑀏𑀓𑀁𑀲𑀁 𑀅𑀚𑀺𑀦𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀧𑀸𑀤𑁂𑀲𑀼 𑀲𑀺𑀭𑀲𑀸 𑀧𑀢𑀺.

‘‘𑀩𑀸𑀯𑀭𑀻 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀪𑁄𑀢𑁄, 𑀲𑀳 𑀲𑀺𑀲𑁆𑀲𑁂𑀳𑀺 𑀫𑀸𑀭𑀺𑀲;

𑀉𑀤𑀕𑁆𑀕𑀘𑀺𑀢𑁆𑀢𑁄 𑀲𑀼𑀫𑀦𑁄, 𑀧𑀸𑀤𑁂 𑀯𑀦𑁆𑀤𑀢𑀺 𑀘𑀓𑁆𑀔𑀼𑀫’’.

‘‘𑀲𑀼𑀔𑀺𑀢𑁄 ¶ 𑀩𑀸𑀯𑀭𑀻 𑀳𑁄𑀢𑀼, 𑀲𑀳 𑀲𑀺𑀲𑁆𑀲𑁂𑀳𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

𑀢𑁆𑀯𑀜𑁆𑀘𑀸𑀧𑀺 𑀲𑀼𑀔𑀺𑀢𑁄 𑀳𑁄𑀳𑀺, 𑀘𑀺𑀭𑀁 𑀚𑀻𑀯𑀸𑀳𑀺 𑀫𑀸𑀡𑀯.

‘‘𑀩𑀸𑀯𑀭𑀺𑀲𑁆𑀲 ¶ 𑀘 𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀸, 𑀲𑀩𑁆𑀩𑁂𑀲𑀁 𑀲𑀩𑁆𑀩𑀲𑀁𑀲𑀬𑀁;

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

𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁂𑀦 𑀓𑀢𑁄𑀓𑀸𑀲𑁄, 𑀦𑀺𑀲𑀻𑀤𑀺𑀢𑁆𑀯𑀸𑀦 𑀧𑀜𑁆𑀚𑀮𑀻;

𑀅𑀚𑀺𑀢𑁄 𑀧𑀞𑀫𑀁 𑀧𑀜𑁆𑀳𑀁, 𑀢𑀢𑁆𑀣 𑀧𑀼𑀘𑁆𑀙𑀺 𑀢𑀣𑀸𑀕𑀢𑀁.

‘‘𑀓𑁂𑀦𑀲𑁆𑀲𑀼 ¶ ¶ 𑀦𑀺𑀯𑀼𑀢𑁄 𑀮𑁄𑀓𑁄, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀅𑀚𑀺𑀢𑁄)

𑀓𑀺𑀲𑁆𑀲𑀸𑀪𑀺𑀮𑁂𑀧𑀦𑀁 𑀩𑁆𑀭𑀽𑀲𑀺, 𑀓𑀺𑀁𑀲𑀼 𑀢𑀲𑁆𑀲 𑀫𑀳𑀩𑁆𑀪𑀬𑀁’’.

‘‘𑀅𑀯𑀺𑀚𑁆𑀚𑀸𑀬 𑀦𑀺𑀯𑀼𑀢𑁄 𑀮𑁄𑀓𑁄, (𑀅𑀚𑀺𑀢𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀯𑁂𑀯𑀺𑀘𑁆𑀙𑀸 𑀧𑀫𑀸𑀤𑀸 𑀦𑀧𑁆𑀧𑀓𑀸𑀲𑀢𑀺;

𑀚𑀧𑁆𑀧𑀸𑀪𑀺𑀮𑁂𑀧𑀦𑀁 𑀩𑁆𑀭𑀽𑀫𑀺, 𑀤𑀼𑀓𑁆𑀔𑀫𑀲𑁆𑀲 𑀫𑀳𑀩𑁆𑀪𑀬𑀁’’.

‘‘𑀲𑀯𑀦𑁆𑀢𑀺 ¶ 𑀲𑀩𑁆𑀩𑀥𑀺 𑀲𑁄𑀢𑀸, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀅𑀚𑀺𑀢𑁄)

𑀲𑁄𑀢𑀸𑀦𑀁 𑀲𑀁𑀯𑀭𑀁 𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑁂𑀦 𑀲𑁄𑀢𑀸 𑀧𑀺𑀥𑀺𑀬𑁆𑀬𑀭𑁂’’ [𑀧𑀺𑀣𑀺𑀬𑁆𑀬𑀭𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀧𑀺𑀣𑀻𑀬𑀭𑁂 (𑀲𑀻. 𑀅𑀝𑁆𑀞.), 𑀧𑀺𑀥𑀻𑀬𑀭𑁂 (?)].

‘‘𑀬𑀸𑀦𑀺 𑀲𑁄𑀢𑀸𑀦𑀺 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁, (𑀅𑀚𑀺𑀢𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀲𑁄𑀢𑀸𑀦𑀁 𑀲𑀁𑀯𑀭𑀁 𑀩𑁆𑀭𑀽𑀫𑀺, 𑀧𑀜𑁆𑀜𑀸𑀬𑁂𑀢𑁂 𑀧𑀺𑀥𑀺𑀬𑁆𑀬𑀭𑁂’’.

‘‘𑀧𑀜𑁆𑀜𑀸 𑀘𑁂𑀯 𑀲𑀢𑀺 𑀬𑀜𑁆𑀘 [𑀲𑀢𑀻 𑀘𑁂𑀯 (𑀲𑀻.), 𑀲𑀢𑀻 𑀘 (𑀲𑁆𑀬𑀸.), 𑀲𑀢𑀻 𑀘𑀸𑀧𑀺 (𑀧𑀻. 𑀦𑀺𑀤𑁆𑀤𑁂𑀲), 𑀲𑀢𑀺 𑀘𑀸𑀧𑀺 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲)], (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀅𑀚𑀺𑀢𑁄)

𑀏𑀢𑀁 ¶ 𑀫𑁂 𑀧𑀼𑀝𑁆𑀞𑁄 𑀧𑀩𑁆𑀭𑀽𑀳𑀺, 𑀓𑀢𑁆𑀣𑁂𑀢𑀁 𑀉𑀧𑀭𑀼𑀚𑁆𑀛𑀢𑀺’’.

‘‘𑀬𑀫𑁂𑀢𑀁 𑀧𑀜𑁆𑀳𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺, 𑀅𑀚𑀺𑀢 𑀢𑀁 𑀯𑀤𑀸𑀫𑀺 𑀢𑁂;

𑀬𑀢𑁆𑀣 𑀦𑀸𑀫𑀜𑁆𑀘 𑀭𑀽𑀧𑀜𑁆𑀘, 𑀅𑀲𑁂𑀲𑀁 𑀉𑀧𑀭𑀼𑀚𑁆𑀛𑀢𑀺;

𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀲𑁆𑀲 𑀦𑀺𑀭𑁄𑀥𑁂𑀦, 𑀏𑀢𑁆𑀣𑁂𑀢𑀁 𑀉𑀧𑀭𑀼𑀚𑁆𑀛𑀢𑀺’’.

‘‘𑀬𑁂 𑀘 𑀲𑀗𑁆𑀔𑀸𑀢𑀥𑀫𑁆𑀫𑀸𑀲𑁂, 𑀬𑁂 𑀘 𑀲𑁂𑀔𑀸 𑀧𑀼𑀣𑀽 𑀇𑀥;

𑀢𑁂𑀲𑀁 𑀫𑁂 𑀦𑀺𑀧𑀓𑁄 𑀇𑀭𑀺𑀬𑀁, 𑀧𑀼𑀝𑁆𑀞𑁄 𑀧𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑀸𑀭𑀺𑀲’’.

‘‘𑀓𑀸𑀫𑁂𑀲𑀼 ¶ 𑀦𑀸𑀪𑀺𑀕𑀺𑀚𑁆𑀛𑁂𑀬𑁆𑀬, 𑀫𑀦𑀲𑀸𑀦𑀸𑀯𑀺𑀮𑁄 𑀲𑀺𑀬𑀸;

𑀓𑀼𑀲𑀮𑁄 𑀲𑀩𑁆𑀩𑀥𑀫𑁆𑀫𑀸𑀦𑀁, 𑀲𑀢𑁄 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀭𑀺𑀩𑁆𑀩𑀚𑁂’’𑀢𑀺.

𑀅𑀚𑀺𑀢𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀧𑀞𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

𑁨. 𑀢𑀺𑀲𑁆𑀲𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸

‘‘𑀓𑁄𑀥 ¶ ¶ 𑀲𑀦𑁆𑀢𑀼𑀲𑀺𑀢𑁄 𑀮𑁄𑀓𑁂, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀢𑀺𑀲𑁆𑀲𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑁄)

𑀓𑁄 𑀉𑀪𑀦𑁆𑀢𑀫𑀪𑀺𑀜𑁆𑀜𑀸𑀬, 𑀫𑀚𑁆𑀛𑁂 𑀫𑀦𑁆𑀢𑀸 𑀦 𑀮𑀺𑀧𑁆𑀧𑀢𑀺 [𑀮𑀺𑀫𑁆𑀧𑀢𑀺 (𑀓.)];

𑀓𑀁 𑀩𑁆𑀭𑀽𑀲𑀺 𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑁄𑀢𑀺, 𑀓𑁄 𑀇𑀥 𑀲𑀺𑀩𑁆𑀩𑀺𑀦𑀺𑀫𑀘𑁆𑀘𑀕𑀸’’.

‘‘𑀓𑀸𑀫𑁂𑀲𑀼 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀯𑀸, (𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀲𑀗𑁆𑀔𑀸𑀬 ¶ 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀢𑀲𑁆𑀲 𑀦𑁄 𑀲𑀦𑁆𑀢𑀺 𑀇𑀜𑁆𑀚𑀺𑀢𑀸.

‘‘𑀲𑁄 𑀉𑀪𑀦𑁆𑀢𑀫𑀪𑀺𑀜𑁆𑀜𑀸𑀬, 𑀫𑀚𑁆𑀛𑁂 𑀫𑀦𑁆𑀢𑀸 𑀦 𑀮𑀺𑀧𑁆𑀧𑀢𑀺;

𑀢𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀫𑀳𑀸𑀧𑀼𑀭𑀺𑀲𑁄𑀢𑀺, 𑀲𑁄 𑀇𑀥 𑀲𑀺𑀩𑁆𑀩𑀺𑀦𑀺𑀫𑀘𑁆𑀘𑀕𑀸’’𑀢𑀺.

𑀢𑀺𑀲𑁆𑀲𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀤𑀼𑀢𑀺𑀬𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀅𑀦𑁂𑀚𑀁 𑀫𑀽𑀮𑀤𑀲𑁆𑀲𑀸𑀯𑀺𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀧𑀼𑀡𑁆𑀡𑀓𑁄)

𑀅𑀢𑁆𑀣𑀺 [𑀅𑀢𑁆𑀣𑀻 (𑀲𑁆𑀬𑀸.)] 𑀧𑀜𑁆𑀳𑁂𑀦 𑀆𑀕𑀫𑀁;

𑀓𑀺𑀁 ¶ 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸 ¶ 𑀇𑀲𑀬𑁄 𑀫𑀦𑀼𑀚𑀸, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀤𑁂𑀯𑀢𑀸𑀦𑀁;

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

‘‘𑀬𑁂 𑀓𑁂𑀘𑀺𑀫𑁂 𑀇𑀲𑀬𑁄 𑀫𑀦𑀼𑀚𑀸, (𑀧𑀼𑀡𑁆𑀡𑀓𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀤𑁂𑀯𑀢𑀸𑀦𑀁;

𑀬𑀜𑁆𑀜𑀫𑀓𑀧𑁆𑀧𑀬𑀺𑀁𑀲𑀼 𑀧𑀼𑀣𑀽𑀥 𑀮𑁄𑀓𑁂, 𑀆𑀲𑀻𑀲𑀫𑀸𑀦𑀸 𑀧𑀼𑀡𑁆𑀡𑀓 𑀇𑀢𑁆𑀣𑀢𑁆𑀢𑀁 [𑀇𑀢𑁆𑀣𑀪𑀸𑀯𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)];

𑀚𑀭𑀁 𑀲𑀺𑀢𑀸 𑀬𑀜𑁆𑀜𑀫𑀓𑀧𑁆𑀧𑀬𑀺𑀁𑀲𑀼’’.

‘‘𑀬𑁂 ¶ 𑀓𑁂𑀘𑀺𑀫𑁂 𑀇𑀲𑀬𑁄 𑀫𑀦𑀼𑀚𑀸, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀧𑀼𑀡𑁆𑀡𑀓𑁄)

𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀤𑁂𑀯𑀢𑀸𑀦𑀁;

𑀬𑀜𑁆𑀜𑀫𑀓𑀧𑁆𑀧𑀬𑀺𑀁𑀲𑀼 ¶ 𑀧𑀼𑀣𑀽𑀥 𑀮𑁄𑀓𑁂, 𑀓𑀘𑁆𑀘𑀺𑀲𑁆𑀲𑀼 𑀢𑁂 𑀪𑀕𑀯𑀸 𑀬𑀜𑁆𑀜𑀧𑀣𑁂 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀸;

𑀅𑀢𑀸𑀭𑀼𑀁 𑀚𑀸𑀢𑀺𑀜𑁆𑀘 𑀚𑀭𑀜𑁆𑀘 𑀫𑀸𑀭𑀺𑀲, 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀢𑀁’’.

‘‘𑀆𑀲𑀻𑀲𑀦𑁆𑀢𑀺 𑀣𑁄𑀫𑀬𑀦𑁆𑀢𑀺, 𑀅𑀪𑀺𑀚𑀧𑁆𑀧𑀦𑁆𑀢𑀺 𑀚𑀼𑀳𑀦𑁆𑀢𑀺; (𑀧𑀼𑀡𑁆𑀡𑀓𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀓𑀸𑀫𑀸𑀪𑀺𑀚𑀧𑁆𑀧𑀦𑁆𑀢𑀺 𑀧𑀝𑀺𑀘𑁆𑀘 𑀮𑀸𑀪𑀁, 𑀢𑁂 𑀬𑀸𑀚𑀬𑁄𑀕𑀸 𑀪𑀯𑀭𑀸𑀕𑀭𑀢𑁆𑀢𑀸;

𑀦𑀸𑀢𑀭𑀺𑀁𑀲𑀼 𑀚𑀸𑀢𑀺𑀚𑀭𑀦𑁆𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀺’’.

‘‘𑀢𑁂 ¶ 𑀘𑁂 𑀦𑀸𑀢𑀭𑀺𑀁𑀲𑀼 𑀬𑀸𑀚𑀬𑁄𑀕𑀸, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀧𑀼𑀡𑁆𑀡𑀓𑁄)

𑀬𑀜𑁆𑀜𑁂𑀳𑀺 𑀚𑀸𑀢𑀺𑀜𑁆𑀘 𑀚𑀭𑀜𑁆𑀘 𑀫𑀸𑀭𑀺𑀲;

𑀅𑀣 𑀓𑁄 𑀘𑀭𑀳𑀺 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂, 𑀅𑀢𑀸𑀭𑀺 𑀚𑀸𑀢𑀺𑀜𑁆𑀘 𑀚𑀭𑀜𑁆𑀘 𑀫𑀸𑀭𑀺𑀲;

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀢𑀁’’.

‘‘𑀲𑀗𑁆𑀔𑀸𑀬 𑀮𑁄𑀓𑀲𑁆𑀫𑀺 𑀧𑀭𑁄𑀧𑀭𑀸𑀦𑀺 [𑀧𑀭𑁄𑀯𑀭𑀸𑀦𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], (𑀧𑀼𑀡𑁆𑀡𑀓𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀬𑀲𑁆𑀲𑀺𑀜𑁆𑀚𑀺𑀢𑀁 𑀦𑀢𑁆𑀣𑀺 𑀓𑀼𑀳𑀺𑀜𑁆𑀘𑀺 𑀮𑁄𑀓𑁂;

𑀲𑀦𑁆𑀢𑁄 𑀯𑀺𑀥𑀽𑀫𑁄 𑀅𑀦𑀻𑀖𑁄 𑀦𑀺𑀭𑀸𑀲𑁄, 𑀅𑀢𑀸𑀭𑀺 𑀲𑁄 𑀚𑀸𑀢𑀺𑀚𑀭𑀦𑁆𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀻’’𑀢𑀺.

𑀧𑀼𑀡𑁆𑀡𑀓𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀢𑀢𑀺𑀬𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 ¶ ¶ 𑀢𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀢𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀫𑁂𑀢𑁆𑀢𑀕𑀽)

𑀫𑀜𑁆𑀜𑀸𑀫𑀺 𑀢𑀁 𑀯𑁂𑀤𑀕𑀼𑀁 𑀪𑀸𑀯𑀺𑀢𑀢𑁆𑀢𑀁;

𑀓𑀼𑀢𑁄 𑀦𑀼 𑀤𑀼𑀓𑁆𑀔𑀸 𑀲𑀫𑀼𑀤𑀸𑀕𑀢𑀸 𑀇𑀫𑁂, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀫𑀦𑁂𑀓𑀭𑀽𑀧𑀸’’.

‘‘𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 ¶ ¶ 𑀯𑁂 𑀫𑀁 𑀧𑀪𑀯𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀲𑀺, (𑀫𑁂𑀢𑁆𑀢𑀕𑀽𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀢𑀁 𑀢𑁂 𑀧𑀯𑀓𑁆𑀔𑀸𑀫𑀺 𑀬𑀣𑀸 𑀧𑀚𑀸𑀦𑀁;

𑀉𑀧𑀥𑀺𑀦𑀺𑀤𑀸𑀦𑀸 𑀧𑀪𑀯𑀦𑁆𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀫𑀦𑁂𑀓𑀭𑀽𑀧𑀸.

‘‘𑀬𑁄 𑀯𑁂 𑀅𑀯𑀺𑀤𑁆𑀯𑀸 𑀉𑀧𑀥𑀺𑀁 𑀓𑀭𑁄𑀢𑀺, 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁 𑀤𑀼𑀓𑁆𑀔𑀫𑀼𑀧𑁂𑀢𑀺 𑀫𑀦𑁆𑀤𑁄;

𑀢𑀲𑁆𑀫𑀸 𑀧𑀚𑀸𑀦𑀁 𑀉𑀧𑀥𑀺𑀁 𑀦 𑀓𑀬𑀺𑀭𑀸, 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀚𑀸𑀢𑀺𑀧𑁆𑀧𑀪𑀯𑀸𑀦𑀼𑀧𑀲𑁆𑀲𑀻’’.

‘‘𑀬𑀁 𑀢𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺𑀫𑁆𑀳 𑀅𑀓𑀺𑀢𑁆𑀢𑀬𑀻 𑀦𑁄, 𑀅𑀜𑁆𑀜𑀁 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫 [𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀢𑀤𑀺𑀗𑁆𑀖 𑀩𑁆𑀭𑀽𑀳𑀺;

𑀓𑀣𑀁 𑀦𑀼 𑀥𑀻𑀭𑀸 𑀯𑀺𑀢𑀭𑀦𑁆𑀢𑀺 𑀑𑀖𑀁, 𑀚𑀸𑀢𑀺𑀁 𑀚𑀭𑀁 𑀲𑁄𑀓𑀧𑀭𑀺𑀤𑁆𑀤𑀯𑀜𑁆𑀘;

𑀢𑀁 𑀫𑁂 𑀫𑀼𑀦𑀺 𑀲𑀸𑀥𑀼 𑀯𑀺𑀬𑀸𑀓𑀭𑁄𑀳𑀺, 𑀢𑀣𑀸 𑀳𑀺 𑀢𑁂 𑀯𑀺𑀤𑀺𑀢𑁄 𑀏𑀲 𑀥𑀫𑁆𑀫𑁄’’.

‘‘𑀓𑀺𑀢𑁆𑀢𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺 ¶ 𑀢𑁂 𑀥𑀫𑁆𑀫𑀁, (𑀫𑁂𑀢𑁆𑀢𑀕𑀽𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀬𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑁄 𑀘𑀭𑀁, 𑀢𑀭𑁂 𑀮𑁄𑀓𑁂 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀁’’.

‘‘𑀢𑀜𑁆𑀘𑀸𑀳𑀁 𑀅𑀪𑀺𑀦𑀦𑁆𑀤𑀸𑀫𑀺, 𑀫𑀳𑁂𑀲𑀺 𑀥𑀫𑁆𑀫𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀬𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑁄 𑀘𑀭𑀁, 𑀢𑀭𑁂 𑀮𑁄𑀓𑁂 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀁’’.

‘‘𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀲𑀫𑁆𑀧𑀚𑀸𑀦𑀸𑀲𑀺, (𑀫𑁂𑀢𑁆𑀢𑀕𑀽𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀉𑀤𑁆𑀥𑀁 𑀅𑀥𑁄 𑀢𑀺𑀭𑀺𑀬𑀜𑁆𑀘𑀸𑀧𑀺 𑀫𑀚𑁆𑀛𑁂;

𑀏𑀢𑁂𑀲𑀼 ¶ 𑀦𑀦𑁆𑀤𑀺𑀜𑁆𑀘 𑀦𑀺𑀯𑁂𑀲𑀦𑀜𑁆𑀘, 𑀧𑀦𑀼𑀚𑁆𑀚 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀁 𑀪𑀯𑁂 𑀦 𑀢𑀺𑀝𑁆𑀞𑁂.

‘‘𑀏𑀯𑀁𑀯𑀺𑀳𑀸𑀭𑀻 ¶ 𑀲𑀢𑁄 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀘𑀭𑀁 𑀳𑀺𑀢𑁆𑀯𑀸 𑀫𑀫𑀸𑀬𑀺𑀢𑀸𑀦𑀺;

𑀚𑀸𑀢𑀺𑀁 𑀚𑀭𑀁 𑀲𑁄𑀓𑀧𑀭𑀺𑀤𑁆𑀤𑀯𑀜𑁆𑀘, 𑀇𑀥𑁂𑀯 𑀯𑀺𑀤𑁆𑀯𑀸 𑀧𑀚𑀳𑁂𑀬𑁆𑀬 𑀤𑀼𑀓𑁆𑀔𑀁’’.

‘‘𑀏𑀢𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑀸𑀫𑀺 ¶ 𑀯𑀘𑁄 𑀫𑀳𑁂𑀲𑀺𑀦𑁄, 𑀲𑀼𑀓𑀺𑀢𑁆𑀢𑀺𑀢𑀁 𑀕𑁄𑀢𑀫𑀦𑀽𑀧𑀥𑀻𑀓𑀁;

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

‘‘𑀢𑁂 𑀘𑀸𑀧𑀺 𑀦𑀽𑀦𑀧𑁆𑀧𑀚𑀳𑁂𑀬𑁆𑀬𑀼 𑀤𑀼𑀓𑁆𑀔𑀁, 𑀬𑁂 𑀢𑁆𑀯𑀁 𑀫𑀼𑀦𑀺 𑀅𑀝𑁆𑀞𑀺𑀢𑀁 𑀑𑀯𑀤𑁂𑀬𑁆𑀬;

𑀢𑀁 𑀢𑀁 𑀦𑀫𑀲𑁆𑀲𑀸𑀫𑀺 𑀲𑀫𑁂𑀘𑁆𑀘 𑀦𑀸𑀕, 𑀅𑀧𑁆𑀧𑁂𑀯 𑀫𑀁 𑀪𑀕𑀯𑀸 𑀅𑀝𑁆𑀞𑀺𑀢𑀁 𑀑𑀯𑀤𑁂𑀬𑁆𑀬’’.

‘‘𑀬𑀁 ¶ 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀯𑁂𑀤𑀕𑀼𑀫𑀸𑀪𑀺𑀚𑀜𑁆𑀜𑀸, 𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀁 𑀓𑀸𑀫𑀪𑀯𑁂 𑀅𑀲𑀢𑁆𑀢𑀁;

𑀅𑀤𑁆𑀥𑀸 𑀳𑀺 𑀲𑁄 𑀑𑀖𑀫𑀺𑀫𑀁 𑀅𑀢𑀸𑀭𑀺, 𑀢𑀺𑀡𑁆𑀡𑁄 𑀘 𑀧𑀸𑀭𑀁 𑀅𑀔𑀺𑀮𑁄 𑀅𑀓𑀗𑁆𑀔𑁄.

‘‘𑀯𑀺𑀤𑁆𑀯𑀸 𑀘 𑀬𑁄 [𑀲𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀯𑁂𑀤𑀕𑀽 𑀦𑀭𑁄 𑀇𑀥, 𑀪𑀯𑀸𑀪𑀯𑁂 𑀲𑀗𑁆𑀕𑀫𑀺𑀫𑀁 𑀯𑀺𑀲𑀚𑁆𑀚;

𑀲𑁄 ¶ 𑀯𑀻𑀢𑀢𑀡𑁆𑀳𑁄 𑀅𑀦𑀻𑀖𑁄 𑀦𑀺𑀭𑀸𑀲𑁄, 𑀅𑀢𑀸𑀭𑀺 𑀲𑁄 𑀚𑀸𑀢𑀺𑀚𑀭𑀦𑁆𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀻’’𑀢𑀺.

𑀫𑁂𑀢𑁆𑀢𑀕𑀽𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀘𑀢𑀼𑀢𑁆𑀣𑀻 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀢𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀥𑁄𑀢𑀓𑁄)

𑀯𑀸𑀘𑀸𑀪𑀺𑀓𑀗𑁆𑀔𑀸𑀫𑀺 𑀫𑀳𑁂𑀲𑀺 𑀢𑀼𑀬𑁆𑀳𑀁;

𑀢𑀯 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑀁, 𑀲𑀺𑀓𑁆𑀔𑁂 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀫𑀢𑁆𑀢𑀦𑁄’’.

‘‘𑀢𑁂𑀦𑀳𑀸𑀢𑀧𑁆𑀧𑀁 𑀓𑀭𑁄𑀳𑀺, (𑀥𑁄𑀢𑀓𑀸𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀇𑀥𑁂𑀯 𑀦𑀺𑀧𑀓𑁄 𑀲𑀢𑁄;

𑀇𑀢𑁄 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑀁, 𑀲𑀺𑀓𑁆𑀔𑁂 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀫𑀢𑁆𑀢𑀦𑁄’’.

‘‘𑀧𑀲𑁆𑀲𑀸𑀫𑀳𑀁 ¶ 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂, 𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀺𑀭𑀺𑀬𑀫𑀸𑀦𑀁;

𑀢𑀁 𑀢𑀁 𑀦𑀫𑀲𑁆𑀲𑀸𑀫𑀺 𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼, 𑀧𑀫𑀼𑀜𑁆𑀘 ¶ 𑀫𑀁 𑀲𑀓𑁆𑀓 𑀓𑀣𑀁𑀓𑀣𑀸𑀳𑀺’’.

‘‘𑀦𑀸𑀳𑀁 ¶ 𑀲𑀳𑀺𑀲𑁆𑀲𑀸𑀫𑀺 [𑀲𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺 (𑀲𑁆𑀬𑀸.), 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺 (𑀲𑀻.), 𑀲𑀫𑀻𑀳𑀸𑀫𑀺 (𑀧𑀻.)] 𑀧𑀫𑁄𑀘𑀦𑀸𑀬, 𑀓𑀣𑀁𑀓𑀣𑀺𑀁 𑀥𑁄𑀢𑀓 𑀓𑀜𑁆𑀘𑀺 𑀮𑁄𑀓𑁂;

𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀲𑁂𑀝𑁆𑀞𑀁 𑀅𑀪𑀺𑀚𑀸𑀦𑀫𑀸𑀦𑁄 [𑀆𑀚𑀸𑀦𑀫𑀸𑀦𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀏𑀯𑀁 𑀢𑀼𑀯𑀁 𑀑𑀖𑀫𑀺𑀫𑀁 𑀢𑀭𑁂𑀲𑀺’’.

‘‘𑀅𑀦𑀼𑀲𑀸𑀲 𑀩𑁆𑀭𑀳𑁆𑀫𑁂 𑀓𑀭𑀼𑀡𑀸𑀬𑀫𑀸𑀦𑁄, 𑀯𑀺𑀯𑁂𑀓𑀥𑀫𑁆𑀫𑀁 𑀬𑀫𑀳𑀁 𑀯𑀺𑀚𑀜𑁆𑀜𑀁;

𑀬𑀣𑀸𑀳𑀁 ¶ 𑀆𑀓𑀸𑀲𑁄𑀯 𑀅𑀩𑁆𑀬𑀸𑀧𑀚𑁆𑀚𑀫𑀸𑀦𑁄, 𑀇𑀥𑁂𑀯 𑀲𑀦𑁆𑀢𑁄 𑀅𑀲𑀺𑀢𑁄 𑀘𑀭𑁂𑀬𑁆𑀬𑀁’’.

‘‘𑀓𑀺𑀢𑁆𑀢𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀢𑁂 𑀲𑀦𑁆𑀢𑀺𑀁, (𑀥𑁄𑀢𑀓𑀸𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀤𑀺𑀝𑁆𑀞𑁂 𑀥𑀫𑁆𑀫𑁂 𑀅𑀦𑀻𑀢𑀺𑀳𑀁;

𑀬𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑁄 𑀘𑀭𑀁, 𑀢𑀭𑁂 𑀮𑁄𑀓𑁂 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀁’’.

‘‘𑀢𑀜𑁆𑀘𑀸𑀳𑀁 𑀅𑀪𑀺𑀦𑀦𑁆𑀤𑀸𑀫𑀺, 𑀫𑀳𑁂𑀲𑀺 𑀲𑀦𑁆𑀢𑀺𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀬𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑁄 𑀘𑀭𑀁, 𑀢𑀭𑁂 𑀮𑁄𑀓𑁂 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀁’’.

‘‘𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀲𑀫𑁆𑀧𑀚𑀸𑀦𑀸𑀲𑀺, (𑀥𑁄𑀢𑀓𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀉𑀤𑁆𑀥𑀁 𑀅𑀥𑁄 𑀢𑀺𑀭𑀺𑀬𑀜𑁆𑀘𑀸𑀧𑀺 𑀫𑀚𑁆𑀛𑁂;

𑀏𑀢𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀲𑀗𑁆𑀕𑁄𑀢𑀺 𑀮𑁄𑀓𑁂, 𑀪𑀯𑀸𑀪𑀯𑀸𑀬 𑀫𑀸𑀓𑀸𑀲𑀺 𑀢𑀡𑁆𑀳’’𑀦𑁆𑀢𑀺.

𑀥𑁄𑀢𑀓𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀧𑀜𑁆𑀘𑀫𑀻 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀏𑀓𑁄 ¶ 𑀅𑀳𑀁 𑀲𑀓𑁆𑀓 𑀫𑀳𑀦𑁆𑀢𑀫𑁄𑀖𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀉𑀧𑀲𑀻𑀯𑁄)

𑀅𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀦𑁄 𑀯𑀺𑀲𑀳𑀸𑀫𑀺 𑀢𑀸𑀭𑀺𑀢𑀼𑀁;

𑀆𑀭𑀫𑁆𑀫𑀡𑀁 𑀩𑁆𑀭𑀽𑀳𑀺 𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼, 𑀬𑀁 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀑𑀖𑀫𑀺𑀫𑀁 𑀢𑀭𑁂𑀬𑁆𑀬𑀁’’.

‘‘𑀆𑀓𑀺𑀜𑁆𑀘𑀜𑁆𑀜𑀁 ¶ 𑀧𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑁄 𑀲𑀢𑀺𑀫𑀸, (𑀉𑀧𑀲𑀻𑀯𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀦𑀢𑁆𑀣𑀻𑀢𑀺 𑀦𑀺𑀲𑁆𑀲𑀸𑀬 𑀢𑀭𑀲𑁆𑀲𑀼 𑀑𑀖𑀁;

𑀓𑀸𑀫𑁂 ¶ 𑀧𑀳𑀸𑀬 𑀯𑀺𑀭𑀢𑁄 𑀓𑀣𑀸𑀳𑀺, 𑀢𑀡𑁆𑀳𑀓𑁆𑀔𑀬𑀁 𑀦𑀢𑁆𑀢𑀫𑀳𑀸𑀪𑀺𑀧𑀲𑁆𑀲’’ [𑀭𑀢𑁆𑀢𑀫𑀳𑀸𑀪𑀺𑀧𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸.), 𑀭𑀢𑁆𑀢𑀫𑀳𑀁 𑀯𑀺𑀧𑀲𑁆𑀲 (𑀓.)].

‘‘𑀲𑀩𑁆𑀩𑁂𑀲𑀼 ¶ 𑀓𑀸𑀫𑁂𑀲𑀼 𑀬𑁄 𑀯𑀻𑀢𑀭𑀸𑀕𑁄, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀉𑀧𑀲𑀻𑀯𑁄)

𑀆𑀓𑀺𑀜𑁆𑀘𑀜𑁆𑀜𑀁 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀳𑀺𑀢𑁆𑀯𑀸 𑀫𑀜𑁆𑀜𑀁;

𑀲𑀜𑁆𑀜𑀸𑀯𑀺𑀫𑁄𑀓𑁆𑀔𑁂 𑀧𑀭𑀫𑁂 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄 [𑀥𑀺𑀫𑀼𑀢𑁆𑀢𑁄 (𑀓.)], 𑀢𑀺𑀝𑁆𑀞𑁂 𑀦𑀼 𑀲𑁄 𑀢𑀢𑁆𑀣 𑀅𑀦𑀸𑀦𑀼𑀬𑀸𑀬𑀻’’ [𑀅𑀦𑀸𑀦𑀼𑀯𑀸𑀬𑀻 (𑀲𑁆𑀬𑀸. 𑀓.)].

‘‘𑀲𑀩𑁆𑀩𑁂𑀲𑀼 𑀓𑀸𑀫𑁂𑀲𑀼 𑀬𑁄 𑀯𑀻𑀢𑀭𑀸𑀕𑁄, (𑀉𑀧𑀲𑀻𑀯𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀆𑀓𑀺𑀜𑁆𑀘𑀜𑁆𑀜𑀁 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑁄 𑀳𑀺𑀢𑁆𑀯𑀸 𑀫𑀜𑁆𑀜𑀁;

𑀲𑀜𑁆𑀜𑀸𑀯𑀺𑀫𑁄𑀓𑁆𑀔𑁂 𑀧𑀭𑀫𑁂 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄, 𑀢𑀺𑀝𑁆𑀞𑁂𑀬𑁆𑀬 𑀲𑁄 𑀢𑀢𑁆𑀣 𑀅𑀦𑀸𑀦𑀼𑀬𑀸𑀬𑀻’’.

‘‘𑀢𑀺𑀝𑁆𑀞𑁂 𑀘𑁂 𑀲𑁄 𑀢𑀢𑁆𑀣 𑀅𑀦𑀸𑀦𑀼𑀬𑀸𑀬𑀻, 𑀧𑀽𑀕𑀫𑁆𑀧𑀺 ¶ 𑀯𑀲𑁆𑀲𑀸𑀦𑀁 𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼;

𑀢𑀢𑁆𑀣𑁂𑀯 𑀲𑁄 𑀲𑀻𑀢𑀺𑀲𑀺𑀬𑀸 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄, 𑀘𑀯𑁂𑀣 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀁 𑀢𑀣𑀸𑀯𑀺𑀥𑀲𑁆𑀲’’.

‘‘𑀅𑀘𑁆𑀘𑀻 𑀬𑀣𑀸 𑀯𑀸𑀢𑀯𑁂𑀕𑁂𑀦 𑀔𑀺𑀢𑁆𑀢𑀸 [𑀔𑀺𑀢𑁆𑀢𑀁 (𑀲𑁆𑀬𑀸.), 𑀔𑀺𑀢𑁆𑀢𑁄 (𑀧𑀻.)], (𑀉𑀧𑀲𑀻𑀯𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀅𑀢𑁆𑀣𑀁 𑀧𑀮𑁂𑀢𑀺 𑀦 𑀉𑀧𑁂𑀢𑀺 𑀲𑀗𑁆𑀔𑀁;

𑀏𑀯𑀁 ¶ 𑀫𑀼𑀦𑀻 𑀦𑀸𑀫𑀓𑀸𑀬𑀸 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄, 𑀅𑀢𑁆𑀣𑀁 𑀧𑀮𑁂𑀢𑀺 𑀦 𑀉𑀧𑁂𑀢𑀺 𑀲𑀗𑁆𑀔𑀁’’.

‘‘𑀅𑀢𑁆𑀣𑀗𑁆𑀕𑀢𑁄 𑀲𑁄 𑀉𑀤 𑀯𑀸 𑀲𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀉𑀤𑀸𑀳𑀼 𑀯𑁂 𑀲𑀲𑁆𑀲𑀢𑀺𑀬𑀸 𑀅𑀭𑁄𑀕𑁄;

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

‘‘𑀅𑀢𑁆𑀣𑀗𑁆𑀕𑀢𑀲𑁆𑀲 ¶ 𑀦 𑀧𑀫𑀸𑀡𑀫𑀢𑁆𑀣𑀺, (𑀉𑀧𑀲𑀻𑀯𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀬𑁂𑀦 𑀦𑀁 𑀯𑀚𑁆𑀚𑀼𑀁 𑀢𑀁 𑀢𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺;

𑀲𑀩𑁆𑀩𑁂𑀲𑀼 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀲𑀫𑀽𑀳𑀢𑁂𑀲𑀼, 𑀲𑀫𑀽𑀳𑀢𑀸 𑀯𑀸𑀤𑀧𑀣𑀸𑀧𑀺 𑀲𑀩𑁆𑀩𑁂’’𑀢𑀺.

𑀉𑀧𑀲𑀻𑀯𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀙𑀝𑁆𑀞𑀻 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀲𑀦𑁆𑀢𑀺 ¶ 𑀮𑁄𑀓𑁂 𑀫𑀼𑀦𑀬𑁄, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀦𑀦𑁆𑀤𑁄)

𑀚𑀦𑀸 𑀯𑀤𑀦𑁆𑀢𑀺 𑀢𑀬𑀺𑀤𑀁 𑀓𑀣𑀁𑀲𑀼;

𑀜𑀸𑀡𑀽𑀧𑀧𑀦𑁆𑀦𑀁 ¶ 𑀦𑁄 𑀫𑀼𑀦𑀺𑀁 [𑀫𑀼𑀦𑀺 𑀦𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀤𑀦𑁆𑀢𑀺, 𑀉𑀤𑀸𑀳𑀼 𑀯𑁂 𑀚𑀻𑀯𑀺𑀢𑁂𑀦𑀽𑀧𑀧𑀦𑁆𑀦𑀁’’.

‘‘𑀦 𑀤𑀺𑀝𑁆𑀞𑀺𑀬𑀸 𑀦 𑀲𑀼𑀢𑀺𑀬𑀸 𑀦 𑀜𑀸𑀡𑁂𑀦, (𑀦 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑁂𑀦) [( ) 𑀦𑀢𑁆𑀣𑀺 𑀲𑀻.-𑀧𑀻 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼]

𑀫𑀼𑀦𑀻𑀥 𑀦𑀦𑁆𑀤 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀦𑁆𑀢𑀺;

𑀯𑀺𑀲𑁂𑀦𑀺𑀓𑀢𑁆𑀯𑀸 ¶ 𑀅𑀦𑀻𑀖𑀸 𑀦𑀺𑀭𑀸𑀲𑀸, 𑀘𑀭𑀦𑁆𑀢𑀺 𑀬𑁂 𑀢𑁂 𑀫𑀼𑀦𑀬𑁄𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀺’’.

‘‘𑀬𑁂 𑀓𑁂𑀘𑀺𑀫𑁂 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀲𑁂, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀦𑀦𑁆𑀤𑁄)

𑀤𑀺𑀝𑁆𑀞𑀲𑁆𑀲𑀼𑀢𑁂𑀦𑀸𑀧𑀺 [𑀤𑀺𑀝𑁆𑀞𑁂𑀦 𑀲𑀼𑀢𑁂𑀦𑀸𑀧𑀺 (𑀲𑀻.), 𑀤𑀺𑀝𑁆𑀞𑁂 𑀲𑀼𑀢𑁂𑀦𑀸𑀧𑀺 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)] 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁;

𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑁂𑀦𑀸𑀧𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁, 𑀅𑀦𑁂𑀓𑀭𑀽𑀧𑁂𑀦 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁;

𑀓𑀘𑁆𑀘𑀺𑀲𑁆𑀲𑀼 𑀢𑁂 𑀪𑀕𑀯𑀸 𑀢𑀢𑁆𑀣 𑀬𑀢𑀸 𑀘𑀭𑀦𑁆𑀢𑀸, 𑀅𑀢𑀸𑀭𑀼 𑀚𑀸𑀢𑀺𑀜𑁆𑀘 𑀚𑀭𑀜𑁆𑀘 𑀫𑀸𑀭𑀺𑀲;

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀢𑀁’’.

‘‘𑀬𑁂 ¶ 𑀓𑁂𑀘𑀺𑀫𑁂 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀲𑁂, (𑀦𑀦𑁆𑀤𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀤𑀺𑀝𑁆𑀞𑀲𑁆𑀲𑀼𑀢𑁂𑀦𑀸𑀧𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁;

𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑁂𑀦𑀸𑀧𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁, 𑀅𑀦𑁂𑀓𑀭𑀽𑀧𑁂𑀦 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁;

𑀓𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀢𑁂 𑀢𑀢𑁆𑀣 𑀬𑀢𑀸 𑀘𑀭𑀦𑁆𑀢𑀺, 𑀦𑀸𑀭𑀺𑀁𑀲𑀼 𑀚𑀸𑀢𑀺𑀚𑀭𑀦𑁆𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀺’’.

‘‘𑀬𑁂 ¶ 𑀓𑁂𑀘𑀺𑀫𑁂 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀲𑁂, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀦𑀦𑁆𑀤𑁄)

𑀤𑀺𑀝𑁆𑀞𑀲𑁆𑀲𑀼𑀢𑁂𑀦𑀸𑀧𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁;

𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑁂𑀦𑀸𑀧𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁, 𑀅𑀦𑁂𑀓𑀭𑀽𑀧𑁂𑀦 𑀯𑀤𑀦𑁆𑀢𑀺 𑀲𑀼𑀤𑁆𑀥𑀺𑀁;

𑀢𑁂 𑀘𑁂 𑀫𑀼𑀦𑀺 [𑀲𑀘𑁂 𑀫𑀼𑀦𑀺 (𑀲𑀻.)] 𑀩𑁆𑀭𑀽𑀲𑀺 𑀅𑀦𑁄𑀖𑀢𑀺𑀡𑁆𑀡𑁂, 𑀅𑀣 ¶ 𑀓𑁄 𑀘𑀭𑀳𑀺 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂;

𑀅𑀢𑀸𑀭𑀺 𑀚𑀸𑀢𑀺𑀜𑁆𑀘 𑀚𑀭𑀜𑁆𑀘 𑀫𑀸𑀭𑀺𑀲, 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀢𑀁’’.

‘‘𑀦𑀸𑀳𑀁 𑀲𑀩𑁆𑀩𑁂 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀲𑁂, (𑀦𑀦𑁆𑀤𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀚𑀸𑀢𑀺𑀚𑀭𑀸𑀬 𑀦𑀺𑀯𑀼𑀢𑀸𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀺;

𑀬𑁂 ¶ 𑀲𑀻𑀥 𑀤𑀺𑀝𑁆𑀞𑀁𑀯 𑀲𑀼𑀢𑀁 𑀫𑀼𑀢𑀁 𑀯𑀸, 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑀁 𑀯𑀸𑀧𑀺 𑀧𑀳𑀸𑀬 𑀲𑀩𑁆𑀩𑀁;

𑀅𑀦𑁂𑀓𑀭𑀽𑀧𑀫𑁆𑀧𑀺 𑀧𑀳𑀸𑀬 𑀲𑀩𑁆𑀩𑀁, 𑀢𑀡𑁆𑀳𑀁 𑀧𑀭𑀺𑀜𑁆𑀜𑀸𑀬 𑀅𑀦𑀸𑀲𑀯𑀸𑀲𑁂;

𑀢𑁂 𑀯𑁂 𑀦𑀭𑀸 𑀑𑀖𑀢𑀺𑀡𑁆𑀡𑀸𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀺’’.

‘‘𑀏𑀢𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑀸𑀫𑀺 𑀯𑀘𑁄 𑀫𑀳𑁂𑀲𑀺𑀦𑁄, 𑀲𑀼𑀓𑀺𑀢𑁆𑀢𑀺𑀢𑀁 𑀕𑁄𑀢𑀫𑀦𑀽𑀧𑀥𑀻𑀓𑀁;

𑀬𑁂 𑀲𑀻𑀥 𑀤𑀺𑀝𑁆𑀞𑀁 𑀯 𑀲𑀼𑀢𑀁 𑀫𑀼𑀢𑀁 𑀯𑀸, 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑀁 𑀯𑀸𑀧𑀺 𑀧𑀳𑀸𑀬 𑀲𑀩𑁆𑀩𑀁;

𑀅𑀦𑁂𑀓𑀭𑀽𑀧𑀫𑁆𑀧𑀺 ¶ 𑀧𑀳𑀸𑀬 𑀲𑀩𑁆𑀩𑀁, 𑀢𑀡𑁆𑀳𑀁 𑀧𑀭𑀺𑀜𑁆𑀜𑀸𑀬 𑀅𑀦𑀸𑀲𑀯𑀸𑀲𑁂;

𑀅𑀳𑀫𑁆𑀧𑀺 𑀢𑁂 𑀑𑀖𑀢𑀺𑀡𑁆𑀡𑀸𑀢𑀺 𑀩𑁆𑀭𑀽𑀫𑀻’’𑀢𑀺.

𑀦𑀦𑁆𑀤𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀲𑀢𑁆𑀢𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀬𑁂 ¶ 𑀫𑁂 𑀧𑀼𑀩𑁆𑀩𑁂 𑀯𑀺𑀬𑀸𑀓𑀁𑀲𑀼, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀳𑁂𑀫𑀓𑁄)

𑀇𑀘𑁆𑀘𑀸𑀲𑀺 𑀇𑀢𑀺 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺, 𑀲𑀩𑁆𑀩𑀁 𑀢𑀁 𑀇𑀢𑀺𑀳𑀻𑀢𑀺𑀳𑀁;

𑀲𑀩𑁆𑀩𑀁 𑀢𑀁 𑀢𑀓𑁆𑀓𑀯𑀟𑁆𑀠𑀦𑀁, 𑀦𑀸𑀳𑀁 𑀢𑀢𑁆𑀣 𑀅𑀪𑀺𑀭𑀫𑀺𑀁.

‘‘𑀢𑁆𑀯𑀜𑁆𑀘 𑀫𑁂 𑀥𑀫𑁆𑀫𑀫𑀓𑁆𑀔𑀸𑀳𑀺, 𑀢𑀡𑁆𑀳𑀸𑀦𑀺𑀕𑁆𑀖𑀸𑀢𑀦𑀁 𑀫𑀼𑀦𑀺;

𑀬𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑁄 𑀘𑀭𑀁, 𑀢𑀭𑁂 𑀮𑁄𑀓𑁂 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓𑀁’’.

‘‘𑀇𑀥 𑀤𑀺𑀝𑁆𑀞𑀲𑀼𑀢𑀫𑀼𑀢𑀯𑀺𑀜𑁆𑀜𑀸𑀢𑁂𑀲𑀼, 𑀧𑀺𑀬𑀭𑀽𑀧𑁂𑀲𑀼 𑀳𑁂𑀫𑀓;

𑀙𑀦𑁆𑀤𑀭𑀸𑀕𑀯𑀺𑀦𑁄𑀤𑀦𑀁, 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀧𑀤𑀫𑀘𑁆𑀘𑀼𑀢𑀁.

‘‘𑀏𑀢𑀤𑀜𑁆𑀜𑀸𑀬 𑀬𑁂 𑀲𑀢𑀸, 𑀤𑀺𑀝𑁆𑀞𑀥𑀫𑁆𑀫𑀸𑀪𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀸;

𑀉𑀧𑀲𑀦𑁆𑀢𑀸 𑀘 𑀢𑁂 𑀲𑀤𑀸, 𑀢𑀺𑀡𑁆𑀡𑀸 𑀮𑁄𑀓𑁂 𑀯𑀺𑀲𑀢𑁆𑀢𑀺𑀓’’𑀦𑁆𑀢𑀺.

𑀳𑁂𑀫𑀓𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀅𑀝𑁆𑀞𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀬𑀲𑁆𑀫𑀺𑀁 ¶ ¶ 𑀓𑀸𑀫𑀸 𑀦 𑀯𑀲𑀦𑁆𑀢𑀺, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀢𑁄𑀤𑁂𑀬𑁆𑀬𑁄)

𑀓𑀣𑀁𑀓𑀣𑀸 𑀘 𑀬𑁄 𑀢𑀺𑀡𑁆𑀡𑁄, 𑀯𑀺𑀫𑁄𑀓𑁆𑀔𑁄 𑀢𑀲𑁆𑀲 𑀓𑀻𑀤𑀺𑀲𑁄’’.

‘‘𑀬𑀲𑁆𑀫𑀺𑀁 ¶ 𑀓𑀸𑀫𑀸 𑀦 𑀯𑀲𑀦𑁆𑀢𑀺, (𑀢𑁄𑀤𑁂𑀬𑁆𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀓𑀣𑀁𑀓𑀣𑀸 𑀘 𑀬𑁄 𑀢𑀺𑀡𑁆𑀡𑁄, 𑀯𑀺𑀫𑁄𑀓𑁆𑀔𑁄 𑀢𑀲𑁆𑀲 𑀦𑀸𑀧𑀭𑁄’’.

‘‘𑀦𑀺𑀭𑀸𑀲𑀲𑁄 𑀲𑁄 𑀉𑀤 𑀆𑀲𑀲𑀸𑀦𑁄, 𑀧𑀜𑁆𑀜𑀸𑀡𑀯𑀸 𑀲𑁄 𑀉𑀤 𑀧𑀜𑁆𑀜𑀓𑀧𑁆𑀧𑀻;

𑀫𑀼𑀦𑀺𑀁 𑀅𑀳𑀁 𑀲𑀓𑁆𑀓 𑀬𑀣𑀸 𑀯𑀺𑀚𑀜𑁆𑀜𑀁, 𑀢𑀁 𑀫𑁂 𑀯𑀺𑀬𑀸𑀘𑀺𑀓𑁆𑀔 𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼’’.

‘‘𑀦𑀺𑀭𑀸𑀲𑀲𑁄 ¶ 𑀲𑁄 𑀦 𑀘 𑀆𑀲𑀲𑀸𑀦𑁄, 𑀧𑀜𑁆𑀜𑀸𑀡𑀯𑀸 𑀲𑁄 𑀦 𑀘 𑀧𑀜𑁆𑀜𑀓𑀧𑁆𑀧𑀻;

𑀏𑀯𑀫𑁆𑀧𑀺 𑀢𑁄𑀤𑁂𑀬𑁆𑀬 𑀫𑀼𑀦𑀺𑀁 𑀯𑀺𑀚𑀸𑀦, 𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀁 𑀓𑀸𑀫𑀪𑀯𑁂 𑀅𑀲𑀢𑁆𑀢’’𑀦𑁆𑀢𑀺.

𑀢𑁄𑀤𑁂𑀬𑁆𑀬𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀦𑀯𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀫𑀚𑁆𑀛𑁂 ¶ 𑀲𑀭𑀲𑁆𑀫𑀺𑀁 𑀢𑀺𑀝𑁆𑀞𑀢𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀓𑀧𑁆𑀧𑁄)

𑀚𑀭𑀸𑀫𑀘𑁆𑀘𑀼𑀧𑀭𑁂𑀢𑀸𑀦𑀁, 𑀤𑀻𑀧𑀁 𑀧𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑀸𑀭𑀺𑀲;

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

‘‘𑀫𑀚𑁆𑀛𑁂 ¶ ¶ 𑀲𑀭𑀲𑁆𑀫𑀺𑀁 𑀢𑀺𑀝𑁆𑀞𑀢𑀁, (𑀓𑀧𑁆𑀧𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀚𑀭𑀸𑀫𑀘𑁆𑀘𑀼𑀧𑀭𑁂𑀢𑀸𑀦𑀁, 𑀤𑀻𑀧𑀁 𑀧𑀩𑁆𑀭𑀽𑀫𑀺 𑀓𑀧𑁆𑀧 𑀢𑁂.

‘‘𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑀁 𑀅𑀦𑀸𑀤𑀸𑀦𑀁, 𑀏𑀢𑀁 𑀤𑀻𑀧𑀁 𑀅𑀦𑀸𑀧𑀭𑀁;

𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀁 𑀇𑀢𑀺 [𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀫𑀻𑀢𑀺 (𑀲𑀻.)] 𑀦𑀁 𑀩𑁆𑀭𑀽𑀫𑀺, 𑀚𑀭𑀸𑀫𑀘𑁆𑀘𑀼𑀧𑀭𑀺𑀓𑁆𑀔𑀬𑀁.

‘‘𑀏𑀢𑀤𑀜𑁆𑀜𑀸𑀬 𑀬𑁂 𑀲𑀢𑀸, 𑀤𑀺𑀝𑁆𑀞𑀥𑀫𑁆𑀫𑀸𑀪𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀸;

𑀦 𑀢𑁂 𑀫𑀸𑀭𑀯𑀲𑀸𑀦𑀼𑀕𑀸, 𑀦 𑀢𑁂 𑀫𑀸𑀭𑀲𑁆𑀲 𑀧𑀤𑁆𑀥𑀕𑀽’’𑀢𑀺 [𑀧𑀝𑁆𑀞𑀕𑀽𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑀓𑀧𑁆𑀧𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀤𑀲𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

𑁧𑁧. 𑀚𑀢𑀼𑀓𑀡𑁆𑀡𑀺𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸

‘‘𑀲𑀼𑀢𑁆𑀯𑀸𑀦𑀳𑀁 𑀯𑀻𑀭𑀫𑀓𑀸𑀫𑀓𑀸𑀫𑀺𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀚𑀢𑀼𑀓𑀡𑁆𑀡𑀺)

𑀑𑀖𑀸𑀢𑀺𑀕𑀁 𑀧𑀼𑀝𑁆𑀞𑀼𑀫𑀓𑀸𑀫𑀫𑀸𑀕𑀫𑀁;

𑀲𑀦𑁆𑀢𑀺𑀧𑀤𑀁 𑀩𑁆𑀭𑀽𑀳𑀺 𑀲𑀳𑀚𑀦𑁂𑀢𑁆𑀢, 𑀬𑀣𑀸𑀢𑀘𑁆𑀙𑀁 ¶ 𑀪𑀕𑀯𑀸 𑀩𑁆𑀭𑀽𑀳𑀺 𑀫𑁂 𑀢𑀁.

‘‘𑀪𑀕𑀯𑀸 ¶ 𑀳𑀺 𑀓𑀸𑀫𑁂 𑀅𑀪𑀺𑀪𑀼𑀬𑁆𑀬 𑀇𑀭𑀺𑀬𑀢𑀺, 𑀆𑀤𑀺𑀘𑁆𑀘𑁄𑀯 𑀧𑀣𑀯𑀺𑀁 𑀢𑁂𑀚𑀻 𑀢𑁂𑀚𑀲𑀸;

𑀧𑀭𑀺𑀢𑁆𑀢𑀧𑀜𑁆𑀜𑀲𑁆𑀲 𑀫𑁂 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜, 𑀆𑀘𑀺𑀓𑁆𑀔 𑀥𑀫𑁆𑀫𑀁 𑀬𑀫𑀳𑀁 𑀯𑀺𑀚𑀜𑁆𑀜𑀁;

𑀚𑀸𑀢𑀺𑀚𑀭𑀸𑀬 𑀇𑀥 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀦𑀁’’.

‘‘𑀓𑀸𑀫𑁂𑀲𑀼 ¶ 𑀯𑀺𑀦𑀬 𑀕𑁂𑀥𑀁, (𑀚𑀢𑀼𑀓𑀡𑁆𑀡𑀻𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀦𑁂𑀓𑁆𑀔𑀫𑁆𑀫𑀁 𑀤𑀝𑁆𑀞𑀼 𑀔𑁂𑀫𑀢𑁄;

𑀉𑀕𑁆𑀕𑀳𑀻𑀢𑀁 𑀦𑀺𑀭𑀢𑁆𑀢𑀁 𑀯𑀸, 𑀫𑀸 𑀢𑁂 𑀯𑀺𑀚𑁆𑀚𑀺𑀢𑁆𑀣 𑀓𑀺𑀜𑁆𑀘𑀦𑀁.

‘‘𑀬𑀁 𑀧𑀼𑀩𑁆𑀩𑁂 𑀢𑀁 𑀯𑀺𑀲𑁄𑀲𑁂𑀳𑀺, 𑀧𑀘𑁆𑀙𑀸 𑀢𑁂 𑀫𑀸𑀳𑀼 𑀓𑀺𑀜𑁆𑀘𑀦𑀁;

𑀫𑀚𑁆𑀛𑁂 𑀘𑁂 𑀦𑁄 𑀕𑀳𑁂𑀲𑁆𑀲𑀲𑀺, 𑀉𑀧𑀲𑀦𑁆𑀢𑁄 𑀘𑀭𑀺𑀲𑁆𑀲𑀲𑀺.

‘‘𑀲𑀩𑁆𑀩𑀲𑁄 ¶ 𑀦𑀸𑀫𑀭𑀽𑀧𑀲𑁆𑀫𑀺𑀁, 𑀯𑀻𑀢𑀕𑁂𑀥𑀲𑁆𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡;

𑀆𑀲𑀯𑀸𑀲𑁆𑀲 𑀦 𑀯𑀺𑀚𑁆𑀚𑀦𑁆𑀢𑀺, 𑀬𑁂𑀳𑀺 𑀫𑀘𑁆𑀘𑀼𑀯𑀲𑀁 𑀯𑀚𑁂’’𑀢𑀺.

𑀚𑀢𑀼𑀓𑀡𑁆𑀡𑀺𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀏𑀓𑀸𑀤𑀲𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

𑁧𑁨. 𑀪𑀤𑁆𑀭𑀸𑀯𑀼𑀥𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸

‘‘𑀑𑀓𑀜𑁆𑀚𑀳𑀁 𑀢𑀡𑁆𑀳𑀘𑁆𑀙𑀺𑀤𑀁 𑀅𑀦𑁂𑀚𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀪𑀤𑁆𑀭𑀸𑀯𑀼𑀥𑁄)

𑀦𑀦𑁆𑀤𑀺𑀜𑁆𑀚𑀳𑀁 𑀑𑀖𑀢𑀺𑀡𑁆𑀡𑀁 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀁;

𑀓𑀧𑁆𑀧𑀜𑁆𑀚𑀳𑀁 𑀅𑀪𑀺𑀬𑀸𑀘𑁂 𑀲𑀼𑀫𑁂𑀥𑀁, 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 ¶ 𑀦𑀸𑀕𑀲𑁆𑀲 𑀅𑀧𑀦𑀫𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀇𑀢𑁄.

‘‘𑀦𑀸𑀦𑀸𑀚𑀦𑀸 𑀚𑀦𑀧𑀤𑁂𑀳𑀺 𑀲𑀗𑁆𑀕𑀢𑀸, 𑀢𑀯 𑀯𑀻𑀭 𑀯𑀸𑀓𑁆𑀬𑀁 𑀅𑀪𑀺𑀓𑀗𑁆𑀔𑀫𑀸𑀦𑀸;

𑀢𑁂𑀲𑀁 𑀢𑀼𑀯𑀁 𑀲𑀸𑀥𑀼 𑀯𑀺𑀬𑀸𑀓𑀭𑁄𑀳𑀺, 𑀢𑀣𑀸 𑀳𑀺 𑀢𑁂 𑀯𑀺𑀤𑀺𑀢𑁄 𑀏𑀲 𑀥𑀫𑁆𑀫𑁄’’.

‘‘𑀆𑀤𑀸𑀦𑀢𑀡𑁆𑀳𑀁 𑀯𑀺𑀦𑀬𑁂𑀣 𑀲𑀩𑁆𑀩𑀁, (𑀪𑀤𑁆𑀭𑀸𑀯𑀼𑀥𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀉𑀤𑁆𑀥𑀁 𑀅𑀥𑁄 𑀢𑀺𑀭𑀺𑀬𑀜𑁆𑀘𑀸𑀧𑀺 𑀫𑀚𑁆𑀛𑁂;

𑀬𑀁 ¶ 𑀬𑀜𑁆𑀳𑀺 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀫𑀼𑀧𑀸𑀤𑀺𑀬𑀦𑁆𑀢𑀺, 𑀢𑁂𑀦𑁂𑀯 𑀫𑀸𑀭𑁄 𑀅𑀦𑁆𑀯𑁂𑀢𑀺 𑀚𑀦𑁆𑀢𑀼𑀁.

‘‘𑀢𑀲𑁆𑀫𑀸 ¶ 𑀧𑀚𑀸𑀦𑀁 𑀦 𑀉𑀧𑀸𑀤𑀺𑀬𑁂𑀣, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀲𑀢𑁄 𑀓𑀺𑀜𑁆𑀘𑀦𑀁 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑁂;

𑀆𑀤𑀸𑀦𑀲𑀢𑁆𑀢𑁂 𑀇𑀢𑀺 𑀧𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑁄, 𑀧𑀚𑀁 𑀇𑀫𑀁 𑀫𑀘𑁆𑀘𑀼𑀥𑁂𑀬𑁆𑀬𑁂 𑀯𑀺𑀲𑀢𑁆𑀢’’𑀦𑁆𑀢𑀺.

𑀪𑀤𑁆𑀭𑀸𑀯𑀼𑀥𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀛𑀸𑀬𑀺𑀁 ¶ 𑀯𑀺𑀭𑀚𑀫𑀸𑀲𑀻𑀦𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀉𑀤𑀬𑁄) 𑀓𑀢𑀓𑀺𑀘𑁆𑀘𑀁 𑀅𑀦𑀸𑀲𑀯𑀁;

𑀧𑀸𑀭𑀕𑀼𑀁 𑀲𑀩𑁆𑀩𑀥𑀫𑁆𑀫𑀸𑀦𑀁, 𑀅𑀢𑁆𑀣𑀺 𑀧𑀜𑁆𑀳𑁂𑀦 𑀆𑀕𑀫𑀁;

𑀅𑀜𑁆𑀜𑀸𑀯𑀺𑀫𑁄𑀓𑁆𑀔𑀁 𑀧𑀩𑁆𑀭𑀽𑀳𑀺, 𑀅𑀯𑀺𑀚𑁆𑀚𑀸𑀬 𑀧𑀪𑁂𑀤𑀦𑀁’’.

‘‘𑀧𑀳𑀸𑀦𑀁 ¶ 𑀓𑀸𑀫𑀘𑁆𑀙𑀦𑁆𑀤𑀸𑀦𑀁, (𑀉𑀤𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀤𑁄𑀫𑀦𑀲𑁆𑀲𑀸𑀦 𑀘𑀽𑀪𑀬𑀁;

𑀣𑀺𑀦𑀲𑁆𑀲 𑀘 𑀧𑀦𑀽𑀤𑀦𑀁, 𑀓𑀼𑀓𑁆𑀓𑀼𑀘𑁆𑀘𑀸𑀦𑀁 𑀦𑀺𑀯𑀸𑀭𑀡𑀁.

‘‘𑀉𑀧𑁂𑀓𑁆𑀔𑀸𑀲𑀢𑀺𑀲𑀁𑀲𑀼𑀤𑁆𑀥𑀁, 𑀥𑀫𑁆𑀫𑀢𑀓𑁆𑀓𑀧𑀼𑀭𑁂𑀚𑀯𑀁;

𑀅𑀜𑁆𑀜𑀸𑀯𑀺𑀫𑁄𑀓𑁆𑀔𑀁 𑀧𑀩𑁆𑀭𑀽𑀫𑀺, 𑀅𑀯𑀺𑀚𑁆𑀚𑀸𑀬 𑀧𑀪𑁂𑀤𑀦𑀁’’.

‘‘𑀓𑀺𑀁𑀲𑀼 ¶ 𑀲𑀁𑀬𑁄𑀚𑀦𑁄 𑀮𑁄𑀓𑁄, 𑀓𑀺𑀁𑀲𑀼 𑀢𑀲𑁆𑀲 𑀯𑀺𑀘𑀸𑀭𑀡𑀁;

𑀓𑀺𑀲𑁆𑀲𑀲𑁆𑀲 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀦𑁂𑀦, 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀁 𑀇𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀺’’.

‘‘𑀦𑀦𑁆𑀤𑀺𑀲𑀁𑀬𑁄𑀚𑀦𑁄 𑀮𑁄𑀓𑁄, 𑀯𑀺𑀢𑀓𑁆𑀓𑀲𑁆𑀲 𑀯𑀺𑀘𑀸𑀭𑀡𑀁;

𑀢𑀡𑁆𑀳𑀸𑀬 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀦𑁂𑀦, 𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀁 𑀇𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀺’’.

‘‘𑀓𑀣𑀁 𑀲𑀢𑀲𑁆𑀲 𑀘𑀭𑀢𑁄, 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀁 𑀉𑀧𑀭𑀼𑀚𑁆𑀛𑀢𑀺;

𑀪𑀕𑀯𑀦𑁆𑀢𑀁 𑀧𑀼𑀝𑁆𑀞𑀼𑀫𑀸𑀕𑀫𑁆𑀫, 𑀢𑀁 𑀲𑀼𑀡𑁄𑀫 𑀯𑀘𑁄 𑀢𑀯’’.

‘‘𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀜𑁆𑀘 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘, 𑀯𑁂𑀤𑀦𑀁 𑀦𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑀢𑁄;

𑀏𑀯𑀁 𑀲𑀢𑀲𑁆𑀲 𑀘𑀭𑀢𑁄, 𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀁 𑀉𑀧𑀭𑀼𑀚𑁆𑀛𑀢𑀻’’𑀢𑀺.

𑀉𑀤𑀬𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀢𑁂𑀭𑀲𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀬𑁄 ¶ ¶ 𑀅𑀢𑀻𑀢𑀁 𑀆𑀤𑀺𑀲𑀢𑀺, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀧𑁄𑀲𑀸𑀮𑁄) 𑀅𑀦𑁂𑀚𑁄 𑀙𑀺𑀦𑁆𑀦𑀲𑀁𑀲𑀬𑁄;

𑀧𑀸𑀭𑀕𑀼𑀁 𑀲𑀩𑁆𑀩𑀥𑀫𑁆𑀫𑀸𑀦𑀁, 𑀅𑀢𑁆𑀣𑀺 𑀧𑀜𑁆𑀳𑁂𑀦 𑀆𑀕𑀫𑀁.

‘‘𑀯𑀺𑀪𑀽𑀢𑀭𑀽𑀧𑀲𑀜𑁆𑀜𑀺𑀲𑁆𑀲 ¶ , 𑀲𑀩𑁆𑀩𑀓𑀸𑀬𑀧𑁆𑀧𑀳𑀸𑀬𑀺𑀦𑁄;

𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀜𑁆𑀘 𑀩𑀳𑀺𑀤𑁆𑀥𑀸 𑀘, 𑀦𑀢𑁆𑀣𑀺 𑀓𑀺𑀜𑁆𑀘𑀻𑀢𑀺 𑀧𑀲𑁆𑀲𑀢𑁄;

𑀜𑀸𑀡𑀁 𑀲𑀓𑁆𑀓𑀸𑀦𑀼𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺, 𑀓𑀣𑀁 𑀦𑁂𑀬𑁆𑀬𑁄 𑀢𑀣𑀸𑀯𑀺𑀥𑁄’’.

‘‘𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀝𑁆𑀞𑀺𑀢𑀺𑀬𑁄 ¶ 𑀲𑀩𑁆𑀩𑀸, (𑀧𑁄𑀲𑀸𑀮𑀸𑀢𑀺 𑀪𑀕𑀯𑀸) 𑀅𑀪𑀺𑀚𑀸𑀦𑀁 𑀢𑀣𑀸𑀕𑀢𑁄;

𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀫𑁂𑀦𑀁 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑀁 𑀢𑀧𑁆𑀧𑀭𑀸𑀬𑀡𑀁.

‘‘𑀆𑀓𑀺𑀜𑁆𑀘𑀜𑁆𑀜𑀲𑀫𑁆𑀪𑀯𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀦𑀦𑁆𑀤𑀻 𑀲𑀁𑀬𑁄𑀚𑀦𑀁 𑀇𑀢𑀺;

𑀏𑀯𑀫𑁂𑀢𑀁 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀬, 𑀢𑀢𑁄 𑀢𑀢𑁆𑀣 𑀯𑀺𑀧𑀲𑁆𑀲𑀢𑀺;

𑀏𑀢𑀁 [𑀏𑀯𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀜𑀸𑀡𑀁 𑀢𑀣𑀁 𑀢𑀲𑁆𑀲, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀯𑀼𑀲𑀻𑀫𑀢𑁄’’𑀢𑀺.

𑀧𑁄𑀲𑀸𑀮𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀘𑀼𑀤𑁆𑀤𑀲𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀤𑁆𑀯𑀸𑀳𑀁 𑀲𑀓𑁆𑀓𑀁 𑀅𑀧𑀼𑀘𑁆𑀙𑀺𑀲𑁆𑀲𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀫𑁄𑀖𑀭𑀸𑀚𑀸)

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

‘‘𑀅𑀬𑀁 𑀮𑁄𑀓𑁄 𑀧𑀭𑁄 𑀮𑁄𑀓𑁄, 𑀩𑁆𑀭𑀳𑁆𑀫𑀮𑁄𑀓𑁄 𑀲𑀤𑁂𑀯𑀓𑁄;

𑀤𑀺𑀝𑁆𑀞𑀺𑀁 𑀢𑁂 𑀦𑀸𑀪𑀺𑀚𑀸𑀦𑀸𑀢𑀺, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

‘‘𑀏𑀯𑀁 ¶ ¶ ¶ 𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀤𑀲𑁆𑀲𑀸𑀯𑀺𑀁, 𑀅𑀢𑁆𑀣𑀺 𑀧𑀜𑁆𑀳𑁂𑀦 𑀆𑀕𑀫𑀁;

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

‘‘𑀲𑀼𑀜𑁆𑀜𑀢𑁄 ¶ 𑀮𑁄𑀓𑀁 𑀅𑀯𑁂𑀓𑁆𑀔𑀲𑁆𑀲𑀼, 𑀫𑁄𑀖𑀭𑀸𑀚 𑀲𑀤𑀸 𑀲𑀢𑁄;

𑀅𑀢𑁆𑀢𑀸𑀦𑀼𑀤𑀺𑀝𑁆𑀞𑀺𑀁 𑀊𑀳𑀘𑁆𑀘, 𑀏𑀯𑀁 𑀫𑀘𑁆𑀘𑀼𑀢𑀭𑁄 𑀲𑀺𑀬𑀸;

𑀏𑀯𑀁 𑀮𑁄𑀓𑀁 𑀅𑀯𑁂𑀓𑁆𑀔𑀦𑁆𑀢𑀁, 𑀫𑀘𑁆𑀘𑀼𑀭𑀸𑀚𑀸 𑀦 𑀧𑀲𑁆𑀲𑀢𑀻’’𑀢𑀺.

𑀫𑁄𑀖𑀭𑀸𑀚𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀧𑀦𑁆𑀦𑀭𑀲𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀚𑀺𑀡𑁆𑀡𑁄𑀳𑀫𑀲𑁆𑀫𑀺 𑀅𑀩𑀮𑁄 𑀯𑀻𑀢𑀯𑀡𑁆𑀡𑁄, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀧𑀺𑀗𑁆𑀕𑀺𑀬𑁄)

𑀦𑁂𑀢𑁆𑀢𑀸 𑀦 𑀲𑀼𑀤𑁆𑀥𑀸 𑀲𑀯𑀦𑀁 𑀦 𑀨𑀸𑀲𑀼;

𑀫𑀸𑀳𑀁 𑀦𑀲𑁆𑀲𑀁 𑀫𑁄𑀫𑀼𑀳𑁄 𑀅𑀦𑁆𑀢𑀭𑀸𑀯

𑀆𑀘𑀺𑀓𑁆𑀔 𑀥𑀫𑁆𑀫𑀁 𑀬𑀫𑀳𑀁 𑀯𑀺𑀚𑀜𑁆𑀜𑀁;

𑀚𑀸𑀢𑀺𑀚𑀭𑀸𑀬 𑀇𑀥 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀦𑀁’’.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀭𑀽𑀧𑁂𑀲𑀼 𑀯𑀺𑀳𑀜𑁆𑀜𑀫𑀸𑀦𑁂, (𑀧𑀺𑀗𑁆𑀕𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀭𑀼𑀧𑁆𑀧𑀦𑁆𑀢𑀺 𑀭𑀽𑀧𑁂𑀲𑀼 𑀚𑀦𑀸 𑀧𑀫𑀢𑁆𑀢𑀸;

𑀢𑀲𑁆𑀫𑀸 𑀢𑀼𑀯𑀁 𑀧𑀺𑀗𑁆𑀕𑀺𑀬 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄,

𑀚𑀳𑀲𑁆𑀲𑀼 𑀭𑀽𑀧𑀁 𑀅𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑀸𑀬’’.

‘‘𑀤𑀺𑀲𑀸 𑀘𑀢𑀲𑁆𑀲𑁄 𑀯𑀺𑀤𑀺𑀲𑀸 𑀘𑀢𑀲𑁆𑀲𑁄, 𑀉𑀤𑁆𑀥𑀁 ¶ 𑀅𑀥𑁄 𑀤𑀲 𑀤𑀺𑀲𑀸 𑀇𑀫𑀸𑀬𑁄;

𑀦 ¶ 𑀢𑀼𑀬𑁆𑀳𑀁 𑀅𑀤𑀺𑀝𑁆𑀞𑀁 𑀅𑀲𑀼𑀢𑀁 𑀅𑀫𑀼𑀢𑀁 [𑀅𑀲𑀼𑀢𑀁 𑀅𑀫𑀼𑀢𑀁 𑀯𑀸 (𑀲𑀻.), 𑀅𑀲𑀼𑀢𑀸𑀫𑀼𑀢𑀁 𑀯𑀸 (𑀲𑁆𑀬𑀸.), 𑀅𑀲𑀼𑀢𑀁’𑀫𑀼𑀢𑀁 𑀯𑀸 (𑀧𑀻.)], 𑀅𑀣𑁄 𑀅𑀯𑀺𑀜𑁆𑀜𑀸𑀢𑀁 𑀓𑀺𑀜𑁆𑀘𑀦𑀫𑀢𑁆𑀣𑀺 [𑀓𑀺𑀜𑁆𑀘𑀺 𑀫𑀢𑁆𑀣𑀺 (𑀲𑁆𑀬𑀸.), 𑀓𑀺𑀜𑁆𑀘𑀺 𑀦𑀢𑁆𑀣𑀺 (𑀧𑀻.), 𑀓𑀺𑀜𑁆𑀘𑀺𑀦𑀫𑀢𑁆𑀣𑀺 (𑀓.)] 𑀮𑁄𑀓𑁂;

𑀆𑀘𑀺𑀓𑁆𑀔 𑀥𑀫𑁆𑀫𑀁 𑀬𑀫𑀳𑀁 𑀯𑀺𑀚𑀜𑁆𑀜𑀁, 𑀚𑀸𑀢𑀺𑀚𑀭𑀸𑀬 𑀇𑀥 𑀯𑀺𑀧𑁆𑀧𑀳𑀸𑀦𑀁’’.

‘‘𑀢𑀡𑁆𑀳𑀸𑀥𑀺𑀧𑀦𑁆𑀦𑁂 ¶ 𑀫𑀦𑀼𑀚𑁂 𑀧𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑁄, (𑀧𑀺𑀗𑁆𑀕𑀺𑀬𑀸𑀢𑀺 𑀪𑀕𑀯𑀸)

𑀢𑀲𑁆𑀫𑀸 𑀢𑀼𑀯𑀁 𑀧𑀺𑀗𑁆𑀕𑀺𑀬 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄, 𑀚𑀳𑀲𑁆𑀲𑀼 𑀢𑀡𑁆𑀳𑀁 𑀅𑀧𑀼𑀦𑀩𑁆𑀪𑀯𑀸𑀬𑀸’’𑀢𑀺.

𑀧𑀺𑀗𑁆𑀕𑀺𑀬𑀫𑀸𑀡𑀯𑀧𑀼𑀘𑁆𑀙𑀸 𑀲𑁄𑀴𑀲𑀫𑀸 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.

𑀇𑀤𑀫𑀯𑁄𑀘 ¶ 𑀪𑀕𑀯𑀸 𑀫𑀕𑀥𑁂𑀲𑀼 𑀯𑀺𑀳𑀭𑀦𑁆𑀢𑁄 𑀧𑀸𑀲𑀸𑀡𑀓𑁂 𑀘𑁂𑀢𑀺𑀬𑁂, 𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑀲𑁄𑀴𑀲𑀸𑀦𑀁 [𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑀲𑁄𑀴𑀲𑀦𑁆𑀦𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀅𑀚𑁆𑀛𑀺𑀝𑁆𑀞𑁄 𑀧𑀼𑀝𑁆𑀞𑁄 𑀧𑀼𑀝𑁆𑀞𑁄 𑀧𑀜𑁆𑀳𑀁 [𑀧𑀜𑁆𑀳𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀩𑁆𑀬𑀸𑀓𑀸𑀲𑀺. 𑀏𑀓𑀫𑁂𑀓𑀲𑁆𑀲 𑀘𑁂𑀧𑀺 𑀧𑀜𑁆𑀳𑀲𑁆𑀲 𑀅𑀢𑁆𑀣𑀫𑀜𑁆𑀜𑀸𑀬 𑀥𑀫𑁆𑀫𑀫𑀜𑁆𑀜𑀸𑀬 𑀥𑀫𑁆𑀫𑀸𑀦𑀼𑀥𑀫𑁆𑀫𑀁 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑁂𑀬𑁆𑀬, 𑀕𑀘𑁆𑀙𑁂𑀬𑁆𑀬𑁂𑀯 𑀚𑀭𑀸𑀫𑀭𑀡𑀲𑁆𑀲 𑀧𑀸𑀭𑀁. 𑀧𑀸𑀭𑀗𑁆𑀕𑀫𑀦𑀻𑀬𑀸 𑀇𑀫𑁂 𑀥𑀫𑁆𑀫𑀸𑀢𑀺, 𑀢𑀲𑁆𑀫𑀸 𑀇𑀫𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑀧𑀭𑀺𑀬𑀸𑀬𑀲𑁆𑀲 𑀧𑀸𑀭𑀸𑀬𑀦𑀦𑁆𑀢𑁂𑀯 [𑀧𑀸𑀭𑀸𑀬𑀡𑀁𑀢𑁆𑀯𑁂𑀯 (𑀲𑀻. 𑀅𑀝𑁆𑀞.)] 𑀅𑀥𑀺𑀯𑀘𑀦𑀁.

𑀅𑀚𑀺𑀢𑁄 𑀢𑀺𑀲𑁆𑀲𑀫𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑁄, 𑀧𑀼𑀡𑁆𑀡𑀓𑁄 𑀅𑀣 𑀫𑁂𑀢𑁆𑀢𑀕𑀽;

𑀥𑁄𑀢𑀓𑁄 𑀉𑀧𑀲𑀻𑀯𑁄 𑀘, 𑀦𑀦𑁆𑀤𑁄 𑀘 𑀅𑀣 𑀳𑁂𑀫𑀓𑁄.

𑀢𑁄𑀤𑁂𑀬𑁆𑀬-𑀓𑀧𑁆𑀧𑀸 ¶ 𑀤𑀼𑀪𑀬𑁄, 𑀚𑀢𑀼𑀓𑀡𑁆𑀡𑀻 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑁄;

𑀪𑀤𑁆𑀭𑀸𑀯𑀼𑀥𑁄 𑀉𑀤𑀬𑁄 𑀘, 𑀧𑁄𑀲𑀸𑀮𑁄 𑀘𑀸𑀧𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

𑀫𑁄𑀖𑀭𑀸𑀚𑀸 ¶ 𑀘 𑀫𑁂𑀥𑀸𑀯𑀻, 𑀧𑀺𑀗𑁆𑀕𑀺𑀬𑁄 𑀘 𑀫𑀳𑀸𑀇𑀲𑀺.

𑀏𑀢𑁂 𑀩𑀼𑀤𑁆𑀥𑀁 𑀉𑀧𑀸𑀕𑀘𑁆𑀙𑀼𑀁, 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀘𑀭𑀡𑀁 𑀇𑀲𑀺𑀁;

𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀸 𑀦𑀺𑀧𑀼𑀡𑁂 𑀧𑀜𑁆𑀳𑁂, 𑀩𑀼𑀤𑁆𑀥𑀲𑁂𑀝𑁆𑀞𑀁 𑀉𑀧𑀸𑀕𑀫𑀼𑀁.

𑀢𑁂𑀲𑀁 𑀩𑀼𑀤𑁆𑀥𑁄 𑀧𑀩𑁆𑀬𑀸𑀓𑀸𑀲𑀺, 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀝𑁆𑀞𑁄 𑀬𑀣𑀸𑀢𑀣𑀁;

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

𑀢𑁂 𑀢𑁄𑀲𑀺𑀢𑀸 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑀸, 𑀩𑀼𑀤𑁆𑀥𑁂𑀦𑀸𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼𑀦𑀸;

𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀫𑀘𑀭𑀺𑀁𑀲𑀼, 𑀯𑀭𑀧𑀜𑁆𑀜𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂.

𑀏𑀓𑀫𑁂𑀓𑀲𑁆𑀲 ¶ 𑀧𑀜𑁆𑀳𑀲𑁆𑀲, 𑀬𑀣𑀸 𑀩𑀼𑀤𑁆𑀥𑁂𑀦 𑀤𑁂𑀲𑀺𑀢𑀁;

𑀢𑀣𑀸 𑀬𑁄 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑁂𑀬𑁆𑀬, 𑀕𑀘𑁆𑀙𑁂 𑀧𑀸𑀭𑀁 𑀅𑀧𑀸𑀭𑀢𑁄.

𑀅𑀧𑀸𑀭𑀸 𑀧𑀸𑀭𑀁 𑀕𑀘𑁆𑀙𑁂𑀬𑁆𑀬, 𑀪𑀸𑀯𑁂𑀦𑁆𑀢𑁄 𑀫𑀕𑁆𑀕𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀫𑀕𑁆𑀕𑁄 𑀲𑁄 𑀧𑀸𑀭𑀁 𑀕𑀫𑀦𑀸𑀬, 𑀢𑀲𑁆𑀫𑀸 𑀧𑀸𑀭𑀸𑀬𑀦𑀁 𑀇𑀢𑀺.

‘‘𑀧𑀸𑀭𑀸𑀬𑀦𑀫𑀦𑀼𑀕𑀸𑀬𑀺𑀲𑁆𑀲𑀁, (𑀇𑀘𑁆𑀘𑀸𑀬𑀲𑁆𑀫𑀸 𑀧𑀺𑀗𑁆𑀕𑀺𑀬𑁄)

𑀬𑀣𑀸𑀤𑁆𑀤𑀓𑁆𑀔𑀺 𑀢𑀣𑀸𑀓𑁆𑀔𑀸𑀲𑀺, 𑀯𑀺𑀫𑀮𑁄 𑀪𑀽𑀭𑀺𑀫𑁂𑀥𑀲𑁄;

𑀦𑀺𑀓𑁆𑀓𑀸𑀫𑁄 𑀦𑀺𑀩𑁆𑀩𑀦𑁄 [𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 (𑀲𑁆𑀬𑀸.)] 𑀦𑀸𑀕𑁄, 𑀓𑀺𑀲𑁆𑀲 𑀳𑁂𑀢𑀼 𑀫𑀼𑀲𑀸 𑀪𑀡𑁂.

‘‘𑀧𑀳𑀻𑀦𑀫𑀮𑀫𑁄𑀳𑀲𑁆𑀲 ¶ ¶ , 𑀫𑀸𑀦𑀫𑀓𑁆𑀔𑀧𑁆𑀧𑀳𑀸𑀬𑀺𑀦𑁄;

𑀳𑀦𑁆𑀤𑀸𑀳𑀁 𑀓𑀺𑀢𑁆𑀢𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀕𑀺𑀭𑀁 𑀯𑀡𑁆𑀡𑀽𑀧𑀲𑀜𑁆𑀳𑀺𑀢𑀁.

‘‘𑀢𑀫𑁄𑀦𑀼𑀤𑁄 𑀩𑀼𑀤𑁆𑀥𑁄 𑀲𑀫𑀦𑁆𑀢𑀘𑀓𑁆𑀔𑀼, 𑀮𑁄𑀓𑀦𑁆𑀢𑀕𑀽 𑀲𑀩𑁆𑀩𑀪𑀯𑀸𑀢𑀺𑀯𑀢𑁆𑀢𑁄;

𑀅𑀦𑀸𑀲𑀯𑁄 𑀲𑀩𑁆𑀩𑀤𑀼𑀓𑁆𑀔𑀧𑀳𑀻𑀦𑁄, 𑀲𑀘𑁆𑀘𑀯𑁆𑀳𑀬𑁄 ¶ 𑀩𑁆𑀭𑀳𑁆𑀫𑁂 𑀉𑀧𑀸𑀲𑀺𑀢𑁄 𑀫𑁂.

‘‘𑀤𑀺𑀚𑁄 𑀬𑀣𑀸 𑀓𑀼𑀩𑁆𑀩𑀦𑀓𑀁 𑀧𑀳𑀸𑀬, 𑀩𑀳𑀼𑀧𑁆𑀨𑀮𑀁 𑀓𑀸𑀦𑀦𑀫𑀸𑀯𑀲𑁂𑀬𑁆𑀬;

𑀏𑀯𑀁 𑀧𑀳𑀁 𑀅𑀧𑁆𑀧𑀤𑀲𑁆𑀲𑁂 𑀧𑀳𑀸𑀬, 𑀫𑀳𑁄𑀤𑀥𑀺𑀁 𑀳𑀁𑀲𑁄𑀭𑀺𑀯 𑀅𑀚𑁆𑀛𑀧𑀢𑁆𑀢𑁄.

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

𑀲𑀩𑁆𑀩𑀁 𑀢𑀁 𑀇𑀢𑀺𑀳𑀺𑀢𑀺𑀳𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀢𑀁 𑀢𑀓𑁆𑀓𑀯𑀟𑁆𑀠𑀦𑀁.

‘‘𑀏𑀓𑁄 𑀢𑀫𑀦𑀼𑀤𑀸𑀲𑀺𑀦𑁄, 𑀚𑀼𑀢𑀺𑀫𑀸 𑀲𑁄 𑀧𑀪𑀗𑁆𑀓𑀭𑁄;

𑀕𑁄𑀢𑀫𑁄 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜𑀸𑀡𑁄, 𑀕𑁄𑀢𑀫𑁄 𑀪𑀽𑀭𑀺𑀫𑁂𑀥𑀲𑁄.

‘‘𑀬𑁄 ¶ 𑀫𑁂 𑀥𑀫𑁆𑀫𑀫𑀤𑁂𑀲𑁂𑀲𑀺, 𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓𑀫𑀓𑀸𑀮𑀺𑀓𑀁;

𑀢𑀡𑁆𑀳𑀓𑁆𑀔𑀬𑀫𑀦𑀻𑀢𑀺𑀓𑀁 ¶ , 𑀬𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺 𑀉𑀧𑀫𑀸 𑀓𑁆𑀯𑀘𑀺’’.

‘‘𑀓𑀺𑀁𑀦𑀼 ¶ 𑀢𑀫𑁆𑀳𑀸 𑀯𑀺𑀧𑁆𑀧𑀯𑀲𑀲𑀺, 𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑀫𑀧𑀺 𑀧𑀺𑀗𑁆𑀕𑀺𑀬;

𑀕𑁄𑀢𑀫𑀸 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜𑀸𑀡𑀸, 𑀕𑁄𑀢𑀫𑀸 𑀪𑀽𑀭𑀺𑀫𑁂𑀥𑀲𑀸.

‘‘𑀬𑁄 𑀢𑁂 𑀥𑀫𑁆𑀫𑀫𑀤𑁂𑀲𑁂𑀲𑀺, 𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓𑀫𑀓𑀸𑀮𑀺𑀓𑀁;

𑀢𑀡𑁆𑀳𑀓𑁆𑀔𑀬𑀫𑀦𑀻𑀢𑀺𑀓𑀁, 𑀬𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺 𑀉𑀧𑀫𑀸 𑀓𑁆𑀯𑀘𑀺’’.

‘‘𑀦𑀸𑀳𑀁 𑀢𑀫𑁆𑀳𑀸 𑀯𑀺𑀧𑁆𑀧𑀯𑀲𑀸𑀫𑀺, 𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑀫𑀧𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡;

𑀕𑁄𑀢𑀫𑀸 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜𑀸𑀡𑀸, 𑀕𑁄𑀢𑀫𑀸 𑀪𑀽𑀭𑀺𑀫𑁂𑀥𑀲𑀸.

‘‘𑀬𑁄 𑀫𑁂 𑀥𑀫𑁆𑀫𑀫𑀤𑁂𑀲𑁂𑀲𑀺, 𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓𑀫𑀓𑀸𑀮𑀺𑀓𑀁;

𑀢𑀡𑁆𑀳𑀓𑁆𑀔𑀬𑀫𑀦𑀻𑀢𑀺𑀓𑀁, 𑀬𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺 𑀉𑀧𑀫𑀸 𑀓𑁆𑀯𑀘𑀺.

‘‘𑀧𑀲𑁆𑀲𑀸𑀫𑀺 ¶ 𑀦𑀁 𑀫𑀦𑀲𑀸 𑀘𑀓𑁆𑀔𑀼𑀦𑀸𑀯, 𑀭𑀢𑁆𑀢𑀺𑀦𑁆𑀤𑀺𑀯𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄;

𑀦𑀫𑀲𑁆𑀲𑀫𑀸𑀦𑁄 𑀯𑀺𑀯𑀲𑁂𑀫𑀺 𑀭𑀢𑁆𑀢𑀺𑀁, 𑀢𑁂𑀦𑁂𑀯 𑀫𑀜𑁆𑀜𑀸𑀫𑀺 𑀅𑀯𑀺𑀧𑁆𑀧𑀯𑀸𑀲𑀁.

‘‘𑀲𑀤𑁆𑀥𑀸 𑀘 𑀧𑀻𑀢𑀺 𑀘 𑀫𑀦𑁄 𑀲𑀢𑀺 𑀘, 𑀦𑀸𑀧𑁂𑀦𑁆𑀢𑀺 𑀫𑁂 𑀕𑁄𑀢𑀫𑀲𑀸𑀲𑀦𑀫𑁆𑀳𑀸;

𑀬𑀁 𑀬𑀁 𑀤𑀺𑀲𑀁 𑀯𑀚𑀢𑀺 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜𑁄, 𑀲 𑀢𑁂𑀦 𑀢𑁂𑀦𑁂𑀯 𑀦𑀢𑁄𑀳𑀫𑀲𑁆𑀫𑀺.

‘‘𑀚𑀺𑀡𑁆𑀡𑀲𑁆𑀲 ¶ 𑀫𑁂 𑀤𑀼𑀩𑁆𑀩𑀮𑀣𑀸𑀫𑀓𑀲𑁆𑀲, 𑀢𑁂𑀦𑁂𑀯 𑀓𑀸𑀬𑁄 𑀦 𑀧𑀮𑁂𑀢𑀺 𑀢𑀢𑁆𑀣;

𑀲𑀁𑀓𑀧𑁆𑀧𑀬𑀦𑁆𑀢𑀸𑀬 [𑀲𑀁𑀓𑀧𑁆𑀧𑀬𑀢𑁆𑀢𑀸𑀬 (𑀲𑀻.)] 𑀯𑀚𑀸𑀫𑀺 𑀦𑀺𑀘𑁆𑀘𑀁, 𑀫𑀦𑁄 𑀳𑀺 𑀫𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀢𑁂𑀦 𑀬𑀼𑀢𑁆𑀢𑁄.

‘‘𑀧𑀗𑁆𑀓𑁂 𑀲𑀬𑀸𑀦𑁄 𑀧𑀭𑀺𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑁄, 𑀤𑀻𑀧𑀸 𑀤𑀻𑀧𑀁 𑀉𑀧𑀧𑁆𑀮𑀯𑀺𑀁 [𑀉𑀧𑀮𑁆𑀮𑀯𑀺𑀁 (𑀲𑁆𑀬𑀸. 𑀦𑀺𑀤𑁆𑀤𑁂𑀲)];

𑀅𑀣𑀤𑁆𑀤𑀲𑀸𑀲𑀺𑀁 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁, 𑀑𑀖𑀢𑀺𑀡𑁆𑀡𑀫𑀦𑀸𑀲𑀯𑀁’’.

‘‘𑀬𑀣𑀸 𑀅𑀳𑀽 𑀯𑀓𑁆𑀓𑀮𑀺 𑀫𑀼𑀢𑁆𑀢𑀲𑀤𑁆𑀥𑁄, 𑀪𑀤𑁆𑀭𑀸𑀯𑀼𑀥𑁄 𑀆𑀴𑀯𑀺 𑀕𑁄𑀢𑀫𑁄 𑀘;

𑀏𑀯𑀫𑁂𑀯 𑀢𑁆𑀯𑀫𑁆𑀧𑀺 𑀧𑀫𑀼𑀜𑁆𑀘𑀲𑁆𑀲𑀼 𑀲𑀤𑁆𑀥𑀁,

𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺 𑀢𑁆𑀯𑀁 𑀧𑀺𑀗𑁆𑀕𑀺𑀬 𑀫𑀘𑁆𑀘𑀼𑀥𑁂𑀬𑁆𑀬𑀲𑁆𑀲 𑀧𑀸𑀭𑀁’’ [𑀫𑀘𑁆𑀘𑀼𑀥𑁂𑀬𑁆𑀬𑀧𑀸𑀭𑀁 (𑀲𑀻.)].

‘‘𑀏𑀲 𑀪𑀺𑀬𑁆𑀬𑁄 𑀧𑀲𑀻𑀤𑀸𑀫𑀺, 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀫𑀼𑀦𑀺𑀦𑁄 𑀯𑀘𑁄;

𑀯𑀺𑀯𑀝𑁆𑀝𑀘𑁆𑀙𑀤𑁄 ¶ 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄, 𑀅𑀔𑀺𑀮𑁄 𑀧𑀝𑀺𑀪𑀸𑀦𑀯𑀸.

‘‘𑀅𑀥𑀺𑀤𑁂𑀯𑁂 ¶ 𑀅𑀪𑀺𑀜𑁆𑀜𑀸𑀬, 𑀲𑀩𑁆𑀩𑀁 𑀯𑁂𑀤𑀺 𑀯𑀭𑁄𑀯𑀭𑀁 [𑀧𑀭𑁄 𑀯𑀭𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀧𑀭𑁄 𑀧𑀭𑀁 (𑀦𑀺𑀤𑁆𑀤𑁂𑀲)];

𑀧𑀜𑁆𑀳𑀸𑀦𑀦𑁆𑀢𑀓𑀭𑁄 𑀲𑀢𑁆𑀣𑀸, 𑀓𑀗𑁆𑀔𑀻𑀦𑀁 𑀧𑀝𑀺𑀚𑀸𑀦𑀢𑀁.

‘‘𑀅𑀲𑀁𑀳𑀻𑀭𑀁 ¶ 𑀅𑀲𑀗𑁆𑀓𑀼𑀧𑁆𑀧𑀁, 𑀬𑀲𑁆𑀲 𑀦𑀢𑁆𑀣𑀺 𑀉𑀧𑀫𑀸 𑀓𑁆𑀯𑀘𑀺;

𑀅𑀤𑁆𑀥𑀸 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀦 𑀫𑁂𑀢𑁆𑀣 𑀓𑀗𑁆𑀔𑀸, 𑀏𑀯𑀁 𑀫𑀁 𑀥𑀸𑀭𑁂𑀳𑀺 𑀅𑀥𑀺𑀫𑀼𑀢𑁆𑀢𑀘𑀺𑀢𑁆𑀢’’𑀦𑁆𑀢𑀺.

𑀧𑀸𑀭𑀸𑀬𑀦𑀯𑀕𑁆𑀕𑁄 𑀧𑀜𑁆𑀘𑀫𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀉𑀭𑀕𑁄 ¶ [𑀇𑀫𑀸 𑀉𑀤𑁆𑀤𑀸𑀦𑀕𑀸𑀣𑀸𑀬𑁄 𑀲𑀻. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼 𑀦 𑀲𑀦𑁆𑀢𑀺] 𑀥𑀦𑀺𑀬𑁄𑀧𑀺 𑀘, 𑀔𑀕𑁆𑀕𑀯𑀺𑀲𑀸𑀡𑁄 𑀓𑀲𑀺 𑀘;

𑀘𑀼𑀦𑁆𑀤𑁄 𑀪𑀯𑁄 𑀧𑀼𑀦𑀤𑁂𑀯, 𑀯𑀲𑀮𑁄 𑀘 𑀓𑀭𑀡𑀻𑀬𑀜𑁆𑀘;

𑀳𑁂𑀫𑀯𑀢𑁄 𑀅𑀣 𑀬𑀓𑁆𑀔𑁄, 𑀯𑀺𑀚𑀬𑀲𑀼𑀢𑁆𑀢𑀁 𑀫𑀼𑀦𑀺𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀦𑁆𑀢𑀺.

𑀧𑀞𑀫𑀓𑀝𑁆𑀞𑀯𑀭𑁄 𑀯𑀭𑀯𑀕𑁆𑀕𑁄, 𑀤𑁆𑀯𑀸𑀤𑀲𑀲𑀼𑀢𑁆𑀢𑀥𑀭𑁄 𑀲𑀼𑀯𑀺𑀪𑀢𑁆𑀢𑁄;

𑀤𑁂𑀲𑀺𑀢𑁄 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑀸 𑀯𑀺𑀫𑀮𑁂𑀦, 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀯𑀕𑁆𑀕𑀯𑀭𑁄 𑀉𑀭𑀕𑁄𑀢𑀺.

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

𑀦𑀸𑀯𑀸 [𑀦𑀸𑀣 (𑀓.)] 𑀓𑀺𑀁𑀲𑀻𑀮𑀉𑀝𑁆𑀞𑀳𑀦𑁄 𑀘, 𑀭𑀸𑀳𑀼𑀮𑁄 ¶ 𑀘 𑀧𑀼𑀦𑀧𑀺 𑀯𑀗𑁆𑀕𑀻𑀲𑁄.

𑀲𑀫𑁆𑀫𑀸𑀧𑀭𑀺𑀩𑁆𑀩𑀸𑀚𑀦𑀻𑀬𑁄𑀧𑀺 𑀘𑁂𑀢𑁆𑀣, 𑀥𑀫𑁆𑀫𑀺𑀓𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑁄 𑀲𑀼𑀯𑀺𑀪𑀢𑁆𑀢𑁄;

𑀘𑀼𑀤𑁆𑀤𑀲𑀲𑀼𑀢𑁆𑀢𑀥𑀭𑁄 𑀤𑀼𑀢𑀺𑀬𑀫𑁆𑀳𑀺, 𑀘𑀽𑀴𑀓𑀯𑀕𑁆𑀕𑀯𑀭𑁄𑀢𑀺 𑀢𑀫𑀸𑀳𑀼.

𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀧𑀥𑀸𑀦𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀦𑀸𑀫𑁄, 𑀧𑀽𑀭𑀴𑀸𑀲𑁄 𑀧𑀼𑀦𑀤𑁂𑀯 𑀫𑀸𑀖𑁄 𑀘;

𑀲𑀪𑀺𑀬𑀁 𑀓𑁂𑀡𑀺𑀬𑀫𑁂𑀯 𑀲𑀮𑁆𑀮𑀦𑀸𑀫𑁄, 𑀯𑀸𑀲𑁂𑀝𑁆𑀞𑀯𑀭𑁄 𑀓𑀸𑀮𑀺𑀓𑁄𑀧𑀺 𑀘.

𑀦𑀸𑀮𑀓𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑁄 𑀲𑀼𑀯𑀺𑀪𑀢𑁆𑀢𑁄, 𑀢𑀁 𑀅𑀦𑀼𑀧𑀲𑁆𑀲𑀻 𑀢𑀣𑀸 𑀧𑀼𑀦𑀤𑁂𑀯;

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

𑀓𑀸𑀫𑀕𑀼𑀳𑀝𑁆𑀞𑀓𑀤𑀼𑀝𑁆𑀞𑀓𑀦𑀸𑀫𑀸 ¶ , 𑀲𑀼𑀤𑁆𑀥𑀯𑀭𑁄 𑀧𑀭𑀫𑀝𑁆𑀞𑀓𑀦𑀸𑀫𑁄;

𑀚𑀭𑀸 𑀫𑁂𑀢𑁆𑀢𑀺𑀬𑀯𑀭𑁄 𑀲𑀼𑀯𑀺𑀪𑀢𑁆𑀢𑁄, 𑀧𑀲𑀽𑀭𑀫𑀸𑀕𑀡𑁆𑀟𑀺𑀬𑀸 𑀧𑀼𑀭𑀸𑀪𑁂𑀤𑁄.

𑀓𑀮𑀳𑀯𑀺𑀯𑀸𑀤𑁄 ¶ 𑀉𑀪𑁄 𑀯𑀺𑀬𑀼𑀳𑀸 𑀘, 𑀢𑀼𑀯𑀝𑀓𑀅𑀢𑁆𑀢𑀤𑀡𑁆𑀟𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀸;

𑀲𑁄𑀴𑀲𑀲𑀼𑀢𑁆𑀢𑀥𑀭𑁄 𑀘𑀢𑀼𑀢𑁆𑀣𑀫𑁆𑀳𑀺, 𑀅𑀝𑁆𑀞𑀓𑀯𑀕𑁆𑀕𑀯𑀭𑁄𑀢𑀺 ¶ 𑀢𑀫𑀸𑀳𑀼.

𑀫𑀕𑀥𑁂 𑀚𑀦𑀧𑀤𑁂 𑀭𑀫𑀡𑀻𑀬𑁂, 𑀤𑁂𑀲𑀯𑀭𑁂 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀦𑀺𑀯𑁂𑀲𑁂;

𑀧𑀸𑀲𑀸𑀡𑀓𑀘𑁂𑀢𑀺𑀬𑀯𑀭𑁂 𑀲𑀼𑀯𑀺𑀪𑀢𑁆𑀢𑁂, 𑀯𑀲𑀺 𑀪𑀕𑀯𑀸 𑀕𑀡𑀲𑁂𑀝𑁆𑀞𑁄.

𑀉𑀪𑀬𑀯𑀸𑀲𑀫𑀸𑀕𑀢𑀺𑀬𑀫𑁆𑀳𑀺 [𑀉𑀪𑀬𑀁 𑀯𑀸 𑀧𑀼𑀡𑁆𑀡𑀲𑀫𑀸𑀕𑀢𑀁 𑀬𑀫𑁆𑀳𑀺 (𑀲𑁆𑀬𑀸.)], 𑀤𑁆𑀯𑀸𑀤𑀲𑀬𑁄𑀚𑀦𑀺𑀬𑀸 𑀧𑀭𑀺𑀲𑀸𑀬;

𑀲𑁄𑀴𑀲𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀓𑀺𑀭 𑀧𑀼𑀝𑁆𑀞𑁄, 𑀧𑀼𑀘𑁆𑀙𑀸𑀬 𑀲𑁄𑀴𑀲𑀧𑀜𑁆𑀳𑀓𑀫𑁆𑀫𑀺𑀬𑀸;

𑀅𑀢𑁆𑀣𑀧𑀓𑀸𑀲𑀓𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀧𑀼𑀡𑁆𑀡𑀁, 𑀥𑀫𑁆𑀫𑀫𑀤𑁂𑀲𑁂𑀲𑀺 𑀧𑀭𑀔𑁂𑀫𑀚𑀦𑀺𑀬𑀁 [𑀯𑀭𑀁 𑀔𑀫𑀦𑀻𑀬𑀁 (𑀓.)];

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

𑀲𑀩𑁆𑀩𑀓𑀺𑀮𑁂𑀲𑀧𑀫𑁄𑀘𑀦𑀳𑁂𑀢𑀼𑀁, 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀫𑀢𑁆𑀣𑀧𑀤𑀁 𑀲𑀫𑀬𑀼𑀢𑁆𑀢𑀁 [𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀫𑀢𑁆𑀣𑀧𑀤𑀲𑀫𑀬𑀼𑀢𑁆𑀢𑀁 (𑀲𑁆𑀬𑀸.)], 𑀅𑀓𑁆𑀔𑀭𑀲𑀜𑁆𑀜𑀺𑀢𑀑𑀧𑀫𑀕𑀸𑀴𑁆𑀳𑀁;

𑀮𑁄𑀓𑀯𑀺𑀘𑀸𑀭𑀡𑀜𑀸𑀡𑀧𑀪𑀕𑁆𑀕𑀁, 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀭𑀸𑀕𑀫𑀮𑁂 ¶ 𑀅𑀫𑀮𑀁 𑀯𑀺𑀫𑀮𑀕𑁆𑀕𑀁, 𑀤𑁄𑀲𑀫𑀮𑁂 𑀅𑀫𑀮𑀁 𑀯𑀺𑀫𑀮𑀕𑁆𑀕𑀁;

𑀫𑁄𑀳𑀫𑀮𑁂 𑀅𑀫𑀮𑀁 𑀯𑀺𑀫𑀮𑀕𑁆𑀕𑀁, 𑀮𑁄𑀓𑀯𑀺𑀘𑀸𑀭𑀡𑀜𑀸𑀡𑀧𑀪𑀕𑁆𑀕𑀁;

𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀓𑁆𑀮𑁂𑀲𑀫𑀮𑁂 ¶ 𑀅𑀫𑀮𑀁 𑀯𑀺𑀫𑀮𑀕𑁆𑀕𑀁, 𑀤𑀼𑀘𑁆𑀘𑀭𑀺𑀢𑀫𑀮𑁂 𑀅𑀫𑀮𑀁 𑀯𑀺𑀫𑀮𑀕𑁆𑀕𑀁;

𑀮𑁄𑀓𑀯𑀺𑀘𑀸𑀭𑀡𑀜𑀸𑀡𑀧𑀪𑀕𑁆𑀕𑀁, 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀆𑀲𑀯𑀩𑀦𑁆𑀥𑀦𑀬𑁄𑀕𑀸𑀓𑀺𑀮𑁂𑀲𑀁, 𑀦𑀻𑀯𑀭𑀡𑀸𑀦𑀺 𑀘 𑀢𑀻𑀡𑀺 𑀫𑀮𑀸𑀦𑀺;

𑀢𑀲𑁆𑀲 𑀓𑀺𑀮𑁂𑀲𑀧𑀫𑁄𑀘𑀦𑀳𑁂𑀢𑀼𑀁, 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀦𑀺𑀫𑁆𑀫𑀮𑀲𑀩𑁆𑀩𑀓𑀺𑀮𑁂𑀲𑀧𑀦𑀽𑀤𑀁, 𑀭𑀸𑀕𑀯𑀺𑀭𑀸𑀕𑀫𑀦𑁂𑀚𑀫𑀲𑁄𑀓𑀁;

𑀲𑀦𑁆𑀢𑀧𑀡𑀻𑀢𑀲𑀼𑀤𑀼𑀤𑁆𑀤𑀲𑀥𑀫𑁆𑀫𑀁, 𑀤𑁂𑀲𑀬𑀺 ¶ 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀭𑀸𑀕𑀜𑁆𑀘 ¶ 𑀤𑁄𑀲𑀓𑀫𑀪𑀜𑁆𑀚𑀺𑀢𑀲𑀦𑁆𑀢𑀁 [𑀤𑁄𑀲𑀜𑁆𑀘 𑀪𑀜𑁆𑀚𑀺𑀢𑀲𑀦𑁆𑀢𑀁 (𑀲𑁆𑀬𑀸.)], 𑀬𑁄𑀦𑀺𑀘𑀢𑀼𑀕𑁆𑀕𑀢𑀺𑀧𑀜𑁆𑀘𑀯𑀺𑀜𑁆𑀜𑀸𑀡𑀁;

𑀢𑀡𑁆𑀳𑀸𑀭𑀢𑀘𑁆𑀙𑀤𑀦𑀢𑀸𑀡𑀮𑀢𑀸𑀧𑀫𑁄𑀓𑁆𑀔𑀁 [𑀢𑀡𑁆𑀳𑀸𑀢𑀮𑀭𑀢𑀘𑁆𑀙𑁂𑀤𑀦𑀢𑀸𑀡𑀧𑀫𑁄𑀓𑁆𑀔𑀁 (𑀲𑁆𑀬𑀸.)], 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀕𑀫𑁆𑀪𑀻𑀭𑀤𑀼𑀤𑁆𑀤𑀲𑀲𑀡𑁆𑀳𑀦𑀺𑀧𑀼𑀡𑀁, 𑀧𑀡𑁆𑀟𑀺𑀢𑀯𑁂𑀤𑀦𑀺𑀬𑀁 𑀦𑀺𑀧𑀼𑀡𑀢𑁆𑀣𑀁;

𑀮𑁄𑀓𑀯𑀺𑀘𑀸𑀭𑀡𑀜𑀸𑀡𑀧𑀪𑀕𑁆𑀕𑀁, 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀦𑀯𑀗𑁆𑀕𑀓𑀼𑀲𑀼𑀫𑀫𑀸𑀮𑀕𑀻𑀯𑁂𑀬𑁆𑀬𑀁, 𑀇𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀛𑀸𑀦𑀯𑀺𑀫𑁄𑀓𑁆𑀔𑀯𑀺𑀪𑀢𑁆𑀢𑀁;

𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑀫𑀕𑁆𑀕𑀥𑀭𑀁 𑀯𑀭𑀬𑀸𑀦𑀁, 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀲𑁄𑀫𑀼𑀧𑀫𑀁 ¶ 𑀯𑀺𑀫𑀮𑀁 𑀧𑀭𑀺𑀲𑀼𑀤𑁆𑀥𑀁, 𑀅𑀡𑁆𑀡𑀯𑀫𑀽𑀧𑀫𑀭𑀢𑀦𑀲𑀼𑀘𑀺𑀢𑁆𑀢𑀁;

𑀧𑀼𑀧𑁆𑀨𑀲𑀫𑀁 𑀭𑀯𑀺𑀫𑀽𑀧𑀫𑀢𑁂𑀚𑀁, 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄.

𑀔𑁂𑀫𑀲𑀺𑀯𑀁 𑀲𑀼𑀔𑀲𑀻𑀢𑀮𑀲𑀦𑁆𑀢𑀁, 𑀫𑀘𑁆𑀘𑀼𑀢𑀢𑀸𑀡𑀧𑀭𑀁 𑀧𑀭𑀫𑀢𑁆𑀣𑀁;

𑀢𑀲𑁆𑀲 𑀲𑀼𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀤𑀲𑁆𑀲𑀦𑀳𑁂𑀢𑀼𑀁, 𑀤𑁂𑀲𑀬𑀺 𑀲𑀼𑀢𑁆𑀢𑀯𑀭𑀁 𑀤𑁆𑀯𑀺𑀧𑀤𑀕𑁆𑀕𑁄𑀢𑀺.

𑀲𑀼𑀢𑁆𑀢𑀦𑀺𑀧𑀸𑀢𑀧𑀸𑀴𑀺 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.