𑁫𑁩𑁪. 𑀫𑀳𑀸𑀳𑀁𑀲𑀚𑀸𑀢𑀓𑀁 (𑁨)

𑁮𑁯. ‘‘𑀏𑀢𑁂 𑀳𑀁𑀲𑀸 𑀧𑀓𑁆𑀓𑀫𑀦𑁆𑀢𑀺, 𑀯𑀓𑁆𑀓𑀗𑁆𑀕𑀸 𑀪𑀬𑀫𑁂𑀭𑀺𑀢𑀸;

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

𑁯𑁦. ‘‘𑀑𑀳𑀸𑀬 𑀫𑀁 𑀜𑀸𑀢𑀺𑀕𑀡𑀸, 𑀏𑀓𑀁 𑀧𑀸𑀲𑀯𑀲𑀁 𑀕𑀢𑀁;

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

𑁯𑁧. ‘‘𑀧𑀢𑁂𑀯 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀦𑀢𑁆𑀣𑀺 𑀩𑀤𑁆𑀥𑁂 𑀲𑀳𑀸𑀬𑀢𑀸;

𑀫𑀸 𑀅𑀦𑀻𑀖𑀸𑀬 𑀳𑀸𑀧𑁂𑀲𑀺, 𑀓𑀸𑀫𑀁 𑀲𑀼𑀫𑀼𑀔 𑀧𑀓𑁆𑀓𑀫’’.

𑁯𑁨. ‘‘𑀦𑀸𑀳𑀁 𑀤𑀼𑀓𑁆𑀔𑀧𑀭𑁂𑀢𑁄𑀧𑀺 [𑀤𑀼𑀓𑁆𑀔𑀧𑀭𑁂𑀢𑁄’’𑀢𑀺 (𑀚𑀸. 𑁧.𑁧𑁫.𑁧𑁩𑁬) 𑀅𑀝𑁆𑀞𑀓𑀣𑀸𑀬𑁄 𑀑𑀮𑁄𑀓𑁂𑀢𑀩𑁆𑀩𑀸], 𑀥𑀢𑀭𑀝𑁆𑀞 𑀢𑀼𑀯𑀁 [𑀢𑀯𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀚𑀳𑁂;

𑀚𑀻𑀯𑀺𑀢𑀁 𑀫𑀭𑀡𑀁 𑀯𑀸 𑀫𑁂, 𑀢𑀬𑀸 𑀲𑀤𑁆𑀥𑀺𑀁 𑀪𑀯𑀺𑀲𑁆𑀲𑀢𑀺.

𑁯𑁩. ‘‘𑀦𑀸𑀳𑀁 𑀤𑀼𑀓𑁆𑀔𑀧𑀭𑁂𑀢𑁄𑀧𑀺, 𑀥𑀢𑀭𑀝𑁆𑀞 𑀢𑀼𑀯𑀁 𑀚𑀳𑁂;

𑀦 𑀫𑀁 𑀅𑀦𑀭𑀺𑀬𑀲𑀁𑀬𑀼𑀢𑁆𑀢𑁂, 𑀓𑀫𑁆𑀫𑁂 𑀬𑁄𑀚𑁂𑀢𑀼𑀫𑀭𑀳𑀲𑀺.

𑁯𑁪. ‘‘𑀲𑀓𑀼𑀫𑀸𑀭𑁄 𑀲𑀔𑀸 𑀢𑁆𑀬𑀲𑁆𑀫𑀺, 𑀲𑀘𑀺𑀢𑁆𑀢𑁂 𑀘𑀲𑁆𑀫𑀺 𑀢𑁂 [𑀲𑀫𑀺𑀢𑁂 (𑀧𑀻.), 𑀢𑁆𑀬𑀲𑁆𑀫𑀺 𑀢𑁂 (𑀓.)] 𑀞𑀺𑀢𑁄;

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

𑁯𑁫. ‘‘𑀓𑀣𑀁 𑀅𑀳𑀁 𑀯𑀺𑀓𑀢𑁆𑀣𑀺𑀲𑁆𑀲𑀁 [𑀯𑀺𑀓𑀢𑁆𑀢𑀺𑀲𑁆𑀲𑀁 (𑀧𑀻.)], 𑀜𑀸𑀢𑀺𑀫𑀚𑁆𑀛𑁂 𑀇𑀢𑁄 𑀕𑀢𑁄;

𑀢𑀁 𑀳𑀺𑀢𑁆𑀯𑀸 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀓𑀺𑀁 𑀢𑁂 𑀯𑀓𑁆𑀔𑀸𑀫𑀺𑀢𑁄 𑀕𑀢𑁄;

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

𑁯𑁬. ‘‘𑀏𑀲𑁄 𑀳𑀺 𑀥𑀫𑁆𑀫𑁄 𑀲𑀼𑀫𑀼𑀔, 𑀬𑀁 𑀢𑁆𑀯𑀁 𑀅𑀭𑀺𑀬𑀧𑀣𑁂 𑀞𑀺𑀢𑁄;

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

𑁯𑁭. ‘‘𑀢𑀜𑁆𑀳𑀺 𑀫𑁂 𑀧𑁂𑀓𑁆𑀔𑀫𑀸𑀦𑀲𑁆𑀲, 𑀪𑀬𑀁 𑀦𑀢𑁆𑀯𑁂𑀯 𑀚𑀸𑀬𑀢𑀺;

𑀅𑀥𑀺𑀕𑀘𑁆𑀙𑀲𑀺 𑀢𑁆𑀯𑀁 𑀫𑀬𑁆𑀳𑀁, 𑀏𑀯𑀁 𑀪𑀽𑀢𑀲𑁆𑀲 𑀚𑀻𑀯𑀺𑀢𑀁’’.

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

𑀤𑀡𑁆𑀟𑀫𑀸𑀤𑀸𑀬 𑀦𑁂𑀲𑀸𑀤𑁄, 𑀆𑀧𑀢𑀻 [𑀆𑀧𑀤𑀻 (𑀓.)] 𑀢𑀼𑀭𑀺𑀢𑁄 𑀪𑀼𑀲𑀁.

𑁯𑁯. ‘‘𑀢𑀫𑀸𑀧𑀢𑀦𑁆𑀢𑀁 𑀤𑀺𑀲𑁆𑀯𑀸𑀦, 𑀲𑀼𑀫𑀼𑀔𑁄 𑀅𑀢𑀺𑀩𑁆𑀭𑀽𑀳𑀬𑀺 [𑀅𑀧𑀭𑀺𑀩𑁆𑀭𑀽𑀳𑀬𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀅𑀝𑁆𑀞𑀸𑀲𑀺 𑀧𑀼𑀭𑀢𑁄 𑀭𑀜𑁆𑀜𑁄, 𑀳𑀁𑀲𑁄 𑀯𑀺𑀲𑁆𑀲𑀸𑀲𑀬𑀁 𑀩𑁆𑀬𑀥𑀁 [𑀩𑁆𑀬𑀣𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)].

𑁧𑁦𑁦. ‘‘𑀫𑀸 𑀪𑀸𑀬𑀺 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀦 𑀳𑀺 𑀪𑀸𑀬𑀦𑁆𑀢𑀺 𑀢𑀸𑀤𑀺𑀲𑀸;

𑀅𑀳𑀁 𑀬𑁄𑀕𑀁 𑀧𑀬𑀼𑀜𑁆𑀚𑀺𑀲𑁆𑀲𑀁, 𑀬𑀼𑀢𑁆𑀢𑀁 𑀥𑀫𑁆𑀫𑀽𑀧𑀲𑀁𑀳𑀺𑀢𑀁;

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

𑁧𑁦𑁧. ‘‘𑀢𑀲𑁆𑀲 𑀢𑀁 𑀯𑀘𑀦𑀁 𑀲𑀼𑀢𑁆𑀯𑀸, 𑀲𑀼𑀫𑀼𑀔𑀲𑁆𑀲 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁;

𑀧𑀳𑀝𑁆𑀞𑀮𑁄𑀫𑁄 𑀦𑁂𑀲𑀸𑀤𑁄, 𑀅𑀜𑁆𑀚𑀮𑀺𑀲𑁆𑀲 𑀧𑀡𑀸𑀫𑀬𑀺.

𑁧𑁦𑁨. ‘‘𑀦 𑀫𑁂 𑀲𑀼𑀢𑀁 𑀯𑀸 𑀤𑀺𑀝𑁆𑀞𑀁 𑀯𑀸, 𑀪𑀸𑀲𑀦𑁆𑀢𑁄 𑀫𑀸𑀦𑀼𑀲𑀺𑀁 𑀤𑀺𑀚𑁄;

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

𑁧𑁦𑁩. ‘‘𑀓𑀺𑀦𑁆𑀦𑀼 𑀢𑀸𑀬𑀁 𑀤𑀺𑀚𑁄 𑀳𑁄𑀢𑀺, 𑀫𑀼𑀢𑁆𑀢𑁄 𑀩𑀤𑁆𑀥𑀁 𑀉𑀧𑀸𑀲𑀲𑀺;

𑀑𑀳𑀸𑀬 𑀲𑀓𑀼𑀡𑀸 𑀬𑀦𑁆𑀢𑀺, 𑀓𑀺𑀁 𑀏𑀓𑁄 𑀅𑀯𑀳𑀻𑀬𑀲𑀺’’.

𑁧𑁦𑁪. ‘‘𑀭𑀸𑀚𑀸 𑀫𑁂 𑀲𑁄 𑀤𑀺𑀚𑀸𑀫𑀺𑀢𑁆𑀢, 𑀲𑁂𑀦𑀸𑀧𑀘𑁆𑀘𑀲𑁆𑀲 𑀓𑀸𑀭𑀬𑀺𑀁;

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

𑁧𑁦𑁫. ‘‘𑀫𑀳𑀸𑀕𑀡𑀸𑀬 𑀪𑀢𑁆𑀢𑀸 𑀫𑁂, 𑀫𑀸 𑀏𑀓𑁄 𑀩𑁆𑀬𑀲𑀦𑀁 𑀅𑀕𑀸;

𑀢𑀣𑀸 𑀢𑀁 𑀲𑀫𑁆𑀫 𑀦𑁂𑀲𑀸𑀤, 𑀪𑀢𑁆𑀢𑀸𑀬𑀁 𑀅𑀪𑀺𑀢𑁄 𑀭𑀫𑁂’’.

𑁧𑁦𑁬. ‘‘𑀅𑀭𑀺𑀬𑀯𑀢𑁆𑀢𑀲𑀺 𑀯𑀓𑁆𑀓𑀗𑁆𑀕, 𑀬𑁄 𑀧𑀺𑀡𑁆𑀟𑀫𑀧𑀘𑀸𑀬𑀲𑀺;

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

𑁧𑁦𑁭. ‘‘𑀲𑀘𑁂 𑀅𑀢𑁆𑀢𑀧𑁆𑀧𑀬𑁄𑀕𑁂𑀦, 𑀑𑀳𑀺𑀢𑁄 𑀳𑀁𑀲𑀧𑀓𑁆𑀔𑀺𑀦𑀁;

𑀧𑀝𑀺𑀕𑀡𑁆𑀳𑀸𑀫 𑀢𑁂 𑀲𑀫𑁆𑀫, 𑀏𑀢𑀁 𑀅𑀪𑀬𑀤𑀓𑁆𑀔𑀺𑀡𑀁.

𑁧𑁦𑁮. ‘‘𑀦𑁄 𑀘𑁂 𑀅𑀢𑁆𑀢𑀧𑁆𑀧𑀬𑁄𑀕𑁂𑀦, 𑀑𑀳𑀺𑀢𑁄 𑀳𑀁𑀲𑀧𑀓𑁆𑀔𑀺𑀦𑀁;

𑀅𑀦𑀺𑀲𑁆𑀲𑀭𑁄 𑀫𑀼𑀜𑁆𑀘𑀫𑀫𑁆𑀳𑁂, 𑀣𑁂𑀬𑁆𑀬𑀁 𑀓𑀬𑀺𑀭𑀸𑀲𑀺 𑀮𑀼𑀤𑁆𑀤𑀓’’.

𑁧𑁦𑁯. ‘‘𑀬𑀲𑁆𑀲 𑀢𑁆𑀯𑀁 𑀪𑀢𑀓𑁄 [𑀪𑀝𑀓𑁄 (𑀓.)] 𑀭𑀜𑁆𑀜𑁄, 𑀓𑀸𑀫𑀁 𑀢𑀲𑁆𑀲𑁂𑀯 𑀧𑀸𑀧𑀬;

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

𑁧𑁧𑁦. ‘‘𑀇𑀘𑁆𑀘𑁂𑀯𑀁 𑀯𑀼𑀢𑁆𑀢𑁄 𑀦𑁂𑀲𑀸𑀤𑁄, 𑀳𑁂𑀫𑀯𑀡𑁆𑀡𑁂 𑀳𑀭𑀺𑀢𑁆𑀢𑀘𑁂;

𑀉𑀪𑁄 𑀳𑀢𑁆𑀣𑁂𑀳𑀺 𑀲𑀗𑁆𑀕𑀬𑁆𑀳 [𑀧𑀕𑁆𑀕𑀬𑁆𑀳 (𑀲𑁆𑀬𑀸. 𑀓.)], 𑀧𑀜𑁆𑀚𑀭𑁂 𑀅𑀚𑁆𑀛𑀯𑁄𑀤𑀳𑀺.

𑁧𑁧𑁧. ‘‘𑀢𑁂 𑀧𑀜𑁆𑀚𑀭𑀕𑀢𑁂 𑀧𑀓𑁆𑀔𑀻, 𑀉𑀪𑁄 𑀪𑀲𑁆𑀲𑀭𑀯𑀡𑁆𑀡𑀺𑀦𑁂;

𑀲𑀼𑀫𑀼𑀔𑀁 𑀥𑀢𑀭𑀝𑁆𑀞𑀜𑁆𑀘, 𑀮𑀼𑀤𑁆𑀤𑁄 𑀆𑀤𑀸𑀬 𑀧𑀓𑁆𑀓𑀫𑀺’’.

𑁧𑁧𑁨. ‘‘𑀳𑀭𑀻𑀬𑀫𑀸𑀦𑁄 𑀥𑀢𑀭𑀝𑁆𑀞𑁄, 𑀲𑀼𑀫𑀼𑀔𑀁 𑀏𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

𑀩𑀸𑀴𑁆𑀳𑀁 𑀪𑀸𑀬𑀸𑀫𑀺 𑀲𑀼𑀫𑀼𑀔, 𑀲𑀸𑀫𑀸𑀬 𑀮𑀓𑁆𑀔𑀡𑀽𑀭𑀼𑀬𑀸;

𑀅𑀲𑁆𑀫𑀸𑀓𑀁 𑀯𑀥𑀫𑀜𑁆𑀜𑀸𑀬, 𑀅𑀣𑀢𑁆𑀢𑀸𑀦𑀁 𑀯𑀥𑀺𑀲𑁆𑀲𑀢𑀺.

𑁧𑁧𑁩. ‘‘𑀧𑀸𑀓𑀳𑀁𑀲𑀸 𑀘 𑀲𑀼𑀫𑀼𑀔, 𑀲𑀼𑀳𑁂𑀫𑀸 𑀳𑁂𑀫𑀲𑀼𑀢𑁆𑀢𑀘𑀸;

𑀓𑁄𑀜𑁆𑀘𑀻 𑀲𑀫𑀼𑀤𑁆𑀤𑀢𑀻𑀭𑁂𑀯, 𑀓𑀧𑀡𑀸 𑀦𑀽𑀦 𑀭𑀼𑀘𑁆𑀙𑀢𑀺’’.

𑁧𑁧𑁪. ‘‘𑀏𑀯𑀁 𑀫𑀳𑀦𑁆𑀢𑁄 𑀮𑁄𑀓𑀲𑁆𑀲, 𑀅𑀧𑁆𑀧𑀫𑁂𑀬𑁆𑀬𑁄 𑀫𑀳𑀸𑀕𑀡𑀻;

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

𑁧𑁧𑁫. ‘‘𑀯𑀸𑀢𑁄𑀯 𑀕𑀦𑁆𑀥𑀫𑀸𑀤𑁂𑀢𑀺, 𑀉𑀪𑀬𑀁 𑀙𑁂𑀓𑀧𑀸𑀧𑀓𑀁;

𑀩𑀸𑀮𑁄 𑀆𑀫𑀓𑀧𑀓𑁆𑀓𑀁𑀯, 𑀮𑁄𑀮𑁄 𑀅𑀦𑁆𑀥𑁄𑀯 𑀆𑀫𑀺𑀲𑀁.

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

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

𑁧𑁧𑁭. ‘‘𑀅𑀟𑁆𑀠𑀼𑀫𑁆𑀫𑀢𑁆𑀢𑁄 𑀉𑀤𑀻𑀭𑁂𑀲𑀺, 𑀬𑁄 𑀲𑁂𑀬𑁆𑀬𑀸 𑀫𑀜𑁆𑀜𑀲𑀺𑀢𑁆𑀣𑀺𑀬𑁄;

𑀩𑀳𑀼𑀲𑀸𑀥𑀸𑀭𑀡𑀸 𑀳𑁂𑀢𑀸, 𑀲𑁄𑀡𑁆𑀟𑀸𑀦𑀁𑀯 𑀲𑀼𑀭𑀸𑀖𑀭𑀁.

𑁧𑁧𑁮. ‘‘𑀫𑀸𑀬𑀸 𑀘𑁂𑀲𑀸 𑀫𑀭𑀻𑀘𑀻 𑀘, 𑀲𑁄𑀓𑁄 𑀭𑁄𑀕𑁄 𑀘𑀼𑀧𑀤𑁆𑀤𑀯𑁄;

𑀔𑀭𑀸 𑀘 𑀩𑀦𑁆𑀥𑀦𑀸 𑀘𑁂𑀢𑀸, 𑀫𑀘𑁆𑀘𑀼𑀧𑀸𑀲𑀸 𑀕𑀼𑀳𑀸𑀲𑀬𑀸 [𑀧𑀘𑁆𑀘𑀼𑀧𑀸𑀲𑁄 𑀕𑀼𑀳𑀸𑀲𑀬𑁄 (𑀲𑀻. 𑀧𑀻.)];

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

𑁧𑁧𑁯. ‘‘𑀬𑀁 𑀯𑀼𑀤𑁆𑀥𑁂𑀳𑀺 𑀉𑀧𑀜𑁆𑀜𑀸𑀢𑀁, 𑀓𑁄 𑀢𑀁 𑀦𑀺𑀦𑁆𑀤𑀺𑀢𑀼𑀫𑀭𑀳𑀢𑀺;

𑀫𑀳𑀸𑀪𑀽𑀢𑀺𑀢𑁆𑀣𑀺𑀬𑁄 𑀦𑀸𑀫, 𑀮𑁄𑀓𑀲𑁆𑀫𑀺𑀁 𑀉𑀤𑀧𑀚𑁆𑀚𑀺𑀲𑀼𑀁.

𑁧𑁨𑁦. ‘‘𑀔𑀺𑀟𑁆𑀟𑀸 𑀧𑀡𑀺𑀳𑀺𑀢𑀸 𑀢𑁆𑀬𑀸𑀲𑀼, 𑀭𑀢𑀺 𑀢𑁆𑀬𑀸𑀲𑀼 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑀸;

𑀩𑀻𑀚𑀸𑀦𑀺 𑀢𑁆𑀬𑀸𑀲𑀼 𑀭𑀽𑀳𑀦𑁆𑀢𑀺, 𑀬𑀤𑀺𑀤𑀁 𑀲𑀢𑁆𑀢𑀸 𑀧𑀚𑀸𑀬𑀭𑁂;

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

𑁧𑁨𑁧. ‘‘𑀢𑁆𑀯𑀫𑁂𑀯 𑀦𑀜𑁆𑀜𑁄 𑀲𑀼𑀫𑀼𑀔, 𑀣𑀻𑀦𑀁 𑀅𑀢𑁆𑀣𑁂𑀲𑀼 𑀬𑀼𑀜𑁆𑀚𑀲𑀺;

𑀢𑀲𑁆𑀲 𑀢𑁆𑀬𑀚𑁆𑀚 𑀪𑀬𑁂 𑀚𑀸𑀢𑁂, 𑀪𑀻𑀢𑁂𑀦 𑀚𑀸𑀬𑀢𑁂 𑀫𑀢𑀺.

𑁧𑁨𑁨. ‘‘𑀲𑀩𑁆𑀩𑁄 𑀳𑀺 𑀲𑀁𑀲𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀪𑀬𑀁 𑀪𑀻𑀭𑀼 𑀢𑀺𑀢𑀺𑀓𑁆𑀔𑀢𑀺;

𑀧𑀡𑁆𑀟𑀺𑀢𑀸 𑀘 𑀫𑀳𑀦𑁆𑀢𑀸𑀦𑁄 [𑀫𑀳𑀢𑁆𑀢𑀸𑀦𑁄 (𑀲𑀻.)], 𑀅𑀢𑁆𑀣𑁂 𑀬𑀼𑀜𑁆𑀚𑀦𑁆𑀢𑀺 𑀤𑀼𑀬𑁆𑀬𑀼𑀚𑁂.

𑁧𑁨𑁩. ‘‘𑀏𑀢𑀤𑀢𑁆𑀣𑀸𑀬 𑀭𑀸𑀚𑀸𑀦𑁄, 𑀲𑀽𑀭𑀫𑀺𑀘𑁆𑀙𑀦𑁆𑀢𑀺 𑀫𑀦𑁆𑀢𑀺𑀦𑀁;

𑀧𑀝𑀺𑀩𑀸𑀳𑀢𑀺 𑀬𑀁 𑀲𑀽𑀭𑁄, 𑀆𑀧𑀤𑀁 𑀅𑀢𑁆𑀢𑀧𑀭𑀺𑀬𑀸𑀬𑀁.

𑁧𑁨𑁪. ‘‘𑀫𑀸 𑀦𑁄 𑀅𑀚𑁆𑀚 𑀯𑀺𑀓𑀦𑁆𑀢𑀺𑀁𑀲𑀼, 𑀭𑀜𑁆𑀜𑁄 𑀲𑀽𑀤𑀸 𑀫𑀳𑀸𑀦𑀲𑁂;

𑀢𑀣𑀸 𑀳𑀺 𑀯𑀡𑁆𑀡𑁄 𑀧𑀢𑁆𑀢𑀸𑀦𑀁, 𑀨𑀮𑀁 𑀯𑁂𑀴𑀼𑀁𑀯 𑀢𑀁 𑀯𑀥𑀺.

𑁧𑁨𑁫. ‘‘𑀫𑀼𑀢𑁆𑀢𑁄𑀧𑀺 𑀦 𑀇𑀘𑁆𑀙𑀺 [𑀦𑀺𑀘𑁆𑀙𑀲𑀺 (𑀓.)] 𑀉𑀟𑁆𑀟𑁂𑀢𑀼𑀁 [𑀑𑀟𑁆𑀟𑁂𑀢𑀼𑀁 (𑀲𑀻.)], 𑀲𑀬𑀁 𑀩𑀦𑁆𑀥𑀁 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀲𑁄𑀧𑀚𑁆𑀚 𑀲𑀁𑀲𑀬𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀅𑀢𑁆𑀣𑀁 𑀕𑀡𑁆𑀳𑀸𑀳𑀺 𑀫𑀸 𑀫𑀼𑀔𑀁’’.

𑁧𑁨𑁬. ‘‘𑀲𑁄 𑀢𑀁 [𑀢𑁆𑀯𑀁 (𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀬𑁄𑀕𑀁 𑀧𑀬𑀼𑀜𑁆𑀚𑀲𑁆𑀲𑀼, 𑀬𑀼𑀢𑁆𑀢𑀁 𑀥𑀫𑁆𑀫𑀽𑀧𑀲𑀁𑀳𑀺𑀢𑀁 [𑀥𑀫𑁆𑀫𑁄𑀧𑀲𑀜𑁆𑀳𑀺𑀢𑀁 (𑀓.)];

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

𑁧𑁨𑁭. ‘‘𑀫𑀸 𑀪𑀸𑀬𑀺 𑀧𑀢𑀢𑀁 𑀲𑁂𑀝𑁆𑀞, 𑀦 𑀳𑀺 𑀪𑀸𑀬𑀦𑁆𑀢𑀺 𑀢𑀸𑀤𑀺𑀲𑀸;

𑀅𑀳𑀁 𑀬𑁄𑀕𑀁 𑀧𑀬𑀼𑀜𑁆𑀚𑀺𑀲𑁆𑀲𑀁, 𑀬𑀼𑀢𑁆𑀢𑀁 𑀥𑀫𑁆𑀫𑀽𑀧𑀲𑀁𑀳𑀺𑀢𑀁 [𑀥𑀫𑁆𑀫𑁄𑀧𑀲𑀜𑁆𑀳𑀺𑀢𑀁 (𑀓.)];

𑀫𑀫 𑀧𑀭𑀺𑀬𑀸𑀧𑀤𑀸𑀦𑁂𑀦, 𑀔𑀺𑀧𑁆𑀧𑀁 𑀧𑀸𑀲𑀸 𑀧𑀫𑁄𑀓𑁆𑀔𑀲𑀺’’.

𑁧𑁨𑁮. ‘‘𑀲𑁄 [𑀲 (𑀲𑀻.)] 𑀮𑀼𑀤𑁆𑀤𑁄 𑀳𑀁𑀲𑀓𑀸𑀚𑁂𑀦 [𑀳𑀁𑀲𑀓𑀸𑀘𑁂𑀦 (𑀧𑀻.)], 𑀭𑀸𑀚𑀤𑁆𑀯𑀸𑀭𑀁 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀧𑀝𑀺𑀯𑁂𑀤𑁂𑀣 𑀫𑀁 𑀭𑀜𑁆𑀜𑁄, 𑀥𑀢𑀭𑀝𑁆𑀞𑀸𑀬𑀫𑀸𑀕𑀢𑁄’’.

𑁧𑁨𑁯. ‘‘𑀢𑁂 𑀤𑀺𑀲𑁆𑀯𑀸 𑀧𑀼𑀜𑁆𑀜𑀲𑀁𑀓𑀸𑀲𑁂, 𑀉𑀪𑁄 𑀮𑀓𑁆𑀔𑀡𑀲𑀫𑁆𑀫𑀢𑁂 [𑀮𑀓𑁆𑀔𑀜𑁆𑀜𑀸𑀲𑀫𑁆𑀫𑀢𑁂 (𑀲𑀻. 𑀧𑀻.)];

𑀔𑀮𑀼 𑀲𑀁𑀬𑀫𑀦𑁄 𑀭𑀸𑀚𑀸, 𑀅𑀫𑀘𑁆𑀘𑁂 𑀅𑀚𑁆𑀛𑀪𑀸𑀲𑀣.

𑁧𑁩𑁦. ‘‘𑀤𑁂𑀣 𑀮𑀼𑀤𑁆𑀤𑀲𑁆𑀲 𑀯𑀢𑁆𑀣𑀸𑀦𑀺, 𑀅𑀦𑁆𑀦𑀁 𑀧𑀸𑀦𑀜𑁆𑀘 𑀪𑁄𑀚𑀦𑀁;

𑀓𑀸𑀫𑀁 𑀓𑀭𑁄 𑀳𑀺𑀭𑀜𑁆𑀜𑀲𑁆𑀲, 𑀬𑀸𑀯𑀦𑁆𑀢𑁄 𑀏𑀲 𑀇𑀘𑁆𑀙𑀢𑀺’’.

𑁧𑁩𑁧. ‘‘𑀤𑀺𑀲𑁆𑀯𑀸 𑀮𑀼𑀤𑁆𑀤𑀁 𑀧𑀲𑀦𑁆𑀦𑀢𑁆𑀢𑀁, 𑀓𑀸𑀲𑀺𑀭𑀸𑀚𑀸 𑀢𑀤𑀩𑁆𑀭𑀯𑀺;

𑀬𑀤𑁆𑀬𑀸𑀬𑀁 [𑀬𑀤𑀸𑀬𑀁 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻.)] 𑀲𑀫𑁆𑀫 𑀔𑁂𑀫𑀓, 𑀧𑀼𑀡𑁆𑀡𑀸 𑀳𑀁𑀲𑁂𑀳𑀺 𑀢𑀺𑀝𑁆𑀞𑀢𑀺.

𑁧𑁩𑁨. ‘‘𑀓𑀣𑀁 𑀭𑀼𑀘𑀺𑀫𑀚𑁆𑀛𑀕𑀢𑀁, 𑀧𑀸𑀲𑀳𑀢𑁆𑀣𑁄 𑀉𑀧𑀸𑀕𑀫𑀺;

𑀑𑀓𑀺𑀡𑁆𑀡𑀁 𑀜𑀸𑀢𑀺𑀲𑀗𑁆𑀖𑁂𑀳𑀺, 𑀦𑀺𑀫𑁆𑀫𑀚𑁆𑀛𑀺𑀫𑀁 [𑀦𑀺𑀫𑀚𑁆𑀛𑀺𑀫𑀁 (𑀲𑀻. 𑀧𑀻. 𑀓.)] 𑀓𑀣𑀁 𑀕𑀳𑀺’’.

𑁧𑁩𑁩. ‘‘𑀅𑀚𑁆𑀚 𑀫𑁂 𑀲𑀢𑁆𑀢𑀫𑀸 𑀭𑀢𑁆𑀢𑀺, 𑀅𑀤𑀦𑀸𑀦𑀺 [𑀆𑀤𑀸𑀦𑀸𑀦𑀺 (𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)] 𑀉𑀧𑀸𑀲𑀢𑁄 [𑀉𑀧𑀸𑀕𑀢𑁄 (𑀓.)];

𑀧𑀤𑀫𑁂𑀢𑀲𑁆𑀲 𑀅𑀦𑁆𑀯𑁂𑀲𑀁, 𑀅𑀧𑁆𑀧𑀫𑀢𑁆𑀢𑁄 𑀖𑀝𑀲𑁆𑀲𑀺𑀢𑁄.

𑁧𑁩𑁪. ‘‘𑀅𑀣𑀲𑁆𑀲 𑀧𑀤𑀫𑀤𑁆𑀤𑀓𑁆𑀔𑀺𑀁, 𑀘𑀭𑀢𑁄 𑀅𑀤𑀦𑁂𑀲𑀦𑀁;

𑀢𑀢𑁆𑀣𑀸𑀳𑀁 𑀑𑀤𑀳𑀺𑀁 𑀧𑀸𑀲𑀁, 𑀏𑀯𑀁 𑀢𑀁 [𑀏𑀯𑁂𑀢𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀤𑀺𑀚𑀫𑀕𑁆𑀕𑀳𑀺𑀁’’.

𑁧𑁩𑁫. ‘‘𑀮𑀼𑀤𑁆𑀤 𑀤𑁆𑀯𑁂 𑀇𑀫𑁂 𑀲𑀓𑀼𑀡𑀸, 𑀅𑀣 𑀏𑀓𑁄𑀢𑀺 𑀪𑀸𑀲𑀲𑀺;

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

𑁧𑁩𑁬. ‘‘𑀬𑀲𑁆𑀲 𑀮𑁄𑀳𑀺𑀢𑀓𑀸 𑀢𑀸𑀮𑀸, 𑀢𑀧𑀦𑀻𑀬𑀦𑀺𑀪𑀸 𑀲𑀼𑀪𑀸;

𑀉𑀭𑀁 𑀲𑀁𑀳𑀘𑁆𑀘 𑀢𑀺𑀝𑁆𑀞𑀦𑁆𑀢𑀺, 𑀲𑁄 𑀫𑁂 𑀩𑀦𑁆𑀥𑀁 𑀉𑀧𑀸𑀕𑀫𑀺.

𑁧𑁩𑁭. ‘‘𑀅𑀣𑀸𑀬𑀁 𑀪𑀲𑁆𑀲𑀭𑁄 𑀧𑀓𑁆𑀔𑀻, 𑀅𑀩𑀤𑁆𑀥𑁄 𑀩𑀤𑁆𑀥𑀫𑀸𑀢𑀼𑀭𑀁;

𑀅𑀭𑀺𑀬𑀁 𑀩𑁆𑀭𑀼𑀯𑀸𑀦𑁄 𑀅𑀝𑁆𑀞𑀸𑀲𑀺, 𑀘𑀚𑀦𑁆𑀢𑁄 𑀫𑀸𑀦𑀼𑀲𑀺𑀁 𑀕𑀺𑀭𑀁’’.

𑁧𑁩𑁮. ‘‘𑀅𑀣 𑀓𑀺𑀁 [𑀅𑀣 𑀓𑀺𑀦𑁆𑀦𑀼 (𑀲𑀻. 𑀧𑀻.), 𑀓𑀣𑀁 𑀦𑀼 (𑀲𑁆𑀬𑀸.)] 𑀤𑀸𑀦𑀺 𑀲𑀼𑀫𑀼𑀔, 𑀳𑀦𑀼𑀁 𑀲𑀁𑀳𑀘𑁆𑀘 𑀢𑀺𑀝𑁆𑀞𑀲𑀺;

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

𑁧𑁩𑁯. ‘‘𑀦𑀸𑀳𑀁 𑀓𑀸𑀲𑀺𑀧𑀢𑀺 𑀪𑀻𑀢𑁄, 𑀑𑀕𑀬𑁆𑀳 𑀧𑀭𑀺𑀲𑀁 𑀢𑀯;

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

𑁧𑁪𑁦. ‘‘𑀦 𑀢𑁂 𑀅𑀪𑀺𑀲𑀭𑀁 𑀧𑀲𑁆𑀲𑁂, 𑀦 𑀭𑀣𑁂 𑀦𑀧𑀺 𑀧𑀢𑁆𑀢𑀺𑀓𑁂;

𑀦𑀸𑀲𑁆𑀲 𑀘𑀫𑁆𑀫𑀁 𑀯 𑀓𑀻𑀝𑀁 𑀯𑀸, 𑀯𑀫𑁆𑀫𑀺𑀢𑁂 𑀘 𑀥𑀦𑀼𑀕𑁆𑀕𑀳𑁂.

𑁧𑁪𑁧. ‘‘𑀦 𑀳𑀺𑀭𑀜𑁆𑀜𑀁 𑀲𑀼𑀯𑀡𑁆𑀡𑀁 𑀯𑀸, 𑀦𑀕𑀭𑀁 𑀯𑀸 𑀲𑀼𑀫𑀸𑀧𑀺𑀢𑀁;

𑀑𑀓𑀺𑀡𑁆𑀡𑀧𑀭𑀺𑀔𑀁 𑀤𑀼𑀕𑁆𑀕𑀁, 𑀤𑀴𑁆𑀳𑀫𑀝𑁆𑀝𑀸𑀮𑀓𑁄𑀝𑁆𑀞𑀓𑀁;

𑀬𑀢𑁆𑀣 𑀧𑀯𑀺𑀝𑁆𑀞𑁄 𑀲𑀼𑀫𑀼𑀔, 𑀪𑀸𑀬𑀺𑀢𑀩𑁆𑀩𑀁 𑀦 𑀪𑀸𑀬𑀲𑀺’’.

𑁧𑁪𑁨. ‘‘𑀦 𑀫𑁂 𑀅𑀪𑀺𑀲𑀭𑁂𑀦𑀢𑁆𑀣𑁄, 𑀦𑀕𑀭𑁂𑀦 𑀥𑀦𑁂𑀦 𑀯𑀸;

𑀅𑀧𑀣𑁂𑀦 𑀧𑀣𑀁 𑀬𑀸𑀫, 𑀅𑀦𑁆𑀢𑀮𑀺𑀓𑁆𑀔𑁂𑀘𑀭𑀸 𑀫𑀬𑀁.

𑁧𑁪𑁩. ‘‘𑀲𑀼𑀢𑀸 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑀸 𑀢𑁆𑀬𑀫𑁆𑀳𑀸, 𑀦𑀺𑀧𑀼𑀡𑀸 𑀅𑀢𑁆𑀣𑀘𑀺𑀦𑁆𑀢𑀓𑀸 [𑀘𑀢𑁆𑀣𑀘𑀺𑀦𑁆𑀢𑀓𑀸 (𑀓.)];

𑀪𑀸𑀲𑁂𑀫𑀢𑁆𑀣𑀯𑀢𑀺𑀁 𑀯𑀸𑀘𑀁, 𑀲𑀘𑁆𑀘𑁂 𑀘𑀲𑁆𑀲 𑀧𑀢𑀺𑀝𑁆𑀞𑀺𑀢𑁄.

𑁧𑁪𑁪. ‘‘𑀓𑀺𑀜𑁆𑀘 𑀢𑀼𑀬𑁆𑀳𑀁 𑀅𑀲𑀘𑁆𑀘𑀲𑁆𑀲, 𑀅𑀦𑀭𑀺𑀬𑀲𑁆𑀲 𑀓𑀭𑀺𑀲𑁆𑀲𑀢𑀺;

𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀺𑀲𑁆𑀲 𑀮𑀼𑀤𑁆𑀤𑀲𑁆𑀲, 𑀪𑀡𑀺𑀢𑀫𑁆𑀧𑀺 𑀲𑀼𑀪𑀸𑀲𑀺𑀢𑀁’’.

𑁧𑁪𑁫. ‘‘𑀢𑀁 𑀩𑁆𑀭𑀸𑀳𑁆𑀫𑀡𑀸𑀦𑀁 𑀯𑀘𑀦𑀸, 𑀇𑀫𑀁 𑀔𑁂𑀫𑀫𑀓𑀸𑀭𑀬𑀺 [𑀔𑁂𑀫𑀺𑀓𑀸𑀭𑀬𑀺 (𑀲𑀻. 𑀧𑀻.)];

𑀅𑀪𑀬𑀜𑁆𑀘 𑀢𑀬𑀸 𑀖𑀼𑀝𑁆𑀞𑀁, 𑀇𑀫𑀸𑀬𑁄 𑀤𑀲𑀥𑀸 𑀤𑀺𑀲𑀸.

𑁧𑁪𑁬. ‘‘𑀑𑀕𑀬𑁆𑀳 𑀢𑁂 𑀧𑁄𑀓𑁆𑀔𑀭𑀡𑀺𑀁, 𑀯𑀺𑀧𑁆𑀧𑀲𑀦𑁆𑀦𑁄𑀤𑀓𑀁 𑀲𑀼𑀘𑀺𑀁;

𑀧𑀳𑀽𑀢𑀁 𑀘𑀸𑀤𑀦𑀁 𑀢𑀢𑁆𑀣, 𑀅𑀳𑀺𑀁𑀲𑀸 𑀘𑁂𑀢𑁆𑀣 𑀧𑀓𑁆𑀔𑀺𑀦𑀁.

𑁧𑁪𑁭. ‘‘𑀇𑀤𑀁 𑀲𑀼𑀢𑁆𑀯𑀸𑀦 𑀦𑀺𑀕𑁆𑀖𑁄𑀲𑀁, 𑀆𑀕𑀢𑀫𑁆𑀳 𑀢𑀯𑀦𑁆𑀢𑀺𑀓𑁂;

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

𑁧𑁪𑁮. ‘‘𑀫𑀼𑀲𑀸𑀯𑀸𑀤𑀁 𑀧𑀼𑀭𑀓𑁆𑀔𑀢𑁆𑀯𑀸, 𑀇𑀘𑁆𑀙𑀸𑀮𑁄𑀪𑀜𑁆𑀘 𑀧𑀸𑀧𑀓𑀁;

𑀉𑀪𑁄 𑀲𑀦𑁆𑀥𑀺𑀫𑀢𑀺𑀓𑁆𑀓𑀫𑁆𑀫, 𑀅𑀲𑀸𑀢𑀁 𑀉𑀧𑀧𑀚𑁆𑀚𑀢𑀺’’.

𑁧𑁪𑁯. ‘‘𑀦𑀸𑀧𑀭𑀚𑁆𑀛𑀸𑀫 𑀲𑀼𑀫𑀼𑀔, 𑀦𑀧𑀺 𑀮𑁄𑀪𑀸𑀯 𑀫𑀕𑁆𑀕𑀳𑀺𑀁;

𑀲𑀼𑀢𑀸 𑀘 𑀧𑀡𑁆𑀟𑀺𑀢𑀸𑀢𑁆𑀬𑀢𑁆𑀣, 𑀦𑀺𑀧𑀼𑀡𑀸 𑀅𑀢𑁆𑀣𑀘𑀺𑀦𑁆𑀢𑀓𑀸.

𑁧𑁫𑁦. ‘‘𑀅𑀧𑁆𑀧𑁂𑀯𑀢𑁆𑀣𑀯𑀢𑀺𑀁 𑀯𑀸𑀘𑀁, 𑀩𑁆𑀬𑀸𑀳𑀭𑁂𑀬𑁆𑀬𑀼𑀁 [𑀩𑁆𑀬𑀸𑀓𑀭𑁂𑀬𑁆𑀬𑀼𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀇𑀥𑀸𑀕𑀢𑀸;

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

𑁧𑁫𑁧. ‘‘𑀦𑁂𑀯 𑀪𑀻𑀢𑀸 [𑀪𑀽𑀢𑀸 (𑀲𑁆𑀬𑀸. 𑀓.)] 𑀓𑀸𑀲𑀺𑀧𑀢𑀺, 𑀉𑀧𑀦𑀻𑀢𑀲𑁆𑀫𑀺 𑀚𑀻𑀯𑀺𑀢𑁂;

𑀪𑀸𑀲𑁂𑀫𑀢𑁆𑀣𑀯𑀢𑀺𑀁 𑀯𑀸𑀘𑀁, 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀸 𑀓𑀸𑀮𑀧𑀭𑀺𑀬𑀸𑀬𑀁.

𑁧𑁫𑁨. ‘‘𑀬𑁄 𑀫𑀺𑀕𑁂𑀦 𑀫𑀺𑀕𑀁 𑀳𑀦𑁆𑀢𑀺, 𑀧𑀓𑁆𑀔𑀺𑀁 𑀯𑀸 𑀧𑀦 𑀧𑀓𑁆𑀔𑀺𑀦𑀸;

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

𑁧𑁫𑁩. ‘‘𑀬𑁄 𑀘𑀸𑀭𑀺𑀬𑀭𑀼𑀤𑀁 [𑀘 𑀅𑀭𑀺𑀬𑀭𑀼𑀤𑀁 (𑀲𑀻. 𑀧𑀻.)] 𑀪𑀸𑀲𑁂, 𑀅𑀦𑀭𑀺𑀬𑀥𑀫𑁆𑀫𑀯𑀲𑁆𑀲𑀺𑀢𑁄 [𑀅𑀦𑀭𑀺𑀬𑀥𑀫𑁆𑀫𑀫𑀯𑀲𑁆𑀲𑀺𑀢𑁄 (𑀲𑀻.)];

𑀉𑀪𑁄 𑀲𑁄 𑀥𑀁𑀲𑀢𑁂 𑀮𑁄𑀓𑀸, 𑀇𑀥 𑀘𑁂𑀯 𑀧𑀭𑀢𑁆𑀣 𑀘.

𑁧𑁫𑁪. ‘‘𑀦 𑀫𑀚𑁆𑀚𑁂𑀣 𑀬𑀲𑀁 𑀧𑀢𑁆𑀢𑁄, 𑀦 𑀩𑁆𑀬𑀸𑀥𑁂 [𑀩𑁆𑀬𑀣𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀧𑀢𑁆𑀢𑀲𑀁𑀲𑀬𑀁;

𑀯𑀸𑀬𑀫𑁂𑀣𑁂𑀯 𑀓𑀺𑀘𑁆𑀘𑁂𑀲𑀼, 𑀲𑀁𑀯𑀭𑁂 𑀯𑀺𑀯𑀭𑀸𑀦𑀺 𑀘.

𑁧𑁫𑁫. ‘‘𑀬𑁂 𑀯𑀼𑀤𑁆𑀥𑀸 𑀅𑀩𑁆𑀪𑀢𑀺𑀓𑁆𑀓𑀦𑁆𑀢𑀸 [𑀦𑀸𑀩𑁆𑀪𑀘𑀺𑀓𑁆𑀔𑀦𑁆𑀢𑀸 (𑀓.)], 𑀲𑀫𑁆𑀧𑀢𑁆𑀢𑀸 𑀓𑀸𑀮𑀧𑀭𑀺𑀬𑀸𑀬𑀁;

𑀇𑀥 𑀥𑀫𑁆𑀫𑀁 𑀘𑀭𑀺𑀢𑁆𑀯𑀸𑀦, 𑀏𑀯𑀁𑀢𑁂 [𑀏𑀯𑁂𑀢𑁂 (𑀲𑀻. 𑀧𑀻.)] 𑀢𑀺𑀤𑀺𑀯𑀁 𑀕𑀢𑀸.

𑁧𑁫𑁬. ‘‘𑀇𑀤𑀁 𑀲𑀼𑀢𑁆𑀯𑀸 𑀓𑀸𑀲𑀺𑀧𑀢𑀺, 𑀥𑀫𑁆𑀫𑀫𑀢𑁆𑀢𑀦𑀺 𑀧𑀸𑀮𑀬;

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

𑁧𑁫𑁭. ‘‘𑀆𑀳𑀭𑀦𑁆𑀢𑀼𑀤𑀓𑀁 𑀧𑀚𑁆𑀚𑀁, 𑀆𑀲𑀦𑀜𑁆𑀘 𑀫𑀳𑀸𑀭𑀳𑀁;

𑀧𑀜𑁆𑀚𑀭𑀢𑁄 𑀧𑀫𑁄𑀓𑁆𑀔𑀸𑀫𑀺, 𑀥𑀢𑀭𑀝𑁆𑀞𑀁 𑀬𑀲𑀲𑁆𑀲𑀺𑀦𑀁.

𑁧𑁫𑁮. ‘‘𑀢𑀜𑁆𑀘 𑀲𑁂𑀦𑀸𑀧𑀢𑀺𑀁 𑀥𑀻𑀭𑀁, 𑀦𑀺𑀧𑀼𑀡𑀁 𑀅𑀢𑁆𑀣𑀘𑀺𑀦𑁆𑀢𑀓𑀁;

𑀬𑁄 𑀲𑀼𑀔𑁂 𑀲𑀼𑀔𑀺𑀢𑁄 𑀭𑀜𑁆𑀜𑁂 [𑀭𑀜𑁆𑀜𑁄 (𑀲𑀻. 𑀲𑁆𑀬𑀸. 𑀧𑀻. 𑀓.)], 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁂 𑀳𑁄𑀢𑀺 𑀤𑀼𑀓𑁆𑀔𑀺𑀢𑁄.

𑁧𑁫𑁯. ‘‘𑀏𑀤𑀺𑀲𑁄 𑀔𑁄 𑀅𑀭𑀳𑀢𑀺, 𑀧𑀺𑀡𑁆𑀟𑀫𑀲𑁆𑀦𑀸𑀢𑀼 𑀪𑀢𑁆𑀢𑀼𑀦𑁄;

𑀬𑀣𑀸𑀬𑀁 𑀲𑀼𑀫𑀼𑀔𑁄 𑀭𑀜𑁆𑀜𑁄, 𑀧𑀸𑀡𑀲𑀸𑀥𑀸𑀭𑀡𑁄 𑀲𑀔𑀸’’.