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

THA Vol 2
MMR Vol 2
VRI Vol 2
PTS Vol 0

Misc. Paragraph

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

𑀘𑀭𑀺𑀬𑀸𑀧𑀺𑀝𑀓𑀧𑀸𑀴𑀺

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

‘‘𑀓𑀧𑁆𑀧𑁂 ¶ ¶ ¶ ¶ 𑀘 𑀲𑀢𑀲𑀳𑀲𑁆𑀲𑁂, 𑀘𑀢𑀼𑀭𑁄 𑀘 𑀅𑀲𑀗𑁆𑀔𑀺𑀬𑁂;

𑀏𑀢𑁆𑀣𑀦𑁆𑀢𑀭𑁂 𑀬𑀁 𑀘𑀭𑀺𑀢𑀁, 𑀲𑀩𑁆𑀩𑀁 𑀢𑀁 𑀩𑁄𑀥𑀺𑀧𑀸𑀘𑀦𑀁.

‘‘𑀅𑀢𑀻𑀢𑀓𑀧𑁆𑀧𑁂 𑀘𑀭𑀺𑀢𑀁, 𑀞𑀧𑀬𑀺𑀢𑁆𑀯𑀸 𑀪𑀯𑀸𑀪𑀯𑁂;

𑀇𑀫𑀫𑁆𑀳𑀺 𑀓𑀧𑁆𑀧𑁂 𑀘𑀭𑀺𑀢𑀁, 𑀧𑀯𑀓𑁆𑀔𑀺𑀲𑁆𑀲𑀁 𑀲𑀼𑀡𑁄𑀳𑀺 𑀫𑁂.

‘‘𑀬𑀤𑀸 𑀅𑀳𑀁 𑀩𑁆𑀭𑀳𑀸𑀭𑀜𑁆𑀜𑁂, 𑀲𑀼𑀜𑁆𑀜𑁂 𑀯𑀺𑀧𑀺𑀦𑀓𑀸𑀦𑀦𑁂;

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

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

𑀥𑀸𑀭𑁂𑀦𑁆𑀢𑁄 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀯𑀡𑁆𑀡𑀁, 𑀪𑀺𑀓𑁆𑀔𑀸𑀬 𑀫𑀁 𑀉𑀧𑀸𑀕𑀫𑀺.

‘‘𑀧𑀯𑀦𑀸 𑀆𑀪𑀢𑀁 𑀧𑀡𑁆𑀡𑀁, 𑀅𑀢𑁂𑀮𑀜𑁆𑀘 𑀅𑀮𑁄𑀡𑀺𑀓𑀁;

𑀫𑀫 𑀤𑁆𑀯𑀸𑀭𑁂 𑀞𑀺𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀲𑀓𑀝𑀸𑀳𑁂𑀦 𑀆𑀓𑀺𑀭𑀺𑀁.

‘‘𑀢𑀲𑁆𑀲 𑀤𑀢𑁆𑀯𑀸𑀦𑀳𑀁 𑀧𑀡𑁆𑀡𑀁, 𑀦𑀺𑀓𑁆𑀓𑀼𑀚𑁆𑀚𑀺𑀢𑁆𑀯𑀸𑀦 𑀪𑀸𑀚𑀦𑀁;

𑀧𑀼𑀦𑁂𑀲𑀦𑀁 𑀚𑀳𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑀸𑀯𑀺𑀲𑀺𑀁 𑀧𑀡𑁆𑀡𑀲𑀸𑀮𑀓𑀁.

‘‘𑀤𑀼𑀢𑀺𑀬𑀫𑁆𑀧𑀺 ¶ 𑀢𑀢𑀺𑀬𑀫𑁆𑀧𑀺, 𑀉𑀧𑀕𑀜𑁆𑀙𑀺 𑀫𑀫𑀦𑁆𑀢𑀺𑀓𑀁;

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

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

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

‘‘𑀬𑀤𑀺 𑀫𑀸𑀲𑀫𑁆𑀧𑀺 𑀤𑁆𑀯𑁂𑀫𑀸𑀲𑀁, 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑀁 𑀯𑀭𑀁 𑀮𑀪𑁂;

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

‘‘𑀦 𑀢𑀲𑁆𑀲 𑀤𑀸𑀦𑀁 𑀤𑀤𑀫𑀸𑀦𑁄, 𑀬𑀲𑀁 𑀮𑀸𑀪𑀜𑁆𑀘 𑀧𑀢𑁆𑀣𑀬𑀺𑀁;

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀢𑁆𑀣𑀬𑀸𑀦𑁄, 𑀢𑀸𑀦𑀺 𑀓𑀫𑁆𑀫𑀸𑀦𑀺 𑀆𑀘𑀭𑀺’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀲𑀗𑁆𑀔𑀲𑀯𑁆𑀳𑀬𑁄;

𑀫𑀳𑀸𑀲𑀫𑀼𑀤𑁆𑀤𑀁 𑀢𑀭𑀺𑀢𑀼𑀓𑀸𑀫𑁄, 𑀉𑀧𑀕𑀘𑁆𑀙𑀸𑀫𑀺 𑀧𑀝𑁆𑀝𑀦𑀁.

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

𑀓𑀦𑁆𑀢𑀸𑀭𑀤𑁆𑀥𑀸𑀦𑀁 𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀁 [𑀓𑀦𑁆𑀢𑀸𑀭𑀤𑁆𑀥𑀸𑀦𑀧𑀝𑀺𑀧𑀦𑁆𑀦𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸.)], 𑀢𑀢𑁆𑀢𑀸𑀬 𑀓𑀞𑀺𑀦𑀪𑀽𑀫𑀺𑀬𑀸.

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

‘𑀇𑀤𑀁 𑀔𑁂𑀢𑁆𑀢𑀁 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑀁, 𑀧𑀼𑀜𑁆𑀜𑀓𑀸𑀫𑀲𑁆𑀲 𑀚𑀦𑁆𑀢𑀼𑀦𑁄.

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

𑀢𑀢𑁆𑀣 𑀩𑀻𑀚𑀁 𑀦 𑀭𑁄𑀧𑁂𑀢𑀺, 𑀦 𑀲𑁄 𑀥𑀜𑁆𑀜𑁂𑀦 𑀅𑀢𑁆𑀣𑀺𑀓𑁄.

‘‘‘𑀏𑀯𑀫𑁂𑀯𑀸𑀳𑀁 ¶ ¶ 𑀧𑀼𑀜𑁆𑀜𑀓𑀸𑀫𑁄, 𑀤𑀺𑀲𑁆𑀯𑀸 𑀔𑁂𑀢𑁆𑀢𑀯𑀭𑀼𑀢𑁆𑀢𑀫𑀁;

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

‘‘‘𑀬𑀣𑀸 𑀅𑀫𑀘𑁆𑀘𑁄 𑀫𑀼𑀤𑁆𑀤𑀺𑀓𑀸𑀫𑁄, 𑀭𑀜𑁆𑀜𑁄 𑀅𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑁂 𑀚𑀦𑁂;

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

‘‘‘𑀏𑀯𑀫𑁂𑀯𑀸𑀳𑀁 𑀧𑀼𑀜𑁆𑀜𑀓𑀸𑀫𑁄, 𑀯𑀺𑀧𑀼𑀮𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀤𑀓𑁆𑀔𑀺𑀡𑀁;

𑀬𑀤𑀺 𑀢𑀲𑁆𑀲 𑀤𑀸𑀦𑀁 𑀦 𑀤𑀤𑀸𑀫𑀺, 𑀧𑀭𑀺𑀳𑀸𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀧𑀼𑀜𑁆𑀜𑀢𑁄’.

‘‘𑀏𑀯𑀸𑀳𑀁 𑀘𑀺𑀦𑁆𑀢𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀑𑀭𑁄𑀳𑀺𑀢𑁆𑀯𑀸 𑀉𑀧𑀸𑀳𑀦𑀸;

𑀢𑀲𑁆𑀲 𑀧𑀸𑀤𑀸𑀦𑀺 𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸, 𑀅𑀤𑀸𑀲𑀺𑀁 𑀙𑀢𑁆𑀢𑀼𑀧𑀸𑀳𑀦𑀁.

‘‘𑀢𑁂𑀦𑁂𑀯𑀸𑀳𑀁 ¶ 𑀲𑀢𑀕𑀼𑀡𑀢𑁄, 𑀲𑀼𑀔𑀼𑀫𑀸𑀮𑁄 𑀲𑀼𑀔𑁂𑀥𑀺𑀢𑁄;

𑀅𑀧𑀺 𑀘 𑀤𑀸𑀦𑀁 𑀧𑀭𑀺𑀧𑀽𑀭𑁂𑀦𑁆𑀢𑁄, 𑀏𑀯𑀁 𑀢𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀳’’𑀦𑁆𑀢𑀺.

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

𑀭𑀸𑀚𑀸 𑀥𑀦𑀜𑁆𑀘𑀬𑁄 𑀦𑀸𑀫, 𑀓𑀼𑀲𑀮𑁂 𑀤𑀲𑀳𑀼𑀧𑀸𑀕𑀢𑁄.

‘‘𑀓𑀮𑀺𑀗𑁆𑀕𑀭𑀝𑁆𑀞𑀯𑀺𑀲𑀬𑀸, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀉𑀧𑀕𑀜𑁆𑀙𑀼 𑀫𑀁;

𑀆𑀬𑀸𑀘𑀼𑀁 𑀫𑀁 𑀳𑀢𑁆𑀣𑀺𑀦𑀸𑀕𑀁, 𑀥𑀜𑁆𑀜𑀁 𑀫𑀗𑁆𑀕𑀮𑀲𑀫𑁆𑀫𑀢𑀁.

‘‘‘𑀅𑀯𑀼𑀝𑁆𑀞𑀺𑀓𑁄 𑀚𑀦𑀧𑀤𑁄, 𑀤𑀼𑀩𑁆𑀪𑀺𑀓𑁆𑀔𑁄 𑀙𑀸𑀢𑀓𑁄 𑀫𑀳𑀸;

𑀤𑀤𑀸𑀳𑀺 𑀧𑀯𑀭𑀁 𑀦𑀸𑀕𑀁, 𑀦𑀻𑀮𑀁 𑀅𑀜𑁆𑀚𑀦𑀲𑀯𑁆𑀳𑀬𑀁.

‘‘‘𑀦 ¶ ¶ 𑀫𑁂 𑀬𑀸𑀘𑀓𑀫𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁂, 𑀧𑀝𑀺𑀓𑁆𑀔𑁂𑀧𑁄 𑀅𑀦𑀼𑀘𑁆𑀙𑀯𑁄;

𑀫𑀸 𑀫𑁂 𑀪𑀺𑀚𑁆𑀚𑀺 𑀲𑀫𑀸𑀤𑀸𑀦𑀁, 𑀤𑀲𑁆𑀲𑀸𑀫𑀺 𑀯𑀺𑀧𑀼𑀮𑀁 𑀕𑀚𑀁’.

‘‘𑀦𑀸𑀕𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀲𑁄𑀡𑁆𑀟𑀸𑀬, 𑀪𑀺𑀗𑁆𑀕𑀸𑀭𑁂 [𑀪𑀺𑀗𑁆𑀓𑀸𑀭𑁂 (𑀲𑀻.)] 𑀭𑀢𑀦𑀸𑀫𑀬𑁂;

𑀚𑀮𑀁 𑀳𑀢𑁆𑀣𑁂 𑀆𑀓𑀺𑀭𑀺𑀢𑁆𑀯𑀸, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀅𑀤𑀁 𑀕𑀚𑀁.

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

‘𑀓𑀺𑀁 𑀦𑀼 𑀢𑀼𑀬𑁆𑀳𑀁 𑀯𑀭𑀁 𑀦𑀸𑀕𑀁, 𑀬𑀸𑀘𑀓𑀸𑀦𑀁 𑀧𑀤𑀲𑁆𑀲𑀲𑀺.

‘‘‘𑀥𑀜𑁆𑀜𑀁 ¶ 𑀫𑀗𑁆𑀕𑀮𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑀁, 𑀲𑀗𑁆𑀕𑀸𑀫𑀯𑀺𑀚𑀬𑀼𑀢𑁆𑀢𑀫𑀁;

𑀢𑀲𑁆𑀫𑀺𑀁 𑀦𑀸𑀕𑁂 𑀧𑀤𑀺𑀦𑁆𑀦𑀫𑁆𑀳𑀺, 𑀓𑀺𑀁 𑀢𑁂 𑀭𑀚𑁆𑀚𑀁 𑀓𑀭𑀺𑀲𑁆𑀲𑀢𑀺.

‘‘‘𑀭𑀚𑁆𑀚𑀫𑁆𑀧𑀺 𑀫𑁂 𑀤𑀤𑁂 𑀲𑀩𑁆𑀩𑀁, 𑀲𑀭𑀻𑀭𑀁 𑀤𑀚𑁆𑀚𑀫𑀢𑁆𑀢𑀦𑁄;

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀺𑀬𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀦𑀸𑀕𑀁 𑀅𑀤𑀸𑀲𑀳’’’𑀦𑁆𑀢𑀺.

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

𑀫𑀳𑀸𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑁄 𑀦𑀸𑀫, 𑀘𑀓𑁆𑀓𑀯𑀢𑁆𑀢𑀻 𑀫𑀳𑀩𑁆𑀩𑀮𑁄.

‘‘𑀢𑀢𑁆𑀣𑀸𑀳𑀁 ¶ 𑀤𑀺𑀯𑀲𑁂 𑀢𑀺𑀓𑁆𑀔𑀢𑁆𑀢𑀼𑀁, 𑀖𑁄𑀲𑀸𑀧𑁂𑀫𑀺 𑀢𑀳𑀺𑀁 𑀢𑀳𑀺𑀁;

‘𑀓𑁄 𑀓𑀺𑀁 𑀇𑀘𑁆𑀙𑀢𑀺 𑀧𑀢𑁆𑀣𑁂𑀢𑀺, 𑀓𑀲𑁆𑀲 𑀓𑀺𑀁 𑀤𑀻𑀬𑀢𑀽 𑀥𑀦𑀁.

‘‘‘𑀓𑁄 𑀙𑀸𑀢𑀓𑁄 𑀓𑁄 𑀢𑀲𑀺𑀢𑁄, 𑀓𑁄 𑀫𑀸𑀮𑀁 𑀓𑁄 𑀯𑀺𑀮𑁂𑀧𑀦𑀁;

𑀦𑀸𑀦𑀸𑀭𑀢𑁆𑀢𑀸𑀦𑀺 𑀯𑀢𑁆𑀣𑀸𑀦𑀺, 𑀓𑁄 𑀦𑀕𑁆𑀕𑁄 𑀧𑀭𑀺𑀤𑀳𑀺𑀲𑁆𑀲𑀢𑀺.

‘‘‘𑀓𑁄 𑀧𑀣𑁂 𑀙𑀢𑁆𑀢𑀫𑀸𑀤𑁂𑀢𑀺, 𑀓𑁄𑀧𑀸𑀳𑀦𑀸 𑀫𑀼𑀤𑀽 𑀲𑀼𑀪𑀸’;

𑀇𑀢𑀺 ¶ 𑀲𑀸𑀬𑀜𑁆𑀘 𑀧𑀸𑀢𑁄 𑀘, 𑀖𑁄𑀲𑀸𑀧𑁂𑀫𑀺 𑀢𑀳𑀺𑀁 𑀢𑀳𑀺𑀁.

‘‘𑀦 𑀢𑀁 𑀤𑀲𑀲𑀼 𑀞𑀸𑀦𑁂𑀲𑀼, 𑀦𑀧𑀺 𑀞𑀸𑀦𑀲𑀢𑁂𑀲𑀼 𑀯𑀸;

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

‘‘𑀤𑀺𑀯𑀸 𑀯𑀸 𑀬𑀤𑀺 𑀯𑀸 𑀭𑀢𑁆𑀢𑀺𑀁, 𑀬𑀤𑀺 𑀏𑀢𑀺 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑁄;

𑀮𑀤𑁆𑀥𑀸 𑀬𑀤𑀺𑀘𑁆𑀙𑀓𑀁 𑀪𑁄𑀕𑀁, 𑀧𑀽𑀭𑀳𑀢𑁆𑀣𑁄𑀯 𑀕𑀘𑁆𑀙𑀢𑀺.

‘‘𑀏𑀯𑀭𑀽𑀧𑀁 𑀫𑀳𑀸𑀤𑀸𑀦𑀁, 𑀅𑀤𑀸𑀲𑀺𑀁 𑀬𑀸𑀯𑀚𑀻𑀯𑀺𑀓𑀁;

𑀦𑀧𑀸𑀳𑀁 𑀤𑁂𑀲𑁆𑀲𑀁 𑀥𑀦𑀁 𑀤𑀫𑁆𑀫𑀺, 𑀦𑀧𑀺 𑀦𑀢𑁆𑀣𑀺 𑀦𑀺𑀘𑀬𑁄 𑀫𑀬𑀺.

‘‘𑀬𑀣𑀸𑀧𑀺 𑀆𑀢𑀼𑀭𑁄 𑀦𑀸𑀫, 𑀭𑁄𑀕𑀢𑁄 𑀧𑀭𑀺𑀫𑀼𑀢𑁆𑀢𑀺𑀬𑀸;

𑀥𑀦𑁂𑀦 𑀯𑁂𑀚𑁆𑀚𑀁 𑀢𑀧𑁆𑀧𑁂𑀢𑁆𑀯𑀸, 𑀭𑁄𑀕𑀢𑁄 𑀧𑀭𑀺𑀫𑀼𑀘𑁆𑀘𑀢𑀺.

‘‘𑀢𑀣𑁂𑀯𑀸𑀳𑀁 𑀚𑀸𑀦𑀫𑀸𑀦𑁄, 𑀧𑀭𑀺𑀧𑀽𑀭𑁂𑀢𑀼𑀫𑀲𑁂𑀲𑀢𑁄;

𑀊𑀦𑀫𑀦𑀁 𑀧𑀽𑀭𑀬𑀺𑀢𑀼𑀁, 𑀤𑁂𑀫𑀺 𑀤𑀸𑀦𑀁 𑀯𑀦𑀺𑀩𑁆𑀩𑀓𑁂;

𑀦𑀺𑀭𑀸𑀮𑀬𑁄 𑀅𑀧𑀘𑁆𑀘𑀸𑀲𑁄, 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀫𑀦𑀼𑀧𑀢𑁆𑀢𑀺𑀬𑀸’’𑀢𑀺.

𑀫𑀳𑀸𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑀘𑀭𑀺𑀬𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀁.

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

𑀧𑀽𑀚𑀺𑀢𑁄 𑀦𑀭𑀤𑁂𑀯𑁂𑀳𑀺, 𑀫𑀳𑀸𑀕𑁄𑀯𑀺𑀦𑁆𑀤𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀢𑀤𑀸𑀳𑀁 𑀲𑀢𑁆𑀢𑀭𑀚𑁆𑀚𑁂𑀲𑀼, 𑀬𑀁 𑀫𑁂 𑀆𑀲𑀺 𑀉𑀧𑀸𑀬𑀦𑀁;

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

‘‘𑀦 ¶ ¶ 𑀫𑁂 𑀤𑁂𑀲𑁆𑀲𑀁 𑀥𑀦𑀁 𑀥𑀜𑁆𑀜𑀁, 𑀦𑀧𑀺 𑀦𑀢𑁆𑀣𑀺 𑀦𑀺𑀘𑀬𑁄 𑀫𑀬𑀺;

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

𑀫𑀳𑀸𑀕𑁄𑀯𑀺𑀦𑁆𑀤𑀘𑀭𑀺𑀬𑀁 𑀧𑀜𑁆𑀘𑀫𑀁.

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

𑀦𑀺𑀫𑀺 𑀦𑀸𑀫 𑀫𑀳𑀸𑀭𑀸𑀚𑀸, 𑀧𑀡𑁆𑀟𑀺𑀢𑁄 𑀓𑀼𑀲𑀮𑀢𑁆𑀣𑀺𑀓𑁄.

‘‘𑀢𑀤𑀸𑀳𑀁 𑀫𑀸𑀧𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀘𑀢𑀼𑀲𑁆𑀲𑀸𑀮𑀁 𑀘𑀢𑀼𑀫𑁆𑀫𑀼𑀔𑀁;

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

‘‘𑀅𑀘𑁆𑀙𑀸𑀤𑀦𑀜𑁆𑀘 𑀲𑀬𑀦𑀁, 𑀅𑀦𑁆𑀦𑀁 𑀧𑀸𑀦𑀜𑁆𑀘 𑀪𑁄𑀚𑀦𑀁;

𑀅𑀩𑁆𑀩𑁄𑀘𑁆𑀙𑀺𑀦𑁆𑀦𑀁 𑀓𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀫𑀳𑀸𑀤𑀸𑀦𑀁 𑀧𑀯𑀢𑁆𑀢𑀬𑀺𑀁.

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

𑀓𑀸𑀬𑁂𑀦 𑀯𑀸𑀘𑀸 𑀫𑀦𑀲𑀸, 𑀆𑀭𑀸𑀥𑀦𑀻𑀬𑀫𑁂𑀲𑀢𑀺.

‘‘𑀢𑀣𑁂𑀯𑀸𑀳𑀁 𑀲𑀩𑁆𑀩𑀪𑀯𑁂, 𑀧𑀭𑀺𑀬𑁂𑀲𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀩𑁄𑀥𑀺𑀚𑀁;

𑀤𑀸𑀦𑁂𑀦 𑀲𑀢𑁆𑀢𑁂 𑀢𑀧𑁆𑀧𑁂𑀢𑁆𑀯𑀸, 𑀇𑀘𑁆𑀙𑀸𑀫𑀺 𑀩𑁄𑀥𑀺𑀫𑀼𑀢𑁆𑀢𑀫’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀏𑀓𑀭𑀸𑀚𑀲𑁆𑀲 𑀅𑀢𑁆𑀭𑀚𑁄;

𑀦𑀕𑀭𑁂 𑀧𑀼𑀧𑁆𑀨𑀯𑀢𑀺𑀬𑀸, 𑀓𑀼𑀫𑀸𑀭𑁄 𑀘𑀦𑁆𑀤𑀲𑀯𑁆𑀳𑀬𑁄.

‘‘𑀢𑀤𑀸𑀳𑀁 ¶ 𑀬𑀚𑀦𑀸 𑀫𑀼𑀢𑁆𑀢𑁄, 𑀦𑀺𑀓𑁆𑀔𑀦𑁆𑀢𑁄 𑀬𑀜𑁆𑀜𑀯𑀸𑀝𑀢𑁄;

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

‘‘𑀦𑀸𑀳𑀁 𑀧𑀺𑀯𑀸𑀫𑀺 𑀔𑀸𑀤𑀸𑀫𑀺, 𑀦𑀧𑀺 𑀪𑀼𑀜𑁆𑀚𑀸𑀫𑀺 𑀪𑁄𑀚𑀦𑀁;

𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑁂 𑀅𑀤𑀢𑁆𑀯𑀸𑀦, 𑀅𑀧𑀺 𑀙𑀧𑁆𑀧𑀜𑁆𑀘𑀭𑀢𑁆𑀢𑀺𑀬𑁄.

‘‘𑀬𑀣𑀸𑀧𑀺 ¶ 𑀯𑀸𑀡𑀺𑀚𑁄 𑀦𑀸𑀫, 𑀓𑀢𑁆𑀯𑀸𑀦 𑀪𑀡𑁆𑀟𑀲𑀜𑁆𑀘𑀬𑀁;

𑀬𑀢𑁆𑀣 𑀮𑀸𑀪𑁄 𑀫𑀳𑀸 𑀳𑁄𑀢𑀺, 𑀢𑀢𑁆𑀣 𑀢𑀁 [𑀢𑀢𑁆𑀣 𑀦𑀁 (𑀲𑀻.), 𑀢𑀢𑁆𑀣 (𑀓.)] 𑀳𑀭𑀢𑀺 𑀪𑀡𑁆𑀟𑀓𑀁.

‘‘𑀢𑀣𑁂𑀯 𑀲𑀓𑀪𑀼𑀢𑁆𑀢𑀸𑀧𑀺, 𑀧𑀭𑁂 𑀤𑀺𑀦𑁆𑀦𑀁 𑀫𑀳𑀧𑁆𑀨𑀮𑀁;

𑀢𑀲𑁆𑀫𑀸 𑀧𑀭𑀲𑁆𑀲 𑀤𑀸𑀢𑀩𑁆𑀩𑀁, 𑀲𑀢𑀪𑀸𑀕𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺.

‘‘𑀏𑀢𑀫𑀢𑁆𑀣𑀯𑀲𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀤𑁂𑀫𑀺 𑀤𑀸𑀦𑀁 𑀪𑀯𑀸𑀪𑀯𑁂;

𑀦 𑀧𑀝𑀺𑀓𑁆𑀓𑀫𑀸𑀫𑀺 𑀤𑀸𑀦𑀢𑁄, 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀫𑀦𑀼𑀧𑀢𑁆𑀢𑀺𑀬𑀸’’𑀢𑀺.

𑀘𑀦𑁆𑀤𑀓𑀼𑀫𑀸𑀭𑀘𑀭𑀺𑀬𑀁 𑀲𑀢𑁆𑀢𑀫𑀁.

‘‘𑀅𑀭𑀺𑀝𑁆𑀞𑀲𑀯𑁆𑀳𑀬𑁂 𑀦𑀕𑀭𑁂, 𑀲𑀺𑀯𑀺𑀦𑀸𑀫𑀸𑀲𑀺 𑀔𑀢𑁆𑀢𑀺𑀬𑁄;

𑀦𑀺𑀲𑀚𑁆𑀚 𑀧𑀸𑀲𑀸𑀤𑀯𑀭𑁂, 𑀏𑀯𑀁 𑀘𑀺𑀦𑁆𑀢𑁂𑀲𑀳𑀁 𑀢𑀤𑀸.

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

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

‘‘𑀫𑀫 𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑀫𑀜𑁆𑀜𑀸𑀬, 𑀲𑀓𑁆𑀓𑁄 𑀤𑁂𑀯𑀸𑀦𑀫𑀺𑀲𑁆𑀲𑀭𑁄;

𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑁄 𑀤𑁂𑀯𑀧𑀭𑀺𑀲𑀸𑀬, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺.

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

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

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

𑀫𑀼𑀳𑀼𑀢𑁆𑀢𑀁 𑀆𑀕𑀫𑁂𑀬𑁆𑀬𑀸𑀣, 𑀬𑀸𑀯 𑀚𑀸𑀦𑀸𑀫𑀺 𑀢𑀁 𑀫𑀦𑀁’.

‘‘𑀧𑀯𑁂𑀥𑀫𑀸𑀦𑁄 𑀧𑀮𑀺𑀢𑀲𑀺𑀭𑁄, 𑀯𑀮𑀺𑀕𑀢𑁆𑀢𑁄 [𑀯𑀮𑀺𑀢𑀕𑀢𑁆𑀢𑁄 (𑀲𑀻.)] 𑀚𑀭𑀸𑀢𑀼𑀭𑁄;

𑀅𑀦𑁆𑀥𑀯𑀡𑁆𑀡𑁄𑀯 𑀳𑀼𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚𑀸𑀦𑀁 𑀉𑀧𑀲𑀗𑁆𑀓𑀫𑀺.

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

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

‘‘‘𑀬𑀸𑀘𑀸𑀫𑀺 𑀢𑀁 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀥𑀫𑁆𑀫𑀺𑀓 𑀭𑀝𑁆𑀞𑀯𑀟𑁆𑀠𑀦;

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

‘‘‘𑀉𑀪𑁄𑀧𑀺 ¶ 𑀦𑁂𑀢𑁆𑀢𑀸 𑀦𑀬𑀦𑀸, 𑀅𑀦𑁆𑀥𑀸 𑀉𑀧𑀳𑀢𑀸 𑀫𑀫;

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

‘‘𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀳𑀝𑁆𑀞𑁄 𑀲𑀁𑀯𑀺𑀕𑁆𑀕𑀫𑀸𑀦𑀲𑁄;

𑀓𑀢𑀜𑁆𑀚𑀮𑀻 𑀯𑁂𑀤𑀚𑀸𑀢𑁄, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺𑀁.

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

𑀢𑁆𑀯𑀁 𑀫𑀫 𑀘𑀺𑀢𑁆𑀢𑀫𑀜𑁆𑀜𑀸𑀬, 𑀦𑁂𑀢𑁆𑀢𑀁 𑀬𑀸𑀘𑀺𑀢𑀼𑀫𑀸𑀕𑀢𑁄.

‘‘‘𑀅𑀳𑁄 𑀫𑁂 𑀫𑀸𑀦𑀲𑀁 𑀲𑀺𑀤𑁆𑀥𑀁, 𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑁄 𑀧𑀭𑀺𑀧𑀽𑀭𑀺𑀢𑁄;

𑀅𑀤𑀺𑀦𑁆𑀦𑀧𑀼𑀩𑁆𑀩𑀁 𑀤𑀸𑀦𑀯𑀭𑀁, 𑀅𑀚𑁆𑀚 𑀤𑀲𑁆𑀲𑀸𑀫𑀺 𑀬𑀸𑀘𑀓𑁂.

‘‘‘𑀏𑀳𑀺 𑀲𑀺𑀯𑀓 𑀉𑀝𑁆𑀞𑁂𑀳𑀺, 𑀫𑀸 𑀤𑀦𑁆𑀥𑀬𑀺 𑀫𑀸 𑀧𑀯𑁂𑀥𑀬𑀺;

𑀉𑀪𑁄𑀧𑀺 𑀦𑀬𑀦𑀁 𑀤𑁂𑀳𑀺, 𑀉𑀧𑁆𑀧𑀸𑀝𑁂𑀢𑁆𑀯𑀸 𑀯𑀡𑀺𑀩𑁆𑀩𑀓𑁂’.

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

𑀉𑀤𑁆𑀥𑀭𑀺𑀢𑁆𑀯𑀸𑀦 𑀧𑀸𑀤𑀸𑀲𑀺, 𑀢𑀸𑀮𑀫𑀺𑀜𑁆𑀚𑀁𑀯 𑀬𑀸𑀘𑀓𑁂.

‘‘𑀤𑀤𑀫𑀸𑀦𑀲𑁆𑀲 𑀤𑁂𑀦𑁆𑀢𑀲𑁆𑀲, 𑀤𑀺𑀦𑁆𑀦𑀤𑀸𑀦𑀲𑁆𑀲 𑀫𑁂 𑀲𑀢𑁄;

𑀘𑀺𑀢𑁆𑀢𑀲𑁆𑀲 𑀅𑀜𑁆𑀜𑀣𑀸 𑀦𑀢𑁆𑀣𑀺, 𑀩𑁄𑀥𑀺𑀬𑀸𑀬𑁂𑀯 𑀓𑀸𑀭𑀡𑀸.

‘‘𑀦 𑀫𑁂 𑀤𑁂𑀲𑁆𑀲𑀸 𑀉𑀪𑁄 𑀘𑀓𑁆𑀔𑀽, 𑀅𑀢𑁆𑀢𑀸 𑀦 𑀫𑁂 𑀦 𑀤𑁂𑀲𑁆𑀲𑀺𑀬𑁄;

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀺𑀬𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀘𑀓𑁆𑀔𑀼𑀁 𑀅𑀤𑀸𑀲𑀳’’𑀦𑁆𑀢𑀺.

‘‘𑀬𑀸 ¶ 𑀫𑁂 𑀅𑀳𑁄𑀲𑀺 𑀚𑀦𑀺𑀓𑀸, 𑀨𑀼𑀲𑁆𑀲𑀢𑀻 [𑀨𑀼𑀲𑀢𑀻 (𑀲𑀻.)] 𑀦𑀸𑀫 𑀔𑀢𑁆𑀢𑀺𑀬𑀸;

𑀲𑀸 𑀅𑀢𑀻𑀢𑀸𑀲𑀼 𑀚𑀸𑀢𑀻𑀲𑀼, 𑀲𑀓𑁆𑀓𑀲𑁆𑀲 𑀫𑀳𑁂𑀲𑀻 𑀧𑀺𑀬𑀸.

‘‘𑀢𑀲𑁆𑀲𑀸 𑀆𑀬𑀼𑀓𑁆𑀔𑀬𑀁 𑀜𑀢𑁆𑀯𑀸, 𑀤𑁂𑀯𑀺𑀦𑁆𑀤𑁄 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

‘𑀤𑀤𑀸𑀫𑀺 𑀢𑁂 𑀤𑀲 𑀯𑀭𑁂, 𑀯𑀭𑀪𑀤𑁆𑀤𑁂 𑀬𑀤𑀺𑀘𑁆𑀙𑀲𑀺’.

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

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

𑀭𑀫𑁆𑀫𑀸 𑀘𑀸𑀯𑁂𑀲𑀺 𑀫𑀁 𑀞𑀸𑀦𑀸, 𑀯𑀸𑀢𑁄𑀯 𑀥𑀭𑀡𑀻𑀭𑀼𑀳𑀁’.

‘‘𑀏𑀯𑀁 ¶ 𑀯𑀼𑀢𑁆𑀢𑁄 𑀘 𑀲𑁄 𑀲𑀓𑁆𑀓𑁄, 𑀧𑀼𑀦 𑀢𑀲𑁆𑀲𑀺𑀤𑀫𑀩𑁆𑀭𑀯𑀺;

‘𑀦 𑀘𑁂𑀯 𑀢𑁂 𑀓𑀢𑀁 𑀧𑀸𑀧𑀁, 𑀦 𑀘 𑀫𑁂 𑀢𑁆𑀯𑀁𑀲𑀺 𑀅𑀧𑁆𑀧𑀺𑀬𑀸.

‘‘‘𑀏𑀢𑁆𑀢𑀓𑀁𑀬𑁂𑀯 ¶ 𑀢𑁂 𑀆𑀬𑀼, 𑀘𑀯𑀦𑀓𑀸𑀮𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺;

𑀧𑀝𑀺𑀕𑁆𑀕𑀡𑁆𑀳 𑀫𑀬𑀸 𑀤𑀺𑀦𑁆𑀦𑁂, 𑀯𑀭𑁂 𑀤𑀲 𑀯𑀭𑀼𑀢𑁆𑀢𑀫𑁂’.

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

𑀫𑀫𑀁 𑀅𑀩𑁆𑀪𑀦𑁆𑀢𑀭𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀨𑀼𑀲𑁆𑀲𑀢𑀻 𑀤𑀲 𑀯𑀭𑁂 𑀯𑀭𑀻.

‘‘𑀢𑀢𑁄 𑀘𑀼𑀢𑀸 𑀲𑀸 𑀨𑀼𑀲𑁆𑀲𑀢𑀻, 𑀔𑀢𑁆𑀢𑀺𑀬𑁂 𑀉𑀧𑀧𑀚𑁆𑀚𑀣;

𑀚𑁂𑀢𑀼𑀢𑁆𑀢𑀭𑀫𑁆𑀳𑀺 𑀦𑀕𑀭𑁂, 𑀲𑀜𑁆𑀚𑀬𑁂𑀦 𑀲𑀫𑀸𑀕𑀫𑀺.

‘‘𑀬𑀤𑀸𑀳𑀁 𑀨𑀼𑀲𑁆𑀲𑀢𑀺𑀬𑀸 𑀓𑀼𑀘𑁆𑀙𑀺𑀁, 𑀑𑀓𑁆𑀓𑀦𑁆𑀢𑁄 𑀧𑀺𑀬𑀫𑀸𑀢𑀼𑀬𑀸;

𑀫𑀫 𑀢𑁂𑀚𑁂𑀦 𑀫𑁂 𑀫𑀸𑀢𑀸, 𑀲𑀤𑀸 𑀤𑀸𑀦𑀭𑀢𑀸 𑀅𑀳𑀼.

‘‘𑀅𑀥𑀦𑁂 𑀆𑀢𑀼𑀭𑁂 𑀚𑀺𑀡𑁆𑀡𑁂, 𑀬𑀸𑀘𑀓𑁂 𑀅𑀤𑁆𑀥𑀺𑀓𑁂 [𑀧𑀣𑀺𑀓𑁂 (𑀓.)] 𑀚𑀦𑁂;

𑀲𑀫𑀡𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂 𑀔𑀻𑀡𑁂, 𑀤𑁂𑀢𑀺 𑀤𑀸𑀦𑀁 𑀅𑀓𑀺𑀜𑁆𑀘𑀦𑁂.

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

𑀯𑁂𑀲𑁆𑀲𑀸𑀦𑀁 𑀯𑀻𑀣𑀺𑀬𑀸 𑀫𑀚𑁆𑀛𑁂, 𑀚𑀦𑁂𑀲𑀺 𑀨𑀼𑀲𑁆𑀲𑀢𑀻 𑀫𑀫𑀁.

‘‘𑀦 𑀫𑀬𑁆𑀳𑀁 𑀫𑀢𑁆𑀢𑀺𑀓𑀁 𑀦𑀸𑀫𑀁, 𑀦𑀧𑀺 𑀧𑁂𑀢𑁆𑀢𑀺𑀓𑀲𑀫𑁆𑀪𑀯𑀁;

𑀚𑀸𑀢𑁂𑀢𑁆𑀣 𑀯𑁂𑀲𑁆𑀲𑀯𑀻𑀣𑀺𑀬𑀸, 𑀢𑀲𑁆𑀫𑀸 𑀯𑁂𑀲𑁆𑀲𑀦𑁆𑀢𑀭𑁄 𑀅𑀳𑀼.

‘‘𑀬𑀤𑀸𑀳𑀁 𑀤𑀸𑀭𑀓𑁄 𑀳𑁄𑀫𑀺, 𑀚𑀸𑀢𑀺𑀬𑀸 𑀅𑀝𑁆𑀞𑀯𑀲𑁆𑀲𑀺𑀓𑁄;

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

‘‘‘𑀳𑀤𑀬𑀁 ¶ 𑀤𑀤𑁂𑀬𑁆𑀬𑀁 𑀘𑀓𑁆𑀔𑀼𑀁, 𑀫𑀁𑀲𑀫𑁆𑀧𑀺 𑀭𑀼𑀥𑀺𑀭𑀫𑁆𑀧𑀺 𑀘;

𑀤𑀤𑁂𑀬𑁆𑀬𑀁 𑀓𑀸𑀬𑀁 𑀲𑀸𑀯𑁂𑀢𑁆𑀯𑀸, 𑀬𑀤𑀺 𑀓𑁄𑀘𑀺 𑀬𑀸𑀘𑀬𑁂 𑀫𑀫𑀁’.

‘‘𑀲𑀪𑀸𑀯𑀁 𑀘𑀺𑀦𑁆𑀢𑀬𑀦𑁆𑀢𑀲𑁆𑀲, 𑀅𑀓𑀫𑁆𑀧𑀺𑀢𑀫𑀲𑀡𑁆𑀞𑀺𑀢𑀁;

𑀅𑀓𑀫𑁆𑀧𑀺 𑀢𑀢𑁆𑀣 𑀧𑀣𑀯𑀻, 𑀲𑀺𑀦𑁂𑀭𑀼𑀯𑀦𑀯𑀝𑀁𑀲𑀓𑀸.

‘‘𑀅𑀦𑁆𑀯𑀤𑁆𑀥𑀫𑀸𑀲𑁂 𑀧𑀦𑁆𑀦𑀭𑀲𑁂, 𑀧𑀼𑀡𑁆𑀡𑀫𑀸𑀲𑁂 𑀉𑀧𑁄𑀲𑀣𑁂;

𑀧𑀘𑁆𑀘𑀬𑀁 𑀦𑀸𑀕𑀫𑀸𑀭𑀼𑀬𑁆𑀳, 𑀤𑀸𑀦𑀁 𑀤𑀸𑀢𑀼𑀁 𑀉𑀧𑀸𑀕𑀫𑀺𑀁.

‘‘𑀓𑀮𑀺𑀗𑁆𑀕𑀭𑀝𑁆𑀞𑀯𑀺𑀲𑀬𑀸 ¶ , 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸 𑀉𑀧𑀕𑀜𑁆𑀙𑀼 𑀫𑀁;

𑀅𑀬𑀸𑀘𑀼𑀁 𑀫𑀁 𑀳𑀢𑁆𑀣𑀺𑀦𑀸𑀕𑀁, 𑀥𑀜𑁆𑀜𑀁 𑀫𑀗𑁆𑀕𑀮𑀲𑀫𑁆𑀫𑀢𑀁.

‘‘𑀅𑀯𑀼𑀝𑁆𑀞𑀺𑀓𑁄 ¶ 𑀚𑀦𑀧𑀤𑁄, 𑀤𑀼𑀩𑁆𑀪𑀺𑀓𑁆𑀔𑁄 𑀙𑀸𑀢𑀓𑁄 𑀫𑀳𑀸;

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

‘‘𑀤𑀤𑀸𑀫𑀺 𑀦 𑀯𑀺𑀓𑀫𑁆𑀧𑀸𑀫𑀺, 𑀬𑀁 𑀫𑀁 𑀬𑀸𑀘𑀦𑁆𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸;

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

‘‘𑀦 𑀫𑁂 𑀬𑀸𑀘𑀓𑀫𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁂, 𑀧𑀝𑀺𑀓𑁆𑀔𑁂𑀧𑁄 𑀅𑀦𑀼𑀘𑁆𑀙𑀯𑁄;

‘𑀫𑀸 𑀫𑁂 𑀪𑀺𑀚𑁆𑀚𑀺 𑀲𑀫𑀸𑀤𑀸𑀦𑀁, 𑀤𑀲𑁆𑀲𑀸𑀫𑀺 𑀯𑀺𑀧𑀼𑀮𑀁 𑀕𑀚𑀁’.

‘‘𑀦𑀸𑀕𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀲𑁄𑀡𑁆𑀟𑀸𑀬, 𑀪𑀺𑀗𑁆𑀕𑀸𑀭𑁂 𑀭𑀢𑀦𑀸𑀫𑀬𑁂;

𑀚𑀮𑀁 𑀳𑀢𑁆𑀣𑁂 𑀆𑀓𑀺𑀭𑀺𑀢𑁆𑀯𑀸, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀅𑀤𑀁 𑀕𑀚𑀁.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 𑀤𑀤𑀦𑁆𑀢𑀲𑁆𑀲, 𑀲𑀩𑁆𑀩𑀲𑁂𑀢𑀁 𑀕𑀚𑀼𑀢𑁆𑀢𑀫𑀁;

𑀢𑀤𑀸𑀧𑀺 𑀧𑀣𑀯𑀻 𑀓𑀫𑁆𑀧𑀺, 𑀲𑀺𑀦𑁂𑀭𑀼𑀯𑀦𑀯𑀝𑀁𑀲𑀓𑀸.

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

𑀧𑀩𑁆𑀩𑀸𑀚𑁂𑀲𑀼𑀁 𑀲𑀓𑀸 𑀭𑀝𑁆𑀞𑀸, ‘𑀯𑀗𑁆𑀓𑀁 𑀕𑀘𑁆𑀙𑀢𑀼 𑀧𑀩𑁆𑀩𑀢𑀁’.

‘‘𑀢𑁂𑀲𑀁 𑀦𑀺𑀘𑁆𑀙𑀼𑀪𑀫𑀸𑀦𑀸𑀦𑀁, 𑀅𑀓𑀫𑁆𑀧𑀺𑀢𑁆𑀣𑀫𑀲𑀡𑁆𑀞𑀺𑀢𑀁;

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

‘‘𑀬𑀸𑀘𑀺𑀢𑀸 ¶ 𑀲𑀺𑀯𑀬𑁄 𑀲𑀩𑁆𑀩𑁂, 𑀏𑀓𑀁 𑀯𑀭𑀫𑀤𑀁𑀲𑀼 𑀫𑁂;

𑀲𑀸𑀯𑀬𑀺𑀢𑁆𑀯𑀸 𑀓𑀡𑁆𑀡𑀪𑁂𑀭𑀺𑀁, 𑀫𑀳𑀸𑀤𑀸𑀦𑀁 𑀤𑀤𑀸𑀫𑀳𑀁.

‘‘𑀅𑀣𑁂𑀢𑁆𑀣 𑀯𑀢𑁆𑀢𑀢𑀻 𑀲𑀤𑁆𑀤𑁄, 𑀢𑀼𑀫𑀼𑀮𑁄 𑀪𑁂𑀭𑀯𑁄 𑀫𑀳𑀸;

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

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

𑀫𑀳𑀸𑀤𑀸𑀦𑀁 𑀤𑀤𑀺𑀢𑁆𑀯𑀸𑀦, 𑀦𑀕𑀭𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑀺𑀁 𑀢𑀤𑀸.

‘‘𑀦𑀺𑀓𑁆𑀔𑀫𑀺𑀢𑁆𑀯𑀸𑀦 ¶ 𑀦𑀕𑀭𑀸, 𑀦𑀺𑀯𑀢𑁆𑀢𑀺𑀢𑁆𑀯𑀸 𑀯𑀺𑀮𑁄𑀓𑀺𑀢𑁂;

𑀢𑀤𑀸𑀧𑀺 𑀧𑀣𑀯𑀻 𑀓𑀫𑁆𑀧𑀺, 𑀲𑀺𑀦𑁂𑀭𑀼𑀯𑀦𑀯𑀝𑀁𑀲𑀓𑀸.

‘‘𑀘𑀢𑀼𑀯𑀸𑀳𑀺𑀁 𑀭𑀣𑀁 𑀤𑀢𑁆𑀯𑀸, 𑀞𑀢𑁆𑀯𑀸 𑀘𑀸𑀢𑀼𑀫𑁆𑀫𑀳𑀸𑀧𑀣𑁂;

𑀏𑀓𑀸𑀓𑀺𑀬𑁄 𑀅𑀤𑀼𑀢𑀺𑀬𑁄, 𑀫𑀤𑁆𑀤𑀺𑀤𑁂𑀯𑀺𑀁 𑀇𑀤𑀫𑀩𑁆𑀭𑀯𑀺𑀁.

‘‘‘𑀢𑁆𑀯𑀁 𑀫𑀤𑁆𑀤𑀺 𑀓𑀡𑁆𑀳𑀁 𑀕𑀡𑁆𑀳𑀸𑀳𑀺, 𑀮𑀳𑀼𑀓𑀸 𑀏𑀲𑀸 𑀓𑀦𑀺𑀝𑁆𑀞𑀺𑀓𑀸;

𑀅𑀳𑀁 𑀚𑀸𑀮𑀺𑀁 𑀕𑀳𑁂𑀲𑁆𑀲𑀸𑀫𑀺, 𑀕𑀭𑀼𑀓𑁄 𑀪𑀸𑀢𑀺𑀓𑁄 𑀳𑀺 𑀲𑁄’.

‘‘𑀧𑀤𑀼𑀫𑀁 ¶ 𑀧𑀼𑀡𑁆𑀟𑀭𑀻𑀓𑀁𑀯, 𑀫𑀤𑁆𑀤𑀻 𑀓𑀡𑁆𑀳𑀸𑀚𑀺𑀦𑀕𑁆𑀕𑀳𑀻;

𑀅𑀳𑀁 𑀲𑀼𑀯𑀡𑁆𑀡𑀩𑀺𑀫𑁆𑀩𑀁𑀯, 𑀚𑀸𑀮𑀺𑀁 𑀔𑀢𑁆𑀢𑀺𑀬𑀫𑀕𑁆𑀕𑀳𑀺𑀁.

‘‘𑀅𑀪𑀺𑀚𑀸𑀢𑀸 𑀲𑀼𑀔𑀼𑀫𑀸𑀮𑀸, 𑀔𑀢𑁆𑀢𑀺𑀬𑀸 𑀘𑀢𑀼𑀭𑁄 𑀚𑀦𑀸;

𑀯𑀺𑀲𑀫𑀁 𑀲𑀫𑀁 𑀅𑀓𑁆𑀓𑀫𑀦𑁆𑀢𑀸, 𑀯𑀗𑁆𑀓𑀁 𑀕𑀘𑁆𑀙𑀸𑀫 𑀧𑀩𑁆𑀩𑀢𑀁.

‘‘𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀦𑀼𑀚𑀸 𑀏𑀦𑁆𑀢𑀺, 𑀅𑀦𑀼𑀫𑀕𑁆𑀕𑁂 𑀧𑀝𑀺𑀧𑁆𑀧𑀣𑁂;

𑀫𑀕𑁆𑀕𑀦𑁆𑀢𑁂 𑀧𑀝𑀺𑀧𑀼𑀘𑁆𑀙𑀸𑀫, ‘𑀓𑀼𑀳𑀺𑀁 𑀯𑀗𑁆𑀓𑀦𑁆𑀢 [𑀯𑀗𑁆𑀓𑀢 (𑀲𑀻.)] 𑀧𑀩𑁆𑀩𑀢𑁄’.

‘‘𑀢𑁂 𑀢𑀢𑁆𑀣 𑀅𑀫𑁆𑀳𑁂 𑀧𑀲𑁆𑀲𑀺𑀢𑁆𑀯𑀸, 𑀓𑀭𑀼𑀡𑀁 𑀕𑀺𑀭𑀫𑀼𑀤𑀻𑀭𑀬𑀼𑀁;

𑀤𑀼𑀓𑁆𑀔𑀁 𑀢𑁂 𑀧𑀝𑀺𑀯𑁂𑀤𑁂𑀦𑁆𑀢𑀺, 𑀤𑀽𑀭𑁂 𑀯𑀗𑁆𑀓𑀦𑁆𑀢𑀧𑀩𑁆𑀩𑀢𑁄.

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

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

‘‘𑀭𑁄𑀤𑀦𑁆𑀢𑁂 𑀤𑀸𑀭𑀓𑁂 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀉𑀩𑁆𑀩𑀺𑀤𑁆𑀥𑀸 [𑀉𑀩𑁆𑀩𑀺𑀕𑁆𑀕𑀸 (𑀲𑁆𑀬𑀸. 𑀓𑀁.)] 𑀯𑀺𑀧𑀼𑀮𑀸 𑀤𑀼𑀫𑀸;

𑀲𑀬𑀫𑁂𑀯𑁄𑀡𑀫𑀺𑀢𑁆𑀯𑀸𑀦, 𑀉𑀧𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀤𑀸𑀭𑀓𑁂.

‘‘𑀇𑀤𑀁 ¶ 𑀅𑀘𑁆𑀙𑀭𑀺𑀬𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀅𑀩𑁆𑀪𑀼𑀢𑀁 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑀁;

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

‘‘𑀅𑀘𑁆𑀙𑁂𑀭𑀁 𑀯𑀢 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁, 𑀅𑀩𑁆𑀪𑀼𑀢𑀁 𑀮𑁄𑀫𑀳𑀁𑀲𑀦𑀁;

𑀯𑁂𑀲𑁆𑀲𑀦𑁆𑀢𑀭𑀲𑁆𑀲 𑀢𑁂𑀚𑁂𑀦, 𑀲𑀬𑀫𑁂𑀯𑁄𑀡𑀢𑀸 𑀤𑀼𑀫𑀸.

‘‘𑀲𑀗𑁆𑀔𑀺𑀧𑀺𑀁𑀲𑀼 𑀧𑀣𑀁 𑀬𑀓𑁆𑀔𑀸, 𑀅𑀦𑀼𑀓𑀫𑁆𑀧𑀸𑀬 𑀤𑀸𑀭𑀓𑁂;

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

‘‘𑀲𑀝𑁆𑀞𑀺𑀭𑀸𑀚𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀺, 𑀢𑀤𑀸 𑀯𑀲𑀦𑁆𑀢𑀺 𑀫𑀸𑀢𑀼𑀮𑁂;

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

‘‘𑀢𑀢𑁆𑀣 𑀯𑀢𑁆𑀢𑁂𑀢𑁆𑀯𑀸 𑀲𑀮𑁆𑀮𑀸𑀧𑀁, 𑀘𑁂𑀢𑁂𑀳𑀺 𑀘𑁂𑀢𑀧𑀼𑀢𑁆𑀢𑁂𑀳𑀺;

𑀢𑁂 𑀢𑀢𑁄 𑀦𑀺𑀓𑁆𑀔𑀫𑀺𑀢𑁆𑀯𑀸𑀦, 𑀯𑀗𑁆𑀓𑀁 𑀅𑀕𑀫𑀼 𑀧𑀩𑁆𑀩𑀢𑀁.

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

𑀅𑀲𑁆𑀲𑀫𑀁 𑀲𑀼𑀓𑀢𑀁 𑀭𑀫𑁆𑀫𑀁, 𑀧𑀡𑁆𑀡𑀲𑀸𑀮𑀁 𑀲𑀼𑀫𑀸𑀧𑀬.

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

𑀅𑀲𑁆𑀲𑀫𑀁 ¶ 𑀲𑀼𑀓𑀢𑀁 𑀭𑀫𑁆𑀫𑀁, 𑀧𑀡𑁆𑀡𑀲𑀸𑀮𑀁 𑀲𑀼𑀫𑀸𑀧𑀬𑀺.

‘‘𑀅𑀚𑁆𑀛𑁄𑀕𑀸𑀳𑁂𑀢𑁆𑀯𑀸 ¶ 𑀧𑀯𑀦𑀁, 𑀅𑀧𑁆𑀧𑀲𑀤𑁆𑀤𑀁 𑀦𑀺𑀭𑀸𑀓𑀼𑀮𑀁;

𑀘𑀢𑀼𑀭𑁄 𑀚𑀦𑀸 𑀫𑀬𑀁 𑀢𑀢𑁆𑀣, 𑀯𑀲𑀸𑀫 𑀧𑀩𑁆𑀩𑀢𑀦𑁆𑀢𑀭𑁂.

‘‘𑀅𑀳𑀜𑁆𑀘 𑀫𑀤𑁆𑀤𑀺𑀤𑁂𑀯𑀻 𑀘, 𑀚𑀸𑀮𑀻 𑀓𑀡𑁆𑀳𑀸𑀚𑀺𑀦𑀸 𑀘𑀼𑀪𑁄;

𑀅𑀜𑁆𑀜𑀫𑀜𑁆𑀜𑀁 𑀲𑁄𑀓𑀦𑀼𑀤𑀸, 𑀯𑀲𑀸𑀫 𑀅𑀲𑁆𑀲𑀫𑁂 𑀢𑀤𑀸.

‘‘𑀤𑀸𑀭𑀓𑁂 𑀅𑀦𑀼𑀭𑀓𑁆𑀔𑀦𑁆𑀢𑁄, 𑀅𑀲𑀼𑀜𑁆𑀜𑁄 𑀳𑁄𑀫𑀺 𑀅𑀲𑁆𑀲𑀫𑁂;

𑀫𑀤𑁆𑀤𑀻 𑀨𑀮𑀁 𑀆𑀳𑀭𑀺𑀢𑁆𑀯𑀸, 𑀧𑁄𑀲𑁂𑀢𑀺 𑀲𑀸 𑀢𑀬𑁄 𑀚𑀦𑁂.

‘‘𑀧𑀯𑀦𑁂 ¶ 𑀯𑀲𑀫𑀸𑀦𑀲𑁆𑀲, 𑀅𑀤𑁆𑀥𑀺𑀓𑁄 𑀫𑀁 𑀉𑀧𑀸𑀕𑀫𑀺;

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

‘‘𑀬𑀸𑀘𑀓𑀁 𑀉𑀧𑀕𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀳𑀸𑀲𑁄 𑀫𑁂 𑀉𑀧𑀧𑀚𑁆𑀚𑀣;

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

‘‘𑀲𑀓𑁂 𑀧𑀼𑀢𑁆𑀢𑁂 𑀘𑀚𑀦𑁆𑀢𑀲𑁆𑀲, 𑀚𑀽𑀚𑀓𑁂 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂 𑀬𑀤𑀸;

𑀢𑀤𑀸𑀧𑀺 𑀧𑀣𑀯𑀻 𑀓𑀫𑁆𑀧𑀺, 𑀲𑀺𑀦𑁂𑀭𑀼𑀯𑀦𑀯𑀝𑀁𑀲𑀓𑀸.

‘‘𑀧𑀼𑀦𑀤𑁂𑀯 𑀲𑀓𑁆𑀓𑁄 𑀑𑀭𑀼𑀬𑁆𑀳, 𑀳𑀼𑀢𑁆𑀯𑀸 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑀦𑁆𑀦𑀺𑀪𑁄;

𑀆𑀬𑀸𑀘𑀺 𑀫𑀁 𑀫𑀤𑁆𑀤𑀺𑀤𑁂𑀯𑀺𑀁, 𑀲𑀻𑀮𑀯𑀦𑁆𑀢𑀺𑀁 𑀧𑀢𑀺𑀩𑁆𑀩𑀢𑀁.

‘‘𑀫𑀤𑁆𑀤𑀺𑀁 𑀳𑀢𑁆𑀣𑁂 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀉𑀤𑀓𑀜𑁆𑀚𑀮𑀺 𑀧𑀽𑀭𑀺𑀬;

𑀧𑀲𑀦𑁆𑀦𑀫𑀦𑀲𑀗𑁆𑀓𑀧𑁆𑀧𑁄, 𑀢𑀲𑁆𑀲 𑀫𑀤𑁆𑀤𑀺𑀁 𑀅𑀤𑀸𑀲𑀳𑀁.

‘‘𑀫𑀤𑁆𑀤𑀺𑀬𑀸 𑀤𑀻𑀬𑀫𑀸𑀦𑀸𑀬, 𑀕𑀕𑀦𑁂 𑀤𑁂𑀯𑀸 𑀧𑀫𑁄𑀤𑀺𑀢𑀸;

𑀢𑀤𑀸𑀧𑀺 𑀧𑀣𑀯𑀻 𑀓𑀫𑁆𑀧𑀺, 𑀲𑀺𑀦𑁂𑀭𑀼𑀯𑀦𑀯𑀝𑀁𑀲𑀓𑀸.

‘‘𑀚𑀸𑀮𑀺𑀁 𑀓𑀡𑁆𑀳𑀸𑀚𑀺𑀦𑀁 𑀥𑀻𑀢𑀁, 𑀫𑀤𑁆𑀤𑀺𑀤𑁂𑀯𑀺𑀁 𑀧𑀢𑀺𑀩𑁆𑀩𑀢𑀁;

𑀘𑀚𑀫𑀸𑀦𑁄 𑀦 𑀘𑀺𑀦𑁆𑀢𑁂𑀲𑀺𑀁, 𑀩𑁄𑀥𑀺𑀬𑀸𑀬𑁂𑀯 𑀓𑀸𑀭𑀡𑀸.

‘‘𑀦 𑀫𑁂 𑀤𑁂𑀲𑁆𑀲𑀸 𑀉𑀪𑁄 𑀧𑀼𑀢𑁆𑀢𑀸, 𑀫𑀤𑁆𑀤𑀺𑀤𑁂𑀯𑀻 𑀦 𑀤𑁂𑀲𑁆𑀲𑀺𑀬𑀸;

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀺𑀬𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀧𑀺𑀬𑁂 𑀅𑀤𑀸𑀲𑀳𑀁.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 𑀩𑁆𑀭𑀳𑀸𑀭𑀜𑁆𑀜𑁂, 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀼𑀲𑀫𑀸𑀕𑀫𑁂;

𑀓𑀭𑀼𑀡𑀁 𑀧𑀭𑀺𑀤𑁂𑀯𑀦𑁆𑀢𑁂, 𑀲𑀮𑁆𑀮𑀧𑀦𑁆𑀢𑁂 𑀲𑀼𑀔𑀁 𑀤𑀼𑀔𑀁.

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

𑀢𑀤𑀸𑀧𑀺 𑀧𑀣𑀯𑀻 𑀓𑀫𑁆𑀧𑀺, 𑀲𑀺𑀦𑁂𑀭𑀼𑀯𑀦𑀯𑀝𑀁𑀲𑀓𑀸.

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

𑀧𑀯𑀺𑀲𑀸𑀫𑀺 𑀧𑀼𑀭𑀁 𑀭𑀫𑁆𑀫𑀁, 𑀚𑁂𑀢𑀼𑀢𑁆𑀢𑀭𑀁 𑀧𑀼𑀭𑀼𑀢𑁆𑀢𑀫𑀁.

‘‘𑀭𑀢𑀦𑀸𑀦𑀺 𑀲𑀢𑁆𑀢 𑀯𑀲𑁆𑀲𑀺𑀁𑀲𑀼, 𑀫𑀳𑀸𑀫𑁂𑀖𑁄 𑀧𑀯𑀲𑁆𑀲𑀣;

𑀢𑀤𑀸𑀧𑀺 𑀧𑀣𑀯𑀻 𑀓𑀫𑁆𑀧𑀺, 𑀲𑀺𑀦𑁂𑀭𑀼𑀯𑀦𑀯𑀝𑀁𑀲𑀓𑀸.

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

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

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀲𑀲𑀓𑁄 𑀧𑀯𑀦𑀘𑀸𑀭𑀓𑁄;

𑀢𑀺𑀡𑀧𑀡𑁆𑀡𑀲𑀸𑀓𑀨𑀮𑀪𑀓𑁆𑀔𑁄, 𑀧𑀭𑀳𑁂𑀞𑀦𑀯𑀺𑀯𑀚𑁆𑀚𑀺𑀢𑁄.

‘‘𑀫𑀓𑁆𑀓𑀝𑁄 𑀘 𑀲𑀺𑀗𑁆𑀕𑀸𑀮𑁄 𑀘, 𑀲𑀼𑀢𑁆𑀢𑀧𑁄𑀢𑁄 𑀘𑀳𑀁 𑀢𑀤𑀸;

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

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

‘𑀧𑀸𑀧𑀸𑀦𑀺 𑀧𑀭𑀺𑀯𑀚𑁆𑀚𑁂𑀣, 𑀓𑀮𑁆𑀬𑀸𑀡𑁂 𑀅𑀪𑀺𑀦𑀺𑀯𑀺𑀲𑁆𑀲𑀣’.

‘‘𑀉𑀧𑁄𑀲𑀣𑀫𑁆𑀳𑀺 𑀤𑀺𑀯𑀲𑁂, 𑀘𑀦𑁆𑀤𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀧𑀽𑀭𑀺𑀢𑀁;

𑀏𑀢𑁂𑀲𑀁 𑀢𑀢𑁆𑀣 𑀆𑀘𑀺𑀓𑁆𑀔𑀺𑀁, 𑀤𑀺𑀯𑀲𑁄 𑀅𑀚𑁆𑀚𑀼𑀧𑁄𑀲𑀣𑁄.

‘‘𑀤𑀸𑀦𑀸𑀦𑀺 𑀧𑀝𑀺𑀬𑀸𑀤𑁂𑀣, 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑀲𑁆𑀲 𑀤𑀸𑀢𑀯𑁂;

𑀤𑀢𑁆𑀯𑀸 𑀤𑀸𑀦𑀁 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑁂, 𑀉𑀧𑀯𑀲𑁆𑀲𑀣𑀼𑀧𑁄𑀲𑀣𑀁.

‘‘𑀢𑁂 ¶ 𑀫𑁂 𑀲𑀸𑀥𑀽𑀢𑀺 𑀯𑀢𑁆𑀯𑀸𑀦, 𑀬𑀣𑀸𑀲𑀢𑁆𑀢𑀺 𑀬𑀣𑀸𑀩𑀮𑀁;

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

‘‘𑀅𑀳𑀁 𑀦𑀺𑀲𑀚𑁆𑀚 𑀘𑀺𑀦𑁆𑀢𑁂𑀲𑀺𑀁, 𑀤𑀸𑀦𑀁 𑀤𑀓𑁆𑀔𑀺𑀡𑀦𑀼𑀘𑁆𑀙𑀯𑀁;

‘𑀬𑀤𑀺𑀳𑀁 𑀮𑀪𑁂 𑀤𑀓𑁆𑀔𑀺𑀡𑁂𑀬𑁆𑀬𑀁, 𑀓𑀺𑀁 𑀫𑁂 𑀤𑀸𑀦𑀁 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺.

‘‘‘𑀦 ¶ 𑀫𑁂 𑀅𑀢𑁆𑀣𑀺 𑀢𑀺𑀮𑀸 𑀫𑀼𑀕𑁆𑀕𑀸, 𑀫𑀸𑀲𑀸 𑀯𑀸 𑀢𑀡𑁆𑀟𑀼𑀮𑀸 𑀖𑀢𑀁;

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

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

𑀤𑀚𑁆𑀚𑀸𑀳𑀁 𑀲𑀓𑀫𑀢𑁆𑀢𑀸𑀦𑀁, 𑀦 𑀲𑁄 𑀢𑀼𑀘𑁆𑀙𑁄 𑀕𑀫𑀺𑀲𑁆𑀲𑀢𑀺’.

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

𑀆𑀲𑀬𑀁 𑀫𑁂 𑀉𑀧𑀸𑀕𑀘𑁆𑀙𑀺, 𑀤𑀸𑀦𑀯𑀻𑀫𑀁𑀲𑀦𑀸𑀬 𑀫𑁂.

‘‘𑀢𑀫𑀳𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀲𑀦𑁆𑀢𑀼𑀝𑁆𑀞𑁄, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺𑀁;

‘𑀲𑀸𑀥𑀼 𑀔𑁄𑀲𑀺 𑀅𑀦𑀼𑀧𑁆𑀧𑀢𑁆𑀢𑁄, 𑀖𑀸𑀲𑀳𑁂𑀢𑀼 𑀫𑀫𑀦𑁆𑀢𑀺𑀓𑁂.

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

𑀢𑀼𑀯𑀁 𑀲𑀻𑀮𑀕𑀼𑀡𑀽𑀧𑁂𑀢𑁄, 𑀅𑀬𑀼𑀢𑁆𑀢𑀁 𑀢𑁂 𑀧𑀭𑀳𑁂𑀞𑀦𑀁.

‘‘‘𑀏𑀳𑀺 𑀅𑀕𑁆𑀕𑀺𑀁 𑀧𑀤𑀻𑀧𑁂𑀳𑀺, 𑀦𑀸𑀦𑀸𑀓𑀝𑁆𑀞𑁂 𑀲𑀫𑀸𑀦𑀬;

𑀅𑀳𑀁 𑀧𑀘𑀺𑀲𑁆𑀲𑀫𑀢𑁆𑀢𑀸𑀦𑀁, 𑀧𑀓𑁆𑀓𑀁 𑀢𑁆𑀯𑀁 𑀪𑀓𑁆𑀔𑀬𑀺𑀲𑁆𑀲𑀲𑀺’.

‘‘‘𑀲𑀸𑀥𑀽’𑀢𑀺 𑀲𑁄 𑀳𑀝𑁆𑀞𑀫𑀦𑁄, 𑀦𑀸𑀦𑀸𑀓𑀝𑁆𑀞𑁂 𑀲𑀫𑀸𑀦𑀬𑀺;

𑀫𑀳𑀦𑁆𑀢𑀁 𑀅𑀓𑀸𑀲𑀺 𑀘𑀺𑀢𑀓𑀁, 𑀓𑀢𑁆𑀯𑀸 𑀅𑀗𑁆𑀕𑀸𑀭𑀕𑀩𑁆𑀪𑀓𑀁.

‘‘𑀅𑀕𑁆𑀕𑀺𑀁 𑀢𑀢𑁆𑀣 𑀧𑀤𑀻𑀧𑁂𑀲𑀺, 𑀬𑀣𑀸 𑀲𑁄 𑀔𑀺𑀧𑁆𑀧𑀁 𑀫𑀳𑀸 𑀪𑀯𑁂;

𑀨𑁄𑀝𑁂𑀢𑁆𑀯𑀸 𑀭𑀚𑀕𑀢𑁂 𑀕𑀢𑁆𑀢𑁂, 𑀏𑀓𑀫𑀦𑁆𑀢𑀁 𑀉𑀧𑀸𑀯𑀺𑀲𑀺𑀁.

‘‘𑀬𑀤𑀸 ¶ 𑀫𑀳𑀸𑀓𑀝𑁆𑀞𑀧𑀼𑀜𑁆𑀚𑁄, 𑀆𑀤𑀺𑀢𑁆𑀢𑁄 𑀥𑀫𑀥𑀫𑀸𑀬𑀢𑀺 [𑀥𑀼𑀫𑀥𑀼𑀫𑀸𑀬𑀢𑀺 (𑀲𑀻.), 𑀥𑀫𑀫𑀸𑀬𑀢𑀺 (𑀓.)];

𑀢𑀤𑀼𑀧𑁆𑀧𑀢𑀺𑀢𑁆𑀯𑀸 𑀧𑀧𑀢𑀺𑀁, 𑀫𑀚𑁆𑀛𑁂 𑀚𑀸𑀮𑀲𑀺𑀔𑀦𑁆𑀢𑀭𑁂.

‘‘𑀬𑀣𑀸 ¶ 𑀲𑀻𑀢𑁄𑀤𑀓𑀁 𑀦𑀸𑀫, 𑀧𑀯𑀺𑀝𑁆𑀞𑀁 𑀬𑀲𑁆𑀲 𑀓𑀲𑁆𑀲𑀘𑀺;

𑀲𑀫𑁂𑀢𑀺 𑀤𑀭𑀣𑀧𑀭𑀺𑀴𑀸𑀳𑀁, 𑀅𑀲𑁆𑀲𑀸𑀤𑀁 𑀤𑁂𑀢𑀺 𑀧𑀻𑀢𑀺 𑀘.

‘‘𑀢𑀣𑁂𑀯 𑀚𑀮𑀺𑀢𑀁 𑀅𑀕𑁆𑀕𑀺𑀁, 𑀧𑀯𑀺𑀝𑁆𑀞𑀲𑁆𑀲 𑀫𑀫𑀁 𑀢𑀤𑀸;

𑀲𑀩𑁆𑀩𑀁 𑀲𑀫𑁂𑀢𑀺 𑀤𑀭𑀣𑀁, 𑀬𑀣𑀸 𑀲𑀻𑀢𑁄𑀤𑀓𑀁 𑀯𑀺𑀬.

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

𑀓𑁂𑀯𑀮𑀁 𑀲𑀓𑀮𑀁 𑀓𑀸𑀬𑀁, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀅𑀤𑀸𑀲𑀳’’𑀦𑁆𑀢𑀺.

𑀅𑀓𑀺𑀢𑁆𑀢𑀺𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 ¶ 𑀲𑀗𑁆𑀔𑁄, 𑀓𑀼𑀭𑀼𑀭𑀸𑀚𑀸 𑀥𑀦𑀜𑁆𑀘𑀬𑁄;

𑀫𑀳𑀸𑀲𑀼𑀤𑀲𑁆𑀲𑀦𑁄 𑀭𑀸𑀚𑀸, 𑀫𑀳𑀸𑀕𑁄𑀯𑀺𑀦𑁆𑀤𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

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

𑀅𑀳𑀫𑁂𑀯 𑀢𑀤𑀸 𑀆𑀲𑀺𑀁, 𑀬𑁄 𑀢𑁂 𑀤𑀸𑀦𑀯𑀭𑁂 𑀅𑀤𑀸.

𑀏𑀢𑁂 𑀤𑀸𑀦𑀧𑀭𑀺𑀓𑁆𑀔𑀸𑀭𑀸, 𑀏𑀢𑁂 𑀤𑀸𑀦𑀲𑁆𑀲 𑀧𑀸𑀭𑀫𑀻;

𑀚𑀻𑀯𑀺𑀢𑀁 𑀬𑀸𑀘𑀓𑁂 𑀤𑀢𑁆𑀯𑀸, 𑀇𑀫𑀁 𑀧𑀸𑀭𑀫𑀺 𑀧𑀽𑀭𑀬𑀺𑀁.

𑀪𑀺𑀓𑁆𑀔𑀸𑀬 𑀉𑀧𑀕𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀲𑀓𑀢𑁆𑀢𑀸𑀦𑀁 𑀧𑀭𑀺𑀘𑁆𑀘𑀚𑀺𑀁;

𑀤𑀸𑀦𑁂𑀦 𑀫𑁂 𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀤𑀸𑀦𑀧𑀸𑀭𑀫𑀻𑀢𑀺.

𑀤𑀸𑀦𑀧𑀸𑀭𑀫𑀺𑀦𑀺𑀤𑁆𑀤𑁂𑀲𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

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

𑀦 𑀢𑀤𑀸 𑀅𑀢𑁆𑀣𑀺 𑀫𑀳𑀺𑀬𑀸, 𑀕𑀼𑀡𑁂𑀦 𑀫𑀫 𑀲𑀸𑀤𑀺𑀲𑁄.

‘‘𑀧𑀯𑀦𑁂 𑀤𑀺𑀲𑁆𑀯𑀸 𑀯𑀦𑀘𑀭𑁄, 𑀭𑀜𑁆𑀜𑁄 𑀫𑀁 𑀧𑀝𑀺𑀯𑁂𑀤𑀬𑀺;

‘𑀢𑀯𑀸𑀦𑀼𑀘𑁆𑀙𑀯𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀕𑀚𑁄 𑀯𑀲𑀢𑀺 𑀓𑀸𑀦𑀦𑁂.

‘‘‘𑀦 𑀢𑀲𑁆𑀲 𑀧𑀭𑀺𑀓𑁆𑀔𑀸𑀬𑀢𑁆𑀣𑁄, 𑀦𑀧𑀺 𑀆𑀴𑀓𑀓𑀸𑀲𑀼𑀬𑀸;

𑀲𑀳 𑀕𑀳𑀺𑀢𑁂 [𑀲𑀫𑀁 𑀕𑀳𑀺𑀢𑁂 (𑀲𑀻.)] 𑀲𑁄𑀡𑁆𑀟𑀸𑀬, 𑀲𑀬𑀫𑁂𑀯 𑀇𑀥𑁂𑀳𑀺’𑀢𑀺.

‘‘𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀭𑀸𑀚𑀸𑀧𑀺 𑀢𑀼𑀝𑁆𑀞𑀫𑀸𑀦𑀲𑁄;

𑀧𑁂𑀲𑁂𑀲𑀺 𑀳𑀢𑁆𑀣𑀺𑀤𑀫𑀓𑀁, 𑀙𑁂𑀓𑀸𑀘𑀭𑀺𑀬𑀁 𑀲𑀼𑀲𑀺𑀓𑁆𑀔𑀺𑀢𑀁.

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

𑀪𑀺𑀲𑀫𑀼𑀴𑀸𑀮𑀁 [𑀪𑀺𑀲𑀫𑀽𑀮𑀁 (𑀓.)] 𑀉𑀤𑁆𑀥𑀭𑀦𑁆𑀢𑀁, 𑀬𑀸𑀧𑀦𑀢𑁆𑀣𑀸𑀬 𑀫𑀸𑀢𑀼𑀬𑀸.

‘‘𑀯𑀺𑀜𑁆𑀜𑀸𑀬 𑀫𑁂 𑀲𑀻𑀮𑀕𑀼𑀡𑀁, 𑀮𑀓𑁆𑀔𑀡𑀁 𑀉𑀧𑀥𑀸𑀭𑀬𑀺;

‘𑀏𑀳𑀺 𑀧𑀼𑀢𑁆𑀢𑀸’𑀢𑀺 𑀧𑀢𑁆𑀯𑀸𑀦, 𑀫𑀫 𑀲𑁄𑀡𑁆𑀟𑀸𑀬 𑀅𑀕𑁆𑀕𑀳𑀺.

‘‘𑀬𑀁 𑀫𑁂 𑀢𑀤𑀸 𑀧𑀸𑀓𑀢𑀺𑀓𑀁, 𑀲𑀭𑀻𑀭𑀸𑀦𑀼𑀕𑀢𑀁 𑀩𑀮𑀁;

𑀅𑀚𑁆𑀚 𑀦𑀸𑀕𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀁, 𑀩𑀮𑁂𑀦 𑀲𑀫𑀲𑀸𑀤𑀺𑀲𑀁.

‘‘𑀬𑀤𑀺𑀳𑀁 𑀢𑁂𑀲𑀁 𑀧𑀓𑀼𑀧𑁆𑀧𑁂𑀬𑁆𑀬𑀁, 𑀉𑀧𑁂𑀢𑀸𑀦𑀁 𑀕𑀳𑀡𑀸𑀬 𑀫𑀁;

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

‘‘𑀅𑀧𑀺 ¶ 𑀘𑀸𑀳𑀁 𑀲𑀻𑀮𑀭𑀓𑁆𑀔𑀸𑀬, 𑀲𑀻𑀮𑀧𑀸𑀭𑀫𑀺𑀧𑀽𑀭𑀺𑀬𑀸;

𑀦 𑀓𑀭𑁄𑀫𑀺 𑀘𑀺𑀢𑁆𑀢𑁂 𑀅𑀜𑁆𑀜𑀣𑀢𑁆𑀢𑀁, 𑀧𑀓𑁆𑀔𑀺𑀧𑀦𑁆𑀢𑀁 𑀫𑀫𑀸𑀴𑀓𑁂.

‘‘𑀬𑀤𑀺 𑀢𑁂 𑀫𑀁 𑀢𑀢𑁆𑀣 𑀓𑁄𑀝𑁆𑀝𑁂𑀬𑁆𑀬𑀼𑀁, 𑀨𑀭𑀲𑀽𑀳𑀺 𑀢𑁄𑀫𑀭𑁂𑀳𑀺 𑀘;

𑀦𑁂𑀯 𑀢𑁂𑀲𑀁 𑀧𑀓𑀼𑀧𑁆𑀧𑁂𑀬𑁆𑀬𑀁, 𑀲𑀻𑀮𑀔𑀡𑁆𑀟𑀪𑀬𑀸 𑀫𑀫𑀸’’𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ ¶ ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀪𑀽𑀭𑀺𑀤𑀢𑁆𑀢𑁄 𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑁄;

𑀯𑀺𑀭𑀽𑀧𑀓𑁆𑀔𑁂𑀦 𑀫𑀳𑀸𑀭𑀜𑁆𑀜𑀸, 𑀤𑁂𑀯𑀮𑁄𑀓𑀫𑀕𑀜𑁆𑀙𑀳𑀁.

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

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

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

𑀘𑀢𑀼𑀭𑁄 𑀅𑀗𑁆𑀕𑁂 𑀅𑀥𑀺𑀝𑁆𑀞𑀸𑀬, 𑀲𑁂𑀫𑀺 𑀯𑀫𑁆𑀫𑀺𑀓𑀫𑀼𑀤𑁆𑀥𑀦𑀺.

‘‘𑀙𑀯𑀺𑀬𑀸 𑀘𑀫𑁆𑀫𑁂𑀦 𑀫𑀁𑀲𑁂𑀦, 𑀦𑀳𑀸𑀭𑀼𑀅𑀝𑁆𑀞𑀺𑀓𑁂𑀳𑀺 𑀯𑀸;

𑀬𑀲𑁆𑀲 𑀏𑀢𑁂𑀦 𑀓𑀭𑀡𑀻𑀬𑀁, 𑀤𑀺𑀦𑁆𑀦𑀁𑀬𑁂𑀯 𑀳𑀭𑀸𑀢𑀼 𑀲𑁄.

‘‘𑀲𑀁𑀲𑀺𑀢𑁄 𑀅𑀓𑀢𑀜𑁆𑀜𑀼𑀦𑀸, 𑀆𑀮𑀫𑁆𑀧𑀸𑀬𑀦𑁄 [𑀆𑀮𑀫𑁆𑀩𑀡𑁄 (𑀲𑀻.)] 𑀫𑀫𑀕𑁆𑀕𑀳𑀺;

𑀧𑁂𑀴𑀸𑀬 𑀧𑀓𑁆𑀔𑀺𑀧𑀺𑀢𑁆𑀯𑀸𑀦, 𑀓𑀻𑀴𑁂𑀢𑀺 𑀫𑀁 𑀢𑀳𑀺𑀁 𑀢𑀳𑀺𑀁.

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

𑀆𑀮𑀫𑁆𑀧𑀸𑀬𑀦𑁂 [𑀆𑀮𑀫𑁆𑀩𑀡𑁂 (𑀲𑀻.)] 𑀦 𑀓𑀼𑀧𑁆𑀧𑀸𑀫𑀺, 𑀲𑀻𑀮𑀔𑀡𑁆𑀟𑀪𑀬𑀸 𑀫𑀫.

‘‘𑀲𑀓𑀚𑀻𑀯𑀺𑀢𑀧𑀭𑀺𑀘𑁆𑀘𑀸𑀕𑁄 ¶ , 𑀢𑀺𑀡𑀢𑁄 𑀮𑀳𑀼𑀓𑁄 𑀫𑀫;

𑀲𑀻𑀮𑀯𑀻𑀢𑀺𑀓𑁆𑀓𑀫𑁄 𑀫𑀬𑁆𑀳𑀁, 𑀧𑀣𑀯𑀻𑀉𑀧𑁆𑀧𑀢𑀦𑀁 𑀯𑀺𑀬.

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

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

‘‘𑀅𑀧𑀺 𑀘𑀸𑀳𑀁 𑀲𑀻𑀮𑀭𑀓𑁆𑀔𑀸𑀬, 𑀲𑀻𑀮𑀧𑀸𑀭𑀫𑀺𑀧𑀽𑀭𑀺𑀬𑀸;

𑀦 𑀓𑀭𑁄𑀫𑀺 𑀘𑀺𑀢𑁆𑀢𑁂 𑀅𑀜𑁆𑀜𑀣𑀢𑁆𑀢𑀁, 𑀧𑀓𑁆𑀔𑀺𑀧𑀦𑁆𑀢𑀫𑁆𑀧𑀺 𑀧𑁂𑀴𑀓𑁂’’𑀢𑀺.

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

𑀢𑀤𑀸𑀧𑀺 𑀥𑀫𑁆𑀫𑀺𑀓𑁄 𑀆𑀲𑀺𑀁, 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑀲𑀫𑀧𑁆𑀧𑀺𑀢𑁄.

‘‘𑀢𑀤𑀸𑀧𑀺 ¶ 𑀫𑀁 𑀥𑀫𑁆𑀫𑀘𑀸𑀭𑀺𑀁, 𑀉𑀧𑀯𑀼𑀢𑁆𑀣𑀁 𑀉𑀧𑁄𑀲𑀣𑀁;

𑀅𑀳𑀺𑀢𑀼𑀡𑁆𑀟𑀺𑀓𑁄 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀭𑀸𑀚𑀤𑁆𑀯𑀸𑀭𑀫𑁆𑀳𑀺 𑀓𑀻𑀴𑀢𑀺.

‘‘𑀬𑀁 ¶ 𑀬𑀁 𑀲𑁄 𑀯𑀡𑁆𑀡𑀁 𑀘𑀺𑀦𑁆𑀢𑀬𑀺, 𑀦𑀻𑀮𑀁𑀯 𑀧𑀻𑀢𑀮𑁄𑀳𑀺𑀢𑀁;

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

‘‘𑀣𑀮𑀁 ¶ 𑀓𑀭𑁂𑀬𑁆𑀬𑀫𑀼𑀤𑀓𑀁, 𑀉𑀤𑀓𑀫𑁆𑀧𑀺 𑀣𑀮𑀁 𑀓𑀭𑁂;

𑀬𑀤𑀺𑀳𑀁 𑀢𑀲𑁆𑀲 𑀧𑀓𑀼𑀧𑁆𑀧𑁂𑀬𑁆𑀬𑀁, 𑀔𑀡𑁂𑀦 𑀙𑀸𑀭𑀺𑀓𑀁 𑀓𑀭𑁂.

‘‘𑀬𑀤𑀺 𑀘𑀺𑀢𑁆𑀢𑀯𑀲𑀻 𑀳𑁂𑀲𑁆𑀲𑀁, 𑀧𑀭𑀺𑀳𑀸𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀲𑀻𑀮𑀢𑁄;

𑀲𑀻𑀮𑁂𑀦 𑀧𑀭𑀺𑀳𑀻𑀦𑀲𑁆𑀲, 𑀉𑀢𑁆𑀢𑀫𑀢𑁆𑀣𑁄 𑀦 𑀲𑀺𑀚𑁆𑀛𑀢𑀺.

‘‘𑀓𑀸𑀫𑀁 ¶ 𑀪𑀺𑀚𑁆𑀚𑀢𑀼𑀬𑀁 𑀓𑀸𑀬𑁄, 𑀇𑀥𑁂𑀯 𑀯𑀺𑀓𑀺𑀭𑀻𑀬𑀢𑀼;

𑀦𑁂𑀯 𑀲𑀻𑀮𑀁 𑀧𑀪𑀺𑀦𑁆𑀤𑁂𑀬𑁆𑀬𑀁, 𑀯𑀺𑀓𑀺𑀭𑀦𑁆𑀢𑁂 𑀪𑀼𑀲𑀁 𑀯𑀺𑀬𑀸’’𑀢𑀺.

𑀘𑀫𑁆𑀧𑁂𑀬𑁆𑀬𑀦𑀸𑀕𑀘𑀭𑀺𑀬𑀁 𑀢𑀢𑀺𑀬𑀁.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀘𑀽𑀴𑀩𑁄𑀥𑀺 𑀲𑀼𑀲𑀻𑀮𑀯𑀸;

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

‘‘𑀬𑀸 𑀫𑁂 𑀤𑀼𑀢𑀺𑀬𑀺𑀓𑀸 𑀆𑀲𑀺, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀻 𑀓𑀦𑀓𑀲𑀦𑁆𑀦𑀺𑀪𑀸;

𑀲𑀸𑀧𑀺 𑀯𑀝𑁆𑀝𑁂 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑀸, 𑀦𑁂𑀓𑁆𑀔𑀫𑁆𑀫𑀁 𑀅𑀪𑀺𑀦𑀺𑀓𑁆𑀔𑀫𑀺.

‘‘𑀦𑀺𑀭𑀸𑀮𑀬𑀸 𑀙𑀺𑀦𑁆𑀦𑀩𑀦𑁆𑀥𑀽, 𑀅𑀦𑀧𑁂𑀓𑁆𑀔𑀸 𑀓𑀼𑀮𑁂 𑀕𑀡𑁂;

𑀘𑀭𑀦𑁆𑀢𑀸 𑀕𑀸𑀫𑀦𑀺𑀕𑀫𑀁, 𑀩𑀸𑀭𑀸𑀡𑀲𑀺𑀫𑀼𑀧𑀸𑀕𑀫𑀼𑀁.

‘‘𑀢𑀢𑁆𑀣 𑀯𑀲𑀸𑀫 𑀦𑀺𑀧𑀓𑀸, 𑀅𑀲𑀁𑀲𑀝𑁆𑀞𑀸 𑀓𑀼𑀮𑁂 𑀕𑀡𑁂;

𑀦𑀺𑀭𑀸𑀓𑀼𑀮𑁂 𑀅𑀧𑁆𑀧𑀲𑀤𑁆𑀤𑁂, 𑀭𑀸𑀚𑀼𑀬𑁆𑀬𑀸𑀦𑁂 𑀯𑀲𑀸𑀫𑀼𑀪𑁄.

‘‘𑀉𑀬𑁆𑀬𑀸𑀦𑀤𑀲𑁆𑀲𑀦𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀭𑀸𑀚𑀸 𑀅𑀤𑁆𑀤𑀲 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀺𑀁;

𑀉𑀧𑀕𑀫𑁆𑀫 𑀫𑀫𑀁 𑀧𑀼𑀘𑁆𑀙𑀺, ‘𑀢𑀼𑀬𑁆𑀳𑁂𑀲𑀸 𑀓𑀸 𑀓𑀲𑁆𑀲 𑀪𑀭𑀺𑀬𑀸’.

‘‘𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁂 𑀅𑀳𑀁 𑀢𑀲𑁆𑀲, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺𑀁;

‘𑀦 𑀫𑀬𑁆𑀳𑀁 𑀪𑀭𑀺𑀬𑀸 𑀏𑀲𑀸, 𑀲𑀳𑀥𑀫𑁆𑀫𑀸 𑀏𑀓𑀲𑀸𑀲𑀦𑀻’.

‘‘𑀢𑀺𑀲𑁆𑀲𑀸 ¶ [𑀢𑀲𑁆𑀲𑀸 (𑀲𑀻.)] 𑀲𑀸𑀭𑀢𑁆𑀢𑀕𑀥𑀺𑀢𑁄, 𑀕𑀸𑀳𑀸𑀧𑁂𑀢𑁆𑀯𑀸𑀦 𑀘𑁂𑀝𑀓𑁂;

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

‘‘𑀑𑀤𑀧𑀢𑁆𑀢𑀓𑀺𑀬𑀸 ¶ 𑀫𑀬𑁆𑀳𑀁, 𑀲𑀳𑀚𑀸 𑀏𑀓𑀲𑀸𑀲𑀦𑀻;

𑀆𑀓𑀟𑁆𑀠𑀺𑀢𑁆𑀯𑀸 𑀦𑀬𑀦𑁆𑀢𑀺𑀬𑀸, 𑀓𑁄𑀧𑁄 𑀫𑁂 𑀉𑀧𑀧𑀚𑁆𑀚𑀣.

‘‘𑀲𑀳 ¶ 𑀓𑁄𑀧𑁂 𑀲𑀫𑀼𑀧𑁆𑀧𑀦𑁆𑀦𑁂, 𑀲𑀻𑀮𑀩𑁆𑀩𑀢𑀫𑀦𑀼𑀲𑁆𑀲𑀭𑀺𑀁;

𑀢𑀢𑁆𑀣𑁂𑀯 𑀓𑁄𑀧𑀁 𑀦𑀺𑀕𑁆𑀕𑀡𑁆𑀳𑀺𑀁, 𑀦𑀸𑀤𑀸𑀲𑀺𑀁 𑀯𑀟𑁆𑀠𑀺𑀢𑀽𑀧𑀭𑀺.

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

𑀦𑁂𑀯 𑀲𑀻𑀮𑀁 𑀧𑀪𑀺𑀦𑁆𑀤𑁂𑀬𑁆𑀬𑀁, 𑀩𑁄𑀥𑀺𑀬𑀸𑀬𑁂𑀯 𑀓𑀸𑀭𑀡𑀸.

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

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀺𑀬𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀲𑀻𑀮𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀺𑀲’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀫𑀳𑀺𑀁𑀲𑁄 𑀧𑀯𑀦𑀘𑀸𑀭𑀓𑁄;

𑀧𑀯𑀟𑁆𑀠𑀓𑀸𑀬𑁄 𑀩𑀮𑀯𑀸, 𑀫𑀳𑀦𑁆𑀢𑁄 𑀪𑀻𑀫𑀤𑀲𑁆𑀲𑀦𑁄.

‘‘𑀧𑀩𑁆𑀪𑀸𑀭𑁂 𑀕𑀺𑀭𑀺𑀤𑀼𑀕𑁆𑀕𑁂 [𑀯𑀦𑀤𑀼𑀕𑁆𑀕𑁂 (𑀲𑀻.)] 𑀘, 𑀭𑀼𑀓𑁆𑀔𑀫𑀽𑀮𑁂 𑀤𑀓𑀸𑀲𑀬𑁂;

𑀳𑁄𑀢𑁂𑀢𑁆𑀣 𑀞𑀸𑀦𑀁 𑀫𑀳𑀺𑀁𑀲𑀸𑀦𑀁, 𑀓𑁄𑀘𑀺 𑀓𑁄𑀘𑀺 𑀢𑀳𑀺𑀁 𑀢𑀳𑀺𑀁.

‘‘𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑁄 𑀩𑁆𑀭𑀳𑀸𑀭𑀜𑁆𑀜𑁂, 𑀞𑀸𑀦𑀁 𑀅𑀤𑁆𑀤𑀲 𑀪𑀤𑁆𑀤𑀓𑀁;

𑀢𑀁 𑀞𑀸𑀦𑀁 𑀉𑀧𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦, 𑀢𑀺𑀝𑁆𑀞𑀸𑀫𑀺 𑀘 𑀲𑀬𑀸𑀫𑀺 𑀘.

‘‘𑀅𑀣𑁂𑀢𑁆𑀣 𑀓𑀧𑀺𑀫𑀸𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀧𑀸𑀧𑁄 𑀅𑀦𑀭𑀺𑀬𑁄 𑀮𑀳𑀼;

𑀔𑀦𑁆𑀥𑁂 𑀦𑀮𑀸𑀝𑁂 𑀪𑀫𑀼𑀓𑁂, 𑀫𑀼𑀢𑁆𑀢𑁂𑀢𑀺 𑀑𑀳𑀦𑁂𑀢𑀺𑀢𑀁.

‘‘𑀲𑀓𑀺𑀫𑁆𑀧𑀺 𑀤𑀺𑀯𑀲𑀁 𑀤𑀼𑀢𑀺𑀬𑀁, 𑀢𑀢𑀺𑀬𑀁 𑀘𑀢𑀼𑀢𑁆𑀣𑀫𑁆𑀧𑀺 𑀘;

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

‘‘𑀫𑀫𑀁 ¶ 𑀉𑀧𑀤𑁆𑀤𑀼𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀬𑀓𑁆𑀔𑁄 𑀫𑀁 𑀇𑀤𑀫𑀩𑁆𑀭𑀯𑀺;

‘𑀦𑀸𑀲𑁂𑀳𑁂𑀢𑀁 𑀙𑀯𑀁 𑀧𑀸𑀧𑀁, 𑀲𑀺𑀗𑁆𑀕𑁂𑀳𑀺 𑀘 𑀔𑀼𑀭𑁂𑀳𑀺 𑀘’.

‘‘𑀏𑀯𑀁 ¶ 𑀯𑀼𑀢𑁆𑀢𑁂 𑀢𑀤𑀸 𑀬𑀓𑁆𑀔𑁂, 𑀅𑀳𑀁 𑀢𑀁 𑀇𑀤𑀫𑀩𑁆𑀭𑀯𑀺𑀁;

‘𑀓𑀺𑀁 𑀢𑁆𑀯𑀁 𑀫𑀓𑁆𑀔𑁂𑀲𑀺 𑀓𑀼𑀡𑀧𑁂𑀦, 𑀧𑀸𑀧𑁂𑀦 𑀅𑀦𑀭𑀺𑀬𑁂𑀦 𑀫𑀁.

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

𑀲𑀻𑀮𑀜𑁆𑀘 𑀫𑁂 𑀧𑀪𑀺𑀚𑁆𑀚𑁂𑀬𑁆𑀬, 𑀯𑀺𑀜𑁆𑀜𑀽 𑀘 𑀕𑀭𑀳𑁂𑀬𑁆𑀬𑀼 𑀫𑀁.

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

𑀓𑁆𑀬𑀸𑀳𑀁 𑀚𑀻𑀯𑀺𑀢𑀳𑁂𑀢𑀽𑀧𑀺, 𑀓𑀸𑀳𑀸𑀫𑀺𑀁 𑀧𑀭𑀳𑁂𑀞𑀦𑀁’.

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

𑀢𑁂𑀯 𑀢𑀲𑁆𑀲 𑀯𑀥𑀺𑀲𑁆𑀲𑀦𑁆𑀢𑀺, 𑀲𑀸 𑀫𑁂 𑀫𑀼𑀢𑁆𑀢𑀺 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺.

‘‘𑀳𑀻𑀦𑀫𑀚𑁆𑀛𑀺𑀫𑀉𑀓𑁆𑀓𑀝𑁆𑀞𑁂, 𑀲𑀳𑀦𑁆𑀢𑁄 𑀅𑀯𑀫𑀸𑀦𑀺𑀢𑀁;

𑀏𑀯𑀁 𑀮𑀪𑀢𑀺 𑀲𑀧𑁆𑀧𑀜𑁆𑀜𑁄, 𑀫𑀦𑀲𑀸 𑀬𑀣𑀸 𑀧𑀢𑁆𑀣𑀺𑀢’’𑀦𑁆𑀢𑀺.

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

𑀫𑀺𑀕𑀭𑀸𑀚𑀸 𑀭𑀼𑀭𑀼𑀦𑀸𑀫, 𑀧𑀭𑀫𑀲𑀻𑀮𑀲𑀫𑀸𑀳𑀺𑀢𑁄.

‘‘𑀭𑀫𑁆𑀫𑁂 𑀧𑀤𑁂𑀲𑁂 𑀭𑀫𑀡𑀻𑀬𑁂, 𑀯𑀺𑀯𑀺𑀢𑁆𑀢𑁂 𑀅𑀫𑀦𑀼𑀲𑁆𑀲𑀓𑁂;

𑀢𑀢𑁆𑀣 𑀯𑀸𑀲𑀁 𑀉𑀧𑀕𑀜𑁆𑀙𑀺𑀁, 𑀕𑀗𑁆𑀕𑀸𑀓𑀽𑀮𑁂 𑀫𑀦𑁄𑀭𑀫𑁂.

‘‘𑀅𑀣 ¶ 𑀉𑀧𑀭𑀺 𑀕𑀗𑁆𑀕𑀸𑀬, 𑀥𑀦𑀺𑀓𑁂𑀳𑀺 𑀧𑀭𑀺𑀧𑀻𑀴𑀺𑀢𑁄;

𑀧𑀼𑀭𑀺𑀲𑁄 𑀕𑀗𑁆𑀕𑀸𑀬 𑀧𑀧𑀢𑀺, ‘𑀚𑀻𑀯𑀸𑀫𑀺 𑀯𑀸 𑀫𑀭𑀸𑀫𑀺 𑀯𑀸’.

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

𑀭𑀯𑀦𑁆𑀢𑁄 𑀓𑀭𑀼𑀡𑀁 𑀭𑀯𑀁, 𑀫𑀚𑁆𑀛𑁂 𑀕𑀗𑁆𑀕𑀸𑀬 𑀕𑀘𑁆𑀙𑀢𑀺.

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

𑀕𑀗𑁆𑀕𑀸𑀬 𑀢𑀻𑀭𑁂 𑀞𑀢𑁆𑀯𑀸𑀦, 𑀅𑀧𑀼𑀘𑁆𑀙𑀺𑀁 ‘𑀓𑁄𑀲𑀺 𑀢𑁆𑀯𑀁 𑀦𑀭𑁄’.

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

‘𑀥𑀦𑀺𑀓𑁂𑀳𑀺 𑀪𑀻𑀢𑁄 𑀢𑀲𑀺𑀢𑁄, 𑀧𑀓𑁆𑀔𑀦𑁆𑀤𑁄𑀳𑀁 𑀫𑀳𑀸𑀦𑀤𑀺𑀁’.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀓𑀢𑁆𑀯𑀸𑀦 𑀓𑀸𑀭𑀼𑀜𑁆𑀜𑀁, 𑀘𑀚𑀺𑀢𑁆𑀯𑀸 𑀫𑀫 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀧𑀯𑀺𑀲𑀺𑀢𑁆𑀯𑀸 𑀦𑀻𑀳𑀭𑀺𑀁 𑀢𑀲𑁆𑀲, 𑀅𑀦𑁆𑀥𑀓𑀸𑀭𑀫𑁆𑀳𑀺 𑀭𑀢𑁆𑀢𑀺𑀬𑀸.

‘‘𑀅𑀲𑁆𑀲𑀢𑁆𑀣𑀓𑀸𑀮𑀫𑀜𑁆𑀜𑀸𑀬, 𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀇𑀤𑀫𑀩𑁆𑀭𑀯𑀺𑀁;

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

‘‘𑀦𑀕𑀭𑀁 ¶ 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦 𑀆𑀘𑀺𑀓𑁆𑀔𑀺, 𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁄 𑀥𑀦𑀳𑁂𑀢𑀼𑀓𑁄;

𑀭𑀸𑀚𑀸𑀦𑀁 𑀲𑁄 𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀉𑀧𑀕𑀜𑁆𑀙𑀺 𑀫𑀫𑀦𑁆𑀢𑀺𑀓𑀁.

‘‘𑀬𑀸𑀯𑀢𑀸 𑀓𑀭𑀡𑀁 𑀲𑀩𑁆𑀩𑀁, 𑀭𑀜𑁆𑀜𑁄 𑀆𑀭𑁄𑀘𑀺𑀢𑀁 𑀫𑀬𑀸;

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

‘𑀇𑀥𑁂𑀯 𑀖𑀸𑀢𑀬𑀺𑀲𑁆𑀲𑀸𑀫𑀺, 𑀫𑀺𑀢𑁆𑀢𑀤𑀼𑀩𑁆𑀪𑀺𑀁 [𑀫𑀺𑀢𑁆𑀢𑀤𑀽𑀪𑀺𑀁 (𑀲𑀻.)] 𑀅𑀦𑀸𑀭𑀺𑀬𑀁’.

‘‘𑀢𑀫𑀳𑀁 𑀅𑀦𑀼𑀭𑀓𑁆𑀔𑀦𑁆𑀢𑁄, 𑀦𑀺𑀫𑁆𑀫𑀺𑀦𑀺𑀁 𑀫𑀫 𑀅𑀢𑁆𑀢𑀦𑀸;

‘𑀢𑀺𑀝𑁆𑀞𑀢𑁂𑀲𑁄 𑀫𑀳𑀸𑀭𑀸𑀚, 𑀓𑀸𑀫𑀓𑀸𑀭𑁄 𑀪𑀯𑀸𑀫𑀺 𑀢𑁂’.

‘‘𑀅𑀦𑀼𑀭𑀓𑁆𑀔𑀺𑀁 𑀫𑀫 𑀲𑀻𑀮𑀁, 𑀦𑀸𑀭𑀓𑁆𑀔𑀺𑀁 𑀫𑀫 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀲𑀻𑀮𑀯𑀸 𑀳𑀺 𑀢𑀤𑀸 𑀆𑀲𑀺𑀁, 𑀩𑁄𑀥𑀺𑀬𑀸𑀬𑁂𑀯 𑀓𑀸𑀭𑀡𑀸’’𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀚𑀝𑀺𑀮𑁄 𑀉𑀕𑁆𑀕𑀢𑀸𑀧𑀦𑁄;

𑀫𑀸𑀢𑀗𑁆𑀕𑁄 𑀦𑀸𑀫 𑀦𑀸𑀫𑁂𑀦, 𑀲𑀻𑀮𑀯𑀸 𑀲𑀼𑀲𑀫𑀸𑀳𑀺𑀢𑁄.

‘‘𑀅𑀳𑀜𑁆𑀘 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀏𑀓𑁄, 𑀕𑀗𑁆𑀕𑀸𑀓𑀽𑀮𑁂 𑀯𑀲𑀸𑀫𑀼𑀪𑁄;

𑀅𑀳𑀁 𑀯𑀲𑀸𑀫𑀺 𑀉𑀧𑀭𑀺, 𑀳𑁂𑀝𑁆𑀞𑀸 𑀯𑀲𑀢𑀺 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄.

‘‘𑀯𑀺𑀘𑀭𑀦𑁆𑀢𑁄 𑀅𑀦𑀼𑀓𑀽𑀮𑀫𑁆𑀳𑀺, 𑀉𑀤𑁆𑀥𑀁 𑀫𑁂 𑀅𑀲𑁆𑀲𑀫𑀤𑁆𑀤𑀲;

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

‘‘𑀬𑀤𑀺𑀳𑀁 𑀢𑀲𑁆𑀲 𑀧𑀓𑀼𑀧𑁆𑀧𑁂𑀬𑁆𑀬𑀁, 𑀬𑀤𑀺 𑀲𑀻𑀮𑀁 𑀦 𑀕𑁄𑀧𑀬𑁂;

𑀑𑀮𑁄𑀓𑁂𑀢𑁆𑀯𑀸𑀦𑀳𑀁 𑀢𑀲𑁆𑀲, 𑀓𑀭𑁂𑀬𑁆𑀬𑀁 𑀙𑀸𑀭𑀺𑀓𑀁 𑀯𑀺𑀬.

‘‘𑀬𑀁 ¶ 𑀲𑁄 𑀢𑀤𑀸 𑀫𑀁 𑀅𑀪𑀺𑀲𑀧𑀺, 𑀓𑀼𑀧𑀺𑀢𑁄 𑀤𑀼𑀝𑁆𑀞𑀫𑀸𑀦𑀲𑁄;

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

‘‘𑀅𑀦𑀼𑀭𑀓𑁆𑀔𑀺𑀁 ¶ 𑀫𑀫 𑀲𑀻𑀮𑀁, 𑀦𑀸𑀭𑀓𑁆𑀔𑀺𑀁 𑀫𑀫 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀲𑀻𑀮𑀯𑀸 𑀳𑀺 𑀢𑀤𑀸 𑀆𑀲𑀺𑀁, 𑀩𑁄𑀥𑀺𑀬𑀸𑀬𑁂𑀯 𑀓𑀸𑀭𑀡𑀸’’𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀫𑀳𑀸𑀧𑀓𑁆𑀔𑁄 𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑁄;

𑀥𑀫𑁆𑀫𑁄 𑀦𑀸𑀫 𑀫𑀳𑀸𑀬𑀓𑁆𑀔𑁄, 𑀲𑀩𑁆𑀩𑀮𑁄𑀓𑀸𑀦𑀼𑀓𑀫𑁆𑀧𑀓𑁄.

‘‘𑀤𑀲𑀓𑀼𑀲𑀮𑀓𑀫𑁆𑀫𑀧𑀣𑁂 ¶ , 𑀲𑀫𑀸𑀤𑀧𑁂𑀦𑁆𑀢𑁄 𑀫𑀳𑀸𑀚𑀦𑀁;

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

‘‘𑀧𑀸𑀧𑁄 𑀓𑀤𑀭𑀺𑀬𑁄 𑀬𑀓𑁆𑀔𑁄, 𑀤𑀻𑀧𑁂𑀦𑁆𑀢𑁄 𑀤𑀲 𑀧𑀸𑀧𑀓𑁂;

𑀲𑁄𑀧𑁂𑀢𑁆𑀣 𑀫𑀳𑀺𑀬𑀸 𑀘𑀭𑀢𑀺, 𑀲𑀫𑀺𑀢𑁆𑀢𑁄 𑀲𑀧𑀭𑀺𑀚𑁆𑀚𑀦𑁄.

‘‘𑀥𑀫𑁆𑀫𑀯𑀸𑀤𑀻 𑀅𑀥𑀫𑁆𑀫𑁄 𑀘, 𑀉𑀪𑁄 𑀧𑀘𑁆𑀘𑀦𑀺𑀓𑀸 𑀫𑀬𑀁;

𑀥𑀼𑀭𑁂 𑀥𑀼𑀭𑀁 𑀖𑀝𑁆𑀝𑀬𑀦𑁆𑀢𑀸, 𑀲𑀫𑀺𑀫𑁆𑀳𑀸 𑀧𑀝𑀺𑀧𑀣𑁂 𑀉𑀪𑁄.

‘‘𑀓𑀮𑀳𑁄 𑀯𑀢𑁆𑀢𑀢𑀻 𑀪𑁂𑀲𑁆𑀫𑀸, 𑀓𑀮𑁆𑀬𑀸𑀡𑀧𑀸𑀧𑀓𑀲𑁆𑀲 𑀘;

𑀫𑀕𑁆𑀕𑀸 𑀑𑀓𑁆𑀓𑀫𑀦𑀢𑁆𑀣𑀸𑀬, 𑀫𑀳𑀸𑀬𑀼𑀤𑁆𑀥𑁄 𑀉𑀧𑀝𑁆𑀞𑀺𑀢𑁄.

‘‘𑀬𑀤𑀺𑀳𑀁 𑀢𑀲𑁆𑀲 𑀓𑀼𑀧𑁆𑀧𑁂𑀬𑁆𑀬𑀁, 𑀬𑀤𑀺 𑀪𑀺𑀦𑁆𑀤𑁂 𑀢𑀧𑁄𑀕𑀼𑀡𑀁;

𑀲𑀳𑀧𑀭𑀺𑀚𑀦𑀁 𑀢𑀲𑁆𑀲, 𑀭𑀚𑀪𑀽𑀢𑀁 𑀓𑀭𑁂𑀬𑁆𑀬𑀳𑀁.

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

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

‘‘𑀲𑀳 𑀧𑀣𑀢𑁄 𑀑𑀓𑁆𑀓𑀦𑁆𑀢𑁂, 𑀓𑀢𑁆𑀯𑀸 𑀘𑀺𑀢𑁆𑀢𑀲𑁆𑀲 𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀺𑀁;

𑀯𑀺𑀯𑀭𑀁 𑀅𑀤𑀸𑀲𑀺 𑀧𑀣𑀯𑀻, 𑀧𑀸𑀧𑀬𑀓𑁆𑀔𑀲𑁆𑀲 𑀢𑀸𑀯𑀤𑁂’’𑀢𑀺.

𑀥𑀫𑁆𑀫𑀤𑁂𑀯𑀧𑀼𑀢𑁆𑀢𑀘𑀭𑀺𑀬𑀁 𑀅𑀝𑁆𑀞𑀫𑀁.

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

𑀭𑀸𑀚𑀸 𑀚𑀬𑀤𑁆𑀤𑀺𑀲𑁄 𑀦𑀸𑀫, 𑀲𑀻𑀮𑀕𑀼𑀡𑀫𑀼𑀧𑀸𑀕𑀢𑁄.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀭𑀜𑁆𑀜𑁄 𑀅𑀳𑀁 𑀧𑀼𑀢𑁆𑀢𑁄, 𑀲𑀼𑀢𑀥𑀫𑁆𑀫𑁄 𑀲𑀼𑀲𑀻𑀮𑀯𑀸;

𑀅𑀮𑀻𑀦𑀲𑀢𑁆𑀢𑁄 𑀕𑀼𑀡𑀯𑀸, 𑀅𑀦𑀼𑀭𑀓𑁆𑀔𑀧𑀭𑀺𑀚𑀦𑁄 𑀲𑀤𑀸.

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

𑀲𑁄 𑀫𑁂 𑀧𑀺𑀢𑀼𑀫𑀕𑁆𑀕𑀳𑁂𑀲𑀺, ‘𑀪𑀓𑁆𑀔𑁄𑀲𑀺 𑀫𑀫 𑀫𑀸 𑀘𑀮𑀺’.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀪𑀻𑀢𑁄 𑀢𑀲𑀺𑀢𑀯𑁂𑀥𑀺𑀢𑁄;

𑀊𑀭𑀼𑀓𑁆𑀔𑀫𑁆𑀪𑁄 𑀅𑀳𑀼 𑀢𑀲𑁆𑀲, 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀧𑁄𑀭𑀺𑀲𑀸𑀤𑀓𑀁.

‘‘𑀫𑀺𑀕𑀯𑀁 𑀕𑀳𑁂𑀢𑁆𑀯𑀸 𑀫𑀼𑀜𑁆𑀘𑀲𑁆𑀲𑀼, 𑀓𑀢𑁆𑀯𑀸 𑀆𑀕𑀫𑀦𑀁 𑀧𑀼𑀦;

𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀥𑀦𑀁 𑀤𑀢𑁆𑀯𑀸, 𑀧𑀺𑀢𑀸 𑀆𑀫𑀦𑁆𑀢𑀬𑀻 𑀫𑀫𑀁.

‘‘‘𑀭𑀚𑁆𑀚𑀁 𑀧𑀼𑀢𑁆𑀢 𑀧𑀝𑀺𑀧𑀚𑁆𑀚, 𑀫𑀸 𑀧𑀫𑀚𑁆𑀚𑀺 𑀧𑀼𑀭𑀁 𑀇𑀤𑀁;

𑀓𑀢𑀁 𑀫𑁂 𑀧𑁄𑀭𑀺𑀲𑀸𑀤𑁂𑀦, 𑀫𑀫 𑀆𑀕𑀫𑀦𑀁 𑀧𑀼𑀦’.

‘‘𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽 𑀘 𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸, 𑀦𑀺𑀫𑁆𑀫𑀺𑀦𑀺𑀢𑁆𑀯𑀸𑀦 𑀅𑀢𑁆𑀢𑀦𑀸;

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

‘‘𑀲𑀲𑀢𑁆𑀣𑀳𑀢𑁆𑀣𑀽𑀧𑀕𑀢𑀁, 𑀓𑀤𑀸𑀘𑀺 𑀲𑁄 𑀢𑀲𑀺𑀲𑁆𑀲𑀢𑀺;

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

‘‘𑀲𑀻𑀮𑀔𑀡𑁆𑀟𑀪𑀬𑀸 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀲 𑀤𑁂𑀲𑁆𑀲𑀁 𑀦 𑀩𑁆𑀬𑀸𑀳𑀭𑀺𑀁;

𑀫𑁂𑀢𑁆𑀢𑀘𑀺𑀢𑁆𑀢𑁄 𑀳𑀺𑀢𑀯𑀸𑀤𑀻, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺𑀁.

‘‘‘𑀉𑀚𑁆𑀚𑀸𑀮𑁂𑀳𑀺 𑀫𑀳𑀸𑀅𑀕𑁆𑀕𑀺𑀁, 𑀧𑀧𑀢𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀭𑀼𑀓𑁆𑀔𑀢𑁄;

𑀢𑁆𑀯𑀁 𑀧𑀓𑁆𑀓𑀓𑀸𑀮𑀫𑀜𑁆𑀜𑀸𑀬 [𑀲𑀼𑀧𑀓𑁆𑀓𑀓𑀸𑀮𑀫𑀜𑁆𑀜𑀸𑀬 (𑀧𑀻.)], 𑀪𑀓𑁆𑀔𑀬 𑀫𑀁 𑀧𑀺𑀢𑀸𑀫𑀳’.

‘‘𑀇𑀢𑀺 𑀲𑀻𑀮𑀯𑀢𑀁 𑀳𑁂𑀢𑀼, 𑀦𑀸𑀭𑀓𑁆𑀔𑀺𑀁 𑀫𑀫 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀧𑀩𑁆𑀩𑀸𑀚𑁂𑀲𑀺𑀁 𑀘𑀳𑀁 𑀢𑀲𑁆𑀲, 𑀲𑀤𑀸 𑀧𑀸𑀡𑀸𑀢𑀺𑀧𑀸𑀢𑀺𑀓’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ ¶ ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀲𑀗𑁆𑀔𑀧𑀸𑀮𑁄 𑀫𑀳𑀺𑀤𑁆𑀥𑀺𑀓𑁄;

𑀤𑀸𑀞𑀸𑀯𑀼𑀥𑁄 𑀖𑁄𑀭𑀯𑀺𑀲𑁄, 𑀤𑁆𑀯𑀺𑀚𑀺𑀯𑁆𑀳𑁄 𑀉𑀭𑀕𑀸𑀥𑀺𑀪𑀽.

‘‘𑀘𑀢𑀼𑀧𑁆𑀧𑀣𑁂 𑀫𑀳𑀸𑀫𑀕𑁆𑀕𑁂, 𑀦𑀸𑀦𑀸𑀚𑀦𑀲𑀫𑀸𑀓𑀼𑀮𑁂;

𑀘𑀢𑀼𑀭𑁄 𑀅𑀗𑁆𑀕𑁂 𑀅𑀥𑀺𑀝𑁆𑀞𑀸𑀬, 𑀢𑀢𑁆𑀣 𑀯𑀸𑀲𑀫𑀓𑀧𑁆𑀧𑀬𑀺𑀁.

‘‘𑀙𑀯𑀺𑀬𑀸 𑀘𑀫𑁆𑀫𑁂𑀦 𑀫𑀁𑀲𑁂𑀦, 𑀦𑀳𑀸𑀭𑀼𑀅𑀝𑁆𑀞𑀺𑀓𑁂𑀳𑀺 𑀯𑀸;

𑀬𑀲𑁆𑀲 𑀏𑀢𑁂𑀦 𑀓𑀭𑀡𑀻𑀬𑀁, 𑀤𑀺𑀦𑁆𑀦𑀁𑀬𑁂𑀯 𑀳𑀭𑀸𑀢𑀼 𑀲𑁄.

‘‘𑀅𑀤𑁆𑀤𑀲𑀁𑀲𑀼 ¶ 𑀪𑁄𑀚𑀧𑀼𑀢𑁆𑀢𑀸, 𑀔𑀭𑀸 𑀮𑀼𑀤𑁆𑀤𑀸 𑀅𑀓𑀸𑀭𑀼𑀡𑀸;

𑀉𑀧𑀕𑀜𑁆𑀙𑀼𑀁 𑀫𑀫𑀁 𑀢𑀢𑁆𑀣, 𑀤𑀡𑁆𑀟𑀫𑀼𑀕𑁆𑀕𑀭𑀧𑀸𑀡𑀺𑀦𑁄.

‘‘𑀦𑀸𑀲𑀸𑀬 𑀯𑀺𑀦𑀺𑀯𑀺𑀚𑁆𑀛𑀺𑀢𑁆𑀯𑀸, 𑀦𑀗𑁆𑀕𑀼𑀝𑁆𑀞𑁂 𑀧𑀺𑀝𑁆𑀞𑀺𑀓𑀡𑁆𑀝𑀓𑁂;

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

‘‘𑀲𑀲𑀸𑀕𑀭𑀦𑁆𑀢𑀁 𑀧𑀣𑀯𑀺𑀁, 𑀲𑀓𑀸𑀦𑀦𑀁 𑀲𑀧𑀩𑁆𑀩𑀢𑀁;

𑀇𑀘𑁆𑀙𑀫𑀸𑀦𑁄 𑀘𑀳𑀁 𑀢𑀢𑁆𑀣, 𑀦𑀸𑀲𑀸𑀯𑀸𑀢𑁂𑀦 𑀛𑀸𑀧𑀬𑁂.

‘‘𑀲𑀽𑀮𑁂𑀳𑀺 𑀯𑀺𑀦𑀺𑀯𑀺𑀚𑁆𑀛𑀦𑁆𑀢𑁂, 𑀓𑁄𑀝𑁆𑀝𑀬𑀦𑁆𑀢𑁂𑀧𑀺 𑀲𑀢𑁆𑀢𑀺𑀪𑀺;

𑀪𑁄𑀚𑀧𑀼𑀢𑁆𑀢𑁂 𑀦 𑀓𑀼𑀧𑁆𑀧𑀸𑀫𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀲𑀻𑀮𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

𑀳𑀢𑁆𑀣𑀺𑀦𑀸𑀕𑁄 ¶ 𑀪𑀽𑀭𑀺𑀤𑀢𑁆𑀢𑁄, 𑀘𑀫𑁆𑀧𑁂𑀬𑁆𑀬𑁄 𑀩𑁄𑀥𑀺 𑀫𑀳𑀺𑀁𑀲𑁄;

𑀭𑀼𑀭𑀼 𑀫𑀸𑀢𑀗𑁆𑀕𑁄 𑀥𑀫𑁆𑀫𑁄 𑀘, 𑀅𑀢𑁆𑀭𑀚𑁄 𑀘 𑀚𑀬𑀤𑁆𑀤𑀺𑀲𑁄.

𑀏𑀢𑁂 𑀦𑀯 𑀲𑀻𑀮𑀩𑀮𑀸, 𑀧𑀭𑀺𑀓𑁆𑀔𑀸𑀭𑀸 𑀧𑀤𑁂𑀲𑀺𑀓𑀸;

𑀚𑀻𑀯𑀺𑀢𑀁 𑀧𑀭𑀺𑀭𑀓𑁆𑀔𑀺𑀢𑁆𑀯𑀸, 𑀲𑀻𑀮𑀸𑀦𑀺 𑀅𑀦𑀼𑀭𑀓𑁆𑀔𑀺𑀲𑀁.

𑀲𑀗𑁆𑀔𑀧𑀸𑀮𑀲𑁆𑀲 𑀫𑁂 𑀲𑀢𑁄, 𑀲𑀩𑁆𑀩𑀓𑀸𑀮𑀫𑁆𑀧𑀺 𑀚𑀻𑀯𑀺𑀢𑀁;

𑀬𑀲𑁆𑀲 𑀓𑀲𑁆𑀲𑀘𑀺 𑀦𑀺𑀬𑁆𑀬𑀢𑁆𑀢𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀲𑀸 𑀲𑀻𑀮𑀧𑀸𑀭𑀫𑀻𑀢𑀺.

𑀲𑀻𑀮𑀧𑀸𑀭𑀫𑀺𑀦𑀺𑀤𑁆𑀤𑁂𑀲𑁄 𑀦𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

‘‘𑀬𑀤𑀸𑀳𑀁 ¶ ¶ ¶ 𑀅𑀫𑀺𑀢𑀬𑀲𑁄, 𑀭𑀸𑀚𑀧𑀼𑀢𑁆𑀢𑁄 𑀬𑀼𑀥𑀜𑁆𑀚𑀬𑁄;

𑀉𑀲𑁆𑀲𑀸𑀯𑀩𑀺𑀦𑁆𑀤𑀼𑀁 𑀲𑀽𑀭𑀺𑀬𑀸𑀢𑀧𑁂, 𑀧𑀢𑀺𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦 𑀲𑀁𑀯𑀺𑀚𑀺𑀁.

‘‘𑀢𑀜𑁆𑀜𑁂𑀯𑀸𑀥𑀺𑀧𑀢𑀺𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀲𑀁𑀯𑁂𑀕𑀫𑀦𑀼𑀩𑁆𑀭𑀽𑀳𑀬𑀺𑀁;

𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽 𑀘 𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸, 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀫𑀦𑀼𑀬𑀸𑀘𑀳𑀁.

‘‘𑀬𑀸𑀘𑀦𑁆𑀢𑀺 𑀫𑀁 𑀧𑀜𑁆𑀚𑀮𑀺𑀓𑀸, 𑀲𑀦𑁂𑀕𑀫𑀸 𑀲𑀭𑀝𑁆𑀞𑀓𑀸;

‘𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀼𑀢𑁆𑀢 𑀧𑀝𑀺𑀧𑀚𑁆𑀚, 𑀇𑀤𑁆𑀥𑀁 𑀨𑀻𑀢𑀁 𑀫𑀳𑀸𑀫𑀳𑀺𑀁’.

‘‘𑀲𑀭𑀸𑀚𑀓𑁂 𑀲𑀳𑁄𑀭𑁄𑀥𑁂, 𑀲𑀦𑁂𑀕𑀫𑁂 𑀲𑀭𑀝𑁆𑀞𑀓𑁂;

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

‘‘𑀓𑁂𑀯𑀮𑀁 𑀧𑀣𑀯𑀺𑀁 𑀭𑀚𑁆𑀚𑀁, 𑀜𑀸𑀢𑀺𑀧𑀭𑀺𑀚𑀦𑀁 𑀬𑀲𑀁;

𑀘𑀚𑀫𑀸𑀦𑁄 𑀦 𑀘𑀺𑀦𑁆𑀢𑁂𑀲𑀺𑀁, 𑀩𑁄𑀥𑀺𑀬𑀸𑀬𑁂𑀯 𑀓𑀸𑀭𑀡𑀸.

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

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀺𑀬𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀭𑀚𑁆𑀚𑀁 𑀧𑀭𑀺𑀘𑁆𑀘𑀚𑀺’’𑀦𑁆𑀢𑀺.

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

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

‘‘𑀲𑀻𑀮𑀯𑀸 𑀕𑀼𑀡𑀲𑀫𑁆𑀧𑀦𑁆𑀦𑁄, 𑀓𑀮𑁆𑀬𑀸𑀡𑀧𑀝𑀺𑀪𑀸𑀦𑀯𑀸;

𑀯𑀼𑀟𑁆𑀠𑀸𑀧𑀘𑀸𑀬𑀻 𑀳𑀺𑀭𑀻𑀫𑀸, 𑀲𑀗𑁆𑀕𑀳𑁂𑀲𑀼 𑀘 𑀓𑁄𑀯𑀺𑀤𑁄.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀭𑀜𑁆𑀜𑁄 𑀧𑀢𑀺𑀓𑀭𑁄, 𑀅𑀳𑁄𑀲𑀺 𑀓𑀼𑀳𑀓𑀢𑀸𑀧𑀲𑁄;

𑀆𑀭𑀸𑀫𑀁 𑀫𑀸𑀮𑀸𑀯𑀘𑁆𑀙𑀜𑁆𑀘, 𑀭𑁄𑀧𑀬𑀺𑀢𑁆𑀯𑀸𑀦 𑀚𑀻𑀯𑀢𑀺.

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

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

‘‘𑀦𑀢𑁆𑀣𑀺𑀫𑀲𑁆𑀲 ¶ 𑀲𑀢𑀁 𑀥𑀫𑁆𑀫𑁄, 𑀲𑀸𑀫𑀜𑁆𑀜𑀸𑀧𑀕𑀢𑁄 𑀅𑀬𑀁;

𑀳𑀺𑀭𑀻𑀲𑀼𑀓𑁆𑀓𑀥𑀫𑁆𑀫𑀚𑀳𑀺𑀢𑁄, 𑀚𑀻𑀯𑀺𑀢𑀯𑀼𑀢𑁆𑀢𑀺𑀓𑀸𑀭𑀡𑀸.

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

𑀢𑀁 𑀦𑀺𑀲𑁂𑀥𑁂𑀢𑀼𑀁 𑀕𑀘𑁆𑀙𑀦𑁆𑀢𑁄, 𑀅𑀦𑀼𑀲𑀸𑀲𑀺 𑀧𑀺𑀢𑀸 𑀫𑀫𑀁.

‘‘‘𑀫𑀸 𑀧𑀫𑀚𑁆𑀚𑀺 𑀢𑀼𑀯𑀁 𑀢𑀸𑀢, 𑀚𑀝𑀺𑀮𑀁 𑀉𑀕𑁆𑀕𑀢𑀸𑀧𑀦𑀁;

𑀬𑀤𑀺𑀘𑁆𑀙𑀓𑀁 𑀧𑀯𑀢𑁆𑀢𑁂𑀳𑀺, 𑀲𑀩𑁆𑀩𑀓𑀸𑀫𑀤𑀤𑁄 𑀳𑀺 𑀲𑁄’.

‘‘𑀢𑀫𑀳𑀁 𑀕𑀦𑁆𑀢𑁆𑀯𑀸𑀦𑀼𑀧𑀝𑁆𑀞𑀸𑀦𑀁, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺𑀁;

‘𑀓𑀘𑁆𑀘𑀺 𑀢𑁂 𑀕𑀳𑀧𑀢𑀺 𑀓𑀼𑀲𑀮𑀁, 𑀓𑀺𑀁 𑀯𑀸 𑀢𑁂 𑀆𑀳𑀭𑀻𑀬𑀢𑀼’.

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

‘𑀖𑀸𑀢𑀸𑀧𑁂𑀫𑀺 𑀢𑀼𑀯𑀁 𑀅𑀚𑁆𑀚, 𑀭𑀝𑁆𑀞𑀸 𑀧𑀩𑁆𑀩𑀸𑀚𑀬𑀸𑀫𑀺 𑀯𑀸’.

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

‘𑀓𑀘𑁆𑀘𑀺 𑀢𑁂 𑀪𑀦𑁆𑀢𑁂 𑀔𑀫𑀦𑀻𑀬𑀁, 𑀲𑀫𑁆𑀫𑀸𑀦𑁄 𑀢𑁂 𑀧𑀯𑀢𑁆𑀢𑀺𑀢𑁄’.

‘‘𑀢𑀲𑁆𑀲 𑀆𑀘𑀺𑀓𑁆𑀔𑀢𑀻 𑀧𑀸𑀧𑁄, 𑀓𑀼𑀫𑀸𑀭𑁄 𑀬𑀣𑀸 𑀦𑀸𑀲𑀺𑀬𑁄;

𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀆𑀡𑀸𑀧𑁂𑀲𑀺 𑀫𑀳𑀻𑀧𑀢𑀺.

‘‘‘𑀲𑀻𑀲𑀁 𑀢𑀢𑁆𑀣𑁂𑀯 𑀙𑀺𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸, 𑀓𑀢𑁆𑀯𑀸𑀦 𑀘𑀢𑀼𑀔𑀡𑁆𑀟𑀺𑀓𑀁;

𑀭𑀣𑀺𑀬𑀸 𑀭𑀣𑀺𑀬𑀁 𑀤𑀲𑁆𑀲𑁂𑀣, 𑀲𑀸 𑀕𑀢𑀺 𑀚𑀝𑀺𑀮𑀳𑀻𑀴𑀺𑀢𑀸’.

‘‘𑀢𑀢𑁆𑀣 𑀓𑀸𑀭𑀡𑀺𑀓𑀸 𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀘𑀡𑁆𑀟𑀸 𑀮𑀼𑀤𑁆𑀤𑀸 𑀅𑀓𑀸𑀭𑀼𑀡𑀸;

𑀫𑀸𑀢𑀼𑀅𑀗𑁆𑀓𑁂 𑀦𑀺𑀲𑀺𑀦𑁆𑀦𑀲𑁆𑀲, 𑀆𑀓𑀟𑁆𑀠𑀺𑀢𑁆𑀯𑀸 𑀦𑀬𑀦𑁆𑀢𑀺 𑀫𑀁.

‘‘𑀢𑁂𑀲𑀸𑀳𑀁 𑀏𑀯𑀫𑀯𑀘𑀁, 𑀩𑀦𑁆𑀥𑀢𑀁 𑀕𑀸𑀴𑁆𑀳𑀩𑀦𑁆𑀥𑀦𑀁;

‘𑀭𑀜𑁆𑀜𑁄 𑀤𑀲𑁆𑀲𑁂𑀣 𑀫𑀁 𑀔𑀺𑀧𑁆𑀧𑀁, 𑀭𑀸𑀚𑀓𑀺𑀭𑀺𑀬𑀸𑀦𑀺 𑀅𑀢𑁆𑀣𑀺 𑀫𑁂’.

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

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

‘‘𑀲𑁄 𑀫𑀁 𑀢𑀢𑁆𑀣 𑀔𑀫𑀸𑀧𑁂𑀲𑀺, 𑀫𑀳𑀸𑀭𑀚𑁆𑀚𑀫𑀤𑀸𑀲𑀺 𑀫𑁂;

𑀲𑁄𑀳𑀁 𑀢𑀫𑀁 𑀤𑀸𑀮𑀬𑀺𑀢𑁆𑀯𑀸, 𑀧𑀩𑁆𑀩𑀚𑀺𑀁 𑀅𑀦𑀕𑀸𑀭𑀺𑀬𑀁.

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

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀺𑀬𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀭𑀚𑁆𑀚𑀁 𑀧𑀭𑀺𑀘𑁆𑀘𑀚𑀺’’𑀦𑁆𑀢𑀺.

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

𑀅𑀬𑁄𑀖𑀭𑀫𑁆𑀳𑀺 𑀲𑀁𑀯𑀟𑁆𑀠𑁄, 𑀦𑀸𑀫𑁂𑀦𑀸𑀲𑀺 𑀅𑀬𑁄𑀖𑀭𑁄.

‘‘𑀤𑀼𑀓𑁆𑀔𑁂𑀦 𑀚𑀻𑀯𑀺𑀢𑁄 𑀮𑀤𑁆𑀥𑁄, 𑀲𑀁𑀧𑀻𑀴𑁂 𑀧𑀢𑀺𑀧𑁄𑀲𑀺𑀢𑁄;

𑀅𑀚𑁆𑀚𑁂𑀯 𑀧𑀼𑀢𑁆𑀢 𑀧𑀝𑀺𑀧𑀚𑁆𑀚, 𑀓𑁂𑀯𑀮𑀁 𑀯𑀲𑀼𑀥𑀁 𑀇𑀫𑀁.

‘‘𑀲𑀭𑀝𑁆𑀞𑀓𑀁 𑀲𑀦𑀺𑀕𑀫𑀁, 𑀲𑀚𑀦𑀁 𑀯𑀦𑁆𑀤𑀺𑀢𑁆𑀯 𑀔𑀢𑁆𑀢𑀺𑀬𑀁;

𑀅𑀜𑁆𑀚𑀮𑀺𑀁 𑀧𑀕𑁆𑀕𑀳𑁂𑀢𑁆𑀯𑀸𑀦, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺𑀁.

‘‘‘𑀬𑁂 𑀓𑁂𑀘𑀺 𑀫𑀳𑀺𑀬𑀸 𑀲𑀢𑁆𑀢𑀸, 𑀳𑀻𑀦𑀫𑀼𑀓𑁆𑀓𑀝𑁆𑀞𑀫𑀚𑁆𑀛𑀺𑀫𑀸;

𑀦𑀺𑀭𑀸𑀭𑀓𑁆𑀔𑀸 𑀲𑀓𑁂 𑀕𑁂𑀳𑁂, 𑀯𑀟𑁆𑀠𑀦𑁆𑀢𑀺 𑀲𑀓𑀜𑀸𑀢𑀺𑀪𑀺.

‘‘‘𑀇𑀤𑀁 𑀮𑁄𑀓𑁂 𑀉𑀢𑁆𑀢𑀭𑀺𑀬𑀁, 𑀲𑀁𑀧𑀻𑀴𑁂 𑀫𑀫 𑀧𑁄𑀲𑀦𑀁;

𑀅𑀬𑁄𑀖𑀭𑀫𑁆𑀳𑀺 𑀲𑀁𑀯𑀟𑁆𑀠𑁄, 𑀅𑀧𑁆𑀧𑀪𑁂 𑀘𑀦𑁆𑀤𑀲𑀽𑀭𑀺𑀬𑁂.

‘‘‘𑀧𑀽𑀢𑀺𑀓𑀼𑀡𑀧𑀲𑀫𑁆𑀧𑀼𑀡𑁆𑀡𑀸, 𑀫𑀼𑀘𑁆𑀘𑀺𑀢𑁆𑀯𑀸 𑀫𑀸𑀢𑀼 𑀓𑀼𑀘𑁆𑀙𑀺𑀢𑁄;

𑀢𑀢𑁄 𑀖𑁄𑀭𑀢𑀭𑁂 𑀤𑀼𑀓𑁆𑀔𑁂, 𑀧𑀼𑀦 𑀧𑀓𑁆𑀔𑀺𑀢𑁆𑀢𑀬𑁄𑀖𑀭𑁂.

‘‘‘𑀬𑀤𑀺𑀳𑀁 𑀢𑀸𑀤𑀺𑀲𑀁 𑀧𑀢𑁆𑀯𑀸, 𑀤𑀼𑀓𑁆𑀔𑀁 𑀧𑀭𑀫𑀤𑀸𑀭𑀼𑀡𑀁;

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

‘‘‘𑀉𑀓𑁆𑀓𑀡𑁆𑀞𑀺𑀢𑁄𑀫𑁆𑀳𑀺 𑀓𑀸𑀬𑁂𑀦, 𑀭𑀚𑁆𑀚𑁂𑀦𑀫𑁆𑀳𑀺 𑀅𑀦𑀢𑁆𑀣𑀺𑀓𑁄;

𑀦𑀺𑀩𑁆𑀩𑀼𑀢𑀺𑀁 𑀧𑀭𑀺𑀬𑁂𑀲𑀺𑀲𑁆𑀲𑀁, 𑀬𑀢𑁆𑀣 𑀫𑀁 𑀫𑀘𑁆𑀘𑀼 𑀦 𑀫𑀤𑁆𑀤𑀺𑀬𑁂’.

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

𑀦𑀸𑀕𑁄𑀯 𑀩𑀦𑁆𑀥𑀦𑀁 𑀙𑁂𑀢𑁆𑀯𑀸, 𑀧𑀸𑀯𑀺𑀲𑀺𑀁 𑀓𑀸𑀦𑀦𑀁 𑀯𑀦𑀁.

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

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀺𑀬𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀭𑀚𑁆𑀚𑀁 𑀧𑀭𑀺𑀘𑁆𑀘𑀚𑀺’’𑀦𑁆𑀢𑀺.

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

𑀪𑀕𑀺𑀦𑀻 𑀘 𑀪𑀸𑀢𑀭𑁄 𑀲𑀢𑁆𑀢, 𑀦𑀺𑀩𑁆𑀩𑀢𑁆𑀢𑀸 𑀲𑁄𑀢𑁆𑀣𑀺𑀬𑁂 𑀓𑀼𑀮𑁂.

‘‘𑀏𑀢𑁂𑀲𑀁 ¶ 𑀧𑀼𑀩𑁆𑀩𑀚𑁄 𑀆𑀲𑀺𑀁, 𑀳𑀺𑀭𑀻𑀲𑀼𑀓𑁆𑀓𑀫𑀼𑀧𑀸𑀕𑀢𑁄;

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

‘‘𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀽𑀳𑀺 ¶ 𑀧𑀳𑀺𑀢𑀸, 𑀲𑀳𑀸𑀬𑀸 𑀏𑀓𑀫𑀸𑀦𑀲𑀸;

𑀓𑀸𑀫𑁂𑀳𑀺 𑀫𑀁 𑀦𑀺𑀫𑀦𑁆𑀢𑁂𑀦𑁆𑀢𑀺, ‘𑀓𑀼𑀮𑀯𑀁𑀲𑀁 𑀥𑀭𑁂𑀳𑀺’𑀢𑀺.

‘‘𑀬𑀁 𑀢𑁂𑀲𑀁 𑀯𑀘𑀦𑀁 𑀯𑀼𑀢𑁆𑀢𑀁, 𑀕𑀺𑀳𑀻𑀥𑀫𑁆𑀫𑁂 𑀲𑀼𑀔𑀸𑀯𑀳𑀁;

𑀢𑀁 𑀫𑁂 𑀅𑀳𑁄𑀲𑀺 𑀓𑀞𑀺𑀦𑀁, 𑀢𑀢𑁆𑀢 [𑀲𑀦𑁆𑀢𑀢𑁆𑀢 (𑀓.)] 𑀨𑀸𑀮𑀲𑀫𑀁 𑀯𑀺𑀬.

‘‘𑀢𑁂 𑀫𑀁 𑀢𑀤𑀸 𑀉𑀓𑁆𑀔𑀺𑀧𑀦𑁆𑀢𑀁, 𑀧𑀼𑀘𑁆𑀙𑀺𑀁𑀲𑀼 𑀧𑀢𑁆𑀣𑀺𑀢𑀁 𑀫𑀫;

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

‘‘𑀢𑁂𑀲𑀸𑀳𑀁 𑀏𑀯𑀫𑀯𑀘𑀁, 𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑁄 𑀳𑀺𑀢𑁂𑀲𑀺𑀦𑀁;

‘𑀦𑀸𑀳𑀁 𑀧𑀢𑁆𑀣𑁂𑀫𑀺 𑀕𑀺𑀳𑀻𑀪𑀸𑀯𑀁, 𑀦𑁂𑀓𑁆𑀔𑀫𑁆𑀫𑀸𑀪𑀺𑀭𑀢𑁄 𑀅𑀳𑀁’.

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

𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀸 𑀏𑀯𑀫𑀸𑀳𑀼, ‘𑀲𑀩𑁆𑀩𑁂𑀯 𑀧𑀩𑁆𑀩𑀚𑀸𑀫 𑀪𑁄’.

‘‘𑀉𑀪𑁄 ¶ 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀸 𑀫𑀬𑁆𑀳𑀁, 𑀪𑀕𑀺𑀦𑀻 𑀘 𑀲𑀢𑁆𑀢 𑀪𑀸𑀢𑀭𑁄;

𑀅𑀫𑀺𑀢𑀥𑀦𑀁 𑀙𑀟𑁆𑀟𑀬𑀺𑀢𑁆𑀯𑀸, 𑀧𑀸𑀯𑀺𑀲𑀺𑀫𑁆𑀳𑀸 𑀫𑀳𑀸𑀯𑀦’’𑀦𑁆𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀦𑀕𑀭𑁂 𑀩𑁆𑀭𑀳𑁆𑀫𑀯𑀟𑁆𑀠𑀦𑁂;

𑀢𑀢𑁆𑀣 𑀓𑀼𑀮𑀯𑀭𑁂 𑀲𑁂𑀝𑁆𑀞𑁂, 𑀫𑀳𑀸𑀲𑀸𑀮𑁂 𑀅𑀚𑀸𑀬𑀳𑀁.

‘‘𑀢𑀤𑀸𑀧𑀺 𑀮𑁄𑀓𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦, 𑀅𑀦𑁆𑀥𑀻𑀪𑀽𑀢𑀁 𑀢𑀫𑁄𑀢𑁆𑀣𑀝𑀁;

𑀘𑀺𑀢𑁆𑀢𑀁 𑀪𑀯𑀢𑁄 𑀧𑀢𑀺𑀓𑀼𑀝𑀢𑀺, 𑀢𑀼𑀢𑁆𑀢𑀯𑁂𑀕𑀳𑀢𑀁 𑀯𑀺𑀬.

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

‘𑀓𑀤𑀸𑀳𑀁 𑀕𑁂𑀳𑀸 𑀦𑀺𑀓𑁆𑀔𑀫𑁆𑀫, 𑀧𑀯𑀺𑀲𑀺𑀲𑁆𑀲𑀸𑀫𑀺 𑀓𑀸𑀦𑀦𑀁’.

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

𑀢𑁂𑀲𑀫𑁆𑀧𑀺 𑀙𑀦𑁆𑀤𑀫𑀸𑀘𑀺𑀓𑁆𑀔𑀺𑀁, ‘𑀫𑀸 𑀦𑀺𑀫𑀦𑁆𑀢𑁂𑀣 𑀢𑁂𑀳𑀺 𑀫𑀁’.

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

𑀲𑁄𑀧𑀺 𑀫𑀁 𑀅𑀦𑀼𑀲𑀺𑀓𑁆𑀔𑀦𑁆𑀢𑁄, 𑀧𑀩𑁆𑀩𑀚𑁆𑀚𑀁 𑀲𑀫𑀭𑁄𑀘𑀬𑀺.

‘‘𑀅𑀳𑀁 𑀲𑁄𑀡𑁄 𑀘 𑀦𑀦𑁆𑀤𑁄 𑀘, 𑀉𑀪𑁄 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀸 𑀫𑀫;

𑀢𑀤𑀸𑀧𑀺 𑀪𑁄𑀕𑁂 𑀙𑀟𑁆𑀟𑁂𑀢𑁆𑀯𑀸, 𑀧𑀸𑀯𑀺𑀲𑀺𑀫𑁆𑀳𑀸 𑀫𑀳𑀸𑀯𑀦’’𑀦𑁆𑀢𑀺.

𑀲𑁄𑀡𑀧𑀡𑁆𑀟𑀺𑀢𑀘𑀭𑀺𑀬𑀁 𑀧𑀜𑁆𑀘𑀫𑀁.

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

𑀫𑀽𑀕𑀧𑀓𑁆𑀔𑁄𑀢𑀺 𑀦𑀸𑀫𑁂𑀦, 𑀢𑁂𑀫𑀺𑀬𑁄𑀢𑀺 𑀯𑀤𑀦𑁆𑀢𑀺 𑀫𑀁.

‘‘𑀲𑁄𑀴𑀲𑀺𑀢𑁆𑀣𑀺𑀲𑀳𑀲𑁆𑀲𑀸𑀦𑀁, 𑀦 𑀯𑀺𑀚𑁆𑀚𑀢𑀺 𑀧𑀼𑀫𑁄 𑀢𑀤𑀸 [𑀲𑀤𑀸 (𑀲𑀻.)];

𑀅𑀳𑁄𑀭𑀢𑁆𑀢𑀸𑀦𑀁 𑀅𑀘𑁆𑀘𑀬𑁂𑀦, 𑀦𑀺𑀩𑁆𑀩𑀢𑁆𑀢𑁄 𑀅𑀳𑀫𑁂𑀓𑀓𑁄.

‘‘𑀓𑀺𑀘𑁆𑀙𑀸 𑀮𑀤𑁆𑀥𑀁 𑀧𑀺𑀬𑀁 𑀧𑀼𑀢𑁆𑀢𑀁, 𑀅𑀪𑀺𑀚𑀸𑀢𑀁 𑀚𑀼𑀢𑀺𑀦𑁆𑀥𑀭𑀁;

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

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

𑀅𑀤𑁆𑀤𑀲𑀁 𑀧𑀡𑁆𑀟𑀭𑀁 𑀙𑀢𑁆𑀢𑀁, 𑀬𑁂𑀦𑀸𑀳𑀁 𑀦𑀺𑀭𑀬𑀁 𑀕𑀢𑁄.

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

𑀯𑀺𑀦𑀺𑀘𑁆𑀙𑀬𑀁 𑀲𑀫𑀸𑀧𑀦𑁆𑀦𑁄, ‘𑀓𑀣𑀸𑀳𑀁 𑀇𑀫𑀁 𑀫𑀼𑀜𑁆𑀘𑀺𑀲𑁆𑀲𑀁’.

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

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

‘‘‘𑀫𑀸 𑀧𑀡𑁆𑀟𑀺𑀘𑁆𑀘𑀬𑀁 𑀯𑀺𑀪𑀸𑀯𑀬, 𑀩𑀸𑀮𑀫𑀢𑁄 𑀪𑀯 𑀲𑀩𑁆𑀩𑀧𑀸𑀡𑀺𑀦𑀁;

𑀲𑀩𑁆𑀩𑁄 𑀢𑀁 𑀚𑀦𑁄 𑀑𑀘𑀺𑀦𑀸𑀬𑀢𑀼, 𑀏𑀯𑀁 𑀢𑀯 𑀅𑀢𑁆𑀣𑁄 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺’.

‘‘𑀏𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑀸𑀬𑀳𑀁 𑀢𑀲𑁆𑀲𑀸, 𑀇𑀤𑀁 𑀯𑀘𑀦𑀫𑀩𑁆𑀭𑀯𑀺𑀁;

‘𑀓𑀭𑁄𑀫𑀺 𑀢𑁂 𑀢𑀁 𑀯𑀘𑀦𑀁, 𑀬𑀁 𑀢𑁆𑀯𑀁 𑀪𑀡𑀲𑀺 𑀤𑁂𑀯𑀢𑁂;

𑀅𑀢𑁆𑀣𑀓𑀸𑀫𑀸𑀲𑀺 𑀫𑁂 𑀅𑀫𑁆𑀫, 𑀳𑀺𑀢𑀓𑀸𑀫𑀸𑀲𑀺 𑀤𑁂𑀯𑀢𑁂’.

‘‘𑀢𑀲𑁆𑀲𑀸𑀳𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀲𑀸𑀕𑀭𑁂𑀯 𑀣𑀮𑀁 𑀮𑀪𑀺𑀁;

𑀳𑀝𑁆𑀞𑁄 ¶ 𑀲𑀁𑀯𑀺𑀕𑁆𑀕𑀫𑀸𑀦𑀲𑁄, 𑀢𑀬𑁄 𑀅𑀗𑁆𑀕𑁂 𑀅𑀥𑀺𑀝𑁆𑀞𑀳𑀺𑀁.

‘‘𑀫𑀽𑀕𑁄 ¶ 𑀅𑀳𑁄𑀲𑀺𑀁 𑀩𑀥𑀺𑀭𑁄, 𑀧𑀓𑁆𑀔𑁄 𑀕𑀢𑀺𑀯𑀺𑀯𑀚𑁆𑀚𑀺𑀢𑁄;

𑀏𑀢𑁂 𑀅𑀗𑁆𑀕𑁂 𑀅𑀥𑀺𑀝𑁆𑀞𑀸𑀬, 𑀯𑀲𑁆𑀲𑀸𑀦𑀺 𑀲𑁄𑀴𑀲𑀁 𑀯𑀲𑀺𑀁.

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

𑀅𑀦𑀽𑀦𑀢𑀁 𑀫𑁂 𑀧𑀲𑁆𑀲𑀺𑀢𑁆𑀯𑀸, ‘𑀓𑀸𑀴𑀓𑀡𑁆𑀡𑀻’𑀢𑀺 𑀦𑀺𑀦𑁆𑀤𑀺𑀲𑀼𑀁.

‘‘𑀢𑀢𑁄 𑀚𑀸𑀦𑀧𑀤𑀸 𑀲𑀩𑁆𑀩𑁂, 𑀲𑁂𑀦𑀸𑀧𑀢𑀺𑀧𑀼𑀭𑁄𑀳𑀺𑀢𑀸;

𑀲𑀩𑁆𑀩𑁂 𑀏𑀓𑀫𑀦𑀸 𑀳𑀼𑀢𑁆𑀯𑀸, 𑀙𑀟𑁆𑀟𑀦𑀁 𑀅𑀦𑀼𑀫𑁄𑀤𑀺𑀲𑀼𑀁.

‘‘𑀲𑁄𑀳𑀁 𑀢𑁂𑀲𑀁 𑀫𑀢𑀺𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀳𑀝𑁆𑀞𑁄 𑀲𑀁𑀯𑀺𑀕𑁆𑀕𑀫𑀸𑀦𑀲𑁄;

𑀬𑀲𑁆𑀲𑀢𑁆𑀣𑀸𑀬 𑀢𑀧𑁄𑀘𑀺𑀡𑁆𑀡𑁄, 𑀲𑁄 𑀫𑁂 𑀅𑀢𑁆𑀣𑁄 𑀲𑀫𑀺𑀚𑁆𑀛𑀣.

‘‘𑀦𑁆𑀳𑀸𑀧𑁂𑀢𑁆𑀯𑀸 𑀅𑀦𑀼𑀮𑀺𑀫𑁆𑀧𑀺𑀢𑁆𑀯𑀸, 𑀯𑁂𑀞𑁂𑀢𑁆𑀯𑀸 𑀭𑀸𑀚𑀯𑁂𑀞𑀦𑀁;

𑀙𑀢𑁆𑀢𑁂𑀦 𑀅𑀪𑀺𑀲𑀺𑀜𑁆𑀘𑀺𑀢𑁆𑀯𑀸, 𑀓𑀸𑀭𑁂𑀲𑀼𑀁 𑀧𑀼𑀭𑀁 𑀧𑀤𑀓𑁆𑀔𑀺𑀡𑀁.

‘‘𑀲𑀢𑁆𑀢𑀸𑀳𑀁 𑀥𑀸𑀭𑀬𑀺𑀢𑁆𑀯𑀸𑀦, 𑀉𑀕𑁆𑀕𑀢𑁂 𑀭𑀯𑀺𑀫𑀡𑁆𑀟𑀮𑁂;

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

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

𑀲𑀸𑀭𑀣𑀻 𑀔𑀡𑀢𑀻 𑀓𑀸𑀲𑀼𑀁, 𑀦𑀺𑀔𑀸𑀢𑀼𑀁 𑀧𑀣𑀯𑀺𑀬𑀸 𑀫𑀫𑀁.

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

𑀦 𑀪𑀺𑀦𑁆𑀤𑀺𑀁 𑀢𑀫𑀥𑀺𑀝𑁆𑀞𑀸𑀦𑀁, 𑀩𑁄𑀥𑀺𑀬𑀸𑀬𑁂𑀯 𑀓𑀸𑀭𑀡𑀸.

‘‘𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀸 𑀦 𑀫𑁂 𑀤𑁂𑀲𑁆𑀲𑀸, 𑀅𑀢𑁆𑀢𑀸 𑀫𑁂 𑀦 𑀘 𑀤𑁂𑀲𑁆𑀲𑀺𑀬𑁄;

𑀲𑀩𑁆𑀩𑀜𑁆𑀜𑀼𑀢𑀁 𑀧𑀺𑀬𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀢𑀲𑁆𑀫𑀸 𑀯𑀢𑀫𑀥𑀺𑀝𑁆𑀞𑀳𑀺𑀁.

‘‘𑀏𑀢𑁂 ¶ ¶ 𑀅𑀗𑁆𑀕𑁂 𑀅𑀥𑀺𑀝𑁆𑀞𑀸𑀬, 𑀯𑀲𑁆𑀲𑀸𑀦𑀺 𑀲𑁄𑀴𑀲𑀁 𑀯𑀲𑀺𑀁;

𑀅𑀥𑀺𑀝𑁆𑀞𑀸𑀦𑁂𑀦 𑀫𑁂 𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀅𑀥𑀺𑀝𑁆𑀞𑀸𑀦𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

‘‘𑀬𑀤𑀸 𑀅𑀳𑀁 𑀓𑀧𑀺 𑀆𑀲𑀺𑀁, 𑀦𑀤𑀻𑀓𑀽𑀮𑁂 𑀤𑀭𑀻𑀲𑀬𑁂;

𑀧𑀻𑀴𑀺𑀢𑁄 𑀲𑀼𑀲𑀼𑀫𑀸𑀭𑁂𑀦, 𑀕𑀫𑀦𑀁 𑀦 𑀮𑀪𑀸𑀫𑀳𑀁.

‘‘𑀬𑀫𑁆𑀳𑁄𑀓𑀸𑀲𑁂 ¶ 𑀅𑀳𑀁 𑀞𑀢𑁆𑀯𑀸, 𑀑𑀭𑀸 𑀧𑀸𑀭𑀁 𑀧𑀢𑀸𑀫𑀳𑀁;

𑀢𑀢𑁆𑀣𑀘𑁆𑀙𑀺 𑀲𑀢𑁆𑀢𑀼 𑀯𑀥𑀓𑁄, 𑀓𑀼𑀫𑁆𑀪𑀻𑀮𑁄 𑀮𑀼𑀤𑁆𑀤𑀤𑀲𑁆𑀲𑀦𑁄.

‘‘𑀲𑁄 𑀫𑀁 𑀅𑀲𑀁𑀲𑀺 ‘𑀏𑀳𑀻’𑀢𑀺, ‘𑀅𑀳𑀁𑀧𑁂𑀫𑀻’𑀢𑀺 𑀢𑀁 𑀯𑀢𑀺𑀁;

𑀢𑀲𑁆𑀲 𑀫𑀢𑁆𑀣𑀓𑀫𑀓𑁆𑀓𑀫𑁆𑀫, 𑀧𑀭𑀓𑀽𑀮𑁂 𑀧𑀢𑀺𑀝𑁆𑀞𑀳𑀺𑀁.

‘‘𑀦 𑀢𑀲𑁆𑀲 𑀅𑀮𑀺𑀓𑀁 𑀪𑀡𑀺𑀢𑀁, 𑀬𑀣𑀸 𑀯𑀸𑀘𑀁 𑀅𑀓𑀸𑀲𑀳𑀁;

𑀲𑀘𑁆𑀘𑁂𑀦 𑀫𑁂 𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀲𑀘𑁆𑀘𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

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

𑀲𑀘𑁆𑀘𑁂𑀦 𑀮𑁄𑀓𑀁 𑀧𑀸𑀮𑁂𑀲𑀺𑀁, 𑀲𑀫𑀕𑁆𑀕𑀁 𑀚𑀦𑀫𑀓𑀸𑀲𑀳’’𑀦𑁆𑀢𑀺.

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

𑀅𑀚𑀸𑀢𑀧𑀓𑁆𑀔𑁄 𑀢𑀭𑀼𑀡𑁄, 𑀫𑀁𑀲𑀧𑁂𑀲𑀺 𑀓𑀼𑀮𑀸𑀯𑀓𑁂.

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

𑀢𑀲𑁆𑀲𑀸 𑀨𑀲𑁆𑀲𑁂𑀦 𑀚𑀻𑀯𑀸𑀫𑀺, 𑀦𑀢𑁆𑀣𑀺 𑀫𑁂 𑀓𑀸𑀬𑀺𑀓𑀁 𑀩𑀮𑀁.

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

𑀉𑀧𑀕𑀘𑁆𑀙𑀢𑀺 𑀅𑀫𑁆𑀳𑀸𑀓𑀁, 𑀧𑀸𑀯𑀓𑁄 𑀓𑀡𑁆𑀳𑀯𑀢𑁆𑀢𑀦𑀻.

‘‘𑀥𑀫𑀥𑀫𑀸 𑀇𑀢𑀺𑀏𑀯𑀁, 𑀲𑀤𑁆𑀤𑀸𑀬𑀦𑁆𑀢𑁄 𑀫𑀳𑀸𑀲𑀺𑀔𑀻;

𑀅𑀦𑀼𑀧𑀼𑀩𑁆𑀩𑁂𑀦 𑀛𑀸𑀧𑁂𑀦𑁆𑀢𑁄, 𑀅𑀕𑁆𑀕𑀺 𑀫𑀫𑀫𑀼𑀧𑀸𑀕𑀫𑀺.

‘‘𑀅𑀕𑁆𑀕𑀺𑀯𑁂𑀕𑀪𑀬𑀸𑀢𑀻𑀢𑀸, 𑀢𑀲𑀺𑀢𑀸 𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀸 𑀫𑀫;

𑀓𑀼𑀮𑀸𑀯𑀓𑁂 𑀫𑀁 𑀙𑀟𑁆𑀟𑁂𑀢𑁆𑀯𑀸, 𑀅𑀢𑁆𑀢𑀸𑀦𑀁 𑀧𑀭𑀺𑀫𑁄𑀘𑀬𑀼𑀁.

‘‘𑀧𑀸𑀤𑁂 ¶ 𑀧𑀓𑁆𑀔𑁂 𑀧𑀚𑀳𑀸𑀫𑀺, 𑀦𑀢𑁆𑀣𑀺 𑀫𑁂 𑀓𑀸𑀬𑀺𑀓𑀁 𑀩𑀮𑀁;

𑀲𑁄𑀳𑀁 𑀅𑀕𑀢𑀺𑀓𑁄 𑀢𑀢𑁆𑀣, 𑀏𑀯𑀁 𑀘𑀺𑀦𑁆𑀢𑁂𑀲𑀳𑀁 𑀢𑀤𑀸.

‘‘‘𑀬𑁂𑀲𑀸𑀳𑀁 𑀉𑀧𑀥𑀸𑀯𑁂𑀬𑁆𑀬𑀁, 𑀪𑀻𑀢𑁄 𑀢𑀲𑀺𑀢𑀯𑁂𑀥𑀺𑀢𑁄;

𑀢𑁂 𑀫𑀁 𑀑𑀳𑀸𑀬 𑀧𑀓𑁆𑀓𑀦𑁆𑀢𑀸, 𑀓𑀣𑀁 𑀫𑁂 𑀅𑀚𑁆𑀚 𑀓𑀸𑀢𑀯𑁂.

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

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

‘‘‘𑀆𑀯𑁂𑀚𑁆𑀚𑁂𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀩𑀮𑀁, 𑀲𑀭𑀺𑀢𑁆𑀯𑀸 𑀧𑀼𑀩𑁆𑀩𑀓𑁂 𑀚𑀺𑀦𑁂;

𑀲𑀘𑁆𑀘𑀩𑀮𑀫𑀯𑀲𑁆𑀲𑀸𑀬, 𑀲𑀘𑁆𑀘𑀓𑀺𑀭𑀺𑀬𑀫𑀓𑀸𑀲𑀳𑀁.

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

𑀫𑀸𑀢𑀸𑀧𑀺𑀢𑀸 𑀘 𑀦𑀺𑀓𑁆𑀔𑀦𑁆𑀢𑀸, 𑀚𑀸𑀢𑀯𑁂𑀤 𑀧𑀝𑀺𑀓𑁆𑀓𑀫’.

‘‘𑀲𑀳𑀲𑀘𑁆𑀘𑁂 𑀓𑀢𑁂 𑀫𑀬𑁆𑀳𑀁, 𑀫𑀳𑀸𑀧𑀚𑁆𑀚𑀮𑀺𑀢𑁄 𑀲𑀺𑀔𑀻;

𑀯𑀚𑁆𑀚𑁂𑀲𑀺 𑀲𑁄𑀴𑀲𑀓𑀭𑀻𑀲𑀸𑀦𑀺, 𑀉𑀤𑀓𑀁 𑀧𑀢𑁆𑀯𑀸 𑀬𑀣𑀸 𑀲𑀺𑀔𑀻;

𑀲𑀘𑁆𑀘𑁂𑀦 𑀫𑁂 𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀲𑀘𑁆𑀘𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

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

𑀉𑀡𑁆𑀳𑁂 𑀲𑀽𑀭𑀺𑀬𑀲𑀦𑁆𑀢𑀸𑀧𑁂, 𑀲𑀭𑁂 𑀉𑀤𑀓 𑀔𑀻𑀬𑀣.

‘‘𑀢𑀢𑁄 𑀓𑀸𑀓𑀸 𑀘 𑀕𑀺𑀚𑁆𑀛𑀸 𑀘, 𑀓𑀗𑁆𑀓𑀸 [𑀩𑀓𑀸 (𑀲𑀻.)] 𑀓𑀼𑀮𑀮𑀲𑁂𑀦𑀓𑀸;

𑀪𑀓𑁆𑀔𑀬𑀦𑁆𑀢𑀺 𑀤𑀺𑀯𑀸𑀭𑀢𑁆𑀢𑀺𑀁, 𑀫𑀘𑁆𑀙𑁂 𑀉𑀧𑀦𑀺𑀲𑀻𑀤𑀺𑀬.

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

‘𑀓𑁂𑀦 𑀦𑀼 𑀔𑁄 𑀉𑀧𑀸𑀬𑁂𑀦, 𑀜𑀸𑀢𑀻 𑀤𑀼𑀓𑁆𑀔𑀸 𑀧𑀫𑁄𑀘𑀬𑁂’.

‘‘𑀯𑀺𑀘𑀺𑀦𑁆𑀢𑀬𑀺𑀢𑁆𑀯𑀸 𑀥𑀫𑁆𑀫𑀢𑁆𑀣𑀁, 𑀲𑀘𑁆𑀘𑀁 𑀅𑀤𑁆𑀤𑀲 𑀧𑀲𑁆𑀲𑀬𑀁;

𑀲𑀘𑁆𑀘𑁂 𑀞𑀢𑁆𑀯𑀸 𑀧𑀫𑁄𑀘𑁂𑀲𑀺𑀁, 𑀜𑀸𑀢𑀻𑀦𑀁 𑀢𑀁 𑀅𑀢𑀺𑀓𑁆𑀔𑀬𑀁.

‘‘𑀅𑀦𑀼𑀲𑁆𑀲𑀭𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑀁 𑀥𑀫𑁆𑀫𑀁, 𑀧𑀭𑀫𑀢𑁆𑀣𑀁 𑀯𑀺𑀘𑀺𑀦𑁆𑀢𑀬𑀁;

𑀅𑀓𑀸𑀲𑀺 𑀲𑀘𑁆𑀘𑀓𑀺𑀭𑀺𑀬𑀁, 𑀬𑀁 𑀮𑁄𑀓𑁂 𑀥𑀼𑀯𑀲𑀲𑁆𑀲𑀢𑀁.

‘‘‘𑀬𑀢𑁄 ¶ 𑀲𑀭𑀸𑀫𑀺 𑀅𑀢𑁆𑀢𑀸𑀦𑀁, 𑀬𑀢𑁄 𑀧𑀢𑁆𑀢𑁄𑀲𑁆𑀫𑀺 𑀯𑀺𑀜𑁆𑀜𑀼𑀢𑀁;

𑀦𑀸𑀪𑀺𑀚𑀸𑀦𑀸𑀫𑀺 𑀲𑀜𑁆𑀘𑀺𑀘𑁆𑀘, 𑀏𑀓𑀧𑀸𑀡𑀫𑁆𑀧𑀺 𑀳𑀺𑀁𑀲𑀺𑀢𑀁.

‘‘‘𑀏𑀢𑁂𑀦 ¶ 𑀲𑀘𑁆𑀘𑀯𑀚𑁆𑀚𑁂𑀦, 𑀧𑀚𑁆𑀚𑀼𑀦𑁆𑀦𑁄 𑀅𑀪𑀺𑀯𑀲𑁆𑀲𑀢𑀼;

𑀅𑀪𑀺𑀢𑁆𑀣𑀦𑀬 𑀧𑀚𑁆𑀚𑀼𑀦𑁆𑀦, 𑀦𑀺𑀥𑀺𑀁 𑀓𑀸𑀓𑀲𑁆𑀲 𑀦𑀸𑀲𑀬;

𑀓𑀸𑀓𑀁 𑀲𑁄𑀓𑀸𑀬 𑀭𑀦𑁆𑀥𑁂𑀳𑀺, 𑀫𑀘𑁆𑀙𑁂 𑀲𑁄𑀓𑀸 𑀧𑀫𑁄𑀘𑀬’.

‘‘𑀲𑀳𑀓𑀢𑁂 𑀲𑀘𑁆𑀘𑀯𑀭𑁂, 𑀧𑀚𑁆𑀚𑀼𑀦𑁆𑀦𑁄 𑀅𑀪𑀺𑀕𑀚𑁆𑀚𑀺𑀬;

𑀣𑀮𑀁 𑀦𑀺𑀦𑁆𑀦𑀜𑁆𑀘 𑀧𑀽𑀭𑁂𑀦𑁆𑀢𑁄, 𑀔𑀡𑁂𑀦 𑀅𑀪𑀺𑀯𑀲𑁆𑀲𑀣.

‘‘𑀏𑀯𑀭𑀽𑀧𑀁 𑀲𑀘𑁆𑀘𑀯𑀭𑀁, 𑀓𑀢𑁆𑀯𑀸 𑀯𑀻𑀭𑀺𑀬𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

𑀯𑀲𑁆𑀲𑀸𑀧𑁂𑀲𑀺𑀁 𑀫𑀳𑀸𑀫𑁂𑀖𑀁, 𑀲𑀘𑁆𑀘𑀢𑁂𑀚𑀩𑀮𑀲𑁆𑀲𑀺𑀢𑁄;

𑀲𑀘𑁆𑀘𑁂𑀦 𑀫𑁂 𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀲𑀘𑁆𑀘𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 ¶ 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀓𑀡𑁆𑀳𑀤𑀻𑀧𑀸𑀬𑀦𑁄 𑀇𑀲𑀺;

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

‘‘𑀦 𑀓𑁄𑀘𑀺 𑀏𑀢𑀁 𑀚𑀸𑀦𑀸𑀢𑀺, 𑀅𑀦𑀪𑀺𑀭𑀢𑀺𑀫𑀦𑀁 𑀫𑀫;

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

‘‘𑀲𑀩𑁆𑀭𑀳𑁆𑀫𑀘𑀸𑀭𑀻 ¶ 𑀫𑀡𑁆𑀟𑀩𑁆𑀬𑁄, 𑀲𑀳𑀸𑀬𑁄 𑀫𑁂 𑀫𑀳𑀸𑀇𑀲𑀺;

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

‘‘𑀢𑀫𑀳𑀁 𑀉𑀧𑀝𑁆𑀞𑀳𑀺𑀢𑁆𑀯𑀸𑀦, 𑀆𑀭𑁄𑀕𑁆𑀬𑀫𑀦𑀼𑀧𑀸𑀧𑀬𑀺𑀁;

𑀆𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁆𑀯𑀸𑀦 𑀆𑀕𑀜𑁆𑀙𑀺𑀁, 𑀬𑀁 𑀫𑀬𑁆𑀳𑀁 𑀲𑀓𑀫𑀲𑁆𑀲𑀫𑀁.

‘‘𑀲𑀳𑀸𑀬𑁄 ¶ 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁄 𑀫𑀬𑁆𑀳𑀁, 𑀪𑀭𑀺𑀬𑀁 𑀆𑀤𑀸𑀬 𑀧𑀼𑀢𑁆𑀢𑀓𑀁;

𑀢𑀬𑁄 𑀚𑀦𑀸 𑀲𑀫𑀸𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀆𑀕𑀜𑁆𑀙𑀼𑀁 𑀧𑀸𑀳𑀼𑀦𑀸𑀕𑀢𑀁.

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

𑀤𑀸𑀭𑀓𑁄 𑀯𑀝𑁆𑀝𑀫𑀦𑀼𑀓𑁆𑀔𑀺𑀧𑀁, 𑀆𑀲𑀻𑀯𑀺𑀲𑀫𑀓𑁄𑀧𑀬𑀺.

‘‘𑀢𑀢𑁄 𑀲𑁄 𑀯𑀝𑁆𑀝𑀕𑀢𑀁 𑀫𑀕𑁆𑀕𑀁, 𑀅𑀦𑁆𑀯𑁂𑀲𑀦𑁆𑀢𑁄 𑀓𑀼𑀫𑀸𑀭𑀓𑁄;

𑀆𑀲𑀻𑀯𑀺𑀲𑀲𑁆𑀲 𑀳𑀢𑁆𑀣𑁂𑀦, 𑀉𑀢𑁆𑀢𑀫𑀗𑁆𑀕𑀁 𑀧𑀭𑀸𑀫𑀲𑀺.

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀆𑀫𑀲𑀦𑁂 𑀓𑀼𑀤𑁆𑀥𑁄, 𑀲𑀧𑁆𑀧𑁄 𑀯𑀺𑀲𑀩𑀮𑀲𑁆𑀲𑀺𑀢𑁄;

𑀓𑀼𑀧𑀺𑀢𑁄 𑀧𑀭𑀫𑀓𑁄𑀧𑁂𑀦, 𑀅𑀟𑀁𑀲𑀺 𑀤𑀸𑀭𑀓𑀁 𑀔𑀡𑁂.

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

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

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

𑀧𑀞𑀫𑀁 𑀅𑀓𑀸𑀲𑀺𑀁 𑀓𑀺𑀭𑀺𑀬𑀁, 𑀅𑀕𑁆𑀕𑀁 𑀲𑀘𑁆𑀘𑀁 𑀯𑀭𑀼𑀢𑁆𑀢𑀫𑀁.

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

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

‘‘‘𑀅𑀓𑀸𑀫𑀓𑁄 𑀯𑀸𑀳𑀺 𑀅𑀳𑀁 𑀘𑀭𑀸𑀫𑀺, 𑀏𑀢𑁂𑀦 𑀲𑀘𑁆𑀘𑁂𑀦 𑀲𑀼𑀯𑀢𑁆𑀣𑀺 𑀳𑁄𑀢𑀼;

𑀳𑀢𑀁 𑀯𑀺𑀲𑀁 𑀚𑀻𑀯𑀢𑀼 𑀬𑀜𑁆𑀜𑀤𑀢𑁆𑀢𑁄’.

‘‘𑀲𑀳 ¶ ¶ 𑀲𑀘𑁆𑀘𑁂 𑀓𑀢𑁂 𑀫𑀬𑁆𑀳𑀁, 𑀯𑀺𑀲𑀯𑁂𑀕𑁂𑀦 𑀯𑁂𑀥𑀺𑀢𑁄;

𑀅𑀩𑀼𑀚𑁆𑀛𑀺𑀢𑁆𑀯𑀸𑀦 𑀯𑀼𑀝𑁆𑀞𑀸𑀲𑀺, 𑀅𑀭𑁄𑀕𑁄 𑀘𑀸𑀲𑀺 𑀫𑀸𑀡𑀯𑁄;

𑀲𑀘𑁆𑀘𑁂𑀦 𑀫𑁂 𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀲𑀘𑁆𑀘𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

𑀓𑀡𑁆𑀳𑀤𑀻𑀧𑀸𑀬𑀦𑀘𑀭𑀺𑀬𑀁 𑀏𑀓𑀸𑀤𑀲𑀫𑀁.

‘‘𑀧𑀼𑀦𑀸𑀧𑀭𑀁 𑀬𑀤𑀸 𑀳𑁄𑀫𑀺, 𑀲𑀼𑀢𑀲𑁄𑀫𑁄 𑀫𑀳𑀻𑀧𑀢𑀺;

𑀕𑀳𑀺𑀢𑁄 𑀧𑁄𑀭𑀺𑀲𑀸𑀤𑁂𑀦, 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑁂 𑀲𑀗𑁆𑀕𑀭𑀁 𑀲𑀭𑀺𑀁.

‘‘𑀔𑀢𑁆𑀢𑀺𑀬𑀸𑀦𑀁 𑀏𑀓𑀲𑀢𑀁, 𑀆𑀯𑀼𑀡𑀺𑀢𑁆𑀯𑀸 𑀓𑀭𑀢𑁆𑀢𑀮𑁂;

𑀏𑀢𑁂𑀲𑀁 𑀧𑀫𑀺𑀮𑀸𑀧𑁂𑀢𑁆𑀯𑀸, 𑀬𑀜𑁆𑀜𑀢𑁆𑀣𑁂 𑀉𑀧𑀦𑀬𑀻 𑀫𑀫𑀁.

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

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

‘‘𑀢𑀲𑁆𑀲 ¶ 𑀧𑀝𑀺𑀲𑁆𑀲𑀼𑀡𑀺𑀢𑁆𑀯𑀸𑀦, 𑀧𑀡𑁆𑀳𑁂 𑀆𑀕𑀫𑀦𑀁 𑀫𑀫;

𑀉𑀧𑀕𑀦𑁆𑀢𑁆𑀯𑀸 𑀧𑀼𑀭𑀁 𑀭𑀫𑁆𑀫𑀁, 𑀭𑀚𑁆𑀚𑀁 𑀦𑀺𑀬𑁆𑀬𑀸𑀤𑀬𑀺𑀁 𑀢𑀤𑀸.

‘‘𑀅𑀦𑀼𑀲𑁆𑀲𑀭𑀺𑀢𑁆𑀯𑀸 𑀲𑀢𑀁 𑀥𑀫𑁆𑀫𑀁, 𑀧𑀼𑀩𑁆𑀩𑀓𑀁 𑀚𑀺𑀦𑀲𑁂𑀯𑀺𑀢𑀁;

𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀲𑁆𑀲 𑀥𑀦𑀁 𑀤𑀢𑁆𑀯𑀸, 𑀧𑁄𑀭𑀺𑀲𑀸𑀤𑀁 𑀉𑀧𑀸𑀕𑀫𑀺𑀁.

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

𑀲𑀘𑁆𑀘𑀯𑀸𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀦𑁆𑀢𑁄, 𑀚𑀻𑀯𑀺𑀢𑀁 𑀘𑀚𑀺𑀢𑀼𑀫𑀼𑀧𑀸𑀕𑀫𑀺𑀁;

𑀲𑀘𑁆𑀘𑁂𑀦 𑀫𑁂 𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀲𑀘𑁆𑀘𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

‘‘𑀲𑀸𑀫𑁄 ¶ ¶ 𑀬𑀤𑀸 𑀯𑀦𑁂 𑀆𑀲𑀺𑀁, 𑀲𑀓𑁆𑀓𑁂𑀦 𑀅𑀪𑀺𑀦𑀺𑀫𑁆𑀫𑀺𑀢𑁄;

𑀧𑀯𑀦𑁂 𑀲𑀻𑀳𑀩𑁆𑀬𑀕𑁆𑀖𑁂 𑀘, 𑀫𑁂𑀢𑁆𑀢𑀸𑀬𑀫𑀼𑀧𑀦𑀸𑀫𑀬𑀺𑀁.

‘‘𑀲𑀻𑀳𑀩𑁆𑀬𑀕𑁆𑀖𑁂𑀳𑀺 𑀤𑀻𑀧𑀻𑀳𑀺, 𑀅𑀘𑁆𑀙𑁂𑀳𑀺 𑀫𑀳𑀺𑀲𑁂𑀳𑀺 𑀘;

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

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

𑀫𑁂𑀢𑁆𑀢𑀸𑀩𑀮𑁂𑀦𑀼𑀧𑀢𑁆𑀣𑀤𑁆𑀥𑁄, 𑀭𑀫𑀸𑀫𑀺 𑀧𑀯𑀦𑁂 𑀢𑀤𑀸’’𑀢𑀺.

𑀲𑀼𑀯𑀡𑁆𑀡𑀲𑀸𑀫𑀘𑀭𑀺𑀬𑀁 𑀢𑁂𑀭𑀲𑀫𑀁.

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

𑀧𑀭𑀫𑀁 𑀲𑀻𑀮𑀁 𑀅𑀥𑀺𑀝𑁆𑀞𑀸𑀬, 𑀧𑀲𑀸𑀲𑀸𑀫𑀺 𑀫𑀳𑀸𑀫𑀳𑀺𑀁.

‘‘𑀤𑀲 𑀓𑀼𑀲𑀮𑀓𑀫𑁆𑀫𑀧𑀣𑁂, 𑀯𑀢𑁆𑀢𑀸𑀫𑀺 𑀅𑀦𑀯𑀲𑁂𑀲𑀢𑁄;

𑀘𑀢𑀽𑀳𑀺 𑀲𑀗𑁆𑀕𑀳𑀯𑀢𑁆𑀣𑀽𑀳𑀺, 𑀲𑀗𑁆𑀕𑀡𑁆𑀳𑀸𑀫𑀺 [𑀲𑀗𑁆𑀕𑀳𑀸𑀫𑀺 (𑀓.)] 𑀫𑀳𑀸𑀚𑀦𑀁.

‘‘𑀏𑀯𑀁 𑀫𑁂 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑀲𑁆𑀲, 𑀇𑀥 𑀮𑁄𑀓𑁂 𑀧𑀭𑀢𑁆𑀣 𑀘;

𑀤𑀩𑁆𑀩𑀲𑁂𑀦𑁄 ¶ 𑀉𑀧𑀕𑀦𑁆𑀢𑁆𑀯𑀸, 𑀅𑀘𑁆𑀙𑀺𑀦𑁆𑀤𑀦𑁆𑀢𑁄 𑀧𑀼𑀭𑀁 𑀫𑀫.

‘‘𑀭𑀸𑀚𑀽𑀧𑀚𑀻𑀯𑁂 ¶ 𑀦𑀺𑀕𑀫𑁂, 𑀲𑀩𑀮𑀝𑁆𑀞𑁂 𑀲𑀭𑀝𑁆𑀞𑀓𑁂;

𑀲𑀩𑁆𑀩𑀁 𑀳𑀢𑁆𑀣𑀕𑀢𑀁 𑀓𑀢𑁆𑀯𑀸, 𑀓𑀸𑀲𑀼𑀬𑀸 𑀦𑀺𑀔𑀡𑀻 𑀫𑀫𑀁.

‘‘𑀅𑀫𑀘𑁆𑀘𑀫𑀡𑁆𑀟𑀮𑀁 𑀭𑀚𑁆𑀚𑀁, 𑀨𑀻𑀢𑀁 𑀅𑀦𑁆𑀢𑁂𑀧𑀼𑀭𑀁 𑀫𑀫;

𑀅𑀘𑁆𑀙𑀺𑀦𑁆𑀤𑀺𑀢𑁆𑀯𑀸𑀦 𑀕𑀳𑀺𑀢𑀁, 𑀧𑀺𑀬𑀁 𑀧𑀼𑀢𑁆𑀢𑀁𑀯 𑀧𑀲𑁆𑀲𑀳𑀁;

𑀫𑁂𑀢𑁆𑀢𑀸𑀬 𑀫𑁂 𑀲𑀫𑁄 𑀦𑀢𑁆𑀣𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀫𑁂𑀢𑁆𑀢𑀸𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

‘‘𑀲𑀼𑀲𑀸𑀦𑁂 ¶ ¶ 𑀲𑁂𑀬𑁆𑀬𑀁 𑀓𑀧𑁆𑀧𑁂𑀫𑀺, 𑀙𑀯𑀝𑁆𑀞𑀺𑀓𑀁 𑀉𑀧𑀦𑀺𑀥𑀸𑀬𑀳𑀁;

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

‘‘𑀅𑀧𑀭𑁂 𑀕𑀦𑁆𑀥𑀫𑀸𑀮𑀜𑁆𑀘, 𑀪𑁄𑀚𑀦𑀁 𑀯𑀺𑀯𑀺𑀥𑀁 𑀩𑀳𑀼𑀁;

𑀉𑀧𑀸𑀬𑀦𑀸𑀦𑀽𑀧𑀦𑁂𑀦𑁆𑀢𑀺, 𑀳𑀝𑁆𑀞𑀸 𑀲𑀁𑀯𑀺𑀕𑁆𑀕𑀫𑀸𑀦𑀲𑀸.

‘‘𑀬𑁂 𑀫𑁂 𑀤𑀼𑀓𑁆𑀔𑀁 𑀉𑀧𑀳𑀭𑀦𑁆𑀢𑀺, 𑀬𑁂 𑀘 𑀤𑁂𑀦𑁆𑀢𑀺 𑀲𑀼𑀔𑀁 𑀫𑀫;

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

‘‘𑀲𑀼𑀔𑀤𑀼𑀓𑁆𑀔𑁂 𑀢𑀼𑀮𑀸𑀪𑀽𑀢𑁄, 𑀬𑀲𑁂𑀲𑀼 𑀅𑀬𑀲𑁂𑀲𑀼 𑀘;

𑀲𑀩𑁆𑀩𑀢𑁆𑀣 𑀲𑀫𑀓𑁄 𑀳𑁄𑀫𑀺, 𑀏𑀲𑀸 𑀫𑁂 𑀉𑀧𑁂𑀓𑁆𑀔𑀸𑀧𑀸𑀭𑀫𑀻’’𑀢𑀺.

𑀫𑀳𑀸𑀮𑁄𑀫𑀳𑀁𑀲𑀘𑀭𑀺𑀬𑀁 𑀧𑀦𑁆𑀦𑀭𑀲𑀫𑀁.

𑀬𑀼𑀥𑀜𑁆𑀚𑀬𑁄 𑀲𑁄𑀫𑀦𑀲𑁆𑀲𑁄, 𑀅𑀬𑁄𑀖𑀭𑀪𑀺𑀲𑁂𑀦 𑀘;

𑀲𑁄𑀡𑀦𑀦𑁆𑀤𑁄 𑀫𑀽𑀕𑀧𑀓𑁆𑀔𑁄, 𑀓𑀧𑀺𑀭𑀸𑀚𑀸 𑀲𑀘𑁆𑀘𑀲𑀯𑁆𑀳𑀬𑁄.

𑀯𑀝𑁆𑀝𑀓𑁄 𑀫𑀘𑁆𑀙𑀭𑀸𑀚𑀸 𑀘, 𑀓𑀡𑁆𑀳𑀤𑀻𑀧𑀸𑀬𑀦𑁄 𑀇𑀲𑀺;

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

𑀉𑀧𑁂𑀓𑁆𑀔𑀸𑀧𑀸𑀭𑀫𑀻 𑀆𑀲𑀺, 𑀇𑀢𑀺 𑀯𑀼𑀢𑁆𑀣𑀁 [𑀯𑀼𑀢𑁆𑀢𑀁 (𑀲𑀩𑁆𑀩𑀢𑁆𑀣) 𑀅𑀝𑁆𑀞𑀓𑀣𑀸 𑀑𑀮𑁄𑀓𑁂𑀢𑀩𑁆𑀩𑀸] 𑀫𑀳𑁂𑀲𑀺𑀦𑀸.

𑀏𑀯𑀁 ¶ 𑀩𑀳𑀼𑀩𑁆𑀩𑀺𑀥𑀁 𑀤𑀼𑀓𑁆𑀔𑀁, 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀻 𑀘 𑀩𑀳𑀼𑀩𑁆𑀩𑀺𑀥𑀸 [𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀺 𑀘 𑀩𑀳𑀼𑀯𑀺𑀥𑀸 (𑀲𑀻.), 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀺𑀁 𑀘 𑀩𑀳𑀼𑀯𑀺𑀥𑀁 (𑀓.)];

𑀪𑀯𑀸𑀪𑀯𑁂 𑀅𑀦𑀼𑀪𑀯𑀺𑀢𑁆𑀯𑀸, 𑀧𑀢𑁆𑀢𑁄 𑀲𑀫𑁆𑀩𑁄𑀥𑀺𑀫𑀼𑀢𑁆𑀢𑀫𑀁.

𑀤𑀢𑁆𑀯𑀸 𑀤𑀸𑀢𑀩𑁆𑀩𑀓𑀁 𑀤𑀸𑀦𑀁, 𑀲𑀻𑀮𑀁 𑀧𑀽𑀭𑁂𑀢𑁆𑀯𑀸 𑀅𑀲𑁂𑀲𑀢𑁄;

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

𑀧𑀡𑁆𑀟𑀺𑀢𑁂 ¶ 𑀧𑀭𑀺𑀧𑀼𑀘𑁆𑀙𑀺𑀢𑁆𑀯𑀸, 𑀯𑀻𑀭𑀺𑀬𑀁 𑀓𑀢𑁆𑀯𑀸𑀦 𑀫𑀼𑀢𑁆𑀢𑀫𑀁;

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

𑀓𑀢𑁆𑀯𑀸 𑀤𑀴𑁆𑀳𑀫𑀥𑀺𑀝𑁆𑀞𑀸𑀦𑀁, 𑀲𑀘𑁆𑀘𑀯𑀸𑀘𑀸𑀦𑀼𑀭𑀓𑁆𑀔𑀺𑀬;

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

𑀮𑀸𑀪𑀸𑀮𑀸𑀪𑁂 ¶ 𑀬𑀲𑀸𑀬𑀲𑁂, 𑀲𑀫𑁆𑀫𑀸𑀦𑀦𑀸𑀯𑀫𑀸𑀦𑀦𑁂;

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

𑀓𑁄𑀲𑀚𑁆𑀚𑀁 𑀪𑀬𑀢𑁄 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀯𑀻𑀭𑀺𑀬𑀸𑀭𑀫𑁆𑀪𑀜𑁆𑀘 𑀔𑁂𑀫𑀢𑁄;

𑀆𑀭𑀤𑁆𑀥𑀯𑀻𑀭𑀺𑀬𑀸 𑀳𑁄𑀣, 𑀏𑀲𑀸 𑀩𑀼𑀤𑁆𑀥𑀸𑀦𑀼𑀲𑀸𑀲𑀦𑀻.

𑀯𑀺𑀯𑀸𑀤𑀁 𑀪𑀬𑀢𑁄 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀅𑀯𑀺𑀯𑀸𑀤𑀜𑁆𑀘 𑀔𑁂𑀫𑀢𑁄;

𑀲𑀫𑀕𑁆𑀕𑀸 𑀲𑀔𑀺𑀮𑀸 𑀳𑁄𑀣, 𑀏𑀲𑀸 𑀩𑀼𑀤𑁆𑀥𑀸𑀦𑀼𑀲𑀸𑀲𑀦𑀻.

𑀧𑀫𑀸𑀤𑀁 𑀪𑀬𑀢𑁄 𑀤𑀺𑀲𑁆𑀯𑀸, 𑀅𑀧𑁆𑀧𑀫𑀸𑀤𑀜𑁆𑀘 𑀔𑁂𑀫𑀢𑁄;

𑀪𑀸𑀯𑁂𑀣𑀝𑁆𑀞𑀗𑁆𑀕𑀺𑀓𑀁 𑀫𑀕𑁆𑀕𑀁, 𑀏𑀲𑀸 𑀩𑀼𑀤𑁆𑀥𑀸𑀦𑀼𑀲𑀸𑀲𑀦𑀻.

𑀇𑀢𑁆𑀣𑀁 𑀲𑀼𑀤𑀁 𑀪𑀕𑀯𑀸 𑀅𑀢𑁆𑀢𑀦𑁄 𑀧𑀼𑀩𑁆𑀩𑀘𑀭𑀺𑀬𑀁 𑀲𑀫𑁆𑀪𑀸𑀯𑀬𑀫𑀸𑀦𑁄 𑀩𑀼𑀤𑁆𑀥𑀸𑀧𑀤𑀸𑀦𑀺𑀬𑀁 𑀦𑀸𑀫 𑀥𑀫𑁆𑀫𑀧𑀭𑀺𑀬𑀸𑀬𑀁 𑀅𑀪𑀸𑀲𑀺𑀢𑁆𑀣𑀸𑀢𑀺.