📜

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

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

𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼𑀧𑀸𑀴𑀺

𑁧. 𑀉𑀭𑀕𑀯𑀕𑁆𑀕𑁄

𑁧. 𑀔𑁂𑀢𑁆𑀢𑀽𑀧𑀫𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁧.

‘‘𑀔𑁂𑀢𑁆𑀢𑀽𑀧𑀫𑀸 ¶ ¶ ¶ ¶ 𑀅𑀭𑀳𑀦𑁆𑀢𑁄, 𑀤𑀸𑀬𑀓𑀸 𑀓𑀲𑁆𑀲𑀓𑀽𑀧𑀫𑀸;

𑀩𑀻𑀚𑀽𑀧𑀫𑀁 𑀤𑁂𑀬𑁆𑀬𑀥𑀫𑁆𑀫𑀁, 𑀏𑀢𑁆𑀢𑁄 𑀦𑀺𑀩𑁆𑀩𑀢𑁆𑀢𑀢𑁂 𑀨𑀮𑀁.

𑁨.

‘‘𑀏𑀢𑀁 𑀩𑀻𑀚𑀁 𑀓𑀲𑀺 𑀔𑁂𑀢𑁆𑀢𑀁, 𑀧𑁂𑀢𑀸𑀦𑀁 𑀤𑀸𑀬𑀓𑀲𑁆𑀲 𑀘;

𑀢𑀁 𑀧𑁂𑀢𑀸 𑀧𑀭𑀺𑀪𑀼𑀜𑁆𑀚𑀦𑁆𑀢𑀺, 𑀤𑀸𑀢𑀸 𑀧𑀼𑀜𑁆𑀜𑁂𑀦 𑀯𑀟𑁆𑀠𑀢𑀺.

𑁩.

‘‘𑀇𑀥𑁂𑀯 ¶ 𑀓𑀼𑀲𑀮𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀧𑁂𑀢𑁂 𑀘 𑀧𑀝𑀺𑀧𑀽𑀚𑀺𑀬;

𑀲𑀕𑁆𑀕𑀜𑁆𑀘 𑀓𑀫𑀢𑀺 [𑀕𑀫𑀢𑀺 (𑀓.)] 𑀝𑁆𑀞𑀸𑀦𑀁, 𑀓𑀫𑁆𑀫𑀁 𑀓𑀢𑁆𑀯𑀸𑀦 𑀪𑀤𑁆𑀤𑀓’’𑀦𑁆𑀢𑀺.

𑀔𑁂𑀢𑁆𑀢𑀽𑀧𑀫𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀧𑀞𑀫𑀁.

𑁨. 𑀲𑀽𑀓𑀭𑀫𑀼𑀔𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪.

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

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

𑁫.

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

𑀢𑁂𑀦 𑀫𑁂𑀢𑀸𑀤𑀺𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀬𑀣𑀸 𑀧𑀲𑁆𑀲𑀲𑀺 𑀦𑀸𑀭𑀤.

𑁬.

‘‘𑀢𑀁 ¶ 𑀢𑁆𑀬𑀸𑀳𑀁 [𑀢𑀸𑀳𑀁 (𑀓.)] 𑀦𑀸𑀭𑀤 𑀩𑁆𑀭𑀽𑀫𑀺, 𑀲𑀸𑀫𑀁 𑀤𑀺𑀝𑁆𑀞𑀫𑀺𑀤𑀁 𑀢𑀬𑀸;

𑀫𑀸𑀓𑀸𑀲𑀺 ¶ 𑀫𑀼𑀔𑀲𑀸 𑀧𑀸𑀧𑀁, 𑀫𑀸 𑀔𑁄 𑀲𑀽𑀓𑀭𑀫𑀼𑀔𑁄 𑀅𑀳𑀽’’𑀢𑀺.

𑀲𑀽𑀓𑀭𑀫𑀼𑀔𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀤𑀼𑀢𑀺𑀬𑀁.

𑁩. 𑀧𑀽𑀢𑀺𑀫𑀼𑀔𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭.

‘‘𑀤𑀺𑀩𑁆𑀩𑀁 𑀲𑀼𑀪𑀁 𑀥𑀸𑀭𑁂𑀲𑀺 𑀯𑀡𑁆𑀡𑀥𑀸𑀢𑀼𑀁, 𑀯𑁂𑀳𑀸𑀬𑀲𑀁 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂;

𑀫𑀼𑀔𑀜𑁆𑀘 𑀢𑁂 𑀓𑀺𑀫𑀬𑁄 𑀧𑀽𑀢𑀺𑀕𑀦𑁆𑀥𑀁, 𑀔𑀸𑀤𑀦𑁆𑀢𑀺 𑀓𑀺𑀁 𑀓𑀫𑁆𑀫𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀩𑁆𑀩𑁂’’.

𑁮.

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

𑀮𑀤𑁆𑀥𑀸 𑀘 𑀫𑁂 𑀢𑀧𑀲𑀸 𑀯𑀡𑁆𑀡𑀥𑀸𑀢𑀼, 𑀫𑀼𑀔𑀜𑁆𑀘 𑀫𑁂 𑀧𑁂𑀲𑀼𑀡𑀺𑀬𑁂𑀦 𑀧𑀽𑀢𑀺.

𑁯.

‘‘𑀢𑀬𑀺𑀤𑀁 𑀢𑀬𑀸 𑀦𑀸𑀭𑀤 𑀲𑀸𑀫𑀁 𑀤𑀺𑀝𑁆𑀞𑀁,

𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀸 𑀬𑁂 𑀓𑀼𑀲𑀮𑀸 𑀯𑀤𑁂𑀬𑁆𑀬𑀼𑀁;

‘𑀫𑀸 𑀧𑁂𑀲𑀼𑀡𑀁 𑀫𑀸 𑀘 𑀫𑀼𑀲𑀸 𑀅𑀪𑀸𑀡𑀺,

𑀬𑀓𑁆𑀔𑁄 𑀢𑀼𑀯𑀁 𑀳𑁄𑀳𑀺𑀲𑀺 𑀓𑀸𑀫𑀓𑀸𑀫𑀻’’’𑀢𑀺.

𑀧𑀽𑀢𑀺𑀫𑀼𑀔𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀢𑀢𑀺𑀬𑀁.

𑁪. 𑀧𑀺𑀝𑁆𑀞𑀥𑀻𑀢𑀮𑀺𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁧𑁦.

‘‘𑀬𑀁 ¶ ¶ 𑀓𑀺𑀜𑁆𑀘𑀸𑀭𑀫𑁆𑀫𑀡𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀤𑀚𑁆𑀚𑀸 𑀤𑀸𑀦𑀁 𑀅𑀫𑀘𑁆𑀙𑀭𑀻;

𑀧𑀼𑀩𑁆𑀩𑀧𑁂𑀢𑁂 𑀘 𑀆𑀭𑀩𑁆𑀪, 𑀅𑀣 𑀯𑀸 𑀯𑀢𑁆𑀣𑀼𑀤𑁂𑀯𑀢𑀸.

𑁧𑁧.

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

𑀓𑀼𑀯𑁂𑀭𑀁 𑀥𑀢𑀭𑀝𑁆𑀞𑀜𑁆𑀘, 𑀯𑀺𑀭𑀽𑀧𑀓𑁆𑀔𑀁 𑀯𑀺𑀭𑀽𑀴𑁆𑀳𑀓𑀁;

𑀢𑁂 ¶ 𑀘𑁂𑀯 𑀧𑀽𑀚𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀺, 𑀤𑀸𑀬𑀓𑀸 𑀘 𑀅𑀦𑀺𑀧𑁆𑀨𑀮𑀸.

𑁧𑁨.

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

𑀦 𑀢𑀁 𑀧𑁂𑀢𑀲𑁆𑀲 𑀅𑀢𑁆𑀣𑀸𑀬, 𑀏𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺 𑀜𑀸𑀢𑀬𑁄.

𑁧𑁩.

‘‘𑀅𑀬𑀜𑁆𑀘 𑀔𑁄 𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀤𑀺𑀦𑁆𑀦𑀸, 𑀲𑀗𑁆𑀖𑀫𑁆𑀳𑀺 𑀲𑀼𑀧𑁆𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸;

𑀤𑀻𑀖𑀭𑀢𑁆𑀢𑀁 𑀳𑀺𑀢𑀸𑀬𑀲𑁆𑀲, 𑀞𑀸𑀦𑀲𑁄 𑀉𑀧𑀓𑀧𑁆𑀧𑀢𑀻’’𑀢𑀺.

𑀧𑀺𑀝𑁆𑀞𑀥𑀻𑀢𑀮𑀺𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

𑁫. 𑀢𑀺𑀭𑁄𑀓𑀼𑀝𑁆𑀝𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁧𑁪.

[𑀔𑀼. 𑀧𑀸. 𑁭.𑁧 𑀔𑀼𑀤𑁆𑀤𑀓𑀧𑀸𑀞𑁂] ‘‘𑀢𑀺𑀭𑁄𑀓𑀼𑀝𑁆𑀝𑁂𑀲𑀼 [𑀢𑀺𑀭𑁄𑀓𑀼𑀟𑁆𑀟𑁂𑀲𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺, 𑀲𑀦𑁆𑀥𑀺𑀲𑀺𑀗𑁆𑀖𑀸𑀝𑀓𑁂𑀲𑀼 𑀘;

𑀤𑁆𑀯𑀸𑀭𑀩𑀸𑀳𑀸𑀲𑀼 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺, 𑀆𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀲𑀓𑀁 𑀖𑀭𑀁.

𑁧𑁫.

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

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

𑁧𑁬.

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

𑀲𑀼𑀘𑀺𑀁 𑀧𑀡𑀻𑀢𑀁 𑀓𑀸𑀮𑁂𑀦, 𑀓𑀧𑁆𑀧𑀺𑀬𑀁 𑀧𑀸𑀦𑀪𑁄𑀚𑀦𑀁;

‘𑀇𑀤𑀁 𑀯𑁄 𑀜𑀸𑀢𑀻𑀦𑀁 𑀳𑁄𑀢𑀼, 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀼 𑀜𑀸𑀢𑀬𑁄’.

𑁧𑁭.

‘‘𑀢𑁂 𑀘 𑀢𑀢𑁆𑀣 𑀲𑀫𑀸𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀜𑀸𑀢𑀺𑀧𑁂𑀢𑀸 𑀲𑀫𑀸𑀕𑀢𑀸;

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

𑁧𑁮.

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

𑀅𑀫𑁆𑀳𑀸𑀓𑀜𑁆𑀘 𑀓𑀢𑀸 𑀧𑀽𑀚𑀸, 𑀤𑀸𑀬𑀓𑀸 𑀘 𑀅𑀦𑀺𑀧𑁆𑀨𑀮𑀸’.

𑁧𑁯.

‘‘‘𑀦 𑀳𑀺 𑀢𑀢𑁆𑀣 𑀓𑀲𑀺 𑀅𑀢𑁆𑀣𑀺, 𑀕𑁄𑀭𑀓𑁆𑀔𑁂𑀢𑁆𑀣 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺;

𑀯𑀡𑀺𑀚𑁆𑀚𑀸 𑀢𑀸𑀤𑀺𑀲𑀻 𑀦𑀢𑁆𑀣𑀺, 𑀳𑀺𑀭𑀜𑁆𑀜𑁂𑀦 𑀓𑀬𑀸𑀓𑀬𑀁 [𑀓𑀬𑁄𑀓𑁆𑀓𑀬𑀁 (𑀲𑀻. 𑀓.) 𑀓𑀬𑁄𑀓𑀬𑀁 (𑀔𑀼. 𑀧𑀸. 𑁭.𑁬)];

𑀇𑀢𑁄 ¶ 𑀤𑀺𑀦𑁆𑀦𑁂𑀦 𑀬𑀸𑀧𑁂𑀦𑁆𑀢𑀺, 𑀧𑁂𑀢𑀸 𑀓𑀸𑀮𑀕𑀢𑀸 [𑀓𑀸𑀮𑀓𑀢𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀢𑀳𑀺𑀁’.

𑁨𑁦.

‘‘‘𑀉𑀦𑁆𑀦𑀫𑁂 ¶ 𑀉𑀤𑀓𑀁 𑀯𑀼𑀝𑁆𑀞𑀁, 𑀬𑀣𑀸 𑀦𑀺𑀦𑁆𑀦𑀁 𑀧𑀯𑀢𑁆𑀢𑀢𑀺;

𑀏𑀯𑀫𑁂𑀯 𑀇𑀢𑁄 𑀤𑀺𑀦𑁆𑀦𑀁, 𑀧𑁂𑀢𑀸𑀦𑀁 𑀉𑀧𑀓𑀧𑁆𑀧𑀢𑀺’.

𑁨𑁧.

‘‘‘𑀬𑀣𑀸 𑀯𑀸𑀭𑀺𑀯𑀳𑀸 𑀧𑀽𑀭𑀸, 𑀧𑀭𑀺𑀧𑀽𑀭𑁂𑀦𑁆𑀢𑀺 𑀲𑀸𑀕𑀭𑀁;

𑀏𑀯𑀫𑁂𑀯 𑀇𑀢𑁄 𑀤𑀺𑀦𑁆𑀦𑀁, 𑀧𑁂𑀢𑀸𑀦𑀁 𑀉𑀧𑀓𑀧𑁆𑀧𑀢𑀺’.

𑁨𑁨.

‘‘‘𑀅𑀤𑀸𑀲𑀺 ¶ 𑀫𑁂 𑀅𑀓𑀸𑀲𑀺 𑀫𑁂, 𑀜𑀸𑀢𑀺 𑀫𑀺𑀢𑁆𑀢𑀸 [𑀜𑀸𑀢𑀺 𑀫𑀺𑀢𑁆𑀢𑁄 (?)] 𑀲𑀔𑀸 𑀘 𑀫𑁂;

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

𑁨𑁩.

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

𑀦 𑀢𑀁 𑀧𑁂𑀢𑀸𑀦𑀫𑀢𑁆𑀣𑀸𑀬, 𑀏𑀯𑀁 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺 𑀜𑀸𑀢𑀬𑁄’.

𑁨𑁪.

‘‘‘𑀅𑀬𑀜𑁆𑀘 𑀔𑁄 𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀤𑀺𑀦𑁆𑀦𑀸, 𑀲𑀗𑁆𑀖𑀫𑁆𑀳𑀺 𑀲𑀼𑀧𑁆𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸;

𑀤𑀻𑀖𑀭𑀢𑁆𑀢𑀁 𑀳𑀺𑀢𑀸𑀬𑀲𑁆𑀲, 𑀞𑀸𑀦𑀲𑁄 𑀉𑀧𑀓𑀧𑁆𑀧𑀢𑀺’.

𑁨𑁫.

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

𑀩𑀮𑀜𑁆𑀘 𑀪𑀺𑀓𑁆𑀔𑀽𑀦𑀫𑀦𑀼𑀧𑁆𑀧𑀤𑀺𑀦𑁆𑀦𑀁, 𑀢𑀼𑀫𑁆𑀳𑁂𑀳𑀺 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀲𑀼𑀢𑀁 𑀅𑀦𑀧𑁆𑀧𑀓’’𑀦𑁆𑀢𑀺.

𑀢𑀺𑀭𑁄𑀓𑀼𑀝𑁆𑀝𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀧𑀜𑁆𑀘𑀫𑀁.

𑁬. 𑀧𑀜𑁆𑀘𑀧𑀼𑀢𑁆𑀢𑀔𑀸𑀤𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁨𑁬.

‘‘𑀦𑀕𑁆𑀕𑀸 ¶ 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀲𑀺, 𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑀸 𑀧𑀽𑀢𑀺 𑀯𑀸𑀬𑀲𑀺;

𑀫𑀓𑁆𑀔𑀺𑀓𑀸𑀳𑀺 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑀸 [𑀫𑀓𑁆𑀔𑀺𑀓𑀸𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑀸 𑀘 (𑀲𑀻.)], 𑀓𑀸 𑀦𑀼 𑀢𑁆𑀯𑀁 𑀇𑀥 𑀢𑀺𑀝𑁆𑀞𑀲𑀻’’𑀢𑀺.

𑁨𑁭.

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

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 ¶ 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸.

𑁨𑁮.

‘‘𑀓𑀸𑀮𑁂𑀦 𑀧𑀜𑁆𑀘 𑀧𑀼𑀢𑁆𑀢𑀸𑀦𑀺, 𑀲𑀸𑀬𑀁 𑀧𑀜𑁆𑀘 𑀧𑀼𑀦𑀸𑀧𑀭𑁂;

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

𑁨𑁯.

‘‘𑀧𑀭𑀺𑀟𑀬𑁆𑀳𑀢𑀺 𑀥𑀽𑀫𑀸𑀬𑀢𑀺, 𑀔𑀼𑀤𑀸𑀬 [𑀔𑀼𑀤𑁆𑀤𑀸𑀬 (𑀓.)] 𑀳𑀤𑀬𑀁 𑀫𑀫;

𑀧𑀸𑀦𑀻𑀬𑀁 𑀦 𑀮𑀪𑁂 𑀧𑀸𑀢𑀼𑀁, 𑀧𑀲𑁆𑀲 𑀫𑀁 𑀩𑁆𑀬𑀲𑀦𑀁 𑀕𑀢’’𑀦𑁆𑀢𑀺.

𑁩𑁦.

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

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

𑁩𑁧.

‘‘𑀲𑀧𑀢𑀻 [𑀲𑀧𑀢𑁆𑀢𑀻 (𑀲𑀻.)] 𑀫𑁂 𑀕𑀩𑁆𑀪𑀺𑀦𑀻 𑀆𑀲𑀺, 𑀢𑀲𑁆𑀲𑀸 𑀧𑀸𑀧𑀁 𑀅𑀘𑁂𑀢𑀬𑀺𑀁;

𑀲𑀸𑀳𑀁 𑀧𑀤𑀼𑀝𑁆𑀞𑀫𑀦𑀲𑀸, 𑀅𑀓𑀭𑀺𑀁 𑀕𑀩𑁆𑀪𑀧𑀸𑀢𑀦𑀁.

𑁩𑁨.

‘‘𑀢𑀲𑁆𑀲𑀸 ¶ ¶ 𑀤𑁆𑀯𑁂𑀫𑀸𑀲𑀺𑀓𑁄 𑀕𑀩𑁆𑀪𑁄, 𑀮𑁄𑀳𑀺𑀢𑀜𑁆𑀜𑁂𑀯 𑀧𑀕𑁆𑀖𑀭𑀺;

𑀢𑀤𑀲𑁆𑀲𑀸 𑀫𑀸𑀢𑀸 𑀓𑀼𑀧𑀺𑀢𑀸, 𑀫𑀬𑁆𑀳𑀁 𑀜𑀸𑀢𑀻 𑀲𑀫𑀸𑀦𑀬𑀺;

𑀲𑀧𑀣𑀜𑁆𑀘 𑀫𑀁 𑀓𑀸𑀭𑁂𑀲𑀺, 𑀧𑀭𑀺𑀪𑀸𑀲𑀸𑀧𑀬𑀻 𑀘 𑀫𑀁.

𑁩𑁩.

‘‘𑀲𑀸𑀳𑀁 𑀖𑁄𑀭𑀜𑁆𑀘 𑀲𑀧𑀣𑀁, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀁 𑀅𑀪𑀸𑀲𑀺𑀲𑀁;

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

𑁩𑁪.

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

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

𑀧𑀜𑁆𑀘𑀧𑀼𑀢𑁆𑀢𑀔𑀸𑀤𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 [𑀧𑀜𑁆𑀘𑀧𑀼𑀢𑁆𑀢𑀔𑀸𑀤𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.) 𑀏𑀯𑀫𑀼𑀧𑀭𑀺𑀧𑀺] 𑀙𑀝𑁆𑀞𑀁.

𑁭. 𑀲𑀢𑁆𑀢𑀧𑀼𑀢𑁆𑀢𑀔𑀸𑀤𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁩𑁫.

‘‘𑀦𑀕𑁆𑀕𑀸 ¶ 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀲𑀺, 𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑀸 𑀧𑀽𑀢𑀺 𑀯𑀸𑀬𑀲𑀺;

𑀫𑀓𑁆𑀔𑀺𑀓𑀸𑀳𑀺 ¶ 𑀧𑀭𑀺𑀓𑀺𑀡𑁆𑀡𑀸, 𑀓𑀸 𑀦𑀼 𑀢𑁆𑀯𑀁 𑀇𑀥 𑀢𑀺𑀝𑁆𑀞𑀲𑀻’’𑀢𑀺.

𑁩𑁬.

‘‘𑀅𑀳𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀧𑁂𑀢𑀻𑀫𑁆𑀳𑀺, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸.

𑁩𑁭.

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

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

𑁩𑁮.

‘‘𑀧𑀭𑀺𑀟𑀬𑁆𑀳𑀢𑀺 𑀥𑀽𑀫𑀸𑀬𑀢𑀺, 𑀔𑀼𑀤𑀸𑀬 𑀳𑀤𑀬𑀁 𑀫𑀫;

𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀺𑀁 𑀦𑀸𑀥𑀺𑀕𑀘𑁆𑀙𑀸𑀫𑀺, 𑀅𑀕𑁆𑀕𑀺𑀤𑀟𑁆𑀠𑀸𑀯 𑀆𑀢𑀧𑁂’’𑀢𑀺.

𑁩𑁯.

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

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

𑁪𑁦.

‘‘𑀅𑀳𑀽 𑀫𑀬𑁆𑀳𑀁 𑀤𑀼𑀯𑁂 𑀧𑀼𑀢𑁆𑀢𑀸, 𑀉𑀪𑁄 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀬𑁄𑀩𑁆𑀩𑀦𑀸;

𑀲𑀸𑀳𑀁 𑀧𑀼𑀢𑁆𑀢𑀩𑀮𑀽𑀧𑁂𑀢𑀸, 𑀲𑀸𑀫𑀺𑀓𑀁 𑀅𑀢𑀺𑀫𑀜𑁆𑀜𑀺𑀲𑀁.

𑁪𑁧.

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

𑀲𑀸 𑀘 𑀕𑀩𑁆𑀪𑀁 𑀅𑀮𑀪𑀺𑀢𑁆𑀣, 𑀢𑀲𑁆𑀲𑀸 𑀧𑀸𑀧𑀁 𑀅𑀘𑁂𑀢𑀬𑀺𑀁.

𑁪𑁨.

‘‘𑀲𑀸𑀳𑀁 ¶ 𑀧𑀤𑀼𑀝𑁆𑀞𑀫𑀦𑀲𑀸, 𑀅𑀓𑀭𑀺𑀁 𑀕𑀩𑁆𑀪𑀧𑀸𑀢𑀦𑀁;

𑀢𑀲𑁆𑀲𑀸 𑀢𑁂𑀫𑀸𑀲𑀺𑀓𑁄 𑀕𑀩𑁆𑀪𑁄, 𑀧𑀼𑀩𑁆𑀩𑀮𑁄𑀳𑀺𑀢𑀓𑁄 [𑀧𑀼𑀩𑁆𑀩𑀮𑁄𑀳𑀺𑀢𑀓𑁄 (𑀓.)] 𑀧𑀢𑀺.

𑁪𑁩.

‘‘𑀢𑀤𑀲𑁆𑀲𑀸 𑀫𑀸𑀢𑀸 𑀓𑀼𑀧𑀺𑀢𑀸, 𑀫𑀬𑁆𑀳𑀁 𑀜𑀸𑀢𑀻 𑀲𑀫𑀸𑀦𑀬𑀺;

𑀲𑀧𑀣𑀜𑁆𑀘 𑀫𑀁 𑀓𑀸𑀭𑁂𑀲𑀺, 𑀧𑀭𑀺𑀪𑀸𑀲𑀸𑀧𑀬𑀻 𑀘 𑀫𑀁.

𑁪𑁪.

‘‘𑀲𑀸𑀳𑀁 ¶ 𑀖𑁄𑀭𑀜𑁆𑀘 𑀲𑀧𑀣𑀁, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀁 𑀅𑀪𑀸𑀲𑀺𑀲𑀁;

‘𑀧𑀼𑀢𑁆𑀢𑀫𑀁𑀲𑀸𑀦𑀺 𑀔𑀸𑀤𑀸𑀫𑀺, 𑀲𑀘𑁂 𑀢𑀁 𑀧𑀓𑀢𑀁 𑀫𑀬𑀸’.

𑁪𑁫.

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

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

𑀲𑀢𑁆𑀢𑀧𑀼𑀢𑁆𑀢𑀔𑀸𑀤𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀲𑀢𑁆𑀢𑀫𑀁.

𑁮. 𑀕𑁄𑀡𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪𑁬.

‘‘𑀓𑀺𑀁 ¶ 𑀦𑀼 𑀉𑀫𑁆𑀫𑀢𑁆𑀢𑀭𑀽𑀧𑁄𑀯, 𑀮𑀸𑀬𑀺𑀢𑁆𑀯𑀸 𑀳𑀭𑀺𑀢𑀁 𑀢𑀺𑀡𑀁;

𑀔𑀸𑀤 𑀔𑀸𑀤𑀸𑀢𑀺 𑀮𑀧𑀲𑀺, 𑀕𑀢𑀲𑀢𑁆𑀢𑀁 𑀚𑀭𑀕𑁆𑀕𑀯𑀁.

𑁪𑁭.

‘‘𑀦 𑀳𑀺 𑀅𑀦𑁆𑀦𑁂𑀦 𑀧𑀸𑀦𑁂𑀦, 𑀫𑀢𑁄 𑀕𑁄𑀡𑁄 𑀲𑀫𑀼𑀝𑁆𑀞𑀳𑁂;

𑀢𑁆𑀯𑀁𑀲𑀺 𑀩𑀸𑀮𑁄 𑀘 [𑀩𑀸𑀮𑁄𑀯 (𑀓.)] 𑀤𑀼𑀫𑁆𑀫𑁂𑀥𑁄, 𑀬𑀣𑀸 𑀢𑀜𑁆𑀜𑁄𑀯 𑀤𑀼𑀫𑁆𑀫𑀢𑀻’’𑀢𑀺.

𑁪𑁮.

‘‘𑀇𑀫𑁂 𑀧𑀸𑀤𑀸 𑀇𑀤𑀁 𑀲𑀻𑀲𑀁, 𑀅𑀬𑀁 𑀓𑀸𑀬𑁄 𑀲𑀯𑀸𑀮𑀥𑀺;

𑀦𑁂𑀢𑁆𑀢𑀸 𑀢𑀣𑁂𑀯 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺, 𑀅𑀬𑀁 𑀕𑁄𑀡𑁄 𑀲𑀫𑀼𑀝𑁆𑀞𑀳𑁂.

𑁪𑁯.

‘‘𑀦𑀸𑀬𑁆𑀬𑀓𑀲𑁆𑀲 𑀳𑀢𑁆𑀣𑀧𑀸𑀤𑀸, 𑀓𑀸𑀬𑁄 𑀲𑀻𑀲𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀭𑀼𑀤𑀁 𑀫𑀢𑁆𑀢𑀺𑀓𑀣𑀽𑀧𑀲𑁆𑀫𑀺𑀁, 𑀦𑀦𑀼 𑀢𑁆𑀯𑀜𑁆𑀜𑁂𑀯 𑀤𑀼𑀫𑁆𑀫𑀢𑀻’’𑀢𑀺.

𑁫𑁦.

‘‘𑀆𑀤𑀺𑀢𑁆𑀢𑀁 𑀯𑀢 𑀫𑀁 𑀲𑀦𑁆𑀢𑀁, 𑀖𑀢𑀲𑀺𑀢𑁆𑀢𑀁𑀯 𑀧𑀸𑀯𑀓𑀁;

𑀯𑀸𑀭𑀺𑀦𑀸 𑀯𑀺𑀬 𑀑𑀲𑀺𑀜𑁆𑀘𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀦𑀺𑀩𑁆𑀩𑀸𑀧𑀬𑁂 𑀤𑀭𑀁.

𑁫𑁧.

‘‘𑀅𑀩𑁆𑀩𑀳𑀻 [𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀁 (𑀩𑀳𑀽𑀲𑀼)] 𑀯𑀢 𑀫𑁂 𑀲𑀮𑁆𑀮𑀁, 𑀲𑁄𑀓𑀁 𑀳𑀤𑀬𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁;

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

𑁫𑁨.

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀲𑀮𑁆𑀮𑁄𑀲𑁆𑀫𑀺, 𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑁄𑀲𑁆𑀫𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄;

𑀦 𑀲𑁄𑀘𑀸𑀫𑀺 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀢𑀯 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀫𑀸𑀡𑀯’.

𑁫𑁩.

𑀏𑀯𑀁 ¶ 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀲𑀧𑁆𑀧𑀜𑁆𑀜𑀸, 𑀬𑁂 𑀳𑁄𑀦𑁆𑀢𑀺 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀸;

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

𑀕𑁄𑀡𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀅𑀝𑁆𑀞𑀫𑀁.

𑁯. 𑀫𑀳𑀸𑀧𑁂𑀲𑀓𑀸𑀭𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁫𑁪.

‘‘𑀕𑀽𑀣𑀜𑁆𑀘 ¶ ¶ ¶ 𑀫𑀼𑀢𑁆𑀢𑀁 𑀭𑀼𑀳𑀺𑀭𑀜𑁆𑀘 𑀧𑀼𑀩𑁆𑀩𑀁, 𑀧𑀭𑀺𑀪𑀼𑀜𑁆𑀚𑀢𑀺 𑀓𑀺𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄;

𑀅𑀬𑀁 𑀦𑀼 𑀓𑀺𑀁 𑀓𑀫𑁆𑀫𑀫𑀓𑀸𑀲𑀺 𑀦𑀸𑀭𑀻, 𑀬𑀸 𑀲𑀩𑁆𑀩𑀤𑀸 𑀮𑁄𑀳𑀺𑀢𑀧𑀼𑀩𑁆𑀩𑀪𑀓𑁆𑀔𑀸.

𑁫𑁫.

‘‘𑀦𑀯𑀸𑀦𑀺 𑀯𑀢𑁆𑀣𑀸𑀦𑀺 𑀲𑀼𑀪𑀸𑀦𑀺 𑀘𑁂𑀯, 𑀫𑀼𑀤𑀽𑀦𑀺 𑀲𑀼𑀤𑁆𑀥𑀸𑀦𑀺 𑀘 𑀮𑁄𑀫𑀲𑀸𑀦𑀺;

𑀤𑀺𑀦𑁆𑀦𑀸𑀦𑀺 𑀫𑀺𑀲𑁆𑀲𑀸 𑀓𑀺𑀢𑀓𑀸 [𑀓𑀺𑀝𑀓𑀸 (𑀓.)] 𑀪𑀯𑀦𑁆𑀢𑀺, 𑀅𑀬𑀁 𑀦𑀼 𑀓𑀺𑀁 𑀓𑀫𑁆𑀫𑀫𑀓𑀸𑀲𑀺 𑀦𑀸𑀭𑀻’’𑀢𑀺.

𑁫𑁬.

‘‘𑀪𑀭𑀺𑀬𑀸 𑀫𑀫𑁂𑀲𑀸 𑀅𑀳𑀽 𑀪𑀤𑀦𑁆𑀢𑁂, 𑀅𑀤𑀸𑀬𑀺𑀓𑀸 𑀫𑀘𑁆𑀙𑀭𑀺𑀦𑀻 𑀓𑀤𑀭𑀺𑀬𑀸;

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

𑁫𑁭.

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

𑀏𑀢𑀁 𑀢𑁂 𑀧𑀭𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀳𑁄𑀢𑀼, 𑀯𑀢𑁆𑀣𑀸 𑀘 𑀢𑁂 𑀓𑀺𑀝𑀓𑀲𑀫𑀸 𑀪𑀯𑀦𑁆𑀢𑀼’;

𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀤𑀼𑀘𑁆𑀘𑀭𑀺𑀢𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸, 𑀇𑀥𑀸𑀕𑀢𑀸 𑀘𑀺𑀭𑀭𑀢𑁆𑀢𑀸𑀬 𑀔𑀸𑀤𑀢𑀻’’𑀢𑀺.

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

𑁧𑁦. 𑀔𑀮𑁆𑀮𑀸𑀝𑀺𑀬𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁫𑁮.

‘‘𑀓𑀸 ¶ ¶ 𑀦𑀼 𑀅𑀦𑁆𑀢𑁄𑀯𑀺𑀫𑀸𑀦𑀲𑁆𑀫𑀺𑀁, 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀻 𑀦𑀽𑀧𑀦𑀺𑀓𑁆𑀔𑀫𑀺;

𑀉𑀧𑀦𑀺𑀓𑁆𑀔𑀫𑀲𑁆𑀲𑀼 𑀪𑀤𑁆𑀤𑁂, 𑀧𑀲𑁆𑀲𑀸𑀫 𑀢𑀁 𑀩𑀳𑀺𑀝𑁆𑀞𑀺𑀢’’𑀦𑁆𑀢𑀺.

𑁫𑁯.

‘‘𑀅𑀝𑁆𑀝𑀻𑀬𑀸𑀫𑀺 ¶ 𑀳𑀭𑀸𑀬𑀸𑀫𑀺, 𑀦𑀕𑁆𑀕𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑀺𑀢𑀼𑀁 𑀩𑀳𑀺;

𑀓𑁂𑀲𑁂𑀳𑀫𑁆𑀳𑀺 𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑀸, 𑀧𑀼𑀜𑁆𑀜𑀁 𑀫𑁂 𑀅𑀧𑁆𑀧𑀓𑀁 𑀓𑀢’’𑀦𑁆𑀢𑀺.

𑁬𑁦.

‘‘𑀳𑀦𑁆𑀤𑀼𑀢𑁆𑀢𑀭𑀻𑀬𑀁 𑀤𑀤𑀸𑀫𑀺 𑀢𑁂, 𑀇𑀤𑀁 𑀤𑀼𑀲𑁆𑀲𑀁 𑀦𑀺𑀯𑀸𑀲𑀬;

𑀇𑀤𑀁 𑀤𑀼𑀲𑁆𑀲𑀁 𑀦𑀺𑀯𑀸𑀲𑁂𑀢𑁆𑀯𑀸, 𑀏𑀳𑀺 𑀦𑀺𑀓𑁆𑀔𑀫 𑀲𑁄𑀪𑀦𑁂;

𑀉𑀧𑀦𑀺𑀓𑁆𑀔𑀫𑀲𑁆𑀲𑀼 𑀪𑀤𑁆𑀤𑁂, 𑀧𑀲𑁆𑀲𑀸𑀫 𑀢𑀁 𑀩𑀳𑀺𑀝𑁆𑀞𑀺𑀢’’𑀦𑁆𑀢𑀺.

𑁬𑁧.

‘‘𑀳𑀢𑁆𑀣𑁂𑀦 𑀳𑀢𑁆𑀣𑁂 𑀢𑁂 𑀤𑀺𑀦𑁆𑀦𑀁, 𑀦 𑀫𑀬𑁆𑀳𑀁 𑀉𑀧𑀓𑀧𑁆𑀧𑀢𑀺;

𑀏𑀲𑁂𑀢𑁆𑀣𑀼𑀧𑀸𑀲𑀓𑁄 𑀲𑀤𑁆𑀥𑁄, 𑀲𑀫𑁆𑀫𑀸𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀲𑀸𑀯𑀓𑁄.

𑁬𑁨.

‘‘𑀏𑀢𑀁 𑀅𑀘𑁆𑀙𑀸𑀤𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀫𑀫 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲;

𑀢𑀣𑀸𑀳𑀁 [𑀅𑀣𑀸𑀳𑀁 (𑀲𑀻.)] 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁂𑀲𑁆𑀲𑀁, 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀦𑀻’’𑀢𑀺.

𑁬𑁩.

𑀢𑀜𑁆𑀘 𑀢𑁂 𑀦𑁆𑀳𑀸𑀧𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀯𑀺𑀮𑀺𑀫𑁆𑀧𑁂𑀢𑁆𑀯𑀸𑀦 𑀯𑀸𑀡𑀺𑀚𑀸;

𑀯𑀢𑁆𑀣𑁂𑀳𑀘𑁆𑀙𑀸𑀤𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀢𑀲𑁆𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲𑀼𑀁.

𑁬𑁪.

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

𑀪𑁄𑀚𑀦𑀘𑁆𑀙𑀸𑀤𑀦𑀧𑀸𑀦𑀻𑀬𑀁 [𑀪𑁄𑀚𑀦𑀘𑁆𑀙𑀸𑀤𑀦𑀁 𑀧𑀸𑀦𑀻𑀬𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬 𑀇𑀤𑀁 𑀨𑀮𑀁.

𑁬𑁫.

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

𑀳𑀲𑀦𑁆𑀢𑀻 𑀯𑀺𑀫𑀸𑀦𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑀺, ‘𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬 𑀇𑀤𑀁 𑀨𑀮’’’𑀦𑁆𑀢𑀺.

𑁬𑁬.

‘‘𑀲𑀼𑀘𑀺𑀢𑁆𑀢𑀭𑀽𑀧𑀁 𑀭𑀼𑀘𑀺𑀭𑀁, 𑀯𑀺𑀫𑀸𑀦𑀁 𑀢𑁂 𑀧𑀪𑀸𑀲𑀢𑀺;

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

𑁬𑁭.

‘‘𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄 ¶ 𑀘𑀭𑀫𑀸𑀦𑀲𑁆𑀲, 𑀤𑁄𑀡𑀺𑀦𑀺𑀫𑁆𑀫𑀚𑁆𑀚𑀦𑀺𑀁 𑀅𑀳𑀁;

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

𑁬𑁮.

‘‘𑀢𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀓𑀼𑀲𑀮𑀲𑁆𑀲, 𑀯𑀺𑀧𑀸𑀓𑀁 𑀤𑀻𑀖𑀫𑀦𑁆𑀢𑀭𑀁;

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

𑁬𑁯.

‘‘𑀉𑀤𑁆𑀥𑀁 ¶ 𑀘𑀢𑀽𑀳𑀺 𑀫𑀸𑀲𑁂𑀳𑀺, 𑀓𑀸𑀮𑀁𑀓𑀺𑀭𑀺𑀬𑀸 [𑀓𑀸𑀮𑀁𑀓𑀺𑀭𑀺𑀬𑀸 (𑀓.)] 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺;

𑀏𑀓𑀦𑁆𑀢𑀓𑀝𑀼𑀓𑀁 𑀖𑁄𑀭𑀁, 𑀦𑀺𑀭𑀬𑀁 𑀧𑀧𑀢𑀺𑀲𑁆𑀲𑀳𑀁.

𑁭𑁦.

[𑀫. 𑀦𑀺. 𑁩.𑁨𑁫𑁦, 𑁨𑁬𑁭; 𑀅. 𑀦𑀺. 𑁩.𑁩𑁬; 𑀧𑁂. 𑀯. 𑁨𑁪𑁦, 𑁬𑁯𑁩] ‘‘𑀘𑀢𑀼𑀓𑁆𑀓𑀡𑁆𑀡𑀁 𑀘𑀢𑀼𑀤𑁆𑀯𑀸𑀭𑀁, 𑀯𑀺𑀪𑀢𑁆𑀢𑀁 𑀪𑀸𑀕𑀲𑁄 𑀫𑀺𑀢𑀁;

𑀅𑀬𑁄𑀧𑀸𑀓𑀸𑀭𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀁, 𑀅𑀬𑀲𑀸 𑀧𑀝𑀺𑀓𑀼𑀚𑁆𑀚𑀺𑀢𑀁.

𑁭𑁧.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀅𑀬𑁄𑀫𑀬𑀸 𑀪𑀽𑀫𑀺, 𑀚𑀮𑀺𑀢𑀸 𑀢𑁂𑀚𑀲𑀸 𑀬𑀼𑀢𑀸;

𑀲𑀫𑀦𑁆𑀢𑀸 𑀬𑁄𑀚𑀦𑀲𑀢𑀁, 𑀨𑀭𑀺𑀢𑁆𑀯𑀸 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀲𑀩𑁆𑀩𑀤𑀸.

𑁭𑁨.

‘‘𑀢𑀢𑁆𑀣𑀸𑀳𑀁 𑀤𑀻𑀖𑀫𑀤𑁆𑀥𑀸𑀦𑀁, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀯𑁂𑀤𑀺𑀲𑁆𑀲 𑀯𑁂𑀤𑀦𑀁;

𑀨𑀮𑀜𑁆𑀘 𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀲𑁆𑀲, 𑀢𑀲𑁆𑀫𑀸 𑀲𑁄𑀘𑀸𑀫𑀳𑀁 𑀪𑀼𑀲’’𑀦𑁆𑀢𑀺.

𑀔𑀮𑁆𑀮𑀸𑀝𑀺𑀬𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀤𑀲𑀫𑀁.

𑁧𑁧. 𑀦𑀸𑀕𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁩.

‘‘𑀧𑀼𑀭𑀢𑁄𑀯 ¶ [𑀧𑀼𑀭𑀢𑁄 𑀘 (𑀲𑁆𑀬𑀸.)] 𑀲𑁂𑀢𑁂𑀦 𑀧𑀮𑁂𑀢𑀺 𑀳𑀢𑁆𑀣𑀺𑀦𑀸, 𑀫𑀚𑁆𑀛𑁂 𑀧𑀦 𑀅𑀲𑁆𑀲𑀢𑀭𑀻𑀭𑀣𑁂𑀦;

𑀧𑀘𑁆𑀙𑀸 𑀘 𑀓𑀜𑁆𑀜𑀸 𑀲𑀺𑀯𑀺𑀓𑀸𑀬 𑀦𑀻𑀬𑀢𑀺, 𑀑𑀪𑀸𑀲𑀬𑀦𑁆𑀢𑀻 𑀤𑀲 𑀲𑀩𑁆𑀩𑀢𑁄 [𑀲𑀩𑁆𑀩𑀢𑁄 (𑀓.)] 𑀤𑀺𑀲𑀸.

𑁭𑁪.

‘‘𑀢𑀼𑀫𑁆𑀳𑁂 𑀧𑀦 𑀫𑀼𑀕𑁆𑀕𑀭𑀳𑀢𑁆𑀣𑀧𑀸𑀡𑀺𑀦𑁄, 𑀭𑀼𑀤𑀁𑀫𑀼𑀔𑀸 𑀙𑀺𑀦𑁆𑀦𑀧𑀪𑀺𑀦𑁆𑀦𑀕𑀢𑁆𑀢𑀸;

𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸 ¶ 𑀓𑀺𑀫𑀓𑀢𑁆𑀣 𑀧𑀸𑀧𑀁, 𑀬𑁂𑀦𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀲𑁆𑀲 𑀧𑀺𑀯𑀸𑀣 𑀮𑁄𑀳𑀺𑀢’’𑀦𑁆𑀢𑀺.

𑁭𑁫.

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

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

𑁭𑁬.

‘‘𑀬𑁄 ¶ 𑀲𑁄 𑀫𑀚𑁆𑀛𑁂 𑀅𑀲𑁆𑀲𑀢𑀭𑀻𑀭𑀣𑁂𑀦, 𑀘𑀢𑀼𑀩𑁆𑀪𑀺 𑀬𑀼𑀢𑁆𑀢𑁂𑀦 𑀲𑀼𑀯𑀕𑁆𑀕𑀺𑀢𑁂𑀦;

𑀅𑀫𑁆𑀳𑀸𑀓 𑀧𑀼𑀢𑁆𑀢𑁄 𑀅𑀳𑀼 𑀫𑀚𑁆𑀛𑀺𑀫𑁄 𑀲𑁄, 𑀅𑀫𑀘𑁆𑀙𑀭𑀻 𑀤𑀸𑀦𑀯𑀢𑀻 𑀯𑀺𑀭𑁄𑀘𑀢𑀺.

𑁭𑁭.

‘‘𑀬𑀸 𑀲𑀸 𑀘 𑀧𑀘𑁆𑀙𑀸 𑀲𑀺𑀯𑀺𑀓𑀸𑀬 𑀦𑀻𑀬𑀢𑀺, 𑀦𑀸𑀭𑀻 𑀲𑀧𑀜𑁆𑀜𑀸 𑀫𑀺𑀕𑀫𑀦𑁆𑀤𑀮𑁄𑀘𑀦𑀸;

𑀅𑀫𑁆𑀳𑀸𑀓 𑀥𑀻𑀢𑀸 𑀅𑀳𑀼 𑀲𑀸 𑀓𑀦𑀺𑀝𑁆𑀞𑀺𑀓𑀸, 𑀪𑀸𑀕𑀟𑁆𑀠𑀪𑀸𑀕𑁂𑀦 𑀲𑀼𑀔𑀻 𑀧𑀫𑁄𑀤𑀢𑀺.

𑁭𑁮.

‘‘𑀏𑀢𑁂 ¶ 𑀘 𑀤𑀸𑀦𑀸𑀦𑀺 𑀅𑀤𑀁𑀲𑀼 𑀧𑀼𑀩𑁆𑀩𑁂, 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑀸 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁;

𑀫𑀬𑀁 𑀧𑀦 𑀫𑀘𑁆𑀙𑀭𑀺𑀦𑁄 𑀅𑀳𑀼𑀫𑁆𑀳, 𑀧𑀭𑀺𑀪𑀸𑀲𑀓𑀸 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁;

𑀏𑀢𑁂 𑀘 𑀤𑀢𑁆𑀯𑀸 𑀧𑀭𑀺𑀘𑀸𑀭𑀬𑀦𑁆𑀢𑀺, 𑀫𑀬𑀜𑁆𑀘 ¶ 𑀲𑀼𑀲𑁆𑀲𑀸𑀫 𑀦𑀴𑁄𑀯 𑀙𑀺𑀦𑁆𑀦𑁄’’𑀢𑀺 [𑀔𑀺𑀢𑁆𑀢𑁄𑀢𑀺 (𑀲𑀻.)].

𑁭𑁯.

‘‘𑀓𑀺𑀁 𑀢𑀼𑀫𑁆𑀳𑀸𑀓𑀁 𑀪𑁄𑀚𑀦𑀁 𑀓𑀺𑀁 𑀲𑀬𑀸𑀦𑀁, 𑀓𑀣𑀜𑁆𑀘 𑀬𑀸𑀧𑁂𑀣 𑀲𑀼𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑀺𑀦𑁄;

𑀧𑀳𑀽𑀢𑀪𑁄𑀕𑁂𑀲𑀼 𑀅𑀦𑀧𑁆𑀧𑀓𑁂𑀲𑀼, 𑀲𑀼𑀔𑀁 𑀯𑀺𑀭𑀸𑀥𑀸𑀬 [𑀯𑀺𑀭𑀸𑀕𑀸𑀬 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀤𑀼𑀓𑁆𑀔𑀚𑁆𑀚 𑀧𑀢𑁆𑀢𑀸’’𑀢𑀺.

𑁮𑁦.

‘‘𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀁 𑀯𑀥𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑀺𑀯𑀸𑀫 𑀧𑀼𑀩𑁆𑀩𑀮𑁄𑀳𑀺𑀢𑀁;

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

𑁮𑁧.

‘‘𑀇𑀘𑁆𑀘𑁂𑀯 𑀫𑀘𑁆𑀘𑀸 𑀧𑀭𑀺𑀤𑁂𑀯𑀬𑀦𑁆𑀢𑀺, 𑀅𑀤𑀸𑀬𑀓𑀸 𑀧𑁂𑀘𑁆𑀘 [𑀫𑀘𑁆𑀙𑀭𑀺𑀦𑁄 (𑀓.)] 𑀬𑀫𑀲𑁆𑀲 𑀞𑀸𑀬𑀺𑀦𑁄;

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

𑁮𑁨.

‘‘𑀢𑁂 ¶ 𑀔𑀼𑀧𑁆𑀧𑀺𑀧𑀸𑀲𑀽𑀧𑀕𑀢𑀸 𑀧𑀭𑀢𑁆𑀣, 𑀧𑀘𑁆𑀙𑀸 [𑀧𑁂𑀢𑀸 (𑀲𑀻.)] 𑀘𑀺𑀭𑀁 𑀛𑀸𑀬𑀭𑁂 𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑀸;

𑀓𑀫𑁆𑀫𑀸𑀦𑀺 𑀓𑀢𑁆𑀯𑀸𑀦 𑀤𑀼𑀔𑀼𑀤𑁆𑀭𑀸𑀦𑀺, 𑀅𑀦𑀼𑀪𑁄𑀦𑁆𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀓𑀝𑀼𑀓𑀧𑁆𑀨𑀮𑀸𑀦𑀺.

𑁮𑁩.

‘‘𑀇𑀢𑁆𑀢𑀭𑀁 𑀳𑀺 𑀥𑀦𑀁 𑀥𑀜𑁆𑀜𑀁, 𑀇𑀢𑁆𑀢𑀭𑀁 𑀇𑀥 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀇𑀢𑁆𑀢𑀭𑀁 𑀇𑀢𑁆𑀢𑀭𑀢𑁄 𑀜𑀢𑁆𑀯𑀸, 𑀤𑀻𑀧𑀁 𑀓𑀬𑀺𑀭𑀸𑀣 𑀧𑀡𑁆𑀟𑀺𑀢𑁄.

𑁮𑁪.

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

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

𑀦𑀸𑀕𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀏𑀓𑀸𑀤𑀲𑀫𑀁.

𑁧𑁨. 𑀉𑀭𑀕𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁮𑁫.

‘‘𑀉𑀭𑀕𑁄𑀯 ¶ ¶ ¶ 𑀢𑀘𑀁 𑀚𑀺𑀡𑁆𑀡𑀁, 𑀳𑀺𑀢𑁆𑀯𑀸 𑀕𑀘𑁆𑀙𑀢𑀺 𑀲𑀦𑁆𑀢𑀦𑀼𑀁;

𑀏𑀯𑀁 𑀲𑀭𑀻𑀭𑁂 𑀦𑀺𑀩𑁆𑀪𑁄𑀕𑁂, 𑀧𑁂𑀢𑁂 𑀓𑀸𑀮𑀗𑁆𑀓𑀢𑁂 𑀲𑀢𑀺.

𑁮𑁬.

‘‘𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑁄 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀜𑀸𑀢𑀻𑀦𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀺𑀢𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀏𑀢𑀁 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀕𑀢𑁄 𑀲𑁄 𑀢𑀲𑁆𑀲 𑀬𑀸 𑀕𑀢𑀺’’.

𑁮𑁭.

‘‘𑀅𑀦𑀩𑁆𑀪𑀺𑀢𑁄 [𑀅𑀦𑀯𑁆𑀳𑀺𑀢𑁄 (𑀲𑀻.)] 𑀢𑀢𑁄 𑀆𑀕𑀸, 𑀦𑀸𑀦𑀼𑀜𑁆𑀜𑀸𑀢𑁄 𑀇𑀢𑁄 𑀕𑀢𑁄;

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

𑁮𑁮.

‘‘𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑁄 ¶ 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀜𑀸𑀢𑀻𑀦𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀺𑀢𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀏𑀢𑀁 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀕𑀢𑁄 𑀲𑁄 𑀢𑀲𑁆𑀲 𑀬𑀸 𑀕𑀢𑀺’’.

𑁮𑁯.

‘‘𑀲𑀘𑁂 𑀭𑁄𑀤𑁂 𑀓𑀺𑀲𑀸 𑀅𑀲𑁆𑀲𑀁, 𑀢𑀢𑁆𑀣 𑀫𑁂 𑀓𑀺𑀁 𑀨𑀮𑀁 𑀲𑀺𑀬𑀸;

𑀜𑀸𑀢𑀺𑀫𑀺𑀢𑁆𑀢𑀲𑀼𑀳𑀚𑁆𑀚𑀸𑀦𑀁, 𑀪𑀺𑀬𑁆𑀬𑁄 𑀦𑁄 𑀅𑀭𑀢𑀻 𑀲𑀺𑀬𑀸.

𑁯𑁦.

‘‘𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑁄 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀜𑀸𑀢𑀻𑀦𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀺𑀢𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀏𑀢𑀁 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀕𑀢𑁄 𑀲𑁄 𑀢𑀲𑁆𑀲 𑀬𑀸 𑀕𑀢𑀺’’.

𑁯𑁧.

‘‘𑀬𑀣𑀸𑀧𑀺 𑀤𑀸𑀭𑀓𑁄 𑀘𑀦𑁆𑀤𑀁, 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀫𑀦𑀼𑀭𑁄𑀤𑀢𑀺;

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

𑁯𑁨.

‘‘𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑁄 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀜𑀸𑀢𑀻𑀦𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀺𑀢𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀏𑀢𑀁 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀕𑀢𑁄 𑀲𑁄 𑀢𑀲𑁆𑀲 𑀬𑀸 𑀕𑀢𑀺’’.

𑁯𑁩.

‘‘𑀬𑀣𑀸𑀧𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑁂 𑀉𑀤𑀓𑀼𑀫𑁆𑀪𑁄, 𑀪𑀺𑀦𑁆𑀦𑁄 𑀅𑀧𑁆𑀧𑀝𑀺𑀲𑀦𑁆𑀥𑀺𑀬𑁄;

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

𑁯𑁪.

‘‘𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑁄 𑀦 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀜𑀸𑀢𑀻𑀦𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀺𑀢𑀁;

𑀢𑀲𑁆𑀫𑀸 ¶ 𑀏𑀢𑀁 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀕𑀢𑁄 𑀲𑁄 𑀢𑀲𑁆𑀲 𑀬𑀸 𑀕𑀢𑀻’’𑀢𑀺.

𑀉𑀭𑀕𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁.

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

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

𑀔𑁂𑀢𑁆𑀢𑀜𑁆𑀘 𑀲𑀽𑀓𑀭𑀁 𑀧𑀽𑀢𑀺, 𑀧𑀺𑀝𑁆𑀞𑀁 𑀘𑀸𑀧𑀺 𑀢𑀺𑀭𑁄𑀓𑀼𑀝𑁆𑀝𑀁;

𑀧𑀜𑁆𑀘𑀸𑀧𑀺 ¶ 𑀲𑀢𑁆𑀢𑀧𑀼𑀢𑁆𑀢𑀜𑁆𑀘, 𑀕𑁄𑀡𑀁 𑀧𑁂𑀲𑀓𑀸𑀭𑀓𑀜𑁆𑀘;

𑀢𑀣𑀸 𑀔𑀮𑁆𑀮𑀸𑀝𑀺𑀬𑀁 𑀦𑀸𑀕𑀁, 𑀤𑁆𑀯𑀸𑀤𑀲𑀁 𑀉𑀭𑀕𑀜𑁆𑀘𑁂𑀯𑀸𑀢𑀺.

𑁨. 𑀉𑀩𑁆𑀩𑀭𑀺𑀯𑀕𑁆𑀕𑁄

𑁧. 𑀲𑀁𑀲𑀸𑀭𑀫𑁄𑀘𑀓𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁯𑁫.

‘‘𑀦𑀕𑁆𑀕𑀸 ¶ ¶ ¶ 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀲𑀺, 𑀓𑀺𑀲𑀸 𑀥𑀫𑀦𑀺𑀲𑀦𑁆𑀣𑀢𑀸;

𑀉𑀧𑁆𑀨𑀸𑀲𑀼𑀮𑀺𑀓𑁂 [𑀉𑀧𑁆𑀧𑀸𑀲𑀼𑀴𑀺𑀓𑁂 (𑀓.)] 𑀓𑀺𑀲𑀺𑀓𑁂, 𑀓𑀸 𑀦𑀼 𑀢𑁆𑀯𑀁 𑀇𑀥 𑀢𑀺𑀝𑁆𑀞𑀲𑀻’’𑀢𑀺.

𑁯𑁬.

‘‘𑀅𑀳𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀧𑁂𑀢𑀻𑀫𑁆𑀳𑀺, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁯𑁭.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁯𑁮.

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

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

𑁯𑁯.

‘‘𑀇𑀢𑁄 𑀅𑀳𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀸𑀦𑀺 𑀧𑀜𑁆𑀘, 𑀬𑀁 𑀏𑀯𑀭𑀽𑀧𑀸 𑀯𑀺𑀘𑀭𑀸𑀫𑀺 𑀦𑀕𑁆𑀕𑀸;

𑀔𑀼𑀤𑀸𑀬 ¶ 𑀢𑀡𑁆𑀳𑀸𑀬 𑀘 𑀔𑀚𑁆𑀚𑀫𑀸𑀦𑀸, 𑀧𑀸𑀧𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀨𑀮𑀁 𑀫𑀫𑁂𑀤𑀁.

𑁧𑁦𑁦.

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

𑀤𑀢𑁆𑀯𑀸 𑀘 𑀫𑁂 𑀆𑀤𑀺𑀲 𑀬𑀁 𑀳𑀺 𑀓𑀺𑀜𑁆𑀘𑀺, 𑀫𑁄𑀘𑁂𑀳𑀺 𑀫𑀁 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀬𑀸 𑀪𑀤𑀦𑁆𑀢𑁂’’𑀢𑀺.

𑁧𑁦𑁧.

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

𑀪𑀺𑀓𑁆𑀔𑀽𑀦𑀁 𑀆𑀮𑁄𑀧𑀁 𑀤𑀢𑁆𑀯𑀸, 𑀧𑀸𑀡𑀺𑀫𑀢𑁆𑀢𑀜𑁆𑀘 𑀘𑁄𑀴𑀓𑀁;

𑀣𑀸𑀮𑀓𑀲𑁆𑀲 𑀘 𑀧𑀸𑀦𑀻𑀬𑀁, 𑀢𑀲𑁆𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲𑀺.

𑁧𑁦𑁨.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂, 𑀯𑀺𑀧𑀸𑀓𑁄 𑀉𑀤𑀧𑀚𑁆𑀚𑀣;

𑀪𑁄𑀚𑀦𑀘𑁆𑀙𑀸𑀤𑀦𑀧𑀸𑀦𑀻𑀬𑀁, 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬 𑀇𑀤𑀁 𑀨𑀮𑀁.

𑁧𑁦𑁩.

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

𑀯𑀺𑀘𑀺𑀢𑁆𑀢𑀯𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑀸, 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺.

𑁧𑁦𑁪.

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

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

𑁧𑁦𑁫.

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

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

𑁧𑁦𑁬.

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

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

𑁧𑁦𑁭.

‘‘𑀉𑀧𑁆𑀧𑀡𑁆𑀟𑀼𑀓𑀺𑀁 𑀓𑀺𑀲𑀁 𑀙𑀸𑀢𑀁, 𑀦𑀕𑁆𑀕𑀁 𑀲𑀫𑁆𑀧𑀢𑀺𑀢𑀘𑁆𑀙𑀯𑀺𑀁 [𑀆𑀧𑀢𑀺𑀢𑀘𑁆𑀙𑀯𑀺𑀁 (𑀲𑀻.)];

𑀫𑀼𑀦𑀺 𑀓𑀸𑀭𑀼𑀡𑀺𑀓𑁄 𑀮𑁄𑀓𑁂, 𑀢𑀁 𑀫𑀁 𑀅𑀤𑁆𑀤𑀓𑁆𑀔𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀁.

𑁧𑁦𑁮.

‘‘𑀪𑀺𑀓𑁆𑀔𑀽𑀦𑀁 𑀆𑀮𑁄𑀧𑀁 𑀤𑀢𑁆𑀯𑀸, 𑀧𑀸𑀡𑀺𑀫𑀢𑁆𑀢𑀜𑁆𑀘 𑀘𑁄𑀴𑀓𑀁;

𑀣𑀸𑀮𑀓𑀲𑁆𑀲 𑀘 𑀧𑀸𑀦𑀻𑀬𑀁, 𑀫𑀫 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲𑀺.

𑁧𑁦𑁯.

‘‘𑀆𑀮𑁄𑀧𑀲𑁆𑀲 𑀨𑀮𑀁 𑀧𑀲𑁆𑀲, 𑀪𑀢𑁆𑀢𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀁 𑀤𑀲;

𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀺 𑀓𑀸𑀫𑀓𑀸𑀫𑀺𑀦𑀻, 𑀅𑀦𑁂𑀓𑀭𑀲𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀁.

𑁧𑁧𑁦.

‘‘𑀧𑀸𑀡𑀺𑀫𑀢𑁆𑀢𑀲𑁆𑀲 𑀘𑁄𑀴𑀲𑁆𑀲, 𑀯𑀺𑀧𑀸𑀓𑀁 𑀧𑀲𑁆𑀲 𑀬𑀸𑀤𑀺𑀲𑀁;

𑀬𑀸𑀯𑀢𑀸 𑀦𑀦𑁆𑀤𑀭𑀸𑀚𑀲𑁆𑀲, 𑀯𑀺𑀚𑀺𑀢𑀲𑁆𑀫𑀺𑀁 𑀧𑀝𑀺𑀘𑁆𑀙𑀤𑀸.

𑁧𑁧𑁧.

‘‘𑀢𑀢𑁄 𑀩𑀳𑀼𑀢𑀭𑀸 𑀪𑀦𑁆𑀢𑁂, 𑀯𑀢𑁆𑀣𑀸𑀦𑀘𑁆𑀙𑀸𑀤𑀦𑀸𑀦𑀺 𑀫𑁂;

𑀓𑁄𑀲𑁂𑀬𑁆𑀬𑀓𑀫𑁆𑀩𑀮𑀻𑀬𑀸𑀦𑀺, 𑀔𑁄𑀫𑀓𑀧𑁆𑀧𑀸𑀲𑀺𑀓𑀸𑀦𑀺 𑀘.

𑁧𑁧𑁨.

‘‘𑀯𑀺𑀧𑀼𑀮𑀸 𑀘 𑀫𑀳𑀕𑁆𑀖𑀸 𑀘, 𑀢𑁂𑀧𑀸𑀓𑀸𑀲𑁂𑀯𑀮𑀫𑁆𑀩𑀭𑁂;

𑀲𑀸𑀳𑀁 𑀢𑀁 𑀧𑀭𑀺𑀤𑀳𑀸𑀫𑀺, 𑀬𑀁 𑀬𑀁 𑀳𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀁.

𑁧𑁧𑁩.

‘‘𑀣𑀸𑀮𑀓𑀲𑁆𑀲 𑀘 𑀧𑀸𑀦𑀻𑀬𑀁, 𑀯𑀺𑀧𑀸𑀓𑀁 𑀧𑀲𑁆𑀲 𑀬𑀸𑀤𑀺𑀲𑀁;

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

𑁧𑁧𑁪.

‘‘𑀲𑁂𑀢𑁄𑀤𑀓𑀸 𑀲𑀼𑀧𑁆𑀧𑀢𑀺𑀢𑁆𑀣𑀸, 𑀲𑀻𑀢𑀸 𑀅𑀧𑁆𑀧𑀝𑀺𑀕𑀦𑁆𑀥𑀺𑀬𑀸;

𑀧𑀤𑀼𑀫𑀼𑀧𑁆𑀧𑀮𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸, 𑀯𑀸𑀭𑀺𑀓𑀺𑀜𑁆𑀚𑀓𑁆𑀔𑀧𑀽𑀭𑀺𑀢𑀸.

𑁧𑁧𑁫.

‘‘𑀲𑀸𑀳𑀁 ¶ 𑀭𑀫𑀸𑀫𑀺 𑀓𑀻𑀴𑀸𑀫𑀺, 𑀫𑁄𑀤𑀸𑀫𑀺 𑀅𑀓𑀼𑀢𑁄𑀪𑀬𑀸;

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

𑀲𑀁𑀲𑀸𑀭𑀫𑁄𑀘𑀓𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀧𑀞𑀫𑀁.

𑁨. 𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀢𑁆𑀣𑁂𑀭𑀫𑀸𑀢𑀼𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁧𑁧𑁬.

‘‘𑀦𑀕𑁆𑀕𑀸 ¶ ¶ 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀲𑀺, 𑀓𑀺𑀲𑀸 𑀥𑀫𑀦𑀺𑀲𑀦𑁆𑀣𑀢𑀸;

𑀉𑀧𑁆𑀨𑀸𑀲𑀼𑀮𑀺𑀓𑁂 𑀓𑀺𑀲𑀺𑀓𑁂, 𑀓𑀸 𑀦𑀼 𑀢𑁆𑀯𑀁 𑀇𑀥 𑀢𑀺𑀝𑁆𑀞𑀲𑀺’’.

𑁧𑁧𑁭.

‘‘𑀅𑀳𑀁 ¶ 𑀢𑁂 𑀲𑀓𑀺𑀬𑀸 𑀫𑀸𑀢𑀸, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀅𑀜𑁆𑀜𑀸𑀲𑀼 𑀚𑀸𑀢𑀻𑀲𑀼;

𑀉𑀧𑀧𑀦𑁆𑀦𑀸 𑀧𑁂𑀢𑁆𑀢𑀺𑀯𑀺𑀲𑀬𑀁, 𑀔𑀼𑀧𑁆𑀧𑀺𑀧𑀸𑀲𑀲𑀫𑀧𑁆𑀧𑀺𑀢𑀸.

𑁧𑁧𑁮.

‘‘𑀙𑀟𑁆𑀟𑀺𑀢𑀁 ¶ 𑀔𑀺𑀧𑀺𑀢𑀁 𑀔𑁂𑀴𑀁, 𑀲𑀺𑀗𑁆𑀖𑀸𑀡𑀺𑀓𑀁 𑀲𑀺𑀮𑁂𑀲𑀼𑀫𑀁;

𑀯𑀲𑀜𑁆𑀘 𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑀸𑀦𑀁, 𑀯𑀺𑀚𑀸𑀢𑀸𑀦𑀜𑁆𑀘 𑀮𑁄𑀳𑀺𑀢𑀁.

𑁧𑁧𑁯.

‘‘𑀯𑀡𑀺𑀓𑀸𑀦𑀜𑁆𑀘 𑀬𑀁 𑀖𑀸𑀦-𑀲𑀻𑀲𑀘𑁆𑀙𑀺𑀦𑁆𑀦𑀸𑀦 𑀮𑁄𑀳𑀺𑀢𑀁;

𑀔𑀼𑀤𑀸𑀧𑀭𑁂𑀢𑀸 𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀺, 𑀇𑀢𑁆𑀣𑀺𑀧𑀼𑀭𑀺𑀲𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁.

𑁧𑁨𑁦.

‘‘𑀧𑀼𑀩𑁆𑀩𑀮𑁄𑀳𑀺𑀢𑀁 𑀪𑀓𑁆𑀔𑀸𑀫𑀺 [𑀧𑀼𑀩𑁆𑀩𑀮𑁄𑀳𑀺𑀢𑀪𑀓𑁆𑀔𑀸𑀲𑁆𑀫𑀺 (𑀲𑀻.)], 𑀧𑀲𑀽𑀦𑀁 𑀫𑀸𑀦𑀼𑀲𑀸𑀦 𑀘;

𑀅𑀮𑁂𑀡𑀸 𑀅𑀦𑀕𑀸𑀭𑀸 𑀘, 𑀦𑀻𑀮𑀫𑀜𑁆𑀘𑀧𑀭𑀸𑀬𑀡𑀸.

𑁧𑁨𑁧.

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

𑀅𑀧𑁆𑀧𑁂𑀯 𑀦𑀸𑀫 𑀫𑀼𑀘𑁆𑀘𑁂𑀬𑁆𑀬𑀁, 𑀧𑀼𑀩𑁆𑀩𑀮𑁄𑀳𑀺𑀢𑀪𑁄𑀚𑀦𑀸’’𑀢𑀺.

𑁧𑁨𑁨.

𑀫𑀸𑀢𑀼𑀬𑀸 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀉𑀧𑀢𑀺𑀲𑁆𑀲𑁄𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑁄;

𑀆𑀫𑀦𑁆𑀢𑀬𑀺 𑀫𑁄𑀕𑁆𑀕𑀮𑁆𑀮𑀸𑀦𑀁, 𑀅𑀦𑀼𑀭𑀼𑀤𑁆𑀥𑀜𑁆𑀘 𑀓𑀧𑁆𑀧𑀺𑀦𑀁.

𑁧𑁨𑁩.

𑀘𑀢𑀲𑁆𑀲𑁄 𑀓𑀼𑀝𑀺𑀬𑁄 𑀓𑀢𑁆𑀯𑀸, 𑀲𑀗𑁆𑀖𑁂 𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑁂 𑀅𑀤𑀸;

𑀓𑀼𑀝𑀺𑀬𑁄 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑀜𑁆𑀘, 𑀫𑀸𑀢𑀼 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲𑀻.

𑁧𑁨𑁪.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂, 𑀯𑀺𑀧𑀸𑀓𑁄 𑀉𑀤𑀧𑀚𑁆𑀚𑀣;

𑀪𑁄𑀚𑀦𑀁 𑀧𑀸𑀦𑀻𑀬𑀁 𑀯𑀢𑁆𑀣𑀁, 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬 𑀇𑀤𑀁 𑀨𑀮𑀁.

𑁧𑁨𑁫.

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

𑀯𑀺𑀘𑀺𑀢𑁆𑀢𑀯𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑀸, 𑀓𑁄𑀮𑀺𑀢𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺.

𑁧𑁨𑁬.

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

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

𑁧𑁨𑁭.

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

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

𑁧𑁨𑁮.

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

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

𑁧𑁨𑁯.

‘‘𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀫𑀸𑀢𑀸, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀅𑀜𑁆𑀜𑀸𑀲𑀼 𑀚𑀸𑀢𑀻𑀲𑀼;

𑀉𑀧𑀧𑀦𑁆𑀦𑀸 𑀧𑁂𑀢𑁆𑀢𑀺𑀯𑀺𑀲𑀬𑀁, 𑀔𑀼𑀧𑁆𑀧𑀺𑀧𑀸𑀲𑀲𑀫𑀧𑁆𑀧𑀺𑀢𑀸.

𑁧𑁩𑁦.

‘‘𑀙𑀟𑁆𑀟𑀺𑀢𑀁 𑀔𑀺𑀧𑀺𑀢𑀁 𑀔𑁂𑀴𑀁, 𑀲𑀺𑀗𑁆𑀖𑀸𑀡𑀺𑀓𑀁 𑀲𑀺𑀮𑁂𑀲𑀼𑀫𑀁;

𑀯𑀲𑀜𑁆𑀘 𑀟𑀬𑁆𑀳𑀫𑀸𑀦𑀸𑀦𑀁, 𑀯𑀺𑀚𑀸𑀢𑀸𑀦𑀜𑁆𑀘 𑀮𑁄𑀳𑀺𑀢𑀁.

𑁧𑁩𑁧.

‘‘𑀯𑀡𑀺𑀓𑀸𑀦𑀜𑁆𑀘 𑀬𑀁 𑀖𑀸𑀦-𑀲𑀻𑀲𑀘𑁆𑀙𑀺𑀦𑁆𑀦𑀸𑀦 𑀮𑁄𑀳𑀺𑀢𑀁;

𑀔𑀼𑀤𑀸𑀧𑀭𑁂𑀢𑀸 𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀺, 𑀇𑀢𑁆𑀣𑀺𑀧𑀼𑀭𑀺𑀲𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁.

𑁧𑁩𑁨.

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

𑀅𑀮𑁂𑀡𑀸 𑀅𑀦𑀕𑀸𑀭𑀸 𑀘, 𑀦𑀻𑀮𑀫𑀜𑁆𑀘𑀧𑀭𑀸𑀬𑀡𑀸.

𑁧𑁩𑁩.

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

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

𑀲𑀸𑀭𑀺𑀧𑀼𑀢𑁆𑀢𑀢𑁆𑀣𑁂𑀭𑀲𑁆𑀲 𑀫𑀸𑀢𑀼𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀤𑀼𑀢𑀺𑀬𑀁.

𑁩. 𑀫𑀢𑁆𑀢𑀸𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁧𑁩𑁪.

‘‘𑀦𑀕𑁆𑀕𑀸 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀲𑀺, 𑀓𑀺𑀲𑀸 𑀥𑀫𑀦𑀺𑀲𑀦𑁆𑀣𑀢𑀸;

𑀉𑀧𑁆𑀨𑀸𑀲𑀼𑀮𑀺𑀓𑁂 ¶ 𑀓𑀺𑀲𑀺𑀓𑁂, 𑀓𑀸 𑀦𑀼 𑀢𑁆𑀯𑀁 𑀇𑀥 𑀢𑀺𑀝𑁆𑀞𑀲𑀻’’𑀢𑀺.

𑁧𑁩𑁫.

‘‘𑀅𑀳𑀁 𑀫𑀢𑁆𑀢𑀸 𑀢𑀼𑀯𑀁 𑀢𑀺𑀲𑁆𑀲𑀸, 𑀲𑀧𑀢𑁆𑀢𑀻 𑀢𑁂 𑀧𑀼𑀭𑁂 𑀅𑀳𑀼𑀁;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁧𑁩𑁬.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁧𑁩𑁭.

‘‘𑀘𑀡𑁆𑀟𑀻 ¶ ¶ 𑀘 𑀨𑀭𑀼𑀲𑀸 𑀘𑀸𑀲𑀺𑀁, 𑀇𑀲𑁆𑀲𑀼𑀓𑀻 𑀫𑀘𑁆𑀙𑀭𑀻 𑀲𑀞𑀸 [𑀲𑀞𑀻 (𑀲𑀻.)];

𑀢𑀸𑀳𑀁 𑀤𑀼𑀭𑀼𑀢𑁆𑀢𑀁 𑀯𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁧𑁩𑁮.

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

𑀅𑀜𑁆𑀜𑀜𑁆𑀘 𑀔𑁄 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺, 𑀓𑁂𑀦𑀸𑀲𑀺 𑀧𑀁𑀲𑀼𑀓𑀼𑀦𑁆𑀣𑀺𑀢𑀸’’𑀢𑀺.

𑁧𑁩𑁯.

‘‘𑀲𑀻𑀲𑀁𑀦𑁆𑀳𑀸𑀢𑀸 𑀢𑀼𑀯𑀁 𑀆𑀲𑀺, 𑀲𑀼𑀘𑀺𑀯𑀢𑁆𑀣𑀸 𑀅𑀮𑀗𑁆𑀓𑀢𑀸;

𑀅𑀳𑀜𑁆𑀘 𑀔𑁄 [𑀔𑁄 𑀢𑀁 (𑀲𑀻. 𑀓.)] 𑀅𑀥𑀺𑀫𑀢𑁆𑀢𑀁, 𑀲𑀫𑀮𑀗𑁆𑀓𑀢𑀢𑀭𑀸 𑀢𑀬𑀸.

𑁧𑁪𑁦.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀫𑁂 𑀧𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑀸𑀬, 𑀲𑀸𑀫𑀺𑀓𑁂𑀦 𑀲𑀫𑀦𑁆𑀢𑀬𑀺;

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

𑁧𑁪𑁧.

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

𑀢𑀲𑁆𑀲 ¶ 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀢𑁂𑀦𑀫𑁆𑀳𑀺 𑀧𑀁𑀲𑀼𑀓𑀼𑀦𑁆𑀣𑀺𑀢𑀸’’𑀢𑀺.

𑁧𑁪𑁨.

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

𑀅𑀜𑁆𑀜𑀜𑁆𑀘 𑀔𑁄 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺, 𑀓𑁂𑀦 𑀔𑀚𑁆𑀚𑀲𑀺 𑀓𑀘𑁆𑀙𑀼𑀬𑀸’’𑀢𑀺.

𑁧𑁪𑁩.

‘‘𑀪𑁂𑀲𑀚𑁆𑀚𑀳𑀸𑀭𑀻 𑀉𑀪𑀬𑁄, 𑀯𑀦𑀦𑁆𑀢𑀁 𑀅𑀕𑀫𑀺𑀫𑁆𑀳𑀲𑁂;

𑀢𑁆𑀯𑀜𑁆𑀘 𑀪𑁂𑀲𑀚𑁆𑀚𑀫𑀸𑀳𑀭𑀺, 𑀅𑀳𑀜𑁆𑀘 𑀓𑀧𑀺𑀓𑀘𑁆𑀙𑀼𑀦𑁄.

𑁧𑁪𑁪.

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

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

𑁧𑁪𑁫.

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

𑀅𑀜𑁆𑀜𑀜𑁆𑀘 𑀔𑁄 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺, 𑀓𑁂𑀦𑀸𑀲𑀺 𑀦𑀕𑁆𑀕𑀺𑀬𑀸 𑀢𑀼𑀯’’𑀦𑁆𑀢𑀺.

𑁧𑁪𑁬.

‘‘𑀲𑀳𑀸𑀬𑀸𑀦𑀁 𑀲𑀫𑀬𑁄 𑀆𑀲𑀺, 𑀜𑀸𑀢𑀻𑀦𑀁 𑀲𑀫𑀺𑀢𑀻 𑀅𑀳𑀼;

𑀢𑁆𑀯𑀜𑁆𑀘 𑀆𑀫𑀦𑁆𑀢𑀺𑀢𑀸 𑀆𑀲𑀺, 𑀲𑀲𑀸𑀫𑀺𑀦𑀻 𑀦𑁄 𑀘 𑀔𑁄 𑀅𑀳𑀁.

𑁧𑁪𑁭.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀢𑁆𑀬𑀸𑀚𑀸𑀦𑀫𑀸𑀦𑀸𑀬, 𑀤𑀼𑀲𑁆𑀲𑀁 𑀢𑁆𑀬𑀸𑀳𑀁 𑀅𑀧𑀸𑀦𑀼𑀤𑀺𑀁;

𑀢𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀢𑁂𑀦𑀫𑁆𑀳𑀺 𑀦𑀕𑁆𑀕𑀺𑀬𑀸 𑀅𑀳’’𑀦𑁆𑀢𑀺.

𑁧𑁪𑁮.

‘‘𑀲𑀘𑁆𑀘𑀁 𑀅𑀳𑀫𑁆𑀧𑀺 𑀚𑀸𑀦𑀸𑀫𑀺, 𑀤𑀼𑀲𑁆𑀲𑀁 𑀫𑁂 𑀢𑁆𑀯𑀁 𑀅𑀧𑀸𑀦𑀼𑀤𑀺;

𑀅𑀜𑁆𑀜𑀜𑁆𑀘 𑀔𑁄 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺, 𑀓𑁂𑀦𑀸𑀲𑀺 𑀕𑀽𑀣𑀕𑀦𑁆𑀥𑀺𑀦𑀻’’𑀢𑀺.

𑁧𑁪𑁯.

‘‘𑀢𑀯 ¶ 𑀕𑀦𑁆𑀥𑀜𑁆𑀘 𑀫𑀸𑀮𑀜𑁆𑀘, 𑀧𑀘𑁆𑀘𑀕𑁆𑀖𑀜𑁆𑀘 𑀯𑀺𑀮𑁂𑀧𑀦𑀁;

𑀕𑀽𑀣𑀓𑀽𑀧𑁂 𑀅𑀥𑀸𑀭𑁂𑀲𑀺𑀁 [𑀅𑀥𑀸𑀭𑁂𑀲𑀺𑀁 (𑀓.)], 𑀢𑀁 𑀧𑀸𑀧𑀁 𑀧𑀓𑀢𑀁 𑀫𑀬𑀸;

𑀢𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀢𑁂𑀦𑀫𑁆𑀳𑀺 𑀕𑀽𑀣𑀕𑀦𑁆𑀥𑀺𑀦𑀻’’𑀢𑀺.

𑁧𑁫𑁦.

‘‘𑀲𑀘𑁆𑀘𑀁 𑀅𑀳𑀫𑁆𑀧𑀺 𑀚𑀸𑀦𑀸𑀫𑀺, 𑀢𑀁 𑀧𑀸𑀧𑀁 𑀧𑀓𑀢𑀁 𑀢𑀬𑀸;

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

𑁧𑁫𑁧.

‘‘𑀉𑀪𑀺𑀦𑁆𑀦𑀁 𑀲𑀫𑀓𑀁 𑀆𑀲𑀺, 𑀬𑀁 𑀕𑁂𑀳𑁂 𑀯𑀺𑀚𑁆𑀚𑀢𑁂 𑀥𑀦𑀁;

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

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

𑁧𑁫𑁨.

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

𑀦 𑀳𑀺 𑀧𑀸𑀧𑁂𑀳𑀺 𑀓𑀫𑁆𑀫𑁂𑀳𑀺, 𑀲𑀼𑀮𑀪𑀸 𑀳𑁄𑀢𑀺 𑀲𑀼𑀕𑁆𑀕𑀢𑀻’’’𑀢𑀺.

𑁧𑁫𑁩.

‘‘𑀯𑀸𑀫𑀢𑁄 𑀫𑀁 𑀢𑁆𑀯𑀁 𑀧𑀘𑁆𑀘𑁂𑀲𑀺, 𑀅𑀣𑁄𑀧𑀺 𑀫𑀁 𑀉𑀲𑀽𑀬𑀲𑀺;

𑀧𑀲𑁆𑀲 ¶ 𑀧𑀸𑀧𑀸𑀦𑀁 𑀓𑀫𑁆𑀫𑀸𑀦𑀁, 𑀯𑀺𑀧𑀸𑀓𑁄 𑀳𑁄𑀢𑀺 𑀬𑀸𑀤𑀺𑀲𑁄.

𑁧𑁫𑁪.

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

𑀢𑁂 𑀅𑀜𑁆𑀜𑁂 𑀧𑀭𑀺𑀘𑀸𑀭𑁂𑀦𑁆𑀢𑀺, 𑀦 𑀪𑁄𑀕𑀸 𑀳𑁄𑀦𑁆𑀢𑀺 𑀲𑀲𑁆𑀲𑀢𑀸.

𑁧𑁫𑁫.

‘‘𑀇𑀤𑀸𑀦𑀺 𑀪𑀽𑀢𑀲𑁆𑀲 𑀧𑀺𑀢𑀸, 𑀆𑀧𑀡𑀸 𑀕𑁂𑀳𑀫𑁂𑀳𑀺𑀢𑀺;

𑀅𑀧𑁆𑀧𑁂𑀯 𑀢𑁂 𑀤𑀤𑁂 𑀓𑀺𑀜𑁆𑀘𑀺, 𑀫𑀸 𑀲𑀼 𑀢𑀸𑀯 𑀇𑀢𑁄 𑀅𑀕𑀸’’𑀢𑀺.

𑁧𑁫𑁬.

‘‘𑀦𑀕𑁆𑀕𑀸 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀫𑁆𑀳𑀺, 𑀓𑀺𑀲𑀸 𑀥𑀫𑀦𑀺𑀲𑀦𑁆𑀣𑀢𑀸;

𑀓𑁄𑀧𑀻𑀦𑀫𑁂𑀢𑀁 𑀇𑀢𑁆𑀣𑀻𑀦𑀁, 𑀫𑀸 𑀫𑀁 𑀪𑀽𑀢𑀧𑀺𑀢𑀸𑀤𑁆𑀤𑀲𑀸’’𑀢𑀺.

𑁧𑁫𑁭.

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

𑀬𑁂𑀦 𑀢𑁆𑀯𑀁 𑀲𑀼𑀔𑀺𑀢𑀸 𑀅𑀲𑁆𑀲, 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀦𑀻’’𑀢𑀺.

𑁧𑁫𑁮.

‘‘𑀘𑀢𑁆𑀢𑀸𑀭𑁄 ¶ 𑀪𑀺𑀓𑁆𑀔𑀽 𑀲𑀗𑁆𑀖𑀢𑁄, 𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀧𑀦 𑀧𑀼𑀕𑁆𑀕𑀮𑀸;

𑀅𑀝𑁆𑀞 𑀪𑀺𑀓𑁆𑀔𑀽 𑀪𑁄𑀚𑀬𑀺𑀢𑁆𑀯𑀸, 𑀫𑀫 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲;

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

𑁧𑁫𑁯.

𑀲𑀸𑀥𑀽𑀢𑀺 𑀲𑀸 𑀧𑀝𑀺𑀲𑁆𑀲𑀼𑀢𑁆𑀯𑀸, 𑀪𑁄𑀚𑀬𑀺𑀢𑁆𑀯𑀸𑀝𑁆𑀞 𑀪𑀺𑀓𑁆𑀔𑀯𑁄;

𑀯𑀢𑁆𑀣𑁂𑀳𑀘𑁆𑀙𑀸𑀤𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀢𑀲𑁆𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲𑀻.

𑁧𑁬𑁦.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂 ¶ , 𑀯𑀺𑀧𑀸𑀓𑁄 𑀉𑀤𑀧𑀚𑁆𑀚𑀣;

𑀪𑁄𑀚𑀦𑀘𑁆𑀙𑀸𑀤𑀦𑀧𑀸𑀦𑀻𑀬𑀁, 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬 𑀇𑀤𑀁 𑀨𑀮𑀁.

𑁧𑁬𑁧.

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

𑀯𑀺𑀘𑀺𑀢𑁆𑀢𑀯𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑀸, 𑀲𑀧𑀢𑁆𑀢𑀺𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺.

𑁧𑁬𑁨.

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

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

𑁧𑁬𑁩.

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

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

𑁧𑁬𑁪.

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

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

𑁧𑁬𑁫.

‘‘𑀅𑀳𑀁 𑀫𑀢𑁆𑀢𑀸 𑀢𑀼𑀯𑀁 𑀢𑀺𑀲𑁆𑀲𑀸, 𑀲𑀧𑀢𑁆𑀢𑀻 𑀢𑁂 𑀧𑀼𑀭𑁂 𑀅𑀳𑀼𑀁;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸.

𑁧𑁬𑁬.

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

𑀘𑀻𑀭𑀁 𑀚𑀻𑀯𑀸𑀳𑀺 𑀪𑀕𑀺𑀦𑀺, 𑀲𑀳 𑀲𑀩𑁆𑀩𑁂𑀳𑀺 𑀜𑀸𑀢𑀺𑀪𑀺;

𑀅𑀲𑁄𑀓𑀁 𑀯𑀺𑀭𑀚𑀁 𑀞𑀸𑀦𑀁, 𑀆𑀯𑀸𑀲𑀁 𑀯𑀲𑀯𑀢𑁆𑀢𑀺𑀦𑀁.

𑁧𑁬𑁭.

‘‘𑀇𑀥 ¶ 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀤𑀸𑀦𑀁 𑀤𑀢𑁆𑀯𑀸𑀦 𑀲𑁄𑀪𑀦𑁂;

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

𑀫𑀢𑁆𑀢𑀸𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀢𑀢𑀺𑀬𑀁.

𑁪. 𑀦𑀦𑁆𑀤𑀸𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁧𑁬𑁮.

‘‘𑀓𑀸𑀴𑀻 ¶ 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀲𑀺, 𑀨𑀭𑀼𑀲𑀸 𑀪𑀻𑀭𑀼𑀤𑀲𑁆𑀲𑀦𑀸;

𑀧𑀺𑀗𑁆𑀕𑀮𑀸𑀲𑀺 𑀓𑀴𑀸𑀭𑀸𑀲𑀺, 𑀦 𑀢𑀁 𑀫𑀜𑁆𑀜𑀸𑀫𑀺 𑀫𑀸𑀦𑀼𑀲𑀺’’𑀦𑁆𑀢𑀺.

𑁧𑁬𑁯.

‘‘𑀅𑀳𑀁 ¶ 𑀦𑀦𑁆𑀤𑀸 𑀦𑀦𑁆𑀤𑀺𑀲𑁂𑀦, 𑀪𑀭𑀺𑀬𑀸 𑀢𑁂 𑀧𑀼𑀭𑁂 𑀅𑀳𑀼𑀁;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁧𑁭𑁦.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁧𑁭𑁧.

‘‘𑀘𑀡𑁆𑀟𑀻 𑀘 𑀨𑀭𑀼𑀲𑀸 𑀘𑀸𑀲𑀺𑀁 [𑀘𑀡𑁆𑀟𑀻 𑀨𑀭𑀼𑀲𑀯𑀸𑀘𑀸 𑀘 (𑀲𑀻.)], 𑀢𑀬𑀺 𑀘𑀸𑀧𑀺 𑀅𑀕𑀸𑀭𑀯𑀸;

𑀢𑀸𑀳𑀁 𑀤𑀼𑀭𑀼𑀢𑁆𑀢𑀁 𑀯𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁧𑁭𑁨.

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

𑀇𑀫𑀁 𑀤𑀼𑀲𑁆𑀲𑀁 𑀦𑀺𑀯𑀸𑀲𑁂𑀢𑁆𑀯𑀸, 𑀏𑀳𑀺 𑀦𑁂𑀲𑁆𑀲𑀸𑀫𑀺 𑀢𑀁 𑀖𑀭𑀁.

𑁧𑁭𑁩.

‘‘𑀯𑀢𑁆𑀣𑀜𑁆𑀘 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑀜𑁆𑀘, 𑀮𑀘𑁆𑀙𑀲𑀺 𑀢𑁆𑀯𑀁 𑀖𑀭𑀁 𑀕𑀢𑀸;

𑀧𑀼𑀢𑁆𑀢𑁂 𑀘 𑀢𑁂 𑀧𑀲𑁆𑀲𑀺𑀲𑁆𑀲𑀲𑀺, 𑀲𑀼𑀡𑀺𑀲𑀸𑀬𑁄 𑀘 𑀤𑀓𑁆𑀔𑀲𑀻’’𑀢𑀺.

𑁧𑁭𑁪.

‘‘𑀳𑀢𑁆𑀣𑁂𑀦 𑀳𑀢𑁆𑀣𑁂 𑀢𑁂 𑀤𑀺𑀦𑁆𑀦𑀁, 𑀦 𑀫𑀬𑁆𑀳𑀁 𑀉𑀧𑀓𑀧𑁆𑀧𑀢𑀺;

𑀪𑀺𑀓𑁆𑀔𑀽 𑀘 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁂, 𑀯𑀻𑀢𑀭𑀸𑀕𑁂 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁂.

𑁧𑁭𑁫.

‘‘𑀢𑀧𑁆𑀧𑁂𑀳𑀺 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑁂𑀦, 𑀫𑀫 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲;

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

𑁧𑁭𑁬.

𑀲𑀸𑀥𑀽𑀢𑀺 𑀲𑁄 𑀧𑀝𑀺𑀲𑁆𑀲𑀼𑀢𑁆𑀯𑀸, 𑀤𑀸𑀦𑀁 𑀯𑀺𑀧𑀼𑀮𑀫𑀸𑀓𑀺𑀭𑀺;

𑀅𑀦𑁆𑀦𑀁 𑀧𑀸𑀦𑀁 𑀔𑀸𑀤𑀦𑀻𑀬𑀁, 𑀯𑀢𑁆𑀣𑀲𑁂𑀦𑀸𑀲𑀦𑀸𑀦𑀺 𑀘;

𑀙𑀢𑁆𑀢𑀁 𑀕𑀦𑁆𑀥𑀜𑁆𑀘 𑀫𑀸𑀮𑀜𑁆𑀘, 𑀯𑀺𑀯𑀺𑀥𑀸 𑀘 𑀉𑀧𑀸𑀳𑀦𑀸.

𑁧𑁭𑁭.

𑀪𑀺𑀓𑁆𑀔𑀽 𑀘 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁂, 𑀯𑀻𑀢𑀭𑀸𑀕𑁂 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁂;

𑀢𑀧𑁆𑀧𑁂𑀢𑁆𑀯𑀸 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑁂𑀦, 𑀢𑀲𑁆𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲𑀻.

𑁧𑁭𑁮.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂 ¶ , 𑀯𑀺𑀧𑀸𑀓𑁄 𑀉𑀤𑀧𑀚𑁆𑀚𑀣;

𑀪𑁄𑀚𑀦𑀘𑁆𑀙𑀸𑀤𑀦𑀧𑀸𑀦𑀻𑀬𑀁, 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬 𑀇𑀤𑀁 𑀨𑀮𑀁.

𑁧𑁭𑁯.

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

𑀯𑀺𑀘𑀺𑀢𑁆𑀢𑀯𑀢𑁆𑀣𑀸𑀪𑀭𑀡𑀸, 𑀲𑀸𑀫𑀺𑀓𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺.

𑁧𑁮𑁦.

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

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

𑁧𑁮𑁧.

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

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

𑁧𑁮𑁨.

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

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

𑁧𑁮𑁩.

‘‘𑀅𑀳𑀁 ¶ 𑀦𑀦𑁆𑀤𑀸 𑀦𑀦𑁆𑀤𑀺𑀲𑁂𑀦, 𑀪𑀭𑀺𑀬𑀸 𑀢𑁂 𑀧𑀼𑀭𑁂 𑀅𑀳𑀼𑀁;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸.

𑁧𑁮𑁪.

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

𑀘𑀺𑀭𑀁 𑀚𑀻𑀯 𑀕𑀳𑀧𑀢𑀺, 𑀲𑀳 𑀲𑀩𑁆𑀩𑁂𑀳𑀺 𑀜𑀸𑀢𑀺𑀪𑀺;

𑀅𑀲𑁄𑀓𑀁 𑀯𑀺𑀭𑀚𑀁 𑀔𑁂𑀫𑀁, 𑀆𑀯𑀸𑀲𑀁 𑀯𑀲𑀯𑀢𑁆𑀢𑀺𑀦𑀁.

𑁧𑁮𑁫.

‘‘𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀤𑀸𑀦𑀁 𑀤𑀢𑁆𑀯𑀸 𑀕𑀳𑀧𑀢𑀺;

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

𑀦𑀦𑁆𑀤𑀸𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

𑁫. 𑀫𑀝𑁆𑀞𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁧𑁮𑁬.

[𑀯𑀺. 𑀯. 𑁧𑁨𑁦𑁭] ‘‘𑀅𑀮𑀗𑁆𑀓𑀢𑁄 ¶ 𑀫𑀝𑁆𑀞𑀓𑀼𑀡𑁆𑀟𑀮𑀻, 𑀫𑀸𑀮𑀥𑀸𑀭𑀻 𑀳𑀭𑀺𑀘𑀦𑁆𑀤𑀦𑀼𑀲𑁆𑀲𑀤𑁄;

𑀩𑀸𑀳𑀸 𑀧𑀕𑁆𑀕𑀬𑁆𑀳 𑀓𑀦𑁆𑀤𑀲𑀺, 𑀯𑀦𑀫𑀚𑁆𑀛𑁂 𑀓𑀺𑀁 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁄 𑀢𑀼𑀯’’𑀦𑁆𑀢𑀺.

𑁧𑁮𑁭.

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑁄 𑀧𑀪𑀲𑁆𑀲𑀭𑁄, 𑀉𑀧𑁆𑀧𑀦𑁆𑀦𑁄 𑀭𑀣𑀧𑀜𑁆𑀚𑀭𑁄 𑀫𑀫;

𑀢𑀲𑁆𑀲 𑀘𑀓𑁆𑀓𑀬𑀼𑀕𑀁 𑀦 𑀯𑀺𑀦𑁆𑀤𑀸𑀫𑀺, 𑀢𑁂𑀦 𑀤𑀼𑀓𑁆𑀔𑁂𑀦 𑀚𑀳𑀸𑀫𑀺 𑀚𑀻𑀯𑀺𑀢’’𑀦𑁆𑀢𑀺.

𑁧𑁮𑁮.

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

𑀆𑀘𑀺𑀓𑁆𑀔 𑀫𑁂 𑀪𑀤𑁆𑀤𑀫𑀸𑀡𑀯, 𑀘𑀓𑁆𑀓𑀬𑀼𑀕𑀁 𑀧𑀝𑀺𑀧𑀸𑀤𑀬𑀸𑀫𑀺 𑀢𑁂’’𑀢𑀺.

𑁧𑁮𑁯.

𑀲𑁄 ¶ 𑀫𑀸𑀡𑀯𑁄 𑀢𑀲𑁆𑀲 𑀧𑀸𑀯𑀤𑀺, ‘‘𑀘𑀦𑁆𑀤𑀲𑀽𑀭𑀺𑀬𑀸 𑀉𑀪𑀬𑁂𑀢𑁆𑀣 𑀤𑀺𑀲𑁆𑀲𑀭𑁂;

𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑁄 𑀭𑀣𑁄 𑀫𑀫, 𑀢𑁂𑀦 𑀘𑀓𑁆𑀓𑀬𑀼𑀕𑁂𑀦 𑀲𑁄𑀪𑀢𑀻’’𑀢𑀺.

𑁧𑁯𑁦.

‘‘𑀩𑀸𑀮𑁄 𑀔𑁄 𑀢𑁆𑀯𑀁 𑀅𑀲𑀺 𑀫𑀸𑀡𑀯, 𑀬𑁄 𑀢𑁆𑀯𑀁 𑀧𑀢𑁆𑀣𑀬𑀲𑁂 𑀅𑀧𑀢𑁆𑀣𑀺𑀬𑀁;

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

𑁧𑁯𑁧.

‘‘𑀕𑀫𑀦𑀸𑀕𑀫𑀦𑀫𑁆𑀧𑀺 𑀤𑀺𑀲𑁆𑀲𑀢𑀺, 𑀯𑀡𑁆𑀡𑀥𑀸𑀢𑀼 𑀉𑀪𑀬𑀢𑁆𑀣 𑀯𑀻𑀣𑀺𑀬𑀸;

𑀧𑁂𑀢𑁄 𑀓𑀸𑀮𑀓𑀢𑁄 𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀺, 𑀓𑁄 𑀦𑀺𑀥 𑀓𑀦𑁆𑀤𑀢𑀁 𑀩𑀸𑀮𑁆𑀬𑀢𑀭𑁄’’𑀢𑀺.

𑁧𑁯𑁨.

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

𑀘𑀦𑁆𑀤𑀁 𑀯𑀺𑀬 𑀤𑀸𑀭𑀓𑁄 𑀭𑀼𑀤𑀁, 𑀧𑁂𑀢𑀁 𑀓𑀸𑀮𑀓𑀢𑀸𑀪𑀺𑀧𑀢𑁆𑀣𑀬𑀺’’𑀦𑁆𑀢𑀺.

𑁧𑁯𑁩.

‘‘𑀆𑀤𑀺𑀢𑁆𑀢𑀁 𑀯𑀢 𑀫𑀁 𑀲𑀦𑁆𑀢𑀁, 𑀖𑀢𑀲𑀺𑀢𑁆𑀢𑀁𑀯 𑀧𑀸𑀯𑀓𑀁;

𑀯𑀸𑀭𑀺𑀦𑀸 𑀯𑀺𑀬 𑀑𑀲𑀺𑀜𑁆𑀘𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀦𑀺𑀩𑁆𑀩𑀸𑀧𑀬𑁂 𑀤𑀭𑀁.

𑁧𑁯𑁪.

‘‘𑀅𑀩𑁆𑀩𑀳𑀻 [𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀢 𑀫𑁂 𑀲𑀮𑁆𑀮𑀁, 𑀲𑁄𑀓𑀁 𑀳𑀤𑀬𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁;

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

𑁧𑁯𑁫.

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀲𑀮𑁆𑀮𑁄𑀲𑁆𑀫𑀺, 𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑁄𑀲𑁆𑀫𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄;

𑀦 𑀲𑁄𑀘𑀸𑀫𑀺 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀢𑀯 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀫𑀸𑀡𑀯𑀸’’𑀢𑀺.

𑁧𑁯𑁬.

‘‘𑀤𑁂𑀯𑀢𑀸 ¶ 𑀦𑀼𑀲𑀺 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀅𑀤𑀼 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

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

𑁧𑁯𑁭.

‘‘𑀬𑀜𑁆𑀘 𑀓𑀦𑁆𑀤𑀲𑀺 𑀬𑀜𑁆𑀘 𑀭𑁄𑀤𑀲𑀺, 𑀧𑀼𑀢𑁆𑀢𑀁 𑀆𑀴𑀸𑀳𑀦𑁂 𑀲𑀬𑀁 𑀤𑀳𑀺𑀢𑁆𑀯𑀸;

𑀲𑁆𑀯𑀸𑀳𑀁 𑀓𑀼𑀲𑀮𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸 𑀓𑀫𑁆𑀫𑀁, 𑀢𑀺𑀤𑀲𑀸𑀦𑀁 𑀲𑀳𑀩𑁆𑀬𑀢𑀁 𑀕𑀢𑁄’’𑀢𑀺.

𑁧𑁯𑁮.

‘‘𑀅𑀧𑁆𑀧𑀁 ¶ 𑀯𑀸 𑀩𑀳𑀼𑀁 𑀯𑀸 𑀦𑀸𑀤𑁆𑀤𑀲𑀸𑀫, 𑀤𑀸𑀦𑀁 𑀤𑀤𑀦𑁆𑀢𑀲𑁆𑀲 𑀲𑀓𑁂 𑀅𑀕𑀸𑀭𑁂;

𑀉𑀧𑁄𑀲𑀣𑀓𑀫𑁆𑀫𑀁 𑀯𑀸 𑀢𑀸𑀤𑀺𑀲𑀁, 𑀓𑁂𑀦 𑀓𑀫𑁆𑀫𑁂𑀦 𑀕𑀢𑁄𑀲𑀺 𑀤𑁂𑀯𑀮𑁄𑀓’’𑀦𑁆𑀢𑀺.

𑁧𑁯𑁯.

‘‘𑀆𑀩𑀸𑀥𑀺𑀓𑁄𑀳𑀁 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁄 𑀕𑀺𑀮𑀸𑀦𑁄, 𑀆𑀢𑀼𑀭𑀭𑀽𑀧𑁄𑀫𑁆𑀳𑀺 𑀲𑀓𑁂 𑀦𑀺𑀯𑁂𑀲𑀦𑁂;

𑀩𑀼𑀤𑁆𑀥𑀁 𑀯𑀺𑀕𑀢𑀭𑀚𑀁 𑀯𑀺𑀢𑀺𑀡𑁆𑀡𑀓𑀗𑁆𑀔𑀁, 𑀅𑀤𑁆𑀤𑀓𑁆𑀔𑀺𑀁 𑀲𑀼𑀕𑀢𑀁 𑀅𑀦𑁄𑀫𑀧𑀜𑁆𑀜𑀁.

𑁨𑁦𑁦.

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

𑀢𑀸𑀳𑀁 𑀓𑀼𑀲𑀮𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦 𑀓𑀫𑁆𑀫𑀁, 𑀢𑀺𑀤𑀲𑀸𑀦𑀁 𑀲𑀳𑀩𑁆𑀬𑀢𑀁 𑀕𑀢𑁄’’𑀢𑀺.

𑁨𑁦𑁧.

‘‘𑀅𑀘𑁆𑀙𑀭𑀺𑀬𑀁 𑀯𑀢 𑀅𑀩𑁆𑀪𑀼𑀢𑀁 𑀯𑀢, 𑀅𑀜𑁆𑀚𑀮𑀺𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀅𑀬𑀫𑀻𑀤𑀺𑀲𑁄 𑀯𑀺𑀧𑀸𑀓𑁄;

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

𑁨𑁦𑁨.

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

𑀢𑀣𑁂𑀯 𑀲𑀺𑀓𑁆𑀔𑀸𑀬 𑀧𑀤𑀸𑀦𑀺 𑀧𑀜𑁆𑀘, 𑀅𑀔𑀡𑁆𑀟𑀨𑀼𑀮𑁆𑀮𑀸𑀦𑀺 𑀲𑀫𑀸𑀤𑀺𑀬𑀲𑁆𑀲𑀼.

𑁨𑁦𑁩.

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

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀫𑀸 𑀘 𑀫𑀼𑀲𑀸 𑀪𑀡𑀸𑀳𑀺, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀳𑀺 𑀢𑀼𑀝𑁆𑀞𑁄’’𑀢𑀺.

𑁨𑁦𑁪.

‘‘𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑁄𑀲𑀺 𑀫𑁂 𑀬𑀓𑁆𑀔, 𑀳𑀺𑀢𑀓𑀸𑀫𑁄𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

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

𑁨𑁦𑁫.

‘‘𑀉𑀧𑁂𑀫𑀺 𑀲𑀭𑀡𑀁 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘𑀸𑀧𑀺 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑀁;

𑀲𑀗𑁆𑀖𑀜𑁆𑀘 𑀦𑀭𑀤𑁂𑀯𑀲𑁆𑀲, 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀲𑀭𑀡𑀁 𑀅𑀳𑀁.

𑁨𑁦𑁬.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 ¶ 𑀯𑀺𑀭𑀫𑀸𑀫𑀺 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀸𑀫𑀺;

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀦𑁄 𑀘 𑀫𑀼𑀲𑀸 𑀪𑀡𑀸𑀫𑀺; 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀫𑀺 𑀢𑀼𑀝𑁆𑀞𑁄’’𑀢𑀺.

𑀫𑀝𑁆𑀞𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀧𑀜𑁆𑀘𑀫𑀁.

𑁬. 𑀓𑀡𑁆𑀳𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁨𑁦𑁭.

‘‘𑀉𑀝𑁆𑀞𑁂𑀳𑀺 ¶ 𑀓𑀡𑁆𑀳 𑀓𑀺𑀁 𑀲𑁂𑀲𑀺, 𑀓𑁄 𑀅𑀢𑁆𑀣𑁄 𑀲𑀼𑀧𑀦𑁂𑀦 𑀢𑁂;

𑀬𑁄 𑀘 𑀢𑀼𑀬𑁆𑀳𑀁 𑀲𑀓𑁄 𑀪𑀸𑀢𑀸, 𑀳𑀤𑀬𑀁 𑀘𑀓𑁆𑀔𑀼 𑀘 [𑀘𑀓𑁆𑀔𑀼𑀁𑀯 (𑀅𑀝𑁆𑀞.)] 𑀤𑀓𑁆𑀔𑀺𑀡𑀁;

𑀢𑀲𑁆𑀲 𑀯𑀸𑀢𑀸 𑀩𑀮𑀻𑀬𑀦𑁆𑀢𑀺, 𑀲𑀲𑀁 𑀚𑀧𑁆𑀧𑀢𑀺 [𑀖𑀝𑁄 𑀚𑀧𑁆𑀧𑀢𑀺 (𑀓.)] 𑀓𑁂𑀲𑀯𑀸’’𑀢𑀺.

𑁨𑁦𑁮.

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

𑀢𑀭𑀫𑀸𑀦𑀭𑀽𑀧𑁄 𑀯𑀼𑀝𑁆𑀞𑀸𑀲𑀺, 𑀪𑀸𑀢𑀼𑀲𑁄𑀓𑁂𑀦 𑀅𑀝𑁆𑀝𑀺𑀢𑁄.

𑁨𑁦𑁯.

‘‘𑀓𑀺𑀁 𑀦𑀼 𑀉𑀫𑁆𑀫𑀢𑁆𑀢𑀭𑀽𑀧𑁄𑀯, 𑀓𑁂𑀯𑀮𑀁 𑀤𑁆𑀯𑀸𑀭𑀓𑀁 𑀇𑀫𑀁;

𑀲𑀲𑁄 𑀲𑀲𑁄𑀢𑀺 𑀮𑀧𑀲𑀺, 𑀓𑀻𑀤𑀺𑀲𑀁 𑀲𑀲𑀫𑀺𑀘𑁆𑀙𑀲𑀺.

𑁨𑁧𑁦.

‘‘𑀲𑁄𑀯𑀡𑁆𑀡𑀫𑀬𑀁 𑀫𑀡𑀺𑀫𑀬𑀁, 𑀮𑁄𑀳𑀫𑀬𑀁 𑀅𑀣 𑀭𑀽𑀧𑀺𑀬𑀫𑀬𑀁;

𑀲𑀗𑁆𑀔𑀲𑀺𑀮𑀸𑀧𑀯𑀸𑀴𑀫𑀬𑀁, 𑀓𑀸𑀭𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀢𑁂 𑀲𑀲𑀁.

𑁨𑁧𑁧.

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

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

𑁨𑁧𑁨.

‘‘𑀦𑀸𑀳𑀫𑁂𑀢𑁂 𑀲𑀲𑁂 𑀇𑀘𑁆𑀙𑁂, 𑀬𑁂 𑀲𑀲𑀸 𑀧𑀣𑀯𑀺𑀲𑁆𑀲𑀺𑀢𑀸;

𑀘𑀦𑁆𑀤𑀢𑁄 𑀲𑀲𑀫𑀺𑀘𑁆𑀙𑀸𑀫𑀺, 𑀢𑀁 𑀫𑁂 𑀑𑀳𑀭 𑀓𑁂𑀲𑀯𑀸’’𑀢𑀺.

𑁨𑁧𑁩.

‘‘𑀲𑁄 𑀦𑀽𑀦 𑀫𑀥𑀼𑀭𑀁 𑀜𑀸𑀢𑀺, 𑀚𑀻𑀯𑀺𑀢𑀁 𑀯𑀺𑀚𑀳𑀺𑀲𑁆𑀲𑀲𑀺;

𑀅𑀧𑀢𑁆𑀣𑀺𑀬𑀁 𑀧𑀢𑁆𑀣𑀬𑀲𑀺, 𑀘𑀦𑁆𑀤𑀢𑁄 𑀲𑀲𑀫𑀺𑀘𑁆𑀙𑀲𑀻’’𑀢𑀺.

𑁨𑁧𑁪.

‘‘𑀏𑀯𑀁 𑀘𑁂 𑀓𑀡𑁆𑀳 𑀚𑀸𑀦𑀸𑀲𑀺, 𑀬𑀣𑀜𑁆𑀜𑀫𑀦𑀼𑀲𑀸𑀲𑀲𑀺;

𑀓𑀲𑁆𑀫𑀸 ¶ 𑀧𑀼𑀭𑁂 𑀫𑀢𑀁 𑀧𑀼𑀢𑁆𑀢𑀁, 𑀅𑀚𑁆𑀚𑀸𑀧𑀺 𑀫𑀦𑀼𑀲𑁄𑀘𑀲𑀺.

𑁨𑁧𑁫.

‘‘𑀦 𑀬𑀁 𑀮𑀩𑁆𑀪𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀦, 𑀅𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀦 𑀯𑀸 𑀧𑀦;

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

𑁨𑁧𑁬.

‘‘𑀦 ¶ 𑀫𑀦𑁆𑀢𑀸 𑀫𑀽𑀮𑀪𑁂𑀲𑀚𑁆𑀚𑀸, 𑀑𑀲𑀥𑁂𑀳𑀺 𑀥𑀦𑁂𑀦 𑀯𑀸;

𑀲𑀓𑁆𑀓𑀸 𑀆𑀦𑀬𑀺𑀢𑀼𑀁 𑀓𑀡𑁆𑀳, 𑀬𑀁 𑀧𑁂𑀢𑀫𑀦𑀼𑀲𑁄𑀘𑀲𑀺.

𑁨𑁧𑁭.

‘‘𑀫𑀳𑀤𑁆𑀥𑀦𑀸 ¶ 𑀫𑀳𑀸𑀪𑁄𑀕𑀸, 𑀭𑀝𑁆𑀞𑀯𑀦𑁆𑀢𑁄𑀧𑀺 𑀔𑀢𑁆𑀢𑀺𑀬𑀸;

𑀧𑀳𑀽𑀢𑀥𑀦𑀥𑀜𑁆𑀜𑀸𑀲𑁂, 𑀢𑁂𑀧𑀺 𑀦𑁄 [𑀦𑀢𑁆𑀣𑁂𑀢𑁆𑀣𑀧𑀸𑀞𑀪𑁂𑀤𑁄] 𑀅𑀚𑀭𑀸𑀫𑀭𑀸.

𑁨𑁧𑁮.

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

𑀏𑀢𑁂 𑀘𑀜𑁆𑀜𑁂 𑀘 𑀚𑀸𑀢𑀺𑀬𑀸, 𑀢𑁂𑀧𑀺 𑀦𑁄 𑀅𑀚𑀭𑀸𑀫𑀭𑀸.

𑁨𑁧𑁯.

‘‘𑀬𑁂 𑀫𑀦𑁆𑀢𑀁 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑁂𑀦𑁆𑀢𑀺, 𑀙𑀴𑀗𑁆𑀕𑀁 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀺𑀦𑁆𑀢𑀺𑀢𑀁;

𑀏𑀢𑁂 𑀘𑀜𑁆𑀜𑁂 𑀘 𑀯𑀺𑀚𑁆𑀚𑀸𑀬, 𑀢𑁂𑀧𑀺 𑀦𑁄 𑀅𑀚𑀭𑀸𑀫𑀭𑀸.

𑁨𑁨𑁦.

‘‘𑀇𑀲𑀬𑁄 𑀯𑀸𑀧𑀺 [𑀇𑀲𑀬𑁄 𑀘𑀸𑀧𑀺 (𑀯𑀺𑀫𑀸𑀦𑀯𑀢𑁆𑀣𑀼 𑁯𑁯)] 𑀬𑁂 𑀲𑀦𑁆𑀢𑀸, 𑀲𑀜𑁆𑀜𑀢𑀢𑁆𑀢𑀸 𑀢𑀧𑀲𑁆𑀲𑀺𑀦𑁄;

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

𑁨𑁨𑁧.

‘‘𑀪𑀸𑀯𑀺𑀢𑀢𑁆𑀢𑀸 𑀅𑀭𑀳𑀦𑁆𑀢𑁄, 𑀓𑀢𑀓𑀺𑀘𑁆𑀘𑀸 𑀅𑀦𑀸𑀲𑀯𑀸;

𑀦𑀺𑀓𑁆𑀔𑀺𑀧𑀦𑁆𑀢𑀺 𑀇𑀫𑀁 𑀤𑁂𑀳𑀁, 𑀧𑀼𑀜𑁆𑀜𑀧𑀸𑀧𑀧𑀭𑀺𑀓𑁆𑀔𑀬𑀸’’𑀢𑀺.

𑁨𑁨𑁨.

‘‘𑀆𑀤𑀺𑀢𑁆𑀢𑀁 𑀯𑀢 𑀫𑀁 𑀲𑀦𑁆𑀢𑀁, 𑀖𑀢𑀲𑀺𑀢𑁆𑀢𑀁𑀯 𑀧𑀸𑀯𑀓𑀁;

𑀯𑀸𑀭𑀺𑀦𑀸 𑀯𑀺𑀬 𑀑𑀲𑀺𑀜𑁆𑀘𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀦𑀺𑀩𑁆𑀩𑀸𑀧𑀬𑁂 𑀤𑀭𑀁.

𑁨𑁨𑁩.

‘‘𑀅𑀩𑁆𑀩𑀳𑀻 ¶ 𑀯𑀢 𑀫𑁂 𑀲𑀮𑁆𑀮𑀁, 𑀲𑁄𑀓𑀁 𑀳𑀤𑀬𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁;

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

𑁨𑁨𑁪.

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 ¶ 𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀲𑀮𑁆𑀮𑁄𑀲𑁆𑀫𑀺, 𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑁄𑀲𑁆𑀫𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑁄;

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

𑁨𑁨𑁫.

𑀏𑀯𑀁 𑀓𑀭𑁄𑀦𑁆𑀢𑀺 𑀲𑀧𑁆𑀧𑀜𑁆𑀜𑀸, 𑀬𑁂 𑀳𑁄𑀦𑁆𑀢𑀺 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀸;

𑀦𑀺𑀯𑀢𑁆𑀢𑀬𑀦𑁆𑀢𑀺 𑀲𑁄𑀓𑀫𑁆𑀳𑀸, 𑀖𑀝𑁄 𑀚𑁂𑀝𑁆𑀞𑀁𑀯 𑀪𑀸𑀢𑀭𑀁.

𑁨𑁨𑁬.

𑀬𑀲𑁆𑀲 𑀏𑀢𑀸𑀤𑀺𑀲𑀸 𑀳𑁄𑀦𑁆𑀢𑀺, 𑀅𑀫𑀘𑁆𑀘𑀸 𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑀸;

𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑁂𑀦 𑀅𑀦𑁆𑀯𑁂𑀦𑁆𑀢𑀺, 𑀖𑀝𑁄 𑀚𑁂𑀝𑁆𑀞𑀁𑀯 𑀪𑀸𑀢𑀭𑀦𑁆𑀢𑀺.

𑀓𑀡𑁆𑀳𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀙𑀝𑁆𑀞𑀁.

𑁭. 𑀥𑀦𑀧𑀸𑀮𑀲𑁂𑀝𑁆𑀞𑀺𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁨𑁨𑁭.

‘‘𑀦𑀕𑁆𑀕𑁄 ¶ ¶ 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑁄𑀲𑀺, 𑀓𑀺𑀲𑁄 𑀥𑀫𑀦𑀺𑀲𑀦𑁆𑀣𑀢𑁄;

𑀉𑀧𑁆𑀨𑀸𑀲𑀼𑀮𑀺𑀓𑁄 𑀓𑀺𑀲𑀺𑀓𑁄, 𑀓𑁄 𑀦𑀼 𑀢𑁆𑀯𑀫𑀲𑀺 𑀫𑀸𑀭𑀺𑀲’’.

𑁨𑁨𑁮.

‘‘𑀅𑀳𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀧𑁂𑀢𑁄𑀫𑁆𑀳𑀺, 𑀤𑀼𑀕𑁆𑀕𑀢𑁄 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑁄;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑁄’’.

𑁨𑁨𑁯.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑁄’’.

𑁨𑁩𑁦.

‘‘𑀦𑀕𑀭𑀁 𑀅𑀢𑁆𑀣𑀺 𑀧𑀡𑁆𑀡𑀸𑀦𑀁 [𑀤𑀲𑀦𑁆𑀦𑀸𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)], 𑀏𑀭𑀓𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑀁;

𑀢𑀢𑁆𑀣 𑀲𑁂𑀝𑁆𑀞𑀺 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺𑀁, 𑀥𑀦𑀧𑀸𑀮𑁄𑀢𑀺 𑀫𑀁 𑀯𑀺𑀤𑀽.

𑁨𑁩𑁧.

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

𑀧𑀳𑀽𑀢𑀁 𑀫𑁂 𑀚𑀸𑀢𑀭𑀽𑀧𑀁, 𑀫𑀼𑀢𑁆𑀢𑀸 𑀯𑁂𑀴𑀼𑀭𑀺𑀬𑀸 𑀩𑀳𑀽.

𑁨𑁩𑁨.

‘‘𑀢𑀸𑀯 𑀫𑀳𑀤𑁆𑀥𑀦𑀲𑁆𑀲𑀸𑀧𑀺, 𑀦 𑀫𑁂 𑀤𑀸𑀢𑀼𑀁 𑀧𑀺𑀬𑀁 𑀅𑀳𑀼;

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

𑁨𑁩𑁩.

‘‘𑀅𑀲𑁆𑀲𑀤𑁆𑀥𑁄 𑀫𑀘𑁆𑀙𑀭𑀻 𑀘𑀸𑀲𑀺𑀁, 𑀓𑀤𑀭𑀺𑀬𑁄 𑀧𑀭𑀺𑀪𑀸𑀲𑀓𑁄;

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

𑁨𑁩𑁪.

‘‘𑀯𑀺𑀧𑀸𑀓𑁄 ¶ 𑀦𑀢𑁆𑀣𑀺 𑀤𑀸𑀦𑀲𑁆𑀲, 𑀲𑀁𑀬𑀫𑀲𑁆𑀲 𑀓𑀼𑀢𑁄 𑀨𑀮𑀁;

𑀧𑁄𑀓𑁆𑀔𑀭𑀜𑁆𑀜𑁄𑀤𑀧𑀸𑀦𑀸𑀦𑀺, 𑀆𑀭𑀸𑀫𑀸𑀦𑀺 𑀘 𑀭𑁄𑀧𑀺𑀢𑁂;

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

𑁨𑁩𑁫.

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 ¶ 𑀅𑀓𑀢𑀓𑀮𑁆𑀬𑀸𑀡𑁄, 𑀓𑀢𑀧𑀸𑀧𑁄 𑀢𑀢𑁄 𑀘𑀼𑀢𑁄;

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

𑁨𑁩𑁬.

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

𑀦𑀸𑀪𑀺𑀚𑀸𑀦𑀸𑀫𑀺 𑀪𑀼𑀢𑁆𑀢𑀁 𑀯𑀸, 𑀧𑀻𑀢𑀁 𑀯𑀸 𑀧𑀦 𑀧𑀸𑀦𑀺𑀬𑀁.

𑁨𑁩𑁭.

‘‘𑀬𑁄 𑀲𑀁𑀬𑀫𑁄 𑀲𑁄 𑀯𑀺𑀦𑀸𑀲𑁄,𑀬𑁄 𑀯𑀺𑀦𑀸𑀲𑁄 𑀲𑁄 𑀲𑀁𑀬𑀫𑁄;

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

𑁨𑁩𑁮.

‘‘𑀅𑀳𑀁 ¶ 𑀧𑀼𑀭𑁂 𑀲𑀁𑀬𑀫𑀺𑀲𑁆𑀲𑀁, 𑀦𑀸𑀤𑀸𑀲𑀺𑀁 𑀩𑀳𑀼𑀓𑁂 𑀥𑀦𑁂;

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

𑀲𑁆𑀯𑀸𑀳𑀁 𑀧𑀘𑁆𑀙𑀸𑀦𑀼𑀢𑀧𑁆𑀧𑀸𑀫𑀺, 𑀅𑀢𑁆𑀢𑀓𑀫𑁆𑀫𑀨𑀮𑀽𑀧𑀕𑁄.

𑁨𑁩𑁯.

[𑀧𑁂. 𑀯. 𑁬𑁯] ‘‘𑀉𑀤𑁆𑀥𑀁 𑀘𑀢𑀽𑀳𑀺 𑀫𑀸𑀲𑁂𑀳𑀺, 𑀓𑀸𑀮𑀁𑀓𑀺𑀭𑀺𑀬𑀸 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺;

𑀏𑀓𑀦𑁆𑀢𑀓𑀝𑀼𑀓𑀁 𑀖𑁄𑀭𑀁, 𑀦𑀺𑀭𑀬𑀁 𑀧𑀧𑀢𑀺𑀲𑁆𑀲𑀳𑀁.

𑁨𑁪𑁦.

[𑀧𑁂. 𑀯. 𑁭𑁦] ‘‘𑀘𑀢𑀼𑀓𑁆𑀓𑀡𑁆𑀡𑀁 𑀘𑀢𑀼𑀤𑁆𑀯𑀸𑀭𑀁, 𑀯𑀺𑀪𑀢𑁆𑀢𑀁 𑀪𑀸𑀕𑀲𑁄 𑀫𑀺𑀢𑀁;

𑀅𑀬𑁄𑀧𑀸𑀓𑀸𑀭𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀁, 𑀅𑀬𑀲𑀸 𑀧𑀝𑀺𑀓𑀼𑀚𑁆𑀚𑀺𑀢𑀁.

𑁨𑁪𑁧.

[𑀧𑁂. 𑀯. 𑁭𑁧] ‘‘𑀢𑀲𑁆𑀲 ¶ 𑀅𑀬𑁄𑀫𑀬𑀸 𑀪𑀽𑀫𑀺, 𑀚𑀮𑀺𑀢𑀸 𑀢𑁂𑀚𑀲𑀸 𑀬𑀼𑀢𑀸;

𑀲𑀫𑀦𑁆𑀢𑀸 𑀬𑁄𑀚𑀦𑀲𑀢𑀁, 𑀨𑀭𑀺𑀢𑁆𑀯𑀸 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀲𑀩𑁆𑀩𑀤𑀸.

𑁨𑁪𑁨.

[𑀧𑁂. 𑀯. 𑁭𑁨] ‘‘𑀢𑀢𑁆𑀣𑀸𑀳𑀁 𑀤𑀻𑀖𑀫𑀤𑁆𑀥𑀸𑀦𑀁, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀯𑁂𑀤𑀺𑀲𑁆𑀲 𑀯𑁂𑀤𑀦𑀁;

𑀨𑀮𑀁 𑀧𑀸𑀧𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲, 𑀢𑀲𑁆𑀫𑀸 𑀲𑁄𑀘𑀸𑀫𑀳𑀁 𑀪𑀼𑀲𑀁.

𑁨𑁪𑁩.

‘‘𑀢𑀁 𑀯𑁄 𑀯𑀤𑀸𑀫𑀺 𑀪𑀤𑁆𑀤𑀁 𑀯𑁄, 𑀬𑀸𑀯𑀦𑁆𑀢𑁂𑀢𑁆𑀣 𑀲𑀫𑀸𑀕𑀢𑀸;

𑀫𑀸𑀓𑀢𑁆𑀣 𑀧𑀸𑀧𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀆𑀯𑀺 𑀯𑀸 𑀬𑀤𑀺 𑀯𑀸 𑀭𑀳𑁄.

𑁨𑁪𑁪.

‘‘𑀲𑀘𑁂 𑀢𑀁 𑀧𑀸𑀧𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀓𑀭𑀺𑀲𑁆𑀲𑀣 𑀓𑀭𑁄𑀣 𑀯𑀸;

𑀦 𑀯𑁄 𑀤𑀼𑀓𑁆𑀔𑀸 𑀧𑀫𑀼𑀢𑁆𑀬𑀢𑁆𑀣𑀺 [𑀧𑀫𑀼𑀢𑁆𑀢𑀢𑁆𑀣𑀺 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣) 𑀉𑀤𑀸. 𑁪𑁪 𑀧𑀲𑁆𑀲𑀺𑀢𑀩𑁆𑀩𑀁], 𑀉𑀧𑁆𑀧𑀘𑁆𑀘𑀸𑀧𑀺 [𑀉𑀧𑁂𑀘𑁆𑀘𑀸𑀧𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀧𑀮𑀸𑀬𑀢𑀁.

𑁨𑁪𑁫.

‘‘𑀫𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑀸 𑀳𑁄𑀣 𑀧𑁂𑀢𑁆𑀢𑁂𑀬𑁆𑀬𑀸, 𑀓𑀼𑀮𑁂 𑀚𑁂𑀝𑁆𑀞𑀸𑀧𑀘𑀸𑀬𑀺𑀓𑀸;

𑀲𑀸𑀫𑀜𑁆𑀜𑀸 𑀳𑁄𑀣 𑀩𑁆𑀭𑀳𑁆𑀫𑀜𑁆𑀜𑀸, 𑀏𑀯𑀁 𑀲𑀕𑁆𑀕𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀣𑀸’’𑀢𑀺.

𑀥𑀦𑀧𑀸𑀮𑀲𑁂𑀝𑁆𑀞𑀺𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀲𑀢𑁆𑀢𑀫𑀁.

𑁮. 𑀘𑀽𑀴𑀲𑁂𑀝𑁆𑀞𑀺𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁨𑁪𑁬.

‘‘𑀦𑀕𑁆𑀕𑁄 ¶ 𑀓𑀺𑀲𑁄 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁄𑀲𑀺 𑀪𑀦𑁆𑀢𑁂, 𑀭𑀢𑁆𑀢𑀺𑀁 𑀓𑀼𑀳𑀺𑀁 𑀕𑀘𑁆𑀙𑀲𑀺 𑀓𑀺𑀲𑁆𑀲 𑀳𑁂𑀢𑀼;

𑀆𑀘𑀺𑀓𑁆𑀔 𑀫𑁂 𑀢𑀁 𑀅𑀧𑀺 𑀲𑀓𑁆𑀓𑀼𑀡𑁂𑀫𑀼, 𑀲𑀩𑁆𑀩𑁂𑀦 𑀯𑀺𑀢𑁆𑀢𑀁 𑀧𑀝𑀺𑀧𑀸𑀤𑀬𑁂 𑀢𑀼𑀯’’𑀦𑁆𑀢𑀺.

𑁨𑁪𑁭.

‘‘𑀩𑀸𑀭𑀸𑀡𑀲𑀻 ¶ ¶ ¶ 𑀦𑀕𑀭𑀁 𑀤𑀽𑀭𑀖𑀼𑀝𑁆𑀞𑀁, 𑀢𑀢𑁆𑀣𑀸𑀳𑀁 𑀕𑀳𑀧𑀢𑀺 𑀅𑀟𑁆𑀠𑀓𑁄 𑀅𑀳𑀼 𑀤𑀻𑀦𑁄;

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

𑁨𑁪𑁮.

‘‘𑀲𑁄 𑀲𑀽𑀘𑀺𑀓𑀸𑀬 𑀓𑀺𑀮𑀫𑀺𑀢𑁄 𑀢𑁂𑀳𑀺,

𑀢𑁂𑀦𑁂𑀯 𑀜𑀸𑀢𑀻𑀲𑀼 𑀬𑀸𑀫𑀺 𑀆𑀫𑀺𑀲𑀓𑀺𑀜𑁆𑀘𑀺𑀓𑁆𑀔𑀳𑁂𑀢𑀼;

𑀅𑀤𑀸𑀦𑀲𑀻𑀮𑀸 𑀦 𑀘 𑀲𑀤𑁆𑀤𑀳𑀦𑁆𑀢𑀺,

𑀤𑀸𑀦𑀨𑀮𑀁 𑀳𑁄𑀢𑀺 𑀧𑀭𑀫𑁆𑀳𑀺 𑀮𑁄𑀓𑁂.

𑁨𑁪𑁯.

‘‘𑀥𑀻𑀢𑀸 ¶ 𑀘 𑀫𑀬𑁆𑀳𑀁 𑀮𑀧𑀢𑁂 𑀅𑀪𑀺𑀓𑁆𑀔𑀡𑀁, ‘𑀤𑀲𑁆𑀲𑀸𑀫𑀺 𑀤𑀸𑀦𑀁 𑀧𑀺𑀢𑀽𑀦𑀁 𑀧𑀺𑀢𑀸𑀫𑀳𑀸𑀦𑀁’;

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

𑁨𑁫𑁦.

𑀢𑀫𑀯𑁄𑀘 𑀭𑀸𑀚𑀸 ‘‘𑀅𑀦𑀼𑀪𑀯𑀺𑀬𑀸𑀦 𑀢𑀫𑁆𑀧𑀺,

𑀏𑀬𑁆𑀬𑀸𑀲𑀺 𑀔𑀺𑀧𑁆𑀧𑀁 𑀅𑀳𑀫𑀧𑀺 𑀓𑀲𑁆𑀲𑀁 𑀧𑀽𑀚𑀁;

𑀆𑀘𑀺𑀓𑁆𑀔 𑀫𑁂 𑀢𑀁 𑀬𑀤𑀺 𑀅𑀢𑁆𑀣𑀺 𑀳𑁂𑀢𑀼,

𑀲𑀤𑁆𑀥𑀸𑀬𑀺𑀢𑀁 𑀳𑁂𑀢𑀼𑀯𑀘𑁄 𑀲𑀼𑀡𑁄𑀫𑀸’’𑀢𑀺.

𑁨𑁫𑁧.

‘𑀢𑀣𑀸’𑀢𑀺 𑀯𑀢𑁆𑀯𑀸 𑀅𑀕𑀫𑀸𑀲𑀺 𑀢𑀢𑁆𑀣, 𑀪𑀼𑀜𑁆𑀚𑀺𑀁𑀲𑀼 𑀪𑀢𑁆𑀢𑀁 𑀦 𑀘 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀭𑀳𑀸;

𑀧𑀘𑁆𑀘𑀸𑀕𑀫𑀺 ¶ 𑀭𑀸𑀚𑀕𑀳𑀁 𑀧𑀼𑀦𑀸𑀧𑀭𑀁, 𑀧𑀸𑀢𑀼𑀭𑀳𑁄𑀲𑀺 𑀧𑀼𑀭𑀢𑁄 𑀚𑀦𑀸𑀥𑀺𑀧𑀲𑁆𑀲.

𑁨𑁫𑁨.

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

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

𑁨𑁫𑁩.

‘‘𑀩𑀼𑀤𑁆𑀥𑀜𑁆𑀘 𑀲𑀗𑁆𑀖𑀁 𑀧𑀭𑀺𑀯𑀺𑀲𑀺𑀬𑀸𑀦 𑀭𑀸𑀚, 𑀅𑀦𑁆𑀦𑁂𑀦 𑀧𑀸𑀦𑁂𑀦 𑀘 𑀘𑀻𑀯𑀭𑁂𑀦;

𑀢𑀁 𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀆𑀤𑀺𑀲 𑀫𑁂 𑀳𑀺𑀢𑀸𑀬, 𑀏𑀯𑀁 𑀅𑀳𑀁 𑀘𑀺𑀭𑀢𑀭𑀁 𑀧𑀻𑀡𑀺𑀢𑁄 𑀲𑀺𑀬𑀸’’𑀢𑀺.

𑁨𑁫𑁪.

𑀢𑀢𑁄 ¶ 𑀘 𑀭𑀸𑀚𑀸 𑀦𑀺𑀧𑀢𑀺𑀢𑁆𑀯𑀸 𑀢𑀸𑀯𑀤𑁂 [𑀢𑀸𑀯𑀤𑁂𑀯 (𑀲𑁆𑀬𑀸.), 𑀢𑀤𑁂𑀯 (𑀓.)], 𑀤𑀸𑀦𑀁 𑀲𑀳𑀢𑁆𑀣𑀸 𑀅𑀢𑀼𑀮𑀁 𑀤𑀤𑀺𑀢𑁆𑀯𑀸 [𑀅𑀢𑀼𑀮𑀜𑁆𑀘 𑀤𑀢𑁆𑀯𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀲𑀗𑁆𑀖𑁂;

𑀆𑀭𑁄𑀘𑁂𑀲𑀺 𑀧𑀓𑀢𑀁 [𑀆𑀭𑁄𑀘𑀬𑀻 𑀧𑀓𑀢𑀺𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀢𑀣𑀸𑀕𑀢𑀲𑁆𑀲, 𑀢𑀲𑁆𑀲 𑀘 𑀧𑁂𑀢𑀲𑁆𑀲 𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀆𑀤𑀺𑀲𑀺𑀢𑁆𑀣.

𑁨𑁫𑁫.

𑀲𑁄 𑀧𑀽𑀚𑀺𑀢𑁄 𑀅𑀢𑀺𑀯𑀺𑀬 𑀲𑁄𑀪𑀫𑀸𑀦𑁄, 𑀧𑀸𑀢𑀼𑀭𑀳𑁄𑀲𑀺 𑀧𑀼𑀭𑀢𑁄 𑀚𑀦𑀸𑀥𑀺𑀧𑀲𑁆𑀲;

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

𑁨𑁫𑁬.

‘‘𑀧𑀲𑁆𑀲𑀸𑀦𑀼𑀪𑀸𑀯𑀁 𑀅𑀧𑀭𑀺𑀫𑀺𑀢𑀁 𑀫𑀫𑀬𑀺𑀤𑀁, 𑀢𑀬𑀸𑀦𑀼𑀤𑀺𑀝𑁆𑀞𑀁 ¶ 𑀅𑀢𑀼𑀮𑀁 𑀤𑀢𑁆𑀯𑀸 𑀲𑀗𑁆𑀖𑁂;

𑀲𑀦𑁆𑀢𑀧𑁆𑀧𑀺𑀢𑁄 𑀲𑀢𑀢𑀁 𑀲𑀤𑀸 𑀩𑀳𑀽𑀳𑀺, 𑀬𑀸𑀫𑀺 𑀅𑀳𑀁 𑀲𑀼𑀔𑀺𑀢𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀤𑁂𑀯𑀸’’𑀢𑀺.

𑀘𑀽𑀴𑀲𑁂𑀝𑁆𑀞𑀺𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀅𑀝𑁆𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑀪𑀸𑀡𑀯𑀸𑀭𑀁 𑀧𑀞𑀫𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁯. 𑀅𑀗𑁆𑀓𑀼𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁨𑁫𑁭.

‘‘𑀬𑀲𑁆𑀲 ¶ ¶ 𑀅𑀢𑁆𑀣𑀸𑀬 𑀕𑀘𑁆𑀙𑀸𑀫, 𑀓𑀫𑁆𑀩𑁄𑀚𑀁 𑀥𑀦𑀳𑀸𑀭𑀓𑀸;

𑀅𑀬𑀁 𑀓𑀸𑀫𑀤𑀤𑁄 𑀬𑀓𑁆𑀔𑁄, 𑀇𑀫𑀁 𑀬𑀓𑁆𑀔𑀁 𑀦𑀬𑀸𑀫𑀲𑁂.

𑁨𑁫𑁮.

‘‘𑀇𑀫𑀁 𑀬𑀓𑁆𑀔𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀲𑀸𑀥𑀼𑀓𑁂𑀦 𑀧𑀲𑀬𑁆𑀳 𑀯𑀸;

𑀬𑀸𑀦𑀁 𑀆𑀭𑁄𑀧𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀔𑀺𑀧𑁆𑀧𑀁 𑀕𑀘𑁆𑀙𑀸𑀫 𑀤𑁆𑀯𑀸𑀭𑀓’’𑀦𑁆𑀢𑀺.

𑁨𑁫𑁯.

[𑀚𑀸. 𑁧.𑁧𑁦.𑁧𑁫𑁧; 𑁧.𑁧𑁪.𑁧𑁯𑁬; 𑁨.𑁧𑁮.𑁧𑁫𑁩; 𑁨.𑁨𑁨.𑁧𑁦] ‘‘𑀬𑀲𑁆𑀲 𑀭𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀙𑀸𑀬𑀸𑀬, 𑀦𑀺𑀲𑀻𑀤𑁂𑀬𑁆𑀬 𑀲𑀬𑁂𑀬𑁆𑀬 𑀯𑀸;

𑀦 𑀢𑀲𑁆𑀲 𑀲𑀸𑀔𑀁 𑀪𑀜𑁆𑀚𑁂𑀬𑁆𑀬, 𑀫𑀺𑀢𑁆𑀢𑀤𑀼𑀩𑁆𑀪𑁄 𑀳𑀺 𑀧𑀸𑀧𑀓𑁄’’𑀢𑀺.

𑁨𑁬𑁦.

‘‘𑀬𑀲𑁆𑀲 𑀭𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀙𑀸𑀬𑀸𑀬, 𑀦𑀺𑀲𑀻𑀤𑁂𑀬𑁆𑀬 𑀲𑀬𑁂𑀬𑁆𑀬 𑀯𑀸;

𑀔𑀦𑁆𑀥𑀫𑁆𑀧𑀺 𑀢𑀲𑁆𑀲 𑀙𑀺𑀦𑁆𑀤𑁂𑀬𑁆𑀬, 𑀅𑀢𑁆𑀣𑁄 𑀘𑁂 𑀢𑀸𑀤𑀺𑀲𑁄 𑀲𑀺𑀬𑀸’’𑀢𑀺.

𑁨𑁬𑁧.

‘‘𑀬𑀲𑁆𑀲 ¶ 𑀭𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀙𑀸𑀬𑀸𑀬, 𑀦𑀺𑀲𑀻𑀤𑁂𑀬𑁆𑀬 𑀲𑀬𑁂𑀬𑁆𑀬 𑀯𑀸;

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

𑁨𑁬𑁨.

‘‘𑀬𑀲𑁆𑀲 𑀭𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀙𑀸𑀬𑀸𑀬, 𑀦𑀺𑀲𑀻𑀤𑁂𑀬𑁆𑀬 𑀲𑀬𑁂𑀬𑁆𑀬 𑀯𑀸;

𑀲𑀫𑀽𑀮𑀫𑁆𑀧𑀺 𑀢𑀁 𑀅𑀩𑁆𑀩𑀼𑀳𑁂 [𑀉𑀩𑁆𑀩𑀳𑁂 (?)], 𑀅𑀢𑁆𑀣𑁄 𑀘𑁂 𑀢𑀸𑀤𑀺𑀲𑁄 𑀲𑀺𑀬𑀸’’𑀢𑀺.

𑁨𑁬𑁩.

‘‘𑀬𑀲𑁆𑀲𑁂𑀓𑀭𑀢𑁆𑀢𑀺𑀫𑁆𑀧𑀺 𑀖𑀭𑁂 𑀯𑀲𑁂𑀬𑁆𑀬, 𑀬𑀢𑁆𑀣𑀦𑁆𑀦𑀧𑀸𑀦𑀁 𑀧𑀼𑀭𑀺𑀲𑁄 𑀮𑀪𑁂𑀣;

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

𑁨𑁬𑁪.

‘‘𑀬𑀲𑁆𑀲𑁂𑀓𑀭𑀢𑁆𑀢𑀺𑀫𑁆𑀧𑀺 𑀖𑀭𑁂 𑀯𑀲𑁂𑀬𑁆𑀬, 𑀅𑀦𑁆𑀦𑁂𑀦 𑀧𑀸𑀦𑁂𑀦 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑁄 𑀲𑀺𑀬𑀸;

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

𑁨𑁬𑁫.

‘‘𑀬𑁄 𑀧𑀼𑀩𑁆𑀩𑁂 𑀓𑀢𑀓𑀮𑁆𑀬𑀸𑀡𑁄, 𑀧𑀘𑁆𑀙𑀸 𑀧𑀸𑀧𑁂𑀦 𑀳𑀺𑀁𑀲𑀢𑀺;

𑀅𑀮𑁆𑀮𑀧𑀸𑀡𑀺𑀳𑀢𑁄 [𑀅𑀤𑀼𑀩𑁆𑀪𑀺𑀧𑀸𑀡𑀻𑀳𑀢𑁄 (𑀓)] 𑀧𑁄𑀲𑁄, 𑀦 𑀲𑁄 𑀪𑀤𑁆𑀭𑀸𑀦𑀺 𑀧𑀲𑁆𑀲𑀢𑀻’’𑀢𑀺.

𑁨𑁬𑁬.

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

𑀬𑀓𑁆𑀔𑁄𑀳𑀫𑀲𑁆𑀫𑀺 𑀧𑀭𑀫𑀺𑀤𑁆𑀥𑀺𑀧𑀢𑁆𑀢𑁄, 𑀤𑀽𑀭𑀗𑁆𑀕𑀫𑁄 𑀯𑀡𑁆𑀡𑀩𑀮𑀽𑀧𑀧𑀦𑁆𑀦𑁄’’𑀢𑀺.

𑁨𑁬𑁭.

‘‘𑀧𑀸𑀡𑀺 𑀢𑁂 𑀲𑀩𑁆𑀩𑀲𑁄 𑀯𑀡𑁆𑀡𑁄, 𑀧𑀜𑁆𑀘𑀥𑀸𑀭𑁄 𑀫𑀥𑀼𑀲𑁆𑀲𑀯𑁄;

𑀦𑀸𑀦𑀸𑀭𑀲𑀸 𑀧𑀕𑁆𑀖𑀭𑀦𑁆𑀢𑀺, 𑀫𑀜𑁆𑀜𑁂𑀳𑀁 𑀢𑀁 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤’’𑀦𑁆𑀢𑀺.

𑁨𑁬𑁮.

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

𑀧𑁂𑀢𑀁 𑀫𑀁 𑀅𑀗𑁆𑀓𑀼𑀭 𑀚𑀸𑀦𑀸𑀳𑀺, 𑀭𑁄𑀭𑀼𑀯𑀫𑁆𑀳𑀸 [𑀳𑁂𑀭𑀼𑀯𑀫𑁆𑀳𑀸 (𑀲𑀻.)] 𑀇𑀥𑀸𑀕𑀢’’𑀦𑁆𑀢𑀺.

𑁨𑁬𑁯.

‘‘𑀓𑀺𑀁𑀲𑀻𑀮𑁄 ¶ ¶ 𑀓𑀺𑀁𑀲𑀫𑀸𑀘𑀸𑀭𑁄, 𑀭𑁄𑀭𑀼𑀯𑀲𑁆𑀫𑀺𑀁 𑀧𑀼𑀭𑁂 𑀢𑀼𑀯𑀁;

𑀓𑁂𑀦 𑀢𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑁂𑀦, 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀸𑀡𑀺𑀫𑁆𑀳𑀺 𑀇𑀚𑁆𑀛𑀢𑀻’’𑀢𑀺.

𑁨𑁭𑁦.

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

𑀲𑀼𑀓𑀺𑀘𑁆𑀙𑀯𑀼𑀢𑁆𑀢𑀺 𑀓𑀧𑀡𑁄, 𑀦 𑀫𑁂 𑀯𑀺𑀚𑁆𑀚𑀢𑀺 𑀤𑀸𑀢𑀯𑁂.

𑁨𑁭𑁧.

‘‘𑀦𑀺𑀯𑁂𑀲𑀦𑀜𑁆𑀘 ¶ ¶ [𑀆𑀯𑁂𑀲𑀦𑀜𑁆𑀘 (𑀲𑀻.)] 𑀫𑁂 𑀆𑀲𑀺, 𑀅𑀲𑀬𑁆𑀳𑀲𑁆𑀲 𑀉𑀧𑀦𑁆𑀢𑀺𑀓𑁂;

𑀲𑀤𑁆𑀥𑀲𑁆𑀲 𑀤𑀸𑀦𑀧𑀢𑀺𑀦𑁄, 𑀓𑀢𑀧𑀼𑀜𑁆𑀜𑀲𑁆𑀲 𑀮𑀚𑁆𑀚𑀺𑀦𑁄.

𑁨𑁭𑁨.

‘‘𑀢𑀢𑁆𑀣 𑀬𑀸𑀘𑀦𑀓𑀸 𑀬𑀦𑁆𑀢𑀺, 𑀦𑀸𑀦𑀸𑀕𑁄𑀢𑁆𑀢𑀸 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑀸;

𑀢𑁂 𑀘 𑀫𑀁 𑀢𑀢𑁆𑀣 𑀧𑀼𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀅𑀲𑀬𑁆𑀳𑀲𑁆𑀲 𑀦𑀺𑀯𑁂𑀲𑀦𑀁.

𑁨𑁭𑁩.

‘‘𑀓𑀢𑁆𑀣 𑀕𑀘𑁆𑀙𑀸𑀫 𑀪𑀤𑁆𑀤𑀁 𑀯𑁄, 𑀓𑀢𑁆𑀣 𑀤𑀸𑀦𑀁 𑀧𑀤𑀻𑀬𑀢𑀺;

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

𑁨𑁭𑁪.

‘‘𑀧𑀕𑁆𑀕𑀬𑁆𑀳 𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀩𑀸𑀳𑀼𑀁, 𑀏𑀢𑁆𑀣 𑀕𑀘𑁆𑀙𑀣 𑀪𑀤𑁆𑀤𑀁 𑀯𑁄;

𑀏𑀢𑁆𑀣 𑀤𑀸𑀦𑀁 𑀧𑀤𑀻𑀬𑀢𑀺, 𑀅𑀲𑀬𑁆𑀳𑀲𑁆𑀲 𑀦𑀺𑀯𑁂𑀲𑀦𑁂.

𑁨𑁭𑁫.

‘‘𑀢𑁂𑀦 𑀧𑀸𑀡𑀺 𑀓𑀸𑀫𑀤𑀤𑁄, 𑀢𑁂𑀦 𑀧𑀸𑀡𑀺 𑀫𑀥𑀼𑀲𑁆𑀲𑀯𑁄;

𑀢𑁂𑀦 𑀫𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑁂𑀦, 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀸𑀡𑀺𑀫𑁆𑀳𑀺 𑀇𑀚𑁆𑀛𑀢𑀻’’𑀢𑀺.

𑁨𑁭𑁬.

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

𑀧𑀭𑀲𑁆𑀲 𑀤𑀸𑀦𑀁 𑀅𑀦𑀼𑀫𑁄𑀤𑀫𑀸𑀦𑁄, 𑀧𑀸𑀡𑀺𑀁 𑀧𑀕𑁆𑀕𑀬𑁆𑀳 𑀧𑀸𑀯𑀤𑀺.

𑁨𑁭𑁭.

‘‘𑀢𑁂𑀦 𑀧𑀸𑀡𑀺 𑀓𑀸𑀫𑀤𑀤𑁄, 𑀢𑁂𑀦 𑀧𑀸𑀡𑀺 𑀫𑀥𑀼𑀲𑁆𑀲𑀯𑁄;

𑀢𑁂𑀦 𑀢𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑁂𑀦, 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀸𑀡𑀺𑀫𑁆𑀳𑀺 𑀇𑀚𑁆𑀛𑀢𑀺.

𑁨𑁭𑁮.

‘‘𑀬𑁄 ¶ 𑀲𑁄 𑀤𑀸𑀦𑀫𑀤𑀸 𑀪𑀦𑁆𑀢𑁂, 𑀧𑀲𑀦𑁆𑀦𑁄 𑀲𑀓𑀧𑀸𑀡𑀺𑀪𑀺;

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

𑁨𑁭𑁯.

‘‘𑀦𑀸𑀳𑀁 𑀧𑀚𑀸𑀦𑀸𑀫𑀺 𑀅𑀲𑀬𑁆𑀳𑀲𑀸𑀳𑀺𑀦𑁄, 𑀅𑀗𑁆𑀕𑀻𑀭𑀲𑀲𑁆𑀲 𑀕𑀢𑀺𑀁 𑀆𑀕𑀢𑀺𑀁 𑀯𑀸;

𑀲𑀼𑀢𑀜𑁆𑀘 𑀫𑁂 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂, 𑀲𑀓𑁆𑀓𑀲𑁆𑀲 𑀲𑀳𑀩𑁆𑀬𑀢𑀁 𑀕𑀢𑁄 𑀅𑀲𑀬𑁆𑀳𑁄’’𑀢𑀺.

𑁨𑁮𑁦.

‘‘𑀅𑀮𑀫𑁂𑀯 𑀓𑀸𑀢𑀼𑀁 𑀓𑀮𑁆𑀬𑀸𑀡𑀁, 𑀤𑀸𑀦𑀁 𑀤𑀸𑀢𑀼𑀁 𑀬𑀣𑀸𑀭𑀳𑀁;

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

𑁨𑁮𑁧.

‘‘𑀲𑁄 𑀳𑀺 𑀦𑀽𑀦 𑀇𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀯𑀸𑀦 𑀤𑁆𑀯𑀸𑀭𑀓𑀁;

𑀤𑀸𑀦𑀁 𑀧𑀝𑁆𑀞𑀧𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀬𑀁 𑀫𑀫𑀲𑁆𑀲 𑀲𑀼𑀔𑀸𑀯𑀳𑀁.

𑁨𑁮𑁨.

‘‘𑀤𑀲𑁆𑀲𑀸𑀫𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘, 𑀯𑀢𑁆𑀣𑀲𑁂𑀦𑀸𑀲𑀦𑀸𑀦𑀺 𑀘;

𑀧𑀧𑀜𑁆𑀘 𑀉𑀤𑀧𑀸𑀦𑀜𑁆𑀘, 𑀤𑀼𑀕𑁆𑀕𑁂 𑀲𑀗𑁆𑀓𑀫𑀦𑀸𑀦𑀺 𑀘𑀸’’𑀢𑀺.

𑁨𑁮𑁩.

‘‘𑀓𑁂𑀦 ¶ 𑀢𑁂 𑀅𑀗𑁆𑀕𑀼𑀮𑀻 𑀓𑀼𑀡𑀸 [𑀓𑀼𑀡𑁆𑀞𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀫𑀼𑀔𑀜𑁆𑀘 𑀓𑀼𑀡𑀮𑀻𑀓𑀢𑀁 [𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀓𑀢𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)];

𑀅𑀓𑁆𑀔𑀻𑀦𑀺 𑀘 𑀧𑀕𑁆𑀖𑀭𑀦𑁆𑀢𑀺, 𑀓𑀺𑀁 𑀧𑀸𑀧𑀁 𑀧𑀓𑀢𑀁 𑀢𑀬𑀸’’𑀢𑀺.

𑁨𑁮𑁪.

‘‘𑀅𑀗𑁆𑀕𑀻𑀭𑀲𑀲𑁆𑀲 ¶ 𑀕𑀳𑀧𑀢𑀺𑀦𑁄, 𑀲𑀤𑁆𑀥𑀲𑁆𑀲 𑀖𑀭𑀫𑁂𑀲𑀺𑀦𑁄;

𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀤𑀸𑀦𑀯𑀺𑀲𑁆𑀲𑀕𑁆𑀕𑁂, 𑀤𑀸𑀦𑁂 𑀅𑀥𑀺𑀓𑀢𑁄 𑀅𑀳𑀼𑀁.

𑁨𑁮𑁫.

‘‘𑀢𑀢𑁆𑀣 𑀬𑀸𑀘𑀦𑀓𑁂 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀆𑀕𑀢𑁂 𑀪𑁄𑀚𑀦𑀢𑁆𑀣𑀺𑀓𑁂;

𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀅𑀧𑀓𑁆𑀓𑀫𑁆𑀫, 𑀅𑀓𑀸𑀲𑀺𑀁 𑀓𑀼𑀡𑀮𑀺𑀁 𑀫𑀼𑀔𑀁.

𑁨𑁮𑁬.

‘‘𑀢𑁂𑀦 ¶ 𑀫𑁂 𑀅𑀗𑁆𑀕𑀼𑀮𑀻 𑀓𑀼𑀡𑀸, 𑀫𑀼𑀔𑀜𑁆𑀘 𑀓𑀼𑀡𑀮𑀻𑀓𑀢𑀁;

𑀅𑀓𑁆𑀔𑀻𑀦𑀺 𑀫𑁂 𑀧𑀕𑁆𑀖𑀭𑀦𑁆𑀢𑀺, 𑀢𑀁 𑀧𑀸𑀧𑀁 𑀧𑀓𑀢𑀁 𑀫𑀬𑀸’’𑀢𑀺.

𑁨𑁮𑁭.

‘‘𑀥𑀫𑁆𑀫𑁂𑀦 ¶ 𑀢𑁂 𑀓𑀸𑀧𑀼𑀭𑀺𑀲, 𑀫𑀼𑀔𑀜𑁆𑀘 𑀓𑀼𑀡𑀮𑀻𑀓𑀢𑀁;

𑀅𑀓𑁆𑀔𑀻𑀦𑀺 𑀘 𑀧𑀕𑁆𑀖𑀭𑀦𑁆𑀢𑀺, 𑀬𑀁 𑀢𑀁 𑀧𑀭𑀲𑁆𑀲 𑀤𑀸𑀦𑀲𑁆𑀲;

𑀅𑀓𑀸𑀲𑀺 𑀓𑀼𑀡𑀮𑀺𑀁 𑀫𑀼𑀔𑀁.

𑁨𑁮𑁮.

‘‘𑀓𑀣𑀁 𑀳𑀺 𑀤𑀸𑀦𑀁 𑀤𑀤𑀫𑀸𑀦𑁄, 𑀓𑀭𑁂𑀬𑁆𑀬 𑀧𑀭𑀧𑀢𑁆𑀢𑀺𑀬𑀁;

𑀅𑀦𑁆𑀦𑀁 𑀧𑀸𑀦𑀁 𑀔𑀸𑀤𑀦𑀻𑀬𑀁, 𑀯𑀢𑁆𑀣𑀲𑁂𑀦𑀸𑀲𑀦𑀸𑀦𑀺 𑀘.

𑁨𑁮𑁯.

‘‘𑀲𑁄 𑀳𑀺 𑀦𑀽𑀦 𑀇𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀯𑀸𑀦 𑀤𑁆𑀯𑀸𑀭𑀓𑀁;

𑀤𑀸𑀦𑀁 𑀧𑀝𑁆𑀞𑀧𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀬𑀁 𑀫𑀫𑀲𑁆𑀲 𑀲𑀼𑀔𑀸𑀯𑀳𑀁.

𑁨𑁯𑁦.

‘‘𑀤𑀲𑁆𑀲𑀸𑀫𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘, 𑀯𑀢𑁆𑀣𑀲𑁂𑀦𑀸𑀲𑀦𑀸𑀦𑀺 𑀘;

𑀧𑀧𑀜𑁆𑀘 𑀉𑀤𑀧𑀸𑀦𑀜𑁆𑀘, 𑀤𑀼𑀕𑁆𑀕𑁂 𑀲𑀗𑁆𑀓𑀫𑀦𑀸𑀦𑀺 𑀘𑀸’’𑀢𑀺.

𑁨𑁯𑁧.

𑀢𑀢𑁄 𑀳𑀺 𑀲𑁄 𑀦𑀺𑀯𑀢𑁆𑀢𑀺𑀢𑁆𑀯𑀸, 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀯𑀸𑀦 𑀤𑁆𑀯𑀸𑀭𑀓𑀁;

𑀤𑀸𑀦𑀁 𑀧𑀝𑁆𑀞𑀧𑀬𑀺 𑀅𑀗𑁆𑀓𑀼𑀭𑁄, 𑀬𑀁𑀢𑀼𑀫𑀲𑁆𑀲 [𑀬𑀁 𑀢𑀁 𑀅𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸.), 𑀬𑀦𑁆𑀢𑀫𑀲𑁆𑀲 (𑀓.)] 𑀲𑀼𑀔𑀸𑀯𑀳𑀁.

𑁨𑁯𑁨.

𑀅𑀤𑀸 𑀅𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀸𑀦𑀜𑁆𑀘, 𑀯𑀢𑁆𑀣𑀲𑁂𑀦𑀸𑀲𑀦𑀸𑀦𑀺 𑀘;

𑀧𑀧𑀜𑁆𑀘 𑀉𑀤𑀧𑀸𑀦𑀜𑁆𑀘, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

𑁨𑁯𑁩.

‘‘𑀓𑁄 𑀙𑀸𑀢𑁄 𑀓𑁄 𑀘 𑀢𑀲𑀺𑀢𑁄, 𑀓𑁄 𑀯𑀢𑁆𑀣𑀁 𑀧𑀭𑀺𑀤𑀳𑀺𑀲𑁆𑀲𑀢𑀺;

𑀓𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀸𑀦𑀺 𑀬𑁄𑀕𑁆𑀕𑀸𑀦𑀺, 𑀇𑀢𑁄 𑀬𑁄𑀚𑁂𑀦𑁆𑀢𑀼 𑀯𑀸𑀳𑀦𑀁.

𑁨𑁯𑁪.

‘‘𑀓𑁄 𑀙𑀢𑁆𑀢𑀺𑀘𑁆𑀙𑀢𑀺 𑀕𑀦𑁆𑀥𑀜𑁆𑀘, 𑀓𑁄 𑀫𑀸𑀮𑀁 𑀓𑁄 𑀉𑀧𑀸𑀳𑀦𑀁;

𑀇𑀢𑀺𑀲𑁆𑀲𑀼 𑀢𑀢𑁆𑀣 𑀖𑁄𑀲𑁂𑀦𑁆𑀢𑀺, 𑀓𑀧𑁆𑀧𑀓𑀸 𑀲𑀽𑀤𑀫𑀸𑀕𑀥𑀸 [𑀧𑀸𑀝𑀯𑀸 (𑀓.)];

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

𑁨𑁯𑁫.

‘‘‘𑀲𑀼𑀔𑀁 ¶ 𑀲𑀼𑀧𑀢𑀺 𑀅𑀗𑁆𑀓𑀼𑀭𑁄’, 𑀇𑀢𑀺 𑀚𑀸𑀦𑀸𑀢𑀺 𑀫𑀁 𑀚𑀦𑁄;

𑀤𑀼𑀓𑁆𑀔𑀁 ¶ 𑀲𑀼𑀧𑀸𑀫𑀺 𑀲𑀺𑀦𑁆𑀥𑀓 [𑀲𑀦𑁆𑀤𑀼𑀓, 𑀲𑀺𑀦𑁆𑀥𑀼𑀓 (𑀓.)], 𑀬𑀁 𑀦 𑀧𑀲𑁆𑀲𑀸𑀫𑀺 𑀬𑀸𑀘𑀓𑁂.

𑁨𑁯𑁬.

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

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

𑁨𑁯𑁭.

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

𑀓𑀺𑀲𑁆𑀲 𑀲𑀩𑁆𑀩𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀯𑀭𑀫𑀸𑀦𑁄 𑀯𑀭𑀁 𑀯𑀭𑁂’’𑀢𑀺.

𑁨𑁯𑁮.

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

𑀓𑀸𑀮𑀼𑀝𑁆𑀞𑀺𑀢𑀲𑁆𑀲 𑀫𑁂 𑀲𑀢𑁄, 𑀲𑀼𑀭𑀺𑀬𑀼𑀕𑁆𑀕𑀫𑀦𑀁 𑀧𑀢𑀺;

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

𑁨𑁯𑁯.

‘‘𑀤𑀤𑀢𑁄 ¶ ¶ 𑀫𑁂 𑀦 𑀔𑀻𑀬𑁂𑀣, 𑀤𑀢𑁆𑀯𑀸 𑀦𑀸𑀦𑀼𑀢𑀧𑁂𑀬𑁆𑀬𑀳𑀁;

𑀤𑀤𑀁 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀲𑀸𑀤𑁂𑀬𑁆𑀬𑀁, 𑀏𑀢𑀁 𑀲𑀓𑁆𑀓𑀁 𑀯𑀭𑀁 𑀯𑀭𑁂’’𑀢𑀺.

𑁩𑁦𑁦.

‘‘𑀦 𑀲𑀩𑁆𑀩𑀯𑀺𑀢𑁆𑀢𑀸𑀦𑀺 𑀧𑀭𑁂 𑀧𑀯𑁂𑀘𑁆𑀙𑁂, 𑀤𑀤𑁂𑀬𑁆𑀬 𑀤𑀸𑀦𑀜𑁆𑀘 𑀥𑀦𑀜𑁆𑀘 𑀭𑀓𑁆𑀔𑁂;

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

𑁩𑁦𑁧.

‘‘𑀅𑀤𑀸𑀦𑀫𑀢𑀺𑀤𑀸𑀦𑀜𑁆𑀘, 𑀦𑀧𑁆𑀧𑀲𑀁𑀲𑀦𑁆𑀢𑀺 𑀧𑀡𑁆𑀟𑀺𑀢𑀸;

𑀢𑀲𑁆𑀫𑀸 𑀳𑀺 𑀤𑀸𑀦𑀸 𑀥𑀦𑀫𑁂𑀯 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀲𑀫𑁂𑀦 𑀯𑀢𑁆𑀢𑁂𑀬𑁆𑀬 𑀲 𑀥𑀻𑀭𑀥𑀫𑁆𑀫𑁄’’𑀢𑀺.

𑁩𑁦𑁨.

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

𑀫𑁂𑀖𑁄𑀯 ¶ 𑀦𑀺𑀦𑁆𑀦𑀸𑀦𑀺 𑀧𑀭𑀺𑀧𑀽𑀭𑀬𑀦𑁆𑀢𑁄 [𑀪𑀺𑀧𑀽𑀭𑀬𑀦𑁆𑀢𑁄 (𑀲𑀻.), 𑀳𑀺 𑀧𑀽𑀭𑀬𑀦𑁆𑀢𑁄 (𑀲𑁆𑀬𑀸.)], 𑀲𑀦𑁆𑀢𑀧𑁆𑀧𑀬𑁂 𑀲𑀩𑁆𑀩𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑀸𑀦𑀁.

𑁩𑁦𑁩.

‘‘𑀬𑀲𑁆𑀲 𑀬𑀸𑀘𑀦𑀓𑁂 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀫𑀼𑀔𑀯𑀡𑁆𑀡𑁄 𑀧𑀲𑀻𑀤𑀢𑀺;

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

𑁩𑁦𑁪.

‘‘𑀬𑀲𑁆𑀲 𑀬𑀸𑀘𑀦𑀓𑁂 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀫𑀼𑀔𑀯𑀡𑁆𑀡𑁄 𑀧𑀲𑀻𑀤𑀢𑀺;

𑀤𑀢𑁆𑀯𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀳𑁄𑀢𑀺, 𑀏𑀲𑀸 𑀬𑀜𑁆𑀜𑀲𑁆𑀲 [𑀧𑀼𑀜𑁆𑀜𑀲𑁆𑀲 (𑀲𑀻.)] 𑀲𑀫𑁆𑀧𑀤𑀸.

𑁩𑁦𑁫.

[𑀅. 𑀦𑀺. 𑁬.𑁩𑁭] ‘‘𑀧𑀼𑀩𑁆𑀩𑁂𑀯 ¶ 𑀤𑀸𑀦𑀸 𑀲𑀼𑀫𑀦𑁄, 𑀤𑀤𑀁 𑀘𑀺𑀢𑁆𑀢𑀁 𑀧𑀲𑀸𑀤𑀬𑁂;

𑀤𑀢𑁆𑀯𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀳𑁄𑀢𑀺, 𑀏𑀲𑀸 𑀬𑀜𑁆𑀜𑀲𑁆𑀲 [𑀧𑀼𑀜𑁆𑀜𑀲𑁆𑀲 (𑀲𑀻.)] 𑀲𑀫𑁆𑀧𑀤𑀸’’𑀢𑀺.

𑁩𑁦𑁬.

𑀲𑀝𑁆𑀞𑀺 𑀯𑀸𑀳𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀅𑀗𑁆𑀓𑀼𑀭𑀲𑁆𑀲 𑀦𑀺𑀯𑁂𑀲𑀦𑁂;

𑀪𑁄𑀚𑀦𑀁 𑀤𑀻𑀬𑀢𑁂 𑀦𑀺𑀘𑁆𑀘𑀁, 𑀧𑀼𑀜𑁆𑀜𑀧𑁂𑀓𑁆𑀔𑀲𑁆𑀲 𑀚𑀦𑁆𑀢𑀼𑀦𑁄.

𑁩𑁦𑁭.

𑀢𑀺𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 𑀲𑀽𑀤𑀸𑀦𑀺 𑀳𑀺 [𑀲𑀽𑀤𑀸𑀦𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀸;

𑀅𑀗𑁆𑀓𑀼𑀭𑀁 𑀉𑀧𑀚𑀻𑀯𑀦𑁆𑀢𑀺, 𑀤𑀸𑀦𑁂 𑀬𑀜𑁆𑀜𑀲𑁆𑀲 𑀯𑀸𑀯𑀝𑀸 [𑀩𑁆𑀬𑀸𑀯𑀝𑀸 (𑀲𑀻.), 𑀧𑀸𑀯𑀝𑀸 (𑀲𑁆𑀬𑀸.)].

𑁩𑁦𑁮.

𑀲𑀝𑁆𑀞𑀺 𑀧𑀼𑀭𑀺𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀆𑀫𑀼𑀢𑁆𑀢𑀫𑀡𑀺𑀓𑀼𑀡𑁆𑀟𑀮𑀸;

𑀅𑀗𑁆𑀓𑀼𑀭𑀲𑁆𑀲 𑀫𑀳𑀸𑀤𑀸𑀦𑁂, 𑀓𑀝𑁆𑀞𑀁 𑀨𑀸𑀮𑁂𑀦𑁆𑀢𑀺 𑀫𑀸𑀡𑀯𑀸.

𑁩𑁦𑁯.

𑀲𑁄𑀴𑀲𑀺𑀢𑁆𑀣𑀺𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀩𑁆𑀩𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀪𑀽𑀲𑀺𑀢𑀸;

𑀅𑀗𑁆𑀓𑀼𑀭𑀲𑁆𑀲 𑀫𑀳𑀸𑀤𑀸𑀦𑁂, 𑀯𑀺𑀥𑀸 𑀧𑀺𑀡𑁆𑀟𑁂𑀦𑁆𑀢𑀺 𑀦𑀸𑀭𑀺𑀬𑁄.

𑁩𑁧𑁦.

𑀲𑁄𑀴𑀲𑀺𑀢𑁆𑀣𑀺𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀲𑀩𑁆𑀩𑀸𑀮𑀗𑁆𑀓𑀸𑀭𑀪𑀽𑀲𑀺𑀢𑀸;

𑀅𑀗𑁆𑀓𑀼𑀭𑀲𑁆𑀲 𑀫𑀳𑀸𑀤𑀸𑀦𑁂, 𑀤𑀩𑁆𑀩𑀺𑀕𑀸𑀳𑀸 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑀸.

𑁩𑁧𑁧.

𑀩𑀳𑀼𑀁 ¶ 𑀩𑀳𑀽𑀦𑀁 𑀧𑀸𑀤𑀸𑀲𑀺, 𑀘𑀺𑀭𑀁 𑀧𑀸𑀤𑀸𑀲𑀺 𑀔𑀢𑁆𑀢𑀺𑀬𑁄;

𑀲𑀓𑁆𑀓𑀘𑁆𑀘𑀜𑁆𑀘 𑀲𑀳𑀢𑁆𑀣𑀸 𑀘, 𑀘𑀺𑀢𑁆𑀢𑀻𑀓𑀢𑁆𑀯𑀸 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁.

𑁩𑁧𑁨.

𑀩𑀳𑀽 𑀫𑀸𑀲𑁂 𑀘 𑀧𑀓𑁆𑀔𑁂 𑀘, 𑀉𑀢𑀼𑀲𑀁𑀯𑀘𑁆𑀙𑀭𑀸𑀦𑀺 𑀘;

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

𑁩𑁧𑁩.

𑀏𑀯𑀁 ¶ ¶ 𑀤𑀢𑁆𑀯𑀸 𑀬𑀚𑀺𑀢𑁆𑀯𑀸 𑀘, 𑀅𑀗𑁆𑀓𑀼𑀭𑁄 𑀤𑀻𑀖𑀫𑀦𑁆𑀢𑀭𑀁;

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

𑁩𑁧𑁪.

𑀓𑀝𑀘𑁆𑀙𑀼𑀪𑀺𑀓𑁆𑀔𑀁 𑀤𑀢𑁆𑀯𑀸𑀦, 𑀅𑀦𑀼𑀭𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀇𑀦𑁆𑀤𑀓𑁄;

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

𑁩𑁧𑁫.

𑀤𑀲𑀳𑀺 𑀞𑀸𑀦𑁂𑀳𑀺 𑀅𑀗𑁆𑀓𑀼𑀭𑀁, 𑀇𑀦𑁆𑀤𑀓𑁄 𑀅𑀢𑀺𑀭𑁄𑀘𑀢𑀺;

𑀭𑀽𑀧𑁂 𑀲𑀤𑁆𑀤𑁂 𑀭𑀲𑁂 𑀕𑀦𑁆𑀥𑁂, 𑀨𑁄𑀝𑁆𑀞𑀩𑁆𑀩𑁂 𑀘 𑀫𑀦𑁄𑀭𑀫𑁂.

𑁩𑁧𑁬.

𑀆𑀬𑀼𑀦𑀸 𑀬𑀲𑀲𑀸 𑀘𑁂𑀯, 𑀯𑀡𑁆𑀡𑁂𑀦 𑀘 𑀲𑀼𑀔𑁂𑀦 𑀘;

𑀆𑀥𑀺𑀧𑀘𑁆𑀘𑁂𑀦 𑀅𑀗𑁆𑀓𑀼𑀭𑀁, 𑀇𑀦𑁆𑀤𑀓𑁄 𑀅𑀢𑀺𑀭𑁄𑀘𑀢𑀺.

𑁩𑁧𑁭.

𑀢𑀸𑀯𑀢𑀺𑀁𑀲𑁂 𑀬𑀤𑀸 𑀩𑀼𑀤𑁆𑀥𑁄, 𑀲𑀺𑀮𑀸𑀬𑀁 𑀧𑀡𑁆𑀟𑀼𑀓𑀫𑁆𑀩𑀮𑁂;

𑀧𑀸𑀭𑀺𑀘𑁆𑀙𑀢𑁆𑀢𑀓𑀫𑀽𑀮𑀫𑁆𑀳𑀺, 𑀯𑀺𑀳𑀸𑀲𑀺 𑀧𑀼𑀭𑀺𑀲𑀼𑀢𑁆𑀢𑀫𑁄.

𑁩𑁧𑁮.

𑀤𑀲𑀲𑀼 ¶ 𑀮𑁄𑀓𑀥𑀸𑀢𑀽𑀲𑀼, 𑀲𑀦𑁆𑀦𑀺𑀧𑀢𑀺𑀢𑁆𑀯𑀸𑀦 𑀤𑁂𑀯𑀢𑀸;

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

𑁩𑁧𑁯.

𑀦 𑀓𑁄𑀘𑀺 𑀤𑁂𑀯𑁄 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀁 𑀅𑀢𑀺𑀭𑁄𑀘𑀢𑀺;

𑀲𑀩𑁆𑀩𑁂 𑀤𑁂𑀯𑁂 𑀅𑀢𑀺𑀓𑁆𑀓𑀫𑁆𑀫 [𑀅𑀥𑀺𑀕𑀬𑁆𑀳 (𑀲𑀻.), 𑀅𑀢𑀺𑀕𑁆𑀕𑀬𑁆𑀳 (𑀓)], 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄𑀯 𑀯𑀺𑀭𑁄𑀘𑀢𑀺.

𑁩𑁨𑁦.

𑀬𑁄𑀚𑀦𑀸𑀦𑀺 ¶ 𑀤𑀲 𑀤𑁆𑀯𑁂 𑀘, 𑀅𑀗𑁆𑀓𑀼𑀭𑁄𑀬𑀁 𑀢𑀤𑀸 𑀅𑀳𑀼;

𑀅𑀯𑀺𑀤𑀽𑀭𑁂𑀯 𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 [𑀅𑀯𑀺𑀤𑀽𑀭𑁂 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 (𑀓.)], 𑀇𑀦𑁆𑀤𑀓𑁄 𑀅𑀢𑀺𑀭𑁄𑀘𑀢𑀺.

𑁩𑁨𑁧.

𑀑𑀮𑁄𑀓𑁂𑀢𑁆𑀯𑀸𑀦 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑁄, 𑀅𑀗𑁆𑀓𑀼𑀭𑀜𑁆𑀘𑀸𑀧𑀺 𑀇𑀦𑁆𑀤𑀓𑀁;

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

𑁩𑁨𑁨.

‘‘𑀫𑀳𑀸𑀤𑀸𑀦𑀁 𑀢𑀬𑀸 𑀤𑀺𑀦𑁆𑀦𑀁, 𑀅𑀗𑁆𑀓𑀼𑀭 𑀤𑀻𑀖𑀫𑀦𑁆𑀢𑀭𑀁;

𑀅𑀢𑀺𑀤𑀽𑀭𑁂 [𑀲𑀼𑀯𑀺𑀤𑀽𑀭𑁂 (𑀓.)] 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄𑀲𑀺, 𑀆𑀕𑀘𑁆𑀙 𑀫𑀫 𑀲𑀦𑁆𑀢𑀺𑀓𑁂’’𑀢𑀺.

𑁩𑁨𑁩.

𑀘𑁄𑀤𑀺𑀢𑁄 𑀪𑀸𑀯𑀺𑀢𑀢𑁆𑀢𑁂𑀦, 𑀅𑀗𑁆𑀓𑀼𑀭𑁄 𑀇𑀤𑀫𑀩𑁆𑀭𑀯𑀺;

‘‘𑀓𑀺𑀁 𑀫𑀬𑁆𑀳𑀁 𑀢𑁂𑀦 𑀤𑀸𑀦𑁂𑀦, 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑁂𑀦 𑀲𑀼𑀜𑁆𑀜𑀢𑀁.

𑁩𑁨𑁪.

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

𑀅𑀢𑀺𑀭𑁄𑀘𑀢𑀺 𑀅𑀫𑁆𑀳𑁂𑀳𑀺, 𑀘𑀦𑁆𑀤𑁄 𑀢𑀸𑀭𑀕𑀡𑁂 𑀬𑀣𑀸’’𑀢𑀺.

𑁩𑁨𑁫.

‘‘𑀉𑀚𑁆𑀚𑀗𑁆𑀕𑀮𑁂 𑀬𑀣𑀸 𑀔𑁂𑀢𑁆𑀢𑁂, 𑀩𑀻𑀚𑀁 𑀩𑀳𑀼𑀫𑁆𑀧𑀺 𑀭𑁄𑀧𑀺𑀢𑀁;

𑀦 𑀯𑀺𑀧𑀼𑀮𑀨𑀮𑀁 𑀳𑁄𑀢𑀺, 𑀦𑀧𑀺 𑀢𑁄𑀲𑁂𑀢𑀺 𑀓𑀲𑁆𑀲𑀓𑀁.

𑁩𑁨𑁬.

‘‘𑀢𑀣𑁂𑀯 𑀤𑀸𑀦𑀁 𑀩𑀳𑀼𑀓𑀁, 𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑁂𑀲𑀼 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀁;

𑀦 𑀯𑀺𑀧𑀼𑀮𑀨𑀮𑀁 𑀳𑁄𑀢𑀺, 𑀦𑀧𑀺 𑀢𑁄𑀲𑁂𑀢𑀺 𑀤𑀸𑀬𑀓𑀁.

𑁩𑁨𑁭.

‘‘𑀬𑀣𑀸𑀧𑀺 ¶ 𑀪𑀤𑁆𑀤𑀓𑁂 𑀔𑁂𑀢𑁆𑀢𑁂, 𑀩𑀻𑀚𑀁 𑀅𑀧𑁆𑀧𑀫𑁆𑀧𑀺 𑀭𑁄𑀧𑀺𑀢𑀁;

𑀲𑀫𑁆𑀫𑀸 𑀥𑀸𑀭𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑀦𑁆𑀢𑁂, 𑀨𑀮𑀁 𑀢𑁄𑀲𑁂𑀢𑀺 𑀓𑀲𑁆𑀲𑀓𑀁.

𑁩𑁨𑁮.

‘‘𑀢𑀣𑁂𑀯 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑁂𑀲𑀼, 𑀕𑀼𑀡𑀯𑀦𑁆𑀢𑁂𑀲𑀼 𑀢𑀸𑀤𑀺𑀲𑀼;

𑀅𑀧𑁆𑀧𑀓𑀫𑁆𑀧𑀺 𑀓𑀢𑀁 𑀓𑀸𑀭𑀁, 𑀧𑀼𑀜𑁆𑀜𑀁 𑀳𑁄𑀢𑀺 𑀫𑀳𑀧𑁆𑀨𑀮’’𑀦𑁆𑀢𑀺.

𑁩𑁨𑁯.

𑀯𑀺𑀘𑁂𑀬𑁆𑀬 ¶ ¶ 𑀤𑀸𑀦𑀁 𑀤𑀸𑀢𑀩𑁆𑀩𑀁, 𑀬𑀢𑁆𑀣 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁;

𑀯𑀺𑀘𑁂𑀬𑁆𑀬 𑀤𑀸𑀦𑀁 𑀤𑀢𑁆𑀯𑀸𑀦, 𑀲𑀕𑁆𑀕𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀤𑀸𑀬𑀓𑀸.

𑁩𑁩𑁦.

𑀯𑀺𑀘𑁂𑀬𑁆𑀬 ¶ 𑀤𑀸𑀦𑀁 𑀲𑀼𑀕𑀢𑀧𑁆𑀧𑀲𑀢𑁆𑀣𑀁, 𑀬𑁂 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑀸 𑀇𑀥 𑀚𑀻𑀯𑀮𑁄𑀓𑁂;

𑀏𑀢𑁂𑀲𑀼 𑀤𑀺𑀦𑁆𑀦𑀸𑀦𑀺 𑀫𑀳𑀧𑁆𑀨𑀮𑀸𑀦𑀺, 𑀩𑀻𑀚𑀸𑀦𑀺 𑀯𑀼𑀢𑁆𑀢𑀸𑀦𑀺 𑀬𑀣𑀸 𑀲𑀼𑀔𑁂𑀢𑁆𑀢𑁂𑀢𑀺.

𑀅𑀗𑁆𑀓𑀼𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀦𑀯𑀫𑀁.

𑁧𑁦. 𑀉𑀢𑁆𑀢𑀭𑀫𑀸𑀢𑀼𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁩𑁩𑁧.

𑀤𑀺𑀯𑀸𑀯𑀺𑀳𑀸𑀭𑀕𑀢𑀁 ¶ 𑀪𑀺𑀓𑁆𑀔𑀼𑀁, 𑀕𑀗𑁆𑀕𑀸𑀢𑀻𑀭𑁂 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀓𑀁;

𑀢𑀁 𑀧𑁂𑀢𑀻 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑁆𑀫, 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀸 𑀪𑀻𑀭𑀼𑀤𑀲𑁆𑀲𑀦𑀸.

𑁩𑁩𑁨.

𑀓𑁂𑀲𑀸 𑀘𑀲𑁆𑀲𑀸 𑀅𑀢𑀺𑀤𑀻𑀖𑀸 [𑀅𑀳𑀽 𑀤𑀻𑀖𑀸 (𑀓.)], 𑀬𑀸𑀯𑀪𑀽𑀫𑀸𑀯𑀮𑀫𑁆𑀩𑀭𑁂 [𑀬𑀸𑀯 𑀪𑀽𑀫𑁆𑀬𑀸’𑀯𑀮𑀫𑁆𑀩𑀭𑁂 (?)];

𑀓𑁂𑀲𑁂𑀳𑀺 𑀲𑀸 𑀧𑀝𑀺𑀘𑁆𑀙𑀦𑁆𑀦𑀸, 𑀲𑀫𑀡𑀁 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺.

𑁩𑁩𑁩.

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

𑀦𑀸𑀪𑀺𑀚𑀸𑀦𑀸𑀫𑀺 𑀪𑀼𑀢𑁆𑀢𑀁 𑀯𑀸, 𑀧𑀻𑀢𑀁 𑀯𑀸 𑀧𑀦 𑀧𑀸𑀦𑀺𑀬𑀁;

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

𑁩𑁩𑁪.

‘‘𑀅𑀬𑀁 𑀲𑀻𑀢𑁄𑀤𑀺𑀓𑀸 𑀕𑀗𑁆𑀕𑀸, 𑀳𑀺𑀫𑀯𑀦𑁆𑀢𑀢𑁄 [𑀳𑀺𑀫𑀯𑀦𑁆𑀢𑀸𑀯 (𑀓.)] 𑀲𑀦𑁆𑀤𑀢𑀺;

𑀧𑀺𑀯 𑀏𑀢𑁆𑀢𑁄 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀓𑀺𑀁 𑀫𑀁 𑀬𑀸𑀘𑀲𑀺 𑀧𑀸𑀦𑀺𑀬’’𑀦𑁆𑀢𑀺.

𑁩𑁩𑁫.

‘‘𑀲𑀘𑀸𑀳𑀁 𑀪𑀦𑁆𑀢𑁂 𑀕𑀗𑁆𑀕𑀸𑀬, 𑀲𑀬𑀁 𑀕𑀡𑁆𑀳𑀸𑀫𑀺 𑀧𑀸𑀦𑀺𑀬𑀁;

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

𑁩𑁩𑁬.

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

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

𑁩𑁩𑁭.

‘‘𑀧𑀼𑀢𑁆𑀢𑁄 𑀫𑁂 𑀉𑀢𑁆𑀢𑀭𑁄 𑀦𑀸𑀫 [𑀧𑀼𑀢𑁆𑀢𑁄 𑀫𑁂 𑀪𑀦𑁆𑀢𑁂 𑀉𑀢𑁆𑀢𑀭𑁄 (𑀓.)], 𑀲𑀤𑁆𑀥𑁄 𑀆𑀲𑀺 𑀉𑀧𑀸𑀲𑀓𑁄;

𑀲𑁄 ¶ 𑀘 𑀫𑀬𑁆𑀳𑀁 𑀅𑀓𑀸𑀫𑀸𑀬, 𑀲𑀫𑀡𑀸𑀦𑀁 𑀧𑀯𑁂𑀘𑁆𑀙𑀢𑀺.

𑁩𑁩𑁮.

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

𑀢𑀫𑀳𑀁 𑀧𑀭𑀺𑀪𑀸𑀲𑀸𑀫𑀺, 𑀫𑀘𑁆𑀙𑁂𑀭𑁂𑀦 𑀉𑀧𑀤𑁆𑀤𑀼𑀢𑀸.

𑁩𑁩𑁯.

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

𑀘𑀻𑀯𑀭𑀁 𑀧𑀺𑀡𑁆𑀟𑀧𑀸𑀢𑀜𑁆𑀘, 𑀧𑀘𑁆𑀘𑀬𑀁 𑀲𑀬𑀦𑀸𑀲𑀦𑀁.

𑁩𑁪𑁦.

‘‘𑀏𑀢𑀁 ¶ 𑀢𑁂 𑀧𑀭𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁, 𑀮𑁄𑀳𑀺𑀢𑀁 𑀳𑁄𑀢𑀼 𑀉𑀢𑁆𑀢𑀭;

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

𑀉𑀢𑁆𑀢𑀭𑀫𑀸𑀢𑀼𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀤𑀲𑀫𑀁.

𑁧𑁧. 𑀲𑀼𑀢𑁆𑀢𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁩𑁪𑁧.

‘‘𑀅𑀳𑀁 ¶ 𑀧𑀼𑀭𑁂 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀦𑁄, 𑀲𑀼𑀢𑁆𑀢𑀁 𑀅𑀤𑀸𑀲𑀺𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑁆𑀫 𑀬𑀸𑀘𑀺𑀢𑀸;

𑀢𑀲𑁆𑀲 𑀯𑀺𑀧𑀸𑀓𑁄 𑀯𑀺𑀧𑀼𑀮𑀨𑀮𑀽𑀧𑀮𑀩𑁆𑀪𑀢𑀺, 𑀩𑀳𑀼𑀓𑀸 𑀘 𑀫𑁂 𑀉𑀧𑁆𑀧𑀚𑁆𑀚𑀭𑁂 [𑀩𑀳𑀽 𑀘 𑀫𑁂 𑀉𑀧𑀧𑀚𑁆𑀚𑀭𑁂 (𑀲𑀻.)] 𑀯𑀢𑁆𑀣𑀓𑁄𑀝𑀺𑀬𑁄.

𑁩𑁪𑁨.

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

𑀲𑀸𑀳𑀁 𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀺 𑀘 𑀧𑀸𑀭𑀼𑀧𑀸𑀫𑀺 𑀘, 𑀧𑀳𑀽𑀢𑀯𑀺𑀢𑁆𑀢𑀸 𑀦 𑀘 𑀢𑀸𑀯 𑀔𑀻𑀬𑀢𑀺.

𑁩𑁪𑁩.

‘‘𑀢𑀲𑁆𑀲𑁂𑀯 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀯𑀺𑀧𑀸𑀓𑀫𑀦𑁆𑀯𑀬𑀸, 𑀲𑀼𑀔𑀜𑁆𑀘 𑀲𑀸𑀢𑀜𑁆𑀘 𑀇𑀥𑀽𑀧𑀮𑀩𑁆𑀪𑀢𑀺;

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

𑁩𑁪𑁪.

‘‘𑀲𑀢𑁆𑀢 𑀢𑀼𑀯𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀸 𑀇𑀥𑀸𑀕𑀢𑀸,

𑀚𑀺𑀡𑁆𑀡𑀸 𑀘 𑀯𑀼𑀟𑁆𑀠𑀸 𑀘 𑀢𑀳𑀺𑀁 𑀪𑀯𑀺𑀲𑁆𑀲𑀲𑀺;

𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀓𑀸𑀮𑀓𑀢𑀸 𑀘 𑀜𑀸𑀢𑀓𑀸,

𑀓𑀺𑀁 𑀢𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀇𑀢𑁄 𑀓𑀭𑀺𑀲𑁆𑀲𑀲𑀻’’𑀢𑀺.

𑁩𑁪𑁫.

‘‘𑀲𑀢𑁆𑀢𑁂𑀯 𑀯𑀲𑁆𑀲𑀸𑀦𑀺 𑀇𑀥𑀸𑀕𑀢𑀸𑀬 𑀫𑁂, 𑀤𑀺𑀩𑁆𑀩𑀜𑁆𑀘 𑀲𑀼𑀔𑀜𑁆𑀘 𑀲𑀫𑀧𑁆𑀧𑀺𑀢𑀸𑀬;

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

𑁩𑁪𑁬.

𑀲𑁄 ¶ 𑀢𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦 𑀧𑀲𑀬𑁆𑀳 𑀩𑀸𑀳𑀸𑀬𑀁, 𑀧𑀘𑁆𑀘𑀸𑀦𑀬𑀺𑀢𑁆𑀯𑀸𑀦 𑀣𑁂𑀭𑀺𑀁 𑀲𑀼𑀤𑀼𑀩𑁆𑀩𑀮𑀁;

‘‘𑀯𑀚𑁆𑀚𑁂𑀲𑀺 𑀅𑀜𑁆𑀜𑀫𑁆𑀧𑀺 𑀚𑀦𑀁 𑀇𑀥𑀸𑀕𑀢𑀁, ‘𑀓𑀭𑁄𑀣 𑀧𑀼𑀜𑁆𑀜𑀸𑀦𑀺 𑀲𑀼𑀔𑀽𑀧𑀮𑀩𑁆𑀪𑀢𑀺’’.

𑁩𑁪𑁭.

‘‘𑀤𑀺𑀝𑁆𑀞𑀸 ¶ 𑀫𑀬𑀸 𑀅𑀓𑀢𑁂𑀦 𑀲𑀸𑀥𑀼𑀦𑀸, 𑀧𑁂𑀢𑀸 𑀯𑀺𑀳𑀜𑁆𑀜𑀦𑁆𑀢𑀺 𑀢𑀣𑁂𑀯 𑀫𑀦𑀼𑀲𑁆𑀲𑀸;

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

𑀲𑀼𑀢𑁆𑀢𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀏𑀓𑀸𑀤𑀲𑀫𑀁.

𑁧𑁨. 𑀓𑀡𑁆𑀡𑀫𑀼𑀡𑁆𑀟𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁩𑁪𑁮.

‘‘𑀲𑁄𑀡𑁆𑀡𑀲𑁄𑀧𑀸𑀦𑀨𑀮𑀓𑀸 ¶ ¶ , 𑀲𑁄𑀡𑁆𑀡𑀯𑀸𑀮𑀼𑀓𑀲𑀦𑁆𑀣𑀢𑀸;

𑀢𑀢𑁆𑀣 𑀲𑁄𑀕𑀦𑁆𑀥𑀺𑀬𑀸 𑀯𑀕𑁆𑀕𑀽, 𑀲𑀼𑀘𑀺𑀕𑀦𑁆𑀥𑀸 𑀫𑀦𑁄𑀭𑀫𑀸.

𑁩𑁪𑁯.

‘‘𑀦𑀸𑀦𑀸𑀭𑀼𑀓𑁆𑀔𑁂𑀳𑀺 𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸, 𑀦𑀸𑀦𑀸𑀕𑀦𑁆𑀥𑀲𑀫𑁂𑀭𑀺𑀢𑀸;

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

𑁩𑁫𑁦.

‘‘𑀲𑀼𑀭𑀪𑀺𑀁 𑀲𑀫𑁆𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺, 𑀫𑀦𑀼𑀜𑁆𑀜𑀸 𑀫𑀸𑀮𑀼𑀢𑁂𑀭𑀺𑀢𑀸;

𑀳𑀁𑀲𑀓𑁄𑀜𑁆𑀘𑀸𑀪𑀺𑀭𑀼𑀤𑀸 𑀘, 𑀘𑀓𑁆𑀓𑀯𑀓𑁆𑀓𑀸𑀪𑀺𑀓𑀽𑀚𑀺𑀢𑀸.

𑁩𑁫𑁧.

‘‘𑀦𑀸𑀦𑀸𑀤𑀺𑀚𑀕𑀡𑀸𑀓𑀺𑀡𑁆𑀡𑀸 ¶ , 𑀦𑀸𑀦𑀸𑀲𑀭𑀕𑀡𑀸𑀬𑀼𑀢𑀸;

𑀦𑀸𑀦𑀸𑀨𑀮𑀥𑀭𑀸 𑀭𑀼𑀓𑁆𑀔𑀸, 𑀦𑀸𑀦𑀸𑀧𑀼𑀧𑁆𑀨𑀥𑀭𑀸 𑀯𑀦𑀸.

𑁩𑁫𑁨.

‘‘𑀦 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀈𑀤𑀺𑀲𑀁, 𑀦𑀕𑀭𑀁 𑀬𑀸𑀤𑀺𑀲𑀁 𑀇𑀤𑀁;

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

𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀸 𑀆𑀪𑁂𑀦𑁆𑀢𑀺 [𑀆𑀪𑀦𑁆𑀢𑀺 (𑀓.)], 𑀲𑀫𑀦𑁆𑀢𑀸 𑀘𑀢𑀼𑀭𑁄 𑀤𑀺𑀲𑀸.

𑁩𑁫𑁩.

‘‘𑀧𑀜𑁆𑀘 𑀤𑀸𑀲𑀺𑀲𑀢𑀸 𑀢𑀼𑀬𑁆𑀳𑀁, 𑀬𑀸 𑀢𑁂𑀫𑀸 𑀧𑀭𑀺𑀘𑀸𑀭𑀺𑀓𑀸;

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

𑁩𑁫𑁪.

‘‘𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑀸 𑀩𑀳𑀼𑀓𑀸 𑀢𑀼𑀬𑁆𑀳𑀁, 𑀲𑁄𑀯𑀡𑁆𑀡𑀭𑀽𑀧𑀺𑀬𑀸𑀫𑀬𑀸;

𑀓𑀤𑀮𑀺𑀫𑀺𑀕𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸 [𑀓𑀸𑀤𑀮𑀺𑀫𑀺𑀕𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸 (𑀲𑀻.)], 𑀲𑀚𑁆𑀚𑀸 𑀕𑁄𑀦𑀓𑀲𑀦𑁆𑀣𑀢𑀸.

𑁩𑁫𑁫.

‘‘𑀬𑀢𑁆𑀣 𑀢𑁆𑀯𑀁 𑀯𑀸𑀲𑀽𑀧𑀕𑀢𑀸, 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀦𑀻;

𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀸𑀬𑀟𑁆𑀠𑀭𑀢𑁆𑀢𑀸𑀬 [… 𑀭𑀢𑁆𑀢𑀺𑀬𑀸 (𑀓.)], 𑀢𑀢𑁄 𑀉𑀝𑁆𑀞𑀸𑀬 𑀕𑀘𑁆𑀙𑀲𑀺.

𑁩𑁫𑁬.

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

𑀢𑀲𑁆𑀲𑀸 ¶ 𑀢𑀻𑀭𑁂 𑀢𑀼𑀯𑀁 𑀞𑀸𑀲𑀺, 𑀳𑀭𑀺𑀢𑁂 𑀲𑀤𑁆𑀤𑀮𑁂 𑀲𑀼𑀪𑁂.

𑁩𑁫𑁭.

‘‘𑀢𑀢𑁄 𑀢𑁂 𑀓𑀡𑁆𑀡𑀫𑀼𑀡𑁆𑀟𑁄 𑀲𑀼𑀦𑀔𑁄, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑀸𑀦𑀺 𑀔𑀸𑀤𑀢𑀺;

𑀬𑀤𑀸 𑀘 𑀔𑀸𑀬𑀺𑀢𑀸 𑀆𑀲𑀺, 𑀅𑀝𑁆𑀞𑀺𑀲𑀗𑁆𑀔𑀮𑀺𑀓𑀸 𑀓𑀢𑀸;

𑀑𑀕𑀸𑀳𑀲𑀺 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀺𑀁, 𑀳𑁄𑀢𑀺 𑀓𑀸𑀬𑁄 𑀬𑀣𑀸 𑀧𑀼𑀭𑁂.

𑁩𑁫𑁮.

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

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

𑁩𑁫𑁯.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀓𑀡𑁆𑀡𑀫𑀼𑀡𑁆𑀟𑁄 𑀲𑀼𑀦𑀔𑁄 𑀢𑀯𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑀸𑀦𑀺 𑀔𑀸𑀤𑀢𑀻’’𑀢𑀺.

𑁩𑁬𑁦.

‘‘𑀓𑀺𑀫𑀺𑀮𑀸𑀬𑀁 [𑀓𑀺𑀫𑁆𑀩𑀺𑀮𑀸𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀕𑀳𑀧𑀢𑀺, 𑀲𑀤𑁆𑀥𑁄 𑀆𑀲𑀺 𑀉𑀧𑀸𑀲𑀓𑁄;

𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀪𑀭𑀺𑀬𑀸 𑀆𑀲𑀺𑀁, 𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑀸 𑀅𑀢𑀺𑀘𑀸𑀭𑀺𑀦𑀻.

𑁩𑁬𑁧.

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

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

𑁩𑁬𑁨.

‘‘𑀲𑀸𑀳𑀁 𑀖𑁄𑀭𑀜𑁆𑀘 𑀲𑀧𑀣𑀁, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀜𑁆𑀘 𑀪𑀸𑀲𑀺𑀲𑀁;

‘𑀦𑀸𑀳𑀁 𑀢𑀁 𑀅𑀢𑀺𑀘𑀭𑀸𑀫𑀺, 𑀓𑀸𑀬𑁂𑀦 𑀉𑀤 𑀘𑁂𑀢𑀲𑀸.

𑁩𑁬𑁩.

‘‘‘𑀲𑀘𑀸𑀳𑀁 𑀢𑀁 𑀅𑀢𑀺𑀘𑀭𑀸𑀫𑀺, 𑀓𑀸𑀬𑁂𑀦 𑀉𑀤 𑀘𑁂𑀢𑀲𑀸;

𑀓𑀡𑁆𑀡𑀫𑀼𑀡𑁆𑀟𑁄 𑀬𑀁 𑀲𑀼𑀦𑀔𑁄, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑀸𑀦𑀺 𑀔𑀸𑀤𑀢𑀼’.

𑁩𑁬𑁪.

‘‘𑀢𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀯𑀺𑀧𑀸𑀓𑀁, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀲𑁆𑀲 𑀘𑀽𑀪𑀬𑀁;

𑀲𑀢𑁆𑀢𑁂𑀯 𑀯𑀲𑁆𑀲𑀲𑀢𑀸𑀦𑀺, 𑀅𑀦𑀼𑀪𑀽𑀢𑀁 𑀬𑀢𑁄 𑀳𑀺 𑀫𑁂;

𑀓𑀡𑁆𑀡𑀫𑀼𑀡𑁆𑀟𑁄 ¶ 𑀘 𑀲𑀼𑀦𑀔𑁄, 𑀅𑀗𑁆𑀕𑀫𑀗𑁆𑀕𑀸𑀦𑀺 𑀔𑀸𑀤𑀢𑀺.

𑁩𑁬𑁫.

‘‘𑀢𑁆𑀯𑀜𑁆𑀘 𑀤𑁂𑀯 𑀩𑀳𑀼𑀓𑀸𑀭𑁄, 𑀅𑀢𑁆𑀣𑀸𑀬 𑀫𑁂 𑀇𑀥𑀸𑀕𑀢𑁄;

𑀲𑀼𑀫𑀼𑀢𑁆𑀢𑀸𑀳𑀁 𑀓𑀡𑁆𑀡𑀫𑀼𑀡𑁆𑀟𑀲𑁆𑀲, 𑀅𑀲𑁄𑀓𑀸 𑀅𑀓𑀼𑀢𑁄𑀪𑀬𑀸.

𑁩𑁬𑁬.

‘‘𑀢𑀸𑀳𑀁 ¶ 𑀤𑁂𑀯 𑀦𑀫𑀲𑁆𑀲𑀸𑀫𑀺, 𑀬𑀸𑀘𑀸𑀫𑀺 𑀧𑀜𑁆𑀚𑀮𑀻𑀓𑀢𑀸;

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

𑁩𑁬𑁭.

‘‘𑀪𑀼𑀢𑁆𑀢𑀸 ¶ 𑀅𑀫𑀸𑀦𑀼𑀲𑀸 𑀓𑀸𑀫𑀸, 𑀭𑀫𑀺𑀢𑁄𑀫𑁆𑀳𑀺 𑀢𑀬𑀸 𑀲𑀳;

𑀢𑀸𑀳𑀁 𑀲𑀼𑀪𑀕𑁂 𑀬𑀸𑀘𑀸𑀫𑀺, 𑀔𑀺𑀧𑁆𑀧𑀁 𑀧𑀝𑀺𑀦𑀬𑀸𑀳𑀺 𑀫’’𑀦𑁆𑀢𑀺.

𑀓𑀡𑁆𑀡𑀫𑀼𑀡𑁆𑀟𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁.

𑁧𑁩. 𑀉𑀩𑁆𑀩𑀭𑀺𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁩𑁬𑁮.

𑀅𑀳𑀼 ¶ 𑀭𑀸𑀚𑀸 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑁄, 𑀧𑀜𑁆𑀘𑀸𑀮𑀸𑀦𑀁 𑀭𑀣𑁂𑀲𑀪𑁄;

𑀅𑀳𑁄𑀭𑀢𑁆𑀢𑀸𑀦𑀫𑀘𑁆𑀘𑀬𑀸, 𑀭𑀸𑀚𑀸 𑀓𑀸𑀮𑀫𑀓𑁆𑀭𑀼𑀩𑁆𑀩𑀣 [𑀭𑀸𑀚𑀸 𑀓𑀸𑀮𑀗𑁆𑀓𑀭𑀻 𑀢𑀤𑀸 (𑀲𑀻.)].

𑁩𑁬𑁯.

𑀢𑀲𑁆𑀲 𑀆𑀴𑀸𑀳𑀦𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀪𑀭𑀺𑀬𑀸 𑀓𑀦𑁆𑀤𑀢𑀺 𑀉𑀩𑁆𑀩𑀭𑀻 [𑀉𑀧𑁆𑀧𑀭𑀺 (𑀓.)];

𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀁 𑀅𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀻, 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀸𑀢𑀺 𑀓𑀦𑁆𑀤𑀢𑀺.

𑁩𑁭𑁦.

𑀇𑀲𑀺 𑀘 𑀢𑀢𑁆𑀣 𑀆𑀕𑀘𑁆𑀙𑀺, 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀘𑀭𑀡𑁄 𑀫𑀼𑀦𑀺;

𑀲𑁄 𑀘 𑀢𑀢𑁆𑀣 𑀅𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁆𑀣, 𑀬𑁂 𑀢𑀢𑁆𑀣 𑀲𑀼𑀲𑀫𑀸𑀕𑀢𑀸.

𑁩𑁭𑁧.

‘‘𑀓𑀲𑁆𑀲 𑀇𑀤𑀁 𑀆𑀴𑀸𑀳𑀦𑀁, 𑀦𑀸𑀦𑀸𑀕𑀦𑁆𑀥𑀲𑀫𑁂𑀭𑀺𑀢𑀁;

𑀓𑀲𑁆𑀲𑀸𑀬𑀁 𑀓𑀦𑁆𑀤𑀢𑀺 𑀪𑀭𑀺𑀬𑀸, 𑀇𑀢𑁄 𑀤𑀽𑀭𑀕𑀢𑀁 𑀧𑀢𑀺𑀁;

𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀁 𑀅𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀻, ‘𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀸’𑀢𑀺 𑀓𑀦𑁆𑀤𑀢𑀺’’.

𑁩𑁭𑁨.

𑀢𑁂 ¶ 𑀘 𑀢𑀢𑁆𑀣 𑀯𑀺𑀬𑀸𑀓𑀁𑀲𑀼, 𑀬𑁂 𑀢𑀢𑁆𑀣 𑀲𑀼𑀲𑀫𑀸𑀕𑀢𑀸;

‘‘𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀲𑁆𑀲 𑀪𑀤𑀦𑁆𑀢𑁂 [𑀪𑀤𑁆𑀤𑀦𑁆𑀢𑁂 (𑀓.)], 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀲𑁆𑀲 𑀫𑀸𑀭𑀺𑀲.

𑁩𑁭𑁩.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀇𑀤𑀁 𑀆𑀴𑀸𑀳𑀦𑀁, 𑀦𑀸𑀦𑀸𑀕𑀦𑁆𑀥𑀲𑀫𑁂𑀭𑀺𑀢𑀁;

𑀢𑀲𑁆𑀲𑀸𑀬𑀁 𑀓𑀦𑁆𑀤𑀢𑀺 𑀪𑀭𑀺𑀬𑀸, 𑀇𑀢𑁄 𑀤𑀽𑀭𑀕𑀢𑀁 𑀧𑀢𑀺𑀁;

𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀁 𑀅𑀧𑀲𑁆𑀲𑀦𑁆𑀢𑀻, ‘𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀸’𑀢𑀺 𑀓𑀦𑁆𑀤𑀢𑀺’’.

𑁩𑁭𑁪.

‘‘𑀙𑀴𑀸𑀲𑀻𑀢𑀺𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀲𑁆𑀲𑀦𑀸𑀫𑀓𑀸;

𑀇𑀫𑀲𑁆𑀫𑀺𑀁 𑀆𑀴𑀸𑀳𑀦𑁂 𑀤𑀟𑁆𑀠𑀸, 𑀢𑁂𑀲𑀁 𑀓𑀫𑀦𑀼𑀲𑁄𑀘𑀲𑀻’’𑀢𑀺.

𑁩𑁭𑁫.

‘‘𑀬𑁄 𑀭𑀸𑀚𑀸 𑀘𑀽𑀴𑀦𑀻𑀧𑀼𑀢𑁆𑀢𑁄, 𑀧𑀜𑁆𑀘𑀸𑀮𑀸𑀦𑀁 𑀭𑀣𑁂𑀲𑀪𑁄;

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

𑁩𑁭𑁬.

‘‘𑀲𑀩𑁆𑀩𑁂 𑀯𑀸𑀳𑁂𑀲𑀼𑀁 𑀭𑀸𑀚𑀸𑀦𑁄, 𑀩𑁆𑀭𑀳𑁆𑀫𑀤𑀢𑁆𑀢𑀲𑁆𑀲𑀦𑀸𑀫𑀓𑀸;

𑀲𑀩𑁆𑀩𑁂𑀯𑀘𑀽𑀴𑀦𑀻𑀧𑀼𑀢𑁆𑀢𑀸, 𑀧𑀜𑁆𑀘𑀸𑀮𑀸𑀦𑀁 𑀭𑀣𑁂𑀲𑀪𑀸.

𑁩𑁭𑁭.

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

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

𑁩𑁭𑁮.

‘‘𑀆𑀢𑀼𑀫𑁂 ¶ 𑀇𑀢𑁆𑀣𑀺𑀪𑀽𑀢𑀸𑀬, 𑀤𑀻𑀖𑀭𑀢𑁆𑀢𑀸𑀬 𑀫𑀸𑀭𑀺𑀲;

𑀬𑀲𑁆𑀲𑀸 𑀫𑁂 𑀇𑀢𑁆𑀣𑀺𑀪𑀽𑀢𑀸𑀬, 𑀲𑀁𑀲𑀸𑀭𑁂 𑀩𑀳𑀼𑀪𑀸𑀲𑀲𑀻’’𑀢𑀺.

𑁩𑁭𑁯.

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

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

𑁩𑁮𑁦.

‘‘𑀆𑀤𑀺𑀢𑁆𑀢𑀁 𑀯𑀢 𑀫𑀁 𑀲𑀦𑁆𑀢𑀁, 𑀖𑀢𑀲𑀺𑀢𑁆𑀢𑀁𑀯 𑀧𑀸𑀯𑀓𑀁;

𑀯𑀸𑀭𑀺𑀦𑀸 𑀯𑀺𑀬 𑀑𑀲𑀺𑀜𑁆𑀘𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀦𑀺𑀩𑁆𑀩𑀸𑀧𑀬𑁂 𑀤𑀭𑀁.

𑁩𑁮𑁧.

‘‘𑀅𑀩𑁆𑀩𑀳𑀻 𑀯𑀢 𑀫𑁂 𑀲𑀮𑁆𑀮𑀁, 𑀲𑁄𑀓𑀁 𑀳𑀤𑀬𑀦𑀺𑀲𑁆𑀲𑀺𑀢𑀁;

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

𑁩𑁮𑁨.

‘‘𑀲𑀸𑀳𑀁 ¶ 𑀅𑀩𑁆𑀩𑀽𑀴𑁆𑀳𑀲𑀮𑁆𑀮𑀸𑀲𑁆𑀫𑀺, 𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑀸𑀲𑁆𑀫𑀺 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀸;

𑀦 𑀲𑁄𑀘𑀸𑀫𑀺 𑀦 𑀭𑁄𑀤𑀸𑀫𑀺, 𑀢𑀯 𑀲𑀼𑀢𑁆𑀯𑀸 𑀫𑀳𑀸𑀫𑀼𑀦𑀻’’𑀢𑀺.

𑁩𑁮𑁩.

𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀲𑀫𑀡𑀲𑁆𑀲 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁;

𑀧𑀢𑁆𑀢𑀘𑀻𑀯𑀭𑀫𑀸𑀤𑀸𑀬, 𑀧𑀩𑁆𑀩𑀚𑀺 𑀅𑀦𑀕𑀸𑀭𑀺𑀬𑀁.

𑁩𑁮𑁪.

𑀲𑀸 𑀘 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀸 𑀲𑀦𑁆𑀢𑀸, 𑀅𑀕𑀸𑀭𑀲𑁆𑀫𑀸 𑀅𑀦𑀕𑀸𑀭𑀺𑀬𑀁;

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

𑁩𑁮𑁫.

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

𑀉𑀭𑀼𑀯𑁂𑀮𑀸 𑀦𑀸𑀫 𑀲𑁄 𑀕𑀸𑀫𑁄, 𑀬𑀢𑁆𑀣 𑀓𑀸𑀮𑀫𑀓𑁆𑀭𑀼𑀩𑁆𑀩𑀣.

𑁩𑁮𑁬.

𑀫𑁂𑀢𑁆𑀢𑀸𑀘𑀺𑀢𑁆𑀢𑀁 ¶ 𑀆𑀪𑀸𑀯𑁂𑀢𑁆𑀯𑀸, 𑀩𑁆𑀭𑀳𑁆𑀫𑀮𑁄𑀓𑀽𑀧𑀧𑀢𑁆𑀢𑀺𑀬𑀸;

𑀇𑀢𑁆𑀣𑀺𑀘𑀺𑀢𑁆𑀢𑀁 𑀯𑀺𑀭𑀸𑀚𑁂𑀢𑁆𑀯𑀸, 𑀩𑁆𑀭𑀳𑁆𑀫𑀮𑁄𑀓𑀽𑀧𑀕𑀸 𑀅𑀳𑀽𑀢𑀺.

𑀉𑀩𑁆𑀩𑀭𑀺𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀢𑁂𑀭𑀲𑀫𑀁.

𑀉𑀩𑁆𑀩𑀭𑀺𑀯𑀕𑁆𑀕𑁄 𑀤𑀼𑀢𑀺𑀬𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

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

𑀫𑁄𑀘𑀓𑀁 [𑀧𑀡𑁆𑀟𑀼 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)] 𑀫𑀸𑀢𑀸 𑀫𑀢𑁆𑀢𑀸 [𑀧𑀺𑀢𑀸 (𑀲𑀻. 𑀓.), 𑀧𑀢𑀺𑀬𑀸 (𑀲𑁆𑀬𑀸.)] 𑀘, 𑀦𑀦𑁆𑀤𑀸 𑀓𑀼𑀡𑁆𑀟𑀮𑀻𑀦𑀸 𑀖𑀝𑁄;

𑀤𑁆𑀯𑁂 𑀲𑁂𑀝𑁆𑀞𑀻 𑀢𑀼𑀦𑁆𑀦𑀯𑀸𑀬𑁄 𑀘, 𑀉𑀢𑁆𑀢𑀭 [𑀯𑀺𑀳𑀸𑀭 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)] 𑀲𑀼𑀢𑁆𑀢𑀓𑀡𑁆𑀡 [𑀲𑁄𑀧𑀸𑀦 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)] 𑀉𑀩𑁆𑀩𑀭𑀻𑀢𑀺.

𑁩. 𑀘𑀽𑀴𑀯𑀕𑁆𑀕𑁄

𑁧. 𑀅𑀪𑀺𑀚𑁆𑀚𑀫𑀸𑀦𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁩𑁮𑁭.

‘‘𑀅𑀪𑀺𑀚𑁆𑀚𑀫𑀸𑀦𑁂 ¶ ¶ ¶ 𑀯𑀸𑀭𑀺𑀫𑁆𑀳𑀺, 𑀕𑀗𑁆𑀕𑀸𑀬 𑀇𑀥 𑀕𑀘𑁆𑀙𑀲𑀺;

𑀦𑀕𑁆𑀕𑁄 𑀧𑀼𑀩𑁆𑀩𑀤𑁆𑀥𑀧𑁂𑀢𑁄𑀯 𑀫𑀸𑀮𑀥𑀸𑀭𑀻 𑀅𑀮𑀗𑁆𑀓𑀢𑁄;

𑀓𑀼𑀳𑀺𑀁 𑀕𑀫𑀺𑀲𑁆𑀲𑀲𑀺 𑀧𑁂𑀢, 𑀓𑀢𑁆𑀣 𑀯𑀸𑀲𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀻’’𑀢𑀺.

𑁩𑁮𑁮.

‘‘𑀘𑀼𑀦𑁆𑀤𑀝𑁆𑀞𑀺𑀮𑀁 ¶ [𑀘𑀼𑀦𑁆𑀤𑀝𑁆𑀞𑀺𑀓𑀁 (𑀲𑀻.)] 𑀕𑀫𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀧𑁂𑀢𑁄 𑀲𑁄 𑀇𑀢𑀺 𑀪𑀸𑀲𑀢𑀺;

𑀅𑀦𑁆𑀢𑀭𑁂 𑀯𑀸𑀲𑀪𑀕𑀸𑀫𑀁, 𑀩𑀸𑀭𑀸𑀡𑀲𑀺𑀁 𑀘 [𑀩𑀸𑀭𑀸𑀡𑀲𑀺𑀬𑀸 𑀘 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀲𑀦𑁆𑀢𑀺𑀓𑁂’’.

𑁩𑁮𑁯.

𑀢𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀯𑀸 𑀫𑀳𑀸𑀫𑀢𑁆𑀢𑁄, 𑀓𑁄𑀮𑀺𑀬𑁄 𑀇𑀢𑀺 𑀯𑀺𑀲𑁆𑀲𑀼𑀢𑁄;

𑀲𑀢𑁆𑀢𑀼𑀁 𑀪𑀢𑁆𑀢𑀜𑁆𑀘 𑀧𑁂𑀢𑀲𑁆𑀲, 𑀧𑀻𑀢𑀓𑀜𑁆𑀘 𑀬𑀼𑀕𑀁 𑀅𑀤𑀸.

𑁩𑁯𑁦.

𑀦𑀸𑀯𑀸𑀬 𑀢𑀺𑀝𑁆𑀞𑀫𑀸𑀦𑀸𑀬, 𑀓𑀧𑁆𑀧𑀓𑀲𑁆𑀲 𑀅𑀤𑀸𑀧𑀬𑀺;

𑀓𑀧𑁆𑀧𑀓𑀲𑁆𑀲 𑀧𑀤𑀺𑀦𑁆𑀦𑀫𑁆𑀳𑀺, 𑀞𑀸𑀦𑁂 𑀧𑁂𑀢𑀲𑁆𑀲 𑀤𑀺𑀲𑁆𑀲𑀣 [𑀧𑁂𑀢𑀲𑁆𑀲𑀼’𑀤𑀺𑀲𑁆𑀲𑀣 (𑀲𑀻.), 𑀧𑁂𑀢𑀲𑁆𑀲𑀼’𑀤𑀺𑀘𑁆𑀙𑀣 (?)].

𑁩𑁯𑁧.

𑀢𑀢𑁄 𑀲𑀼𑀯𑀢𑁆𑀣𑀯𑀲𑀦𑁄, 𑀫𑀸𑀮𑀥𑀸𑀭𑀻 𑀅𑀮𑀗𑁆𑀓𑀢𑁄;

𑀞𑀸𑀦𑁂 𑀞𑀺𑀢𑀲𑁆𑀲 𑀧𑁂𑀢𑀲𑁆𑀲, 𑀤𑀓𑁆𑀔𑀺𑀡𑀸 𑀉𑀧𑀓𑀧𑁆𑀧𑀣;

𑀢𑀲𑁆𑀫𑀸 𑀤𑀚𑁆𑀚𑁂𑀣 𑀧𑁂𑀢𑀸𑀦𑀁, 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀸𑀬 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁.

𑁩𑁯𑁨.

𑀲𑀸𑀢𑀼𑀦𑁆𑀦𑀯𑀲𑀦𑀸 [𑀲𑀸𑀳𑀼𑀦𑁆𑀦𑀯𑀸𑀲𑀺𑀦𑁄 (𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀲𑀸𑀳𑀼𑀦𑁆𑀤𑀯𑀸𑀲𑀺𑀦𑁄 (𑀓.)] 𑀏𑀓𑁂, 𑀅𑀜𑁆𑀜𑁂 𑀓𑁂𑀲𑀦𑀺𑀯𑀸𑀲𑀦𑀸 [𑀓𑁂𑀲𑀦𑀺𑀯𑀸𑀲𑀺𑀦𑁄 (𑀲𑁆𑀬𑀸. 𑀓.)];

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

𑁩𑁯𑁩.

𑀤𑀽𑀭𑁂 𑀏𑀓𑁂 [𑀤𑀽𑀭𑁂 𑀧𑁂𑀢𑀸 (𑀓.)] 𑀧𑀥𑀸𑀯𑀺𑀢𑁆𑀯𑀸, 𑀅𑀮𑀤𑁆𑀥𑀸𑀯 𑀦𑀺𑀯𑀢𑁆𑀢𑀭𑁂;

𑀙𑀸𑀢𑀸 𑀧𑀫𑀼𑀘𑁆𑀙𑀺𑀢𑀸 𑀪𑀦𑁆𑀢𑀸, 𑀪𑀽𑀫𑀺𑀬𑀁 𑀧𑀝𑀺𑀲𑀼𑀫𑁆𑀪𑀺𑀢𑀸.

𑁩𑁯𑁪.

𑀢𑁂 𑀘 [𑀓𑁂𑀘𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀢𑀢𑁆𑀣 𑀧𑀧𑀢𑀺𑀢𑀸 [𑀧𑀧𑀢𑀺𑀢𑁆𑀯𑀸 (𑀲𑀻.), 𑀘 𑀧𑀢𑀺𑀢𑀸 (𑀲𑁆𑀬𑀸.)], 𑀪𑀽𑀫𑀺𑀬𑀁 𑀧𑀝𑀺𑀲𑀼𑀫𑁆𑀪𑀺𑀢𑀸;

𑀧𑀼𑀩𑁆𑀩𑁂 𑀅𑀓𑀢𑀓𑀮𑁆𑀬𑀸𑀡𑀸, 𑀅𑀕𑁆𑀕𑀺𑀤𑀟𑁆𑀠𑀸𑀯 𑀆𑀢𑀧𑁂.

𑁩𑁯𑁫.

‘‘𑀫𑀬𑀁 𑀧𑀼𑀩𑁆𑀩𑁂 𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑀸, 𑀖𑀭𑀡𑀻 𑀓𑀼𑀮𑀫𑀸𑀢𑀭𑁄;

𑀲𑀦𑁆𑀢𑁂𑀲𑀼 𑀤𑁂𑀬𑁆𑀬𑀥𑀫𑁆𑀫𑁂𑀲𑀼, 𑀤𑀻𑀧𑀁 𑀦𑀸𑀓𑀫𑁆𑀳 𑀅𑀢𑁆𑀢𑀦𑁄.

𑁩𑁯𑁬.

‘‘𑀧𑀳𑀽𑀢𑀁 ¶ ¶ 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑀫𑁆𑀧𑀺, 𑀅𑀧𑀺𑀲𑁆𑀲𑀼 𑀅𑀯𑀓𑀺𑀭𑀻𑀬𑀢𑀺;

𑀲𑀫𑁆𑀫𑀕𑁆𑀕𑀢𑁂 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑁂, 𑀦 𑀘 𑀓𑀺𑀜𑁆𑀘𑀺 𑀅𑀤𑀫𑁆𑀳𑀲𑁂.

𑁩𑁯𑁭.

‘‘𑀅𑀓𑀫𑁆𑀫𑀓𑀸𑀫𑀸 ¶ 𑀅𑀮𑀲𑀸, 𑀲𑀸𑀤𑀼𑀓𑀸𑀫𑀸 𑀫𑀳𑀕𑁆𑀖𑀲𑀸;

𑀆𑀮𑁄𑀧𑀧𑀺𑀡𑁆𑀟𑀤𑀸𑀢𑀸𑀭𑁄, 𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑁂 𑀧𑀭𑀺𑀪𑀸𑀲𑀺𑀫𑁆𑀳𑀲𑁂 [𑀧𑀭𑀺𑀪𑀸𑀲𑀺𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑁩𑁯𑁮.

‘‘𑀢𑁂 ¶ 𑀖𑀭𑀸 𑀢𑀸 𑀘 𑀤𑀸𑀲𑀺𑀬𑁄, 𑀢𑀸𑀦𑁂𑀯𑀸𑀪𑀭𑀡𑀸𑀦𑀺 𑀦𑁄;

𑀢𑁂 𑀅𑀜𑁆𑀜𑁂 𑀧𑀭𑀺𑀘𑀸𑀭𑁂𑀦𑁆𑀢𑀺, 𑀫𑀬𑀁 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀪𑀸𑀕𑀺𑀦𑁄.

𑁩𑁯𑁯.

‘‘𑀯𑁂𑀡𑀻 𑀯𑀸 𑀅𑀯𑀜𑁆𑀜𑀸 𑀳𑁄𑀦𑁆𑀢𑀺, 𑀭𑀣𑀓𑀸𑀭𑀻 𑀘 𑀤𑀼𑀩𑁆𑀪𑀺𑀓𑀸;

𑀘𑀡𑁆𑀟𑀸𑀮𑀻 𑀓𑀧𑀡𑀸 𑀳𑁄𑀦𑁆𑀢𑀺, 𑀓𑀧𑁆𑀧𑀓𑀸 [𑀦𑁆𑀳𑀸𑀧𑀺𑀓𑀸 (𑀲𑀻.)] 𑀘 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁.

𑁪𑁦𑁦.

‘‘𑀬𑀸𑀦𑀺 𑀬𑀸𑀦𑀺 𑀦𑀺𑀳𑀻𑀦𑀸𑀦𑀺, 𑀓𑀼𑀮𑀸𑀦𑀺 𑀓𑀧𑀡𑀸𑀦𑀺 𑀘;

𑀢𑁂𑀲𑀼 𑀢𑁂𑀲𑁆𑀯𑁂𑀯 𑀚𑀸𑀬𑀦𑁆𑀢𑀺, 𑀏𑀲𑀸 𑀫𑀘𑁆𑀙𑀭𑀺𑀦𑁄 𑀕𑀢𑀺.

𑁪𑁦𑁧.

‘‘𑀧𑀼𑀩𑁆𑀩𑁂 𑀘 𑀓𑀢𑀓𑀮𑁆𑀬𑀸𑀡𑀸, 𑀤𑀸𑀬𑀓𑀸 𑀯𑀻𑀢𑀫𑀘𑁆𑀙𑀭𑀸;

𑀲𑀕𑁆𑀕𑀁 𑀢𑁂 𑀧𑀭𑀺𑀧𑀽𑀭𑁂𑀦𑁆𑀢𑀺, 𑀑𑀪𑀸𑀲𑁂𑀦𑁆𑀢𑀺 𑀘 𑀦𑀦𑁆𑀤𑀦𑀁.

𑁪𑁦𑁨.

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

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

𑁪𑁦𑁩.

‘‘𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑁂 𑀘 𑀧𑀸𑀲𑀸𑀤𑁂, 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑁂 𑀕𑁄𑀦𑀓𑀢𑁆𑀣𑀢𑁂;

𑀩𑀻𑀚𑀺𑀢𑀗𑁆𑀕𑀸 [𑀯𑀻𑀚𑀺𑀢𑀗𑁆𑀕𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀫𑁄𑀭𑀳𑀢𑁆𑀣𑁂𑀳𑀺, 𑀓𑀼𑀮𑁂 𑀚𑀸𑀢𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑁄.

𑁪𑁦𑁪.

‘‘𑀅𑀗𑁆𑀓𑀢𑁄 𑀅𑀗𑁆𑀓𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺, 𑀫𑀸𑀮𑀥𑀸𑀭𑀻 𑀅𑀮𑀗𑁆𑀓𑀢𑀸;

𑀥𑀸𑀢𑀺𑀬𑁄 𑀉𑀧𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺, 𑀲𑀸𑀬𑀁 𑀧𑀸𑀢𑀁 𑀲𑀼𑀔𑁂𑀲𑀺𑀦𑁄.

𑁪𑁦𑁫.

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

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

𑁪𑁦𑁬.

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

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

𑁪𑁦𑁭.

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

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

𑀅𑀪𑀺𑀚𑁆𑀚𑀫𑀸𑀦𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀧𑀞𑀫𑀁.

𑁨. 𑀲𑀸𑀡𑀯𑀸𑀲𑀻𑀣𑁂𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪𑁦𑁮.

𑀓𑀼𑀡𑁆𑀟𑀺𑀦𑀸𑀕𑀭𑀺𑀬𑁄 ¶ 𑀣𑁂𑀭𑁄, 𑀲𑀸𑀡𑀯𑀸𑀲𑀺 [𑀲𑀸𑀦𑀼𑀯𑀸𑀲𑀺 (𑀲𑀻.), 𑀲𑀸𑀦𑀯𑀸𑀲𑀺 (𑀲𑁆𑀬𑀸.)] 𑀦𑀺𑀯𑀸𑀲𑀺𑀓𑁄;

𑀧𑁄𑀝𑁆𑀞𑀧𑀸𑀤𑁄𑀢𑀺 𑀦𑀸𑀫𑁂𑀦, 𑀲𑀫𑀡𑁄 𑀪𑀸𑀯𑀺𑀢𑀺𑀦𑁆𑀤𑁆𑀭𑀺𑀬𑁄.

𑁪𑁦𑁯.

𑀢𑀲𑁆𑀲 ¶ 𑀫𑀸𑀢𑀸 𑀧𑀺𑀢𑀸 𑀪𑀸𑀢𑀸, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 ¶ 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸.

𑁪𑁧𑁦.

𑀢𑁂 ¶ 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀲𑀽𑀘𑀺𑀓𑀝𑁆𑀝𑀸, 𑀓𑀺𑀮𑀦𑁆𑀢𑀸 𑀦𑀕𑁆𑀕𑀺𑀦𑁄 𑀓𑀺𑀲𑀸;

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

𑁪𑁧𑁧.

𑀢𑀲𑁆𑀲 𑀪𑀸𑀢𑀸 𑀯𑀺𑀢𑀭𑀺𑀢𑁆𑀯𑀸, 𑀦𑀕𑁆𑀕𑁄 𑀏𑀓𑀧𑀣𑁂𑀓𑀓𑁄;

𑀘𑀢𑀼𑀓𑀼𑀡𑁆𑀟𑀺𑀓𑁄 𑀪𑀯𑀺𑀢𑁆𑀯𑀸𑀦, 𑀣𑁂𑀭𑀲𑁆𑀲 𑀤𑀲𑁆𑀲𑀬𑀻𑀢𑀼𑀫𑀁.

𑁪𑁧𑁨.

𑀣𑁂𑀭𑁄 𑀘𑀸𑀫𑀦𑀲𑀺𑀓𑀢𑁆𑀯𑀸, 𑀢𑀼𑀡𑁆𑀳𑀻𑀪𑀽𑀢𑁄 𑀅𑀢𑀺𑀓𑁆𑀓𑀫𑀺;

𑀲𑁄 𑀘 𑀯𑀺𑀜𑁆𑀜𑀸𑀧𑀬𑀻 𑀣𑁂𑀭𑀁, ‘𑀪𑀸𑀢𑀸 𑀧𑁂𑀢𑀕𑀢𑁄 𑀅𑀳𑀁’.

𑁪𑁧𑁩.

‘‘𑀫𑀸𑀢𑀸 ¶ 𑀧𑀺𑀢𑀸 𑀘 𑀢𑁂 𑀪𑀦𑁆𑀢𑁂, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸.

𑁪𑁧𑁪.

‘‘𑀢𑁂 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀲𑀽𑀘𑀺𑀓𑀝𑁆𑀝𑀸, 𑀓𑀺𑀮𑀦𑁆𑀢𑀸 𑀦𑀕𑁆𑀕𑀺𑀦𑁄 𑀓𑀺𑀲𑀸;

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

𑁪𑁧𑁫.

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

𑀢𑀯 𑀤𑀺𑀦𑁆𑀦𑁂𑀦 𑀤𑀸𑀦𑁂𑀦, 𑀬𑀸𑀧𑁂𑀲𑁆𑀲𑀦𑁆𑀢𑀺 𑀓𑀼𑀭𑀽𑀭𑀺𑀦𑁄’’𑀢𑀺.

𑁪𑁧𑁬.

𑀣𑁂𑀭𑁄 𑀘𑀭𑀺𑀢𑁆𑀯𑀸 𑀧𑀺𑀡𑁆𑀟𑀸𑀬, 𑀪𑀺𑀓𑁆𑀔𑀽 𑀅𑀜𑁆𑀜𑁂 𑀘 𑀤𑁆𑀯𑀸𑀤𑀲;

𑀏𑀓𑀚𑁆𑀛𑀁 𑀲𑀦𑁆𑀦𑀺𑀧𑀢𑀺𑀁𑀲𑀼, 𑀪𑀢𑁆𑀢𑀯𑀺𑀲𑁆𑀲𑀕𑁆𑀕𑀓𑀸𑀭𑀡𑀸.

𑁪𑁧𑁭.

𑀣𑁂𑀭𑁄 𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀆𑀳, ‘‘𑀬𑀣𑀸𑀮𑀤𑁆𑀥𑀁 𑀤𑀤𑀸𑀣 𑀫𑁂;

𑀲𑀗𑁆𑀖𑀪𑀢𑁆𑀢𑀁 𑀓𑀭𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀸𑀬 𑀜𑀸𑀢𑀺𑀦𑀁’’.

𑁪𑁧𑁮.

𑀦𑀺𑀬𑁆𑀬𑀸𑀤𑀬𑀺𑀁𑀲𑀼 𑀣𑁂𑀭𑀲𑁆𑀲, 𑀣𑁂𑀭𑁄 𑀲𑀗𑁆𑀖𑀁 𑀦𑀺𑀫𑀦𑁆𑀢𑀬𑀺;

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

‘‘𑀇𑀤𑀁 𑀫𑁂 𑀜𑀸𑀢𑀻𑀦𑀁 𑀳𑁄𑀢𑀼, 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀼 𑀜𑀸𑀢𑀬𑁄’’.

𑁪𑁧𑁯.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂, 𑀪𑁄𑀚𑀦𑀁 𑀉𑀤𑀧𑀚𑁆𑀚𑀣;

𑀲𑀼𑀘𑀺𑀁 𑀧𑀡𑀻𑀢𑀁 𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁, 𑀅𑀦𑁂𑀓𑀭𑀲𑀩𑁆𑀬𑀜𑁆𑀚𑀦𑀁.

𑁪𑁨𑁦.

𑀢𑀢𑁄 𑀉𑀤𑁆𑀤𑀲𑁆𑀲𑀬𑀻 [𑀉𑀤𑁆𑀤𑀺𑀲𑀬𑀻 (𑀲𑀻. 𑀓.), 𑀉𑀤𑁆𑀤𑀺𑀲𑁆𑀲𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀪𑀸𑀢𑀸, 𑀯𑀡𑁆𑀡𑀯𑀸 𑀩𑀮𑀯𑀸 𑀲𑀼𑀔𑀻;

‘‘𑀧𑀳𑀽𑀢𑀁 𑀪𑁄𑀚𑀦𑀁 𑀪𑀦𑁆𑀢𑁂, 𑀧𑀲𑁆𑀲 𑀦𑀕𑁆𑀕𑀸𑀫𑁆𑀳𑀲𑁂 𑀫𑀬𑀁;

𑀢𑀣𑀸 𑀪𑀦𑁆𑀢𑁂 𑀧𑀭𑀓𑁆𑀓𑀫, 𑀬𑀣𑀸 𑀯𑀢𑁆𑀣𑀁 𑀮𑀪𑀸𑀫𑀲𑁂’’𑀢𑀺.

𑁪𑁨𑁧.

𑀣𑁂𑀭𑁄 ¶ 𑀲𑀗𑁆𑀓𑀸𑀭𑀓𑀽𑀝𑀫𑁆𑀳𑀸, 𑀉𑀘𑁆𑀘𑀺𑀦𑀺𑀢𑁆𑀯𑀸𑀦 𑀦𑀦𑁆𑀢𑀓𑁂;

𑀧𑀺𑀮𑁄𑀢𑀺𑀓𑀁 ¶ 𑀧𑀝𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀲𑀗𑁆𑀖𑁂 𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑁂 𑀅𑀤𑀸.

𑁪𑁨𑁨.

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

‘‘𑀇𑀤𑀁 𑀫𑁂 𑀜𑀸𑀢𑀻𑀦𑀁 𑀳𑁄𑀢𑀼, 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀼 𑀜𑀸𑀢𑀬𑁄’’.

𑁪𑁨𑁩.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂, 𑀯𑀢𑁆𑀣𑀸𑀦𑀺 𑀉𑀤𑀧𑀚𑁆𑀚𑀺𑀲𑀼𑀁;

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

𑁪𑁨𑁪.

‘‘𑀬𑀸𑀯𑀢𑀸 ¶ 𑀦𑀦𑁆𑀤𑀭𑀸𑀚𑀲𑁆𑀲, 𑀯𑀺𑀚𑀺𑀢𑀲𑁆𑀫𑀺𑀁 𑀧𑀝𑀺𑀘𑁆𑀙𑀤𑀸;

𑀢𑀢𑁄 𑀩𑀳𑀼𑀢𑀭𑀸 𑀪𑀦𑁆𑀢𑁂, 𑀯𑀢𑁆𑀣𑀸𑀦𑀘𑁆𑀙𑀸𑀤𑀦𑀸𑀦𑀺 𑀦𑁄.

𑁪𑁨𑁫.

‘‘𑀓𑁄𑀲𑁂𑀬𑁆𑀬𑀓𑀫𑁆𑀩𑀮𑀻𑀬𑀸𑀦𑀺, 𑀔𑁄𑀫 𑀓𑀧𑁆𑀧𑀸𑀲𑀺𑀓𑀸𑀦𑀺 𑀘;

𑀯𑀺𑀧𑀼𑀮𑀸 𑀘 𑀫𑀳𑀕𑁆𑀖𑀸 𑀘, 𑀢𑁂𑀧𑀸𑀓𑀸𑀲𑁂𑀯𑀮𑀫𑁆𑀩𑀭𑁂.

𑁪𑁨𑁬.

‘‘𑀢𑁂 𑀫𑀬𑀁 𑀧𑀭𑀺𑀤𑀳𑀸𑀫, 𑀬𑀁 𑀬𑀁 𑀳𑀺 𑀫𑀦𑀲𑁄 𑀧𑀺𑀬𑀁;

𑀢𑀣𑀸 𑀪𑀦𑁆𑀢𑁂 𑀧𑀭𑀓𑁆𑀓𑀫, 𑀬𑀣𑀸 𑀕𑁂𑀳𑀁 𑀮𑀪𑀸𑀫𑀲𑁂’’𑀢𑀺.

𑁪𑁨𑁭.

𑀣𑁂𑀭𑁄 𑀧𑀡𑁆𑀡𑀓𑀼𑀝𑀺𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀲𑀗𑁆𑀖𑁂 𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑁂 𑀅𑀤𑀸;

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

‘‘𑀇𑀤𑀁 𑀫𑁂 𑀜𑀸𑀢𑀻𑀦𑀁 𑀳𑁄𑀢𑀼, 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀼 𑀜𑀸𑀢𑀬𑁄’’.

𑁪𑁨𑁮.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂 ¶ , 𑀖𑀭𑀸𑀦𑀺 𑀉𑀤𑀧𑀚𑁆𑀚𑀺𑀲𑀼𑀁;

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

𑁪𑁨𑁯.

‘‘𑀦 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀈𑀤𑀺𑀲𑀸, 𑀬𑀸𑀤𑀺𑀲𑀸 𑀦𑁄 𑀖𑀭𑀸 𑀇𑀥;

𑀅𑀧𑀺 𑀤𑀺𑀩𑁆𑀩𑁂𑀲𑀼 𑀬𑀸𑀤𑀺𑀲𑀸, 𑀢𑀸𑀤𑀺𑀲𑀸 𑀦𑁄 𑀖𑀭𑀸 𑀇𑀥.

𑁪𑁩𑁦.

‘‘𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀸 ¶ 𑀆𑀪𑁂𑀦𑁆𑀢𑀺 [𑀆𑀪𑀦𑁆𑀢𑀺 (𑀓.)], 𑀲𑀫𑀦𑁆𑀢𑀸 𑀘𑀢𑀼𑀭𑁄 𑀤𑀺𑀲𑀸;

‘𑀢𑀣𑀸 𑀪𑀦𑁆𑀢𑁂 𑀧𑀭𑀓𑁆𑀓𑀫, 𑀬𑀣𑀸 𑀧𑀸𑀦𑀻𑀬𑀁 𑀮𑀪𑀸𑀫𑀲𑁂’’𑀢𑀺.

𑁪𑁩𑁧.

𑀣𑁂𑀭𑁄 𑀓𑀭𑀡𑀁 [𑀓𑀭𑀓𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀧𑀽𑀭𑁂𑀢𑁆𑀯𑀸, 𑀲𑀗𑁆𑀖𑁂 𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑁂 𑀅𑀤𑀸;

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

‘‘𑀇𑀤𑀁 𑀫𑁂 𑀜𑀸𑀢𑀻𑀦𑀁 𑀳𑁄𑀢𑀼, 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀼 𑀜𑀸𑀢𑀬𑁄’.

𑁪𑁩𑁨.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂, 𑀧𑀸𑀦𑀻𑀬𑀁 𑀉𑀤𑀧𑀚𑁆𑀚𑀣;

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

𑁪𑁩𑁩.

𑀲𑀻𑀢𑁄𑀤𑀺𑀓𑀸 ¶ 𑀲𑀼𑀧𑁆𑀧𑀢𑀺𑀢𑁆𑀣𑀸, 𑀲𑀻𑀢𑀸 𑀅𑀧𑁆𑀧𑀝𑀺𑀕𑀦𑁆𑀥𑀺𑀬𑀸;

𑀧𑀤𑀼𑀫𑀼𑀧𑁆𑀧𑀮𑀲𑀜𑁆𑀙𑀦𑁆𑀦𑀸, 𑀯𑀸𑀭𑀺𑀓𑀺𑀜𑁆𑀚𑀓𑁆𑀔𑀧𑀽𑀭𑀺𑀢𑀸.

𑁪𑁩𑁪.

𑀢𑀢𑁆𑀣 𑀦𑁆𑀳𑀢𑁆𑀯𑀸 𑀧𑀺𑀯𑀺𑀢𑁆𑀯𑀸 𑀘, 𑀣𑁂𑀭𑀲𑁆𑀲 𑀧𑀝𑀺𑀤𑀲𑁆𑀲𑀬𑀼𑀁;

‘‘𑀧𑀳𑀽𑀢𑀁 𑀧𑀸𑀦𑀻𑀬𑀁 𑀪𑀦𑁆𑀢𑁂, 𑀧𑀸𑀤𑀸 𑀤𑀼𑀓𑁆𑀔𑀸 𑀨𑀮𑀦𑁆𑀢𑀺 𑀦𑁄’’.

𑁪𑁩𑁫.

‘‘𑀆𑀳𑀺𑀡𑁆𑀟𑀫𑀸𑀦𑀸 𑀔𑀜𑁆𑀚𑀸𑀫, 𑀲𑀓𑁆𑀔𑀭𑁂 𑀓𑀼𑀲𑀓𑀡𑁆𑀝𑀓𑁂;

‘𑀢𑀣𑀸 𑀪𑀦𑁆𑀢𑁂 𑀧𑀭𑀓𑁆𑀓𑀫, 𑀬𑀣𑀸 𑀬𑀸𑀦𑀁 𑀮𑀪𑀸𑀫𑀲𑁂’’’𑀢𑀺.

𑁪𑁩𑁬.

𑀣𑁂𑀭𑁄 𑀲𑀺𑀧𑀸𑀝𑀺𑀓𑀁 𑀮𑀤𑁆𑀥𑀸, 𑀲𑀗𑁆𑀖𑁂 𑀘𑀸𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑁂 𑀅𑀤𑀸;

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

‘‘𑀇𑀤𑀁 𑀫𑁂 𑀜𑀸𑀢𑀻𑀦𑀁 𑀳𑁄𑀢𑀼, 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀼 𑀜𑀸𑀢𑀬𑁄’’.

𑁪𑁩𑁭.

𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂 ¶ , 𑀧𑁂𑀢𑀸 𑀭𑀣𑁂𑀦 𑀫𑀸𑀕𑀫𑀼𑀁;

‘‘𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀺𑀢𑀫𑁆𑀳 𑀪𑀤𑀦𑁆𑀢𑁂, 𑀪𑀢𑁆𑀢𑁂𑀦𑀘𑁆𑀙𑀸𑀤𑀦𑁂𑀦 𑀘.

𑁪𑁩𑁮.

‘‘𑀖𑀭𑁂𑀦 𑀧𑀸𑀦𑀻𑀬𑀤𑀸𑀦𑁂𑀦, 𑀬𑀸𑀦𑀤𑀸𑀦𑁂𑀦 𑀘𑀽𑀪𑀬𑀁;

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

𑀲𑀸𑀡𑀯𑀸𑀲𑀻𑀣𑁂𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀤𑀼𑀢𑀺𑀬𑀁.

𑁩. 𑀭𑀣𑀓𑀸𑀭𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁪𑁩𑁯.

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

𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀲𑀺 𑀤𑁂𑀯𑀺 𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁂, 𑀧𑀣𑀤𑁆𑀥𑀦𑀺 [𑀲𑀫𑀦𑁆𑀢𑀢𑁄 (𑀓.)] 𑀧𑀦𑁆𑀦𑀭𑀲𑁂𑀯 𑀘𑀦𑁆𑀤𑁄.

𑁪𑁪𑁦.

‘‘𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀓𑀦𑀓𑀲𑁆𑀲 𑀲𑀦𑁆𑀦𑀺𑀪𑁄, 𑀉𑀢𑁆𑀢𑀢𑁆𑀢𑀭𑀽𑀧𑁄 𑀪𑀼𑀲 𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑁄;

𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑀲𑁂𑀝𑁆𑀞𑁂 𑀅𑀢𑀼𑀮𑁂 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀸, 𑀏𑀓𑀸 𑀢𑀼𑀯𑀁 𑀦𑀢𑁆𑀣𑀺 𑀘 𑀢𑀼𑀬𑁆𑀳 𑀲𑀸𑀫𑀺𑀓𑁄.

𑁪𑁪𑁧.

‘‘𑀇𑀫𑀸 𑀘 𑀢𑁂 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻 𑀲𑀫𑀦𑁆𑀢𑀸, 𑀧𑀳𑀽𑀢𑀫𑀮𑁆𑀬𑀸 [𑀧𑀳𑀽𑀢𑀫𑀸𑀮𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀩𑀳𑀼𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀸;

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

𑁪𑁪𑁨.

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

𑀲𑀫𑀬𑁆𑀬 𑀯𑀕𑁆𑀕𑀽𑀧𑀦𑀤𑀦𑁆𑀢𑀺 𑀲𑀩𑁆𑀩𑁂, 𑀩𑀺𑀦𑁆𑀤𑀼𑀲𑁆𑀲𑀭𑀸 𑀤𑀼𑀦𑁆𑀤𑀼𑀪𑀻𑀦𑀁𑀯 𑀖𑁄𑀲𑁄.

𑁪𑁪𑁩.

‘‘𑀤𑀤𑁆𑀤𑀮𑁆𑀮𑀫𑀸𑀦𑀸 𑀬𑀲𑀲𑀸 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀻, 𑀦𑀸𑀯𑀸𑀬 𑀘 𑀢𑁆𑀯𑀁 𑀅𑀯𑀮𑀫𑁆𑀩 𑀢𑀺𑀝𑁆𑀞𑀲𑀺;

𑀆𑀴𑀸𑀭𑀧𑀫𑁆𑀳𑁂 ¶ 𑀳𑀲𑀺𑀢𑁂 𑀧𑀺𑀬𑀁𑀯𑀤𑁂, 𑀲𑀩𑁆𑀩𑀗𑁆𑀕𑀓𑀮𑁆𑀬𑀸𑀡𑀺 𑀪𑀼𑀲𑀁 𑀯𑀺𑀭𑁄𑀘𑀲𑀺.

𑁪𑁪𑁪.

‘‘𑀇𑀤𑀁 ¶ 𑀯𑀺𑀫𑀸𑀦𑀁 𑀯𑀺𑀭𑀚𑀁 𑀲𑀫𑁂 𑀞𑀺𑀢𑀁, 𑀉𑀬𑁆𑀬𑀸𑀦𑀯𑀦𑁆𑀢𑀁 [𑀉𑀬𑁆𑀬𑀸𑀦𑀯𑀦𑀁 (𑀓.)] 𑀭𑀢𑀺𑀦𑀦𑁆𑀤𑀺𑀯𑀟𑁆𑀠𑀦𑀁;

𑀇𑀘𑁆𑀙𑀸𑀫𑀳𑀁 𑀦𑀸𑀭𑀺 𑀅𑀦𑁄𑀫𑀤𑀲𑁆𑀲𑀦𑁂, 𑀢𑀬𑀸 𑀲𑀳 𑀦𑀦𑁆𑀤𑀦𑁂 𑀇𑀥 𑀫𑁄𑀤𑀺𑀢𑀼’’𑀦𑁆𑀢𑀺.

𑁪𑁪𑁫.

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

𑀓𑀢𑁆𑀯𑀸𑀦 𑀓𑀫𑁆𑀫𑀁 𑀇𑀥 𑀯𑁂𑀤𑀦𑀻𑀬𑀁, 𑀏𑀯𑀁 𑀫𑀫𑀁 𑀮𑀘𑁆𑀙𑀲𑀺 𑀓𑀸𑀫𑀓𑀸𑀫𑀺𑀦𑀺’’𑀦𑁆𑀢𑀺.

𑁪𑁪𑁬.

‘‘𑀲𑀸𑀥𑀽’’𑀢𑀺 𑀲𑁄 𑀢𑀲𑁆𑀲𑀸 𑀧𑀝𑀺𑀲𑁆𑀲𑀼𑀡𑀺𑀢𑁆𑀯𑀸, 𑀅𑀓𑀸𑀲𑀺 𑀓𑀫𑁆𑀫𑀁 𑀢𑀳𑀺𑀁 𑀯𑁂𑀤𑀦𑀻𑀬𑀁;

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

𑀭𑀣𑀓𑀸𑀭𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀢𑀢𑀺𑀬𑀁.

𑀪𑀸𑀡𑀯𑀸𑀭𑀁 𑀤𑀼𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁪. 𑀪𑀼𑀲𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪𑁪𑁭.

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

𑀢𑀼𑀯𑀜𑁆𑀘 ¶ 𑀕𑀽𑀣𑀁 𑀅𑀲𑀼𑀘𑀺𑀁 𑀅𑀓𑀦𑁆𑀢𑀁 [𑀅𑀓𑀦𑁆𑀢𑀺𑀓𑀁 (𑀲𑀻. 𑀧𑀻.)], 𑀧𑀭𑀺𑀪𑀼𑀜𑁆𑀚𑀲𑀺 𑀓𑀺𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄’’𑀢𑀺.

𑁪𑁪𑁮.

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

𑀅𑀬𑀁 𑀫𑀁𑀲𑀸𑀦𑀺 𑀔𑀸𑀤𑀺𑀢𑁆𑀯𑀸, 𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑁂𑀦 𑀯𑀜𑁆𑀘𑁂𑀢𑀺.

𑁪𑁪𑁯.

‘‘𑀅𑀳𑀁 𑀫𑀦𑀼𑀲𑁆𑀲𑁂𑀲𑀼 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑀸, 𑀅𑀕𑀸𑀭𑀺𑀦𑀻 𑀲𑀩𑁆𑀩𑀓𑀼𑀮𑀲𑁆𑀲 𑀇𑀲𑁆𑀲𑀭𑀸;

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

𑁪𑁫𑁦.

‘‘𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑁂𑀦 𑀙𑀸𑀤𑁂𑀫𑀺, ‘𑀦𑀢𑁆𑀣𑀺 𑀏𑀢𑀁 𑀫𑀫 𑀕𑁂𑀳𑁂;

𑀲𑀘𑁂 𑀲𑀦𑁆𑀢𑀁 𑀦𑀺𑀕𑀼𑀳𑀸𑀫𑀺, 𑀕𑀽𑀣𑁄 𑀫𑁂 𑀳𑁄𑀢𑀼 𑀪𑁄𑀚𑀦𑀁’.

𑁪𑁫𑁧.

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

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

𑁪𑁫𑁨.

‘‘𑀅𑀯𑀜𑁆𑀛𑀸𑀦𑀺 𑀘 𑀓𑀫𑁆𑀫𑀸𑀦𑀺, 𑀦 𑀳𑀺 𑀓𑀫𑁆𑀫𑀁 𑀯𑀺𑀦𑀲𑁆𑀲𑀢𑀺;

𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑀁 𑀓𑀺𑀫𑀺𑀦𑀁 [𑀓𑀺𑀫𑀺𑀚𑀁 (𑀲𑀻.)] 𑀫𑀻𑀴𑀁, 𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀺 𑀘 𑀧𑀺𑀯𑀸𑀫𑀺 𑀘𑀸’’𑀢𑀺.

𑀪𑀼𑀲𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

𑁫. 𑀓𑀼𑀫𑀸𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪𑁫𑁩.

𑀅𑀘𑁆𑀙𑁂𑀭𑀭𑀽𑀧𑀁 𑀲𑀼𑀕𑀢𑀲𑁆𑀲 𑀜𑀸𑀡𑀁, 𑀲𑀢𑁆𑀣𑀸 𑀬𑀣𑀸 𑀧𑀼𑀕𑁆𑀕𑀮𑀁 𑀩𑁆𑀬𑀸𑀓𑀸𑀲𑀺;

𑀉𑀲𑁆𑀲𑀦𑁆𑀦𑀧𑀼𑀜𑁆𑀜𑀸𑀧𑀺 𑀪𑀯𑀦𑁆𑀢𑀺 𑀳𑁂𑀓𑁂, 𑀧𑀭𑀺𑀢𑁆𑀢𑀧𑀼𑀜𑁆𑀜𑀸𑀧𑀺 𑀪𑀯𑀦𑁆𑀢𑀺 𑀳𑁂𑀓𑁂.

𑁪𑁫𑁪.

𑀅𑀬𑀁 ¶ 𑀓𑀼𑀫𑀸𑀭𑁄 𑀲𑀻𑀯𑀣𑀺𑀓𑀸𑀬 𑀙𑀟𑁆𑀟𑀺𑀢𑁄, 𑀅𑀗𑁆𑀕𑀼𑀝𑁆𑀞𑀲𑁆𑀦𑁂𑀳𑁂𑀦 ¶ 𑀬𑀸𑀧𑁂𑀢𑀺 𑀭𑀢𑁆𑀢𑀺𑀁;

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

𑁪𑁫𑁫.

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

𑀕𑀩𑁆𑀪𑀸𑀲𑀬𑀁 𑀧𑀓𑁆𑀔𑀺𑀕𑀡𑀸 𑀳𑀭𑀦𑁆𑀢𑀺, 𑀓𑀸𑀓𑀸 𑀧𑀦 𑀅𑀓𑁆𑀔𑀺𑀫𑀮𑀁 𑀳𑀭𑀦𑁆𑀢𑀺.

𑁪𑁫𑁬.

𑀦𑀬𑀺𑀫𑀲𑁆𑀲 ¶ [𑀦 𑀇𑀫𑀲𑁆𑀲 (𑀲𑁆𑀬𑀸.), 𑀦𑀺𑀫𑀲𑁆𑀲 (𑀓.)] 𑀭𑀓𑁆𑀔𑀁 𑀯𑀺𑀤𑀳𑀺𑀁𑀲𑀼 𑀓𑁂𑀘𑀺, 𑀦 𑀑𑀲𑀥𑀁 𑀲𑀸𑀲𑀧𑀥𑀽𑀧𑀦𑀁 𑀯𑀸;

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

𑁪𑁫𑁭.

𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀉𑀢𑁆𑀢𑀫𑀓𑀺𑀘𑁆𑀙𑀧𑀢𑁆𑀢𑀁, 𑀭𑀢𑁆𑀢𑀸𑀪𑀢𑀁 𑀲𑀻𑀯𑀣𑀺𑀓𑀸𑀬 𑀙𑀟𑁆𑀟𑀺𑀢𑀁;

𑀦𑁄𑀦𑀻𑀢𑀧𑀺𑀡𑁆𑀟𑀁𑀯 𑀧𑀯𑁂𑀥𑀫𑀸𑀦𑀁, 𑀲𑀲𑀁𑀲𑀬𑀁 𑀚𑀻𑀯𑀺𑀢𑀲𑀸𑀯𑀲𑁂𑀲𑀁.

𑁪𑁫𑁮.

𑀢𑀫𑀤𑁆𑀤𑀲𑀸 ¶ 𑀤𑁂𑀯𑀫𑀦𑀼𑀲𑁆𑀲𑀧𑀽𑀚𑀺𑀢𑁄, 𑀤𑀺𑀲𑁆𑀯𑀸 𑀘 𑀢𑀁 𑀩𑁆𑀬𑀸𑀓𑀭𑀺 𑀪𑀽𑀭𑀺𑀧𑀜𑁆𑀜𑁄;

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

𑁪𑁫𑁯.

‘‘𑀓𑀺𑀲𑁆𑀲 ¶ [𑀓𑀺𑀁’𑀲 (?)] 𑀯𑀢𑀁 𑀓𑀺𑀁 𑀧𑀦 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, 𑀓𑀺𑀲𑁆𑀲 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄;

𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀩𑁆𑀬𑀲𑀦𑀁 𑀧𑀸𑀧𑀼𑀡𑀺𑀢𑁆𑀯𑀸, 𑀢𑀁 𑀢𑀸𑀤𑀺𑀲𑀁 𑀧𑀘𑁆𑀘𑀦𑀼𑀪𑁄𑀲𑁆𑀲𑀢𑀺𑀤𑁆𑀥𑀺’’𑀦𑁆𑀢𑀺.

𑁪𑁬𑁦.

𑀩𑀼𑀤𑁆𑀥𑀧𑀫𑀼𑀔𑀲𑁆𑀲 𑀪𑀺𑀓𑁆𑀔𑀼𑀲𑀗𑁆𑀖𑀲𑁆𑀲, 𑀧𑀽𑀚𑀁 𑀅𑀓𑀸𑀲𑀺 𑀚𑀦𑀢𑀸 𑀉𑀴𑀸𑀭𑀁;

𑀢𑀢𑁆𑀭𑀲𑁆𑀲 𑀘𑀺𑀢𑁆𑀢𑀲𑁆𑀲𑀳𑀼 𑀅𑀜𑁆𑀜𑀣𑀢𑁆𑀢𑀁, 𑀯𑀸𑀘𑀁 𑀅𑀪𑀸𑀲𑀺 𑀨𑀭𑀼𑀲𑀁 𑀅𑀲𑀩𑁆𑀪𑀁.

𑁪𑁬𑁧.

𑀲𑁄 𑀢𑀁 𑀯𑀺𑀢𑀓𑁆𑀓𑀁 𑀧𑀯𑀺𑀦𑁄𑀤𑀬𑀺𑀢𑁆𑀯𑀸, 𑀧𑀻𑀢𑀺𑀁 𑀧𑀲𑀸𑀤𑀁 𑀧𑀝𑀺𑀮𑀤𑁆𑀥𑀸 𑀧𑀘𑁆𑀙𑀸;

𑀢𑀣𑀸𑀕𑀢𑀁 𑀚𑁂𑀢𑀯𑀦𑁂 𑀯𑀲𑀦𑁆𑀢𑀁, 𑀬𑀸𑀕𑀼𑀬𑀸 𑀉𑀧𑀝𑁆𑀞𑀸𑀲𑀺 𑀲𑀢𑁆𑀢𑀭𑀢𑁆𑀢𑀁.

𑁪𑁬𑁨.

𑀢𑀲𑁆𑀲 [𑀢𑀁’𑀲 (?)] 𑀯𑀢𑀁 𑀢𑀁 𑀧𑀦 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁, 𑀢𑀲𑁆𑀲 𑀲𑀼𑀘𑀺𑀡𑁆𑀡𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄;

𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀩𑁆𑀬𑀲𑀦𑀁 𑀧𑀸𑀧𑀼𑀡𑀺𑀢𑁆𑀯𑀸, 𑀢𑀁 𑀢𑀸𑀤𑀺𑀲𑀁 𑀧𑀘𑁆𑀘𑀦𑀼𑀪𑁄𑀲𑁆𑀲𑀢𑀺𑀤𑁆𑀥𑀺𑀁.

𑁪𑁬𑁩.

𑀞𑀢𑁆𑀯𑀸𑀦 ¶ 𑀲𑁄 𑀯𑀲𑁆𑀲𑀲𑀢𑀁 𑀇𑀥𑁂𑀯, 𑀲𑀩𑁆𑀩𑁂𑀳𑀺 𑀓𑀸𑀫𑁂𑀳𑀺 𑀲𑀫𑀗𑁆𑀕𑀺𑀪𑀽𑀢𑁄;

𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀅𑀪𑀺𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑀁, 𑀲𑀳𑀩𑁆𑀬𑀢𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀯𑀸𑀲𑀯𑀲𑁆𑀲𑀸𑀢𑀺.

𑀓𑀼𑀫𑀸𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀧𑀜𑁆𑀘𑀫𑀁.

𑁬. 𑀲𑁂𑀭𑀺𑀡𑀻𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪𑁬𑁪.

‘‘𑀦𑀕𑁆𑀕𑀸 ¶ ¶ 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀲𑀺, 𑀓𑀺𑀲𑀸 𑀥𑀫𑀦𑀺𑀲𑀦𑁆𑀣𑀢𑀸;

𑀉𑀧𑁆𑀨𑀸𑀲𑀼𑀮𑀺𑀓𑁂 𑀓𑀺𑀲𑀺𑀓𑁂, 𑀓𑀸 𑀦𑀼 𑀢𑁆𑀯𑀁 𑀇𑀥 𑀢𑀺𑀝𑁆𑀞𑀲𑀻’’𑀢𑀺.

𑁪𑁬𑁫.

‘‘𑀅𑀳𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀧𑁂𑀢𑀻𑀫𑁆𑀳𑀺, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁪𑁬𑁬.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁪𑁬𑁭.

‘‘𑀅𑀦𑀸𑀯𑀝𑁂𑀲𑀼 𑀢𑀺𑀢𑁆𑀣𑁂𑀲𑀼, 𑀯𑀺𑀘𑀺𑀦𑀺𑀁 𑀅𑀟𑁆𑀠𑀫𑀸𑀲𑀓𑀁;

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

𑁪𑁬𑁮.

‘‘𑀦𑀤𑀺𑀁 𑀉𑀧𑁂𑀫𑀺 𑀢𑀲𑀺𑀢𑀸, 𑀭𑀺𑀢𑁆𑀢𑀓𑀸 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑀢𑀺;

𑀙𑀸𑀬𑀁 𑀉𑀧𑁂𑀫𑀺 𑀉𑀡𑁆𑀳𑁂𑀲𑀼, 𑀆𑀢𑀧𑁄 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑀢𑀺.

𑁪𑁬𑁯.

‘‘𑀅𑀕𑁆𑀕𑀺𑀯𑀡𑁆𑀡𑁄 𑀘 𑀫𑁂 𑀯𑀸𑀢𑁄, 𑀟𑀳𑀦𑁆𑀢𑁄 𑀉𑀧𑀯𑀸𑀬𑀢𑀺;

𑀏𑀢𑀜𑁆𑀘 𑀪𑀦𑁆𑀢𑁂 𑀅𑀭𑀳𑀸𑀫𑀺, 𑀅𑀜𑁆𑀜𑀜𑁆𑀘 𑀧𑀸𑀧𑀓𑀁 𑀢𑀢𑁄.

𑁪𑁭𑁦.

‘‘𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 ¶ ¶ 𑀳𑀢𑁆𑀣𑀺𑀦𑀺𑀁 𑀧𑀼𑀭𑀁, 𑀯𑀚𑁆𑀚𑁂𑀲𑀺 𑀫𑀬𑁆𑀳 𑀫𑀸𑀢𑀭𑀁;

‘𑀥𑀻𑀢𑀸 𑀘 𑀢𑁂 𑀫𑀬𑀸 𑀤𑀺𑀝𑁆𑀞𑀸, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’.

𑁪𑁭𑁧.

‘‘𑀅𑀢𑁆𑀣𑀺 𑀫𑁂 𑀏𑀢𑁆𑀣 𑀦𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀁, 𑀅𑀦𑀓𑁆𑀔𑀸𑀢𑀜𑁆𑀘 𑀢𑀁 𑀫𑀬𑀸;

𑀘𑀢𑁆𑀢𑀸𑀭𑀺𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑀲𑁆𑀲 𑀘 𑀳𑁂𑀝𑁆𑀞𑀢𑁄.

𑁪𑁭𑁨.

‘‘𑀢𑀢𑁄 𑀫𑁂 𑀤𑀸𑀦𑀁 𑀤𑀤𑀢𑀼, 𑀢𑀲𑁆𑀲𑀸 𑀘 𑀳𑁄𑀢𑀼 𑀚𑀻𑀯𑀺𑀓𑀸;

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

𑀢𑀤𑀸𑀳𑀁 ¶ 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁂𑀲𑁆𑀲𑀁, 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀦𑀻’’𑀢𑀺.

𑁪𑁭𑁩.

‘‘𑀲𑀸𑀥𑀽’’𑀢𑀺 ¶ 𑀲𑁄 𑀧𑀝𑀺𑀲𑁆𑀲𑀼𑀢𑁆𑀯𑀸, 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀳𑀢𑁆𑀣𑀺𑀦𑀺𑀁 𑀧𑀼𑀭𑀁;

𑀅𑀯𑁄𑀘 𑀢𑀲𑁆𑀲𑀸 𑀫𑀸𑀢𑀭𑀁 𑁋

‘𑀥𑀻𑀢𑀸 𑀘 𑀢𑁂 𑀫𑀬𑀸 𑀤𑀺𑀝𑁆𑀞𑀸, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’.

𑁪𑁭𑁪.

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

‘𑀥𑀻𑀢𑀸 𑀘 𑀢𑁂 𑀫𑀬𑀸 𑀤𑀺𑀝𑁆𑀞𑀸, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’.

𑁪𑁭𑁫.

‘‘𑀅𑀢𑁆𑀣𑀺 𑀘 𑀫𑁂 𑀏𑀢𑁆𑀣 𑀦𑀺𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀁, 𑀅𑀦𑀓𑁆𑀔𑀸𑀢𑀜𑁆𑀘 𑀢𑀁 𑀫𑀬𑀸;

𑀘𑀢𑁆𑀢𑀸𑀭𑀺𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑀲𑁆𑀲 𑀘 𑀳𑁂𑀝𑁆𑀞𑀢𑁄.

𑁪𑁭𑁬.

‘‘𑀢𑀢𑁄 𑀫𑁂 𑀤𑀸𑀦𑀁 𑀤𑀤𑀢𑀼, 𑀢𑀲𑁆𑀲𑀸 𑀘 𑀳𑁄𑀢𑀼 𑀚𑀻𑀯𑀺𑀓𑀸;

𑀤𑀸𑀦𑀁 𑀤𑀢𑁆𑀯𑀸 𑀘 𑀫𑁂 𑀫𑀸𑀢𑀸, 𑀤𑀓𑁆𑀔𑀺𑀡𑀁 𑀅𑀦𑀼𑀤𑀺𑀘𑁆𑀙𑀢𑀼 ( ) [(𑀢𑀢𑁄 𑀢𑀼𑀯𑀁 𑀤𑀸𑀦𑀁 𑀤𑁂𑀳𑀺, 𑀢𑀲𑁆𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲𑀻) (𑀓.)];

‘𑀢𑀤𑀸 𑀲𑀸 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁂𑀲𑁆𑀲𑀁, 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀲𑀫𑀺𑀤𑁆𑀥𑀺𑀦𑀻’’’𑀢𑀺.

𑁪𑁭𑁭.

𑀢𑀢𑁄 𑀳𑀺 𑀲𑀸 𑀤𑀸𑀦𑀫𑀤𑀸, 𑀢𑀲𑁆𑀲𑀸 𑀤𑀓𑁆𑀔𑀺𑀡𑀫𑀸𑀤𑀺𑀲𑀻;

𑀧𑁂𑀢𑀻 𑀘 𑀲𑀼𑀔𑀺𑀢𑀸 𑀆𑀲𑀺, 𑀢𑀲𑁆𑀲𑀸 𑀘𑀸𑀲𑀺 𑀲𑀼𑀚𑀻𑀯𑀺𑀓𑀸𑀢𑀺.

𑀲𑁂𑀭𑀺𑀡𑀻𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀙𑀝𑁆𑀞𑀁.

𑁭. 𑀫𑀺𑀕𑀮𑀼𑀤𑁆𑀤𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪𑁭𑁮.

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

𑀤𑀺𑀯𑀲𑀁 𑀅𑀦𑀼𑀪𑁄𑀲𑀺 𑀓𑀸𑀭𑀡𑀁, 𑀓𑀺𑀫𑀓𑀸𑀲𑀺 𑀧𑀼𑀭𑀺𑀫𑀸𑀬 𑀚𑀸𑀢𑀺𑀬𑀸’’𑀢𑀺.

𑁪𑁭𑁯.

‘‘𑀅𑀳𑀁 ¶ 𑀭𑀸𑀚𑀕𑀳𑁂 𑀭𑀫𑁆𑀫𑁂, 𑀭𑀫𑀡𑀻𑀬𑁂 𑀕𑀺𑀭𑀺𑀩𑁆𑀩𑀚𑁂;

𑀫𑀺𑀕𑀮𑀼𑀤𑁆𑀤𑁄 ¶ 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺𑀁, 𑀮𑁄𑀳𑀺𑀢𑀧𑀸𑀡𑀺 𑀤𑀸𑀭𑀼𑀡𑁄.

𑁪𑁮𑁦.

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

𑀯𑀺𑀘𑀭𑀺𑀁 𑀅𑀢𑀺𑀤𑀸𑀭𑀼𑀡𑁄 𑀲𑀤𑀸 [𑀢𑀤𑀸 (𑀲𑀻.)], 𑀧𑀭𑀳𑀺𑀁𑀲𑀸𑀬 𑀭𑀢𑁄 𑀅𑀲𑀜𑁆𑀜𑀢𑁄.

𑁪𑁮𑁧.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀫𑁂 𑀲𑀳𑀸𑀬𑁄 𑀲𑀼𑀳𑀤𑀬𑁄 [𑀲𑀼𑀳𑀤𑁄 (𑀲𑀻.)], 𑀲𑀤𑁆𑀥𑁄 𑀆𑀲𑀺 𑀉𑀧𑀸𑀲𑀓𑁄;

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

𑁪𑁮𑁨.

‘‘‘𑀫𑀸𑀓𑀸𑀲𑀺 𑀧𑀸𑀧𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀫𑀸 𑀢𑀸𑀢 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁 𑀅𑀕𑀸;

𑀲𑀘𑁂 𑀇𑀘𑁆𑀙𑀲𑀺 𑀧𑁂𑀘𑁆𑀘 𑀲𑀼𑀔𑀁, 𑀯𑀺𑀭𑀫 𑀧𑀸𑀡𑀯𑀥𑀸 𑀅𑀲𑀁𑀬𑀫𑀸’.

𑁪𑁮𑁩.

‘‘𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀲𑀼𑀔𑀓𑀸𑀫𑀲𑁆𑀲 𑀳𑀺𑀢𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀺𑀦𑁄;

𑀦𑀸𑀓𑀸𑀲𑀺𑀁 𑀲𑀓𑀮𑀸𑀦𑀼𑀲𑀸𑀲𑀦𑀺𑀁, 𑀘𑀺𑀭𑀧𑀸𑀧𑀸𑀪𑀺𑀭𑀢𑁄 𑀅𑀩𑀼𑀤𑁆𑀥𑀺𑀫𑀸.

𑁪𑁮𑁪.

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

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

𑁪𑁮𑁫.

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 ¶ 𑀤𑀺𑀯𑀸 𑀳𑀦𑀺𑀢𑁆𑀯𑀸 𑀧𑀸𑀡𑀺𑀦𑁄, 𑀯𑀺𑀭𑀢𑁄 𑀭𑀢𑁆𑀢𑀺𑀫𑀳𑁄𑀲𑀺 𑀲𑀜𑁆𑀜𑀢𑁄;

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

𑁪𑁮𑁬.

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

𑀤𑀺𑀯𑀸 𑀧𑀝𑀺𑀳𑀢𑀸𑀯 [𑀧𑀝𑀺𑀳𑀢𑀸 𑀘 (𑀓.)] 𑀓𑀼𑀓𑁆𑀓𑀼𑀭𑀸, 𑀉𑀧𑀥𑀸𑀯𑀦𑁆𑀢𑀺 𑀲𑀫𑀦𑁆𑀢𑀸 𑀔𑀸𑀤𑀺𑀢𑀼𑀁.

𑁪𑁮𑁭.

‘‘𑀬𑁂 𑀘 𑀢𑁂 𑀲𑀢𑀢𑀸𑀦𑀼𑀬𑁄𑀕𑀺𑀦𑁄, 𑀥𑀼𑀯𑀁 𑀧𑀬𑀼𑀢𑁆𑀢𑀸 𑀲𑀼𑀕𑀢𑀲𑁆𑀲 𑀲𑀸𑀲𑀦𑁂;

𑀫𑀜𑁆𑀜𑀸𑀫𑀺 𑀢𑁂 𑀅𑀫𑀢𑀫𑁂𑀯 𑀓𑁂𑀯𑀮𑀁, 𑀅𑀥𑀺𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀧𑀤𑀁 𑀅𑀲𑀗𑁆𑀔𑀢’’𑀦𑁆𑀢𑀺.

𑀫𑀺𑀕𑀮𑀼𑀤𑁆𑀤𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀲𑀢𑁆𑀢𑀫𑀁.

𑁮. 𑀤𑀼𑀢𑀺𑀬𑀫𑀺𑀕𑀮𑀼𑀤𑁆𑀤𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪𑁮𑁮.

‘‘𑀓𑀽𑀝𑀸𑀕𑀸𑀭𑁂 ¶ 𑀘 𑀧𑀸𑀲𑀸𑀤𑁂, 𑀧𑀮𑁆𑀮𑀗𑁆𑀓𑁂 𑀕𑁄𑀦𑀓𑀢𑁆𑀣𑀢𑁂;

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

𑁪𑁮𑁯.

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

𑀅𑀧𑀯𑀺𑀤𑁆𑀥𑁄 𑀲𑀼𑀲𑀸𑀦𑀲𑁆𑀫𑀺𑀁, 𑀩𑀳𑀼𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀲𑀺.

𑁪𑁯𑁦.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀇𑀤𑀁 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀲𑀺’’.

𑁪𑁯𑁧.

‘‘𑀅𑀳𑀁 ¶ 𑀭𑀸𑀚𑀕𑀳𑁂 𑀭𑀫𑁆𑀫𑁂, 𑀭𑀫𑀡𑀻𑀬𑁂 𑀕𑀺𑀭𑀺𑀩𑁆𑀩𑀚𑁂;

𑀫𑀺𑀕𑀮𑀼𑀤𑁆𑀤𑁄 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺𑀁, 𑀮𑀼𑀤𑁆𑀤𑁄 𑀘𑀸𑀲𑀺𑀫𑀲𑀜𑁆𑀜𑀢𑁄.

𑁪𑁯𑁨.

‘‘𑀢𑀲𑁆𑀲 𑀫𑁂 𑀲𑀳𑀸𑀬𑁄 𑀲𑀼𑀳𑀤𑀬𑁄, 𑀲𑀤𑁆𑀥𑁄 𑀆𑀲𑀺 𑀉𑀧𑀸𑀲𑀓𑁄;

𑀢𑀲𑁆𑀲 𑀓𑀼𑀮𑀼𑀧𑀓𑁄 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀆𑀲𑀺 𑀕𑁄𑀢𑀫𑀲𑀸𑀯𑀓𑁄;

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

𑁪𑁯𑁩.

‘‘‘𑀫𑀸𑀓𑀸𑀲𑀺 𑀧𑀸𑀧𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀫𑀸 𑀢𑀸𑀢 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀁 𑀅𑀕𑀸;

𑀲𑀘𑁂 𑀇𑀘𑁆𑀙𑀲𑀺 𑀧𑁂𑀘𑁆𑀘 𑀲𑀼𑀔𑀁, 𑀯𑀺𑀭𑀫 𑀧𑀸𑀡𑀯𑀥𑀸 𑀅𑀲𑀁𑀬𑀫𑀸’.

𑁪𑁯𑁪.

‘‘𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀲𑀼𑀔𑀓𑀸𑀫𑀲𑁆𑀲 𑀳𑀺𑀢𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀺𑀦𑁄;

𑀦𑀸𑀓𑀸𑀲𑀺𑀁 𑀲𑀓𑀮𑀸𑀦𑀼𑀲𑀸𑀲𑀦𑀺𑀁, 𑀘𑀺𑀭𑀧𑀸𑀧𑀸𑀪𑀺𑀭𑀢𑁄 𑀅𑀩𑀼𑀤𑁆𑀥𑀺𑀫𑀸.

𑁪𑁯𑁫.

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

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

𑁪𑁯𑁬.

‘‘𑀲𑁆𑀯𑀸𑀳𑀁 𑀤𑀺𑀯𑀸 𑀳𑀦𑀺𑀢𑁆𑀯𑀸 𑀧𑀸𑀡𑀺𑀦𑁄, 𑀯𑀺𑀭𑀢𑁄 𑀭𑀢𑁆𑀢𑀺𑀫𑀳𑁄𑀲𑀺 𑀲𑀜𑁆𑀜𑀢𑁄;

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

𑁪𑁯𑁭.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀓𑀼𑀲𑀮𑀲𑁆𑀲, 𑀅𑀦𑀼𑀪𑁄𑀫𑀺 𑀭𑀢𑁆𑀢𑀺𑀁 𑀅𑀫𑀸𑀦𑀼𑀲𑀺𑀁;

𑀤𑀺𑀯𑀸 𑀧𑀝𑀺𑀳𑀢𑀸𑀯 𑀓𑀼𑀓𑁆𑀓𑀼𑀭𑀸, 𑀉𑀧𑀥𑀸𑀯𑀦𑁆𑀢𑀺 𑀲𑀫𑀦𑁆𑀢𑀸 𑀔𑀸𑀤𑀺𑀢𑀼𑀁.

𑁪𑁯𑁮.

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

𑀫𑀜𑁆𑀜𑀸𑀫𑀺 𑀢𑁂 𑀅𑀫𑀢𑀫𑁂𑀯 𑀓𑁂𑀯𑀮𑀁, 𑀅𑀥𑀺𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀧𑀤𑀁 𑀅𑀲𑀗𑁆𑀔𑀢’’𑀦𑁆𑀢𑀺.

𑀤𑀼𑀢𑀺𑀬𑀫𑀺𑀕𑀮𑀼𑀤𑁆𑀤𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀅𑀝𑁆𑀞𑀫𑀁.

𑁯. 𑀓𑀽𑀝𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑀺𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁪𑁯𑁯.

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

𑀧𑀲𑀦𑁆𑀦𑀫𑀼𑀔𑀯𑀡𑁆𑀡𑁄𑀲𑀺, 𑀲𑀽𑀭𑀺𑀬𑀯𑀡𑁆𑀡𑁄𑀯 𑀲𑁄𑀪𑀲𑀺.

𑁫𑁦𑁦.

‘‘𑀅𑀫𑀸𑀦𑀼𑀲𑀸 𑀧𑀸𑀭𑀺𑀲𑀚𑁆𑀚𑀸, 𑀬𑁂 𑀢𑁂𑀫𑁂 𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑀸;

𑀤𑀲 𑀓𑀜𑁆𑀜𑀸𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀬𑀸 𑀢𑁂𑀫𑀸 𑀧𑀭𑀺𑀘𑀸𑀭𑀺𑀓𑀸;

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

𑁫𑁦𑁧.

‘‘𑀫𑀳𑀸𑀦𑀼𑀪𑀸𑀯𑁄𑀲𑀺 𑀢𑀼𑀯𑀁, 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑀭𑀽𑀧𑀯𑀸;

𑀧𑀺𑀝𑁆𑀞𑀺𑀫𑀁𑀲𑀸𑀦𑀺 𑀅𑀢𑁆𑀢𑀦𑁄, 𑀲𑀸𑀫𑀁 𑀉𑀓𑁆𑀓𑀘𑁆𑀘 [𑀉𑀓𑁆𑀓𑀟𑁆𑀠 (𑀲𑀻.)] 𑀔𑀸𑀤𑀲𑀺.

𑁫𑁦𑁨.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑀺𑀝𑁆𑀞𑀺𑀫𑀁𑀲𑀸𑀦𑀺 𑀅𑀢𑁆𑀢𑀦𑁄;

𑀲𑀸𑀫𑀁 𑀉𑀓𑁆𑀓𑀘𑁆𑀘 𑀔𑀸𑀤𑀲𑀻’’𑀢𑀺.

𑁫𑁦𑁩.

‘‘𑀅𑀢𑁆𑀢𑀦𑁄𑀳𑀁 𑀅𑀦𑀢𑁆𑀣𑀸𑀬, 𑀚𑀻𑀯𑀮𑁄𑀓𑁂 𑀅𑀘𑀸𑀭𑀺𑀲𑀁;

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

𑁫𑁦𑁪.

‘‘𑀢𑀢𑁆𑀣𑀸𑀳𑀁 𑀧𑀭𑀺𑀲𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀲𑀘𑁆𑀘𑀓𑀸𑀮𑁂 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑁂;

𑀅𑀢𑁆𑀣𑀁 ¶ 𑀥𑀫𑁆𑀫𑀁 𑀦𑀺𑀭𑀸𑀓𑀢𑁆𑀯𑀸 [𑀦𑀺𑀭𑀁𑀓𑀢𑁆𑀯𑀸 (𑀓.) 𑀦𑀺 + 𑀆 + 𑀓𑀭 + 𑀢𑁆𑀯𑀸 = 𑀦𑀺𑀭𑀸𑀓𑀢𑁆𑀯𑀸], 𑀅𑀥𑀫𑁆𑀫𑀫𑀦𑀼𑀯𑀢𑁆𑀢𑀺𑀲𑀁.

𑁫𑁦𑁫.

‘‘𑀏𑀯𑀁 𑀲𑁄 𑀔𑀸𑀤𑀢𑀢𑁆𑀢𑀸𑀦𑀁, 𑀬𑁄 𑀳𑁄𑀢𑀺 𑀧𑀺𑀝𑁆𑀞𑀺𑀫𑀁𑀲𑀺𑀓𑁄;

𑀬𑀣𑀸𑀳𑀁 𑀅𑀚𑁆𑀚 𑀔𑀸𑀤𑀸𑀫𑀺, 𑀧𑀺𑀝𑁆𑀞𑀺𑀫𑀁𑀲𑀸𑀦𑀺 𑀅𑀢𑁆𑀢𑀦𑁄.

𑁫𑁦𑁬.

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

𑀫𑀸 𑀧𑁂𑀲𑀼𑀡𑀁 𑀫𑀸 𑀘 𑀫𑀼𑀲𑀸 𑀅𑀪𑀸𑀡𑀺, 𑀫𑀸 𑀔𑁄𑀲𑀺 𑀧𑀺𑀝𑁆𑀞𑀺𑀫𑀁𑀲𑀺𑀓𑁄 𑀢𑀼𑀯’’𑀦𑁆𑀢𑀺.

𑀓𑀽𑀝𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑀺𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀦𑀯𑀫𑀁.

𑁧𑁦. 𑀥𑀸𑀢𑀼𑀯𑀺𑀯𑀡𑁆𑀡𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁫𑁦𑁭.

‘‘𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑀲𑁆𑀫𑀺𑀁 ¶ 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑁄, 𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑁄 𑀧𑀽𑀢𑀺 𑀯𑀸𑀬𑀲𑀺;

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

𑁫𑁦𑁮.

‘‘𑀢𑀢𑁄 ¶ 𑀲𑀢𑁆𑀣𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀑𑀓𑁆𑀓𑀦𑁆𑀢𑀦𑁆𑀢𑀺 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁;

𑀔𑀸𑀭𑁂𑀦 𑀧𑀭𑀺𑀧𑁆𑀨𑁄𑀲𑀺𑀢𑁆𑀯𑀸, 𑀑𑀓𑁆𑀓𑀦𑁆𑀢𑀦𑁆𑀢𑀺 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁.

𑁫𑁦𑁯.

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

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

𑁫𑁧𑁦.

‘‘𑀅𑀳𑀁 𑀭𑀸𑀚𑀕𑀳𑁂 𑀭𑀫𑁆𑀫𑁂, 𑀭𑀫𑀡𑀻𑀬𑁂 𑀕𑀺𑀭𑀺𑀩𑁆𑀩𑀚𑁂;

𑀇𑀲𑁆𑀲𑀭𑁄 𑀥𑀦𑀥𑀜𑁆𑀜𑀲𑁆𑀲, 𑀲𑀼𑀧𑀳𑀽𑀢𑀲𑁆𑀲 𑀫𑀸𑀭𑀺𑀲.

𑁫𑁧𑁧.

‘‘𑀢𑀲𑁆𑀲𑀸𑀬𑀁 𑀫𑁂 𑀪𑀭𑀺𑀬𑀸 𑀘, 𑀥𑀻𑀢𑀸 𑀘 𑀲𑀼𑀡𑀺𑀲𑀸 𑀘 𑀫𑁂;

𑀢𑀸 𑀫𑀸𑀮𑀁 𑀉𑀧𑁆𑀧𑀮𑀜𑁆𑀘𑀸𑀧𑀺, 𑀧𑀘𑁆𑀘𑀕𑁆𑀖𑀜𑁆𑀘 𑀯𑀺𑀮𑁂𑀧𑀦𑀁;

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

𑁫𑁧𑁨.

‘‘𑀙𑀴𑀸𑀲𑀻𑀢𑀺𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 ¶ , 𑀫𑀬𑀁 𑀧𑀘𑁆𑀘𑀢𑁆𑀢𑀯𑁂𑀤𑀦𑀸;

𑀣𑀽𑀧𑀧𑀽𑀚𑀁 𑀯𑀺𑀯𑀡𑁆𑀡𑁂𑀢𑁆𑀯𑀸, 𑀧𑀘𑁆𑀘𑀸𑀫 𑀦𑀺𑀭𑀬𑁂 𑀪𑀼𑀲𑀁.

𑁫𑁧𑁩.

‘‘𑀬𑁂 ¶ 𑀘 𑀔𑁄 𑀣𑀽𑀧𑀧𑀽𑀚𑀸𑀬, 𑀯𑀢𑁆𑀢𑀦𑁆𑀢𑁂 𑀅𑀭𑀳𑀢𑁄 𑀫𑀳𑁂;

𑀆𑀤𑀻𑀦𑀯𑀁 𑀧𑀓𑀸𑀲𑁂𑀦𑁆𑀢𑀺, 𑀯𑀺𑀯𑁂𑀘𑀬𑁂𑀣 [𑀯𑀺𑀯𑁂𑀘𑀬𑀣 (𑀲𑀻.)] 𑀦𑁂 𑀢𑀢𑁄.

𑁫𑁧𑁪.

‘‘𑀇𑀫𑀸 𑀘 𑀧𑀲𑁆𑀲 𑀆𑀬𑀦𑁆𑀢𑀺𑀬𑁄, 𑀫𑀸𑀮𑀥𑀸𑀭𑀻 𑀅𑀮𑀗𑁆𑀓𑀢𑀸;

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

𑁫𑁧𑁫.

‘‘𑀢𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀅𑀘𑁆𑀙𑁂𑀭𑀁, 𑀅𑀩𑁆𑀪𑀼𑀢𑀁 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑀁;

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

𑁫𑁧𑁬.

‘‘𑀲𑁄𑀳𑀁 ¶ 𑀦𑀽𑀦 𑀇𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀬𑁄𑀦𑀺𑀁 𑀮𑀤𑁆𑀥𑀸𑀦 𑀫𑀸𑀦𑀼𑀲𑀺𑀁;

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

𑀥𑀸𑀢𑀼𑀯𑀺𑀯𑀡𑁆𑀡𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀤𑀲𑀫𑀁.

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

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

𑀅𑀪𑀺𑀚𑁆𑀚𑀫𑀸𑀦𑁄 𑀓𑀼𑀡𑁆𑀟𑀺𑀬𑁄 [𑀓𑁄𑀡𑁆𑀟𑀜𑁆𑀜𑁄 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)], 𑀭𑀣𑀓𑀸𑀭𑀻 𑀪𑀼𑀲𑁂𑀦 𑀘;

𑀓𑀼𑀫𑀸𑀭𑁄 𑀕𑀡𑀺𑀓𑀸 𑀘𑁂𑀯, 𑀤𑁆𑀯𑁂 𑀮𑀼𑀤𑁆𑀤𑀸 𑀧𑀺𑀝𑁆𑀞𑀺𑀧𑀽𑀚𑀦𑀸;

𑀯𑀕𑁆𑀕𑁄 𑀢𑁂𑀦 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀻𑀢𑀺.

𑁪. 𑀫𑀳𑀸𑀯𑀕𑁆𑀕𑁄

𑁧. 𑀅𑀫𑁆𑀩𑀲𑀓𑁆𑀓𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁫𑁧𑁭.

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

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

𑁫𑁧𑁮.

‘‘𑀲𑁂𑀬𑁆𑀬𑀸 𑀦𑀺𑀲𑀚𑁆𑀚𑀸 𑀦𑀬𑀺𑀫𑀲𑁆𑀲 𑀅𑀢𑁆𑀣𑀺, 𑀅𑀪𑀺𑀓𑁆𑀓𑀫𑁄 𑀦𑀢𑁆𑀣𑀺 𑀧𑀝𑀺𑀓𑁆𑀓𑀫𑁄 𑀘;

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

𑁫𑁧𑁯.

‘‘𑀬𑁂 𑀜𑀸𑀢𑀓𑀸 𑀤𑀺𑀝𑁆𑀞𑀲𑀼𑀢𑀸 𑀲𑀼𑀳𑀚𑁆𑀚𑀸, 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑀸 𑀬𑀲𑁆𑀲 𑀅𑀳𑁂𑀲𑀼𑀁 𑀧𑀼𑀩𑁆𑀩𑁂;

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

𑁫𑁨𑁦.

‘‘𑀦 𑀑𑀕𑁆𑀕𑀢𑀢𑁆𑀢𑀲𑁆𑀲 𑀪𑀯𑀦𑁆𑀢𑀺 𑀫𑀺𑀢𑁆𑀢𑀸, 𑀚𑀳𑀦𑁆𑀢𑀺 𑀫𑀺𑀢𑁆𑀢𑀸 𑀯𑀺𑀓𑀮𑀁 𑀯𑀺𑀤𑀺𑀢𑁆𑀯𑀸;

𑀅𑀢𑁆𑀣𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀯𑀸 𑀧𑀭𑀺𑀯𑀸𑀭𑀬𑀦𑁆𑀢𑀺, 𑀩𑀳𑀽 𑀫𑀺𑀢𑁆𑀢𑀸 𑀉𑀕𑁆𑀕𑀢𑀢𑁆𑀢𑀲𑁆𑀲 𑀳𑁄𑀦𑁆𑀢𑀺.

𑁫𑁨𑁧.

‘‘𑀦𑀺𑀳𑀻𑀦𑀢𑁆𑀢𑁄 𑀲𑀩𑁆𑀩𑀪𑁄𑀕𑁂𑀳𑀺 𑀓𑀺𑀘𑁆𑀙𑁄, 𑀲𑀫𑁆𑀫𑀓𑁆𑀔𑀺𑀢𑁄 ¶ 𑀲𑀫𑁆𑀧𑀭𑀺𑀪𑀺𑀦𑁆𑀦𑀕𑀢𑁆𑀢𑁄;

𑀉𑀲𑁆𑀲𑀸𑀯𑀩𑀺𑀦𑁆𑀤𑀽𑀯 𑀧𑀮𑀺𑀫𑁆𑀧𑀫𑀸𑀦𑁄, 𑀅𑀚𑁆𑀚 𑀲𑀼𑀯𑁂 𑀚𑀻𑀯𑀺𑀢𑀲𑁆𑀲𑀽𑀧𑀭𑁄𑀥𑁄.

𑁫𑁨𑁨.

‘‘𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀉𑀢𑁆𑀢𑀫𑀓𑀺𑀘𑁆𑀙𑀧𑁆𑀧𑀢𑁆𑀢𑀁, 𑀉𑀢𑁆𑀢𑀸𑀲𑀺𑀢𑀁 𑀧𑀼𑀘𑀺𑀫𑀦𑁆𑀤𑀲𑁆𑀲 𑀲𑀽𑀮𑁂;

‘𑀅𑀣 𑀢𑁆𑀯𑀁 𑀓𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦 𑀯𑀤𑁂𑀲𑀺 𑀬𑀓𑁆𑀔, 𑀚𑀻𑀯 𑀪𑁄 𑀚𑀻𑀯𑀺𑀢𑀫𑁂𑀯 𑀲𑁂𑀬𑁆𑀬𑁄’’’𑀢𑀺.

𑁫𑁨𑁩.

‘‘𑀲𑀸𑀮𑁄𑀳𑀺𑀢𑁄 ¶ ¶ 𑀏𑀲 𑀅𑀳𑁄𑀲𑀺 𑀫𑀬𑁆𑀳𑀁, 𑀅𑀳𑀁 𑀲𑀭𑀸𑀫𑀺 𑀧𑀼𑀭𑀺𑀫𑀸𑀬 𑀚𑀸𑀢𑀺𑀬𑀸;

𑀤𑀺𑀲𑁆𑀯𑀸 𑀘 𑀫𑁂 𑀓𑀸𑀭𑀼𑀜𑁆𑀜𑀫𑀳𑁄𑀲𑀺 𑀭𑀸𑀚, 𑀫𑀸 𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁄 𑀦𑀺𑀭𑀬𑀁 𑀧𑀢𑀸𑀬𑀁 [𑀧𑀢𑀺 + 𑀅𑀬𑀁 = 𑀧𑀢𑀸𑀬𑀁].

𑁫𑁨𑁪.

‘‘𑀇𑀢𑁄 𑀘𑀼𑀢𑁄 𑀮𑀺𑀘𑁆𑀙𑀯𑀺 𑀏𑀲 𑀧𑁄𑀲𑁄, 𑀲𑀢𑁆𑀢𑀼𑀲𑁆𑀲𑀤𑀁 𑀦𑀺𑀭𑀬𑀁 𑀖𑁄𑀭𑀭𑀽𑀧𑀁;

𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀺 𑀤𑀼𑀓𑁆𑀓𑀝𑀓𑀫𑁆𑀫𑀓𑀸𑀭𑀻, 𑀫𑀳𑀸𑀪𑀺𑀢𑀸𑀧𑀁 𑀓𑀝𑀼𑀓𑀁 𑀪𑀬𑀸𑀦𑀓𑀁.

𑁫𑁨𑁫.

‘‘𑀅𑀦𑁂𑀓𑀪𑀸𑀕𑁂𑀦 𑀕𑀼𑀡𑁂𑀦 𑀲𑁂𑀬𑁆𑀬𑁄, 𑀅𑀬𑀫𑁂𑀯 𑀲𑀽𑀮𑁄 𑀦𑀺𑀭𑀬𑁂𑀦 𑀢𑁂𑀦;

𑀏𑀓𑀦𑁆𑀢𑀤𑀼𑀓𑁆𑀔𑀁 𑀓𑀝𑀼𑀓𑀁 𑀪𑀬𑀸𑀦𑀓𑀁, 𑀏𑀓𑀦𑁆𑀢𑀢𑀺𑀩𑁆𑀩𑀁 𑀦𑀺𑀭𑀬𑀁 𑀧𑀢𑀸𑀬𑀁 [𑀧𑀢𑁂 + 𑀅𑀬𑀁 = 𑀧𑀢𑀸𑀬𑀁].

𑁫𑁨𑁬.

‘‘𑀇𑀤𑀜𑁆𑀘 ¶ 𑀲𑀼𑀢𑁆𑀯𑀸 𑀯𑀘𑀦𑀁 𑀫𑀫𑁂𑀲𑁄, 𑀤𑀼𑀓𑁆𑀔𑀽𑀧𑀦𑀻𑀢𑁄 𑀯𑀺𑀚𑀳𑁂𑀬𑁆𑀬 𑀧𑀸𑀡𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀅𑀳𑀁 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀦 𑀪𑀡𑀸𑀫𑀺, 𑀫𑀸 𑀫𑁂 𑀓𑀢𑁄 𑀚𑀻𑀯𑀺𑀢𑀲𑁆𑀲𑀽𑀧𑀭𑁄𑀥𑁄’’.

𑁫𑁨𑁭.

‘‘𑀅𑀜𑁆𑀜𑀸𑀢𑁄 𑀏𑀲𑁄 [𑀅𑀚𑁆𑀛𑀺𑀢𑁄 𑀏𑀲 (𑀓.)] 𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 𑀅𑀢𑁆𑀣𑁄, 𑀅𑀜𑁆𑀜𑀫𑁆𑀧𑀺 𑀇𑀘𑁆𑀙𑀸𑀫𑀲𑁂 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑀼𑀁 𑀢𑀼𑀯𑀁;

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

𑁫𑁨𑁮.

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

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

𑁫𑁨𑁯.

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

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

𑁫𑁩𑁦.

‘‘𑀲𑀘𑁆𑀘𑀧𑁆𑀧𑀝𑀺𑀜𑁆𑀜𑀸 ¶ 𑀢𑀯 𑀫𑁂𑀲𑀸 𑀳𑁄𑀢𑀼, 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀥𑀫𑁆𑀫𑀁 𑀮𑀪 𑀲𑀼𑀧𑁆𑀧𑀲𑀸𑀤𑀁;

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

𑀲𑀩𑁆𑀩𑀫𑁆𑀧𑀺 𑀅𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁 [𑀲𑀩𑁆𑀩𑀁 𑀆𑀘𑀺𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁 (𑀲𑀻.)] 𑀬𑀣𑀸 𑀧𑀚𑀸𑀦𑀦𑁆𑀢𑀺.

𑁫𑁩𑁧.

‘‘𑀲𑁂𑀢𑁂𑀦 𑀅𑀲𑁆𑀲𑁂𑀦 𑀅𑀮𑀗𑁆𑀓𑀢𑁂𑀦, 𑀉𑀧𑀬𑀸𑀲𑀺 𑀲𑀽𑀮𑀸𑀯𑀼𑀢𑀓𑀲𑁆𑀲 𑀲𑀦𑁆𑀢𑀺𑀓𑁂;

𑀬𑀸𑀦𑀁 𑀇𑀤𑀁 𑀅𑀩𑁆𑀪𑀼𑀢𑀁 𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀁, 𑀓𑀺𑀲𑁆𑀲𑁂𑀢𑀁 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄’’𑀢𑀺.

𑁫𑁩𑁨.

‘‘𑀯𑁂𑀲𑀸𑀮𑀺𑀬𑀸 ¶ 𑀦𑀕𑀭𑀲𑁆𑀲 [𑀢𑀲𑁆𑀲 𑀦𑀕𑀭𑀲𑁆𑀲 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀫𑀚𑁆𑀛𑁂, 𑀘𑀺𑀓𑁆𑀔𑀮𑁆𑀮𑀫𑀕𑁆𑀕𑁂 𑀦𑀭𑀓𑀁 𑀅𑀳𑁄𑀲𑀺;

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

𑁫𑁩𑁩.

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

𑀬𑀸𑀦𑀁 𑀇𑀤𑀁 𑀅𑀩𑁆𑀪𑀼𑀢𑀁 𑀤𑀲𑁆𑀲𑀦𑁂𑀬𑁆𑀬𑀁, 𑀢𑀲𑁆𑀲𑁂𑀯 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄’’𑀢𑀺.

𑁫𑁩𑁪.

‘‘𑀯𑀡𑁆𑀡𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀪𑀸𑀲𑀢𑀺, 𑀕𑀦𑁆𑀥𑁄 𑀘 𑀢𑁂 𑀲𑀩𑁆𑀩𑀤𑀺𑀲𑀸 𑀧𑀯𑀸𑀬𑀢𑀺;

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

𑁫𑁩𑁫.

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

𑀢𑀲𑁆𑀲𑁂𑀯 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄, 𑀤𑀺𑀩𑁆𑀩𑁄 𑀫𑁂 𑀯𑀡𑁆𑀡𑁄 𑀲𑀢𑀢𑀁 𑀧𑀪𑀸𑀲𑀢𑀺.

𑁫𑁩𑁬.

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

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

𑁫𑁩𑁭.

‘‘𑀲𑀳𑀸𑀬𑀸𑀦𑀁 ¶ 𑀢𑀺𑀢𑁆𑀣𑀲𑁆𑀫𑀺𑀁 𑀦𑁆𑀳𑀸𑀬𑀦𑁆𑀢𑀸𑀦𑀁, 𑀣𑀮𑁂 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀦𑀺𑀤𑀳𑀺𑀲𑁆𑀲 𑀤𑀼𑀲𑁆𑀲𑀁;

𑀔𑀺𑀟𑁆𑀟𑀢𑁆𑀣𑀺𑀓𑁄 𑀦𑁄 𑀘 𑀧𑀤𑀼𑀝𑁆𑀞𑀘𑀺𑀢𑁆𑀢𑁄, 𑀢𑁂𑀦𑀫𑁆𑀳𑀺 𑀦𑀕𑁆𑀕𑁄 𑀓𑀲𑀺𑀭𑀸 𑀘 𑀯𑀼𑀢𑁆𑀢𑀻’’𑀢𑀺.

𑁫𑁩𑁮.

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

𑀅𑀓𑀻𑀴𑀫𑀸𑀦𑁄 𑀧𑀦 𑀬𑁄 𑀓𑀭𑁄𑀢𑀺, 𑀓𑀺𑀁 𑀢𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀯𑀺𑀧𑀸𑀓𑀫𑀸𑀳𑀽’’𑀢𑀺.

𑁫𑁩𑁯.

‘‘𑀬𑁂 𑀤𑀼𑀝𑁆𑀞𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑀫𑀦𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀸, 𑀓𑀸𑀬𑁂𑀦 𑀯𑀸𑀘𑀸𑀬 𑀘 𑀲𑀗𑁆𑀓𑀺𑀮𑀺𑀝𑁆𑀞𑀸;

𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀅𑀪𑀺𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑀁, 𑀅𑀲𑀁𑀲𑀬𑀁 𑀢𑁂 𑀦𑀺𑀭𑀬𑀁 𑀉𑀧𑁂𑀦𑁆𑀢𑀺.

𑁫𑁪𑁦.

‘‘𑀅𑀧𑀭𑁂 ¶ 𑀧𑀦 𑀲𑀼𑀕𑀢𑀺𑀫𑀸𑀲𑀫𑀸𑀦𑀸, 𑀤𑀸𑀦𑁂 𑀭𑀢𑀸 𑀲𑀗𑁆𑀕𑀳𑀺𑀢𑀢𑁆𑀢𑀪𑀸𑀯𑀸;

𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀅𑀪𑀺𑀲𑀫𑁆𑀧𑀭𑀸𑀬𑀁, 𑀅𑀲𑀁𑀲𑀬𑀁 𑀢𑁂 𑀲𑀼𑀕𑀢𑀺𑀁 𑀉𑀧𑁂𑀦𑁆𑀢𑀻’’𑀢𑀺.

𑁫𑁪𑁧.

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

𑀓𑀺𑀁 𑀯𑀸𑀳𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀅𑀪𑀺𑀲𑀤𑁆𑀤𑀳𑁂𑀬𑁆𑀬𑀁, 𑀓𑁄 𑀯𑀸𑀧𑀺 𑀫𑀁 𑀲𑀤𑁆𑀤𑀳𑀸𑀧𑁂𑀬𑁆𑀬 𑀏𑀢’’𑀦𑁆𑀢𑀺.

𑁫𑁪𑁨.

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

𑀓𑀮𑁆𑀬𑀸𑀡𑀧𑀸𑀧𑁂 𑀉𑀪𑀬𑁂 𑀅𑀲𑀦𑁆𑀢𑁂, 𑀲𑀺𑀬𑀸 𑀦𑀼 𑀲𑀢𑁆𑀢𑀸 𑀲𑀼𑀕𑀢𑀸 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀯𑀸.

𑁫𑁪𑁩.

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

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

𑁫𑁪𑁪.

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

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

𑁫𑁪𑁫.

‘‘𑀤𑁆𑀯𑀬𑀚𑁆𑀚 𑀓𑀫𑁆𑀫𑀸𑀦𑀁 𑀯𑀺𑀧𑀸𑀓𑀫𑀸𑀳𑀼, 𑀲𑀼𑀔𑀲𑁆𑀲 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀘 𑀯𑁂𑀤𑀦𑀻𑀬𑀁;

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

𑁫𑁪𑁬.

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

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

𑁫𑁪𑁭.

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

𑀆𑀘𑀺𑀓𑁆𑀔 𑀫𑁂 𑀢𑁆𑀯𑀁 𑀬𑀤𑀢𑁆𑀣𑀺 𑀳𑁂𑀢𑀼, 𑀲𑀤𑁆𑀥𑀸𑀬𑀺𑀓𑀁 [𑀲𑀤𑁆𑀥𑀸𑀬𑀺𑀢𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀳𑁂𑀢𑀼𑀯𑀘𑁄 𑀲𑀼𑀡𑁄𑀫𑀸’’𑀢𑀺.

𑁫𑁪𑁮.

‘‘𑀓𑀧𑁆𑀧𑀺𑀢𑀓𑁄 [𑀓𑀧𑁆𑀧𑀺𑀦𑀓𑁄 (𑀲𑀻.)] 𑀦𑀸𑀫 𑀇𑀥𑀢𑁆𑀣𑀺 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀛𑀸𑀬𑀻 𑀲𑀼𑀲𑀻𑀮𑁄 𑀅𑀭𑀳𑀸 𑀯𑀺𑀫𑀼𑀢𑁆𑀢𑁄;

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

𑁫𑁪𑁯.

‘‘𑀲𑀔𑀺𑀮𑁄 𑀯𑀤𑀜𑁆𑀜𑀽 𑀲𑀼𑀯𑀘𑁄 𑀲𑀼𑀫𑀼𑀔𑁄, 𑀲𑁆𑀯𑀸𑀕𑀫𑁄 𑀲𑀼𑀧𑁆𑀧𑀝𑀺𑀫𑀼𑀢𑁆𑀢𑀓𑁄 𑀘;

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

𑁫𑁫𑁦.

‘‘𑀲𑀦𑁆𑀢𑁄 𑀯𑀺𑀥𑀽𑀫𑁄 𑀅𑀦𑀻𑀖𑁄 𑀦𑀺𑀭𑀸𑀲𑁄, 𑀫𑀼𑀢𑁆𑀢𑁄 𑀯𑀺𑀲𑀮𑁆𑀮𑁄 𑀅𑀫𑀫𑁄 𑀅𑀯𑀗𑁆𑀓𑁄;

𑀦𑀺𑀭𑀽𑀧𑀥𑀻 𑀲𑀩𑁆𑀩𑀧𑀧𑀜𑁆𑀘𑀔𑀻𑀡𑁄, 𑀢𑀺𑀲𑁆𑀲𑁄 𑀯𑀺𑀚𑁆𑀚𑀸 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁄 𑀚𑀼𑀢𑀺𑀫𑀸.

𑁫𑁫𑁧.

‘‘𑀅𑀧𑁆𑀧𑀜𑁆𑀜𑀸𑀢𑁄 ¶ 𑀤𑀺𑀲𑁆𑀯𑀸𑀧𑀺 𑀦 𑀘 𑀲𑀼𑀚𑀸𑀦𑁄, 𑀫𑀼𑀦𑀻𑀢𑀺 𑀦𑀁 𑀯𑀚𑁆𑀚𑀺𑀲𑀼 𑀯𑁄𑀳𑀭𑀦𑁆𑀢𑀺;

𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀢𑀁 𑀬𑀓𑁆𑀔𑀪𑀽𑀢𑀸 𑀅𑀦𑁂𑀚𑀁, 𑀓𑀮𑁆𑀬𑀸𑀡𑀥𑀫𑁆𑀫𑀁 𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑀁 𑀮𑁄𑀓𑁂.

𑁫𑁫𑁨.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀢𑀼𑀯𑀁 𑀏𑀓𑀬𑀼𑀕𑀁 𑀤𑀼𑀯𑁂 𑀯𑀸, 𑀫𑀫𑀼𑀤𑁆𑀤𑀺𑀲𑀺𑀢𑁆𑀯𑀸𑀦 𑀲𑀘𑁂 𑀤𑀤𑁂𑀣;

𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑀻𑀢𑀸𑀦𑀺 𑀘 𑀢𑀸𑀦𑀺 𑀅𑀲𑁆𑀲𑀼, 𑀫𑀫𑀜𑁆𑀘 𑀧𑀲𑁆𑀲𑁂𑀣 𑀲𑀦𑁆𑀦𑀤𑁆𑀥𑀤𑀼𑀲𑁆𑀲’’𑀦𑁆𑀢𑀺.

𑁫𑁫𑁩.

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

𑀬𑁄 𑀫𑀚𑁆𑀚 [𑀲 𑀫𑀚𑁆𑀚 (𑀲𑀻.)] 𑀓𑀗𑁆𑀔𑀁 𑀯𑀺𑀘𑀺𑀓𑀺𑀘𑁆𑀙𑀺𑀢𑀜𑁆𑀘, 𑀤𑀺𑀝𑁆𑀞𑀻𑀯𑀺𑀲𑀽𑀓𑀸𑀦𑀺 𑀯𑀺𑀦𑁄𑀤𑀬𑁂𑀬𑁆𑀬𑀸’’𑀢𑀺.

𑁫𑁫𑁪.

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

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

𑁫𑁫𑁫.

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

𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑀺𑀢𑀸𑀦𑀺 𑀘 𑀢𑀸𑀦𑀺 𑀅𑀲𑁆𑀲𑀼, 𑀢𑀼𑀯𑀜𑁆𑀘 𑀧𑀲𑁆𑀲𑁂𑀫𑀼 𑀲𑀦𑁆𑀦𑀤𑁆𑀥𑀤𑀼𑀲𑁆𑀲’’𑀦𑁆𑀢𑀺.

𑁫𑁫𑁬.

‘‘𑀫𑀸 𑀅𑀓𑁆𑀔𑀡𑁂 𑀧𑀩𑁆𑀩𑀚𑀺𑀢𑀁 𑀉𑀧𑀸𑀕𑀫𑀺, 𑀲𑀸𑀥𑀼 𑀯𑁄 𑀮𑀺𑀘𑁆𑀙𑀯𑀺 𑀦𑁂𑀲 𑀥𑀫𑁆𑀫𑁄;

𑀢𑀢𑁄 𑀘 𑀓𑀸𑀮𑁂 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀢𑀢𑁆𑀣𑁂𑀯 𑀧𑀲𑁆𑀲𑀸𑀳𑀺 𑀭𑀳𑁄 𑀦𑀺𑀲𑀺𑀦𑁆𑀦’’𑀦𑁆𑀢𑀺.

𑁫𑁫𑁭.

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

𑀲𑁄 𑀢𑀁 𑀦𑀕𑀭𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀯𑀸𑀲𑀽𑀧𑀕𑀘𑁆𑀙𑀺𑀢𑁆𑀣 𑀲𑀓𑁂 𑀦𑀺𑀯𑁂𑀲𑀦𑁂.

𑁫𑁫𑁮.

𑀢𑀢𑁄 ¶ ¶ 𑀘 𑀓𑀸𑀮𑁂 𑀕𑀺𑀳𑀺𑀓𑀺𑀘𑁆𑀘𑀸𑀦𑀺 𑀓𑀢𑁆𑀯𑀸, 𑀦𑁆𑀳𑀢𑁆𑀯𑀸 𑀧𑀺𑀯𑀺𑀢𑁆𑀯𑀸 𑀘 𑀔𑀡𑀁 𑀮𑀪𑀺𑀢𑁆𑀯𑀸;

𑀯𑀺𑀘𑁂𑀬𑁆𑀬 𑀧𑁂𑀴𑀸𑀢𑁄 𑀘 𑀬𑀼𑀕𑀸𑀦𑀺 𑀅𑀝𑁆𑀞, 𑀕𑀸𑀳𑀸𑀧𑀬𑀻 𑀤𑀸𑀲𑀕𑀡𑁂𑀦 𑀮𑀺𑀘𑁆𑀙𑀯𑀺.

𑁫𑁫𑁯.

𑀲𑁄 𑀢𑀁 𑀧𑀤𑁂𑀲𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀢𑀁 𑀅𑀤𑁆𑀤𑀲 𑀲𑀫𑀡𑀁 𑀲𑀦𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑀁;

𑀧𑀝𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀁 ¶ 𑀕𑁄𑀘𑀭𑀢𑁄 𑀦𑀺𑀯𑀢𑁆𑀢𑀁, 𑀲𑀻𑀢𑀺𑀪𑀽𑀢𑀁 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑁂 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁.

𑁫𑁬𑁦.

𑀢𑀫𑁂𑀦𑀫𑀯𑁄𑀘 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀅𑀧𑁆𑀧𑀸𑀩𑀸𑀥𑀁 𑀨𑀸𑀲𑀼𑀯𑀺𑀳𑀸𑀭𑀜𑁆𑀘 𑀧𑀼𑀘𑁆𑀙𑀺;

‘‘𑀯𑁂𑀲𑀸𑀮𑀺𑀬𑀁 𑀮𑀺𑀘𑁆𑀙𑀯𑀺𑀳𑀁 𑀪𑀤𑀦𑁆𑀢𑁂, 𑀚𑀸𑀦𑀦𑁆𑀢𑀺 𑀫𑀁 𑀮𑀺𑀘𑁆𑀙𑀯𑀺 𑀅𑀫𑁆𑀩𑀲𑀓𑁆𑀓𑀭𑁄.

𑁫𑁬𑁧.

‘‘𑀇𑀫𑀸𑀦𑀺 𑀫𑁂 𑀅𑀝𑁆𑀞 𑀬𑀼𑀕𑀸 𑀲𑀼𑀪𑀸𑀦𑀺 [𑀬𑀼𑀕𑀸𑀦𑀺 𑀪𑀦𑁆𑀢𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀧𑀝𑀺𑀕𑀡𑁆𑀳 𑀪𑀦𑁆𑀢𑁂 𑀧𑀤𑀤𑀸𑀫𑀺 𑀢𑀼𑀬𑁆𑀳𑀁;

𑀢𑁂𑀦𑁂𑀯 𑀅𑀢𑁆𑀣𑁂𑀦 𑀇𑀥𑀸𑀕𑀢𑁄𑀲𑁆𑀫𑀺, 𑀬𑀣𑀸 𑀅𑀳𑀁 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀪𑀯𑁂𑀬𑁆𑀬’’𑀦𑁆𑀢𑀺.

𑁫𑁬𑁨.

‘‘𑀤𑀽𑀭𑀢𑁄𑀯 ¶ 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀘, 𑀦𑀺𑀯𑁂𑀲𑀦𑀁 𑀢𑁂 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀦𑁆𑀢𑀺;

𑀧𑀢𑁆𑀢𑀸𑀦𑀺 𑀪𑀺𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀘 𑀢𑁂 [𑀪𑀺𑀚𑁆𑀚𑀦𑁆𑀢𑀺 𑀢𑀯 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀦𑀺𑀯𑁂𑀲𑀦𑁂, 𑀲𑀗𑁆𑀖𑀸𑀝𑀺𑀬𑁄 𑀘𑀸𑀧𑀺 𑀯𑀺𑀤𑀸𑀮𑀬𑀦𑁆𑀢𑀺 [𑀯𑀺𑀧𑀸𑀝𑀬𑀦𑁆𑀢𑀺 (𑀲𑀻.), 𑀯𑀺𑀧𑀸𑀢𑀬𑀦𑁆𑀢𑀺 (𑀓.)].

𑁫𑁬𑁩.

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

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

𑁫𑁬𑁪.

‘‘𑀢𑀺𑀡𑁂𑀦 𑀢𑁂𑀮𑀫𑁆𑀧𑀺 𑀦 𑀢𑁆𑀯𑀁 𑀅𑀤𑀸𑀲𑀺, 𑀫𑀽𑀴𑁆𑀳𑀲𑁆𑀲 ¶ 𑀫𑀕𑁆𑀕𑀫𑁆𑀧𑀺 𑀦 𑀧𑀸𑀯𑀤𑀸𑀲𑀺;

𑀅𑀦𑁆𑀥𑀲𑁆𑀲 𑀤𑀡𑁆𑀟𑀁 𑀲𑀬𑀫𑀸𑀤𑀺𑀬𑀸𑀲𑀺, 𑀏𑀢𑀸𑀤𑀺𑀲𑁄 𑀓𑀤𑀭𑀺𑀬𑁄 𑀅𑀲𑀁𑀯𑀼𑀢𑁄 𑀢𑀼𑀯𑀁;

𑀅𑀣 𑀢𑁆𑀯𑀁 𑀓𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦 𑀓𑀺𑀫𑁂𑀯 𑀤𑀺𑀲𑁆𑀯𑀸,

𑀅𑀫𑁆𑀳𑁂𑀳𑀺 𑀲𑀳 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀁 𑀓𑀭𑁄𑀲𑀻’’𑀢𑀺.

𑁫𑁬𑁫.

‘‘𑀧𑀘𑁆𑀘𑁂𑀫𑀺 ¶ 𑀪𑀦𑁆𑀢𑁂 𑀬𑀁 𑀢𑁆𑀯𑀁 𑀯𑀤𑁂𑀲𑀺, 𑀯𑀺𑀳𑁂𑀲𑀬𑀺𑀁 𑀲𑀫𑀡𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂 𑀘;

𑀔𑀺𑀟𑁆𑀟𑀢𑁆𑀣𑀺𑀓𑁄 𑀦𑁄 𑀘 𑀧𑀤𑀼𑀝𑁆𑀞𑀘𑀺𑀢𑁆𑀢𑁄, 𑀏𑀢𑀫𑁆𑀧𑀺 𑀫𑁂 𑀤𑀼𑀓𑁆𑀓𑀝𑀫𑁂𑀯 𑀪𑀦𑁆𑀢𑁂.

𑁫𑁬𑁬.

‘‘𑀔𑀺𑀟𑁆𑀟𑀸𑀬 𑀬𑀓𑁆𑀔𑁄 𑀧𑀲𑀯𑀺𑀢𑁆𑀯𑀸 𑀧𑀸𑀧𑀁, 𑀯𑁂𑀤𑁂𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑀁 𑀅𑀲𑀫𑀢𑁆𑀢𑀪𑁄𑀕𑀻;

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

𑁫𑁬𑁭.

‘‘𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀲𑀁𑀯𑁂𑀕𑀫𑀮𑀢𑁆𑀣𑀁 𑀪𑀦𑁆𑀢𑁂, 𑀢𑀧𑁆𑀧𑀘𑁆𑀘𑀬𑀸 𑀯𑀸𑀧𑀺 [𑀢𑀧𑁆𑀧𑀘𑁆𑀘𑀬𑀸 𑀢𑀸𑀳𑀁 (𑀲𑀻.), 𑀢𑀧𑁆𑀧𑀘𑁆𑀘𑀬𑀸 𑀘𑀸𑀳𑀁 (𑀧𑀻.)] 𑀤𑀤𑀸𑀫𑀺 𑀤𑀸𑀦𑀁;

𑀧𑀝𑀺𑀕𑀡𑁆𑀳 𑀪𑀦𑁆𑀢𑁂 𑀯𑀢𑁆𑀣𑀬𑀼𑀕𑀸𑀦𑀺 𑀅𑀝𑁆𑀞, 𑀬𑀓𑁆𑀔𑀲𑁆𑀲𑀺𑀫𑀸 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀼 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬𑁄’’𑀢𑀺.

𑁫𑁬𑁮.

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

𑀧𑀝𑀺𑀕𑀡𑁆𑀳𑀸𑀫𑀺 ¶ 𑀢𑁂 𑀯𑀢𑁆𑀣𑀬𑀼𑀕𑀸𑀦𑀺 𑀅𑀝𑁆𑀞, 𑀬𑀓𑁆𑀔𑀲𑁆𑀲𑀺𑀫𑀸 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀼 𑀤𑀓𑁆𑀔𑀺𑀡𑀸𑀬𑁄’’𑀢𑀺.

𑁫𑁬𑁯.

𑀢𑀢𑁄 𑀳𑀺 𑀲𑁄 𑀆𑀘𑀫𑀬𑀺𑀢𑁆𑀯𑀸 𑀮𑀺𑀘𑁆𑀙𑀯𑀺, 𑀣𑁂𑀭𑀲𑁆𑀲 𑀤𑀢𑁆𑀯𑀸𑀦 𑀬𑀼𑀕𑀸𑀦𑀺 𑀅𑀝𑁆𑀞;

‘𑀧𑀝𑀺𑀕𑁆𑀕𑀳𑀺𑀢𑀸𑀦𑀺 𑀘 𑀢𑀸𑀦𑀺 𑀅𑀲𑁆𑀲𑀼, 𑀬𑀓𑁆𑀔𑀜𑁆𑀘 𑀧𑀲𑁆𑀲𑁂𑀣 𑀲𑀦𑁆𑀦𑀤𑁆𑀥𑀤𑀼𑀲𑁆𑀲𑀁’.

𑁫𑁭𑁦.

𑀢𑀫𑀤𑁆𑀤𑀲𑀸 𑀘𑀦𑁆𑀤𑀦𑀲𑀸𑀭𑀮𑀺𑀢𑁆𑀢𑀁, 𑀆𑀚𑀜𑁆𑀜𑀫𑀸𑀭𑀽𑀴𑁆𑀳𑀫𑀼𑀴𑀸𑀭𑀯𑀡𑁆𑀡𑀁;

𑀅𑀮𑀗𑁆𑀓𑀢𑀁 𑀲𑀸𑀥𑀼𑀦𑀺𑀯𑀢𑁆𑀣𑀤𑀼𑀲𑁆𑀲𑀁, 𑀧𑀭𑀺𑀯𑀸𑀭𑀺𑀢𑀁 𑀬𑀓𑁆𑀔𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀧𑀢𑁆𑀢𑀁.

𑁫𑁭𑁧.

𑀲𑁄 ¶ 𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸 𑀅𑀢𑁆𑀢𑀫𑀦𑀸 𑀉𑀤𑀕𑁆𑀕𑁄, 𑀧𑀳𑀝𑁆𑀞𑀘𑀺𑀢𑁆𑀢𑁄 𑀘 𑀲𑀼𑀪𑀕𑁆𑀕𑀭𑀽𑀧𑁄;

𑀓𑀫𑁆𑀫𑀜𑁆𑀘 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀫𑀳𑀸𑀯𑀺𑀧𑀸𑀓𑀁, 𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓𑀁 𑀘𑀓𑁆𑀔𑀼𑀦𑀸 𑀲𑀘𑁆𑀙𑀺𑀓𑀢𑁆𑀯𑀸.

𑁫𑁭𑁨.

𑀢𑀫𑁂𑀦𑀫𑀯𑁄𑀘 ¶ ¶ 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, ‘‘𑀤𑀲𑁆𑀲𑀸𑀫𑀺 𑀤𑀸𑀦𑀁 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁;

𑀦 𑀘𑀸𑀧𑀺 𑀫𑁂 𑀓𑀺𑀜𑁆𑀘𑀺 𑀅𑀤𑁂𑀬𑁆𑀬𑀫𑀢𑁆𑀣𑀺, 𑀢𑀼𑀯𑀜𑁆𑀘 𑀫𑁂 𑀬𑀓𑁆𑀔 𑀩𑀳𑀽𑀧𑀓𑀸𑀭𑁄’’𑀢𑀺.

𑁫𑁭𑁩.

‘‘𑀢𑀼𑀯𑀜𑁆𑀘 𑀫𑁂 𑀮𑀺𑀘𑁆𑀙𑀯𑀺 𑀏𑀓𑀤𑁂𑀲𑀁, 𑀅𑀤𑀸𑀲𑀺 𑀤𑀸𑀦𑀸𑀦𑀺 𑀅𑀫𑁄𑀖𑀫𑁂𑀢𑀁;

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

𑁫𑁭𑁪.

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

𑀬𑀸𑀘𑀸𑀫𑀺 𑀢𑀁 [𑀬𑀸𑀘𑀸𑀫𑀳𑀁 (𑀲𑀻.)] 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑁄 𑀪𑀯𑀺𑀢𑁆𑀯𑀸, 𑀇𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀬𑀓𑁆𑀔 𑀧𑀼𑀦𑀸𑀧𑀺 𑀤𑀝𑁆𑀞𑀼’’𑀦𑁆𑀢𑀺.

𑁫𑁭𑁫.

‘‘𑀲𑀘𑁂 𑀢𑀼𑀯𑀁 𑀅𑀲𑁆𑀲𑀤𑁆𑀥𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀲𑀺, 𑀓𑀤𑀭𑀺𑀬𑀭𑀽𑀧𑁄 𑀯𑀺𑀧𑁆𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄;

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

𑁫𑁭𑁬.

‘‘𑀲𑀘𑁂 𑀧𑀦 𑀢𑁆𑀯𑀁 𑀪𑀯𑀺𑀲𑁆𑀲𑀲𑀺 𑀥𑀫𑁆𑀫𑀕𑀸𑀭𑀯𑁄, 𑀤𑀸𑀦𑁂 𑀭𑀢𑁄 𑀲𑀗𑁆𑀕𑀳𑀺𑀢𑀢𑁆𑀢𑀪𑀸𑀯𑁄;

𑀑𑀧𑀸𑀦𑀪𑀽𑀢𑁄 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁, 𑀏𑀯𑀁 𑀫𑀫𑀁 𑀮𑀘𑁆𑀙𑀲𑀺 𑀤𑀲𑁆𑀲𑀦𑀸𑀬.

𑁫𑁭𑁭.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸 𑀘 𑀢𑀁 𑀆𑀮𑀧𑀺𑀲𑁆𑀲𑀁 𑀪𑀤𑀦𑁆𑀢𑁂, 𑀇𑀫𑀜𑁆𑀘 𑀲𑀽𑀮𑀢𑁄 𑀮𑀳𑀼𑀁 𑀧𑀫𑀼𑀜𑁆𑀘;

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

𑁫𑁭𑁮.

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

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

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

𑁫𑁭𑁯.

‘‘𑀓𑀧𑁆𑀧𑀺𑀢𑀓𑀜𑁆𑀘 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀢𑁂𑀦𑁂𑀯 [𑀢𑁂𑀦 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀲𑀳 𑀲𑀁𑀯𑀺𑀪𑀚𑀺𑀢𑁆𑀯𑀸 𑀓𑀸𑀮𑁂;

𑀲𑀬𑀁 𑀫𑀼𑀔𑁂𑀦𑀽𑀧𑀦𑀺𑀲𑀚𑁆𑀚 𑀧𑀼𑀘𑁆𑀙, 𑀲𑁄 𑀢𑁂 𑀅𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀢𑀺 𑀏𑀢𑀫𑀢𑁆𑀣𑀁.

𑁫𑁮𑁦.

‘‘𑀢𑀫𑁂𑀯 𑀪𑀺𑀓𑁆𑀔𑀼𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀧𑀼𑀘𑁆𑀙𑀲𑁆𑀲𑀼 𑀅𑀜𑁆𑀜𑀢𑁆𑀣𑀺𑀓𑁄 𑀦𑁄 𑀘 𑀧𑀤𑀼𑀝𑁆𑀞𑀘𑀺𑀢𑁆𑀢𑁄;

𑀲𑁄 𑀢𑁂 𑀲𑀼𑀢𑀁 𑀅𑀲𑀼𑀢𑀜𑁆𑀘𑀸𑀧𑀺 𑀥𑀫𑁆𑀫𑀁,

𑀲𑀩𑁆𑀩𑀫𑁆𑀧𑀺 ¶ 𑀅𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀢𑀺 𑀬𑀣𑀸 𑀧𑀚𑀸𑀦’’𑀦𑁆𑀢𑀺.

𑁫𑁮𑁧.

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

𑀧𑀓𑁆𑀓𑀸𑀫𑀺 𑀲𑁄 𑀮𑀺𑀘𑁆𑀙𑀯𑀻𑀦𑀁 𑀲𑀓𑀸𑀲𑀁, 𑀅𑀣 𑀩𑁆𑀭𑀯𑀺 𑀧𑀭𑀺𑀲𑀁 𑀲𑀦𑁆𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁.

𑁫𑁮𑁨.

‘‘𑀲𑀼𑀡𑀦𑁆𑀢𑀼 𑀪𑁄𑀦𑁆𑀢𑁄 𑀫𑀫 𑀏𑀓𑀯𑀸𑀓𑁆𑀬𑀁, 𑀯𑀭𑀁 𑀯𑀭𑀺𑀲𑁆𑀲𑀁 𑀮𑀪𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀅𑀢𑁆𑀣𑀁;

𑀲𑀽𑀮𑀸𑀯𑀼𑀢𑁄 ¶ 𑀧𑀼𑀭𑀺𑀲𑁄 𑀮𑀼𑀤𑁆𑀤𑀓𑀫𑁆𑀫𑁄, 𑀧𑀡𑀻𑀳𑀺𑀢𑀤𑀡𑁆𑀟𑁄 [𑀧𑀡𑀻𑀢𑀦𑀡𑁆𑀟𑁄 (𑀓.)] 𑀅𑀦𑀼𑀲𑀢𑁆𑀢𑀭𑀽𑀧𑁄 [𑀅𑀦𑀼𑀧𑀓𑁆𑀓𑀭𑀽𑀧𑁄 (𑀓.)].

𑁫𑁮𑁩.

‘‘𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀸 𑀯𑀻𑀲𑀢𑀺𑀭𑀢𑁆𑀢𑀺𑀫𑀢𑁆𑀢𑀸, 𑀬𑀢𑁄 𑀆𑀯𑀼𑀢𑁄 𑀦𑁂𑀯 𑀚𑀻𑀯𑀢𑀺 𑀦 𑀫𑀢𑁄;

𑀢𑀸𑀳𑀁 𑀫𑁄𑀘𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀤𑀸𑀦𑀺, 𑀬𑀣𑀸𑀫𑀢𑀺𑀁 𑀅𑀦𑀼𑀚𑀸𑀦𑀸𑀢𑀼 𑀲𑀗𑁆𑀖𑁄’’𑀢𑀺.

𑁫𑁮𑁪.

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

𑀬𑀣𑀸 𑀧𑀚𑀸𑀦𑀸𑀲𑀺 𑀢𑀣𑀸 𑀓𑀭𑁄𑀳𑀺, 𑀬𑀣𑀸𑀫𑀢𑀺𑀁 𑀅𑀦𑀼𑀚𑀸𑀦𑀸𑀢𑀺 𑀲𑀗𑁆𑀖𑁄’’𑀢𑀺.

𑁫𑁮𑁫.

𑀲𑁄 ¶ 𑀢𑀁 𑀧𑀤𑁂𑀲𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀲𑀽𑀮𑀸𑀯𑀼𑀢𑀁 𑀫𑁄𑀘𑀬𑀺 𑀔𑀺𑀧𑁆𑀧𑀫𑁂𑀯;

‘𑀫𑀸 𑀪𑀸𑀬𑀺 𑀲𑀫𑁆𑀫𑀸’𑀢𑀺 𑀘 𑀢𑀁 𑀅𑀯𑁄𑀘, 𑀢𑀺𑀓𑀺𑀘𑁆𑀙𑀓𑀸𑀦𑀜𑁆𑀘 𑀉𑀧𑀝𑁆𑀞𑀧𑁂𑀲𑀺.

𑁫𑁮𑁬.

‘‘𑀓𑀧𑁆𑀧𑀺𑀢𑀓𑀜𑁆𑀘 ¶ 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸, 𑀢𑁂𑀦𑁂𑀯 𑀲𑀳 [𑀢𑁂𑀦 𑀲𑀫𑀁 (𑀲𑀻.), 𑀢𑁂𑀦 𑀲𑀳 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀲𑀁𑀯𑀺𑀪𑀚𑀺𑀢𑁆𑀯𑀸 𑀓𑀸𑀮𑁂;

𑀲𑀬𑀁 𑀫𑀼𑀔𑁂𑀦𑀽𑀧𑀦𑀺𑀲𑀚𑁆𑀚 𑀮𑀺𑀘𑁆𑀙𑀯𑀺, 𑀢𑀣𑁂𑀯 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁆𑀣 𑀦𑀁 𑀓𑀸𑀭𑀡𑀢𑁆𑀣𑀺𑀓𑁄.

𑁫𑁮𑁭.

‘‘𑀲𑀽𑀮𑀸𑀯𑀼𑀢𑁄 𑀧𑀼𑀭𑀺𑀲𑁄 𑀮𑀼𑀤𑁆𑀤𑀓𑀫𑁆𑀫𑁄, 𑀧𑀡𑀻𑀢𑀤𑀡𑁆𑀟𑁄 ¶ 𑀅𑀦𑀼𑀲𑀢𑁆𑀢𑀭𑀽𑀧𑁄;

𑀏𑀢𑁆𑀢𑀸𑀯𑀢𑀸 𑀯𑀻𑀲𑀢𑀺𑀭𑀢𑁆𑀢𑀺𑀫𑀢𑁆𑀢𑀸, 𑀬𑀢𑁄 𑀆𑀯𑀼𑀢𑁄 𑀦𑁂𑀯 𑀚𑀻𑀯𑀢𑀺 𑀦 𑀫𑀢𑁄.

𑁫𑁮𑁮.

‘‘𑀲𑁄 𑀫𑁄𑀘𑀺𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀫𑀬𑀸 𑀇𑀤𑀸𑀦𑀺, 𑀏𑀢𑀲𑁆𑀲 𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀯𑀘𑁄 𑀳𑀺 𑀪𑀦𑁆𑀢𑁂;

𑀲𑀺𑀬𑀸 𑀦𑀼 𑀔𑁄 𑀓𑀸𑀭𑀡𑀁 𑀓𑀺𑀜𑁆𑀘𑀺𑀤𑁂𑀯, 𑀬𑁂𑀦 𑀲𑁄 𑀦𑀺𑀭𑀬𑀁 𑀦𑁄 𑀯𑀚𑁂𑀬𑁆𑀬.

𑁫𑁮𑁯.

‘‘𑀆𑀘𑀺𑀓𑁆𑀔 𑀪𑀦𑁆𑀢𑁂 𑀬𑀤𑀺 𑀅𑀢𑁆𑀣𑀺 𑀳𑁂𑀢𑀼, 𑀲𑀤𑁆𑀥𑀸𑀬𑀺𑀓𑀁 𑀳𑁂𑀢𑀼𑀯𑀘𑁄 𑀲𑀼𑀡𑁄𑀫;

𑀦 𑀢𑁂𑀲𑀁 𑀓𑀫𑁆𑀫𑀸𑀦𑀁 𑀯𑀺𑀦𑀸𑀲𑀫𑀢𑁆𑀣𑀺, 𑀅𑀯𑁂𑀤𑀬𑀺𑀢𑁆𑀯𑀸 𑀇𑀥 𑀩𑁆𑀬𑀦𑁆𑀢𑀺𑀪𑀸𑀯𑁄’’𑀢𑀺.

𑁫𑁯𑁦.

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

𑀫𑀼𑀘𑁆𑀘𑁂𑀬𑁆𑀬 𑀲𑁄 𑀦𑀺𑀭𑀬𑀸 𑀘 𑀢𑀫𑁆𑀳𑀸, 𑀓𑀫𑁆𑀫𑀁 𑀲𑀺𑀬𑀸 𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀯𑁂𑀤𑀦𑀻𑀬’’𑀦𑁆𑀢𑀺.

𑁫𑁯𑁧.

‘‘𑀅𑀜𑁆𑀜𑀸𑀢𑁄 [𑀜𑀸𑀢𑁄𑀫𑁆𑀳𑀺 (𑀓.)] 𑀏𑀲𑁄 𑀧𑀼𑀭𑀺𑀲𑀲𑁆𑀲 𑀅𑀢𑁆𑀣𑁄, 𑀫𑀫𑀫𑁆𑀧𑀺 𑀤𑀸𑀦𑀺 𑀅𑀦𑀼𑀓𑀫𑁆𑀧 𑀪𑀦𑁆𑀢𑁂;

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

𑁫𑁯𑁨.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 ¶ ¶ 𑀩𑀼𑀤𑁆𑀥𑀁 𑀲𑀭𑀡𑀁 𑀉𑀧𑁂𑀳𑀺, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀲𑀗𑁆𑀖𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄;

𑀢𑀣𑁂𑀯 𑀲𑀺𑀓𑁆𑀔𑀸𑀬 𑀧𑀤𑀸𑀦𑀺 𑀧𑀜𑁆𑀘, 𑀅𑀔𑀡𑁆𑀟𑀨𑀼𑀮𑁆𑀮𑀸𑀦𑀺 𑀲𑀫𑀸𑀤𑀺𑀬𑀲𑁆𑀲𑀼.

𑁫𑁯𑁩.

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

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀫𑀸 𑀘 𑀫𑀼𑀲𑀸 𑀅𑀪𑀸𑀡𑀻, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀳𑀺 𑀢𑀼𑀝𑁆𑀞𑁄;

𑀇𑀫𑀜𑁆𑀘 𑀅𑀭𑀺𑀬𑀁 [𑀇𑀫𑀜𑁆𑀘 (𑀲𑁆𑀬𑀸.)] 𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑀯𑀭𑁂𑀦𑀼𑀧𑁂𑀢𑀁, 𑀲𑀫𑀸𑀤𑀺𑀬𑀸𑀳𑀺 𑀓𑀼𑀲𑀮𑀁 𑀲𑀼𑀔𑀼𑀤𑁆𑀭𑀬𑀁.

𑁫𑁯𑁪.

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

𑀅𑀦𑁆𑀦𑀁 𑀧𑀸𑀦𑀁 𑀔𑀸𑀤𑀦𑀻𑀬𑀁, 𑀯𑀢𑁆𑀣𑀲𑁂𑀦𑀸𑀲𑀦𑀸𑀦𑀺 𑀘;

𑀤𑀤𑀸𑀳𑀺 𑀉𑀚𑀼𑀪𑀽𑀢𑁂𑀲𑀼, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸 [𑀲𑀤𑀸 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀯𑀟𑁆𑀠𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)].

𑁫𑁯𑁫.

‘‘𑀪𑀺𑀓𑁆𑀔𑀽𑀧𑀺 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁂, 𑀯𑀻𑀢𑀭𑀸𑀕𑁂 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁂;

𑀢𑀧𑁆𑀧𑁂𑀳𑀺 𑀅𑀦𑁆𑀦𑀧𑀸𑀦𑁂𑀦, 𑀲𑀤𑀸 𑀧𑀼𑀜𑁆𑀜𑀁 𑀧𑀯𑀟𑁆𑀠𑀢𑀺.

𑁫𑁯𑁬.

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

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

𑁫𑁯𑁭.

‘‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀩𑀼𑀤𑁆𑀥𑀁 𑀲𑀭𑀡𑀁 𑀉𑀧𑁂𑀫𑀺, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘 𑀲𑀗𑁆𑀖𑀜𑁆𑀘 𑀧𑀲𑀦𑁆𑀦𑀘𑀺𑀢𑁆𑀢𑁄;

𑀢𑀣𑁂𑀯 𑀲𑀺𑀓𑁆𑀔𑀸𑀬 𑀧𑀤𑀸𑀦𑀺 𑀧𑀜𑁆𑀘, 𑀅𑀔𑀡𑁆𑀟𑀨𑀼𑀮𑁆𑀮𑀸𑀦𑀺 𑀲𑀫𑀸𑀤𑀺𑀬𑀸𑀫𑀺.

𑁫𑁯𑁮.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀫𑀸𑀫𑀺 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀸𑀫𑀺;

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀦𑁄 𑀘 𑀫𑀼𑀲𑀸 𑀪𑀡𑀸𑀫𑀺, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀫𑀺 𑀢𑀼𑀝𑁆𑀞𑁄;

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

𑁫𑁯𑁯.

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

𑀅𑀦𑁆𑀦𑀁 𑀧𑀸𑀦𑀁 𑀔𑀸𑀤𑀦𑀻𑀬𑀁, 𑀯𑀢𑁆𑀣𑀲𑁂𑀦𑀸𑀲𑀦𑀸𑀦𑀺 𑀘.

𑁬𑁦𑁦.

‘‘𑀪𑀺𑀓𑁆𑀔𑀽 ¶ 𑀘 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁂, 𑀯𑀻𑀢𑀭𑀸𑀕𑁂 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁂;

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

𑁬𑁦𑁧.

𑀏𑀢𑀸𑀤𑀺𑀲𑀸 𑀮𑀺𑀘𑁆𑀙𑀯𑀺 𑀅𑀫𑁆𑀩𑀲𑀓𑁆𑀓𑀭𑁄, 𑀯𑁂𑀲𑀸𑀮𑀺𑀬𑀁 𑀅𑀜𑁆𑀜𑀢𑀭𑁄 𑀉𑀧𑀸𑀲𑀓𑁄;

𑀲𑀤𑁆𑀥𑁄 𑀫𑀼𑀤𑀽 𑀓𑀸𑀭𑀓𑀭𑁄 𑀘 𑀪𑀺𑀓𑁆𑀔𑀼, 𑀲𑀗𑁆𑀖𑀜𑁆𑀘 𑀲𑀓𑁆𑀓𑀘𑁆𑀘 𑀢𑀤𑀸 𑀉𑀧𑀝𑁆𑀞𑀳𑀺.

𑁬𑁦𑁨.

𑀲𑀽𑀮𑀸𑀯𑀼𑀢𑁄 𑀘 𑀅𑀭𑁄𑀕𑁄 𑀳𑀼𑀢𑁆𑀯𑀸, 𑀲𑁂𑀭𑀻 ¶ 𑀲𑀼𑀔𑀻 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁 𑀉𑀧𑀸𑀕𑀫𑀺 [𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀫𑀼𑀧𑀕𑀘𑁆𑀙𑀺 (𑀓.)];

𑀪𑀺𑀓𑁆𑀔𑀼𑀜𑁆𑀘 𑀆𑀕𑀫𑁆𑀫 𑀓𑀧𑁆𑀧𑀺𑀢𑀓𑀼𑀢𑁆𑀢𑀫𑀁, 𑀉𑀪𑁄𑀧𑀺 𑀲𑀸𑀫𑀜𑁆𑀜𑀨𑀮𑀸𑀦𑀺 𑀅𑀚𑁆𑀛𑀕𑀼𑀁.

𑁬𑁦𑁩.

𑀏𑀢𑀸𑀤𑀺𑀲𑀸 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀸𑀦 𑀲𑁂𑀯𑀦𑀸, 𑀫𑀳𑀧𑁆𑀨𑀮𑀸 𑀳𑁄𑀢𑀺 𑀲𑀢𑀁 𑀯𑀺𑀚𑀸𑀦𑀢𑀁;

𑀲𑀽𑀮𑀸𑀯𑀼𑀢𑁄 𑀅𑀕𑁆𑀕𑀨𑀮𑀁 𑀅𑀨𑀲𑁆𑀲𑀬𑀺 [𑀨𑀼𑀲𑁆𑀲𑀬𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀨𑀮𑀁 𑀓𑀦𑀺𑀝𑁆𑀞𑀁 𑀧𑀦 𑀅𑀫𑁆𑀩𑀲𑀓𑁆𑀓𑀭𑁄’’𑀢𑀺.

𑀅𑀫𑁆𑀩𑀲𑀓𑁆𑀓𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀧𑀞𑀫𑀁.

𑁨. 𑀲𑁂𑀭𑀻𑀲𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁬𑁦𑁪.

[𑀯𑀺. 𑀯. 𑁧𑁨𑁨𑁮] 𑀲𑀼𑀡𑁄𑀣 𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀯𑀸𑀡𑀺𑀚𑀸𑀦 𑀘, 𑀲𑀫𑀸𑀕𑀫𑁄 𑀬𑀢𑁆𑀣 𑀢𑀤𑀸 𑀅𑀳𑁄𑀲𑀺;

𑀬𑀣𑀸 𑀓𑀣𑀁 𑀇𑀢𑀭𑀺𑀢𑀭𑁂𑀦 𑀘𑀸𑀧𑀺, 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁 𑀢𑀜𑁆𑀘 𑀲𑀼𑀡𑀸𑀣 𑀲𑀩𑁆𑀩𑁂.

𑁬𑁦𑁫.

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

𑀲𑁄 𑀫𑁄𑀤𑀫𑀸𑀦𑁄𑀯 𑀲𑀓𑁂 𑀯𑀺𑀫𑀸𑀦𑁂, 𑀅𑀫𑀸𑀦𑀼𑀲𑁄 𑀫𑀸𑀦𑀼𑀲𑁂 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀻𑀢𑀺.

𑁬𑁦𑁬.

‘‘𑀯𑀗𑁆𑀓𑁂 ¶ 𑀅𑀭𑀜𑁆𑀜𑁂 𑀅𑀫𑀦𑀼𑀲𑁆𑀲𑀝𑁆𑀞𑀸𑀦𑁂, 𑀓𑀦𑁆𑀢𑀸𑀭𑁂 𑀅𑀧𑁆𑀧𑁄𑀤𑀓𑁂 𑀅𑀧𑁆𑀧𑀪𑀓𑁆𑀔𑁂;

𑀲𑀼𑀤𑀼𑀕𑁆𑀕𑀫𑁂 𑀯𑀡𑁆𑀡𑀼𑀧𑀣𑀲𑁆𑀲 𑀫𑀚𑁆𑀛𑁂, 𑀯𑀗𑁆𑀓𑀁𑀪𑀬𑀸 𑀦𑀝𑁆𑀞𑀫𑀦𑀸 𑀫𑀦𑀼𑀲𑁆𑀲𑀸.

𑁬𑁦𑁭.

‘‘𑀦𑀬𑀺𑀥 𑀨𑀮𑀸 𑀫𑀽𑀮𑀫𑀬𑀸 𑀘 𑀲𑀦𑁆𑀢𑀺, 𑀉𑀧𑀸𑀤𑀸𑀦𑀁 𑀦𑀢𑁆𑀣𑀺 𑀓𑀼𑀢𑁄𑀥 𑀪𑀓𑁆𑀔𑁄 [𑀪𑀺𑀓𑁆𑀔𑁄 (𑀓.)];

𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀧𑀁𑀲𑀽𑀳𑀺 𑀘 𑀯𑀸𑀮𑀼𑀓𑀸𑀳𑀺 𑀘, 𑀢𑀢𑀸𑀳𑀺 𑀉𑀡𑁆𑀳𑀸𑀳𑀺 𑀘 𑀤𑀸𑀭𑀼𑀡𑀸𑀳𑀺 𑀘.

𑁬𑁦𑁮.

‘‘𑀉𑀚𑁆𑀚𑀗𑁆𑀕𑀮𑀁 𑀢𑀢𑁆𑀢𑀫𑀺𑀯𑀁 𑀓𑀧𑀸𑀮𑀁, 𑀅𑀦𑀸𑀬𑀲𑀁 𑀧𑀭𑀮𑁄𑀓𑁂𑀦 𑀢𑀼𑀮𑁆𑀬𑀁;

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

𑁬𑁦𑁯.

‘‘‘𑀅𑀣 𑀢𑀼𑀫𑁆𑀳𑁂 𑀓𑁂𑀦 𑀯𑀡𑁆𑀡𑁂𑀦, 𑀓𑀺𑀫𑀸𑀲𑀫𑀸𑀦𑀸 𑀇𑀫𑀁 𑀧𑀤𑁂𑀲𑀁 𑀳𑀺;

𑀅𑀦𑀼𑀧𑀯𑀺𑀝𑁆𑀞𑀸 𑀲𑀳𑀲𑀸 𑀲𑀫𑀘𑁆𑀘, 𑀮𑁄𑀪𑀸 𑀪𑀬𑀸 𑀅𑀣 𑀯𑀸 𑀲𑀫𑁆𑀧𑀫𑀽𑀴𑁆𑀳𑀸’’’𑀢𑀺.

𑁬𑁧𑁦.

‘‘𑀫𑀕𑀥𑁂𑀲𑀼 𑀅𑀗𑁆𑀕𑁂𑀲𑀼 𑀘 𑀲𑀢𑁆𑀣𑀯𑀸𑀳𑀸, 𑀆𑀭𑁄𑀧𑀬𑀺𑀢𑁆𑀯𑀸 𑀧𑀡𑀺𑀬𑀁 𑀧𑀼𑀣𑀼𑀢𑁆𑀢𑀁;

𑀢𑁂 𑀬𑀸𑀫𑀲𑁂 𑀲𑀺𑀦𑁆𑀥𑀼𑀲𑁄𑀯𑀻𑀭𑀪𑀽𑀫𑀺𑀁, 𑀥𑀦𑀢𑁆𑀣𑀺𑀓𑀸 𑀉𑀤𑁆𑀤𑀬𑀁 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑀸.

𑁬𑁧𑁧.

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

𑀏𑀢𑁂𑀦 𑀯𑁂𑀕𑁂𑀦 𑀆𑀬𑀸𑀫 𑀲𑀩𑁆𑀩𑁂, 𑀭𑀢𑁆𑀢𑀺𑀁 𑀫𑀕𑁆𑀕𑀁 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀸 𑀯𑀺𑀓𑀸𑀮𑁂.

𑁬𑁧𑁨.

‘‘𑀢𑁂 ¶ 𑀤𑀼𑀧𑁆𑀧𑀬𑀸𑀢𑀸 𑀅𑀧𑀭𑀤𑁆𑀥𑀫𑀕𑁆𑀕𑀸, 𑀅𑀦𑁆𑀥𑀸𑀓𑀼𑀮𑀸 𑀯𑀺𑀧𑁆𑀧𑀦𑀝𑁆𑀞𑀸 𑀅𑀭𑀜𑁆𑀜𑁂;

𑀲𑀼𑀤𑀼𑀕𑁆𑀕𑀫𑁂 𑀯𑀡𑁆𑀡𑀼𑀧𑀣𑀲𑁆𑀲 𑀫𑀚𑁆𑀛𑁂, 𑀤𑀺𑀲𑀁 𑀦 𑀚𑀸𑀦𑀸𑀫 𑀧𑀫𑀽𑀴𑁆𑀳𑀘𑀺𑀢𑁆𑀢𑀸.

𑁬𑁧𑁩.

‘‘𑀇𑀤𑀜𑁆𑀘 ¶ 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀅𑀤𑀺𑀝𑁆𑀞𑀧𑀼𑀩𑁆𑀩𑀁, 𑀯𑀺𑀫𑀸𑀦𑀲𑁂𑀝𑁆𑀞𑀜𑁆𑀘 𑀢𑀯𑀜𑁆𑀘 𑀬𑀓𑁆𑀔;

𑀢𑀢𑀼𑀢𑁆𑀢𑀭𑀺𑀁 𑀚𑀻𑀯𑀺𑀢𑀫𑀸𑀲𑀫𑀸𑀦𑀸, 𑀤𑀺𑀲𑁆𑀯𑀸 𑀧𑀢𑀻𑀢𑀸 𑀲𑀼𑀫𑀦𑀸 𑀉𑀤𑀕𑁆𑀕𑀸’’𑀢𑀺.

𑁬𑁧𑁪.

‘‘𑀧𑀸𑀭𑀁 𑀲𑀫𑀼𑀤𑁆𑀤𑀲𑁆𑀲 𑀇𑀫𑀜𑁆𑀘 𑀯𑀡𑁆𑀡𑀼𑀁, 𑀯𑁂𑀢𑁆𑀢𑀸𑀘𑀭𑀁 [𑀯𑁂𑀢𑁆𑀢𑀁 𑀧𑀭𑀁 (𑀲𑁆𑀬𑀸.), 𑀯𑁂𑀢𑁆𑀢𑀸𑀘𑀸𑀭𑀁 (𑀓.)] 𑀲𑀗𑁆𑀓𑀼𑀧𑀣𑀜𑁆𑀘 𑀫𑀕𑁆𑀕𑀁;

𑀦𑀤𑀺𑀬𑁄 𑀧𑀦 𑀧𑀩𑁆𑀩𑀢𑀸𑀦𑀜𑁆𑀘 𑀤𑀼𑀕𑁆𑀕𑀸, 𑀧𑀼𑀣𑀼𑀤𑁆𑀤𑀺𑀲𑀸 𑀕𑀘𑁆𑀙𑀣 𑀪𑁄𑀕𑀳𑁂𑀢𑀼.

𑁬𑁧𑁫.

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

𑀬𑀁 𑀯𑁄 𑀲𑀼𑀢𑀁 𑀯𑀸 𑀅𑀣 𑀯𑀸𑀧𑀺 𑀤𑀺𑀝𑁆𑀞𑀁, 𑀅𑀘𑁆𑀙𑁂𑀭𑀓𑀁 𑀢𑀁 𑀯𑁄 𑀲𑀼𑀡𑁄𑀫 𑀢𑀸𑀢𑀸’’𑀢𑀺.

𑁬𑁧𑁬.

‘‘𑀇𑀢𑁄𑀧𑀺 𑀅𑀘𑁆𑀙𑁂𑀭𑀢𑀭𑀁 𑀓𑀼𑀫𑀸𑀭, 𑀦 𑀦𑁄 𑀲𑀼𑀢𑀁 𑀯𑀸 𑀅𑀣 𑀯𑀸𑀧𑀺 𑀤𑀺𑀝𑁆𑀞𑀁;

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

𑁬𑁧𑁭.

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

𑀤𑀼𑀫𑀸 𑀘𑀺𑀫𑁂 𑀦𑀺𑀘𑁆𑀘𑀨𑀮𑀽𑀧𑀧𑀦𑁆𑀦𑀸, 𑀅𑀢𑀻𑀯 𑀕𑀦𑁆𑀥𑀸 𑀲𑀼𑀭𑀪𑀺𑀁 𑀧𑀯𑀸𑀬𑀦𑁆𑀢𑀺.

𑁬𑁧𑁮.

‘‘𑀯𑁂𑀴𑀽𑀭𑀺𑀬𑀣𑀫𑁆𑀪𑀸 𑀲𑀢𑀫𑀼𑀲𑁆𑀲𑀺𑀢𑀸𑀲𑁂, 𑀲𑀺𑀮𑀸𑀧𑀯𑀸𑀴𑀲𑁆𑀲 𑀘 𑀆𑀬𑀢𑀁𑀲𑀸;

𑀫𑀲𑀸𑀭𑀕𑀮𑁆𑀮𑀸 𑀲𑀳𑀮𑁄𑀳𑀺𑀢𑀗𑁆𑀕𑀸, 𑀣𑀫𑁆𑀪𑀸 𑀇𑀫𑁂 𑀚𑁄𑀢𑀺𑀭𑀲𑀸𑀫𑀬𑀸𑀲𑁂.

𑁬𑁧𑁯.

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

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

𑁬𑁨𑁦.

‘‘𑀚𑀫𑁆𑀩𑁄𑀦𑀤𑀼𑀢𑁆𑀢𑀢𑁆𑀢𑀫𑀺𑀤𑀁 ¶ 𑀲𑀼𑀫𑀝𑁆𑀞𑁄, 𑀧𑀸𑀲𑀸𑀤𑀲𑁄𑀧𑀸𑀡𑀨𑀮𑀽𑀧𑀧𑀦𑁆𑀦𑁄;

𑀤𑀴𑁆𑀳𑁄 𑀘 𑀯𑀕𑁆𑀕𑀼 𑀘 𑀲𑀼𑀲𑀗𑁆𑀕𑀢𑁄 𑀘 [𑀯𑀕𑁆𑀕𑀼 𑀲𑀼𑀫𑀼𑀔𑁄 𑀲𑀼𑀲𑀗𑁆𑀕𑀢𑁄 (𑀲𑀻.)], 𑀅𑀢𑀻𑀯 𑀦𑀺𑀚𑁆𑀛𑀸𑀦𑀔𑀫𑁄 𑀫𑀦𑀼𑀜𑁆𑀜𑁄.

𑁬𑁨𑁧.

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

𑀫𑀼𑀭𑀚𑀆𑀮𑀫𑁆𑀩𑀭𑀢𑀽𑀭𑀺𑀬𑀖𑀼𑀝𑁆𑀞𑁄, 𑀅𑀪𑀺𑀯𑀦𑁆𑀤𑀺𑀢𑁄𑀲𑀺 𑀣𑀼𑀢𑀺𑀯𑀦𑁆𑀤𑀦𑀸𑀬.

𑁬𑁨𑁨.

‘‘𑀲𑁄 𑀫𑁄𑀤𑀲𑀺 𑀦𑀸𑀭𑀺𑀕𑀡𑀧𑁆𑀧𑀩𑁄𑀥𑀦𑁄, 𑀯𑀺𑀫𑀸𑀦𑀧𑀸𑀲𑀸𑀤𑀯𑀭𑁂 𑀫𑀦𑁄𑀭𑀫𑁂;

𑀅𑀘𑀺𑀦𑁆𑀢𑀺𑀬𑁄 𑀲𑀩𑁆𑀩𑀕𑀼𑀡𑀽𑀧𑀧𑀦𑁆𑀦𑁄, 𑀭𑀸𑀚𑀸 𑀬𑀣𑀸 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑁄 𑀦𑀴𑀺𑀦𑁆𑀬𑀸 [𑀦𑀴𑀺𑀜𑁆𑀜𑀁 (𑀓.)].

𑁬𑁨𑁩.

‘‘𑀤𑁂𑀯𑁄 𑀦𑀼 𑀆𑀲𑀺 𑀉𑀤𑀯𑀸𑀲𑀺 𑀬𑀓𑁆𑀔𑁄, 𑀉𑀤𑀸𑀳𑀼 𑀤𑁂𑀯𑀺𑀦𑁆𑀤𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀪𑀽𑀢𑁄;

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

𑁬𑁨𑁪.

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

𑀇𑀫𑀁 𑀧𑀤𑁂𑀲𑀁 𑀅𑀪𑀺𑀧𑀸𑀮𑀬𑀸𑀫𑀺, 𑀯𑀘𑀦𑀓𑀭𑁄 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑀲𑁆𑀲 𑀭𑀜𑁆𑀜𑁄’’𑀢𑀺.

𑁬𑁨𑁫.

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

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

𑁬𑁨𑁬.

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

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

𑁬𑁨𑁭.

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

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

𑁬𑁨𑁮.

‘‘𑀫𑀫𑀁 ¶ 𑀧𑀸𑀬𑀸𑀲𑀻𑀢𑀺 𑀅𑀳𑀼 𑀲𑀫𑀜𑁆𑀜𑀸, 𑀭𑀚𑁆𑀚𑀁 𑀬𑀤𑀸 𑀓𑀸𑀭𑀬𑀺𑀁 𑀓𑁄𑀲𑀮𑀸𑀦𑀁;

𑀦𑀢𑁆𑀣𑀺𑀓𑀤𑀺𑀝𑁆𑀞𑀺 𑀓𑀤𑀭𑀺𑀬𑁄 𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁄, 𑀉𑀘𑁆𑀙𑁂𑀤𑀯𑀸𑀤𑀻 𑀘 𑀢𑀤𑀸 𑀅𑀳𑁄𑀲𑀺𑀁.

𑁬𑁨𑁯.

‘‘𑀲𑀫𑀡𑁄 𑀘 𑀔𑁄 𑀆𑀲𑀺 𑀓𑀼𑀫𑀸𑀭𑀓𑀲𑁆𑀲𑀧𑁄, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁄 𑀘𑀺𑀢𑁆𑀢𑀓𑀣𑀻 𑀉𑀴𑀸𑀭𑁄;

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

𑁬𑁩𑁦.

‘‘𑀢𑀸𑀳𑀁 𑀢𑀲𑁆𑀲 𑀥𑀫𑁆𑀫𑀓𑀣𑀁 𑀲𑀼𑀡𑀺𑀢𑁆𑀯𑀸, 𑀉𑀧𑀸𑀲𑀓𑀢𑁆𑀢𑀁 𑀧𑀝𑀺𑀤𑁂𑀯𑀬𑀺𑀲𑁆𑀲𑀁;

𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀢𑁄 𑀅𑀳𑁄𑀲𑀺𑀁, 𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀺𑀲𑁆𑀲𑀁;

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

𑁬𑁩𑁧.

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

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

𑁬𑁩𑁨.

‘‘𑀲𑀘𑁆𑀘𑀁 𑀓𑀺𑀭𑀸𑀳𑀁𑀲𑀼 𑀦𑀭𑀸 𑀲𑀧𑀜𑁆𑀜𑀸, 𑀅𑀦𑀜𑁆𑀜𑀣𑀸 𑀯𑀘𑀦𑀁 𑀧𑀡𑁆𑀟𑀺𑀢𑀸𑀦𑀁;

𑀬𑀳𑀺𑀁 𑀬𑀳𑀺𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀧𑀼𑀜𑁆𑀜𑀓𑀫𑁆𑀫𑁄, 𑀢𑀳𑀺𑀁 𑀢𑀳𑀺𑀁 𑀫𑁄𑀤𑀢𑀺 𑀓𑀸𑀫𑀓𑀸𑀫𑀻.

𑁬𑁩𑁩.

‘‘𑀬𑀳𑀺𑀁 𑀬𑀳𑀺𑀁 𑀲𑁄𑀓𑀧𑀭𑀺𑀤𑁆𑀤𑀯𑁄 𑀘, 𑀯𑀥𑁄 𑀘 𑀩𑀦𑁆𑀥𑁄 𑀘 𑀧𑀭𑀺𑀓𑁆𑀓𑀺𑀮𑁂𑀲𑁄;

𑀢𑀳𑀺𑀁 𑀢𑀳𑀺𑀁 𑀕𑀘𑁆𑀙𑀢𑀺 𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑁄, 𑀦 𑀫𑀼𑀘𑁆𑀘𑀢𑀺 𑀤𑀼𑀕𑁆𑀕𑀢𑀺𑀬𑀸 𑀓𑀤𑀸𑀘𑀻’’𑀢𑀺.

𑁬𑁩𑁪.

‘‘𑀲𑀫𑁆𑀫𑀽𑀴𑁆𑀳𑀭𑀽𑀧𑁄𑀯 ¶ 𑀚𑀦𑁄 𑀅𑀳𑁄𑀲𑀺, 𑀅𑀲𑁆𑀫𑀺𑀁 𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑁂 𑀓𑀮𑀮𑀻𑀓𑀢𑁄𑀯;

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

𑁬𑁩𑁫.

‘‘𑀇𑀫𑁂 𑀘 𑀲𑀺𑀭𑀻𑀲𑀯𑀦𑀸 [𑀇𑀫𑁂 𑀲𑀺𑀭𑀻𑀲𑀽𑀧𑀯𑀦𑀸 𑀘 (𑀲𑀻.), 𑀇𑀫𑁂𑀧𑀺 𑀲𑀺𑀭𑀻𑀲𑀯𑀦𑀸 𑀘 (𑀧𑀻. 𑀓.)] 𑀢𑀸𑀢𑀸, 𑀤𑀺𑀩𑁆𑀩𑀸 𑀕𑀦𑁆𑀥𑀸 𑀲𑀼𑀭𑀪𑀻 𑀲𑀫𑁆𑀧𑀯𑀦𑁆𑀢𑀺;

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

𑁬𑁩𑁬.

‘‘𑀇𑀫𑁂𑀲𑀜𑁆𑀘 𑀔𑁄 𑀯𑀲𑁆𑀲𑀲𑀢𑀘𑁆𑀘𑀬𑁂𑀦, 𑀲𑀺𑀧𑀸𑀝𑀺𑀓𑀸 𑀨𑀮𑀢𑀺 𑀏𑀓𑀫𑁂𑀓𑀸;

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

𑁬𑁩𑁭.

‘‘𑀤𑀺𑀲𑁆𑀯𑀸𑀦𑀳𑀁 𑀯𑀲𑁆𑀲𑀲𑀢𑀸𑀦𑀺 𑀧𑀜𑁆𑀘, 𑀅𑀲𑁆𑀫𑀺𑀁 𑀯𑀺𑀫𑀸𑀦𑁂 𑀞𑀢𑁆𑀯𑀸𑀦 𑀢𑀸𑀢𑀸;

𑀆𑀬𑀼𑀓𑁆𑀔𑀬𑀸 𑀧𑀼𑀜𑁆𑀜𑀓𑁆𑀔𑀬𑀸 𑀘𑀯𑀺𑀲𑁆𑀲𑀁, 𑀢𑁂𑀦𑁂𑀯 𑀲𑁄𑀓𑁂𑀦 𑀧𑀫𑀼𑀘𑁆𑀙𑀺𑀢𑁄𑀲𑁆𑀫𑀻’’𑀢𑀺.

𑁬𑁩𑁮.

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

𑀬𑁂 𑀘𑀸𑀧𑀺 𑀔𑁄 𑀇𑀢𑁆𑀢𑀭𑀫𑀼𑀧𑀧𑀦𑁆𑀦𑀸, 𑀢𑁂 𑀦𑀽𑀦 𑀲𑁄𑀘𑁂𑀬𑁆𑀬𑀼𑀁 𑀧𑀭𑀺𑀢𑁆𑀢𑀧𑀼𑀜𑁆𑀜𑀸’’𑀢𑀺.

𑁬𑁩𑁯.

‘‘𑀅𑀦𑀼𑀘𑁆𑀙𑀯𑀺𑀁 𑀑𑀯𑀤𑀺𑀬𑀜𑁆𑀘 𑀫𑁂 𑀢𑀁, 𑀬𑀁 𑀫𑀁 𑀢𑀼𑀫𑁆𑀳𑁂 𑀧𑁂𑀬𑁆𑀬𑀯𑀸𑀘𑀁 𑀯𑀤𑁂𑀣;

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

𑁬𑁪𑁦.

‘‘𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀫𑀬𑀁 𑀲𑀺𑀦𑁆𑀥𑀼𑀲𑁄𑀯𑀻𑀭𑀪𑀽𑀫𑀺𑀁, 𑀥𑀦𑁆𑀦𑀢𑁆𑀣𑀺𑀓𑀸 𑀉𑀤𑁆𑀤𑀬𑀁 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑀸;

𑀬𑀣𑀸𑀧𑀬𑁄𑀕𑀸 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀘𑀸𑀕𑀸, 𑀓𑀸𑀳𑀸𑀫 𑀲𑁂𑀭𑀻𑀲𑀫𑀳𑀁 𑀉𑀴𑀸𑀭’’𑀦𑁆𑀢𑀺.

𑁬𑁪𑁧.

‘‘𑀫𑀸 ¶ 𑀘𑁂𑀯 𑀲𑁂𑀭𑀻𑀲𑀫𑀳𑀁 𑀅𑀓𑀢𑁆𑀣, 𑀲𑀩𑁆𑀩𑀜𑁆𑀘 𑀯𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺 𑀬𑀁 𑀯𑀤𑁂𑀣;

𑀧𑀸𑀧𑀸𑀦𑀺 𑀓𑀫𑁆𑀫𑀸𑀦𑀺 𑀯𑀺𑀯𑀚𑁆𑀚𑀬𑀸𑀣, 𑀥𑀫𑁆𑀫𑀸𑀦𑀼𑀬𑁄𑀕𑀜𑁆𑀘 𑀅𑀥𑀺𑀝𑁆𑀞𑀳𑀸𑀣.

𑁬𑁪𑁨.

‘‘𑀉𑀧𑀸𑀲𑀓𑁄 𑀅𑀢𑁆𑀣𑀺 𑀇𑀫𑀫𑁆𑀳𑀺 𑀲𑀗𑁆𑀖𑁂, 𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁄 𑀲𑀻𑀮𑀯𑀢𑀽𑀧𑀧𑀦𑁆𑀦𑁄;

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

𑁬𑁪𑁩.

‘‘𑀲𑀜𑁆𑀚𑀸𑀦𑀫𑀸𑀦𑁄 ¶ 𑀦 𑀫𑀼𑀲𑀸 𑀪𑀡𑁂𑀬𑁆𑀬, 𑀧𑀭𑀽𑀧𑀖𑀸𑀢𑀸𑀬 𑀘 𑀘𑁂𑀢𑀬𑁂𑀬𑁆𑀬;

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

𑁬𑁪𑁪.

‘‘𑀲𑀕𑀸𑀭𑀯𑁄 𑀲𑀧𑁆𑀧𑀝𑀺𑀲𑁆𑀲𑁄 𑀯𑀺𑀦𑀻𑀢𑁄, 𑀅𑀧𑀸𑀧𑀓𑁄 𑀅𑀥𑀺𑀲𑀻𑀮𑁂 𑀯𑀺𑀲𑀼𑀤𑁆𑀥𑁄;

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

𑁬𑁪𑁫.

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

𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽𑀦𑀜𑁆𑀘 𑀬𑁄 𑀅𑀘𑁆𑀘𑀬𑁂𑀦, 𑀦𑁂𑀓𑁆𑀔𑀫𑁆𑀫𑀧𑁄𑀡𑁄 𑀘𑀭𑀺𑀲𑁆𑀲𑀢𑀺 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑀁.

𑁬𑁪𑁬.

‘‘𑀉𑀚𑀽 𑀅𑀯𑀗𑁆𑀓𑁄 𑀅𑀲𑀞𑁄 𑀅𑀫𑀸𑀬𑁄, 𑀦 𑀮𑁂𑀲𑀓𑀧𑁆𑀧𑁂𑀦 𑀘 𑀯𑁄𑀳𑀭𑁂𑀬𑁆𑀬;

𑀲𑁄 𑀢𑀸𑀤𑀺𑀲𑁄 𑀲𑀼𑀓𑀢𑀓𑀫𑁆𑀫𑀓𑀸𑀭𑀻, 𑀥𑀫𑁆𑀫𑁂 𑀞𑀺𑀢𑁄 𑀓𑀺𑀦𑁆𑀢𑀺 𑀮𑀪𑁂𑀣 𑀤𑀼𑀓𑁆𑀔𑀁.

𑁬𑁪𑁭.

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

𑀅𑀜𑁆𑀜𑀢𑁆𑀭 𑀢𑁂𑀦𑀺𑀳 𑀪𑀲𑁆𑀫𑀻 [𑀪𑀲𑁆𑀫𑀺 (𑀲𑁆𑀬𑀸.), 𑀪𑀲𑁆𑀫 (𑀓.)] 𑀪𑀯𑁂𑀣, 𑀅𑀦𑁆𑀥𑀸𑀓𑀼𑀮𑀸 𑀯𑀺𑀧𑁆𑀧𑀦𑀝𑁆𑀞𑀸 𑀅𑀭𑀜𑁆𑀜𑁂;

𑀢𑀁 𑀔𑀺𑀧𑁆𑀧𑀫𑀸𑀦𑁂𑀦 𑀮𑀳𑀼𑀁 𑀧𑀭𑁂𑀦, 𑀲𑀼𑀔𑁄 𑀳𑀯𑁂 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑁂𑀦 𑀲𑀗𑁆𑀕𑀫𑁄’’𑀢𑀺.

𑁬𑁪𑁮.

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

𑀫𑀬𑀫𑁆𑀧𑀺 𑀦𑀁 𑀤𑀝𑁆𑀞𑀼𑀓𑀸𑀫𑀫𑁆𑀳 𑀬𑀓𑁆𑀔, 𑀬𑀲𑁆𑀲𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀸𑀬 𑀇𑀥𑀸𑀕𑀢𑁄𑀲𑀺;

𑀮𑀸𑀪𑀸 𑀳𑀺 𑀢𑀲𑁆𑀲 𑀬𑀲𑁆𑀲 𑀢𑀼𑀯𑀁 𑀧𑀺𑀳𑁂𑀲𑀻’’𑀢𑀺.

𑁬𑁪𑁯.

‘‘𑀬𑁄 𑀓𑀧𑁆𑀧𑀓𑁄 𑀲𑀫𑁆𑀪𑀯𑀦𑀸𑀫𑀥𑁂𑀬𑁆𑀬𑁄, 𑀉𑀧𑀸𑀲𑀓𑁄 𑀓𑁄𑀘𑁆𑀙𑀨𑀮𑀽𑀧𑀚𑀻𑀯𑀻;

𑀚𑀸𑀦𑀸𑀣 𑀦𑀁 𑀢𑀼𑀫𑁆𑀳𑀸𑀓𑀁 𑀧𑁂𑀲𑀺𑀬𑁄 𑀲𑁄, 𑀫𑀸 𑀔𑁄 𑀦𑀁 𑀳𑀻𑀴𑀺𑀢𑁆𑀣 𑀲𑀼𑀧𑁂𑀲𑀮𑁄 𑀲𑁄’’𑀢𑀺.

𑁬𑁫𑁦.

‘‘𑀚𑀸𑀦𑀸𑀫𑀲𑁂 𑀬𑀁 𑀢𑁆𑀯𑀁 𑀧𑀯𑀤𑁂𑀲𑀺 𑀬𑀓𑁆𑀔, 𑀦 𑀔𑁄 𑀦𑀁 𑀚𑀸𑀦𑀸𑀫 𑀲 𑀏𑀤𑀺𑀲𑁄𑀢𑀺;

𑀫𑀬𑀫𑁆𑀧𑀺 𑀦𑀁 𑀧𑀽𑀚𑀬𑀺𑀲𑁆𑀲𑀸𑀫 𑀬𑀓𑁆𑀔, 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀘𑀦𑀁 𑀉𑀴𑀸𑀭’’𑀦𑁆𑀢𑀺.

𑁬𑁫𑁧.

‘‘𑀬𑁂 𑀓𑁂𑀘𑀺 𑀇𑀫𑀲𑁆𑀫𑀺𑀁 𑀲𑀢𑁆𑀣𑁂 𑀫𑀦𑀼𑀲𑁆𑀲𑀸, 𑀤𑀳𑀭𑀸 𑀫𑀳𑀦𑁆𑀢𑀸 𑀅𑀣𑀯𑀸𑀧𑀺 𑀫𑀚𑁆𑀛𑀺𑀫𑀸;

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

𑁬𑁫𑁨.

𑀢𑁂 𑀢𑀢𑁆𑀣 𑀲𑀩𑁆𑀩𑁂𑀯 ‘𑀅𑀳𑀁 𑀧𑀼𑀭𑁂’𑀢𑀺, 𑀢𑀁 𑀓𑀧𑁆𑀧𑀓𑀁 𑀢𑀢𑁆𑀣 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁆𑀯𑀸 [𑀧𑀼𑀭𑀓𑁆𑀔𑀺𑀧𑀺𑀢𑁆𑀯𑀸 (𑀲𑀻.)];

𑀲𑀩𑁆𑀩𑁂𑀯 𑀢𑁂 𑀆𑀮𑀫𑁆𑀩𑀺𑀁𑀲𑀼 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀫𑀲𑀓𑁆𑀓𑀲𑀸𑀭𑀁 𑀯𑀺𑀬 𑀯𑀸𑀲𑀯𑀲𑁆𑀲.

𑁬𑁫𑁩.

𑀢𑁂 𑀢𑀢𑁆𑀣 𑀲𑀩𑁆𑀩𑁂𑀯 ‘𑀅𑀳𑀁 𑀧𑀼𑀭𑁂’𑀢𑀺, 𑀉𑀧𑀸𑀲𑀓𑀢𑁆𑀢𑀁 𑀧𑀝𑀺𑀯𑁂𑀤𑀬𑀺𑀁𑀲𑀼;

𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀧𑀝𑀺𑀯𑀺𑀭𑀢𑀸 𑀅𑀳𑁂𑀲𑀼𑀁, 𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀺𑀁𑀲𑀼;

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

𑁬𑁫𑁪.

𑀢𑁂 ¶ 𑀢𑀢𑁆𑀣 𑀲𑀩𑁆𑀩𑁂𑀯 ‘𑀅𑀳𑀁 𑀧𑀼𑀭𑁂’𑀢𑀺, 𑀉𑀧𑀸𑀲𑀓𑀢𑁆𑀢𑀁 𑀧𑀝𑀺𑀯𑁂𑀤𑀬𑀺𑀢𑁆𑀯𑀸;

𑀧𑀓𑁆𑀓𑀸𑀫𑀺 𑀲𑀢𑁆𑀣𑁄 𑀅𑀦𑀼𑀫𑁄𑀤𑀫𑀸𑀦𑁄, 𑀬𑀓𑁆𑀔𑀺𑀤𑁆𑀥𑀺𑀬𑀸 𑀅𑀦𑀼𑀫𑀢𑁄 𑀧𑀼𑀦𑀧𑁆𑀧𑀼𑀦𑀁.

𑁬𑁫𑁫.

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

𑀬𑀣𑀸𑀧𑀬𑁄𑀕𑀸 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀮𑀸𑀪𑀸, 𑀧𑀘𑁆𑀘𑀸𑀕𑀫𑀼𑀁 𑀧𑀸𑀝𑀮𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑀓𑁆𑀔𑀢𑀁.

𑁬𑁫𑁬.

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

𑀆𑀦𑀦𑁆𑀤𑀻 𑀯𑀺𑀢𑁆𑀢𑀸 𑀲𑀼𑀫𑀦𑀸 𑀧𑀢𑀻𑀢𑀸, 𑀅𑀓𑀁𑀲𑀼 𑀲𑁂𑀭𑀻𑀲𑀫𑀳𑀁 𑀉𑀴𑀸𑀭𑀁;

𑀲𑁂𑀭𑀻𑀲𑀓𑀁 𑀢𑁂 𑀧𑀭𑀺𑀯𑁂𑀡𑀁 𑀫𑀸𑀧𑀬𑀺𑀁𑀲𑀼.

𑁬𑁫𑁭.

𑀏𑀢𑀸𑀤𑀺𑀲𑀸 ¶ 𑀲𑀧𑁆𑀧𑀼𑀭𑀺𑀲𑀸𑀦 𑀲𑁂𑀯𑀦𑀸, 𑀫𑀳𑀢𑁆𑀣𑀺𑀓𑀸 𑀥𑀫𑁆𑀫𑀕𑀼𑀡𑀸𑀦 𑀲𑁂𑀯𑀦𑀸;

𑀏𑀓𑀲𑁆𑀲 𑀅𑀢𑁆𑀣𑀸𑀬 𑀉𑀧𑀸𑀲𑀓𑀲𑁆𑀲, 𑀲𑀩𑁆𑀩𑁂𑀯 𑀲𑀢𑁆𑀢𑀸 𑀲𑀼𑀔𑀺𑀢𑀸 [𑀲𑀼𑀔𑀺𑀦𑁄 (𑀧𑀻. 𑀓.)] 𑀅𑀳𑁂𑀲𑀼𑀦𑁆𑀢𑀺.

𑀲𑁂𑀭𑀻𑀲𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀤𑀼𑀢𑀺𑀬𑀁.

𑀪𑀸𑀡𑀯𑀸𑀭𑀁 𑀢𑀢𑀺𑀬𑀁 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀁.

𑁩. 𑀦𑀦𑁆𑀤𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁬𑁫𑁮.

𑀭𑀸𑀚𑀸 ¶ 𑀧𑀺𑀗𑁆𑀕𑀮𑀓𑁄 𑀦𑀸𑀫, 𑀲𑀼𑀭𑀝𑁆𑀞𑀸𑀦𑀁 𑀅𑀥𑀺𑀧𑀢𑀺 𑀅𑀳𑀼;

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

𑁬𑁫𑁯.

𑀉𑀡𑁆𑀳𑁂 𑀫𑀚𑁆𑀛𑀦𑁆𑀳𑀺𑀓𑁂 [𑀫𑀚𑁆𑀛𑀦𑁆𑀢𑀺𑀓𑁂 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣)] 𑀓𑀸𑀮𑁂, 𑀭𑀸𑀚𑀸 𑀧𑀗𑁆𑀓𑀁 [𑀯𑀗𑁆𑀓𑀁 (𑀓.)] 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀅𑀤𑁆𑀤𑀲 𑀫𑀕𑁆𑀕𑀁 𑀭𑀫𑀡𑀻𑀬𑀁, 𑀧𑁂𑀢𑀸𑀦𑀁 𑀢𑀁 𑀯𑀡𑁆𑀡𑀼𑀧𑀣𑀁 [𑀯𑀡𑁆𑀡𑀦𑀸𑀧𑀣𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)].

𑁬𑁬𑁦.

𑀲𑀸𑀭𑀣𑀺𑀁 ¶ 𑀆𑀫𑀦𑁆𑀢𑀬𑀻 𑀭𑀸𑀚𑀸 𑁋

‘‘𑀅𑀬𑀁 𑀫𑀕𑁆𑀕𑁄 𑀭𑀫𑀡𑀻𑀬𑁄, 𑀔𑁂𑀫𑁄 𑀲𑁄𑀯𑀢𑁆𑀣𑀺𑀓𑁄 𑀲𑀺𑀯𑁄;

𑀇𑀫𑀺𑀦𑀸 𑀲𑀸𑀭𑀣𑀺 𑀬𑀸𑀫, 𑀲𑀼𑀭𑀝𑁆𑀞𑀸𑀦𑀁 𑀲𑀦𑁆𑀢𑀺𑀓𑁂 𑀇𑀢𑁄’’.

𑁬𑁬𑁧.

𑀢𑁂𑀦 ¶ 𑀧𑀸𑀬𑀸𑀲𑀺 𑀲𑁄𑀭𑀝𑁆𑀞𑁄, 𑀲𑁂𑀦𑀸𑀬 𑀘𑀢𑀼𑀭𑀗𑁆𑀕𑀺𑀦𑀺𑀬𑀸;

𑀉𑀩𑁆𑀩𑀺𑀕𑁆𑀕𑀭𑀽𑀧𑁄 𑀧𑀼𑀭𑀺𑀲𑁄, 𑀲𑁄𑀭𑀝𑁆𑀞𑀁 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺.

𑁬𑁬𑁨.

‘‘𑀓𑀼𑀫𑁆𑀫𑀕𑁆𑀕𑀁 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀫𑁆𑀳𑀸, 𑀪𑀺𑀁𑀲𑀦𑀁 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑀁;

𑀧𑀼𑀭𑀢𑁄 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀫𑀕𑁆𑀕𑁄, 𑀧𑀘𑁆𑀙𑀢𑁄 𑀘 𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑁬𑁬𑁩.

‘‘𑀓𑀼𑀫𑁆𑀫𑀕𑁆𑀕𑀁 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀫𑁆𑀳𑀸, 𑀬𑀫𑀧𑀼𑀭𑀺𑀲𑀸𑀦 𑀲𑀦𑁆𑀢𑀺𑀓𑁂;

𑀅𑀫𑀸𑀦𑀼𑀲𑁄 𑀯𑀸𑀬𑀢𑀺 𑀕𑀦𑁆𑀥𑁄, 𑀖𑁄𑀲𑁄 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 [𑀲𑀽𑀬𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)] 𑀤𑀸𑀭𑀼𑀡𑁄’’.

𑁬𑁬𑁪.

𑀲𑀁𑀯𑀺𑀕𑁆𑀕𑁄 𑀭𑀸𑀚𑀸 𑀲𑁄𑀭𑀝𑁆𑀞𑁄, 𑀲𑀸𑀭𑀣𑀺𑀁 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

‘‘𑀓𑀼𑀫𑁆𑀫𑀕𑁆𑀕𑀁 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀫𑁆𑀳𑀸, 𑀪𑀺𑀁𑀲𑀦𑀁 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑀁;

𑀧𑀼𑀭𑀢𑁄 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀫𑀕𑁆𑀕𑁄, 𑀧𑀘𑁆𑀙𑀢𑁄 𑀘 𑀦 𑀤𑀺𑀲𑁆𑀲𑀢𑀺.

𑁬𑁬𑁫.

‘‘𑀓𑀼𑀫𑁆𑀫𑀕𑁆𑀕𑀁 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀫𑁆𑀳𑀸, 𑀬𑀫𑀧𑀼𑀭𑀺𑀲𑀸𑀦 𑀲𑀦𑁆𑀢𑀺𑀓𑁂;

𑀅𑀫𑀸𑀦𑀼𑀲𑁄 𑀯𑀸𑀬𑀢𑀺 𑀕𑀦𑁆𑀥𑁄, 𑀖𑁄𑀲𑁄 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀤𑀸𑀭𑀼𑀡𑁄’’.

𑁬𑁬𑁬.

𑀳𑀢𑁆𑀣𑀺𑀓𑁆𑀔𑀦𑁆𑀥𑀁 𑀲𑀫𑀸𑀭𑀼𑀬𑁆𑀳, 𑀑𑀮𑁄𑀓𑁂𑀦𑁆𑀢𑁄 𑀘𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑀁 [𑀘𑀢𑀼𑀤𑁆𑀤𑀺𑀲𑁆𑀲𑀸 (𑀓.)];

𑀅𑀤𑁆𑀤𑀲 𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑀁 𑀭𑀫𑀡𑀻𑀬𑀁 [𑀭𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀧𑀸𑀤𑀧𑀁 𑀙𑀸𑀬𑀸𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁;

𑀦𑀻𑀮𑀩𑁆𑀪𑀯𑀡𑁆𑀡𑀲𑀤𑀺𑀲𑀁, 𑀫𑁂𑀖𑀯𑀡𑁆𑀡𑀲𑀺𑀭𑀻𑀦𑀺𑀪𑀁.

𑁬𑁬𑁭.

𑀲𑀸𑀭𑀣𑀺𑀁 ¶ ¶ 𑀆𑀫𑀦𑁆𑀢𑀬𑀻 𑀭𑀸𑀚𑀸, ‘‘𑀓𑀺𑀁 𑀏𑀲𑁄 𑀤𑀺𑀲𑁆𑀲𑀢𑀺 𑀩𑁆𑀭𑀳𑀸;

𑀦𑀻𑀮𑀩𑁆𑀪𑀯𑀡𑁆𑀡𑀲𑀤𑀺𑀲𑁄, 𑀫𑁂𑀖𑀯𑀡𑁆𑀡𑀲𑀺𑀭𑀻𑀦𑀺𑀪𑁄’’.

𑁬𑁬𑁮.

‘‘𑀦𑀺𑀕𑁆𑀭𑁄𑀥𑁄 𑀲𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀧𑀸𑀤𑀧𑁄 𑀙𑀸𑀬𑀸𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄;

𑀦𑀻𑀮𑀩𑁆𑀪𑀯𑀡𑁆𑀡𑀲𑀤𑀺𑀲𑁄 ¶ , 𑀫𑁂𑀖𑀯𑀡𑁆𑀡𑀲𑀺𑀭𑀻𑀦𑀺𑀪𑁄’’.

𑁬𑁬𑁯.

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

𑀦𑀻𑀮𑀩𑁆𑀪𑀯𑀡𑁆𑀡𑀲𑀤𑀺𑀲𑁄, 𑀫𑁂𑀖𑀯𑀡𑁆𑀡𑀲𑀺𑀭𑀻𑀦𑀺𑀪𑁄.

𑁬𑁭𑁦.

𑀳𑀢𑁆𑀣𑀺𑀓𑁆𑀔𑀦𑁆𑀥𑀢𑁄 𑀑𑀭𑀼𑀬𑁆𑀳, 𑀭𑀸𑀚𑀸 𑀭𑀼𑀓𑁆𑀔𑀁 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀦𑀺𑀲𑀻𑀤𑀺 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀲𑁆𑀫𑀺𑀁, 𑀲𑀸𑀫𑀘𑁆𑀘𑁄 𑀲𑀧𑀭𑀺𑀚𑁆𑀚𑀦𑁄;

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

𑁬𑁭𑁧.

𑀧𑀼𑀭𑀺𑀲𑁄 ¶ 𑀘 𑀤𑁂𑀯𑀯𑀡𑁆𑀡𑀻, 𑀲𑀩𑁆𑀩𑀸𑀪𑀭𑀡𑀪𑀽𑀲𑀺𑀢𑁄;

𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺𑀢𑁆𑀯𑀸 𑀭𑀸𑀚𑀸𑀦𑀁, 𑀲𑁄𑀭𑀝𑁆𑀞𑀁 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺.

𑁬𑁭𑁨.

‘‘𑀲𑁆𑀯𑀸𑀕𑀢𑀁 𑀢𑁂 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀅𑀣𑁄 𑀢𑁂 𑀅𑀤𑀼𑀭𑀸𑀕𑀢𑀁;

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

𑁬𑁭𑁩.

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

𑀧𑀽𑀯𑁂 𑀔𑀸𑀤𑀺𑀢𑁆𑀯𑀸 𑀧𑀺𑀢𑁆𑀯𑀸 𑀘, 𑀲𑁄𑀭𑀝𑁆𑀞𑁄 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺.

𑁬𑁭𑁪.

‘‘𑀤𑁂𑀯𑀢𑀸 𑀦𑀼𑀲𑀺 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀅𑀤𑀼 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀅𑀚𑀸𑀦𑀦𑁆𑀢𑀸 𑀢𑀁 𑀧𑀼𑀘𑁆𑀙𑀸𑀫, 𑀓𑀣𑀁 𑀚𑀸𑀦𑁂𑀫𑀼 𑀢𑀁 𑀫𑀬’’𑀦𑁆𑀢𑀺.

𑁬𑁭𑁫.

‘‘𑀦𑀸𑀫𑁆𑀳𑀺 𑀤𑁂𑀯𑁄 𑀦 𑀕𑀦𑁆𑀥𑀩𑁆𑀩𑁄, 𑀦𑀸𑀧𑀺 [𑀦𑀫𑁆𑀳𑀺 (𑀓.)] 𑀲𑀓𑁆𑀓𑁄 𑀧𑀼𑀭𑀺𑀦𑁆𑀤𑀤𑁄;

𑀧𑁂𑀢𑁄 𑀅𑀳𑀁 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀲𑀼𑀭𑀝𑁆𑀞𑀸 𑀇𑀥 𑀫𑀸𑀕𑀢𑁄’’𑀢𑀺.

𑁬𑁭𑁬.

‘‘𑀓𑀺𑀁𑀲𑀻𑀮𑁄 𑀓𑀺𑀁𑀲𑀫𑀸𑀘𑀸𑀭𑁄, 𑀲𑀼𑀭𑀝𑁆𑀞𑀲𑁆𑀫𑀺𑀁 𑀧𑀼𑀭𑁂 𑀢𑀼𑀯𑀁;

𑀓𑁂𑀦 𑀢𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀭𑀺𑀬𑁂𑀦, 𑀆𑀦𑀼𑀪𑀸𑀯𑁄 𑀅𑀬𑀁 𑀢𑀯𑀸’’𑀢𑀺.

𑁬𑁭𑁭.

‘‘𑀢𑀁 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀅𑀭𑀺𑀦𑁆𑀤𑀫 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦;

𑀅𑀫𑀘𑁆𑀘𑀸 𑀧𑀸𑀭𑀺𑀲𑀚𑁆𑀚𑀸 𑀘, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀘 𑀧𑀼𑀭𑁄𑀳𑀺𑀢𑁄.

𑁬𑁭𑁮.

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

𑀫𑀺𑀘𑁆𑀙𑀸𑀤𑀺𑀝𑁆𑀞𑀺 𑀘 𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑁄, 𑀓𑀤𑀭𑀺𑀬𑁄 𑀧𑀭𑀺𑀪𑀸𑀲𑀓𑁄.

𑁬𑁭𑁯.

‘‘‘𑀤𑀤𑀦𑁆𑀢𑀸𑀦𑀁 ¶ 𑀓𑀭𑁄𑀦𑁆𑀢𑀸𑀦𑀁, 𑀯𑀸𑀭𑀬𑀺𑀲𑁆𑀲𑀁 𑀩𑀳𑀼𑀚𑁆𑀚𑀦𑀁;

𑀅𑀜𑁆𑀜𑁂𑀲𑀁 𑀤𑀤𑀫𑀸𑀦𑀸𑀦𑀁, 𑀅𑀦𑁆𑀢𑀭𑀸𑀬𑀓𑀭𑁄 𑀅𑀳𑀁.

𑁬𑁮𑁦.

‘‘‘𑀯𑀺𑀧𑀸𑀓𑁄 𑀦𑀢𑁆𑀣𑀺 𑀤𑀸𑀦𑀲𑁆𑀲, 𑀲𑀁𑀬𑀫𑀲𑁆𑀲 𑀓𑀼𑀢𑁄 𑀨𑀮𑀁;

𑀦𑀢𑁆𑀣𑀺 𑀆𑀘𑀭𑀺𑀬𑁄 𑀦𑀸𑀫, 𑀅𑀤𑀦𑁆𑀢𑀁 𑀓𑁄 𑀤𑀫𑁂𑀲𑁆𑀲𑀢𑀺.

𑁬𑁮𑁧.

‘‘‘𑀲𑀫𑀢𑀼𑀮𑁆𑀬𑀸𑀦𑀺 ¶ 𑀪𑀽𑀢𑀸𑀦𑀺, 𑀓𑀼𑀢𑁄 [𑀓𑀼𑀮𑁂 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀚𑁂𑀝𑁆𑀞𑀸𑀧𑀘𑀸𑀬𑀺𑀓𑁄;

𑀦𑀢𑁆𑀣𑀺 𑀩𑀮𑀁 𑀯𑀻𑀭𑀺𑀬𑀁 𑀯𑀸, 𑀓𑀼𑀢𑁄 𑀉𑀝𑁆𑀞𑀸𑀦𑀧𑁄𑀭𑀺𑀲𑀁.

𑁬𑁮𑁨.

‘‘‘𑀦𑀢𑁆𑀣𑀺 𑀤𑀸𑀦𑀨𑀮𑀁 𑀦𑀸𑀫, 𑀦 𑀯𑀺𑀲𑁄𑀥𑁂𑀢𑀺 𑀯𑁂𑀭𑀺𑀦𑀁;

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

𑁬𑁮𑁩.

‘‘‘𑀦𑀢𑁆𑀣𑀺 ¶ 𑀫𑀸𑀢𑀸 𑀧𑀺𑀢𑀸 𑀪𑀸𑀢𑀸, 𑀮𑁄𑀓𑁄 𑀦𑀢𑁆𑀣𑀺 𑀇𑀢𑁄 𑀧𑀭𑀁;

𑀦𑀢𑁆𑀣𑀺 𑀤𑀺𑀦𑁆𑀦𑀁 𑀦𑀢𑁆𑀣𑀺 𑀳𑀼𑀢𑀁, 𑀲𑀼𑀦𑀺𑀳𑀺𑀢𑀁 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺.

𑁬𑁮𑁪.

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

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

𑁬𑁮𑁫.

‘‘‘𑀅𑀘𑁆𑀙𑁂𑀚𑁆𑀚𑀸𑀪𑁂𑀚𑁆𑀚𑁄 𑀳𑀺 [𑀪𑁂𑀚𑁆𑀚𑁄 (𑀲𑀻.), 𑀅𑀪𑁂𑀚𑁆𑀚𑁄 (𑀲𑁆𑀬𑀸.), 𑀪𑁂𑀚𑁆𑀚𑀸𑀲𑀺 (𑀓.)] 𑀚𑀻𑀯𑁄, 𑀅𑀝𑁆𑀞𑀁𑀲𑁄 𑀕𑀼𑀴𑀧𑀭𑀺𑀫𑀡𑁆𑀟𑀮𑁄;

𑀬𑁄𑀚𑀦𑀸𑀦𑀁 𑀲𑀢𑀁 𑀧𑀜𑁆𑀘, 𑀓𑁄 𑀚𑀻𑀯𑀁 𑀙𑁂𑀢𑁆𑀢𑀼𑀫𑀭𑀳𑀢𑀺.

𑁬𑁮𑁬.

‘‘‘𑀬𑀣𑀸 𑀲𑀼𑀢𑁆𑀢𑀕𑀼𑀴𑁂 𑀔𑀺𑀢𑁆𑀢𑁂, 𑀦𑀺𑀩𑁆𑀩𑁂𑀞𑁂𑀦𑁆𑀢𑀁 𑀧𑀮𑀸𑀬𑀢𑀺;

𑀏𑀯𑀫𑁂𑀯 𑀘 𑀲𑁄 𑀚𑀻𑀯𑁄, 𑀦𑀺𑀩𑁆𑀩𑁂𑀞𑁂𑀦𑁆𑀢𑁄 𑀧𑀮𑀸𑀬𑀢𑀺.

𑁬𑁮𑁭.

‘‘‘𑀬𑀣𑀸 𑀕𑀸𑀫𑀢𑁄 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫, 𑀅𑀜𑁆𑀜𑀁 𑀕𑀸𑀫𑀁 𑀧𑀯𑀺𑀲𑀢𑀺;

𑀏𑀯𑀫𑁂𑀯 𑀘 𑀲𑁄 𑀚𑀻𑀯𑁄, 𑀅𑀜𑁆𑀜𑀁 𑀩𑁄𑀦𑁆𑀤𑀺𑀁 𑀧𑀯𑀺𑀲𑀢𑀺.

𑁬𑁮𑁮.

‘‘‘𑀬𑀣𑀸 ¶ 𑀕𑁂𑀳𑀢𑁄 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫, 𑀅𑀜𑁆𑀜𑀁 𑀕𑁂𑀳𑀁 𑀧𑀯𑀺𑀲𑀢𑀺;

𑀏𑀯𑀫𑁂𑀯 𑀘 𑀲𑁄 𑀚𑀻𑀯𑁄, 𑀅𑀜𑁆𑀜𑀁 𑀩𑁄𑀦𑁆𑀤𑀺𑀁 𑀧𑀯𑀺𑀲𑀢𑀺.

𑁬𑁮𑁯.

‘‘‘𑀘𑀼𑀮𑁆𑀮𑀸𑀲𑀻𑀢𑀺 [𑀘𑀼𑀴𑀸𑀲𑀻𑀢𑀺 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀓.)] 𑀫𑀳𑀸𑀓𑀧𑁆𑀧𑀺𑀦𑁄 [𑀫𑀳𑀸𑀓𑀧𑁆𑀧𑀼𑀦𑁄 (𑀲𑀻.)], 𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 𑀳𑀺;

𑀬𑁂 𑀩𑀸𑀮𑀸 𑀬𑁂 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑀸, 𑀲𑀁𑀲𑀸𑀭𑀁 𑀔𑁂𑀧𑀬𑀺𑀢𑁆𑀯𑀸𑀦;

𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲𑀦𑁆𑀢𑀁 𑀓𑀭𑀺𑀲𑁆𑀲𑀭𑁂.

𑁬𑁯𑁦.

‘‘‘𑀫𑀺𑀢𑀸𑀦𑀺 𑀲𑀼𑀔𑀤𑀼𑀓𑁆𑀔𑀸𑀦𑀺, 𑀤𑁄𑀡𑁂𑀳𑀺 𑀧𑀺𑀝𑀓𑁂𑀳𑀺 𑀘;

𑀚𑀺𑀦𑁄 𑀲𑀩𑁆𑀩𑀁 𑀧𑀚𑀸𑀦𑀸𑀢𑀺’, 𑀲𑀫𑁆𑀫𑀽𑀴𑁆𑀳𑀸 𑀇𑀢𑀭𑀸 𑀧𑀚𑀸.

𑁬𑁯𑁧.

‘‘𑀏𑀯𑀁𑀤𑀺𑀝𑁆𑀞𑀺 𑀧𑀼𑀭𑁂 𑀆𑀲𑀺𑀁, 𑀲𑀫𑁆𑀫𑀽𑀴𑁆𑀳𑁄 𑀫𑁄𑀳𑀧𑀸𑀭𑀼𑀢𑁄;

𑀫𑀺𑀘𑁆𑀙𑀸𑀤𑀺𑀝𑁆𑀞𑀺 𑀘 𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑁄, 𑀓𑀤𑀭𑀺𑀬𑁄 𑀧𑀭𑀺𑀪𑀸𑀲𑀓𑁄.

𑁬𑁯𑁨.

‘‘𑀑𑀭𑀁 𑀫𑁂 𑀙𑀳𑀺 𑀫𑀸𑀲𑁂𑀳𑀺, 𑀓𑀸𑀮𑀗𑁆𑀓𑀺𑀭𑀺𑀬𑀸 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺;

𑀏𑀓𑀦𑁆𑀢𑀓𑀝𑀼𑀓𑀁 𑀖𑁄𑀭𑀁, 𑀦𑀺𑀭𑀬𑀁 𑀧𑀧𑀢𑀺𑀲𑁆𑀲𑀳𑀁.

𑁬𑁯𑁩.

[𑀧𑁂. 𑀯. 𑁭𑁦] ‘‘𑀘𑀢𑀼𑀓𑁆𑀓𑀡𑁆𑀡𑀁 𑀘𑀢𑀼𑀤𑁆𑀯𑀸𑀭𑀁, 𑀯𑀺𑀪𑀢𑁆𑀢𑀁 𑀪𑀸𑀕𑀲𑁄 𑀫𑀺𑀢𑀁;

𑀅𑀬𑁄𑀧𑀸𑀓𑀸𑀭𑀧𑀭𑀺𑀬𑀦𑁆𑀢𑀁, 𑀅𑀬𑀲𑀸 𑀧𑀝𑀺𑀓𑀼𑀚𑁆𑀚𑀺𑀢𑀁.

𑁬𑁯𑁪.

[𑀧𑁂. 𑀯. 𑁭𑁧] ‘‘𑀢𑀲𑁆𑀲 𑀅𑀬𑁄𑀫𑀬𑀸 𑀪𑀽𑀫𑀺, 𑀚𑀮𑀺𑀢𑀸 𑀢𑁂𑀚𑀲𑀸 𑀬𑀼𑀢𑀸;

𑀲𑀫𑀦𑁆𑀢𑀸 𑀬𑁄𑀚𑀦𑀲𑀢𑀁, 𑀨𑀭𑀺𑀢𑁆𑀯𑀸 𑀢𑀺𑀝𑁆𑀞𑀢𑀺 𑀲𑀩𑁆𑀩𑀤𑀸.

𑁬𑁯𑁫.

‘‘𑀯𑀲𑁆𑀲𑀸𑀦𑀺 ¶ 𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀖𑁄𑀲𑁄 𑀲𑀼𑀬𑁆𑀬𑀢𑀺 𑀢𑀸𑀯𑀤𑁂;

𑀮𑀓𑁆𑀔𑁄 𑀏𑀲𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀲𑀢𑀪𑀸𑀕𑀯𑀲𑁆𑀲𑀓𑁄𑀝𑀺𑀬𑁄.

𑁬𑁯𑁬.

‘‘𑀓𑁄𑀝𑀺𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺 ¶ , 𑀦𑀺𑀭𑀬𑁂 𑀧𑀘𑁆𑀘𑀭𑁂 𑀚𑀦𑀸;

𑀫𑀺𑀘𑁆𑀙𑀸𑀤𑀺𑀝𑁆𑀞𑀻 𑀘 𑀤𑀼𑀲𑁆𑀲𑀻𑀮𑀸, 𑀬𑁂 𑀘 𑀅𑀭𑀺𑀬𑀽𑀧𑀯𑀸𑀤𑀺𑀦𑁄.

𑁬𑁯𑁭.

‘‘𑀢𑀢𑁆𑀣𑀸𑀳𑀁 𑀤𑀻𑀖𑀫𑀤𑁆𑀥𑀸𑀦𑀁, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀯𑁂𑀤𑀺𑀲𑁆𑀲 𑀯𑁂𑀤𑀦𑀁;

𑀨𑀮𑀁 𑀧𑀸𑀧𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀲𑁆𑀲, 𑀢𑀲𑁆𑀫𑀸 𑀲𑁄𑀘𑀸𑀫𑀳𑀁 𑀪𑀼𑀲𑀁.

𑁬𑁯𑁮.

‘‘𑀢𑀁 ¶ ¶ 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀅𑀭𑀺𑀦𑁆𑀤𑀫 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦;

𑀥𑀻𑀢𑀸 𑀫𑀬𑁆𑀳𑀁 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀉𑀢𑁆𑀢𑀭𑀸 𑀪𑀤𑁆𑀤𑀫𑀢𑁆𑀣𑀼 𑀢𑁂.

𑁬𑁯𑁯.

‘‘𑀓𑀭𑁄𑀢𑀺 𑀪𑀤𑁆𑀤𑀓𑀁 𑀓𑀫𑁆𑀫𑀁, 𑀲𑀻𑀮𑁂𑀲𑀼𑀧𑁄𑀲𑀣𑁂 𑀭𑀢𑀸;

𑀲𑀜𑁆𑀜𑀢𑀸 𑀲𑀁𑀯𑀺𑀪𑀸𑀕𑀻 𑀘, 𑀯𑀤𑀜𑁆𑀜𑀽 𑀯𑀻𑀢𑀫𑀘𑁆𑀙𑀭𑀸.

𑁭𑁦𑁦.

‘‘𑀅𑀔𑀡𑁆𑀟𑀓𑀸𑀭𑀻 𑀲𑀺𑀓𑁆𑀔𑀸𑀬, 𑀲𑀼𑀡𑁆𑀳𑀸 𑀧𑀭𑀓𑀼𑀮𑁂𑀲𑀼 𑀘;

𑀉𑀧𑀸𑀲𑀺𑀓𑀸 𑀲𑀓𑁆𑀬𑀫𑀼𑀦𑀺𑀦𑁄, 𑀲𑀫𑁆𑀩𑀼𑀤𑁆𑀥𑀲𑁆𑀲 𑀲𑀺𑀭𑀻𑀫𑀢𑁄.

𑁭𑁦𑁧.

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

𑀑𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀘𑀓𑁆𑀔𑀼 𑀲𑀢𑀺𑀫𑀸, 𑀕𑀼𑀢𑁆𑀢𑀤𑁆𑀯𑀸𑀭𑁄 𑀲𑀼𑀲𑀁𑀯𑀼𑀢𑁄.

𑁭𑁦𑁨.

‘‘𑀲𑀧𑀤𑀸𑀦𑀁 𑀘𑀭𑀫𑀸𑀦𑁄, 𑀅𑀕𑀫𑀸 𑀢𑀁 𑀦𑀺𑀯𑁂𑀲𑀦𑀁;

‘𑀢𑀫𑀤𑁆𑀤𑀲 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀉𑀢𑁆𑀢𑀭𑀸 𑀪𑀤𑁆𑀤𑀫𑀢𑁆𑀣𑀼 𑀢𑁂’.

𑁭𑁦𑁩.

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

‘𑀧𑀺𑀢𑀸 𑀫𑁂 𑀓𑀸𑀮𑀗𑁆𑀓𑀢𑁄, 𑀪𑀦𑁆𑀢𑁂 𑀢𑀲𑁆𑀲𑁂𑀢𑀁 𑀉𑀧𑀓𑀧𑁆𑀧𑀢𑀼’.

𑁭𑁦𑁪.

‘‘𑀲𑀫𑀦𑀦𑁆𑀢𑀭𑀸𑀦𑀼𑀤𑁆𑀤𑀺𑀝𑁆𑀞𑁂, 𑀯𑀺𑀧𑀸𑀓𑁄 𑀉𑀤𑀧𑀚𑁆𑀚𑀣;

𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀺 𑀓𑀸𑀫𑀓𑀸𑀫𑀻𑀳𑀁, 𑀭𑀸𑀚𑀸 𑀯𑁂𑀲𑁆𑀲𑀯𑀡𑁄 𑀬𑀣𑀸.

𑁭𑁦𑁫.

‘‘𑀢𑀁 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀅𑀭𑀺𑀦𑁆𑀤𑀫 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦;

𑀲𑀤𑁂𑀯𑀓𑀲𑁆𑀲 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀩𑀼𑀤𑁆𑀥𑁄 𑀅𑀕𑁆𑀕𑁄 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀺;

𑀢𑀁 𑀩𑀼𑀤𑁆𑀥𑀁 𑀲𑀭𑀡𑀁 𑀕𑀘𑁆𑀙, 𑀲𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑁄 𑀅𑀭𑀺𑀦𑁆𑀤𑀫.

𑁭𑁦𑁬.

‘‘𑀅𑀝𑁆𑀞𑀗𑁆𑀕𑀺𑀓𑁂𑀦 𑀫𑀕𑁆𑀕𑁂𑀦, 𑀨𑀼𑀲𑀦𑁆𑀢𑀺 𑀅𑀫𑀢𑀁 𑀧𑀤𑀁;

𑀢𑀁 𑀥𑀫𑁆𑀫𑀁 𑀲𑀭𑀡𑀁 𑀕𑀘𑁆𑀙, 𑀲𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑁄 𑀅𑀭𑀺𑀦𑁆𑀤𑀫.

𑁭𑁦𑁭.

‘‘𑀘𑀢𑁆𑀢𑀸𑀭𑁄 ¶ 𑀘 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀸 [𑀫𑀕𑁆𑀕𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀸 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀘𑀢𑁆𑀢𑀸𑀭𑁄 𑀘 𑀨𑀮𑁂 𑀞𑀺𑀢𑀸;

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

𑀢𑀁 𑀲𑀗𑁆𑀖𑀁 𑀲𑀭𑀡𑀁 𑀕𑀘𑁆𑀙, 𑀲𑀧𑀼𑀢𑁆𑀢𑀤𑀸𑀭𑁄 𑀅𑀭𑀺𑀦𑁆𑀤𑀫.

𑁭𑁦𑁮.

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

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀫𑀸 𑀘 𑀫𑀼𑀲𑀸 𑀅𑀪𑀸𑀡𑀻, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀳𑀺 𑀢𑀼𑀝𑁆𑀞𑁄’’𑀢𑀺.

𑁭𑁦𑁯.

‘‘𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑁄𑀲𑀺 𑀫𑁂 𑀬𑀓𑁆𑀔, 𑀳𑀺𑀢𑀓𑀸𑀫𑁄𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀓𑀭𑁄𑀫𑀺 𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀘𑀦𑀁, 𑀢𑁆𑀯𑀁𑀲𑀺 𑀆𑀘𑀭𑀺𑀬𑁄 𑀫𑀫.

𑁭𑁧𑁦.

‘‘𑀉𑀧𑁂𑀫𑀺 𑀲𑀭𑀡𑀁 𑀩𑀼𑀤𑁆𑀥𑀁, 𑀥𑀫𑁆𑀫𑀜𑁆𑀘𑀸𑀧𑀺 𑀅𑀦𑀼𑀢𑁆𑀢𑀭𑀁;

𑀲𑀗𑁆𑀖𑀜𑁆𑀘 𑀦𑀭𑀤𑁂𑀯𑀲𑁆𑀲, 𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀲𑀭𑀡𑀁 𑀅𑀳𑀁.

𑁭𑁧𑁧.

‘‘𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀸 𑀯𑀺𑀭𑀫𑀸𑀫𑀺 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀮𑁄𑀓𑁂 𑀅𑀤𑀺𑀦𑁆𑀦𑀁 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑀬𑀸𑀫𑀺;

𑀅𑀫𑀚𑁆𑀚𑀧𑁄 𑀦𑁄 𑀘 𑀫𑀼𑀲𑀸 𑀪𑀡𑀸𑀫𑀺, 𑀲𑀓𑁂𑀦 𑀤𑀸𑀭𑁂𑀦 𑀘 𑀳𑁄𑀫𑀺 𑀢𑀼𑀝𑁆𑀞𑁄.

𑁭𑁧𑁨.

‘‘𑀑𑀨𑀼𑀡𑀸𑀫𑀺 ¶ [𑀑𑀧𑀼𑀡𑀸𑀫𑀺 (𑀲𑀻.), 𑀑𑀨𑀼𑀦𑀸𑀫𑀺 (𑀲𑁆𑀬𑀸. 𑀓.), 𑀑𑀧𑀼𑀦𑀸𑀫𑀺 (?)] 𑀫𑀳𑀸𑀯𑀸𑀢𑁂, 𑀦𑀤𑀺𑀬𑀸 𑀲𑀻𑀖𑀕𑀸𑀫𑀺𑀬𑀸;

𑀯𑀫𑀸𑀫𑀺 𑀧𑀸𑀧𑀺𑀓𑀁 𑀤𑀺𑀝𑁆𑀞𑀺𑀁, 𑀩𑀼𑀤𑁆𑀥𑀸𑀦𑀁 𑀲𑀸𑀲𑀦𑁂 𑀭𑀢𑁄’’.

𑁭𑁧𑁩.

𑀇𑀤𑀁 𑀯𑀢𑁆𑀯𑀸𑀦 𑀲𑁄𑀭𑀝𑁆𑀞𑁄, 𑀯𑀺𑀭𑀫𑀺𑀢𑁆𑀯𑀸 𑀧𑀸𑀧𑀤𑀲𑁆𑀲𑀦𑀸 [𑀧𑀸𑀧𑀤𑀲𑁆𑀲𑀦𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)];

𑀦𑀫𑁄 ¶ 𑀪𑀕𑀯𑀢𑁄 𑀓𑀢𑁆𑀯𑀸, 𑀧𑀸𑀫𑁄𑀓𑁆𑀔𑁄 𑀭𑀣𑀫𑀸𑀭𑀼𑀳𑀻𑀢𑀺.

𑀦𑀦𑁆𑀤𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀢𑀢𑀺𑀬𑀁.

𑁪. 𑀭𑁂𑀯𑀢𑀻𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁧𑁪.

[𑀯𑀺. 𑀯. 𑁮𑁬𑁩] ‘‘𑀉𑀝𑁆𑀞𑁂𑀳𑀺 𑀭𑁂𑀯𑀢𑁂 𑀲𑀼𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁂, 𑀅𑀧𑀸𑀭𑀼𑀢𑀤𑁆𑀯𑀸𑀭𑁂 𑀅𑀤𑀸𑀦𑀲𑀻𑀮𑁂;

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

𑁭𑁧𑁫.

𑀇𑀘𑁆𑀘𑁂𑀯 [𑀇𑀘𑁆𑀘𑁂𑀯𑀁 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀯𑀢𑁆𑀯𑀸𑀦 𑀬𑀫𑀲𑁆𑀲 𑀤𑀽𑀢𑀸, 𑀢𑁂 𑀤𑁆𑀯𑁂 𑀬𑀓𑁆𑀔𑀸 𑀮𑁄𑀳𑀺𑀢𑀓𑁆𑀔𑀸 𑀩𑁆𑀭𑀳𑀦𑁆𑀢𑀸;

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

𑁭𑁧𑁬.

‘‘𑀆𑀤𑀺𑀘𑁆𑀘𑀯𑀡𑁆𑀡𑀁 ¶ 𑀭𑀼𑀘𑀺𑀭𑀁 𑀧𑀪𑀲𑁆𑀲𑀭𑀁, 𑀩𑁆𑀬𑀫𑁆𑀳𑀁 𑀲𑀼𑀪𑀁 𑀓𑀜𑁆𑀘𑀦𑀚𑀸𑀮𑀙𑀦𑁆𑀦𑀁;

𑀓𑀲𑁆𑀲𑁂𑀢𑀫𑀸𑀓𑀺𑀡𑁆𑀡𑀚𑀦𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀼𑀭𑀺𑀬𑀲𑁆𑀲 𑀭𑀁𑀲𑀻𑀭𑀺𑀯 𑀚𑁄𑀢𑀫𑀸𑀦𑀁.

𑁭𑁧𑁭.

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

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

𑁭𑁧𑁮.

‘‘𑀩𑀸𑀭𑀸𑀡𑀲𑀺𑀬𑀁 𑀦𑀦𑁆𑀤𑀺𑀬𑁄 𑀦𑀸𑀫𑀸𑀲𑀺, 𑀉𑀧𑀸𑀲𑀓𑁄 𑀅𑀫𑀘𑁆𑀙𑀭𑀻 𑀤𑀸𑀦𑀧𑀢𑀺 𑀯𑀤𑀜𑁆𑀜𑀽;

𑀢𑀲𑁆𑀲𑁂𑀢𑀫𑀸𑀓𑀺𑀡𑁆𑀡𑀚𑀦𑀁 𑀯𑀺𑀫𑀸𑀦𑀁, 𑀲𑀼𑀭𑀺𑀬𑀲𑁆𑀲 𑀭𑀁𑀲𑀻𑀭𑀺𑀯 𑀚𑁄𑀢𑀫𑀸𑀦𑀁.

𑁭𑁧𑁯.

‘‘𑀦𑀸𑀭𑀻𑀕𑀡𑀸 𑀘𑀦𑁆𑀤𑀦𑀲𑀸𑀭𑀮𑀺𑀢𑁆𑀢𑀸, 𑀉𑀪𑀢𑁄 𑀯𑀺𑀫𑀸𑀦𑀁 𑀉𑀧𑀲𑁄𑀪𑀬𑀦𑁆𑀢𑀺;

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

𑁭𑁨𑁦.

‘‘𑀦𑀦𑁆𑀤𑀺𑀬𑀲𑁆𑀲𑀸𑀳𑀁 ¶ 𑀪𑀭𑀺𑀬𑀸, 𑀅𑀕𑀸𑀭𑀺𑀦𑀻 𑀲𑀩𑁆𑀩𑀓𑀼𑀮𑀲𑁆𑀲 𑀇𑀲𑁆𑀲𑀭𑀸;

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

𑁭𑁨𑁧.

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

𑀦 𑀳𑀺 𑀫𑀘𑁆𑀙𑀭𑀻 𑀭𑁄𑀲𑀓𑁄 𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁄, 𑀲𑀕𑁆𑀕𑀽𑀧𑀕𑀸𑀦𑀁 𑀮𑀪𑀢𑀺 𑀲𑀳𑀩𑁆𑀬𑀢’’𑀦𑁆𑀢𑀺.

𑁭𑁨𑁨.

‘‘𑀓𑀺𑀁 𑀦𑀼 𑀕𑀽𑀣𑀜𑁆𑀘 𑀫𑀼𑀢𑁆𑀢𑀜𑁆𑀘, 𑀅𑀲𑀼𑀘𑀻 𑀧𑀝𑀺𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀤𑀼𑀕𑁆𑀕𑀦𑁆𑀥𑀁 𑀓𑀺𑀫𑀺𑀤𑀁 𑀫𑀻𑀴𑁆𑀳𑀁, 𑀓𑀺𑀫𑁂𑀢𑀁 𑀉𑀧𑀯𑀸𑀬𑀢𑀻’’𑀢𑀺.

𑁭𑁨𑁩.

‘‘𑀏𑀲 𑀲𑀁𑀲𑀯𑀓𑁄 𑀦𑀸𑀫, 𑀕𑀫𑁆𑀪𑀻𑀭𑁄 𑀲𑀢𑀧𑁄𑀭𑀺𑀲𑁄;

𑀬𑀢𑁆𑀣 𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀢𑀼𑀯𑀁 𑀧𑀘𑁆𑀘𑀲𑀺 𑀭𑁂𑀯𑀢𑁂’’𑀢𑀺.

𑁭𑁨𑁪.

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

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

𑁭𑁨𑁫.

‘‘𑀲𑀫𑀡𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂 𑀘𑀸𑀧𑀺, 𑀅𑀜𑁆𑀜𑁂 𑀯𑀸𑀧𑀺 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑁂;

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

𑁭𑁨𑁬.

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

𑀢𑀢𑁆𑀣 𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀢𑀼𑀯𑀁 𑀧𑀘𑁆𑀘𑀲𑀺 𑀭𑁂𑀯𑀢𑁂.

𑁭𑁨𑁭.

‘‘𑀳𑀢𑁆𑀣𑁂𑀧𑀺 𑀙𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀅𑀣𑁄𑀧𑀺 𑀧𑀸𑀤𑁂, 𑀓𑀡𑁆𑀡𑁂𑀧𑀺 𑀙𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀅𑀣𑁄𑀧𑀺 𑀦𑀸𑀲𑀁;

𑀅𑀣𑁄𑀧𑀺 𑀓𑀸𑀓𑁄𑀴𑀕𑀡𑀸 𑀲𑀫𑁂𑀘𑁆𑀘, 𑀲𑀗𑁆𑀕𑀫𑁆𑀫 𑀔𑀸𑀤𑀦𑁆𑀢𑀺 𑀯𑀺𑀨𑀦𑁆𑀤𑀫𑀸𑀦’’𑀦𑁆𑀢𑀺.

𑁭𑁨𑁮.

‘‘𑀲𑀸𑀥𑀼 𑀔𑁄 𑀫𑀁 𑀧𑀝𑀺𑀦𑁂𑀣, 𑀓𑀸𑀳𑀸𑀫𑀺 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼𑀁;

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

𑀬𑀁 𑀓𑀢𑁆𑀯𑀸 𑀲𑀼𑀔𑀺𑀢𑀸 𑀳𑁄𑀦𑁆𑀢𑀺, 𑀦 𑀘 𑀧𑀘𑁆𑀙𑀸𑀦𑀼𑀢𑀧𑁆𑀧𑀭𑁂’’𑀢𑀺.

𑁭𑁨𑁯.

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

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

𑁭𑁩𑁦.

‘‘𑀓𑁄 𑀤𑁂𑀯𑀮𑁄𑀓𑀢𑁄 𑀫𑀦𑀼𑀲𑁆𑀲𑀮𑁄𑀓𑀁, 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀧𑀼𑀝𑁆𑀞𑁄 𑀫𑁂 𑀏𑀯𑀁 𑀯𑀤𑁂𑀬𑁆𑀬;

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

𑀦 𑀳𑀺 𑀫𑀘𑁆𑀙𑀭𑀻 𑀭𑁄𑀲𑀓𑁄 𑀧𑀸𑀧𑀥𑀫𑁆𑀫𑁄, 𑀲𑀕𑁆𑀕𑀽𑀧𑀕𑀸𑀦𑀁 𑀮𑀪𑀢𑀺 𑀲𑀳𑀩𑁆𑀬𑀢𑀁’.

𑁭𑁩𑁧.

‘‘𑀲𑀸𑀳𑀁 𑀦𑀽𑀦 𑀇𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀬𑁄𑀦𑀺𑀁 𑀮𑀤𑁆𑀥𑀸𑀦 𑀫𑀸𑀦𑀼𑀲𑀺𑀁;

𑀯𑀤𑀜𑁆𑀜𑀽 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀓𑀸𑀳𑀸𑀫𑀺 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼𑀁;

𑀤𑀸𑀦𑁂𑀦 𑀲𑀫𑀘𑀭𑀺𑀬𑀸𑀬, 𑀲𑀁𑀬𑀫𑁂𑀦 𑀤𑀫𑁂𑀦 𑀘.

𑁭𑁩𑁨.

‘‘𑀆𑀭𑀸𑀫𑀸𑀦𑀺 𑀘 𑀭𑁄𑀧𑀺𑀲𑁆𑀲𑀁, 𑀤𑀼𑀕𑁆𑀕𑁂 𑀲𑀗𑁆𑀓𑀫𑀦𑀸𑀦𑀺 𑀘;

𑀧𑀧𑀜𑁆𑀘 𑀉𑀤𑀧𑀸𑀦𑀜𑁆𑀘, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁂𑀦 𑀘𑁂𑀢𑀲𑀸.

𑁭𑁩𑁩.

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

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

𑁭𑁩𑁪.

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

𑀦 𑀘 𑀤𑀸𑀦𑁂 𑀧𑀫𑀚𑁆𑀚𑀺𑀲𑁆𑀲𑀁, 𑀲𑀸𑀫𑀁 𑀤𑀺𑀝𑁆𑀞𑀫𑀺𑀤𑀁 𑀫𑀬𑀸’’𑀢𑀺.

𑁭𑁩𑁫.

𑀇𑀘𑁆𑀘𑁂𑀯𑀁 ¶ 𑀯𑀺𑀧𑁆𑀧𑀮𑀧𑀦𑁆𑀢𑀺𑀁, 𑀨𑀦𑁆𑀤𑀫𑀸𑀦𑀁 𑀢𑀢𑁄 𑀢𑀢𑁄;

𑀔𑀺𑀧𑀺𑀁𑀲𑀼 𑀦𑀺𑀭𑀬𑁂 𑀖𑁄𑀭𑁂, 𑀉𑀤𑁆𑀥𑀁𑀧𑀸𑀤𑀁 𑀅𑀯𑀁𑀲𑀺𑀭𑀁.

𑁭𑁩𑁬.

‘‘𑀅𑀳𑀁 𑀧𑀼𑀭𑁂 𑀫𑀘𑁆𑀙𑀭𑀺𑀦𑀻 𑀅𑀳𑁄𑀲𑀺𑀁, 𑀧𑀭𑀺𑀪𑀸𑀲𑀺𑀓𑀸 𑀲𑀫𑀡𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁;

𑀯𑀺𑀢𑀣𑁂𑀦 𑀘 𑀲𑀸𑀫𑀺𑀓𑀁 𑀯𑀜𑁆𑀘𑀬𑀺𑀢𑁆𑀯𑀸, 𑀧𑀘𑁆𑀘𑀸𑀫𑀳𑀁 𑀦𑀺𑀭𑀬𑁂 𑀖𑁄𑀭𑀭𑀽𑀧𑁂’’𑀢𑀺.

𑀭𑁂𑀯𑀢𑀻𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

𑁫. 𑀉𑀘𑁆𑀙𑀼𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁩𑁭.

‘‘𑀇𑀤𑀁 ¶ 𑀫𑀫 𑀉𑀘𑁆𑀙𑀼𑀯𑀦𑀁 𑀫𑀳𑀦𑁆𑀢𑀁, 𑀦𑀺𑀩𑁆𑀩𑀢𑁆𑀢𑀢𑀺 𑀧𑀼𑀜𑁆𑀜𑀨𑀮𑀁 𑀅𑀦𑀧𑁆𑀧𑀓𑀁;

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

𑁭𑁩𑁮.

‘‘𑀳𑀜𑁆𑀜𑀸𑀫𑀺 [𑀯𑀺𑀳𑀜𑁆𑀜𑀸𑀫𑀺 (𑀓.)] 𑀔𑀚𑁆𑀚𑀸𑀫𑀺 𑀘 𑀯𑀸𑀬𑀫𑀸𑀫𑀺, 𑀧𑀭𑀺𑀲𑀓𑁆𑀓𑀸𑀫𑀺 𑀧𑀭𑀺𑀪𑀼𑀜𑁆𑀚𑀺𑀢𑀼𑀁 𑀓𑀺𑀜𑁆𑀘𑀺;

𑀲𑁆𑀯𑀸𑀳𑀁 𑀙𑀺𑀦𑁆𑀦𑀣𑀸𑀫𑁄 𑀓𑀧𑀡𑁄 𑀮𑀸𑀮𑀧𑀸𑀫𑀺, 𑀓𑀺𑀲𑁆𑀲 [𑀓𑀺𑀲𑁆𑀲𑀲𑁆𑀲 (𑀲𑀻.), 𑀓𑀺𑀲𑁆𑀲𑀲𑁆𑀲𑀼 (?)] 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄.

𑁭𑁩𑁯.

‘‘𑀯𑀺𑀖𑀸𑀢𑁄 𑀘𑀸𑀳𑀁 𑀧𑀭𑀺𑀧𑀢𑀸𑀫𑀺 𑀙𑀫𑀸𑀬𑀁, 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑀸𑀫𑀺 𑀯𑀸𑀭𑀺𑀘𑀭𑁄𑀯 𑀖𑀫𑁆𑀫𑁂;

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

𑁭𑁪𑁦.

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

𑀧𑀼𑀘𑁆𑀙𑀸𑀫𑀺 𑀢𑀁 𑀏𑀢𑀫𑀢𑁆𑀣𑀁 𑀪𑀤𑀦𑁆𑀢𑁂, 𑀓𑀣𑀁 𑀦𑀼 𑀉𑀘𑁆𑀙𑀼𑀧𑀭𑀺𑀪𑁄𑀕𑀁 𑀮𑀪𑁂𑀬𑁆𑀬’’𑀦𑁆𑀢𑀺.

𑁭𑁪𑁧.

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

𑀅𑀳𑀜𑁆𑀘 𑀢𑀁 𑀏𑀢𑀫𑀢𑁆𑀣𑀁 𑀯𑀤𑀸𑀫𑀺, 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀢𑁆𑀯𑀁 𑀏𑀢𑀫𑀢𑁆𑀣𑀁 𑀯𑀺𑀚𑀸𑀦.

𑁭𑁪𑁨.

‘‘𑀉𑀘𑁆𑀙𑀼𑀁 ¶ 𑀢𑀼𑀯𑀁 𑀔𑀸𑀤𑀫𑀸𑀦𑁄 𑀧𑀬𑀸𑀢𑁄, 𑀧𑀼𑀭𑀺𑀲𑁄 𑀘 𑀢𑁂 𑀧𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀅𑀦𑁆𑀯𑀕𑀘𑁆𑀙𑀺;

𑀲𑁄 𑀘 𑀢𑀁 𑀧𑀘𑁆𑀘𑀸𑀲𑀦𑁆𑀢𑁄 𑀓𑀣𑁂𑀲𑀺, 𑀢𑀲𑁆𑀲 𑀢𑀼𑀯𑀁 𑀦 𑀓𑀺𑀜𑁆𑀘𑀺 𑀆𑀮𑀧𑀺𑀢𑁆𑀣.

𑁭𑁪𑁩.

‘‘𑀲𑁄 𑀘 𑀢𑀁 𑀅𑀪𑀡𑀦𑁆𑀢𑀁 𑀅𑀬𑀸𑀘𑀺, ‘𑀤𑁂𑀳𑀬𑁆𑀬 𑀉𑀘𑁆𑀙𑀼’𑀦𑁆𑀢𑀺 𑀘 𑀢𑀁 𑀅𑀯𑁄𑀘;

𑀢𑀲𑁆𑀲 𑀢𑀼𑀯𑀁 𑀧𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀉𑀘𑁆𑀙𑀼𑀁 𑀅𑀤𑀸𑀲𑀺, 𑀢𑀲𑁆𑀲𑁂𑀢𑀁 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀅𑀬𑀁 𑀯𑀺𑀧𑀸𑀓𑁄.

𑁭𑁪𑁪.

‘‘𑀇𑀗𑁆𑀖 𑀢𑁆𑀯𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀧𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀕𑀡𑁆𑀳𑁂𑀬𑁆𑀬𑀸𑀲𑀺 [𑀇𑀗𑁆𑀖 𑀢𑁆𑀯𑀁 𑀧𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀕𑀡𑁆𑀳 𑀉𑀘𑁆𑀙𑀼𑀁 (𑀲𑀻.)], 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦 𑀢𑀁 𑀔𑀸𑀤𑀲𑁆𑀲𑀼 𑀬𑀸𑀯𑀤𑀢𑁆𑀣𑀁;

𑀢𑁂𑀦𑁂𑀯 𑀢𑁆𑀯𑀁 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀲𑀺, 𑀳𑀝𑁆𑀞𑁄 𑀘𑀼𑀤𑀕𑁆𑀕𑁄 𑀘 𑀧𑀫𑁄𑀤𑀺𑀢𑁄 𑀘𑀸’’𑀢𑀺.

𑁭𑁪𑁫.

𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 ¶ 𑀲𑁄 𑀧𑀺𑀝𑁆𑀞𑀺𑀢𑁄 𑀅𑀕𑁆𑀕𑀳𑁂𑀲𑀺, 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦 𑀢𑀁 𑀔𑀸𑀤𑀺 𑀬𑀸𑀯𑀤𑀢𑁆𑀣𑀁;

𑀢𑁂𑀦𑁂𑀯 𑀲𑁄 𑀅𑀢𑁆𑀢𑀫𑀦𑁄 𑀅𑀳𑁄𑀲𑀺, 𑀳𑀝𑁆𑀞𑁄 𑀘𑀼𑀤𑀕𑁆𑀕𑁄 𑀘 𑀧𑀫𑁄𑀤𑀺𑀢𑁄 𑀘𑀸𑀢𑀺.

𑀉𑀘𑁆𑀙𑀼𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀧𑀜𑁆𑀘𑀫𑀁.

𑁬. 𑀓𑀼𑀫𑀸𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁪𑁬.

‘‘𑀲𑀸𑀯𑀢𑁆𑀣𑀺 ¶ ¶ 𑀦𑀸𑀫 𑀦𑀕𑀭𑀁, 𑀳𑀺𑀫𑀯𑀦𑁆𑀢𑀲𑁆𑀲 𑀧𑀲𑁆𑀲𑀢𑁄;

𑀢𑀢𑁆𑀣 𑀆𑀲𑀼𑀁 𑀤𑁆𑀯𑁂 𑀓𑀼𑀫𑀸𑀭𑀸, 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑀸𑀢𑀺 𑀫𑁂 𑀲𑀼𑀢𑀁.

𑁭𑁪𑁭.

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

𑀧𑀘𑁆𑀘𑀼𑀧𑁆𑀧𑀦𑁆𑀦𑀲𑀼𑀔𑁂 𑀕𑀺𑀤𑁆𑀥𑀸, 𑀦 𑀢𑁂 𑀧𑀲𑁆𑀲𑀺𑀁𑀲𑀼𑀦𑀸𑀕𑀢𑀁.

𑁭𑁪𑁮.

‘‘𑀢𑁂 𑀘𑀼𑀢𑀸 𑀘 𑀫𑀦𑀼𑀲𑁆𑀲𑀢𑁆𑀢𑀸, 𑀧𑀭𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸;

𑀢𑁂𑀥 𑀖𑁄𑀲𑁂𑀦𑁆𑀢𑁆𑀬𑀤𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀸, 𑀧𑀼𑀩𑁆𑀩𑁂 𑀤𑀼𑀓𑁆𑀓𑀝𑀫𑀢𑁆𑀢𑀦𑁄.

𑁭𑁪𑁯.

‘‘‘𑀩𑀳𑀽𑀲𑀼 𑀯𑀢 [𑀩𑀳𑀼𑀲𑁆𑀲𑀼𑀢𑁂𑀲𑀼 (𑀲𑀻. 𑀓.)] 𑀲𑀦𑁆𑀢𑁂𑀲𑀼, 𑀤𑁂𑀬𑁆𑀬𑀥𑀫𑁆𑀫𑁂 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑁂;

𑀦𑀸𑀲𑀓𑁆𑀔𑀺𑀫𑁆𑀳𑀸 𑀘 𑀅𑀢𑁆𑀢𑀸𑀦𑀁, 𑀧𑀭𑀺𑀢𑁆𑀢𑀁 𑀓𑀸𑀢𑀼𑀁 𑀲𑀼𑀔𑀸𑀯𑀳𑀁.

𑁭𑁫𑁦.

‘‘‘𑀓𑀺𑀁 𑀢𑀢𑁄 𑀧𑀸𑀧𑀓𑀁 𑀅𑀲𑁆𑀲, 𑀬𑀁 𑀦𑁄 𑀭𑀸𑀚𑀓𑀼𑀮𑀸 𑀘𑀼𑀢𑀸;

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

𑁭𑁫𑁧.

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

𑀪𑀫𑀦𑁆𑀢𑀺 [𑀘𑀭𑀦𑁆𑀢𑀺 (𑀲𑀻. 𑀧𑀻.), 𑀫𑀭𑀦𑁆𑀢𑀺 (𑀲𑁆𑀬𑀸.)] 𑀔𑀼𑀧𑁆𑀧𑀺𑀧𑀸𑀲𑀸𑀬, 𑀫𑀦𑀼𑀲𑁆𑀲𑀸 𑀉𑀦𑁆𑀦𑀢𑁄𑀦𑀢𑀸.

𑁭𑁫𑁨.

‘‘𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀇𑀲𑁆𑀲𑀭𑀫𑀤𑀲𑀫𑁆𑀪𑀯𑀁;

𑀧𑀳𑀸𑀬 ¶ 𑀇𑀲𑁆𑀲𑀭𑀫𑀤𑀁, 𑀪𑀯𑁂 𑀲𑀕𑁆𑀕𑀕𑀢𑁄 𑀦𑀭𑁄;

𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀲𑀧𑁆𑀧𑀜𑁆𑀜𑁄, 𑀲𑀕𑁆𑀕𑀁 𑀲𑁄 𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀻’’𑀢𑀺.

𑀓𑀼𑀫𑀸𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀙𑀝𑁆𑀞𑀁.

𑁭. 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁫𑁩.

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

𑀭𑀽𑀧𑁂 𑀲𑀤𑁆𑀤𑁂 𑀭𑀲𑁂 𑀕𑀦𑁆𑀥𑁂, 𑀨𑁄𑀝𑁆𑀞𑀩𑁆𑀩𑁂 𑀘 𑀫𑀦𑁄𑀭𑀫𑁂.

𑁭𑁫𑁪.

𑀦𑀘𑁆𑀘𑀁 𑀕𑀻𑀢𑀁 𑀭𑀢𑀺𑀁 𑀔𑀺𑀟𑁆𑀟𑀁, 𑀅𑀦𑀼𑀪𑀼𑀢𑁆𑀯𑀸 𑀅𑀦𑀧𑁆𑀧𑀓𑀁;

𑀉𑀬𑁆𑀬𑀸𑀦𑁂 𑀧𑀭𑀺𑀘𑀭𑀺𑀢𑁆𑀯𑀸, 𑀧𑀯𑀺𑀲𑀦𑁆𑀢𑁄 𑀕𑀺𑀭𑀺𑀩𑁆𑀩𑀚𑀁.

𑁭𑁫𑁫.

𑀇𑀲𑀺𑀁 𑀲𑀼𑀦𑁂𑀢𑁆𑀢 [𑀲𑀼𑀦𑀺𑀢 (𑀓.)] 𑀫𑀤𑁆𑀤𑀓𑁆𑀔𑀺, 𑀅𑀢𑁆𑀢𑀤𑀦𑁆𑀢𑀁 𑀲𑀫𑀸𑀳𑀺𑀢𑀁;

𑀅𑀧𑁆𑀧𑀺𑀘𑁆𑀙𑀁 𑀳𑀺𑀭𑀺𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁, 𑀉𑀜𑁆𑀙𑁂 𑀧𑀢𑁆𑀢𑀕𑀢𑁂 𑀭𑀢𑀁.

𑁭𑁫𑁬.

𑀳𑀢𑁆𑀣𑀺𑀓𑁆𑀔𑀦𑁆𑀥𑀢𑁄 𑀑𑀭𑀼𑀬𑁆𑀳, 𑀮𑀤𑁆𑀥𑀸 𑀪𑀦𑁆𑀢𑁂𑀢𑀺 𑀘𑀸𑀩𑁆𑀭𑀯𑀺;

𑀢𑀲𑁆𑀲 𑀧𑀢𑁆𑀢𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀉𑀘𑁆𑀘𑀁 𑀧𑀕𑁆𑀕𑀬𑁆𑀳 𑀔𑀢𑁆𑀢𑀺𑀬𑁄.

𑁭𑁫𑁭.

𑀣𑀡𑁆𑀟𑀺𑀮𑁂 ¶ 𑀧𑀢𑁆𑀢𑀁 𑀪𑀺𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸, 𑀳𑀲𑀫𑀸𑀦𑁄 𑀅𑀧𑀓𑁆𑀓𑀫𑀺;

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

𑁭𑁫𑁮.

𑀢𑀲𑁆𑀲 ¶ 𑀓𑀫𑁆𑀫𑀲𑁆𑀲 𑀨𑀭𑀼𑀲𑀲𑁆𑀲, 𑀯𑀺𑀧𑀸𑀓𑁄 𑀓𑀝𑀼𑀓𑁄 𑀅𑀳𑀼;

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

𑁭𑁫𑁯.

𑀙𑀴𑁂𑀯 𑀘𑀢𑀼𑀭𑀸𑀲𑀻𑀢𑀺, 𑀯𑀲𑁆𑀲𑀸𑀦𑀺 𑀦𑀯𑀼𑀢𑀸𑀦𑀺 𑀘;

𑀪𑀼𑀲𑀁 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀺𑀢𑁆𑀣𑁄, 𑀦𑀺𑀭𑀬𑁂 𑀓𑀢𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑁄.

𑁭𑁬𑁦.

𑀉𑀢𑁆𑀢𑀸𑀦𑁄𑀧𑀺 𑀘 𑀧𑀘𑁆𑀘𑀺𑀢𑁆𑀣, 𑀦𑀺𑀓𑀼𑀚𑁆𑀚𑁄 𑀯𑀸𑀫𑀤𑀓𑁆𑀔𑀺𑀡𑁄;

𑀉𑀤𑁆𑀥𑀁𑀧𑀸𑀤𑁄 𑀞𑀺𑀢𑁄 𑀘𑁂𑀯, 𑀘𑀺𑀭𑀁 𑀩𑀸𑀮𑁄 𑀅𑀧𑀘𑁆𑀘𑀣.

𑁭𑁬𑁧.

𑀩𑀳𑀽𑀦𑀺 ¶ 𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀽𑀕𑀸𑀦𑀺 𑀦𑀳𑀼𑀢𑀸𑀦𑀺 𑀘;

𑀪𑀼𑀲𑀁 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀺𑀢𑁆𑀣𑁄, 𑀦𑀺𑀭𑀬𑁂 𑀓𑀢𑀓𑀺𑀩𑁆𑀩𑀺𑀲𑁄.

𑁭𑁬𑁨.

𑀏𑀢𑀸𑀤𑀺𑀲𑀁 𑀔𑁄 𑀓𑀝𑀼𑀓𑀁, 𑀅𑀧𑁆𑀧𑀤𑀼𑀝𑁆𑀞𑀧𑁆𑀧𑀤𑁄𑀲𑀺𑀦𑀁;

𑀧𑀘𑁆𑀘𑀦𑁆𑀢𑀺 𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀦𑁆𑀢𑀸, 𑀇𑀲𑀺𑀫𑀸𑀲𑀚𑁆𑀚 𑀲𑀼𑀩𑁆𑀩𑀢𑀁.

𑁭𑁬𑁩.

𑀲𑁄 𑀢𑀢𑁆𑀣 𑀩𑀳𑀼𑀯𑀲𑁆𑀲𑀸𑀦𑀺, 𑀯𑁂𑀤𑀬𑀺𑀢𑁆𑀯𑀸 𑀩𑀳𑀼𑀁 𑀤𑀼𑀔𑀁;

𑀔𑀼𑀧𑁆𑀧𑀺𑀧𑀸𑀲𑀳𑀢𑁄 𑀦𑀸𑀫 [𑀔𑀼𑀧𑁆𑀧𑀺𑀧𑀸𑀲𑀸𑀳𑀢𑁄 𑀦𑀸𑀫 (𑀲𑀻. 𑀧𑀻)], 𑀧𑁂𑀢𑁄 𑀆𑀲𑀺 𑀢𑀢𑁄 𑀘𑀼𑀢𑁄.

𑁭𑁬𑁪.

𑀏𑀢𑀫𑀸𑀤𑀻𑀦𑀯𑀁 𑀜𑀢𑁆𑀯𑀸 [𑀤𑀺𑀲𑁆𑀯𑀸 (𑀲𑀻.)], 𑀇𑀲𑁆𑀲𑀭𑀫𑀤𑀲𑀫𑁆𑀪𑀯𑀁;

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

𑁭𑁬𑁫.

𑀤𑀺𑀝𑁆𑀞𑁂𑀯 𑀥𑀫𑁆𑀫𑁂 𑀧𑀸𑀲𑀁𑀲𑁄, 𑀬𑁄 𑀩𑀼𑀤𑁆𑀥𑁂𑀲𑀼 𑀲𑀕𑀸𑀭𑀯𑁄;

𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀲𑀧𑁆𑀧𑀜𑁆𑀜𑁄, 𑀲𑀕𑁆𑀕𑀁 𑀲𑁄 𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀻𑀢𑀺.

𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀲𑀢𑁆𑀢𑀫𑀁.

𑁮. 𑀕𑀽𑀣𑀔𑀸𑀤𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁬𑁬.

‘‘𑀕𑀽𑀣𑀓𑀽𑀧𑀢𑁄 ¶ 𑀉𑀕𑁆𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀓𑁄 𑀦𑀼 𑀤𑀻𑀦𑁄 𑀧𑀢𑀺𑀝𑁆𑀞𑀲𑀺 [𑀤𑀻𑀦𑁄 𑀳𑀺 𑀢𑀺𑀝𑁆𑀞𑀲𑀺 (𑀲𑀻.)];

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

𑁭𑁬𑁭.

‘‘𑀅𑀳𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀧𑁂𑀢𑁄𑀫𑁆𑀳𑀺, 𑀤𑀼𑀕𑁆𑀕𑀢𑁄 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑁄;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑁄’’.

𑁭𑁬𑁮.

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

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

𑁭𑁬𑁯.

‘‘𑀅𑀳𑀼 ¶ 𑀆𑀯𑀸𑀲𑀺𑀓𑁄 𑀫𑀬𑁆𑀳𑀁, 𑀇𑀲𑁆𑀲𑀼𑀓𑀻 𑀓𑀼𑀮𑀫𑀘𑁆𑀙𑀭𑀻;

𑀅𑀚𑁆𑀛𑁄𑀲𑀺𑀢𑁄 𑀫𑀬𑁆𑀳𑀁 𑀖𑀭𑁂, 𑀓𑀤𑀭𑀺𑀬𑁄 𑀧𑀭𑀺𑀪𑀸𑀲𑀓𑁄.

𑁭𑁭𑁦.

‘‘𑀢𑀲𑁆𑀲𑀸𑀳𑀁 ¶ ¶ 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀪𑀺𑀓𑁆𑀔𑀯𑁄 𑀧𑀭𑀺𑀪𑀸𑀲𑀺𑀲𑀁;

𑀢𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑁄’’𑀢𑀺.

𑁭𑁭𑁧.

‘‘𑀅𑀫𑀺𑀢𑁆𑀢𑁄 𑀫𑀺𑀢𑁆𑀢𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑁄 𑀢𑁂 𑀆𑀲𑀺 𑀓𑀼𑀮𑀽𑀧𑀓𑁄;

𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀤𑀼𑀧𑁆𑀧𑀜𑁆𑀜𑁄, 𑀓𑀺𑀁 𑀦𑀼 𑀧𑁂𑀘𑁆𑀘 𑀕𑀢𑀺𑀁 𑀕𑀢𑁄’’𑀢𑀺.

𑁭𑁭𑁨.

‘‘𑀢𑀲𑁆𑀲𑁂𑀯𑀸𑀳𑀁 𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀲𑁆𑀲, 𑀲𑀻𑀲𑁂 𑀢𑀺𑀝𑁆𑀞𑀸𑀫𑀺 𑀫𑀢𑁆𑀣𑀓𑁂;

𑀲𑁄 𑀘 𑀧𑀭𑀯𑀺𑀲𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀫𑀫𑁂𑀯 𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑁄.

𑁭𑁭𑁩.

‘‘𑀬𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀳𑀤𑀦𑁆𑀢𑀜𑁆𑀜𑁂, 𑀏𑀢𑀁 𑀫𑁂 𑀳𑁄𑀢𑀺 𑀪𑁄𑀚𑀦𑀁;

𑀅𑀳𑀜𑁆𑀘 𑀔𑁄 𑀬𑀁 𑀳𑀤𑀸𑀫𑀺, 𑀏𑀢𑀁 𑀲𑁄 𑀉𑀧𑀚𑀻𑀯𑀢𑀻’’𑀢𑀺.

𑀕𑀽𑀣𑀔𑀸𑀤𑀓𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀅𑀝𑁆𑀞𑀫𑀁.

𑁯. 𑀕𑀽𑀣𑀔𑀸𑀤𑀓𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼

𑁭𑁭𑁪.

‘‘𑀕𑀽𑀣𑀓𑀽𑀧𑀢𑁄 ¶ 𑀉𑀕𑁆𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀓𑀸 𑀦𑀼 𑀤𑀻𑀦𑀸 𑀧𑀢𑀺𑀝𑁆𑀞𑀲𑀺;

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

𑁭𑁭𑁫.

‘‘𑀅𑀳𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀧𑁂𑀢𑀻𑀫𑁆𑀳𑀺, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁭𑁭𑁬.

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

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

𑁭𑁭𑁭.

‘‘𑀅𑀳𑀼 𑀆𑀯𑀸𑀲𑀺𑀓𑁄 𑀫𑀬𑁆𑀳𑀁, 𑀇𑀲𑁆𑀲𑀼𑀓𑀻 𑀓𑀼𑀮𑀫𑀘𑁆𑀙𑀭𑀻;

𑀅𑀚𑁆𑀛𑁄𑀲𑀺𑀢𑁄 𑀫𑀬𑁆𑀳𑀁 𑀖𑀭𑁂, 𑀓𑀤𑀭𑀺𑀬𑁄 𑀧𑀭𑀺𑀪𑀸𑀲𑀓𑁄.

𑁭𑁭𑁮.

‘‘𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀪𑀺𑀓𑁆𑀔𑀯𑁄 𑀧𑀭𑀺𑀪𑀸𑀲𑀺𑀲𑀁;

𑀢𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁭𑁭𑁯.

‘‘𑀅𑀫𑀺𑀢𑁆𑀢𑁄 ¶ 𑀫𑀺𑀢𑁆𑀢𑀯𑀡𑁆𑀡𑁂𑀦, 𑀬𑁄 𑀢𑁂 𑀆𑀲𑀺 𑀓𑀼𑀮𑀽𑀧𑀓𑁄;

𑀓𑀸𑀬𑀲𑁆𑀲 𑀪𑁂𑀤𑀸 𑀤𑀼𑀧𑁆𑀧𑀜𑁆𑀜𑁄, 𑀓𑀺𑀁 𑀦𑀼 𑀧𑁂𑀘𑁆𑀘 𑀕𑀢𑀺𑀁 𑀕𑀢𑁄’’𑀢𑀺.

𑁭𑁮𑁦.

‘‘𑀢𑀲𑁆𑀲𑁂𑀯𑀸𑀳𑀁 𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀲𑁆𑀲, 𑀲𑀻𑀲𑁂 𑀢𑀺𑀝𑁆𑀞𑀸𑀫𑀺 𑀫𑀢𑁆𑀣𑀓𑁂;

𑀲𑁄 𑀘 𑀧𑀭𑀯𑀺𑀲𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀫𑀫𑁂𑀯 𑀧𑀭𑀺𑀘𑀸𑀭𑀓𑁄.

𑁭𑁮𑁧.

‘‘𑀬𑀁 ¶ 𑀪𑀤𑀦𑁆𑀢𑁂 𑀳𑀤𑀦𑁆𑀢𑀜𑁆𑀜𑁂, 𑀏𑀢𑀁 𑀫𑁂 𑀳𑁄𑀢𑀺 𑀪𑁄𑀚𑀦𑀁;

𑀅𑀳𑀜𑁆𑀘 𑀔𑁄 𑀬𑀁 𑀳𑀤𑀸𑀫𑀺, 𑀏𑀢𑀁 𑀲𑁄 𑀉𑀧𑀚𑀻𑀯𑀢𑀻’’𑀢𑀺.

𑀕𑀽𑀣𑀔𑀸𑀤𑀓𑀧𑁂𑀢𑀺𑀯𑀢𑁆𑀣𑀼 𑀦𑀯𑀫𑀁.

𑁧𑁦. 𑀕𑀡𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁮𑁨.

‘‘𑀦𑀕𑁆𑀕𑀸 ¶ 𑀤𑀼𑀩𑁆𑀩𑀡𑁆𑀡𑀭𑀽𑀧𑀸𑀢𑁆𑀣, 𑀓𑀺𑀲𑀸 𑀥𑀫𑀦𑀺𑀲𑀦𑁆𑀣𑀢𑀸;

𑀉𑀧𑁆𑀨𑀸𑀲𑀼𑀮𑀺𑀓𑀸 [𑀉𑀧𑁆𑀧𑀸𑀲𑀼𑀴𑀺𑀓𑀸 (𑀓.)] 𑀓𑀺𑀲𑀺𑀓𑀸, 𑀓𑁂 𑀦𑀼 𑀢𑀼𑀫𑁆𑀳𑁂𑀢𑁆𑀣 𑀫𑀸𑀭𑀺𑀲𑀸’’𑀢𑀺.

𑁭𑁮𑁩.

‘‘𑀫𑀬𑀁 𑀪𑀤𑀦𑁆𑀢𑁂 𑀧𑁂𑀢𑀸𑀫𑁆𑀳𑀸, 𑀤𑀼𑀕𑁆𑀕𑀢𑀸 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑀸;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁭𑁮𑁪.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑀸’’𑀢𑀺.

𑁭𑁮𑁫.

‘‘𑀅𑀦𑀸𑀯𑀝𑁂𑀲𑀼 𑀢𑀺𑀢𑁆𑀣𑁂𑀲𑀼, 𑀯𑀺𑀘𑀺𑀦𑀺𑀫𑁆𑀳𑀤𑁆𑀥𑀫𑀸𑀲𑀓𑀁;

𑀲𑀦𑁆𑀢𑁂𑀲𑀼 𑀤𑁂𑀬𑁆𑀬𑀥𑀫𑁆𑀫𑁂𑀲𑀼, 𑀤𑀻𑀧𑀁 𑀦𑀸𑀓𑀫𑁆𑀳 𑀅𑀢𑁆𑀢𑀦𑁄.

𑁭𑁮𑁬.

‘‘𑀦𑀤𑀺𑀁 𑀉𑀧𑁂𑀫 𑀢𑀲𑀺𑀢𑀸, 𑀭𑀺𑀢𑁆𑀢𑀓𑀸 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑀢𑀺;

𑀙𑀸𑀬𑀁 𑀉𑀧𑁂𑀫 𑀉𑀡𑁆𑀳𑁂𑀲𑀼, 𑀆𑀢𑀧𑁄 𑀧𑀭𑀺𑀯𑀢𑁆𑀢𑀢𑀺.

𑁭𑁮𑁭.

‘‘𑀅𑀕𑁆𑀕𑀺𑀯𑀡𑁆𑀡𑁄 𑀘 𑀦𑁄 𑀯𑀸𑀢𑁄, 𑀟𑀳𑀦𑁆𑀢𑁄 𑀉𑀧𑀯𑀸𑀬𑀢𑀺;

𑀏𑀢𑀜𑁆𑀘 𑀪𑀦𑁆𑀢𑁂 𑀅𑀭𑀳𑀸𑀫, 𑀅𑀜𑁆𑀜𑀜𑁆𑀘 𑀧𑀸𑀧𑀓𑀁 𑀢𑀢𑁄.

𑁭𑁮𑁮.

‘‘𑀅𑀧𑀺 𑀬𑁄𑀚𑀦𑀸𑀦𑀺 [𑀅𑀥𑀺𑀬𑁄𑀚𑀦𑀸𑀦𑀺 (𑀲𑀻. 𑀓.)] 𑀕𑀘𑁆𑀙𑀸𑀫, 𑀙𑀸𑀢𑀸 𑀆𑀳𑀸𑀭𑀕𑁂𑀥𑀺𑀦𑁄;

𑀅𑀮𑀤𑁆𑀥𑀸𑀯 ¶ 𑀦𑀺𑀯𑀢𑁆𑀢𑀸𑀫, 𑀅𑀳𑁄 𑀦𑁄 𑀅𑀧𑁆𑀧𑀧𑀼𑀜𑁆𑀜𑀢𑀸.

𑁭𑁮𑁯.

‘‘𑀙𑀸𑀢𑀸 𑀧𑀫𑀼𑀘𑁆𑀙𑀺𑀢𑀸 𑀪𑀦𑁆𑀢𑀸, 𑀪𑀽𑀫𑀺𑀬𑀁 𑀧𑀝𑀺𑀲𑀼𑀫𑁆𑀪𑀺𑀢𑀸;

𑀉𑀢𑁆𑀢𑀸𑀦𑀸 𑀧𑀝𑀺𑀓𑀺𑀭𑀸𑀫, 𑀅𑀯𑀓𑀼𑀚𑁆𑀚𑀸 𑀧𑀢𑀸𑀫𑀲𑁂.

𑁭𑁯𑁦.

‘‘𑀢𑁂 𑀘 𑀢𑀢𑁆𑀣𑁂𑀯 𑀧𑀢𑀺𑀢𑀸 [𑀢𑀢𑁆𑀣 𑀧𑀧𑀳𑀺𑀢𑀸 (𑀓.)], 𑀪𑀽𑀫𑀺𑀬𑀁 𑀧𑀝𑀺𑀲𑀼𑀫𑁆𑀪𑀺𑀢𑀸;

𑀉𑀭𑀁 𑀲𑀻𑀲𑀜𑁆𑀘 𑀖𑀝𑁆𑀝𑁂𑀫, 𑀅𑀳𑁄 𑀦𑁄 𑀅𑀧𑁆𑀧𑀧𑀼𑀜𑁆𑀜𑀢𑀸.

𑁭𑁯𑁧.

‘‘𑀏𑀢𑀜𑁆𑀘 𑀪𑀦𑁆𑀢𑁂 𑀅𑀭𑀳𑀸𑀫, 𑀅𑀜𑁆𑀜𑀜𑁆𑀘 𑀧𑀸𑀧𑀓𑀁 𑀢𑀢𑁄;

𑀲𑀦𑁆𑀢𑁂𑀲𑀼 𑀤𑁂𑀬𑁆𑀬𑀥𑀫𑁆𑀫𑁂𑀲𑀼, 𑀤𑀻𑀧𑀁 𑀦𑀸𑀓𑀫𑁆𑀳 𑀅𑀢𑁆𑀢𑀦𑁄.

𑁭𑁯𑁨.

‘‘𑀢𑁂 𑀳𑀺 𑀦𑀽𑀦 𑀇𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀬𑁄𑀦𑀺𑀁 𑀮𑀤𑁆𑀥𑀸𑀦 𑀫𑀸𑀦𑀼𑀲𑀺𑀁;

𑀯𑀤𑀜𑁆𑀜𑀽 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀸, 𑀓𑀸𑀳𑀸𑀫 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼’’𑀦𑁆𑀢𑀺.

𑀕𑀡𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀤𑀲𑀫𑀁.

𑁧𑁧. 𑀧𑀸𑀝𑀮𑀺𑀧𑀼𑀢𑁆𑀢𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁯𑁩.

‘‘𑀤𑀺𑀝𑁆𑀞𑀸 ¶ ¶ ¶ 𑀢𑀬𑀸 𑀦𑀺𑀭𑀬𑀸 𑀢𑀺𑀭𑀘𑁆𑀙𑀸𑀦𑀬𑁄𑀦𑀺,

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

𑀦𑁂𑀲𑁆𑀲𑀸𑀫𑀺 𑀢𑀁 𑀧𑀸𑀝𑀮𑀺𑀧𑀼𑀢𑁆𑀢𑀫𑀓𑁆𑀔𑀢𑀁; 𑀢𑀢𑁆𑀣 𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀓𑀼𑀲𑀮𑀁 𑀓𑀭𑁄𑀳𑀺 𑀓𑀫𑁆𑀫𑀁’’.

𑁭𑁯𑁪.

‘‘𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑁄𑀲𑀺 𑀫𑁂 𑀬𑀓𑁆𑀔, 𑀳𑀺𑀢𑀓𑀸𑀫𑁄𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀓𑀭𑁄𑀫𑀺 𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀘𑀦𑀁, 𑀢𑁆𑀯𑀁𑀲𑀺 𑀆𑀘𑀭𑀺𑀬𑁄 𑀫𑀫.

𑁭𑁯𑁫.

‘‘𑀤𑀺𑀝𑁆𑀞𑀸 𑀫𑀬𑀸 𑀦𑀺𑀭𑀬𑀸 𑀢𑀺𑀭𑀘𑁆𑀙𑀸𑀦𑀬𑁄𑀦𑀺, 𑀧𑁂𑀢𑀸 𑀅𑀲𑀼𑀭𑀸 𑀅𑀣𑀯𑀸𑀧𑀺 𑀫𑀸𑀦𑀼𑀲𑀸 𑀤𑁂𑀯𑀸;

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

𑀧𑀸𑀝𑀮𑀺𑀧𑀼𑀢𑁆𑀢𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀏𑀓𑀸𑀤𑀲𑀫𑀁.

𑁧𑁨. 𑀅𑀫𑁆𑀩𑀯𑀦𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁭𑁯𑁬.

‘‘𑀅𑀬𑀜𑁆𑀘 𑀢𑁂 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀻 𑀲𑀼𑀭𑀫𑁆𑀫𑀸, 𑀲𑀫𑀸 𑀲𑀼𑀢𑀺𑀢𑁆𑀣𑀸 𑀘 𑀫𑀳𑁄𑀤𑀓𑀸 𑀘;

𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀸 𑀪𑀫𑀭𑀕𑀡𑀸𑀦𑀼𑀓𑀺𑀡𑁆𑀡𑀸, 𑀓𑀣𑀁 𑀢𑀬𑀸 𑀮𑀤𑁆𑀥𑀸 𑀅𑀬𑀁 𑀫𑀦𑀼𑀜𑁆𑀜𑀸.

𑁭𑁯𑁭.

‘‘𑀇𑀤𑀜𑁆𑀘 𑀢𑁂 𑀅𑀫𑁆𑀩𑀯𑀦𑀁 𑀲𑀼𑀭𑀫𑁆𑀫𑀁, 𑀲𑀩𑁆𑀩𑁄𑀢𑀼𑀓𑀁 𑀥𑀸𑀭𑀬𑀢𑁂 [𑀥𑀸𑀭𑀬𑀢𑀺 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀨𑀮𑀸𑀦𑀺;

𑀲𑀼𑀧𑀼𑀧𑁆𑀨𑀺𑀢𑀁 𑀪𑀫𑀭𑀕𑀡𑀸𑀦𑀼𑀓𑀺𑀡𑁆𑀡𑀁, 𑀓𑀣𑀁 𑀢𑀬𑀸 𑀮𑀤𑁆𑀥𑀫𑀺𑀤𑀁 𑀯𑀺𑀫𑀸𑀦𑀁’’.

𑁭𑁯𑁮.

‘‘𑀅𑀫𑁆𑀩𑀧𑀓𑁆𑀓𑀁 𑀤𑀓𑀁 [𑀅𑀫𑁆𑀩𑀧𑀓𑁆𑀓𑁄𑀤𑀓𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.), 𑀅𑀫𑁆𑀩𑀧𑀓𑁆𑀓𑀽𑀤𑀓𑀁 (𑀓.)] 𑀬𑀸𑀕𑀼, 𑀲𑀻𑀢𑀘𑁆𑀙𑀸𑀬𑀸 𑀫𑀦𑁄𑀭𑀫𑀸;

𑀥𑀻𑀢𑀸𑀬 𑀤𑀺𑀦𑁆𑀦𑀤𑀸𑀦𑁂𑀦, 𑀢𑁂𑀦 𑀫𑁂 𑀇𑀥 𑀮𑀩𑁆𑀪𑀢𑀺’’.

𑁭𑁯𑁯.

‘‘𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓𑀁 ¶ 𑀓𑀫𑁆𑀫𑀁 𑀏𑀯𑀁 [𑀲𑀦𑁆𑀤𑀺𑀝𑁆𑀞𑀺𑀓𑀁 𑀏𑀯 (𑀲𑁆𑀬𑀸.)] 𑀧𑀲𑁆𑀲𑀣, 𑀤𑀸𑀦𑀲𑁆𑀲 𑀤𑀫𑀲𑁆𑀲 𑀲𑀁𑀬𑀫𑀲𑁆𑀲 𑀯𑀺𑀧𑀸𑀓𑀁;

𑀤𑀸𑀲𑀻 𑀅𑀳𑀁 𑀅𑀬𑁆𑀬𑀓𑀼𑀮𑁂𑀲𑀼 𑀳𑀼𑀢𑁆𑀯𑀸, 𑀲𑀼𑀡𑀺𑀲𑀸 𑀳𑁄𑀫𑀺 𑀅𑀕𑀸𑀭𑀲𑁆𑀲 𑀇𑀲𑁆𑀲𑀭𑀸’’𑀢𑀺.

𑀅𑀫𑁆𑀩𑀯𑀦𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀤𑁆𑀯𑀸𑀤𑀲𑀫𑀁.

𑁧𑁩. 𑀅𑀓𑁆𑀔𑀭𑀼𑀓𑁆𑀔𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁮𑁦𑁦.

‘‘𑀬𑀁 ¶ ¶ 𑀤𑀤𑀸𑀢𑀺 𑀦 𑀢𑀁 𑀳𑁄𑀢𑀺, 𑀤𑁂𑀣𑁂𑀯 𑀤𑀸𑀦𑀁 𑀤𑀢𑁆𑀯𑀸 𑀉𑀪𑀬𑀁 𑀢𑀭𑀢𑀺;

𑀉𑀪𑀬𑀁 𑀢𑁂𑀦 𑀤𑀸𑀦𑁂𑀦 [𑀢𑁂𑀦 (𑀓.)] 𑀕𑀘𑁆𑀙𑀢𑀺, 𑀚𑀸𑀕𑀭𑀣 𑀫𑀸𑀧𑀫𑀚𑁆𑀚𑀣𑀸’’𑀢𑀺.

𑀅𑀓𑁆𑀔𑀭𑀼𑀓𑁆𑀔𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀢𑁂𑀭𑀲𑀫𑀁.

𑁧𑁪. 𑀪𑁄𑀕𑀲𑀁𑀳𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁮𑁦𑁧.

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

𑀢𑁂 𑀅𑀜𑁆𑀜𑁂 𑀧𑀭𑀺𑀪𑀼𑀜𑁆𑀚𑀦𑁆𑀢𑀺, 𑀫𑀬𑀁 𑀤𑀼𑀓𑁆𑀔𑀲𑁆𑀲 𑀪𑀸𑀕𑀺𑀦𑀻’’𑀢𑀺.

𑀪𑁄𑀕𑀲𑀁𑀳𑀭𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀘𑀼𑀤𑁆𑀤𑀲𑀫𑀁.

𑁧𑁫. 𑀲𑁂𑀝𑁆𑀞𑀺𑀧𑀼𑀢𑁆𑀢𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁮𑁦𑁨.

[𑀚𑀸. 𑁧.𑁪.𑁫𑁪 𑀚𑀸𑀢𑀓𑁂𑀧𑀺] ‘‘𑀲𑀝𑁆𑀞𑀺𑀯𑀲𑁆𑀲𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀸𑀦𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

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

𑁮𑁦𑁩.

[𑀚𑀸. 𑁧.𑁪.𑁫𑁫 𑀚𑀸𑀢𑀓𑁂𑀧𑀺] ‘‘𑀦𑀢𑁆𑀣𑀺 𑀅𑀦𑁆𑀢𑁄 𑀓𑀼𑀢𑁄 𑀅𑀦𑁆𑀢𑁄, 𑀦 𑀅𑀦𑁆𑀢𑁄 𑀧𑀝𑀺𑀤𑀺𑀲𑁆𑀲𑀢𑀺;

𑀢𑀣𑀸 𑀳𑀺 𑀧𑀓𑀢𑀁 𑀧𑀸𑀧𑀁, 𑀢𑀼𑀬𑁆𑀳𑀁 𑀫𑀬𑁆𑀳𑀜𑁆𑀘 𑀫𑀸𑀭𑀺𑀲𑀸 [𑀫𑀫 𑀢𑀼𑀬𑁆𑀳𑀜𑁆𑀘 𑀫𑀸𑀭𑀺𑀲 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑁮𑁦𑁪.

[𑀚𑀸. 𑁧.𑁪.𑁫𑁩 𑀚𑀸𑀢𑀓𑁂𑀧𑀺] ‘‘𑀤𑀼𑀚𑁆𑀚𑀻𑀯𑀺𑀢𑀫𑀚𑀻𑀯𑀫𑁆𑀳 ¶ , 𑀬𑁂 𑀲𑀦𑁆𑀢𑁂 𑀦 𑀤𑀤𑀫𑁆𑀳𑀲𑁂;

𑀲𑀦𑁆𑀢𑁂𑀲𑀼 𑀤𑁂𑀬𑁆𑀬𑀥𑀫𑁆𑀫𑁂𑀲𑀼, 𑀤𑀻𑀧𑀁 𑀦𑀸𑀓𑀫𑁆𑀳 𑀅𑀢𑁆𑀢𑀦𑁄.

𑁮𑁦𑁫.

[𑀚𑀸. 𑁧.𑁪.𑁫𑁬 𑀚𑀸𑀢𑀓𑁂𑀧𑀺] ‘‘𑀲𑁄𑀳𑀁 𑀦𑀽𑀦 𑀇𑀢𑁄 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀬𑁄𑀦𑀺𑀁 𑀮𑀤𑁆𑀥𑀸𑀦 𑀫𑀸𑀦𑀼𑀲𑀺𑀁;

𑀯𑀤𑀜𑁆𑀜𑀽 𑀲𑀻𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀓𑀸𑀳𑀸𑀫𑀺 𑀓𑀼𑀲𑀮𑀁 𑀩𑀳𑀼’’𑀦𑁆𑀢𑀺.

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

𑁧𑁬. 𑀲𑀝𑁆𑀞𑀺𑀓𑀽𑀝𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼

𑁮𑁦𑁬.

‘‘𑀓𑀺𑀁 ¶ 𑀦𑀼 𑀉𑀫𑁆𑀫𑀢𑁆𑀢𑀭𑀽𑀧𑁄𑀯, 𑀫𑀺𑀕𑁄 𑀪𑀦𑁆𑀢𑁄𑀯 𑀥𑀸𑀯𑀲𑀺;

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

𑁮𑁦𑁭.

‘‘𑀅𑀳𑀁 ¶ 𑀪𑀤𑀦𑁆𑀢𑁂 𑀧𑁂𑀢𑁄𑀫𑁆𑀳𑀺, 𑀤𑀼𑀕𑁆𑀕𑀢𑁄 𑀬𑀫𑀮𑁄𑀓𑀺𑀓𑁄;

𑀧𑀸𑀧𑀓𑀫𑁆𑀫𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑁂𑀢𑀮𑁄𑀓𑀁 𑀇𑀢𑁄 𑀕𑀢𑁄.

𑁮𑁦𑁮.

‘‘𑀲𑀝𑁆𑀞𑀺 𑀓𑀽𑀝𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀸𑀦𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

𑀲𑀻𑀲𑁂 𑀫𑀬𑁆𑀳𑀁 𑀦𑀺𑀧𑀢𑀦𑁆𑀢𑀺, 𑀢𑁂 𑀪𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀘 𑀫𑀢𑁆𑀣𑀓’’𑀦𑁆𑀢𑀺.

𑁮𑁦𑁯.

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

𑀓𑀺𑀲𑁆𑀲 𑀓𑀫𑁆𑀫𑀯𑀺𑀧𑀸𑀓𑁂𑀦, 𑀇𑀤𑀁 𑀤𑀼𑀓𑁆𑀔𑀁 𑀦𑀺𑀕𑀘𑁆𑀙𑀲𑀺.

𑁮𑁧𑁦.

‘‘𑀲𑀝𑁆𑀞𑀺 ¶ 𑀓𑀽𑀝𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀸𑀦𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

𑀲𑀻𑀲𑁂 𑀢𑀼𑀬𑁆𑀳𑀁 𑀦𑀺𑀧𑀢𑀦𑁆𑀢𑀺, 𑀢𑁂 𑀪𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀘 𑀫𑀢𑁆𑀣𑀓’’𑀦𑁆𑀢𑀺.

𑁮𑁧𑁧.

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

𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀁 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑀲𑁆𑀫𑀺𑀁, 𑀛𑀸𑀬𑀦𑁆𑀢𑀁 𑀅𑀓𑀼𑀢𑁄𑀪𑀬𑀁.

𑁮𑁧𑁨.

‘‘𑀲𑀸𑀮𑀺𑀢𑁆𑀢𑀓𑀧𑁆𑀧𑀳𑀸𑀭𑁂𑀦, 𑀪𑀺𑀦𑁆𑀤𑀺𑀲𑁆𑀲𑀁 𑀢𑀲𑁆𑀲 𑀫𑀢𑁆𑀣𑀓𑀁;

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

𑁮𑁧𑁩.

‘‘𑀲𑀝𑁆𑀞𑀺 𑀓𑀽𑀝𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀸𑀦𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

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

𑁮𑁧𑁪.

‘‘𑀥𑀫𑁆𑀫𑁂𑀦 𑀢𑁂 𑀓𑀸𑀧𑀼𑀭𑀺𑀲, 𑀲𑀝𑁆𑀞𑀺𑀓𑀽𑀝𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀧𑀭𑀺𑀧𑀼𑀡𑁆𑀡𑀸𑀦𑀺 𑀲𑀩𑁆𑀩𑀲𑁄;

𑀲𑀻𑀲𑁂 𑀢𑀼𑀬𑁆𑀳𑀁 𑀦𑀺𑀧𑀢𑀦𑁆𑀢𑀺, 𑀢𑁂 𑀪𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑀺 𑀘 𑀫𑀢𑁆𑀣𑀓’’𑀦𑁆𑀢𑀺.

𑀲𑀝𑁆𑀞𑀺𑀓𑀽𑀝𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼 𑀲𑁄𑀴𑀲𑀫𑀁.

𑀫𑀳𑀸𑀯𑀕𑁆𑀕𑁄 𑀘𑀢𑀼𑀢𑁆𑀣𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

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

𑀅𑀫𑁆𑀩𑀲𑀓𑁆𑀓𑀭𑁄 ¶ ¶ 𑀲𑁂𑀭𑀻𑀲𑀓𑁄, 𑀧𑀺𑀗𑁆𑀕𑀮𑁄 𑀭𑁂𑀯𑀢𑀺 𑀉𑀘𑁆𑀙𑀼;

𑀤𑁆𑀯𑁂 𑀓𑀼𑀫𑀸𑀭𑀸 𑀤𑀼𑀯𑁂 𑀕𑀽𑀣𑀸, 𑀕𑀡𑀧𑀸𑀝𑀮𑀺𑀅𑀫𑁆𑀩𑀯𑀦𑀁.

𑀅𑀓𑁆𑀔𑀭𑀼𑀓𑁆𑀔𑀪𑁄𑀕𑀲𑀁𑀳𑀭𑀸, 𑀲𑁂𑀝𑁆𑀞𑀺𑀧𑀼𑀢𑁆𑀢𑀲𑀝𑁆𑀞𑀺𑀓𑀽𑀝𑀸;

𑀇𑀢𑀺 𑀲𑁄𑀴𑀲𑀯𑀢𑁆𑀣𑀽𑀦𑀺, 𑀯𑀕𑁆𑀕𑁄 𑀢𑁂𑀦 𑀧𑀯𑀼𑀘𑁆𑀘𑀢𑀺.

𑀅𑀣 𑀯𑀕𑁆𑀕𑀼𑀤𑁆𑀤𑀸𑀦𑀁 𑁋

𑀉𑀭𑀕𑁄 𑀉𑀧𑀭𑀺𑀯𑀕𑁆𑀕𑁄, 𑀘𑀽𑀴𑀫𑀳𑀸𑀢𑀺 𑀘𑀢𑀼𑀥𑀸;

𑀯𑀢𑁆𑀣𑀽𑀦𑀺 𑀏𑀓𑀧𑀜𑁆𑀜𑀸𑀲𑀁, 𑀘𑀢𑀼𑀥𑀸 𑀪𑀸𑀡𑀯𑀸𑀭𑀢𑁄.

𑀧𑁂𑀢𑀯𑀢𑁆𑀣𑀼𑀧𑀸𑀴𑀺 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑀸.