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

𑁧𑁩𑁬. ‘‘𑀫𑀫 ¶ 𑀘, 𑀪𑀦𑁆𑀢𑁂, 𑀯𑀘𑀦𑁂𑀦 𑀪𑀕𑀯𑀢𑁄 𑀧𑀸𑀤𑁂 𑀲𑀺𑀭𑀲𑀸 𑀯𑀦𑁆𑀤𑁂𑀬𑁆𑀬𑀸𑀲𑀺 𑁋 ‘𑀉𑀢𑁆𑀢𑀭𑀸 𑀦𑀸𑀫, 𑀪𑀦𑁆𑀢𑁂, 𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀪𑀕𑀯𑀢𑁄 𑀧𑀸𑀤𑁂 𑀲𑀺𑀭𑀲𑀸 𑀯𑀦𑁆𑀤𑀢𑀻’𑀢𑀺. 𑀅𑀦𑀘𑁆𑀙𑀭𑀺𑀬𑀁 𑀔𑁄 𑀧𑀦𑁂𑀢𑀁, 𑀪𑀦𑁆𑀢𑁂, 𑀬𑀁 𑀫𑀁 𑀪𑀕𑀯𑀸 𑀅𑀜𑁆𑀜𑀢𑀭𑀲𑁆𑀫𑀺𑀁 𑀲𑀸𑀫𑀜𑁆𑀜𑀨𑀮𑁂 𑀩𑁆𑀬𑀸𑀓𑀭𑁂𑀬𑁆𑀬 [𑀩𑁆𑀬𑀸𑀓𑀭𑁂𑀬𑁆𑀬𑀸𑀢𑀺 (?)], 𑀢𑀁 𑀪𑀕𑀯𑀸 𑀲𑀓𑀤𑀸𑀕𑀸𑀫𑀺𑀨𑀮𑁂 𑀩𑁆𑀬𑀸𑀓𑀸𑀲𑀻’’𑀢𑀺.

𑀉𑀢𑁆𑀢𑀭𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀧𑀦𑁆𑀦𑀭𑀲𑀫𑀁.

‘‘𑀬𑀼𑀢𑁆𑀢𑀸 ¶ 𑀘 𑀢𑁂 𑀧𑀭𑀫𑀅𑀮𑀗𑁆𑀓𑀢𑀸 𑀳𑀬𑀸, 𑀅𑀥𑁄𑀫𑀼𑀔𑀸 𑀅𑀖𑀲𑀺𑀕𑀫𑀸 𑀩𑀮𑀻 𑀚𑀯𑀸;

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

‘‘𑀲𑀸 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀭𑀣𑀯𑀭𑁂 𑀅𑀮𑀗𑁆𑀓𑀢𑀸, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀚𑀮𑀫𑀺𑀯 𑀚𑁄𑀢𑀺 𑀧𑀸𑀯𑀓𑁄;

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

‘‘𑀓𑀸𑀫𑀕𑁆𑀕𑀧𑀢𑁆𑀢𑀸𑀦𑀁 ¶ 𑀬𑀫𑀸𑀳𑀼𑀦𑀼𑀢𑁆𑀢𑀭𑀁 [… 𑀦𑀼𑀢𑁆𑀢𑀭𑀸 (𑀓.), 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑀸 (𑀲𑁆𑀬𑀸.)], 𑀦𑀺𑀫𑁆𑀫𑀸𑀬 𑀦𑀺𑀫𑁆𑀫𑀸𑀬 𑀭𑀫𑀦𑁆𑀢𑀺 𑀤𑁂𑀯𑀢𑀸;

𑀢𑀲𑁆𑀫𑀸 𑀓𑀸𑀬𑀸 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻, 𑀇𑀥𑀸𑀕𑀢𑀸 𑀅𑀦𑀥𑀺𑀯𑀭𑀁 𑀦𑀫𑀲𑁆𑀲𑀺𑀢𑀼𑀁.

‘‘𑀓𑀺𑀁 𑀢𑁆𑀯𑀁 𑀧𑀼𑀭𑁂 𑀲𑀼𑀘𑀭𑀺𑀢𑀫𑀸𑀘𑀭𑀻𑀥 [𑀲𑀼𑀘𑀭𑀺𑀢𑀁 𑀅𑀘𑀸𑀭𑀺𑀥 (𑀧𑀻.)],

𑀓𑁂𑀦𑀘𑁆𑀙𑀲𑀺 ¶ 𑀢𑁆𑀯𑀁 𑀅𑀫𑀺𑀢𑀬𑀲𑀸 𑀲𑀼𑀔𑁂𑀥𑀺𑀢𑀸;

𑀇𑀤𑁆𑀥𑀻 𑀘 𑀢𑁂 𑀅𑀦𑀥𑀺𑀯𑀭𑀸 𑀯𑀺𑀳𑀗𑁆𑀕𑀫𑀸,

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀤𑀲 𑀤𑀺𑀲𑀸 𑀯𑀺𑀭𑁄𑀘𑀢𑀺.

‘‘𑀤𑁂𑀯𑁂𑀳𑀺 𑀢𑁆𑀯𑀁 𑀧𑀭𑀺𑀯𑀼𑀢𑀸 𑀲𑀓𑁆𑀓𑀢𑀸 𑀘𑀲𑀺,

𑀓𑀼𑀢𑁄 𑀘𑀼𑀢𑀸 𑀲𑀼𑀕𑀢𑀺𑀕𑀢𑀸𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀓𑀲𑁆𑀲 𑀯𑀸 𑀢𑁆𑀯𑀁 𑀯𑀘𑀦𑀓𑀭𑀸𑀦𑀼𑀲𑀸𑀲𑀦𑀺𑀁,

𑀆𑀘𑀺𑀓𑁆𑀔 𑀫𑁂 𑀢𑁆𑀯𑀁 𑀬𑀤𑀺 𑀩𑀼𑀤𑁆𑀥𑀲𑀸𑀯𑀺𑀓𑀸’’𑀢𑀺.

‘‘𑀦𑀕𑀦𑁆𑀢𑀭𑁂 ¶ 𑀦𑀕𑀭𑀯𑀭𑁂 𑀲𑀼𑀫𑀸𑀧𑀺𑀢𑁂, 𑀧𑀭𑀺𑀘𑀸𑀭𑀺𑀓𑀸 𑀭𑀸𑀚𑀯𑀭𑀲𑁆𑀲 𑀲𑀺𑀭𑀺𑀫𑀢𑁄;

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

‘‘𑀩𑀼𑀤𑁆𑀥𑁄 𑀘 𑀫𑁂 𑀇𑀲𑀺𑀦𑀺𑀲𑀪𑁄 𑀯𑀺𑀦𑀸𑀬𑀓𑁄, 𑀅𑀤𑁂𑀲𑀬𑀻 𑀲𑀫𑀼𑀤𑀬𑀤𑀼𑀓𑁆𑀔𑀦𑀺𑀘𑁆𑀘𑀢𑀁;

𑀅𑀲𑀗𑁆𑀔𑀢𑀁 𑀤𑀼𑀓𑁆𑀔𑀦𑀺𑀭𑁄𑀥𑀲𑀲𑁆𑀲𑀢𑀁, 𑀫𑀕𑁆𑀕𑀜𑁆𑀘𑀺𑀫𑀁 𑀅𑀓𑀼𑀝𑀺𑀮𑀫𑀜𑁆𑀚𑀲𑀁 𑀲𑀺𑀯𑀁.

‘‘𑀲𑀼𑀢𑁆𑀯𑀸𑀦𑀳𑀁 𑀅𑀫𑀢𑀧𑀤𑀁 𑀅𑀲𑀗𑁆𑀔𑀢𑀁, 𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲𑀦𑀥𑀺𑀯𑀭𑀲𑁆𑀲 𑀲𑀸𑀲𑀦𑀁;

𑀲𑀻𑀮𑁂𑀲𑁆𑀯𑀳𑀁 𑀧𑀭𑀫𑀲𑀼𑀲𑀁𑀯𑀼𑀢𑀸 𑀅𑀳𑀼𑀁, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑀸 𑀦𑀭𑀯𑀭𑀩𑀼𑀤𑁆𑀥𑀤𑁂𑀲𑀺𑀢𑁂 [𑀪𑀸𑀲𑀺𑀢𑁂 (𑀲𑀻.)].

‘‘𑀜𑀢𑁆𑀯𑀸𑀦𑀳𑀁 𑀯𑀺𑀭𑀚𑀧𑀤𑀁 𑀅𑀲𑀗𑁆𑀔𑀢𑀁, 𑀢𑀣𑀸𑀕𑀢𑁂𑀦𑀦𑀥𑀺𑀯𑀭𑁂𑀦 ¶ 𑀤𑁂𑀲𑀺𑀢𑀁;

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

‘‘𑀮𑀤𑁆𑀥𑀸𑀦𑀳𑀁 ¶ 𑀅𑀫𑀢𑀯𑀭𑀁 𑀯𑀺𑀲𑁂𑀲𑀦𑀁, 𑀏𑀓𑀁𑀲𑀺𑀓𑀸 𑀅𑀪𑀺𑀲𑀫𑀬𑁂 𑀯𑀺𑀲𑁂𑀲𑀺𑀬;

𑀅𑀲𑀁𑀲𑀬𑀸 𑀩𑀳𑀼𑀚𑀦𑀧𑀽𑀚𑀺𑀢𑀸 𑀅𑀳𑀁, 𑀔𑀺𑀟𑁆𑀟𑀸𑀭𑀢𑀺𑀁 [𑀔𑀺𑀟𑁆𑀟𑀁 𑀭𑀢𑀺𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀧𑀘𑁆𑀘𑀦𑀼𑀪𑁄𑀫𑀦𑀧𑁆𑀧𑀓𑀁.

‘‘𑀏𑀯𑀁 𑀅𑀳𑀁 𑀅𑀫𑀢𑀤𑀲𑀫𑁆𑀳𑀺 [𑀅𑀫𑀢𑀭𑀲𑀫𑁆𑀳𑀺 (𑀓.)] 𑀤𑁂𑀯𑀢𑀸, 𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲𑀦𑀥𑀺𑀯𑀭𑀲𑁆𑀲 𑀲𑀸𑀯𑀺𑀓𑀸;

𑀥𑀫𑁆𑀫𑀤𑁆𑀤𑀲𑀸 𑀧𑀞𑀫𑀨𑀮𑁂 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸, 𑀲𑁄𑀢𑀸𑀧𑀦𑁆𑀦𑀸 𑀦 𑀘 𑀧𑀦 𑀫𑀢𑁆𑀣𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺.

‘‘𑀲𑀸 𑀯𑀦𑁆𑀤𑀺𑀢𑀼𑀁 𑀅𑀦𑀥𑀺𑀯𑀭𑀁 𑀉𑀧𑀸𑀕𑀫𑀺𑀁, 𑀧𑀸𑀲𑀸𑀤𑀺𑀓𑁂 𑀓𑀼𑀲𑀮𑀭𑀢𑁂 𑀘 𑀪𑀺𑀓𑁆𑀔𑀯𑁄;

𑀦𑀫𑀲𑁆𑀲𑀺𑀢𑀼𑀁 𑀲𑀫𑀡𑀲𑀫𑀸𑀕𑀫𑀁 𑀲𑀺𑀯𑀁, 𑀲𑀕𑀸𑀭𑀯𑀸 𑀲𑀺𑀭𑀺𑀫𑀢𑁄 𑀥𑀫𑁆𑀫𑀭𑀸𑀚𑀺𑀦𑁄.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸 ¶ 𑀫𑀼𑀦𑀺𑀁 𑀫𑀼𑀤𑀺𑀢𑀫𑀦𑀫𑁆𑀳𑀺 𑀧𑀻𑀡𑀺𑀢𑀸, 𑀢𑀣𑀸𑀕𑀢𑀁 𑀦𑀭𑀯𑀭𑀤𑀫𑁆𑀫𑀲𑀸𑀭𑀣𑀺𑀁;

𑀢𑀡𑁆𑀳𑀘𑁆𑀙𑀺𑀤𑀁 𑀓𑀼𑀲𑀮𑀭𑀢𑀁 𑀯𑀺𑀦𑀸𑀬𑀓𑀁, 𑀯𑀦𑁆𑀤𑀸𑀫𑀳𑀁 𑀧𑀭𑀫𑀳𑀺𑀢𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀓’’𑀦𑁆𑀢𑀺.

‘‘𑀇𑀤𑀁 ¶ ¶ ¶ 𑀯𑀺𑀫𑀸𑀦𑀁 𑀭𑀼𑀘𑀺𑀭𑀁 𑀧𑀪𑀲𑁆𑀲𑀭𑀁, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀁 𑀲𑀢𑀢𑀁 𑀲𑀼𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀁;

𑀲𑀼𑀯𑀡𑁆𑀡𑀭𑀼𑀓𑁆𑀔𑁂𑀳𑀺 𑀲𑀫𑀦𑁆𑀢𑀫𑁄𑀢𑁆𑀣𑀢𑀁, 𑀞𑀸𑀦𑀁 𑀫𑀫𑀁 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑀲𑀫𑁆𑀪𑀯𑀁.

‘‘𑀢𑀢𑁆𑀭𑀽𑀧𑀧𑀦𑁆𑀦𑀸 𑀧𑀼𑀭𑀺𑀫𑀘𑁆𑀙𑀭𑀸 𑀇𑀫𑀸, 𑀲𑀢𑀁 𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 𑀲𑀓𑁂𑀦 𑀓𑀫𑁆𑀫𑀼𑀦𑀸;

𑀢𑀼𑀯𑀁𑀲𑀺 𑀅𑀚𑁆𑀛𑀼𑀧𑀕𑀢𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀧𑀼𑀩𑁆𑀩𑀤𑁂𑀯𑀢𑀸.

‘‘𑀲𑀲𑀻 𑀅𑀥𑀺𑀕𑁆𑀕𑀬𑁆𑀳 𑀬𑀣𑀸 𑀯𑀺𑀭𑁄𑀘𑀢𑀺, 𑀦𑀓𑁆𑀔𑀢𑁆𑀢𑀭𑀸𑀚𑀸𑀭𑀺𑀯 𑀢𑀸𑀭𑀓𑀸𑀕𑀡𑀁;

𑀢𑀣𑁂𑀯 𑀢𑁆𑀯𑀁 𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀗𑁆𑀕𑀡𑀁 [𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀗𑁆𑀕𑀫𑀁 (𑀲𑀻.)] 𑀇𑀫𑀁, 𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀸 𑀬𑀲𑀲𑀸 𑀯𑀺𑀭𑁄𑀘𑀲𑀺.

‘‘𑀓𑀼𑀢𑁄 𑀦𑀼 𑀆𑀕𑀫𑁆𑀫 𑀅𑀦𑁄𑀫𑀤𑀲𑁆𑀲𑀦𑁂, 𑀉𑀧𑀧𑀦𑁆𑀦𑀸 𑀢𑁆𑀯𑀁 𑀪𑀯𑀦𑀁 𑀫𑀫𑀁 𑀇𑀤𑀁;

𑀩𑁆𑀭𑀳𑁆𑀫𑀁𑀯 𑀤𑁂𑀯𑀸 𑀢𑀺𑀤𑀲𑀸 𑀲𑀳𑀺𑀦𑁆𑀤𑀓𑀸, 𑀲𑀩𑁆𑀩𑁂 𑀦 𑀢𑀧𑁆𑀧𑀸𑀫𑀲𑁂 𑀤𑀲𑁆𑀲𑀦𑁂𑀦 𑀢’’𑀦𑁆𑀢𑀺.

‘‘𑀬𑀫𑁂𑀢𑀁 𑀲𑀓𑁆𑀓 𑀅𑀦𑀼𑀧𑀼𑀘𑁆𑀙𑀲𑁂 𑀫𑀫𑀁, ‘𑀓𑀼𑀢𑁄 𑀘𑀼𑀢𑀸 𑀢𑁆𑀯𑀁 𑀇𑀥 𑀆𑀕𑀢𑀸’𑀢𑀺 [𑀓𑀼𑀢𑁄 𑀘𑀼𑀢𑀸 𑀇𑀥 𑀆𑀕𑀢𑀸 𑀢𑀼𑀯𑀁 (𑀲𑁆𑀬𑀸.), 𑀓𑀼𑀢𑁄 𑀘𑀼𑀢𑀸𑀬 𑀆𑀕𑀢𑀺 𑀢𑀯 (𑀧𑀻.)];

𑀩𑀸𑀭𑀸𑀡𑀲𑀻 𑀦𑀸𑀫 𑀧𑀼𑀭𑀢𑁆𑀣𑀺 𑀓𑀸𑀲𑀺𑀦𑀁, 𑀢𑀢𑁆𑀣 𑀅𑀳𑁄𑀲𑀺𑀁 𑀧𑀼𑀭𑁂 𑀓𑁂𑀲𑀓𑀸𑀭𑀺𑀓𑀸.

‘‘𑀩𑀼𑀤𑁆𑀥𑁂 ¶ ¶ 𑀘 𑀥𑀫𑁆𑀫𑁂 𑀘 𑀧𑀲𑀦𑁆𑀦𑀫𑀸𑀦𑀲𑀸, 𑀲𑀗𑁆𑀖𑁂 𑀘 𑀏𑀓𑀦𑁆𑀢𑀕𑀢𑀸 𑀅𑀲𑀁𑀲𑀬𑀸;

𑀅𑀔𑀡𑁆𑀟𑀲𑀺𑀓𑁆𑀔𑀸𑀧𑀤𑀸 𑀆𑀕𑀢𑀧𑁆𑀨𑀮𑀸, 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀥𑀫𑁆𑀫𑁂 𑀦𑀺𑀬𑀢𑀸 𑀅𑀦𑀸𑀫𑀬𑀸’’𑀢𑀺.

‘‘𑀢𑀦𑁆𑀢𑁆𑀬𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑀸𑀫𑀲𑁂 𑀲𑁆𑀯𑀸𑀕𑀢𑀜𑁆𑀘 [𑀲𑀸𑀕𑀢𑀜𑁆𑀘 (𑀲𑀻.)] 𑀢𑁂, 𑀥𑀫𑁆𑀫𑁂𑀦 𑀘 𑀢𑁆𑀯𑀁 𑀬𑀲𑀲𑀸 𑀯𑀺𑀭𑁄𑀘𑀲𑀺;

𑀩𑀼𑀤𑁆𑀥𑁂 𑀘 𑀥𑀫𑁆𑀫𑁂 𑀘 𑀧𑀲𑀦𑁆𑀦𑀫𑀸𑀦𑀲𑁂, 𑀲𑀗𑁆𑀖𑁂 𑀘 𑀏𑀓𑀦𑁆𑀢𑀕𑀢𑁂 𑀅𑀲𑀁𑀲𑀬𑁂;

𑀅𑀔𑀡𑁆𑀟𑀲𑀺𑀓𑁆𑀔𑀸𑀧𑀤𑁂 𑀆𑀕𑀢𑀧𑁆𑀨𑀮𑁂, 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀥𑀫𑁆𑀫𑁂 𑀦𑀺𑀬𑀢𑁂 𑀅𑀦𑀸𑀫𑀬𑁂’’𑀢𑀺.

𑀓𑁂𑀲𑀓𑀸𑀭𑀻𑀯𑀺𑀫𑀸𑀦𑀁 𑀲𑀢𑁆𑀢𑀭𑀲𑀫𑀁.

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

𑀧𑀜𑁆𑀘 𑀧𑀻𑀞𑀸 𑀢𑀬𑁄 𑀦𑀸𑀯𑀸, 𑀤𑀻𑀧𑀢𑀺𑀮𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀤𑁆𑀯𑁂;

𑀧𑀢𑀺 𑀤𑁆𑀯𑁂 𑀲𑀼𑀡𑀺𑀲𑀸 𑀉𑀢𑁆𑀢𑀭𑀸, 𑀲𑀺𑀭𑀺𑀫𑀸 𑀓𑁂𑀲𑀓𑀸𑀭𑀺𑀓𑀸;

‘‘𑀅𑀧𑀺 ¶ ¶ 𑀲𑀓𑁆𑀓𑁄𑀯 𑀤𑁂𑀯𑀺𑀦𑁆𑀤𑁄, 𑀭𑀫𑁆𑀫𑁂 𑀘𑀺𑀢𑁆𑀢𑀮𑀢𑀸𑀯𑀦𑁂;

𑀲𑀫𑀦𑁆𑀢𑀸 𑀅𑀦𑀼𑀧𑀭𑀺𑀬𑀸𑀲𑀺, 𑀦𑀸𑀭𑀻𑀕𑀡𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑀸;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 ¶ 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀓𑁂𑀦 𑀢𑁂 𑀇𑀥 𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀘 𑀢𑁂 𑀪𑁄𑀕𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑀸, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑀸 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸, 𑀤𑀸𑀲𑀻 𑀅𑀳𑁄𑀲𑀺𑀁 𑀧𑀭𑀧𑁂𑀲𑁆𑀲𑀺𑀬𑀸 [𑀧𑀭𑀧𑁂𑀲𑀺𑀬𑀸 (𑀓.)] 𑀓𑀼𑀮𑁂.

‘‘𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄;

𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀦𑀺𑀓𑁆𑀓𑀫𑁄 𑀆𑀲𑀺, 𑀲𑀸𑀲𑀦𑁂 𑀢𑀲𑁆𑀲 𑀢𑀸𑀤𑀺𑀦𑁄.

‘‘𑀓𑀸𑀫𑀁 𑀪𑀺𑀚𑁆𑀚𑀢𑀼𑀬𑀁 𑀓𑀸𑀬𑁄, 𑀦𑁂𑀯 𑀅𑀢𑁆𑀣𑁂𑀢𑁆𑀣 𑀲𑀡𑁆𑀞𑀦𑀁 [𑀲𑀦𑁆𑀣𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

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

‘‘𑀅𑀓𑀡𑁆𑀝𑀓𑁄 𑀅𑀕𑀳𑀦𑁄, 𑀉𑀚𑀼 𑀲𑀩𑁆𑀪𑀺 𑀧𑀯𑁂𑀤𑀺𑀢𑁄;

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

‘‘𑀆𑀫𑀦𑁆𑀢𑀦𑀺𑀓𑀸 𑀭𑀜𑁆𑀜𑁄𑀫𑁆𑀳𑀺, 𑀲𑀓𑁆𑀓𑀲𑁆𑀲 𑀯𑀲𑀯𑀢𑁆𑀢𑀺𑀦𑁄;

𑀲𑀝𑁆𑀞𑀺 ¶ 𑀢𑀼𑀭𑀺𑀬 [𑀢𑀼𑀭𑀺𑀬 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀝𑀺𑀩𑁄𑀥𑀁 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀫𑁂.

‘‘𑀆𑀮𑀫𑁆𑀩𑁄 𑀕𑀕𑁆𑀕𑀭𑁄 [𑀕𑀕𑁆𑀕𑀫𑁄 (𑀲𑁆𑀬𑀸.), 𑀪𑀕𑁆𑀕𑀭𑁄 (𑀓.)] 𑀪𑀻𑀫𑁄 [𑀪𑀺𑀫𑁆𑀫𑁄 (𑀓.)], 𑀲𑀸𑀥𑀼𑀯𑀸𑀤𑀻 𑀘 𑀲𑀁𑀲𑀬𑁄;

𑀧𑁄𑀓𑁆𑀔𑀭𑁄 ¶ 𑀘 𑀲𑀼𑀨𑀲𑁆𑀲𑁄 𑀘, 𑀯𑀺𑀡𑀸𑀫𑁄𑀓𑁆𑀔𑀸 [𑀯𑀺𑀮𑀸𑀫𑁄𑀓𑁆𑀔𑀸 (𑀓.)] 𑀘 𑀦𑀸𑀭𑀺𑀬𑁄.

‘‘𑀦𑀦𑁆𑀤𑀸 𑀘𑁂𑀯 𑀲𑀼𑀦𑀦𑁆𑀤𑀸 𑀘, 𑀲𑁄𑀡𑀤𑀺𑀦𑁆𑀦𑀸 𑀲𑀼𑀘𑀺𑀫𑁆𑀳𑀺𑀢𑀸 [𑀲𑀼𑀘𑀺𑀫𑁆𑀪𑀺𑀓𑀸 (𑀲𑁆𑀬𑀸.)];

𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀸 𑀫𑀺𑀲𑁆𑀲𑀓𑁂𑀲𑀻 𑀘, 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀸𑀢𑀺 𑀤𑀸𑀭𑀼𑀡𑀻.

‘‘𑀏𑀡𑀻𑀨𑀲𑁆𑀲𑀸 𑀲𑀼𑀨𑀲𑁆𑀲𑀸 𑀘, 𑀲𑀼𑀪𑀤𑁆𑀤𑀸 𑀫𑀼𑀤𑀼𑀯𑀸𑀤𑀺𑀦𑀻;

𑀏𑀢𑀸 𑀘𑀜𑁆𑀜𑀸 𑀘 𑀲𑁂𑀬𑁆𑀬𑀸𑀲𑁂, 𑀅𑀘𑁆𑀙𑀭𑀸𑀦𑀁 𑀧𑀩𑁄𑀥𑀺𑀓𑀸.

‘‘𑀢𑀸 ¶ 𑀫𑀁 𑀓𑀸𑀮𑁂𑀦𑀼𑀧𑀸𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀅𑀪𑀺𑀪𑀸𑀲𑀦𑁆𑀢𑀺 𑀤𑁂𑀯𑀢𑀸;

𑀳𑀦𑁆𑀤 𑀦𑀘𑁆𑀘𑀸𑀫 𑀕𑀸𑀬𑀸𑀫, 𑀳𑀦𑁆𑀤 𑀢𑀁 𑀭𑀫𑀬𑀸𑀫𑀲𑁂.

‘‘𑀦𑀬𑀺𑀤𑀁 ¶ 𑀅𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁, 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀫𑁂𑀯𑀺𑀤𑀁;

𑀅𑀲𑁄𑀓𑀁 𑀦𑀦𑁆𑀤𑀦𑀁 𑀭𑀫𑁆𑀫𑀁, 𑀢𑀺𑀤𑀲𑀸𑀦𑀁 𑀫𑀳𑀸𑀯𑀦𑀁.

‘‘𑀲𑀼𑀔𑀁 𑀅𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁, 𑀇𑀥 𑀦𑀢𑁆𑀣𑀺 𑀧𑀭𑀢𑁆𑀣 𑀘;

𑀲𑀼𑀔𑀜𑁆𑀘 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁, 𑀇𑀥 𑀘𑁂𑀯 𑀧𑀭𑀢𑁆𑀣 𑀘.

‘‘𑀢𑁂𑀲𑀁 𑀲𑀳𑀩𑁆𑀬𑀓𑀸𑀫𑀸𑀦𑀁, 𑀓𑀢𑁆𑀢𑀩𑁆𑀩𑀁 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼𑀁;

𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸 𑀳𑀺 𑀫𑁄𑀤𑀦𑁆𑀢𑀺, 𑀲𑀕𑁆𑀕𑁂 𑀪𑁄𑀕𑀲𑀫𑀗𑁆𑀕𑀺𑀦𑁄’’𑀢𑀺.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 ¶ 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀓𑁂𑀦 𑀢𑁂 𑀇𑀥 𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀘 𑀢𑁂 𑀪𑁄𑀕𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀤𑁂𑀯𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 𑀓𑀺𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑀸, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸;

𑀧𑀜𑁆𑀳𑀁 ¶ 𑀧𑀼𑀝𑁆𑀞𑀸 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀓𑁂𑀯𑀝𑁆𑀝𑀤𑁆𑀯𑀸𑀭𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫, 𑀅𑀳𑀼 𑀫𑀬𑁆𑀳𑀁 𑀦𑀺𑀯𑁂𑀲𑀦𑀁;

𑀢𑀢𑁆𑀣 𑀲𑀜𑁆𑀘𑀭𑀫𑀸𑀦𑀸𑀦𑀁, 𑀲𑀸𑀯𑀓𑀸𑀦𑀁 𑀫𑀳𑁂𑀲𑀺𑀦𑀁.

‘‘𑀑𑀤𑀦𑀁 𑀓𑀼𑀫𑁆𑀫𑀸𑀲𑀁 [𑀲𑀸𑀓𑀁 (𑀲𑀻.)] 𑀟𑀸𑀓𑀁, 𑀮𑁄𑀡𑀲𑁄𑀯𑀻𑀭𑀓𑀜𑁆𑀘𑀳𑀁;

𑀅𑀤𑀸𑀲𑀺𑀁 𑀉𑀚𑀼𑀪𑀽𑀢𑁂𑀲𑀼, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

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

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

‘‘𑀉𑀧𑁄𑀲𑀣𑀁 ¶ 𑀉𑀧𑀯𑀲𑀺𑀲𑁆𑀲𑀁, 𑀲𑀤𑀸 𑀲𑀻𑀮𑁂𑀲𑀼 𑀲𑀁𑀯𑀼𑀢𑀸;

𑀲𑀜𑁆𑀜𑀫𑀸 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀸 𑀘, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀆𑀯𑀲𑀸𑀫𑀳𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 ¶ 𑀯𑀺𑀭𑀢𑀸, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀸 𑀘 𑀲𑀜𑁆𑀜𑀢𑀸;

𑀣𑁂𑀬𑁆𑀬𑀸 𑀘 𑀅𑀢𑀺𑀘𑀸𑀭𑀸 𑀘, 𑀫𑀚𑁆𑀚𑀧𑀸𑀦𑀸 𑀘 𑀆𑀭𑀓𑀸.

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

𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻𑀢𑀺.

‘‘𑀫𑀫 𑀘, 𑀪𑀦𑁆𑀢𑁂, 𑀯𑀘𑀦𑁂𑀦 𑀪𑀕𑀯𑀢𑁄 𑀧𑀸𑀤𑁂 𑀲𑀺𑀭𑀲𑀸 𑀯𑀦𑁆𑀤𑁂𑀬𑁆𑀬𑀸𑀲𑀺 𑁋 ‘𑀮𑀔𑀼𑀫𑀸 𑀦𑀸𑀫,𑀪𑀦𑁆𑀢𑁂,𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀪𑀕𑀯𑀢𑁄 𑀧𑀸𑀤𑁂 𑀲𑀺𑀭𑀲𑀸 𑀯𑀦𑁆𑀤𑀢𑀻’𑀢𑀺. 𑀅𑀦𑀘𑁆𑀙𑀭𑀺𑀬𑀁 𑀔𑁄 𑀧𑀦𑁂𑀢𑀁, 𑀪𑀦𑁆𑀢𑁂, 𑀬𑀁 𑀫𑀁 𑀪𑀕𑀯𑀸 𑀅𑀜𑁆𑀜𑀢𑀭𑀲𑁆𑀫𑀺𑀁 𑀲𑀸𑀫𑀜𑁆𑀜𑀨𑀮𑁂 𑀩𑁆𑀬𑀸𑀓𑀭𑁂𑀬𑁆𑀬 [𑀩𑁆𑀬𑀸𑀓𑀭𑁂𑀬𑁆𑀬𑀸𑀢𑀺 (?)]. 𑀢𑀁 𑀪𑀕𑀯𑀸 𑀲𑀓𑀤𑀸𑀕𑀸𑀫𑀺𑀨𑀮𑁂 𑀩𑁆𑀬𑀸𑀓𑀸𑀲𑀻’’𑀢𑀺.

𑁩. 𑀆𑀘𑀸𑀫𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀧𑀺𑀡𑁆𑀟𑀸𑀬 ¶ ¶ 𑀢𑁂 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲, 𑀢𑀼𑀡𑁆𑀳𑀻𑀪𑀽𑀢𑀲𑁆𑀲 𑀢𑀺𑀝𑁆𑀞𑀢𑁄;

𑀤𑀮𑀺𑀤𑁆𑀤𑀸 𑀓𑀧𑀡𑀸 𑀦𑀸𑀭𑀻, 𑀧𑀭𑀸𑀕𑀸𑀭𑀁 𑀅𑀧𑀲𑁆𑀲𑀺𑀢𑀸 [𑀅𑀯𑀲𑁆𑀲𑀺𑀢𑀸 (𑀲𑀻.)].

‘‘𑀬𑀸 𑀢𑁂 𑀅𑀤𑀸𑀲𑀺 𑀆𑀘𑀸𑀫𑀁, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺;

𑀲𑀸 𑀳𑀺𑀢𑁆𑀯𑀸 𑀫𑀸𑀦𑀼𑀲𑀁 𑀤𑁂𑀳𑀁, 𑀓𑀁 𑀦𑀼 𑀲𑀸 𑀤𑀺𑀲𑀢𑀁 𑀕𑀢𑀸’’𑀢𑀺.

‘‘𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀫𑁂 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲, 𑀢𑀼𑀡𑁆𑀳𑀻𑀪𑀽𑀢𑀲𑁆𑀲 𑀢𑀺𑀝𑁆𑀞𑀢𑁄;

𑀤𑀮𑀺𑀤𑁆𑀤𑀸 𑀓𑀧𑀡𑀸 𑀦𑀸𑀭𑀻, 𑀧𑀭𑀸𑀕𑀸𑀭𑀁 𑀅𑀧𑀲𑁆𑀲𑀺𑀢𑀸.

‘‘𑀬𑀸 𑀫𑁂 𑀅𑀤𑀸𑀲𑀺 𑀆𑀘𑀸𑀫𑀁, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺;

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

‘‘𑀦𑀺𑀫𑁆𑀫𑀸𑀦𑀭𑀢𑀺𑀦𑁄 𑀦𑀸𑀫, 𑀲𑀦𑁆𑀢𑀺 𑀤𑁂𑀯𑀸 𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑀸;

𑀢𑀢𑁆𑀣 𑀲𑀸 𑀲𑀼𑀔𑀺𑀢𑀸 𑀦𑀸𑀭𑀻, 𑀫𑁄𑀤𑀢𑀸𑀘𑀸𑀫𑀤𑀸𑀬𑀺𑀓𑀸’’𑀢𑀺.

‘‘𑀅𑀳𑁄 ¶ 𑀤𑀸𑀦𑀁 𑀯𑀭𑀸𑀓𑀺𑀬𑀸, 𑀓𑀲𑁆𑀲𑀧𑁂 𑀲𑀼𑀧𑁆𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀁;

𑀧𑀭𑀸𑀪𑀢𑁂𑀦 𑀤𑀸𑀦𑁂𑀦, 𑀇𑀚𑁆𑀛𑀺𑀢𑁆𑀣 𑀯𑀢 𑀤𑀓𑁆𑀔𑀺𑀡𑀸.

‘‘𑀬𑀸 𑀫𑀳𑁂𑀲𑀺𑀢𑁆𑀢𑀁 𑀓𑀸𑀭𑁂𑀬𑁆𑀬, 𑀘𑀓𑁆𑀓𑀯𑀢𑁆𑀢𑀺𑀲𑁆𑀲 𑀭𑀸𑀚𑀺𑀦𑁄;

𑀦𑀸𑀭𑀻 𑀲𑀩𑁆𑀩𑀗𑁆𑀕𑀓𑀮𑁆𑀬𑀸𑀡𑀻, 𑀪𑀢𑁆𑀢𑀼 𑀘𑀸𑀦𑁄𑀫𑀤𑀲𑁆𑀲𑀺𑀓𑀸;

𑀏𑀢𑀲𑁆𑀲𑀸𑀘𑀸𑀫𑀤𑀸𑀦𑀲𑁆𑀲 ¶ , 𑀓𑀮𑀁 𑀦𑀸𑀕𑁆𑀖𑀢𑀺 𑀲𑁄𑀴𑀲𑀺𑀁.

‘‘𑀲𑀢𑀁 ¶ 𑀦𑀺𑀓𑁆𑀔𑀸 𑀲𑀢𑀁 𑀅𑀲𑁆𑀲𑀸, 𑀲𑀢𑀁 𑀅𑀲𑁆𑀲𑀢𑀭𑀻𑀭𑀣𑀸;

𑀲𑀢𑀁 𑀓𑀜𑁆𑀜𑀸𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀸;

𑀏𑀢𑀲𑁆𑀲𑀸𑀘𑀸𑀫𑀤𑀸𑀦𑀲𑁆𑀲, 𑀓𑀮𑀁 𑀦𑀸𑀕𑁆𑀖𑀦𑁆𑀢𑀺 𑀲𑁄𑀴𑀲𑀺𑀁.

‘‘𑀲𑀢𑀁 𑀳𑁂𑀫𑀯𑀢𑀸 𑀦𑀸𑀕𑀸, 𑀈𑀲𑀸𑀤𑀦𑁆𑀢𑀸 𑀉𑀭𑀽𑀴𑁆𑀳𑀯𑀸;

𑀲𑀼𑀯𑀡𑁆𑀡𑀓𑀘𑁆𑀙𑀸 𑀫𑀸𑀢𑀗𑁆𑀕𑀸, 𑀳𑁂𑀫𑀓𑀧𑁆𑀧𑀦𑀯𑀸𑀲𑀲𑀸 [𑀳𑁂𑀫𑀓𑀧𑁆𑀧𑀦𑀺𑀯𑀸𑀲𑀲𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀏𑀢𑀲𑁆𑀲𑀸𑀘𑀸𑀫𑀤𑀸𑀦𑀲𑁆𑀲, 𑀓𑀮𑀁 𑀦𑀸𑀕𑁆𑀖𑀢𑀺 𑀲𑁄𑀴𑀲𑀺𑀁.

‘‘𑀘𑀢𑀼𑀦𑁆𑀦𑀫𑀧𑀺 ¶ 𑀤𑀻𑀧𑀸𑀦𑀁, 𑀇𑀲𑁆𑀲𑀭𑀁 𑀬𑁄𑀥 𑀓𑀸𑀭𑀬𑁂;

𑀏𑀢𑀲𑁆𑀲𑀸𑀘𑀸𑀫𑀤𑀸𑀦𑀲𑁆𑀲, 𑀓𑀮𑀁 𑀦𑀸𑀕𑁆𑀖𑀢𑀺 𑀲𑁄𑀴𑀲𑀺’’𑀦𑁆𑀢𑀺.

𑀆𑀘𑀸𑀫𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀢𑀢𑀺𑀬𑀁.

‘‘𑀘𑀡𑁆𑀟𑀸𑀮𑀺 𑀯𑀦𑁆𑀤 𑀧𑀸𑀤𑀸𑀦𑀺, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄;

𑀢𑀫𑁂𑀯 [𑀢𑀯𑁂𑀯 (𑀲𑀻.)] 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀸𑀬, 𑀅𑀝𑁆𑀞𑀸𑀲𑀺 𑀇𑀲𑀺𑀲𑀢𑁆𑀢𑀫𑁄 [𑀇𑀲𑀺𑀲𑀼𑀢𑁆𑀢𑀫𑁄 (𑀲𑀻.)].

‘‘𑀅𑀪𑀺𑀧𑁆𑀧𑀲𑀸𑀤𑁂𑀳𑀺 𑀫𑀦𑀁, 𑀅𑀭𑀳𑀦𑁆𑀢𑀫𑁆𑀳𑀺 𑀢𑀸𑀤𑀺𑀦𑀺 [𑀢𑀸𑀤𑀺𑀦𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀔𑀺𑀧𑁆𑀧𑀁 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀯𑀦𑁆𑀤, 𑀧𑀭𑀺𑀢𑁆𑀢𑀁 𑀢𑀯 𑀚𑀻𑀯𑀺𑀢’’𑀦𑁆𑀢𑀺.

𑀘𑁄𑀤𑀺𑀢𑀸 𑀪𑀸𑀯𑀺𑀢𑀢𑁆𑀢𑁂𑀦, 𑀲𑀭𑀻𑀭𑀦𑁆𑀢𑀺𑀫𑀥𑀸𑀭𑀺𑀦𑀸;

𑀘𑀡𑁆𑀟𑀸𑀮𑀻 𑀯𑀦𑁆𑀤𑀺 𑀧𑀸𑀤𑀸𑀦𑀺, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

𑀢𑀫𑁂𑀦𑀁 𑀅𑀯𑀥𑀻 𑀕𑀸𑀯𑀻, 𑀘𑀡𑁆𑀟𑀸𑀮𑀺𑀁 𑀧𑀜𑁆𑀚𑀮𑀺𑀁 𑀞𑀺𑀢𑀁;

𑀦𑀫𑀲𑁆𑀲𑀫𑀸𑀦𑀁 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁, 𑀅𑀦𑁆𑀥𑀓𑀸𑀭𑁂 𑀧𑀪𑀗𑁆𑀓𑀭𑀦𑁆𑀢𑀺.

‘‘𑀔𑀻𑀡𑀸𑀲𑀯𑀁 ¶ 𑀯𑀺𑀕𑀢𑀭𑀚𑀁 𑀅𑀦𑁂𑀚𑀁, 𑀏𑀓𑀁 𑀅𑀭𑀜𑁆𑀜𑀫𑁆𑀳𑀺 𑀭𑀳𑁄 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁;

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

‘‘𑀲𑀼𑀯𑀡𑁆𑀡𑀯𑀡𑁆𑀡𑀸 𑀚𑀮𑀺𑀢𑀸 𑀫𑀳𑀸𑀬𑀲𑀸, 𑀯𑀺𑀫𑀸𑀦𑀫𑁄𑀭𑀼𑀬𑁆𑀳 𑀅𑀦𑁂𑀓𑀘𑀺𑀢𑁆𑀢𑀸;

𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑀸 𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀗𑁆𑀕𑀡𑁂𑀦 [𑀅𑀘𑁆𑀙𑀭𑀸𑀦𑀁 𑀕𑀡𑁂𑀦 (𑀲𑀻.)], 𑀓𑀸 𑀢𑁆𑀯𑀁 𑀲𑀼𑀪𑁂 𑀤𑁂𑀯𑀢𑁂 𑀯𑀦𑁆𑀤𑀲𑁂 𑀫𑀫’’𑀦𑁆𑀢𑀺.

‘‘𑀅𑀳𑀁 ¶ 𑀪𑀤𑁆𑀤𑀦𑁆𑀢𑁂 𑀘𑀡𑁆𑀟𑀸𑀮𑀻, 𑀢𑀬𑀸 𑀯𑀻𑀭𑁂𑀦 [𑀣𑁂𑀭𑁂𑀦 (𑀓.)] 𑀧𑁂𑀲𑀺𑀢𑀸;

𑀯𑀦𑁆𑀤𑀺𑀁 ¶ 𑀅𑀭𑀳𑀢𑁄 𑀧𑀸𑀤𑁂, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

‘‘𑀲𑀸𑀳𑀁 𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸 [𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯 (𑀲𑀻.)] 𑀧𑀸𑀤𑀸𑀦𑀺, 𑀘𑀼𑀢𑀸 𑀘𑀡𑁆𑀟𑀸𑀮𑀬𑁄𑀦𑀺𑀬𑀸;

𑀯𑀺𑀫𑀸𑀦𑀁 𑀲𑀩𑁆𑀩𑀢𑁄 𑀪𑀤𑁆𑀤𑀁, 𑀉𑀧𑀧𑀦𑁆𑀦𑀫𑁆𑀳𑀺 𑀦𑀦𑁆𑀤𑀦𑁂.

‘‘𑀅𑀘𑁆𑀙𑀭𑀸𑀦𑀁 ¶ 𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀁, 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁆𑀯𑀸𑀦 [𑀧𑀼𑀭𑀓𑁆𑀔𑀺𑀢𑁆𑀯𑀸 𑀫𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀢𑀺𑀝𑁆𑀞𑀢𑀺;

𑀢𑀸𑀲𑀸𑀳𑀁 𑀧𑀯𑀭𑀸 𑀲𑁂𑀝𑁆𑀞𑀸, 𑀯𑀡𑁆𑀡𑁂𑀦 𑀬𑀲𑀲𑀸𑀬𑀼𑀦𑀸.

‘‘𑀧𑀳𑀽𑀢𑀓𑀢𑀓𑀮𑁆𑀬𑀸𑀡𑀸, 𑀲𑀫𑁆𑀧𑀚𑀸𑀦𑀸 𑀧𑀝𑀺𑀲𑁆𑀲𑀢𑀸 [𑀧𑀢𑀺𑀲𑁆𑀲𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)];

𑀫𑀼𑀦𑀺𑀁 𑀓𑀸𑀭𑀼𑀡𑀺𑀓𑀁 𑀮𑁄𑀓𑁂, 𑀢𑀁 𑀪𑀦𑁆𑀢𑁂 𑀯𑀦𑁆𑀤𑀺𑀢𑀼𑀫𑀸𑀕𑀢𑀸’’𑀢𑀺.

𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀘𑀡𑁆𑀟𑀸𑀮𑀻, 𑀓𑀢𑀜𑁆𑀜𑀽 𑀓𑀢𑀯𑁂𑀤𑀺𑀦𑀻;

𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸 𑀅𑀭𑀳𑀢𑁄 𑀧𑀸𑀤𑁂, 𑀢𑀢𑁆𑀣𑁂𑀯𑀦𑁆𑀢𑀭𑀥𑀸𑀬𑀣𑀸𑀢𑀺 [𑀢𑀢𑁆𑀣𑁂𑀯𑀦𑁆𑀢𑀭𑀥𑀸𑀬𑀢𑀻𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑀘𑀡𑁆𑀟𑀸𑀮𑀺𑀯𑀺𑀫𑀸𑀦𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

𑁫. 𑀪𑀤𑁆𑀤𑀺𑀢𑁆𑀣𑀺𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀦𑀻𑀮𑀸 𑀧𑀻𑀢𑀸 𑀘 𑀓𑀸𑀴𑀸 𑀘, 𑀫𑀜𑁆𑀚𑀺𑀝𑁆𑀞𑀸 [𑀫𑀜𑁆𑀚𑁂𑀝𑁆𑀞𑀸 (𑀲𑀻.), 𑀫𑀜𑁆𑀚𑀝𑁆𑀞𑀸 (𑀧𑀻.)] 𑀅𑀣 𑀮𑁄𑀳𑀺𑀢𑀸;

𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑀸𑀦𑀁 𑀯𑀡𑁆𑀡𑀸𑀦𑀁, 𑀓𑀺𑀜𑁆𑀚𑀓𑁆𑀔𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑀸.

‘‘𑀫𑀦𑁆𑀤𑀸𑀭𑀯𑀸𑀦𑀁 𑀧𑀼𑀧𑁆𑀨𑀸𑀦𑀁, 𑀫𑀸𑀮𑀁 𑀥𑀸𑀭𑁂𑀲𑀺 𑀫𑀼𑀤𑁆𑀥𑀦𑀺;

𑀦𑀬𑀺𑀫𑁂 𑀅𑀜𑁆𑀜𑁂𑀲𑀼 𑀓𑀸𑀬𑁂𑀲𑀼, 𑀭𑀼𑀓𑁆𑀔𑀸 𑀲𑀦𑁆𑀢𑀺 𑀲𑀼𑀫𑁂𑀥𑀲𑁂.

‘‘𑀓𑁂𑀦 ¶ ¶ 𑀓𑀸𑀬𑀁 𑀉𑀧𑀧𑀦𑁆𑀦𑀸, 𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑀁 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀪𑀤𑁆𑀤𑀺𑀢𑁆𑀣𑀺𑀓𑀸𑀢𑀺 [𑀪𑀤𑁆𑀤𑀺𑀢𑁆𑀣𑀻𑀢𑀺 (𑀲𑀻.)] 𑀫𑀁 𑀅𑀜𑁆𑀜𑀁𑀲𑀼, 𑀓𑀺𑀫𑀺𑀮𑀸𑀬𑀁 𑀉𑀧𑀸𑀲𑀺𑀓𑀸;

𑀲𑀤𑁆𑀥𑀸 𑀲𑀻𑀮𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀭𑀢𑀸 𑀲𑀤𑀸.

‘‘𑀅𑀘𑁆𑀙𑀸𑀤𑀦𑀜𑁆𑀘 𑀪𑀢𑁆𑀢𑀜𑁆𑀘, 𑀲𑁂𑀦𑀸𑀲𑀦𑀁 𑀧𑀤𑀻𑀧𑀺𑀬𑀁;

𑀅𑀤𑀸𑀲𑀺𑀁 𑀉𑀚𑀼𑀪𑀽𑀢𑁂𑀲𑀼, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

‘‘𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀲𑀺𑀁 ¶ 𑀧𑀜𑁆𑀘𑀤𑀲𑀺𑀁, 𑀬𑀸 𑀘 𑀧𑀓𑁆𑀔𑀲𑁆𑀲 𑀅𑀝𑁆𑀞𑀫𑀻;

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

‘‘𑀉𑀧𑁄𑀲𑀣𑀁 𑀉𑀧𑀯𑀲𑀺𑀲𑁆𑀲𑀁, 𑀲𑀤𑀸 𑀲𑀻𑀮𑁂𑀲𑀼 𑀲𑀁𑀯𑀼𑀢𑀸;

𑀲𑀜𑁆𑀜𑀫𑀸 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀸 𑀘, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀆𑀯𑀲𑀸𑀫𑀳𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀢𑀸, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀸 𑀘 𑀲𑀜𑁆𑀜𑀢𑀸;

𑀣𑁂𑀬𑁆𑀬𑀸 𑀘 𑀅𑀢𑀺𑀘𑀸𑀭𑀸 𑀘, 𑀫𑀚𑁆𑀚𑀧𑀸𑀦𑀸 𑀘 𑀆𑀭𑀓𑀸.

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

𑀉𑀧𑀸𑀲𑀺𑀓𑀸 ¶ 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄, 𑀅𑀧𑁆𑀧𑀫𑀸𑀤𑀯𑀺𑀳𑀸𑀭𑀺𑀦𑀻.

𑀓𑀢𑀸𑀯𑀸𑀲𑀸 𑀓𑀢𑀓𑀼𑀲𑀮𑀸 𑀢𑀢𑁄 𑀘𑀼𑀢𑀸 [𑀓𑀢𑀸𑀯𑀓𑀸𑀲𑀸 𑀓𑀢𑀓𑀼𑀲𑀮𑀸 (𑀓.)],

𑀲𑀬𑀁 𑀧𑀪𑀸 𑀅𑀦𑀼𑀯𑀺𑀘𑀭𑀸𑀫𑀺 𑀦𑀦𑁆𑀤𑀦𑀁.

‘‘𑀪𑀺𑀓𑁆𑀔𑀽 𑀘𑀸𑀳𑀁 𑀧𑀭𑀫𑀳𑀺𑀢𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑁂, 𑀅𑀪𑁄𑀚𑀬𑀺𑀁 𑀢𑀧𑀲𑁆𑀲𑀺𑀬𑀼𑀕𑀁 𑀫𑀳𑀸𑀫𑀼𑀦𑀺𑀁;

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

‘‘𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑀺𑀓𑀁 𑀅𑀧𑀭𑀺𑀫𑀺𑀢𑀁 𑀲𑀼𑀔𑀸𑀯𑀳𑀁, 𑀉𑀧𑁄𑀲𑀣𑀁 𑀲𑀢𑀢𑀫𑀼𑀧𑀸𑀯𑀲𑀺𑀁 𑀅𑀳𑀁;

𑀓𑀢𑀸𑀯𑀸𑀲𑀸 𑀓𑀢𑀓𑀼𑀲𑀮𑀸 𑀢𑀢𑁄 𑀘𑀼𑀢𑀸 [𑀓𑀢𑀸𑀯𑀓𑀸𑀲𑀸 𑀓𑀢𑀓𑀼𑀲𑀮𑀸 (𑀓.)], 𑀲𑀬𑀁 𑀧𑀪𑀸 𑀅𑀦𑀼𑀯𑀺𑀘𑀭𑀸𑀫𑀺 𑀦𑀦𑁆𑀤𑀦’’𑀦𑁆𑀢𑀺.

𑀪𑀤𑁆𑀤𑀺𑀢𑁆𑀣𑀺𑀯𑀺𑀫𑀸𑀦𑀁 [𑀪𑀤𑁆𑀤𑀺𑀢𑁆𑀣𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀁 (𑀲𑁆𑀬𑀸.)] 𑀧𑀜𑁆𑀘𑀫𑀁.

𑁬. 𑀲𑁄𑀡𑀤𑀺𑀦𑁆𑀦𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 ¶ ¶ 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 ¶ 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀓𑁂𑀦 𑀢𑁂 𑀇𑀥 𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀘 𑀢𑁂 𑀪𑁄𑀕𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀤𑁂𑀯𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 𑀓𑀺𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑀸, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑀸 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀲𑁄𑀡𑀤𑀺𑀦𑁆𑀦𑀸𑀢𑀺 𑀫𑀁 𑀅𑀜𑁆𑀜𑀁𑀲𑀼, 𑀦𑀸𑀴𑀦𑁆𑀤𑀸𑀬𑀁 𑀉𑀧𑀸𑀲𑀺𑀓𑀸;

𑀲𑀤𑁆𑀥𑀸 𑀲𑀻𑀮𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀭𑀢𑀸 𑀲𑀤𑀸.

‘‘𑀅𑀘𑁆𑀙𑀸𑀤𑀦𑀜𑁆𑀘 𑀪𑀢𑁆𑀢𑀜𑁆𑀘, 𑀲𑁂𑀦𑀸𑀲𑀦𑀁 𑀧𑀤𑀻𑀧𑀺𑀬𑀁;

𑀅𑀤𑀸𑀲𑀺𑀁 𑀉𑀚𑀼𑀪𑀽𑀢𑁂𑀲𑀼, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

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

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

‘‘𑀉𑀧𑁄𑀲𑀣𑀁 𑀉𑀧𑀯𑀲𑀺𑀲𑁆𑀲𑀁, 𑀲𑀤𑀸 𑀲𑀻𑀮𑁂𑀲𑀼 𑀲𑀁𑀯𑀼𑀢𑀸;

𑀲𑀜𑁆𑀜𑀫𑀸 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀸 𑀘, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀆𑀯𑀲𑀸𑀫𑀳𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀢𑀸, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀸 𑀘 𑀲𑀜𑁆𑀜𑀢𑀸;

𑀣𑁂𑀬𑁆𑀬𑀸 𑀘 𑀅𑀢𑀺𑀘𑀸𑀭𑀸 𑀘, 𑀫𑀚𑁆𑀚𑀧𑀸𑀦𑀸 𑀘 𑀆𑀭𑀓𑀸.

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

𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 ¶ 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄𑀡𑀤𑀺𑀦𑁆𑀦𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀙𑀝𑁆𑀞𑀁.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 ¶ ¶ 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀉𑀧𑁄𑀲𑀣𑀸𑀢𑀺 𑀫𑀁 𑀅𑀜𑁆𑀜𑀁𑀲𑀼, 𑀲𑀸𑀓𑁂𑀢𑀸𑀬𑀁 𑀉𑀧𑀸𑀲𑀺𑀓𑀸;

𑀲𑀤𑁆𑀥𑀸 𑀲𑀻𑀮𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀭𑀢𑀸 𑀲𑀤𑀸.

‘‘𑀅𑀘𑁆𑀙𑀸𑀤𑀦𑀜𑁆𑀘 𑀪𑀢𑁆𑀢𑀜𑁆𑀘, 𑀲𑁂𑀦𑀸𑀲𑀦𑀁 𑀧𑀤𑀻𑀧𑀺𑀬𑀁;

𑀅𑀤𑀸𑀲𑀺𑀁 𑀉𑀚𑀼𑀪𑀽𑀢𑁂𑀲𑀼, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

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

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

‘‘𑀉𑀧𑁄𑀲𑀣𑀁 𑀉𑀧𑀯𑀲𑀺𑀲𑁆𑀲𑀁, 𑀲𑀤𑀸 𑀲𑀻𑀮𑁂𑀲𑀼 𑀲𑀁𑀯𑀼𑀢𑀸;

𑀲𑀜𑁆𑀜𑀫𑀸 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀸 𑀘, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀆𑀯𑀲𑀸𑀫𑀳𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀢𑀸, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀸 𑀘 𑀲𑀜𑁆𑀜𑀢𑀸;

𑀣𑁂𑀬𑁆𑀬𑀸 𑀘 𑀅𑀢𑀺𑀘𑀸𑀭𑀸 𑀘, 𑀫𑀚𑁆𑀚𑀧𑀸𑀦𑀸 𑀘 𑀆𑀭𑀓𑀸.

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

𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 ¶ 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀅𑀪𑀺𑀓𑁆𑀔𑀡𑀁 ¶ 𑀦𑀦𑁆𑀤𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀙𑀦𑁆𑀤𑁄 𑀫𑁂 𑀉𑀤𑀧𑀚𑁆𑀚𑀣 [𑀉𑀧𑀧𑀚𑁆𑀚𑀣 (𑀩𑀳𑀽𑀲𑀼)];

𑀢𑀢𑁆𑀣 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀡𑀺𑀥𑀸𑀬, 𑀉𑀧𑀧𑀦𑁆𑀦𑀫𑁆𑀳𑀺 𑀦𑀦𑁆𑀤𑀦𑀁.

‘‘𑀦𑀸𑀓𑀸𑀲𑀺𑀁 ¶ 𑀲𑀢𑁆𑀣𑀼 𑀯𑀘𑀦𑀁, 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲𑀸𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼𑀦𑁄;

𑀳𑀻𑀦𑁂 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀡𑀺𑀥𑀸𑀬, 𑀲𑀸𑀫𑁆𑀳𑀺 𑀧𑀘𑁆𑀙𑀸𑀦𑀼𑀢𑀸𑀧𑀺𑀦𑀻’’𑀢𑀺.

‘‘𑀓𑀻𑀯 𑀘𑀺𑀭𑀁 𑀯𑀺𑀫𑀸𑀦𑀫𑁆𑀳𑀺, 𑀇𑀥 𑀯𑀘𑁆𑀙𑀲𑀼𑀧𑁄𑀲𑀣𑁂 [𑀯𑀲𑁆𑀲𑀲𑀼𑀧𑁄𑀲𑀣𑁂 (𑀲𑀻.)];

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀬𑀤𑀺 𑀚𑀸𑀦𑀸𑀲𑀺 𑀆𑀬𑀼𑀦𑁄’’𑀢𑀺.

‘‘𑀲𑀝𑁆𑀞𑀺𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 ¶ [𑀲𑀝𑁆𑀞𑀺 𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 (?)], 𑀢𑀺𑀲𑁆𑀲𑁄 𑀘 𑀯𑀲𑁆𑀲𑀓𑁄𑀝𑀺𑀬𑁄;

𑀇𑀥 𑀞𑀢𑁆𑀯𑀸 𑀫𑀳𑀸𑀫𑀼𑀦𑀺, 𑀇𑀢𑁄 𑀘𑀼𑀢𑀸 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺;

𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁 𑀲𑀳𑀩𑁆𑀬𑀢’’𑀦𑁆𑀢𑀺.

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

𑀲𑁄𑀢𑀸𑀧𑀦𑁆𑀦𑀸 𑀯𑀺𑀲𑁂𑀲𑀬𑀺, 𑀧𑀳𑀻𑀦𑀸 𑀢𑀯 𑀤𑀼𑀕𑁆𑀕𑀢𑀻’’𑀢𑀺.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀦𑀺𑀤𑁆𑀤𑀸𑀢𑀺 [𑀲𑀤𑁆𑀥𑀸𑀢𑀺 (𑀲𑀻.)] 𑀫𑀫𑀁 𑀅𑀜𑁆𑀜𑀁𑀲𑀼, 𑀭𑀸𑀚𑀕𑀳𑀲𑁆𑀫𑀺𑀁 𑀉𑀧𑀸𑀲𑀺𑀓𑀸;

𑀲𑀤𑁆𑀥𑀸 𑀲𑀻𑀮𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀭𑀢𑀸 𑀲𑀤𑀸.

‘‘𑀅𑀘𑁆𑀙𑀸𑀤𑀦𑀜𑁆𑀘 ¶ ¶ 𑀪𑀢𑁆𑀢𑀜𑁆𑀘, 𑀲𑁂𑀦𑀸𑀲𑀦𑀁 𑀧𑀤𑀻𑀧𑀺𑀬𑀁;

𑀅𑀤𑀸𑀲𑀺𑀁 𑀉𑀚𑀼𑀪𑀽𑀢𑁂𑀲𑀼, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

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

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

‘‘𑀉𑀧𑁄𑀲𑀣𑀁 𑀉𑀧𑀯𑀲𑀺𑀲𑁆𑀲𑀁, 𑀲𑀤𑀸 𑀲𑀻𑀮𑁂𑀲𑀼 𑀲𑀁𑀯𑀼𑀢𑀸;

𑀲𑀜𑁆𑀜𑀫𑀸 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀸 𑀘, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀆𑀯𑀲𑀸𑀫𑀳𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 ¶ 𑀯𑀺𑀭𑀢𑀸, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀸 𑀘 𑀲𑀜𑁆𑀜𑀢𑀸;

𑀣𑁂𑀬𑁆𑀬𑀸 𑀘 𑀅𑀢𑀺𑀘𑀸𑀭𑀸 𑀘, 𑀫𑀚𑁆𑀚𑀧𑀸𑀦𑀸 𑀘 𑀆𑀭𑀓𑀸.

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

𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀦𑀺𑀤𑁆𑀤𑀸𑀯𑀺𑀫𑀸𑀦𑀁 [𑀲𑀤𑁆𑀥𑀸𑀯𑀺𑀫𑀸𑀦𑀁 (𑀲𑀻.)] 𑀅𑀝𑁆𑀞𑀫𑀁.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀲𑀼𑀦𑀺𑀤𑁆𑀤𑀸𑀢𑀺 ¶ [𑀲𑀼𑀦𑀦𑁆𑀤𑀸𑀢𑀺 (𑀲𑀻.)] 𑀫𑀁 𑀅𑀜𑁆𑀜𑀁𑀲𑀼, 𑀭𑀸𑀚𑀕𑀳𑀲𑁆𑀫𑀺𑀁 𑀉𑀧𑀸𑀲𑀺𑀓𑀸;

𑀲𑀤𑁆𑀥𑀸 𑀲𑀻𑀮𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀭𑀢𑀸 𑀲𑀤𑀸.

(𑀬𑀣𑀸 𑀦𑀺𑀤𑁆𑀤𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀢𑀣𑀸 𑀯𑀺𑀢𑁆𑀣𑀸𑀭𑁂𑀢𑀩𑁆𑀩𑀁.)

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

𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁧𑁦. 𑀧𑀞𑀫𑀪𑀺𑀓𑁆𑀔𑀸𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 ¶ 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 ¶ 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸, 𑀧𑀼𑀭𑀺𑀫𑀸𑀬 𑀚𑀸𑀢𑀺𑀬𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂.

‘‘𑀅𑀤𑁆𑀤𑀲𑀁 ¶ ¶ 𑀯𑀺𑀭𑀚𑀁 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀫𑀦𑀸𑀯𑀺𑀮𑀁;

𑀢𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀳𑀁 𑀪𑀺𑀓𑁆𑀔𑀁, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀧𑀞𑀫𑀪𑀺𑀓𑁆𑀔𑀸𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀤𑀲𑀫𑀁.

𑁧𑁧. 𑀤𑀼𑀢𑀺𑀬𑀪𑀺𑀓𑁆𑀔𑀸𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸, 𑀧𑀼𑀭𑀺𑀫𑀸𑀬 𑀚𑀸𑀢𑀺𑀬𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂.

‘‘𑀅𑀤𑁆𑀤𑀲𑀁 𑀯𑀺𑀭𑀚𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀁, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀫𑀦𑀸𑀯𑀺𑀮𑀁;

𑀢𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀳𑀁 𑀪𑀺𑀓𑁆𑀔𑀁, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂. ¶ … 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀤𑀼𑀢𑀺𑀬𑀪𑀺𑀓𑁆𑀔𑀸𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀏𑀓𑀸𑀤𑀲𑀫𑀁.

𑀘𑀺𑀢𑁆𑀢𑀮𑀢𑀸𑀯𑀕𑁆𑀕𑁄 𑀤𑀼𑀢𑀺𑀬𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀤𑀸𑀲𑀻 ¶ 𑀘𑁂𑀯 𑀮𑀔𑀼𑀫𑀸 𑀘, 𑀅𑀣 𑀆𑀘𑀸𑀫𑀤𑀸𑀬𑀺𑀓𑀸;

𑀘𑀡𑁆𑀟𑀸𑀮𑀻 ¶ 𑀪𑀤𑁆𑀤𑀺𑀢𑁆𑀣𑀻 𑀘𑁂𑀯 [𑀪𑀤𑁆𑀤𑀺𑀢𑁆𑀣𑀺𑀓𑀸 𑀘 (𑀲𑁆𑀬𑀸.)], 𑀲𑁄𑀡𑀤𑀺𑀦𑁆𑀦𑀸 𑀉𑀧𑁄𑀲𑀣𑀸;

𑀦𑀺𑀤𑁆𑀤𑀸 𑀘𑁂𑀯 𑀲𑀼𑀦𑀺𑀤𑁆𑀤𑀸 𑀘 [𑀦𑀦𑁆𑀤𑀸 𑀘𑁂𑀯 𑀲𑀼𑀦𑀦𑁆𑀤𑀸 𑀘 (𑀲𑀻.)], 𑀤𑁆𑀯𑁂 𑀘 𑀪𑀺𑀓𑁆𑀔𑀸𑀬 𑀤𑀸𑀬𑀺𑀓𑀸;

‘‘𑀉𑀴𑀸𑀭𑁄 ¶ ¶ 𑀢𑁂 𑀬𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀲𑀩𑁆𑀩𑀸 𑀑𑀪𑀸𑀲𑀢𑁂 𑀤𑀺𑀲𑀸;

𑀦𑀸𑀭𑀺𑀬𑁄 𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀕𑀸𑀬𑀦𑁆𑀢𑀺, 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑀸 𑀅𑀮𑀗𑁆𑀓𑀢𑀸.

‘‘𑀫𑁄𑀤𑁂𑀦𑁆𑀢𑀺 𑀧𑀭𑀺𑀯𑀸𑀭𑁂𑀦𑁆𑀢𑀺, 𑀢𑀯 𑀧𑀽𑀚𑀸𑀬 𑀤𑁂𑀯𑀢𑁂;

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

‘‘𑀢𑀼𑀯𑀁𑀲𑀺 𑀇𑀲𑁆𑀲𑀭𑀸 𑀢𑁂𑀲𑀁, 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀦𑀻;

𑀅𑀪𑀺𑀚𑀸𑀢𑀸 𑀫𑀳𑀦𑁆𑀢𑀸𑀲𑀺, 𑀤𑁂𑀯𑀓𑀸𑀬𑁂 𑀧𑀫𑁄𑀤𑀲𑀺;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

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

𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑀓𑀼𑀮𑁂 𑀲𑀼𑀡𑀺𑀲𑀸 𑀅𑀳𑁄𑀲𑀺𑀁, 𑀅𑀲𑁆𑀲𑀤𑁆𑀥𑁂𑀲𑀼 𑀓𑀤𑀭𑀺𑀬𑁂𑀲𑀼 𑀅𑀳𑀁.

‘‘𑀲𑀤𑁆𑀥𑀸 𑀲𑀻𑀮𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀭𑀢𑀸 𑀲𑀤𑀸;

𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀫𑀸𑀦𑀲𑁆𑀲, 𑀅𑀧𑀽𑀯𑀁 𑀢𑁂 𑀅𑀤𑀸𑀲𑀳𑀁.

‘‘𑀢𑀤𑀸𑀳𑀁 ¶ 𑀲𑀲𑁆𑀲𑀼𑀬𑀸𑀘𑀺𑀓𑁆𑀔𑀺𑀁, 𑀲𑀫𑀡𑁄 𑀆𑀕𑀢𑁄 𑀇𑀥;

𑀢𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀳𑀁 𑀧𑀽𑀯𑀁, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀇𑀢𑀺𑀲𑁆𑀲𑀸 ¶ ¶ 𑀲𑀲𑁆𑀲𑀼 𑀧𑀭𑀺𑀪𑀸𑀲𑀺, 𑀅𑀯𑀺𑀦𑀻𑀢𑀸𑀲𑀺 𑀢𑁆𑀯𑀁 [𑀅𑀯𑀺𑀦𑀻𑀢𑀸 𑀢𑀼𑀯𑀁 (𑀲𑀻.)] 𑀯𑀥𑀼;

𑀦 𑀫𑀁 𑀲𑀫𑁆𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀼𑀁 𑀇𑀘𑁆𑀙𑀺, 𑀲𑀫𑀡𑀲𑁆𑀲 𑀤𑀤𑀸𑀫𑀳𑀁.

‘‘𑀢𑀢𑁄 𑀫𑁂 𑀲𑀲𑁆𑀲𑀼 𑀓𑀼𑀧𑀺𑀢𑀸, 𑀧𑀳𑀸𑀲𑀺 𑀫𑀼𑀲𑀮𑁂𑀦 𑀫𑀁;

𑀓𑀽𑀝𑀗𑁆𑀕𑀘𑁆𑀙𑀺 𑀅𑀯𑀥𑀺 𑀫𑀁, 𑀦𑀸𑀲𑀓𑁆𑀔𑀺𑀁 𑀚𑀻𑀯𑀺𑀢𑀼𑀁 𑀘𑀺𑀭𑀁.

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

𑀤𑁂𑀯𑀸𑀦𑀁 𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑀸𑀦𑀁, 𑀉𑀧𑀧𑀦𑁆𑀦𑀸 𑀲𑀳𑀩𑁆𑀬𑀢𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁨. 𑀉𑀘𑁆𑀙𑀼𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀑𑀪𑀸𑀲𑀬𑀺𑀢𑁆𑀯𑀸 ¶ ¶ 𑀧𑀣𑀯𑀺𑀁 [𑀧𑀞𑀯𑀺𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀲𑀤𑁂𑀯𑀓𑀁, 𑀅𑀢𑀺𑀭𑁄𑀘𑀲𑀺 𑀘𑀦𑁆𑀤𑀺𑀫𑀲𑀽𑀭𑀺𑀬𑀸 𑀯𑀺𑀬;

𑀲𑀺𑀭𑀺𑀬𑀸 𑀘 𑀯𑀡𑁆𑀡𑁂𑀦 𑀬𑀲𑁂𑀦 𑀢𑁂𑀚𑀲𑀸, 𑀩𑁆𑀭𑀳𑁆𑀫𑀸𑀯 𑀤𑁂𑀯𑁂 𑀢𑀺𑀤𑀲𑁂 𑀲𑀳𑀺𑀦𑁆𑀤𑀓𑁂 [𑀲𑀇𑀦𑁆𑀤𑀓𑁂 (𑀲𑀻.)].

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀉𑀧𑁆𑀧𑀮𑀫𑀸𑀮𑀥𑀸𑀭𑀺𑀦𑀻, 𑀆𑀯𑁂𑀴𑀺𑀦𑀻 𑀓𑀜𑁆𑀘𑀦𑀲𑀦𑁆𑀦𑀺𑀪𑀢𑁆𑀢𑀘𑁂;

𑀅𑀮𑀗𑁆𑀓𑀢𑁂 𑀉𑀢𑁆𑀢𑀫𑀯𑀢𑁆𑀣𑀥𑀸𑀭𑀺𑀦𑀻, 𑀓𑀸 𑀢𑁆𑀯𑀁 𑀲𑀼𑀪𑁂 𑀤𑁂𑀯𑀢𑁂 𑀯𑀦𑁆𑀤𑀲𑁂 𑀫𑀫𑀁.

‘‘𑀓𑀺𑀁 𑀢𑁆𑀯𑀁 𑀧𑀼𑀭𑁂 𑀓𑀫𑁆𑀫𑀫𑀓𑀸𑀲𑀺 𑀅𑀢𑁆𑀢𑀦𑀸, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 𑀧𑀼𑀭𑀺𑀫𑀸𑀬 𑀚𑀸𑀢𑀺𑀬𑀸;

𑀤𑀸𑀦𑀁 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑀁 𑀅𑀣 𑀲𑀻𑀮𑀲𑀁𑀬𑀫𑀁 [𑀲𑀜𑁆𑀜𑀫𑀁 (𑀲𑀻.)], 𑀓𑁂𑀦𑀽𑀧𑀧𑀦𑁆𑀦𑀸 ¶ 𑀲𑀼𑀕𑀢𑀺𑀁 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀇𑀤𑀸𑀦𑀺 ¶ 𑀪𑀦𑁆𑀢𑁂 𑀇𑀫𑀫𑁂𑀯 𑀕𑀸𑀫𑀁 [𑀕𑀸𑀫𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀅𑀫𑁆𑀳𑀸𑀓𑀁 𑀖𑀭𑀁 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀢𑀢𑁄 𑀢𑁂 𑀉𑀘𑁆𑀙𑀼𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀺 𑀔𑀡𑁆𑀟𑀺𑀓𑀁, 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸 𑀅𑀢𑀼𑀮𑀸𑀬 𑀧𑀻𑀢𑀺𑀬𑀸.

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

𑀦 𑀙𑀟𑁆𑀟𑀺𑀢𑀁 𑀦𑁄 𑀧𑀦 𑀔𑀸𑀤𑀺𑀢𑀁 𑀫𑀬𑀸, 𑀲𑀦𑁆𑀢𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑁆𑀲 𑀲𑀬𑀁 𑀅𑀤𑀸𑀲𑀳𑀁.

‘‘𑀢𑀼𑀬𑁆𑀳𑀁𑀦𑁆𑀯𑀺𑀤𑀁 [𑀢𑀼𑀬𑁆𑀳𑀁 𑀦𑀼 𑀇𑀤𑀁 (𑀲𑁆𑀬𑀸.)] 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑀁 𑀅𑀣𑁄 𑀫𑀫, 𑀇𑀢𑀺𑀲𑁆𑀲𑀸 𑀲𑀲𑁆𑀲𑀼 𑀧𑀭𑀺𑀪𑀸𑀲𑀢𑁂 𑀫𑀫𑀁;

𑀧𑀻𑀞𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀧𑀳𑀸𑀭𑀁 𑀅𑀤𑀸𑀲𑀺 𑀫𑁂, 𑀢𑀢𑁄 𑀘𑀼𑀢𑀸 𑀓𑀸𑀮𑀓𑀢𑀸𑀫𑁆𑀳𑀺 𑀤𑁂𑀯𑀢𑀸.

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

𑀤𑁂𑀯𑁂𑀳𑀺 𑀲𑀤𑁆𑀥𑀺𑀁 𑀧𑀭𑀺𑀘𑀸𑀭𑀬𑀸𑀫𑀳𑀁, 𑀫𑁄𑀤𑀸𑀫𑀳𑀁 𑀓𑀸𑀫𑀕𑀼𑀡𑁂𑀳𑀺 𑀧𑀜𑁆𑀘𑀳𑀺.

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

𑀤𑁂𑀯𑀺𑀦𑁆𑀤𑀕𑀼𑀢𑁆𑀢𑀸 ¶ 𑀢𑀺𑀤𑀲𑁂𑀳𑀺 𑀭𑀓𑁆𑀔𑀺𑀢𑀸, 𑀲𑀫𑀧𑁆𑀧𑀺𑀢𑀸 𑀓𑀸𑀫𑀕𑀼𑀡𑁂𑀳𑀺 𑀧𑀜𑁆𑀘𑀳𑀺.

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀧𑀼𑀜𑁆𑀜𑀨𑀮𑀁 𑀅𑀦𑀧𑁆𑀧𑀓𑀁, 𑀫𑀳𑀸𑀯𑀺𑀧𑀸𑀓𑀸 𑀫𑀫 𑀉𑀘𑁆𑀙𑀼𑀤𑀓𑁆𑀔𑀺𑀡𑀸;

𑀤𑁂𑀯𑁂𑀳𑀺 𑀲𑀤𑁆𑀥𑀺𑀁 𑀧𑀭𑀺𑀘𑀸𑀭𑀬𑀸𑀫𑀳𑀁, 𑀫𑁄𑀤𑀸𑀫𑀳𑀁 𑀓𑀸𑀫𑀕𑀼𑀡𑁂𑀳𑀺 𑀧𑀜𑁆𑀘𑀳𑀺.

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 ¶ 𑀧𑀼𑀜𑁆𑀜𑀨𑀮𑀁 𑀅𑀦𑀧𑁆𑀧𑀓𑀁, 𑀫𑀳𑀸𑀚𑀼𑀢𑀺𑀓𑀸 𑀫𑀫 𑀉𑀘𑁆𑀙𑀼𑀤𑀓𑁆𑀔𑀺𑀡𑀸;

𑀤𑁂𑀯𑀺𑀦𑁆𑀤𑀕𑀼𑀢𑁆𑀢𑀸 𑀢𑀺𑀤𑀲𑁂𑀳𑀺 𑀭𑀓𑁆𑀔𑀺𑀢𑀸, 𑀲𑀳𑀲𑁆𑀲𑀦𑁂𑀢𑁆𑀢𑁄𑀭𑀺𑀯 𑀦𑀦𑁆𑀤𑀦𑁂 𑀯𑀦𑁂.

‘‘𑀢𑀼𑀯𑀜𑁆𑀘 ¶ 𑀪𑀦𑁆𑀢𑁂 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀁 𑀯𑀺𑀤𑀼𑀁, 𑀉𑀧𑁂𑀘𑁆𑀘 𑀯𑀦𑁆𑀤𑀺𑀁 𑀓𑀼𑀲𑀮𑀜𑁆𑀘 𑀧𑀼𑀘𑁆𑀙𑀺𑀲𑀁;

𑀢𑀢𑁄 𑀢𑁂 𑀉𑀘𑁆𑀙𑀼𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀺 𑀔𑀡𑁆𑀟𑀺𑀓𑀁, 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑀸 𑀅𑀢𑀼𑀮𑀸𑀬 𑀧𑀻𑀢𑀺𑀬𑀸’’𑀢𑀺.

𑀉𑀘𑁆𑀙𑀼𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀤𑀼𑀢𑀺𑀬𑀁.

‘‘𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑀲𑁂𑀝𑁆𑀞𑁂 ¶ ¶ 𑀫𑀡𑀺𑀲𑁄𑀡𑁆𑀡𑀘𑀺𑀢𑁆𑀢𑁂, 𑀧𑀼𑀧𑁆𑀨𑀸𑀪𑀺𑀓𑀺𑀡𑁆𑀡𑁂 𑀲𑀬𑀦𑁂 𑀉𑀴𑀸𑀭𑁂;

𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀤𑁂𑀯𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂, 𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑀸 𑀇𑀤𑁆𑀥𑀺 𑀯𑀺𑀓𑀼𑀩𑁆𑀩𑀫𑀸𑀦𑀸.

‘‘𑀇𑀫𑀸 𑀘 𑀢𑁂 𑀅𑀘𑁆𑀙𑀭𑀸𑀬𑁄 𑀲𑀫𑀦𑁆𑀢𑀢𑁄, 𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 ¶ 𑀕𑀸𑀬𑀦𑁆𑀢𑀺 𑀧𑀫𑁄𑀤𑀬𑀦𑁆𑀢𑀺;

𑀤𑁂𑀯𑀺𑀤𑁆𑀥𑀺𑀧𑀢𑁆𑀢𑀸𑀲𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 𑀓𑀺𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑀸, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸, 𑀅𑀟𑁆𑀠𑁂 𑀓𑀼𑀮𑁂 𑀲𑀼𑀡𑀺𑀲𑀸 𑀅𑀳𑁄𑀲𑀺𑀁;

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

‘‘𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 𑀤𑀳𑀭𑀸 𑀅𑀧𑀸𑀧𑀺𑀓𑀸 [𑀤𑀳𑀭𑀸𑀲’𑀧𑀸𑀧𑀺𑀓𑀸 (𑀲𑀻.)], 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸 𑀧𑀢𑀺𑀫𑀸𑀪𑀺𑀭𑀸𑀥𑀬𑀺𑀁;

𑀤𑀺𑀯𑀸 𑀘 𑀭𑀢𑁆𑀢𑁄 𑀘 𑀫𑀦𑀸𑀧𑀘𑀸𑀭𑀺𑀦𑀻, 𑀅𑀳𑀁 𑀧𑀼𑀭𑁂 𑀲𑀻𑀮𑀯𑀢𑀻 𑀅𑀳𑁄𑀲𑀺𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 ¶ 𑀯𑀺𑀭𑀢𑀸 𑀅𑀘𑁄𑀭𑀺𑀓𑀸, 𑀲𑀁𑀲𑀼𑀤𑁆𑀥𑀓𑀸𑀬𑀸 𑀲𑀼𑀘𑀺𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺𑀦𑀻;

𑀅𑀫𑀚𑁆𑀚𑀧𑀸 𑀦𑁄 𑀘 𑀫𑀼𑀲𑀸 𑀅𑀪𑀸𑀡𑀺𑀁, 𑀲𑀺𑀓𑁆𑀔𑀸𑀧𑀤𑁂𑀲𑀼 𑀧𑀭𑀺𑀧𑀽𑀭𑀓𑀸𑀭𑀺𑀦𑀻.

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

𑀧𑀸𑀝𑀺𑀳𑀸𑀭𑀺𑀬𑀧𑀓𑁆𑀔𑀜𑁆𑀘, 𑀧𑀲𑀦𑁆𑀦𑀫𑀸𑀦𑀲𑀸 𑀅𑀳𑀁 [𑀅𑀢𑀺𑀧𑀲𑀦𑁆𑀦𑀫𑀸𑀦𑀲𑀸 (𑀓.)].

‘‘𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑀼𑀧𑁂𑀢𑀁 𑀅𑀦𑀼𑀥𑀫𑁆𑀫𑀘𑀸𑀭𑀺𑀦𑀻, 𑀉𑀧𑁄𑀲𑀣𑀁 ¶ 𑀧𑀻𑀢𑀺𑀫𑀦𑀸 𑀉𑀧𑀸𑀯𑀲𑀺𑀁;

𑀇𑀫𑀜𑁆𑀘 𑀅𑀭𑀺𑀬𑀁 𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑀯𑀭𑁂𑀳𑀼𑀧𑁂𑀢𑀁, 𑀲𑀫𑀸𑀤𑀺𑀬𑀺𑀢𑁆𑀯𑀸 𑀓𑀼𑀲𑀮𑀁 𑀲𑀼𑀔𑀼𑀤𑁆𑀭𑀬𑀁;

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

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀓𑀼𑀲𑀮𑀁 𑀚𑀻𑀯𑀮𑁄𑀓𑁂, 𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦 𑀯𑀺𑀲𑁂𑀲𑀪𑀸𑀕𑀺𑀦𑀻;

𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀅𑀪𑀺𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑀁, 𑀤𑁂𑀯𑀺𑀤𑁆𑀥𑀺𑀧𑀢𑁆𑀢𑀸 𑀲𑀼𑀕𑀢𑀺𑀫𑁆𑀳𑀺 𑀆𑀕𑀢𑀸.

‘‘𑀯𑀺𑀫𑀸𑀦𑀧𑀸𑀲𑀸𑀤𑀯𑀭𑁂 𑀫𑀦𑁄𑀭𑀫𑁂, 𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑀸 𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀗𑁆𑀕𑀡𑁂𑀦;

𑀲𑀬𑀁𑀧𑀪𑀸 𑀤𑁂𑀯𑀕𑀡𑀸 𑀭𑀫𑁂𑀦𑁆𑀢𑀺 𑀫𑀁, 𑀤𑀻𑀖𑀸𑀬𑀼𑀓𑀺𑀁 𑀤𑁂𑀯𑀯𑀺𑀫𑀸𑀦𑀫𑀸𑀕𑀢’’𑀦𑁆𑀢𑀺;

𑀮𑀢𑀸 ¶ 𑀘 𑀲𑀚𑁆𑀚𑀸 𑀧𑀯𑀭𑀸 𑀘 𑀤𑁂𑀯𑀢𑀸, 𑀅𑀘𑁆𑀘𑀺𑀫𑀢𑀻 [𑀅𑀘𑁆𑀘𑀺𑀫𑀼𑀔𑀻 (𑀲𑀻.), 𑀅𑀘𑁆𑀙𑀺𑀫𑀢𑀻 (𑀧𑀻. 𑀓.) 𑀅𑀘𑁆𑀙𑀺𑀫𑀼𑀢𑀻 (𑀲𑁆𑀬𑀸.)] 𑀭𑀸𑀚𑀯𑀭𑀲𑁆𑀲 𑀲𑀺𑀭𑀻𑀫𑀢𑁄;

𑀲𑀼𑀢𑀸 𑀘 𑀭𑀜𑁆𑀜𑁄 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑀲𑁆𑀲 𑀥𑀻𑀢𑀸, 𑀭𑀸𑀚𑀻𑀫𑀢𑀻 𑀥𑀫𑁆𑀫𑀕𑀼𑀡𑁂𑀳𑀺 𑀲𑁄𑀪𑀣.

𑀧𑀜𑁆𑀘𑁂𑀢𑁆𑀣 ¶ ¶ 𑀦𑀸𑀭𑀺𑀬𑁄 𑀆𑀕𑀫𑀁𑀲𑀼 𑀦𑁆𑀳𑀸𑀬𑀺𑀢𑀼𑀁, 𑀲𑀻𑀢𑁄𑀤𑀓𑀁 𑀉𑀧𑁆𑀧𑀮𑀺𑀦𑀺𑀁 𑀲𑀺𑀯𑀁 𑀦𑀤𑀺𑀁;

𑀢𑀸 ¶ 𑀢𑀢𑁆𑀣 𑀦𑁆𑀳𑀸𑀬𑀺𑀢𑁆𑀯𑀸 𑀭𑀫𑁂𑀢𑁆𑀯𑀸 𑀤𑁂𑀯𑀢𑀸, 𑀦𑀘𑁆𑀘𑀺𑀢𑁆𑀯𑀸 𑀕𑀸𑀬𑀺𑀢𑁆𑀯𑀸 𑀲𑀼𑀢𑀸 𑀮𑀢𑀁 𑀩𑁆𑀭𑀯𑀺 [𑀩𑁆𑀭𑀼𑀯𑀻 (𑀲𑀻.)].

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀉𑀧𑁆𑀧𑀮𑀫𑀸𑀮𑀥𑀸𑀭𑀺𑀦𑀺, 𑀆𑀯𑁂𑀴𑀺𑀦𑀺 𑀓𑀜𑁆𑀘𑀦𑀲𑀦𑁆𑀦𑀺𑀪𑀢𑁆𑀢𑀘𑁂;

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

‘‘𑀓𑁂𑀦𑀸𑀲𑀺 𑀪𑀤𑁆𑀤𑁂 𑀧𑀢𑀺𑀦𑁄 𑀧𑀺𑀬𑀢𑀭𑀸, 𑀯𑀺𑀲𑀺𑀝𑁆𑀞𑀓𑀮𑁆𑀬𑀸𑀡𑀺𑀢𑀭𑀲𑁆𑀲𑀼 𑀭𑀽𑀧𑀢𑁄;

𑀧𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀦𑀘𑁆𑀘𑀕𑀻𑀢𑀯𑀸𑀤𑀺𑀢𑁂, 𑀆𑀘𑀺𑀓𑁆𑀔 𑀦𑁄 𑀢𑁆𑀯𑀁 𑀦𑀭𑀦𑀸𑀭𑀺𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸’’𑀢𑀺.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸, 𑀉𑀴𑀸𑀭𑀪𑁄𑀕𑁂 𑀓𑀼𑀮𑁂 𑀲𑀼𑀡𑀺𑀲𑀸 𑀅𑀳𑁄𑀲𑀺𑀁;

𑀅𑀓𑁆𑀓𑁄𑀥𑀦𑀸 𑀪𑀢𑁆𑀢𑀼𑀯𑀲𑀸𑀦𑀼𑀯𑀢𑁆𑀢𑀺𑀦𑀻, 𑀉𑀧𑁄𑀲𑀣𑁂 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀸 𑀅𑀳𑁄𑀲𑀺𑀁.

‘‘𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 ¶ 𑀤𑀳𑀭𑀸 𑀅𑀧𑀸𑀧𑀺𑀓𑀸 [𑀤𑀳𑀭𑀸𑀲’𑀧𑀸𑀧𑀺𑀓𑀸 (𑀲𑀻.)], 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸 𑀧𑀢𑀺𑀫𑀸𑀪𑀺𑀭𑀸𑀥𑀬𑀺𑀁;

𑀲𑀤𑁂𑀯𑀭𑀁 𑀲𑀲𑁆𑀲𑀲𑀼𑀭𑀁 𑀲𑀤𑀸𑀲𑀓𑀁, 𑀅𑀪𑀺𑀭𑀸𑀥𑀬𑀺𑀁 𑀢𑀫𑁆𑀳𑀺 𑀓𑀢𑁄 𑀬𑀲𑁄 𑀫𑀫.

‘‘𑀲𑀸𑀳𑀁 𑀢𑁂𑀦 𑀓𑀼𑀲𑀮𑁂𑀦 𑀓𑀫𑁆𑀫𑀼𑀦𑀸, 𑀘𑀢𑀼𑀩𑁆𑀪𑀺 𑀞𑀸𑀦𑁂𑀳𑀺 𑀯𑀺𑀲𑁂𑀲𑀫𑀚𑁆𑀛𑀕𑀸;

𑀆𑀬𑀼𑀜𑁆𑀘 ¶ 𑀯𑀡𑁆𑀡𑀜𑁆𑀘 𑀲𑀼𑀔𑀁 𑀩𑀮𑀜𑁆𑀘, 𑀔𑀺𑀟𑁆𑀟𑀸𑀭𑀢𑀺𑀁 𑀧𑀘𑁆𑀘𑀦𑀼𑀪𑁄𑀫𑀦𑀧𑁆𑀧𑀓𑀁.

‘‘𑀲𑀼𑀢𑀁 𑀦𑀼 𑀢𑀁 𑀪𑀸𑀲𑀢𑀺 𑀬𑀁 𑀅𑀬𑀁 𑀮𑀢𑀸, 𑀬𑀁 𑀦𑁄 𑀅𑀧𑀼𑀘𑁆𑀙𑀺𑀫𑁆𑀳 𑀅𑀓𑀺𑀢𑁆𑀢𑀬𑀻 𑀦𑁄;

𑀧𑀢𑀺𑀦𑁄 𑀓𑀺𑀭𑀫𑁆𑀳𑀸𑀓𑀁 𑀯𑀺𑀲𑀺𑀝𑁆𑀞 𑀦𑀸𑀭𑀻𑀦𑀁, 𑀕𑀢𑀻 𑀘 𑀢𑀸𑀲𑀁 𑀧𑀯𑀭𑀸 𑀘 𑀤𑁂𑀯𑀢𑀸.

‘‘𑀧𑀢𑀻𑀲𑀼 ¶ 𑀥𑀫𑁆𑀫𑀁 𑀧𑀘𑀭𑀸𑀫 𑀲𑀩𑁆𑀩𑀸, 𑀧𑀢𑀺𑀩𑁆𑀩𑀢𑀸 𑀬𑀢𑁆𑀣 𑀪𑀯𑀦𑁆𑀢𑀺 𑀇𑀢𑁆𑀣𑀺𑀬𑁄;

𑀧𑀢𑀻𑀲𑀼 𑀥𑀫𑁆𑀫𑀁 𑀧𑀘𑀭𑀺𑀢𑁆𑀯 [𑀧𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦 (𑀓.)] 𑀲𑀩𑁆𑀩𑀸, 𑀮𑀘𑁆𑀙𑀸𑀫𑀲𑁂 𑀪𑀸𑀲𑀢𑀺 𑀬𑀁 𑀅𑀬𑀁 𑀮𑀢𑀸.

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

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

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

𑀓𑁄𑀥𑀁 𑀯𑀥𑀺𑀢𑁆𑀯𑀸 𑀅𑀪𑀺𑀪𑀼𑀬𑁆𑀬 𑀫𑀘𑁆𑀙𑀭𑀁, 𑀲𑀕𑁆𑀕𑀫𑁆𑀳𑀺 𑀲𑀸 𑀫𑁄𑀤𑀢𑀺 𑀥𑀫𑁆𑀫𑀘𑀸𑀭𑀺𑀦𑀻’’𑀢𑀺.

𑁧. 𑀯𑀢𑁆𑀣𑀼𑀢𑁆𑀢𑀫𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀲𑀢𑁆𑀢𑀢𑀦𑁆𑀢𑀺𑀁 ¶ 𑀲𑀼𑀫𑀥𑀼𑀭𑀁, 𑀭𑀸𑀫𑀡𑁂𑀬𑁆𑀬𑀁 𑀅𑀯𑀸𑀘𑀬𑀺𑀁;

𑀲𑁄 ¶ 𑀫𑀁 𑀭𑀗𑁆𑀕𑀫𑁆𑀳𑀺 𑀅𑀯𑁆𑀳𑁂𑀢𑀺, ‘𑀲𑀭𑀡𑀁 𑀫𑁂 𑀳𑁄𑀳𑀺 𑀓𑁄𑀲𑀺𑀬𑀸’𑀢𑀺.

‘‘𑀅𑀳𑀁 ¶ 𑀢𑁂 𑀲𑀭𑀡𑀁 𑀳𑁄𑀫𑀺, 𑀅𑀳𑀫𑀸𑀘𑀭𑀺𑀬𑀧𑀽𑀚𑀓𑁄;

𑀦 𑀢𑀁 𑀚𑀬𑀺𑀲𑁆𑀲𑀢𑀺 𑀲𑀺𑀲𑁆𑀲𑁄, 𑀲𑀺𑀲𑁆𑀲𑀫𑀸𑀘𑀭𑀺𑀬 𑀚𑁂𑀲𑁆𑀲𑀲𑀻’’𑀢𑀺.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀓𑁂𑀦 𑀢𑁂 𑀇𑀥 𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀘 𑀢𑁂 𑀪𑁄𑀕𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑀸, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑀸 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

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

𑀏𑀯𑀁 𑀧𑀺𑀬𑀭𑀽𑀧𑀤𑀸𑀬𑀺𑀓𑀸 𑀫𑀦𑀸𑀧𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀲𑀸 𑀮𑀪𑀢𑁂 𑀉𑀧𑁂𑀘𑁆𑀘 𑀞𑀸𑀦𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 ¶ 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 [𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁 𑀧𑀯𑀭𑀸, (𑀲𑁆𑀬𑀸.)] 𑀧𑀲𑁆𑀲 ¶ 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀢𑁂𑀦 𑀫𑁂 𑀇𑀥 𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀘 𑀫𑁂 𑀪𑁄𑀕𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀅𑀓𑁆𑀔𑀸𑀫𑀺 𑀢𑁂 𑀪𑀺𑀓𑁆𑀔𑀼 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 𑀬𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀢𑁂𑀦𑀫𑁆𑀳𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑀸, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

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

𑁨. 𑀧𑀼𑀧𑁆𑀨𑀼𑀢𑁆𑀢𑀫𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀤𑁂𑀯𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀧𑀼𑀧𑁆𑀨𑀼𑀢𑁆𑀢𑀫𑀤𑀸𑀬𑀺𑀓𑀸 𑀦𑀸𑀭𑀻, 𑀧𑀯𑀭𑀸 𑀳𑁄𑀢𑀺 𑀦𑀭𑁂𑀲𑀼 𑀦𑀸𑀭𑀻𑀲𑀼;

𑀏𑀯𑀁 𑀧𑀺𑀬𑀭𑀽𑀧𑀤𑀸𑀬𑀺𑀓𑀸 𑀫𑀦𑀸𑀧𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀲𑀸 𑀮𑀪𑀢𑁂 𑀉𑀧𑁂𑀘𑁆𑀘 𑀞𑀸𑀦𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 ¶ ¶ 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁩. 𑀕𑀦𑁆𑀥𑀼𑀢𑁆𑀢𑀫𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁨)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… ¶ 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀤𑁂𑀯𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

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

𑀏𑀯𑀁 𑀧𑀺𑀬𑀭𑀽𑀧𑀤𑀸𑀬𑀺𑀓𑀸 𑀫𑀦𑀸𑀧𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀲𑀸 𑀮𑀪𑀢𑁂 𑀉𑀧𑁂𑀘𑁆𑀘 𑀞𑀸𑀦𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁪. 𑀨𑀮𑀼𑀢𑁆𑀢𑀫𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁩)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀤𑁂𑀯𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 ¶ 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀨𑀮𑀼𑀢𑁆𑀢𑀫𑀤𑀸𑀬𑀺𑀓𑀸 𑀦𑀸𑀭𑀻, 𑀧𑀯𑀭𑀸 𑀳𑁄𑀢𑀺 𑀦𑀭𑁂𑀲𑀼 𑀦𑀸𑀭𑀻𑀲𑀼;

𑀏𑀯𑀁 𑀧𑀺𑀬𑀭𑀽𑀧𑀤𑀸𑀬𑀺𑀓𑀸 𑀫𑀦𑀸𑀧𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀲𑀸 𑀮𑀪𑀢𑁂 𑀉𑀧𑁂𑀘𑁆𑀘 𑀞𑀸𑀦𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁫. 𑀭𑀲𑀼𑀢𑁆𑀢𑀫𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁪)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 ¶ 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀤𑁂𑀯𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀭𑀲𑀼𑀢𑁆𑀢𑀫𑀤𑀸𑀬𑀺𑀓𑀸 𑀦𑀸𑀭𑀻, 𑀧𑀯𑀭𑀸 ¶ 𑀳𑁄𑀢𑀺 𑀦𑀭𑁂𑀲𑀼 𑀦𑀸𑀭𑀻𑀲𑀼;

𑀏𑀯𑀁 𑀧𑀺𑀬𑀭𑀽𑀧𑀤𑀸𑀬𑀺𑀓𑀸 𑀫𑀦𑀸𑀧𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀲𑀸 𑀮𑀪𑀢𑁂 𑀉𑀧𑁂𑀘𑁆𑀘 𑀞𑀸𑀦𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁬. 𑀕𑀦𑁆𑀥𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀼𑀮𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀕𑀦𑁆𑀥𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀼𑀮𑀺𑀓𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀓𑀲𑁆𑀲𑀧𑀲𑁆𑀲 𑀪𑀕𑀯𑀢𑁄 𑀣𑀽𑀧𑀫𑁆𑀳𑀺;

𑀏𑀯𑀁 𑀧𑀺𑀬𑀭𑀽𑀧𑀤𑀸𑀬𑀺𑀓𑀸 𑀫𑀦𑀸𑀧𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀲𑀸 𑀮𑀪𑀢𑁂 𑀉𑀧𑁂𑀘𑁆𑀘 𑀞𑀸𑀦𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁 ¶ , 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

(𑀅𑀦𑀦𑁆𑀢𑀭𑀁 ¶ 𑀘𑀢𑀼𑀭𑀯𑀺𑀫𑀸𑀦𑀁 𑀬𑀣𑀸 𑀕𑀦𑁆𑀥𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀼𑀮𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀢𑀣𑀸 𑀯𑀺𑀢𑁆𑀣𑀸𑀭𑁂𑀢𑀩𑁆𑀩𑀁 [( ) 𑀦𑀢𑁆𑀣𑀺 𑀲𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂] )

𑁭. 𑀏𑀓𑀽𑀧𑁄𑀲𑀣𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂…𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀪𑀺𑀓𑁆𑀔𑀽 𑀘 𑀅𑀳𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑀺𑀬𑁄 𑀘, 𑀅𑀤𑁆𑀤𑀲𑀸𑀲𑀺𑀁 𑀧𑀦𑁆𑀣𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑁂;

𑀢𑁂𑀲𑀸𑀳𑀁 𑀥𑀫𑁆𑀫𑀁 𑀲𑀼𑀢𑁆𑀯𑀸𑀦, 𑀏𑀓𑀽𑀧𑁄𑀲𑀣𑀁 𑀉𑀧𑀯𑀲𑀺𑀲𑁆𑀲𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁮. 𑀉𑀤𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁨)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 ¶ ¶ 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

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

𑀏𑀯𑀁 𑀧𑀺𑀬𑀭𑀽𑀧𑀤𑀸𑀬𑀺𑀓𑀸 𑀫𑀦𑀸𑀧𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀲𑀸 𑀮𑀪𑀢𑁂 𑀉𑀧𑁂𑀘𑁆𑀘 𑀞𑀸𑀦𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁯. 𑀉𑀧𑀝𑁆𑀞𑀸𑀦𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁩)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 ¶ 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀲𑀲𑁆𑀲𑀼𑀜𑁆𑀘𑀸𑀳𑀁 𑀲𑀲𑀼𑀭𑀜𑁆𑀘, 𑀘𑀡𑁆𑀟𑀺𑀓𑁂 𑀓𑁄𑀥𑀦𑁂 𑀘 𑀨𑀭𑀼𑀲𑁂 𑀘;

𑀅𑀦𑀼𑀲𑀽𑀬𑀺𑀓𑀸 𑀉𑀧𑀝𑁆𑀞𑀸𑀲𑀺𑀁 [𑀲𑀽𑀧𑀝𑁆𑀞𑀸𑀲𑀺𑀁 (𑀲𑀻.)], 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀸 ¶ 𑀲𑀓𑁂𑀦 𑀲𑀻𑀮𑁂𑀦.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁧𑁦. 𑀅𑀧𑀭𑀓𑀫𑁆𑀫𑀓𑀸𑀭𑀺𑀦𑀻𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁪)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

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

𑀅𑀓𑁆𑀓𑁄𑀥𑀦𑀸𑀦𑀢𑀺𑀫𑀸𑀦𑀺𑀦𑀻 [𑀅𑀦𑀢𑀺𑀫𑀸𑀦𑀻 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀺𑀦𑀻 𑀲𑀓𑀲𑁆𑀲 𑀪𑀸𑀕𑀲𑁆𑀲.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 ¶ 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁧𑁧. 𑀔𑀻𑀭𑁄𑀤𑀦𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 ¶ 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀔𑀻𑀭𑁄𑀤𑀦𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲;

𑀏𑀯𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸 𑀓𑀫𑁆𑀫𑀁, 𑀲𑀼𑀕𑀢𑀺𑀁 𑀉𑀧𑀧𑀚𑁆𑀚 𑀫𑁄𑀤𑀸𑀫𑀺.

‘‘𑀢𑀲𑁆𑀲𑀸 ¶ 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

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

𑁧𑁨. 𑀨𑀸𑀡𑀺𑀢𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧)

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… ¶ 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀨𑀸𑀡𑀺𑀢𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂…’’.

𑁧𑁩. 𑀉𑀘𑁆𑀙𑀼𑀔𑀡𑁆𑀟𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀢𑁆𑀣𑀼 (𑁨)

𑀉𑀘𑁆𑀙𑀼𑀔𑀡𑁆𑀟𑀺𑀓𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁧𑁪. 𑀢𑀺𑀫𑁆𑀩𑀭𑀼𑀲𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁩)

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

𑁧𑁫. 𑀓𑀓𑁆𑀓𑀸𑀭𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁪)

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

𑁧𑁬. 𑀏𑀴𑀸𑀮𑀼𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁫)

𑀏𑀴𑀸𑀮𑀼𑀓𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁧𑁭. 𑀯𑀮𑁆𑀮𑀺𑀨𑀮𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼(𑁬)

𑀯𑀮𑁆𑀮𑀺𑀨𑀮𑀁 ¶ 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁧𑁮. 𑀨𑀸𑀭𑀼𑀲𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁭)

𑀨𑀸𑀭𑀼𑀲𑀓𑀁 ¶ 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁧𑁯. 𑀳𑀢𑁆𑀣𑀧𑁆𑀧𑀢𑀸𑀧𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁮)

𑀳𑀢𑁆𑀣𑀧𑁆𑀧𑀢𑀸𑀧𑀓𑀁 ¶ 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁨𑁦. 𑀲𑀸𑀓𑀫𑀼𑀝𑁆𑀞𑀺𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁯)

𑀲𑀸𑀓𑀫𑀼𑀝𑁆𑀞𑀺𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀦𑁆𑀣𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀲𑁆𑀲…𑀧𑁂….

𑁨𑁧. 𑀧𑀼𑀧𑁆𑀨𑀓𑀫𑀼𑀝𑁆𑀞𑀺𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁦)

𑀧𑀼𑀧𑁆𑀨𑀓𑀫𑀼𑀝𑁆𑀞𑀺𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁨𑁨. 𑀫𑀽𑀮𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁧)

𑀫𑀽𑀮𑀓𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁨𑁩. 𑀦𑀺𑀫𑁆𑀩𑀫𑀼𑀝𑁆𑀞𑀺𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁨)

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

𑁨𑁪. 𑀅𑀫𑁆𑀩𑀓𑀜𑁆𑀚𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁩)

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

𑁨𑁫. 𑀤𑁄𑀡𑀺𑀦𑀺𑀫𑁆𑀫𑀚𑁆𑀚𑀦𑀺𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁪)

𑀤𑁄𑀡𑀺𑀦𑀺𑀫𑁆𑀫𑀚𑁆𑀚𑀦𑀺𑀁 [𑀤𑁄𑀡𑀺𑀦𑀺𑀫𑁆𑀫𑀼𑀚𑁆𑀚𑀦𑀁 (𑀲𑁆𑀬𑀸.)] 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁨𑁬. 𑀓𑀸𑀬𑀩𑀦𑁆𑀥𑀦𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁫)

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

𑁨𑁭. 𑀅𑀁𑀲𑀩𑀤𑁆𑀥𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁬)

𑀅𑀁𑀲𑀩𑀤𑁆𑀥𑀓𑀁 ¶ [𑀅𑀁𑀲𑀯𑀝𑁆𑀝𑀓𑀁 (𑀲𑀻.), 𑀅𑀁𑀲𑀩𑀦𑁆𑀥𑀦𑀁 (𑀓.)] 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁨𑁮. 𑀆𑀬𑁄𑀕𑀧𑀝𑁆𑀝𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁭)

𑀆𑀬𑁄𑀕𑀧𑀝𑁆𑀝𑀁 ¶ 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁨𑁯. 𑀯𑀺𑀥𑀽𑀧𑀦𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁮)

𑀯𑀺𑀥𑀽𑀧𑀦𑀁 ¶ 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁩𑁦. 𑀢𑀸𑀮𑀯𑀡𑁆𑀝𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁧𑁯)

𑀢𑀸𑀮𑀯𑀡𑁆𑀝𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁩𑁧. 𑀫𑁄𑀭𑀳𑀢𑁆𑀣𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁨𑁦)

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

𑁩𑁨. 𑀙𑀢𑁆𑀢𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁨𑁧)

𑀙𑀢𑁆𑀢𑀁 [𑀙𑀢𑁆𑀢𑀜𑁆𑀘 (𑀓.)] 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁩𑁩. 𑀉𑀧𑀸𑀳𑀦𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁨𑁨)

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

𑁩𑁪. 𑀧𑀽𑀯𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁨𑁩)

𑀧𑀽𑀯𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

𑁩𑁫. 𑀫𑁄𑀤𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁨𑁪)

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

𑁩𑁬. 𑀲𑀓𑁆𑀔𑀮𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 (𑁨𑁫)

‘‘𑀲𑀓𑁆𑀔𑀮𑀺𑀓𑀁 [𑀲𑀓𑁆𑀔𑀮𑀺𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲…𑀧𑁂….

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑀲𑁆𑀲 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻𑀳𑀫𑀲𑁆𑀫𑀺;

𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀳𑀲𑁆𑀲𑀲𑁆𑀲𑀸𑀳𑀁, 𑀧𑀯𑀭𑀸 𑀧𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀁.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀲𑁆𑀯𑀸𑀕𑀢𑀁 𑀯𑀢 𑀫𑁂 𑀅𑀚𑁆𑀚, 𑀲𑀼𑀧𑁆𑀧𑀪𑀸𑀢𑀁 𑀲𑀼𑀳𑀼𑀝𑁆𑀞𑀺𑀢𑀁 [𑀲𑀼𑀯𑀼𑀝𑁆𑀞𑀺𑀢𑀁 (𑀲𑀻.)];

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

‘‘𑀇𑀫𑀸𑀲𑀸𑀳𑀁 ¶ [𑀢𑀸𑀲𑀸𑀳𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀥𑀫𑁆𑀫𑀁 𑀲𑀼𑀢𑁆𑀯𑀸 [𑀲𑀼𑀢𑁆𑀯𑀸𑀦 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀓𑀸𑀳𑀸𑀫𑀺 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼𑀁.

𑀤𑀸𑀦𑁂𑀦 𑀲𑀫𑀘𑀭𑀺𑀬𑀸𑀬, 𑀲𑀜𑁆𑀜𑀫𑁂𑀦 𑀤𑀫𑁂𑀦 𑀘;

𑀲𑁆𑀯𑀸𑀳𑀁 𑀢𑀢𑁆𑀣 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺 [𑀢𑀢𑁆𑀣𑁂𑀯 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 (𑀓.)], 𑀬𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀦 𑀲𑁄𑀘𑀭𑁂’’𑀢𑀺.

‘‘𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀸 ¶ ¶ [𑀤𑀤𑁆𑀤𑀴𑁆𑀳𑀫𑀸𑀦𑀸 (𑀓.)] 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀲𑀲𑀸 𑀘 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻;

𑀲𑀩𑁆𑀩𑁂 𑀤𑁂𑀯𑁂 𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑁂, 𑀯𑀡𑁆𑀡𑁂𑀦 𑀅𑀢𑀺𑀭𑁄𑀘𑀲𑀺.

‘‘𑀤𑀲𑁆𑀲𑀦𑀁 𑀦𑀸𑀪𑀺𑀚𑀸𑀦𑀸𑀫𑀺, 𑀇𑀤𑀁 𑀧𑀞𑀫𑀤𑀲𑁆𑀲𑀦𑀁;

𑀓𑀲𑁆𑀫𑀸 𑀓𑀸𑀬𑀸 𑀦𑀼 𑀆𑀕𑀫𑁆𑀫, 𑀦𑀸𑀫𑁂𑀦 𑀪𑀸𑀲𑀲𑁂 𑀫𑀫’’𑀦𑁆𑀢𑀺.

‘‘𑀅𑀳𑀁 𑀪𑀤𑁆𑀤𑁂 𑀲𑀼𑀪𑀤𑁆𑀤𑀸𑀲𑀺𑀁, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀫𑀸𑀦𑀼𑀲𑀓𑁂 𑀪𑀯𑁂;

𑀲𑀳𑀪𑀭𑀺𑀬𑀸 𑀘 𑀢𑁂 𑀆𑀲𑀺𑀁, 𑀪𑀕𑀺𑀦𑀻 𑀘 𑀓𑀦𑀺𑀝𑁆𑀞𑀺𑀓𑀸.

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

𑀦𑀺𑀫𑁆𑀫𑀸𑀦𑀭𑀢𑀻𑀦𑀁 𑀤𑁂𑀯𑀸𑀦𑀁, 𑀉𑀧𑀧𑀦𑁆𑀦𑀸 𑀲𑀳𑀩𑁆𑀬𑀢’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀳𑀽𑀢𑀓𑀢𑀓𑀮𑁆𑀬𑀸𑀡𑀸, 𑀢𑁂 𑀤𑁂𑀯𑁂 𑀬𑀦𑁆𑀢𑀺 𑀧𑀸𑀡𑀺𑀦𑁄;

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

‘‘𑀅𑀣 [𑀓𑀣𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀢𑁆𑀯𑀁 𑀓𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀓𑁂𑀦 𑀯𑀸 𑀅𑀦𑀼𑀲𑀸𑀲𑀺𑀢𑀸;

𑀓𑀻𑀤𑀺𑀲𑁂𑀦𑁂𑀯 𑀤𑀸𑀦𑁂𑀦, 𑀲𑀼𑀩𑁆𑀩𑀢𑁂𑀦 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻.

‘‘𑀬𑀲𑀁 𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀧𑀢𑁆𑀢𑀸, 𑀯𑀺𑀲𑁂𑀲𑀁 𑀯𑀺𑀧𑀼𑀮𑀫𑀚𑁆𑀛𑀕𑀸;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀅𑀝𑁆𑀞𑁂𑀯 𑀧𑀺𑀡𑁆𑀟𑀧𑀸𑀢𑀸𑀦𑀺, 𑀬𑀁 𑀤𑀸𑀦𑀁 𑀅𑀤𑀤𑀁 𑀧𑀼𑀭𑁂;

𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑀲𑁆𑀲 𑀲𑀗𑁆𑀖𑀲𑁆𑀲, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

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

𑀢𑀧𑁆𑀧𑁂𑀲𑀺𑀁 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑁂𑀦, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑀬𑀸 ¶ ¶ 𑀩𑀳𑀼𑀢𑀭𑀁 𑀤𑀢𑁆𑀯𑀸, 𑀳𑀻𑀦𑀓𑀸𑀬𑀽𑀧𑀕𑀸 𑀅𑀳𑀁 [𑀅𑀳𑀼𑀁 (𑀓. 𑀲𑀻.)];

𑀓𑀣𑀁 𑀢𑁆𑀯𑀁 𑀅𑀧𑁆𑀧𑀢𑀭𑀁 𑀤𑀢𑁆𑀯𑀸, 𑀯𑀺𑀲𑁂𑀲𑀁 𑀯𑀺𑀧𑀼𑀮𑀫𑀚𑁆𑀛𑀕𑀸;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀫𑀦𑁄𑀪𑀸𑀯𑀦𑀻𑀬𑁄 ¶ 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑁄 𑀫𑁂 𑀧𑀼𑀭𑁂 𑀅𑀳𑀼;

𑀢𑀸𑀳𑀁 𑀪𑀢𑁆𑀢𑁂𑀦 [𑀪𑀤𑁆𑀤𑁂 (𑀓.)] 𑀦𑀺𑀫𑀦𑁆𑀢𑁂𑀲𑀺𑀁, 𑀭𑁂𑀯𑀢𑀁 𑀅𑀢𑁆𑀢𑀦𑀝𑁆𑀞𑀫𑀁.

‘‘𑀲𑁄 𑀫𑁂 𑀅𑀢𑁆𑀣𑀧𑀼𑀭𑁂𑀓𑁆𑀔𑀸𑀭𑁄, 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀸𑀬 𑀭𑁂𑀯𑀢𑁄;

𑀲𑀗𑁆𑀖𑁂 𑀤𑁂𑀳𑀻𑀢𑀺 𑀫𑀁𑀯𑁄𑀘, 𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀯𑀘𑀦𑀁 𑀓𑀭𑀺𑀁.

‘‘𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀲𑀗𑁆𑀖𑀕𑀢𑀸, 𑀅𑀧𑁆𑀧𑀫𑁂𑀬𑁆𑀬𑁂 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸;

𑀧𑀼𑀕𑁆𑀕𑀮𑁂𑀲𑀼 𑀢𑀬𑀸 𑀤𑀺𑀦𑁆𑀦𑀁, 𑀦 𑀢𑀁 𑀢𑀯 𑀫𑀳𑀧𑁆𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀇𑀤𑀸𑀦𑁂𑀯𑀸𑀳𑀁 𑀚𑀸𑀦𑀸𑀫𑀺, 𑀲𑀗𑁆𑀖𑁂 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁;

𑀲𑀸𑀳𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀢𑁆𑀢𑀁, 𑀯𑀤𑀜𑁆𑀜𑀽 𑀯𑀻𑀢𑀫𑀘𑁆𑀙𑀭𑀸;

𑀲𑀗𑁆𑀖𑁂 𑀤𑀸𑀦𑀸𑀦𑀺 𑀤𑀲𑁆𑀲𑀸𑀫𑀺 [𑀲𑀗𑁆𑀖𑁂 𑀤𑀸𑀦𑀁 𑀤𑀲𑁆𑀲𑀸𑀫𑀺𑀳𑀁 (𑀲𑁆𑀬𑀸.)], 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀸 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦’’𑀦𑁆𑀢𑀺.

‘‘𑀓𑀸 𑀏𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀪𑀤𑁆𑀤𑁂, 𑀢𑀬𑀸 𑀫𑀦𑁆𑀢𑀬𑀢𑁂 𑀲𑀳;

𑀲𑀩𑁆𑀩𑁂 𑀤𑁂𑀯𑁂 𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑁂, 𑀯𑀡𑁆𑀡𑁂𑀦 𑀅𑀢𑀺𑀭𑁄𑀘𑀢𑀻’’𑀢𑀺.

‘‘𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 𑀤𑁂𑀯𑀺𑀦𑁆𑀤, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀫𑀸𑀦𑀼𑀲𑀓𑁂 𑀪𑀯𑁂;

𑀲𑀳𑀪𑀭𑀺𑀬𑀸 𑀘 𑀫𑁂 𑀆𑀲𑀺, 𑀪𑀕𑀺𑀦𑀻 𑀘 𑀓𑀦𑀺𑀝𑁆𑀞𑀺𑀓𑀸;

𑀲𑀗𑁆𑀖𑁂 𑀤𑀸𑀦𑀸𑀦𑀺 𑀤𑀢𑁆𑀯𑀸𑀦, 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸 𑀯𑀺𑀭𑁄𑀘𑀢𑀻’’𑀢𑀺.

‘‘𑀥𑀫𑁆𑀫𑁂𑀦 𑀧𑀼𑀩𑁆𑀩𑁂 𑀪𑀕𑀺𑀦𑀻, 𑀢𑀬𑀸 𑀪𑀤𑁆𑀤𑁂 𑀯𑀺𑀭𑁄𑀘𑀢𑀺;

𑀬𑀁 𑀲𑀗𑁆𑀖𑀫𑁆𑀳𑀺 𑀅𑀧𑁆𑀧𑀫𑁂𑀬𑁆𑀬𑁂, 𑀧𑀢𑀺𑀝𑁆𑀞𑀸𑀧𑁂𑀲𑀺 𑀤𑀓𑁆𑀔𑀺𑀡𑀁.

‘‘𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀳𑀺 𑀫𑀬𑀸 𑀩𑀼𑀤𑁆𑀥𑁄, 𑀕𑀺𑀚𑁆𑀛𑀓𑀽𑀝𑀫𑁆𑀳𑀺 𑀧𑀩𑁆𑀩𑀢𑁂;

𑀯𑀺𑀧𑀸𑀓𑀁 ¶ 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀲𑁆𑀲, 𑀬𑀢𑁆𑀣 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

‘‘𑀬𑀚𑀫𑀸𑀦𑀸𑀦𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁, 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑀸𑀦 𑀧𑀸𑀡𑀺𑀦𑀁;

𑀓𑀭𑁄𑀢𑀁 𑀑𑀧𑀥𑀺𑀓𑀁 𑀧𑀼𑀜𑁆𑀜𑀁, 𑀬𑀢𑁆𑀣 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

‘‘𑀢𑀁 ¶ 𑀫𑁂 𑀩𑀼𑀤𑁆𑀥𑁄 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀚𑀸𑀦𑀁 𑀓𑀫𑁆𑀫𑀨𑀮𑀁 𑀲𑀓𑀁;

𑀯𑀺𑀧𑀸𑀓𑀁 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀲𑁆𑀲, 𑀬𑀢𑁆𑀣 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

[𑀯𑀺. 𑀯. 𑁭𑁫𑁦; 𑀓𑀣𑀸. 𑁭𑁯𑁮] ‘‘𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀘 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀸, 𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀘 𑀨𑀮𑁂 𑀞𑀺𑀢𑀸;

𑀏𑀲 𑀲𑀗𑁆𑀖𑁄 𑀉𑀚𑀼𑀪𑀽𑀢𑁄, 𑀧𑀜𑁆𑀜𑀸𑀲𑀻𑀮𑀲𑀫𑀸𑀳𑀺𑀢𑁄.

[𑀯𑀺. 𑀯. 𑁭𑁫𑁧; 𑀓𑀣𑀸. 𑁭𑁯𑁮] ‘‘𑀬𑀚𑀫𑀸𑀦𑀸𑀦𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁, 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑀸𑀦 𑀧𑀸𑀡𑀺𑀦𑀁;

𑀓𑀭𑁄𑀢𑀁 𑀑𑀧𑀥𑀺𑀓𑀁 𑀧𑀼𑀜𑁆𑀜𑀁, 𑀲𑀗𑁆𑀖𑁂 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

[𑀯𑀺. 𑀯. 𑁭𑁫𑁨; 𑀓𑀣𑀸. 𑁭𑁯𑁮] ‘‘𑀏𑀲𑁄 ¶ 𑀳𑀺 𑀲𑀗𑁆𑀖𑁄 𑀯𑀺𑀧𑀼𑀮𑁄 𑀫𑀳𑀕𑁆𑀕𑀢𑁄, 𑀏𑀲𑀧𑁆𑀧𑀫𑁂𑀬𑁆𑀬𑁄 𑀉𑀤𑀥𑀻𑀯 𑀲𑀸𑀕𑀭𑁄;

𑀏𑀢𑁂 𑀳𑀺 𑀲𑁂𑀝𑁆𑀞𑀸 𑀦𑀭𑀯𑀻𑀭𑀲𑀸𑀯𑀓𑀸, 𑀧𑀪𑀗𑁆𑀓𑀭𑀸 𑀥𑀫𑁆𑀫𑀫𑀼𑀤𑀻𑀭𑀬𑀦𑁆𑀢𑀺 [𑀥𑀫𑁆𑀫𑀓𑀣𑀁 𑀉𑀤𑀻𑀭𑀬𑀦𑁆𑀢𑀺 (𑀲𑁆𑀬𑀸.)].

[𑀯𑀺. 𑀯. 𑁭𑁫𑁩; 𑀓𑀣𑀸. 𑁭𑁯𑁮] ‘‘𑀢𑁂𑀲𑀁 ¶ 𑀲𑀼𑀤𑀺𑀦𑁆𑀦𑀁 𑀲𑀼𑀳𑀼𑀢𑀁 𑀲𑀼𑀬𑀺𑀝𑁆𑀞𑀁, 𑀬𑁂 𑀲𑀗𑁆𑀖𑀫𑀼𑀤𑁆𑀤𑀺𑀲𑁆𑀲 𑀤𑀤𑀦𑁆𑀢𑀺 𑀤𑀸𑀦𑀁;

𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀲𑀗𑁆𑀖𑀕𑀢𑀸 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸, 𑀫𑀳𑀧𑁆𑀨𑀮𑀸 𑀮𑁄𑀓𑀯𑀺𑀤𑀽𑀦 [𑀮𑁄𑀓𑀯𑀺𑀤𑀽𑀳𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀡𑁆𑀡𑀺𑀢𑀸.

[𑀯𑀺. 𑀯. 𑁭𑁫𑁪; 𑀓𑀣𑀸. 𑁭𑁯𑁮] ‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀬𑀜𑁆𑀜𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀦𑁆𑀢𑀸 [𑀧𑀼𑀜𑁆𑀜𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀦𑁆𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀬𑁂 𑀯𑁂𑀤𑀚𑀸𑀢𑀸 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂;

𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀫𑀘𑁆𑀙𑁂𑀭𑀫𑀮𑀁 𑀲𑀫𑀽𑀮𑀁, 𑀅𑀦𑀺𑀦𑁆𑀤𑀺𑀢𑀸 ¶ 𑀲𑀕𑁆𑀕𑀫𑀼𑀧𑁂𑀦𑁆𑀢𑀺 𑀞𑀸𑀦’’𑀦𑁆𑀢𑀺.

𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀯𑀺𑀫𑀸𑀦𑀁 [𑀤𑀤𑁆𑀤𑀴𑁆𑀳𑀯𑀺𑀫𑀸𑀦𑀁 (𑀓.)] 𑀙𑀝𑁆𑀞𑀁.

‘‘𑀨𑀮𑀺𑀓𑀭𑀚𑀢𑀳𑁂𑀫𑀚𑀸𑀮𑀙𑀦𑁆𑀦𑀁 ¶ , 𑀯𑀺𑀯𑀺𑀥𑀘𑀺𑀢𑁆𑀭𑀢𑀮𑀫𑀤𑁆𑀤𑀲𑀁 𑀲𑀼𑀭𑀫𑁆𑀫𑀁;

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

‘‘𑀪𑀸𑀢𑀺 ¶ 𑀘 𑀤𑀲 𑀤𑀺𑀲𑀸 𑀦𑀪𑁂𑀯 𑀲𑀼𑀭𑀺𑀬𑁄, 𑀲𑀭𑀤𑁂 𑀢𑀫𑁄𑀦𑀼𑀤𑁄 𑀲𑀳𑀲𑁆𑀲𑀭𑀁𑀲𑀻;

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

‘‘𑀫𑀼𑀲𑀢𑀻𑀯 𑀦𑀬𑀦𑀁 𑀲𑀢𑁂𑀭𑀢𑀸𑀯 [𑀲𑀢𑁂𑀭𑀺𑀢𑀸𑀯 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀆𑀓𑀸𑀲𑁂 𑀞𑀧𑀺𑀢𑀫𑀺𑀤𑀁 𑀫𑀦𑀼𑀜𑁆𑀜𑀁;

𑀯𑀻𑀡𑀸𑀫𑀼𑀭𑀚𑀲𑀫𑁆𑀫𑀢𑀸𑀴𑀖𑀼𑀝𑁆𑀞𑀁, 𑀇𑀤𑁆𑀥𑀁 𑀇𑀦𑁆𑀤𑀧𑀼𑀭𑀁 𑀬𑀣𑀸 𑀢𑀯𑁂𑀤𑀁.

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

𑀲𑀸𑀮𑀓𑀼𑀲𑀼𑀫𑀺𑀢𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀸 𑀅𑀲𑁄𑀓𑀸, 𑀯𑀺𑀯𑀺𑀥𑀤𑀼𑀫𑀕𑁆𑀕𑀲𑀼𑀕𑀦𑁆𑀥𑀲𑁂𑀯𑀺𑀢𑀫𑀺𑀤𑀁.

‘‘𑀲𑀴𑀮𑀮𑀩𑀼𑀚𑀪𑀼𑀚𑀓 [𑀲𑀼𑀚𑀓 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑀸 [𑀲𑀜𑁆𑀜𑀢𑀸 (𑀲𑀻.)], 𑀓𑀼𑀲𑀓𑀲𑀼𑀨𑀼𑀮𑁆𑀮𑀺𑀢𑀮𑀢𑀸𑀯𑀮𑀫𑁆𑀩𑀺𑀦𑀻𑀳𑀺 ¶ ;

𑀫𑀡𑀺𑀚𑀸𑀮𑀲𑀤𑀺𑀲𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻, 𑀭𑀫𑁆𑀫𑀸 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸 𑀢𑁂.

‘‘𑀉𑀤𑀓𑀭𑀼𑀳𑀸 𑀘 𑀬𑁂𑀢𑁆𑀣𑀺 𑀧𑀼𑀧𑁆𑀨𑀚𑀸𑀢𑀸, 𑀣𑀮𑀚𑀸 𑀬𑁂 𑀘 𑀲𑀦𑁆𑀢𑀺 𑀭𑀼𑀓𑁆𑀔𑀚𑀸𑀢𑀸;

𑀫𑀸𑀦𑀼𑀲𑀓𑀸𑀫𑀸𑀦𑀼𑀲𑁆𑀲𑀓𑀸 𑀘 𑀤𑀺𑀩𑁆𑀩𑀸, 𑀲𑀩𑁆𑀩𑁂 𑀢𑀼𑀬𑁆𑀳𑀁 𑀦𑀺𑀯𑁂𑀲𑀦𑀫𑁆𑀳𑀺 𑀚𑀸𑀢𑀸.

‘‘𑀓𑀺𑀲𑁆𑀲 𑀲𑀁𑀬𑀫𑀤𑀫𑀲𑁆𑀲𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄, 𑀓𑁂𑀦𑀸𑀲𑀺 𑀓𑀫𑁆𑀫𑀨𑀮𑁂𑀦𑀺𑀥𑀽𑀧𑀧𑀦𑁆𑀦𑀸;

𑀬𑀣𑀸 𑀘 𑀢𑁂 𑀅𑀥𑀺𑀕𑀢𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀢𑀤𑀦𑀼𑀧𑀤𑀁 𑀅𑀯𑀘𑀸𑀲𑀺𑀴𑀸𑀭𑀧𑀫𑁆𑀳𑁂’’𑀢𑀺 [𑀧𑀔𑀼𑀫𑁂𑀢𑀺 (𑀲𑀻.)].

‘‘𑀬𑀣𑀸 ¶ 𑀘 𑀫𑁂 𑀅𑀥𑀺𑀕𑀢𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀓𑁄𑀜𑁆𑀘𑀫𑀬𑀽𑀭𑀘𑀓𑁄𑀭 [𑀘𑀗𑁆𑀓𑁄𑀭 (𑀓.)] 𑀲𑀗𑁆𑀖𑀘𑀭𑀺𑀢𑀁;

𑀤𑀺𑀩𑁆𑀬 [𑀤𑀺𑀩𑁆𑀩 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀺𑀮𑀯𑀳𑀁𑀲𑀭𑀸𑀚𑀘𑀺𑀡𑁆𑀡𑀁, 𑀤𑀺𑀚𑀓𑀸𑀭𑀡𑁆𑀟𑀯𑀓𑁄𑀓𑀺𑀮𑀸𑀪𑀺𑀦𑀤𑀺𑀢𑀁.

‘‘𑀦𑀸𑀦𑀸𑀲𑀦𑁆𑀢𑀸𑀦𑀓𑀧𑀼𑀧𑁆𑀨𑀭𑀼𑀓𑁆𑀔𑀯𑀺𑀯𑀺𑀥𑀸, 𑀧𑀸𑀝𑀮𑀺𑀚𑀫𑁆𑀩𑀼𑀅𑀲𑁄𑀓𑀭𑀼𑀓𑁆𑀔𑀯𑀦𑁆𑀢𑀁;

𑀬𑀣𑀸 𑀘 𑀫𑁂 𑀅𑀥𑀺𑀕𑀢𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀢𑀁 ¶ 𑀢𑁂 𑀧𑀯𑁂𑀤𑀬𑀸𑀫𑀺 [𑀧𑀯𑀤𑀺𑀲𑁆𑀲𑀸𑀫𑀺 (𑀲𑀻.), 𑀧𑀯𑁂𑀤𑀺𑀲𑁆𑀲𑀸𑀫𑀺 (𑀧𑀻.)] 𑀲𑀼𑀡𑁄𑀳𑀺 𑀪𑀦𑁆𑀢𑁂.

‘‘𑀫𑀕𑀥𑀯𑀭𑀧𑀼𑀭𑀢𑁆𑀣𑀺𑀫𑁂𑀦 ¶ , 𑀦𑀸𑀴𑀓𑀕𑀸𑀫𑁄 𑀦𑀸𑀫 𑀅𑀢𑁆𑀣𑀺 𑀪𑀦𑁆𑀢𑁂;

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

‘‘𑀲𑀸𑀳𑀫𑀧𑀘𑀺𑀢𑀢𑁆𑀣𑀥𑀫𑁆𑀫𑀓𑀼𑀲𑀮𑀁 ¶ , 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀧𑀽𑀚𑀺𑀢𑀁 𑀫𑀳𑀦𑁆𑀢𑀁;

𑀉𑀧𑀢𑀺𑀲𑁆𑀲𑀁 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀫𑀧𑁆𑀧𑀫𑁂𑀬𑁆𑀬𑀁, 𑀫𑀼𑀤𑀺𑀢𑀫𑀦𑀸 𑀓𑀼𑀲𑀼𑀫𑁂𑀳𑀺 𑀅𑀩𑁆𑀪𑀼𑀓𑀺𑀭𑀺𑀁 [𑀅𑀩𑁆𑀪𑁄𑀓𑀺𑀭𑀺𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)].

‘‘𑀧𑀭𑀫𑀕𑀢𑀺𑀕𑀢𑀜𑁆𑀘 𑀧𑀽𑀚𑀬𑀺𑀢𑁆𑀯𑀸, 𑀅𑀦𑁆𑀢𑀺𑀫𑀤𑁂𑀳𑀥𑀭𑀁 𑀇𑀲𑀺𑀁 𑀉𑀴𑀸𑀭𑀁;

𑀧𑀳𑀸𑀬 𑀫𑀸𑀦𑀼𑀲𑀓𑀁 𑀲𑀫𑀼𑀲𑁆𑀲𑀬𑀁, 𑀢𑀺𑀤𑀲𑀕𑀢𑀸 𑀇𑀥 𑀫𑀸𑀯𑀲𑀸𑀫𑀺 𑀞𑀸𑀦’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀻𑀢𑀯𑀢𑁆𑀣𑁂 ¶ 𑀧𑀻𑀢𑀥𑀚𑁂, 𑀧𑀻𑀢𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀪𑀽𑀲𑀺𑀢𑁂;

𑀧𑀻𑀢𑀦𑁆𑀢𑀭𑀸𑀳𑀺 𑀯𑀕𑁆𑀕𑀽𑀳𑀺, 𑀅𑀧𑀺𑀴𑀦𑁆𑀥𑀸𑀯 𑀲𑁄𑀪𑀲𑀺.

‘‘𑀓𑀸 ¶ 𑀓𑀫𑁆𑀩𑀼𑀓𑀸𑀬𑀽𑀭𑀥𑀭𑁂 [𑀓𑀓𑀫𑁆𑀩𑀼𑀓𑀸𑀬𑀼𑀭𑀥𑀭𑁂 (𑀲𑁆𑀬𑀸.)], 𑀓𑀜𑁆𑀘𑀦𑀸𑀯𑁂𑀴𑀪𑀽𑀲𑀺𑀢𑁂;

𑀳𑁂𑀫𑀚𑀸𑀮𑀓𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑁂 [𑀧𑀘𑁆𑀙𑀦𑁆𑀦𑁂 (𑀲𑀻.)], 𑀦𑀸𑀦𑀸𑀭𑀢𑀦𑀫𑀸𑀮𑀺𑀦𑀻.

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑀸 𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀕𑀫𑀬𑀸 [𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀓𑀫𑀬𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀘, 𑀫𑀼𑀢𑁆𑀢𑀸𑀫𑀬𑀸 ¶ 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀫𑀬𑀸 𑀘;

𑀫𑀲𑀸𑀭𑀕𑀮𑁆𑀮𑀸 𑀲𑀳𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀕𑀸 [𑀲𑀳𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀓𑀸 (𑀲𑀻.), 𑀲𑀳𑀮𑁄𑀳𑀺𑀢𑀓𑀸 (𑀲𑁆𑀬𑀸.)], 𑀧𑀸𑀭𑁂𑀯𑀢𑀓𑁆𑀔𑀻𑀳𑀺 𑀫𑀡𑀻𑀳𑀺 𑀘𑀺𑀢𑁆𑀢𑀢𑀸.

‘‘𑀓𑁄𑀘𑀺 𑀓𑁄𑀘𑀺 𑀏𑀢𑁆𑀣 𑀫𑀬𑀽𑀭𑀲𑀼𑀲𑁆𑀲𑀭𑁄, 𑀳𑀁𑀲𑀲𑁆𑀲 𑀭𑀜𑁆𑀜𑁄 𑀓𑀭𑀯𑀻𑀓𑀲𑀼𑀲𑁆𑀲𑀭𑁄;

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

‘‘𑀭𑀣𑁄 𑀘 𑀢𑁂 𑀲𑀼𑀪𑁄 𑀯𑀕𑁆𑀕𑀼 [𑀯𑀕𑁆𑀕𑀽 (𑀲𑁆𑀬𑀸.)], 𑀦𑀸𑀦𑀸𑀭𑀢𑀦𑀘𑀺𑀢𑁆𑀢𑀺𑀢𑁄 [𑀦𑀸𑀦𑀸𑀭𑀢𑀦𑀘𑀺𑀢𑁆𑀢𑀗𑁆𑀕𑁄 (𑀲𑁆𑀬𑀸.)];

𑀦𑀸𑀦𑀸𑀯𑀡𑁆𑀡𑀸𑀳𑀺 𑀥𑀸𑀢𑀽𑀳𑀺, 𑀲𑀼𑀯𑀺𑀪𑀢𑁆𑀢𑁄𑀯 𑀲𑁄𑀪𑀢𑀺.

‘‘𑀢𑀲𑁆𑀫𑀺𑀁 𑀭𑀣𑁂 𑀓𑀜𑁆𑀘𑀦𑀩𑀺𑀫𑁆𑀩𑀯𑀡𑁆𑀡𑁂, 𑀬𑀸 𑀢𑁆𑀯𑀁 [𑀬𑀢𑁆𑀣 (𑀓. 𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)] 𑀞𑀺𑀢𑀸 𑀪𑀸𑀲𑀲𑀺 𑀫𑀁 𑀧𑀤𑁂𑀲𑀁;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀚𑀸𑀮𑀁 𑀫𑀡𑀺𑀲𑁄𑀡𑁆𑀡𑀘𑀺𑀢𑁆𑀢𑀺𑀢𑀁 [𑀯𑀺𑀘𑀺𑀢𑁆𑀢𑀁 (𑀓.), 𑀘𑀺𑀢𑁆𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀫𑀼𑀢𑁆𑀢𑀸𑀘𑀺𑀢𑀁 𑀳𑁂𑀫𑀚𑀸𑀮𑁂𑀦 𑀙𑀦𑁆𑀦𑀁 [𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀁 (𑀓.)];

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

‘‘𑀢𑀸𑀳𑀁 𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀓𑀼𑀲𑀮𑀁 𑀩𑀼𑀤𑁆𑀥𑀯𑀡𑁆𑀡𑀺𑀢𑀁;

𑀅𑀧𑁂𑀢𑀲𑁄𑀓𑀸 𑀲𑀼𑀔𑀺𑀢𑀸, 𑀲𑀫𑁆𑀧𑀫𑁄𑀤𑀸𑀫𑀦𑀸𑀫𑀬𑀸’’𑀢𑀺.

𑁯. 𑀯𑀺𑀲𑀸𑀮𑀓𑁆𑀔𑀺𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀓𑀸 ¶ ¶ ¶ 𑀦𑀸𑀫 𑀢𑁆𑀯𑀁 𑀯𑀺𑀲𑀸𑀮𑀓𑁆𑀔𑀺 [𑀯𑀺𑀲𑀸𑀮𑀓𑁆𑀔𑀻 (𑀲𑁆𑀬𑀸.)], 𑀭𑀫𑁆𑀫𑁂 𑀘𑀺𑀢𑁆𑀢𑀮𑀢𑀸𑀯𑀦𑁂;

𑀲𑀫𑀦𑁆𑀢𑀸 𑀅𑀦𑀼𑀧𑀭𑀺𑀬𑀸𑀲𑀺, 𑀦𑀸𑀭𑀻𑀕𑀡𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑀸 [𑀧𑀼𑀭𑀓𑁆𑀔𑀺𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)].

‘‘𑀬𑀤𑀸 ¶ 𑀤𑁂𑀯𑀸 𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑀸, 𑀧𑀯𑀺𑀲𑀦𑁆𑀢𑀺 𑀇𑀫𑀁 𑀯𑀦𑀁;

𑀲𑀬𑁄𑀕𑁆𑀕𑀸 𑀲𑀭𑀣𑀸 𑀲𑀩𑁆𑀩𑁂, 𑀘𑀺𑀢𑁆𑀭𑀸 𑀳𑁄𑀦𑁆𑀢𑀺 𑀇𑀥𑀸𑀕𑀢𑀸.

‘‘𑀢𑀼𑀬𑁆𑀳𑀜𑁆𑀘 𑀇𑀥 𑀧𑀢𑁆𑀢𑀸𑀬, 𑀉𑀬𑁆𑀬𑀸𑀦𑁂 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺𑀬𑀸;

𑀓𑀸𑀬𑁂 𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀻 𑀘𑀺𑀢𑁆𑀢𑀁, 𑀓𑁂𑀦 𑀭𑀽𑀧𑀁 𑀢𑀯𑁂𑀤𑀺𑀲𑀁;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀬𑁂𑀦 𑀓𑀫𑁆𑀫𑁂𑀦 𑀤𑁂𑀯𑀺𑀦𑁆𑀤, 𑀭𑀽𑀧𑀁 𑀫𑀬𑁆𑀳𑀁 𑀕𑀢𑀻 𑀘 𑀫𑁂;

𑀇𑀤𑁆𑀥𑀺 𑀘 𑀆𑀦𑀼𑀪𑀸𑀯𑁄 𑀘, 𑀢𑀁 𑀲𑀼𑀡𑁄𑀳𑀺 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤.

‘‘𑀅𑀳𑀁 𑀭𑀸𑀚𑀕𑀳𑁂 𑀭𑀫𑁆𑀫𑁂, 𑀲𑀼𑀦𑀦𑁆𑀤𑀸 𑀦𑀸𑀫𑀼𑀧𑀸𑀲𑀺𑀓𑀸;

𑀲𑀤𑁆𑀥𑀸 𑀲𑀻𑀮𑁂𑀦 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀭𑀢𑀸 𑀲𑀤𑀸.

‘‘𑀅𑀘𑁆𑀙𑀸𑀤𑀦𑀜𑁆𑀘 𑀪𑀢𑁆𑀢𑀜𑁆𑀘, 𑀲𑁂𑀦𑀸𑀲𑀦𑀁 𑀧𑀤𑀻𑀧𑀺𑀬𑀁;

𑀅𑀤𑀸𑀲𑀺𑀁 𑀉𑀚𑀼𑀪𑀽𑀢𑁂𑀲𑀼, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

‘‘𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀲𑀺𑀁 [𑀘𑀢𑀼𑀤𑁆𑀤𑀲𑀺𑀁 (𑀧𑀻. 𑀓.)] 𑀧𑀜𑁆𑀘𑀤𑀲𑀺𑀁, 𑀬𑀸 𑀘 𑀧𑀓𑁆𑀔𑀲𑁆𑀲 𑀅𑀝𑁆𑀞𑀫𑀻;

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

‘‘𑀉𑀧𑁄𑀲𑀣𑀁 𑀉𑀧𑀯𑀲𑀺𑀲𑁆𑀲𑀁, 𑀲𑀤𑀸 𑀲𑀻𑀮𑁂𑀲𑀼 𑀲𑀁𑀯𑀼𑀢𑀸;

𑀲𑀜𑁆𑀜𑀫𑀸 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀸 𑀘, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀆𑀯𑀲𑀸𑀫𑀳𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀢𑀸, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀸 𑀘 𑀲𑀜𑁆𑀜𑀢𑀸;

𑀣𑁂𑀬𑁆𑀬𑀸 𑀘 𑀅𑀢𑀺𑀘𑀸𑀭𑀸 𑀘, 𑀫𑀚𑁆𑀚𑀧𑀸𑀦𑀸 𑀘 𑀆𑀭𑀓𑀸.

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

𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄, 𑀕𑁄𑀢𑀫𑀲𑁆𑀲 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

‘‘𑀢𑀲𑁆𑀲𑀸 ¶ ¶ 𑀫𑁂 𑀜𑀸𑀢𑀺𑀓𑀼𑀮𑀸 𑀤𑀸𑀲𑀻 [𑀜𑀸𑀢𑀺𑀓𑀼𑀮𑀁 𑀆𑀲𑀻 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀲𑀤𑀸 𑀫𑀸𑀮𑀸𑀪𑀺𑀳𑀸𑀭𑀢𑀺;

𑀢𑀸𑀳𑀁 𑀪𑀕𑀯𑀢𑁄 𑀣𑀽𑀧𑁂, 𑀲𑀩𑁆𑀩𑀫𑁂𑀯𑀸𑀪𑀺𑀭𑁄𑀧𑀬𑀺𑀁.

‘‘𑀉𑀧𑁄𑀲𑀣𑁂 𑀘𑀳𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀫𑀸𑀮𑀸𑀕𑀦𑁆𑀥𑀯𑀺𑀮𑁂𑀧𑀦𑀁;

𑀣𑀽𑀧𑀲𑁆𑀫𑀺𑀁 𑀅𑀪𑀺𑀭𑁄𑀧𑁂𑀲𑀺𑀁, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑁂𑀦 ¶ 𑀓𑀫𑁆𑀫𑁂𑀦 𑀤𑁂𑀯𑀺𑀦𑁆𑀤, 𑀭𑀽𑀧𑀁 𑀫𑀬𑁆𑀳𑀁 𑀕𑀢𑀻 𑀘 𑀫𑁂;

𑀇𑀤𑁆𑀥𑀻 𑀘 𑀆𑀦𑀼𑀪𑀸𑀯𑁄 𑀘, 𑀬𑀁 𑀫𑀸𑀮𑀁 𑀅𑀪𑀺𑀭𑁄𑀧𑀬𑀺𑀁.

‘‘𑀬𑀜𑁆𑀘 𑀲𑀻𑀮𑀯𑀢𑀻 𑀆𑀲𑀺𑀁, 𑀦 𑀢𑀁 𑀢𑀸𑀯 𑀯𑀺𑀧𑀘𑁆𑀘𑀢𑀺;

𑀆𑀲𑀸 𑀘 𑀧𑀦 𑀫𑁂 𑀤𑁂𑀯𑀺𑀦𑁆𑀤, 𑀲𑀓𑀤𑀸𑀕𑀸𑀫𑀺𑀦𑀻 𑀲𑀺𑀬’’𑀦𑁆𑀢𑀺.

𑁧𑁦. 𑀧𑀸𑀭𑀺𑀘𑁆𑀙𑀢𑁆𑀢𑀓𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀧𑀸𑀭𑀺𑀘𑁆𑀙𑀢𑁆𑀢𑀓𑁂 ¶ 𑀓𑁄𑀯𑀺𑀴𑀸𑀭𑁂, 𑀭𑀫𑀡𑀻𑀬𑁂 𑀫𑀦𑁄𑀭𑀫𑁂;

𑀤𑀺𑀩𑁆𑀩𑀫𑀸𑀮𑀁 𑀕𑀦𑁆𑀣𑀫𑀸𑀦𑀸, 𑀕𑀸𑀬𑀦𑁆𑀢𑀻 𑀲𑀫𑁆𑀧𑀫𑁄𑀤𑀲𑀺.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀢𑁂 𑀦𑀘𑁆𑀘𑀫𑀸𑀦𑀸𑀬, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑁂𑀳𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

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

‘‘𑀢𑀲𑁆𑀲𑀸 𑀢𑁂 𑀦𑀘𑁆𑀘𑀫𑀸𑀦𑀸𑀬, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑁂𑀳𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

𑀤𑀺𑀩𑁆𑀩𑀸 𑀕𑀦𑁆𑀥𑀸 𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺, 𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥𑀸 𑀫𑀦𑁄𑀭𑀫𑀸.

‘‘𑀯𑀺𑀯𑀢𑁆𑀢𑀫𑀸𑀦𑀸 𑀓𑀸𑀬𑁂𑀦, 𑀬𑀸 𑀯𑁂𑀡𑀻𑀲𑀼 𑀧𑀺𑀴𑀦𑁆𑀥𑀦𑀸.

𑀢𑁂𑀲𑀁 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑁄, 𑀢𑀽𑀭𑀺𑀬𑁂 𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀺𑀓𑁂 𑀬𑀣𑀸.

‘‘𑀯𑀝𑀁𑀲𑀓𑀸 𑀯𑀸𑀢𑀥𑀼𑀢𑀸 [𑀯𑀸𑀢𑀥𑀽𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀯𑀸𑀢𑁂𑀦 𑀲𑀫𑁆𑀧𑀓𑀫𑁆𑀧𑀺𑀢𑀸;

𑀢𑁂𑀲𑀁 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑁄, 𑀢𑀽𑀭𑀺𑀬𑁂 𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀺𑀓𑁂 𑀬𑀣𑀸.

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

𑀯𑀸𑀢𑀺 ¶ 𑀕𑀦𑁆𑀥𑁄 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀭𑀼𑀓𑁆𑀔𑁄 𑀫𑀜𑁆𑀚𑀽𑀲𑀓𑁄 𑀬𑀣𑀸.

‘‘𑀖𑀸𑀬𑀲𑁂 𑀢𑀁 𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥𑀁 [𑀲𑀼𑀘𑀺𑀁 𑀕𑀦𑁆𑀥𑀁 (𑀲𑀻.)], 𑀭𑀽𑀧𑀁 𑀧𑀲𑁆𑀲𑀲𑀺 𑀅𑀫𑀸𑀦𑀼𑀲𑀁 [𑀫𑀸𑀦𑀼𑀲𑀁 (𑀧𑀻.)];

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀪𑀲𑁆𑀲𑀭𑀁 𑀅𑀘𑁆𑀘𑀺𑀫𑀦𑁆𑀢𑀁, 𑀯𑀡𑁆𑀡𑀕𑀦𑁆𑀥𑁂𑀦 𑀲𑀁𑀬𑀼𑀢𑀁;

𑀅𑀲𑁄𑀓𑀧𑀼𑀧𑁆𑀨𑀫𑀸𑀮𑀸𑀳𑀁, 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀉𑀧𑀦𑀸𑀫𑀬𑀺𑀁.

‘‘𑀢𑀸𑀳𑀁 𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀓𑀼𑀲𑀮𑀁 𑀩𑀼𑀤𑁆𑀥𑀯𑀡𑁆𑀡𑀺𑀢𑀁;

𑀅𑀧𑁂𑀢𑀲𑁄𑀓𑀸 𑀲𑀼𑀔𑀺𑀢𑀸, 𑀲𑀫𑁆𑀧𑀫𑁄𑀤𑀸𑀫𑀦𑀸𑀫𑀬𑀸’’𑀢𑀺.

𑀧𑀸𑀭𑀺𑀘𑁆𑀙𑀢𑁆𑀢𑀓𑀯𑀺𑀫𑀸𑀦𑀁 𑀤𑀲𑀫𑀁.

𑀧𑀸𑀭𑀺𑀘𑁆𑀙𑀢𑁆𑀢𑀓𑀯𑀕𑁆𑀕𑁄 𑀢𑀢𑀺𑀬𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀉𑀴𑀸𑀭𑁄 𑀉𑀘𑁆𑀙𑀼 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑁄, 𑀮𑀢𑀸 𑀘 𑀕𑀼𑀢𑁆𑀢𑀺𑀮𑁂𑀦 𑀘;

𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀧𑁂𑀲𑀫𑀮𑁆𑀮𑀺𑀓𑀸, 𑀯𑀺𑀲𑀸𑀮𑀓𑁆𑀔𑀺 𑀧𑀸𑀭𑀺𑀘𑁆𑀙𑀢𑁆𑀢𑀓𑁄;

𑁧. 𑀫𑀜𑁆𑀚𑀺𑀝𑁆𑀞𑀓𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀫𑀜𑁆𑀚𑀺𑀝𑁆𑀞𑀓𑁂 ¶ ¶ [𑀫𑀜𑁆𑀚𑁂𑀝𑁆𑀞𑀓𑁂 (𑀲𑀻.)] 𑀯𑀺𑀫𑀸𑀦𑀲𑁆𑀫𑀺𑀁, 𑀲𑁄𑀡𑁆𑀡𑀯𑀸𑀮𑀼𑀓𑀲𑀦𑁆𑀣𑀢𑁂 [𑀲𑁄𑀯𑀡𑁆𑀡𑀯𑀸𑀮𑀼𑀓𑀲𑀦𑁆𑀣𑀢𑁂 (𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀲𑁄𑀯𑀡𑁆𑀡𑀯𑀸𑀮𑀺𑀓𑀲𑀦𑁆𑀣𑀢𑁂 (𑀓.)];

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

‘‘𑀢𑀫𑁆𑀳𑀸 𑀯𑀺𑀫𑀸𑀦𑀸 𑀑𑀭𑀼𑀬𑁆𑀳, 𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸 𑀭𑀢𑀦𑀸𑀫𑀬𑀸;

𑀑𑀕𑀸𑀳𑀲𑀺 ¶ 𑀲𑀸𑀮𑀯𑀦𑀁, 𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁.

‘‘𑀬𑀲𑁆𑀲 𑀬𑀲𑁆𑀲𑁂𑀯 𑀲𑀸𑀮𑀲𑁆𑀲, 𑀫𑀽𑀮𑁂 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀲𑁄 𑀲𑁄 𑀫𑀼𑀜𑁆𑀘𑀢𑀺 𑀧𑀼𑀧𑁆𑀨𑀸𑀦𑀺, 𑀑𑀦𑀫𑀺𑀢𑁆𑀯𑀸 𑀤𑀼𑀫𑀼𑀢𑁆𑀢𑀫𑁄.

‘‘𑀯𑀸𑀢𑁂𑀭𑀺𑀢𑀁 𑀲𑀸𑀮𑀯𑀦𑀁, 𑀆𑀥𑀼𑀢𑀁 [𑀆𑀥𑀽𑀢𑀁 (𑀲𑀻.)] 𑀤𑀺𑀚𑀲𑁂𑀯𑀺𑀢𑀁;

𑀯𑀸𑀢𑀺 𑀕𑀦𑁆𑀥𑁄 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀭𑀼𑀓𑁆𑀔𑁄 𑀫𑀜𑁆𑀚𑀽𑀲𑀓𑁄 𑀬𑀣𑀸.

‘‘𑀖𑀸𑀬𑀲𑁂 𑀢𑀁 𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥𑀁, 𑀭𑀽𑀧𑀁 𑀧𑀲𑁆𑀲𑀲𑀺 𑀅𑀫𑀸𑀦𑀼𑀲𑀁;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

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

𑀩𑀼𑀤𑁆𑀥𑀁 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦, 𑀲𑀸𑀮𑀧𑀼𑀧𑁆𑀨𑁂𑀳𑀺 𑀑𑀓𑀺𑀭𑀺𑀁.

‘‘𑀯𑀝𑀁𑀲𑀓𑀜𑁆𑀘 𑀲𑀼𑀓𑀢𑀁, 𑀲𑀸𑀮𑀧𑀼𑀧𑁆𑀨𑀫𑀬𑀁 𑀅𑀳𑀁;

𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀉𑀧𑀦𑀸𑀫𑁂𑀲𑀺𑀁, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑀸𑀳𑀁 ¶ 𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀓𑀼𑀲𑀮𑀁 𑀩𑀼𑀤𑁆𑀥𑀯𑀡𑁆𑀡𑀺𑀢𑀁;

𑀅𑀧𑁂𑀢𑀲𑁄𑀓𑀸 𑀲𑀼𑀔𑀺𑀢𑀸, 𑀲𑀫𑁆𑀧𑀫𑁄𑀤𑀸𑀫𑀦𑀸𑀫𑀬𑀸’’𑀢𑀺.

‘‘𑀧𑀪𑀲𑁆𑀲𑀭𑀯𑀭𑀯𑀡𑁆𑀡𑀦𑀺𑀪𑁂 ¶ , 𑀲𑀼𑀭𑀢𑁆𑀢𑀯𑀢𑁆𑀣𑀯𑀲𑀦𑁂 [𑀯𑀢𑁆𑀣𑀦𑀺𑀯𑀸𑀲𑀦𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)];

𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑁂 𑀘𑀦𑁆𑀤𑀦𑀭𑀼𑀘𑀺𑀭𑀕𑀢𑁆𑀢𑁂, 𑀓𑀸 𑀢𑁆𑀯𑀁 𑀲𑀼𑀪𑁂 𑀤𑁂𑀯𑀢𑁂 𑀯𑀦𑁆𑀤𑀲𑁂 𑀫𑀫𑀁.

‘‘𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑁄 ¶ 𑀘 𑀢𑁂 𑀫𑀳𑀕𑁆𑀖𑁄, 𑀦𑀸𑀦𑀸𑀭𑀢𑀦𑀘𑀺𑀢𑁆𑀢𑀺𑀢𑁄 ¶ 𑀭𑀼𑀘𑀺𑀭𑁄;

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

‘‘𑀓𑀺𑀁 𑀢𑁆𑀯𑀁 𑀧𑀼𑀭𑁂 𑀲𑀼𑀘𑀭𑀺𑀢𑀫𑀸𑀘𑀭𑀻 𑀪𑀤𑁆𑀤𑁂, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀯𑀺𑀧𑀸𑀓𑀁;

𑀅𑀦𑀼𑀪𑁄𑀲𑀺 𑀤𑁂𑀯𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁, 𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔;

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀢𑁂 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲, 𑀫𑀸𑀮𑀁 𑀨𑀸𑀡𑀺𑀢𑀜𑁆𑀘 𑀅𑀤𑀤𑀁 𑀪𑀦𑁆𑀢𑁂;

𑀢𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀯𑀺𑀧𑀸𑀓𑀁, 𑀅𑀦𑀼𑀪𑁄𑀫𑀺 𑀤𑁂𑀯𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁.

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

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

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

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

‘‘𑀬𑁂𑀲𑀁 𑀅𑀢𑁆𑀣𑀺 𑀲𑀤𑁆𑀥𑀸 𑀩𑀼𑀤𑁆𑀥𑁂, 𑀥𑀫𑁆𑀫𑁂 ¶ 𑀘 𑀲𑀗𑁆𑀖𑀭𑀢𑀦𑁂;

𑀢𑁂 𑀫𑀁 𑀅𑀢𑀺𑀯𑀺𑀭𑁄𑀘𑀦𑁆𑀢𑀺, 𑀆𑀬𑀼𑀦𑀸 𑀬𑀲𑀲𑀸 𑀲𑀺𑀭𑀺𑀬𑀸.

‘‘𑀧𑀢𑀸𑀧𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦 𑀉𑀢𑁆𑀢𑀭𑀺𑀢𑀭𑀸,

𑀅𑀜𑁆𑀜𑁂 𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑀢𑀭𑀸 𑀫𑀬𑀸 𑀤𑁂𑀯𑀸’’𑀢𑀺;

‘‘𑀅𑀮𑀗𑁆𑀓𑀢𑀸 ¶ ¶ 𑀫𑀡𑀺𑀓𑀜𑁆𑀘𑀦𑀸𑀘𑀺𑀢𑀁, 𑀲𑁄𑀯𑀡𑁆𑀡𑀚𑀸𑀮𑀘𑀺𑀢𑀁 𑀫𑀳𑀦𑁆𑀢𑀁;

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

‘‘𑀦𑀸𑀕𑀲𑁆𑀲 𑀤𑀦𑁆𑀢𑁂𑀲𑀼 𑀤𑀼𑀯𑁂𑀲𑀼 𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸, 𑀅𑀘𑁆𑀙𑁄𑀤𑀓𑀸 [𑀅𑀘𑁆𑀙𑁄𑀤𑀺𑀓𑀸 (𑀲𑀻. 𑀓.)] 𑀧𑀤𑀼𑀫𑀺𑀦𑀺𑀬𑁄 𑀲𑀼𑀨𑀼𑀮𑁆𑀮𑀸;

𑀧𑀤𑀼𑀫𑁂𑀲𑀼 𑀘 𑀢𑀼𑀭𑀺𑀬𑀕𑀡𑀸 𑀧𑀪𑀺𑀚𑁆𑀚𑀭𑁂, 𑀇𑀫𑀸 𑀘 𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀫𑀦𑁄𑀳𑀭𑀸𑀬𑁄.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑀸, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀩𑀸𑀭𑀸𑀡𑀲𑀺𑀬𑀁 ¶ 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲𑀳𑀁 𑀯𑀢𑁆𑀣𑀬𑀼𑀕𑀁 𑀅𑀤𑀸𑀲𑀺𑀁;

𑀧𑀸𑀤𑀸𑀦𑀺 𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸 [𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯 (𑀲𑀻.)] 𑀙𑀫𑀸 𑀦𑀺𑀲𑀻𑀤𑀺𑀁, 𑀯𑀺𑀢𑁆𑀢𑀸 𑀘𑀳𑀁 𑀅𑀜𑁆𑀚𑀮𑀺𑀓𑀁 𑀅𑀓𑀸𑀲𑀺𑀁.

‘‘𑀩𑀼𑀤𑁆𑀥𑁄 𑀘 𑀫𑁂 𑀓𑀜𑁆𑀘𑀦𑀲𑀦𑁆𑀦𑀺𑀪𑀢𑁆𑀢𑀘𑁄, 𑀅𑀤𑁂𑀲𑀬𑀺 𑀲𑀫𑀼𑀤𑀬𑀤𑀼𑀓𑁆𑀔𑀦𑀺𑀘𑁆𑀘𑀢𑀁;

𑀅𑀲𑀗𑁆𑀔𑀢𑀁 𑀤𑀼𑀓𑁆𑀔𑀦𑀺𑀭𑁄𑀥𑀲𑀲𑁆𑀲𑀢𑀁, 𑀫𑀕𑁆𑀕𑀁 𑀅𑀤𑁂𑀲𑀬𑀺 [𑀅𑀤𑁂𑀲𑁂𑀲𑀺 (𑀲𑀻.)] 𑀬𑀢𑁄 𑀯𑀺𑀚𑀸𑀦𑀺𑀲𑀁;

‘‘𑀅𑀧𑁆𑀧𑀸𑀬𑀼𑀓𑀻 ¶ 𑀓𑀸𑀮𑀓𑀢𑀸 𑀢𑀢𑁄 𑀘𑀼𑀢𑀸, 𑀉𑀧𑀧𑀦𑁆𑀦𑀸 𑀢𑀺𑀤𑀲𑀕𑀡𑀁 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻;

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

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 ¶ ¶ 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀜𑁆𑀘 ¶ 𑀩𑀸𑀭𑀸𑀡𑀲𑀺𑀬𑀁, 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲𑀸𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼𑀦𑁄;

𑀅𑀤𑀸𑀲𑀺𑀁 𑀲𑀼𑀓𑁆𑀔𑀓𑀼𑀫𑁆𑀫𑀸𑀲𑀁, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀲𑀼𑀓𑁆𑀔𑀸𑀬 𑀅𑀮𑁄𑀡𑀺𑀓𑀸𑀬 𑀘, 𑀧𑀲𑁆𑀲 𑀨𑀮𑀁 𑀓𑀼𑀫𑁆𑀫𑀸𑀲𑀧𑀺𑀡𑁆𑀟𑀺𑀬𑀸;

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

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… ¶ 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁫. 𑀓𑀜𑁆𑀚𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀅𑀦𑁆𑀥𑀓𑀯𑀺𑀦𑁆𑀤𑀫𑁆𑀳𑀺, 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲𑀸𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼𑀦𑁄;

𑀅𑀤𑀸𑀲𑀺𑀁 𑀓𑁄𑀮𑀲𑀫𑁆𑀧𑀸𑀓𑀁, 𑀓𑀜𑁆𑀚𑀺𑀓𑀁 𑀢𑁂𑀮𑀥𑀽𑀧𑀺𑀢𑀁.

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

𑀅𑀤𑀸𑀲𑀺𑀁 𑀉𑀚𑀼𑀪𑀽𑀢𑀲𑁆𑀫𑀺𑀁 [𑀉𑀚𑀼𑀪𑀽𑀢𑁂𑀲𑀼 (𑀓.)], 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

‘‘𑀬𑀸 ¶ ¶ 𑀫𑀳𑁂𑀲𑀺𑀢𑁆𑀢𑀁 𑀓𑀸𑀭𑁂𑀬𑁆𑀬, 𑀘𑀓𑁆𑀓𑀯𑀢𑁆𑀢𑀺𑀲𑁆𑀲 𑀭𑀸𑀚𑀺𑀦𑁄;

𑀦𑀸𑀭𑀻 𑀲𑀩𑁆𑀩𑀗𑁆𑀕𑀓𑀮𑁆𑀬𑀸𑀡𑀻, 𑀪𑀢𑁆𑀢𑀼 𑀘𑀸𑀦𑁄𑀫𑀤𑀲𑁆𑀲𑀺𑀓𑀸;

𑀏𑀓𑀲𑁆𑀲 ¶ 𑀓𑀜𑁆𑀚𑀺𑀓𑀤𑀸𑀦𑀲𑁆𑀲, 𑀓𑀮𑀁 𑀦𑀸𑀕𑁆𑀖𑀢𑀺 𑀲𑁄𑀴𑀲𑀺𑀁.

‘‘𑀲𑀢𑀁 𑀦𑀺𑀓𑁆𑀔𑀸 𑀲𑀢𑀁 𑀅𑀲𑁆𑀲𑀸, 𑀲𑀢𑀁 𑀅𑀲𑁆𑀲𑀢𑀭𑀻𑀭𑀣𑀸;

𑀲𑀢𑀁 𑀓𑀜𑁆𑀜𑀸𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀸;

𑀏𑀓𑀲𑁆𑀲 𑀓𑀜𑁆𑀚𑀺𑀓𑀤𑀸𑀦𑀲𑁆𑀲, 𑀓𑀮𑀁 𑀦𑀸𑀕𑁆𑀖𑀦𑁆𑀢𑀺 𑀲𑁄𑀴𑀲𑀺𑀁.

‘‘𑀲𑀢𑀁 𑀳𑁂𑀫𑀯𑀢𑀸 𑀦𑀸𑀕𑀸, 𑀈𑀲𑀸𑀤𑀦𑁆𑀢𑀸 𑀉𑀭𑀽𑀴𑁆𑀳𑀯𑀸;

𑀲𑀼𑀯𑀡𑁆𑀡𑀓𑀘𑁆𑀙𑀸 𑀫𑀸𑀢𑀗𑁆𑀕𑀸, 𑀳𑁂𑀫𑀓𑀧𑁆𑀧𑀦𑀯𑀸𑀲𑀲𑀸;

𑀏𑀓𑀲𑁆𑀲 𑀓𑀜𑁆𑀚𑀺𑀓𑀤𑀸𑀦𑀲𑁆𑀲, 𑀓𑀮𑀁 𑀦𑀸𑀕𑁆𑀖𑀦𑁆𑀢𑀺 𑀲𑁄𑀴𑀲𑀺𑀁.

‘‘𑀘𑀢𑀼𑀦𑁆𑀦𑀫𑀧𑀺 ¶ 𑀤𑀻𑀧𑀸𑀦𑀁, 𑀇𑀲𑁆𑀲𑀭𑀁 𑀬𑁄𑀥 𑀓𑀸𑀭𑀬𑁂;

𑀏𑀓𑀲𑁆𑀲 𑀓𑀜𑁆𑀚𑀺𑀓𑀤𑀸𑀦𑀲𑁆𑀲, 𑀓𑀮𑀁 𑀦𑀸𑀕𑁆𑀖𑀢𑀺 𑀲𑁄𑀴𑀲𑀺’’𑀦𑁆𑀢𑀺.

𑀓𑀜𑁆𑀚𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀧𑀜𑁆𑀘𑀫𑀁.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂… 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀢𑁂 𑀦𑀘𑁆𑀘𑀫𑀸𑀦𑀸𑀬, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑁂𑀳𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

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

‘‘𑀢𑀲𑁆𑀲𑀸 𑀢𑁂 𑀦𑀘𑁆𑀘𑀫𑀸𑀦𑀸𑀬, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑁂𑀳𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

𑀤𑀺𑀩𑁆𑀩𑀸 𑀕𑀦𑁆𑀥𑀸 𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺, 𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥𑀸 𑀫𑀦𑁄𑀭𑀫𑀸.

‘‘𑀯𑀺𑀯𑀢𑁆𑀢𑀫𑀸𑀦𑀸 𑀓𑀸𑀬𑁂𑀦, 𑀬𑀸 𑀯𑁂𑀡𑀻𑀲𑀼 𑀧𑀺𑀴𑀦𑁆𑀥𑀦𑀸;

𑀢𑁂𑀲𑀁 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑁄, 𑀢𑀼𑀭𑀺𑀬𑁂 𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀺𑀓𑁂 𑀬𑀣𑀸.

‘‘𑀯𑀝𑀁𑀲𑀓𑀸 𑀯𑀸𑀢𑀥𑀼𑀢𑀸, 𑀯𑀸𑀢𑁂𑀦 𑀲𑀫𑁆𑀧𑀓𑀫𑁆𑀧𑀺𑀢𑀸;

𑀢𑁂𑀲𑀁 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑁄, 𑀢𑀼𑀭𑀺𑀬𑁂 𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀺𑀓𑁂 𑀬𑀣𑀸.

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

𑀯𑀸𑀢𑀺 𑀕𑀦𑁆𑀥𑁄 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀭𑀼𑀓𑁆𑀔𑁄 𑀫𑀜𑁆𑀚𑀽𑀲𑀓𑁄 𑀬𑀣𑀸.

‘‘𑀖𑀸𑀬𑀲𑁂 𑀢𑀁 𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥𑀁, 𑀭𑀽𑀧𑀁 𑀧𑀲𑁆𑀲𑀲𑀺 𑀅𑀫𑀸𑀦𑀼𑀲𑀁;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀲𑀸𑀯𑀢𑁆𑀣𑀺𑀬𑀁 ¶ ¶ 𑀫𑀬𑁆𑀳𑀁 𑀲𑀔𑀻 𑀪𑀤𑀦𑁆𑀢𑁂, 𑀲𑀗𑁆𑀖𑀲𑁆𑀲 𑀓𑀸𑀭𑁂𑀲𑀺 𑀫𑀳𑀸𑀯𑀺𑀳𑀸𑀭𑀁;

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

‘‘𑀢𑀸𑀬𑁂𑀯 ¶ 𑀫𑁂 𑀲𑀼𑀤𑁆𑀥𑀦𑀼𑀫𑁄𑀤𑀦𑀸𑀬, 𑀮𑀤𑁆𑀥𑀁 𑀯𑀺𑀫𑀸𑀦𑀩𑁆𑀪𑀼𑀢𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀁;

𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀲𑁄𑀴𑀲𑀬𑁄𑀚𑀦𑀸𑀦𑀺, 𑀯𑁂𑀳𑀸𑀬𑀲𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀇𑀤𑁆𑀥𑀺𑀬𑀸 𑀫𑀫.

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

𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀸 𑀆𑀪𑀦𑁆𑀢𑀺, 𑀲𑀫𑀦𑁆𑀢𑀸 𑀲𑀢𑀬𑁄𑀚𑀦𑀁.

‘‘𑀧𑁄𑀓𑁆𑀔𑀭𑀜𑁆𑀜𑁄 𑀘 𑀫𑁂 𑀏𑀢𑁆𑀣, 𑀧𑀼𑀣𑀼𑀮𑁄𑀫𑀦𑀺𑀲𑁂𑀯𑀺𑀢𑀸;

𑀅𑀘𑁆𑀙𑁄𑀤𑀓𑀸 [𑀅𑀘𑁆𑀙𑁄𑀤𑀺𑀓𑀸 (𑀲𑀻.)] 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀸, 𑀲𑁄𑀡𑁆𑀡𑀯𑀸𑀮𑀼𑀓𑀲𑀦𑁆𑀣𑀢𑀸.

‘‘𑀦𑀸𑀦𑀸𑀧𑀤𑀼𑀫𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸, 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀲𑀫𑁄𑀢𑀢𑀸 [𑀧𑀡𑁆𑀟𑀭𑀻𑀓𑀲𑀫𑁄𑀦𑀢𑀸 (𑀲𑀻.)];

𑀲𑀼𑀭𑀪𑀻 𑀲𑀫𑁆𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺, 𑀫𑀦𑀼𑀜𑁆𑀜𑀸 𑀫𑀸𑀮𑀼𑀢𑁂𑀭𑀺𑀢𑀸.

‘‘𑀚𑀫𑁆𑀩𑀼𑀬𑁄 𑀧𑀦𑀲𑀸 𑀢𑀸𑀮𑀸, 𑀦𑀸𑀴𑀺𑀓𑁂𑀭𑀯𑀦𑀸𑀦𑀺 𑀘;

𑀅𑀦𑁆𑀢𑁄𑀦𑀺𑀯𑁂𑀲𑀦𑁂 𑀚𑀸𑀢𑀸, 𑀦𑀸𑀦𑀸𑀭𑀼𑀓𑁆𑀔𑀸 𑀅𑀭𑁄𑀧𑀺𑀫𑀸.

‘‘𑀦𑀸𑀦𑀸𑀢𑀽𑀭𑀺𑀬𑀲𑀗𑁆𑀖𑀼𑀝𑁆𑀞𑀁 ¶ , 𑀅𑀘𑁆𑀙𑀭𑀸𑀕𑀡𑀖𑁄𑀲𑀺𑀢𑀁;

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

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀅𑀩𑁆𑀪𑀼𑀢𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀁, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀲𑀩𑁆𑀩𑀲𑁄𑀧𑀪𑀁;

𑀫𑀫 𑀓𑀫𑁆𑀫𑁂𑀳𑀺 𑀦𑀺𑀩𑁆𑀩𑀢𑁆𑀢𑀁, 𑀅𑀮𑀁 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺 𑀓𑀸𑀢𑀯𑁂’’𑀢𑀺.

‘‘𑀢𑀸𑀬𑁂𑀯 𑀢𑁂 𑀲𑀼𑀤𑁆𑀥𑀦𑀼𑀫𑁄𑀤𑀦𑀸𑀬, 𑀮𑀤𑁆𑀥𑀁 𑀯𑀺𑀫𑀸𑀦𑀩𑁆𑀪𑀼𑀢𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀁;

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

‘‘𑀬𑀸 𑀲𑀸 𑀅𑀳𑀼 𑀫𑀬𑁆𑀳𑀁 𑀲𑀔𑀻 𑀪𑀤𑀦𑁆𑀢𑁂, 𑀲𑀗𑁆𑀖𑀲𑁆𑀲 𑀓𑀸𑀭𑁂𑀲𑀺 𑀫𑀳𑀸𑀯𑀺𑀳𑀸𑀭𑀁;

𑀯𑀺𑀜𑁆𑀜𑀸𑀢𑀥𑀫𑁆𑀫𑀸 𑀲𑀸 𑀅𑀤𑀸𑀲𑀺 𑀤𑀸𑀦𑀁, 𑀉𑀧𑁆𑀧𑀦𑁆𑀦𑀸 𑀦𑀺𑀫𑁆𑀫𑀸𑀦𑀭𑀢𑀻𑀲𑀼 𑀤𑁂𑀯𑁂𑀲𑀼.

‘‘𑀧𑀚𑀸𑀧𑀢𑀻 ¶ 𑀢𑀲𑁆𑀲 𑀲𑀼𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀲𑁆𑀲, 𑀅𑀘𑀺𑀦𑁆𑀢𑀺𑀬𑀸 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑀸 𑀢𑀲𑁆𑀲;

𑀬𑀫𑁂𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀲𑀺 𑀓𑀼𑀳𑀺𑀁 𑀉𑀧𑁆𑀧𑀦𑁆𑀦𑀸 [𑀉𑀧𑀧𑀦𑁆𑀦𑀸 (𑀓.)] 𑀲𑀸𑀢𑀺, 𑀢𑀁 𑀢𑁂 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺𑀁 𑀅𑀦𑀜𑁆𑀜𑀣𑀸 𑀅𑀳𑀁.

‘‘𑀢𑁂𑀦𑀳𑀜𑁆𑀜𑁂𑀧𑀺 𑀲𑀫𑀸𑀤𑀧𑁂𑀣, 𑀲𑀗𑁆𑀖𑀲𑁆𑀲 𑀤𑀸𑀦𑀸𑀦𑀺 𑀤𑀤𑀸𑀣 𑀯𑀺𑀢𑁆𑀢𑀸;

𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀲𑀼𑀡𑀸𑀣 𑀧𑀲𑀦𑁆𑀦𑀫𑀸𑀦𑀲𑀸, 𑀲𑀼𑀤𑀼𑀮𑁆𑀮𑀪𑁄 𑀮𑀤𑁆𑀥𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑀸𑀪𑁄.

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

𑀲𑀗𑁆𑀖𑀲𑁆𑀲 𑀤𑀸𑀦𑀸𑀦𑀺 𑀤𑀤𑀸𑀣 𑀯𑀺𑀢𑁆𑀢𑀸, 𑀫𑀳𑀧𑁆𑀨𑀮𑀸 𑀬𑀢𑁆𑀣 𑀪𑀯𑀦𑁆𑀢𑀺 𑀤𑀓𑁆𑀔𑀺𑀡𑀸.

[𑀔𑀼. 𑀧𑀸. 𑁬.𑁬; 𑀲𑀼. 𑀦𑀺. 𑁨𑁨𑁯] ‘‘𑀬𑁂 ¶ 𑀧𑀼𑀕𑁆𑀕𑀮𑀸 𑀅𑀝𑁆𑀞 𑀲𑀢𑀁 𑀧𑀲𑀢𑁆𑀣𑀸, 𑀘𑀢𑁆𑀢𑀸𑀭𑀺 𑀏𑀢𑀸𑀦𑀺 𑀬𑀼𑀕𑀸𑀦𑀺 𑀳𑁄𑀦𑁆𑀢𑀺;

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

[𑀯𑀺. 𑀯. 𑁬𑁪𑁧] ‘‘𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀘 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀸, 𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀘 𑀨𑀮𑁂 𑀞𑀺𑀢𑀸;

𑀏𑀲 𑀲𑀗𑁆𑀖𑁄 𑀉𑀚𑀼𑀪𑀽𑀢𑁄, 𑀧𑀜𑁆𑀜𑀸𑀲𑀻𑀮𑀲𑀫𑀸𑀳𑀺𑀢𑁄.

[𑀯𑀺. 𑀯. 𑁬𑁪𑁨] ‘‘𑀬𑀚𑀫𑀸𑀦𑀸𑀦𑀁 ¶ 𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁, 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑀸𑀦 𑀧𑀸𑀡𑀺𑀦𑀁;

𑀓𑀭𑁄𑀢𑀁 𑀑𑀧𑀥𑀺𑀓𑀁 𑀧𑀼𑀜𑁆𑀜𑀁, 𑀲𑀗𑁆𑀖𑁂 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

[𑀯𑀺. 𑀯. 𑁬𑁪𑁩] ‘‘𑀏𑀲𑁄 𑀳𑀺 𑀲𑀗𑁆𑀖𑁄 𑀯𑀺𑀧𑀼𑀮𑁄 𑀫𑀳𑀕𑁆𑀕𑀢𑁄, 𑀏𑀲𑀧𑁆𑀧𑀫𑁂𑀬𑁆𑀬𑁄 𑀉𑀤𑀥𑀻𑀯 𑀲𑀸𑀕𑀭𑁄;

𑀏𑀢𑁂𑀳𑀺 𑀲𑁂𑀝𑁆𑀞𑀸 𑀦𑀭𑀯𑀻𑀭𑀲𑀸𑀯𑀓𑀸, 𑀧𑀪𑀗𑁆𑀓𑀭𑀸 𑀥𑀫𑁆𑀫𑀫𑀼𑀤𑀻𑀭𑀬𑀦𑁆𑀢𑀺 [𑀦𑀢𑁆𑀣𑁂𑀢𑁆𑀣 𑀧𑀸𑀞𑀪𑁂𑀤𑁄].

[𑀯𑀺. 𑀯. 𑁬𑁪𑁪] ‘‘𑀢𑁂𑀲𑀁 𑀲𑀼𑀤𑀺𑀦𑁆𑀦𑀁 𑀲𑀼𑀳𑀼𑀢𑀁 𑀲𑀼𑀬𑀺𑀝𑁆𑀞𑀁, 𑀬𑁂 𑀲𑀗𑁆𑀖𑀫𑀼𑀤𑁆𑀤𑀺𑀲𑁆𑀲 𑀤𑀤𑀦𑁆𑀢𑀺 𑀤𑀸𑀦𑀁;

𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀲𑀗𑁆𑀖𑀕𑀢𑀸 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸, 𑀫𑀳𑀧𑁆𑀨𑀮𑀸 𑀮𑁄𑀓𑀯𑀺𑀤𑀽𑀦 [𑀮𑁄𑀓𑀯𑀺𑀤𑀽𑀳𑀺 (𑀓.)] 𑀯𑀡𑁆𑀡𑀺𑀢𑀸.

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 ¶ ¶ 𑀬𑀜𑁆𑀜𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀦𑁆𑀢𑀸, 𑀬𑁂 𑀯𑁂𑀤𑀚𑀸𑀢𑀸 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀮𑁄𑀓𑁂;

𑀯𑀺𑀦𑁂𑀬𑁆𑀬 𑀫𑀘𑁆𑀙𑁂𑀭𑀫𑀮𑀁 𑀲𑀫𑀽𑀮𑀁, 𑀅𑀦𑀺𑀦𑁆𑀤𑀺𑀢𑀸 𑀲𑀕𑁆𑀕𑀫𑀼𑀧𑁂𑀦𑁆𑀢𑀺 𑀞𑀸𑀦’’𑀦𑁆𑀢𑀺.

𑀪𑀸𑀡𑀯𑀸𑀭𑀁 𑀤𑀼𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁭. 𑀘𑀢𑀼𑀭𑀺𑀢𑁆𑀣𑀺𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 ¶ 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀇𑀦𑁆𑀤𑀻𑀯𑀭𑀸𑀦𑀁 ¶ 𑀳𑀢𑁆𑀣𑀓𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲;

𑀏𑀲𑀺𑀓𑀸𑀦𑀁 𑀉𑀡𑁆𑀡𑀢𑀲𑁆𑀫𑀺𑀁, 𑀦𑀕𑀭𑀯𑀭𑁂 𑀧𑀡𑁆𑀡𑀓𑀢𑁂 𑀭𑀫𑁆𑀫𑁂.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑁆𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… ¶ 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀦𑀻𑀮𑀼𑀧𑁆𑀧𑀮𑀳𑀢𑁆𑀣𑀓𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁, 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲;

𑀏𑀲𑀺𑀓𑀸𑀦𑀁 𑀉𑀡𑁆𑀡𑀢𑀲𑁆𑀫𑀺𑀁, 𑀦𑀕𑀭𑀯𑀭𑁂 𑀧𑀡𑁆𑀡𑀓𑀢𑁂 𑀭𑀫𑁆𑀫𑁂.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 ¶ 𑀯𑀡𑁆𑀡𑁂𑀦…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀑𑀤𑀸𑀢𑀫𑀽𑀮𑀓𑀁 𑀳𑀭𑀺𑀢𑀧𑀢𑁆𑀢𑀁, 𑀉𑀤𑀓𑀲𑁆𑀫𑀺𑀁 𑀲𑀭𑁂 𑀚𑀸𑀢𑀁 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁;

𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲, 𑀏𑀲𑀺𑀓𑀸𑀦𑀁 𑀉𑀡𑁆𑀡𑀢𑀲𑁆𑀫𑀺𑀁;

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀲𑀼𑀫𑀦𑀸 𑀲𑀼𑀫𑀦𑀲𑁆𑀲 𑀲𑀼𑀫𑀦𑀫𑀓𑀼𑀴𑀸𑀦𑀺, 𑀤𑀦𑁆𑀢𑀯𑀡𑁆𑀡𑀸𑀦𑀺 𑀅𑀳𑀫𑀤𑀸𑀲𑀺𑀁;

𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀘𑀭𑀦𑁆𑀢𑀲𑁆𑀲, 𑀏𑀲𑀺𑀓𑀸𑀦𑀁 𑀉𑀡𑁆𑀡𑀢𑀲𑁆𑀫𑀺𑀁;

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

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

‘‘𑀤𑀺𑀩𑁆𑀩𑀁 ¶ 𑀢𑁂 𑀅𑀫𑁆𑀩𑀯𑀦𑀁 𑀭𑀫𑁆𑀫𑀁, 𑀧𑀸𑀲𑀸𑀤𑁂𑀢𑁆𑀣 𑀫𑀳𑀮𑁆𑀮𑀓𑁄;

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

‘‘𑀧𑀤𑀻𑀧𑁄 𑀘𑁂𑀢𑁆𑀣 𑀚𑀮𑀢𑀺, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀲𑁄𑀯𑀡𑁆𑀡𑀬𑁄 𑀫𑀳𑀸;

𑀤𑀼𑀲𑁆𑀲𑀨𑀮𑁂𑀳𑀺 𑀭𑀼𑀓𑁆𑀔𑁂𑀳𑀺, 𑀲𑀫𑀦𑁆𑀢𑀸 𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑁄.

‘‘𑀓𑁂𑀦 ¶ 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺;

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… ¶ 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

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

𑀯𑀺𑀳𑀸𑀭𑀁 𑀲𑀗𑁆𑀖𑀲𑁆𑀲 𑀓𑀸𑀭𑁂𑀲𑀺𑀁, 𑀅𑀫𑁆𑀩𑁂𑀳𑀺 𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑀁.

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

𑀅𑀫𑁆𑀩𑁂𑀳𑀺 𑀙𑀸𑀤𑀬𑀺𑀢𑁆𑀯𑀸𑀦 [𑀅𑀫𑁆𑀩𑁂 𑀅𑀘𑁆𑀙𑀸𑀤𑀬𑀺𑀢𑁆𑀯𑀸𑀦 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀅𑀫𑁆𑀩𑁂𑀳𑀘𑁆𑀙𑀸𑀤𑀬𑀺𑀢𑁆𑀯𑀸𑀦 (𑀧𑀻. 𑀓.)], 𑀓𑀢𑁆𑀯𑀸 𑀤𑀼𑀲𑁆𑀲𑀫𑀬𑁂 𑀨𑀮𑁂.

‘‘𑀧𑀤𑀻𑀧𑀁 𑀢𑀢𑁆𑀣 𑀚𑀸𑀮𑁂𑀢𑁆𑀯𑀸, 𑀪𑁄𑀚𑀬𑀺𑀢𑁆𑀯𑀸 𑀕𑀡𑀼𑀢𑁆𑀢𑀫𑀁;

𑀦𑀺𑀬𑁆𑀬𑀸𑀤𑁂𑀲𑀺𑀁 𑀢𑀁 𑀲𑀗𑁆𑀖𑀲𑁆𑀲, 𑀧𑀲𑀦𑁆𑀦𑀸 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑁂𑀦 𑀫𑁂 𑀅𑀫𑁆𑀩𑀯𑀦𑀁 𑀭𑀫𑁆𑀫𑀁, 𑀧𑀸𑀲𑀸𑀤𑁂𑀢𑁆𑀣 𑀫𑀳𑀮𑁆𑀮𑀓𑁄;

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

‘‘𑀧𑀤𑀻𑀧𑁄 ¶ 𑀘𑁂𑀢𑁆𑀣 𑀚𑀮𑀢𑀺, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀲𑁄𑀯𑀡𑁆𑀡𑀬𑁄 𑀫𑀳𑀸;

𑀤𑀼𑀲𑁆𑀲𑀨𑀮𑁂𑀳𑀺 𑀭𑀼𑀓𑁆𑀔𑁂𑀳𑀺, 𑀲𑀫𑀦𑁆𑀢𑀸 𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑁄.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀧𑀻𑀢𑀯𑀢𑁆𑀣𑁂 ¶ 𑀧𑀻𑀢𑀥𑀚𑁂, 𑀧𑀻𑀢𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀪𑀽𑀲𑀺𑀢𑁂;

𑀧𑀻𑀢𑀘𑀦𑁆𑀤𑀦𑀮𑀺𑀢𑁆𑀢𑀗𑁆𑀕𑁂, 𑀧𑀻𑀢𑀉𑀧𑁆𑀧𑀮𑀫𑀸𑀮𑀺𑀦𑀻 [𑀧𑀻𑀢𑀼𑀧𑁆𑀧𑀮𑀫𑀥𑀸𑀭𑀺𑀦𑀻 (𑀲𑁆𑀬𑀸. 𑀓.), 𑀧𑀻𑀢𑀼𑀧𑁆𑀧𑀮𑀫𑀸𑀮𑀺𑀦𑀻 (𑀧𑀻.)].

‘‘𑀧𑀻𑀢𑀧𑀸𑀲𑀸𑀤𑀲𑀬𑀦𑁂, 𑀧𑀻𑀢𑀸𑀲𑀦𑁂 𑀧𑀻𑀢𑀪𑀸𑀚𑀦𑁂;

𑀧𑀻𑀢𑀙𑀢𑁆𑀢𑁂 𑀧𑀻𑀢𑀭𑀣𑁂, 𑀧𑀻𑀢𑀲𑁆𑀲𑁂 𑀧𑀻𑀢𑀩𑀻𑀚𑀦𑁂.

‘‘𑀓𑀺𑀁 ¶ ¶ 𑀓𑀫𑁆𑀫𑀫𑀓𑀭𑀻 𑀪𑀤𑁆𑀤𑁂, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀫𑀸𑀦𑀼𑀲𑀓𑁂 𑀪𑀯𑁂;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀓𑁄𑀲𑀸𑀢𑀓𑀻 𑀦𑀸𑀫 𑀮𑀢𑀢𑁆𑀣𑀺 𑀪𑀦𑁆𑀢𑁂, 𑀢𑀺𑀢𑁆𑀢𑀺𑀓𑀸 𑀅𑀦𑀪𑀺𑀘𑁆𑀙𑀺𑀢𑀸;

𑀢𑀲𑁆𑀲𑀸 𑀘𑀢𑁆𑀢𑀸𑀭𑀺 𑀧𑀼𑀧𑁆𑀨𑀸𑀦𑀺, 𑀣𑀽𑀧𑀁 𑀅𑀪𑀺𑀳𑀭𑀺𑀁 𑀅𑀳𑀁.

‘‘𑀲𑀢𑁆𑀣𑀼 𑀲𑀭𑀻𑀭𑀫𑀼𑀤𑁆𑀤𑀺𑀲𑁆𑀲, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸;

𑀦𑀸𑀲𑁆𑀲 𑀫𑀕𑁆𑀕𑀁 𑀅𑀯𑁂𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁, 𑀦 𑀢𑀕𑁆𑀕𑀫𑀦𑀲𑀸 [𑀢𑀤𑀕𑁆𑀕𑀫𑀦𑀲𑀸 (𑀲𑀻.), 𑀢𑀤𑀗𑁆𑀕𑀫𑀦𑀲𑀸 (𑀲𑁆𑀬𑀸.)] 𑀲𑀢𑀻.

‘‘𑀢𑀢𑁄 𑀫𑀁 𑀅𑀯𑀥𑀻 𑀕𑀸𑀯𑀻, 𑀣𑀽𑀧𑀁 𑀅𑀧𑀢𑁆𑀢𑀫𑀸𑀦𑀲𑀁;

𑀢𑀜𑁆𑀘𑀸𑀳𑀁 𑀅𑀪𑀺𑀲𑀜𑁆𑀘𑁂𑀬𑁆𑀬𑀁, 𑀪𑀺𑀬𑁆𑀬𑁄 [𑀪𑀻𑀬𑁄 (𑀲𑀻. 𑀅𑀝𑁆𑀞.)] 𑀦𑀽𑀦 𑀇𑀢𑁄 𑀲𑀺𑀬𑀸.

‘‘𑀢𑁂𑀦 𑀓𑀫𑁆𑀫𑁂𑀦 𑀤𑁂𑀯𑀺𑀦𑁆𑀤, 𑀫𑀖𑀯𑀸 𑀤𑁂𑀯𑀓𑀼𑀜𑁆𑀚𑀭𑁄;

𑀧𑀳𑀸𑀬 𑀫𑀸𑀦𑀼𑀲𑀁 𑀤𑁂𑀳𑀁, 𑀢𑀯 𑀲𑀳𑀩𑁆𑀬 [𑀲𑀳𑀩𑁆𑀬𑀢 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀫𑀸𑀕𑀢𑀸’’𑀢𑀺.

𑀇𑀤𑀁 ¶ 𑀲𑀼𑀢𑁆𑀯𑀸 𑀢𑀺𑀤𑀲𑀸𑀥𑀺𑀧𑀢𑀺, 𑀫𑀖𑀯𑀸 𑀤𑁂𑀯𑀓𑀼𑀜𑁆𑀚𑀭𑁄;

𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑁂 𑀧𑀲𑀸𑀤𑁂𑀦𑁆𑀢𑁄, 𑀫𑀸𑀢𑀮𑀺𑀁 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺 [𑀏𑀢𑀤𑀩𑁆𑀭𑀽𑀯𑀻𑀢𑀺 (𑀲𑀻.)].

‘‘𑀧𑀲𑁆𑀲 𑀫𑀸𑀢𑀮𑀺 𑀅𑀘𑁆𑀙𑁂𑀭𑀁, 𑀘𑀺𑀢𑁆𑀢𑀁 𑀓𑀫𑁆𑀫𑀨𑀮𑀁 𑀇𑀤𑀁;

𑀅𑀧𑁆𑀧𑀓𑀫𑁆𑀧𑀺 𑀓𑀢𑀁 𑀤𑁂𑀬𑁆𑀬𑀁, 𑀧𑀼𑀜𑁆𑀜𑀁 𑀳𑁄𑀢𑀺 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

‘‘𑀦𑀢𑁆𑀣𑀺 𑀘𑀺𑀢𑁆𑀢𑁂 𑀧𑀲𑀦𑁆𑀦𑀫𑁆𑀳𑀺, 𑀅𑀧𑁆𑀧𑀓𑀸 𑀦𑀸𑀫 𑀤𑀓𑁆𑀔𑀺𑀡𑀸;

𑀢𑀣𑀸𑀕𑀢𑁂 𑀯𑀸 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁂, 𑀅𑀣 𑀯𑀸 𑀢𑀲𑁆𑀲 𑀲𑀸𑀯𑀓𑁂.

‘‘𑀏𑀳𑀺 𑀫𑀸𑀢𑀮𑀺 𑀅𑀫𑁆𑀳𑁂𑀧𑀺, 𑀪𑀺𑀬𑁆𑀬𑁄 𑀪𑀺𑀬𑁆𑀬𑁄 𑀫𑀳𑁂𑀫𑀲𑁂;

𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲 𑀥𑀸𑀢𑀼𑀬𑁄, 𑀲𑀼𑀔𑁄 𑀧𑀼𑀜𑁆𑀜𑀸𑀦 𑀫𑀼𑀘𑁆𑀘𑀬𑁄.

‘‘𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑁂 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁂 𑀘𑀸𑀧𑀺, 𑀲𑀫𑁂 𑀘𑀺𑀢𑁆𑀢𑁂 𑀲𑀫𑀁 𑀨𑀮𑀁;

𑀘𑁂𑀢𑁄𑀧𑀡𑀺𑀥𑀺𑀳𑁂𑀢𑀼 ¶ 𑀳𑀺, 𑀲𑀢𑁆𑀢𑀸 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀲𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

‘‘𑀩𑀳𑀽𑀦𑀁 [𑀩𑀳𑀼𑀦𑁆𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀯𑀢 𑀅𑀢𑁆𑀣𑀸𑀬, 𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀢𑀣𑀸𑀕𑀢𑀸;

𑀬𑀢𑁆𑀣 𑀓𑀸𑀭𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀲𑀕𑁆𑀕𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀤𑀸𑀬𑀓𑀸’’𑀢𑀺.

‘‘𑀑𑀪𑀸𑀲𑀬𑀺𑀢𑁆𑀯𑀸 ¶ ¶ 𑀧𑀣𑀯𑀺𑀁 𑀲𑀤𑁂𑀯𑀓𑀁, 𑀅𑀢𑀺𑀭𑁄𑀘𑀲𑀺 𑀘𑀦𑁆𑀤𑀺𑀫𑀲𑀽𑀭𑀺𑀬𑀸 𑀯𑀺𑀬;

𑀲𑀺𑀭𑀺𑀬𑀸 𑀘 𑀯𑀡𑁆𑀡𑁂𑀦 𑀬𑀲𑁂𑀦 𑀢𑁂𑀚𑀲𑀸, 𑀩𑁆𑀭𑀳𑁆𑀫𑀸𑀯 𑀤𑁂𑀯𑁂 𑀢𑀺𑀤𑀲𑁂 𑀲𑀳𑀺𑀦𑁆𑀤𑀓𑁂.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 ¶ 𑀢𑀁 𑀉𑀧𑁆𑀧𑀮𑀫𑀸𑀮𑀥𑀸𑀭𑀺𑀦𑀻, 𑀆𑀯𑁂𑀴𑀺𑀦𑀻 𑀓𑀜𑁆𑀘𑀦𑀲𑀦𑁆𑀦𑀺𑀪𑀢𑁆𑀢𑀘𑁂;

𑀅𑀮𑀗𑁆𑀓𑀢𑁂 𑀉𑀢𑁆𑀢𑀫𑀯𑀢𑁆𑀣𑀥𑀸𑀭𑀺𑀦𑀻, 𑀓𑀸 𑀢𑁆𑀯𑀁 𑀲𑀼𑀪𑁂 𑀤𑁂𑀯𑀢𑁂 𑀯𑀦𑁆𑀤𑀲𑁂 𑀫𑀫𑀁.

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

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀇𑀤𑀸𑀦𑀺 𑀪𑀦𑁆𑀢𑁂 𑀇𑀫𑀫𑁂𑀯 𑀕𑀸𑀫𑀁, 𑀧𑀺𑀡𑁆𑀟𑀸𑀬 𑀅𑀫𑁆𑀳𑀸𑀓 𑀖𑀭𑀁 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀢𑀢𑁄 𑀢𑁂 𑀉𑀘𑁆𑀙𑀼𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀺 𑀔𑀡𑁆𑀟𑀺𑀓𑀁, 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸 𑀅𑀢𑀼𑀮𑀸𑀬 𑀧𑀻𑀢𑀺𑀬𑀸;

‘‘𑀲𑀲𑁆𑀲𑀼 ¶ 𑀘 𑀧𑀘𑁆𑀙𑀸 𑀅𑀦𑀼𑀬𑀼𑀜𑁆𑀚𑀢𑁂 𑀫𑀫𑀁, 𑀓𑀳𑀁 𑀦𑀼 𑀉𑀘𑁆𑀙𑀼𑀁 𑀯𑀥𑀼𑀓𑁂 𑀅𑀯𑀸𑀓𑀺𑀭𑀻;

𑀦 𑀙𑀟𑁆𑀟𑀺𑀢𑀁 𑀦𑁄 𑀧𑀦 𑀔𑀸𑀤𑀺𑀢𑀁 𑀫𑀬𑀸, 𑀲𑀦𑁆𑀢𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑁆𑀲 𑀲𑀬𑀁 𑀅𑀤𑀸𑀲𑀳𑀁.

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

𑀮𑁂𑀟𑁆𑀟𑀼𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀧𑀳𑀸𑀭𑀁 𑀅𑀤𑀸𑀲𑀺 𑀫𑁂, 𑀢𑀢𑁄 𑀘𑀼𑀢𑀸 𑀓𑀸𑀮𑀓𑀢𑀸𑀫𑁆𑀳𑀺 𑀤𑁂𑀯𑀢𑀸.

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

𑀤𑁂𑀯𑁂𑀳𑀺 𑀲𑀤𑁆𑀥𑀺𑀁 𑀧𑀭𑀺𑀘𑀸𑀭𑀬𑀸𑀫𑀳𑀁, 𑀫𑁄𑀤𑀸𑀫𑀳𑀁 𑀓𑀸𑀫𑀕𑀼𑀡𑁂𑀳𑀺 𑀧𑀜𑁆𑀘𑀳𑀺.

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

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

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 ¶ 𑀧𑀼𑀜𑁆𑀜𑀨𑀮𑀁 𑀅𑀦𑀧𑁆𑀧𑀓𑀁, 𑀫𑀳𑀸𑀯𑀺𑀧𑀸𑀓𑀸 𑀫𑀫 𑀉𑀘𑁆𑀙𑀼𑀤𑀓𑁆𑀔𑀺𑀡𑀸;

𑀤𑁂𑀯𑁂𑀳𑀺 𑀲𑀤𑁆𑀥𑀺𑀁 𑀧𑀭𑀺𑀘𑀸𑀭𑀬𑀸𑀫𑀳𑀁, 𑀫𑁄𑀤𑀸𑀫𑀳𑀁 𑀓𑀸𑀫𑀕𑀼𑀡𑁂𑀳𑀺 𑀧𑀜𑁆𑀘𑀳𑀺.

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀧𑀼𑀜𑁆𑀜𑀨𑀮𑀁 𑀅𑀦𑀧𑁆𑀧𑀓𑀁, 𑀫𑀳𑀸𑀚𑀼𑀢𑀺𑀓𑀸 𑀫𑀫 𑀉𑀘𑁆𑀙𑀼𑀤𑀓𑁆𑀔𑀺𑀡𑀸;

𑀢𑀢𑁄 𑀢𑁂 𑀉𑀘𑁆𑀙𑀼𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀺𑀁 𑀔𑀡𑁆𑀟𑀺𑀓𑀁, 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸 𑀅𑀢𑀼𑀮𑀸𑀬 𑀧𑀻𑀢𑀺𑀬𑀸’’𑀢𑀺.

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 ¶ 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀻 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂. ¶ …

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀸 𑀤𑁂𑀯𑀢𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀲𑀫𑀡𑁂 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁂;

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

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 ¶ 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁧𑁨. 𑀭𑀚𑁆𑀚𑀼𑀫𑀸𑀮𑀸𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑀸 𑀢𑁆𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀳𑀢𑁆𑀣𑀧𑀸𑀤𑁂 𑀘 𑀯𑀺𑀕𑁆𑀕𑀬𑁆𑀳, 𑀦𑀘𑁆𑀘𑀲𑀺 𑀲𑀼𑀧𑁆𑀧𑀯𑀸𑀤𑀺𑀢𑁂.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀢𑁂 𑀦𑀘𑁆𑀘𑀫𑀸𑀦𑀸𑀬, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑁂𑀳𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

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

‘‘𑀢𑀲𑁆𑀲𑀸 𑀢𑁂 𑀦𑀘𑁆𑀘𑀫𑀸𑀦𑀸𑀬, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑁂𑀳𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

𑀤𑀺𑀩𑁆𑀩𑀸 𑀕𑀦𑁆𑀥𑀸 𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺, 𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥𑀸 𑀫𑀦𑁄𑀭𑀫𑀸.

‘‘𑀯𑀺𑀯𑀢𑁆𑀢𑀫𑀸𑀦𑀸 𑀓𑀸𑀬𑁂𑀦, 𑀬𑀸 𑀯𑁂𑀡𑀻𑀲𑀼 𑀧𑀺𑀴𑀦𑁆𑀥𑀦𑀸;

𑀢𑁂𑀲𑀁 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑁄, 𑀢𑀼𑀭𑀺𑀬𑁂 𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀺𑀓𑁂 𑀬𑀣𑀸.

‘‘𑀯𑀝𑀁𑀲𑀓𑀸 𑀯𑀸𑀢𑀥𑀼𑀢𑀸, 𑀯𑀸𑀢𑁂𑀦 𑀲𑀫𑁆𑀧𑀓𑀫𑁆𑀧𑀺𑀢𑀸;

𑀢𑁂𑀲𑀁 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑁄, 𑀢𑀼𑀭𑀺𑀬𑁂 𑀧𑀜𑁆𑀘𑀗𑁆𑀕𑀺𑀓𑁂 𑀬𑀣𑀸.

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

𑀯𑀸𑀢𑀺 𑀕𑀦𑁆𑀥𑁄 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀭𑀼𑀓𑁆𑀔𑁄 𑀫𑀜𑁆𑀚𑀽𑀲𑀓𑁄 𑀬𑀣𑀸.

‘‘𑀖𑀸𑀬𑀲𑁂 ¶ 𑀢𑀁 𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥𑀁, 𑀭𑀽𑀧𑀁 𑀧𑀲𑁆𑀲𑀲𑀺 𑀅𑀫𑀸𑀦𑀼𑀲𑀁;

𑀤𑁂𑀯𑀢𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀘𑀺𑀓𑁆𑀔, 𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀤𑀸𑀲𑀻 ¶ 𑀅𑀳𑀁 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺𑀁, 𑀕𑀬𑀸𑀬𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲𑀳𑀁;

𑀅𑀧𑁆𑀧𑀧𑀼𑀜𑁆𑀜𑀸 𑀅𑀮𑀓𑁆𑀔𑀺𑀓𑀸, 𑀭𑀚𑁆𑀚𑀼𑀫𑀸𑀮𑀸𑀢𑀺 𑀫𑀁 𑀯𑀺𑀤𑀼𑀁 [𑀯𑀺𑀤𑀽 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)].

‘‘𑀅𑀓𑁆𑀓𑁄𑀲𑀸𑀦𑀁 𑀯𑀥𑀸𑀦𑀜𑁆𑀘, 𑀢𑀚𑁆𑀚𑀦𑀸𑀬 𑀘 𑀉𑀕𑁆𑀕𑀢𑀸 [𑀉𑀓𑁆𑀓𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)];

𑀓𑀼𑀝𑀁 ¶ 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫, 𑀅𑀕𑀜𑁆𑀙𑀺𑀁 [𑀆𑀕𑀘𑁆𑀙𑀺𑀁 (𑀲𑁆𑀬𑀸. 𑀓.), 𑀅𑀕𑀘𑁆𑀙𑀺𑀁 (𑀧𑀻.), 𑀕𑀘𑁆𑀙𑀺𑀁 (𑀲𑀻.)] 𑀉𑀤𑀳𑀸𑀭𑀺𑀬𑀸 [𑀉𑀤𑀓𑀳𑀸𑀭𑀺𑀬𑀸 (𑀲𑀻.)].

‘‘𑀯𑀺𑀧𑀣𑁂 ¶ 𑀓𑀼𑀝𑀁 𑀦𑀺𑀓𑁆𑀔𑀺𑀧𑀺𑀢𑁆𑀯𑀸, 𑀯𑀦𑀲𑀡𑁆𑀟𑀁 𑀉𑀧𑀸𑀕𑀫𑀺𑀁;

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

‘‘𑀤𑀴𑁆𑀳𑀁 𑀧𑀸𑀲𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀆𑀲𑀼𑀫𑁆𑀪𑀺𑀢𑁆𑀯𑀸𑀦 𑀧𑀸𑀤𑀧𑁂;

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

‘‘𑀢𑀢𑁆𑀣𑀤𑁆𑀤𑀲𑀸𑀲𑀺𑀁 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁, 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀳𑀺𑀢𑀁 𑀫𑀼𑀦𑀺𑀁;

𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀲𑁆𑀫𑀺𑀁, 𑀛𑀸𑀬𑀦𑁆𑀢𑀁 𑀅𑀓𑀼𑀢𑁄𑀪𑀬𑀁.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀅𑀳𑀼 𑀲𑀁𑀯𑁂𑀕𑁄, 𑀅𑀩𑁆𑀪𑀼𑀢𑁄 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑁄;

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

‘‘𑀧𑀸𑀲𑀸𑀤𑀺𑀓𑀁 𑀧𑀲𑀸𑀤𑀦𑀻𑀬𑀁, 𑀯𑀦𑀸 𑀦𑀺𑀩𑁆𑀩𑀦𑀫𑀸𑀕𑀢𑀁;

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

‘‘𑀕𑀼𑀢𑁆𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁄 𑀛𑀸𑀦𑀭𑀢𑁄, 𑀅𑀩𑀳𑀺𑀕𑁆𑀕𑀢𑀫𑀸𑀦𑀲𑁄;

𑀳𑀺𑀢𑁄 𑀲𑀩𑁆𑀩𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀩𑀼𑀤𑁆𑀥𑁄 𑀅𑀬𑀁 [𑀲𑁄𑀬𑀁 (𑀲𑀻.)] 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺.

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

𑀤𑀼𑀮𑁆𑀮𑀪𑀸𑀬𑀁 𑀤𑀲𑁆𑀲𑀦𑀸𑀬, 𑀧𑀼𑀧𑁆𑀨𑀁 𑀑𑀤𑀼𑀫𑁆𑀩𑀭𑀁 𑀬𑀣𑀸.

‘‘𑀲𑁄 𑀫𑀁 𑀫𑀼𑀤𑀽𑀳𑀺 𑀯𑀸𑀘𑀸𑀳𑀺, 𑀆𑀮𑀧𑀺𑀢𑁆𑀯𑀸 𑀢𑀣𑀸𑀕𑀢𑁄;

𑀭𑀚𑁆𑀚𑀼𑀫𑀸𑀮𑁂𑀢𑀺 𑀫𑀁𑀯𑁄𑀘, 𑀲𑀭𑀡𑀁 𑀕𑀘𑁆𑀙 𑀢𑀣𑀸𑀕𑀢𑀁.

‘‘𑀢𑀸𑀳𑀁 𑀕𑀺𑀭𑀁 𑀲𑀼𑀡𑀺𑀢𑁆𑀯𑀸𑀦, 𑀦𑁂𑀮𑀁 𑀅𑀢𑁆𑀣𑀯𑀢𑀺𑀁 𑀲𑀼𑀘𑀺𑀁;

𑀲𑀡𑁆𑀳𑀁 𑀫𑀼𑀤𑀼𑀜𑁆𑀘 𑀯𑀕𑁆𑀕𑀼𑀜𑁆𑀘, 𑀲𑀩𑁆𑀩𑀲𑁄𑀓𑀸𑀧𑀦𑀽𑀤𑀦𑀁.

‘‘𑀓𑀮𑁆𑀮𑀘𑀺𑀢𑁆𑀢𑀜𑁆𑀘 𑀫𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀧𑀲𑀦𑁆𑀦𑀁 𑀲𑀼𑀤𑁆𑀥𑀫𑀸𑀦𑀲𑀁;

𑀳𑀺𑀢𑁄 ¶ 𑀲𑀩𑁆𑀩𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀅𑀦𑀼𑀲𑀸𑀲𑀺 𑀢𑀣𑀸𑀕𑀢𑁄.

‘‘𑀇𑀤𑀁 𑀤𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑀺 𑀫𑀁𑀯𑁄𑀘, 𑀅𑀬𑀁 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀲𑀫𑁆𑀪𑀯𑁄;

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

‘‘𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀲𑁆𑀲 ¶ 𑀓𑀼𑀲𑀮𑀲𑁆𑀲, 𑀑𑀯𑀸𑀤𑀫𑁆𑀳𑀺 𑀅𑀳𑀁 𑀞𑀺𑀢𑀸;

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

‘‘𑀲𑀸𑀳𑀁 𑀅𑀯𑀝𑁆𑀞𑀺𑀢𑀸𑀧𑁂𑀫𑀸, 𑀤𑀲𑁆𑀲𑀦𑁂 𑀅𑀯𑀺𑀓𑀫𑁆𑀧𑀺𑀦𑀻;

𑀫𑀽𑀮𑀚𑀸𑀢𑀸𑀬 𑀲𑀤𑁆𑀥𑀸𑀬, 𑀥𑀻𑀢𑀸 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀑𑀭𑀲𑀸.

‘‘𑀲𑀸𑀳𑀁 ¶ ¶ 𑀭𑀫𑀸𑀫𑀺 𑀓𑀻𑀴𑀸𑀫𑀺, 𑀫𑁄𑀤𑀸𑀫𑀺 𑀅𑀓𑀼𑀢𑁄𑀪𑀬𑀸;

𑀤𑀺𑀩𑁆𑀩𑀫𑀸𑀮𑀁 𑀥𑀸𑀭𑀬𑀸𑀫𑀺, 𑀧𑀺𑀯𑀸𑀫𑀺 𑀫𑀥𑀼𑀫𑀤𑁆𑀤𑀯𑀁.

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

𑀆𑀴𑀫𑁆𑀩𑁄 𑀕𑀕𑁆𑀕𑀭𑁄 𑀪𑀻𑀫𑁄, 𑀲𑀸𑀥𑀼𑀯𑀸𑀤𑀻 𑀘 𑀲𑀁𑀲𑀬𑁄.

‘‘𑀧𑁄𑀓𑁆𑀔𑀭𑁄 𑀘 𑀲𑀼𑀨𑀲𑁆𑀲𑁄 𑀘, 𑀯𑀻𑀡𑀸𑀫𑁄𑀓𑁆𑀔𑀸 𑀘 𑀦𑀸𑀭𑀺𑀬𑁄;

𑀦𑀦𑁆𑀤𑀸 𑀘𑁂𑀯 𑀲𑀼𑀦𑀦𑁆𑀤𑀸 𑀘, 𑀲𑁄𑀡𑀤𑀺𑀦𑁆𑀦𑀸 𑀲𑀼𑀘𑀺𑀫𑁆𑀳𑀺𑀢𑀸.

‘‘𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀸 𑀫𑀺𑀲𑁆𑀲𑀓𑁂𑀲𑀻 𑀘, 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀸𑀢𑀺𑀤𑀸𑀭𑀼𑀡𑀻 [… 𑀢𑀺𑀘𑀸𑀭𑀼𑀡𑀻 (𑀲𑀻.)];

𑀏𑀡𑀻𑀨𑀲𑁆𑀲𑀸 𑀲𑀼𑀨𑀲𑁆𑀲𑀸 [𑀲𑀼𑀧𑀲𑁆𑀲𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)] 𑀘, 𑀲𑀼𑀪𑀤𑁆𑀤𑀸 [𑀲𑀁𑀪𑀤𑁆𑀤𑀸 (𑀓.)] 𑀫𑀼𑀤𑀼𑀯𑀸𑀤𑀺𑀦𑀻.

‘‘𑀏𑀢𑀸 𑀘𑀜𑁆𑀜𑀸 𑀘 𑀲𑁂𑀬𑁆𑀬𑀸𑀲𑁂, 𑀅𑀘𑁆𑀙𑀭𑀸𑀦𑀁 𑀧𑀩𑁄𑀥𑀺𑀓𑀸;

𑀢𑀸 𑀫𑀁 𑀓𑀸𑀮𑁂𑀦𑀼𑀧𑀸𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀅𑀪𑀺𑀪𑀸𑀲𑀦𑁆𑀢𑀺 𑀤𑁂𑀯𑀢𑀸.

‘‘𑀳𑀦𑁆𑀤 𑀦𑀘𑁆𑀘𑀸𑀫 𑀕𑀸𑀬𑀸𑀫, 𑀳𑀦𑁆𑀤 𑀢𑀁 𑀭𑀫𑀬𑀸𑀫𑀲𑁂;

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

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

𑀲𑀼𑀔𑀁 𑀅𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁, 𑀇𑀥 𑀦𑀢𑁆𑀣𑀺 𑀧𑀭𑀢𑁆𑀣 𑀘.

‘‘𑀲𑀼𑀔𑀜𑁆𑀘 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁, 𑀇𑀥 𑀘𑁂𑀯 𑀧𑀭𑀢𑁆𑀣 𑀘;

𑀢𑁂𑀲𑀁 𑀲𑀳𑀩𑁆𑀬𑀓𑀸𑀫𑀸𑀦𑀁, 𑀓𑀢𑁆𑀢𑀩𑁆𑀩𑀁 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼𑀁;

𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀸 𑀳𑀺 𑀫𑁄𑀤𑀦𑁆𑀢𑀺, 𑀲𑀕𑁆𑀕𑁂 𑀪𑁄𑀕𑀲𑀫𑀗𑁆𑀕𑀺𑀦𑁄.

‘‘𑀩𑀳𑀽𑀦𑀁 𑀯𑀢 𑀅𑀢𑁆𑀣𑀸𑀬, 𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀢𑀣𑀸𑀕𑀢𑀸;

𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀸𑀦𑀁, 𑀧𑀼𑀜𑁆𑀜𑀔𑁂𑀢𑁆𑀢𑀸𑀦𑀫𑀸𑀓𑀭𑀸;

𑀬𑀢𑁆𑀣 𑀓𑀸𑀭𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀲𑀕𑁆𑀕𑁂 𑀫𑁄𑀤𑀦𑁆𑀢𑀺 𑀤𑀸𑀬𑀓𑀸’’𑀢𑀺.

𑀭𑀚𑁆𑀚𑀼𑀫𑀸𑀮𑀸𑀯𑀺𑀫𑀸𑀦𑀁 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁.

𑀫𑀜𑁆𑀚𑀺𑀝𑁆𑀞𑀓𑀯𑀕𑁆𑀕𑁄 𑀘𑀢𑀼𑀢𑁆𑀣𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀫𑀜𑁆𑀚𑀺𑀝𑁆𑀞𑀸 ¶ 𑀧𑀪𑀲𑁆𑀲𑀭𑀸 𑀦𑀸𑀕𑀸, 𑀅𑀮𑁄𑀫𑀸𑀓𑀜𑁆𑀚𑀺𑀓𑀤𑀸𑀬𑀺𑀓𑀸;

𑀯𑀺𑀳𑀸𑀭𑀘𑀢𑀼𑀭𑀺𑀢𑁆𑀣𑀫𑁆𑀩𑀸, 𑀧𑀻𑀢𑀸 𑀉𑀘𑁆𑀙𑀼𑀯𑀦𑁆𑀤𑀦𑀭𑀚𑁆𑀚𑀼𑀫𑀸𑀮𑀸 𑀘;

𑁧. 𑀫𑀡𑁆𑀟𑀽𑀓𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀓𑁄 ¶ ¶ ¶ 𑀫𑁂 𑀯𑀦𑁆𑀤𑀢𑀺 𑀧𑀸𑀤𑀸𑀦𑀺, 𑀇𑀤𑁆𑀥𑀺𑀬𑀸 𑀬𑀲𑀲𑀸 𑀚𑀮𑀁;

𑀅𑀪𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀲𑀩𑁆𑀩𑀸 𑀑𑀪𑀸𑀲𑀬𑀁 𑀤𑀺𑀲𑀸’’𑀢𑀺.

‘‘𑀫𑀡𑁆𑀟𑀽𑀓𑁄𑀳𑀁 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺𑀁, 𑀉𑀤𑀓𑁂 𑀯𑀸𑀭𑀺𑀕𑁄𑀘𑀭𑁄;

𑀢𑀯 𑀥𑀫𑁆𑀫𑀁 𑀲𑀼𑀡𑀦𑁆𑀢𑀲𑁆𑀲, 𑀅𑀯𑀥𑀻 𑀯𑀘𑁆𑀙𑀧𑀸𑀮𑀓𑁄.

‘‘𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑀁 ¶ 𑀘𑀺𑀢𑁆𑀢𑀧𑀲𑀸𑀤𑀲𑁆𑀲, 𑀇𑀤𑁆𑀥𑀺𑀁 𑀧𑀲𑁆𑀲 𑀬𑀲𑀜𑁆𑀘 𑀫𑁂;

𑀆𑀦𑀼𑀪𑀸𑀯𑀜𑁆𑀘 𑀫𑁂 𑀧𑀲𑁆𑀲, 𑀯𑀡𑁆𑀡𑀁 𑀧𑀲𑁆𑀲 𑀚𑀼𑀢𑀺𑀜𑁆𑀘 𑀫𑁂.

‘‘𑀬𑁂 𑀘 𑀢𑁂 𑀤𑀻𑀖𑀫𑀤𑁆𑀥𑀸𑀦𑀁, 𑀥𑀫𑁆𑀫𑀁 𑀅𑀲𑁆𑀲𑁄𑀲𑀼𑀁 𑀕𑁄𑀢𑀫;

𑀧𑀢𑁆𑀢𑀸 𑀢𑁂 𑀅𑀘𑀮𑀝𑁆𑀞𑀸𑀦𑀁, 𑀬𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀦 𑀲𑁄𑀘𑀭𑁂’’𑀢𑀺.

𑀫𑀡𑁆𑀟𑀽𑀓𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑀯𑀺𑀫𑀸𑀦𑀁 𑀧𑀞𑀫𑀁.

[𑀥. 𑀧. 𑁨𑁧𑁯 𑀥𑀫𑁆𑀫𑀧𑀤𑁂] ‘‘𑀘𑀺𑀭𑀧𑁆𑀧𑀯𑀸𑀲𑀺𑀁 𑀧𑀼𑀭𑀺𑀲𑀁, 𑀤𑀽𑀭𑀢𑁄 𑀲𑁄𑀢𑁆𑀣𑀺𑀫𑀸𑀕𑀢𑀁;

𑀜𑀸𑀢𑀺𑀫𑀺𑀢𑁆𑀢𑀸 𑀲𑀼𑀳𑀚𑁆𑀚𑀸 𑀘, 𑀅𑀪𑀺𑀦𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀆𑀕𑀢𑀁;

[𑀥. 𑀧. 𑁨𑁨𑁦 𑀥𑀫𑁆𑀫𑀧𑀤𑁂] ‘‘𑀢𑀣𑁂𑀯 ¶ 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀫𑁆𑀧𑀺, 𑀅𑀲𑁆𑀫𑀸 𑀮𑁄𑀓𑀸 𑀧𑀭𑀁 𑀕𑀢𑀁;

𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺 𑀧𑀝𑀺𑀕𑀡𑁆𑀳𑀦𑁆𑀢𑀺, 𑀧𑀺𑀬𑀁 𑀜𑀸𑀢𑀻𑀯 𑀆𑀕𑀢𑀁.

[𑀧𑁂. 𑀯. 𑁭𑁧𑁪]‘‘𑀉𑀝𑁆𑀞𑁂𑀳𑀺 𑀭𑁂𑀯𑀢𑁂 𑀲𑀼𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁂, 𑀅𑀧𑀸𑀭𑀼𑀢𑀤𑁆𑀯𑀸𑀭𑁂 [𑀅𑀧𑀸𑀭𑀼𑀪𑀁 𑀤𑁆𑀯𑀸𑀭𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀅𑀧𑀸𑀭𑀼𑀢𑀤𑁆𑀯𑀸𑀭𑀁 (𑀧𑀻. 𑀓.)] 𑀅𑀤𑀸𑀦𑀲𑀻𑀮𑁂;

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

𑀇𑀘𑁆𑀘𑁂𑀯 ¶ [𑀇𑀘𑁆𑀘𑁂𑀯𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀢𑁆𑀯𑀸𑀦 𑀬𑀫𑀲𑁆𑀲 𑀤𑀽𑀢𑀸, 𑀢𑁂 𑀤𑁆𑀯𑁂 𑀬𑀓𑁆𑀔𑀸 𑀮𑁄𑀳𑀺𑀢𑀓𑁆𑀔𑀸 𑀩𑁆𑀭𑀳𑀦𑁆𑀢𑀸;

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

‘‘𑀆𑀤𑀺𑀘𑁆𑀘𑀯𑀡𑁆𑀡𑀁 ¶ 𑀭𑀼𑀘𑀺𑀭𑀁 𑀧𑀪𑀲𑁆𑀲𑀭𑀁, 𑀩𑁆𑀬𑀫𑁆𑀳𑀁 𑀲𑀼𑀪𑀁 𑀓𑀜𑁆𑀘𑀦𑀚𑀸𑀮𑀙𑀦𑁆𑀦𑀁;

𑀓𑀲𑁆𑀲𑁂𑀢𑀫𑀸𑀓𑀺𑀡𑁆𑀡𑀚𑀦𑀁 ¶ 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀽𑀭𑀺𑀬𑀲𑁆𑀲 𑀭𑀁𑀲𑀻𑀭𑀺𑀯 𑀚𑁄𑀢𑀫𑀸𑀦𑀁.

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

𑀢𑀁 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀲𑀽𑀭𑀺𑀬𑀲𑀫𑀸𑀦𑀯𑀡𑁆𑀡𑀁, 𑀓𑁄 𑀫𑁄𑀤𑀢𑀺 𑀲𑀕𑁆𑀕𑀧𑀢𑁆𑀢𑁄 𑀯𑀺𑀫𑀸𑀦𑁂’’𑀢𑀺.

‘‘𑀩𑀸𑀭𑀸𑀡𑀲𑀺𑀬𑀁 𑀦𑀦𑁆𑀤𑀺𑀬𑁄 𑀦𑀸𑀫𑀸𑀲𑀺, 𑀉𑀧𑀸𑀲𑀓𑁄 𑀅𑀫𑀘𑁆𑀙𑀭𑀻 𑀤𑀸𑀦𑀧𑀢𑀺 𑀯𑀤𑀜𑁆𑀜𑀽;

𑀢𑀲𑁆𑀲𑁂𑀢𑀫𑀸𑀓𑀺𑀡𑁆𑀡𑀚𑀦𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀽𑀭𑀺𑀬𑀲𑁆𑀲 𑀭𑀁𑀲𑀻𑀭𑀺𑀯 𑀚𑁄𑀢𑀫𑀸𑀦𑀁.

‘‘𑀦𑀸𑀭𑀻𑀕𑀡𑀸 𑀘𑀦𑁆𑀤𑀦𑀲𑀸𑀭𑀮𑀺𑀢𑁆𑀢𑀸, 𑀉𑀪𑀢𑁄 𑀯𑀺𑀫𑀸𑀦𑀁 𑀉𑀧𑀲𑁄𑀪𑀬𑀦𑁆𑀢𑀺;

𑀢𑀁 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀲𑀽𑀭𑀺𑀬𑀲𑀫𑀸𑀦𑀯𑀡𑁆𑀡𑀁, 𑀲𑁄 𑀫𑁄𑀤𑀢𑀺 𑀲𑀕𑁆𑀕𑀧𑀢𑁆𑀢𑁄 𑀯𑀺𑀫𑀸𑀦𑁂’’𑀢𑀺.

‘‘𑀦𑀦𑁆𑀤𑀺𑀬𑀲𑁆𑀲𑀸𑀳𑀁 𑀪𑀭𑀺𑀬𑀸, 𑀅𑀕𑀸𑀭𑀺𑀦𑀻 𑀲𑀩𑁆𑀩𑀓𑀼𑀮𑀲𑁆𑀲 𑀇𑀲𑁆𑀲𑀭𑀸;

𑀪𑀢𑁆𑀢𑀼 𑀯𑀺𑀫𑀸𑀦𑁂 𑀭𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀤𑀸𑀦𑀳𑀁, 𑀦 𑀧𑀢𑁆𑀣𑀬𑁂 𑀦𑀺𑀭𑀬𑀁 𑀤𑀲𑁆𑀲𑀦𑀸𑀬𑀸’’𑀢𑀺.

‘‘𑀏𑀲𑁄 𑀢𑁂 𑀦𑀺𑀭𑀬𑁄 𑀲𑀼𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁂, 𑀧𑀼𑀜𑁆𑀜𑀁 ¶ 𑀢𑀬𑀸 𑀅𑀓𑀢𑀁 𑀚𑀻𑀯𑀮𑁄𑀓𑁂;

𑀦 𑀳𑀺 𑀫𑀘𑁆𑀙𑀭𑀻 𑀭𑁄𑀲𑀓𑁄 𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁄, 𑀲𑀕𑁆𑀕𑀽𑀧𑀕𑀸𑀦𑀁 𑀮𑀪𑀢𑀺 𑀲𑀳𑀩𑁆𑀬𑀢’’𑀦𑁆𑀢𑀺.

‘‘𑀓𑀺𑀁 ¶ 𑀦𑀼 𑀕𑀽𑀣𑀜𑁆𑀘 𑀫𑀼𑀢𑁆𑀢𑀜𑁆𑀘, 𑀅𑀲𑀼𑀘𑀻 𑀧𑀝𑀺𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑀁 𑀓𑀺𑀫𑀺𑀤𑀁 𑀫𑀻𑀴𑁆𑀳𑀁, 𑀓𑀺𑀫𑁂𑀢𑀁 𑀉𑀧𑀯𑀸𑀬𑀢𑀻’’𑀢𑀺.

‘‘𑀏𑀲 𑀲𑀁𑀲𑀯𑀓𑁄 𑀦𑀸𑀫, 𑀕𑀫𑁆𑀪𑀻𑀭𑁄 𑀲𑀢𑀧𑁄𑀭𑀺𑀲𑁄;

𑀬𑀢𑁆𑀣 𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀢𑀼𑀯𑀁 𑀧𑀘𑁆𑀘𑀲𑀺 𑀭𑁂𑀯𑀢𑁂’’𑀢𑀺.

‘‘𑀓𑀺𑀁 ¶ 𑀦𑀼 𑀓𑀸𑀬𑁂𑀦 𑀯𑀸𑀘𑀸𑀬, 𑀫𑀦𑀲𑀸 𑀤𑀼𑀓𑁆𑀓𑀝𑀁 𑀓𑀢𑀁;

𑀓𑁂𑀦 𑀲𑀁𑀲𑀯𑀓𑁄 𑀮𑀤𑁆𑀥𑁄, 𑀕𑀫𑁆𑀪𑀻𑀭𑁄 𑀲𑀢𑀧𑁄𑀭𑀺𑀲𑁄’’𑀢𑀺.

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

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

‘‘𑀢𑁂𑀦 𑀲𑀁𑀲𑀯𑀓𑁄 𑀮𑀤𑁆𑀥𑁄, 𑀕𑀫𑁆𑀪𑀻𑀭𑁄 𑀲𑀢𑀧𑁄𑀭𑀺𑀲𑁄;

𑀢𑀢𑁆𑀣 𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀢𑀼𑀯𑀁 𑀧𑀘𑁆𑀘𑀲𑀺 𑀭𑁂𑀯𑀢𑁂.

‘‘𑀳𑀢𑁆𑀣𑁂𑀧𑀺 𑀙𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀅𑀣𑁄𑀧𑀺 𑀧𑀸𑀤𑁂, 𑀓𑀡𑁆𑀡𑁂𑀧𑀺 𑀙𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀅𑀣𑁄𑀧𑀺 𑀦𑀸𑀲𑀁;

𑀅𑀣𑁄𑀧𑀺 𑀓𑀸𑀓𑁄𑀴𑀕𑀡𑀸 𑀲𑀫𑁂𑀘𑁆𑀘, 𑀲𑀗𑁆𑀕𑀫𑁆𑀫 𑀔𑀸𑀤𑀦𑁆𑀢𑀺 𑀯𑀺𑀨𑀦𑁆𑀤𑀫𑀸𑀦’’𑀦𑁆𑀢𑀺.

‘‘𑀲𑀸𑀥𑀼 𑀔𑁄 𑀫𑀁 𑀧𑀝𑀺𑀦𑁂𑀣, 𑀓𑀸𑀳𑀸𑀫𑀺 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼𑀁;

𑀤𑀸𑀦𑁂𑀦 𑀲𑀫𑀘𑀭𑀺𑀬𑀸𑀬, 𑀲𑀁𑀬𑀫𑁂𑀦 𑀤𑀫𑁂𑀦 𑀘;

𑀬𑀁 𑀓𑀢𑁆𑀯𑀸 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀺, 𑀦 𑀘 𑀧𑀘𑁆𑀙𑀸𑀦𑀼𑀢𑀧𑁆𑀧𑀭𑁂’’𑀢𑀺.

‘‘𑀧𑀼𑀭𑁂 ¶ 𑀢𑀼𑀯𑀁 𑀧𑀫𑀚𑁆𑀚𑀺𑀢𑁆𑀯𑀸, 𑀇𑀤𑀸𑀦𑀺 𑀧𑀭𑀺𑀤𑁂𑀯𑀲𑀺;

𑀲𑀬𑀁 𑀓𑀢𑀸𑀦𑀁 𑀓𑀫𑁆𑀫𑀸𑀦𑀁, 𑀯𑀺𑀧𑀸𑀓𑀁 𑀅𑀦𑀼𑀪𑁄𑀲𑁆𑀲𑀲𑀻’’𑀢𑀺.

‘‘𑀓𑁄 ¶ 𑀤𑁂𑀯𑀮𑁄𑀓𑀢𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑀁, 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑁂 𑀏𑀯𑀁 𑀯𑀤𑁂𑀬𑁆𑀬;

‘𑀦𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀤𑀡𑁆𑀟𑁂𑀲𑀼 𑀤𑀤𑀸𑀣 𑀤𑀸𑀦𑀁, 𑀅𑀘𑁆𑀙𑀸𑀤𑀦𑀁 𑀲𑁂𑀬𑁆𑀬 [𑀲𑀬𑀦 (𑀲𑀻.)] 𑀫𑀣𑀦𑁆𑀦𑀧𑀸𑀦𑀁;

𑀦𑀳𑀺 𑀫𑀘𑁆𑀙𑀭𑀻 𑀭𑁄𑀲𑀓𑁄 𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁄, 𑀲𑀕𑁆𑀕𑀽𑀧𑀕𑀸𑀦𑀁 𑀮𑀪𑀢𑀺 𑀲𑀳𑀩𑁆𑀬𑀢𑀁’.

‘‘𑀲𑀸𑀳𑀁 𑀦𑀽𑀦 𑀇𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀬𑁄𑀦𑀺𑀁 𑀮𑀤𑁆𑀥𑀸𑀦 𑀫𑀸𑀦𑀼𑀲𑀺𑀁;

𑀯𑀤𑀜𑁆𑀜𑀽 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀓𑀸𑀳𑀸𑀫𑀺 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼𑀁;

𑀤𑀸𑀦𑁂𑀦 𑀲𑀫𑀘𑀭𑀺𑀬𑀸𑀬, 𑀲𑀁𑀬𑀫𑁂𑀦 𑀤𑀫𑁂𑀦 𑀘.

‘‘𑀆𑀭𑀸𑀫𑀸𑀦𑀺 ¶ 𑀘 𑀭𑁄𑀧𑀺𑀲𑁆𑀲𑀁, 𑀤𑀼𑀕𑁆𑀕𑁂 𑀲𑀗𑁆𑀓𑀫𑀦𑀸𑀦𑀺 𑀘;

𑀧𑀧𑀜𑁆𑀘 𑀉𑀤𑀧𑀸𑀦𑀜𑁆𑀘, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

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

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

‘‘𑀉𑀧𑁄𑀲𑀣𑀁 𑀉𑀧𑀯𑀲𑀺𑀲𑁆𑀲𑀁, 𑀲𑀤𑀸 𑀲𑀻𑀮𑁂𑀲𑀼 𑀲𑀁𑀯𑀼𑀢𑀸;

𑀦 𑀘 𑀤𑀸𑀦𑁂 𑀧𑀫𑀚𑁆𑀚𑀺𑀲𑁆𑀲𑀁, 𑀲𑀸𑀫𑀁 𑀤𑀺𑀝𑁆𑀞𑀫𑀺𑀤𑀁 𑀫𑀬𑀸’’𑀢𑀺;

𑀇𑀘𑁆𑀘𑁂𑀯𑀁 𑀯𑀺𑀧𑁆𑀧𑀮𑀧𑀦𑁆𑀢𑀺𑀁, 𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑀁 𑀢𑀢𑁄 𑀢𑀢𑁄;

𑀔𑀺𑀧𑀺𑀁𑀲𑀼 𑀦𑀺𑀭𑀬𑁂 𑀖𑁄𑀭𑁂, 𑀉𑀤𑁆𑀥𑀧𑀸𑀤𑀁 𑀅𑀯𑀁𑀲𑀺𑀭𑀁.

‘‘𑀅𑀳𑀁 𑀧𑀼𑀭𑁂 𑀫𑀘𑁆𑀙𑀭𑀺𑀦𑀻 𑀅𑀳𑁄𑀲𑀺𑀁, 𑀧𑀭𑀺𑀪𑀸𑀲𑀺𑀓𑀸 ¶ 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁;

𑀯𑀺𑀢𑀣𑁂𑀦 𑀘 𑀲𑀸𑀫𑀺𑀓𑀁 𑀯𑀜𑁆𑀘𑀬𑀺𑀢𑁆𑀯𑀸, 𑀧𑀘𑁆𑀘𑀸𑀫𑀳𑀁 𑀦𑀺𑀭𑀬𑁂 𑀖𑁄𑀭𑀭𑀽𑀧𑁂’’𑀢𑀺.

𑁩. 𑀙𑀢𑁆𑀢𑀫𑀸𑀡𑀯𑀓𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀬𑁂 ¶ 𑀯𑀤𑀢𑀁 𑀧𑀯𑀭𑁄 𑀫𑀦𑀼𑀚𑁂𑀲𑀼, 𑀲𑀓𑁆𑀬𑀫𑀼𑀦𑀻 𑀪𑀕𑀯𑀸 𑀓𑀢𑀓𑀺𑀘𑁆𑀘𑁄;

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

‘‘𑀭𑀸𑀕𑀯𑀺𑀭𑀸𑀕𑀫𑀦𑁂𑀚𑀫𑀲𑁄𑀓𑀁, 𑀥𑀫𑁆𑀫𑀫𑀲𑀗𑁆𑀔𑀢𑀫𑀧𑁆𑀧𑀝𑀺𑀓𑀽𑀮𑀁;

𑀫𑀥𑀼𑀭𑀫𑀺𑀫𑀁 𑀧𑀕𑀼𑀡𑀁 𑀲𑀼𑀯𑀺𑀪𑀢𑁆𑀢𑀁, 𑀥𑀫𑁆𑀫𑀫𑀺𑀫𑀁 𑀲𑀭𑀡𑀢𑁆𑀣𑀫𑀼𑀧𑁂𑀳𑀺.

‘‘𑀬𑀢𑁆𑀣 ¶ 𑀘 𑀤𑀺𑀦𑁆𑀦 𑀫𑀳𑀧𑁆𑀨𑀮𑀫𑀸𑀳𑀼, 𑀘𑀢𑀽𑀲𑀼 𑀲𑀼𑀘𑀻𑀲𑀼 𑀧𑀼𑀭𑀺𑀲𑀬𑀼𑀕𑁂𑀲𑀼;

𑀅𑀝𑁆𑀞 𑀘 𑀧𑀼𑀕𑁆𑀕𑀮𑀥𑀫𑁆𑀫𑀤𑀲𑀸 𑀢𑁂, 𑀲𑀗𑁆𑀖𑀫𑀺𑀫𑀁 𑀲𑀭𑀡𑀢𑁆𑀣𑀫𑀼𑀧𑁂𑀳𑀺.

‘‘𑀦 ¶ 𑀢𑀣𑀸 𑀢𑀧𑀢𑀺 𑀦𑀪𑁂 𑀲𑀽𑀭𑀺𑀬𑁄, 𑀘𑀦𑁆𑀤𑁄 𑀘 𑀦 𑀪𑀸𑀲𑀢𑀺 𑀦 𑀨𑀼𑀲𑁆𑀲𑁄;

𑀬𑀣𑀸 𑀅𑀢𑀼𑀮𑀫𑀺𑀤𑀁 𑀫𑀳𑀧𑁆𑀧𑀪𑀸𑀲𑀁, 𑀓𑁄 ¶ 𑀦𑀼 𑀢𑁆𑀯𑀁 𑀢𑀺𑀤𑀺𑀯𑀸 𑀫𑀳𑀺𑀁 𑀉𑀧𑀸𑀕𑀸.

‘‘𑀙𑀺𑀦𑁆𑀤𑀢𑀺 ¶ 𑀭𑀁𑀲𑀻 𑀧𑀪𑀗𑁆𑀓𑀭𑀲𑁆𑀲, 𑀲𑀸𑀥𑀺𑀓𑀯𑀻𑀲𑀢𑀺𑀬𑁄𑀚𑀦𑀸𑀦𑀺 𑀆𑀪𑀸;

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

‘‘𑀩𑀳𑀼𑀧𑀤𑀼𑀫𑀯𑀺𑀘𑀺𑀢𑁆𑀭𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀁, 𑀯𑁄𑀓𑀺𑀡𑁆𑀡𑀁 𑀓𑀼𑀲𑀼𑀫𑁂𑀳𑀺 𑀦𑁂𑀓𑀘𑀺𑀢𑁆𑀢𑀁;

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

‘‘𑀭𑀢𑁆𑀢𑀫𑁆𑀩𑀭𑀧𑀻𑀢𑀯𑀲𑀲𑀸𑀳𑀺, 𑀅𑀕𑀭𑀼𑀧𑀺𑀬𑀗𑁆𑀕𑀼𑀘𑀦𑁆𑀤𑀦𑀼𑀲𑁆𑀲𑀤𑀸𑀳𑀺;

𑀓𑀜𑁆𑀘𑀦𑀢𑀦𑀼𑀲𑀦𑁆𑀦𑀺𑀪𑀢𑁆𑀢𑀘𑀸𑀳𑀺, 𑀧𑀭𑀺𑀧𑀽𑀭𑀁 𑀕𑀕𑀦𑀁𑀯 𑀢𑀸𑀭𑀓𑀸𑀳𑀺.

‘‘𑀦𑀭𑀦𑀸𑀭𑀺𑀬𑁄 [𑀦𑀭𑀦𑀸𑀭𑀻 (𑀓.), 𑀦𑀸𑀭𑀺𑀬𑁄 (?)] 𑀩𑀳𑀼𑀓𑁂𑀢𑁆𑀣𑀦𑁂𑀓𑀯𑀡𑁆𑀡𑀸, 𑀓𑀼𑀲𑀼𑀫𑀯𑀺𑀪𑀽𑀲𑀺𑀢𑀸𑀪𑀭𑀡𑁂𑀢𑁆𑀣 𑀲𑀼𑀫𑀦𑀸;

𑀅𑀦𑀺𑀮𑀧𑀫𑀼𑀜𑁆𑀘𑀺𑀢𑀸 𑀧𑀯𑀦𑁆𑀢𑀺 [𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺 (𑀓.)] 𑀲𑀼𑀭𑀪𑀺𑀁, 𑀢𑀧𑀦𑀺𑀬𑀯𑀺𑀢𑀢𑀸 𑀲𑀼𑀯𑀡𑁆𑀡𑀙𑀦𑁆𑀦𑀸 [𑀲𑀼𑀯𑀡𑁆𑀡𑀘𑁆𑀙𑀸𑀤𑀦𑀸 (𑀲𑀻.)].

‘‘𑀓𑀺𑀲𑁆𑀲 𑀲𑀁𑀬𑀫𑀲𑁆𑀲 [𑀲𑀫𑀤𑀫𑀲𑁆𑀲 (𑀲𑀻.)] 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄, 𑀓𑁂𑀦𑀸𑀲𑀺 𑀓𑀫𑁆𑀫𑀨𑀮𑁂𑀦𑀺𑀥𑀽𑀧𑀧𑀦𑁆𑀦𑁄;

𑀬𑀣𑀸 ¶ 𑀘 𑀢𑁂 𑀅𑀥𑀺𑀕𑀢𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀢𑀤𑀦𑀼𑀧𑀤𑀁 𑀅𑀯𑀘𑀸𑀲𑀺 𑀇𑀗𑁆𑀖 𑀧𑀼𑀝𑁆𑀞𑁄’’𑀢𑀺.

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

𑀢𑀯 𑀭𑀢𑀦𑀯𑀭𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀓𑀭𑀺𑀲𑁆𑀲𑀸𑀫𑀻𑀢𑀺 𑀘 𑀩𑁆𑀭𑀯𑀺𑀢𑁆𑀣 𑀙𑀢𑁆𑀢𑁄.

‘‘𑀚𑀺𑀦𑀯𑀭𑀧𑀯𑀭𑀁 ¶ [𑀚𑀺𑀦𑀧𑀯𑀭𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀉𑀧𑁂𑀳𑀺 [𑀉𑀧𑁂𑀫𑀺 (𑀩𑀳𑀽𑀲𑀼)] 𑀲𑀭𑀡𑀁, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘𑀸𑀧𑀺 𑀢𑀣𑁂𑀯 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀁;

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

‘‘𑀫𑀸 𑀘 𑀧𑀸𑀡𑀯𑀥𑀁 𑀯𑀺𑀯𑀺𑀥𑀁 𑀘𑀭𑀲𑁆𑀲𑀼 𑀅𑀲𑀼𑀘𑀺𑀁,

𑀦 𑀳𑀺 𑀧𑀸𑀡𑁂𑀲𑀼 𑀅𑀲𑀜𑁆𑀜𑀢𑀁 𑀅𑀯𑀡𑁆𑀡𑀬𑀺𑀁𑀲𑀼 𑀲𑀧𑁆𑀧𑀜𑁆𑀜𑀸;

𑀦𑁄𑀢𑀺 𑀧𑀞𑀫𑀁 𑀅𑀯𑁄𑀘𑀳𑀁 𑀪𑀦𑁆𑀢𑁂,

𑀧𑀘𑁆𑀙𑀸 𑀢𑁂 𑀯𑀘𑀦𑀁 𑀢𑀣𑁂𑀯𑀓𑀸𑀲𑀺𑀁.

‘‘𑀫𑀸 ¶ 𑀘 𑀧𑀭𑀚𑀦𑀲𑁆𑀲 𑀭𑀓𑁆𑀔𑀺𑀢𑀫𑁆𑀧𑀺, 𑀆𑀤𑀸𑀢𑀩𑁆𑀩𑀫𑀫𑀜𑁆𑀜𑀺𑀣𑁄 [𑀫𑀫𑀜𑁆𑀜𑀺𑀢𑁆𑀣 (𑀲𑀻. 𑀧𑀻.)] 𑀅𑀤𑀺𑀦𑁆𑀦𑀁;

𑀦𑁄𑀢𑀺 𑀧𑀞𑀫𑀁 𑀅𑀯𑁄𑀘𑀳𑀁 𑀪𑀦𑁆𑀢𑁂, 𑀧𑀘𑁆𑀙𑀸 𑀯𑀘𑀦𑀁 𑀢𑀣𑁂𑀯𑀓𑀸𑀲𑀺𑀁.

‘‘𑀫𑀸 𑀘 𑀧𑀭𑀚𑀦𑀲𑁆𑀲 𑀭𑀓𑁆𑀔𑀺𑀢𑀸𑀬𑁄, 𑀧𑀭𑀪𑀭𑀺𑀬𑀸 𑀅𑀕𑀫𑀸 𑀅𑀦𑀭𑀺𑀬𑀫𑁂𑀢𑀁;

𑀦𑁄𑀢𑀺 𑀧𑀞𑀫𑀁 𑀅𑀯𑁄𑀘𑀳𑀁 𑀪𑀦𑁆𑀢𑁂, 𑀧𑀘𑁆𑀙𑀸 𑀢𑁂 𑀯𑀘𑀦𑀁 𑀢𑀣𑁂𑀯𑀓𑀸𑀲𑀺𑀁;

‘‘𑀫𑀸 𑀘 𑀯𑀺𑀢𑀣𑀁 𑀅𑀜𑁆𑀜𑀣𑀸 𑀅𑀪𑀸𑀡𑀺,

𑀦 ¶ 𑀳𑀺 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀁 𑀅𑀯𑀡𑁆𑀡𑀬𑀺𑀁𑀲𑀼 𑀲𑀧𑁆𑀧𑀜𑁆𑀜𑀸;

𑀦𑁄𑀢𑀺 𑀧𑀞𑀫𑀁 𑀅𑀯𑁄𑀘𑀳𑀁 𑀪𑀦𑁆𑀢𑁂, 𑀧𑀘𑁆𑀙𑀸 𑀢𑁂 𑀯𑀘𑀦𑀁 𑀢𑀣𑁂𑀯𑀓𑀸𑀲𑀺𑀁.

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

𑀦𑁄𑀢𑀺 𑀧𑀞𑀫𑀁 𑀅𑀯𑁄𑀘𑀳𑀁 𑀪𑀦𑁆𑀢𑁂, 𑀧𑀘𑁆𑀙𑀸 𑀢𑁂 𑀯𑀘𑀦𑀁 𑀢𑀣𑁂𑀯𑀓𑀸𑀲𑀺𑀁.

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 𑀇𑀥 𑀧𑀜𑁆𑀘 𑀲𑀺𑀓𑁆𑀔𑀸 𑀓𑀭𑀺𑀢𑁆𑀯𑀸, 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑀺𑀢𑁆𑀯𑀸 𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑁂;

𑀤𑁆𑀯𑁂𑀧𑀣𑀫𑀕𑀫𑀸𑀲𑀺𑀁 𑀘𑁄𑀭𑀫𑀚𑁆𑀛𑁂, 𑀢𑁂 𑀫𑀁 𑀢𑀢𑁆𑀣 𑀯𑀥𑀺𑀁𑀲𑀼 𑀪𑁄𑀕𑀳𑁂𑀢𑀼.

‘‘𑀏𑀢𑁆𑀢𑀓𑀫𑀺𑀤𑀁 ¶ ¶ 𑀅𑀦𑀼𑀲𑁆𑀲𑀭𑀸𑀫𑀺 𑀓𑀼𑀲𑀮𑀁, 𑀢𑀢𑁄 𑀧𑀭𑀁 𑀦 𑀫𑁂 𑀯𑀺𑀚𑁆𑀚𑀢𑀺 𑀅𑀜𑁆𑀜𑀁;

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

‘‘𑀧𑀲𑁆𑀲 𑀔𑀡𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑀲𑀜𑁆𑀜𑀫𑀲𑁆𑀲, 𑀅𑀦𑀼𑀥𑀫𑁆𑀫𑀧𑁆𑀧𑀝𑀺𑀧𑀢𑁆𑀢𑀺𑀬𑀸 𑀯𑀺𑀧𑀸𑀓𑀁;

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

‘‘𑀧𑀲𑁆𑀲 𑀓𑀢𑀺𑀧𑀬𑀸𑀬 𑀤𑁂𑀲𑀦𑀸𑀬, 𑀲𑀼𑀕𑀢𑀺𑀜𑁆𑀘𑀫𑁆𑀳𑀺 ¶ 𑀕𑀢𑁄 𑀲𑀼𑀔𑀜𑁆𑀘 𑀧𑀢𑁆𑀢𑁄;

𑀬𑁂 𑀘 𑀢𑁂 𑀲𑀢𑀢𑀁 𑀲𑀼𑀡𑀦𑁆𑀢𑀺 𑀥𑀫𑁆𑀫𑀁, 𑀫𑀜𑁆𑀜𑁂 𑀢𑁂 𑀅𑀫𑀢𑀁 𑀨𑀼𑀲𑀦𑁆𑀢𑀺 𑀔𑁂𑀫𑀁.

‘‘𑀅𑀧𑁆𑀧𑀫𑁆𑀧𑀺 𑀓𑀢𑀁 𑀫𑀳𑀸𑀯𑀺𑀧𑀸𑀓𑀁, 𑀯𑀺𑀧𑀼𑀮𑀁 𑀳𑁄𑀢𑀺 [𑀯𑀺𑀧𑀼𑀮𑀨𑀮𑀁 (𑀓.)] 𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑁂;

𑀧𑀲𑁆𑀲 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀢𑀸𑀬 𑀙𑀢𑁆𑀢𑁄, 𑀑𑀪𑀸𑀲𑁂𑀢𑀺 𑀧𑀣𑀯𑀺𑀁 𑀬𑀣𑀸𑀧𑀺 𑀲𑀽𑀭𑀺𑀬𑁄.

‘‘𑀓𑀺𑀫𑀺𑀤𑀁 𑀓𑀼𑀲𑀮𑀁 𑀓𑀺𑀫𑀸𑀘𑀭𑁂𑀫, 𑀇𑀘𑁆𑀘𑁂𑀓𑁂 𑀳𑀺 𑀲𑀫𑁂𑀘𑁆𑀘 𑀫𑀦𑁆𑀢𑀬𑀦𑁆𑀢𑀺;

𑀢𑁂 𑀫𑀬𑀁 𑀧𑀼𑀦𑀭𑁂𑀯 [𑀧𑀼𑀦𑀧𑀺 (?)] 𑀮𑀤𑁆𑀥 𑀫𑀸𑀦𑀼𑀲𑀢𑁆𑀢𑀁, 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀸 𑀯𑀺𑀳𑀭𑁂𑀫𑀼 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁄.

‘‘𑀩𑀳𑀼𑀓𑀸𑀭𑁄 ¶ 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑁄 𑀘 𑀲𑀢𑁆𑀣𑀸, 𑀇𑀢𑀺 𑀫𑁂 𑀲𑀢𑀺 𑀅𑀕𑀫𑀸 𑀤𑀺𑀯𑀸 𑀤𑀺𑀯𑀲𑁆𑀲;

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

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

𑀦 𑀘 𑀢𑁂 𑀧𑀼𑀦𑀫𑀼𑀧𑁂𑀦𑁆𑀢𑀺 𑀕𑀩𑁆𑀪𑀲𑁂𑀬𑁆𑀬𑀁, 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀕𑀢𑀸 𑀳𑀺 𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑀸’’𑀢𑀺.

𑀙𑀢𑁆𑀢𑀫𑀸𑀡𑀯𑀓𑀯𑀺𑀫𑀸𑀦𑀁 𑀢𑀢𑀺𑀬𑀁.

𑁪. 𑀓𑀓𑁆𑀓𑀝𑀓𑀭𑀲𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 [𑀭𑀼𑀘𑀺𑀭𑀢𑁆𑀣𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.) 𑁬𑁪𑁬 𑀕𑀸𑀣𑀸𑀬𑀁 ‘‘𑀭𑀼𑀘𑀓𑀼𑀧𑀓𑀺𑀡𑁆𑀡𑀁’’𑀢𑀺 𑀧𑀤𑀲𑁆𑀲 𑀲𑀁𑀯𑀡𑁆𑀡𑀦𑀸 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀸] 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 ¶ 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁 [𑀯𑀕𑁆𑀕𑀼 (𑀲𑀻. 𑀓.), 𑀯𑀕𑁆𑀕𑀽 (𑀲𑁆𑀬𑀸.)];

𑀤𑀺𑀩𑁆𑀩𑀸 𑀭𑀲𑀸 𑀓𑀸𑀫𑀕𑀼𑀡𑁂𑀢𑁆𑀣 𑀧𑀜𑁆𑀘, 𑀦𑀸𑀭𑀺𑀬𑁄 𑀘 𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀲𑀼𑀯𑀡𑁆𑀡𑀙𑀦𑁆𑀦𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀓𑁂𑀦 𑀢𑁂 𑀇𑀥 𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀘 𑀢𑁂 𑀪𑁄𑀕𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

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

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑁄 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀲𑀢𑀺𑀲𑀫𑀼𑀧𑁆𑀧𑀸𑀤𑀓𑀭𑁄 ¶ , 𑀤𑁆𑀯𑀸𑀭𑁂 𑀓𑀓𑁆𑀓𑀝𑀓𑁄 𑀞𑀺𑀢𑁄;

𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀚𑀸𑀢𑀭𑀽𑀧𑀲𑁆𑀲, 𑀲𑁄𑀪𑀢𑀺 𑀤𑀲𑀧𑀸𑀤𑀓𑁄.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀢𑁂𑀦 𑀫𑁂 𑀇𑀥 𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 ¶ 𑀘 𑀫𑁂 𑀪𑁄𑀕𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀅𑀓𑁆𑀔𑀸𑀫𑀺 𑀢𑁂 𑀪𑀺𑀓𑁆𑀔𑀼 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄 𑀬𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀢𑁂𑀦𑀫𑁆𑀳𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀓𑀓𑁆𑀓𑀝𑀓𑀭𑀲𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

(𑀅𑀦𑀦𑁆𑀢𑀭𑀁 𑀧𑀜𑁆𑀘𑀯𑀺𑀫𑀸𑀦𑀁 𑀬𑀣𑀸 𑀓𑀓𑁆𑀓𑀝𑀓𑀭𑀲𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀁 𑀢𑀣𑀸 𑀯𑀺𑀢𑁆𑀣𑀸𑀭𑁂𑀢𑀩𑁆𑀩𑀁)

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… ¶ 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑁄 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀤𑀺𑀩𑁆𑀩𑀁 𑀫𑀫𑀁 𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀫𑀸𑀬𑀼, 𑀯𑀸𑀘𑀸𑀪𑀺𑀕𑀻𑀢𑀁 𑀫𑀦𑀲𑀸 𑀧𑀯𑀢𑁆𑀢𑀺𑀢𑀁;

𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀸 𑀞𑀲𑁆𑀲𑀢𑀺 𑀧𑀼𑀜𑁆𑀜𑀓𑀫𑁆𑀫𑁄, 𑀤𑀺𑀩𑁆𑀩𑁂𑀳𑀺 𑀓𑀸𑀫𑁂𑀳𑀺 𑀲𑀫𑀗𑁆𑀕𑀺𑀪𑀽𑀢𑁄.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀤𑁆𑀯𑀸𑀭𑀧𑀸𑀮𑀯𑀺𑀫𑀸𑀦𑀁 𑀧𑀜𑁆𑀘𑀫𑀁.

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 ¶ 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂…𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀓𑀭𑀡𑀻𑀬𑀸𑀦𑀺 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺, 𑀧𑀡𑁆𑀟𑀺𑀢𑁂𑀦 𑀯𑀺𑀚𑀸𑀦𑀢𑀸;

𑀲𑀫𑁆𑀫𑀕𑁆𑀕𑀢𑁂𑀲𑀼 𑀩𑀼𑀤𑁆𑀥𑁂𑀲𑀼, 𑀬𑀢𑁆𑀣 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

‘‘𑀅𑀢𑁆𑀣𑀸𑀬 𑀯𑀢 𑀫𑁂 𑀩𑀼𑀤𑁆𑀥𑁄, 𑀅𑀭𑀜𑁆𑀜𑀸 𑀕𑀸𑀫𑀫𑀸𑀕𑀢𑁄;

𑀢𑀢𑁆𑀣 ¶ 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀲𑀸𑀤𑁂𑀢𑁆𑀯𑀸, 𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑀽𑀧𑀕𑁄 𑀅𑀳𑀁 [𑀅𑀳𑀼𑀁 (𑀲𑀻.)].

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁭. 𑀤𑀼𑀢𑀺𑀬𑀓𑀭𑀡𑀻𑀬𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀓𑀭𑀡𑀻𑀬𑀸𑀦𑀺 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺, 𑀧𑀡𑁆𑀟𑀺𑀢𑁂𑀦 𑀯𑀺𑀚𑀸𑀦𑀢𑀸;

𑀲𑀫𑁆𑀫𑀕𑁆𑀕𑀢𑁂𑀲𑀼 𑀪𑀺𑀓𑁆𑀔𑀽𑀲𑀼, 𑀬𑀢𑁆𑀣 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁.

‘‘𑀅𑀢𑁆𑀣𑀸𑀬 𑀯𑀢 𑀫𑁂 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀅𑀭𑀜𑁆𑀜𑀸 𑀕𑀸𑀫𑀫𑀸𑀕𑀢𑁄;

𑀢𑀢𑁆𑀣 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀲𑀸𑀤𑁂𑀢𑁆𑀯𑀸, 𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑀽𑀧𑀕𑁄 𑀅𑀳𑀁.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

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

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 ¶ 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 ¶ 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

𑀬𑀜𑁆𑀘𑁂𑀯 𑀤𑀚𑁆𑀚𑀸 𑀢𑀜𑁆𑀘𑁂𑀯 𑀲𑁂𑀬𑁆𑀬𑁄;

𑀲𑀽𑀘𑀺 𑀤𑀺𑀦𑁆𑀦𑀸 𑀲𑀽𑀘𑀺𑀫𑁂𑀯 𑀲𑁂𑀬𑁆𑀬𑁄.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁯. 𑀤𑀼𑀢𑀺𑀬𑀲𑀽𑀘𑀺𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 ¶ 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄,𑀧𑀼𑀭𑀺𑀫𑀚𑀸𑀢𑀺𑀬𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂.

‘‘𑀅𑀤𑁆𑀤𑀲𑀁 ¶ 𑀯𑀺𑀭𑀚𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀁, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀫𑀦𑀸𑀯𑀺𑀮𑀁;

𑀢𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀳𑀁 𑀲𑀽𑀘𑀺𑀁, 𑀧𑀲𑀦𑁆𑀦𑁄 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀲𑀼𑀲𑀼𑀓𑁆𑀓𑀔𑀦𑁆𑀥𑀁 ¶ ¶ 𑀅𑀪𑀺𑀭𑀼𑀬𑁆𑀳 𑀦𑀸𑀕𑀁, 𑀅𑀓𑀸𑀘𑀺𑀦𑀁 𑀤𑀦𑁆𑀢𑀺𑀁 𑀩𑀮𑀺𑀁 𑀫𑀳𑀸𑀚𑀯𑀁;

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

‘‘𑀦𑀸𑀕𑀲𑁆𑀲 𑀤𑀦𑁆𑀢𑁂𑀲𑀼 𑀤𑀼𑀯𑁂𑀲𑀼 𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸, 𑀅𑀘𑁆𑀙𑁄𑀤𑀓𑀸 𑀧𑀤𑀼𑀫𑀺𑀦𑀺𑀬𑁄 𑀲𑀼𑀨𑀼𑀮𑁆𑀮𑀸;

𑀧𑀤𑀼𑀫𑁂𑀲𑀼 𑀘 𑀢𑀼𑀭𑀺𑀬𑀕𑀡𑀸 𑀧𑀯𑀚𑁆𑀚𑀭𑁂, 𑀇𑀫𑀸 𑀘 𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀫𑀦𑁄𑀳𑀭𑀸𑀬𑁄.

‘‘𑀤𑁂𑀯𑀺𑀤𑁆𑀥𑀺𑀧𑀢𑁆𑀢𑁄𑀲𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄 𑀓𑀺𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑁄 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀝𑁆𑀞𑁂𑀯 𑀫𑀼𑀢𑁆𑀢𑀧𑀼𑀧𑁆𑀨𑀸𑀦𑀺, 𑀓𑀲𑁆𑀲𑀧𑀲𑁆𑀲 𑀫𑀳𑁂𑀲𑀺𑀦𑁄 [𑀪𑀕𑀯𑀢𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀣𑀽𑀧𑀲𑁆𑀫𑀺𑀁 𑀅𑀪𑀺𑀭𑁄𑀧𑁂𑀲𑀺𑀁, 𑀧𑀲𑀦𑁆𑀦𑁄 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁧𑁧. 𑀤𑀼𑀢𑀺𑀬𑀦𑀸𑀕𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀫𑀳𑀦𑁆𑀢𑀁 ¶ ¶ 𑀦𑀸𑀕𑀁 𑀅𑀪𑀺𑀭𑀼𑀬𑁆𑀳, 𑀲𑀩𑁆𑀩𑀲𑁂𑀢𑀁 𑀕𑀚𑀼𑀢𑁆𑀢𑀫𑀁;

𑀯𑀦𑀸 𑀯𑀦𑀁 𑀅𑀦𑀼𑀧𑀭𑀺𑀬𑀸𑀲𑀺, 𑀦𑀸𑀭𑀻𑀕𑀡𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄;

𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑁄 𑀤𑀺𑀲𑀸 𑀲𑀩𑁆𑀩𑀸, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸.

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄, 𑀯𑀗𑁆𑀕𑀻𑀲𑁂𑀦𑁂𑀯 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑁄 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄, 𑀉𑀧𑀸𑀲𑀓𑁄 𑀘𑀓𑁆𑀔𑀼𑀫𑀢𑁄 𑀅𑀳𑁄𑀲𑀺𑀁;

𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀢𑁄 𑀅𑀳𑁄𑀲𑀺𑀁, 𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀺𑀲𑁆𑀲𑀁.

‘‘𑀅𑀫𑀚𑁆𑀚𑀧𑁄 ¶ 𑀦𑁄 𑀘 𑀫𑀼𑀲𑀸 𑀅𑀪𑀸𑀡𑀺𑀁 [𑀅𑀪𑀸𑀲𑀺𑀁 (𑀲𑀻. 𑀓.)], 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀢𑀼𑀝𑁆𑀞𑁄 𑀅𑀳𑁄𑀲𑀺𑀁;

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀸𑀲𑀺𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀤𑀼𑀢𑀺𑀬𑀦𑀸𑀕𑀯𑀺𑀫𑀸𑀦𑀁 𑀏𑀓𑀸𑀤𑀲𑀫𑀁.

‘‘𑀓𑁄 ¶ ¶ 𑀦𑀼 𑀤𑀺𑀩𑁆𑀩𑁂𑀦 𑀬𑀸𑀦𑁂𑀦, 𑀲𑀩𑁆𑀩𑀲𑁂𑀢𑁂𑀦 𑀳𑀢𑁆𑀣𑀺𑀦𑀸;

𑀢𑀼𑀭𑀺𑀬𑀢𑀸𑀴𑀺𑀢𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑁄, 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂 𑀫𑀳𑀻𑀬𑀢𑀺.

‘‘𑀤𑁂𑀯𑀢𑀸 𑀦𑀼𑀲𑀺 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀅𑀤𑀼 [𑀆𑀤𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀅𑀚𑀸𑀦𑀦𑁆𑀢𑀸 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫, 𑀓𑀣𑀁 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑀁 𑀫𑀬’’𑀦𑁆𑀢𑀺.

‘‘𑀦𑀫𑁆𑀳𑀺 ¶ 𑀤𑁂𑀯𑁄 𑀦 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀦𑀸𑀧𑀺 [𑀦𑀸𑀫𑁆𑀳𑀺 (𑀓.)] 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

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

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

𑀓𑀺𑀁 𑀓𑀢𑁆𑀯𑀸 𑀫𑀸𑀦𑀼𑀲𑁂 𑀓𑀫𑁆𑀫𑀁, 𑀲𑀼𑀥𑀫𑁆𑀫𑀁 𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀻’’𑀢𑀺.

‘‘𑀉𑀘𑁆𑀙𑀸𑀕𑀸𑀭𑀁 𑀢𑀺𑀡𑀸𑀕𑀸𑀭𑀁, 𑀯𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑀜𑁆𑀘 𑀬𑁄 𑀤𑀤𑁂;

𑀢𑀺𑀡𑁆𑀡𑀁 𑀅𑀜𑁆𑀜𑀢𑀭𑀁 𑀤𑀢𑁆𑀯𑀸, 𑀲𑀼𑀥𑀫𑁆𑀫𑀁 𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀻’’𑀢𑀺.

𑀢𑀢𑀺𑀬𑀦𑀸𑀕𑀯𑀺𑀫𑀸𑀦𑀁 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁.

‘‘𑀤𑀴𑁆𑀳𑀥𑀫𑁆𑀫𑀸 𑀦𑀺𑀲𑀸𑀭𑀲𑁆𑀲, 𑀥𑀦𑀼𑀁 𑀑𑀮𑀼𑀩𑁆𑀪 𑀢𑀺𑀝𑁆𑀞𑀲𑀺;

𑀔𑀢𑁆𑀢𑀺𑀬𑁄 𑀦𑀼𑀲𑀺 𑀭𑀸𑀚𑀜𑁆𑀜𑁄, 𑀅𑀤𑀼 𑀮𑀼𑀤𑁆𑀤𑁄 𑀯𑀦𑁂𑀘𑀭𑁄’’𑀢𑀺 [𑀯𑀦𑀸𑀘𑀭𑁄𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)].

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

𑀦𑀸𑀫𑀁 𑀫𑁂 𑀪𑀺𑀓𑁆𑀔𑀼 𑀢𑁂 𑀩𑁆𑀭𑀽𑀫𑀺, 𑀲𑀼𑀚𑀸𑀢𑁄 𑀇𑀢𑀺 𑀫𑀁 𑀯𑀺𑀤𑀽 [𑀯𑀺𑀤𑀼𑀁 (𑀲𑀻.)].

‘‘𑀫𑀺𑀕𑁂 𑀕𑀯𑁂𑀲𑀫𑀸𑀦𑁄𑀳𑀁, 𑀑𑀕𑀸𑀳𑀦𑁆𑀢𑁄 𑀩𑁆𑀭𑀳𑀸𑀯𑀦𑀁;

𑀫𑀺𑀕𑀁 𑀢𑀜𑁆𑀘𑁂𑀯 [𑀫𑀺𑀕𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑁂𑀯 (𑀲𑁆𑀬𑀸.), 𑀫𑀺𑀕𑀯𑀥𑀜𑁆𑀘 (𑀓.)] 𑀦𑀸𑀤𑁆𑀤𑀓𑁆𑀔𑀺𑀁, 𑀢𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀯𑀸 𑀞𑀺𑀢𑁄 𑀅𑀳’’𑀦𑁆𑀢𑀺.

‘‘𑀲𑁆𑀯𑀸𑀕𑀢𑀁 ¶ 𑀢𑁂 𑀫𑀳𑀸𑀧𑀼𑀜𑁆𑀜, 𑀅𑀣𑁄 𑀢𑁂 𑀅𑀤𑀼𑀭𑀸𑀕𑀢𑀁;

𑀏𑀢𑁆𑀢𑁄 𑀉𑀤𑀓𑀫𑀸𑀤𑀸𑀬, 𑀧𑀸𑀤𑁂 𑀧𑀓𑁆𑀔𑀸𑀮𑀬𑀲𑁆𑀲𑀼 𑀢𑁂.

‘‘𑀇𑀤𑀫𑁆𑀧𑀺 𑀧𑀸𑀦𑀻𑀬𑀁 𑀲𑀻𑀢𑀁, 𑀆𑀪𑀢𑀁 𑀕𑀺𑀭𑀺𑀕𑀩𑁆𑀪𑀭𑀸;

𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢 𑀢𑀢𑁄 𑀧𑀺𑀢𑁆𑀯𑀸 [𑀧𑀻𑀢𑁆𑀯𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀲𑀦𑁆𑀣𑀢𑀲𑁆𑀫𑀺𑀁 𑀉𑀧𑀸𑀯𑀺𑀲𑀸’’𑀢𑀺.

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

𑀦𑁂𑀮𑀸 𑀅𑀢𑁆𑀣𑀯𑀢𑀻 [𑀘𑀢𑁆𑀣𑀯𑀢𑀻 (𑀲𑀻.)] 𑀯𑀕𑁆𑀕𑀼, 𑀫𑀦𑁆𑀢𑁆𑀯𑀸 [𑀫𑀦𑁆𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)] 𑀅𑀢𑁆𑀣𑀜𑁆𑀘 𑀪𑀸𑀲𑀲𑀺 [𑀪𑀸𑀲𑀲𑁂 (𑀲𑀻.)].

‘‘𑀓𑀸 ¶ 𑀢𑁂 𑀭𑀢𑀺 𑀯𑀦𑁂 𑀯𑀺𑀳𑀭𑀢𑁄, 𑀇𑀲𑀺𑀦𑀺𑀲𑀪 𑀯𑀤𑁂𑀳𑀺 𑀧𑀼𑀝𑁆𑀞𑁄;

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

‘‘𑀅𑀳𑀺𑀁𑀲𑀸 ¶ 𑀲𑀩𑁆𑀩𑀧𑀸𑀡𑀻𑀦𑀁, 𑀓𑀼𑀫𑀸𑀭𑀫𑁆𑀳𑀸𑀓 𑀭𑀼𑀘𑁆𑀘𑀢𑀺;

𑀣𑁂𑀬𑁆𑀬𑀸 𑀘 𑀅𑀢𑀺𑀘𑀸𑀭𑀸 𑀘, 𑀫𑀚𑁆𑀚𑀧𑀸𑀦𑀸 𑀘 𑀆𑀭𑀢𑀺.

‘‘𑀆𑀭𑀢𑀺 𑀲𑀫𑀘𑀭𑀺𑀬𑀸 𑀘, 𑀩𑀸𑀳𑀼𑀲𑀘𑁆𑀘𑀁 𑀓𑀢𑀜𑁆𑀜𑀼𑀢𑀸;

𑀤𑀺𑀝𑁆𑀞𑁂𑀯 𑀥𑀫𑁆𑀫𑁂 𑀧𑀸𑀲𑀁𑀲𑀸, 𑀥𑀫𑁆𑀫𑀸 𑀏𑀢𑁂 𑀧𑀲𑀁𑀲𑀺𑀬𑀸𑀢𑀺.

‘‘𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀫𑀭𑀡𑀁 𑀢𑀼𑀬𑁆𑀳𑀁, 𑀑𑀭𑀁 𑀫𑀸𑀲𑁂𑀳𑀺 𑀧𑀜𑁆𑀘𑀳𑀺;

𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢 ¶ 𑀯𑀺𑀚𑀸𑀦𑀸𑀳𑀺, 𑀅𑀢𑁆𑀢𑀸𑀦𑀁 𑀧𑀭𑀺𑀫𑁄𑀘𑀬𑀸’’𑀢𑀺.

‘‘𑀓𑀢𑀫𑀁 𑀲𑁆𑀯𑀸𑀳𑀁 𑀚𑀦𑀧𑀤𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀓𑀺𑀁 𑀓𑀫𑁆𑀫𑀁 𑀓𑀺𑀜𑁆𑀘 𑀧𑁄𑀭𑀺𑀲𑀁;

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

‘‘𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑁂 𑀲𑁄 𑀧𑀤𑁂𑀲𑁄, 𑀓𑀫𑁆𑀫𑀁 𑀯𑀺𑀚𑁆𑀚𑀸 𑀘 𑀧𑁄𑀭𑀺𑀲𑀁;

𑀬𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀪𑀯𑁂 𑀫𑀘𑁆𑀘𑁄, 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑀸𑀚𑀭𑀸𑀫𑀭𑁄.

‘‘𑀫𑀳𑀤𑁆𑀥𑀦𑀸 𑀫𑀳𑀸𑀪𑁄𑀕𑀸, 𑀭𑀝𑁆𑀞𑀯𑀦𑁆𑀢𑁄𑀧𑀺 𑀔𑀢𑁆𑀢𑀺𑀬𑀸;

𑀧𑀳𑀽𑀢𑀥𑀦𑀥𑀜𑁆𑀜𑀸𑀲𑁂, 𑀢𑁂𑀧𑀺 𑀦𑁄 [𑀢𑁂𑀧𑀺 𑀦 (𑀩𑀳𑀽𑀲𑀼)] 𑀅𑀚𑀭𑀸𑀫𑀭𑀸.

‘‘𑀬𑀤𑀺 𑀢𑁂 𑀲𑀼𑀢𑀸 𑀅𑀦𑁆𑀥𑀓𑀯𑁂𑀡𑁆𑀟𑀼𑀧𑀼𑀢𑁆𑀢𑀸 [𑀅𑀦𑁆𑀥𑀓𑀯𑁂𑀡𑁆𑀳𑀼𑀧𑀼𑀢𑁆𑀢𑀸 (𑀲𑀻.), 𑀅𑀡𑁆𑀟𑀓𑀯𑁂𑀡𑁆𑀟𑀧𑀼𑀢𑁆𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀲𑀽𑀭𑀸 𑀯𑀻𑀭𑀸 𑀯𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀧𑁆𑀧𑀳𑀸𑀭𑀺𑀦𑁄;

𑀢𑁂𑀧𑀺 𑀆𑀬𑀼𑀓𑁆𑀔𑀬𑀁 𑀧𑀢𑁆𑀢𑀸, 𑀯𑀺𑀤𑁆𑀥𑀲𑁆𑀢𑀸 𑀲𑀲𑁆𑀲𑀢𑀻𑀲𑀫𑀸.

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

𑀏𑀢𑁂 𑀘𑀜𑁆𑀜𑁂 𑀘 𑀚𑀸𑀢𑀺𑀬𑀸, 𑀢𑁂𑀧𑀺 𑀦𑁄 𑀅𑀚𑀭𑀸𑀫𑀭𑀸.

‘‘𑀬𑁂 𑀫𑀦𑁆𑀢𑀁 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑁂𑀦𑁆𑀢𑀺, 𑀙𑀴𑀗𑁆𑀕𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀺𑀦𑁆𑀢𑀺𑀢𑀁;

𑀏𑀢𑁂 𑀘𑀜𑁆𑀜𑁂 𑀘 𑀯𑀺𑀚𑁆𑀚𑀸𑀬, 𑀢𑁂𑀧𑀺 𑀦𑁄 𑀅𑀚𑀭𑀸𑀫𑀭𑀸.

‘‘𑀇𑀲𑀬𑁄 𑀘𑀸𑀧𑀺 𑀬𑁂 𑀲𑀦𑁆𑀢𑀸, 𑀲𑀜𑁆𑀜𑀢𑀢𑁆𑀢𑀸 𑀢𑀧𑀲𑁆𑀲𑀺𑀦𑁄;

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

‘‘𑀪𑀸𑀯𑀺𑀢𑀢𑁆𑀢𑀸𑀧𑀺 ¶ 𑀅𑀭𑀳𑀦𑁆𑀢𑁄, 𑀓𑀢𑀓𑀺𑀘𑁆𑀘𑀸 𑀅𑀦𑀸𑀲𑀯𑀸;

𑀦𑀺𑀓𑁆𑀔𑀺𑀧𑀦𑁆𑀢𑀺 𑀇𑀫𑀁 𑀤𑁂𑀳𑀁, 𑀧𑀼𑀜𑁆𑀜𑀧𑀸𑀧𑀧𑀭𑀺𑀓𑁆𑀔𑀬𑀸’’𑀢𑀺.

‘‘𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸 𑀅𑀢𑁆𑀣𑀯𑀢𑀻, 𑀕𑀸𑀣𑀸𑀬𑁄 𑀢𑁂 𑀫𑀳𑀸𑀫𑀼𑀦𑀺;

𑀦𑀺𑀚𑁆𑀛𑀢𑁆𑀢𑁄𑀫𑁆𑀳𑀺 ¶ 𑀲𑀼𑀪𑀝𑁆𑀞𑁂𑀦, 𑀢𑁆𑀯𑀜𑁆𑀘 𑀫𑁂 𑀲𑀭𑀡𑀁 𑀪𑀯𑀸’’𑀢𑀺.

‘‘𑀫𑀸 ¶ 𑀫𑀁 𑀢𑁆𑀯𑀁 𑀲𑀭𑀡𑀁 𑀕𑀘𑁆𑀙, 𑀢𑀫𑁂𑀯 𑀲𑀭𑀡𑀁 𑀯𑀚 [𑀪𑀚 (𑀓.)];

𑀲𑀓𑁆𑀬𑀧𑀼𑀢𑁆𑀢𑀁 𑀫𑀳𑀸𑀯𑀻𑀭𑀁, 𑀬𑀫𑀳𑀁 𑀲𑀭𑀡𑀁 𑀕𑀢𑁄’’𑀢𑀺.

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

𑀅𑀳𑀫𑁆𑀧𑀺 𑀤𑀝𑁆𑀞𑀼𑀁 𑀕𑀘𑁆𑀙𑀺𑀲𑁆𑀲𑀁, 𑀚𑀺𑀦𑀁 𑀅𑀧𑁆𑀧𑀝𑀺𑀧𑀼𑀕𑁆𑀕𑀮’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀼𑀭𑀢𑁆𑀣𑀺𑀫𑀲𑁆𑀫𑀺𑀁 ¶ 𑀚𑀦𑀧𑀤𑁂, 𑀑𑀓𑁆𑀓𑀸𑀓𑀓𑀼𑀮𑀲𑀫𑁆𑀪𑀯𑁄;

𑀢𑀢𑁆𑀣𑀸𑀲𑀺 𑀧𑀼𑀭𑀺𑀲𑀸𑀚𑀜𑁆𑀜𑁄, 𑀲𑁄 𑀘 𑀔𑁄 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄’’𑀢𑀺.

‘‘𑀲𑀘𑁂 𑀳𑀺 𑀩𑀼𑀤𑁆𑀥𑁄 𑀢𑀺𑀝𑁆𑀞𑁂𑀬𑁆𑀬, 𑀲𑀢𑁆𑀣𑀸 𑀢𑀼𑀫𑁆𑀳𑀸𑀓 𑀫𑀸𑀭𑀺𑀲;

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

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

𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀫𑁆𑀧𑀺 [𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀫𑀳𑀸𑀯𑀻𑀭𑀁, 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀲𑀭𑀡𑀁 𑀅𑀳𑀁.

‘‘𑀉𑀧𑁂𑀫𑀺 𑀲𑀭𑀡𑀁 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘𑀸𑀧𑀺 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑀁;

𑀲𑀗𑁆𑀖𑀜𑁆𑀘 𑀦𑀭𑀤𑁂𑀯𑀲𑁆𑀲, 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀲𑀭𑀡𑀁 𑀅𑀳𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀫𑀸𑀫𑀺 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀸𑀫𑀺;

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀦𑁄 𑀘 𑀫𑀼𑀲𑀸 𑀪𑀡𑀸𑀫𑀺, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀫𑀺 𑀢𑀼𑀝𑁆𑀞𑁄’’𑀢𑀺.

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

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

‘‘𑀲𑀼𑀯𑀡𑁆𑀡𑀧𑀝𑁆𑀝𑁂𑀳𑀺 𑀲𑀫𑀦𑁆𑀢𑀫𑁄𑀢𑁆𑀣𑀝𑁄, 𑀉𑀭𑀲𑁆𑀲 𑀫𑀼𑀢𑁆𑀢𑀸𑀳𑀺 𑀫𑀡𑀻𑀳𑀺 𑀘𑀺𑀢𑁆𑀢𑀺𑀢𑁄;

𑀮𑁂𑀔𑀸 𑀲𑀼𑀯𑀡𑁆𑀡𑀲𑁆𑀲 𑀘 𑀭𑀽𑀧𑀺𑀬𑀲𑁆𑀲 𑀘, 𑀲𑁄𑀪𑁂𑀦𑁆𑀢𑀺 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀫𑀬𑀸 𑀲𑀼𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸.

‘‘𑀲𑀻𑀲𑀜𑁆𑀘𑀺𑀤𑀁 ¶ 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀲𑁆𑀲 𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀁, 𑀬𑀼𑀕𑀜𑁆𑀘𑀺𑀤𑀁 𑀮𑁄𑀳𑀺𑀢𑀓𑀸𑀬 𑀘𑀺𑀢𑁆𑀢𑀺𑀢𑀁;

𑀬𑀼𑀢𑁆𑀢𑀸 𑀲𑀼𑀯𑀡𑁆𑀡𑀲𑁆𑀲 𑀘 𑀭𑀽𑀧𑀺𑀬𑀲𑁆𑀲 𑀘, 𑀲𑁄𑀪𑀦𑁆𑀢𑀺 𑀅𑀲𑁆𑀲𑀸 𑀘 𑀇𑀫𑁂 𑀫𑀦𑁄𑀚𑀯𑀸.

‘‘𑀲𑁄 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀳𑁂𑀫𑀭𑀣𑁂 𑀅𑀥𑀺𑀝𑁆𑀞𑀺𑀢𑁄, 𑀤𑁂𑀯𑀸𑀦𑀫𑀺𑀦𑁆𑀤𑁄𑀯 𑀲𑀳𑀲𑁆𑀲𑀯𑀸𑀳𑀦𑁄;

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀸𑀳𑀁 𑀬𑀲𑀯𑀦𑁆𑀢 𑀓𑁄𑀯𑀺𑀤𑀁 [𑀓𑁄𑀯𑀺𑀤 (𑀓.)], 𑀓𑀣𑀁 𑀢𑀬𑀸 𑀮𑀤𑁆𑀥𑁄 𑀅𑀬𑀁 𑀉𑀴𑀸𑀭𑁄’’𑀢𑀺.

‘‘𑀲𑀼𑀚𑀸𑀢𑁄 ¶ 𑀦𑀸𑀫𑀳𑀁 𑀪𑀦𑁆𑀢𑁂, 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑁄 𑀧𑀼𑀭𑁂 𑀅𑀳𑀼𑀁;

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

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

𑀇𑀫𑀁 𑀲𑀼𑀚𑀸𑀢 𑀧𑀽𑀚𑁂𑀳𑀺, 𑀢𑀁 𑀢𑁂 𑀅𑀢𑁆𑀣𑀸𑀬 𑀳𑁂𑀳𑀺𑀢𑀺.

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

𑀧𑀳𑀸𑀬 𑀫𑀸𑀦𑀼𑀲𑀁 𑀤𑁂𑀳𑀁, 𑀉𑀧𑀧𑀦𑁆𑀦𑁄𑀫𑁆𑀳𑀺 𑀦𑀦𑁆𑀤𑀦𑀁.

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

𑀭𑀫𑀸𑀫𑀺 𑀦𑀘𑁆𑀘𑀕𑀻𑀢𑁂𑀳𑀺, 𑀅𑀘𑁆𑀙𑀭𑀸𑀳𑀺 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄’’𑀢𑀺.

‘‘𑀲𑀳𑀲𑁆𑀲𑀬𑀼𑀢𑁆𑀢𑀁 ¶ ¶ 𑀳𑀬𑀯𑀸𑀳𑀦𑀁 𑀲𑀼𑀪𑀁, 𑀆𑀭𑀼𑀬𑁆𑀳𑀺𑀫𑀁 𑀲𑀦𑁆𑀤𑀦𑀁 𑀦𑁂𑀓𑀘𑀺𑀢𑁆𑀢𑀁;

𑀉𑀬𑁆𑀬𑀸𑀦𑀪𑀽𑀫𑀺𑀁 𑀅𑀪𑀺𑀢𑁄 𑀅𑀦𑀼𑀓𑁆𑀓𑀫𑀁, 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄 𑀪𑀽𑀢𑀧𑀢𑀻𑀯 𑀯𑀸𑀲𑀯𑁄.

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑀸 𑀢𑁂 𑀭𑀣𑀓𑀼𑀩𑁆𑀩𑀭𑀸 𑀉𑀪𑁄, 𑀨𑀮𑁂𑀳𑀺 [𑀣𑀮𑁂𑀳𑀺 (𑀲𑀻.)] 𑀅𑀁𑀲𑁂𑀳𑀺 𑀅𑀢𑀻𑀯 𑀲𑀗𑁆𑀕𑀢𑀸;

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

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

𑀲𑀼𑀦𑀦𑁆𑀤𑀺𑀖𑁄𑀲𑁄 𑀘 𑀲𑀼𑀪𑀲𑁆𑀲𑀭𑁄 𑀘, 𑀯𑀺𑀭𑁄𑀘𑀢𑀻 𑀘𑀸𑀫𑀭𑀳𑀢𑁆𑀣𑀩𑀸𑀳𑀼𑀪𑀺.

‘‘𑀇𑀫𑀸 𑀘 𑀦𑀸𑀪𑁆𑀬𑁄 𑀫𑀦𑀲𑀸𑀪𑀺𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸, 𑀭𑀣𑀲𑁆𑀲 𑀧𑀸𑀤𑀦𑁆𑀢𑀭𑀫𑀚𑁆𑀛𑀪𑀽𑀲𑀺𑀢𑀸;

𑀇𑀫𑀸 𑀘 𑀦𑀸𑀪𑁆𑀬𑁄 𑀲𑀢𑀭𑀸𑀚𑀺𑀘𑀺𑀢𑁆𑀢𑀺𑀢𑀸, 𑀲𑀢𑁂𑀭𑀢𑀸 𑀯𑀺𑀚𑁆𑀚𑀼𑀭𑀺𑀯𑀧𑁆𑀧𑀪𑀸𑀲𑀭𑁂.

‘‘𑀅𑀦𑁂𑀓𑀘𑀺𑀢𑁆𑀢𑀸𑀯𑀢𑀢𑁄 ¶ 𑀭𑀣𑁄 𑀅𑀬𑀁, 𑀧𑀼𑀣𑀽 𑀘 𑀦𑁂𑀫𑀻 𑀘 𑀲𑀳𑀲𑁆𑀲𑀭𑀁𑀲𑀺𑀓𑁄;

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

‘‘𑀲𑀺𑀭𑀲𑁆𑀫𑀺𑀁 ¶ 𑀘𑀺𑀢𑁆𑀢𑀁 𑀫𑀡𑀺𑀘𑀦𑁆𑀤𑀓𑀧𑁆𑀧𑀺𑀢𑀁, 𑀲𑀤𑀸 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀁 𑀭𑀼𑀘𑀺𑀭𑀁 𑀧𑀪𑀲𑁆𑀲𑀭𑀁;

𑀲𑀼𑀯𑀡𑁆𑀡𑀭𑀸𑀚𑀻𑀳𑀺 𑀅𑀢𑀻𑀯 𑀲𑀗𑁆𑀕𑀢𑀁, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀭𑀸𑀚𑀻𑀯 𑀅𑀢𑀻𑀯 𑀲𑁄𑀪𑀢𑀺.

‘‘𑀇𑀫𑁂 𑀘 𑀯𑀸𑀴𑀻 𑀫𑀡𑀺𑀘𑀦𑁆𑀤𑀓𑀧𑁆𑀧𑀺𑀢𑀸, 𑀆𑀭𑁄𑀳𑀓𑀫𑁆𑀩𑀽 𑀲𑀼𑀚𑀯𑀸 𑀩𑁆𑀭𑀳𑀽𑀧𑀫𑀸.

𑀩𑁆𑀭𑀳𑀸 𑀫𑀳𑀦𑁆𑀢𑀸 𑀩𑀮𑀺𑀦𑁄 𑀫𑀳𑀸𑀚𑀯𑀸, 𑀫𑀦𑁄 𑀢𑀯𑀜𑁆𑀜𑀸𑀬 𑀢𑀣𑁂𑀯 𑀲𑀺𑀁𑀲𑀭𑁂 [𑀲𑀩𑁆𑀩𑀭𑁂 (𑀓.), 𑀲𑀧𑁆𑀧𑀭𑁂 (?)].

‘‘𑀇𑀫𑁂 𑀘 𑀲𑀩𑁆𑀩𑁂 𑀲𑀳𑀺𑀢𑀸 𑀘𑀢𑀼𑀓𑁆𑀓𑀫𑀸, 𑀫𑀦𑁄 𑀢𑀯𑀜𑁆𑀜𑀸𑀬 𑀢𑀣𑁂𑀯 𑀲𑀺𑀁𑀲𑀭𑁂;

𑀲𑀫𑀁 𑀯𑀳𑀦𑁆𑀢𑀸 𑀫𑀼𑀤𑀼𑀓𑀸 𑀅𑀦𑀼𑀤𑁆𑀥𑀢𑀸, 𑀆𑀫𑁄𑀤𑀫𑀸𑀦𑀸 𑀢𑀼𑀭𑀕𑀸𑀦 [𑀢𑀼𑀭𑀗𑁆𑀕𑀸𑀦 (𑀓.)] 𑀫𑀼𑀢𑁆𑀢𑀫𑀸.

‘‘𑀥𑀼𑀦𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀦𑁆𑀢𑀺 𑀧𑀢𑀦𑁆𑀢𑀺 [𑀧𑀯𑀢𑁆𑀢𑀦𑁆𑀢𑀺 (𑀧𑀻. 𑀓.)] 𑀘𑀫𑁆𑀩𑀭𑁂, 𑀅𑀩𑁆𑀪𑀼𑀤𑁆𑀥𑀼𑀦𑀦𑁆𑀢𑀸 𑀲𑀼𑀓𑀢𑁂 𑀧𑀺𑀴𑀦𑁆𑀥𑀦𑁂;

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

‘‘𑀭𑀣𑀲𑁆𑀲 ¶ 𑀖𑁄𑀲𑁄 𑀅𑀧𑀺𑀴𑀦𑁆𑀥𑀦𑀸𑀦 𑀘, 𑀔𑀼𑀭𑀲𑁆𑀲 𑀦𑀸𑀤𑁄 [𑀦𑀸𑀤𑀻 (𑀲𑁆𑀬𑀸.), 𑀦𑀸𑀤𑀺 (𑀧𑀻. 𑀓.)] 𑀅𑀪𑀺𑀳𑀺𑀁𑀲𑀦𑀸𑀬 𑀘;

𑀖𑁄𑀲𑁄 𑀲𑀼𑀯𑀕𑁆𑀕𑀽 𑀲𑀫𑀺𑀢𑀲𑁆𑀲 𑀲𑀼𑀬𑁆𑀬𑀢𑀺, 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑀢𑀽𑀭𑀺𑀬𑀸𑀦𑀺 𑀯𑀺𑀘𑀺𑀢𑁆𑀭𑀲𑀁𑀯𑀦𑁂.

‘‘𑀭𑀣𑁂 𑀞𑀺𑀢𑀸 𑀢𑀸 𑀫𑀺𑀕𑀫𑀦𑁆𑀤𑀮𑁄𑀘𑀦𑀸, 𑀆𑀴𑀸𑀭𑀧𑀫𑁆𑀳𑀸 𑀳𑀲𑀺𑀢𑀸 𑀧𑀺𑀬𑀁𑀯𑀤𑀸;

𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀚𑀸𑀮𑀸𑀯𑀢𑀢𑀸 𑀢𑀦𑀼𑀘𑁆𑀙𑀯𑀸, 𑀲𑀤𑁂𑀯 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑀲𑀽𑀭𑀕𑁆𑀕𑀧𑀽𑀚𑀺𑀢𑀸.

‘‘𑀢𑀸 𑀭𑀢𑁆𑀢𑀭𑀢𑁆𑀢𑀫𑁆𑀩𑀭𑀧𑀻𑀢𑀯𑀸𑀲𑀲𑀸, 𑀯𑀺𑀲𑀸𑀮𑀦𑁂𑀢𑁆𑀢𑀸 𑀅𑀪𑀺𑀭𑀢𑁆𑀢𑀮𑁄𑀘𑀦𑀸;

𑀓𑀼𑀮𑁂 𑀲𑀼𑀚𑀸𑀢𑀸 𑀲𑀼𑀢𑀦𑀽 𑀲𑀼𑀘𑀺𑀫𑁆𑀳𑀺𑀢𑀸, 𑀭𑀣𑁂 𑀞𑀺𑀢𑀸 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀢𑀸 𑀓𑀫𑁆𑀩𑀼𑀓𑁂𑀬𑀽𑀭𑀥𑀭𑀸 𑀲𑀼𑀯𑀸𑀲𑀲𑀸, 𑀲𑀼𑀫𑀚𑁆𑀛𑀺𑀫𑀸 𑀊𑀭𑀼𑀣𑀦𑀽𑀧𑀧𑀦𑁆𑀦𑀸;

𑀯𑀝𑁆𑀝𑀗𑁆𑀕𑀼𑀮𑀺𑀬𑁄 𑀲𑀼𑀫𑀼𑀔𑀸 𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑀸, 𑀭𑀣𑁂 𑀞𑀺𑀢𑀸 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀅𑀜𑁆𑀜𑀸 𑀲𑀼𑀯𑁂𑀡𑀻 𑀲𑀼𑀲𑀼 𑀫𑀺𑀲𑁆𑀲𑀓𑁂𑀲𑀺𑀬𑁄, 𑀲𑀫𑀁 𑀯𑀺𑀪𑀢𑁆𑀢𑀸𑀳𑀺 𑀧𑀪𑀲𑁆𑀲𑀭𑀸𑀳𑀺 𑀘;

𑀅𑀦𑀼𑀩𑁆𑀩𑀢𑀸 𑀢𑀸 𑀢𑀯 𑀫𑀸𑀦𑀲𑁂 𑀭𑀢𑀸, 𑀭𑀣𑁂 𑀞𑀺𑀢𑀸 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀆𑀯𑁂𑀴𑀺𑀦𑀺𑀬𑁄 ¶ 𑀧𑀤𑀼𑀫𑀼𑀧𑁆𑀧𑀮𑀘𑁆𑀙𑀤𑀸, 𑀅𑀮𑀗𑁆𑀓𑀢𑀸 𑀘𑀦𑁆𑀤𑀦𑀲𑀸𑀭𑀯𑀸𑀲𑀺𑀢𑀸 [𑀯𑁄𑀲𑀺𑀢𑀸 (𑀲𑁆𑀬𑀸.), 𑀪𑀽𑀲𑀺𑀢𑀸 (𑀓.)];

𑀅𑀦𑀼𑀩𑁆𑀩𑀢𑀸 ¶ 𑀢𑀸 𑀢𑀯 𑀫𑀸𑀦𑀲𑁂 𑀭𑀢𑀸, 𑀭𑀣𑁂 𑀞𑀺𑀢𑀸 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀢𑀸 ¶ 𑀫𑀸𑀮𑀺𑀦𑀺𑀬𑁄 𑀧𑀤𑀼𑀫𑀼𑀧𑁆𑀧𑀮𑀘𑁆𑀙𑀤𑀸, 𑀅𑀮𑀗𑁆𑀓𑀢𑀸 𑀘𑀦𑁆𑀤𑀦𑀲𑀸𑀭𑀯𑀸𑀲𑀺𑀢𑀸;

𑀅𑀦𑀼𑀩𑁆𑀩𑀢𑀸 𑀢𑀸 𑀢𑀯 𑀫𑀸𑀦𑀲𑁂 𑀭𑀢𑀸, 𑀭𑀣𑁂 𑀞𑀺𑀢𑀸 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸.

‘‘𑀓𑀡𑁆𑀞𑁂𑀲𑀼 ¶ 𑀢𑁂 𑀬𑀸𑀦𑀺 𑀧𑀺𑀴𑀦𑁆𑀥𑀦𑀸𑀦𑀺, 𑀳𑀢𑁆𑀣𑁂𑀲𑀼 𑀧𑀸𑀤𑁂𑀲𑀼 𑀢𑀣𑁂𑀯 𑀲𑀻𑀲𑁂;

𑀑𑀪𑀸𑀲𑀬𑀦𑁆𑀢𑀻 𑀤𑀲 𑀲𑀩𑁆𑀩𑀲𑁄 𑀤𑀺𑀲𑀸, 𑀅𑀩𑁆𑀪𑀼𑀤𑁆𑀤𑀬𑀁 𑀲𑀸𑀭𑀤𑀺𑀓𑁄𑀯 𑀪𑀸𑀡𑀼𑀫𑀸.

‘‘𑀯𑀸𑀢𑀲𑁆𑀲 𑀯𑁂𑀕𑁂𑀦 𑀘 𑀲𑀫𑁆𑀧𑀓𑀫𑁆𑀧𑀺𑀢𑀸, 𑀪𑀼𑀚𑁂𑀲𑀼 𑀫𑀸𑀮𑀸 𑀅𑀧𑀺𑀴𑀦𑁆𑀥𑀦𑀸𑀦𑀺 𑀘;

𑀫𑀼𑀜𑁆𑀘𑀦𑁆𑀢𑀺 𑀖𑁄𑀲𑀁 𑀭𑀽𑀘𑀺𑀭𑀁 𑀲𑀼𑀘𑀺𑀁 𑀲𑀼𑀪𑀁, 𑀲𑀩𑁆𑀩𑁂𑀳𑀺 𑀯𑀺𑀜𑁆𑀜𑀽𑀳𑀺 𑀲𑀼𑀢𑀩𑁆𑀩𑀭𑀽𑀧𑀁.

‘‘𑀉𑀬𑁆𑀬𑀸𑀦𑀪𑀽𑀫𑁆𑀬𑀸 𑀘 𑀤𑀼𑀯𑀤𑁆𑀥𑀢𑁄 𑀞𑀺𑀢𑀸, 𑀭𑀣𑀸 ¶ 𑀘 𑀦𑀸𑀕𑀸 𑀢𑀽𑀭𑀺𑀬𑀸𑀦𑀺 𑀘 𑀲𑀭𑁄;

𑀢𑀫𑁂𑀯 𑀤𑁂𑀯𑀺𑀦𑁆𑀤 𑀧𑀫𑁄𑀤𑀬𑀦𑁆𑀢𑀺, 𑀯𑀻𑀡𑀸 𑀬𑀣𑀸 𑀧𑁄𑀓𑁆𑀔𑀭𑀧𑀢𑁆𑀢𑀩𑀸𑀳𑀼𑀪𑀺.

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

𑀧𑀯𑀚𑁆𑀚𑀫𑀸𑀦𑀸𑀲𑀼 𑀅𑀢𑀻𑀯 𑀅𑀘𑁆𑀙𑀭𑀸, 𑀪𑀫𑀦𑁆𑀢𑀺 𑀓𑀜𑁆𑀜𑀸 𑀧𑀤𑀼𑀫𑁂𑀲𑀼 𑀲𑀺𑀓𑁆𑀔𑀺𑀢𑀸.

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

𑀅𑀣𑁂𑀢𑁆𑀣 𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀅𑀣𑁂𑀢𑁆𑀣 𑀅𑀘𑁆𑀙𑀭𑀸, 𑀑𑀪𑀸𑀲𑀬𑀦𑁆𑀢𑀻 𑀉𑀪𑀢𑁄 𑀯𑀭𑀺𑀢𑁆𑀣𑀺𑀬𑁄.

‘‘𑀲𑁄 𑀫𑁄𑀤𑀲𑀺 𑀢𑀼𑀭𑀺𑀬𑀕𑀡𑀧𑁆𑀧𑀩𑁄𑀥𑀦𑁄, 𑀫𑀳𑀻𑀬𑀫𑀸𑀦𑁄 𑀯𑀚𑀺𑀭𑀸𑀯𑀼𑀥𑁄𑀭𑀺𑀯;

𑀇𑀫𑀸𑀲𑀼 𑀯𑀻𑀡𑀸𑀲𑀼 𑀩𑀳𑀽𑀲𑀼 𑀯𑀕𑁆𑀕𑀽𑀲𑀼, 𑀫𑀦𑀼𑀜𑁆𑀜𑀭𑀽𑀧𑀸𑀲𑀼 𑀳𑀤𑀬𑁂𑀭𑀺𑀢𑀁 𑀧𑀻𑀢𑀺𑀁.

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

𑀉𑀧𑁄𑀲𑀣𑀁 𑀓𑀁 𑀯𑀸 [𑀉𑀧𑁄𑀲𑀣𑀁 𑀓𑀺𑀁 𑀯 (𑀲𑁆𑀬𑀸.)] 𑀢𑀼𑀯𑀁 𑀉𑀧𑀸𑀯𑀲𑀺, 𑀓𑀁 [𑀓𑀺𑀁 (𑀲𑁆𑀬𑀸.)] 𑀥𑀫𑁆𑀫𑀘𑀭𑀺𑀬𑀁 𑀯𑀢𑀫𑀸𑀪𑀺𑀭𑁄𑀘𑀬𑀺.

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

𑀇𑀤𑁆𑀥𑀸𑀦𑀼𑀪𑀸𑀯𑁄 ¶ 𑀯𑀺𑀧𑀼𑀮𑁄 𑀅𑀬𑀁 𑀢𑀯, 𑀬𑀁 𑀤𑁂𑀯𑀲𑀗𑁆𑀖𑀁 𑀅𑀪𑀺𑀭𑁄𑀘𑀲𑁂 𑀪𑀼𑀲𑀁.

‘‘𑀤𑀸𑀦𑀲𑁆𑀲 𑀢𑁂 𑀇𑀤𑀁 𑀨𑀮𑀁, 𑀅𑀣𑁄 𑀲𑀻𑀮𑀲𑁆𑀲 𑀯𑀸 𑀧𑀦;

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

𑀲𑁄 ¶ 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑁄 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀦𑁆𑀢𑀺.

‘‘𑀚𑀺𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑀁 𑀩𑀼𑀤𑁆𑀥𑀫𑀦𑁄𑀫𑀦𑀺𑀓𑁆𑀓𑀫𑀁, 𑀦𑀭𑀼𑀢𑁆𑀢𑀫𑀁 𑀓𑀲𑁆𑀲𑀧𑀫𑀕𑁆𑀕𑀧𑀼𑀕𑁆𑀕𑀮𑀁;

𑀅𑀯𑀸𑀧𑀼𑀭𑀦𑁆𑀢𑀁 𑀅𑀫𑀢𑀲𑁆𑀲 𑀤𑁆𑀯𑀸𑀭𑀁, 𑀤𑁂𑀯𑀸𑀢𑀺𑀤𑁂𑀯𑀁 𑀲𑀢𑀧𑀼𑀜𑁆𑀜𑀮𑀓𑁆𑀔𑀡𑀁.

‘‘𑀢𑀫𑀤𑁆𑀤𑀲𑀁 𑀓𑀼𑀜𑁆𑀚𑀭𑀫𑁄𑀖𑀢𑀺𑀡𑁆𑀡𑀁, 𑀲𑀼𑀯𑀡𑁆𑀡𑀲𑀺𑀗𑁆𑀕𑀻𑀦𑀤𑀩𑀺𑀫𑁆𑀩𑀲𑀸𑀤𑀺𑀲𑀁;

𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀢𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑀳𑀼𑀁 𑀲𑀼𑀘𑀻𑀫𑀦𑁄, 𑀢𑀫𑁂𑀯 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀤𑁆𑀥𑀚𑀁.

‘‘𑀢𑀫𑀦𑁆𑀦𑀧𑀸𑀦𑀁 𑀅𑀣𑀯𑀸𑀧𑀺 𑀘𑀻𑀯𑀭𑀁, 𑀲𑀼𑀘𑀺𑀁 𑀧𑀡𑀻𑀢𑀁 𑀭𑀲𑀲𑀸 𑀉𑀧𑁂𑀢𑀁;

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

‘‘𑀢𑀫𑀦𑁆𑀦𑀧𑀸𑀦𑁂𑀦 ¶ 𑀘 𑀘𑀻𑀯𑀭𑁂𑀦 𑀘, 𑀔𑀚𑁆𑀚𑁂𑀦 𑀪𑁄𑀚𑁆𑀚𑁂𑀦 𑀘 𑀲𑀸𑀬𑀦𑁂𑀦 𑀘;

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

‘‘𑀏𑀢𑁂𑀦𑀼𑀧𑀸𑀬𑁂𑀦 𑀇𑀫𑀁 𑀦𑀺𑀭𑀕𑁆𑀕𑀴𑀁, 𑀬𑀜𑁆𑀜𑀁 𑀬𑀚𑀺𑀢𑁆𑀯𑀸 𑀢𑀺𑀯𑀺𑀥𑀁 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑀁.

𑀧𑀳𑀸𑀬𑀳𑀁 𑀫𑀸𑀦𑀼𑀲𑀓𑀁 𑀲𑀫𑀼𑀲𑁆𑀲𑀬𑀁, 𑀇𑀦𑁆𑀤𑀽𑀧𑀫𑁄 [𑀇𑀦𑁆𑀤𑀲𑁆𑀲𑀫𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀤𑁂𑀯𑀧𑀼𑀭𑁂 𑀭𑀫𑀸𑀫𑀳𑀁.

‘‘𑀆𑀬𑀼𑀜𑁆𑀘 ¶ 𑀯𑀡𑁆𑀡𑀜𑁆𑀘 𑀲𑀼𑀔𑀁 𑀩𑀮𑀜𑁆𑀘, 𑀧𑀡𑀻𑀢𑀭𑀽𑀧𑀁 𑀅𑀪𑀺𑀓𑀗𑁆𑀔𑀢𑀸 𑀫𑀼𑀦𑀺;

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀩𑀳𑀼𑀁 𑀲𑀼𑀲𑀗𑁆𑀔𑀢𑀁, 𑀧𑀢𑀺𑀝𑁆𑀞𑀧𑁂𑀢𑀩𑁆𑀩𑀫𑀲𑀗𑁆𑀕𑀫𑀸𑀦𑀲𑁂.

[𑀓𑀣𑀸. 𑁭𑁯𑁯]‘‘𑀦𑀬𑀺𑀫𑀲𑁆𑀫𑀺𑀁 𑀮𑁄𑀓𑁂 𑀧𑀭𑀲𑁆𑀫𑀺𑀁 [𑀦𑀬𑀺𑀫𑀲𑁆𑀫𑀺𑀁 𑀯𑀸 𑀮𑁄𑀓𑁂 𑀧𑀭𑀲𑁆𑀫𑀺𑀁 (𑀓𑀣𑀸𑀯𑀢𑁆𑀣𑀼 𑁭𑁯𑁯), 𑀦𑀬𑀺𑀫𑀲𑁆𑀫𑀺 𑀮𑁄𑀓𑁂 𑀯 𑀧𑀭𑀲𑁆𑀫𑀺 (?)] 𑀯𑀸 𑀧𑀦, 𑀩𑀼𑀤𑁆𑀥𑁂𑀦 𑀲𑁂𑀝𑁆𑀞𑁄 𑀯 𑀲𑀫𑁄 𑀯 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀆𑀳𑀼𑀦𑁂𑀬𑁆𑀬𑀸𑀦𑀁 [𑀬𑀫𑀸𑀳𑀼𑀦𑁂𑀬𑁆𑀬𑀸𑀦𑀁 (𑀓.)] 𑀧𑀭𑀫𑀸𑀳𑀼𑀢𑀺𑀁 𑀕𑀢𑁄, 𑀧𑀼𑀜𑁆𑀜𑀢𑁆𑀣𑀺𑀓𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀧𑁆𑀨𑀮𑁂𑀲𑀺𑀦’’𑀦𑁆𑀢𑀺.

𑀫𑀳𑀸𑀭𑀣𑀯𑀕𑁆𑀕𑁄 𑀧𑀜𑁆𑀘𑀫𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀫𑀡𑁆𑀟𑀽𑀓𑁄 𑀭𑁂𑀯𑀢𑀻 𑀙𑀢𑁆𑀢𑁄, 𑀓𑀓𑁆𑀓𑀝𑁄 𑀤𑁆𑀯𑀸𑀭𑀧𑀸𑀮𑀓𑁄;

𑀤𑁆𑀯𑁂 𑀓𑀭𑀡𑀻𑀬𑀸 𑀤𑁆𑀯𑁂 𑀲𑀽𑀘𑀺, 𑀢𑀬𑁄 𑀦𑀸𑀕𑀸 𑀘 𑀤𑁆𑀯𑁂 𑀭𑀣𑀸;

𑀧𑀼𑀭𑀺𑀲𑀸𑀦𑀁 𑀧𑀞𑀫𑁄 𑀯𑀕𑁆𑀕𑁄 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀻𑀢𑀺.

𑀪𑀸𑀡𑀯𑀸𑀭𑀁 𑀢𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁧. 𑀧𑀞𑀫𑀅𑀕𑀸𑀭𑀺𑀬𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀬𑀣𑀸 ¶ ¶ ¶ 𑀯𑀦𑀁 𑀘𑀺𑀢𑁆𑀢𑀮𑀢𑀁 𑀧𑀪𑀸𑀲𑀢𑀺 [𑀧𑀓𑀸𑀲𑀢𑀺 (𑀓.)], 𑀉𑀬𑁆𑀬𑀸𑀦𑀲𑁂𑀝𑁆𑀞𑀁 𑀢𑀺𑀤𑀲𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀢𑀣𑀽𑀧𑀫𑀁 𑀢𑀼𑀬𑁆𑀳𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 ¶ 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑁄 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀜𑁆𑀘 𑀪𑀭𑀺𑀬𑀸 𑀘 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂, 𑀑𑀧𑀸𑀦𑀪𑀽𑀢𑀸 𑀖𑀭𑀫𑀸𑀯𑀲𑀺𑀫𑁆𑀳;

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀫𑁆𑀳.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁨. 𑀤𑀼𑀢𑀺𑀬𑀅𑀕𑀸𑀭𑀺𑀬𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀬𑀣𑀸 ¶ 𑀯𑀦𑀁 𑀘𑀺𑀢𑁆𑀢𑀮𑀢𑀁 𑀧𑀪𑀸𑀲𑀢𑀺, 𑀉𑀬𑁆𑀬𑀸𑀦𑀲𑁂𑀝𑁆𑀞𑀁 𑀢𑀺𑀤𑀲𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀢𑀣𑀽𑀧𑀫𑀁 ¶ 𑀢𑀼𑀬𑁆𑀳𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀜𑁆𑀘 𑀪𑀭𑀺𑀬𑀸 𑀘 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂, 𑀑𑀧𑀸𑀦𑀪𑀽𑀢𑀸 𑀖𑀭𑀫𑀸𑀯𑀲𑀺𑀫𑁆𑀳;

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀫𑁆𑀳.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀤𑀼𑀢𑀺𑀬𑀅𑀕𑀸𑀭𑀺𑀬𑀯𑀺𑀫𑀸𑀦𑀁 𑀤𑀼𑀢𑀺𑀬𑀁.

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ ¶ ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀲𑁄𑀴𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 ¶ 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

𑀅𑀝𑁆𑀞𑀝𑁆𑀞𑀓𑀸 𑀲𑀺𑀓𑁆𑀔𑀺𑀢𑀸 𑀲𑀸𑀥𑀼𑀭𑀽𑀧𑀸, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀓𑀜𑁆𑀜𑀸 𑀢𑀺𑀤𑀲𑀘𑀭𑀸 𑀉𑀴𑀸𑀭𑀸;

𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀕𑀸𑀬𑀦𑁆𑀢𑀺 𑀧𑀫𑁄𑀤𑀬𑀦𑁆𑀢𑀺.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀨𑀮𑀤𑀸𑀬𑀻 𑀨𑀮𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀮𑀪𑀢𑀺, 𑀤𑀤𑀫𑀼𑀚𑀼𑀕𑀢𑁂𑀲𑀼 𑀧𑀲𑀦𑁆𑀦𑀫𑀸𑀦𑀲𑁄;

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

‘‘𑀢𑀯𑁂𑀯𑀸𑀳𑀁 [𑀢𑀣𑁂𑀯𑀸𑀳𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀳𑀸𑀫𑀼𑀦𑀺, 𑀅𑀤𑀸𑀲𑀺𑀁 𑀘𑀢𑀼𑀭𑁄 𑀨𑀮𑁂.

‘‘𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀨𑀮𑀁 𑀅𑀮𑀫𑁂𑀯 𑀤𑀸𑀢𑀼𑀁, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀦 𑀲𑀼𑀔𑀢𑁆𑀣𑀺𑀓𑁂𑀦;

𑀤𑀺𑀩𑁆𑀩𑀸𑀦𑀺 𑀯𑀸 𑀧𑀢𑁆𑀣𑀬𑀢𑀸 𑀲𑀼𑀔𑀸𑀦𑀺, 𑀫𑀦𑀼𑀲𑁆𑀲𑀲𑁄𑀪𑀕𑁆𑀕𑀢𑀫𑀺𑀘𑁆𑀙𑀢𑀸 𑀯𑀸.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁪. 𑀧𑀞𑀫𑀉𑀧𑀲𑁆𑀲𑀬𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀘𑀦𑁆𑀤𑁄 ¶ ¶ 𑀬𑀣𑀸 𑀯𑀺𑀕𑀢𑀯𑀮𑀸𑀳𑀓𑁂 𑀦𑀪𑁂, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂;

𑀢𑀣𑀽𑀧𑀫𑀁 𑀢𑀼𑀬𑁆𑀳𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂.

‘‘𑀤𑁂𑀯𑀺𑀤𑁆𑀥𑀺𑀧𑀢𑁆𑀢𑁄𑀲𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑀸, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄 𑀓𑀺𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

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

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀫𑁆𑀳.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀧𑀞𑀫𑀉𑀧𑀲𑁆𑀲𑀬𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

𑁫. 𑀤𑀼𑀢𑀺𑀬𑀉𑀧𑀲𑁆𑀲𑀬𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

𑀲𑀽𑀭𑀺𑀬𑁄 ¶ ¶ 𑀬𑀣𑀸 𑀯𑀺𑀕𑀢𑀯𑀮𑀸𑀳𑀓𑁂 𑀦𑀪𑁂…𑀧𑁂….

(𑀬𑀣𑀸 𑀧𑀼𑀭𑀺𑀫𑀯𑀺𑀫𑀸𑀦𑀁 𑀢𑀣𑀸 𑀯𑀺𑀢𑁆𑀣𑀸𑀭𑁂𑀢𑀩𑁆𑀩𑀁).

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀤𑀼𑀢𑀺𑀬𑀉𑀧𑀲𑁆𑀲𑀬𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀁 𑀧𑀜𑁆𑀘𑀫𑀁.

𑁬. 𑀪𑀺𑀓𑁆𑀔𑀸𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀤𑁂𑀯𑀺𑀤𑁆𑀥𑀺𑀧𑀢𑁆𑀢𑁄𑀲𑀺 ¶ 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄 𑀓𑀺𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀪𑀺𑀓𑁆𑀔𑀼𑀁 𑀢𑀲𑀺𑀢𑀁 𑀓𑀺𑀮𑀦𑁆𑀢𑀁;

𑀏𑀓𑀸𑀳𑀁 𑀪𑀺𑀓𑁆𑀔𑀁 𑀧𑀝𑀺𑀧𑀸𑀤𑀬𑀺𑀲𑁆𑀲𑀁, 𑀲𑀫𑀗𑁆𑀕𑀺 𑀪𑀢𑁆𑀢𑁂𑀦 𑀢𑀤𑀸 𑀅𑀓𑀸𑀲𑀺𑀁.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀪𑀺𑀓𑁆𑀔𑀸𑀤𑀸𑀬𑀓𑀯𑀺𑀫𑀸𑀦𑀁 𑀙𑀝𑁆𑀞𑀁.

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 ¶ 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄, 𑀅𑀳𑁄𑀲𑀺𑀁 𑀬𑀯𑀧𑀸𑀮𑀓𑁄;

𑀅𑀤𑁆𑀤𑀲𑀁 𑀯𑀺𑀭𑀚𑀁 𑀪𑀺𑀓𑁆𑀔𑀼𑀁, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀫𑀦𑀸𑀯𑀺𑀮𑀁.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀅𑀤𑀸𑀲𑀳𑀁 𑀪𑀸𑀕𑀁, 𑀧𑀲𑀦𑁆𑀦𑁄 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺;

𑀓𑀼𑀫𑁆𑀫𑀸𑀲𑀧𑀺𑀡𑁆𑀟𑀁 𑀤𑀢𑁆𑀯𑀸𑀦, 𑀫𑁄𑀤𑀸𑀫𑀺 𑀦𑀦𑁆𑀤𑀦𑁂 𑀯𑀦𑁂.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑁮. 𑀧𑀞𑀫𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀮𑀗𑁆𑀓𑀢𑁄 𑀫𑀮𑁆𑀬𑀥𑀭𑁄 𑀲𑀼𑀯𑀢𑁆𑀣𑁄, 𑀲𑀼𑀓𑀼𑀡𑁆𑀟𑀮𑀻 𑀓𑀧𑁆𑀧𑀺𑀢𑀓𑁂𑀲𑀫𑀲𑁆𑀲𑀼;

𑀆𑀫𑀼𑀢𑁆𑀢𑀳𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑁄 𑀬𑀲𑀲𑁆𑀲𑀻, 𑀤𑀺𑀩𑁆𑀩𑁂 ¶ 𑀯𑀺𑀫𑀸𑀦𑀫𑁆𑀳𑀺 𑀬𑀣𑀸𑀧𑀺 𑀘𑀦𑁆𑀤𑀺𑀫𑀸.

‘‘𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁, 𑀅𑀝𑁆𑀞𑀝𑁆𑀞𑀓𑀸 𑀲𑀺𑀓𑁆𑀔𑀺𑀢𑀸 𑀲𑀸𑀥𑀼𑀭𑀽𑀧𑀸;

𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀓𑀜𑁆𑀜𑀸 𑀢𑀺𑀤𑀲𑀘𑀭𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀕𑀸𑀬𑀦𑁆𑀢𑀺 𑀧𑀫𑁄𑀤𑀬𑀦𑁆𑀢𑀺.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀲𑀫𑀡𑁂 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁂;

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

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀸𑀲𑀺𑀁.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀧𑀞𑀫𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀯𑀺𑀫𑀸𑀦𑀁 𑀅𑀝𑁆𑀞𑀫𑀁.

𑁯. 𑀤𑀼𑀢𑀺𑀬𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀅𑀮𑀗𑁆𑀓𑀢𑁄 ¶ ¶ 𑀫𑀮𑁆𑀬𑀥𑀭𑁄 𑀲𑀼𑀯𑀢𑁆𑀣𑁄, 𑀲𑀼𑀓𑀼𑀡𑁆𑀟𑀮𑀻 𑀓𑀧𑁆𑀧𑀺𑀢𑀓𑁂𑀲𑀫𑀲𑁆𑀲𑀼;

𑀆𑀫𑀼𑀢𑁆𑀢𑀳𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑁄 𑀬𑀲𑀲𑁆𑀲𑀻, 𑀤𑀺𑀩𑁆𑀩𑁂 𑀯𑀺𑀫𑀸𑀦𑀫𑁆𑀳𑀺 𑀬𑀣𑀸𑀧𑀺 𑀘𑀦𑁆𑀤𑀺𑀫𑀸.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 ¶ 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀲𑀫𑀡𑁂 𑀲𑀸𑀥𑀼𑀭𑀽𑀧𑁂 [𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁂 (𑀓.)];

𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀯𑀺𑀚𑁆𑀚𑀸𑀘𑀭𑀡𑁂 𑀬𑀲𑀲𑁆𑀲𑀻, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁂 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁂 𑀧𑀲𑀦𑁆𑀦𑁂 [𑀲𑀻𑀮𑀯𑀢𑀽𑀧𑀧𑀦𑁆𑀦𑁂 (𑀓. 𑀲𑀻. 𑀓.)];

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 ¶ 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀸𑀲𑀺𑀁.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀤𑀼𑀢𑀺𑀬𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀯𑀺𑀫𑀸𑀦𑀁 𑀦𑀯𑀫𑀁.

𑁧𑁦. (𑀉𑀢𑁆𑀢𑀭) 𑀧𑀸𑀬𑀸𑀲𑀺𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀬𑀸 ¶ 𑀤𑁂𑀯𑀭𑀸𑀚𑀲𑁆𑀲 𑀲𑀪𑀸 𑀲𑀼𑀥𑀫𑁆𑀫𑀸, 𑀬𑀢𑁆𑀣𑀘𑁆𑀙𑀢𑀺 𑀤𑁂𑀯𑀲𑀗𑁆𑀖𑁄 𑀲𑀫𑀕𑁆𑀕𑁄;

𑀢𑀣𑀽𑀧𑀫𑀁 𑀢𑀼𑀬𑁆𑀳𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

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

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

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 ¶ 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀸𑀲𑀺𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂. ¶ …𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

(𑀉𑀢𑁆𑀢𑀭) 𑀧𑀸𑀬𑀸𑀲𑀺𑀯𑀺𑀫𑀸𑀦𑀁 [𑀉𑀢𑁆𑀢𑀭𑀯𑀺𑀫𑀸𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀅𑀝𑁆𑀞.)] 𑀤𑀲𑀫𑀁.

𑀧𑀸𑀬𑀸𑀲𑀺𑀯𑀕𑁆𑀕𑁄 𑀙𑀝𑁆𑀞𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀤𑁆𑀯𑁂 𑀅𑀕𑀸𑀭𑀺𑀦𑁄 𑀨𑀮𑀤𑀸𑀬𑀻, 𑀤𑁆𑀯𑁂 𑀉𑀧𑀲𑁆𑀲𑀬𑀤𑀸𑀬𑀻 𑀪𑀺𑀓𑁆𑀔𑀸𑀬 𑀤𑀸𑀬𑀻;

𑀬𑀯𑀧𑀸𑀮𑀓𑁄 𑀘𑁂𑀯 𑀤𑁆𑀯𑁂, 𑀓𑀼𑀡𑁆𑀟𑀮𑀺𑀦𑁄 𑀧𑀸𑀬𑀸𑀲𑀻𑀢𑀺 [𑀧𑀸𑀞𑀪𑁂𑀤𑁄 𑀦𑀢𑁆𑀣𑀺];

𑀧𑀼𑀭𑀺𑀲𑀸𑀦𑀁 𑀤𑀼𑀢𑀺𑀬𑁄 𑀯𑀕𑁆𑀕𑁄 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀻𑀢𑀺.

‘‘𑀬𑀣𑀸 ¶ ¶ ¶ 𑀯𑀦𑀁 𑀘𑀺𑀢𑁆𑀢𑀮𑀢𑀁 𑀧𑀪𑀸𑀲𑀢𑀺, 𑀉𑀬𑁆𑀬𑀸𑀦𑀲𑁂𑀝𑁆𑀞𑀁 𑀢𑀺𑀤𑀲𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀢𑀣𑀽𑀧𑀫𑀁 𑀢𑀼𑀬𑁆𑀳𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… ¶ 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄, 𑀤𑀮𑀺𑀤𑁆𑀤𑁄 𑀅𑀢𑀸𑀡𑁄 𑀓𑀧𑀡𑁄 𑀓𑀫𑁆𑀫𑀓𑀭𑁄 𑀅𑀳𑁄𑀲𑀺𑀁;

𑀚𑀺𑀡𑁆𑀡𑁂 𑀘 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀭𑁄 𑀅𑀪𑀸𑀭𑀺𑀁 [𑀅𑀪𑀭𑀺𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀧𑀺𑀬𑀸 𑀘 𑀫𑁂 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁄 𑀅𑀳𑁂𑀲𑀼𑀁;

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀸𑀲𑀺.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀬𑀣𑀸 ¶ 𑀯𑀦𑀁 𑀦𑀦𑁆𑀤𑀦𑀁 [𑀦𑀦𑁆𑀤𑀦𑀁 𑀘𑀺𑀢𑁆𑀢𑀮𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.), 𑀦𑀦𑁆𑀤𑀯𑀦𑀁 (𑀓.)] 𑀧𑀪𑀸𑀲𑀢𑀺, 𑀉𑀬𑁆𑀬𑀸𑀦𑀲𑁂𑀝𑁆𑀞𑀁 𑀢𑀺𑀤𑀲𑀸𑀦𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀢𑀣𑀽𑀧𑀫𑀁 𑀢𑀼𑀬𑁆𑀳𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀑𑀪𑀸𑀲𑀬𑀁 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… ¶ 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

𑀚𑀺𑀡𑁆𑀡𑁂 𑀘 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀭𑁄 𑀅𑀪𑀸𑀭𑀺𑀁, 𑀧𑀺𑀬𑀸 𑀘 𑀫𑁂 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁄 𑀅𑀳𑁂𑀲𑀼𑀁;

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀸𑀲𑀺𑀁.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂…𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 ¶ 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂…𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

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

𑀆𑀭𑀸𑀫𑀭𑀼𑀓𑁆𑀔𑀸𑀦𑀺 𑀘 𑀭𑁄𑀧𑀬𑀺𑀲𑁆𑀲𑀁, 𑀧𑀺𑀬𑀸 𑀘 𑀫𑁂 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁄 𑀅𑀳𑁂𑀲𑀼𑀁;

𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀸𑀲𑀺𑀁.

‘‘𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑁂 ¶ 𑀧𑀩𑁆𑀩𑀢𑀲𑁆𑀫𑀺𑀁, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀲𑀩𑁆𑀩𑀢𑁄𑀧𑀪𑀁;

𑀳𑁂𑀫𑀚𑀸𑀮𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑀁 [𑀳𑁂𑀫𑀚𑀸𑀮𑀓𑀧𑀘𑁆𑀙𑀦𑁆𑀦𑀁 (𑀲𑀻.)], 𑀓𑀺𑀗𑁆𑀓𑀺𑀡𑀺 [𑀓𑀺𑀗𑁆𑀓𑀡𑀺𑀓 (𑀲𑁆𑀬𑀸. 𑀓.), 𑀓𑀺𑀗𑁆𑀓𑀺𑀡𑀺𑀓 (𑀧𑀻.)] 𑀚𑀸𑀮𑀓𑀧𑁆𑀧𑀺𑀢𑀁.

‘‘𑀅𑀝𑁆𑀞𑀁𑀲𑀸 𑀲𑀼𑀓𑀢𑀸 𑀣𑀫𑁆𑀪𑀸, 𑀲𑀩𑁆𑀩𑁂 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀸𑀫𑀬𑀸;

𑀏𑀓𑀫𑁂𑀓𑀸𑀬 𑀅𑀁𑀲𑀺𑀬𑀸, 𑀭𑀢𑀦𑀸 𑀲𑀢𑁆𑀢 𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸.

‘‘𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀲𑀼𑀯𑀡𑁆𑀡𑀲𑁆𑀲, 𑀨𑀮𑀺𑀓𑀸 𑀭𑀽𑀧𑀺𑀬𑀲𑁆𑀲 𑀘;

𑀫𑀲𑀸𑀭𑀕𑀮𑁆𑀮𑀫𑀼𑀢𑁆𑀢𑀸𑀳𑀺, 𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀕𑀫𑀡𑀻𑀳𑀺 𑀘.

‘‘𑀘𑀺𑀢𑁆𑀭𑀸 𑀫𑀦𑁄𑀭𑀫𑀸 𑀪𑀽𑀫𑀺, 𑀦 𑀢𑀢𑁆𑀣𑀼𑀤𑁆𑀥𑀁𑀲𑀢𑀻 𑀭𑀚𑁄;

𑀕𑁄𑀧𑀸𑀡𑀲𑀻𑀕𑀡𑀸 𑀧𑀻𑀢𑀸, 𑀓𑀽𑀝𑀁 𑀥𑀸𑀭𑁂𑀦𑁆𑀢𑀺 𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸.

‘‘𑀲𑁄𑀧𑀸𑀡𑀸𑀦𑀺 ¶ 𑀘 𑀘𑀢𑁆𑀢𑀸𑀭𑀺, 𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑀸 𑀘𑀢𑀼𑀭𑁄 𑀤𑀺𑀲𑀸;

𑀦𑀸𑀦𑀸𑀭𑀢𑀦𑀕𑀩𑁆𑀪𑁂𑀳𑀺 ¶ , 𑀆𑀤𑀺𑀘𑁆𑀘𑁄𑀯 𑀯𑀺𑀭𑁄𑀘𑀢𑀺.

‘‘𑀯𑁂𑀤𑀺𑀬𑀸 𑀘𑀢𑀲𑁆𑀲𑁄 𑀢𑀢𑁆𑀣, 𑀯𑀺𑀪𑀢𑁆𑀢𑀸 𑀪𑀸𑀕𑀲𑁄 𑀫𑀺𑀢𑀸;

𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀸 𑀆𑀪𑀦𑁆𑀢𑀺, 𑀲𑀫𑀦𑁆𑀢𑀸 𑀘𑀢𑀼𑀭𑁄 𑀤𑀺𑀲𑀸.

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

𑀅𑀢𑀺𑀭𑁄𑀘𑀲𑀺 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀉𑀤𑀬𑀦𑁆𑀢𑁄𑀯 𑀪𑀸𑀡𑀼𑀫𑀸.

‘‘𑀤𑀸𑀦𑀲𑁆𑀲 ¶ 𑀢𑁂 𑀇𑀤𑀁 𑀨𑀮𑀁, 𑀅𑀣𑁄 𑀲𑀻𑀮𑀲𑁆𑀲 𑀯𑀸 𑀧𑀦;

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

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀅𑀦𑁆𑀥𑀓𑀯𑀺𑀦𑁆𑀤𑀲𑁆𑀫𑀺𑀁, 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲𑀸𑀤𑀺𑀘𑁆𑀘𑀩𑀦𑁆𑀥𑀼𑀦𑁄;

𑀯𑀺𑀳𑀸𑀭𑀁 𑀲𑀢𑁆𑀣𑀼 𑀓𑀸𑀭𑁂𑀲𑀺𑀁, 𑀧𑀲𑀦𑁆𑀦𑁄 𑀲𑁂𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺.

‘‘𑀢𑀢𑁆𑀣 𑀕𑀦𑁆𑀥𑀜𑁆𑀘 𑀫𑀸𑀮𑀜𑁆𑀘, 𑀧𑀘𑁆𑀘𑀬𑀜𑁆𑀘 [𑀧𑀘𑁆𑀘𑀕𑁆𑀕𑀜𑁆𑀘 (𑀲𑀻.), 𑀧𑀘𑁆𑀘𑀕𑁆𑀖𑀜𑁆𑀘 (?)] 𑀯𑀺𑀮𑁂𑀧𑀦𑀁;

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

𑀢𑁂𑀦 𑀫𑀬𑁆𑀳𑀁 𑀇𑀤𑀁 𑀮𑀤𑁆𑀥𑀁, 𑀯𑀲𑀁 𑀯𑀢𑁆𑀢𑁂𑀫𑀺 𑀦𑀦𑁆𑀤𑀦𑁂.

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

𑀭𑀫𑀸𑀫𑀺 𑀦𑀘𑁆𑀘𑀕𑀻𑀢𑁂𑀳𑀺, 𑀅𑀘𑁆𑀙𑀭𑀸𑀳𑀺 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄’’𑀢𑀺.

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 ¶ 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄…𑀧𑁂… 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀕𑀺𑀫𑁆𑀳𑀸𑀦𑀁 ¶ 𑀧𑀘𑁆𑀙𑀺𑀫𑁂 𑀫𑀸𑀲𑁂, 𑀧𑀢𑀧𑀦𑁆𑀢𑁂 [𑀧𑀢𑀸𑀧𑀦𑁆𑀢𑁂 (𑀲𑁆𑀬𑀸.), 𑀧𑀢𑀸𑀧𑁂𑀦𑁆𑀢𑁂 (𑀓.)] 𑀤𑀺𑀯𑀗𑁆𑀓𑀭𑁂;

𑀧𑀭𑁂𑀲𑀁 𑀪𑀢𑀓𑁄 𑀧𑁄𑀲𑁄, 𑀅𑀫𑁆𑀩𑀸𑀭𑀸𑀫𑀫𑀲𑀺𑀜𑁆𑀘𑀢𑀺.

‘‘𑀅𑀣 ¶ 𑀢𑁂𑀦𑀸𑀕𑀫𑀸 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑁄𑀢𑀺 𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑁄;

𑀓𑀺𑀮𑀦𑁆𑀢𑀭𑀽𑀧𑁄 𑀓𑀸𑀬𑁂𑀦, 𑀅𑀓𑀺𑀮𑀦𑁆𑀢𑁄𑀯 𑀘𑁂𑀢𑀲𑀸.

‘‘𑀢𑀜𑁆𑀘 ¶ 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀆𑀬𑀦𑁆𑀢𑀁, 𑀅𑀯𑁄𑀘𑀁 𑀅𑀫𑁆𑀩𑀲𑀺𑀜𑁆𑀘𑀓𑁄;

𑀲𑀸𑀥𑀼 𑀢𑀁 [𑀲𑀸𑀥𑀼𑀓𑀁 (𑀓.)] 𑀪𑀦𑁆𑀢𑁂 𑀦𑁆𑀳𑀸𑀧𑁂𑀬𑁆𑀬𑀁, 𑀬𑀁 𑀫𑀫𑀲𑁆𑀲 𑀲𑀼𑀔𑀸𑀯𑀳𑀁.

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

𑀦𑀺𑀲𑀻𑀤𑀺 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀲𑁆𑀫𑀺𑀁, 𑀙𑀸𑀬𑀸𑀬 𑀏𑀓𑀘𑀻𑀯𑀭𑁄.

‘‘𑀢𑀜𑁆𑀘 𑀅𑀘𑁆𑀙𑁂𑀦 𑀯𑀸𑀭𑀺𑀦𑀸, 𑀧𑀲𑀦𑁆𑀦𑀫𑀸𑀦𑀲𑁄 𑀦𑀭𑁄;

𑀦𑁆𑀳𑀸𑀧𑀬𑀻 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀲𑁆𑀫𑀺𑀁, 𑀙𑀸𑀬𑀸𑀬 𑀏𑀓𑀘𑀻𑀯𑀭𑀁.

‘‘𑀅𑀫𑁆𑀩𑁄 ¶ 𑀘 𑀲𑀺𑀢𑁆𑀢𑁄 𑀲𑀫𑀡𑁄 𑀘 𑀦𑁆𑀳𑀸𑀧𑀺𑀢𑁄, 𑀫𑀬𑀸 𑀘 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀲𑀼𑀢𑀁 𑀅𑀦𑀧𑁆𑀧𑀓𑀁;

𑀇𑀢𑀺 𑀲𑁄 𑀧𑀻𑀢𑀺𑀬𑀸 𑀓𑀸𑀬𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀨𑀭𑀢𑀺 𑀅𑀢𑁆𑀢𑀦𑁄.

‘‘𑀢𑀤𑁂𑀯 𑀏𑀢𑁆𑀢𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀅𑀓𑀸𑀲𑀺𑀁 𑀢𑀸𑀬 𑀚𑀸𑀢𑀺𑀬𑀸;

𑀧𑀳𑀸𑀬 𑀫𑀸𑀦𑀼𑀲𑀁 𑀤𑁂𑀳𑀁, 𑀉𑀧𑀧𑀦𑁆𑀦𑁄𑀫𑁆𑀳𑀺 𑀦𑀦𑁆𑀤𑀦𑀁.

‘‘𑀦𑀦𑁆𑀤𑀦𑁂 𑀘 𑀯𑀦𑁂 𑀭𑀫𑁆𑀫𑁂, 𑀦𑀸𑀦𑀸𑀤𑀺𑀚𑀕𑀡𑀸𑀬𑀼𑀢𑁂;

𑀭𑀫𑀸𑀫𑀺 𑀦𑀘𑁆𑀘𑀕𑀻𑀢𑁂𑀳𑀺, 𑀅𑀘𑁆𑀙𑀭𑀸𑀳𑀺 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁄’’𑀢𑀺.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀤𑁂𑀯𑀁 𑀧𑀝𑀺𑀧𑀼𑀘𑁆𑀙𑀺 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀉𑀘𑁆𑀘𑁂 𑀯𑀺𑀫𑀸𑀦𑀫𑁆𑀳𑀺 𑀘𑀺𑀭𑀝𑁆𑀞𑀺𑀢𑀺𑀓𑁂;

𑀆𑀫𑀼𑀢𑁆𑀢𑀳𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑀁 𑀬𑀲𑀲𑁆𑀲𑀺𑀁 [𑀆𑀫𑀼𑀢𑁆𑀢𑀳𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑁄 𑀬𑀲𑀲𑁆𑀲𑀻 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)], 𑀤𑀺𑀩𑁆𑀩𑁂 𑀯𑀺𑀫𑀸𑀦𑀫𑁆𑀳𑀺 𑀬𑀣𑀸𑀧𑀺 𑀘𑀦𑁆𑀤𑀺𑀫𑀸.

‘‘𑀅𑀮𑀗𑁆𑀓𑀢𑁄 ¶ ¶ 𑀫𑀮𑁆𑀬𑀥𑀭𑁄 [𑀫𑀸𑀮𑀪𑀸𑀭𑀻 (𑀲𑀻.), 𑀫𑀸𑀮𑀥𑀭𑀻 (𑀓.)] 𑀲𑀼𑀯𑀢𑁆𑀣𑁄, 𑀲𑀼𑀓𑀼𑀡𑁆𑀟𑀮𑀻 𑀓𑀧𑁆𑀧𑀺𑀢𑀓𑁂𑀲𑀫𑀲𑁆𑀲𑀼;

𑀆𑀫𑀼𑀢𑁆𑀢𑀳𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑁄 𑀬𑀲𑀲𑁆𑀲𑀻, 𑀤𑀺𑀩𑁆𑀩𑁂 𑀯𑀺𑀫𑀸𑀦𑀫𑁆𑀳𑀺 𑀬𑀣𑀸𑀧𑀺 𑀘𑀦𑁆𑀤𑀺𑀫𑀸.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 ¶ 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄, 𑀲𑀗𑁆𑀕𑀫𑁆𑀫 𑀭𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁 𑀧𑀭𑁂𑀲𑀁 𑀥𑁂𑀦𑀼𑀬𑁄;

𑀢𑀢𑁄 𑀘 𑀆𑀕𑀸 𑀲𑀫𑀡𑁄 𑀫𑀫𑀦𑁆𑀢𑀺𑀓𑁂 𑀕𑀸𑀯𑁄 𑀘 𑀫𑀸𑀲𑁂 𑀅𑀕𑀫𑀁𑀲𑀼 𑀔𑀸𑀤𑀺𑀢𑀼𑀁.

‘‘𑀤𑁆𑀯𑀬𑀚𑁆𑀚 ¶ 𑀓𑀺𑀘𑁆𑀘𑀁 𑀉𑀪𑀬𑀜𑁆𑀘 𑀓𑀸𑀭𑀺𑀬𑀁, 𑀇𑀘𑁆𑀘𑁂𑀯𑀳𑀁 [𑀇𑀘𑁆𑀘𑁂𑀯𑀁 (𑀓.)] 𑀪𑀦𑁆𑀢𑁂 𑀢𑀤𑀸 𑀯𑀺𑀘𑀺𑀦𑁆𑀢𑀬𑀺𑀁;

𑀢𑀢𑁄 𑀘 𑀲𑀜𑁆𑀜𑀁 𑀧𑀝𑀺𑀮𑀤𑁆𑀥𑀬𑁄𑀦𑀺𑀲𑁄, 𑀤𑀤𑀸𑀫𑀺 𑀪𑀦𑁆𑀢𑁂𑀢𑀺 𑀔𑀺𑀧𑀺𑀁 𑀅𑀦𑀦𑁆𑀢𑀓𑀁.

‘‘𑀲𑁄 𑀫𑀸𑀲𑀔𑁂𑀢𑁆𑀢𑀁 𑀢𑀼𑀭𑀺𑀢𑁄 𑀅𑀯𑀸𑀲𑀭𑀺𑀁, 𑀧𑀼𑀭𑀸 𑀅𑀬𑀁 𑀪𑀜𑁆𑀚𑀢𑀺 𑀬𑀲𑁆𑀲𑀺𑀤𑀁 𑀥𑀦𑀁;

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

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 ¶ 𑀅𑀝𑁆𑀝𑁄𑀫𑁆𑀳𑀺 𑀤𑀼𑀓𑁆𑀔𑁂𑀦 𑀧𑀻𑀴𑀺𑀢𑁄, 𑀪𑀺𑀓𑁆𑀔𑀼 𑀘 𑀢𑀁 𑀲𑀸𑀫𑀁 𑀫𑀼𑀜𑁆𑀘𑀺𑀢𑁆𑀯𑀸𑀦𑀦𑁆𑀢𑀓𑀁 [𑀫𑀼𑀜𑁆𑀘𑀺𑀢𑁆𑀯 𑀦𑀦𑁆𑀢𑀓𑀁 (𑀲𑀻.), 𑀫𑀼𑀜𑁆𑀘𑀺𑀢𑁆𑀯𑀸 𑀅𑀦𑀦𑁆𑀢𑀓𑀁 (𑀲𑁆𑀬𑀸.)];

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

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

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

‘‘𑀲𑀤𑁂𑀯𑀓𑁂 𑀮𑁄𑀓𑁂 𑀲𑀫𑀸𑀭𑀓𑁂 𑀘, 𑀅𑀜𑁆𑀜𑁄 𑀫𑀼𑀦𑀺 𑀦𑀢𑁆𑀣𑀺 𑀢𑀬𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑁄;

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

‘‘𑀇𑀫𑀲𑁆𑀫𑀺𑀁 ¶ 𑀮𑁄𑀓𑁂 𑀧𑀭𑀲𑁆𑀫𑀺𑀁 𑀯𑀸 𑀧𑀦, 𑀅𑀜𑁆𑀜𑁄 𑀫𑀼𑀦𑀻 𑀦𑀢𑁆𑀣𑀺 𑀢𑀬𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑁄;

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

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

𑀲𑀫𑀦𑁆𑀢𑀸 𑀅𑀦𑀼𑀧𑀭𑀺𑀬𑀸𑀢𑀺, 𑀢𑀸𑀭𑀓𑀸𑀥𑀺𑀧𑀢𑀻 𑀲𑀲𑀻.

‘‘𑀢𑀣𑀽𑀧𑀫𑀁 𑀇𑀤𑀁 𑀩𑁆𑀬𑀫𑁆𑀳𑀁, 𑀤𑀺𑀩𑁆𑀩𑀁 𑀤𑁂𑀯𑀧𑀼𑀭𑀫𑁆𑀳𑀺 𑀘;

𑀅𑀢𑀺𑀭𑁄𑀘𑀢𑀺 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀉𑀤𑀬𑀦𑁆𑀢𑁄𑀯 𑀭𑀁𑀲𑀺𑀫𑀸.

‘‘𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀲𑀼𑀯𑀡𑁆𑀡𑀲𑁆𑀲, 𑀨𑀮𑀺𑀓𑀸 𑀭𑀽𑀧𑀺𑀬𑀲𑁆𑀲 𑀘;

𑀫𑀲𑀸𑀭𑀕𑀮𑁆𑀮𑀫𑀼𑀢𑁆𑀢𑀸𑀳𑀺, 𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀕𑀫𑀡𑀻𑀳𑀺 𑀘.

‘‘𑀘𑀺𑀢𑁆𑀭𑀸 𑀫𑀦𑁄𑀭𑀫𑀸 𑀪𑀽𑀫𑀺, 𑀯𑁂𑀴𑀽𑀭𑀺𑀬𑀲𑁆𑀲 𑀲𑀦𑁆𑀣𑀢𑀸;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 ¶ 𑀲𑀼𑀪𑀸 𑀭𑀫𑁆𑀫𑀸, 𑀧𑀸𑀲𑀸𑀤𑁄 𑀢𑁂 𑀲𑀼𑀫𑀸𑀧𑀺𑀢𑁄.

‘‘𑀭𑀫𑁆𑀫𑀸 ¶ ¶ 𑀘 𑀢𑁂 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻, 𑀧𑀼𑀣𑀼𑀮𑁄𑀫𑀦𑀺𑀲𑁂𑀯𑀺𑀢𑀸;

𑀅𑀘𑁆𑀙𑁄𑀤𑀓𑀸 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀸, 𑀲𑁄𑀯𑀡𑁆𑀡𑀯𑀸𑀮𑀼𑀓𑀲𑀦𑁆𑀣𑀢𑀸.

‘‘𑀦𑀸𑀦𑀸𑀧𑀤𑀼𑀫𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸, 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀲𑀫𑁄𑀢𑀢𑀸 [𑀲𑀫𑁄𑀢𑁆𑀣𑀢𑀸 (𑀓.), 𑀲𑀫𑁄𑀕𑀢𑀸 (𑀲𑁆𑀬𑀸.)];

𑀲𑀼𑀭𑀪𑀺𑀁 𑀲𑀫𑁆𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺, 𑀫𑀦𑀼𑀜𑁆𑀜𑀸 𑀫𑀸𑀮𑀼𑀢𑁂𑀭𑀺𑀢𑀸.

‘‘𑀢𑀲𑁆𑀲𑀸 ¶ 𑀢𑁂 𑀉𑀪𑀢𑁄 𑀧𑀲𑁆𑀲𑁂, 𑀯𑀦𑀕𑀼𑀫𑁆𑀩𑀸 𑀲𑀼𑀫𑀸𑀧𑀺𑀢𑀸;

𑀉𑀧𑁂𑀢𑀸 𑀧𑀼𑀧𑁆𑀨𑀭𑀼𑀓𑁆𑀔𑁂𑀳𑀺, 𑀨𑀮𑀭𑀼𑀓𑁆𑀔𑁂𑀳𑀺 𑀘𑀽𑀪𑀬𑀁.

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀧𑀸𑀤𑁂 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑁂, 𑀫𑀼𑀤𑀼𑀓𑁂 𑀕𑁄𑀡𑀓𑀢𑁆𑀣𑀢𑁂 [𑀘𑁄𑀮𑀲𑀦𑁆𑀣𑀢𑁂 (𑀲𑀻.)];

𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁 𑀤𑁂𑀯𑀭𑀸𑀚𑀁𑀯, 𑀉𑀧𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺 𑀅𑀘𑁆𑀙𑀭𑀸.

‘‘𑀲𑀩𑁆𑀩𑀸𑀪𑀭𑀡𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸, 𑀦𑀸𑀦𑀸𑀫𑀸𑀮𑀸𑀯𑀺𑀪𑀽𑀲𑀺𑀢𑀸;

𑀭𑀫𑁂𑀦𑁆𑀢𑀺 𑀢𑀁 𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑀁, 𑀯𑀲𑀯𑀢𑁆𑀢𑀻𑀯 𑀫𑁄𑀤𑀲𑀺.

‘‘𑀪𑁂𑀭𑀺𑀲𑀗𑁆𑀔𑀫𑀼𑀤𑀺𑀗𑁆𑀕𑀸𑀳𑀺, 𑀯𑀻𑀡𑀸𑀳𑀺 𑀧𑀡𑀯𑁂𑀳𑀺 𑀘;

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

‘‘𑀤𑀺𑀩𑁆𑀩𑀸 𑀢𑁂 𑀯𑀺𑀯𑀺𑀥𑀸 𑀭𑀽𑀧𑀸, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀲𑀤𑁆𑀤𑀸 𑀅𑀣𑁄 𑀭𑀲𑀸;

𑀕𑀦𑁆𑀥𑀸 𑀘 𑀢𑁂 𑀅𑀥𑀺𑀧𑁆𑀧𑁂𑀢𑀸, 𑀨𑁄𑀝𑁆𑀞𑀩𑁆𑀩𑀸 𑀘 𑀫𑀦𑁄𑀭𑀫𑀸.

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

𑀅𑀢𑀺𑀭𑁄𑀘𑀲𑀺 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀉𑀤𑀬𑀦𑁆𑀢𑁄𑀯 𑀪𑀸𑀡𑀼𑀫𑀸.

‘‘𑀤𑀸𑀦𑀲𑁆𑀲 𑀢𑁂 𑀇𑀤𑀁 𑀨𑀮𑀁, 𑀅𑀣𑁄 𑀲𑀻𑀮𑀲𑁆𑀲 𑀯𑀸 𑀧𑀦;

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

𑀲𑁄 ¶ 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀓𑀧𑀺𑀮𑀯𑀢𑁆𑀣𑀼𑀲𑁆𑀫𑀺𑀁, 𑀲𑀸𑀓𑀺𑀬𑀸𑀦𑀁 𑀧𑀼𑀭𑀼𑀢𑁆𑀢𑀫𑁂;

𑀲𑀼𑀤𑁆𑀥𑁄𑀤𑀦𑀲𑁆𑀲 𑀧𑀼𑀢𑁆𑀢𑀲𑁆𑀲, 𑀓𑀡𑁆𑀟𑀓𑁄 𑀲𑀳𑀚𑁄 𑀅𑀳𑀁.

‘‘𑀬𑀤𑀸 𑀲𑁄 𑀅𑀟𑁆𑀠𑀭𑀢𑁆𑀢𑀸𑀬𑀁, 𑀩𑁄𑀥𑀸𑀬 𑀫𑀪𑀺𑀦𑀺𑀓𑁆𑀔𑀫𑀺;

𑀲𑁄 𑀫𑀁 𑀫𑀼𑀤𑀽𑀳𑀺 𑀧𑀸𑀡𑀻𑀳𑀺, 𑀚𑀸𑀮𑀺 [𑀚𑀸𑀮 (𑀲𑀻.)] 𑀢𑀫𑁆𑀩𑀦𑀔𑁂𑀳𑀺 𑀘.

‘‘𑀲𑀢𑁆𑀣𑀺𑀁 𑀆𑀓𑁄𑀝𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀯𑀳 𑀲𑀫𑁆𑀫𑀸𑀢𑀺 𑀘𑀩𑁆𑀭𑀯𑀺;

𑀅𑀳𑀁 𑀮𑁄𑀓𑀁 𑀢𑀸𑀭𑀬𑀺𑀲𑁆𑀲𑀁, 𑀧𑀢𑁆𑀢𑁄 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀢𑀁 ¶ 𑀫𑁂 𑀕𑀺𑀭𑀁 𑀲𑀼𑀡𑀦𑁆𑀢𑀲𑁆𑀲, 𑀳𑀸𑀲𑁄 𑀫𑁂 𑀯𑀺𑀧𑀼𑀮𑁄 𑀅𑀳𑀼;

𑀉𑀤𑀕𑁆𑀕𑀘𑀺𑀢𑁆𑀢𑁄 𑀲𑀼𑀫𑀦𑁄, 𑀅𑀪𑀺𑀲𑀻𑀲𑀺𑀁 [𑀅𑀪𑀺𑀲𑀺𑀁𑀲𑀺𑀁 (𑀲𑀻.), 𑀅𑀪𑀺𑀲𑀻𑀲𑀺 (𑀧𑀻.)] 𑀢𑀤𑀸 𑀅𑀳𑀁.

‘‘𑀅𑀪𑀺𑀭𑀽𑀴𑁆𑀳𑀜𑁆𑀘 𑀫𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀲𑀓𑁆𑀬𑀧𑀼𑀢𑁆𑀢𑀁 𑀫𑀳𑀸𑀬𑀲𑀁;

𑀉𑀤𑀕𑁆𑀕𑀘𑀺𑀢𑁆𑀢𑁄 𑀫𑀼𑀤𑀺𑀢𑁄, 𑀯𑀳𑀺𑀲𑁆𑀲𑀁 𑀧𑀼𑀭𑀺𑀲𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀧𑀭𑁂𑀲𑀁 𑀯𑀺𑀚𑀺𑀢𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀉𑀕𑁆𑀕𑀢𑀲𑁆𑀫𑀺𑀁 𑀤𑀺𑀯𑀸𑀓𑀭𑁂 [𑀤𑀺𑀯𑀗𑁆𑀓𑀭𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀫𑀫𑀁 𑀙𑀦𑁆𑀦𑀜𑁆𑀘 𑀑𑀳𑀸𑀬, 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑁄 𑀲𑁄 𑀅𑀧𑀓𑁆𑀓𑀫𑀺.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀢𑀫𑁆𑀩𑀦𑀔𑁂 𑀧𑀸𑀤𑁂, 𑀚𑀺𑀯𑁆𑀳𑀸𑀬 𑀧𑀭𑀺𑀮𑁂𑀳𑀺𑀲𑀁;

𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀜𑁆𑀘 𑀫𑀳𑀸𑀯𑀻𑀭𑀁, 𑀭𑀼𑀤𑀫𑀸𑀦𑁄 𑀉𑀤𑀺𑀓𑁆𑀔𑀺𑀲𑀁.

‘‘𑀅𑀤𑀲𑁆𑀲𑀦𑁂𑀦𑀳𑀁 ¶ 𑀢𑀲𑁆𑀲, 𑀲𑀓𑁆𑀬𑀧𑀼𑀢𑁆𑀢𑀲𑁆𑀲 𑀲𑀺𑀭𑀻𑀫𑀢𑁄;

𑀅𑀮𑀢𑁆𑀣𑀁 𑀕𑀭𑀼𑀓𑀸𑀩𑀸𑀥𑀁, 𑀔𑀺𑀧𑁆𑀧𑀁 𑀫𑁂 𑀫𑀭𑀡𑀁 𑀅𑀳𑀼.

‘‘𑀢𑀲𑁆𑀲𑁂𑀯 𑀆𑀦𑀼𑀪𑀸𑀯𑁂𑀦, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀆𑀯𑀲𑀸𑀫𑀺𑀤𑀁;

𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀕𑀼𑀡𑁄𑀧𑁂𑀢𑀁 ¶ , 𑀤𑀺𑀩𑁆𑀩𑀁 𑀤𑁂𑀯𑀧𑀼𑀭𑀫𑁆𑀳𑀺 𑀘.

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

𑀢𑁂𑀦𑁂𑀯 𑀓𑀼𑀲𑀮𑀫𑀽𑀮𑁂𑀦, 𑀨𑀼𑀲𑀺𑀲𑁆𑀲𑀁 𑀆𑀲𑀯𑀓𑁆𑀔𑀬𑀁.

‘‘𑀲𑀘𑁂 𑀳𑀺 𑀪𑀦𑁆𑀢𑁂 𑀕𑀘𑁆𑀙𑁂𑀬𑁆𑀬𑀸𑀲𑀺, 𑀲𑀢𑁆𑀣𑀼 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂;

𑀫𑀫𑀸𑀧𑀺 𑀦𑀁 𑀯𑀘𑀦𑁂𑀦, 𑀲𑀺𑀭𑀲𑀸 𑀯𑀚𑁆𑀚𑀸𑀲𑀺 𑀯𑀦𑁆𑀤𑀦𑀁.

‘‘𑀅𑀳𑀫𑁆𑀧𑀺 𑀤𑀝𑁆𑀞𑀼𑀁 𑀕𑀘𑁆𑀙𑀺𑀲𑁆𑀲𑀁, 𑀚𑀺𑀦𑀁 𑀅𑀧𑁆𑀧𑀝𑀺𑀧𑀼𑀕𑁆𑀕𑀮𑀁;

𑀤𑀼𑀮𑁆𑀮𑀪𑀁 𑀤𑀲𑁆𑀲𑀦𑀁 𑀳𑁄𑀢𑀺, 𑀮𑁄𑀓𑀦𑀸𑀣𑀸𑀦 𑀢𑀸𑀤𑀺𑀦’’𑀦𑁆𑀢𑀺.

𑀲𑁄 𑀓𑀢𑀜𑁆𑀜𑀽 𑀓𑀢𑀯𑁂𑀤𑀻, 𑀲𑀢𑁆𑀣𑀸𑀭𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺;

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

𑀯𑀺𑀲𑁄𑀥𑁂𑀢𑁆𑀯𑀸 𑀤𑀺𑀝𑁆𑀞𑀺𑀕𑀢𑀁, 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀁 𑀯𑀢𑀸𑀦𑀺 𑀘;

𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑁆𑀣𑀼𑀦𑁄 𑀧𑀸𑀤𑁂, 𑀢𑀢𑁆𑀣𑁂𑀯𑀦𑁆𑀢𑀭𑀥𑀸𑀬𑀣𑀸𑀢𑀺 [𑀢𑀢𑁆𑀣𑁂𑀯𑀦𑁆𑀢𑀭𑀥𑀸𑀬𑀢𑀻𑀢𑀺 (𑀓.)].

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

𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑁄 𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀗𑁆𑀕𑀡𑁂𑀦, 𑀲𑀼𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑁄 𑀪𑀽𑀢𑀧𑀢𑀻𑀯 𑀫𑁄𑀤𑀲𑀺.

‘‘𑀲𑀫𑀲𑁆𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺 𑀓𑀼𑀢𑁄 𑀧𑀦𑀼𑀢𑁆𑀢𑀭𑁄 [𑀉𑀢𑁆𑀢𑀭𑀺 (𑀓.)], 𑀬𑀲𑁂𑀦 𑀧𑀼𑀜𑁆𑀜𑁂𑀦 𑀘 𑀇𑀤𑁆𑀥𑀺𑀬𑀸 𑀘;

𑀲𑀩𑁆𑀩𑁂 𑀘 𑀤𑁂𑀯𑀸 𑀢𑀺𑀤𑀲𑀕𑀡𑀸 𑀲𑀫𑁂𑀘𑁆𑀘, 𑀢𑀁 ¶ 𑀢𑀁 𑀦𑀫𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀲𑀲𑀺𑀁𑀯 𑀤𑁂𑀯𑀸;

𑀇𑀫𑀸 𑀘 𑀢𑁂 𑀅𑀘𑁆𑀙𑀭𑀸𑀬𑁄 𑀲𑀫𑀦𑁆𑀢𑀢𑁄, 𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀕𑀸𑀬𑀦𑁆𑀢𑀺 𑀧𑀫𑁄𑀤𑀬𑀦𑁆𑀢𑀺.

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄…𑀧𑁂… 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀅𑀳𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀅𑀳𑀼𑀯𑀸𑀲𑀺 𑀧𑀼𑀩𑁆𑀩𑁂, 𑀲𑀼𑀫𑁂𑀥𑀦𑀸𑀫𑀲𑁆𑀲 𑀚𑀺𑀦𑀲𑁆𑀲 𑀲𑀸𑀯𑀓𑁄;

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

‘‘𑀲𑁄𑀳𑀁 ¶ 𑀲𑀼𑀫𑁂𑀥𑀲𑁆𑀲 𑀚𑀺𑀦𑀲𑁆𑀲 𑀲𑀢𑁆𑀣𑀼𑀦𑁄, 𑀧𑀭𑀺𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀲𑁆𑀲𑁄𑀖𑀢𑀺𑀡𑁆𑀡𑀲𑁆𑀲 𑀢𑀸𑀤𑀺𑀦𑁄;

𑀭𑀢𑀦𑀼𑀘𑁆𑀘𑀬𑀁 𑀳𑁂𑀫𑀚𑀸𑀮𑁂𑀦 𑀙𑀦𑁆𑀦𑀁, 𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸 𑀣𑀽𑀧𑀲𑁆𑀫𑀺𑀁 𑀫𑀦𑀁 𑀧𑀲𑀸𑀤𑀬𑀺𑀁.

‘‘𑀦 ¶ 𑀫𑀸𑀲𑀺 𑀤𑀸𑀦𑀁 𑀦 𑀘 𑀫𑀢𑁆𑀣𑀺 𑀤𑀸𑀢𑀼𑀁, 𑀧𑀭𑁂 𑀘 𑀔𑁄 𑀢𑀢𑁆𑀣 𑀲𑀫𑀸𑀤𑀧𑁂𑀲𑀺𑀁;

𑀧𑀽𑀚𑁂𑀣 𑀦𑀁 𑀧𑀽𑀚𑀦𑀻𑀬𑀲𑁆𑀲 [𑀧𑀽𑀚𑀦𑁂𑀬𑁆𑀬𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀥𑀸𑀢𑀼𑀁, 𑀏𑀯𑀁 ¶ 𑀓𑀺𑀭 𑀲𑀕𑁆𑀕𑀫𑀺𑀢𑁄 𑀕𑀫𑀺𑀲𑁆𑀲𑀣.

‘‘𑀢𑀤𑁂𑀯 𑀓𑀫𑁆𑀫𑀁 𑀓𑀼𑀲𑀮𑀁 𑀓𑀢𑀁 𑀫𑀬𑀸, 𑀲𑀼𑀔𑀜𑁆𑀘 𑀤𑀺𑀩𑁆𑀩𑀁 𑀅𑀦𑀼𑀪𑁄𑀫𑀺 𑀅𑀢𑁆𑀢𑀦𑀸;

𑀫𑁄𑀤𑀸𑀫𑀳𑀁 𑀢𑀺𑀤𑀲𑀕𑀡𑀲𑁆𑀲 𑀫𑀚𑁆𑀛𑁂, 𑀦 𑀢𑀲𑁆𑀲 𑀧𑀼𑀜𑁆𑀜𑀲𑁆𑀲 𑀔𑀬𑀫𑁆𑀧𑀺 𑀅𑀚𑁆𑀛𑀕’’𑀦𑁆𑀢𑀺.

𑀅𑀦𑁂𑀓𑀯𑀡𑁆𑀡𑀯𑀺𑀫𑀸𑀦𑀁 𑀅𑀝𑁆𑀞𑀫𑀁.

𑁯. 𑀫𑀝𑁆𑀞𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

[𑀧𑁂. 𑀯. 𑁧𑁮𑁬] ‘‘𑀅𑀮𑀗𑁆𑀓𑀢𑁄 ¶ 𑀫𑀝𑁆𑀞𑀓𑀼𑀡𑁆𑀟𑀮𑀻 [𑀫𑀝𑁆𑀝𑀓𑀼𑀡𑁆𑀟𑀮𑀻 (𑀲𑀻.)], 𑀫𑀸𑀮𑀥𑀸𑀭𑀻 𑀳𑀭𑀺𑀘𑀦𑁆𑀤𑀦𑀼𑀲𑁆𑀲𑀤𑁄;

𑀩𑀸𑀳𑀸 𑀧𑀕𑁆𑀕𑀬𑁆𑀳 𑀓𑀦𑁆𑀤𑀲𑀺, 𑀯𑀦𑀫𑀚𑁆𑀛𑁂 𑀓𑀺𑀁 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁄 𑀢𑀼𑀯’’𑀦𑁆𑀢𑀺.

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑁄 𑀧𑀪𑀲𑁆𑀲𑀭𑁄, 𑀉𑀧𑁆𑀧𑀦𑁆𑀦𑁄 𑀭𑀣𑀧𑀜𑁆𑀚𑀭𑁄 𑀫𑀫;

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

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑀁 𑀫𑀡𑀺𑀫𑀬𑀁, 𑀮𑁄𑀳𑀺𑀢𑀓𑀫𑀬𑀁 [𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀕𑀫𑀬𑀁 (𑀲𑁆𑀬𑀸.), 𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀓𑀫𑀬𑀁 (𑀲𑀻.), 𑀮𑁄𑀳𑀫𑀬𑀁 (𑀓𑀢𑁆𑀣𑀘𑀺)] 𑀅𑀣 𑀭𑀽𑀧𑀺𑀬𑀫𑀬𑀁;

𑀆𑀘𑀺𑀓𑁆𑀔 [𑀆𑀘𑀺𑀓𑁆𑀔𑀣 (𑀓.)] 𑀫𑁂 𑀪𑀤𑁆𑀤𑀫𑀸𑀡𑀯, 𑀘𑀓𑁆𑀓𑀬𑀼𑀕𑀁 𑀧𑀝𑀺𑀧𑀸𑀤𑀬𑀸𑀫𑀺 𑀢𑁂’’𑀢𑀺.

𑀲𑁄 ¶ 𑀫𑀸𑀡𑀯𑁄 𑀢𑀲𑁆𑀲 𑀧𑀸𑀯𑀤𑀺, ‘‘𑀘𑀦𑁆𑀤𑀺𑀫𑀲𑀽𑀭𑀺𑀬𑀸 𑀉𑀪𑀬𑁂𑀢𑁆𑀣 𑀤𑀺𑀲𑁆𑀲𑀭𑁂;

𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑁄 𑀭𑀣𑁄 𑀫𑀫, 𑀢𑁂𑀦 𑀘𑀓𑁆𑀓𑀬𑀼𑀕𑁂𑀦 𑀲𑁄𑀪𑀢𑀻’’𑀢𑀺.

‘‘𑀩𑀸𑀮𑁄 ¶ 𑀔𑁄 𑀢𑁆𑀯𑀁 𑀅𑀲𑀺 𑀫𑀸𑀡𑀯, 𑀬𑁄 𑀢𑁆𑀯𑀁 𑀧𑀢𑁆𑀣𑀬𑀲𑁂 𑀅𑀧𑀢𑁆𑀣𑀺𑀬𑀁;

𑀫𑀜𑁆𑀜𑀸𑀫𑀺 𑀢𑀼𑀯𑀁 𑀫𑀭𑀺𑀲𑁆𑀲𑀲𑀺, 𑀦 𑀳𑀺 𑀢𑁆𑀯𑀁 𑀮𑀘𑁆𑀙𑀲𑀺 𑀘𑀦𑁆𑀤𑀺𑀫𑀲𑀽𑀭𑀺𑀬𑁂’’𑀢𑀺.

‘‘𑀕𑀫𑀦𑀸𑀕𑀫𑀦𑀫𑁆𑀧𑀺 𑀤𑀺𑀲𑁆𑀲𑀢𑀺, 𑀯𑀡𑁆𑀡𑀥𑀸𑀢𑀼 𑀉𑀪𑀬𑀢𑁆𑀣 𑀯𑀻𑀣𑀺𑀬𑀸;

𑀧𑁂𑀢𑁄 [𑀧𑁂𑀢𑁄 𑀧𑀦 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀓𑀸𑀮𑀓𑀢𑁄 𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀺, 𑀓𑁄 𑀦𑀺𑀥 𑀓𑀦𑁆𑀤𑀢𑀁 𑀩𑀸𑀮𑁆𑀬𑀢𑀭𑁄’’𑀢𑀺.

‘‘𑀲𑀘𑁆𑀘𑀁 𑀔𑁄 𑀯𑀤𑁂𑀲𑀺 𑀫𑀸𑀡𑀯, 𑀅𑀳𑀫𑁂𑀯 𑀓𑀦𑁆𑀤𑀢𑀁 𑀩𑀸𑀮𑁆𑀬𑀢𑀭𑁄;

𑀘𑀦𑁆𑀤𑀁 𑀯𑀺𑀬 𑀤𑀸𑀭𑀓𑁄 𑀭𑀼𑀤𑀁, 𑀧𑁂𑀢𑀁 𑀓𑀸𑀮𑀓𑀢𑀸𑀪𑀺𑀧𑀢𑁆𑀣𑀬𑀺’’𑀦𑁆𑀢𑀺.

‘‘𑀆𑀤𑀺𑀢𑁆𑀢𑀁 𑀯𑀢 𑀫𑀁 𑀲𑀦𑁆𑀢𑀁, 𑀖𑀢𑀲𑀺𑀢𑁆𑀢𑀁𑀯 𑀧𑀸𑀯𑀓𑀁;

𑀯𑀸𑀭𑀺𑀦𑀸 𑀯𑀺𑀬 𑀑𑀲𑀺𑀜𑁆𑀘𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀦𑀺𑀩𑁆𑀩𑀸𑀧𑀬𑁂 𑀤𑀭𑀁.

‘‘𑀅𑀩𑁆𑀩𑀳𑀻 ¶ [𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳 (𑀧𑀻.), 𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀢 𑀫𑁂 𑀲𑀮𑁆𑀮𑀁, 𑀲𑁄𑀓𑀁 𑀳𑀤𑀬𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁;

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

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 ¶ ¶ 𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀲𑀮𑁆𑀮𑁄𑀲𑁆𑀫𑀺, 𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑁄𑀲𑁆𑀫𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄;

𑀦 𑀲𑁄𑀘𑀸𑀫𑀺 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀯𑀢 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀫𑀸𑀡𑀯𑀸𑀢𑀺.

‘‘𑀤𑁂𑀯𑀢𑀸 𑀦𑀼𑀲𑀺 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀅𑀤𑀼 [𑀆𑀤𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀓𑁄 𑀯𑀸 𑀢𑁆𑀯𑀁 𑀓𑀲𑁆𑀲 𑀯𑀸 𑀧𑀼𑀢𑁆𑀢𑁄, 𑀓𑀣𑀁 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑀁 𑀫𑀬’’𑀦𑁆𑀢𑀺.

‘‘𑀬𑀜𑁆𑀘 [𑀬𑀁 (𑀓.)] 𑀓𑀦𑁆𑀤𑀲𑀺 𑀬𑀜𑁆𑀘 𑀭𑁄𑀤𑀲𑀺, 𑀧𑀼𑀢𑁆𑀢𑀁 𑀆𑀴𑀸𑀳𑀦𑁂 𑀲𑀬𑀁 𑀤𑀳𑀺𑀢𑁆𑀯𑀸;

𑀲𑁆𑀯𑀸𑀳𑀁 𑀓𑀼𑀲𑀮𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸 𑀓𑀫𑁆𑀫𑀁, 𑀢𑀺𑀤𑀲𑀸𑀦𑀁 𑀲𑀳𑀩𑁆𑀬𑀢𑀁 𑀕𑀢𑁄’’𑀢𑀺 [𑀧𑀢𑁆𑀢𑁄𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

‘‘𑀅𑀧𑁆𑀧𑀁 ¶ 𑀯𑀸 𑀩𑀳𑀼𑀁 𑀯𑀸 𑀦𑀸𑀤𑁆𑀤𑀲𑀸𑀫, 𑀤𑀸𑀦𑀁 𑀤𑀤𑀦𑁆𑀢𑀲𑁆𑀲 𑀲𑀓𑁂 𑀅𑀕𑀸𑀭𑁂;

𑀉𑀧𑁄𑀲𑀣𑀓𑀫𑁆𑀫𑀁 𑀯𑀸 [𑀉𑀧𑁄𑀲𑀣𑀓𑀫𑁆𑀫𑀜𑁆𑀘 (𑀓.)] 𑀢𑀸𑀤𑀺𑀲𑀁, 𑀓𑁂𑀦 𑀓𑀫𑁆𑀫𑁂𑀦 𑀕𑀢𑁄𑀲𑀺 𑀤𑁂𑀯𑀮𑁄𑀓’’𑀦𑁆𑀢𑀺.

‘‘𑀆𑀩𑀸𑀥𑀺𑀓𑁄𑀳𑀁 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁄 𑀕𑀺𑀮𑀸𑀦𑁄, 𑀆𑀢𑀼𑀭𑀭𑀽𑀧𑁄𑀫𑁆𑀳𑀺 𑀲𑀓𑁂 𑀦𑀺𑀯𑁂𑀲𑀦𑁂;

𑀩𑀼𑀤𑁆𑀥𑀁 𑀯𑀺𑀕𑀢𑀭𑀚𑀁 𑀯𑀺𑀢𑀺𑀡𑁆𑀡𑀓𑀗𑁆𑀔𑀁, 𑀅𑀤𑁆𑀤𑀓𑁆𑀔𑀺𑀁 𑀲𑀼𑀕𑀢𑀁 𑀅𑀦𑁄𑀫𑀧𑀜𑁆𑀜𑀁.

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 𑀫𑀼𑀤𑀺𑀢𑀫𑀦𑁄 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀅𑀜𑁆𑀚𑀮𑀺𑀁 ¶ 𑀅𑀓𑀭𑀺𑀁 𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲;

𑀢𑀸𑀳𑀁 𑀓𑀼𑀲𑀮𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦 𑀓𑀫𑁆𑀫𑀁, 𑀢𑀺𑀤𑀲𑀸𑀦𑀁 𑀲𑀳𑀩𑁆𑀬𑀢𑀁 𑀕𑀢𑁄’’𑀢𑀺.

‘‘𑀅𑀘𑁆𑀙𑀭𑀺𑀬𑀁 𑀯𑀢 𑀅𑀩𑁆𑀪𑀼𑀢𑀁 𑀯𑀢, 𑀅𑀜𑁆𑀚𑀮𑀺𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀅𑀬𑀫𑀻𑀤𑀺𑀲𑁄 𑀯𑀺𑀧𑀸𑀓𑁄;

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

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀩𑀼𑀤𑁆𑀥𑀁 𑀲𑀭𑀡𑀁 𑀯𑀚𑀸𑀳𑀺, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀲𑀗𑁆𑀖𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄;

𑀢𑀣𑁂𑀯 𑀲𑀺𑀓𑁆𑀔𑀸𑀬 𑀧𑀤𑀸𑀦𑀺 𑀧𑀜𑁆𑀘, 𑀅𑀔𑀡𑁆𑀟𑀨𑀼𑀮𑁆𑀮𑀸𑀦𑀺 𑀲𑀫𑀸𑀤𑀺𑀬𑀲𑁆𑀲𑀼.

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

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀫𑀸 𑀘 𑀫𑀼𑀲𑀸 𑀪𑀡𑀸𑀳𑀺, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀳𑀺 𑀢𑀼𑀝𑁆𑀞𑁄’’𑀢𑀺.

‘‘𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑁄𑀲𑀺 𑀫𑁂 𑀬𑀓𑁆𑀔, 𑀳𑀺𑀢𑀓𑀸𑀫𑁄𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀓𑀭𑁄𑀫𑀺 𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀘𑀦𑀁, 𑀢𑁆𑀯𑀁𑀲𑀺 𑀆𑀘𑀭𑀺𑀬𑁄 𑀫𑀫𑀸𑀢𑀺.

‘‘𑀉𑀧𑁂𑀫𑀺 𑀲𑀭𑀡𑀁 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘𑀸𑀧𑀺 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑀁;

𑀲𑀗𑁆𑀖𑀜𑁆𑀘 𑀦𑀭𑀤𑁂𑀯𑀲𑁆𑀲, 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀲𑀭𑀡𑀁 𑀅𑀳𑀁.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 ¶ ¶ 𑀯𑀺𑀭𑀫𑀸𑀫𑀺 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀮𑁄𑀓𑁂 ¶ 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀸𑀫𑀺;

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀦𑁄 𑀘 𑀫𑀼𑀲𑀸 𑀪𑀡𑀸𑀫𑀺, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀫𑀺 𑀢𑀼𑀝𑁆𑀞𑁄’’𑀢𑀺.

𑀫𑀝𑁆𑀞𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀯𑀺𑀫𑀸𑀦𑀁 𑀦𑀯𑀫𑀁.

[𑀧𑁂. 𑀯. 𑁬𑁦𑁪] 𑀲𑀼𑀡𑁄𑀣 ¶ ¶ 𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀘 𑀯𑀸𑀡𑀺𑀚𑀸𑀦 𑀘, 𑀲𑀫𑀸𑀕𑀫𑁄 𑀬𑀢𑁆𑀣 𑀢𑀤𑀸 𑀅𑀳𑁄𑀲𑀺;

𑀬𑀣𑀸 𑀓𑀣𑀁 𑀇𑀢𑀭𑀺𑀢𑀭𑁂𑀦 𑀘𑀸𑀧𑀺, 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 𑀢𑀜𑁆𑀘 𑀲𑀼𑀡𑀸𑀣 𑀲𑀩𑁆𑀩𑁂.

‘‘𑀬𑁄 𑀲𑁄 𑀅𑀳𑀼 𑀭𑀸𑀚𑀸 𑀧𑀸𑀬𑀸𑀲𑀺 𑀦𑀸𑀫 [𑀦𑀸𑀫𑁄 (𑀲𑀻.)], 𑀪𑀼𑀫𑁆𑀫𑀸𑀦𑀁 𑀲𑀳𑀩𑁆𑀬𑀕𑀢𑁄 𑀬𑀲𑀲𑁆𑀲𑀻;

𑀲𑁄 𑀫𑁄𑀤𑀫𑀸𑀦𑁄𑀯 𑀲𑀓𑁂 𑀯𑀺𑀫𑀸𑀦𑁂, 𑀅𑀫𑀸𑀦𑀼𑀲𑁄 𑀫𑀸𑀦𑀼𑀲𑁂 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀻𑀢𑀺.

‘‘𑀯𑀗𑁆𑀓𑁂 𑀅𑀭𑀜𑁆𑀜𑁂 𑀅𑀫𑀦𑀼𑀲𑁆𑀲𑀝𑁆𑀞𑀸𑀦𑁂, 𑀓𑀦𑁆𑀢𑀸𑀭𑁂 𑀅𑀧𑁆𑀧𑁄𑀤𑀓𑁂 𑀅𑀧𑁆𑀧𑀪𑀓𑁆𑀔𑁂;

𑀲𑀼𑀤𑀼𑀕𑁆𑀕𑀫𑁂 𑀯𑀡𑁆𑀡𑀼𑀧𑀣𑀲𑁆𑀲 𑀫𑀚𑁆𑀛𑁂, 𑀯𑀗𑁆𑀓𑀁 𑀪𑀬𑀸 [𑀥𑀗𑁆𑀓𑀁𑀪𑀬𑀸 (𑀓.)] 𑀦𑀝𑁆𑀞𑀫𑀦𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀸.

‘‘𑀦𑀬𑀺𑀥 𑀨𑀮𑀸 𑀫𑀽𑀮𑀫𑀬𑀸 𑀘 𑀲𑀦𑁆𑀢𑀺, 𑀉𑀧𑀸𑀤𑀸𑀦𑀁 𑀦𑀢𑁆𑀣𑀺 𑀓𑀼𑀢𑁄𑀥 𑀪𑀓𑁆𑀔𑁄;

𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀧𑀁𑀲𑀽𑀳𑀺 𑀘 𑀯𑀸𑀮𑀼𑀓𑀸𑀳𑀺 𑀘, 𑀢𑀢𑀸𑀳𑀺 ¶ 𑀉𑀡𑁆𑀳𑀸𑀳𑀺 𑀘 𑀤𑀸𑀭𑀼𑀡𑀸𑀳𑀺 𑀘.

‘‘𑀉𑀚𑁆𑀚𑀗𑁆𑀕𑀮𑀁 𑀢𑀢𑁆𑀢𑀫𑀺𑀯𑀁 𑀓𑀧𑀸𑀮𑀁, 𑀅𑀦𑀸𑀬𑀲𑀁 𑀧𑀭𑀮𑁄𑀓𑁂𑀦 𑀢𑀼𑀮𑁆𑀬𑀁;

𑀮𑀼𑀤𑁆𑀤𑀸𑀦𑀫𑀸𑀯𑀸𑀲𑀫𑀺𑀤𑀁 𑀧𑀼𑀭𑀸𑀡𑀁, 𑀪𑀽𑀫𑀺𑀧𑁆𑀧𑀤𑁂𑀲𑁄 𑀅𑀪𑀺𑀲𑀢𑁆𑀢𑀭𑀽𑀧𑁄.

‘‘𑀅𑀣 ¶ 𑀢𑀼𑀫𑁆𑀳𑁂 𑀓𑁂𑀦 [𑀓𑁂𑀦 𑀦𑀼 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀓𑀺𑀫𑀸𑀲𑀫𑀸𑀦𑀸 𑀇𑀫𑀁 𑀧𑀤𑁂𑀲𑀁 𑀳𑀺;

𑀅𑀦𑀼𑀧𑀯𑀺𑀝𑁆𑀞𑀸 𑀲𑀳𑀲𑀸 𑀲𑀫𑁂𑀘𑁆𑀘, 𑀮𑁄𑀪𑀸 𑀪𑀬𑀸 𑀅𑀣 𑀯𑀸 𑀲𑀫𑁆𑀧𑀫𑀽𑀴𑁆𑀳𑀸’’𑀢𑀺.

‘‘𑀫𑀕𑀥𑁂𑀲𑀼 𑀅𑀗𑁆𑀕𑁂𑀲𑀼 𑀘 𑀲𑀢𑁆𑀣𑀯𑀸𑀳𑀸, 𑀆𑀭𑁄𑀧𑀬𑀺𑀢𑁆𑀯𑀸 𑀧𑀡𑀺𑀬𑀁 𑀧𑀼𑀣𑀼𑀢𑁆𑀢𑀁;

𑀢𑁂 𑀬𑀸𑀫𑀲𑁂 𑀲𑀺𑀦𑁆𑀥𑀼𑀲𑁄𑀯𑀻𑀭𑀪𑀽𑀫𑀺𑀁, 𑀥𑀦𑀢𑁆𑀣𑀺𑀓𑀸 𑀉𑀤𑁆𑀤𑀬𑀁 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑀸.

‘‘𑀤𑀺𑀯𑀸 ¶ 𑀧𑀺𑀧𑀸𑀲𑀁 𑀦𑀥𑀺𑀯𑀸𑀲𑀬𑀦𑁆𑀢𑀸, 𑀬𑁄𑀕𑁆𑀕𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀜𑁆𑀘 𑀲𑀫𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑀸,

𑀏𑀢𑁂𑀦 𑀯𑁂𑀕𑁂𑀦 𑀆𑀬𑀸𑀫 𑀲𑀩𑁆𑀩𑁂 [𑀲𑀩𑁆𑀩𑁂 𑀢𑁂 (𑀓.)], 𑀭𑀢𑁆𑀢𑀺𑀁 𑀫𑀕𑁆𑀕𑀁 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀸 𑀯𑀺𑀓𑀸𑀮𑁂.

‘‘𑀢𑁂 𑀤𑀼𑀧𑁆𑀧𑀬𑀸𑀢𑀸 𑀅𑀧𑀭𑀤𑁆𑀥𑀫𑀕𑁆𑀕𑀸, 𑀅𑀦𑁆𑀥𑀸𑀓𑀼𑀮𑀸 𑀯𑀺𑀧𑁆𑀧𑀦𑀝𑁆𑀞𑀸 𑀅𑀭𑀜𑁆𑀜𑁂;

𑀲𑀼𑀤𑀼𑀕𑁆𑀕𑀫𑁂 ¶ 𑀯𑀡𑁆𑀡𑀼𑀧𑀣𑀲𑁆𑀲 𑀫𑀚𑁆𑀛𑁂, 𑀤𑀺𑀲𑀁 𑀦 𑀚𑀸𑀦𑀸𑀫 𑀧𑀫𑀽𑀴𑁆𑀳𑀘𑀺𑀢𑁆𑀢𑀸.

‘‘𑀇𑀤𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀅𑀤𑀺𑀝𑁆𑀞𑀧𑀼𑀩𑁆𑀩𑀁, 𑀯𑀺𑀫𑀸𑀦𑀲𑁂𑀝𑁆𑀞𑀜𑁆𑀘 𑀢𑀯𑀜𑁆𑀘 𑀬𑀓𑁆𑀔;

𑀢𑀢𑀼𑀢𑁆𑀢𑀭𑀺𑀁 𑀚𑀻𑀯𑀺𑀢𑀫𑀸𑀲𑀫𑀸𑀦𑀸, 𑀤𑀺𑀲𑁆𑀯𑀸 𑀧𑀢𑀻𑀢𑀸 𑀲𑀼𑀫𑀦𑀸 𑀉𑀤𑀕𑁆𑀕𑀸’’𑀢𑀺.

‘‘𑀧𑀸𑀭𑀁 𑀲𑀫𑀼𑀤𑁆𑀤𑀲𑁆𑀲 𑀇𑀫𑀜𑁆𑀘 𑀯𑀡𑁆𑀡𑀼𑀁 [𑀯𑀦𑀁 (𑀲𑁆𑀬𑀸.), 𑀯𑀡𑁆𑀡𑀁 (𑀓.)], 𑀯𑁂𑀢𑁆𑀢𑀸𑀘𑀭𑀁 [𑀯𑁂𑀢𑁆𑀢𑀁 𑀧𑀭𑀁 (𑀲𑁆𑀬𑀸.), 𑀯𑁂𑀢𑁆𑀢𑀸𑀘𑀸𑀭𑀁 (𑀓.)] 𑀲𑀗𑁆𑀓𑀼𑀧𑀣𑀜𑁆𑀘 𑀫𑀕𑁆𑀕𑀁;

𑀦𑀤𑀺𑀬𑁄 𑀧𑀦 𑀧𑀩𑁆𑀩𑀢𑀸𑀦𑀜𑁆𑀘 𑀤𑀼𑀕𑁆𑀕𑀸, 𑀧𑀼𑀣𑀼𑀤𑁆𑀤𑀺𑀲𑀸 𑀕𑀘𑁆𑀙𑀣 𑀪𑁄𑀕𑀳𑁂𑀢𑀼.

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

𑀬𑀁 𑀯𑁄 𑀲𑀼𑀢𑀁 𑀯𑀸 𑀅𑀣 𑀯𑀸𑀧𑀺 𑀤𑀺𑀝𑁆𑀞𑀁, 𑀅𑀘𑁆𑀙𑁂𑀭𑀓𑀁 𑀢𑀁 𑀯𑁄 𑀲𑀼𑀡𑁄𑀫 𑀢𑀸𑀢𑀸’’𑀢𑀺.

‘‘𑀇𑀢𑁄𑀧𑀺 ¶ 𑀅𑀘𑁆𑀙𑁂𑀭𑀢𑀭𑀁 𑀓𑀼𑀫𑀸𑀭, 𑀦 𑀢𑁄 𑀲𑀼𑀢𑀁 𑀯𑀸 𑀅𑀣 𑀯𑀸𑀧𑀺 𑀤𑀺𑀝𑁆𑀞𑀁;

𑀅𑀢𑀻𑀢𑀫𑀸𑀦𑀼𑀲𑁆𑀲𑀓𑀫𑁂𑀯 𑀲𑀩𑁆𑀩𑀁, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀢𑀧𑁆𑀧𑀸𑀫 𑀅𑀦𑁄𑀫𑀯𑀡𑁆𑀡𑀁.

‘‘𑀯𑁂𑀳𑀸𑀬𑀲𑀁 𑀧𑁄𑀓𑁆𑀔𑀭𑀜𑁆𑀜𑁄 𑀲𑀯𑀦𑁆𑀢𑀺, 𑀧𑀳𑀽𑀢𑀫𑀮𑁆𑀬𑀸 ¶ [𑀧𑀳𑀽𑀢𑀫𑀸𑀮𑁆𑀬𑀸 (𑀲𑁆𑀬𑀸.)] 𑀩𑀳𑀼𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀸;

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

‘‘𑀯𑁂𑀴𑀽𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 ¶ 𑀲𑀢𑀫𑀼𑀲𑁆𑀲𑀺𑀢𑀸𑀲𑁂, 𑀲𑀺𑀮𑀸𑀧𑀯𑀸𑀴𑀲𑁆𑀲 𑀘 𑀆𑀬𑀢𑀁𑀲𑀸;

𑀫𑀲𑀸𑀭𑀕𑀮𑁆𑀮𑀸 𑀲𑀳𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀕𑀸, 𑀣𑀫𑁆𑀪𑀸 𑀇𑀫𑁂 𑀚𑁄𑀢𑀺𑀭𑀲𑀸𑀫𑀬𑀸𑀲𑁂.

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

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

‘‘𑀚𑀫𑁆𑀩𑁄𑀦𑀤𑀼𑀢𑁆𑀢𑀢𑁆𑀢𑀫𑀺𑀤𑀁 𑀲𑀼𑀫𑀝𑁆𑀞𑁄, 𑀧𑀸𑀲𑀸𑀤𑀲𑁄𑀧𑀸𑀡𑀨𑀮𑀽𑀧𑀧𑀦𑁆𑀦𑁄;

𑀤𑀴𑁆𑀳𑁄 𑀘 𑀯𑀕𑁆𑀕𑀼 𑀘 𑀲𑀼𑀲𑀗𑁆𑀕𑀢𑁄 𑀘 [𑀯𑀕𑁆𑀕𑀼 𑀲𑀼𑀫𑀼𑀔𑁄 𑀲𑀼𑀲𑀗𑁆𑀕𑀢𑁄 (𑀲𑀻.)], 𑀅𑀢𑀻𑀯 𑀦𑀺𑀚𑁆𑀛𑀸𑀦𑀔𑀫𑁄 𑀫𑀦𑀼𑀜𑁆𑀜𑁄.

‘‘𑀭𑀢𑀦𑀦𑁆𑀢𑀭𑀲𑁆𑀫𑀺𑀁 ¶ 𑀩𑀳𑀼𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑀁, 𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑁄 𑀅𑀘𑁆𑀙𑀭𑀸𑀲𑀗𑁆𑀕𑀡𑁂𑀦;

𑀫𑀼𑀭𑀚𑀆𑀮𑀫𑁆𑀩𑀭𑀢𑀽𑀭𑀺𑀬𑀖𑀼𑀝𑁆𑀞𑁄, 𑀅𑀪𑀺𑀯𑀦𑁆𑀤𑀺𑀢𑁄𑀲𑀺 𑀣𑀼𑀢𑀺𑀯𑀦𑁆𑀤𑀦𑀸𑀬.

‘‘𑀲𑁄 ¶ 𑀫𑁄𑀤𑀲𑀺 𑀦𑀸𑀭𑀺𑀕𑀡𑀧𑁆𑀧𑀩𑁄𑀥𑀦𑁄, 𑀯𑀺𑀫𑀸𑀦𑀧𑀸𑀲𑀸𑀤𑀯𑀭𑁂 𑀫𑀦𑁄𑀭𑀫𑁂;

𑀅𑀘𑀺𑀦𑁆𑀢𑀺𑀬𑁄 𑀲𑀩𑁆𑀩𑀕𑀼𑀡𑀽𑀧𑀧𑀦𑁆𑀦𑁄, 𑀭𑀸𑀚𑀸 𑀬𑀣𑀸 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑁄 𑀦𑀴𑀺𑀦𑁆𑀬𑀸 [𑀦𑀴𑀺𑀜𑁆𑀜𑀁 (𑀓.)].

‘‘𑀤𑁂𑀯𑁄 ¶ 𑀦𑀼 𑀆𑀲𑀺 𑀉𑀤𑀯𑀸𑀲𑀺 𑀬𑀓𑁆𑀔𑁄, 𑀉𑀤𑀸𑀳𑀼 𑀤𑁂𑀯𑀺𑀦𑁆𑀤𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄;

𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀢𑀁 𑀯𑀸𑀡𑀺𑀚𑀸 𑀲𑀢𑁆𑀣𑀯𑀸𑀳𑀸, 𑀆𑀘𑀺𑀓𑁆𑀔 𑀓𑁄 𑀦𑀸𑀫 𑀢𑀼𑀯𑀁𑀲𑀺 𑀬𑀓𑁆𑀔𑁄’’𑀢𑀺.

‘‘𑀲𑁂𑀭𑀻𑀲𑀓𑁄 [𑀲𑁂𑀭𑀺𑀲𑁆𑀲𑀓𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀦𑀸𑀫 𑀅𑀳𑀫𑁆𑀳𑀺 𑀬𑀓𑁆𑀔𑁄, 𑀓𑀦𑁆𑀢𑀸𑀭𑀺𑀬𑁄 𑀯𑀡𑁆𑀡𑀼𑀧𑀣𑀫𑁆𑀳𑀺 𑀕𑀼𑀢𑁆𑀢𑁄;

𑀇𑀫𑀁 𑀧𑀤𑁂𑀲𑀁 𑀅𑀪𑀺𑀧𑀸𑀮𑀬𑀸𑀫𑀺, 𑀯𑀘𑀦𑀓𑀭𑁄 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑀲𑁆𑀲 𑀭𑀜𑁆𑀜𑁄’’𑀢𑀺.

‘‘𑀅𑀥𑀺𑀘𑁆𑀘𑀮𑀤𑁆𑀥𑀁 𑀧𑀭𑀺𑀡𑀸𑀫𑀚𑀁 𑀢𑁂, 𑀲𑀬𑀁 𑀓𑀢𑀁 𑀉𑀤𑀸𑀳𑀼 𑀤𑁂𑀯𑁂𑀳𑀺 𑀤𑀺𑀦𑁆𑀦𑀁;

𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀢𑀁 𑀯𑀸𑀡𑀺𑀚𑀸 𑀲𑀢𑁆𑀣𑀯𑀸𑀳𑀸, 𑀓𑀣𑀁 𑀢𑀬𑀸 𑀮𑀤𑁆𑀥𑀫𑀺𑀤𑀁 𑀫𑀦𑀼𑀜𑁆𑀜’’𑀦𑁆𑀢𑀺.

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

𑀲𑀓𑁂𑀳𑀺 𑀓𑀫𑁆𑀫𑁂𑀳𑀺 𑀅𑀧𑀸𑀧𑀓𑁂𑀳𑀺, 𑀧𑀼𑀜𑁆𑀜𑁂𑀳𑀺 ¶ 𑀫𑁂 𑀮𑀤𑁆𑀥𑀫𑀺𑀤𑀁 𑀫𑀦𑀼𑀜𑁆𑀜’’𑀦𑁆𑀢𑀺.

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

𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀢𑀁 𑀯𑀸𑀡𑀺𑀚𑀸 𑀲𑀢𑁆𑀣𑀯𑀸𑀳𑀸, 𑀓𑀣𑀁 𑀢𑀬𑀸 𑀮𑀤𑁆𑀥𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦’’𑀦𑁆𑀢𑀺.

‘‘𑀫𑀫𑀁 𑀧𑀸𑀬𑀸𑀲𑀻𑀢𑀺 𑀅𑀳𑀼 𑀲𑀫𑀜𑁆𑀜𑀸, 𑀭𑀚𑁆𑀚𑀁 𑀬𑀤𑀸 𑀓𑀸𑀭𑀬𑀺𑀁 𑀓𑁄𑀲𑀮𑀸𑀦𑀁;

𑀦𑀢𑁆𑀣𑀺𑀓𑀤𑀺𑀝𑁆𑀞𑀺 𑀓𑀤𑀭𑀺𑀬𑁄 𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁄, 𑀉𑀘𑁆𑀙𑁂𑀤𑀯𑀸𑀤𑀻 𑀘 𑀢𑀤𑀸 𑀅𑀳𑁄𑀲𑀺𑀁.

‘‘𑀲𑀫𑀡𑁄 𑀘 𑀔𑁄 𑀆𑀲𑀺 𑀓𑀼𑀫𑀸𑀭𑀓𑀲𑁆𑀲𑀧𑁄, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁄 𑀘𑀺𑀢𑁆𑀢𑀓𑀣𑀻 𑀉𑀴𑀸𑀭𑁄;

𑀲𑁄 𑀫𑁂 𑀢𑀤𑀸 𑀥𑀫𑁆𑀫𑀓𑀣𑀁 𑀅𑀪𑀸𑀲𑀺 [𑀅𑀓𑀸𑀲𑀺 (𑀲𑀻.)], 𑀤𑀺𑀝𑁆𑀞𑀺𑀯𑀺𑀲𑀽𑀓𑀸𑀦𑀺 𑀯𑀺𑀦𑁄𑀤𑀬𑀻 𑀫𑁂.

‘‘𑀢𑀸𑀳𑀁 ¶ 𑀢𑀲𑁆𑀲 [𑀢𑀸𑀳𑀁 (𑀓.)] 𑀥𑀫𑁆𑀫𑀓𑀣𑀁 𑀲𑀼𑀡𑀺𑀢𑁆𑀯𑀸, 𑀉𑀧𑀸𑀲𑀓𑀢𑁆𑀢𑀁 𑀧𑀝𑀺𑀯𑁂𑀤𑀬𑀺𑀲𑁆𑀲𑀁;

𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀢𑁄 𑀅𑀳𑁄𑀲𑀺𑀁, 𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀺𑀲𑁆𑀲𑀁;

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 ¶ 𑀦𑁄 𑀘 𑀫𑀼𑀲𑀸 𑀅𑀪𑀸𑀡𑀺𑀁, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀅𑀳𑁄𑀲𑀺 𑀢𑀼𑀝𑁆𑀞𑁄.

‘‘𑀢𑀁 ¶ 𑀫𑁂 𑀯𑀢𑀁 𑀢𑀁 𑀧𑀦 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, 𑀢𑀲𑁆𑀲 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄;

𑀢𑁂𑀳𑁂𑀯 𑀓𑀫𑁆𑀫𑁂𑀳𑀺 𑀅𑀧𑀸𑀧𑀓𑁂𑀳𑀺, 𑀧𑀼𑀜𑁆𑀜𑁂𑀳𑀺 𑀫𑁂 𑀮𑀤𑁆𑀥𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦’’𑀦𑁆𑀢𑀺.

‘‘𑀲𑀘𑁆𑀘𑀁 ¶ 𑀓𑀺𑀭𑀸𑀳𑀁𑀲𑀼 𑀦𑀭𑀸 𑀲𑀧𑀜𑁆𑀜𑀸, 𑀅𑀦𑀜𑁆𑀜𑀣𑀸 𑀯𑀘𑀦𑀁 𑀧𑀡𑁆𑀟𑀺𑀢𑀸𑀦𑀁;

𑀬𑀳𑀺𑀁 𑀬𑀳𑀺𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀧𑀼𑀜𑁆𑀜𑀓𑀫𑁆𑀫𑁄, 𑀢𑀳𑀺𑀁 𑀢𑀳𑀺𑀁 𑀫𑁄𑀤𑀢𑀺 𑀓𑀸𑀫𑀓𑀸𑀫𑀻.

‘‘𑀬𑀳𑀺𑀁 𑀬𑀳𑀺𑀁 𑀲𑁄𑀓𑀧𑀭𑀺𑀤𑁆𑀤𑀯𑁄 𑀘, 𑀯𑀥𑁄 𑀘 𑀩𑀦𑁆𑀥𑁄 𑀘 𑀧𑀭𑀺𑀓𑁆𑀓𑀺𑀮𑁂𑀲𑁄;

𑀢𑀳𑀺𑀁 𑀢𑀳𑀺𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑁄, 𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀬𑀸 𑀓𑀤𑀸𑀘𑀻’’𑀢𑀺.

‘‘𑀲𑀫𑁆𑀫𑀽𑀴𑁆𑀳𑀭𑀽𑀧𑁄𑀯 𑀚𑀦𑁄 𑀅𑀳𑁄𑀲𑀺, 𑀅𑀲𑁆𑀫𑀺𑀁 𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑁂 𑀓𑀮𑀮𑀻𑀓𑀢𑁄𑀯;

𑀚𑀦𑀲𑁆𑀲𑀺𑀫𑀲𑁆𑀲 𑀢𑀼𑀬𑁆𑀳𑀜𑁆𑀘 𑀓𑀼𑀫𑀸𑀭, 𑀅𑀧𑁆𑀧𑀘𑁆𑀘𑀬𑁄 𑀓𑁂𑀦 𑀦𑀼 𑀔𑁄 𑀅𑀳𑁄𑀲𑀻’’𑀢𑀺.

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

𑀢𑁂 𑀲𑀫𑁆𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺 𑀇𑀫𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀤𑀺𑀯𑀸 ¶ 𑀘 𑀭𑀢𑁆𑀢𑁄 𑀘 𑀢𑀫𑀁 𑀦𑀺𑀳𑀦𑁆𑀢𑁆𑀯𑀸.

‘‘𑀇𑀫𑁂𑀲𑀜𑁆𑀘 ¶ 𑀔𑁄 𑀯𑀲𑁆𑀲𑀲𑀢𑀘𑁆𑀘𑀬𑁂𑀦, 𑀲𑀺𑀧𑀸𑀝𑀺𑀓𑀸 𑀨𑀮𑀢𑀺 𑀏𑀓𑀫𑁂𑀓𑀸;

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

‘‘𑀤𑀺𑀲𑁆𑀯𑀸𑀦𑀳𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀸𑀦𑀺 𑀧𑀜𑁆𑀘, 𑀅𑀲𑁆𑀫𑀺𑀁 𑀯𑀺𑀫𑀸𑀦𑁂 𑀞𑀢𑁆𑀯𑀸𑀦 𑀢𑀸𑀢𑀸;

𑀆𑀬𑀼𑀓𑁆𑀔𑀬𑀸 𑀧𑀼𑀜𑁆𑀜𑀓𑁆𑀔𑀬𑀸 𑀘𑀯𑀺𑀲𑁆𑀲𑀁, 𑀢𑁂𑀦𑁂𑀯 𑀲𑁄𑀓𑁂𑀦 𑀧𑀫𑀼𑀘𑁆𑀙𑀺𑀢𑁄𑀲𑁆𑀫𑀻’’𑀢𑀺 [𑀲𑀫𑀼𑀘𑁆𑀙𑀺𑀢𑁄𑀲𑁆𑀫𑀻𑀢𑀺 (𑀧𑀻. 𑀓.)].

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

𑀬𑁂 𑀘𑀸𑀧𑀺 𑀔𑁄 𑀇𑀢𑁆𑀢𑀭𑀫𑀼𑀧𑀧𑀦𑁆𑀦𑀸, 𑀢𑁂 𑀦𑀽𑀦 𑀲𑁄𑀘𑁂𑀬𑁆𑀬𑀼𑀁 𑀧𑀭𑀺𑀢𑁆𑀢𑀧𑀼𑀜𑁆𑀜𑀸’’𑀢𑀺.

‘‘𑀅𑀦𑀼𑀘𑁆𑀙𑀯𑀺𑀁 𑀑𑀯𑀤𑀺𑀬𑀜𑁆𑀘 𑀫𑁂 𑀢𑀁, 𑀬𑀁 𑀫𑀁 𑀢𑀼𑀫𑁆𑀳𑁂 𑀧𑁂𑀬𑁆𑀬𑀯𑀸𑀘𑀁 𑀯𑀤𑁂𑀣;

𑀢𑀼𑀫𑁆𑀳𑁂 𑀘 𑀔𑁄 𑀢𑀸𑀢𑀸 𑀫𑀬𑀸𑀦𑀼𑀕𑀼𑀢𑁆𑀢𑀸, 𑀬𑁂𑀦𑀺𑀘𑁆𑀙𑀓𑀁 𑀢𑁂𑀦 𑀧𑀮𑁂𑀣 𑀲𑁄𑀢𑁆𑀣𑀺’’𑀦𑁆𑀢𑀺.

‘‘𑀕𑀦𑁆𑀢𑁆𑀯𑀸 ¶ 𑀫𑀬𑀁 𑀲𑀺𑀦𑁆𑀥𑀼𑀲𑁄𑀯𑀻𑀭𑀪𑀽𑀫𑀺𑀁, 𑀥𑀦𑀢𑁆𑀣𑀺𑀓𑀸 𑀉𑀤𑁆𑀤𑀬𑀁 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑀸;

𑀬𑀣𑀸𑀧𑀬𑁄𑀕𑀸 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀘𑀸𑀕𑀸, 𑀓𑀸𑀳𑀸𑀫 ¶ 𑀲𑁂𑀭𑀻𑀲𑀫𑀳𑀁 𑀉𑀴𑀸𑀭’’𑀦𑁆𑀢𑀺.

‘‘𑀫𑀸 𑀘𑁂𑀯 𑀲𑁂𑀭𑀻𑀲𑀫𑀳𑀁 𑀅𑀓𑀢𑁆𑀣, 𑀲𑀩𑁆𑀩𑀜𑁆𑀘 𑀯𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺 𑀬𑀁 𑀯𑀤𑁂𑀣;

𑀧𑀸𑀧𑀸𑀦𑀺 𑀓𑀫𑁆𑀫𑀸𑀦𑀺 𑀯𑀺𑀯𑀚𑁆𑀚𑀬𑀸𑀣, 𑀥𑀫𑁆𑀫𑀸𑀦𑀼𑀬𑁄𑀕𑀜𑁆𑀘 𑀅𑀥𑀺𑀝𑁆𑀞𑀳𑀸𑀣.

‘‘𑀉𑀧𑀸𑀲𑀓𑁄 𑀅𑀢𑁆𑀣𑀺 𑀇𑀫𑀫𑁆𑀳𑀺 𑀲𑀗𑁆𑀖𑁂, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁄 𑀲𑀻𑀮𑀯𑀢𑀽𑀧𑀧𑀦𑁆𑀦𑁄;

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

‘‘𑀲𑀜𑁆𑀚𑀸𑀦𑀫𑀸𑀦𑁄 ¶ 𑀦 𑀫𑀼𑀲𑀸 𑀪𑀡𑁂𑀬𑁆𑀬, 𑀧𑀭𑀽𑀧𑀖𑀸𑀢𑀸𑀬 𑀦 𑀘𑁂𑀢𑀬𑁂𑀬𑁆𑀬;

𑀯𑁂𑀪𑀽𑀢𑀺𑀓𑀁 𑀧𑁂𑀲𑀼𑀡𑀁 𑀦𑁄 𑀓𑀭𑁂𑀬𑁆𑀬, 𑀲𑀡𑁆𑀳𑀜𑁆𑀘 𑀯𑀸𑀘𑀁 𑀲𑀔𑀺𑀮𑀁 𑀪𑀡𑁂𑀬𑁆𑀬.

‘‘𑀲𑀕𑀸𑀭𑀯𑁄 𑀲𑀧𑁆𑀧𑀝𑀺𑀲𑁆𑀲𑁄 𑀯𑀺𑀦𑀻𑀢𑁄, 𑀅𑀧𑀸𑀧𑀓𑁄 𑀅𑀥𑀺𑀲𑀻𑀮𑁂 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑁄;

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

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

𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽𑀦𑀜𑁆𑀘 𑀬𑁄 [𑀲𑁄 (?)] 𑀅𑀘𑁆𑀘𑀬𑁂𑀦, 𑀦𑁂𑀓𑁆𑀔𑀫𑁆𑀫𑀧𑁄𑀡𑁄 ¶ 𑀘𑀭𑀺𑀲𑁆𑀲𑀢𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁.

‘‘𑀉𑀚𑀽 𑀅𑀯𑀗𑁆𑀓𑁄 𑀅𑀲𑀞𑁄 𑀅𑀫𑀸𑀬𑁄, 𑀦 𑀮𑁂𑀲𑀓𑀧𑁆𑀧𑁂𑀦 𑀘 𑀯𑁄𑀳𑀭𑁂𑀬𑁆𑀬;

𑀲𑁄 𑀢𑀸𑀤𑀺𑀲𑁄 𑀲𑀼𑀓𑀢𑀓𑀫𑁆𑀫𑀓𑀸𑀭𑀻, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀓𑀺𑀦𑁆𑀢𑀺 𑀮𑀪𑁂𑀣 𑀤𑀼𑀓𑁆𑀔𑀁.

‘‘𑀢𑀁 ¶ 𑀓𑀸𑀭𑀡𑀸 𑀧𑀸𑀢𑀼𑀓𑀢𑁄𑀫𑁆𑀳𑀺 𑀅𑀢𑁆𑀢𑀦𑀸, 𑀢𑀲𑁆𑀫𑀸 𑀥𑀫𑁆𑀫𑀁 𑀧𑀲𑁆𑀲𑀣 𑀯𑀸𑀡𑀺𑀚𑀸𑀲𑁂;

𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀢𑁂𑀦𑀺𑀳 𑀪𑀲𑁆𑀫𑀻 [𑀪𑀲𑁆𑀫𑀺 (𑀲𑁆𑀬𑀸.), 𑀪𑀲𑁆𑀫 (𑀓.)] 𑀪𑀯𑁂𑀣, 𑀅𑀦𑁆𑀥𑀸𑀓𑀼𑀮𑀸 𑀯𑀺𑀧𑁆𑀧𑀦𑀝𑁆𑀞𑀸 𑀅𑀭𑀜𑁆𑀜𑁂;

𑀢𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑀸𑀦𑁂𑀦 𑀮𑀳𑀼𑀁 𑀧𑀭𑁂𑀦, 𑀲𑀼𑀔𑁄 𑀳𑀯𑁂 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑁂𑀦 𑀲𑀗𑁆𑀕𑀫𑁄’’𑀢𑀺.

‘‘𑀓𑀺𑀁 𑀦𑀸𑀫 𑀲𑁄 𑀓𑀺𑀜𑁆𑀘 𑀓𑀭𑁄𑀢𑀺 𑀓𑀫𑁆𑀫𑀁,

𑀓𑀺𑀁 𑀦𑀸𑀫𑀥𑁂𑀬𑁆𑀬𑀁 𑀓𑀺𑀁 𑀧𑀦 𑀢𑀲𑁆𑀲 𑀕𑁄𑀢𑁆𑀢𑀁;

𑀫𑀬𑀫𑁆𑀧𑀺 𑀦𑀁 𑀤𑀝𑁆𑀞𑀼𑀓𑀸𑀫𑀫𑁆𑀳 𑀬𑀓𑁆𑀔, 𑀬𑀲𑁆𑀲𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀸𑀬 𑀇𑀥𑀸𑀕𑀢𑁄𑀲𑀺;

𑀮𑀸𑀪𑀸 𑀳𑀺 𑀢𑀲𑁆𑀲, 𑀬𑀲𑁆𑀲 𑀢𑀼𑀯𑀁 𑀧𑀺𑀳𑁂𑀲𑀻’’𑀢𑀺.

‘‘𑀬𑁄 ¶ ¶ 𑀓𑀧𑁆𑀧𑀓𑁄 𑀲𑀫𑁆𑀪𑀯𑀦𑀸𑀫𑀥𑁂𑀬𑁆𑀬𑁄,

𑀚𑀸𑀦𑀸𑀣 𑀦𑀁 𑀢𑀼𑀫𑁆𑀳𑀸𑀓𑀁 𑀧𑁂𑀲𑀺𑀬𑁄 𑀲𑁄,

𑀫𑀸 ¶ 𑀔𑁄 𑀦𑀁 𑀳𑀻𑀴𑀺𑀢𑁆𑀣 𑀲𑀼𑀧𑁂𑀲𑀮𑁄 𑀲𑁄’’𑀢𑀺.

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

𑀫𑀬𑀫𑁆𑀧𑀺 𑀦𑀁 𑀧𑀽𑀚𑀬𑀺𑀲𑁆𑀲𑀸𑀫 𑀬𑀓𑁆𑀔,

𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀘𑀦𑀁 𑀉𑀴𑀸𑀭’’𑀦𑁆𑀢𑀺.

‘‘𑀬𑁂 𑀓𑁂𑀘𑀺 𑀇𑀫𑀲𑁆𑀫𑀺𑀁 𑀲𑀢𑁆𑀣𑁂 𑀫𑀦𑀼𑀲𑁆𑀲𑀸,

𑀤𑀳𑀭𑀸 𑀫𑀳𑀦𑁆𑀢𑀸 𑀅𑀣𑀯𑀸𑀧𑀺 𑀫𑀚𑁆𑀛𑀺𑀫𑀸;

𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀆𑀮𑀫𑁆𑀩𑀦𑁆𑀢𑀼 𑀯𑀺𑀫𑀸𑀦𑀁,

𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀼 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀁 𑀨𑀮𑀁 𑀓𑀤𑀭𑀺𑀬𑀸’’𑀢𑀺.

𑀢𑁂 𑀢𑀢𑁆𑀣 𑀲𑀩𑁆𑀩𑁂𑀯 ‘𑀅𑀳𑀁 𑀧𑀼𑀭𑁂’𑀢𑀺,

𑀢𑀁 𑀓𑀧𑁆𑀧𑀓𑀁 𑀢𑀢𑁆𑀣 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁆𑀯𑀸 [𑀧𑀼𑀭𑀓𑁆𑀔𑀺𑀧𑀺𑀢𑁆𑀯𑀸 (𑀲𑀻.)];

𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀆𑀮𑀫𑁆𑀩𑀺𑀁𑀲𑀼 𑀯𑀺𑀫𑀸𑀦𑀁,

𑀢𑁂 ¶ 𑀢𑀢𑁆𑀣 𑀲𑀩𑁆𑀩𑁂𑀯 ‘𑀅𑀳𑀁 𑀧𑀼𑀭𑁂’𑀢𑀺, 𑀉𑀧𑀸𑀲𑀓𑀢𑁆𑀢𑀁 𑀧𑀝𑀺𑀯𑁂𑀤𑀬𑀺𑀁𑀲𑀼;

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

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

𑀢𑁂 𑀢𑀢𑁆𑀣 𑀲𑀩𑁆𑀩𑁂𑀯 ‘𑀅𑀳𑀁 𑀧𑀼𑀭𑁂’𑀢𑀺, 𑀉𑀧𑀸𑀲𑀓𑀢𑁆𑀢𑀁 𑀧𑀝𑀺𑀯𑁂𑀤𑀬𑀺𑀢𑁆𑀯𑀸;

𑀧𑀓𑁆𑀓𑀸𑀫𑀺 𑀲𑀢𑁆𑀣𑁄 𑀅𑀦𑀼𑀫𑁄𑀤𑀫𑀸𑀦𑁄, 𑀬𑀓𑁆𑀔𑀺𑀤𑁆𑀥𑀺𑀬𑀸 𑀅𑀦𑀼𑀫𑀢𑁄 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁.

‘‘𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 ¶ 𑀢𑁂 𑀲𑀺𑀦𑁆𑀥𑀼𑀲𑁄𑀯𑀻𑀭𑀪𑀽𑀫𑀺𑀁, 𑀥𑀦𑀢𑁆𑀣𑀺𑀓𑀸 𑀉𑀤𑁆𑀤𑀬𑀁 [𑀉𑀤𑀬 (𑀧𑀻. 𑀓.)] 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑀸;

𑀬𑀣𑀸𑀧𑀬𑁄𑀕𑀸 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀮𑀸𑀪𑀸, 𑀧𑀘𑁆𑀘𑀸𑀕𑀫𑀼𑀁 𑀧𑀸𑀝𑀮𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑀓𑁆𑀔𑀢𑀁.

‘‘𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 ¶ 𑀢𑁂 𑀲𑀗𑁆𑀖𑀭𑀁 𑀲𑁄𑀢𑁆𑀣𑀺𑀯𑀦𑁆𑀢𑁄,

𑀧𑀼𑀢𑁆𑀢𑁂𑀳𑀺 𑀤𑀸𑀭𑁂𑀳𑀺 𑀲𑀫𑀗𑁆𑀕𑀺𑀪𑀽𑀢𑀸;

𑀆𑀦𑀦𑁆𑀤𑀻 𑀯𑀺𑀢𑁆𑀢𑀸 [𑀆𑀦𑀦𑁆𑀤𑀘𑀺𑀢𑁆𑀢𑀸 (𑀲𑁆𑀬𑀸.), 𑀆𑀦𑀦𑁆𑀤𑀻𑀘𑀺𑀢𑁆𑀢𑀸 (𑀓.)] 𑀲𑀼𑀫𑀦𑀸 𑀧𑀢𑀻𑀢𑀸,

𑀲𑁂𑀭𑀻𑀲𑀓𑀁 𑀢𑁂 𑀧𑀭𑀺𑀯𑁂𑀡𑀁 𑀫𑀸𑀧𑀬𑀺𑀁𑀲𑀼.

𑀏𑀢𑀸𑀤𑀺𑀲𑀸 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀸𑀦 𑀲𑁂𑀯𑀦𑀸,

𑀫𑀳𑀢𑁆𑀣𑀺𑀓𑀸 𑀥𑀫𑁆𑀫𑀕𑀼𑀡𑀸𑀦 𑀲𑁂𑀯𑀦𑀸;

𑀲𑀩𑁆𑀩𑁂𑀯 𑀲𑀢𑁆𑀢𑀸 𑀲𑀼𑀔𑀺𑀢𑀸 [𑀲𑀼𑀔𑀺𑀦𑁄 (𑀧𑀻. 𑀓.)] 𑀅𑀳𑁂𑀲𑀼𑀦𑁆𑀢𑀺.

𑁧𑁧. 𑀲𑀼𑀦𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼

‘‘𑀉𑀘𑁆𑀘𑀫𑀺𑀤𑀁 ¶ 𑀫𑀡𑀺𑀣𑀽𑀡𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀫𑀦𑁆𑀢𑀢𑁄 𑀤𑁆𑀯𑀸𑀤𑀲 𑀬𑁄𑀚𑀦𑀸𑀦𑀺;

𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀸 ¶ 𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀉𑀴𑀸𑀭𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀭𑀼𑀘𑀓𑀢𑁆𑀣𑀢𑀸 𑀲𑀼𑀪𑀸.

‘‘𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀧𑀺𑀯𑀲𑀺 𑀔𑀸𑀤𑀲𑀺 𑀘, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀘 𑀯𑀻𑀡𑀸 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 𑀯𑀕𑁆𑀕𑀼𑀁;

‘‘𑀓𑁂𑀦 𑀢𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀓𑁂𑀦 𑀢𑁂 𑀇𑀥 𑀫𑀺𑀚𑁆𑀛𑀢𑀺;

𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀘 𑀢𑁂 𑀪𑁄𑀕𑀸, 𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀸.

‘‘𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 ¶ ‘𑀢𑀁 𑀤𑁂𑀯 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯, 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄 𑀓𑀺𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀜𑁆𑀜𑀁;

𑀓𑁂𑀦𑀸𑀲𑀺 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑁄 ¶ 𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁂𑀦 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄;

𑀧𑀜𑁆𑀳𑀁 𑀧𑀼𑀝𑁆𑀞𑁄 𑀯𑀺𑀬𑀸𑀓𑀸𑀲𑀺, 𑀬𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲𑀺𑀤𑀁 𑀨𑀮𑀁.

‘‘𑀤𑀼𑀦𑁆𑀦𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀁 𑀫𑀸𑀮𑀁 𑀲𑀼𑀦𑀺𑀓𑁆𑀔𑀺𑀧𑀺𑀢𑁆𑀯𑀸, 𑀧𑀢𑀺𑀝𑁆𑀞𑀧𑁂𑀢𑁆𑀯𑀸 𑀲𑀼𑀕𑀢𑀲𑁆𑀲 𑀣𑀽𑀧𑁂;

𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑁄 𑀘𑀫𑁆𑀳𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀤𑀺𑀩𑁆𑀩𑁂𑀳𑀺 𑀓𑀸𑀫𑁂𑀳𑀺 𑀲𑀫𑀗𑁆𑀕𑀺𑀪𑀽𑀢𑁄.

‘‘𑀅𑀓𑁆𑀔𑀸𑀫𑀺 𑀢𑁂 𑀪𑀺𑀓𑁆𑀔𑀼 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯,

𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄 𑀬𑀫𑀳𑀁 𑀅𑀓𑀸𑀲𑀺𑀁;

𑀢𑁂𑀦𑀫𑁆𑀳𑀺 ¶ 𑀏𑀯𑀁 𑀚𑀮𑀺𑀢𑀸𑀦𑀼𑀪𑀸𑀯𑁄,

𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀻’’𑀢𑀺.

𑀲𑀼𑀦𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀯𑀺𑀫𑀸𑀦𑀁 𑀏𑀓𑀸𑀤𑀲𑀫𑀁.

𑀲𑀼𑀦𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀯𑀕𑁆𑀕𑁄 𑀲𑀢𑁆𑀢𑀫𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑀤𑁆𑀯𑁂 𑀤𑀮𑀺𑀤𑁆𑀤𑀸 𑀯𑀦𑀯𑀺𑀳𑀸𑀭𑀸, 𑀪𑀢𑀓𑁄 𑀕𑁄𑀧𑀸𑀮𑀓𑀡𑁆𑀟𑀓𑀸;

𑀅𑀦𑁂𑀓𑀯𑀡𑁆𑀡𑀫𑀝𑁆𑀞𑀓𑀼𑀡𑁆𑀟𑀮𑀻, 𑀲𑁂𑀭𑀻𑀲𑀓𑁄 𑀲𑀼𑀦𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀁;

𑀧𑀼𑀭𑀺𑀲𑀸𑀦𑀁 𑀢𑀢𑀺𑀬𑁄 𑀯𑀕𑁆𑀕𑁄 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀻𑀢𑀺.

𑀪𑀸𑀡𑀯𑀸𑀭𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼𑀧𑀸𑀴𑀺 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.