📜

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

𑀔𑀼𑀤𑁆𑀤𑀓𑀦𑀺𑀓𑀸𑀬𑁂

𑀚𑀸𑀢𑀓𑀧𑀸𑀴𑀺

(𑀤𑀼𑀢𑀺𑀬𑁄 𑀪𑀸𑀕𑁄)

𑁧𑁭. 𑀘𑀢𑁆𑀢𑀸𑀮𑀻𑀲𑀦𑀺𑀧𑀸𑀢𑁄

𑁫𑁨𑁧. 𑀢𑁂𑀲𑀓𑀼𑀡𑀚𑀸𑀢𑀓𑀁 (𑁧)

𑁧.

‘‘𑀯𑁂𑀲𑁆𑀲𑀦𑁆𑀢𑀭𑀁 ¶ ¶ ¶ 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺, 𑀲𑀓𑀼𑀡 𑀪𑀤𑁆𑀤𑀫𑀢𑁆𑀣𑀼 𑀢𑁂;

𑀭𑀚𑁆𑀚𑀁 𑀓𑀸𑀭𑁂𑀢𑀼𑀓𑀸𑀫𑁂𑀦, 𑀓𑀺𑀁 𑀲𑀼 𑀓𑀺𑀘𑁆𑀘𑀁 𑀓𑀢𑀁 𑀯𑀭𑀁’’.

𑁨.

‘‘𑀘𑀺𑀭𑀲𑁆𑀲𑀁 𑀯𑀢 𑀫𑀁 𑀢𑀸𑀢𑁄, 𑀓𑀁𑀲𑁄 𑀩𑀸𑀭𑀸𑀡𑀲𑀺𑀕𑁆𑀕𑀳𑁄;

𑀧𑀫𑀢𑁆𑀢𑁄 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀁 𑀫𑀁, 𑀧𑀺𑀢𑀸 𑀧𑀼𑀢𑁆𑀢𑀁 𑀅𑀘𑁄𑀤𑀬𑀺.

𑁩.

‘‘𑀧𑀞𑀫𑁂𑀦𑁂𑀯 𑀯𑀺𑀢𑀣𑀁, 𑀓𑁄𑀥𑀁 𑀳𑀸𑀲𑀁 𑀦𑀺𑀯𑀸𑀭𑀬𑁂;

𑀢𑀢𑁄 𑀓𑀺𑀘𑁆𑀘𑀸𑀦𑀺 𑀓𑀸𑀭𑁂𑀬𑁆𑀬, 𑀢𑀁 𑀯𑀢𑀁 𑀆𑀳𑀼 𑀔𑀢𑁆𑀢𑀺𑀬.

𑁪.

‘‘𑀬𑀁 ¶ 𑀢𑁆𑀯𑀁 𑀢𑀸𑀢 𑀢𑀧𑁄𑀓𑀫𑁆𑀫𑀁 [𑀢𑀧𑁂 𑀓𑀫𑁆𑀫𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀧𑀼𑀩𑁆𑀩𑁂 𑀓𑀢𑀫𑀲𑀁𑀲𑀬𑀁;

𑀭𑀢𑁆𑀢𑁄 𑀤𑀼𑀝𑁆𑀞𑁄 𑀘 𑀬𑀁 𑀓𑀬𑀺𑀭𑀸, 𑀦 𑀢𑀁 𑀓𑀬𑀺𑀭𑀸 𑀢𑀢𑁄 𑀧𑀼𑀦 [𑀧𑀼𑀦𑀁 (𑀧𑀻.)].

𑁫.

‘‘𑀔𑀢𑁆𑀢𑀺𑀬𑀲𑁆𑀲 𑀧𑀫𑀢𑁆𑀢𑀲𑁆𑀲, 𑀭𑀝𑁆𑀞𑀲𑁆𑀫𑀺𑀁 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦;

𑀲𑀩𑁆𑀩𑁂 𑀪𑁄𑀕𑀸 𑀯𑀺𑀦𑀲𑁆𑀲𑀦𑁆𑀢𑀺, 𑀭𑀜𑁆𑀜𑁄 𑀢𑀁 𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀅𑀖𑀁.

𑁬.

‘‘𑀲𑀺𑀭𑀻 𑀢𑀸𑀢 𑀅𑀮𑀓𑁆𑀔𑀻 𑀘 [𑀲𑀺𑀭𑀻 𑀘 𑀢𑀸𑀢 𑀮𑀓𑁆𑀔𑀻 𑀘 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀼𑀁;

𑀉𑀝𑁆𑀞𑀸𑀦 [𑀉𑀝𑁆𑀞𑀸𑀦𑁂 (𑀲𑁆𑀬𑀸.)] 𑀯𑀻𑀭𑀺𑀬𑁂 𑀧𑁄𑀲𑁂, 𑀭𑀫𑀸𑀳𑀁 𑀅𑀦𑀼𑀲𑀽𑀬𑀓𑁂.

𑁭.

‘‘𑀉𑀲𑀽𑀬𑀓𑁂 ¶ 𑀤𑀼𑀳𑀤𑀬𑁂, 𑀧𑀼𑀭𑀺𑀲𑁂 𑀓𑀫𑁆𑀫𑀤𑀼𑀲𑁆𑀲𑀓𑁂;

𑀓𑀸𑀮𑀓𑀡𑁆𑀡𑀻 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀭𑀫𑀢𑀺 [𑀭𑀫𑀸𑀢𑀺 (𑀓.)] 𑀘𑀓𑁆𑀓𑀪𑀜𑁆𑀚𑀦𑀻.

𑁮.

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

𑀅𑀮𑀓𑁆𑀔𑀺𑀁 𑀦𑀼𑀤 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀮𑀓𑁆𑀔𑁆𑀬𑀸 𑀪𑀯 𑀦𑀺𑀯𑁂𑀲𑀦𑀁.

𑁯.

‘‘𑀲 ¶ 𑀮𑀓𑁆𑀔𑀻𑀥𑀺𑀢𑀺𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀧𑀼𑀭𑀺𑀲𑁄 𑀳𑀺 𑀫𑀳𑀕𑁆𑀕𑀢𑁄;

𑀅𑀫𑀺𑀢𑁆𑀢𑀸𑀦𑀁 𑀓𑀸𑀲𑀺𑀧𑀢𑀺, 𑀫𑀽𑀮𑀁 𑀅𑀕𑁆𑀕𑀜𑁆𑀘 𑀙𑀺𑀦𑁆𑀤𑀢𑀺.

𑁧𑁦.

‘‘𑀲𑀓𑁆𑀓𑁄𑀧𑀺 𑀳𑀺 𑀪𑀽𑀢𑀧𑀢𑀺, 𑀉𑀝𑁆𑀞𑀸𑀦𑁂 𑀦𑀧𑁆𑀧𑀫𑀚𑁆𑀚𑀢𑀺;

𑀲 𑀓𑀮𑁆𑀬𑀸𑀡𑁂 𑀥𑀺𑀢𑀺𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀉𑀝𑁆𑀞𑀸𑀦𑁂 𑀓𑀼𑀭𑀼𑀢𑁂 𑀫𑀦𑁄.

𑁧𑁧.

‘‘𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑀸 𑀧𑀺𑀢𑀭𑁄 𑀤𑁂𑀯𑀸, 𑀲𑀸𑀚𑀻𑀯𑀸 [𑀲𑀜𑁆𑀚𑀻𑀯𑀸 (𑀧𑀻.)] 𑀳𑁄𑀦𑁆𑀢𑀺 𑀢𑀸𑀤𑀺𑀦𑁄;

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

𑁧𑁨.

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

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

𑁧𑁩.

‘‘𑀢𑀢𑁆𑀣𑁂𑀯 𑀢𑁂 𑀯𑀢𑁆𑀢𑀧𑀤𑀸, 𑀏𑀲𑀸𑀯 [𑀏𑀲𑀸 𑀘 (𑀧𑀻.)] 𑀅𑀦𑀼𑀲𑀸𑀲𑀦𑀻;

𑀅𑀮𑀁 𑀫𑀺𑀢𑁆𑀢𑁂 𑀲𑀼𑀔𑀸𑀧𑁂𑀢𑀼𑀁, 𑀅𑀫𑀺𑀢𑁆𑀢𑀸𑀦𑀁 𑀤𑀼𑀔𑀸𑀬 [𑀤𑀼𑀓𑁆𑀔𑀸𑀬 (𑀧𑀻.)] 𑀘’’.

𑁧𑁪.

‘‘𑀲𑀓𑁆𑀔𑀺𑀲𑀺 𑀢𑁆𑀯𑀁 [𑀲𑀓𑁆𑀔𑀻 𑀢𑀼𑀯𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀓𑀼𑀡𑁆𑀟𑀮𑀺𑀦𑀺, 𑀫𑀜𑁆𑀜𑀲𑀺 𑀔𑀢𑁆𑀢𑀩𑀦𑁆𑀥𑀼𑀦𑀺 [𑀔𑀢𑁆𑀢𑀺𑀬𑀩𑀦𑁆𑀥𑀼𑀦𑀻 (𑀧𑀻.)];

𑀭𑀚𑁆𑀚𑀁 𑀓𑀸𑀭𑁂𑀢𑀼𑀓𑀸𑀫𑁂𑀦, 𑀓𑀺𑀁 𑀲𑀼 𑀓𑀺𑀘𑁆𑀘𑀁 𑀓𑀢𑀁 𑀯𑀭𑀁’’.

𑁧𑁫.

‘‘𑀤𑁆𑀯𑁂𑀯 𑀢𑀸𑀢 𑀧𑀤𑀓𑀸𑀦𑀺, 𑀬𑀢𑁆𑀣 [𑀬𑁂𑀲𑀼 (𑀧𑀻.)] 𑀲𑀩𑁆𑀩𑀁 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀁;

𑀅𑀮𑀤𑁆𑀥𑀲𑁆𑀲 𑀘 𑀬𑁄 𑀮𑀸𑀪𑁄, 𑀮𑀤𑁆𑀥𑀲𑁆𑀲 𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀡𑀸.

𑁧𑁬.

‘‘𑀅𑀫𑀘𑁆𑀘𑁂 𑀢𑀸𑀢 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀥𑀻𑀭𑁂 𑀅𑀢𑁆𑀣𑀲𑁆𑀲 𑀓𑁄𑀯𑀺𑀤𑁂;

𑀅𑀦𑀓𑁆𑀔𑀸 𑀓𑀺𑀢𑀯𑁂 𑀢𑀸𑀢, 𑀅𑀲𑁄𑀡𑁆𑀟𑁂 𑀅𑀯𑀺𑀦𑀸𑀲𑀓𑁂.

𑁧𑁭.

‘‘𑀬𑁄 𑀘 𑀢𑀁 𑀢𑀸𑀢 𑀭𑀓𑁆𑀔𑁂𑀬𑁆𑀬, 𑀥𑀦𑀁 𑀬𑀜𑁆𑀘𑁂𑀯 𑀢𑁂 𑀲𑀺𑀬𑀸;

𑀲𑀽𑀢𑁄𑀯 𑀭𑀣𑀁 𑀲𑀗𑁆𑀕𑀡𑁆𑀳𑁂, 𑀲𑁄 𑀢𑁂 𑀓𑀺𑀘𑁆𑀘𑀸𑀦𑀺 𑀓𑀸𑀭𑀬𑁂.

𑁧𑁮.

‘‘𑀲𑀼𑀲𑀗𑁆𑀕𑀳𑀺𑀢𑀦𑁆𑀢𑀚𑀦𑁄, 𑀲𑀬𑀁 𑀯𑀺𑀢𑁆𑀢𑀁 𑀅𑀯𑁂𑀓𑁆𑀔𑀺𑀬;

𑀦𑀺𑀥𑀺𑀜𑁆𑀘 𑀇𑀡𑀤𑀸𑀦𑀜𑁆𑀘, 𑀦 𑀓𑀭𑁂 𑀧𑀭𑀧𑀢𑁆𑀢𑀺𑀬𑀸.

𑁧𑁯.

‘‘𑀲𑀬𑀁 ¶ ¶ 𑀆𑀬𑀁 ¶ 𑀯𑀬𑀁 [𑀆𑀬𑀯𑀬𑀁 (𑀧𑀻.)] 𑀚𑀜𑁆𑀜𑀸, 𑀲𑀬𑀁 𑀚𑀜𑁆𑀜𑀸 𑀓𑀢𑀸𑀓𑀢𑀁;

𑀦𑀺𑀕𑁆𑀕𑀡𑁆𑀳𑁂 𑀦𑀺𑀕𑁆𑀕𑀳𑀸𑀭𑀳𑀁, 𑀧𑀕𑁆𑀕𑀡𑁆𑀳𑁂 𑀧𑀕𑁆𑀕𑀳𑀸𑀭𑀳𑀁.

𑁨𑁦.

‘‘𑀲𑀬𑀁 𑀚𑀸𑀦𑀧𑀤𑀁 𑀅𑀢𑁆𑀣𑀁, 𑀅𑀦𑀼𑀲𑀸𑀲 𑀭𑀣𑁂𑀲𑀪;

𑀫𑀸 𑀢𑁂 𑀅𑀥𑀫𑁆𑀫𑀺𑀓𑀸 𑀬𑀼𑀢𑁆𑀢𑀸, 𑀥𑀦𑀁 𑀭𑀝𑁆𑀞𑀜𑁆𑀘 𑀦𑀸𑀲𑀬𑀼𑀁.

𑁨𑁧.

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

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

𑁨𑁨.

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

𑀓𑁄𑀥𑀲𑀸 𑀳𑀺 𑀩𑀳𑀽 𑀨𑀻𑀢𑀸, 𑀓𑀼𑀮𑀸 𑀅𑀓𑀼𑀮𑀢𑀁 𑀕𑀢𑀸.

𑁨𑁩.

‘‘𑀫𑀸 𑀢𑀸𑀢 𑀇𑀲𑁆𑀲𑀭𑁄𑀫𑁆𑀳𑀻𑀢𑀺, 𑀅𑀦𑀢𑁆𑀣𑀸𑀬 𑀧𑀢𑀸𑀭𑀬𑀺;

𑀇𑀢𑁆𑀣𑀻𑀦𑀁 𑀧𑀼𑀭𑀺𑀲𑀸𑀦𑀜𑁆𑀘, 𑀫𑀸 𑀢𑁂 𑀆𑀲𑀺 𑀤𑀼𑀔𑀼𑀤𑁆𑀭𑀬𑁄.

𑁨𑁪.

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

𑀲𑀩𑁆𑀩𑁂 𑀪𑁄𑀕𑀸 𑀯𑀺𑀦𑀲𑁆𑀲𑀦𑁆𑀢𑀺, 𑀭𑀜𑁆𑀜𑁄 𑀢𑀁 𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀅𑀖𑀁.

𑁨𑁫.

‘‘𑀢𑀢𑁆𑀣𑁂𑀯 𑀢𑁂 𑀯𑀢𑁆𑀢𑀧𑀤𑀸, 𑀏𑀲𑀸𑀯 𑀅𑀦𑀼𑀲𑀸𑀲𑀦𑀻;

𑀤𑀓𑁆𑀔𑀲𑁆𑀲𑀼𑀤𑀸𑀦𑀺 𑀧𑀼𑀜𑁆𑀜𑀓𑀭𑁄, 𑀅𑀲𑁄𑀡𑁆𑀟𑁄 𑀅𑀯𑀺𑀦𑀸𑀲𑀓𑁄;

𑀲𑀻𑀮𑀯𑀸𑀲𑁆𑀲𑀼 [𑀲𑀻𑀮𑀯𑀸𑀲𑁆𑀲 (𑀝𑀻𑀓𑀸)] 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑁄 𑀯𑀺𑀦𑀺𑀧𑀸𑀢𑀺𑀓𑁄’’ [𑀯𑀺𑀦𑀺𑀧𑀸𑀢𑀓𑁄 (𑀧𑀻.)].

𑁨𑁬.

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

𑀢𑁆𑀯𑀁 𑀤𑀸𑀦𑀺 𑀯𑀤𑁂𑀳𑀺 𑀚𑀫𑁆𑀩𑀼𑀓 [𑀚𑀫𑁆𑀩𑀼𑀓 𑀢𑁆𑀯𑀁 𑀤𑀸𑀦𑀺 𑀯𑀤𑁂𑀳𑀺 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀩𑀮𑀸𑀦𑀁 𑀩𑀮𑀫𑀼𑀢𑁆𑀢𑀫𑀁’’.

𑁨𑁭.

‘‘𑀩𑀮𑀁 𑀧𑀜𑁆𑀘𑀯𑀺𑀥𑀁 𑀮𑁄𑀓𑁂, 𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀫𑀺𑀁 𑀫𑀳𑀕𑁆𑀕𑀢𑁂;

𑀢𑀢𑁆𑀣 𑀩𑀸𑀳𑀼𑀩𑀮𑀁 𑀦𑀸𑀫, 𑀘𑀭𑀺𑀫𑀁 𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀩𑀮𑀁.

𑁨𑁮.

‘‘𑀪𑁄𑀕𑀩𑀮𑀜𑁆𑀘 𑀤𑀻𑀖𑀸𑀯𑀼, 𑀤𑀼𑀢𑀺𑀬𑀁 𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀩𑀮𑀁;

𑀅𑀫𑀘𑁆𑀘𑀩𑀮𑀜𑁆𑀘 ¶ 𑀤𑀻𑀖𑀸𑀯𑀼, 𑀢𑀢𑀺𑀬𑀁 𑀯𑀼𑀘𑁆𑀘𑀢𑁂 𑀩𑀮𑀁.

𑁨𑁯.

‘‘𑀅𑀪𑀺𑀚𑀘𑁆𑀘𑀩𑀮𑀁 𑀘𑁂𑀯, 𑀢𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀅𑀲𑀁𑀲𑀬𑀁;

𑀬𑀸𑀦𑀺 𑀘𑁂𑀢𑀸𑀦𑀺 𑀲𑀩𑁆𑀩𑀸𑀦𑀺, 𑀅𑀥𑀺𑀕𑀡𑁆𑀳𑀸𑀢𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑁄.

𑁩𑁦.

‘‘𑀢𑀁 𑀩𑀮𑀸𑀦𑀁 𑀩𑀮𑀁 𑀲𑁂𑀝𑁆𑀞𑀁, 𑀅𑀕𑁆𑀕𑀁 𑀧𑀜𑁆𑀜𑀸𑀩𑀁 𑀩𑀮𑀁 [𑀯𑀭𑀁 (𑀲𑀻.)];

𑀧𑀜𑁆𑀜𑀸𑀩𑀮𑁂𑀦𑀼𑀧𑀢𑁆𑀣𑀤𑁆𑀥𑁄, 𑀅𑀢𑁆𑀣𑀁 𑀯𑀺𑀦𑁆𑀤𑀢𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑁄.

𑁩𑁧.

‘‘𑀅𑀧𑀺 ¶ 𑀘𑁂 𑀮𑀪𑀢𑀺 𑀫𑀦𑁆𑀤𑁄, 𑀨𑀻𑀢𑀁 𑀥𑀭𑀡𑀺𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀅𑀓𑀸𑀫𑀲𑁆𑀲 𑀧𑀲𑀬𑁆𑀳𑀁 𑀯𑀸, 𑀅𑀜𑁆𑀜𑁄 𑀢𑀁 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑀢𑀺.

𑁩𑁨.

‘‘𑀅𑀪𑀺𑀚𑀸𑀢𑁄𑀧𑀺 𑀘𑁂 𑀳𑁄𑀢𑀺, 𑀭𑀚𑁆𑀚𑀁 𑀮𑀤𑁆𑀥𑀸𑀦 𑀔𑀢𑁆𑀢𑀺𑀬𑁄;

𑀤𑀼𑀧𑁆𑀧𑀜𑁆𑀜𑁄 𑀳𑀺 𑀓𑀸𑀲𑀺𑀧𑀢𑀺, 𑀲𑀩𑁆𑀩𑁂𑀦𑀧𑀺 𑀦 𑀚𑀻𑀯𑀢𑀺.

𑁩𑁩.

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

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

𑁩𑁪.

‘‘𑀧𑀜𑁆𑀜𑀜𑁆𑀘 𑀔𑁄 𑀅𑀲𑀼𑀲𑁆𑀲𑀽𑀲𑀁, 𑀦 𑀓𑁄𑀘𑀺 𑀅𑀥𑀺𑀕𑀘𑁆𑀙𑀢𑀺;

𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑀁 𑀅𑀦𑀸𑀕𑀫𑁆𑀫, 𑀥𑀫𑁆𑀫𑀝𑁆𑀞𑀁 𑀅𑀯𑀺𑀦𑀺𑀩𑁆𑀪𑀼𑀚𑀁.

𑁩𑁫.

‘‘𑀬𑁄 𑀘 𑀥𑀫𑁆𑀫𑀯𑀺𑀪𑀗𑁆𑀕𑀜𑁆𑀜𑀽 [𑀬𑁄 𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀯𑀺𑀪𑀸𑀕𑀜𑁆𑀜𑀽 (𑀧𑀻.)], 𑀓𑀸𑀮𑀼𑀝𑁆𑀞𑀸𑀬𑀻 𑀫𑀢𑀦𑁆𑀤𑀺𑀢𑁄;

𑀅𑀦𑀼𑀝𑁆𑀞𑀳𑀢𑀺 𑀓𑀸𑀮𑁂𑀦, 𑀓𑀫𑁆𑀫𑀨𑀮𑀁 𑀢𑀲𑁆𑀲 𑀇𑀚𑁆𑀛𑀢𑀺 [𑀓𑀫𑁆𑀫𑀨𑀮𑀁 𑀢𑀲𑁆𑀲𑀺𑀚𑁆𑀛𑀢𑀺, 𑀨𑀮𑀁 𑀢𑀲𑁆𑀲 𑀲𑀫𑀺𑀚𑁆𑀛𑀢𑀺 (𑀓.)].

𑁩𑁬.

‘‘𑀅𑀦𑀸𑀬𑀢𑀦 [𑀦𑀸’𑀦𑀸𑀬𑀢𑀦 (𑀧𑀻.)] 𑀲𑀻𑀮𑀲𑁆𑀲, 𑀅𑀦𑀸𑀬𑀢𑀦 [𑀦𑀸’𑀦𑀸𑀬𑀢𑀦 (𑀧𑀻.)] 𑀲𑁂𑀯𑀺𑀦𑁄;

𑀦 𑀦𑀺𑀩𑁆𑀩𑀺𑀦𑁆𑀤𑀺𑀬𑀓𑀸𑀭𑀺𑀲𑁆𑀲, 𑀲𑀫𑁆𑀫𑀤𑀢𑁆𑀣𑁄 𑀯𑀺𑀧𑀘𑁆𑀘𑀢𑀺.

𑁩𑁭.

‘‘𑀅𑀚𑁆𑀛𑀢𑁆𑀢𑀜𑁆𑀘 𑀧𑀬𑀼𑀢𑁆𑀢𑀲𑁆𑀲, 𑀢𑀣𑀸𑀬𑀢𑀦𑀲𑁂𑀯𑀺𑀦𑁄;

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

𑁩𑁮.

‘‘𑀬𑁄𑀕𑀧𑁆𑀧𑀬𑁄𑀕𑀲𑀗𑁆𑀔𑀸𑀢𑀁, 𑀲𑀫𑁆𑀪𑀢𑀲𑁆𑀲𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀡𑀁;

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

𑀅𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀳𑀺 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀦𑀴𑀸𑀕𑀸𑀭𑀁𑀯 𑀲𑀻𑀤𑀢𑀺’’.

𑁩𑁯.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽𑀲𑀼 𑀔𑀢𑁆𑀢𑀺𑀬;

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺.

𑁪𑁦.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑁂𑀲𑀼 𑀔𑀢𑁆𑀢𑀺𑀬;

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺.

𑁪𑁧.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀫𑀺𑀢𑁆𑀢𑀸𑀫𑀘𑁆𑀘𑁂𑀲𑀼 𑀔𑀢𑁆𑀢𑀺𑀬;

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺.

𑁪𑁨.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀯𑀸𑀳𑀦𑁂𑀲𑀼 𑀩𑀮𑁂𑀲𑀼 𑀘;

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺.

𑁪𑁩.

‘‘𑀥𑀫𑁆𑀫𑀁 ¶ 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀕𑀸𑀫𑁂𑀲𑀼 𑀦𑀺𑀕𑀫𑁂𑀲𑀼 𑀘…𑀧𑁂….

𑁪𑁪.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀭𑀝𑁆𑀞𑁂𑀲𑀼 [𑀭𑀝𑁆𑀞𑁂 (𑀧𑀻.)] 𑀚𑀦𑀧𑀤𑁂𑀲𑀼 𑀘…𑀧𑁂….

𑁪𑁫.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀲𑀫𑀡 [𑀲𑀫𑀡𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼 𑀘…𑀧𑁂….

𑁪𑁬.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀫𑀺𑀕𑀧𑀓𑁆𑀔𑀻𑀲𑀼 𑀔𑀢𑁆𑀢𑀺𑀬;

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺.

𑁪𑁭.

‘‘𑀥𑀫𑁆𑀫𑀁 ¶ 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀥𑀫𑁆𑀫𑁄 𑀘𑀺𑀡𑁆𑀡𑁄 𑀲𑀼𑀔𑀸𑀯𑀳𑁄 [𑀥𑀫𑁆𑀫𑁄 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑁄 𑀲𑀼𑀔𑀫𑀸𑀯𑀳𑀢𑀺 (𑀓.)];

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺.

𑁪𑁮.

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

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

𑁪𑁯.

‘‘𑀢𑀢𑁆𑀣𑁂𑀯 ¶ 𑀢𑁂 [𑀯𑁂𑀢𑁂 (𑀧𑀻.)] 𑀯𑀢𑁆𑀢𑀧𑀤𑀸, 𑀏𑀲𑀸𑀯 [𑀏𑀲𑀸 𑀘 (𑀧𑀻.)] 𑀅𑀦𑀼𑀲𑀸𑀲𑀦𑀻;

𑀲𑀧𑁆𑀧𑀜𑁆𑀜𑀲𑁂𑀯𑀻 𑀓𑀮𑁆𑀬𑀸𑀡𑀻, 𑀲𑀫𑀢𑁆𑀢𑀁 𑀲𑀸𑀫 [𑀲𑀸𑀫𑀁 (𑀓.)] 𑀢𑀁 𑀯𑀺𑀤𑀽’’𑀢𑀺.

𑀢𑁂𑀲𑀓𑀼𑀡𑀚𑀸𑀢𑀓𑀁 𑀧𑀞𑀫𑀁.

𑁫𑁨𑁨. 𑀲𑀭𑀪𑀗𑁆𑀕𑀚𑀸𑀢𑀓𑀁 (𑁨)

𑁫𑁦.

‘‘𑀅𑀮𑀗𑁆𑀓𑀢𑀸 𑀓𑀼𑀡𑁆𑀟𑀮𑀺𑀦𑁄 𑀲𑀼𑀯𑀢𑁆𑀣𑀸, 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀫𑀼𑀢𑁆𑀢𑀸𑀣𑀭𑀼𑀔𑀕𑁆𑀕𑀩𑀦𑁆𑀥𑀸 [𑀩𑀤𑁆𑀥𑀸 (𑀧𑀻.)];

𑀭𑀣𑁂𑀲𑀪𑀸 𑀢𑀺𑀝𑁆𑀞𑀣 𑀓𑁂 𑀦𑀼 𑀢𑀼𑀫𑁆𑀳𑁂, 𑀓𑀣𑀁 𑀯𑁄 𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂’’.

𑁫𑁧.

‘‘𑀅𑀳𑀫𑀝𑁆𑀞𑀓𑁄 𑀪𑀻𑀫𑀭𑀣𑁄 𑀧𑀦𑀸𑀬𑀁, 𑀓𑀸𑀮𑀺𑀗𑁆𑀕𑀭𑀸𑀚𑀸 𑀧𑀦 𑀉𑀕𑁆𑀕𑀢𑁄𑀬𑀁 [𑀉𑀕𑁆𑀕𑀢𑁄 𑀅𑀬𑀁 (𑀧𑀻.), 𑀉𑀕𑁆𑀕𑀢𑀸𑀬𑀁 (𑀓.)];

𑀲𑀼𑀲𑀜𑁆𑀜𑀢𑀸𑀦𑀁 𑀇𑀲𑀻𑀦𑀁 [𑀲𑀼𑀲𑀜𑁆𑀜𑀢𑀸𑀦𑀺𑀲𑀺𑀦𑀁 (𑀧𑀻.)] 𑀤𑀲𑁆𑀲𑀦𑀸𑀬, 𑀇𑀥𑀸𑀕𑀢𑀸 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀸𑀬𑁂𑀫𑁆𑀳 𑀧𑀜𑁆𑀳𑁂’’.

𑁫𑁨.

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

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀬𑀓𑁆𑀔 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯, 𑀓𑀣𑀁 𑀢𑀁 𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂’’.

𑁫𑁩.

‘‘𑀬𑀫𑀸𑀳𑀼 𑀤𑁂𑀯𑁂𑀲𑀼 𑀲𑀼𑀚𑀫𑁆𑀧𑀢𑀻𑀢𑀺, 𑀫𑀖𑀯𑀸𑀢𑀺 ¶ 𑀢𑀁 𑀆𑀳𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂;

𑀲 𑀤𑁂𑀯𑀭𑀸𑀚𑀸 𑀇𑀤𑀫𑀚𑁆𑀚 𑀧𑀢𑁆𑀢𑁄, 𑀲𑀼𑀲𑀜𑁆𑀜𑀢𑀸𑀦𑀁 𑀇𑀲𑀻𑀦𑀁 𑀤𑀲𑁆𑀲𑀦𑀸𑀬’’.

𑁫𑁪.

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

𑀯𑀦𑁆𑀤𑀸𑀫𑀺 𑀢𑁂 𑀅𑀬𑀺𑀭𑁂 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀬𑁂 𑀚𑀻𑀯𑀮𑁄𑀓𑁂𑀢𑁆𑀣 𑀫𑀦𑀼𑀲𑁆𑀲𑀲𑁂𑀝𑁆𑀞𑀸’’.

𑁫𑁫.

𑀕𑀦𑁆𑀥𑁄 𑀇𑀲𑀻𑀦𑀁 𑀘𑀺𑀭𑀤𑀺𑀓𑁆𑀔𑀺𑀢𑀸𑀦𑀁 [𑀤𑀓𑁆𑀔𑀺𑀢𑀸𑀦𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀓𑀸𑀬𑀸 𑀘𑀼𑀢𑁄 𑀕𑀘𑁆𑀙𑀢𑀺 𑀫𑀸𑀮𑀼𑀢𑁂𑀦;

𑀇𑀢𑁄 𑀧𑀝𑀺𑀓𑁆𑀓𑀫𑁆𑀫 𑀲𑀳𑀲𑁆𑀲𑀦𑁂𑀢𑁆𑀢, 𑀕𑀦𑁆𑀥𑁄 𑀇𑀲𑀻𑀦𑀁 𑀅𑀲𑀼𑀘𑀺 𑀤𑁂𑀯𑀭𑀸𑀚’’.

𑁫𑁬.

‘‘𑀕𑀦𑁆𑀥𑁄 𑀇𑀲𑀻𑀦𑀁 𑀘𑀺𑀭𑀤𑀺𑀓𑁆𑀔𑀺𑀢𑀸𑀦𑀁, 𑀓𑀸𑀬𑀸 𑀘𑀼𑀢𑁄 𑀕𑀘𑁆𑀙𑀢𑀼 𑀫𑀸𑀮𑀼𑀢𑁂𑀦;

𑀯𑀺𑀘𑀺𑀢𑁆𑀭𑀧𑀼𑀧𑁆𑀨𑀁 𑀲𑀼𑀭𑀪𑀺𑀁𑀯 𑀫𑀸𑀮𑀁, 𑀕𑀦𑁆𑀥𑀜𑁆𑀘 𑀏𑀢𑀁 𑀧𑀸𑀝𑀺𑀓𑀗𑁆𑀔𑀸𑀫 𑀪𑀦𑁆𑀢𑁂;

𑀦 𑀳𑁂𑀢𑁆𑀣 𑀤𑁂𑀯𑀸 𑀧𑀝𑀺𑀓𑁆𑀓𑀽𑀮𑀲𑀜𑁆𑀜𑀺𑀦𑁄’’.

𑁫𑁭.

‘‘𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄 𑀪𑀽𑀢𑀧𑀢𑀻 𑀬𑀲𑀲𑁆𑀲𑀻, 𑀤𑁂𑀯𑀸𑀦𑀫𑀺𑀦𑁆𑀤𑁄 𑀲𑀓𑁆𑀓𑁄 [𑀇𑀤𑀁 𑀧𑀤𑀁 𑀦𑀢𑁆𑀣𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼)] 𑀫𑀖𑀯𑀸 𑀲𑀼𑀚𑀫𑁆𑀧𑀢𑀺;

𑀲 𑀤𑁂𑀯𑀭𑀸𑀚𑀸 𑀅𑀲𑀼𑀭𑀕𑀡𑀧𑁆𑀧𑀫𑀤𑁆𑀤𑀦𑁄, 𑀑𑀓𑀸𑀲𑀫𑀸𑀓𑀗𑁆𑀔𑀢𑀺 𑀧𑀜𑁆𑀳 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀼𑀁.

𑁫𑁮.

‘‘𑀓𑁄 ¶ 𑀦𑁂𑀯𑀺𑀫𑁂𑀲𑀁 𑀇𑀥 𑀧𑀡𑁆𑀟𑀺𑀢𑀸𑀦𑀁, 𑀧𑀜𑁆𑀳𑁂 𑀧𑀼𑀝𑁆𑀞𑁄 𑀦𑀺𑀧𑀼𑀡𑁂 𑀩𑁆𑀬𑀸𑀓𑀭𑀺𑀲𑁆𑀲𑀢𑀺;

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

𑁫𑁯.

‘‘𑀅𑀬𑀁 ¶ 𑀇𑀲𑀺 [𑀇𑀲𑀻 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀭𑀪𑀗𑁆𑀕𑁄 𑀢𑀧𑀲𑁆𑀲𑀻 [𑀬𑀲𑀲𑁆𑀲𑀻 (𑀲𑀻.)], 𑀬𑀢𑁄 𑀚𑀸𑀢𑁄 𑀯𑀺𑀭𑀢𑁄 𑀫𑁂𑀣𑀼𑀦𑀲𑁆𑀫𑀸;

𑀆𑀘𑁂𑀭𑀧𑀼𑀢𑁆𑀢𑁄 [𑀆𑀘𑀭𑀺𑀬𑀧𑀼𑀢𑁆𑀢𑁄 (𑀧𑀻. 𑀓.)] 𑀲𑀼𑀯𑀺𑀦𑀻𑀢𑀭𑀽𑀧𑁄, 𑀲𑁄 𑀦𑁂𑀲𑀁 𑀧𑀜𑁆𑀳𑀸𑀦𑀺 𑀯𑀺𑀬𑀸𑀓𑀭𑀺𑀲𑁆𑀲𑀢𑀺’’.

𑁬𑁦.

‘‘𑀓𑁄𑀡𑁆𑀟𑀜𑁆𑀜 𑀧𑀜𑁆𑀳𑀸𑀦𑀺 𑀯𑀺𑀬𑀸𑀓𑀭𑁄𑀳𑀺, 𑀬𑀸𑀘𑀦𑁆𑀢𑀺 𑀢𑀁 𑀇𑀲𑀬𑁄 𑀲𑀸𑀥𑀼𑀭𑀽𑀧𑀸;

𑀓𑁄𑀡𑁆𑀟𑀜𑁆𑀜 𑀏𑀲𑁄 𑀫𑀦𑀼𑀚𑁂𑀲𑀼 𑀥𑀫𑁆𑀫𑁄, 𑀬𑀁 𑀯𑀼𑀤𑁆𑀥 [𑀯𑀤𑁆𑀥 (𑀧𑀻.), 𑀩𑀼𑀤𑁆𑀥 (𑀓.)] 𑀫𑀸𑀕𑀘𑁆𑀙𑀢𑀺 𑀏𑀲 𑀪𑀸𑀭𑁄’’.

𑁬𑁧.

‘‘𑀓𑀢𑀸𑀯𑀓𑀸𑀲𑀸 ¶ 𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀼 𑀪𑁄𑀦𑁆𑀢𑁄, 𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀧𑀜𑁆𑀳𑀁 𑀫𑀦𑀲𑀸𑀪𑀺𑀧𑀢𑁆𑀣𑀺𑀢𑀁;

𑀅𑀳𑀜𑁆𑀳𑀺 𑀢𑀁 𑀢𑀁 𑀯𑁄 𑀯𑀺𑀬𑀸𑀓𑀭𑀺𑀲𑁆𑀲𑀁, 𑀜𑀢𑁆𑀯𑀸 𑀲𑀬𑀁 𑀮𑁄𑀓𑀫𑀺𑀫𑀁 𑀧𑀭𑀜𑁆𑀘’’.

𑁬𑁨.

‘‘𑀢𑀢𑁄 𑀘 𑀫𑀖𑀯𑀸 𑀲𑀓𑁆𑀓𑁄, 𑀅𑀢𑁆𑀣𑀤𑀲𑁆𑀲𑀻 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀅𑀧𑀼𑀘𑁆𑀙𑀺 𑀧𑀞𑀫𑀁 𑀧𑀜𑁆𑀳𑀁, 𑀬𑀜𑁆𑀘𑀸𑀲𑀺 𑀅𑀪𑀺𑀧𑀢𑁆𑀣𑀺𑀢𑀁’’.

𑁬𑁩.

‘‘𑀓𑀺𑀁 𑀲𑀽 𑀯𑀥𑀺𑀢𑁆𑀯𑀸 𑀦 𑀓𑀤𑀸𑀘𑀺 𑀲𑁄𑀘𑀢𑀺, 𑀓𑀺𑀲𑁆𑀲𑀧𑁆𑀧𑀳𑀸𑀦𑀁 𑀇𑀲𑀬𑁄 𑀯𑀡𑁆𑀡𑀬𑀦𑁆𑀢𑀺;

𑀓𑀲𑁆𑀲𑀻𑀥 ¶ 𑀯𑀼𑀢𑁆𑀢𑀁 𑀨𑀭𑀼𑀲𑀁 𑀔𑀫𑁂𑀣, 𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀓𑁄𑀡𑁆𑀟𑀜𑁆𑀜 𑀏𑀢𑀫𑀢𑁆𑀣𑀁’’.

𑁬𑁪.

‘‘𑀓𑁄𑀥𑀁 𑀯𑀥𑀺𑀢𑁆𑀯𑀸 𑀦 𑀓𑀤𑀸𑀘𑀺 𑀲𑁄𑀘𑀢𑀺, 𑀫𑀓𑁆𑀔𑀧𑁆𑀧𑀳𑀸𑀦𑀁 𑀇𑀲𑀬𑁄 𑀯𑀡𑁆𑀡𑀬𑀦𑁆𑀢𑀺;

𑀲𑀩𑁆𑀩𑁂𑀲𑀁 𑀯𑀼𑀢𑁆𑀢𑀁 𑀨𑀭𑀼𑀲𑀁 𑀔𑀫𑁂𑀣, 𑀏𑀢𑀁 𑀔𑀦𑁆𑀢𑀺𑀁 𑀉𑀢𑁆𑀢𑀫𑀫𑀸𑀳𑀼 𑀲𑀦𑁆𑀢𑁄’’.

𑁬𑁫.

‘‘𑀲𑀓𑁆𑀓𑀸 𑀉𑀪𑀺𑀦𑁆𑀦𑀁 [𑀳𑀺 𑀤𑁆𑀯𑀺𑀦𑁆𑀦𑀁 (𑀧𑀻.)] 𑀯𑀘𑀦𑀁 𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀺𑀢𑀼𑀁, 𑀲𑀤𑀺𑀲𑀲𑁆𑀲 𑀯𑀸 𑀲𑁂𑀝𑁆𑀞𑀢𑀭𑀲𑁆𑀲 [𑀲𑁂𑀝𑁆𑀞𑀦𑀭𑀲𑁆𑀲 (𑀧𑀻.)] 𑀯𑀸𑀧𑀺;

𑀓𑀣𑀁 𑀦𑀼 𑀳𑀻𑀦𑀲𑁆𑀲 𑀯𑀘𑁄 𑀔𑀫𑁂𑀣, 𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀓𑁄𑀡𑁆𑀟𑀜𑁆𑀜 𑀏𑀢𑀫𑀢𑁆𑀣𑀁’’.

𑁬𑁬.

‘‘𑀪𑀬𑀸 ¶ 𑀳𑀺 𑀲𑁂𑀝𑁆𑀞𑀲𑁆𑀲 𑀯𑀘𑁄 𑀔𑀫𑁂𑀣, 𑀲𑀸𑀭𑀫𑁆𑀪𑀳𑁂𑀢𑀽 𑀧𑀦 𑀲𑀸𑀤𑀺𑀲𑀲𑁆𑀲;

𑀬𑁄 𑀘𑀻𑀥 𑀳𑀻𑀦𑀲𑁆𑀲 𑀯𑀘𑁄 𑀔𑀫𑁂𑀣, 𑀏𑀢𑀁 𑀔𑀦𑁆𑀢𑀺𑀁 𑀉𑀢𑁆𑀢𑀫𑀫𑀸𑀳𑀼 𑀲𑀦𑁆𑀢𑁄’’.

𑁬𑁭.

‘‘𑀓𑀣𑀁 𑀯𑀺𑀚𑀜𑁆𑀜𑀸 𑀘𑀢𑀼𑀧𑀢𑁆𑀣𑀭𑀽𑀧𑀁 [𑀘𑀢𑀼𑀫𑀝𑁆𑀞𑀭𑀽𑀧𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀲𑁂𑀝𑁆𑀞𑀁 𑀲𑀭𑀺𑀓𑁆𑀔𑀁 𑀅𑀣𑀯𑀸𑀧𑀺 𑀳𑀻𑀦𑀁;

𑀯𑀺𑀭𑀽𑀧𑀭𑀽𑀧𑁂𑀦 𑀘𑀭𑀦𑁆𑀢𑀺 𑀲𑀦𑁆𑀢𑁄, 𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀲𑀩𑁆𑀩𑁂𑀲𑀁 𑀯𑀘𑁄 𑀔𑀫𑁂𑀣’’.

𑁬𑁮.

‘‘𑀦 𑀳𑁂𑀢𑀫𑀢𑁆𑀣𑀁 𑀫𑀳𑀢𑀻𑀧𑀺 𑀲𑁂𑀦𑀸, 𑀲𑀭𑀸𑀚𑀺𑀓𑀸 𑀬𑀼𑀚𑁆𑀛𑀫𑀸𑀦𑀸 𑀮𑀪𑁂𑀣;

𑀬𑀁 ¶ 𑀔𑀦𑁆𑀢𑀺𑀫𑀸 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑁄 𑀮𑀪𑁂𑀣, 𑀔𑀦𑁆𑀢𑀻 𑀩𑀮𑀲𑁆𑀲𑀽𑀧𑀲𑀫𑀦𑁆𑀢𑀺 𑀯𑁂𑀭𑀸’’.

𑁬𑁯.

‘‘𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 𑀢𑁂 𑀅𑀦𑀼𑀫𑁄𑀤𑀺𑀬𑀸𑀦, 𑀅𑀜𑁆𑀜𑀁 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀤𑀺𑀗𑁆𑀖 𑀩𑁆𑀭𑀽𑀳𑀺;

𑀬𑀣𑀸 𑀅𑀳𑀼𑀁 [𑀅𑀳𑀽 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀤𑀡𑁆𑀟𑀓𑀻 𑀦𑀸𑀴𑀺𑀓𑁂𑀭𑁄 [𑀦𑀸𑀴𑀺𑀓𑀻𑀭𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀅𑀣𑀚𑁆𑀚𑀼𑀦𑁄 𑀓𑀮𑀸𑀩𑀼 𑀘𑀸𑀧𑀺 𑀭𑀸𑀚𑀸;

𑀢𑁂𑀲𑀁 𑀕𑀢𑀺𑀁 𑀩𑁆𑀭𑀽𑀳𑀺 𑀲𑀼𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀺𑀦𑀁, 𑀓𑀢𑁆𑀣𑀽𑀧𑀧𑀦𑁆𑀦𑀸 𑀇𑀲𑀺𑀦𑀁 𑀯𑀺𑀳𑁂𑀞𑀓𑀸’’.

𑁭𑁦.

‘‘𑀓𑀺𑀲𑀜𑁆𑀳𑀺 [𑀓𑀺𑀲𑀁𑀧𑀺 (𑀧𑀻.)] 𑀯𑀘𑁆𑀙𑀁 𑀅𑀯𑀓𑀺𑀭𑀺𑀬 𑀤𑀡𑁆𑀟𑀓𑀻, 𑀉𑀘𑁆𑀙𑀺𑀦𑁆𑀦𑀫𑀽𑀮𑁄 𑀲𑀚𑀦𑁄 𑀲𑀭𑀝𑁆𑀞𑁄;

𑀓𑀼𑀓𑁆𑀓𑀼𑀴𑀦𑀸𑀫𑁂 𑀦𑀺𑀭𑀬𑀫𑁆𑀳𑀺 𑀧𑀘𑁆𑀘𑀢𑀺, 𑀢𑀲𑁆𑀲 𑀨𑀼𑀮𑀺𑀗𑁆𑀕𑀸𑀦𑀺 𑀧𑀢𑀦𑁆𑀢𑀺 𑀓𑀸𑀬𑁂.

𑁭𑁧.

‘‘𑀬𑁄 𑀲𑀜𑁆𑀜𑀢𑁂 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁂 𑀅𑀳𑁂𑀞𑀬𑀺 [𑀅𑀯𑀜𑁆𑀘𑀲𑀺 (𑀧𑀻.)], 𑀥𑀫𑁆𑀫𑀁 𑀪𑀡𑀦𑁆𑀢𑁂 𑀲𑀫𑀡𑁂 𑀅𑀤𑀽𑀲𑀓𑁂;

𑀢𑀁 𑀦𑀸𑀴𑀺𑀓𑁂𑀭𑀁 𑀲𑀼𑀦𑀔𑀸 𑀧𑀭𑀢𑁆𑀣, 𑀲𑀗𑁆𑀕𑀫𑁆𑀫 𑀔𑀸𑀤𑀦𑁆𑀢𑀺 𑀯𑀺𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑀁.

𑁭𑁨.

‘‘𑀅𑀣𑀚𑁆𑀚𑀼𑀦𑁄 ¶ 𑀦𑀺𑀭𑀬𑁂 𑀲𑀢𑁆𑀢𑀺𑀲𑀽𑀮𑁂, 𑀅𑀯𑀁𑀲𑀺𑀭𑁄 𑀧𑀢𑀺𑀢𑁄 𑀉𑀤𑁆𑀥𑀁𑀧𑀸𑀤𑁄 [𑀉𑀤𑁆𑀥𑀧𑀸𑀤𑁄 (𑀲𑁆𑀬𑀸.), 𑀅𑀤𑁆𑀥𑀧𑀸𑀤𑁄 (𑀧𑀻.)];

𑀅𑀗𑁆𑀕𑀻𑀭𑀲𑀁 𑀕𑁄𑀢𑀫𑀁 𑀳𑁂𑀞𑀬𑀺𑀢𑁆𑀯𑀸, 𑀔𑀦𑁆𑀢𑀺𑀁 𑀢𑀧𑀲𑁆𑀲𑀺𑀁 𑀘𑀺𑀭𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺𑀁.

𑁭𑁩.

‘‘𑀬𑁄 ¶ 𑀔𑀡𑁆𑀟𑀲𑁄 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀁 𑀅𑀙𑁂𑀤𑀬𑀺, 𑀔𑀦𑁆𑀢𑀺𑀁 𑀯𑀤𑀦𑁆𑀢𑀁 𑀲𑀫𑀡𑀁 𑀅𑀤𑀽𑀲𑀓𑀁;

𑀓𑀮𑀸𑀩𑀼𑀯𑀻𑀘𑀺𑀁 𑀉𑀧𑀧𑀚𑁆𑀚 𑀧𑀘𑁆𑀘𑀢𑀺, 𑀫𑀳𑀸𑀧𑀢𑀸𑀧𑀁 [𑀫𑀳𑀸𑀪𑀺𑀢𑀸𑀧𑀁 (𑀧𑀻.)] 𑀓𑀝𑀼𑀓𑀁 𑀪𑀬𑀸𑀦𑀓𑀁.

𑁭𑁪.

‘‘𑀏𑀢𑀸𑀦𑀺 𑀲𑀼𑀢𑁆𑀯𑀸 𑀦𑀺𑀭𑀬𑀸𑀦𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑁄, 𑀅𑀜𑁆𑀜𑀸𑀦𑀺 𑀧𑀸𑀧𑀺𑀝𑁆𑀞𑀢𑀭𑀸𑀦𑀺 𑀘𑁂𑀢𑁆𑀣;

𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑁂 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼, 𑀏𑀯𑀗𑁆𑀓𑀭𑁄 𑀲𑀕𑁆𑀕𑀫𑀼𑀧𑁂𑀢𑀺 𑀞𑀸𑀦𑀁’’.

𑁭𑁫.

‘‘𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 ¶ 𑀢𑁂 𑀅𑀦𑀼𑀫𑁄𑀤𑀺𑀬𑀸𑀦, 𑀅𑀜𑁆𑀜𑀁 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀤𑀺𑀗𑁆𑀖 𑀩𑁆𑀭𑀽𑀳𑀺;

𑀓𑀣𑀁𑀯𑀺𑀥𑀁 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑀁 𑀯𑀤𑀦𑁆𑀢𑀺, 𑀓𑀣𑀁𑀯𑀺𑀥𑀁 𑀧𑀜𑁆𑀜𑀯𑀦𑁆𑀢𑀁 𑀯𑀤𑀦𑁆𑀢𑀺;

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

𑁭𑁬.

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

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

𑁭𑁭.

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

𑀓𑀸𑀮𑀸𑀕𑀢𑀁 ¶ [𑀓𑀸𑀮𑀸𑀪𑀢𑀁 (𑀧𑀻.)] 𑀅𑀢𑁆𑀣𑀧𑀤𑀁 𑀦 𑀭𑀺𑀜𑁆𑀘𑀢𑀺, 𑀢𑀣𑀸𑀯𑀺𑀥𑀁 𑀧𑀜𑁆𑀜𑀯𑀦𑁆𑀢𑀁 𑀯𑀤𑀦𑁆𑀢𑀺.

𑁭𑁮.

‘‘𑀬𑁄 ¶ 𑀯𑁂 𑀓𑀢𑀜𑁆𑀜𑀽 𑀓𑀢𑀯𑁂𑀤𑀺 𑀥𑀻𑀭𑁄, 𑀓𑀮𑁆𑀬𑀸𑀡𑀫𑀺𑀢𑁆𑀢𑁄 𑀤𑀴𑁆𑀳𑀪𑀢𑁆𑀢𑀺 𑀘 𑀳𑁄𑀢𑀺;

𑀤𑀼𑀔𑀺𑀢𑀲𑁆𑀲 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀓𑀭𑁄𑀢𑀺 𑀓𑀺𑀘𑁆𑀘𑀁, 𑀢𑀣𑀸𑀯𑀺𑀥𑀁 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀁 𑀯𑀤𑀦𑁆𑀢𑀺.

𑁭𑁯.

‘‘𑀏𑀢𑁂𑀳𑀺 𑀲𑀩𑁆𑀩𑁂𑀳𑀺 𑀕𑀼𑀡𑁂𑀳𑀼𑀧𑁂𑀢𑁄, 𑀲𑀤𑁆𑀥𑁄 𑀫𑀼𑀤𑀽 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀻 𑀯𑀤𑀜𑁆𑀜𑀽;

𑀲𑀗𑁆𑀕𑀸𑀳𑀓𑀁 𑀲𑀔𑀺𑀮𑀁 𑀲𑀡𑁆𑀳𑀯𑀸𑀘𑀁, 𑀢𑀣𑀸𑀯𑀺𑀥𑀁 𑀦𑁄 𑀲𑀺𑀭𑀺 𑀦𑁄 𑀚𑀳𑀸𑀢𑀺’’.

𑁮𑁦.

‘‘𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 𑀢𑁂 𑀅𑀦𑀼𑀫𑁄𑀤𑀺𑀬𑀸𑀦, 𑀅𑀜𑁆𑀜𑀁 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀤𑀺𑀗𑁆𑀖 𑀩𑁆𑀭𑀽𑀳𑀺;

𑀲𑀻𑀮𑀁 𑀲𑀺𑀭𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀲𑀢𑀜𑁆𑀘 𑀥𑀫𑁆𑀫𑀁, 𑀧𑀜𑁆𑀜𑀜𑁆𑀘 𑀓𑀁 𑀲𑁂𑀝𑁆𑀞𑀢𑀭𑀁 𑀯𑀤𑀦𑁆𑀢𑀺’’.

𑁮𑁧.

‘‘𑀧𑀜𑁆𑀜𑀸 𑀳𑀺 𑀲𑁂𑀝𑁆𑀞𑀸 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑀦𑁆𑀢𑀺, 𑀦𑀓𑁆𑀔𑀢𑁆𑀢𑀭𑀸𑀚𑀸𑀭𑀺𑀯 𑀢𑀸𑀭𑀓𑀸𑀦𑀁;

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

𑁮𑁨.

‘‘𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 𑀢𑁂 𑀅𑀦𑀼𑀫𑁄𑀤𑀺𑀬𑀸𑀦, 𑀅𑀜𑁆𑀜𑀁 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀤𑀺𑀗𑁆𑀖 𑀩𑁆𑀭𑀽𑀳𑀺;

𑀓𑀣𑀁𑀓𑀭𑁄 ¶ 𑀓𑀺𑀦𑁆𑀢𑀺𑀓𑀭𑁄 𑀓𑀺𑀫𑀸𑀘𑀭𑀁, 𑀓𑀺𑀁 𑀲𑁂𑀯𑀫𑀸𑀦𑁄 𑀮𑀪𑀢𑀻𑀥 𑀧𑀜𑁆𑀜𑀁;

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

𑁮𑁩.

‘‘𑀲𑁂𑀯𑁂𑀣 𑀯𑀼𑀤𑁆𑀥𑁂 𑀦𑀺𑀧𑀼𑀡𑁂 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁂, 𑀉𑀕𑁆𑀕𑀸𑀳𑀓𑁄 𑀘 𑀧𑀭𑀺𑀧𑀼𑀘𑁆𑀙𑀓𑁄 𑀲𑀺𑀬𑀸;

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

𑁮𑁪.

‘‘ ¶ 𑀧𑀜𑁆𑀜𑀯𑀸 𑀓𑀸𑀫𑀕𑀼𑀡𑁂 𑀅𑀯𑁂𑀓𑁆𑀔𑀢𑀺, 𑀅𑀦𑀺𑀘𑁆𑀘𑀢𑁄 𑀤𑀼𑀓𑁆𑀔𑀢𑁄 𑀭𑁄𑀕𑀢𑁄 𑀘;

𑀏𑀯𑀁 𑀯𑀺𑀧𑀲𑁆𑀲𑀻 𑀧𑀚𑀳𑀸𑀢𑀺 𑀙𑀦𑁆𑀤𑀁, 𑀤𑀼𑀓𑁆𑀔𑁂𑀲𑀼 𑀓𑀸𑀫𑁂𑀲𑀼 𑀫𑀳𑀩𑁆𑀪𑀬𑁂𑀲𑀼.

𑁮𑁫.

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

𑀲𑀩𑁆𑀩𑁂𑀲𑀼 𑀪𑀽𑀢𑁂𑀲𑀼 𑀦𑀺𑀥𑀸𑀬 𑀤𑀡𑁆𑀟𑀁, 𑀅𑀦𑀺𑀦𑁆𑀤𑀺𑀢𑁄 𑀩𑁆𑀭𑀳𑁆𑀫𑀫𑀼𑀧𑁂𑀢𑀺 𑀞𑀸𑀦𑀁’’.

𑁮𑁬.

‘‘𑀫𑀳𑀢𑁆𑀣𑀺𑀬𑀁 [𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀆𑀕𑀫𑀦𑀁 𑀅𑀳𑁄𑀲𑀺, 𑀢𑀯𑀫𑀝𑁆𑀞𑀓𑀸 [𑀫𑀝𑁆𑀞𑀓 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)] 𑀪𑀻𑀫𑀭𑀣𑀲𑁆𑀲 𑀘𑀸𑀧𑀺;

𑀓𑀸𑀮𑀺𑀗𑁆𑀕𑀭𑀸𑀚𑀲𑁆𑀲 𑀘 𑀉𑀕𑁆𑀕𑀢𑀲𑁆𑀲, 𑀲𑀩𑁆𑀩𑁂𑀲 ¶ 𑀯𑁄 𑀓𑀸𑀫𑀭𑀸𑀕𑁄 𑀧𑀳𑀻𑀦𑁄’’.

𑁮𑁭.

‘‘𑀏𑀯𑀫𑁂𑀢𑀁 𑀧𑀭𑀘𑀺𑀢𑁆𑀢𑀯𑁂𑀤𑀺, 𑀲𑀩𑁆𑀩𑁂𑀲 𑀦𑁄 𑀓𑀸𑀫𑀭𑀸𑀕𑁄 𑀧𑀳𑀻𑀦𑁄;

𑀓𑀭𑁄𑀳𑀺 𑀑𑀓𑀸𑀲𑀫𑀦𑀼𑀕𑁆𑀕𑀳𑀸𑀬, 𑀬𑀣𑀸 𑀕𑀢𑀺𑀁 𑀢𑁂 𑀅𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑁂𑀫’’.

𑁮𑁮.

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

𑀨𑀭𑀸𑀣 𑀓𑀸𑀬𑀁 𑀯𑀺𑀧𑀼𑀮𑀸𑀬 𑀧𑀻𑀢𑀺𑀬𑀸, 𑀬𑀣𑀸 𑀕𑀢𑀺𑀁 𑀫𑁂 𑀅𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑁂𑀣’’.

𑁮𑁯.

‘‘𑀲𑀩𑁆𑀩𑀁 ¶ 𑀓𑀭𑀺𑀲𑁆𑀲𑀸𑀫 𑀢𑀯𑀸𑀦𑀼𑀲𑀸𑀲𑀦𑀺𑀁, 𑀬𑀁 𑀬𑀁 𑀢𑀼𑀯𑀁 𑀯𑀓𑁆𑀔𑀲𑀺 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜;

𑀨𑀭𑀸𑀫 𑀓𑀸𑀬𑀁 𑀯𑀺𑀧𑀼𑀮𑀸𑀬 𑀧𑀻𑀢𑀺𑀬𑀸, 𑀬𑀣𑀸 𑀕𑀢𑀺𑀁 𑀢𑁂 𑀅𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑁂𑀫’’.

𑁯𑁦.

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

𑀛𑀸𑀦𑁂 𑀭𑀢𑀸 𑀳𑁄𑀣 𑀲𑀤𑀸 𑀲𑀫𑀸𑀳𑀺𑀢𑀸, 𑀏𑀲𑀸 𑀭𑀢𑀻 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀲𑁆𑀲 𑀲𑁂𑀝𑁆𑀞𑀸’’.

𑁯𑁧.

‘‘𑀲𑀼𑀢𑁆𑀯𑀸𑀦 ¶ 𑀕𑀸𑀣𑀸 𑀧𑀭𑀫𑀢𑁆𑀣𑀲𑀁𑀳𑀺𑀢𑀸, 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸 𑀇𑀲𑀺𑀦𑀸 𑀧𑀡𑁆𑀟𑀺𑀢𑁂𑀦;

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

𑁯𑁨.

‘‘𑀕𑀸𑀣𑀸 𑀇𑀫𑀸 𑀅𑀢𑁆𑀣𑀯𑀢𑀻 𑀲𑀼𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀸, 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸 𑀇𑀲𑀺𑀦𑀸 𑀧𑀡𑁆𑀟𑀺𑀢𑁂𑀦;

𑀬𑁄 𑀓𑁄𑀘𑀺𑀫𑀸 𑀅𑀝𑁆𑀞𑀺𑀓𑀢𑁆𑀯𑀸 [𑀅𑀝𑁆𑀞𑀺𑀁 𑀓𑀢𑁆𑀯𑀸 (𑀓.)] 𑀲𑀼𑀡𑁂𑀬𑁆𑀬, 𑀮𑀪𑁂𑀣 𑀧𑀼𑀩𑁆𑀩𑀸𑀧𑀭𑀺𑀬𑀁 𑀯𑀺𑀲𑁂𑀲𑀁;

𑀮𑀤𑁆𑀥𑀸𑀦 𑀧𑀼𑀩𑁆𑀩𑀸𑀧𑀭𑀺𑀬𑀁 𑀯𑀺𑀲𑁂𑀲𑀁, 𑀅𑀤𑀲𑁆𑀲𑀦𑀁 𑀫𑀘𑁆𑀘𑀼𑀭𑀸𑀚𑀲𑁆𑀲 𑀕𑀘𑁆𑀙𑁂’’.

𑁯𑁩.

‘‘𑀲𑀸𑀮𑀺𑀲𑁆𑀲𑀭𑁄 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑁄, 𑀫𑁂𑀡𑁆𑀟𑀺𑀲𑁆𑀲𑀭𑁄 𑀘 𑀓𑀲𑁆𑀲𑀧𑁄;

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

𑁯𑁪.

‘‘𑀅𑀦𑀼𑀲𑀺𑀲𑁆𑀲𑁄 𑀘 𑀆𑀦𑀦𑁆𑀤𑁄, 𑀓𑀺𑀲𑀯𑀘𑁆𑀙𑁄 𑀘 𑀓𑁄𑀮𑀺𑀢𑁄;

𑀦𑀸𑀭𑀤𑁄 𑀉𑀤𑀸𑀬𑀻 𑀣𑁂𑀭𑁄 [𑀦𑀸𑀭𑀤𑁄 𑀧𑀼𑀡𑁆𑀡𑁄 𑀫𑀦𑁆𑀢𑀸𑀦𑀻𑀧𑀼𑀢𑁆𑀢𑁄 (𑀲𑀻.)], 𑀧𑀭𑀺𑀲𑀸 𑀩𑀼𑀤𑁆𑀥𑀧𑀭𑀺𑀲𑀸;

𑀲𑀭𑀪𑀗𑁆𑀕𑁄 𑀮𑁄𑀓𑀦𑀸𑀣𑁄, 𑀏𑀯𑀁 𑀥𑀸𑀭𑁂𑀣 𑀚𑀸𑀢𑀓’’𑀦𑁆𑀢𑀺.

𑀲𑀭𑀪𑀗𑁆𑀕𑀚𑀸𑀢𑀓𑀁 𑀤𑀼𑀢𑀺𑀬𑀁.

𑁫𑁨𑁩. 𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀸𑀚𑀸𑀢𑀓𑀁 (𑁩)

𑁯𑁫.

‘‘𑀅𑀣 𑀩𑁆𑀭𑀯𑀺 𑀩𑁆𑀭𑀳𑀸 𑀇𑀦𑁆𑀤𑁄, 𑀯𑀢𑁆𑀭𑀪𑀽 𑀚𑀬𑀢𑀁 𑀧𑀺𑀢𑀸;

𑀤𑁂𑀯𑀓𑀜𑁆𑀜𑀁 𑀧𑀭𑀸𑀪𑁂𑀢𑁆𑀯𑀸, 𑀲𑀼𑀥𑀫𑁆𑀫𑀸𑀬𑀁 𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀁.

𑁯𑁬.

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

𑀇𑀲𑀺𑀧𑁆𑀧𑀮𑁄𑀪𑀦𑁂 ¶ [𑀇𑀲𑀺𑀧𑀮𑁄𑀪𑀺𑀓𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀇𑀲𑀺𑀁 𑀧𑀮𑁄𑀪𑀺𑀓𑁂 (𑀧𑀻.)] 𑀕𑀘𑁆𑀙, 𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑀁 𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑁂.

𑁯𑁭.

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

𑀦𑀺𑀩𑁆𑀩𑀸𑀦𑀸𑀪𑀺𑀭𑀢𑁄 𑀯𑀼𑀤𑁆𑀥𑁄 [𑀯𑀤𑁆𑀥𑁄 (𑀧𑀻.), 𑀩𑀼𑀤𑁆𑀥𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀢𑀲𑁆𑀲 𑀫𑀕𑁆𑀕𑀸𑀦𑀺 𑀆𑀯𑀭’’.

𑁯𑁮.

‘‘𑀤𑁂𑀯𑀭𑀸𑀚 𑀓𑀺𑀫𑁂𑀯 𑀢𑁆𑀯𑀁, 𑀫𑀫𑁂𑀯 𑀢𑀼𑀯𑀁 𑀲𑀺𑀓𑁆𑀔𑀲𑀺;

𑀇𑀲𑀺𑀧𑁆𑀧𑀮𑁄𑀪𑀦𑁂 [𑀇𑀲𑀺𑀧𑀮𑁄𑀪𑀺𑀓𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀇𑀲𑀺𑀁 𑀧𑀮𑁄𑀪𑀺𑀓𑁂 (𑀧𑀻.)] 𑀕𑀘𑁆𑀙, 𑀲𑀦𑁆𑀢𑀺 𑀅𑀜𑁆𑀜𑀸𑀧𑀺 𑀅𑀘𑁆𑀙𑀭𑀸.

𑁯𑁯.

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

𑀢𑀸𑀲𑀫𑁆𑀧𑀺 𑀳𑁄𑀢𑀼 𑀧𑀭𑀺𑀬𑀸𑀬𑁄, 𑀢𑀸𑀧𑀺 𑀬𑀦𑁆𑀢𑀼 𑀧𑀮𑁄𑀪𑀦𑀸’’ [𑀧𑀮𑁄𑀪𑀺𑀓𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑁧𑁦𑁦.

‘‘𑀅𑀤𑁆𑀥𑀸 ¶ 𑀳𑀺 𑀲𑀘𑁆𑀘𑀁 𑀪𑀡𑀲𑀺, 𑀲𑀦𑁆𑀢𑀺 𑀅𑀜𑁆𑀜𑀸𑀧𑀺 𑀅𑀘𑁆𑀙𑀭𑀸;

𑀢𑀸𑀤𑀺𑀲𑀺𑀬𑁄 𑀧𑀯𑀭𑀸 𑀘𑁂𑀯, 𑀅𑀲𑁄𑀓𑁂 𑀦𑀦𑁆𑀤𑀦𑁂 𑀯𑀦𑁂.

𑁧𑁦𑁧.

‘‘𑀦 𑀢𑀸 𑀏𑀯𑀁 𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀧𑀸𑀭𑀺𑀘𑀭𑀺𑀬𑀁 𑀧𑀼𑀫𑀁 𑀕𑀢𑀸;

𑀬𑀸𑀤𑀺𑀲𑀁 𑀢𑁆𑀯𑀁 𑀧𑀚𑀸𑀦𑀸𑀲𑀺, 𑀦𑀸𑀭𑀺 𑀲𑀩𑁆𑀩𑀗𑁆𑀕𑀲𑁄𑀪𑀦𑁂.

𑁧𑁦𑁨.

‘‘𑀢𑁆𑀯𑀫𑁂𑀯 𑀕𑀘𑁆𑀙 𑀓𑀮𑁆𑀬𑀸𑀡𑀺, 𑀇𑀢𑁆𑀣𑀻𑀦𑀁 𑀧𑀯𑀭𑀸 𑀘𑀲𑀺;

𑀢𑀯𑁂𑀯 𑀯𑀡𑁆𑀡𑀭𑀽𑀧𑁂𑀦, 𑀲𑀯𑀲𑀫𑀸𑀦𑀬𑀺𑀲𑁆𑀲𑀲𑀺’’ [𑀯𑀲𑀫𑀸𑀦𑀸𑀧𑀬𑀺𑀲𑁆𑀲𑀲𑀺 (𑀲𑁆𑀬𑀸.), 𑀯𑀲𑀫𑀸𑀦𑀸𑀫𑀬𑀺𑀲𑁆𑀲𑀲𑀺 (𑀧𑀻.), 𑀢𑀁 𑀯𑀲𑀫𑀸𑀦𑀬𑀺𑀲𑁆𑀲𑀲𑀺 (𑀓.)].

𑁧𑁦𑁩.

‘‘𑀦 𑀯𑀸𑀳𑀁 𑀦 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀤𑁂𑀯𑀭𑀸𑀚𑁂𑀦 𑀧𑁂𑀲𑀺𑀢𑀸;

𑀯𑀺𑀪𑁂𑀫𑀺 𑀘𑁂𑀢𑀁 𑀆𑀲𑀸𑀤𑀼𑀁, 𑀉𑀕𑁆𑀕𑀢𑁂𑀚𑁄 𑀳𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

𑁧𑁦𑁪.

‘‘𑀅𑀦𑁂𑀓𑁂 𑀦𑀺𑀭𑀬𑀁 𑀧𑀢𑁆𑀢𑀸, 𑀇𑀲𑀺𑀫𑀸𑀲𑀸𑀤𑀺𑀬𑀸 𑀚𑀦𑀸;

𑀆𑀧𑀦𑁆𑀦𑀸 𑀫𑁄𑀳𑀲𑀁𑀲𑀸𑀭𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀮𑁄𑀫𑀸𑀦𑀺 𑀳𑀁𑀲𑀬𑁂’’.

𑁧𑁦𑁫.

‘‘𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀧𑀓𑁆𑀓𑀸𑀫𑀺, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻;

𑀫𑀺𑀲𑁆𑀲𑀸 𑀫𑀺𑀲𑁆𑀲𑀺𑀢𑀼 [𑀫𑀺𑀲𑁆𑀲𑁂𑀢𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀺𑀘𑁆𑀙𑀦𑁆𑀢𑀻, 𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑀁 𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀸.

𑁧𑁦𑁬.

‘‘𑀲𑀸 𑀘 𑀢𑀁 𑀯𑀦𑀫𑁄𑀕𑀬𑁆𑀳, 𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑁂𑀦 𑀭𑀓𑁆𑀔𑀺𑀢𑀁;

𑀩𑀺𑀫𑁆𑀩𑀚𑀸𑀮𑀓𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀁 ¶ , 𑀲𑀫𑀦𑁆𑀢𑀸 𑀅𑀟𑁆𑀠𑀬𑁄𑀚𑀦𑀁.

𑁧𑁦𑁭.

‘‘𑀧𑀸𑀢𑁄𑀯 𑀧𑀸𑀢𑀭𑀸𑀲𑀫𑁆𑀳𑀺, 𑀉𑀤𑀡𑁆𑀳𑀲𑀫𑀬𑀁 [𑀉𑀤𑀬𑀲𑀫𑀬𑀁 (𑀲𑁆𑀬𑀸.), 𑀉𑀤𑀦𑁆𑀢𑀲𑀫𑀬𑀁 (𑀓.)] 𑀧𑀢𑀺;

𑀅𑀕𑁆𑀕𑀺𑀝𑁆𑀞𑀁 𑀧𑀭𑀺𑀫𑀚𑁆𑀚𑀦𑁆𑀢𑀁, 𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑀁 𑀉𑀧𑀸𑀕𑀫𑀺’’.

𑁧𑁦𑁮.

‘‘𑀓𑀸 𑀦𑀼 𑀯𑀺𑀚𑁆𑀚𑀼𑀭𑀺𑀯𑀸𑀪𑀸𑀲𑀺, 𑀑𑀲𑀥𑀻 𑀯𑀺𑀬 𑀢𑀸𑀭𑀓𑀸;

𑀯𑀺𑀘𑀺𑀢𑁆𑀢𑀳𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑀸 [𑀯𑀺𑀘𑀺𑀢𑁆𑀢𑀯𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑀸 (𑀲𑀻.)], 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀸 [𑀆𑀫𑀼𑀓𑁆𑀓𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀸 (?)].

𑁧𑁦𑁯.

‘‘𑀆𑀤𑀺𑀘𑁆𑀘𑀯𑀡𑁆𑀡𑀲𑀗𑁆𑀓𑀸𑀲𑀸, 𑀳𑁂𑀫𑀘𑀦𑁆𑀤𑀦𑀕𑀦𑁆𑀥𑀺𑀦𑀻;

𑀲𑀜𑁆𑀜𑀢𑀽𑀭𑀽 𑀫𑀳𑀸𑀫𑀸𑀬𑀸, 𑀓𑀼𑀫𑀸𑀭𑀻 𑀘𑀸𑀭𑀼𑀤𑀲𑁆𑀲𑀦𑀸.

𑁧𑁧𑁦.

‘‘𑀯𑀺𑀮𑀕𑁆𑀕𑀸 [𑀯𑀺𑀮𑀸𑀓𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀼𑀤𑀼𑀓𑀸 𑀲𑀼𑀤𑁆𑀥𑀸, 𑀧𑀸𑀤𑀸 𑀢𑁂 𑀲𑀼𑀧𑁆𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸;

𑀕𑀫𑀦𑀸 𑀓𑀸𑀫𑀦𑀻𑀬𑀸 [𑀓𑀫𑀦𑀸 𑀓𑀫𑀦𑀻𑀬𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀢𑁂, 𑀳𑀭𑀦𑁆𑀢𑀺𑀬𑁂𑀯 𑀫𑁂 𑀫𑀦𑁄.

𑁧𑁧𑁧.

‘‘𑀅𑀦𑀼𑀧𑀼𑀩𑁆𑀩𑀸𑀯 ¶ 𑀢𑁂 𑀊𑀭𑀽, 𑀦𑀸𑀕𑀦𑀸𑀲𑀲𑀫𑀽𑀧𑀫𑀸;

𑀯𑀺𑀫𑀝𑁆𑀞𑀸 𑀢𑀼𑀬𑁆𑀳𑀁 𑀲𑀼𑀲𑁆𑀲𑁄𑀡𑀻, 𑀅𑀓𑁆𑀔𑀲𑁆𑀲 𑀨𑀮𑀓𑀁 𑀬𑀣𑀸.

𑁧𑁧𑁨.

‘‘𑀉𑀧𑁆𑀧𑀮𑀲𑁆𑀲𑁂𑀯 𑀓𑀺𑀜𑁆𑀚𑀓𑁆𑀔𑀸, 𑀦𑀸𑀪𑀺 𑀢𑁂 𑀲𑀸𑀥𑀼 𑀲𑀡𑁆𑀞𑀺𑀢𑀸;

𑀧𑀽𑀭𑀸 𑀓𑀡𑁆𑀳𑀜𑁆𑀚𑀦𑀲𑁆𑀲𑁂𑀯, 𑀤𑀽𑀭𑀢𑁄 𑀧𑀝𑀺𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑁧𑁧𑁩.

‘‘𑀤𑀼𑀯𑀺𑀥𑀸 𑀚𑀸𑀢𑀸 𑀉𑀭𑀚𑀸, 𑀅𑀯𑀡𑁆𑀝𑀸 𑀲𑀸𑀥𑀼 𑀧𑀘𑁆𑀘𑀼𑀤𑀸;

𑀧𑀬𑁄𑀥𑀭𑀸 𑀅𑀧𑀢𑀺𑀢𑀸 [𑀅𑀧𑁆𑀧𑀢𑀻𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀅𑀟𑁆𑀠𑀮𑀸𑀩𑀼𑀲𑀫𑀸 𑀣𑀦𑀸.

𑁧𑁧𑁪.

‘‘𑀤𑀻𑀖𑀸 𑀓𑀫𑁆𑀩𑀼𑀢𑀮𑀸𑀪𑀸𑀲𑀸, 𑀕𑀻𑀯𑀸 𑀏𑀡𑁂𑀬𑁆𑀬𑀓𑀸 𑀬𑀣𑀸;

𑀧𑀡𑁆𑀟𑀭𑀸𑀯𑀭𑀡𑀸 𑀯𑀕𑁆𑀕𑀼, 𑀘𑀢𑀼𑀢𑁆𑀣𑀫𑀦𑀲𑀦𑁆𑀦𑀺𑀪𑀸.

𑁧𑁧𑁫.

‘‘𑀉𑀤𑁆𑀥𑀕𑁆𑀕𑀸 ¶ 𑀘 𑀅𑀥𑀕𑁆𑀕𑀸 𑀘, 𑀤𑀼𑀫𑀕𑁆𑀕𑀧𑀭𑀺𑀫𑀚𑁆𑀚𑀺𑀢𑀸;

𑀤𑀼𑀯𑀺𑀚𑀸 𑀦𑁂𑀮𑀲𑀫𑁆𑀪𑀽𑀢𑀸, 𑀤𑀦𑁆𑀢𑀸 𑀢𑀯 𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑀸.

𑁧𑁧𑁬.

‘‘𑀅𑀧𑀡𑁆𑀟𑀭𑀸 𑀮𑁄𑀳𑀺𑀢𑀦𑁆𑀢𑀸, 𑀚𑀺𑀜𑁆𑀚𑀽𑀓 [𑀚𑀺𑀜𑁆𑀚𑀼𑀓 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀨𑀮𑀲𑀦𑁆𑀦𑀺𑀪𑀸;

𑀆𑀬𑀢𑀸 ¶ 𑀘 𑀯𑀺𑀲𑀸𑀮𑀸 𑀘, 𑀦𑁂𑀢𑁆𑀢𑀸 𑀢𑀯 𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑀸.

𑁧𑁧𑁭.

‘‘𑀦𑀸𑀢𑀺𑀤𑀻𑀖𑀸 𑀲𑀼𑀲𑀫𑁆𑀫𑀝𑁆𑀞𑀸, 𑀓𑀦𑀓𑀩𑁆𑀬𑀸 [𑀓𑀦𑀓𑀕𑁆𑀕𑀸 (𑀧𑀻.)] 𑀲𑀫𑁄𑀘𑀺𑀢𑀸;

𑀉𑀢𑁆𑀢𑀫𑀗𑁆𑀕𑀭𑀼𑀳𑀸 𑀢𑀼𑀬𑁆𑀳𑀁, 𑀓𑁂𑀲𑀸 𑀘𑀦𑁆𑀤𑀦𑀕𑀦𑁆𑀥𑀺𑀓𑀸.

𑁧𑁧𑁮.

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

𑀇𑀲𑀻𑀦𑀜𑁆𑀘 𑀧𑀭𑀓𑁆𑀓𑀦𑁆𑀢𑀁, 𑀲𑀜𑁆𑀜𑀢𑀸𑀦𑀁 𑀢𑀧𑀲𑁆𑀲𑀺𑀦𑀁.

𑁧𑁧𑁯.

‘‘𑀦 𑀢𑁂 𑀲𑀫𑀲𑀫𑀁 𑀧𑀲𑁆𑀲𑁂, 𑀅𑀲𑁆𑀫𑀺𑀁 𑀧𑀣𑀯𑀺 [𑀧𑀼𑀣𑀼𑀯𑀺 (𑀧𑀻.)] 𑀫𑀡𑁆𑀟𑀮𑁂;

𑀓𑁄 𑀯𑀸 𑀢𑁆𑀯𑀁 𑀓𑀲𑁆𑀲 𑀯𑀸 𑀧𑀼𑀢𑁆𑀢𑁄, 𑀓𑀣𑀁 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑀁 𑀫𑀬𑀁’’.

𑁧𑁨𑁦.

‘‘𑀦 𑀧𑀜𑁆𑀳𑀓𑀸𑀮𑁄 𑀪𑀤𑁆𑀤𑀦𑁆𑀢𑁂, 𑀓𑀲𑁆𑀲𑀧𑁂𑀯𑀁 𑀕𑀢𑁂 𑀲𑀢𑀺;

𑀏𑀳𑀺 𑀲𑀫𑁆𑀫 𑀭𑀫𑀺𑀲𑁆𑀲𑀸𑀫, 𑀉𑀪𑁄 𑀅𑀲𑁆𑀫𑀸𑀓𑀫𑀲𑁆𑀲𑀫𑁂;

𑀏𑀳𑀺 𑀢𑀁 𑀉𑀧𑀕𑀽𑀳𑀺𑀲𑁆𑀲𑀁 [𑀉𑀧𑀕𑀼𑀬𑁆𑀳𑀺𑀲𑁆𑀲𑀁 (𑀲𑁆𑀬𑀸.)], 𑀭𑀢𑀻𑀦𑀁 𑀓𑀼𑀲𑀮𑁄 𑀪𑀯’’.

𑁧𑁨𑁧.

‘‘𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀧𑀓𑁆𑀓𑀸𑀫𑀺, 𑀅𑀘𑁆𑀙𑀭𑀸 𑀓𑀸𑀫𑀯𑀡𑁆𑀡𑀺𑀦𑀻;

𑀫𑀺𑀲𑁆𑀲𑀸 𑀫𑀺𑀲𑁆𑀲𑀺𑀢𑀼𑀫𑀺𑀘𑁆𑀙𑀦𑁆𑀢𑀻, 𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑀁 𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀸’’.

𑁧𑁨𑁨.

‘‘𑀲𑁄 𑀘 𑀯𑁂𑀕𑁂𑀦 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫, 𑀙𑁂𑀢𑁆𑀯𑀸 𑀤𑀦𑁆𑀥𑀧𑀭𑀓𑁆𑀓𑀫𑀁 [𑀤𑀦𑁆𑀥𑀧𑀤𑀓𑁆𑀓𑀫𑀁 (𑀓.)];

𑀢𑀫𑀼𑀢𑁆𑀢𑀫𑀸𑀲𑀼 𑀯𑁂𑀡𑀻𑀲𑀼, 𑀅𑀚𑁆𑀛𑀧𑁆𑀧𑀢𑁆𑀢𑁄 [𑀅𑀚𑁆𑀛𑀸𑀧𑀢𑁆𑀢𑁄 (𑀧𑀻.)] 𑀧𑀭𑀸𑀫𑀲𑀺;

𑁧𑁨𑁩.

‘‘𑀢𑀫𑀼𑀤𑀸𑀯𑀢𑁆𑀢 ¶ 𑀓𑀮𑁆𑀬𑀸𑀡𑀻, 𑀧𑀮𑀺𑀲𑁆𑀲𑀚𑀺 𑀲𑀼𑀲𑁄𑀪𑀦𑀸 [𑀲𑀼𑀲𑁄𑀪𑀡𑀻 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀘𑀯𑀺𑀢𑀫𑁆𑀳𑀺 [𑀘𑀯𑀺 𑀢𑀫𑁆𑀳𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀸, 𑀬𑀣𑀸 𑀢𑀁 𑀅𑀣 𑀢𑁄𑀲𑀺𑀢𑀸.

𑁧𑁨𑁪.

‘‘𑀫𑀦𑀲𑀸 𑀅𑀕𑀫𑀸 𑀇𑀦𑁆𑀤𑀁, 𑀯𑀲𑀦𑁆𑀢𑀁 𑀦𑀦𑁆𑀤𑀦𑁂 𑀯𑀦𑁂;

𑀢𑀲𑁆𑀲𑀸 𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑀫𑀜𑁆𑀜𑀸𑀬, 𑀫𑀖𑀯𑀸 𑀤𑁂𑀯𑀓𑀼𑀜𑁆𑀚𑀭𑁄.

𑁧𑁨𑁫.

‘‘𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑀁 𑀧𑀳𑀺𑀡𑀻 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀲𑁄𑀯𑀡𑁆𑀡𑀁 𑀲𑁄𑀧𑀯𑀸𑀳𑀦𑀁;

𑀲𑀉𑀢𑁆𑀢𑀭𑀘𑁆𑀙𑀤𑀧𑀜𑁆𑀜𑀸𑀲𑀁, 𑀲𑀳𑀲𑁆𑀲𑀧𑀝𑀺𑀬𑀢𑁆𑀣𑀢𑀁 [𑀧𑀝𑀺𑀓𑀢𑁆𑀣𑀢𑀁 (𑀲𑀻.)].

𑁧𑁨𑁬.

‘‘𑀢𑀫𑁂𑀦𑀁 ¶ 𑀢𑀢𑁆𑀣 𑀥𑀸𑀭𑁂𑀲𑀺, 𑀉𑀭𑁂 𑀓𑀢𑁆𑀯𑀸𑀦 𑀲𑁄𑀪𑀦𑀸;

𑀬𑀣𑀸 𑀏𑀓𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑀁𑀯, 𑀢𑀻𑀡𑀺 𑀯𑀲𑁆𑀲𑀸𑀦𑀺 𑀥𑀸𑀭𑀬𑀺.

𑁧𑁨𑁭.

‘‘𑀯𑀺𑀫𑀤𑁄 𑀢𑀻𑀳𑀺 𑀯𑀲𑁆𑀲𑁂𑀳𑀺, 𑀧𑀩𑀼𑀚𑁆𑀛𑀺𑀢𑁆𑀯𑀸𑀦 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄;

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

𑁧𑁨𑁮.

‘‘𑀦𑀯𑀧𑀢𑁆𑀢𑀯𑀦𑀁 𑀨𑀼𑀮𑁆𑀮𑀁, 𑀓𑁄𑀓𑀺𑀮𑀕𑁆𑀕𑀡𑀖𑁄𑀲𑀺𑀢𑀁;

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

𑁧𑁨𑁯.

‘‘𑀦 ¶ 𑀚𑀼𑀳𑁂 𑀦 𑀚𑀧𑁂 [𑀚𑀧𑁆𑀧𑁂 (𑀓.)] 𑀫𑀦𑁆𑀢𑁂, 𑀅𑀕𑁆𑀕𑀺𑀳𑀼𑀢𑁆𑀢𑀁 𑀧𑀳𑀸𑀧𑀺𑀢𑀁;

𑀓𑁄 𑀦𑀼 𑀫𑁂 𑀧𑀸𑀭𑀺𑀘𑀭𑀺𑀬𑀸𑀬, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀮𑁄𑀪𑀬𑀺.

𑁧𑁩𑁦.

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

𑀦𑀸𑀦𑀸𑀭𑀢𑁆𑀦𑀧𑀭𑀺𑀧𑀽𑀭𑀁, 𑀦𑀸𑀯𑀁𑀯 𑀕𑀡𑁆𑀳𑀺 𑀅𑀡𑁆𑀡𑀯𑁂’’.

𑁧𑁩𑁧.

‘‘𑀅𑀳𑀁 𑀢𑁂 𑀧𑀸𑀭𑀺𑀘𑀭𑀺𑀬𑀸𑀬, 𑀤𑁂𑀯𑀭𑀸𑀚𑁂𑀦 𑀧𑁂𑀲𑀺𑀢𑀸;

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

𑁧𑁩𑁨.

‘‘𑀇𑀫𑀸𑀦𑀺 𑀓𑀺𑀭 𑀫𑀁 𑀢𑀸𑀢𑁄, 𑀓𑀲𑁆𑀲𑀧𑁄 𑀅𑀦𑀼𑀲𑀸𑀲𑀢𑀺;

𑀓𑀫𑀮𑀸𑀲𑀤𑀺𑀲𑀺𑀢𑁆𑀣𑀺𑀬𑁄 [𑀲𑀭𑀺𑀲𑀺𑀢𑁆𑀣𑀺𑀬𑁄 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀢𑀸𑀬𑁄 𑀩𑀼𑀚𑁆𑀛𑁂𑀲𑀺 𑀫𑀸𑀡𑀯.

𑁧𑁩𑁩.

‘‘𑀉𑀭𑁂 𑀕𑀡𑁆𑀟𑀸𑀬𑁄 𑀩𑀼𑀚𑁆𑀛𑁂𑀲𑀺, 𑀢𑀸𑀬𑁄 𑀩𑀼𑀚𑁆𑀛𑁂𑀲𑀺 𑀫𑀸𑀡𑀯;

𑀇𑀘𑁆𑀘𑀸𑀦𑀼𑀲𑀸𑀲𑀺 𑀫𑀁 𑀢𑀸𑀢𑁄, 𑀬𑀣𑀸 𑀫𑀁 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑁄.

𑁧𑁩𑁪.

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

𑀅𑀭𑀜𑁆𑀜𑁂 𑀦𑀺𑀫𑁆𑀫𑀦𑀼𑀲𑁆𑀲𑀫𑁆𑀳𑀺, 𑀲𑁆𑀯𑀚𑁆𑀚 𑀛𑀸𑀬𑀸𑀫𑀺 [𑀲𑁆𑀯𑀸𑀚𑁆𑀚𑀚𑁆𑀛𑀸𑀬𑀸𑀫𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀏𑀓𑀓𑁄.

𑁧𑁩𑁫.

‘‘𑀲𑁄𑀳𑀁 ¶ 𑀢𑀣𑀸 𑀓𑀭𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀥𑀺𑀭𑀢𑁆𑀣𑀼 𑀚𑀻𑀯𑀺𑀢𑁂𑀦 𑀫𑁂;

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

𑁧𑁩𑁬.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀢𑁂𑀚𑀁 [𑀢𑁂𑀚𑀜𑁆𑀘 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑀻𑀭𑀺𑀬𑀜𑁆𑀘, 𑀥𑀺𑀢𑀺𑀁 [𑀥𑀺𑀢𑀺𑀜𑁆𑀘 (𑀧𑀻.)] 𑀜𑀢𑁆𑀯𑀸 𑀅𑀯𑀝𑁆𑀞𑀺𑀢𑀁 [𑀲𑀼𑀯𑀟𑁆𑀠𑀺𑀢𑀁 (𑀲𑀻.)];

𑀲𑀺𑀭𑀲𑀸 𑀅𑀕𑁆𑀕𑀳𑀻 𑀧𑀸𑀤𑁂, 𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑀁 𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀸.

𑁧𑁩𑁭.

‘‘𑀫𑀸 𑀫𑁂 𑀓𑀼𑀚𑁆𑀛 [𑀓𑀼𑀚𑁆𑀛𑀺 (𑀧𑀻.)] 𑀫𑀳𑀸𑀯𑀻𑀭, 𑀫𑀸 𑀫𑁂 𑀓𑀼𑀚𑁆𑀛 [𑀓𑀼𑀚𑁆𑀛𑀺 (𑀧𑀻.)] 𑀫𑀳𑀸𑀇𑀲𑁂;

𑀫𑀳𑀸 𑀅𑀢𑁆𑀣𑁄 𑀫𑀬𑀸 𑀘𑀺𑀡𑁆𑀡𑁄, 𑀢𑀺𑀤𑀲𑀸𑀦𑀁 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀁;

𑀢𑀬𑀸 𑀲𑀁𑀓𑀫𑁆𑀧𑀺𑀢𑀁 𑀆𑀲𑀺, 𑀲𑀩𑁆𑀩𑀁 𑀤𑁂𑀯𑀧𑀼𑀭𑀁 𑀢𑀤𑀸’’.

𑁧𑁩𑁮.

‘‘𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑀸 𑀘 𑀬𑁂 𑀤𑁂𑀯𑀸, 𑀢𑀺𑀤𑀲𑀸𑀦𑀜𑁆𑀘 𑀯𑀸𑀲𑀯𑁄;

𑀢𑁆𑀯𑀜𑁆𑀘 𑀪𑀤𑁆𑀤𑁂 𑀲𑀼𑀔𑀻 𑀳𑁄𑀳𑀺, 𑀕𑀘𑁆𑀙 𑀓𑀜𑁆𑀜𑁂 𑀬𑀣𑀸𑀲𑀼𑀔𑀁’’.

𑁧𑁩𑁯.

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

𑀅𑀜𑁆𑀚𑀮𑀺𑀁 𑀧𑀕𑁆𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀢𑀫𑁆𑀳𑀸 𑀞𑀸𑀦𑀸 𑀅𑀧𑀓𑁆𑀓𑀫𑀺.

𑁧𑁪𑁦.

‘‘𑀬𑁄 𑀘 𑀢𑀲𑁆𑀲𑀸𑀲𑀺 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑁄, 𑀲𑁄𑀯𑀡𑁆𑀡𑁄 𑀲𑁄𑀧𑀯𑀸𑀳𑀦𑁄;

𑀲𑀉𑀢𑁆𑀢𑀭𑀘𑁆𑀙𑀤𑀧𑀜𑁆𑀜𑀸𑀲𑁄, 𑀲𑀳𑀲𑁆𑀲𑀧𑀝𑀺𑀬𑀢𑁆𑀣𑀢𑁄;

𑀢𑀫𑁂𑀯 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑀫𑀸𑀭𑀼𑀬𑁆𑀳, 𑀅𑀕𑀸 𑀤𑁂𑀯𑀸𑀦 𑀲𑀦𑁆𑀢𑀺𑀓𑁂.

𑁧𑁪𑁧.

‘‘𑀢𑀫𑁄𑀓𑁆𑀓𑀫𑀺𑀯 𑀆𑀬𑀦𑁆𑀢𑀺𑀁, 𑀚𑀮𑀦𑁆𑀢𑀺𑀁 𑀯𑀺𑀚𑁆𑀚𑀼𑀢𑀁 𑀬𑀣𑀸;

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

𑁧𑁪𑁨.

‘‘𑀯𑀭𑀜𑁆𑀘𑁂 ¶ 𑀫𑁂 𑀅𑀤𑁄 𑀲𑀓𑁆𑀓, 𑀲𑀩𑁆𑀩𑀪𑀽𑀢𑀸𑀦𑀫𑀺𑀲𑁆𑀲𑀭;

𑀦𑀺𑀲𑀺𑀧𑁆𑀧𑀮𑁄𑀪𑀺𑀓𑀸 [𑀦 𑀇𑀲𑀺𑀧𑀮𑁄𑀪𑀺𑀓𑀸 (𑀲𑁆𑀬𑀸.), 𑀦 𑀇𑀲𑀺𑀧𑀮𑁄𑀪𑀺𑀬𑀁 (𑀧𑀻.)] 𑀕𑀘𑁆𑀙𑁂, 𑀏𑀢𑀁 𑀲𑀓𑁆𑀓 𑀯𑀭𑀁 𑀯𑀭𑁂’’𑀢𑀺.

𑀅𑀮𑀫𑁆𑀩𑀼𑀲𑀸𑀚𑀸𑀢𑀓𑀁 𑀢𑀢𑀺𑀬𑀁.

𑁫𑁨𑁪. 𑀲𑀗𑁆𑀔𑀧𑀸𑀮𑀚𑀸𑀢𑀓𑀁 (𑁪)

𑁧𑁪𑁩.

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

𑀓𑀣𑀁 𑀦𑀼 𑀯𑀺𑀢𑁆𑀢𑀸𑀦𑀺 𑀧𑀳𑀸𑀬 𑀪𑁄𑀕𑁂, 𑀧𑀩𑁆𑀩𑀚𑀺 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫 𑀖𑀭𑀸 𑀲𑀧𑀜𑁆𑀜’’ [𑀲𑀧𑀜𑁆𑀜𑁄 (𑀲𑁆𑀬𑀸.), 𑀲𑀧𑀜𑁆𑀜𑀸 (𑀧𑀻.)].

𑁧𑁪𑁪.

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

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

𑁧𑁪𑁫.

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

𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀏𑀢𑀫𑀢𑁆𑀣𑀁, 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀫𑁂 𑀚𑀸𑀬𑀺𑀳𑀺𑀢𑀺𑀧𑁆𑀧𑀲𑀸𑀤𑁄’’.

𑁧𑁪𑁬.

‘‘𑀯𑀸𑀡𑀺𑀚𑁆𑀚 [𑀯𑀡𑀺𑀚𑁆𑀚 (𑀧𑀻.)] 𑀭𑀝𑁆𑀞𑀸𑀥𑀺𑀧 𑀕𑀘𑁆𑀙𑀫𑀸𑀦𑁄, 𑀧𑀣𑁂 𑀅𑀤𑁆𑀤𑀲𑀸𑀲𑀺𑀫𑁆𑀳𑀺 𑀪𑁄𑀚𑀧𑀼𑀢𑁆𑀢𑁂 [𑀫𑀺𑀮𑀸𑀘𑀧𑀼𑀢𑁆𑀢𑁂 (𑀲𑀻. 𑀧𑀻.)];

𑀧𑀯𑀤𑁆𑀥𑀓𑀸𑀬𑀁 𑀉𑀭𑀕𑀁 𑀫𑀳𑀦𑁆𑀢𑀁, 𑀆𑀤𑀸𑀬 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑁂 𑀧𑀫𑁄𑀤𑀫𑀸𑀦𑁂’’.

𑁧𑁪𑁭.

‘‘𑀲𑁄𑀳𑀁 𑀲𑀫𑀸𑀕𑀫𑁆𑀫 𑀚𑀦𑀺𑀦𑁆𑀤 𑀢𑁂𑀳𑀺, 𑀧𑀳𑀝𑁆𑀞𑀮𑁄𑀫𑁄 𑀅𑀯𑀘𑀫𑁆𑀳𑀺 𑀪𑀻𑀢𑁄;

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

𑁧𑁪𑁮.

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

𑀲𑀸𑀤𑀼𑀜𑁆𑀘 𑀣𑀽𑀮𑀜𑁆𑀘 𑀫𑀼𑀤𑀼𑀜𑁆𑀘 𑀫𑀁𑀲𑀁, 𑀦 𑀢𑁆𑀯𑀁 𑀭𑀲𑀜𑁆𑀜𑀸𑀲𑀺 𑀯𑀺𑀤𑁂𑀳𑀧𑀼𑀢𑁆𑀢.

𑁧𑁪𑁯.

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

𑀫𑀁𑀲𑀸𑀦𑀺 𑀪𑁄𑀓𑁆𑀔𑀸𑀫 [𑀪𑀓𑁆𑀔𑀸𑀫 (𑀲𑁆𑀬𑀸.)] 𑀧𑀫𑁄𑀤𑀫𑀸𑀦𑀸, 𑀫𑀬𑀜𑁆𑀳𑀺 𑀯𑁂 𑀲𑀢𑁆𑀢𑀯𑁄 𑀧𑀦𑁆𑀦𑀕𑀸𑀦𑀁.

𑁧𑁫𑁦.

‘‘𑀲𑀘𑁂 𑀅𑀬𑀁 𑀦𑀻𑀬𑀢𑀺 𑀪𑁄𑀚𑀦𑀢𑁆𑀣𑀸, 𑀧𑀯𑀤𑁆𑀥𑀓𑀸𑀬𑁄 𑀉𑀭𑀕𑁄 𑀫𑀳𑀦𑁆𑀢𑁄;

𑀤𑀤𑀸𑀫𑀺 𑀯𑁄 𑀩𑀮𑀺𑀩𑀤𑁆𑀤𑀸𑀦𑀺 [𑀩𑀮𑀺𑀯𑀤𑁆𑀤𑀸𑀦𑀺 (𑀧𑀻.)] 𑀲𑁄𑀴𑀲, 𑀦𑀸𑀕𑀁 𑀇𑀫𑀁 𑀫𑀼𑀜𑁆𑀘𑀣 𑀩𑀦𑁆𑀥𑀦𑀲𑁆𑀫𑀸.

𑁧𑁫𑁧.

‘‘𑀅𑀤𑁆𑀥𑀸 ¶ 𑀳𑀺 𑀦𑁄 𑀪𑀓𑁆𑀔𑁄 𑀅𑀬𑀁 𑀫𑀦𑀸𑀧𑁄, 𑀩𑀳𑀽 𑀘 𑀦𑁄 𑀉𑀭𑀕𑀸 𑀪𑀼𑀢𑁆𑀢𑀧𑀼𑀩𑁆𑀩𑀸 [𑀩𑀳𑀼𑀁 𑀘 𑀦𑁄 𑀉𑀭𑀕𑁄 𑀪𑀼𑀢𑁆𑀢𑀧𑀼𑀩𑁆𑀩𑁄 (𑀓.)];

𑀓𑀭𑁄𑀫 𑀢𑁂 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀅𑀴𑀸𑀭 [𑀆𑀴𑀸𑀭 (𑀓.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺], 𑀫𑀺𑀢𑁆𑀢𑀜𑁆𑀘 𑀦𑁄 𑀳𑁄𑀳𑀺 𑀯𑀺𑀤𑁂𑀳𑀧𑀼𑀢𑁆𑀢.

𑁧𑁫𑁨.

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

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

𑁧𑁫𑁩.

‘‘𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀧𑀸𑀘𑀻𑀦𑀫𑀼𑀔𑁄 𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑀁, 𑀧𑀼𑀡𑁆𑀡𑁂𑀳𑀺 ¶ 𑀦𑁂𑀢𑁆𑀢𑁂𑀳𑀺 𑀧𑀮𑁄𑀓𑀬𑀻 𑀫𑀁;

𑀢𑀤𑀸𑀲𑁆𑀲𑀳𑀁 𑀧𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀅𑀦𑁆𑀯𑀕𑀘𑁆𑀙𑀺𑀁, 𑀤𑀲𑀗𑁆𑀕𑀼𑀮𑀺𑀁 𑀅𑀜𑁆𑀚𑀮𑀺𑀁 𑀧𑀕𑁆𑀕𑀳𑁂𑀢𑁆𑀯𑀸.

𑁧𑁫𑁪.

‘‘𑀕𑀘𑁆𑀙𑁂𑀯 ¶ 𑀔𑁄 𑀢𑁆𑀯𑀁 𑀢𑀭𑀫𑀸𑀦𑀭𑀽𑀧𑁄, 𑀫𑀸 𑀢𑀁 𑀅𑀫𑀺𑀢𑁆𑀢𑀸 𑀧𑀼𑀦𑀭𑀕𑁆𑀕𑀳𑁂𑀲𑀼𑀁;

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

𑁧𑁫𑁫.

‘‘𑀅𑀕𑀫𑀸𑀲𑀺 𑀲𑁄 𑀭𑀳𑀤𑀁 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀁, 𑀦𑀻𑀮𑁄𑀪𑀸𑀲𑀁 𑀭𑀫𑀡𑀻𑀬𑀁 𑀲𑀼𑀢𑀺𑀢𑁆𑀣𑀁;

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

𑁧𑁫𑁬.

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

𑀉𑀧𑀝𑁆𑀞𑀳𑀻 𑀫𑀁 𑀧𑀺𑀢𑀭𑀁𑀯 𑀧𑀼𑀢𑁆𑀢𑁄, 𑀳𑀤𑀬𑀗𑁆𑀕𑀫𑀁 𑀓𑀡𑁆𑀡𑀲𑀼𑀔𑀁 𑀪𑀡𑀦𑁆𑀢𑁄.

𑁧𑁫𑁭.

‘‘𑀢𑁆𑀯𑀁 ¶ 𑀫𑁂𑀲𑀺 𑀫𑀸𑀢𑀸 𑀘 𑀧𑀺𑀢𑀸 [𑀧𑀺𑀢𑀸 𑀘 (𑀧𑀻.)] 𑀅𑀴𑀸𑀭, 𑀅𑀩𑁆𑀪𑀦𑁆𑀢𑀭𑁄 𑀧𑀸𑀡𑀤𑀤𑁄 𑀲𑀳𑀸𑀬𑁄;

𑀲𑀓𑀜𑁆𑀘 𑀇𑀤𑁆𑀥𑀺𑀁 𑀧𑀝𑀺𑀮𑀸𑀪𑀓𑁄𑀲𑁆𑀫𑀺 [𑀧𑀝𑀺𑀮𑀸𑀪𑀺𑀢𑁄𑀲𑁆𑀫𑀺 (𑀧𑀻.)], 𑀅𑀴𑀸𑀭 𑀧𑀲𑁆𑀲 𑀫𑁂 𑀦𑀺𑀯𑁂𑀲𑀦𑀸𑀦𑀺;

𑀧𑀳𑀽𑀢𑀪𑀓𑁆𑀔𑀁 𑀩𑀳𑀼𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑀁, 𑀫𑀲𑀓𑁆𑀓𑀲𑀸𑀭𑀁 ¶ 𑀯𑀺𑀬 𑀯𑀸𑀲𑀯𑀲𑁆𑀲’’.

𑁧𑁫𑁮.

‘‘𑀢𑀁 𑀪𑀽𑀫𑀺𑀪𑀸𑀕𑁂𑀳𑀺 𑀉𑀧𑁂𑀢𑀭𑀽𑀧𑀁, 𑀅𑀲𑀓𑁆𑀔𑀭𑀸 𑀘𑁂𑀯 𑀫𑀼𑀤𑀽 𑀲𑀼𑀪𑀸 𑀘;

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

𑁧𑁫𑁯.

‘‘𑀅𑀦𑀸𑀯𑀓𑀼𑀮𑀸 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀽𑀧𑀦𑀻𑀮𑀸, 𑀘𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑀁 𑀅𑀫𑁆𑀩𑀯𑀦𑀁 𑀲𑀼𑀭𑀫𑁆𑀫𑀁;

𑀧𑀓𑁆𑀓𑀸 𑀘 𑀧𑁂𑀲𑀻 𑀘 𑀨𑀮𑀸 𑀲𑀼𑀨𑀼𑀮𑁆𑀮𑀸, 𑀦𑀺𑀘𑁆𑀘𑁄𑀢𑀼𑀓𑀸 𑀥𑀸𑀭𑀬𑀦𑁆𑀢𑀻 𑀨𑀮𑀸𑀦𑀺.

𑁧𑁬𑁦.

‘‘𑀢𑁂𑀲𑀁 𑀯𑀦𑀸𑀦𑀁 𑀦𑀭𑀤𑁂𑀯 𑀫𑀚𑁆𑀛𑁂, 𑀦𑀺𑀯𑁂𑀲𑀦𑀁 𑀪𑀲𑁆𑀲𑀭𑀲𑀦𑁆𑀦𑀺𑀓𑀸𑀲𑀁;

𑀭𑀚𑀢𑀕𑁆𑀕𑀴𑀁 𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑀁 𑀉𑀴𑀸𑀭𑀁, 𑀑𑀪𑀸𑀲𑀢𑀻 𑀯𑀺𑀚𑁆𑀚𑀼𑀭𑀺𑀯𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂.

𑁧𑁬𑁧.

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

𑀧𑀭𑀺𑀧𑀽𑀭𑀸 𑀓𑀜𑁆𑀜𑀸𑀳𑀺 𑀅𑀮𑀗𑁆𑀓𑀢𑀸𑀪𑀺, 𑀲𑀼𑀯𑀡𑁆𑀡𑀓𑀸𑀬𑀽𑀭𑀥𑀭𑀸𑀳𑀺 𑀭𑀸𑀚.

𑁧𑁬𑁨.

‘‘𑀲𑁄 𑀲𑀗𑁆𑀔𑀧𑀸𑀮𑁄 𑀢𑀭𑀫𑀸𑀦𑀭𑀽𑀧𑁄, 𑀧𑀸𑀲𑀸𑀤𑀫𑀸𑀭𑀼𑀬𑁆𑀳 𑀅𑀦𑁄𑀫𑀯𑀡𑁆𑀡𑁄;

𑀲𑀳𑀲𑁆𑀲𑀣𑀫𑁆𑀪𑀁 𑀅𑀢𑀼𑀮𑀸𑀦𑀼𑀪𑀸𑀯𑀁, 𑀬𑀢𑁆𑀣𑀲𑁆𑀲 ¶ 𑀪𑀭𑀺𑀬𑀸 𑀫𑀳𑁂𑀲𑀻 𑀅𑀳𑁄𑀲𑀺.

𑁧𑁬𑁩.

‘‘𑀏𑀓𑀸 ¶ 𑀘 𑀦𑀸𑀭𑀻 𑀢𑀭𑀫𑀸𑀦𑀭𑀽𑀧𑀸, 𑀆𑀤𑀸𑀬 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀫𑀬𑀁 𑀫𑀳𑀕𑁆𑀖𑀁;

𑀲𑀼𑀪𑀁 𑀫𑀡𑀺𑀁 𑀚𑀸𑀢𑀺𑀫𑀦𑁆𑀢𑀽𑀧𑀧𑀦𑁆𑀦𑀁, 𑀅𑀘𑁄𑀤𑀺𑀢𑀸 𑀆𑀲𑀦𑀫𑀩𑁆𑀪𑀺𑀳𑀸𑀲𑀺.

𑁧𑁬𑁪.

‘‘𑀢𑀢𑁄 𑀫𑀁 𑀉𑀭𑀕𑁄 𑀳𑀢𑁆𑀣𑁂 𑀕𑀳𑁂𑀢𑁆𑀯𑀸, 𑀦𑀺𑀲𑀻𑀤𑀬𑀻 𑀧𑀸𑀫𑀼𑀔𑀆𑀲𑀦𑀲𑁆𑀫𑀺𑀁;

𑀇𑀤𑀫𑀸𑀲𑀦𑀁 𑀅𑀢𑁆𑀭 𑀪𑀯𑀁 𑀦𑀺𑀲𑀻𑀤𑀢𑀼, 𑀪𑀯𑀜𑁆𑀳𑀺 𑀫𑁂 𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀕𑀭𑀽𑀦𑀁.

𑁧𑁬𑁫.

‘‘𑀅𑀜𑁆𑀜𑀸 𑀘 𑀦𑀸𑀭𑀻 𑀢𑀭𑀫𑀸𑀦𑀭𑀽𑀧𑀸, 𑀆𑀤𑀸𑀬 𑀯𑀸𑀭𑀺𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸;

𑀧𑀸𑀤𑀸𑀦𑀺 𑀧𑀓𑁆𑀔𑀸𑀮𑀬𑀻 𑀫𑁂 𑀚𑀦𑀺𑀦𑁆𑀤, 𑀪𑀭𑀺𑀬𑀸𑀯 [𑀪𑀭𑀺𑀬𑀸 𑀘 (𑀧𑀻.)] 𑀪𑀢𑁆𑀢𑀽 𑀧𑀢𑀺𑀦𑁄 𑀧𑀺𑀬𑀲𑁆𑀲.

𑁧𑁬𑁬.

‘‘𑀅𑀧𑀭𑀸 𑀘 𑀦𑀸𑀭𑀻 𑀢𑀭𑀫𑀸𑀦𑀭𑀽𑀧𑀸, 𑀧𑀕𑁆𑀕𑀬𑁆𑀳 𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑀸𑀬 [𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑀸 (𑀧𑀻.)] 𑀧𑀸𑀢𑀺𑀬𑀸;

𑀅𑀦𑁂𑀓𑀲𑀽𑀧𑀁 𑀯𑀺𑀯𑀺𑀥𑀁 𑀯𑀺𑀬𑀜𑁆𑀚𑀦𑀁, 𑀉𑀧𑀦𑀸𑀫𑀬𑀻 𑀪𑀢𑁆𑀢 𑀫𑀦𑀼𑀜𑁆𑀜𑀭𑀽𑀧𑀁.

𑁧𑁬𑁭.

‘‘𑀢𑀼𑀭𑀺𑀬𑁂𑀳𑀺 [𑀢𑀽𑀭𑀺𑀬𑁂𑀳𑀺 (𑀓.)] 𑀫𑀁 𑀪𑀸𑀭𑀢 𑀪𑀼𑀢𑁆𑀢𑀯𑀦𑁆𑀢𑀁, 𑀉𑀧𑀝𑁆𑀞𑀳𑀼𑀁 𑀪𑀢𑁆𑀢𑀼 𑀫𑀦𑁄 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸;

𑀢𑀢𑀼𑀢𑁆𑀢𑀭𑀺𑀁 [𑀢𑀤𑀼𑀢𑁆𑀢𑀭𑀺𑀁 (𑀓.)] 𑀫𑀁 𑀦𑀺𑀧𑀢𑀻 𑀫𑀳𑀦𑁆𑀢𑀁, 𑀤𑀺𑀩𑁆𑀩𑁂𑀳𑀺 ¶ 𑀓𑀸𑀫𑁂𑀳𑀺 𑀅𑀦𑀧𑁆𑀧𑀓𑁂𑀳𑀺.

𑁧𑁬𑁮.

‘‘𑀪𑀭𑀺𑀬𑀸 ¶ 𑀫𑀫𑁂𑀢𑀸 𑀢𑀺𑀲𑀢𑀸 𑀅𑀴𑀸𑀭, 𑀲𑀩𑁆𑀩𑀢𑁆𑀢𑀫𑀚𑁆𑀛𑀸 𑀧𑀤𑀼𑀫𑀼𑀢𑁆𑀢𑀭𑀸𑀪𑀸;

𑀅𑀴𑀸𑀭 𑀏𑀢𑀸𑀲𑁆𑀲𑀼 𑀢𑁂 𑀓𑀸𑀫𑀓𑀸𑀭𑀸, 𑀤𑀤𑀸𑀫𑀺 𑀢𑁂 𑀢𑀸 𑀧𑀭𑀺𑀘𑀸𑀭𑀬𑀲𑁆𑀲𑀼.

𑁧𑁬𑁯.

‘‘𑀲𑀁𑀯𑀘𑁆𑀙𑀭𑀁 𑀤𑀺𑀩𑁆𑀩𑀭𑀲𑀸𑀦𑀼𑀪𑀼𑀢𑁆𑀯𑀸, 𑀢𑀤𑀸𑀲𑁆𑀲𑀼𑀳𑀁 [𑀢𑀤𑀲𑁆𑀲𑀳𑀁 (𑀧𑀻.)] 𑀉𑀢𑁆𑀢𑀭𑀺𑀫𑀚𑁆𑀛𑀪𑀸𑀲𑀺𑀁 [𑀉𑀢𑁆𑀢𑀭𑀺 𑀧𑀘𑁆𑀘𑀪𑀸𑀲𑀺𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀉𑀢𑁆𑀢𑀭𑀺𑀁 𑀧𑀘𑁆𑀘𑀪𑀸𑀲𑀺𑀁 (𑀧𑀻.)];

𑀦𑀸𑀕𑀲𑁆𑀲𑀺𑀤𑀁 𑀓𑀺𑀦𑁆𑀢𑀺 𑀓𑀣𑀜𑁆𑀘 𑀮𑀤𑁆𑀥𑀁, 𑀓𑀣𑀚𑁆𑀛𑀕𑀫𑀸𑀲𑀺 𑀯𑀺𑀫𑀸𑀦𑀲𑁂𑀝𑁆𑀞𑀁’’.

𑁧𑁭𑁦.

‘‘𑀅𑀥𑀺𑀘𑁆𑀘 ¶ 𑀮𑀤𑁆𑀥𑀁 𑀧𑀭𑀺𑀡𑀸𑀫𑀚𑀁 𑀢𑁂, 𑀲𑀬𑀁𑀓𑀢𑀁 𑀉𑀤𑀸𑀳𑀼 𑀤𑁂𑀯𑁂𑀳𑀺 𑀤𑀺𑀦𑁆𑀦𑀁;

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 [𑀢𑁂 (𑀧𑀻.)] 𑀦𑀸𑀕𑀭𑀸𑀚𑁂𑀢𑀫𑀢𑁆𑀣𑀁, 𑀓𑀣𑀚𑁆𑀛𑀕𑀫𑀸𑀲𑀺 𑀯𑀺𑀫𑀸𑀦𑀲𑁂𑀝𑁆𑀞𑀁’’.

𑁧𑁭𑁧.

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

𑀲𑀓𑁂𑀳𑀺 𑀓𑀫𑁆𑀫𑁂𑀳𑀺 𑀅𑀧𑀸𑀧𑀓𑁂𑀳𑀺, 𑀧𑀼𑀜𑁆𑀜𑁂𑀳𑀺 𑀫𑁂 𑀮𑀤𑁆𑀥𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁’’.

𑁧𑁭𑁨.

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

𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀦𑀸𑀕𑀭𑀸𑀚𑁂𑀢𑀫𑀢𑁆𑀣𑀁, 𑀓𑀣𑀁 ¶ 𑀦𑀼 𑀢𑁂 𑀮𑀤𑁆𑀥𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁’’.

𑁧𑁭𑁩.

‘‘𑀭𑀸𑀚𑀸 𑀅𑀳𑁄𑀲𑀺𑀁 𑀫𑀕𑀥𑀸𑀦𑀫𑀺𑀲𑁆𑀲𑀭𑁄, 𑀤𑀼𑀬𑁆𑀬𑁄𑀥𑀦𑁄 𑀦𑀸𑀫 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁄;

𑀲𑁄 𑀇𑀢𑁆𑀢𑀭𑀁 𑀚𑀻𑀯𑀺𑀢𑀁 𑀲𑀁𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸, 𑀅𑀲𑀲𑁆𑀲𑀢𑀁 𑀯𑀺𑀧𑀭𑀺𑀡𑀸𑀫𑀥𑀫𑁆𑀫𑀁.

𑁧𑁭𑁪.

‘‘𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀤𑀸𑀲𑀺𑀁 [𑀅𑀤𑀸𑀲𑀺 (𑀧𑀻.)];

𑀑𑀧𑀸𑀦𑀪𑀽𑀢𑀁 𑀫𑁂 𑀖𑀭𑀁 𑀢𑀤𑀸𑀲𑀺, 𑀲𑀦𑁆𑀢𑀧𑁆𑀧𑀺𑀢𑀸 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀘.

𑁧𑁭𑁫.

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

𑀅𑀘𑁆𑀙𑀸𑀤𑀦𑀁 𑀲𑁂𑀬𑁆𑀬𑀫𑀣𑀦𑁆𑀦𑀧𑀸𑀦𑀁, 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀤𑀸𑀦𑀸𑀦𑀺 𑀅𑀤𑀫𑁆𑀳 𑀢𑀢𑁆𑀣 [𑀅𑀬𑀁 𑀕𑀸𑀣𑀸 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂 𑀦𑀢𑁆𑀣𑀺].

𑁧𑁭𑁬.

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

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

‘‘𑀦𑀘𑁆𑀘𑁂𑀳𑀺 𑀕𑀻𑀢𑁂𑀳𑀺 𑀘𑀼𑀧𑁂𑀢𑀭𑀽𑀧𑀁, 𑀘𑀺𑀭𑀝𑁆𑀞𑀺𑀢𑀺𑀓𑀁 𑀦 𑀘 𑀲𑀲𑁆𑀲𑀢𑀸𑀬𑀁.

𑁧𑁭𑁭.

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

𑀓𑀺𑀫𑁂𑀯 𑀤𑀸𑀞𑀸𑀯𑀼𑀥 𑀓𑀺𑀁 𑀧𑀝𑀺𑀘𑁆𑀘, 𑀳𑀢𑁆𑀣𑀢𑁆𑀢 [𑀳𑀢𑁆𑀣𑀢𑁆𑀣 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀸𑀕𑀘𑁆𑀙𑀺 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑀸𑀦𑀁 [𑀯𑀡𑀺𑀩𑁆𑀩𑀓𑀸𑀦𑀁 (𑀲𑀻.)].

𑁧𑁭𑁮.

‘‘𑀪𑀬𑀁 𑀦𑀼 𑀢𑁂 𑀅𑀦𑁆𑀯𑀕𑀢𑀁 𑀫𑀳𑀦𑁆𑀢𑀁, 𑀢𑁂𑀚𑁄 𑀦𑀼 𑀢𑁂 𑀦𑀸𑀦𑁆𑀯𑀕𑀁 𑀤𑀦𑁆𑀢𑀫𑀽𑀮𑀁;

𑀓𑀺𑀫𑁂𑀯 𑀤𑀸𑀞𑀸𑀯𑀼𑀥 𑀓𑀺𑀁 𑀧𑀝𑀺𑀘𑁆𑀘, 𑀓𑀺𑀮𑁂𑀲𑀫𑀸𑀧𑀚𑁆𑀚𑀺 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑀸𑀦𑀁’’.

𑁧𑁭𑁯.

‘‘𑀦 𑀫𑁂 𑀪𑀬𑀁 𑀅𑀦𑁆𑀯𑀕𑀢𑀁 𑀫𑀳𑀦𑁆𑀢𑀁, 𑀢𑁂𑀚𑁄 𑀦 𑀲𑀓𑁆𑀓𑀸 𑀫𑀫 𑀢𑁂𑀳𑀺 𑀳𑀦𑁆𑀢𑀼𑀁 [𑀢𑁂𑀪𑀺𑀳𑀦𑁆𑀢𑀼𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀲𑀢𑀜𑁆𑀘 𑀥𑀫𑁆𑀫𑀸𑀦𑀺 𑀲𑀼𑀓𑀺𑀢𑁆𑀢𑀺𑀢𑀸𑀦𑀺, 𑀲𑀫𑀼𑀤𑁆𑀤𑀯𑁂𑀮𑀸𑀯 𑀤𑀼𑀭𑀘𑁆𑀘𑀬𑀸𑀦𑀺.

𑁧𑁮𑁦.

‘‘𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀲𑀺𑀁 𑀧𑀜𑁆𑀘𑀤𑀲𑀺𑀁 𑀅𑀴𑀸𑀭, 𑀉𑀧𑁄𑀲𑀣𑀁 𑀦𑀺𑀘𑁆𑀘𑀫𑀼𑀧𑀸𑀯𑀲𑀸𑀫𑀺;

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

𑁧𑁮𑁧.

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

𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀤𑀼𑀓𑁆𑀔𑀫𑀳𑀁 𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀁 [𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀺𑀁 (𑀧𑀻.)], 𑀉𑀧𑁄𑀲𑀣𑀁 𑀅𑀧𑁆𑀧𑀝𑀺𑀓𑁄𑀧𑀬𑀦𑁆𑀢𑁄’’.

𑁧𑁮𑁨.

‘‘𑀏𑀓𑀸𑀬𑀦𑁂 ¶ ¶ 𑀢𑀁 𑀧𑀣𑁂 𑀅𑀤𑁆𑀤𑀲𑀁𑀲𑀼, 𑀩𑀮𑁂𑀦 ¶ 𑀯𑀡𑁆𑀡𑁂𑀦 𑀘𑀼𑀧𑁂𑀢𑀭𑀽𑀧𑀁;

𑀲𑀺𑀭𑀺𑀬𑀸 𑀧𑀜𑁆𑀜𑀸𑀬 𑀘 𑀪𑀸𑀯𑀺𑀢𑁄𑀲𑀺, 𑀓𑀺𑀁 𑀧𑀢𑁆𑀣𑀬𑀁 [𑀓𑀺𑀫𑀢𑁆𑀣𑀺𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀦𑀸𑀕 𑀢𑀧𑁄 𑀓𑀭𑁄𑀲𑀺.

𑁧𑁮𑁩.

‘‘𑀦 𑀧𑀼𑀢𑁆𑀢𑀳𑁂𑀢𑀽 𑀦 𑀥𑀦𑀲𑁆𑀲 𑀳𑁂𑀢𑀼, 𑀦 𑀆𑀬𑀼𑀦𑁄 𑀘𑀸𑀧𑀺 𑀅𑀴𑀸𑀭 𑀳𑁂𑀢𑀼;

𑀫𑀦𑀼𑀲𑁆𑀲𑀬𑁄𑀦𑀺𑀁 𑀅𑀪𑀺𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑁄, 𑀢𑀲𑁆𑀫𑀸 𑀧𑀭𑀓𑁆𑀓𑀫𑁆𑀫 𑀢𑀧𑁄 𑀓𑀭𑁄𑀫𑀺’’.

𑁧𑁮𑁪.

‘‘𑀢𑁆𑀯𑀁 𑀮𑁄𑀳𑀺𑀢𑀓𑁆𑀔𑁄 𑀯𑀺𑀳𑀢𑀦𑁆𑀢𑀭𑀁𑀲𑁄, 𑀅𑀮𑀗𑁆𑀓𑀢𑁄 𑀓𑀧𑁆𑀧𑀺𑀢𑀓𑁂𑀲𑀫𑀲𑁆𑀲𑀼;

𑀲𑀼𑀭𑁄𑀲𑀺𑀢𑁄 𑀮𑁄𑀳𑀺𑀢𑀘𑀦𑁆𑀤𑀦𑁂𑀦, 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑀭𑀸𑀚𑀸𑀯 𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀲𑀺 [𑀧𑀪𑀸𑀲𑀺 (𑀓.)].

𑁧𑁮𑁫.

‘‘𑀤𑁂𑀯𑀺𑀤𑁆𑀥𑀺𑀧𑀢𑁆𑀢𑁄𑀲𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁄, 𑀲𑀩𑁆𑀩𑁂𑀳𑀺 𑀓𑀸𑀫𑁂𑀳𑀺 𑀲𑀫𑀗𑁆𑀕𑀺𑀪𑀽𑀢𑁄;

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀦𑀸𑀕𑀭𑀸𑀚𑁂𑀢𑀫𑀢𑁆𑀣𑀁, 𑀲𑁂𑀬𑁆𑀬𑁄 𑀇𑀢𑁄 𑀓𑁂𑀦 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁄’’.

𑁧𑁮𑁬.

‘‘𑀅𑀴𑀸𑀭 𑀦𑀸𑀜𑁆𑀜𑀢𑁆𑀭 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑀸, 𑀲𑀼𑀤𑁆𑀥𑀻 𑀯 𑀲𑀁𑀯𑀺𑀚𑁆𑀚𑀢𑀺 𑀲𑀁𑀬𑀫𑁄 𑀯𑀸;

𑀅𑀳𑀜𑁆𑀘 𑀮𑀤𑁆𑀥𑀸𑀦 𑀫𑀦𑀼𑀲𑁆𑀲𑀬𑁄𑀦𑀺𑀁, 𑀓𑀸𑀳𑀸𑀫𑀺 𑀚𑀸𑀢𑀺𑀫𑀭𑀡𑀲𑁆𑀲 𑀅𑀦𑁆𑀢𑀁’’.

𑁧𑁮𑁭.

‘‘𑀲𑀁𑀯𑀘𑁆𑀙𑀭𑁄 ¶ 𑀫𑁂 𑀯𑀲𑀢𑁄 [𑀯𑀼𑀲𑀺𑀢𑁄 (𑀧𑀻.)] 𑀢𑀯𑀦𑁆𑀢𑀺𑀓𑁂, 𑀅𑀦𑁆𑀦𑁂𑀦 𑀧𑀸𑀦𑁂𑀦 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑁄𑀲𑁆𑀫𑀺;

𑀆𑀫𑀦𑁆𑀢𑀬𑀺𑀢𑁆𑀯𑀸𑀦 𑀧𑀮𑁂𑀫𑀺 𑀦𑀸𑀕, 𑀘𑀺𑀭𑀧𑁆𑀧𑀯𑀼𑀝𑁆𑀞𑁄𑀲𑁆𑀫𑀺 [𑀘𑀺𑀭𑀧𑁆𑀧𑀯𑀼𑀢𑁆𑀣𑁄 𑀅𑀲𑁆𑀫𑀺 (𑀧𑀻.)] 𑀅𑀳𑀁 𑀚𑀦𑀺𑀦𑁆𑀤’’.

𑁧𑁮𑁮.

‘‘𑀧𑀼𑀢𑁆𑀢𑀸 𑀘 𑀤𑀸𑀭𑀸 𑀅𑀦𑀼𑀚𑀻𑀯𑀺𑀦𑁄 𑀘 [𑀘’𑀦𑀼𑀚𑀻𑀯𑀺𑀦𑁄 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀦𑀺𑀘𑁆𑀘𑀸𑀦𑀼𑀲𑀺𑀝𑁆𑀞𑀸 𑀉𑀧𑀢𑀺𑀝𑁆𑀞𑀢𑁂 𑀢𑀁;

𑀓𑀘𑁆𑀘𑀺𑀦𑁆𑀦𑀼 𑀢𑀁 𑀦𑀸𑀪𑀺𑀲𑀧𑀺𑀢𑁆𑀣 [𑀦𑀸𑀪𑀺𑀲𑀁𑀲𑀺𑀢𑁆𑀣 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀓𑁄𑀘𑀺, 𑀧𑀺𑀬𑀜𑁆𑀳𑀺 𑀫𑁂 𑀤𑀲𑁆𑀲𑀦𑀁 𑀢𑀼𑀬𑁆𑀳𑀁 [𑀢𑀼𑀬𑁆𑀳 (𑀧𑀻.)] 𑀅𑀴𑀸𑀭’’.

𑁧𑁮𑁯.

‘‘𑀬𑀣𑀸𑀧𑀺 ¶ 𑀫𑀸𑀢𑀽 𑀘 𑀧𑀺𑀢𑀽 𑀅𑀕𑀸𑀭𑁂, 𑀧𑀼𑀢𑁆𑀢𑁄 𑀧𑀺𑀬𑁄 𑀧𑀝𑀺𑀯𑀺𑀳𑀺𑀢𑁄 𑀯𑀲𑁂𑀬𑁆𑀬 [𑀲𑁂𑀬𑁆𑀬𑁄 (𑀧𑀻.)];

𑀢𑀢𑁄𑀧𑀺 𑀫𑀬𑁆𑀳𑀁 𑀇𑀥𑀫𑁂𑀯 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀘𑀺𑀢𑁆𑀢𑀜𑁆𑀳𑀺 𑀢𑁂 𑀦𑀸𑀕 𑀫𑀬𑀻 𑀧𑀲𑀦𑁆𑀦𑀁’’.

𑁧𑁯𑁦.

‘‘𑀫𑀡𑀻 𑀫𑀫𑀁 𑀯𑀺𑀚𑁆𑀚𑀢𑀺 𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀓𑁄 [𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀕𑁄 (𑀓.)], 𑀥𑀦𑀸𑀳𑀭𑁄 𑀫𑀡𑀺𑀭𑀢𑀦𑀁 𑀉𑀴𑀸𑀭𑀁;

𑀆𑀤𑀸𑀬 𑀢𑁆𑀯𑀁 [𑀢𑀁 (𑀧𑀻.)] 𑀕𑀘𑁆𑀙 𑀲𑀓𑀁 𑀦𑀺𑀓𑁂𑀢𑀁, 𑀮𑀤𑁆𑀥𑀸 𑀥𑀦𑀁 𑀢𑀁 𑀫𑀡𑀺𑀫𑁄𑀲𑁆𑀲𑀚𑀲𑁆𑀲𑀼’’.

𑁧𑁯𑁧.

‘‘𑀤𑀺𑀝𑁆𑀞𑀸 𑀫𑀬𑀸 𑀫𑀸𑀦𑀼𑀲𑀓𑀸𑀧𑀺 𑀓𑀸𑀫𑀸, 𑀅𑀲𑀲𑁆𑀲𑀢𑀸 𑀯𑀺𑀧𑀭𑀺𑀡𑀸𑀫𑀥𑀫𑁆𑀫𑀸;

𑀆𑀤𑀻𑀦𑀯𑀁 𑀓𑀸𑀫𑀕𑀼𑀡𑁂𑀲𑀼 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀲𑀤𑁆𑀥𑀸𑀬𑀳𑀁 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄𑀫𑁆𑀳𑀺 𑀭𑀸𑀚.

𑁧𑁯𑁨.

‘‘𑀤𑀼𑀫𑀧𑁆𑀨𑀮𑀸𑀦𑀻𑀯 ¶ 𑀧𑀢𑀦𑁆𑀢𑀺 𑀫𑀸𑀡𑀯𑀸, 𑀤𑀳𑀭𑀸 𑀘 𑀯𑀼𑀤𑁆𑀥𑀸 𑀘 𑀲𑀭𑀻𑀭𑀪𑁂𑀤𑀸;

𑀏𑀢𑀫𑁆𑀧𑀺 𑀤𑀺𑀲𑁆𑀯𑀸 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄𑀫𑁆𑀳𑀺 𑀭𑀸𑀚, 𑀅𑀧𑀡𑁆𑀡𑀓𑀁 𑀲𑀸𑀫𑀜𑁆𑀜𑀫𑁂𑀯 𑀲𑁂𑀬𑁆𑀬𑁄’’.

𑁧𑁯𑁩.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀳𑀯𑁂 𑀲𑁂𑀯𑀺𑀢𑀩𑁆𑀩𑀸 𑀲𑀧𑀜𑁆𑀜𑀸, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑀸 𑀬𑁂 𑀩𑀳𑀼𑀞𑀸𑀦𑀘𑀺𑀦𑁆𑀢𑀺𑀦𑁄;

𑀦𑀸𑀕𑀜𑁆𑀘 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀢𑀯𑀜𑁆𑀘𑀴𑀸𑀭, 𑀓𑀸𑀳𑀸𑀫𑀺 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺 𑀅𑀦𑀧𑁆𑀧𑀓𑀸𑀦𑀺’’.

𑁧𑁯𑁪.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀳𑀯𑁂 𑀲𑁂𑀯𑀺𑀢𑀩𑁆𑀩𑀸 𑀲𑀧𑀜𑁆𑀜𑀸, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑀸 𑀬𑁂 𑀩𑀳𑀼𑀞𑀸𑀦𑀘𑀺𑀦𑁆𑀢𑀺𑀦𑁄;

𑀦𑀸𑀕𑀜𑁆𑀘 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀫𑀫𑀜𑁆𑀘 𑀭𑀸𑀚, 𑀓𑀭𑁄𑀳𑀺 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺 𑀅𑀦𑀧𑁆𑀧𑀓𑀸𑀦𑀻’’𑀢𑀺.

𑀲𑀗𑁆𑀔𑀧𑀸𑀮𑀚𑀸𑀢𑀓𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

𑁫𑁨𑁫. 𑀘𑀽𑀴𑀲𑀼𑀢𑀲𑁄𑀫𑀚𑀸𑀢𑀓𑀁 (𑁫)

𑁧𑁯𑁫.

‘‘𑀆𑀫𑀦𑁆𑀢𑀬𑀸𑀫𑀺 ¶ ¶ 𑀦𑀺𑀕𑀫𑀁, 𑀫𑀺𑀢𑁆𑀢𑀸𑀫𑀘𑁆𑀘𑁂 𑀧𑀭𑀺𑀲𑁆𑀲𑀚𑁂 [𑀧𑀸𑀭𑀺𑀲𑀚𑁆𑀚𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)];

𑀲𑀺𑀭𑀲𑁆𑀫𑀺𑀁 𑀧𑀮𑀺𑀢𑀁 𑀚𑀸𑀢𑀁, 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁 𑀤𑀸𑀦𑀺 𑀭𑁄𑀘𑀳𑀁’’.

𑁧𑁯𑁬.

‘‘𑀅𑀪𑀼𑀫𑁆𑀫𑁂 𑀓𑀣𑀁 𑀦𑀼 𑀪𑀡𑀲𑀺, 𑀲𑀮𑁆𑀮𑀁 𑀫𑁂 𑀤𑁂𑀯 𑀉𑀭𑀲𑀺 𑀓𑀧𑁆𑀧𑁂𑀲𑀺 [𑀓𑀫𑁆𑀧𑁂𑀲𑀺 (𑀧𑀻.)];

𑀲𑀢𑁆𑀢𑀲𑀢𑀸 𑀢𑁂 𑀪𑀭𑀺𑀬𑀸, 𑀓𑀣𑀁 ¶ 𑀦𑀼 𑀢𑁂 𑀢𑀸 𑀪𑀯𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺’’.

𑁧𑁯𑁭.

‘‘𑀧𑀜𑁆𑀜𑀸𑀬𑀺𑀳𑀺𑀦𑁆𑀢𑀺 𑀏𑀢𑀸, 𑀤𑀳𑀭𑀸 𑀅𑀜𑁆𑀜𑀫𑁆𑀧𑀺 𑀢𑀸 𑀕𑀫𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺;

𑀲𑀕𑁆𑀕𑀜𑁆𑀘𑀲𑁆𑀲 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑁄, 𑀢𑁂𑀦 𑀅𑀳𑀁 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺’’.

𑁧𑁯𑁮.

‘‘𑀤𑀼𑀮𑁆𑀮𑀤𑁆𑀥𑀁 𑀫𑁂 𑀆𑀲𑀺 𑀲𑀼𑀢𑀲𑁄𑀫, 𑀬𑀲𑁆𑀲 𑀢𑁂 𑀳𑁄𑀫𑀳𑀁 𑀫𑀸𑀢𑀸;

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

𑁧𑁯𑁯.

‘‘𑀤𑀼𑀮𑁆𑀮𑀤𑁆𑀥𑀁 𑀫𑁂 𑀆𑀲𑀺 𑀲𑀼𑀢𑀲𑁄𑀫, 𑀬𑀁 𑀢𑀁 𑀅𑀳𑀁 𑀯𑀺𑀚𑀸𑀬𑀺𑀲𑁆𑀲𑀁;

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

𑁨𑁦𑁦.

‘‘𑀓𑁄 𑀦𑀸𑀫𑁂𑀲𑁄 𑀥𑀫𑁆𑀫𑁄, 𑀲𑀼𑀢𑀲𑁄𑀫 𑀓𑀸 𑀘 𑀦𑀸𑀫 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀸;

𑀬𑀁 𑀦𑁄 𑀅𑀫𑁆𑀳𑁂 𑀚𑀺𑀡𑁆𑀡𑁂, 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑁄 𑀧𑀩𑁆𑀩𑀚𑀲𑀺 𑀤𑁂𑀯.

𑁨𑁦𑁧.

‘‘𑀧𑀼𑀢𑁆𑀢𑀸𑀧𑀺 𑀢𑀼𑀬𑁆𑀳𑀁 𑀩𑀳𑀯𑁄, 𑀤𑀳𑀭𑀸 𑀅𑀧𑁆𑀧𑀢𑁆𑀢𑀬𑁄𑀩𑁆𑀩𑀦𑀸;

𑀫𑀜𑁆𑀚𑀽 𑀢𑁂𑀧𑀺 [𑀢𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀢𑀁 𑀅𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀸, 𑀫𑀜𑁆𑀜𑁂 ¶ 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺’’.

𑁨𑁦𑁨.

‘‘𑀧𑀼𑀢𑁆𑀢𑁂𑀳𑀺 𑀘 𑀫𑁂 𑀏𑀢𑁂𑀳𑀺, 𑀤𑀳𑀭𑁂𑀳𑀺 𑀅𑀧𑁆𑀧𑀢𑁆𑀢𑀬𑁄𑀩𑁆𑀩𑀦𑁂𑀳𑀺;

𑀫𑀜𑁆𑀚𑀽𑀳𑀺 𑀲𑀩𑁆𑀩𑁂𑀳𑀺𑀧𑀺 𑀢𑀼𑀫𑁆𑀳𑁂𑀳𑀺, 𑀘𑀺𑀭𑀫𑁆𑀧𑀺 𑀞𑀢𑁆𑀯𑀸 𑀯𑀺𑀦𑀸𑀲𑀪𑀸𑀯𑁄’’ [𑀯𑀺𑀦𑀸𑀪𑀸𑀯𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑁨𑁦𑁩.

‘‘𑀙𑀺𑀦𑁆𑀦𑀁 ¶ 𑀦𑀼 𑀢𑀼𑀬𑁆𑀳𑀁 𑀳𑀤𑀬𑀁, 𑀅𑀤𑀼 𑀢𑁂 [𑀆𑀤𑀼 (𑀲𑀻. 𑀧𑀻.), 𑀆𑀤𑀽 (𑀲𑁆𑀬𑀸.)] 𑀓𑀭𑀼𑀡𑀸 𑀘 𑀦𑀢𑁆𑀣𑀺 𑀅𑀫𑁆𑀳𑁂𑀲𑀼;

𑀬𑀁 𑀦𑁄 𑀯𑀺𑀓𑀦𑁆𑀤𑀦𑁆𑀢𑀺𑀬𑁄 [𑀯𑀺𑀓𑁆𑀓𑀦𑁆𑀤𑀦𑁆𑀢𑀺𑀬𑁄 (𑀲𑀻.)], 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑁄 𑀧𑀩𑁆𑀩𑀚𑀲𑀺 𑀤𑁂𑀯’’.

𑁨𑁦𑁪.

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

𑀲𑀕𑁆𑀕𑀜𑁆𑀘 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑁄, 𑀢𑁂𑀦 𑀅𑀳𑀁 [𑀢𑁂𑀦𑀸𑀳𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀢𑁂𑀦𑀫𑀳𑀁 (𑀧𑀻.)] 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺’’.

𑁨𑁦𑁫.

‘‘𑀤𑀼𑀮𑁆𑀮𑀤𑁆𑀥𑀁 𑀫𑁂 𑀆𑀲𑀺, 𑀲𑀼𑀢𑀲𑁄𑀫 𑀬𑀲𑁆𑀲 𑀢𑁂 𑀅𑀳𑀁 𑀪𑀭𑀺𑀬𑀸;

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

𑁨𑁦𑁬.

‘‘𑀤𑀼𑀮𑁆𑀮𑀤𑁆𑀥𑀁 𑀫𑁂 𑀆𑀲𑀺, 𑀲𑀼𑀢𑀲𑁄𑀫 𑀬𑀲𑁆𑀲 𑀢𑁂 𑀅𑀳𑀁 𑀪𑀭𑀺𑀬𑀸;

𑀬𑀁 𑀫𑁂 𑀓𑀼𑀘𑁆𑀙𑀺𑀧𑀝𑀺𑀲𑀦𑁆𑀥𑀺𑀁 [𑀫𑀁 𑀓𑀼𑀘𑁆𑀙𑀺𑀫𑀢𑀺𑀁 𑀲𑀦𑁆𑀢𑀺𑀁 (𑀧𑀻.)], 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑁄 ¶ 𑀧𑀩𑁆𑀩𑀚𑀲𑀺 𑀤𑁂𑀯.

𑁨𑁦𑁭.

‘‘𑀧𑀭𑀺𑀧𑀓𑁆𑀓𑁄 𑀫𑁂 𑀕𑀩𑁆𑀪𑁄, 𑀓𑀼𑀘𑁆𑀙𑀺𑀕𑀢𑁄 𑀬𑀸𑀯 𑀦𑀁 𑀯𑀺𑀚𑀸𑀬𑀸𑀫𑀺;

𑀫𑀸𑀳𑀁 𑀏𑀓𑀸 𑀯𑀺𑀥𑀯𑀸, 𑀧𑀘𑁆𑀙𑀸 𑀤𑀼𑀓𑁆𑀔𑀸𑀦𑀺 𑀅𑀤𑁆𑀤𑀓𑁆𑀔𑀺𑀁’’.

𑁨𑁦𑁮.

‘‘𑀧𑀭𑀺𑀧𑀓𑁆𑀓𑁄 𑀢𑁂 𑀕𑀩𑁆𑀪𑁄, 𑀓𑀼𑀘𑁆𑀙𑀺𑀕𑀢𑁄 𑀇𑀗𑁆𑀖 𑀢𑁆𑀯𑀁 [𑀢𑁆𑀯 (𑀲𑀻.), 𑀦𑀁 (𑀧𑀻.)] 𑀯𑀺𑀚𑀸𑀬𑀲𑁆𑀲𑀼;

𑀧𑀼𑀢𑁆𑀢𑀁 𑀅𑀦𑁄𑀫𑀯𑀡𑁆𑀡𑀁, 𑀢𑀁 𑀳𑀺𑀢𑁆𑀯𑀸 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺’’.

𑁨𑁦𑁯.

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

𑀆𑀭𑁄𑀳 𑀯𑀭𑀧𑀸𑀲𑀸𑀤𑀁 [𑀘 𑀧𑀸𑀲𑀸𑀤𑀁 (𑀧𑀻.)], 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑁄 𑀅𑀳𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺’’.

𑁨𑁧𑁦.

‘‘𑀓𑁄 ¶ 𑀢𑀁 𑀅𑀫𑁆𑀫 𑀓𑁄𑀧𑁂𑀲𑀺, 𑀓𑀺𑀁 𑀭𑁄𑀤𑀲𑀺 𑀧𑁂𑀓𑁆𑀔𑀲𑀺 𑀘 𑀫𑀁 𑀩𑀸𑀴𑁆𑀳𑀁;

𑀓𑀁 𑀅𑀯𑀚𑁆𑀛𑀁 𑀖𑀸𑀢𑁂𑀫𑀺 [𑀖𑀸𑀢𑁂𑀫𑀺 𑀓𑀁 𑀅𑀯𑀚𑁆𑀛𑀁 (𑀧𑀻.), 𑀢𑀁 𑀅𑀯𑀚𑁆𑀛𑀁 𑀖𑀸𑀢𑁂𑀫𑀺 (𑀓.)], 𑀜𑀸𑀢𑀻𑀦𑀁 𑀉𑀤𑀺𑀓𑁆𑀔𑀫𑀸𑀦𑀸𑀦𑀁’’.

𑁨𑁧𑁧.

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

𑀧𑀺𑀢𑀸 𑀢𑁂 𑀫𑀁 𑀢𑀸𑀢 𑀅𑀯𑀘, 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑁄 ¶ 𑀅𑀳𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺’’.

𑁨𑁧𑁨.

‘‘𑀬𑁄𑀳𑀁 𑀧𑀼𑀩𑁆𑀩𑁂 𑀦𑀺𑀬𑁆𑀬𑀸𑀫𑀺, 𑀉𑀬𑁆𑀬𑀸𑀦𑀁 𑀫𑀢𑁆𑀢𑀓𑀼𑀜𑁆𑀚𑀭𑁂 𑀘 𑀬𑁄𑀥𑁂𑀫𑀺;

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

𑁨𑁧𑁩.

‘‘𑀫𑀸𑀢𑀼𑀘𑁆𑀘 [𑀫𑀸𑀢𑀼 𑀘 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀫𑁂 𑀭𑀼𑀤𑀦𑁆𑀢𑁆𑀬𑀸 [𑀭𑀼𑀤𑀢𑁆𑀬𑀸 (𑀧𑀻.)], 𑀚𑁂𑀝𑁆𑀞𑀲𑁆𑀲 𑀘 𑀪𑀸𑀢𑀼𑀦𑁄 𑀅𑀓𑀸𑀫𑀲𑁆𑀲;

𑀳𑀢𑁆𑀣𑁂𑀧𑀺 𑀢𑁂 𑀕𑀳𑁂𑀲𑁆𑀲𑀁, 𑀦 𑀳𑀺 𑀕𑀘𑁆𑀙𑀲𑀺 [𑀕𑀜𑁆𑀙𑀺𑀲𑀺 (𑀧𑀻.)] 𑀦𑁄 𑀅𑀓𑀸𑀫𑀸𑀦𑀁’’.

𑁨𑁧𑁪.

‘‘𑀉𑀝𑁆𑀞𑁂𑀳𑀺 𑀢𑁆𑀯𑀁 𑀥𑀸𑀢𑀺, 𑀇𑀫𑀁 𑀓𑀼𑀫𑀸𑀭𑀁 𑀭𑀫𑁂𑀳𑀺 𑀅𑀜𑁆𑀜𑀢𑁆𑀣;

𑀫𑀸 𑀫𑁂 𑀧𑀭𑀺𑀧𑀦𑁆𑀣𑀫𑀓𑀸𑀲𑀺 [𑀫𑀓𑀸 (𑀲𑀻. 𑀧𑀻.)], 𑀲𑀕𑁆𑀕𑀁 𑀫𑀫 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑀲𑁆𑀲’’.

𑁨𑁧𑁫.

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

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

𑁨𑁧𑁬.

‘‘𑀓𑁄𑀲𑁄 ¶ 𑀘 𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀺𑀧𑀼𑀮𑁄, 𑀓𑁄𑀝𑁆𑀞𑀸𑀕𑀸𑀭𑀜𑁆𑀘 𑀢𑀼𑀬𑁆𑀳𑀁 𑀧𑀭𑀺𑀧𑀽𑀭𑀁;

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

𑁨𑁧𑁭.

‘‘𑀓𑁄𑀲𑁄 𑀘 𑀫𑀬𑁆𑀳𑀁 𑀯𑀺𑀧𑀼𑀮𑁄, 𑀓𑁄𑀝𑁆𑀞𑀸𑀕𑀸𑀭𑀜𑁆𑀘 𑀫𑀬𑁆𑀳𑀁 𑀧𑀭𑀺𑀧𑀽𑀭𑀁;

𑀧𑀣𑀯𑀻 𑀘 𑀫𑀬𑁆𑀳𑀁 𑀯𑀺𑀚𑀺𑀢𑀸, 𑀢𑀁 𑀳𑀺𑀢𑁆𑀯𑀸 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺’’.

𑁨𑁧𑁮.

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

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

𑁨𑁧𑁯.

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

𑀲𑀕𑁆𑀕𑀜𑁆𑀘 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑁄, 𑀢𑁂𑀦 𑀅𑀳𑀁 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺’’.

𑁨𑁨𑁦.

‘‘𑀉𑀓𑁆𑀓𑀡𑁆𑀞𑀺𑀢𑁄𑀲𑁆𑀫𑀺 𑀩𑀸𑀴𑁆𑀳𑀁, 𑀅𑀭𑀢𑀺 𑀫𑀁 𑀲𑁄𑀫𑀤𑀢𑁆𑀢 𑀆𑀯𑀺𑀲𑀢𑀺 [𑀆𑀯𑀻𑀲𑀢𑀺 (𑀓.)];

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

𑁨𑁨𑁧.

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

𑀅𑀳𑀫𑁆𑀧𑀺 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀦 ¶ 𑀉𑀲𑁆𑀲𑀳𑁂 𑀢𑀬𑀸 𑀯𑀺𑀦𑀸 𑀅𑀳𑀁 𑀞𑀸𑀢𑀼𑀁’’.

𑁨𑁨𑁨.

‘‘𑀦 𑀳𑀺 𑀲𑀓𑁆𑀓𑀸 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀼𑀁, 𑀦𑀕𑀭𑁂 𑀦 𑀳𑀺 𑀧𑀘𑁆𑀘𑀢𑀺 𑀚𑀦𑀧𑀤𑁂 𑀘’’;

‘‘𑀲𑀼𑀢𑀲𑁄𑀫𑁂 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁂, 𑀓𑀣𑀁 𑀦𑀼 𑀤𑀸𑀦𑀺 𑀓𑀭𑀺𑀲𑁆𑀲𑀸𑀫’’.

𑁨𑁨𑁩.

‘‘𑀉𑀧𑀦𑀻𑀬𑀢𑀺𑀤𑀁 𑀫𑀜𑁆𑀜𑁂, 𑀧𑀭𑀺𑀢𑁆𑀢𑀁 𑀉𑀤𑀓𑀁𑀯 𑀘𑀗𑁆𑀓𑀯𑀸𑀭𑀫𑁆𑀳𑀺;

𑀏𑀯𑀁 𑀲𑀼𑀧𑀭𑀺𑀢𑁆𑀢𑀓𑁂 𑀚𑀻𑀯𑀺𑀢𑁂, 𑀦 𑀘 𑀧𑀫𑀚𑁆𑀚𑀺𑀢𑀼𑀁 𑀓𑀸𑀮𑁄.

𑁨𑁨𑁪.

‘‘𑀉𑀧𑀦𑀻𑀬𑀢𑀺𑀤𑀁 ¶ 𑀫𑀜𑁆𑀜𑁂, 𑀧𑀭𑀺𑀢𑁆𑀢𑀁 𑀉𑀤𑀓𑀁𑀯 𑀘𑀗𑁆𑀓𑀯𑀸𑀭𑀫𑁆𑀳𑀺;

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

𑁨𑁨𑁫.

‘‘𑀢𑁂 𑀯𑀟𑁆𑀠𑀬𑀦𑁆𑀢𑀺 𑀦𑀺𑀭𑀬𑀁, 𑀢𑀺𑀭𑀘𑁆𑀙𑀸𑀦𑀬𑁄𑀦𑀺𑀜𑁆𑀘 𑀧𑁂𑀢𑁆𑀢𑀺𑀯𑀺𑀲𑀬𑀜𑁆𑀘;

𑀢𑀡𑁆𑀳𑀸𑀬 𑀩𑀦𑁆𑀥𑀦𑀩𑀤𑁆𑀥𑀸, 𑀯𑀟𑁆𑀠𑁂𑀦𑁆𑀢𑀺 𑀅𑀲𑀼𑀭𑀓𑀸𑀬𑀁’’.

𑁨𑁨𑁬.

‘‘𑀊𑀳𑀜𑁆𑀜𑀢𑁂 ¶ 𑀭𑀚𑀕𑁆𑀕𑀁, 𑀅𑀯𑀺𑀤𑀽𑀭𑁂 𑀧𑀼𑀩𑁆𑀩𑀓𑀫𑁆𑀳𑀺 𑀘 [𑀧𑀼𑀧𑁆𑀨𑀓𑀫𑁆𑀳𑀺 𑀘 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀸𑀲𑀸𑀤𑁂;

𑀫𑀜𑁆𑀜𑁂 𑀦𑁄 𑀓𑁂𑀲𑀸 𑀙𑀺𑀦𑁆𑀦𑀸, 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄 ¶ 𑀥𑀫𑁆𑀫𑀭𑀸𑀚𑀲𑁆𑀲’’.

𑁨𑁨𑁭.

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

𑀬𑀳𑀺 [𑀬𑀫𑁆𑀳𑀺 (𑀧𑀻.)] 𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑁂𑀳𑀺.

𑁨𑁨𑁮.

‘‘𑀅𑀬𑀫𑀲𑁆𑀲 𑀧𑀸𑀲𑀸𑀤𑁄, 𑀲𑁄𑀯𑀡𑁆𑀡𑀧𑀼𑀧𑁆𑀨𑀫𑀸𑀮𑁆𑀬𑀯𑀻𑀢𑀺𑀓𑀺𑀡𑁆𑀡𑁄;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀦.

𑁨𑁨𑁯.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀁, 𑀲𑁄𑀯𑀡𑁆𑀡𑀧𑀼𑀧𑁆𑀨𑀫𑀸𑀮𑁆𑀬𑀯𑀻𑀢𑀺𑀓𑀺𑀡𑁆𑀡𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑁂𑀳𑀺.

𑁨𑁩𑁦.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑀁, 𑀲𑁄𑀯𑀡𑁆𑀡 [𑀲𑁄𑀯𑀡𑁆𑀡𑀁 (𑀧𑀻.)] 𑀧𑀼𑀧𑁆𑀨𑀫𑀸𑀮𑁆𑀬𑀯𑀻𑀢𑀺𑀓𑀺𑀡𑁆𑀡𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀦.

𑁨𑁩𑁧.

‘‘𑀅𑀬𑀫𑀲𑁆𑀲 𑀅𑀲𑁄𑀓𑀯𑀦𑀺𑀓𑀸, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀸 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀸 𑀭𑀫𑁆𑀫𑀸;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 ¶ 𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑁂𑀳𑀺.

𑁨𑁩𑁨.

‘‘𑀅𑀬𑀫𑀲𑁆𑀲 𑀅𑀲𑁄𑀓𑀯𑀦𑀺𑀓𑀸, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀸 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀸 𑀭𑀫𑁆𑀫𑀸;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀦.

𑁨𑁩𑁩.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀉𑀬𑁆𑀬𑀸𑀦𑀁, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁 𑀭𑀫𑁆𑀫𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑁂𑀳𑀺.

𑁨𑁩𑁪.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀉𑀬𑁆𑀬𑀸𑀦𑀁, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁 𑀭𑀫𑁆𑀫𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀦.

𑁨𑁩𑁫.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀓𑀡𑀺𑀓𑀸𑀭𑀯𑀦𑀁, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁 𑀭𑀫𑁆𑀫𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑁂𑀳𑀺.

𑁨𑁩𑁬.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀓𑀡𑀺𑀓𑀸𑀭𑀯𑀦𑀁, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁 𑀭𑀫𑁆𑀫𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 ¶ 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀦.

𑁨𑁩𑁭.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀧𑀸𑀝𑀮𑀺𑀯𑀦𑀁 [𑀧𑀸𑀝𑀮𑀻𑀯𑀦𑀁 (𑀲𑀻.)], 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁 𑀭𑀫𑁆𑀫𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑁂𑀳𑀺.

𑁨𑁩𑁮.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀧𑀸𑀝𑀮𑀺𑀯𑀦𑀁, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁 𑀭𑀫𑁆𑀫𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀦.

𑁨𑁩𑁯.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 ¶ ¶ 𑀅𑀫𑁆𑀩𑀯𑀦𑀁, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁 𑀭𑀫𑁆𑀫𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑁂𑀳𑀺.

𑁨𑁪𑁦.

‘‘𑀇𑀤𑀫𑀲𑁆𑀲 𑀅𑀫𑁆𑀩𑀯𑀦𑀁, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀺𑀓𑀁 𑀭𑀫𑁆𑀫𑀁;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀦.

𑁨𑁪𑁧.

‘‘𑀅𑀬𑀫𑀲𑁆𑀲 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻, 𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸 𑀅𑀡𑁆𑀟𑀚𑁂𑀳𑀺 𑀯𑀻𑀢𑀺𑀓𑀺𑀡𑁆𑀡𑀸;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 ¶ 𑀇𑀢𑁆𑀣𑀸𑀕𑀸𑀭𑁂𑀳𑀺.

𑁨𑁪𑁨.

‘‘𑀅𑀬𑀫𑀲𑁆𑀲 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻, 𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸 𑀅𑀡𑁆𑀟𑀚𑁂𑀳𑀺 𑀯𑀻𑀢𑀺𑀓𑀺𑀡𑁆𑀡𑀸;

𑀬𑀳𑀺𑀫𑀦𑀼𑀯𑀺𑀘𑀭𑀺 𑀭𑀸𑀚𑀸, 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑁄 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀦’’.

𑁨𑁪𑁩.

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

𑀓𑀸𑀲𑀸𑀬𑀯𑀢𑁆𑀣𑀯𑀲𑀦𑁄, 𑀦𑀸𑀕𑁄𑀯 𑀏𑀓𑀓𑁄 [𑀏𑀓𑀓𑁄𑀯 (𑀲𑀻.)] 𑀘𑀭𑀢𑀺’’.

𑁨𑁪𑁪.

‘‘𑀫𑀸𑀲𑁆𑀲𑀼 𑀧𑀼𑀩𑁆𑀩𑁂 𑀭𑀢𑀺𑀓𑀻𑀴𑀺𑀢𑀸𑀦𑀺, 𑀳𑀲𑀺𑀢𑀸𑀦𑀺 𑀘 𑀅𑀦𑀼𑀲𑁆𑀲𑀭𑀺𑀢𑁆𑀣 [𑀅𑀦𑀼𑀲𑁆𑀲𑀭𑀺𑀢𑁆𑀣𑁄 (𑀧𑀻.)];

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

𑁨𑁪𑁫.

‘‘𑀫𑁂𑀢𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑀜𑁆𑀘 [𑀫𑁂𑀢𑁆𑀢𑀜𑁆𑀘 (𑀧𑀻.)] 𑀪𑀸𑀯𑁂𑀣, 𑀅𑀧𑁆𑀧𑀫𑀸𑀡𑀁 𑀤𑀺𑀯𑀸 𑀘 𑀭𑀢𑁆𑀢𑁄 𑀘;

𑀅𑀕𑀘𑁆𑀙𑀺𑀢𑁆𑀣 [𑀅𑀣 𑀕𑀜𑁆𑀙𑀺𑀢𑁆𑀣 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀤𑁂𑀯𑀧𑀼𑀭, 𑀆𑀯𑀸𑀲𑀁 𑀧𑀼𑀜𑁆𑀜𑀓𑀫𑁆𑀫𑀺𑀦’’𑀦𑁆𑀢𑀺 [𑀧𑀼𑀜𑁆𑀜𑀓𑀫𑁆𑀫𑀸𑀦𑀦𑁆𑀢𑀺 (𑀧𑀻.)].

𑀘𑀽𑀴𑀲𑀼𑀢𑀲𑁄𑀫𑀚𑀸𑀢𑀓𑀁 𑀧𑀜𑁆𑀘𑀫𑀁.

𑀘𑀢𑁆𑀢𑀸𑀮𑀻𑀲𑀦𑀺𑀧𑀸𑀢𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀢𑀲𑁆𑀲𑀼𑀤𑁆𑀤𑀸𑀦𑀁 𑁋

𑀲𑀼𑀯𑀧𑀡𑁆𑀟𑀺𑀢𑀚𑀫𑁆𑀩𑀼𑀓𑀓𑀼𑀡𑁆𑀟𑀮𑀺𑀦𑁄 ¶ , 𑀯𑀭𑀓𑀜𑁆𑀜𑀫𑀮𑀫𑁆𑀩𑀼𑀲𑀚𑀸𑀢𑀓𑀜𑁆𑀘;

𑀧𑀯𑀭𑀼𑀢𑁆𑀢𑀫𑀲𑀗𑁆𑀔𑀲𑀺𑀭𑀻𑀯𑁆𑀳𑀬𑀓𑁄, 𑀲𑀼𑀢𑀲𑁄𑀫𑀅𑀭𑀺𑀦𑁆𑀥𑀫𑀭𑀸𑀚𑀯𑀭𑁄.

𑁧𑁮. 𑀧𑀡𑁆𑀡𑀸𑀲𑀦𑀺𑀧𑀸𑀢𑁄

𑁫𑁨𑁬. 𑀦𑀺𑀴𑀺𑀦𑀺𑀓𑀸𑀚𑀸𑀢𑀓𑀁 (𑁧)

𑁧.

‘‘𑀉𑀤𑁆𑀤𑀬𑁆𑀳𑀢𑁂 ¶ ¶ ¶ [𑀉𑀟𑁆𑀟𑀬𑁆𑀳𑀢𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀚𑀦𑀧𑀤𑁄, 𑀭𑀝𑁆𑀞𑀜𑁆𑀘𑀸𑀧𑀺 𑀯𑀺𑀦𑀲𑁆𑀲𑀢𑀺;

𑀏𑀳𑀺 𑀦𑀺𑀴𑀺𑀦𑀺𑀓𑁂 [𑀦𑀺𑀴𑀺𑀓𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] 𑀕𑀘𑁆𑀙, 𑀢𑀁 𑀫𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀫𑀸𑀦𑀬’’.

𑁨.

‘‘𑀦𑀸𑀳𑀁 𑀤𑀼𑀓𑁆𑀔𑀓𑁆𑀔𑀫𑀸 𑀭𑀸𑀚, 𑀦𑀸𑀳𑀁 𑀅𑀤𑁆𑀥𑀸𑀦𑀓𑁄𑀯𑀺𑀤𑀸;

𑀓𑀣𑀁 𑀅𑀳𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀯𑀦𑀁 𑀓𑀼𑀜𑁆𑀚𑀭𑀲𑁂𑀯𑀺𑀢𑀁’’.

𑁩.

‘‘𑀨𑀻𑀢𑀁 𑀚𑀦𑀧𑀤𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀳𑀢𑁆𑀣𑀺𑀦𑀸 𑀘 𑀭𑀣𑁂𑀦 𑀘;

𑀤𑀸𑀭𑀼𑀲𑀗𑁆𑀖𑀸𑀝𑀬𑀸𑀦𑁂𑀦, 𑀏𑀯𑀁 𑀕𑀘𑁆𑀙 𑀦𑀺𑀴𑀺𑀦𑀺𑀓𑁂.

𑁪.

‘‘𑀳𑀢𑁆𑀣𑀺𑀅𑀲𑁆𑀲𑀭𑀣𑁂 𑀧𑀢𑁆𑀢𑀻, 𑀕𑀘𑁆𑀙𑁂𑀯𑀸𑀤𑀸𑀬 𑀔𑀢𑁆𑀢𑀺𑀬𑁂;

𑀢𑀯𑁂𑀯 𑀯𑀡𑁆𑀡𑀭𑀽𑀧𑁂𑀦, 𑀯𑀲𑀁 𑀢𑀫𑀸𑀦𑀬𑀺𑀲𑁆𑀲𑀲𑀺’’.

𑁫.

‘‘𑀓𑀤𑀮𑀻𑀥𑀚𑀧𑀜𑁆𑀜𑀸𑀡𑁄, 𑀆𑀪𑀼𑀚𑀻𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑁄;

𑀏𑀲𑁄 𑀧𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀭𑀫𑁆𑀫𑁄, 𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑀲𑁆𑀲 𑀅𑀲𑁆𑀲𑀫𑁄.

𑁬.

‘‘𑀏𑀲𑁄 𑀅𑀕𑁆𑀕𑀺𑀲𑁆𑀲 𑀲𑀗𑁆𑀔𑀸𑀢𑁄, 𑀏𑀲𑁄 𑀥𑀽𑀫𑁄 𑀧𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀫𑀜𑁆𑀜𑁂 𑀦𑁄 𑀅𑀕𑁆𑀕𑀺𑀁 𑀳𑀸𑀧𑁂𑀢𑀺, 𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑁄 𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑁄’’.

𑁭.

‘‘𑀢𑀜𑁆𑀘 ¶ 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀆𑀬𑀦𑁆𑀢𑀺𑀁, 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀁;

𑀇𑀲𑀺𑀲𑀺𑀗𑁆𑀕𑁄 𑀧𑀸𑀯𑀺𑀲𑀺 𑀪𑀻𑀢𑁄, 𑀅𑀲𑁆𑀲𑀫𑀁 𑀧𑀡𑁆𑀡𑀙𑀸𑀤𑀦𑀁.

𑁮.

‘‘𑀅𑀲𑁆𑀲𑀫𑀲𑁆𑀲 𑀘 𑀲𑀸 𑀤𑁆𑀯𑀸𑀭𑁂, 𑀕𑁂𑀡𑁆𑀟𑀼𑀓𑁂𑀦𑀲𑁆𑀲 [𑀪𑁂𑀡𑁆𑀟𑀼𑀓𑁂𑀦𑀲𑁆𑀲 (𑀲𑀻. 𑀧𑀻.)] 𑀓𑀻𑀴𑀢𑀺;

𑀯𑀺𑀤𑀁𑀲𑀬𑀦𑁆𑀢𑀻 𑀅𑀗𑁆𑀕𑀸𑀦𑀺, 𑀕𑀼𑀬𑁆𑀳𑀁 𑀧𑀓𑀸𑀲𑀺𑀢𑀸𑀦𑀺 𑀘.

𑁯.

‘‘𑀢𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀓𑀻𑀴𑀦𑁆𑀢𑀺𑀁, 𑀧𑀡𑁆𑀡𑀲𑀸𑀮𑀕𑀢𑁄 𑀚𑀝𑀻;

𑀅𑀲𑁆𑀲𑀫𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑀺𑀢𑁆𑀯𑀸𑀦, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺.

𑁧𑁦.

‘‘𑀅𑀫𑁆𑀪𑁄 𑀓𑁄 𑀦𑀸𑀫 𑀲𑁄 𑀭𑀼𑀓𑁆𑀔𑁄, 𑀬𑀲𑁆𑀲 𑀢𑁂𑀯𑀁𑀕𑀢𑀁 𑀨𑀮𑀁;

𑀤𑀽𑀭𑁂𑀧𑀺 𑀔𑀺𑀢𑁆𑀢𑀁 𑀧𑀘𑁆𑀘𑁂𑀢𑀺, 𑀦 𑀢𑀁 𑀑𑀳𑀸𑀬 𑀕𑀘𑁆𑀙𑀢𑀺’’.

𑁧𑁧.

‘‘𑀅𑀲𑁆𑀲𑀫𑀲𑁆𑀲 ¶ 𑀫𑀫 [𑀫𑀁 (𑀲𑀻.)] 𑀩𑁆𑀭𑀳𑁆𑀫𑁂, 𑀲𑀫𑀻𑀧𑁂 𑀕𑀦𑁆𑀥𑀫𑀸𑀤𑀦𑁂;

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

𑀤𑀽𑀭𑁂𑀧𑀺 𑀔𑀺𑀢𑁆𑀢𑀁 𑀧𑀘𑁆𑀘𑁂𑀢𑀺, 𑀦 𑀫𑀁 𑀑𑀳𑀸𑀬 𑀕𑀘𑁆𑀙𑀢𑀺’’.

𑁧𑁨.

‘‘𑀏𑀢𑀽 ¶ [𑀏𑀢𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)] 𑀪𑀯𑀁 𑀅𑀲𑁆𑀲𑀫𑀺𑀫𑀁 𑀅𑀤𑁂𑀢𑀼, 𑀧𑀚𑁆𑀚𑀜𑁆𑀘 𑀪𑀓𑁆𑀔𑀜𑁆𑀘 𑀧𑀝𑀺𑀘𑁆𑀙 𑀤𑀫𑁆𑀫𑀺;

𑀇𑀤𑀫𑀸𑀲𑀦𑀁 𑀅𑀢𑁆𑀭 𑀪𑀯𑀁 𑀦𑀺𑀲𑀻𑀤𑀢𑀼, 𑀇𑀢𑁄 𑀪𑀯𑀁 𑀫𑀽𑀮𑀨𑀮𑀸𑀦𑀺 𑀪𑀼𑀜𑁆𑀚𑀢𑀼’’ [𑀔𑀸𑀤𑀢𑀼 (𑀲𑀻.)].

𑁧𑁩.

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

𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀏𑀢𑀫𑀢𑁆𑀣𑀁, 𑀓𑁄𑀲𑁂 𑀦𑀼 𑀢𑁂 𑀉𑀢𑁆𑀢𑀫𑀗𑁆𑀕𑀁 𑀧𑀯𑀺𑀝𑁆𑀞𑀁’’.

𑁧𑁪.

‘‘𑀅𑀳𑀁 𑀯𑀦𑁂 𑀫𑀽𑀮𑀨𑀮𑁂𑀲𑀦𑀁 𑀘𑀭𑀁, 𑀆𑀲𑀸𑀤𑀬𑀺𑀁 ¶ [𑀅𑀲𑁆𑀲𑀸𑀤𑀬𑀺𑀁 (𑀓.)] 𑀅𑀘𑁆𑀙𑀁 𑀲𑀼𑀖𑁄𑀭𑀭𑀽𑀧𑀁;

𑀲𑁄 𑀫𑀁 𑀧𑀢𑀺𑀢𑁆𑀯𑀸 𑀲𑀳𑀲𑀸𑀚𑁆𑀛𑀧𑀢𑁆𑀢𑁄, 𑀧𑀦𑀼𑀚𑁆𑀚 𑀫𑀁 𑀅𑀩𑁆𑀩𑀳𑀺 [𑀅𑀩𑁆𑀩𑀼𑀳𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀉𑀢𑁆𑀢𑀫𑀗𑁆𑀕𑀁.

𑁧𑁫.

‘‘𑀲𑁆𑀯𑀸𑀬𑀁 𑀯𑀡𑁄 𑀔𑀚𑁆𑀚𑀢𑀺 𑀓𑀡𑁆𑀟𑀼𑀯𑀸𑀬𑀢𑀺, 𑀲𑀩𑁆𑀩𑀜𑁆𑀘 𑀓𑀸𑀮𑀁 𑀦 𑀮𑀪𑀸𑀫𑀺 𑀲𑀸𑀢𑀁;

𑀧𑀳𑁄 𑀪𑀯𑀁 𑀓𑀡𑁆𑀟𑀼𑀫𑀺𑀫𑀁 𑀯𑀺𑀦𑁂𑀢𑀼𑀁, 𑀓𑀼𑀭𑀼𑀢𑀁 𑀪𑀯𑀁 𑀬𑀸𑀘𑀺𑀢𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀢𑁆𑀣𑀁’’.

𑁧𑁬.

‘‘𑀕𑀫𑁆𑀪𑀻𑀭𑀭𑀽𑀧𑁄 𑀢𑁂 𑀯𑀡𑁄 𑀲𑀮𑁄𑀳𑀺𑀢𑁄, 𑀅𑀧𑀽𑀢𑀺𑀓𑁄 𑀯𑀡𑀕𑀦𑁆𑀥𑁄 [𑀧𑀓𑁆𑀓𑀕𑀦𑁆𑀥𑁄 (𑀲𑀻.), 𑀧𑀦𑁆𑀦𑀕𑀦𑁆𑀥𑁄 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀳𑀸 𑀘;

𑀓𑀭𑁄𑀫𑀺 𑀢𑁂 𑀓𑀺𑀜𑁆𑀘𑀺 𑀓𑀲𑀸𑀬𑀬𑁄𑀕𑀁, 𑀬𑀣𑀸 𑀪𑀯𑀁 𑀧𑀭𑀫𑀲𑀼𑀔𑀻 𑀪𑀯𑁂𑀬𑁆𑀬’’.

𑁧𑁭.

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

𑀖𑀝𑁆𑀝𑁂 𑀫𑀼𑀤𑀼𑀓𑁂𑀦 [𑀬𑀁 𑀢𑁂 𑀫𑀼𑀤𑀼 𑀢𑁂𑀦 (𑀲𑀻.), 𑀬𑀁 𑀢𑁂 𑀫𑀼𑀤𑀽 𑀢𑁂𑀦 (𑀧𑀻.)] 𑀯𑀺𑀦𑁂𑀳𑀺 𑀓𑀡𑁆𑀟𑀼𑀁 [𑀓𑀡𑁆𑀟𑀼𑀓𑀁 (𑀧𑀻.)], 𑀬𑀣𑀸 𑀅𑀳𑀁 𑀧𑀭𑀫𑀲𑀼𑀔𑀻 𑀪𑀯𑁂𑀬𑁆𑀬𑀁’’.

𑁧𑁮.

‘‘𑀇𑀢𑁄 𑀦𑀼 𑀪𑁄𑀢𑁄 𑀓𑀢𑀫𑁂𑀦 𑀅𑀲𑁆𑀲𑀫𑁄, 𑀓𑀘𑁆𑀘𑀺 𑀪𑀯𑀁 𑀅𑀪𑀺𑀭𑀫𑀲𑀺 [𑀅𑀪𑀺𑀭𑀫𑀲𑀻 (𑀧𑀻.)] 𑀅𑀭𑀜𑁆𑀜𑁂;

𑀓𑀘𑁆𑀘𑀺 𑀦𑀼 𑀢𑁂 [𑀓𑀘𑁆𑀘𑀺 𑀢𑁂 (𑀧𑀻.)] 𑀫𑀽𑀮𑀨𑀮𑀁 𑀧𑀳𑀽𑀢𑀁, 𑀓𑀘𑁆𑀘𑀺 𑀪𑀯𑀦𑁆𑀢𑀁 𑀦 𑀯𑀺𑀳𑀺𑀁𑀲𑀦𑁆𑀢𑀺 𑀯𑀸𑀴𑀸’’.

𑁧𑁯.

‘‘𑀇𑀢𑁄 ¶ 𑀉𑀚𑀼𑀁 𑀉𑀢𑁆𑀢𑀭𑀸𑀬𑀁 𑀤𑀺𑀲𑀸𑀬𑀁, 𑀔𑁂𑀫𑀸𑀦𑀤𑀻 𑀳𑀺𑀫𑀯𑀢𑀸 𑀧𑀪𑀸𑀯𑀻 [𑀧𑀪𑀸𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀢𑀲𑁆𑀲𑀸 𑀢𑀻𑀭𑁂 𑀅𑀲𑁆𑀲𑀫𑁄 𑀫𑀬𑁆𑀳 𑀭𑀫𑁆𑀫𑁄, 𑀅𑀳𑁄 𑀪𑀯𑀁 𑀅𑀲𑁆𑀲𑀫𑀁 𑀫𑀬𑁆𑀳𑀁 𑀧𑀲𑁆𑀲𑁂.

𑁨𑁦.

‘‘𑀅𑀫𑁆𑀩𑀸 𑀘 𑀲𑀸𑀮𑀸 𑀢𑀺𑀮𑀓𑀸 𑀘 𑀚𑀫𑁆𑀩𑀼𑀬𑁄, 𑀉𑀤𑁆𑀤𑀸𑀮𑀓𑀸 𑀧𑀸𑀝𑀮𑀺𑀬𑁄 𑀘 𑀨𑀼𑀮𑁆𑀮𑀸;

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

𑁨𑁧.

‘‘𑀢𑀸𑀮𑀸 𑀘 𑀫𑀽𑀮𑀸 𑀘 𑀨𑀮𑀸 𑀘 𑀫𑁂𑀢𑁆𑀣, 𑀯𑀡𑁆𑀡𑁂𑀦 𑀕𑀦𑁆𑀥𑁂𑀦 𑀉𑀧𑁂𑀢𑀭𑀽𑀧𑀁;

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

𑁨𑁧.

‘‘𑀨𑀮𑀸 𑀘 𑀫𑀽𑀮𑀸 𑀘 𑀧𑀳𑀽𑀢𑀫𑁂𑀢𑁆𑀣, 𑀯𑀡𑁆𑀡𑁂𑀦 𑀕𑀦𑁆𑀥𑁂𑀦 𑀭𑀲𑁂𑀦𑀼𑀧𑁂𑀢𑀸;

𑀆𑀬𑀦𑁆𑀢𑀺 𑀘 𑀮𑀼𑀤𑁆𑀤𑀓𑀸 𑀢𑀁 𑀧𑀤𑁂𑀲𑀁, 𑀫𑀸 𑀫𑁂 𑀢𑀢𑁄 𑀫𑀽𑀮𑀨𑀮𑀁 𑀅𑀳𑀸𑀲𑀼𑀁’’.

𑁨𑁩.

‘‘𑀧𑀺𑀢𑀸 𑀫𑀫𑀁 𑀫𑀽𑀮𑀨𑀮𑁂𑀲𑀦𑀁 𑀕𑀢𑁄, 𑀇𑀤𑀸𑀦𑀺 𑀆𑀕𑀘𑁆𑀙𑀢𑀺 𑀲𑀸𑀬𑀓𑀸𑀮𑁂;

𑀉𑀪𑁄𑀯 𑀕𑀘𑁆𑀙𑀸𑀫𑀲𑁂 𑀅𑀲𑁆𑀲𑀫𑀁 𑀢𑀁, 𑀬𑀸𑀯 ¶ 𑀧𑀺𑀢𑀸 𑀫𑀽𑀮𑀨𑀮𑀢𑁄 𑀏𑀢𑀼’’.

𑁨𑁪.

‘‘𑀅𑀜𑁆𑀜𑁂 ¶ 𑀩𑀳𑀽 𑀇𑀲𑀬𑁄 𑀲𑀸𑀥𑀼𑀭𑀽𑀧𑀸, 𑀭𑀸𑀚𑀻𑀲𑀬𑁄 𑀅𑀦𑀼𑀫𑀕𑁆𑀕𑁂 𑀯𑀲𑀦𑁆𑀢𑀺;

𑀢𑁂 𑀬𑁂𑀯 𑀧𑀼𑀘𑁆𑀙𑁂𑀲𑀺 𑀫𑀫𑀲𑁆𑀲𑀫𑀁 𑀢𑀁, 𑀢𑁂 𑀢𑀁 𑀦𑀬𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀫𑀫𑀁 𑀲𑀓𑀸𑀲𑁂’’.

𑁨𑁫.

‘‘𑀦 𑀢𑁂 𑀓𑀝𑁆𑀞𑀸𑀦𑀺 𑀪𑀺𑀦𑁆𑀦𑀸𑀦𑀺, 𑀦 𑀢𑁂 𑀉𑀤𑀓𑀫𑀸𑀪𑀢𑀁;

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

𑁨𑁬.

‘‘𑀪𑀺𑀦𑁆𑀦𑀸𑀦𑀺 𑀓𑀝𑁆𑀞𑀸𑀦𑀺 𑀳𑀼𑀢𑁄 𑀘 𑀅𑀕𑁆𑀕𑀺, 𑀢𑀧𑀦𑀻𑀧𑀺 𑀢𑁂 𑀲𑀫𑀺𑀢𑀸 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀻 [𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺 (?)];

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

𑁨𑁭.

‘‘𑀅𑀪𑀺𑀦𑁆𑀦𑀓𑀝𑁆𑀞𑁄𑀲𑀺 ¶ 𑀅𑀦𑀸𑀪𑀢𑁄𑀤𑀓𑁄, 𑀅𑀳𑀸𑀧𑀺𑀢𑀕𑁆𑀕𑀻𑀲𑀺 [𑀅𑀳𑀸𑀧𑀺𑀢𑀕𑁆𑀕𑀻𑀧𑀺 (𑀓.)] 𑀅𑀲𑀺𑀤𑁆𑀥𑀪𑁄𑀚𑀦𑁄 [𑀅𑀲𑀺𑀝𑁆𑀞𑀪𑁄𑀚𑀦𑁄 (𑀓.)];

𑀦 𑀫𑁂 𑀢𑀼𑀯𑀁 𑀆𑀮𑀧𑀲𑀻 𑀫𑀫𑀚𑁆𑀚, 𑀦𑀝𑁆𑀞𑀁 𑀦𑀼 𑀓𑀺𑀁 𑀘𑁂𑀢𑀲𑀺𑀓𑀜𑁆𑀘 𑀤𑀼𑀓𑁆𑀔𑀁’’.

𑁨𑁮.

‘‘𑀇𑀥𑀸𑀕𑀫𑀸 𑀚𑀝𑀺𑀮𑁄 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀻, 𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑁄 𑀲𑀼𑀢𑀦𑀽 𑀯𑀺𑀦𑁂𑀢𑀺;

𑀦𑁂𑀯𑀸𑀢𑀺𑀤𑀻𑀖𑁄 𑀦 𑀧𑀦𑀸𑀢𑀺𑀭𑀲𑁆𑀲𑁄, 𑀲𑀼𑀓𑀡𑁆𑀳𑀓𑀡𑁆𑀳𑀘𑁆𑀙𑀤𑀦𑁂𑀳𑀺 𑀪𑁄𑀢𑁄.

𑁨𑁯.

‘‘𑀅𑀫𑀲𑁆𑀲𑀼𑀚𑀸𑀢𑁄 ¶ 𑀅𑀧𑀼𑀭𑀸𑀡𑀯𑀡𑁆𑀡𑀻, 𑀆𑀥𑀸𑀭𑀭𑀽𑀧𑀜𑁆𑀘 𑀧𑀦𑀲𑁆𑀲 𑀓𑀡𑁆𑀞𑁂;

𑀤𑁆𑀯𑁂 𑀬𑀫𑀸 [𑀤𑁆𑀯𑁂 𑀧𑀲𑁆𑀲 (𑀲𑀻.), 𑀤𑁆𑀯𑀸𑀲𑁆𑀲 (𑀧𑀻.)] 𑀕𑀡𑁆𑀟𑀸 𑀉𑀭𑁂𑀲𑀼 𑀚𑀸𑀢𑀸, 𑀲𑀼𑀯𑀡𑁆𑀡𑀢𑀺𑀦𑁆𑀤𑀼𑀓𑀦𑀺𑀪𑀸 [𑀲𑀼𑀯𑀡𑁆𑀡𑀧𑀺𑀦𑁆𑀤𑀽𑀧𑀦𑀺𑀪𑀸 (𑀲𑀻.), 𑀲𑀼𑀯𑀡𑁆𑀡𑀢𑀺𑀡𑁆𑀟𑀼𑀲𑀦𑁆𑀦𑀺𑀪𑀸 (𑀲𑁆𑀬𑀸.), 𑀲𑁄𑀯𑀦𑁆𑀦𑀧𑀺𑀡𑁆𑀟𑀽𑀧𑀦𑀺𑀪𑀸 (𑀧𑀻.)] 𑀧𑀪𑀲𑁆𑀲𑀭𑀸.

𑁩𑁦.

‘‘𑀫𑀼𑀔𑀜𑁆𑀘 𑀢𑀲𑁆𑀲 𑀪𑀼𑀲𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀁, 𑀓𑀡𑁆𑀡𑁂𑀲𑀼 𑀮𑀫𑁆𑀩𑀦𑁆𑀢𑀺 𑀘 𑀓𑀼𑀜𑁆𑀘𑀺𑀢𑀕𑁆𑀕𑀸;

𑀢𑁂 𑀚𑁄𑀢𑀭𑁂 𑀘𑀭𑀢𑁄 𑀫𑀸𑀡𑀯𑀲𑁆𑀲, 𑀲𑀼𑀢𑁆𑀢𑀜𑁆𑀘 𑀬𑀁 𑀲𑀁𑀬𑀫𑀦𑀁 𑀚𑀝𑀸𑀦𑀁.

𑁩𑁧.

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

𑀢𑀸 𑀧𑀺𑀁𑀲𑀭𑁂 [𑀲𑀁𑀲𑀭𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀘𑀭𑀢𑁄 𑀫𑀸𑀡𑀯𑀲𑁆𑀲, 𑀢𑀺𑀭𑀺𑀝𑀺 [𑀘𑀺𑀭𑀻𑀝𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀗𑁆𑀖𑀸𑀭𑀺𑀯 𑀧𑀸𑀯𑀼𑀲𑀫𑁆𑀳𑀺.

𑁩𑁨.

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

𑀢𑀸 𑀚𑁄𑀢𑀭𑁂 𑀚𑀖𑀦𑀦𑁆𑀢𑀭𑁂 [𑀚𑀖𑀦𑀯𑀭𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑀺𑀮𑀕𑁆𑀕𑀸, 𑀲𑀢𑁂𑀭𑀢𑀸 𑀯𑀺𑀚𑁆𑀚𑀼𑀭𑀺𑀯𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂.

𑁩𑁩.

‘‘𑀅𑀔𑀻𑀮𑀓𑀸𑀦𑀺 𑀘 𑀅𑀯𑀡𑁆𑀝𑀓𑀸𑀦𑀺, 𑀳𑁂𑀝𑁆𑀞𑀸 𑀦𑀪𑁆𑀬𑀸 𑀓𑀝𑀺𑀲𑀫𑁄𑀳𑀺𑀢𑀸𑀦𑀺;

𑀅𑀖𑀝𑁆𑀝𑀺𑀢𑀸 𑀦𑀺𑀘𑁆𑀘𑀓𑀻𑀴𑀁 𑀓𑀭𑁄𑀦𑁆𑀢𑀺, 𑀳𑀁 𑀢𑀸𑀢 𑀓𑀺𑀁𑀭𑀼𑀓𑁆𑀔𑀨𑀮𑀸𑀦𑀺 𑀢𑀸𑀦𑀺.

𑁩𑁪.

‘‘𑀚𑀝𑀸 ¶ 𑀘 𑀢𑀲𑁆𑀲 𑀪𑀼𑀲𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀸, 𑀧𑀭𑁄𑀲𑀢𑀁 𑀯𑁂𑀮𑁆𑀮𑀺𑀢𑀕𑁆𑀕𑀸 𑀲𑀼𑀕𑀦𑁆𑀥𑀸;

𑀤𑁆𑀯𑁂𑀥𑀸 𑀲𑀺𑀭𑁄 𑀲𑀸𑀥𑀼 𑀯𑀺𑀪𑀢𑁆𑀢𑀭𑀽𑀧𑁄, 𑀅𑀳𑁄 𑀦𑀼 𑀔𑁄 𑀫𑀬𑁆𑀳 𑀢𑀣𑀸 𑀚𑀝𑀸𑀲𑁆𑀲𑀼.

𑁩𑁫.

‘‘𑀬𑀤𑀸 𑀘 𑀲𑁄 𑀧𑀓𑀺𑀭𑀢𑀺 𑀢𑀸 𑀚𑀝𑀸𑀬𑁄, 𑀯𑀡𑁆𑀡𑁂𑀦 𑀕𑀦𑁆𑀥𑁂𑀦 𑀉𑀧𑁂𑀢𑀭𑀽𑀧𑀸;

𑀦𑀻𑀮𑀼𑀧𑁆𑀧𑀮𑀁 𑀯𑀸𑀢𑀲𑀫𑁂𑀭𑀺𑀢𑀁𑀯, 𑀢𑀣𑁂𑀯 𑀲𑀁𑀯𑀸𑀢𑀺 𑀧𑀦𑀲𑁆𑀲𑀫𑁄 𑀅𑀬𑀁.

𑁩𑁬.

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

𑀲𑁄 𑀯𑀸𑀬𑀢𑀻 𑀏𑀭𑀺𑀢𑁄 𑀫𑀸𑀮𑀼𑀢𑁂𑀦, 𑀯𑀦𑀁 𑀬𑀣𑀸 𑀅𑀕𑁆𑀕𑀕𑀺𑀫𑁆𑀳𑁂 𑀲𑀼𑀨𑀼𑀮𑁆𑀮𑀁.

𑁩𑁭.

‘‘𑀦𑀺𑀳𑀦𑁆𑀢𑀺 ¶ 𑀲𑁄 𑀭𑀼𑀓𑁆𑀔𑀨𑀮𑀁 𑀧𑀣𑀩𑁆𑀬𑀸, 𑀲𑀼𑀘𑀺𑀢𑁆𑀢𑀭𑀽𑀧𑀁 𑀭𑀼𑀘𑀺𑀭𑀁 𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀁;

𑀔𑀺𑀢𑁆𑀢𑀜𑁆𑀘 𑀢𑀲𑁆𑀲 𑀧𑀼𑀦𑀭𑁂𑀢𑀺 𑀳𑀢𑁆𑀣𑀁, 𑀳𑀁 𑀢𑀸𑀢 𑀓𑀺𑀁𑀭𑀼𑀓𑁆𑀔𑀨𑀮𑀁 𑀦𑀼 𑀔𑁄 𑀢𑀁.

𑁩𑁮.

‘‘𑀤𑀦𑁆𑀢𑀸 𑀘 𑀢𑀲𑁆𑀲 𑀪𑀼𑀲𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀸, 𑀲𑀼𑀤𑁆𑀥𑀸 𑀲𑀫𑀸 𑀲𑀗𑁆𑀔𑀯𑀭𑀽𑀧𑀧𑀦𑁆𑀦𑀸;

𑀫𑀦𑁄 𑀧𑀲𑀸𑀤𑁂𑀦𑁆𑀢𑀺 𑀯𑀺𑀯𑀭𑀺𑀬𑀫𑀸𑀦𑀸, 𑀦 𑀳𑀺 [𑀦 𑀳 (𑀲𑀻. 𑀧𑀻.)] 𑀦𑀽𑀦 𑀲𑁄 𑀲𑀸𑀓𑀫𑀔𑀸𑀤𑀺 𑀢𑁂𑀳𑀺.

𑁩𑁯.

‘‘𑀅𑀓𑀓𑁆𑀓𑀲𑀁 ¶ 𑀅𑀕𑁆𑀕𑀴𑀺𑀢𑀁 𑀫𑀼𑀳𑀼𑀁 𑀫𑀼𑀤𑀼𑀁, 𑀉𑀚𑀼𑀁 𑀅𑀦𑀼𑀤𑁆𑀥𑀢𑀁 𑀅𑀘𑀧𑀮𑀫𑀲𑁆𑀲 𑀪𑀸𑀲𑀺𑀢𑀁;

𑀭𑀼𑀤𑀁 𑀫𑀦𑀼𑀜𑁆𑀜𑀁 𑀓𑀭𑀯𑀻𑀓𑀲𑀼𑀲𑁆𑀲𑀭𑀁, 𑀳𑀤𑀬𑀗𑁆𑀕𑀫𑀁 𑀭𑀜𑁆𑀚𑀬𑀢𑁂𑀯 𑀫𑁂 𑀫𑀦𑁄.

𑁪𑁦.

‘‘𑀩𑀺𑀦𑁆𑀤𑀼𑀲𑁆𑀲𑀭𑁄 𑀦𑀸𑀢𑀺𑀯𑀺𑀲𑀝𑁆𑀞𑀯𑀸𑀓𑁆𑀬𑁄 [𑀦𑀸𑀢𑀺𑀯𑀺𑀲𑁆𑀲𑀝𑁆𑀞𑀯𑀸𑀓𑁆𑀬𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀦 𑀦𑀽𑀦 𑀲𑀚𑁆𑀛𑀸𑀬𑀫𑀢𑀺𑀧𑁆𑀧𑀬𑀼𑀢𑁆𑀢𑁄;

𑀇𑀘𑁆𑀙𑀸𑀫𑀺 𑀪𑁄 [𑀔𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀢𑀁 𑀧𑀼𑀦𑀤𑁂𑀯 𑀤𑀝𑁆𑀞𑀼𑀁, 𑀫𑀺𑀢𑁆𑀢𑁄 𑀳𑀺 [𑀫𑀺𑀢𑁆𑀢𑀁 𑀳𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑁂 𑀫𑀸𑀡𑀯𑁄𑀳𑀼 [𑀫𑀸𑀡𑀯𑀸𑀳𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀫𑀸𑀡𑀯𑀸𑀳𑀽 (𑀧𑀻.)] 𑀧𑀼𑀭𑀢𑁆𑀣𑀸.

𑁪𑁧.

‘‘𑀲𑀼𑀲𑀦𑁆𑀥𑀺 ¶ 𑀲𑀩𑁆𑀩𑀢𑁆𑀣 𑀯𑀺𑀫𑀝𑁆𑀞𑀺𑀫𑀁 𑀯𑀡𑀁, 𑀧𑀼𑀣𑀽 [𑀧𑀼𑀣𑀼𑀁 (𑀧𑀻.), 𑀧𑀼𑀣𑀼 (𑀓.)] 𑀲𑀼𑀚𑀸𑀢𑀁 𑀔𑀭𑀧𑀢𑁆𑀢𑀲𑀦𑁆𑀦𑀺𑀪𑀁;

𑀢𑁂𑀦𑁂𑀯 𑀫𑀁 𑀉𑀢𑁆𑀢𑀭𑀺𑀬𑀸𑀦 𑀫𑀸𑀡𑀯𑁄, 𑀯𑀺𑀯𑀭𑀺𑀢𑀁 𑀊𑀭𑀼𑀁 𑀚𑀖𑀦𑁂𑀦 𑀧𑀻𑀴𑀬𑀺.

𑁪𑁨.

‘‘𑀢𑀧𑀦𑁆𑀢𑀺 𑀆𑀪𑀦𑁆𑀢𑀺 𑀯𑀺𑀭𑁄𑀘𑀭𑁂 𑀘, 𑀲𑀢𑁂𑀭𑀢𑀸 𑀯𑀺𑀚𑁆𑀚𑀼𑀭𑀺𑀯𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂;

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

𑁪𑁩.

‘‘𑀅𑀓𑀓𑁆𑀓𑀲𑀗𑁆𑀕𑁄 ¶ 𑀦 𑀘 𑀤𑀻𑀖𑀮𑁄𑀫𑁄, 𑀦𑀔𑀸𑀲𑁆𑀲 𑀤𑀻𑀖𑀸 𑀅𑀧𑀺 𑀮𑁄𑀳𑀺𑀢𑀕𑁆𑀕𑀸;

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

𑁪𑁪.

‘‘𑀤𑀼𑀫𑀲𑁆𑀲 ¶ 𑀢𑀽𑀮𑀽𑀧𑀦𑀺𑀪𑀸 𑀧𑀪𑀲𑁆𑀲𑀭𑀸, 𑀲𑀼𑀯𑀡𑁆𑀡𑀓𑀫𑁆𑀩𑀼𑀢𑀮𑀯𑀝𑁆𑀝𑀲𑀼𑀘𑁆𑀙𑀯𑀻;

𑀳𑀢𑁆𑀣𑀸 𑀫𑀼𑀤𑀽 𑀢𑁂𑀳𑀺 𑀫𑀁 𑀲𑀁𑀨𑀼𑀲𑀺𑀢𑁆𑀯𑀸, 𑀇𑀢𑁄 𑀕𑀢𑁄 𑀢𑁂𑀦 𑀫𑀁 𑀤𑀳𑀦𑁆𑀢𑀺 𑀢𑀸𑀢.

𑁪𑁫.

‘‘𑀦 𑀦𑀽𑀦 [𑀦 𑀳 𑀦𑀽𑀦 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑁄 𑀔𑀸𑀭𑀺𑀯𑀺𑀥𑀁 𑀅𑀳𑀸𑀲𑀺, 𑀦 𑀦𑀽𑀦 𑀲𑁄 𑀓𑀝𑁆𑀞𑀸𑀦𑀺 𑀲𑀬𑀁 𑀅𑀪𑀜𑁆𑀚𑀺;

𑀦 𑀦𑀽𑀦 𑀲𑁄 𑀳𑀦𑁆𑀢𑀺 𑀤𑀼𑀫𑁂 𑀓𑀼𑀞𑀸𑀭𑀺𑀬𑀸 [𑀓𑀼𑀥𑀸𑀭𑀺𑀬𑀸 (𑀓.)], 𑀦 𑀳𑀺𑀲𑁆𑀲 [𑀦 𑀧𑀺𑀲𑁆𑀲 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀳𑀢𑁆𑀣𑁂𑀲𑀼 𑀔𑀺𑀮𑀸𑀦𑀺 𑀅𑀢𑁆𑀣𑀺.

𑁪𑁬.

‘‘𑀅𑀘𑁆𑀙𑁄 𑀘 𑀔𑁄 𑀢𑀲𑁆𑀲 𑀯𑀡𑀁 𑀅𑀓𑀸𑀲𑀺, 𑀲𑁄 𑀫𑀁𑀩𑁆𑀭𑀯𑀺 𑀲𑀼𑀔𑀺𑀢𑀁 𑀫𑀁 𑀓𑀭𑁄𑀳𑀺;

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

𑁪𑁭.

‘‘𑀅𑀬𑀜𑁆𑀘 𑀢𑁂 𑀫𑀸𑀮𑀼𑀯𑀧𑀡𑁆𑀡𑀲𑀦𑁆𑀣𑀢𑀸, 𑀯𑀺𑀓𑀺𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀯 𑀫𑀬𑀸 𑀘 𑀢𑁂𑀦 𑀘;

𑀓𑀺𑀮𑀦𑁆𑀢𑀭𑀽𑀧𑀸 𑀉𑀤𑀓𑁂 𑀭𑀫𑀺𑀢𑁆𑀯𑀸, 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁 𑀧𑀡𑁆𑀡𑀓𑀼𑀝𑀺𑀁 𑀯𑀚𑀸𑀫.

𑁪𑁮.

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

𑀦 𑀘𑀸𑀧𑀺 𑀢𑁂 𑀫𑀽𑀮𑀨𑀮𑀸𑀦𑀺 𑀪𑀼𑀜𑁆𑀚𑁂, 𑀬𑀸𑀯 ¶ 𑀦 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀢𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺𑀁.

𑁪𑁯.

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

𑀢𑀁 𑀫𑀁 𑀤𑀺𑀲𑀁 𑀧𑀸𑀧𑀬 𑀢𑀸𑀢 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀫𑀸 𑀢𑁂 𑀅𑀳𑀁 𑀅𑀫𑀭𑀺𑀫𑀲𑁆𑀲𑀫𑀫𑁆𑀳𑀺.

𑁫𑁦.

‘‘𑀯𑀺𑀘𑀺𑀢𑁆𑀭𑀨𑀼𑀮𑁆𑀮𑀁 [𑀯𑀺𑀘𑀺𑀢𑁆𑀭𑀧𑀼𑀧𑁆𑀨𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀳𑀺 𑀯𑀦𑀁 𑀲𑀼𑀢𑀁 𑀫𑀬𑀸, 𑀤𑀺𑀚𑀸𑀪𑀺𑀖𑀼𑀝𑁆𑀞𑀁 𑀤𑀺𑀚𑀲𑀗𑁆𑀖𑀲𑁂𑀯𑀺𑀢𑀁;

𑀢𑀁 𑀫𑀁 𑀯𑀦𑀁 𑀧𑀸𑀧𑀬 𑀢𑀸𑀢 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀧𑀼𑀭𑀸 𑀢𑁂 𑀧𑀸𑀡𑀁 𑀯𑀺𑀚𑀳𑀸𑀫𑀺 𑀅𑀲𑁆𑀲𑀫𑁂’’.

𑁫𑁧.

‘‘𑀇𑀫𑀲𑁆𑀫𑀸𑀳𑀁 𑀚𑁄𑀢𑀺𑀭𑀲𑁂 𑀯𑀦𑀫𑁆𑀳𑀺, 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑀤𑁂𑀯𑀘𑁆𑀙𑀭𑀲𑀗𑁆𑀖𑀲𑁂𑀯𑀺𑀢𑁂;

𑀇𑀲𑀻𑀦𑀫𑀸𑀯𑀸𑀲𑁂 𑀲𑀦𑀦𑁆𑀢𑀦𑀫𑁆𑀳𑀺, 𑀦𑁂𑀢𑀸𑀤𑀺𑀲𑀁 𑀅𑀭𑀢𑀺𑀁 𑀧𑀸𑀧𑀼𑀡𑁂𑀣.

𑁫𑁨.

‘‘𑀪𑀯𑀦𑁆𑀢𑀺 𑀫𑀺𑀢𑁆𑀢𑀸𑀦𑀺 𑀅𑀣𑁄 𑀦 𑀳𑁄𑀦𑁆𑀢𑀺, 𑀜𑀸𑀢𑀻𑀲𑀼 𑀫𑀺𑀢𑁆𑀢𑁂𑀲𑀼 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀧𑁂𑀫𑀁;

𑀅𑀬𑀜𑁆𑀘 𑀚𑀫𑁆𑀫𑁄 𑀓𑀺𑀲𑁆𑀲 𑀯𑀸 𑀦𑀺𑀯𑀺𑀝𑁆𑀞𑁄, 𑀬𑁄 𑀦𑁂𑀯 𑀚𑀸𑀦𑀸𑀢𑀺 𑀓𑀼𑀢𑁄𑀫𑁆𑀳𑀺 𑀆𑀕𑀢𑁄.

𑁫𑁩.

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

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

𑁫𑁪.

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

𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀲𑀲𑁆𑀲𑀁𑀯 𑀫𑀳𑁄𑀤𑀓𑁂𑀦, 𑀢𑀧𑁄𑀕𑀼𑀡𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑀺𑀫𑀁 𑀧𑀳𑀺𑀲𑁆𑀲𑀲𑀺 [𑀧𑀳𑀲𑁆𑀲𑀲𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑁫𑁫.

‘‘𑀧𑀼𑀦𑀧𑀺 ¶ [𑀧𑀼𑀦𑀧𑁆𑀧𑀺 (𑀧𑀻.)] 𑀘𑁂 𑀤𑀓𑁆𑀔𑀲𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺𑀁, 𑀧𑀼𑀦𑀧𑀺 [𑀧𑀼𑀦𑀧𑁆𑀧𑀺 (𑀧𑀻.)] 𑀘𑁂 𑀲𑀮𑁆𑀮𑀧𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺𑀦𑀸;

𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀲𑀲𑁆𑀲𑀁𑀯 𑀫𑀳𑁄𑀤𑀓𑁂𑀦, 𑀉𑀲𑁆𑀫𑀸𑀕𑀢𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑀺𑀫𑀁 𑀧𑀳𑀺𑀲𑁆𑀲𑀲𑀺.

𑁫𑁬.

‘‘𑀪𑀽𑀢𑀸𑀦𑀺 ¶ 𑀳𑁂𑀢𑀸𑀦𑀺 [𑀏𑀢𑀸𑀦𑀺 (𑀧𑀻.)] 𑀘𑀭𑀦𑁆𑀢𑀺 𑀢𑀸𑀢, 𑀯𑀺𑀭𑀽𑀧𑀭𑀽𑀧𑁂𑀦 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑁂;

𑀦 𑀢𑀸𑀦𑀺 𑀲𑁂𑀯𑁂𑀣 𑀦𑀭𑁄 𑀲𑀧𑀜𑁆𑀜𑁄, 𑀆𑀲𑀚𑁆𑀚 𑀦𑀁 𑀦𑀲𑁆𑀲𑀢𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀻’’𑀢𑀺.

𑀦𑀺𑀴𑀺𑀦𑀺𑀓𑀸𑀚𑀸𑀢𑀓𑀁 [𑀦𑀴𑀺𑀦𑀻𑀚𑀸𑀢𑀓𑀁 (𑀲𑀻.), 𑀦𑀴𑀺𑀦𑀺𑀚𑀸𑀢𑀓𑀁 (𑀧𑀻.)] 𑀧𑀞𑀫𑀁.

𑁫𑁨𑁭. 𑀉𑀫𑁆𑀫𑀸𑀤𑀦𑁆𑀢𑀻𑀚𑀸𑀢𑀓𑀁 (𑁨)

𑁫𑁭.

‘‘𑀦𑀺𑀯𑁂𑀲𑀦𑀁 𑀓𑀲𑁆𑀲 𑀦𑀼𑀤𑀁 𑀲𑀼𑀦𑀦𑁆𑀤, 𑀧𑀸𑀓𑀸𑀭𑁂𑀦 𑀧𑀡𑁆𑀟𑀼𑀫𑀬𑁂𑀦 𑀕𑀼𑀢𑁆𑀢𑀁;

𑀓𑀸 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀅𑀕𑁆𑀕𑀺𑀲𑀺𑀔𑀸𑀯 𑀤𑀽𑀭𑁂, 𑀯𑁂𑀳𑀸𑀬𑀲𑀁 [𑀯𑁂𑀳𑀸𑀲𑀬𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀩𑁆𑀩𑀢𑀕𑁆𑀕𑁂𑀯 𑀅𑀘𑁆𑀘𑀺.

𑁫𑁮.

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

𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀔𑀺𑀧𑁆𑀧𑀫𑀺𑀥𑁂𑀯 𑀧𑀼𑀝𑁆𑀞𑁄, 𑀅𑀯𑀸𑀯𑀝𑀸 𑀬𑀤𑀺 𑀯𑀸 𑀅𑀢𑁆𑀣𑀺 𑀪𑀢𑁆𑀢𑀸’’.

𑁫𑁯.

‘‘𑀅𑀳𑀜𑁆𑀳𑀺 𑀚𑀸𑀦𑀸𑀫𑀺 𑀚𑀦𑀺𑀦𑁆𑀤 𑀏𑀢𑀁, 𑀫𑀢𑁆𑀬𑀸 𑀘 𑀧𑁂𑀢𑁆𑀬𑀸 𑀘 𑀅𑀣𑁄𑀧𑀺 𑀅𑀲𑁆𑀲𑀸;

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

𑁬𑁦.

‘‘𑀇𑀤𑁆𑀥𑁄 𑀘 𑀨𑀻𑀢𑁄 𑀘 𑀲𑀼𑀯𑀟𑁆𑀠𑀺𑀢𑁄 [𑀲𑀼𑀩𑀸𑀴𑁆𑀳𑀺𑀓𑁄 (𑀧𑀻.)] 𑀘, 𑀅𑀫𑀘𑁆𑀘𑁄 𑀘 𑀢𑁂 𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀚𑀦𑀺𑀦𑁆𑀤;

𑀢𑀲𑁆𑀲𑁂𑀲𑀸 𑀪𑀭𑀺𑀬𑀸𑀪𑀺𑀧𑀸𑀭𑀓𑀲𑁆𑀲 [𑀅𑀳𑀺𑀧𑀸𑀭𑀓𑀲𑁆𑀲 (𑀲𑀻. 𑀧𑀻.), 𑀅𑀪𑀺𑀧𑀸𑀤𑀓𑀲𑁆𑀲 (𑀓.)], 𑀉𑀫𑁆𑀫𑀸𑀤𑀦𑁆𑀢𑀻 [𑀉𑀫𑁆𑀫𑀸𑀤𑀦𑁆𑀢𑀻𑀢𑀺 (𑀓.)] 𑀦𑀸𑀫𑀥𑁂𑀬𑁆𑀬𑁂𑀦 𑀭𑀸𑀚’’.

𑁬𑁧.

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

𑀢𑀤𑀸 [𑀢𑀣𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀳𑀺 𑀫𑀬𑁆𑀳𑀁 𑀅𑀯𑀮𑁄𑀓𑀬𑀦𑁆𑀢𑀻, 𑀉𑀫𑁆𑀫𑀢𑁆𑀢𑀓𑀁 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀻 𑀅𑀓𑀸𑀲𑀺’’.

𑁬𑁨.

‘‘𑀬𑀸 𑀧𑀼𑀡𑁆𑀡𑀫𑀸𑀲𑁂 [𑀧𑀼𑀡𑁆𑀡𑀫𑀸𑀬𑁂 (𑀓.)] 𑀫𑀺𑀕𑀫𑀦𑁆𑀤𑀮𑁄𑀘𑀦𑀸, 𑀉𑀧𑀸𑀯𑀺𑀲𑀺 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀢𑁆𑀢𑀘𑀗𑁆𑀕𑀻;

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

𑁬𑁩.

‘‘𑀅𑀴𑀸𑀭𑀧𑀫𑁆𑀳𑁂𑀳𑀺 ¶ 𑀲𑀼𑀪𑁂𑀳𑀺 𑀯𑀕𑁆𑀕𑀼𑀪𑀺, 𑀧𑀮𑁄𑀪𑀬𑀦𑁆𑀢𑀻 𑀫𑀁 𑀬𑀤𑀸 𑀉𑀤𑀺𑀓𑁆𑀔𑀢𑀺;

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

𑁬𑁪.

‘‘𑀢𑀤𑀸 𑀳𑀺 𑀩𑁆𑀭𑀳𑀢𑀻 𑀲𑀸𑀫𑀸, 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀸;

𑀏𑀓𑀘𑁆𑀘𑀯𑀲𑀦𑀸 𑀦𑀸𑀭𑀻, 𑀫𑀺𑀕𑀻 𑀪𑀦𑁆𑀢𑀸𑀯𑀼𑀤𑀺𑀓𑁆𑀔𑀢𑀺.

𑁬𑁫.

‘‘𑀓𑀤𑀸𑀲𑁆𑀲𑀼 𑀫𑀁 𑀢𑀫𑁆𑀩𑀦𑀔𑀸 𑀲𑀼𑀮𑁄𑀫𑀸, 𑀩𑀸𑀳𑀸𑀫𑀼𑀤𑀽 𑀘𑀦𑁆𑀤𑀦𑀲𑀸𑀭𑀮𑀺𑀢𑁆𑀢𑀸;

𑀯𑀝𑁆𑀝𑀗𑁆𑀕𑀼𑀮𑀻 𑀲𑀦𑁆𑀦𑀢𑀥𑀻𑀭𑀓𑀼𑀢𑁆𑀢𑀺𑀬𑀸, 𑀦𑀸𑀭𑀻 𑀉𑀧𑀜𑁆𑀜𑀺𑀲𑁆𑀲𑀢𑀺 𑀲𑀻𑀲𑀢𑁄 𑀲𑀼𑀪𑀸.

𑁬𑁬.

‘‘𑀓𑀤𑀸𑀲𑁆𑀲𑀼 𑀫𑀁 𑀓𑀜𑁆𑀘𑀦𑀚𑀸𑀮𑀼𑀭𑀘𑁆𑀙𑀤𑀸, 𑀥𑀻𑀢𑀸 𑀢𑀺𑀭𑀻𑀝𑀺𑀲𑁆𑀲 𑀯𑀺𑀮𑀕𑁆𑀕𑀫𑀚𑁆𑀛𑀸;

𑀫𑀼𑀤𑀽𑀳𑀺 𑀩𑀸𑀳𑀸𑀳𑀺 𑀧𑀮𑀺𑀲𑁆𑀲𑀚𑀺𑀲𑁆𑀲𑀢𑀺, 𑀩𑁆𑀭𑀳𑀸𑀯𑀦𑁂 𑀚𑀸𑀢𑀤𑀼𑀫𑀁𑀯 𑀫𑀸𑀮𑀼𑀯𑀸.

𑁬𑁭.

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

𑀫𑀼𑀔𑀁 𑀫𑀼𑀔𑁂𑀦 𑀉𑀧𑀦𑀸𑀫𑀬𑀺𑀲𑁆𑀲𑀢𑀺, 𑀲𑁄𑀡𑁆𑀟𑁄𑀯 𑀲𑁄𑀡𑁆𑀟𑀲𑁆𑀲 𑀲𑀼𑀭𑀸𑀬 𑀣𑀸𑀮𑀁.

𑁬𑁮.

‘‘𑀬𑀤𑀸𑀤𑁆𑀤𑀲𑀁 [𑀬𑀣𑀸𑀤𑁆𑀤𑀲𑀁 (𑀧𑀻.)] 𑀢𑀁 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺𑀁, 𑀲𑀩𑁆𑀩𑀪𑀤𑁆𑀤𑀁 [𑀲𑀩𑁆𑀩𑀕𑀢𑁆𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀦𑁄𑀭𑀫𑀁;

𑀢𑀢𑁄 ¶ 𑀲𑀓𑀲𑁆𑀲 𑀘𑀺𑀢𑁆𑀢𑀲𑁆𑀲, 𑀦𑀸𑀯𑀩𑁄𑀥𑀸𑀫𑀺 𑀓𑀜𑁆𑀘𑀺𑀦𑀁 [𑀓𑀺𑀜𑁆𑀘𑀺𑀦𑀁 (𑀓.), 𑀓𑀺𑀜𑁆𑀘𑀦𑀁 (𑀧𑀻.)].

𑁬𑁯.

‘‘𑀉𑀫𑁆𑀫𑀸𑀤𑀦𑁆𑀢𑀺𑀫𑀳𑀁 ¶ 𑀤𑀝𑁆𑀞𑀸 [𑀤𑀺𑀝𑁆𑀞𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)], 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀁;

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

𑁭𑁦.

‘‘𑀲𑀓𑁆𑀓𑁄 𑀘𑁂 [𑀘 (𑀲𑀻. 𑀧𑀻.)] 𑀫𑁂 𑀯𑀭𑀁 𑀤𑀚𑁆𑀚𑀸, 𑀲𑁄 𑀘 𑀮𑀩𑁆𑀪𑁂𑀣 𑀫𑁂 𑀯𑀭𑁄;

𑀏𑀓𑀭𑀢𑁆𑀢𑀁 𑀤𑁆𑀯𑀺𑀭𑀢𑁆𑀢𑀁 [𑀤𑀺𑀭𑀢𑁆𑀢𑀁 (𑀧𑀻.)] 𑀯𑀸, 𑀪𑀯𑁂𑀬𑁆𑀬𑀁 𑀅𑀪𑀺𑀧𑀸𑀭𑀓𑁄;

𑀉𑀫𑁆𑀫𑀸𑀤𑀦𑁆𑀢𑁆𑀬𑀸 𑀭𑀫𑀺𑀢𑁆𑀯𑀸𑀦, 𑀲𑀺𑀯𑀺𑀭𑀸𑀚𑀸 𑀢𑀢𑁄 𑀲𑀺𑀬𑀁’’ [𑀲𑀺𑀬𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑁭𑁧.

‘‘𑀪𑀽𑀢𑀸𑀦𑀺 𑀫𑁂 𑀪𑀽𑀢𑀧𑀢𑀻 𑀦𑀫𑀲𑁆𑀲𑀢𑁄, 𑀆𑀕𑀫𑁆𑀫 𑀬𑀓𑁆𑀔𑁄 𑀇𑀤𑀫𑁂𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

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

𑁭𑁨.

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

𑀪𑀼𑀲𑁄 𑀘 𑀢𑁆𑀬𑀲𑁆𑀲 𑀫𑀦𑀲𑁄 𑀯𑀺𑀖𑀸𑀢𑁄, 𑀤𑀢𑁆𑀯𑀸 𑀧𑀺𑀬𑀁 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀺𑀁 𑀅𑀤𑀝𑁆𑀞𑀸’’.

𑁭𑁩.

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

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

𑁭𑁪.

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

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

𑁭𑁫.

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

𑀪𑀼𑀲𑁄 𑀘 𑀢𑁆𑀬𑀲𑁆𑀲 𑀫𑀦𑀲𑁄 𑀯𑀺𑀖𑀸𑀢𑁄, 𑀤𑀢𑁆𑀯𑀸 𑀧𑀺𑀬𑀁 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀺𑀁 𑀅𑀤𑀝𑁆𑀞𑀸’’.

𑁭𑁬.

‘‘𑀅𑀤𑁆𑀥𑀸 ¶ 𑀧𑀺𑀬𑀸 𑀫𑀬𑁆𑀳 𑀚𑀦𑀺𑀦𑁆𑀤 𑀏𑀲𑀸, 𑀦 𑀲𑀸 𑀫𑀫𑀁 𑀅𑀧𑁆𑀧𑀺𑀬𑀸 𑀪𑀽𑀫𑀺𑀧𑀸𑀮;

𑀕𑀘𑁆𑀙𑁂𑀯 𑀢𑁆𑀯𑀁 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀺𑀁 𑀪𑀤𑀦𑁆𑀢𑁂, 𑀲𑀻𑀳𑁄𑀯 𑀲𑁂𑀮𑀲𑁆𑀲 𑀕𑀼𑀳𑀁 𑀉𑀧𑁂𑀢𑀺’’.

𑁭𑁭.

‘‘𑀦 𑀧𑀻𑀴𑀺𑀢𑀸 𑀅𑀢𑁆𑀢𑀤𑀼𑀔𑁂𑀦 𑀥𑀻𑀭𑀸, 𑀲𑀼𑀔𑀧𑁆𑀨𑀮𑀁 𑀓𑀫𑁆𑀫 𑀧𑀭𑀺𑀘𑁆𑀘𑀚𑀦𑁆𑀢𑀺;

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

𑁭𑁮.

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

𑀤𑀸𑀲𑁄 𑀅𑀳𑀁 𑀢𑀼𑀬𑁆𑀳 𑀲𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑁄, 𑀬𑀣𑀸𑀲𑀼𑀔𑀁 𑀲𑀸𑀫𑀺 [𑀲𑀺𑀩𑁆𑀩 (𑀲𑀻.), 𑀲𑀻𑀯𑀺 (𑀲𑁆𑀬𑀸.)] 𑀓𑀭𑁄𑀳𑀺 𑀓𑀸𑀫𑀁’’.

𑁭𑁯.

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

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

𑁮𑁦.

‘‘𑀅𑀜𑁆𑀜𑀸𑀢𑀓𑀁 𑀲𑀸𑀫𑀺𑀓𑁂𑀳𑀻 𑀧𑀤𑀺𑀦𑁆𑀦𑀁, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑀸 𑀬𑁂 𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀤𑀸𑀦𑀁;

𑀧𑀝𑀺𑀘𑁆𑀙𑀓𑀸 𑀤𑀸𑀬𑀓𑀸 𑀘𑀸𑀧𑀺 𑀢𑀢𑁆𑀣, 𑀲𑀼𑀔𑀧𑁆𑀨𑀮𑀜𑁆𑀜𑁂𑀯 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀓𑀫𑁆𑀫𑀁’’.

𑁮𑁧.

‘‘𑀅𑀜𑁆𑀜𑁄 ¶ 𑀦𑀼 𑀢𑁂 𑀓𑁄𑀘𑀺 𑀦𑀭𑁄 𑀧𑀣𑀩𑁆𑀬𑀸, 𑀲𑀤𑁆𑀥𑁂𑀬𑁆𑀬 𑀮𑁄𑀓𑀲𑁆𑀫𑀺 𑀦 𑀫𑁂 𑀧𑀺𑀬𑀸𑀢𑀺;

𑀪𑀼𑀲𑁄 𑀘 𑀢𑁆𑀬𑀲𑁆𑀲 𑀫𑀦𑀲𑁄 𑀯𑀺𑀖𑀸𑀢𑁄, 𑀤𑀢𑁆𑀯𑀸 𑀧𑀺𑀬𑀁 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀺𑀁 𑀅𑀤𑀝𑁆𑀞𑀸’’.

𑁮𑁨.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀧𑀺𑀬𑀸 𑀫𑀬𑁆𑀳 𑀚𑀦𑀺𑀦𑁆𑀤 𑀏𑀲𑀸, 𑀦 𑀲𑀸 𑀫𑀫𑀁 𑀅𑀧𑁆𑀧𑀺𑀬𑀸 𑀪𑀽𑀫𑀺𑀧𑀸𑀮;

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

𑁮𑁩.

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

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

𑁮𑁪.

‘‘𑀅𑀜𑁆𑀜𑁄 𑀦𑀼 𑀢𑁂 𑀓𑁄𑀘𑀺 𑀦𑀭𑁄 𑀧𑀣𑀩𑁆𑀬𑀸, 𑀲𑀤𑁆𑀥𑁂𑀬𑁆𑀬 ¶ 𑀮𑁄𑀓𑀲𑁆𑀫𑀺 𑀦 𑀫𑁂 𑀧𑀺𑀬𑀸𑀢𑀺;

𑀪𑀼𑀲𑁄 𑀘 𑀢𑁆𑀬𑀲𑁆𑀲 𑀫𑀦𑀲𑁄 𑀯𑀺𑀖𑀸𑀢𑁄, 𑀤𑀢𑁆𑀯𑀸 𑀧𑀺𑀬𑀁 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀺𑀁 𑀅𑀤𑀝𑁆𑀞𑀸’’.

𑁮𑁫.

‘‘𑀚𑀦𑀺𑀦𑁆𑀤 𑀚𑀸𑀦𑀸𑀲𑀺 𑀧𑀺𑀬𑀸 𑀫𑀫𑁂𑀲𑀸, 𑀦 𑀲𑀸 𑀫𑀫𑀁 𑀅𑀧𑁆𑀧𑀺𑀬𑀸 𑀪𑀽𑀫𑀺𑀧𑀸𑀮;

𑀧𑀺𑀬𑁂𑀦 𑀢𑁂 𑀤𑀫𑁆𑀫𑀺 𑀧𑀺𑀬𑀁 𑀚𑀦𑀺𑀦𑁆𑀤, 𑀧𑀺𑀬𑀤𑀸𑀬𑀺𑀦𑁄 𑀤𑁂𑀯 𑀧𑀺𑀬𑀁 𑀮𑀪𑀦𑁆𑀢𑀺’’.

𑁮𑁬.

‘‘𑀲𑁄 𑀦𑀽𑀦𑀸𑀳𑀁 𑀯𑀥𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀅𑀢𑁆𑀢𑀸𑀦𑀁 𑀓𑀸𑀫𑀳𑁂𑀢𑀼𑀓𑀁;

𑀦 𑀳𑀺 𑀥𑀫𑁆𑀫𑀁 𑀅𑀥𑀫𑁆𑀫𑁂𑀦, 𑀅𑀳𑀁 𑀯𑀥𑀺𑀢𑀼𑀫𑀼𑀲𑁆𑀲𑀳𑁂’’.

𑁮𑁭.

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

𑀘𑀚𑀸𑀫𑀺 𑀦𑀁 𑀲𑀩𑁆𑀩𑀚𑀦𑀲𑁆𑀲 𑀲𑀺𑀩𑁆𑀬𑀸 [𑀲𑀺𑀩𑁆𑀩 (𑀲𑀻. 𑀧𑀻.), 𑀫𑀚𑁆𑀛𑁂 (𑀲𑁆𑀬𑀸.)], 𑀫𑀬𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑀁 𑀢𑀢𑁄 𑀅𑀯𑁆𑀳𑀬𑁂𑀲𑀺 [𑀅𑀯𑁆𑀳𑀬𑀸𑀲𑀺 (𑀓.)] 𑀦𑀁’’.

𑁮𑁮.

‘‘𑀅𑀤𑀽𑀲𑀺𑀬𑀁 𑀘𑁂 𑀅𑀪𑀺𑀧𑀸𑀭𑀓 𑀢𑁆𑀯𑀁, 𑀘𑀚𑀸𑀲𑀺 𑀓𑀢𑁆𑀢𑁂 𑀅𑀳𑀺𑀢𑀸𑀬 𑀢𑁆𑀬𑀲𑁆𑀲;

𑀫𑀳𑀸 𑀘 𑀢𑁂 𑀉𑀧𑀯𑀸𑀤𑁄𑀧𑀺 𑀅𑀲𑁆𑀲, 𑀦 𑀘𑀸𑀧𑀺 𑀢𑁆𑀬𑀲𑁆𑀲 𑀦𑀕𑀭𑀫𑁆𑀳𑀺 𑀧𑀓𑁆𑀔𑁄’’.

𑁮𑁯.

‘‘𑀅𑀳𑀁 𑀲𑀳𑀺𑀲𑁆𑀲𑀁 𑀉𑀧𑀯𑀸𑀤𑀫𑁂𑀢𑀁, 𑀦𑀺𑀦𑁆𑀤𑀁 𑀧𑀲𑀁𑀲𑀁 𑀕𑀭𑀳𑀜𑁆𑀘 𑀲𑀩𑁆𑀩𑀁;

𑀫𑀫𑁂𑀢𑀫𑀸𑀕𑀘𑁆𑀙𑀢𑀼 𑀪𑀽𑀫𑀺𑀧𑀸𑀮, 𑀬𑀣𑀸𑀲𑀼𑀔𑀁 ¶ 𑀲𑀺𑀯𑀺 [𑀲𑀺𑀩𑁆𑀩 (𑀲𑀻. 𑀧𑀻.)] 𑀓𑀭𑁄𑀳𑀺 𑀓𑀸𑀫𑀁’’.

𑁯𑁦.

‘‘𑀬𑁄 ¶ 𑀦𑁂𑀯 𑀦𑀺𑀦𑁆𑀤𑀁 𑀦 𑀧𑀦𑀧𑁆𑀧𑀲𑀁𑀲𑀁, 𑀆𑀤𑀺𑀬𑀢𑀺 𑀕𑀭𑀳𑀁 𑀦𑁄𑀧𑀺 𑀧𑀽𑀚𑀁;

𑀲𑀺𑀭𑀻 𑀘 𑀮𑀓𑁆𑀔𑀻 𑀘 𑀅𑀧𑁂𑀢𑀺 𑀢𑀫𑁆𑀳𑀸, 𑀆𑀧𑁄 𑀲𑀼𑀯𑀼𑀝𑁆𑀞𑀻𑀯 𑀬𑀣𑀸 𑀣𑀮𑀫𑁆𑀳𑀸’’.

𑁯𑁧.

‘‘𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀤𑀼𑀓𑁆𑀔𑀜𑁆𑀘 𑀲𑀼𑀔𑀜𑁆𑀘 𑀏𑀢𑁆𑀢𑁄, 𑀥𑀫𑁆𑀫𑀸𑀢𑀺𑀲𑀸𑀭𑀜𑁆𑀘 𑀫𑀦𑁄𑀯𑀺𑀖𑀸𑀢𑀁;

𑀉𑀭𑀲𑀸 𑀅𑀳𑀁 𑀧𑀘𑁆𑀘𑀼𑀢𑁆𑀢𑀭𑀺𑀲𑁆𑀲𑀸𑀫𑀺 [𑀧𑀝𑀺𑀘𑁆𑀙𑀺𑀲𑁆𑀲𑀸𑀫𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀧𑀘𑁆𑀘𑀼𑀧𑀤𑀺𑀲𑁆𑀲𑀸𑀫𑀺 (𑀧𑀻.)] 𑀲𑀩𑁆𑀩𑀁, 𑀧𑀣𑀯𑀻 𑀬𑀣𑀸 𑀣𑀸𑀯𑀭𑀸𑀦𑀁 𑀢𑀲𑀸𑀦𑀁’’.

𑁯𑁨.

‘‘𑀥𑀫𑁆𑀫𑀸𑀢𑀺𑀲𑀸𑀭𑀜𑁆𑀘 𑀫𑀦𑁄𑀯𑀺𑀖𑀸𑀢𑀁, 𑀤𑀼𑀓𑁆𑀔𑀜𑁆𑀘 𑀦𑀺𑀘𑁆𑀙𑀸𑀫𑀺 𑀅𑀳𑀁 𑀧𑀭𑁂𑀲𑀁;

𑀏𑀓𑁄𑀯𑀺𑀫𑀁 𑀳𑀸𑀭𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀪𑀸𑀭𑀁, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀓𑀺𑀜𑁆𑀘𑀺 𑀅𑀳𑀸𑀧𑀬𑀦𑁆𑀢𑁄’’.

𑁯𑁩.

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

𑀤𑀤𑀸𑀫𑀺 𑀢𑁂 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀺𑀁 𑀧𑀲𑀦𑁆𑀦𑁄, 𑀭𑀸𑀚𑀸𑀯 𑀬𑀜𑁆𑀜𑁂 𑀥𑀦𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁’’.

𑁯𑁪.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀢𑀼𑀯𑀁 𑀓𑀢𑁆𑀢𑁂 𑀳𑀺𑀢𑁂𑀲𑀺 𑀫𑀬𑁆𑀳𑀁, 𑀲𑀔𑀸 𑀫𑀫𑀁 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀻 𑀢𑀼𑀯𑀜𑁆𑀘;

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

𑁯𑁫.

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

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

𑁯𑁬.

‘‘𑀅𑀤𑁆𑀥𑀸 ¶ 𑀢𑀼𑀯𑀁 𑀓𑀢𑁆𑀢𑁂 𑀳𑀺𑀢𑁂𑀲𑀺 𑀫𑀬𑁆𑀳𑀁, 𑀲𑀔𑀸 𑀫𑀫𑀁 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀻 𑀢𑀼𑀯𑀜𑁆𑀘;

𑀲𑀢𑀜𑁆𑀘 𑀥𑀫𑁆𑀫𑀸𑀦𑀺 𑀲𑀼𑀓𑀺𑀢𑁆𑀢𑀺𑀢𑀸𑀦𑀺, 𑀲𑀫𑀼𑀤𑁆𑀤𑀯𑁂𑀮𑀸𑀯 𑀤𑀼𑀭𑀘𑁆𑀘𑀬𑀸𑀦𑀺’’.

𑁯𑁭.

‘‘𑀆𑀳𑀼𑀦𑁂𑀬𑁆𑀬𑁄 ¶ 𑀫𑁂𑀲𑀺 𑀳𑀺𑀢𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀻, 𑀥𑀸𑀢𑀸 𑀯𑀺𑀥𑀸𑀢𑀸 𑀘𑀲𑀺 𑀓𑀸𑀫𑀧𑀸𑀮𑁄;

𑀢𑀬𑀻 𑀳𑀼𑀢𑀸 𑀭𑀸𑀚 𑀫𑀳𑀧𑁆𑀨𑀮𑀸 𑀳𑀺 [𑀫𑀳𑀧𑁆𑀨𑀮𑀸 𑀳𑀺 𑀫𑁂 (𑀧𑀻.)], 𑀓𑀸𑀫𑁂𑀦 𑀫𑁂 𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀺𑀁 𑀧𑀝𑀺𑀘𑁆𑀙’’.

𑁯𑁮.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀳𑀺 𑀲𑀩𑁆𑀩𑀁 𑀅𑀪𑀺𑀧𑀸𑀭𑀓 𑀢𑁆𑀯𑀁, 𑀥𑀫𑁆𑀫𑀁 𑀅𑀘𑀸𑀭𑀻 𑀫𑀫 𑀓𑀢𑁆𑀢𑀼𑀧𑀼𑀢𑁆𑀢;

𑀅𑀜𑁆𑀜𑁄 𑀦𑀼 𑀢𑁂 𑀓𑁄 𑀇𑀥 𑀲𑁄𑀢𑁆𑀣𑀺𑀓𑀢𑁆𑀢𑀸, 𑀤𑁆𑀯𑀺𑀧𑀤𑁄 𑀦𑀭𑁄 𑀅𑀭𑀼𑀡𑁂 𑀚𑀻𑀯𑀮𑁄𑀓𑁂’’.

𑁯𑁯.

‘‘𑀢𑀼𑀯𑀁 𑀦𑀼 𑀲𑁂𑀝𑁆𑀞𑁄 𑀢𑁆𑀯𑀫𑀦𑀼𑀢𑁆𑀢𑀭𑁄𑀲𑀺, 𑀢𑁆𑀯𑀁 𑀥𑀫𑁆𑀫𑀕𑀽 [𑀥𑀫𑁆𑀫𑀕𑀼𑀢𑁆𑀢𑁄 (𑀲𑀻.)] 𑀥𑀫𑁆𑀫𑀯𑀺𑀤𑀽 𑀲𑀼𑀫𑁂𑀥𑁄;

𑀲𑁄 𑀥𑀫𑁆𑀫𑀕𑀼𑀢𑁆𑀢𑁄 𑀘𑀺𑀭𑀫𑁂𑀯 𑀚𑀻𑀯, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘 ¶ 𑀫𑁂 𑀤𑁂𑀲𑀬 𑀥𑀫𑁆𑀫𑀧𑀸𑀮’’.

𑁧𑁦𑁦.

‘‘𑀢𑀤𑀺𑀗𑁆𑀖 𑀅𑀪𑀺𑀧𑀸𑀭𑀓, 𑀲𑀼𑀡𑁄𑀳𑀺 𑀯𑀘𑀦𑀁 𑀫𑀫;

𑀥𑀫𑁆𑀫𑀁 𑀢𑁂 𑀤𑁂𑀲𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀲𑀢𑀁 𑀆𑀲𑁂𑀯𑀺𑀢𑀁 𑀅𑀳𑀁.

𑁧𑁦𑁧.

‘‘𑀲𑀸𑀥𑀼 𑀥𑀫𑁆𑀫𑀭𑀼𑀘𑀺 𑀭𑀸𑀚𑀸, 𑀲𑀸𑀥𑀼 𑀧𑀜𑁆𑀜𑀸𑀡𑀯𑀸 𑀦𑀭𑁄;

𑀲𑀸𑀥𑀼 𑀫𑀺𑀢𑁆𑀢𑀸𑀦𑀫𑀤𑁆𑀤𑀼𑀩𑁆𑀪𑁄, 𑀧𑀸𑀧𑀲𑁆𑀲𑀸𑀓𑀭𑀡𑀁 𑀲𑀼𑀔𑀁.

𑁧𑁦𑁨.

‘‘𑀅𑀓𑁆𑀓𑁄𑀥𑀦𑀲𑁆𑀲 𑀯𑀺𑀚𑀺𑀢𑁂, 𑀞𑀺𑀢𑀥𑀫𑁆𑀫𑀲𑁆𑀲 𑀭𑀸𑀚𑀺𑀦𑁄;

𑀲𑀼𑀔𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑀸 𑀆𑀲𑁂𑀣, 𑀲𑀻𑀢𑀘𑁆𑀙𑀸𑀬𑀸𑀬 𑀲𑀗𑁆𑀖𑀭𑁂.

𑁧𑁦𑁩.

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

𑀬𑁂 𑀯𑀸𑀧𑀺 𑀜𑀢𑁆𑀯𑀸𑀦 𑀲𑀬𑀁 𑀓𑀭𑁄𑀦𑁆𑀢𑀺, 𑀉𑀧𑀫𑀸 𑀇𑀫𑀸 𑀫𑀬𑁆𑀳𑀁 𑀢𑀼𑀯𑀁 𑀲𑀼𑀡𑁄𑀳𑀺.

𑁧𑁦𑁪.

‘‘𑀕𑀯𑀁 𑀘𑁂 𑀢𑀭𑀫𑀸𑀦𑀸𑀦𑀁, 𑀚𑀺𑀫𑁆𑀳𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀧𑀼𑀗𑁆𑀕𑀯𑁄;

𑀲𑀩𑁆𑀩𑀸 𑀢𑀸 𑀚𑀺𑀫𑁆𑀳𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀦𑁂𑀢𑁆𑀢𑁂 𑀚𑀺𑀫𑁆𑀳𑀁 𑀕𑀢𑁂 𑀲𑀢𑀺.

𑁧𑁦𑁫.

‘‘𑀏𑀯𑀫𑁂𑀯 [𑀏𑀯𑀫𑁂𑀯𑀁 (𑀧𑀻.)] 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀬𑁄 𑀳𑁄𑀢𑀺 𑀲𑁂𑀝𑁆𑀞𑀲𑀫𑁆𑀫𑀢𑁄;

𑀲𑁄 𑀘𑁂 𑀅𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀢𑀺, 𑀧𑀕𑁂𑀯 𑀇𑀢𑀭𑀸 𑀧𑀚𑀸;

𑀲𑀩𑁆𑀩𑀁 ¶ 𑀭𑀝𑁆𑀞𑀁 𑀤𑀼𑀔𑀁 𑀲𑁂𑀢𑀺, 𑀭𑀸𑀚𑀸 𑀘𑁂 𑀳𑁄𑀢𑀺 𑀅𑀥𑀫𑁆𑀫𑀺𑀓𑁄.

𑁧𑁦𑁬.

‘‘𑀕𑀯𑀁 ¶ 𑀘𑁂 𑀢𑀭𑀫𑀸𑀦𑀸𑀦𑀁, 𑀉𑀚𑀼𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀧𑀼𑀗𑁆𑀕𑀯𑁄;

𑀲𑀩𑁆𑀩𑀸 𑀕𑀸𑀯𑀻 𑀉𑀚𑀼𑀁 𑀬𑀦𑁆𑀢𑀺, 𑀦𑁂𑀢𑁆𑀢𑁂 𑀉𑀚𑀼𑀁 𑀕𑀢𑁂 𑀲𑀢𑀺.

𑁧𑁦𑁭.

‘‘𑀏𑀯𑀫𑁂𑀯 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀬𑁄 𑀳𑁄𑀢𑀺 𑀲𑁂𑀝𑁆𑀞𑀲𑀫𑁆𑀫𑀢𑁄;

𑀲𑁄 𑀲𑀘𑁂 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀢𑀺, 𑀧𑀕𑁂𑀯 𑀇𑀢𑀭𑀸 𑀧𑀚𑀸;

𑀲𑀩𑁆𑀩𑀁 𑀭𑀝𑁆𑀞𑀁 𑀲𑀼𑀔𑀁 𑀲𑁂𑀢𑀺, 𑀭𑀸𑀚𑀸 𑀘𑁂 𑀳𑁄𑀢𑀺 𑀥𑀫𑁆𑀫𑀺𑀓𑁄.

𑁧𑁦𑁮.

‘‘𑀦 𑀘𑀸𑀧𑀸𑀳𑀁 𑀅𑀥𑀫𑁆𑀫𑁂𑀦, 𑀅𑀫𑀭𑀢𑁆𑀢𑀫𑀪𑀺𑀧𑀢𑁆𑀣𑀬𑁂;

𑀇𑀫𑀁 𑀯𑀸 𑀧𑀣𑀯𑀺𑀁 𑀲𑀩𑁆𑀩𑀁, 𑀯𑀺𑀚𑁂𑀢𑀼𑀁 𑀅𑀪𑀺𑀧𑀸𑀭𑀓.

𑁧𑁦𑁯.

‘‘𑀬𑀜𑁆𑀳𑀺 𑀓𑀺𑀜𑁆𑀘𑀺 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀭𑀢𑀦𑀁 𑀇𑀥 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

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

𑁧𑁧𑁦.

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

𑀦 𑀢𑀲𑁆𑀲 𑀳𑁂𑀢𑀼 𑀯𑀺𑀲𑀫𑀁 𑀘𑀭𑁂𑀬𑁆𑀬𑀁, 𑀫𑀚𑁆𑀛𑁂 𑀲𑀺𑀯𑀻𑀦𑀁 𑀉𑀲𑀪𑁄𑀫𑁆𑀳𑀺 𑀚𑀸𑀢𑁄.

𑁧𑁧𑁧.

‘‘𑀦𑁂𑀢𑀸 𑀳𑀺𑀢𑀸 [𑀦𑁂𑀢𑀸𑀪𑀺 𑀢𑀸 (𑀲𑀻.)] 𑀉𑀕𑁆𑀕𑀢𑁄 𑀭𑀝𑁆𑀞𑀧𑀸𑀮𑁄, 𑀥𑀫𑁆𑀫𑀁 𑀲𑀺𑀯𑀻𑀦𑀁 𑀅𑀧𑀘𑀸𑀬𑀫𑀸𑀦𑁄;

𑀲𑁄 𑀥𑀫𑁆𑀫𑀫𑁂𑀯𑀸𑀦𑀼𑀯𑀺𑀘𑀺𑀦𑁆𑀢𑀬𑀦𑁆𑀢𑁄, 𑀢𑀲𑁆𑀫𑀸 𑀲𑀓𑁂 𑀘𑀺𑀢𑁆𑀢𑀯𑀲𑁂 𑀦 𑀯𑀢𑁆𑀢𑁄’’.

𑁧𑁧𑁨.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀢𑀼𑀯𑀁 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀅𑀩𑁆𑀬𑀲𑀦𑀁 𑀲𑀺𑀯𑀁;

𑀓𑀭𑀺𑀲𑁆𑀲𑀲𑀺 𑀘𑀺𑀭𑀁 𑀭𑀚𑁆𑀚𑀁, 𑀧𑀜𑁆𑀜𑀸 𑀳𑀺 𑀢𑀯 𑀢𑀸𑀤𑀺𑀲𑀻.

𑁧𑁧𑁩.

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

𑀥𑀫𑁆𑀫𑀁 𑀧𑀫𑀚𑁆𑀚 𑀔𑀢𑁆𑀢𑀺𑀬𑁄, 𑀭𑀝𑁆𑀞𑀸 [𑀞𑀸𑀦𑀸 (𑀲𑀻.)] 𑀘𑀯𑀢𑀺 𑀇𑀲𑁆𑀲𑀭𑁄.

𑁧𑁧𑁪.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽𑀲𑀼 𑀔𑀢𑁆𑀢𑀺𑀬;

𑀇𑀥 ¶ 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺.

𑁧𑁧𑁫.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑁂𑀲𑀼 𑀔𑀢𑁆𑀢𑀺𑀬…𑀧𑁂….

𑁧𑁧𑁬.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀫𑀺𑀢𑁆𑀢𑀸𑀫𑀘𑁆𑀘𑁂𑀲𑀼 𑀔𑀢𑁆𑀢𑀺𑀬…𑀧𑁂….

𑁧𑁧𑁭.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀯𑀸𑀳𑀦𑁂𑀲𑀼 𑀩𑀮𑁂𑀲𑀼 𑀘…𑀧𑁂….

𑁧𑁧𑁮.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀕𑀸𑀫𑁂𑀲𑀼 𑀦𑀺𑀕𑀫𑁂𑀲𑀼 𑀘…𑀧𑁂….

𑁧𑁧𑁯.

‘‘𑀥𑀫𑁆𑀫𑀁 ¶ 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀭𑀝𑁆𑀞𑁂𑀲𑀼 𑀚𑀦𑀧𑀤𑁂𑀲𑀼 𑀘…𑀧𑁂….

𑁧𑁨𑁦.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀲𑀼 𑀘…𑀧𑁂….

𑁧𑁨𑁧.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀫𑀺𑀕𑀧𑀓𑁆𑀔𑀻𑀲𑀼 𑀔𑀢𑁆𑀢𑀺𑀬…𑀧𑁂….

𑁧𑁨𑁨.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀥𑀫𑁆𑀫𑁄 𑀘𑀺𑀡𑁆𑀡𑁄 𑀲𑀼𑀔𑀸𑀯𑀳𑁄;

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺.

𑁧𑁨𑁩.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀲𑀇𑀦𑁆𑀤𑀸 𑀤𑁂𑀯𑀸 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑀸;

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

𑀉𑀫𑁆𑀫𑀸𑀤𑀦𑁆𑀢𑀻𑀚𑀸𑀢𑀓𑀁 𑀤𑀼𑀢𑀺𑀬𑀁.

𑁫𑁨𑁮. 𑀫𑀳𑀸𑀩𑁄𑀥𑀺𑀚𑀸𑀢𑀓𑀁 (𑁩)

𑁧𑁨𑁪.

‘‘𑀓𑀺𑀁 ¶ 𑀦𑀼 𑀤𑀡𑁆𑀟𑀁 𑀓𑀺𑀫𑀚𑀺𑀦𑀁, 𑀓𑀺𑀁 𑀙𑀢𑁆𑀢𑀁 𑀓𑀺𑀫𑀼𑀧𑀸𑀳𑀦𑀁;

𑀓𑀺𑀫𑀗𑁆𑀓𑀼𑀲𑀜𑁆𑀘 𑀧𑀢𑁆𑀢𑀜𑁆𑀘, 𑀲𑀗𑁆𑀖𑀸𑀝𑀺𑀜𑁆𑀘𑀸𑀧𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡;

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

𑁧𑁨𑁫.

‘‘𑀤𑁆𑀯𑀸𑀤𑀲𑁂𑀢𑀸𑀦𑀺 ¶ 𑀯𑀲𑁆𑀲𑀸𑀦𑀺, 𑀯𑀼𑀲𑀺𑀢𑀸𑀦𑀺 𑀢𑀯𑀦𑁆𑀢𑀺𑀓𑁂;

𑀦𑀸𑀪𑀺𑀚𑀸𑀦𑀸𑀫𑀺 𑀲𑁄𑀡𑁂𑀦, 𑀧𑀺𑀗𑁆𑀕𑀮𑁂𑀦𑀸𑀪𑀺𑀓𑀽𑀚𑀺𑀢𑀁.

𑁧𑁨𑁬.

‘‘𑀲𑁆𑀯𑀸𑀬𑀁 𑀤𑀺𑀢𑁆𑀢𑁄𑀯 𑀦𑀤𑀢𑀺, 𑀲𑀼𑀓𑁆𑀓𑀤𑀸𑀞𑀁 𑀯𑀺𑀤𑀁𑀲𑀬𑀁;

𑀢𑀯 𑀲𑀼𑀢𑁆𑀯𑀸 𑀲𑀪𑀭𑀺𑀬𑀲𑁆𑀲, 𑀯𑀻𑀢𑀲𑀤𑁆𑀥𑀲𑁆𑀲 𑀫𑀁 𑀧𑀢𑀺’’.

𑁧𑁨𑁭.

‘‘𑀅𑀳𑀼 𑀏𑀲 𑀓𑀢𑁄 𑀤𑁄𑀲𑁄, 𑀬𑀣𑀸 𑀪𑀸𑀲𑀲𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡;

𑀏𑀲 𑀪𑀺𑀬𑁆𑀬𑁄 𑀧𑀲𑀻𑀤𑀸𑀫𑀺, 𑀯𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀫𑀸𑀕𑀫𑀸’’.

𑁧𑁨𑁮.

‘‘𑀲𑀩𑁆𑀩𑀲𑁂𑀢𑁄 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺, 𑀢𑀢𑁄𑀧𑀺 𑀲𑀩𑀮𑁄 𑀅𑀳𑀼;

𑀲𑀩𑁆𑀩𑀮𑁄𑀳𑀺𑀢𑀓𑁄 𑀤𑀸𑀦𑀺, 𑀓𑀸𑀮𑁄 𑀧𑀓𑁆𑀓𑀫𑀺𑀢𑀼𑀁 𑀫𑀫.

𑁧𑁨𑁯.

‘‘𑀅𑀩𑁆𑀪𑀦𑁆𑀢𑀭𑀁 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺, 𑀢𑀢𑁄 𑀫𑀚𑁆𑀛𑁂 𑀢𑀢𑁄 𑀩𑀳𑀺;

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

𑁧𑁩𑁦.

‘‘𑀯𑀻𑀢𑀲𑀤𑁆𑀥𑀁 𑀦 𑀲𑁂𑀯𑁂𑀬𑁆𑀬, 𑀉𑀤𑀧𑀸𑀦𑀁𑀯𑀦𑁄𑀤𑀓𑀁;

𑀲𑀘𑁂𑀧𑀺 𑀦𑀁 𑀅𑀦𑀼𑀔𑀡𑁂, 𑀯𑀸𑀭𑀺 𑀓𑀤𑁆𑀤𑀫𑀕𑀦𑁆𑀥𑀺𑀓𑀁.

𑁧𑁩𑁧.

‘‘𑀧𑀲𑀦𑁆𑀦𑀫𑁂𑀯 𑀲𑁂𑀯𑁂𑀬𑁆𑀬, 𑀅𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑀁 𑀯𑀺𑀯𑀚𑁆𑀚𑀬𑁂;

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

𑁧𑁩𑁨.

‘‘𑀪𑀚𑁂 ¶ 𑀪𑀚𑀦𑁆𑀢𑀁 𑀧𑀼𑀭𑀺𑀲𑀁, 𑀅𑀪𑀚𑀦𑁆𑀢𑀁 𑀦 𑀪𑀚𑁆𑀚𑀬𑁂 [𑀪𑀸𑀚𑀬𑁂 (𑀧𑀻.)];

𑀅𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀥𑀫𑁆𑀫𑁄 𑀲𑁄, 𑀬𑁄 𑀪𑀚𑀦𑁆𑀢𑀁 𑀦 𑀪𑀚𑁆𑀚𑀢𑀺 [𑀪𑀸𑀚𑀢𑀺 (𑀧𑀻.)].

𑁧𑁩𑁩.

‘‘𑀬𑁄 ¶ 𑀪𑀚𑀦𑁆𑀢𑀁 𑀦 𑀪𑀚𑀢𑀺, 𑀲𑁂𑀯𑀫𑀸𑀦𑀁 𑀦 𑀲𑁂𑀯𑀢𑀺;

𑀲 𑀯𑁂 𑀫𑀦𑀼𑀲𑁆𑀲𑀧𑀸𑀧𑀺𑀝𑁆𑀞𑁄, 𑀫𑀺𑀕𑁄 𑀲𑀸𑀔𑀲𑁆𑀲𑀺𑀢𑁄 𑀬𑀣𑀸.

𑁧𑁩𑁪.

‘‘𑀅𑀘𑁆𑀘𑀸𑀪𑀺𑀓𑁆𑀔𑀡𑀲𑀁𑀲𑀕𑁆𑀕𑀸, 𑀅𑀲𑀫𑁄𑀲𑀭𑀡𑁂𑀦 𑀘;

𑀏𑀢𑁂𑀦 𑀫𑀺𑀢𑁆𑀢𑀸 𑀚𑀻𑀭𑀦𑁆𑀢𑀺, 𑀅𑀓𑀸𑀮𑁂 𑀬𑀸𑀘𑀦𑀸𑀬 𑀘.

𑁧𑁩𑁫.

‘‘𑀢𑀲𑁆𑀫𑀸 𑀦𑀸𑀪𑀺𑀓𑁆𑀔𑀡𑀁 𑀕𑀘𑁆𑀙𑁂, 𑀦 𑀘 𑀕𑀘𑁆𑀙𑁂 𑀘𑀺𑀭𑀸𑀘𑀺𑀭𑀁;

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

𑁧𑁩𑁬.

‘‘𑀅𑀢𑀺𑀘𑀺𑀭𑀁 𑀦𑀺𑀯𑀸𑀲𑁂𑀦, 𑀧𑀺𑀬𑁄 𑀪𑀯𑀢𑀺 𑀅𑀧𑁆𑀧𑀺𑀬𑁄;

𑀆𑀫𑀦𑁆𑀢 𑀔𑁄 𑀢𑀁 𑀕𑀘𑁆𑀙𑀸𑀫, 𑀧𑀼𑀭𑀸 𑀢𑁂 𑀳𑁄𑀫 𑀅𑀧𑁆𑀧𑀺𑀬𑀸’’.

𑁧𑁩𑁭.

‘‘𑀏𑀯𑀁 𑀘𑁂 𑀬𑀸𑀘𑀫𑀸𑀦𑀸𑀦𑀁, 𑀅𑀜𑁆𑀚𑀮𑀺𑀁 𑀦𑀸𑀯𑀩𑀼𑀚𑁆𑀛𑀲𑀺;

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

𑀏𑀯𑀁 𑀢𑀁 𑀅𑀪𑀺𑀬𑀸𑀘𑀸𑀫, 𑀧𑀼𑀦 𑀓𑀬𑀺𑀭𑀸𑀲𑀺 𑀧𑀭𑀺𑀬𑀸𑀬𑀁’’.

𑁧𑁩𑁮.

‘‘𑀏𑀯𑀁 𑀘𑁂 𑀦𑁄 𑀯𑀺𑀳𑀭𑀢𑀁, 𑀅𑀦𑁆𑀢𑀭𑀸𑀬𑁄 𑀦 𑀳𑁂𑀲𑁆𑀲𑀢𑀺;

𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀸𑀧𑀺 [𑀢𑀼𑀫𑁆𑀳𑀜𑁆𑀘𑀸𑀧𑀺 (𑀲𑀻.), 𑀢𑀼𑀬𑁆𑀳𑀜𑁆𑀘𑀸𑀧𑀺 (𑀧𑀻.)] 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀫𑀬𑁆𑀳𑀁 𑀯𑀸 [𑀅𑀫𑁆𑀳𑀁 𑀯𑀸 (𑀲𑀻.), 𑀫𑀬𑁆𑀳𑀜𑁆𑀘 (𑀧𑀻.)] 𑀭𑀝𑁆𑀞𑀯𑀤𑁆𑀥𑀦;

𑀅𑀧𑁆𑀧𑁂𑀯 𑀦𑀸𑀫 𑀧𑀲𑁆𑀲𑁂𑀫, 𑀅𑀳𑁄𑀭𑀢𑁆𑀢𑀸𑀦𑀫𑀘𑁆𑀘𑀬𑁂’’.

𑁧𑁩𑁯.

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

𑀅𑀓𑀸𑀫𑀸 𑀅𑀓𑀭𑀡𑀻𑀬𑀁 𑀯𑀸, 𑀓𑀭𑀡𑀻𑀬𑀁 𑀯𑀸𑀧𑀺 𑀓𑀼𑀩𑁆𑀩𑀢𑀺;

𑀆𑀓𑀸𑀫𑀸𑀓𑀭𑀡𑀻𑀬𑀫𑁆𑀳𑀺, 𑀓𑁆𑀯𑀺𑀥 𑀧𑀸𑀧𑁂𑀦 𑀮𑀺𑀧𑁆𑀧𑀢𑀺 [𑀮𑀺𑀫𑁆𑀧𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑁧𑁪𑁦.

‘‘𑀲𑁄 𑀘𑁂 𑀅𑀢𑁆𑀣𑁄 𑀘 𑀥𑀫𑁆𑀫𑁄 𑀘, 𑀓𑀮𑁆𑀬𑀸𑀡𑁄 𑀦 𑀘 𑀧𑀸𑀧𑀓𑁄;

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

𑁧𑁪𑁧.

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

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

𑁧𑁪𑁨.

‘‘𑀇𑀲𑁆𑀲𑀭𑁄 ¶ 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀲𑁆𑀲, 𑀲𑀘𑁂 𑀓𑀧𑁆𑀧𑁂𑀢𑀺 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀇𑀤𑁆𑀥𑀺𑀁 [𑀇𑀤𑁆𑀥𑀺 (𑀧𑀻. 𑀓.)] 𑀩𑁆𑀬𑀲𑀦𑀪𑀸𑀯𑀜𑁆𑀘, 𑀓𑀫𑁆𑀫𑀁 𑀓𑀮𑁆𑀬𑀸𑀡𑀧𑀸𑀧𑀓𑀁;

𑀦𑀺𑀤𑁆𑀤𑁂𑀲𑀓𑀸𑀭𑀻 𑀧𑀼𑀭𑀺𑀲𑁄, 𑀇𑀲𑁆𑀲𑀭𑁄 𑀢𑁂𑀦 𑀮𑀺𑀧𑁆𑀧𑀢𑀺.

𑁧𑁪𑁩.

‘‘𑀲𑁄 𑀘𑁂 𑀅𑀢𑁆𑀣𑁄 𑀘 𑀥𑀫𑁆𑀫𑁄 𑀘, 𑀓𑀮𑁆𑀬𑀸𑀡𑁄 𑀦 𑀘 𑀧𑀸𑀧𑀓𑁄;

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

𑁧𑁪𑁪.

‘‘𑀅𑀢𑁆𑀢𑀦𑁄 𑀘𑁂 𑀳𑀺 𑀯𑀸𑀤𑀲𑁆𑀲, 𑀅𑀧𑀭𑀸𑀥𑀁 𑀯𑀺𑀚𑀸𑀦𑀺𑀬𑀸;

𑀦 𑀫𑀁 𑀢𑁆𑀯𑀁 𑀕𑀭𑀳𑁂𑀬𑁆𑀬𑀸𑀲𑀺, 𑀪𑁄𑀢𑁄 𑀯𑀸𑀤𑁄 𑀳𑀺 𑀢𑀸𑀤𑀺𑀲𑁄’’.

𑁧𑁪𑁫.

‘‘𑀲𑀘𑁂 𑀧𑀼𑀩𑁆𑀩𑁂𑀓𑀢𑀳𑁂𑀢𑀼, 𑀲𑀼𑀔𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀢𑀺;

𑀧𑁄𑀭𑀸𑀡𑀓𑀁 𑀓𑀢𑀁 𑀧𑀸𑀧𑀁, 𑀢𑀫𑁂𑀲𑁄 𑀫𑀼𑀘𑁆𑀘𑀢𑁂 [𑀫𑀼𑀜𑁆𑀘𑀢𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀇𑀡𑀁;

𑀧𑁄𑀭𑀸𑀡𑀓𑀇𑀡𑀫𑁄𑀓𑁆𑀔𑁄, 𑀓𑁆𑀯𑀺𑀥 𑀧𑀸𑀧𑁂𑀦 𑀮𑀺𑀧𑁆𑀧𑀢𑀺.

𑁧𑁪𑁬.

‘‘𑀲𑁄 𑀘𑁂 𑀅𑀢𑁆𑀣𑁄 𑀘 𑀥𑀫𑁆𑀫𑁄 𑀘, 𑀓𑀮𑁆𑀬𑀸𑀡𑁄 𑀦 𑀘 𑀧𑀸𑀧𑀓𑁄;

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

𑁧𑁪𑁭.

‘‘𑀅𑀢𑁆𑀢𑀦𑁄 𑀘𑁂 𑀳𑀺 𑀯𑀸𑀤𑀲𑁆𑀲, 𑀅𑀧𑀭𑀸𑀥𑀁 𑀯𑀺𑀚𑀸𑀦𑀺𑀬𑀸;

𑀦 𑀫𑀁 𑀢𑁆𑀯𑀁 𑀕𑀭𑀳𑁂𑀬𑁆𑀬𑀸𑀲𑀺, 𑀪𑁄𑀢𑁄 𑀯𑀸𑀤𑁄 𑀳𑀺 𑀢𑀸𑀤𑀺𑀲𑁄’’.

𑁧𑁪𑁮.

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

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

𑀇𑀥𑁂𑀯 𑀚𑀻𑀯𑀢𑀺 𑀚𑀻𑀯𑁄, 𑀧𑁂𑀘𑁆𑀘 𑀧𑁂𑀘𑁆𑀘 𑀯𑀺𑀦𑀲𑁆𑀲𑀢𑀺.

𑁧𑁪𑁯.

𑀉𑀘𑁆𑀙𑀺𑀚𑁆𑀚𑀢𑀺 𑀅𑀬𑀁 𑀮𑁄𑀓𑁄, 𑀬𑁂 𑀩𑀸𑀮𑀸 𑀬𑁂 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

𑀉𑀘𑁆𑀙𑀺𑀚𑁆𑀚𑀫𑀸𑀦𑁂 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁, 𑀓𑁆𑀯𑀺𑀥 𑀧𑀸𑀧𑁂𑀦 𑀮𑀺𑀧𑁆𑀧𑀢𑀺.

𑁧𑁫𑁦.

‘‘𑀲𑁄 ¶ 𑀘𑁂 𑀅𑀢𑁆𑀣𑁄 𑀘 𑀥𑀫𑁆𑀫𑁄 𑀘, 𑀓𑀮𑁆𑀬𑀸𑀡𑁄 𑀦 𑀘 𑀧𑀸𑀧𑀓𑁄;

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

𑁧𑁫𑁧.

‘‘𑀅𑀢𑁆𑀢𑀦𑁄 𑀘𑁂 𑀳𑀺 𑀯𑀸𑀤𑀲𑁆𑀲, 𑀅𑀧𑀭𑀸𑀥𑀁 𑀯𑀺𑀚𑀸𑀦𑀺𑀬𑀸;

𑀦 𑀫𑀁 𑀢𑁆𑀯𑀁 𑀕𑀭𑀳𑁂𑀬𑁆𑀬𑀸𑀲𑀺, 𑀪𑁄𑀢𑁄 𑀯𑀸𑀤𑁄 𑀳𑀺 𑀢𑀸𑀤𑀺𑀲𑁄’’.

𑁧𑁫𑁨.

‘‘𑀆𑀳𑀼 ¶ 𑀔𑀢𑁆𑀢𑀯𑀺𑀤𑀸 [𑀔𑀢𑁆𑀢𑀯𑀺𑀥𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀮𑁄𑀓𑁂, 𑀩𑀸𑀮𑀸 𑀧𑀡𑁆𑀟𑀺𑀢𑀫𑀸𑀦𑀺𑀦𑁄.

𑀫𑀸𑀢𑀭𑀁 𑀧𑀺𑀢𑀭𑀁 𑀳𑀜𑁆𑀜𑁂, 𑀅𑀣𑁄 𑀚𑁂𑀝𑁆𑀞𑀫𑁆𑀧𑀺 𑀪𑀸𑀢𑀭𑀁;

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

𑁧𑁫𑁩.

‘‘𑀬𑀲𑁆𑀲 ¶ 𑀭𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀙𑀸𑀬𑀸𑀬, 𑀦𑀺𑀲𑀻𑀤𑁂𑀬𑁆𑀬 𑀲𑀬𑁂𑀬𑁆𑀬 𑀯𑀸;

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

𑁧𑁫𑁪.

‘‘𑀅𑀣 𑀅𑀢𑁆𑀣𑁂 𑀲𑀫𑀼𑀧𑁆𑀧𑀦𑁆𑀦𑁂, 𑀲𑀫𑀽𑀮𑀫𑀧𑀺 𑀅𑀩𑁆𑀩𑀳𑁂 [𑀅𑀩𑁆𑀪𑀳𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)];

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

𑁧𑁫𑁫.

[𑀅𑀬𑀁 𑀕𑀸𑀣𑀸 𑀲𑀻𑀳𑀴𑀧𑁄𑀢𑁆𑀣𑀓𑁂 𑀦𑀢𑁆𑀣𑀺] ‘‘𑀲𑁄 𑀘𑁂 𑀅𑀢𑁆𑀣𑁄 𑀘 𑀥𑀫𑁆𑀫𑁄 𑀘, 𑀓𑀮𑁆𑀬𑀸𑀡𑁄 𑀦 𑀘 𑀧𑀸𑀧𑀓𑁄;

𑀪𑁄𑀢𑁄 𑀘𑁂 𑀯𑀘𑀦𑀁 𑀲𑀘𑁆𑀘𑀁, 𑀲𑀼𑀳𑀢𑁄 𑀯𑀸𑀦𑀭𑁄 𑀫𑀬𑀸 [𑀅𑀬𑀁 𑀕𑀸𑀣𑀸 𑀲𑀻𑀳𑀴𑀧𑁄𑀢𑁆𑀣𑀓𑁂 𑀦𑀢𑁆𑀣𑀺].

𑁧𑁫𑁬.

‘‘𑀅𑀢𑁆𑀢𑀦𑁄 𑀘𑁂 𑀳𑀺 𑀯𑀸𑀤𑀲𑁆𑀲, 𑀅𑀧𑀭𑀸𑀥𑀁 𑀯𑀺𑀚𑀸𑀦𑀺𑀬𑀸;

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

𑁧𑁫𑁭.

‘‘𑀅𑀳𑁂𑀢𑀼𑀯𑀸𑀤𑁄 𑀧𑀼𑀭𑀺𑀲𑁄, 𑀬𑁄 𑀘 𑀇𑀲𑁆𑀲𑀭𑀓𑀼𑀢𑁆𑀢𑀺𑀓𑁄;

𑀧𑀼𑀩𑁆𑀩𑁂𑀓𑀢𑀻 𑀘 𑀉𑀘𑁆𑀙𑁂𑀤𑀻, 𑀬𑁄 𑀘 𑀔𑀢𑁆𑀢𑀯𑀺𑀤𑁄 𑀦𑀭𑁄.

𑁧𑁫𑁮.

‘‘𑀏𑀢𑁂 𑀅𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀸 𑀮𑁄𑀓𑁂, 𑀩𑀸𑀮𑀸 𑀧𑀡𑁆𑀟𑀺𑀢𑀫𑀸𑀦𑀺𑀦𑁄;

𑀓𑀭𑁂𑀬𑁆𑀬 𑀢𑀸𑀤𑀺𑀲𑁄 𑀧𑀸𑀧𑀁, 𑀅𑀣𑁄 𑀅𑀜𑁆𑀜𑀫𑁆𑀧𑀺 𑀓𑀸𑀭𑀬𑁂;

𑀅𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀲𑀁𑀲𑀕𑁆𑀕𑁄 ¶ , 𑀤𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑁄 [𑀤𑀼𑀓𑁆𑀓𑀝𑁄 (𑀲𑀻.)] 𑀓𑀝𑀼𑀓𑀼𑀤𑁆𑀭𑀬𑁄.

𑁧𑁫𑁯.

‘‘𑀉𑀭𑀩𑁆𑀪𑀭𑀽𑀧𑁂𑀦 𑀯𑀓𑀲𑁆𑀲𑀼 [𑀩𑀓𑀸𑀲𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀯𑀓𑀸𑀲𑀼 (𑀧𑀻.)] 𑀧𑀼𑀩𑁆𑀩𑁂, 𑀅𑀲𑀁𑀓𑀺𑀢𑁄 𑀅𑀚𑀬𑀽𑀣𑀁 𑀉𑀧𑁂𑀢𑀺;

𑀳𑀦𑁆𑀢𑁆𑀯𑀸 𑀉𑀭𑀡𑀺𑀁 𑀅𑀚𑀺𑀓𑀁 [𑀅𑀚𑀺𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀅𑀚𑀜𑁆𑀘, 𑀉𑀢𑁆𑀭𑀸𑀲𑀬𑀺𑀢𑁆𑀯𑀸 [𑀘𑀺𑀢𑁆𑀭𑀸𑀲𑀬𑀺𑀢𑁆𑀯𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀬𑁂𑀦 𑀓𑀸𑀫𑀁 𑀧𑀮𑁂𑀢𑀺.

𑁧𑁬𑁦.

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

𑀅𑀦𑀸𑀲𑀓𑀸 𑀣𑀡𑁆𑀟𑀺𑀮𑀲𑁂𑀬𑁆𑀬𑀓𑀸 𑀘, 𑀭𑀚𑁄𑀚𑀮𑁆𑀮𑀁 𑀉𑀓𑁆𑀓𑀼𑀝𑀺𑀓𑀧𑁆𑀧𑀥𑀸𑀦𑀁;

𑀧𑀭𑀺𑀬𑀸𑀬𑀪𑀢𑁆𑀢𑀜𑁆𑀘 𑀅𑀧𑀸𑀦𑀓𑀢𑁆𑀢𑀸, 𑀧𑀸𑀧𑀸𑀘𑀸𑀭𑀸 𑀅𑀭𑀳𑀦𑁆𑀢𑁄 𑀯𑀤𑀸𑀦𑀸.

𑁧𑁬𑁧.

‘‘𑀏𑀢𑁂 𑀅𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀸 𑀮𑁄𑀓𑁂, 𑀩𑀸𑀮𑀸 𑀧𑀡𑁆𑀟𑀺𑀢𑀫𑀸𑀦𑀺𑀦𑁄;

𑀓𑀭𑁂𑀬𑁆𑀬 𑀢𑀸𑀤𑀺𑀲𑁄 𑀧𑀸𑀧𑀁, 𑀅𑀣𑁄 𑀅𑀜𑁆𑀜𑀫𑁆𑀧𑀺 𑀓𑀸𑀭𑀬𑁂;

𑀅𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀲𑀁𑀲𑀕𑁆𑀕𑁄, 𑀤𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑁄 𑀓𑀝𑀼𑀓𑀼𑀤𑁆𑀭𑀬𑁄.

𑁧𑁬𑁨.

‘‘𑀬𑀫𑀸𑀳𑀼 ¶ 𑀦𑀢𑁆𑀣𑀺 𑀯𑀻𑀭𑀺𑀬𑀦𑁆𑀢𑀺, 𑀅𑀳𑁂𑀢𑀼𑀜𑁆𑀘 𑀧𑀯𑀤𑀦𑁆𑀢𑀺 [𑀳𑁂𑀢𑀼𑀜𑁆𑀘 𑀅𑀧𑀯𑀤𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀬𑁂;

𑀧𑀭𑀓𑀸𑀭𑀁 𑀅𑀢𑁆𑀢𑀓𑀸𑀭𑀜𑁆𑀘, 𑀬𑁂 𑀢𑀼𑀘𑁆𑀙𑀁 𑀲𑀫𑀯𑀡𑁆𑀡𑀬𑀼𑀁.

𑁧𑁬𑁩.

‘‘𑀏𑀢𑁂 𑀅𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀸 𑀮𑁄𑀓𑁂, 𑀩𑀸𑀮𑀸 𑀧𑀡𑁆𑀟𑀺𑀢𑀫𑀸𑀦𑀺𑀦𑁄;

𑀓𑀭𑁂𑀬𑁆𑀬 𑀢𑀸𑀤𑀺𑀲𑁄 𑀧𑀸𑀧𑀁, 𑀅𑀣𑁄 𑀅𑀜𑁆𑀜𑀫𑁆𑀧𑀺 𑀓𑀸𑀭𑀬𑁂;

𑀅𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀲𑀁𑀲𑀕𑁆𑀕𑁄, 𑀤𑀼𑀓𑁆𑀔𑀦𑁆𑀢𑁄 𑀓𑀝𑀼𑀓𑀼𑀤𑁆𑀭𑀬𑁄.

𑁧𑁬𑁪.

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

𑀦 ¶ 𑀪𑀭𑁂 𑀯𑀟𑁆𑀠𑀓𑀺𑀁 𑀭𑀸𑀚𑀸, 𑀦𑀧𑀺 𑀬𑀦𑁆𑀢𑀸𑀦𑀺 𑀓𑀸𑀭𑀬𑁂.

𑁧𑁬𑁫.

‘‘𑀬𑀲𑁆𑀫𑀸 𑀘 𑀯𑀻𑀭𑀺𑀬𑀁 𑀅𑀢𑁆𑀣𑀺, 𑀓𑀫𑁆𑀫𑀁 𑀓𑀮𑁆𑀬𑀸𑀡𑀧𑀸𑀧𑀓𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀬𑀦𑁆𑀢𑀸𑀦𑀺 𑀓𑀸𑀭𑁂𑀢𑀺, 𑀭𑀸𑀚𑀸 𑀪𑀭𑀢𑀺 𑀯𑀟𑁆𑀠𑀓𑀺𑀁.

𑁧𑁬𑁬.

‘‘𑀬𑀤𑀺 𑀯𑀲𑁆𑀲𑀲𑀢𑀁 𑀤𑁂𑀯𑁄, 𑀦 𑀯𑀲𑁆𑀲𑁂 𑀦 𑀳𑀺𑀫𑀁 𑀧𑀢𑁂;

𑀉𑀘𑁆𑀙𑀺𑀚𑁆𑀚𑁂𑀬𑁆𑀬 𑀅𑀬𑀁 𑀮𑁄𑀓𑁄, 𑀯𑀺𑀦𑀲𑁆𑀲𑁂𑀬𑁆𑀬 𑀅𑀬𑀁 𑀧𑀚𑀸.

𑁧𑁬𑁭.

‘‘𑀬𑀲𑁆𑀫𑀸 𑀘 𑀯𑀲𑁆𑀲𑀢𑀻 𑀤𑁂𑀯𑁄, 𑀳𑀺𑀫𑀜𑁆𑀘𑀸𑀦𑀼𑀨𑀼𑀲𑀸𑀬𑀢𑀺;

𑀢𑀲𑁆𑀫𑀸 𑀲𑀲𑁆𑀲𑀸𑀦𑀺 𑀧𑀘𑁆𑀘𑀦𑁆𑀢𑀺, 𑀭𑀝𑁆𑀞𑀜𑁆𑀘 𑀧𑀸𑀮𑀺𑀢𑁂 [𑀧𑀮𑁆𑀮𑀢𑁂 (𑀲𑀻. 𑀧𑀻.), 𑀧𑁄𑀮𑀬𑀢𑁂 (𑀲𑁆𑀬𑀸.)] 𑀘𑀺𑀭𑀁.

𑁧𑁬𑁮.

‘‘𑀕𑀯𑀁 𑀘𑁂 𑀢𑀭𑀫𑀸𑀦𑀸𑀦𑀁, 𑀚𑀺𑀫𑁆𑀳𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀧𑀼𑀗𑁆𑀕𑀯𑁄;

𑀲𑀩𑁆𑀩𑀸 𑀢𑀸 𑀚𑀺𑀫𑁆𑀳𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀦𑁂𑀢𑁆𑀢𑁂 𑀚𑀺𑀫𑁆𑀳𑀁 [𑀚𑀺𑀫𑁆𑀳 (𑀧𑀻.)] 𑀕𑀢𑁂 𑀲𑀢𑀺.

𑁧𑁬𑁯.

‘‘𑀏𑀯𑀫𑁂𑀯 [𑀏𑀯𑀫𑁂𑀯𑀁 (𑀧𑀻.)] 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀬𑁄 𑀳𑁄𑀢𑀺 𑀲𑁂𑀝𑁆𑀞𑀲𑀫𑁆𑀫𑀢𑁄;

𑀲𑁄 𑀘𑁂 𑀅𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀢𑀺, 𑀧𑀕𑁂𑀯 𑀇𑀢𑀭𑀸 𑀧𑀚𑀸;

𑀲𑀩𑁆𑀩𑀁 𑀭𑀝𑁆𑀞𑀁 𑀤𑀼𑀔𑀁 𑀲𑁂𑀢𑀺, 𑀭𑀸𑀚𑀸 𑀘𑁂 𑀳𑁄𑀢𑀺 𑀅𑀥𑀫𑁆𑀫𑀺𑀓𑁄.

𑁧𑁭𑁦.

‘‘𑀕𑀯𑀁 𑀘𑁂 𑀢𑀭𑀫𑀸𑀦𑀸𑀦𑀁, 𑀉𑀚𑀼𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀧𑀼𑀗𑁆𑀕𑀯𑁄;

𑀲𑀩𑁆𑀩𑀸 𑀕𑀸𑀯𑀻 𑀉𑀚𑀼𑀁 𑀬𑀦𑁆𑀢𑀺, 𑀦𑁂𑀢𑁆𑀢𑁂 𑀉𑀚𑀼𑀁 [𑀉𑀚𑀽 (𑀧𑀻.)] 𑀕𑀢𑁂 𑀲𑀢𑀺.

𑁧𑁭𑁧.

‘‘𑀏𑀯𑀫𑁂𑀯 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼, 𑀬𑁄 𑀳𑁄𑀢𑀺 𑀲𑁂𑀝𑁆𑀞𑀲𑀫𑁆𑀫𑀢𑁄;

𑀲𑁄 𑀲𑀘𑁂 [𑀘𑁂𑀯 (𑀲𑀻.), 𑀘𑁂𑀧𑀺 (𑀓.)] 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀢𑀺, 𑀧𑀕𑁂𑀯 𑀇𑀢𑀭𑀸 𑀧𑀚𑀸;

𑀲𑀩𑁆𑀩𑀁 𑀭𑀝𑁆𑀞𑀁 𑀲𑀼𑀔𑀁 𑀲𑁂𑀢𑀺, 𑀭𑀸𑀚𑀸 𑀘𑁂 𑀳𑁄𑀢𑀺 𑀥𑀫𑁆𑀫𑀺𑀓𑁄.

𑁧𑁭𑁨.

‘‘𑀫𑀳𑀸𑀭𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀨𑀮𑀺𑀦𑁄, 𑀆𑀫𑀁 𑀙𑀺𑀦𑁆𑀤𑀢𑀺 𑀬𑁄 𑀨𑀮𑀁;

𑀭𑀲𑀜𑁆𑀘𑀲𑁆𑀲 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀩𑀻𑀚𑀜𑁆𑀘𑀲𑁆𑀲 𑀯𑀺𑀦𑀲𑁆𑀲𑀢𑀺.

𑁧𑁭𑁩.

‘‘𑀫𑀳𑀸𑀭𑀼𑀓𑁆𑀔𑀽𑀧𑀫𑀁 ¶ 𑀭𑀝𑁆𑀞𑀁, 𑀅𑀥𑀫𑁆𑀫𑁂𑀦 𑀧𑀲𑀸𑀲𑀢𑀺;

𑀭𑀲𑀜𑁆𑀘𑀲𑁆𑀲 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀭𑀝𑁆𑀞𑀜𑁆𑀘𑀲𑁆𑀲 𑀯𑀺𑀦𑀲𑁆𑀲𑀢𑀺.

𑁧𑁭𑁪.

‘‘𑀫𑀳𑀸𑀭𑀼𑀓𑁆𑀔𑀲𑁆𑀲 ¶ 𑀨𑀮𑀺𑀦𑁄, 𑀧𑀓𑁆𑀓𑀁 𑀙𑀺𑀦𑁆𑀤𑀢𑀺 𑀬𑁄 𑀨𑀮𑀁;

𑀭𑀲𑀜𑁆𑀘𑀲𑁆𑀲 𑀯𑀺𑀚𑀸𑀦𑀸𑀢𑀺, 𑀩𑀻𑀚𑀜𑁆𑀘𑀲𑁆𑀲 𑀦 𑀦𑀲𑁆𑀲𑀢𑀺.

𑁧𑁭𑁫.

‘‘𑀫𑀳𑀸𑀭𑀼𑀓𑁆𑀔𑀽𑀧𑀫𑀁 𑀭𑀝𑁆𑀞𑀁, 𑀥𑀫𑁆𑀫𑁂𑀦 𑀬𑁄 𑀧𑀲𑀸𑀲𑀢𑀺;

𑀭𑀲𑀜𑁆𑀘𑀲𑁆𑀲 𑀯𑀺𑀚𑀸𑀦𑀸𑀢𑀺, 𑀭𑀝𑁆𑀞𑀜𑁆𑀘𑀲𑁆𑀲 𑀦 𑀦𑀲𑁆𑀲𑀢𑀺.

𑁧𑁭𑁬.

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

𑀲𑀩𑁆𑀩𑁄𑀲𑀥𑀻𑀳𑀺 𑀲𑁄 𑀭𑀸𑀚𑀸, 𑀯𑀺𑀭𑀼𑀤𑁆𑀥𑁄 𑀳𑁄𑀢𑀺 𑀔𑀢𑁆𑀢𑀺𑀬𑁄.

𑁧𑁭𑁭.

‘‘𑀢𑀣𑁂𑀯 𑀦𑁂𑀕𑀫𑁂 𑀳𑀺𑀁𑀲𑀁, 𑀬𑁂 𑀬𑀼𑀢𑁆𑀢𑀸 𑀓𑀬𑀯𑀺𑀓𑁆𑀓𑀬𑁂;

𑀑𑀚𑀤𑀸𑀦𑀩𑀮𑀻𑀓𑀸𑀭𑁂, 𑀲 𑀓𑁄𑀲𑁂𑀦 𑀯𑀺𑀭𑀼𑀚𑁆𑀛𑀢𑀺.

𑁧𑁭𑁮.

‘‘𑀧𑀳𑀸𑀭𑀯𑀭𑀔𑁂𑀢𑁆𑀢𑀜𑁆𑀜𑀽 ¶ , 𑀲𑀗𑁆𑀕𑀸𑀫𑁂 𑀓𑀢𑀦𑀺𑀲𑁆𑀲𑀫𑁂 [𑀓𑀢𑀦𑀺𑀬𑀫𑁂 (𑀓.)];

𑀉𑀲𑁆𑀲𑀺𑀢𑁂 𑀳𑀺𑀁𑀲𑀬𑀁 𑀭𑀸𑀚𑀸, 𑀲 𑀩𑀮𑁂𑀦 𑀯𑀺𑀭𑀼𑀚𑁆𑀛𑀢𑀺.

𑁧𑁭𑁯.

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

𑀅𑀥𑀫𑁆𑀫𑀘𑀸𑀭𑀻 𑀔𑀢𑁆𑀢𑀺𑀬𑁄, 𑀲𑁄 𑀲𑀕𑁆𑀕𑁂𑀦 𑀯𑀺𑀭𑀼𑀚𑁆𑀛𑀢𑀺.

𑁧𑁮𑁦.

‘‘𑀬𑁄 𑀘 𑀭𑀸𑀚𑀸 𑀅𑀥𑀫𑁆𑀫𑀝𑁆𑀞𑁄, 𑀪𑀭𑀺𑀬𑀁 𑀳𑀦𑁆𑀢𑀺 𑀅𑀤𑀽𑀲𑀺𑀓𑀁;

𑀮𑀼𑀤𑁆𑀤𑀁 𑀧𑀲𑀯𑀢𑁂 𑀞𑀸𑀦𑀁 [𑀧𑀸𑀧𑀁 (𑀲𑀻.)], 𑀧𑀼𑀢𑁆𑀢𑁂𑀳𑀺 𑀘 𑀯𑀺𑀭𑀼𑀚𑁆𑀛𑀢𑀺.

𑁧𑁮𑁧.

‘‘𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑁂 𑀚𑀸𑀦𑀧𑀤𑁂, 𑀦𑁂𑀕𑀫𑁂𑀲𑀼 [𑀦𑀺𑀕𑀫𑁂𑀲𑀼 (𑀲𑀻.)] 𑀩𑀮𑁂𑀲𑀼 𑀘;

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

𑁧𑁮𑁨.

‘‘𑀲 𑀢𑀸𑀤𑀺𑀲𑁄 𑀪𑀽𑀫𑀺𑀧𑀢𑀺, 𑀭𑀝𑁆𑀞𑀧𑀸𑀮𑁄 𑀅𑀓𑁄𑀥𑀦𑁄;

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

𑀫𑀳𑀸𑀩𑁄𑀥𑀺𑀚𑀸𑀢𑀓𑀁 𑀢𑀢𑀺𑀬𑀁.

𑀧𑀡𑁆𑀡𑀸𑀲𑀦𑀺𑀧𑀸𑀢𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀢𑀲𑁆𑀲𑀼𑀤𑁆𑀤𑀸𑀦𑀁 𑁋

𑀲𑀦𑀺𑀴𑀻𑀦𑀺𑀓𑀫𑀯𑁆𑀳𑀬𑀦𑁄 𑀧𑀞𑀫𑁄, 𑀤𑀼𑀢𑀺𑀬𑁄 𑀧𑀦 𑀲𑀉𑀫𑁆𑀫𑀤𑀦𑁆𑀢𑀺𑀯𑀭𑁄;

𑀢𑀢𑀺𑀬𑁄 𑀧𑀦 𑀩𑁄𑀥𑀺𑀲𑀺𑀭𑀻𑀯𑁆𑀳𑀬𑀦𑁄, 𑀓𑀣𑀺𑀢𑀸 𑀧𑀦 𑀢𑀻𑀡𑀺 𑀚𑀺𑀦𑁂𑀦 𑀲𑀼𑀪𑀸𑀢𑀺.

𑁧𑁯. 𑀲𑀝𑁆𑀞𑀺𑀦𑀺𑀧𑀸𑀢𑁄

𑁫𑁨𑁯. 𑀲𑁄𑀡𑀓𑀚𑀸𑀢𑀓𑀁 (𑁧)

𑁧.

‘‘𑀢𑀲𑁆𑀲 ¶ ¶ ¶ 𑀲𑀼𑀢𑁆𑀯𑀸 𑀲𑀢𑀁 𑀤𑀫𑁆𑀫𑀺, 𑀲𑀳𑀲𑁆𑀲𑀁 𑀤𑀺𑀝𑁆𑀞 [𑀤𑀝𑁆𑀞𑀼 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑁄𑀡𑀓𑀁;

𑀓𑁄 𑀫𑁂 𑀲𑁄𑀡𑀓𑀫𑀓𑁆𑀔𑀸𑀢𑀺, 𑀲𑀳𑀸𑀬𑀁 𑀧𑀁𑀲𑀼𑀓𑀻𑀴𑀺𑀢𑀁’’.

𑁨.

‘‘𑀅𑀣𑀩𑁆𑀭𑀯𑀻 𑀫𑀸𑀡𑀯𑀓𑁄, 𑀤𑀳𑀭𑁄 𑀧𑀜𑁆𑀘𑀘𑀽𑀴𑀓𑁄;

𑀫𑀬𑁆𑀳𑀁 𑀲𑀼𑀢𑁆𑀯𑀸 𑀲𑀢𑀁 𑀤𑁂𑀳𑀺, 𑀲𑀳𑀲𑁆𑀲𑀁 𑀤𑀺𑀝𑁆𑀞 [𑀤𑀝𑁆𑀞𑀼 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑁄𑀡𑀓𑀁;

𑀅𑀳𑀁 𑀢𑁂 𑀲𑁄𑀡𑀓𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁 [𑀅𑀳𑀁 𑀲𑁄𑀡𑀓𑀫𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁 (𑀲𑀻. 𑀧𑀻.), 𑀅𑀳𑀁 𑀢𑁂 𑀲𑁄𑀡𑀓𑀫𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁 (𑀲𑁆𑀬𑀸.)], 𑀲𑀳𑀸𑀬𑀁 𑀧𑀁𑀲𑀼𑀓𑀻𑀴𑀺𑀢𑀁’’.

𑁩.

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

𑀓𑀢𑁆𑀣 𑀲𑁄𑀡𑀓𑀫𑀤𑁆𑀤𑀓𑁆𑀔𑀺 [𑀓𑀢𑁆𑀣 𑀢𑁂 𑀲𑁄𑀡𑀓𑁄 𑀤𑀺𑀝𑁆𑀞𑁄 (𑀲𑀻. 𑀧𑀻.)], 𑀢𑀁 𑀫𑁂 𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄’’.

𑁪.

‘‘𑀢𑀯𑁂𑀯 𑀤𑁂𑀯 𑀯𑀺𑀚𑀺𑀢𑁂, 𑀢𑀯𑁂𑀯𑀼𑀬𑁆𑀬𑀸𑀦𑀪𑀽𑀫𑀺𑀬𑀸;

𑀉𑀚𑀼𑀯𑀁𑀲𑀸 𑀫𑀳𑀸𑀲𑀸𑀮𑀸, 𑀦𑀻𑀮𑁄𑀪𑀸𑀲𑀸 𑀫𑀦𑁄𑀭𑀫𑀸.

𑁫.

‘‘𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺 𑀫𑁂𑀖𑀲𑀫𑀸𑀦𑀸, 𑀭𑀫𑁆𑀫𑀸 𑀅𑀜𑁆𑀜𑁄𑀜𑁆𑀜𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸;

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

𑀉𑀧𑀸𑀤𑀸𑀦𑁂𑀲𑀼 𑀮𑁄𑀓𑁂𑀲𑀼, 𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑁂𑀲𑀼 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄.

𑁬.

‘‘𑀢𑀢𑁄 𑀘 𑀭𑀸𑀚𑀸 𑀧𑀸𑀬𑀸𑀲𑀺, 𑀲𑁂𑀦𑀸𑀬 𑀘𑀢𑀼𑀭𑀗𑁆𑀕𑀺𑀬𑀸;

𑀓𑀸𑀭𑀸𑀧𑁂𑀢𑁆𑀯𑀸 𑀲𑀫𑀁 𑀫𑀕𑁆𑀕𑀁, 𑀅𑀕𑀫𑀸 𑀬𑁂𑀦 𑀲𑁄𑀡𑀓𑁄.

𑁭.

‘‘𑀉𑀬𑁆𑀬𑀸𑀦𑀪𑀽𑀫𑀺𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦, 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑁄 𑀩𑁆𑀭𑀳𑀸𑀯𑀦𑁂;

𑀆𑀲𑀻𑀦𑀁 ¶ 𑀲𑁄𑀡𑀓𑀁 𑀤𑀓𑁆𑀔𑀺, 𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑁂𑀲𑀼 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀁’’.

𑁮.

‘‘𑀓𑀧𑀡𑁄 𑀯𑀢𑀬𑀁 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀫𑀼𑀡𑁆𑀟𑁄 𑀲𑀗𑁆𑀖𑀸𑀝𑀺𑀧𑀸𑀭𑀼𑀢𑁄;

𑀅𑀫𑀸𑀢𑀺𑀓𑁄 𑀅𑀧𑀺𑀢𑀺𑀓𑁄, 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀲𑁆𑀫𑀺 𑀛𑀸𑀬𑀢𑀺’’.

𑁯.

‘‘𑀇𑀫𑀁 𑀯𑀸𑀓𑁆𑀬𑀁 𑀦𑀺𑀲𑀸𑀫𑁂𑀢𑁆𑀯𑀸, 𑀲𑁄𑀡𑀓𑁄 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

‘𑀦 𑀭𑀸𑀚 𑀓𑀧𑀡𑁄 𑀳𑁄𑀢𑀺, 𑀥𑀫𑁆𑀫𑀁 𑀓𑀸𑀬𑁂𑀦 𑀨𑀲𑁆𑀲𑀬𑀁 [𑀨𑀼𑀲𑀬𑀁 (𑀓.)].

𑁧𑁦.

‘𑀬𑁄 ¶ 𑀘 [𑀬𑁄𑀥 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀥𑀫𑁆𑀫𑀁 𑀦𑀺𑀭𑀁𑀓𑀢𑁆𑀯𑀸 [𑀦𑀺𑀭𑀸𑀓𑀢𑁆𑀯𑀸 (?)], 𑀅𑀥𑀫𑁆𑀫𑀫𑀦𑀼𑀯𑀢𑁆𑀢𑀢𑀺;

𑀲 𑀭𑀸𑀚 𑀓𑀧𑀡𑁄 𑀳𑁄𑀢𑀺, 𑀧𑀸𑀧𑁄 𑀧𑀸𑀧𑀧𑀭𑀸𑀬𑀦𑁄’’’.

𑁧𑁧.

‘‘‘𑀅𑀭𑀺𑀦𑁆𑀤𑀫𑁄𑀢𑀺 ¶ 𑀫𑁂 𑀦𑀸𑀫𑀁, 𑀓𑀸𑀲𑀺𑀭𑀸𑀚𑀸𑀢𑀺 𑀫𑀁 𑀯𑀺𑀤𑀽;

𑀓𑀘𑁆𑀘𑀺 𑀪𑁄𑀢𑁄 𑀲𑀼𑀔𑀲𑁆𑀲𑁂𑀬𑁆𑀬𑀸 [𑀲𑀼𑀔𑀸 𑀲𑁂𑀬𑁆𑀬𑀸 (𑀧𑀻.), 𑀲𑀼𑀔𑀲𑁂𑀬𑁆𑀬𑁄 (𑀓.)], 𑀇𑀥 𑀧𑀢𑁆𑀢𑀲𑁆𑀲 𑀲𑁄𑀡𑀓’’’.

𑁧𑁨.

‘‘𑀲𑀤𑀸𑀧𑀺 𑀪𑀤𑁆𑀭𑀫𑀥𑀦𑀲𑁆𑀲, 𑀅𑀦𑀸𑀕𑀸𑀭𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄;

𑀦 𑀢𑁂𑀲𑀁 𑀓𑁄𑀝𑁆𑀞𑁂 𑀑𑀧𑁂𑀦𑁆𑀢𑀺, 𑀦 𑀓𑀼𑀫𑁆𑀪𑀺𑀁 𑀦 𑀔𑀴𑁄𑀧𑀺𑀬𑀁 [𑀦 𑀓𑀼𑀫𑁆𑀪𑁂 𑀦 𑀓𑀴𑁄𑀧𑀺𑀬𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

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

𑁧𑁩.

‘‘𑀤𑀼𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀪𑀤𑁆𑀭𑀫𑀥𑀦𑀲𑁆𑀲, 𑀅𑀦𑀸𑀕𑀸𑀭𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄;

𑀅𑀦𑀯𑀚𑁆𑀚𑀧𑀺𑀡𑁆𑀟𑁄 [𑀅𑀦𑀯𑀚𑁆𑀚𑁄 𑀧𑀺𑀡𑁆𑀟𑀸 (𑀧𑀻.)] 𑀪𑁄𑀢𑁆𑀢𑀩𑁆𑀩𑁄, 𑀦 𑀘 𑀓𑁄𑀘𑀽𑀧𑀭𑁄𑀥𑀢𑀺.

𑁧𑁪.

‘‘𑀢𑀢𑀺𑀬𑀫𑁆𑀧𑀺 𑀪𑀤𑁆𑀭𑀫𑀥𑀦𑀲𑁆𑀲, 𑀅𑀦𑀸𑀕𑀸𑀭𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄;

𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄 𑀧𑀺𑀡𑁆𑀟𑁄 𑀪𑁄𑀢𑁆𑀢𑀩𑁆𑀩𑁄, 𑀦 𑀘 𑀓𑁄𑀘𑀽𑀧𑀭𑁄𑀥𑀢𑀺.

𑁧𑁫.

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

𑀫𑀼𑀢𑁆𑀢𑀲𑁆𑀲 𑀭𑀝𑁆𑀞𑁂 𑀘𑀭𑀢𑁄, 𑀲𑀗𑁆𑀕𑁄 𑀬𑀲𑁆𑀲 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺.

𑁧𑁬.

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

𑀦𑀕𑀭𑀫𑁆𑀳𑀺 𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑀫𑁆𑀳𑀺, 𑀦𑀸𑀲𑁆𑀲 𑀓𑀺𑀜𑁆𑀘𑀺 𑀅𑀟𑀬𑁆𑀳𑀣.

𑁧𑁭.

‘‘𑀙𑀝𑁆𑀞𑀫𑁆𑀧𑀺 ¶ [𑀙𑀝𑁆𑀞𑀁 (𑀧𑀻.)] 𑀪𑀤𑁆𑀭𑀫𑀥𑀦𑀲𑁆𑀲, 𑀅𑀦𑀸𑀕𑀸𑀭𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄;

𑀭𑀝𑁆𑀞𑁂 𑀯𑀺𑀮𑀼𑀫𑁆𑀧𑀫𑀸𑀦𑀫𑁆𑀳𑀺 [𑀯𑀺𑀮𑀼𑀧𑁆𑀧𑀫𑀸𑀦𑀫𑁆𑀳𑀺 (𑀓.)], 𑀦𑀸𑀲𑁆𑀲 𑀓𑀺𑀜𑁆𑀘𑀺 𑀅𑀳𑀻𑀭𑀣 [𑀅𑀳𑀸𑀭𑀣 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)].

𑁧𑁮.

‘‘𑀲𑀢𑁆𑀢𑀫𑀫𑁆𑀧𑀺 [𑀲𑀢𑁆𑀢𑀫𑀁 (𑀧𑀻.)] 𑀪𑀤𑁆𑀭𑀫𑀥𑀦𑀲𑁆𑀲, 𑀅𑀦𑀸𑀕𑀸𑀭𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄;

𑀘𑁄𑀭𑁂𑀳𑀺 𑀭𑀓𑁆𑀔𑀺𑀢𑀁 𑀫𑀕𑁆𑀕𑀁, 𑀬𑁂 𑀘𑀜𑁆𑀜𑁂 𑀧𑀭𑀺𑀧𑀦𑁆𑀣𑀺𑀓𑀸;

𑀧𑀢𑁆𑀢𑀘𑀻𑀯𑀭𑀫𑀸𑀤𑀸𑀬, 𑀲𑁄𑀢𑁆𑀣𑀺𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀲𑀼𑀩𑁆𑀩𑀢𑁄.

𑁧𑁯.

‘‘𑀅𑀝𑁆𑀞𑀫𑀫𑁆𑀧𑀺 [𑀅𑀝𑁆𑀞𑀫𑀁 (𑀧𑀻.)] 𑀪𑀤𑁆𑀭𑀫𑀥𑀦𑀲𑁆𑀲, 𑀅𑀦𑀸𑀕𑀸𑀭𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄;

𑀬𑀁 𑀬𑀁 𑀤𑀺𑀲𑀁 𑀧𑀓𑁆𑀓𑀫𑀢𑀺, 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑁄𑀯 𑀕𑀘𑁆𑀙𑀢𑀺’’.

𑁨𑁦.

‘‘𑀩𑀳𑀽𑀧𑀺 𑀪𑀤𑁆𑀭𑀸 [𑀩𑀳𑀽𑀦𑀺 𑀲𑀫𑀡𑀪𑀤𑁆𑀭𑀸𑀦𑀺 (𑀲𑀻.), 𑀩𑀳𑀽𑀧𑀺 𑀪𑀤𑁆𑀭𑀓𑀸 𑀏𑀢𑁂 (𑀧𑀻.)] 𑀏𑀢𑁂𑀲𑀁, 𑀬𑁄 𑀢𑁆𑀯𑀁 𑀪𑀺𑀓𑁆𑀔𑀼 𑀧𑀲𑀁𑀲𑀲𑀺;

𑀅𑀳𑀜𑁆𑀘 𑀕𑀺𑀤𑁆𑀥𑁄 𑀓𑀸𑀫𑁂𑀲𑀼, 𑀓𑀣𑀁 𑀓𑀸𑀳𑀸𑀫𑀺 𑀲𑁄𑀡𑀓.

𑁨𑁧.

‘‘𑀧𑀺𑀬𑀸 ¶ 𑀫𑁂 𑀫𑀸𑀦𑀼𑀲𑀸 𑀓𑀸𑀫𑀸, 𑀅𑀣𑁄 𑀤𑀺𑀩𑁆𑀬𑀸𑀧𑀺 𑀫𑁂 𑀧𑀺𑀬𑀸;

𑀅𑀣 𑀓𑁂𑀦 𑀦𑀼 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀉𑀪𑁄 𑀮𑁄𑀓𑁂 𑀮𑀪𑀸𑀫𑀲𑁂’’.

𑁨𑁨.

‘‘𑀓𑀸𑀫𑁂 𑀕𑀺𑀤𑁆𑀥𑀸 [𑀓𑀸𑀫𑁂𑀲𑀼 𑀕𑀺𑀤𑁆𑀥𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀓𑀸𑀫𑀭𑀢𑀸, 𑀓𑀸𑀫𑁂𑀲𑀼 𑀅𑀥𑀺𑀫𑀼𑀘𑁆𑀙𑀺𑀢𑀸;

𑀦𑀭𑀸 𑀧𑀸𑀧𑀸𑀦𑀺 𑀓𑀢𑁆𑀯𑀸𑀦, 𑀉𑀧𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

𑁨𑁩.

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

𑀏𑀓𑁄𑀤𑀺𑀪𑀸𑀯𑀸𑀥𑀺𑀕𑀢𑀸, 𑀦 𑀢𑁂 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

𑁨𑁪.

‘‘𑀉𑀧𑀫𑀁 𑀢𑁂 𑀓𑀭𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀢𑀁 𑀲𑀼𑀡𑁄𑀳𑀺 𑀅𑀭𑀺𑀦𑁆𑀤𑀫;

𑀉𑀧𑀫𑀸𑀬 𑀫𑀺𑀥𑁂𑀓𑀘𑁆𑀘𑁂 [𑀧𑀺𑀥𑁂𑀓𑀘𑁆𑀘𑁂 (𑀲𑀻. 𑀧𑀻.)], 𑀅𑀢𑁆𑀣𑀁 𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑀸.

𑁨𑁫.

‘‘𑀕𑀗𑁆𑀕𑀸𑀬 ¶ 𑀓𑀼𑀡𑀧𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀯𑀼𑀬𑁆𑀳𑀫𑀸𑀦𑀁 𑀫𑀳𑀡𑁆𑀡𑀯𑁂;

𑀯𑀸𑀬𑀲𑁄 𑀲𑀫𑀘𑀺𑀦𑁆𑀢𑁂𑀲𑀺, 𑀅𑀧𑁆𑀧𑀧𑀜𑁆𑀜𑁄 𑀅𑀘𑁂𑀢𑀲𑁄.

𑁨𑁬.

‘‘‘𑀬𑀸𑀦𑀜𑁆𑀘 ¶ 𑀯𑀢𑀺𑀤𑀁 𑀮𑀤𑁆𑀥𑀁, 𑀪𑀓𑁆𑀔𑁄 𑀘𑀸𑀬𑀁 𑀅𑀦𑀧𑁆𑀧𑀓𑁄’;

𑀢𑀢𑁆𑀣 𑀭𑀢𑁆𑀢𑀺𑀁 𑀢𑀢𑁆𑀣 𑀤𑀺𑀯𑀸, 𑀢𑀢𑁆𑀣𑁂𑀯 𑀦𑀺𑀭𑀢𑁄 𑀫𑀦𑁄.

𑁨𑁭.

‘‘𑀔𑀸𑀤𑀁 𑀦𑀸𑀕𑀲𑁆𑀲 𑀫𑀁𑀲𑀸𑀦𑀺, 𑀧𑀺𑀯𑀁 𑀪𑀸𑀕𑀻𑀭𑀣𑁄𑀤𑀓𑀁 [𑀪𑀸𑀕𑀺𑀭𑀲𑁄𑀤𑀓𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)];

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

𑁨𑁮.

‘‘𑀢𑀜𑁆𑀘 [𑀢𑀁𑀯 (𑀧𑀻.)] 𑀑𑀢𑀭𑀡𑀻 𑀕𑀗𑁆𑀕𑀸, 𑀧𑀫𑀢𑁆𑀢𑀁 𑀓𑀼𑀡𑀧𑁂 𑀭𑀢𑀁;

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

𑁨𑁯.

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

𑀦 𑀧𑀘𑁆𑀙𑀢𑁄 𑀦 𑀧𑀼𑀭𑀢𑁄, 𑀦𑀼𑀢𑁆𑀢𑀭𑀁 𑀦𑁄𑀧𑀺 𑀤𑀓𑁆𑀔𑀺𑀡𑀁.

𑁩𑁦.

‘‘𑀤𑀻𑀧𑀁 𑀲𑁄 𑀦𑀚𑁆𑀛𑀕𑀸𑀕𑀜𑁆𑀙𑀺 [𑀦 𑀅𑀚𑁆𑀛𑀕𑀜𑁆𑀙𑀺 (𑀲𑀻.), 𑀦 𑀅𑀚𑁆𑀛𑀕𑀘𑁆𑀙𑀺 (𑀧𑀻.)], 𑀅𑀕𑀢𑀻 𑀬𑀢𑁆𑀣 𑀧𑀓𑁆𑀔𑀺𑀦𑀁;

𑀲𑁄 𑀘 𑀢𑀢𑁆𑀣𑁂𑀯 𑀧𑀸𑀧𑀢𑁆𑀣, 𑀬𑀣𑀸 𑀤𑀼𑀩𑁆𑀩𑀮𑀓𑁄 𑀢𑀣𑀸.

𑁩𑁧.

‘‘𑀢𑀜𑁆𑀘 𑀲𑀸𑀫𑀼𑀤𑁆𑀤𑀺𑀓𑀸 𑀫𑀘𑁆𑀙𑀸, 𑀓𑀼𑀫𑁆𑀪𑀻𑀮𑀸 𑀫𑀓𑀭𑀸 𑀲𑀼𑀲𑀽;

𑀧𑀲𑀬𑁆𑀳𑀓𑀸𑀭𑀸 𑀔𑀸𑀤𑀺𑀁𑀲𑀼, 𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑀁 𑀯𑀺𑀧𑀓𑁆𑀔𑀓𑀁 [𑀯𑀺𑀧𑀓𑁆𑀔𑀺𑀦𑀁 (𑀲𑀻. 𑀧𑀻.), 𑀯𑀺𑀧𑀓𑁆𑀔𑀺𑀓𑀁 (𑀲𑁆𑀬𑀸.)].

𑁩𑁨.

‘‘𑀏𑀯𑀫𑁂𑀯 ¶ 𑀢𑀼𑀯𑀁 𑀭𑀸𑀚, 𑀬𑁂 𑀘𑀜𑁆𑀜𑁂 𑀓𑀸𑀫𑀪𑁄𑀕𑀺𑀦𑁄;

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

𑁩𑁩.

‘‘𑀏𑀲𑀸 𑀢𑁂 𑀉𑀧𑀫𑀸 𑀭𑀸𑀚, 𑀅𑀢𑁆𑀣𑀲𑀦𑁆𑀤𑀲𑁆𑀲𑀦𑀻 𑀓𑀢𑀸;

𑀢𑁆𑀯𑀜𑁆𑀘 𑀧𑀜𑁆𑀜𑀸𑀬𑀲𑁂 𑀢𑁂𑀦, 𑀬𑀤𑀺 𑀓𑀸𑀳𑀲𑀺 𑀯𑀸 𑀦 𑀯𑀸.

𑁩𑁪.

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

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

𑁩𑁫.

‘‘𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀧𑀓𑁆𑀓𑀸𑀫𑀺, 𑀲𑁄𑀡𑀓𑁄 𑀅𑀫𑀺𑀢𑀩𑀼𑀤𑁆𑀥𑀺𑀫𑀸 [𑀲𑁄𑀡𑀓𑁄’𑀫𑀺𑀢𑀩𑀼𑀤𑁆𑀥𑀺𑀫𑀸 (?)];

𑀯𑁂𑀳𑀸𑀲𑁂 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑀲𑁆𑀫𑀺𑀁, 𑀅𑀦𑀼𑀲𑀸𑀲𑀺𑀢𑁆𑀯𑀸𑀦 𑀔𑀢𑁆𑀢𑀺𑀬𑀁’’.

𑁩𑁬.

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

𑀭𑀚𑁆𑀚𑀁 𑀦𑀺𑀬𑁆𑀬𑀸𑀤𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀦𑀸𑀳𑀁 𑀭𑀚𑁆𑀚𑁂𑀦 𑀫𑀢𑁆𑀣𑀺𑀓𑁄.

𑁩𑁭.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀓𑁄 𑀚𑀜𑁆𑀜𑀸 𑀫𑀭𑀡𑀁 𑀲𑀼𑀯𑁂;

𑀫𑀸𑀳𑀁 𑀓𑀸𑀓𑁄𑀯 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀓𑀸𑀫𑀸𑀦𑀁 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀁’’ [𑀯𑀲𑀫𑀦𑁆𑀦𑀕𑀸 (𑀧𑀻.)].

𑁩𑁮.

‘‘𑀅𑀢𑁆𑀣𑀺 𑀢𑁂 𑀤𑀳𑀭𑁄 𑀧𑀼𑀢𑁆𑀢𑁄, 𑀤𑀻𑀖𑀸𑀯𑀼 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦𑁄;

𑀢𑀁 𑀭𑀚𑁆𑀚𑁂 𑀅𑀪𑀺𑀲𑀺𑀜𑁆𑀘𑀲𑁆𑀲𑀼, 𑀲𑁄 𑀦𑁄 𑀭𑀸𑀚𑀸 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺’’.

𑁩𑁯.

‘‘𑀔𑀺𑀧𑁆𑀧𑀁 𑀓𑀼𑀫𑀸𑀭𑀫𑀸𑀦𑁂𑀣, 𑀤𑀻𑀖𑀸𑀯𑀼𑀁 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦𑀁;

𑀢𑀁 𑀭𑀚𑁆𑀚𑁂 𑀅𑀪𑀺𑀲𑀺𑀜𑁆𑀘𑀺𑀲𑁆𑀲𑀁, 𑀲𑁄 𑀯𑁄 𑀭𑀸𑀚𑀸 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺’’.

𑁪𑁦.

‘‘𑀢𑀢𑁄 ¶ 𑀓𑀼𑀫𑀸𑀭𑀫𑀸𑀦𑁂𑀲𑀼𑀁, 𑀤𑀻𑀖𑀸𑀯𑀼𑀁 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦𑀁;

𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀆𑀮𑀧𑀻 𑀭𑀸𑀚𑀸, 𑀏𑀓𑀧𑀼𑀢𑁆𑀢𑀁 𑀫𑀦𑁄𑀭𑀫𑀁.

𑁪𑁧.

‘‘𑀲𑀝𑁆𑀞𑀺 𑀕𑀸𑀫𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀸𑀦𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

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

𑁪𑁨.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀓𑁄 𑀚𑀜𑁆𑀜𑀸 𑀫𑀭𑀡𑀁 𑀲𑀼𑀯𑁂;

𑀫𑀸𑀳𑀁 𑀓𑀸𑀓𑁄𑀯 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀓𑀸𑀫𑀸𑀦𑀁 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀁 [𑀯𑀲𑀫𑀦𑁆𑀦𑀕𑀸 (𑀧𑀻.)].

𑁪𑁩.

‘‘𑀲𑀝𑁆𑀞𑀺 𑀦𑀸𑀕𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀩𑁆𑀩𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀪𑀽𑀲𑀺𑀢𑀸;

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

𑁪𑁪.

‘‘𑀆𑀭𑀽𑀴𑁆𑀳𑀸 ¶ 𑀕𑀸𑀫𑀡𑀻𑀬𑁂𑀳𑀺, 𑀢𑁄𑀫𑀭𑀗𑁆𑀓𑀼𑀲𑀧𑀸𑀡𑀺𑀪𑀺;

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

𑁪𑁫.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀓𑁄 𑀚𑀜𑁆𑀜𑀸 𑀫𑀭𑀡𑀁 𑀲𑀼𑀯𑁂;

𑀫𑀸𑀳𑀁 𑀓𑀸𑀓𑁄𑀯 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀓𑀸𑀫𑀸𑀦𑀁 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀁.

𑁪𑁬.

‘‘𑀲𑀝𑁆𑀞𑀺 ¶ 𑀅𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀩𑁆𑀩𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀪𑀽𑀲𑀺𑀢𑀸;

𑀆𑀚𑀸𑀦𑀻𑀬𑀸𑀯 𑀚𑀸𑀢𑀺𑀬𑀸, 𑀲𑀺𑀦𑁆𑀥𑀯𑀸 𑀲𑀻𑀖𑀯𑀸𑀳𑀺𑀦𑁄.

𑁪𑁭.

‘‘𑀆𑀭𑀽𑀴𑁆𑀳𑀸 𑀕𑀸𑀫𑀡𑀻𑀬𑁂𑀳𑀺, 𑀇𑀮𑁆𑀮𑀺𑀬𑀸𑀘𑀸𑀧𑀥𑀸𑀭𑀺𑀪𑀺 [𑀇𑀦𑁆𑀤𑀺𑀬𑀸𑀘𑀸𑀧𑀥𑀸𑀭𑀺𑀪𑀺 (𑀓.)];

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

𑁪𑁮.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀓𑁄 𑀚𑀜𑁆𑀜𑀸 𑀫𑀭𑀡𑀁 𑀲𑀼𑀯𑁂;

𑀫𑀸𑀳𑀁 𑀓𑀸𑀓𑁄𑀯 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀓𑀸𑀫𑀸𑀦𑀁 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀁.

𑁪𑁯.

‘‘𑀲𑀝𑁆𑀞𑀺 𑀭𑀣𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀦𑁆𑀦𑀤𑁆𑀥𑀸 𑀉𑀲𑁆𑀲𑀺𑀢𑀤𑁆𑀥𑀚𑀸;

𑀤𑀻𑀧𑀸 𑀅𑀣𑁄𑀧𑀺 𑀯𑁂𑀬𑁆𑀬𑀕𑁆𑀖𑀸, 𑀲𑀩𑁆𑀩𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀪𑀽𑀲𑀺𑀢𑀸.

𑁫𑁦.

‘‘𑀆𑀭𑀽𑀴𑁆𑀳𑀸 𑀕𑀸𑀫𑀡𑀻𑀬𑁂𑀳𑀺, 𑀘𑀸𑀧𑀳𑀢𑁆𑀣𑁂𑀳𑀺 𑀯𑀫𑁆𑀫𑀺𑀪𑀺;

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

𑁫𑁧.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀓𑁄 𑀚𑀜𑁆𑀜𑀸 𑀫𑀭𑀡𑀁 𑀲𑀼𑀯𑁂;

𑀫𑀸𑀳𑀁 𑀓𑀸𑀓𑁄𑀯 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀓𑀸𑀫𑀸𑀦𑀁 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀁.

𑁫𑁨.

‘‘𑀲𑀝𑁆𑀞𑀺 𑀥𑁂𑀦𑀼𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀭𑁄𑀳𑀜𑁆𑀜𑀸 𑀧𑀼𑀗𑁆𑀕𑀯𑀽𑀲𑀪𑀸;

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

𑁫𑁩.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀓𑁄 𑀚𑀜𑁆𑀜𑀸 𑀫𑀭𑀡𑀁 𑀲𑀼𑀯𑁂;

𑀫𑀸𑀳𑀁 𑀓𑀸𑀓𑁄𑀯 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀓𑀸𑀫𑀸𑀦𑀁 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀁.

𑁫𑁪.

‘‘𑀲𑁄𑀴𑀲𑀺𑀢𑁆𑀣𑀺𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 ¶ , 𑀲𑀩𑁆𑀩𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀪𑀽𑀲𑀺𑀢𑀸;

𑀯𑀺𑀘𑀺𑀢𑁆𑀭𑀯𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑀸, 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀸;

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

𑁫𑁫.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀓𑁄 𑀚𑀜𑁆𑀜𑀸 𑀫𑀭𑀡𑀁 𑀲𑀼𑀯𑁂;

𑀫𑀸𑀳𑀁 ¶ 𑀓𑀸𑀓𑁄𑀯 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀓𑀸𑀫𑀸𑀦𑀁 𑀯𑀲𑀫𑀦𑁆𑀯𑀕𑀁’’.

𑁫𑁬.

‘‘𑀤𑀳𑀭𑀲𑁆𑀲𑁂𑀯 ¶ 𑀫𑁂 𑀢𑀸𑀢, 𑀫𑀸𑀢𑀸 𑀫𑀢𑀸𑀢𑀺 𑀫𑁂 𑀲𑀼𑀢𑀁;

𑀢𑀬𑀸 𑀯𑀺𑀦𑀸 𑀅𑀳𑀁 𑀢𑀸𑀢, 𑀚𑀻𑀯𑀺𑀢𑀼𑀫𑁆𑀧𑀺 𑀦 𑀉𑀲𑁆𑀲𑀳𑁂.

𑁫𑁭.

‘‘𑀬𑀣𑀸 𑀆𑀭𑀜𑁆𑀜𑀓𑀁 𑀦𑀸𑀕𑀁, 𑀧𑁄𑀢𑁄 𑀅𑀦𑁆𑀯𑁂𑀢𑀺 𑀧𑀘𑁆𑀙𑀢𑁄;

𑀚𑁂𑀲𑁆𑀲𑀦𑁆𑀢𑀁 𑀕𑀺𑀭𑀺𑀤𑀼𑀕𑁆𑀕𑁂𑀲𑀼, 𑀲𑀫𑁂𑀲𑀼 𑀯𑀺𑀲𑀫𑁂𑀲𑀼 𑀘.

𑁫𑁮.

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

𑀲𑀼𑀪𑀭𑁄 𑀢𑁂 𑀪𑀯𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀦 𑀢𑁂 𑀳𑁂𑀲𑁆𑀲𑀸𑀫𑀺 𑀤𑀼𑀩𑁆𑀪𑀭𑁄’’.

𑁫𑁯.

‘‘𑀬𑀣𑀸 𑀲𑀸𑀫𑀼𑀤𑁆𑀤𑀺𑀓𑀁 𑀦𑀸𑀯𑀁, 𑀯𑀸𑀡𑀺𑀚𑀸𑀦𑀁 𑀥𑀦𑁂𑀲𑀺𑀦𑀁;

𑀯𑁄𑀳𑀸𑀭𑁄 𑀢𑀢𑁆𑀣 𑀕𑀡𑁆𑀳𑁂𑀬𑁆𑀬, 𑀯𑀸𑀡𑀺𑀚𑀸 𑀩𑁆𑀬𑀲𑀦𑀻 [𑀩𑁆𑀬𑀲𑀦𑀁 (𑀓.)] 𑀲𑀺𑀬𑀸.

𑁬𑁦.

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

𑀇𑀫𑀁 𑀓𑀼𑀫𑀸𑀭𑀁 𑀧𑀸𑀧𑁂𑀣, 𑀧𑀸𑀲𑀸𑀤𑀁 𑀭𑀢𑀺𑀯𑀟𑁆𑀠𑀦𑀁.

𑁬𑁧.

‘‘𑀢𑀢𑁆𑀣 𑀓𑀫𑁆𑀩𑀼𑀲𑀳𑀢𑁆𑀣𑀸𑀬𑁄, 𑀬𑀣𑀸 𑀲𑀓𑁆𑀓𑀁𑀯 𑀅𑀘𑁆𑀙𑀭𑀸;

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

𑁬𑁨.

‘‘𑀢𑀢𑁄 𑀓𑀼𑀫𑀸𑀭𑀁 𑀧𑀸𑀧𑁂𑀲𑀼𑀁, 𑀧𑀸𑀲𑀸𑀤𑀁 𑀭𑀢𑀺𑀯𑀟𑁆𑀠𑀦𑀁;

𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀅𑀯𑀘𑀼𑀁 𑀓𑀜𑁆𑀜𑀸, 𑀤𑀻𑀖𑀸𑀯𑀼𑀁 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦𑀁.

𑁬𑁩.

‘‘𑀤𑁂𑀯𑀢𑀸 𑀦𑀼𑀲𑀺 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀅𑀤𑀼 [𑀆𑀤𑀼 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀓𑁄 𑀯𑀸 𑀢𑁆𑀯𑀁 𑀓𑀲𑁆𑀲 𑀯𑀸 𑀧𑀼𑀢𑁆𑀢𑁄, 𑀓𑀣𑀁 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑀁 𑀫𑀬𑀁’’.

𑁬𑁪.

‘‘𑀦𑀫𑁆𑀳𑀺 𑀤𑁂𑀯𑁄 𑀦 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀦𑀸𑀧𑀺 [𑀦𑀫𑁆𑀳𑀺 (𑀓.)] 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀓𑀸𑀲𑀺𑀭𑀜𑁆𑀜𑁄 𑀅𑀳𑀁 𑀧𑀼𑀢𑁆𑀢𑁄, 𑀤𑀻𑀖𑀸𑀯𑀼 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦𑁄;

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

𑁬𑁫.

‘‘𑀢𑀁 ¶ 𑀢𑀢𑁆𑀣 𑀅𑀯𑀘𑀼𑀁 𑀓𑀜𑁆𑀜𑀸, 𑀤𑀻𑀖𑀸𑀯𑀼𑀁 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦𑀁;

‘𑀓𑀼𑀳𑀺𑀁 𑀭𑀸𑀚𑀸 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁄, 𑀇𑀢𑁄 𑀭𑀸𑀚𑀸 𑀓𑀼𑀳𑀺𑀁 𑀕𑀢𑁄’’’.

𑁬𑁬.

‘‘𑀧𑀗𑁆𑀓𑀁 𑀭𑀸𑀚𑀸 𑀅𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑁄, 𑀣𑀮𑁂 𑀭𑀸𑀚𑀸 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑁄;

𑀅𑀓𑀡𑁆𑀝𑀓𑀁 𑀅𑀕𑀳𑀦𑀁, 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑁄 𑀫𑀳𑀸𑀧𑀣𑀁.

𑁬𑁭.

‘‘𑀅𑀳𑀜𑁆𑀘 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑁄𑀲𑁆𑀫𑀺, 𑀫𑀕𑁆𑀕𑀁 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀕𑀸𑀫𑀺𑀦𑀁;

𑀲𑀓𑀡𑁆𑀝𑀓𑀁 𑀲𑀕𑀳𑀦𑀁, 𑀬𑁂𑀦 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁’’.

𑁬𑁮.

‘‘𑀢𑀲𑁆𑀲 ¶ ¶ 𑀢𑁂 𑀲𑁆𑀯𑀸𑀕𑀢𑀁 𑀭𑀸𑀚, 𑀲𑀻𑀳𑀲𑁆𑀲𑁂𑀯 𑀕𑀺𑀭𑀺𑀩𑁆𑀩𑀚𑀁;

𑀅𑀦𑀼𑀲𑀸𑀲 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀢𑁆𑀯𑀁 𑀦𑁄 𑀲𑀩𑁆𑀩𑀸𑀲𑀫𑀺𑀲𑁆𑀲𑀭𑁄’’𑀢𑀺.

𑀲𑁄𑀡𑀓𑀚𑀸𑀢𑀓𑀁 𑀧𑀞𑀫𑀁.

𑁫𑁩𑁦. 𑀲𑀁𑀓𑀺𑀘𑁆𑀘𑀚𑀸𑀢𑀓𑀁 (𑁨)

𑁬𑁯.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁 𑀭𑀸𑀚𑀸𑀦𑀁, 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀁 𑀭𑀣𑁂𑀲𑀪𑀁;

𑀅𑀣𑀲𑁆𑀲 𑀧𑀝𑀺𑀯𑁂𑀤𑁂𑀲𑀺, 𑀬𑀲𑁆𑀲𑀸𑀲𑀺 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑁄.

𑁭𑁦.

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

𑀢𑀭𑀫𑀸𑀦𑀭𑀽𑀧𑁄 𑀦𑀺𑀬𑁆𑀬𑀸𑀳𑀺, 𑀔𑀺𑀧𑁆𑀧𑀁 𑀧𑀲𑁆𑀲 𑀫𑀳𑁂𑀲𑀺𑀦𑀁.

𑁭𑁧.

‘‘𑀢𑀢𑁄 𑀘 𑀭𑀸𑀚𑀸 𑀢𑀭𑀫𑀸𑀦𑁄, 𑀬𑀼𑀢𑁆𑀢𑀫𑀸𑀭𑀼𑀬𑁆𑀳 𑀲𑀦𑁆𑀤𑀦𑀁;

𑀫𑀺𑀢𑁆𑀢𑀸𑀫𑀘𑁆𑀘𑀧𑀭𑀺𑀩𑁆𑀬𑀽𑀴𑁆𑀳𑁄 [𑀧𑀭𑀺𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑁄 (𑀲𑀻. 𑀧𑀻.)], 𑀅𑀕𑀫𑀸𑀲𑀺 𑀭𑀣𑁂𑀲𑀪𑁄.

𑁭𑁨.

‘‘𑀦𑀺𑀓𑁆𑀔𑀺𑀧𑁆𑀧 𑀧𑀜𑁆𑀘 𑀓𑀓𑀼𑀥𑀸𑀦𑀺, 𑀓𑀸𑀲𑀻𑀦𑀁 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦𑁄;

𑀯𑀸𑀴𑀩𑀻𑀚𑀦𑀺 [𑀯𑀸 𑀴𑀯𑀻𑀚𑀦𑀻 (𑀲𑀻. 𑀧𑀻.)] 𑀫𑀼𑀡𑁆𑀳𑀻𑀲𑀁, 𑀔𑀕𑁆𑀕𑀁 𑀙𑀢𑁆𑀢𑀜𑁆𑀘𑀼𑀧𑀸𑀳𑀦𑀁;

𑁭𑁩.

‘‘𑀑𑀭𑀼𑀬𑁆𑀳 𑀭𑀸𑀚𑀸 𑀬𑀸𑀦𑀫𑁆𑀳𑀸, 𑀞𑀧𑀬𑀺𑀢𑁆𑀯𑀸 𑀧𑀝𑀺𑀘𑁆𑀙𑀤𑀁;

𑀆𑀲𑀻𑀦𑀁 ¶ 𑀤𑀸𑀬𑀧𑀲𑁆𑀲𑀲𑁆𑀫𑀺𑀁, 𑀲𑀁𑀓𑀺𑀘𑁆𑀘𑀫𑀼𑀧𑀲𑀗𑁆𑀓𑀫𑀺.

𑁭𑁪.

‘‘𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀲𑁄 𑀭𑀸𑀚𑀸, 𑀲𑀫𑁆𑀫𑁄𑀤𑀺 𑀇𑀲𑀺𑀦𑀸 𑀲𑀳;

𑀢𑀁 𑀓𑀣𑀁 𑀯𑀻𑀢𑀺𑀲𑀸𑀭𑁂𑀢𑁆𑀯𑀸, 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀉𑀧𑀸𑀯𑀺𑀲𑀺.

𑁭𑁫.

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

𑀢𑀢𑁄 𑀧𑀸𑀧𑀸𑀦𑀺 𑀓𑀫𑁆𑀫𑀸𑀦𑀺, 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀼𑀁 𑀧𑀝𑀺𑀧𑀚𑁆𑀚𑀣.

𑁭𑁬.

‘‘𑀇𑀲𑀺𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫 [𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀁𑀓𑀺𑀘𑁆𑀘𑀁, 𑀇𑀲𑀻𑀦𑀁 𑀲𑀸𑀥𑀼𑀲𑀫𑁆𑀫𑀢𑀁;

𑀆𑀲𑀻𑀦𑀁 𑀤𑀸𑀬𑀧𑀲𑁆𑀲𑀲𑁆𑀫𑀺𑀁, 𑀇𑀲𑀺𑀲𑀗𑁆𑀖𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑀁 [𑀧𑀼𑀭𑀓𑁆𑀔𑀺𑀢𑀁 (𑀓.)].

𑁭𑁭.

‘‘𑀓𑀁 𑀕𑀢𑀺𑀁 𑀧𑁂𑀘𑁆𑀘 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀦𑀭𑀸 𑀥𑀫𑁆𑀫𑀸𑀢𑀺𑀘𑀸𑀭𑀺𑀦𑁄;

𑀅𑀢𑀺𑀘𑀺𑀡𑁆𑀡𑁄 𑀫𑀬𑀸 𑀥𑀫𑁆𑀫𑁄, 𑀢𑀁 𑀫𑁂 𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄.

𑁭𑁮.

‘‘𑀇𑀲𑀻 𑀅𑀯𑀘 𑀲𑀁𑀓𑀺𑀘𑁆𑀘𑁄, 𑀓𑀸𑀲𑀻𑀦𑀁 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦𑀁;

𑀆𑀲𑀻𑀦𑀁 𑀤𑀸𑀬𑀧𑀲𑁆𑀲𑀲𑁆𑀫𑀺𑀁, 𑀫𑀳𑀸𑀭𑀸𑀚 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑁂.

𑁭𑁯.

‘‘𑀉𑀧𑁆𑀧𑀣𑁂𑀦 ¶ 𑀯𑀚𑀦𑁆𑀢𑀲𑁆𑀲, 𑀬𑁄 𑀫𑀕𑁆𑀕𑀫𑀦𑀼𑀲𑀸𑀲𑀢𑀺;

𑀢𑀲𑁆𑀲 𑀘𑁂 𑀯𑀘𑀦𑀁 𑀓𑀬𑀺𑀭𑀸, 𑀦𑀸𑀲𑁆𑀲 𑀫𑀕𑁆𑀕𑁂𑀬𑁆𑀬 𑀓𑀡𑁆𑀝𑀓𑁄.

𑁮𑁦.

‘‘𑀅𑀥𑀫𑁆𑀫𑀁 ¶ 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀲𑁆𑀲, 𑀬𑁄 𑀥𑀫𑁆𑀫𑀫𑀦𑀼𑀲𑀸𑀲𑀢𑀺;

𑀢𑀲𑁆𑀲 𑀘𑁂 𑀯𑀘𑀦𑀁 𑀓𑀬𑀺𑀭𑀸, 𑀦 𑀲𑁄 𑀕𑀘𑁆𑀙𑁂𑀬𑁆𑀬 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

𑁮𑁧.

‘‘𑀥𑀫𑁆𑀫𑁄 𑀧𑀣𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀅𑀥𑀫𑁆𑀫𑁄 𑀧𑀦 𑀉𑀧𑁆𑀧𑀣𑁄;

𑀅𑀥𑀫𑁆𑀫𑁄 𑀦𑀺𑀭𑀬𑀁 𑀦𑁂𑀢𑀺, 𑀥𑀫𑁆𑀫𑁄 𑀧𑀸𑀧𑁂𑀢𑀺 𑀲𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

𑁮𑁨.

‘‘𑀅𑀥𑀫𑁆𑀫𑀘𑀸𑀭𑀺𑀦𑁄 𑀭𑀸𑀚, 𑀦𑀭𑀸 𑀯𑀺𑀲𑀫𑀚𑀻𑀯𑀺𑀦𑁄;

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

𑁮𑁩.

‘‘𑀲𑀜𑁆𑀚𑀻𑀯𑁄 𑀓𑀸𑀴𑀲𑀼𑀢𑁆𑀢𑁄 𑀘, 𑀲𑀗𑁆𑀖𑀸𑀢𑁄 [𑀲𑀗𑁆𑀔𑀸𑀝𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀤𑁆𑀯𑁂 𑀘 𑀭𑁄𑀭𑀼𑀯𑀸;

𑀅𑀣𑀸𑀧𑀭𑁄 ¶ 𑀫𑀳𑀸𑀯𑀻𑀘𑀺, 𑀢𑀸𑀧𑀦𑁄 [𑀢𑀧𑀦𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀘 𑀧𑀢𑀸𑀧𑀦𑁄.

𑁮𑁪.

‘‘𑀇𑀘𑁆𑀘𑁂𑀢𑁂 𑀅𑀝𑁆𑀞 𑀦𑀺𑀭𑀬𑀸, 𑀅𑀓𑁆𑀔𑀸𑀢𑀸 𑀤𑀼𑀭𑀢𑀺𑀓𑁆𑀓𑀫𑀸;

𑀆𑀓𑀺𑀡𑁆𑀡𑀸 𑀮𑀼𑀤𑁆𑀤𑀓𑀫𑁆𑀫𑁂𑀳𑀺, 𑀧𑀘𑁆𑀘𑁂𑀓𑀸 𑀲𑁄𑀴𑀲𑀼𑀲𑁆𑀲𑀤𑀸.

𑁮𑁫.

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

𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑀭𑀽𑀧𑀸 𑀘, 𑀪𑁂𑀲𑁆𑀫𑀸 𑀧𑀝𑀺𑀪𑀬𑀸 𑀤𑀼𑀔𑀸.

𑁮𑁬.

‘‘𑀘𑀢𑀼𑀓𑁆𑀓𑀡𑁆𑀡𑀸 𑀘𑀢𑀼𑀤𑁆𑀯𑀸𑀭𑀸, 𑀯𑀺𑀪𑀢𑁆𑀢𑀸 𑀪𑀸𑀕𑀲𑁄 𑀫𑀺𑀢𑀸;

𑀅𑀬𑁄𑀧𑀸𑀓𑀸𑀭𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀸, 𑀅𑀬𑀲𑀸 𑀧𑀝𑀺𑀓𑀼𑀚𑁆𑀚𑀺𑀢𑀸.

𑁮𑁭.

‘‘𑀢𑁂𑀲𑀁 𑀅𑀬𑁄𑀫𑀬𑀸 𑀪𑀽𑀫𑀺, 𑀚𑀮𑀺𑀢𑀸 𑀢𑁂𑀚𑀲𑀸 𑀬𑀼𑀢𑀸;

𑀲𑀫𑀦𑁆𑀢𑀸 𑀬𑁄𑀚𑀦𑀲𑀢𑀁, 𑀨𑀼𑀝𑀸 [𑀨𑀭𑀺𑀢𑁆𑀯𑀸 (𑀅. 𑀦𑀺. 𑁩.𑁩𑁬; 𑀧𑁂. 𑀯. 𑁭𑁧)] 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺 𑀲𑀩𑁆𑀩𑀤𑀸.

𑁮𑁮.

‘‘𑀏𑀢𑁂 𑀧𑀢𑀦𑁆𑀢𑀺 𑀦𑀺𑀭𑀬𑁂, 𑀉𑀤𑁆𑀥𑀁𑀧𑀸𑀤𑀸 𑀅𑀯𑀁𑀲𑀺𑀭𑀸;

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

𑁮𑁯.

‘‘𑀢𑁂 𑀪𑀽𑀦𑀳𑀼𑀦𑁄 𑀧𑀘𑁆𑀘𑀦𑁆𑀢𑀺, 𑀫𑀘𑁆𑀙𑀸 𑀩𑀺𑀮𑀓𑀢𑀸 𑀬𑀣𑀸;

𑀲𑀁𑀯𑀘𑁆𑀙𑀭𑁂 𑀅𑀲𑀗𑁆𑀔𑁂𑀬𑁆𑀬𑁂, 𑀦𑀭𑀸 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀓𑀸𑀭𑀺𑀦𑁄.

𑁯𑁦.

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

𑀦𑀺𑀭𑀬𑀸 𑀦𑀸𑀥𑀺𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀤𑁆𑀯𑀸𑀭𑀁 𑀦𑀺𑀓𑁆𑀔𑀫𑀦𑁂𑀲𑀺𑀦𑁄.

𑁯𑁧.

‘‘𑀧𑀼𑀭𑀢𑁆𑀣𑀺𑀫𑁂𑀦 ¶ 𑀥𑀸𑀯𑀦𑁆𑀢𑀺, 𑀢𑀢𑁄 𑀥𑀸𑀯𑀦𑁆𑀢𑀺 𑀧𑀘𑁆𑀙𑀢𑁄;

𑀉𑀢𑁆𑀢𑀭𑁂𑀦𑀧𑀺 𑀥𑀸𑀯𑀦𑁆𑀢𑀺, 𑀢𑀢𑁄 𑀥𑀸𑀯𑀦𑁆𑀢𑀺 𑀤𑀓𑁆𑀔𑀺𑀡𑀁;

𑀬𑀁 𑀬𑀜𑁆𑀳𑀺 𑀤𑁆𑀯𑀸𑀭𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀢𑀁 𑀢𑀤𑁂𑀯 𑀧𑀺𑀥𑀻𑀬𑀭𑁂 [𑀧𑀺𑀣𑀺𑀬𑁆𑀬𑀢𑀺 (𑀲𑀻.), 𑀧𑀺𑀣𑀺𑀬𑁆𑀬𑀭𑁂 (𑀲𑁆𑀬𑀸.), 𑀧𑀺𑀣𑀻𑀬𑀭𑁂 (𑀧𑀻.)].

𑁯𑁨.

‘‘𑀩𑀳𑀽𑀦𑀺 𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀚𑀦𑀸 𑀦𑀺𑀭𑀬𑀕𑀸𑀫𑀺𑀦𑁄;

𑀩𑀸𑀳𑀸 𑀧𑀕𑁆𑀕𑀬𑁆𑀳 𑀓𑀦𑁆𑀤𑀦𑁆𑀢𑀺, 𑀧𑀢𑁆𑀯𑀸 𑀤𑀼𑀓𑁆𑀔𑀁 𑀅𑀦𑀧𑁆𑀧𑀓𑀁.

𑁯𑁩.

‘‘𑀆𑀲𑀻𑀯𑀺𑀲𑀁𑀯 ¶ 𑀓𑀼𑀧𑀺𑀢𑀁, 𑀢𑁂𑀚𑀲𑁆𑀲𑀺𑀁 𑀤𑀼𑀭𑀢𑀺𑀓𑁆𑀓𑀫𑀁;

𑀦 𑀲𑀸𑀥𑀼𑀭𑀽𑀧𑁂 𑀆𑀲𑀻𑀤𑁂, 𑀲𑀜𑁆𑀜𑀢𑀸𑀦𑀁 𑀢𑀧𑀲𑁆𑀲𑀺𑀦𑀁.

𑁯𑁪.

‘‘𑀅𑀢𑀺𑀓𑀸𑀬𑁄 ¶ 𑀫𑀳𑀺𑀲𑁆𑀲𑀸𑀲𑁄, 𑀅𑀚𑁆𑀚𑀼𑀦𑁄 𑀓𑁂𑀓𑀓𑀸𑀥𑀺𑀧𑁄;

𑀲𑀳𑀲𑁆𑀲𑀩𑀸𑀳𑀼 𑀉𑀘𑁆𑀙𑀺𑀦𑁆𑀦𑁄, 𑀇𑀲𑀺𑀫𑀸𑀲𑀚𑁆𑀚 𑀕𑁄𑀢𑀫𑀁.

𑁯𑁫.

‘‘𑀅𑀭𑀚𑀁 𑀭𑀚𑀲𑀸 𑀯𑀘𑁆𑀙𑀁, 𑀓𑀺𑀲𑀁 𑀅𑀯𑀓𑀺𑀭𑀺𑀬 𑀤𑀡𑁆𑀟𑀓𑀻;

𑀢𑀸𑀮𑁄𑀯 𑀫𑀽𑀮𑀢𑁄 [𑀲𑀫𑀽𑀮𑁄 (𑀓.)] 𑀙𑀺𑀦𑁆𑀦𑁄, 𑀲 𑀭𑀸𑀚𑀸 𑀯𑀺𑀪𑀯𑀗𑁆𑀕𑀢𑁄.

𑁯𑁬.

‘‘𑀉𑀧𑀳𑀘𑁆𑀘 𑀫𑀦𑀁 𑀫𑀚𑁆𑀛𑁄 [𑀫𑁂𑀚𑁆𑀛𑁄 (𑀓.)], 𑀫𑀸𑀢𑀗𑁆𑀕𑀲𑁆𑀫𑀺𑀁 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁂;

𑀲𑀧𑀸𑀭𑀺𑀲𑀚𑁆𑀚𑁄 𑀉𑀘𑁆𑀙𑀺𑀦𑁆𑀦𑁄, 𑀫𑀚𑁆𑀛𑀸𑀭𑀜𑁆𑀜𑀁 𑀢𑀤𑀸 𑀅𑀳𑀼.

𑁯𑁭.

‘‘𑀓𑀡𑁆𑀳𑀤𑀻𑀧𑀸𑀬𑀦𑀸𑀲𑀚𑁆𑀚, 𑀇𑀲𑀺𑀁 𑀅𑀦𑁆𑀥𑀓𑀯𑁂𑀡𑁆𑀟𑀬𑁄 [𑀯𑁂𑀡𑁆𑀳𑀼𑀬𑁄 (𑀲𑀻. 𑀧𑀻.), 𑀧𑀺𑀡𑁆𑀳𑀬𑁄 (?)];

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

𑁯𑁮.

‘‘𑀅𑀣𑀸𑀬𑀁 𑀇𑀲𑀺𑀦𑀸 𑀲𑀢𑁆𑀢𑁄, 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑀘𑀭𑁄 𑀧𑀼𑀭𑁂;

𑀧𑀸𑀯𑁂𑀓𑁆𑀔𑀺 𑀧𑀣𑀯𑀺𑀁 [𑀧𑀞𑀯𑀺𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀘𑁂𑀘𑁆𑀘𑁄, 𑀳𑀻𑀦𑀢𑁆𑀢𑁄 𑀧𑀢𑁆𑀢𑀧𑀭𑀺𑀬𑀸𑀬𑀁.

𑁯𑁯.

‘‘𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀙𑀦𑁆𑀤𑀸𑀕𑀫𑀦𑀁, 𑀦𑀧𑁆𑀧𑀲𑀁𑀲𑀦𑁆𑀢𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

𑀅𑀤𑀼𑀝𑁆𑀞𑀘𑀺𑀢𑁆𑀢𑁄 𑀪𑀸𑀲𑁂𑀬𑁆𑀬, 𑀕𑀺𑀭𑀁 𑀲𑀘𑁆𑀘𑀽𑀧𑀲𑀁𑀳𑀺𑀢𑀁.

𑁧𑁦𑁦.

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

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

𑁧𑁦𑁧.

‘‘𑀬𑁂 𑀯𑀼𑀟𑁆𑀠𑁂 [𑀯𑀤𑁆𑀥𑁂 (𑀓.)] 𑀧𑀭𑀺𑀪𑀸𑀲𑀦𑁆𑀢𑀺, 𑀨𑀭𑀼𑀲𑀽𑀧𑀓𑁆𑀓𑀫𑀸 𑀚𑀦𑀸;

𑀅𑀦𑀧𑀘𑁆𑀘𑀸 𑀅𑀤𑀸𑀬𑀸𑀤𑀸, 𑀢𑀸𑀮𑀯𑀢𑁆𑀣𑀼 [𑀢𑀸𑀮𑀯𑀢𑁆𑀣𑀽 (𑀲𑁆𑀬𑀸.), 𑀢𑀸𑀮𑀸𑀯𑀢𑁆𑀣𑀼 (𑀧𑀻.)] 𑀪𑀯𑀦𑁆𑀢𑀺 𑀢𑁂.

𑁧𑁦𑁨.

‘‘𑀬𑁄 ¶ 𑀘 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀁 𑀳𑀦𑁆𑀢𑀺, 𑀓𑀢𑀓𑀺𑀘𑁆𑀘𑀁 𑀫𑀳𑁂𑀲𑀺𑀦𑀁;

𑀲 𑀓𑀸𑀴𑀲𑀼𑀢𑁆𑀢𑁂 𑀦𑀺𑀭𑀬𑁂, 𑀘𑀺𑀭𑀭𑀢𑁆𑀢𑀸𑀬 𑀧𑀘𑁆𑀘𑀢𑀺.

𑁧𑁦𑁩.

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

𑀢𑀸𑀧𑀬𑀺𑀢𑁆𑀯𑀸 𑀚𑀦𑀧𑀤𑀁, 𑀢𑀸𑀧𑀦𑁂 𑀧𑁂𑀘𑁆𑀘 𑀧𑀘𑁆𑀘𑀢𑀺.

𑁧𑁦𑁪.

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

𑀅𑀘𑁆𑀘𑀺𑀲𑀗𑁆𑀖𑀧𑀭𑁂𑀢𑁄 𑀲𑁄, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀯𑁂𑀤𑁂𑀢𑀺 𑀯𑁂𑀤𑀦𑀁.

𑁧𑁦𑁫.

‘‘𑀢𑀲𑁆𑀲 𑀅𑀕𑁆𑀕𑀺𑀲𑀺𑀔𑀸 𑀓𑀸𑀬𑀸, 𑀦𑀺𑀘𑁆𑀙𑀭𑀦𑁆𑀢𑀺 𑀧𑀪𑀲𑁆𑀲𑀭𑀸;

𑀢𑁂𑀚𑁄𑀪𑀓𑁆𑀔𑀲𑁆𑀲 𑀕𑀢𑁆𑀢𑀸𑀦𑀺, 𑀮𑁄𑀫𑁂𑀳𑀺 𑀘 [𑀮𑁄𑀫𑀕𑁆𑀕𑁂𑀳𑀺 𑀘 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀦𑀔𑁂𑀳𑀺 𑀘.

𑁧𑁦𑁬.

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

𑀤𑀼𑀓𑁆𑀔𑀸𑀪𑀺𑀢𑀼𑀦𑁆𑀦𑁄 𑀦𑀤𑀢𑀺, 𑀦𑀸𑀕𑁄 𑀢𑀼𑀢𑁆𑀢𑀝𑁆𑀝𑀺𑀢𑁄 [𑀢𑀼𑀢𑁆𑀢𑀤𑁆𑀤𑀺𑀢𑁄 (𑀲𑀻.)] 𑀬𑀣𑀸.

𑁧𑁦𑁭.

‘‘𑀬𑁄 𑀮𑁄𑀪𑀸 𑀧𑀺𑀢𑀭𑀁 𑀳𑀦𑁆𑀢𑀺, 𑀤𑁄𑀲𑀸 𑀯𑀸 𑀧𑀼𑀭𑀺𑀲𑀸𑀥𑀫𑁄;

𑀲 𑀓𑀸𑀴𑀲𑀼𑀢𑁆𑀢𑁂 𑀦𑀺𑀭𑀬𑁂, 𑀘𑀺𑀭𑀭𑀢𑁆𑀢𑀸𑀬 𑀧𑀘𑁆𑀘𑀢𑀺.

𑁧𑁦𑁮.

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

𑀅𑀦𑁆𑀥𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸 𑀫𑀼𑀢𑁆𑀢𑀓𑀭𑀻𑀲𑀪𑀓𑁆𑀔𑀁, 𑀔𑀸𑀭𑁂 𑀦𑀺𑀫𑀼𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀢𑀣𑀸𑀯𑀺𑀥𑀁 𑀦𑀭𑀁.

𑁧𑁦𑁯.

‘‘𑀢𑀢𑁆𑀢𑀁 𑀧𑀓𑁆𑀓𑀼𑀣𑀺𑀢𑀫𑀬𑁄𑀕𑀼𑀴𑀜𑁆𑀘 [𑀧𑀓𑁆𑀓𑀼𑀥𑀺𑀢𑀫𑀬𑁄𑀕𑀼𑀴𑀜𑁆𑀘 (𑀓.)], 𑀤𑀻𑀖𑁂 𑀘 𑀨𑀸𑀮𑁂 𑀘𑀺𑀭𑀭𑀢𑁆𑀢𑀢𑀸𑀧𑀺𑀢𑁂;

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

𑁧𑁧𑁦.

‘‘𑀲𑀸𑀫𑀸 𑀘 𑀲𑁄𑀡𑀸 𑀲𑀩𑀮𑀸 𑀘 𑀕𑀺𑀚𑁆𑀛𑀸, 𑀓𑀸𑀓𑁄𑀴𑀲𑀗𑁆𑀖𑀸 𑀘 𑀤𑀺𑀚𑀸 𑀅𑀬𑁄𑀫𑀼𑀔𑀸;

𑀲𑀗𑁆𑀕𑀫𑁆𑀫 ¶ 𑀔𑀸𑀤𑀦𑁆𑀢𑀺 𑀯𑀺𑀧𑁆𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑀁, 𑀚𑀺𑀯𑁆𑀳𑀁 𑀯𑀺𑀪𑀚𑁆𑀚 𑀯𑀺𑀖𑀸𑀲𑀁 𑀲𑀮𑁄𑀳𑀺𑀢𑀁.

𑁧𑁧𑁧.

‘‘𑀢𑀁 ¶ 𑀤𑀟𑁆𑀠𑀢𑀸𑀮𑀁 𑀧𑀭𑀺𑀪𑀺𑀦𑁆𑀦𑀕𑀢𑁆𑀢𑀁, 𑀦𑀺𑀧𑁆𑀧𑁄𑀣𑀬𑀦𑁆𑀢𑀸 𑀅𑀦𑀼𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀺 𑀭𑀓𑁆𑀔𑀲𑀸;

𑀭𑀢𑀻 𑀳𑀺 𑀦𑁂𑀲𑀁 𑀤𑀼𑀔𑀺𑀦𑁄 𑀧𑀦𑀻𑀢𑀭𑁂, 𑀏𑀢𑀸𑀤𑀺𑀲𑀲𑁆𑀫𑀺𑀁 𑀦𑀺𑀭𑀬𑁂 𑀯𑀲𑀦𑁆𑀢𑀺;

𑀬𑁂 𑀓𑁂𑀘𑀺 𑀮𑁄𑀓𑁂 𑀇𑀥 𑀧𑁂𑀢𑁆𑀢𑀺𑀖𑀸𑀢𑀺𑀦𑁄.

𑁧𑁧𑁨.

‘‘𑀧𑀼𑀢𑁆𑀢𑁄 𑀘 𑀫𑀸𑀢𑀭𑀁 𑀳𑀦𑁆𑀢𑁆𑀯𑀸, 𑀇𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀬𑀫𑀓𑁆𑀔𑀬𑀁;

𑀪𑀼𑀲𑀫𑀸𑀧𑀚𑁆𑀚𑀢𑁂 𑀤𑀼𑀓𑁆𑀔𑀁, 𑀅𑀢𑁆𑀢𑀓𑀫𑁆𑀫𑀨𑀮𑀽𑀧𑀕𑁄.

𑁧𑁧𑁩.

‘‘𑀅𑀫𑀦𑀼𑀲𑁆𑀲𑀸 𑀅𑀢𑀺𑀩𑀮𑀸, 𑀳𑀦𑁆𑀢𑀸𑀭𑀁 𑀚𑀦𑀬𑀦𑁆𑀢𑀺𑀬𑀸;

𑀅𑀬𑁄𑀫𑀬𑁂𑀳𑀺 𑀯𑀸𑀴𑁂𑀳𑀺 [𑀨𑀸𑀮𑁂𑀳𑀺 (𑀧𑀻.)], 𑀧𑀻𑀴𑀬𑀦𑁆𑀢𑀺 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁.

𑁧𑁧𑁪.

‘‘𑀢𑀫𑀲𑁆𑀲𑀯𑀁 [𑀢𑀁 𑀧𑀲𑁆𑀲𑀯𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀢𑀁 𑀧𑀲𑁆𑀲𑀼𑀢𑀁 (𑀧𑀻.)] 𑀲𑀓𑀸 𑀕𑀢𑁆𑀢𑀸, 𑀭𑀼𑀳𑀺𑀭𑀁 [𑀭𑀼𑀥𑀺𑀭𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀅𑀢𑁆𑀢𑀲𑀫𑁆𑀪𑀯𑀁;

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

𑁧𑁧𑁫.

‘‘𑀚𑀺𑀕𑀼𑀘𑁆𑀙𑀁 𑀓𑀼𑀡𑀧𑀁 𑀧𑀽𑀢𑀺𑀁, 𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑀁 𑀕𑀽𑀣𑀓𑀤𑁆𑀤𑀫𑀁;

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

𑁧𑁧𑁬.

‘‘𑀢𑀫𑁂𑀦𑀁 𑀓𑀺𑀫𑀬𑁄 𑀢𑀢𑁆𑀣, 𑀅𑀢𑀺𑀓𑀸𑀬𑀸 𑀅𑀬𑁄𑀫𑀼𑀔𑀸;

𑀙𑀯𑀺𑀁 𑀪𑁂𑀢𑁆𑀯𑀸𑀦 [𑀙𑁂𑀢𑁆𑀯𑀸𑀦 (𑀲𑀻. 𑀧𑀻.)] 𑀔𑀸𑀤𑀦𑁆𑀢𑀺, 𑀲𑀁𑀕𑀺𑀤𑁆𑀥𑀸 [𑀧𑀕𑀺𑀤𑁆𑀥𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀁𑀲𑀮𑁄𑀳𑀺𑀢𑁂.

𑁧𑁧𑁭.

‘‘𑀲𑁄 𑀘 𑀢𑀁 𑀦𑀺𑀭𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀦𑀺𑀫𑀼𑀕𑁆𑀕𑁄 𑀲𑀢𑀧𑁄𑀭𑀺𑀲𑀁;

𑀧𑀽𑀢𑀺𑀓𑀁 𑀓𑀼𑀡𑀧𑀁 𑀯𑀸𑀢𑀺, 𑀲𑀫𑀦𑁆𑀢𑀸 𑀲𑀢𑀬𑁄𑀚𑀦𑀁.

𑁧𑁧𑁮.

‘‘𑀘𑀓𑁆𑀔𑀼𑀫𑀸𑀧𑀺 𑀳𑀺 𑀘𑀓𑁆𑀔𑀽𑀳𑀺, 𑀢𑁂𑀦 𑀕𑀦𑁆𑀥𑁂𑀦 𑀚𑀻𑀬𑀢𑀺;

𑀏𑀢𑀸𑀤𑀺𑀲𑀁 ¶ 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢, 𑀫𑀸𑀢𑀼𑀖𑁄 𑀮𑀪𑀢𑁂 𑀤𑀼𑀔𑀁.

𑁧𑁧𑁯.

‘‘𑀔𑀼𑀭𑀥𑀸𑀭𑀫𑀦𑀼𑀓𑁆𑀓𑀫𑁆𑀫, 𑀢𑀺𑀓𑁆𑀔𑀁 𑀤𑀼𑀭𑀪𑀺𑀲𑀫𑁆𑀪𑀯𑀁;

𑀧𑀢𑀦𑁆𑀢𑀺 𑀕𑀩𑁆𑀪𑀧𑀸𑀢𑀺𑀬𑁄 [𑀕𑀩𑁆𑀪𑀧𑀸𑀢𑀺𑀦𑀺𑀬𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀤𑀼𑀕𑁆𑀕𑀁 𑀯𑁂𑀢𑀭𑀡𑀺𑀁 [𑀯𑁂𑀢𑁆𑀢𑀭𑀡𑀺𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀦𑀤𑀺𑀁.

𑁧𑁨𑁦.

‘‘𑀅𑀬𑁄𑀫𑀬𑀸 𑀲𑀺𑀫𑁆𑀩𑀮𑀺𑀬𑁄, 𑀲𑁄𑀴𑀲𑀗𑁆𑀕𑀼𑀮𑀓𑀡𑁆𑀝𑀓𑀸;

𑀉𑀪𑀢𑁄 𑀅𑀪𑀺𑀮𑀫𑁆𑀩𑀦𑁆𑀢𑀺, 𑀤𑀼𑀕𑁆𑀕𑀁 𑀯𑁂𑀢𑀭𑀡𑀺𑀁 [𑀯𑁂𑀢𑁆𑀢𑀭𑀡𑀺𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀦𑀤𑀺𑀁.

𑁧𑁨𑁧.

‘‘𑀢𑁂 ¶ 𑀅𑀘𑁆𑀘𑀺𑀫𑀦𑁆𑀢𑁄 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺, 𑀅𑀕𑁆𑀕𑀺𑀓𑁆𑀔𑀦𑁆𑀥𑀸𑀯 𑀆𑀭𑀓𑀸;

𑀆𑀤𑀺𑀢𑁆𑀢𑀸 𑀚𑀸𑀢𑀯𑁂𑀤𑁂𑀦, 𑀉𑀤𑁆𑀥𑀁 𑀬𑁄𑀚𑀦𑀫𑀼𑀕𑁆𑀕𑀢𑀸.

𑁧𑁨𑁨.

‘‘𑀏𑀢𑁂 ¶ 𑀯𑀚𑀦𑁆𑀢𑀺 [𑀲𑀚𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.), 𑀧𑀚𑁆𑀚𑀦𑁆𑀢𑀺 (𑀲𑁆𑀬𑀸.)] 𑀦𑀺𑀭𑀬𑁂, 𑀢𑀢𑁆𑀢𑁂 𑀢𑀺𑀔𑀺𑀡𑀓𑀡𑁆𑀝𑀓𑁂;

𑀦𑀸𑀭𑀺𑀬𑁄 𑀘 𑀅𑀢𑀺𑀘𑀸𑀭𑀸 [𑀅𑀢𑀺𑀘𑀸𑀭𑀺𑀦𑀺𑀬𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀦𑀭𑀸 𑀘 𑀧𑀭𑀤𑀸𑀭𑀕𑀽.

𑁧𑁨𑁩.

‘‘𑀢𑁂 𑀧𑀢𑀦𑁆𑀢𑀺 𑀅𑀥𑁄𑀓𑁆𑀔𑀦𑁆𑀥𑀸, 𑀯𑀺𑀯𑀢𑁆𑀢𑀸 𑀯𑀺𑀳𑀢𑀸 𑀧𑀼𑀣𑀽;

𑀲𑀬𑀦𑁆𑀢𑀺 𑀯𑀺𑀦𑀺𑀯𑀺𑀤𑁆𑀥𑀗𑁆𑀕𑀸, 𑀤𑀻𑀖𑀁 𑀚𑀕𑁆𑀕𑀦𑁆𑀢𑀺 𑀲𑀩𑁆𑀩𑀤𑀸 [𑀲𑀁𑀯𑀭𑀺𑀁 (𑀲𑀻. 𑀧𑀻.)].

𑁧𑁨𑁪.

‘‘𑀢𑀢𑁄 𑀭𑀢𑁆𑀬𑀸 𑀯𑀺𑀯𑀲𑀸𑀦𑁂 [𑀯𑀺𑀯𑀲𑀦𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀫𑀳𑀢𑀺𑀁 𑀧𑀩𑁆𑀩𑀢𑀽𑀧𑀫𑀁;

𑀮𑁄𑀳𑀓𑀼𑀫𑁆𑀪𑀺𑀁 𑀧𑀯𑀚𑁆𑀚𑀦𑁆𑀢𑀺, 𑀢𑀢𑁆𑀢𑀁 𑀅𑀕𑁆𑀕𑀺𑀲𑀫𑀽𑀤𑀓𑀁.

𑁧𑁨𑁫.

‘‘𑀏𑀯𑀁 𑀤𑀺𑀯𑀸 𑀘 𑀭𑀢𑁆𑀢𑁄 𑀘, 𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑀸 𑀫𑁄𑀳𑀧𑀸𑀭𑀼𑀢𑀸;

𑀅𑀦𑀼𑀪𑁄𑀦𑁆𑀢𑀺 𑀲𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀤𑀼𑀓𑁆𑀓𑀝𑀫𑀢𑁆𑀢𑀦𑁄.

𑁧𑁨𑁬.

‘‘𑀬𑀸 𑀘 𑀪𑀭𑀺𑀬𑀸 𑀥𑀦𑀓𑁆𑀓𑀻𑀢𑀸, 𑀲𑀸𑀫𑀺𑀓𑀁 𑀅𑀢𑀺𑀫𑀜𑁆𑀜𑀢𑀺;

𑀲𑀲𑁆𑀲𑀼𑀁 𑀯𑀸 𑀲𑀲𑀼𑀭𑀁 𑀯𑀸𑀧𑀺, 𑀚𑁂𑀝𑁆𑀞𑀁 𑀯𑀸𑀧𑀺 𑀦𑀦𑀦𑁆𑀤𑀭𑀁 [𑀦𑀦𑀦𑁆𑀤𑀦𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑁧𑁨𑁭.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀯𑀗𑁆𑀓𑁂𑀦 𑀚𑀺𑀯𑁆𑀳𑀕𑁆𑀕𑀁, 𑀦𑀺𑀩𑁆𑀩𑀳𑀦𑁆𑀢𑀺 𑀲𑀩𑀦𑁆𑀥𑀦𑀁;

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

𑀯𑀺𑀜𑁆𑀜𑀸𑀧𑁂𑀢𑀼𑀁 ¶ 𑀦 𑀲𑀓𑁆𑀓𑁄𑀢𑀺, 𑀢𑀸𑀧𑀦𑁂 𑀧𑁂𑀘𑁆𑀘 𑀧𑀘𑁆𑀘𑀢𑀺.

𑁧𑁨𑁮.

‘‘𑀑𑀭𑀩𑁆𑀪𑀺𑀓𑀸 𑀲𑀽𑀓𑀭𑀺𑀓𑀸, 𑀫𑀘𑁆𑀙𑀺𑀓𑀸 𑀫𑀺𑀕𑀩𑀦𑁆𑀥𑀓𑀸;

𑀘𑁄𑀭𑀸 𑀕𑁄𑀖𑀸𑀢𑀓𑀸 𑀮𑀼𑀤𑁆𑀤𑀸, 𑀅𑀯𑀡𑁆𑀡𑁂 𑀯𑀡𑁆𑀡𑀓𑀸𑀭𑀓𑀸.

𑁧𑁨𑁯.

‘‘𑀲𑀢𑁆𑀢𑀻𑀳𑀺 𑀮𑁄𑀳𑀓𑀽𑀝𑁂𑀳𑀺, 𑀦𑁂𑀢𑁆𑀢𑀺𑀁𑀲𑁂𑀳𑀺 𑀉𑀲𑀽𑀳𑀺 𑀘;

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

𑁧𑁩𑁦.

‘‘𑀲𑀸𑀬𑀁 𑀧𑀸𑀢𑁄 𑀓𑀽𑀝𑀓𑀸𑀭𑀻, 𑀅𑀬𑁄𑀓𑀽𑀝𑁂𑀳𑀺 𑀳𑀜𑁆𑀜𑀢𑀺;

𑀢𑀢𑁄 𑀯𑀦𑁆𑀢𑀁 𑀤𑀼𑀭𑀢𑁆𑀢𑀸𑀦𑀁, 𑀧𑀭𑁂𑀲𑀁 𑀪𑀼𑀜𑁆𑀚𑀭𑁂 [𑀪𑀼𑀜𑁆𑀚𑀢𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀲𑀤𑀸.

𑁧𑁩𑁧.

‘‘𑀥𑀗𑁆𑀓𑀸 𑀪𑁂𑀭𑀡𑁆𑀟𑀓𑀸 [𑀪𑁂𑀤𑀡𑁆𑀟𑀓𑀸 (𑀓.)] 𑀕𑀺𑀚𑁆𑀛𑀸, 𑀓𑀸𑀓𑁄𑀴𑀸 𑀘 𑀅𑀬𑁄𑀫𑀼𑀔𑀸;

𑀯𑀺𑀧𑁆𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑀁 𑀔𑀸𑀤𑀦𑁆𑀢𑀺, 𑀦𑀭𑀁 𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀓𑀸𑀭𑀓𑀁 [𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑀓𑀸𑀭𑀺𑀦𑀁 (𑀧𑀻.)].

𑁧𑁩𑁨.

‘‘𑀬𑁂 𑀫𑀺𑀕𑁂𑀦 𑀫𑀺𑀕𑀁 𑀳𑀦𑁆𑀢𑀺, 𑀧𑀓𑁆𑀔𑀺𑀁 𑀯𑀸 𑀧𑀦 𑀧𑀓𑁆𑀔𑀺𑀦𑀸;

𑀅𑀲𑀦𑁆𑀢𑁄 𑀭𑀚𑀲𑀸 𑀙𑀦𑁆𑀦𑀸, 𑀕𑀦𑁆𑀢𑀸 [𑀕𑀢𑀸 (𑀓.)] 𑀢𑁂 𑀦𑀺𑀭𑀬𑀼𑀲𑁆𑀲𑀤𑀁 [𑀦𑀺𑀭𑀬𑀁 𑀅𑀥𑁄 (𑀧𑀻.)].

𑁧𑁩𑁩.

‘‘𑀲𑀦𑁆𑀢𑁄 ¶ 𑀘 [𑀲𑀦𑁆𑀢𑁄𑀯 (𑀲𑁆𑀬𑀸.)] 𑀉𑀤𑁆𑀥𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑁂𑀦𑀺𑀥 𑀓𑀫𑁆𑀫𑀼𑀦𑀸;

𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑀲𑁆𑀲 𑀨𑀮𑀁 𑀧𑀲𑁆𑀲, 𑀲𑀇𑀦𑁆𑀤𑀸 [𑀲𑀳𑀺𑀦𑁆𑀤𑀸 (𑀲𑀻.)] 𑀤𑁂𑀯𑀸 𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀓𑀸.

𑁧𑁩𑁪.

‘‘𑀢𑀁 ¶ 𑀢𑀁 𑀩𑁆𑀭𑀽𑀫𑀺 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀥𑀫𑁆𑀫𑀁 𑀭𑀝𑁆𑀞𑀧𑀢𑀻 𑀘𑀭;

𑀢𑀣𑀸 [𑀢𑀣𑀸 𑀢𑀣𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀭𑀸𑀚 𑀘𑀭𑀸𑀳𑀺 𑀥𑀫𑁆𑀫𑀁, 𑀬𑀣𑀸 𑀢𑀁 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑀁 𑀦𑀸𑀦𑀼𑀢𑀧𑁆𑀧𑁂𑀬𑁆𑀬 𑀧𑀘𑁆𑀙𑀸’’𑀢𑀺.

𑀲𑀁𑀓𑀺𑀘𑁆𑀘𑀚𑀸𑀢𑀓𑀁 𑀤𑀼𑀢𑀺𑀬𑀁.

𑀲𑀝𑁆𑀞𑀺𑀦𑀺𑀧𑀸𑀢𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀢𑀲𑁆𑀲𑀼𑀤𑁆𑀤𑀸𑀦𑀁 𑁋

𑀅𑀣 𑀲𑀝𑁆𑀞𑀺𑀦𑀺𑀧𑀸𑀢𑀫𑁆𑀳𑀺, 𑀲𑀼𑀡𑀸𑀣 𑀫𑀫 𑀪𑀸𑀲𑀺𑀢𑀁;

𑀚𑀸𑀢𑀓𑀲𑀯𑁆𑀳𑀬𑀦𑁄 ¶ 𑀧𑀯𑀭𑁄, 𑀲𑁄𑀡𑀓𑀅𑀭𑀺𑀦𑁆𑀤𑀫𑀲𑀯𑁆𑀳𑀬𑀦𑁄;

𑀢𑀣𑀸 𑀯𑀼𑀢𑁆𑀢𑀭𑀣𑁂𑀲𑀪𑀓𑀺𑀘𑁆𑀘𑀯𑀭𑁄𑀢𑀺.

𑁨𑁦. 𑀲𑀢𑁆𑀢𑀢𑀺𑀦𑀺𑀧𑀸𑀢𑁄

𑁫𑁩𑁧. 𑀓𑀼𑀲𑀚𑀸𑀢𑀓𑀁 (𑁧)

𑁧.

‘‘𑀇𑀤𑀁 ¶ ¶ ¶ 𑀢𑁂 𑀭𑀝𑁆𑀞𑀁 𑀲𑀥𑀦𑀁 𑀲𑀬𑁄𑀕𑁆𑀕𑀁, 𑀲𑀓𑀸𑀬𑀼𑀭𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀽𑀧𑀧𑀦𑁆𑀦𑀁;

𑀇𑀤𑀁 𑀢𑁂 𑀭𑀚𑁆𑀚𑀁 [𑀭𑀝𑁆𑀞𑀁 (𑀓.)] 𑀅𑀦𑀼𑀲𑀸𑀲 𑀅𑀫𑁆𑀫, 𑀕𑀘𑁆𑀙𑀸𑀫𑀳𑀁 𑀬𑀢𑁆𑀣 𑀧𑀺𑀬𑀸 𑀧𑀪𑀸𑀯𑀢𑀻’’.

𑁨.

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

𑀧𑀝𑀺𑀕𑀘𑁆𑀙 𑀢𑁆𑀯𑀁 𑀔𑀺𑀧𑁆𑀧𑀁 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁 𑀓𑀼𑀲 [𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀦𑀺𑀘𑁆𑀙𑀸𑀫𑀺 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀫𑀳𑀁 𑀯𑀲𑀦𑁆𑀢𑀁’’.

𑁩.

‘‘𑀦𑀸𑀳𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀇𑀢𑁄 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁, 𑀧𑀪𑀸𑀯𑀢𑀻 𑀯𑀡𑁆𑀡𑀧𑀮𑁄𑀪𑀺𑀢𑁄 𑀢𑀯;

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

𑁪.

‘‘𑀧𑀪𑀸𑀯𑀢𑀻 𑀯𑀡𑁆𑀡𑀧𑀮𑁄𑀪𑀺𑀢𑁄 𑀢𑀯, 𑀲𑀫𑁆𑀫𑀽𑀴𑁆𑀳𑀭𑀽𑀧𑁄 𑀯𑀺𑀘𑀭𑀸𑀫𑀺 𑀫𑁂𑀤𑀺𑀦𑀺𑀁 [𑀫𑁂𑀤𑀦𑀺𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀤𑀺𑀲𑀁 𑀦 𑀚𑀸𑀦𑀸𑀫𑀺 𑀓𑀼𑀢𑁄𑀫𑁆𑀳𑀺 𑀆𑀕𑀢𑁄, 𑀢𑀬𑀫𑁆𑀳𑀺 𑀫𑀢𑁆𑀢𑁄 𑀫𑀺𑀕𑀫𑀦𑁆𑀤𑀮𑁄𑀘𑀦𑁂.

𑁫.

‘‘𑀲𑀼𑀯𑀡𑁆𑀡𑀘𑀻𑀭𑀯𑀲𑀦𑁂, 𑀚𑀸𑀢𑀭𑀽𑀧𑀲𑀼𑀫𑁂𑀔𑀮𑁂;

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

𑁬.

‘‘𑀅𑀩𑁆𑀪𑀽𑀢𑀺 [𑀅𑀩𑁆𑀪𑀽 𑀳𑀺 (𑀲𑀻.), 𑀅𑀪𑀽𑀢𑀺 (𑀲𑁆𑀬𑀸.), 𑀅𑀩𑁆𑀪𑀼 𑀳𑀺 (𑀧𑀻.)] 𑀢𑀲𑁆𑀲 𑀪𑁄 𑀳𑁄𑀢𑀺, 𑀬𑁄 𑀅𑀦𑀺𑀘𑁆𑀙𑀦𑁆𑀢𑀫𑀺𑀘𑁆𑀙𑀢𑀺;

𑀅𑀓𑀸𑀫𑀁 𑀭𑀸𑀚 𑀓𑀸𑀫𑁂𑀲𑀺 [𑀓𑀸𑀫𑁂𑀳𑀺 (𑀲𑀻. 𑀧𑀻.)], 𑀅𑀓𑀦𑁆𑀢𑀁 𑀓𑀦𑁆𑀢𑀼 [𑀅𑀓𑀦𑁆𑀢𑁄 𑀓𑀦𑁆𑀢 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀺𑀘𑁆𑀙𑀲𑀺’’.

𑁭.

‘‘𑀅𑀓𑀸𑀫𑀁 𑀯𑀸 𑀲𑀓𑀸𑀫𑀁 𑀯𑀸, 𑀬𑁄 𑀦𑀭𑁄 𑀮𑀪𑀢𑁂 𑀧𑀺𑀬𑀁;

𑀮𑀸𑀪𑀫𑁂𑀢𑁆𑀣 𑀧𑀲𑀁𑀲𑀸𑀫, 𑀅𑀮𑀸𑀪𑁄 𑀢𑀢𑁆𑀣 𑀧𑀸𑀧𑀓𑁄’’.

𑁮.

‘‘𑀧𑀸𑀲𑀸𑀡𑀲𑀸𑀭𑀁 ¶ 𑀔𑀡𑀲𑀺, 𑀓𑀡𑀺𑀓𑀸𑀭𑀲𑁆𑀲 𑀤𑀸𑀭𑀼𑀦𑀸;

𑀯𑀸𑀢𑀁 𑀚𑀸𑀮𑁂𑀦 𑀩𑀸𑀥𑁂𑀲𑀺, 𑀬𑁄 𑀅𑀦𑀺𑀘𑁆𑀙𑀦𑁆𑀢𑀫𑀺𑀘𑁆𑀙𑀲𑀺’’.

𑁯.

‘‘𑀧𑀸𑀲𑀸𑀡𑁄 𑀦𑀽𑀦 𑀢𑁂 𑀳𑀤𑀬𑁂, 𑀑𑀳𑀺𑀢𑁄 𑀫𑀼𑀤𑀼𑀮𑀓𑁆𑀔𑀡𑁂;

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

𑁧𑁦.

‘‘𑀬𑀤𑀸 𑀫𑀁 𑀪𑀓𑀼𑀝𑀺𑀁 [𑀪𑀽𑀓𑀼𑀝𑀺𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀓𑀢𑁆𑀯𑀸, 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑀻 𑀉𑀤𑀺𑀓𑁆𑀔𑀢𑀺 [𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑀺 𑀉𑀤𑀺𑀓𑁆𑀔𑀲𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀆𑀴𑀸𑀭𑀺𑀓𑁄 𑀢𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀭𑀜𑁆𑀜𑁄 𑀫𑀤𑁆𑀤𑀲𑁆𑀲𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑁂 [𑀫𑀤𑁆𑀤𑀲𑁆𑀲 𑀣𑀻𑀧𑀼𑀭𑁂 (𑀲𑀻. 𑀧𑀻.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺].

𑁧𑁧.

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

𑀦𑀸𑀴𑀸𑀭𑀺𑀓𑁄 𑀢𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀭𑀸𑀚𑀸 𑀳𑁄𑀫𑀺 𑀢𑀤𑀸 𑀓𑀼𑀲𑁄’’.

𑁧𑁨.

‘‘𑀲𑀘𑁂 ¶ 𑀳𑀺 𑀯𑀘𑀦𑀁 𑀲𑀘𑁆𑀘𑀁, 𑀦𑁂𑀫𑀺𑀢𑁆𑀢𑀸𑀦𑀁 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺;

𑀦𑁂𑀯 𑀫𑁂 𑀢𑁆𑀯𑀁 𑀧𑀢𑀻 𑀅𑀲𑁆𑀲, 𑀓𑀸𑀫𑀁 𑀙𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀼 𑀲𑀢𑁆𑀢𑀥𑀸’’.

𑁧𑁩.

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

𑀦𑁂𑀯 𑀢𑀼𑀬𑁆𑀳𑀁 𑀧𑀢𑀻 𑀅𑀢𑁆𑀣𑀺, 𑀅𑀜𑁆𑀜𑁄 𑀲𑀻𑀳𑀲𑁆𑀲𑀭𑀸 𑀓𑀼𑀲𑀸’’.

𑁧𑁪.

‘‘𑀦𑁂𑀓𑁆𑀔𑀁 𑀕𑀻𑀯𑀁 𑀢𑁂 𑀓𑀸𑀭𑁂𑀲𑁆𑀲𑀁, 𑀧𑀢𑁆𑀯𑀸 𑀔𑀼𑀚𑁆𑀚𑁂 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁;

𑀲𑀘𑁂 𑀫𑀁 𑀦𑀸𑀕𑀦𑀸𑀲𑀽𑀭𑀽, 𑀑𑀮𑁄𑀓𑁂𑀬𑁆𑀬 𑀧𑀪𑀸𑀯𑀢𑀻.

𑁧𑁫.

‘‘𑀦𑁂𑀓𑁆𑀔𑀁 ¶ 𑀕𑀻𑀯𑀁 𑀢𑁂 𑀓𑀸𑀭𑁂𑀲𑁆𑀲𑀁, 𑀧𑀢𑁆𑀯𑀸 𑀔𑀼𑀚𑁆𑀚𑁂 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁;

𑀲𑀘𑁂 𑀫𑀁 𑀦𑀸𑀕𑀦𑀸𑀲𑀽𑀭𑀽, 𑀆𑀮𑀧𑁂𑀬𑁆𑀬 𑀧𑀪𑀸𑀯𑀢𑀻.

𑁧𑁬.

‘‘𑀦𑁂𑀓𑁆𑀔𑀁 𑀕𑀻𑀯𑀁 𑀢𑁂 𑀓𑀸𑀭𑁂𑀲𑁆𑀲𑀁, 𑀧𑀢𑁆𑀯𑀸 𑀔𑀼𑀚𑁆𑀚𑁂 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁;

𑀲𑀘𑁂 𑀫𑀁 𑀦𑀸𑀕𑀦𑀸𑀲𑀽𑀭𑀽, 𑀉𑀫𑁆𑀳𑀸𑀬𑁂𑀬𑁆𑀬 𑀧𑀪𑀸𑀯𑀢𑀻.

𑁧𑁭.

‘‘𑀦𑁂𑀓𑁆𑀔𑀁 𑀕𑀻𑀯𑀁 𑀢𑁂 𑀓𑀸𑀭𑁂𑀲𑁆𑀲𑀁, 𑀧𑀢𑁆𑀯𑀸 𑀔𑀼𑀚𑁆𑀚𑁂 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁;

𑀲𑀘𑁂 𑀫𑀁 𑀦𑀸𑀕𑀦𑀸𑀲𑀽𑀭𑀽, 𑀧𑀫𑁆𑀳𑀸𑀬𑁂𑀬𑁆𑀬 𑀧𑀪𑀸𑀯𑀢𑀻.

𑁧𑁮.

‘‘𑀦𑁂𑀓𑁆𑀔𑀁 𑀕𑀻𑀯𑀁 𑀢𑁂 𑀓𑀸𑀭𑁂𑀲𑁆𑀲𑀁, 𑀧𑀢𑁆𑀯𑀸 𑀔𑀼𑀚𑁆𑀚𑁂 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁;

𑀲𑀘𑁂 𑀫𑁂 𑀦𑀸𑀕𑀦𑀸𑀲𑀽𑀭𑀽, 𑀧𑀸𑀡𑀻𑀳𑀺 𑀉𑀧𑀲𑀫𑁆𑀨𑀼𑀲𑁂’’.

𑁧𑁯.

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

𑀆𑀴𑀸𑀭𑀺𑀓𑁂 𑀪𑀢𑁂 𑀧𑁄𑀲𑁂, 𑀯𑁂𑀢𑀦𑁂𑀦 𑀅𑀦𑀢𑁆𑀣𑀺𑀓𑁂’’.

𑁨𑁦.

‘‘𑀦 𑀳𑀺 𑀦𑀽𑀦𑀸𑀬𑀁 𑀲𑀸 [𑀦𑀽𑀦 𑀅𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀔𑀼𑀚𑁆𑀚𑀸, 𑀮𑀪𑀢𑀺 𑀚𑀺𑀯𑁆𑀳𑀸𑀬 𑀙𑁂𑀤𑀦𑀁;

𑀲𑀼𑀦𑀺𑀲𑀺𑀢𑁂𑀦 𑀲𑀢𑁆𑀣𑁂𑀦, 𑀏𑀯𑀁 𑀤𑀼𑀩𑁆𑀪𑀸𑀲𑀺𑀢𑀁 𑀪𑀡𑀁’’.

𑁨𑁧.

‘‘𑀫𑀸 ¶ 𑀦𑀁 𑀭𑀽𑀧𑁂𑀦 𑀧𑀸𑀫𑁂𑀲𑀺, 𑀆𑀭𑁄𑀳𑁂𑀦 𑀧𑀪𑀸𑀯𑀢𑀺;

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

𑁨𑁨.

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

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

𑁨𑁩.

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

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

𑁨𑁪.

‘‘𑀫𑀸 ¶ 𑀦𑀁 𑀭𑀽𑀧𑁂𑀦 𑀧𑀸𑀫𑁂𑀲𑀺, 𑀆𑀭𑁄𑀳𑁂𑀦 𑀧𑀪𑀸𑀯𑀢𑀺;

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

𑁨𑁫.

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

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

𑁨𑁬.

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

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

𑁨𑁭.

‘‘𑀫𑀸 ¶ 𑀦𑀁 𑀭𑀽𑀧𑁂𑀦 𑀧𑀸𑀫𑁂𑀲𑀺, 𑀆𑀭𑁄𑀳𑁂𑀦 𑀧𑀪𑀸𑀯𑀢𑀺;

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

𑁨𑁮.

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

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

𑁨𑁯.

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

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

𑁩𑁦.

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

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

𑁩𑁧.

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

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

𑁩𑁨.

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

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

𑁩𑁩.

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

𑀓𑀼𑀲𑀭𑀸𑀚𑀸𑀢𑀺 𑀓𑀢𑁆𑀯𑀸𑀦, 𑀓𑀭𑀲𑁆𑀲𑀼 𑀭𑀼𑀘𑀺𑀭𑁂 𑀧𑀺𑀬𑀁’’.

𑁩𑁪.

‘‘𑀏𑀢𑁂 ¶ 𑀦𑀸𑀕𑀸 𑀉𑀧𑀢𑁆𑀣𑀤𑁆𑀥𑀸, 𑀲𑀩𑁆𑀩𑁂 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺 𑀯𑀫𑁆𑀫𑀺𑀢𑀸 [𑀯𑀫𑁆𑀫𑀺𑀓𑀸 (𑀲𑁆𑀬𑀸.)];

𑀧𑀼𑀭𑀸 𑀫𑀤𑁆𑀤𑀦𑁆𑀢𑀺 𑀧𑀸𑀓𑀸𑀭𑀁, 𑀆𑀦𑁂𑀦𑁆𑀢𑁂𑀢𑀁 𑀧𑀪𑀸𑀯𑀢𑀺𑀁’’.

𑁩𑁫.

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

𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀁 𑀧𑀤𑀲𑁆𑀲𑀸𑀫𑀺, 𑀬𑁂 𑀫𑀁 𑀳𑀦𑁆𑀢𑀼𑀁 𑀇𑀥𑀸𑀕𑀢𑀸’’.

𑁩𑁬.

‘‘𑀅𑀯𑀼𑀝𑁆𑀞𑀳𑀺 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑀻, 𑀲𑀸𑀫𑀸 𑀓𑁄𑀲𑁂𑀬𑁆𑀬𑀯𑀸𑀲𑀺𑀦𑀻;

𑀅𑀲𑁆𑀲𑀼𑀧𑀼𑀡𑁆𑀡𑁂𑀳𑀺 𑀦𑁂𑀢𑁆𑀢𑁂𑀳𑀺, 𑀤𑀸𑀲𑀻𑀕𑀡𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑀸’’.

𑁩𑁭.

‘‘𑀢𑀁 𑀦𑀽𑀦 𑀓𑀓𑁆𑀓𑀽𑀧𑀦𑀺𑀲𑁂𑀯𑀺𑀢𑀁 𑀫𑀼𑀔𑀁, 𑀆𑀤𑀸𑀲𑀤𑀦𑁆𑀢𑀸𑀣𑀭𑀼𑀧𑀘𑁆𑀘𑀯𑁂𑀓𑁆𑀔𑀺𑀢𑀁;

𑀲𑀼𑀪𑀁 𑀲𑀼𑀦𑁂𑀢𑁆𑀢𑀁 𑀯𑀺𑀭𑀚𑀁 𑀅𑀦𑀗𑁆𑀕𑀡𑀁, 𑀙𑀼𑀤𑁆𑀥𑀁 𑀯𑀦𑁂 𑀞𑀲𑁆𑀲𑀢𑀺 𑀔𑀢𑁆𑀢𑀺𑀬𑁂𑀳𑀺.

𑁩𑁮.

‘‘𑀢𑁂 𑀦𑀽𑀦 𑀫𑁂 𑀅𑀲𑀺𑀢𑁂 𑀯𑁂𑀮𑁆𑀮𑀺𑀢𑀕𑁆𑀕𑁂, 𑀓𑁂𑀲𑁂 𑀫𑀼𑀤𑀽 𑀘𑀦𑁆𑀤𑀦𑀲𑀸𑀭𑀮𑀺𑀢𑁆𑀢𑁂;

𑀲𑀫𑀸𑀓𑀼𑀮𑁂 𑀲𑀻𑀯𑀣𑀺𑀓𑀸𑀬 𑀫𑀚𑁆𑀛𑁂, 𑀧𑀸𑀤𑁂𑀳𑀺 𑀕𑀺𑀚𑁆𑀛𑀸 𑀧𑀭𑀺𑀓𑀟𑁆𑀠𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺 [𑀧𑀭𑀺𑀓𑀟𑁆𑀠𑀬𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑁩𑁯.

‘‘𑀢𑀸 𑀦𑀽𑀦 𑀫𑁂 𑀢𑀫𑁆𑀩𑀦𑀔𑀸 𑀲𑀼𑀮𑁄𑀫𑀸, 𑀩𑀸𑀳𑀸 𑀫𑀼𑀤𑀽 𑀘𑀦𑁆𑀤𑀦𑀲𑀸𑀭𑀮𑀺𑀢𑁆𑀢𑀸;

𑀙𑀺𑀦𑁆𑀦𑀸 𑀯𑀦𑁂 𑀉𑀚𑁆𑀛𑀺𑀢𑀸 𑀔𑀢𑁆𑀢𑀺𑀬𑁂𑀳𑀺, 𑀕𑀬𑁆𑀳 𑀥𑀗𑁆𑀓𑁄 [𑀯𑀓𑁄 (𑀧𑀻.)] 𑀕𑀘𑁆𑀙𑀢𑀺 𑀬𑁂𑀦 𑀓𑀸𑀫𑀁.

𑁪𑁦.

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

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

𑁪𑁧.

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

𑀙𑀺𑀦𑁆𑀦𑀁 𑀯𑀦𑁂 𑀔𑀢𑁆𑀢𑀺𑀬𑁂𑀳𑀻 𑀅𑀯𑀢𑁆𑀣𑀁, 𑀲𑀺𑀗𑁆𑀕𑀸𑀮𑀲𑀗𑁆𑀖𑀸 𑀧𑀭𑀺𑀓𑀟𑁆𑀠𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺 [𑀕𑀬𑁆𑀳𑀸 𑀯𑀓𑁄 𑀕𑀘𑁆𑀙𑀢𑀺 𑀬𑁂𑀦𑀓𑀸𑀫𑀁 (𑀧𑀻.)].

𑁪𑁨.

‘‘𑀲𑁄𑀡𑀸 ¶ ¶ 𑀥𑀗𑁆𑀓𑀸 [𑀯𑀓𑀸 (𑀧𑀻.)] 𑀲𑀺𑀗𑁆𑀕𑀸𑀮𑀸 𑀘, 𑀬𑁂 𑀘𑀜𑁆𑀜𑁂 𑀲𑀦𑁆𑀢𑀺 𑀤𑀸𑀞𑀺𑀦𑁄;

𑀅𑀚𑀭𑀸 𑀦𑀽𑀦 𑀳𑁂𑀲𑁆𑀲𑀦𑁆𑀢𑀺, 𑀪𑀓𑁆𑀔𑀬𑀺𑀢𑁆𑀯𑀸 𑀧𑀪𑀸𑀯𑀢𑀺𑀁.

𑁪𑁩.

‘‘𑀲𑀘𑁂 𑀫𑀁𑀲𑀸𑀦𑀺 𑀳𑀭𑀺𑀁𑀲𑀼, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀤𑀽𑀭𑀕𑀸𑀫𑀺𑀦𑁄;

𑀅𑀝𑁆𑀞𑀻𑀦𑀺 𑀅𑀫𑁆𑀫 𑀬𑀸𑀘𑀺𑀢𑁆𑀯𑀸, 𑀅𑀦𑀼𑀧𑀣𑁂 𑀤𑀳𑀸𑀣 𑀦𑀁.

𑁪𑁪.

‘‘𑀔𑁂𑀢𑁆𑀢𑀸𑀦𑀺 𑀅𑀫𑁆𑀫 𑀓𑀸𑀭𑁂𑀢𑁆𑀯𑀸, 𑀓𑀡𑀺𑀓𑀸𑀭𑁂𑀢𑁆𑀣 𑀭𑁄𑀧𑀬 [𑀭𑁄𑀧𑀬𑁂 (𑀓.)];

𑀬𑀤𑀸 𑀢𑁂 𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀸 𑀅𑀲𑁆𑀲𑀼, 𑀳𑁂𑀫𑀦𑁆𑀢𑀸𑀦𑀁 𑀳𑀺𑀫𑀘𑁆𑀘𑀬𑁂;

𑀲𑀭𑁂𑀬𑁆𑀬𑀸𑀣 𑀫𑀫𑀁 [𑀫𑀫 (𑀧𑀻.)] 𑀅𑀫𑁆𑀫, 𑀏𑀯𑀁𑀯𑀡𑁆𑀡𑀸 𑀧𑀪𑀸𑀯𑀢𑀻’’.

𑁪𑁫.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑀸𑀢𑀸 𑀉𑀤𑀝𑁆𑀞𑀸𑀲𑀺, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀤𑁂𑀯𑀯𑀡𑁆𑀡𑀺𑀦𑀻;

𑀤𑀺𑀲𑁆𑀯𑀸 𑀅𑀲𑀺𑀜𑁆𑀘 𑀲𑀽𑀦𑀜𑁆𑀘, 𑀭𑀜𑁆𑀜𑁄 𑀫𑀤𑁆𑀤𑀲𑁆𑀲𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑁂’’.

𑁪𑁬.

‘‘𑀇𑀫𑀺𑀦𑀸 𑀦𑀽𑀦 𑀅𑀲𑀺𑀦𑀸, 𑀲𑀼𑀲𑀜𑁆𑀜𑀁 𑀢𑀦𑀼𑀫𑀚𑁆𑀛𑀺𑀫𑀁;

𑀥𑀻𑀢𑀭𑀁 𑀫𑀤𑁆𑀤 [𑀫𑀫 (𑀲𑀻.), 𑀫𑀤𑁆𑀤𑁄 (𑀧𑀻.)] 𑀳𑀦𑁆𑀢𑁆𑀯𑀸𑀦, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀁 𑀧𑀤𑀲𑁆𑀲𑀲𑀺’’ [𑀧𑀤𑀲𑁆𑀲𑀢𑀺 (𑀧𑀻. 𑀓.)].

𑁪𑁭.

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

𑀲𑀸𑀚𑁆𑀚 𑀮𑁄𑀳𑀺𑀢𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸, 𑀕𑀘𑁆𑀙𑀲𑀺 [𑀕𑀜𑁆𑀙𑀺𑀲𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀬𑀫𑀲𑀸𑀥𑀦𑀁.

𑁪𑁮.

‘‘𑀏𑀯𑀫𑀸𑀧𑀚𑁆𑀚𑀢𑀻 𑀧𑁄𑀲𑁄, 𑀧𑀸𑀧𑀺𑀬𑀜𑁆𑀘 𑀦𑀺𑀕𑀘𑁆𑀙𑀢𑀺;

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

𑁪𑁯.

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

𑀓𑀼𑀲𑁂𑀦 ¶ 𑀚𑀸𑀢𑀁 𑀔𑀢𑁆𑀢𑀺𑀬𑀁, 𑀲𑀼𑀯𑀡𑁆𑀡𑀫𑀡𑀺𑀫𑁂𑀔𑀮𑀁;

𑀧𑀽𑀚𑀺𑀢𑀁 [𑀧𑀽𑀚𑀺𑀢𑀸 (𑀧𑀻.)] 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀳𑀺, 𑀦 𑀕𑀘𑁆𑀙𑀲𑀺 [𑀕𑀜𑁆𑀙𑀺𑀲𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀬𑀫𑀓𑁆𑀔𑀬𑀁.

𑁫𑁦.

‘‘𑀬𑀢𑁆𑀣𑀲𑁆𑀲𑀼 𑀪𑁂𑀭𑀻 𑀦𑀤𑀢𑀺, 𑀓𑀼𑀜𑁆𑀚𑀭𑁄 𑀘 𑀦𑀺𑀓𑀽𑀚𑀢𑀺 [𑀦𑀺𑀓𑀼𑀜𑁆𑀚𑀢𑀺 (𑀧𑀻.)];

𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀁 𑀓𑀼𑀮𑁂 𑀪𑀤𑁆𑀤𑁂, 𑀓𑀺𑀁 𑀦𑀼 𑀲𑀼𑀔𑀢𑀭𑀁 𑀢𑀢𑁄.

𑁫𑁧.

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

𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀁 𑀓𑀼𑀮𑁂 𑀪𑀤𑁆𑀤𑁂, 𑀓𑀺𑀁 𑀦𑀼 𑀲𑀼𑀔𑀢𑀭𑀁 𑀢𑀢𑁄.

𑁫𑁨.

‘‘𑀫𑀬𑀽𑀭𑀓𑁄𑀜𑁆𑀘𑀸𑀪𑀺𑀭𑀼𑀤𑁂, 𑀓𑁄𑀓𑀺𑀮𑀸𑀪𑀺𑀦𑀺𑀓𑀽𑀚𑀺𑀢𑁂;

𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀁 𑀓𑀼𑀮𑁂 𑀪𑀤𑁆𑀤𑁂, 𑀓𑀺𑀁 𑀦𑀼 𑀲𑀼𑀔𑀢𑀭𑀁 𑀢𑀢𑁄’’.

𑁫𑁩.

‘‘𑀓𑀳𑀁 ¶ 𑀦𑀼 𑀲𑁄 𑀲𑀢𑁆𑀢𑀼𑀫𑀤𑁆𑀤𑀦𑁄, 𑀧𑀭𑀭𑀝𑁆𑀞𑀧𑁆𑀧𑀫𑀤𑁆𑀤𑀦𑁄;

𑀓𑀼𑀲𑁄 𑀲𑁄𑀴𑀸𑀭𑀧𑀜𑁆𑀜𑀸𑀡𑁄, 𑀬𑁄 𑀦𑁄 𑀤𑀼𑀓𑁆𑀔𑀸 𑀧𑀫𑁄𑀘𑀬𑁂’’.

𑁫𑁪.

‘‘𑀇𑀥𑁂𑀯 𑀲𑁄 𑀲𑀢𑁆𑀢𑀼𑀫𑀤𑁆𑀤𑀦𑁄, 𑀧𑀭𑀭𑀝𑁆𑀞𑀧𑁆𑀧𑀫𑀤𑁆𑀤𑀦𑁄;

𑀓𑀼𑀲𑁄 𑀲𑁄𑀴𑀸𑀭𑀧𑀜𑁆𑀜𑀸𑀡𑁄, 𑀬𑁄 𑀢𑁂 𑀲𑀩𑁆𑀩𑁂 𑀯𑀥𑀺𑀲𑁆𑀲𑀢𑀺’’ [𑀬𑁄 𑀦𑁄 𑀤𑀼𑀓𑁆𑀔𑀸 𑀧𑀫𑁄𑀘𑀬𑁂 (𑀲𑀻.), 𑀲𑁄 𑀦𑁄 𑀲𑀩𑁆𑀩𑁂 𑀯𑀥𑀺𑀲𑁆𑀲𑀢𑀺 (𑀧𑀻.)].

𑁫𑁫.

‘‘𑀉𑀫𑁆𑀫𑀢𑁆𑀢𑀺𑀓𑀸 𑀦𑀼 𑀪𑀡𑀲𑀺, 𑀅𑀦𑁆𑀥𑀩𑀸𑀮𑀸 𑀧𑀪𑀸𑀲𑀲𑀺 [𑀆𑀤𑀼 𑀩𑀸𑀮𑀸𑀯 𑀪𑀸𑀲𑀲𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀓𑀼𑀲𑁄 𑀘𑁂 𑀆𑀕𑀢𑁄 𑀅𑀲𑁆𑀲, 𑀓𑀺𑀁 𑀦 [𑀓𑀺𑀦𑁆𑀦𑀼 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑀁 𑀫𑀬𑀁’’.

𑁫𑁬.

‘‘𑀏𑀲𑁄 ¶ 𑀆𑀴𑀸𑀭𑀺𑀓𑁄 𑀧𑁄𑀲𑁄, 𑀓𑀼𑀫𑀸𑀭𑀻𑀧𑀼𑀭𑀫𑀦𑁆𑀢𑀭𑁂;

𑀤𑀴𑁆𑀳𑀁 𑀓𑀢𑁆𑀯𑀸𑀦 𑀲𑀁𑀯𑁂𑀮𑁆𑀮𑀺𑀁, 𑀓𑀼𑀫𑁆𑀪𑀺𑀁 𑀥𑁄𑀯𑀢𑀺 𑀑𑀡𑀢𑁄’’.

𑁫𑁭.

‘‘𑀯𑁂𑀡𑀻 𑀢𑁆𑀯𑀫𑀲𑀺 𑀘𑀡𑁆𑀟𑀸𑀮𑀻, 𑀅𑀤𑀽𑀲𑀺 𑀓𑀼𑀮𑀕𑀦𑁆𑀥𑀺𑀦𑀻;

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

𑁫𑁮.

‘‘𑀦𑀫𑁆𑀳𑀺 𑀯𑁂𑀡𑀻 𑀦 𑀘𑀡𑁆𑀟𑀸𑀮𑀻, 𑀦 𑀘𑀫𑁆𑀳𑀺 𑀓𑀼𑀮𑀕𑀦𑁆𑀥𑀺𑀦𑀻;

𑀑𑀓𑁆𑀓𑀸𑀓𑀧𑀼𑀢𑁆𑀢𑁄 𑀪𑀤𑁆𑀤𑀦𑁆𑀢𑁂, 𑀢𑁆𑀯𑀁 𑀦𑀼 𑀤𑀸𑀲𑁄𑀢𑀺 𑀫𑀜𑁆𑀜𑀲𑀺’’.

𑁫𑁯.

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

𑀑𑀓𑁆𑀓𑀸𑀓𑀧𑀼𑀢𑁆𑀢𑁄 𑀪𑀤𑁆𑀤𑀦𑁆𑀢𑁂, 𑀢𑁆𑀯𑀁 𑀦𑀼 𑀤𑀸𑀲𑁄𑀢𑀺 𑀫𑀜𑁆𑀜𑀲𑀺’’.

𑁬𑁦.

‘‘𑀬𑀲𑁆𑀲 𑀦𑀸𑀕𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀤𑀸 𑀬𑁄𑀚𑁂𑀦𑁆𑀢𑀺 𑀯𑀻𑀲𑀢𑀺𑀁;

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

𑁬𑁧.

‘‘𑀬𑀲𑁆𑀲 𑀅𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀤𑀸 𑀬𑁄𑀚𑁂𑀦𑁆𑀢𑀺 𑀯𑀻𑀲𑀢𑀺𑀁;

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

𑁬𑁨.

‘‘𑀬𑀲𑁆𑀲 𑀭𑀣𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀤𑀸 𑀬𑁄𑀚𑁂𑀦𑁆𑀢𑀺 𑀯𑀻𑀲𑀢𑀺𑀁;

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

[( ) 𑀅𑀬𑀁 𑀕𑀸𑀣𑀸 𑀲𑀻. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼𑀬𑁂𑀯 𑀤𑀺𑀲𑁆𑀲𑀢𑀺] (‘‘𑀬𑀲𑁆𑀲 𑀉𑀲𑀪𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀤𑀸 𑀬𑁄𑀚𑁂𑀦𑁆𑀢𑀺 𑀯𑀻𑀲𑀢𑀺𑀁;

𑀑𑀓𑁆𑀓𑀸𑀓𑀧𑀼𑀢𑁆𑀢𑁄 𑀪𑀤𑁆𑀤𑀦𑁆𑀢𑁂, 𑀢𑁆𑀯𑀁 𑀦𑀼 𑀤𑀸𑀲𑁄𑀢𑀺 𑀫𑀜𑁆𑀜𑀲𑀺) [( ) 𑀅𑀬𑀁 𑀕𑀸𑀣𑀸 𑀲𑀻. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼𑀬𑁂𑀯 𑀤𑀺𑀲𑁆𑀲𑀢𑀺].

𑁬𑁩.

‘‘𑀬𑀲𑁆𑀲 𑀥𑁂𑀦𑀼𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀤𑀸 𑀤𑀼𑀳𑀦𑁆𑀢𑀺 𑀯𑀻𑀲𑀢𑀺𑀁 [𑀤𑀼𑀬𑁆𑀳𑀦𑁆𑀢𑀺 𑀯𑀻𑀲𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀑𑀓𑁆𑀓𑀸𑀓𑀧𑀼𑀢𑁆𑀢𑁄 𑀪𑀤𑁆𑀤𑀦𑁆𑀢𑁂, 𑀢𑁆𑀯𑀁 𑀦𑀼 𑀤𑀸𑀲𑁄𑀢𑀺 𑀫𑀜𑁆𑀜𑀲𑀺’’.

𑁬𑁪.

‘‘𑀢𑀕𑁆𑀖 ¶ 𑀢𑁂 𑀤𑀼𑀓𑁆𑀓𑀝𑀁 𑀩𑀸𑀮𑁂, 𑀬𑀁 𑀔𑀢𑁆𑀢𑀺𑀬𑀁 𑀫𑀳𑀩𑁆𑀩𑀮𑀁;

𑀦𑀸𑀕𑀁 𑀫𑀡𑁆𑀟𑀽𑀓𑀯𑀡𑁆𑀡𑁂𑀦, 𑀦 𑀦𑀁 [𑀦 𑀢𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀅𑀓𑁆𑀔𑀸𑀲𑀺𑀥𑀸𑀕𑀢𑀁’’ [𑀅𑀓𑁆𑀔𑀸𑀲𑀺 𑀆𑀕𑀢𑀁 (𑀲𑀻.)].

𑁬𑁫.

‘‘𑀅𑀧𑀭𑀸𑀥𑀁 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀢𑁆𑀯𑀁 𑀦𑁄 𑀔𑀫 𑀭𑀣𑁂𑀲𑀪;

𑀬𑀁 𑀢𑀁 𑀅𑀜𑁆𑀜𑀸𑀢𑀯𑁂𑀲𑁂𑀦, 𑀦𑀸𑀜𑁆𑀜𑀸𑀲𑀺𑀫𑁆𑀳𑀸 𑀇𑀥𑀸𑀕𑀢𑀁’’.

𑁬𑁬.

‘‘𑀫𑀸𑀤𑀺𑀲𑀲𑁆𑀲 𑀦 𑀢𑀁 𑀙𑀦𑁆𑀦𑀁, 𑀬𑁄𑀳𑀁 𑀆𑀴𑀸𑀭𑀺𑀓𑁄 𑀪𑀯𑁂;

𑀢𑁆𑀯𑀜𑁆𑀜𑁂𑀯 𑀫𑁂 𑀧𑀲𑀻𑀤𑀲𑁆𑀲𑀼, 𑀦𑀢𑁆𑀣𑀺 𑀢𑁂 𑀤𑁂𑀯 𑀤𑀼𑀓𑁆𑀓𑀝𑀁’’.

𑁬𑁭.

‘‘𑀕𑀘𑁆𑀙 𑀩𑀸𑀮𑁂 𑀔𑀫𑀸𑀧𑁂𑀳𑀺, 𑀓𑀼𑀲𑀭𑀸𑀚𑀁 𑀫𑀳𑀩𑁆𑀩𑀮𑀁;

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

𑁬𑁮.

‘‘𑀧𑀺𑀢𑀼𑀲𑁆𑀲 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀤𑁂𑀯𑀯𑀡𑁆𑀡𑀻 𑀧𑀪𑀸𑀯𑀢𑀻;

𑀲𑀺𑀭𑀲𑀸 𑀅𑀕𑁆𑀕𑀳𑀻 𑀧𑀸𑀤𑁂, 𑀓𑀼𑀲𑀭𑀸𑀚𑀁 𑀫𑀳𑀩𑁆𑀩𑀮𑀁’’.

𑁬𑁯.

‘‘𑀬𑀸𑀫𑀸 ¶ 𑀭𑀢𑁆𑀬𑁄 𑀅𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀸, 𑀢𑀸𑀫𑀸 𑀤𑁂𑀯 𑀢𑀬𑀸 𑀯𑀺𑀦𑀸;

𑀯𑀦𑁆𑀤𑁂 𑀢𑁂 𑀲𑀺𑀭𑀲𑀸 𑀧𑀸𑀤𑁂, 𑀫𑀸 𑀫𑁂 𑀓𑀼𑀚𑁆𑀛𑀁 𑀭𑀣𑁂𑀲𑀪.

𑁭𑁦.

‘‘𑀲𑀩𑁆𑀩𑀁 ¶ [𑀲𑀘𑁆𑀘𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀢𑁂 𑀧𑀝𑀺𑀚𑀸𑀦𑀸𑀫𑀺, 𑀫𑀳𑀸𑀭𑀸𑀚 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑁂;

𑀦 𑀘𑀸𑀧𑀺 𑀅𑀧𑁆𑀧𑀺𑀬𑀁 𑀢𑀼𑀬𑁆𑀳𑀁, 𑀓𑀭𑁂𑀬𑁆𑀬𑀸𑀫𑀺 𑀅𑀳𑀁 𑀧𑀼𑀦.

𑁭𑁧.

‘‘𑀏𑀯𑀁 𑀘𑁂 𑀬𑀸𑀘𑀫𑀸𑀦𑀸𑀬, 𑀯𑀘𑀦𑀁 𑀫𑁂 𑀦 𑀓𑀸𑀳𑀲𑀺;

𑀇𑀤𑀸𑀦𑀺 𑀫𑀁 𑀢𑀸𑀢𑁄 𑀳𑀦𑁆𑀢𑁆𑀯𑀸, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀁 𑀧𑀤𑀲𑁆𑀲𑀢𑀺’’.

𑁭𑁨.

‘‘𑀏𑀯𑀁 𑀢𑁂 𑀬𑀸𑀘𑀫𑀸𑀦𑀸𑀬, 𑀓𑀺𑀁 𑀦 𑀓𑀸𑀳𑀸𑀫𑀺 𑀢𑁂 𑀯𑀘𑁄;

𑀯𑀺𑀓𑀼𑀤𑁆𑀥𑁄 𑀢𑁆𑀬𑀲𑁆𑀫𑀺 𑀓𑀮𑁆𑀬𑀸𑀡𑀺, 𑀫𑀸 𑀢𑁆𑀯𑀁 𑀪𑀸𑀬𑀺 𑀧𑀪𑀸𑀯𑀢𑀺.

𑁭𑁩.

‘‘𑀲𑀩𑁆𑀩𑀁 𑀢𑁂 𑀧𑀝𑀺𑀚𑀸𑀦𑀸𑀫𑀺, 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑀺 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑁂;

𑀦 𑀘𑀸𑀧𑀺 𑀅𑀧𑁆𑀧𑀺𑀬𑀁 𑀢𑀼𑀬𑁆𑀳𑀁, 𑀓𑀭𑁂𑀬𑁆𑀬𑀸𑀫𑀺 𑀅𑀳𑀁 𑀧𑀼𑀦.

𑁭𑁪.

‘‘𑀢𑀯 𑀓𑀸𑀫𑀸 𑀳𑀺 𑀲𑀼𑀲𑁆𑀲𑁄𑀡𑀺, 𑀧𑀳𑀼 [𑀩𑀳𑀼 (𑀲𑁆𑀬𑀸.), 𑀩𑀳𑀽 (𑀧𑀻.), 𑀩𑀳𑀼𑀁 (𑀓.)] 𑀤𑀼𑀓𑁆𑀔𑀁 𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀺𑀲𑀁 [𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁 (𑀲𑀻. 𑀧𑀻.)];

𑀩𑀳𑀼𑀁 𑀫𑀤𑁆𑀤𑀓𑀼𑀮𑀁 𑀳𑀦𑁆𑀢𑁆𑀯𑀸, 𑀦𑀬𑀺𑀢𑀼𑀁 𑀢𑀁 𑀧𑀪𑀸𑀯𑀢𑀺’’.

𑁭𑁫.

‘‘𑀬𑁄𑀚𑀬𑀦𑁆𑀢𑀼 𑀭𑀣𑁂 𑀅𑀲𑁆𑀲𑁂, 𑀦𑀸𑀦𑀸𑀘𑀺𑀢𑁆𑀢𑁂 𑀲𑀫𑀸𑀳𑀺𑀢𑁂;

𑀅𑀣 𑀤𑀓𑁆𑀔𑀣 𑀫𑁂 𑀯𑁂𑀕𑀁, 𑀯𑀺𑀥𑀫𑀦𑁆𑀢𑀲𑁆𑀲 [𑀯𑀺𑀥𑀫𑁂𑀦𑁆𑀢𑀲𑁆𑀲 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)] 𑀲𑀢𑁆𑀢𑀯𑁄’’.

𑁭𑁬.

‘‘𑀢𑀜𑁆𑀘 𑀢𑀢𑁆𑀣 𑀉𑀤𑀺𑀓𑁆𑀔𑀺𑀁𑀲𑀼, 𑀭𑀜𑁆𑀜𑁄 𑀫𑀤𑁆𑀤𑀲𑁆𑀲𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑁂;

𑀯𑀺𑀚𑀫𑁆𑀪𑀫𑀸𑀦𑀁 𑀲𑀻𑀳𑀁𑀯, 𑀨𑁄𑀝𑁂𑀦𑁆𑀢𑀁 𑀤𑀺𑀕𑀼𑀡𑀁 𑀪𑀼𑀚𑀁.

𑁭𑁭.

‘‘𑀳𑀢𑁆𑀣𑀺𑀓𑁆𑀔𑀦𑁆𑀥𑀜𑁆𑀘 ¶ 𑀆𑀭𑀼𑀬𑁆𑀳, 𑀆𑀭𑁄𑀧𑁂𑀢𑁆𑀯𑀸 𑀧𑀪𑀸𑀯𑀢𑀺𑀁;

𑀲𑀗𑁆𑀕𑀸𑀫𑀁 𑀑𑀢𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀲𑀻𑀳𑀦𑀸𑀤𑀁 𑀦𑀤𑀻 𑀓𑀼𑀲𑁄.

𑁭𑁮.

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

𑀔𑀢𑁆𑀢𑀺𑀬𑀸 ¶ 𑀯𑀺𑀧𑀮𑀸𑀬𑀺𑀁𑀲𑀼, 𑀓𑀼𑀲𑀲𑀤𑁆𑀤𑀪𑀬𑀝𑁆𑀝𑀺𑀢𑀸 [𑀓𑀼𑀲𑀲𑀤𑁆𑀤𑀪𑀬𑀝𑁆𑀞𑀺𑀢𑀸 (𑀧𑀻.)].

𑁭𑁯.

‘‘𑀳𑀢𑁆𑀣𑀸𑀭𑁄𑀳𑀸 𑀅𑀦𑀻𑀓𑀝𑁆𑀞𑀸, 𑀭𑀣𑀺𑀓𑀸 𑀧𑀢𑁆𑀢𑀺𑀓𑀸𑀭𑀓𑀸;

𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀲𑁆𑀲 𑀙𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺, 𑀓𑀼𑀲𑀲𑀤𑁆𑀤𑀪𑀬𑀝𑁆𑀝𑀺𑀢𑀸.

𑁮𑁦.

‘‘𑀢𑀲𑁆𑀫𑀺𑀁 𑀲𑀗𑁆𑀕𑀸𑀫𑀲𑀻𑀲𑀲𑁆𑀫𑀺𑀁, 𑀧𑀲𑁆𑀲𑀺𑀢𑁆𑀯𑀸 𑀳𑀝𑁆𑀞 [𑀢𑀼𑀝𑁆𑀞 (𑀲𑀻.)] 𑀫𑀸𑀦𑀲𑁄;

𑀓𑀼𑀲𑀲𑁆𑀲 𑀭𑀜𑁆𑀜𑁄 𑀤𑁂𑀯𑀺𑀦𑁆𑀤𑁄, 𑀅𑀤𑀸 𑀯𑁂𑀭𑁄𑀘𑀦𑀁 𑀫𑀡𑀺𑀁.

𑁮𑁧.

‘‘𑀲𑁄 𑀢𑀁 𑀯𑀺𑀚𑀺𑀢𑁆𑀯𑀸 𑀲𑀗𑁆𑀕𑀸𑀫𑀁, 𑀮𑀤𑁆𑀥𑀸 𑀯𑁂𑀭𑁄𑀘𑀦𑀁 𑀫𑀡𑀺𑀁;

𑀳𑀢𑁆𑀣𑀺𑀓𑁆𑀔𑀦𑁆𑀥𑀕𑀢𑁄 𑀭𑀸𑀚𑀸, 𑀧𑀸𑀯𑁂𑀓𑁆𑀔𑀺 𑀦𑀕𑀭𑀁 𑀧𑀼𑀭𑀁.

𑁮𑁨.

‘‘𑀚𑀻𑀯𑀕𑁆𑀕𑀸𑀳𑀁 [𑀚𑀻𑀯𑀕𑀸𑀳𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀩𑀦𑁆𑀥𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑁆𑀢 𑀔𑀢𑁆𑀢𑀺𑀬𑁂;

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

𑁮𑁩.

‘‘𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀯𑀲𑀁 𑀕𑀢𑀸, 𑀅𑀫𑀺𑀢𑁆𑀢𑀸 𑀯𑀺𑀳𑀢𑀸 𑀢𑀯;

𑀓𑀸𑀫𑀁 𑀓𑀭𑁄𑀳𑀺 𑀢𑁂 𑀢𑀬𑀸, 𑀫𑀼𑀜𑁆𑀘 𑀯𑀸 𑀢𑁂 𑀳𑀦𑀲𑁆𑀲𑀼 𑀯𑀸’’.

𑁮𑁪.

‘‘𑀢𑀼𑀬𑁆𑀳𑁂𑀯 𑀲𑀢𑁆𑀢𑀯𑁄 𑀏𑀢𑁂, 𑀦 𑀳𑀺 𑀢𑁂 𑀫𑀬𑁆𑀳 𑀲𑀢𑁆𑀢𑀯𑁄;

𑀢𑁆𑀯𑀜𑁆𑀜𑁂𑀯 𑀦𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀫𑀼𑀜𑁆𑀘 𑀯𑀸 𑀢𑁂 𑀳𑀦𑀲𑁆𑀲𑀼 𑀯𑀸’’.

𑁮𑁫.

‘‘𑀇𑀫𑀸 ¶ 𑀢𑁂 𑀥𑀻𑀢𑀭𑁄 𑀲𑀢𑁆𑀢, 𑀤𑁂𑀯𑀓𑀜𑁆𑀜𑀽𑀧𑀫𑀸 𑀲𑀼𑀪𑀸;

𑀤𑀤𑀸𑀳𑀺 𑀦𑁂𑀲𑀁 𑀏𑀓𑁂𑀓𑀁, 𑀳𑁄𑀦𑁆𑀢𑀼 𑀚𑀸𑀫𑀸𑀢𑀭𑁄 𑀢𑀯’’.

𑁮𑁬.

‘‘𑀅𑀫𑁆𑀳𑀸𑀓𑀜𑁆𑀘𑁂𑀯 𑀢𑀸𑀲𑀜𑁆𑀘, 𑀢𑁆𑀯𑀁 𑀦𑁄 𑀲𑀩𑁆𑀩𑁂𑀲𑀫𑀺𑀲𑁆𑀲𑀭𑁄;

𑀢𑁆𑀯𑀜𑁆𑀜𑁂𑀯 𑀦𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀤𑁂𑀳𑀺 𑀦𑁂𑀲𑀁 𑀬𑀤𑀺𑀘𑁆𑀙𑀲𑀺’’.

𑁮𑁭.

‘‘𑀏𑀓𑀫𑁂𑀓𑀲𑁆𑀲 𑀏𑀓𑁂𑀓𑀁, 𑀅𑀤𑀸 𑀲𑀻𑀳𑀲𑁆𑀲𑀭𑁄 𑀓𑀼𑀲𑁄;

𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀁 𑀢𑀤𑀸 𑀢𑁂𑀲𑀁, 𑀭𑀜𑁆𑀜𑁄 𑀫𑀤𑁆𑀤𑀲𑁆𑀲 𑀥𑀻𑀢𑀭𑁄.

𑁮𑁮.

‘‘𑀧𑀻𑀡𑀺𑀢𑀸 𑀢𑁂𑀦 𑀮𑀸𑀪𑁂𑀦, 𑀢𑀼𑀝𑁆𑀞𑀸 𑀲𑀻𑀳𑀲𑁆𑀲𑀭𑁂 𑀓𑀼𑀲𑁂;

𑀲𑀓𑀭𑀝𑁆𑀞𑀸𑀦𑀺 ¶ 𑀧𑀸𑀬𑀺𑀁𑀲𑀼, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀲𑀢𑁆𑀢 𑀢𑀸𑀯𑀤𑁂.

𑁮𑁯.

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

𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁 𑀓𑀼𑀲𑁄 𑀭𑀸𑀚𑀸, 𑀅𑀕𑀫𑀸𑀲𑀺 𑀫𑀳𑀩𑁆𑀩𑀮𑁄.

𑁯𑁦.

‘‘𑀢𑁆𑀬𑀲𑁆𑀲𑀼 ¶ 𑀏𑀓𑀭𑀣𑁂 𑀬𑀦𑁆𑀢𑀸, 𑀧𑀯𑀺𑀲𑀦𑁆𑀢𑀸 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀁;

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

𑁯𑁧.

‘‘𑀫𑀸𑀢𑀸 𑀧𑀼𑀢𑁆𑀢𑁂𑀦 𑀲𑀗𑁆𑀕𑀘𑁆𑀙𑀺 [𑀲𑀗𑁆𑀕𑀜𑁆𑀙𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀉𑀪𑀬𑁄 𑀘 𑀚𑀬𑀫𑁆𑀧𑀢𑀻;

𑀲𑀫𑀕𑁆𑀕𑀸 𑀢𑁂 𑀢𑀤𑀸 𑀆𑀲𑀼𑀁, 𑀨𑀻𑀢𑀁 𑀥𑀭𑀡𑀺𑀫𑀸𑀯𑀲𑀼’’𑀦𑁆𑀢𑀺.

𑀓𑀼𑀲𑀚𑀸𑀢𑀓𑀁 𑀧𑀞𑀫𑀁.

𑁫𑁩𑁨. 𑀲𑁄𑀡𑀦𑀦𑁆𑀤𑀚𑀸𑀢𑀓𑀁 (𑁨)

𑁯𑁨.

‘‘𑀤𑁂𑀯𑀢𑀸 𑀦𑀼𑀲𑀺 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀅𑀤𑀼 [𑀆𑀤𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄 𑀇𑀤𑁆𑀥𑀺𑀫𑀸, 𑀓𑀣𑀁 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑀁 𑀫𑀬𑀁’’.

𑁯𑁩.

‘‘𑀦𑀸𑀧𑀺 𑀤𑁂𑀯𑁄 𑀦 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀦𑀸𑀧𑀺 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄 𑀇𑀤𑁆𑀥𑀺𑀫𑀸, 𑀏𑀯𑀁 𑀚𑀸𑀦𑀸𑀳𑀺 𑀪𑀸𑀭𑀥’’ [𑀪𑀸𑀭𑀪 (𑀓.)].

𑁯𑁪.

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

𑀤𑁂𑀯𑀫𑁆𑀳𑀺 𑀯𑀲𑁆𑀲𑀫𑀸𑀦𑀫𑁆𑀳𑀺, 𑀅𑀦𑁄𑀯𑀲𑁆𑀲𑀁 𑀪𑀯𑀁 𑀅𑀓𑀸.

𑁯𑁫.

‘‘𑀢𑀢𑁄 𑀯𑀸𑀢𑀸𑀢𑀧𑁂 𑀖𑁄𑀭𑁂, 𑀲𑀻𑀢𑀘𑁆𑀙𑀸𑀬𑀁 𑀪𑀯𑀁 𑀅𑀓𑀸;

𑀢𑀢𑁄 𑀅𑀫𑀺𑀢𑁆𑀢𑀫𑀚𑁆𑀛𑁂𑀲𑀼 [𑀅𑀫𑀺𑀢𑁆𑀢𑀫𑀚𑁆𑀛𑁂 𑀘 (𑀲𑀻.)], 𑀲𑀭𑀢𑀸𑀡𑀁 𑀪𑀯𑀁 𑀅𑀓𑀸.

𑁯𑁬.

‘‘𑀢𑀢𑁄 𑀨𑀻𑀢𑀸𑀦𑀺 𑀭𑀝𑁆𑀞𑀸𑀦𑀺, 𑀯𑀲𑀺𑀦𑁄 𑀢𑁂 𑀪𑀯𑀁 𑀅𑀓𑀸;

𑀢𑀢𑁄 𑀏𑀓𑀲𑀢𑀁 𑀔𑀢𑁆𑀬𑁂, 𑀅𑀦𑀼𑀬𑀦𑁆𑀢𑁂 [𑀅𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑁂 (𑀧𑀻.)] 𑀪𑀯𑀁 𑀅𑀓𑀸.

𑁯𑁭.

‘‘𑀧𑀢𑀻𑀢𑀸𑀲𑁆𑀲𑀼 ¶ ¶ 𑀫𑀬𑀁 𑀪𑁄𑀢𑁄, 𑀯𑀤 𑀢𑀁 [𑀯𑀭 𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀪𑀜𑁆𑀚 [𑀪𑀜𑁆𑀜 (𑀲𑀻. 𑀧𑀻.), 𑀪𑀼𑀜𑁆𑀚 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀫𑀺𑀘𑁆𑀙𑀲𑀺;

𑀳𑀢𑁆𑀣𑀺𑀬𑀸𑀦𑀁 𑀅𑀲𑁆𑀲𑀭𑀣𑀁, 𑀦𑀸𑀭𑀺𑀬𑁄 𑀘 𑀅𑀮𑀗𑁆𑀓𑀢𑀸;

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

𑁯𑁮.

‘‘𑀅𑀣 𑀯𑀗𑁆𑀕𑁂 [𑀅𑀣 𑀯𑀸 𑀲𑀗𑁆𑀕𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑀸 𑀫𑀕𑀥𑁂, 𑀫𑀬𑀁 𑀪𑁄𑀢𑁄 𑀤𑀤𑀸𑀫𑀲𑁂;

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

𑁯𑁯.

‘‘𑀉𑀧𑀟𑁆𑀠𑀁 𑀯𑀸𑀧𑀺 𑀭𑀚𑁆𑀚𑀲𑁆𑀲, 𑀫𑀬𑀁 𑀪𑁄𑀢𑁄 𑀤𑀤𑀸𑀫𑀲𑁂;

𑀲𑀘𑁂 𑀢𑁂 𑀅𑀢𑁆𑀣𑁄 𑀭𑀚𑁆𑀚𑁂𑀦, 𑀅𑀦𑀼𑀲𑀸𑀲 𑀬𑀤𑀺𑀘𑁆𑀙𑀲𑀺’’.

𑁧𑁦𑁦.

‘‘𑀦 ¶ 𑀫𑁂 𑀅𑀢𑁆𑀣𑁄𑀧𑀺 𑀭𑀚𑁆𑀚𑁂𑀦, 𑀦𑀕𑀭𑁂𑀦 𑀥𑀦𑁂𑀦 𑀯𑀸;

𑀅𑀣𑁄𑀧𑀺 𑀚𑀦𑀧𑀤𑁂𑀦, 𑀅𑀢𑁆𑀣𑁄 𑀫𑀬𑁆𑀳𑀁 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺.

𑁧𑁦𑁧.

‘‘𑀪𑁄𑀢𑁄𑀯 𑀭𑀝𑁆𑀞𑁂 𑀯𑀺𑀚𑀺𑀢𑁂, 𑀅𑀭𑀜𑁆𑀜𑁂 𑀅𑀢𑁆𑀣𑀺 𑀅𑀲𑁆𑀲𑀫𑁄;

𑀧𑀺𑀢𑀸 𑀫𑀬𑁆𑀳𑀁 𑀚𑀦𑁂𑀢𑁆𑀢𑀻 𑀘, 𑀉𑀪𑁄 𑀲𑀫𑁆𑀫𑀦𑁆𑀢𑀺 𑀅𑀲𑁆𑀲𑀫𑁂.

𑁧𑁦𑁨.

‘‘𑀢𑁂𑀲𑀸𑀳𑀁 [𑀢𑁂𑀲𑁆𑀯𑀳𑀁 (𑀓.)] 𑀧𑀼𑀩𑁆𑀩𑀸𑀘𑀭𑀺𑀬𑁂𑀲𑀼, 𑀧𑀼𑀜𑁆𑀜𑀁 𑀦 𑀮𑀪𑀸𑀫𑀺 𑀓𑀸𑀢𑀯𑁂;

𑀪𑀯𑀦𑁆𑀢𑀁 𑀅𑀚𑁆𑀛𑀸𑀯𑀭𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀲𑁄𑀡𑀁 [𑀲𑁄𑀦𑀁 (𑀧𑀻.)] 𑀬𑀸𑀘𑁂𑀫𑀼 𑀲𑀁𑀯𑀭𑀁’’.

𑁧𑁦𑁩.

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

𑀏𑀢𑀜𑁆𑀘 𑀔𑁄 𑀦𑁄 𑀅𑀓𑁆𑀔𑀸𑀳𑀺, 𑀓𑀻𑀯𑀦𑁆𑀢𑁄 𑀳𑁄𑀦𑁆𑀢𑀼 𑀬𑀸𑀘𑀓𑀸’’.

𑁧𑁦𑁪.

‘‘𑀧𑀭𑁄𑀲𑀢𑀁 𑀚𑀸𑀦𑀧𑀤𑀸, 𑀫𑀳𑀸𑀲𑀸𑀮𑀸 𑀘 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸;

𑀇𑀫𑁂 𑀘 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀲𑀩𑁆𑀩𑁂, 𑀅𑀪𑀺𑀚𑀸𑀢𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄;

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

𑁧𑁦𑁫.

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

𑀆𑀩𑀦𑁆𑀥𑀦𑀸𑀦𑀺 𑀕𑀡𑁆𑀳𑀸𑀣, 𑀧𑀸𑀤𑀸𑀲𑀼𑀲𑁆𑀲𑀸𑀭𑀬𑀤𑁆𑀥𑀚𑁂 [𑀧𑀸𑀤𑁂𑀲𑀼𑀲𑁆𑀲𑀸𑀭𑀬𑀁 𑀥𑀚𑁂 (𑀲𑀻.), 𑀧𑀸𑀤𑀸𑀲𑀼𑀲𑁆𑀲𑀸𑀭𑀬𑀁 𑀥𑀚𑁂 (𑀧𑀻.)];

𑀅𑀲𑁆𑀲𑀫𑀁 ¶ 𑀢𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀬𑀢𑁆𑀣 𑀲𑀫𑁆𑀫𑀢𑀺 𑀓𑁄𑀲𑀺𑀬𑁄’’.

𑁧𑁦𑁬.

‘‘𑀢𑀢𑁄 𑀘 𑀭𑀸𑀚𑀸 𑀧𑀸𑀬𑀸𑀲𑀺, 𑀲𑁂𑀦𑀸𑀬 𑀘𑀢𑀼𑀭𑀗𑁆𑀕𑀺𑀦𑀻;

𑀅𑀕𑀫𑀸 𑀅𑀲𑁆𑀲𑀫𑀁 𑀭𑀫𑁆𑀫𑀁, 𑀬𑀢𑁆𑀣 𑀲𑀫𑁆𑀫𑀢𑀺 𑀓𑁄𑀲𑀺𑀬𑁄’’.

𑁧𑁦𑁭.

‘‘𑀓𑀲𑁆𑀲 𑀓𑀸𑀤𑀫𑁆𑀩𑀬𑁄 [𑀓𑀲𑁆𑀲 𑀓𑀸𑀤𑀫𑁆𑀩𑀫𑀬𑁄 (𑀓.)] 𑀓𑀸𑀚𑁄, 𑀯𑁂𑀳𑀸𑀲𑀁 𑀘𑀢𑀼𑀭𑀗𑁆𑀕𑀼𑀮𑀁;

𑀅𑀁𑀲𑀁 𑀅𑀲𑀫𑁆𑀨𑀼𑀲𑀁 𑀏𑀢𑀺, 𑀉𑀤𑀳𑀸𑀭𑀸𑀬 [𑀉𑀤𑀳𑀸𑀭𑀲𑁆𑀲 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀕𑀘𑁆𑀙𑀢𑁄’’.

𑁧𑁦𑁮.

‘‘𑀅𑀳𑀁 𑀲𑁄𑀡𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀢𑀸𑀧𑀲𑁄 𑀲𑀳𑀺𑀢𑀩𑁆𑀩𑀢𑁄 [𑀲𑀳𑀺𑀢𑀁 𑀯𑀢𑁄 (𑀧𑀻.)];

𑀪𑀭𑀸𑀫𑀺 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀭𑁄, 𑀭𑀢𑁆𑀢𑀺𑀦𑁆𑀤𑀺𑀯𑀫𑀢𑀦𑁆𑀤𑀺𑀢𑁄.

𑁧𑁦𑁯.

‘‘𑀯𑀦𑁂 𑀨𑀮𑀜𑁆𑀘 𑀫𑀽𑀮𑀜𑁆𑀘, 𑀆𑀳𑀭𑀺𑀢𑁆𑀯𑀸 𑀤𑀺𑀲𑀫𑁆𑀧𑀢𑀺;

𑀧𑁄𑀲𑁂𑀫𑀺 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀭𑁄, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀓𑀢𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀁’’.

𑁧𑁧𑁦.

‘‘𑀇𑀘𑁆𑀙𑀸𑀫 ¶ 𑀅𑀲𑁆𑀲𑀫𑀁 𑀕𑀦𑁆𑀢𑀼𑀁, 𑀬𑀢𑁆𑀣 𑀲𑀫𑁆𑀫𑀢𑀺 𑀓𑁄𑀲𑀺𑀬𑁄;

𑀫𑀕𑁆𑀕𑀁 𑀦𑁄 𑀲𑁄𑀡 𑀅𑀓𑁆𑀔𑀸𑀳𑀺, 𑀬𑁂𑀦 𑀕𑀘𑁆𑀙𑁂𑀫𑀼 [𑀕𑀘𑁆𑀙𑀸𑀫 (𑀲𑀻.)] 𑀅𑀲𑁆𑀲𑀫𑀁’’.

𑁧𑁧𑁧.

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

𑀓𑁄𑀯𑀺𑀴𑀸𑀭𑁂𑀳𑀺 𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀁, 𑀏𑀢𑁆𑀣 𑀲𑀫𑁆𑀫𑀢𑀺 𑀓𑁄𑀲𑀺𑀬𑁄’’.

𑁧𑁧𑁨.

‘‘𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀧𑀓𑁆𑀓𑀸𑀫𑀺, 𑀢𑀭𑀫𑀸𑀦𑁄 𑀫𑀳𑀸𑀇𑀲𑀺;

𑀯𑁂𑀳𑀸𑀲𑁂 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑀲𑁆𑀫𑀺𑀁, 𑀅𑀦𑀼𑀲𑀸𑀲𑀺𑀢𑁆𑀯𑀸𑀦 𑀔𑀢𑁆𑀢𑀺𑀬𑁂.

𑁧𑁧𑁩.

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

𑀧𑀡𑁆𑀡𑀲𑀸𑀮𑀁 𑀧𑀯𑀺𑀲𑀺𑀢𑁆𑀯𑀸, 𑀧𑀺𑀢𑀭𑀁 𑀧𑀝𑀺𑀩𑁄𑀥𑀬𑀺.

𑁧𑁧𑁪.

‘‘𑀇𑀫𑁂 𑀆𑀬𑀦𑁆𑀢𑀺 𑀭𑀸𑀚𑀸𑀦𑁄, 𑀅𑀪𑀺𑀚𑀸𑀢𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄;

𑀅𑀲𑁆𑀲𑀫𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑀺𑀢𑁆𑀯𑀸𑀦, 𑀦𑀺𑀲𑀻𑀤 𑀢𑁆𑀯𑀁 [𑀦𑀺𑀲𑀻𑀤𑀸𑀳𑀺 (𑀲𑀻.)] 𑀫𑀳𑀸𑀇𑀲𑁂.

𑁧𑁧𑁫.

‘‘𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀢𑀭𑀫𑀸𑀦𑁄 𑀫𑀳𑀸𑀇𑀲𑀺;

𑀅𑀲𑁆𑀲𑀫𑀸 ¶ 𑀦𑀺𑀓𑁆𑀔𑀫𑀺𑀢𑁆𑀯𑀸𑀦, 𑀲𑀤𑁆𑀯𑀸𑀭𑀫𑁆𑀳𑀺 𑀉𑀧𑀸𑀯𑀺𑀲𑀺’’.

𑁧𑁧𑁬.

‘‘𑀢𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀆𑀬𑀦𑁆𑀢𑀁, 𑀚𑀮𑀦𑁆𑀢𑀁𑀭𑀺𑀯 𑀢𑁂𑀚𑀲𑀸;

𑀔𑀢𑁆𑀬𑀲𑀗𑁆𑀖𑀧𑀭𑀺𑀩𑁆𑀬𑀽𑀴𑁆𑀳𑀁, 𑀓𑁄𑀲𑀺𑀬𑁄 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺.

𑁧𑁧𑁭.

‘‘𑀓𑀲𑁆𑀲 𑀪𑁂𑀭𑀻 𑀫𑀼𑀤𑀺𑀗𑁆𑀕𑀸 𑀘 [𑀫𑀼𑀢𑀺𑀗𑁆𑀕𑀸 𑀘 (𑀧𑀻.)], 𑀲𑀗𑁆𑀔𑀸 𑀧𑀡𑀯𑀤𑀺𑀦𑁆𑀤𑀺𑀫𑀸 [𑀤𑁂𑀡𑁆𑀟𑀺𑀫𑀸 (𑀲𑀻. 𑀧𑀻.)];

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

𑁧𑁧𑁮.

‘‘𑀓𑀲𑁆𑀲 𑀓𑀜𑁆𑀘𑀦𑀧𑀝𑁆𑀝𑁂𑀦, 𑀧𑀼𑀣𑀼𑀦𑀸 𑀯𑀺𑀚𑁆𑀚𑀼𑀯𑀡𑁆𑀡𑀺𑀦𑀸;

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

𑁧𑁧𑁯.

‘‘𑀉𑀓𑁆𑀓𑀸𑀫𑀼𑀔𑀧𑀳𑀝𑁆𑀞𑀁𑀯, 𑀔𑀤𑀺𑀭𑀗𑁆𑀕𑀸𑀭𑀲𑀦𑁆𑀦𑀺𑀪𑀁;

𑀫𑀼𑀔𑀜𑁆𑀘 𑀭𑀼𑀘𑀺𑀭𑀸 𑀪𑀸𑀢𑀺, 𑀓𑁄 𑀏𑀢𑀺 𑀲𑀺𑀭𑀺𑀬𑀸 𑀚𑀮𑀁.

𑁧𑁨𑁦.

‘‘𑀓𑀲𑁆𑀲 𑀧𑀕𑁆𑀕𑀳𑀺𑀢𑀁 𑀙𑀢𑁆𑀢𑀁, 𑀲𑀲𑀮𑀸𑀓𑀁 𑀫𑀦𑁄𑀭𑀫𑀁;

𑀆𑀤𑀺𑀘𑁆𑀘𑀭𑀁𑀲𑀸𑀯𑀭𑀡𑀁, 𑀓𑁄 𑀏𑀢𑀺 𑀲𑀺𑀭𑀺𑀬𑀸 𑀚𑀮𑀁.

𑁧𑁨𑁧.

‘‘𑀓𑀲𑁆𑀲 𑀅𑀗𑁆𑀕𑀁 𑀧𑀭𑀺𑀕𑁆𑀕𑀬𑁆𑀳, 𑀯𑀸𑀴𑀩𑀻𑀚𑀦𑀺𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀘𑀭𑀦𑁆𑀢𑀺 𑀯𑀭𑀧𑀼𑀜𑁆𑀜𑀲𑁆𑀲 [𑀯𑀭𑀧𑀜𑁆𑀜𑀲𑁆𑀲 (𑀲𑀻. 𑀧𑀻.)], 𑀳𑀢𑁆𑀣𑀺𑀓𑁆𑀔𑀦𑁆𑀥𑁂𑀦 𑀆𑀬𑀢𑁄.

𑁧𑁨𑁨.

‘‘𑀓𑀲𑁆𑀲 𑀲𑁂𑀢𑀸𑀦𑀺 𑀙𑀢𑁆𑀢𑀸𑀦𑀺, 𑀆𑀚𑀸𑀦𑀻𑀬𑀸 𑀘 𑀯𑀫𑁆𑀫𑀺𑀢𑀸;

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

𑁧𑁨𑁩.

‘‘𑀓𑀲𑁆𑀲 ¶ 𑀏𑀓𑀲𑀢𑀁 𑀔𑀢𑁆𑀬𑀸, 𑀅𑀦𑀼𑀬𑀦𑁆𑀢𑀸 [𑀅𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑀸 (𑀧𑀻.)] 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄;

𑀲𑀫𑀦𑁆𑀢𑀸𑀦𑀼𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀺, 𑀓𑁄 𑀏𑀢𑀺 𑀲𑀺𑀭𑀺𑀬𑀸 𑀚𑀮𑀁.

𑁧𑁨𑁪.

‘‘𑀳𑀢𑁆𑀣𑀺 𑀅𑀲𑁆𑀲𑀭𑀣 𑀧𑀢𑁆𑀢𑀺 [𑀳𑀢𑁆𑀣𑀻 𑀅𑀲𑁆𑀲𑀸 𑀭𑀣𑀸 𑀧𑀢𑁆𑀢𑀻 (𑀲𑀻.)], 𑀲𑁂𑀦𑀸 𑀘 𑀘𑀢𑀼𑀭𑀗𑁆𑀕𑀺𑀦𑀻;

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

𑁧𑁨𑁫.

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

𑀅𑀓𑁆𑀔𑁄𑀪𑀡𑀻 ¶ [𑀅𑀓𑁆𑀔𑀸𑀪𑀦𑀻 (𑀲𑀻.), 𑀅𑀓𑁆𑀔𑁄𑀪𑀺𑀦𑀻 (𑀲𑁆𑀬𑀸.)] 𑀅𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀸, 𑀲𑀸𑀕𑀭𑀲𑁆𑀲𑁂𑀯 𑀊𑀫𑀺𑀬𑁄’’.

𑁧𑁨𑁬.

‘‘𑀭𑀸𑀚𑀸𑀪𑀺𑀭𑀸𑀚𑀸 [𑀭𑀸𑀚𑀸𑀥𑀺𑀭𑀸𑀚𑀸 (𑀓.)] 𑀫𑀦𑁄𑀚𑁄, 𑀇𑀦𑁆𑀤𑁄𑀯 𑀚𑀬𑀢𑀁 𑀧𑀢𑀺;

𑀦𑀦𑁆𑀤𑀲𑁆𑀲𑀚𑁆𑀛𑀸𑀯𑀭𑀁 𑀏𑀢𑀺, 𑀅𑀲𑁆𑀲𑀫𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺𑀦𑀁.

𑁧𑁨𑁭.

‘‘𑀢𑀲𑁆𑀲𑁂𑀲𑀸 𑀫𑀳𑀢𑀻 𑀲𑁂𑀦𑀸, 𑀧𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀅𑀦𑀼𑀯𑀢𑁆𑀢𑀢𑀺;

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

𑁧𑁨𑁮.

‘‘𑀅𑀦𑀼𑀮𑀺𑀢𑁆𑀢𑀸 𑀘𑀦𑁆𑀤𑀦𑁂𑀦, 𑀓𑀸𑀲𑀺𑀓𑀼𑀢𑁆𑀢𑀫𑀥𑀸𑀭𑀺𑀦𑁄 [𑀓𑀸𑀲𑀺𑀓𑀯𑀢𑁆𑀣𑀥𑀸𑀭𑀺𑀦𑁄 (𑀧𑀻.)];

𑀲𑀩𑁆𑀩𑁂 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸 𑀳𑀼𑀢𑁆𑀯𑀸, 𑀇𑀲𑀻𑀦𑀁 𑀅𑀚𑁆𑀛𑀼𑀧𑀸𑀕𑀫𑀼𑀁’’.

𑁧𑁨𑁯.

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

𑀓𑀘𑁆𑀘𑀺 𑀉𑀜𑁆𑀙𑁂𑀦 𑀬𑀸𑀧𑁂𑀣, 𑀓𑀘𑁆𑀘𑀺 𑀫𑀽𑀮𑀨𑀮𑀸 𑀩𑀳𑀽.

𑁧𑁩𑁦.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀟𑀁𑀲𑀸 𑀫𑀓𑀲𑀸 𑀘, 𑀅𑀧𑁆𑀧𑀫𑁂𑀯 𑀲𑀭𑀻𑀲𑀧𑀸 [𑀲𑀺𑀭𑀺𑀁𑀲𑀧𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀯𑀦𑁂 𑀯𑀸𑀴𑀫𑀺𑀕𑀸𑀓𑀺𑀡𑁆𑀡𑁂, 𑀓𑀘𑁆𑀘𑀺 𑀳𑀺𑀁𑀲𑀸 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺’’.

𑁧𑁩𑁧.

‘‘𑀓𑀼𑀲𑀮𑀜𑁆𑀘𑁂𑀯 𑀦𑁄 𑀭𑀸𑀚, 𑀅𑀣𑁄 𑀭𑀸𑀚 𑀅𑀦𑀸𑀫𑀬𑀁;

𑀅𑀣𑁄 𑀉𑀜𑁆𑀙𑁂𑀦 𑀬𑀸𑀧𑁂𑀫, 𑀅𑀣𑁄 𑀫𑀽𑀮𑀨𑀮𑀸 𑀩𑀳𑀽.

𑁧𑁩𑁨.

‘‘𑀅𑀣𑁄 𑀟𑀁𑀲𑀸 𑀫𑀓𑀲𑀸 𑀘 [𑀟𑀁𑀲𑀸 𑀘 𑀫𑀓𑀲𑀸 (𑀲𑀻.), 𑀟𑀁𑀲𑀸 𑀘 𑀫𑀓𑀲𑀸 𑀘 (𑀧𑀻.)], 𑀅𑀧𑁆𑀧𑀫𑁂𑀯 𑀲𑀭𑀻𑀲𑀧𑀸 [𑀲𑀺𑀭𑀺𑀁𑀲𑀧𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀯𑀦𑁂 𑀯𑀸𑀴𑀫𑀺𑀕𑀸𑀓𑀺𑀡𑁆𑀡𑁂, 𑀳𑀺𑀁𑀲𑀸 𑀫𑀬𑁆𑀳𑀁 [𑀅 𑀫𑁆𑀳𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺.

𑁧𑁩𑁩.

‘‘𑀩𑀳𑀽𑀦𑀺 𑀯𑀲𑁆𑀲𑀧𑀽𑀕𑀸𑀦𑀺, 𑀅𑀲𑁆𑀲𑀫𑁂 𑀲𑀫𑁆𑀫𑀢𑀁 [𑀯𑀲𑀢𑁄 (𑀲𑀻.)] 𑀇𑀥;

𑀦𑀸𑀪𑀺𑀚𑀸𑀦𑀸𑀫𑀺 𑀉𑀧𑁆𑀧𑀦𑁆𑀦𑀁, 𑀆𑀩𑀸𑀥𑀁 𑀅𑀫𑀦𑁄𑀭𑀫𑀁.

𑁧𑁩𑁪.

‘‘𑀲𑁆𑀯𑀸𑀕𑀢𑀁 𑀢𑁂 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀅𑀣𑁄 𑀢𑁂 𑀅𑀤𑀼𑀭𑀸𑀕𑀢𑀁;

𑀇𑀲𑁆𑀲𑀭𑁄𑀲𑀺 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁄, 𑀬𑀁 𑀇𑀥𑀢𑁆𑀣𑀺 𑀧𑀯𑁂𑀤𑀬.

𑁧𑁩𑁫.

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

𑀨𑀮𑀸𑀦𑀺 ¶ 𑀔𑀼𑀤𑁆𑀤𑀓𑀧𑁆𑀧𑀸𑀦𑀺, 𑀪𑀼𑀜𑁆𑀚 𑀭𑀸𑀚 𑀯𑀭𑀁 𑀯𑀭𑀁.

𑁧𑁩𑁬.

‘‘𑀇𑀤𑀫𑁆𑀧𑀺 𑀧𑀸𑀦𑀻𑀬𑀁 𑀲𑀻𑀢𑀁, 𑀆𑀪𑀢𑀁 𑀕𑀺𑀭𑀺𑀕𑀩𑁆𑀪𑀭𑀸;

𑀢𑀢𑁄 𑀧𑀺𑀯 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀲𑀘𑁂 𑀢𑁆𑀯𑀁 𑀅𑀪𑀺𑀓𑀗𑁆𑀔𑀲𑀺’’.

𑁧𑁩𑁭.

‘‘𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑀺𑀢𑀁 𑀬𑀁 𑀤𑀺𑀦𑁆𑀦𑀁, 𑀲𑀩𑁆𑀩𑀲𑁆𑀲 𑀅𑀕𑁆𑀖𑀺𑀬𑀁 𑀓𑀢𑀁;

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

𑁧𑁩𑁮.

‘‘𑀅𑀚𑁆𑀛𑀸𑀯𑀭𑀫𑁆𑀳𑀸 𑀦𑀦𑁆𑀤𑀲𑁆𑀲, 𑀪𑁄𑀢𑁄 𑀲𑀦𑁆𑀢𑀺𑀓𑀫𑀸𑀕𑀢𑀸;

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

𑁧𑁩𑁯.

‘‘𑀧𑀭𑁄𑀲𑀢𑀁 ¶ 𑀚𑀸𑀦𑀧𑀤𑀸 [𑀚𑀦𑀧𑀤𑀸 (𑀧𑀻.)], 𑀫𑀳𑀸𑀲𑀸𑀮𑀸 𑀘 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸;

𑀇𑀫𑁂 𑀘 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀲𑀩𑁆𑀩𑁂, 𑀅𑀪𑀺𑀚𑀸𑀢𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄;

𑀪𑀯𑀜𑁆𑀘 𑀭𑀸𑀚𑀸 𑀫𑀦𑁄𑀚𑁄, 𑀅𑀦𑀼𑀫𑀜𑁆𑀜𑀦𑁆𑀢𑀼 𑀫𑁂 𑀯𑀘𑁄.

𑁧𑁪𑁦.

‘‘𑀬𑁂 𑀘 𑀲𑀦𑁆𑀢𑀺 [𑀬𑁂 𑀯𑀲𑀦𑁆𑀢𑀺 (𑀲𑀻.), 𑀬𑁂 𑀳𑀺 𑀲𑀦𑁆𑀢𑀺 (𑀧𑀻.)] 𑀲𑀫𑀻𑀢𑀸𑀭𑁄, 𑀬𑀓𑁆𑀔𑀸𑀦𑀺 𑀇𑀥 𑀫𑀲𑁆𑀲𑀫𑁂;

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

𑁧𑁪𑁧.

‘‘𑀦𑀫𑁄 𑀓𑀢𑁆𑀯𑀸𑀦 𑀪𑀽𑀢𑀸𑀦𑀁, 𑀇𑀲𑀺𑀁 𑀯𑀓𑁆𑀔𑀸𑀫𑀺 𑀲𑀼𑀩𑁆𑀩𑀢𑀁;

𑀲𑁄 𑀢𑁆𑀬𑀸𑀳𑀁 𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀩𑀸𑀳𑀼, 𑀢𑀯 𑀓𑁄𑀲𑀺𑀬 𑀲𑀫𑁆𑀫𑀢𑁄.

𑁧𑁪𑁨.

‘‘𑀧𑀺𑀢𑀭𑀁 𑀫𑁂 𑀚𑀦𑁂𑀢𑁆𑀢𑀺𑀜𑁆𑀘, 𑀪𑀢𑁆𑀢𑀼𑀓𑀸𑀫𑀲𑁆𑀲 𑀫𑁂 𑀲𑀢𑁄;

𑀯𑀻𑀭 𑀧𑀼𑀜𑁆𑀜𑀫𑀺𑀤𑀁 𑀞𑀸𑀦𑀁, 𑀫𑀸 𑀫𑀁 𑀓𑁄𑀲𑀺𑀬 𑀯𑀸𑀭𑀬.

𑁧𑁪𑁩.

‘‘𑀲𑀩𑁆𑀪𑀺 𑀳𑁂𑀢𑀁 𑀉𑀧𑀜𑁆𑀜𑀸𑀢𑀁, 𑀫𑀫𑁂𑀢𑀁 𑀉𑀧𑀦𑀺𑀲𑁆𑀲𑀚;

𑀉𑀝𑁆𑀞𑀸𑀦𑀧𑀸𑀭𑀺𑀘𑀭𑀺𑀬𑀸𑀬, 𑀤𑀻𑀖𑀭𑀢𑁆𑀢𑀁 𑀢𑀬𑀸 𑀓𑀢𑀁;

𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽𑀲𑀼 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺, 𑀫𑀫 𑀮𑁄𑀓𑀤𑀤𑁄 𑀪𑀯.

𑁧𑁪𑁪.

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

𑀫𑀕𑁆𑀕𑁄 ¶ 𑀲𑀕𑁆𑀕𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀬𑀣𑀸 𑀚𑀸𑀦𑀸𑀲𑀺 𑀢𑁆𑀯𑀁 𑀇𑀲𑁂.

𑁧𑁪𑁫.

‘‘𑀉𑀝𑁆𑀞𑀸𑀦𑀧𑀸𑀭𑀺𑀘𑀭𑀺𑀬𑀸𑀬, 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀼𑀲𑀼𑀔𑀸𑀯𑀳𑀁;

𑀢𑀁 𑀫𑀁 𑀧𑀼𑀜𑁆𑀜𑀸 𑀦𑀺𑀯𑀸𑀭𑁂𑀢𑀺, 𑀅𑀭𑀺𑀬𑀫𑀕𑁆𑀕𑀸𑀯𑀭𑁄 𑀦𑀭𑁄’’.

𑁧𑁪𑁬.

‘‘𑀲𑀼𑀡𑀦𑁆𑀢𑀼 ¶ 𑀪𑁄𑀦𑁆𑀢𑁄 𑀯𑀘𑀦𑀁, 𑀪𑀸𑀢𑀼𑀭𑀚𑁆𑀛𑀸𑀯𑀭𑀸 𑀫𑀫;

𑀓𑀼𑀮𑀯𑀁𑀲𑀁 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀧𑁄𑀭𑀸𑀡𑀁 𑀧𑀭𑀺𑀳𑀸𑀧𑀬𑀁;

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

𑁧𑁪𑁭.

‘‘𑀬𑁂 𑀘 𑀥𑀫𑁆𑀫𑀲𑁆𑀲 𑀓𑀼𑀲𑀮𑀸, 𑀧𑁄𑀭𑀸𑀡𑀲𑁆𑀲 𑀤𑀺𑀲𑀫𑁆𑀧𑀢𑀺;

𑀘𑀸𑀭𑀺𑀢𑁆𑀢𑁂𑀦 𑀘 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀦 𑀢𑁂 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

𑁧𑁪𑁮.

‘‘𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀸 𑀘 𑀪𑀸𑀢𑀸 𑀘, 𑀪𑀕𑀺𑀦𑀻 𑀜𑀸𑀢𑀺𑀩𑀦𑁆𑀥𑀯𑀸;

𑀲𑀩𑁆𑀩𑁂 𑀚𑁂𑀝𑁆𑀞𑀲𑁆𑀲 𑀢𑁂 𑀪𑀸𑀭𑀸, 𑀏𑀯𑀁 𑀚𑀸𑀦𑀸𑀳𑀺 𑀪𑀸𑀭𑀥 [𑀪𑀸𑀭𑀣 (𑀲𑁆𑀬𑀸.)].

𑁧𑁪𑁯.

‘‘𑀆𑀤𑀺𑀬𑀺𑀢𑁆𑀯𑀸 𑀕𑀭𑀼𑀁 𑀪𑀸𑀭𑀁, 𑀦𑀸𑀯𑀺𑀓𑁄 𑀯𑀺𑀬 𑀉𑀲𑁆𑀲𑀳𑁂;

𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀦𑀧𑁆𑀧𑀫𑀚𑁆𑀚𑀸𑀫𑀺, 𑀚𑁂𑀝𑁆𑀞𑁄 𑀘𑀲𑁆𑀫𑀺 𑀭𑀣𑁂𑀲𑀪’’.

𑁧𑁫𑁦.

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

𑀏𑀯𑀫𑁂𑀯 𑀦𑁄 𑀪𑀯𑀁 𑀥𑀫𑁆𑀫𑀁, 𑀓𑁄𑀲𑀺𑀬𑁄 𑀧𑀯𑀺𑀤𑀁𑀲𑀬𑀺.

𑁧𑁫𑁧.

‘‘𑀬𑀣𑀸 𑀉𑀤𑀬𑀫𑀸𑀤𑀺𑀘𑁆𑀘𑁄, 𑀯𑀸𑀲𑀼𑀤𑁂𑀯𑁄 𑀧𑀪𑀗𑁆𑀓𑀭𑁄;

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

𑀏𑀯𑀫𑁂𑀯 𑀦𑁄 𑀪𑀯𑀁 𑀥𑀫𑁆𑀫𑀁, 𑀓𑁄𑀲𑀺𑀬𑁄 𑀧𑀯𑀺𑀤𑀁𑀲𑀬𑀺’’.

𑁧𑁫𑁨.

‘‘𑀏𑀯𑀁 ¶ 𑀫𑁂 𑀬𑀸𑀘𑀫𑀸𑀦𑀲𑁆𑀲, 𑀅𑀜𑁆𑀚𑀮𑀺𑀁 𑀦𑀸𑀯𑀩𑀼𑀚𑁆𑀛𑀣;

𑀢𑀯 𑀧𑀤𑁆𑀥𑀘𑀭𑁄 [𑀢𑀯 𑀧𑀝𑁆𑀞𑀘𑀭𑁄 (𑀲𑁆𑀬𑀸.), 𑀢𑀯 𑀩𑀤𑁆𑀥𑀜𑁆𑀘𑀭𑁄 (𑀧𑀻.), 𑀢𑀯𑀼𑀧𑀝𑁆𑀞𑀘𑀭𑁄 (𑀓.)] 𑀳𑁂𑀲𑁆𑀲𑀁, 𑀯𑀼𑀝𑁆𑀞𑀺𑀢𑁄 𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑁄’’.

𑁧𑁫𑁩.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀦𑀦𑁆𑀤 𑀯𑀺𑀚𑀸𑀦𑀸𑀲𑀺 [𑀧𑀚𑀸𑀦𑀸𑀲𑀺 (𑀲𑀻.)], 𑀲𑀤𑁆𑀥𑀫𑁆𑀫𑀁 𑀲𑀩𑁆𑀪𑀺 𑀤𑁂𑀲𑀺𑀢𑀁;

𑀅𑀭𑀺𑀬𑁄 ¶ 𑀅𑀭𑀺𑀬𑀲𑀫𑀸𑀘𑀸𑀭𑁄, 𑀩𑀸𑀴𑁆𑀳𑀁 𑀢𑁆𑀯𑀁 𑀫𑀫 𑀭𑀼𑀘𑁆𑀘𑀲𑀺.

𑁧𑁫𑁪.

‘‘𑀪𑀯𑀦𑁆𑀢𑀁 𑀯𑀤𑀸𑀫𑀺 𑀪𑁄𑀢𑀺𑀜𑁆𑀘, 𑀲𑀼𑀡𑀸𑀣 𑀯𑀘𑀦𑀁 𑀫𑀫;

𑀦𑀸𑀬𑀁 𑀪𑀸𑀭𑁄 𑀪𑀸𑀭𑀫𑀢𑁄 [𑀪𑀸𑀭𑀫𑀢𑁆𑀢𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀅𑀳𑀼 𑀫𑀬𑁆𑀳𑀁 𑀓𑀼𑀤𑀸𑀘𑀦𑀁.

𑁧𑁫𑁫.

‘‘𑀢𑀁 𑀫𑀁 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀁 𑀲𑀦𑁆𑀢𑀁, 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀼𑀲𑀼𑀔𑀸𑀯𑀳𑀁;

𑀦𑀦𑁆𑀤𑁄 𑀅𑀚𑁆𑀛𑀸𑀯𑀭𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀉𑀧𑀝𑁆𑀞𑀸𑀦𑀸𑀬 𑀬𑀸𑀘𑀢𑀺.

𑁧𑁫𑁬.

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

𑀦𑀦𑁆𑀤𑀁 𑀯𑁄 𑀯𑀭𑀣 𑀏𑀓𑁄 [𑀦𑀦𑁆𑀤𑀁 𑀯𑀤𑀣 𑀏𑀓𑁂 (𑀧𑀻.)], 𑀓𑀁 𑀦𑀦𑁆𑀤𑁄 𑀉𑀧𑀢𑀺𑀝𑁆𑀞𑀢𑀼’’.

𑁧𑁫𑁭.

‘‘𑀢𑀬𑀸 ¶ 𑀢𑀸𑀢 𑀅𑀦𑀼𑀜𑁆𑀜𑀸𑀢𑀸, 𑀲𑁄𑀡 𑀢𑀁 𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸 𑀫𑀬𑀁;

𑀉𑀧𑀖𑀸𑀢𑀼𑀁 [𑀉𑀧𑀖𑀸𑀬𑀺𑀢𑀼𑀁 (𑀲𑀻.)] 𑀮𑀪𑁂 𑀦𑀦𑁆𑀤𑀁, 𑀫𑀼𑀤𑁆𑀥𑀦𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀺𑀦𑀁’’.

𑁧𑁫𑁮.

‘‘𑀅𑀲𑁆𑀲𑀢𑁆𑀣𑀲𑁆𑀲𑁂𑀯 𑀢𑀭𑀼𑀡𑀁, 𑀧𑀯𑀸𑀴𑀁 𑀫𑀸𑀮𑀼𑀢𑁂𑀭𑀺𑀢𑀁;

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

𑁧𑁫𑁯.

‘‘𑀬𑀤𑀸 𑀲𑀼𑀢𑁆𑀢𑀸𑀧𑀺 𑀲𑀼𑀧𑀺𑀦𑁂 [𑀲𑀼𑀧𑁆𑀧𑀦𑁆𑀢𑁂 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀦𑀦𑁆𑀤𑀁 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀆𑀕𑀢𑀁;

𑀉𑀤𑀕𑁆𑀕𑀸 𑀲𑀼𑀫𑀦𑀸 𑀳𑁄𑀫𑀺, 𑀦𑀦𑁆𑀤𑁄 𑀦𑁄 𑀆𑀕𑀢𑁄 𑀅𑀬𑀁.

𑁧𑁬𑁦.

‘‘𑀬𑀤𑀸 𑀘 𑀧𑀝𑀺𑀩𑀼𑀚𑁆𑀛𑀺𑀢𑁆𑀯𑀸, 𑀦𑀦𑁆𑀤𑀁 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀦𑀸𑀕𑀢𑀁;

𑀪𑀺𑀬𑁆𑀬𑁄 𑀆𑀯𑀺𑀲𑀢𑀻 𑀲𑁄𑀓𑁄, 𑀤𑁄𑀫𑀦𑀲𑁆𑀲𑀜𑁆𑀘𑀦𑀧𑁆𑀧𑀓𑀁.

𑁧𑁬𑁧.

‘‘𑀲𑀸𑀳𑀁 𑀅𑀚𑁆𑀚 𑀘𑀺𑀭𑀲𑁆𑀲𑀫𑁆𑀧𑀺, 𑀦𑀦𑁆𑀤𑀁 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀆𑀕𑀢𑀁;

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

𑁧𑁬𑁨.

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

𑀮𑀪𑀢𑀽 𑀢𑀸𑀢 𑀦𑀦𑁆𑀤𑁄 𑀢𑀁, 𑀫𑀁 𑀦𑀦𑁆𑀤𑁄 𑀉𑀧𑀢𑀺𑀝𑁆𑀞𑀢𑀼’’.

𑁧𑁬𑁩.

‘‘𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀺𑀓𑀸 ¶ 𑀧𑀢𑀺𑀝𑁆𑀞𑀸 𑀘, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀭𑀲𑀤𑀤𑀻 𑀘 𑀦𑁄;

𑀫𑀕𑁆𑀕𑁄 𑀲𑀕𑁆𑀕𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀫𑀸𑀢𑀸 𑀢𑀁 𑀯𑀭𑀢𑁂 𑀇𑀲𑁂.

𑁧𑁬𑁪.

‘‘𑀧𑀼𑀩𑁆𑀩𑁂 𑀭𑀲𑀤𑀤𑀻 𑀕𑁄𑀢𑁆𑀢𑀻, 𑀫𑀸𑀢𑀸 𑀧𑀼𑀜𑁆𑀜𑀽𑀧𑀲𑀁𑀳𑀺𑀢𑀸;

𑀫𑀕𑁆𑀕𑁄 𑀲𑀕𑁆𑀕𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀫𑀸𑀢𑀸 𑀢𑀁 𑀯𑀭𑀢𑁂 𑀇𑀲𑁂’’.

𑁧𑁬𑁫.

‘‘𑀆𑀓𑀗𑁆𑀔𑀫𑀸𑀦𑀸 𑀧𑀼𑀢𑁆𑀢𑀨𑀮𑀁, 𑀤𑁂𑀯𑀢𑀸𑀬 𑀦𑀫𑀲𑁆𑀲𑀢𑀺;

𑀦𑀓𑁆𑀔𑀢𑁆𑀢𑀸𑀦𑀺 𑀘 𑀧𑀼𑀘𑁆𑀙𑀢𑀺, 𑀉𑀢𑀼𑀲𑀁𑀯𑀘𑁆𑀙𑀭𑀸𑀦𑀺 𑀘.

𑁧𑁬𑁬.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀉𑀢𑀼𑀫𑁆𑀳𑀺 𑀦𑁆𑀳𑀸𑀢𑀸𑀬 [𑀉𑀢𑀼𑀲𑀺𑀦𑀸𑀢𑀸𑀬 (𑀧𑀻.)], 𑀳𑁄𑀢𑀺 𑀕𑀩𑁆𑀪𑀲𑁆𑀲 𑀯𑁄𑀓𑁆𑀓𑀫𑁄 [𑀕𑀩𑁆𑀪𑀲𑁆𑀲’𑀯𑀓𑁆𑀓𑀫𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀢𑁂𑀦 𑀤𑁄𑀳𑀴𑀺𑀦𑀻 𑀳𑁄𑀢𑀺, 𑀲𑀼𑀳𑀤𑀸 𑀢𑁂𑀦 𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

𑁧𑁬𑁭.

‘‘𑀲𑀁𑀯𑀘𑁆𑀙𑀭𑀁 ¶ 𑀯𑀸 𑀊𑀦𑀁 𑀯𑀸, 𑀧𑀭𑀺𑀳𑀭𑀺𑀢𑁆𑀯𑀸 𑀯𑀺𑀚𑀸𑀬𑀢𑀺;

𑀢𑁂𑀦 𑀲𑀸 𑀚𑀦𑀬𑀦𑁆𑀢𑀻𑀢𑀺, 𑀚𑀦𑁂𑀢𑁆𑀢𑀺 [𑀚𑀦𑁂𑀢𑁆𑀢𑀻 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀢𑁂𑀦 𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

𑁧𑁬𑁮.

‘‘𑀣𑀦𑀔𑀻𑀭𑁂𑀦 [𑀣𑀦𑀓𑁆𑀔𑀻𑀭𑁂𑀦 (𑀲𑀻.)] 𑀕𑀻𑀢𑁂𑀦, 𑀅𑀗𑁆𑀕𑀧𑀸𑀯𑀼𑀭𑀡𑁂𑀦 [𑀅𑀗𑁆𑀕𑀧𑀸𑀧𑀼𑀭𑀡𑁂𑀦 (𑀧𑀻.)] 𑀘;

𑀭𑁄𑀤𑀦𑁆𑀢𑀁 𑀧𑀼𑀢𑁆𑀢𑀁 [𑀏𑀯 (𑀧𑀻.)] 𑀢𑁄𑀲𑁂𑀢𑀺, 𑀢𑁄𑀲𑁂𑀦𑁆𑀢𑀻 𑀢𑁂𑀦 𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

𑁧𑁬𑁯.

‘‘𑀢𑀢𑁄 ¶ 𑀯𑀸𑀢𑀸𑀢𑀧𑁂 𑀖𑁄𑀭𑁂, 𑀫𑀫𑀁 𑀓𑀢𑁆𑀯𑀸 𑀉𑀤𑀺𑀓𑁆𑀔𑀢𑀺;

𑀤𑀸𑀭𑀓𑀁 𑀅𑀧𑁆𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀁, 𑀧𑁄𑀲𑁂𑀦𑁆𑀢𑀻 𑀢𑁂𑀦 𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

𑁧𑁭𑁦.

‘‘𑀬𑀜𑁆𑀘 𑀫𑀸𑀢𑀼𑀥𑀦𑀁 𑀳𑁄𑀢𑀺, 𑀬𑀜𑁆𑀘 𑀳𑁄𑀢𑀺 𑀧𑀺𑀢𑀼𑀤𑁆𑀥𑀦𑀁;

𑀉𑀪𑀬𑀫𑁆𑀧𑁂𑀢𑀲𑁆𑀲 𑀕𑁄𑀧𑁂𑀢𑀺, 𑀅𑀧𑀺 𑀧𑀼𑀢𑁆𑀢𑀲𑁆𑀲 𑀦𑁄 𑀲𑀺𑀬𑀸.

𑁧𑁭𑁧.

‘‘𑀏𑀯𑀁 𑀧𑀼𑀢𑁆𑀢 𑀅𑀤𑀼𑀁 𑀧𑀼𑀢𑁆𑀢, 𑀇𑀢𑀺 𑀫𑀸𑀢𑀸 𑀯𑀺𑀳𑀜𑁆𑀜𑀢𑀺;

𑀧𑀫𑀢𑁆𑀢𑀁 𑀧𑀭𑀤𑀸𑀭𑁂𑀲𑀼, 𑀦𑀺𑀲𑀻𑀣𑁂 𑀧𑀢𑁆𑀢𑀬𑁄𑀩𑁆𑀩𑀦𑁂;

𑀲𑀸𑀬𑀁 𑀧𑀼𑀢𑁆𑀢𑀁 𑀅𑀦𑀸𑀬𑀦𑁆𑀢𑀁, 𑀇𑀢𑀺 𑀫𑀸𑀢𑀸 𑀯𑀺𑀳𑀜𑁆𑀜𑀢𑀺.

𑁧𑁭𑁨.

‘‘𑀏𑀯𑀁 𑀓𑀺𑀘𑁆𑀙𑀸 𑀪𑀢𑁄 𑀧𑁄𑀲𑁄, 𑀫𑀸𑀢𑀼 𑀅𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑁄;

𑀫𑀸𑀢𑀭𑀺 𑀫𑀺𑀘𑁆𑀙𑀸 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀦𑀺𑀭𑀬𑀁 𑀲𑁄𑀧𑀧𑀚𑁆𑀚𑀢𑀺.

𑁧𑁭𑁩.

‘‘𑀏𑀯𑀁 ¶ 𑀓𑀺𑀘𑁆𑀙𑀸 𑀪𑀢𑁄 𑀧𑁄𑀲𑁄, 𑀧𑀺𑀢𑀼 𑀅𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑁄;

𑀧𑀺𑀢𑀭𑀺 𑀫𑀺𑀘𑁆𑀙𑀸 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀦𑀺𑀭𑀬𑀁 𑀲𑁄𑀧𑀧𑀚𑁆𑀚𑀢𑀺.

𑁧𑁭𑁪.

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

𑀫𑀸𑀢𑀭𑀁 𑀅𑀧𑀭𑀺𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀓𑀺𑀘𑁆𑀙𑀁 𑀯𑀸 𑀲𑁄 𑀦𑀺𑀕𑀘𑁆𑀙𑀢𑀺.

𑁧𑁭𑁫.

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

𑀧𑀺𑀢𑀭𑀁 𑀅𑀧𑀭𑀺𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀓𑀺𑀘𑁆𑀙𑀁 𑀯𑀸 𑀲𑁄 𑀦𑀺𑀕𑀘𑁆𑀙𑀢𑀺.

𑁧𑁭𑁬.

‘‘𑀆𑀦𑀦𑁆𑀤𑁄 𑀘 𑀧𑀫𑁄𑀤𑁄 𑀘, 𑀲𑀤𑀸 𑀳𑀲𑀺𑀢𑀓𑀻𑀴𑀺𑀢𑀁;

𑀫𑀸𑀢𑀭𑀁 𑀧𑀭𑀺𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀮𑀩𑁆𑀪𑀫𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀢𑁄.

𑁧𑁭𑁭.

‘‘𑀆𑀦𑀦𑁆𑀤𑁄 𑀘 𑀧𑀫𑁄𑀤𑁄 𑀘, 𑀲𑀤𑀸 𑀳𑀲𑀺𑀢𑀓𑀻𑀴𑀺𑀢𑀁;

𑀧𑀺𑀢𑀭𑀁 𑀧𑀭𑀺𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀮𑀩𑁆𑀪𑀫𑁂𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀢𑁄.

𑁧𑁭𑁮.

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

𑀲𑀫𑀸𑀦𑀢𑁆𑀢𑀢𑀸 [𑀲𑀫𑀸𑀦𑀢𑁆𑀢𑀸 (𑀧𑀻.)] 𑀘 𑀥𑀫𑁆𑀫𑁂𑀲𑀼, 𑀢𑀢𑁆𑀣 𑀢𑀢𑁆𑀣 𑀬𑀣𑀸𑀭𑀳𑀁;

𑀏𑀢𑁂 𑀔𑁄 𑀲𑀗𑁆𑀕𑀳𑀸 𑀮𑁄𑀓𑁂, 𑀭𑀣𑀲𑁆𑀲𑀸𑀡𑀻𑀯 𑀬𑀸𑀬𑀢𑁄.

𑁧𑁭𑁯.

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

𑀮𑀪𑁂𑀣 𑀫𑀸𑀦𑀁 𑀧𑀽𑀚𑀁 𑀯𑀸 [𑀧𑀽𑀚𑀜𑁆𑀘 (𑀧𑀻.)], 𑀧𑀺𑀢𑀸 𑀯𑀸 𑀧𑀼𑀢𑁆𑀢𑀓𑀸𑀭𑀡𑀸.

𑁧𑁮𑁦.

‘‘𑀬𑀲𑁆𑀫𑀸 𑀘 𑀲𑀗𑁆𑀕𑀳𑀸 [𑀲𑀗𑁆𑀕𑀳𑁂 (𑀤𑀻. 𑀦𑀺. 𑁩.𑁨𑁭𑁩; 𑀅. 𑀦𑀺. 𑁪.𑁩𑁨) 𑀢𑀤𑀝𑁆𑀞𑀓𑀣𑀸𑀬𑁄 𑀑𑀮𑁄𑀓𑁂𑀢𑀩𑁆𑀩𑀸] 𑀏𑀢𑁂, 𑀲𑀫𑁆𑀫𑀧𑁂𑀓𑁆𑀔𑀦𑁆𑀢𑀺 [𑀲𑀫𑀯𑁂𑀓𑁆𑀔𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.) 𑀅. 𑀦𑀺. 𑁪.𑁩𑁨] 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

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

𑁧𑁮𑁧.

‘‘𑀩𑁆𑀭𑀳𑁆𑀫𑀸𑀢𑀺 ¶ ¶ [𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀳𑀺 (𑀧𑀻.)] 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀭𑁄, 𑀧𑀼𑀩𑁆𑀩𑀸𑀘𑀭𑀺𑀬𑀸𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀭𑁂;

𑀆𑀳𑀼𑀦𑁂𑀬𑁆𑀬𑀸 ¶ 𑀘 𑀧𑀼𑀢𑁆𑀢𑀸𑀦𑀁, 𑀧𑀚𑀸𑀬 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀸.

𑁧𑁮𑁨.

‘‘𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀦𑁂 𑀦𑀫𑀲𑁆𑀲𑁂𑀬𑁆𑀬, 𑀲𑀓𑁆𑀓𑀭𑁂𑀬𑁆𑀬 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑁄;

𑀅𑀦𑁆𑀦𑁂𑀦 𑀅𑀣𑁄 [𑀫𑀣𑁄 (𑀧𑀻.), 𑀅𑀣 (𑀅. 𑀦𑀺. 𑁪.𑁬𑁩; 𑀇𑀢𑀺𑀯𑀼. 𑁧𑁦𑁬)] 𑀧𑀸𑀦𑁂𑀦, 𑀯𑀢𑁆𑀣𑁂𑀦 𑀲𑀬𑀦𑁂𑀦 𑀘;

𑀉𑀘𑁆𑀙𑀸𑀤𑀦𑁂𑀦 𑀦𑁆𑀳𑀸𑀧𑀦𑁂𑀦 [𑀦𑀳𑀸𑀧𑀦𑁂𑀦 (𑀲𑀻. 𑀧𑀻.)], 𑀧𑀸𑀤𑀸𑀦𑀁 𑀥𑁄𑀯𑀦𑁂𑀦 𑀘.

𑁧𑁮𑁩.

‘‘𑀢𑀸𑀬 𑀦𑀁 𑀧𑀸𑀭𑀺𑀘𑀭𑀺𑀬𑀸𑀬 [𑀧𑀭𑀺𑀘𑀭𑀺𑀬𑀸𑀬 (𑀧𑀻.)], 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽𑀲𑀼 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

𑀇𑀥𑁂𑀯 𑀦𑀁 𑀧𑀲𑀁𑀲𑀦𑁆𑀢𑀺, 𑀧𑁂𑀘𑁆𑀘 𑀲𑀕𑁆𑀕𑁂 𑀧𑀫𑁄𑀤𑀢𑀻’’𑀢𑀺.

𑀲𑁄𑀡𑀦𑀦𑁆𑀤𑀚𑀸𑀢𑀓𑀁 𑀤𑀼𑀢𑀺𑀬𑀁.

𑀲𑀢𑁆𑀢𑀢𑀺𑀦𑀺𑀧𑀸𑀢𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀢𑀲𑁆𑀲𑀼𑀤𑁆𑀤𑀸𑀦𑀁 𑁋

𑀅𑀣 𑀲𑀢𑁆𑀢𑀢𑀺𑀫𑀫𑁆𑀳𑀺 𑀦𑀺𑀧𑀸𑀢𑀯𑀭𑁂, 𑀲𑀪𑀸𑀯𑀦𑁆𑀢𑀼 𑀓𑀼𑀲𑀸𑀯𑀢𑀺𑀭𑀸𑀚𑀯𑀭𑁄;

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

𑁨𑁧. 𑀅𑀲𑀻𑀢𑀺𑀦𑀺𑀧𑀸𑀢𑁄

𑁫𑁩𑁩. 𑀘𑀽𑀴𑀳𑀁𑀲𑀚𑀸𑀢𑀓𑀁 (𑁧)

𑁧.

‘‘𑀲𑀼𑀫𑀼𑀔 ¶ ¶ ¶ 𑀅𑀦𑀼𑀧𑀘𑀺𑀦𑀦𑁆𑀢𑀸, 𑀧𑀓𑁆𑀓𑀫𑀦𑁆𑀢𑀺 𑀯𑀺𑀳𑀗𑁆𑀕𑀫𑀸;

𑀕𑀘𑁆𑀙 𑀢𑀼𑀯𑀫𑁆𑀧𑀺 𑀫𑀸 𑀓𑀗𑁆𑀔𑀺, 𑀦𑀢𑁆𑀣𑀺 𑀩𑀤𑁆𑀥𑁂 [𑀩𑀦𑁆𑀥𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀲𑀳𑀸𑀬𑀢𑀸’’.

𑁨.

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

𑀲𑀼𑀔𑀺𑀢𑀁 𑀢𑀁 𑀉𑀧𑀸𑀲𑀺𑀢𑁆𑀯𑀸, 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑀁 𑀢𑀁 𑀓𑀣𑀁 𑀚𑀳𑁂.

𑁩.

‘‘𑀫𑀭𑀡𑀁 𑀯𑀸 𑀢𑀬𑀸 𑀲𑀤𑁆𑀥𑀺𑀁, 𑀚𑀻𑀯𑀺𑀢𑀁 𑀯𑀸 𑀢𑀬𑀸 𑀯𑀺𑀦𑀸;

𑀢𑀤𑁂𑀯 𑀫𑀭𑀡𑀁 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀬𑀜𑁆𑀘𑁂 𑀚𑀻𑀯𑁂 𑀢𑀬𑀸 𑀯𑀺𑀦𑀸.

𑁪.

‘‘𑀦𑁂𑀲 𑀥𑀫𑁆𑀫𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀬𑀁 𑀢𑀁 𑀏𑀯𑀁 𑀕𑀢𑀁 𑀚𑀳𑁂;

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

𑁫.

‘‘𑀓𑀸 𑀦𑀼 𑀧𑀸𑀲𑁂𑀦 𑀩𑀤𑁆𑀥𑀲𑁆𑀲 [𑀩𑀦𑁆𑀥𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀕𑀢𑀺 𑀅𑀜𑁆𑀜𑀸 𑀫𑀳𑀸𑀦𑀲𑀸;

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

𑁬.

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

𑀜𑀸𑀢𑀻𑀦𑀁 𑀯𑀸𑀯𑀲𑀺𑀝𑁆𑀞𑀸𑀦𑀁, 𑀉𑀪𑀺𑀦𑁆𑀦𑀁 𑀚𑀻𑀯𑀺𑀢𑀓𑁆𑀔𑀬𑁂.

𑁭.

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

𑀢𑀸𑀤𑀺𑀲𑁂 𑀲𑀜𑁆𑀘𑀚𑀁 𑀧𑀸𑀡𑀁, 𑀓𑀫𑀢𑁆𑀣𑀫𑀪𑀺𑀚𑁄𑀢𑀬𑁂’’.

𑁮.

‘‘𑀓𑀣𑀁 𑀦𑀼 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀥𑀫𑁆𑀫𑁂 𑀅𑀢𑁆𑀣𑀁 𑀦 𑀩𑀼𑀚𑁆𑀛𑀲𑀺 [𑀩𑀼𑀚𑁆𑀛𑀲𑁂 (𑀲𑀻.)];

𑀥𑀫𑁆𑀫𑁄 𑀅𑀧𑀘𑀺𑀢𑁄 𑀲𑀦𑁆𑀢𑁄, 𑀅𑀢𑁆𑀣𑀁 𑀤𑀲𑁆𑀲𑁂𑀢𑀺 𑀧𑀸𑀡𑀺𑀦𑀁.

𑁯.

‘‘𑀲𑁄𑀳𑀁 𑀥𑀫𑁆𑀫𑀁 𑀅𑀧𑁂𑀓𑁆𑀔𑀸𑀦𑁄, 𑀥𑀫𑁆𑀫𑀸 𑀘𑀢𑁆𑀣𑀁 𑀲𑀫𑀼𑀝𑁆𑀞𑀺𑀢𑀁;

𑀪𑀢𑁆𑀢𑀺𑀜𑁆𑀘 ¶ 𑀢𑀬𑀺 𑀲𑀫𑁆𑀧𑀲𑁆𑀲𑀁, 𑀦𑀸𑀯𑀓𑀗𑁆𑀔𑀸𑀫𑀺 𑀚𑀻𑀯𑀺𑀢𑀁’’.

𑁧𑁦.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀏𑀲𑁄 𑀲𑀢𑀁 𑀥𑀫𑁆𑀫𑁄, 𑀬𑁄 𑀫𑀺𑀢𑁆𑀢𑁄 𑀫𑀺𑀢𑁆𑀢𑀫𑀸𑀧𑀤𑁂;

𑀦 𑀘𑀚𑁂 𑀚𑀻𑀯𑀺𑀢𑀲𑁆𑀲𑀸𑀧𑀺, 𑀳𑁂𑀢𑀼𑀥𑀫𑁆𑀫𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀁.

𑁧𑁧.

‘‘𑀲𑁆𑀯𑀸𑀬𑀁 𑀥𑀫𑁆𑀫𑁄 𑀘 𑀢𑁂 𑀘𑀺𑀡𑁆𑀡𑁄, 𑀪𑀢𑁆𑀢𑀺 𑀘 𑀯𑀺𑀤𑀺𑀢𑀸 𑀫𑀬𑀺;

𑀓𑀸𑀫𑀁 𑀓𑀭𑀲𑁆𑀲𑀼 𑀫𑀬𑁆𑀳𑁂𑀢𑀁, 𑀕𑀘𑁆𑀙𑁂𑀯𑀸𑀦𑀼𑀫𑀢𑁄 𑀫𑀬𑀸’’.

𑁧𑁨.

‘‘𑀅𑀧𑀺 ¶ ¶ 𑀢𑁆𑀯𑁂𑀯𑀁 𑀕𑀢𑁂 𑀓𑀸𑀮𑁂, 𑀬𑀁 𑀔𑀡𑁆𑀟𑀁 [𑀩𑀤𑁆𑀥𑀁 (𑀲𑀻.), 𑀩𑀦𑁆𑀥𑀁 (𑀧𑀻.)] 𑀜𑀸𑀢𑀺𑀦𑀁 𑀫𑀬𑀸;

𑀢𑀬𑀸 𑀢𑀁 𑀩𑀼𑀤𑁆𑀥𑀺𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁 [𑀩𑀼𑀤𑁆𑀥𑀺𑀲𑀫𑁆𑀧𑀦𑁆𑀦 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀅𑀲𑁆𑀲 𑀧𑀭𑀫𑀲𑀁𑀯𑀼𑀢𑀁.

𑁧𑁩.

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

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

𑁧𑁪.

‘‘𑀢𑁂 𑀲𑀢𑁆𑀢𑀼𑀫𑀪𑀺𑀲𑀜𑁆𑀘𑀺𑀓𑁆𑀔, 𑀤𑀻𑀖𑀭𑀢𑁆𑀢𑀁 𑀳𑀺𑀢𑀸 𑀤𑀺𑀚𑀸;

𑀢𑀼𑀡𑁆𑀳𑀻𑀫𑀸𑀲𑀺𑀢𑁆𑀣 𑀉𑀪𑀬𑁄, 𑀦 𑀲𑀜𑁆𑀘𑀮𑁂𑀲𑀼𑀫𑀸𑀲𑀦𑀸 [𑀦 𑀘 𑀲𑀜𑁆𑀘𑁂𑀲𑀼’𑀫𑀸𑀲𑀦𑀸 (𑀲𑀻. 𑀧𑀻.)].

𑁧𑁫.

‘‘𑀥𑀢𑀭𑀝𑁆𑀞𑁂 𑀘 𑀤𑀺𑀲𑁆𑀯𑀸𑀦, 𑀲𑀫𑀼𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑁂 𑀢𑀢𑁄 𑀢𑀢𑁄;

𑀅𑀪𑀺𑀓𑁆𑀓𑀫𑀣 𑀯𑁂𑀕𑁂𑀦, 𑀤𑀺𑀚𑀲𑀢𑁆𑀢𑀼 𑀤𑀺𑀚𑀸𑀥𑀺𑀧𑁂.

𑁧𑁬.

‘‘𑀲𑁄 𑀘 𑀯𑁂𑀕𑁂𑀦𑀪𑀺𑀓𑁆𑀓𑀫𑁆𑀫, 𑀆𑀲𑀚𑁆𑀚 𑀧𑀭𑀫𑁂 𑀤𑀺𑀚𑁂;

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

𑁧𑁭.

‘‘𑀏𑀓𑀁𑀯 𑀩𑀤𑁆𑀥𑀫𑀸𑀲𑀻𑀦𑀁, 𑀅𑀩𑀤𑁆𑀥𑀜𑁆𑀘 𑀧𑀼𑀦𑀸𑀧𑀭𑀁;

𑀆𑀲𑀚𑁆𑀚 𑀩𑀤𑁆𑀥𑀫𑀸𑀲𑀻𑀦𑀁, 𑀧𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑀫𑀤𑀻𑀦𑀯𑀁.

𑁧𑁮.

‘‘𑀢𑀢𑁄 𑀲𑁄 𑀯𑀺𑀫𑀢𑁄𑀬𑁂𑀯, 𑀧𑀡𑁆𑀟𑀭𑁂 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣;

𑀧𑀯𑀟𑁆𑀠𑀓𑀸𑀬𑁂 𑀆𑀲𑀻𑀦𑁂, 𑀤𑀺𑀚𑀲𑀗𑁆𑀖𑀕𑀡𑀸𑀥𑀺𑀧𑁂.

𑁧𑁯.

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

𑀅𑀣 ¶ 𑀓𑀲𑁆𑀫𑀸 𑀅𑀩𑀤𑁆𑀥𑁄 𑀢𑁆𑀯𑀁, 𑀩𑀮𑀻 𑀧𑀓𑁆𑀔𑀺 𑀦 𑀕𑀘𑁆𑀙𑀲𑀺.

𑁨𑁦.

‘‘𑀓𑀺𑀦𑁆𑀦𑀼 𑀢𑁆𑀬𑀸𑀬𑀁 [𑀢𑀸’𑀬𑀁 (𑀲𑀻. 𑀧𑀻. 𑀓.)] 𑀤𑀺𑀚𑁄 𑀳𑁄𑀢𑀺, 𑀫𑀼𑀢𑁆𑀢𑁄 𑀩𑀤𑁆𑀥𑀁 𑀉𑀧𑀸𑀲𑀲𑀺;

𑀑𑀳𑀸𑀬 𑀲𑀓𑀼𑀡𑀸 𑀬𑀦𑁆𑀢𑀺, 𑀓𑀺𑀁 𑀏𑀓𑁄 𑀅𑀯𑀳𑀻𑀬𑀲𑀺’’.

𑁨𑁧.

‘‘𑀭𑀸𑀚𑀸 𑀫𑁂 𑀲𑁄 𑀤𑀺𑀚𑀸𑀫𑀺𑀢𑁆𑀢, 𑀲𑀔𑀸 𑀧𑀸𑀡𑀲𑀫𑁄 𑀘 𑀫𑁂;

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

𑁨𑁨.

‘‘𑀓𑀣𑀁 𑀧𑀦𑀸𑀬𑀁 𑀯𑀺𑀳𑀗𑁆𑀕𑁄, 𑀦𑀸𑀤𑁆𑀤𑀲 𑀧𑀸𑀲𑀫𑁄𑀟𑁆𑀟𑀺𑀢𑀁;

𑀧𑀤𑀜𑁆𑀳𑁂𑀢𑀁 𑀫𑀳𑀦𑁆𑀢𑀸𑀦𑀁, 𑀩𑁄𑀤𑁆𑀥𑀼𑀫𑀭𑀳𑀦𑁆𑀢𑀺 𑀆𑀧𑀤𑀁.

𑁨𑁩.

‘‘𑀬𑀤𑀸 𑀧𑀭𑀸𑀪𑀯𑁄 𑀳𑁄𑀢𑀺, 𑀧𑁄𑀲𑁄 𑀚𑀻𑀯𑀺𑀢𑀲𑀗𑁆𑀔𑀬𑁂;

𑀅𑀣 𑀚𑀸𑀮𑀜𑁆𑀘 𑀧𑀸𑀲𑀜𑁆𑀘, 𑀆𑀲𑀚𑁆𑀚𑀸𑀧𑀺 𑀦 𑀩𑀼𑀚𑁆𑀛𑀢𑀺.

𑁨𑁪.

‘‘𑀅𑀧𑀺 ¶ 𑀢𑁆𑀯𑁂𑀯 𑀫𑀳𑀸𑀧𑀜𑁆𑀜, 𑀧𑀸𑀲𑀸 𑀩𑀳𑀼𑀯𑀺𑀥𑀸 𑀢𑀢𑀸 [𑀢𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀕𑀼𑀬𑁆𑀳𑀫𑀸𑀲𑀚𑁆𑀚 [𑀕𑀽𑀴𑁆𑀳𑀫𑀸𑀲𑀚𑁆𑀚 (𑀲𑀻. 𑀧𑀻.)] 𑀩𑀚𑁆𑀛𑀦𑁆𑀢𑀺, 𑀅𑀣𑁂𑀯𑀁 𑀚𑀻𑀯𑀺𑀢𑀓𑁆𑀔𑀬𑁂’’.

𑁨𑁫.

‘‘𑀅𑀧𑀺 𑀦𑀸𑀬𑀁 𑀢𑀬𑀸 𑀲𑀤𑁆𑀥𑀺𑀁, 𑀲𑀁𑀯𑀸𑀲𑀲𑁆𑀲 [𑀲𑀫𑁆𑀪𑀸𑀲𑀲𑁆𑀲 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀼𑀔𑀼𑀤𑁆𑀭𑀬𑁄;

𑀅𑀧𑀺 𑀦𑁄 𑀅𑀦𑀼𑀫𑀜𑁆𑀜𑀸𑀲𑀺, 𑀅𑀧𑀺 𑀦𑁄 𑀚𑀻𑀯𑀺𑀢𑀁 𑀤𑀤𑁂’’.

𑁨𑁬.

‘‘𑀦 𑀘𑁂𑀯 𑀫𑁂 𑀢𑁆𑀯𑀁 𑀩𑀤𑁆𑀥𑁄𑀲𑀺, 𑀦𑀧𑀺 𑀇𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑁂 𑀯𑀥𑀁;

𑀓𑀸𑀫𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑀺𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀚𑀻𑀯 𑀢𑁆𑀯𑀁 𑀅𑀦𑀺𑀖𑁄 𑀘𑀺𑀭𑀁’’.

𑁨𑁭.

‘‘𑀦𑁂𑀯𑀸𑀳𑀫𑁂𑀢𑀫𑀺𑀘𑁆𑀙𑀸𑀫𑀺 ¶ , 𑀅𑀜𑁆𑀜𑀢𑁆𑀭𑁂𑀢𑀲𑁆𑀲 𑀚𑀻𑀯𑀺𑀢𑀸;

𑀲𑀘𑁂 𑀏𑀓𑁂𑀦 𑀢𑀼𑀝𑁆𑀞𑁄𑀲𑀺, 𑀫𑀼𑀜𑁆𑀘𑁂𑀢𑀁 𑀫𑀜𑁆𑀘 𑀪𑀓𑁆𑀔𑀬.

𑁨𑁮.

‘‘𑀆𑀭𑁄𑀳𑀧𑀭𑀺𑀡𑀸𑀳𑁂𑀦, 𑀢𑀼𑀮𑁆𑀬𑀸𑀲𑁆𑀫𑀸 [𑀢𑀼𑀮𑁆𑀬𑀸𑀫𑁆𑀳𑀸 (𑀓.)] 𑀯𑀬𑀲𑀸 𑀉𑀪𑁄;

𑀦 𑀢𑁂 𑀮𑀸𑀪𑁂𑀦 𑀚𑀻𑀯𑀢𑁆𑀣𑀺 [𑀚𑀻𑀦𑀢𑁆𑀣𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀏𑀢𑁂𑀦 𑀦𑀺𑀫𑀺𑀦𑀸 𑀢𑀼𑀯𑀁.

𑁨𑁯.

‘‘𑀢𑀤𑀺𑀗𑁆𑀖 ¶ 𑀲𑀫𑀧𑁂𑀓𑁆𑀔𑀲𑁆𑀲𑀼 [𑀲𑀫𑀯𑁂𑀓𑁆𑀔𑀲𑀼 (𑀲𑀻. 𑀧𑀻.)], 𑀳𑁄𑀢𑀼 𑀕𑀺𑀤𑁆𑀥𑀺 𑀢𑀯𑀫𑁆𑀳𑀲𑀼 [𑀢𑀯𑀲𑁆𑀫𑀲𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)];

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

𑁩𑁦.

‘‘𑀢𑀸𑀯𑀤𑁂𑀯 𑀘 𑀢𑁂 𑀮𑀸𑀪𑁄, 𑀓𑀢𑀸𑀲𑁆𑀲 [𑀓𑀢𑀲𑁆𑀲𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀬𑀸𑀘𑀦𑀸𑀬 𑀘;

𑀫𑀺𑀢𑁆𑀢𑀺 𑀘 𑀥𑀢𑀭𑀝𑁆𑀞𑁂𑀳𑀺, 𑀬𑀸𑀯𑀚𑀻𑀯𑀸𑀬 𑀢𑁂 𑀲𑀺𑀬𑀸’’.

𑁩𑁧.

‘‘𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀼 𑀦𑁄 𑀫𑀳𑀸𑀲𑀗𑁆𑀖𑀸, 𑀢𑀬𑀸 𑀫𑀼𑀢𑁆𑀢𑀁 𑀇𑀢𑁄 𑀕𑀢𑀁;

𑀫𑀺𑀢𑁆𑀢𑀸𑀫𑀘𑁆𑀘𑀸 𑀘 𑀪𑀘𑁆𑀘𑀸 𑀘, 𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑀸 𑀘 𑀩𑀦𑁆𑀥𑀯𑀸.

𑁩𑁨.

‘‘𑀦 𑀘 𑀢𑁂 𑀢𑀸𑀤𑀺𑀲𑀸 𑀫𑀺𑀢𑁆𑀢𑀸, 𑀩𑀳𑀽𑀦𑀁 [𑀩𑀳𑀼𑀦𑁆𑀦𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀇𑀥 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀬𑀣𑀸 𑀢𑁆𑀯𑀁 𑀥𑀢𑀭𑀝𑁆𑀞𑀲𑁆𑀲, 𑀧𑀸𑀡𑀲𑀸𑀥𑀸𑀭𑀡𑁄 𑀲𑀔𑀸.

𑁩𑁩.

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

𑀓𑀸𑀫𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑀺𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀜𑀸𑀢𑀺𑀫𑀚𑁆𑀛𑁂 𑀯𑀺𑀭𑁄𑀘𑀣’’.

𑁩𑁪.

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

𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣 𑀯𑀓𑁆𑀓𑀗𑁆𑀕𑁄 [𑀯𑀗𑁆𑀓𑀗𑁆𑀕𑁄 (𑀲𑁆𑀬𑀸.)], 𑀯𑀸𑀘𑀁 𑀓𑀡𑁆𑀡𑀲𑀼𑀔𑀁 𑀪𑀡𑀁.

𑁩𑁫.

‘‘𑀏𑀯𑀁 𑀮𑀼𑀤𑁆𑀤𑀓 𑀦𑀦𑁆𑀤𑀲𑁆𑀲𑀼, 𑀲𑀳 𑀲𑀩𑁆𑀩𑁂𑀳𑀺 𑀜𑀸𑀢𑀺𑀪𑀺;

𑀬𑀣𑀸𑀳𑀫𑀚𑁆𑀚 𑀦𑀦𑁆𑀤𑀸𑀫𑀺, 𑀫𑀼𑀢𑁆𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀤𑀺𑀚𑀸𑀥𑀺𑀧𑀁’’.

𑁩𑁬.

‘‘𑀏𑀳𑀺 ¶ 𑀢𑀁 𑀅𑀦𑀼𑀲𑀺𑀓𑁆𑀔𑀸𑀫𑀺, 𑀬𑀣𑀸 𑀢𑁆𑀯𑀫𑀧𑀺 𑀮𑀘𑁆𑀙𑀲𑁂;

𑀮𑀸𑀪𑀁 𑀢𑀯𑀸𑀬𑀁 [𑀬𑀣𑀸𑀬𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀥𑀢𑀭𑀝𑁆𑀞𑁄, 𑀧𑀸𑀧𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 [𑀓𑀜𑁆𑀘𑀺 (𑀲𑀻.)] 𑀦 𑀤𑀓𑁆𑀔𑀢𑀺.

𑁩𑁭.

‘‘𑀔𑀺𑀧𑁆𑀧𑀫𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑀁 𑀦𑁂𑀢𑁆𑀯𑀸 [𑀕𑀦𑁆𑀢𑁆𑀯𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀭𑀜𑁆𑀜𑁄 𑀤𑀲𑁆𑀲𑁂𑀳𑀺 𑀦𑁄 𑀉𑀪𑁄;

𑀅𑀩𑀤𑁆𑀥𑁂 𑀧𑀓𑀢𑀺𑀪𑀽𑀢𑁂, 𑀓𑀸𑀚𑁂 [𑀓𑀸𑀘𑁂 (𑀧𑀻.)] 𑀉𑀪𑀬𑀢𑁄 𑀞𑀺𑀢𑁂.

𑁩𑁮.

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

𑀅𑀬𑀜𑁆𑀳𑀺 ¶ 𑀭𑀸𑀚𑀸 𑀳𑀁𑀲𑀸𑀦𑀁, 𑀅𑀬𑀁 𑀲𑁂𑀦𑀸𑀧𑀢𑀻𑀢𑀭𑁄.

𑁩𑁯.

‘‘𑀅𑀲𑀁𑀲𑀬𑀁 𑀇𑀫𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀳𑀁𑀲𑀭𑀸𑀚𑀁 𑀦𑀭𑀸𑀥𑀺𑀧𑁄;

𑀧𑀢𑀻𑀢𑁄 𑀲𑀼𑀫𑀦𑁄 𑀯𑀺𑀢𑁆𑀢𑁄 [𑀘𑀺𑀢𑁆𑀢𑁄 (𑀓.)], 𑀩𑀳𑀼𑀁 𑀤𑀲𑁆𑀲𑀢𑀺 𑀢𑁂 𑀥𑀦𑀁’’.

𑁪𑁦.

‘‘𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀓𑀫𑁆𑀫𑀼𑀦𑀸 𑀉𑀧𑀧𑀸𑀤𑀬𑀺;

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

𑀅𑀩𑀤𑁆𑀥𑁂 𑀧𑀓𑀢𑀺𑀪𑀽𑀢𑁂, 𑀓𑀸𑀚𑁂 𑀉𑀪𑀬𑀢𑁄 𑀞𑀺𑀢𑁂.

𑁪𑁧.

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

𑀅𑀬𑀜𑁆𑀳𑀺 𑀭𑀸𑀚𑀸 𑀳𑀁𑀲𑀸𑀦𑀁, 𑀅𑀬𑀁 𑀲𑁂𑀦𑀸𑀧𑀢𑀻𑀢𑀭𑁄’’.

𑁪𑁨.

‘‘𑀓𑀣𑀁 𑀧𑀦𑀺𑀫𑁂 𑀯𑀺𑀳𑀗𑁆𑀕𑀸 [𑀯𑀺𑀳𑀕𑀸 (𑀲𑀻. 𑀧𑀻.)], 𑀢𑀯 𑀳𑀢𑁆𑀣𑀢𑁆𑀢𑀫𑀸𑀕𑀢𑀸 [𑀳𑀢𑁆𑀣𑀢𑁆𑀣’𑀫𑀸𑀕𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀓𑀣𑀁 𑀮𑀼𑀤𑁆𑀤𑁄 𑀫𑀳𑀦𑁆𑀢𑀸𑀦𑀁, 𑀇𑀲𑁆𑀲𑀭𑁂 𑀇𑀥 𑀅𑀚𑁆𑀛𑀕𑀸’’.

𑁪𑁩.

‘‘𑀯𑀺𑀳𑀺𑀢𑀸 𑀲𑀦𑁆𑀢𑀺𑀫𑁂 𑀧𑀸𑀲𑀸, 𑀧𑀮𑁆𑀮𑀮𑁂𑀲𑀼 𑀚𑀦𑀸𑀥𑀺𑀧;

𑀬𑀁 𑀬𑀤𑀸𑀬𑀢𑀦𑀁 𑀫𑀜𑁆𑀜𑁂, 𑀤𑀺𑀚𑀸𑀦𑀁 𑀧𑀸𑀡𑀭𑁄𑀥𑀦𑀁.

𑁪𑁪.

‘‘𑀢𑀸𑀤𑀺𑀲𑀁 𑀧𑀸𑀲𑀫𑀸𑀲𑀚𑁆𑀚, 𑀳𑀁𑀲𑀭𑀸𑀚𑀸 𑀅𑀩𑀚𑁆𑀛𑀣;

𑀢𑀁 𑀅𑀩𑀤𑁆𑀥𑁄 𑀉𑀧𑀸𑀲𑀻𑀦𑁄, 𑀫𑀫𑀸𑀬𑀁 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣.

𑁪𑁫.

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

𑀪𑀢𑁆𑀢𑀼𑀭𑀢𑁆𑀣𑁂 𑀧𑀭𑀓𑁆𑀓𑀦𑁆𑀢𑁄, 𑀥𑀫𑁆𑀫𑀬𑀼𑀢𑁆𑀢𑁄 [𑀥𑀫𑁆𑀫𑁂 𑀬𑀼𑀢𑁆𑀢𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑀺𑀳𑀗𑁆𑀕𑀫𑁄.

𑁪𑁬.

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

𑀅𑀦𑀼𑀢𑁆𑀣𑀼𑀦𑀦𑁆𑀢𑁄 𑀆𑀲𑀻𑀦𑁄, 𑀪𑀢𑁆𑀢𑀼 𑀬𑀸𑀘𑀺𑀢𑁆𑀣 𑀚𑀻𑀯𑀺𑀢𑀁.

𑁪𑁭.

‘‘𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀧𑀲𑀸𑀤𑀫𑀳𑀫𑀚𑁆𑀛𑀕𑀸;

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

𑁪𑁮.

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

𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣 𑀯𑀓𑁆𑀓𑀗𑁆𑀕𑁄, 𑀯𑀸𑀘𑀁 𑀓𑀡𑁆𑀡𑀲𑀼𑀔𑀁 𑀪𑀡𑀁.

𑁪𑁯.

‘‘‘𑀏𑀯𑀁 𑀮𑀼𑀤𑁆𑀤𑀓 𑀦𑀦𑁆𑀤𑀲𑁆𑀲𑀼, 𑀲𑀳 𑀲𑀩𑁆𑀩𑁂𑀳𑀺 𑀜𑀸𑀢𑀺𑀪𑀺;

𑀬𑀣𑀸𑀳𑀫𑀚𑁆𑀚 𑀦𑀦𑁆𑀤𑀸𑀫𑀺, 𑀫𑀼𑀢𑁆𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀤𑀺𑀚𑀸𑀥𑀺𑀧𑀁.

𑁫𑁦.

‘‘‘𑀏𑀳𑀺 𑀢𑀁 𑀅𑀦𑀼𑀲𑀺𑀓𑁆𑀔𑀸𑀫𑀺, 𑀬𑀣𑀸 𑀢𑁆𑀯𑀫𑀧𑀺 𑀮𑀘𑁆𑀙𑀲𑁂;

𑀮𑀸𑀪𑀁 𑀢𑀯𑀸𑀬𑀁 𑀥𑀢𑀭𑀝𑁆𑀞𑁄, 𑀧𑀸𑀧𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀦 𑀤𑀓𑁆𑀔𑀢𑀺.

𑁫𑁧.

‘‘‘𑀔𑀺𑀧𑁆𑀧𑀫𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑀁 𑀦𑁂𑀢𑁆𑀯𑀸 [𑀕𑀦𑁆𑀢𑁆𑀯𑀸 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)], 𑀭𑀜𑁆𑀜𑁄 𑀤𑀲𑁆𑀲𑁂𑀳𑀺 𑀦𑁄 𑀉𑀪𑁄;

𑀅𑀩𑀤𑁆𑀥𑁂 𑀧𑀓𑀢𑀺𑀪𑀽𑀢𑁂, 𑀓𑀸𑀚𑁂 𑀉𑀪𑀬𑀢𑁄 𑀞𑀺𑀢𑁂.

𑁫𑁨.

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

𑀅𑀬𑀜𑁆𑀳𑀺 𑀭𑀸𑀚𑀸 𑀳𑀁𑀲𑀸𑀦𑀁, 𑀅𑀬𑀁 𑀲𑁂𑀦𑀸𑀧𑀢𑀻𑀢𑀭𑁄.

𑁫𑁩.

‘‘‘𑀅𑀲𑀁𑀲𑀬𑀁 𑀇𑀫𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀳𑀁𑀲𑀭𑀸𑀚𑀁 𑀦𑀭𑀸𑀥𑀺𑀧𑁄;

𑀧𑀢𑀻𑀢𑁄 𑀲𑀼𑀫𑀦𑁄 𑀯𑀺𑀢𑁆𑀢𑁄, 𑀩𑀳𑀼𑀁 𑀤𑀲𑁆𑀲𑀢𑀺 𑀢𑁂 𑀥𑀦𑀁’.

𑁫𑁪.

‘‘𑀏𑀯𑀫𑁂𑀢𑀲𑁆𑀲 𑀯𑀘𑀦𑀸, 𑀆𑀦𑀻𑀢𑀸𑀫𑁂 𑀉𑀪𑁄 𑀫𑀬𑀸;

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

𑁫𑁫.

‘‘𑀲𑁄𑀬𑀁 𑀏𑀯𑀁 𑀕𑀢𑁄 𑀧𑀓𑁆𑀔𑀻, 𑀤𑀺𑀚𑁄 𑀧𑀭𑀫𑀥𑀫𑁆𑀫𑀺𑀓𑁄;

𑀫𑀸𑀤𑀺𑀲𑀲𑁆𑀲 𑀳𑀺 𑀮𑀼𑀤𑁆𑀤𑀲𑁆𑀲, 𑀚𑀦𑀬𑁂𑀬𑁆𑀬𑀸𑀣 𑀫𑀤𑁆𑀤𑀯𑀁.

𑁫𑁬.

‘‘𑀉𑀧𑀸𑀬𑀦𑀜𑁆𑀘 ¶ 𑀢𑁂 𑀤𑁂𑀯, 𑀦𑀸𑀜𑁆𑀜𑀁 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀏𑀤𑀺𑀲𑀁;

𑀲𑀩𑁆𑀩𑀲𑀸𑀓𑀼𑀡𑀺𑀓𑀸𑀕𑀸𑀫𑁂, 𑀢𑀁 𑀧𑀲𑁆𑀲 𑀫𑀦𑀼𑀚𑀸𑀥𑀺𑀧’’.

𑁫𑁭.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁 𑀭𑀸𑀚𑀸𑀦𑀁, 𑀧𑀻𑀞𑁂 𑀲𑁄𑀯𑀡𑁆𑀡𑀬𑁂 𑀲𑀼𑀪𑁂;

𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣 𑀯𑀓𑁆𑀓𑀗𑁆𑀕𑁄, 𑀯𑀸𑀘𑀁 𑀓𑀡𑁆𑀡𑀲𑀼𑀔𑀁 𑀪𑀡𑀁.

𑁫𑁮.

‘‘𑀓𑀘𑁆𑀘𑀺𑀦𑁆𑀦𑀼 ¶ 𑀪𑁄𑀢𑁄 𑀓𑀼𑀲𑀮𑀁, 𑀓𑀘𑁆𑀘𑀺 𑀪𑁄𑀢𑁄 𑀅𑀦𑀸𑀫𑀬𑀁;

𑀓𑀘𑁆𑀘𑀺 𑀭𑀝𑁆𑀞𑀫𑀺𑀤𑀁 𑀨𑀻𑀢𑀁, 𑀥𑀫𑁆𑀫𑁂𑀦 𑀫𑀦𑀼𑀲𑀸𑀲𑀲𑀺’’.

𑁫𑁯.

‘‘𑀓𑀼𑀲𑀮𑀜𑁆𑀘𑁂𑀯 𑀫𑁂 𑀳𑀁𑀲, 𑀅𑀣𑁄 𑀳𑀁𑀲 𑀅𑀦𑀸𑀫𑀬𑀁;

𑀅𑀣𑁄 𑀭𑀝𑁆𑀞𑀫𑀺𑀤𑀁 𑀨𑀻𑀢𑀁, 𑀥𑀫𑁆𑀫𑁂𑀦 𑀫𑀦𑀼𑀲𑀸𑀲𑀳𑀁’’ [𑀫𑀦𑀼𑀲𑀺𑀲𑁆𑀲𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)].

𑁬𑁦.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀪𑁄𑀢𑁄 𑀅𑀫𑀘𑁆𑀘𑁂𑀲𑀼, 𑀤𑁄𑀲𑁄 𑀓𑁄𑀘𑀺 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀓𑀘𑁆𑀘𑀺 𑀘 [𑀓𑀘𑁆𑀘𑀺𑀦𑁆𑀦𑀼 (𑀲𑀻. 𑀧𑀻.)] 𑀢𑁂 𑀢𑀯𑀢𑁆𑀣𑁂𑀲𑀼, 𑀦𑀸𑀯𑀓𑀗𑁆𑀔𑀦𑁆𑀢𑀺 𑀚𑀻𑀯𑀺𑀢𑀁’’.

𑁬𑁧.

‘‘𑀅𑀣𑁄𑀧𑀺 ¶ 𑀫𑁂 𑀅𑀫𑀘𑁆𑀘𑁂𑀲𑀼, 𑀤𑁄𑀲𑁄 𑀓𑁄𑀘𑀺 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀅𑀣𑁄𑀧𑀺 𑀢𑁂 [𑀅𑀣𑁄𑀧𑀺𑀫𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀫𑀫𑀢𑁆𑀣𑁂𑀲𑀼, 𑀦𑀸𑀯𑀓𑀗𑁆𑀔𑀦𑁆𑀢𑀺 𑀚𑀻𑀯𑀺𑀢𑀁’’.

𑁬𑁨.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀢𑁂 𑀲𑀸𑀤𑀺𑀲𑀻 𑀪𑀭𑀺𑀬𑀸, 𑀅𑀲𑁆𑀲𑀯𑀸 𑀧𑀺𑀬𑀪𑀸𑀡𑀺𑀦𑀻;

𑀧𑀼𑀢𑁆𑀢𑀭𑀽𑀧𑀬𑀲𑀽𑀧𑁂𑀢𑀸, 𑀢𑀯 𑀙𑀦𑁆𑀤𑀯𑀲𑀸𑀦𑀼𑀕𑀸’’.

𑁬𑁩.

‘‘𑀅𑀣𑁄 𑀫𑁂 𑀲𑀸𑀤𑀺𑀲𑀻 𑀪𑀭𑀺𑀬𑀸, 𑀅𑀲𑁆𑀲𑀯𑀸 𑀧𑀺𑀬𑀪𑀸𑀡𑀺𑀦𑀻;

𑀧𑀼𑀢𑁆𑀢𑀭𑀽𑀧𑀬𑀲𑀽𑀧𑁂𑀢𑀸, 𑀫𑀫 𑀙𑀦𑁆𑀤𑀯𑀲𑀸𑀦𑀼𑀕𑀸’’.

𑁬𑁪.

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

𑀤𑀼𑀓𑁆𑀔𑀫𑀸𑀧𑀚𑁆𑀚𑀺 𑀯𑀺𑀧𑀼𑀮𑀁, 𑀢𑀲𑁆𑀫𑀺𑀁 𑀧𑀞𑀫𑀫𑀸𑀧𑀤𑁂.

𑁬𑁫.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀬𑀦𑁆𑀢𑀸𑀧𑀢𑀺𑀢𑁆𑀯𑀸𑀦, 𑀤𑀡𑁆𑀟𑁂𑀦 𑀲𑀫𑀧𑁄𑀣𑀬𑀺;

𑀏𑀯𑀫𑁂𑀢𑁂𑀲𑀁 𑀚𑀫𑁆𑀫𑀸𑀦𑀁, 𑀧𑀸𑀢𑀺𑀓𑀁 [𑀧𑀸𑀓𑀢𑀺𑀓𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀪𑀯𑀢𑀺 𑀢𑀸𑀯𑀤𑁂’’.

𑁬𑁬.

‘‘𑀔𑁂𑀫𑀫𑀸𑀲𑀺 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀏𑀯𑀫𑀸𑀧𑀤𑀺𑀬𑀸 𑀲𑀢𑀺 [𑀏𑀯𑀫𑀸𑀧𑀤𑀺 𑀲𑀁𑀲𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀦 𑀘𑀸𑀬𑀁 𑀓𑀺𑀜𑁆𑀘𑀺 𑀭𑀲𑁆𑀫𑀸𑀲𑀼, 𑀲𑀢𑁆𑀢𑀽𑀯 𑀲𑀫𑀧𑀚𑁆𑀚𑀣.

𑁬𑁭.

‘‘𑀧𑀘𑁆𑀘𑀕𑀫𑀺𑀢𑁆𑀣 𑀦𑁂𑀲𑀸𑀤𑁄, 𑀧𑀼𑀩𑁆𑀩𑁂𑀯 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣;

𑀢𑀤𑀸𑀬𑀁 𑀲𑀼𑀫𑀼𑀔𑁄𑀬𑁂𑀯, 𑀧𑀡𑁆𑀟𑀺𑀢𑁄 𑀧𑀘𑁆𑀘𑀪𑀸𑀲𑀣.

𑁬𑁮.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀧𑀲𑀸𑀤𑀫𑀬𑀫𑀚𑁆𑀛𑀕𑀸;

𑀢𑀢𑁄 𑀫𑀁 𑀧𑀸𑀫𑀼𑀘𑀻 𑀧𑀸𑀲𑀸, 𑀅𑀦𑀼𑀜𑁆𑀜𑀸𑀲𑀺 𑀲𑀼𑀔𑁂𑀦 𑀘.

𑁬𑁯.

‘‘𑀇𑀤𑀜𑁆𑀘 𑀲𑀼𑀫𑀼𑀔𑁂𑀦𑁂𑀯, 𑀏𑀢𑀤𑀢𑁆𑀣𑀸𑀬 𑀘𑀺𑀦𑁆𑀢𑀺𑀢𑀁;

𑀪𑁄𑀢𑁄 𑀲𑀓𑀸𑀲𑁂𑀕𑀫𑀦𑀁 [𑀲𑀓𑀸𑀲𑁂 + 𑀆𑀕𑀫𑀦𑀁], 𑀏𑀢𑀲𑁆𑀲 𑀥𑀦𑀫𑀺𑀘𑁆𑀙𑀢𑀸’’.

𑁭𑁦.

‘‘𑀲𑁆𑀯𑀸𑀕𑀢𑀜𑁆𑀘𑁂𑀯𑀺𑀤𑀁 𑀪𑀯𑀢𑀁, 𑀧𑀢𑀻𑀢𑁄 𑀘𑀲𑁆𑀫𑀺 𑀤𑀲𑁆𑀲𑀦𑀸;

𑀏𑀲𑁄 𑀘𑀸𑀧𑀺 𑀩𑀳𑀼𑀁 𑀯𑀺𑀢𑁆𑀢𑀁, 𑀮𑀪𑀢𑀁 𑀬𑀸𑀯𑀤𑀺𑀘𑁆𑀙𑀢𑀺’’ [𑀬𑀸𑀯𑀢𑀺𑀘𑁆𑀙𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)].

𑁭𑁧.

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

𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣 𑀯𑀓𑁆𑀓𑀗𑁆𑀕𑀁, 𑀯𑀸𑀘𑀁 𑀓𑀡𑁆𑀡𑀲𑀼𑀔𑀁 𑀪𑀡𑀁’’.

𑁭𑁨.

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

𑀲𑀩𑁆𑀩𑀢𑁆𑀣𑀺𑀲𑁆𑀲𑀭𑀺𑀬𑀁 𑀢𑀯 [𑀲𑀩𑁆𑀩𑀢𑁆𑀣𑀺𑀲𑁆𑀲𑀭𑀺𑀬𑀁 𑀪𑀯𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀲𑀩𑁆𑀩𑀺𑀲𑁆𑀲𑀭𑀺𑀬𑀁 𑀪𑀯𑀢𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀢𑀁 𑀧𑀲𑀸𑀲 [𑀧𑀲𑀸𑀲𑀣 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀬𑀤𑀺𑀘𑁆𑀙𑀣.

𑁭𑁩.

‘‘𑀤𑀸𑀦𑀢𑁆𑀣𑀁 ¶ 𑀉𑀧𑀪𑁄𑀢𑁆𑀢𑀼𑀁 𑀯𑀸, 𑀬𑀁 𑀘𑀜𑁆𑀜𑀁 𑀉𑀧𑀓𑀧𑁆𑀧𑀢𑀺;

𑀏𑀢𑀁 𑀤𑀤𑀸𑀫𑀺 𑀯𑁄 𑀯𑀺𑀢𑁆𑀢𑀁, 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑀁 [𑀇𑀲𑁆𑀲𑁂𑀭𑀁 (𑀲𑀻.), 𑀇𑀲𑁆𑀲𑀭𑀁 (𑀧𑀻.)] 𑀯𑀺𑀲𑁆𑀲𑀚𑀸𑀫𑀺 𑀯𑁄’’.

𑁭𑁪.

‘‘𑀬𑀣𑀸 𑀘 𑀫𑁆𑀬𑀸𑀬𑀁 𑀲𑀼𑀫𑀼𑀔𑁄, 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑁂𑀬𑁆𑀬 𑀧𑀡𑁆𑀟𑀺𑀢𑁄;

𑀓𑀸𑀫𑀲𑀸 𑀩𑀼𑀤𑁆𑀥𑀺𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀢𑀁 𑀫𑁆𑀬𑀸𑀲𑁆𑀲 𑀧𑀭𑀫𑀧𑁆𑀧𑀺𑀬𑀁’’.

𑁭𑁫.

‘‘𑀅𑀳𑀁 𑀔𑀮𑀼 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀦𑀸𑀕𑀭𑀸𑀚𑀸𑀭𑀺𑀯𑀦𑁆𑀢𑀭𑀁;

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

𑁭𑁬.

‘‘𑀅𑀫𑁆𑀳𑀸𑀓𑀜𑁆𑀘𑁂𑀯 𑀲𑁄 [𑀬𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑁂𑀝𑁆𑀞𑁄, 𑀢𑁆𑀯𑀜𑁆𑀘 𑀉𑀢𑁆𑀢𑀫𑀲𑀢𑁆𑀢𑀯𑁄;

𑀪𑀽𑀫𑀺𑀧𑀸𑀮𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀺𑀦𑁆𑀤𑁄, 𑀧𑀽𑀚𑀸 𑀩𑀳𑀽𑀳𑀺 𑀳𑁂𑀢𑀼𑀳𑀺.

𑁭𑁭.

‘‘𑀢𑁂𑀲𑀁 𑀉𑀪𑀺𑀦𑁆𑀦𑀁 𑀪𑀡𑀢𑀁, 𑀯𑀢𑁆𑀢𑀫𑀸𑀦𑁂 𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑁂;

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

𑁭𑁮.

‘‘𑀥𑀫𑁆𑀫𑁂𑀦 ¶ 𑀓𑀺𑀭 𑀦𑁂𑀲𑀸𑀤𑁄, 𑀧𑀡𑁆𑀟𑀺𑀢𑁄 𑀅𑀡𑁆𑀟𑀚𑁄 𑀇𑀢𑀺;

𑀦 𑀳𑁂𑀯 𑀅𑀓𑀢𑀢𑁆𑀢𑀲𑁆𑀲, 𑀦𑀬𑁄 𑀏𑀢𑀸𑀤𑀺𑀲𑁄 𑀲𑀺𑀬𑀸.

𑁭𑁯.

‘‘𑀏𑀯𑀁 𑀅𑀕𑁆𑀕𑀧𑀓𑀢𑀺𑀫𑀸, 𑀏𑀯𑀁 𑀉𑀢𑁆𑀢𑀫𑀲𑀢𑁆𑀢𑀯𑁄;

𑀬𑀸𑀯𑀢𑀢𑁆𑀣𑀺 𑀫𑀬𑀸 𑀤𑀺𑀝𑁆𑀞𑀸, 𑀦𑀸𑀜𑁆𑀜𑀁 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀏𑀤𑀺𑀲𑀁.

𑁮𑁦.

‘‘𑀢𑀼𑀝𑁆𑀞𑁄𑀲𑁆𑀫𑀺 𑀯𑁄 𑀧𑀓𑀢𑀺𑀬𑀸, 𑀯𑀸𑀓𑁆𑀬𑁂𑀦 𑀫𑀥𑀼𑀭𑁂𑀦 𑀘;

𑀏𑀲𑁄 𑀘𑀸𑀧𑀺 𑀫𑀫𑀘𑁆𑀙𑀦𑁆𑀤𑁄, 𑀘𑀺𑀭𑀁 𑀧𑀲𑁆𑀲𑁂𑀬𑁆𑀬 𑀯𑁄 𑀉𑀪𑁄’’.

𑁮𑁧.

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

𑀧𑀢𑁆𑀢𑀸 𑀦𑀺𑀲𑁆𑀲𑀁𑀲𑀬𑀁 𑀢𑁆𑀬𑀸𑀫𑁆𑀳𑀸 [𑀢𑁆𑀬𑀫𑁆𑀳𑀸 (𑀧𑀻.)], 𑀪𑀢𑁆𑀢𑀺𑀭𑀲𑁆𑀫𑀸𑀲𑀼 𑀬𑀸 𑀢𑀯.

𑁮𑁨.

‘‘𑀅𑀤𑀼𑀜𑁆𑀘 𑀦𑀽𑀦 𑀲𑀼𑀫𑀳𑀸, 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑀲𑁆𑀲 𑀫𑀦𑁆𑀢𑀭𑀁;

𑀅𑀤𑀲𑁆𑀲𑀦𑁂𑀦 𑀅𑀲𑁆𑀫𑀸𑀓𑀁 [𑀅𑀫𑁆𑀳𑀸𑀓𑀁 (𑀲𑀻. 𑀧𑀻.)], 𑀤𑀼𑀓𑁆𑀔𑀁 𑀩𑀳𑀽𑀲𑀼 𑀧𑀓𑁆𑀔𑀺𑀲𑀼.

𑁮𑁩.

‘‘𑀢𑁂𑀲𑀁 𑀲𑁄𑀓𑀯𑀺𑀖𑀸𑀢𑀸𑀬, 𑀢𑀬𑀸 𑀅𑀦𑀼𑀫𑀢𑀸 𑀫𑀬𑀁;

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

𑁮𑁪.

‘‘𑀅𑀤𑁆𑀥𑀸𑀳𑀁 𑀯𑀺𑀧𑀼𑀮𑀁 𑀧𑀻𑀢𑀺𑀁, 𑀪𑀯𑀢𑀁 𑀯𑀺𑀦𑁆𑀤𑀸𑀫𑀺 𑀤𑀲𑁆𑀲𑀦𑀸;

𑀏𑀲𑁄 𑀘𑀸𑀧𑀺 𑀫𑀳𑀸 𑀅𑀢𑁆𑀣𑁄, 𑀜𑀸𑀢𑀺𑀯𑀺𑀲𑁆𑀲𑀸𑀲𑀦𑀸 𑀲𑀺𑀬𑀸’’.

𑁮𑁫.

‘‘𑀇𑀤𑀁 ¶ 𑀯𑀢𑁆𑀯𑀸 𑀥𑀢𑀭𑀝𑁆𑀞𑁄 [𑀥𑀢𑀭𑀝𑁆𑀞𑀸 (𑀲𑀻.)], 𑀳𑀁𑀲𑀭𑀸𑀚𑀸 𑀦𑀭𑀸𑀥𑀺𑀧𑀁;

𑀉𑀢𑁆𑀢𑀫𑀁 𑀚𑀯𑀫𑀦𑁆𑀯𑀸𑀬 [𑀉𑀢𑁆𑀢𑀫𑀚𑀯𑀫𑀢𑁆𑀢𑀸𑀬 (𑀲𑀻. 𑀧𑀻.)], 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑀁 𑀉𑀧𑀸𑀕𑀫𑀼𑀁.

𑁮𑁬.

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

𑀓𑁂𑀓𑀸𑀢𑀺 𑀫𑀓𑀭𑀼𑀁 𑀳𑀁𑀲𑀸, 𑀧𑀼𑀣𑀼𑀲𑀤𑁆𑀤𑁄 𑀅𑀚𑀸𑀬𑀣.

𑁮𑁭.

‘‘𑀢𑁂 𑀧𑀢𑀻𑀢𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑁂𑀦, 𑀪𑀢𑁆𑀢𑀼𑀦𑀸 𑀪𑀢𑁆𑀢𑀼𑀕𑀸𑀭𑀯𑀸;

𑀲𑀫𑀦𑁆𑀢𑀸 𑀧𑀭𑀺𑀓𑀺𑀭𑀺𑀁𑀲𑀼 [𑀧𑀭𑀺𑀓𑀭𑀺𑀁𑀲𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀅𑀡𑁆𑀟𑀚𑀸 𑀮𑀤𑁆𑀥𑀧𑀘𑁆𑀘𑀬𑀸’’.

𑁮𑁮.

‘‘𑀏𑀯𑀁 ¶ 𑀫𑀺𑀢𑁆𑀢𑀯𑀢𑀁 𑀅𑀢𑁆𑀣𑀸, 𑀲𑀩𑁆𑀩𑁂 𑀳𑁄𑀦𑁆𑀢𑀺 𑀧𑀤𑀓𑁆𑀔𑀺𑀡𑀸;

𑀳𑀁𑀲𑀸 𑀬𑀣𑀸 𑀥𑀢𑀭𑀝𑁆𑀞𑀸, 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑀁 𑀉𑀧𑀸𑀕𑀫𑀼’’𑀦𑁆𑀢𑀺.

𑀘𑀽𑀴 [𑀘𑀼𑀮𑁆𑀮 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀳𑀁𑀲𑀚𑀸𑀢𑀓𑀁 𑀧𑀞𑀫𑀁.

𑁫𑁩𑁪. 𑀫𑀳𑀸𑀳𑀁𑀲𑀚𑀸𑀢𑀓𑀁 (𑁨)

𑁮𑁯.

‘‘𑀏𑀢𑁂 𑀳𑀁𑀲𑀸 𑀧𑀓𑁆𑀓𑀫𑀦𑁆𑀢𑀺, 𑀯𑀓𑁆𑀓𑀗𑁆𑀕𑀸 𑀪𑀬𑀫𑁂𑀭𑀺𑀢𑀸;

𑀳𑀭𑀺𑀢𑁆𑀢𑀘 𑀳𑁂𑀫𑀯𑀡𑁆𑀡, 𑀓𑀸𑀫𑀁 𑀲𑀼𑀫𑀼𑀔 𑀧𑀓𑁆𑀓𑀫.

𑁯𑁦.

‘‘𑀑𑀳𑀸𑀬 𑀫𑀁 𑀜𑀸𑀢𑀺𑀕𑀡𑀸, 𑀏𑀓𑀁 𑀧𑀸𑀲𑀯𑀲𑀁 𑀕𑀢𑀁;

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

𑁯𑁧.

‘‘𑀧𑀢𑁂𑀯 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀦𑀢𑁆𑀣𑀺 𑀩𑀤𑁆𑀥𑁂 𑀲𑀳𑀸𑀬𑀢𑀸;

𑀫𑀸 𑀅𑀦𑀻𑀖𑀸𑀬 𑀳𑀸𑀧𑁂𑀲𑀺, 𑀓𑀸𑀫𑀁 𑀲𑀼𑀫𑀼𑀔 𑀧𑀓𑁆𑀓𑀫’’.

𑁯𑁨.

‘‘𑀦𑀸𑀳𑀁 𑀤𑀼𑀓𑁆𑀔𑀧𑀭𑁂𑀢𑁄𑀧𑀺 [𑀤𑀼𑀓𑁆𑀔𑀧𑀭𑁂𑀢𑁄’’𑀢𑀺 (𑀚𑀸. 𑁧.𑁧𑁫.𑁧𑁩𑁬) 𑀅𑀝𑁆𑀞𑀓𑀣𑀸𑀬𑁄 𑀑𑀮𑁄𑀓𑁂𑀢𑀩𑁆𑀩𑀸], 𑀥𑀢𑀭𑀝𑁆𑀞 𑀢𑀼𑀯𑀁 [𑀢𑀯𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀚𑀳𑁂;

𑀚𑀻𑀯𑀺𑀢𑀁 𑀫𑀭𑀡𑀁 𑀯𑀸 𑀫𑁂, 𑀢𑀬𑀸 𑀲𑀤𑁆𑀥𑀺𑀁 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺.

𑁯𑁩.

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

𑀦 𑀫𑀁 𑀅𑀦𑀭𑀺𑀬𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑁂, 𑀓𑀫𑁆𑀫𑁂 𑀬𑁄𑀚𑁂𑀢𑀼𑀫𑀭𑀳𑀲𑀺.

𑁯𑁪.

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

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

𑁯𑁫.

‘‘𑀓𑀣𑀁 ¶ 𑀅𑀳𑀁 𑀯𑀺𑀓𑀢𑁆𑀣𑀺𑀲𑁆𑀲𑀁 [𑀯𑀺𑀓𑀢𑁆𑀢𑀺𑀲𑁆𑀲𑀁 (𑀧𑀻.)], 𑀜𑀸𑀢𑀺𑀫𑀚𑁆𑀛𑁂 𑀇𑀢𑁄 𑀕𑀢𑁄;

𑀢𑀁 𑀳𑀺𑀢𑁆𑀯𑀸 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀓𑀺𑀁 𑀢𑁂 𑀯𑀓𑁆𑀔𑀸𑀫𑀺𑀢𑁄 𑀕𑀢𑁄;

𑀇𑀥 𑀧𑀸𑀡𑀁 𑀘𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀦𑀸𑀦𑀭𑀺𑀬𑀁 [𑀦 𑀅𑀦𑀭𑀺𑀬𑀁 (𑀧𑀻.)] 𑀓𑀢𑁆𑀢𑀼𑀫𑀼𑀲𑁆𑀲𑀳𑁂’’.

𑁯𑁬.

‘‘𑀏𑀲𑁄 ¶ 𑀳𑀺 𑀥𑀫𑁆𑀫𑁄 𑀲𑀼𑀫𑀼𑀔, 𑀬𑀁 𑀢𑁆𑀯𑀁 𑀅𑀭𑀺𑀬𑀧𑀣𑁂 𑀞𑀺𑀢𑁄;

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

𑁯𑁭.

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

𑀅𑀥𑀺𑀕𑀘𑁆𑀙𑀲𑀺 𑀢𑁆𑀯𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀏𑀯𑀁 𑀪𑀽𑀢𑀲𑁆𑀲 𑀚𑀻𑀯𑀺𑀢𑀁’’.

𑁯𑁮.

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

𑀤𑀡𑁆𑀟𑀫𑀸𑀤𑀸𑀬 𑀦𑁂𑀲𑀸𑀤𑁄, 𑀆𑀧𑀢𑀻 [𑀆𑀧𑀤𑀻 (𑀓.)] 𑀢𑀼𑀭𑀺𑀢𑁄 𑀪𑀼𑀲𑀁.

𑁯𑁯.

‘‘𑀢𑀫𑀸𑀧𑀢𑀦𑁆𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦, 𑀲𑀼𑀫𑀼𑀔𑁄 𑀅𑀢𑀺𑀩𑁆𑀭𑀽𑀳𑀬𑀺 [𑀅𑀧𑀭𑀺𑀩𑁆𑀭𑀽𑀳𑀬𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀅𑀝𑁆𑀞𑀸𑀲𑀺 𑀧𑀼𑀭𑀢𑁄 𑀭𑀜𑁆𑀜𑁄, 𑀳𑀁𑀲𑁄 𑀯𑀺𑀲𑁆𑀲𑀸𑀲𑀬𑀁 𑀩𑁆𑀬𑀥𑀁 [𑀩𑁆𑀬𑀣𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑁧𑁦𑁦.

‘‘𑀫𑀸 𑀪𑀸𑀬𑀺 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀦 𑀳𑀺 𑀪𑀸𑀬𑀦𑁆𑀢𑀺 𑀢𑀸𑀤𑀺𑀲𑀸;

𑀅𑀳𑀁 𑀬𑁄𑀕𑀁 𑀧𑀬𑀼𑀜𑁆𑀚𑀺𑀲𑁆𑀲𑀁, 𑀬𑀼𑀢𑁆𑀢𑀁 𑀥𑀫𑁆𑀫𑀽𑀧𑀲𑀁𑀳𑀺𑀢𑀁;

𑀢𑁂𑀦 𑀧𑀭𑀺𑀬𑀸𑀧𑀤𑀸𑀦𑁂𑀦 [𑀧𑀭𑀺𑀬𑀸𑀤𑀸𑀦𑁂𑀦 (𑀓.)], 𑀔𑀺𑀧𑁆𑀧𑀁 𑀧𑀸𑀲𑀸 𑀧𑀫𑁄𑀓𑁆𑀔𑀲𑀺’’.

𑁧𑁦𑁧.

‘‘𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀲𑀼𑀫𑀼𑀔𑀲𑁆𑀲 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁;

𑀧𑀳𑀝𑁆𑀞𑀮𑁄𑀫𑁄 𑀦𑁂𑀲𑀸𑀤𑁄, 𑀅𑀜𑁆𑀚𑀮𑀺𑀲𑁆𑀲 𑀧𑀡𑀸𑀫𑀬𑀺.

𑁧𑁦𑁨.

‘‘𑀦 𑀫𑁂 𑀲𑀼𑀢𑀁 𑀯𑀸 𑀤𑀺𑀝𑁆𑀞𑀁 𑀯𑀸, 𑀪𑀸𑀲𑀦𑁆𑀢𑁄 𑀫𑀸𑀦𑀼𑀲𑀺𑀁 𑀤𑀺𑀚𑁄;

𑀅𑀭𑀺𑀬𑀁 𑀩𑁆𑀭𑀼𑀯𑀸𑀦𑁄 [𑀩𑁆𑀭𑀽𑀳𑀦𑁆𑀢𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀓𑁆𑀓𑀗𑁆𑀕𑁄, 𑀘𑀚𑀦𑁆𑀢𑁄 𑀫𑀸𑀦𑀼𑀲𑀺𑀁 𑀕𑀺𑀭𑀁.

𑁧𑁦𑁩.

‘‘𑀓𑀺𑀦𑁆𑀦𑀼 𑀢𑀸𑀬𑀁 𑀤𑀺𑀚𑁄 𑀳𑁄𑀢𑀺, 𑀫𑀼𑀢𑁆𑀢𑁄 𑀩𑀤𑁆𑀥𑀁 𑀉𑀧𑀸𑀲𑀲𑀺;

𑀑𑀳𑀸𑀬 𑀲𑀓𑀼𑀡𑀸 𑀬𑀦𑁆𑀢𑀺, 𑀓𑀺𑀁 𑀏𑀓𑁄 𑀅𑀯𑀳𑀻𑀬𑀲𑀺’’.

𑁧𑁦𑁪.

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

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

𑁧𑁦𑁫.

‘‘𑀫𑀳𑀸𑀕𑀡𑀸𑀬 𑀪𑀢𑁆𑀢𑀸 𑀫𑁂, 𑀫𑀸 𑀏𑀓𑁄 𑀩𑁆𑀬𑀲𑀦𑀁 𑀅𑀕𑀸;

𑀢𑀣𑀸 ¶ 𑀢𑀁 𑀲𑀫𑁆𑀫 𑀦𑁂𑀲𑀸𑀤, 𑀪𑀢𑁆𑀢𑀸𑀬𑀁 𑀅𑀪𑀺𑀢𑁄 𑀭𑀫𑁂’’.

𑁧𑁦𑁬.

‘‘𑀅𑀭𑀺𑀬𑀯𑀢𑁆𑀢𑀲𑀺 ¶ 𑀯𑀓𑁆𑀓𑀗𑁆𑀕, 𑀬𑁄 𑀧𑀺𑀡𑁆𑀟𑀫𑀧𑀘𑀸𑀬𑀲𑀺;

𑀘𑀚𑀸𑀫𑀺 𑀢𑁂 𑀢𑀁 𑀪𑀢𑁆𑀢𑀸𑀭𑀁, 𑀕𑀘𑁆𑀙𑀣𑀽𑀪𑁄 [𑀕𑀘𑁆𑀙𑀢𑀼 𑀪𑁄 (𑀧𑀻.)] 𑀬𑀣𑀸𑀲𑀼𑀔𑀁’’.

𑁧𑁦𑁭.

‘‘𑀲𑀘𑁂 𑀅𑀢𑁆𑀢𑀧𑁆𑀧𑀬𑁄𑀕𑁂𑀦, 𑀑𑀳𑀺𑀢𑁄 𑀳𑀁𑀲𑀧𑀓𑁆𑀔𑀺𑀦𑀁;

𑀧𑀝𑀺𑀕𑀡𑁆𑀳𑀸𑀫 𑀢𑁂 𑀲𑀫𑁆𑀫, 𑀏𑀢𑀁 𑀅𑀪𑀬𑀤𑀓𑁆𑀔𑀺𑀡𑀁.

𑁧𑁦𑁮.

‘‘𑀦𑁄 𑀘𑁂 𑀅𑀢𑁆𑀢𑀧𑁆𑀧𑀬𑁄𑀕𑁂𑀦, 𑀑𑀳𑀺𑀢𑁄 𑀳𑀁𑀲𑀧𑀓𑁆𑀔𑀺𑀦𑀁;

𑀅𑀦𑀺𑀲𑁆𑀲𑀭𑁄 𑀫𑀼𑀜𑁆𑀘𑀫𑀫𑁆𑀳𑁂, 𑀣𑁂𑀬𑁆𑀬𑀁 𑀓𑀬𑀺𑀭𑀸𑀲𑀺 𑀮𑀼𑀤𑁆𑀤𑀓’’.

𑁧𑁦𑁯.

‘‘𑀬𑀲𑁆𑀲 𑀢𑁆𑀯𑀁 𑀪𑀢𑀓𑁄 [𑀪𑀝𑀓𑁄 (𑀓.)] 𑀭𑀜𑁆𑀜𑁄, 𑀓𑀸𑀫𑀁 𑀢𑀲𑁆𑀲𑁂𑀯 𑀧𑀸𑀧𑀬;

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

𑁧𑁧𑁦.

‘‘𑀇𑀘𑁆𑀘𑁂𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁄 𑀦𑁂𑀲𑀸𑀤𑁄, 𑀳𑁂𑀫𑀯𑀡𑁆𑀡𑁂 𑀳𑀭𑀺𑀢𑁆𑀢𑀘𑁂;

𑀉𑀪𑁄 𑀳𑀢𑁆𑀣𑁂𑀳𑀺 𑀲𑀗𑁆𑀕𑀬𑁆𑀳 [𑀧𑀕𑁆𑀕𑀬𑁆𑀳 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀧𑀜𑁆𑀚𑀭𑁂 𑀅𑀚𑁆𑀛𑀯𑁄𑀤𑀳𑀺.

𑁧𑁧𑁧.

‘‘𑀢𑁂 𑀧𑀜𑁆𑀚𑀭𑀕𑀢𑁂 𑀧𑀓𑁆𑀔𑀻, 𑀉𑀪𑁄 𑀪𑀲𑁆𑀲𑀭𑀯𑀡𑁆𑀡𑀺𑀦𑁂;

𑀲𑀼𑀫𑀼𑀔𑀁 𑀥𑀢𑀭𑀝𑁆𑀞𑀜𑁆𑀘, 𑀮𑀼𑀤𑁆𑀤𑁄 𑀆𑀤𑀸𑀬 𑀧𑀓𑁆𑀓𑀫𑀺’’.

𑁧𑁧𑁨.

‘‘𑀳𑀭𑀻𑀬𑀫𑀸𑀦𑁄 ¶ 𑀥𑀢𑀭𑀝𑁆𑀞𑁄, 𑀲𑀼𑀫𑀼𑀔𑀁 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

𑀩𑀸𑀴𑁆𑀳𑀁 𑀪𑀸𑀬𑀸𑀫𑀺 𑀲𑀼𑀫𑀼𑀔, 𑀲𑀸𑀫𑀸𑀬 𑀮𑀓𑁆𑀔𑀡𑀽𑀭𑀼𑀬𑀸;

𑀅𑀲𑁆𑀫𑀸𑀓𑀁 𑀯𑀥𑀫𑀜𑁆𑀜𑀸𑀬, 𑀅𑀣𑀢𑁆𑀢𑀸𑀦𑀁 𑀯𑀥𑀺𑀲𑁆𑀲𑀢𑀺.

𑁧𑁧𑁩.

‘‘𑀧𑀸𑀓𑀳𑀁𑀲𑀸 𑀘 𑀲𑀼𑀫𑀼𑀔, 𑀲𑀼𑀳𑁂𑀫𑀸 𑀳𑁂𑀫𑀲𑀼𑀢𑁆𑀢𑀘𑀸;

𑀓𑁄𑀜𑁆𑀘𑀻 𑀲𑀫𑀼𑀤𑁆𑀤𑀢𑀻𑀭𑁂𑀯, 𑀓𑀧𑀡𑀸 𑀦𑀽𑀦 𑀭𑀼𑀘𑁆𑀙𑀢𑀺’’.

𑁧𑁧𑁪.

‘‘𑀏𑀯𑀁 𑀫𑀳𑀦𑁆𑀢𑁄 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀅𑀧𑁆𑀧𑀫𑁂𑀬𑁆𑀬𑁄 𑀫𑀳𑀸𑀕𑀡𑀻;

𑀏𑀓𑀺𑀢𑁆𑀣𑀺𑀫𑀦𑀼𑀲𑁄𑀘𑁂𑀬𑁆𑀬, 𑀦𑀬𑀺𑀤𑀁 𑀧𑀜𑁆𑀜𑀯𑀢𑀸𑀫𑀺𑀯.

𑁧𑁧𑁫.

‘‘𑀯𑀸𑀢𑁄𑀯 ¶ 𑀕𑀦𑁆𑀥𑀫𑀸𑀤𑁂𑀢𑀺, 𑀉𑀪𑀬𑀁 𑀙𑁂𑀓𑀧𑀸𑀧𑀓𑀁;

𑀩𑀸𑀮𑁄 𑀆𑀫𑀓𑀧𑀓𑁆𑀓𑀁𑀯, 𑀮𑁄𑀮𑁄 𑀅𑀦𑁆𑀥𑁄𑀯 𑀆𑀫𑀺𑀲𑀁.

𑁧𑁧𑁬.

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

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

𑁧𑁧𑁭.

‘‘𑀅𑀟𑁆𑀠𑀼𑀫𑁆𑀫𑀢𑁆𑀢𑁄 𑀉𑀤𑀻𑀭𑁂𑀲𑀺, 𑀬𑁄 𑀲𑁂𑀬𑁆𑀬𑀸 𑀫𑀜𑁆𑀜𑀲𑀺𑀢𑁆𑀣𑀺𑀬𑁄;

𑀩𑀳𑀼𑀲𑀸𑀥𑀸𑀭𑀡𑀸 𑀳𑁂𑀢𑀸, 𑀲𑁄𑀡𑁆𑀟𑀸𑀦𑀁𑀯 𑀲𑀼𑀭𑀸𑀖𑀭𑀁.

𑁧𑁧𑁮.

‘‘𑀫𑀸𑀬𑀸 ¶ 𑀘𑁂𑀲𑀸 𑀫𑀭𑀻𑀘𑀻 𑀘, 𑀲𑁄𑀓𑁄 𑀭𑁄𑀕𑁄 𑀘𑀼𑀧𑀤𑁆𑀤𑀯𑁄;

𑀔𑀭𑀸 𑀘 𑀩𑀦𑁆𑀥𑀦𑀸 𑀘𑁂𑀢𑀸, 𑀫𑀘𑁆𑀘𑀼𑀧𑀸𑀲𑀸 𑀕𑀼𑀳𑀸𑀲𑀬𑀸 [𑀧𑀘𑁆𑀘𑀼𑀧𑀸𑀲𑁄 𑀕𑀼𑀳𑀸𑀲𑀬𑁄 (𑀲𑀻. 𑀧𑀻.)];

𑀢𑀸𑀲𑀼 𑀬𑁄 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀧𑁄𑀲𑁄, 𑀲𑁄 𑀦𑀭𑁂𑀲𑀼 𑀦𑀭𑀸𑀥𑀫𑁄’’.

𑁧𑁧𑁯.

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

𑀫𑀳𑀸𑀪𑀽𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀦𑀸𑀫, 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀉𑀤𑀧𑀚𑁆𑀚𑀺𑀲𑀼𑀁.

𑁧𑁨𑁦.

‘‘𑀔𑀺𑀟𑁆𑀟𑀸 𑀧𑀡𑀺𑀳𑀺𑀢𑀸 𑀢𑁆𑀬𑀸𑀲𑀼, 𑀭𑀢𑀺 𑀢𑁆𑀬𑀸𑀲𑀼 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸;

𑀩𑀻𑀚𑀸𑀦𑀺 𑀢𑁆𑀬𑀸𑀲𑀼 𑀭𑀽𑀳𑀦𑁆𑀢𑀺, 𑀬𑀤𑀺𑀤𑀁 𑀲𑀢𑁆𑀢𑀸 𑀧𑀚𑀸𑀬𑀭𑁂;

𑀢𑀸𑀲𑀼 𑀓𑁄 𑀦𑀺𑀩𑁆𑀩𑀺𑀤𑁂 [𑀦𑀺𑀩𑁆𑀩𑀺𑀚𑁂 (𑀓.)] 𑀧𑁄𑀲𑁄, 𑀧𑀸𑀡𑀫𑀸𑀲𑀚𑁆𑀚 𑀧𑀸𑀡𑀺𑀪𑀺 [𑀧𑀸𑀡𑀳𑀺 (𑀲𑀻.)].

𑁧𑁨𑁧.

‘‘𑀢𑁆𑀯𑀫𑁂𑀯 𑀦𑀜𑁆𑀜𑁄 𑀲𑀼𑀫𑀼𑀔, 𑀣𑀻𑀦𑀁 𑀅𑀢𑁆𑀣𑁂𑀲𑀼 𑀬𑀼𑀜𑁆𑀚𑀲𑀺;

𑀢𑀲𑁆𑀲 𑀢𑁆𑀬𑀚𑁆𑀚 𑀪𑀬𑁂 𑀚𑀸𑀢𑁂, 𑀪𑀻𑀢𑁂𑀦 𑀚𑀸𑀬𑀢𑁂 𑀫𑀢𑀺.

𑁧𑁨𑁨.

‘‘𑀲𑀩𑁆𑀩𑁄 𑀳𑀺 𑀲𑀁𑀲𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀪𑀬𑀁 𑀪𑀻𑀭𑀼 𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀢𑀺;

𑀧𑀡𑁆𑀟𑀺𑀢𑀸 𑀘 𑀫𑀳𑀦𑁆𑀢𑀸𑀦𑁄 [𑀫𑀳𑀢𑁆𑀢𑀸𑀦𑁄 (𑀲𑀻.)], 𑀅𑀢𑁆𑀣𑁂 𑀬𑀼𑀜𑁆𑀚𑀦𑁆𑀢𑀺 𑀤𑀼𑀬𑁆𑀬𑀼𑀚𑁂.

𑁧𑁨𑁩.

‘‘𑀏𑀢𑀤𑀢𑁆𑀣𑀸𑀬 𑀭𑀸𑀚𑀸𑀦𑁄, 𑀲𑀽𑀭𑀫𑀺𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀫𑀦𑁆𑀢𑀺𑀦𑀁;

𑀧𑀝𑀺𑀩𑀸𑀳𑀢𑀺 𑀬𑀁 𑀲𑀽𑀭𑁄, 𑀆𑀧𑀤𑀁 𑀅𑀢𑁆𑀢𑀧𑀭𑀺𑀬𑀸𑀬𑀁.

𑁧𑁨𑁪.

‘‘𑀫𑀸 ¶ 𑀦𑁄 𑀅𑀚𑁆𑀚 𑀯𑀺𑀓𑀦𑁆𑀢𑀺𑀁𑀲𑀼, 𑀭𑀜𑁆𑀜𑁄 𑀲𑀽𑀤𑀸 𑀫𑀳𑀸𑀦𑀲𑁂;

𑀢𑀣𑀸 𑀳𑀺 𑀯𑀡𑁆𑀡𑁄 𑀧𑀢𑁆𑀢𑀸𑀦𑀁, 𑀨𑀮𑀁 𑀯𑁂𑀴𑀼𑀁𑀯 𑀢𑀁 𑀯𑀥𑀺.

𑁧𑁨𑁫.

‘‘𑀫𑀼𑀢𑁆𑀢𑁄𑀧𑀺 ¶ 𑀦 𑀇𑀘𑁆𑀙𑀺 [𑀦𑀺𑀘𑁆𑀙𑀲𑀺 (𑀓.)] 𑀉𑀟𑁆𑀟𑁂𑀢𑀼𑀁 [𑀑𑀟𑁆𑀟𑁂𑀢𑀼𑀁 (𑀲𑀻.)], 𑀲𑀬𑀁 𑀩𑀦𑁆𑀥𑀁 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀲𑁄𑀧𑀚𑁆𑀚 𑀲𑀁𑀲𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀅𑀢𑁆𑀣𑀁 𑀕𑀡𑁆𑀳𑀸𑀳𑀺 𑀫𑀸 𑀫𑀼𑀔𑀁’’.

𑁧𑁨𑁬.

‘‘𑀲𑁄 𑀢𑀁 [𑀢𑁆𑀯𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀬𑁄𑀕𑀁 𑀧𑀬𑀼𑀜𑁆𑀚𑀲𑁆𑀲𑀼, 𑀬𑀼𑀢𑁆𑀢𑀁 𑀥𑀫𑁆𑀫𑀽𑀧𑀲𑀁𑀳𑀺𑀢𑀁 [𑀥𑀫𑁆𑀫𑁄𑀧𑀲𑀜𑁆𑀳𑀺𑀢𑀁 (𑀓.)];

𑀢𑀯 𑀧𑀭𑀺𑀬𑀸𑀧𑀤𑀸𑀦𑁂𑀦, 𑀫𑀫 𑀧𑀸𑀡𑁂𑀲𑀦𑀁 𑀘𑀭’’.

𑁧𑁨𑁭.

‘‘𑀫𑀸 𑀪𑀸𑀬𑀺 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀦 𑀳𑀺 𑀪𑀸𑀬𑀦𑁆𑀢𑀺 𑀢𑀸𑀤𑀺𑀲𑀸;

𑀅𑀳𑀁 𑀬𑁄𑀕𑀁 𑀧𑀬𑀼𑀜𑁆𑀚𑀺𑀲𑁆𑀲𑀁, 𑀬𑀼𑀢𑁆𑀢𑀁 𑀥𑀫𑁆𑀫𑀽𑀧𑀲𑀁𑀳𑀺𑀢𑀁 [𑀥𑀫𑁆𑀫𑁄𑀧𑀲𑀜𑁆𑀳𑀺𑀢𑀁 (𑀓.)];

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

𑁧𑁨𑁮.

‘‘𑀲𑁄 [𑀲 (𑀲𑀻.)] 𑀮𑀼𑀤𑁆𑀤𑁄 𑀳𑀁𑀲𑀓𑀸𑀚𑁂𑀦 [𑀳𑀁𑀲𑀓𑀸𑀘𑁂𑀦 (𑀧𑀻.)], 𑀭𑀸𑀚𑀤𑁆𑀯𑀸𑀭𑀁 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀧𑀝𑀺𑀯𑁂𑀤𑁂𑀣 𑀫𑀁 𑀭𑀜𑁆𑀜𑁄, 𑀥𑀢𑀭𑀝𑁆𑀞𑀸𑀬𑀫𑀸𑀕𑀢𑁄’’.

𑁧𑁨𑁯.

‘‘𑀢𑁂 ¶ 𑀤𑀺𑀲𑁆𑀯𑀸 𑀧𑀼𑀜𑁆𑀜𑀲𑀁𑀓𑀸𑀲𑁂, 𑀉𑀪𑁄 𑀮𑀓𑁆𑀔𑀡𑀲𑀫𑁆𑀫𑀢𑁂 [𑀮𑀓𑁆𑀔𑀜𑁆𑀜𑀸𑀲𑀫𑁆𑀫𑀢𑁂 (𑀲𑀻. 𑀧𑀻.)];

𑀔𑀮𑀼 𑀲𑀁𑀬𑀫𑀦𑁄 𑀭𑀸𑀚𑀸, 𑀅𑀫𑀘𑁆𑀘𑁂 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣.

𑁧𑁩𑁦.

‘‘𑀤𑁂𑀣 𑀮𑀼𑀤𑁆𑀤𑀲𑁆𑀲 𑀯𑀢𑁆𑀣𑀸𑀦𑀺, 𑀅𑀦𑁆𑀦𑀁 𑀧𑀸𑀦𑀜𑁆𑀘 𑀪𑁄𑀚𑀦𑀁;

𑀓𑀸𑀫𑀁 𑀓𑀭𑁄 𑀳𑀺𑀭𑀜𑁆𑀜𑀲𑁆𑀲, 𑀬𑀸𑀯𑀦𑁆𑀢𑁄 𑀏𑀲 𑀇𑀘𑁆𑀙𑀢𑀺’’.

𑁧𑁩𑁧.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸 𑀮𑀼𑀤𑁆𑀤𑀁 𑀧𑀲𑀦𑁆𑀦𑀢𑁆𑀢𑀁, 𑀓𑀸𑀲𑀺𑀭𑀸𑀚𑀸 𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

𑀬𑀤𑁆𑀬𑀸𑀬𑀁 [𑀬𑀤𑀸𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀲𑀫𑁆𑀫 𑀔𑁂𑀫𑀓, 𑀧𑀼𑀡𑁆𑀡𑀸 𑀳𑀁𑀲𑁂𑀳𑀺 𑀢𑀺𑀝𑁆𑀞𑀢𑀺.

𑁧𑁩𑁨.

‘‘𑀓𑀣𑀁 𑀭𑀼𑀘𑀺𑀫𑀚𑁆𑀛𑀕𑀢𑀁, 𑀧𑀸𑀲𑀳𑀢𑁆𑀣𑁄 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀑𑀓𑀺𑀡𑁆𑀡𑀁 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀳𑀺, 𑀦𑀺𑀫𑁆𑀫𑀚𑁆𑀛𑀺𑀫𑀁 [𑀦𑀺𑀫𑀚𑁆𑀛𑀺𑀫𑀁 (𑀲𑀻. 𑀧𑀻. 𑀓.)] 𑀓𑀣𑀁 𑀕𑀳𑀺’’.

𑁧𑁩𑁩.

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

𑀧𑀤𑀫𑁂𑀢𑀲𑁆𑀲 ¶ 𑀅𑀦𑁆𑀯𑁂𑀲𑀁, 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄 𑀖𑀝𑀲𑁆𑀲𑀺𑀢𑁄.

𑁧𑁩𑁪.

‘‘𑀅𑀣𑀲𑁆𑀲 𑀧𑀤𑀫𑀤𑁆𑀤𑀓𑁆𑀔𑀺𑀁, 𑀘𑀭𑀢𑁄 𑀅𑀤𑀦𑁂𑀲𑀦𑀁;

𑀢𑀢𑁆𑀣𑀸𑀳𑀁 𑀑𑀤𑀳𑀺𑀁 𑀧𑀸𑀲𑀁, 𑀏𑀯𑀁 𑀢𑀁 [𑀏𑀯𑁂𑀢𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀤𑀺𑀚𑀫𑀕𑁆𑀕𑀳𑀺𑀁’’.

𑁧𑁩𑁫.

‘‘𑀮𑀼𑀤𑁆𑀤 𑀤𑁆𑀯𑁂 𑀇𑀫𑁂 𑀲𑀓𑀼𑀡𑀸, 𑀅𑀣 𑀏𑀓𑁄𑀢𑀺 𑀪𑀸𑀲𑀲𑀺;

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

𑁧𑁩𑁬.

‘‘𑀬𑀲𑁆𑀲 𑀮𑁄𑀳𑀺𑀢𑀓𑀸 𑀢𑀸𑀮𑀸, 𑀢𑀧𑀦𑀻𑀬𑀦𑀺𑀪𑀸 𑀲𑀼𑀪𑀸;

𑀉𑀭𑀁 𑀲𑀁𑀳𑀘𑁆𑀘 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺, 𑀲𑁄 𑀫𑁂 𑀩𑀦𑁆𑀥𑀁 𑀉𑀧𑀸𑀕𑀫𑀺.

𑁧𑁩𑁭.

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

𑀅𑀭𑀺𑀬𑀁 𑀩𑁆𑀭𑀼𑀯𑀸𑀦𑁄 𑀅𑀝𑁆𑀞𑀸𑀲𑀺, 𑀘𑀚𑀦𑁆𑀢𑁄 𑀫𑀸𑀦𑀼𑀲𑀺𑀁 𑀕𑀺𑀭𑀁’’.

𑁧𑁩𑁮.

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

𑀅𑀤𑀼 𑀫𑁂 𑀧𑀭𑀺𑀲𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀪𑀬𑀸 𑀪𑀻𑀢𑁄 𑀦 𑀪𑀸𑀲𑀲𑀺’’.

𑁧𑁩𑁯.

‘‘𑀦𑀸𑀳𑀁 ¶ 𑀓𑀸𑀲𑀺𑀧𑀢𑀺 𑀪𑀻𑀢𑁄, 𑀑𑀕𑀬𑁆𑀳 𑀧𑀭𑀺𑀲𑀁 𑀢𑀯;

𑀦𑀸𑀳𑀁 𑀪𑀬𑀸 𑀦 𑀪𑀸𑀲𑀺𑀲𑁆𑀲𑀁, 𑀯𑀸𑀓𑁆𑀬𑀁 𑀅𑀢𑁆𑀣𑀫𑁆𑀳𑀺 𑀢𑀸𑀤𑀺𑀲𑁂’’.

𑁧𑁪𑁦.

‘‘𑀦 𑀢𑁂 𑀅𑀪𑀺𑀲𑀭𑀁 𑀧𑀲𑁆𑀲𑁂, 𑀦 𑀭𑀣𑁂 𑀦𑀧𑀺 𑀧𑀢𑁆𑀢𑀺𑀓𑁂;

𑀦𑀸𑀲𑁆𑀲 𑀘𑀫𑁆𑀫𑀁 𑀯 𑀓𑀻𑀝𑀁 𑀯𑀸, 𑀯𑀫𑁆𑀫𑀺𑀢𑁂 𑀘 𑀥𑀦𑀼𑀕𑁆𑀕𑀳𑁂.

𑁧𑁪𑁧.

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

𑀑𑀓𑀺𑀡𑁆𑀡𑀧𑀭𑀺𑀔𑀁 𑀤𑀼𑀕𑁆𑀕𑀁, 𑀤𑀴𑁆𑀳𑀫𑀝𑁆𑀝𑀸𑀮𑀓𑁄𑀝𑁆𑀞𑀓𑀁;

𑀬𑀢𑁆𑀣 𑀧𑀯𑀺𑀝𑁆𑀞𑁄 𑀲𑀼𑀫𑀼𑀔, 𑀪𑀸𑀬𑀺𑀢𑀩𑁆𑀩𑀁 𑀦 𑀪𑀸𑀬𑀲𑀺’’.

𑁧𑁪𑁨.

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

𑀅𑀧𑀣𑁂𑀦 𑀧𑀣𑀁 𑀬𑀸𑀫, 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂𑀘𑀭𑀸 𑀫𑀬𑀁.

𑁧𑁪𑁩.

‘‘𑀲𑀼𑀢𑀸 ¶ 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑀸 𑀢𑁆𑀬𑀫𑁆𑀳𑀸, 𑀦𑀺𑀧𑀼𑀡𑀸 𑀅𑀢𑁆𑀣𑀘𑀺𑀦𑁆𑀢𑀓𑀸 [𑀘𑀢𑁆𑀣𑀘𑀺𑀦𑁆𑀢𑀓𑀸 (𑀓.)];

𑀪𑀸𑀲𑁂𑀫𑀢𑁆𑀣𑀯𑀢𑀺𑀁 𑀯𑀸𑀘𑀁, 𑀲𑀘𑁆𑀘𑁂 𑀘𑀲𑁆𑀲 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑁧𑁪𑁪.

‘‘𑀓𑀺𑀜𑁆𑀘 𑀢𑀼𑀬𑁆𑀳𑀁 𑀅𑀲𑀘𑁆𑀘𑀲𑁆𑀲, 𑀅𑀦𑀭𑀺𑀬𑀲𑁆𑀲 𑀓𑀭𑀺𑀲𑁆𑀲𑀢𑀺;

𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀺𑀲𑁆𑀲 𑀮𑀼𑀤𑁆𑀤𑀲𑁆𑀲, 𑀪𑀡𑀺𑀢𑀫𑁆𑀧𑀺 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁’’.

𑁧𑁪𑁫.

‘‘𑀢𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀯𑀘𑀦𑀸, 𑀇𑀫𑀁 𑀔𑁂𑀫𑀫𑀓𑀸𑀭𑀬𑀺 [𑀔𑁂𑀫𑀺𑀓𑀸𑀭𑀬𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀅𑀪𑀬𑀜𑁆𑀘 𑀢𑀬𑀸 𑀖𑀼𑀝𑁆𑀞𑀁, 𑀇𑀫𑀸𑀬𑁄 𑀤𑀲𑀥𑀸 𑀤𑀺𑀲𑀸.

𑁧𑁪𑁬.

‘‘𑀑𑀕𑀬𑁆𑀳 𑀢𑁂 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀺𑀁, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁄𑀤𑀓𑀁 𑀲𑀼𑀘𑀺𑀁;

𑀧𑀳𑀽𑀢𑀁 𑀘𑀸𑀤𑀦𑀁 𑀢𑀢𑁆𑀣, 𑀅𑀳𑀺𑀁𑀲𑀸 𑀘𑁂𑀢𑁆𑀣 𑀧𑀓𑁆𑀔𑀺𑀦𑀁.

𑁧𑁪𑁭.

‘‘𑀇𑀤𑀁 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑀁, 𑀆𑀕𑀢𑀫𑁆𑀳 𑀢𑀯𑀦𑁆𑀢𑀺𑀓𑁂;

𑀢𑁂 𑀢𑁂 𑀩𑀦𑁆𑀥𑀲𑁆𑀫 𑀧𑀸𑀲𑁂𑀦, 𑀏𑀢𑀁 𑀢𑁂 𑀪𑀸𑀲𑀺𑀢𑀁 𑀫𑀼𑀲𑀸.

𑁧𑁪𑁮.

‘‘𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀁 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁆𑀯𑀸, 𑀇𑀘𑁆𑀙𑀸𑀮𑁄𑀪𑀜𑁆𑀘 𑀧𑀸𑀧𑀓𑀁;

𑀉𑀪𑁄 𑀲𑀦𑁆𑀥𑀺𑀫𑀢𑀺𑀓𑁆𑀓𑀫𑁆𑀫, 𑀅𑀲𑀸𑀢𑀁 𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀺’’.

𑁧𑁪𑁯.

‘‘𑀦𑀸𑀧𑀭𑀚𑁆𑀛𑀸𑀫 𑀲𑀼𑀫𑀼𑀔, 𑀦𑀧𑀺 𑀮𑁄𑀪𑀸𑀯 𑀫𑀕𑁆𑀕𑀳𑀺𑀁;

𑀲𑀼𑀢𑀸 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑀸𑀢𑁆𑀬𑀢𑁆𑀣, 𑀦𑀺𑀧𑀼𑀡𑀸 𑀅𑀢𑁆𑀣𑀘𑀺𑀦𑁆𑀢𑀓𑀸.

𑁧𑁫𑁦.

‘‘𑀅𑀧𑁆𑀧𑁂𑀯𑀢𑁆𑀣𑀯𑀢𑀺𑀁 𑀯𑀸𑀘𑀁, 𑀩𑁆𑀬𑀸𑀳𑀭𑁂𑀬𑁆𑀬𑀼𑀁 [𑀩𑁆𑀬𑀸𑀓𑀭𑁂𑀬𑁆𑀬𑀼𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀇𑀥𑀸𑀕𑀢𑀸;

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

𑁧𑁫𑁧.

‘‘𑀦𑁂𑀯 𑀪𑀻𑀢𑀸 [𑀪𑀽𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀓𑀸𑀲𑀺𑀧𑀢𑀺, 𑀉𑀧𑀦𑀻𑀢𑀲𑁆𑀫𑀺 𑀚𑀻𑀯𑀺𑀢𑁂;

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

𑁧𑁫𑁨.

‘‘𑀬𑁄 𑀫𑀺𑀕𑁂𑀦 𑀫𑀺𑀕𑀁 𑀳𑀦𑁆𑀢𑀺, 𑀧𑀓𑁆𑀔𑀺𑀁 𑀯𑀸 𑀧𑀦 𑀧𑀓𑁆𑀔𑀺𑀦𑀸;

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

𑁧𑁫𑁩.

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

𑀉𑀪𑁄 𑀲𑁄 𑀥𑀁𑀲𑀢𑁂 𑀮𑁄𑀓𑀸, 𑀇𑀥 𑀘𑁂𑀯 𑀧𑀭𑀢𑁆𑀣 𑀘.

𑁧𑁫𑁪.

‘‘𑀦 𑀫𑀚𑁆𑀚𑁂𑀣 𑀬𑀲𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀦 𑀩𑁆𑀬𑀸𑀥𑁂 [𑀩𑁆𑀬𑀣𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀢𑁆𑀢𑀲𑀁𑀲𑀬𑀁;

𑀯𑀸𑀬𑀫𑁂𑀣𑁂𑀯 𑀓𑀺𑀘𑁆𑀘𑁂𑀲𑀼, 𑀲𑀁𑀯𑀭𑁂 𑀯𑀺𑀯𑀭𑀸𑀦𑀺 𑀘.

𑁧𑁫𑁫.

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

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀏𑀯𑀁𑀢𑁂 [𑀏𑀯𑁂𑀢𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀢𑀺𑀤𑀺𑀯𑀁 𑀕𑀢𑀸.

𑁧𑁫𑁬.

‘‘𑀇𑀤𑀁 𑀲𑀼𑀢𑁆𑀯𑀸 𑀓𑀸𑀲𑀺𑀧𑀢𑀺, 𑀥𑀫𑁆𑀫𑀫𑀢𑁆𑀢𑀦𑀺 𑀧𑀸𑀮𑀬;

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

𑁧𑁫𑁭.

‘‘𑀆𑀳𑀭𑀦𑁆𑀢𑀼𑀤𑀓𑀁 𑀧𑀚𑁆𑀚𑀁, 𑀆𑀲𑀦𑀜𑁆𑀘 𑀫𑀳𑀸𑀭𑀳𑀁;

𑀧𑀜𑁆𑀚𑀭𑀢𑁄 𑀧𑀫𑁄𑀓𑁆𑀔𑀸𑀫𑀺, 𑀥𑀢𑀭𑀝𑁆𑀞𑀁 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀁.

𑁧𑁫𑁮.

‘‘𑀢𑀜𑁆𑀘 𑀲𑁂𑀦𑀸𑀧𑀢𑀺𑀁 𑀥𑀻𑀭𑀁, 𑀦𑀺𑀧𑀼𑀡𑀁 𑀅𑀢𑁆𑀣𑀘𑀺𑀦𑁆𑀢𑀓𑀁;

𑀬𑁄 𑀲𑀼𑀔𑁂 𑀲𑀼𑀔𑀺𑀢𑁄 𑀭𑀜𑁆𑀜𑁂 [𑀭𑀜𑁆𑀜𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)], 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁂 𑀳𑁄𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁄.

𑁧𑁫𑁯.

‘‘𑀏𑀤𑀺𑀲𑁄 𑀔𑁄 𑀅𑀭𑀳𑀢𑀺, 𑀧𑀺𑀡𑁆𑀟𑀫𑀲𑁆𑀦𑀸𑀢𑀼 𑀪𑀢𑁆𑀢𑀼𑀦𑁄;

𑀬𑀣𑀸𑀬𑀁 𑀲𑀼𑀫𑀼𑀔𑁄 𑀭𑀜𑁆𑀜𑁄, 𑀧𑀸𑀡𑀲𑀸𑀥𑀸𑀭𑀡𑁄 𑀲𑀔𑀸’’.

𑁧𑁬𑁦.

‘‘𑀧𑀻𑀞𑀜𑁆𑀘 𑀲𑀩𑁆𑀩𑀲𑁄𑀯𑀡𑁆𑀡𑀁, 𑀅𑀝𑁆𑀞𑀧𑀸𑀤𑀁 𑀫𑀦𑁄𑀭𑀫𑀁;

𑀫𑀝𑁆𑀞𑀁 𑀓𑀸𑀲𑀺𑀓𑀫𑀢𑁆𑀣𑀦𑁆𑀦𑀁 [𑀓𑀸𑀲𑀺𑀓𑀧𑀢𑁆𑀣𑀺𑀡𑁆𑀡𑀁 (𑀲𑀻.), 𑀓𑀸𑀲𑀺𑀓𑀯𑀢𑁆𑀣𑀺𑀦𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀥𑀢𑀭𑀝𑁆𑀞𑁄 𑀉𑀧𑀸𑀯𑀺𑀲𑀺.

𑁧𑁬𑁧.

‘‘𑀓𑁄𑀘𑁆𑀙𑀜𑁆𑀘 𑀲𑀩𑁆𑀩𑀲𑁄𑀯𑀡𑁆𑀡𑀁, 𑀯𑁂𑀬𑁆𑀬𑀕𑁆𑀖𑀧𑀭𑀺𑀲𑀺𑀩𑁆𑀩𑀺𑀢𑀁;

𑀲𑀼𑀫𑀼𑀔𑁄 𑀅𑀚𑁆𑀛𑀼𑀧𑀸𑀯𑁂𑀓𑁆𑀔𑀺, 𑀥𑀢𑀭𑀝𑁆𑀞𑀲𑁆𑀲𑀦𑀦𑁆𑀢𑀭𑀸 [𑀅𑀦𑀦𑁆𑀢𑀭𑀁 (𑀲𑀻.)].

𑁧𑁬𑁨.

‘‘𑀢𑁂𑀲𑀁 𑀓𑀜𑁆𑀘𑀦𑀧𑀢𑁆𑀢𑁂𑀳𑀺, 𑀧𑀼𑀣𑀽 𑀆𑀤𑀸𑀬 𑀓𑀸𑀲𑀺𑀬𑁄;

𑀳𑀁𑀲𑀸𑀦𑀁 𑀅𑀪𑀺𑀳𑀸𑀭𑁂𑀲𑀼𑀁, 𑀅𑀕𑁆𑀕𑀭𑀜𑁆𑀜𑁄 𑀧𑀯𑀸𑀲𑀺𑀢𑀁’’.

𑁧𑁬𑁩.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸 ¶ 𑀅𑀪𑀺𑀳𑀝𑀁 𑀅𑀕𑁆𑀕𑀁, 𑀓𑀸𑀲𑀺𑀭𑀸𑀚𑁂𑀦 𑀧𑁂𑀲𑀺𑀢𑀁;

𑀓𑀼𑀲𑀮𑁄 𑀔𑀢𑁆𑀢𑀥𑀫𑁆𑀫𑀸𑀦𑀁, 𑀢𑀢𑁄 𑀧𑀼𑀘𑁆𑀙𑀺 𑀅𑀦𑀦𑁆𑀢𑀭𑀸.

𑁧𑁬𑁪.

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

𑀓𑀘𑁆𑀘𑀺 𑀭𑀝𑁆𑀞𑀫𑀺𑀤𑀁 𑀨𑀻𑀢𑀁, 𑀥𑀫𑁆𑀫𑁂𑀦 𑀫𑀦𑀼𑀲𑀸𑀲𑀲𑀺’’.

𑁧𑁬𑁫.

‘‘𑀓𑀼𑀲𑀮𑀜𑁆𑀘𑁂𑀯 ¶ 𑀫𑁂 𑀳𑀁𑀲, 𑀅𑀣𑁄 𑀳𑀁𑀲 𑀅𑀦𑀸𑀫𑀬𑀁;

𑀅𑀣𑁄 𑀭𑀝𑁆𑀞𑀫𑀺𑀤𑀁 𑀨𑀻𑀢𑀁, 𑀥𑀫𑁆𑀫𑁂𑀦𑀁 𑀫𑀦𑀼𑀲𑀸𑀲𑀳𑀁.

𑁧𑁬𑁬.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀪𑁄𑀢𑁄 𑀅𑀫𑀘𑁆𑀘𑁂𑀲𑀼, 𑀤𑁄𑀲𑁄 𑀓𑁄𑀘𑀺 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀓𑀘𑁆𑀘𑀺 𑀘 𑀢𑁂 𑀢𑀯𑀢𑁆𑀣𑁂𑀲𑀼, 𑀦𑀸𑀯𑀓𑀗𑁆𑀔𑀦𑁆𑀢𑀺 𑀚𑀻𑀯𑀺𑀢𑀁’’.

𑁧𑁬𑁭.

‘‘𑀅𑀣𑁄𑀧𑀺 𑀫𑁂 𑀅𑀫𑀘𑁆𑀘𑁂𑀲𑀼, 𑀤𑁄𑀲𑁄 𑀓𑁄𑀘𑀺 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀅𑀣𑁄𑀧𑀺 𑀢𑁂 𑀫𑀫𑀢𑁆𑀣𑁂𑀲𑀼, 𑀦𑀸𑀯𑀓𑀗𑁆𑀔𑀦𑁆𑀢𑀺 𑀚𑀻𑀯𑀺𑀢𑀁’’.

𑁧𑁬𑁮.

‘‘𑀓𑀘𑁆𑀘𑀺 ¶ 𑀢𑁂 𑀲𑀸𑀤𑀺𑀲𑀻 𑀪𑀭𑀺𑀬𑀸, 𑀅𑀲𑁆𑀲𑀯𑀸 𑀧𑀺𑀬𑀪𑀸𑀡𑀺𑀦𑀻;

𑀧𑀼𑀢𑁆𑀢𑀭𑀽𑀧𑀬𑀲𑀽𑀧𑁂𑀢𑀸, 𑀢𑀯 𑀙𑀦𑁆𑀤𑀯𑀲𑀸𑀦𑀼𑀕𑀸’’.

𑁧𑁬𑁯.

‘‘𑀅𑀣𑁄 𑀫𑁂 𑀲𑀸𑀤𑀺𑀲𑀻 𑀪𑀭𑀺𑀬𑀸, 𑀅𑀲𑁆𑀲𑀯𑀸 𑀧𑀺𑀬𑀪𑀸𑀡𑀺𑀦𑀻;

𑀧𑀼𑀢𑁆𑀢𑀭𑀽𑀧𑀬𑀲𑀽𑀧𑁂𑀢𑀸, 𑀫𑀫 𑀙𑀦𑁆𑀤𑀯𑀲𑀸𑀦𑀼𑀕𑀸’’.

𑁧𑁭𑁦.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀭𑀝𑁆𑀞𑀁 𑀅𑀦𑀼𑀧𑁆𑀧𑀻𑀴𑀁, 𑀅𑀓𑀼𑀢𑁄𑀘𑀺𑀉𑀧𑀤𑁆𑀤𑀯𑀁;

𑀅𑀲𑀸𑀳𑀲𑁂𑀦 𑀥𑀫𑁆𑀫𑁂𑀦, 𑀲𑀫𑁂𑀦 𑀫𑀦𑀼𑀲𑀸𑀲𑀲𑀺’’.

𑁧𑁭𑁧.

‘‘𑀅𑀣𑁄 𑀭𑀝𑁆𑀞𑀁 𑀅𑀦𑀼𑀧𑁆𑀧𑀻𑀴𑀁, 𑀅𑀓𑀼𑀢𑁄𑀘𑀺𑀉𑀧𑀤𑁆𑀤𑀯𑀁;

𑀅𑀲𑀸𑀳𑀲𑁂𑀦 𑀥𑀫𑁆𑀫𑁂𑀦, 𑀲𑀫𑁂𑀦 𑀫𑀦𑀼𑀲𑀸𑀲𑀳𑀁’’.

𑁧𑁭𑁨.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀲𑀦𑁆𑀢𑁄 𑀅𑀧𑀘𑀺𑀢𑀸, 𑀅𑀲𑀦𑁆𑀢𑁄 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀺𑀢𑀸;

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

𑁧𑁭𑁩.

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

𑀥𑀫𑁆𑀫𑀫𑁂𑀯𑀸𑀦𑀼𑀯𑀢𑁆𑀢𑀸𑀫𑀺, 𑀅𑀥𑀫𑁆𑀫𑁄 𑀫𑁂 𑀦𑀺𑀭𑀗𑁆𑀓𑀢𑁄’’.

𑁧𑁭𑁪.

‘‘𑀓𑀘𑁆𑀘𑀺 𑀦𑀸𑀦𑀸𑀕𑀢𑀁 [𑀓𑀘𑁆𑀘𑀺 𑀦𑀼𑀦𑀸𑀕𑀢𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀤𑀻𑀖𑀁, 𑀲𑀫𑀯𑁂𑀓𑁆𑀔𑀲𑀺 𑀔𑀢𑁆𑀢𑀺𑀬;

𑀓𑀘𑁆𑀘𑀺 𑀫𑀢𑁆𑀢𑁄 [𑀦 𑀫𑀢𑁆𑀢𑁄 (𑀲𑀻.)] 𑀫𑀤𑀦𑀻𑀬𑁂, 𑀧𑀭𑀮𑁄𑀓𑀁 𑀦 𑀲𑀦𑁆𑀢𑀲𑀺’’.

𑁧𑁭𑁫.

‘‘𑀦𑀸𑀳𑀁 𑀅𑀦𑀸𑀕𑀢𑀁 [𑀅𑀳𑀁 𑀅𑀦𑀸𑀕𑀢𑀁 (𑀲𑁆𑀬𑀸.)] 𑀤𑀻𑀖𑀁, 𑀲𑀫𑀯𑁂𑀓𑁆𑀔𑀸𑀫𑀺 𑀧𑀓𑁆𑀔𑀺𑀫;

𑀞𑀺𑀢𑁄 𑀤𑀲𑀲𑀼 𑀥𑀫𑁆𑀫𑁂𑀲𑀼, 𑀧𑀭𑀮𑁄𑀓𑀁 𑀦 𑀲𑀦𑁆𑀢𑀲𑁂 [𑀲𑀦𑁆𑀢𑀲𑀺𑀁 (𑀲𑁆𑀬𑀸.)].

𑁧𑁭𑁬.

‘‘𑀤𑀸𑀦𑀁 𑀲𑀻𑀮𑀁 𑀧𑀭𑀺𑀘𑁆𑀘𑀸𑀕𑀁, 𑀅𑀚𑁆𑀚𑀯𑀁 𑀫𑀤𑁆𑀤𑀯𑀁 𑀢𑀧𑀁;

𑀅𑀓𑁆𑀓𑁄𑀥𑀁 𑀅𑀯𑀺𑀳𑀺𑀁𑀲𑀜𑁆𑀘, 𑀔𑀦𑁆𑀢𑀺𑀜𑁆𑀘 [𑀔𑀦𑁆𑀢𑀻 𑀘 (𑀓.)] 𑀅𑀯𑀺𑀭𑁄𑀥𑀦𑀁.

𑁧𑁭𑁭.

‘‘𑀇𑀘𑁆𑀘𑁂𑀢𑁂 𑀓𑀼𑀲𑀮𑁂 𑀥𑀫𑁆𑀫𑁂, 𑀞𑀺𑀢𑁂 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀅𑀢𑁆𑀢𑀦𑀺;

𑀢𑀢𑁄 𑀫𑁂 𑀚𑀸𑀬𑀢𑁂 𑀧𑀻𑀢𑀺, 𑀲𑁄𑀫𑀦𑀲𑁆𑀲𑀜𑁆𑀘𑀦𑀧𑁆𑀧𑀓𑀁.

𑁧𑁭𑁮.

‘‘𑀲𑀼𑀫𑀼𑀔𑁄 ¶ 𑀘 𑀅𑀘𑀺𑀦𑁆𑀢𑁂𑀢𑁆𑀯𑀸, 𑀯𑀺𑀲𑀚𑁆𑀚𑀺 [𑀯𑀺𑀲𑁆𑀲𑀚𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀨𑀭𑀼𑀲𑀁 𑀕𑀺𑀭𑀁;

𑀪𑀸𑀯𑀤𑁄𑀲𑀫𑀦𑀜𑁆𑀜𑀸𑀬, 𑀅𑀲𑁆𑀫𑀸𑀓𑀸𑀬𑀁 𑀯𑀺𑀳𑀗𑁆𑀕𑀫𑁄.

𑁧𑁭𑁯.

‘‘𑀲𑁄 𑀓𑀼𑀤𑁆𑀥𑁄 𑀨𑀭𑀼𑀲𑀁 𑀯𑀸𑀘𑀁, 𑀦𑀺𑀘𑁆𑀙𑀸𑀭𑁂𑀲𑀺 𑀅𑀬𑁄𑀦𑀺𑀲𑁄;

𑀬𑀸𑀦𑀲𑁆𑀫𑀸𑀲𑀼 [𑀬𑀸𑀦𑀲𑁆𑀫𑀸𑀲𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸 𑀧𑀻.)] 𑀦 𑀯𑀺𑀚𑁆𑀚𑀦𑁆𑀢𑀺, 𑀦𑀬𑀺𑀤𑀁 [𑀦 𑀇𑀤𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀜𑁆𑀜𑀯𑀢𑀸𑀫𑀺𑀯’’.

𑁧𑁮𑁦.

‘‘𑀅𑀢𑁆𑀣𑀺 𑀫𑁂 𑀢𑀁 𑀅𑀢𑀺𑀲𑀸𑀭𑀁, 𑀯𑁂𑀕𑁂𑀦 𑀫𑀦𑀼𑀚𑀸𑀥𑀺𑀧;

𑀥𑀢𑀭𑀝𑁆𑀞𑁂 𑀘 𑀩𑀤𑁆𑀥𑀲𑁆𑀫𑀺𑀁, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀫𑁂 𑀯𑀺𑀧𑀼𑀮𑀁 𑀅𑀳𑀼.

𑁧𑁮𑁧.

‘‘𑀢𑁆𑀯𑀁 𑀦𑁄 𑀧𑀺𑀢𑀸𑀯 𑀧𑀼𑀢𑁆𑀢𑀸𑀦𑀁, 𑀪𑀽𑀢𑀸𑀦𑀁 𑀥𑀭𑀡𑀻𑀭𑀺𑀯;

𑀅𑀲𑁆𑀫𑀸𑀓𑀁 𑀅𑀥𑀺𑀧𑀦𑁆𑀦𑀸𑀦𑀁, 𑀔𑀫𑀲𑁆𑀲𑀼 𑀭𑀸𑀚𑀓𑀼𑀜𑁆𑀚𑀭’’.

𑁧𑁮𑁨.

‘‘𑀏𑀢𑀁 [𑀏𑀯𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀢𑁂 𑀅𑀦𑀼𑀫𑁄𑀤𑀸𑀫, 𑀬𑀁 𑀪𑀸𑀯𑀁 𑀦 𑀦𑀺𑀕𑀽𑀳𑀲𑀺;

𑀔𑀺𑀮𑀁 𑀧𑀪𑀺𑀦𑁆𑀤𑀲𑀺 𑀧𑀓𑁆𑀔𑀺, 𑀉𑀚𑀼𑀓𑁄𑀲𑀺 𑀯𑀺𑀳𑀗𑁆𑀕𑀫’’.

𑁧𑁮𑁩.

‘‘𑀬𑀁 ¶ ¶ 𑀓𑀺𑀜𑁆𑀘𑀺 𑀭𑀢𑀦𑀁 𑀅𑀢𑁆𑀣𑀺, 𑀓𑀸𑀲𑀺𑀭𑀸𑀚 𑀦𑀺𑀯𑁂𑀲𑀦𑁂;

𑀭𑀚𑀢𑀁 𑀚𑀸𑀢𑀭𑀽𑀧𑀜𑁆𑀘, 𑀫𑀼𑀢𑁆𑀢𑀸 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀸 𑀩𑀳𑀽.

𑁧𑁮𑁪.

‘‘𑀫𑀡𑀬𑁄 𑀲𑀗𑁆𑀔𑀫𑀼𑀢𑁆𑀢𑀜𑁆𑀘, 𑀯𑀢𑁆𑀣𑀓𑀁 𑀳𑀭𑀺𑀘𑀦𑁆𑀤𑀦𑀁;

𑀅𑀚𑀺𑀦𑀁 𑀤𑀦𑁆𑀢𑀪𑀡𑁆𑀟𑀜𑁆𑀘, 𑀮𑁄𑀳𑀁 𑀓𑀸𑀴𑀸𑀬𑀲𑀁 𑀩𑀳𑀼𑀁;

𑀏𑀢𑀁 𑀤𑀤𑀸𑀫𑀺 𑀯𑁄 𑀯𑀺𑀢𑁆𑀢𑀁, 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑀁 [𑀇𑀲𑁆𑀲𑁂𑀭𑀁 (𑀲𑀻.), 𑀇𑀲𑁆𑀲𑀭𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)] 𑀯𑀺𑀲𑁆𑀲𑀚𑀸𑀫𑀺 𑀯𑁄’’.

𑁧𑁮𑁫.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀅𑀧𑀘𑀺𑀢𑀸 𑀢𑁆𑀬𑀫𑁆𑀳𑀸, 𑀲𑀓𑁆𑀓𑀢𑀸 𑀘 𑀭𑀣𑁂𑀲𑀪;

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

𑁧𑁮𑁬.

‘‘𑀆𑀘𑀭𑀺𑀬 𑀲𑀫𑀦𑀼𑀜𑁆𑀜𑀸𑀢𑀸, 𑀢𑀬𑀸 𑀅𑀦𑀼𑀫𑀢𑀸 𑀫𑀬𑀁;

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

𑁧𑁮𑁭.

‘‘𑀲𑀩𑁆𑀩𑀭𑀢𑁆𑀢𑀺𑀁 𑀘𑀺𑀦𑁆𑀢𑀬𑀺𑀢𑁆𑀯𑀸, 𑀫𑀦𑁆𑀢𑀬𑀺𑀢𑁆𑀯𑀸 𑀬𑀣𑀸𑀢𑀣𑀁;

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

𑁧𑁮𑁮.

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

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

𑁧𑁮𑁯.

‘‘𑀢𑁂 𑀅𑀭𑁄𑀕𑁂 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁂, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀧𑀭𑀫𑁂 𑀤𑀺𑀚𑁂;

𑀓𑁂𑀓𑀸𑀢𑀺 𑀫𑀓𑀭𑀼𑀁 𑀳𑀁𑀲𑀸, 𑀧𑀼𑀣𑀼𑀲𑀤𑁆𑀤𑁄 𑀅𑀚𑀸𑀬𑀣.

𑁧𑁯𑁦.

‘‘𑀢𑁂 ¶ 𑀧𑀢𑀻𑀢𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑁂𑀦, 𑀪𑀢𑁆𑀢𑀼𑀦𑀸 𑀪𑀢𑁆𑀢𑀼𑀕𑀸𑀭𑀯𑀸;

𑀲𑀫𑀦𑁆𑀢𑀸 𑀧𑀭𑀺𑀓𑀺𑀭𑀺𑀁𑀲𑀼, 𑀅𑀡𑁆𑀟𑀚𑀸 𑀮𑀤𑁆𑀥𑀧𑀘𑁆𑀘𑀬𑀸’’.

𑁧𑁯𑁧.

‘‘𑀏𑀯𑀁 𑀫𑀺𑀢𑁆𑀢𑀯𑀢𑀁 𑀅𑀢𑁆𑀣𑀸, 𑀲𑀩𑁆𑀩𑁂 𑀳𑁄𑀦𑁆𑀢𑀺 𑀧𑀤𑀓𑁆𑀔𑀺𑀡𑀸;

𑀳𑀁𑀲𑀸 𑀬𑀣𑀸 𑀥𑀢𑀭𑀝𑁆𑀞𑀸, 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑀁 𑀉𑀧𑀸𑀕𑀫𑀼’’𑀦𑁆𑀢𑀺.

𑀫𑀳𑀸𑀳𑀁𑀲𑀚𑀸𑀢𑀓𑀁 𑀤𑀼𑀢𑀺𑀬𑀁.

𑁫𑁩𑁫. 𑀲𑀼𑀥𑀸𑀪𑁄𑀚𑀦𑀚𑀸𑀢𑀓𑀁 (𑁩)

𑁧𑁯𑁨.

‘‘𑀦𑁂𑀯 ¶ 𑀓𑀺𑀡𑀸𑀫𑀺 𑀦𑀧𑀺 𑀯𑀺𑀓𑁆𑀓𑀺𑀡𑀸𑀫𑀺, 𑀦 𑀘𑀸𑀧𑀺 𑀫𑁂 𑀲𑀦𑁆𑀦𑀺𑀘𑀬𑁄 𑀘 𑀅𑀢𑁆𑀣𑀺 [𑀇𑀥𑀢𑁆𑀣𑀺 (𑀲𑁆𑀬𑀸.)];

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

𑁧𑁯𑁩.

‘‘𑀅𑀧𑁆𑀧𑀫𑁆𑀳𑀸 𑀅𑀧𑁆𑀧𑀓𑀁 𑀤𑀚𑁆𑀚𑀸, 𑀅𑀦𑀼𑀫𑀚𑁆𑀛𑀢𑁄 𑀫𑀚𑁆𑀛𑀓𑀁;

𑀩𑀳𑀼𑀫𑁆𑀳𑀸 𑀩𑀳𑀼𑀓𑀁 𑀤𑀚𑁆𑀚𑀸, 𑀅𑀤𑀸𑀦𑀁 𑀦𑀼𑀧𑀧𑀚𑁆𑀚𑀢𑀺 [𑀦 𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)].

𑁧𑁯𑁪.

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

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

𑁧𑁯𑁫.

‘‘𑀫𑁄𑀖𑀜𑁆𑀘𑀲𑁆𑀲 ¶ 𑀳𑀼𑀢𑀁 𑀳𑁄𑀢𑀺, 𑀫𑁄𑀖𑀜𑁆𑀘𑀸𑀧𑀺 𑀲𑀫𑀻𑀳𑀺𑀢𑀁;

𑀅𑀢𑀺𑀣𑀺𑀲𑁆𑀫𑀺𑀁 𑀬𑁄 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀲𑁆𑀫𑀺𑀁, 𑀏𑀓𑁄 𑀪𑀼𑀜𑁆𑀚𑀢𑀺 𑀪𑁄𑀚𑀦𑀁.

𑁧𑁯𑁬.

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

𑀅𑀭𑀺𑀬𑀫𑀕𑁆𑀕𑀁 𑀲𑀫𑀸𑀭𑀽𑀳, 𑀦𑁂𑀓𑀸𑀲𑀻 𑀮𑀪𑀢𑁂 𑀲𑀼𑀔𑀁’’.

𑁧𑁯𑁭.

‘‘𑀲𑀘𑁆𑀘𑀜𑁆𑀘𑀲𑁆𑀲 𑀳𑀼𑀢𑀁 𑀳𑁄𑀢𑀺, 𑀲𑀘𑁆𑀘𑀜𑁆𑀘𑀸𑀧𑀺 𑀲𑀫𑀻𑀳𑀺𑀢𑀁;

𑀅𑀢𑀺𑀣𑀺𑀲𑁆𑀫𑀺𑀁 𑀬𑁄 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀲𑁆𑀫𑀺𑀁, 𑀦𑁂𑀓𑁄 𑀪𑀼𑀜𑁆𑀚𑀢𑀺 𑀪𑁄𑀚𑀦𑀁.

𑁧𑁯𑁮.

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

𑀅𑀭𑀺𑀬𑀫𑀕𑁆𑀕𑀁 𑀲𑀫𑀸𑀭𑀽𑀳, 𑀦𑁂𑀓𑀸𑀲𑀻 𑀮𑀪𑀢𑁂 𑀲𑀼𑀔𑀁’’.

𑁧𑁯𑁯.

‘‘𑀲𑀭𑀜𑁆𑀘 𑀚𑀼𑀳𑀢𑀺 𑀧𑁄𑀲𑁄, 𑀩𑀳𑀼𑀓𑀸𑀬 𑀕𑀬𑀸𑀬 𑀘;

𑀤𑁄𑀡𑁂 𑀢𑀺𑀫𑁆𑀩𑀭𑀼𑀢𑀺𑀢𑁆𑀣𑀲𑁆𑀫𑀺𑀁, 𑀲𑀻𑀖𑀲𑁄𑀢𑁂 𑀫𑀳𑀸𑀯𑀳𑁂.

𑁨𑁦𑁦.

‘‘𑀅𑀢𑁆𑀭 𑀘𑀲𑁆𑀲 𑀳𑀼𑀢𑀁 𑀳𑁄𑀢𑀺, 𑀅𑀢𑁆𑀭 𑀘𑀲𑁆𑀲 𑀲𑀫𑀻𑀳𑀺𑀢𑀁;

𑀅𑀢𑀺𑀣𑀺𑀲𑁆𑀫𑀺𑀁 ¶ 𑀬𑁄 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀲𑁆𑀫𑀺𑀁, 𑀦𑁂𑀓𑁄 𑀪𑀼𑀜𑁆𑀚𑀢𑀺 𑀪𑁄𑀚𑀦𑀁.

𑁨𑁦𑁧.

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

𑀅𑀭𑀺𑀬𑀫𑀕𑁆𑀕𑀁 𑀲𑀫𑀸𑀭𑀽𑀳, 𑀦𑁂𑀓𑀸𑀲𑀻 𑀮𑀪𑀢𑁂 𑀲𑀼𑀔𑀁’’.

𑁨𑁦𑁨.

‘‘𑀩𑀴𑀺𑀲𑀜𑁆𑀳𑀺 𑀲𑁄 𑀦𑀺𑀕𑀺𑀮𑀢𑀺 [𑀦𑀺𑀕𑁆𑀕𑀺𑀮𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)], 𑀤𑀻𑀖𑀲𑀼𑀢𑁆𑀢𑀁 𑀲𑀩𑀦𑁆𑀥𑀦𑀁;

𑀅𑀢𑀺𑀣𑀺𑀲𑁆𑀫𑀺𑀁 𑀬𑁄 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀲𑁆𑀫𑀺𑀁, 𑀏𑀓𑁄 𑀪𑀼𑀜𑁆𑀚𑀢𑀺 𑀪𑁄𑀚𑀦𑀁.

𑁨𑁦𑁩.

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

𑀅𑀭𑀺𑀬𑀫𑀕𑁆𑀕𑀁 𑀲𑀫𑀸𑀭𑀽𑀳, 𑀦𑁂𑀓𑀸𑀲𑀻 𑀮𑀪𑀢𑁂 𑀲𑀼𑀔𑀁’’.

𑁨𑁦𑁪.

‘‘𑀉𑀴𑀸𑀭𑀯𑀡𑁆𑀡𑀸 𑀯𑀢 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀇𑀫𑁂, 𑀅𑀬𑀜𑁆𑀘 𑀯𑁄 𑀲𑀼𑀦𑀔𑁄 𑀓𑀺𑀲𑁆𑀲 𑀳𑁂𑀢𑀼;

𑀉𑀘𑁆𑀘𑀸𑀯𑀘𑀁 𑀯𑀡𑁆𑀡𑀦𑀺𑀪𑀁 𑀯𑀺𑀓𑀼𑀩𑁆𑀩𑀢𑀺, 𑀅𑀓𑁆𑀔𑀸𑀣 𑀦𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀓𑁂 𑀦𑀼 𑀢𑀼𑀫𑁆𑀳𑁂’’.

𑁨𑁦𑁫.

‘‘𑀘𑀦𑁆𑀤𑁄 𑀘 𑀲𑀽𑀭𑀺𑀬𑁄 𑀘 [𑀲𑀽𑀭𑀺𑀬𑁄 𑀘 (𑀓.)] 𑀉𑀪𑁄 𑀇𑀥𑀸𑀕𑀢𑀸, 𑀅𑀬𑀁 𑀧𑀦 𑀫𑀸𑀢𑀮𑀺 𑀤𑁂𑀯𑀲𑀸𑀭𑀣𑀺;

𑀲𑀓𑁆𑀓𑁄𑀳𑀫𑀲𑁆𑀫𑀺 𑀢𑀺𑀤𑀲𑀸𑀦𑀫𑀺𑀦𑁆𑀤𑁄, 𑀏𑀲𑁄 𑀘 𑀔𑁄 𑀧𑀜𑁆𑀘𑀲𑀺𑀔𑁄𑀢𑀺 𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

𑁨𑁦𑁬.

‘‘𑀧𑀸𑀡𑀺𑀲𑁆𑀲𑀭𑀸 𑀫𑀼𑀤𑀺𑀗𑁆𑀕𑀸 𑀘 [𑀫𑀼𑀢𑀺𑀗𑁆𑀕𑀸 𑀘 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀫𑀼𑀭𑀚𑀸𑀮𑀫𑁆𑀩𑀭𑀸𑀦𑀺 𑀘;

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

𑁨𑁦𑁭.

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

𑀇𑀥𑁂𑀯 𑀦𑀺𑀓𑁆𑀔𑀺𑀧𑁆𑀧 𑀲𑀭𑀻𑀭𑀤𑁂𑀳𑀁, 𑀓𑀸𑀬𑀲𑁆𑀲 ¶ 𑀪𑁂𑀤𑀸 𑀦𑀺𑀭𑀬𑀁 𑀯𑀚𑀦𑁆𑀢𑀺’’.

𑁨𑁦𑁮.

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

𑀇𑀥𑁂𑀯 𑀦𑀺𑀓𑁆𑀔𑀺𑀧𑁆𑀧 𑀲𑀭𑀻𑀭𑀤𑁂𑀳𑀁, 𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀲𑀼𑀕𑀢𑀺𑀁 𑀯𑀚𑀦𑁆𑀢𑀺’’.

𑁨𑁦𑁯.

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

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

𑁨𑁧𑁦.

‘‘𑀅𑀤𑁆𑀥𑀸 ¶ 𑀳𑀺 𑀫𑀁 𑀯𑁄 𑀳𑀺𑀢𑀓𑀸𑀫𑀸, 𑀬𑀁 𑀫𑀁 𑀲𑀫𑀦𑀼𑀲𑀸𑀲𑀣;

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

𑁨𑁧𑁧.

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

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

𑁨𑁧𑁨.

‘‘𑀏𑀯𑀜𑁆𑀘 𑀫𑁂 𑀤𑀤𑀢𑁄 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀁 [𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑁂 (𑀓.)], 𑀪𑁄𑀕𑀸 𑀇𑀫𑁂 𑀯𑀸𑀲𑀯 𑀔𑀻𑀬𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺;

𑀢𑀢𑁄 𑀅𑀳𑀁 𑀧𑀩𑁆𑀩𑀚𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀲𑀓𑁆𑀓, 𑀳𑀺𑀢𑁆𑀯𑀸𑀦 𑀓𑀸𑀫𑀸𑀦𑀺 𑀬𑀣𑁄𑀥𑀺𑀓𑀸𑀦𑀺’’.

𑁨𑁧𑁩.

‘‘𑀦𑀕𑀼𑀢𑁆𑀢𑀫𑁂 𑀕𑀺𑀭𑀺𑀯𑀭𑁂 𑀕𑀦𑁆𑀥𑀫𑀸𑀤𑀦𑁂, 𑀫𑁄𑀤𑀦𑁆𑀢𑀺 ¶ 𑀢𑀸 𑀤𑁂𑀯𑀯𑀭𑀸𑀪𑀺𑀧𑀸𑀮𑀺𑀢𑀸;

𑀅𑀣𑀸𑀕𑀫𑀸 𑀇𑀲𑀺𑀯𑀭𑁄 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀕𑀽, 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀤𑀼𑀫𑀯𑀭𑀲𑀸𑀔𑀫𑀸𑀤𑀺𑀬.

𑁨𑁧𑁪.

‘‘𑀲𑀼𑀘𑀺𑀁 𑀲𑀼𑀕𑀦𑁆𑀥𑀁 𑀢𑀺𑀤𑀲𑁂𑀳𑀺 𑀲𑀓𑁆𑀓𑀢𑀁, 𑀧𑀼𑀧𑁆𑀨𑀼𑀢𑁆𑀢𑀫𑀁 𑀅𑀫𑀭𑀯𑀭𑁂𑀳𑀺 𑀲𑁂𑀯𑀺𑀢𑀁;

𑀅𑀮𑀤𑁆𑀥 𑀫𑀘𑁆𑀘𑁂𑀳𑀺 𑀯 𑀤𑀸𑀦𑀯𑁂𑀳𑀺 𑀯𑀸, 𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀤𑁂𑀯𑁂𑀳𑀺 𑀢𑀤𑀸𑀭𑀳𑀁 𑀳𑀺𑀤𑀁 [𑀳𑀺𑀢𑀁 (𑀲𑁆𑀬𑀸.)].

𑁨𑁧𑁫.

‘‘𑀢𑀢𑁄 𑀘𑀢𑀲𑁆𑀲𑁄 𑀓𑀦𑀓𑀢𑁆𑀢𑀘𑀽𑀧𑀫𑀸, 𑀉𑀝𑁆𑀞𑀸𑀬 𑀦𑀸𑀭𑀺𑀬𑁄 𑀧𑀫𑀤𑀸𑀥𑀺𑀧𑀸 𑀫𑀼𑀦𑀺𑀁;

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

𑁨𑁧𑁬.

‘‘𑀲𑀘𑁂 ¶ 𑀅𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑀁 𑀢𑀬𑀸 𑀫𑀳𑀸𑀫𑀼𑀦𑀺, 𑀧𑀼𑀧𑁆𑀨𑀁 𑀇𑀫𑀁 𑀧𑀸𑀭𑀺𑀙𑀢𑁆𑀢𑀲𑁆𑀲 𑀩𑁆𑀭𑀳𑁆𑀫𑁂;

𑀤𑀤𑀸𑀳𑀺 𑀦𑁄 𑀲𑀩𑁆𑀩𑀸 𑀕𑀢𑀺 𑀢𑁂 𑀇𑀚𑁆𑀛𑀢𑀼, 𑀢𑀼𑀯𑀫𑁆𑀧𑀺 𑀦𑁄 𑀳𑁄𑀳𑀺 𑀬𑀣𑁂𑀯 𑀯𑀸𑀲𑀯𑁄.

𑁨𑁧𑁭.

‘‘𑀢𑀁 𑀬𑀸𑀘𑀫𑀸𑀦𑀸𑀪𑀺𑀲𑀫𑁂𑀓𑁆𑀔 𑀦𑀸𑀭𑀤𑁄, 𑀇𑀘𑁆𑀘𑀩𑁆𑀭𑀯𑀻 𑀲𑀁𑀓𑀮𑀳𑀁 𑀉𑀤𑀻𑀭𑀬𑀺;

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

𑁨𑁧𑁮.

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

𑀬𑀲𑁆𑀲𑀸 𑀳𑀺 𑀦𑁄 𑀦𑀸𑀭𑀤 𑀢𑁆𑀯𑀁 𑀧𑀤𑀲𑁆𑀲𑀲𑀺, 𑀲𑀸𑀬𑁂𑀯 𑀦𑁄 𑀳𑁂𑀳𑀺𑀢𑀺 𑀲𑁂𑀝𑁆𑀞𑀲𑀫𑁆𑀫𑀢𑀸’’.

𑁨𑁧𑁯.

‘‘𑀅𑀓𑀮𑁆𑀮𑀫𑁂𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀕𑀢𑁆𑀢𑁂, 𑀓𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀲𑀁𑀓𑀮𑀳𑀁 𑀉𑀤𑀻𑀭𑀬𑁂;

𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀪𑀽𑀢𑀸𑀥𑀺𑀧𑀫𑁂𑀯 𑀧𑀼𑀘𑁆𑀙𑀣, 𑀲𑀘𑁂 𑀦 𑀚𑀸𑀦𑀸𑀣 𑀇𑀥𑀼𑀢𑁆𑀢𑀫𑀸𑀥𑀫𑀁’’.

𑁨𑁨𑁦.

‘‘𑀢𑀸 𑀦𑀸𑀭𑀤𑁂𑀦 𑀧𑀭𑀫𑀧𑁆𑀧𑀓𑁄𑀧𑀺𑀢𑀸, 𑀉𑀤𑀻𑀭𑀺𑀢𑀸 𑀯𑀡𑁆𑀡𑀫𑀤𑁂𑀦 𑀫𑀢𑁆𑀢𑀸;

𑀲𑀓𑀸𑀲𑁂 [𑀲𑀓𑀸𑀲𑀁 (𑀓.)] 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀲𑀳𑀲𑁆𑀲𑀘𑀓𑁆𑀔𑀼𑀦𑁄, 𑀧𑀼𑀘𑁆𑀙𑀺𑀁𑀲𑀼 𑀪𑀽𑀢𑀸𑀥𑀺𑀧𑀁 𑀓𑀸 𑀦𑀼 𑀲𑁂𑀬𑁆𑀬𑀲𑀺’’.

𑁨𑁨𑁧.

‘‘𑀢𑀸 𑀤𑀺𑀲𑁆𑀯𑀸 𑀆𑀬𑀢𑁆𑀢𑀫𑀦𑀸 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄, 𑀇𑀘𑁆𑀘𑀩𑁆𑀭𑀯𑀻 𑀤𑁂𑀯𑀯𑀭𑁄 𑀓𑀢𑀜𑁆𑀚𑀮𑀻;

𑀲𑀩𑁆𑀩𑀸𑀯 𑀯𑁄 𑀳𑁄𑀣 𑀲𑀼𑀕𑀢𑁆𑀢𑁂 𑀲𑀸𑀤𑀺𑀲𑀻, 𑀓𑁄 𑀦𑁂𑀯 𑀪𑀤𑁆𑀤𑁂 𑀓𑀮𑀳𑀁 𑀉𑀤𑀻𑀭𑀬𑀺’’.

𑁨𑁨𑁨.

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

𑀲𑁄 𑀦𑁄𑀩𑁆𑀭𑀯𑀺 [𑀩𑁆𑀭𑀯𑀻 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀕𑀺𑀭𑀺𑀯𑀭𑁂 𑀕𑀦𑁆𑀥𑀫𑀸𑀤𑀦𑁂, 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀪𑀽𑀢𑀸𑀥𑀺𑀧𑀫𑁂𑀯 𑀧𑀼𑀘𑁆𑀙𑀣;

𑀲𑀘𑁂 𑀦 𑀚𑀸𑀦𑀸𑀣 𑀇𑀥𑀼𑀢𑁆𑀢𑀫𑀸𑀥𑀫𑀁’’.

𑁨𑁨𑁩.

‘‘𑀅𑀲𑀼 ¶ [𑀅𑀲𑀽 (𑀲𑁆𑀬𑀸.)] 𑀩𑁆𑀭𑀳𑀸𑀭𑀜𑁆𑀜𑀘𑀭𑁄 𑀫𑀳𑀸𑀫𑀼𑀦𑀺, 𑀦𑀸𑀤𑀢𑁆𑀯𑀸 𑀪𑀢𑁆𑀢𑀁 𑀯𑀭𑀕𑀢𑁆𑀢𑁂 𑀪𑀼𑀜𑁆𑀚𑀢𑀺;

𑀯𑀺𑀘𑁂𑀬𑁆𑀬 𑀤𑀸𑀦𑀸𑀦𑀺 𑀤𑀤𑀸𑀢𑀺 𑀓𑁄𑀲𑀺𑀬𑁄, 𑀬𑀲𑁆𑀲𑀸 𑀳𑀺 𑀲𑁄 𑀤𑀲𑁆𑀲𑀢𑀺 𑀲𑀸𑀯 𑀲𑁂𑀬𑁆𑀬𑀲𑀺’’.

𑁨𑁨𑁪.

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

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

𑁨𑁨𑁫.

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

𑀲𑀼𑀔𑀺𑀧𑁆𑀧𑀫𑁂𑀯 [𑀲 𑀔𑀺𑀧𑁆𑀧𑀫𑁂𑀯 (𑀲𑀻. 𑀧𑀻.)] 𑀉𑀧𑀕𑀫𑁆𑀫 𑀅𑀲𑁆𑀲𑀫𑀁, 𑀅𑀤𑀺𑀲𑁆𑀲𑀫𑀸𑀦𑁄 𑀫𑀼𑀦𑀺𑀦𑁄 𑀲𑀼𑀥𑀁 𑀅𑀤𑀸’’.

𑁨𑁨𑁬.

‘‘𑀉𑀤𑀕𑁆𑀕𑀺𑀳𑀼𑀢𑁆𑀢𑀁 𑀉𑀧𑀢𑀺𑀝𑁆𑀞𑀢𑁄 𑀳𑀺 𑀫𑁂, 𑀧𑀪𑀗𑁆𑀓𑀭𑀁 𑀮𑁄𑀓𑀢𑀫𑁄𑀦𑀼𑀤𑀼𑀢𑁆𑀢𑀫𑀁;

𑀲𑀩𑁆𑀩𑀸𑀦𑀺 𑀪𑀽𑀢𑀸𑀦𑀺 𑀅𑀥𑀺𑀘𑁆𑀘 [𑀅𑀢𑀺𑀘𑁆𑀘 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑀸𑀲𑀯𑁄, 𑀓𑁄 𑀦𑁂𑀯 𑀫𑁂 𑀧𑀸𑀡𑀺𑀲𑀼 𑀓𑀺𑀁 𑀲𑀼𑀥𑁄𑀤𑀳𑀺.

𑁨𑁨𑁭.

‘‘𑀲𑀗𑁆𑀔𑀽𑀧𑀫𑀁 𑀲𑁂𑀢𑀫𑀢𑀼𑀮𑁆𑀬𑀤𑀲𑁆𑀲𑀦𑀁, 𑀲𑀼𑀘𑀺𑀁 𑀲𑀼𑀕𑀦𑁆𑀥𑀁 𑀧𑀺𑀬𑀭𑀽𑀧𑀫𑀩𑁆𑀪𑀼𑀢𑀁;

𑀅𑀤𑀺𑀝𑁆𑀞𑀧𑀼𑀩𑁆𑀩𑀁 𑀫𑀫 𑀚𑀸𑀢𑀼 𑀘𑀓𑁆𑀔𑀼𑀪𑀺 [𑀚𑀸𑀢𑀘𑀓𑁆𑀔𑀼𑀳𑀺 (𑀲𑀻. 𑀧𑀻.)], 𑀓𑀸 𑀤𑁂𑀯𑀢𑀸 𑀧𑀸𑀡𑀺𑀲𑀼 𑀓𑀺𑀁 𑀲𑀼𑀥𑁄𑀤𑀳𑀺’’.

𑁨𑁨𑁮.

‘‘𑀅𑀳𑀁 ¶ ¶ 𑀫𑀳𑀺𑀦𑁆𑀤𑁂𑀦 𑀫𑀳𑁂𑀲𑀺 𑀧𑁂𑀲𑀺𑀢𑁄, 𑀲𑀼𑀥𑀸𑀪𑀺𑀳𑀸𑀲𑀺𑀁 𑀢𑀼𑀭𑀺𑀢𑁄 𑀫𑀳𑀸𑀫𑀼𑀦𑀺;

𑀚𑀸𑀦𑀸𑀲𑀺 𑀫𑀁 𑀫𑀸𑀢𑀮𑀺 𑀤𑁂𑀯𑀲𑀸𑀭𑀣𑀺, 𑀪𑀼𑀜𑁆𑀚𑀲𑁆𑀲𑀼 𑀪𑀢𑁆𑀢𑀼𑀢𑁆𑀢𑀫 𑀫𑀸𑀪𑀺𑀯𑀸𑀭𑀬𑀺 [𑀫𑀸 𑀯𑀺𑀘𑀸𑀭𑀬𑀺 (𑀲𑀻. 𑀧𑀻.)].

𑁨𑁨𑁯.

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

𑀓𑁄𑀥𑀽𑀧𑀦𑀸𑀳𑀜𑁆𑀘 𑀯𑀺𑀯𑀸𑀤𑀧𑁂𑀲𑀼𑀡𑀁, 𑀲𑀻𑀢𑀼𑀡𑁆𑀳𑀢𑀦𑁆𑀤𑀺𑀜𑁆𑀘 𑀭𑀲𑀼𑀢𑁆𑀢𑀫𑀁 𑀇𑀤𑀁’’.

𑁨𑁩𑁦.

‘‘𑀦 𑀓𑀧𑁆𑀧𑀢𑀻 𑀫𑀸𑀢𑀮𑀺 𑀫𑀬𑁆𑀳 𑀪𑀼𑀜𑁆𑀚𑀺𑀢𑀼𑀁, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀅𑀤𑀢𑁆𑀯𑀸 𑀇𑀢𑀺 𑀫𑁂 𑀯𑀢𑀼𑀢𑁆𑀢𑀫𑀁;

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

𑁨𑁩𑁧.

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

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

𑁨𑁩𑁨.

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

𑀲𑀤𑁆𑀥𑀸 𑀯𑀤𑀜𑁆𑀜𑀽 𑀇𑀥 𑀯𑀻𑀢𑀫𑀘𑁆𑀙𑀭𑀸, 𑀪𑀯𑀦𑁆𑀢𑀺 ¶ 𑀳𑁂𑀢𑁂 𑀲𑀼𑀘𑀺𑀲𑀘𑁆𑀘𑀲𑀫𑁆𑀫𑀢𑀸’’ [𑀲𑀫𑁆𑀫𑀲𑀫𑁆𑀫𑀢𑀸 (𑀲𑀻.)].

𑁨𑁩𑁩.

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

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

𑁨𑁩𑁪.

‘‘𑀢𑀸 ¶ 𑀤𑀺𑀲𑁆𑀯𑀸 𑀲𑀩𑁆𑀩𑁄 𑀧𑀭𑀫𑀧𑁆𑀧𑀫𑁄𑀤𑀺𑀢𑁄 [𑀲𑀩𑁆𑀩𑀸 𑀧𑀭𑀫𑀧𑁆𑀧𑀫𑁄𑀤𑀺𑀢𑀸 (𑀲𑁆𑀬𑀸.)], 𑀲𑀼𑀪𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦 𑀲𑀺𑀔𑀸𑀭𑀺𑀯𑀕𑁆𑀕𑀺𑀦𑁄;

𑀓𑀜𑁆𑀜𑀸 𑀘𑀢𑀲𑁆𑀲𑁄 𑀘𑀢𑀼𑀭𑁄 𑀘𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑀸, 𑀇𑀘𑁆𑀘𑀩𑁆𑀭𑀯𑀻 𑀫𑀸𑀢𑀮𑀺𑀦𑁄 𑀘 𑀲𑀫𑁆𑀫𑀼𑀔𑀸.

𑁨𑁩𑁫.

‘‘𑀧𑀼𑀭𑀺𑀫𑀁 𑀤𑀺𑀲𑀁 𑀓𑀸 𑀢𑁆𑀯𑀁 𑀧𑀪𑀸𑀲𑀺 𑀤𑁂𑀯𑀢𑁂, 𑀅𑀮𑀗𑁆𑀓𑀢𑀸 𑀢𑀸𑀭𑀯𑀭𑀸𑀯 𑀑𑀲𑀥𑀻;

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀓𑀜𑁆𑀘𑀦𑀯𑁂𑀮𑁆𑀮𑀺𑀯𑀺𑀕𑁆𑀕𑀳𑁂, 𑀆𑀘𑀺𑀓𑁆𑀔 𑀫𑁂 𑀢𑁆𑀯𑀁 𑀓𑀢𑀫𑀸𑀲𑀺 𑀤𑁂𑀯𑀢𑀸.

𑁨𑁩𑁬.

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

𑀲𑀼𑀥𑀸𑀯𑀺𑀯𑀸𑀤𑁂𑀦 𑀢𑀯𑀦𑁆𑀢𑀺𑀫𑀸𑀕𑀢𑀸, 𑀢𑀁 ¶ 𑀫𑀁 𑀲𑀼𑀥𑀸𑀬 𑀯𑀭𑀧𑀜𑁆𑀜 𑀪𑀸𑀚𑀬.

𑁨𑁩𑁭.

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

𑀲𑀺𑀭𑀻𑀢𑀺 𑀫𑀁 𑀚𑀸𑀦𑀳𑀺 𑀚𑀽𑀳𑀢𑀼𑀢𑁆𑀢𑀫, 𑀢𑀁 𑀫𑀁 𑀲𑀼𑀥𑀸𑀬 𑀯𑀭𑀧𑀜𑁆𑀜 𑀪𑀸𑀚𑀬’’.

𑁨𑁩𑁮.

‘‘𑀲𑀺𑀧𑁆𑀧𑁂𑀦 𑀯𑀺𑀚𑁆𑀚𑀸𑀘𑀭𑀡𑁂𑀦 𑀩𑀼𑀤𑁆𑀥𑀺𑀬𑀸, 𑀦𑀭𑀸 𑀉𑀧𑁂𑀢𑀸 𑀧𑀕𑀼𑀡𑀸 𑀲𑀓𑀫𑁆𑀫𑀼𑀦𑀸 [𑀲𑀓𑀫𑁆𑀫𑀦𑀸 (𑀲𑀻. 𑀧𑀻.)];

𑀢𑀬𑀸 𑀯𑀺𑀳𑀻𑀦𑀸 𑀦 𑀮𑀪𑀦𑁆𑀢𑀺 𑀓𑀺𑀜𑁆𑀘𑀦𑀁 [𑀓𑀺𑀜𑁆𑀘𑀺𑀦𑀁 (𑀓.)], 𑀢𑀬𑀺𑀤𑀁 𑀦 𑀲𑀸𑀥𑀼 𑀬𑀤𑀺𑀤𑀁 𑀢𑀬𑀸 𑀓𑀢𑀁.

𑁨𑁩𑁯.

‘‘𑀧𑀲𑁆𑀲𑀸𑀫𑀺 ¶ 𑀧𑁄𑀲𑀁 𑀅𑀮𑀲𑀁 𑀫𑀳𑀕𑁆𑀖𑀲𑀁, 𑀲𑀼𑀤𑀼𑀓𑁆𑀓𑀼𑀮𑀻𑀦𑀫𑁆𑀧𑀺 𑀅𑀭𑀽𑀧𑀺𑀫𑀁 𑀦𑀭𑀁;

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

𑁨𑁪𑁦.

‘‘𑀢𑀁 𑀢𑀁 𑀅𑀲𑀘𑁆𑀘𑀁 𑀅𑀯𑀺𑀪𑀚𑁆𑀚𑀲𑁂𑀯𑀺𑀦𑀺𑀁, 𑀚𑀸𑀦𑀸𑀫𑀺 𑀫𑀽𑀴𑁆𑀳𑀁 𑀯𑀺𑀤𑀼𑀭𑀸𑀦𑀼𑀧𑀸𑀢𑀺𑀦𑀺𑀁;

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

𑁨𑁪𑁧.

‘‘𑀓𑀸 ¶ 𑀲𑀼𑀓𑁆𑀓𑀤𑀸𑀞𑀸 𑀧𑀝𑀺𑀫𑀼𑀓𑁆𑀓𑀓𑀼𑀡𑁆𑀟𑀮𑀸, 𑀘𑀺𑀢𑁆𑀢𑀗𑁆𑀕𑀤𑀸 𑀓𑀫𑁆𑀩𑀼𑀯𑀺𑀫𑀝𑁆𑀞𑀥𑀸𑀭𑀺𑀦𑀻;

𑀑𑀲𑀺𑀢𑁆𑀢𑀯𑀡𑁆𑀡𑀁 𑀧𑀭𑀺𑀤𑀬𑁆𑀳 𑀲𑁄𑀪𑀲𑀺, 𑀓𑀼𑀲𑀕𑁆𑀕𑀺𑀭𑀢𑁆𑀢𑀁 𑀅𑀧𑀺𑀴𑀬𑁆𑀳 𑀫𑀜𑁆𑀚𑀭𑀺𑀁.

𑁨𑁪𑁨.

‘‘𑀫𑀺𑀕𑀻𑀯 𑀪𑀦𑁆𑀢𑀸 𑀲𑀭𑀘𑀸𑀧𑀥𑀸𑀭𑀺𑀦𑀸, 𑀯𑀺𑀭𑀸𑀥𑀺𑀢𑀸 𑀫𑀦𑁆𑀤𑀫𑀺𑀯 𑀉𑀤𑀺𑀓𑁆𑀔𑀲𑀺;

𑀓𑁄 𑀢𑁂 𑀤𑀼𑀢𑀻𑀬𑁄 𑀇𑀥 𑀫𑀦𑁆𑀤𑀮𑁄𑀘𑀦𑁂, 𑀦 ¶ 𑀪𑀸𑀬𑀲𑀺 𑀏𑀓𑀺𑀓𑀸 𑀓𑀸𑀦𑀦𑁂 𑀯𑀦𑁂’’.

𑁨𑁪𑁩.

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

𑀆𑀲𑀸 𑀲𑀼𑀥𑀸𑀲𑀸𑀬 𑀢𑀯𑀦𑁆𑀢𑀺𑀫𑀸𑀕𑀢𑀸, 𑀢𑀁 𑀫𑀁 𑀲𑀼𑀥𑀸𑀬 𑀯𑀭𑀧𑀜𑁆𑀜 𑀪𑀸𑀚𑀬’’.

𑁨𑁪𑁪.

‘‘𑀆𑀲𑀸𑀬 𑀬𑀦𑁆𑀢𑀺 𑀯𑀸𑀡𑀺𑀚𑀸 𑀥𑀦𑁂𑀲𑀺𑀦𑁄, 𑀦𑀸𑀯𑀁 𑀲𑀫𑀸𑀭𑀼𑀬𑁆𑀳 𑀧𑀭𑁂𑀦𑁆𑀢𑀺 𑀅𑀡𑁆𑀡𑀯𑁂;

𑀢𑁂 𑀢𑀢𑁆𑀣 𑀲𑀻𑀤𑀦𑁆𑀢𑀺 𑀅𑀣𑁄𑀧𑀺 𑀏𑀓𑀤𑀸, 𑀚𑀻𑀦𑀸𑀥𑀦𑀸 𑀏𑀦𑁆𑀢𑀺 𑀯𑀺𑀦𑀝𑁆𑀞𑀧𑀸𑀪𑀢𑀸.

𑁨𑁪𑁫.

‘‘𑀆𑀲𑀸𑀬 𑀔𑁂𑀢𑁆𑀢𑀸𑀦𑀺 𑀓𑀲𑀦𑁆𑀢𑀺 𑀓𑀲𑁆𑀲𑀓𑀸, 𑀯𑀧𑀦𑁆𑀢𑀺 𑀩𑀻𑀚𑀸𑀦𑀺 𑀓𑀭𑁄𑀦𑁆𑀢𑀼𑀧𑀸𑀬𑀲𑁄;

𑀈𑀢𑀻𑀦𑀺𑀧𑀸𑀢𑁂𑀦 𑀅𑀯𑀼𑀝𑁆𑀞𑀺𑀢𑀸𑀬 [𑀅𑀯𑀼𑀝𑁆𑀞𑀺𑀓𑀸𑀬 (𑀲𑀻. 𑀧𑀻.)] 𑀯𑀸, 𑀦 𑀓𑀺𑀜𑁆𑀘𑀺 𑀯𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀢𑀢𑁄 𑀨𑀮𑀸𑀕𑀫𑀁.

𑁨𑁪𑁬.

‘‘𑀅𑀣𑀢𑁆𑀢𑀓𑀸𑀭𑀸𑀦𑀺 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀪𑀢𑁆𑀢𑀼𑀲𑀼, 𑀆𑀲𑀁 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁆𑀯𑀸 𑀦𑀭𑀸 𑀲𑀼𑀔𑁂𑀲𑀺𑀦𑁄;

𑀢𑁂 𑀪𑀢𑁆𑀢𑀼𑀭𑀢𑁆𑀣𑀸 𑀅𑀢𑀺𑀕𑀸𑀴𑁆𑀳𑀺𑀢𑀸 𑀧𑀼𑀦, 𑀤𑀺𑀲𑀸 𑀧𑀦𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀅𑀮𑀤𑁆𑀥 𑀓𑀺𑀜𑁆𑀘𑀦𑀁.

𑁨𑁪𑁭.

‘‘𑀳𑀺𑀢𑁆𑀯𑀸𑀦 [𑀚𑀳𑀺𑀢𑁆𑀯 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀥𑀜𑁆𑀜𑀜𑁆𑀘 𑀥𑀦𑀜𑁆𑀘 𑀜𑀸𑀢𑀓𑁂, 𑀆𑀲𑀸𑀬 𑀲𑀕𑁆𑀕𑀸𑀥𑀺𑀫𑀦𑀸 𑀲𑀼𑀔𑁂𑀲𑀺𑀦𑁄;

𑀢𑀧𑀦𑁆𑀢𑀺 ¶ 𑀮𑀽𑀔𑀫𑁆𑀧𑀺 𑀢𑀧𑀁 𑀘𑀺𑀭𑀦𑁆𑀢𑀭𑀁, 𑀓𑀼𑀫𑀕𑁆𑀕𑀫𑀸𑀭𑀼𑀬𑁆𑀳 [𑀓𑀼𑀫𑁆𑀫𑀕𑁆𑀕𑀫𑀸𑀭𑀼𑀬𑁆𑀳 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀧𑀭𑁂𑀦𑁆𑀢𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

𑁨𑁪𑁮.

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

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

𑁨𑁪𑁯.

‘‘𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀸 𑀬𑀲𑀲𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻, 𑀚𑀺𑀖𑀜𑁆𑀜𑀦𑀸𑀫𑀯𑁆𑀳𑀬𑀦𑀁 𑀤𑀺𑀲𑀁 𑀧𑀢𑀺;

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

𑁨𑁫𑁦.

‘‘𑀲𑀤𑁆𑀥𑀸𑀳 𑀤𑁂𑀯𑀻𑀫𑀦𑀼𑀚𑁂𑀳𑀺 [𑀤𑁂𑀯𑀻𑀫𑀦𑀼𑀚𑁂𑀲𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀧𑀽𑀚𑀺𑀢𑀸, 𑀅𑀧𑀸𑀧𑀲𑀢𑁆𑀢𑀽𑀧𑀦𑀺𑀲𑁂𑀯𑀺𑀦𑀻 𑀲𑀤𑀸;

𑀲𑀼𑀥𑀸𑀯𑀺𑀯𑀸𑀤𑁂𑀦 𑀢𑀯𑀦𑁆𑀢𑀺𑀫𑀸𑀕𑀢𑀸, 𑀢𑀁 𑀫𑀁 𑀲𑀼𑀥𑀸𑀬 𑀯𑀭𑀧𑀜𑁆𑀜 𑀪𑀸𑀚𑀬’’.

𑁨𑁫𑁧.

‘‘𑀤𑀸𑀦𑀁 𑀤𑀫𑀁 𑀘𑀸𑀕𑀫𑀣𑁄𑀧𑀺 𑀲𑀁𑀬𑀫𑀁, 𑀆𑀤𑀸𑀬 𑀲𑀤𑁆𑀥𑀸𑀬 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀳𑁂𑀓𑀤𑀸;

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

𑁨𑁫𑁨.

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

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

𑁨𑁫𑁩.

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

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

𑁨𑁫𑁪.

‘‘𑀚𑀺𑀖𑀜𑁆𑀜𑀭𑀢𑁆𑀢𑀺𑀁 ¶ 𑀅𑀭𑀼𑀡𑀲𑁆𑀫𑀺𑀫𑀽𑀳𑀢𑁂, 𑀬𑀸 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀉𑀢𑁆𑀢𑀫𑀭𑀽𑀧𑀯𑀡𑁆𑀡𑀺𑀦𑀻;

𑀢𑀣𑀽𑀧𑀫𑀸 𑀫𑀁 𑀧𑀝𑀺𑀪𑀸𑀲𑀺 𑀤𑁂𑀯𑀢𑁂, 𑀆𑀘𑀺𑀓𑁆𑀔 𑀫𑁂 𑀢𑁆𑀯𑀁 𑀓𑀢𑀫𑀸𑀲𑀺 𑀅𑀘𑁆𑀙𑀭𑀸.

𑁨𑁫𑁫.

‘‘𑀓𑀸𑀮𑀸 ¶ 𑀦𑀺𑀤𑀸𑀖𑁂𑀭𑀺𑀯 𑀅𑀕𑁆𑀕𑀺𑀚𑀸𑀭𑀺𑀯 [𑀅𑀕𑁆𑀕𑀚𑀸𑀢𑀺𑀯 (𑀲𑀻.), 𑀅𑀕𑁆𑀕𑀺𑀚𑀸𑀢𑀺𑀯 (𑀧𑀻.)], 𑀅𑀦𑀺𑀮𑁂𑀭𑀺𑀢𑀸 𑀮𑁄𑀳𑀺𑀢𑀧𑀢𑁆𑀢𑀫𑀸𑀮𑀺𑀦𑀻;

𑀓𑀸 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀫𑀦𑁆𑀤𑀫𑀺𑀕𑀸𑀯𑀮𑁄𑀓𑀬𑀁 [𑀫𑀦𑁆𑀤𑀫𑀺𑀯𑀸𑀯𑀮𑁄𑀓𑀬𑀁 (𑀲𑀻. 𑀧𑀻.)], 𑀪𑀸𑀲𑁂𑀲𑀫𑀸𑀦𑀸𑀯 𑀕𑀺𑀭𑀁 𑀦 𑀫𑀼𑀜𑁆𑀘𑀲𑀺’’.

𑁨𑁫𑁬.

‘‘𑀳𑀺𑀭𑀸𑀳 𑀤𑁂𑀯𑀻𑀫𑀦𑀼𑀚𑁂𑀳𑀺 𑀧𑀽𑀚𑀺𑀢𑀸, 𑀅𑀧𑀸𑀧𑀲𑀢𑁆𑀢𑀽𑀧𑀦𑀺𑀲𑁂𑀯𑀺𑀦𑀻 𑀲𑀤𑀸;

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

𑀓𑁄𑀧𑀻𑀦𑀭𑀽𑀧𑀸 𑀯𑀺𑀬 𑀬𑀸𑀘𑀦𑀺𑀢𑁆𑀣𑀺𑀬𑀸’’.

𑁨𑁫𑁭.

‘‘𑀥𑀫𑁆𑀫𑁂𑀦 𑀜𑀸𑀬𑁂𑀦 𑀲𑀼𑀕𑀢𑁆𑀢𑁂 𑀮𑀘𑁆𑀙𑀲𑀺, 𑀏𑀲𑁄 ¶ 𑀳𑀺 𑀥𑀫𑁆𑀫𑁄 𑀦 𑀳𑀺 𑀬𑀸𑀘𑀦𑀸 𑀲𑀼𑀥𑀸;

𑀢𑀁 𑀢𑀁 𑀅𑀬𑀸𑀘𑀦𑁆𑀢𑀺𑀫𑀳𑀁 𑀦𑀺𑀫𑀦𑁆𑀢𑀬𑁂, 𑀲𑀼𑀥𑀸𑀬 𑀬𑀜𑁆𑀘𑀺𑀘𑁆𑀙𑀲𑀺 𑀢𑀫𑁆𑀧𑀺 𑀤𑀫𑁆𑀫𑀺 𑀢𑁂.

𑁨𑁫𑁮.

‘‘𑀲𑀸 𑀢𑁆𑀯𑀁 𑀫𑀬𑀸 𑀅𑀚𑁆𑀚 𑀲𑀓𑀫𑁆𑀳𑀺 𑀅𑀲𑁆𑀲𑀫𑁂, 𑀦𑀺𑀫𑀦𑁆𑀢𑀺𑀢𑀸 𑀓𑀜𑁆𑀘𑀦𑀯𑁂𑀮𑁆𑀮𑀺𑀯𑀺𑀕𑁆𑀕𑀳𑁂;

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

𑁨𑁫𑁯.

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

𑀉𑀤𑀓𑀯𑀦𑁆𑀢𑀁 [𑀉𑀤𑀜𑁆𑀜𑀯𑀦𑁆𑀢𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀨𑀮𑀫𑀭𑀺𑀬𑀧𑀽𑀚𑀺𑀢𑀁, 𑀅𑀧𑀸𑀧𑀲𑀢𑁆𑀢𑀽𑀧𑀦𑀺𑀲𑁂𑀯𑀺𑀢𑀁 𑀲𑀤𑀸.

𑁨𑁬𑁦.

‘‘𑀭𑀼𑀓𑁆𑀔𑀕𑁆𑀕𑀳𑀸𑀦𑀸 𑀩𑀳𑀼𑀓𑁂𑀢𑁆𑀣 𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀸, 𑀅𑀫𑁆𑀩𑀸 𑀧𑀺𑀬𑀸𑀮𑀸 𑀧𑀦𑀲𑀸 𑀘 𑀓𑀺𑀁𑀲𑀼𑀓𑀸;

𑀲𑁄𑀪𑀜𑁆𑀚𑀦𑀸 𑀮𑁄𑀤𑁆𑀤𑀫𑀣𑁄𑀧𑀺 𑀧𑀤𑁆𑀫𑀓𑀸, 𑀓𑁂𑀓𑀸 𑀘 𑀪𑀗𑁆𑀕𑀸 𑀢𑀺𑀮𑀓𑀸 𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀸.

𑁨𑁬𑁧.

‘‘𑀲𑀸𑀮𑀸 ¶ 𑀓𑀭𑁂𑀭𑀻 𑀩𑀳𑀼𑀓𑁂𑀢𑁆𑀣 𑀚𑀫𑁆𑀩𑀼𑀬𑁄, 𑀅𑀲𑁆𑀲𑀢𑁆𑀣𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑀫𑀥𑀼𑀓𑀯𑁂𑀢𑀲𑀸 [𑀯𑁂𑀤𑀺𑀲𑀸 (𑀓.)];

𑀉𑀤𑁆𑀤𑀸𑀮𑀓𑀸 𑀧𑀸𑀝𑀮𑀺 𑀲𑀺𑀦𑁆𑀤𑀼𑀯𑀸𑀭𑀓𑀸 [𑀲𑀺𑀦𑁆𑀤𑀼𑀯𑀸𑀭𑀺𑀢𑀸 (𑀩𑀳𑀽𑀲𑀼)], 𑀫𑀦𑀼𑀜𑁆𑀜𑀕𑀦𑁆𑀥𑀸 𑀫𑀼𑀘𑀮𑀺𑀦𑁆𑀤𑀓𑁂𑀢𑀓𑀸.

𑁨𑁬𑁨.

‘‘𑀳𑀭𑁂𑀡𑀼𑀓𑀸 𑀯𑁂𑀴𑀼𑀓𑀸 𑀓𑁂𑀡𑀼 [𑀯𑁂𑀡𑀼 (𑀲𑀻. 𑀧𑀻.)] 𑀢𑀺𑀦𑁆𑀤𑀼𑀓𑀸, 𑀲𑀸𑀫𑀸𑀓𑀦𑀻𑀯𑀸𑀭𑀫𑀣𑁄𑀧𑀺 ¶ 𑀘𑀻𑀦𑀓𑀸;

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

𑁨𑁬𑁩.

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

𑀅𑀓𑀓𑁆𑀓𑀲𑀸 𑀅𑀧𑀩𑁆𑀪𑀸𑀭𑀸, 𑀲𑀸𑀥𑀼 𑀅𑀧𑁆𑀧𑀝𑀺𑀕𑀦𑁆𑀥𑀺𑀓𑀸.

𑁨𑁬𑁪.

‘‘𑀢𑀢𑁆𑀣 𑀫𑀘𑁆𑀙𑀸 𑀲𑀦𑁆𑀦𑀺𑀭𑀢𑀸, 𑀔𑁂𑀫𑀺𑀦𑁄 𑀩𑀳𑀼𑀪𑁄𑀚𑀦𑀸;

𑀲𑀺𑀗𑁆𑀕𑀽 𑀲𑀯𑀗𑁆𑀓𑀸 𑀲𑀁𑀓𑀼𑀮𑀸 [𑀲𑀓𑀼𑀮𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀲𑀢𑀯𑀗𑁆𑀓𑀸 𑀘 𑀭𑁄𑀳𑀺𑀢𑀸;

𑀆𑀴𑀺𑀕𑀕𑁆𑀕𑀭𑀓𑀸𑀓𑀺𑀡𑁆𑀡𑀸, 𑀧𑀸𑀞𑀻𑀦𑀸 𑀓𑀸𑀓𑀫𑀘𑁆𑀙𑀓𑀸.

𑁨𑁬𑁫.

‘‘𑀢𑀢𑁆𑀣 𑀧𑀓𑁆𑀔𑀻 𑀲𑀦𑁆𑀦𑀺𑀭𑀢𑀸, 𑀔𑁂𑀫𑀺𑀦𑁄 𑀩𑀳𑀼𑀪𑁄𑀚𑀦𑀸;

𑀳𑀁𑀲𑀸 𑀓𑁄𑀜𑁆𑀘𑀸 𑀫𑀬𑀽𑀭𑀸 𑀘, 𑀘𑀓𑁆𑀓𑀯𑀸𑀓𑀸 𑀘 𑀓𑀼𑀓𑁆𑀓𑀼𑀳𑀸;

𑀓𑀼𑀡𑀸𑀮𑀓𑀸 𑀩𑀳𑀽 𑀘𑀺𑀢𑁆𑀭𑀸, 𑀲𑀺𑀔𑀡𑁆𑀟𑀻 𑀚𑀻𑀯𑀚𑀻𑀯𑀓𑀸.

𑁨𑁬𑁬.

‘‘𑀢𑀢𑁆𑀣 𑀧𑀸𑀦𑀸𑀬 𑀫𑀸𑀬𑀦𑁆𑀢𑀺, 𑀦𑀸𑀦𑀸 𑀫𑀺𑀕𑀕𑀡𑀸 𑀩𑀳𑀽;

𑀲𑀻𑀳𑀸 𑀩𑁆𑀬𑀕𑁆𑀖𑀸 𑀯𑀭𑀸𑀳𑀸 𑀘, 𑀅𑀘𑁆𑀙𑀓𑁄𑀓𑀢𑀭𑀘𑁆𑀙𑀬𑁄.

𑁨𑁬𑁭.

‘‘𑀧𑀮𑀸𑀲𑀸𑀤𑀸 ¶ 𑀕𑀯𑀚𑀸 𑀘, 𑀫𑀳𑀺𑀁𑀲𑀸 [𑀫𑀳𑀺𑀲𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀭𑁄𑀳𑀺𑀢𑀸 𑀭𑀼𑀭𑀽;

𑀏𑀡𑁂𑀬𑁆𑀬𑀸 𑀘 𑀯𑀭𑀸𑀳𑀸 𑀘, 𑀕𑀡𑀺𑀦𑁄 𑀦𑀻𑀓𑀲𑀽𑀓𑀭𑀸;

𑀓𑀤𑀮𑀺𑀫𑀺𑀕𑀸 𑀩𑀳𑀼𑀓𑁂𑀢𑁆𑀣, 𑀩𑀺𑀴𑀸𑀭𑀸 𑀲𑀲𑀓𑀡𑁆𑀡𑀺𑀓𑀸 [𑀲𑀲𑀓𑀡𑁆𑀡𑀓𑀸 (𑀲𑀻.)].

𑁨𑁬𑁮.

‘‘𑀙𑀫𑀸𑀕𑀺𑀭𑀻 𑀧𑀼𑀧𑁆𑀨𑀯𑀺𑀘𑀺𑀢𑁆𑀭𑀲𑀦𑁆𑀣𑀢𑀸, 𑀤𑀺𑀚𑀸𑀪𑀺𑀖𑀼𑀝𑁆𑀞𑀸 𑀤𑀺𑀚𑀲𑀗𑁆𑀖𑀲𑁂𑀯𑀺𑀢𑀸’’.

𑁨𑁬𑁯.

‘‘𑀲𑀸 ¶ 𑀲𑀼𑀢𑁆𑀢𑀘𑀸 𑀦𑀻𑀮𑀤𑀼𑀫𑀸𑀪𑀺𑀮𑀫𑁆𑀩𑀺𑀢𑀸, 𑀯𑀺𑀚𑁆𑀚𑀼 𑀫𑀳𑀸𑀫𑁂𑀖𑀭𑀺𑀯𑀸𑀦𑀼𑀧𑀚𑁆𑀚𑀣;

𑀢𑀲𑁆𑀲𑀸 ¶ 𑀲𑀼𑀲𑀫𑁆𑀩𑀦𑁆𑀥𑀲𑀺𑀭𑀁 𑀓𑀼𑀲𑀸𑀫𑀬𑀁, 𑀲𑀼𑀘𑀺𑀁 𑀲𑀼𑀕𑀦𑁆𑀥𑀁 𑀅𑀚𑀺𑀦𑀽𑀧𑀲𑁂𑀯𑀺𑀢𑀁;

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

𑁨𑁭𑁦.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀢𑀤𑀸 𑀓𑁄𑀘𑁆𑀙𑀕𑀢𑀸𑀬 𑀓𑁄𑀲𑀺𑀬𑁄, 𑀬𑀤𑀺𑀘𑁆𑀙𑀫𑀸𑀦𑀸𑀬 𑀚𑀝𑀸𑀚𑀺𑀦𑀦𑁆𑀥𑀭𑁄 [𑀚𑀝𑀸𑀚𑀼𑀢𑀺𑀦𑁆𑀥𑀭𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)];

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

𑁨𑁭𑁧.

‘‘𑀲𑀸 𑀢𑀁 𑀧𑀝𑀺𑀕𑁆𑀕𑀬𑁆𑀳 𑀉𑀪𑁄𑀳𑀺 𑀧𑀸𑀡𑀺𑀪𑀺, 𑀇𑀘𑁆𑀘𑀩𑁆𑀭𑀯𑀺 𑀅𑀢𑁆𑀢𑀫𑀦𑀸 𑀚𑀝𑀸𑀥𑀭𑀁;

‘𑀳𑀦𑁆𑀤𑀸𑀳𑀁 𑀏𑀢𑀭𑀳𑀺 𑀧𑀽𑀚𑀺𑀢𑀸 𑀢𑀬𑀸, 𑀕𑀘𑁆𑀙𑁂𑀬𑁆𑀬𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑁂 𑀢𑀺𑀤𑀺𑀯𑀁 𑀚𑀺𑀢𑀸𑀯𑀺𑀦𑀻’.

𑁨𑁭𑁨.

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

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

𑁨𑁭𑁩.

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

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

𑁨𑁭𑁪.

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

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

𑀳𑀺𑀭𑀻 𑀲𑀼𑀥𑀁 𑀓𑁂𑀦 𑀫𑀮𑀢𑁆𑀣 𑀳𑁂𑀢𑀼𑀦𑀸.

𑁨𑁭𑁫.

‘‘𑀢𑀁 ¶ 𑀲𑀼 𑀯𑀢𑁆𑀣𑀁 𑀉𑀤𑀢𑀸𑀭𑀬𑀻 𑀭𑀣𑀁, 𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀁 𑀉𑀧𑀓𑀸𑀭𑀺𑀬𑀲𑀸𑀤𑀺𑀲𑀁 [𑀉𑀧𑀓𑀺𑀭𑀺𑀬𑀲𑀸𑀤𑀺𑀲𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑀚𑀫𑁆𑀩𑁄𑀦𑀤𑀻𑀲𑀁 𑀢𑀧𑀦𑁂𑀬𑁆𑀬𑀲𑀦𑁆𑀦𑀺𑀪𑀁 [𑀲𑀦𑁆𑀢𑀺𑀓𑀁 (𑀲𑀻.𑀧𑀻.)], 𑀅𑀮𑀗𑁆𑀓𑀢𑀁 𑀓𑀜𑁆𑀘𑀦𑀘𑀺𑀢𑁆𑀢𑀲𑀦𑁆𑀦𑀺𑀪𑀁.

𑁨𑁭𑁬.

‘‘𑀲𑀼𑀯𑀡𑁆𑀡𑀘𑀦𑁆𑀤𑁂𑀢𑁆𑀣 𑀩𑀳𑀽 𑀦𑀺𑀧𑀸𑀢𑀺𑀢𑀸, 𑀳𑀢𑁆𑀣𑀻 𑀕𑀯𑀲𑁆𑀲𑀸 𑀓𑀺𑀓𑀺𑀩𑁆𑀬𑀕𑁆𑀖𑀤𑀻𑀧𑀺𑀬𑁄 [𑀓𑀺𑀫𑁆𑀧𑀼𑀭𑀺𑀲𑀩𑁆𑀬𑀕𑁆𑀖𑀤𑀻𑀧𑀺𑀬𑁄 (𑀓.)];

𑀏𑀡𑁂𑀬𑁆𑀬𑀓𑀸 𑀮𑀗𑁆𑀖𑀫𑀬𑁂𑀢𑁆𑀣 𑀧𑀓𑁆𑀔𑀺𑀦𑁄 [𑀧𑀓𑁆𑀔𑀺𑀬𑁄 (𑀲𑀻. 𑀧𑀻.)], 𑀫𑀺𑀕𑁂𑀢𑁆𑀣 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀫𑀬𑀸 𑀬𑀼𑀥𑀸 𑀬𑀼𑀢𑀸.

𑁨𑁭𑁭.

‘‘𑀢𑀢𑁆𑀣𑀲𑁆𑀲𑀭𑀸𑀚𑀳𑀭𑀬𑁄 𑀅𑀬𑁄𑀚𑀬𑀼𑀁, 𑀤𑀲𑀲𑀢𑀸𑀦𑀺 𑀲𑀼𑀲𑀼𑀦𑀸𑀕𑀲𑀸𑀤𑀺𑀲𑁂;

𑀅𑀮𑀗𑁆𑀓𑀢𑁂 𑀓𑀜𑁆𑀘𑀦𑀚𑀸𑀮𑀼𑀭𑀘𑁆𑀙𑀤𑁂, 𑀆𑀯𑁂𑀴𑀺𑀦𑁂 𑀲𑀤𑁆𑀤𑀕𑀫𑁂 𑀅𑀲𑀗𑁆𑀕𑀺𑀢𑁂.

𑁨𑁭𑁮.

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

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

𑁨𑁭𑁯.

‘‘𑀲 𑀔𑀺𑀧𑁆𑀧𑀫𑁂𑀯 𑀉𑀧𑀕𑀫𑁆𑀫 𑀅𑀲𑁆𑀲𑀫𑀁, 𑀧𑀸𑀯𑀸𑀭𑀫𑁂𑀓𑀁𑀲𑀓𑀢𑁄 𑀓𑀢𑀜𑁆𑀚𑀮𑀻;

𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑀁 𑀯𑀼𑀤𑁆𑀥𑀁 𑀯𑀺𑀦𑀻𑀢𑀯𑀦𑁆𑀢𑀁, 𑀇𑀘𑁆𑀘𑀩𑁆𑀭𑀯𑀻 𑀫𑀸𑀢𑀮𑀺 𑀤𑁂𑀯𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁.

𑁨𑁮𑁦.

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

𑀆𑀲𑀸𑀬 𑀲𑀤𑁆𑀥𑀸 𑀲𑀺𑀭𑀺𑀬𑀸 𑀘 𑀓𑁄𑀲𑀺𑀬, 𑀳𑀺𑀭𑀻 𑀲𑀼𑀥𑀁 𑀓𑁂𑀦 𑀫𑀮𑀢𑁆𑀣 𑀳𑁂𑀢𑀼𑀦𑀸’’.

𑁨𑁮𑁧.

‘‘𑀅𑀦𑁆𑀥𑀸 ¶ ¶ 𑀲𑀺𑀭𑀻 𑀫𑀁 𑀧𑀝𑀺𑀪𑀸𑀢𑀺 𑀫𑀸𑀢𑀮𑀺, 𑀲𑀤𑁆𑀥𑀸 𑀅𑀦𑀺𑀘𑁆𑀘𑀸 𑀧𑀦 𑀤𑁂𑀯𑀲𑀸𑀭𑀣𑀺;

𑀆𑀲𑀸 𑀯𑀺𑀲𑀁𑀯𑀸𑀤𑀺𑀓𑀲𑀫𑁆𑀫𑀢𑀸 𑀳𑀺 𑀫𑁂, 𑀳𑀺𑀭𑀻 𑀘 𑀅𑀭𑀺𑀬𑀫𑁆𑀳𑀺 𑀕𑀼𑀡𑁂 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸’’.

𑁨𑁮𑁨.

‘‘𑀓𑀼𑀫𑀸𑀭𑀺𑀬𑁄 𑀬𑀸𑀘𑀺𑀫𑀸 𑀕𑁄𑀢𑁆𑀢𑀭𑀓𑁆𑀔𑀺𑀢𑀸, 𑀚𑀺𑀡𑁆𑀡𑀸 𑀘 𑀬𑀸 𑀬𑀸 𑀘 𑀲𑀪𑀢𑁆𑀢𑀼𑀇𑀢𑁆𑀣𑀺𑀬𑁄;

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

𑁨𑁮𑁩.

‘‘𑀲𑀗𑁆𑀕𑀸𑀫𑀲𑀻𑀲𑁂 𑀲𑀭𑀲𑀢𑁆𑀢𑀺𑀲𑀁𑀬𑀼𑀢𑁂, 𑀧𑀭𑀸𑀚𑀺𑀢𑀸𑀦𑀁 𑀧𑀢𑀢𑀁 𑀧𑀮𑀸𑀬𑀺𑀦𑀁;

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

𑁨𑁮𑁪.

‘‘𑀯𑁂𑀮𑀸 𑀬𑀣𑀸 𑀲𑀸𑀕𑀭𑀯𑁂𑀕𑀯𑀸𑀭𑀺𑀦𑀻, 𑀳𑀺𑀭𑀸𑀬 𑀳𑀺 𑀧𑀸𑀧𑀚𑀦𑀁 𑀦𑀺𑀯𑀸𑀭𑀺𑀦𑀻;

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

𑁨𑁮𑁫.

‘‘𑀓𑁄 𑀢𑁂 𑀇𑀫𑀁 𑀓𑁄𑀲𑀺𑀬 𑀤𑀺𑀝𑁆𑀞𑀺𑀫𑁄𑀤𑀳𑀺, 𑀩𑁆𑀭𑀳𑁆𑀫𑀸 𑀫𑀳𑀺𑀦𑁆𑀤𑁄 𑀅𑀣 𑀯𑀸 𑀧𑀚𑀸𑀧𑀢𑀺;

𑀳𑀺𑀭𑀸𑀬 𑀤𑁂𑀯𑁂𑀲𑀼 𑀳𑀺 𑀲𑁂𑀝𑁆𑀞𑀲𑀫𑁆𑀫𑀢𑀸, 𑀥𑀻𑀢𑀸 𑀫𑀳𑀺𑀦𑁆𑀤𑀲𑁆𑀲 𑀫𑀳𑁂𑀲𑀺 𑀚𑀸𑀬𑀣’’.

𑁨𑁮𑁬.

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

𑀇𑀦𑁆𑀤𑁄 𑀘 𑀢𑀁 𑀇𑀦𑁆𑀤𑀲𑀕𑁄𑀢𑁆𑀢 𑀓𑀗𑁆𑀔𑀢𑀺, 𑀅𑀚𑁆𑀚𑁂𑀯 𑀢𑁆𑀯𑀁 𑀇𑀦𑁆𑀤𑀲𑀳𑀩𑁆𑀬𑀢𑀁 𑀯𑀚’’.

𑁨𑁮𑁭.

‘‘𑀏𑀯𑀁 𑀯𑀺𑀲𑀼𑀚𑁆𑀛𑀦𑁆𑀢𑀺 [𑀲𑀫𑀺𑀚𑁆𑀛𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀅𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀺𑀦𑁄, 𑀅𑀣𑁄 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑀲𑁆𑀲 𑀨𑀮𑀁 𑀦 𑀦𑀲𑁆𑀲𑀢𑀺;

𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀤𑁆𑀤𑀓𑁆𑀔𑀼 𑀲𑀼𑀥𑀸𑀬 𑀪𑁄𑀚𑀦𑀁, 𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀇𑀦𑁆𑀤𑀲𑀳𑀩𑁆𑀬𑀢𑀁 𑀕𑀢𑀸’’.

𑁨𑁮𑁮.

‘‘𑀳𑀺𑀭𑀻 ¶ 𑀉𑀧𑁆𑀧𑀮𑀯𑀡𑁆𑀡𑀸𑀲𑀺, 𑀓𑁄𑀲𑀺𑀬𑁄 𑀤𑀸𑀦𑀧𑀢𑀺 𑀪𑀺𑀓𑁆𑀔𑀼;

𑀅𑀦𑀼𑀭𑀼𑀤𑁆𑀥𑁄 𑀧𑀜𑁆𑀘𑀲𑀺𑀔𑁄, 𑀆𑀦𑀦𑁆𑀤𑁄 𑀆𑀲𑀺 𑀫𑀸𑀢𑀮𑀺.

𑁨𑁮𑁯.

‘‘𑀲𑀽𑀭𑀺𑀬𑁄 𑀓𑀲𑁆𑀲𑀧𑁄 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑁄𑀲𑀺 𑀘𑀦𑁆𑀤𑀺𑀫𑀸;

𑀦𑀸𑀭𑀤𑁄 ¶ 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑁄𑀲𑀺, 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄 𑀆𑀲𑀺 𑀯𑀸𑀲𑀯𑁄’’𑀢𑀺.

𑀲𑀼𑀥𑀸𑀪𑁄𑀚𑀦𑀚𑀸𑀢𑀓𑀁 𑀢𑀢𑀺𑀬𑀁.

𑁫𑁩𑁬. 𑀓𑀼𑀡𑀸𑀮𑀚𑀸𑀢𑀓𑀁 (𑁪)

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

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

𑀧𑀜𑁆𑀘𑀲𑀢𑀸 [𑀧𑀜𑁆𑀘𑀲𑀢 (𑀧𑀻.)] 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀳𑁂𑀝𑁆𑀞𑀢𑁄 𑀳𑁂𑀝𑁆𑀞𑀢𑁄 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑁋 [𑀟𑁂𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] ‘‘𑀲𑀘𑀸𑀬𑀁 𑀓𑀼𑀡𑀸𑀮𑁄 ¶ 𑀲𑀓𑀼𑀡𑁄 𑀆𑀲𑀦𑀸 𑀧𑀭𑀺𑀧𑀢𑀺𑀲𑁆𑀲𑀢𑀺, 𑀫𑀬𑀁 𑀢𑀁 𑀧𑀓𑁆𑀔𑁂𑀳𑀺 𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑁂𑀲𑁆𑀲𑀸𑀫𑀸𑀢𑀺.

𑀧𑀜𑁆𑀘𑀲𑀢𑀸 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀉𑀧𑀭𑀽𑀧𑀭𑀺 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑁋 [𑀟𑁂𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] ‘‘𑀫𑀸 𑀦𑀁 𑀓𑀼𑀡𑀸𑀮𑀁 𑀲𑀓𑀼𑀡𑀁 𑀆𑀢𑀧𑁄 𑀧𑀭𑀺𑀢𑀸𑀧𑁂𑀲𑀻’’𑀢𑀺 [𑀧𑀭𑀺𑀓𑀸𑀧𑀻𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)].

𑀧𑀜𑁆𑀘𑀲𑀢𑀸 ¶ 𑀧𑀜𑁆𑀘𑀲𑀢𑀸 [𑀲𑀻. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼 ‘‘𑀧𑀜𑁆𑀘𑀲𑀢𑀸’’𑀢𑀺 𑀲𑀓𑀺𑀤𑁂𑀯 𑀆𑀕𑀢𑀁] 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀉𑀪𑀢𑁄𑀧𑀲𑁆𑀲𑁂𑀦 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑁋 [𑀟𑁂𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] ‘‘𑀫𑀸 𑀦𑀁 𑀓𑀼𑀡𑀸𑀮𑀁 𑀲𑀓𑀼𑀡𑀁 𑀲𑀻𑀢𑀁 𑀯𑀸 𑀉𑀡𑁆𑀳𑀁 𑀯𑀸 𑀢𑀺𑀡𑀁 𑀯𑀸 𑀭𑀚𑁄 𑀯𑀸 𑀯𑀸𑀢𑁄 𑀯𑀸 𑀉𑀲𑁆𑀲𑀸𑀯𑁄 𑀯𑀸 𑀉𑀧𑀧𑁆𑀨𑀼𑀲𑀻’’𑀢𑀺.

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

𑀧𑀜𑁆𑀘𑀲𑀢𑀸 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀧𑀘𑁆𑀙𑀢𑁄 𑀧𑀘𑁆𑀙𑀢𑁄 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑀲𑀡𑁆𑀳𑀸𑀳𑀺 𑀲𑀔𑀺𑀮𑀸𑀳𑀺 𑀫𑀜𑁆𑀚𑀽𑀳𑀺 𑀫𑀥𑀼𑀭𑀸𑀳𑀺 𑀯𑀸𑀘𑀸𑀳𑀺 𑀲𑀫𑀼𑀤𑀸𑀘𑀭𑀦𑁆𑀢𑀺𑀬𑁄 𑁋 ‘‘𑀫𑀸𑀬𑀁 𑀓𑀼𑀡𑀸𑀮𑁄 𑀲𑀓𑀼𑀡𑁄 𑀆𑀲𑀦𑁂 𑀧𑀭𑀺𑀬𑀼𑀓𑁆𑀓𑀡𑁆𑀞𑀻’’𑀢𑀺.

𑀧𑀜𑁆𑀘𑀲𑀢𑀸 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀤𑀺𑀲𑁄𑀤𑀺𑀲𑀁 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑀅𑀦𑁂𑀓𑀭𑀼𑀓𑁆𑀔𑀯𑀺𑀯𑀺𑀥𑀯𑀺𑀓𑀢𑀺𑀨𑀮𑀫𑀸𑀳𑀭𑀦𑁆𑀢𑀺𑀬𑁄 𑁋 ‘‘𑀫𑀸𑀬𑀁 𑀓𑀼𑀡𑀸𑀮𑁄 𑀲𑀓𑀼𑀡𑁄 𑀔𑀼𑀤𑀸𑀬 𑀧𑀭𑀺𑀓𑀺𑀮𑀫𑀺𑀢𑁆𑀣𑀸’’𑀢𑀺.

𑀅𑀣 𑀔𑀮𑀼, 𑀪𑁄, 𑀢𑀸 [𑀦𑀢𑁆𑀣𑀺 𑀲𑀻. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼] 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀢𑀁 𑀓𑀼𑀡𑀸𑀮𑀁 𑀲𑀓𑀼𑀡𑀁 𑀆𑀭𑀸𑀫𑁂𑀦𑁂𑀯 𑀆𑀭𑀸𑀫𑀁 𑀉𑀬𑁆𑀬𑀸𑀦𑁂𑀦𑁂𑀯 𑀉𑀬𑁆𑀬𑀸𑀦𑀁 ¶ 𑀦𑀤𑀻𑀢𑀺𑀢𑁆𑀣𑁂𑀦𑁂𑀯 𑀦𑀤𑀻𑀢𑀺𑀢𑁆𑀣𑀁 𑀧𑀩𑁆𑀩𑀢𑀲𑀺𑀔𑀭𑁂𑀦𑁂𑀯 𑀧𑀩𑁆𑀩𑀢𑀲𑀺𑀔𑀭𑀁 𑀅𑀫𑁆𑀩𑀯𑀦𑁂𑀦𑁂𑀯 𑀅𑀫𑁆𑀩𑀯𑀦𑀁 𑀚𑀫𑁆𑀩𑀼𑀯𑀦𑁂𑀦𑁂𑀯 𑀚𑀫𑁆𑀩𑀼𑀯𑀦𑀁 𑀮𑀩𑀼𑀚𑀯𑀦𑁂𑀦𑁂𑀯 𑀮𑀩𑀼𑀚𑀯𑀦𑀁 𑀦𑀸𑀴𑀺𑀓𑁂𑀭𑀲𑀜𑁆𑀘𑀸𑀭𑀺𑀬𑁂𑀦𑁂𑀯 [𑀲𑀜𑁆𑀚𑀸𑀤𑀺𑀬𑁂𑀦𑁂𑀯 (𑀧𑀻.)] 𑀦𑀸𑀴𑀺𑀓𑁂𑀭𑀲𑀜𑁆𑀘𑀸𑀭𑀺𑀬𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑁂𑀯 𑀅𑀪𑀺𑀲𑀫𑁆𑀪𑁄𑀦𑁆𑀢𑀺 ¶ 𑀭𑀢𑀺𑀢𑁆𑀣𑀸𑀬 [𑀭𑀢𑀢𑁆𑀣𑀸𑀬 (𑀲𑀻. 𑀧𑀻.)].

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

𑀢𑀲𑁆𑀲𑁂𑀯 𑀔𑀮𑀼, 𑀪𑁄, 𑀳𑀺𑀫𑀯𑀢𑁄 𑀧𑀩𑁆𑀩𑀢𑀭𑀸𑀚𑀲𑁆𑀲 𑀧𑀼𑀭𑀢𑁆𑀣𑀺𑀫𑀤𑀺𑀲𑀸𑀪𑀸𑀕𑁂 𑀲𑀼𑀲𑀼𑀔𑀼𑀫𑀲𑀼𑀦𑀺𑀧𑀼𑀡𑀕𑀺𑀭𑀺𑀧𑁆𑀧𑀪𑀯 [𑀧𑁆𑀧𑀪𑀯𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑁋 𑀳𑀭𑀺𑀢𑀼𑀧𑀬𑀦𑁆𑀢𑀺𑀬𑁄.

𑀉𑀧𑁆𑀧𑀮 ¶ 𑀧𑀤𑀼𑀫 𑀓𑀼𑀫𑀼𑀤 𑀦𑀴𑀺𑀦 𑀲𑀢𑀧𑀢𑁆𑀢 𑀲𑁄𑀕𑀦𑁆𑀥𑀺𑀓 𑀫𑀦𑁆𑀤𑀸𑀮𑀓 [𑀫𑀦𑁆𑀤𑀸𑀮𑀯 (𑀲𑀻. 𑀧𑀻.), 𑀫𑀦𑁆𑀤𑀸𑀭𑀯 (𑀓.)] 𑀲𑀫𑁆𑀧𑀢𑀺𑀯𑀺𑀭𑀽𑀴𑁆𑀳𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥 𑀫𑀦𑀼𑀜𑁆𑀜𑀫𑀸𑀯𑀓𑀧𑁆𑀧𑀤𑁂𑀲𑁂 [𑀧𑀸𑀯𑀓𑀧𑁆𑀧𑀤𑁂𑀲𑁂 (𑀲𑀻. 𑀧𑀻.)].

𑀓𑀼𑀭𑀯𑀓-𑀫𑀼𑀘𑀮𑀺𑀦𑁆𑀤-𑀓𑁂𑀢𑀓-𑀯𑁂𑀤𑀺𑀲-𑀯𑀜𑁆𑀚𑀼𑀮 [𑀯𑁂𑀢𑀲𑀫𑀜𑁆𑀚𑀼𑀮 (𑀲𑀻.)] -𑀧𑀼𑀦𑁆𑀦𑀸𑀕𑀩𑀓𑀼𑀮-𑀢𑀺𑀮𑀓-𑀧𑀺𑀬𑀓-𑀳𑀲𑀦𑀲𑀸𑀮-𑀲𑀴𑀮𑀘𑀫𑁆𑀧𑀓 𑀅𑀲𑁄𑀓-𑀦𑀸𑀕𑀭𑀼𑀓𑁆𑀔-𑀢𑀺𑀭𑀻𑀝𑀺-𑀪𑀼𑀚𑀧𑀢𑁆𑀢-𑀮𑁄𑀤𑁆𑀤-𑀘𑀦𑁆𑀤𑀦𑁄𑀖𑀯𑀦𑁂𑀓𑀸𑀴𑀸𑀕𑀭𑀼-𑀧𑀤𑁆𑀫𑀓-𑀧𑀺𑀬𑀗𑁆𑀕𑀼-𑀤𑁂𑀯𑀤𑀸𑀭𑀼𑀓𑀘𑁄𑀘𑀕𑀳𑀦𑁂 𑀓𑀓𑀼𑀥𑀓𑀼𑀝𑀚𑀅𑀗𑁆𑀓𑁄𑀮-𑀓𑀘𑁆𑀘𑀺𑀓𑀸𑀭 [𑀓𑀘𑁆𑀙𑀺𑀓𑀸𑀭 (𑀓.)] -𑀓𑀡𑀺𑀓𑀸𑀭-𑀓𑀡𑁆𑀡𑀺𑀓𑀸𑀭-𑀓𑀦𑀯𑁂𑀭-𑀓𑁄𑀭𑀡𑁆𑀟𑀓-𑀓𑁄𑀯𑀺𑀴𑀸𑀭-𑀓𑀺𑀁𑀲𑀼𑀓-𑀬𑁄𑀥𑀺𑀓 𑀯𑀦𑀫𑀮𑁆𑀮𑀺𑀓 [𑀦𑀯𑀫𑀮𑁆𑀮𑀺𑀓 (𑀲𑀻. 𑀧𑀻.)] -𑀫𑀦𑀗𑁆𑀕𑀡-𑀫𑀦𑀯𑀚𑁆𑀚-𑀪𑀡𑁆𑀟𑀺-𑀲𑀼𑀭𑀼𑀘𑀺𑀭-𑀪𑀕𑀺𑀦𑀺𑀫𑀸𑀮𑀸𑀫𑀮𑁆𑀬𑀥𑀭𑁂 𑀚𑀸𑀢𑀺𑀲𑀼𑀫𑀦𑀫𑀥𑀼𑀕𑀦𑁆𑀥𑀺𑀓- [𑀫𑀥𑀼𑀓𑀩𑀦𑁆𑀥𑀼𑀓 (𑀓.)] 𑀥𑀦𑀼𑀢𑀓𑁆𑀓𑀸𑀭𑀺 [𑀥𑀦𑀼𑀓𑀸𑀭𑀺 (𑀲𑀻.), 𑀥𑀦𑀼𑀓𑀸𑀭𑀺𑀓 (𑀧𑀻.)] 𑀢𑀸𑀮𑀻𑀲-𑀢𑀕𑀭𑀫𑀼𑀲𑀻𑀭𑀓𑁄𑀝𑁆𑀞-𑀓𑀘𑁆𑀙𑀯𑀺𑀢𑀢𑁂 𑀅𑀢𑀺𑀫𑀼𑀢𑁆𑀢𑀓𑀲𑀁𑀓𑀼𑀲𑀼𑀫𑀺𑀢𑀮𑀢𑀸𑀯𑀺𑀢𑀢𑀧𑀝𑀺𑀫𑀡𑁆𑀟𑀺𑀢𑀧𑁆𑀧𑀤𑁂𑀲𑁂 𑀳𑀁𑀲-𑀧𑀺𑀮𑀯-𑀓𑀸𑀤𑀫𑁆𑀩-𑀓𑀸𑀭𑀡𑁆𑀟𑀯𑀸𑀪𑀺𑀦𑀤𑀺𑀢𑁂 𑀯𑀺𑀚𑁆𑀚𑀸𑀥𑀭-𑀲𑀺𑀤𑁆𑀥 [𑀲𑀺𑀦𑁆𑀥𑀯 (𑀲𑀻. 𑀧𑀻.)] -𑀲𑀫𑀡-𑀢𑀸𑀧𑀲𑀕𑀡𑀸𑀥𑀺𑀯𑀼𑀝𑁆𑀞𑁂 𑀯𑀭𑀤𑁂𑀯-𑀬𑀓𑁆𑀔-𑀭𑀓𑁆𑀔𑀲-𑀤𑀸𑀦𑀯-𑀕𑀦𑁆𑀥𑀩𑁆𑀩-𑀓𑀺𑀦𑁆𑀦𑀭𑀫𑀳𑁄𑀭𑀕𑀸𑀦𑀼𑀘𑀺𑀡𑁆𑀡𑀧𑁆𑀧𑀤𑁂𑀲𑁂 𑀏𑀯𑀭𑀽𑀧𑁂 𑀔𑀮𑀼, 𑀪𑁄, 𑀭𑀫𑁆𑀫𑁂 𑀯𑀦𑀲𑀡𑁆𑀟𑁂 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑁄 𑀦𑀸𑀫 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑁄 𑀧𑀝𑀺𑀯𑀲𑀢𑀺 𑀅𑀢𑀺𑀯𑀺𑀬 𑀫𑀥𑀼𑀭𑀕𑀺𑀭𑁄 𑀯𑀺𑀮𑀸𑀲𑀺𑀢𑀦𑀬𑀦𑁄 𑀫𑀢𑁆𑀢𑀓𑁆𑀔𑁄 [𑀲𑀯𑀺𑀮𑀸𑀲𑀺𑀢𑀦𑀬𑀦𑀫𑀢𑁆𑀢𑀓𑁆𑀔𑁄 (𑀓.)].

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

𑀧𑀜𑁆𑀜𑀸𑀲 ¶ 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀳𑁂𑀝𑁆𑀞𑀢𑁄 𑀳𑁂𑀝𑁆𑀞𑀢𑁄 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑁋 ‘‘𑀲𑀘𑀸𑀬𑀁 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑁄 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑁄 𑀆𑀲𑀦𑀸 𑀧𑀭𑀺𑀧𑀢𑀺𑀲𑁆𑀲𑀢𑀺, 𑀫𑀬𑀁 𑀢𑀁 𑀧𑀓𑁆𑀔𑁂𑀳𑀺 𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑁂𑀲𑁆𑀲𑀸𑀫𑀸’’𑀢𑀺.

𑀧𑀜𑁆𑀜𑀸𑀲 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀉𑀧𑀭𑀽𑀧𑀭𑀺 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑁋 ‘‘𑀫𑀸 𑀦𑀁 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑀁 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑀁 𑀆𑀢𑀧𑁄 𑀧𑀭𑀺𑀢𑀸𑀧𑁂𑀲𑀻’’𑀢𑀺.

𑀧𑀜𑁆𑀜𑀸𑀲 𑀧𑀜𑁆𑀜𑀸𑀲 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀉𑀪𑀢𑁄𑀧𑀲𑁆𑀲𑁂𑀦 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑁋 ‘‘𑀫𑀸 𑀦𑀁 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑀁 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑀁 𑀲𑀻𑀢𑀁 𑀯𑀸 𑀉𑀡𑁆𑀳𑀁 𑀯𑀸 𑀢𑀺𑀡𑀁 𑀯𑀸 𑀭𑀚𑁄 𑀯𑀸 𑀯𑀸𑀢𑁄 𑀯𑀸 𑀉𑀲𑁆𑀲𑀸𑀯𑁄 𑀯𑀸 𑀉𑀧𑀧𑁆𑀨𑀼𑀲𑀻’’𑀢𑀺.

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

𑀧𑀜𑁆𑀜𑀸𑀲 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀧𑀘𑁆𑀙𑀢𑁄 𑀧𑀘𑁆𑀙𑀢𑁄 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑀲𑀡𑁆𑀳𑀸𑀳𑀺 𑀲𑀔𑀺𑀮𑀸𑀳𑀺 𑀫𑀜𑁆𑀚𑀽𑀳𑀺 𑀫𑀥𑀼𑀭𑀸𑀳𑀺 𑀯𑀸𑀘𑀸𑀳𑀺 𑀲𑀫𑀼𑀤𑀸𑀘𑀭𑀦𑁆𑀢𑀺𑀬𑁄 𑁋 ‘‘𑀫𑀸𑀬𑀁 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑁄 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑁄 𑀆𑀲𑀦𑁂 𑀧𑀭𑀺𑀬𑀼𑀓𑁆𑀓𑀡𑁆𑀞𑀻’’𑀢𑀺.

𑀧𑀜𑁆𑀜𑀸𑀲 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀤𑀺𑀲𑁄𑀤𑀺𑀲𑀁 𑀉𑀟𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑀅𑀦𑁂𑀓𑀭𑀼𑀓𑁆𑀔𑀯𑀺𑀯𑀺𑀥𑀯𑀺𑀓𑀢𑀺𑀨𑀮𑀫𑀸𑀳𑀭𑀦𑁆𑀢𑀺𑀬𑁄 𑁋 ‘‘𑀫𑀸𑀬𑀁 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑁄 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑁄 𑀔𑀼𑀤𑀸𑀬 𑀧𑀭𑀺𑀓𑀺𑀮𑀫𑀺𑀢𑁆𑀣𑀸’’𑀢𑀺.

𑀅𑀣 𑀔𑀮𑀼, 𑀪𑁄, 𑀢𑀸 𑀤𑀺𑀚𑀓𑀜𑁆𑀜𑀸𑀬𑁄 𑀢𑀁 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑀁 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑀁 ¶ 𑀆𑀭𑀸𑀫𑁂𑀦𑁂𑀯 𑀆𑀭𑀸𑀫𑀁 𑀉𑀬𑁆𑀬𑀸𑀦𑁂𑀦𑁂𑀯 𑀉𑀬𑁆𑀬𑀸𑀦𑀁 𑀦𑀤𑀻𑀢𑀺𑀢𑁆𑀣𑁂𑀦𑁂𑀯 𑀦𑀤𑀻𑀢𑀺𑀢𑁆𑀣𑀁 𑀧𑀩𑁆𑀩𑀢𑀲𑀺𑀔𑀭𑁂𑀦𑁂𑀯 𑀧𑀩𑁆𑀩𑀢𑀲𑀺𑀔𑀭𑀁 𑀅𑀫𑁆𑀩𑀯𑀦𑁂𑀦𑁂𑀯 𑀅𑀫𑁆𑀩𑀯𑀦𑀁 𑀚𑀫𑁆𑀩𑀼𑀯𑀦𑁂𑀦𑁂𑀯 𑀚𑀫𑁆𑀩𑀼𑀯𑀦𑀁 𑀮𑀩𑀼𑀚𑀯𑀦𑁂𑀦𑁂𑀯 𑀮𑀩𑀼𑀚𑀯𑀦𑀁 𑀦𑀸𑀴𑀺𑀓𑁂𑀭𑀲𑀜𑁆𑀘𑀸𑀭𑀺𑀬𑁂𑀦𑁂𑀯 𑀦𑀸𑀴𑀺𑀓𑁂𑀭𑀲𑀜𑁆𑀘𑀸𑀭𑀺𑀬𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑁂𑀯 𑀅𑀪𑀺𑀲𑀫𑁆𑀪𑁄𑀦𑁆𑀢𑀺 𑀭𑀢𑀺𑀢𑁆𑀣𑀸𑀬.

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

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

𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂, 𑀓𑀼𑀡𑀸𑀮𑁄 𑀲𑀓𑀼𑀡𑁄 𑀢𑀁 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑀁 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑀁 𑀏𑀯𑀁 𑀅𑀧𑀲𑀸𑀤𑁂𑀲𑀺 𑁋 ‘‘𑀦𑀲𑁆𑀲 𑀢𑁆𑀯𑀁, 𑀲𑀫𑁆𑀫 𑀚𑀫𑁆𑀫 𑀯𑀲𑀮, 𑀯𑀺𑀦𑀲𑁆𑀲 𑀢𑁆𑀯𑀁, 𑀲𑀫𑁆𑀫 𑀚𑀫𑁆𑀫 𑀯𑀲𑀮, 𑀓𑁄 𑀦𑀼 𑀢𑀬𑀸 𑀯𑀺𑀬𑀢𑁆𑀢𑁄 𑀚𑀸𑀬𑀸𑀚𑀺𑀦𑁂𑀦𑀸’’𑀢𑀺. 𑀏𑀯𑀁 𑀅𑀧𑀲𑀸𑀤𑀺𑀢𑁄 𑀘 𑀧𑀦 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔𑁄 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑁄 𑀢𑀢𑁄𑀬𑁂𑀯 [𑀢𑀢𑁄 𑀳𑁂𑀯 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀝𑀺𑀦𑀺𑀯𑀢𑁆𑀢𑀺.

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

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

‘‘𑀤𑀺𑀝𑁆𑀞𑀸 𑀫𑀬𑀸, 𑀲𑀫𑁆𑀫 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔, 𑀓𑀡𑁆𑀳𑀸 𑀤𑁆𑀯𑁂𑀧𑀺𑀢𑀺𑀓𑀸 𑀧𑀜𑁆𑀘𑀧𑀢𑀺𑀓𑀸𑀬 𑀙𑀝𑁆𑀞𑁂 𑀧𑀼𑀭𑀺𑀲𑁂 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀝𑀺𑀩𑀦𑁆𑀥𑀦𑁆𑀢𑀺𑀬𑀸, 𑀬𑀤𑀺𑀤𑀁 𑀓𑀩𑀦𑁆𑀥𑁂 [𑀓𑀯𑀦𑁆𑀥𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀻𑀞𑀲𑀧𑁆𑀧𑀺𑀫𑁆𑀳𑀻𑀢𑀺. 𑀪𑀯𑀢𑀺 𑀘 𑀧𑀦𑀼𑀢𑁆𑀢𑀭𑁂𑀢𑁆𑀣 [𑀧𑀼𑀦𑀼𑀢𑁆𑀢𑀘𑁂𑀢𑁆𑀣 (𑀓.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] 𑀯𑀸𑀓𑁆𑀬𑀁 𑁋

𑁨𑁯𑁦.

‘‘𑀅𑀣𑀚𑁆𑀚𑀼𑀦𑁄 𑀦𑀓𑀼𑀮𑁄 𑀪𑀻𑀫𑀲𑁂𑀦𑁄 [𑀪𑀺𑀫𑁆𑀫𑀲𑁂𑀦𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀬𑀼𑀥𑀺𑀝𑁆𑀞𑀺𑀮𑁄 𑀲𑀳𑀤𑁂𑀯𑁄 [𑀲𑀻𑀳𑀤𑁂𑀯𑁄 (𑀓.)] 𑀘 𑀭𑀸𑀚𑀸;

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

‘‘𑀤𑀺𑀝𑁆𑀞𑀸 𑀫𑀬𑀸, 𑀲𑀫𑁆𑀫 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔, 𑀲𑀘𑁆𑀘𑀢𑀧𑀸𑀧𑀻 [𑀲𑀘𑁆𑀘𑀢𑀧𑀸𑀯𑀻 (𑀲𑀻. 𑀧𑀻.), 𑀧𑀜𑁆𑀘𑀢𑀧𑀸𑀯𑀻 (𑀲𑁆𑀬𑀸.)] 𑀦𑀸𑀫 𑀲𑀫𑀡𑀻 𑀲𑀼𑀲𑀸𑀦𑀫𑀚𑁆𑀛𑁂 𑀯𑀲𑀦𑁆𑀢𑀻 𑀘𑀢𑀼𑀢𑁆𑀣𑀪𑀢𑁆𑀢𑀁 𑀧𑀭𑀺𑀡𑀸𑀫𑀬𑀫𑀸𑀦𑀸 𑀲𑀼𑀭𑀸𑀥𑀼𑀢𑁆𑀢𑀓𑁂𑀦 [𑀢𑀼𑀮𑀸𑀧𑀼𑀢𑁆𑀢𑀓𑁂𑀦 (𑀲𑀻. 𑀧𑀻.), 𑀲𑀸 𑀲𑀼𑀭𑀸𑀥𑀼𑀢𑁆𑀢𑀓𑁂𑀦 (𑀓.)] 𑀧𑀸𑀧𑀫𑀓𑀸𑀲𑀺.

‘‘𑀤𑀺𑀝𑁆𑀞𑀸 𑀫𑀬𑀸, 𑀲𑀫𑁆𑀫 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔, 𑀓𑀸𑀓𑀯𑀢𑀻 [𑀓𑀸𑀓𑀸𑀢𑀻 (𑀲𑀻.), 𑀓𑀸𑀓𑀸𑀢𑀺 (𑀧𑀻.)] 𑀦𑀸𑀫 𑀤𑁂𑀯𑀻 𑀲𑀫𑀼𑀤𑁆𑀤𑀫𑀚𑁆𑀛𑁂 𑀯𑀲𑀦𑁆𑀢𑀻 𑀪𑀭𑀺𑀬𑀸 𑀯𑁂𑀦𑀢𑁂𑀬𑁆𑀬𑀲𑁆𑀲 𑀦𑀝𑀓𑀼𑀯𑁂𑀭𑁂𑀦 𑀧𑀸𑀧𑀫𑀓𑀸𑀲𑀺.

𑀤𑀺𑀝𑁆𑀞𑀸 𑀫𑀬𑀸, 𑀲𑀫𑁆𑀫 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔, 𑀓𑀼𑀭𑀼𑀗𑁆𑀕𑀤𑁂𑀯𑀻 [𑀓𑀼𑀭𑀗𑁆𑀕𑀯𑀻 (𑀲𑀻. 𑀧𑀻.)] 𑀦𑀸𑀫 𑀮𑁄𑀫𑀲𑀼𑀤𑁆𑀤𑀭𑀻 [𑀮𑁄𑀫𑀲𑀼𑀦𑁆𑀤𑀭𑀻 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀏𑀴𑀺𑀓𑀓𑀼𑀫𑀸𑀭𑀁 [𑀏𑀴𑀫𑀸𑀭𑀓𑀁 (𑀲𑀻.), 𑀏𑀴𑀓𑀓𑀼𑀫𑀸𑀭𑀁 (𑀲𑁆𑀬𑀸.), 𑀏𑀴𑀓𑀫𑀸𑀭𑀁 (𑀧𑀻.)] 𑀓𑀸𑀫𑀬𑀫𑀸𑀦𑀸 𑀙𑀴𑀗𑁆𑀕𑀓𑀼𑀫𑀸𑀭𑀥𑀦𑀦𑁆𑀢𑁂𑀯𑀸𑀲𑀺𑀦𑀸 𑀧𑀸𑀧𑀫𑀓𑀸𑀲𑀺.

𑀏𑀯𑀜𑁆𑀳𑁂𑀢𑀁 ¶ 𑀫𑀬𑀸 𑀜𑀸𑀢𑀁, 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀲𑁆𑀲 𑀫𑀸𑀢𑀭𑀁 [𑀫𑀸𑀢𑀼𑀓𑀸 (𑀲𑁆𑀬𑀸.)] 𑀑𑀳𑀸𑀬 𑀓𑁄𑀲𑀮𑀭𑀸𑀚𑀁 𑀧𑀜𑁆𑀘𑀸𑀮𑀘𑀡𑁆𑀟𑁂𑀦 𑀧𑀸𑀧𑀫𑀓𑀸𑀲𑀺.

𑁨𑁯𑁧.

‘‘𑀏𑀢𑀸 𑀘 𑀅𑀜𑁆𑀜𑀸 𑀘 𑀅𑀓𑀁𑀲𑀼 𑀧𑀸𑀧𑀁, 𑀢𑀲𑁆𑀫𑀸𑀳𑀫𑀺𑀢𑁆𑀣𑀻𑀦𑀁 𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀦𑀧𑁆𑀧𑀲𑀁𑀲𑁂;

𑀫𑀳𑀻 𑀬𑀣𑀸 𑀚𑀕𑀢𑀺 𑀲𑀫𑀸𑀦𑀭𑀢𑁆𑀢𑀸, 𑀯𑀲𑀼𑀦𑁆𑀥𑀭𑀸 𑀇𑀢𑀭𑀻𑀢𑀭𑀸𑀧𑀢𑀺𑀝𑁆𑀞𑀸 [𑀇𑀢𑀭𑀻𑀢𑀭𑀸𑀦𑀁 𑀧𑀢𑀺𑀝𑁆𑀞𑀸 (𑀲𑁆𑀬𑀸.), 𑀇𑀢𑁆𑀢𑀭𑀻𑀢𑀭𑀧𑁆𑀧𑀢𑀺𑀝𑁆𑀞𑀸 (?)];

𑀲𑀩𑁆𑀩𑀲𑀳𑀸 𑀅𑀨𑀦𑁆𑀤𑀦𑀸 𑀅𑀓𑀼𑀧𑁆𑀧𑀸, 𑀢𑀣𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀢𑀸𑀬𑁄 𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀦𑀭𑁄.

𑁨𑁯𑁨.

‘‘𑀲𑀻𑀳𑁄 ¶ 𑀬𑀣𑀸 𑀮𑁄𑀳𑀺𑀢𑀫𑀁𑀲𑀪𑁄𑀚𑀦𑁄, 𑀯𑀸𑀴𑀫𑀺𑀕𑁄 𑀧𑀜𑁆𑀘𑀸𑀯𑀼𑀥𑁄 [𑀧𑀜𑁆𑀘𑀳𑀢𑁆𑀣𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀼𑀭𑀼𑀤𑁆𑀥𑁄;

𑀧𑀲𑀬𑁆𑀳𑀔𑀸𑀤𑀻 𑀧𑀭𑀳𑀺𑀁𑀲𑀦𑁂 𑀭𑀢𑁄, 𑀢𑀣𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀢𑀸𑀬𑁄 𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀦𑀭𑁄.

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

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

𑁨𑁯𑁩.

‘‘𑀬𑀣𑀸 ¶ 𑀘𑁄𑀭𑁄 𑀬𑀣𑀸 𑀤𑀺𑀤𑁆𑀥𑁄, 𑀯𑀸𑀡𑀺𑀚𑁄𑀯 𑀯𑀺𑀓𑀢𑁆𑀣𑀦𑀻;

𑀇𑀲𑁆𑀲𑀲𑀺𑀗𑁆𑀖𑀫𑀺𑀯 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑀸 [𑀫𑀺𑀯𑀸𑀯𑀝𑁆𑀝𑁄 (𑀲𑀻.), 𑀫𑀺𑀯𑀸𑀯𑀢𑁆𑀢𑀸 (𑀧𑀻.)], 𑀤𑀼𑀚𑀺𑀯𑁆𑀳𑀸 [𑀤𑀼𑀚𑁆𑀚𑀺𑀯𑁆𑀳 (𑀧𑀻.)] 𑀉𑀭𑀕𑁄 𑀯𑀺𑀬.

𑁨𑁯𑁪.

‘‘𑀲𑁄𑀩𑁆𑀪𑀫𑀺𑀯 𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑀸, 𑀧𑀸𑀢𑀸𑀮𑀫𑀺𑀯 𑀤𑀼𑀧𑁆𑀧𑀼𑀭𑀸;

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

𑁨𑁯𑁫.

[𑀬𑀣𑀸 𑀲𑀺𑀔𑀻 𑀦𑀤𑀻𑀯𑀸𑀳𑁄, 𑀅𑀦𑀺𑀮𑁄 𑀓𑀸𑀫𑀘𑀸𑀭𑀯𑀸;§𑀦𑁂𑀭𑀽𑀯 𑀅𑀯𑀺𑀲𑁂𑀲𑀸 𑀘, 𑀯𑀺𑀲𑀭𑀼𑀓𑁆𑀔𑁄 𑀯𑀺𑀬 𑀦𑀺𑀘𑁆𑀘𑀨𑀮𑀸;§𑀦𑀸𑀲𑀬𑀦𑁆𑀢𑀺 𑀖𑀭𑁂 𑀪𑁄𑀕𑀁, 𑀭𑀢𑀦𑀸𑀦𑀦𑁆𑀢𑀓𑀭𑀺𑀢𑁆𑀣𑀺 𑀬𑁄𑀢𑀺; (𑀲𑀻. 𑀲𑁆𑀬𑀸.)]

‘‘𑀬𑀣𑀸 𑀲𑀺𑀔𑀻 𑀦𑀤𑀻 𑀯𑀸𑀢𑁄, 𑀦𑁂𑀭𑀼𑀦𑀸𑀯 𑀲𑀫𑀸𑀕𑀢𑀸.

𑀯𑀺𑀲𑀭𑀼𑀓𑁆𑀔𑁄 𑀯𑀺𑀬 𑀦𑀺𑀘𑁆𑀘𑀨𑀮𑀸, 𑀦𑀸𑀲𑀬𑀦𑁆𑀢𑀺 𑀖𑀭𑁂 𑀪𑁄𑀕𑀁;

𑀭𑀢𑀦𑀦𑁆𑀢𑀓𑀭𑀺𑀢𑁆𑀣𑀺𑀬𑁄’’𑀢𑀺 [𑀬𑀣𑀸 𑀲𑀺𑀔𑀻 𑀦𑀤𑀻𑀯𑀸𑀳𑁄, 𑀅𑀦𑀺𑀮𑁄 𑀓𑀸𑀫𑀘𑀸𑀭𑀯𑀸;§𑀦𑁂𑀭𑀽𑀯 𑀅𑀯𑀺𑀲𑁂𑀲𑀸 𑀘, 𑀯𑀺𑀲𑀭𑀼𑀓𑁆𑀔𑁄 𑀯𑀺𑀬 𑀦𑀺𑀘𑁆𑀘𑀨𑀮𑀸;§𑀦𑀸𑀲𑀬𑀦𑁆𑀢𑀺 𑀖𑀭𑁂 𑀪𑁄𑀕𑀁, 𑀭𑀢𑀦𑀸𑀦𑀦𑁆𑀢𑀓𑀭𑀺𑀢𑁆𑀣𑀺 𑀬𑁄𑀢𑀺; (𑀲𑀻. 𑀲𑁆𑀬𑀸.)].

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

𑁨𑁯𑁬.

‘𑀕𑁄𑀡𑀁 ¶ 𑀥𑁂𑀦𑀼𑀜𑁆𑀘 𑀬𑀸𑀦𑀜𑁆𑀘, 𑀪𑀭𑀺𑀬𑀁 𑀜𑀸𑀢𑀺𑀓𑀼𑀮𑁂 𑀦 𑀯𑀸𑀲𑀬𑁂;

𑀪𑀜𑁆𑀚𑀦𑁆𑀢𑀺 𑀭𑀣𑀁 𑀅𑀬𑀸𑀦𑀓𑀸, 𑀅𑀢𑀺𑀯𑀸𑀳𑁂𑀦 𑀳𑀦𑀦𑁆𑀢𑀺 𑀧𑀼𑀗𑁆𑀕𑀯𑀁;

𑀤𑁄𑀳𑁂𑀦 𑀳𑀦𑀦𑁆𑀢𑀺 𑀯𑀘𑁆𑀙𑀓𑀁, 𑀪𑀭𑀺𑀬𑀸 𑀜𑀸𑀢𑀺𑀓𑀼𑀮𑁂 𑀧𑀤𑀼𑀲𑁆𑀲𑀢𑀻’’’𑀢𑀺.

‘‘𑀙 𑀇𑀫𑀸𑀦𑀺, 𑀲𑀫𑁆𑀫 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔, 𑀬𑀸𑀦𑀺 (𑀯𑀢𑁆𑀣𑀽𑀦𑀺) [( ) 𑀲𑀻. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼 𑀦𑀼 𑀤𑀺𑀲𑁆𑀲𑀢𑀺] 𑀓𑀺𑀘𑁆𑀘𑁂 𑀚𑀸𑀢𑁂 𑀅𑀦𑀢𑁆𑀣𑀘𑀭𑀸𑀦𑀺 𑀪𑀯𑀦𑁆𑀢𑀺 𑁋

𑁨𑁯𑁭.

‘𑀅𑀕𑀼𑀡𑀁 𑀥𑀦𑀼 𑀜𑀸𑀢𑀺𑀓𑀼𑀮𑁂 𑀘 𑀪𑀭𑀺𑀬𑀸, 𑀧𑀸𑀭𑀁 𑀦𑀸𑀯𑀸 𑀅𑀓𑁆𑀔𑀪𑀕𑁆𑀕𑀜𑁆𑀘 𑀬𑀸𑀦𑀁;

𑀤𑀽𑀭𑁂 ¶ 𑀫𑀺𑀢𑁆𑀢𑁄 𑀧𑀸𑀧𑀲𑀳𑀸𑀬𑀓𑁄 𑀘, 𑀓𑀺𑀘𑁆𑀘𑁂 𑀚𑀸𑀢𑁂 𑀅𑀦𑀢𑁆𑀣𑀘𑀭𑀸𑀦𑀺 𑀪𑀯’’’𑀦𑁆𑀢𑀺.

‘‘𑀅𑀝𑁆𑀞𑀳𑀺 𑀔𑀮𑀼, 𑀲𑀫𑁆𑀫 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔, 𑀞𑀸𑀦𑁂𑀳𑀺 𑀇𑀢𑁆𑀣𑀻 𑀲𑀸𑀫𑀺𑀓𑀁 𑀅𑀯𑀚𑀸𑀦𑀸𑀢𑀺. 𑀤𑀮𑀺𑀤𑁆𑀤𑀢𑀸, 𑀆𑀢𑀼𑀭𑀢𑀸, 𑀚𑀺𑀡𑁆𑀡𑀢𑀸, 𑀲𑀼𑀭𑀸𑀲𑁄𑀡𑁆𑀟𑀢𑀸, 𑀫𑀼𑀤𑁆𑀥𑀢𑀸, 𑀧𑀫𑀢𑁆𑀢𑀢𑀸, 𑀲𑀩𑁆𑀩𑀓𑀺𑀘𑁆𑀘𑁂𑀲𑀼 𑀅𑀦𑀼𑀯𑀢𑁆𑀢𑀦𑀢𑀸, 𑀲𑀩𑁆𑀩𑀥𑀦𑀅𑀦𑀼𑀧𑁆𑀧𑀤𑀸𑀦𑁂𑀦 ¶ 𑁋 𑀇𑀫𑁂𑀳𑀺 𑀔𑀮𑀼, 𑀲𑀫𑁆𑀫 𑀧𑀼𑀡𑁆𑀡𑀫𑀼𑀔, 𑀅𑀝𑁆𑀞𑀳𑀺 𑀞𑀸𑀦𑁂𑀳𑀺 𑀇𑀢𑁆𑀣𑀻 𑀲𑀸𑀫𑀺𑀓𑀁 𑀅𑀯𑀚𑀸𑀦𑀸𑀢𑀺. 𑀪𑀯𑀢𑀺 𑀘 𑀧𑀦𑀼𑀢𑁆𑀢𑀭𑁂𑀢𑁆𑀣 𑀯𑀸𑀓𑁆𑀬𑀁 𑁋

𑁨𑁯𑁮.

‘𑀤𑀮𑀺𑀤𑁆𑀤𑀁 𑀆𑀢𑀼𑀭𑀜𑁆𑀘𑀸𑀧𑀺, 𑀚𑀺𑀡𑁆𑀡𑀓𑀁 𑀲𑀼𑀭𑀲𑁄𑀡𑁆𑀟𑀓𑀁;

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

𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀧𑁆𑀧𑀤𑀸𑀦𑁂𑀦 [𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀧𑀡𑀺𑀥𑀸𑀦𑁂𑀦 (𑀲𑁆𑀬𑀸)], 𑀅𑀯𑀚𑀸𑀦𑀸𑀢𑀺 [𑀅𑀯𑀚𑀸𑀦𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀸𑀫𑀺𑀓’’’𑀦𑁆𑀢𑀺.

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

𑁨𑁯𑁯.

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

𑀆𑀤𑀸𑀲𑀤𑀼𑀲𑁆𑀲𑀫𑀡𑁆𑀟𑀦𑀫𑀦𑀼𑀬𑀼𑀢𑁆𑀢𑀸, 𑀬𑀸 ¶ 𑀘𑀺𑀢𑁆𑀣𑀻 𑀫𑀚𑁆𑀚𑀧𑀸𑀬𑀺𑀦𑀻.

𑁩𑁦𑁦.

‘𑀬𑀸 ¶ 𑀘 𑀦𑀺𑀮𑁆𑀮𑁄𑀓𑀦𑀲𑀻𑀮𑀸, 𑀬𑀸 𑀘 𑀲𑀤𑁆𑀯𑀸𑀭𑀞𑀸𑀬𑀺𑀦𑀻;

𑀦𑀯𑀳𑁂𑀢𑁂𑀳𑀺 𑀞𑀸𑀦𑁂𑀳𑀺, 𑀧𑀤𑁄𑀲𑀫𑀸𑀳𑀭𑀦𑁆𑀢𑀺 𑀇𑀢𑁆𑀣𑀺𑀬𑁄’’’𑀢𑀺.

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

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

𑁩𑁦𑁧.

‘𑀧𑀯𑀸𑀲𑀁 ¶ 𑀢𑀲𑁆𑀲 𑀯𑀡𑁆𑀡𑁂𑀢𑀺, 𑀕𑀢𑀁 𑀢𑀲𑁆𑀲 𑀦 𑀲𑁄𑀘𑀢𑀺 [𑀧𑀯𑀸𑀲’𑀫𑀲𑁆𑀲 𑀯𑀡𑁆𑀡𑁂𑀢𑀺 𑀕𑀢𑀺𑀁 𑀦𑀸𑀦𑀼𑀲𑁄𑀘𑀢𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀧𑀢𑀺𑀫𑀸𑀕𑀢𑀁 [𑀤𑀺𑀲𑁆𑀯𑀸𑀧𑀢𑀺𑀁 𑀆𑀕𑀢𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀦𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑀢𑀺;

𑀪𑀢𑁆𑀢𑀸𑀭𑀯𑀡𑁆𑀡𑀁 𑀦 𑀓𑀤𑀸𑀘𑀺 𑀪𑀸𑀲𑀢𑀺, 𑀏𑀢𑁂 𑀧𑀤𑀼𑀝𑁆𑀞𑀸𑀬 𑀪𑀯𑀦𑁆𑀢𑀺 𑀮𑀓𑁆𑀔𑀡𑀸.

𑁩𑁦𑁨.

‘𑀅𑀦𑀢𑁆𑀣𑀁 𑀢𑀲𑁆𑀲 𑀘𑀭𑀢𑀺 𑀅𑀲𑀜𑁆𑀜𑀢𑀸, 𑀅𑀢𑁆𑀣𑀜𑁆𑀘 𑀳𑀸𑀧𑁂𑀢𑀺 𑀅𑀓𑀺𑀘𑁆𑀘𑀓𑀸𑀭𑀺𑀦𑀻;

𑀧𑀭𑀺𑀤𑀳𑀺𑀢𑁆𑀯𑀸 ¶ 𑀲𑀬𑀢𑀺 𑀧𑀭𑀫𑁆𑀫𑀼𑀔𑀻, 𑀏𑀢𑁂 𑀧𑀤𑀼𑀝𑁆𑀞𑀸𑀬 𑀪𑀯𑀦𑁆𑀢𑀺 𑀮𑀓𑁆𑀔𑀡𑀸.

𑁩𑁦𑁩.

‘𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑀚𑀸𑀢𑀸 𑀘 [𑀧𑀭𑀸𑀯𑀢𑁆𑀢𑀓𑀚𑀸𑀢𑀸 𑀘 (𑀲𑀻.)] 𑀪𑀯𑀢𑀺 𑀓𑀼𑀗𑁆𑀓𑀼𑀫𑀻, 𑀤𑀻𑀖𑀜𑁆𑀘 𑀅𑀲𑁆𑀲𑀲𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑀯𑁂𑀤𑀺𑀦𑀻;

𑀉𑀘𑁆𑀘𑀸𑀭𑀧𑀲𑁆𑀲𑀸𑀯𑀫𑀪𑀺𑀡𑁆𑀳𑀁 𑀕𑀘𑁆𑀙𑀢𑀺, 𑀏𑀢𑁂 𑀧𑀤𑀼𑀝𑁆𑀞𑀸𑀬 𑀪𑀯𑀦𑁆𑀢𑀺 𑀮𑀓𑁆𑀔𑀡𑀸.

𑁩𑁦𑁪.

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

𑀦𑀺𑀳𑀢𑀪𑁄𑀕𑀸 𑀘 𑀓𑀭𑁄𑀢𑀺 𑀲𑀦𑁆𑀣𑀯𑀁, 𑀏𑀢𑁂 𑀧𑀤𑀼𑀝𑁆𑀞𑀸𑀬 𑀪𑀯𑀦𑁆𑀢𑀺 𑀮𑀓𑁆𑀔𑀡𑀸.

𑁩𑁦𑁫.

‘𑀓𑀺𑀘𑁆𑀙𑁂𑀦 𑀮𑀤𑁆𑀥𑀁 𑀓𑀲𑀺𑀭𑀸𑀪𑀢𑀁 [𑀓𑀲𑀺𑀭𑁂𑀦𑀸𑀪𑀢𑀁 (𑀲𑀻.)] 𑀥𑀦𑀁, 𑀯𑀺𑀢𑁆𑀢𑀁 𑀯𑀺𑀦𑀸𑀲𑁂𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑁂𑀦 𑀲𑀫𑁆𑀪𑀢𑀁;

𑀧𑀝𑀺𑀯𑀺𑀲𑁆𑀲𑀓𑁂𑀳𑀺 𑀘 𑀓𑀭𑁄𑀢𑀺 𑀲𑀦𑁆𑀣𑀯𑀁, 𑀏𑀢𑁂 𑀧𑀤𑀼𑀝𑁆𑀞𑀸𑀬 𑀪𑀯𑀦𑁆𑀢𑀺 𑀮𑀓𑁆𑀔𑀡𑀸.

𑁩𑁦𑁬.

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

𑀅𑀢𑀺𑀘𑀸𑀭𑀺𑀦𑀻 𑀳𑁄𑀢𑀺 𑀅𑀧𑁂𑀢𑀕𑀸𑀭𑀯𑀸 [𑀢𑀣𑁂𑀯’𑀕𑀸𑀭𑀯𑀸 (𑀲𑀻. 𑀧𑀻.)], 𑀏𑀢𑁂 𑀧𑀤𑀼𑀝𑁆𑀞𑀸𑀬 𑀪𑀯𑀦𑁆𑀢𑀺 𑀮𑀓𑁆𑀔𑀡𑀸.

𑁩𑁦𑁭.

‘𑀅𑀪𑀺𑀓𑁆𑀔𑀡𑀁 ¶ 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀤𑁆𑀯𑀸𑀭𑀫𑀽𑀮𑁂, 𑀣𑀦𑀸𑀦𑀺 𑀓𑀘𑁆𑀙𑀸𑀦𑀺 𑀘 𑀤𑀲𑁆𑀲𑀬𑀦𑁆𑀢𑀻;

𑀤𑀺𑀲𑁄𑀤𑀺𑀲𑀁 ¶ 𑀧𑁂𑀓𑁆𑀔𑀢𑀺 𑀪𑀦𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑀸, 𑀏𑀢𑁂 𑀧𑀤𑀼𑀝𑁆𑀞𑀸𑀬 𑀪𑀯𑀦𑁆𑀢𑀺 𑀮𑀓𑁆𑀔𑀡𑀸.

𑁩𑁦𑁮.

‘𑀲𑀩𑁆𑀩𑀸 𑀦𑀤𑀻 𑀯𑀗𑁆𑀓𑀕𑀢𑀻 [𑀯𑀗𑁆𑀓𑀦𑀤𑀻 (𑀓.)], 𑀲𑀩𑁆𑀩𑁂 𑀓𑀝𑁆𑀞𑀫𑀬𑀸 𑀯𑀦𑀸;

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

𑁩𑁦𑁯.

‘𑀲𑀘𑁂 𑀮𑀪𑁂𑀣 𑀔𑀡𑀁 𑀯𑀸 𑀭𑀳𑁄 𑀯𑀸, 𑀦𑀺𑀯𑀸𑀢𑀓𑀁 𑀯𑀸𑀧𑀺 𑀮𑀪𑁂𑀣 𑀢𑀸𑀤𑀺𑀲𑀁;

𑀲𑀩𑁆𑀩𑀸𑀯 𑀇𑀢𑁆𑀣𑀻 𑀓𑀬𑀺𑀭𑀼𑀁 𑀦𑀼 [𑀓𑀭𑁂𑀬𑁆𑀬𑀼 𑀦𑁄 (𑀲𑀻.), 𑀓𑀭𑁂𑀬𑁆𑀬𑀼𑀁 𑀦𑁄 (𑀧𑀻.)] 𑀧𑀸𑀧𑀁, 𑀅𑀜𑁆𑀜𑀁 𑀅𑀮𑀢𑁆𑀣 [𑀅𑀮𑀤𑁆𑀥𑀸 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)] 𑀧𑀻𑀞𑀲𑀧𑁆𑀧𑀺𑀦𑀸𑀧𑀺 𑀲𑀤𑁆𑀥𑀺𑀁.

𑁩𑁧𑁦.

‘‘𑀦𑀭𑀸𑀦𑀫𑀸𑀭𑀸𑀫𑀓𑀭𑀸𑀲𑀼 ¶ 𑀦𑀸𑀭𑀺𑀲𑀼, 𑀅𑀦𑁂𑀓𑀘𑀺𑀢𑁆𑀢𑀸𑀲𑀼 𑀅𑀦𑀺𑀕𑁆𑀕𑀳𑀸𑀲𑀼 𑀘;

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

𑁩𑁧𑁧.

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

𑀢𑀁 𑀢𑀸𑀤𑀺𑀲𑀁 𑀫𑀘𑁆𑀘𑀁 𑀘𑀚𑀺𑀢𑁆𑀯𑀸 𑀪𑀭𑀺𑀬𑀸, 𑀅𑀜𑁆𑀜𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀧𑀼𑀭𑀺𑀲𑀁 𑀧𑀻𑀞𑀲𑀧𑁆𑀧𑀺𑀁.

𑁩𑁧𑁨.

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

𑀅𑀯𑀸𑀘𑀭𑀻 [𑀅𑀘𑁆𑀘𑀸𑀘𑀭𑀺 (𑀲𑁆𑀬𑀸.), 𑀅𑀦𑀸𑀘𑀭𑀺 (𑀓.)] 𑀧𑀝𑁆𑀞𑀯𑀲𑀸𑀦𑀼𑀕𑀲𑁆𑀲 [𑀩𑀤𑁆𑀥𑀯𑀲𑀸𑀦𑀼𑀕𑀲𑁆𑀲 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀧𑀢𑁆𑀢𑀯𑀲𑀸𑀦𑀼𑀕𑀢𑀲𑁆𑀲 (𑀓.)], 𑀓𑀁 𑀯𑀸𑀧𑀺 𑀇𑀢𑁆𑀣𑀻 𑀦𑀸𑀢𑀺𑀘𑀭𑁂 𑀢𑀤𑀜𑁆𑀜𑀁.

𑁩𑁧𑁩.

‘𑀧𑀺𑀗𑁆𑀕𑀺𑀬𑀸𑀦𑀻 ¶ ¶ 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀺𑀲𑁆𑀲𑀭𑀲𑁆𑀲, 𑀭𑀜𑁆𑀜𑁄 𑀧𑀺𑀬𑀸 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀲𑁆𑀲 𑀪𑀭𑀺𑀬𑀸;

𑀅𑀯𑀸𑀘𑀭𑀻 𑀧𑀝𑁆𑀞𑀯𑀲𑀸𑀦𑀼𑀕𑀲𑁆𑀲, 𑀢𑀁 𑀯𑀸𑀧𑀺 𑀲𑀸 𑀦𑀸𑀚𑁆𑀛𑀕𑀸 𑀓𑀸𑀫𑀓𑀸𑀫𑀺𑀦𑀻.

𑁩𑁧𑁪.

‘𑀮𑀼𑀤𑁆𑀥𑀸𑀦𑀁 [𑀔𑀼𑀤𑁆𑀤𑀸𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀮𑀳𑀼𑀘𑀺𑀢𑁆𑀢𑀸𑀦𑀁, 𑀅𑀓𑀢𑀜𑁆𑀜𑀽𑀦 𑀤𑀼𑀩𑁆𑀪𑀺𑀦𑀁;

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

𑁩𑁧𑁫.

‘𑀦 𑀢𑀸 𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀓𑀢𑀁 𑀦 𑀓𑀺𑀘𑁆𑀘𑀁, 𑀦 𑀫𑀸𑀢𑀭𑀁 𑀧𑀺𑀢𑀭𑀁 𑀪𑀸𑀢𑀭𑀁 𑀯𑀸;

𑀅𑀦𑀭𑀺𑀬𑀸 𑀲𑀫𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀥𑀫𑁆𑀫𑀸, 𑀲𑀲𑁆𑀲𑁂𑀯 𑀘𑀺𑀢𑁆𑀢𑀲𑁆𑀲 𑀯𑀲𑀁 𑀯𑀚𑀦𑁆𑀢𑀺.

𑁩𑁧𑁬.

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

𑀆𑀯𑀸𑀲𑀼 𑀓𑀺𑀘𑁆𑀘𑁂𑀲𑀼 𑀘 𑀦𑀁 𑀚𑀳𑀦𑁆𑀢𑀺, 𑀢𑀲𑁆𑀫𑀸𑀳𑀫𑀺𑀢𑁆𑀣𑀻𑀦𑀁 𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑀸𑀫𑀺.

𑁩𑁧𑁭.

‘𑀣𑀻𑀦𑀜𑁆𑀳𑀺 𑀘𑀺𑀢𑁆𑀢𑀁 𑀬𑀣𑀸 𑀯𑀸𑀦𑀭𑀲𑁆𑀲, 𑀓𑀦𑁆𑀦𑀧𑁆𑀧𑀓𑀦𑁆𑀦𑀁 𑀬𑀣𑀸 𑀭𑀼𑀓𑁆𑀔𑀙𑀸𑀬𑀸;

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

𑁩𑁧𑁮.

‘𑀬𑀤𑀸 𑀢𑀸 𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀲𑀫𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑀸, 𑀆𑀤𑁂𑀬𑁆𑀬𑀭𑀽𑀧𑀁 𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 𑀯𑀺𑀢𑁆𑀢𑀁;

𑀲𑀡𑁆𑀳𑀸𑀳𑀺 ¶ 𑀯𑀸𑀘𑀸𑀳𑀺 𑀦𑀬𑀦𑁆𑀢𑀺 𑀫𑁂𑀦𑀁, 𑀓𑀫𑁆𑀩𑁄𑀚𑀓𑀸 𑀚𑀮𑀚𑁂𑀦𑁂𑀯 𑀅𑀲𑁆𑀲𑀁.

𑁩𑁧𑁯.

‘𑀬𑀤𑀸 𑀦 𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀲𑀫𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑀸, 𑀆𑀤𑁂𑀬𑁆𑀬𑀭𑀽𑀧𑀁 𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 𑀯𑀺𑀢𑁆𑀢𑀁;

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

𑁩𑁨𑁦.

‘𑀲𑀺𑀮𑁂𑀲𑀽𑀧𑀫𑀸𑀁 ¶ 𑀲𑀺𑀔𑀺𑀭𑀺𑀯 𑀲𑀩𑁆𑀩𑀪𑀓𑁆𑀔𑀸, 𑀢𑀺𑀓𑁆𑀔𑀫𑀸𑀬𑀸 𑀦𑀤𑀻𑀭𑀺𑀯 𑀲𑀻𑀖𑀲𑁄𑀢𑀸;

𑀲𑁂𑀯𑀦𑁆𑀢𑀺 𑀳𑁂𑀢𑀸 𑀧𑀺𑀬𑀫𑀧𑁆𑀧𑀺𑀬𑀜𑁆𑀘, 𑀦𑀸𑀯𑀸 𑀬𑀣𑀸 𑀑𑀭𑀓𑀽𑀮𑀁 [𑀑𑀭𑀓𑀼𑀮𑀁 (𑀲𑀻.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] 𑀧𑀭𑀜𑁆𑀘.

𑁩𑁨𑁧.

‘𑀦 𑀢𑀸 𑀏𑀓𑀲𑁆𑀲 𑀦 𑀤𑁆𑀯𑀺𑀦𑁆𑀦𑀁, 𑀆𑀧𑀡𑁄𑀯 𑀧𑀲𑀸𑀭𑀺𑀢𑁄;

𑀬𑁄 𑀢𑀸 𑀫𑀬𑁆𑀳𑀦𑁆𑀢𑀺 𑀫𑀜𑁆𑀜𑁂𑀬𑁆𑀬, 𑀯𑀸𑀢𑀁 𑀚𑀸𑀮𑁂𑀦 𑀩𑀸𑀥𑀬𑁂 [𑀩𑀦𑁆𑀥𑀬𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑁩𑁨𑁨.

‘𑀬𑀣𑀸 𑀦𑀤𑀻 𑀘 𑀧𑀦𑁆𑀣𑁄 𑀘, 𑀧𑀸𑀦𑀸𑀕𑀸𑀭𑀁 𑀲𑀪𑀸 𑀧𑀧𑀸;

𑀏𑀯𑀁 𑀮𑁄𑀓𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀦𑀸𑀫, 𑀯𑁂𑀮𑀸 𑀢𑀸𑀲𑀁 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺 [𑀓𑁂𑀲𑀼𑀘𑀺 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼 𑀇𑀫𑀺𑀲𑁆𑀲𑀸 𑀕𑀸𑀣𑀸𑀬 𑀧𑀼𑀩𑁆𑀩𑀤𑁆𑀥𑀸𑀧𑀭𑀤𑁆𑀥𑀁 𑀯𑀺𑀧𑀭𑀺𑀬𑀸𑀬𑁂𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀺].

𑁩𑁨𑁩.

‘𑀖𑀢𑀸𑀲𑀦𑀲𑀫𑀸 𑀏𑀢𑀸, 𑀓𑀡𑁆𑀳𑀲𑀧𑁆𑀧𑀲𑀺𑀭𑀽𑀧𑀫𑀸;

𑀕𑀸𑀯𑁄 𑀩𑀳𑀺𑀢𑀺𑀡𑀲𑁆𑀲𑁂𑀯, 𑀑𑀫𑀲𑀦𑁆𑀢𑀺 𑀯𑀭𑀁 𑀯𑀭𑀁.

𑁩𑁨𑁪.

‘𑀖𑀢𑀸𑀲𑀦𑀁 𑀓𑀼𑀜𑁆𑀚𑀭𑀁 𑀓𑀡𑁆𑀳𑀲𑀧𑁆𑀧𑀁, 𑀫𑀼𑀤𑁆𑀥𑀸𑀪𑀺𑀲𑀺𑀢𑁆𑀢𑀁 𑀧𑀫𑀤𑀸 𑀘 𑀲𑀩𑁆𑀩𑀸;

𑀏𑀢𑁂 𑀦𑀭𑁄 [𑀏𑀢𑁂𑀦 𑀲𑁄 (𑀧𑀻.)] 𑀦𑀺𑀘𑁆𑀘𑀬𑀢𑁄 [𑀦𑀺𑀘𑁆𑀘𑀬𑀢𑁆𑀢𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀪𑀚𑁂𑀣, 𑀢𑁂𑀲𑀁 𑀳𑀯𑁂 𑀤𑀼𑀩𑁆𑀩𑀺𑀤𑀼 𑀲𑀩𑁆𑀩𑀪𑀸𑀯𑁄 [𑀲𑀘𑁆𑀘𑀪𑀸𑀯𑁄 (𑀲𑁆𑀬𑀸.)].

𑁩𑁨𑁫.

‘𑀦𑀘𑁆𑀘𑀦𑁆𑀢𑀯𑀡𑁆𑀡𑀸 ¶ ¶ 𑀦 𑀩𑀳𑀽𑀦𑀁 𑀓𑀦𑁆𑀢𑀸, 𑀦 𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀧𑀫𑀤𑀸 𑀲𑁂𑀯𑀺𑀢𑀩𑁆𑀩𑀸;

𑀦 𑀧𑀭𑀲𑁆𑀲 𑀪𑀭𑀺𑀬𑀸 𑀦 𑀥𑀦𑀲𑁆𑀲 𑀳𑁂𑀢𑀼, 𑀏𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀧𑀜𑁆𑀘 𑀦 𑀲𑁂𑀯𑀺𑀢𑀩𑁆𑀩𑀸’’’.

𑀅𑀣 𑀔𑀮𑀼, 𑀪𑁄, 𑀆𑀦𑀦𑁆𑀤𑁄 𑀕𑀺𑀚𑁆𑀛𑀭𑀸𑀚𑀸 𑀓𑀼𑀡𑀸𑀮𑀲𑁆𑀲 𑀲𑀓𑀼𑀡𑀲𑁆𑀲 𑀆𑀤𑀺𑀫𑀚𑁆𑀛𑀓𑀣𑀸𑀧𑀭𑀺𑀬𑁄𑀲𑀸𑀦𑀁 [𑀆𑀤𑀺𑀫𑀚𑁆𑀛𑀕𑀸𑀣𑀸𑀧𑀭𑀺𑀬𑁄𑀲𑀸𑀦𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀢𑀸𑀬𑀁 𑀯𑁂𑀮𑀸𑀬𑀁 𑀇𑀫𑀸 𑀕𑀸𑀣𑀸𑀬𑁄 𑀅𑀪𑀸𑀲𑀺 𑁋

𑁩𑁨𑁬.

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

𑀮𑀤𑁆𑀥𑀸 𑀔𑀡𑀁 𑀅𑀢𑀺𑀫𑀜𑁆𑀜𑁂𑀬𑁆𑀬 𑀢𑀫𑁆𑀧𑀺, 𑀢𑀸𑀲𑀁 𑀯𑀲𑀁 𑀅𑀲𑀢𑀻𑀦𑀁 𑀦 𑀕𑀘𑁆𑀙𑁂.

𑁩𑁨𑁭.

‘‘𑀉𑀝𑁆𑀞𑀸𑀳𑀓𑀁 ¶ 𑀘𑁂𑀧𑀺 𑀅𑀮𑀻𑀦𑀯𑀼𑀢𑁆𑀢𑀺𑀁, 𑀓𑁄𑀫𑀸𑀭𑀪𑀢𑁆𑀢𑀸𑀭𑀁 𑀧𑀺𑀬𑀁 𑀫𑀦𑀸𑀧𑀁;

𑀆𑀯𑀸𑀲𑀼 𑀓𑀺𑀘𑁆𑀘𑁂𑀲𑀼 𑀘 𑀦𑀁 𑀚𑀳𑀦𑁆𑀢𑀺, 𑀢𑀲𑁆𑀫𑀸𑀳𑀫𑀺𑀢𑁆𑀣𑀻𑀦𑀁 [𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀇𑀢𑁆𑀣𑀻𑀦𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑀸𑀫𑀺.

𑁩𑁨𑁮.

‘‘𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀇𑀘𑁆𑀙𑀢𑀺 𑀫𑀦𑁆𑀢𑀺 𑀧𑁄𑀲𑁄, 𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀭𑁄𑀤𑀢𑀺 𑀫𑁂 𑀲𑀓𑀸𑀲𑁂;

𑀲𑁂𑀯𑀦𑁆𑀢𑀺 𑀳𑁂𑀢𑀸 𑀧𑀺𑀬𑀫𑀧𑁆𑀧𑀺𑀬𑀜𑁆𑀘, 𑀦𑀸𑀯𑀸 𑀬𑀣𑀸 𑀑𑀭𑀓𑀽𑀮𑀁 𑀧𑀭𑀜𑁆𑀘.

𑁩𑁨𑁯.

‘‘𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀲𑀸𑀔𑀧𑀼𑀭𑀸𑀡𑀲𑀦𑁆𑀣𑀢𑀁, 𑀦 ¶ 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀫𑀺𑀢𑁆𑀢𑀧𑀼𑀭𑀸𑀡𑀘𑁄𑀭𑀁;

𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀭𑀸𑀚𑀸𑀦𑀁 𑀲𑀔𑀸 [𑀭𑀸𑀚𑀸 𑀲𑀔𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀫𑀫𑀦𑁆𑀢𑀺, 𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀇𑀢𑁆𑀣𑀺 𑀤𑀲𑀦𑁆𑀦 𑀫𑀸𑀢𑀭𑀁.

𑁩𑁩𑁦.

‘‘𑀦 𑀯𑀺𑀲𑁆𑀲𑀲𑁂 𑀭𑀸𑀫𑀓𑀭𑀸𑀲𑀼 𑀦𑀸𑀭𑀺𑀲𑀼, 𑀅𑀘𑁆𑀘𑀦𑁆𑀢𑀲𑀻𑀮𑀸𑀲𑀼 𑀅𑀲𑀜𑁆𑀜𑀢𑀸𑀲𑀼;

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

𑁩𑁩𑁧.

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

𑀫𑀸 𑀤𑀻𑀦𑀓𑀸𑀫𑀸𑀲𑀼 𑀅𑀲𑀜𑁆𑀜𑀢𑀸𑀲𑀼, 𑀪𑀸𑀯𑀁 𑀓𑀭𑁂 𑀕𑀗𑁆𑀕𑀢𑀺𑀢𑁆𑀣𑀽𑀧𑀫𑀸𑀲𑀼.

𑁩𑁩𑁨.

‘‘𑀫𑀼𑀲𑀸 𑀢𑀸𑀲𑀁 𑀬𑀣𑀸 𑀲𑀘𑁆𑀘𑀁, 𑀲𑀘𑁆𑀘𑀁 𑀢𑀸𑀲𑀁 𑀬𑀣𑀸 𑀫𑀼𑀲𑀸;

𑀕𑀸𑀯𑁄 𑀩𑀳𑀺𑀢𑀺𑀡𑀲𑁆𑀲𑁂𑀯, 𑀑𑀫𑀲𑀦𑁆𑀢𑀺 𑀯𑀭𑀁 𑀯𑀭𑀁.

𑁩𑁩𑁩.

‘‘𑀕𑀢𑁂𑀦𑁂𑀢𑀸 𑀧𑀮𑁄𑀪𑁂𑀦𑁆𑀢𑀺, 𑀧𑁂𑀓𑁆𑀔𑀺𑀢𑁂𑀦 𑀫𑁆𑀳𑀺𑀢𑁂𑀦 𑀘;

𑀅𑀣𑁄𑀧𑀺 𑀤𑀼𑀦𑁆𑀦𑀺𑀯𑀢𑁆𑀣𑁂𑀦, 𑀫𑀜𑁆𑀚𑀼𑀦𑀸 𑀪𑀡𑀺𑀢𑁂𑀦 𑀘.

𑁩𑁩𑁪.

‘‘𑀘𑁄𑀭𑀺𑀬𑁄 𑀓𑀣𑀺𑀦𑀸 [𑀓𑀞𑀺𑀦𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀳𑁂𑀢𑀸, 𑀯𑀸𑀴𑀸 𑀘 𑀮𑀧𑀲𑀓𑁆𑀔𑀭𑀸;

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

𑁩𑁩𑁫.

‘‘𑀅𑀲𑀸 ¶ 𑀮𑁄𑀓𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀦𑀸𑀫, 𑀯𑁂𑀮𑀸 𑀢𑀸𑀲𑀁 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀲𑀸𑀭𑀢𑁆𑀢𑀸 𑀘 𑀧𑀕𑀩𑁆𑀪𑀸 𑀘, 𑀲𑀺𑀔𑀻 𑀲𑀩𑁆𑀩𑀖𑀲𑁄 𑀬𑀣𑀸.

𑁩𑁩𑁬.

‘‘𑀦𑀢𑁆𑀣𑀺𑀢𑁆𑀣𑀻𑀦𑀁 ¶ 𑀧𑀺𑀬𑁄 𑀦𑀸𑀫, 𑀅𑀧𑁆𑀧𑀺𑀬𑁄𑀧𑀺 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀲𑁂𑀯𑀦𑁆𑀢𑀺 𑀳𑁂𑀢𑀸 𑀧𑀺𑀬𑀫𑀧𑁆𑀧𑀺𑀬𑀜𑁆𑀘, 𑀦𑀸𑀯𑀸 𑀬𑀣𑀸 𑀑𑀭𑀓𑀽𑀮𑀁 𑀧𑀭𑀜𑁆𑀘.

𑁩𑁩𑁭.

‘‘𑀦𑀢𑁆𑀣𑀺𑀢𑁆𑀣𑀻𑀦𑀁 𑀧𑀺𑀬𑁄 𑀦𑀸𑀫, 𑀅𑀧𑁆𑀧𑀺𑀬𑁄𑀧𑀺 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀥𑀦𑀢𑁆𑀢𑀸 [𑀥𑀦𑀢𑁆𑀣𑀸 (𑀲𑁆𑀬𑀸.)] 𑀧𑀝𑀺𑀯𑀮𑁆𑀮𑀦𑁆𑀢𑀺, 𑀮𑀢𑀸𑀯 𑀤𑀼𑀫𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀸.

𑁩𑁩𑁮.

‘‘𑀳𑀢𑁆𑀣𑀺𑀩𑀦𑁆𑀥𑀁 ¶ 𑀅𑀲𑁆𑀲𑀩𑀦𑁆𑀥𑀁, 𑀕𑁄𑀧𑀼𑀭𑀺𑀲𑀜𑁆𑀘 𑀫𑀡𑁆𑀟𑀮𑀁 [𑀘𑀡𑁆𑀟𑀮𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)];

𑀙𑀯𑀟𑀸𑀳𑀓𑀁 𑀧𑀼𑀧𑁆𑀨𑀙𑀟𑁆𑀟𑀓𑀁, 𑀲𑀥𑀦𑀫𑀦𑀼𑀧𑀢𑀦𑁆𑀢𑀺 𑀦𑀸𑀭𑀺𑀬𑁄.

𑁩𑁩𑁯.

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

𑀅𑀦𑀼𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 [𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 (𑀧𑀻.)] 𑀅𑀦𑀼𑀧𑀢𑀦𑁆𑀢𑀺, 𑀥𑀦𑀳𑁂𑀢𑀼 𑀳𑀺 𑀦𑀸𑀭𑀺𑀬𑁄’’𑀢𑀺 [𑀥𑀦𑀳𑁂𑀢𑀼 𑀘 𑀦𑀸𑀭𑀺𑀬𑁄 (𑀲𑁆𑀬𑀸.), 𑀥𑀦𑀳𑁂𑀢𑀼 𑀦𑀸𑀭𑀺𑀬𑁄 (𑀧𑀻.)].

𑀅𑀣 𑀔𑀮𑀼, 𑀪𑁄, 𑀦𑀸𑀭𑀤𑁄 𑀤𑁂𑀯𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀆𑀦𑀦𑁆𑀤𑀲𑁆𑀲 𑀕𑀺𑀚𑁆𑀛𑀭𑀸𑀚𑀲𑁆𑀲 𑀆𑀤𑀺𑀫𑀚𑁆𑀛𑀓𑀣𑀸𑀧𑀭𑀺𑀬𑁄𑀲𑀸𑀦𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀢𑀸𑀬𑀁 𑀯𑁂𑀮𑀸𑀬𑀁 𑀇𑀫𑀸 𑀕𑀸𑀣𑀸𑀬𑁄 𑀅𑀪𑀸𑀲𑀺 𑁋

𑁩𑁪𑁦.

‘‘𑀘𑀢𑁆𑀢𑀸𑀭𑁄𑀫𑁂 𑀦 𑀧𑀽𑀭𑁂𑀦𑁆𑀢𑀺, 𑀢𑁂 𑀫𑁂 𑀲𑀼𑀡𑀸𑀣 𑀪𑀸𑀲𑀢𑁄;

𑀲𑀫𑀼𑀤𑁆𑀤𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀭𑀸𑀚𑀸, 𑀇𑀢𑁆𑀣𑀻 𑀘𑀸𑀧𑀺 𑀤𑀺𑀚𑀫𑁆𑀧𑀢𑀺.

𑁩𑁪𑁧.

‘‘𑀲𑀭𑀺𑀢𑀸 𑀲𑀸𑀕𑀭𑀁 𑀬𑀦𑁆𑀢𑀺, 𑀬𑀸 𑀓𑀸𑀘𑀺 𑀧𑀣𑀯𑀺𑀲𑁆𑀲𑀺𑀢𑀸;

𑀢𑀸 𑀲𑀫𑀼𑀤𑁆𑀤𑀁 𑀦 𑀧𑀽𑀭𑁂𑀦𑁆𑀢𑀺, 𑀊𑀦𑀢𑁆𑀢𑀸 𑀳𑀺 𑀦 𑀧𑀽𑀭𑀢𑀺.

𑁩𑁪𑁨.

‘‘𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀘 𑀅𑀥𑀻𑀬𑀸𑀦, 𑀯𑁂𑀤𑀫𑀓𑁆𑀔𑀸𑀦𑀧𑀜𑁆𑀘𑀫𑀁;

𑀪𑀺𑀬𑁆𑀬𑁄𑀧𑀺 𑀲𑀼𑀢𑀫𑀺𑀘𑁆𑀙𑁂𑀬𑁆𑀬, 𑀊𑀦𑀢𑁆𑀢𑀸 𑀳𑀺 𑀦 𑀧𑀽𑀭𑀢𑀺.

𑁩𑁪𑁩.

‘‘𑀭𑀸𑀚𑀸 𑀘 𑀧𑀣𑀯𑀺𑀁 𑀲𑀩𑁆𑀩𑀁, 𑀲𑀲𑀫𑀼𑀤𑁆𑀤𑀁 𑀲𑀧𑀩𑁆𑀩𑀢𑀁;

𑀅𑀚𑁆𑀛𑀸𑀯𑀲𑀁 𑀯𑀺𑀚𑀺𑀦𑀺𑀢𑁆𑀯𑀸, 𑀅𑀦𑀦𑁆𑀢𑀭𑀢𑀦𑁄𑀘𑀺𑀢𑀁;

𑀧𑀸𑀭𑀁 ¶ 𑀲𑀫𑀼𑀤𑁆𑀤𑀁 𑀧𑀢𑁆𑀣𑁂𑀢𑀺, 𑀊𑀦𑀢𑁆𑀢𑀸 𑀳𑀺 𑀦 𑀧𑀽𑀭𑀢𑀺.

𑁩𑁪𑁪.

‘‘𑀏𑀓𑀫𑁂𑀓𑀸𑀬 𑀇𑀢𑁆𑀣𑀺𑀬𑀸, 𑀅𑀝𑁆𑀞𑀝𑁆𑀞 𑀧𑀢𑀺𑀦𑁄 𑀲𑀺𑀬𑀸;

𑀲𑀽𑀭𑀸 𑀘 𑀩𑀮𑀯𑀦𑁆𑀢𑁄 𑀘, 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀭𑀲𑀸𑀳𑀭𑀸;

𑀓𑀭𑁂𑀬𑁆𑀬 𑀦𑀯𑀫𑁂 𑀙𑀦𑁆𑀤𑀁, 𑀊𑀦𑀢𑁆𑀢𑀸 𑀳𑀺 𑀦 𑀧𑀽𑀭𑀢𑀺.

𑁩𑁪𑁫.

‘‘𑀲𑀩𑁆𑀩𑀺𑀢𑁆𑀣𑀺𑀬𑁄 ¶ 𑀲𑀺𑀔𑀺𑀭𑀺𑀯 𑀲𑀩𑁆𑀩𑀪𑀓𑁆𑀔𑀸, 𑀲𑀩𑁆𑀩𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀦𑀤𑀻𑀭𑀺𑀯 𑀲𑀩𑁆𑀩𑀯𑀸𑀳𑀻;

𑀲𑀩𑁆𑀩𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀓𑀡𑁆𑀝𑀓𑀸𑀦𑀁𑀯 𑀲𑀸𑀔𑀸, 𑀲𑀩𑁆𑀩𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀥𑀦𑀳𑁂𑀢𑀼 𑀯𑀚𑀦𑁆𑀢𑀺.

𑁩𑁪𑁬.

‘‘𑀯𑀸𑀢𑀜𑁆𑀘 𑀚𑀸𑀮𑁂𑀦 𑀦𑀭𑁄 𑀧𑀭𑀸𑀫𑀲𑁂, 𑀑𑀲𑀺𑀜𑁆𑀘𑀬𑁂 [𑀑𑀲𑀜𑁆𑀘𑀺𑀬𑀸 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀸𑀕𑀭𑀫𑁂𑀓𑀧𑀸𑀡𑀺𑀦𑀸;

𑀲𑀓𑁂𑀦 𑀳𑀢𑁆𑀣𑁂𑀦 𑀓𑀭𑁂𑀬𑁆𑀬 𑀖𑁄𑀲𑀁 [𑀲𑀓𑁂𑀦 𑀓𑀸𑀮𑁂𑀦 𑀳𑀦𑁂𑀬𑁆𑀬 𑀖𑁄𑀲𑀦𑀁 (𑀧𑀻.)], 𑀬𑁄 𑀲𑀩𑁆𑀩𑀪𑀸𑀯𑀁 𑀧𑀫𑀤𑀸𑀲𑀼 𑀑𑀲𑀚𑁂.

𑁩𑁪𑁭.

‘‘𑀘𑁄𑀭𑀻𑀦𑀁 𑀩𑀳𑀼𑀩𑀼𑀤𑁆𑀥𑀻𑀦𑀁, 𑀬𑀸𑀲𑀼 𑀲𑀘𑁆𑀘𑀁 𑀲𑀼𑀤𑀼𑀮𑁆𑀮𑀪𑀁;

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

𑁩𑁪𑁮.

‘‘𑀅𑀦𑀮𑀸 𑀫𑀼𑀤𑀼𑀲𑀫𑁆𑀪𑀸𑀲𑀸, 𑀤𑀼𑀧𑁆𑀧𑀽𑀭𑀸 𑀢𑀸 𑀦𑀤𑀻𑀲𑀫𑀸;

𑀲𑀻𑀤𑀦𑁆𑀢𑀺 𑀦𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸𑀦, 𑀆𑀭𑀓𑀸 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑁂.

𑁩𑁪𑁯.

‘‘𑀆𑀯𑀝𑁆𑀝𑀦𑀻 𑀫𑀳𑀸𑀫𑀸𑀬𑀸, 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀯𑀺𑀓𑁄𑀧𑀦𑀸;

𑀲𑀻𑀤𑀦𑁆𑀢𑀺 𑀦𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸𑀦, 𑀆𑀭𑀓𑀸 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑁂.

𑁩𑁫𑁦.

‘‘𑀬𑀁 ¶ 𑀏𑀢𑀸 [𑀬𑀜𑁆𑀘𑁂𑀢𑀸 (𑀲𑁆𑀬𑀸.)] 𑀉𑀧𑀲𑁂𑀯𑀦𑁆𑀢𑀺, 𑀙𑀦𑁆𑀤𑀲𑀸 𑀯𑀸 𑀥𑀦𑁂𑀦 𑀯𑀸;

𑀚𑀸𑀢𑀯𑁂𑀤𑁄𑀯 𑀲𑀡𑁆𑀞𑀸𑀦𑀁, 𑀔𑀺𑀧𑁆𑀧𑀁 𑀅𑀦𑀼𑀤𑀳𑀦𑁆𑀢𑀺 𑀦’’𑀦𑁆𑀢𑀺.

𑀅𑀣 ¶ 𑀔𑀮𑀼, 𑀪𑁄, 𑀓𑀼𑀡𑀸𑀮𑁄 𑀲𑀓𑀼𑀡𑁄 𑀦𑀸𑀭𑀤𑀲𑁆𑀲 𑀤𑁂𑀯𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀆𑀤𑀺𑀫𑀚𑁆𑀛𑀓𑀣𑀸𑀧𑀭𑀺𑀬𑁄𑀲𑀸𑀦𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸 𑀢𑀸𑀬𑀁 𑀯𑁂𑀮𑀸𑀬𑀁 𑀇𑀫𑀸 𑀕𑀸𑀣𑀸𑀬𑁄 𑀅𑀪𑀸𑀲𑀺 𑁋

𑁩𑁫𑁧.

‘‘𑀲𑀮𑁆𑀮𑀧𑁂 𑀦𑀺𑀲𑀺𑀢𑀔𑀕𑁆𑀕𑀧𑀸𑀡𑀺𑀦𑀸, 𑀧𑀡𑁆𑀟𑀺𑀢𑁄 𑀅𑀧𑀺 𑀧𑀺𑀲𑀸𑀘𑀤𑁄𑀲𑀺𑀦𑀸;

𑀉𑀕𑁆𑀕𑀢𑁂𑀚𑀫𑀼𑀭𑀕𑀫𑁆𑀧𑀺 𑀆𑀲𑀺𑀤𑁂, 𑀏𑀓𑁄 𑀏𑀓𑀸𑀬 𑀧𑀫𑀤𑀸𑀬 𑀦𑀸𑀮𑀧𑁂 [𑀏𑀓𑁄 𑀏𑀓𑀧𑀫𑀤𑀁 𑀳𑀺 𑀦𑀸𑀮𑀧𑁂 (𑀧𑀻.) 𑀏𑀓𑁄 𑀏𑀓𑀧𑀫𑀸𑀤𑀸𑀬 𑀦𑀸𑀮𑀧𑁂 (?)].

𑁩𑁫𑁨.

‘‘𑀮𑁄𑀓𑀘𑀺𑀢𑁆𑀢𑀫𑀣𑀦𑀸 𑀳𑀺 𑀦𑀸𑀭𑀺𑀬𑁄, 𑀦𑀘𑁆𑀘𑀕𑀻𑀢𑀪𑀡𑀺𑀢𑀫𑁆𑀳𑀺𑀢𑀸𑀯𑀼𑀥𑀸;

𑀩𑀸𑀥𑀬𑀦𑁆𑀢𑀺 𑀅𑀦𑀼𑀧𑀝𑁆𑀞𑀺𑀢𑀲𑁆𑀲𑀢𑀺𑀁 [𑀅𑀦𑀼𑀧𑀝𑁆𑀞𑀺𑀢𑀸𑀲𑀢𑀻 (𑀧𑀻.)], 𑀤𑀻𑀧𑁂 𑀭𑀓𑁆𑀔𑀲𑀺𑀕𑀡𑁄𑀯 [𑀤𑀻𑀧𑀭𑀓𑁆𑀔𑀲𑀺𑀕𑀡𑀸𑀯 (𑀲𑀻.)] 𑀯𑀸𑀡𑀺𑀚𑁂.

𑁩𑁫𑁩.

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

𑀢𑀸 𑀕𑀺𑀮𑀦𑁆𑀢𑀺 𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 𑀧𑀸𑀪𑀢𑀁, 𑀲𑀸𑀕𑀭𑁂𑀯 𑀫𑀓𑀭𑀁 𑀢𑀺𑀫𑀺𑀗𑁆𑀕𑀮𑁄 [𑀢𑀺𑀫𑀺𑀗𑁆𑀕𑀺𑀮𑁄 (𑀲𑀻. 𑀧𑀻.)].

𑁩𑁫𑁪.

‘‘𑀧𑀜𑁆𑀘𑀓𑀸𑀫𑀕𑀼𑀡𑀲𑀸𑀢𑀕𑁄𑀘𑀭𑀸, 𑀉𑀤𑁆𑀥𑀢𑀸 𑀅𑀦𑀺𑀬𑀢𑀸 𑀅𑀲𑀜𑁆𑀜𑀢𑀸;

𑀑𑀲𑀭𑀦𑁆𑀢𑀺 𑀧𑀫𑀤𑀸 𑀧𑀫𑀸𑀤𑀺𑀦𑀁, 𑀮𑁄𑀡𑀢𑁄𑀬𑀯𑀢𑀺𑀬𑀁𑀯 𑀆𑀧𑀓𑀸.

𑁩𑁫𑁫.

‘‘𑀬𑀁 𑀦𑀭𑀁 𑀉𑀧𑀮𑀧𑁂𑀦𑁆𑀢𑀺 [𑀉𑀧𑀭𑀫𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.), 𑀧𑀮𑀸𑀧𑁂𑀦𑁆𑀢𑀺 (𑀓.)] 𑀦𑀸𑀭𑀺𑀬𑁄, 𑀙𑀦𑁆𑀤𑀲𑀸 𑀯 ¶ 𑀭𑀢𑀺𑀬𑀸 𑀥𑀦𑁂𑀦 𑀯𑀸;

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

𑁩𑁫𑁬.

‘‘𑀅𑀟𑁆𑀠𑀁 𑀜𑀢𑁆𑀯𑀸 𑀧𑀼𑀭𑀺𑀲𑀁 𑀫𑀳𑀤𑁆𑀥𑀦𑀁, 𑀑𑀲𑀭𑀦𑁆𑀢𑀺 𑀲𑀥𑀦𑀸 𑀲𑀳𑀢𑁆𑀢𑀦𑀸;

𑀭𑀢𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑀫𑀢𑀺𑀯𑁂𑀞𑀬𑀦𑁆𑀢𑀺 𑀦𑀁, 𑀲𑀸𑀮 𑀫𑀸𑀮𑀼𑀯𑀮𑀢𑀸𑀯 𑀓𑀸𑀦𑀦𑁂.

𑁩𑁫𑁭.

‘‘𑀢𑀸 𑀉𑀧𑁂𑀦𑁆𑀢𑀺 𑀯𑀺𑀯𑀺𑀥𑁂𑀦 𑀙𑀦𑁆𑀤𑀲𑀸, 𑀘𑀺𑀢𑁆𑀭𑀩𑀺𑀫𑁆𑀩𑀫𑀼𑀔𑀺𑀬𑁄 𑀅𑀮𑀗𑁆𑀓𑀢𑀸;

𑀉𑀳𑀲𑀦𑁆𑀢𑀺 [𑀊𑀳𑀲𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.), 𑀑𑀳𑀲𑀦𑁆𑀢𑀺 (𑀲𑁆𑀬𑀸.)] 𑀧𑀳𑀲𑀦𑁆𑀢𑀺 𑀦𑀸𑀭𑀺𑀬𑁄, 𑀲𑀫𑁆𑀩𑀭𑁄𑀯 [𑀲𑀁𑀯𑀭𑁄𑀯 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)] 𑀲𑀢𑀫𑀸𑀬𑀓𑁄𑀯𑀺𑀤𑀸.

𑁩𑁫𑁮.

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

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

𑁩𑁫𑁯.

‘‘𑀢𑁂𑀚𑀯𑀸𑀧𑀺 ¶ 𑀳𑀺 𑀦𑀭𑁄 𑀯𑀺𑀘𑀓𑁆𑀔𑀡𑁄, 𑀲𑀓𑁆𑀓𑀢𑁄 𑀩𑀳𑀼𑀚𑀦𑀲𑁆𑀲 𑀧𑀽𑀚𑀺𑀢𑁄;

𑀦𑀸𑀭𑀺𑀦𑀁 𑀯𑀲𑀕𑀢𑁄 𑀦 𑀪𑀸𑀲𑀢𑀺, 𑀭𑀸𑀳𑀼𑀦𑀸 𑀉𑀧𑀳𑀢𑁄𑀯 𑀘𑀦𑁆𑀤𑀺𑀫𑀸.

𑁩𑁬𑁦.

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

𑀢𑁂𑀦 𑀪𑀺𑀬𑁆𑀬𑁄 𑀩𑁆𑀬𑀲𑀦𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀢𑀺, 𑀦𑀸𑀭𑀺𑀦𑀁 𑀯𑀲𑀕𑀢𑁄 𑀅𑀧𑁂𑀓𑁆𑀔𑀯𑀸.

𑁩𑁬𑁧.

‘‘𑀓𑁂𑀲𑀮𑀽𑀦𑀦𑀔𑀙𑀺𑀦𑁆𑀦𑀢𑀚𑁆𑀚𑀺𑀢𑀸, 𑀧𑀸𑀤𑀧𑀸𑀡𑀺𑀓𑀲𑀤𑀡𑁆𑀟𑀢𑀸𑀴𑀺𑀢𑀸;

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

𑁩𑁬𑁨.

‘‘𑀢𑀸 𑀓𑀼𑀮𑁂𑀲𑀼 𑀯𑀺𑀲𑀺𑀔𑀦𑁆𑀢𑀭𑁂𑀲𑀼 𑀯𑀸, 𑀭𑀸𑀚𑀥𑀸𑀦𑀺𑀦𑀺𑀕𑀫𑁂𑀲𑀼 𑀯𑀸 𑀧𑀼𑀦 [𑀯𑀸 𑀧𑀦 (𑀲𑁆𑀬𑀸.)];

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

𑁩𑁬𑁩.

‘‘𑀑𑀲𑁆𑀲𑀚𑀺𑀢𑁆𑀯 ¶ 𑀓𑀼𑀲𑀮𑀁 𑀢𑀧𑁄𑀕𑀼𑀡𑀁, 𑀬𑁄 𑀅𑀦𑀭𑀺𑀬𑀘𑀭𑀺𑀢𑀸𑀦𑀺 𑀫𑀸𑀘𑀭𑀺;

𑀤𑁂𑀯𑀢𑀸𑀳𑀺 𑀦𑀺𑀭𑀬𑀁 𑀦𑀺𑀫𑀺𑀲𑁆𑀲𑀢𑀺, 𑀙𑁂𑀤𑀕𑀸𑀫𑀺𑀫𑀡𑀺𑀬𑀁𑀯 𑀯𑀸𑀡𑀺𑀚𑁄.

𑁩𑁬𑁪.

‘‘𑀲𑁄 𑀇𑀥 𑀕𑀭𑀳𑀺𑀢𑁄 𑀧𑀭𑀢𑁆𑀣 𑀘, 𑀤𑀼𑀫𑁆𑀫𑀢𑀻 𑀉𑀧𑀳𑀢𑁄 [𑀉𑀧𑀕𑀢𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀓𑀫𑁆𑀫𑀼𑀦𑀸;

𑀕𑀘𑁆𑀙𑀢𑀻 𑀅𑀦𑀺𑀬𑀢𑁄 𑀕𑀴𑀸𑀕𑀴𑀁, 𑀤𑀼𑀝𑁆𑀞𑀕𑀤𑁆𑀭𑀪𑀭𑀣𑁄𑀯 𑀉𑀧𑁆𑀧𑀣𑁂.

𑁩𑁬𑁫.

‘‘𑀲𑁄 𑀉𑀧𑁂𑀢𑀺 𑀦𑀺𑀭𑀬𑀁 𑀧𑀢𑀸𑀧𑀦𑀁, 𑀲𑀢𑁆𑀢𑀺𑀲𑀺𑀫𑁆𑀩𑀮𑀺𑀯𑀦𑀜𑁆𑀘 ¶ 𑀆𑀬𑀲𑀁;

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

𑁩𑁬𑁬.

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

𑀦𑀸𑀲𑀬𑀦𑁆𑀢𑀺 𑀧𑀫𑀤𑀸 𑀧𑀫𑀸𑀤𑀺𑀦𑀁, 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀜𑁆𑀘 𑀧𑀝𑀺𑀧𑀸𑀤𑀬𑀦𑁆𑀢𑀺 𑀦𑀁.

𑁩𑁬𑁭.

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

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

𑁩𑁬𑁮.

‘‘𑀓𑀸𑀫𑀥𑀸𑀢𑀼𑀲𑀫𑀢𑀺𑀓𑁆𑀓𑀫𑀸 𑀕𑀢𑀺, 𑀭𑀽𑀧𑀥𑀸𑀢𑀼𑀬𑀸 𑀪𑀸𑀯𑁄 [𑀭𑀽𑀧𑀥𑀸𑀢𑀼𑀬𑀸 𑀪𑀯𑁄 (𑀲𑀻.), 𑀭𑀽𑀧𑀥𑀸𑀢𑀼𑀲𑀫𑁆𑀪𑀯𑁄 (𑀲𑁆𑀬𑀸.)] 𑀦 𑀤𑀼𑀮𑁆𑀮𑀪𑁄;

𑀯𑀻𑀢𑀭𑀸𑀕𑀯𑀺𑀲𑀬𑀽𑀧𑀧𑀢𑁆𑀢𑀺𑀬𑀸, 𑀬𑁂 𑀘𑀭𑀦𑁆𑀢𑀺 𑀧𑀫𑀤𑀸𑀳𑀦𑀢𑁆𑀣𑀺𑀓𑀸.

𑁩𑁬𑁯.

‘‘𑀲𑀩𑁆𑀩𑀤𑀼𑀓𑁆𑀔𑀲𑀫𑀢𑀺𑀓𑁆𑀓𑀫𑀁 𑀲𑀺𑀯𑀁, 𑀅𑀘𑁆𑀘𑀦𑁆𑀢𑀫𑀘𑀮𑀺𑀢𑀁 𑀅𑀲𑀗𑁆𑀔𑀢𑀁;

𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁂𑀳𑀺 𑀲𑀼𑀘𑀺𑀳𑀻 𑀦 𑀤𑀼𑀮𑁆𑀮𑀪𑀁, 𑀬𑁂 𑀘𑀭𑀦𑁆𑀢𑀺 𑀧𑀫𑀤𑀸𑀳𑀦𑀢𑁆𑀣𑀺𑀓𑀸’’𑀢𑀺.

𑁩𑁭𑁦.

‘‘𑀓𑀼𑀡𑀸𑀮𑁄𑀳𑀁 𑀢𑀤𑀸 𑀆𑀲𑀺𑀁, 𑀉𑀤𑀸𑀬𑀻 𑀨𑀼𑀲𑁆𑀲𑀓𑁄𑀓𑀺𑀮𑁄;

𑀆𑀦𑀦𑁆𑀤𑁄 ¶ 𑀕𑀺𑀚𑁆𑀛𑀭𑀸𑀚𑀸𑀲𑀺, 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑁄 𑀘 𑀦𑀸𑀭𑀤𑁄;

𑀧𑀭𑀺𑀲𑀸 𑀩𑀼𑀤𑁆𑀥𑀧𑀭𑀺𑀲𑀸, 𑀏𑀯𑀁 𑀥𑀸𑀭𑁂𑀣 𑀚𑀸𑀢𑀓’’𑀦𑁆𑀢𑀺.

𑀓𑀼𑀡𑀸𑀮𑀚𑀸𑀢𑀓𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

𑁫𑁩𑁭. 𑀫𑀳𑀸𑀲𑀼𑀢𑀲𑁄𑀫𑀚𑀸𑀢𑀓𑀁 (𑁫)

𑁩𑁭𑁧.

‘‘𑀓𑀲𑁆𑀫𑀸 𑀢𑀼𑀯𑀁 𑀭𑀲𑀓 𑀏𑀤𑀺𑀲𑀸𑀦𑀺, 𑀓𑀭𑁄𑀲𑀺 𑀓𑀫𑁆𑀫𑀸𑀦𑀺 𑀲𑀼𑀤𑀸𑀭𑀼𑀡𑀸𑀦𑀺;

𑀳𑀦𑀸𑀲𑀺 𑀇𑀢𑁆𑀣𑀻 𑀧𑀼𑀭𑀺𑀲𑁂 𑀘 𑀫𑀽𑀴𑁆𑀳𑁄, 𑀫𑀁𑀲𑀲𑁆𑀲 𑀳𑁂𑀢𑀼 𑀅𑀤𑀼 [𑀆𑀤𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀥𑀦𑀲𑁆𑀲 𑀓𑀸𑀭𑀡𑀸’’.

𑁩𑁭𑁨.

‘‘𑀦𑀁 ¶ 𑀅𑀢𑁆𑀢𑀳𑁂𑀢𑀽 𑀦 𑀥𑀦𑀲𑁆𑀲 𑀓𑀸𑀭𑀡𑀸, 𑀦 𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑀲𑁆𑀲 𑀲𑀳𑀸𑀬𑀜𑀸𑀢𑀺𑀦𑀁;

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

𑁩𑁭𑁩.

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

𑀧𑀸𑀢𑁄𑀯 𑀅𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑀁 𑀧𑀸𑀧𑀼𑀡𑀺𑀢𑁆𑀯𑀸, 𑀮𑀧𑁂𑀬𑁆𑀬𑀸𑀲𑀺 𑀫𑁂 𑀭𑀸𑀚𑀺𑀦𑁄 𑀲𑀫𑁆𑀫𑀼𑀔𑁂 𑀢𑀁’’.

𑁩𑁭𑁪.

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

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

𑁩𑁭𑁫.

𑀢𑀢𑁄 ¶ 𑀭𑀢𑁆𑀬𑀸 𑀯𑀺𑀯𑀲𑀸𑀦𑁂 [𑀯𑀺𑀯𑀲𑀦𑁂 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀲𑀽𑀭𑀺𑀬𑀼𑀕𑁆𑀕𑀫𑀦𑀁 𑀧𑀢𑀺;

𑀓𑀸𑀴𑁄 𑀭𑀲𑀓𑀫𑀸𑀤𑀸𑀬, 𑀭𑀸𑀚𑀸𑀦𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺;

𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑁆𑀫 [𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀭𑀸𑀚𑀸𑀦𑀁, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺.

𑁩𑁭𑁬.

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

𑀳𑀦𑀢𑀺 𑀇𑀢𑁆𑀣𑀺𑀧𑀼𑀭𑀺𑀲𑁂, 𑀢𑀼𑀯𑀁 𑀫𑀁𑀲𑀸𑀦𑀺 𑀔𑀸𑀤𑀲𑀺’’.

𑁩𑁭𑁭.

‘‘𑀏𑀯𑀫𑁂𑀯 𑀢𑀣𑀸 𑀓𑀸𑀴, 𑀭𑀲𑀓𑁄 𑀧𑁂𑀲𑀺𑀢𑁄 𑀫𑀬𑀸;

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

𑁩𑁭𑁮.

‘‘𑀆𑀦𑀦𑁆𑀤𑁄 𑀲𑀩𑁆𑀩𑀫𑀘𑁆𑀙𑀸𑀦𑀁, 𑀔𑀸𑀤𑀺𑀢𑁆𑀯𑀸 𑀭𑀲𑀕𑀺𑀤𑁆𑀥𑀺𑀫𑀸;

𑀧𑀭𑀺𑀓𑁆𑀔𑀻𑀡𑀸𑀬 𑀧𑀭𑀺𑀲𑀸𑀬, 𑀅𑀢𑁆𑀢𑀸𑀦𑀁 𑀔𑀸𑀤𑀺𑀬𑀸 𑀫𑀢𑁄.

𑁩𑁭𑁯.

‘‘𑀏𑀯𑀁 𑀧𑀫𑀢𑁆𑀢𑁄 𑀭𑀲𑀕𑀸𑀭𑀯𑁂 𑀭𑀢𑁆𑀢𑁄 [𑀭𑀢𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀩𑀸𑀮𑁄 𑀬𑀤𑀻 𑀆𑀬𑀢𑀺 𑀦𑀸𑀯𑀩𑀼𑀚𑁆𑀛𑀢𑀺;

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

𑁩𑁮𑁦.

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

𑀫𑀸 𑀢𑁆𑀯𑀁 𑀇𑀫𑀁 𑀓𑁂𑀯𑀮𑀁 𑀯𑀸𑀭𑀺𑀚𑁄𑀯, 𑀤𑁆𑀯𑀺𑀧𑀤𑀸𑀥𑀺𑀧 [𑀤𑀺𑀧𑀤𑀸𑀤𑀺𑀧 (𑀲𑀻. 𑀧𑀻.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] 𑀲𑀼𑀜𑁆𑀜𑀫𑀓𑀸𑀲𑀺 𑀭𑀝𑁆𑀞𑀁’’.

𑁩𑁮𑁧.

‘‘𑀲𑀼𑀚𑀸𑀢𑁄 𑀦𑀸𑀫 𑀦𑀸𑀫𑁂𑀦, 𑀑𑀭𑀲𑁄 𑀢𑀲𑁆𑀲 𑀅𑀢𑁆𑀭𑀚𑁄 [𑀢𑀲𑁆𑀲 𑀑𑀭𑀲 𑀅𑀢𑁆𑀭𑀚𑁄 (𑀲𑀻.), 𑀢𑀲𑁆𑀲 𑀅𑀢𑁆𑀭𑀚 𑀑𑀭𑀲𑁄 (𑀧𑀻.)];

𑀚𑀫𑁆𑀩𑀼𑀧𑁂𑀲𑀺𑀫𑀮𑀤𑁆𑀥𑀸𑀦, 𑀫𑀢𑁄 𑀲𑁄 𑀢𑀲𑁆𑀲 𑀲𑀗𑁆𑀔𑀬𑁂.

𑁩𑁮𑁨.

‘‘𑀏𑀯𑀫𑁂𑀯 ¶ 𑀅𑀳𑀁 𑀓𑀸𑀴, 𑀪𑀼𑀢𑁆𑀯𑀸 𑀪𑀓𑁆𑀔𑀁 𑀭𑀲𑀼𑀢𑁆𑀢𑀫𑀁;

𑀅𑀮𑀤𑁆𑀥𑀸 𑀫𑀸𑀦𑀼𑀲𑀁 𑀫𑀁𑀲𑀁, 𑀫𑀜𑁆𑀜𑁂 𑀳𑀺𑀲𑁆𑀲𑀸𑀫𑀺 [𑀳𑁂𑀲𑁆𑀲𑀸𑀫𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.), 𑀳𑀲𑁆𑀲𑀸𑀫𑀺 (𑀧𑀻.)] 𑀚𑀻𑀯𑀺𑀢𑀁’’.

𑁩𑁮𑁩.

‘‘𑀫𑀸𑀡𑀯 𑀅𑀪𑀺𑀭𑀽𑀧𑁄𑀲𑀺, 𑀓𑀼𑀮𑁂 𑀚𑀸𑀢𑁄𑀲𑀺 𑀲𑁄𑀢𑁆𑀣𑀺𑀬𑁂;

𑀦 𑀢𑁆𑀯𑀁 𑀅𑀭𑀳𑀲𑀺 𑀢𑀸𑀢, 𑀅𑀪𑀓𑁆𑀔𑀁 𑀪𑀓𑁆𑀔𑀬𑁂𑀢𑀯𑁂’’.

𑁩𑁮𑁪.

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

𑀲𑁄𑀳𑀁 𑀢𑀢𑁆𑀣 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀬𑀢𑁆𑀣 𑀮𑀘𑁆𑀙𑀸𑀫𑀺 𑀏𑀤𑀺𑀲𑀁.

𑁩𑁮𑁫.

‘‘𑀲𑁄𑀯𑀸𑀳𑀁 𑀦𑀺𑀧𑁆𑀧𑀢𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀦 𑀢𑁂 𑀯𑀘𑁆𑀙𑀸𑀫𑀺 𑀲𑀦𑁆𑀢𑀺𑀓𑁂;

𑀬𑀲𑁆𑀲 𑀫𑁂 𑀤𑀲𑁆𑀲𑀦𑁂𑀦 𑀢𑁆𑀯𑀁, 𑀦𑀸𑀪𑀺𑀦𑀦𑁆𑀤𑀲𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡’’.

𑁩𑁮𑁬.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀅𑀜𑁆𑀜𑁂𑀧𑀺 𑀤𑀸𑀬𑀸𑀤𑁂, 𑀧𑀼𑀢𑁆𑀢𑁂 𑀮𑀘𑁆𑀙𑀸𑀫 𑀫𑀸𑀡𑀯;

𑀢𑁆𑀯𑀜𑁆𑀘 𑀚𑀫𑁆𑀫 𑀯𑀺𑀦𑀲𑁆𑀲𑀲𑁆𑀲𑀼, 𑀬𑀢𑁆𑀣 𑀧𑀢𑁆𑀢𑀁 𑀦 𑀢𑀁 𑀲𑀼𑀡𑁂’’.

𑁩𑁮𑁭.

‘‘𑀏𑀯𑀫𑁂𑀯 𑀢𑀼𑀯𑀁 𑀭𑀸𑀚, 𑀤𑁆𑀯𑀺𑀧𑀤𑀺𑀦𑁆𑀤 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑁂;

𑀧𑀩𑁆𑀩𑀸𑀚𑁂𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀢𑀁 𑀭𑀝𑁆𑀞𑀸, 𑀲𑁄𑀡𑁆𑀟𑀁 𑀫𑀸𑀡𑀯𑀓𑀁 𑀬𑀣𑀸’’.

𑁩𑁮𑁮.

‘‘𑀲𑀼𑀚𑀸𑀢𑁄 𑀦𑀸𑀫 𑀦𑀸𑀫𑁂𑀦, 𑀪𑀸𑀯𑀺𑀢𑀢𑁆𑀢𑀸𑀦 𑀲𑀸𑀯𑀓𑁄;

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

𑁩𑁮𑁯.

‘‘𑀓𑀼𑀲𑀕𑁆𑀕𑁂𑀦𑀼𑀤𑀓𑀫𑀸𑀤𑀸𑀬 ¶ [𑀓𑀼𑀲𑀕𑁆𑀕𑁂 𑀉𑀤𑀓𑀫𑀸𑀤𑀸𑀬 (𑀲𑀻. 𑀧𑀻.)], 𑀲𑀫𑀼𑀤𑁆𑀤𑁂 𑀉𑀤𑀓𑀁 𑀫𑀺𑀦𑁂;

𑀏𑀯𑀁 𑀫𑀸𑀦𑀼𑀲𑀓𑀸 𑀓𑀸𑀫𑀸, 𑀤𑀺𑀩𑁆𑀩𑀓𑀸𑀫𑀸𑀦 𑀲𑀦𑁆𑀢𑀺𑀓𑁂.

𑁩𑁯𑁦.

‘‘𑀏𑀯𑀫𑁂𑀯 𑀅𑀳𑀁 𑀓𑀸𑀴, 𑀪𑀼𑀢𑁆𑀯𑀸 𑀪𑀓𑁆𑀔𑀁 𑀭𑀲𑀼𑀢𑁆𑀢𑀫𑀁;

𑀅𑀮𑀤𑁆𑀥𑀸 𑀫𑀸𑀦𑀼𑀲𑀁 𑀫𑀁𑀲𑀁, 𑀫𑀜𑁆𑀜𑁂 𑀳𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀚𑀻𑀯𑀺𑀢𑀁’’.

𑁩𑁯𑁧.

‘‘𑀬𑀣𑀸𑀧𑀺 ¶ 𑀢𑁂 𑀥𑀢𑀭𑀝𑁆𑀞𑀸, 𑀳𑀁𑀲𑀸 𑀯𑁂𑀳𑀸𑀬𑀲𑀗𑁆𑀕𑀫𑀸;

𑀅𑀪𑀼𑀢𑁆𑀢𑀧𑀭𑀺𑀪𑁄𑀕𑁂𑀦 [𑀅𑀯𑀼𑀢𑁆𑀢𑀺𑀧𑀭𑀺𑀪𑁄𑀕𑁂𑀦 (𑀲𑀻. 𑀧𑀻.), 𑀅𑀬𑀼𑀢𑁆𑀢𑀧𑀭𑀺𑀪𑁄𑀕𑁂𑀦 (𑀲𑁆𑀬𑀸.)], 𑀲𑀩𑁆𑀩𑁂 𑀅𑀩𑁆𑀪𑀢𑁆𑀣𑀢𑀁 𑀕𑀢𑀸.

𑁩𑁯𑁨.

‘‘𑀏𑀯𑀫𑁂𑀯 ¶ 𑀢𑀼𑀯𑀁 𑀭𑀸𑀚, 𑀤𑁆𑀯𑀺𑀧𑀤𑀺𑀦𑁆𑀤 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑁂;

𑀅𑀪𑀓𑁆𑀔𑀁 𑀭𑀸𑀚 𑀪𑀓𑁆𑀔𑁂𑀲𑀺, 𑀢𑀲𑁆𑀫𑀸 𑀧𑀩𑁆𑀩𑀸𑀚𑀬𑀦𑁆𑀢𑀺 𑀢𑀁’’.

𑁩𑁯𑁩.

‘‘𑀢𑀺𑀝𑁆𑀞𑀸𑀳𑀻𑀢𑀺 𑀫𑀬𑀸 𑀯𑀼𑀢𑁆𑀢𑁄, 𑀲𑁄 𑀢𑁆𑀯𑀁 𑀕𑀘𑁆𑀙𑀲𑀺 𑀧𑀫𑁆𑀫𑀼𑀔𑁄 [𑀧𑀸𑀫𑀼𑀔𑁄 (𑀓.)];

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

𑀇𑀤𑀁 𑀢𑁂 𑀲𑀫𑀡𑀸𑀬𑀼𑀢𑁆𑀢𑀁, 𑀅𑀲𑀺𑀜𑁆𑀘 𑀫𑁂 𑀫𑀜𑁆𑀜𑀲𑀺 𑀓𑀗𑁆𑀓𑀧𑀢𑁆𑀢𑀁’’ [𑀓𑀗𑁆𑀔𑀧𑀢𑁆𑀢𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑁩𑁯𑁪.

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

𑀘𑁄𑀭𑀜𑁆𑀘 𑀮𑁄𑀓𑁂 𑀅𑀞𑀺𑀢𑀁 𑀯𑀤𑀦𑁆𑀢𑀺, 𑀆𑀧𑀸𑀬𑀺𑀓𑀁 𑀦𑁂𑀭𑀬𑀺𑀓𑀁 𑀇𑀢𑁄 𑀘𑀼𑀢𑀁.

𑁩𑁯𑁫.

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

𑀢𑁂𑀦 𑀬𑀜𑁆𑀜𑀁 𑀬𑀚𑀺𑀢𑁆𑀯𑀸𑀦, 𑀏𑀯𑀁 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺’’.

𑁩𑁯𑁬.

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

𑀅𑀓𑁆𑀔𑀸𑀳𑀺 𑀫𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡 𑀏𑀢𑀫𑀢𑁆𑀣𑀁, 𑀓𑀺𑀫𑀺𑀘𑁆𑀙𑀲𑀻 𑀤𑁂𑀫𑀺 𑀢𑀬𑀚𑁆𑀚 𑀧𑀢𑁆𑀣𑀺𑀢𑀁’’.

𑁩𑁯𑁭.

‘‘𑀕𑀸𑀣𑀸 𑀘𑀢𑀲𑁆𑀲𑁄 𑀥𑀭𑀡𑀻𑀫𑀳𑀺𑀲𑁆𑀲𑀭, 𑀲𑀼𑀕𑀫𑁆𑀪𑀺𑀭𑀢𑁆𑀣𑀸 𑀯𑀭𑀲𑀸𑀕𑀭𑀽𑀧𑀫𑀸;

𑀢𑀯𑁂𑀯 𑀅𑀢𑁆𑀣𑀸𑀬 𑀇𑀥𑀸𑀕𑀢𑁄𑀲𑁆𑀫𑀺, 𑀲𑀼𑀡𑁄𑀳𑀺 𑀕𑀸𑀣𑀸 𑀧𑀭𑀫𑀢𑁆𑀣𑀲𑀁𑀳𑀺𑀢𑀸’’.

𑁩𑁯𑁮.

‘‘𑀦 𑀯𑁂 𑀭𑀼𑀤𑀦𑁆𑀢𑀺 𑀫𑀢𑀺𑀫𑀦𑁆𑀢𑁄 𑀲𑀧𑀜𑁆𑀜𑀸, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑀸 ¶ 𑀬𑁂 𑀩𑀳𑀼𑀝𑁆𑀞𑀸𑀦𑀘𑀺𑀦𑁆𑀢𑀺𑀦𑁄;

𑀤𑀻𑀧𑀜𑁆𑀳𑀺 𑀏𑀢𑀁 𑀧𑀭𑀫𑀁 𑀦𑀭𑀸𑀦𑀁, 𑀬𑀁 𑀧𑀡𑁆𑀟𑀺𑀢𑀸 𑀲𑁄𑀓𑀦𑀼𑀤𑀸 𑀪𑀯𑀦𑁆𑀢𑀺.

𑁩𑁯𑁯.

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

𑀓𑀺𑀫𑁂𑀯 𑀢𑁆𑀯𑀁 [𑀓𑀺𑀫𑁄 𑀦𑀼 𑀢𑁆𑀯𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀼𑀢𑀲𑁄𑀫𑀸𑀦𑀼𑀢𑀧𑁆𑀧𑁂, 𑀓𑁄𑀭𑀩𑁆𑀬𑀲𑁂𑀝𑁆𑀞 𑀯𑀘𑀦𑀁 𑀲𑀼𑀡𑁄𑀫 𑀢𑁂𑀢𑀁’.

𑁪𑁦𑁦.

‘‘𑀦𑁂𑀯𑀸𑀳𑀫𑀢𑁆𑀢𑀸𑀦𑀫𑀦𑀼𑀢𑁆𑀣𑀼𑀦𑀸𑀫𑀺, 𑀦 𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑀁 𑀦 𑀥𑀦𑀁 𑀦 𑀭𑀝𑁆𑀞𑀁;

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

𑁪𑁦𑁧.

‘‘𑀓𑀢𑁄 𑀫𑀬𑀸 𑀲𑀗𑁆𑀓𑀭𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀦, 𑀭𑀝𑁆𑀞𑁂 𑀲𑀓𑁂 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑁂 𑀞𑀺𑀢𑁂𑀦;

𑀢𑀁 𑀲𑀗𑁆𑀓𑀭𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑀧𑁆𑀧𑀤𑀸𑀬, 𑀲𑀘𑁆𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀻 𑀧𑀼𑀦𑀭𑀸𑀯𑀚𑀺𑀲𑁆𑀲𑀁’’.

𑁪𑁦𑁨.

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

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

𑁪𑁦𑁩.

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

𑀫𑀥𑀼𑀭𑀁 𑀧𑀺𑀬𑀁 𑀚𑀻𑀯𑀺𑀢𑀁 𑀮𑀤𑁆𑀥 𑀭𑀸𑀚, 𑀓𑀼𑀢𑁄 𑀢𑀼𑀯𑀁 𑀏𑀳𑀺𑀲𑀺 𑀫𑁂 𑀲𑀓𑀸𑀲𑀁’’.

𑁪𑁦𑁪.

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

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

𑁪𑁦𑁫.

‘‘𑀲𑀘𑁂𑀧𑀺 𑀯𑀸𑀢𑁄 𑀕𑀺𑀭𑀺𑀫𑀸𑀯𑀳𑁂𑀬𑁆𑀬, 𑀘𑀦𑁆𑀤𑁄 𑀘 𑀲𑀽𑀭𑀺𑀬𑁄 𑀘 𑀙𑀫𑀸 𑀧𑀢𑁂𑀬𑁆𑀬𑀼𑀁;

𑀲𑀩𑁆𑀩𑀸 𑀘 𑀦𑀚𑁆𑀚𑁄 𑀧𑀝𑀺𑀲𑁄𑀢𑀁 𑀯𑀚𑁂𑀬𑁆𑀬𑀼𑀁, 𑀦 𑀢𑁆𑀯𑁂𑀯𑀳𑀁 𑀭𑀸𑀚 𑀫𑀼𑀲𑀸 𑀪𑀡𑁂𑀬𑁆𑀬𑀁.

𑁪𑁦𑁬.

[𑀅𑀬𑀁 𑀕𑀸𑀣𑀸 𑀲𑀻. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼 𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀺] ‘‘𑀦𑀪𑀁 ¶ 𑀨𑀮𑁂𑀬𑁆𑀬 𑀉𑀤𑀥𑀻𑀧𑀺 𑀲𑀼𑀲𑁆𑀲𑁂, 𑀲𑀁𑀯𑀝𑁆𑀝𑀬𑁂 𑀪𑀽𑀢𑀥𑀭𑀸 𑀯𑀲𑀼𑀦𑁆𑀥𑀭𑀸;

𑀲𑀺𑀮𑀼𑀘𑁆𑀘𑀬𑁄 𑀫𑁂𑀭𑀼 𑀲𑀫𑀽𑀮𑀫𑀼𑀧𑁆𑀧𑀢𑁂, 𑀦 𑀢𑁆𑀯𑁂𑀯𑀳𑀁 𑀭𑀸𑀚 𑀫𑀼𑀲𑀸 𑀪𑀡𑁂𑀬𑁆𑀬𑀁’’ [𑀅𑀬𑀁 𑀕𑀸𑀣𑀸 𑀲𑀻. 𑀧𑀻. 𑀧𑁄𑀢𑁆𑀣𑀓𑁂𑀲𑀼 𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀺].

𑁪𑁦𑁭.

‘‘𑀅𑀲𑀺𑀜𑁆𑀘 𑀲𑀢𑁆𑀢𑀺𑀜𑁆𑀘 𑀧𑀭𑀸𑀫𑀲𑀸𑀫𑀺, 𑀲𑀧𑀣𑀫𑁆𑀧𑀺 𑀢𑁂 𑀲𑀫𑁆𑀫 𑀅𑀳𑀁 𑀓𑀭𑁄𑀫𑀺;

𑀢𑀬𑀸 𑀧𑀫𑀼𑀢𑁆𑀢𑁄 𑀅𑀦𑀡𑁄 𑀪𑀯𑀺𑀢𑁆𑀯𑀸, 𑀲𑀘𑁆𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀻 𑀧𑀼𑀦𑀭𑀸𑀯𑀚𑀺𑀲𑁆𑀲𑀁’’.

𑁪𑁦𑁮.

‘‘𑀬𑁄 𑀢𑁂 𑀓𑀢𑁄 𑀲𑀗𑁆𑀓𑀭𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀦, 𑀭𑀝𑁆𑀞𑁂 𑀲𑀓𑁂 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑁂 𑀞𑀺𑀢𑁂𑀦;

𑀢𑀁 𑀲𑀗𑁆𑀓𑀭𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑀧𑁆𑀧𑀤𑀸𑀬, 𑀲𑀘𑁆𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀻 𑀧𑀼𑀦𑀭𑀸𑀯𑀚𑀲𑁆𑀲𑀼’’.

𑁪𑁦𑁯.

‘‘𑀬𑁄 𑀫𑁂 𑀓𑀢𑁄 𑀲𑀗𑁆𑀓𑀭𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀦, 𑀭𑀝𑁆𑀞𑁂 ¶ 𑀲𑀓𑁂 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑁂 𑀞𑀺𑀢𑁂𑀦;

𑀢𑀁 𑀲𑀗𑁆𑀓𑀭𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑀧𑁆𑀧𑀤𑀸𑀬, 𑀲𑀘𑁆𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀻 𑀧𑀼𑀦𑀭𑀸𑀯𑀚𑀺𑀲𑁆𑀲𑀁’’.

𑁪𑁧𑁦.

‘‘𑀫𑀼𑀢𑁆𑀢𑁄 𑀘 𑀲𑁄 𑀧𑁄𑀭𑀺𑀲𑀸𑀤𑀲𑁆𑀲 𑀳𑀢𑁆𑀣𑀸, 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀢𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀁 𑀏𑀢𑀤𑀯𑁄𑀘;

𑀲𑀼𑀡𑁄𑀫 [𑀲𑀼𑀡𑁄𑀫𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀕𑀸𑀣𑀸𑀬𑁄 𑀲𑀢𑀸𑀭𑀳𑀸𑀬𑁄, 𑀬𑀸 𑀫𑁂 𑀲𑀼𑀢𑀸 𑀅𑀲𑁆𑀲𑀼 𑀳𑀺𑀢𑀸𑀬 𑀩𑁆𑀭𑀳𑁆𑀫𑁂’’.

𑁪𑁧𑁧.

‘‘𑀲𑀓𑀺𑀤𑁂𑀯 𑀲𑀼𑀢𑀲𑁄𑀫, 𑀲𑀩𑁆𑀪𑀺 𑀳𑁄𑀢𑀺 [𑀳𑁄𑀢𑀼 (𑀧𑀻.)] 𑀲𑀫𑀸𑀕𑀫𑁄;

𑀲𑀸 𑀦𑀁 𑀲𑀗𑁆𑀕𑀢𑀺 𑀧𑀸𑀮𑁂𑀢𑀺, 𑀦𑀸𑀲𑀩𑁆𑀪𑀺 𑀩𑀳𑀼𑀲𑀗𑁆𑀕𑀫𑁄.

𑁪𑁧𑁨.

‘‘𑀲𑀩𑁆𑀪𑀺𑀭𑁂𑀯 𑀲𑀫𑀸𑀲𑁂𑀣, 𑀲𑀩𑁆𑀪𑀺 𑀓𑀼𑀩𑁆𑀩𑁂𑀣 𑀲𑀦𑁆𑀣𑀯𑀁;

𑀲𑀢𑀁 𑀲𑀤𑁆𑀥𑀫𑁆𑀫𑀫𑀜𑁆𑀜𑀸𑀬, 𑀲𑁂𑀬𑁆𑀬𑁄 𑀳𑁄𑀢𑀺 𑀦 𑀧𑀸𑀧𑀺𑀬𑁄.

𑁪𑁧𑁩.

‘‘𑀚𑀻𑀭𑀦𑁆𑀢𑀺 𑀯𑁂 𑀭𑀸𑀚𑀭𑀣𑀸 𑀲𑀼𑀘𑀺𑀢𑁆𑀢𑀸, 𑀅𑀣𑁄 𑀲𑀭𑀻𑀭𑀫𑁆𑀧𑀺 𑀚𑀭𑀁 𑀉𑀧𑁂𑀢𑀺;

𑀲𑀢𑀜𑁆𑀘 𑀥𑀫𑁆𑀫𑁄 𑀦 𑀚𑀭𑀁 𑀉𑀧𑁂𑀢𑀺, 𑀲𑀦𑁆𑀢𑁄 𑀳𑀯𑁂 𑀲𑀩𑁆𑀪𑀺 𑀧𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑁪𑁧𑁪.

‘‘𑀦𑀪𑀜𑁆𑀘𑀁 ¶ 𑀤𑀽𑀭𑁂 𑀧𑀣𑀯𑀻 𑀘 𑀤𑀽𑀭𑁂, 𑀧𑀸𑀭𑀁 ¶ 𑀲𑀫𑀼𑀤𑁆𑀤𑀲𑁆𑀲 𑀢𑀤𑀸𑀳𑀼 𑀤𑀽𑀭𑁂;

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

𑁪𑁧𑁫.

‘‘𑀲𑀳𑀲𑁆𑀲𑀺𑀬𑀸 [𑀲𑀳𑀲𑁆𑀲𑀺𑀬𑁄 (𑀲𑀻. 𑀧𑀻.)] 𑀇𑀫𑀸 𑀕𑀸𑀣𑀸, 𑀦𑀳𑀺𑀫𑀸 [𑀦 𑀇𑀫𑀸, (𑀲𑀻. 𑀧𑀻.) 𑀦𑀬𑀺𑀫𑀸 (𑀲𑁆𑀬𑀸.)] 𑀕𑀸𑀣𑀸 𑀲𑀢𑀸𑀭𑀳𑀸;

𑀘𑀢𑁆𑀢𑀸𑀭𑀺 𑀢𑁆𑀯𑀁 𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀔𑀺𑀧𑁆𑀧𑀁 𑀕𑀡𑁆𑀳𑀸𑀳𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡’’.

𑁪𑁧𑁬.

‘‘𑀆𑀲𑀻𑀢𑀺𑀬𑀸 𑀦𑀸𑀯𑀼𑀢𑀺𑀬𑀸 [𑀅𑀲𑀻𑀢𑀺𑀬𑀸 𑀦𑀯𑀼𑀢𑀺𑀬𑀸 (𑀧𑀻.)] 𑀘 𑀕𑀸𑀣𑀸, 𑀲𑀢𑀸𑀭𑀳𑀸 𑀘𑀸𑀧𑀺 𑀪𑀯𑁂𑀬𑁆𑀬 [𑀪𑀯𑁂𑀬𑁆𑀬𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀕𑀸𑀣𑀸;

𑀧𑀘𑁆𑀘𑀢𑁆𑀢𑀫𑁂𑀯 𑀲𑀼𑀢𑀲𑁄𑀫 𑀚𑀸𑀦𑀳𑀺, 𑀲𑀳𑀲𑁆𑀲𑀺𑀬𑀸 𑀦𑀸𑀫 𑀓𑀸 𑀅𑀢𑁆𑀣𑀺 [𑀲𑀳𑀲𑁆𑀲𑀺𑀬𑁄 𑀦𑀸𑀫 𑀇𑀥𑀢𑁆𑀣𑀺 (𑀲𑀻.)] 𑀕𑀸𑀣𑀸’’.

𑁪𑁧𑁭.

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

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

𑁪𑁧𑁮.

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

𑀏𑀯𑀫𑁆𑀧𑀺 𑀢𑁂 𑀧𑀡𑁆𑀟𑀺𑀢𑀸 𑀭𑀸𑀚𑀲𑁂𑀝𑁆𑀞, 𑀲𑀼𑀢𑁆𑀯𑀸 𑀦 𑀢𑀧𑁆𑀧𑀦𑁆𑀢𑀺 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑁂𑀦.

𑁪𑁧𑁯.

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

𑀢𑀫𑁂𑀯 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀦𑀺𑀲𑀸𑀫𑀬𑀸𑀫𑀺, 𑀦 ¶ 𑀳𑀺 𑀢𑀸𑀢 𑀥𑀫𑁆𑀫𑁂𑀲𑀼 𑀫𑀫𑀢𑁆𑀣𑀺 𑀢𑀺𑀢𑁆𑀢𑀺’’.

𑁪𑁨𑁦.

‘‘𑀇𑀤𑀁 ¶ 𑀢𑁂 𑀭𑀝𑁆𑀞𑀁 𑀲𑀥𑀦𑀁 𑀲𑀬𑁄𑀕𑁆𑀕𑀁, 𑀲𑀓𑀸𑀬𑀼𑀭𑀁 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀽𑀧𑀧𑀦𑁆𑀦𑀁;

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

𑁪𑁨𑁧.

‘‘𑀅𑀢𑁆𑀢𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀸𑀬 𑀪𑀯𑀦𑁆𑀢𑀺 𑀳𑁂𑀢𑁂, 𑀳𑀢𑁆𑀣𑀸𑀭𑁄𑀳𑀸 𑀭𑀣𑀺𑀓𑀸 𑀧𑀢𑁆𑀢𑀺𑀓𑀸 𑀘;

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

𑁪𑁨𑁨.

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

𑀢𑀁 𑀢𑀸𑀤𑀺𑀲𑀁 𑀧𑀼𑀩𑁆𑀩𑀓𑀺𑀘𑁆𑀘𑀁 𑀲𑀭𑀦𑁆𑀢𑁄, 𑀤𑀼𑀩𑁆𑀪𑁂 𑀅𑀳𑀁 𑀢𑀲𑁆𑀲 𑀓𑀣𑀁 𑀚𑀦𑀺𑀦𑁆𑀤’’.

𑁪𑁨𑁩.

‘‘𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸 𑀲𑁄 𑀧𑀺𑀢𑀭𑀁 𑀫𑀸𑀢𑀭𑀜𑁆𑀘, 𑀅𑀦𑀼𑀲𑀸𑀲𑁂𑀢𑁆𑀯𑀸 𑀦𑁂𑀕𑀫𑀜𑁆𑀘 𑀩𑀮𑀜𑁆𑀘;

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

𑁪𑁨𑁪.

‘‘𑀓𑀢𑁄 𑀫𑀬𑀸 𑀲𑀗𑁆𑀓𑀭𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂𑀦, 𑀭𑀝𑁆𑀞𑁂 𑀲𑀓𑁂 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑁂 𑀞𑀺𑀢𑁂𑀦;

𑀢𑀁 𑀲𑀗𑁆𑀓𑀭𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑀧𑁆𑀧𑀤𑀸𑀬, 𑀲𑀘𑁆𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀻 ¶ 𑀧𑀼𑀦𑀭𑀸𑀕𑀢𑁄𑀲𑁆𑀫𑀺;

𑀬𑀚𑀲𑁆𑀲𑀼 𑀬𑀜𑁆𑀜𑀁 𑀔𑀸𑀤 𑀫𑀁 𑀧𑁄𑀭𑀺𑀲𑀸𑀤’’.

𑁪𑁨𑁫.

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

𑀦𑀺𑀤𑁆𑀥𑀽𑀫𑀓𑁂 𑀧𑀘𑀺𑀢𑀁 𑀲𑀸𑀥𑀼𑀧𑀓𑁆𑀓𑀁, 𑀲𑀼𑀡𑁄𑀫 [𑀲𑀼𑀡𑁄𑀫𑀺 (𑀲𑀻.), 𑀲𑀼𑀡𑀸𑀫 (𑀧𑀻.)] 𑀕𑀸𑀣𑀸𑀬𑁄 𑀲𑀢𑀸𑀭𑀳𑀸𑀬𑁄’’.

𑁪𑁨𑁬.

‘‘𑀅𑀥𑀫𑁆𑀫𑀺𑀓𑁄 ¶ 𑀢𑁆𑀯𑀁 𑀧𑁄𑀭𑀺𑀲𑀸𑀤𑀓𑀸𑀲𑀺 [𑀧𑁄𑀭𑀺𑀲𑀸𑀤𑀫𑀓𑀸𑀲𑀺 (𑀓.)], 𑀭𑀝𑁆𑀞𑀸 𑀘 𑀪𑀝𑁆𑀞𑁄 𑀉𑀤𑀭𑀲𑁆𑀲 𑀳𑁂𑀢𑀼;

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

𑁪𑁨𑁭.

‘‘𑀅𑀥𑀫𑁆𑀫𑀺𑀓𑀲𑁆𑀲 𑀮𑀼𑀤𑁆𑀤𑀲𑁆𑀲, 𑀦𑀺𑀘𑁆𑀘𑀁 𑀮𑁄𑀳𑀺𑀢𑀧𑀸𑀡𑀺𑀦𑁄;

𑀦𑀢𑁆𑀣𑀺 𑀲𑀘𑁆𑀘𑀁 𑀓𑀼𑀢𑁄 𑀥𑀫𑁆𑀫𑁄, 𑀓𑀺𑀁 𑀲𑀼𑀢𑁂𑀦 𑀓𑀭𑀺𑀲𑁆𑀲𑀲𑀺’’.

𑁪𑁨𑁮.

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

𑀉𑀪𑁄𑀧𑀺 𑀢𑁂 𑀧𑁂𑀘𑁆𑀘 𑀲𑀫𑀸 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀓𑀲𑁆𑀫𑀸 𑀦𑁄 [𑀓𑀲𑁆𑀫𑀸 𑀦𑀼 (𑀓.)] 𑀅𑀥𑀫𑁆𑀫𑀺𑀓𑀁 𑀩𑁆𑀭𑀽𑀲𑀺 𑀫𑀁 𑀢𑁆𑀯𑀁’’.

𑁪𑁨𑁯.

‘‘𑀧𑀜𑁆𑀘 𑀧𑀜𑁆𑀘𑀦𑀔𑀸 𑀪𑀓𑁆𑀔𑀸, 𑀔𑀢𑁆𑀢𑀺𑀬𑁂𑀦 𑀧𑀚𑀸𑀦𑀢𑀸;

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

𑁪𑁩𑁦.

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

𑀅𑀫𑀺𑀢𑁆𑀢𑀳𑀢𑁆𑀣𑀁 ¶ 𑀧𑀼𑀦𑀭𑀸𑀕𑀢𑁄𑀲𑀺, 𑀦 𑀔𑀢𑁆𑀢𑀥𑀫𑁆𑀫𑁂 𑀓𑀼𑀲𑀮𑁄𑀲𑀺 𑀭𑀸𑀚’’.

𑁪𑁩𑁧.

‘‘𑀬𑁂 ¶ 𑀔𑀢𑁆𑀢𑀥𑀫𑁆𑀫𑁂 𑀓𑀼𑀲𑀮𑀸 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀧𑀸𑀬𑁂𑀦 𑀢𑁂 𑀦𑁂𑀭𑀬𑀺𑀓𑀸 𑀪𑀯𑀦𑁆𑀢𑀺;

𑀢𑀲𑁆𑀫𑀸 𑀅𑀳𑀁 𑀔𑀢𑁆𑀢𑀥𑀫𑁆𑀫𑀁 𑀧𑀳𑀸𑀬, 𑀲𑀘𑁆𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀻 𑀧𑀼𑀦𑀭𑀸𑀕𑀢𑁄𑀲𑁆𑀫𑀺;

𑀬𑀚𑀲𑁆𑀲𑀼 𑀬𑀜𑁆𑀜𑀁 𑀔𑀸𑀤 𑀫𑀁 𑀧𑁄𑀭𑀺𑀲𑀸𑀤’’.

𑁪𑁩𑁨.

‘‘𑀧𑀸𑀲𑀸𑀤𑀯𑀸𑀲𑀸 𑀧𑀣𑀯𑀻𑀕𑀯𑀲𑁆𑀲𑀸, 𑀓𑀸𑀫𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀓𑀸𑀲𑀺𑀓𑀘𑀦𑁆𑀤𑀦𑀜𑁆𑀘;

𑀲𑀩𑁆𑀩𑀁 𑀢𑀳𑀺𑀁 𑀮𑀪𑀲𑀺 [𑀮𑀩𑁆𑀪𑀢𑀺 (𑀧𑀻.)] 𑀲𑀸𑀫𑀺𑀢𑀸𑀬, 𑀲𑀘𑁆𑀘𑁂𑀦 𑀓𑀺𑀁 𑀧𑀲𑁆𑀲𑀲𑀺 𑀆𑀦𑀺𑀲𑀁𑀲𑀁’’.

𑁪𑁩𑁩.

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

𑀲𑀘𑁆𑀘𑁂 𑀞𑀺𑀢𑀸 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀘, 𑀢𑀭𑀦𑁆𑀢𑀺 𑀚𑀸𑀢𑀺𑀫𑀭𑀡𑀲𑁆𑀲 𑀧𑀸𑀭𑀁’’.

𑁪𑁩𑁪.

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

𑀅𑀫𑀺𑀢𑁆𑀢𑀳𑀢𑁆𑀣𑀁 𑀧𑀼𑀦𑀭𑀸𑀕𑀢𑁄𑀲𑀺, 𑀦 𑀳𑀺 𑀦𑀽𑀦 𑀢𑁂 𑀫𑀭𑀡𑀪𑀬𑀁 𑀚𑀦𑀺𑀦𑁆𑀤;

𑀅𑀮𑀻𑀦𑀘𑀺𑀢𑁆𑀢𑁄 𑀅𑀲𑀺 [𑀘’𑀲𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀲𑀘𑁆𑀘𑀯𑀸𑀤𑀻’’.

𑁪𑁩𑁫.

‘‘𑀓𑀢𑀸 ¶ 𑀫𑁂 𑀓𑀮𑁆𑀬𑀸𑀡𑀸 𑀅𑀦𑁂𑀓𑀭𑀽𑀧𑀸, 𑀬𑀜𑁆𑀜𑀸 𑀬𑀺𑀝𑁆𑀞𑀸 𑀬𑁂 𑀯𑀺𑀧𑀼𑀮𑀸 𑀧𑀲𑀢𑁆𑀣𑀸;

𑀯𑀺𑀲𑁄𑀥𑀺𑀢𑁄 𑀧𑀭𑀮𑁄𑀓𑀲𑁆𑀲 𑀫𑀕𑁆𑀕𑁄, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀓𑁄 𑀫𑀭𑀡𑀲𑁆𑀲 𑀪𑀸𑀬𑁂.

𑁪𑁩𑁬.

‘‘𑀓𑀢𑀸 𑀫𑁂 𑀓𑀮𑁆𑀬𑀸𑀡𑀸 𑀅𑀦𑁂𑀓𑀭𑀽𑀧𑀸, 𑀬𑀜𑁆𑀜𑀸 𑀬𑀺𑀝𑁆𑀞𑀸 𑀬𑁂 𑀯𑀺𑀧𑀼𑀮𑀸 𑀧𑀲𑀢𑁆𑀣𑀸;

𑀅𑀦𑀸𑀦𑀼𑀢𑀧𑁆𑀧𑀁 𑀧𑀭𑀮𑁄𑀓𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀁, 𑀬𑀚𑀲𑁆𑀲𑀼 𑀬𑀜𑁆𑀜𑀁 𑀅𑀤 [𑀔𑀸𑀤 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀁 𑀧𑁄𑀭𑀺𑀲𑀸𑀤.

𑁪𑁩𑁭.

‘‘𑀧𑀺𑀢𑀸 𑀘 𑀫𑀸𑀢𑀸 𑀘 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸 𑀫𑁂, 𑀥𑀫𑁆𑀫𑁂𑀦 𑀫𑁂 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑀁 𑀧𑀲𑀢𑁆𑀣𑀁;

𑀯𑀺𑀲𑁄𑀥𑀺𑀢𑁄 𑀧𑀭𑀮𑁄𑀓𑀲𑁆𑀲 𑀫𑀕𑁆𑀕𑁄, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀓𑁄 𑀫𑀭𑀡𑀲𑁆𑀲 𑀪𑀸𑀬𑁂.

𑁪𑁩𑁮.

‘‘𑀧𑀺𑀢𑀸 𑀘 𑀫𑀸𑀢𑀸 𑀘 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸 𑀫𑁂, 𑀥𑀫𑁆𑀫𑁂𑀦 𑀫𑁂 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑀁 𑀧𑀲𑀢𑁆𑀣𑀁;

𑀅𑀦𑀸𑀦𑀼𑀢𑀧𑁆𑀧𑀁 𑀧𑀭𑀮𑁄𑀓𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀁, 𑀬𑀚𑀲𑁆𑀲𑀼 𑀬𑀜𑁆𑀜𑀁 𑀅𑀤 𑀫𑀁 𑀧𑁄𑀭𑀺𑀲𑀸𑀤.

𑁪𑁩𑁯.

‘‘𑀜𑀸𑀢𑀻𑀲𑀼 ¶ 𑀫𑀺𑀢𑁆𑀢𑁂𑀲𑀼 𑀓𑀢𑀸 𑀫𑁂 𑀓𑀸𑀭𑀸 [𑀓𑀢𑀽𑀧𑀓𑀸𑀭𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀥𑀫𑁆𑀫𑁂𑀦 𑀫𑁂 𑀇𑀲𑁆𑀲𑀭𑀺𑀬𑀁 𑀧𑀲𑀢𑁆𑀣𑀁;

𑀯𑀺𑀲𑁄𑀥𑀺𑀢𑁄 𑀧𑀭𑀮𑁄𑀓𑀲𑁆𑀲 𑀫𑀕𑁆𑀕𑁄, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀓𑁄 𑀫𑀭𑀡𑀲𑁆𑀲 𑀪𑀸𑀬𑁂.

𑁪𑁪𑁦.

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

𑀅𑀦𑀸𑀦𑀼𑀢𑀧𑁆𑀧𑀁 𑀧𑀭𑀮𑁄𑀓𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀁, 𑀬𑀚𑀲𑁆𑀲𑀼 𑀬𑀜𑁆𑀜𑀁 𑀅𑀤 𑀫𑀁 𑀧𑁄𑀭𑀺𑀲𑀸𑀤.

𑁪𑁪𑁧.

‘‘𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑁂 𑀤𑀸𑀦𑀁 𑀩𑀳𑀼𑀥𑀸 𑀩𑀳𑀽𑀦𑀁, 𑀲𑀦𑁆𑀢𑀧𑁆𑀧𑀺𑀢𑀸 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀘;

𑀯𑀺𑀲𑁄𑀥𑀺𑀢𑁄 𑀧𑀭𑀮𑁄𑀓𑀲𑁆𑀲 𑀫𑀕𑁆𑀕𑁄, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀓𑁄 𑀫𑀭𑀡𑀲𑁆𑀲 𑀪𑀸𑀬𑁂.

𑁪𑁪𑁨.

‘‘𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑁂 𑀤𑀸𑀦𑀁 𑀩𑀳𑀼𑀥𑀸 𑀩𑀳𑀽𑀦𑀁, 𑀲𑀦𑁆𑀢𑀧𑁆𑀧𑀺𑀢𑀸 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀘;

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

𑁪𑁪𑁩.

‘‘𑀯𑀺𑀲𑀁 𑀧𑀚𑀸𑀦𑀁 𑀧𑀼𑀭𑀺𑀲𑁄 𑀅𑀤𑁂𑀬𑁆𑀬, 𑀆𑀲𑀻𑀯𑀺𑀲𑀁 𑀚𑀮𑀺𑀢𑀫𑀼𑀕𑁆𑀕𑀢𑁂𑀚𑀁;

𑀫𑀼𑀤𑁆𑀥𑀸𑀧𑀺 𑀢𑀲𑁆𑀲 𑀯𑀺𑀨𑀮𑁂𑀬𑁆𑀬 [𑀯𑀺𑀧𑀢𑁂𑀬𑁆𑀬 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀢𑁆𑀢𑀥𑀸, 𑀬𑁄 𑀢𑀸𑀤𑀺𑀲𑀁 𑀲𑀘𑁆𑀘𑀯𑀸𑀤𑀺𑀁 𑀅𑀤𑁂𑀬𑁆𑀬’’.

𑁪𑁪𑁪.

‘‘𑀲𑀼𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀁 𑀯𑀺𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀦𑀭𑀸 𑀓𑀮𑁆𑀬𑀸𑀡𑀧𑀸𑀧𑀓𑀁;

𑀅𑀧𑀺 𑀕𑀸𑀣𑀸 𑀲𑀼𑀡𑀺𑀢𑁆𑀯𑀸𑀦, 𑀥𑀫𑁆𑀫𑁂 𑀫𑁂 𑀭𑀫𑀢𑁂 [𑀭𑀫𑀢𑀻 (𑀲𑀻. 𑀧𑀻.)] 𑀫𑀦𑁄’’.

𑁪𑁪𑁫.

‘‘𑀲𑀓𑀺𑀤𑁂𑀯 ¶ 𑀫𑀳𑀸𑀭𑀸𑀚 [𑀲𑀼𑀢𑀲𑁄𑀫 (𑀲𑀻. 𑀧𑀻.)], 𑀲𑀩𑁆𑀪𑀺 𑀳𑁄𑀢𑀺 𑀲𑀫𑀸𑀕𑀫𑁄;

𑀲𑀸 𑀦𑀁 𑀲𑀗𑁆𑀕𑀢𑀺 𑀧𑀸𑀮𑁂𑀢𑀺, 𑀦𑀸𑀲𑀩𑁆𑀪𑀺 𑀩𑀳𑀼𑀲𑀗𑁆𑀕𑀫𑁄.

𑁪𑁪𑁬.

‘‘𑀲𑀩𑁆𑀪𑀺𑀭𑁂𑀯 ¶ 𑀲𑀫𑀸𑀲𑁂𑀣, 𑀲𑀩𑁆𑀪𑀺 𑀓𑀼𑀩𑁆𑀩𑁂𑀣 𑀲𑀦𑁆𑀣𑀯𑀁;

𑀲𑀢𑀁 𑀲𑀤𑁆𑀥𑀫𑁆𑀫𑀫𑀜𑁆𑀜𑀸𑀬, 𑀲𑁂𑀬𑁆𑀬𑁄 𑀳𑁄𑀢𑀺 𑀦 𑀧𑀸𑀧𑀺𑀬𑁄.

𑁪𑁪𑁭.

‘‘𑀚𑀻𑀭𑀦𑁆𑀢𑀺 𑀯𑁂 𑀭𑀸𑀚𑀭𑀣𑀸 𑀲𑀼𑀘𑀺𑀢𑁆𑀢𑀸, 𑀅𑀣𑁄 𑀲𑀭𑀻𑀭𑀫𑁆𑀧𑀺 𑀚𑀭𑀁 𑀉𑀧𑁂𑀢𑀺;

𑀲𑀢𑀜𑁆𑀘 𑀥𑀫𑁆𑀫𑁄 𑀦 𑀚𑀭𑀁 𑀉𑀧𑁂𑀢𑀺, 𑀲𑀦𑁆𑀢𑁄 𑀳𑀯𑁂 𑀲𑀩𑁆𑀪𑀺 𑀧𑀯𑁂𑀤𑀬𑀦𑁆𑀢𑀺.

𑁪𑁪𑁮.

‘‘𑀦𑀪𑀜𑁆𑀘𑀁 ¶ 𑀤𑀽𑀭𑁂 𑀧𑀣𑀯𑀻 𑀘 𑀤𑀽𑀭𑁂, 𑀧𑀸𑀭𑀁 𑀲𑀫𑀼𑀤𑁆𑀤𑀲𑁆𑀲 𑀢𑀤𑀸𑀳𑀼 𑀤𑀽𑀭𑁂;

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

𑁪𑁪𑁯.

‘‘𑀕𑀸𑀣𑀸 𑀇𑀫𑀸 𑀅𑀢𑁆𑀣𑀯𑀢𑀻 𑀲𑀼𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀸, 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀸 𑀢𑀼𑀬𑁆𑀳 𑀚𑀦𑀺𑀦𑁆𑀤 𑀲𑀼𑀢𑁆𑀯𑀸;

𑀆𑀦𑀦𑁆𑀤𑀺 𑀯𑀺𑀢𑁆𑀢𑁄 𑀲𑀼𑀫𑀦𑁄 𑀧𑀢𑀻𑀢𑁄, 𑀘𑀢𑁆𑀢𑀸𑀭𑀺 𑀢𑁂 𑀲𑀫𑁆𑀫 𑀯𑀭𑁂 𑀤𑀤𑀸𑀫𑀺’’.

𑁪𑁫𑁦.

‘‘𑀬𑁄 𑀦𑀢𑁆𑀢𑀦𑁄 𑀫𑀭𑀡𑀁 𑀩𑀼𑀚𑁆𑀛𑀲𑀺 𑀢𑀼𑀯𑀁 [𑀩𑀼𑀚𑁆𑀛𑀲𑁂 𑀢𑁆𑀯𑀁 (𑀲𑀻. 𑀧𑀻.), 𑀩𑀼𑀚𑁆𑀛𑀲𑁂 𑀢𑀼𑀯𑀁 (𑀲𑁆𑀬𑀸.)], 𑀳𑀺𑀢𑀸𑀳𑀺𑀢𑀁 𑀯𑀺𑀦𑀺𑀧𑀸𑀢𑀜𑁆𑀘 𑀲𑀕𑁆𑀕𑀁;

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

𑁪𑁫𑁧.

‘‘𑀅𑀳𑀜𑁆𑀘 𑀢𑀁 𑀤𑁂𑀳𑀺 𑀯𑀭𑀦𑁆𑀢𑀺 𑀯𑀚𑁆𑀚𑀁, 𑀢𑁆𑀯𑀜𑁆𑀘𑀸𑀧𑀺 𑀤𑀢𑁆𑀯𑀸𑀦 𑀅𑀯𑀸𑀓𑀭𑁂𑀬𑁆𑀬;

𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓𑀁 ¶ 𑀓𑀮𑀳𑀫𑀺𑀫𑀁 𑀯𑀺𑀯𑀸𑀤𑀁, 𑀓𑁄 𑀧𑀡𑁆𑀟𑀺𑀢𑁄 𑀚𑀸𑀦𑀫𑀼𑀧𑀩𑁆𑀩𑀚𑁂𑀬𑁆𑀬’’.

𑁪𑁫𑁨.

‘‘𑀦 𑀢𑀁 𑀯𑀭𑀁 𑀅𑀭𑀳𑀢𑀺 𑀚𑀦𑁆𑀢𑀼 𑀤𑀸𑀢𑀼𑀁, 𑀬𑀁 𑀯𑀸𑀧𑀺 𑀤𑀢𑁆𑀯𑀸𑀦 𑀅𑀯𑀸𑀓𑀭𑁂𑀬𑁆𑀬;

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

𑁪𑁫𑁩.

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

𑀧𑀲𑁆𑀲𑁂𑀬𑁆𑀬 𑀢𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀁 𑀅𑀭𑁄𑀕𑀁 [𑀆𑀭𑁄𑀕𑁆𑀬𑀁 (𑀓.)], 𑀏𑀢𑀁 𑀯𑀭𑀸𑀦𑀁 𑀧𑀞𑀫𑀁 𑀯𑀭𑀸𑀫𑀺’’.

𑁪𑁫𑁪.

‘‘𑀅𑀭𑀺𑀬𑀲𑁆𑀲 𑀅𑀭𑀺𑀬𑁂𑀦 𑀲𑀫𑁂𑀢𑀺 𑀲𑀔𑁆𑀬𑀁, 𑀧𑀜𑁆𑀜𑀲𑁆𑀲 𑀧𑀜𑁆𑀜𑀸𑀡𑀯𑀢𑀸 𑀲𑀫𑁂𑀢𑀺;

𑀧𑀲𑁆𑀲𑀸𑀲𑀺 𑀫𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀁 𑀅𑀭𑁄𑀕𑀁, 𑀏𑀢𑀁 𑀯𑀭𑀸𑀦𑀁 𑀧𑀞𑀫𑀁 𑀤𑀤𑀸𑀫𑀺’’.

𑁪𑁫𑁫.

‘‘𑀬𑁂 ¶ 𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀲𑁂 𑀇𑀥 𑀪𑀽𑀫𑀺𑀧𑀸𑀮𑀸, 𑀫𑀼𑀤𑁆𑀥𑀸𑀪𑀺𑀲𑀺𑀢𑁆𑀢𑀸 𑀓𑀢𑀦𑀸𑀫𑀥𑁂𑀬𑁆𑀬𑀸;

𑀦 𑀢𑀸𑀤𑀺𑀲𑁂 𑀪𑀽𑀫𑀺𑀧𑀢𑀻 𑀅𑀤𑁂𑀲𑀺, 𑀏𑀢𑀁 𑀯𑀭𑀸𑀦𑀁 𑀤𑀼𑀢𑀺𑀬𑀁 𑀯𑀭𑀸𑀫𑀺’’.

𑁪𑁫𑁬.

‘‘𑀬𑁂 𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀲𑁂 𑀇𑀥 𑀪𑀽𑀫𑀺𑀧𑀸𑀮𑀸, 𑀫𑀼𑀤𑁆𑀥𑀸𑀪𑀺𑀲𑀺𑀢𑁆𑀢𑀸 𑀓𑀢𑀦𑀸𑀫𑀥𑁂𑀬𑁆𑀬𑀸;

𑀦 ¶ 𑀢𑀸𑀤𑀺𑀲𑁂 𑀪𑀽𑀫𑀺𑀧𑀢𑀻 𑀅𑀤𑁂𑀫𑀺, 𑀏𑀢𑀁 𑀯𑀭𑀸𑀦𑀁 𑀤𑀼𑀢𑀺𑀬𑀁 𑀤𑀤𑀸𑀫𑀺’’.

𑁪𑁫𑁭.

‘‘𑀧𑀭𑁄𑀲𑀢𑀁 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀢𑁂 𑀕𑀳𑀺𑀢𑀸, 𑀢𑀮𑀸𑀯𑀼𑀢𑀸 𑀅𑀲𑁆𑀲𑀼𑀫𑀼𑀔𑀸 𑀭𑀼𑀤𑀦𑁆𑀢𑀸;

𑀲𑀓𑁂 𑀢𑁂 𑀭𑀝𑁆𑀞𑁂 𑀧𑀝𑀺𑀧𑀸𑀤𑀬𑀸𑀳𑀺, 𑀏𑀢𑀁 𑀯𑀭𑀸𑀦𑀁 𑀢𑀢𑀺𑀬𑀁 𑀯𑀭𑀸𑀫𑀺’’.

𑁪𑁫𑁮.

‘‘𑀧𑀭𑁄𑀲𑀢𑀁 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀫𑁂 𑀕𑀳𑀺𑀢𑀸, 𑀢𑀮𑀸𑀯𑀼𑀢𑀸 𑀅𑀲𑁆𑀲𑀼𑀫𑀼𑀔𑀸 𑀭𑀼𑀤𑀦𑁆𑀢𑀸;

𑀲𑀓𑁂 𑀢𑁂 𑀭𑀝𑁆𑀞𑁂 𑀧𑀝𑀺𑀧𑀸𑀤𑀬𑀸𑀫𑀺 [𑀲𑀓𑁂𑀦 𑀭𑀝𑁆𑀞𑁂𑀦 𑀧𑀝𑀺𑀧𑀸𑀤𑀬𑀸𑀫𑀺 𑀢𑁂 (𑀲𑀻.)], 𑀏𑀢𑀁 𑀯𑀭𑀸𑀦𑀁 𑀢𑀢𑀺𑀬𑀁 𑀤𑀤𑀸𑀫𑀺’’.

𑁪𑁫𑁯.

‘‘𑀙𑀺𑀤𑁆𑀤𑀁 𑀢𑁂 𑀭𑀝𑁆𑀞𑀁 𑀩𑁆𑀬𑀣𑀺𑀢𑀸 [𑀩𑁆𑀬𑀣𑀺𑀢𑀁 (𑀲𑀻.), 𑀩𑁆𑀬𑀸𑀥𑀺𑀢𑀁 (𑀧𑀻.)] 𑀪𑀬𑀸 𑀳𑀺, 𑀧𑀼𑀣𑀽 𑀦𑀭𑀸 𑀮𑁂𑀡𑀫𑀦𑀼𑀧𑁆𑀧𑀯𑀺𑀝𑁆𑀞𑀸;

𑀫𑀦𑀼𑀲𑁆𑀲𑀫𑀁𑀲𑀁 𑀯𑀺𑀭𑀫𑁂𑀳𑀺 [𑀯𑀺𑀭𑀫𑀸𑀳𑀺 (𑀲𑁆𑀬𑀸.)] 𑀭𑀸𑀚, 𑀏𑀢𑀁 𑀯𑀭𑀸𑀦𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀯𑀭𑀸𑀫𑀺’’.

𑁪𑁬𑁦.

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

𑀲𑁄𑀳𑀁 𑀓𑀣𑀁 𑀏𑀢𑁆𑀢𑁄 𑀉𑀧𑀸𑀭𑀫𑁂𑀬𑁆𑀬𑀁, 𑀅𑀜𑁆𑀜𑀁 𑀯𑀭𑀸𑀦𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁 𑀯𑀭𑀲𑁆𑀲𑀼’’.

𑁪𑁬𑁧.

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

𑀅𑀢𑁆𑀢𑀸𑀯 ¶ 𑀲𑁂𑀬𑁆𑀬𑁄 𑀧𑀭𑀫𑀸 𑀘 [𑀧𑀭𑀫𑀸𑀯 (𑀩𑀳𑀽𑀲𑀼) 𑀚𑀸. 𑁧.𑁬.𑁮𑁧 𑀲𑀁𑀲𑀦𑁆𑀤𑁂𑀢𑀩𑁆𑀩𑀁] 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀮𑀩𑁆𑀪𑀸 𑀧𑀺𑀬𑀸 𑀑𑀘𑀺𑀢𑀢𑁆𑀣𑁂𑀦 [𑀑𑀘𑀺𑀢𑀢𑁆𑀢𑁂𑀦 (𑀓.)] 𑀧𑀘𑁆𑀙𑀸’’.

𑁪𑁬𑁨.

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

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

𑁪𑁬𑁩.

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

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

𑁪𑁬𑁪.

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

𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁄𑀯 𑀧𑀺𑀢𑁆𑀯𑀸𑀦 𑀬𑀣𑁄𑀲𑀥𑀸𑀦𑀺, 𑀢𑁂𑀦𑁂𑀯 𑀲𑁄 𑀳𑁄𑀢𑀺 𑀲𑀼𑀔𑀻 𑀧𑀭𑀢𑁆𑀣’’.

𑁪𑁬𑁫.

‘‘𑀑𑀳𑀸𑀬𑀳𑀁 𑀧𑀺𑀢𑀭𑀁 𑀫𑀸𑀢𑀭𑀜𑁆𑀘, 𑀫𑀦𑀸𑀧𑀺𑀬𑁂 𑀓𑀸𑀫𑀕𑀼𑀡𑁂 𑀘 [𑀓𑀸𑀫𑀕𑀼𑀡𑁂𑀧𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀧𑀜𑁆𑀘;

𑀏𑀢𑀲𑁆𑀲 𑀳𑁂𑀢𑀼𑀫𑁆𑀳𑀺 𑀯𑀦𑀁 𑀧𑀯𑀺𑀝𑁆𑀞𑁄, 𑀢𑀁 𑀢𑁂 𑀯𑀭𑀁 𑀓𑀺𑀦𑁆𑀢𑀺 𑀫𑀳𑀁 𑀤𑀤𑀸𑀫𑀺’’.

𑁪𑁬𑁬.

‘‘𑀦 𑀧𑀡𑁆𑀟𑀺𑀢𑀸 𑀤𑀺𑀕𑀼𑀡𑀫𑀸𑀳𑀼 𑀯𑀸𑀓𑁆𑀬𑀁, 𑀲𑀘𑁆𑀘𑀧𑁆𑀧𑀝𑀺𑀜𑁆𑀜𑀸𑀯 𑀪𑀯𑀦𑁆𑀢𑀺 𑀲𑀦𑁆𑀢𑁄;

𑀯𑀭𑀲𑁆𑀲𑀼 𑀲𑀫𑁆𑀫 𑀇𑀢𑀺 𑀫𑀁 𑀅𑀯𑁄𑀘, 𑀇𑀘𑁆𑀘𑀩𑁆𑀭𑀯𑀻 𑀢𑁆𑀯𑀁 𑀦 𑀳𑀺 𑀢𑁂 𑀲𑀫𑁂𑀢𑀺’’.

𑁪𑁬𑁭.

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

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

𑁪𑁬𑁮.

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

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

𑁪𑁬𑁯.

‘‘𑀧𑀸𑀡𑀁 𑀘𑀚𑀦𑁆𑀢𑀺 𑀲𑀦𑁆𑀢𑁄 𑀦𑀸𑀧𑀺 𑀥𑀫𑁆𑀫𑀁, 𑀲𑀘𑁆𑀘𑀧𑁆𑀧𑀝𑀺𑀜𑁆𑀜𑀸𑀯 𑀪𑀯𑀦𑁆𑀢𑀺 𑀲𑀦𑁆𑀢𑁄;

𑀤𑀢𑁆𑀯𑀸 𑀯𑀭𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑀯𑀸𑀓𑀭𑁄𑀳𑀺, 𑀏𑀢𑁂𑀦 𑀲𑀫𑁆𑀧𑀚𑁆𑀚 𑀲𑀼𑀭𑀸𑀚𑀲𑁂𑀝𑁆𑀞.

𑁪𑁭𑁦.

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

𑀅𑀗𑁆𑀕𑀁 𑀥𑀦𑀁 𑀚𑀻𑀯𑀺𑀢𑀜𑁆𑀘𑀸𑀧𑀺 𑀲𑀩𑁆𑀩𑀁, 𑀘𑀚𑁂 𑀦𑀭𑁄 𑀥𑀫𑁆𑀫𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀦𑁆𑀢𑁄’’.

𑁪𑁭𑁧.

‘‘𑀬𑀲𑁆𑀫𑀸 𑀳𑀺 𑀥𑀫𑁆𑀫𑀁 𑀧𑀼𑀭𑀺𑀲𑁄 𑀯𑀺𑀚𑀜𑁆𑀜𑀸, 𑀬𑁂 𑀘𑀲𑁆𑀲 𑀓𑀗𑁆𑀔𑀁 𑀯𑀺𑀦𑀬𑀦𑁆𑀢𑀺 𑀲𑀦𑁆𑀢𑁄;

𑀢𑀁 𑀳𑀺𑀲𑁆𑀲 𑀤𑀻𑀧𑀜𑁆𑀘 𑀧𑀭𑀸𑀬𑀡𑀜𑁆𑀘, 𑀦 ¶ 𑀢𑁂𑀦 𑀫𑀺𑀢𑁆𑀢𑀺𑀁 𑀚𑀺𑀭𑀬𑁂𑀣 [𑀚𑀭𑀬𑁂𑀣 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀜𑁆𑀜𑁄.

𑁪𑁭𑁨.

‘‘𑀅𑀤𑁆𑀥𑀸 𑀳𑀺 𑀲𑁄 𑀪𑀓𑁆𑀔𑁄 𑀫𑀫 𑀫𑀦𑀸𑀧𑁄, 𑀏𑀢𑀲𑁆𑀲 𑀳𑁂𑀢𑀼𑀫𑁆𑀳𑀺 𑀯𑀦𑀁 𑀧𑀯𑀺𑀝𑁆𑀞𑁄;

𑀲𑀘𑁂 𑀘 𑀫𑀁 𑀬𑀸𑀘𑀲𑀺 𑀏𑀢𑀫𑀢𑁆𑀣𑀁, 𑀏𑀢𑀫𑁆𑀧𑀺 𑀢𑁂 𑀲𑀫𑁆𑀫 𑀯𑀭𑀁 𑀤𑀤𑀸𑀫𑀺.

𑁪𑁭𑁩.

‘‘𑀲𑀢𑁆𑀣𑀸 𑀘 𑀫𑁂 𑀳𑁄𑀲𑀺 𑀲𑀔𑀸 𑀘 𑀫𑁂𑀲𑀺, 𑀯𑀘𑀦𑀫𑁆𑀧𑀺 𑀢𑁂 𑀲𑀫𑁆𑀫 𑀅𑀳𑀁 𑀅𑀓𑀸𑀲𑀺𑀁;

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

𑁪𑁭𑁪.

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

𑀅𑀳𑀫𑁆𑀧𑀺 𑀢𑁂 𑀲𑀫𑁆𑀫 𑀓𑀭𑁄𑀫𑀺 𑀯𑀸𑀓𑁆𑀬𑀁, 𑀉𑀪𑁄𑀧𑀺 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀧𑀫𑁄𑀘𑀬𑀸𑀫’’.

𑁪𑁭𑁫.

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

𑀦 𑀚𑀸𑀢𑀼 𑀤𑀼𑀩𑁆𑀪𑁂𑀣 𑀇𑀫𑀲𑁆𑀲 𑀭𑀜𑁆𑀜𑁄, 𑀲𑀘𑁆𑀘𑀧𑁆𑀧𑀝𑀺𑀜𑁆𑀜𑀁 ¶ 𑀫𑁂 𑀧𑀝𑀺𑀲𑁆𑀲𑀼𑀡𑀸𑀣’’.

𑁪𑁭𑁬.

‘‘𑀓𑀫𑁆𑀫𑀸𑀲𑀧𑀸𑀤𑁂𑀦 𑀯𑀺𑀳𑁂𑀞𑀺𑀢𑀫𑁆𑀳𑀸, 𑀢𑀮𑀸𑀯𑀼𑀢𑀸 𑀅𑀲𑁆𑀲𑀼𑀫𑀼𑀔𑀸 𑀭𑀼𑀤𑀦𑁆𑀢𑀸;

𑀦 𑀚𑀸𑀢𑀼 𑀤𑀼𑀩𑁆𑀪𑁂𑀫 𑀇𑀫𑀲𑁆𑀲 𑀭𑀜𑁆𑀜𑁄, 𑀲𑀘𑁆𑀘𑀧𑁆𑀧𑀝𑀺𑀜𑁆𑀜𑀁 𑀢𑁂 𑀧𑀝𑀺𑀲𑁆𑀲𑀼𑀡𑀸𑀫’’.

𑁪𑁭𑁭.

‘‘𑀬𑀣𑀸 𑀧𑀺𑀢𑀸 𑀯𑀸 𑀅𑀣 𑀯𑀸𑀧𑀺 𑀫𑀸𑀢𑀸, 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀸 𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑀸 𑀧𑀚𑀸𑀦𑀁;

𑀏𑀯𑀫𑁂𑀯 𑀯𑁄 [𑀏𑀯𑀫𑁂𑀯 (𑀲𑀻.), 𑀏𑀯𑀫𑁆𑀧𑀺 𑀯𑁄 (𑀲𑁆𑀬𑀸.)] 𑀳𑁄𑀢𑀼 𑀅𑀬𑀜𑁆𑀘 𑀭𑀸𑀚𑀸, 𑀢𑀼𑀫𑁆𑀳𑁂 𑀘 𑀯𑁄 𑀳𑁄𑀣 𑀬𑀣𑁂𑀯 𑀧𑀼𑀢𑁆𑀢𑀸’’.

𑁪𑁭𑁮.

‘‘𑀬𑀣𑀸 𑀧𑀺𑀢𑀸 𑀯𑀸 𑀅𑀣 𑀯𑀸𑀧𑀺 𑀫𑀸𑀢𑀸, 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀸 𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑀸 𑀧𑀚𑀸𑀦𑀁;

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

𑁪𑁭𑁯.

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

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

𑁪𑁮𑁦.

‘‘𑀢𑀸 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀯𑀮𑁆𑀮𑀺𑀯𑀺𑀮𑀸𑀓𑀫𑀚𑁆𑀛𑀸, 𑀅𑀮𑀗𑁆𑀓𑀢𑀸 𑀲𑀫𑁆𑀧𑀭𑀺𑀯𑀸𑀭𑀬𑀺𑀢𑁆𑀯𑀸;

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

𑁪𑁮𑁧.

‘‘𑀢𑀫𑁆𑀩𑀽𑀧𑀥𑀸𑀦𑁂 𑀩𑀳𑀼𑀕𑁄𑀡𑀓𑀫𑁆𑀳𑀺, 𑀲𑀼𑀪𑀫𑁆𑀳𑀺 [𑀲𑀼𑀘𑀺𑀫𑁆𑀳𑀺 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀩𑁆𑀩𑀲𑁆𑀲𑀬𑀦𑀫𑁆𑀳𑀺 𑀲𑀗𑁆𑀕𑁂 [𑀲𑀜𑁆𑀜𑀢𑁂 (𑀲𑀻. 𑀧𑀻.), 𑀮𑀗𑁆𑀕𑀢𑁂 (𑀲𑁆𑀬𑀸.)];

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

𑁪𑁮𑁨.

‘‘𑀧𑀸𑀡𑀺𑀲𑁆𑀲𑀭𑀁 ¶ 𑀓𑀼𑀫𑁆𑀪𑀣𑀽𑀡𑀁 𑀦𑀺𑀲𑀻𑀣𑁂, 𑀅𑀣𑁄𑀧𑀺 𑀯𑁂 𑀦𑀺𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀫𑁆𑀧𑀺 𑀢𑀽𑀭𑀺𑀬𑀁;

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

𑁪𑁮𑁩.

‘‘𑀉𑀬𑁆𑀬𑀸𑀦𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁 𑀧𑀳𑀽𑀢𑀫𑀸𑀮𑁆𑀬𑀁, 𑀫𑀺𑀕𑀸𑀚𑀺𑀦𑀽𑀧𑁂𑀢𑀧𑀼𑀭𑀁 [𑀫𑀺𑀕𑀸𑀘𑀺𑀭𑀽𑀧𑁂𑀢𑀧𑀼𑀭𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀲𑀼𑀭𑀫𑁆𑀫𑀁;

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

𑁪𑁮𑁪.

‘‘𑀓𑀸𑀴𑀧𑀓𑁆𑀔𑁂 𑀬𑀣𑀸 𑀘𑀦𑁆𑀤𑁄, 𑀳𑀸𑀬𑀢𑁂𑀯 𑀲𑀼𑀯𑁂 𑀲𑀼𑀯𑁂;

𑀓𑀸𑀴𑀧𑀓𑁆𑀔𑀽𑀧𑀫𑁄 𑀭𑀸𑀚, 𑀅𑀲𑀢𑀁 𑀳𑁄𑀢𑀺 𑀲𑀫𑀸𑀕𑀫𑁄.

𑁪𑁮𑁫.

‘‘𑀬𑀣𑀸𑀳𑀁 [𑀬𑀣𑀸 (𑀲𑀻.)] 𑀭𑀲𑀓𑀫𑀸𑀕𑀫𑁆𑀫, 𑀲𑀽𑀤𑀁 𑀓𑀸𑀧𑀼𑀭𑀺𑀲𑀸𑀥𑀫𑀁 [𑀲𑀽𑀤𑀓𑀁 𑀧𑀼𑀭𑀺𑀲𑀸𑀥𑀫𑀁 (𑀲𑀻. 𑀧𑀻.)];

𑀅𑀓𑀸𑀲𑀺𑀁 𑀧𑀸𑀧𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀬𑁂𑀦 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

𑁪𑁮𑁬.

‘‘𑀲𑀼𑀓𑁆𑀓𑀧𑀓𑁆𑀔𑁂 𑀬𑀣𑀸 𑀘𑀦𑁆𑀤𑁄, 𑀯𑀟𑁆𑀠𑀢𑁂𑀯 𑀲𑀼𑀯𑁂 𑀲𑀼𑀯𑁂;

𑀲𑀼𑀓𑁆𑀓𑀧𑀓𑁆𑀔𑀽𑀧𑀫𑁄 𑀭𑀸𑀚, 𑀲𑀢𑀁 𑀳𑁄𑀢𑀺 𑀲𑀫𑀸𑀕𑀫𑁄.

𑁪𑁮𑁭.

‘‘𑀬𑀣𑀸𑀳𑀁 𑀢𑀼𑀯𑀫𑀸𑀕𑀫𑁆𑀫, 𑀲𑀼𑀢𑀲𑁄𑀫 𑀯𑀺𑀚𑀸𑀦𑀳𑀺;

𑀓𑀸𑀳𑀸𑀫𑀺 𑀓𑀼𑀲𑀮𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀬𑁂𑀦 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀲𑀼𑀕𑁆𑀕𑀢𑀺𑀁.

𑁪𑁮𑁮.

‘‘𑀣𑀮𑁂 𑀬𑀣𑀸 𑀯𑀸𑀭𑀺 𑀚𑀦𑀺𑀦𑁆𑀤 𑀯𑀼𑀝𑁆𑀞𑀁 [𑀯𑀝𑁆𑀝𑀁 (𑀲𑀻. 𑀧𑀻.)], 𑀅𑀦𑀤𑁆𑀥𑀦𑁂𑀬𑁆𑀬𑀁 𑀦 𑀘𑀺𑀭𑀝𑁆𑀞𑀺𑀢𑀻𑀓𑀁;

𑀏𑀯𑀫𑁆𑀧𑀺 ¶ 𑀳𑁄𑀢𑀺 𑀅𑀲𑀢𑀁 𑀲𑀫𑀸𑀕𑀫𑁄, 𑀅𑀦𑀤𑁆𑀥𑀦𑁂𑀬𑁆𑀬𑁄 𑀉𑀤𑀓𑀁 𑀣𑀮𑁂𑀯.

𑁪𑁮𑁯.

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

𑀏𑀯𑀫𑁆𑀧𑀺 𑀯𑁂 [𑀏𑀯𑀫𑁆𑀧𑀺 𑀫𑁂 (𑀲𑁆𑀬𑀸.), 𑀏𑀯𑀫𑁆𑀧𑀺 𑀘𑁂 (𑀧𑀻. 𑀓.)] 𑀳𑁄𑀢𑀺 𑀲𑀢𑀁 𑀲𑀫𑀸𑀕𑀫𑁄, 𑀘𑀺𑀭𑀝𑁆𑀞𑀺𑀢𑀻𑀓𑁄 [𑀘𑀺𑀭𑀝𑁆𑀞𑀺𑀢𑀺𑀓𑀁 (𑀓.)] 𑀉𑀤𑀓𑀁 𑀲𑀭𑁂𑀯.

𑁪𑁯𑁦.

‘‘𑀅𑀩𑁆𑀬𑀸𑀬𑀺𑀓𑁄 ¶ ¶ 𑀳𑁄𑀢𑀺 𑀲𑀢𑀁 𑀲𑀫𑀸𑀕𑀫𑁄, 𑀬𑀸𑀯𑀫𑁆𑀧𑀺 𑀢𑀺𑀝𑁆𑀞𑁂𑀬𑁆𑀬 𑀢𑀣𑁂𑀯 𑀳𑁄𑀢𑀺;

𑀔𑀺𑀧𑁆𑀧𑀜𑁆𑀳𑀺 𑀯𑁂𑀢𑀺 𑀅𑀲𑀢𑀁 𑀲𑀫𑀸𑀕𑀫𑁄, 𑀢𑀲𑁆𑀫𑀸 𑀲𑀢𑀁 𑀥𑀫𑁆𑀫𑁄 𑀅𑀲𑀩𑁆𑀪𑀺 𑀆𑀭𑀓𑀸’’.

𑁪𑁯𑁧.

‘‘𑀦 𑀲𑁄 𑀭𑀸𑀚𑀸 𑀬𑁄 [𑀭𑀸𑀚𑀸 𑀦 𑀲𑁄 𑀬𑁄 (𑀓.)] 𑀅𑀚𑁂𑀬𑁆𑀬𑀁 𑀚𑀺𑀦𑀸𑀢𑀺, 𑀦 𑀲𑁄 𑀲𑀔𑀸 𑀬𑁄 𑀲𑀔𑀸𑀭𑀁 𑀚𑀺𑀦𑀸𑀢𑀺;

𑀦 𑀲𑀸 𑀪𑀭𑀺𑀬𑀸 𑀬𑀸 𑀧𑀢𑀺𑀦𑁄 𑀦 𑀯𑀺𑀪𑁂𑀢𑀺, 𑀦 𑀢𑁂 𑀧𑀼𑀢𑁆𑀢𑀸 [𑀧𑀼𑀢𑁆𑀢𑀸 𑀦 𑀢𑁂 (𑀓.)] 𑀬𑁂 𑀦 𑀪𑀭𑀦𑁆𑀢𑀺 𑀚𑀺𑀡𑁆𑀡𑀁.

𑁪𑁯𑁨.

‘‘𑀦 𑀲𑀸 𑀲𑀪𑀸 𑀬𑀢𑁆𑀣 𑀦 𑀲𑀦𑁆𑀢𑀺 𑀲𑀦𑁆𑀢𑁄, 𑀦 𑀢𑁂 𑀲𑀦𑁆𑀢𑁄 [𑀲𑀦𑁆𑀢𑁄 𑀦 𑀢𑁂 (𑀓.)] 𑀬𑁂 𑀦 𑀪𑀡𑀦𑁆𑀢𑀺 𑀥𑀫𑁆𑀫𑀁;

𑀭𑀸𑀕𑀜𑁆𑀘 𑀤𑁄𑀲𑀜𑁆𑀘 𑀧𑀳𑀸𑀬 𑀫𑁄𑀳𑀁, 𑀥𑀫𑁆𑀫𑀁 𑀪𑀡𑀦𑁆𑀢𑀸𑀯 𑀪𑀯𑀦𑁆𑀢𑀺 𑀲𑀦𑁆𑀢𑁄.

𑁪𑁯𑁩.

‘‘𑀦𑀸𑀪𑀸𑀲𑀫𑀸𑀦𑀁 𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀫𑀺𑀲𑁆𑀲𑀁 𑀩𑀸𑀮𑁂𑀳𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑀁;

𑀪𑀸𑀲𑀫𑀸𑀦𑀜𑁆𑀘 𑀚𑀸𑀦𑀦𑁆𑀢𑀺, 𑀤𑁂𑀲𑁂𑀦𑁆𑀢𑀁 𑀅𑀫𑀢𑀁 𑀧𑀤𑀁.

𑁪𑁯𑁪.

‘‘𑀪𑀸𑀲𑀬𑁂 ¶ 𑀚𑁄𑀢𑀬𑁂 𑀥𑀫𑁆𑀫𑀁, 𑀧𑀕𑁆𑀕𑀡𑁆𑀳𑁂 𑀇𑀲𑀺𑀦𑀁 𑀥𑀚𑀁;

𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀤𑁆𑀥𑀚𑀸 𑀇𑀲𑀬𑁄, 𑀥𑀫𑁆𑀫𑁄 𑀳𑀺 𑀇𑀲𑀺𑀦𑀁 𑀥𑀚𑁄’’𑀢𑀺.

𑀫𑀳𑀸𑀲𑀼𑀢𑀲𑁄𑀫𑀚𑀸𑀢𑀓𑀁 𑀧𑀜𑁆𑀘𑀫𑀁.

𑀅𑀲𑀻𑀢𑀺𑀦𑀺𑀧𑀸𑀢𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀢𑀲𑁆𑀲𑀼𑀤𑁆𑀤𑀸𑀦𑀁 𑁋

𑀲𑀼𑀫𑀼𑀔𑁄 𑀧𑀦 𑀳𑀁𑀲𑀯𑀭𑁄 𑀘 𑀫𑀳𑀸, 𑀲𑀼𑀥𑀪𑁄𑀚𑀦𑀺𑀓𑁄 𑀘 𑀧𑀭𑁄 𑀧𑀯𑀭𑁄;

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

𑁨𑁨. 𑀫𑀳𑀸𑀦𑀺𑀧𑀸𑀢𑁄

𑁫𑁩𑁮. 𑀫𑀽𑀕𑀧𑀓𑁆𑀔𑀚𑀸𑀢𑀓𑀁 (𑁧)

𑁧.

‘‘𑀫𑀸 ¶ ¶ ¶ 𑀧𑀡𑁆𑀟𑀺𑀘𑁆𑀘𑀬𑀁 [𑀧𑀡𑁆𑀟𑀺𑀢𑀺𑀬𑀁 (𑀲𑀻.), 𑀧𑀡𑁆𑀟𑀺𑀘𑁆𑀘𑀺𑀬𑀁 (𑀧𑀻.)] 𑀯𑀺𑀪𑀸𑀯𑀬, 𑀩𑀸𑀮𑀫𑀢𑁄 𑀪𑀯 𑀲𑀩𑁆𑀩𑀧𑀸𑀡𑀺𑀦𑀁;

𑀲𑀩𑁆𑀩𑁄 𑀢𑀁 𑀚𑀦𑁄 𑀑𑀘𑀺𑀦𑀸𑀬𑀢𑀼, 𑀏𑀯𑀁 𑀢𑀯 𑀅𑀢𑁆𑀣𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺’’.

𑁨.

‘‘𑀓𑀭𑁄𑀫𑀺 𑀢𑁂 𑀢𑀁 𑀯𑀘𑀦𑀁, 𑀬𑀁 𑀫𑀁 𑀪𑀡𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑀸𑀲𑀺 𑀫𑁂 𑀅𑀫𑁆𑀫, 𑀳𑀺𑀢𑀓𑀸𑀫𑀸𑀲𑀺 𑀤𑁂𑀯𑀢𑁂’’.

𑁩.

‘‘𑀓𑀺𑀁 𑀦𑀼 𑀲𑀦𑁆𑀢𑀭𑀫𑀸𑀦𑁄𑀯, 𑀓𑀸𑀲𑀼𑀁 𑀔𑀡𑀲𑀺 𑀲𑀸𑀭𑀣𑀺;

𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑁂 𑀲𑀫𑁆𑀫 𑀅𑀓𑁆𑀔𑀸𑀳𑀺, 𑀓𑀺𑀁 𑀓𑀸𑀲𑀼𑀬𑀸 𑀓𑀭𑀺𑀲𑁆𑀲𑀲𑀺’’.

𑁪.

‘‘𑀭𑀜𑁆𑀜𑁄 𑀫𑀽𑀕𑁄 𑀘 𑀧𑀓𑁆𑀔𑁄 𑀘, 𑀧𑀼𑀢𑁆𑀢𑁄 𑀚𑀸𑀢𑁄 𑀅𑀘𑁂𑀢𑀲𑁄;

𑀲𑁄𑀫𑁆𑀳𑀺 𑀭𑀜𑁆𑀜𑀸 𑀲𑀫𑀚𑁆𑀛𑀺𑀝𑁆𑀞𑁄, 𑀧𑀼𑀢𑁆𑀢𑀁 𑀫𑁂 𑀦𑀺𑀔𑀡𑀁 𑀯𑀦𑁂’’.

𑁫.

‘‘𑀦 𑀩𑀥𑀺𑀭𑁄 𑀦 𑀫𑀽𑀕𑁄𑀲𑁆𑀫𑀺, 𑀦 𑀧𑀓𑁆𑀔𑁄 𑀦 𑀘 𑀯𑀻𑀓𑀮𑁄 [𑀦𑀧𑀺 𑀧𑀗𑁆𑀕𑀼𑀮𑁄 (𑀲𑀻. 𑀧𑀻.), 𑀦 𑀘 𑀧𑀺𑀗𑁆𑀕𑀮𑁄 (𑀲𑁆𑀬𑀸.)];

𑀅𑀥𑀫𑁆𑀫𑀁 𑀲𑀸𑀭𑀣𑀺 𑀓𑀬𑀺𑀭𑀸, 𑀫𑀁 𑀘𑁂 𑀢𑁆𑀯𑀁 𑀦𑀺𑀔𑀡𑀁 𑀯𑀦𑁂’’.

𑁬.

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

𑀅𑀥𑀫𑁆𑀫𑀁 𑀲𑀸𑀭𑀣𑀺 𑀓𑀬𑀺𑀭𑀸, 𑀫𑀁 𑀘𑁂 𑀢𑁆𑀯𑀁 𑀦𑀺𑀔𑀡𑀁 𑀯𑀦𑁂’’.