USE sofia;
DROP TABLE IF EXISTS sofia.syls_vpl;
CREATE TABLE syls_vpl (
  verseID VARCHAR(16) NOT NULL PRIMARY KEY,
  canon_order VARCHAR(12) NOT NULL,
  book VARCHAR(3) NOT NULL,
  chapter VARCHAR(3) NOT NULL,
  startVerse VARCHAR(3) NOT NULL,
  endVerse VARCHAR(3) NOT NULL,
  verseText TEXT CHARACTER SET UTF8 NOT NULL) ENGINE=MyISAM;
LOCK TABLES syls_vpl WRITE;
INSERT INTO syls_vpl VALUES ("GN1_1","002_1_1","GEN","1","1","1","ꠙꠄꠟꠣꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠍꠝꠣꠘ ꠀꠞ ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN1_2","002_1_2","GEN","1","2","2","ꠖꠥꠘꠤꠀꠁ ꠘꠤꠞꠣꠇꠣꠞ ꠀꠞ ꠈꠣꠟꠤ ꠀꠍꠤꠟ, ꠉꠁꠘ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠙꠥꠞꠣ ꠀꠘ꠆ꠖꠣꠁꠞ ꠀꠍꠤꠟ। ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥ ꠄꠞ ꠃꠙꠞꠦ ꠌꠟꠣꠌꠟ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN1_3","002_1_3","GEN","1","3","3","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ ꠚꠞ ꠅꠃꠇ, ꠀꠞ ꠚꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN1_4","002_1_4","GEN","1","4","4","ꠀꠟ꠆ꠟꠣꠄ ꠖꠦꠈꠟꠣ ꠚꠞ ꠜꠣꠟꠣ। ꠔꠣꠁꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠕꠣꠇꠤ ꠚꠞꠞꠦ ꠀꠟꠉꠣ ꠇꠞꠤꠀ ");
INSERT INTO syls_vpl VALUES ("GN1_5","002_1_5","GEN","1","5","5","ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠖꠤꠘ, ꠀꠞ ꠀꠘ꠆ꠖꠣꠁꠞꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠞꠣꠁꠔ। ꠢꠣꠁꠘ꠆ꠎꠣ ꠉꠦꠟ, ꠛꠤꠀꠘꠅ ꠉꠦꠟ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠙꠄꠟꠣ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN1_6","002_1_6","GEN","1","6","6","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠉꠥꠝ꠆ꠛꠥꠎꠞ ꠟꠣꠈꠣꠘ ꠚꠣꠇ ꠎꠣꠉꠣ ꠅꠃꠇ, ꠀꠞ ꠙꠣꠘꠤ ꠖꠥꠁ ꠜꠣꠉ ꠅꠁꠎꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GN1_7","002_1_7","GEN","1","7","7","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠚꠣꠇ ꠎꠣꠉꠣ ꠙꠄꠖꠣ ꠇꠞꠤꠀ, ꠔꠟꠞ ꠀꠞ ꠃꠙꠞꠞ ꠙꠣꠘꠤ ꠀꠟꠉꠣ ꠇꠞꠟꠣ। ꠀꠞ ꠅꠃꠟꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN1_8","002_1_8","GEN","1","8","8","ꠀꠟ꠆ꠟꠣꠄ ꠉꠥꠝ꠆ꠛꠥꠎꠞ ꠟꠣꠈꠣꠘ ꠎꠦ ꠎꠣꠉꠣ ꠛꠣꠘꠣꠁꠟꠣ, ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠀꠍꠝꠣꠘ। ꠢꠣꠁꠘ꠆ꠎꠣ ꠉꠦꠟ, ꠛꠤꠀꠘꠅ ꠉꠦꠟ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN1_9","002_1_9","GEN","1","9","9","ꠄꠞꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, ꠀꠍꠝꠣꠘꠞ ꠔꠟꠞ ꠙꠣꠘꠤ ꠄꠇ ꠎꠣꠉꠣꠔ ꠖꠟꠣ ꠅꠃꠇ, ꠀꠞ ꠢꠥꠇꠘꠣ ꠎꠣꠉꠣ ꠖꠦꠈꠣ ꠎꠣꠃꠇ। ꠀꠞ ꠅꠃꠟꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN1_10","002_1_10","GEN","1","10","10","ꠀꠟ꠆ꠟꠣꠄ ꠢꠥꠇꠘꠣ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠎꠝꠤꠘ ꠀꠞ ꠎꠝꠣꠁꠟ ꠙꠣꠘꠤꠞ ꠘꠣꠝ ꠖꠞꠤꠀ। ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ ꠁꠔꠣ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN1_11","002_1_11","GEN","1","11","11","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, ꠎꠝꠤꠘꠅ ꠊꠣꠡ ꠚꠟꠃꠇ; ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠤꠌꠀꠟꠣ ꠟꠔꠣ-ꠙꠣꠔꠣ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤꠞ ꠎꠘꠝ ꠅꠃꠇ। ꠀꠞ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠚꠟꠞ ꠉꠣꠍꠅ ꠅꠃꠇ, ꠄꠞꠣ ꠘꠤꠎꠞ ꠎꠣꠔꠝꠔ ꠚꠟ ꠗꠞꠛ ꠀꠞ ꠚꠟꠞ ꠝꠣꠎꠦ ꠎꠣꠞꠎꠤꠞ ꠛꠤꠌꠅ ꠕꠣꠇꠛ। ꠀꠞ ꠅꠃꠟꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN1_12","002_1_12","GEN","1","12","12","ꠎꠝꠤꠘꠅ ꠊꠣꠡ ꠚꠟꠤꠟ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠤꠌꠀꠟꠣ ꠟꠔꠣ-ꠙꠣꠔꠣ ꠉꠣꠍ-ꠛꠤꠞꠤꠇ ꠎꠘꠝꠤꠟ। ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠚꠟꠞ ꠉꠣꠍ ꠅꠁꠟ ꠎꠦꠔꠣꠄ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠔꠝꠔ ꠚꠟ ꠗꠞꠦ, ꠢꠤ ꠚꠟꠞ ꠝꠣꠎꠦ ꠎꠣꠞꠎꠤꠞ ꠛꠤꠌꠅ ꠀꠍꠦ। ꠀꠟ꠆ꠟꠣꠄ ꠖꠦꠈꠟꠣ ꠁꠔꠣ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN1_13","002_1_13","GEN","1","13","13","ꠢꠣꠁꠘ꠆ꠎꠣ ꠉꠦꠟ, ꠛꠤꠀꠘꠅ ꠉꠦꠟ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN1_14","002_1_14","GEN","1","14","14","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, ꠀꠍꠝꠣꠘꠞ ꠝꠣꠎꠦ ꠅꠃꠟꠣ ꠌꠦꠞꠣꠉ ꠅꠇꠟ ꠅꠃꠇ, ꠎꠣꠞꠣ ꠞꠣꠁꠔ ꠕꠣꠇꠤ ꠖꠤꠘꠞꠦ ꠀꠟꠉꠣ ꠇꠞꠦ। ꠁꠔꠣ ꠀꠟꠉꠣ ꠀꠟꠉꠣ ꠖꠤꠘ, ꠛꠍꠞ ꠀꠞ ꠁꠖ-ꠃꠔꠡꠛꠞ ꠘꠤꠡꠣꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN1_15","002_1_15","GEN","1","15","15","ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠞ ꠃꠙꠞꠦ ꠚꠞ ꠖꠤꠛ। ꠅꠃꠟꠣꠃ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN1_16","002_1_16","GEN","1","16","16","ꠀꠟ꠆ꠟꠣꠄ ꠖꠥꠁꠐꠣ ꠛꠠ ꠌꠦꠞꠣꠉ ꠛꠣꠘꠣꠁꠟꠣ, ꠄꠞꠝꠣꠎꠦ ꠛꠠꠐꠣꠞꠦ ꠖꠤꠘꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠢꠥꠞꠥꠐꠣꠞꠦ ꠞꠣꠁꠔꠞ ꠃꠙꠞꠦ। ꠁꠔꠣ ꠍꠣꠠꠣ ꠔꠣꠁꠘ ꠔꠦꠞꠣ ꠅꠇꠟꠅ ꠙꠄꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN1_17","002_1_17","GEN","1","17","17","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠀꠍꠝꠣꠘꠞ ꠝꠣꠎꠦ ꠛꠅꠀꠁꠟꠣ ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠚꠞ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("GN1_18","002_1_18","GEN","1","18","18","ꠄꠞꠣ ꠖꠤꠘ ꠀꠞ ꠞꠣꠁꠔꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠦ, ꠀꠘ꠆ꠖꠣꠁꠞ ꠕꠣꠇꠤ ꠚꠞꠞꠦ ꠀꠟꠉꠣ ꠇꠞꠦ। ꠀꠟ꠆ꠟꠣꠄ ꠖꠦꠈꠟꠣ ꠁꠔꠣ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN1_19","002_1_19","GEN","1","19","19","ꠢꠣꠁꠘ꠆ꠎꠣ ꠉꠦꠟ, ꠛꠤꠀꠘꠅ ꠉꠦꠟ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN1_20","002_1_20","GEN","1","20","20","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠎꠣꠘꠖꠣꠞ ꠅꠇꠟ ꠙꠣꠟꠦ ꠙꠣꠟꠦ ꠜꠞꠤ ꠎꠣꠃꠇ, ꠀꠞ ꠖꠥꠘꠤꠀꠁꠞ ꠃꠙꠞꠦ ꠀꠍꠝꠣꠘꠞ ꠝꠣꠎꠦ ꠙꠣꠈꠤꠘ ꠃꠠꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GN1_21","002_1_21","GEN","1","21","21","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠖꠞꠤꠀꠞ ꠛꠤꠞꠣꠐ ꠎꠣꠘꠖꠣꠞ ꠅꠇꠟ, ꠀꠞ ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠙꠣꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠊꠥꠞꠞꠣ ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠣꠘꠖꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠟꠣ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠣꠈꠤꠅ ꠙꠄꠖꠣ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ ꠁꠔꠣ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN1_22","002_1_22","GEN","1","22","22","ꠔꠣꠁꠘ ꠔꠣꠞꠣ ꠢꠇꠟꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠣ, ꠔꠥꠝꠞꠣ ꠚꠟꠀꠟꠣ ꠅꠁꠀ ꠛꠣꠠꠅ ꠀꠞ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤ ꠜꠞꠤ ꠎꠣꠅ, ꠖꠥꠘꠤꠀꠁꠞ ꠝꠣꠎꠦ ꠙꠣꠈꠤ ꠅꠇꠟꠅ ꠛꠣꠠꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GN1_23","002_1_23","GEN","1","23","23","ꠢꠣꠁꠘ꠆ꠎꠣ ꠉꠦꠟ, ꠛꠤꠀꠘꠅ ꠉꠦꠟ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN1_24","002_1_24","GEN","1","24","24","ꠄꠞꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, ꠝꠣꠐꠤ ꠕꠣꠇꠤ ꠅꠃꠟꠣ ꠎꠣꠘꠖꠣꠞ ꠅꠃꠇ ꠎꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔ ꠅꠇꠟꠞꠦ ꠛꠣꠠꠣꠁꠛ, ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ, ꠝꠣꠐꠤꠔ ꠌꠟꠞꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞ ꠅꠇꠟꠅ। ꠅꠃꠟꠣꠃ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN1_25","002_1_25","GEN","1","25","25","ꠀꠟ꠆ꠟꠣꠄ ꠖꠥꠘꠤꠀꠁꠞ ꠝꠣꠎꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞ, ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ ꠀꠞ ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠛꠣꠘꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ ꠁꠔꠣ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN1_26","002_1_26","GEN","1","26","26","ꠄꠞꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, ꠀꠅ ꠀꠝꠞꠣꠞ ꠍꠥꠞꠔꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠤꠟ ꠞꠣꠈꠤꠀ ꠝꠣꠘꠥꠡ ꠛꠣꠘꠣꠁ। ꠔꠣꠞꠣ ꠖꠞꠤꠀꠞ ꠝꠣꠍ, ꠀꠍꠝꠣꠘꠞ ꠙꠣꠈꠤ, ꠎꠣꠘꠥꠀꠞ, ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ, ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GN1_27","002_1_27","GEN","1","27","27","ꠔꠣꠁꠘ ꠔꠣꠘ ꠘꠤꠎꠞ ꠍꠥꠞꠔꠦ ꠝꠣꠘꠥꠡ ꠙꠄꠖꠣ ꠇꠞꠟꠣ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠘꠤꠎꠞ ꠝꠔ ꠇꠞꠤ ꠙꠄꠖꠣ ꠇꠞꠟꠣ, ꠙꠄꠖꠣ ꠇꠞꠟꠣ ꠛꠦꠐꠣ ꠀꠞ ꠛꠦꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("GN1_28","002_1_28","GEN","1","28","28","ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ꠔꠥꠝꠤꠔꠣꠁꠘ ꠚꠟꠀꠟꠣ ꠅꠁꠀ ꠛꠣꠠꠤꠀ ꠖꠥꠘꠤꠀꠁ ꠜꠞꠤ ꠎꠣꠅ। ꠖꠥꠘꠤꠀꠁꠞꠦ ꠡꠣꠡꠘ ꠇꠞꠅ, ꠀꠞ ꠖꠞꠤꠀꠞ ꠝꠣꠍ, ꠀꠍꠝꠣꠘꠞ ꠙꠣꠈꠤ, ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠌꠟꠞꠣ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("GN1_29","002_1_29","GEN","1","29","29","ꠄꠞꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, ꠢꠥꠘꠅ, ꠖꠥꠘꠤꠀꠞ ꠃꠙꠞꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠤꠌꠀꠟꠣ ꠉꠣꠍ-ꠛꠤꠞꠤꠇ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠚꠟꠞ ꠉꠣꠍ ꠎꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠝꠔ ꠚꠟ ꠗꠞꠦ ꠎꠣꠞ ꠚꠟꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠛꠤꠌ ꠀꠍꠦ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN1_30","002_1_30","GEN","1","30","30","ꠖꠥꠘꠤꠀꠞ ꠙꠞꠔꠦꠇ ꠎꠣꠘꠥꠀꠞ, ꠀꠍꠝꠣꠘꠞ ꠙꠣꠈꠤꠘ, ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠢꠇꠟ ꠟꠔꠣ-ꠙꠣꠔꠣ ꠀꠞ ꠊꠣꠡ ꠖꠤꠟꠣꠝ। ꠅꠃꠟꠣꠃ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN1_31","002_1_31","GEN","1","31","31","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠙꠄꠖꠣ ꠇꠞꠣ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠟꠣ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠈꠥꠛ ꠜꠣꠟꠣ ꠅꠁꠍꠦ। ꠢꠣꠁꠘ꠆ꠎꠣ ꠉꠦꠟ, ꠛꠤꠀꠘꠅ ꠉꠦꠟ। ꠁꠇꠐꠣ ꠅꠁꠟ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN2_1","002_2_1","GEN","2","1","1","ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠀꠞ ꠄꠞ ꠝꠣꠎꠞ ꠢꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠣ ꠡꠦꠡ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN2_2","002_2_2","GEN","2","2","2","ꠀꠟ꠆ꠟꠣꠄ ꠁ ꠢꠇꠟ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠀꠞꠣꠝ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠁꠖꠤꠘ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN2_3","002_2_3","GEN","2","3","3","ꠅꠃ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠤꠀ ꠙꠣꠇ ꠖꠤꠘ ꠇꠞꠟꠣ, ꠔꠣꠘ ꠢꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠣ ꠡꠦꠡ ꠇꠞꠤ ꠔꠣꠁꠘ ꠅꠃ ꠖꠤꠘ ꠎꠤꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN2_4","002_2_4","GEN","2","4","4","ꠅꠃ ꠅꠁꠟ ꠀꠍꠝꠣꠘ ꠀꠞ ꠎꠝꠤꠘ ꠙꠄꠖꠣꠞ ꠛꠄꠀꠘ। ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠀꠍꠝꠣꠘ ꠀꠞ ꠎꠝꠤꠘ ꠙꠄꠖꠣ ꠇꠞꠍꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN2_5","002_2_5","GEN","2","5","5","ꠁ ꠡꠝꠄ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠉꠣꠍ-ꠙꠣꠟꠣ ꠀꠍꠤꠟ ꠘꠣ ꠀꠞ ꠇꠥꠘꠥ ꠟꠔꠣ-ꠙꠣꠔꠣꠅ ꠚꠟꠤꠍꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠝꠦꠊ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠀꠞ ꠎꠝꠤꠘ ꠀꠛꠣꠖ ꠇꠞꠣꠞ ꠝꠣꠘꠥꠡꠅ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN2_6","002_2_6","GEN","2","6","6","ꠅꠃ ꠡꠝꠄ ꠝꠣꠐꠤꠞ ꠝꠥꠞ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠃꠑꠔ ꠀꠞ ꠎꠝꠤꠘ ꠜꠤꠎꠔ। ");
INSERT INTO syls_vpl VALUES ("GN2_7","002_2_7","GEN","2","7","7","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠚꠦꠇ ꠝꠣꠐꠤ ꠖꠤꠀ ꠝꠣꠘꠥꠡ ꠛꠣꠘꠣꠁꠀ ꠔꠣꠞ ꠘꠣꠇꠞ ꠝꠣꠎꠦ ꠚꠥ ꠖꠤꠀ ꠎꠣꠘ ꠢꠣꠞꠣꠁꠟꠣ। ꠀꠞ ꠅꠃ ꠝꠣꠘꠥꠡ ꠎꠣꠘꠖꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN2_8","002_2_8","GEN","2","8","8","ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠙꠥꠛꠦꠖꠤ ꠀꠖꠣꠘ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠄꠇ ꠛꠣꠉꠣꠘ ꠇꠞꠍꠤꠟꠣ, ꠢꠘꠅ ꠔꠣꠘꠞ ꠛꠣꠘꠣꠁꠟ ꠅꠃ ꠝꠣꠘꠥꠡꠞꠦ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN2_9","002_2_9","GEN","2","9","9","ꠢꠤꠈꠣꠘꠞ ꠝꠣꠐꠤꠔ ꠔꠣꠁꠘ ꠅꠃ ꠟꠣꠈꠣꠘ ꠉꠣꠍ ꠅꠇꠟ ꠚꠟꠣꠁꠍꠟꠣ, ꠎꠦꠔꠣ ꠖꠦꠈꠔꠦ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠀꠞ ꠚꠟꠅ ꠈꠣꠁꠔꠦ ꠈꠥꠛ ꠝꠎꠣ। ꠀꠞ ꠛꠣꠉꠣꠘꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠔꠣꠁꠘ “ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠉꠣꠍ” ꠀꠞ “ꠘꠦꠇꠤ-ꠛꠖꠤꠞ ꠀꠈꠟ ꠖꠦꠅꠞꠣ ꠉꠣꠍ” ꠘꠣꠝꠞ ꠖꠥꠁꠐꠣ ꠉꠣꠍꠅ ꠞꠣꠈꠍꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN2_10","002_2_10","GEN","2","10","10","ꠢꠃ ꠛꠣꠉꠣꠘꠅ ꠙꠣꠘꠤ ꠎꠥꠉꠣꠁꠀ ꠖꠤꠔ ꠄꠇ ꠉꠣꠋ ꠀꠍꠤꠟ, ꠎꠦꠇꠐꠣ ꠀꠖꠣꠘꠞ ꠝꠣꠎꠦꠖꠤ ꠛꠣꠞ ꠅꠁꠀ ꠌꠣꠁꠞ ꠜꠣꠉ ꠅꠁꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN2_11","002_2_11","GEN","2","11","11","ꠙꠄꠟꠣ ꠉꠣꠋꠉꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠙꠤꠡꠥꠘ, ꠁꠇꠐꠣ ꠀꠡ꠆ꠔꠣ ꠢꠛꠤꠟꠣ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦ ꠖꠤꠀ ꠉꠦꠍꠦ। ꠁꠘꠅ ꠡꠥꠘꠣ ꠙꠣꠅꠀ ꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("GN2_12","002_2_12","GEN","2","12","12","ꠀꠞ ꠅꠃ ꠖꠦꠡꠞ ꠡꠥꠘꠣ ꠈꠥꠛ ꠈꠣꠐꠤ, ꠁꠔꠣ ꠍꠣꠠꠣꠅ ꠢꠤꠘꠅ ꠝꠦꠡꠇꠦ-ꠀꠝ꠆ꠛꠞ ꠀꠞ ꠀꠇꠤꠇ ꠝꠘꠤ ꠙꠣꠅꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN2_13","002_2_13","GEN","2","13","13","ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠉꠣꠋꠉꠞ ꠘꠣꠝ ꠎꠤꠢꠥꠘ, ꠁꠇꠐꠣ ꠀꠡ꠆ꠔꠣ ꠇꠥꠡ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦ ꠖꠤꠀ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN2_14","002_2_14","GEN","2","14","14","ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠉꠣꠋꠉꠞ ꠘꠣꠝ ꠖꠎꠟꠣ, ꠁꠇꠐꠣ ꠀꠡꠤꠞꠤꠀ ꠖꠦꠡꠞ ꠙꠥꠛꠦ ꠖꠤꠀ ꠉꠦꠍꠦ। ꠀꠞ ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠉꠣꠋꠉꠞ ꠘꠣꠝ ꠅꠁꠟ ꠚꠥꠞꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("GN2_15","002_2_15","GEN","2","15","15","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠝꠣꠘꠥꠡꠞꠦ ꠀꠖꠣꠘ ꠛꠣꠉꠣꠘꠅ ꠞꠣꠈꠟꠣ, ꠢꠤꠘꠅ ꠈꠦꠔ-ꠈꠣꠝꠣꠞ ꠀꠞ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN2_16","002_2_16","GEN","2","16","16","ꠔꠣꠁꠘ ꠀꠖꠝꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠈꠥꠡꠤꠝꠔ ꠁ ꠛꠣꠉꠤꠌꠣꠞ ꠎꠦꠇꠥꠘꠥ ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("GN2_17","002_2_17","GEN","2","17","17","ꠈꠣꠟꠤ ꠘꠦꠇꠤ-ꠛꠖꠤꠞ ꠀꠈꠟꠞ ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠁꠅ ꠘꠣ, ꠎꠦꠖꠤꠘ ꠔꠥꠝꠤ ꠅꠃ ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠁꠛꠣꠄ ꠁꠖꠤꠘ ꠔꠥꠝꠤ ꠝꠞꠛꠣꠄꠃ ꠝꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN2_18","002_2_18","GEN","2","18","18","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠄꠇꠟꠣ ꠕꠣꠇꠣ ꠜꠣꠟꠣ ꠘꠣꠄ। ꠀꠝꠤ ꠔꠣꠞ ꠟꠣꠈ ꠄꠇꠎꠘ ꠎꠥꠠꠤ ꠛꠣꠘꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN2_19","002_2_19","GEN","2","19","19","ꠀꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠖꠥꠘꠤꠀꠁꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠀꠍꠝꠣꠘꠞ ꠢꠇꠟ ꠙꠣꠈꠤ ꠝꠣꠐꠤꠖꠤ ꠛꠣꠘꠣꠁꠀ ꠅꠃ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠟꠣ, ꠖꠦꠈꠟꠣ ꠄꠁꠘ ꠁꠔꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠁꠀ ꠒꠣꠇꠂꠘ, ꠀꠞ ꠔꠣꠁꠘ ꠎꠣꠞꠦ ꠎꠦ ꠘꠣꠝꠦ ꠒꠣꠇꠟꠣ, ꠔꠣꠞ ꠅꠃ ꠘꠣꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN2_20","002_2_20","GEN","2","20","20","ꠀꠖꠝꠦ ꠢꠇꠟ ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ, ꠀꠍꠝꠣꠘꠞ ꠙꠣꠈꠤ ꠀꠞ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ, ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠟꠣꠈ ꠇꠥꠘꠥ ꠎꠥꠠꠤ ꠝꠤꠟꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN2_21","002_2_21","GEN","2","21","21","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠖꠝꠞ ꠝꠣꠎꠦ ꠛꠦꠢꠥꠡꠤ ꠊꠥꠝ ꠀꠘꠟꠣ। ꠅꠃ ꠊꠥꠝꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠙꠣꠁꠘ꠆ꠎꠞꠞ ꠄꠇꠐꠣ ꠀꠒ꠆ꠒꠤ ꠈꠥꠟꠤꠀ ꠘꠤꠀ ꠎꠣꠉꠣꠐꠣ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN2_22","002_2_22","GEN","2","22","22","ꠀꠞ ꠅꠃ ꠀꠒ꠆ꠒꠤ ꠖꠤꠀ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠄꠇ ꠛꠦꠐꠤꠝꠣꠘꠥꠡ ꠛꠣꠘꠣꠁꠀ ꠀꠖꠝꠞ ꠉꠦꠍꠦ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN2_23","002_2_23","GEN","2","23","23","ꠔꠣꠘꠦ ꠖꠦꠈꠤꠀ ꠀꠖꠝꠦ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠅꠁꠍꠦ, ꠔꠣꠁ ꠀꠝꠣꠞ ꠀꠒ꠆ꠒꠤꠞ ꠀꠒ꠆ꠒꠤ, ꠉꠥꠡ꠆ꠔꠞ ꠉꠥꠡ꠆ꠔ। ꠔꠣꠁꠞ ꠘꠣꠝ ꠅꠁꠛ ꠘꠣꠞꠤ, ꠔꠣꠁꠞꠦ ꠘꠞ ꠕꠣꠇꠤ ꠘꠦꠅꠀ।” ");
INSERT INTO syls_vpl VALUES ("GN2_24","002_2_24","GEN","2","24","24","ꠄꠞꠟꠣꠉꠤ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠍꠣꠠꠤꠀ ꠛꠃꠞ ꠟꠉꠦ ꠞꠁꠛꠣ, ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘ ꠄꠇ ꠡꠞꠤꠟ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN2_25","002_2_25","GEN","2","25","25","ꠀꠖꠝ ꠀꠞ ꠔꠣꠘ ꠛꠤꠛꠤꠞ ꠡꠞꠤꠟ ꠃꠖꠣꠝ ꠕꠣꠇꠔ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠡꠞꠝ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN3_1","002_3_1","GEN","3","1","1","ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠣ ꠎꠝꠤꠘꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠝꠣꠎꠦ ꠢꠣꠚ ꠅꠁꠟ ꠢꠇꠟ ꠕꠣꠇꠤ ꠚꠘ꠆ꠖꠤꠛꠣꠎ। ꠅꠃ ꠢꠣꠚꠦ ꠄꠇꠖꠤꠘ ꠢꠤ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟ, “ꠀꠟ꠆ꠟꠣꠄ ꠢꠣꠍꠣꠃ ꠔꠥꠝꠣꠔꠣꠘꠞꠦ ꠇꠁꠍꠂꠘ ꠘꠤ, ꠛꠣꠉꠣꠘꠞ ꠢꠇꠟ ꠉꠣꠍꠞ ꠚꠟ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("GN3_2","002_3_2","GEN","3","2","2","ꠛꠦꠐꠤꠄ ꠇꠁꠟꠣ, “ꠛꠣꠉꠣꠘꠞ ꠎꠦꠇꠥꠘꠥ ꠉꠣꠍꠞ ꠚꠟ ꠀꠝꠞꠣ ꠈꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("GN3_3","002_3_3","GEN","3","3","3","ꠈꠣꠟꠤ ꠛꠣꠉꠣꠘꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠎꠦ ꠉꠣꠍꠐꠣ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠄꠞ ꠚꠟ ꠈꠣꠁꠅ ꠘꠣ, ꠍꠁꠅ-ꠅ ꠘꠣ, ꠍꠁꠟꠦꠃ ꠝꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN3_4","002_3_4","GEN","3","4","4","ꠅꠃ ꠢꠣꠚꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟ, “ꠘꠣ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠝꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN3_5","002_3_5","GEN","3","5","5","ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠎꠣꠘꠂꠘ, ꠎꠦꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠁ ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠁꠟꠤꠛꠣꠄ ꠁꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠌꠃꠈ ꠈꠥꠟꠤꠎꠤꠛ, ꠀꠞ ꠘꠦꠇꠤ-ꠛꠖꠤꠞ ꠀꠈꠟ ꠙꠣꠁꠀ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠎꠤꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN3_6","002_3_6","GEN","3","6","6","ꠛꠦꠐꠤꠄ ꠎꠦꠛꠟꠣ ꠛꠥꠎꠟꠣ, ꠅꠃ ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠁꠔꠦ ꠝꠎꠣ ꠅꠁꠛ, ꠖꠦꠈꠔꠦꠅ ꠡꠥꠘ꠆ꠖꠞ, ꠀꠞ ꠀꠈꠟꠖꠣꠞꠅ ꠅꠁꠎꠤꠝꠥ, ꠅꠃ ꠔꠣꠁꠘ ꠚꠟ ꠙꠣꠠꠤꠀ ꠈꠣꠁꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠎꠣꠝꠣꠁꠞꠦꠅ ꠖꠤꠟꠣ ꠀꠞ ꠎꠣꠝꠣꠁꠄꠅ ꠈꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN3_7","002_3_7","GEN","3","7","7","ꠟꠉꠦ ꠟꠉꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠎꠘꠞ ꠌꠃꠈ ꠈꠥꠟꠤꠉꠦꠟ, ꠀꠞ ꠛꠥꠎꠟꠣ ꠔꠣꠁꠘ-ꠔꠣꠁꠘ ꠟꠦꠝꠐꠣ। ꠅꠃ ꠔꠣꠞꠣ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠞ ꠇꠄꠐꠣ ꠙꠣꠔꠣ ꠍꠤꠠꠤꠀ ꠡꠤꠟꠣꠁ ꠇꠞꠤ ꠟꠦꠝꠐꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN3_8","002_3_8","GEN","3","8","8","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣ, ꠔꠣꠁꠘ ꠛꠣꠉꠣꠘꠞ ꠝꠣꠎꠦ ꠙꠣꠇꠣꠘꠤꠔ ꠀꠁꠞꠣ। ꠔꠦꠃ ꠀꠖꠝ ꠀꠞ ꠔꠣꠘ ꠛꠃ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠘꠣ ꠙꠠꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠉꠣꠘꠞ ꠉꠣꠍꠞ ꠀꠅꠠꠦ ꠟꠥꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN3_9","002_3_9","GEN","3","9","9","ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠖꠝꠞꠦ ꠒꠣꠇ ꠖꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠥꠀꠁ?” ");
INSERT INTO syls_vpl VALUES ("GN3_10","002_3_10","GEN","3","10","10","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠛꠣꠉꠣꠘꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠍꠤ। ꠀꠝꠤ ꠔ ꠟꠦꠝꠐꠣ, ꠄꠞꠟꠣꠉꠤ ꠒꠞꠣꠁꠀ ꠟꠥꠇꠣꠁ ꠞꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN3_11","002_3_11","GEN","3","11","11","ꠔꠦꠃ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠦ ꠟꠦꠝꠐꠣ ꠇꠦ ꠇꠁꠟ? ꠎꠦ ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠁꠔꠦ ꠔꠥꠝꠣꠞꠦ ꠘꠣ ꠇꠞꠍꠤꠟꠣꠝ, ꠈꠣꠁꠟꠤꠍ ꠘꠣ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("GN3_12","002_3_12","GEN","3","12","12","ꠀꠖꠝꠦ ꠇꠁꠟꠣ, “ꠎꠦ ꠛꠦꠐꠤꠝꠣꠘꠥꠡ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠖꠤꠍ, ꠔꠣꠁ ꠅꠃ ꠉꠣꠍꠞ ꠚꠟ ꠀꠝꠣꠞꠦ ꠈꠣꠅꠀꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN3_13","002_3_13","GEN","3","13","13","ꠅꠃ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠛꠦꠐꠤꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠟꠣꠄ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠍꠣꠟ꠆ꠟꠣ ꠖꠤꠀ ꠈꠣꠅꠀꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN3_14","002_3_14","GEN","3","14","14","ꠔꠦꠃ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠢꠣꠚꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠁ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠢꠇꠟ ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ ꠀꠞ ꠢꠇꠟ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠤꠃ ꠟꠣꠘ꠆ꠘꠔꠤ ꠅꠁꠟꠣꠄ। ꠔꠥꠝꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠜꠞ ꠙꠦꠐꠅ ꠜꠞꠖꠤ ꠌꠟꠛꠣꠄ ꠀꠞ ꠗꠥꠟꠣ-ꠛꠣꠟꠥ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN3_15","002_3_15","GEN","3","15","15","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠀꠞ ꠛꠦꠐꠤꠞ ꠝꠣꠎꠦ, ꠔꠥꠝꠣꠞ ꠛꠋꠡ ꠀꠞ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞ ꠛꠋꠡꠞ ꠝꠣꠎꠦ ꠖꠥꠡꠝꠘꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ। ꠢꠤ ꠛꠋꠡꠦ ꠔꠥꠝꠣꠞ ꠇꠟ꠆ꠟꠣ ꠉꠥꠠꠣ ꠇꠞꠛ, ꠀꠞ ꠔꠥꠝꠤ ꠔꠣꠞ ꠙꠣꠅꠞ ꠝꠥꠞꠣꠔ ꠇꠣꠝꠠꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN3_16","002_3_16","GEN","3","16","16","ꠀꠞ ꠔꠣꠁꠘ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠛꠣꠞ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠝꠍꠤꠛꠔ ꠈꠥꠛ ꠛꠣꠠꠣꠁ ꠖꠤꠝꠥ, ꠔꠥꠝꠤ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠇꠞꠤꠀ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠛꠣꠄ। ꠎꠣꠝꠣꠁꠞ ꠛꠣꠄ ꠔꠥꠝꠣꠞ ꠈꠥꠛ ꠈꠣꠁꠡ ꠕꠣꠇꠛ, ꠀꠞ ꠢꠦ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN3_17","002_3_17","GEN","3","17","17","ꠔꠣꠁꠘ ꠀꠖꠝꠞꠦ ꠇꠁꠟꠣ, “ꠎꠦ ꠉꠣꠍꠞ ꠚꠟ ꠀꠝꠤ ꠢꠣꠞꠣꠝ ꠇꠞꠤꠀ ꠖꠤꠍꠟꠣꠝ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠃꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠁꠔꠣ ꠈꠣꠁꠍ, ꠅꠃ ꠇꠣꠞꠘꠦ ꠎꠝꠤꠘꠞꠦ ꠟꠣꠘ꠆ꠘꠔꠤ ꠇꠞꠣ ꠅꠁꠟ। ꠎꠤꠘ꠆ꠖꠦꠉꠤꠜꠞ ꠎꠛꠞ ꠔꠇꠟꠤꠚ ꠇꠞꠤꠀ ꠔꠥꠝꠤ ꠎꠝꠤꠘꠞ ꠚꠡꠟ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN3_18","002_3_18","GEN","3","18","18","ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠇꠣꠐꠣ-ꠉꠍꠣ ꠀꠞ ꠛꠤꠡꠀꠟꠣ ꠎꠋꠉꠟ ꠎꠘꠝꠣꠁꠛ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠈꠣꠘꠤ ꠅꠁꠛ ꠅꠃ ꠝꠣꠐꠤꠞ ꠚꠄ-ꠚꠡꠟ। ");
INSERT INTO syls_vpl VALUES ("GN3_19","002_3_19","GEN","3","19","19","ꠎꠦ ꠝꠣꠐꠤ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞꠦ ꠙꠄꠖꠣ ꠇꠞꠍꠟꠣꠝ, ꠢꠃ ꠝꠣꠐꠤꠔ ꠚꠤꠞꠤꠀ ꠘꠣ ꠎꠣꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠣꠞ ꠝꠣꠕꠣꠞ ꠊꠣꠝ ꠙꠣꠅꠔ ꠚꠣꠟꠣꠁꠀ ꠈꠣꠘꠤ ꠈꠣꠁꠛꠣꠄ। ꠔꠥꠝꠣꠞ ꠝꠣꠐꠤꠞ ꠡꠞꠤꠟ, ꠝꠣꠐꠤꠔꠃ ꠝꠤꠡꠤꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN3_20","002_3_20","GEN","3","20","20","ꠀꠖꠝꠦ ꠔꠣꠘ ꠛꠤꠛꠤꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠢꠣꠅꠀ ꠝꠣꠘꠤ, ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠖꠦꠅꠞꠣ, ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠢꠇꠟ ꠎꠤꠘ꠆ꠖꠣ ꠝꠣꠘꠡꠞ ꠝꠣ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN3_21","002_3_21","GEN","3","21","21","ꠀꠖꠝ ꠀꠞ ꠔꠣꠘ ꠛꠤꠛꠤꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠘꠥꠀꠞꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠟꠦꠛꠣꠍ ꠛꠣꠘꠣꠁꠀ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN3_22","002_3_22","GEN","3","22","22","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠖꠦꠈꠅ, ꠘꠦꠇꠤ-ꠛꠖꠤꠞ ꠀꠈꠟ ꠙꠣꠁꠀ ꠝꠣꠘꠥꠡ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠉꠦꠍꠦ, ꠅꠈꠘ ꠢꠦ ꠎꠣꠔꠦ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠁꠀ ꠢꠣꠝꠦꠡꠣ ꠎꠤꠘ꠆ꠖꠣ ꠘꠣ ꠞꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN3_23","002_3_23","GEN","3","23","23","ꠅꠃ ꠇꠕꠣ ꠇꠁꠀ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠝꠣꠐꠤ ꠖꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠙꠄꠖꠣ ꠇꠞꠍꠟꠣ, ꠢꠃ ꠝꠣꠐꠤꠔ ꠈꠦꠔ-ꠈꠣꠝꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠀꠖꠣꠘ ꠛꠣꠉꠣꠘ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN3_24","002_3_24","GEN","3","24","24","ꠈꠦꠖꠣꠁ ꠖꠤꠀ ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠉꠣꠍꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀꠞ ꠙꠕ ꠙꠣꠞꠣ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠖꠣꠘ ꠛꠣꠉꠣꠘꠞ ꠙꠥꠛꠦꠖꠤ ꠇꠣꠞꠥꠛꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠞꠣꠈꠟꠣ ꠀꠞ ꠀꠉꠥꠁꠘꠞ ꠔꠟꠥꠀꠞꠅ ꠊꠥꠞꠣꠘꠤꠔ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN4_1","002_4_1","GEN","4","1","1","ꠀꠖꠝꠦ ꠔꠣꠘ ꠛꠤꠛꠤ ꠢꠣꠅꠀꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ, ꠀꠞ ꠇꠣꠛꠤꠟ ꠘꠣꠝꠦ ꠔꠣꠘ ꠄꠇ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟ। ꠔꠦꠃ ꠛꠤꠛꠤ ꠢꠣꠅꠀꠄ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠘꠦ ꠀꠝꠤ ꠄꠇ ꠝꠣꠘꠥꠡ ꠇꠛꠥꠟ ꠇꠞꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN4_2","002_4_2","GEN","4","2","2","ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠊꠞꠅ ꠇꠣꠛꠤꠟꠞ ꠜꠣꠁ ꠢꠣꠛꠤꠟꠞ ꠎꠘꠝ ꠅꠁꠟ। ꠢꠣꠛꠤꠟꠦ ꠍꠣꠉꠟ-ꠝꠦꠠꠣ ꠞꠣꠈꠔ, ꠀꠞ ꠇꠣꠛꠤꠟꠦ ꠈꠦꠔ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("GN4_3","002_4_3","GEN","4","3","3","ꠛꠣꠖꠦ ꠄꠇꠖꠤꠘ ꠇꠣꠛꠤꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠔꠣꠞ ꠈꠦꠔꠞ ꠚꠄ-ꠚꠡꠟ ꠀꠘꠤꠀ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠟ ");
INSERT INTO syls_vpl VALUES ("GN4_4","002_4_4","GEN","4","4","4","ꠀꠞ ꠢꠣꠛꠤꠟꠦꠅ ꠔꠣꠞ ꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠙꠄꠟꠣ ꠎꠘꠝꠤꠍꠦ ꠅꠃꠟꠣ ꠇꠄꠐꠣ ꠍꠣꠉꠟ-ꠝꠦꠠꠣ ꠎꠛ ꠇꠞꠤꠀ ꠌꠞ꠆ꠛꠤꠀꠟꠣ ꠅꠋꠡ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠟ। ꠝꠣꠛꠥꠖꠦ ꠢꠣꠛꠤꠟ ꠀꠞ ꠔꠣꠞ ꠟꠤꠟ꠆ꠟꠣ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN4_5","002_4_5","GEN","4","5","5","ꠇꠣꠛꠤꠟ ꠀꠞ ꠔꠣꠞ ꠟꠤꠟ꠆ꠟꠣ ꠇꠛꠥꠟ ꠇꠞꠟꠣ ꠘꠣ, ꠉꠔꠤꠇꠦ ꠢꠦ ꠈꠥꠛ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠝꠥꠈ ꠇꠣꠟꠣ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("GN4_6","002_4_6","GEN","4","6","6","ꠝꠣꠛꠥꠖꠦ ꠇꠣꠛꠤꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠉꠥꠍꠣ ꠇꠞꠞꠣꠄ ꠇꠦꠘꠦ, ꠀꠞ ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠝꠥꠈ ꠇꠣꠟꠣ ꠇꠞꠍ? ");
INSERT INTO syls_vpl VALUES ("GN4_7","002_4_7","GEN","4","7","7","ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠟꠦ ꠔꠥꠝꠣꠞ ꠝꠥꠈ ꠚꠞ ꠅꠁꠟ ꠅꠘꠦ? ꠀꠞ ꠘꠣ ꠇꠞꠟꠦ ꠔ ꠉꠥꠘꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠗꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠖꠥꠀꠞꠅ ꠃꠛꠣꠁ ꠞꠁꠍꠦ। ꠁꠉꠥꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠤ ꠎꠤꠔꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN4_8","002_4_8","GEN","4","8","8","ꠛꠣꠖꠦ ꠇꠣꠛꠤꠟꠦ ꠔꠣꠞ ꠜꠣꠁ ꠢꠣꠛꠤꠟꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟ, “ꠀꠅ ꠀꠝꠞꠣ ꠛꠘ꠆ꠖꠅ ꠎꠣꠁ।” ꠀꠞ ꠛꠘ꠆ꠖꠅ ꠉꠤꠀ ꠔꠣꠞ ꠜꠣꠁ ꠢꠣꠛꠤꠟꠞ ꠃꠙꠞꠦ ꠀꠈꠔꠣ ꠢꠣꠝꠟꠣ ꠇꠞꠤꠀ ꠈꠥꠘ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("GN4_9","002_4_9","GEN","4","9","9","ꠢꠦꠡꠦ ꠝꠣꠛꠥꠖꠦ ꠇꠣꠛꠤꠟꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠇꠥꠀꠁ?” ꠇꠣꠛꠤꠟꠦ ꠇꠁꠟ, “ꠀꠝꠤ ꠎꠣꠘꠤ ꠘꠣ, ꠀꠝꠣꠞ ꠜꠣꠁꠞꠦ ꠀꠝꠤ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠤ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN4_10","002_4_10","GEN","4","10","10","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠟꠣꠄ? ꠖꠦꠈꠅ, ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞ ꠟꠃꠄ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠚꠞꠤꠀꠖ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("GN4_11","002_4_11","GEN","4","11","11","ꠎꠝꠤꠘꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠣꠞ ꠇꠣꠞꠘꠦ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞ ꠟꠃ ꠈꠣꠁꠟ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠤ ꠟꠣꠘ꠆ꠘꠔꠤ ꠅꠁꠀ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠟ ꠅꠁꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN4_12","002_4_12","GEN","4","12","12","ꠔꠥꠝꠤ ꠎꠦꠛꠟꠣ ꠎꠝꠤꠘꠅ ꠈꠦꠔ ꠇꠞꠛꠣꠄ, ꠎꠝꠤꠘꠦ ꠀꠞ ꠔꠥꠝꠣꠞꠦ ꠚꠡꠟ ꠖꠤꠔ ꠘꠣꠄ। ꠔꠥꠝꠤ ꠛꠂꠔꠟ ꠅꠁꠀ ꠖꠥꠘꠤꠀꠁ ꠎꠥꠠꠤ ꠊꠥꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN4_13","002_4_13","GEN","4","13","13","ꠔꠦꠃ ꠇꠣꠛꠤꠟꠦ ꠝꠣꠛꠥꠖꠞꠦ ꠇꠁꠟ, “ꠁ ꠡꠣꠡ꠆ꠔꠤ ꠀꠝꠣꠞ ꠀꠋꠉꠣꠎ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN4_14","002_4_14","GEN","4","14","14","ꠀꠁꠎ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠞꠣꠄ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠘꠦ ꠢꠞꠤ ꠎꠣꠁꠝꠥꠉꠤ। ꠀꠞ ꠛꠂꠔꠟ ꠅꠁꠀ ꠎꠦꠛꠟꠣ ꠀꠝꠤ ꠖꠥꠘꠤꠀꠁꠔ ꠊꠥꠞꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠎꠣꠞ ꠍꠣꠝꠘꠦꠃ ꠀꠝꠤ ꠙꠠꠝꠥ, ꠢꠦ-ꠃ ꠀꠝꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN4_15","002_4_15","GEN","4","15","15","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠔꠥꠝꠣꠞꠦ ꠎꠦ ꠈꠥꠘ ꠇꠞꠛ, ꠔꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠡꠣꠔꠉꠥꠘ ꠛꠖꠟꠣ ꠟꠁꠝꠥ।” ꠅꠃ ꠇꠕꠣ ꠇꠁꠀ ꠝꠣꠛꠥꠖꠦ ꠇꠣꠛꠤꠟꠞꠦ ꠄꠇꠐꠣ ꠌꠤꠘ꠆ꠘꠔ ꠖꠤꠟꠣ, ꠎꠣꠔꠦ ꠇꠦꠃ ꠔꠣꠞꠦ ꠀꠔꠅ ꠙꠣꠁꠀꠅ ꠘꠣ ꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("GN4_16","002_4_16","GEN","4","16","16","ꠄꠞꠛꠣꠖꠦ ꠇꠣꠛꠤꠟ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠀꠖꠣꠘꠞ ꠙꠥꠛꠦꠖꠤ ꠘꠥꠖ ꠝꠣꠘꠤ, ꠊꠥꠞꠣ-ꠚꠤꠞꠣ ꠖꠦꠡꠅ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN4_17","002_4_17","GEN","4","17","17","ꠀꠞ ꠇꠣꠛꠤꠟ ꠔꠣꠞ ꠛꠃꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠄ ꠔꠣꠁꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ, ꠀꠞ ꠢꠘꠥꠇꠞ ꠎꠘꠝ ꠅꠁꠟ। ꠇꠣꠛꠤꠟꠦ ꠄꠇꠐꠣ ꠐꠣꠃꠘ ꠛꠣꠘꠣꠁꠀ ꠔꠣꠞ ꠙꠥꠀꠞ ꠘꠣꠝꠦ ꠐꠣꠃꠘꠞ ꠘꠣꠝ ꠞꠣꠈꠟ ꠢꠘꠥꠇ। ");
INSERT INTO syls_vpl VALUES ("GN4_18","002_4_18","GEN","4","18","18","ꠢꠘꠥꠇꠞ ꠙꠥꠀ ꠁꠞꠖ, ꠁꠞꠖꠞ ꠙꠥꠀ ꠝꠢꠥꠀꠁꠄꠟ, ꠝꠢꠥꠀꠁꠄꠟꠞ ꠙꠥꠀ ꠝꠕꠥꠡꠣꠁꠄꠟ, ꠝꠕꠥꠡꠣꠁꠄꠟꠞ ꠙꠥꠀ ꠟꠦꠝꠇ। ");
INSERT INTO syls_vpl VALUES ("GN4_19","002_4_19","GEN","4","19","19","ꠟꠦꠝꠇꠦ ꠖꠥꠁ ꠛꠤꠀ ꠇꠞꠍꠟꠣ, ꠄꠇ ꠛꠃꠞ ꠘꠣꠝ ꠀꠖꠣ, ꠀꠞꠇ ꠛꠃꠞ ꠘꠣꠝ ꠡꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN4_20","002_4_20","GEN","4","20","20","ꠀꠖꠣꠞ ꠊꠞꠅ ꠎꠣꠛꠟꠞ ꠎꠘꠝ ꠅꠁꠟ, ꠎꠣꠞꠣ ꠔꠣꠝ꠆ꠛꠥꠔ ꠕꠣꠇꠦ ꠀꠞ ꠙꠡꠥ ꠙꠣꠟꠦ, ꠅꠃ ꠎꠣꠛꠟ ꠔꠣꠞꠣꠞ ꠝꠥꠟ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("GN4_21","002_4_21","GEN","4","21","21","ꠎꠣꠛꠟꠞ ꠜꠣꠁꠞ ꠘꠣꠝ ꠎꠥꠛꠟ। ꠎꠣꠞꠣ ꠛꠣꠡꠤ ꠀꠞ ꠛꠤꠘ ꠛꠣꠎꠣꠄ, ꠅꠃ ꠎꠥꠛꠟ ꠔꠣꠞꠣꠞ ꠝꠥꠟ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("GN4_22","002_4_22","GEN","4","22","22","ꠡꠤꠟ꠆ꠟꠣꠞ ꠙꠦꠐꠅ ꠔꠥꠛꠟ-ꠇꠣꠛꠤꠟꠞ ꠎꠘꠝ ꠅꠁꠟ। ꠙꠤꠔꠟ ꠀꠞ ꠟꠥꠀꠞ ꠀꠔꠤꠀꠞ ꠛꠣꠘꠣꠘꠤ ꠀꠍꠤꠟ ꠔꠣꠞ ꠇꠣꠝ। ꠔꠣꠞ ꠛꠁꠘꠞ ꠘꠣꠝ ꠘꠣꠁꠄꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("GN4_23","002_4_23","GEN","4","23","23","ꠄꠇꠖꠤꠘ ꠟꠦꠝꠇꠦ ꠔꠣꠞ ꠖꠥꠁ ꠛꠃꠞꠦ ꠇꠁꠟ, “ꠅ ꠀꠖꠣ ꠀꠞ ꠡꠤꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘ, ꠟꠦꠝꠇꠞ ꠛꠤꠛꠤꠘ, ꠀꠝꠣꠞ ꠇꠕꠣꠄ ꠖꠦꠅ ꠇꠣꠘ। ꠎꠦ ꠛꠦꠐꠣꠄ ꠀꠝꠣꠞꠦ ꠇꠞꠤꠟ ꠎꠈꠝ, ꠎꠦ ꠛꠦꠐꠣꠄ ꠀꠝꠣꠞ ꠉꠣꠔ ꠔꠥꠟꠟ ꠀꠔ, ꠢꠦꠞꠦ ꠀꠝꠤ ꠇꠞꠤꠟꠣꠝ ꠘꠤꠙꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("GN4_24","002_4_24","GEN","4","24","24","ꠇꠣꠛꠤꠟꠞ ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠎꠥꠖꠤ ꠡꠣꠔ ꠉꠥꠘ ꠅꠄ, ꠟꠦꠝꠇꠞ ꠛꠖꠟꠣ ꠡꠣꠔꠔ꠆ꠔꠁꠞ ꠉꠥꠘ ꠘꠤꠌ꠆ꠌꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN4_25","002_4_25","GEN","4","25","25","ꠄꠞꠝꠣꠎꠦ ꠀꠖꠝꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠛꠃꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠄ, ꠔꠣꠘ ꠙꠦꠐꠅ ꠀꠞꠇ ꠙꠥꠀ ꠅꠁꠟ, ꠢꠣꠅꠀꠄ ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠡꠤꠡ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠇꠣꠛꠤꠟꠦ ꠢꠣꠛꠤꠟꠞꠦ ꠈꠥꠘ ꠇꠞꠍꠦ ꠇꠞꠤ ꠀꠟ꠆ꠟꠣꠄ ꠢꠣꠛꠤꠟꠞ ꠛꠖꠟꠣ ꠀꠝꠣꠞꠦ ꠄꠇ ꠌꠦꠞꠣꠉ ꠎꠥꠉꠣꠁ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN4_26","002_4_26","GEN","4","26","26","ꠛꠣꠖꠦ ꠡꠤꠡꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ, ꠢꠦ ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟ ꠀꠘꠥꠡ, ꠅꠃ ꠡꠝꠄ ꠕꠘꠦ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ ꠟꠅꠀ ꠡꠥꠞꠥ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_1","002_5_1","GEN","5","1","1","ꠁꠔꠣ ꠅꠁꠟ ꠀꠖꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠇꠟꠝꠛꠘ꠆ꠖꠤ ꠛꠄꠀꠘ। ꠝꠣꠘꠥꠡ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠍꠥꠞꠔꠦ ꠙꠄꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_2","002_5_2","GEN","5","2","2","ꠙꠄꠖꠣ ꠇꠞꠟꠣ ꠛꠦꠐꠣ ꠀꠞ ꠛꠦꠐꠤ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠛꠞꠇꠔ ꠖꠤꠟꠣ, ꠙꠄꠖꠣ ꠇꠞꠤꠀ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠀꠖꠝ। ");
INSERT INTO syls_vpl VALUES ("GN5_3","002_5_3","GEN","5","3","3","ꠀꠖꠝꠞ ꠄꠇ-ꠡ ꠔꠤꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠟꠉꠦ ꠝꠤꠟ ꠞꠣꠈꠤꠀ ꠔꠣꠘ ꠍꠥꠞꠔꠦ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ। ꠔꠣꠁꠘ ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠡꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("GN5_4","002_5_4","GEN","5","4","4","ꠡꠤꠡꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠀꠖꠝ ꠀꠞꠅ ꠀꠐ-ꠡ ꠛꠞꠍ ꠛꠣꠌꠟꠣ, ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_5","002_5_5","GEN","5","5","5","ꠝꠥꠐ ꠘꠄ-ꠡ ꠔꠤꠡ ꠛꠞꠍ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠣꠞ ꠛꠣꠖꠦ ꠀꠖꠝ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_6","002_5_6","GEN","5","6","6","ꠡꠤꠡꠞ ꠄꠇ-ꠡ ꠙꠣꠌ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠥꠀ ꠀꠘꠥꠡꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_7","002_5_7","GEN","5","7","7","ꠀꠘꠥꠡꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠡꠤꠡ ꠀꠞꠅ ꠀꠐ-ꠡ ꠡꠣꠔ ꠛꠞꠍ ꠛꠣꠌꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_8","002_5_8","GEN","5","8","8","ꠝꠥꠐ ꠘꠄ-ꠡ ꠛꠣꠞꠅ ꠛꠞꠍ ꠛꠣꠌꠣꠞ ꠛꠣꠖꠦ ꠡꠤꠡ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_9","002_5_9","GEN","5","9","9","ꠀꠘꠥꠡꠞ ꠘꠛ꠆ꠛꠁ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠥꠀ ꠇꠤꠘꠣꠘꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_10","002_5_10","GEN","5","10","10","ꠇꠤꠘꠣꠘꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠀꠘꠥꠡ ꠀꠞꠅ ꠀꠐ-ꠡ ꠙꠘꠞ ꠛꠞꠍ ꠛꠣꠌꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_11","002_5_11","GEN","5","11","11","ꠝꠥꠐ ꠘꠄ-ꠡ ꠙꠣꠌ ꠛꠞꠍ ꠛꠣꠌꠣꠞ ꠛꠣꠖꠦ ꠀꠘꠥꠡ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_12","002_5_12","GEN","5","12","12","ꠇꠤꠘꠣꠘꠞ ꠡꠔ꠆ꠔꠁꠞ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠥꠀ ꠝꠣꠢꠟꠣꠁꠟꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_13","002_5_13","GEN","5","13","13","ꠝꠣꠢꠟꠣꠁꠟꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠇꠤꠘꠣꠘ ꠀꠞꠅ ꠀꠐ-ꠡ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠛꠣꠌꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_14","002_5_14","GEN","5","14","14","ꠝꠥꠐ ꠘꠄ-ꠡ ꠖꠡ ꠛꠞꠍ ꠛꠣꠌꠣꠞ ꠛꠣꠖꠦ ꠇꠤꠘꠣꠘ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_15","002_5_15","GEN","5","15","15","ꠝꠣꠢꠟꠣꠁꠟꠞ ꠙꠄꠡꠐ꠆ꠐꠤ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠥꠀ ꠁꠀꠞꠦꠖꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_16","002_5_16","GEN","5","16","16","ꠁꠀꠞꠦꠖꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠝꠣꠢꠟꠣꠁꠟ ꠀꠞꠅ ꠀꠐ-ꠡ ꠔꠤꠡ ꠛꠞꠍ ꠛꠣꠌꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_17","002_5_17","GEN","5","17","17","ꠝꠥꠐ ꠀꠐ-ꠡ ꠙꠌꠣꠘꠛ꠆ꠛꠁ ꠛꠞꠍ ꠛꠣꠌꠣꠞ ꠛꠣꠖꠦ ꠝꠣꠢꠟꠣꠁꠟ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_18","002_5_18","GEN","5","18","18","ꠁꠀꠞꠦꠖꠞ ꠄꠇ-ꠡ ꠛꠣꠡꠐ꠆ꠐꠤ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠥꠀ ꠁꠖ꠆ꠞꠤꠍꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_19","002_5_19","GEN","5","19","19","ꠁꠖ꠆ꠞꠤꠍꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠁꠀꠞꠦꠖ ꠀꠞꠅ ꠀꠐ-ꠡ ꠛꠞꠍ ꠛꠣꠌꠟꠣ, ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_20","002_5_20","GEN","5","20","20","ꠝꠥꠐ ꠘꠄ-ꠡ ꠛꠣꠡꠐ꠆ꠐꠤ ꠛꠞꠍ ꠛꠣꠌꠣꠞ ꠛꠣꠖꠦ ꠁꠀꠞꠦꠖ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_21","002_5_21","GEN","5","21","21","ꠁꠖ꠆ꠞꠤꠍꠞ ꠙꠄꠡꠐ꠆ꠐꠤ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠥꠀ ꠝꠣꠔꠥꠡꠣꠟꠣꠈꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_22","002_5_22","GEN","5","22","22","ꠝꠣꠔꠥꠡꠣꠟꠣꠈꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠔꠤꠘ-ꠡ ꠛꠞꠍ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠁꠖ꠆ꠞꠤꠍꠞ ꠈꠣꠍ ꠖꠤꠖꠣꠞ ꠀꠍꠤꠟ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_23","002_5_23","GEN","5","23","23","ꠁꠖ꠆ꠞꠤꠍ ꠝꠥꠐ ꠔꠤꠘ-ꠡ ꠙꠄꠡꠐ꠆ꠐꠤ ꠛꠞꠍ ꠖꠥꠘꠤꠀꠁꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_24","002_5_24","GEN","5","24","24","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠘꠦ ꠀꠞ ꠖꠦꠈꠣ ꠉꠦꠟ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠔꠣꠘ ꠈꠣꠍ ꠖꠤꠖꠣꠞ ꠀꠍꠤꠟ ꠉꠔꠤꠇꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠘꠤꠎꠞ ꠉꠦꠍꠦ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN5_25","002_5_25","GEN","5","25","25","ꠝꠣꠔꠥꠡꠣꠟꠣꠈꠞ ꠄꠇ-ꠡ ꠡꠣꠔꠣꠡꠤ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠥꠀ ꠟꠣꠝꠣꠇꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_26","002_5_26","GEN","5","26","26","ꠟꠣꠝꠣꠇꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠝꠣꠔꠥꠡꠣꠟꠣꠈ ꠀꠞꠅ ꠡꠣꠔ-ꠡ ꠛꠤꠞꠣꠡꠤ ꠛꠞꠍ ꠛꠣꠌꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_27","002_5_27","GEN","5","27","27","ꠝꠥꠐ ꠘꠄ-ꠡ ꠃꠘꠥꠡꠔ꠆ꠔꠁꠞ ꠛꠞꠍ ꠛꠣꠌꠣꠞ ꠛꠣꠖꠦ ꠝꠣꠔꠥꠡꠣꠟꠣꠈ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_28","002_5_28","GEN","5","28","28","ꠟꠣꠝꠣꠇꠞ ꠄꠇ-ꠡ ꠛꠤꠞꠣꠡꠤ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_29","002_5_29","GEN","5","29","29","ꠔꠣꠁꠘ ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠘꠥꠢ ꠀꠞ ꠇꠁꠟꠣ, “ꠢꠦ ꠀꠝꠞꠣꠞ ꠀꠔꠞ ꠁ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠇꠣꠝ ꠕꠣꠇꠤ, ꠝꠣꠛꠥꠖꠞ ꠟꠣꠘ꠆ꠘꠔꠤ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠅꠈꠘ ꠀꠞꠣꠝ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN5_30","002_5_30","GEN","5","30","30","ꠘꠥꠢꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠟꠣꠝꠣꠇ ꠀꠞꠅ ꠙꠣꠌ-ꠡ ꠙꠌꠣꠘꠛ꠆ꠛꠁ ꠛꠞꠍ ꠛꠣꠌꠟꠣ, ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN5_31","002_5_31","GEN","5","31","31","ꠝꠥꠐ ꠡꠣꠔ-ꠡ ꠡꠣꠔꠔ꠆ꠔꠁꠞ ꠛꠞꠍ ꠛꠣꠌꠣꠞ ꠛꠣꠖꠦ ꠟꠣꠝꠣꠇ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN5_32","002_5_32","GEN","5","32","32","ꠘꠥꠢꠞ ꠙꠣꠌ-ꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠡꠣꠝ, ꠢꠣꠝ ꠀꠞ ꠁꠀꠚꠦꠔꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN6_1","002_6_1","GEN","6","1","1","ꠖꠥꠘꠤꠀꠞ ꠃꠙꠞꠦ ꠎꠦꠛꠟꠣ ꠝꠣꠘꠥꠡ ꠛꠣꠠꠣ ꠀꠞꠝ꠆ꠛ ꠅꠁꠟ, ꠀꠞ ꠛꠃꠔ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠅ ꠎꠘꠝ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("GN6_2","002_6_2","GEN","6","2","2","ꠔꠦꠃ ꠉꠣꠁꠛꠤ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠅꠇꠟꠦ ꠅꠃ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠈꠥꠛꠍꠥꠞꠔ ꠖꠦꠈꠤꠀ, ꠎꠦ ꠎꠣꠞꠦ ꠈꠥꠡꠤ ꠔꠣꠁꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN6_3","002_6_3","GEN","6","3","3","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠞꠥꠢꠥ ꠢꠣꠝꠦꠡꠣ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠕꠣꠇꠔ ꠘꠣꠄ। ꠝꠣꠘꠥꠡ ꠔ ꠈꠣꠟꠤ ꠉꠥꠡ꠆ꠔꠞ ꠇꠣꠄꠀ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠄꠇ-ꠡ ꠛꠤꠡ ꠛꠞꠍ ꠢꠣꠄꠀꠔ ꠖꠤꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN6_4","002_6_4","GEN","6","4","4","ꠅꠃ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠢꠃ ꠉꠣꠁꠛꠤ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠅꠇꠟꠞ ꠝꠤꠟꠣ-ꠝꠤꠡꠣꠞ ꠇꠣꠞꠘꠦ ꠎꠦ ꠀꠅꠟꠣꠖꠞ ꠎꠘꠝ ꠅꠁꠟ, ꠔꠣꠞꠣ ꠀꠍꠟꠣ ꠙꠥꠞꠣꠘꠣ ꠎꠝꠣꠘꠣꠞ ꠙꠄꠟꠥꠀꠘ ꠅꠇꠟ। ꠢꠤ ꠡꠝꠄ ꠛꠣ ꠔꠣꠞ ꠛꠣꠖꠦꠅ ꠖꠥꠘꠤꠀꠁꠔ ꠘꠦꠚꠤꠟꠤ ꠎꠣꠔꠞ ꠝꠣꠘꠥꠡ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN6_5","002_6_5","GEN","6","5","5","ꠝꠣꠛꠥꠖꠦ ꠖꠦꠈꠟꠣ, ꠖꠥꠘꠤꠀꠁꠔ ꠝꠣꠘꠡꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠈꠥꠛ ꠛꠣꠠꠤ ꠉꠦꠍꠦ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠈꠣꠁꠡ, ꠈꠤꠀꠟ-ꠈꠥꠡꠤ ꠈꠣꠟꠤ ꠈꠣꠞꠣꠙꠤꠞ ꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN6_6","002_6_6","GEN","6","6","6","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠣꠛꠥꠖꠦ ꠈꠥꠛ ꠔꠇꠟꠤꠚ ꠙꠣꠁꠟꠣ, ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀꠁꠔ ꠝꠣꠘꠥꠡ ꠙꠄꠖꠣ ꠇꠞꠍꠤꠟꠣ ꠇꠞꠤ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN6_7","002_6_7","GEN","6","7","7","ꠀꠞ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠣ ꠝꠣꠘꠡꠞꠦ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠣꠘꠥꠀꠞ, ꠝꠣꠐꠤꠔ ꠌꠟꠞꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠀꠍꠝꠣꠘꠞ ꠙꠣꠈꠤꠅ ꠈꠔꠝ ꠇꠞꠤ ꠖꠤꠝꠥ। ꠁꠔꠣꠞꠦ ꠙꠄꠖꠣ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠖꠤꠟꠅ ꠖꠥꠈ ꠟꠣꠉꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN6_8","002_6_8","GEN","6","8","8","ꠅꠁꠟꠦ ꠘꠥꠢꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN6_9","002_6_9","GEN","6","9","9","ꠁꠔꠣ ꠅꠁꠟ ꠘꠥꠢꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠛꠄꠀꠘ। ꠘꠥꠢ ꠄꠇꠎꠘ ꠇꠣꠝꠤꠟ ꠝꠣꠘꠥꠡ, ꠔꠣꠘ ꠀꠝꠟꠞ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠔꠣꠁꠘꠃ ꠀꠍꠟꠣ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ। ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠔꠣꠘꠞ ꠈꠣꠍ ꠖꠤꠖꠣꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN6_10","002_6_10","GEN","6","10","10","ꠡꠣꠝ, ꠢꠣꠝ ꠀꠞ ꠁꠀꠚꠦꠔ ꠘꠣꠝꠞ ꠔꠣꠘ ꠔꠤꠘ ꠙꠥꠀ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN6_11","002_6_11","GEN","6","11","11","ꠁ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠞ ꠌꠈꠥꠔ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁ ꠉꠥꠘꠣꠄ ꠙꠌꠤ ꠉꠦꠍꠦ ꠀꠞ ꠎꠥꠞ-ꠎꠥꠟꠥꠝꠦ ꠜꠞꠤ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN6_12","002_6_12","GEN","6","12","12","ꠀꠟ꠆ꠟꠣꠄ ꠖꠥꠘꠤꠀꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠁꠔꠣ ꠉꠥꠘꠣꠄ ꠙꠌꠤ ꠉꠦꠍꠦ। ꠇꠣꠞꠘ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞ ꠈꠣꠁꠍꠟꠔ ꠛꠦ-ꠙꠕꠦ ꠉꠦꠍꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN6_13","002_6_13","GEN","6","13","13","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠟ꠆ꠟꠣꠄ ꠘꠥꠢꠞꠦ ꠇꠁꠟꠣ, “ꠔꠣꠝꠣꠝ ꠝꠣꠘꠥꠡ ꠎꠣꠔꠞꠦ ꠀꠝꠤ ꠈꠔꠝ ꠇꠞꠤꠟꠣꠁꠔꠣꠝ ꠑꠤꠇ ꠇꠞꠍꠤ। ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠖꠥꠘꠤꠀꠁ ꠎꠥꠞ-ꠎꠥꠟꠥꠝꠦ ꠜꠞꠤ ꠉꠦꠍꠦ। ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠟꠉꠦ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟꠔꠣ ꠀꠝꠤ ꠡꠦꠡ ꠇꠞꠤꠟꠤꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN6_14","002_6_14","GEN","6","14","14","ꠔꠥꠝꠤ ꠉꠚꠞꠞ ꠔꠇ꠆ꠔꠣ ꠖꠤꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘ ꠎꠣꠎ ꠛꠣꠘꠣꠅ। ꠄꠞ ꠜꠤꠔꠞꠦ ꠀꠟꠉꠣ ꠀꠟꠉꠣ ꠇꠥꠑꠣ ꠕꠣꠇꠛ। ꠀꠞ ꠎꠣꠎꠞ ꠛꠣꠞꠦ-ꠜꠤꠔꠞꠦ ꠀꠟꠇꠣꠔꠞꠣ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("GN6_15","002_6_15","GEN","6","15","15","ꠎꠣꠎꠈꠣꠘ ꠟꠣꠝ꠆ꠛꠣꠄ ꠔꠤꠘ-ꠡ ꠀꠔ, ꠙꠣꠡꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠔ ꠀꠞ ꠈꠣꠠꠣ-ꠃꠛꠤ ꠔꠤꠡ ꠀꠔ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("GN6_16","002_6_16","GEN","6","16","16","ꠀꠞ ꠌꠣꠟꠅ ꠕꠣꠇꠤ ꠄꠇ ꠀꠔ ꠔꠟꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠈꠤꠠꠇꠤ ꠞꠣꠈꠛꠣꠄ, ꠀꠞ ꠖꠥꠀꠞ ꠖꠤꠛꠣꠄ ꠎꠣꠎꠞ ꠄꠇ ꠇꠣꠘ꠆ꠖꠣꠔ। ꠎꠣꠎꠈꠣꠘ ꠔꠤꠔꠣꠟꠣ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("GN6_17","002_6_17","GEN","6","17","17","ꠖꠦꠈꠤꠅ, ꠀꠝꠤ ꠖꠥꠘꠤꠀꠁꠔ ꠅꠟꠣ ꠛꠁꠘ꠆ꠘꠣ ꠖꠤꠝꠥ, ꠀꠍꠝꠣꠘꠞ ꠔꠟꠦ ꠎꠔ ꠎꠣꠘꠖꠣꠞꠦ ꠖꠝ ꠚꠣꠟꠣꠄ ꠢꠇꠟꠔꠣꠃ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛ। ꠖꠥꠘꠤꠀꠁꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠃ ꠝꠞꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("GN6_18","002_6_18","GEN","6","18","18","ꠈꠣꠟꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠅꠀꠖꠣ ꠎꠣꠞꠤ ꠞꠣꠈꠝꠥ। ꠔꠥꠝꠤ ꠉꠤꠀ ꠎꠣꠎꠅ ꠃꠑꠛꠣꠄ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ, ꠔꠥꠝꠣꠞ ꠛꠤꠛꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠛꠃ-ꠅ। ");
INSERT INTO syls_vpl VALUES ("GN6_19","002_6_19","GEN","6","19","19","ꠀꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠣꠘꠖꠣꠞꠞ ꠛꠦꠐꠣ-ꠛꠦꠐꠤꠞ ꠎꠥꠠꠣ ꠝꠤꠟꠣꠁꠀ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠎꠣꠎꠅ ꠔꠥꠟꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN6_20","002_6_20","GEN","6","20","20","ꠙꠞꠔꠦꠇ ꠎꠣꠔꠞ ꠙꠣꠈꠤ, ꠢꠦꠝꠣꠘ-ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠥꠠꠣ ꠎꠥꠠꠣ ꠇꠞꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN6_21","002_6_21","GEN","6","21","21","ꠀꠞ ꠔꠥꠝꠤ ꠢꠇꠟ ꠎꠣꠔꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠤꠞ ꠎꠤꠘꠤꠡ ꠎꠥꠉꠣꠠ ꠇꠞꠤ ꠞꠣꠈꠛꠣꠄ। ꠁꠔꠣ ꠔꠥꠝꠣꠞ ꠀꠞ ꠔꠣꠞꠣꠞ ꠈꠣꠘꠤ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN6_22","002_6_22","GEN","6","22","22","ꠘꠥꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠢꠇꠟꠔꠣꠃ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN7_1","002_7_1","GEN","7","1","1","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠘꠥꠢꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟ ꠀꠁꠀ ꠎꠣꠎꠅ ꠃꠑꠛꠣꠄ। ꠀꠝꠤ ꠖꠦꠈꠤꠀꠞ ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠤꠃ ꠈꠣꠟꠤ ꠖꠤꠘꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("GN7_2","002_7_2","GEN","7","2","2","ꠔꠥꠝꠤ ꠢꠣꠟꠣꠟ ꠎꠣꠘꠥꠀꠞ ꠅꠇꠟ ꠕꠣꠇꠤ ꠘꠞ-ꠝꠦꠖꠤ ꠝꠤꠟꠣꠁꠀ ꠡꠣꠔ ꠎꠥꠠꠣ ꠇꠞꠤ ꠀꠞ ꠢꠣꠞꠣꠝ ꠎꠣꠘꠥꠀꠞ ꠕꠣꠇꠤ ꠄꠇ ꠎꠥꠠꠣ ꠇꠞꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠟꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("GN7_3","002_7_3","GEN","7","3","3","ꠀꠍꠝꠣꠘꠅ ꠃꠠꠞꠣ ꠙꠣꠈꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠘꠞ-ꠝꠦꠖꠤ ꠝꠤꠟꠣꠁꠀ ꠡꠣꠔ ꠎꠥꠠꠣ ꠇꠞꠤ ꠟꠁꠅ। ꠖꠥꠘꠤꠀꠞ ꠝꠣꠎꠦ ꠄꠞꠣꠞ ꠛꠋꠡ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠈꠣꠘ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("GN7_4","002_7_4","GEN","7","4","4","ꠀꠝꠤ ꠡꠣꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠖꠥꠘꠤꠀꠁꠞ ꠃꠙꠞꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ ꠄꠇꠟꠣꠉꠣꠞꠦ ꠝꠦꠊ ꠖꠤꠝꠥ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞꠦ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠈꠔꠝ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN7_5","002_7_5","GEN","7","5","5","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠘꠥꠢꠦ ꠢꠇꠟ ꠇꠣꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN7_6","002_7_6","GEN","7","6","6","ꠛꠁꠘ꠆ꠘꠣ ꠡꠥꠞꠥꠞ ꠡꠝꠄ ꠘꠥꠢꠞ ꠛꠄꠅꠡ ꠀꠍꠤꠟ ꠍꠄ-ꠡ ꠛꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("GN7_7","002_7_7","GEN","7","7","7","ꠛꠁꠘ꠆ꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠞ ꠟꠣꠉꠤ ꠘꠥꠢ, ꠔꠣꠘ ꠛꠤꠛꠤ, ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠀꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠛꠃꠞꠦ ꠟꠁꠀ ꠎꠣꠎꠅ ꠉꠤꠀ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN7_8","002_7_8","GEN","7","8","9","ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠢꠣꠟꠣꠟ-ꠢꠣꠞꠣꠝ ꠎꠣꠘꠥꠀꠞ, ꠙꠣꠈꠤ, ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞꠞ ꠘꠞ-ꠝꠦꠖꠤ ꠝꠤꠟꠤꠀ ꠎꠥꠠꠣ ꠎꠥꠠꠣ ꠅꠁꠀ ꠘꠥꠢꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠎꠣꠎꠅ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN7_10","002_7_10","GEN","7","10","10","ꠅꠃ ꠡꠣꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠖꠥꠘꠤꠀꠁꠔ ꠛꠁꠘ꠆ꠘꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_11","002_7_11","GEN","7","11","11","ꠘꠥꠢꠞ ꠍꠄ-ꠡ ꠛꠍꠞꠞ ꠡꠝꠄ ꠖꠥꠍꠞꠣ ꠝꠣꠡꠞ ꠡꠔꠞ ꠔꠣꠞꠤꠈ ꠙꠣꠔꠣꠟꠞ ꠢꠇꠟ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠔ ꠟꠣꠉꠟ, ꠀꠞ ꠀꠍꠝꠣꠘ ꠎꠦꠘꠥ ꠚꠣꠐꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_12","002_7_12","GEN","7","12","12","ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ ꠖꠥꠘꠤꠀꠁꠞ ꠃꠙꠞꠦ ꠝꠦꠊ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_13","002_7_13","GEN","7","13","13","ꠎꠦꠖꠤꠘ ꠝꠦꠊ ꠡꠥꠞꠥ ꠅꠁꠟ, ꠁꠖꠤꠘ ꠘꠥꠢ, ꠔꠣꠘ ꠛꠤꠛꠤ, ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠡꠣꠝ, ꠢꠣꠝ, ꠁꠀꠚꠦꠔ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠃ ꠅꠇꠟꠅ ꠎꠣꠎꠅ ꠀꠁꠀ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN7_14","002_7_14","GEN","7","14","14","ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠥꠠꠣ ꠎꠥꠠꠣ ꠇꠞꠤ ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞ, ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ, ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ, ꠙꠣꠈꠤ ꠀꠞ ꠒꠣꠈꠘꠣ ꠀꠟꠣ ꠢꠇꠟꠔꠣꠅ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN7_15","002_7_15","GEN","7","15","15","ꠖꠝ ꠚꠣꠟꠣꠁꠀ ꠛꠣꠌꠦ ꠁꠟꠣ ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠣꠘꠖꠣꠞ ꠘꠥꠢꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠎꠣꠎꠅ ꠃꠑꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_16","002_7_16","GEN","7","16","16","ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇꠃ ꠘꠞ-ꠝꠦꠖꠤꠞ ꠎꠥꠠꠣ ꠝꠤꠟꠤꠀ ꠔꠣꠞꠣ ꠃꠑꠍꠤꠟ। ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠎꠣꠎꠞ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN7_17","002_7_17","GEN","7","17","17","ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠗꠞꠤ ꠖꠥꠘꠤꠀꠁꠔ ꠙꠣꠘꠤ ꠛꠣꠠꠔꠦꠃ ꠕꠣꠇꠟ। ꠙꠣꠘꠤ ꠛꠣꠠꠤ ꠎꠣꠅꠀꠄ ꠎꠣꠎꠈꠣꠘ ꠝꠣꠐꠤ ꠕꠣꠇꠤ ꠃꠙꠞꠦ ꠜꠣꠁꠀ ꠃꠑꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_18","002_7_18","GEN","7","18","18","ꠛꠣꠖꠦ ꠙꠣꠘꠤ ꠈꠥꠛ ꠛꠣꠠꠟ ꠀꠞ ꠎꠣꠎꠈꠣꠘ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠌꠟꠣꠌꠟ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_19","002_7_19","GEN","7","19","19","ꠀꠞ ꠙꠣꠘꠤ ꠛꠣꠠꠔꠦꠃ ꠕꠣꠇꠟ। ꠄꠞꠟꠣꠉꠤ ꠎꠦꠘꠅ ꠎꠔ ꠛꠠ ꠛꠠ ꠙꠣꠠ ꠀꠍꠤꠟ, ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠥꠠꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_20","002_7_20","GEN","7","20","20","ꠢꠇꠟ ꠙꠣꠠ-ꠙꠞꠛꠔ ꠛꠥꠠꠤꠀ ꠙꠣꠘꠤ ꠀꠞꠅ ꠙꠘꠞ ꠀꠔ ꠃꠙꠞꠦ ꠃꠑꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_21","002_7_21","GEN","7","21","21","ꠀꠞ ꠖꠥꠘꠤꠀꠁꠔ ꠌꠟꠞꠣ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞ, ꠝꠣꠘꠤ ꠙꠣꠈꠤ, ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ, ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠙꠣꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠊꠥꠞꠞꠣ ꠢꠇꠟꠔꠣ, ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_22","002_7_22","GEN","7","22","22","ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠎꠔ ꠞꠇꠝꠞ ꠎꠔ ꠎꠣꠘꠖꠣꠞ ꠖꠝ ꠚꠣꠟꠣꠁꠀ ꠛꠣꠌꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN7_23","002_7_23","GEN","7","23","23","ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠎꠝꠤꠘꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞ ꠖꠥꠘꠤꠀꠁꠞ ꠃꠙꠞ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠣꠁꠟꠣ। ꠄꠔꠦ ꠝꠣꠘꠥꠡ, ꠎꠣꠘꠥꠀꠞ, ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠀꠍꠝꠣꠘꠞ ꠙꠣꠈꠤ ꠖꠥꠘꠤꠀꠁ ꠕꠣꠇꠤ ꠍꠣꠚ ꠅꠁꠉꠦꠟ। ꠈꠣꠟꠤ ꠘꠥꠢ ꠀꠞ ꠔꠣꠘ ꠟꠉꠦ ꠎꠣꠞꠣ ꠀꠍꠤꠟ, ꠔꠣꠞꠣꠃ ꠛꠣꠌꠤꠀ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN7_24","002_7_24","GEN","7","24","24","ꠖꠥꠘꠤꠀ ꠖꠦꠠ-ꠡ ꠖꠤꠘ ꠙꠣꠘꠤꠔ ꠛꠥꠠꠣꠁꠟ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN8_1","002_8_1","GEN","8","1","1","ꠎꠣꠎꠅ ꠘꠥꠢ ꠀꠞ ꠔꠣꠘ ꠟꠉꠦ ꠎꠔ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ ꠀꠍꠤꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠇꠕꠣꠅ ꠚꠣꠃꠞꠤꠟꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀꠁꠔ ꠛꠣꠔꠣꠡ ꠌꠣꠟꠣꠁꠟꠦ ꠙꠣꠘꠤ ꠇꠝꠣ ꠡꠥꠞꠥ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN8_2","002_8_2","GEN","8","2","2","ꠝꠣꠐꠤꠞ ꠔꠟ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠛꠣꠞꠘꠤ ꠀꠞ ꠀꠍꠝꠣꠘ ꠕꠘꠦ ꠝꠦꠊ ꠙꠠꠣꠞ ꠚꠣꠐꠣ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ, ꠀꠞ ꠝꠦꠊꠅ ꠖꠝ ꠟꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN8_3","002_8_3","GEN","8","3","3","ꠝꠣꠐꠤꠞ ꠃꠙꠞꠞ ꠙꠣꠘꠤ ꠢꠞꠤ ꠉꠦꠟ, ꠀꠞ ꠖꠦꠠ-ꠡ ꠖꠤꠘ ꠛꠣꠖꠦ ꠖꠦꠈꠣ ꠉꠦꠟ ꠙꠣꠘꠤ ꠛꠃꠔ ꠇꠝꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN8_4","002_8_4","GEN","8","4","4","ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠝꠣꠡꠞ ꠡꠔꠞ ꠔꠣꠞꠤꠈ ꠎꠣꠎꠈꠣꠘ ꠀꠞꠣꠞꠣꠔꠞ ꠙꠣꠠꠤ ꠄꠟꠣꠇꠣꠔ ꠉꠤꠀ ꠀꠐꠇꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN8_5","002_8_5","GEN","8","5","5","ꠄꠞꠛꠣꠖꠦꠅ ꠙꠣꠘꠤ ꠇꠝꠣꠔ ꠕꠣꠇꠟ, ꠀꠞ ꠖꠡ ꠘꠝ꠆ꠛꠞ ꠝꠣꠡꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠙꠣꠠ ꠅꠇꠟꠞ ꠝꠣꠕꠣ ꠖꠦꠈꠣ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN8_6","002_8_6","GEN","8","6","6","ꠄꠞ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠛꠣꠖꠦ ꠘꠥꠢꠦ ꠎꠣꠎꠞ ꠈꠤꠠꠇꠤ ꠈꠥꠟꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN8_7","002_8_7","GEN","8","7","7","ꠀꠞ ꠈꠤꠠꠇꠤꠛꠣꠄ ꠄꠇ ꠇꠣꠃꠀ ꠍꠣꠠꠟꠣ। ꠝꠣꠐꠤ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠘꠣ ꠢꠥꠇꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠣꠃꠀꠐꠣ ꠀꠅꠀ-ꠎꠣꠅꠀꠔ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN8_8","002_8_8","GEN","8","8","8","ꠝꠣꠐꠤꠞ ꠃꠙꠞ ꠕꠘꠦ ꠙꠣꠘꠤ ꠇꠝꠍꠦ ꠇꠤ ꠘꠣ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠘꠥꠢꠦ ꠛꠣꠖꠦ ꠄꠇꠐꠣ ꠙꠣꠞꠅ ꠍꠣꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN8_9","002_8_9","GEN","8","9","9","ꠁ ꠡꠝꠄꠅ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠙꠣꠘꠤ ꠀꠍꠤꠟ ꠇꠞꠤ ꠙꠣꠅ ꠕꠁꠛꠣꠞ ꠎꠣꠉꠣ ꠘꠣ ꠙꠣꠁꠀ ꠙꠣꠞꠅꠐꠣ ꠢꠤꠞꠛꠣꠞ ꠚꠤꠞꠤꠀ ꠀꠁꠟ। ꠔꠣꠁꠘ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠔꠣꠞꠦ ꠜꠤꠔꠞꠦ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN8_10","002_8_10","GEN","8","10","10","ꠢꠦꠡꠦ ꠔꠣꠁꠘ ꠀꠞꠅ ꠡꠣꠔ ꠖꠤꠘ ꠛꠣꠞ ꠌꠣꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠞꠦ ꠍꠣꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN8_11","002_8_11","GEN","8","11","11","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠢꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠀꠁꠟ, ꠀꠞ ꠔꠣꠞ ꠑꠥꠐꠅ ꠀꠍꠤꠟ ꠎꠄꠔꠥꠘ ꠉꠣꠍꠞ ꠢꠣꠎꠝꠣ ꠙꠣꠔꠣ, ꠔꠣꠁꠘ ꠛꠥꠎꠟꠣ ꠝꠣꠐꠤꠞ ꠃꠙꠞ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠇꠝꠤ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN8_12","002_8_12","GEN","8","12","12","ꠀꠞꠅ ꠡꠣꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠙꠣꠞꠅꠐꠣ ꠍꠣꠠꠟꠣ, ꠁꠇꠐꠣ ꠀꠞ ꠚꠤꠞꠤꠀ ꠀꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN8_13","002_8_13","GEN","8","13","13","ꠘꠥꠢꠞ ꠛꠄꠅꠡ ꠍꠄ-ꠡ ꠄꠇ ꠛꠍꠞꠞ ꠡꠝꠄ ꠙꠄꠟꠣ ꠝꠣꠡꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠝꠣꠐꠤꠞ ꠃꠙꠞ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠢꠞꠤ ꠉꠦꠟ, ꠀꠞ ꠘꠥꠢꠦ ꠎꠣꠎꠞ ꠌꠣꠟ ꠈꠥꠟꠤꠀ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠝꠣꠐꠤ ꠢꠥꠇꠣꠘꠤ ꠗꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN8_14","002_8_14","GEN","8","14","14","ꠖꠥꠍꠞꠣ ꠝꠣꠡꠞ ꠡꠣꠔꠣꠁꠡ ꠖꠤꠘꠞ ꠖꠤꠘ ꠝꠣꠐꠤ ꠄꠇꠁꠛꠣꠞꠦ ꠢꠥꠇꠣꠁ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN8_15","002_8_15","GEN","8","15","15","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN8_16","002_8_16","GEN","8","16","16","“ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠤꠛꠤ, ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠛꠃꠞꠦ ꠟꠁꠀ ꠎꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠅ। ");
INSERT INTO syls_vpl VALUES ("GN8_17","002_8_17","GEN","8","17","17","ꠀꠞ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠎꠔ ꠎꠣꠔꠞ ꠎꠣꠘꠖꠣꠞ ꠀꠍꠦ - ꠙꠣꠈꠤ, ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ - ꠔꠣꠞꠣꠞꠦꠅ ꠛꠣꠞ ꠇꠞꠤ ꠟꠁꠀ ꠀꠅ, ꠎꠦꠘꠥ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁ ꠎꠥꠠꠤ ꠔꠣꠞꠣ ꠍꠤꠔ꠆ꠞꠤꠀ ꠉꠤꠀ ꠚꠟꠀꠟꠣ ꠅꠁꠀ ꠛꠣꠠꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN8_18","002_8_18","GEN","8","18","18","ꠔꠦꠃ ꠘꠥꠢꠦ, ꠔꠣꠘ ꠛꠤꠛꠤ, ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠃꠞꠦ ꠟꠁꠀ ꠎꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN8_19","002_8_19","GEN","8","19","19","ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠖꠥꠘꠤꠀꠁꠞ ꠢꠇꠟ ꠎꠣꠘꠥꠀꠞ, ꠝꠣꠐꠤꠔ ꠌꠟꠞꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞ, ꠀꠞ ꠙꠣꠈꠤ, ꠄꠇ ꠇꠕꠣꠄ ꠖꠥꠘꠤꠀꠁꠔ ꠌꠟꠞꠣ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞ, ꠎꠣꠞꠎꠤꠞ ꠎꠣꠔꠝꠔ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN8_20","002_8_20","GEN","8","20","20","ꠛꠣꠖꠦ ꠘꠥꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠙꠞꠔꠦꠇ ꠎꠣꠔꠞ ꠢꠣꠟꠣꠟ ꠙꠡꠥ-ꠙꠣꠈꠤ ꠕꠣꠇꠤ ꠄꠇ ꠄꠇꠐꠣ ꠟꠁꠀ ꠎꠛ ꠇꠞꠤꠀ, ꠎꠣꠟꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN8_21","002_8_21","GEN","8","21","21","ꠝꠣꠛꠥꠖ ꠁ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠈꠥꠡꠤ ꠅꠁꠟꠣ, ꠀꠞ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠞ ꠇꠥꠘꠥ ꠡꠝꠄꠅ ꠝꠣꠐꠤꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠔꠣꠝ ꠘꠣꠄ, ꠎꠥꠖꠤꠅ ꠢꠥꠞꠥꠛꠣꠟꠣ ꠕꠣꠇꠤꠃ ꠝꠣꠘꠡꠞ ꠝꠘꠞ ꠈꠤꠀꠟ ꠈꠣꠞꠣꠙꠤꠞ ꠛꠣꠄ ꠕꠣꠇꠦ। ꠁꠚꠤꠞꠣ ꠎꠦꠟꠣ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞꠦ ꠝꠣꠞꠍꠤ, ꠁꠟꠣꠈꠣꠘ ꠀꠞ ꠇꠥꠘꠥ ꠖꠤꠘꠃ ꠝꠣꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN8_22","002_8_22","GEN","8","22","22","ꠎꠔꠖꠤꠘ ꠁ ꠖꠥꠘꠤꠀꠁ ꠕꠣꠇꠛ, ꠅꠔꠖꠤꠘ ꠘꠤꠅꠝꠝꠔ ꠛꠤꠌ ꠚꠣꠟꠣꠘꠤ ꠀꠞ ꠚꠡꠟ ꠇꠣꠐꠣ, ꠑꠣꠘ꠆ꠒꠣ ꠀꠞ ꠉꠞꠝ, ꠛꠣꠞꠤꠡꠣ ꠀꠞ ꠄꠅꠔ, ꠖꠤꠘ ꠀꠞ ꠞꠣꠁꠔ ꠌꠟꠔꠦꠃ ꠕꠣꠇꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN9_1","002_9_1","GEN","9","1","1","ꠀꠟ꠆ꠟꠣꠄ ꠘꠥꠢ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠛꠞꠇꠔ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤꠔꠣꠁꠘ ꠚꠟꠀꠟꠣ ꠅꠁꠀ ꠛꠣꠠꠤꠀ ꠖꠥꠘꠤꠀꠁ ꠜꠞꠤ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("GN9_2","002_9_2","GEN","9","2","2","ꠖꠥꠘꠤꠀꠁꠞ ꠎꠣꠘꠥꠀꠞ, ꠀꠍꠝꠣꠘꠞ ꠙꠣꠈꠤ, ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠖꠞꠤꠀꠞ ꠝꠣꠍ, ꠢꠇꠟꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠒꠞ-ꠜꠄ ꠇꠞꠤ ꠌꠟꠛ। ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN9_3","002_9_3","GEN","9","3","3","ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠦꠔꠞ ꠚꠟ-ꠚꠡꠟ ꠀꠞ ꠔꠞꠤ-ꠔꠞꠇꠣꠞꠤ ꠖꠤꠍꠟꠣꠝ, ꠅꠃꠟꠣ ꠅꠈꠘ ꠎꠤꠔꠣ ꠎꠣꠘꠖꠣꠞ ꠢꠇꠟꠞꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN9_4","002_9_4","GEN","9","4","4","ꠈꠣꠟꠤ ꠟꠃ ꠡꠢ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ, ꠟꠃ ꠅꠁꠟꠉꠤ ꠎꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN9_5","002_9_5","GEN","9","5","5","ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠘ ꠇꠞꠦ ꠔꠦ ꠀꠝꠤ ꠅꠛꠡ꠆ꠡꠃ ꠔꠣꠞ ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠟꠁꠝꠥ। ꠢꠦ ꠎꠣꠘꠥꠀꠞ ꠅꠃꠇ ꠛꠣ ꠝꠣꠘꠥꠡ ꠅꠃꠇ, ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠎꠦ ꠘꠦꠄ, ꠔꠣꠞ ꠎꠣꠘꠅ ꠖꠦꠅꠘ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("GN9_6","002_9_6","GEN","9","6","6","ꠝꠣꠘꠡꠞ ꠟꠃ ꠎꠦ ꠛꠣꠞ ꠇꠞꠦ, ꠝꠣꠘꠡꠦꠅ ꠔꠣꠞ ꠟꠃ ꠛꠣꠞ ꠇꠞꠛ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠘꠤꠎꠞ ꠍꠥꠞꠔꠦ ꠛꠣꠘꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN9_7","002_9_7","GEN","9","7","7","ꠔꠥꠝꠤꠔꠣꠁꠘ ꠛꠦꠡ ꠇꠞꠤ ꠚꠟꠀꠟꠣ ꠅꠁꠀ ꠛꠣꠠꠅ ꠀꠞ ꠖꠥꠘꠤꠀꠁꠔ ꠍꠤꠔ꠆ꠞꠤꠀ ꠎꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN9_8","002_9_8","GEN","9","8","8","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠘꠥꠢ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN9_9","002_9_9","GEN","9","9","9","“ꠢꠥꠘꠅ, ꠀꠝꠤ ꠎꠛꠣꠘ ꠖꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠖꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("GN9_10","002_9_10","GEN","9","10","10","ꠀꠞ ꠙꠣꠈꠤ, ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ ꠀꠞ ꠖꠥꠘꠤꠀꠁꠞ ꠎꠔ ꠎꠣꠘꠥꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠍꠦ, ꠔꠣꠞꠣꠞꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("GN9_11","002_9_11","GEN","9","11","11","ꠎꠛꠣꠘꠐꠣ ꠅꠁꠟ, ꠛꠣꠘꠞ ꠙꠣꠘꠤ ꠖꠤꠀ ꠀꠞ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠢꠇ꠆ꠇꠟ ꠎꠣꠘꠖꠣꠞꠞꠦ ꠝꠣꠞꠣ ꠅꠁꠔ ꠘꠣꠄ, ꠀꠞ ꠔꠣꠝꠣꠝ ꠖꠥꠘꠤꠀꠁ ꠍꠣꠚ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠟꠣ ꠇꠥꠘꠥ ꠛꠣꠘꠅ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN9_12","002_9_12","GEN","9","12","12","ꠀꠟ꠆ꠟꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠎꠦ ꠎꠛꠣꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠞ ꠎꠣꠘꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠖꠤꠟꠣꠝ, ꠁꠇꠐꠣ ꠇꠤꠀꠝꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠅꠀꠁꠟ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN9_13","002_9_13","GEN","9","13","13","ꠀꠞ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤꠞ ꠝꠣꠎꠦ ꠀꠝꠣꠞ ꠞꠋꠗꠦꠘꠥ ꠖꠤꠟꠣꠝ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠖꠥꠘꠤꠀꠁꠔ ꠀꠝꠣꠞ ꠎꠛꠣꠘꠞ ꠘꠤꠡꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN9_14","002_9_14","GEN","9","14","14","ꠎꠦꠛꠟꠣ ꠀꠝꠤ ꠖꠥꠘꠤꠀꠁꠞ ꠃꠙꠞꠦ ꠇꠣꠟꠘꠤ ꠖꠤꠝꠥ, ꠁ ꠡꠝꠄ ꠅꠃ ꠞꠋꠗꠦꠘꠥ ꠖꠦꠈꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN9_15","002_9_15","GEN","9","15","15","ꠀꠞ ꠅꠃ ꠡꠝꠄꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠎꠛꠣꠘꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠝꠥ। ꠀꠞ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠛꠁꠘ꠆ꠘꠣ ꠅꠁꠀ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞꠦ ꠙꠣꠘꠤ ꠖꠤꠀ ꠗꠁꠀ ꠘꠤꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN9_16","002_9_16","GEN","9","16","16","ꠇꠣꠟꠘꠤꠞ ꠝꠣꠎꠦ ꠎꠦꠛꠟꠣ ꠢꠤ ꠞꠋꠗꠦꠘꠥ ꠖꠦꠈꠣ ꠎꠣꠁꠛ ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠖꠥꠘꠤꠀꠁꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠁ ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠎꠛꠣꠘꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN9_17","002_9_17","GEN","9","17","17","ꠢꠦꠡꠦ ꠀꠟ꠆ꠟꠣꠄ ꠘꠥꠢꠞꠦ ꠇꠁꠟꠣ, “ꠖꠥꠘꠤꠀꠁꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠟꠉꠦ ꠀꠝꠤ ꠎꠦ ꠎꠛꠣꠘ ꠖꠤꠍꠤ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠔꠣꠞ ꠘꠤꠡꠣꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN9_18","002_9_18","GEN","9","18","18","ꠎꠣꠎ ꠕꠘꠦ ꠘꠥꠢꠞ ꠎꠦ ꠙꠥꠀꠂꠘ ꠛꠣꠞ ꠅꠁꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠡꠣꠝ, ꠢꠣꠝ ꠀꠞ ꠁꠀꠚꠦꠔ। ꠅꠃ ꠢꠣꠝ ꠅꠁꠟ ꠇꠦꠘꠣꠘꠞ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("GN9_19","002_9_19","GEN","9","19","19","ꠘꠥꠢꠞ ꠅꠃ ꠔꠤꠘꠅ ꠙꠥꠀꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠅꠇꠟ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN9_20","002_9_20","GEN","9","20","20","ꠘꠥꠢꠦ ꠈꠦꠔ-ꠈꠣꠝꠣꠞ ꠡꠥꠞꠥ ꠇꠞꠤꠀ ꠄꠇ ꠀꠋꠉꠥꠞ-ꠈꠦꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN9_21","002_9_21","GEN","9","21","21","ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠣꠛ ꠈꠣꠁꠀ ꠐꠣꠟ ꠅꠁꠀ ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠃꠖꠣꠝ ꠅꠁꠀ ꠙꠠꠤ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN9_22","002_9_22","GEN","9","22","22","ꠇꠦꠘꠣꠘꠞ ꠛꠣꠚ ꠢꠣꠝꠦ ꠀꠁꠀ ꠔꠣꠞ ꠛꠣꠚꠞ ꠅꠃ ꠢꠣꠟ ꠖꠦꠈꠤꠀ ꠛꠣꠞꠦ ꠉꠤꠀ ꠔꠣꠞ ꠖꠥꠁꠅ ꠜꠣꠁꠞ ꠉꠦꠍꠦ ꠇꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN9_23","002_9_23","GEN","9","23","23","ꠅꠁꠟꠦ ꠡꠣꠝ ꠀꠞ ꠁꠀꠚꠦꠔꠦ ꠇꠣꠘ꠆ꠖꠅ ꠇꠞꠤ ꠄꠇꠈꠣꠘ ꠇꠣꠙꠠ ꠟꠁꠀ ꠙꠤꠍꠦ ꠀꠐꠤꠀ ꠛꠣꠚꠞꠦ ꠅꠃ ꠇꠣꠙꠠꠖꠤ ꠉꠥꠞꠤꠀ ꠖꠤꠟꠣ, ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠃꠟꠐꠣꠛꠣꠄ ꠕꠣꠇꠣꠄ ꠛꠣꠚꠞꠦ ꠛꠦ-ꠀꠛꠞꠥ ꠢꠣꠟꠔꠦ ꠖꠦꠈꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN9_24","002_9_24","GEN","9","24","24","ꠘꠤꠡꠣ ꠇꠝꠤ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠘꠥꠢꠦ ꠔꠣꠘ ꠙꠥꠀꠞ ꠇꠣꠘ꠆ꠒ ꠢꠥꠘꠤꠀ ");
INSERT INTO syls_vpl VALUES ("GN9_25","002_9_25","GEN","9","25","25","ꠇꠁꠟꠣ, “ꠇꠦꠘꠣꠘꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠃꠇ, ꠢꠦ ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠉꠥꠟꠣꠝꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN9_26","002_9_26","GEN","9","26","26","ꠔꠣꠁꠘ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠢꠇꠟ ꠔꠣꠞꠤꠚ ꠡꠣꠝꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ, ꠇꠦꠘꠣꠘ ꠡꠣꠝꠞ ꠉꠥꠟꠣꠝ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GN9_27","002_9_27","GEN","9","27","27","ꠀꠟ꠆ꠟꠣꠄ ꠁꠀꠚꠦꠔꠞꠦ ꠛꠃꠔꠔꠣ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠢꠦ ꠡꠣꠝꠞ ꠔꠣꠝ꠆ꠛꠥꠔ ꠕꠣꠇꠃꠇ, ꠀꠞ ꠇꠦꠘꠣꠘ ꠔꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("GN9_28","002_9_28","GEN","9","28","28","ꠛꠣꠘꠞ ꠛꠣꠖꠦ ꠘꠥꠢ ꠀꠞꠅ ꠡꠣꠠꠦ ꠔꠤꠘ-ꠡ ꠛꠞꠍ ꠛꠣꠌꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN9_29","002_9_29","GEN","9","29","29","ꠝꠥꠐ ꠡꠣꠠꠦ ꠘꠄ-ꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN10_1","002_10_1","GEN","10","1","1","ꠘꠥꠢꠞ ꠙꠥꠀꠂꠘ ꠡꠣꠝ, ꠢꠣꠝ, ꠀꠞ ꠁꠀꠚꠦꠔꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠄꠀꠘ। ꠛꠣꠘꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN10_2","002_10_2","GEN","10","2","2","ꠁꠀꠚꠦꠔꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ: ꠉꠥꠝꠞ, ꠝꠣꠎꠥꠎ, ꠝꠣꠖꠄ, ꠁꠀꠛꠣꠘ, ꠔꠥꠛꠟ, ꠝꠦꠡꠇ ꠀꠞ ꠔꠤꠞꠡ। ");
INSERT INTO syls_vpl VALUES ("GN10_3","002_10_3","GEN","10","3","3","ꠉꠥꠝꠞꠞ ꠙꠥꠀꠂꠘ: ꠅꠡ꠆ꠇꠤꠘꠡ, ꠞꠤꠚꠔ ꠀꠞ ꠔꠥꠉꠞ꠆ꠝ। ");
INSERT INTO syls_vpl VALUES ("GN10_4","002_10_4","GEN","10","4","4","ꠁꠀꠛꠣꠘꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ: ꠁꠟꠤꠡꠣꠢ, ꠔꠞ꠆ꠡꠤꠡ, ꠇꠤꠔ꠆ꠔꠤꠝ ꠀꠞ ꠞꠥꠖꠣꠘꠤꠝ। ");
INSERT INTO syls_vpl VALUES ("GN10_5","002_10_5","GEN","10","5","5","ꠄꠞꠣꠞ ꠛꠋꠡꠞ ꠝꠣꠘꠡꠦ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠞ ꠝꠣꠔ-ꠇꠕꠣ, ꠙꠞꠤꠛꠣꠞ ꠀꠞ ꠎꠣꠔ ꠢꠤꠡꠣꠛꠦ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠞ ꠘꠣꠘꠣꠘ ꠖꠦꠡꠅ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN10_6","002_10_6","GEN","10","6","6","ꠢꠣꠝꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ: ꠇꠥꠡ, ꠝꠤꠡꠞ, ꠙꠥꠐ ꠀꠞ ꠇꠦꠘꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN10_7","002_10_7","GEN","10","7","7","ꠇꠥꠡꠞ ꠙꠥꠀꠂꠘ: ꠍꠛꠣ, ꠢꠛꠤꠟꠣ, ꠍꠙ꠆ꠔꠣ, ꠞꠄꠝꠣ ꠀꠞ ꠍꠙ꠆ꠔꠇꠣ। ꠞꠄꠝꠣꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ: ꠡꠣꠛꠣ ꠀꠞ ꠖꠖꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN10_8","002_10_8","GEN","10","8","8","ꠇꠥꠡꠞ ꠄꠇ ꠙꠥꠀꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠘꠝꠞꠥꠖ। ꠅꠃ ꠘꠝꠞꠥꠖ ꠖꠥꠘꠤꠀꠁꠔ ꠙꠄꠟꠥꠀꠘ ꠅꠁꠀ ꠃꠑꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN10_9","002_10_9","GEN","10","9","9","ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠢꠦ ꠀꠍꠤꠟ ꠙꠄꠟꠥꠀꠘ ꠡꠤꠇꠣꠞꠤ। ꠄꠞꠟꠣꠉꠤ ꠒꠣꠇꠞ ꠇꠕꠣ ꠀꠍꠦ, ꠝꠣꠘꠥꠡꠐꠣ ꠎꠦꠘ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠘꠝꠞꠥꠖꠞ ꠟꠣꠈꠣꠘ ꠙꠄꠟꠥꠀꠘ ꠡꠤꠇꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("GN10_10","002_10_10","GEN","10","10","10","ꠡꠤꠘꠣꠞ ꠖꠦꠡꠞ ꠛꠣꠛꠤꠟ, ꠄꠞꠇ, ꠅꠇ꠆ꠇꠖ ꠀꠞ ꠇꠟꠘꠤ ꠘꠣꠝꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠟꠁꠀ ꠢꠦ ꠛꠣꠖꠡꠣꠁ ꠡꠥꠞꠥ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("GN10_11","002_10_11","GEN","10","11","11","ꠅꠘ ꠕꠣꠇꠤ ꠔꠣꠞ ꠞꠣꠁꠎ꠆ꠎ ꠛꠣꠠꠤꠀ ꠀꠡꠤꠞꠤꠀ ꠖꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠦꠟ। ꠢꠈꠣꠘꠞ ꠘꠤꠘꠜ, ꠞꠢꠛꠔꠙꠥꠞ, ꠇꠦꠟꠢ ");
INSERT INTO syls_vpl VALUES ("GN10_12","002_10_12","GEN","10","12","12","ꠀꠞ ꠞꠦꠡꠘ ꠘꠣꠝꠞ ꠐꠣꠃꠘ ꠅꠇꠟꠅ ꠔꠣꠞ ꠛꠣꠘꠣꠁꠟ। ꠞꠦꠡꠘ ꠀꠍꠤꠟ ꠘꠤꠘꠜ ꠀꠞ ꠇꠦꠟꠢꠞ ꠝꠣꠎꠈꠣꠘꠅ, ꠁ ꠔꠤꠘꠐꠣꠄ ꠝꠤꠟꠤꠀ ꠄꠇ ꠛꠤꠞꠣꠐ ꠡꠢꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN10_13","002_10_13","GEN","10","13","13","ꠝꠤꠡꠞꠞ ꠛꠋꠡ ꠅꠁꠟꠣ ꠅꠃ ꠎꠣꠔ ꠅꠇꠟ: ꠟꠥꠖꠤ, ꠅꠘꠣꠝꠤ, ꠟꠢꠣꠛꠤ, ꠘꠙ꠆ꠔꠥꠢꠤ, ");
INSERT INTO syls_vpl VALUES ("GN10_14","002_10_14","GEN","10","14","14","ꠙꠕ꠆ꠞꠥꠡꠤ, ꠇꠡꠟꠥꠢꠤ, ꠀꠞ ꠇꠙ꠆ꠔꠥꠞꠤ, ꠅꠃ ꠇꠙ꠆ꠔꠥꠞ ꠖꠤꠙ ꠕꠣꠇꠤ ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN10_15","002_10_15","GEN","10","15","15","ꠇꠦꠘꠣꠘꠞ ꠛꠠ ꠙꠥꠀ ꠍꠤꠖꠘ, ꠛꠣꠖꠞ ꠙꠥꠀ ꠢꠤꠐ, ꠢꠤꠐ꠆ꠐꠤ ꠎꠣꠔꠤꠞ ꠝꠥꠟ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("GN10_16","002_10_16","GEN","10","16","16","ꠇꠦꠘꠣꠘ ꠀꠍꠟꠣ ꠎꠤꠛꠥꠎꠤ, ꠀꠝꠥꠞꠤ, ꠉꠤꠞ꠆ꠉꠣꠡꠤ, ");
INSERT INTO syls_vpl VALUES ("GN10_17","002_10_17","GEN","10","17","17","ꠢꠤꠛ꠆ꠛꠤ, ꠀꠞ꠆ꠇꠤ, ꠍꠤꠘꠤ, ");
INSERT INTO syls_vpl VALUES ("GN10_18","002_10_18","GEN","10","18","18","ꠀꠞ꠆ꠛꠣꠖꠤ, ꠎꠝꠣꠞꠤ ꠀꠞ ꠢꠣꠝꠣꠔꠤ, ꠅꠃ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠝꠥꠟ ꠛꠣꠚ। ꠢꠦꠡꠦ ꠅꠃ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN10_19","002_10_19","GEN","10","19","19","ꠍꠤꠖꠘ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠉꠦꠞꠣꠞꠞ ꠝꠥꠈꠣ ꠉꠣꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠞ ꠉꠣꠎꠣ ꠕꠣꠇꠤ ꠍꠣꠖꠥꠝ, ꠀꠝꠥꠞꠣ, ꠅꠖꠝꠣ ꠀꠞ ꠍꠛꠂꠁꠝ ꠎꠣꠅꠀꠞ ꠙꠕꠦ ꠟꠣꠡꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠞ ꠞꠣꠎꠔ꠆ꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN10_20","002_10_20","GEN","10","20","20","ꠙꠞꠤꠛꠣꠞ, ꠝꠣꠔ-ꠇꠕꠣ, ꠖꠦꠡ ꠀꠞ ꠎꠣꠔ ꠢꠤꠡꠣꠛꠦ ꠄꠞꠣ ꠀꠍꠤꠟ ꠢꠣꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN10_21","002_10_21","GEN","10","21","21","ꠁꠀꠚꠦꠔꠞ ꠛꠠ ꠜꠣꠁ ꠡꠣꠝꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠅꠁꠍꠟꠣ। ꠡꠣꠝ ꠅꠁꠟꠣ ꠀꠛꠦꠞ ꠀꠞ ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("GN10_22","002_10_22","GEN","10","22","22","ꠡꠣꠝꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ: ꠁꠟꠣꠝ, ꠀꠡꠥꠞ, ꠀꠞ꠆ꠚꠣꠇꠍꠣꠖ, ꠟꠥꠖ ꠀꠞ ꠅꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN10_23","002_10_23","GEN","10","23","23","ꠅꠞꠣꠝꠞ ꠙꠥꠀꠂꠘ: ꠃꠎ, ꠢꠥꠟ, ꠉꠦꠕꠞ ꠀꠞ ꠝꠡ। ");
INSERT INTO syls_vpl VALUES ("GN10_24","002_10_24","GEN","10","24","24","ꠀꠞ꠆ꠚꠣꠇꠍꠣꠖꠞ ꠙꠥꠀ ꠡꠣꠟꠦꠈ, ꠀꠞ ꠡꠣꠟꠦꠈꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠀꠛꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("GN10_25","002_10_25","GEN","10","25","25","ꠀꠛꠦꠞꠞ ꠖꠥꠁ ꠙꠥꠀ ꠅꠁꠍꠟꠣ, ꠄꠇꠎꠘꠞ ꠘꠣꠝ ꠚꠣꠟꠦꠎ ꠝꠣꠘꠤ, ꠀꠟꠉꠣ, ꠔꠣꠘ ꠡꠝꠄ ꠖꠥꠘꠤꠀ ꠀꠟꠉ ꠅꠁꠍꠤꠟ ꠇꠞꠤ ꠔꠣꠘ ꠅꠃ ꠘꠣꠝ ꠅꠁꠟ। ꠚꠣꠟꠦꠎꠞ ꠜꠣꠁꠞ ꠘꠣꠝ ꠁꠀꠇꠔꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN10_26","002_10_26","GEN","10","26","26","ꠁꠀꠇꠔꠣꠘꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ: ꠅꠟꠝꠥꠖꠖ, ꠡꠦꠟꠚ, ꠢꠣꠎꠞꠣꠝꠣꠅꠔ, ꠎꠦꠞꠢ, ");
INSERT INTO syls_vpl VALUES ("GN10_27","002_10_27","GEN","10","27","27","ꠢꠖꠥꠞꠣꠝ, ꠃꠎꠣꠟ, ꠖꠤꠇ꠆ꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN10_28","002_10_28","GEN","10","28","28","ꠅꠛꠟ, ꠅꠛꠤꠝꠣꠁꠄꠟ, ꠡꠣꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("GN10_29","002_10_29","GEN","10","29","29","ꠅꠚꠤꠞ, ꠢꠛꠤꠟꠣ ꠀꠞ ꠎꠥꠛꠛ। ꠄꠞꠣ ꠢꠇꠟ ꠅꠁꠟꠣ ꠁꠀꠇꠔꠣꠘꠞ ꠙꠥꠀꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN10_30","002_10_30","GEN","10","30","30","ꠝꠦꠡꠣ ꠕꠣꠇꠤ ꠙꠥꠛꠦꠖꠤ ꠍꠦꠚꠣꠞꠅ ꠎꠣꠅꠀꠞ ꠙꠕꠅ ꠎꠦ ꠙꠣꠠꠤ ꠎꠣꠉꠣ ꠀꠍꠦ, ꠅꠘꠅ ꠔꠣꠞꠣ ꠕꠣꠇꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN10_31","002_10_31","GEN","10","31","31","ꠙꠞꠤꠛꠣꠞ, ꠝꠣꠔ-ꠇꠕꠣ, ꠖꠦꠡ, ꠀꠞ ꠎꠣꠔ ꠢꠤꠡꠣꠛꠦ ꠄꠞꠣ ꠅꠁꠟꠣ ꠡꠣꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN10_32","002_10_32","GEN","10","32","32","ꠎꠣꠔ ꠀꠞ ꠛꠋꠡ ꠢꠤꠡꠣꠛꠦ ꠄꠞꠣ ꠅꠁꠟ ꠘꠥꠢꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠙꠞꠤꠛꠣꠞ। ꠛꠣꠘꠞ ꠛꠣꠖꠦ ꠄꠞꠣꠞ ꠛꠋꠡ ꠅꠇꠟꠦ ꠘꠣꠘꠣꠘ ꠎꠣꠔ ꠅꠁꠀ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_1","002_11_1","GEN","11","1","1","ꠢꠤ ꠎꠝꠣꠘꠣꠔ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠈꠣꠟꠤ ꠄꠇ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠔꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠥꠟꠤ ꠅꠇꠟꠅ ꠄꠇꠟꠣꠈꠣꠘꠃ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_2","002_11_2","GEN","11","2","2","ꠔꠣꠞꠣ ꠙꠥꠛꠦꠖꠤ ꠀꠉꠥꠀꠁꠀ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠡꠤꠘꠣꠞ ꠖꠦꠡꠞ ꠄꠇ ꠢꠝꠣꠘ ꠎꠣꠉꠣ ꠙꠣꠁꠀ ꠢꠈꠣꠘꠅꠃ ꠛꠡꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_3","002_11_3","GEN","11","3","3","ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠇꠁꠟ, “ꠀꠅ, ꠀꠝꠞꠣ ꠁꠐ ꠛꠣꠘꠣꠁꠀ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁ।” ꠇꠁꠀꠃ ꠔꠣꠞꠣ ꠙꠣꠔ꠆ꠔꠞꠞ ꠛꠖꠟꠣ ꠁꠐ ꠀꠞ ꠌꠥꠘ-ꠡꠥꠞꠇꠤꠞ ꠛꠖꠟꠣ ꠔꠣꠞꠔꠦꠟ ꠟꠣꠉꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_4","002_11_4","GEN","11","4","4","ꠔꠣꠞꠣ ꠀꠞꠅ ꠇꠁꠟ, “ꠀꠅ, ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠡꠢꠞ ꠛꠣꠘꠣꠁ, ꠀꠞ ꠅꠃꠟꠣ ꠄꠇꠐꠣ ꠊꠞꠅ ꠛꠣꠘꠣꠁ, ꠎꠦꠇꠐꠣꠞ ꠝꠤꠘꠣꠞ ꠉꠤꠀ ꠀꠍꠝꠣꠘ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠛ। ꠔꠦꠃ ꠀꠝꠞꠣꠞ ꠘꠣꠝꠅ ꠅꠁꠛ ꠀꠞ ꠀꠝꠞꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠍꠤꠔ꠆ꠞꠤꠔꠣꠝꠅ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN11_5","002_11_5","GEN","11","5","5","ꠝꠣꠘꠡꠦ ꠎꠦ ꠃꠌꠣ ꠊꠞ ꠀꠞ ꠡꠢꠞ ꠛꠣꠘꠣꠁꠞꠣ ꠁꠇꠐꠣ ꠖꠦꠈꠣꠔ ꠝꠣꠛꠥꠖ ꠟꠣꠝꠤ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_6","002_11_6","GEN","11","6","6","ꠀꠞ ꠇꠁꠟꠣ, “ꠄꠞꠣ ꠄꠇ ꠎꠣꠔꠞ ꠝꠣꠘꠥꠡ, ꠄꠞꠣꠞ ꠝꠣꠔ-ꠇꠕꠣꠅ ꠄꠇ; ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠅꠃ ꠇꠣꠝꠞ ꠝꠣꠎꠦ ꠀꠔ ꠖꠤꠍꠦ। ꠘꠤꠎꠞ ꠝꠔꠟꠛ ꠢꠣꠍꠤꠟꠞ ꠟꠣꠉꠤ ꠄꠞꠣ ꠀꠞ ꠇꠥꠘꠥ ꠛꠣꠗꠣꠃ ꠝꠣꠘꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN11_7","002_11_7","GEN","11","7","7","ꠔꠦ ꠀꠅ, ꠀꠝꠞꠣ ꠟꠣꠝꠤꠀ ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠛꠥꠟꠤꠞ ꠝꠣꠎꠦ ꠉꠥꠟꠝꠣꠟ ꠟꠣꠉꠣꠁ ꠖꠦꠁ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞ ꠝꠣꠔ ꠛꠥꠎꠔ ꠘꠣ ꠙꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN11_8","002_11_8","GEN","11","8","8","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠍꠤꠔ꠆ꠞꠣꠁ ꠖꠤꠟꠣ। ꠀꠞ ꠔꠣꠞꠣꠞ ꠢꠃ ꠡꠢꠞ ꠛꠣꠘꠣꠘꠤꠞ ꠇꠣꠝꠅ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_9","002_11_9","GEN","11","9","9","ꠅꠃ ꠇꠣꠞꠘꠦ ꠢꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠛꠣꠛꠤꠟ ꠝꠣꠘꠤ, ꠉꠥꠟꠝꠣꠟ, ꠢꠈꠣꠘꠅꠃ ꠝꠣꠛꠥꠖꠦ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠞ ꠛꠥꠟꠤꠞ ꠝꠣꠎꠦ ꠉꠥꠟꠝꠣꠟ ꠟꠣꠉꠣꠁ ꠖꠤꠍꠟꠣ। ꠢꠈꠣꠘ ꠕꠣꠇꠤꠃ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞꠦ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠍꠤꠔ꠆ꠞꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_10","002_11_10","GEN","11","10","10","ꠅꠃ ꠅꠁꠟ ꠡꠣꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠄꠀꠘ। ꠛꠣꠘꠞ ꠖꠥꠁ ꠛꠞꠍ ꠛꠣꠖꠦ ꠡꠣꠝꠞ ꠛꠄꠅꠡ ꠎꠦꠛꠟꠣ ꠄꠇ-ꠡ ꠛꠞꠍ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠀꠞ꠆ꠚꠣꠇꠍꠣꠖꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_11","002_11_11","GEN","11","11","11","ꠀꠞ꠆ꠚꠣꠇꠍꠣꠖꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠡꠣꠝ ꠀꠞꠅ ꠙꠣꠌ-ꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠀ ꠀꠍꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_12","002_11_12","GEN","11","12","12","ꠀꠞ꠆ꠚꠣꠇꠍꠣꠖꠞ ꠙꠣꠄꠔꠤꠡ ꠛꠍꠞꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠡꠣꠟꠦꠈꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_13","002_11_13","GEN","11","13","13","ꠡꠣꠟꠦꠈꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠞꠅ ꠌꠣꠁꠞ-ꠡ ꠔꠤꠘ ꠛꠞꠍ ꠛꠣꠌꠤꠀ ꠀꠍꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_14","002_11_14","GEN","11","14","14","ꠡꠣꠟꠦꠈꠞ ꠔꠤꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠀꠛꠦꠞꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_15","002_11_15","GEN","11","15","15","ꠀꠛꠦꠞꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠡꠣꠟꠦꠈ ꠀꠞꠅ ꠌꠣꠁꠞ-ꠡ ꠔꠤꠘ ꠛꠞꠍ ꠛꠣꠌꠤꠀ ꠀꠍꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_16","002_11_16","GEN","11","16","16","ꠀꠛꠦꠞꠞ ꠌꠃꠔꠤꠡ ꠛꠍꠞꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠚꠣꠟꠦꠎꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_17","002_11_17","GEN","11","17","17","ꠚꠣꠟꠦꠎꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠀꠛꠦꠞ ꠀꠞꠅ ꠌꠣꠁꠞ-ꠡ ꠔꠤꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠀ ꠀꠍꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_18","002_11_18","GEN","11","18","18","ꠚꠣꠟꠦꠎꠞ ꠔꠤꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠞꠣꠃꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_19","002_11_19","GEN","11","19","19","ꠞꠣꠃꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠚꠣꠟꠦꠎ ꠀꠞꠅ ꠖꠥꠁ-ꠡ ꠘꠄ ꠛꠞꠍ ꠛꠣꠌꠤꠀ ꠀꠍꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_20","002_11_20","GEN","11","20","20","ꠞꠣꠃꠞ ꠛꠔ꠆ꠔꠤꠡ ꠛꠍꠞꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠍꠣꠞꠥꠎꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_21","002_11_21","GEN","11","21","21","ꠍꠣꠞꠥꠎꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠞꠣꠃ ꠀꠞꠅ ꠖꠥꠁ-ꠡ ꠡꠣꠔ ꠛꠞꠍ ꠛꠣꠌꠤꠀ ꠀꠍꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_22","002_11_22","GEN","11","22","22","ꠍꠣꠞꠥꠎꠞ ꠔꠤꠡ ꠛꠍꠞꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠘꠣꠢꠥꠞꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_23","002_11_23","GEN","11","23","23","ꠘꠣꠢꠥꠞꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠍꠣꠞꠥꠎ ꠀꠞꠅ ꠖꠥꠁ-ꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠀ ꠀꠍꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_24","002_11_24","GEN","11","24","24","ꠘꠣꠢꠥꠞꠞ ꠃꠘꠔꠤꠡ ꠛꠍꠞꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠔꠣꠞꠦꠈꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_25","002_11_25","GEN","11","25","25","ꠔꠣꠞꠦꠈꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠘꠣꠢꠥꠞ ꠀꠞꠅ ꠄꠇ-ꠡ ꠃꠘ꠆ꠘꠤꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠀ ꠀꠍꠟꠣ। ꠄꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠞꠅ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_26","002_11_26","GEN","11","26","26","ꠔꠣꠞꠦꠈꠞ ꠡꠔ꠆ꠔꠁꠞ ꠛꠍꠞꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠀꠛ꠆ꠞꠣꠝ (ꠔꠣꠘ ꠛꠣꠖꠞ ꠘꠣꠝ ꠁꠛ꠆ꠞꠣꠢꠤꠝ), ꠘꠣꠢꠥꠞ ꠀꠞ ꠢꠣꠞꠘꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN11_27","002_11_27","GEN","11","27","27","ꠅꠃ ꠅꠁꠟ ꠔꠣꠞꠦꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠄꠀꠘ। ꠔꠣꠞꠦꠈꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠀꠛ꠆ꠞꠣꠝ, ꠘꠣꠢꠥꠞ ꠀꠞ ꠢꠣꠞꠘ। ꠀꠞ ꠢꠣꠞꠘꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠟꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("GN11_28","002_11_28","GEN","11","28","28","ꠢꠣꠞꠘ ꠔꠣꠘ ꠛꠣꠛꠣ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠔꠦꠃ, ꠔꠣꠘ ꠎꠘꠝ-ꠝꠣꠐꠤ ꠛꠣꠛꠤꠟ ꠖꠦꠡꠞ ꠃꠞ ꠐꠣꠃꠘꠅ ꠝꠣꠞꠣ ꠉꠦꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_29","002_11_29","GEN","11","29","29","ꠀꠛ꠆ꠞꠣꠝ ꠀꠞ ꠘꠣꠢꠥꠞ ꠖꠥꠁꠎꠘꠦ ꠛꠤꠀ ꠇꠞꠍꠟꠣ। ꠀꠛ꠆ꠞꠣꠝꠞ ꠛꠃꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠍꠣꠞꠣ। ꠀꠞ ꠘꠣꠢꠥꠞꠞ ꠛꠃꠞ ꠘꠣꠝ ꠝꠤꠟꠇꠣ। ꠝꠤꠟꠇꠣ ꠀꠞ ꠁꠍꠇꠣ ꠀꠍꠟꠣ ꠢꠣꠞꠘꠞ ꠙꠥꠠꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN11_30","002_11_30","GEN","11","30","30","ꠅꠁꠟꠦ ꠍꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠀꠍꠤꠟ ꠘꠣ, ꠔꠣꠁꠘ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_31","002_11_31","GEN","11","31","31","ꠔꠣꠞꠦꠈꠦ ꠀꠛ꠆ꠞꠣꠝ, ꠟꠥꠔ ꠀꠞ ꠍꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠛꠣꠛꠤꠟ ꠖꠦꠡꠞ ꠃꠞ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ꠀꠛ꠆ꠞꠣꠝ ꠅꠁꠟꠣ ꠔꠣꠞꠦꠈꠞ ꠙꠥꠀ, ꠢꠣꠞꠘꠞ ꠙꠥꠀ ꠟꠥꠔ ꠅꠁꠟꠣ ꠔꠣꠞꠦꠈꠞ ꠘꠣꠔꠤ, ꠀꠞ ꠍꠣꠞꠣ ꠅꠁꠟꠣ ꠔꠣꠞꠦꠈꠞ ꠙꠥꠀ ꠀꠛ꠆ꠞꠣꠝꠞ ꠛꠃ। ꠙꠄꠟꠣ ꠔꠣꠞꠣ ꠢꠣꠞꠣꠘ ꠘꠣꠝꠦ ꠄꠇ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ ꠀꠞ ꠢꠈꠣꠘꠅ ꠛꠡꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN11_32","002_11_32","GEN","11","32","32","ꠔꠣꠞꠦꠈ ꠖꠥꠁ-ꠡ ꠙꠣꠌ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠢꠣꠞꠣꠘ ꠐꠣꠃꠘꠅ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN12_1","002_12_1","GEN","12","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠚꠞꠝꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠖꠦꠡ, ꠈꠦꠡ-ꠇꠥꠐꠥꠝ, ꠀꠞ ꠛꠣꠛꠣꠁꠔꠤ ꠜꠤꠐꠣ-ꠝꠣꠐꠤ ꠍꠣꠠꠤꠀ ꠀꠝꠤ ꠎꠦ ꠖꠦꠡ ꠖꠦꠈꠣꠁꠝꠥ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("GN12_2","002_12_2","GEN","12","2","2","ꠔꠥꠝꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠀꠝꠤ ꠛꠃꠔ ꠛꠠ ꠄꠇ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ। ꠔꠥꠝꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠝꠥ। ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠠ ꠁꠎ꠆ꠎꠔꠤ ꠛꠣꠘꠣꠁꠝꠥ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN12_3","002_12_3","GEN","12","3","3","ꠀꠞ ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞꠦ ꠎꠣꠞꠣ ꠖꠥꠀ ꠖꠤꠛꠣ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠝꠥ, ꠅꠁꠟꠦ ꠎꠣꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠛꠖ꠆ꠖꠥꠀ ꠖꠤꠛꠣ, ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠝꠥ। ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠔꠥꠝꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN12_4","002_12_4","GEN","12","4","4","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠔꠃ ꠀꠛ꠆ꠞꠣꠝ ꠛꠣꠞ ꠅꠁꠉꠦꠟꠣ, ꠔꠣꠘ ꠜꠣꠔꠤꠎꠣ ꠟꠥꠔꠅ ꠔꠣꠘ ꠟꠉꠦ ꠉꠦꠟꠣ। ꠢꠣꠞꠣꠘ ꠐꠣꠃꠘ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠀꠛ꠆ꠞꠣꠝꠞ ꠛꠄꠅꠡ ꠀꠍꠤꠟ ꠙꠌꠔ꠆ꠔꠁꠞ ꠛꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("GN12_5","002_12_5","GEN","12","5","5","ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠣꠞꠣ ꠀꠞ ꠜꠣꠔꠤꠎꠣ ꠟꠥꠔꠞꠦ ꠟꠁꠀ ꠔꠣꠁꠘ ꠛꠣꠞ ꠅꠁꠟꠣ। ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠁꠀ ꠀꠞ ꠎꠦ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠔꠣꠁꠘ-ꠔꠣꠁꠘ ꠢꠣꠞꠣꠘ ꠄꠟꠣꠇꠣꠔ ꠙꠣꠁꠍꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠣ ꠇꠞꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠢꠦꠡꠦ ꠢꠘꠅ ꠉꠤꠀ ꠙꠃꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN12_6","002_12_6","GEN","12","6","6","ꠇꠦꠘꠣꠘꠞ ꠝꠣꠎꠦꠖꠤ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠀꠛ꠆ꠞꠣꠝ ꠡꠤꠈꠤꠝꠅ ꠀꠁꠀ ꠝꠥꠞꠤꠞ ꠄꠟꠘ ꠉꠣꠍꠞ ꠉꠦꠍꠦ ꠎꠤꠞꠣꠁꠟꠣ। ꠁ ꠡꠝꠄ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟ ꠢꠃ ꠖꠦꠡꠅ ꠛꠡꠔ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN12_7","002_12_7","GEN","12","7","7","ꠝꠣꠛꠥꠖꠦ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠀ ꠇꠁꠟꠣ, ꠁ ꠖꠦꠡꠈꠣꠘ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞꠦ ꠖꠤꠟꠣꠁꠝꠥ। ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠎꠦꠁꠘ ꠖꠦꠈꠣ ꠖꠤꠟꠣ, ꠢꠃ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠣꠁꠘ ꠢꠘꠅ ꠄꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN12_8","002_12_8","GEN","12","8","8","ꠢꠘ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠛꠦꠕꠦꠟ ꠐꠣꠃꠘꠞ ꠙꠥꠛꠦꠖꠤ ꠙꠣꠠꠤ ꠄꠟꠣꠇꠣꠔ ꠀꠉꠥꠀꠁ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠙꠁꠌꠝꠦ ꠛꠦꠕꠦꠟ ꠙꠥꠛꠦ ꠅꠄ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠔꠣꠁꠘ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠣꠁꠘ ꠁꠘꠅ ꠄꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN12_9","002_12_9","GEN","12","9","9","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠤꠘ ꠕꠣꠇꠤ ꠢꠞꠔꠦ ꠢꠞꠔꠦ ꠘꠦꠉꠦꠜ ꠘꠣꠝꠞ ꠖꠃꠇꠘꠞ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄꠖꠤ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN12_10","002_12_10","GEN","12","10","10","ꠁ ꠡꠝꠄ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠟ। ꠁ ꠘꠤꠖꠣꠘ ꠈꠥꠛ ꠇꠑꠤꠘ ꠅꠀꠄ, ꠀꠛ꠆ꠞꠣꠝꠦ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠁꠀ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN12_11","002_12_11","GEN","12","11","11","ꠝꠤꠡꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠀꠛ꠆ꠞꠣꠝꠦ ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠎꠣꠘꠤ ꠔꠥꠝꠤ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("GN12_12","002_12_12","GEN","12","12","12","ꠔꠥꠝꠤ ꠎꠦꠛꠟꠣ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠌꠃꠈꠅ ꠙꠠꠛꠣꠄ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠛꠥꠎꠛ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠃ, ꠀꠞ ꠔꠥꠝꠣꠞꠦ ꠞꠣꠈꠤꠀ ꠀꠝꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("GN12_13","002_12_13","GEN","12","13","13","ꠄꠞꠟꠣꠉꠤ ꠇꠁꠅ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠁꠘ। ꠄꠔꠦ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠜꠣꠟꠣ ꠅꠁꠛ, ꠀꠞ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠀ ꠞꠣꠈꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN12_14","002_12_14","GEN","12","14","14","ꠀꠛ꠆ꠞꠣꠝ ꠝꠤꠡꠞꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠤꠡꠞꠞ ꠝꠣꠘꠡꠦ ꠖꠦꠈꠟꠣ ꠍꠣꠞꠣ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("GN12_15","002_12_15","GEN","12","15","15","ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠥꠁꠀ ꠅꠇꠟꠦ ꠔꠣꠘꠦ ꠖꠦꠈꠤꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠤꠀ ꠛꠃꠔꠔꠣ ꠇꠁꠟꠣ। ꠀꠞ ꠍꠣꠞꠣꠞꠦ ꠞꠣꠎꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠘꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN12_16","002_12_16","GEN","12","16","16","ꠍꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠚꠦꠞꠣꠃꠘꠦ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠔꠣ ꠟꠣꠉꠟꠣ। ꠔꠣꠁꠘ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠛꠃꠔ ꠉꠞꠥ-ꠍꠣꠉꠟ, ꠉꠣꠗꠣ-ꠉꠣꠗꠤ, ꠃꠐ, ꠀꠞ ꠛꠣꠘ꠆ꠖꠤ-ꠉꠥꠟꠣꠝ ꠃꠙꠢꠣꠞ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN12_17","002_12_17","GEN","12","17","17","ꠅꠁꠟꠦ ꠛꠤꠛꠤ ꠍꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠛꠣꠠꠤꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠛꠦꠡꠦꠛꠣ ꠛꠦꠝꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN12_18","002_12_18","GEN","12","18","18","ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠘꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠟꠣ? ꠔꠣꠘꠞꠦ ꠇꠦꠘꠦ ꠀꠙꠘꠣꠞ ꠛꠃ ꠘꠣ ꠇꠁꠀ ");
INSERT INTO syls_vpl VALUES ("GN12_19","002_12_19","GEN","12","19","19","ꠛꠁꠘ ꠇꠁꠟꠣ? ꠀꠞ ꠀꠝꠤ ꠔ ꠔꠣꠘꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠦꠅꠀꠁꠍꠟꠣꠝ। ꠄꠁꠘ ꠔ ꠀꠙꠘꠣꠞ ꠛꠤꠛꠤ, ꠄꠘꠦ ꠟꠁꠀ ꠀꠙꠘꠦ ꠁꠘ ꠕꠣꠇꠤ ꠢꠞꠤ ꠎꠣꠃꠇ꠆ꠇꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN12_20","002_12_20","GEN","12","20","20","ꠅꠃ ꠇꠕꠣ ꠇꠁꠀ ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠟꠣ, ꠀꠞ ꠔꠣꠞꠣ ꠀꠛ꠆ꠞꠣꠝꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠡꠢ ꠔꠣꠘꠦ ꠀꠞ ꠔꠣꠘ ꠛꠤꠛꠤꠞꠦ ꠛꠤꠖꠣꠄ ꠇꠞꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN13_1","002_13_1","GEN","13","1","1","ꠔꠦꠃ ꠀꠛ꠆ꠞꠣꠝ ꠀꠞ ꠔꠣꠘ ꠛꠤꠛꠤꠄ ꠢꠇꠟꠔꠣ ꠟꠁꠀ ꠝꠤꠡꠞ ꠖꠦꠡ ꠚꠣꠟꠣꠁꠀ ꠘꠦꠉꠦꠜ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠦꠟꠣꠉꠤ, ꠟꠥꠔꠅ ꠔꠣꠘ ꠟꠉꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN13_2","002_13_2","GEN","13","2","2","ꠀꠛ꠆ꠞꠣꠝ ꠈꠥꠛ ꠗꠘꠤ ꠀꠍꠟꠣ, ꠔꠣꠘ ꠛꠃꠔ ꠢꠦꠝꠣꠘ-ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN13_3","002_13_3","GEN","13","3","3","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠘꠦꠉꠦꠜ ꠕꠣꠇꠤ ꠢꠞꠔꠦ ꠢꠞꠔꠦ ꠛꠦꠕꠦꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠔꠣꠁꠘ ꠛꠦꠕꠦꠟ ꠀꠞ ꠅꠄ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠙꠃꠍꠟꠣ, ꠎꠦ ꠎꠣꠉꠣꠔ ꠔꠣꠁꠘ ꠀꠉꠦ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠍꠟꠣ ");
INSERT INTO syls_vpl VALUES ("GN13_4","002_13_4","GEN","13","4","4","ꠀꠞ ꠙꠄꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠍꠟꠣ। ꠅꠘꠅ ꠉꠤꠀ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN13_5","002_13_5","GEN","13","5","5","ꠀꠛ꠆ꠞꠣꠝꠞ ꠟꠉꠦ ꠝꠥꠍꠣꠚꠤꠞ ꠀꠍꠟꠣ ꠔꠣꠘ ꠜꠣꠔꠤꠎꠣ ꠟꠥꠔ, ꠄꠘꠅ ꠛꠃꠔ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠀꠞ ꠔꠣꠝ꠆ꠛꠥ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN13_6","002_13_6","GEN","13","6","6","ꠅꠁꠟꠦ ꠎꠣꠉꠣꠐꠣ ꠁꠟꠣ ꠀꠍꠤꠟ ꠘꠣ ꠎꠦꠘ, ꠖꠥꠁꠅꠎꠘꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠦ ꠄꠇꠟꠉꠦ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ꠉꠞꠥ-ꠍꠣꠉꠟ ꠀꠞ ꠔꠣꠝ꠆ꠛꠥ ꠅꠔ ꠛꠦꠡꠤ ꠀꠍꠤꠟ ꠎꠦꠘ, ꠁꠔꠣ ꠟꠁꠀ ꠔꠣꠞꠣꠞ ꠕꠣꠇꠣꠞ ꠃꠙꠣꠄ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN13_7","002_13_7","GEN","13","7","7","ꠄꠞꠟꠣꠉꠤ ꠀꠛ꠆ꠞꠣꠝ ꠀꠞ ꠟꠥꠔꠞ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠢꠣꠝꠦꠡꠣ ꠖꠞꠛꠣꠞ-ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠔꠣ। ꠀꠞ ꠢꠤ ꠡꠝꠄ ꠇꠦꠘꠣꠘꠤ ꠀꠞ ꠚꠣꠞꠤꠎꠤ ꠅꠇꠟꠅ ꠢꠤ ꠖꠦꠡꠅ ꠛꠡꠔ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("GN13_8","002_13_8","GEN","13","8","8","ꠔꠦꠃ ꠀꠛ꠆ꠞꠣꠝꠦ ꠟꠥꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠔ ꠖꠥꠁꠅꠎꠘꠃ ꠀꠙꠘ। ꠔꠦ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠀꠞ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠞꠣꠈꠣꠟꠞ ꠝꠣꠎꠦꠅ ꠖꠞꠛꠣꠞ-ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠣ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN13_9","002_13_9","GEN","13","9","9","ꠢꠣꠞꠣ ꠖꠦꠡꠐꠣꠃ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠙꠠꠤ ꠞꠁꠍꠦ। ꠔꠦ ꠀꠅ, ꠀꠝꠞꠣ ꠀꠟꠉꠣ ꠅꠁꠎꠣꠁ। ꠔꠥꠝꠤ ꠛꠣꠃꠄ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠦ, ꠀꠝꠤ ꠒꠣꠁꠘꠦ, ꠀꠞ ꠔꠥꠝꠤ ꠒꠣꠁꠘꠦ ꠉꠦꠟꠦ, ꠀꠝꠤ ꠛꠣꠃꠄ ꠎꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN13_10","002_13_10","GEN","13","10","10","ꠟꠥꠔꠦ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠕꠟ ꠎꠣꠉꠣꠞ ꠢꠇꠟꠛꠣꠄ ꠍꠥꠀꠞ ꠉꠣꠃ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠃꠔ ꠙꠣꠘꠤ ꠀꠍꠦ, ꠝꠣꠛꠥꠖꠞ ꠛꠣꠉꠤꠌꠣ ꠛꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠟꠣꠈꠣꠘ ꠁ ꠎꠣꠉꠣꠅ ꠊꠣꠡ-ꠙꠣꠘꠤ ꠀꠟꠣ। ꠅꠃ ꠡꠝꠄꠅ ꠝꠣꠛꠥꠖꠦ ꠍꠣꠖꠥꠝ ꠀꠞ ꠀꠝꠥꠞꠣ ꠐꠣꠃꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN13_11","002_13_11","GEN","13","11","11","ꠄꠞꠟꠣꠉꠤ ꠟꠥꠔꠦ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠇꠟ ꠕꠟ ꠎꠣꠉꠣ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠛꠣꠍꠤꠀ ꠙꠥꠛꠦꠖꠤ ꠢꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ। ꠅꠃꠟꠣ ꠔꠣꠞꠣ ꠀꠟꠉꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN13_12","002_13_12","GEN","13","12","12","ꠀꠛ꠆ꠞꠣꠝ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠞꠁꠟꠣ, ꠀꠞ ꠟꠥꠔ ꠢꠃ ꠕꠟ ꠎꠝꠤꠘꠞ ꠐꠣꠃꠘ ꠅꠇꠟꠞ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠛꠡꠔ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘꠞ ꠇꠤꠘꠣꠞꠅ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN13_13","002_13_13","GEN","13","13","13","ꠍꠣꠖꠥꠝꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠈꠥꠛ ꠈꠛꠤꠍ ꠀꠍꠤꠟ, ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞꠅ ꠔꠣꠞꠣ ꠛꠦꠕꠣꠄꠀ ꠉꠥꠘꠣꠉꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("GN13_14","002_13_14","GEN","13","14","14","ꠟꠥꠔ ꠀꠟꠉꠣ ꠅꠀꠞ ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠦ ꠎꠣꠉꠣꠔ ꠃꠛꠣꠁꠍ, ꠁꠈꠣꠘ ꠕꠣꠇꠤ ꠃꠔꠞꠦ-ꠖꠃꠇꠘꠦ, ꠙꠥꠛꠦ-ꠙꠁꠌꠝꠦ ꠄꠇꠛꠣꠞ ꠌꠣꠁꠀ ꠖꠦꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("GN13_15","002_13_15","GEN","13","15","15","ꠎꠦ ꠎꠣꠉꠣ ꠅꠇꠟ ꠔꠥꠝꠤ ꠖꠦꠈꠞꠣꠄ, ꠁꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN13_16","002_13_16","GEN","13","16","16","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞꠦ ꠖꠥꠘꠤꠀꠁꠞ ꠗꠥꠁꠟ-ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠤꠡꠣꠛ ꠇꠞꠝꠥ। ꠖꠥꠘꠤꠀꠞ ꠗꠥꠁꠟ-ꠛꠣꠟꠥ ꠎꠥꠖꠤ ꠇꠦꠃ ꠉꠘꠤꠀ ꠚꠥꠠꠣꠁꠔ ꠙꠣꠞꠦ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞꠦꠅ ꠉꠘꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("GN13_17","002_13_17","GEN","13","17","17","ꠃꠑꠅ, ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠐꠣ ꠔꠥꠝꠤ ꠄꠇꠛꠣꠞ ꠊꠥꠞꠤꠀ ꠀꠅ, ꠅꠃ ꠖꠦꠡꠃ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN13_18","002_13_18","GEN","13","18","18","ꠔꠦꠃ ꠀꠛ꠆ꠞꠣꠝꠦ ꠔꠣꠘ ꠔꠣꠝ꠆ꠛꠥ ꠔꠥꠟꠤꠀ, ꠢꠦꠛꠞꠘ ꠄꠟꠣꠇꠣꠔ ꠝꠝ꠆ꠞꠤꠞ ꠄꠟꠘ ꠛꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠘꠤꠀ ꠉꠣꠠꠤꠟꠣ। ꠢꠈꠣꠘꠅ ꠔꠣꠁꠘ ꠝꠣꠛꠥꠖꠞ ꠟꠣꠉꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_1","002_14_1","GEN","14","1","1","ꠛꠣꠛꠤꠟ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣ ꠅꠝ꠆ꠞꠣꠚꠦꠟ, ꠁꠟ꠆ꠟꠣꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠀꠞꠤꠀꠇ, ꠁꠟꠣꠝꠞ ꠛꠣꠖꠡꠣ ꠇꠖꠞ-ꠟꠣꠃꠝꠞ ꠀꠞ ꠉꠥꠁꠝꠞ ꠛꠣꠖꠡꠣ ꠔꠤꠖꠤꠅꠟ, ꠄꠞꠣ ꠌꠣꠁꠞꠅꠎꠘꠦ ꠄꠇ ꠅꠁꠀ ");
INSERT INTO syls_vpl VALUES ("GN14_2","002_14_2","GEN","14","2","2","ꠍꠣꠖꠥꠝꠞ ꠛꠣꠖꠡꠣ ꠛꠤꠞꠣ, ꠀꠝꠥꠞꠣꠞ ꠛꠣꠖꠡꠣ ꠛꠤꠞꠡꠣ, ꠅꠖꠝꠣꠞ ꠛꠣꠖꠡꠣ ꠡꠤꠘꠣꠛ, ꠍꠛꠂꠁꠝꠞ ꠛꠣꠖꠡꠣ ꠡꠤꠝꠦꠛꠞ ꠀꠞ ꠛꠤꠟꠣꠞ ꠛꠣ ꠍꠥꠀꠞꠞ ꠛꠣꠖꠡꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_3","002_14_3","GEN","14","3","3","ꠅꠃ ꠙꠣꠌꠎꠘ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠞꠣꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠤꠀ ꠍꠤꠖ꠆ꠖꠤꠝꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠁ ꠎꠣꠉꠣꠞꠦ ꠟꠥꠘꠣ ꠡꠣꠉꠞ ꠇꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN14_4","002_14_4","GEN","14","4","4","ꠢꠤ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠦ ꠛꠣꠞꠅ ꠛꠞꠍ ꠛꠣꠖꠡꠣ ꠇꠖꠞ-ꠟꠣꠃꠝꠞꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠤꠀ ꠔꠦꠞꠅ ꠛꠍꠞꠞ ꠡꠝꠄ ꠛꠤꠖ꠆ꠞꠥꠢ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_5","002_14_5","GEN","14","5","5","ꠄꠞ ꠛꠣꠖꠞ ꠛꠞꠍ ꠛꠣꠖꠡꠣ ꠇꠖꠞ-ꠟꠣꠃꠝꠞ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠦ ꠉꠤꠀ ꠅꠡ꠆ꠔꠞꠥꠕ-ꠇꠞ꠆ꠘꠄꠁꠝꠅ ꠞꠚꠣꠄꠁ ꠅꠇꠟꠞꠦ, ꠢꠝꠅ ꠉꠤꠀ ꠎꠥꠎꠤ ꠅꠇꠟꠞꠦ, ꠀꠞ ꠡꠣꠛꠤ-ꠇꠤꠞꠤꠀꠔꠣꠁꠝꠅ ꠉꠤꠀ ꠄꠁꠝꠤ ꠅꠇꠟꠞꠦ ꠀꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_6","002_14_6","GEN","14","6","6","ꠛꠣꠖꠦ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠣꠍꠣꠞ ꠄꠟ-ꠚꠣꠞꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠍꠦꠁꠞ ꠙꠣꠠꠞ ꠢꠥꠞꠤꠅ ꠅꠇꠟꠞꠦꠅ ꠀꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_7","002_14_7","GEN","14","7","7","ꠢꠦꠡꠦ ꠅꠃ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠦ ꠊꠥꠞꠤꠀ ꠉꠤꠀ ꠅꠂꠘ-ꠝꠤꠡꠙꠐꠅ ꠛꠣ ꠇꠣꠖꠦꠡ ꠉꠦꠟꠣ। ꠔꠣꠞꠣ ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠟꠣ ꠀꠞ ꠢꠣꠎꠣꠎꠘ-ꠔꠣꠝꠣꠞ ꠐꠣꠃꠘꠅ ꠎꠦ ꠀꠝꠥꠞꠤ ꠅꠇꠟ ꠀꠍꠤꠟ ꠔꠣꠞꠣꠞꠦꠅ ꠖꠈꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_8","002_14_8","GEN","14","8","8","ꠛꠣꠖꠦ ꠍꠣꠖꠥꠝ, ꠀꠝꠥꠞꠣ, ꠅꠖꠝꠣ, ꠍꠛꠂꠁꠝ ꠀꠞ ꠛꠤꠟꠣ ꠛꠣ ꠍꠥꠀꠞꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠦ ");
INSERT INTO syls_vpl VALUES ("GN14_9","002_14_9","GEN","14","9","9","ꠁꠟꠣꠝꠞ ꠛꠣꠖꠡꠣ ꠇꠖꠞ-ꠟꠣꠃꠝꠞ, ꠉꠥꠁꠝꠞ ꠛꠣꠖꠡꠣ ꠔꠤꠖꠤꠅꠟ, ꠛꠣꠛꠤꠟꠞ ꠛꠣꠖꠡꠣ ꠅꠝ꠆ꠞꠣꠚꠦꠟ ꠀꠞ ꠁꠟ꠆ꠟꠣꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠀꠞꠤꠀꠇꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠤꠖ꠆ꠖꠤꠝ ꠘꠣꠝꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠔꠣꠞꠣꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟ ꠢꠣꠎꠣꠁꠟꠣ। ꠌꠣꠁꠞ ꠛꠣꠖꠡꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠙꠣꠌ ꠛꠣꠖꠡꠣꠄ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_10","002_14_10","GEN","14","10","10","ꠍꠤꠖ꠆ꠖꠤꠝꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠔꠣꠞꠔꠦꠟꠞ ꠛꠃꠔ ꠉꠣꠔ-ꠉꠣꠠꠣ ꠀꠍꠤꠟ। ꠍꠣꠖꠥꠝ ꠀꠞ ꠀꠝꠥꠞꠣꠞ ꠛꠣꠖꠡꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠜꠣꠉꠤꠀ ꠎꠣꠁꠞꠣ, ꠁ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠟꠉꠞ ꠇꠦꠃ ꠇꠦꠃ ꠅꠃ ꠔꠣꠞꠔꠦꠟꠞ ꠉꠣꠔꠅ ꠙꠠꠤ ꠉꠦꠟꠣ, ꠀꠞ ꠛꠣꠇꠤ ꠅꠇꠟꠦ ꠜꠣꠉꠤꠀ ꠙꠣꠠꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_11","002_14_11","GEN","14","11","11","ꠔꠦꠃ ꠔꠣꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠦ ꠍꠣꠖꠥꠝ-ꠀꠝꠥꠞꠣꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠀꠞ ꠈꠣꠘꠤ-ꠖꠣꠘꠤꠞ ꠢꠇꠟꠔꠣ ꠟꠥꠐꠤꠀ ꠟꠁꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN14_12","002_14_12","GEN","14","12","12","ꠀꠞ ꠔꠣꠞꠣ ꠀꠛ꠆ꠞꠣꠝꠞ ꠜꠣꠔꠤꠎꠣ ꠟꠥꠔꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠡꠥꠖ꠆ꠖꠣ ꠢꠃ ꠟꠥꠔꠞꠦꠃ ꠗꠞꠤꠀ ꠟꠁꠀ ꠉꠦꠟꠣꠉꠤ, ꠇꠣꠞꠘ ꠄꠁꠘꠦꠃ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘꠅ ꠞꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_13","002_14_13","GEN","14","13","13","ꠔꠦꠃ ꠄꠇꠎꠘꠦ ꠜꠣꠉꠤꠀ ꠀꠁꠀ ꠁꠛꠞꠣꠘꠤ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠅꠃ ꠈꠛꠞ ꠖꠤꠟ। ꠀꠛ꠆ꠞꠣꠝ ꠁ ꠡꠝꠄ ꠀꠝꠥꠞꠤ ꠝꠝ꠆ꠞꠤꠞ ꠄꠟꠘ ꠛꠘꠞ ꠇꠣꠍꠣꠔ ꠕꠣꠇꠔꠣ। ꠁ ꠝꠝ꠆ꠞꠤ ꠀꠍꠟꠣ ꠀꠡꠇꠥꠟ ꠀꠞ ꠀꠘꠦꠞꠞ ꠜꠣꠁ, ꠀꠛ꠆ꠞꠣꠝꠞ ꠟꠉꠦ ꠄꠞꠣꠞ ꠎꠥꠖ꠆ꠖꠞ ꠡꠣꠁꠎ꠆ꠎꠞ ꠌꠥꠇ꠆ꠔꠤ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN14_14","002_14_14","GEN","14","14","14","ꠔꠣꠘ ꠜꠣꠔꠤꠎꠣꠞꠦ ꠗꠞꠤꠀ ꠟꠁꠀ ꠉꠦꠍꠂꠘꠉꠤ ꠢꠥꠘꠤꠀ ꠀꠛ꠆ꠞꠣꠝꠦ ꠟꠣꠠꠣꠁ ꠎꠣꠘꠞꠣ ꠘꠤꠎꠞ ꠔꠤꠘ-ꠡ ꠀꠑꠣꠞ ꠎꠘ ꠉꠥꠟꠣꠝꠞꠦ ꠟꠁꠀ ꠖꠣꠘ ꠐꠣꠃꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠥꠡꠝꠘꠞ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟꠣ। ꠅꠃ ꠉꠥꠟꠣꠝ ꠅꠇꠟ ꠔꠣꠘ ꠛꠣꠠꠤꠔꠃ ꠎꠘꠝꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN14_15","002_14_15","GEN","14","15","15","ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠖꠥꠡꠝꠘ ꠖꠟꠞ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠀ ꠄꠞꠣ ꠢꠣꠝꠟꠣ ꠇꠞꠤꠀ ꠢꠦꠞꠣꠞꠦ ꠀꠞꠣꠁꠟ꠆ꠟꠣ, ꠀꠞ ꠈꠦꠖꠣꠁꠔꠦ ꠈꠦꠖꠣꠁꠔꠦ ꠖꠣꠝꠦꠡ꠆ꠇ ꠐꠣꠃꠘꠞ ꠃꠔꠞꠦ ꠢꠥꠛꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_16","002_14_16","GEN","14","16","16","ꠟꠥꠐ ꠇꠞꠣ ꠢꠇ꠆ꠇꠟ ꠎꠤꠘꠤꠡ ꠔꠣꠁꠘ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠟꠣ, ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠡꠥꠖ꠆ꠖꠣ ꠔꠣꠘ ꠜꠣꠔꠤꠎꠣ ꠟꠥꠔꠞꠦꠅ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠟꠣ। ꠄꠞ ꠟꠉꠦ ꠢꠇꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦꠅ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_17","002_14_17","GEN","14","17","17","ꠇꠖꠞ-ꠟꠣꠃꠝꠞ ꠀꠞ ꠔꠣꠞ ꠟꠉꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠞꠦ ꠀꠞꠣꠁꠀ ꠀꠛ꠆ꠞꠣꠝ ꠚꠤꠞꠤꠀ ꠀꠅꠀꠞ ꠡꠝꠄ ꠍꠣꠖꠥꠝꠞ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠘ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠛꠤ ꠛꠣ ꠛꠣꠖꠡꠣ ꠘꠣꠝꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_18","002_14_18","GEN","14","18","18","ꠀꠞ ꠡꠣꠟꠦꠝꠞ ꠛꠣꠖꠡꠣ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠦ ꠀꠛ꠆ꠞꠣꠝꠞ ꠟꠣꠉꠤ ꠞꠥꠐꠤ ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠟꠁꠀ ꠀꠁꠟꠣ, ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠙꠍꠘ꠆ꠖꠞ ꠁꠝꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN14_19","002_14_19","GEN","14","19","19","ꠔꠣꠁꠘ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠖꠥꠀ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘ ꠀꠞ ꠎꠝꠤꠘ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠛꠞꠇꠔ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_20","002_14_20","GEN","14","20","20","ꠀꠙꠘꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠎꠦꠁꠘ ꠀꠙꠘꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠍꠂꠘ, ꠔꠣꠘ ꠘꠣꠝ ꠗꠁꠘ꠆ꠘ ꠅꠃꠇ।” ꠅꠃ ꠀꠛ꠆ꠞꠣꠝꠦ ꠔꠣꠘ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠖꠡꠛꠣꠐꠞ ꠄꠇꠛꠣꠐ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞꠦ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN14_21","002_14_21","GEN","14","21","21","ꠀꠞ ꠍꠣꠖꠥꠝꠞ ꠛꠣꠖꠡꠣꠄ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠢꠇꠟꠔꠣ ꠞꠣꠈꠤ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠈꠣꠟꠤ ꠝꠣꠘꠥꠡ ꠉꠥꠁꠘ ꠀꠝꠣꠞꠦ ꠚꠤꠞꠔ ꠖꠤꠟꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN14_22","002_14_22","GEN","14","22","22","ꠀꠛ꠆ꠞꠣꠝꠦ ꠍꠣꠖꠥꠝꠞ ꠛꠣꠖꠡꠣꠞꠦ ꠇꠁꠟꠣ, “ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ ꠢꠃ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠀꠔ ꠔꠥꠟꠤꠀ ꠇꠍꠝ ꠇꠞꠍꠤ, ");
INSERT INTO syls_vpl VALUES ("GN14_23","002_14_23","GEN","14","23","23","ꠀꠙꠘꠣꠞ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠃ, ꠄꠇꠍꠣ ꠡꠥꠔꠣꠃ ꠛꠣ ꠙꠣꠅꠞ ꠎꠥꠔꠣꠞ ꠄꠇꠍꠣ ꠚꠤꠔꠣꠅ ꠀꠝꠤ ꠘꠤꠔꠣꠝ ꠘꠣꠄ। ꠀꠞꠘꠣꠄ ꠛꠣꠖꠦ ꠀꠙꠘꠦ ꠇꠁꠛꠣ, ꠀꠝꠣꠞ ꠗꠘꠦꠃ ꠀꠛ꠆ꠞꠣꠝ ꠗꠘꠤ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN14_24","002_14_24","GEN","14","24","24","ꠀꠝꠣꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠈꠣꠁꠟꠤꠍꠂꠘ ꠁꠔꠣ ꠍꠣꠠꠣ ꠀꠝꠤ ꠀꠞ ꠇꠤꠌ꠆ꠍꠥ ꠘꠤꠔꠣꠝ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠀꠘꠦꠞ, ꠀꠡꠇꠥꠟ ꠀꠞ ꠝꠝ꠆ꠞꠤ ꠎꠦꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠉꠦꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠛꠣꠐ ꠔꠣꠞꠣ ꠘꠦꠃꠇ꠆ꠇꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN15_1","002_15_1","GEN","15","1","1","ꠅꠔꠣ ꠊꠐꠘꠣ ꠅꠇꠟꠞ ꠛꠣꠖꠦ ꠅꠢꠤꠞ ꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠣꠟꠣꠝ ꠀꠛ꠆ꠞꠣꠝꠞ ꠉꠦꠍꠦ ꠘꠣꠎꠤꠟ ꠅꠁꠟ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅ ꠀꠛ꠆ꠞꠣꠝ, ꠒꠞꠣꠁꠅ ꠘꠣ, ꠀꠝꠤꠃ ꠔꠥꠝꠣꠞ ꠢꠦꠚꠣꠎꠔꠇꠣꠞꠤ, ꠔꠥꠝꠣꠞ ꠛꠃꠔ ꠛꠠ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN15_2","002_15_2","GEN","15","2","2","ꠀꠛ꠆ꠞꠣꠝꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣ, ꠀꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠖꠤꠔꠣꠄ? ꠀꠝꠤ ꠔ ꠘꠤꠀꠅꠟꠣꠖꠤ। ꠀꠝꠤ ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠖꠣꠝꠦꠡ꠆ꠇꠞ ꠄꠟꠤꠄꠎꠦꠞ ꠀꠝꠣꠞ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN15_3","002_15_3","GEN","15","3","3","ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞꠦ ꠇꠥꠘꠥ ꠀꠅꠟꠣꠖ ꠖꠤꠟꠣꠄ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠣꠠꠤꠞ ꠉꠥꠟꠣꠝ ꠀꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN15_4","002_15_4","GEN","15","4","4","ꠅꠃ ꠝꠣꠛꠥꠖꠦ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠢꠦ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠃꠞ ꠀꠅꠟꠣꠖꠃ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN15_5","002_15_5","GEN","15","5","5","ꠝꠣꠛꠥꠖꠦ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠛꠣꠞꠦ ꠀꠘꠤꠀ ꠇꠁꠟꠣ, “ꠀꠍꠝꠣꠘꠞ ꠛꠣꠄ ꠌꠣꠅ, ꠀꠞ ꠙꠣꠞꠟꠦ ꠅꠃ ꠔꠦꠞꠣ ꠅꠇꠟ ꠉꠘꠤꠀ ꠚꠥꠠꠣꠅ, ꠔꠥꠝꠣꠞ ꠛꠋꠡꠞ ꠅꠀꠞꠤꠡ ꠅꠃꠟꠣ ꠛꠦꠢꠤꠡꠣꠛ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN15_6","002_15_6","GEN","15","6","6","ꠀꠛ꠆ꠞꠣꠝꠦ ꠝꠣꠛꠥꠖꠞ ꠅꠃ ꠅꠀꠖꠣꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠟꠣ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠄꠇꠤꠘꠞꠦ ꠖꠤꠘꠖꠣꠞꠤ ꠇꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN15_7","002_15_7","GEN","15","7","7","ꠀꠞ ꠔꠣꠁꠘ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ। ꠁ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠅꠗꠤꠇꠣꠞꠤ ꠅꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠣꠛꠤꠟ ꠖꠦꠡꠞ ꠃꠞ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN15_8","002_15_8","GEN","15","8","8","ꠅꠃ ꠀꠛ꠆ꠞꠣꠝꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣ, ꠀꠝꠤ ꠁꠔꠣꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠝꠥ ꠇꠞꠤ ꠇꠤꠟꠣ ꠛꠥꠎꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("GN15_9","002_15_9","GEN","15","9","9","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔꠤꠘ ꠛꠍꠞꠞ ꠄꠇꠐꠣ ꠇꠞꠤ ꠒꠦꠇꠤ, ꠍꠣꠉꠤ, ꠀꠞ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠟꠁꠀ ꠀꠅ, ꠄꠞ ꠟꠉꠦ ꠄꠇꠐꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠀꠞ ꠄꠇꠐꠣ ꠙꠣꠞꠅꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠅ ꠀꠘꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN15_10","002_15_10","GEN","15","10","10","ꠀꠛ꠆ꠞꠣꠝꠦ ꠅꠃꠟꠣ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠁꠔꠣ ꠢꠇꠟꠐꠤ ꠀꠘꠤꠀ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠇꠞꠤꠀ ꠃꠟꠐꠣ-ꠃꠟꠐꠤ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠀ ꠞꠣꠈꠟꠣ, ꠈꠣꠟꠤ ꠙꠣꠈꠤ ꠅꠇꠟꠞꠦ ꠐꠥꠇꠞꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN15_11","002_15_11","GEN","15","11","11","ꠔꠦꠃ ꠢꠇꠥꠘ ꠀꠁꠀ ꠅꠃ ꠐꠥꠇꠞꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠙꠠꠟꠦ, ꠀꠛ꠆ꠞꠣꠝꠦ ꠈꠦꠖꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN15_12","002_15_12","GEN","15","12","12","ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣꠞ ꠡꠝꠄ ꠀꠛ꠆ꠞꠣꠝꠞ ꠄꠇ ꠛꠦꠃꠡꠤ ꠊꠥꠝ ꠀꠁꠟ। ꠊꠥꠝꠞ ꠝꠣꠎꠦ ꠛꠦꠕꠣꠄꠀ ꠒꠞ ꠀꠞ ꠀꠘ꠆ꠖꠣꠁꠞꠦ ꠔꠣꠘꠦ ꠀꠍꠞ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("GN15_13","002_15_13","GEN","15","13","13","ꠅꠃ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠘꠤꠌ꠆ꠌꠄ ꠅꠁꠀ ꠎꠣꠘꠤꠅ, ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠦ ꠅꠃꠟꠣ ꠖꠦꠡꠅ ꠉꠤꠀ ꠞꠁꠛꠣ ꠎꠦꠇꠐꠣ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠘꠣꠄ। ꠢꠘꠅ ꠔꠣꠞꠣ ꠈꠥꠛ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦ ꠞꠁꠀ ꠌꠣꠁꠞ-ꠡ ꠛꠞꠍ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN15_14","002_15_14","GEN","15","14","14","ꠀꠞ ꠎꠦ ꠎꠣꠔꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠁꠛꠣ, ꠀꠝꠤ ꠢꠤ ꠎꠣꠔꠤꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠝꠥ। ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠛꠃꠔ ꠗꠘ-ꠖꠃꠟꠔ ꠟꠁꠀ ꠢꠘ ꠕꠘꠦ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN15_15","002_15_15","GEN","15","15","15","ꠀꠞ ꠔꠥꠝꠤ ꠡꠣꠘ꠆ꠔꠤꠄ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛꠣꠄ। ꠔꠥꠝꠤ ꠙꠥꠞꠣ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠄꠅꠡꠅ ꠇꠄꠛꠞꠅ ꠢꠣꠝꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN15_16","002_15_16","GEN","15","16","16","ꠔꠥꠝꠣꠞ ꠌꠣꠁꠞ ꠍꠤꠠꠤ ꠛꠣꠖꠦ ꠄꠞꠣ ꠅꠘꠅ ꠚꠤꠞꠤꠀ ꠀꠁꠛꠣ, ꠇꠣꠞꠘ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠉꠥꠘꠣ ꠅꠈꠘꠅ ꠙꠥꠞꠣ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN15_17","002_15_17","GEN","15","17","17","ꠡꠥꠞꠥꠎ ꠒꠥꠛꠤꠀ ꠎꠦꠛꠟꠣ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠟ ꠅꠃ ꠡꠝꠄ ꠗꠥꠝꠣꠄ ꠜꠞꠣ ꠄꠇ ꠃꠘ꠆ꠖꠣꠟ ꠀꠞ ꠀꠉꠥꠘꠤꠞ ꠝꠥꠡꠣꠟ ꠢꠃ ꠢꠣꠎꠣꠁꠀ ꠞꠣꠈꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠐꠥꠇꠞꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠦꠖꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN15_18","002_15_18","GEN","15","18","18","ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠖꠤꠘꠃ ꠀꠛ꠆ꠞꠣꠝꠞ ꠟꠉꠦ ꠅꠃꠟꠣ ꠅꠀꠖꠣ ꠇꠞꠟꠣ, “ꠝꠤꠡꠞꠞ ꠉꠣꠋ ꠕꠘꠦ ꠛꠠ ꠉꠣꠋ ꠚꠥꠞꠣꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞꠦ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN15_19","002_15_19","GEN","15","19","19","ꠁꠇꠐꠣ ꠅꠁꠟ ꠇꠦꠘꠤ, ꠇꠘꠤꠎꠤ, ꠇꠖꠝꠥꠘꠤ, ");
INSERT INTO syls_vpl VALUES ("GN15_20","002_15_20","GEN","15","20","20","ꠢꠤꠐ꠆ꠐꠤ, ꠚꠣꠞꠤꠎꠤ, ꠞꠚꠣꠄꠁ, ");
INSERT INTO syls_vpl VALUES ("GN15_21","002_15_21","GEN","15","21","21","ꠀꠝꠥꠞꠤ, ꠇꠦꠘꠣꠘꠤ, ꠉꠤꠞ꠆ꠉꠣꠡꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠅꠇꠟꠞ ꠖꠦꠡ।” ");
INSERT INTO syls_vpl VALUES ("GN16_1","002_16_1","GEN","16","1","1","ꠛꠤꠛꠤ ꠍꠣꠞꠣꠞ ꠙꠦꠐꠅ ꠀꠛ꠆ꠞꠣꠝꠞ ꠇꠥꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠍꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠢꠣꠎꠦꠞꠣ ꠘꠣꠝꠦ ꠍꠣꠞꠣꠞ ꠄꠇ ꠝꠤꠡꠞꠤ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN16_2","002_16_2","GEN","16","2","2","ꠄꠇꠖꠤꠘ ꠍꠣꠞꠣꠄ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠇꠞꠍꠂꠘ। ꠔꠦ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠘ꠆ꠖꠤꠞ ꠇꠣꠍꠣꠔ ꠎꠣꠅ, ꠇꠤꠛꠣ ꠔꠣꠁꠞꠦ ꠖꠤꠀ ꠀꠝꠤ ꠀꠅꠟꠣꠖ ꠙꠣꠁꠟꠤꠔꠣꠝ ꠙꠣꠞꠤ।” ꠅꠃ ꠀꠛ꠆ꠞꠣꠝꠅ ꠍꠣꠞꠣꠞ ꠝꠣꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN16_3","002_16_3","GEN","16","3","3","ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠀꠛ꠆ꠞꠣꠝ ꠖꠡ ꠛꠞꠍ ꠞꠅꠀꠞ ꠛꠣꠖꠦ ꠍꠣꠞꠣꠄ ꠔꠣꠘ ꠝꠤꠡꠞꠤ ꠛꠣꠘ꠆ꠖꠤ ꠢꠣꠎꠦꠞꠣꠞꠦ ꠘꠤꠎꠞ ꠎꠣꠝꠣꠁ ꠀꠛ꠆ꠞꠣꠝꠞ ꠟꠉꠦ ꠛꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN16_4","002_16_4","GEN","16","4","4","ꠛꠣꠖꠦ ꠀꠛ꠆ꠞꠣꠝ ꠀꠞ ꠢꠣꠎꠦꠞꠣ ꠄꠇꠈꠣꠘꠅ ꠞꠁꠟꠦ ꠔꠣꠁꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ। ꠢꠣꠎꠦꠞꠣꠄ ꠎꠦꠛꠟꠣ ꠛꠥꠎꠟ ꠔꠣꠁꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠔꠣ ꠔꠦꠃ ꠔꠣꠁꠞ ꠝꠣꠟꠤꠇ ꠛꠤꠛꠤꠞ ꠛꠣꠄ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠘꠤꠔ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("GN16_5","002_16_5","GEN","16","5","5","ꠅꠃ ꠍꠣꠞꠣꠄ ꠀꠛ꠆ꠞꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠣꠄ ꠔꠣꠁꠞ ꠛꠦꠀꠖꠛꠤꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤꠃ ꠖꠣꠄꠁ। ꠀꠝꠣꠞ ꠁ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠀꠝꠤꠃ ꠔꠥꠝꠣꠞ ꠛꠤꠍꠘꠣꠔ ꠔꠥꠟꠤꠀ ꠖꠤꠍꠟꠣꠝ, ꠀꠞ ꠅꠈꠘ ꠔꠣꠁꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠔꠣ ꠇꠞꠤ ꠀꠝꠣꠞꠦ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠞ। ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN16_6","002_16_6","GEN","16","6","6","ꠀꠛ꠆ꠞꠣꠝꠦ ꠍꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠅ, ꠔꠥꠝꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠔ ꠔꠥꠝꠣꠞ ꠀꠔꠅꠃ ꠀꠍꠦ। ꠔꠥꠝꠣꠞ ꠎꠦꠟꠣ ꠜꠣꠟꠣ ꠝꠘꠦ ꠇꠄ ꠅꠟꠣꠃ ꠇꠞꠅ।” ꠅꠃ ꠍꠣꠞꠣꠄ ꠢꠣꠎꠦꠞꠣꠞꠦ ꠅꠃꠟꠣ ꠖꠥꠈ ꠖꠤꠟꠣ, ꠖꠥꠈꠦ ꠔꠣꠁ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN16_7","002_16_7","GEN","16","7","7","ꠙꠕꠅ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠄꠇꠐꠣ ꠙꠣꠘꠤꠞ ꠁꠘ꠆ꠖꠣꠞꠣꠞ ꠇꠣꠍꠣꠔ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠢꠣꠎꠦꠞꠣꠞꠦ ꠙꠣꠁꠟꠣ। ꠁ ꠁꠘ꠆ꠖꠣꠞꠣ ꠀꠍꠤꠟ ꠡꠥꠞ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠎꠣꠅꠀꠞ ꠙꠕꠅ। ");
INSERT INTO syls_vpl VALUES ("GN16_8","002_16_8","GEN","16","8","8","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠍꠣꠞꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠢꠣꠎꠦꠞꠣ, ꠔꠥꠝꠤ ꠇꠁ ꠕꠣꠇꠤ ꠀꠁꠞꠣꠄ ꠀꠞ ꠇꠁ ꠎꠣꠁꠔꠣꠄ?” ꠢꠣꠎꠦꠞꠣꠄ ꠇꠁꠟ, “ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ ꠛꠤꠛꠤ ꠍꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠀ ꠎꠣꠁꠞꠣꠝꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN16_9","002_16_9","GEN","16","9","9","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠝꠣꠟꠤꠇ ꠛꠤꠛꠤꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠉꠤꠀ ꠇꠟ꠆ꠟꠣ ꠘꠥꠀꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠈꠦꠎꠝꠔꠅ ꠟꠣꠉꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN16_10","002_16_10","GEN","16","10","10","ꠔꠣꠁꠘ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠃꠟꠣ ꠛꠣꠠꠣꠁ ꠖꠤꠝꠥ, ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠀ ꠚꠥꠠꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN16_11","002_16_11","GEN","16","11","11","ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠍꠦ। ꠔꠥꠝꠣꠞ ꠄꠇ ꠙꠥꠀ ꠅꠁꠛ, ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠤꠅ ꠁꠍꠝꠣꠁꠟ ꠝꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠢꠥꠘꠂꠘ, ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞ ꠖꠥꠈ ꠢꠥꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN16_12","002_16_12","GEN","16","12","12","ꠀꠞ ꠛꠠ ꠅꠁꠟꠦ ꠢꠦ ꠟꠣꠉꠣꠝ ꠍꠣꠠꠣ ꠊꠥꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠛ। ꠢꠦ ꠢꠇ꠆ꠇꠟꠞ ꠛꠣꠄ ꠀꠔ ꠔꠥꠟꠛ, ꠀꠞ ꠢꠇ꠆ꠇꠟꠦ ꠔꠣꠞ ꠛꠣꠄ ꠀꠔ ꠔꠥꠟꠛꠣ। ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠢꠣꠝꠦꠡꠣ ꠔꠣꠞ ꠟꠣꠉ ꠕꠣꠇꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN16_13","002_16_13","GEN","16","13","13","ꠀꠞ ꠢꠣꠎꠦꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠣꠔꠤꠟꠣ ꠇꠞꠤ, ꠔꠣꠁ ꠔꠣꠘ ꠘꠣꠝ ꠖꠤꠟ “ꠔꠥꠝꠤ ꠖꠦꠈꠣ ꠖꠦꠘꠦꠀꠟꠣ ꠀꠟ꠆ꠟꠣ”; ꠔꠣꠁ ꠇꠁꠟ, “ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠂꠘ, ꠀꠝꠤ ꠅꠘꠅꠃ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠟꠣꠝ ꠘꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN16_14","002_16_14","GEN","16","14","14","ꠄꠞꠟꠣꠉꠤ ꠇꠣꠖꠦꠡ ꠀꠞ ꠛꠦꠞꠦꠖꠞ ꠝꠣꠎꠞ ꠢꠤ ꠇꠥꠀꠞ ꠘꠣꠝ ꠅꠁꠟ, ꠛꠦꠞ-ꠟꠢꠄ-ꠞꠥꠁ ꠝꠣꠘꠤ, ꠎꠦꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠞ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠞꠣ, ꠔꠣꠘ ꠇꠥꠀ। ");
INSERT INTO syls_vpl VALUES ("GN16_15","002_16_15","GEN","16","15","15","ꠛꠣꠖꠦ ꠡꠝꠄ ꠀꠁꠟꠦ ꠢꠣꠎꠦꠞꠣꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ, ꠀꠛ꠆ꠞꠣꠝꠦ ꠅꠃ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠁꠍꠝꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN16_16","002_16_16","GEN","16","16","16","ꠀꠛ꠆ꠞꠣꠝꠞ ꠛꠄꠅꠡ ꠎꠦꠛꠟꠣ ꠍꠤꠀꠡꠤ ꠛꠍꠞ ꠅꠁꠉꠦꠍꠦ, ꠅꠃ ꠡꠝꠄ ꠢꠣꠎꠦꠞꠣꠞ ꠊꠞꠅ ꠁꠍꠝꠣꠁꠟꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN17_1","002_17_1","GEN","17","1","1","ꠀꠛ꠆ꠞꠣꠝꠞ ꠘꠤꠞꠣꠘ꠆ꠘꠛ꠆ꠛꠁ ꠛꠞꠍꠞ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣ। ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠙꠕꠅ ꠕꠣꠇꠤꠀ ꠇꠣꠝꠤꠟ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("GN17_2","002_17_2","GEN","17","2","2","ꠀꠝꠤ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠌꠥꠇ꠆ꠔꠤ ꠇꠣꠁꠝ ꠇꠞꠝꠥ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠈꠥꠛ ꠛꠦꠡꠤ ꠛꠣꠠꠣꠁ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN17_3","002_17_3","GEN","17","3","3","ꠔꠦꠃ ꠀꠛ꠆ꠞꠣꠝ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠟꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN17_4","002_17_4","GEN","17","4","4","“ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠝꠤ ꠅꠀꠖꠣ ꠇꠣꠁꠝ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠤ ꠛꠃꠔ ꠎꠣꠔꠤꠞ ꠝꠥꠟ ꠛꠣꠚ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN17_5","002_17_5","GEN","17","5","5","ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠀꠛ꠆ꠞꠣꠝ ꠝꠣꠘꠤ, ꠛꠠ ꠛꠣꠚ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠁꠔ ꠘꠣꠄ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠝꠣꠘꠤ, ꠛꠃꠔ ꠎꠣꠔꠤꠞ ꠛꠣꠚ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠃꠔ ꠎꠣꠔꠤꠞ ꠝꠥꠟ ꠛꠣꠚ ꠛꠣꠘꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN17_6","002_17_6","GEN","17","6","6","ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠃꠔ ꠚꠟꠀꠟꠣ ꠇꠞꠝꠥ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠝꠣꠎ ꠕꠘꠦ ꠛꠃꠔ ꠎꠣꠔꠤ ꠀꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟ ꠙꠄꠖꠣ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN17_7","002_17_7","GEN","17","7","7","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠦ ꠌꠥꠇ꠆ꠔꠤ ꠇꠣꠁꠝ ꠇꠞꠝꠥ, ꠁꠇꠐꠣ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠛꠅꠀꠁꠟ ꠕꠣꠇꠛ, ꠅꠃ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ ꠅꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN17_8","002_17_8","GEN","17","8","8","ꠀꠞ ꠎꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠔꠥꠝꠤ ꠅꠈꠘ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠁꠀ ꠕꠣꠇꠞꠣꠄ, ꠁ ꠙꠥꠞꠣꠐꠣꠃ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠖꠈꠟꠞ ꠟꠣꠉꠤ ꠖꠤꠝꠥ। ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠅꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN17_9","002_17_9","GEN","17","9","9","ꠀꠟ꠆ꠟꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠇꠣꠁꠝ ꠇꠞꠣ ꠌꠥꠇ꠆ꠔꠤ ꠝꠣꠘꠤꠅ, ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠦꠅ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("GN17_10","002_17_10","GEN","17","10","10","ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠅꠃꠟꠣ ꠌꠥꠇ꠆ꠔꠤ ꠇꠣꠁꠝ ꠅꠁꠟ, ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN17_11","002_17_11","GEN","17","11","11","ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠘꠤꠎꠞ ꠙꠥꠞꠥꠡ ꠅꠋꠉꠞ ꠝꠥꠈꠣꠞ ꠌꠣꠝꠠꠣ ꠇꠣꠐꠛꠣꠄ। ꠅꠇꠐꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠀꠞ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠌꠥꠇ꠆ꠔꠤꠞ ꠘꠤꠡꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN17_12","002_17_12","GEN","17","12","12","ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠎꠘꠝꠞ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠛꠣꠄ। ꠎꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠠꠤꠔ ꠎꠘꠝꠤꠍꠦ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝ, ꠔꠣꠞꠣꠞꠅ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("GN17_13","002_17_13","GEN","17","13","13","ꠔꠥꠝꠞꠣꠞ ꠊꠞꠅ ꠎꠘꠝꠤꠍꠦ ꠛꠣ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠘꠤꠌꠄ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠛꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟꠅ ꠎꠣꠞꠤ ꠇꠞꠣ ꠀꠝꠣꠞ ꠁ ꠌꠥꠇ꠆ꠔꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠌꠥꠇ꠆ꠔꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN17_14","002_17_14","GEN","17","14","14","ꠎꠦ ꠛꠦꠐꠣꠄ ꠙꠥꠞꠥꠡ ꠅꠋꠉꠞ ꠝꠥꠈꠣꠞ ꠌꠣꠝꠠꠣ ꠇꠣꠐꠔ ꠘꠣꠄ, ꠔꠣꠞꠦ ꠔꠣꠞ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠛ। ꠢꠦ ꠔ ꠀꠝꠣꠞ ꠌꠥꠇ꠆ꠔꠤꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN17_15","002_17_15","GEN","17","15","15","ꠀꠟ꠆ꠟꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠛꠤꠛꠤꠞꠦ ꠀꠞ ꠍꠣꠞꠣ ꠇꠁꠀ ꠒꠣꠇꠤꠅ ꠘꠣ। ꠄꠘ ꠘꠣꠝ ꠅꠁꠛ ꠍꠣꠄꠞꠣ ꠝꠣꠘꠤ, ꠞꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("GN17_16","002_17_16","GEN","17","16","16","ꠀꠝꠤ ꠔꠣꠁꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠝꠥ, ꠔꠣꠁꠞ ꠊꠞꠅ ꠔꠥꠝꠣꠞ ꠄꠇ ꠙꠥꠀ ꠖꠤꠝꠥ। ꠀꠞ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠤꠀ ꠛꠃꠔ ꠎꠣꠔꠤꠞ ꠝꠥꠟ ꠝꠣ ꠛꠣꠘꠣꠁꠝꠥ, ꠀꠞ ꠛꠃꠔ ꠝꠥꠟ꠆ꠟꠥꠇꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠅ ꠙꠄꠖꠣ ꠅꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN17_17","002_17_17","GEN","17","17","17","ꠅꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤ ꠀꠡꠤꠀ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, “ꠢꠣꠍꠣꠃ ꠄꠇ-ꠡ ꠛꠍꠞꠞ ꠛꠥꠠꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠔ ꠘꠤ! ꠔꠣ-ꠅ ꠘꠛ꠆ꠛꠁ ꠛꠍꠞꠞ ꠛꠥꠠꠤ ꠍꠣꠄꠞꠣꠞ ꠙꠦꠐꠅ?” ");
INSERT INTO syls_vpl VALUES ("GN17_18","002_17_18","GEN","17","18","18","ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠢ! ꠁꠍꠝꠣꠁꠟꠉꠥ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞ ꠞꠢꠝꠔꠦ ꠛꠣꠌꠤꠀ ꠕꠣꠇꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN17_19","002_17_19","GEN","17","19","19","ꠅꠃ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, “ꠑꠤꠇ ꠀꠍꠦ। ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠙꠦꠐꠅ ꠢꠣꠍꠣꠃ ꠔꠥꠝꠣꠞ ꠙꠥꠀ ꠅꠁꠛ, ꠔꠥꠝꠤ ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠛꠣꠄ ꠁꠍꠢꠣꠇ ꠝꠣꠘꠤ, ꠢꠦ ꠀꠡꠦ। ꠔꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠌꠥꠇ꠆ꠔꠤ ꠇꠣꠁꠝ ꠇꠞꠝꠥ, ꠔꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠟꠉꠦ ꠁꠇꠐꠣ ꠀꠝꠣꠞ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠌꠥꠇ꠆ꠔꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN17_20","002_17_20","GEN","17","20","20","ꠀꠞ ꠁꠍꠝꠣꠁꠟꠞ ꠟꠣꠉꠤꠅ ꠔꠥꠝꠣꠞ ꠖꠥꠀ ꠢꠥꠘꠍꠤ। ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠣꠞꠦꠅ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠝꠥ ꠀꠞ ꠔꠣꠞꠦ ꠚꠟꠀꠟꠣ ꠇꠞꠤꠀ ꠛꠃꠔ ꠛꠣꠠꠣꠁ ꠖꠤꠝꠥ। ꠢꠦ ꠛꠣꠞꠅꠎꠘ ꠞꠣꠎꠣꠞ ꠛꠣꠚ ꠅꠁꠛ ꠀꠞ ꠔꠣꠞ ꠝꠣꠎꠦꠖꠤ ꠀꠝꠤ ꠛꠤꠞꠣꠐ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN17_21","002_17_21","GEN","17","21","21","ꠍꠣꠝꠘꠞ ꠛꠞꠍ ꠁ ꠌꠣꠘ꠆ꠖꠅ ꠍꠣꠄꠞꠣꠞ ꠊꠞꠅ ꠔꠥꠝꠣꠞ ꠎꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠛ, ꠢꠃ ꠁꠍꠢꠣꠇꠞ ꠟꠉꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠌꠥꠇ꠆ꠔꠤ ꠇꠣꠁꠝ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN17_22","002_17_22","GEN","17","22","22","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠡꠦꠡ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠔꠡꠞꠤꠚ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN17_23","002_17_23","GEN","17","23","23","ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠢꠃ ꠖꠤꠘꠃ ꠁꠍꠝꠣꠁꠟꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟꠣ। ꠄꠞ ꠟꠉꠦ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝ ꠅꠇꠟ ꠀꠞ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠎꠘꠝꠤꠍꠦ ꠁꠟꠣ ꠢꠇꠟ ꠉꠥꠟꠣꠝꠞꠦ, ꠛꠣꠠꠤꠞ ꠢꠇ꠆ꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN17_24","002_17_24","GEN","17","24","24","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠘꠤꠎꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠡꠝꠄ ꠔꠣꠘ ꠛꠄꠅꠡ ꠀꠍꠤꠟ ꠘꠤꠞꠣꠘ꠆ꠘꠛ꠆ꠛꠁ ꠛꠞꠍ, ");
INSERT INTO syls_vpl VALUES ("GN17_25","002_17_25","GEN","17","25","25","ꠀꠞ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠝꠣꠁꠟꠞ ꠛꠄꠅꠡ ꠔꠦꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("GN17_26","002_17_26","GEN","17","26","26","ꠄꠇ ꠖꠤꠘꠦꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠝꠣꠁꠟꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN17_27","002_17_27","GEN","17","27","27","ꠢꠤ ꠖꠤꠘ ꠛꠣꠠꠤꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ, ꠎꠣꠞꠣ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠎꠘꠝꠤꠍꠤꠟ ꠀꠞ ꠎꠦꠞꠣꠞꠦ ꠛꠤꠖꠦꠡ ꠕꠣꠇꠤ ꠟꠁꠀ ꠀꠘꠍꠂꠘ, ꠁꠔꠣ ꠢꠇꠟꠞꠃ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠄꠇꠟꠉꠦ ꠇꠞꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN18_1","002_18_1","GEN","18","1","1","ꠛꠣꠖꠦ ꠝꠝ꠆ꠞꠤꠞ ꠄꠟꠘ ꠛꠘꠞ ꠇꠣꠍꠣꠔ ꠝꠣꠛꠥꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠖꠤꠘꠞ ꠉꠞꠝꠞ ꠡꠝꠄ ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠞꠎꠣꠔ ꠛꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_2","002_18_2","GEN","18","2","2","ꠅꠃꠟꠣ ꠡꠝꠄ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠖꠦꠈꠟꠣ, ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠔꠤꠘꠎꠘ ꠝꠣꠘꠥꠡ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠖꠦꠈꠤꠀꠃ ꠔꠣꠁꠘ ꠖꠞꠎꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ, ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN18_3","002_18_3","GEN","18","3","3","“ꠅ ꠝꠥꠘꠤꠛ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠀꠙꠘꠣꠞꠣꠞ ꠝꠣꠄꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠅꠁ, ꠔꠣꠁꠟꠦ ꠀꠙꠘꠣꠞꠣꠞ ꠁ ꠉꠥꠟꠣꠝꠞꠦ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠁꠘ ꠘꠣ ꠎꠦꠘ। ");
INSERT INTO syls_vpl VALUES ("GN18_4","002_18_4","GEN","18","4","4","ꠀꠝꠤ ꠕꠥꠠꠣ ꠙꠣꠘꠤ ꠀꠘꠤꠀ ꠖꠤꠀꠞ ꠀꠙꠘꠣꠞꠣ ꠀꠔ-ꠙꠣꠅ ꠗꠁꠀ, ꠅꠃ ꠉꠣꠍ ꠔꠟꠣꠔ ꠎꠤꠞꠣꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_5","002_18_5","GEN","18","5","5","ꠀꠞ ꠁ ꠉꠥꠟꠣꠝꠞ ꠇꠣꠍꠣꠔ ꠎꠦꠛꠟꠣ ꠀꠁꠍꠂꠘ, ꠔꠦ ꠕꠥꠠꠣ ꠈꠣꠘꠤ ꠀꠘꠤꠀ ꠖꠦꠁ, ꠅꠔꠣ ꠈꠣꠁꠀ ꠎꠣꠘꠅ ꠀꠞꠣꠝ ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣꠘꠦ।” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠜꠣꠟꠣ, ꠀꠙꠘꠦ ꠎꠦꠛꠟꠣ ꠇꠁꠞꠣ, ꠔꠦ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN18_6","002_18_6","GEN","18","6","6","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠟꠉꠦ ꠟꠉꠦ ꠜꠤꠔꠞꠦ ꠉꠤꠀ ꠍꠣꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠎꠟꠖꠤ ꠇꠞꠤꠀ ꠔꠤꠘ ꠙꠦꠐꠥ ꠜꠣꠟꠣ ꠝꠄꠖꠣ ꠝꠣꠈꠤꠀ ꠙꠤꠑꠣ ꠛꠣꠘꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN18_7","002_18_7","GEN","18","7","7","ꠔꠣꠁꠘ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠉꠞꠥꠞ ꠙꠣꠟ ꠕꠘꠦ ꠈꠥꠛ ꠜꠣꠟꠣ ꠄꠇꠐꠣ ꠇꠍꠝꠣ ꠛꠣꠍꠥꠞ ꠀꠘꠤꠀ ꠔꠣꠘ ꠉꠥꠟꠣꠝꠞꠦ ꠖꠤꠟꠣ। ꠢꠦ-ꠅ ꠎꠟꠖꠤ ꠇꠞꠤ ꠅꠇꠐꠣ ꠞꠣꠘ꠆ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN18_8","002_18_8","GEN","18","8","8","ꠅꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠖꠥꠗ, ꠖꠁ ꠀꠞ ꠉꠥꠡ꠆ꠔ ꠀꠘꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠈꠣꠁꠛꠣꠞ ꠖꠤꠟꠣ, ꠔꠣꠞꠣ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠣꠍ ꠔꠟꠣꠔ ꠃꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_9","002_18_9","GEN","18","9","9","ꠔꠣꠞꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣ ꠇꠁ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠃꠘꠥ, ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN18_10","002_18_10","GEN","18","10","10","ꠅꠃ ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠄꠇꠎꠘꠦ ꠇꠁꠟꠣ, “ꠍꠣꠝꠘꠞ ꠛꠞꠍ ꠁ ꠌꠣꠘ꠆ꠖꠅ ꠀꠝꠤ ꠅꠛꠡ꠆ꠡꠃ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ। ꠖꠦꠈꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠙꠘꠣꠞ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠇꠥꠟꠅ ꠄꠇ ꠙꠥꠀ ꠕꠣꠇꠛ।” ꠍꠣꠄꠞꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠈꠞꠦ ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠞꠎꠣꠔ ꠃꠛꠣꠁꠀ ꠁꠔꠣ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_11","002_18_11","GEN","18","11","11","ꠁ ꠡꠝꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠀꠞ ꠍꠣꠄꠞꠣ ꠛꠥꠠꠣ-ꠎꠁꠚ ꠅꠁꠉꠦꠍꠂꠘ, ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠀꠞ ꠟꠣꠈꠣꠘ ꠛꠄꠅꠡꠅ ꠍꠣꠄꠞꠣꠞ ꠞꠁꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_12","002_18_12","GEN","18","12","12","ꠄꠞꠟꠣꠉꠤ ꠍꠣꠄꠞꠣꠄ ꠝꠘꠦ ꠝꠘꠦ ꠀꠡꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠅꠃꠟꠣ ꠢꠦꠡꠇꠣꠟꠤ ꠛꠄꠅꠡꠅ ꠁꠔꠣ ꠈꠥꠡꠤ ꠀꠞ ꠀꠁꠛ ꠘꠤ? ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇꠅ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠁꠉꠦꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN18_13","002_18_13","GEN","18","13","13","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠍꠣꠄꠞꠣꠄ ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠇꠁꠀ ꠀꠡꠟ ꠎꠦꠘ, ꠢꠣꠍꠣꠃ ꠀꠝꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠛ ꠘꠤ, ꠀꠝꠤ ꠔ ꠛꠥꠠꠤ? ");
INSERT INTO syls_vpl VALUES ("GN18_14","002_18_14","GEN","18","14","14","ꠝꠣꠛꠥꠖꠦ ꠙꠣꠞꠂꠘ ꠘꠣ ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠀꠍꠦ ꠘꠤ? ꠖꠦꠈꠤꠅ, ꠑꠤꠇ ꠡꠝꠄꠄ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ, ꠀꠞ ꠁ ꠡꠝꠄ ꠍꠣꠄꠞꠣꠞ ꠇꠥꠟꠅ ꠙꠥꠀ ꠕꠣꠇꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN18_15","002_18_15","GEN","18","15","15","ꠍꠣꠄꠞꠣꠄ ꠒꠞꠣꠁꠀ ꠇꠁꠟꠣ, “ꠎꠤ ꠘꠣ, ꠀꠝꠤ ꠔ ꠀꠡꠍꠤ ꠘꠣ।” ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠘꠣ ꠞꠦꠉ, ꠔꠥꠝꠤ ꠘꠥ ꠀꠡꠤꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN18_16","002_18_16","GEN","18","16","16","ꠄꠞꠛꠣꠖꠦ ꠢꠃ ꠔꠤꠘꠎꠘꠦ ꠁꠘ ꠕꠘꠦ ꠃꠑꠤꠀ ꠍꠣꠖꠥꠝꠞ ꠛꠣꠄ ꠌꠣꠁꠟꠣ। ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠛꠤꠖꠣꠄ ꠖꠦꠅꠀꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_17","002_18_17","GEN","18","17","17","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠞꠔꠣꠝ ꠌꠣꠁꠀꠞ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠟꠥꠇꠣꠁꠔꠣꠝ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GN18_18","002_18_18","GEN","18","18","18","ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠕꠣꠇꠤꠀꠃ ꠔ ꠀꠝꠤ ꠄꠇ ꠝꠢꠣꠘ ꠢꠤꠝ꠆ꠝꠔꠀꠟꠣ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ, ꠖꠥꠘꠤꠀꠁꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠅꠘ ꠕꠘꠦ ꠛꠞꠇꠔ ꠇꠣꠝꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_19","002_18_19","GEN","18","19","19","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠔꠣꠞꠦ ꠈꠣꠔꠤꠞ ꠇꠞꠍꠤ, ꠢꠦ ꠔꠣꠞ ꠅꠀꠞꠤꠡ ꠀꠞ ꠔꠣꠞ ꠘꠤꠎꠞ ꠢꠇꠟꠞꠦ ꠀꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠘꠤꠀ ꠢꠇ ꠀꠞ ꠁꠘꠍꠣꠚꠞ ꠇꠣꠝ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠦꠄ। ꠔꠣꠞꠣꠅ ꠎꠥꠖꠤ ꠅꠃ ꠟꠣꠈꠣꠘ ꠌꠟꠦ, ꠔꠣꠁꠟꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠔꠔꠣ ꠇꠁꠍꠤ, ꠢꠇꠟꠔꠣꠃ ꠙꠥꠞꠣ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN18_20","002_18_20","GEN","18","20","20","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠍꠣꠖꠥꠝ ꠀꠞ ꠀꠝꠥꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠈꠥꠛ ꠘꠣꠟꠤꠡ ꠀꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠤꠀꠞ, ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠅ ꠈꠥꠛ ꠛꠦꠎꠥꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_21","002_18_21","GEN","18","21","21","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠟꠦ ꠟꠣꠝꠤꠀ ꠉꠤꠀ ꠖꠦꠈꠤ, ꠀꠝꠤ ꠎꠦꠟꠣ ꠘꠣꠟꠤꠡ ꠢꠥꠘꠤꠀꠞ, ꠁꠔꠣ ꠢꠣꠍꠣꠃ ꠅꠃꠟꠣ ꠈꠣꠞꠣꠙ ꠇꠤ ꠘꠣ। ꠀꠞ ꠘꠣ ꠅꠁꠟꠦꠅ ꠔ ꠖꠦꠈꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN18_22","002_18_22","GEN","18","22","22","ꠅꠃ ꠢꠤ ꠖꠥꠁꠅꠎꠘꠦ ꠚꠤꠞꠤꠀ ꠍꠣꠖꠥꠝꠞ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN18_23","002_18_23","GEN","18","23","23","ꠛꠣꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠄ ꠀꠉꠥꠀꠁꠀ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠉꠥꠘꠣꠉꠣꠞꠞ ꠟꠉꠦ ꠢꠇ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞꠦꠅ ꠝꠣꠞꠤꠟꠣꠁꠔꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GN18_24","002_18_24","GEN","18","24","24","ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ ꠢꠇ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠦ ꠔꠣꠁꠟꠦ ꠢꠃ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘꠞ ꠈꠣꠔꠤꠞꠦ ꠐꠣꠃꠘꠞꠦ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠘꠣ ꠇꠞꠤꠀ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠁꠛꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GN18_25","002_18_25","GEN","18","25","25","ꠔꠦ ꠀꠙꠘꠣꠞ ꠇꠣꠝ ꠔ ꠅꠃꠟꠣ ꠘꠣꠄ, ꠢꠇ ꠀꠞ ꠉꠥꠘꠣꠉꠣꠞꠞꠦ ꠄꠇꠟꠉꠦ ꠝꠣꠞꠤꠟꠣꠅꠀ, ꠄꠇ ꠢꠝꠣꠘ ꠡꠣꠎꠣ ꠖꠦꠅꠀ, ꠀꠙꠘꠣꠞ ꠟꠣꠉꠤ ꠔ ꠑꠤꠇ ꠘꠣꠄ। ꠎꠦꠁꠘ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ, ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠢꠇ ꠁꠘꠍꠣꠚ ꠇꠞꠔꠣ ꠘꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN18_26","002_18_26","GEN","18","26","26","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠎꠥꠖꠤ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘꠅ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘꠅ ꠢꠇ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠂꠘ, ꠔꠣꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠝꠤ ꠀꠡ꠆ꠔꠣ ꠐꠣꠃꠘꠞꠦ ꠞꠦꠢꠣꠁ ꠖꠤꠟꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN18_27","002_18_27","GEN","18","27","27","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠔ ꠗꠥꠁꠟ ꠀꠞ ꠍꠣꠟꠤ ꠍꠣꠠꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ, ꠔꠣ-ꠅ ꠀꠝꠤ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("GN18_28","002_18_28","GEN","18","28","28","ꠗꠞꠃꠇ꠆ꠇꠣ, ꠎꠥꠖꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ ꠢꠇ ꠝꠣꠘꠥꠡ ꠘꠣ ꠅꠁꠀ ꠙꠣꠌ ꠎꠘ ꠇꠝ ꠅꠄ, ꠔꠣꠁꠟꠦ ꠇꠤꠔꠣ ꠅꠃ ꠙꠣꠌ ꠎꠘ ꠇꠝꠞ ꠟꠣꠉꠤ ꠀꠙꠘꠦ ꠀꠡ꠆ꠔꠣ ꠐꠣꠃꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠁꠛꠣ ꠘꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠥꠖꠤ ꠢꠤꠘꠅ ꠙꠄꠔꠣꠟ꠆ꠟꠤꠡ ꠎꠘꠞꠦ ꠙꠣꠁ, ꠔꠣꠁꠟꠦ ꠁꠇꠐꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN18_29","002_18_29","GEN","18","29","29","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠔꠣꠘꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠗꠞꠃꠇ꠆ꠇꠣ, ꠎꠥꠖꠤ ꠢꠤꠘꠅ ꠌꠣꠟ꠆ꠟꠤꠡ ꠎꠘ ꠙꠣꠅꠀ ꠎꠣꠄ?” ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠢꠃ ꠌꠣꠟ꠆ꠟꠤꠡ ꠎꠘꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠝꠤ ꠛꠤꠘꠣꠡ ꠇꠞꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN18_30","002_18_30","GEN","18","30","30","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ ꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠝꠣꠔꠦ ꠘꠣꠞꠣꠎ ꠘꠣ ꠅꠁꠘ। ꠀꠁꠌ꠆ꠍꠣ, ꠎꠥꠖꠤ ꠢꠤꠘꠅ ꠔꠤꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠎꠣꠄ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠎꠥꠖꠤ ꠀꠝꠤ ꠔꠤꠡ ꠎꠘꠞꠦꠅ ꠙꠣꠁ, ꠔꠣꠁꠟꠦꠅ ꠀꠝꠤ ꠛꠤꠘꠣꠡ ꠇꠞꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN18_31","002_18_31","GEN","18","31","31","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤꠀ ꠝꠣꠟꠤꠇꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤꠀꠞ ꠔꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠀꠞ, ꠎꠥꠖꠤ ꠢꠤꠘꠅ ꠛꠤꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠎꠣꠄ?” ꠝꠣꠛꠥꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠃ ꠛꠤꠡ ꠎꠘꠞ ꠈꠣꠔꠤꠞꠦꠃ ꠀꠝꠤ ꠁꠇꠐꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN18_32","002_18_32","GEN","18","32","32","ꠢꠦꠡꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ ꠎꠣꠘꠥ ꠘꠣꠞꠣꠎ ꠘꠣ ꠅꠁꠘ, ꠀꠝꠤ ꠈꠣꠟꠤ ꠀꠞꠅ ꠄꠇꠛꠣꠞꠔꠣ ꠇꠁꠀꠞ, ꠎꠥꠖꠤ ꠢꠤꠘꠅ ꠖꠡ ꠎꠘ ꠕꠣꠇꠂꠘ?” ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠢꠃ ꠖꠡ ꠎꠘꠞ ꠈꠣꠔꠤꠞꠦꠃ ꠀꠝꠤ ꠁꠇꠐꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN18_33","002_18_33","GEN","18","33","33","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠉꠦ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠔ-ꠍꠅꠀꠟ ꠡꠦꠡ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ, ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠅ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_1","002_19_1","GEN","19","1","1","ꠛꠣꠖꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠢꠃ ꠖꠥꠁꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ। ꠁ ꠡꠝꠄ ꠟꠥꠔ ꠐꠣꠃꠘꠞ ꠝꠥꠟ ꠉꠦꠁꠐꠞ ꠉꠦꠍꠦ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠄꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠃꠛꠣꠁꠟꠣ ꠀꠞ ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN19_2","002_19_2","GEN","19","2","2","“ꠅ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ ꠅꠇꠟ, ꠀꠝꠤ ꠝꠤꠘꠔꠤ ꠇꠞꠤ ꠇꠁꠀꠞ, ꠖꠄꠀ ꠇꠞꠤ ꠀꠙꠘꠣꠞꠣꠞ ꠅꠃ ꠉꠥꠟꠣꠝꠞ ꠊꠞꠅ ꠔꠡꠞꠤꠚ ꠀꠘꠤꠟꠣꠃꠇ꠆ꠇꠣ ꠀꠞ ꠀꠔ-ꠙꠣꠅ ꠗꠁꠀ ꠞꠣꠁꠔꠈꠣꠘ ꠇꠣꠐꠣꠃꠇ꠆ꠇꠣ। ꠛꠤꠀꠘꠦ ꠢꠤꠞꠛꠣꠞ ꠞꠅꠀꠘꠣ ꠅꠁꠛꠣꠘꠦ।” ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠘꠣ, ꠀꠝꠞꠣ ꠅꠃ ꠐꠣꠃꠘꠞ ꠝꠄꠖꠣꠘꠅ ꠞꠣꠁꠔ ꠇꠣꠐꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN19_3","002_19_3","GEN","19","3","3","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠈꠥꠛ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠞꠣ ꠅꠃ ꠡꠝꠄ ꠄꠞꠣ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠟꠣ। ꠛꠣꠖꠦ ꠟꠥꠔꠦ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠁꠀ ꠄꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠎꠥꠁꠔ ꠇꠞꠟꠣ, ꠀꠞ ꠔꠣꠞꠣ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_4","002_19_4","GEN","19","4","4","ꠄꠞꠣꠞ ꠢꠥꠔꠤꠛꠣꠞ ꠀꠉꠦꠃ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘꠞ ꠢꠇ꠆ꠇꠟ ꠎꠥꠀꠘ-ꠛꠥꠠꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠀꠁꠀ ꠢꠤ ꠛꠣꠠꠤꠞꠦ ꠛꠦꠞꠤꠟꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN19_5","002_19_5","GEN","19","5","5","ꠀꠞ ꠟꠥꠔꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, “ꠀꠁꠎ ꠞꠣꠁꠔ ꠎꠦ ꠖꠥꠁꠎꠘ ꠝꠣꠘꠥꠡ ꠔꠞ ꠁꠘꠅ ꠀꠁꠍꠦ, ꠔꠣꠞꠣ ꠇꠁ? ꠅꠔꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠘ। ꠀꠝꠞꠣ ꠅꠔꠣꠞ ꠟꠉꠦ ꠝꠃꠎ ꠇꠞꠔꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN19_6","002_19_6","GEN","19","6","6","ꠅꠃ ꠡꠝꠄ ꠟꠥꠔꠦ ꠖꠞꠎꠣꠞ ꠛꠣꠞꠦ ꠉꠤꠀ ꠔꠣꠘ ꠈꠞꠞ ꠖꠞꠎꠣ ꠛꠘ꠆ꠖ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN19_7","002_19_7","GEN","19","7","7","“ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠤ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠁꠟꠣ ꠛꠖ ꠇꠣꠝ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_8","002_19_8","GEN","19","8","8","ꠖꠦꠈꠅ, ꠀꠝꠣꠞ ꠖꠥꠁꠐꠣ ꠡꠔꠤ ꠙꠥꠠꠤ ꠀꠍꠦ। ꠀꠝꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠀꠞ, ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠞꠁꠍꠂꠘ ꠘꠣ, ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠝꠘꠦ ꠌꠣꠄ ꠇꠞꠅ; ꠔꠣ-ꠅ, ꠁ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠄꠞꠣ ꠀꠝꠣꠞ ꠊꠞꠅ ꠀꠡꠞꠄ ꠟꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN19_9","002_19_9","GEN","19","9","9","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠎꠣ, ꠎꠣ, ꠙꠕ ꠕꠣꠇꠤ ꠢꠞ!” ꠔꠣꠞꠣ ꠀꠞꠅ ꠇꠁꠟ, “ꠅꠂ ꠛꠦꠐꠣ, ꠔꠥꠁ ꠄꠇꠟꠣ ꠛꠂꠔꠟ ꠅꠁꠀ ꠀꠁꠍꠍ ꠀꠞ ꠈꠣꠟꠤ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠘꠦꠔꠣꠉꠤꠞꠤ ꠇꠞꠞꠦ। ꠅꠈꠘ ꠄꠞꠣꠞ ꠌꠣꠁꠔꠦ ꠔꠞ ꠟꠉꠦ ꠀꠞꠅ ꠛꠦꠡꠤ ꠈꠛꠤꠍꠤ ꠇꠞꠝꠥ।” ꠇꠁꠀꠃ ꠔꠣꠞꠣ ꠟꠥꠔꠞꠦ ꠑꠦꠟꠤꠀ ꠢꠞꠣꠁꠀ ꠖꠞꠎꠣ ꠜꠣꠋꠉꠔ ꠌꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN19_10","002_19_10","GEN","19","10","10","ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠖꠥꠁꠎꠘꠦ ꠀꠔ ꠛꠣꠠꠣꠁꠀ, ꠟꠥꠔꠞꠦ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠐꠣꠘꠤꠀ ꠘꠤꠀ ꠖꠞꠎꠣ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_11","002_19_11","GEN","19","11","11","ꠀꠞ ꠖꠞꠎꠣꠞ ꠛꠣꠞꠦ ꠃꠛꠣꠁꠟ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟ ꠀꠈꠔꠣꠃ ꠀꠘ꠆ꠖꠣ ꠅꠁꠉꠦꠟ, ꠀꠞ ꠖꠞꠎꠣ ꠔꠥꠇꠣꠁꠔꠦ ꠔꠥꠇꠣꠁꠔꠦ ꠢꠦꠞꠣꠘ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN19_12","002_19_12","GEN","19","12","12","ꠛꠣꠖꠦ ꠢꠃ ꠖꠥꠁꠅꠎꠘꠦ ꠟꠥꠔꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁꠘꠅ ꠔꠥꠝꠣꠞ ꠀꠞ ꠇꠦ ꠇꠦ ꠀꠍꠦ? ꠔꠥꠝꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤ ꠀꠞ ꠖꠣꠝꠣꠘ꠆ꠖꠞꠦ ꠟꠁꠀ ꠁꠘ ꠕꠘꠦ ꠢꠞꠤꠀ ꠎꠣꠅꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN19_13","002_19_13","GEN","19","13","13","ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠁ ꠎꠣꠉꠣꠞꠦ ꠍꠣꠞꠈꠣꠞ ꠇꠞꠤꠟꠣꠁꠀꠞ। ꠁꠘꠞ ꠝꠣꠘꠡꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠅꠃꠟꠣ ꠛꠦꠎꠥꠁꠔꠣ ꠘꠣꠟꠤꠡ ꠅꠁꠍꠦ ꠎꠦꠘ, ꠁꠇꠐꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN19_14","002_19_14","GEN","19","14","14","ꠅꠃ ꠟꠥꠔꠦ ꠛꠣꠞꠦ ꠉꠤꠀ ꠔꠣꠘ ꠖꠣꠝꠣꠘ꠆ꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠔꠥꠝꠞꠣ ꠁ ꠎꠣꠉꠣ ꠍꠣꠠꠤꠀ ꠛꠣꠞꠅ ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠦ ꠁ ꠐꠣꠃꠘꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠤꠀꠞ ꠅꠁꠞꠁꠍꠂꠘ।” ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠝꠘꠦ ꠇꠞꠟ, ꠔꠣꠁꠘ ꠁꠔꠣ ꠔꠣꠝꠡꠣ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_15","002_19_15","GEN","19","15","15","ꠙꠔꠣꠛꠣꠟꠣ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠟꠥꠔꠞꠦ ꠔꠣꠉꠖꠣ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠃꠑꠅ, ꠎꠟꠖꠤ ꠇꠞꠤ ꠔꠥꠝꠣꠞ ꠛꠃ ꠀꠞ ꠁ ꠖꠥꠁꠅ ꠙꠥꠠꠤꠞꠦ ꠟꠁꠀ ꠅꠘ ꠕꠘꠦ ꠎꠣꠅꠉꠤ। ꠘꠣꠁꠟꠦ ꠅꠃ ꠉꠎꠛꠞ ꠝꠣꠎꠦ ꠙꠠꠤꠀ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN19_16","002_19_16","GEN","19","16","16","ꠟꠥꠔꠦ ꠎꠣꠁ-ꠎꠣꠁꠞꠣꠝ ꠅꠃꠟꠣ ꠇꠞꠞꠣ। ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠝꠣꠄꠀ ꠔꠣꠘ ꠃꠙꠞꠦ ꠀꠍꠤꠟ ꠇꠞꠤ ꠢꠃ ꠖꠥꠁꠅꠎꠘꠦ, ꠔꠣꠁꠘ ꠀꠞ ꠔꠣꠘ ꠛꠃ ꠀꠞ ꠔꠣꠘ ꠖꠥꠁꠅ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠀꠔꠅ ꠗꠞꠤ ꠐꠣꠘꠤꠀ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_17","002_19_17","GEN","19","17","17","ꠢꠇꠟꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠛꠣꠌꠔꠦ ꠌꠣꠁꠟꠦ ꠜꠣꠉꠅ, ꠈꠞꠦꠖꠤ ꠌꠣꠁꠅ ꠘꠣ, ꠜꠣꠉꠤꠀ ꠙꠣꠠꠅ ꠎꠣꠅ, ꠁ ꠕꠟ ꠎꠣꠉꠣꠞ ꠇꠥꠘꠥꠈꠣꠘꠅ ꠃꠛꠣꠁꠅ ꠘꠣ ꠀꠞꠘꠣꠄ ꠔꠥꠝꠞꠣꠅ ꠝꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN19_18","002_19_18","GEN","19","18","18","ꠅꠃ ꠟꠥꠔꠦ ꠇꠁꠟꠣ, “ꠅ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ ꠅꠇꠟ, ꠁꠟꠣ ꠇꠞꠂꠘ ꠘꠣ ꠎꠦꠘ; ");
INSERT INTO syls_vpl VALUES ("GN19_19","002_19_19","GEN","19","19","19","ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝꠞꠦ ꠀꠙꠘꠦ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠝꠢꠣ ꠖꠄꠀ ꠖꠦꠈꠣꠁꠍꠂꠘ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠜꠣꠉꠤꠀ ꠙꠣꠠꠅ ꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ। ꠢꠄꠔ ꠁ ꠛꠤꠙꠖ ꠀꠁꠀ ꠀꠝꠣꠞꠦ ꠎꠣꠔꠣ ꠝꠣꠞꠤ ꠗꠞꠟꠦ, ꠀꠝꠤꠅ ꠝꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN19_20","002_19_20","GEN","19","20","20","ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠜꠣꠉꠤꠀ ꠎꠣꠁꠔꠦ ꠔ ꠅꠃ ꠢꠥꠞꠥ ꠉꠣꠃꠐꠣ ꠇꠣꠍꠣꠔ ꠀꠍꠦ। ꠎꠣꠘ ꠛꠣꠌꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠅꠘꠅ ꠙꠣꠑꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠉꠣꠃꠐꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN19_21","002_19_21","GEN","19","21","21","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠑꠤꠇ ꠀꠍꠦ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠁ ꠀꠞꠎꠤ ꠝꠣꠘꠟꠣꠝ। ꠔꠥꠝꠤ ꠎꠦ ꠉꠣꠃꠞ ꠇꠕꠣ ꠇꠁꠟꠣꠄ, ꠁꠐꠣ ꠀꠝꠤ ꠗꠋꠡ ꠇꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN19_22","002_19_22","GEN","19","22","22","ꠎꠟꠖꠤ ꠇꠞꠤ ꠢꠤꠘꠅ ꠎꠣꠅ। ꠔꠥꠝꠤ ꠢꠘꠅ ꠘꠣ ꠙꠃꠍꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠤ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤꠀꠞ ꠘꠣ।” ꠟꠥꠔꠞ ꠇꠕꠣꠞ ꠟꠣꠉꠤ ꠢꠃ ꠉꠣꠃꠞ ꠘꠣꠝ ꠅꠁꠟ ꠍꠥꠀꠞ ꠝꠣꠘꠤ, ꠢꠥꠞꠥ। ");
INSERT INTO syls_vpl VALUES ("GN19_23","002_19_23","GEN","19","23","23","ꠟꠥꠔꠦ ꠎꠦꠛꠟꠣ ꠍꠥꠀꠞꠅ ꠉꠤꠀ ꠙꠃꠍꠟꠣ ꠁ ꠡꠝꠄ ꠡꠥꠞꠥꠎ ꠃꠑꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN19_24","002_19_24","GEN","19","24","24","ꠄꠞꠛꠣꠖꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠍꠣꠖꠥꠝ ꠀꠞ ꠀꠝꠥꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠉꠥꠁꠘ ꠀꠞ ꠉꠘ꠆ꠖꠇꠞ ꠉꠎꠛ ꠍꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_25","002_19_25","GEN","19","25","25","ꠔꠣꠁꠘ ꠢꠤ ꠐꠣꠃꠘ ꠅꠇꠟ, ꠢꠇꠟ ꠕꠟ ꠎꠣꠉꠣ, ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠥꠡ ꠀꠞ ꠢꠤ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠗꠋꠡ ꠇꠞꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_26","002_19_26","GEN","19","26","26","ꠄꠞꠝꠣꠎꠦ ꠟꠥꠔꠞ ꠛꠃꠄ ꠈꠞꠦꠖꠤ ꠚꠤꠞꠤꠀ ꠌꠣꠅꠀꠄ, ꠔꠣꠁꠘ ꠄꠇꠐꠣ ꠘꠥꠘꠞ ꠌꠣꠇ꠆ꠇꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_27","002_19_27","GEN","19","27","27","ꠛꠣꠖꠞ ꠖꠤꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠛꠤꠀꠘꠦ ꠃꠑꠤꠀ ꠢꠃ ꠎꠣꠉꠣꠔ ꠉꠦꠟꠣ ꠎꠦꠘꠅ ꠀꠉꠞ ꠖꠤꠘ ꠔꠣꠁꠘ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_28","002_19_28","GEN","19","28","28","ꠔꠣꠁꠘ ꠔꠟꠦ ꠍꠣꠖꠥꠝ, ꠀꠝꠥꠞꠣ ꠀꠞ ꠢꠇꠟ ꠕꠟ ꠎꠣꠉꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠁꠐ-ꠜꠣꠐ꠆ꠐꠣ ꠕꠣꠇꠤ ꠎꠦꠟꠣ ꠗꠥꠝꠣ ꠛꠣꠞꠅꠄ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠃ ꠄꠟꠣꠇꠣ ꠕꠣꠇꠤ ꠗꠥꠝꠣ ꠃꠠꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("GN19_29","002_19_29","GEN","19","29","29","ꠀꠞ ꠟꠥꠔꠦ ꠎꠦꠈꠣꠘꠅ ꠛꠡꠔ ꠇꠞꠔꠣ, ꠢꠃ ꠕꠟ ꠎꠣꠉꠣꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠗꠋꠡ ꠇꠞꠣꠞ ꠡꠝꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠇꠕꠣ ꠝꠘꠅ ꠇꠞꠤꠀ ꠟꠥꠔꠞꠦ ꠢꠤꠘꠞ ꠉꠎꠛꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_30","002_19_30","GEN","19","30","30","ꠍꠥꠀꠞ ꠉꠣꠃꠔ ꠞꠁꠔꠦ ꠒꠞꠣꠁꠟꠣ ꠇꠞꠤ, ꠟꠥꠔꠦ ꠔꠣꠘ ꠖꠥꠁꠅ ꠙꠥꠠꠤꠞꠦ ꠟꠁꠀ ꠢꠤꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠙꠣꠠꠅ ꠀꠁꠀ, ꠄꠇ ꠉꠣꠔꠞ ꠜꠤꠔꠞꠦ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_31","002_19_31","GEN","19","31","31","ꠄꠇꠖꠤꠘ ꠔꠣꠘ ꠛꠠ ꠙꠥꠠꠤꠄ ꠢꠥꠞꠥ ꠛꠁꠘꠞꠦ ꠇꠁꠟ, “ꠛꠣꠛꠣ ꠔ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠁꠉꠦꠍꠂꠘ। ꠀꠞ ꠎꠉꠔꠞ ꠡꠝꠣꠎꠞ ꠘꠤꠅꠝ ꠝꠔ ꠀꠝꠞꠣꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠘꠅ ꠇꠥꠘꠥ ꠛꠦꠐꠣꠁꠘꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN19_32","002_19_32","GEN","19","32","32","ꠔꠦ ꠀꠄ, ꠀꠝꠞꠣ ꠛꠣꠛꠣꠞꠦ ꠡꠞꠣꠛ ꠈꠣꠅꠀꠁꠀ ꠔꠣꠘ ꠇꠣꠍꠣꠔ ꠞꠁ। ꠔꠦꠃ ꠛꠣꠛꠣꠞꠦꠖꠤ ꠀꠝꠞꠣꠞ ꠛꠋꠡ ꠛꠣꠌꠣꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN19_33","002_19_33","GEN","19","33","33","ꠅꠃ ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠔꠣꠘꠞꠦ ꠡꠞꠣꠛ ꠈꠣꠅꠀꠁꠀ ꠐꠣꠟ ꠛꠣꠘꠣꠁꠟ। ꠛꠣꠖꠦ ꠛꠠ ꠛꠁꠘ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠢꠥꠔꠤꠔ ꠉꠦꠟ, ꠅꠁꠟꠦ ꠇꠥꠘ ꠡꠝꠄ ꠢꠥꠔꠤꠟ ꠀꠞ ꠇꠥꠘ ꠡꠝꠄ ꠃꠑꠤꠟ, ꠛꠣꠚꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠐꠦꠞ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_34","002_19_34","GEN","19","34","34","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠠꠉꠥꠄ ꠢꠥꠞꠥꠉꠥꠞꠦ ꠇꠁꠟ, “ꠖꠦꠈ, ꠇꠣꠁꠟ ꠞꠣꠁꠔ ꠀꠝꠤ ꠛꠣꠛꠣꠞ ꠉꠦꠍꠦ ꠢꠥꠔꠤꠍꠟꠣꠝ। ꠀꠄ, ꠀꠁꠎ ꠞꠣꠁꠔꠅ ꠔꠣꠘꠦ ꠅꠃꠟꠣ ꠡꠞꠣꠛ ꠈꠣꠅꠀꠁꠀ ꠐꠣꠟ ꠛꠣꠘꠣꠁ, ꠛꠣꠖꠦ ꠔꠥꠁꠅ ꠉꠤꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠢꠥꠔꠤꠍ। ꠔꠦ ꠛꠣꠛꠣꠞꠦꠖꠤ ꠀꠝꠞꠣꠞ ꠛꠋꠡ ꠛꠣꠌꠣꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN19_35","002_19_35","GEN","19","35","35","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠢꠃ ꠞꠣꠁꠔꠅ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞꠦ ꠡꠞꠣꠛ ꠈꠣꠅꠀꠁꠀ ꠐꠣꠟ ꠛꠣꠘꠣꠁꠟ, ꠀꠞ ꠢꠥꠞꠥ ꠙꠥꠠꠤ ꠔꠣꠁꠞ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠢꠥꠔꠤꠟ। ꠔꠣꠁ ꠇꠥꠘ ꠡꠝꠄ ꠢꠥꠔꠤꠟ ꠀꠞ ꠇꠥꠘ ꠡꠝꠄ ꠃꠑꠤꠟ, ꠁꠔꠣ ꠔꠣꠁꠘ ꠇꠥꠘ꠆ꠔꠣꠃ ꠐꠦꠞ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN19_36","002_19_36","GEN","19","36","36","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠟꠥꠔꠞ ꠖꠥꠁꠅ ꠙꠥꠠꠤꠞ ꠙꠦꠐꠅ ꠛꠣꠚꠞꠦꠖꠤ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN19_37","002_19_37","GEN","19","37","37","ꠛꠣꠖꠦ ꠛꠠ ꠙꠥꠠꠤꠞ ꠊꠞꠅ ꠙꠥꠀ ꠅꠁꠟꠦ, ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟ ꠝꠥꠀꠛ ꠝꠣꠘꠤ, ꠛꠣꠛꠣꠞ ꠉꠦꠍ ꠕꠘꠦ। ꠅꠃ ꠝꠥꠀꠛꠃ ꠅꠈꠘꠇꠥꠞ ꠝꠥꠀꠛꠤ ꠅꠇꠟꠞ ꠝꠥꠟ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("GN19_38","002_19_38","GEN","19","38","38","ꠀꠞ ꠢꠥꠞꠥ ꠙꠥꠠꠤꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ, ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟ ꠛꠤꠘ-ꠅꠝ꠆ꠝꠤ ꠝꠣꠘꠤ, ꠀꠝꠣꠞ ꠝꠥꠟ꠆ꠟꠥꠇꠞ ꠙꠥꠀ। ꠢꠦ ꠅꠈꠘꠇꠥꠞ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘꠞ ꠝꠥꠟ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("GN20_1","002_20_1","GEN","20","1","1","ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠢꠤꠘ ꠕꠘꠦ ꠘꠦꠉꠦꠜꠞ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠉꠤꠀ ꠇꠣꠖꠦꠡ ꠀꠞ ꠡꠥꠞꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠉꠦꠞꠣꠞ ꠖꠦꠡꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN20_2","002_20_2","GEN","20","2","2","ꠢꠘꠅ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠛꠃ ꠍꠣꠄꠞꠣꠞꠦ ꠘꠤꠎꠞ ꠛꠁꠘ ꠇꠁꠀ ꠙꠞꠤꠌꠄ ꠖꠤꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠢꠤꠘꠞ ꠛꠣꠖꠡꠣ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠝꠣꠘꠥꠡꠖꠤ ꠍꠣꠄꠞꠣꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN20_3","002_20_3","GEN","20","3","3","ꠀꠞ ꠞꠣꠁꠔ ꠀꠟ꠆ꠟꠣꠄ ꠀꠛꠤꠝꠣꠟꠤꠇꠞꠦ ꠈꠥꠀꠛꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠅꠃ ꠎꠦ ꠛꠦꠐꠤꠞꠦ ꠔꠥꠝꠤ ꠟꠁꠀ ꠀꠁꠍ, ꠔꠣꠁꠞ ꠔ ꠎꠣꠝꠣꠁ ꠀꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠅꠈꠘ ꠝꠃꠔꠞ ꠝꠥꠈꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN20_4","002_20_4","GEN","20","4","4","ꠀꠛꠤꠝꠣꠟꠤꠇ ꠅꠈꠘꠅ ꠍꠣꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠉꠦꠍꠂꠘ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠟꠤꠇ, ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠎꠣꠔꠤ ꠅꠁꠟꠦꠅ ꠇꠤꠔꠣ ꠀꠙꠘꠦ ꠝꠣꠞꠤꠟꠣꠁꠔꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GN20_5","002_20_5","GEN","20","5","5","ꠅꠃ ꠝꠣꠘꠥꠡꠐꠣꠄ ꠔ ꠘꠤꠎꠦꠃ ꠇꠁꠍꠦ, ꠄꠁꠘ ꠔꠣꠞ ꠛꠁꠘ। ꠀꠞ ꠅꠃ ꠛꠦꠐꠤꠄꠅ ꠇꠁꠍꠂꠘ ꠘꠣ ꠘꠤ, ꠄꠁꠘ ꠔꠣꠘ ꠜꠣꠁ? ꠀꠝꠤ ꠔ ꠡꠞꠟ ꠝꠘꠦ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠀꠔꠦ ꠁ ꠇꠣꠝ ꠇꠞꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN20_6","002_20_6","GEN","20","6","6","ꠀꠟ꠆ꠟꠣꠄ ꠈꠥꠀꠛꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤꠅ ꠎꠣꠘꠤ, ꠔꠥꠝꠤ ꠡꠞꠟ ꠝꠘꠦ ꠁ ꠇꠣꠝ ꠇꠞꠍ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠕꠣꠇꠤ ꠀꠝꠤ ꠖꠝ ꠟꠅꠀꠁꠟꠣꠝ। ꠔꠣꠁꠞꠦ ꠍꠁꠔꠦ ꠖꠤꠟꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN20_7","002_20_7","GEN","20","7","7","ꠅꠈꠘ ꠔꠥꠝꠤ ꠔꠣꠘ ꠛꠤꠛꠤꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠚꠤꠞꠔ ꠖꠤꠟꠣꠅ। ꠔꠣꠁꠘ ꠄꠇꠎꠘ ꠘꠛꠤ। ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠛꠣ, ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠛ। ꠀꠞ ꠎꠥꠖꠤ ꠔꠣꠁꠞꠦ ꠚꠤꠞꠔ ꠘꠣ ꠖꠦꠅ, ꠔꠦ ꠎꠣꠘꠤꠟꠤꠅ, ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠢꠇꠟꠃ ꠘꠤꠌꠄ ꠝꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN20_8","002_20_8","GEN","20","8","8","ꠅꠃ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠚꠎꠞꠦ ꠃꠑꠤꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠅꠇꠟꠞꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠁꠟꠣ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠛꠦꠡꠤ ꠒꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN20_9","002_20_9","GEN","20","9","9","ꠛꠣꠖꠦ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠁꠔꠣ ꠇꠥꠘ ꠎꠣꠔꠞ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠟꠣ? ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠇꠤꠔꠣ ꠖꠥꠡ ꠇꠞꠍꠤ ꠎꠦꠘ, ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠀꠞ ꠀꠝꠣꠞ ꠛꠣꠖꠡꠣꠁꠞꠦ ꠅꠔ ꠛꠠ ꠉꠥꠘꠣꠞ ꠖꠣꠄꠄ ꠚꠣꠟꠣꠁꠟꠣ? ꠀꠙꠘꠦ ꠔ ꠀꠝꠣꠞ ꠟꠉꠦ ꠁꠔꠣ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠣꠝ ꠇꠞꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN20_10","002_20_10","GEN","20","10","10","ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠖꠦꠈꠤꠀ ꠁꠟꠣ ꠇꠣꠝ ꠇꠞꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("GN20_11","002_20_11","GEN","20","11","11","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠝꠘꠦ ꠇꠞꠍꠟꠣꠝ, ꠁ ꠎꠣꠉꠣꠞ ꠝꠣꠘꠡꠞ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠇꠥꠘꠥ ꠒꠞ-ꠜꠄ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠃꠞ ꠟꠣꠟꠌꠦ ꠢꠄꠔ ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN20_12","002_20_12","GEN","20","12","12","ꠀꠞ ꠔꠣꠁ ꠢꠣꠍꠣꠃ ꠀꠝꠣꠞ ꠛꠁꠘ ꠟꠣꠉꠦ, ꠇꠣꠞꠘ ꠔꠣꠁ ꠀꠝꠣꠞ ꠢꠣꠔꠘ ꠊꠞꠞ ꠛꠁꠘ, ꠀꠞ ꠅꠈꠘ ꠀꠝꠣꠞ ꠛꠃ। ");
INSERT INTO syls_vpl VALUES ("GN20_13","002_20_13","GEN","20","13","13","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞꠦ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤ ꠕꠘꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠔꠣꠁꠞꠦ ꠇꠁꠍꠟꠣꠝ, ‘ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠅꠃ ꠝꠣꠄꠀꠈꠣꠘ ꠇꠞꠤꠅ, ꠀꠝꠞꠣ ꠎꠦꠘꠅꠃ ꠎꠣꠁ ꠘꠣ ꠇꠦꠘꠦ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠇꠁꠀ ꠙꠞꠤꠌꠄ ꠖꠤꠅ।’ ” ");
INSERT INTO syls_vpl VALUES ("GN20_14","002_20_14","GEN","20","14","14","ꠛꠣꠖꠦ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠇꠔꠐꠣ ꠝꠦꠠꠣ-ꠉꠞꠥ, ꠛꠣꠘ꠆ꠖꠤ-ꠉꠥꠟꠣꠝ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠖꠤꠟꠣ ꠀꠞ ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞꠦꠅ ꠚꠤꠞꠔ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN20_15","002_20_15","GEN","20","15","15","ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠐꠣꠃ ꠀꠙꠘꠣꠞ ꠍꠣꠝꠘꠦ ꠙꠠꠤ ꠞꠁꠍꠦ, ꠔꠦ ꠀꠙꠘꠣꠞ ꠎꠦꠘꠅ ꠙꠍꠘ꠆ꠖ ꠅꠘꠅꠃ ꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN20_16","002_20_16","GEN","20","16","16","ꠔꠣꠁꠘ ꠍꠣꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠜꠣꠁꠞꠦ ꠄꠇ ꠀꠎꠣꠞ ꠞꠥꠙꠣꠞ ꠐꠦꠇꠣ ꠖꠤꠟꠣꠝ। ꠀꠞ ꠀꠙꠘꠣꠞ ꠁꠎ꠆ꠎꠔꠞ ꠢꠇꠟ ꠛꠤꠌꠣꠞꠞ ꠚꠄꠍꠣꠟꠣ ꠅꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("GN20_17","002_20_17","GEN","20","17","17","ꠛꠣꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠖꠥꠀ ꠇꠞꠟꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠀꠛꠤꠝꠣꠟꠤꠇ, ꠔꠣꠘ ꠛꠃ ꠀꠞ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤ ꠅꠇꠟꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠟꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠅ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN20_18","002_20_18","GEN","20","18","18","ꠇꠣꠞꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠀꠛꠤꠝꠣꠟꠤꠇꠞ ꠛꠣꠠꠤꠞ ꠢꠇꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠀ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_1","002_21_1","GEN","21","1","1","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠝꠥꠔꠣꠛꠦꠇ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_2","002_21_2","GEN","21","2","2","ꠀꠞ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠡꠝꠄꠇꠥꠞ ꠇꠕꠣ ꠇꠁꠍꠟꠣ, ꠢꠃ ꠡꠝꠄꠄꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN21_3","002_21_3","GEN","21","3","3","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠍꠣꠄꠞꠣꠞ ꠊꠞꠞ ꠔꠣꠘ ꠅꠃ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠁꠍꠢꠣꠇ ꠝꠣꠘꠤ, ꠀꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_4","002_21_4","GEN","21","4","4","ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠔ ꠔꠣꠁꠘ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_5","002_21_5","GEN","21","5","5","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠄꠇ-ꠡ ꠛꠍꠞꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN21_6","002_21_6","GEN","21","6","6","ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠄ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞ ꠝꠥꠈꠅ ꠀꠡꠤ ꠛꠣꠞ ꠇꠞꠟꠣ, ꠀꠞ ꠁꠔꠣ ꠎꠦ ꠢꠥꠘꠛ, ꠢꠦ-ꠅ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠡꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN21_7","002_21_7","GEN","21","7","7","ꠔꠣꠁꠘ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠍꠣꠄꠞꠣꠄ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠛꠥꠇꠥꠞ ꠖꠥꠗ ꠈꠣꠅꠀꠁꠛ, ꠁꠔꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠇꠦ ꠇꠁꠟ ꠅꠘꠦ? ꠀꠞ ꠅꠈꠘ ꠔ ꠅꠃ ꠛꠥꠠꠣ ꠛꠄꠅꠡꠅ, ꠀꠝꠣꠞ ꠙꠦꠐꠅ ꠔꠣꠘ ꠙꠥꠀ ꠙꠄꠖꠣ ꠅꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("GN21_8","002_21_8","GEN","21","8","8","ꠁꠍꠢꠣꠇ ꠛꠠ ꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠦꠖꠤꠘ ꠔꠣꠘꠦ ꠝꠣʼꠞ ꠖꠥꠗ ꠍꠣꠠꠣꠁꠟ ꠅꠁꠟ, ꠢꠃꠖꠤꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠄꠇ ꠛꠠ ꠝꠦꠎꠛꠣꠘꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_9","002_21_9","GEN","21","9","9","ꠀꠞ ꠝꠤꠡꠞꠤ ꠢꠣꠎꠦꠞꠣꠞ ꠙꠦꠐꠅ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠎꠦ ꠙꠥꠀ ꠅꠁꠍꠤꠟ, ꠍꠣꠄꠞꠣꠄ ꠖꠦꠈꠟꠣ ꠢꠦ ꠔꠣꠝꠡꠣ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("GN21_10","002_21_10","GEN","21","10","10","ꠅꠃ ꠔꠣꠁꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠙꠥꠀ ꠡꠢ ꠁ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠖꠦꠅ, ꠛꠣꠘ꠆ꠖꠤꠞ ꠙꠥꠀ ꠀꠝꠣꠞ ꠁꠍꠢꠣꠇꠞ ꠟꠉꠦ ꠅꠋꠡꠤꠖꠣꠞ ꠅꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN21_11","002_21_11","GEN","21","11","11","ꠙꠥꠀꠞ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠝꠘꠅ ꠈꠥꠛ ꠔꠇꠟꠤꠚ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_12","002_21_12","GEN","21","12","12","ꠅꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠀꠞ ꠔꠣꠁꠞ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠛꠦꠎꠣꠞ ꠅꠁꠅ ꠘꠣ। ꠍꠣꠄꠞꠣꠄ ꠎꠦꠟꠣ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠍꠦ ꠅꠃꠟꠣ ꠇꠞꠅ, ꠇꠣꠞꠘ ꠔꠥꠝꠣꠞ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦꠃ ꠔꠥꠝꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠇꠁꠀ ꠉꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN21_13","002_21_13","GEN","21","13","13","ꠀꠞ ꠁ ꠛꠣꠘ꠆ꠖꠤꠞ ꠔꠞꠚꠣ ꠙꠥꠀ ꠕꠣꠇꠤꠅ ꠀꠝꠤ ꠄꠇꠐꠣ ꠎꠣꠔꠤ ꠔꠂꠀꠞ ꠇꠞꠝꠥ, ꠇꠣꠞꠘ ꠢꠦ-ꠅ ꠔ ꠔꠥꠝꠣꠞ ꠀꠅꠟꠣꠖ।” ");
INSERT INTO syls_vpl VALUES ("GN21_14","002_21_14","GEN","21","14","14","ꠅꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠀꠉꠥꠀꠘ ꠃꠑꠤꠀ ꠇꠤꠍꠥ ꠞꠥꠐꠤ ꠀꠞ ꠙꠣꠘꠤ ꠜꠞꠣ ꠄꠇꠐꠣ ꠌꠣꠝꠠꠣꠞ ꠕꠟꠤ ꠢꠣꠎꠣꠁꠀ ꠢꠣꠎꠦꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠅ ꠔꠥꠟꠤꠀ ꠖꠤꠀ, ꠙꠥꠀꠉꠥꠞꠦ ꠔꠣꠁꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠛꠤꠖꠣꠄ ꠇꠞꠟꠣ। ꠢꠤꠘ ꠕꠘꠦ ꠛꠣꠞ ꠅꠁꠀ ꠢꠣꠎꠦꠞꠣꠄ ꠛꠦꠞ-ꠡꠦꠛꠣꠞ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠌꠇ꠆ꠇꠞ ꠖꠤꠔꠣ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_15","002_21_15","GEN","21","15","15","ꠕꠟꠤꠞ ꠙꠣꠘꠤ ꠡꠦꠡ ꠅꠁꠉꠦꠟꠦ ꠔꠣꠁꠘ ꠙꠥꠀꠞꠦ ꠄꠇꠐꠣ ꠎꠋꠟꠣꠞ ꠔꠟꠦ ꠢꠥꠔꠣꠁꠀ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_16","002_21_16","GEN","21","16","16","ꠀꠞ ꠄꠇ ꠒꠣꠇꠞ ꠙꠞꠤꠝꠣꠘ ꠖꠥꠞꠁ ꠉꠤꠀ ꠔꠣꠁꠘ ꠛꠁꠞꠁꠟꠣ। “ꠙꠥꠀꠞ ꠝꠃꠔ ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠌꠃꠈꠦ ꠘꠣ ꠖꠦꠈꠤ,” ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠀ, ꠔꠣꠁꠘ ꠢꠘꠅ ꠛꠁꠀꠃ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_17","002_21_17","GEN","21","17","17","ꠙꠥꠀꠉꠥꠞ ꠇꠣꠘ꠆ꠖꠘ ꠀꠟ꠆ꠟꠣꠄ ꠢꠥꠘꠟꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠍꠝꠣꠘ ꠕꠘꠦ ꠒꠣꠇꠤꠀ ꠢꠣꠎꠦꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠣꠎꠦꠞꠣ, ꠅ ꠢꠣꠎꠦꠞꠣ, ꠔꠥꠝꠣꠞ ꠇꠤꠔꠣ ꠅꠁꠍꠦ? ꠒꠞꠣꠁꠅ ꠘꠣ, ꠙꠥꠀꠉꠥ ꠎꠦꠘꠅ ꠀꠍꠦ, ꠢꠘ ꠕꠣꠇꠤꠃ ꠔꠣꠞ ꠇꠣꠘ꠆ꠖꠘ ꠀꠟ꠆ꠟꠣꠄ ꠢꠥꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN21_18","002_21_18","GEN","21","18","18","ꠔꠥꠝꠤ ꠃꠑꠤꠀ ꠙꠥꠀꠉꠥꠞ ꠀꠔꠅ ꠗꠞꠅ, ꠀꠝꠤ ꠔꠣꠞꠦꠖꠤ ꠄꠇ ꠛꠤꠞꠣꠐ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN21_19","002_21_19","GEN","21","19","19","ꠅꠃ ꠀꠟ꠆ꠟꠣꠄ ꠢꠣꠎꠦꠞꠣꠞ ꠌꠃꠈ ꠈꠥꠟꠤꠀ ꠖꠤꠟꠣ, ꠀꠞ ꠔꠣꠁꠘ ꠄꠇ ꠇꠥꠀ ꠖꠦꠈꠟꠣ। ꠢꠤ ꠇꠥꠀ ꠕꠘꠦ ꠌꠣꠝꠠꠣꠞ ꠕꠟꠤꠔ ꠙꠣꠘꠤ ꠜꠞꠤ ꠀꠘꠤꠀ ꠙꠥꠀꠞꠦ ꠈꠣꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_20","002_21_20","GEN","21","20","20","ꠀꠟ꠆ꠟꠣꠄ ꠢꠃ ꠙꠥꠀꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠟꠣ। ꠢꠦ ꠛꠠ ꠅꠁꠟ, ꠀꠞ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠕꠣꠇꠤꠀ ꠔꠤꠞ-ꠗꠘꠥꠇ ꠌꠣꠟꠣꠘꠤꠞ ꠃꠡ꠆ꠔꠣꠖ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN21_21","002_21_21","GEN","21","21","21","ꠢꠦ ꠚꠣꠞꠣꠘ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠕꠣꠇꠔ। ꠔꠣꠞ ꠝꠣʼꠄ ꠝꠤꠡꠞꠞ ꠄꠇ ꠙꠥꠠꠤꠞꠦ ꠀꠘꠤꠀ ꠔꠣꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_22","002_21_22","GEN","21","22","22","ꠢꠃ ꠡꠝꠄ ꠀꠛꠤꠝꠣꠟꠤꠇ ꠀꠞ ꠔꠣꠘ ꠡꠦꠘꠣꠙꠔꠤ ꠚꠤꠈꠥꠟꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠎꠦꠔꠣꠃ ꠇꠞꠂꠘ, ꠅꠔꠣꠔꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN21_23","002_21_23","GEN","21","23","23","ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠀꠙꠘꠦ ꠅꠈꠘ ꠅꠘꠅ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞ ꠛꠣ ꠀꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠟꠉꠦ, ꠀꠙꠘꠦ ꠇꠥꠘꠥ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠔꠣ ꠘꠣꠄ। ꠀꠞ ꠀꠝꠤ ꠎꠦꠟꠣ ꠀꠙꠘꠣꠞꠦ ꠖꠄꠀ ꠖꠦꠈꠣꠁꠍꠤ, ꠀꠙꠘꠦꠅ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠞ ꠀꠙꠘꠣꠞ ꠝꠥꠍꠣꠚꠤꠞꠤꠞ ꠎꠣꠉꠣ, ꠁ ꠖꠦꠡꠞ ꠟꠉꠦ ꠅꠃꠟꠣ ꠖꠄꠀꠞ ꠘꠎꠞ ꠞꠣꠈꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN21_24","002_21_24","GEN","21","24","24","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠇꠍꠝ ꠇꠞꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN21_25","002_21_25","GEN","21","25","25","ꠀꠞ ꠀꠛꠤꠝꠣꠟꠤꠇꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠄꠇꠐꠣ ꠙꠣꠘꠤꠞ ꠇꠥꠀ ꠎꠥꠞꠦ ꠘꠤꠍꠤꠟꠉꠤ ꠇꠞꠤ, ꠔꠣꠁꠘ ꠘꠣꠟꠤꠡ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_26","002_21_26","GEN","21","26","26","ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠁꠔꠣ ꠇꠣꠝ ꠇꠦ ꠇꠞꠍꠦ ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ ꠘꠣ। ꠀꠙꠘꠦꠅ ꠀꠝꠣꠞꠦ ꠁꠔꠣ ꠇꠁꠍꠂꠘ ꠘꠣ, ꠀꠁꠎꠃ ꠀꠝꠤ ꠁꠇꠐꠣ ꠢꠥꠘꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN21_27","002_21_27","GEN","21","27","27","ꠛꠣꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠤꠍꠥ ꠝꠦꠠꠣ ꠀꠞ ꠉꠞꠥ ꠀꠘꠤꠀ ꠀꠛꠤꠝꠣꠟꠤꠇꠞꠦ ꠖꠤꠟꠣ ꠀꠞ ꠖꠥꠁꠅꠎꠘꠦ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_28","002_21_28","GEN","21","28","28","ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠙꠣꠟ ꠕꠘꠦ ꠡꠣꠔꠉꠥ ꠝꠦꠠꠤ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠟꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_29","002_21_29","GEN","21","29","29","ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠔꠣꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁ ꠝꠦꠠꠤ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠡꠣꠔꠉꠥ ꠀꠟꠉꠣ ꠇꠞꠣꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("GN21_30","002_21_30","GEN","21","30","30","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠅꠉꠥꠁꠘ꠆ꠔꠞꠦ ꠘꠦꠃꠇ꠆ꠇꠣ। ꠁ ꠇꠥꠀꠐꠣ ꠎꠦ ꠀꠝꠤ ꠈꠥꠖꠍꠤ ꠁꠇꠐꠣ ꠅꠁꠟ ꠔꠣꠞ ꠙꠞꠝꠣꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN21_31","002_21_31","GEN","21","31","31","ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠛꠦꠞ-ꠡꠦꠛꠣ ꠝꠣꠘꠤ, ꠇꠍꠝꠞ ꠇꠥꠀ, ꠅꠘꠅꠃ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠎꠘꠦ ꠇꠍꠝ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_32","002_21_32","GEN","21","32","32","ꠔꠣꠞꠣ ꠛꠦꠞ-ꠡꠦꠛꠣꠔ ꠅꠃ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠣꠞ ꠛꠣꠖꠦ, ꠀꠛꠤꠝꠣꠟꠤꠇ ꠀꠞ ꠔꠣꠘ ꠡꠦꠘꠣꠙꠔꠤ ꠚꠤꠈꠥꠟ ꠃꠑꠤꠀ ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠚꠤꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN21_33","002_21_33","GEN","21","33","33","ꠛꠣꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠛꠦꠞ-ꠡꠦꠛꠣꠔ ꠄꠇꠐꠣ ꠏꠣꠃ ꠉꠣꠍ ꠞꠥꠁꠟꠣ, ꠀꠞ ꠎꠦ ꠝꠣꠛꠥꠖꠞ ꠡꠥꠞꠥꠅ ꠘꠣꠄ ꠡꠦꠡꠅ ꠘꠣꠄ, ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN21_34","002_21_34","GEN","21","34","34","ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠛꠃꠔ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_1","002_22_1","GEN","22","1","1","ꠁ ꠊꠐꠘꠣꠞ ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠄꠇ ꠙꠞꠤꠇ꠆ꠇꠣ ꠟꠁꠟꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠒꠣꠇ ꠖꠤꠟꠣ, “ꠁꠛ꠆ꠞꠣꠢꠤꠝ!” ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅꠃꠘꠥ ꠀꠝꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN22_2","002_22_2","GEN","22","2","2","ꠝꠣꠛꠥꠖꠦ ꠚꠞꠝꠣꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠙꠥꠀꠞꠦ, ꠎꠣꠞꠦ ꠔꠥꠝꠤ ꠅꠔ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ, ꠢꠃ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠙꠥꠔ ꠁꠍꠢꠣꠇꠞꠦ ꠟꠁꠀ ꠔꠥꠝꠤ ꠝꠥꠞꠤꠀ ꠄꠟꠣꠇꠣꠔ ꠎꠣꠅ। ꠢꠈꠣꠘꠅ ꠎꠦ ꠙꠣꠠꠞ ꠇꠕꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠝꠥ, ꠄꠞ ꠃꠙꠞꠦ ꠔꠣꠞꠦ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN22_3","002_22_3","GEN","22","3","3","ꠔꠦꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠚꠎꠞꠦ ꠃꠑꠤꠀ ꠉꠣꠗꠣꠞ ꠙꠤꠑꠤꠔ ꠉꠖ꠆ꠖꠤ ꠟꠣꠉꠣꠁꠀ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠢꠣꠇ, ꠖꠥꠁꠎꠘ ꠉꠥꠟꠣꠝ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠟꠣꠇꠠꠤ ꠇꠣꠐꠤꠀ ꠟꠁꠀ, ꠎꠦ ꠎꠣꠉꠣꠞ ꠇꠕꠣ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠍꠟꠣ, ꠢꠛꠣꠄꠖꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_4","002_22_4","GEN","22","4","4","ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠌꠣꠁꠔꠦꠃ ꠖꠥꠞꠁ ꠕꠣꠇꠤ ꠢꠃ ꠎꠣꠉꠣꠈꠣꠘ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_5","002_22_5","GEN","22","5","5","ꠅꠃ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠉꠣꠗꠣꠐꠣ ꠟꠁꠀ ꠅꠘꠅ ꠃꠛꠣꠅ, ꠀꠝꠤ ꠀꠞ ꠀꠝꠣꠞ ꠙꠥꠀ ꠢꠘꠅ ꠉꠤꠀ ꠄꠛꠣꠖꠔꠤ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN22_6","002_22_6","GEN","22","6","6","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠇꠠꠤꠞ ꠀꠐꠣ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠇꠣꠘ꠆ꠖꠅ ꠔꠥꠟꠤꠀ ꠖꠤꠀ ꠘꠤꠎꠦ ꠀꠉꠥꠁꠘꠞ ꠙꠣꠔꠤꠟ ꠀꠞ ꠍꠥꠞꠤ ꠟꠁꠀ, ꠖꠥꠁꠅ ꠎꠘꠦ ꠍꠣꠝꠘꠞ ꠛꠣꠄ ꠀꠉꠥꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_7","002_22_7","GEN","22","7","7","ꠅꠃ ꠁꠍꠢꠣꠇꠦ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠇꠤꠔꠣꠞꠦ ꠛꠣꠚ ꠇꠅ?” ꠁꠍꠢꠣꠇꠦ ꠇꠁꠟꠣ, “ꠁꠘꠅ ꠔ ꠟꠣꠇꠠꠤ ꠀꠞ ꠀꠉꠥꠁꠘ ꠀꠍꠦ, ꠔꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠀꠁ?” ");
INSERT INTO syls_vpl VALUES ("GN22_8","002_22_8","GEN","22","8","8","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠛꠣꠛꠣꠞꠦ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠎꠥꠉꠣꠁꠛꠣ।” ꠅꠔꠣ ꠝꠣꠔꠔꠦ ꠝꠣꠔꠔꠦ ꠔꠣꠞꠣ ꠀꠉꠥꠀꠁ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_9","002_22_9","GEN","22","9","9","ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖꠞ ꠎꠣꠉꠣꠔ ꠙꠃꠍꠤꠀ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠀ, ꠟꠣꠇꠠꠤ ꠢꠣꠎꠣꠁꠟꠣ। ꠛꠣꠖꠦ ꠘꠤꠎꠞ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠅꠃ ꠖꠣꠞꠥꠞ ꠃꠙꠞꠦ ꠢꠥꠔꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_10","002_22_10","GEN","22","10","10","ꠀꠞ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠙꠥꠀꠞꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠍꠥꠞꠤ ꠀꠔꠅ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_11","002_22_11","GEN","22","11","11","ꠅꠃ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠍꠝꠣꠘ ꠕꠘꠦ ꠔꠣꠘꠦ ꠒꠣꠇ ꠖꠤꠟꠣ, “ꠁꠛ꠆ꠞꠣꠢꠤꠝ! ꠅ ꠁꠛ꠆ꠞꠣꠢꠤꠝ!” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠃꠘꠥ ꠀꠝꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN22_12","002_22_12","GEN","22","12","12","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠙꠥꠀꠉꠥꠞ ꠛꠣꠄ ꠔꠥꠝꠣꠞ ꠀꠔ ꠔꠥꠟꠤꠅ ꠘꠣ, ꠔꠣꠞꠦ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠤ ꠎꠦꠘ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠅ ꠁꠔꠣ ꠛꠥꠎꠣ ꠉꠦꠍꠦ, ꠇꠣꠞꠘ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠙꠥꠀ, ꠔꠥꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠙꠥꠀ ꠖꠣꠘ ꠇꠞꠔꠦꠅ ꠘꠣ-ꠈꠥꠡ ꠅꠁꠍ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN22_13","002_22_13","GEN","22","13","13","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠌꠃꠈ ꠔꠥꠟꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠂꠘ, ꠔꠣꠘ ꠈꠞꠦ ꠄꠇꠐꠣ ꠖꠥꠝ꠆ꠛꠣ ꠀꠞ ꠔꠣꠞ ꠢꠤꠋ ꠎꠋꠉꠟꠞ ꠝꠣꠎꠦ ꠀꠐꠇꠤ ꠞꠁꠍꠦ। ꠅꠃ ꠔꠣꠁꠘ ꠉꠤꠀ ꠖꠥꠝ꠆ꠛꠣꠐꠣ ꠀꠘꠤꠀ, ꠘꠤꠎꠞ ꠙꠥꠀꠞ ꠛꠖꠟꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_14","002_22_14","GEN","22","14","14","ꠔꠣꠁꠘ ꠢꠤ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠁꠀꠅꠄꠢ-ꠎꠤꠞꠤꠢ ꠝꠣꠘꠤ, ꠝꠣꠛꠥꠖꠦ ꠎꠥꠉꠣꠁꠘ। ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘꠅ ꠝꠣꠘꠡꠦ ꠇꠂꠘ, “ꠝꠣꠛꠥꠖꠞ ꠙꠣꠠꠅ ꠎꠥꠉꠣꠁꠟ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN22_15","002_22_15","GEN","22","15","15","ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠍꠝꠣꠘ ꠕꠘꠦ ꠢꠤꠞꠛꠣꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN22_16","002_22_16","GEN","22","16","16","“ꠢꠥꠘꠅ, ꠝꠣꠛꠥꠖꠦ ꠇꠁꠞꠣ, ꠔꠥꠝꠤ ꠅꠃꠟꠣ ꠇꠞꠟꠣꠄ, ꠔꠥꠝꠣꠞ ꠙꠥꠀꠞꠦ, ꠔꠥꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠙꠥꠀꠞꠦ ꠖꠣꠘ ꠇꠞꠔꠦꠅ ꠘꠣꠞꠣꠎ ꠅꠁꠟꠣꠄ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠍꠝ ꠇꠞꠤꠀ ꠇꠁꠀꠞ, ");
INSERT INTO syls_vpl VALUES ("GN22_17","002_22_17","GEN","22","17","17","ꠀꠝꠤ ꠘꠤꠌꠄ ꠔꠥꠝꠣꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠝꠥ, ꠔꠥꠝꠣꠞ ꠛꠋꠡꠞꠦ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣ ꠀꠞ ꠖꠞꠤꠀꠞ ꠌꠞꠞ ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠤꠡꠣꠛ ꠇꠞꠝꠥ। ꠔꠥꠝꠣꠞ ꠛꠋꠡꠄ ꠔꠣꠞꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠈꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_18","002_22_18","GEN","22","18","18","ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠋꠡꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠛꠞꠇꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛꠣ। ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠍ।” ");
INSERT INTO syls_vpl VALUES ("GN22_19","002_22_19","GEN","22","19","19","ꠛꠣꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ, ꠀꠞ ꠔꠣꠞꠣ ꠄꠇꠟꠉꠦ ꠛꠦꠞ-ꠡꠦꠛꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠉꠦꠟꠣ। ꠅꠃ ꠎꠣꠉꠣꠔꠃ ꠔꠣꠁꠘ ꠛꠡꠔꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_20","002_22_20","GEN","22","20","20","ꠁ ꠊꠐꠘꠣꠞ ꠛꠣꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠈꠛꠞ ꠙꠣꠁꠟꠣ, ꠔꠣꠘ ꠜꠣꠁ ꠘꠣꠢꠥꠞꠞ ꠛꠤꠛꠤ ꠝꠤꠟꠇꠣꠞ ꠇꠄꠉꠥ ꠙꠥꠀꠂꠘ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN22_21","002_22_21","GEN","22","21","21","ꠄꠞ ꠛꠠ ꠙꠥꠀꠞ ꠘꠣꠝ ꠀꠃꠎ, ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠘꠣꠝ ꠛꠥꠎ, ꠀꠞ ꠅꠞꠣꠝꠞ ꠛꠣꠚ ꠇꠝꠥꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("GN22_22","002_22_22","GEN","22","22","22","ꠄꠞꠛꠣꠖꠦ ꠇꠦꠍꠖ, ꠢꠡꠅ, ꠙꠤꠟꠖꠡ, ꠎꠤꠖꠟꠚ ꠀꠞ ꠛꠕꠥꠄꠟ। ꠛꠕꠥꠄꠟꠞ ꠙꠥꠠꠤꠞ ꠘꠣꠝ ꠞꠦꠛꠦꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN22_23","002_22_23","GEN","22","23","23","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠜꠣꠁ ꠘꠣꠢꠥꠞꠞ ꠛꠤꠛꠤ ꠝꠤꠟꠇꠣꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠤ ꠁ ꠀꠐꠎꠘ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN22_24","002_22_24","GEN","22","24","24","ꠘꠣꠢꠥꠞꠞ ꠄꠇ ꠢꠣꠋꠉꠣꠞ ꠛꠃ ꠀꠍꠤꠟ, ꠔꠣꠁꠞ ꠘꠣꠝ ꠞꠃꠝꠣ। ꠔꠣꠁꠞ ꠙꠦꠐꠅ ꠐꠦꠛꠢ, ꠉꠢꠝ, ꠔꠢꠡ ꠀꠞ ꠝꠣꠈꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN23_1","002_23_1","GEN","23","1","1","ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣ ꠄꠇ-ꠡ ꠡꠣꠔꠣꠁꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠟꠣ; ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠦ ꠅꠔꠖꠤꠘꠞ ꠢꠣꠄꠀꠔꠤ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN23_2","002_23_2","GEN","23","2","2","ꠛꠣꠖꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠇꠤꠞꠤꠅꠔ-ꠅꠞ꠆ꠛ ꠝꠣꠘꠤ ꠢꠦꠛꠞꠘꠅ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ। ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠔꠣꠘ ꠟꠣꠉꠤ ꠛꠃꠔ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN23_3","002_23_3","GEN","23","3","3","ꠢꠦꠡꠦ ꠔꠣꠘ ꠝꠥꠞ꠆ꠖꠣ ꠛꠤꠛꠤꠞ ꠉꠦꠍ ꠕꠘꠦ ꠢꠞꠤꠀ ꠉꠤꠀ ꠢꠃ ꠖꠦꠡꠞ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN23_4","002_23_4","GEN","23","4","4","“ꠀꠝꠤ ꠔ ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠁꠀ ꠀꠙꠘꠣꠞꠣꠞ ꠅꠘꠅ ꠞꠁꠀꠞ। ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠇꠛꠞꠡ꠆ꠕꠣꠘ ꠛꠣꠘꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠕꠥꠠꠣ ꠎꠝꠤ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠘꠦ ꠀꠝꠣꠞ ꠝꠥꠞ꠆ꠖꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN23_5","002_23_5","GEN","23","5","5","ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN23_6","002_23_6","GEN","23","6","6","“ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠃꠇ꠆ꠇꠣ। ꠀꠙꠘꠦ ꠔ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠛꠥꠎꠥꠞ꠆ꠉ। ꠀꠝꠞꠣꠞ ꠉꠥꠞꠥꠡ꠆ꠕꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠘꠅ ꠙꠍꠘ꠆ꠖ ꠅꠄ, ꠅꠘꠅꠃ ꠀꠙꠘꠣꠞ ꠝꠥꠞ꠆ꠖꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠇꠦꠃ-ꠃ ꠘꠤꠎꠞ ꠛꠣꠘꠣꠁꠟ ꠇꠄꠛꠞ ꠍꠣꠠꠔꠦ ꠅꠝꠔ ꠇꠞꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN23_7","002_23_7","GEN","23","7","7","ꠅꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠃꠛꠣꠁꠀ ꠢꠤꠘꠞ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠀ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN23_8","002_23_8","GEN","23","8","8","“ꠀꠝꠣꠞ ꠛꠤꠛꠤꠞꠦ ꠁꠘꠅ ꠖꠣꠚꠘ ꠇꠞꠣꠔ ꠎꠥꠖꠤ ꠀꠙꠘꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠅꠝꠔ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠖꠄꠀ ꠇꠞꠤ ꠀꠝꠣꠞ ꠀꠞꠎꠤꠈꠣꠘ ꠢꠥꠘꠃꠇ꠆ꠇꠣ। ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞ ꠅꠁꠀ ꠡꠥꠢꠞꠞ ꠙꠥꠀ ꠁꠚ꠆ꠞꠥꠘꠞꠦ ꠇꠃꠇ꠆ꠇꠣ, ");
INSERT INTO syls_vpl VALUES ("GN23_9","002_23_9","GEN","23","9","9","ꠔꠣꠘ ꠎꠝꠤꠘꠞ ꠢꠦꠡ ꠝꠣꠕꠣꠔ ꠝꠇꠙꠦꠟꠣ ꠎꠦ ꠉꠥꠢꠣ ꠀꠍꠦ, ꠅꠈꠣꠘꠔꠣ ꠎꠦꠘꠥ ꠇꠛꠞꠡ꠆ꠕꠣꠘ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠙꠥꠞꠣ ꠖꠣꠝ ꠟꠁꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠛꠦꠌꠤꠟꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN23_10","002_23_10","GEN","23","10","10","ꠀꠞꠅ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠁ ꠡꠝꠄ ꠁꠚ꠆ꠞꠥꠘꠅ ꠢꠘꠅ ꠛꠅꠀꠔ ꠀꠍꠟꠣ। ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠣꠔꠞ ꠎꠥꠀꠙꠦ ꠢꠃ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠁꠚ꠆ꠞꠥꠘꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN23_11","002_23_11","GEN","23","11","11","“ꠘꠣ, ꠘꠣ, ꠀꠙꠘꠦ ꠖꠄꠀ ꠇꠞꠤ ꠀꠝꠣꠞ ꠝꠣꠔꠈꠣꠘ ꠢꠥꠘꠃꠇ꠆ꠇꠣ। ꠀꠝꠤ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦꠃ ꠁ ꠎꠝꠤ ꠀꠞ ꠉꠥꠢꠣ ꠀꠙꠘꠣꠞꠦ ꠖꠤꠟꠣꠁꠟꠣꠝ, ꠀꠙꠘꠣꠞ ꠝꠥꠞ꠆ꠖꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠤꠟꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN23_12","002_23_12","GEN","23","12","12","ꠔꠦꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠢꠤꠞꠛꠣꠞ ꠢꠤꠘꠞ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("GN23_13","002_23_13","GEN","23","13","13","ꠢꠤ ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟꠞꠦ ꠢꠥꠘꠣꠁꠀ ꠁꠚ꠆ꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠎꠝꠤꠈꠣꠘꠞ ꠖꠣꠝ ꠀꠝꠤ ꠖꠤꠟꠣꠁ। ꠀꠙꠘꠦꠅ ꠎꠝꠤꠈꠣꠘꠞ ꠖꠣꠝ ꠘꠦꠃꠇ꠆ꠇꠣꠉꠤ, ꠛꠣꠖꠦ ꠀꠝꠣꠞ ꠝꠥꠞ꠆ꠖꠣꠞꠦ ꠅꠘꠅ ꠖꠣꠚꠘ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN23_14","002_23_14","GEN","23","14","14","ꠁꠚ꠆ꠞꠥꠘꠦ ꠔꠣꠘꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN23_15","002_23_15","GEN","23","15","15","“ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠅꠃ ꠎꠝꠤꠈꠣꠘꠞ ꠖꠣꠝ ꠅꠁꠟꠉꠤ ꠌꠣꠁꠞ-ꠡ ꠔꠟꠣ ꠞꠥꠙꠣ, ꠔꠦ ꠀꠙꠘꠣꠞ-ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠄ। ꠀꠙꠘꠣꠞ ꠝꠥꠞ꠆ꠖꠣꠞꠦ ꠇꠄꠛꠞ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN23_16","002_23_16","GEN","23","16","16","ꠅꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠁꠚ꠆ꠞꠥꠘꠞ ꠇꠕꠣ ꠝꠣꠘꠤꠀ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠁꠘ, ꠁꠚ꠆ꠞꠥꠘꠞ ꠌꠣꠅꠀ ꠖꠣꠝ ꠝꠣꠚꠤꠇ, ꠙꠣꠁꠇꠣꠞꠤ ꠝꠣꠙꠦ ꠌꠣꠁꠞ-ꠡ ꠔꠟꠣ ꠞꠥꠙꠣ ꠔꠣꠘꠞꠦ ꠝꠣꠙꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN23_17","002_23_17","GEN","23","17","17","ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠝ꠆ꠞꠤ ꠐꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠝꠇꠙꠦꠟꠣꠔ ꠁꠚ꠆ꠞꠥꠘꠞ ꠎꠦ ꠎꠝꠤꠘ ꠀꠍꠤꠟ ꠢꠃ ꠎꠝꠤꠘ ꠀꠞ ꠢꠘꠞ ꠉꠥꠢꠣ ꠀꠞ ꠎꠝꠤꠘꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠎꠔ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤ ꠀꠍꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("GN23_18","002_23_18","GEN","23","18","18","ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠢꠤꠘꠞ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟ ꠀꠞ ꠐꠣꠃꠘꠞ ꠝꠥꠈꠞ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠣꠟꠤꠇꠣꠘꠣꠄ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN23_19","002_23_19","GEN","23","19","19","ꠛꠣꠖꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠝꠝ꠆ꠞꠤ ꠐꠣꠃꠘ ꠛꠣ ꠢꠦꠛꠞꠘꠞ ꠝꠇꠙꠦꠟꠣꠞ ꠉꠥꠢꠣꠔ ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN23_20","002_23_20","GEN","23","20","20","ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠇꠙꠦꠟꠣꠞ ꠅꠃ ꠉꠥꠢꠣ ꠡꠢ ꠀꠡ꠆ꠔꠣ ꠎꠝꠤꠘꠈꠣꠘ ꠉꠥꠞꠥꠡ꠆ꠕꠣꠘꠞ ꠟꠣꠉꠤ, ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞ ꠀꠔ ꠕꠘꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠔꠅ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN24_1","002_24_1","GEN","24","1","1","ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠁ ꠡꠝꠄ ꠈꠥꠛ ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠎꠣꠅꠀꠉꠤꠞ ꠙꠕꠤ ꠅꠁꠉꠦꠍꠂꠘ। ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠢꠇꠟꠛꠣꠄ ꠕꠘꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_2","002_24_2","GEN","24","2","2","ꠀꠞ ꠔꠣꠘ ꠈꠣꠍ ꠉꠥꠟꠣꠝ, ꠛꠣꠠꠤꠞ ꠙꠥꠞꠣꠘ ꠎꠦ ꠉꠥꠟꠣꠝꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠢꠇꠟꠔꠣꠞ ꠜꠣꠞ ꠖꠦꠅꠀ ꠀꠍꠤꠟ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠔꠈꠣꠘ ꠀꠝꠣꠞ ꠃꠞꠣꠔꠞ ꠔꠟꠦ ꠢꠣꠞꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("GN24_3","002_24_3","GEN","24","3","3","ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠝꠣꠟꠤꠇ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠣꠁꠀꠞ, ꠀꠝꠤ ꠎꠦ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠕꠣꠇꠤꠀꠞ, ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠀꠝꠣꠞ ꠙꠥꠀꠞ ꠛꠃ ꠛꠣꠘꠣꠁꠀ ꠔꠥꠝꠤ ꠀꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_4","002_24_4","GEN","24","4","4","ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠖꠦꠡꠅ ꠉꠤꠀ, ꠀꠝꠣꠞ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠉꠥ ꠇꠁꠘꠣ ꠌꠣꠁꠀ ꠀꠘꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN24_5","002_24_5","GEN","24","5","5","ꠅꠃ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠄ ꠀꠝꠣꠞ ꠟꠉꠦ ꠁ ꠖꠦꠡꠅ ꠀꠁꠔꠦ ꠞꠣꠎꠤ ꠘꠣ ꠅꠁꠘ, ꠔꠣꠁꠟꠦ ꠎꠦ ꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠀꠙꠘꠦ ꠀꠁꠍꠂꠘ, ꠀꠙꠘꠣꠞ ꠙꠥꠀꠞꠦ ꠀꠝꠤ ꠢꠘꠅ ꠟꠁꠀ ꠎꠣꠁꠔꠣꠝ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN24_6","002_24_6","GEN","24","6","6","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠈꠛꠞꠖꠣꠞ! ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠙꠥꠀꠞꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠢꠤꠘꠅ ꠟꠁꠀ ꠎꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_7","002_24_7","GEN","24","7","7","ꠎꠦ ꠀꠍꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ, ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤ ꠀꠞ ꠎꠘꠝ ꠝꠣꠐꠤ ꠕꠘꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠣꠔ-ꠍꠅꠀꠟ ꠇꠞꠤ ꠇꠍꠝ ꠇꠞꠤꠀ ꠇꠁꠍꠂꠘ, ꠁ ꠖꠦꠡꠈꠣꠘ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠖꠤꠛꠣ। ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞ ꠀꠉꠦꠃ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠢꠘꠅ ꠙꠣꠑꠣꠁꠛꠣ, ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠢꠘ ꠕꠘꠦ ꠄꠉꠥ ꠇꠁꠘꠣ ꠀꠘꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("GN24_8","002_24_8","GEN","24","8","8","ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠄ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠁꠔꠦ ꠞꠣꠎꠤ ꠘꠣ ꠅꠄ, ꠔꠦ ꠀꠝꠣꠞ ꠁ ꠇꠍꠝ ꠕꠣꠇꠤ ꠔꠥꠝꠤ ꠈꠣꠟꠣꠍ; ꠔꠣ-ꠅ ꠀꠝꠣꠞ ꠙꠥꠀꠞꠦ ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘꠃ ꠢꠤꠘꠅ ꠟꠁꠀ ꠎꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN24_9","002_24_9","GEN","24","9","9","ꠅꠃ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠔꠣꠘ ꠝꠥꠘꠤꠛ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠃꠞꠣꠔꠞ ꠔꠟꠦ ꠀꠔ ꠢꠣꠞꠣꠁꠀ ꠅꠃꠟꠣ ꠇꠍꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_10","002_24_10","GEN","24","10","10","ꠛꠣꠖꠦ ꠢꠃ ꠉꠥꠟꠣꠝꠦ ꠔꠣꠘ ꠝꠥꠘꠤꠛꠞ ꠃꠐꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠖꠡꠐꠣ ꠃꠐ ꠟꠁꠟꠣ। ꠀꠞ ꠝꠥꠘꠤꠛꠞ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠎꠤꠘꠤꠡ ꠅꠇꠟ ꠟꠁꠀ, ꠅꠞꠣꠝ-ꠘꠢꠞꠄꠁꠝ ꠖꠦꠡꠞ ꠎꠦꠘꠅ ꠘꠣꠢꠥꠞ ꠕꠣꠇꠔꠣ ꠢꠛꠣꠄꠖꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_11","002_24_11","GEN","24","11","11","ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠎꠦꠛꠟꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠙꠣꠘꠤ ꠀꠘꠣꠔ ꠛꠣꠞ ꠅꠁꠘ, ꠅꠃ ꠡꠝꠄ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠄꠇ ꠇꠥꠀꠞ ꠇꠣꠍꠣꠔ ꠔꠣꠘ ꠃꠐ ꠅꠇꠟꠞꠦ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_12","002_24_12","GEN","24","12","12","ꠕꠁꠀ ꠅꠃ ꠖꠥꠀ ꠇꠞꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠞꠎ ꠇꠞꠤ, ꠀꠁꠎ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠇꠣꠝꠤꠀꠛꠤ ꠎꠣꠁꠞ ꠇꠞꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("GN24_13","002_24_13","GEN","24","13","13","ꠖꠦꠈꠅ, ꠁ ꠐꠣꠃꠘꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠙꠣꠘꠤ ꠘꠦꠅꠀꠔ ꠀꠁꠞꠣ ꠀꠞ ꠀꠝꠤ ꠁꠘꠅ ꠇꠥꠀꠞ ꠇꠣꠍꠣꠔ ꠃꠛꠣꠁ ꠞꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN24_14","002_24_14","GEN","24","14","14","ꠔꠦ ꠅꠃ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠎꠣꠞꠦ ꠇꠁꠝꠥ, ‘ꠀꠙꠘꠣꠞ ꠈꠂꠟꠣ ꠟꠣꠝꠣꠁꠀ ꠀꠝꠣꠞꠦ ꠕꠥꠠꠣ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠃꠇ꠆ꠇꠣ’, ꠄꠞ ꠎꠥꠀꠙꠦ ꠎꠥꠖꠤ ꠢꠃ ꠙꠥꠠꠤꠄ ꠇꠂꠘ, ‘ꠀꠙꠘꠦ ꠙꠣꠘꠤ ꠈꠣꠃꠇ꠆ꠇꠣ ꠀꠞ ꠀꠙꠘꠣꠞ ꠃꠐ ꠅꠇꠟꠞꠦꠅ ꠀꠝꠤ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠝꠥ’ ꠔꠣꠁꠟꠦ ꠅꠃ ꠙꠥꠠꠤꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠁꠍꠢꠣꠇꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠙꠍꠘ꠆ꠖꠞ ꠙꠥꠠꠤ ꠅꠁꠘ। ꠔꠦꠃ ꠀꠝꠤ ꠛꠥꠎꠝꠥ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN24_15","002_24_15","GEN","24","15","15","ꠔꠣꠘ ꠖꠥꠀ ꠡꠦꠡ ꠘꠣ ꠅꠁꠔꠦꠃ ꠛꠕꠥꠄꠟꠞ ꠙꠥꠠꠤ ꠞꠦꠛꠦꠇꠣꠄ ꠇꠣꠈꠅ ꠈꠂꠟꠣ ꠟꠁꠀ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ। ꠅꠃ ꠛꠕꠥꠄꠟ ꠅꠁꠟꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠜꠣꠁ ꠘꠣꠢꠥꠞꠞ ꠛꠤꠛꠤ ꠝꠤꠟꠇꠣꠞ ꠙꠥꠀ। ");
INSERT INTO syls_vpl VALUES ("GN24_16","002_24_16","GEN","24","16","16","ꠞꠦꠛꠦꠇꠣ ꠀꠍꠟꠣ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞꠤ, ꠀꠛꠤꠀꠔꠤ, ꠡꠔꠤ ꠘꠣꠞꠤ। ꠔꠣꠁꠘ ꠇꠥꠀ ꠕꠣꠇꠤ ꠈꠂꠟꠣ ꠜꠞꠤꠀ ꠎꠦꠛꠟꠣ ꠃꠑꠤꠀ ꠀꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("GN24_17","002_24_17","GEN","24","17","17","ꠅꠃ ꠡꠝꠄꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠥꠟꠣꠝꠦ ꠖꠃꠠꠣꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠖꠄꠀ ꠇꠞꠤ ꠀꠙꠘꠣꠞ ꠈꠂꠟꠣ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠕꠥꠠꠣ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN24_18","002_24_18","GEN","24","18","18","ꠞꠦꠛꠦꠇꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠙꠣꠘꠤ ꠈꠣꠃꠇ꠆ꠇꠣ।” ꠅꠃ ꠇꠕꠣ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠎꠟꠖꠤ ꠇꠞꠤ ꠈꠂꠟꠣꠐꠣ ꠇꠣꠈꠅ ꠕꠘꠦ ꠀꠔꠅ ꠀꠘꠤꠀ ꠙꠣꠘꠤ ꠈꠣꠁꠔꠦ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_19","002_24_19","GEN","24","19","19","ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠛꠣꠞ ꠛꠣꠖꠦ ꠞꠦꠛꠦꠇꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠃꠐ ꠅꠇꠟꠞꠦꠅ ꠔꠣꠞꠣꠞ ꠙꠤꠀꠍ ꠝꠤꠐꠣꠁꠀ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠝꠥ, ꠔꠣꠞꠣ ꠙꠦꠐ ꠜꠞꠤꠀ ꠙꠣꠘꠤ ꠈꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN24_20","002_24_20","GEN","24","20","20","ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠎꠟꠖꠤ ꠇꠞꠤ ꠙꠣꠘꠤꠞ ꠉꠣꠝꠟꠣꠔ ꠈꠂꠟꠣꠞ ꠙꠣꠘꠤ ꠓꠣꠟꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠖꠃꠠꠣꠁꠀ ꠇꠥꠀꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ। ꠀꠞ ꠢꠇꠟ ꠃꠐꠞꠦ ꠙꠣꠘꠤ ꠔꠥꠟꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_21","002_24_21","GEN","24","21","21","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠁ ꠍꠚꠞ ꠇꠣꠝꠤꠀꠛ ꠇꠞꠍꠂꠘ ꠇꠤ ꠘꠣ ꠁꠐꠣ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠘꠤꠞꠛꠦ ꠞꠦꠛꠦꠇꠣꠞ ꠛꠣꠄ ꠌꠣꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_22","002_24_22","GEN","24","22","22","ꠃꠐ ꠅꠇꠟꠦ ꠙꠣꠘꠤ ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠁꠘ ꠀꠗꠣ ꠔꠟꠣꠞ ꠄꠇꠐꠣ ꠡꠥꠘꠣꠞ ꠘꠣꠇꠞ ꠘꠕ ꠀꠞ ꠖꠥꠁ ꠀꠔꠅ ꠖꠡ ꠔꠟꠣꠞ ꠖꠥꠁꠐꠣ ꠡꠥꠘꠣꠞ ꠛꠣꠟꠣ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠖꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN24_23","002_24_23","GEN","24","23","23","“ꠀꠙꠘꠣꠞ ꠛꠣꠛꠣꠞ ꠘꠣꠝ ꠇꠤꠔꠣ? ꠀꠙꠘꠦ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠀꠙꠘꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠀꠝꠞꠣꠞ ꠞꠣꠁꠔ ꠕꠣꠇꠣꠞ ꠎꠣꠉꠣ ꠅꠁꠛ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN24_24","002_24_24","GEN","24","24","24","ꠞꠦꠛꠦꠇꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞ ꠘꠣꠝ ꠛꠕꠥꠄꠟ। ꠖꠣꠖꠣꠞ ꠘꠣꠝ ꠘꠣꠢꠥꠞ ꠀꠞ ꠖꠣꠖꠤꠞ ꠘꠣꠝ ꠝꠤꠟꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_25","002_24_25","GEN","24","25","25","ꠔꠦ ꠀꠙꠘꠣꠞ ꠃꠐꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠛꠣꠠꠤꠔ ꠛꠃꠔ ꠈꠦꠞ-ꠜꠥꠡꠤ ꠀꠍꠦ ꠀꠞ ꠞꠁꠛꠣꠞ ꠎꠣꠉꠣꠅ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN24_26","002_24_26","GEN","24","26","26","ꠅꠃ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN24_27","002_24_27","GEN","24","27","27","“ꠢꠇ꠆ꠇꠟ ꠙ꠆ꠞꠡꠋꠡꠣ ꠝꠣꠛꠥꠖꠞ, ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ। ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠔꠣꠘ ꠖꠦꠅꠀ ꠅꠀꠖꠣ ꠞꠣꠈꠔꠦ ꠀꠞ ꠁꠝꠣꠘꠖꠣꠞꠤ ꠖꠦꠈꠣꠁꠔꠦ ꠚꠣꠃꠞꠤꠍꠂꠘ ꠘꠣ। ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦꠅ ꠙꠕ ꠌꠤꠘꠣꠁꠀ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠇꠥꠐꠝꠞ ꠛꠣꠠꠤꠔ ꠟꠁꠀ ꠀꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN24_28","002_24_28","GEN","24","28","28","ꠞꠦꠛꠦꠇꠣꠄ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠔꠣꠘ ꠝꠣʼꠞ ꠛꠣꠠꠤꠞ ꠢꠇꠟꠞꠦ ꠁꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_29","002_24_29","GEN","24","29","29","ꠞꠦꠛꠦꠇꠣꠞ ꠄꠇ ꠜꠣꠁꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠟꠣꠛꠘ। ꠅꠃ ꠟꠣꠛꠘꠦ ꠖꠃꠠꠣꠁꠀ ꠇꠥꠀꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠟꠣ ꠄꠘꠞꠦ ꠖꠦꠈꠔꠣ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("GN24_30","002_24_30","GEN","24","30","30","ꠛꠘꠤꠞ ꠀꠔꠞ ꠛꠣꠟꠣ ꠀꠞ ꠘꠣꠇꠞ ꠘꠕ ꠖꠦꠈꠤꠀ, ꠀꠞ ꠢꠤ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀ, ꠔꠣꠁꠘ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠝꠣꠘꠥꠡꠐꠣ ꠇꠥꠀꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠔꠣꠞ ꠃꠐꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN24_31","002_24_31","GEN","24","31","31","ꠟꠣꠛꠘꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖꠞ ꠞꠢꠝꠔꠞ ꠝꠣꠘꠥꠡ, ꠀꠃꠇ꠆ꠇꠣ। ꠛꠣꠞꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ ꠇꠦꠘꠦ? ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠊꠞ, ꠀꠞ ꠃꠐꠞ ꠟꠣꠉꠤ ꠎꠣꠉꠣ ꠎꠥꠁꠔ ꠇꠞꠤꠀ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN24_32","002_24_32","GEN","24","32","32","ꠅꠃ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠃꠐ ꠅꠇꠟꠞ ꠉꠣꠁꠐ ꠟꠣꠝꠣꠁꠔꠦꠃ, ꠟꠣꠛꠘꠦ ꠈꠦꠞ ꠀꠞ ꠜꠥꠡꠤ ꠀꠘꠤꠀ ꠖꠤꠟꠣ। ꠔꠣꠘꠦ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠞꠦ ꠀꠔ-ꠙꠣꠅ ꠗꠅꠀꠞ ꠙꠣꠘꠤꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_33","002_24_33","GEN","24","33","33","ꠛꠣꠖꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠈꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠔꠦꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ ꠁꠘꠅ ꠀꠁꠍꠤ, ꠁꠔꠣ ꠘꠣ ꠢꠥꠘꠣꠁꠀ ꠈꠣꠘꠤ ꠈꠣꠁꠔꠣꠝ ꠘꠣꠄ।” ꠟꠣꠛꠘꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠇꠁꠟꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN24_34","002_24_34","GEN","24","34","34","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠥꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN24_35","002_24_35","GEN","24","35","35","ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠛꠃꠔ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠍꠂꠘ, ꠀꠁꠎ ꠔꠣꠁꠘ ꠛꠃꠔ ꠗꠘꠤ-ꠝꠣꠘꠤ। ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠛꠃꠔ ꠉꠞꠥ-ꠝꠦꠠꠣ, ꠃꠐ-ꠉꠣꠗꠣ, ꠡꠥꠘꠣ-ꠞꠥꠙꠣ, ꠀꠞ ꠛꠣꠘ꠆ꠖꠤ-ꠉꠥꠟꠣꠝ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN24_36","002_24_36","GEN","24","36","36","ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠄꠅꠡꠅ ꠝꠥꠘꠤꠛꠞ ꠄꠇꠎꠘ ꠙꠥꠀ ꠅꠁꠍꠂꠘ, ꠀꠞ ꠅꠃ ꠙꠥꠀꠞꠦꠃ ꠔꠣꠁꠘ, ꠔꠣꠘ ꠢꠇꠟꠔꠣ ꠖꠤꠟꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN24_37","002_24_37","GEN","24","37","37","ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠇꠍꠝ ꠇꠞꠣꠁꠀ ꠇꠁꠍꠂꠘ ꠎꠦꠘ, ꠔꠣꠁꠘ ꠎꠦ ꠖꠦꠡꠅ ꠛꠡꠔ ꠇꠞꠞꠣ, ꠢꠤ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠎꠣꠔꠦ ꠔꠣꠘ ꠙꠥꠀꠞ ꠛꠃ ꠘꠣ ꠛꠣꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("GN24_38","002_24_38","GEN","24","38","38","ꠄꠞ ꠛꠖꠟꠣ ꠔꠣꠘ ꠛꠣꠚꠞ ꠀꠞ ꠔꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠔꠣꠘ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠄꠇꠎꠘ ꠇꠁꠘꠣ ꠌꠣꠁꠀ ꠘꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("GN24_39","002_24_39","GEN","24","39","39","ꠅꠃ ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠇꠁꠟꠣꠝ, ‘ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠙꠥꠠꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠁꠔꠦ ꠞꠣꠎꠤ ꠘꠣ ꠅꠁꠘ?’ ");
INSERT INTO syls_vpl VALUES ("GN24_40","002_24_40","GEN","24","40","40","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠝꠣꠛꠥꠖ, ꠎꠣꠘꠞꠦ ꠀꠝꠤ ꠈꠦꠎꠝꠔ ꠇꠞꠤ, ꠔꠣꠁꠘꠃ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠙꠣꠑꠣꠁ ꠖꠤꠛꠣ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞ ꠍꠚꠞ ꠇꠣꠝꠤꠀꠛ ꠅꠄ। ꠀꠞ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠋꠡ ꠀꠞ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠘꠦ, ꠄꠉꠥ ꠙꠥꠠꠤꠞꠦ ꠀꠝꠣꠞ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠌꠣꠁꠀ ꠀꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN24_41","002_24_41","GEN","24","41","41","ꠔꠣꠞꠣꠞ ꠢꠤꠘꠅ ꠉꠦꠟꠦ ꠎꠥꠖꠤ ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠘꠣ ꠖꠦꠁꠘ, ꠔꠣꠁꠟꠦ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠁ ꠇꠍꠝ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠛꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("GN24_42","002_24_42","GEN","24","42","42","“ꠅꠃ ꠀꠁꠎ ꠀꠝꠤ ꠇꠥꠀꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠖꠥꠀ ꠇꠞꠟꠣꠝ, ‘ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠁ ꠍꠚꠞ ꠇꠣꠝꠤꠀꠛ ꠇꠞꠅ ꠔꠣꠁꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("GN24_43","002_24_43","GEN","24","43","43","ꠖꠦꠈꠅ, ꠀꠝꠤ ꠅꠃ ꠜꠞꠣ ꠇꠥꠀꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠤ, ꠀꠞ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠄ ꠅꠘꠅ ꠙꠣꠘꠤ ꠘꠦꠅꠀꠔ ꠀꠁꠟꠦ ꠀꠝꠤ ꠇꠁꠝꠥ, ꠈꠂꠟꠣ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠕꠥꠠꠣ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠅ। ");
INSERT INTO syls_vpl VALUES ("GN24_44","002_24_44","GEN","24","44","44","ꠀꠞ ꠎꠥꠖꠤ ꠔꠣꠁ ꠇꠄ, ‘ꠔꠥꠝꠤꠅ ꠙꠣꠘꠤ ꠈꠣꠅ ꠀꠞ ꠔꠥꠝꠣꠞ ꠃꠐ ꠅꠇꠟꠞꠦꠅ ꠀꠝꠤ ꠙꠣꠘꠤ ꠔꠥꠟꠤꠀ ꠖꠤꠝꠥ’, ꠔꠣꠁꠟꠦ ꠅꠃ ꠙꠥꠠꠤꠃ ꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠙꠥꠠꠤ ꠅꠄ।’ ");
INSERT INTO syls_vpl VALUES ("GN24_45","002_24_45","GEN","24","45","45","“ꠀꠝꠣꠞ ꠖꠥꠀ ꠡꠦꠡ ꠘꠣ ꠅꠁꠔꠦꠃ ꠖꠦꠈꠤ, ꠞꠦꠛꠦꠇꠣꠄ ꠈꠂꠟꠣ ꠇꠣꠈꠅ ꠟꠁꠀ ꠇꠥꠀꠔ ꠀꠁꠞꠣ ꠙꠣꠘꠤ ꠔꠥꠟꠔꠣ। ꠙꠣꠘꠤ ꠔꠥꠟꠣꠞ ꠛꠣꠖꠦ ꠀꠝꠤ ꠇꠁꠟꠣꠝ, ‘ꠖꠄꠀ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠕꠥꠠꠣ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠃꠇ꠆ꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("GN24_46","002_24_46","GEN","24","46","46","ꠔꠣꠁꠘ ꠎꠟꠖꠤ ꠇꠞꠤ ꠇꠣꠈꠅ ꠕꠘꠦ ꠈꠂꠟꠣ ꠟꠣꠝꠣꠁꠀ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ‘ꠅꠃ ꠘꠦꠁꠘ, ꠙꠣꠘꠤ ꠈꠣꠁꠘ। ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠃꠐ ꠅꠇꠟꠞꠦꠅ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠝꠥ।’ ꠔꠦꠃ ꠀꠝꠤ ꠙꠣꠘꠤ ꠈꠣꠁꠟꠣꠝ, ꠀꠞ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠃꠐ ꠅꠇꠟꠞꠦꠅ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_47","002_24_47","GEN","24","47","47","ꠛꠣꠖꠦ ꠀꠝꠤ ꠔꠣꠘꠦ ꠎꠤꠇꠣꠁꠟꠣꠝ, ‘ꠀꠙꠘꠦ ꠇꠣꠞ ꠙꠥꠠꠤ?’ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠀꠝꠤ ꠛꠕꠥꠄꠟꠞ ꠙꠥꠠꠤ, ꠀꠝꠣꠞ ꠖꠣꠖꠣꠞ ꠘꠣꠝ ꠘꠣꠢꠥꠞ ꠀꠞ ꠖꠣꠖꠤꠞ ꠘꠣꠝ ꠝꠤꠟꠇꠣ।’ ꠅꠃ ꠀꠝꠤ ꠔꠣꠘ ꠘꠣꠇꠅ ꠘꠕ ꠀꠞ ꠀꠔꠅ ꠛꠣꠟꠣ ꠚꠤꠘ꠆ꠖꠣꠁꠀ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN24_48","002_24_48","GEN","24","48","48","ꠛꠣꠖꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣꠝ। ꠀꠞ ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ, ꠢꠃ ꠝꠣꠛꠥꠖꠞ ꠡꠥꠇꠥꠞ ꠀꠖꠣꠄ ꠇꠞꠟꠣꠝ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞꠦ ꠑꠤꠇ ꠙꠕꠦ ꠌꠣꠟꠣꠁꠀ ꠀꠘꠍꠂꠘ ꠎꠣꠔꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠜꠣꠔꠤꠎꠤꠞꠦ, ꠔꠣꠘ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("GN24_49","002_24_49","GEN","24","49","49","ꠔꠦꠃ ꠅꠈꠘ ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠛꠣꠄ ꠖꠞꠖ ꠀꠞ ꠁꠘꠍꠣꠚ ꠇꠞꠛꠣ ꠘꠤ, ꠇꠃꠇ꠆ꠇꠣ। ꠎꠥꠖꠤ ꠘꠣ ꠇꠞꠂꠘ ꠔꠣ-ꠅ ꠇꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠀꠝꠤ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN24_50","002_24_50","GEN","24","50","50","ꠅꠃ ꠟꠣꠛꠘ ꠀꠞ ꠛꠕꠥꠄꠟꠦ ꠇꠁꠟꠣ, “ꠊꠐꠘꠣ ꠔ ꠝꠣꠛꠥꠖ ꠕꠣꠇꠤꠃ ꠅꠁꠍꠦ। ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠝꠣꠔꠣꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN24_51","002_24_51","GEN","24","51","51","ꠅꠃ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠞꠦꠛꠦꠇꠣ ꠔ ꠅꠘꠅ ꠀꠍꠦ, ꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠔ ꠀꠙꠘꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠙꠥꠀꠞ ꠛꠃ ꠛꠣꠘꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠄꠞꠦ ꠟꠁꠀ ꠎꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN24_52","002_24_52","GEN","24","52","52","ꠁ ꠝꠣꠔ ꠢꠥꠘꠤꠀ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠥꠟꠣꠝꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_53","002_24_53","GEN","24","53","53","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠞ ꠉꠄꠘꠣ-ꠉꠣꠐꠤ ꠀꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠛꠣꠞ ꠇꠞꠤꠀ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠖꠤꠟꠣ, ꠄꠞ ꠟꠉꠦ ꠞꠦꠛꠦꠇꠣꠞ ꠝꠣ-ꠜꠣꠁꠞꠦꠅ ꠛꠃꠔ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠃꠙꠢꠣꠞ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_54","002_24_54","GEN","24","54","54","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠦ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠈꠣꠘꠅꠃ ꠞꠣꠁꠔ ꠇꠣꠐꠣꠁꠟꠣ। ꠛꠤꠀꠘꠦ ꠊꠥꠝ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN24_55","002_24_55","GEN","24","55","55","ꠔꠦꠃ ꠞꠦꠛꠦꠇꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁꠄ ꠇꠁꠟꠣ, “ꠙꠥꠠꠤꠉꠥ ꠀꠞꠅ ꠖꠡꠈꠣꠘ ꠖꠤꠘ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠕꠣꠇꠃꠇ, ꠛꠣꠖꠦ ꠎꠣꠁꠛꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN24_56","002_24_56","GEN","24","56","56","ꠅꠃ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠁ ꠍꠚꠞ ꠇꠣꠝꠤꠀꠛ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠖꠦꠞꠤ ꠘꠣ ꠇꠞꠣꠁꠀ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN24_57","002_24_57","GEN","24","57","57","ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔꠣꠁꠟꠦ ꠙꠥꠠꠤꠞꠦ ꠍꠣꠝꠘꠦ ꠀꠘꠤꠀ ꠎꠤꠇꠣꠁꠟꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("GN24_58","002_24_58","GEN","24","58","58","ꠀꠞ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠒꠣꠇꠤꠀ ꠀꠘꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠔꠣꠘ ꠟꠉꠦ ꠎꠣꠁꠛꠣꠄ ꠘꠤ ꠉ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠎꠣꠁꠝꠥꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN24_59","002_24_59","GEN","24","59","59","ꠅꠃ ꠔꠣꠞꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠥꠟꠣꠝ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠛꠁꠘ ꠀꠞ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_60","002_24_60","GEN","24","60","60","ꠀꠞ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠖꠥꠀ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠛꠁꠘ ꠉ, ꠔꠥꠝꠤ ꠟꠣꠈ ꠟꠣꠈ ꠀꠅꠟꠣꠖꠞ ꠝꠣ ꠅꠅ। ꠔꠥꠝꠣꠞ ꠀꠅꠟꠣꠖꠦ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠊꠣꠁꠟ ꠇꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("GN24_61","002_24_61","GEN","24","61","61","ꠞꠦꠛꠦꠇꠣ ꠀꠞ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤ ꠅꠇꠟꠦ ꠔꠂꠀꠞ ꠅꠁꠀ ꠃꠐꠞ ꠃꠙꠞꠦ ꠌꠠꠤꠀ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠥꠟꠣꠝꠞ ꠈꠞꠦ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠃ ꠉꠥꠟꠣꠝꠦ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠟꠁꠀ ꠛꠣꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_62","002_24_62","GEN","24","62","62","ꠁꠍꠢꠣꠇ ꠁ ꠡꠝꠄ ꠘꠦꠉꠦꠜꠅ ꠕꠣꠇꠔꠣ। ꠔꠣꠁꠘ ꠛꠦꠞ-ꠟꠢꠄ-ꠞꠥꠁ ꠘꠣꠝꠞ ꠎꠣꠉꠣ ꠕꠘꠦ ꠚꠤꠞꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_63","002_24_63","GEN","24","63","63","ꠄꠇꠖꠤꠘ ꠛꠤꠀꠟꠤ ꠛꠣꠟꠣ ꠔꠣꠁꠘ ꠛꠘ꠆ꠖꠦꠖꠤ ꠀꠐꠣꠔ ꠛꠣꠞ ꠅꠁꠟꠣ। ꠀꠈꠔꠣꠃ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠇꠄꠐꠣ ꠃꠐ ꠀꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_64","002_24_64","GEN","24","64","64","ꠞꠦꠛꠦꠇꠣꠄꠅ ꠖꠥꠞꠁ ꠕꠘꠦ ꠁꠍꠢꠣꠇꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠃꠐꠞ ꠃꠙꠞ ꠕꠣꠇꠤ ꠟꠣꠝꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_65","002_24_65","GEN","24","65","65","ꠀꠞ ꠢꠃ ꠉꠥꠟꠣꠝꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠃ ꠎꠦꠁꠘ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦꠖꠤ ꠀꠝꠞꠣꠞ ꠛꠣꠄ ꠀꠁꠞꠣ, ꠄꠁꠘ ꠇꠦ?” ꠉꠥꠟꠣꠝꠦ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠔ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ।” ꠅꠃ ꠞꠦꠛꠦꠇꠣꠄ ꠛꠥꠞꠇꠣꠞ ꠙꠞ꠆ꠖꠣ ꠟꠣꠝꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_66","002_24_66","GEN","24","66","66","ꠀꠞ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠞꠤꠀ ꠀꠁꠍꠂꠘ, ꠢꠇꠟꠔꠣ ꠁꠍꠢꠣꠇꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN24_67","002_24_67","GEN","24","67","67","ꠁꠍꠢꠣꠇꠦ ꠔꠣꠘ ꠝꠣ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠔꠣꠝ꠆ꠛꠥꠔ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠟꠁꠀ ꠉꠤꠀ ꠔꠣꠘꠦ ꠛꠤꠀ ꠇꠞꠟꠣ। ꠀꠞ ꠔꠣꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠟꠣ। ꠔꠣꠘ ꠝꠣʼꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ, ꠞꠦꠛꠦꠇꠣꠞ ꠝꠣꠄꠀꠄꠃ ꠔꠣꠘ ꠎꠣꠘꠅ ꠡꠣꠘ꠆ꠔꠤ ꠙꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_1","002_25_1","GEN","25","1","1","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠣꠔꠥꠞꠣ ꠘꠣꠝꠞ ꠀꠞꠅ ꠄꠇꠎꠘ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_2","002_25_2","GEN","25","2","2","ꠔꠣꠘ ꠙꠦꠐꠅ ꠎꠤꠝ꠆ꠞꠘ, ꠎꠇꠡꠘ, ꠝꠖꠣꠘ, ꠝꠣꠖꠤꠀꠘ, ꠎꠤꠡꠛꠇ ꠀꠞ ꠡꠥꠢꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN25_3","002_25_3","GEN","25","3","3","ꠡꠣꠛꠣ ꠀꠞ ꠖꠖꠣꠘ ꠅꠁꠟꠣ ꠎꠇꠡꠘꠞ ꠀꠅꠟꠣꠖ। ꠀꠡꠥꠞꠤ, ꠟꠐꠥꠡꠤ, ꠟꠤꠃꠝ꠆ꠝꠤ ꠅꠇꠟ ꠅꠁꠟꠣ ꠖꠖꠣꠘꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GN25_4","002_25_4","GEN","25","4","4","ꠝꠣꠖꠤꠀꠘꠞ ꠀꠅꠟꠣꠖ ꠅꠁꠟꠣ ꠅꠂꠚꠣ, ꠄꠚꠞ, ꠢꠘꠥꠇ, ꠅꠛꠤꠖ ꠀꠞ ꠁꠟꠖꠣꠄꠀ। ꠄꠞꠣ ꠢꠇꠟꠃ ꠇꠣꠔꠥꠞꠣꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GN25_5","002_25_5","GEN","25","5","5","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠔꠣꠘ ꠢꠇꠟꠔꠣ ꠁꠍꠢꠣꠇꠞꠦ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_6","002_25_6","GEN","25","6","6","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠔꠦꠃ, ꠔꠣꠘ ꠢꠦꠡꠞ ꠛꠤꠀꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦꠅ ꠀꠟꠉꠣ ꠀꠟꠉꠣ ꠖꠣꠘ ꠇꠞꠤꠀ, ꠄꠞꠣꠞꠦ ꠁꠍꠢꠣꠇꠞ ꠟꠉꠦ ꠘꠣ ꠞꠣꠈꠤꠀ ꠙꠥꠛꠦꠖꠤ, ꠙꠥꠛꠞ ꠖꠦꠡꠅ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_7","002_25_7","GEN","25","7","7","ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠄꠇ-ꠡ ꠙꠌꠔ꠆ꠔꠁꠞ ꠛꠞꠍ ꠛꠣꠌꠤꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠦ ꠅꠔꠖꠤꠘꠞ ꠢꠣꠄꠀꠔꠤ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_8","002_25_8","GEN","25","8","8","ꠔꠣꠁꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠁꠀ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠥꠠꠣ ꠛꠄꠅꠡꠅ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠀꠎꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_9","002_25_9","GEN","25","9","9","ꠢꠦꠡꠦ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠝꠣꠁꠟ ꠀꠞ ꠁꠍꠢꠣꠇꠦ ꠝꠝ꠆ꠞꠤ ꠐꠣꠃꠘꠞ ꠙꠥꠛꠦꠖꠤ, ꠢꠤꠐ꠆ꠐꠤ ꠡꠥꠢꠞꠞ ꠙꠥꠀ ꠁꠚ꠆ꠞꠥꠘꠞ ꠎꠝꠤꠞ ꠝꠇꠙꠦꠟꠣ-ꠉꠥꠢꠣꠔ, ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_10","002_25_10","GEN","25","10","10","ꠁ ꠎꠝꠤꠈꠣꠘ ꠔꠣꠁꠘ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠘꠦ ꠟꠁꠍꠟꠣ। ꠅꠘꠅꠃ ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞꠦ ꠀꠞ ꠔꠣꠘꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN25_11","002_25_11","GEN","25","11","11","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠛꠦꠞ-ꠟꠢꠄ-ꠞꠥꠁꠞ ꠉꠦꠍꠦ ꠞꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_12","002_25_12","GEN","25","12","12","ꠅꠃ ꠅꠁꠟ ꠁꠍꠝꠣꠁꠟꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠄꠀꠘ। ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠝꠤꠡꠞꠤ ꠢꠣꠎꠦꠞꠣꠞ ꠙꠦꠐꠅ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠙꠥꠀ ꠁꠍꠝꠣꠁꠟꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN25_13","002_25_13","GEN","25","13","13","ꠅꠃ ꠅꠁꠟ ꠁꠍꠝꠣꠁꠟꠞ ꠀꠅꠟꠣꠖꠞ ꠘꠣꠝ ꠀꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠛꠄꠀꠘ। ꠔꠣꠘ ꠛꠠ ꠙꠥꠀꠞ ꠘꠣꠝ ꠘꠣꠛꠣꠃꠔ, ꠛꠣꠖꠦ ꠇꠣꠄꠖꠣꠞ, ꠅꠖꠛꠦꠟ, ꠝꠤꠛꠍꠝ, ");
INSERT INTO syls_vpl VALUES ("GN25_14","002_25_14","GEN","25","14","14","ꠝꠤꠡꠝꠣ, ꠖꠥꠝꠣ, ꠝꠣꠍꠣ, ");
INSERT INTO syls_vpl VALUES ("GN25_15","002_25_15","GEN","25","15","15","ꠢꠖꠖ, ꠔꠦꠝꠣ, ꠎꠤꠐꠥꠞ, ꠘꠣꠚꠤꠡ ꠀꠞ ꠇꠦꠖꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_16","002_25_16","GEN","25","16","16","ꠁꠍꠝꠣꠁꠟꠞ ꠅꠃ ꠛꠣꠞꠅꠎꠘ ꠙꠥꠀ ꠀꠍꠟꠣ ꠛꠣꠞꠅ ꠉꠥꠡ꠆ꠐꠤꠞ ꠡꠞ꠆ꠖꠣꠞ। ꠔꠣꠞꠣꠞ ꠘꠣꠝꠞ ꠟꠣꠈꠣꠘ ꠢꠤ ꠉꠣꠃ ꠀꠞ ꠔꠣꠝ꠆ꠛꠥ ꠛꠤꠍꠣꠁꠟ ꠎꠣꠉꠣꠞꠅ ꠅꠃ ꠘꠣꠝ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN25_17","002_25_17","GEN","25","17","17","ꠁꠍꠝꠣꠁꠟꠞ ꠢꠣꠄꠀꠔ ꠄꠇ-ꠡ ꠡꠣꠠꠔꠤꠡ ꠛꠞꠍ ꠀꠍꠤꠟ, ꠢꠦꠡꠦ ꠔꠣꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠟꠣ ꠀꠞ ꠔꠣꠘ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN25_18","002_25_18","GEN","25","18","18","ꠢꠛꠤꠟꠣ ꠕꠘꠦ ꠀꠡꠤꠞꠤꠀꠞ ꠛꠣꠄ ꠝꠤꠡꠞꠞ ꠍꠣꠝꠘꠞ ꠡꠥꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠘ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠞꠁꠔꠣ। ꠁꠍꠝꠣꠁꠟꠦ ꠔꠣꠘ ꠢꠇꠟ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠣꠟꠣꠛꠣꠄ ꠞꠅꠀꠞ ꠎꠣꠉꠣ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_19","002_25_19","GEN","25","19","19","ꠅꠃ ꠅꠁꠟ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠈꠣꠘ꠆ꠖꠣꠘ-ꠘꠣꠝꠣ। ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠊꠞꠅ ꠁꠍꠢꠣꠇꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN25_20","002_25_20","GEN","25","20","20","ꠁꠍꠢꠣꠇꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠝꠣꠝꠥꠞ ꠊꠞꠞ ꠛꠁꠘ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠀꠘꠣꠁꠀ ꠛꠤꠀ ꠇꠞꠟꠣ। ꠞꠦꠛꠦꠇꠣ ꠅꠁꠟꠣ ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝ ꠖꠦꠡꠞ ꠅꠞꠣꠝꠤ ꠛꠕꠥꠄꠟꠞ ꠙꠥꠠꠤ, ꠅꠞꠣꠝꠤ ꠟꠣꠛꠘꠞ ꠛꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("GN25_21","002_25_21","GEN","25","21","21","ꠔꠣꠘ ꠛꠃ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠀꠍꠟꠣ ꠉꠔꠤꠇꠦ, ꠁꠍꠢꠣꠇꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠖꠥꠀ ꠇꠞꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠀꠞ ꠞꠦꠛꠦꠇꠣꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN25_22","002_25_22","GEN","25","22","22","ꠛꠣꠖꠦ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠄ ꠟꠠꠣ-ꠌꠠꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠙꠦꠐꠅ ꠁꠟꠣ ꠟꠣꠉꠦꠞ ꠇꠦꠘꠦ?” ꠇꠣꠞꠘ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠖꠥꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_23","002_25_23","GEN","25","23","23","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠙꠦꠐꠅ ꠖꠥꠁꠐꠣ ꠎꠣꠔꠤ ꠀꠍꠦ, ꠙꠦꠐꠅ ꠕꠘꠦꠃ ꠔꠣꠞꠣ ꠖꠥꠁ ꠛꠋꠡ ꠅꠁꠀ ꠙꠄꠖꠣ ꠅꠁꠛꠣ। ꠄꠇ ꠛꠋꠡ ꠕꠘꠦ ꠀꠞꠇ ꠛꠋꠡ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠅꠁꠛ, ꠀꠞ ꠛꠠꠉꠥꠄ ꠢꠥꠞꠥꠉꠥꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN25_24","002_25_24","GEN","25","24","24","ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣꠞ ꠛꠣꠟꠣ ꠖꠦꠈꠂꠘ, ꠢꠣꠍꠣꠃ ꠔꠣꠘ ꠙꠦꠐꠅ ꠎꠥꠠꠞ ꠙꠥꠀ। ");
INSERT INTO syls_vpl VALUES ("GN25_25","002_25_25","GEN","25","25","25","ꠙꠄꠟꠣ ꠎꠣꠞ ꠎꠘꠝ ꠅꠁꠟ ꠢꠦ ꠟꠣꠟ ꠞꠋꠉꠞ ꠀꠞ ꠔꠣꠞ ꠡꠞꠤꠟꠅ ꠙꠡꠝꠤ ꠇꠣꠙꠠꠞ ꠟꠣꠈꠣꠘ ꠞꠥꠝꠣꠄ ꠜꠞꠣ। ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠁꠡ ꠝꠣꠘꠤ, ꠞꠥꠝꠣꠀꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_26","002_25_26","GEN","25","26","26","ꠛꠣꠖꠦ ꠁꠡʼꠞ ꠙꠣꠅꠞ ꠝꠥꠞꠣꠔ ꠗꠞꠤ ꠔꠣꠞ ꠜꠣꠁꠞ ꠎꠘꠝ ꠅꠁꠟ, ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠁꠀꠇꠥꠛ ꠝꠣꠘꠤ, ꠙꠣꠅꠔ ꠗꠞꠞꠣ। ꠁꠍꠢꠣꠇꠞ ꠡꠣꠁꠐ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠄꠞꠣ ꠎꠥꠠꠦ ꠙꠄꠖꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_27","002_25_27","GEN","25","27","27","ꠅꠃ ꠙꠥꠀꠂꠘ ꠛꠠ ꠅꠀꠞ ꠛꠣꠖꠦ ꠁꠡ ꠈꠥꠛ ꠜꠣꠟꠣ ꠡꠤꠇꠣꠞꠤ ꠀꠞ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠙꠣꠇꠣꠅꠞꠣ ꠅꠁꠟꠣ, ꠅꠁꠟꠦ ꠁꠀꠇꠥꠛ ꠀꠍꠟꠣ ꠘꠤꠞꠣꠁ-ꠎꠤꠞꠣꠁ, ꠔꠣꠁꠘ ꠔꠣꠝ꠆ꠛꠥꠔ ꠕꠣꠇꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_28","002_25_28","GEN","25","28","28","ꠡꠤꠇꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠝꠎꠣ ꠟꠣꠉꠔ ꠇꠞꠤ ꠁꠍꠢꠣꠇꠦ ꠁꠡʼꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠔꠣ, ꠀꠞ ꠞꠦꠛꠦꠇꠣꠄ ꠁꠀꠇꠥꠛꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_29","002_25_29","GEN","25","29","29","ꠄꠇꠖꠤꠘ ꠁꠀꠇꠥꠛꠦ ꠒꠣꠁꠟ ꠞꠣꠘ꠆ꠖꠤꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠛꠠ ꠜꠣꠁ ꠁꠡ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠙꠦꠐꠞ ꠜꠥꠇꠦ ꠈꠥꠛ ꠇꠣꠔꠞ ꠅꠁꠀ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠢꠥꠞꠥ ꠜꠣꠁ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN25_30","002_25_30","GEN","25","30","30","“ꠜꠣꠁꠞꠦ, ꠀꠝꠣꠞ ꠈꠥꠛ ꠜꠥꠇ ꠟꠣꠉꠍꠦ। ꠔꠦ ꠅꠃ ꠞꠋꠉꠤꠟ, ꠞꠋꠉꠤꠟ ꠅꠔꠣ ꠀꠝꠣꠞꠦ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠁꠔꠦ ꠖꠦ।” ꠅꠃ ꠇꠕꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠌꠤꠠ ꠟꠣꠉꠟ ꠁꠖꠥꠝ ꠝꠣꠘꠤ, ꠞꠋꠉꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN25_31","002_25_31","GEN","25","31","31","ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠔꠣꠁꠟꠦ ꠛꠠ ꠜꠣꠁ ꠅꠀꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ, ꠔꠥꠝꠤ ꠀꠁꠎ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠛꠦꠌꠤꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN25_32","002_25_32","GEN","25","32","32","ꠁꠡꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠅ, ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠞ ꠅꠁꠎꠣꠞ, ꠀꠞ ꠛꠠ ꠜꠣꠁꠞ ꠝꠣꠟꠤꠇꠣꠘꠣꠖꠤ ꠀꠞ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("GN25_33","002_25_33","GEN","25","33","33","ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠀꠉꠦ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠇꠞꠅ।” ꠅꠃ ꠁꠡꠦ ꠇꠍꠝ ꠇꠞꠤꠀ ꠛꠠ ꠜꠣꠁ ꠅꠀꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠛꠦꠌꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN25_34","002_25_34","GEN","25","34","34","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠁꠡʼꠞꠦ ꠒꠣꠁꠟ ꠀꠞ ꠞꠥꠐꠤ ꠈꠣꠁꠔꠦ ꠖꠤꠟꠣ। ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠤꠀ ꠔꠣꠁꠘ ꠃꠑꠤꠀ ꠉꠦꠟꠣꠉꠤ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠁꠡꠦ ꠛꠠ ꠙꠥꠀ ꠅꠀꠞ ꠇꠥꠘꠥ ꠖꠣꠝꠃ ꠞꠣꠈꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_1","002_26_1","GEN","26","1","1","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠎꠝꠣꠘꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠚꠤꠞꠣꠅ ꠖꠦꠡꠅ ꠢꠤꠞꠛꠣꠞ ꠄꠇ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠟ। ꠔꠦꠃ ꠁꠍꠢꠣꠇ ꠉꠦꠞꠣꠞ ꠐꠣꠃꠘꠅ ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠀꠛꠤꠝꠣꠟꠤꠇꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN26_2","002_26_2","GEN","26","2","2","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠁꠍꠢꠣꠇꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠝꠤꠡꠞꠅ ꠟꠣꠝꠤꠀ ꠎꠣꠁꠅ ꠘꠣ। ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠇꠕꠣ ꠇꠁꠝꠥ, ꠅꠘꠅꠃ ꠕꠣꠇꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("GN26_3","002_26_3","GEN","26","3","3","ꠅꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠤ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠁꠀ ꠞꠅ। ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠞꠁꠀ, ꠔꠥꠝꠣꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠝꠥ। ꠁ ꠖꠦꠡ ꠅꠇꠟ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠖꠤꠝꠥ। ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠣꠚ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠎꠦ ꠇꠍꠝ ꠇꠞꠍꠟꠣꠝ, ꠅꠇꠐꠣ ꠙꠥꠞꠣ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN26_4","002_26_4","GEN","26","4","4","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠤꠡꠣꠛ ꠇꠞꠝꠥ, ꠅꠃ ꠖꠦꠡ ꠅꠇꠟꠅ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠝꠥ। ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞꠦꠖꠤ, ꠖꠥꠘꠤꠀꠁꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_5","002_26_5","GEN","26","5","5","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠀꠝꠣꠞ ꠝꠣꠔ ꠢꠥꠘꠤꠀ, ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ, ꠀꠝꠣꠞ ꠀꠁꠘ ꠀꠞ ꠀꠝꠣꠞ ꠡꠞꠤꠅꠔ ꠅꠇꠟ ꠀꠝꠟ ꠇꠞꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN26_6","002_26_6","GEN","26","6","6","ꠔꠦꠃ ꠁꠍꠢꠣꠇ ꠉꠦꠞꠣꠞ ꠐꠣꠃꠘꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_7","002_26_7","GEN","26","7","7","ꠀꠞ ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠛꠃꠞ ꠇꠕꠣ ꠎꠤꠇꠣꠁꠟꠦ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ ꠄꠁꠘ ꠀꠝꠣꠞ ꠛꠁꠘ। ꠄꠘꠞꠦ ꠛꠃ ꠇꠁꠔꠦ ꠔꠣꠁꠘ ꠒꠞꠣꠁꠟꠣ, ꠝꠘꠦ ꠇꠞꠟꠣ, ꠞꠦꠛꠦꠇꠣ ꠡꠥꠘ꠆ꠖꠞꠤ ꠇꠞꠤꠀ ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_8","002_26_8","GEN","26","8","8","ꠁꠍꠢꠣꠇ ꠛꠃꠔ ꠖꠤꠘ ꠢꠘꠅ ꠞꠅꠀꠞ ꠛꠣꠖꠦ ꠄꠇꠖꠤꠘ ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠈꠤꠠꠇꠤ ꠛꠣꠄꠖꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠁꠍꠢꠣꠇꠦ ꠔꠣꠘ ꠛꠤꠛꠤ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_9","002_26_9","GEN","26","9","9","ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠁꠍꠢꠣꠇꠞꠦ ꠘꠦꠅꠀꠁꠀ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠞꠦꠛꠦꠇꠣ ꠔ ꠀꠍꠟꠦ ꠀꠙꠘꠣꠞ ꠛꠤꠛꠤ, ꠔꠦ ꠀꠙꠘꠦ ꠇꠦꠘꠦ ꠔꠣꠘꠞꠦ ꠀꠙꠘꠣꠞ ꠛꠁꠘ ꠇꠁꠟꠣ?” ꠁꠍꠢꠣꠇꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠝꠘꠦ ꠇꠞꠍꠟꠣꠝ ꠔꠣꠁꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠎꠣꠘ ꠀꠞꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN26_10","002_26_10","GEN","26","10","10","ꠔꠦꠃ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠙꠘꠦ ꠁꠔꠣ ꠇꠤꠔꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠟꠣ? ꠎꠦꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔ ꠀꠙꠘꠣꠞ ꠛꠤꠛꠤꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠔ ꠌꠣꠁꠟ ꠅꠘꠦ ꠀꠞ ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠖꠥꠡꠤ ꠛꠣꠘꠣꠁꠟꠣ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN26_11","002_26_11","GEN","26","11","11","ꠛꠣꠖꠦ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠎꠣꠞꠤ ꠇꠞꠟꠣ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠍꠢꠣꠇ ꠛꠣ ꠔꠣꠘ ꠛꠤꠛꠤꠞ ꠡꠞꠤꠟꠅ ꠀꠔ ꠖꠦꠄ, ꠔꠣꠞꠦ ꠘꠤꠌꠄ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN26_12","002_26_12","GEN","26","12","12","ꠀꠞ ꠁꠍꠢꠣꠇꠦ ꠢꠤ ꠛꠞꠍ ꠈꠦꠔ ꠇꠞꠤꠀ ꠔꠣꠘ ꠎꠝꠤꠘꠅ ꠞꠥꠀ ꠛꠤꠌ ꠕꠣꠇꠤ ꠄꠇ-ꠡ ꠉꠥꠘ ꠛꠦꠡꠤ ꠚꠡꠟ ꠙꠣꠁꠟꠣ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠅꠃꠟꠣ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_13","002_26_13","GEN","26","13","13","ꠔꠣꠘ ꠈꠣꠟꠤ ꠛꠣꠠꠔꠦꠃ ꠟꠣꠉꠟ, ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠔꠣꠁꠘ ꠈꠥꠛ ꠝꠣꠟꠖꠣꠞ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_14","002_26_14","GEN","26","14","14","ꠔꠣꠘ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠀꠞ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ ꠅꠃꠟꠣ ꠛꠣꠠꠟ ꠎꠦꠘ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟꠦ ꠁꠋꠡꠣꠁꠔꠣ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_15","002_26_15","GEN","26","15","15","ꠀꠞ ꠔꠣꠘ ꠛꠣꠚ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠝꠟꠅ, ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠎꠦ ꠇꠥꠀ ꠅꠇꠟ ꠈꠥꠖꠤꠍꠟꠣ, ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟꠦ ꠁꠉꠥꠁꠘ ꠝꠣꠐꠤꠖꠤ ꠜꠞꠤꠀ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_16","002_26_16","GEN","26","16","16","ꠛꠣꠖꠦ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠁꠍꠢꠣꠇꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠎꠣꠃꠇ꠆ꠇꠣꠉꠤ, ꠀꠙꠘꠦ ꠔ ꠀꠝꠞꠣ ꠕꠘꠦ ꠛꠦꠡꠤ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠅꠁꠉꠦꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN26_17","002_26_17","GEN","26","17","17","ꠅꠃ ꠁꠍꠢꠣꠇꠦ ꠢꠘ ꠕꠘꠦ ꠢꠞꠤꠀ ꠉꠤꠀ ꠉꠦꠞꠣꠞ ꠝꠞꠣ ꠉꠣꠋꠉꠞ ꠌꠞꠅ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠀ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_18","002_26_18","GEN","26","18","18","ꠀꠞ ꠔꠣꠘ ꠛꠣꠚ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠝꠟꠞ ꠈꠥꠖꠣ ꠇꠥꠀꠁꠘ, ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠈꠥꠖꠤꠟꠣ, ꠇꠣꠞꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟꠦ ꠁꠔꠣ ꠜꠞꠤꠟꠣꠁꠍꠟꠣ। ꠀꠞ ꠔꠣꠘ ꠛꠣꠚꠦ ꠅꠃ ꠇꠥꠀꠁꠘ꠆ꠔꠞ ꠎꠦ ꠘꠣꠝ ꠞꠣꠈꠍꠟꠣ, ꠔꠣꠁꠘꠅ ꠅꠃ ꠘꠣꠝ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_19","002_26_19","GEN","26","19","19","ꠁꠍꠢꠣꠇꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠅꠃ ꠉꠣꠋꠉꠞ ꠌꠞꠅ ꠈꠥꠖꠤꠀ ꠙꠣꠘꠤꠞ ꠚꠥꠔꠀꠟꠣ ꠄꠇ ꠇꠥꠀ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_20","002_26_20","GEN","26","20","20","ꠀꠞ ꠉꠦꠞꠣꠞꠞ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠔꠣꠘ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠞ ꠟꠉꠦ ꠖꠞꠛꠣꠞ ꠇꠞꠤꠀ ꠇꠁꠟ, ꠁ ꠙꠣꠘꠤ ꠀꠝꠞꠣꠞ। ꠅꠃ ꠔꠣꠁꠘ ꠁ ꠇꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠄꠡꠇ ꠝꠣꠘꠤ, ꠖꠞꠛꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("GN26_21","002_26_21","GEN","26","21","21","ꠛꠣꠖꠦ ꠁꠍꠢꠣꠇꠞ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠀꠞꠅ ꠄꠇ ꠇꠥꠀ ꠈꠥꠖꠤꠟꠣ, ꠀꠞ ꠁꠐꠣ ꠟꠁꠀꠅ ꠔꠣꠞꠣ ꠖꠞꠛꠣꠞ ꠇꠞꠟꠣ। ꠅꠃ ꠔꠣꠁꠘ ꠁꠐꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠡꠤꠐꠘꠣ ꠝꠣꠘꠤ, ꠖꠥꠡꠝꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("GN26_22","002_26_22","GEN","26","22","22","ꠢꠦꠡꠦ ꠔꠣꠁꠘ ꠢꠘ ꠕꠘꠦ ꠢꠞꠤꠀ ꠉꠤꠀ ꠀꠞꠅ ꠄꠇ ꠇꠥꠀ ꠈꠥꠖꠣꠁꠟꠣ, ꠁꠚꠤꠞꠣ ꠔꠣꠞꠣ ꠀꠞ ꠇꠥꠘꠥ ꠖꠞꠛꠣꠞ ꠇꠞꠟꠣ ꠘꠣ। ꠔꠦꠃ ꠁꠍꠢꠣꠇꠦ ꠅꠃ ꠇꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠞꠢꠛꠔ ꠝꠣꠘꠤ, ꠛꠃꠔ ꠎꠣꠉꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠝꠣꠛꠥꠖꠦꠃ ꠀꠝꠞꠣꠞꠦ ꠛꠃꠔ ꠎꠣꠉꠣ ꠖꠤꠟꠣ, ꠀꠝꠞꠣ ꠁ ꠖꠦꠡꠅ ꠀꠞꠅ ꠛꠣꠠꠔꠣꠝ ꠙꠣꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN26_23","002_26_23","GEN","26","23","23","ꠛꠣꠖꠦ ꠁꠍꠢꠣꠇꠦ ꠢꠘ ꠕꠘꠦ ꠢꠞꠤꠀ ꠛꠦꠞ-ꠡꠦꠛꠣꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN26_24","002_26_24","GEN","26","24","24","ꠢꠃ ꠞꠣꠁꠔꠃ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠚ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ। ꠔꠥꠝꠤ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠍꠤ। ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠝꠥ ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠋꠡ ꠛꠣꠠꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN26_25","002_26_25","GEN","26","25","25","ꠅꠃ ꠁꠍꠢꠣꠇꠦ ꠢꠘꠅ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ ꠟꠁꠟꠣ। ꠢꠘꠅ ꠔꠣꠁꠘ ꠔꠣꠘ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ ꠀꠞ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠄꠇ ꠇꠥꠀ ꠈꠥꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_26","002_26_26","GEN","26","26","26","ꠛꠣꠖꠦ ꠀꠛꠤꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠃꠎꠤꠞ ꠅꠢꠥꠎꠔ ꠀꠞ ꠡꠦꠘꠣꠙꠔꠤ ꠚꠤꠈꠥꠟꠞꠦ ꠟꠁꠀ ꠉꠦꠞꠣꠞ ꠕꠣꠇꠤ ꠁꠍꠢꠣꠇꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_27","002_26_27","GEN","26","27","27","ꠁꠍꠢꠣꠇꠦ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ ꠀꠁꠟꠣ? ꠀꠙꠘꠣꠞꠣ ꠔ ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠀꠙꠘꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠟꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN26_28","002_26_28","GEN","26","28","28","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠅꠈꠘ ꠍꠣꠚ ꠛꠥꠎꠤꠀꠞ ꠎꠦꠘ, ꠝꠣꠛꠥꠖ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠄꠉꠥ ꠅꠀꠖꠣ ꠅꠁꠎꠣꠃꠇ। ꠀꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣ ꠄꠇ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠤꠟꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("GN26_29","002_26_29","GEN","26","29","29","ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠀꠙꠘꠣꠞꠦ ꠍꠁꠍꠤ ꠘꠣ ꠀꠞ ꠀꠙꠘꠣꠞ ꠜꠣꠟꠣꠁ ꠍꠣꠠꠣ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠇꠞꠍꠤ ꠘꠣ, ꠎꠦꠟꠣ ꠀꠙꠘꠣꠞꠦ ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠤꠖꠣꠄ ꠖꠤꠍꠤ, ꠅꠃꠟꠣ ꠀꠙꠘꠦꠅ ꠀꠝꠞꠣꠞꠦ ꠈꠦꠔꠤ ꠇꠞꠔꠣ ꠘꠣ। ꠀꠙꠘꠦꠃ ꠔ ꠝꠣꠛꠥꠖꠞ ꠛꠞꠇꠔꠞ ꠝꠣꠘꠥꠡ।” ");
INSERT INTO syls_vpl VALUES ("GN26_30","002_26_30","GEN","26","30","30","ꠛꠣꠖꠦ ꠁꠍꠢꠣꠇꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠎꠥꠁꠔ ꠇꠞꠟꠦ, ꠔꠣꠞꠣ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_31","002_26_31","GEN","26","31","31","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠃꠑꠤꠀ ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠇꠍꠝ ꠇꠞꠟꠣ। ꠀꠞ ꠁꠍꠢꠣꠇꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠦ, ꠔꠣꠞꠣ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠡꠣꠘ꠆ꠔꠤ ꠙꠣꠁꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_32","002_26_32","GEN","26","32","32","ꠢꠃ ꠖꠤꠘꠃ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠈꠥꠖꠣ ꠄꠇ ꠇꠥꠀꠞ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠙꠣꠘꠤꠞ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN26_33","002_26_33","GEN","26","33","33","ꠅꠃ ꠔꠣꠁꠘ ꠄꠞ ꠘꠣꠝ ꠖꠤꠟꠣ ꠡꠦꠛꠣ ꠝꠣꠘꠤ, ꠇꠍꠝ। ꠄꠞꠟꠣꠉꠤ ꠀꠁꠎꠅ ꠢꠤꠘꠞ ꠘꠣꠝ ꠛꠦꠞ-ꠡꠦꠛꠣ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN26_34","002_26_34","GEN","26","34","34","ꠁꠡꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠢꠤꠐ꠆ꠐꠤ ꠛꠦꠞꠤꠞ ꠙꠥꠠꠤ ꠎꠤꠢꠥꠖꠤꠕ ꠀꠞ ꠢꠤꠐ꠆ꠐꠤ ꠄꠟꠘꠞ ꠙꠥꠠꠤ ꠛꠣꠡꠝꠔꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN26_35","002_26_35","GEN","26","35","35","ꠁ ꠖꠥꠁꠅ ꠛꠦꠐꠤꠄ ꠁꠍꠢꠣꠇ ꠀꠞ ꠞꠦꠛꠦꠇꠣꠞ ꠎꠣꠘꠞ ꠝꠣꠎꠦ ꠈꠥꠛ ꠖꠥꠈ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_1","002_27_1","GEN","27","1","1","ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠄꠅꠡꠅ ꠁꠍꠢꠣꠇꠞ ꠌꠃꠈꠞ ꠎꠥꠔꠤ ꠇꠝꠤ ꠎꠣꠅꠀꠄ ꠔꠣꠁꠘ ꠀꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠔꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠔꠣꠘ ꠛꠠ ꠙꠥꠀ ꠁꠡʼꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣꠞꠦ।” ꠁꠡꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅꠃꠘꠥ ꠀꠝꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN27_2","002_27_2","GEN","27","2","2","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠖꠦꠈꠅ, ꠀꠝꠤ ꠔ ꠛꠥꠠꠣ ꠅꠁꠉꠦꠍꠤ, ꠇꠥꠘꠖꠤꠘ ꠝꠞꠤꠎꠤꠝꠥ ꠇꠁꠔꠣꠝ ꠙꠣꠞꠤꠀꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_3","002_27_3","GEN","27","3","3","ꠔꠥꠝꠤ ꠄꠉꠥ ꠇꠣꠝ ꠇꠞꠅ; ꠔꠥꠝꠣꠞ ꠀꠔꠤꠀꠞ, ꠔꠤꠞ-ꠗꠘꠥꠇ ꠟꠁꠀ ꠎꠋꠉꠟꠅ ꠡꠤꠇꠣꠞꠅ ꠎꠣꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣ ꠡꠤꠇꠣꠞ ꠇꠞꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("GN27_4","002_27_4","GEN","27","4","4","ꠀꠝꠣꠞ ꠙꠍꠘ꠆ꠖꠞ ꠜꠣꠟꠣ ꠈꠣꠘꠤ ꠔꠂꠀꠞ ꠇꠞꠤ ꠀꠘꠅ, ꠔꠦꠃ ꠝꠞꠣꠞ ꠀꠉꠦ ꠁꠔꠣ ꠈꠣꠁꠀ ꠀꠝꠣꠞ ꠎꠣꠘꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN27_5","002_27_5","GEN","27","5","5","ꠁꠍꠢꠣꠇꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠙꠥꠀ ꠁꠡʼꠞ ꠟꠉꠦ ꠁꠔꠣ ꠝꠣꠔꠤꠞꠣ, ꠁ ꠡꠝꠄ ꠞꠦꠛꠦꠇꠣꠄ ꠁꠔꠣ ꠢꠥꠘꠍꠤꠟꠣ। ꠔꠦꠃ ꠁꠡ ꠎꠦꠛꠟꠣ ꠡꠤꠇꠣꠞꠅ ꠉꠦꠟꠣꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("GN27_6","002_27_6","GEN","27","6","6","ꠔꠣꠁꠘ ꠀꠁꠀ ꠔꠣꠘ ꠙꠥꠀ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠦ ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠁꠡʼꠞꠦ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("GN27_7","002_27_7","GEN","27","7","7","‘ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣ ꠡꠤꠇꠣꠞ ꠇꠞꠤ ꠜꠣꠟꠣ ꠈꠣꠘꠤ ꠔꠂꠀꠞ ꠇꠞꠅ, ꠔꠦꠃ ꠀꠝꠤ ꠝꠞꠣꠞ ꠀꠉꠦ ꠅꠔꠣ ꠈꠣꠁꠀ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("GN27_8","002_27_8","GEN","27","8","8","ꠔꠦ ꠞꠦ ꠙꠥꠔ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠅꠈꠘ ꠎꠦꠔꠣ ꠇꠞꠔꠣꠄ ꠇꠁꠝꠥ, ꠔꠥꠝꠤ ꠅꠃꠟꠣ ꠢꠥꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("GN27_9","002_27_9","GEN","27","9","9","ꠔꠥꠝꠤ ꠉꠤꠀ ꠙꠣꠟ ꠕꠣꠇꠤ ꠖꠥꠁꠐꠣ ꠔꠣꠎꠣ ꠈꠡꠤ ꠀꠘꠅ। ꠀꠝꠤ ꠁꠔꠣꠖꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠡꠈꠞ ꠈꠣꠘꠤ, ꠀꠌꠣꠘꠇ ꠝꠎꠣ ꠇꠞꠤ ꠞꠣꠘ꠆ꠖꠤꠀ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("GN27_10","002_27_10","GEN","27","10","10","ꠔꠦꠃ ꠔꠥꠝꠤ ꠅꠔꠣ ꠟꠁꠀ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠅ, ꠔꠣꠁꠘ ꠁꠔꠣ ꠈꠣꠁꠀ ꠝꠞꠣꠞ ꠀꠉꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠀ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN27_11","002_27_11","GEN","27","11","11","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠝꠣʼꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠜꠣꠁ ꠁꠡʼꠞ ꠡꠞꠤꠟ ꠔ ꠞꠥꠝꠣꠀꠟꠣ, ꠀꠝꠣꠞ ꠡꠞꠤꠟꠅ ꠔ ꠞꠥꠝꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN27_12","002_27_12","GEN","27","12","12","ꠎꠥꠖꠤ ꠛꠣꠛꠣꠄ ꠀꠝꠣꠞ ꠡꠞꠤꠟꠅ ꠀꠔꠣꠁꠘ, ꠔꠦ ꠝꠘꠅ ꠇꠞꠛꠣ ꠀꠝꠤ ꠔꠣꠘꠦ ꠗꠥꠇꠣ ꠖꠤꠀꠞ, ꠔꠣꠁꠟꠦ ꠀꠝꠤ ꠖꠥꠀꠞ ꠛꠖꠟꠣ ꠀꠞꠅ ꠟꠣꠘ꠆ꠘꠔ ꠒꠣꠇꠤꠀ ꠀꠘꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN27_13","002_27_13","GEN","27","13","13","ꠔꠦꠃ ꠔꠣꠘ ꠝꠣʼꠄ ꠇꠁꠟꠣ, “ꠙꠥꠔꠞꠦ, ꠔꠥꠝꠣꠞ ꠁ ꠟꠣꠘ꠆ꠘꠔ ꠀꠝꠣꠞ ꠃꠙꠞꠦꠃ ꠙꠠꠃꠇ। ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠝꠣꠔꠈꠣꠘ ꠢꠥꠘꠅ ꠀꠞ ꠈꠡꠤꠉꠥꠁꠘ ꠀꠘꠤꠀ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN27_14","002_27_14","GEN","27","14","14","ꠅꠃ ꠁꠀꠇꠥꠛꠦ ꠉꠤꠀ ꠈꠡꠤ ꠀꠘꠤꠀ ꠔꠣꠘ ꠝꠣʼꠞꠦ ꠖꠤꠟꠣ। ꠀꠞ ꠔꠣꠘ ꠛꠣꠚꠦ ꠎꠦꠟꠣ ꠡꠈ ꠇꠞꠂꠘ, ꠔꠣꠁꠘ ꠅꠃꠟꠣ ꠝꠎꠣ ꠇꠞꠤ ꠞꠣꠘ꠆ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_15","002_27_15","GEN","27","15","15","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠊꠞꠞ ꠝꠣꠎꠦ ꠕꠅꠀ ꠛꠠ ꠙꠥꠀ ꠁꠡʼꠞ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠀꠘꠤꠀ ꠔꠣꠘ ꠢꠥꠞꠥ ꠙꠥꠀ ꠁꠀꠇꠥꠛꠞꠦ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_16","002_27_16","GEN","27","16","16","ꠁꠀꠇꠥꠛꠞ ꠀꠔꠅ ꠀꠞ ꠉꠟꠣꠔ ꠎꠦ ꠎꠣꠉꠣꠔ ꠞꠥꠝꠣ ꠘꠣꠄ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠅꠃ ꠈꠡꠤꠞ ꠌꠣꠝꠠꠣ ꠟꠣꠉꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_17","002_27_17","GEN","27","17","17","ꠀꠞ ꠘꠤꠎꠞ ꠞꠣꠘ꠆ꠖꠣ ꠢꠃ ꠝꠎꠣꠞ ꠈꠣꠘꠤ ꠀꠞ ꠞꠥꠐꠤ ꠔꠣꠘ ꠙꠥꠀ ꠁꠀꠇꠥꠛꠞ ꠀꠔꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_18","002_27_18","GEN","27","18","18","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠒꠣꠇ ꠖꠤꠟꠣ, “ꠛꠣꠛꠣ।” ꠁꠍꠢꠣꠇꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅꠃꠘꠥ ꠀꠝꠤ, ꠔꠥꠝꠤ ꠇꠦ ꠞꠦ ꠙꠥꠔ?” ");
INSERT INTO syls_vpl VALUES ("GN27_19","002_27_19","GEN","27","19","19","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠛꠠ ꠙꠥꠀ ꠁꠡ। ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣ, ꠀꠝꠤ ꠅꠃꠟꠣ ꠇꠞꠍꠤ। ꠖꠄꠀ ꠇꠞꠤ ꠃꠑꠤꠀ ꠛꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞ ꠡꠤꠇꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠃꠇ꠆ꠇꠣ, ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN27_20","002_27_20","GEN","27","20","20","ꠁꠍꠢꠣꠇꠦ ꠔꠣꠘ ꠙꠥꠀꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣꠞꠦ, ꠔꠥꠝꠤ ꠅꠔ ꠎꠟꠖꠤ ꠡꠤꠇꠣꠞ ꠙꠣꠁꠟꠣꠄ ꠇꠤꠟꠣ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠝꠤꠟꠣꠁ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN27_21","002_27_21","GEN","27","21","21","ꠅꠃ ꠁꠍꠢꠣꠇꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ, ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠅ ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠉꠔꠞꠅ ꠀꠔ ꠖꠤꠀ ꠛꠥꠎꠝꠥ, ꠔꠥꠝꠤ ꠢꠣꠍꠣꠃ ꠀꠝꠣꠞ ꠙꠥꠀ ꠁꠡ ꠘꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN27_22","002_27_22","GEN","27","22","22","ꠁꠀꠇꠥꠛ ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠞ ꠀꠞꠅ ꠇꠣꠍꠣꠔ ꠉꠦꠟꠣ। ꠔꠣꠁꠘ ꠡꠞꠤꠟꠅ ꠀꠔꠣꠁꠀ ꠇꠁꠟꠣ, “ꠉꠟꠣꠞ ꠀꠅꠀꠎꠐꠣ ꠁꠀꠇꠥꠛꠞ, ꠅꠁꠟꠦ ꠀꠔ ꠖꠥꠁꠅꠈꠣꠘ ꠔ ꠁꠡʼꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN27_23","002_27_23","GEN","27","23","23","ꠁꠀꠇꠥꠛꠞ ꠀꠔ ꠔꠣꠘ ꠜꠣꠁ ꠁꠡʼꠞ ꠝꠔ ꠞꠥꠝꠦ ꠜꠞꠣ ꠀꠍꠤꠟ ꠇꠞꠤ ꠁꠍꠢꠣꠇꠦ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠟꠣ ꠘꠣ। ꠅꠃ ꠔꠣꠁꠘ ꠁꠀꠇꠥꠛꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_24","002_27_24","GEN","27","24","24","ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠢꠣꠍꠣꠃ ꠀꠝꠣꠞ ꠙꠥꠀ ꠁꠡ ꠘꠤ?” ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ ꠛꠣꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN27_25","002_27_25","GEN","27","25","25","ꠅꠃ ꠁꠍꠢꠣꠇꠦ ꠇꠁꠟꠣ, “ꠙꠥꠀꠞ ꠡꠤꠇꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠅ, ꠁꠔꠣ ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠀꠝꠣꠞ ꠎꠣꠘꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠛ।” ꠁꠀꠇꠥꠛꠦ ꠉꠥꠡ꠆ꠔ ꠟꠁꠀ ꠀꠁꠟꠦ ꠔꠣꠁꠘ ꠈꠣꠁꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠘꠞꠦ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠖꠤꠟꠦ ꠔꠣꠁꠘ ꠄꠅꠔꠣ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_26","002_27_26","GEN","27","26","26","ꠢꠦꠡꠦ ꠔꠣꠘ ꠛꠣꠚꠦ ꠇꠁꠟꠣ, “ꠅ ꠙꠥꠔ ꠀꠅ, ꠇꠣꠍꠣꠔ ꠀꠁꠀ ꠀꠝꠣꠞꠦ ꠢꠥꠋꠉꠣ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN27_27","002_27_27","GEN","27","27","27","ꠅꠃ ꠁꠀꠇꠥꠛꠦ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠢꠥꠋꠉꠣ ꠖꠤꠟꠣ, ꠀꠞ ꠁꠍꠢꠣꠇꠦ ꠔꠣꠘ ꠡꠞꠤꠟꠞ ꠇꠣꠙꠠꠞ ꠊꠦꠞꠣꠘ ꠢꠥꠋꠉꠤꠀ ꠔꠣꠘꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ, “ꠖꠦꠈꠅ, ꠀꠝꠣꠞ ꠙꠥꠀꠞ ꠊꠦꠞꠣꠘ ꠔ ꠝꠣꠛꠥꠖꠞ ꠛꠞꠇꠔꠤ ꠈꠦꠔꠞ ꠊꠦꠞꠣꠘꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN27_28","002_27_28","GEN","27","28","28","ꠀꠟ꠆ꠟꠣꠄ ꠀꠍꠝꠣꠘꠞ ꠈꠥꠀ ꠕꠘꠦ ꠀꠞ ꠞꠡꠣꠁꠟ ꠎꠝꠤꠘ ꠕꠘꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠃꠇ꠆ꠇꠣ; ꠛꠃꠔ ꠚꠡꠟ ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_29","002_27_29","GEN","27","29","29","ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠃꠇ, ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠕꠣ ꠘꠥꠀꠃꠇ। ꠘꠤꠎꠞ ꠎꠣꠔꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠤ ꠛꠠ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠅ, ꠔꠥꠝꠣꠞ ꠝꠣʼꠞ ꠙꠦꠐꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠕꠣ ꠘꠥꠀꠃꠇ। ꠎꠦ ꠔꠥꠝꠣꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠛ, ꠔꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠃꠇ। ꠎꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠀ ꠇꠞꠛ, ꠢꠦ ꠞꠢꠝꠔꠤ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("GN27_30","002_27_30","GEN","27","30","30","ꠁꠍꠢꠣꠇꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠖꠥꠀ ꠇꠞꠣ ꠡꠦꠡ ꠅꠁꠟꠦ, ꠁꠀꠇꠥꠛ ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠞ ꠍꠣꠝꠘꠦ ꠕꠘꠦ ꠢꠞꠔꠦꠃ, ꠔꠣꠘ ꠜꠣꠁ ꠁꠡꠦ ꠡꠤꠇꠣꠞ ꠟꠁꠀ ꠊꠞꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_31","002_27_31","GEN","27","31","31","ꠔꠣꠁꠘꠅ ꠜꠣꠟꠣ ꠈꠣꠘꠤ ꠔꠂꠀꠞ ꠇꠞꠤꠀ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ, ꠃꠑꠤꠀ ꠛꠁꠀ ꠀꠙꠘꠣꠞ ꠙꠥꠀꠞ ꠡꠤꠇꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠃꠇ꠆ꠇꠣ, ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠀꠙꠘꠣꠞ ꠎꠣꠘꠦ ꠀꠝꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN27_32","002_27_32","GEN","27","32","32","ꠅꠃ ꠔꠣꠘ ꠛꠣꠚꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠦ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ, ꠀꠝꠤ ꠔ ꠀꠙꠘꠣꠞ ꠛꠠ ꠙꠥꠀ ꠁꠡ।” ");
INSERT INTO syls_vpl VALUES ("GN27_33","002_27_33","GEN","27","33","33","ꠀꠞ ꠁꠍꠢꠣꠇꠞ ꠡꠞꠤꠟꠅ ꠛꠦꠎꠥꠁꠔꠣ ꠇꠣꠙꠣ ꠡꠥꠞꠥ ꠅꠁꠟ। ꠇꠣꠙꠤ ꠇꠣꠙꠤ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠣꠁꠟꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠡꠤꠇꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠟꠁꠀ ꠎꠦ ꠀꠁꠍꠤꠟ, ꠁꠉꠥ ꠇꠦ? ꠔꠥꠝꠤ ꠀꠁꠛꠣꠞ ꠀꠉꠦꠃ ꠀꠝꠤ ꠅꠔꠣ ꠈꠣꠁꠀ ꠔꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠍꠤ, ꠀꠞ ꠖꠥꠀꠞ ꠚꠟ ꠢꠦ-ꠃ ꠙꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN27_34","002_27_34","GEN","27","34","34","ꠛꠣꠚꠞ ꠝꠣꠔ ꠢꠥꠘꠤꠀꠃ ꠁꠡꠦ ꠄꠇꠦꠛꠣꠞꠦ ꠛꠥꠇ ꠜꠣꠋꠉꠤꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠎꠣꠘ, ꠀꠝꠣꠞꠦ, ꠀꠝꠣꠞꠦꠅ ꠖꠥꠀ ꠇꠞꠅ!” ");
INSERT INTO syls_vpl VALUES ("GN27_35","002_27_35","GEN","27","35","35","ꠁꠍꠢꠣꠇꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠜꠣꠁꠄ ꠀꠁꠀ ꠌꠔꠥꠞꠤ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠖꠥꠀ ꠘꠤꠍꠦꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN27_36","002_27_36","GEN","27","36","36","ꠁꠡꠦ ꠇꠁꠟꠣ, “ꠔꠣꠞ ꠘꠣꠝ ꠁꠀꠇꠥꠛ ꠝꠣꠘꠤ, ꠗꠥꠇꠣꠛꠣꠎ ꠘꠣꠄ ꠘꠤ? ꠢꠣꠍꠣꠃ ꠢꠦ ꠖꠥꠁꠛꠣꠞ ꠀꠝꠣꠞꠦ ꠗꠥꠇꠣ ꠖꠤꠍꠦ। ꠛꠠ ꠙꠥꠀ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠢꠦ ꠀꠉꠦ ꠌꠥꠞꠤ ꠇꠞꠤ ꠘꠤꠍꠤꠟ, ꠀꠞ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁꠚꠤꠞꠣ ꠀꠝꠣꠞ ꠖꠥꠀꠅ ꠟꠁꠀ ꠉꠦꠟꠉꠤ।” ꠔꠣꠁꠘ ꠚꠤꠞꠤꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠖꠥꠀꠃ ꠞꠣꠈꠍꠂꠘ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN27_37","002_27_37","GEN","27","37","37","ꠁꠍꠢꠣꠇꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠘꠦꠔꠣ ꠛꠣꠘꠣꠁꠍꠤ, ꠀꠞ ꠔꠣꠞ ꠉꠥꠡ꠆ꠐꠤꠞꠦ ꠔꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠁꠍꠤ, ꠔꠣꠞꠦ ꠚꠡꠟ ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠖꠤꠀ ꠍꠣꠝꠣꠘꠤ ꠇꠞꠍꠤ; ꠅꠈꠘ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝꠞꠦ ꠙꠥꠔ?” ");
INSERT INTO syls_vpl VALUES ("GN27_38","002_27_38","GEN","27","38","38","ꠁꠡꠦ ꠚꠤꠞꠤꠀ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠣꠎꠣꠘ, ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠇꠤꠔꠣ ꠅꠃ ꠄꠇ ꠖꠥꠀꠃ ꠀꠍꠤꠟ ꠘꠤ? ꠛꠣꠎꠣꠘ ꠞꠦꠛꠣ, ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ, ꠀꠝꠣꠞꠦꠅ ꠖꠥꠀ ꠇꠞꠃꠇ꠆ꠇꠣ!” ꠅꠔꠣ ꠇꠁꠀ ꠔꠣꠁꠘ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN27_39","002_27_39","GEN","27","39","39","ꠅꠃ ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠛꠡꠔꠈꠣꠘꠣꠞ ꠝꠣꠐꠤ ꠘꠤꠞꠡ ꠅꠁꠛ, ꠢꠤꠘꠅ ꠀꠍꠝꠣꠘꠞ ꠈꠥꠀꠅ ꠙꠠꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN27_40","002_27_40","GEN","27","40","40","ꠔꠟꠥꠀꠞꠃ ꠔꠥꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠅꠁꠛ, ꠀꠞ ꠘꠤꠎꠞ ꠜꠣꠁꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠛꠣꠄ; ꠅꠁꠟꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠤ ꠘꠣ-ꠝꠣꠘꠞꠣ ꠅꠁꠎꠤꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠘꠤꠎꠞ ꠉꠞ꠆ꠖꠘꠣ ꠕꠣꠇꠤ ꠔꠣꠞ ꠎꠥꠀꠟ ꠢꠞꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN27_41","002_27_41","GEN","27","41","41","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠘꠦ ꠖꠥꠀ ꠙꠣꠁꠍꠟꠣ ꠇꠞꠤ ꠁꠡꠦ ꠔꠣꠘꠞꠦ ꠁꠋꠡꠣꠁꠔꠣ ꠟꠣꠉꠟꠣ। ꠁꠡꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠟꠣꠉꠤ ꠝꠃꠔꠞ ꠇꠣꠘ꠆ꠖꠘꠞ ꠖꠤꠘ ꠀꠁꠌ꠆ꠌꠦ। ꠄꠞꠛꠣꠖꠦꠃ ꠔꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN27_42","002_27_42","GEN","27","42","42","ꠞꠦꠛꠦꠇꠣꠄ ꠔꠣꠘ ꠛꠠ ꠙꠥꠀ ꠁꠡʼꠞ ꠁꠔꠣ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠢꠥꠘꠟꠣ, ꠔꠦꠃ ꠢꠥꠞꠥ ꠙꠥꠀ ꠁꠀꠇꠥꠛꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠁꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠖꠤꠟꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠟꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN27_43","002_27_43","GEN","27","43","43","ꠀꠝꠣꠞ ꠙꠥꠔ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠝꠣꠔꠈꠣꠘ ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠢꠣꠞꠣꠘ ꠐꠣꠃꠘꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠟꠣꠛꠘꠞ ꠉꠦꠍꠦ ꠢꠞꠤꠀ ꠎꠣꠅꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("GN27_44","002_27_44","GEN","27","44","44","ꠀꠞ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞ ꠉꠥꠍꠣ ꠘꠣ ꠇꠝꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠘ ꠉꠦꠍꠦ ꠕꠣꠇꠅ। ");
INSERT INTO syls_vpl VALUES ("GN27_45","002_27_45","GEN","27","45","45","ꠔꠣꠞ ꠉꠥꠍꠣ ꠇꠝꠤꠉꠦꠟꠦ, ꠔꠥꠝꠤ ꠔꠣꠞ ꠟꠉꠦ ꠎꠦꠔꠣ ꠇꠞꠍ ꠁꠔꠣ ꠢꠦ ꠚꠣꠃꠞꠤꠟꠤꠟꠦ, ꠀꠝꠤ ꠈꠛꠞꠤꠀꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠘꠣꠁꠝꠥ। ꠇꠤꠔꠣꠟ꠆ꠟꠣꠉꠤ ꠀꠝꠤ ꠄꠇꠖꠤꠘꠦ ꠔꠥꠝꠞꠣ ꠖꠥꠁꠅꠎꠘꠞꠦ ꠀꠞꠣꠁꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("GN27_46","002_27_46","GEN","27","46","46","ꠛꠣꠖꠦ ꠞꠦꠛꠦꠇꠣꠄ ꠁꠍꠢꠣꠇꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠢꠤꠐ꠆ꠐꠤ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠀꠞ ꠛꠣꠌꠣꠞ ꠡ꠆ꠛꠣꠖ ꠘꠣꠁ। ꠁꠀꠇꠥꠛꠦꠅ ꠎꠥꠖꠤ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠁ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠢꠤꠐ꠆ꠐꠤ ꠙꠥꠠꠤꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠤꠟꠣꠄ, ꠔꠣꠁꠟꠦ ꠀꠝꠣꠞ ꠀꠞ ꠛꠣꠌꠤꠀꠃ ꠟꠣꠜ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("GN28_1","002_28_1","GEN","28","1","1","ꠞꠦꠛꠦꠇꠣꠞ ꠝꠣꠔ ꠢꠥꠘꠤꠀ ꠁꠍꠢꠣꠇꠦ, ꠁꠀꠇꠥꠛꠞꠦ ꠀꠘꠣꠁꠀ ꠖꠥꠀ ꠇꠞꠟꠣ ꠀꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN28_2","002_28_2","GEN","28","2","2","ꠔꠥꠝꠤ ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝ ꠖꠦꠡꠅ ꠔꠥꠝꠣꠞ ꠘꠣꠘꠣ ꠛꠕꠥꠄꠟꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ, ꠢꠘꠅ ꠔꠥꠝꠣꠞ ꠝꠣꠝꠥ ꠟꠣꠛꠘꠞ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("GN28_3","002_28_3","GEN","28","3","3","ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠃꠇ꠆ꠇꠣ ꠀꠞ ꠚꠟꠖꠣꠞ ꠇꠞꠤꠀ ꠛꠃꠔ ꠛꠣꠠꠣꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠇꠞꠤ ꠔꠥꠝꠤ ꠛꠃꠔ ꠉꠥꠡ꠆ꠐꠤꠀꠟꠣ ꠎꠣꠔꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("GN28_4","002_28_4","GEN","28","4","4","ꠎꠦ ꠛꠞꠇꠔ ꠔꠣꠁꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠘꠣꠎꠤꠟ ꠇꠞꠍꠟꠣ, ꠢꠃ ꠛꠞꠇꠔ ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠋꠡꠞꠦ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠀꠞ ꠎꠦ ꠖꠦꠡ ꠀꠟ꠆ꠟꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠖꠤꠍꠂꠘ, ꠎꠦꠈꠣꠘꠅ ꠔꠥꠝꠤ ꠅꠈꠘ ꠝꠥꠍꠣꠚꠤꠞ ꠀꠍ, ꠁ ꠖꠦꠡꠈꠣꠘ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN28_5","002_28_5","GEN","28","5","5","ꠛꠣꠖꠦ ꠁꠍꠢꠣꠇꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣ, ꠀꠞ ꠔꠣꠁꠘ ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝꠅ ꠅꠞꠣꠝꠤ ꠛꠕꠥꠄꠟꠞ ꠙꠥꠀ ꠟꠣꠛꠘꠞ ꠉꠦꠍꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ꠟꠣꠛꠘ ꠅꠁꠟꠣ ꠞꠦꠛꠦꠇꠣꠞ ꠜꠣꠁ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠁꠡʼꠞ ꠝꠣꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN28_6","002_28_6","GEN","28","6","6","ꠁꠡꠦ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣ, ꠁꠍꠢꠣꠇꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠖꠥꠀ ꠇꠞꠤꠀ ꠛꠤꠀ ꠇꠞꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝꠅ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠀꠞ ꠇꠦꠘꠣꠘꠤ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠛꠤꠀ ꠇꠞꠔꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("GN28_7","002_28_7","GEN","28","7","7","ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠝꠣ-ꠛꠣꠚꠞ ꠢꠥꠇꠥꠝꠦ ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝꠅ ꠉꠦꠍꠂꠘꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("GN28_8","002_28_8","GEN","28","8","8","ꠅꠃ ꠁꠡꠦ ꠛꠥꠎꠟꠣ ꠎꠦꠘ, ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠢꠣꠇ ꠇꠦꠘꠣꠘꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN28_9","002_28_9","GEN","28","9","9","ꠄꠞꠟꠣꠉꠤ ꠖꠥꠁ ꠛꠃ ꠕꠣꠇꠟꠦꠅ ꠔꠣꠁꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠙꠥꠀ ꠁꠍꠝꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠔꠣꠘ ꠙꠥꠠꠤ ꠝꠢꠟꠔꠞꠦ ꠛꠤꠀ ꠇꠞꠟꠣ। ꠝꠢꠟꠔ ꠅꠁꠟꠣ ꠘꠣꠛꠣꠃꠔꠞ ꠛꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("GN28_10","002_28_10","GEN","28","10","10","ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠛꠦꠞ-ꠡꠦꠛꠣ ꠍꠣꠠꠤꠀ ꠔꠣꠘ ꠝꠣꠝꠥꠞ ꠛꠣꠠꠤ ꠢꠣꠞꠣꠘ ꠐꠣꠃꠘꠞ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN28_11","002_28_11","GEN","28","11","11","ꠙꠕꠅ ꠄꠇ ꠎꠣꠉꠣꠔ ꠡꠥꠞꠥꠎ ꠒꠥꠛꠤ ꠉꠦꠟꠦ ꠔꠣꠁꠘ ꠢꠘꠅꠃ ꠞꠣꠁꠔ ꠇꠣꠐꠣꠁꠟꠣ। ꠢꠘꠞ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠢꠤꠔꠣꠘ ꠖꠤꠀ ꠁꠀꠇꠥꠛꠦ ꠊꠥꠝꠣꠁꠔꠣ ꠇꠞꠤ ꠢꠥꠔꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN28_12","002_28_12","GEN","28","12","12","ꠢꠥꠔꠤꠀ ꠢꠣꠞꠟꠦ ꠈꠥꠀꠛꠦ ꠖꠦꠈꠟꠣ, ꠖꠥꠘꠤꠀꠁꠞ ꠃꠙꠞꠦ ꠄꠇꠈꠣꠘ ꠝꠁ ꠃꠛꠣꠁ ꠞꠁꠍꠦ, ꠁ ꠝꠁꠞ ꠝꠣꠕꠣ ꠀꠍꠝꠣꠘꠅ ꠟꠣꠉꠣꠁꠟ। ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠅꠉꠥꠛꠣꠄ ꠃꠑꠣ-ꠘꠣꠝꠣ ꠇꠞꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("GN28_13","002_28_13","GEN","28","13","13","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠄꠞ ꠃꠙꠞꠦ ꠃꠛꠣꠁꠀ ꠇꠁꠞꠣ, “ꠀꠝꠤ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠁꠍꠢꠣꠇꠞ ꠀꠟ꠆ꠟꠣ। ꠔꠥꠝꠤ ꠅꠃ ꠎꠦ ꠎꠝꠤꠘꠅ ꠢꠥꠔꠤꠍ, ꠁꠐꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN28_14","002_28_14","GEN","28","14","14","ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟ ꠖꠥꠘꠤꠀꠁꠞ ꠗꠥꠁꠟ-ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠤꠡꠣꠛ ꠅꠁꠛꠣ। ꠀꠞ ꠙꠥꠛꠦ-ꠙꠁꠌꠝꠦ, ꠃꠔꠞꠦ-ꠖꠃꠇꠘꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠝꠦꠟꠤꠎꠤꠛꠣ। ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠋꠡꠞ ꠝꠣꠎꠦꠖꠤ ꠖꠥꠘꠤꠀꠁꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠄ ꠛꠞꠇꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN28_15","002_28_15","GEN","28","15","15","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠤ, ꠔꠥꠝꠤ ꠎꠦꠘꠅꠃ ꠎꠣꠅ ꠘꠣ ꠇꠦꠘꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠝꠥ ꠀꠞ ꠅꠃ ꠖꠦꠡꠅ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠣꠞꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠝꠥ। ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠁꠍꠤ ꠁꠔꠣ ꠢꠣꠍꠤꠟ ꠅꠀꠞ ꠀꠉꠦ, ꠔꠥꠝꠣꠞꠦ ꠍꠣꠠꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN28_16","002_28_16","GEN","28","16","16","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠊꠥꠝ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠇꠁꠟꠣ, “ꠔꠣꠁꠟꠦ ꠢꠣꠍꠣꠃ ꠝꠣꠛꠥꠖ ꠁꠘꠅ ꠀꠍꠂꠘ, ꠀꠝꠤ ꠔ ꠎꠣꠘꠔꠣꠝ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN28_17","002_28_17","GEN","28","17","17","ꠅꠃ ꠔꠣꠁꠘ ꠒꠞꠣꠁꠀ ꠇꠁꠟꠣ, “ꠇꠤꠎꠣꠔ ꠉꠞꠝ ꠁ ꠎꠣꠉꠣ! ꠁꠈꠣꠘ ꠘꠤꠌ꠆ꠌꠄ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ, ꠅꠈꠣꠘꠅꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠖꠥꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN28_18","002_28_18","GEN","28","18","18","ꠔꠣꠁꠘ ꠚꠎꠞꠞ ꠡꠝꠄ ꠃꠑꠤꠀ, ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠐꠣ ꠔꠣꠘ ꠝꠣꠕꠣꠞ ꠔꠟꠦ ꠢꠤꠔꠣꠘ ꠖꠤꠍꠟꠣ, ꠁꠇꠐꠣ ꠈꠥꠐꠤꠞ ꠝꠔ ꠇꠞꠤ ꠉꠣꠠꠤꠀ ꠄꠞ ꠃꠙꠞꠦ ꠔꠦꠟ ꠓꠣꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN28_19","002_28_19","GEN","28","19","19","ꠀꠞ ꠢꠤ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠛꠦꠕꠦꠟ ꠝꠣꠘꠤ, ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ, ꠁꠘꠞ ꠀꠉꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠟꠥꠎ। ");
INSERT INTO syls_vpl VALUES ("GN28_20","002_28_20","GEN","28","20","20","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠁ ꠍꠚꠞꠅ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠂꠘ, ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇ, ꠚꠤꠘ꠆ꠖꠣꠞ ꠟꠦꠛꠣꠍ ꠎꠥꠉꠣꠁ ꠖꠦꠁꠘ, ");
INSERT INTO syls_vpl VALUES ("GN28_21","002_28_21","GEN","28","21","21","ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠚꠤꠞꠤꠀ ꠀꠁ, ꠔꠦ ꠅꠃ ꠝꠣꠛꠥꠖꠞꠦꠃ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ ꠝꠣꠘꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN28_22","002_28_22","GEN","28","22","22","ꠀꠞ ꠅꠃ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞ ꠀꠝꠤ ꠈꠥꠐꠤ ꠉꠣꠠꠤꠀ ꠕꠁꠟꠣꠝ, ꠅꠘꠅ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠅꠁꠛ। ꠀꠞ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠔꠔꠣ ꠖꠤꠛꠣꠄ, ꠄꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠝꠤ ꠘꠤꠌ꠆ꠌꠄ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN29_1","002_29_1","GEN","29","1","1","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠀꠐꠤ ꠀꠐꠤ ꠙꠥꠛꠞ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞ ꠄꠟꠣꠇꠣꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN29_2","002_29_2","GEN","29","2","2","ꠉꠤꠀ ꠢꠘꠞ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠄꠇ ꠇꠥꠀ ꠖꠦꠈꠟꠣ। ꠢꠃ ꠇꠥꠀꠞ ꠉꠦꠍꠦ ꠔꠤꠘ ꠙꠣꠟ ꠝꠦꠠꠣ ꠢꠥꠔꠤ ꠞꠁꠍꠦ; ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠅꠘ ꠕꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠂꠘ। ꠀꠞ ꠇꠥꠀꠞ ꠝꠥꠈꠅ ꠛꠠ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞ ꠕꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN29_3","002_29_3","GEN","29","3","3","ꠢꠇꠟ ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠎꠦꠛꠟꠣ ꠄꠇꠈꠣꠘꠅ ꠅꠁꠔ, ꠔꠦꠃ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠇꠥꠀꠞ ꠝꠥꠈ ꠕꠘꠦ ꠙꠣꠔ꠆ꠔꠞꠉꠥ ꠢꠞꠣꠁ ꠖꠤꠀ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞꠦ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠔ। ꠛꠣꠖꠦ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠥꠀꠞ ꠝꠥꠈꠅ ꠕꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("GN29_4","002_29_4","GEN","29","4","4","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠜꠣꠁ ꠅꠇꠟ, ꠀꠙꠘꠣꠞꠣ ꠇꠥꠘ ꠎꠣꠉꠣꠞ ꠝꠣꠘꠥꠡ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠢꠣꠞꠣꠘ ꠐꠣꠃꠘꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN29_5","002_29_5","GEN","29","5","5","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠘꠣꠢꠥꠞꠞ ꠘꠣꠔꠤ ꠟꠣꠛꠘꠞꠦ ꠌꠤꠘꠂꠘ ꠘꠤ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠌꠤꠘꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN29_6","002_29_6","GEN","29","6","6","ꠁꠀꠇꠥꠛꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠣꠁꠘ ꠜꠣꠟꠣ ꠀꠍꠂꠘ ꠘꠤ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠜꠣꠟꠣ ꠀꠍꠂꠘ। ꠅꠃꠘꠥ ꠔꠣꠘ ꠙꠥꠠꠤ ꠞꠣꠢꠦꠟꠣꠄ ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠟꠁꠀ ꠀꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN29_7","002_29_7","GEN","29","7","7","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠅꠈꠘꠅ ꠛꠃꠔ ꠛꠦꠁꠟ ꠀꠍꠦ। ꠔꠦ ꠙꠡꠥ ꠅꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠅꠁꠛꠣꠞ ꠡꠝꠄ ꠔ ꠅꠁꠍꠦ ꠘꠣ। ꠀꠙꠘꠣꠞꠣ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞꠦ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠞꠣꠈꠣꠔ ꠟꠁꠀ ꠎꠣꠁꠘꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN29_8","002_29_8","GEN","29","8","8","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠘꠣ, ꠀꠝꠞꠣ ꠁꠟꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ, ꠢꠇ꠆ꠇꠟ ꠙꠣꠟ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠟꠦ ꠛꠣꠖꠦ ꠇꠥꠀꠞ ꠝꠥꠈ ꠕꠘꠦ ꠙꠣꠔ꠆ꠔꠞ ꠢꠞꠣꠁꠀ ꠀꠝꠞꠣ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞꠦ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁ।” ");
INSERT INTO syls_vpl VALUES ("GN29_9","002_29_9","GEN","29","9","9","ꠔꠣꠁꠘ ꠅꠈꠘꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠅ ꠞꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠞꠣꠢꠦꠟꠣꠄ ꠔꠣꠘ ꠛꠣꠚꠞ ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠟꠁꠀ ꠅꠘꠅ ꠀꠁꠟꠣ, ꠔꠣꠁꠘ ꠁ ꠙꠣꠟꠞ ꠞꠣꠈꠣꠟꠤꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_10","002_29_10","GEN","29","10","10","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠝꠣꠝꠥ ꠟꠣꠛꠘꠞ ꠙꠥꠠꠤ ꠞꠣꠢꠦꠟꠣꠞꠦ ꠀꠞ ꠔꠣꠘ ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠖꠦꠈꠤꠀꠃ ꠇꠥꠀꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠥꠀꠞ ꠝꠥꠈ ꠕꠘꠦ ꠙꠣꠔ꠆ꠔꠞꠐꠣ ꠢꠞꠣꠁꠀ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞꠦ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_11","002_29_11","GEN","29","11","11","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠞꠣꠢꠦꠟꠣꠞꠦ ꠝꠣꠄꠀ ꠖꠤꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠣꠘ꠆ꠖꠤꠔꠣ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_12","002_29_12","GEN","29","12","12","ꠀꠞ ꠔꠣꠁꠘ ꠞꠣꠢꠦꠟꠣꠞꠦ ꠇꠁꠟꠣ ꠎꠦꠘ, ꠔꠣꠁꠘ ꠟꠣꠛꠘꠞ ꠜꠣꠁꠉꠘꠣ, ꠞꠦꠛꠦꠇꠣꠞ ꠙꠥꠀ। ꠅꠃ ꠞꠣꠢꠦꠟꠣꠄ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠁ ꠈꠛꠞ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_13","002_29_13","GEN","29","13","13","ꠟꠣꠛꠘꠦ ꠔꠣꠘ ꠜꠣꠁꠉꠘꠣ ꠁꠀꠇꠥꠛꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠖꠃꠠꠣꠁꠀ ꠔꠣꠘ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠀꠁꠟꠣ। ꠔꠣꠘꠞꠦ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠢꠥꠋꠉꠣ ꠖꠤꠀ ꠛꠣꠠꠤꠔ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠁꠀꠇꠥꠛꠦ ꠟꠣꠛꠘꠞꠦ ꠔꠣꠘ ꠀꠁꠛꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_14","002_29_14","GEN","29","14","14","ꠟꠣꠛꠘꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞꠃ ꠎꠣꠘ ꠀꠞ ꠀꠝꠣꠞꠃ ꠉꠥꠡ꠆ꠔ।” ꠀꠞ ꠁꠀꠇꠥꠛ ꠟꠣꠛꠘꠞ ꠛꠣꠠꠤꠔ ꠄꠇ ꠝꠣꠡ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_15","002_29_15","GEN","29","15","15","ꠄꠇ ꠝꠣꠡ ꠛꠣꠖꠦ ꠟꠣꠛꠘꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠇꠥꠐꠥꠝ ꠅꠁꠟꠣꠄ ꠇꠞꠤ ꠛꠤꠘꠣ ꠛꠦꠔꠘꠦ ꠀꠝꠣꠞ ꠌꠣꠇꠞꠤ ꠇꠞꠔꠣꠄ ꠘꠤ ꠛꠣ? ꠔꠥꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠖꠤꠔꠣꠝ, ꠇꠁꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN29_16","002_29_16","GEN","29","16","16","ꠟꠣꠛꠘꠞ ꠖꠥꠁꠐꠣ ꠙꠥꠠꠤ ꠀꠍꠤꠟ। ꠛꠠꠉꠥꠞ ꠘꠣꠝ ꠟꠦꠀ ꠀꠞ ꠢꠥꠞꠥꠉꠥꠞ ꠘꠣꠝ ꠞꠣꠢꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_17","002_29_17","GEN","29","17","17","ꠟꠦꠀꠞ ꠈꠣꠟꠤ ꠌꠃꠈꠃ ꠡꠥꠘ꠆ꠖꠞ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠞꠣꠢꠦꠟꠣꠞ ꠉꠑꠘ ꠀꠞ ꠌꠦꠢꠣꠞꠣ-ꠍꠥꠞꠔ, ꠢꠇ꠆ꠇꠟꠔꠣ ꠡꠥꠘ꠆ꠖꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN29_18","002_29_18","GEN","29","18","18","ꠁꠀꠇꠥꠛꠦ ꠞꠣꠢꠦꠟꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠔꠣ ꠇꠞꠤ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠢꠥꠞꠥ ꠙꠥꠠꠤ ꠞꠣꠢꠦꠟꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠡꠣꠔ ꠛꠞꠍ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN29_19","002_29_19","GEN","29","19","19","ꠟꠣꠛꠘꠦ ꠇꠁꠟꠣ, “ꠞꠣꠢꠦꠟꠣꠞꠦ ꠝꠣꠘꠡꠞ ꠀꠔꠅ ꠖꠦꠅꠀꠞ ꠌꠣꠁꠔꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠖꠦꠅꠀꠃ ꠜꠣꠟꠣ। ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN29_20","002_29_20","GEN","29","20","20","ꠔꠦꠃ ꠁꠀꠇꠥꠛꠦ ꠞꠣꠢꠦꠟꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠔ ꠛꠞꠍ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠟꠣ। ꠞꠣꠢꠦꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠔꠣ ꠇꠞꠤ, ꠁꠔꠣ ꠄꠇꠅ ꠛꠞꠍ ꠔꠣꠘ ꠉꠦꠍꠦ ꠄꠇ ꠖꠤꠘꠞ ꠢꠝꠣꠘ ꠝꠘꠅ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN29_21","002_29_21","GEN","29","21","21","ꠢꠦꠡꠦ ꠔꠣꠁꠘ ꠟꠣꠛꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝꠤꠞ ꠝꠤꠀꠖ ꠙꠥꠞꠤ ꠉꠦꠍꠦ। ꠅꠈꠘ ꠀꠝꠣꠞ ꠛꠃꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁꠀ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠔꠣꠁꠞ ꠉꠦꠍꠦ ꠞꠁꠔꠣꠝ ꠌꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("GN29_22","002_29_22","GEN","29","22","22","ꠔꠦꠃ ꠟꠣꠛꠘꠦ ꠢꠃ ꠄꠟꠣꠇꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠀꠞ ꠖꠣꠅꠔ ꠇꠞꠤꠀ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠈꠣꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_23","002_29_23","GEN","29","23","23","ꠢꠦꠡꠦ ꠞꠣꠁꠔ ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠔꠣꠘ ꠙꠥꠠꠤ ꠟꠦꠀꠞꠦ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠖꠤꠟꠣ, ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠄꠘ ꠟꠉꠦ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_24","002_29_24","GEN","29","24","24","ꠟꠣꠛꠘꠦ ꠘꠤꠎꠞ ꠛꠣꠘ꠆ꠖꠤ ꠎꠤꠟꠙꠣꠞꠦ, ꠔꠣꠘ ꠙꠥꠠꠤ ꠟꠦꠀꠞ ꠛꠣꠘ꠆ꠖꠤ ꠉꠤꠞꠤꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_25","002_29_25","GEN","29","25","25","ꠅꠁꠟꠦ ꠛꠤꠀꠘꠦ ꠃꠑꠤꠀ ꠖꠦꠈꠂꠘ, ꠄꠁꠘ ꠔ ꠟꠦꠀ। ꠔꠦꠃ ꠁꠀꠇꠥꠛꠦ ꠟꠣꠛꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠁꠔꠣ ꠇꠥꠘ ꠎꠣꠔꠞ ꠇꠣꠝ ꠇꠞꠟꠣ? ꠅꠔ ꠖꠤꠘ ꠀꠝꠤ ꠞꠣꠢꠦꠟꠣꠞ ꠟꠣꠉꠤ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠍꠤ ꠘꠣꠄ ꠘꠤ? ꠔꠦ ꠀꠝꠣꠞꠦ ꠗꠥꠇꠣ ꠖꠤꠟꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("GN29_26","002_29_26","GEN","29","26","26","ꠟꠣꠛꠘꠦ ꠇꠁꠟꠣ, “ꠛꠠ ꠙꠥꠠꠤꠞ ꠀꠉꠦ ꠢꠥꠞꠥ ꠙꠥꠠꠤꠞ ꠛꠤꠀ ꠖꠦꠅꠀ ꠀꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠌꠟ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN29_27","002_29_27","GEN","29","27","27","ꠔꠥꠝꠤ ꠛꠤꠀꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠞ ꠢꠣꠙ꠆ꠔꠣꠐꠣ ꠙꠣꠞ ꠅꠁꠔꠦ ꠖꠦꠅ। ꠔꠦꠃ ꠢꠤ ꠙꠥꠠꠤꠞꠦꠅ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠖꠤꠝꠥ, ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠀꠞꠅ ꠡꠣꠔ ꠛꠞꠍ ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN29_28","002_29_28","GEN","29","28","28","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠇꠕꠣ ꠝꠣꠘꠤꠀ ꠅꠃ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠞ ꠢꠣꠙ꠆ꠔꠣ ꠙꠣꠞ ꠇꠞꠟꠣ। ꠛꠣꠖꠦ ꠟꠣꠛꠘꠦ ꠔꠣꠘ ꠙꠥꠠꠤ ꠞꠣꠢꠦꠟꠣꠞꠦꠅ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠡꠣꠖꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_29","002_29_29","GEN","29","29","29","ꠀꠞ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤ ꠛꠤꠟꠢꠣꠞꠦ ꠞꠣꠢꠦꠟꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠉꠤꠞꠤꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_30","002_29_30","GEN","29","30","30","ꠁꠀꠇꠥꠛꠦ ꠞꠣꠢꠦꠟꠣꠞ ꠟꠉꠦꠅ ꠞꠁꠟꠣ, ꠔꠣꠁꠘ ꠟꠦꠀꠞ ꠌꠣꠁꠔꠦ ꠞꠣꠢꠦꠟꠣꠞꠦ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠔꠣ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠞꠅ ꠡꠣꠔ ꠛꠞꠍ ꠔꠣꠘ ꠝꠣꠝꠥ ꠟꠣꠛꠘꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_31","002_29_31","GEN","29","31","31","ꠅꠁꠟꠦ ꠟꠦꠀꠞꠦ ꠝꠣꠄꠀ ꠘꠣ ꠇꠞꠣꠄ, ꠝꠣꠛꠥꠖꠦ ꠟꠦꠀꠞꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣꠞ ꠈꠦꠝꠔꠣ ꠖꠤꠟꠣ, ꠀꠞ ꠞꠣꠢꠦꠟꠣ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN29_32","002_29_32","GEN","29","32","32","ꠀꠞ ꠟꠦꠀꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ। ꠔꠣꠁꠘ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠞꠥꠛꠦꠘ ꠝꠣꠘꠤ, ꠙꠥꠀꠞꠦ ꠖꠦꠈꠅ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠖꠥꠈ ꠖꠦꠈꠍꠂꠘ, ꠅꠈꠘ ꠘꠤꠌ꠆ꠌꠄ ꠀꠝꠣꠞ ꠎꠣꠝꠣꠁꠄ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN29_33","002_29_33","GEN","29","33","33","ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ। ꠔꠣꠁꠘ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠡꠤꠝꠤꠅꠘ ꠝꠣꠘꠤ, ꠢꠥꠘꠂꠘ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠣꠞ ꠇꠕꠣ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠘꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠅꠃ ꠙꠥꠀ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN29_34","002_29_34","GEN","29","34","34","ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠀꠝꠣꠞ ꠎꠣꠝꠣꠁꠄ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠡꠤꠇ ꠅꠁꠛꠣ, ꠔꠣꠘ ꠔꠤꠘꠐꠣ ꠙꠥꠀ ꠀꠝꠣꠞ ꠙꠦꠐ ꠕꠘꠦ ꠙꠄꠖꠣ ꠅꠁꠟ।” ꠅꠃ ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠟꠦꠛꠤ ꠝꠣꠘꠤ, ꠀꠡꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("GN29_35","002_29_35","GEN","29","35","35","ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠀꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠚꠤꠞꠣ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠝꠥ।” ꠀꠞ ꠔꠣꠁꠘ ꠅꠃ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠄꠢꠥꠖꠣ ꠝꠣꠘꠤ, ꠔꠣꠞꠤꠚ। ꠄꠞꠛꠣꠖꠦ ꠔꠣꠘ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠀ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN30_1","002_30_1","GEN","30","1","1","ꠞꠣꠢꠦꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣ, ꠔꠣꠘ ꠊꠞꠅ ꠁꠀꠇꠥꠛꠞ ꠇꠥꠘꠥ ꠀꠅꠟꠣꠖ ꠅꠁꠞꠣ ꠘꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠛꠘꠤꠞ ꠛꠣꠄ ꠁꠋꠡꠣ ꠙꠄꠖꠣ ꠅꠁꠟ। ꠔꠣꠁꠘ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞꠦ ꠀꠅꠟꠣꠖ ꠖꠦꠅ, ꠘꠣꠁꠟꠦ ꠀꠝꠤ ꠝꠞꠤꠎꠤꠝꠥ!” ");
INSERT INTO syls_vpl VALUES ("GN30_2","002_30_2","GEN","30","2","2","ꠔꠦꠃ ꠞꠣꠢꠦꠟꠣꠞ ꠟꠉꠦ ꠁꠀꠇꠥꠛꠦ ꠈꠥꠛ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠇꠥꠘꠥ ꠀꠟ꠆ꠟꠣ ꠘꠤ? ꠔꠣꠁꠘꠃ ꠔ ꠔꠥꠝꠣꠞ ꠙꠦꠐ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN30_3","002_30_3","GEN","30","3","3","ꠞꠣꠢꠦꠟꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠛꠤꠟꠢꠣ ꠅꠘꠅ ꠀꠍꠦ, ꠀꠙꠘꠦ ꠔꠣꠁꠞ ꠉꠦꠍꠦ ꠎꠣꠃꠇ꠆ꠇꠣ, ꠔꠣꠁꠞꠦꠖꠤ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠣꠁꠀ ꠀꠝꠤꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠟꠣ ꠅꠁꠎꠤꠔꠣꠝ ꠙꠣꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN30_4","002_30_4","GEN","30","4","4","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠞꠣꠢꠦꠟꠣꠄ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤ ꠛꠤꠟꠢꠣꠞꠦ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠢꠣꠋꠉꠣ ꠖꠤꠟꠣ, ꠀꠞ ꠁꠀꠇꠥꠛ ꠔꠣꠁꠞ ꠉꠦꠍꠦ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_5","002_30_5","GEN","30","5","5","ꠔꠦꠃ ꠛꠤꠟꠢꠣꠞ ꠊꠞꠅ ꠁꠀꠇꠥꠛꠞ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN30_6","002_30_6","GEN","30","6","6","ꠀꠞ ꠞꠣꠢꠦꠟꠣꠄ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠁꠘꠍꠣꠚ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠀꠝꠣꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠢꠥꠘꠤꠀ ꠄꠉꠥ ꠙꠥꠀ ꠖꠤꠍꠂꠘ।” ꠔꠣꠁꠘ ꠁ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠖꠣꠘ ꠝꠣꠘꠤ, ꠁꠘꠍꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("GN30_7","002_30_7","GEN","30","7","7","ꠛꠣꠖꠦ ꠞꠣꠢꠦꠟꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠛꠤꠟꠢꠣꠞ ꠊꠞꠅ ꠢꠤꠞꠛꠣꠞ ꠁꠀꠇꠥꠛꠞ ꠖꠥꠍꠞꠣ ꠙꠥꠀ ꠙꠄꠖꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN30_8","002_30_8","GEN","30","8","8","ꠀꠞ ꠞꠣꠢꠦꠟꠣꠄ ꠇꠁꠟꠣ, “ꠛꠁꠘꠞ ꠟꠉꠦ ꠝꠢꠣ ꠟꠣꠠꠣꠁꠔ ꠀꠝꠤ ꠎꠤꠔꠍꠤ।” ꠅꠃ ꠔꠣꠁꠘ ꠁ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠘꠙ꠆ꠔꠣꠟꠤ ꠝꠣꠘꠤ, ꠟꠣꠠꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("GN30_9","002_30_9","GEN","30","9","9","ꠟꠦꠀꠄ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣ ꠔꠣꠘ ꠊꠞꠅ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠞꠣ ꠘꠣ, ꠔꠦꠃ ꠔꠣꠁꠘꠅ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤ ꠎꠤꠟꠙꠣꠞꠦ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠢꠣꠋꠉꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_10","002_30_10","GEN","30","10","10","ꠔꠦꠃ ꠟꠦꠀꠞ ꠛꠣꠘ꠆ꠖꠤ ꠎꠤꠟꠙꠣꠞ ꠙꠦꠐꠅ ꠁꠀꠇꠥꠛꠞ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN30_11","002_30_11","GEN","30","11","11","ꠀꠞ ꠟꠦꠀꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠇꠙꠣꠟ ꠈꠥꠟꠍꠦ!” ꠔꠣꠁꠘ ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠍꠣꠖꠥ ꠝꠣꠘꠤ, ꠇꠙꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("GN30_12","002_30_12","GEN","30","12","12","ꠛꠣꠖꠦ ꠟꠦꠀꠞ ꠛꠣꠘ꠆ꠖꠤ ꠎꠤꠟꠙꠣꠞ ꠊꠞꠅ ꠁꠀꠇꠥꠛꠞ ꠀꠞꠇ ꠙꠥꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN30_13","002_30_13","GEN","30","13","13","ꠀꠞ ꠟꠦꠀꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠇꠔ ꠡꠥꠈ! ꠢꠇꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠀꠝꠣꠞꠦ ꠡꠥꠈꠤ ꠇꠁꠛꠣ।” ꠔꠦꠃ ꠔꠣꠁꠘ ꠁ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠀꠡꠤꠞ ꠝꠣꠘꠤ, ꠡꠥꠈꠤ। ");
INSERT INTO syls_vpl VALUES ("GN30_14","002_30_14","GEN","30","14","14","ꠉꠝ ꠖꠣꠅꠀꠞ ꠡꠝꠄ ꠞꠥꠛꠦꠘꠦ ꠛꠘ꠆ꠖꠅ ꠉꠤꠀ ꠇꠤꠍꠥ ꠗꠥꠔꠞꠣ-ꠉꠥꠐꠣ ꠙꠣꠁꠀ, ꠔꠣꠘ ꠝꠣ ꠟꠦꠀꠞ ꠉꠦꠍꠦ ꠀꠘꠤꠀ ꠖꠤꠟꠣ। ꠀꠞ ꠞꠣꠢꠦꠟꠣꠄ ꠟꠦꠀꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠙꠥꠀꠞ ꠇꠄꠉꠥ ꠗꠥꠔꠞꠣ-ꠉꠥꠐꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠅꠌꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN30_15","002_30_15","GEN","30","15","15","ꠟꠦꠀꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠖꠈꠟ ꠇꠞꠍ, ꠁꠔꠣꠄ ꠅꠁꠍꠦ ꠘꠣ ꠘꠤ? ꠅꠈꠘ ꠀꠝꠣꠞ ꠙꠥꠀꠞ ꠗꠥꠔꠞꠣ-ꠉꠥꠐꠣꠅ ꠌꠣꠁꠞꠣꠄ ꠘꠤ?” ꠞꠣꠢꠦꠟꠣꠄ ꠇꠁꠟꠣ, “ꠔꠣꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠞ ꠗꠥꠔꠞꠣ-ꠉꠥꠐꠣꠞ ꠛꠖꠟꠣ ꠀꠁꠎ ꠞꠣꠁꠔ ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠞꠁꠛꠣ ꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN30_16","002_30_16","GEN","30","16","16","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠁꠀꠇꠥꠛꠦ ꠛꠘ꠆ꠖꠅ ꠕꠘꠦ ꠀꠁꠔꠦꠃ ꠟꠦꠀꠄ ꠛꠣꠞ ꠅꠁꠀ ꠔꠣꠘꠦ ꠇꠁꠟꠣ, “ꠀꠁꠎ ꠀꠝꠣꠞ ꠟꠉꠦ ꠞꠁꠛꠣꠄ, ꠇꠣꠞꠘ ꠀꠝꠣꠞ ꠙꠥꠀꠞ ꠗꠥꠔꠞꠣ-ꠉꠥꠐꠣꠞ ꠛꠖꠟꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠅꠟꠣꠔ ꠘꠤꠍꠤ।” ꠅꠃ ꠢꠤ ꠞꠣꠁꠔ ꠔꠣꠁꠘ ꠟꠦꠀꠞ ꠊꠞꠅ ꠢꠥꠔꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_17","002_30_17","GEN","30","17","17","ꠀꠟ꠆ꠟꠣꠄ ꠟꠦꠀꠞ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠣꠄ, ꠔꠣꠘ ꠊꠞꠅ ꠁꠀꠇꠥꠛꠞ ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN30_18","002_30_18","GEN","30","18","18","ꠅꠃ ꠟꠦꠀꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠎꠣꠝꠣꠁꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠖꠤꠍꠟꠣꠝ ꠇꠞꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠄꠞ ꠛꠖꠟꠣ ꠖꠤꠟꠣ।” ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠁ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠁꠍꠣꠈꠞ ꠝꠣꠘꠤ, ꠛꠖꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_19","002_30_19","GEN","30","19","19","ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠟꠦꠀꠞ ꠊꠞꠅ ꠁꠀꠇꠥꠛꠞ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN30_20","002_30_20","GEN","30","20","20","ꠟꠦꠀꠄ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠛꠃꠔ ꠛꠠ ꠄꠇ ꠘꠤꠀꠝꠔ ꠖꠤꠟꠣ। ꠅꠈꠘ ꠀꠝꠣꠞ ꠎꠣꠝꠣꠁꠄ ꠀꠝꠣꠞꠦ ꠖꠣꠝ ꠖꠤꠛꠣ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠔꠣꠘ ꠍꠄꠉꠥ ꠙꠥꠀꠞ ꠎꠘꠝ ꠖꠤꠍꠤ।” ꠔꠣꠁꠘ ꠁ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠍꠛꠥꠟꠘ ꠝꠣꠘꠤ, ꠖꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN30_21","002_30_21","GEN","30","21","21","ꠢꠦꠡꠦ ꠟꠦꠀꠞ ꠄꠇ ꠙꠥꠠꠤ ꠅꠁꠟ, ꠔꠣꠁꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠖꠤꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_22","002_30_22","GEN","30","22","22","ꠀꠟ꠆ꠟꠣꠄ ꠞꠣꠢꠦꠟꠣꠞ ꠛꠣꠄꠅ ꠈꠤꠀꠟ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠞꠣꠢꠦꠟꠣꠞ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠤꠀ, ꠔꠣꠘꠞꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_23","002_30_23","GEN","30","23","23","ꠀꠞ ꠞꠣꠢꠦꠟꠣꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞ ꠡꠞꠝ ꠢꠞꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN30_24","002_30_24","GEN","30","24","24","ꠔꠣꠁꠘ ꠁ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠁꠃꠍꠥꠚ ꠝꠣꠘꠤ, ꠛꠣꠠꠣꠘꠤ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠀꠞꠅꠉꠥ ꠙꠥꠀ ꠛꠣꠠꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN30_25","002_30_25","GEN","30","25","25","ꠞꠣꠢꠦꠟꠣꠞ ꠊꠞꠅ ꠁꠃꠍꠥꠚ ꠅꠀꠞ ꠛꠣꠖꠦ, ꠁꠀꠇꠥꠛꠦ ꠟꠣꠛꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠀꠝꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠘꠤꠎꠞ ꠖꠦꠡꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠁꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN30_26","002_30_26","GEN","30","26","26","ꠀꠙꠘꠦ ꠔ ꠎꠣꠘꠂꠘ, ꠀꠝꠤ ꠇꠤꠟꠣ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠍꠤ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠃꠀꠁꠘ ꠀꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠞ ꠟꠣꠉꠤ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠍꠤ। ꠅꠈꠘ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠀꠝꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN30_27","002_30_27","GEN","30","27","27","ꠟꠣꠛꠘꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠄꠀ ꠕꠣꠇꠦ, ꠔꠦ ꠎꠣꠁꠅ ꠘꠣ। ꠀꠝꠤ ꠀꠟꠣꠝꠔꠦ ꠛꠥꠎꠤꠀꠞ ꠎꠦꠘ, ꠔꠥꠝꠣꠞ ꠈꠣꠔꠤꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦꠅ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN30_28","002_30_28","GEN","30","28","28","ꠔꠥꠝꠣꠞ ꠛꠦꠔꠘ ꠔꠥꠝꠤ ꠘꠤꠎꠦꠃ ꠇꠁꠟꠣꠅ। ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠅꠟꠣꠃ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN30_29","002_30_29","GEN","30","29","29","ꠅꠃ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠇꠤꠟꠣ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠍꠤ, ꠀꠞ ꠀꠝꠣꠞ ꠀꠔꠅ ꠀꠙꠘꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠇꠤꠟꠣꠈꠣꠘ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠀꠙꠘꠦꠃ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN30_30","002_30_30","GEN","30","30","30","ꠀꠝꠤ ꠀꠅꠀꠞ ꠀꠉꠦ ꠀꠙꠘꠦ ꠉꠞꠤꠛ ꠀꠍꠟꠣ। ꠀꠞ ꠅꠈꠘ ꠔ ꠛꠣꠠꠤꠀ ꠛꠃꠔꠔꠣ ꠅꠁꠍꠦ। ꠀꠝꠣꠞ ꠇꠣꠞꠘꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠙꠘꠣꠞꠦ ꠛꠃꠔ ꠛꠞꠇꠔ ꠖꠤꠍꠂꠘ। ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠖꠤꠘ ꠇꠣꠝꠣꠁ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("GN30_31","002_30_31","GEN","30","31","31","ꠔꠦꠃ ꠟꠣꠛꠘꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠖꠤꠔꠣꠝ?” ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣ ꠖꠤꠀ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠄꠉꠥ ꠝꠣꠔ ꠞꠣꠈꠂꠘ, ꠔꠦ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠀꠙꠘꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN30_32","002_30_32","GEN","30","32","32","ꠀꠝꠤ ꠀꠁꠎ ꠀꠙꠘꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠉꠤꠀ, ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠖꠣꠉꠀꠟꠣ ꠀꠞ ꠇꠣꠟꠣ ꠀꠞ ꠍꠤꠔ꠆ꠞꠣ ꠝꠦꠠꠣꠁꠘ ꠀꠞ ꠍꠣꠉꠟꠞ ꠝꠣꠎꠦ ꠍꠤꠔ꠆ꠞꠣ ꠀꠞ ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠞꠋꠉꠞ ꠢꠇ꠆ꠇꠟꠐꠤ ꠀꠝꠣꠞ ꠛꠦꠔꠘ ꠛꠣꠛꠔ ꠘꠤꠝꠥꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN30_33","002_30_33","GEN","30","33","33","ꠔꠦꠃ ꠀꠙꠘꠦ ꠎꠦꠛꠟꠣꠃ ꠛꠦꠔꠘꠞ ꠇꠣꠞꠘꠦ ꠀꠁꠛꠣ, ꠁ ꠡꠝꠄ ꠖꠦꠈꠛꠣ, ꠀꠝꠣꠞ ꠁꠝꠣꠘꠖꠣꠞꠤꠄ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠀꠙ ꠖꠤꠛ। ꠀꠞ ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠖꠣꠉꠀꠟꠣ ꠀꠞ ꠇꠣꠟꠣ ꠀꠞ ꠍꠤꠔ꠆ꠞꠣ ꠝꠦꠠꠣꠁꠘ ꠀꠞ ꠍꠣꠉꠟꠞ ꠝꠣꠎꠦ ꠍꠤꠔ꠆ꠞꠣ ꠀꠞ ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠞꠋꠉꠞꠔꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠙꠣꠁꠟꠦ ꠝꠘꠅ ꠇꠞꠛꠣ, ꠀꠝꠤ ꠌꠥꠞꠤ ꠇꠞꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN30_34","002_30_34","GEN","30","34","34","ꠅꠃ ꠟꠣꠛꠘꠦ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠔꠥꠝꠣꠞ ꠇꠕꠣꠃ ꠑꠤꠇ ꠕꠣꠇꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("GN30_35","002_30_35","GEN","30","35","35","ꠟꠣꠛꠘꠦ ꠢꠃ ꠖꠤꠘꠃ ꠙꠣꠟ ꠕꠣꠇꠤ ꠟꠣꠝ꠆ꠛꠣ ꠖꠣꠉꠀꠟꠣ ꠀꠞ ꠍꠤꠔ꠆ꠞꠣ ꠍꠣꠉꠟ, ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠖꠣꠉ ꠀꠞ ꠍꠤꠔ꠆ꠞꠣ ꠕꠥꠠꠣ ꠕꠥꠠꠣ ꠗꠟꠣ ꠍꠣꠉꠤꠘ ꠀꠞ ꠇꠣꠟꠣ ꠝꠦꠠꠣ ꠅꠇꠟ ꠀꠟꠉꠣꠁꠀ ꠘꠤꠎꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_36","002_30_36","GEN","30","36","36","ꠖꠤꠀ ꠔꠣꠁꠘ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠤꠘ ꠖꠤꠘꠞ ꠙꠕ ꠖꠥꠞꠁ ꠢꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠟꠣꠛꠘꠞ ꠛꠣꠇꠤ ꠙꠣꠟ ꠅꠇꠟꠞꠦ ꠞꠣꠈꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_37","002_30_37","GEN","30","37","37","ꠁꠀꠇꠥꠛꠦ ꠟꠤꠛꠘꠤ, ꠟꠣꠃꠎ ꠀꠞ ꠀꠞ꠆ꠝꠥꠘ ꠉꠣꠍꠞ ꠇꠣꠌꠣ ꠒꠣꠟ ꠇꠣꠐꠤꠀ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠛꠣꠇꠟ ꠚꠣꠟꠣꠁꠀ ꠒꠣꠟꠞ ꠝꠣꠎꠦ ꠟꠣꠝ꠆ꠛꠣ ꠟꠣꠝ꠆ꠛꠣ ꠗꠟꠣ ꠖꠣꠉ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_38","002_30_38","GEN","30","38","38","ꠍꠣꠉꠟꠞ ꠙꠣꠟꠦ ꠀꠁꠀ ꠎꠦꠈꠣꠘꠅ ꠙꠣꠘꠤ ꠈꠣꠁꠘ, ꠔꠣꠁꠘ ꠅꠃ ꠛꠣꠇꠟ ꠚꠣꠟꠣꠁꠟ ꠖꠣꠉꠀꠟꠣ ꠒꠣꠟ ꠅꠇꠟ, ꠢꠘꠅ ꠙꠣꠘꠤꠞ ꠉꠣꠝꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠟꠣ। ꠀꠞ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠞ ꠡꠝꠄ ꠄꠞꠣ ꠚꠣꠟ ꠈꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("GN30_39","002_30_39","GEN","30","39","39","ꠔꠦꠃ ꠅꠃ ꠒꠣꠟꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠚꠣꠟ ꠈꠣꠅꠀꠄ ꠔꠣꠞꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘꠅ ꠍꠤꠔ꠆ꠞꠣ, ꠟꠣꠝ꠆ꠛꠣ ꠖꠣꠉꠀꠟꠣ ꠀꠞ ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠞꠋꠉꠞ ꠅꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_40","002_30_40","GEN","30","40","40","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠃ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠀꠟꠉꠣꠁꠔꠣ, ꠀꠞ ꠟꠣꠛꠘꠞ ꠒꠥꠞꠣꠀꠟꠣ ꠀꠞ ꠇꠣꠟꠣ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞ ꠛꠣꠄ ꠝꠦꠠꠤꠘ꠆ꠔꠞ ꠌꠃꠈ ꠞꠣꠈꠣꠁꠔꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠁꠘ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠣꠟꠞꠦ ꠟꠣꠛꠘꠞ ꠙꠣꠟꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠁꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_41","002_30_41","GEN","30","41","41","ꠀꠞ ꠎꠥꠞꠀꠟꠣ ꠝꠦꠠꠤ-ꠍꠣꠉꠤꠘ꠆ꠔꠦ ꠚꠣꠟ ꠈꠣꠅꠀꠞ ꠡꠝꠄ, ꠔꠣꠁꠘ ꠉꠣꠝꠟꠣꠔ ꠔꠣꠞꠣꠞ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠒꠣꠟ ꠅꠇꠟ ꠕꠁꠔꠣ, ");
INSERT INTO syls_vpl VALUES ("GN30_42","002_30_42","GEN","30","42","42","ꠅꠁꠟꠦ ꠇꠝꠎꠥꠞ ꠙꠡꠥꠞ ꠍꠣꠝꠘꠦ ꠁ ꠒꠣꠟꠣꠁꠘ ꠕꠁꠔꠣ ꠘꠣ। ꠔꠦꠃ ꠟꠣꠛꠘꠞ ꠙꠡꠥꠁꠘ ꠅꠁꠔꠣ ꠇꠝꠎꠥꠞ, ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠙꠡꠥꠁꠘ ꠅꠁꠔꠣ ꠎꠥꠞꠀꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN30_43","002_30_43","GEN","30","43","43","ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠤꠀ ꠔꠣꠁꠘ ꠛꠃꠔ ꠗꠘꠤ ꠅꠁꠟꠣ। ꠔꠣꠘ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ, ꠃꠐ-ꠉꠣꠗꠣ ꠀꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠛꠃꠔ ꠛꠣꠠꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN31_1","002_31_1","GEN","31","1","1","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠞ ꠇꠣꠘꠅ ꠀꠁꠟ ꠟꠣꠛꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠝꠣꠔꠤꠞꠣ ꠎꠦꠘ, “ꠁꠀꠇꠥꠛꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠚꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠘꠤꠍꠦꠉꠤ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠣꠚꠞ ꠝꠣꠟ ꠖꠤꠀꠃ ꠢꠦ ꠝꠣꠟꠖꠣꠞ ꠅꠁꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN31_2","002_31_2","GEN","31","2","2","ꠀꠞ ꠁꠀꠇꠥꠛꠦꠅ ꠈꠤꠀꠟ ꠇꠞꠟꠣ, ꠔꠣꠘꠛꠣꠄꠖꠤ ꠟꠣꠛꠘꠞ ꠀꠉꠞ ꠢꠤ ꠝꠘꠞ ꠜꠣꠛ ꠀꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN31_3","002_31_3","GEN","31","3","3","ꠝꠣꠛꠥꠖꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠖꠦꠡꠅ ꠘꠤꠎꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠎꠣꠅꠉꠤ। ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN31_4","002_31_4","GEN","31","4","4","ꠅꠃ ꠁꠀꠇꠥꠛꠦ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠀ ꠟꠦꠀ ꠀꠞ ꠞꠣꠢꠦꠟꠣꠞꠦ ꠛꠘ꠆ꠖꠅ ꠔꠣꠘ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠉꠦꠍꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN31_5","002_31_5","GEN","31","5","5","“ꠀꠝꠤ ꠔꠥꠝꠣꠞꠔꠣꠘꠞ ꠛꠣꠚꠞ ꠝꠥꠈ ꠖꠦꠈꠤꠀ ꠛꠥꠎꠤꠀꠞ, ꠔꠣꠘ ꠀꠉꠞ ꠢꠤ ꠝꠘꠞ ꠜꠣꠛ ꠀꠝꠣꠞ ꠛꠣꠄ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN31_6","002_31_6","GEN","31","6","6","ꠔꠥꠝꠤꠔꠣꠁꠘ ꠔ ꠎꠣꠘ ꠎꠦꠘ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠢꠇꠟ ꠡꠇ꠆ꠔꠤ ꠖꠤꠀꠃ ꠔꠣꠘ ꠇꠔ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠍꠤ, ");
INSERT INTO syls_vpl VALUES ("GN31_7","002_31_7","GEN","31","7","7","ꠔꠣ-ꠅ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠐꠉꠤꠍꠂꠘ ꠀꠞ ꠖꠡ-ꠖꠡꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠛꠦꠔꠘ ꠛꠖꠟꠣꠁꠍꠂꠘ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠅꠁꠔꠦ ꠖꠤꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_8","002_31_8","GEN","31","8","8","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠇꠁꠟꠣ, ꠔꠥꠝꠣꠞ ꠛꠦꠔꠘ ꠅꠁꠛ, ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠞꠋꠉꠞ ꠙꠡꠥ, ꠔꠦꠃ ꠙꠣꠟꠞ ꠢꠇꠟ ꠙꠡꠥꠄ ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠣꠁꠌ꠆ꠌꠣ ꠖꠤꠟ। ꠢꠤꠞꠛꠣꠞ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠇꠁꠟꠣ, ꠔꠥꠝꠣꠞ ꠛꠦꠔꠘ ꠅꠁꠛ ꠒꠥꠞꠣꠀꠟꠣ ꠙꠡꠥ, ꠔꠦꠃ ꠙꠣꠟꠞ ꠢꠇꠟ ꠙꠡꠥꠄ ꠒꠥꠞꠣꠀꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN31_9","002_31_9","GEN","31","9","9","ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠔꠣꠘ ꠙꠣꠟꠞ ꠙꠡꠥ ꠀꠘꠤꠀ ꠀꠝꠣꠞꠦ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN31_10","002_31_10","GEN","31","10","10","“ꠄꠇꠛꠣꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠦ ꠚꠣꠟ ꠈꠣꠅꠀꠞ ꠡꠝꠄ ꠀꠝꠤ ꠈꠥꠀꠛꠦ ꠖꠦꠈꠟꠣꠝ, ꠝꠦꠠꠤ-ꠍꠣꠉꠤꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠎꠦ ꠙꠣꠑꠣ ꠅꠇꠟ ꠃꠑꠤꠞꠣ, ꠁꠉꠥꠁꠘ ꠒꠥꠞꠣꠀꠟꠣ, ꠍꠤꠔ꠆ꠞꠣ ꠀꠞ ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠞꠋꠉꠞ। ");
INSERT INTO syls_vpl VALUES ("GN31_11","002_31_11","GEN","31","11","11","ꠈꠥꠀꠛꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠒꠣꠇꠤꠟꠣ, ‘ꠁꠀꠇꠥꠛ!’ ꠀꠝꠤ ꠇꠁꠟꠣꠝ, ‘ꠅꠃꠘꠥ ꠀꠝꠤ।’ ");
INSERT INTO syls_vpl VALUES ("GN31_12","002_31_12","GEN","31","12","12","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠤ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠖꠦꠈꠅ, ꠝꠦꠠꠤ-ꠍꠣꠉꠤꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠎꠦꠔꠣ ꠙꠣꠑꠣꠁꠘ ꠃꠑꠤꠞꠣ, ꠢꠇ꠆ꠇꠟꠐꠤ ꠒꠥꠞꠣꠀꠟꠣ, ꠍꠤꠔ꠆ꠞꠣ ꠀꠞ ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠞꠋꠉꠞ। ꠟꠣꠛꠘꠦ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠞꠍꠦ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠤ ꠖꠦꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN31_13","002_31_13","GEN","31","13","13","ꠀꠝꠤ ꠢꠃ ꠛꠦꠕꠦꠟꠞ ꠀꠟ꠆ꠟꠣ, ꠎꠦꠘꠅ ꠔꠥꠝꠤ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠔꠦꠟ ꠓꠣꠟꠤꠀ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠍꠟꠣꠄ। ꠅꠈꠘ ꠌꠟꠅ, ꠁ ꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠔꠥꠝꠣꠞ ꠎꠘꠝ ꠝꠣꠐꠤꠔ ꠚꠤꠞꠔ ꠎꠣꠅ।’ ” ");
INSERT INTO syls_vpl VALUES ("GN31_14","002_31_14","GEN","31","14","14","ꠅꠃ ꠟꠦꠀ ꠀꠞ ꠞꠣꠢꠦꠟꠣꠄ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣꠞ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤꠞ ꠇꠥꠘꠥ ꠖꠣꠛꠤ ꠀꠞ ꠀꠝꠞꠣꠞ ꠞꠁꠟ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GN31_15","002_31_15","GEN","31","15","15","ꠔꠣꠁꠘ ꠔ ꠀꠝꠞꠣꠞꠦ ꠛꠦꠉꠣꠘꠣ ꠝꠣꠘꠥꠡ ꠝꠘꠅ ꠇꠞꠤꠀ, ꠀꠝꠞꠣꠞꠦ ꠛꠦꠌꠤꠟꠣꠁꠍꠂꠘ ꠀꠞ ꠀꠝꠞꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠈꠣꠁꠟꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN31_16","002_31_16","GEN","31","16","16","ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠛꠣꠛꠣꠞ ꠍꠣꠝꠣꠘꠣ ꠕꠘꠦ ꠎꠔꠔꠣ ꠘꠤꠍꠂꠘ, ꠁ ꠢꠇ꠆ꠇꠟꠐꠤꠃ ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠀꠞ ꠀꠝꠞꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠅꠁꠍꠦ। ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠤꠅ ꠅꠃꠟꠣ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN31_17","002_31_17","GEN","31","17","17","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠀꠞ ꠛꠤꠛꠤꠘ꠆ꠔꠞꠦ ꠃꠐꠞ ꠃꠙꠞꠦ ꠔꠥꠟꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("GN31_18","002_31_18","GEN","31","18","18","ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝꠅ ꠔꠣꠘ ꠇꠣꠝꠣꠁꠟ ꠙꠡꠥ ꠅꠇꠟ ꠀꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠟꠁꠀ, ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠞ ꠉꠦꠍꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_19","002_31_19","GEN","31","19","19","ꠢꠃ ꠡꠝꠄ ꠟꠣꠛꠘꠦ ꠔꠣꠘ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞ ꠞꠥꠝꠣ ꠇꠣꠐꠣꠞ ꠟꠣꠉꠤ ꠉꠦꠍꠟꠣ, ꠀꠞ ꠅꠃ ꠚꠣꠇꠦ ꠞꠣꠢꠦꠟꠣꠄ ꠔꠣꠘ ꠛꠣꠚꠞ ꠝꠥꠞ꠆ꠔꠤ ꠅꠇꠟ ꠌꠥꠞꠤ ꠇꠞꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_20","002_31_20","GEN","31","20","20","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠎꠣꠅꠀꠞ ꠇꠕꠣ ꠅꠞꠣꠝꠤ ꠟꠣꠛꠘꠞꠦ ꠘꠣ ꠎꠣꠘꠣꠁꠀ ꠔꠣꠘꠞꠦ ꠐꠉꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_21","002_31_21","GEN","31","21","21","ꠀꠞ ꠔꠣꠁꠘ ꠢꠇ꠆ꠇꠟꠔꠣ ꠟꠁꠀ ꠜꠣꠉꠤꠀ, ꠚꠥꠞꠣꠔ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠉꠤꠟꠤꠅꠖꠞ ꠙꠣꠠꠞ ꠍꠣꠝꠘꠦꠖꠤ ꠎꠣꠅꠀꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_22","002_31_22","GEN","31","22","22","ꠎꠣꠅꠀꠞ ꠔꠤꠘ ꠖꠤꠘ ꠛꠣꠖꠦ ꠟꠣꠛꠘꠦ ꠢꠥꠘꠟꠣ ꠎꠦꠘ, ꠁꠀꠇꠥꠛ ꠜꠣꠉꠤꠀ ꠉꠦꠍꠂꠘꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN31_23","002_31_23","GEN","31","23","23","ꠅꠃ ꠔꠣꠁꠘ ꠈꠦꠡ-ꠇꠥꠐꠥꠝꠞꠦ ꠟꠁꠀ, ꠁꠀꠇꠥꠛꠞ ꠈꠞꠦ ꠅꠁꠀ ꠡꠣꠔ ꠖꠤꠘꠞ ꠙꠕ ꠉꠤꠀ, ꠉꠤꠟꠤꠅꠖꠞ ꠙꠣꠠꠅ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_24","002_31_24","GEN","31","24","24","ꠅꠁꠟꠦ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠀꠟ꠆ꠟꠣꠄ ꠈꠥꠀꠛꠦ ꠅꠞꠣꠝꠤ ꠟꠣꠛꠘꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠈꠛꠞꠖꠣꠞ! ꠁꠀꠇꠥꠛꠞꠦ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN31_25","002_31_25","GEN","31","25","25","ꠁꠀꠇꠥꠛꠦ ꠙꠣꠠꠞ ꠝꠣꠎꠦ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠍꠟꠣ, ꠀꠞ ꠟꠣꠛꠘꠦ ꠉꠤꠀ ꠔꠣꠘꠞꠦ ꠅꠘꠅꠃ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠟꠤꠟꠣ, ꠔꠦꠃ ꠟꠣꠛꠘ ꠀꠞ ꠔꠣꠘ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠅꠇꠟꠦꠅ ꠉꠤꠟꠤꠅꠖꠞ ꠢꠃ ꠙꠣꠠꠞ ꠝꠣꠎꠦ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_26","002_31_26","GEN","31","26","26","ꠛꠣꠖꠦ ꠟꠣꠛꠘꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠁꠔꠣ ꠇꠞꠟꠣꠄ? ꠀꠝꠣꠞꠦ ꠐꠉꠤꠀ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠇꠦꠘꠦ ꠎꠥꠖ꠆ꠖꠞ ꠛꠘ꠆ꠖꠤꠞ ꠟꠣꠈꠣꠘ ꠟꠁꠀ ꠀꠁꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("GN31_27","002_31_27","GEN","31","27","27","ꠇꠦꠘꠦ ꠔꠥꠝꠤ ꠗꠥꠇꠣ ꠖꠤꠀ ꠀꠝꠣꠞꠦ ꠘꠣ ꠎꠣꠘꠣꠁꠀ, ꠟꠥꠇꠣꠁꠀ ꠜꠣꠉꠤꠀ ꠀꠁꠟꠣꠄ? ꠀꠝꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠦ ꠔ ꠀꠝꠤ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠀ, ꠖꠥꠔꠣꠞꠣ ꠀꠞ ꠝꠘ꠆ꠖꠤꠞꠣ ꠛꠣꠎꠣꠁꠀ ꠉꠣꠘ ꠉꠣꠁꠀ, ꠔꠥꠝꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠝ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("GN31_28","002_31_28","GEN","31","28","28","ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠀꠞ ꠘꠣꠔꠤꠘꠡꠣꠞꠦꠅ ꠢꠥꠋꠉꠣ ꠖꠤꠔꠦꠅ ꠖꠤꠟꠣꠄ ꠘꠣ, ꠛꠦꠀꠈꠟꠞ ꠝꠔ ꠇꠣꠝ ꠇꠞꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN31_29","002_31_29","GEN","31","29","29","ꠅꠈꠘ ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠝꠥ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠀꠟ꠆ꠟꠣꠄ ꠉꠔ ꠞꠣꠁꠔ ꠀꠝꠣꠞꠦ ꠇꠁꠍꠂꠘ, ‘ꠈꠛꠞꠖꠣꠞ! ꠁꠀꠇꠥꠛꠞꠦ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠁꠅ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("GN31_30","002_31_30","GEN","31","30","30","ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠝꠘꠦ ꠇꠣꠘ꠆ꠖꠤꠍꠤꠟ ꠇꠞꠤ, ꠔꠥꠝꠤ ꠜꠣꠉꠤꠀ ꠀꠁꠍ ꠝꠣꠘꠟꠣꠝ, ꠔꠦ ꠀꠝꠣꠞ ꠖꠦꠛꠔꠣ ꠅꠇꠟ ꠇꠦꠘꠦ ꠌꠥꠞꠤ ꠇꠞꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("GN31_31","002_31_31","GEN","31","31","31","ꠁꠀꠇꠥꠛꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠒꠞꠣꠁꠍꠟꠣꠝ, ꠝꠘꠅ ꠇꠞꠍꠟꠣꠝ, ꠀꠙꠘꠦ ꠎꠥꠞ ꠇꠞꠤꠀ ꠀꠙꠘꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ, ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠇꠣꠠꠤꠀ ꠞꠣꠈꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_32","002_31_32","GEN","31","32","32","ꠔꠦ ꠅꠈꠘ ꠎꠣꠞ ꠉꠦꠍꠦ ꠀꠙꠘꠣꠞ ꠖꠦꠛꠔꠣꠁꠘ ꠙꠣꠁꠛꠣ, ꠔꠣꠞꠦ ꠎꠤꠔꠣ ꠞꠣꠈꠔꠣꠝ ꠘꠣꠄ। ꠀꠝꠞꠣꠞ ꠈꠦꠡ-ꠇꠥꠐꠝꠞ ꠍꠣꠝꠘꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠀꠙꠘꠣꠞ ꠇꠥꠘ꠆ꠔꠣ ꠙꠣꠁꠘ, ꠔꠣꠁꠟꠦ ꠘꠦꠃꠇ꠆ꠇꠣꠉꠤ।” ꠢꠃ ꠝꠥꠞ꠆ꠔꠤ ꠅꠇꠟ ꠎꠦꠘ ꠞꠣꠢꠦꠟꠣꠄ ꠌꠥꠞꠤ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠔ ꠁꠀꠇꠥꠛꠦ ꠎꠣꠘꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_33","002_31_33","GEN","31","33","33","ꠅꠃ ꠟꠣꠛꠘꠦ ꠁꠀꠇꠥꠛ, ꠟꠦꠀ ꠀꠞ ꠖꠥꠁꠅ ꠛꠣꠘ꠆ꠖꠤꠞ ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠁꠀ ꠢꠇꠟꠔꠣ ꠔꠥꠇꠣꠁꠀ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠙꠣꠁꠀ, ꠢꠦꠡꠦ ꠟꠦꠀꠞ ꠔꠣꠝ꠆ꠛꠥ ꠕꠘꠦ ꠞꠣꠢꠦꠟꠣꠞ ꠔꠣꠝ꠆ꠛꠥꠔ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_34","002_31_34","GEN","31","34","34","ꠞꠣꠢꠦꠟꠣꠄ ꠁ ꠝꠥꠞ꠆ꠔꠤ ꠅꠇꠟ ꠘꠤꠀ ꠃꠐꠞ ꠉꠖ꠆ꠖꠤꠞ ꠜꠤꠔꠞꠦ ꠕꠁꠀ, ꠔꠣꠁꠘ ꠅꠃ ꠉꠖ꠆ꠖꠤꠞ ꠃꠙꠞꠦ ꠛꠁꠟꠣ। ꠟꠣꠛꠘꠦ ꠔꠣꠘ ꠔꠣꠝ꠆ꠛꠥꠞ ꠢꠇꠟꠔꠣ ꠔꠥꠇꠣꠁꠀ ꠢꠘꠅ-ꠅ ꠁꠔꠣ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_35","002_31_35","GEN","31","35","35","ꠀꠞ ꠞꠣꠢꠦꠟꠣꠄ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠎꠣꠘ ꠀꠝꠤ ꠃꠑꠤꠀ ꠃꠛꠣꠁꠔꠣꠝ ꠙꠣꠞꠤꠀꠞ ꠘꠣ ꠇꠞꠤ ꠀꠙꠘꠦ ꠛꠦꠎꠣꠞ ꠅꠁꠘ ꠘꠣ ꠎꠦꠘ, ꠛꠦꠐꠤꠀꠞꠣ ꠛꠦꠝꠣꠞꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠡꠞꠤꠟ ꠈꠣꠞꠣꠙ।” ꠅꠃ ꠟꠣꠛꠘꠦ ꠢꠤ ꠝꠥꠞ꠆ꠔꠤ ꠅꠇꠟ ꠀꠞ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_36","002_31_36","GEN","31","36","36","ꠢꠦꠡꠦ ꠁꠀꠇꠥꠛꠦ ꠉꠥꠍꠣ ꠅꠁꠀ ꠟꠣꠛꠘꠞꠦ ꠍꠤꠠꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠅꠙꠞꠣꠗ ꠇꠤꠀꠘꠅ? ꠀꠝꠤ ꠇꠤꠔꠣ ꠖꠥꠡ ꠇꠞꠍꠤ, ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠈꠞꠦ ꠅꠁꠀ ꠅꠃꠟꠣ ꠈꠦꠖꠣꠘꠤꠔ ꠀꠁꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("GN31_37","002_31_37","GEN","31","37","37","ꠀꠝꠣꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠀꠃꠟꠣꠁꠀ ꠀꠙꠘꠣꠞ ꠊꠞꠞ ꠇꠥꠘ ꠎꠤꠘꠤꠡꠈꠣꠘ ꠙꠣꠁꠟꠣ? ꠙꠣꠁꠟꠦ ꠁꠔꠣ ꠀꠙꠘꠣꠞ-ꠀꠝꠣꠞ ꠈꠦꠡ-ꠇꠥꠐꠝꠞ ꠍꠣꠝꠘꠦ ꠞꠣꠈꠃꠇ꠆ꠇꠣ, ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_38","002_31_38","GEN","31","38","38","ꠀꠝꠤ ꠁ ꠛꠤꠡ ꠛꠞꠍ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣꠝ। ꠄꠞ ꠝꠣꠎꠦ ꠀꠙꠘꠣꠞ ꠇꠥꠘꠥ ꠝꠦꠠꠤ ꠛꠣ ꠍꠣꠉꠤꠞ ꠙꠦꠐꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠘꠡ꠆ꠐ ꠅꠁꠍꠦ ꠘꠣ ꠛꠣ ꠀꠙꠘꠣꠞ ꠙꠣꠟꠞ ꠇꠥꠘꠥ ꠝꠦꠠꠣꠅ ꠀꠝꠤ ꠈꠣꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_39","002_31_39","GEN","31","39","39","ꠀꠞ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠝꠣꠞꠣ ꠇꠥꠘꠥ ꠙꠡꠥꠅ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠍꠤ ꠘꠣ, ꠁꠔꠣ ꠀꠝꠤ ꠘꠤꠎꠦꠃ ꠙꠥꠞꠤꠀ ꠖꠤꠍꠤ। ꠖꠤꠘꠅ ꠛꠣ ꠞꠣꠁꠔ ꠇꠥꠘꠥ ꠙꠡꠥ ꠌꠥꠞꠤ ꠅꠁꠟꠦ, ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠞꠤꠀ ꠟꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN31_40","002_31_40","GEN","31","40","40","ꠀꠝꠤ ꠅꠃꠟꠣ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠍꠤ, ꠖꠤꠘꠅ ꠎꠟꠍꠤ ꠉꠞꠝꠦ ꠀꠞ ꠞꠣꠁꠔꠦ ꠇꠣꠙꠍꠤ ꠡꠤꠔꠦ। ꠀꠝꠣꠞ ꠌꠈꠥꠔ ꠊꠥꠝ ꠀꠁꠔ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_41","002_31_41","GEN","31","41","41","ꠎꠦ ꠛꠤꠡ ꠛꠞꠍ ꠀꠙꠘꠣꠞ ꠛꠣꠠꠤꠔ ꠞꠁꠍꠤ, ꠄꠞ ꠌꠃꠖ꠆ꠖ ꠛꠞꠍ ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠖꠥꠁ ꠙꠥꠠꠤꠞ ꠟꠣꠉꠤ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠍꠤ, ꠀꠞ ꠍꠄ ꠛꠞꠍ ꠉꠦꠍꠦ ꠀꠙꠘꠣꠞ ꠙꠡꠥꠞ ꠟꠣꠉꠤ। ꠄꠞ ꠝꠣꠎꠦ ꠀꠙꠘꠦ ꠖꠡ-ꠖꠡꠛꠣꠞ ꠀꠝꠣꠞ ꠛꠦꠔꠘꠅ ꠛꠖꠟꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN31_42","002_31_42","GEN","31","42","42","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ, ꠎꠣꠘꠞꠦ ꠀꠝꠣꠞ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠦ ꠝꠣꠛꠥꠖ ꠢꠤꠡꠣꠛꠦ ꠒꠞꠣꠁꠔꠣ, ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠖꠣꠖꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠅ ꠝꠣꠛꠥꠖ, ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠘꠣ ꠕꠣꠇꠔꠣ, ꠔꠦ ꠢꠣꠍꠣꠃ ꠅꠈꠘ ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠈꠣꠟꠤ ꠀꠔꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣ ꠅꠘꠦ। ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞ ꠝꠦꠘꠔ ꠀꠞ ꠖꠥꠈ ꠖꠦꠈꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠁꠘ ꠇꠣꠁꠟ ꠞꠣꠁꠔ ꠀꠙꠘꠣꠞꠦ ꠗꠝꠇꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN31_43","002_31_43","GEN","31","43","43","ꠟꠣꠛꠘꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠁ ꠙꠥꠠꠤꠘ ꠀꠝꠣꠞꠃ ꠙꠥꠠꠤꠘ, ꠀꠞ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠀꠝꠣꠞꠃ ꠘꠣꠔꠤꠘꠡꠣ, ꠀꠞ ꠁ ꠙꠡꠥꠞ ꠙꠣꠟ ꠅꠇꠟꠅ ꠀꠝꠣꠞ। ꠔꠥꠝꠤ ꠅꠘꠅ ꠎꠔꠔꠣ ꠖꠦꠈꠞꠣꠄ, ꠢꠇꠟꠔꠣꠃ ꠀꠝꠣꠞ, ꠔꠣ-ꠅ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠛꠣ ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠀꠝꠤ ꠀꠞ ꠇꠤꠔꠣ ꠇꠞꠝꠥ? ");
INSERT INTO syls_vpl VALUES ("GN31_44","002_31_44","GEN","31","44","44","ꠀꠅ, ꠀꠝꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠄꠇ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠤꠟꠣꠁ। ꠅꠃ ꠌꠥꠇ꠆ꠔꠤꠞ ꠘꠤꠡꠣꠘꠣꠐꠣ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN31_45","002_31_45","GEN","31","45","45","ꠅꠃ ꠁꠀꠇꠥꠛꠦ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞ ꠟꠁꠀ ꠈꠥꠐꠤ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_46","002_31_46","GEN","31","46","46","ꠀꠞ ꠔꠣꠘ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣꠅ ꠙꠣꠔ꠆ꠔꠞ ꠀꠘꠃꠇ꠆ꠇꠣ।” ꠔꠦꠃ ꠔꠣꠞꠣꠅ ꠙꠣꠔ꠆ꠔꠞ ꠀꠘꠤꠀ ꠄꠇ ꠜꠤꠐꠣ ꠛꠣꠘꠣꠁꠟꠣ, ꠢꠦꠡꠦ ꠅꠃ ꠜꠤꠐꠣꠞ ꠉꠦꠍꠦ ꠈꠣꠘꠤ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_47","002_31_47","GEN","31","47","47","ꠟꠣꠛꠘꠦ ꠢꠃ ꠜꠤꠐꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠎꠤꠉꠞ-ꠡꠣꠢꠖꠥꠔꠣ ꠝꠣꠘꠤ, ꠡꠣꠇ꠆ꠇꠤ-ꠜꠤꠐꠣ ꠅꠁꠟꠦ ꠁꠀꠇꠥꠛꠦ ꠄꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠉꠟ-ꠄꠖ। ");
INSERT INTO syls_vpl VALUES ("GN31_48","002_31_48","GEN","31","48","48","ꠟꠣꠛꠘꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠜꠤꠐꠣ ꠅꠈꠘ ꠕꠘꠦ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠅꠁꠟ।” ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠜꠤꠐꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠉꠟ-ꠄꠖ, ");
INSERT INTO syls_vpl VALUES ("GN31_49","002_31_49","GEN","31","49","49","ꠀꠞ ꠅꠃ ꠈꠥꠐꠤꠞ ꠘꠣꠝ ꠅꠁꠟ ꠝꠤꠡꠙꠣ ꠝꠣꠘꠤ, ꠙꠣꠢꠣꠞꠣꠞ ꠎꠣꠉꠣ। ꠟꠣꠛꠘꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠞꠤꠀ ꠎꠣꠁꠝꠥꠉꠤ ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦꠃ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠙꠣꠢꠣꠞꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_50","002_31_50","GEN","31","50","50","ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠖꠥꠈ ꠖꠦꠅ ꠛꠣ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠘ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠛꠤꠀ ꠇꠞꠅ, ꠔꠣꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠘꠣ ꠞꠁꠟꠦꠅ ꠀꠟ꠆ꠟꠣ ꠀꠝꠞꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠞꠁꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN31_51","002_31_51","GEN","31","51","51","ꠟꠣꠛꠘꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠅꠃ ꠜꠤꠐꠣ ꠛꠣꠄ ꠀꠞ ꠅꠃ ꠈꠥꠐꠤꠞ ꠛꠣꠄ ꠌꠣꠅ, ꠁꠐꠣ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠀꠝꠤ ꠉꠣꠠꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN31_52","002_31_52","GEN","31","52","52","ꠁ ꠖꠥꠁꠅꠐꠣ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠞꠁꠟ। ꠔꠥꠝꠤꠅ ꠁꠋꠡꠣ ꠇꠞꠤ ꠅꠃ ꠜꠤꠐꠣ ꠀꠞ ꠈꠥꠐꠤ ꠒꠤꠋꠉꠣꠁꠀ ꠀꠁꠛꠣꠄ ꠘꠣ ꠀꠞ ꠀꠝꠤꠅ ꠛꠥꠞꠣꠁꠞ ꠘꠤꠅꠔꠦ ꠁꠔꠣ ꠒꠤꠋꠉꠣꠁꠀ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN31_53","002_31_53","GEN","31","53","53","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ, ꠘꠣꠢꠥꠞꠞ ꠃꠙꠞꠀꠟꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞ ꠃꠙꠞꠀꠟꠣꠄ ꠔꠥꠝꠣꠞ-ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ।” ꠀꠞ ꠁꠀꠇꠥꠛꠦ, ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠦ ꠎꠣꠘꠞꠦ ꠒꠞꠣꠁꠔꠣ ꠔꠣꠘ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_54","002_31_54","GEN","31","54","54","ꠁꠀꠇꠥꠛꠦ ꠢꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠔꠣꠘ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠅꠇꠟꠞꠦ ꠈꠣꠅꠀꠞ ꠖꠣꠅꠀꠔ ꠖꠤꠟꠣ। ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠞꠣ ꠢꠃ ꠙꠣꠠꠞ ꠝꠣꠎꠦ ꠞꠣꠁꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN31_55","002_31_55","GEN","31","55","55","ꠛꠣꠖꠞ ꠖꠤꠘ ꠚꠎꠞꠦ ꠟꠣꠛꠘꠦ ꠔꠣꠘ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠀꠞ ꠘꠣꠔꠤꠘꠡꠣꠞꠦ ꠢꠥꠋꠉꠣ ꠖꠤꠀ ꠖꠥꠀ ꠇꠞꠟꠣ, ꠢꠦꠡꠦ ꠔꠣꠘ ꠛꠣꠠꠤ ꠝꠥꠈꠣ ꠙꠕ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_1","002_32_1","GEN","32","1","1","ꠁꠀꠇꠥꠛꠅ ꠔꠣꠘ ꠙꠕꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_2","002_32_2","GEN","32","2","2","ꠄꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠚꠃꠎ।” ꠀꠞ ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠝꠢꠘꠄꠁꠝ ꠝꠣꠘꠤ, ꠖꠥꠁ ꠚꠃꠎ। ");
INSERT INTO syls_vpl VALUES ("GN32_3","002_32_3","GEN","32","3","3","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠀꠉꠦ ꠇꠞꠤ ꠍꠦꠁꠞ ꠛꠣ ꠁꠖꠥꠝ ꠖꠦꠡꠅ, ꠔꠣꠘ ꠛꠠ ꠜꠣꠁ ꠁꠡʼꠞ ꠉꠦꠍꠦ ꠇꠄꠎꠘ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_4","002_32_4","GEN","32","4","4","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠢꠤꠇꠣꠁ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠁꠡʼꠞꠦ ꠇꠁꠅ, ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠁꠀꠇꠥꠛꠦ ꠇꠁꠍꠦ, ꠀꠝꠤ ꠅꠔꠖꠤꠘ ꠕꠘꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠝꠥ ꠟꠣꠛꠘꠞ ꠉꠦꠍꠦ ꠝꠥꠍꠣꠚꠤꠞꠤꠔ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN32_5","002_32_5","GEN","32","5","5","ꠀꠝꠣꠞ ꠉꠞꠥ-ꠉꠣꠗꠣ, ꠍꠣꠉꠟ-ꠝꠦꠠꠣ ꠀꠞ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ ꠢꠇꠟꠔꠣꠃ ꠀꠍꠦ। ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠉꠦꠍꠦ ꠖꠄꠀ ꠙꠣꠅꠀꠞ ꠀꠡꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN32_6","002_32_6","GEN","32","6","6","ꠈꠛꠞꠤꠀ ꠅꠇꠟꠦ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠜꠣꠁ ꠁꠡʼꠞ ꠉꠦꠍꠦ ꠉꠦꠍꠟꠣꠝ। ꠔꠣꠁꠘ ꠌꠣꠁꠞ-ꠡ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠣꠔ ꠀꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN32_7","002_32_7","GEN","32","7","7","ꠅꠃ ꠁꠀꠇꠥꠛꠦ ꠒꠞꠣꠁꠀ ꠈꠥꠛ ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠉꠦꠟꠣ। ꠔꠣꠁꠘ ꠟꠉꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ, ꠉꠞꠥ-ꠍꠣꠉꠟ, ꠝꠦꠠꠣ-ꠝꠦꠠꠤ ꠀꠞ ꠃꠐ-ꠉꠣꠗꠣ ꠅꠇꠟꠞꠦ ꠖꠥꠁ ꠖꠟꠦ ꠀꠟꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_8","002_32_8","GEN","32","8","8","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ꠜꠣꠁꠄ ꠀꠁꠀ ꠄꠇ ꠖꠟꠞꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠟꠦꠅ ꠀꠞꠇ ꠖꠟ ꠘꠤꠞꠣꠙꠖꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN32_9","002_32_9","GEN","32","9","9","ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠖꠥꠀ ꠇꠞꠟꠣ, “ꠅ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠖꠣꠖꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠣꠛꠥꠖ ꠀꠞ ꠀꠝꠣꠞ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠞ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠍ ꠎꠦꠘ, ‘ꠔꠥꠝꠣꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠎꠣꠅ, ꠔꠦꠃ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("GN32_10","002_32_10","GEN","32","10","10","ꠔꠥꠝꠣꠞ ꠁ ꠉꠥꠟꠣꠝꠞ ꠛꠣꠄ ꠎꠦ ꠞꠢꠝ ꠀꠞ ꠁꠝꠣꠘꠖꠣꠞꠤ ꠖꠦꠈꠣꠁꠍ, ꠀꠝꠤ ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠞꠃ ꠟꠣꠈ ꠘꠣꠄ। ꠀꠝꠤ ꠔ ꠄꠉꠥ ꠟꠣꠑꠤ ꠟꠁꠀ ꠁ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠍꠟꠣꠝ, ꠀꠞ ꠅꠈꠘ ꠖꠥꠁ ꠖꠟ ꠅꠁꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN32_11","002_32_11","GEN","32","11","11","ꠝꠣꠛꠥꠖ, ꠀꠝꠤ ꠀꠞꠎ ꠇꠞꠤꠀꠞ, ꠀꠝꠣꠞ ꠜꠣꠁ ꠁꠡʼꠞ ꠀꠔ ꠕꠘꠦ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠅ। ꠀꠝꠣꠞ ꠒꠞ ꠇꠞꠦꠞ, ꠢꠦ ꠀꠁꠀ ꠛꠃ ꠙꠥꠀ-ꠙꠥꠠꠤꠞ ꠟꠉꠦ ꠀꠝꠣꠞꠦꠅ ꠈꠥꠘ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("GN32_12","002_32_12","GEN","32","12","12","ꠔꠥꠝꠤꠃ ꠔ ꠅꠀꠖꠣ ꠇꠞꠍ, ‘ꠀꠝꠤ ꠅꠛꠡ꠆ꠡꠃ ꠔꠥꠝꠣꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠝꠥ, ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠞ ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠤꠡꠣꠛ ꠇꠞꠝꠥ, ꠎꠦꠟꠣ ꠉꠘꠤꠀ ꠚꠥꠠꠣꠄ ꠘꠣ।’ ” ");
INSERT INTO syls_vpl VALUES ("GN32_13","002_32_13","GEN","32","13","13","ꠁꠀꠇꠥꠛꠦ ꠁ ꠞꠣꠁꠔ ꠢꠘꠅ ꠞꠁꠟꠣ ꠀꠞ ꠔꠣꠘ ꠎꠔꠔꠣ ꠀꠍꠤꠟ ꠄꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠇꠔꠈꠣꠘ ꠟꠁꠀ ꠔꠣꠘ ꠜꠣꠁ ꠁꠡʼꠞ ꠟꠣꠉꠤ ꠄꠇ ꠃꠙꠢꠣꠞ ꠔꠂꠀꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_14","002_32_14","GEN","32","14","14","ꠁꠔꠣ ꠅꠁꠟ ꠖꠥꠁ-ꠡ ꠍꠣꠉꠤ, ꠇꠥꠠꠤꠐꠣ ꠍꠣꠉꠟ, ꠖꠥꠁ-ꠡ ꠝꠦꠠꠤ, ꠇꠥꠠꠤꠐꠣ ꠝꠦꠠꠣ, ");
INSERT INTO syls_vpl VALUES ("GN32_15","002_32_15","GEN","32","15","15","ꠔꠤꠡꠉꠥ ꠛꠣꠁꠌ꠆ꠌꠣꠀꠟꠣ ꠖꠥꠗꠞ ꠃꠐ, ꠖꠥꠁ ꠇꠥꠠꠤ ꠉꠣꠁ, ꠖꠡꠉꠥ ꠛꠤꠍꠣꠟ, ꠄꠇ ꠇꠥꠠꠤ ꠉꠣꠗꠤ ꠀꠞ ꠖꠡꠉꠥ ꠉꠣꠗꠣ, ");
INSERT INTO syls_vpl VALUES ("GN32_16","002_32_16","GEN","32","16","16","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠄꠇ ꠄꠇ ꠉꠥꠟꠣꠝꠞ ꠀꠔꠅ ꠄꠇ ꠄꠇ ꠙꠣꠟ ꠡꠝꠎꠣꠁ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠀꠉꠦ ꠅꠁꠀ ꠎꠣꠅ ꠀꠞ ꠄꠇ ꠙꠣꠟ ꠕꠣꠇꠤ ꠀꠞꠇ ꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠚꠣꠇ ꠞꠣꠈꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN32_17","002_32_17","GEN","32","17","17","ꠙꠄꠟꠣ ꠖꠟꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠔꠣꠁꠘ ꠢꠤꠇꠣꠁ ꠖꠤꠟꠣ, “ꠀꠝꠣꠞ ꠜꠣꠁ ꠁꠡʼꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠎꠤꠇꠣꠁꠛꠣ, ‘ꠇꠁ ꠎꠣꠁꠔꠣꠄ ꠛꠣ? ꠔꠥꠝꠤ ꠇꠣꠞ ꠝꠣꠘꠥꠡ? ꠔꠥꠝꠣꠞ ꠢꠝꠈꠞ ꠙꠡꠥꠁꠘ ꠇꠣꠞ?’ ");
INSERT INTO syls_vpl VALUES ("GN32_18","002_32_18","GEN","32","18","18","ꠔꠥꠝꠤ ꠎꠥꠀꠙ ꠖꠤꠅ, ‘ꠁꠔꠣ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠁꠀꠇꠥꠛꠞ। ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠁꠡʼꠞ ꠟꠣꠉꠤ, ꠁꠔꠣ ꠃꠙꠢꠣꠞ ꠙꠣꠑꠣꠁꠍꠂꠘ। ꠀꠞ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠈꠞꠦ ꠅꠁꠀ ꠀꠁꠞꠣ।’ ” ");
INSERT INTO syls_vpl VALUES ("GN32_19","002_32_19","GEN","32","19","19","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠁꠘ ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ, ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠖꠟꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦꠅ ꠢꠤꠇꠣꠁ ꠖꠤꠟꠣ ꠎꠦꠘ, “ꠁꠡʼꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠇꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("GN32_20","002_32_20","GEN","32","20","20","ꠀꠞ ꠢꠦꠡꠦ ꠇꠁꠅ, ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠁꠀꠇꠥꠛꠅ ꠀꠝꠞꠣꠞ ꠈꠞꠦ ꠅꠁꠀ ꠀꠁꠞꠣ।” ꠁꠀꠇꠥꠛꠦ ꠝꠘꠅ ꠇꠞꠟꠣ, “ꠀꠉꠦ ꠃꠙꠢꠣꠞ ꠅꠇꠟ ꠙꠣꠑꠣꠁꠀ ꠔꠣꠘꠦ ꠑꠣꠘ꠆ꠒꠣ ꠇꠞꠝꠥ, ꠛꠣꠖꠦ ꠔꠣꠘ ꠟꠉꠦ ꠖꠦꠈꠣ-ꠡꠣꠁꠇ꠆ꠇꠣꠔ ꠇꠞꠝꠥ, ꠔꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠤꠟꠤꠔꠣ ꠙꠣꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN32_21","002_32_21","GEN","32","21","21","ꠔꠣꠘ ꠀꠉꠦ ꠅꠁꠀ ꠃꠙꠢꠣꠞ ꠅꠇꠟ ꠉꠦꠟꠉꠤ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠞꠣꠁꠔ ꠔꠣꠘ ꠒꠦꠞꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_22","002_32_22","GEN","32","22","22","ꠢꠦꠡꠦ ꠞꠣꠁꠔ ꠃꠑꠤꠀ ꠔꠣꠘ ꠖꠥꠁꠅ ꠛꠤꠛꠤꠘ, ꠖꠥꠁꠅ ꠛꠣꠘ꠆ꠖꠤ ꠀꠞ ꠄꠉꠣꠞꠅꠉꠥ ꠙꠥꠀꠞꠦ ꠟꠁꠀ ꠙꠣꠅꠄ ꠀꠐꠤꠀ, ꠎꠣꠛ꠆ꠛꠥꠇ ꠈꠣꠟꠞ ꠢꠙꠣꠞꠅ ꠕꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_23","002_32_23","GEN","32","23","23","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠈꠣꠟ ꠙꠣꠞ ꠇꠞꠣꠁꠀ ꠔꠣꠘ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠅ ꠢꠘꠅ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_24","002_32_24","GEN","32","24","24","ꠀꠞ ꠔꠣꠁꠘ ꠄꠇꠟꠣ ꠅꠘꠅ ꠞꠁꠟꠣ, ꠔꠦꠃ ꠉꠣꠁꠛꠤ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠔꠣꠘ ꠟꠉꠦ ꠞꠣꠁꠔꠜꠞ ꠇꠥꠡ꠆ꠔꠣ-ꠇꠥꠡ꠆ꠔꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_25","002_32_25","GEN","32","25","25","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠣꠛꠥ ꠇꠞꠔꠣ ꠘꠣ ꠙꠣꠞꠣꠄ ꠄꠘ ꠃꠞꠣꠔꠞ ꠎꠥꠠꠣꠔ ꠝꠣꠞꠟꠣ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠃꠞꠣꠔꠞ ꠀꠠ ꠎꠣꠉꠣ ꠕꠘꠦ ꠒꠥꠟꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN32_26","002_32_26","GEN","32","26","26","ꠢꠦꠡꠦ ꠢꠤ ꠝꠣꠘꠡꠦ ꠇꠁꠟꠣ, “ꠚꠎꠞ ꠅꠁꠎꠣꠞ, ꠅꠈꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ।” ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠖꠥꠀ ꠘꠣ ꠇꠞꠟꠦ ꠍꠣꠠꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN32_27","002_32_27","GEN","32","27","27","ꠢꠤ ꠝꠣꠘꠡꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠇꠤꠔꠣ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠀꠇꠥꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN32_28","002_32_28","GEN","32","28","28","ꠅꠃ ꠢꠦꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠤꠀ ꠎꠤꠔꠍ ꠇꠞꠤ, ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠀꠞ ꠁꠀꠇꠥꠛ ꠞꠁꠔ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠁꠍꠞꠣꠁꠟ ꠝꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠇꠥꠡ꠆ꠔꠤ ꠇꠞꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN32_29","002_32_29","GEN","32","29","29","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠘꠣꠝꠈꠣꠘ ꠇꠤꠔꠣ ꠇꠃꠇ꠆ꠇꠣ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠘꠣꠝ ꠎꠤꠇꠣꠁꠞꠣꠄ?” ꠢꠦꠡꠦ ꠔꠣꠁꠘ ꠁꠀꠇꠥꠛꠞꠦ ꠖꠥꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_30","002_32_30","GEN","32","30","30","ꠅꠃ ꠁꠀꠇꠥꠛꠦ ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠙꠘꠥꠄꠟ ꠝꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠍꠥꠞꠔ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠖꠦꠈꠤꠀꠅ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN32_31","002_32_31","GEN","32","31","31","ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠙꠘꠥꠄꠟ ꠙꠣꠞꠘꠤꠞ ꠛꠣꠖꠦ ꠡꠥꠞꠥꠎ ꠃꠑꠤꠉꠦꠟ। ꠔꠣꠘ ꠃꠞꠣꠔꠞ ꠝꠣꠁꠞꠞ ꠟꠣꠉꠤ ꠟꠦꠋꠠꠣꠁꠔꠣ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN32_32","002_32_32","GEN","32","32","32","ꠄꠞꠟꠣꠉꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠈꠘꠅ ꠞꠣꠘꠞ ꠎꠥꠠꠣꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠘ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠃꠞꠣꠔꠞ ꠎꠥꠠꠣꠞ ꠞꠉꠞ ꠝꠣꠎꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠝꠣꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_1","002_33_1","GEN","33","1","1","ꠁꠀꠇꠥꠛꠦ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠔꠣꠘ ꠛꠠ ꠜꠣꠁ ꠁꠡꠦ ꠌꠣꠁꠞ-ꠡ ꠝꠣꠘꠥꠡ ꠟꠁꠀ ꠀꠉꠥꠀꠁꠀ ꠀꠁꠞꠣ। ꠅꠃ ꠔꠣꠁꠘ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠔꠣꠘ ꠛꠤꠛꠤꠘ ꠟꠦꠀ ꠀꠞ ꠞꠣꠢꠦꠟꠣ ꠀꠞ ꠖꠥꠁꠅ ꠛꠣꠘ꠆ꠖꠤꠞ ꠉꠦꠍꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_2","002_33_2","GEN","33","2","2","ꠔꠣꠁꠘ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤꠘ ꠀꠞ ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠍꠣꠝꠘꠞ ꠇꠣꠔꠣꠞꠅ ꠞꠣꠈꠟꠣ। ꠛꠣꠖꠦ ꠟꠦꠀ ꠀꠞ ꠔꠣꠘ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ, ꠢꠇꠟ ꠢꠦꠡꠦ ꠞꠣꠈꠟꠣ ꠞꠣꠢꠦꠟꠣ ꠀꠞ ꠁꠃꠍꠥꠚꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("GN33_3","002_33_3","GEN","33","3","3","ꠀꠞ ꠘꠤꠎꠦ ꠄꠞꠣꠞ ꠀꠉꠦ ꠉꠤꠀ ꠡꠣꠔꠛꠣꠞ ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠔꠣꠘ ꠜꠣꠁꠞ ꠉꠦꠍꠦ ꠀꠎꠤꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_4","002_33_4","GEN","33","4","4","ꠔꠦꠃ ꠁꠡꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠖꠃꠠꠣꠁꠀ ꠀꠁꠀ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠉꠟꠣꠔ ꠗꠞꠤꠀ ꠢꠥꠋꠉꠣ ꠖꠤꠟꠣ, ꠀꠞ ꠖꠥꠁꠅꠎꠘꠦ ꠇꠣꠘ꠆ꠖꠤꠔꠣ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_5","002_33_5","GEN","33","5","5","ꠛꠣꠖꠦ ꠁꠡꠦ ꠝꠥꠈ ꠔꠥꠟꠤꠀ ꠅꠃ ꠛꠦꠐꠤꠘ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠖꠦꠈꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠄꠞꠣ ꠇꠦꠉꠥ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠞꠢꠝꠔꠦ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠁ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN33_6","002_33_6","GEN","33","6","6","ꠔꠦꠃ ꠙꠄꠟꠣ ꠛꠣꠘ꠆ꠖꠤ ꠅꠇꠟꠦ ꠁꠡʼꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠟꠁꠀ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN33_7","002_33_7","GEN","33","7","7","ꠛꠣꠖꠦ ꠟꠦꠀꠄꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠟꠁꠀ ꠀꠉꠥꠀꠁꠀ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠟꠣ, ꠢꠦꠡꠦ ꠁꠃꠍꠥꠚ ꠀꠞ ꠞꠣꠢꠦꠟꠣꠄ ꠉꠤꠀ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_8","002_33_8","GEN","33","8","8","ꠔꠦꠃ ꠁꠡꠦ ꠇꠁꠟꠣ, “ꠙꠕꠅ ꠎꠦꠔꠣ ꠖꠟꠛꠟ ꠖꠦꠈꠟꠣꠝ, ꠁꠔꠣ ꠇꠤꠅꠞ ꠟꠣꠉꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠉꠦꠍꠦ ꠖꠄꠀ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN33_9","002_33_9","GEN","33","9","9","ꠁꠡꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁꠞꠦ, ꠀꠝꠣꠞ ꠛꠃꠔꠔꠣ ꠀꠍꠦ, ꠔꠥꠝꠣꠞ ꠁꠔꠣ ꠔꠥꠝꠣꠞꠃ ꠕꠣꠇꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("GN33_10","002_33_10","GEN","33","10","10","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠎꠤ ꠘꠣ, ꠀꠝꠤ ꠝꠤꠘꠔ ꠇꠞꠤꠀ ꠇꠁꠀꠞ, ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠛꠣꠄ ꠀꠙꠘꠣꠞ ꠖꠄꠀ ꠅꠄ, ꠔꠣꠁꠟꠦ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠁ ꠖꠣꠘ-ꠖꠇ꠆ꠇꠤꠘꠣ ꠀꠙꠘꠦ ꠘꠦꠃꠇ꠆ꠇꠣ। ꠀꠙꠘꠦ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞꠦ ꠈꠥꠡꠤ ꠝꠘꠦ ꠇꠛꠥꠟ ꠇꠞꠍꠂꠘ, ꠔꠦ ꠀꠙꠘꠣꠞ ꠝꠥꠈ ꠖꠦꠈꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠅꠀ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN33_11","002_33_11","GEN","33","11","11","ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠞꠢꠝꠔ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠀꠝꠣꠞ ꠛꠃꠔꠔꠣ ꠀꠍꠦ ꠀꠞ ꠅꠃ ꠎꠦꠔꠣ ꠃꠙꠢꠣꠞ ꠀꠙꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠘꠍꠤ, ꠁꠔꠣ ꠀꠙꠘꠦ ꠘꠦꠃꠇ꠆ꠇꠣ।” ꠔꠣꠁꠘ ꠅꠃꠟꠣ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠣꠄ, ꠁꠡꠦ ꠁꠔꠣ ꠇꠛꠥꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_12","002_33_12","GEN","33","12","12","ꠁꠡꠦ ꠇꠁꠟꠣ, “ꠌꠟꠅ, ꠀꠝꠞꠣ ꠞꠅꠀꠘꠣ ꠅꠁ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠞꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN33_13","002_33_13","GEN","33","13","13","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠔ ꠎꠣꠘꠞꠣ, ꠁ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠇꠟꠅ ꠢꠥꠞꠥ ꠀꠞ ꠖꠥꠗꠣꠟ ꠉꠣꠁꠀꠁꠘ-ꠝꠦꠠꠤꠘꠅ ꠟꠉꠦ ꠀꠍꠦ, ꠛꠦꠎꠣꠘ ꠅꠁꠀ ꠁꠔꠣꠞꠦ ꠄꠇꠖꠤꠘꠃ ꠀꠐꠣꠁꠟꠦ, ꠢꠇ꠆ꠇꠟꠐꠤ ꠝꠞꠤꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_14","002_33_14","GEN","33","14","14","ꠔꠦ ꠝꠥꠘꠤꠛ, ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠀꠉꠦ ꠎꠣꠃꠇ꠆ꠇꠣꠉꠤ, ꠙꠡꠥꠞ ꠙꠣꠟ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠇꠟꠞ ꠌꠟꠣꠞ ꠈꠦꠝꠔꠣ ꠛꠥꠎꠤꠀ ꠀꠝꠤ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠍꠦꠁꠞ ꠄꠟꠣꠇꠣꠔ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN33_15","002_33_15","GEN","33","15","15","ꠁꠡꠦ ꠇꠁꠟꠣ, “ꠔꠣꠁꠟꠦ ꠀꠝꠣꠞ ꠟꠉꠞ ꠅꠔꠣ ꠇꠄꠎꠘꠞꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠕꠁꠀ ꠎꠣꠁꠉꠤ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠔꠣꠞ ꠖꠞꠇꠣꠞ ꠇꠤꠔꠣ? ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠎꠦ ꠞꠢꠝ ꠙꠣꠁꠍꠤ, ꠅꠐꠣꠃ ꠔ ꠛꠃꠔꠔꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN33_16","002_33_16","GEN","33","16","16","ꠀꠞ ꠁꠡ ꠢꠃ ꠖꠤꠘꠃ ꠍꠦꠁꠞꠞ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_17","002_33_17","GEN","33","17","17","ꠅꠁꠟꠦ ꠁꠀꠇꠥꠛꠦ ꠡꠥꠇ꠆ꠇꠔꠅ ꠙꠃꠍꠤꠀ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠒꠦꠞꠣ ꠛꠣꠘꠣꠁꠀ, ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠟꠣꠉꠤꠅ ꠇꠄꠈꠣꠘ ꠛꠣꠕꠣꠘ ꠛꠣꠘꠣꠁꠟꠣ, ꠔꠦꠃ ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠡꠥꠇ꠆ꠇꠔ ꠝꠣꠘꠤ, ꠒꠦꠞꠣ ꠅꠇꠟ। ");
INSERT INTO syls_vpl VALUES ("GN33_18","002_33_18","GEN","33","18","18","ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝ ꠕꠘꠦ ꠛꠣꠞ ꠅꠁꠀ ꠁꠀꠇꠥꠛꠦ, ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠡꠤꠈꠤꠝ ꠐꠣꠃꠘꠅ ꠀꠁꠀ, ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠔꠣꠝ꠆ꠛꠥꠁꠘ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_19","002_33_19","GEN","33","19","19","ꠢꠦꠡꠦ ꠅꠃ ꠔꠣꠝ꠆ꠛꠥꠀꠟꠣ ꠎꠝꠤꠘꠈꠣꠘ ꠔꠣꠁꠘ, ꠡꠤꠈꠤꠝꠞ ꠛꠣꠚ ꠢꠝꠥꠞꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠉꠦꠍ ꠕꠘꠦ, ꠞꠥꠙꠣꠞ ꠄꠇ-ꠡ ꠐꠦꠇꠣ ꠖꠤꠀ ꠈꠞꠤꠖ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN33_20","002_33_20","GEN","33","20","20","ꠀꠞ ꠢꠘꠅ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠀ ꠄꠞ ꠘꠣꠝ ꠖꠤꠟꠣ ꠄꠟ-ꠁꠟꠥꠢꠦ-ꠁꠍꠞꠣꠁꠟ ꠝꠣꠘꠤ, ꠀꠟ꠆ꠟꠣ, ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠀꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_1","002_34_1","GEN","34","1","1","ꠟꠦꠀꠞ ꠊꠞꠅ ꠖꠤꠘꠣ ꠘꠣꠝꠦ ꠁꠀꠇꠥꠛꠞ ꠎꠦ ꠙꠥꠠꠤ ꠅꠁꠍꠤꠟ, ꠄꠁꠘ ꠄꠇꠖꠤꠘ ꠢꠘꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_2","002_34_2","GEN","34","2","2","ꠀꠞ ꠡꠤꠈꠤꠝ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠌꠃꠈꠅ ꠙꠠꠟꠣ। ꠁ ꠡꠤꠈꠤꠝ ꠀꠍꠤꠟ ꠢꠤꠛ꠆ꠛꠤ ꠎꠣꠔꠤꠞ ꠡꠞ꠆ꠖꠣꠞ ꠢꠝꠥꠞꠞ ꠙꠥꠀ। ꠡꠤꠈꠤꠝꠦ ꠄꠞꠦ ꠎꠥꠞ ꠇꠞꠤ ꠗꠞꠤꠀ ꠘꠤꠀ ꠈꠛꠤꠍꠤ ꠇꠣꠝ ꠇꠞꠤꠟ꠆ꠟ। ");
INSERT INTO syls_vpl VALUES ("GN34_3","002_34_3","GEN","34","3","3","ꠖꠤꠘꠣꠞ ꠛꠣꠄ ꠔꠣꠞ ꠖꠤꠟ ꠀꠡꠤꠇ ꠅꠁꠉꠦꠟ। ꠢꠦ ꠄꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ ꠄꠞ ꠟꠉꠦ ꠝꠤꠑꠣ ꠝꠤꠑꠣ ꠝꠣꠔ ꠝꠣꠔꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN34_4","002_34_4","GEN","34","4","4","ꠛꠣꠖꠦ ꠡꠤꠈꠤꠝꠦ ꠔꠣꠞ ꠛꠣꠚ ꠢꠝꠥꠞꠞꠦ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠅꠃ ꠇꠁꠘꠣꠞꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠤꠀꠞ ꠛꠘ꠆ꠖꠛꠡ꠆ꠔ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN34_5","002_34_5","GEN","34","5","5","ꠁꠀꠇꠥꠛꠦ ꠈꠛꠞ ꠙꠣꠁꠟꠣ, ꠡꠤꠈꠤꠝꠦ ꠔꠣꠘ ꠙꠥꠠꠤꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠍꠦ, ꠅꠁꠟꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠙꠡꠥꠞ ꠙꠣꠟ ꠟꠁꠀ ꠛꠘ꠆ꠖꠅ ꠕꠣꠇꠣꠄ, ꠔꠣꠁꠘ ꠘꠣ-ꠝꠣꠔꠤꠀ ꠘꠤꠞꠣꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_6","002_34_6","GEN","34","6","6","ꠡꠤꠈꠤꠝꠞ ꠛꠣꠚ ꠢꠝꠥꠞꠦ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠛꠤꠀꠞ ꠝꠣꠔ ꠟꠁꠀ ꠀꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("GN34_7","002_34_7","GEN","34","7","7","ꠀꠞ ꠁ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀꠂꠘꠅ ꠛꠘ꠆ꠖꠅ ꠕꠘꠦ ꠀꠁꠟꠣ। ꠔꠣꠞꠣ ꠛꠦꠕꠣꠄꠀ ꠉꠥꠍꠣ ꠀꠞ ꠉꠞꠝ ꠅꠁꠟꠣ, ꠇꠣꠞꠘ ꠁꠀꠇꠥꠛꠞ ꠙꠥꠠꠤꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠣꠄ ꠡꠤꠈꠤꠝꠦ ꠀꠡ꠆ꠔꠣ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠀꠞ ꠘꠣꠎꠣꠁꠎ ꠇꠣꠝ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN34_8","002_34_8","GEN","34","8","8","ꠔꠦꠃ ꠢꠝꠥꠞꠦ ꠄꠞꠣꠞꠦ ꠇꠁꠟ, “ꠀꠙꠘꠣꠞꠣꠞ ꠇꠁꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠙꠥꠀ ꠀꠡꠤꠇ ꠅꠁꠉꠦꠍꠦ। ꠖꠄꠀ ꠇꠞꠤ, ꠀꠝꠣꠞ ꠙꠥꠀꠞ ꠟꠉꠦ ꠄꠞ ꠡꠣꠖꠤ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_9","002_34_9","GEN","34","9","9","ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠇꠥꠐꠥꠝꠤꠔꠣ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣꠞ ꠇꠁꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠘꠦꠃꠇ꠆ꠇꠣ ꠀꠞ ꠀꠙꠘꠣꠞꠣꠞꠔꠣ ꠀꠝꠞꠣꠞꠦ ꠖꠦꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_10","002_34_10","GEN","34","10","10","ꠀꠞ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠃꠇ꠆ꠇꠣ, ꠁ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠃ ꠔ ꠍꠣꠝꠘꠦ ꠞꠁꠍꠦ, ꠀꠙꠘꠣꠞꠣ ꠅꠘꠅꠃ ꠕꠣꠇꠂꠘ, ꠇꠣꠄ-ꠇꠣꠞꠛꠣꠞ ꠇꠞꠤꠀ, ꠘꠤꠎꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠇꠣꠁꠝ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN34_11","002_34_11","GEN","34","11","11","ꠡꠤꠈꠤꠝꠦ ꠖꠤꠘꠣꠞ ꠛꠣꠚ-ꠜꠣꠁꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠣꠄ ꠀꠙꠘꠣꠞꠣ ꠖꠄꠀ ꠇꠞꠂꠘ, ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠌꠣꠁꠛꠣ, ꠀꠝꠤ ꠅꠔꠣꠃ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN34_12","002_34_12","GEN","34","12","12","ꠝꠢꠞꠣꠘꠣ ꠀꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠀꠙꠘꠣꠞꠣ ꠎꠦꠔꠣ ꠖꠣꠛꠤ ꠇꠞꠛꠣ ꠀꠝꠤ ꠖꠤꠝꠥ, ꠎꠦꠇꠥꠘꠥ ꠟꠣꠈꠣꠘꠃ ꠖꠤꠘꠣꠞꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠤꠀ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN34_13","002_34_13","GEN","34","13","13","ꠡꠤꠈꠤꠝꠦ ꠔꠣꠞꠣꠞ ꠛꠁꠘꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠍꠤꠟ ꠇꠞꠤ ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠔꠣꠞꠦ ꠀꠞ ꠔꠣꠞ ꠛꠣꠚ ꠢꠝꠥꠞꠞꠦ ꠜꠣꠘꠣ ꠖꠦꠈꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN34_14","002_34_14","GEN","34","14","14","“ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠘꠣ ꠇꠞꠣꠁꠟ ꠇꠥꠘꠥ ꠖꠣꠝꠣꠘ꠆ꠖꠞ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠛꠁꠘꠞꠦ ꠛꠤꠀ ꠖꠤꠟꠦ ꠀꠝꠞꠣꠞ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN34_15","002_34_15","GEN","34","15","15","ꠅꠁꠟꠦ ꠅꠃ ꠇꠣꠝ ꠇꠞꠟꠦ ꠀꠝꠞꠣ ꠞꠣꠎꠤ ꠅꠁꠝꠥ, ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠀ, ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_16","002_34_16","GEN","34","16","16","ꠔꠣꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠀꠙꠘꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠖꠤꠝꠥ ꠀꠞ ꠀꠙꠘꠣꠞꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦꠅ ꠀꠝꠞꠣ ꠀꠘꠝꠥ, ꠀꠝꠞꠣꠅ ꠀꠙꠘꠣꠞꠣꠞ ꠟꠉꠦ ꠄꠇ ꠎꠣꠔꠤ ꠅꠁꠀ ꠛꠡꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN34_17","002_34_17","GEN","34","17","17","ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠁ ꠝꠍꠟꠝꠣꠘꠤꠞ ꠇꠕꠣ ꠘꠣ ꠝꠣꠘꠟꠦ, ꠀꠝꠞꠣꠞ ꠇꠁꠘꠣꠞꠦ ꠟꠁꠀ ꠎꠣꠁꠝꠥꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN34_18","002_34_18","GEN","34","18","18","ꠔꠦꠃ ꠔꠣꠞꠣꠞ ꠁ ꠝꠣꠔꠦ ꠢꠝꠥꠞ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀ ꠡꠤꠈꠤꠝ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_19","002_34_19","GEN","34","19","19","ꠅꠃ ꠡꠤꠈꠤꠝ ꠅꠁꠟ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠣꠎꠦ ꠢꠇꠟ ꠕꠘꠦ ꠖꠣꠝꠤ ꠝꠣꠘꠥꠡ। ꠢꠦ ꠖꠦꠞꠤ ꠘꠣ ꠇꠞꠤꠀ ꠇꠕꠣ ꠝꠣꠘꠤꠟꠣꠁꠟ, ꠇꠣꠞꠘ ꠁꠀꠇꠥꠛꠞ ꠙꠥꠠꠤꠞ ꠛꠣꠄ ꠢꠦ ꠀꠡꠤꠇ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN34_20","002_34_20","GEN","34","20","20","ꠛꠣꠖꠦ ꠐꠣꠃꠘꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠀꠁꠀ, ꠢꠝꠥꠞ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠄ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN34_21","002_34_21","GEN","34","21","21","“ꠁ ꠝꠣꠘꠥꠡꠉꠥꠁꠘ꠆ꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠇꠥꠘꠥ ꠎꠣꠝꠦꠟꠣ ꠇꠞꠦꠞ ꠘꠣ। ꠀꠝꠞꠣꠞ ꠖꠦꠡꠅ ꠄꠞꠣꠞ ꠕꠣꠇꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠎꠣꠉꠣꠅ ꠀꠍꠦ, ꠔꠦ ꠄꠞꠣ ꠅꠘꠅꠃ ꠕꠣꠇꠃꠇ ꠀꠞ ꠇꠣꠄ-ꠇꠣꠞꠛꠣꠞ ꠇꠞꠃꠇ, ꠀꠝꠞꠣ ꠄꠞꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠀꠘꠤ ꠀꠞ ꠀꠝꠞꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦꠅ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("GN34_22","002_34_22","GEN","34","22","22","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠄꠇꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠟꠦ, ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠄꠇ ꠎꠣꠔꠤ ꠅꠁꠔꠦ ꠞꠣꠎꠤ ꠀꠍꠂꠘ। ꠇꠣꠝꠐꠣ ꠅꠁꠟ, ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣꠞꠅ ꠢꠇ꠆ꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("GN34_23","002_34_23","GEN","34","23","23","ꠀꠞ ꠔꠣꠞꠣꠞ ꠉꠞꠥ-ꠝꠦꠠꠣ, ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔ ꠀꠝꠞꠣꠞ ꠅꠁꠛ, ꠔꠣꠞꠣꠞ ꠇꠕꠣꠄ ꠞꠣꠎꠤ ꠅꠁꠟꠦꠃ ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN34_24","002_34_24","GEN","34","24","24","ꠅꠃ ꠐꠣꠃꠘꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ ꠢꠝꠥꠞ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀ ꠡꠤꠈꠤꠝꠞ ꠝꠣꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠟ, ꠀꠞ ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN34_25","002_34_25","GEN","34","25","25","ꠢꠦꠡꠦ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠎꠦꠛꠟꠣ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠍꠟꠝꠣꠘꠤꠞ ꠛꠦꠖꠘꠣꠄ ꠇꠡ꠆ꠐ ꠙꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠖꠤꠘꠣꠞ ꠀꠙꠘ ꠜꠣꠁ ꠁꠀꠇꠥꠛꠞ ꠖꠥꠁ ꠙꠥꠀ ꠡꠤꠝꠤꠅꠘ ꠀꠞ ꠟꠦꠛꠤ, ꠔꠣꠞꠣꠞ ꠔꠟꠥꠀꠞ ꠟꠁꠀ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠁꠀ, ꠄꠞꠣꠞꠦ ꠛꠦ-ꠈꠤꠀꠟꠅ ꠙꠣꠁꠀ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞꠦ ꠝꠣꠞꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN34_26","002_34_26","GEN","34","26","26","ꠔꠣꠞꠣ ꠢꠝꠥꠞ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀ ꠡꠤꠈꠤꠝꠞꠦꠅ ꠔꠟꠥꠀꠞꠖꠤ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠀ ꠡꠤꠈꠤꠝꠞ ꠊꠞ ꠕꠘꠦ ꠖꠤꠘꠣꠞꠦ ꠟꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN34_27","002_34_27","GEN","34","27","27","ꠄꠞꠣ ꠔꠣꠞꠣꠞ ꠛꠁꠘꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠍꠤꠟ ꠇꠞꠤ, ꠁꠀꠇꠥꠛꠞ ꠢꠇꠟ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠝꠞꠣ ꠟꠣꠡꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠐꠣꠃꠘꠅ ꠟꠥꠐ-ꠔꠞꠣꠎ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_28","002_34_28","GEN","34","28","28","ꠀꠞ ꠐꠣꠃꠘꠞ ꠜꠤꠔꠞ-ꠛꠣꠁꠞꠞ ꠉꠞꠥ-ꠉꠣꠗꠣ, ꠍꠣꠉꠟ-ꠝꠦꠠꠣ, ꠀꠞ ꠈꠦꠔꠞ ꠢꠇꠟꠔꠣ ꠟꠥꠐꠤꠀ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_29","002_34_29","GEN","34","29","29","ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠛꠦꠐꠤꠘ, ꠀꠞ ꠊꠞꠞ ꠢꠇꠟꠔꠣꠅ ꠟꠥꠐ-ꠙꠣꠐ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN34_30","002_34_30","GEN","34","30","30","ꠢꠦꠡꠦ ꠁꠀꠇꠥꠛꠦ ꠡꠤꠝꠤꠅꠘ ꠀꠞ ꠟꠦꠛꠤꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁ ꠖꠦꠡꠞ ꠇꠦꠘꠣꠘꠤ ꠀꠞ ꠚꠣꠞꠤꠎꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞꠦ ꠙꠌꠣ-ꠊꠤꠘ꠆ꠘꠣꠞ ꠝꠣꠘꠥꠡ ꠛꠣꠘꠣꠁꠀ ꠝꠍꠤꠛꠔꠅ ꠚꠣꠟꠣꠁꠍ। ꠀꠝꠣꠞ ꠝꠣꠘꠥꠡ ꠇꠝ, ꠅꠈꠘ ꠔꠣꠞꠣ ꠄꠇꠈꠣꠘꠅ ꠅꠁꠀ ꠀꠝꠣꠞꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠟꠦ, ꠀꠝꠤ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇ꠆ꠇꠟꠞꠦ ꠟꠁꠀ ꠝꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN34_31","002_34_31","GEN","34","31","31","ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠦ ꠀꠝꠞꠣꠞ ꠛꠁꠘꠞꠦ ꠘꠤꠀ ꠈꠣꠘꠇꠤ ꠛꠣꠘꠣꠁꠟꠤꠔ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN35_1","002_35_1","GEN","35","1","1","ꠄꠞꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠛꠦꠕꠦꠟꠅ ꠎꠣꠅꠉꠤ। ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠁꠡʼꠞ ꠉꠦꠍ ꠕꠘꠦ ꠜꠣꠉꠤꠛꠣꠞ ꠛꠣꠟꠣ, ꠎꠦꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠍꠟꠣ, ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠤ ꠢꠘꠅ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN35_2","002_35_2","GEN","35","2","2","ꠔꠦꠃ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠀꠙꠘ ꠝꠣꠘꠡꠞꠦ ꠀꠞ ꠟꠉꠞ ꠢꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠖꠦꠛꠔꠣꠞ ꠎꠦꠔꠣ ꠝꠥꠞ꠆ꠔꠤꠘ ꠀꠍꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤ ꠚꠣꠟꠣꠅ; ꠀꠞ ꠢꠇꠟꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠀ, ꠍꠣꠚ-ꠍꠥꠔꠞꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠅ। ");
INSERT INTO syls_vpl VALUES ("GN35_3","002_35_3","GEN","35","3","3","ꠀꠞ ꠌꠟꠅ, ꠀꠝꠞꠣ ꠛꠦꠕꠦꠟꠅ ꠎꠣꠁꠔꠣꠝꠉꠤ। ꠢꠘꠅ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠝꠥ, ꠎꠦꠁꠘ ꠝꠍꠤꠛꠔꠞ ꠖꠤꠘꠅ ꠀꠝꠣꠞ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠍꠟꠣ, ꠀꠞ ꠀꠝꠣꠞ ꠍꠚꠞꠞ ꠟꠉꠤ ꠅꠁꠍꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN35_4","002_35_4","GEN","35","4","4","ꠔꠦꠃ ꠔꠣꠞꠣꠞ ꠎꠔ ꠟꠣꠈꠣꠘ ꠖꠦꠛꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤꠘ ꠀꠞ ꠇꠣꠘꠞ ꠎꠦꠅꠞꠣꠔ ꠀꠍꠤꠟ, ꠢꠇꠟꠔꠣ ꠁꠀꠇꠥꠛꠞ ꠀꠔꠅ ꠖꠤꠟꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠁꠔꠣ ꠘꠤꠀ ꠡꠤꠈꠤꠝ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠄꠟꠘ ꠉꠣꠍꠞ ꠔꠟꠦ ꠉꠣꠠꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_5","002_35_5","GEN","35","5","5","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠢꠘ ꠕꠘꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠢꠇꠟ ꠉꠣꠃ-ꠉꠦꠞꠣꠝꠅ ꠄꠇ ꠒꠞ ꠙꠄꠖꠣ ꠇꠞꠟꠣ, ꠔꠦꠃ ꠢꠤꠘꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠈꠦꠖꠣꠘꠤꠔ ꠉꠦꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_6","002_35_6","GEN","35","6","6","ꠢꠦꠡꠦ ꠁꠀꠇꠥꠛ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠟꠥꠎ ꠘꠣꠝꠞ ꠎꠣꠉꠣ, ꠝꠣꠘꠤ ꠛꠦꠕꠦꠟꠅ ꠀꠁꠀ ꠙꠃꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_7","002_35_7","GEN","35","7","7","ꠅꠘꠅ ꠔꠣꠁꠘ ꠄꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠀ, ꠅꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠖꠤꠟꠣ ꠄꠟ-ꠛꠦꠕꠦꠟ ꠝꠣꠘꠤ, ꠛꠦꠕꠦꠟꠞ ꠀꠟ꠆ꠟꠣ, ꠇꠣꠞꠘ ꠜꠣꠁꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠛꠣꠞ ꠛꠣꠟꠣ ꠀꠟ꠆ꠟꠣꠄ ꠅꠘꠅꠃ ꠔꠣꠘꠞꠦ ꠖꠤꠖꠣꠞ-ꠖꠞꠡꠘ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_8","002_35_8","GEN","35","8","8","ꠀꠞ ꠞꠦꠛꠦꠇꠣꠞ ꠖꠣꠁꠝꠣ ꠖꠛꠥꠞꠣ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ꠔꠣꠘꠦ ꠛꠦꠕꠦꠟꠞ ꠟꠣꠝꠣꠔ ꠄꠇ ꠄꠟꠘ ꠉꠣꠍꠞ ꠔꠟꠦ ꠝꠣꠐꠤ ꠖꠤꠟꠣ, ꠔꠦꠃ ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠄꠟꠘ-ꠛꠣꠈꠥꠔ ꠝꠣꠘꠤ, ꠇꠣꠘ꠆ꠖꠘꠞ ꠉꠣꠍ। ");
INSERT INTO syls_vpl VALUES ("GN35_9","002_35_9","GEN","35","9","9","ꠁꠀꠇꠥꠛꠦ ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝ ꠕꠣꠇꠤ ꠀꠅꠀꠞ ꠛꠣꠖꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_10","002_35_10","GEN","35","10","10","ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠔ ꠁꠀꠇꠥꠛ; ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠁꠀꠇꠥꠛ ꠇꠁꠀ ꠒꠣꠇꠔꠣ ꠘꠣꠄ, ꠔꠥꠝꠣꠞꠦ ꠁꠍꠞꠣꠁꠟ ꠇꠁꠛꠣ।” ꠔꠦꠃ ꠔꠣꠘ ꠘꠣꠝ ꠅꠁꠟ ꠁꠍꠞꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN35_11","002_35_11","GEN","35","11","11","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣ। ꠔꠥꠝꠤ ꠚꠟꠀꠟꠣ ꠅꠁꠀ ꠛꠣꠠꠅ। ꠔꠥꠝꠣ ꠕꠘꠦ ꠄꠇ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠅꠁꠛ, ꠁꠐꠣ ꠅꠁꠛ ꠛꠃꠔ ꠉꠥꠡ꠆ꠐꠤꠀꠟꠣ ꠎꠣꠔꠤ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠛꠣꠖꠡꠣ ꠅꠇꠟ ꠙꠄꠖꠣ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_12","002_35_12","GEN","35","12","12","ꠀꠝꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠀꠞ ꠁꠍꠢꠣꠇꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠍꠤ, ꠢꠃ ꠖꠦꠡ ꠅꠈꠘ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠣꠖꠞ ꠅꠀꠞꠤꠡꠞꠦ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN35_13","002_35_13","GEN","35","13","13","ꠀꠟ꠆ꠟꠣꠄ ꠢꠘꠅ ꠁꠀꠇꠥꠛꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠀꠍꠝꠣꠘꠅ ꠔꠡꠞꠤꠚ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN35_14","002_35_14","GEN","35","14","14","ꠁꠀꠇꠥꠛꠦ ꠢꠃ ꠛꠣꠔꠌꠤꠔꠞ ꠎꠣꠉꠣꠔ ꠙꠣꠔ꠆ꠔꠞꠞ ꠄꠇ ꠈꠥꠐꠤ ꠉꠣꠠꠤꠀ, ꠄꠞ ꠃꠙꠞꠦ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠓꠣꠟꠤꠟꠣ, ꠢꠦꠡꠦ ꠔꠦꠟꠅ ꠓꠣꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_15","002_35_15","GEN","35","15","15","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠈꠣꠘꠅ ꠔꠣꠘꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠍꠟꠣ, ꠁꠀꠇꠥꠛꠦ ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠍꠟꠣ ꠛꠦꠕꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN35_16","002_35_16","GEN","35","16","16","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠦ ꠛꠦꠕꠦꠟ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠇꠞꠤꠀ ꠁꠚ꠆ꠞꠣꠕꠅ ꠙꠃꠍꠣꠞ ꠛꠣꠇ꠆ꠇꠣ ꠀꠉꠦ, ꠞꠣꠢꠦꠟꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠀꠞ ꠛꠤꠡꠦ ꠗꠞꠟ, ꠔꠣꠘ ꠈꠥꠛ ꠔꠇꠟꠤꠚ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN35_17","002_35_17","GEN","35","17","17","ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠀꠞ ꠛꠤꠡ ꠀꠞꠅ ꠛꠣꠠꠟ, ꠔꠦꠃ ꠖꠣꠁ ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠒꠞꠣꠁꠅ ꠘꠣ ꠉ, ꠁꠛꠣꠞꠅ ꠔꠥꠝꠣꠞ ꠊꠞꠅ ꠙꠥꠀ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN35_18","002_35_18","GEN","35","18","18","ꠅꠁꠟꠦ ꠞꠣꠢꠦꠟꠣ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ꠝꠞꠣꠞ ꠡꠝꠄ ꠔꠣꠁꠘ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠛꠤꠘ-ꠅꠘꠤ ꠝꠣꠘꠤ, ꠀꠝꠣꠞ ꠔꠇꠟꠤꠚꠞ ꠙꠥꠀ ꠅꠁꠟꠦ ꠛꠣꠚꠦ ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠝꠣꠘꠤ, ꠀꠝꠣꠞ ꠛꠟꠞ ꠙꠥꠀ। ");
INSERT INTO syls_vpl VALUES ("GN35_19","002_35_19","GEN","35","19","19","ꠞꠣꠢꠦꠟꠣꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠁꠚ꠆ꠞꠣꠕ, ꠝꠣꠘꠤ ꠛꠦꠕꠦꠟꠢꠣꠝ, ꠎꠣꠅꠀꠞ ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠔꠣꠘꠞꠦ ꠝꠣꠐꠤ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN35_20","002_35_20","GEN","35","20","20","ꠝꠣꠐꠤ ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠇꠄꠛꠞꠞ ꠃꠙꠞꠦ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞꠞ ꠈꠥꠐꠤ ꠉꠣꠠꠟꠣ, ꠁ ꠈꠥꠐꠤ ꠀꠁꠎꠅ ꠅꠘꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN35_21","002_35_21","GEN","35","21","21","ꠅꠘ ꠕꠘꠦ ꠁꠍꠞꠣꠁꠟꠦ ꠢꠤꠞꠛꠣꠞ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠀꠞ ꠄꠖꠞ ꠝꠤꠘꠣꠞ ꠚꠣꠟꠣꠁꠀ ꠀꠁꠀ ꠔꠣꠘ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_22","002_35_22","GEN","35","22","22","ꠁꠍꠞꠣꠁꠟ ꠎꠦꠛꠟꠣ ꠢꠘꠅ ꠞꠁꠞꠣ, ꠅꠃ ꠚꠣꠇꠅ ꠞꠥꠛꠦꠘꠦ ꠉꠤꠀ ꠔꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠖꠞ ꠛꠤꠀꠞ ꠛꠃ ꠛꠤꠟꠢꠣꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠟ ꠀꠞ ꠁꠔꠣ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠣꠘꠅ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN35_23","002_35_23","GEN","35","23","23","ꠁꠀꠇꠥꠛꠞ ꠛꠣꠞꠅꠎꠘ ꠙꠥꠀ ꠀꠍꠟꠣ, ꠟꠦꠀꠞ ꠔꠞꠚꠣ ꠔꠣꠘ ꠛꠠ ꠙꠥꠀ ꠞꠥꠛꠦꠘ, ꠛꠣꠖꠦ ꠡꠤꠝꠤꠅꠘ, ꠟꠦꠛꠤ, ꠄꠢꠥꠖꠣ, ꠁꠍꠣꠈꠞ ꠀꠞ ꠍꠛꠥꠟꠘ। ");
INSERT INTO syls_vpl VALUES ("GN35_24","002_35_24","GEN","35","24","24","ꠞꠣꠢꠦꠟꠣꠞ ꠔꠞꠚꠣ ꠁꠃꠍꠥꠚ ꠀꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN35_25","002_35_25","GEN","35","25","25","ꠞꠣꠢꠦꠟꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠛꠤꠟꠢꠣꠞ ꠔꠞꠚꠣ, ꠖꠣꠘ ꠀꠞ ꠘꠙ꠆ꠔꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("GN35_26","002_35_26","GEN","35","26","26","ꠟꠦꠀꠞ ꠛꠣꠘ꠆ꠖꠤ ꠎꠤꠟꠙꠣꠞ ꠔꠞꠚꠣ, ꠍꠣꠖꠥ ꠀꠞ ꠀꠡꠤꠞ। ꠔꠣꠘ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠇꠟ ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝꠅ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_27","002_35_27","GEN","35","27","27","ꠢꠦꠡꠦ ꠁꠀꠇꠥꠛ ꠇꠤꠞꠤꠅꠔ-ꠅꠞ꠆ꠛꠞ, ꠝꠣꠘꠤ ꠢꠦꠛꠞꠘꠞ ꠇꠣꠍꠣꠔ ꠝꠝ꠆ꠞꠤ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ, ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠅꠃ ꠎꠣꠉꠣꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠀꠞ ꠁꠍꠢꠣꠇꠦꠅ ꠛꠡꠔ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN35_28","002_35_28","GEN","35","28","28","ꠁꠍꠢꠣꠇꠞ ꠛꠄꠅꠡ ꠄꠇ-ꠡ ꠀꠡꠤ ꠛꠞꠍ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN35_29","002_35_29","GEN","35","29","29","ꠀꠞ ꠁꠍꠢꠣꠇ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠥꠠꠣ ꠅꠁꠀ, ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠄꠅꠡꠅ ꠝꠣꠞꠣ ꠉꠤꠀ ꠔꠣꠘ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠀꠎꠤꠟꠣ। ꠔꠣꠘ ꠙꠥꠀ ꠁꠡ ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_1","002_36_1","GEN","36","1","1","ꠅꠃ ꠅꠁꠟ ꠁꠡ ꠛꠣ ꠁꠖꠥꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠄꠀꠘ। ");
INSERT INTO syls_vpl VALUES ("GN36_2","002_36_2","GEN","36","2","2","ꠁꠡꠦ ꠇꠦꠘꠣꠘꠤ ꠖꠥꠁ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠟꠣ। ꠄꠞꠣ ꠅꠁꠟꠣ ꠢꠤꠐ꠆ꠐꠤ ꠄꠟꠘꠞ ꠙꠥꠠꠤ ꠀꠖꠣ, ꠀꠞ ꠢꠤꠛ꠆ꠛꠤ ꠎꠤꠛꠤꠅꠘꠞ ꠘꠣꠔꠤꠘ, ꠅꠘꠣꠞ ꠙꠥꠠꠤ ꠅꠢꠟꠤꠛꠣꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_3","002_36_3","GEN","36","3","3","ꠄꠞꠣꠞ ꠛꠣꠖꠦꠅ ꠔꠣꠁꠘ ꠁꠍꠝꠣꠁꠟꠞ ꠙꠥꠠꠤ ꠘꠣꠛꠣꠃꠔꠞ ꠛꠁꠘ ꠛꠣꠡꠝꠔꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_4","002_36_4","GEN","36","4","4","ꠀꠖꠣꠞ ꠙꠦꠐꠅ ꠁꠟꠤꠚꠎ ꠀꠞ ꠛꠣꠡꠝꠔꠞ ꠙꠦꠐꠅ ꠞꠥꠄꠟꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("GN36_5","002_36_5","GEN","36","5","5","ꠀꠞ ꠅꠢꠟꠤꠛꠣꠝꠣꠞ ꠙꠦꠐꠅ ꠎꠤꠃꠡ, ꠎꠣꠟꠝ ꠀꠞ ꠇꠥꠞꠢꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ꠁꠡʼꠞ ꠁ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ। ");
INSERT INTO syls_vpl VALUES ("GN36_6","002_36_6","GEN","36","6","6","ꠛꠣꠖꠦ ꠁꠡꠦ ꠔꠣꠘ ꠛꠃꠀꠁꠘ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠊꠞꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠀꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠣꠁꠘ, ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠇꠣꠝꠣꠁ ꠇꠞꠣ ꠢꠇꠟ ꠗꠘ-ꠖꠃꠟꠔ ꠟꠁꠀ, ꠔꠣꠘ ꠜꠣꠁ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍ ꠕꠘꠦ ꠢꠞꠤꠀ ꠀꠞꠇ ꠖꠦꠡꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN36_7","002_36_7","GEN","36","7","7","ꠁꠡ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠙꠡꠥꠞ ꠙꠣꠟ, ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠅꠔ ꠛꠦꠡꠤ ꠀꠍꠤꠟ ꠎꠦꠘ, ꠄꠞꠣ ꠄꠇꠈꠣꠘꠅ ꠞꠁꠔꠦ ꠢꠤ ꠖꠦꠡꠞ ꠁ ꠎꠣꠉꠣꠄ ꠀꠞ ꠇꠥꠟꠣꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_8","002_36_8","GEN","36","8","8","ꠔꠦꠃ ꠁꠡ ꠍꠦꠁꠞꠞ ꠙꠣꠠꠤ ꠄꠟꠣꠇꠣꠔ ꠉꠤꠀ ꠛꠡꠔ ꠇꠞꠟꠣ। ꠄꠁꠘꠃ ꠁꠖꠥꠝ। ");
INSERT INTO syls_vpl VALUES ("GN36_9","002_36_9","GEN","36","9","9","ꠅꠃ ꠅꠁꠟ ꠍꠦꠁꠞꠞ ꠙꠣꠠꠞ ꠁꠖꠥꠝꠤ ꠅꠇꠟꠞ ꠝꠥꠟ ꠛꠣꠚ ꠁꠡʼꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠄꠀꠘ। ");
INSERT INTO syls_vpl VALUES ("GN36_10","002_36_10","GEN","36","10","10","ꠁꠡʼꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ, ꠁꠟꠤꠚꠎ ꠀꠞ ꠞꠥꠄꠟ। ꠁꠟꠤꠚꠎ ꠀꠖꠣꠞ ꠙꠥꠀ, ꠞꠥꠄꠟ ꠛꠣꠡꠝꠔꠞ ꠙꠥꠀ। ");
INSERT INTO syls_vpl VALUES ("GN36_11","002_36_11","GEN","36","11","11","ꠁꠟꠤꠚꠎꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ, ꠔꠂꠝꠘ, ꠅꠝꠣꠞ, ꠎꠚꠅ, ꠉꠣꠕꠣꠝ ꠀꠞ ꠇꠦꠘꠣꠎ। ");
INSERT INTO syls_vpl VALUES ("GN36_12","002_36_12","GEN","36","12","12","ꠁꠡʼꠞ ꠙꠥꠀ ꠁꠟꠤꠚꠎꠞ ꠔꠤꠝꠘꠣ ꠘꠣꠝꠞ ꠄꠇ ꠢꠣꠋꠉꠣꠞ ꠛꠃ ꠀꠍꠤꠟ, ꠄꠞ ꠊꠞꠅ ꠀꠝꠣꠟꠦꠇꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ꠄꠞꠣ ꠢꠇꠟꠦꠃ ꠁꠡʼꠞ ꠛꠃ ꠀꠖꠣꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GN36_13","002_36_13","GEN","36","13","13","ꠞꠥꠄꠟꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠘꠢꠕ, ꠎꠣꠞꠣꠢ, ꠡꠝ꠆ꠝ ꠀꠞ ꠝꠤꠎ꠆ꠎꠣ। ꠄꠞꠣ ꠁꠡʼꠞ ꠛꠃ ꠛꠣꠡꠝꠔꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GN36_14","002_36_14","GEN","36","14","14","ꠎꠤꠛꠤꠅꠘꠞ ꠘꠣꠔꠤꠘ, ꠅꠘꠣꠞ ꠙꠥꠠꠤ ꠅꠢꠟꠤꠛꠣꠝꠣꠞ ꠔꠞꠚꠣ ꠁꠡʼꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠎꠤꠃꠡ, ꠎꠣꠟꠝ ꠀꠞ ꠇꠥꠞꠢ। ");
INSERT INTO syls_vpl VALUES ("GN36_15","002_36_15","GEN","36","15","15","ꠁꠡʼꠞ ꠀꠅꠟꠣꠖꠞ ꠝꠣꠎꠦ ꠄꠞꠣ ꠀꠍꠟꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠦꠔꠣ। ꠁꠡʼꠞ ꠛꠠ ꠙꠥꠀ ꠁꠟꠤꠚꠎꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠔꠂꠝꠘ, ꠅꠝꠣꠞ, ꠎꠚꠅ, ꠇꠦꠘꠣꠎ, ");
INSERT INTO syls_vpl VALUES ("GN36_16","002_36_16","GEN","36","16","16","ꠇꠥꠞꠢ, ꠉꠣꠕꠣꠝ, ꠀꠞ ꠀꠝꠣꠟꠦꠇ। ꠄꠞꠣ ꠅꠁꠟꠣ ꠁꠖꠥꠝ ꠖꠦꠡꠅ, ꠀꠖꠣꠞ ꠙꠥꠀ ꠁꠟꠤꠚꠎꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GN36_17","002_36_17","GEN","36","17","17","ꠁꠡʼꠞ ꠙꠥꠀ ꠞꠥꠄꠟꠞ ꠙꠥꠀꠂꠘ ꠎꠦꠞꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠦꠔꠣ ꠅꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠘꠢꠕ, ꠎꠣꠞꠣꠢ, ꠡꠝ꠆ꠝ ꠀꠞ ꠝꠤꠎ꠆ꠎꠣ। ꠄꠞꠣ ꠅꠁꠟꠣ ꠁꠖꠥꠝ ꠖꠦꠡꠅ ꠁꠡʼꠞ ꠛꠃ ꠛꠣꠡꠝꠔꠞ ꠙꠥꠀ ꠞꠥꠄꠟꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GN36_18","002_36_18","GEN","36","18","18","ꠁꠡʼꠞ ꠛꠃ ꠅꠢꠟꠤꠛꠣꠝꠣꠞ ꠎꠦ ꠙꠥꠀꠂꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠦꠔꠣ ꠅꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠎꠤꠃꠡ, ꠎꠣꠟꠝ ꠀꠞ ꠇꠥꠞꠢ। ꠄꠞꠣ ꠀꠍꠟꠣ ꠅꠘꠣꠞ ꠙꠥꠠꠤ ꠅꠢꠟꠤꠛꠣꠝꠣꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GN36_19","002_36_19","GEN","36","19","19","ꠄꠞꠣ ꠅꠁꠟꠣ ꠁꠡ ꠛꠣ ꠁꠖꠥꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠀꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠦꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_20","002_36_20","GEN","36","20","20","ꠢꠘꠞ ꠢꠥꠞꠤꠅ ꠍꠦꠁꠞꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ ꠟꠥꠐꠘ, ꠡꠥꠛꠟ, ꠎꠤꠛꠤꠅꠘ, ꠅꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("GN36_21","002_36_21","GEN","36","21","21","ꠖꠤꠡꠥꠘ, ꠄꠕꠡꠞ ꠀꠞ ꠖꠤꠡꠣꠘ। ꠄꠞꠣ ꠢꠇꠟꠦ ꠁꠖꠥꠝ ꠖꠦꠡꠅ ꠍꠦꠁꠞꠞ ꠙꠥꠀꠂꠘ, ꠢꠥꠞꠤꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠦꠔꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_22","002_36_22","GEN","36","22","22","ꠟꠥꠐꠘꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠅꠁꠟ ꠢꠥꠞꠤ ꠀꠞ ꠢꠦꠝꠣꠝ, ꠀꠞ ꠛꠘꠤꠞ ꠘꠣꠝ ꠔꠤꠝꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_23","002_36_23","GEN","36","23","23","ꠡꠥꠛꠟꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ ꠅꠟꠛꠘ, ꠝꠣꠘꠢꠕ, ꠁꠛꠣꠟ, ꠡꠚꠅ ꠀꠞ ꠅꠘꠝ। ");
INSERT INTO syls_vpl VALUES ("GN36_24","002_36_24","GEN","36","24","24","ꠎꠤꠛꠤꠅꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ ꠅꠄꠀ ꠀꠞ ꠅꠘꠣ। ꠅꠃ ꠅꠘꠣꠃ ꠔꠣꠘ ꠛꠣꠛꠣ ꠎꠤꠛꠤꠅꠘꠞ ꠉꠣꠗꠣ ꠞꠣꠈꠣꠔ ꠉꠤꠀ, ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠉꠞꠝ ꠙꠣꠘꠤꠞ ꠁꠘ꠆ꠖꠣꠞꠣ ꠅꠇꠟ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_25","002_36_25","GEN","36","25","25","ꠅꠘꠣꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠖꠤꠡꠥꠘ ꠀꠞ ꠙꠥꠠꠤꠞ ꠘꠣꠝ ꠅꠢꠟꠤꠛꠣꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_26","002_36_26","GEN","36","26","26","ꠖꠤꠡꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ ꠢꠤꠝꠖꠘ, ꠁꠡꠛꠘ, ꠎꠤꠔ꠆ꠞꠘ ꠀꠞ ꠇꠦꠞꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN36_27","002_36_27","GEN","36","27","27","ꠄꠕꠡꠞꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ ꠛꠤꠟꠢꠘ, ꠎꠣꠅꠀꠘ ꠀꠞ ꠀꠇꠘ। ");
INSERT INTO syls_vpl VALUES ("GN36_28","002_36_28","GEN","36","28","28","ꠖꠤꠡꠣꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ ꠀꠃꠎ ꠀꠞ ꠅꠞꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN36_29","002_36_29","GEN","36","29","29","ꠢꠥꠞꠤꠅ ꠅꠇꠟꠞ ꠘꠦꠔꠣ ꠅꠁꠟꠣ ꠟꠥꠐꠘ, ꠡꠥꠛꠟ, ꠎꠤꠛꠤꠅꠘ, ꠅꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("GN36_30","002_36_30","GEN","36","30","30","ꠖꠤꠡꠥꠘ, ꠄꠕꠡꠞ ꠀꠞ ꠖꠤꠡꠣꠘ। ꠄꠞꠣ ꠅꠁꠟꠣ ꠍꠦꠁꠞ ꠖꠦꠡꠞ ꠢꠥꠞꠤꠅ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠦꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_31","002_36_31","GEN","36","31","31","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠛꠣꠖꠡꠣꠁ ꠢꠥꠇꠥꠝꠔ ꠀꠁꠛꠣꠞ ꠀꠉꠦ, ꠁꠖꠥꠝ ꠖꠦꠡꠅ ꠄꠞꠣꠃ ꠞꠣꠎꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_32","002_36_32","GEN","36","32","32","ꠛꠣꠃꠞꠞ ꠙꠥꠀ ꠛꠦꠟꠣ ꠁꠖꠥꠝꠞ ꠞꠣꠎꠣ ꠅꠁꠟꠣ। ꠔꠣꠘ ꠞꠣꠎꠗꠣꠘꠤꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠖꠤꠘꠢꠣꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_33","002_36_33","GEN","36","33","33","ꠛꠦꠟꠣ ꠝꠞꠣꠞ ꠛꠣꠖꠦ, ꠔꠣꠘ ꠎꠣꠉꠣꠔ ꠛꠡꠞꠣ ꠐꠣꠃꠘꠞ ꠎꠣꠞꠣꠢꠞ ꠙꠥꠀ ꠎꠥꠛꠛ ꠞꠣꠎꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_34","002_36_34","GEN","36","34","34","ꠎꠥꠛꠛ ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠂꠝꠘ ꠖꠦꠡꠞ ꠢꠥꠡꠝ ꠢꠘꠞ ꠞꠣꠎꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_35","002_36_35","GEN","36","35","35","ꠢꠥꠡꠝ ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠎꠣꠉꠣꠔ ꠛꠖꠖꠞ ꠙꠥꠀ ꠢꠖꠖ ꠞꠣꠎꠣ ꠅꠁꠟꠣ। ꠔꠣꠁꠘ ꠎꠥꠖ꠆ꠖ ꠇꠞꠤ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟꠞꠦ ꠀꠞꠣꠁꠟꠣ। ꠔꠣꠘ ꠞꠣꠎꠗꠣꠘꠤꠞ ꠘꠣꠝ ꠅꠁꠟ ꠅꠛꠤꠕ। ");
INSERT INTO syls_vpl VALUES ("GN36_36","002_36_36","GEN","36","36","36","ꠢꠖꠖ ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠝꠡ꠆ꠞꠦꠇꠣ ꠐꠣꠃꠘꠞ ꠍꠣꠝꠟꠣ ꠢꠘꠞ ꠞꠣꠎꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_37","002_36_37","GEN","36","37","37","ꠍꠣꠝꠟꠣ ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠢꠘꠞ ꠚꠥꠞꠣꠔ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠞ ꠞꠢꠛꠔ ꠐꠣꠃꠘꠞ ꠡꠃꠟ ꠞꠣꠎꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_38","002_36_38","GEN","36","38","38","ꠡꠃꠟ ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠎꠣꠉꠣꠔ ꠀꠇꠛꠣꠞꠞ ꠙꠥꠀ ꠛꠣꠀꠟ-ꠢꠣꠘꠘ ꠞꠣꠎꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN36_39","002_36_39","GEN","36","39","39","ꠀꠇꠛꠣꠞꠞ ꠙꠥꠀ ꠛꠣꠀꠟ-ꠢꠣꠘꠘ ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠎꠣꠉꠣꠔ ꠢꠖꠞ ꠞꠣꠎꠣ ꠅꠁꠟꠣ। ꠔꠣꠘ ꠞꠣꠎꠗꠣꠘꠤꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠙꠣꠃ, ꠀꠞ ꠔꠣꠘ ꠛꠃꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠝꠢꠦꠐꠣꠛꠦꠟ। ꠄꠁꠘ ꠝꠐꠞꠦꠖꠞ ꠙꠥꠠꠤ ꠀꠞ ꠝꠦꠎꠣꠢꠣꠛꠞ ꠘꠣꠔꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN36_40","002_36_40","GEN","36","40","40","ꠁꠡʼꠞ ꠎꠦꠔꠣ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠄꠟꠣꠇꠣꠞ ꠘꠦꠔꠣ ꠀꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠘꠣꠝ ꠅꠁꠟ, ꠔꠤꠝꠘꠣ, ꠅꠟꠛꠣ ꠀꠞ ꠎꠤꠔꠦꠕ, ");
INSERT INTO syls_vpl VALUES ("GN36_41","002_36_41","GEN","36","41","41","ꠅꠢꠟꠤꠛꠣꠝꠣ, ꠄꠟꠣ, ꠙꠤꠘꠥꠘ, ");
INSERT INTO syls_vpl VALUES ("GN36_42","002_36_42","GEN","36","42","42","ꠇꠦꠘꠣꠎ, ꠔꠂꠝꠘ, ꠝꠤꠛꠎꠣꠞ, ");
INSERT INTO syls_vpl VALUES ("GN36_43","002_36_43","GEN","36","43","43","ꠝꠉꠖꠤꠄꠟ ꠀꠞ ꠅꠞꠣꠝ। ꠄꠞꠣ ꠀꠍꠟꠣ ꠎꠣꠞꠎꠤꠞ ꠖꠦꠡꠞ, ꠎꠣꠞꠎꠤꠞ ꠄꠟꠣꠇꠣꠞ ꠁꠖꠥꠝꠤ ꠘꠦꠔꠣ। ꠁꠖꠥꠝꠤ ꠅꠇꠟꠞ ꠝꠥꠟ ꠛꠣꠚ ꠁꠡʼꠞ ꠛꠄꠀꠘ ꠅꠘꠅꠃ ꠡꠦꠡ। ");
INSERT INTO syls_vpl VALUES ("GN37_1","002_37_1","GEN","37","1","1","ꠁꠀꠇꠥꠛ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅꠃ ꠞꠁꠟꠣ, ꠔꠣꠘ ꠛꠣꠚꠅ ꠢꠘꠅ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠁꠀ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_2","002_37_2","GEN","37","2","2","ꠅꠃ ꠅꠁꠟ ꠁꠀꠇꠥꠛꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠄꠀꠘ। ꠁꠃꠍꠥꠚꠦ ꠡꠔꠞ ꠛꠞꠍ ꠛꠄꠅꠡ ꠕꠘꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠝꠦꠠꠣ-ꠍꠣꠉꠟ ꠞꠣꠈꠔꠣ। ꠔꠣꠁꠘ ꠢꠥꠞꠥꠝꠣꠘ ꠕꠘꠦꠃ ꠔꠣꠘ ꠢꠣꠔꠘ ꠝꠣ ꠛꠤꠟꠢꠣ ꠀꠞ ꠎꠤꠟꠙꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠉꠦ ꠞꠁꠔꠣ। ꠀꠞ ꠄꠞꠣꠞ ꠢꠇꠟ ꠛꠣꠖ ꠌꠣꠟ-ꠌꠟꠘꠞ ꠈꠛꠞ ꠛꠣꠚꠞꠦ ꠎꠣꠘꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_3","002_37_3","GEN","37","3","3","ꠁꠃꠍꠥꠚ, ꠁꠍꠞꠣꠁꠟꠞ ꠛꠥꠠꠣ ꠛꠄꠅꠡꠞ ꠙꠥꠀ ꠉꠔꠤꠇꠦ, ꠔꠣꠁꠘ ꠄꠞꠦ ꠢꠇꠟ ꠕꠘꠦ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠔꠣ। ꠔꠣꠁꠘ ꠄꠞꠦ ꠄꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠎꠥꠛ꠆ꠛꠣ ꠛꠣꠘꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_4","002_37_4","GEN","37","4","4","ꠛꠣꠚꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠢꠇꠟ ꠕꠘꠦ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠂꠘ ꠖꠦꠈꠤꠀ, ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠣꠘꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠔꠣ। ꠔꠣꠞꠣ ꠄꠘ ꠟꠉꠦ ꠜꠣꠟꠣ ꠝꠘꠦ ꠝꠣꠔ-ꠇꠕꠣꠅ ꠝꠣꠔꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_5","002_37_5","GEN","37","5","5","ꠁꠃꠍꠥꠚꠦ ꠄꠇ ꠈꠥꠀꠛ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠀꠞꠅ ꠛꠦꠡꠤ ꠊꠤꠘ꠆ꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_6","002_37_6","GEN","37","6","6","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠈꠥꠀꠛꠦ ꠇꠤꠔꠣ ꠖꠦꠈꠍꠤ ꠢꠥꠘꠅ: ");
INSERT INTO syls_vpl VALUES ("GN37_7","002_37_7","GEN","37","7","7","ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠀꠝꠞꠣ ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠗꠣꠘꠞ ꠝꠥꠁꠐ ꠛꠣꠘ꠆ꠖꠤꠀꠞ ꠀꠞ ꠀꠝꠣꠞ ꠛꠣꠘ꠆ꠖꠣ ꠝꠥꠁꠐꠈꠣꠘ ꠃꠛꠣꠁꠉꠦꠟ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠁꠐ ꠅꠇꠟꠦ ꠀꠝꠣꠞ ꠝꠥꠁꠐꠞꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠛꠦꠞꠤꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN37_8","002_37_8","GEN","37","8","8","ꠅꠃ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠇꠁꠟꠣ, “ꠔꠥꠁ ꠢꠣꠍꠣꠃ ꠀꠝꠞꠣꠞ ꠞꠣꠎꠣ ꠅꠁꠔꠦ ꠌꠣꠁꠞꠦ ꠘꠤ? ꠔꠥꠁ ꠞꠣꠎꠣ ꠅꠁꠀ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠔꠦ ꠘꠤ?” ꠔꠦꠃ ꠔꠣꠘ ꠈꠥꠀꠛ ꠀꠞ ꠔꠣꠘ ꠝꠣꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠀꠞꠅ ꠛꠦꠡꠤ ꠊꠤꠘ꠆ꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_9","002_37_9","GEN","37","9","9","ꠁꠃꠍꠥꠚꠦ ꠢꠤꠞꠛꠣꠞ ꠄꠇ ꠈꠥꠀꠛ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠈꠥꠀꠛꠦ ꠖꠦꠈꠍꠤ, ꠌꠣꠘ-ꠡꠥꠞꠥꠎ ꠀꠞ ꠄꠉꠣꠞꠅꠐꠣ ꠔꠦꠞꠣꠄ ꠀꠝꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN37_10","002_37_10","GEN","37","10","10","ꠔꠣꠁꠘ ꠁ ꠈꠥꠀꠛꠞ ꠇꠕꠣ ꠔꠣꠘ ꠛꠣꠚ ꠀꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠇꠁꠀ ꠢꠣꠞꠟꠦ, ꠛꠣꠚꠦ ꠔꠣꠘꠞꠦ ꠗꠝꠇꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠁꠘ ꠁꠔꠣ ꠇꠥꠘ ꠎꠣꠔꠞ ꠈꠥꠀꠛ ꠖꠦꠈꠟꠦ, ꠞꠦ ꠙꠥꠔ? ꠔꠞ ꠝꠣ-ꠜꠣꠁꠀꠁꠘ ꠀꠞ ꠀꠝꠤꠅ ꠇꠤꠔꠣ ꠢꠣꠍꠣꠃ ꠔꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠔꠣꠝ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN37_11","002_37_11","GEN","37","11","11","ꠀꠞ ꠁꠃꠍꠥꠚꠞꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠈꠥꠛ ꠁꠋꠡꠣꠁꠔꠣ। ꠅꠁꠟꠦ ꠛꠣꠚꠦ ꠁ ꠈꠥꠀꠛꠞ ꠇꠕꠣ ꠝꠘꠅ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_12","002_37_12","GEN","37","12","12","ꠀꠞ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠛꠣꠚꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠟꠁꠀ ꠡꠤꠈꠤꠝꠅ ꠞꠣꠈꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_13","002_37_13","GEN","37","13","13","ꠔꠦꠃ ꠁꠍꠞꠣꠁꠟꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠔꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠙꠡꠥꠞ ꠙꠣꠟ ꠞꠣꠈꠣꠔ ꠡꠤꠈꠤꠝꠅ ꠉꠦꠍꠂꠘ, ꠔꠦ ꠀꠄ, ꠀꠝꠤ ꠔꠞꠦꠅ ꠢꠘꠅ ꠙꠣꠑꠣꠁ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠀꠝꠤ ꠎꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN37_14","002_37_14","GEN","37","14","14","ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠘꠦ ꠇꠁꠟꠣ, “ꠔꠥꠁ ꠉꠤꠀ ꠔꠞ ꠜꠣꠁꠀꠁꠘ ꠀꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠈꠛꠞ-ꠀꠘ꠆ꠔꠞ ꠢꠥꠘꠤꠀ ꠀꠁꠀ ꠀꠝꠣꠞꠦ ꠇꠁꠍ।” ꠔꠦꠃ ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠢꠦꠛꠞꠘ ꠕꠘꠦ ꠡꠤꠈꠤꠝꠅ ꠙꠣꠑꠣꠁꠟꠣ। ꠀꠞ ꠁꠃꠍꠥꠚꠅ ꠉꠤꠀ ꠡꠤꠈꠤꠝꠅ ꠀꠎꠤꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_15","002_37_15","GEN","37","15","15","ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘꠞꠦ ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠊꠥꠞꠣ-ꠚꠤꠞꠣꠔ ꠖꠦꠈꠤꠀ ꠄꠇ ꠛꠦꠐꠣꠄ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠔꠥꠇꠣꠁꠞꠣꠄ ꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("GN37_16","002_37_16","GEN","37","16","16","ꠁꠃꠍꠥꠚꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠝꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠔꠥꠇꠣꠁꠀꠞ। ꠀꠙꠘꠦ ꠎꠣꠘꠂꠘ ꠘꠤ, ꠄꠞꠣ ꠙꠡꠥꠞ ꠙꠣꠟ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠞꠣꠈꠞꠣ?” ");
INSERT INTO syls_vpl VALUES ("GN37_17","002_37_17","GEN","37","17","17","ꠢꠤ ꠛꠦꠐꠣꠄ ꠇꠁꠟꠣ, “ꠔꠣꠞꠣ ꠁꠘ ꠕꠘꠦ ꠉꠦꠍꠂꠘꠉꠤ। ꠀꠝꠤ ꠢꠥꠘꠍꠤ ꠔꠣꠞꠣ ꠝꠣꠔꠤꠞꠣ, ꠀꠅ, ꠀꠝꠞꠣ ꠖꠥꠕꠘꠅ ꠎꠣꠁꠉꠤ।” ꠅꠃ ꠁꠃꠍꠥꠚꠦ ꠔꠥꠇꠣꠁ ꠔꠥꠇꠣꠁ ꠖꠥꠕꠘꠅ ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_18","002_37_18","GEN","37","18","18","ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠖꠥꠞꠁ ꠕꠘꠦ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠟ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠃꠍꠣꠞ ꠀꠉꠦꠃ ꠔꠣꠞꠣ ꠄꠘꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠝꠔꠟꠛ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("GN37_19","002_37_19","GEN","37","19","19","ꠔꠣꠞꠣ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞꠦ ꠇꠁꠟ, “ꠅꠃ ꠖꠦꠈꠅ, ꠈꠥꠀꠛ ꠖꠦꠈꠞꠣ ꠍꠣꠛ ꠀꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_20","002_37_20","GEN","37","20","20","ꠀꠅ, ꠅꠈꠘꠃ ꠀꠝꠞꠣ ꠄꠘꠦ ꠈꠔꠝ ꠇꠞꠤꠀ ꠅꠃ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁ ꠖꠦꠁ; ꠛꠣꠖꠦ ꠇꠁꠝꠥ, ꠇꠥꠘꠥ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠈꠣꠁꠟꠣꠁꠍꠦ, ꠢꠦꠡꠦ ꠖꠦꠈꠝꠥꠘꠦ, ꠔꠣꠞ ꠈꠥꠀꠛꠞ ꠖꠡꠣ ꠇꠤꠔꠣ ꠅꠄ?” ");
INSERT INTO syls_vpl VALUES ("GN37_21","002_37_21","GEN","37","21","21","ꠅꠁꠟꠦ ꠞꠥꠛꠦꠘꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠄꠘꠞꠦ ꠛꠣꠌꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠁꠟꠣ, “ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN37_22","002_37_22","GEN","37","22","22","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠟꠣ, “ꠈꠥꠘ-ꠈꠣꠞꠣꠙꠤ ꠇꠞꠣꠔ ꠎꠣꠁꠅ ꠘꠣ, ꠘꠤꠎꠞ ꠀꠔꠦ ꠘꠣ ꠝꠣꠞꠤꠀ ꠅꠉꠥꠞꠦ ꠄꠝꠘꠦꠃ ꠉꠣꠔꠞ ꠝꠣꠎꠦ ꠚꠣꠟꠣꠁ ꠖꠦꠅ।” ꠅꠃꠟꠣ ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠔꠣꠞꠣꠞ ꠀꠔ ꠕꠘꠦ ꠛꠣꠌꠣꠁꠀ, ꠛꠣꠚꠞ ꠀꠔꠅ ꠙꠣꠑꠣꠘꠤꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_23","002_37_23","GEN","37","23","23","ꠁꠃꠍꠥꠚ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠦꠃ ꠔꠣꠞꠣ, ꠔꠣꠘ ꠉꠔꠞ ꠕꠘꠦ ꠎꠥꠛ꠆ꠛꠣ ꠈꠥꠟꠤꠟꠣꠁꠟꠣ, ꠢꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠎꠥꠛ꠆ꠛꠣꠐꠣ ꠐꠣꠘꠤꠀ ꠈꠥꠟꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_24","002_37_24","GEN","37","24","24","ꠀꠞ ꠔꠣꠘꠦ ꠗꠞꠤꠀ ꠉꠣꠔꠞ ꠝꠣꠎꠦ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ। ꠁ ꠉꠣꠔ ꠢꠥꠇꠘꠣ ꠀꠍꠤꠟ, ꠇꠥꠘꠥ ꠙꠣꠘꠤ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_25","002_37_25","GEN","37","25","25","ꠢꠦꠡꠦ ꠔꠣꠞꠣ ꠈꠣꠅꠀꠔ ꠛꠁꠀ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠉꠤꠟꠤꠅꠖ ꠕꠣꠇꠤ ꠁꠍꠝꠣꠁꠟꠤ ꠄꠇ ꠛꠦꠙꠣꠞꠤꠞ ꠖꠟ ꠁꠛꠣꠄ ꠀꠞ। ꠄꠞꠣ ꠃꠐꠞ ꠙꠤꠑꠤꠔ ꠇꠞꠤ ꠈꠥꠡꠛꠄ ꠝꠡꠟꠣ, ꠀꠉꠞ, ꠀꠞ ꠝꠦꠡꠇꠦ-ꠀꠝ꠆ꠛꠞ ꠟꠁꠀ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_26","002_37_26","GEN","37","26","26","ꠅꠃ ꠄꠢꠥꠖꠣꠄ ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠇꠁꠟ, “ꠗꠞꠅ, ꠜꠣꠁꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠀ ꠀꠝꠞꠣ ꠟꠥꠇꠣꠁꠟꠤꠟꠣꠝ, ꠔꠦꠃ ꠀꠝꠞꠣꠞ ꠇꠤꠔꠣ ꠟꠣꠜ ꠅꠁꠛ? ");
INSERT INTO syls_vpl VALUES ("GN37_27","002_37_27","GEN","37","27","27","ꠢꠦ ꠔ ꠀꠝꠞꠣꠞꠃ ꠜꠣꠁ, ꠀꠝꠞꠣꠞ ꠀꠙꠘ ꠟꠃ ꠀꠞ ꠉꠥꠡ꠆ꠔ। ꠔꠦ ꠔꠣꠞ ꠡꠞꠤꠟꠅ ꠀꠔ ꠘꠣ ꠖꠤꠀ ꠀꠅ, ꠁꠍꠝꠣꠁꠟꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠔꠣꠞꠦ ꠛꠦꠌꠤꠟꠣꠁ।” ꠅꠃ ꠜꠣꠁꠀꠁꠘꠅ ꠞꠣꠎꠤ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_28","002_37_28","GEN","37","28","28","ꠢꠃ ꠝꠣꠖꠤꠀꠘꠤ ꠛꠦꠙꠣꠞꠤ ꠅꠇꠟ ꠇꠣꠍꠣꠔ ꠀꠁꠔꠦꠃ, ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠉꠣꠔꠅ ꠕꠘꠦ ꠐꠣꠘꠤꠀ ꠔꠥꠟꠟꠣ ꠀꠞ ꠄꠇ ꠇꠥꠠꠤ ꠞꠥꠙꠣꠞ ꠐꠦꠇꠣꠞ ꠛꠖꠟꠣ, ꠁꠍꠝꠣꠁꠟꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠔꠣꠘꠦ ꠛꠦꠌꠤꠟꠣꠁꠟꠣ। ꠄꠞꠣ ꠁꠃꠍꠥꠚꠞꠦ ꠟꠁꠀ ꠝꠤꠡꠞꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN37_29","002_37_29","GEN","37","29","29","ꠛꠣꠖꠦ ꠞꠥꠛꠦꠘꠦ ꠢꠃ ꠉꠣꠔꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠁꠃꠍꠥꠚꠞꠦ ꠘꠣ ꠖꠦꠈꠤꠀ, ꠔꠣꠘ ꠉꠔꠞꠞ ꠇꠥꠞ꠆ꠔꠣ ꠚꠣꠞꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_30","002_37_30","GEN","37","30","30","ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠙꠥꠀꠉꠥ ꠔ ꠁꠘꠅ ꠘꠣꠄ। ꠅꠈꠘ ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("GN37_31","002_37_31","GEN","37","31","31","ꠅꠃ ꠔꠣꠞꠣ ꠄꠇ ꠛꠇꠞꠤ ꠝꠣꠞꠤꠀ, ꠄꠞ ꠟꠃ ꠁꠃꠍꠥꠚꠞ ꠢꠃ ꠎꠥꠛ꠆ꠛꠣꠔ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_32","002_37_32","GEN","37","32","32","ꠛꠣꠖꠦ ꠝꠣꠘꠥꠡꠖꠤ ꠅꠃ ꠎꠥꠛ꠆ꠛꠣ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁꠐꠣ ꠀꠝꠞꠣ ꠙꠕꠅ ꠙꠣꠁꠍꠤ, ꠔꠦ ꠀꠙꠘꠦ ꠜꠣꠟꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁꠐꠣ ꠀꠙꠘꠣꠞ ꠙꠥꠀꠞ ꠎꠥꠛ꠆ꠛꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN37_33","002_37_33","GEN","37","33","33","ꠁꠀꠇꠥꠛꠦ ꠁ ꠎꠥꠛ꠆ꠛꠣ ꠌꠤꠘꠤꠀ ꠇꠁꠟꠣ, “ꠁꠐꠣ ꠔ ꠀꠝꠣꠞ ꠙꠥꠀꠞꠃ। ꠔꠣꠞꠦ ꠇꠥꠘꠥ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠈꠣꠁꠟꠤꠍꠦ, ꠔꠣꠞꠦ ꠘꠤꠌꠄ ꠍꠤꠠꠤ-ꠛꠤꠠꠤꠟꠣꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN37_34","002_37_34","GEN","37","34","34","ꠔꠣꠁꠘ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠍꠤꠠꠤꠀ, ꠇꠝꠞꠅ ꠍꠟꠣꠞ ꠌꠐ ꠛꠣꠘ꠆ꠖꠤꠀ, ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠖꠤꠘ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_35","002_37_35","GEN","37","35","35","ꠔꠣꠘ ꠢꠇꠟ ꠙꠥꠀ-ꠙꠥꠠꠤꠄ ꠔꠣꠘꠦ ꠛꠥꠎꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠛꠥꠎꠦꠃ ꠔꠣꠘ ꠛꠥꠇ ꠑꠣꠘ꠆ꠒꠣ ꠅꠁꠟ ꠘꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠤ ꠇꠞꠤ ꠀꠝꠣꠞ ꠙꠥꠀꠞ ꠉꠦꠍꠦ ꠇꠄꠛꠞꠅ ꠢꠣꠝꠣꠁꠝꠥ।” ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN37_36","002_37_36","GEN","37","36","36","ꠄꠞ ꠝꠣꠎꠦ ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠝꠤꠡꠞꠅ ꠘꠤꠀ, ꠚꠦꠞꠣꠃꠘꠞ ꠇꠞ꠆ꠝꠌꠣꠞꠤ ꠀꠎꠤꠎꠞ ꠉꠦꠍꠦ ꠛꠦꠌꠤꠟꠣꠁꠟꠣ, ꠁ ꠇꠞ꠆ꠝꠌꠣꠞꠤ ꠀꠍꠟꠣ ꠔꠣꠘ ꠙꠞꠗꠣꠘ ꠉꠣꠒ। ");
INSERT INTO syls_vpl VALUES ("GN38_1","002_38_1","GEN","38","1","1","ꠄꠢꠥꠖꠣꠄ ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠕꠁꠀ ꠅꠖꠥꠟ꠆ꠟꠝ ꠉꠣꠃꠞ ꠢꠤꠞꠣ ꠘꠣꠝꠞ ꠄꠇ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠞꠅꠀꠔ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN38_2","002_38_2","GEN","38","2","2","ꠢꠘꠅ ꠞꠁꠀ ꠡꠥꠀ ꠘꠣꠝꠞ ꠄꠇ ꠇꠦꠘꠣꠘꠤ ꠝꠣꠘꠡꠞ ꠙꠥꠠꠤꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠅꠁꠟ, ꠖꠦꠈꠤꠀ ꠢꠦ ꠅꠃ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("GN38_3","002_38_3","GEN","38","3","3","ꠛꠤꠀꠞ ꠛꠣꠖꠦ ꠢꠃ ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ, ꠄꠢꠥꠖꠣꠄ ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟ ꠄꠁꠞ। ");
INSERT INTO syls_vpl VALUES ("GN38_4","002_38_4","GEN","38","4","4","ꠢꠤꠞꠛꠣꠞ ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠀꠞꠇ ꠙꠥꠀ ꠅꠁꠟꠦ, ꠝꠣʼꠄ ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟ ꠅꠘꠘ। ");
INSERT INTO syls_vpl VALUES ("GN38_5","002_38_5","GEN","38","5","5","ꠢꠦꠡꠦ ꠅꠃ ꠛꠦꠐꠤꠞ ꠀꠞꠇ ꠙꠥꠀ ꠅꠁꠟꠦ, ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟ ꠡꠦꠟꠣ। ꠁ ꠡꠝꠄ ꠔꠣꠞꠣ ꠇꠡꠤꠛ ꠉꠣꠃꠔ ꠞꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN38_6","002_38_6","GEN","38","6","6","ꠀꠞ ꠄꠢꠥꠖꠣꠄ ꠔꠣꠞ ꠛꠠ ꠙꠥꠀ ꠄꠁꠞꠞ ꠟꠉꠦ ꠔꠣꠝꠣꠞ ꠘꠣꠝꠞ ꠄꠇ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN38_7","002_38_7","GEN","38","7","7","ꠅꠁꠟꠦ ꠔꠣꠞ ꠁ ꠙꠥꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞꠅ ꠈꠥꠛ ꠈꠛꠤꠍ ꠀꠍꠤꠟ ꠉꠔꠤꠇꠦ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN38_8","002_38_8","GEN","38","8","8","ꠅꠃ ꠄꠢꠥꠖꠣꠄ ꠅꠘꠘꠞꠦ ꠇꠁꠟ, “ꠔꠥꠝꠣꠞ ꠜꠣꠛꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠟꠣꠅ। ꠔꠣꠁꠞ ꠖꠦꠅꠞ ꠅꠀꠄ ꠔꠥꠝꠣꠞ ꠎꠦꠔꠣ ꠇꠞꠣ ꠎꠞꠥꠞ ꠀꠍꠦ, ꠁꠔꠣ ꠀꠖꠣꠄ ꠇꠞꠅ ꠀꠞ ꠘꠤꠎꠞ ꠜꠣꠁꠞ ꠅꠀꠞꠤꠡ ꠙꠄꠖꠣ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN38_9","002_38_9","GEN","38","9","9","ꠅꠘꠘꠦ ꠎꠣꠘꠔ, ꠁ ꠅꠀꠞꠤꠡ ꠔꠣꠞ ꠘꠤꠎꠞ ꠅꠁꠔ ꠘꠣꠄ, ꠀꠞ ꠔꠣꠞ ꠜꠣꠁꠞ ꠅꠀꠞꠤꠡ ꠞꠣꠈꠔꠦ ꠔꠣꠞ ꠈꠤꠀꠟ ꠀꠍꠤꠟ ꠘꠣ ꠉꠔꠤꠇꠦ, ꠔꠣꠁꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣꠞ ꠡꠝꠄ ꠔꠣꠞ ꠛꠤꠎ ꠛꠣꠁꠞꠦ ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("GN38_10","002_38_10","GEN","38","10","10","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞ ꠁ ꠇꠣꠝꠦ ꠘꠣꠞꠣꠎ ꠅꠁꠟꠣ, ꠔꠣꠁꠘ ꠄꠁꠞꠞꠦꠅ ꠝꠣꠞꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN38_11","002_38_11","GEN","38","11","11","ꠅꠃ ꠄꠢꠥꠖꠣꠄ ꠔꠣꠞ ꠙꠥꠀꠞ ꠛꠃ ꠔꠣꠝꠣꠞꠞꠦ ꠇꠁꠟ, “ꠀꠝꠣꠞ ꠙꠥꠀ ꠡꠦꠟꠣ ꠎꠔꠖꠤꠘ ꠛꠠ ꠘꠣ ꠅꠄ, ꠅꠔꠖꠤꠘ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠠꠣꠠꠤ ꠅꠁꠀꠃ ꠞꠅ।” ꠄꠢꠥꠖꠣꠄ ꠒꠞꠣꠁꠟ, ꠡꠦꠟꠣꠅ ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠣꠈꠣꠘ ꠝꠞꠤꠎꠤꠛ। ꠀꠞ ꠔꠣꠝꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN38_12","002_38_12","GEN","38","12","12","ꠛꠣꠇ꠆ꠇꠣ ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠄꠢꠥꠖꠣꠞ ꠛꠃ, ꠡꠥꠀꠞ ꠙꠥꠠꠤ ꠝꠞꠤꠉꠦꠟ, ꠔꠦꠃ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠄꠢꠥꠖꠣꠄ ꠡꠣꠘ꠆ꠔꠤ ꠅꠁꠀ ꠅꠖꠥꠟ꠆ꠟꠝ ꠉꠣꠃꠞ ꠔꠣꠞ ꠖꠥꠡ꠆ꠔ ꠢꠤꠞꠣꠞ ꠟꠉꠦ ꠔꠤꠝꠘꠣ ꠉꠣꠃꠔ, ꠔꠣꠞ ꠝꠦꠠꠣꠞ ꠙꠣꠟꠞ ꠞꠥꠝꠣ ꠇꠣꠐꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN38_13","002_38_13","GEN","38","13","13","ꠀꠞ ꠔꠣꠝꠣꠞꠞꠦ ꠉꠤꠀ ꠇꠦꠃ ꠈꠛꠞ ꠖꠤꠟ “ꠔꠥꠝꠣꠞ ꠢꠃꠞꠦ ꠔꠣꠘ ꠝꠦꠠꠣꠞ ꠞꠥꠝꠣ ꠇꠣꠐꠣꠞ ꠟꠣꠉꠤ ꠔꠤꠝꠘꠣꠔ ꠎꠣꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN38_14","002_38_14","GEN","38","14","14","ꠔꠣꠝꠣꠞꠦ ꠖꠦꠈꠟ, ꠡꠦꠟꠣ ꠛꠠ ꠅꠁꠟꠦꠅ ꠢꠃꠞꠦ ꠡꠦꠟꠣꠞ ꠟꠉꠦ ꠔꠣꠁꠞ ꠛꠤꠀ ꠖꠤꠞꠣ ꠘꠣ, ꠅꠃ ꠔꠣꠁ ꠠꠣꠠꠤꠞ ꠇꠣꠙꠠ ꠛꠖꠟꠣꠁꠀ ꠢꠣꠎꠤ-ꠙꠣꠠꠤ ꠝꠥꠈꠅ ꠊꠥꠝꠐꠣ ꠖꠤꠀ, ꠀꠄꠘꠣꠁꠝꠞ ꠙꠕꠞ ꠝꠥꠈꠅ ꠉꠤꠀ ꠛꠁꠟ। ꠀꠄꠘꠣꠁꠝ ꠀꠍꠤꠟ ꠔꠤꠝꠘꠣꠔ ꠎꠣꠅꠀꠞ ꠙꠕꠅ। ");
INSERT INTO syls_vpl VALUES ("GN38_15","002_38_15","GEN","38","15","15","ꠀꠞ ꠔꠣꠁ ꠝꠥꠈ ꠟꠥꠇꠣꠁꠀ ꠞꠣꠈꠣꠄ, ꠄꠢꠥꠖꠣꠄ ꠝꠘꠅ ꠇꠞꠟ ꠁꠉꠥ ꠍꠤꠟꠣꠘ ꠛꠦꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("GN38_16","002_38_16","GEN","38","16","16","ꠔꠦꠃ ꠄꠢꠥꠖꠣꠄ ꠙꠥꠀꠞ ꠛꠃꠞꠦ ꠘꠣ ꠌꠤꠘꠣꠄ, ꠙꠕꠞ ꠗꠣꠞꠅ ꠔꠣꠝꠣꠞꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟ, “ꠀꠅ, ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠤ।” ꠔꠣꠝꠣꠞꠦ ꠇꠁꠟ, “ꠔꠦ ꠀꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠖꠤꠛꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("GN38_17","002_38_17","GEN","38","17","17","ꠢꠦ ꠇꠁꠟ, “ꠀꠝꠣꠞ ꠙꠣꠟ ꠕꠘꠦ ꠛꠇꠞꠤ ꠛꠣꠁꠌ꠆ꠌꠣ ꠄꠉꠥ ꠙꠣꠑꠣꠁ ꠖꠤꠝꠥ।” ꠔꠣꠝꠣꠞꠦ ꠇꠁꠟ, “ꠁꠐꠣ ꠙꠣꠑꠣꠘꠤꠞ ꠀꠉꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘ꠆ꠔꠣ ꠎꠤꠝ꠆ꠝꠣ ꠕꠁꠀ ꠎꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN38_18","002_38_18","GEN","38","18","18","ꠄꠢꠥꠖꠣꠄ ꠇꠁꠟ, “ꠇꠤꠔꠣ ꠕꠁꠔꠣꠝ?” ꠔꠣꠁ ꠇꠁꠟ, “ꠀꠙꠘꠣꠞ ꠅꠃ ꠚꠤꠔꠣꠀꠟꠣ ꠡꠤꠟ ꠀꠞ ꠀꠙꠘꠣꠞ ꠀꠔꠞ ꠟꠣꠑꠤ ꠕꠁꠀ ꠎꠣꠃꠇ꠆ꠇꠣ।” ꠔꠦꠃ ꠄꠢꠥꠖꠣꠄ ꠅꠉꠥꠁꠘ ꠎꠤꠝ꠆ꠝꠣ ꠕꠁꠀ ꠔꠣꠁꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠟ ꠀꠞ ꠔꠣꠝꠣꠞꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN38_19","002_38_19","GEN","38","19","19","ꠛꠣꠖꠦ ꠔꠣꠝꠣꠞ ꠃꠑꠤꠀ ꠉꠦꠟꠉꠤ ꠀꠞ ꠢꠤ ꠇꠣꠙꠠ ꠛꠖꠟꠣꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠠꠣꠠꠤꠞ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN38_20","002_38_20","GEN","38","20","20","ꠢꠦꠡꠦ ꠅꠃ ꠛꠦꠐꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠤꠝ꠆ꠝꠣꠞ ꠝꠣꠟ ꠚꠤꠞꠔ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠞ ꠅꠖꠥꠟ꠆ꠟꠝꠞ ꠖꠥꠡ꠆ꠔꠞꠦ ꠖꠤꠀ ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠄꠉꠥ ꠙꠣꠑꠣꠁꠟ। ꠢꠦ ꠀꠁꠀ ꠔꠣꠁꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN38_21","002_38_21","GEN","38","21","21","ꠅꠃ ꠢꠦ ꠢꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠎꠤꠇꠣꠁꠟ, “ꠀꠄꠘꠣꠁꠝꠞ ꠙꠕꠞ ꠗꠣꠞꠅ ꠄꠇ ꠡꠦꠛꠇ ꠛꠦꠐꠤ ꠀꠍꠤꠟ, ꠅꠉꠥ ꠇꠁ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠁꠘꠅ ꠔ ꠁꠟꠣ ꠇꠥꠘꠥ ꠛꠦꠐꠤ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN38_22","002_38_22","GEN","38","22","22","ꠔꠦꠃ ꠢꠦ ꠄꠢꠥꠖꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟ, “ꠀꠝꠤ ꠉꠤꠀ ꠔꠣꠁꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟꠣꠝ ꠘꠣ। ꠢꠘꠞ ꠝꠣꠘꠡꠦꠅ ꠇꠁꠟꠣ, ꠁꠘꠅ ꠔ ꠁꠟꠣ ꠇꠥꠘꠥ ꠛꠦꠐꠤ ꠀꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN38_23","002_38_23","GEN","38","23","23","ꠄꠢꠥꠖꠣꠄ ꠇꠁꠟ, “ꠔꠦ ꠁꠔꠣ ꠀꠞ ꠔꠣꠁꠞ ꠉꠦꠍꠦꠃ ꠕꠣꠇꠃꠇ। ꠘꠣꠁꠟꠦ ꠀꠝꠞꠣ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠝꠥ। ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠔ ꠙꠣꠑꠣꠁꠟꠣꠝ, ꠔꠣ-ꠅ ꠔꠥꠝꠤ ꠄꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟꠣꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN38_24","002_38_24","GEN","38","24","24","ꠅꠘꠥꠝꠣꠘ ꠔꠤꠘ ꠝꠣꠡ ꠛꠣꠖꠦ ꠄꠢꠥꠖꠣꠄ ꠢꠥꠘꠟ, ꠔꠣꠞ ꠙꠥꠀꠞ ꠛꠃ ꠔꠣꠝꠣꠞꠦ ꠎꠤꠘꠣ ꠇꠞꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠔꠣ। ꠅꠃ ꠄꠢꠥꠖꠣꠄ ꠇꠁꠟ, “ꠅꠉꠥꠞꠦ ꠛꠣꠞꠦ ꠘꠤꠀ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN38_25","002_38_25","GEN","38","25","25","ꠔꠣꠝꠣꠞꠞꠦ ꠎꠦꠛꠟꠣ ꠛꠣꠞꠦ ꠘꠤꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠞ ꠢꠃꠞꠞꠦ ꠈꠛꠞ ꠖꠤꠟ ꠎꠦꠘ, “ꠎꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠝꠣꠞ ꠙꠦꠐꠅ ꠀꠍꠦ, ꠅꠃ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠅꠇꠟ ꠔꠣꠞ। ꠔꠦ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠅꠃ ꠚꠤꠔꠣꠀꠟꠣ ꠡꠤꠟ ꠀꠞ ꠟꠣꠑꠤꠉꠥ ꠇꠣꠞ ꠌꠤꠘꠂꠘ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN38_26","002_38_26","GEN","38","26","26","ꠄꠢꠥꠖꠣꠄ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠇꠁꠟ, “ꠔꠣꠁ ꠔ ꠀꠝꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠛꠠ ꠙꠞꠦꠎꠉꠣꠞ। ꠀꠝꠣꠞ ꠙꠥꠀ ꠡꠦꠟꠣꠞ ꠟꠉꠦ ꠔꠣꠁꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠁꠍꠤ ꠘꠣ।” ꠄꠞꠛꠣꠖꠦ ꠄꠢꠥꠖꠣꠄ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠔꠣꠝꠣꠞꠞ ꠉꠦꠍꠦ ꠢꠥꠔꠤꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN38_27","002_38_27","GEN","38","27","27","ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠛꠣꠞ ꠛꠣꠟꠣ ꠖꠦꠈꠂꠘ, ꠔꠣꠝꠣꠞꠞ ꠙꠦꠐꠅ ꠎꠥꠠꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN38_28","002_38_28","GEN","38","28","28","ꠙꠄꠟꠣ ꠄꠉꠥꠄ ꠔꠣꠞ ꠀꠔ ꠛꠣꠞ ꠇꠞꠟ ꠀꠞ ꠖꠣꠁ ꠛꠦꠐꠤꠄ ꠟꠣꠟ ꠡꠥꠔꠣ ꠄꠇꠍꠣ ꠔꠣꠞ ꠀꠔꠅ ꠛꠣꠘ꠆ꠖꠤꠀ ꠇꠁꠟ, “ꠁꠉꠥ ꠙꠄꠟꠣ ꠙꠄꠖꠣ ꠅꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("GN38_29","002_38_29","GEN","38","29","29","ꠅꠁꠟꠦ ꠢꠦ ꠀꠔ ꠐꠣꠘ ꠖꠤꠀ ꠜꠤꠔꠞꠦ ꠘꠤꠟꠉꠤ, ꠔꠦꠃ ꠔꠣꠞ ꠜꠣꠁ ꠙꠄꠟꠣ ꠛꠣꠞ ꠅꠁꠟ ꠀꠞ ꠖꠣꠁ ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠇꠤꠟꠣ ꠚꠣꠇ ꠇꠞꠤꠀ ꠛꠣꠞ ꠅꠁꠟꠣꠄ?” ꠄꠞꠟꠣꠉꠤ ꠄꠞ ꠘꠣꠝ ꠅꠁꠟ ꠚꠤꠞꠥꠎ ꠝꠣꠘꠤ, ꠚꠣꠇ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GN38_30","002_38_30","GEN","38","30","30","ꠛꠣꠖꠦ ꠔꠣꠞ ꠜꠣꠁ ꠟꠣꠟ ꠡꠥꠔꠣ ꠀꠔꠅ ꠛꠣꠘ꠆ꠖꠣ ꠟꠁꠀ ꠛꠣꠞ ꠅꠁꠟ, ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠎꠣꠞꠣꠢ। ");
INSERT INTO syls_vpl VALUES ("GN39_1","002_39_1","GEN","39","1","1","ꠁꠃꠍꠥꠚꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠟꠁꠀ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ, ꠁꠍꠝꠣꠁꠟꠤ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠘꠦ, ꠀꠎꠤꠎ ꠘꠣꠝꠞ ꠚꠦꠞꠣꠃꠘꠞ ꠄꠇꠎꠘ ꠝꠤꠡꠞꠤ ꠇꠞ꠆ꠝꠌꠣꠞꠤꠄ, ꠁꠃꠍꠥꠚꠞꠦ ꠈꠞꠤꠖ ꠇꠞꠟꠣ। ꠀꠎꠤꠎ ꠅꠁꠟꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠙꠞꠗꠣꠘ ꠉꠣꠒ। ");
INSERT INTO syls_vpl VALUES ("GN39_2","002_39_2","GEN","39","2","2","ꠝꠣꠛꠥꠖꠦ ꠁꠃꠍꠥꠚꠞ ꠟꠉꠤ ꠅꠁꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠁꠃꠍꠥꠚ ꠢꠇꠟ ꠇꠣꠝꠅ ꠇꠣꠝꠤꠀꠛ ꠅꠁꠟꠣ। ꠔꠣꠁꠘ ꠢꠃ ꠝꠤꠡꠞꠤ ꠝꠥꠘꠤꠛꠞ ꠛꠣꠠꠤꠔ ꠇꠣꠝ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN39_3","002_39_3","GEN","39","3","3","ꠝꠣꠛꠥꠖ ꠔꠣꠘ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠂꠘ ꠀꠞ ꠢꠇꠟ ꠇꠣꠝꠅ ꠔꠣꠘꠦ ꠇꠣꠝꠤꠀꠛ ꠇꠞꠞꠣ, ꠔꠣꠘ ꠝꠥꠘꠤꠛꠦꠅ ꠁꠔꠣ ꠛꠥꠎꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN39_4","002_39_4","GEN","39","4","4","ꠔꠦꠃ ꠝꠥꠘꠤꠛꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠔꠣ ꠟꠣꠉꠟꠣ, ꠔꠣꠘꠦ ꠝꠥꠘꠤꠛꠞ ꠈꠣꠍ ꠈꠦꠎꠝꠔꠉꠣꠞ ꠛꠣꠘꠣꠁꠟꠣ ꠀꠞ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠣ-ꠢꠥꠘꠣꠞ ꠜꠣꠞꠅ ꠁꠃꠍꠥꠚꠞ ꠉꠦꠍꠦ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN39_5","002_39_5","GEN","39","5","5","ꠁꠃꠍꠥꠚꠞꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠀꠞ ꠢꠇꠟꠔꠣꠞ ꠜꠣꠞ ꠡꠙꠤ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠕꠘꠦ, ꠝꠣꠛꠥꠖꠦ ꠁꠃꠍꠥꠚꠞ ꠟꠣꠉꠤꠃ, ꠔꠣꠘ ꠝꠥꠘꠤꠛꠞ ꠢꠇꠟꠔꠣꠞ ꠝꠣꠎꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠣ। ꠀꠎꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠀꠞ ꠈꠦꠔ-ꠈꠣꠝꠣꠞ, ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠝꠣꠛꠥꠖꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN39_6","002_39_6","GEN","39","6","6","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠎꠤꠎꠦ ꠔꠣꠘ ꠢꠇꠟꠔꠣꠞ ꠜꠣꠞ ꠁꠃꠍꠥꠚꠞ ꠃꠙꠞꠦ ꠡꠙꠤ ꠖꠤꠟꠣ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠞꠃ ꠈꠛꠞ ꠟꠁꠔꠣ ꠘꠣ। ꠁꠃꠍꠥꠚꠞ ꠡꠞꠤꠟꠞ ꠉꠑꠘ ꠀꠞ ꠌꠦꠢꠣꠞꠣꠅ ꠡꠥꠘ꠆ꠖꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN39_7","002_39_7","GEN","39","7","7","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠝꠥꠘꠤꠛꠞ ꠛꠃꠄ ꠔꠣꠘ ꠛꠣꠄ ꠟꠣꠟꠌ ꠇꠞꠟ। ꠔꠣꠁ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟ, “ꠀꠝꠣꠞ ꠛꠤꠍꠘꠣꠔ ꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN39_8","002_39_8","GEN","39","8","8","ꠅꠁꠟꠦ ꠁꠃꠍꠥꠚ ꠞꠣꠎꠤ ꠘꠣ ꠅꠁꠀ ꠝꠥꠘꠤꠛꠞ ꠛꠃꠞꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁ ꠛꠣꠠꠤꠔ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠀꠍꠦ, ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠈꠛꠞ ꠟꠂꠘ ꠘꠣ, ꠢꠇꠟꠔꠣꠞ ꠜꠣꠞ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠡꠝꠎꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN39_9","002_39_9","GEN","39","9","9","ꠁ ꠛꠣꠠꠤꠔ ꠀꠝꠣ ꠕꠘꠦ ꠛꠠ ꠀꠞ ꠇꠦꠃ ꠘꠣꠄ। ꠀꠙꠘꠦ ꠔ ꠔꠣꠘ ꠛꠤꠛꠤ, ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠦ ꠍꠣꠠꠣ ꠀꠞ ꠢꠇꠟꠞꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠞꠣꠈꠍꠂꠘ, ꠔꠦ ꠀꠝꠤ ꠇꠤꠟꠣ ꠅꠔ ꠛꠠ ꠄꠇ ꠎꠊꠁꠘ꠆ꠘ ꠇꠣꠝ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠉꠥꠘꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("GN39_10","002_39_10","GEN","39","10","10","ꠔꠣꠁ ꠢꠣꠝꠦꠡꠣ ꠁꠃꠍꠥꠚꠞꠦ ꠅꠃꠟꠣ ꠝꠤꠘꠔ ꠇꠞꠟꠦꠅ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠁꠞ ꠉꠦꠍꠦ ꠢꠥꠔꠔꠦ ꠛꠣ ꠇꠣꠍꠣꠔ ꠞꠁꠔꠦꠅ ꠞꠣꠎꠤ ꠅꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN39_11","002_39_11","GEN","39","11","11","ꠢꠦꠡꠦ ꠄꠇꠖꠤꠘ ꠇꠥꠘꠥ ꠄꠇ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠁꠃꠍꠥꠚ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠞ ꠇꠦꠃ ꠢꠤꠘꠅ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN39_12","002_39_12","GEN","39","12","12","ꠔꠦꠃ ꠀꠎꠤꠎꠞ ꠛꠃꠄ ꠁꠃꠍꠥꠚꠞ ꠇꠣꠙꠠꠅ ꠗꠞꠤ ꠇꠁꠟ, “ꠀꠝꠣꠞ ꠛꠤꠍꠘꠣꠔ ꠀꠄ।” ꠅꠁꠟꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠇꠣꠙꠠ ꠚꠣꠟꠣꠁꠀ ꠖꠃꠠꠤꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN39_13","002_39_13","GEN","39","13","13","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠁꠞ ꠀꠔꠅ ꠇꠣꠙꠠ ꠕꠁꠀ ꠖꠃꠠꠣꠁꠀ ꠉꠦꠟꠣꠉꠤ ꠇꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("GN39_14","002_39_14","GEN","39","14","14","ꠀꠎꠤꠎꠞ ꠛꠃꠄ ꠊꠞꠞ ꠝꠣꠘꠡꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟ, “ꠢꠥꠘꠅ, ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠔꠣꠝꠡꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁ ꠁꠛꠞꠣꠘꠤ ꠛꠦꠐꠣꠞꠦ ꠀꠘꠍꠂꠘ। ꠢꠦ ꠀꠝꠣꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠣꠞ ꠝꠔꠟꠛꠦ ꠀꠝꠣꠞ ꠛꠤꠍꠘꠣꠔ ꠀꠁꠍꠤꠟ, ꠅꠃ ꠀꠝꠤ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠃꠑꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN39_15","002_39_15","GEN","39","15","15","ꠀꠝꠣꠞ ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠤꠀ ꠢꠦ ꠔꠣꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠕꠁꠀ ꠜꠣꠉꠤꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN39_16","002_39_16","GEN","39","16","16","ꠁꠃꠍꠥꠚꠞ ꠝꠥꠘꠤꠛ ꠛꠣꠠꠤꠔ ꠘꠣ ꠀꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠁ ꠇꠣꠙꠠ ꠔꠣꠁ ꠘꠤꠎꠞ ꠉꠦꠍꠦ ꠞꠣꠈꠟ। ");
INSERT INTO syls_vpl VALUES ("GN39_17","002_39_17","GEN","39","17","17","ꠔꠣꠁꠘ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁ ꠘꠣꠟꠤꠡ ꠖꠤꠟ, “ꠔꠥꠝꠤ ꠎꠦ ꠁꠛꠞꠣꠘꠤ ꠉꠥꠟꠣꠝꠞꠦ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠍ, ꠢꠦ ꠀꠝꠣꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠣꠞ ꠝꠔꠟꠛꠦ ꠀꠝꠣꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN39_18","002_39_18","GEN","39","18","18","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠢꠣꠃꠇꠣ-ꠢꠣꠃꠇꠤ ꠀꠞ ꠌꠤꠟ꠆ꠟꠣꠘꠤꠄ ꠢꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠞ ꠇꠣꠙꠠ ꠚꠣꠟꠣꠁ ꠕꠁꠀ ꠜꠣꠉꠤꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN39_19","002_39_19","GEN","39","19","19","ꠛꠃꠞ ꠝꠣꠔ ꠢꠥꠘꠤꠀ ꠁꠃꠍꠥꠚꠞ ꠝꠥꠘꠤꠛꠦ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ। ꠔꠣꠘ ꠛꠃꠄ ꠇꠁꠟ, “ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN39_20","002_39_20","GEN","39","20","20","ꠔꠦꠃ ꠀꠎꠤꠎꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠘꠤꠀ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠢꠣꠞꠣꠁꠟꠣ। ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣꠞ ꠛꠘ꠆ꠖꠤ ꠅꠇꠟꠞꠦ ꠎꠦꠘꠅ ꠞꠣꠈꠂꠘ, ꠔꠣꠘꠦꠅ ꠢꠃ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN39_21","002_39_21","GEN","39","21","21","ꠅꠁꠟꠦ ꠁꠃꠍꠥꠚꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠄꠀ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠛꠠ ꠎꠦꠟꠣꠞ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN39_22","002_39_22","GEN","39","22","22","ꠛꠠ ꠎꠦꠟꠣꠞ ꠍꠣꠛꠦ ꠎꠦꠟ ꠈꠣꠘꠣꠞ ꠢꠇꠟ ꠛꠘ꠆ꠖꠤ ꠅꠇꠟꠞ ꠡꠞ꠆ꠖꠣꠞꠤ ꠁꠃꠍꠥꠚꠞ ꠃꠙꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠟꠣ, ꠔꠦꠃ ꠢꠘꠞ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠁꠃꠍꠥꠚꠞ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠔ। ");
INSERT INTO syls_vpl VALUES ("GN39_23","002_39_23","GEN","39","23","23","ꠀꠞ ꠛꠠ ꠎꠦꠟꠣꠞ ꠍꠣꠛꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣ ꠟꠣꠉꠔ ꠘꠣ, ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖ ꠁꠃꠍꠥꠚꠞ ꠟꠉꠦ ꠀꠍꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠁꠃꠍꠥꠚꠦ ꠎꠦꠔꠣꠔ ꠀꠔ ꠖꠤꠔꠣ, ꠝꠣꠛꠥꠖꠦ ꠁꠔꠣ ꠇꠣꠝꠤꠀꠛ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN40_1","002_40_1","GEN","40","1","1","ꠁꠔꠣꠞ ꠛꠣꠖꠦ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣꠞ ꠖꠞꠛꠣꠞꠞ ꠡꠞꠣꠛ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠞꠣ ꠀꠞ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠅꠞꠣ ꠁ ꠖꠥꠁꠅꠎꠘꠦ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦ ꠇꠍꠥꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN40_2","002_40_2","GEN","40","2","2","ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘ ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣ ꠅꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN40_3","002_40_3","GEN","40","3","3","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤꠀ ꠔꠣꠘ ꠛꠠ ꠎꠟ꠆ꠟꠣꠖꠞ ꠛꠣꠠꠤꠞ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠟꠣ। ꠅꠃ ꠎꠦꠟꠅ ꠁꠃꠍꠥꠚꠅ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN40_4","002_40_4","GEN","40","4","4","ꠛꠠ ꠎꠟ꠆ꠟꠣꠖꠦ ꠁ ꠖꠥꠁꠅ ꠇꠄꠖꠤꠞ ꠜꠣꠞꠅ ꠁꠃꠍꠥꠚꠞ ꠀꠔꠅ ꠖꠤꠟꠣ, ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠔꠣ ꠟꠣꠉꠟꠣ। ꠅꠃꠟꠣ ꠄꠞꠣ ꠇꠤꠍꠥꠖꠤꠘ ꠎꠦꠟꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN40_5","002_40_5","GEN","40","5","5","ꠛꠣꠖꠦ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣꠞ ꠢꠃ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠅꠞꠣ ꠀꠞ ꠡꠞꠣꠛ ꠛꠤꠟꠣꠅꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠄꠇ ꠞꠣꠁꠔꠦ ꠖꠥꠈꠣꠘ ꠈꠥꠀꠛ ꠖꠦꠈꠟꠣ, ꠔꠣꠞꠣꠞ ꠈꠥꠀꠛꠞ ꠝꠣꠘꠤꠅ ꠀꠍꠤꠟ ꠖꠥꠁ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN40_6","002_40_6","GEN","40","6","6","ꠛꠤꠀꠘꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠔꠣꠞꠣ ꠈꠥꠛ ꠝꠘ-ꠝꠞꠣ ꠅꠁꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN40_7","002_40_7","GEN","40","7","7","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠅꠁꠍꠦ, ꠀꠁꠎ ꠅꠔ ꠛꠦꠎꠣꠞ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("GN40_8","002_40_8","GEN","40","8","8","ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠈꠥꠀꠛ ꠖꠦꠈꠍꠤ, ꠅꠁꠟꠦ ꠄꠞ ꠔꠣꠛꠤꠞ ꠛꠥꠎꠣꠁ ꠖꠦꠅꠞꠣ ꠇꠦꠃ ꠘꠣꠄ।” ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠘꠤ ꠛꠥꠎꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠇꠤꠔꠣ ꠀꠟ꠆ꠟꠣꠄ ꠖꠦꠁꠘ ꠘꠣ ꠘꠤ? ꠖꠦꠈꠤ ꠌꠣꠁꠘ, ꠀꠝꠣꠞꠦ ꠢꠥꠘꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN40_9","002_40_9","GEN","40","9","9","ꠅꠃ ꠢꠤ ꠡꠞꠣꠛ ꠛꠤꠟꠣꠅꠞꠣꠄ, ꠔꠣꠘ ꠡ꠆ꠛꠙꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ। ꠢꠦ ꠇꠁꠟ, “ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠄꠇ ꠀꠋꠉꠥꠞꠞ ꠉꠣꠍ। ");
INSERT INTO syls_vpl VALUES ("GN40_10","002_40_10","GEN","40","10","10","ꠉꠣꠍꠞ ꠔꠤꠘꠉꠥ ꠒꠣꠟ ꠀꠍꠦ; ꠢꠃ ꠒꠣꠟꠅ ꠇꠥꠠꠤ ꠛꠣꠞꠘꠤꠞ ꠟꠉꠦ ꠟꠉꠦ ꠚꠥꠟ ꠗꠞꠟ, ꠀꠞ ꠍꠠꠣ ꠍꠠꠣ ꠀꠋꠉꠥꠞ ꠗꠞꠤ ꠙꠣꠇꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN40_11","002_40_11","GEN","40","11","11","ꠅꠃ ꠡꠝꠄ ꠚꠦꠞꠣꠃꠘꠞ ꠡꠞꠛꠔꠞ ꠙꠤꠀꠟꠣ ꠀꠝꠣꠞ ꠀꠔꠅ ꠀꠍꠤꠟ। ꠀꠝꠤ ꠢꠃ ꠀꠋꠉꠥꠞ ꠅꠇꠟ ꠌꠤꠙꠤꠀ ꠞꠡ ꠛꠣꠞ ꠇꠞꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠀꠔꠅ ꠖꠤꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN40_12","002_40_12","GEN","40","12","12","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠡ꠆ꠛꠙꠘꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠔꠤꠘ ꠒꠣꠟ ꠝꠣꠘꠤ ꠔꠤꠘ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN40_13","002_40_13","GEN","40","13","13","ꠅꠃ ꠔꠤꠘ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠀꠙꠘꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠀꠉꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠛꠣ। ꠀꠙꠘꠦ ꠢꠤꠞꠛꠣꠞ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠀꠔꠅ ꠙꠤꠀꠟꠣ ꠔꠥꠟꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN40_14","002_40_14","GEN","40","14","14","ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠦ ꠝꠤꠘꠔꠤ ꠇꠞꠤ ꠇꠁꠀꠞ, ꠀꠙꠘꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠀꠞ ꠛꠣꠖꠦ ꠀꠝꠣꠞꠦ ꠝꠘꠅ ꠇꠞꠛꠣ ꠀꠞ ꠖꠄꠀ ꠇꠞꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠇꠕꠣ ꠇꠁꠀ, ꠁ ꠎꠦꠟꠈꠣꠘꠣ ꠕꠘꠦ ꠀꠝꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN40_15","002_40_15","GEN","40","15","15","ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡ ꠕꠘꠦ ꠀꠝꠣꠞꠦ ꠎꠥꠞ ꠇꠞꠤ ꠗꠞꠤꠀ ꠀꠘꠣ ꠅꠁꠍꠦ। ꠀꠞ ꠅꠘꠅ ꠀꠁꠀꠅ ꠀꠝꠤ ꠎꠦꠟ ꠈꠣꠐꠣꠞ ꠝꠔ ꠄꠝꠘ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠍꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN40_16","002_40_16","GEN","40","16","16","ꠛꠣꠖꠦ ꠢꠤ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠅꠞꠣꠄ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟ ꠎꠦꠘ, ꠡꠞꠣꠛ ꠛꠤꠟꠣꠅꠞꠣꠞ ꠈꠥꠀꠛꠞ ꠝꠣꠘꠤ ꠜꠣꠟꠣ ꠀꠍꠦ, ꠔꠦꠃ ꠢꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟ, “ꠀꠝꠤꠅ ꠈꠥꠀꠛꠦ ꠖꠦꠈꠍꠤ, ꠖꠦꠈꠟꠣꠝ ꠎꠦꠘ ꠀꠝꠣꠞ ꠝꠣꠕꠣꠔ ꠔꠤꠘ ꠐꠥꠇꠞꠤ ꠝꠄꠖꠣꠞ ꠞꠥꠐꠤ ꠟꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN40_17","002_40_17","GEN","40","17","17","ꠀꠞ ꠃꠙꠞꠞ ꠐꠥꠇꠞꠤꠔ ꠀꠍꠤꠟ, ꠚꠦꠞꠣꠃꠘꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠎꠣꠔꠞ ꠙꠤꠑꠣ; ꠔꠦꠃ ꠙꠣꠈꠤ ꠅꠇꠟꠦ ꠀꠁꠀ, ꠀꠝꠣꠞ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠞ ꠐꠥꠇꠞꠤ ꠕꠣꠇꠤ ꠁꠔꠣ ꠈꠣꠁꠟꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN40_18","002_40_18","GEN","40","18","18","ꠁꠃꠍꠥꠚꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠁ ꠡ꠆ꠛꠙꠘꠞ ꠔꠣꠛꠤꠞ ꠅꠁꠟ, ꠔꠤꠘ ꠐꠥꠇꠞꠤ ꠝꠣꠘꠤ ꠔꠤꠘ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN40_19","002_40_19","GEN","40","19","19","ꠅꠃ ꠔꠤꠘ ꠖꠤꠘꠞ ꠝꠣꠎꠦ, ꠚꠦꠞꠣꠃꠘꠦ ꠀꠙꠘꠣꠞ ꠗꠠ ꠕꠘꠦ ꠇꠟ꠆ꠟꠣ ꠀꠟꠉꠣꠁꠀ, ꠉꠣꠍꠞ ꠝꠣꠎꠦ ꠟꠐꠇꠣꠁꠛꠣ, ꠢꠦꠡꠦ ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠀꠙꠘꠣꠞ ꠗꠠꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN40_20","002_40_20","GEN","40","20","20","ꠄꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠎꠘꠝ ꠖꠤꠘ ꠀꠍꠤꠟ। ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ, ꠈꠣꠘꠤ ꠔꠤꠀꠞ ꠇꠞꠣꠁꠟꠣ। ꠀꠞ ꠢꠃ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠅꠞꠣ ꠀꠞ ꠡꠞꠣꠛ ꠛꠤꠟꠣꠅꠞꠣ ꠖꠥꠁꠅꠎꠘꠞꠦ ꠀꠘꠣꠁꠀ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN40_21","002_40_21","GEN","40","21","21","ꠔꠣꠁꠘ ꠡꠞꠣꠛ ꠛꠤꠟꠣꠅꠞꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠟꠣ, ꠢꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠀꠔꠅ ꠢꠤꠞꠛꠣꠞ ꠙꠤꠀꠟꠣ ꠔꠥꠟꠤꠀ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN40_22","002_40_22","GEN","40","22","22","ꠅꠁꠟꠦ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠅꠞꠣꠞꠦ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠟꠣ। ꠁꠃꠍꠥꠚꠦ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃꠟꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN40_23","002_40_23","GEN","40","23","23","ꠔꠣ-ꠅ ꠁꠃꠍꠥꠚꠞ ꠇꠕꠣ ꠢꠤ ꠡꠞꠣꠛ ꠛꠤꠟꠣꠅꠞꠣꠞ ꠁꠀꠖ ꠞꠁꠟ ꠘꠣ, ꠢꠦ ꠚꠣꠃꠞꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_1","002_41_1","GEN","41","1","1","ꠄꠞ ꠙꠥꠞꠣ ꠖꠥꠁ ꠛꠞꠍ ꠛꠣꠖꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠈꠥꠀꠛꠦ ꠖꠦꠈꠟꠣ। ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠘꠤꠟ ꠘꠖꠞ ꠉꠦꠍꠦ ꠔꠣꠁꠘ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("GN41_2","002_41_2","GEN","41","2","2","ꠀꠞ ꠘꠤꠟ ꠘꠖ ꠕꠘꠦ ꠡꠣꠔꠉꠥ ꠡꠥꠘ꠆ꠖꠞ ꠔꠞꠔꠣꠎꠣ ꠉꠞꠥ ꠃꠑꠤꠀ ꠀꠁꠀ ꠘꠟ ꠛꠘꠞ ꠝꠣꠎꠦ ꠀꠐꠤꠀ ꠈꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_3","002_41_3","GEN","41","3","3","ꠄꠞꠛꠣꠖꠦ ꠖꠦꠈꠂꠘ, ꠀꠞꠅ ꠡꠣꠔꠉꠥ ꠢꠣꠟꠣꠇ ꠀꠞ ꠈꠛꠤꠍꠞ ꠟꠣꠈꠣꠘ ꠉꠞꠥ ꠃꠑꠤꠀ ꠀꠁꠀ, ꠘꠤꠟ ꠘꠖꠞ ꠙꠣꠞꠞ ꠢꠃ ꠉꠞꠥꠁꠘ꠆ꠔꠞ ꠇꠣꠍꠣꠔ ꠃꠛꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_4","002_41_4","GEN","41","4","4","ꠢꠦꠡꠦ ꠅꠃ ꠢꠣꠟꠣꠇ ꠀꠞ ꠈꠛꠤꠍꠞ ꠟꠣꠈꠣꠘ ꠉꠞꠥꠁꠘ꠆ꠔꠦ ꠢꠃ ꠡꠥꠘ꠆ꠖꠞ ꠀꠞ ꠔꠞꠔꠣꠎꠣ ꠡꠣꠔꠅ ꠉꠞꠥꠞꠦ ꠈꠣꠁꠟꠤꠟ, ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘꠞ ꠊꠥꠝ ꠜꠣꠋꠉꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_5","002_41_5","GEN","41","5","5","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠊꠥꠝꠣꠁꠟꠣ ꠀꠞ ꠖꠥꠀꠞꠣ ꠈꠥꠀꠛꠦ ꠖꠦꠈꠟꠣ, ꠄꠇ ꠉꠝꠞ ꠒꠦꠐꠣꠔ ꠡꠣꠔꠉꠥ ꠙꠥꠡ꠆ꠐ ꠀꠞ ꠔꠣꠎꠣ ꠍꠠꠣ ꠛꠣꠞ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN41_6","002_41_6","GEN","41","6","6","ꠢꠦꠡꠦ ꠛꠣꠞ ꠅꠁꠟ, ꠙꠥꠛꠣꠟꠤ ꠛꠣꠔꠣꠡꠞ ꠉꠞꠝꠦ ꠢꠥꠇꠘꠣ ꠡꠣꠔꠉꠥ ꠇꠝ ꠙꠥꠡ꠆ꠐ ꠍꠥꠍꠣꠀꠟꠣ ꠍꠠꠣ, ");
INSERT INTO syls_vpl VALUES ("GN41_7","002_41_7","GEN","41","7","7","ꠀꠞ ꠅꠃ ꠇꠝ ꠙꠥꠡ꠆ꠐ ꠍꠠꠣꠄ ꠢꠃ ꠡꠣꠔꠅ ꠙꠥꠡ꠆ꠐ-ꠔꠣꠎꠣ ꠍꠠꠣꠞꠦ ꠉꠤꠟꠤꠟꠣꠁꠟ। ꠛꠣꠖꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠊꠥꠝ ꠜꠣꠋꠉꠤ ꠉꠦꠟ, ꠔꠣꠁꠘ ꠛꠥꠎꠟꠣ ꠎꠦꠘ ꠁꠔꠣ ꠔ ꠈꠥꠀꠛ। ");
INSERT INTO syls_vpl VALUES ("GN41_8","002_41_8","GEN","41","8","8","ꠛꠤꠀꠘꠦ ꠔꠣꠘ ꠝꠘ ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠉꠦꠟ, ꠔꠦꠃ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇꠟ ꠎꠣꠖꠥꠉꠤꠞ ꠀꠞ ꠙꠘ꠆ꠒꠤꠔꠞꠦ ꠈꠛꠞꠤꠀꠖꠤ ꠀꠘꠣꠁꠀ, ꠔꠣꠘ ꠈꠥꠀꠛ ꠔꠣꠞꠣꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠄꠞꠣꠞ ꠇꠦꠃ ꠄꠞ ꠔꠣꠛꠤꠞ ꠇꠁꠔ ꠙꠣꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_9","002_41_9","GEN","41","9","9","ꠢꠦꠡꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠢꠃ ꠡꠞꠣꠛ ꠛꠤꠟꠣꠅꠞꠣꠄ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠁꠎ ꠀꠝꠣꠞ ꠄꠇ ꠖꠥꠡ ꠝꠘꠅ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN41_10","002_41_10","GEN","41","10","10","ꠛꠃꠔ ꠖꠤꠘ ꠀꠉꠦ ꠢꠥꠎꠥꠞꠦ ꠘꠤꠎꠞ ꠖꠥꠁ ꠉꠥꠟꠣꠝꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣ ꠇꠞꠍꠟꠣ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠀꠞ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠅꠞꠣꠞꠦ ꠛꠠ ꠎꠦꠟꠣꠞ ꠍꠣꠛꠞ ꠛꠣꠠꠤꠞ ꠎꠦꠟꠅ ꠕꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_11","002_41_11","GEN","41","11","11","ꠀꠞ ꠄꠇ ꠞꠣꠁꠔꠦ ꠀꠝꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠀꠟꠉ ꠀꠟꠉ ꠈꠥꠀꠛ ꠖꠦꠈꠟꠣꠝ, ꠖꠥꠁꠅ ꠈꠥꠀꠛꠞ ꠖꠥꠁ ꠟꠣꠈꠣꠘ ꠔꠣꠛꠤꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_12","002_41_12","GEN","41","12","12","ꠁ ꠡꠝꠄ ꠎꠦꠟꠣꠞ ꠍꠣꠛꠞ, ꠄꠇ ꠁꠛꠞꠣꠘꠤ ꠎꠥꠀꠘ ꠉꠥꠟꠣꠝꠅ ꠅꠘꠅ ꠀꠍꠤꠟ। ꠔꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠈꠥꠀꠛꠞ ꠇꠕꠣ ꠢꠥꠘꠣꠁꠟꠣꠝ, ꠀꠞ ꠢꠦ ꠀꠝꠞꠣꠞ ꠈꠥꠀꠛꠞ ꠔꠣꠛꠤꠞ ꠇꠁꠀ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_13","002_41_13","GEN","41","13","13","ꠢꠦ ꠀꠝꠞꠣꠞ ꠈꠥꠀꠛꠞ ꠔꠣꠛꠤꠞ ꠎꠦꠟꠣ ꠇꠁꠍꠤꠟ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘꠃ ꠚꠟꠤꠟ। ꠢꠥꠎꠥꠞꠦ ꠀꠝꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠅꠞꠣꠞꠦ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN41_14","002_41_14","GEN","41","14","14","ꠅꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠉꠤꠀ ꠎꠟꠖꠤ ꠇꠞꠤ ꠎꠦꠟꠈꠣꠘꠣ ꠕꠘꠦ ꠔꠣꠘꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣ। ꠁꠃꠍꠥꠚꠦ ꠖꠣꠠꠤ-ꠝꠥꠍ ꠇꠣꠝꠣꠁꠀ, ꠇꠣꠙꠠ ꠛꠖꠟꠣꠁꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_15","002_41_15","GEN","41","15","15","ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠄꠇꠈꠣꠘ ꠈꠥꠀꠛ ꠖꠦꠈꠍꠤ, ꠅꠁꠟꠦ ꠄꠞ ꠔꠣꠛꠤꠞ ꠇꠦꠃ ꠇꠁꠔ ꠙꠣꠞꠦꠞ ꠘꠣ। ꠔꠦ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ ꠎꠦꠘ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠈꠥꠀꠛ ꠢꠥꠘꠣꠁꠟꠦ, ꠔꠥꠝꠤ ꠄꠞ ꠔꠣꠛꠤꠞ ꠇꠁꠔꠣꠄ ꠙꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN41_16","002_41_16","GEN","41","16","16","ꠁꠃꠍꠥꠚꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠤ ꠈꠦꠝꠔꠣ ꠔ ꠀꠝꠣꠞ ꠘꠣꠄ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠝꠢꠣꠞꠣꠎꠞ ꠖꠤꠟꠞ ꠡꠣꠘ꠆ꠔꠤꠞ ꠎꠥꠀꠙ ꠛꠣꠔꠣꠁꠀ ꠖꠤꠛꠣ ꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN41_17","002_41_17","GEN","41","17","17","ꠚꠦꠞꠣꠃꠘꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠈꠥꠀꠛꠦ ꠖꠦꠈꠟꠣꠝ, ꠀꠝꠤ ꠘꠤꠟ ꠘꠖꠞ ꠙꠣꠞꠅ ꠃꠛꠣꠁ ꠞꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN41_18","002_41_18","GEN","41","18","18","ꠀꠞ ꠖꠦꠈꠤ, ꠉꠣꠋꠉꠅ ꠕꠘꠦ ꠡꠣꠔꠉꠥ ꠡꠥꠘ꠆ꠖꠞ, ꠔꠞꠔꠣꠎꠣ ꠉꠞꠥ ꠃꠑꠤꠀ ꠀꠁꠀ ꠘꠟ ꠛꠘꠞ ꠝꠣꠎꠦ ꠀꠐꠤꠀ ꠈꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_19","002_41_19","GEN","41","19","19","ꠄꠞꠛꠣꠖꠦ ꠀꠞꠅ ꠡꠣꠔꠉꠥ ꠉꠞꠥ ꠃꠑꠤꠀ ꠀꠁꠟ। ꠁꠔꠣ ꠢꠣꠟꠣꠇ ꠀꠞ ꠈꠛꠤꠍꠞ ꠟꠣꠈꠣꠘ, ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠈꠣꠘꠅ ꠁꠟꠣꠈꠣꠘ ꠛꠦ-ꠍꠥꠞꠔ ꠉꠞꠥ ꠇꠥꠘꠥ ꠖꠤꠘꠅ ꠖꠦꠈꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_20","002_41_20","GEN","41","20","20","ꠛꠣꠖꠦ ꠅꠃ ꠢꠣꠟꠣꠇ ꠀꠞ ꠛꠦ-ꠍꠥꠞꠔ ꠉꠞꠥꠁꠘ꠆ꠔꠦ, ꠀꠉꠞ ꠢꠤ ꠡꠣꠔꠅ ꠔꠞꠔꠣꠎꠣ ꠉꠞꠥꠞꠦ ꠈꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_21","002_41_21","GEN","41","21","21","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠁꠔꠣꠞꠦ ꠉꠤꠟꠣꠞ ꠛꠣꠖꠦ, ꠈꠣꠁꠍꠦ ꠇꠞꠤ ꠛꠥꠎꠣꠅ ꠉꠦꠟ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠀꠉꠞ ꠟꠣꠈꠣꠘꠃ ꠢꠣꠟꠣꠇ ꠀꠞ ꠛꠦ-ꠍꠥꠞꠔ ꠞꠁꠟ। ꠢꠦꠡꠦ ꠀꠝꠣꠞ ꠊꠥꠝ ꠜꠣꠋꠉꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_22","002_41_22","GEN","41","22","22","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠟꠣꠝ, ꠉꠝꠞ ꠄꠇ ꠒꠦꠐꠣꠞ ꠝꠣꠎꠦ ꠡꠣꠔꠉꠥ ꠛꠠ ꠀꠞ ꠙꠥꠡ꠆ꠐ ꠍꠠꠣ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_23","002_41_23","GEN","41","23","23","ꠙꠥꠛꠣꠟꠤ ꠢꠣꠅꠀꠞ ꠉꠞꠝꠦ ꠢꠥꠇꠘꠣ ꠡꠣꠔꠉꠥ ꠇꠝ ꠙꠥꠡ꠆ꠐ ꠍꠥꠍꠣꠀꠟꠣ ꠍꠠꠣꠅ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_24","002_41_24","GEN","41","24","24","ꠀꠞ ꠅꠃ ꠡꠣꠔꠅ ꠍꠠꠣꠄ, ꠢꠃ ꠔꠣꠎꠣ ꠡꠣꠔꠅ ꠍꠠꠣꠞꠦ ꠉꠤꠟꠤꠟꠤꠟ। ꠁ ꠈꠥꠀꠛ ꠀꠝꠤ ꠎꠣꠖꠥꠉꠤꠞ ꠅꠇꠟꠞꠦ ꠢꠥꠘꠣꠁꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠇꠦꠃ ꠄꠞ ꠝꠣꠘꠤ ꠇꠁꠔ ꠙꠣꠞꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN41_25","002_41_25","GEN","41","25","25","ꠁꠃꠍꠥꠚꠦ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠖꠥꠁꠅ ꠈꠥꠀꠛꠃ ꠀꠖꠔꠦ ꠄꠇ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠇꠞꠔꠣ ꠌꠣꠁꠞꠣ, ꠁꠔꠣ ꠀꠙꠘꠣꠞꠦ ꠖꠦꠈꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN41_26","002_41_26","GEN","41","26","26","ꠅꠃ ꠔꠞꠔꠣꠎꠣ ꠡꠣꠔꠅ ꠉꠞꠥꠞ ꠝꠣꠘꠤ ꠡꠣꠔ ꠛꠞꠍ, ꠀꠞ ꠙꠥꠡ꠆ꠐ ꠡꠣꠔꠅ ꠉꠝꠞ ꠍꠠꠣꠞ ꠝꠣꠘꠤꠅ ꠡꠣꠔ ꠛꠞꠍ। ꠖꠥꠁꠅ ꠈꠥꠀꠛꠃ ꠄꠇ। ");
INSERT INTO syls_vpl VALUES ("GN41_27","002_41_27","GEN","41","27","27","ꠀꠞ ꠢꠦꠡꠦ ꠃꠑꠤꠀ ꠀꠅꠀ ꠡꠣꠔꠅ ꠢꠣꠟꠣꠇ ꠀꠞ ꠛꠦ-ꠍꠥꠞꠔ ꠉꠞꠥ, ꠀꠞ ꠙꠥꠛꠣꠟꠤ ꠢꠣꠅꠀꠞ ꠉꠞꠝꠦ ꠢꠥꠇꠘꠣ ꠡꠣꠔꠅ ꠉꠝꠞ ꠍꠠꠣ, ꠄꠞꠣꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠀꠇꠣꠟꠞ ꠡꠣꠔ ꠛꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("GN41_28","002_41_28","GEN","41","28","28","ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠇꠞꠔꠣ ꠌꠣꠁꠞꠣ, ꠁꠔꠣ ꠝꠢꠣꠞꠣꠎꠞꠦ ꠖꠦꠈꠣꠁꠍꠂꠘ। ꠅꠃ ꠇꠕꠣꠃ ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠀꠉꠦ ꠇꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN41_29","002_41_29","GEN","41","29","29","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠡꠣꠔ ꠛꠞꠍ ꠈꠥꠛ ꠛꠦꠡꠤ ꠚꠡꠟ ꠚꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("GN41_30","002_41_30","GEN","41","30","30","ꠄꠞꠛꠣꠖꠦꠃ ꠀꠁꠛ ꠀꠇꠣꠟꠞ ꠡꠣꠔ ꠛꠞꠍ। ꠔꠦꠃ ꠀꠉꠞ ꠢꠤ ꠛꠦꠡꠤ ꠚꠡꠟꠞ ꠇꠕꠣ ꠝꠣꠘꠡꠦ ꠚꠣꠃꠞꠤꠟꠤꠛꠣ, ꠀꠞ ꠀꠇꠣꠟꠦ ꠖꠦꠡꠞꠦ ꠡꠦꠡ ꠇꠞꠤ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("GN41_31","002_41_31","GEN","41","31","31","ꠅꠃ ꠀꠇꠣꠟꠞ ꠖꠞꠥꠘ, ꠀꠉꠞ ꠢꠤ ꠚꠡꠟꠞ ꠇꠕꠣ ꠝꠣꠘꠡꠞ ꠝꠘꠅ ꠞꠁꠔ ꠘꠣꠄ। ꠁ ꠀꠇꠣꠟ ꠅꠁꠛ ꠈꠥꠛ ꠛꠦꠎꠥꠁꠔꠣ ꠝꠍꠤꠛꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("GN41_32","002_41_32","GEN","41","32","32","ꠁ ꠈꠥꠀꠛ ꠀꠙꠘꠣꠞꠦ ꠖꠥꠁꠛꠣꠞ ꠖꠦꠈꠣꠘꠤꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠁ ꠖꠡꠣ ꠊꠐꠣꠁꠛꠣ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠑꠤꠇ ꠇꠞꠤꠟꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠈꠥꠛ ꠎꠟꠖꠤ ꠇꠞꠤꠃ ꠊꠐꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("GN41_33","002_41_33","GEN","41","33","33","ꠅꠈꠘ ꠢꠥꠎꠥꠞꠦ ꠄꠇꠎꠘ ꠌꠔꠥꠞ-ꠛꠥꠎꠖꠣꠞ ꠙꠘ꠆ꠒꠤꠔ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠇꠣꠁꠀ, ꠄꠘ ꠉꠦꠍꠦ ꠝꠤꠡꠞꠞꠦ ꠡꠙꠤ ꠖꠦꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_34","002_41_34","GEN","41","34","34","ꠀꠞ ꠀꠙꠘꠦ ꠅꠃꠟꠣ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠖꠦꠡꠅ ꠀꠙꠘꠣꠞ ꠇꠞ꠆ꠝꠌꠣꠞꠤ ꠟꠣꠉꠣꠁꠘ, ꠅꠃ ꠡꠣꠔ ꠛꠍꠞꠦ ꠎꠦꠛꠟꠣ ꠈꠥꠛ ꠛꠦꠡꠤ ꠚꠡꠟ ꠚꠟꠛ, ꠁ ꠡꠝꠄ ꠔꠣꠞꠣ ꠄꠞ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠖꠟꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_35","002_41_35","GEN","41","35","35","ꠔꠣꠞꠣ ꠅꠃ ꠡꠥꠖꠤꠘꠞ ꠛꠍꠞꠞ ꠗꠣꠘ ꠖꠟꠣ ꠇꠞꠤꠀ ꠢꠥꠎꠥꠞꠞ ꠖꠈꠟꠦ, ꠛꠣꠎꠣꠞꠦ ꠛꠣꠎꠣꠞꠦ ꠉꠥꠖꠣꠝꠅ ꠜꠞꠤꠀ ꠕꠃꠇ ꠀꠞ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GN41_36","002_41_36","GEN","41","36","36","ꠡꠣꠔ ꠛꠞꠍ ꠗꠞꠤ ꠝꠤꠡꠞꠅ ꠎꠦ ꠀꠇꠣꠟ ꠅꠁꠛ, ꠢꠃ ꠀꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠗꠣꠘ ꠎꠝꠣꠁꠀ ꠞꠣꠈꠛꠣ, ꠔꠦꠃ ꠀꠇꠣꠟꠦ ꠖꠦꠡꠞ ꠝꠣꠘꠥꠡ ꠝꠞꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN41_37","002_41_37","GEN","41","37","37","ꠁꠃꠍꠥꠚꠞ ꠁ ꠝꠣꠔ, ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠞ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠈꠥꠛ ꠜꠣꠟꠣ ꠝꠘꠅ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_38","002_41_38","GEN","41","38","38","ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠘ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠁ ꠛꠦꠌꠣꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠀꠟꠣ ꠝꠣꠘꠥꠡ ꠀꠝꠤ ꠇꠥꠀꠁ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("GN41_39","002_41_39","GEN","41","39","39","ꠅꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠥꠎꠖꠣꠞ ꠀꠞ ꠛꠤꠛꠦꠇꠝꠣꠘ ꠔ ꠀꠞ ꠇꠦꠃ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN41_40","002_41_40","GEN","41","40","40","ꠅꠈꠘ ꠞꠣꠎꠛꠣꠠꠤꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠥꠝꠤꠃ ꠌꠣꠟꠣꠁꠛꠣꠄ। ꠀꠝꠣꠞ ꠢꠇꠟ ꠙ꠆ꠞꠎꠣ ꠔꠥꠝꠣꠞ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠛꠣ। ꠈꠣꠟꠤ ꠛꠣꠖꠡꠣꠞ ꠔꠈ꠆ꠔꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN41_41","002_41_41","GEN","41","41","41","ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN41_42","002_41_42","GEN","41","42","42","ꠀꠞ ꠚꠦꠞꠣꠃꠘꠦ ꠘꠤꠎꠞ ꠀꠋꠉꠥꠁꠟ ꠕꠣꠇꠤ ꠛꠣꠖꠡꠣꠁ ꠡꠤꠟꠞ ꠀꠋꠐꠤ ꠈꠥꠟꠤꠀ ꠁꠃꠍꠥꠚꠞ ꠀꠔꠅ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ, ꠔꠣꠘ ꠉꠟꠣꠔ ꠡꠥꠘꠣꠞ ꠢꠣꠞ ꠖꠤꠟꠣ ꠀꠞ ꠖꠣꠝꠤ ꠇꠣꠙꠠꠞ ꠡꠣꠖꠣ ꠟꠦꠛꠣꠍꠅ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_43","002_41_43","GEN","41","43","43","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠔꠣꠘ ꠞꠣꠁꠎ꠆ꠎꠞ ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠞꠕꠞ ꠝꠣꠎꠦ ꠔꠥꠟꠟꠣ ꠀꠞ ꠁꠃꠍꠥꠚꠞ ꠀꠉꠦ ꠀꠉꠦ ꠄꠟꠣꠘ ꠇꠞꠣ ꠅꠁꠟ, “ꠙꠞꠘꠣꠝ ꠇꠞꠅ! ꠙꠞꠘꠣꠝ ꠇꠞꠅ!” ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞ ꠃꠙꠞꠦ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠜꠣꠞ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_44","002_41_44","GEN","41","44","44","ꠚꠦꠞꠣꠃꠘꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠚꠦꠞꠣꠃꠘ, ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ! ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠍꠣꠠꠣ, ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠇꠦꠃ ꠞꠥꠝꠣꠅ ꠟꠣꠠꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN41_45","002_41_45","GEN","41","45","45","ꠚꠦꠞꠣꠃꠘꠦ ꠁꠃꠍꠥꠚꠞ ꠘꠄꠀ ꠘꠣꠝ ꠞꠣꠈꠟꠣ, ꠡꠣꠚꠘꠕ-ꠙꠣꠘꠦꠢ। ꠔꠣꠁꠘ ꠅꠃꠘ ꠝꠘ꠆ꠖꠤꠞꠞ ꠛꠣꠛꠘ-ꠑꠣꠇꠥꠞ ꠙꠥꠐꠤꠚꠦꠞꠣꠞ ꠙꠥꠠꠤ ꠀꠡꠘꠔꠞꠦ ꠁꠃꠍꠥꠚꠞ ꠟꠉꠦ ꠛꠤꠀ ꠖꠤꠟꠣ ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠊꠥꠞꠣꠊꠥꠞꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_46","002_41_46","GEN","41","46","46","ꠁꠃꠍꠥꠚꠦ ꠔꠤꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠅ, ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠟꠣ, ꠔꠣꠁꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠞꠛꠣꠞ ꠕꠘꠦ ꠛꠣꠞ ꠅꠁꠀ ꠖꠦꠡꠞ ꠢꠇꠟ ꠎꠣꠉꠣ ꠍꠚꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_47","002_41_47","GEN","41","47","47","ꠀꠞ ꠛꠦꠡꠤ ꠚꠡꠟꠞ ꠅꠃ ꠡꠣꠔ ꠛꠍꠞꠦ ꠖꠦꠡꠅ ꠛꠃꠔ ꠚꠡꠟ ꠚꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_48","002_41_48","GEN","41","48","48","ꠔꠦꠃ ꠁꠃꠍꠥꠚꠦ ꠁ ꠡꠥꠖꠤꠘꠞ ꠡꠣꠔ ꠛꠍꠞꠦ ꠝꠤꠡꠞꠞ ꠢꠇꠟ ꠗꠣꠘ, ꠛꠣꠎꠣꠞꠞ ꠉꠥꠖꠣꠝ ꠊꠞꠣꠁꠘ꠆ꠔꠅ ꠎꠝꠣ ꠇꠞꠣꠁꠀ ꠕꠁꠟꠣ। ꠔꠣꠁꠘ ꠢꠇ꠆ꠇꠟ ꠛꠣꠎꠣꠞꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠗꠣꠘ ꠅꠇꠟ, ꠢꠃ ꠛꠣꠎꠣꠞꠞ ꠉꠥꠖꠣꠝꠅ ꠎꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_49","002_41_49","GEN","41","49","49","ꠔꠣꠁꠘ ꠖꠞꠤꠀꠞ ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ ꠅꠃꠟꠣ ꠛꠦꠢꠤꠡꠣꠛ ꠗꠣꠘ ꠖꠟꠣ ꠇꠞꠟꠣ ꠎꠦꠘ, ꠁꠔꠣ ꠀꠞ ꠝꠣꠙꠤꠀ ꠚꠥꠠꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠔꠦꠃ ꠝꠣꠙꠣ-ꠝꠣꠙꠤ ꠇꠞꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_50","002_41_50","GEN","41","50","50","ꠀꠞ ꠀꠇꠣꠟꠞ ꠀꠉꠦ ꠅꠃꠘ ꠝꠘ꠆ꠖꠤꠞꠞ ꠛꠣꠛꠘ-ꠑꠣꠇꠥꠞ, ꠙꠥꠐꠤꠚꠦꠞꠣꠞ ꠙꠥꠠꠤ ꠀꠡꠘꠔꠞ ꠙꠦꠐꠅ ꠁꠃꠍꠥꠚꠞ ꠖꠥꠁ ꠙꠥꠀ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_51","002_41_51","GEN","41","51","51","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠠ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠝꠣꠘꠡꠣ ꠝꠣꠘꠤ, ꠚꠣꠃꠞꠤꠟꠣꠅꠀ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞ ꠢꠇꠟ ꠔꠇꠟꠤꠚ ꠀꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠞ ꠢꠇ꠆ꠇꠟꠔꠣ, ꠀꠝꠣꠞ ꠖꠤꠟ ꠕꠘꠦ ꠚꠣꠃꠞꠣꠁꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN41_52","002_41_52","GEN","41","52","52","ꠛꠣꠖꠦ ꠔꠣꠘ ꠖꠥꠍꠞꠣ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠀꠚꠞꠣꠁꠝ ꠝꠣꠘꠤ, ꠚꠟꠖꠣꠞ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦ ꠖꠦꠡꠅ ꠔꠇꠟꠤꠚ ꠙꠣꠁꠍꠤ, ꠢꠃ ꠖꠦꠡꠅꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠚꠟꠖꠣꠞ ꠛꠣꠘꠣꠁꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN41_53","002_41_53","GEN","41","53","53","ꠀꠞ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠈꠥꠛ ꠛꠦꠡꠤ ꠚꠡꠟꠞ ꠢꠤ ꠡꠣꠔ ꠛꠞꠍ ꠙꠥꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN41_54","002_41_54","GEN","41","54","54","ꠔꠦꠃ ꠁꠃꠍꠥꠚꠦ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣ, ꠅꠃꠟꠣ ꠀꠇꠣꠟꠞ ꠢꠃ ꠡꠣꠔ ꠛꠞꠍ ꠀꠁꠀ ꠀꠎꠤꠟ। ꠄꠞ ꠟꠉꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠢꠇꠟ ꠖꠦꠡꠅ-ꠅ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠟ ꠅꠁꠟꠦ ꠝꠤꠡꠞꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤꠞ ꠅꠜꠣꠛ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_55","002_41_55","GEN","41","55","55","ꠢꠦꠡꠦ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠇꠣꠟ ꠖꠦꠈꠣ ꠖꠤꠟꠦ, ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠦ ꠀꠁꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠈꠣꠘꠤ ꠝꠣꠉꠤꠟꠣ, ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁꠃꠍꠥꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠅ। ꠄꠁꠘ ꠎꠦꠟꠣ ꠇꠂꠘ, ꠑꠤꠇꠃ ꠅꠃꠟꠣ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN41_56","002_41_56","GEN","41","56","56","ꠁ ꠀꠇꠣꠟ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠎꠥꠠꠤ ꠖꠦꠈꠣ ꠖꠤꠟ। ꠛꠣꠖꠦ ꠀꠞꠅ ꠛꠦꠎꠥꠁꠔꠣ ꠅꠀꠄ ꠁꠃꠍꠥꠚꠦ ꠢꠇꠟ ꠎꠣꠉꠣꠞ ꠉꠥꠖꠣꠝ ꠊꠞꠣꠁꠘ ꠈꠥꠟꠤꠀ, ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠗꠣꠘ ꠛꠦꠌꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN41_57","002_41_57","GEN","41","57","57","ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠟ ꠀꠞ ꠢꠇꠟ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠦ ꠗꠣꠘ ꠈꠞꠤꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠁꠃꠍꠥꠚꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_1","002_42_1","GEN","42","1","1","ꠁꠀꠇꠥꠛꠦꠅ ꠢꠥꠘꠟꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠗꠣꠘ ꠀꠍꠦ, ꠅꠃ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠄꠉꠥꠄ ꠀꠞꠉꠥꠞ ꠝꠥꠈꠞ ꠛꠣꠄ ꠌꠣꠁ ꠞꠁꠍ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("GN42_2","002_42_2","GEN","42","2","2","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠢꠥꠘꠍꠤ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠗꠣꠘ ꠀꠍꠦ, ꠔꠥꠝꠞꠣ ꠢꠘꠅ ꠉꠤꠀ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠤꠍꠥ ꠗꠣꠘ ꠟꠁꠀ ꠀꠘꠅ, ꠔꠦꠃ ꠀꠝꠞꠣ ꠁ ꠝꠞꠘ ꠕꠣꠇꠤꠀ ꠎꠣꠘꠦ ꠛꠣꠌꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN42_3","002_42_3","GEN","42","3","3","ꠅꠃ ꠁꠃꠍꠥꠚꠞ ꠖꠡꠅ ꠜꠣꠁꠄ ꠗꠣꠘ ꠟꠁꠀ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠝꠤꠡꠞꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_4","002_42_4","GEN","42","4","4","ꠅꠁꠟꠦ ꠁꠀꠇꠥꠛꠦ ꠁꠃꠍꠥꠚꠞ ꠀꠙꠘ ꠝꠣʼꠞ ꠙꠦꠐꠞ ꠜꠣꠁ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠣꠁꠔꠦ ꠖꠤꠟꠣ ꠘꠣ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ꠄꠞ ꠇꠥꠘꠥ ꠛꠤꠙꠖ ꠅꠁꠎꠤꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("GN42_5","002_42_5","GEN","42","5","5","ꠗꠣꠘ ꠈꠞꠤꠖꠞ ꠟꠣꠉꠤ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠕꠣꠇꠤ ꠎꠦꠞꠣ ꠝꠤꠡꠞꠅ ꠉꠦꠟ, ꠁꠍꠞꠣꠁꠟꠞ ꠙꠥꠀꠂꠘꠅ ꠔꠣꠞꠣꠞ ꠖꠟꠞ ꠟꠉꠅ ꠅꠁꠀ ꠉꠦꠟꠣ, ꠇꠣꠞꠘ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ-ꠅ ꠀꠇꠣꠟ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN42_6","002_42_6","GEN","42","6","6","ꠁ ꠡꠝꠄ ꠁꠃꠍꠥꠚꠃ ꠀꠍꠟꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠣꠟꠤꠇ। ꠖꠦꠡꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠔꠣꠁꠘꠃ ꠗꠣꠘ ꠛꠦꠌꠔꠣ। ꠔꠦꠃ ꠁꠃꠍꠥꠚꠞ ꠜꠣꠁꠀꠁꠘꠅ ꠔꠣꠘ ꠉꠦꠍꠦ ꠉꠤꠀ, ꠔꠣꠞꠣ ꠝꠣꠕꠣꠞꠦ ꠝꠣꠐꠤꠔ ꠟꠣꠉꠣꠁꠀ ꠔꠣꠘꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_7","002_42_7","GEN","42","7","7","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠌꠤꠘꠤꠟꠤꠟꠣ, ꠅꠁꠟꠦ ꠘꠣ ꠌꠤꠘꠣꠞ ꠜꠣꠘ ꠇꠞꠤꠀ, ꠔꠣꠁꠘ ꠈꠥꠛ ꠇꠠꠣ ꠉꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠕꠘꠦ ꠀꠁꠍꠤ, ꠗꠣꠘ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN42_8","002_42_8","GEN","42","8","8","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠢꠣꠍꠣꠞꠞ ꠌꠤꠘꠟꠦꠅ, ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_9","002_42_9","GEN","42","9","9","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠟꠁꠀ ꠈꠥꠀꠛꠦ ꠎꠦꠔꠣ ꠖꠦꠈꠍꠟꠣ, ꠢꠃ ꠇꠕꠣ ꠔꠣꠘ ꠝꠘꠅ ꠅꠁꠟ। ꠅꠃ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠉꠥꠁꠀ! ꠀꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠚꠣꠇ-ꠚꠥꠇꠞ ꠅꠔꠣ ꠖꠦꠈꠣꠔ ꠀꠁꠍ।” ");
INSERT INTO syls_vpl VALUES ("GN42_10","002_42_10","GEN","42","10","10","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤ ꠘꠣ ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠈꠣꠟꠤ ꠗꠣꠘ ꠟꠅꠀꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN42_11","002_42_11","GEN","42","11","11","ꠀꠝꠞꠣ ꠔ ꠢꠇꠟ ꠄꠇ ꠛꠣꠚꠞ ꠀꠅꠟꠣꠖ ꠀꠞ ꠍꠣꠁꠌ꠆ꠌꠣ ꠝꠣꠘꠥꠡ; ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟ ꠇꠥꠘꠥ ꠉꠥꠁꠀ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN42_12","002_42_12","GEN","42","12","12","ꠁꠃꠍꠥꠚꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠖꠦꠡꠞ ꠚꠣꠇ-ꠚꠥꠇꠞ ꠖꠦꠈꠣꠔ ꠀꠁꠍ।” ");
INSERT INTO syls_vpl VALUES ("GN42_13","002_42_13","GEN","42","13","13","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟ, ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠛꠣꠞꠅ ꠜꠣꠁ। ꠀꠝꠞꠣ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠄꠇ ꠛꠣꠚꠞ ꠀꠅꠟꠣꠖ। ꠀꠝꠞꠣꠞ ꠢꠥꠞꠥ ꠜꠣꠁ ꠅꠈꠘ ꠛꠣꠛꠣꠞ ꠉꠦꠍꠦ ꠞꠁꠍꠦ, ꠀꠞ ꠀꠞꠇ ꠜꠣꠁ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN42_14","002_42_14","GEN","42","14","14","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠀꠝꠤ ꠑꠤꠇꠃ ꠇꠁꠍꠤ, ꠔꠥꠝꠞꠣ ꠉꠥꠁꠀꠃ! ");
INSERT INTO syls_vpl VALUES ("GN42_15","002_42_15","GEN","42","15","15","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠅꠟꠣꠃ ꠅꠁꠎꠣꠃꠇ: ꠀꠝꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠎꠣꠘꠞ ꠇꠍꠝ ꠇꠞꠤ ꠇꠁꠀꠞ, ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥ ꠜꠣꠁ ꠅꠘꠅ ꠘꠣ ꠀꠁꠟꠦ, ꠔꠥꠝꠞꠣꠅ ꠁꠘ ꠕꠘꠦ ꠍꠣꠠꠣ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN42_16","002_42_16","GEN","42","16","16","ꠔꠥꠝꠞꠣꠞ ꠄꠇꠎꠘꠞꠦ ꠙꠣꠑꠣꠁꠀ, ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠜꠣꠁꠞꠦ ꠀꠘꠣꠅ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟꠦ ꠛꠘ꠆ꠖꠤ ꠞꠅ। ꠅꠃ ꠙꠞꠤꠇ꠆ꠇꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠔꠞ ꠢꠣꠍꠣ-ꠝꠤꠍꠣ ꠛꠥꠎꠝꠥ। ꠔꠣꠞꠦ ꠘꠣ ꠀꠘꠟꠦ, ꠀꠝꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠎꠣꠘꠞ ꠇꠍꠝ ꠇꠞꠤ ꠇꠁꠀꠞ, ꠔꠥꠝꠞꠣ ꠘꠤꠌꠄ ꠉꠥꠁꠀ!” ");
INSERT INTO syls_vpl VALUES ("GN42_17","002_42_17","GEN","42","17","17","ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠔꠤꠘ ꠖꠤꠘ ꠔꠣꠞꠣꠞꠦ ꠀꠎꠔ ꠈꠣꠘꠣꠔ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_18","002_42_18","GEN","42","18","18","ꠢꠦꠡꠦ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ, ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁ, ꠔꠥꠝꠞꠣ ꠛꠣꠌꠔꠦ ꠌꠣꠁꠟꠦ, ꠀꠝꠤ ꠎꠦꠟꠣ ꠇꠁ, ꠅꠃꠟꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("GN42_19","002_42_19","GEN","42","19","19","ꠔꠥꠝꠞꠣ ꠢꠣꠍꠣꠞꠞ ꠍꠣꠁꠌ꠆ꠌꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠦ, ꠔꠥꠝꠞꠣꠞ ꠄꠇ ꠜꠣꠁ ꠀꠎꠔꠅ ꠕꠣꠇꠃꠇ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠇꠣꠟꠤ ꠙꠞꠤꠛꠣꠞꠞ ꠟꠣꠉꠤ ꠗꠣꠘ ꠟꠁꠀ ꠎꠣꠅꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN42_20","002_42_20","GEN","42","20","20","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠔ ꠢꠣꠍꠣ ꠇꠤ ꠘꠣ ꠁꠐꠣ ꠛꠥꠎꠣꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥ ꠜꠣꠁꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠝꠞꠔꠣꠄ ꠘꠣꠄ।” ꠅꠃ ꠔꠣꠞꠣꠅ ꠞꠣꠎꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_21","002_42_21","GEN","42","21","21","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠟꠣ, “ꠢꠣꠍꠣꠃ ꠔ, ꠀꠝꠞꠣꠞ ꠢꠤ ꠜꠣꠁꠞ ꠟꠉꠦ ꠎꠦꠔꠣ ꠇꠞꠍꠤ ꠁꠔꠣ ꠅꠁꠘ꠆ꠘꠣꠄ। ꠢꠦ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠣꠎ-ꠝꠤꠘꠔꠤ ꠇꠞꠟꠦꠅ, ꠀꠝꠞꠣ ꠔꠣꠞ ꠝꠣꠔꠅ ꠇꠣꠘ ꠖꠤꠍꠤ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠁ ꠝꠍꠤꠛꠔ ꠀꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN42_22","002_42_22","GEN","42","22","22","ꠔꠦꠃ ꠞꠥꠛꠦꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠟꠣꠝ, ꠔꠣꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠎꠥꠟꠥꠝ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠢꠥꠘꠟꠣꠄ ꠘꠣ। ꠖꠦꠈꠅ, ꠅꠈꠘ ꠔꠣꠞ ꠟꠃꠞ ꠢꠤꠡꠣꠛ-ꠘꠤꠇꠣꠡ ꠖꠤꠔꠦ ꠅꠞ।” ");
INSERT INTO syls_vpl VALUES ("GN42_23","002_42_23","GEN","42","23","23","ꠅꠁꠟꠦ ꠁꠃꠍꠥꠚꠦ ꠎꠦꠘ ꠔꠣꠞꠣꠞ ꠝꠣꠔ ꠛꠥꠎꠞꠣ, ꠁꠔꠣ ꠔꠣꠞꠣ ꠎꠣꠘꠟ ꠘꠣ। ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠝꠣꠔ ꠛꠥꠎꠣꠅꠞꠣ ꠄꠇꠎꠘꠞꠦ ꠝꠣꠎꠦ ꠞꠣꠈꠤꠀ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_24","002_42_24","GEN","42","24","24","ꠔꠦꠃ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠢꠞꠤꠀ ꠉꠤꠀ ꠇꠣꠘ꠆ꠖꠤꠔꠣ ꠟꠣꠉꠟꠣ। ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠟꠣ ꠀꠞ ꠔꠣꠁꠘ ꠡꠤꠝꠤꠅꠘꠞꠦ ꠗꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦꠃ ꠛꠣꠘ꠆ꠖꠣꠁꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_25","002_42_25","GEN","42","25","25","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞ ꠛꠡ꠆ꠔꠣꠞ ꠝꠣꠎꠦ ꠗꠣꠘ ꠜꠞꠣꠁꠀ, ꠎꠣꠞꠎꠤꠞ ꠐꠦꠇꠣ ꠔꠣꠞ ꠛꠡ꠆ꠔꠣꠔ ꠚꠤꠞꠣꠁ ꠖꠤꠀ, ꠄꠞꠣꠞ ꠙꠕꠞ ꠈꠣꠘꠤꠞ ꠝꠍꠣ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ꠀꠞ ꠅꠃꠟꠣ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN42_26","002_42_26","GEN","42","26","26","ꠢꠦꠡꠦ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠉꠣꠗꠣꠞ ꠙꠤꠑꠤꠔ ꠗꠣꠘꠞ ꠉꠣꠁꠐ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_27","002_42_27","GEN","42","27","27","ꠙꠕꠅ ꠎꠤꠞꠣꠘꠤꠞ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠎꠦꠛꠟꠣ ꠄꠇꠎꠘꠦ ꠉꠣꠗꠣꠞꠦ ꠈꠣꠅꠀꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠡ꠆ꠔꠣ ꠈꠥꠟꠟ, ꠀꠞ ꠖꠦꠈꠟ, ꠛꠡ꠆ꠔꠣꠞ ꠝꠥꠈꠅ ꠔꠣꠞ ꠐꠦꠇꠣꠞ ꠈꠥꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("GN42_28","002_42_28","GEN","42","28","28","ꠅꠃ ꠢꠦ ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠇꠁꠟ, “ꠖꠦꠈꠅ, ꠖꠦꠈꠅ, ꠀꠝꠣꠞ ꠐꠦꠇꠣ ꠀꠝꠣꠞ ꠛꠡ꠆ꠔꠣꠔ ꠚꠤꠞꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠦ।” ꠖꠦꠈꠤꠀꠃ ꠔꠣꠞꠣꠞ ꠎꠣꠘ ꠃꠠꠤ ꠉꠦꠟ ꠀꠞ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠔꠦ ꠇꠣꠙꠔꠦ ꠇꠁꠟ, “ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("GN42_29","002_42_29","GEN","42","29","29","ꠛꠣꠖꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠛꠣꠚ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠀꠎꠤꠞ ꠅꠁꠀ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠢꠥꠘꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN42_30","002_42_30","GEN","42","30","30","“ꠢꠤ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠦ, ꠀꠝꠞꠣꠞꠦ ꠈꠥꠛ ꠇꠠꠣ ꠉꠟꠣꠄ ꠇꠁꠍꠂꠘ, ꠀꠝꠞꠣ ꠉꠥꠁꠀ ꠅꠁꠀ ꠢꠤ ꠖꠦꠡꠅ ꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN42_31","002_42_31","GEN","42","31","31","ꠀꠝꠞꠣ ꠇꠁꠍꠤ, ꠀꠝꠞꠣ ꠢꠇ ꠝꠣꠘꠥꠡ, ꠇꠥꠘꠥ ꠉꠥꠁꠀ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN42_32","002_42_32","GEN","42","32","32","ꠀꠝꠞꠣ ꠛꠣꠞꠅꠎꠘ ꠜꠣꠁ, ꠄꠇ ꠛꠣꠚꠞ ꠛꠣꠞꠅ ꠙꠥꠀ, ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠄꠇꠎꠘ ꠘꠣꠄ ꠀꠞ ꠢꠇꠟ ꠕꠘꠦ ꠢꠥꠞꠥ ꠜꠣꠁ ꠅꠈꠘ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠛꠣꠛꠣꠞ ꠉꠦꠍꠦ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN42_33","002_42_33","GEN","42","33","33","ꠅꠃ ꠢꠤ ꠝꠣꠘꠡꠦ, ꠎꠦꠁꠘ ꠢꠤ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇ, ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠇꠁꠟꠣ, ‘ꠀꠝꠤ ꠅꠃꠟꠣ ꠛꠥꠎꠝꠥ ꠎꠦꠘ, ꠔꠥꠝꠞꠣ ꠢꠇ ꠝꠣꠘꠥꠡ। ꠔꠥꠝꠞꠣꠞ ꠄꠇ ꠜꠣꠁꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠕꠁꠀ, ꠔꠥꠝꠞꠣꠞ ꠀꠇꠣꠟꠤ ꠙꠞꠤꠛꠣꠞꠞ ꠟꠣꠉꠤ ꠗꠣꠘ ꠟꠁꠀ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("GN42_34","002_42_34","GEN","42","34","34","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥ ꠜꠣꠁꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠅ। ꠔꠦꠃ ꠀꠝꠤ ꠛꠥꠎꠝꠥ, ꠔꠥꠝꠞꠣ ꠢꠇ ꠝꠣꠘꠥꠡ, ꠇꠥꠘꠥ ꠉꠥꠁꠀ ꠘꠣꠄ। ꠛꠣꠖꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠞꠦ ꠚꠤꠞꠣꠁ ꠖꠤꠝꠥ ꠀꠞ ꠔꠥꠝꠞꠣ ꠁ ꠖꠦꠡꠅ ꠇꠣꠄ-ꠇꠣꠞꠛꠣꠞ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ।’ ” ");
INSERT INTO syls_vpl VALUES ("GN42_35","002_42_35","GEN","42","35","35","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠛꠡ꠆ꠔꠣ ꠕꠘꠦ ꠗꠣꠘ ꠓꠣꠟꠔꠦꠃ ꠖꠦꠈꠂꠘ, ꠔꠣꠞꠣꠞ ꠢꠇꠟꠞ ꠐꠦꠇꠣꠞ ꠈꠥꠔꠤ ꠛꠡ꠆ꠔꠣꠞ ꠝꠣꠎꠦ ꠞꠁꠍꠦ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠦ ꠀꠞ ꠔꠣꠞꠣꠅ ꠒꠞꠣꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN42_36","002_42_36","GEN","42","36","36","ꠔꠦꠃ ꠛꠣꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠀꠅꠟꠣꠖ ꠍꠣꠠꠣ ꠛꠣꠘꠣꠁꠍ। ꠁꠃꠍꠥꠚ ꠘꠣꠄ, ꠡꠤꠝꠤꠅꠘꠅ ꠘꠣꠄ ꠀꠞ ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦꠅ ꠘꠤꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ। ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠣꠞ ꠎꠥꠟꠥꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN42_37","002_42_37","GEN","42","37","37","ꠞꠥꠛꠦꠘꠦ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠔꠦ ꠘꠣ ꠙꠣꠞꠟꠦ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠟꠤꠅ। ꠔꠣꠞꠦ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠀꠔꠅ ꠍꠣꠠꠤ ꠖꠦꠅ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN42_38","002_42_38","GEN","42","38","38","ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠀꠝꠣꠞ ꠁ ꠙꠥꠀ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ꠔꠣꠞ ꠜꠣꠁ ꠝꠞꠤꠉꠦꠍꠦ, ꠀꠞ ꠅꠈꠘ ꠢꠦ ꠄꠇꠟꠣ ꠎꠤꠔꠣ ꠀꠍꠦ। ꠔꠥꠝꠞꠣꠞ ꠎꠣꠅꠀꠞ ꠙꠕꠅ ꠎꠥꠖꠤ ꠔꠣꠞ ꠇꠥꠘꠥ ꠛꠤꠙꠖ ꠅꠄ, ꠔꠦ ꠅꠃ ꠙꠣꠇꠘꠣ ꠌꠥꠟꠦ ꠛꠃꠔ ꠖꠥꠈ ꠖꠤꠀ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠇꠄꠛꠞꠅ ꠢꠣꠞꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN43_1","002_43_1","GEN","43","1","1","ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠀꠇꠣꠟꠞ ꠖꠡꠣ ꠀꠞꠅ ꠛꠦꠢꠣꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN43_2","002_43_2","GEN","43","2","2","ꠀꠞ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠘꠦ ꠎꠦꠔꠣ ꠗꠣꠘ ꠘꠤꠍꠟꠣ, ꠁꠔꠣ ꠚꠥꠠꠣꠁ ꠉꠦꠟꠦ ꠁꠍꠞꠣꠁꠟꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠉꠤꠀ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠇꠤꠍꠥ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠟꠁꠀ ꠀꠘꠅꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN43_3","002_43_3","GEN","43","3","3","ꠔꠦꠃ ꠄꠢꠥꠖꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟ, “ꠢꠃ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞꠦ ꠈꠥꠛ ꠇꠠꠣ ꠜꠣꠡꠣꠄ ꠇꠁꠀ ꠖꠤꠍꠂꠘ, ‘ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠘꠣ ꠀꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠅ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("GN43_4","002_43_4","GEN","43","4","4","ꠅꠈꠘ ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞ ꠜꠣꠁꠞꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠇꠞꠤ ꠖꠦꠅ, ꠔꠦꠃ ꠀꠝꠞꠣ ꠉꠤꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠤ ꠟꠁꠀ ꠀꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN43_5","002_43_5","GEN","43","5","5","ꠀꠞ ꠔꠣꠞꠦ ꠟꠉꠦ ꠘꠣ ꠖꠤꠟꠦ ꠀꠝꠞꠣꠅ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠢꠤ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞꠦ ꠇꠁꠀ ꠖꠤꠍꠂꠘ, ‘ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠞꠦ ꠟꠉꠦ ꠘꠣ ꠀꠘꠟꠦ, ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠅ ꠘꠣ।’ ” ");
INSERT INTO syls_vpl VALUES ("GN43_6","002_43_6","GEN","43","6","6","ꠁꠍꠞꠣꠁꠟꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠃꠟꠣ ꠚꠣꠔꠞꠣꠝꠤ ꠇꠞꠟꠣꠄ? ꠔꠥꠝꠞꠣꠞ ꠀꠞꠇ ꠜꠣꠁ ꠀꠍꠦ, ꠁꠔꠣ ꠔꠣꠘꠞꠦ ꠇꠦꠘꠦ ꠇꠁꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("GN43_7","002_43_7","GEN","43","7","7","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠢꠤ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞ ꠀꠞ ꠀꠝꠞꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠀꠉꠣ-ꠉꠥꠠꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠤꠇꠣꠁꠍꠂꠘ, ‘ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ ꠇꠤꠔꠣ ꠅꠈꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ ꠘꠤ? ꠔꠥꠝꠞꠣꠞ ꠀꠞ ꠇꠥꠘꠥ ꠜꠣꠁ ꠀꠍꠂꠘ ꠘꠤ?’ ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠔꠣꠘ ꠍꠅꠀꠟꠞ ꠎꠥꠀꠙ ꠖꠤꠍꠟꠣꠝ, ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠎꠣꠘꠔꠣꠝ ꠘꠤ, ꠔꠣꠁꠘ ꠇꠁꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠞꠦꠅ ꠟꠁꠀ ꠀꠁꠅ?” ");
INSERT INTO syls_vpl VALUES ("GN43_8","002_43_8","GEN","43","8","8","ꠄꠢꠥꠖꠣꠄ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣ, “ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠇꠞꠤ ꠖꠤꠟꠣꠅ, ꠀꠝꠞꠣ ꠎꠟꠖꠤ ꠎꠟꠖꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠎꠣꠁ, ꠔꠦꠃ ꠔꠥꠝꠤ, ꠀꠝꠞꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠢꠇ꠆ꠇꠟꠃ ꠎꠣꠘꠦ ꠛꠣꠌꠝꠥ, ꠇꠦꠃ ꠝꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN43_9","002_43_9","GEN","43","9","9","ꠀꠝꠤ ꠘꠤꠎꠦꠃ ꠔꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠝꠤꠘ ꠞꠁꠟꠣꠝ, ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠡꠝꠎꠤꠀ ꠘꠤꠅ। ꠀꠝꠤ ꠔꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠣꠁꠀ ꠘꠣ ꠀꠘꠟꠦ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠎꠤꠞ ꠘꠣ ꠇꠞꠟꠦ, ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠜꠞꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠖꠣꠄꠁ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN43_10","002_43_10","GEN","43","10","10","ꠀꠞ ꠅꠔ ꠖꠦꠞꠤ ꠘꠣ ꠇꠞꠟꠦ, ꠀꠝꠞꠣ ꠅꠔꠖꠤꠘꠦ ꠖꠥꠁꠛꠣꠞ ꠊꠥꠞꠤꠀ ꠀꠁꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("GN43_11","002_43_11","GEN","43","11","11","ꠅꠃ ꠔꠣꠞꠣꠞ ꠛꠣꠚ ꠁꠍꠞꠣꠁꠟꠦ ꠇꠁꠟꠣ, “ꠅꠃꠟꠣ ꠅꠁꠟꠦ ꠄꠇ ꠇꠣꠝ ꠇꠞꠅ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠦꠉꠞ ꠝꠣꠎꠦ ꠅꠘꠞ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠝꠣꠟ, ꠀꠉꠞ, ꠝꠃ, ꠈꠥꠡꠛꠄ ꠝꠡꠟꠣ, ꠝꠦꠡꠇꠦ-ꠀꠝ꠆ꠛꠞ, ꠙꠦꠡ꠆ꠔꠣ ꠀꠞ ꠛꠣꠖꠣꠝ ꠜꠞꠤꠀ ꠢꠃ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠍꠣꠟꠣꠝꠤ ꠟꠁꠀ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("GN43_12","002_43_12","GEN","43","12","12","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠇꠞꠤ ꠀꠉꠞ ꠒꠣꠛꠥꠟ ꠐꠦꠇꠣ ꠘꠦꠅ, ꠛꠡ꠆ꠔꠣꠞ ꠝꠥꠈꠅ ꠎꠦ ꠐꠦꠇꠣ ꠚꠤꠞꠔ ꠀꠁꠍꠦ, ꠔꠣ-ꠅ ꠢꠤꠞꠛꠣꠞ ꠟꠁꠀ ꠎꠣꠅ, ꠇꠤ ꠎꠣꠘꠤ ꠇꠥꠘꠥ ꠜꠥꠟ ꠅꠁꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN43_13","002_43_13","GEN","43","13","13","ꠔꠥꠝꠞꠣꠞ ꠁ ꠜꠣꠁꠞꠦ ꠟꠉꠦ ꠟꠁꠀ, ꠎꠟꠖꠤ ꠇꠞꠤ ꠢꠃ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("GN43_14","002_43_14","GEN","43","14","14","ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠃ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠅ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠙꠄꠖꠣ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠜꠣꠁ ꠀꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠚꠤꠞꠔ ꠖꠦꠁꠘ। ꠀꠞ ꠀꠝꠣꠞ ꠙꠥꠀ ꠈꠥꠀꠘꠤ ꠉꠦꠟꠦ, ꠘꠣ ꠅꠄ ꠉꠦꠟꠃ।” ");
INSERT INTO syls_vpl VALUES ("GN43_15","002_43_15","GEN","43","15","15","ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠃ ꠍꠣꠟꠣꠝꠤ, ꠒꠣꠛꠥꠟ ꠐꠦꠇꠣ ꠀꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠟꠁꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠀ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠙꠃꠍꠤꠀ ꠁꠃꠍꠥꠚꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN43_16","002_43_16","GEN","43","16","16","ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠈꠣꠖꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞꠦ ꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠘꠦꠅ ꠀꠞ ꠈꠡꠤ ꠎꠛ ꠇꠞꠤꠀ ꠉꠥꠡ꠆ꠔ ꠞꠣꠘ꠆ꠖꠅ। ꠔꠣꠞꠣ ꠝꠣꠗꠣꠘꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠈꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN43_17","002_43_17","GEN","43","17","17","ꠁꠃꠍꠥꠚꠦ ꠎꠦꠟꠣ ꠇꠁꠟꠣ, ꠈꠣꠖꠤꠝꠦꠅ ꠑꠤꠇ ꠅꠃꠟꠣ ꠇꠞꠟ, ꠢꠦ ꠄꠞꠣꠞꠦ ꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠟꠁꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN43_18","002_43_18","GEN","43","18","18","ꠀꠞ ꠢꠦ ꠄꠞꠣꠞꠦ ꠁꠃꠍꠥꠚꠞ ꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠘꠦꠅꠀꠄ, ꠔꠣꠞꠣ ꠒꠞꠣꠁꠀ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠟꠣ, “ꠀꠉꠞ ꠚꠤꠞꠣ ꠎꠦ ꠐꠦꠇꠣ ꠀꠝꠞꠣꠞ ꠛꠡ꠆ꠔꠣꠔ ꠇꠞꠤ ꠚꠤꠞꠔ ꠉꠦꠍꠤꠟ, ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠞꠣꠞꠦ ꠅꠘꠅ ꠘꠤꠞꠣ, ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠖꠥꠡ ꠖꠦꠈꠣꠁꠀ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠁꠛꠣ, ꠀꠞ ꠉꠣꠗꠣ ꠅꠇꠟꠅ ꠇꠣꠠꠤꠀ ꠘꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN43_19","002_43_19","GEN","43","19","19","ꠔꠦꠃ ꠁꠃꠍꠥꠚꠞ ꠛꠣꠠꠤꠞ ꠖꠞꠎꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠔꠣꠞꠣ ꠛꠣꠠꠤꠞ ꠈꠣꠖꠤꠝꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN43_20","002_43_20","GEN","43","20","20","“ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠄꠞ ꠀꠉꠦꠅ ꠗꠣꠘ ꠟꠅꠀꠔ ꠀꠁꠍꠟꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("GN43_21","002_43_21","GEN","43","21","21","ꠢꠦꠡꠦ ꠚꠤꠞꠔ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ, ꠖꠝ ꠟꠁꠛꠣꠞ ꠎꠣꠉꠣꠔ ꠙꠃꠍꠤꠀ, ꠛꠡ꠆ꠔꠣ ꠈꠥꠟꠔꠦꠃ ꠖꠦꠈꠤ, ꠀꠝꠞꠣꠞ ꠙꠥꠞꠣ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠡ꠆ꠔꠣꠞ ꠝꠥꠈꠅ ꠞꠁꠍꠦ, ꠅꠈꠘ ꠅꠃ ꠐꠦꠇꠣ ꠚꠤꠞꠔ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN43_22","002_43_22","GEN","43","22","22","ꠀꠞ ꠗꠣꠘ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠐꠦꠇꠣ ꠀꠘꠍꠤ, ꠅꠁꠟꠦ ꠢꠤ ꠐꠦꠇꠣ ꠀꠝꠞꠣꠞ ꠛꠡ꠆ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠇꠦ ꠕꠁꠍꠤꠟ ꠎꠣꠘꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN43_23","002_43_23","GEN","43","23","23","ꠅꠃ ꠈꠣꠖꠤꠝꠦ ꠇꠁꠟ, “ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠃꠇ, ꠒꠞꠣꠁꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚꠞ ꠀꠟ꠆ꠟꠣꠄ, ꠁ ꠉꠣꠁꠛꠤ ꠗꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠡ꠆ꠔꠣꠞ ꠝꠣꠎꠦ ꠖꠤꠍꠂꠘ। ꠔꠥꠝꠞꠣꠞ ꠐꠦꠇꠣ ꠀꠝꠤ ꠙꠣꠁꠍꠤ।” ꠛꠣꠖꠦ ꠢꠦ ꠡꠤꠝꠤꠅꠘꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN43_24","002_43_24","GEN","43","24","24","ꠢꠦ ꠢꠇꠟꠞꠦ ꠁꠃꠍꠥꠚꠞ ꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠘꠤꠀ ꠙꠣꠘꠤ ꠖꠤꠟ ꠔꠣꠞꠣ ꠙꠣꠅ ꠗꠥꠁꠟꠣ ꠀꠞ ꠢꠦ ꠔꠣꠞꠣꠞ ꠉꠣꠗꠣ ꠅꠇꠟꠞꠦꠅ ꠈꠣꠘꠤ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN43_25","002_43_25","GEN","43","25","25","ꠁꠃꠍꠥꠚ ꠝꠣꠗꠣꠘꠦ ꠀꠁꠛꠣ ꠉꠔꠤꠇꠦ, ꠄꠞꠣ ꠔꠣꠞꠣꠞ ꠍꠣꠟꠣꠝꠤ ꠅꠇꠟ ꠎꠥꠁꠔ ꠇꠞꠟꠣ। ꠔꠣꠞꠣ ꠢꠥꠘꠍꠟꠣ ꠎꠦꠘ, ꠔꠣꠘ ꠟꠉꠦꠃ ꠔꠣꠞꠣꠞ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN43_26","002_43_26","GEN","43","26","26","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚ ꠛꠣꠠꠤꠔ ꠀꠁꠟꠦ, ꠔꠣꠞꠣꠞ ꠢꠃ ꠍꠣꠟꠣꠝꠤ ꠅꠇꠟ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠘꠤꠀ ꠔꠣꠘꠞꠦ ꠖꠤꠟꠣ, ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN43_27","002_43_27","GEN","43","27","27","ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠎꠦ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠣꠚꠞ ꠇꠕꠣ ꠇꠁꠍꠟꠣꠄ, ꠔꠣꠁꠘ ꠜꠣꠟꠣ ꠀꠍꠂꠘ ꠘꠤ? ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN43_28","002_43_28","GEN","43","28","28","ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠎꠤꠅꠄ, ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠀꠝꠞꠣꠞ ꠛꠣꠛꠣ ꠅꠈꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ ꠀꠞ ꠜꠣꠟꠣ ꠀꠍꠂꠘ।” ꠢꠦꠡꠦ ꠔꠣꠞꠣ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN43_29","002_43_29","GEN","43","29","29","ꠁꠃꠍꠥꠚꠦ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠜꠣꠁ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠅꠃꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠢꠥꠞꠥ ꠜꠣꠁ, ꠎꠣꠞ ꠇꠕꠣ ꠀꠉꠦ ꠇꠁꠍꠟꠣꠄ?” ꠔꠣꠁꠘ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN43_30","002_43_30","GEN","43","30","30","ꠜꠣꠁꠞꠦ ꠖꠦꠈꠤꠀ ꠁꠃꠍꠥꠚꠞ ꠖꠤꠟ ꠇꠣꠘ꠆ꠖꠤꠔ ꠟꠣꠉꠟ। ꠔꠣꠁꠘ ꠎꠟꠖꠤ ꠇꠞꠤ ꠛꠣꠞ ꠅꠁꠀ, ꠘꠤꠎꠞ ꠇꠥꠑꠣꠔ ꠉꠤꠀ ꠇꠣꠘ꠆ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN43_31","002_43_31","GEN","43","31","31","ꠛꠣꠖꠦ ꠌꠃꠈ-ꠝꠥꠈ ꠗꠁꠀ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ ꠀꠞ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠈꠣꠘꠤ ꠛꠤꠟꠣꠁꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN43_32","002_43_32","GEN","43","32","32","ꠅꠃ ꠁꠃꠍꠥꠚꠞꠦ, ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠀꠞ ꠔꠣꠘ ꠟꠉꠦ ꠈꠣꠘꠦꠀꠟꠣ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞꠦ ꠀꠟꠉ ꠀꠟꠉ ꠎꠣꠉꠣꠔ ꠈꠣꠘꠤ ꠖꠤꠟꠣ। ꠇꠣꠞꠘ ꠝꠤꠡꠞꠤꠘ꠆ꠔꠦ ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠛꠁꠀ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠇꠞꠔ ꠘꠣ, ꠁꠔꠣ ꠔꠣꠞꠣ ꠊꠤꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN43_33","002_43_33","GEN","43","33","33","ꠔꠣꠞꠣ ꠁꠃꠍꠥꠚꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠛꠠꠞꠦ ꠛꠠꠞ ꠎꠣꠉꠣꠔ, ꠢꠥꠞꠥꠞꠦ ꠢꠥꠞꠥꠞ ꠎꠣꠉꠣꠔ ꠛꠅꠀꠁꠟꠣ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞ ꠛꠣꠄ ꠌꠣꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN43_34","002_43_34","GEN","43","34","34","ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠘꠤꠎꠞ ꠕꠣꠟꠞ ꠈꠣꠘꠤ ꠕꠘꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠖꠦꠅꠀꠁꠟꠣ, ꠅꠁꠟꠦ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠢꠇꠟ ꠕꠘꠦ ꠙꠣꠌ ꠉꠥꠘ ꠛꠦꠡꠤ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠈꠥꠡꠤ ꠅꠁꠀ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN44_1","002_44_1","GEN","44","1","1","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠈꠣꠖꠤꠝꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠁ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞ ꠛꠡ꠆ꠔꠣꠔ ꠎꠔ ꠗꠣꠘ ꠎꠣꠉꠣ ꠅꠄ, ꠜꠞꠤꠀ ꠖꠤꠟꠣꠅ ꠀꠞ ꠎꠣꠞꠎꠤꠞ ꠐꠦꠇꠣ ꠔꠣꠞ ꠛꠡ꠆ꠔꠣꠞ ꠝꠥꠈꠅ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("GN44_2","002_44_2","GEN","44","2","2","ꠅꠁꠟꠦ ꠅꠃ ꠢꠥꠞꠥ ꠎꠘꠞ ꠛꠡ꠆ꠔꠣꠞ ꠝꠥꠈꠅ ꠔꠣꠞ ꠐꠦꠇꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠞꠥꠙꠣꠞ ꠛꠣꠐꠤꠅ ꠕꠁꠅ।” ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠁꠟꠣ, ꠢꠦ ꠅꠃꠟꠣ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("GN44_3","002_44_3","GEN","44","3","3","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦꠃ ꠔꠣꠞꠣ ꠉꠣꠗꠣ ꠟꠁꠀ ꠛꠤꠖꠣꠄ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN44_4","002_44_4","GEN","44","4","4","ꠔꠣꠞꠣ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠖꠥꠞꠁ ꠎꠣꠁꠔꠦꠃ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠈꠣꠖꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠎꠟꠖꠤ ꠇꠞꠤ ꠄꠞꠣꠞ ꠈꠞꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ, ꠄꠞꠣꠞ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠇꠁꠛꠣꠄ, ꠔꠥꠝꠞꠣ ꠃꠙꠇꠣꠞꠞ ꠛꠖꠟꠣ ꠇꠦꠘꠦ ꠈꠦꠔꠤ ꠇꠞꠟꠣꠄ? ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠞꠥꠙꠣꠞ ꠛꠣꠐꠤ ꠇꠦꠘꠦ ꠌꠥꠞꠤ ꠇꠞꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("GN44_5","002_44_5","GEN","44","5","5","ꠅꠃ ꠛꠣꠐꠤꠔ ꠇꠞꠤꠀ ꠔ ꠔꠣꠁꠘ ꠡꠞꠛꠔ-ꠙꠣꠘꠤ ꠈꠣꠁꠘ ꠀꠞ ꠔꠖꠛꠤꠞꠞ ꠇꠣꠝꠅ ꠇꠞꠂꠘ। ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠈꠥꠛ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠍ।” ");
INSERT INTO syls_vpl VALUES ("GN44_6","002_44_6","GEN","44","6","6","ꠢꠤ ꠈꠣꠖꠤꠝꠦ ꠔꠣꠞꠣꠞ ꠈꠞꠦꠖꠤ ꠉꠤꠀ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠀ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN44_7","002_44_7","GEN","44","7","7","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ ꠁꠟꠣ ꠝꠣꠔ ꠇꠦꠘꠦ ꠝꠣꠔꠤꠞꠣ? ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘꠃ ꠁꠔꠣ ꠇꠣꠝ ꠇꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN44_8","002_44_8","GEN","44","8","8","ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠉꠞꠛꠣꠞ ꠀꠝꠞꠣꠞ ꠛꠡ꠆ꠔꠣꠞ ꠝꠥꠈꠅ ꠎꠦ ꠐꠦꠇꠣ ꠙꠣꠁꠍꠟꠣꠝ, ꠁꠔꠣ ꠀꠝꠞꠣ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠕꠘꠦ ꠢꠤꠞꠛꠣꠞ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠔ ꠀꠘꠍꠤ, ꠔꠦ ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠀꠙꠘꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠛꠣꠠꠤ ꠕꠘꠦ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠌꠥꠞꠤ ꠇꠞꠝꠥ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GN44_9","002_44_9","GEN","44","9","9","ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠎꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠛꠣꠐꠤ ꠙꠣꠁꠛꠣ, ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠣꠁꠛꠣ ꠀꠞ ꠀꠝꠞꠣꠅ ꠢꠥꠎꠥꠞꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠎꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN44_10","002_44_10","GEN","44","10","10","ꠔꠦꠃ ꠈꠣꠖꠤꠝꠦ ꠇꠁꠟ, “ꠜꠣꠟꠣ ꠇꠕꠣ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠇꠁꠟꠣꠄ, ꠅꠃꠟꠣꠃ ꠅꠃꠇ। ꠎꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠛꠣꠐꠤ ꠝꠤꠟꠛ, ꠈꠣꠟꠤ ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠁꠝꠥ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN44_11","002_44_11","GEN","44","11","11","ꠅꠃ ꠔꠣꠞꠣ ꠎꠟꠖꠤ ꠇꠞꠤ ꠢꠇꠟꠞ ꠛꠡ꠆ꠔꠣ ꠝꠣꠐꠤꠔ ꠟꠣꠝꠣꠁꠀ ꠈꠥꠟꠟ। ");
INSERT INTO syls_vpl VALUES ("GN44_12","002_44_12","GEN","44","12","12","ꠀꠞ ꠈꠣꠖꠤꠝꠦ ꠛꠠ ꠜꠣꠁ ꠕꠘꠦ ꠢꠥꠞꠥ ꠜꠣꠁ ꠔꠞꠤ ꠢꠇꠟꠞ ꠛꠡ꠆ꠔꠣ ꠔꠥꠇꠣꠁꠟꠦꠅ ꠢꠦꠡꠦ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞ ꠛꠡ꠆ꠔꠣꠔ ꠢꠤ ꠛꠣꠐꠤ ꠝꠤꠟꠟ। ");
INSERT INTO syls_vpl VALUES ("GN44_13","002_44_13","GEN","44","13","13","ꠔꠦꠃ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠚꠣꠠꠤꠟ꠆ꠟꠣ, ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠉꠣꠗꠣꠞ ꠙꠤꠑꠤꠔ ꠉꠣꠁꠐ ꠛꠣꠘ꠆ꠖꠤꠀ ꠐꠣꠃꠘꠅ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN44_14","002_44_14","GEN","44","14","14","ꠔꠦꠃ ꠄꠢꠥꠖꠣ ꠀꠞ ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘ ꠁꠃꠍꠥꠚꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ, ꠁ ꠡꠝꠄ ꠔꠣꠁꠘ ꠢꠘꠅ ꠀꠍꠟꠣ। ꠔꠣꠞꠣ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠉꠤꠀ ꠝꠣꠐꠤꠔ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN44_15","002_44_15","GEN","44","15","15","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠟꠣꠄ? ꠀꠝꠤ ꠎꠦꠘ ꠢꠇꠟꠔꠣ ꠉꠘꠔꠣꠝ ꠙꠣꠞꠤ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN44_16","002_44_16","GEN","44","16","16","ꠄꠢꠥꠖꠣꠄ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠁꠝꠥ? ꠇꠤꠔꠣ ꠎꠥꠀꠙ ꠖꠤꠝꠥ? ꠀꠞ ꠇꠤꠟꠣ ꠀꠝꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠔꠣꠝ? ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠖꠥꠡ ꠖꠦꠈꠣꠁ ꠖꠤꠍꠂꠘ, ꠔꠦ ꠎꠣꠞ ꠉꠦꠍꠦ ꠁ ꠛꠣꠐꠤ ꠝꠤꠟꠍꠦ, ꠢꠦ ꠀꠞ ꠀꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠢꠥꠎꠥꠞꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN44_17","002_44_17","GEN","44","17","17","ꠅꠁꠟꠦ ꠁꠃꠍꠥꠚꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠀꠝꠤ ꠁ ꠇꠣꠝ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘꠃ ꠇꠞꠔꠣꠝ ꠘꠣꠄ। ꠎꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠛꠣꠐꠤ ꠝꠤꠟꠍꠦ, ꠢꠦ-ꠃ ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠛ, ꠛꠣꠇꠤ ꠡꠛ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN44_18","002_44_18","GEN","44","18","18","ꠔꠦꠃ ꠄꠢꠥꠖꠣꠄ ꠁꠃꠍꠥꠚꠞ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ ꠀꠙꠘꠦ ꠔ ꠚꠦꠞꠣꠃꠘꠞ ꠢꠝꠣꠘ, ꠔꠦ ꠖꠄꠀ ꠇꠞꠤ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠄꠇꠈꠣꠘ ꠝꠣꠔ ꠝꠣꠔꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣ ꠅꠁꠘ ꠘꠣ ꠎꠦꠘ। ");
INSERT INTO syls_vpl VALUES ("GN44_19","002_44_19","GEN","44","19","19","ꠢꠥꠎꠥꠞꠦ ꠀꠉꠦ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠍꠟꠣ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ ꠛꠣ ꠇꠥꠘꠥ ꠜꠣꠁ ꠀꠍꠂꠘ ꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("GN44_20","002_44_20","GEN","44","20","20","ꠀꠝꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠍꠟꠣꠝ, ꠀꠝꠞꠣꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠣꠛꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ, ꠀꠞ ꠔꠣꠘ ꠢꠦꠡꠇꠣꠟꠤ ꠛꠄꠅꠡꠞ ꠄꠉꠥ ꠙꠥꠀ ꠀꠍꠦ। ꠔꠣꠞ ꠜꠣꠁ ꠝꠞꠤꠉꠦꠍꠦ, ꠀꠞ ꠢꠦ ꠄꠇ ꠝꠣʼꠞ ꠄꠇ ꠙꠥꠔ ꠉꠔꠤꠇꠦ ꠛꠣꠛꠣꠄ ꠔꠣꠞꠦ ꠈꠥꠛ ꠝꠣꠄꠀ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN44_21","002_44_21","GEN","44","21","21","ꠛꠣꠖꠦ ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠇꠁꠍꠟꠣ, ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠅ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN44_22","002_44_22","GEN","44","22","22","ꠢꠤ ꠡꠝꠄ ꠀꠝꠞꠣ ꠢꠥꠎꠥꠞꠞꠦ ꠇꠁꠍꠟꠣꠝ, ꠛꠣꠛꠣꠞꠦ ꠕꠁꠀ ꠢꠦ ꠀꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ ꠀꠞ ꠕꠁꠀ ꠀꠁꠟꠦꠅ ꠛꠣꠛꠣ ꠝꠣꠞꠣ ꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN44_23","002_44_23","GEN","44","23","23","ꠅꠁꠟꠦ ꠀꠙꠘꠦ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠇꠁꠍꠟꠣ, ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥ ꠜꠣꠁꠞꠦ ꠟꠉꠦ ꠘꠣ ꠀꠘꠟꠦ, ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN44_24","002_44_24","GEN","44","24","24","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠚꠤꠞꠤꠀ ꠉꠤꠀ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ, ꠀꠝꠞꠣꠞ ꠛꠣꠛꠣꠞꠦ ꠢꠥꠎꠥꠞꠞ ꠢꠇꠟ ꠇꠕꠣ ꠢꠥꠘꠣꠁꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN44_25","002_44_25","GEN","44","25","25","ꠛꠣꠖꠦ ꠛꠣꠛꠣꠄ ꠇꠁꠟꠣ, ꠔꠥꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠉꠤꠀ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠕꠥꠠꠣ ꠗꠣꠘ ꠟꠁꠀ ꠀꠘꠅꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN44_26","002_44_26","GEN","44","26","26","ꠔꠦꠃ ꠀꠝꠞꠣ ꠇꠁꠟꠣꠝ, ꠀꠝꠞꠣꠞ ꠢꠥꠞꠥ ꠜꠣꠁꠞꠦ ꠟꠉꠦ ꠖꠤꠟꠦ ꠀꠝꠞꠣ ꠎꠣꠁꠝꠥ, ꠀꠞꠘꠣꠄ ꠀꠝꠞꠣ ꠉꠤꠀ ꠢꠤ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠝꠥꠈ ꠖꠦꠈꠣꠁꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN44_27","002_44_27","GEN","44","27","27","ꠅꠃ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ, ꠀꠝꠞꠣꠞ ꠛꠣꠛꠣꠄ ꠇꠁꠟꠣ, ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠀꠝꠣꠞ ꠁ ꠛꠤꠛꠤꠞ ꠔꠞꠚꠣ ꠖꠥꠉꠥ ꠙꠥꠀ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GN44_28","002_44_28","GEN","44","28","28","ꠄꠞꠣꠞ ꠄꠇꠎꠘ ꠀꠝꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠉꠦꠟ, ꠀꠞ ꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠔꠣꠞꠦ ꠖꠦꠈꠟꠣꠝ ꠘꠣ, ꠀꠝꠤ ꠛꠥꠎꠟꠣꠝ ꠎꠦꠘ, ꠘꠤꠌꠄ ꠇꠥꠘꠥ ꠎꠣꠘꠥꠀꠞꠦ ꠔꠣꠞꠦ ꠍꠤꠠꠤ-ꠛꠤꠠꠤꠟꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GN44_29","002_44_29","GEN","44","29","29","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠄꠞꠦꠅ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠘꠤꠟꠦꠉꠤ ꠀꠞ ꠄꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠅꠁꠟꠦ, ꠔꠣꠞ ꠖꠥꠈꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠅꠃ ꠙꠣꠇꠘꠣ ꠌꠥꠟꠦ ꠇꠄꠛꠞꠅ ꠢꠣꠞꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN44_30","002_44_30","GEN","44","30","30","ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘ ꠎꠥꠖꠤ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ, ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠎꠣꠁ ꠀꠞ ꠔꠣꠘ ꠁ ꠙꠥꠀꠞꠦ ꠟꠉꠦ ꠘꠣ ꠖꠦꠈꠂꠘ, ꠔꠦ ꠄꠞ ꠎꠣꠘꠞ ꠟꠉꠦ ꠔꠣꠘ ꠎꠣꠘ ꠄꠇꠈꠣꠘꠅ ꠛꠣꠘ꠆ꠖꠣ ꠉꠔꠤꠇꠦ, ");
INSERT INTO syls_vpl VALUES ("GN44_31","002_44_31","GEN","44","31","31","ꠔꠣꠞꠦ ꠘꠣ ꠖꠦꠈꠟꠦ, ꠔꠣꠁꠘ ꠘꠤꠌꠄ ꠝꠣꠞꠣ ꠎꠣꠁꠛꠣ। ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ, ꠀꠝꠞꠣꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠣꠚ ꠛꠃꠔ ꠖꠥꠈꠦ ꠙꠣꠇꠘꠣ ꠌꠥꠟ ꠟꠁꠀ ꠇꠄꠛꠞꠅ ꠢꠣꠝꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN44_32","002_44_32","GEN","44","32","32","ꠀꠞ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠀꠝꠤ, ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠝꠤꠘ ꠅꠁꠀ ꠇꠁꠍꠤ ꠎꠦꠘ, ꠔꠣꠞꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠔꠦ ꠘꠣ ꠙꠣꠞꠟꠦ, ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠜꠞꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠖꠣꠛꠤꠔ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN44_33","002_44_33","GEN","44","33","33","ꠔꠦ ꠢꠥꠎꠥꠞ ꠀꠝꠤ ꠝꠤꠘꠔꠤ ꠇꠞꠤꠀꠞ, ꠔꠣꠞ ꠛꠖꠟꠣ ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠝꠥ ꠀꠞ ꠔꠣꠞꠦ ꠀꠙꠘꠦ ꠄꠞꠣꠞ ꠟꠉꠦ ꠎꠣꠁꠛꠣꠞ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN44_34","002_44_34","GEN","44","34","34","ꠄꠞꠦ ꠟꠉꠦ ꠘꠣ ꠘꠤꠀ ꠀꠝꠤ ꠇꠤꠟꠣ ꠛꠣꠛꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠝꠥ? ꠘꠣꠁꠟꠦ ꠛꠣꠛꠣꠞ ꠎꠣꠘꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠘ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN45_1","002_45_1","GEN","45","1","1","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠇꠞ꠆ꠝꠌꠣꠞꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠎꠞꠦ ꠀꠞ ꠑꠤꠇ ꠞꠣꠈꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠔꠣꠁꠘ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠢꠇ꠆ꠇꠟ ꠢꠞꠤ ꠎꠣꠅ!” ꠔꠦꠃ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠘꠤꠎꠞ ꠙꠞꠤꠌꠄ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠞ ꠇꠦꠃ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_2","002_45_2","GEN","45","2","2","ꠔꠣꠁꠘ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠘ ꠡꠥꠞꠥ ꠇꠞꠟꠣ, ꠔꠦꠃ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠁꠔꠣ ꠢꠥꠘꠟꠣ ꠀꠞ ꠚꠦꠞꠣꠃꠘꠞ ꠛꠣꠠꠤꠞ ꠝꠣꠘꠡꠦꠅ ꠁ ꠈꠛꠞ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_3","002_45_3","GEN","45","3","3","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠁꠃꠍꠥꠚ; ꠀꠝꠣꠞ ꠛꠣꠛꠣ ꠅꠈꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ ꠘꠤ?” ꠅꠃ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠒꠞꠣꠁꠀ ꠎꠛꠣꠘ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ, ꠝꠣꠔꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_4","002_45_4","GEN","45","4","4","ꠔꠦꠃ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠅ।” ꠔꠣꠞꠣ ꠇꠣꠍꠣꠔ ꠀꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠜꠣꠁ ꠁꠃꠍꠥꠚ, ꠝꠤꠡꠞꠅ ꠎꠣꠅꠞꠣ ꠛꠦꠙꠣꠞꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠦ ꠛꠦꠌꠤꠟꠣꠁꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN45_5","002_45_5","GEN","45","5","5","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠛꠦꠌꠤꠍꠟꠣꠄ ꠇꠞꠤ ꠅꠈꠘ ꠛꠦꠎꠣꠞ ꠅꠁꠅ ꠘꠣ, ꠛꠣ ꠘꠤꠎꠞ ꠃꠙꠞꠦ ꠘꠣꠞꠣꠎ ꠅꠁꠅ ꠘꠣ। ꠝꠣꠘꠡꠞ ꠎꠣꠘꠞ ꠢꠦꠚꠣꠎꠔꠞ ꠟꠣꠉꠤ, ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠝꠣꠞꠦ ꠅꠘꠅ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN45_6","002_45_6","GEN","45","6","6","ꠀꠇꠣꠟ ꠌꠟꠦꠞ ꠅꠃ ꠖꠥꠁ ꠛꠞꠍ ꠗꠞꠤ, ꠔꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠞꠍ ꠇꠥꠘꠥ ꠈꠦꠔ-ꠈꠣꠝꠣꠞ ꠛꠣ ꠚꠡꠟ ꠚꠟꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN45_7","002_45_7","GEN","45","7","7","ꠖꠥꠘꠤꠀꠁꠔ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠛꠣꠌꠣꠁꠀ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN45_8","002_45_8","GEN","45","8","8","ꠔꠦꠃ ꠛꠥꠎꠣ ꠎꠣꠄ ꠎꠦꠘ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠁꠘꠅ ꠙꠣꠑꠣꠁꠍ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠄꠃ ꠙꠣꠑꠣꠁꠍꠂꠘ। ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠛꠣꠚꠞ ꠢꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠔꠣꠘ ꠙꠞꠤꠛꠣꠞꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠀꠞ ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡ ꠡꠣꠡꠘꠞ ꠄꠈꠔꠤꠀꠞ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN45_9","002_45_9","GEN","45","9","9","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠎꠟꠖꠤ ꠇꠞꠤ ꠛꠣꠛꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠅ, ꠔꠣꠘ ꠙꠥꠀ ꠁꠃꠍꠥꠚꠦ ꠇꠁꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠔꠦ ꠔꠥꠝꠤ ꠀꠞ ꠖꠦꠞꠤ ꠘꠣ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("GN45_10","002_45_10","GEN","45","10","10","ꠔꠥꠝꠤ, ꠔꠥꠝꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠘꠣꠔꠤ-ꠙꠥꠔꠤ, ꠉꠞꠥ-ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠀꠞ ꠔꠥꠝꠣꠞ ꠎꠔꠔꠣ ꠀꠍꠦ, ꠢꠇ꠆ꠇꠟꠔꠣ ꠟꠁꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠉꠥꠡꠘ ꠄꠟꠣꠇꠣꠔ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN45_11","002_45_11","GEN","45","11","11","ꠢꠘꠅ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠝꠥ, ꠀꠇꠣꠟ ꠔ ꠀꠞꠅ ꠙꠣꠌ ꠛꠞꠍ ꠞꠁꠛ, ꠀꠞꠘꠣꠄ ꠔꠥꠝꠤꠔꠣꠁꠘ ꠢꠇꠟꠦ ꠁ ꠀꠇꠣꠟꠦ ꠛꠦꠢꠣꠟꠔ ꠅꠁꠎꠤꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("GN45_12","002_45_12","GEN","45","12","12","ꠀꠝꠣꠞ ꠀꠙꠘ ꠜꠣꠁ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠦ ꠀꠞ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠞꠣꠄ ꠎꠦꠘ, ꠀꠝꠤ ꠘꠤꠎꠞ ꠝꠥꠈꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN45_13","002_45_13","GEN","45","13","13","ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠝꠣꠞ ꠎꠦꠔꠣ ꠖꠣꠙꠐ, ꠝꠣꠘ-ꠁꠎ꠆ꠎꠔ ꠖꠦꠈꠞꠣꠄ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞꠦ ꠁꠔꠣ ꠇꠁꠛꠣꠄ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠎꠟꠖꠤ ꠇꠞꠤ ꠅꠈꠣꠘꠅ ꠟꠁꠀ ꠀꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN45_14","002_45_14","GEN","45","14","14","ꠢꠦꠡꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠜꠣꠁ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞ ꠉꠟꠣꠔ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠇꠣꠘ꠆ꠖꠘ ꠡꠥꠞꠥ ꠇꠞꠟꠣ ꠀꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠦꠅ ꠉꠟꠣꠔ ꠗꠞꠤ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_15","002_45_15","GEN","45","15","15","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠢꠇꠟ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠢꠥꠋꠉꠣ ꠖꠤꠟꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠉꠟꠣꠔ ꠗꠞꠤꠅ ꠇꠣꠘ꠆ꠖꠤꠟꠣ। ꠔꠦꠃ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦꠅ ꠔꠣꠘ ꠟꠉꠦ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_16","002_45_16","GEN","45","16","16","ꠁꠃꠍꠥꠚꠞ ꠜꠣꠁꠀꠁꠘ ꠀꠅꠀꠞ ꠈꠛꠞ ꠚꠦꠞꠣꠃꠘꠞ ꠛꠣꠠꠤꠔ ꠙꠃꠍꠤꠟꠦ, ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠘ ꠇꠞ꠆ꠝꠌꠣꠞꠤ ꠅꠇꠟ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_17","002_45_17","GEN","45","17","17","ꠚꠦꠞꠣꠃꠘꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠇꠅ ꠎꠦꠘ, ꠔꠥꠝꠞꠣ ꠉꠣꠗꠣꠞ ꠙꠤꠑꠤꠔ ꠗꠣꠘꠞ ꠛꠡ꠆ꠔꠣ ꠛꠣꠘ꠆ꠖꠤꠀ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠉꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("GN45_18","002_45_18","GEN","45","18","18","ꠛꠣꠛꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇ꠆ꠇꠟꠞꠦ ꠟꠁꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠅ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞꠞ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠌꠤꠎ ꠅꠇꠟ ꠖꠤꠝꠥ ꠀꠞ ꠔꠥꠝꠞꠣ ꠖꠦꠡꠞ ꠢꠇꠟ ꠕꠘꠦ ꠜꠣꠟꠣ ꠎꠣꠉꠣꠅ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN45_19","002_45_19","GEN","45","19","19","ꠀꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠝꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠃ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠉꠣꠠꠤ ꠟꠁꠀ ꠉꠤꠀ, ꠔꠣꠞꠣꠞꠦ ꠀꠞ ꠛꠣꠛꠣꠞꠦ ꠟꠁꠀ ꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("GN45_20","002_45_20","GEN","45","20","20","ꠀꠞ ꠢꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠄꠀ ꠖꠦꠈꠣꠁꠅ ꠘꠣ, ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠌꠤꠎ ꠅꠇꠟ ꠔ ꠔꠥꠝꠞꠣꠞꠃ।” ");
INSERT INTO syls_vpl VALUES ("GN45_21","002_45_21","GEN","45","21","21","ꠁꠍꠞꠣꠁꠟꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠃꠟꠣꠃ ꠇꠞꠟꠣ। ꠚꠦꠞꠣꠃꠘꠞ ꠢꠥꠇꠥꠝꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠉꠣꠠꠤ ꠀꠞ ꠙꠕꠞ ꠈꠣꠘꠤꠞ ꠝꠍꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_22","002_45_22","GEN","45","22","22","ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠞꠦ ꠄꠇ ꠡꠦꠐ ꠇꠞꠤꠀ ꠇꠣꠙꠠ ꠖꠤꠟꠣ, ꠅꠁꠟꠦ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞꠦ ꠖꠤꠟꠣ ꠙꠣꠌ ꠡꠦꠐ ꠇꠣꠙꠠ ꠀꠞ ꠔꠤꠘ-ꠡ ꠞꠥꠙꠣꠞ ꠐꠦꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_23","002_45_23","GEN","45","23","23","ꠔꠣꠁꠘ ꠔꠣꠘ ꠛꠣꠚꠞ ꠟꠣꠉꠤ ꠖꠡꠉꠥ ꠉꠣꠗꠣꠞ ꠙꠤꠑꠤꠔ ꠇꠞꠤ ꠝꠤꠡꠞꠞ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠌꠤꠎ ꠅꠇꠟ, ꠀꠞ ꠖꠡꠉꠥ ꠉꠣꠗꠤꠞ ꠙꠤꠑꠤꠔ ꠇꠞꠤ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠞꠥꠐꠤ ꠀꠞ ꠗꠣꠘ ꠛꠥꠏꠣꠁ ꠇꠞꠤ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_24","002_45_24","GEN","45","24","24","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣ, ꠛꠤꠖꠣꠄ ꠛꠣꠟꠣ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠙꠕꠅ ꠟꠣꠉꠣ-ꠟꠣꠉꠤ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN45_25","002_45_25","GEN","45","25","25","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠝꠤꠡꠞ ꠕꠘꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ, ꠔꠣꠞꠣꠞ ꠛꠣꠚ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN45_26","002_45_26","GEN","45","26","26","“ꠁꠃꠍꠥꠚ ꠅꠈꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠦ। ꠢꠦ ꠔ ꠅꠈꠘ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠅꠞ꠆ꠔꠣꠇꠞ꠆ꠔꠣ।” ꠅꠁꠟꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠁꠀꠇꠥꠛꠞ ꠢꠥꠡ ꠃꠠꠤ ꠉꠦꠟ, ꠔꠣꠘ ꠛꠤꠡ꠆ꠛꠣꠡꠃ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN45_27","002_45_27","GEN","45","27","27","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠇꠁꠀ ꠖꠤꠍꠟꠣ ꠁꠔꠣ ꠢꠥꠘꠤꠀ, ꠀꠞ ꠔꠣꠘꠦ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠁꠃꠍꠥꠚꠞ ꠙꠣꠑꠣꠁꠟ ꠉꠣꠠꠤꠘ ꠖꠦꠈꠤꠀ, ꠔꠣꠞꠣꠞ ꠛꠣꠚ ꠁꠀꠇꠥꠛꠞ ꠢꠥꠡ ꠑꠤꠇ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN45_28","002_45_28","GEN","45","28","28","ꠁꠍꠞꠣꠁꠟꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠙꠥꠀ ꠁꠃꠍꠥꠚ ꠎꠦꠘ ꠅꠈꠘꠅ ꠎꠤꠔꠣ ꠀꠍꠦ, ꠅꠐꠣꠃ ꠔ ꠛꠃꠔ, ꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠝꠤ ꠉꠤꠀ ꠔꠣꠞꠦ ꠖꠦꠈꠣꠃ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN46_1","002_46_1","GEN","46","1","1","ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠘ ꠢꠇ꠆ꠇꠟꠔꠣ ꠟꠁꠀ ꠛꠣꠞ ꠅꠁꠉꠦꠟꠣ। ꠀꠞ ꠛꠦꠞ-ꠡꠦꠛꠣꠔ ꠀꠁꠀ ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠢꠣꠇꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN46_2","002_46_2","GEN","46","2","2","ꠛꠣꠖꠦ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠀꠟ꠆ꠟꠣꠄ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠁꠀꠇꠥꠛ, ꠁꠀꠇꠥꠛ!” ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅꠃꠘꠥ ꠀꠝꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN46_3","002_46_3","GEN","46","3","3","ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠟꠣ, “ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠝꠣꠛꠥꠖ। ꠔꠥꠝꠤ ꠝꠤꠡꠞꠅ ꠎꠣꠁꠔꠦ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠢꠘꠅ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠄꠇ ꠛꠤꠞꠣꠐ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN46_4","002_46_4","GEN","46","4","4","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠝꠤꠡꠞꠅ ꠎꠣꠁꠝꠥ, ꠀꠞ ꠀꠝꠤꠃ ꠔꠥꠝꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠝꠥ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀ ꠁꠃꠍꠥꠚꠦ ꠔꠥꠝꠣꠞ ꠌꠃꠈ ꠝꠥꠎꠣꠁꠀ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN46_5","002_46_5","GEN","46","5","5","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠛꠦꠞ-ꠡꠦꠛꠣ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠉꠣꠠꠤꠘ ꠖꠤꠍꠟꠣ, ꠁꠍꠞꠣꠁꠟꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠔꠣꠔ ꠇꠞꠤ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞꠦ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠃ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN46_6","002_46_6","GEN","46","6","6","ꠢꠦꠡꠦ ꠁꠀꠇꠥꠛ, ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠞꠣ ꠉꠥꠡ꠆ꠐꠤ, ꠙꠡꠥꠞ ꠙꠣꠟ ꠅꠇꠟ ꠀꠞ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠇꠣꠝꠣꠁ ꠇꠞꠣ ꠢꠇ꠆ꠇꠟ ꠗꠘ-ꠖꠃꠟꠔ ꠟꠁꠀ ꠝꠤꠡꠞꠅ ꠙꠃꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN46_7","002_46_7","GEN","46","7","7","ꠅꠃ ꠟꠣꠈꠣꠘ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠘꠣꠔꠤ-ꠘꠣꠔꠤꠘ, ꠙꠥꠞꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠢꠇ꠆ꠇꠟꠞꠦ ꠟꠁꠀ ꠝꠤꠡꠞꠅ ꠙꠣꠞ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN46_8","002_46_8","GEN","46","8","8","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠝꠣꠘꠤ ꠁꠀꠇꠥꠛ ꠀꠞ ꠔꠣꠘ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠎꠦꠞꠣ ꠝꠤꠡꠞꠅ ꠉꠦꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ-ꠘꠣꠝꠣ ꠅꠁꠟ: ꠁꠀꠇꠥꠛꠞ ꠛꠠ ꠙꠥꠀ ꠞꠥꠛꠦꠘ; ");
INSERT INTO syls_vpl VALUES ("GN46_9","002_46_9","GEN","46","9","9","ꠀꠞ ꠞꠥꠛꠦꠘꠞ ꠙꠥꠀꠂꠘ: ꠢꠘꠥꠇ, ꠚꠣꠟꠥ, ꠢꠣꠍꠤꠞ ꠀꠞ ꠇꠞ꠆ꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("GN46_10","002_46_10","GEN","46","10","10","ꠡꠤꠝꠤꠅꠘꠞ ꠙꠥꠀꠂꠘ: ꠎꠤꠝꠥꠄꠟ, ꠎꠣꠝꠤꠘ, ꠅꠢꠖ, ꠎꠣꠈꠤꠘ, ꠡꠥꠢꠞ, ꠀꠞ ꠇꠦꠘꠣꠘꠤ ꠛꠃꠞ ꠔꠞꠚꠣ ꠡꠃꠟ। ");
INSERT INTO syls_vpl VALUES ("GN46_11","002_46_11","GEN","46","11","11","ꠟꠦꠛꠤꠞ ꠙꠥꠀꠂꠘ: ꠎꠣꠞꠍꠥꠘ, ꠇꠣꠢꠣꠔ ꠀꠞ ꠝꠣꠞꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("GN46_12","002_46_12","GEN","46","12","12","ꠄꠢꠥꠖꠣꠞ ꠙꠥꠀꠂꠘ: ꠄꠁꠞ, ꠅꠘꠘ, ꠡꠦꠟꠣ, ꠚꠤꠞꠥꠎ ꠀꠞ ꠎꠣꠞꠣꠢ। ꠅꠁꠟꠦ ꠅꠘꠘ ꠀꠞ ꠄꠁꠞ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅꠃ ꠝꠞꠤ ꠉꠦꠍꠟꠣ। ꠚꠤꠞꠥꠎꠞ ꠙꠥꠀꠂꠘ: ꠢꠣꠍꠤꠞ ꠀꠞ ꠢꠣꠝꠥꠟ। ");
INSERT INTO syls_vpl VALUES ("GN46_13","002_46_13","GEN","46","13","13","ꠁꠍꠣꠈꠞꠞ ꠙꠥꠀꠂꠘ: ꠔꠟꠣ, ꠚꠅꠀ, ꠎꠣꠡꠥꠛ ꠀꠞ ꠡꠤꠝꠞꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_14","002_46_14","GEN","46","14","14","ꠍꠛꠥꠟꠘꠞ ꠙꠥꠀꠂꠘ: ꠍꠦꠞꠦꠖ, ꠄꠟꠘ ꠀꠞ ꠎꠢꠟꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN46_15","002_46_15","GEN","46","15","15","ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠟꠦꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠙꠖ꠆ꠖꠘ-ꠁꠞꠣꠝꠅ ꠟꠦꠀꠞ ꠔꠞꠚꠣ ꠁꠀꠇꠥꠛꠞ ꠁ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠠꠤ ꠖꠤꠘꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ, ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠄ ꠔꠦꠔ꠆ꠞꠤꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_16","002_46_16","GEN","46","16","16","ꠍꠣꠖꠥꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ: ꠍꠤꠚꠘ, ꠢꠉꠤ, ꠡꠥꠘꠤ, ꠁꠡꠛꠥꠘ, ꠄꠁꠞꠤ, ꠅꠞꠥꠖꠤ ꠀꠞ ꠅꠞꠦꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("GN46_17","002_46_17","GEN","46","17","17","ꠀꠡꠤꠞꠞ ꠙꠥꠀꠂꠘ: ꠁꠝꠘꠣ, ꠎꠤꠍꠛꠣ, ꠎꠤꠍꠛꠤ, ꠛꠞꠤꠀ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠁꠘ ꠍꠦꠞꠣ। ꠛꠞꠤꠀꠞ ꠙꠥꠀꠂꠘ: ꠢꠦꠛꠞ ꠀꠞ ꠝꠟꠇꠤꠄꠟ। ");
INSERT INTO syls_vpl VALUES ("GN46_18","002_46_18","GEN","46","18","18","ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠎꠤꠟꠙꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠟꠣꠛꠘꠦ ꠔꠣꠘ ꠙꠥꠠꠤ ꠟꠦꠀꠞ ꠟꠉꠦ ꠅꠃ ꠛꠣꠘ꠆ꠖꠤ ꠎꠤꠟꠙꠣꠞꠦ ꠖꠤꠍꠟꠣ, ꠄꠞꠣ ꠢꠇꠟꠃ ꠔꠣꠁꠞ ꠔꠞꠚꠣ ꠁꠀꠇꠥꠛꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠅꠃ ꠡꠥꠟ꠆ꠟ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_19","002_46_19","GEN","46","19","19","ꠁꠀꠇꠥꠛꠞ ꠛꠤꠛꠤ ꠞꠣꠢꠦꠟꠣꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ: ꠁꠃꠍꠥꠚ ꠀꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_20","002_46_20","GEN","46","20","20","ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀꠂꠘ ꠝꠣꠘꠡꠣ ꠀꠞ ꠀꠚꠞꠣꠁꠝ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠎꠘꠝꠤꠍꠟꠣ। ꠄꠞꠣꠞ ꠝꠣ ꠅꠁꠟꠣ ꠅꠃꠘ ꠝꠘ꠆ꠖꠤꠞꠞ ꠛꠣꠛꠘ-ꠑꠣꠇꠥꠞ, ꠙꠥꠐꠤꠚꠦꠞꠣꠞ ꠙꠥꠠꠤ ꠀꠡꠘꠔ। ");
INSERT INTO syls_vpl VALUES ("GN46_21","002_46_21","GEN","46","21","21","ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞ ꠙꠥꠀꠂꠘ: ꠛꠦꠟꠣ, ꠛꠦꠈꠞ, ꠅꠡꠛꠦꠟ, ꠉꠦꠞꠣ, ꠘꠣꠝꠣꠘ, ꠄꠢꠤ, ꠞꠥꠡ, ꠝꠥꠙ꠆ꠙꠤꠝ, ꠢꠥꠙ꠆ꠙꠤꠝ ꠀꠞ ꠅꠞ꠆ꠖ। ");
INSERT INTO syls_vpl VALUES ("GN46_22","002_46_22","GEN","46","22","22","ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠞꠣꠢꠦꠟꠣꠞ ꠔꠞꠚꠣ ꠁꠀꠇꠥꠛꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠅꠃ ꠌꠃꠖ꠆ꠖ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_23","002_46_23","GEN","46","23","23","ꠖꠣꠘꠞ ꠙꠥꠀ: ꠢꠥꠡꠤꠝ। ");
INSERT INTO syls_vpl VALUES ("GN46_24","002_46_24","GEN","46","24","24","ꠘꠙ꠆ꠔꠣꠟꠤꠞ ꠙꠥꠀꠂꠘ: ꠎꠢꠡꠤꠄꠟ, ꠉꠥꠘꠤ, ꠁꠎꠦꠞ ꠀꠞ ꠡꠤꠟ꠆ꠟꠦꠝ। ");
INSERT INTO syls_vpl VALUES ("GN46_25","002_46_25","GEN","46","25","25","ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠛꠤꠟꠢꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠟꠣꠛꠘꠦ ꠔꠣꠘ ꠙꠥꠠꠤ ꠞꠣꠢꠦꠟꠣꠞ ꠟꠉꠦ ꠅꠃ ꠛꠣꠘ꠆ꠖꠤ ꠛꠤꠟꠢꠣꠞꠦ ꠖꠤꠍꠟꠣ। ꠄꠞꠣ ꠢꠇꠟꠃ ꠔꠣꠁꠞ ꠔꠞꠚꠣ ꠁꠀꠇꠥꠛꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠅꠃ ꠡꠣꠔ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_26","002_46_26","GEN","46","26","26","ꠁꠀꠇꠥꠛꠞ ꠘꠣꠘꠣꠘ ꠔꠞꠚꠣꠞ ꠎꠘꠝꠞ ꠎꠣꠞꠣ ꠝꠤꠡꠞꠅ ꠀꠁꠟꠣ, ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠛꠃ ꠛꠣꠖ ꠖꠤꠀ ꠄꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠍꠄꠡꠐ꠆ꠐꠤ ꠎꠘ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN46_27","002_46_27","GEN","46","27","27","ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠁꠃꠍꠥꠚꠞ ꠖꠥꠁꠎꠘ ꠙꠥꠀ ꠎꠘꠝꠤꠍꠟꠣ। ꠄꠞꠣ ꠡꠢ ꠁꠀꠇꠥꠛꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠎꠣꠞꠣ ꠝꠤꠡꠞꠅ ꠀꠁꠟꠣ, ꠔꠣꠞꠣ ꠝꠥꠐ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_28","002_46_28","GEN","46","28","28","ꠄꠞ ꠀꠉꠦ ꠁꠀꠇꠥꠛꠦ ꠄꠢꠥꠖꠣꠞꠦ ꠁꠃꠍꠥꠚꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠉꠥꠡꠘꠅ ꠎꠣꠅꠀꠞ ꠙꠕ ꠌꠤꠘꠣꠞ ꠟꠣꠉꠤ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟ ꠅꠘꠅ ꠉꠤꠀ ꠙꠃꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN46_29","002_46_29","GEN","46","29","29","ꠀꠞ ꠁꠃꠍꠥꠚꠦꠅ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ ꠢꠣꠎꠣꠁꠀ ꠔꠣꠘ ꠛꠣꠚ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠉꠥꠡꠘꠅ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠉꠦꠟꠣ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠉꠟꠣꠔ ꠗꠞꠤꠀ ꠛꠃꠔ ꠡꠝꠄ ꠇꠣꠘ꠆ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN46_30","002_46_30","GEN","46","30","30","ꠔꠦꠃ ꠁꠍꠞꠣꠁꠟꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠦꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍ ꠞꠦ ꠙꠥꠔ, ꠁꠐꠣ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠟꠣꠝ। ꠅꠈꠘ ꠡꠣꠘ꠆ꠔꠤꠄꠃ ꠝꠞꠔꠣꠝ ꠙꠣꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN46_31","002_46_31","GEN","46","31","31","ꠅꠃ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠀꠞ ꠔꠣꠘ ꠛꠣꠚꠞ ꠟꠉꠞ ꠢꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠉꠤꠀ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠎꠣꠘꠣꠁꠝꠥ, ꠀꠝꠣꠞ ꠜꠣꠁꠀꠁꠘ ꠀꠞ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠞ ꠢꠇꠟ, ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠕꠘꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠌ꠆ꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_32","002_46_32","GEN","46","32","32","ꠔꠣꠞꠣꠞ ꠇꠣꠝ ꠅꠁꠟ ꠙꠡꠥ ꠙꠣꠟꠣ। ꠔꠣꠞꠣ ꠔ ꠍꠣꠉꠟ-ꠝꠦꠠꠣ ꠙꠣꠟꠂꠘ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠅꠇꠟ ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠁꠀ ꠀꠁꠌ꠆ꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GN46_33","002_46_33","GEN","46","33","33","ꠚꠦꠞꠣꠃꠘꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠛꠣ, ꠀꠙꠘꠣꠞꠣ ꠇꠤꠔꠣ ꠇꠣꠝ ꠇꠞꠂꠘ? ");
INSERT INTO syls_vpl VALUES ("GN46_34","002_46_34","GEN","46","34","34","ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠇꠁꠅ, ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠦꠅ ꠢꠥꠞꠥꠝꠣꠘ ꠕꠘꠦꠃ ꠙꠡꠥ ꠙꠣꠟꠤꠀ ꠛꠣꠌꠂꠘ। ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠉꠥꠡꠘꠅ ꠞꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠇꠣꠞꠘ ꠙꠡꠥ ꠙꠣꠟꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠊꠤꠘ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN47_1","002_47_1","GEN","47","1","1","ꠁꠃꠍꠥꠚꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠣꠛꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ, ꠔꠣꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠀꠞ ꠔꠣꠞꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠟꠁꠀ, ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠀꠁꠍꠂꠘ। ꠔꠣꠞꠣ ꠀꠁꠀ ꠉꠥꠡꠘꠅ ꠙꠃꠍꠤ ꠉꠦꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("GN47_2","002_47_2","GEN","47","2","2","ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠙꠣꠌ ꠎꠘꠞꠦ ꠘꠤꠀ ꠔꠣꠁꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_3","002_47_3","GEN","47","3","3","ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠣꠝ ꠇꠞꠅ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠀꠝꠟ ꠕꠣꠇꠤꠃ ꠙꠡꠥ ꠙꠣꠟꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN47_4","002_47_4","GEN","47","4","4","ꠔꠣꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠁ ꠖꠦꠡꠅ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠁꠀ ꠕꠣꠇꠣꠞ ꠟꠣꠉꠤ ꠀꠁꠍꠤ। ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠅꠈꠘ ꠛꠦꠎꠥꠁꠔꠣ ꠘꠤꠖꠣꠘ ꠌꠟꠦꠞ ꠇꠞꠤ, ꠢꠤꠘꠅ ꠀꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠈꠥꠞꠣꠇꠤ ꠘꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠖꠄꠀ ꠇꠞꠤ ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ, ꠉꠥꠡꠘꠅ ꠞꠁꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN47_5","002_47_5","GEN","47","5","5","ꠚꠦꠞꠣꠃꠘꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠜꠣꠁꠀꠁꠘ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠍꠂꠘ; ");
INSERT INTO syls_vpl VALUES ("GN47_6","002_47_6","GEN","47","6","6","ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠃ ꠔ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠙꠠꠤ ꠞꠁꠍꠦ। ꠖꠦꠡꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠎꠣꠉꠣꠔ ꠔꠣꠞꠣꠞꠦ ꠞꠁꠔꠦ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠉꠥꠡꠘꠅꠃ ꠕꠣꠇꠃꠇ ꠀꠞ ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠁꠉ꠆ꠉ ꠝꠣꠘꠥꠡ ꠙꠣꠁꠟꠦ, ꠔꠣꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠛꠣꠘꠣꠁꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN47_7","002_47_7","GEN","47","7","7","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠚ ꠁꠀꠇꠥꠛꠞꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠣꠁꠟꠣ ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_8","002_47_8","GEN","47","8","8","ꠚꠦꠞꠣꠃꠘꠦ ꠁꠀꠇꠥꠛꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠛꠄꠅꠡ ꠇꠔ ꠅꠁꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("GN47_9","002_47_9","GEN","47","9","9","ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠖꠥꠘꠤꠀꠁꠔ ꠀꠝꠣꠞ ꠝꠥꠍꠣꠚꠤꠞꠤꠞ ꠀꠄꠃ ꠄꠇ-ꠡ ꠔꠤꠡ ꠛꠞꠍ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠔ ꠛꠦꠡꠤ ꠘꠣꠄ, ꠀꠞ ꠈꠥꠛ ꠔꠇꠟꠤꠚꠦꠃ ꠁ ꠖꠤꠘ ꠇꠣꠐꠍꠦ; ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠥꠍꠣꠚꠤꠞꠤꠞ ꠀꠄꠃꠞ ꠢꠝꠣꠘ ꠅꠈꠘꠅ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN47_10","002_47_10","GEN","47","10","10","ꠢꠦꠡꠦ ꠁꠀꠇꠥꠛꠦ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠖꠥꠀ ꠇꠞꠤꠀ ꠛꠤꠖꠣꠄ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_11","002_47_11","GEN","47","11","11","ꠔꠦꠃ ꠁꠃꠍꠥꠚꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠢꠥꠇꠥꠝ ꠝꠔ, ꠔꠣꠘ ꠛꠣꠚ-ꠜꠣꠁꠀꠁꠘꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠎꠣꠉꠣ, ꠞꠣꠝꠣꠡꠦꠡ ꠄꠟꠣꠇꠣꠔ ꠞꠁꠔꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_12","002_47_12","GEN","47","12","12","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠚ-ꠜꠣꠁꠀꠁꠘ ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠞꠤꠛꠣꠞꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠖꠞꠇꠣꠞꠤ, ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠢꠇꠟꠔꠣ ꠎꠥꠉꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_13","002_47_13","GEN","47","13","13","ꠛꠣꠖꠦ ꠀꠇꠣꠟ ꠀꠞꠅ ꠛꠦꠕꠣꠄꠀ ꠅꠁꠟ, ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠈꠣꠘꠤꠞ ꠇꠥꠘ꠆ꠔꠣ ꠀꠍꠤꠟ ꠘꠣ। ꠔꠦꠃ ꠝꠤꠡꠞ ꠀꠞ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠇꠣꠢꠤꠟ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("GN47_14","002_47_14","GEN","47","14","14","ꠝꠤꠡꠞ ꠀꠞ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞ ꠎꠔ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠀꠍꠤꠟ, ꠁꠔꠣꠖꠤ ꠔꠣꠞꠣ ꠗꠣꠘ ꠈꠞꠤꠖ ꠇꠞꠣꠄ, ꠁꠃꠍꠥꠚꠦ ꠅꠔꠣ ꠖꠟꠣ ꠇꠞꠤꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠜꠣꠘ꠆ꠒꠣꠞꠅ ꠎꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_15","002_47_15","GEN","47","15","15","ꠝꠤꠡꠞ ꠀꠞ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠢꠇꠟ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠎꠦꠛꠟꠣ ꠚꠥꠠꠣꠁ ꠉꠦꠟ, ꠔꠦꠃ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠀꠁꠀ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞꠦ ꠈꠣꠘꠤꠞ ꠇꠥꠘ꠆ꠔꠣ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠀꠝꠞꠣꠞ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠚꠥꠠꠣꠁ ꠉꠦꠍꠦ ꠇꠞꠤ ꠀꠙꠘꠣꠞ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ ꠝꠞꠤꠎꠤꠔꠣꠝ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("GN47_16","002_47_16","GEN","47","16","16","ꠁꠃꠍꠥꠚꠦ ꠇꠁꠟꠣ, “ꠔꠣꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠡꠥ ꠅꠇꠟ ꠀꠘꠤꠀ ꠖꠦꠅ, ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠚꠥꠠꠣꠁ ꠉꠦꠟꠦꠅ ꠙꠡꠥ ꠅꠇꠟꠞ ꠛꠖꠟꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN47_17","002_47_17","GEN","47","17","17","ꠔꠦꠃ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ, ꠊꠥꠠꠣ-ꠝꠦꠠꠣ, ꠉꠣꠗꠣ-ꠉꠣꠗꠤ ꠁꠃꠍꠥꠚꠞ ꠉꠦꠍꠦ ꠀꠘꠟꠣ ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠄꠞ ꠛꠖꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠗꠣꠘ ꠖꠤꠟꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠙꠡꠥꠞ ꠛꠖꠟꠣ, ꠢꠤ ꠛꠍꠞꠞ ꠈꠥꠞꠣꠇꠤ ꠌꠣꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_18","002_47_18","GEN","47","18","18","ꠀꠞ ꠢꠤ ꠛꠞꠍ ꠉꠦꠟ, ꠄꠞ ꠛꠣꠖꠞ ꠛꠞꠍ ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠟꠥꠇꠣꠁꠀꠞ ꠘꠣ, ꠀꠝꠞꠣꠞ ꠢꠇꠟ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠡꠦꠡ ꠅꠁꠉꠦꠍꠦ ꠀꠞ ꠙꠡꠥ ꠅꠇꠟꠅ ꠀꠙꠘꠣꠞꠦ ꠖꠤꠟꠣꠁꠍꠤ। ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠞꠁꠍꠦ ꠘꠣ, ꠈꠣꠟꠤ ꠅꠃ ꠡꠞꠤꠟ ꠀꠞ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠍꠣꠠꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_19","002_47_19","GEN","47","19","19","ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ ꠎꠝꠤ-ꠎꠝꠣ ꠡꠢ ꠀꠝꠞꠣ ꠇꠤꠟꠣ ꠝꠞꠤꠎꠤꠔꠣꠝ? ꠔꠦ ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦꠅ ꠀꠞ ꠀꠝꠞꠣꠞ ꠢꠇꠟ ꠎꠝꠤ-ꠎꠝꠣꠅ ꠟꠁꠟꠣꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠝꠥ, ꠔꠣ-ꠅ ꠀꠝꠞꠣꠞꠦ ꠈꠣꠘꠤ ꠖꠦꠃꠇ꠆ꠇꠣ ꠀꠞ ꠛꠤꠌ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠔꠦꠃ ꠀꠝꠞꠣꠅ ꠝꠞꠣ ꠕꠘꠦ ꠛꠣꠌꠝꠥ ꠀꠞ ꠎꠝꠤꠘ ꠈꠣꠘꠣꠁꠘꠅ ꠛꠞꠛꠣꠖ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GN47_20","002_47_20","GEN","47","20","20","ꠅꠃ ꠁꠃꠍꠥꠚꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟ ꠎꠝꠤꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠘꠣꠝꠦ ꠟꠁꠟꠤꠟꠣ, ꠇꠣꠞꠘ ꠁ ꠀꠇꠣꠟ ꠅꠃꠟꠣ ꠛꠦꠎꠥꠁꠔꠣ ꠅꠁꠍꠤꠟ ꠎꠦꠘ, ꠝꠤꠡꠞꠞ ꠢꠇꠟꠦꠃ ꠔꠣꠞꠣꠞ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠛꠦꠌꠤꠟꠣꠁꠟꠣ। ꠔꠦꠃ ꠖꠦꠡꠞ ꠢꠇꠟ ꠎꠝꠤꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠀꠔꠅ ꠀꠁꠟ꠆ꠟ। ");
INSERT INTO syls_vpl VALUES ("GN47_21","002_47_21","GEN","47","21","21","ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠐꠣꠃꠘꠅ ꠙꠣꠞ ꠇꠞꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_22","002_47_22","GEN","47","22","22","ꠈꠣꠟꠤ ꠛꠣꠛꠘ ꠅꠇꠟꠞ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠔꠣꠁꠘ ꠟꠁꠟꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠄꠞꠣꠞꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠛꠦꠔꠘ ꠖꠤꠔꠣ, ꠀꠞ ꠅꠔꠣ ꠖꠤꠀꠃ ꠔꠣꠞꠣ ꠌꠟꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_23","002_47_23","GEN","47","23","23","ꠢꠦꠡꠦ ꠁꠃꠍꠥꠚꠦ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠚꠦꠞꠣꠃꠘꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠎꠣꠉꠣ-ꠎꠝꠤꠘꠅ ꠟꠁꠟꠤꠟꠣꠝ। ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠅꠃ ꠛꠤꠌ ꠅꠇꠟ ꠘꠦꠅ ꠀꠞ ꠎꠝꠤꠘꠅ ꠛꠣꠁꠘ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("GN47_24","002_47_24","GEN","47","24","24","ꠔꠦꠃ ꠎꠝꠤꠘꠅ ꠎꠦꠔꠣ ꠚꠡꠟ ꠚꠟꠤꠛ, ꠄꠞ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠖꠤꠅ ꠀꠞ ꠛꠣꠇꠤ ꠌꠣꠁꠞ ꠛꠣꠐ, ꠎꠝꠤꠘꠞ ꠛꠤꠌ, ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠙꠞꠤꠛꠣꠞ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠘꠤꠅꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("GN47_25","002_47_25","GEN","47","25","25","ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠟꠣ। ꠢꠥꠎꠥꠞꠦ ꠀꠝꠞꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠟꠦ, ꠀꠝꠞꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN47_26","002_47_26","GEN","47","26","26","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠎꠣꠉꠣ-ꠎꠝꠤꠘꠞ ꠟꠣꠉꠤ ꠅꠃ ꠀꠁꠘ ꠎꠣꠞꠤ ꠇꠞꠟꠣ, ꠢꠇꠟ ꠚꠡꠟꠞ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠚꠦꠞꠣꠃꠘꠦ ꠙꠣꠁꠛꠣ, ꠈꠣꠟꠤ ꠛꠣꠛꠘ ꠅꠇꠟꠞ ꠎꠝꠤꠘ ꠛꠣꠖꠦ। ꠅꠃ ꠀꠁꠘ ꠅꠈꠘꠅ ꠌꠟꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("GN47_27","002_47_27","GEN","47","27","27","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠉꠥꠡꠘꠅ ꠛꠡꠔ ꠇꠞꠟꠣ। ꠔꠣꠞꠣ ꠢꠘꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠀ, ꠈꠥꠛ ꠚꠟꠀꠟꠣ ꠅꠁꠟꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠃꠔ ꠀꠅꠟꠣꠖ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_28","002_47_28","GEN","47","28","28","ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠁꠀ ꠁꠀꠇꠥꠛ ꠡꠔꠞ ꠛꠞꠍ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠟꠣ। ꠔꠦꠃ ꠔꠣꠁꠘ ꠢꠇꠟꠔꠣꠄ ꠄꠇ-ꠡ ꠡꠣꠔꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_29","002_47_29","GEN","47","29","29","ꠁꠍꠞꠣꠁꠟꠞ ꠝꠃꠔꠞ ꠖꠤꠘ ꠇꠣꠍꠣꠁꠀ ꠀꠁꠟꠦ ꠔꠣꠘ ꠙꠥꠀ ꠁꠃꠍꠥꠚꠞꠦ ꠈꠛꠞ ꠖꠤ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠣꠄ ꠔꠥꠝꠣꠞ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠅꠁꠟꠦ ꠄꠇꠈꠣꠘ ꠅꠍꠤꠅꠔ ꠇꠞꠣꠁꠔꠣꠝ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠃꠞꠣꠔꠞ ꠔꠟꠦ ꠔꠥꠝꠣꠞ ꠀꠔꠈꠣꠘ ꠢꠣꠞꠣꠅ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠄ ꠖꠄꠀ ꠀꠞ ꠢꠣꠟꠣꠟꠤ ꠖꠦꠈꠣꠁꠅ, ꠀꠝꠣꠞꠦ ꠝꠤꠡꠞꠅ ꠖꠣꠚꠘ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GN47_30","002_47_30","GEN","47","30","30","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠝꠥꠉꠤ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠘꠤꠀ, ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠇꠛꠞꠡ꠆ꠕꠣꠘꠅ ꠖꠣꠚꠘ ꠇꠞꠤꠅ।” ꠁꠃꠍꠥꠚꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠎꠦꠟꠣ ꠇꠁꠟꠣ, ꠅꠃꠟꠣꠃ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN47_31","002_47_31","GEN","47","31","31","ꠔꠦꠃ ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠇꠞꠅ।” ꠁꠃꠍꠥꠚꠦ ꠇꠍꠝ ꠇꠞꠟꠣ। ꠅꠃ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠘ ꠛꠤꠍꠘꠣꠞ ꠢꠤꠔꠣꠘ ꠛꠣꠄ ꠇꠣꠁꠔ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_1","002_48_1","GEN","48","1","1","ꠄꠞꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠦ ꠈꠛꠞ ꠙꠣꠁꠟꠣ, ꠔꠣꠘ ꠛꠣꠚ ꠛꠦꠝꠣꠞ, ꠅꠃ ꠔꠣꠘ ꠖꠥꠁꠅ ꠙꠥꠀ ꠝꠣꠘꠡꠣ ꠀꠞ ꠀꠚꠞꠣꠁꠝꠞꠦ ꠟꠁꠀ ꠛꠣꠚꠞꠦ ꠖꠦꠈꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_2","002_48_2","GEN","48","2","2","ꠁꠀꠇꠥꠛꠦ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣ, ꠔꠣꠘ ꠙꠥꠀ ꠁꠃꠍꠥꠚ ꠀꠁꠍꠂꠘ, ꠅꠃ ꠔꠣꠁꠘ ꠡꠞꠤꠟꠞ ꠢꠇꠟ ꠛꠟ ꠈꠣꠐꠣꠁꠀ, ꠃꠑꠤꠀ ꠛꠤꠍꠘꠣꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_3","002_48_3","GEN","48","3","3","ꠀꠞ ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣꠄ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠟꠥꠎ ꠐꠣꠃꠘꠅ, ꠀꠝꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠛꠞꠇꠔ ꠖꠣꠘ ꠇꠞꠤꠀ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("GN48_4","002_48_4","GEN","48","4","4","‘ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠚꠟꠖꠣꠞ ꠇꠞꠝꠥ ꠀꠞ ꠛꠃꠔ ꠀꠅꠟꠣꠖ ꠖꠤꠝꠥ, ꠔꠥꠝꠣ ꠕꠘꠦ ꠛꠃꠔ ꠉꠥꠡ꠆ꠐꠤꠀꠟꠣ ꠄꠇ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ, ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠟꠣꠉꠤ ꠁ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("GN48_5","002_48_5","GEN","48","5","5","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠝꠤꠡꠞꠅ ꠀꠁꠛꠣꠞ ꠀꠉꠦ, ꠔꠥꠝꠣꠞ ꠎꠦ ꠖꠥꠁꠅ ꠙꠥꠀ ꠝꠤꠡꠞꠅ ꠎꠘꠝꠤꠍꠂꠘ, ꠔꠣꠞꠣ ꠀꠝꠣꠞꠃ। ꠞꠥꠛꠦꠘ ꠀꠞ ꠡꠤꠝꠤꠅꠘ ꠎꠦꠟꠣ ꠀꠝꠣꠞ, ꠅꠃꠟꠣ ꠝꠣꠘꠡꠣ ꠀꠞ ꠀꠚꠞꠣꠁꠝꠅ ꠀꠝꠣꠞ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_6","002_48_6","GEN","48","6","6","ꠅꠁꠟꠦ ꠄꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠣꠞ ꠎꠦꠔꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠍꠂꠘ, ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞꠃ ꠞꠁꠛꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠜꠣꠁꠞ ꠘꠣꠝꠦꠃ ꠄꠞꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠇꠣꠁꠝ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN48_7","002_48_7","GEN","48","7","7","ꠀꠞ ꠙꠖ꠆ꠖꠘ ꠕꠣꠇꠤ ꠀꠝꠞꠣ ꠀꠅꠀꠞ ꠡꠝꠄ, ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠁꠚ꠆ꠞꠣꠕ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠖꠥꠞꠁ ꠕꠣꠇꠔꠦꠃ, ꠞꠣꠢꠦꠟꠣ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ꠔꠦꠃ ꠀꠝꠤ ꠢꠘꠞ ꠁꠚ꠆ꠞꠣꠕꠅ, ꠛꠦꠕꠦꠟꠢꠣꠝꠞ ꠙꠕꠞ ꠗꠣꠞꠅ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN48_8","002_48_8","GEN","48","8","8","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠄꠞꠣ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("GN48_9","002_48_9","GEN","48","9","9","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠄꠞꠣ ꠀꠝꠣꠞ ꠙꠥꠀꠂꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠖꠦꠡꠅꠃ ꠄꠞꠣꠞꠦ ꠖꠤꠍꠂꠘ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠄꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠘꠅ। ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠀ ꠇꠞꠔꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN48_10","002_48_10","GEN","48","10","10","ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠄꠅꠡꠅ ꠌꠃꠈꠞ ꠎꠥꠔꠤ ꠇꠝꠤ ꠎꠣꠅꠀꠄ ꠁꠍꠞꠣꠁꠟꠦ ꠜꠣꠟꠣ ꠇꠞꠤ ꠖꠦꠈꠔꠣ ꠘꠣ। ꠔꠦꠃ ꠄꠞꠣ ꠇꠣꠍꠣꠔ ꠀꠁꠟꠦ, ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠢꠥꠋꠉꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_11","002_48_11","GEN","48","11","11","ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣꠞꠦ, ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠍꠟꠣꠝ ꠔꠥꠝꠣꠞ ꠝꠥꠈ ꠀꠞ ꠇꠥꠘꠥ ꠖꠤꠘ ꠖꠦꠈꠔꠣꠝ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦꠅ ꠖꠦꠈꠣꠁꠟꠤꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN48_12","002_48_12","GEN","48","12","12","ꠔꠦꠃ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠘꠦ, ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠢꠞꠣꠁꠀ ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_13","002_48_13","GEN","48","13","13","ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠟꠁꠀ, ꠒꠣꠁꠘ ꠀꠔ ꠖꠤꠀ ꠀꠚꠞꠣꠁꠝꠞꠦ ꠗꠞꠤꠀ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠃ ꠉꠣꠟꠣꠔ, ꠀꠞ ꠛꠣꠃ ꠀꠔ ꠖꠤꠀ ꠝꠣꠘꠡꠣꠞꠦ ꠗꠞꠤꠀ ꠁꠍꠞꠣꠁꠟꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ ꠀꠘꠤꠀ ꠀꠎꠤꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_14","002_48_14","GEN","48","14","14","ꠅꠁꠟꠦ ꠁꠍꠞꠣꠁꠟꠞ ꠘꠤꠎꠞ ꠀꠈꠟꠦ, ꠔꠣꠘ ꠀꠔ ꠀꠠꠣ-ꠀꠠꠤ ꠇꠞꠤꠀ, ꠒꠣꠁꠘꠞ ꠀꠔ ꠢꠥꠞꠥ ꠙꠥꠀ ꠀꠚꠞꠣꠁꠝꠞ ꠝꠣꠕꠣꠔ ꠀꠞ ꠁꠃꠍꠥꠚꠞ ꠛꠠ ꠙꠥꠀ ꠝꠣꠘꠡꠣꠞ ꠝꠣꠕꠣꠔ ꠕꠁꠟꠣ ꠔꠣꠘ ꠛꠣꠃ ꠀꠔ। ");
INSERT INTO syls_vpl VALUES ("GN48_15","002_48_15","GEN","48","15","15","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠖꠥꠀ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠢꠃ ꠀꠟ꠆ꠟꠣ, ꠎꠣꠘ ꠝꠞ꠆ꠎꠤꠄ ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ, ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠀꠞ ꠁꠍꠢꠣꠇꠦ ꠌꠟꠔꠣ, ꠢꠃ ꠀꠟ꠆ꠟꠣ, ꠎꠦꠁꠘ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠀꠁꠎ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠣꠞꠦ ꠙꠣꠟꠤꠀ ꠀꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("GN48_16","002_48_16","GEN","48","16","16","ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠢꠇꠟ ꠝꠍꠤꠛꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠅꠃ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠄꠞꠣꠞꠦ ꠖꠤꠀꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠀꠞ ꠁꠍꠢꠣꠇ ꠀꠞ ꠀꠝꠣꠞ ꠘꠣꠝ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠃꠇ। ꠖꠥꠘꠤꠀꠁꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣꠞ ꠛꠃꠔ ꠉꠥꠡ꠆ꠐꠤ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("GN48_17","002_48_17","GEN","48","17","17","ꠛꠣꠚꠦ ꠔꠣꠘ ꠒꠣꠁꠘ ꠀꠔ ꠀꠚꠞꠣꠁꠝꠞ ꠝꠣꠕꠣꠔ ꠞꠣꠈꠟꠣ ꠇꠞꠤ ꠁꠃꠍꠥꠚ ꠛꠦꠎꠣꠞ ꠅꠁꠉꠦꠟꠣ। ꠀꠞ ꠀꠚꠞꠣꠁꠝꠞ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ, ꠝꠣꠘꠡꠣꠞ ꠝꠣꠕꠣꠔ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ, ꠔꠣꠘ ꠛꠣꠚꠞ ꠀꠔ ꠃꠌꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_18","002_48_18","GEN","48","18","18","ꠔꠣꠁꠘ ꠀꠔꠅ ꠗꠞꠤꠀ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ, ꠁ ꠟꠣꠈꠣꠘ ꠘꠣꠄ। ꠅꠃꠘꠥ ꠀꠝꠣꠞ ꠛꠠ ꠙꠥꠀ, ꠔꠦ ꠀꠙꠘꠣꠞ ꠒꠣꠁꠘ ꠀꠔ ꠔꠣꠞ ꠝꠣꠕꠣꠔ ꠞꠣꠈꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN48_19","002_48_19","GEN","48","19","19","ꠅꠁꠟꠦ ꠔꠣꠘ ꠛꠣꠚꠦ ꠘꠣ-ꠈꠥꠡ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣꠞꠦ, ꠀꠝꠤ ꠁꠔꠣ ꠎꠣꠘꠤ, ꠀꠝꠤ ꠁꠔꠣ ꠎꠣꠘꠤꠞꠦ ꠙꠥꠔ। ꠔꠣꠞꠅ ꠄꠇ ꠎꠣꠔꠤ ꠅꠁꠛ ꠀꠞ ꠝꠢꠣꠘ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠔꠣꠞ ꠢꠥꠞꠥ ꠜꠣꠁ ꠔꠣꠞ ꠌꠣꠁꠔꠦꠅ ꠝꠢꠣꠘ ꠅꠁꠛ, ꠀꠞ ꠔꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠛꠃꠔ ꠉꠥꠡ꠆ꠐꠤ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("GN48_20","002_48_20","GEN","48","20","20","ꠁꠍꠞꠣꠁꠟꠦ ꠄꠞꠛꠣꠖꠦ ꠅꠃ ꠖꠥꠁꠅ ꠘꠣꠔꠤꠞꠦ ꠖꠥꠀ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠀ ꠇꠞꠟꠦ ꠅꠃꠟꠣ ꠇꠁꠛꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠀꠚꠞꠣꠁꠝ ꠀꠞ ꠝꠣꠘꠡꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ।” ꠅꠃꠟꠣ ꠔꠣꠁꠘ ꠝꠣꠘꠡꠣꠞ ꠌꠣꠁꠔꠦ ꠀꠚꠞꠣꠁꠝꠞꠦ ꠛꠠ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_21","002_48_21","GEN","48","21","21","ꠢꠦꠡꠦ ꠢꠎꠞꠔ ꠁꠍꠞꠣꠁꠟꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠅ, ꠀꠝꠣꠞ ꠝꠞꠘꠞ ꠅꠇ꠆ꠔ ꠀꠁꠌ꠆ꠌꠦ। ꠀꠟ꠆ꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠛꠣ, ꠀꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠖꠦꠡꠅ ꠘꠤꠌ꠆ꠌꠄ ꠚꠤꠞꠣꠁꠀ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN48_22","002_48_22","GEN","48","22","22","ꠔꠥꠝꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠌꠣꠁꠔꠦ ꠔꠥꠝꠣꠞꠦ ꠄꠇ ꠛꠣꠐ ꠛꠦꠡꠤ ꠖꠤꠟꠣꠝ। ꠅꠃ ꠛꠣꠐ ꠔ ꠡꠤꠈꠤꠝ ꠄꠟꠣꠇꠣ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠔꠟꠥꠀꠞ-ꠗꠘꠥꠇ ꠖꠤꠀ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠘꠍꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN49_1","002_49_1","GEN","49","1","1","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠢꠇ꠆ꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠅꠅ। ꠜꠛꠤꠡꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠤꠟꠣ ꠎꠣꠁꠛ, ꠁꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GN49_2","002_49_2","GEN","49","2","2","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀꠂꠘ, ꠔꠥꠝꠞꠣ ꠄꠇꠈꠣꠘꠅ ꠀꠅ; ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠥꠟꠤ ꠢꠥꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("GN49_3","002_49_3","GEN","49","3","3","ꠞꠥꠛꠦꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠠ ꠙꠥꠀ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠟ, ꠀꠝꠣꠞ ꠎꠥꠀꠘꠇꠤꠞ ꠙꠄꠟꠣ ꠚꠟ; ꠔꠥꠝꠤ ꠢꠇꠟ ꠕꠣꠇꠤ ꠔꠦꠎꠤ ꠀꠞ ꠢꠤꠝ꠆ꠝꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("GN49_4","002_49_4","GEN","49","4","4","ꠔꠥꠝꠤ ꠃꠔꠞꠣꠁꠟ ꠉꠞꠝ ꠙꠣꠘꠤꠞ ꠟꠣꠈꠣꠘ, ꠔꠥꠝꠣꠞ ꠛꠠꠣꠁ ꠞꠁꠔ ꠘꠣꠄ; ꠔꠥꠝꠤ ꠀꠙꠘ ꠛꠣꠚꠞ ꠛꠤꠍꠘꠣꠔ ꠉꠦꠍ, ꠢꠣꠔꠘ ꠝꠣʼꠞ ꠟꠉꠦ ꠘꠣꠙꠣꠇꠤ ꠇꠣꠝ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("GN49_5","002_49_5","GEN","49","5","5","ꠡꠤꠝꠤꠅꠘ ꠀꠞ ꠟꠦꠛꠤ ꠖꠥꠁ ꠜꠣꠁ; ꠔꠣꠞꠣꠞ ꠔꠟꠥꠀꠞ ꠎꠣꠟꠤꠝꠞ ꠀꠔꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("GN49_6","002_49_6","GEN","49","6","6","ꠅ ꠀꠝꠣꠞ ꠎꠣꠘ, ꠔꠣꠞꠣꠞ ꠝꠎꠟꠤꠍꠅ ꠢꠣꠝꠣꠁꠅ ꠘꠣ; ꠅ ꠀꠝꠣꠞ ꠡꠣꠘ, ꠔꠣꠞꠣꠞ ꠡꠝꠣꠎꠅ ꠎꠣꠁꠅ ꠘꠣ। ꠔꠣꠞꠣ ꠉꠥꠍꠣ ꠇꠞꠤ ꠈꠥꠘ ꠇꠞꠟ; ꠀꠠꠥꠀꠝꠤ ꠇꠞꠤ ꠛꠤꠍꠣꠟꠞ ꠞꠉ ꠇꠣꠐꠟ। ");
INSERT INTO syls_vpl VALUES ("GN49_7","002_49_7","GEN","49","7","7","ꠔꠣꠞꠣꠞ ꠉꠥꠍꠣ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ, ꠁꠔꠣ ꠛꠠ ꠛꠦꠎꠥꠁꠔꠣ; ꠟꠣꠘ꠆ꠘꠔꠤ ꠔꠣꠞꠣꠞ ꠎꠥꠟꠥꠝ, ꠁꠔꠣ ꠔ ꠙꠣꠡꠣꠘ। ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠁꠀꠇꠥꠛꠞ ꠝꠣꠎꠦ ꠛꠣꠐꠤꠝꠥ; ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠍꠤꠔ꠆ꠞꠣꠁ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GN49_8","002_49_8","GEN","49","8","8","ꠄꠢꠥꠖꠣ, ꠔꠥꠝꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠥꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠛꠣ; ꠔꠥꠝꠤ ꠖꠥꠡꠝꠘꠞ ꠉꠞ꠆ꠖꠘꠣꠔ ꠗꠞꠛꠣꠄ; ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠦ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN49_9","002_49_9","GEN","49","9","9","ꠔꠥꠝꠤ ꠔ ꠡꠤꠋꠢꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠄꠢꠥꠖꠣ। ꠔꠥꠝꠤ ꠡꠤꠇꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠀ ꠢꠞꠤꠀ ꠀꠁꠟꠣꠄ; ꠢꠦ ꠡꠤꠋꠢꠞ ꠟꠣꠈꠣꠘ ꠟꠦꠐꠤꠀ ꠢꠥꠔꠤꠀ ꠉꠠꠤꠀꠁꠟ; ꠡꠤꠋꠢꠤꠞꠦ ꠇꠦꠉꠥꠄ ꠊꠥꠝ ꠜꠣꠋꠉꠣꠁꠔ? ");
INSERT INTO syls_vpl VALUES ("GN49_10","002_49_10","GEN","49","10","10","ꠄꠢꠥꠖꠣꠞ ꠀꠔ ꠕꠘꠦ ꠔ ꠞꠣꠎ-ꠟꠣꠑꠤ ꠢꠞꠔ ꠘꠣꠄ; ꠔꠣꠞ ꠖꠥꠁꠅ ꠙꠣꠅꠞ ꠝꠣꠎ ꠕꠘꠦ ꠛꠤꠌꠣꠞꠞ ꠉꠖꠣ ꠎꠣꠁꠔ ꠘꠣꠄ; ꠎꠔꠖꠤꠘ ꠡꠤꠟꠅ ꠘꠣ ꠀꠁꠛꠣ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤ ꠔꠣꠘ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GN49_11","002_49_11","GEN","49","11","11","ꠢꠦ ꠀꠋꠉꠥꠞ ꠉꠣꠍꠅ ꠛꠣꠘꠛ ꠔꠣꠞ ꠉꠣꠗꠣ; ꠀꠋꠉꠥꠞꠞ ꠡꠥꠘ꠆ꠖꠞ ꠒꠣꠟꠅ ꠛꠣꠘꠛ ꠉꠣꠗꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣ; ꠟꠣꠟ ꠀꠋꠉꠥꠞꠞ ꠞꠡꠖꠤ ꠗꠥꠁꠛ ꠔꠣꠞ ꠎꠥꠛ꠆ꠛꠣ, ꠀꠋꠉꠥꠞꠞ ꠟꠃꠖꠤ ꠇꠞꠛ ꠟꠦꠛꠣꠍ ꠍꠚꠣ। ");
INSERT INTO syls_vpl VALUES ("GN49_12","002_49_12","GEN","49","12","12","ꠔꠣꠞ ꠌꠃꠈ ꠀꠋꠉꠥꠞꠞ ꠞꠡꠦ ꠟꠣꠟ ꠐꠇꠐꠇꠣ, ꠀꠞ ꠔꠣꠞ ꠖꠣꠔ ꠖꠥꠗꠞ ꠟꠣꠈꠣꠘ ꠗꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN49_13","002_49_13","GEN","49","13","13","ꠍꠛꠥꠟꠘ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠅ ꠛꠡꠔ ꠇꠞꠤꠛ, ꠢꠦ ꠎꠣꠎ ꠜꠤꠠꠣꠘꠤꠞ ꠊꠣꠐ ꠅꠁꠛ, ꠍꠤꠖꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞ ꠡꠤꠝꠣꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN49_14","002_49_14","GEN","49","14","14","ꠁꠍꠣꠈꠞ ꠄꠉꠥ ꠛꠟꠀꠟꠣ ꠉꠣꠗꠣ, ꠢꠦ ꠈꠥꠅꠠꠞ ꠜꠤꠔꠞꠦ ꠢꠥꠔꠦ। ");
INSERT INTO syls_vpl VALUES ("GN49_15","002_49_15","GEN","49","15","15","ꠢꠦ ꠖꠦꠈꠟ ꠎꠤꠞꠣꠘꠤꠞ ꠎꠣꠉꠣꠈꠣꠘ ꠜꠣꠟꠣ, ꠖꠦꠡꠈꠣꠘ ꠡꠥꠘ꠆ꠖꠞ; ꠔꠦꠃ ꠉꠣꠁꠐ ꠛꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖ ꠟꠣꠝꠣꠁꠟ, ꠀꠞ ꠎꠥꠞꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GN49_16","002_49_16","GEN","49","16","16","ꠖꠣꠘꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛ, ꠁꠍꠞꠣꠁꠟꠞ ꠄꠇ ꠉꠥꠡ꠆ꠐꠤꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GN49_17","002_49_17","GEN","49","17","17","ꠢꠦ ꠅꠁꠛ ꠡꠠꠇꠞ ꠗꠣꠞꠞ ꠢꠣꠚ, ꠙꠕꠞ ꠛꠤꠡꠀꠟꠣ ꠀꠟꠖ; ꠎꠦꠉꠤꠄ ꠊꠥꠠꠣꠞ ꠙꠣꠅꠔ ꠇꠣꠝꠠ ꠝꠣꠞꠦ, ꠊꠥꠠ-ꠍꠅꠀꠞ ꠈꠞꠦꠖꠤ ꠃꠟꠐꠤꠀ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("GN49_18","002_49_18","GEN","49","18","18","ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠘꠣꠎꠣꠔꠞ ꠝꠥꠈꠣ ꠌꠣꠁ ꠞꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN49_19","002_49_19","GEN","49","19","19","ꠍꠣꠖꠥꠞꠦ ꠟꠥꠐꠞꠣ ꠖꠟꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠛ, ꠛꠣꠖꠦ ꠢꠦ-ꠅ ꠔꠣꠞꠣꠞ ꠈꠞꠦꠖꠤ ꠟꠥꠐꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("GN49_20","002_49_20","GEN","49","20","20","ꠀꠡꠤꠞꠞ ꠈꠥꠛ ꠜꠣꠟꠣ ꠚꠡꠟ ꠚꠟꠤꠛ, ꠢꠦ ꠛꠣꠖꠡꠣꠞ ꠎꠥꠇꠣ ꠈꠣꠘꠤ ꠎꠥꠉꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN49_21","002_49_21","GEN","49","21","21","ꠘꠙ꠆ꠔꠣꠟꠤ ꠅꠁꠟ ꠍꠣꠠꠣ ꠢꠞꠤꠘꠤ, ꠔꠣꠞ ꠝꠥꠈꠅ ꠀꠍꠦ ꠝꠤꠑꠣ ꠝꠤꠑꠣ ꠝꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("GN49_22","002_49_22","GEN","49","22","22","ꠁꠃꠍꠥꠚ ꠚꠟꠀꠟꠣ ꠉꠣꠍꠞ ꠒꠣꠟ, ꠁꠘ꠆ꠖꠣꠞꠣꠞ ꠗꠣꠞꠞ ꠚꠟꠀꠟꠣ ꠉꠣꠍꠞ ꠒꠣꠟ; ꠔꠣꠞ ꠒꠣꠟꠣꠁꠘ ꠛꠦꠠ ꠙꠣꠞ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GN49_23","002_49_23","GEN","49","23","23","ꠔꠤꠞ-ꠗꠘꠥꠇ ꠀꠟꠣꠁꠘ꠆ꠔꠦ ꠔꠣꠞꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠔꠇꠟꠤꠚ ꠖꠤꠍꠟꠣ, ꠔꠤꠞ ꠝꠣꠞꠤꠀ ꠔꠣꠞꠦ ꠛꠦꠇꠣꠄꠖꠣꠔ ꠚꠣꠟꠣꠁꠍꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("GN49_24","002_49_24","GEN","49","24","24","ꠅꠁꠟꠦ ꠔꠣꠞ ꠗꠘꠥꠇ ꠝꠎꠛꠥꠔ ꠞꠁꠟ, ꠔꠣꠞ ꠀꠔꠞ ꠢꠘꠣꠔ ꠛꠟ ꠞꠁꠟ; ꠁꠀꠇꠥꠛꠞ ꠢꠃ ꠝꠢꠣꠘ ꠡꠇ꠆ꠔꠤꠀꠟꠣꠞ ꠀꠔ ꠖꠤꠀ, ꠎꠦꠁꠘ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠡꠞꠄ ꠐꠤꠟ꠆ꠟꠣ, ꠔꠣꠘꠞꠦ ꠖꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("GN49_25","002_49_25","GEN","49","25","25","ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠢꠃ ꠀꠟ꠆ꠟꠣꠞꠦ ꠖꠤꠀ, ꠎꠦꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ; ꠢꠃ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘꠞꠦ ꠖꠤꠀ, ꠎꠦꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠛꠣ; ꠃꠙꠞꠦ ꠕꠅꠀ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠟꠣꠝꠞꠣ ꠛꠞꠇꠔꠦ, ꠔꠟꠦ ꠛꠤꠍꠣꠁꠟ ꠙꠣꠘꠤ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠀ ꠏꠞꠘꠣꠞ ꠛꠞꠇꠔꠦ, ꠛꠥꠇꠥꠞ ꠖꠥꠗ ꠀꠞ ꠙꠦꠐ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠀ ꠛꠞꠇꠔꠦ। ");
INSERT INTO syls_vpl VALUES ("GN49_26","002_49_26","GEN","49","26","26","ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠖꠥꠀ ꠕꠣꠇꠤ, ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠖꠦꠅꠀ ꠖꠥꠀ ꠛꠃꠔ ꠜꠣꠟꠣ ꠅꠃꠇ; ꠁꠔꠣ ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠈꠣꠠꠣ ꠢꠣꠎꠣꠁꠟ ꠙꠣꠠ-ꠙꠞꠛꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠃꠇ। ꠢꠃ ꠖꠥꠀ ꠁꠃꠍꠥꠚꠞ ꠝꠣꠕꠣꠔ ꠙꠠꠃꠇ; ꠜꠣꠁꠀꠁꠘ ꠕꠣꠇꠤ ꠀꠟꠉꠞ ꠝꠣꠕꠣꠞ ꠔꠣꠟꠥꠔ ꠙꠠꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GN49_27","002_49_27","GEN","49","27","27","ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠅꠁꠟ ꠛꠠ-ꠛꠣꠊꠞ ꠟꠣꠈꠣꠘ, ꠢꠦ ꠛꠤꠀꠘꠦ ꠈꠣꠄ ꠡꠤꠇꠣꠞꠞ ꠉꠥꠡ꠆ꠔ, ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣꠄ ꠛꠤꠟꠣꠄ ꠟꠥꠐꠞ ꠝꠣꠟ।” ");
INSERT INTO syls_vpl VALUES ("GN49_28","002_49_28","GEN","49","28","28","ꠄꠞꠣ ꠅꠁꠟꠣ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠉꠥꠡ꠆ꠐꠤ, ꠔꠣꠞꠣꠞ ꠛꠣꠚꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀꠞ ꠡꠝꠄ ꠅꠃꠟꠣ ꠇꠁꠟꠣ। ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠙꠣꠅꠘꠣ ꠖꠥꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN49_29","002_49_29","GEN","49","29","29","ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠅꠍꠤꠅꠔ ꠇꠞꠣꠁꠟꠣ ꠎꠦꠘ, “ꠀꠝꠣꠞ ꠔ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ, ꠔꠦ ꠢꠤꠐ꠆ꠐꠤ ꠁꠚ꠆ꠞꠥꠘꠞ ꠎꠝꠤꠘꠞ ꠉꠥꠢꠣꠔ, ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠝꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("GN49_30","002_49_30","GEN","49","30","30","ꠁ ꠉꠥꠢꠣ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ, ꠝꠝ꠆ꠞꠤꠞ ꠗꠣꠞꠅ ꠝꠇꠙꠦꠟꠣꠞ ꠎꠝꠤꠔ। ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠢꠤꠐ꠆ꠐꠤ ꠁꠚ꠆ꠞꠥꠘꠞ ꠉꠦꠍ ꠕꠘꠦ ꠅꠃ ꠎꠝꠤꠘ ꠟꠁꠍꠟꠣ ꠇꠛꠞꠡ꠆ꠕꠣꠘ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN49_31","002_49_31","GEN","49","31","31","ꠅꠘꠅꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠀꠞ ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠔꠣꠘ ꠛꠤꠛꠤ ꠞꠦꠛꠦꠇꠣꠞꠦꠅ ꠅꠘꠅ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠀꠞ ꠀꠝꠤ ꠟꠦꠀꠞꠦꠅ ꠅꠘꠅ ꠖꠣꠚꠘ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GN49_32","002_49_32","GEN","49","32","32","ꠁ ꠎꠝꠤꠘ ꠀꠞ ꠄꠞ ꠝꠣꠎꠞ ꠉꠥꠢꠣ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠘꠦ ꠟꠁꠍꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN49_33","002_49_33","GEN","49","33","33","ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠅꠍꠤꠅꠔ ꠇꠞꠣ ꠡꠦꠡ ꠅꠁꠟꠦ, ꠛꠤꠍꠘꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠖꠥꠁꠅ ꠙꠣꠅ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠟꠣ ꠀꠞ ꠀꠈꠦꠞꠤ ꠖꠝ ꠍꠣꠠꠤꠀ ꠔꠣꠘ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("GN50_1","002_50_1","GEN","50","1","1","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠚꠞ ꠝꠥꠈꠞ ꠃꠙꠞꠦ ꠝꠥꠈ ꠟꠣꠉꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠤꠔꠣ ꠟꠣꠉꠟꠣ ꠀꠞ ꠔꠣꠘꠞꠦ ꠢꠥꠋꠉꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_2","002_50_2","GEN","50","2","2","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠅꠗꠤꠘꠞ ꠢꠦꠇꠤꠝ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠔꠣꠞꠣ ꠔꠣꠘ ꠛꠣꠚꠞ ꠟꠣꠡꠞꠦ ꠝꠝꠤ ꠛꠣꠘꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ। ꠔꠦꠃ ꠔꠣꠞꠣ ꠔꠣꠘ ꠉꠔꠞꠅ ꠝꠝꠤꠞ ꠝꠡꠟꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_3","002_50_3","GEN","50","3","3","ꠔꠣꠞꠣ ꠁ ꠇꠣꠝꠅ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠟꠣꠉꠣꠁꠟꠣ, ꠅꠃ ꠇꠣꠝꠅ ꠔ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘꠃ ꠟꠣꠉꠦ। ꠀꠞ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠔꠣꠘ ꠟꠣꠉꠤ ꠡꠔ꠆ꠔꠁꠞ ꠖꠤꠘ ꠜꠞꠤꠀ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_4","002_50_4","GEN","50","4","4","ꠅꠃ ꠀꠢꠣꠎꠣꠞꠤꠞ ꠖꠤꠘꠞ ꠛꠣꠖꠦ, ꠁꠃꠍꠥꠚꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠛꠣꠠꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠂꠘ, ꠔꠦ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠀꠝꠣꠞ ꠅꠃ ꠇꠕꠣꠈꠣꠘ ꠎꠣꠘꠣꠃꠇ꠆ꠇꠣ ꠎꠦꠘ। ");
INSERT INTO syls_vpl VALUES ("GN50_5","002_50_5","GEN","50","5","5","ꠛꠣꠛꠣꠄ ꠀꠝꠣꠞꠦ ꠇꠍꠝ ꠇꠞꠣꠁꠀ ꠇꠁꠍꠟꠣ, ‘ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔ ꠝꠞꠤꠎꠤꠝꠥ, ꠔꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠇꠞꠣ ꠇꠄꠛꠞꠅ ꠀꠝꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠤꠅ।’ ꠔꠦꠃ ꠅꠈꠘ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘꠞ ꠟꠣꠉꠤ, ꠖꠄꠀ ꠇꠞꠤ ꠀꠝꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠛꠣꠛꠣꠞꠦ ꠇꠄꠛꠞ ꠖꠤꠀꠃ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("GN50_6","002_50_6","GEN","50","6","6","ꠚꠦꠞꠣꠃꠘꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠍꠝ ꠇꠞꠣꠁꠍꠂꠘ, ꠔꠥꠝꠤ ꠉꠤꠀ ꠅꠃꠟꠣꠃ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN50_7","002_50_7","GEN","50","7","7","ꠔꠦꠃ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠖꠣꠚꠘꠞ ꠟꠣꠉꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ; ꠀꠞ ꠚꠦꠞꠣꠃꠘꠞ ꠢꠇꠟ ꠉꠥꠟꠣꠝꠦ, ꠔꠣꠘ ꠖꠞꠛꠣꠞꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠀꠞ ꠝꠤꠡꠞꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("GN50_8","002_50_8","GEN","50","8","8","ꠁꠃꠍꠥꠚꠞ ꠘꠤꠎꠞ ꠙꠞꠤꠛꠣꠞ, ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ ꠀꠞ ꠔꠣꠘ ꠛꠣꠚꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠉꠥꠡꠘꠅ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠀꠞ ꠉꠞꠥ-ꠝꠦꠠꠣꠞ ꠙꠣꠟꠣꠁꠘ ꠕꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_9","002_50_9","GEN","50","9","9","ꠔꠣꠞꠣ ꠛꠃꠔ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ ꠀꠞ ꠊꠥꠠ-ꠍꠅꠀꠞ ꠅꠇꠟ ꠟꠁꠀ ꠄꠇ ꠛꠤꠞꠣꠐ ꠖꠟ ꠢꠣꠎꠤꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_10","002_50_10","GEN","50","10","10","ꠀꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠀꠐꠣꠖꠞ ꠗꠣꠘ ꠝꠣꠠꠣꠞ ꠎꠣꠉꠣꠔ ꠉꠤꠀ, ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠡꠣꠔꠖꠤꠘ ꠗꠞꠤ ꠁꠃꠍꠥꠚꠞ ꠛꠣꠚꠞ ꠟꠣꠉꠤ ꠈꠥꠛ ꠀꠢꠣꠎꠣꠞꠤ ꠀꠞ ꠛꠤꠟꠣꠙ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_11","002_50_11","GEN","50","11","11","ꠀꠐꠣꠖꠞ ꠗꠣꠘ ꠝꠣꠠꠣꠞ ꠎꠣꠉꠣꠔ ꠔꠣꠞꠣꠞꠦ ꠁꠟꠣ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠣꠔ ꠖꠦꠈꠤꠀ, ꠢꠤ ꠖꠦꠡꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠁꠐꠣ ꠈꠥꠛ ꠛꠦꠎꠥꠁꠔꠣ ꠀꠢꠣꠎꠣꠞꠤ; ꠄꠞꠟꠣꠉꠤ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠞ ꠅꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠉꠦꠟ, ꠀꠛꠦꠟ-ꠝꠤꠡꠞꠄꠁꠝ ꠝꠣꠘꠤ, ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠀꠢꠣꠎꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("GN50_12","002_50_12","GEN","50","12","12","ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠎꠦꠟꠣ ꠅꠍꠤꠅꠔ ꠇꠞꠍꠟꠣ, ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_13","002_50_13","GEN","50","13","13","ꠔꠣꠞꠣ ꠔꠣꠘ ꠟꠣꠡ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠟꠁꠀ ꠉꠦꠟꠣ, ꠀꠞ ꠝꠝ꠆ꠞꠤꠞ ꠉꠦꠍꠦ ꠝꠇꠙꠦꠟꠣꠞ ꠎꠝꠤꠘꠞ, ꠉꠥꠢꠣꠞ ꠝꠣꠎꠦ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ। ꠁꠐꠣ ꠇꠛꠞꠡ꠆ꠕꠣꠘ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ, ꠢꠤꠐ꠆ꠐꠤ ꠁꠚ꠆ꠞꠥꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠟꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_14","002_50_14","GEN","50","14","14","ꠛꠣꠚꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚ, ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ ꠀꠞ ꠎꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣꠔ ꠟꠉꠦ ꠉꠦꠍꠟꠣ, ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠡꠞꠅ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_15","002_50_15","GEN","50","15","15","ꠛꠣꠚ ꠝꠞꠤꠉꠦꠍꠂꠘ ꠖꠦꠈꠤꠀ ꠁꠃꠍꠥꠚꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠟꠣ, ꠁꠃꠍꠥꠚꠦ ꠇꠤꠛꠣ ꠀꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠛ ꠀꠞ ꠀꠝꠞꠣ ꠔꠣꠞ ꠎꠦꠔꠣ ꠈꠦꠔꠤ ꠇꠞꠍꠤ, ꠅꠈꠘ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠛꠖꠟꠣ ꠟꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GN50_16","002_50_16","GEN","50","16","16","ꠔꠦꠃ ꠔꠣꠞꠣ ꠁꠃꠍꠥꠚꠞ ꠉꠦꠍꠦ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠛꠣꠚꠦ ꠝꠞꠣꠞ ꠀꠉꠦ ꠁ ꠅꠍꠤꠅꠔ ꠇꠞꠍꠟꠣ ꠎꠦꠘ, ");
INSERT INTO syls_vpl VALUES ("GN50_17","002_50_17","GEN","50","17","17","ꠔꠥꠝꠞꠣ ꠁꠃꠍꠥꠚꠞꠦ ꠅꠃ ꠇꠕꠣꠈꠣꠘ ꠇꠁꠅ, ꠔꠥꠝꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠥꠝꠣꠞ ꠎꠦꠔꠣ ꠈꠦꠔꠤ ꠇꠞꠍꠂꠘ, ꠖꠄꠀ ꠇꠞꠤ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠢꠤ ꠅꠁꠘ꠆ꠘꠣꠄ ꠀꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠅ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠅ।” ꠔꠣꠞꠣꠞ ꠝꠣꠔ ꠢꠥꠘꠤꠀ ꠁꠃꠍꠥꠚꠞ ꠇꠣꠘ꠆ꠖꠘ ꠀꠁꠟ꠆ꠟ। ");
INSERT INTO syls_vpl VALUES ("GN50_18","002_50_18","GEN","50","18","18","ꠛꠣꠖꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠔ ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("GN50_19","002_50_19","GEN","50","19","19","ꠅꠁꠟꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠀꠝꠤ ꠇꠥꠘꠥ ꠀꠟ꠆ꠟꠣꠞ ꠈꠟꠤꠚꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GN50_20","002_50_20","GEN","50","20","20","ꠔꠥꠝꠞꠣ ꠔ ꠀꠝꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠔꠣꠄ ꠌꠣꠁꠍꠟꠣꠄ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣꠞꠦ ꠜꠣꠟꠣꠁ ꠛꠣꠘꠣꠁꠟ꠆ꠟꠣ, ꠎꠦꠟꠣ ꠀꠁꠎ ꠖꠦꠈꠞꠣꠄ, ꠔꠦ ꠔꠣꠘ ꠈꠤꠀꠟ ꠀꠍꠤꠟ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_21","002_50_21","GEN","50","21","21","ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠝꠥ।” ꠔꠣꠁꠘ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠔꠣꠞꠣꠞꠦ ꠛꠥꠎ ꠖꠤꠟꠣ ꠀꠞ ꠈꠥꠡ ꠖꠤꠟꠦ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_22","002_50_22","GEN","50","22","22","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚ ꠀꠞ ꠔꠣꠘ ꠛꠣꠚꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠝꠤꠡꠞꠅ ꠛꠡꠔ ꠇꠞꠣꠔ ꠞꠁꠟꠣ। ꠁꠃꠍꠥꠚ ꠄꠇ-ꠡ ꠖꠡ ꠛꠞꠍ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_23","002_50_23","GEN","50","23","23","ꠔꠣꠁꠘ ꠀꠚꠞꠣꠁꠝꠞ ꠘꠣꠔꠤꠘꠡꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠦꠈꠟꠣ ꠀꠞ ꠝꠣꠘꠡꠣꠞ ꠙꠥꠀ ꠝꠣꠈꠤꠞꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠅ ꠁꠃꠍꠥꠚꠞ ꠀꠔꠅ ꠙꠄꠖꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GN50_24","002_50_24","GEN","50","24","24","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠔ ꠝꠃꠔꠞ ꠅꠇ꠆ꠔ ꠀꠁꠌ꠆ꠌꠦ, ꠘꠤꠌꠄ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠘꠎꠞ ꠞꠣꠈꠛꠣ। ꠔꠣꠁꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠔꠣ ꠇꠞꠤ ꠇꠍꠝ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣꠞꠦ ꠅꠘ ꠕꠣꠇꠤ ꠢꠃ ꠖꠦꠡꠅ ꠟꠁꠀ ꠎꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GN50_25","002_50_25","GEN","50","25","25","ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠅꠃ ꠅꠍꠤꠅꠔ ꠇꠞꠣꠁꠟꠣ, “ꠘꠤꠌꠄ ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠘꠎꠞ ꠇꠞꠛꠣ। ꠔꠦ ꠅꠘ ꠕꠣꠇꠤ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠀꠒ꠆ꠒꠤ ꠅꠇꠟ ꠔꠥꠟꠤꠀ ꠟꠁꠀ ꠎꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("GN50_26","002_50_26","GEN","50","26","26","ꠢꠦꠡꠦ ꠄꠇ-ꠡ ꠖꠡ ꠛꠞꠍ ꠛꠄꠅꠡꠅ ꠁꠃꠍꠥꠚ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠟꠣꠡꠞꠦ ꠈꠥꠡꠛꠥ-ꠝꠡꠟꠣꠖꠤ ꠝꠣꠈꠤꠀ ꠝꠝꠤ ꠛꠣꠘꠣꠁꠀ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠄꠇ ꠇꠣꠚꠘꠞ ꠛꠣꠇ꠆ꠡꠞ ꠜꠤꠔꠞꠦ ꠕꠁꠟꠣ॥");
INSERT INTO syls_vpl VALUES ("EX1_1","003_1_1","EXO","1","1","1","ꠀꠟ꠆ꠟꠣꠄ ꠢꠎꠞꠔ ꠁꠀꠇꠥꠛꠞ ꠘꠄꠀ ꠘꠣꠝ ꠖꠤꠍꠟꠣ ꠁꠍꠞꠣꠁꠟ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠛꠋꠡꠞ ꠘꠣꠝ ꠅꠁꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ। ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠛꠤꠛꠤꠘ-ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠞꠦ ꠟꠁꠀ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠦꠟꠣꠉꠤ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠟꠉꠦ ꠅꠁꠀ ꠎꠦꠞꠣ ꠉꠦꠟꠣ, ꠄꠞꠣꠞ ꠘꠣꠝ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("EX1_2","003_1_2","EXO","1","2","2","ꠞꠥꠛꠦꠘ, ꠡꠤꠝꠤꠅꠘ, ꠟꠦꠛꠤ, ꠄꠢꠥꠖꠣ, ");
INSERT INTO syls_vpl VALUES ("EX1_3","003_1_3","EXO","1","3","3","ꠁꠍꠣꠈꠞ, ꠍꠛꠥꠟꠘ, ꠛꠤꠘ-ꠁꠀꠝꠤꠘ, ");
INSERT INTO syls_vpl VALUES ("EX1_4","003_1_4","EXO","1","4","4","ꠖꠣꠘ, ꠘꠙ꠆ꠔꠣꠟꠤ, ꠍꠣꠖꠥ ꠀꠞ ꠀꠡꠤꠞ। ");
INSERT INTO syls_vpl VALUES ("EX1_5","003_1_5","EXO","1","5","5","ꠁꠀꠇꠥꠛꠞ ꠛꠋꠡꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠄ ꠝꠤꠟꠤꠀ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ ꠀꠍꠟꠣ। ꠀꠞ ꠁꠃꠍꠥꠚ ꠀꠉ ꠕꠣꠇꠤꠃ ꠝꠤꠡꠞꠅ ꠕꠣꠇꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_6","003_1_6","EXO","1","6","6","ꠛꠣꠖꠦ ꠁꠃꠍꠥꠚ, ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ, ꠀꠞ ꠢꠤ ꠀꠝꠟꠞ ꠢꠇꠟ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_7","003_1_7","EXO","1","7","7","ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠖꠞ ꠛꠋꠡꠗꠞ ꠛꠣꠠꠤꠀ ꠈꠥꠛ ꠛꠟꠀꠟꠣ ꠅꠁꠟꠣ। ꠄꠞꠣ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤꠀ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡ ꠜꠞꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_8","003_1_8","EXO","1","8","8","ꠄꠞꠝꠣꠎꠦ ꠝꠤꠡꠞꠅ ꠄꠇꠎꠘ ꠘꠄꠀ ꠛꠣꠖꠡꠣ ꠅꠁꠟꠣ, ꠄꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠌꠤꠘꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_9","003_1_9","EXO","1","9","9","ꠄꠁꠘ ꠘꠤꠎꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠌꠣꠁꠀ ꠖꠦꠈꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠦꠡꠤꠅ ꠀꠞ ꠛꠟꠀꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EX1_10","003_1_10","EXO","1","10","10","ꠔꠦ ꠀꠅ, ꠀꠝꠞꠣ ꠄꠇ ꠚꠘ꠆ꠖꠤ ꠇꠞꠤ, ꠁꠔꠣ ꠎꠦꠘꠥ ꠀꠞ ꠘꠣ ꠛꠣꠠꠂꠘ। ꠀꠞꠘꠣꠄ ꠔꠣꠞꠣ ꠛꠣꠠꠤꠀ ꠢꠦꠡꠦ ꠎꠥꠖ꠆ꠖꠞ ꠇꠣꠟꠅ ꠀꠝꠞꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠀꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠛ, ꠛꠣꠖꠦ ꠀꠝꠞꠣꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠎꠣꠁꠛꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX1_11","003_1_11","EXO","1","11","11","ꠔꠦꠃ ꠔꠣꠞꠣ ꠡꠞ꠆ꠖꠣꠞ ꠟꠣꠉꠣꠁꠟꠣ ꠄꠞꠣꠞꠦ ꠝꠣꠞꠤꠀ-ꠗꠞꠤꠀ ꠎꠥꠞ-ꠎꠥꠟꠥꠝ ꠇꠞꠤꠀ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ। ꠄꠞꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠚꠡꠟ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠙꠤꠕꠥꠝ ꠀꠞ ꠞꠣꠝꠣꠡꠦꠡ ꠘꠣꠝꠞ ꠖꠥꠁꠐꠣ ꠐꠣꠃꠘꠅ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_12","003_1_12","EXO","1","12","12","ꠅꠁꠟꠦ ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠔ ꠛꠦꠡꠤ ꠎꠥꠞ-ꠎꠥꠟꠥꠝ ꠇꠞꠣ ꠅꠁꠟ, ꠄꠞꠣꠅ ꠅꠔ ꠛꠦꠡꠤ ꠛꠣꠠꠤꠟꠣ ꠀꠞ ꠍꠤꠔ꠆ꠞꠤꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠈꠥꠛ ꠒꠞꠣꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_13","003_1_13","EXO","1","13","13","ꠒꠞꠣꠁꠀ ꠄꠞꠣꠞꠦꠖꠤ ꠀꠞꠅ ꠇꠑꠤꠘ ꠇꠣꠝ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_14","003_1_14","EXO","1","14","14","ꠝꠣꠐꠤ ꠇꠣꠝ, ꠁꠐꠞ ꠇꠣꠝ ꠀꠞ ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠇꠡ꠆ꠐꠞ ꠇꠣꠝ ꠇꠞꠣꠁꠀ ꠄꠞꠣꠞ ꠎꠣꠘꠞꠦ ꠔꠤꠔ꠆ꠔꠣ ꠛꠣꠘꠣꠁꠟꠤꠟ। ꠀꠞ ꠔꠣꠞꠣ ꠎꠥꠞ-ꠎꠥꠟꠥꠝ ꠇꠞꠤꠀ ꠘꠤꠡ꠆ꠑꠥꠞ-ꠙꠣꠡꠣꠘꠞ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("EX1_15","003_1_15","EXO","1","15","15","ꠛꠣꠖꠦ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣꠄ ꠡꠤꠚ꠆ꠞꠣ ꠀꠞ ꠚꠥꠀ ꠘꠣꠝꠞ ꠖꠥꠁꠎꠘ ꠁꠛꠞꠣꠘꠤ ꠖꠣꠁ ꠛꠦꠐꠤꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX1_16","003_1_16","EXO","1","16","16","“ꠔꠥꠝꠞꠣ ꠁꠛꠞꠣꠘꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠖꠣꠁ ꠉꠤꠞꠤꠔ ꠉꠤꠀ, ꠁꠔꠣꠞ ꠙꠥꠀꠂꠘ ꠙꠄꠖꠣ ꠅꠁꠟꠦꠃ ꠝꠣꠞꠤꠟꠣꠁꠅ, ꠈꠣꠟꠤ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠎꠤꠔꠣ ꠞꠣꠈꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX1_17","003_1_17","EXO","1","17","17","ꠅꠁꠟꠦ ꠢꠤ ꠖꠣꠁ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠔꠣ ꠉꠔꠤꠇꠦ, ꠝꠤꠡꠞꠤ ꠛꠣꠖꠡꠣꠞ ꠢꠥꠇꠥꠝ ꠘꠣ ꠝꠣꠘꠤꠀ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦꠅ ꠎꠤꠔꠣ ꠞꠣꠈꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_18","003_1_18","EXO","1","18","18","ꠔꠦꠃ ꠛꠣꠖꠡꠣꠄ ꠄꠞꠣꠞꠦ ꠘꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁꠔꠣ ꠇꠣꠝ ꠇꠦꠘꠦ ꠇꠞꠟꠣꠄ? ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠇꠦꠘꠦ ꠎꠤꠔꠣ ꠞꠣꠈꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("EX1_19","003_1_19","EXO","1","19","19","ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠁꠛꠞꠣꠘꠤ ꠛꠦꠐꠤꠘ ꠝꠤꠡꠞꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ, ꠔꠣꠞꠣ ꠛꠃꠔ ꠛꠟꠀꠟꠣ। ꠖꠣꠁꠛꠦꠐꠤ ꠔꠣꠞꠣꠞ ꠇꠣꠍꠣꠔ ꠎꠣꠁꠛꠣꠞ ꠀꠉꠦꠃ ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣ ꠅꠁꠎꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX1_20","003_1_20","EXO","1","20","21","ꠅꠃ ꠖꠥꠁꠅ ꠛꠦꠐꠤꠄ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠔꠣ ꠇꠞꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠞꠢꠝꠔ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦꠅ ꠀꠅꠟꠣꠖ ꠖꠤꠟꠣ। ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠅ ꠀꠞꠅ ꠛꠦꠡꠤ ꠇꠞꠤ ꠛꠣꠠꠤꠀ ꠈꠥꠛ ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX1_22","003_1_22","EXO","1","22","22","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠚꠦꠞꠣꠃꠘꠦ ꠘꠤꠎꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠇꠥꠘꠥ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠦꠃ ꠔꠥꠝꠞꠣ ꠘꠤꠟ ꠘꠖꠅ ꠚꠣꠟꠣꠁ ꠖꠤꠅ, ꠈꠣꠟꠤ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠎꠤꠔꠣ ꠞꠣꠈꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX2_1","003_2_1","EXO","2","1","1","ꠄꠞꠝꠣꠎꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠇ ꠇꠁꠘꠣꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_2","003_2_2","EXO","2","2","2","ꠅꠃ ꠇꠁꠘꠣꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟ। ꠙꠥꠀꠉꠥ ꠖꠦꠈꠔꠦ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠅꠀꠄ, ꠔꠤꠘ ꠝꠣꠡ ꠗꠞꠤ ꠟꠥꠇꠣꠁ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_3","003_2_3","EXO","2","3","3","ꠢꠦꠡꠦ ꠀꠞ ꠟꠥꠇꠣꠁꠔꠣ ꠘꠣ ꠙꠣꠞꠤꠀ, ꠔꠣꠁꠘ ꠘꠟ-ꠈꠣꠉꠠꠣꠞ ꠄꠇ ꠐꠥꠇꠞꠤ ꠟꠁꠟꠣ। ꠅꠃ ꠐꠥꠇꠞꠤꠔ ꠝꠣꠐꠤꠀ ꠔꠦꠟ ꠀꠞ ꠀꠟꠇꠣꠔꠞꠣ ꠟꠦꠙꠤꠀ ꠅꠉꠥꠞ ꠜꠤꠔꠞꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠢꠣꠞꠣꠁꠀ, ꠉꠣꠋꠉꠞ ꠌꠞꠞ ꠘꠟ ꠛꠘꠞ ꠝꠣꠎꠦ ꠕꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_4","003_2_4","EXO","2","4","4","ꠀꠞ ꠄꠞ ꠇꠤꠔꠣ ꠖꠡꠣ ꠅꠄ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠞ ꠛꠁꠘ ꠖꠥꠞꠁ ꠃꠛꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX2_5","003_2_5","EXO","2","5","5","ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠠꠤ ꠉꠣꠋꠉꠅ ꠘꠣꠅꠀꠔ ꠀꠁꠟꠣ। ꠉꠣꠋꠉꠞ ꠙꠣꠞꠅ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤ ꠅꠇꠟ ꠊꠥꠞꠣꠊꠥꠞꠤꠔ ꠀꠍꠤꠟ। ꠔꠣꠁꠘ ꠌꠞꠞ ꠘꠟ-ꠈꠣꠉꠠꠣꠞ ꠝꠣꠎꠦ ꠅꠃ ꠐꠥꠇꠞꠤ ꠖꠦꠈꠤꠀ, ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠐꠥꠇꠞꠤꠉꠥ ꠀꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX2_6","003_2_6","EXO","2","6","6","ꠐꠥꠇꠞꠤꠞ ꠒꠣꠟꠣ ꠈꠥꠟꠤꠀ ꠖꠦꠈꠟꠣ, ꠄꠞ ꠜꠤꠔꠞꠦ ꠄꠇ ꠙꠥꠀꠄ ꠇꠣꠘ꠆ꠖꠦꠞ। ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠝꠣꠄꠀ ꠟꠣꠉꠤꠉꠦꠟ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠡ, ꠁꠉꠥ ꠔ ꠇꠥꠘꠥ ꠁꠛꠞꠣꠘꠤꠞ ꠙꠥꠀ।” ");
INSERT INTO syls_vpl VALUES ("EX2_7","003_2_7","EXO","2","7","7","ꠅꠃ ꠡꠝꠄ ꠙꠥꠀꠞ ꠛꠁꠘ ꠀꠁꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠠꠤꠞꠦ ꠎꠤꠇꠣꠁꠟ, “ꠞꠣꠘꠤ ꠝꠣ, ꠁ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠖꠥꠗ ꠈꠣꠅꠀꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠁꠛꠞꠣꠘꠤ ꠛꠦꠐꠤꠞꠦ ꠙꠣꠁꠟꠦ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠔꠣꠝ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("EX2_8","003_2_8","EXO","2","8","8","ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠠꠤꠄ ꠇꠁꠟꠣ, “ꠎꠣ ꠀꠘꠉꠤ।” ꠔꠦꠃ ꠙꠥꠠꠤꠄ ꠉꠤꠀ ꠙꠥꠀꠞ ꠝꠣʼꠞꠦ ꠟꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX2_9","003_2_9","EXO","2","9","9","ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠠꠤꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅꠉ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠦꠔꠘ ꠖꠤꠝꠥꠘꠦ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠅꠁꠀ ꠅꠃ ꠙꠥꠀꠉꠥꠞꠦ ꠛꠥꠇꠥꠞ ꠖꠥꠗ ꠈꠣꠅꠀꠅ।” ꠅꠃ ꠢꠤ ꠛꠦꠐꠤꠄ ꠘꠤꠀ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠖꠥꠗ ꠈꠣꠅꠀꠁꠀ ꠙꠣꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_10","003_2_10","EXO","2","10","10","ꠙꠥꠀꠉꠥ ꠇꠤꠍꠥ ꠛꠠ ꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠘꠤꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠠꠤꠞ ꠉꠦꠍꠦ ꠖꠤꠟꠣꠁꠟꠣ। ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠠꠤꠄ ꠄꠘꠞꠦ ꠘꠤꠎꠞ ꠙꠥꠀ ꠛꠣꠘꠣꠁꠀ ꠙꠣꠟꠤꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠣꠞꠦ ꠙꠣꠘꠤ ꠕꠣꠇꠤ ꠐꠣꠘꠤꠀ ꠔꠥꠟꠍꠤ।” ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠝꠥꠍꠣ ꠝꠣꠘꠤ, ꠐꠣꠘꠤꠀ ꠔꠥꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_11","003_2_11","EXO","2","11","11","ꠢꠦꠡꠦ ꠝꠥꠍꠣ ꠛꠠ ꠅꠁꠉꠦꠟꠦ ꠄꠇꠖꠤꠘ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠔꠣꠞꠣ ꠈꠥꠛ ꠇꠡ꠆ꠐꠞ ꠇꠣꠝ ꠇꠞꠞꠣ। ꠄꠞꠝꠣꠎꠦ ꠖꠦꠈꠟꠣ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠁꠛꠞꠣꠘꠤ ꠎꠣꠔꠤꠞ ꠄꠇ ꠛꠦꠐꠣꠞꠦ, ꠄꠇ ꠝꠤꠡꠞꠤꠄ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("EX2_12","003_2_12","EXO","2","12","12","ꠖꠦꠈꠤꠀ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠌꠣꠁꠀ ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠘꠣ ꠖꠦꠈꠣꠄ, ꠔꠣꠁꠘ ꠢꠃ ꠝꠤꠡꠞꠤꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠀ ꠛꠣꠟꠥꠞ ꠔꠟꠦ ꠉꠣꠠꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_13","003_2_13","EXO","2","13","13","ꠛꠣꠖꠞ ꠖꠤꠘꠅ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠞꠦ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠖꠥꠁꠎꠘ ꠁꠛꠞꠣꠘꠤꠄ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠝꠣꠞꠣ-ꠝꠣꠞꠤ ꠇꠞꠦꠞ। ꠅꠃ ꠔꠣꠁꠘ ꠖꠥꠡꠤ ꠎꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞꠦ ꠇꠦꠘꠦ ꠝꠣꠞꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("EX2_14","003_2_14","EXO","2","14","14","ꠢꠦ ꠇꠁꠟ, “ꠔꠥꠝꠣꠞꠦ ꠇꠦꠉꠤꠄ ꠀꠝꠞꠣꠞ ꠢꠣꠇꠤꠝ ꠛꠣꠘꠣꠁꠀ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠔ ꠙꠣꠑꠣꠁꠟ? ꠇꠣꠁꠟ ꠎꠦꠟꠣ ꠢꠃ ꠝꠤꠡꠞꠤꠞꠦ ꠈꠥꠘ ꠇꠞꠍ, ꠅꠃꠟꠣ ꠀꠝꠣꠞꠦꠅ ꠈꠥꠘ ꠇꠞꠤꠟꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ ꠘꠤ?” ꠅꠃ ꠝꠥꠍꠣꠄ ꠒꠞꠣꠁꠉꠦꠟꠣ। ꠔꠣꠁꠘ ꠛꠥꠎꠟꠣ ꠁꠔꠣ ꠔ ꠎꠣꠘꠣ-ꠎꠣꠘꠤ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX2_15","003_2_15","EXO","2","15","15","ꠀꠞ ꠚꠦꠞꠣꠃꠘꠦꠅ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣꠞꠦ ꠝꠣꠞꠤꠟꠔꠣ ꠌꠣꠁꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠤ ꠉꠦꠟꠣ। ꠜꠣꠉꠤꠀ ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠅ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠢꠘꠞ ꠄꠇ ꠇꠥꠀꠞ ꠇꠣꠍꠣꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_16","003_2_16","EXO","2","16","16","ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠅ ꠡꠥꠀꠁꠛ ꠘꠣꠝꠞ ꠄꠇ ꠁꠝꠣꠝ ꠍꠣꠛ ꠀꠍꠟꠣ। ꠔꠣꠘ ꠡꠣꠔꠎꠘ ꠙꠥꠠꠤꠘ ꠀꠍꠂꠘ। ꠅꠃ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠇꠥꠀꠞ ꠙꠣꠞꠅ ꠀꠁꠀ, ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞ ꠍꠣꠉꠟ-ꠝꠦꠠꠣꠞꠦ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠘꠤꠞ ꠟꠣꠉꠤ ꠉꠣꠝꠟꠣ ꠜꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_17","003_2_17","EXO","2","17","17","ꠅꠃ ꠡꠝꠄ ꠅꠁꠘ꠆ꠘ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠟꠣꠁꠟ। ꠅꠁꠟꠦ ꠝꠥꠍꠣ ꠃꠛꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠣꠟꠞꠦ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_18","003_2_18","EXO","2","18","18","ꠔꠣꠞꠣ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞ ꠗꠣꠞꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠁꠎ ꠅꠔ ꠎꠟꠖꠤ ꠇꠦꠝꠘꠦ ꠀꠁꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("EX2_19","003_2_19","EXO","2","19","19","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠄꠇ ꠝꠤꠡꠞꠤ ꠛꠦꠐꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠍꠂꠘ। ꠄꠁꠘ ꠀꠝꠞꠣꠞ ꠍꠣꠉꠟ-ꠝꠦꠠꠣꠞꠦ ꠙꠣꠘꠤ ꠔꠥꠟꠤꠀ ꠈꠣꠅꠀꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX2_20","003_2_20","EXO","2","20","20","ꠔꠦꠃ ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁ ꠝꠣꠘꠥꠡꠉꠥ ꠇꠥꠀꠁ? ꠔꠥꠝꠞꠣ ꠔꠣꠞꠦ ꠕꠁꠀ ꠀꠁꠟ꠆ꠟꠣꠄ ꠇꠦꠘꠦ? ꠄꠞꠦ ꠒꠣꠇꠤꠀ ꠀꠘꠤꠀ ꠈꠣꠘꠣ ꠈꠣꠅꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX2_21","003_2_21","EXO","2","21","21","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠅꠃ ꠁꠝꠣꠝꠞ ꠛꠣꠠꠤꠔ ꠞꠁꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠟꠣ। ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠣꠘ ꠙꠥꠠꠤ ꠍꠚꠥꠞꠣꠞꠦ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠡꠣꠖꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_22","003_2_22","EXO","2","22","22","ꠛꠣꠖꠦ ꠍꠚꠥꠞꠣꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟꠦ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠛꠂꠔꠟ ꠛꠘꠤꠀ ꠛꠤꠖꠦꠡꠅ ꠞꠁꠞꠣꠝ।” ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠎꠣꠞꠍꠥꠝ ꠝꠣꠘꠤ, ꠛꠂꠔꠟ। ");
INSERT INTO syls_vpl VALUES ("EX2_23","003_2_23","EXO","2","23","23","ꠛꠃꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠝꠞꠤꠉꠦꠟꠣ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠉꠥꠟꠣꠝꠤꠞ ꠟꠣꠉꠤ ꠇꠣꠔꠞ ꠅꠁꠀ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠟ। ꠔꠣꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠘ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠇꠛꠥꠟ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX2_24","003_2_24","EXO","2","24","24","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠟꠣ। ꠔꠣꠁꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠟꠉꠦ ꠔꠣꠘ ꠅꠀꠖꠣꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX2_25","003_2_25","EXO","2","25","25","ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠄ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠟꠣ, ꠖꠄꠀꠞ ꠘꠎꠞꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX3_1","003_3_1","EXO","3","1","1","ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠢꠃꠞ ꠝꠣꠖꠤꠀꠘ ꠎꠣꠔꠤꠞ ꠁꠝꠣꠝ ꠍꠣꠛ ꠢꠎꠞꠔ ꠡꠥꠀꠁꠛꠞ ꠍꠣꠉꠟ-ꠝꠦꠠꠣ ꠞꠣꠈꠔꠣ। ꠄꠇꠖꠤꠘ ꠔꠣꠘ ꠍꠣꠉꠟꠞ ꠙꠣꠟ ꠟꠁꠀ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠢꠦꠡ ꠉꠣꠟꠣꠔ ꠀꠟ꠆ꠟꠣꠞ ꠢꠃ ꠔꠥꠞ ꠙꠣꠠꠞ ꠇꠣꠍꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX3_2","003_3_2","EXO","3","2","2","ꠢꠘꠅ ꠄꠇ ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠘꠥꠞꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠟꠣ। ꠝꠥꠍꠣꠄ ꠖꠦꠈꠟꠣ, ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠀꠉꠥꠁꠘ ꠎꠟꠦꠞ ꠅꠁꠟꠦ ꠎꠋꠟꠣ ꠎꠟꠦꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX3_3","003_3_3","EXO","3","3","3","ꠅꠃ ꠔꠣꠁꠘ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠎꠋꠟꠣ ꠎꠦ ꠎꠟꠦꠞ ꠘꠣ, ꠄꠞ ꠇꠣꠞꠘ ꠇꠤꠔꠣ? ꠔꠦ ꠀꠞꠅ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠖꠦꠈꠤ ꠌꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX3_4","003_3_4","EXO","3","4","4","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣ ꠄꠁꠘ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠍꠣꠔ ꠎꠣꠁꠞꠣꠉꠤ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠎꠋꠟꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, “ꠝꠥꠍꠣ, ꠅ ꠝꠥꠍꠣ!” ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅꠃꠘꠥ ꠀꠝꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX3_5","003_3_5","EXO","3","5","5","ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠀꠞ ꠍꠣꠝꠘꠦ ꠀꠉꠥꠀꠁꠅ ꠘꠣ। ꠔꠥꠝꠣꠞ ꠙꠣꠅ ꠕꠣꠇꠤ ꠎꠥꠔꠣ ꠈꠥꠟꠤꠟꠣꠅ। ꠎꠣꠘ ꠘꠤ, ꠔꠥꠝꠤ ꠅꠈꠘ ꠎꠦ ꠎꠣꠉꠣꠔ ꠃꠛꠣꠁꠍ ꠁꠈꠣꠘ ꠙꠣꠇ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("EX3_6","003_3_6","EXO","3","6","6","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠝꠣꠛꠥꠖ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠣꠛꠥꠖ, ꠁꠍꠢꠣꠇꠞ ꠝꠣꠛꠥꠖ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠝꠣꠛꠥꠖ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠝꠥꠈ ꠟꠥꠇꠣꠁꠟ꠆ꠟꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠔꠦ ꠔꠣꠘ ꠖꠤꠟꠅ ꠒꠞ ꠢꠣꠝꠣꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX3_7","003_3_7","EXO","3","7","7","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠖꠦꠈꠤꠀꠞ। ꠝꠤꠡꠞꠤ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞ ꠎꠥꠟꠥꠝꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠘ ꠢꠥꠘꠤꠀꠞ। ꠔꠣꠞꠣꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠢꠇꠟꠔꠣ ꠀꠝꠤ ꠖꠦꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX3_8","003_3_8","EXO","3","8","8","ꠖꠦꠈꠤꠀ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠀꠔ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠔꠣꠝ ꠇꠞꠤ ꠀꠝꠤ ꠘꠤꠎꠦ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠤ। ꠔꠦ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠘꠤꠝꠥꠉꠤ। ꠘꠤꠀ ꠞꠡꠣꠁꠟ ꠎꠝꠤꠞ ꠛꠃꠔ ꠛꠠ ꠡꠥꠘ꠆ꠖꠞ ꠄꠇ ꠖꠦꠡ ꠖꠤꠝꠥ। ꠁꠈꠣꠘ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠖꠦꠡ। ꠅꠃ ꠖꠦꠡ ꠅꠁꠟ ꠅꠈꠘꠇꠥꠞ ꠇꠦꠘꠣꠘꠤ, ꠢꠤꠐ꠆ꠐꠤ, ꠀꠝꠥꠞꠤ, ꠚꠣꠞꠤꠎꠤ, ꠢꠤꠛ꠆ꠛꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠅꠇꠟꠞ ꠖꠦꠡ। ");
INSERT INTO syls_vpl VALUES ("EX3_9","003_3_9","EXO","3","9","9","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠚꠞꠤꠀꠖ ꠀꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠁꠍꠦ, ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠍꠣꠔꠣꠁꠞꠣ, ꠁꠔꠣ ꠀꠝꠤ ꠖꠦꠈꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("EX3_10","003_3_10","EXO","3","10","10","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠀꠞ। ꠔꠥꠝꠤ ꠎꠣꠅ, ꠉꠤꠀ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX3_11","003_3_11","EXO","3","11","11","ꠝꠥꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠀꠞꠇ ꠎꠘ ꠇꠦ, ꠎꠦꠁꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠉꠤꠀ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠢꠞꠣꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("EX3_12","003_3_12","EXO","3","12","12","ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠝꠥ। ꠔꠥꠝꠤ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠝꠣꠘꠡꠞꠦ ꠢꠞꠣꠁꠀ ꠀꠘꠤꠀ, ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠅꠃ ꠙꠣꠠꠅ ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠛꠣꠄ। ꠔꠦꠃ ꠛꠥꠎꠛꠣꠄ ꠀꠝꠤꠃ ꠔꠥꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX3_13","003_3_13","EXO","3","13","13","ꠝꠥꠍꠣꠄ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠉꠤꠀ ꠇꠁꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠎꠤꠇꠣꠁꠘ ꠔꠣꠘ ꠘꠣꠝ ꠇꠤꠔꠣ, ꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠤꠔꠣ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("EX3_14","003_3_14","EXO","3","14","14","ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦꠁꠘ ꠀꠍꠤ, ꠀꠍꠤꠃ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠅꠃꠟꠣ ꠇꠁꠅ, ꠎꠦꠘ ꠘꠣꠝ ‘ꠀꠝꠤ ꠀꠍꠤ’ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX3_15","003_3_15","EXO","3","15","15","ꠔꠣꠁꠘ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠅ, ‘ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠎꠦꠁꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠍꠂꠘ, ꠄꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠣꠛꠥꠖ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠣꠛꠥꠖ, ꠁꠍꠢꠣꠇꠞ ꠝꠣꠛꠥꠖ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠝꠣꠛꠥꠖ, ꠄꠁꠘꠃ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ।’ “ꠀꠝꠣꠞ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠘꠣꠝ ‘ꠀꠝꠤ ꠎꠦꠁꠘ ꠀꠍꠤ’। ꠎꠥꠉꠦ ꠎꠥꠉꠦ, ꠙꠥꠞꠥꠡꠦ ꠙꠥꠞꠥꠡꠦ ꠅꠃ ꠘꠣꠝ ꠇꠣꠁꠝ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX3_16","003_3_16","EXO","3","16","16","ꠔꠥꠝꠤ ꠎꠣꠅ, ꠉꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠤꠀ ꠇꠅ, ꠢꠃ ꠀꠟ꠆ꠟꠣ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠣꠛꠥꠖ, ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠝꠣꠛꠥꠖ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠇꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠞ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠖꠦꠈꠍꠂꠘ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠎꠦꠔꠣ ꠇꠞꠣ ꠅꠞ ꠄꠅꠔꠣ ꠔꠣꠁꠘ ꠈꠤꠀꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX3_17","003_3_17","EXO","3","17","17","ꠅꠈꠘ ꠔꠣꠁꠘ ꠇꠁꠞꠣ, ꠝꠤꠡꠞꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠀ ꠇꠦꠘꠣꠘꠤ, ꠢꠤꠐ꠆ꠐꠤ, ꠀꠝꠥꠞꠤ, ꠚꠣꠞꠤꠎꠤ, ꠢꠤꠛ꠆ꠛꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠅꠇꠟꠞ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠖꠦꠡꠅ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠛꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX3_18","003_3_18","EXO","3","18","18","ꠀꠟ꠆ꠟꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠔꠥꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠛꠣ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠅ। ꠉꠤꠀ ꠇꠁꠅ, ‘ꠀꠟ꠆ꠟꠣ ꠎꠦꠁꠘ ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠝꠣꠛꠥꠖ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠔꠣꠘ ꠘꠣꠝꠦ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠔꠣꠝ ꠌꠣꠁꠀꠞ, ꠀꠝꠞꠣ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠔꠤꠘ ꠖꠤꠘꠞ ꠙꠕ ꠉꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠝꠥ, ꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠣꠅꠀꠞ ꠅꠘꠥꠝꠔꠤ ꠖꠦꠃꠇ꠆ꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("EX3_19","003_3_19","EXO","3","19","19","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠣꠘꠤ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠖꠤꠔ ꠘꠣꠄ, ꠎꠥꠞ-ꠎꠛꠞꠖꠡ꠆ꠔꠤ ꠇꠞꠟꠦꠅ ꠖꠤꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX3_20","003_3_20","EXO","3","20","20","ꠔꠦꠃ ꠀꠝꠤ ꠀꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠟꠣꠉꠣꠁꠝꠥ ꠀꠞ ꠅꠃꠟꠣ ꠀꠌꠣꠘꠇ ꠉꠎꠛ ꠘꠣꠎꠤꠟ ꠇꠞꠝꠥ, ꠎꠣꠔꠦ ꠢꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("EX3_21","003_3_21","EXO","3","21","21","ꠀꠞ ꠀꠝꠤ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠄ ꠄꠝꠘ ꠄꠇ ꠖꠄꠀꠞ ꠜꠣꠛ ꠙꠄꠖꠣ ꠇꠞꠣꠁꠝꠥ, ꠄꠞꠣ ꠎꠣꠘꠥ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠈꠣꠟꠤ ꠀꠔꠦ ꠘꠣ ꠎꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("EX3_22","003_3_22","EXO","3","22","22","ꠢꠇꠟ ꠁꠍꠞꠣꠁꠟꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠀꠞꠤ-ꠚꠞꠤ ꠛꠣ ꠎꠦꠞꠣꠞ ꠛꠣꠠꠤꠔ ꠔꠣꠞꠣ ꠞꠂꠘ, ꠅꠃꠟꠣ ꠝꠤꠡꠞꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠞ ꠉꠄꠘꠣ-ꠉꠣꠐꠤ ꠀꠞ ꠜꠣꠟꠣ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠈꠥꠎꠤꠀ ꠘꠤꠅ। ꠅꠔꠣ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦꠅ ꠢꠣꠎꠣꠁꠅ, ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞꠤꠘ꠆ꠔꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠖꠈꠟ ꠇꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX4_1","003_4_1","EXO","4","1","1","ꠝꠥꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠄꠇꠤꠘ ꠘꠣ ꠇꠞꠂꠘ, ꠀꠝꠣꠞ ꠝꠣꠔ ꠘꠣ ꠢꠥꠘꠂꠘ ꠛꠣ ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠇꠂꠘ, ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠔꠦ ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("EX4_2","003_4_2","EXO","4","2","2","ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠁꠉꠥ ꠇꠤꠔꠣ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠄꠉꠥ ꠟꠣꠑꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX4_3","003_4_3","EXO","4","3","3","ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠅꠇꠐꠣ ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠅ।” ꠝꠥꠍꠣꠄ ꠟꠣꠑꠤꠞꠦ ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠁꠔꠦꠃ ꠁꠐꠣ ꠢꠣꠚ ꠅꠁꠉꠦꠟ। ꠢꠣꠚ ꠖꠦꠈꠤꠀꠃ ꠔꠣꠁꠘ ꠚꠣꠟꠖꠤ ꠢꠞꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_4","003_4_4","EXO","4","4","4","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠟꠣ, “ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠅꠉꠥꠞ ꠟꠦꠘ꠆ꠎꠅ ꠗꠞꠅ।” ꠀꠞ ꠔꠣꠁꠘ ꠗꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠅꠉꠥ ꠢꠤꠞꠛꠣꠞ ꠟꠣꠑꠤ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX4_5","003_4_5","EXO","4","5","5","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤꠅ ꠅꠃꠟꠣ ꠇꠞꠤꠅ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠣꠍꠣꠃ ꠄꠇꠤꠘ ꠇꠞꠛꠣ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠛꠥꠖ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠣꠛꠥꠖ, ꠁꠍꠢꠣꠇꠞ ꠝꠣꠛꠥꠖ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX4_6","003_4_6","EXO","4","6","6","ꠀꠟ꠆ꠟꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠔ ꠔꠥꠝꠣꠞ ꠌꠣꠖ꠆ꠖꠞꠞ ꠔꠟꠦ ꠢꠣꠞꠣꠅ।” ꠔꠣꠁꠘ ꠀꠔ ꠢꠣꠞꠣꠁꠟꠣ, ꠀꠞ ꠛꠣꠞ ꠇꠞꠣꠞ ꠛꠣꠖꠦꠃ ꠔꠣꠘ ꠀꠔ ꠇꠥꠡ꠆ꠑ-ꠗꠟꠛꠦꠖꠣ ꠛꠦꠝꠣꠞꠦ ꠖꠥꠗꠞ ꠟꠣꠈꠣꠘ ꠗꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX4_7","003_4_7","EXO","4","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠔ ꠢꠤꠞꠛꠣꠞ ꠢꠘꠅ ꠢꠣꠞꠣꠅ।” ꠔꠣꠁꠘ ꠢꠣꠞꠣꠁꠟꠣ ꠀꠞ ꠌꠣꠖ꠆ꠖꠞꠞ ꠔꠟ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠖꠦꠈꠂꠘ, ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX4_8","003_4_8","EXO","4","8","8","ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠄꠇꠤꠘ ꠘꠣ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠟꠣꠑꠤꠞꠦ ꠢꠣꠚ ꠅꠀ ꠖꠦꠈꠟꠦ ꠄꠇꠤꠘ ꠇꠞꠛꠣ, ꠀꠞ ꠄꠅꠐꠣꠄ ꠄꠇꠤꠘ ꠘꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠣꠞ ꠀꠔꠞ ꠛꠦꠝꠣꠞꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠟꠦ ꠔꠣꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_9","003_4_9","EXO","4","9","9","ꠀꠞ ꠎꠥꠖꠤ ꠁ ꠖꠥꠁꠅ ꠇꠦꠞꠣꠝꠔꠤꠄꠅ ꠄꠇꠤꠘ ꠘꠣ ꠇꠞꠂꠘ, ꠔꠥꠝꠣꠞ ꠇꠕꠣ ꠘꠣ ꠝꠣꠘꠂꠘ, ꠔꠦ ꠔꠥꠝꠤ ꠘꠤꠟ ꠘꠖ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠙꠣꠘꠤ ꠀꠘꠤꠀ ꠢꠥꠇꠘꠣ ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠁꠅ, ꠖꠦꠈꠛꠣꠄ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀꠃ ꠁ ꠙꠣꠘꠤ ꠟꠃ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX4_10","003_4_10","EXO","4","10","10","ꠅꠃ ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠟꠤꠇ, ꠀꠝꠤ ꠔ ꠜꠣꠟꠣ ꠇꠞꠤ ꠝꠣꠔ-ꠇꠕꠣꠃ ꠝꠣꠔꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ, ꠀꠉꠦꠅ ꠙꠣꠞꠔꠣꠝ ꠘꠣ ꠀꠞ ꠀꠙꠘꠦ ꠁ ꠉꠥꠟꠣꠝꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠣꠞ ꠛꠣꠖꠦꠅ ꠙꠣꠞꠤ ꠘꠣ, ꠀꠝꠣꠞ ꠔ ꠎꠤꠚꠞꠣ ꠛꠣꠠꠥꠀ।” ");
INSERT INTO syls_vpl VALUES ("EX4_11","003_4_11","EXO","4","11","11","ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, “ꠝꠣꠘꠡꠞ ꠝꠥꠈ ꠇꠦ ꠛꠣꠘꠣꠁꠍꠦ, ꠀꠝꠤ ꠘꠣꠄ ꠘꠤ? ꠇꠦ ꠝꠣꠘꠡꠞꠦ ꠛꠥꠛꠣ, ꠈꠣꠟꠥꠀ ꠛꠣ ꠀꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠘ? ꠌꠃꠈꠦ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠌꠈꠥꠞ ꠙꠣꠅꠀꠞ ꠇꠦ ꠖꠦꠁꠘ? ꠁꠔꠣ ꠔ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠄꠃ ꠖꠦꠁ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("EX4_12","003_4_12","EXO","4","12","12","ꠔꠦ ꠔꠥꠝꠤ ꠎꠣꠅ, ꠉꠤꠀ ꠇꠤꠔꠣ ꠝꠣꠔꠤꠔꠣꠄ ꠀꠝꠤ ꠢꠤꠇꠣꠁꠀ ꠖꠤꠝꠥ। ꠔꠥꠝꠣꠞ ꠝꠥꠈꠞ ꠎꠛꠣꠘꠞꠦ ꠀꠝꠤ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX4_13","003_4_13","EXO","4","13","13","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠟꠤꠇ, ꠀꠝꠤ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠅꠁꠘ꠆ꠘ ꠇꠦꠃꠞꠞꠦ ꠙꠣꠑꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX4_14","003_4_14","EXO","4","14","14","ꠅꠃ ꠝꠥꠍꠣꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠍꠣ ꠃꠑꠟ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘ ꠛꠤꠘ ꠟꠦꠛꠤ ꠀꠍꠦ ꠘꠣ ꠘꠤ? ꠀꠝꠤ ꠎꠣꠘꠤ, ꠢꠦ ꠜꠣꠟꠣ ꠛꠇ꠆ꠔꠤꠔꠣ ꠖꠤꠔ ꠙꠣꠞꠦ। ꠢꠦ ꠅꠈꠘ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠀꠞ, ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠢꠦ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX4_15","003_4_15","EXO","4","15","15","ꠔꠥꠝꠤ ꠢꠤꠇꠣꠁꠀ ꠖꠤꠅ ꠀꠞ ꠇꠁꠅ ꠢꠦ ꠇꠤꠔꠣ ꠝꠣꠔꠤꠔ। ꠀꠝꠤ ꠔꠥꠝꠞꠣ ꠖꠥꠁꠅꠎꠘꠞ ꠝꠥꠈꠞ ꠎꠛꠣꠘꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠝꠥ। ꠀꠞ ꠢꠘꠅ ꠉꠤꠀ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠄ ꠀꠝꠤ ꠢꠤꠇꠣꠁꠀ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX4_16","003_4_16","EXO","4","16","16","ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘꠞ ꠝꠥꠈ ꠅꠁꠛ ꠔꠥꠝꠣꠞ ꠝꠥꠈ, ꠢꠦ ꠔꠥꠝꠣꠞ ꠅꠁꠀ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠛ। ꠙꠦꠉꠣꠝ꠆ꠛꠞ ꠅꠇꠟꠦ ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠇꠂꠘ, ꠢꠣꠞꠥꠘꠦ ꠅꠃꠟꠣ ꠔꠥꠝꠣꠞ ꠛꠥꠟꠤ ꠇꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX4_17","003_4_17","EXO","4","17","17","ꠅꠃ ꠟꠣꠑꠤ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠞꠣꠈꠤꠅ, ꠁꠐꠣ ꠖꠤꠀ ꠢꠃ ꠇꠦꠞꠣꠝꠔꠤ-ꠝꠥꠎꠦꠎꠣ ꠅꠇꠟ ꠎꠣꠁꠞ ꠇꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX4_18","003_4_18","EXO","4","18","19","ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠅ ꠕꠣꠇꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠟꠣ, “ꠔꠥꠝꠤ ꠝꠤꠡꠞꠅ ꠎꠣꠅꠉꠤ, ꠇꠣꠞꠘ ꠝꠤꠡꠞꠞ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠔꠣ ꠌꠣꠁꠍꠟꠣ, ꠁꠔꠣ ꠅꠈꠘ ꠝꠞꠤ ꠉꠦꠍꠂꠘ।” ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠢꠃꠞ ꠡꠥꠀꠁꠛꠞ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠝꠣꠞ ꠎꠘꠝ ꠝꠣꠐꠤ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠀꠝꠣꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠅꠇꠟ ꠎꠤꠔꠣ ꠀꠍꠂꠘ ꠇꠤ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠖꠦꠈꠣꠔ ꠎꠣꠁꠔꠣꠝ, ꠔꠦ ꠀꠝꠣꠞꠦ ꠎꠣꠅꠀꠞ ꠅꠘꠥꠝꠔꠤ ꠖꠦꠃꠇ꠆ꠇꠣ।” ꠢꠃꠞꠦ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠎꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX4_20","003_4_20","EXO","4","20","20","ꠅꠃ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠛꠤꠛꠤ ꠀꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠉꠣꠗꠣꠞ ꠃꠙꠞꠦ ꠌꠠꠣꠁꠀ ꠝꠤꠡꠞꠞ ꠙꠕꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ꠔꠣꠘ ꠀꠔꠅ ꠀꠟ꠆ꠟꠣꠁ ꠇꠦꠞꠣꠝꠔꠤꠞ ꠢꠃ ꠟꠣꠑꠤ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_21","003_4_21","EXO","4","21","21","ꠀꠟ꠆ꠟꠣꠄ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤ ꠝꠤꠡꠞꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠇꠦꠞꠣꠝꠔꠤ ꠅꠇꠟ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠖꠦꠈꠣꠁꠅ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠣꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠟꠤꠝꠥ, ꠢꠦ ꠝꠣꠘꠡꠞꠦ ꠍꠣꠠꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX4_22","003_4_22","EXO","4","22","22","ꠔꠥꠝꠤ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠅ, ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠦ ꠇꠁꠍꠂꠘ, ‘ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠔ ꠀꠝꠣꠞ ꠙꠄꠟꠣ ꠙꠥꠔꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("EX4_23","003_4_23","EXO","4","23","23","ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠥꠝꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠟꠣꠝ, ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔꠅ ꠎꠣꠁꠔꠣ ꠇꠞꠤ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠙꠥꠔꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠔꠣꠄ, ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠝꠣꠘꠍ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠀꠝꠤꠅ ꠔꠥꠝꠣꠞ ꠙꠄꠟꠣ ꠙꠥꠔꠞꠦ ꠝꠣꠞꠤꠟꠤꠝꠥ।’ ” ");
INSERT INTO syls_vpl VALUES ("EX4_24","003_4_24","EXO","4","24","24","ꠛꠣꠖꠦ ꠝꠤꠡꠞꠅ ꠎꠣꠅꠀꠞ ꠙꠕꠅ ꠞꠣꠁꠔ ꠇꠣꠐꠣꠁꠛꠣꠞ ꠎꠣꠉꠣꠔ ꠀꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠇꠞꠤ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_25","003_4_25","EXO","4","25","25","ꠅꠁꠟꠦ ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠚꠥꠞꠣꠄ ꠄꠇꠈꠣꠘ ꠗꠣꠞꠣꠁꠟ ꠙꠣꠔ꠆ꠔꠞ ꠟꠁꠀ ꠔꠣꠘ ꠙꠥꠀꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ꠆ꠟꠣ ꠀꠞ ꠅꠇꠐꠣ ꠔꠣꠘ ꠎꠣꠝꠣꠁ ꠝꠥꠍꠣꠞ ꠙꠣꠅꠞ ꠝꠣꠎꠦ ꠍꠥꠀꠁꠀ ꠇꠁꠟꠣ, “ꠟꠃꠞ ꠛꠖꠟꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠣꠝꠣꠁ ꠢꠤꠡꠣꠛꠦ ꠙꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX4_26","003_4_26","EXO","4","26","26","ꠔꠦꠃ ꠝꠥꠍꠣꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠍꠣꠠꠤꠖꠤꠟꠣ। ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠍꠚꠥꠞꠣꠄ ꠔ ꠅꠃ ꠇꠕꠣꠃ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_27","003_4_27","EXO","4","27","27","ꠄꠞꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠤꠀ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠅ।” ꠅꠃ ꠔꠣꠁꠘ ꠉꠦꠟꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠠ ꠔꠥꠞꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠝꠥꠍꠣꠞꠦ ꠙꠣꠁꠀ ꠌꠥꠝꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_28","003_4_28","EXO","4","28","28","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠝꠥꠍꠣꠄ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠢꠣꠞꠥꠘꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠇꠦꠞꠣꠝꠔꠤ-ꠝꠥꠎꠦꠎꠣ ꠖꠦꠈꠣꠘꠤꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠔꠣꠁꠘ ꠢꠣꠞꠥꠘꠞꠦ ꠛꠥꠎꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_29","003_4_29","EXO","4","29","29","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠖꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_30","003_4_30","EXO","4","30","30","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠔꠔꠣ ꠇꠁꠍꠟꠣ, ꠢꠣꠞꠥꠘꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠢꠃ ꠇꠦꠞꠣꠝꠔꠤ ꠅꠇꠟꠅ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX4_31","003_4_31","EXO","4","31","31","ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠟꠣ। ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠃꠙꠞꠞ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠖꠦꠈꠍꠂꠘ, ꠅꠃ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX5_1","003_5_1","EXO","5","1","1","ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠉꠤꠀ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠇꠁꠍꠂꠘ, ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠤ ꠍꠣꠠꠤ ꠖꠦꠅ, ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠢꠎ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠞꠣ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠢꠤꠎꠞꠔ ꠇꠞꠔꠦ ꠅꠁꠛ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠍꠣꠠꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX5_2","003_5_2","EXO","5","2","2","ꠚꠦꠞꠣꠃꠘꠦ ꠎꠥꠀꠙ ꠖꠤꠟ, “ꠁ ꠝꠣꠛꠥꠖ ꠀꠞꠇ ꠎꠘ ꠇꠦ, ꠎꠦꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠔꠣꠝ? ꠁꠟꠣ ꠇꠥꠘꠥ ꠝꠣꠛꠥꠖꠞꠦ ꠀꠝꠤ ꠌꠤꠘꠤ ꠘꠣ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦꠅ ꠀꠝꠤ ꠍꠣꠠꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX5_3","003_5_3","EXO","5","3","3","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ ꠀꠝꠞꠣꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠔꠤꠘ ꠖꠤꠘꠞ ꠙꠕ ꠉꠤꠀ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠔꠦ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠀꠞꠘꠣꠄ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠉꠎꠛꠤ ꠛꠦꠝꠣꠞ ꠖꠤꠀ ꠛꠣ ꠎꠥꠖ꠆ꠖꠞ ꠝꠣꠎꠦ ꠚꠣꠟꠣꠁꠀ ꠝꠣꠞꠤꠟꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX5_4","003_5_4","EXO","5","4","4","ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ, ꠔꠥꠝꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠇꠦꠘꠦ ꠇꠣꠝꠅ ꠕꠣꠇꠤ ꠚꠤꠞꠣꠁꠞꠣꠄ? ꠎꠣꠅ, ꠔꠥꠝꠞꠣꠅ ꠉꠤꠀ ꠇꠣꠝꠅ ꠟꠣꠉꠅ। ");
INSERT INTO syls_vpl VALUES ("EX5_5","003_5_5","EXO","5","5","5","ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠥꠡ ꠛꠃꠔ ꠛꠣꠠꠤꠉꠦꠍꠂꠘ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠁ ꠙꠣꠁꠀ ꠁꠔꠣꠄ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠞꠣ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX5_6","003_5_6","EXO","5","6","6","ꠅꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠢꠃ ꠖꠤꠘꠃ ꠝꠤꠡꠞꠤ ꠎꠣꠟꠤꠝ ꠡꠞ꠆ꠖꠣꠞ ꠀꠞ ꠁꠛꠞꠣꠘꠤ ꠍꠥꠛꠦꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX5_7","003_5_7","EXO","5","7","7","“ꠁꠐ ꠛꠣꠘꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠈꠦꠞ-ꠘꠦꠞꠣ ꠀꠘꠤꠀ ꠖꠤꠅ ꠘꠣ, ꠔꠣꠞꠣ ꠉꠤꠀ ꠁꠔꠣ ꠎꠥꠉꠣꠠ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("EX5_8","003_5_8","EXO","5","8","8","ꠅꠁꠟꠦ ꠀꠉꠦ ꠔꠣꠞꠣ ꠎꠔꠈꠣꠘ ꠁꠐ ꠛꠣꠘꠣꠁꠔ ꠅꠈꠘꠅ ꠅꠔꠈꠣꠘ ꠛꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ, ꠄꠇꠈꠣꠘꠅ ꠇꠝ ꠅꠁꠔ ꠘꠣꠄ। ꠁꠔꠣ ꠀꠟꠡꠤꠀ ꠅꠁꠉꠦꠍꠂꠘ ꠇꠞꠤ, ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠔꠣ ꠇꠁꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("EX5_9","003_5_9","EXO","5","9","9","ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠅ ꠇꠡ꠆ꠐꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠅ, ꠔꠦꠃ ꠁꠔꠣꠄ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠛꠣꠎꠦ ꠝꠣꠔ ꠘꠣ ꠢꠥꠘꠤꠀ ꠇꠣꠝꠞ ꠝꠣꠎꠦ ꠝꠘ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX5_10","003_5_10","EXO","5","10","10","ꠅꠃ ꠢꠤ ꠡꠞ꠆ꠖꠣꠞ ꠀꠞ ꠍꠥꠛꠦꠖꠣꠞ ꠅꠇꠟ ꠛꠣꠞ ꠅꠁ ꠉꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠚꠦꠞꠣꠃꠘꠦ ꠇꠁꠍꠂꠘ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠀꠞ ꠁꠐ ꠛꠣꠘꠣꠘꠤꠞ ꠈꠦꠞ ꠎꠥꠉꠣꠁ ꠖꠤꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX5_11","003_5_11","EXO","5","11","11","ꠔꠥꠝꠞꠣ ꠎꠦꠘ ꠕꠣꠇꠤ ꠙꠣꠞ ꠈꠦꠞ-ꠘꠦꠞꠣ ꠎꠥꠉꠣꠁꠅ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠝꠣꠁꠟ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX5_12","003_5_12","EXO","5","12","12","ꠅꠃ ꠝꠣꠘꠡꠦ ꠈꠦꠞ-ꠘꠦꠞꠣ ꠔꠥꠇꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX5_13","003_5_13","EXO","5","13","13","ꠀꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠔꠣꠉꠖꠣ ꠖꠤꠀ ꠇꠁꠟ, “ꠀꠉꠦ ꠈꠦꠞ ꠎꠥꠉꠣꠁꠀ ꠖꠦꠅꠀꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠎꠔꠈꠣꠘ ꠁꠐ ꠛꠣꠘꠣꠁꠔꠣꠄ, ꠅꠈꠘꠅ ꠅꠔꠈꠣꠘ ꠛꠣꠘꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX5_14","003_5_14","EXO","5","14","14","ꠚꠦꠞꠣꠃꠘꠞ ꠎꠣꠟꠤꠝ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠎꠦ ꠍꠥꠛꠦꠖꠣꠞ ꠟꠣꠉꠣꠁꠍꠤꠟ, ꠢꠃ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟ ꠀꠁꠀ ꠍꠥꠛꠦꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠤꠀ ꠎꠤꠇꠣꠁꠟ, “ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠎꠔꠈꠣꠘ ꠁꠐ ꠖꠤꠔꠣꠄ, ꠅꠈꠘ ꠅꠔꠈꠣꠘ ꠖꠦꠅ ꠘꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("EX5_15","003_5_15","EXO","5","15","15","ꠅꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠥꠛꠦꠖꠣꠞ ꠅꠇꠟꠦ ꠀꠁꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠟꠣ, “ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠟꠉꠦ ꠁꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠦꠘꠦ ꠇꠞꠞꠣ? ");
INSERT INTO syls_vpl VALUES ("EX5_16","003_5_16","EXO","5","16","16","ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠀꠝꠞꠣꠞꠦ ꠈꠦꠞ-ꠘꠦꠞꠣ ꠎꠥꠉꠣꠁ ꠖꠦꠁꠘ ꠘꠣ, ꠔꠣ-ꠅ ꠁꠐ ꠛꠣꠘꠣꠁꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠦꠁꠘ ꠀꠞ ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠂꠘ, ꠅꠁꠟꠦ ꠖꠥꠡ ꠔ ꠀꠙꠘꠣꠞ ꠘꠤꠎꠞ ꠡꠞ꠆ꠖꠣꠞꠞ।” ");
INSERT INTO syls_vpl VALUES ("EX5_17","003_5_17","EXO","5","17","17","ꠚꠦꠞꠣꠃꠘꠦ ꠎꠥꠀꠙ ꠖꠤꠟ, “ꠔꠥꠝꠞꠣ ꠀꠟꠡꠤꠀ, ꠇꠥꠠꠤꠀ, ꠄꠞꠟꠣꠉꠤ ꠇꠁꠞꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣꠔ ꠎꠣꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EX5_18","003_5_18","EXO","5","18","18","ꠎꠣꠅ, ꠇꠣꠝ ꠇꠞꠅ ꠉꠤꠀ। ꠔꠥꠝꠞꠣꠞꠦ ꠈꠦꠞ ꠖꠦꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ, ꠔꠣ-ꠅ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠎꠔꠈꠣꠘ ꠁꠐ ꠛꠣꠘꠣꠁꠛꠣꠞ ꠇꠕꠣ ꠀꠍꠤꠟ, ꠅꠔꠈꠣꠘꠃ ꠛꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX5_19","003_5_19","EXO","5","19","19","ꠅꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠥꠛꠦꠖꠣꠞ ꠅꠇꠟꠦ ꠛꠥꠎꠟꠣ, ꠔꠣꠞꠣ ꠛꠤꠙꠖꠞ ꠝꠣꠎꠦ ꠙꠠꠍꠂꠘ, ꠇꠣꠞꠘ ꠔꠣꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠀꠉꠦ ꠎꠔꠈꠣꠘ ꠁꠐ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠔ, ꠅꠈꠘꠅ ꠅꠔꠈꠣꠘ ꠁꠐ ꠛꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ, ꠇꠝ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX5_20","003_5_20","EXO","5","20","20","ꠔꠣꠞꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠣꠅꠀꠞ ꠙꠕꠅ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠅꠁꠟ, ꠄꠞꠣ ꠃꠛꠣꠁꠀ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX5_21","003_5_21","EXO","5","21","21","ꠍꠥꠛꠦꠖꠣꠞ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠀꠙꠘꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠖꠤꠛꠣ, ꠀꠙꠘꠣꠞꠣ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣꠞꠦ ꠙꠌꠣ-ꠉꠣꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠀ, ꠀꠝꠞꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠟꠥꠀꠞ ꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX5_22","003_5_22","EXO","5","22","22","ꠅꠃ ꠝꠥꠍꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠚꠞꠤꠀꠖ ꠇꠞꠟꠣ, “ꠅ ꠖꠤꠘ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠟꠤꠇ, ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠔꠥꠝꠣꠞ ꠛꠘ꠆ꠖꠣꠞꠦ ꠝꠍꠤꠛꠔꠅ ꠚꠣꠟꠣꠁꠟꠣꠄ? ꠀꠞ ꠀꠝꠣꠞꠦ ꠇꠤꠔꠣꠟ꠆ꠟꠣꠉꠤ ꠙꠣꠑꠣꠁꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("EX5_23","003_5_23","EXO","5","23","23","ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠣꠘꠤꠞ ꠛꠣꠖ ꠕꠣꠇꠤꠃ ꠔꠥꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠔ ꠀꠞꠅ ꠛꠣꠠꠤꠍꠦ। ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠔ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠟꠣꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX6_1","003_6_1","EXO","6","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠚꠦꠞꠣꠃꠘꠞ ꠇꠤꠔꠣ ꠖꠡꠣ ꠅꠄ ꠔꠥꠝꠤ ꠖꠦꠈꠤꠅ, ꠀꠝꠣꠞ ꠀꠔꠞ ꠎꠥꠞ ꠖꠦꠈꠟꠦꠃ ꠢꠦ ꠝꠣꠘꠡꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠛ। ꠎꠥꠞꠀꠟꠣ ꠀꠔꠞ ꠇꠥꠖꠞꠔ ꠖꠦꠈꠟꠦꠃ ꠢꠦ ꠔꠣꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠄꠞꠣꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX6_2","003_6_2","EXO","6","2","2","ꠀꠟ꠆ꠟꠣꠄ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠘꠣꠝꠃ ‘ꠀꠟ꠆ꠟꠣ ꠎꠦꠁꠘ ꠀꠍꠂꠘ’। ");
INSERT INTO syls_vpl VALUES ("EX6_3","003_6_3","EXO","6","3","3","ꠀꠝꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣ ꠘꠣꠝꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠔꠣꠝ, ‘ꠀꠟ꠆ꠟꠣ ꠎꠦꠁꠘ ꠀꠍꠂꠘ’ ꠘꠣꠝꠦ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠔꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX6_4","003_6_4","EXO","6","4","4","ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠅꠃ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣꠝ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠖꠤꠝꠥ, ꠎꠦ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠁꠀ ꠞꠅ, ꠅꠃ ꠖꠦꠡꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX6_5","003_6_5","EXO","6","5","5","ꠈꠣꠍ ꠇꠞꠤ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠘ ꠢꠥꠘꠤꠀ, ꠀꠝꠣꠞ ꠢꠃ ꠅꠀꠖꠣ ꠅꠈꠘ ꠁꠀꠖ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EX6_6","003_6_6","EXO","6","6","6","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠉꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠝꠣꠛꠥꠖꠦ ꠇꠁꠍꠂꠘ, ꠀꠝꠤ ꠝꠣꠛꠥꠖ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠔꠟ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠝꠥ, ꠔꠣꠞꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠇꠞꠝꠥ। ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠝꠔ ꠡꠣꠎꠣ ꠖꠤꠀ, ꠀꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX6_7","003_6_7","EXO","6","7","7","ꠢꠦꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠝꠥ, ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠅꠁꠝꠥ। ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠀꠞ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠜꠣꠞꠞ ꠔꠟ ꠕꠣꠇꠤ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX6_8","003_6_8","EXO","6","8","8","ꠀꠝꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ, ꠁꠀꠇꠥꠛꠞ ꠟꠉꠦ ꠎꠦ ꠖꠦꠡꠞ ꠇꠕꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠤ, ꠢꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠎꠣꠁꠝꠥ, ꠔꠥꠝꠞꠣ ꠢꠃ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠛꠣꠄ। ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("EX6_9","003_6_9","EXO","6","9","9","ꠝꠥꠍꠣꠄ ꠉꠤꠀ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠢꠤ ꠛꠦꠕꠣꠄꠀ ꠎꠥꠟꠥꠝ-ꠔꠇꠟꠤꠚ ꠀꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠔꠦ ꠇꠞꠔꠦ ꠝꠘ-ꠝꠞꠣ ꠅꠁꠎꠣꠅꠀꠄ, ꠔꠣꠞꠣ ꠀꠞ ꠝꠥꠍꠣꠞ ꠝꠣꠔꠦ ꠇꠣꠘ ꠖꠤꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX6_10","003_6_10","EXO","6","10","10","ꠅꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX6_11","003_6_11","EXO","6","11","11","“ꠔꠥꠝꠤ ꠉꠤꠀ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠅ, ꠢꠦ ꠎꠣꠘꠥ ꠔꠣꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠄꠞꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠖꠦꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX6_12","003_6_12","EXO","6","12","12","ꠝꠥꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦꠃ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠝꠣꠔ ꠢꠥꠘꠦꠞ ꠘꠣ, ꠔꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠇꠤꠟꠣ ꠢꠥꠘꠛ? ꠀꠞ ꠀꠝꠣꠞ ꠔ ꠝꠣꠔꠔꠦ ꠝꠥꠈꠅ ꠟꠣꠉꠤꠎꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX6_13","003_6_13","EXO","6","13","13","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠞ ꠝꠤꠡꠞꠞ ꠞꠣꠎꠣ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠅ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX6_14","003_6_14","EXO","6","14","14","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠁꠟꠣ ꠢꠎꠞꠔ ꠁꠀꠇꠥꠛ, ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠁꠀꠇꠥꠛꠞ ꠘꠄꠀ ꠘꠣꠝ ꠖꠤꠍꠟꠣ ꠁꠍꠞꠣꠁꠟ। ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠞꠥꠛꠦꠘ, ꠡꠤꠝꠤꠅꠘ, ꠟꠦꠛꠤ ꠡꠢ ꠝꠥꠐ ꠛꠣꠞꠅꠎꠘ। ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠅꠁꠟꠣ ꠅꠃ ꠢꠎꠞꠔ ꠟꠦꠛꠤꠞ ꠛꠋꠡꠗꠞ। ꠁꠍꠞꠣꠁꠟꠞ ꠛꠠ ꠙꠥꠀ ꠞꠥꠛꠦꠘꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠢꠘꠥꠇ, ꠚꠣꠟꠥ, ꠢꠣꠍꠤꠞ ꠀꠞ ꠇꠞ꠆ꠝꠤ, ꠄꠞꠣ ꠔ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("EX6_15","003_6_15","EXO","6","15","15","ꠡꠤꠝꠤꠅꠘꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠎꠤꠝꠥꠄꠟ, ꠎꠣꠝꠤꠘ, ꠅꠢꠖ, ꠎꠣꠈꠤꠘ, ꠡꠥꠢꠞ ꠀꠞ ꠔꠣꠞ ꠇꠦꠘꠣꠘꠤ ꠛꠃꠞ ꠔꠞꠚꠣ ꠙꠥꠀ ꠡꠃꠟ, ꠄꠞꠣ ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("EX6_16","003_6_16","EXO","6","16","16","ꠈꠣꠘ꠆ꠖꠣꠘ ꠔꠣꠟꠤꠇꠣ ꠢꠤꠡꠣꠛꠦ ꠢꠎꠞꠔ ꠟꠦꠛꠤꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠎꠣꠞꠍꠥꠘ, ꠇꠣꠢꠣꠔ ꠀꠞ ꠝꠣꠞꠣꠞꠤ। ꠟꠦꠛꠤ ꠄꠇ-ꠡ ꠡꠣꠠꠔꠤꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX6_17","003_6_17","EXO","6","17","17","ꠎꠣꠞꠎꠤꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠙꠞꠗꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠎꠣꠞꠍꠥꠘꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠟꠤꠛꠘꠤ ꠀꠞ ꠡꠤꠝꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("EX6_18","003_6_18","EXO","6","18","18","ꠇꠣꠢꠣꠔꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠁꠝꠞꠣꠘ, ꠁꠎꠢꠣꠞ, ꠢꠦꠛꠞꠘ ꠀꠞ ꠃꠎ꠆ꠎꠟ। ꠇꠣꠢꠣꠔ ꠄꠇ-ꠡ ꠔꠦꠔ꠆ꠞꠤꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX6_19","003_6_19","EXO","6","19","19","ꠝꠣꠞꠣꠞꠤꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ, ꠝꠢꠟꠤ ꠀꠞ ꠝꠥꠡꠤ। ꠄꠞꠣꠃ ꠅꠁꠟꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("EX6_20","003_6_20","EXO","6","20","20","ꠁꠝꠞꠣꠘꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ। ꠁꠝꠞꠣꠘꠦ ꠔꠣꠘ ꠚꠥꠚꠥ ꠁꠃꠈꠣꠛꠦꠎꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠟꠣ, ꠔꠣꠘ ꠙꠦꠐꠅ ꠄꠞꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ꠁꠝꠞꠣꠘ ꠄꠇ-ꠡ ꠡꠣꠠꠔꠤꠡ ꠛꠞꠍ ꠛꠣꠌꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX6_21","003_6_21","EXO","6","21","21","ꠁꠎꠢꠣꠞꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠇꠥꠞꠣꠢ, ꠘꠦꠚꠉ, ꠎꠤꠈꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("EX6_22","003_6_22","EXO","6","22","22","ꠃꠎ꠆ꠎꠟꠞ ꠙꠥꠀꠂꠘ ꠝꠤꠡꠣꠄꠄꠟ, ꠄꠟꠎꠣꠚꠘ ꠀꠞ ꠎꠤꠔꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("EX6_23","003_6_23","EXO","6","23","23","ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠀꠝꠤꠘꠣꠖꠣꠛꠞ ꠙꠥꠠꠤ ꠘꠣꠢꠤꠡꠞ ꠛꠁꠘ ꠁꠟꠤꠡꠦꠛꠣꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠄ, ꠔꠣꠘ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠟꠣ ꠘꠣꠖꠣꠛ, ꠀꠛꠤꠢꠥ, ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠁꠍꠣꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("EX6_24","003_6_24","EXO","6","24","24","ꠇꠥꠞꠣꠢꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠅꠡꠤꠞ, ꠁꠟꠇꠣꠘꠣ, ꠅꠛꠤꠀꠡꠚ। ꠄꠞꠣ ꠇꠥꠞꠣꠢꠤ ꠅꠇꠟꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("EX6_25","003_6_25","EXO","6","25","25","ꠀꠟꠤ-ꠀꠎꠞꠞ ꠙꠥꠀ ꠅꠁꠟꠣ ꠙꠤꠘꠢꠡ। ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠙꠥꠐꠤꠄꠟꠞ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠄ ꠔꠣꠁꠞ ꠙꠦꠐꠅ ꠙꠤꠘꠢꠡꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ꠄꠞꠣ ꠅꠁꠟꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("EX6_26","003_6_26","EXO","6","26","26","ꠅꠃ ꠢꠣꠞꠥꠘ ꠀꠞ ꠝꠥꠍꠣꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠟꠣ, ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠟꠣꠈꠣꠘ ꠢꠣꠎꠤꠀ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EX6_27","003_6_27","EXO","6","27","27","ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠣꠞ ꠇꠕꠣ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX6_28","003_6_28","EXO","6","28","28","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠎꠦꠖꠤꠘ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX6_29","003_6_29","EXO","6","29","29","ꠢꠃ ꠖꠤꠘ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠝꠣꠛꠥꠖ। ꠔꠦ ꠔꠥꠝꠣꠞꠦ ꠅꠈꠘ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠁꠝꠥ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠥꠝꠤ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX6_30","003_6_30","EXO","6","30","30","ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞ ꠔ ꠝꠣꠔꠔꠦ ꠝꠥꠈꠅ ꠟꠣꠉꠤꠎꠣꠄ, ꠚꠦꠞꠣꠃꠘꠦ ꠇꠥꠘꠥ ꠀꠝꠣꠞ ꠝꠣꠔ ꠢꠥꠘꠛ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("EX7_1","003_7_1","EXO","7","1","1","ꠅꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠘꠣꠁꠝꠥ। ꠀꠞ ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘꠞꠦ ꠛꠣꠘꠣꠁꠝꠥ ꠔꠥꠝꠣꠞ ꠘꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("EX7_2","003_7_2","EXO","7","2","2","ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠝꠥ, ꠔꠥꠝꠤ ꠅꠃꠟꠣ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠛꠣꠄ, ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠅꠔꠣ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠛ; ꠎꠣꠔꠦ ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠔꠣꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠍꠣꠠꠤ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("EX7_3","003_7_3","EXO","7","3","3","ꠅꠁꠟꠦ ꠀꠝꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟꠤꠝꠥ। ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠝꠤ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠀꠞ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX7_4","003_7_4","EXO","7","4","4","ꠔꠣꠞ ꠛꠣꠖꠦꠅ ꠚꠦꠞꠣꠃꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠔꠞ ꠖꠣꠝ ꠖꠤꠔ ꠘꠣꠄ। ꠔꠦꠃ ꠀꠝꠤ ꠝꠤꠡꠞꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠀꠔ ꠟꠣꠉꠣꠁꠀ, ꠖꠦꠈꠣꠞ ꠝꠔ ꠡꠣꠎꠣ ꠖꠤꠀ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠘ꠆ꠖꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠍꠤꠙꠣꠁꠞ ꠟꠣꠈꠣꠘ ꠖꠟꠦ ꠖꠟꠦ ꠛꠣꠞ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX7_5","003_7_5","EXO","7","5","5","ꠝꠤꠡꠞꠞ ꠝꠣꠎꠦ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠀꠔ ꠟꠣꠉꠣꠁꠝꠥ, ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠝꠥ, ꠅꠃꠖꠤꠘ ꠔꠣꠞꠣ ꠛꠥꠎꠛꠣ ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("EX7_6","003_7_6","EXO","7","6","6","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠅꠃꠟꠣ ꠇꠞꠟꠣ, ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX7_7","003_7_7","EXO","7","7","7","ꠚꠦꠞꠣꠃꠘꠞ ꠟꠉꠦ ꠝꠣꠔ-ꠇꠕꠣꠞ ꠡꠝꠄ ꠝꠥꠍꠣꠞ ꠛꠄꠅꠡ ꠀꠍꠤꠟ ꠀꠡꠤ, ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠔꠤꠞꠣꠡꠤ ꠛꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("EX7_8","003_7_8","EXO","7","8","8","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX7_9","003_7_9","EXO","7","9","9","“ꠚꠦꠞꠣꠃꠘꠦ ꠎꠦꠛꠟꠣ ꠇꠁꠛ, ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠇꠥꠘꠥ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠅ, ꠔꠦꠃ ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠅ, ꠔꠣꠞ ꠟꠣꠑꠤ ꠘꠤꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠚꠣꠟꠣꠁꠔ, ꠚꠣꠟꠣꠘꠤꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠁꠐꠣ ꠢꠣꠚ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX7_10","003_7_10","EXO","7","10","10","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠟꠣ। ꠢꠣꠞꠥꠘꠦ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠍꠣꠝꠘꠦ ꠢꠃ ꠟꠣꠑꠤ ꠚꠣꠟꠣꠘꠤꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠁꠐꠣ ꠢꠣꠚ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX7_11","003_7_11","EXO","7","11","11","ꠅꠃ ꠚꠦꠞꠣꠃꠘꠦꠅ ꠔꠣꠞ ꠉꠥꠘꠤꠘ ꠀꠞ ꠎꠣꠖꠥꠉꠤꠞ ꠅꠇꠟꠞꠦ ꠀꠘꠣꠁꠟ, ꠔꠣꠞꠣꠅ ꠔꠣꠞꠣꠞ ꠎꠣꠖꠥ-ꠝꠘꠔ꠆ꠞ ꠖꠤꠀ ꠅꠃꠟꠣ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX7_12","003_7_12","EXO","7","12","12","ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠎꠣꠞꠎꠤꠞ ꠟꠣꠑꠤ ꠍꠣꠠꠟ, ꠀꠞ ꠄꠅꠔꠣ ꠢꠣꠚ ꠅꠁꠉꠦꠟ, ꠅꠁꠟꠦ ꠢꠣꠞꠥꠘꠞ ꠟꠣꠑꠤꠄ ꠔꠣꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠟꠣꠑꠤꠞꠦ ꠉꠤꠟꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX7_13","003_7_13","EXO","7","13","13","ꠁꠔꠣ ꠖꠦꠈꠤꠀꠅ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠞꠁꠟ, ꠢꠦ ꠄꠞꠣꠞ ꠝꠣꠔꠦ ꠇꠣꠘ ꠖꠤꠟ ꠘꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX7_14","003_7_14","EXO","7","14","14","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟ ꠔ ꠙꠣꠡꠣꠘ, ꠢꠦ ꠝꠣꠘꠡꠞꠦ ꠍꠣꠠꠔꠦ ꠞꠣꠎꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX7_15","003_7_15","EXO","7","15","15","ꠔꠦ ꠔꠥꠝꠤ ꠛꠤꠀꠘꠤ ꠛꠣꠟꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠅ, ꠉꠦꠟꠦ ꠖꠦꠈꠛꠣꠄ ꠢꠦ ꠙꠣꠘꠤꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛ, ꠔꠥꠝꠤ ꠔꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠟ ꠘꠖꠞ ꠙꠣꠞꠅ ꠃꠛꠣꠁꠅ। ꠔꠥꠝꠣꠞ ꠎꠦ ꠟꠣꠑꠤ ꠢꠣꠚ ꠅꠁꠍꠤꠟ, ꠅꠃ ꠟꠣꠑꠤ ꠀꠔꠅ ꠇꠞꠤ ꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX7_16","003_7_16","EXO","7","16","16","ꠘꠤꠀ ꠔꠣꠞꠦ ꠇꠁꠅ, ‘ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠀꠙꠘꠣꠞꠦ ꠅꠈꠣꠘ ꠇꠁꠔꠣꠝ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠢꠤꠎꠞꠔ ꠇꠞꠃꠇ, ꠔꠣ-ꠅ ꠅꠈꠘꠅ ꠔꠥꠝꠤ ꠢꠥꠘꠞꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX7_17","003_7_17","EXO","7","17","17","ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘ ꠔꠥꠝꠤ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ।’ ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠤ ꠇꠁꠅ, ‘ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠘꠤꠎꠞ ꠀꠔꠞ ꠟꠣꠑꠤ ꠖꠤꠀ ꠅꠃ ꠘꠤꠟ ꠘꠖꠞ ꠙꠣꠘꠤꠔ ꠛꠣꠠꠤ ꠝꠣꠞꠝꠥ, ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠙꠣꠘꠤ ꠟꠃ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX7_18","003_7_18","EXO","7","18","18","ꠢꠇ꠆ꠇꠟ ꠝꠣꠍ ꠝꠞꠤꠎꠤꠛ ꠀꠞ ꠙꠌꠣ ꠉꠘ꠆ꠖ ꠛꠣꠞ ꠅꠁꠛ, ꠔꠦꠃ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠅꠃ ꠘꠤꠟ ꠘꠖꠞ ꠙꠣꠘꠤ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣꠄ।’ ” ");
INSERT INTO syls_vpl VALUES ("EX7_19","003_7_19","EXO","7","19","19","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠣꠞꠥꠘꠞꠦ ꠅꠃ ꠇꠕꠣ ꠇꠅ, ꠔꠥꠝꠤ ꠘꠤꠎꠞ ꠟꠣꠑꠤ ꠟꠁꠀ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠢꠇ꠆ꠇꠟ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ, ꠖꠦꠡꠞ ꠉꠣꠋ-ꠘꠣꠟꠣ, ꠈꠣꠟ-ꠛꠤꠟ, ꠀꠅꠞ-ꠛꠣꠅꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠔꠥꠝꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠅ, ꠔꠦꠃ ꠁꠔꠣꠞ ꠢꠇ꠆ꠇꠟ ꠙꠣꠘꠤ ꠟꠃ ꠅꠁꠎꠤꠛ। ꠙꠣꠔ꠆ꠔꠞ ꠈꠥꠖꠤꠀ ꠛꠣꠘꠣꠁꠟ ꠛꠣ ꠟꠣꠇꠠꠤꠞ ꠙꠣꠔꠤꠟ-ꠇꠟꠡꠞ ꠝꠣꠎꠦ ꠕꠅꠀ ꠙꠣꠘꠤꠅ ꠟꠃ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX7_20","003_7_20","EXO","7","20","20","ꠅꠃ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠅꠃꠟꠣ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠟꠣꠑꠤ ꠃꠌꠣ ꠇꠞꠤ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠟ ꠘꠖꠞ ꠙꠣꠘꠤꠔ ꠛꠣꠠꠤ ꠝꠣꠞꠟꠣ, ꠔꠦꠃ ꠢꠇꠟ ꠙꠣꠘꠤ ꠟꠃ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX7_21","003_7_21","EXO","7","21","21","ꠘꠤꠟ ꠘꠖꠞ ꠢꠇꠟ ꠝꠣꠍ ꠝꠞꠤꠉꠦꠟ, ꠢꠇꠟ ꠙꠣꠘꠤꠔ ꠙꠌꠣ ꠉꠘ꠆ꠖ ꠛꠣꠞ ꠅꠁꠟ, ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠙꠣꠘꠤ ꠀꠞ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇꠟ ꠙꠣꠘꠤ ꠟꠃ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX7_22","003_7_22","EXO","7","22","22","ꠝꠤꠡꠞꠤ ꠎꠣꠖꠥꠉꠤꠞ ꠅꠇꠟꠦꠅ ꠔꠣꠞꠣꠞ ꠎꠣꠖꠥ-ꠝꠘꠔ꠆ꠞ ꠍꠣꠠꠤꠀ ꠅꠃꠟꠣ ꠇꠞꠟ, ꠄꠔꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠞꠁꠟ। ꠢꠦ ꠄꠞꠣꠞ ꠝꠣꠔꠅ ꠇꠣꠘ ꠖꠤꠟ ꠘꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX7_23","003_7_23","EXO","7","23","23","ꠛꠣꠖꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠙꠤꠍ ꠖꠤꠀ ꠔꠣꠞ ꠞꠣꠎꠛꠣꠠꠤꠔ ꠉꠦꠟꠉꠤ, ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠔꠃ ꠇꠣꠘ ꠖꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX7_24","003_7_24","EXO","7","24","24","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠤꠡꠞꠤꠄ ꠉꠣꠋꠉꠞ ꠙꠣꠘꠤ ꠈꠣꠁꠔꠦ ꠘꠣ ꠙꠣꠞꠣꠄ, ꠙꠣꠘꠤ ꠈꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠔꠣꠞꠣ ꠉꠣꠔ ꠈꠥꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX7_25","003_7_25","EXO","7","25","25","ꠘꠤꠟ ꠘꠖꠞ ꠙꠣꠘꠤꠔ ꠝꠣꠛꠥꠖꠞ ꠉꠎꠛ ꠘꠣꠎꠤꠟ ꠅꠀꠞ ꠛꠣꠖꠦ ꠡꠣꠔ ꠖꠤꠘ ꠉꠥꠎꠞꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX8_1","003_8_1","EXO","8","1","1","ꠅꠃ ꠡꠣꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠎꠣꠅ, ꠉꠤꠀ ꠔꠣꠞꠦ ꠇꠅ, ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠦ ꠇꠁꠞꠣ, ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("EX8_2","003_8_2","EXO","8","2","2","ꠔꠣꠞꠣꠞꠦ ꠘꠣ ꠍꠣꠠꠤꠀ ꠇꠥꠘꠥ ꠛꠣꠗꠣ ꠖꠤꠟꠦ, ꠀꠝꠤ ꠛꠦꠋ ꠖꠤꠀ ꠔꠥꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠅ ꠉꠎꠛ ꠓꠣꠟꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX8_3","003_8_3","EXO","8","3","3","ꠀꠡ꠆ꠔꠣ ꠘꠤꠟ ꠘꠖ ꠛꠦꠋꠉꠦ ꠜꠞꠤꠎꠤꠛꠣ, ꠀꠞ ꠁꠔꠣ ꠀꠁꠀ ꠔꠥꠝꠣꠞ ꠞꠣꠎꠛꠣꠠꠤꠔ, ꠢꠥꠔꠤꠛꠣꠞ ꠊꠞꠅ, ꠔꠥꠝꠣꠞ ꠛꠤꠍꠘꠣꠔ ꠃꠑꠤꠛꠣ। ꠀꠞ ꠔꠥꠝꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠊꠞꠅ, ꠔꠥꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠊꠞꠅ, ꠔꠥꠝꠣꠞ ꠃꠘ꠆ꠖꠣꠟ ꠀꠞ ꠙꠤꠑꠣ ꠛꠣꠘꠣꠁꠛꠣꠞ ꠉꠣꠝꠟꠣꠔꠅ ꠀꠁꠀ ꠢꠣꠝꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX8_4","003_8_4","EXO","8","4","4","ꠔꠥꠝꠣꠞ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ, ꠀꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠉꠔꠞꠅ ꠛꠦꠋ ꠃꠑꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX8_5","003_8_5","EXO","8","5","5","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠣꠞꠥꠘꠞꠦ ꠇꠅ, ꠔꠥꠝꠤ ꠘꠤꠟ ꠘꠖ ꠀꠞ ꠈꠣꠟ-ꠛꠤꠟꠞ ꠃꠙꠞꠦ ꠢꠃ ꠟꠣꠑꠤ ꠀꠟꠣ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞꠅ ꠛꠦꠋ ꠀꠘꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX8_6","003_8_6","EXO","8","6","6","ꠅꠃ ꠢꠣꠞꠥꠘꠦ ꠝꠤꠡꠞꠞ ꠢꠇꠟ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠀꠔ ꠛꠣꠠꠣꠁꠟꠣ, ꠔꠦꠃ ꠛꠦꠋꠉꠣꠁꠘ꠆ꠔꠦ ꠀꠁꠀ ꠝꠤꠡꠞ ꠖꠦꠡ ꠜꠞꠤꠀ ꠎꠣꠝ ꠅꠁꠉꠦꠟꠣ, ꠇꠥꠘꠥ ꠎꠣꠉꠣ ꠈꠣꠟꠤ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX8_7","003_8_7","EXO","8","7","7","ꠅꠁꠟꠦ ꠎꠣꠖꠥꠉꠤꠞ ꠅꠇꠟꠦꠅ ꠔꠣꠞꠣꠞ ꠎꠣꠖꠥ-ꠝꠘꠔ꠆ꠞ ꠖꠤꠀ ꠝꠤꠡꠞꠅ ꠅꠃꠟꠣ ꠛꠦꠋ ꠀꠘꠟ। ");
INSERT INTO syls_vpl VALUES ("EX8_8","003_8_8","EXO","8","8","8","ꠛꠣꠖꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠀꠞꠎ ꠇꠞꠅ, ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠞ ꠀꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠁ ꠛꠦꠋ ꠅꠇꠟ ꠢꠞꠣꠁꠀ ꠘꠦꠃꠇ꠆ꠇꠣ, ꠔꠣꠁꠟꠦ ꠀꠝꠤ ꠝꠣꠘꠡꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠝꠥ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠔ ꠙꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("EX8_9","003_8_9","EXO","8","9","9","ꠅꠃꠉꠤ ꠝꠥꠍꠣꠄ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠑꠤꠇ ꠇꠞꠤ ꠇꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠇꠥꠘ ꠡꠝꠄꠇꠥꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔꠤ ꠇꠞꠔꠣꠝ, ꠇꠥꠘ ꠡꠝꠄ ꠀꠙꠘꠣꠞ ꠊꠞ, ꠀꠙꠘꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠀꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠊꠞ ꠕꠣꠇꠤ ꠛꠦꠋ ꠅꠇꠟ ꠢꠞꠤꠀ ꠎꠣꠁꠔꠣꠉꠤ, ꠉꠤꠀ ꠈꠣꠟꠤ ꠉꠣꠋꠉꠅ ꠞꠁꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("EX8_10","003_8_10","EXO","8","10","10","ꠔꠣꠁꠘ ꠇꠁꠟꠣ “ꠇꠣꠁꠟꠇꠥꠞ ꠟꠣꠉꠤ।” ꠅꠃ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠎꠛꠣꠘ ꠝꠔꠃ ꠅꠃꠇ, ꠎꠣꠔꠦ ꠀꠙꠘꠦ ꠛꠥꠎꠔꠣ ꠙꠣꠞꠂꠘ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠝꠣꠘꠤ ꠀꠞ ꠇꠦꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("EX8_11","003_8_11","EXO","8","11","11","ꠛꠦꠋꠉꠣꠁꠘ꠆ꠔꠦ ꠀꠙꠘꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠀꠙꠘꠣꠞ ꠊꠞ-ꠛꠣꠠꠤ ꠕꠣꠇꠤ, ꠀꠙꠘꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠀꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠊꠞ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠤꠀ ꠈꠣꠟꠤ ꠘꠤꠟ ꠘꠖꠅ ꠞꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX8_12","003_8_12","EXO","8","12","12","ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠣꠞꠦ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠚꠞꠤꠀꠖ ꠇꠞꠟꠣ, ꠚꠦꠞꠣꠃꠘꠞ ꠃꠙꠞ ꠕꠣꠇꠤ ꠛꠦꠋꠉꠞ ꠉꠎꠛ ꠢꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX8_13","003_8_13","EXO","8","13","13","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞ ꠀꠞꠎꠤ ꠇꠛꠥꠟ ꠇꠞꠣꠄ, ꠔꠣꠞꠣꠞ ꠛꠣꠠꠤ-ꠊꠞ, ꠃꠑꠣꠘ ꠀꠞ ꠛꠘ꠆ꠖꠞ ꠢꠇꠟ ꠛꠦꠋ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX8_14","003_8_14","EXO","8","14","14","ꠀꠞ ꠝꠣꠘꠡꠦ ꠁꠔꠣꠞꠦ ꠎꠣꠉꠣꠄ ꠎꠣꠉꠣꠄ ꠖꠟꠣ ꠇꠞꠟꠦ, ꠙꠌꠤꠀ ꠖꠦꠡꠅ ꠉꠘ꠆ꠖ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX8_15","003_8_15","EXO","8","15","15","ꠅꠁꠟꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟ, ꠉꠎꠛ ꠔ ꠢꠞꠤꠉꠦꠍꠦ, ꠅꠃ ꠢꠦ ꠔꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟ꠆ꠟ। ꠄꠞꠣꠞ ꠝꠣꠔꠅ ꠀꠞ ꠇꠣꠘ ꠖꠤꠟ ꠘꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX8_16","003_8_16","EXO","8","16","16","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠅ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠣꠑꠤ ꠛꠣꠠꠣꠁꠀ ꠝꠣꠐꠤꠞ ꠗꠥꠟꠤꠔ ꠛꠣꠠꠤ ꠝꠣꠞꠅ, ꠔꠦꠃ ꠁ ꠗꠥꠁꠟ ꠝꠡꠣ ꠅꠁꠀ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡ ꠜꠞꠤꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX8_17","003_8_17","EXO","8","17","17","ꠔꠣꠞꠣ ꠅꠃꠟꠣ ꠇꠞꠟꠣ, ꠢꠣꠞꠥꠘꠦ ꠔꠣꠘ ꠟꠣꠑꠤ ꠀꠟꠣ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠝꠣꠐꠤꠞ ꠗꠥꠟꠤꠔ ꠛꠣꠠꠤ ꠝꠣꠞꠟꠣ, ꠔꠦꠃ ꠝꠣꠐꠤꠞ ꠢꠇ꠆ꠇꠟ ꠗꠥꠁꠟ ꠝꠡꠣ ꠅꠁꠉꠦꠟ। ꠅꠃ ꠝꠡꠣꠄ ꠝꠣꠘꠥꠡ, ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠝꠤꠡꠞꠞ ꠢꠇ꠆ꠇꠟꠛꠣꠄ ꠜꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX8_18","003_8_18","EXO","8","18","18","ꠀꠞ ꠎꠣꠖꠥꠉꠤꠞ ꠅꠇꠟꠦꠅ ꠔꠣꠞꠣꠞ ꠎꠣꠖꠥ-ꠝꠘꠔ꠆ꠞ ꠖꠤꠀ ꠅꠃꠟꠣ ꠝꠡꠣ ꠛꠣꠘꠣꠁꠔ ꠌꠣꠁꠟ, ꠅꠁꠟꠦ ꠙꠣꠞꠟ ꠘꠣ। ꠝꠣꠘꠥꠡ ꠀꠞ ꠎꠣꠘꠥꠀꠞꠞ ꠝꠣꠎꠦ ꠝꠡꠣ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX8_19","003_8_19","EXO","8","19","19","ꠔꠦꠃ ꠎꠣꠖꠥꠉꠤꠞ ꠅꠇꠟꠦ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔ।” ꠔꠣ-ꠅ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠞꠁꠟ, ꠢꠦ ꠄꠞꠣꠞ ꠝꠣꠔꠦ ꠇꠣꠘ ꠖꠤꠟ ꠘꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX8_20","003_8_20","EXO","8","20","20","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠚꠎꠞꠦ ꠃꠑꠤꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠀꠎꠤꠞ ꠅꠅ, ꠉꠦꠟꠦ ꠖꠦꠈꠛꠣꠄ ꠢꠦ ꠙꠣꠘꠤꠞ ꠉꠦꠍꠦ ꠀꠁꠛ। ꠔꠥꠝꠤ ꠔꠣꠞꠦ ꠅꠃꠟꠣ ꠇꠁꠅ, ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠦ ꠇꠁꠞꠣ, ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("EX8_21","003_8_21","EXO","8","21","21","ꠎꠥꠖꠤ ꠘꠣ ꠍꠣꠠꠅ ꠔꠣꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ, ꠔꠥꠝꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ, ꠔꠥꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠊꠞꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠇꠣꠝꠠꠣꠅꠞꠣ ꠒꠣꠡ-ꠝꠣꠍꠤꠞ ꠙꠣꠟ ꠙꠣꠑꠣꠁꠝꠥ, ꠁꠔꠣ ꠙꠣꠟꠦ ꠙꠣꠟꠦ ꠀꠁꠀ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠊꠞꠅ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠡꠔ-ꠜꠤꠐꠣ ꠡꠢ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠎꠣꠝ ꠅꠁꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX8_22","003_8_22","EXO","8","22","22","ꠅꠁꠟꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠉꠥꠡꠘ ꠄꠟꠣꠇꠣꠞꠦ ꠁꠔꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠝꠥ, ꠁꠘꠅ ꠒꠣꠡ-ꠝꠣꠍꠤꠞ ꠙꠣꠟ ꠀꠁꠔꠣ ꠘꠣꠄ। ꠔꠦꠃ ꠔꠥꠝꠤ ꠛꠥꠎꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠁ ꠖꠦꠡꠅ ꠀꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX8_23","003_8_23","EXO","8","23","23","ꠀꠝꠤ ꠔ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙ꠆ꠞꠎꠣꠞ ꠝꠣꠎꠦ ꠔꠚꠣꠔ-ꠙꠣꠞ꠆ꠕꠇ꠆ꠇ ꠇꠞꠝꠥ, ꠇꠣꠁꠟ ꠁ ꠘꠝꠥꠘꠣ ꠖꠦꠈꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX8_24","003_8_24","EXO","8","24","24","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠅꠃꠟꠣ ꠇꠞꠟꠣ, ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠊꠞꠅ ꠇꠣꠝꠠꠣꠅꠞꠣ ꠒꠣꠡ-ꠝꠣꠍꠤꠞ ꠙꠣꠟ ꠀꠁꠟ, ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟꠛꠣꠄ ꠒꠣꠡ-ꠝꠣꠍꠤꠞ ꠟꠣꠉꠤ ꠡꠞ꠆ꠛꠘꠣꠡ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX8_25","003_8_25","EXO","8","25","25","ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠒꠣꠇꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠣꠅ, ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠅꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX8_26","003_8_26","EXO","8","26","26","ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁꠟꠣ ꠇꠞꠣ ꠑꠤꠇ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠊꠤꠘ꠆ꠘꠣ ꠇꠞꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠀꠞ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠣꠞ ꠊꠤꠘ꠆ꠘꠣ ꠇꠞꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠟꠦ ꠔꠣꠞꠣ ꠔ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠁꠐꠣꠁꠀ ꠝꠣꠞꠤꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX8_27","003_8_27","EXO","8","27","27","ꠔꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠛꠣ, ꠀꠝꠞꠣ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠔꠤꠘ ꠖꠤꠘꠞ ꠙꠕ ꠢꠞꠤꠀ ꠉꠤꠀ, ꠔꠣꠘ ꠘꠣꠝꠦ ꠅꠃꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX8_28","003_8_28","EXO","8","28","28","ꠚꠦꠞꠣꠃꠘꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠅ। ꠅꠁꠟꠦ ꠛꠦꠡꠤ ꠖꠥꠞꠁ ꠎꠣꠁꠅ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤꠅ ꠝꠤꠘꠔ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX8_29","003_8_29","EXO","8","29","29","ꠅꠃ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔꠤ ꠇꠞꠝꠥ, ꠔꠦꠃ ꠇꠣꠁꠟ ꠀꠙꠘꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠀꠙꠘꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠀꠞ ꠀꠙꠘꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠒꠣꠡ-ꠝꠣꠍꠤꠞ ꠙꠣꠟ ꠢꠞꠤꠎꠤꠛꠣ। ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣꠔ ꠎꠣꠁꠔꠦ ꠀꠙꠘꠦ ꠀꠞ ꠇꠥꠘꠥ ꠜꠣꠅꠔꠣꠛꠣꠎꠤ ꠇꠞꠂꠘ ꠘꠣ ꠎꠣꠘꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX8_30","003_8_30","EXO","8","30","30","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX8_31","003_8_31","EXO","8","31","31","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞ ꠀꠞꠎꠤ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠟꠣ। ꠚꠦꠞꠣꠃꠘ, ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠀꠞ ꠔꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠇ꠆ꠇꠟ ꠒꠣꠡ-ꠝꠣꠍꠤ ꠢꠞꠤꠉꠦꠟꠣ, ꠄꠉꠥꠅ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX8_32","003_8_32","EXO","8","32","32","ꠅꠁꠟꠦ ꠢꠤꠞꠛꠣꠞ ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟ꠆ꠟ, ꠝꠣꠘꠡꠞꠦ ꠍꠣꠠꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_1","003_9_1","EXO","9","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠔꠣꠞꠦ ꠇꠅ, ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠇꠁꠞꠣ, ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("EX9_2","003_9_2","EXO","9","2","2","ꠔꠣꠞꠣꠞꠦ ꠍꠣꠠꠔꠦ ꠞꠣꠎꠤ ꠘꠣ ꠅꠁꠀ ꠅꠈꠘꠅ ꠛꠣꠗꠣ ꠖꠤꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("EX9_3","003_9_3","EXO","9","3","3","ꠢꠥꠘꠤꠀ ꠞꠣꠈꠅ, ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠣꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦ, ꠊꠥꠠꠣꠁꠘ꠆ꠔꠞ, ꠉꠣꠗꠣꠁꠘ꠆ꠔꠞ, ꠃꠐ, ꠀꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ, ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦꠅ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠀꠔ ꠖꠤꠝꠥ, ꠛꠦꠕꠣꠄꠀ ꠛꠦꠝꠣꠞꠞ ꠝꠞꠇꠤ ꠍꠣꠠꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX9_4","003_9_4","EXO","9","4","4","ꠅꠁꠟꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞꠞ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠡꠥꠞ ꠝꠣꠎꠦ ꠔꠚꠣꠔ ꠇꠞꠝꠥ; ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠥꠘꠥ ꠙꠡꠥ ꠝꠞꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX9_5","003_9_5","EXO","9","5","5","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠡꠝꠄꠅ ꠑꠤꠇ ꠇꠞꠤꠀ ꠖꠤꠟꠣꠁꠟꠣ, ꠍꠣꠝꠘꠞ ꠇꠣꠁꠟ ꠔꠣꠁꠘ ꠖꠦꠡꠅ ꠁ ꠇꠣꠝ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_6","003_9_6","EXO","9","6","6","ꠢꠣꠍꠣꠃ ꠛꠣꠖꠞ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠦ ꠅꠃꠟꠣꠃ ꠇꠞꠟꠣ, ꠔꠦꠃ ꠝꠤꠡꠞꠞ ꠢꠇ꠆ꠇꠟ ꠙꠡꠥ ꠝꠞꠤꠉꠦꠟꠣ, ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠄꠉꠥ ꠙꠡꠥꠅ ꠝꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_7","003_9_7","EXO","9","7","7","ꠚꠦꠞꠣꠃꠘꠦ ꠝꠣꠘꠥꠡꠖꠤ ꠈꠛꠞ ꠟꠁꠀ ꠖꠦꠈꠟ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠄꠉꠥ ꠙꠡꠥꠅ ꠝꠞꠍꠂꠘ ꠘꠣ; ꠔꠣ-ꠅ ꠔꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠞꠁꠟ, ꠢꠦ ꠝꠣꠘꠡꠞꠦ ꠍꠣꠠꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_8","003_9_8","EXO","9","8","8","ꠅꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠝꠥꠁꠐ ꠜꠞꠤꠀ ꠃꠘ꠆ꠖꠣꠟꠞ ꠍꠣꠟꠤ ꠀꠘꠅ, ꠀꠘꠤꠀ ꠝꠥꠍꠣꠄ ꠅꠃ ꠍꠣꠟꠤꠞꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠃꠙꠞꠦꠖꠤ ꠍꠤꠐꠣꠁ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("EX9_9","003_9_9","EXO","9","9","9","ꠖꠦꠈꠛꠣꠄꠘꠦ, ꠁꠔꠣ ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠙꠣꠔꠟꠣ ꠗꠥꠁꠟ ꠅꠁꠀ ꠢꠇꠟ ꠎꠣꠉꠣꠞ ꠝꠣꠘꠥꠡ ꠀꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠉꠔꠞꠅ ꠉꠎꠛꠤ ꠛꠤꠡ-ꠚꠥꠞꠤ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX9_10","003_9_10","EXO","9","10","10","ꠔꠦꠃ ꠔꠣꠞꠣ ꠃꠘ꠆ꠖꠣꠟꠞ ꠍꠣꠟꠤ ꠀꠘꠤꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠀ, ꠝꠥꠍꠣꠄ ꠃꠙꠞꠦꠖꠤ ꠍꠤꠐꠣꠁ ꠖꠤꠟꠣ, ꠄꠔꠦ ꠝꠣꠘꠡꠞ ꠀꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠉꠔꠞꠅ ꠛꠤꠡ-ꠚꠥꠞꠤ ꠚꠥꠐꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX9_11","003_9_11","EXO","9","11","11","ꠀꠞ ꠅꠃ ꠚꠥꠞꠤꠞ ꠟꠣꠉꠤ ꠎꠣꠖꠥꠉꠤꠞ ꠅꠇꠟꠦ ꠝꠥꠍꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠢꠇꠟ ꠝꠤꠡꠞꠤ ꠀꠞ ꠎꠣꠖꠥꠉꠤꠞ ꠅꠇꠟꠞ ꠉꠔꠞꠅ-ꠅ ꠛꠤꠡ-ꠚꠥꠞꠤ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX9_12","003_9_12","EXO","9","12","12","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟ꠆ꠟꠣ। ꠢꠦ ꠄꠞꠣꠞ ꠝꠣꠔꠦ ꠇꠣꠘ ꠖꠤꠟ ꠘꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_13","003_9_13","EXO","9","13","13","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠛꠤꠀꠘꠦ ꠃꠑꠤꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠀ ꠅꠃꠟꠣ ꠇꠁꠅ, ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠇꠁꠞꠣ, ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("EX9_14","003_9_14","EXO","9","14","14","ꠘꠣꠁꠟꠦ ꠁꠚꠤꠞꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞ, ꠔꠥꠝꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠀꠝꠣꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠉꠎꠛ ꠍꠣꠠꠤꠝꠥ। ꠔꠦꠃ ꠔꠥꠝꠤ ꠛꠥꠎꠛꠣꠄ, ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠀꠝꠣꠞ ꠢꠝꠣꠘꠤ ꠇꠦꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("EX9_15","003_9_15","EXO","9","15","15","ꠄꠞ ꠀꠉꠦꠃ ꠀꠝꠤ ꠀꠝꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠛꠦꠕꠣꠄꠀ ꠝꠞꠇꠤ ꠖꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞꠦ ꠝꠣꠞꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠅꠘꠦ, ꠔꠥꠝꠤ ꠖꠥꠘꠤꠀꠁ ꠕꠣꠇꠤ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟꠣꠄ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("EX9_16","003_9_16","EXO","9","16","16","ꠀꠍꠟꠦ ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠘꠤꠀꠁꠔ ꠅꠔꠖꠤꠘ ꠛꠣꠌꠣꠁꠍꠤ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞꠦ ꠀꠝꠣꠞ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠣꠁ, ꠀꠞ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠀꠝꠣꠞ ꠘꠣꠝ ꠎꠣꠁꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EX9_17","003_9_17","EXO","9","17","17","ꠔꠥꠝꠤ ꠅꠈꠘꠅ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠍꠣꠠꠞꠣꠄ ꠘꠣ, ꠔꠥꠝꠣꠞ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠞꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("EX9_18","003_9_18","EXO","9","18","18","ꠔꠦ ꠖꠦꠈꠤꠅ, ꠇꠣꠁꠟ ꠁ ꠡꠝꠄꠄ ꠀꠝꠤ ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠀꠞ ꠝꠦꠊ ꠖꠤꠝꠥ, ꠎꠦꠔꠣ ꠝꠤꠡꠞꠞ ꠎꠘꠝ ꠕꠣꠇꠤ ꠀꠁꠎ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_19","003_9_19","EXO","9","19","19","ꠄꠞꠟꠣꠉꠤ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠣꠞ ꠙꠡꠥꠁꠘ ꠀꠞ ꠎꠔꠔꠣ ꠀꠍꠦ, ꠁꠔꠣꠞꠦ ꠀꠘꠤꠀ ꠊꠞꠅ ꠢꠣꠞꠣꠅ; ꠝꠣꠘꠥꠡ ꠛꠣ ꠙꠡꠥꠁꠘ ꠎꠦꠔꠣ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠔꠣ ꠘꠣꠄ, ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠢꠤꠟ ꠙꠠꠤꠀ ꠢꠇ꠆ꠇꠟꠐꠤ ꠝꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX9_20","003_9_20","EXO","9","20","20","ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠎꠛꠣꠘꠦ ꠒꠞꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠎꠟꠖꠤ ꠇꠞꠤ ꠘꠤꠎꠞ ꠉꠥꠟꠣꠝ ꠀꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞꠦ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_21","003_9_21","EXO","9","21","21","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠎꠛꠣꠘꠞꠦ ꠎꠦꠔꠣꠄ ꠖꠣꠝ ꠖꠤꠟ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠉꠥꠟꠣꠝ ꠀꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞꠦ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠕꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX9_22","003_9_22","EXO","9","22","22","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠍꠝꠣꠘꠞ ꠛꠣꠄ ꠘꠤꠎꠞ ꠀꠔ ꠛꠣꠠꠣꠅ, ꠔꠦꠃ ꠝꠤꠡꠞꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠉꠣꠔ ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠅꠁꠛ, ꠝꠤꠡꠞꠞ ꠝꠣꠘꠥꠡ, ꠙꠡꠥ ꠀꠞ ꠈꠦꠔꠞ ꠢꠇꠟ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤꠞ ꠃꠙꠞꠦ ꠁꠔꠣ ꠙꠠꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX9_23","003_9_23","EXO","9","23","23","ꠅꠃ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠀꠔꠞ ꠟꠣꠑꠤ ꠃꠙꠞꠦꠖꠤ ꠔꠥꠟꠟꠣ, ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠝꠦꠊꠞ ꠒꠣꠇ-ꠎꠤꠟꠇꠣꠘꠤꠞ ꠟꠉꠦ ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠖꠦꠅꠀꠁꠟꠣ; ꠀꠞ ꠀꠍꠝꠣꠘꠤ ꠑꠣꠐꠣ ꠎꠝꠤꠘꠅ ꠙꠠꠟ। ");
INSERT INTO syls_vpl VALUES ("EX9_24","003_9_24","EXO","9","24","24","ꠅꠃ ꠢꠤꠟꠞ ꠟꠉꠦ ꠝꠦꠊꠞ ꠎꠤꠟꠇꠣꠘꠤ ꠀꠞ ꠑꠣꠐꠣꠅ ꠀꠍꠤꠟ। ꠁ ꠟꠣꠈꠣꠘ ꠉꠎꠛꠤ ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠎꠘꠝ ꠕꠣꠇꠤ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_25","003_9_25","EXO","9","25","25","ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠥꠡ ꠀꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦꠅ ꠈꠥꠛ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠢꠤꠟ ꠙꠠꠟ, ꠀꠞ ꠈꠦꠔꠞ ꠢꠇꠟ ꠚꠡꠟ ꠘꠡ꠆ꠐ ꠅꠁꠉꠦꠟ ꠀꠞ ꠢꠇꠟ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤꠅ ꠜꠣꠋꠉꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX9_26","003_9_26","EXO","9","26","26","ꠈꠣꠟꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠉꠥꠡꠘ ꠄꠟꠣꠇꠣꠔ ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_27","003_9_27","EXO","9","27","27","ꠛꠣꠖꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠁꠀ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟ, “ꠁꠚꠤꠞꠣ ꠀꠝꠤ ꠅꠙꠞꠣꠗ ꠇꠞꠍꠤ। ꠝꠣꠛꠥꠖ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠀꠞ ꠀꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟ ꠅꠙꠞꠣꠗꠤ। ");
INSERT INTO syls_vpl VALUES ("EX9_28","003_9_28","EXO","9","28","28","ꠔꠦ ꠉꠎꠛꠤ ꠝꠦꠊꠞ ꠒꠣꠇ ꠀꠞ ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠔ ꠛꠃꠔ ꠅꠁꠍꠦ, ꠀꠞ ꠎꠣꠞꠔꠣꠝ ꠙꠣꠞꠤꠀꠞ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠝꠥ, ꠀꠞ ꠀꠐꠇꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX9_29","003_9_29","EXO","9","29","29","ꠝꠥꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠐꠣꠃꠘꠞ ꠛꠣꠁꠞꠦ ꠉꠤꠀꠃ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠀꠔ ꠔꠥꠟꠝꠥ, ꠔꠦꠃ ꠝꠦꠊꠞ ꠒꠣꠇ, ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠛꠘ꠆ꠖ ꠅꠁꠎꠤꠛ, ꠎꠣꠔꠦ ꠀꠙꠘꠦ ꠛꠥꠎꠔꠣ ꠙꠣꠞꠂꠘ ꠁ ꠖꠥꠘꠤꠀꠁ ꠔ ꠝꠣꠛꠥꠖꠞ। ");
INSERT INTO syls_vpl VALUES ("EX9_30","003_9_30","EXO","9","30","30","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ, ꠀꠙꠘꠦ ꠛꠣ ꠀꠙꠘꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠅꠇꠟꠦ ꠅꠈꠘꠅ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠒꠞꠣꠁꠞꠣ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX9_31","003_9_31","EXO","9","31","31","ꠁ ꠡꠝꠄ ꠈꠦꠔꠞ ꠢꠇꠟ ꠘꠣꠟꠤꠀ ꠉꠣꠍ ꠀꠞ ꠛꠣꠞ꠆ꠟꠤ ꠚꠡꠟ ꠘꠡ꠆ꠐ ꠅꠁꠉꠦꠟ, ꠇꠣꠞꠘ ꠘꠣꠟꠤꠀ ꠉꠣꠍꠞ ꠚꠥꠟ ꠀꠞ ꠛꠣꠞ꠆ꠟꠤꠞ ꠍꠠꠣ ꠛꠣꠞ ꠅꠁꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX9_32","003_9_32","EXO","9","32","32","ꠅꠁꠟꠦ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠉꠝꠞ ꠉꠣꠍ ꠛꠠ ꠘꠣ ꠅꠀꠄ ꠁꠔꠣꠞ ꠈꠦꠔꠤ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX9_33","003_9_33","EXO","9","33","33","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠀꠔ ꠔꠥꠟꠟꠣ, ꠟꠉꠦ ꠟꠉꠦ ꠝꠦꠊꠞ ꠒꠣꠇ, ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠛꠘ꠆ꠖ ꠅꠁꠟ, ꠝꠦꠊꠞ ꠎꠠꠤꠅ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX9_34","003_9_34","EXO","9","34","34","ꠅꠁꠟꠦ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠅꠇꠟꠦ ꠝꠦꠊ, ꠝꠦꠊꠞ ꠒꠣꠇ ꠀꠞ ꠢꠤꠟ ꠙꠠꠣ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠍꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟ꠆ꠟꠣ। ꠚꠦꠞꠣꠃꠘꠦ ꠢꠤꠞꠛꠣꠞ ꠉꠥꠘꠣ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("EX9_35","003_9_35","EXO","9","35","35","ꠔꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠅꠁꠎꠣꠅꠀꠄ, ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠍꠣꠠꠟ ꠘꠣ, ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠎꠦꠟꠣ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX10_1","003_10_1","EXO","10","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠎꠣꠅ; ꠀꠝꠤ ꠔ ꠔꠣꠞ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟꠤꠍꠤ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("EX10_2","003_10_2","EXO","10","2","2","ꠀꠝꠤ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠑꠤꠘ ꠉꠎꠛ ꠖꠤꠍꠤ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠖꠞꠔꠤ ꠎꠦꠔꠣ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠎꠣꠁꠞ ꠇꠞꠍꠤ, ꠔꠥꠝꠤ ꠁꠔꠣ ꠔꠥꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠀꠞ ꠘꠣꠔꠤ-ꠙꠥꠔꠤꠞ ꠉꠦꠍꠦ ꠉꠚ ꠇꠞꠔꠣꠄ ꠙꠣꠞ, ꠀꠞ ꠀꠝꠤꠃ ꠎꠦꠘ ꠝꠣꠛꠥꠖ ꠁꠐꠣ ꠛꠥꠎꠔꠣꠄ ꠙꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("EX10_3","003_10_3","EXO","10","3","3","ꠔꠦꠃ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣ, ꠎꠦꠁꠘ ꠁꠛꠞꠣꠘꠤ ꠅꠇꠟꠞ ꠝꠣꠛꠥꠖ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠇꠁꠞꠣ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠔꠦ ꠀꠞ ꠇꠔꠖꠤꠘ ꠢꠞꠣꠁꠟ ꠞꠁꠔꠣꠄ? ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠣꠠꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("EX10_4","003_10_4","EXO","10","4","4","ꠔꠣꠞꠣꠞꠦ ꠍꠣꠠꠔꠦ ꠞꠣꠎꠤ ꠘꠣ ꠅꠁꠟꠦ ꠖꠦꠈꠤꠅ, ꠀꠝꠤ ꠇꠣꠁꠟ ꠔꠥꠝꠣꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠙꠋꠉꠙꠣꠟ ꠅꠇꠟ ꠍꠣꠠꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX10_5","003_10_5","EXO","10","5","5","ꠁꠔꠣꠄ ꠀꠁꠀ ꠔꠥꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠎꠝꠤꠘꠞꠦ ꠅꠃꠟꠣ ꠛꠦꠞꠤꠟꠤꠛꠣ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠝꠣꠐꠤ ꠖꠦꠈꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠕꠣꠇꠤ ꠎꠔꠔꠣ ꠛꠣꠌꠤꠉꠦꠍꠦ, ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠎꠔ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤ ꠞꠁꠍꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠣꠞꠣ ꠈꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX10_6","003_10_6","EXO","10","6","6","ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠊꠞ-ꠛꠣꠠꠤ, ꠔꠥꠝꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠊꠞꠣꠁꠘ, ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠊꠞꠣꠁꠘ ꠜꠞꠤꠀ ꠎꠣꠝ ꠅꠁꠎꠤꠛꠣ। ꠔꠥꠝꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠦꠅ ꠖꠥꠘꠤꠀꠁꠔ ꠔꠣꠞꠣꠞ ꠎꠘꠝ ꠕꠣꠇꠤ ꠀꠁꠎ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠃꠟꠣ ꠖꠦꠈꠍꠂꠘ ꠘꠣ।” ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠣꠞꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX10_7","003_10_7","EXO","10","7","7","ꠚꠦꠞꠣꠃꠘꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠦ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁ ꠛꠦꠐꠣꠄ ꠀꠞ ꠇꠔꠖꠤꠘ ꠀꠝꠞꠣꠞꠦ ꠍꠣꠔꠣꠁꠔ? ꠅꠔꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔꠞ ꠟꠣꠉꠤ ꠅꠔꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠀꠙꠘꠦ ꠅꠈꠘꠅ ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠞꠣ ꠘꠣ ꠘꠤ, ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠘꠥ ꠍꠣꠞꠈꠣꠞ ꠅꠁꠎꠣꠞ?” ");
INSERT INTO syls_vpl VALUES ("EX10_8","003_10_8","EXO","10","8","8","ꠅꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠀꠘꠣꠁꠟ, ꠀꠘꠣꠁꠀ ꠇꠁꠟ, “ꠔꠥꠝꠞꠣ ꠎꠣꠅꠉꠤ, ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠅ। ꠅꠁꠟꠦ ꠇꠦ ꠇꠦ ꠎꠣꠁꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("EX10_9","003_10_9","EXO","10","9","9","ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠢꠎꠅ ꠎꠣꠁꠞꠣꠝ। ꠔꠦ ꠀꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠝꠥꠞꠛ꠆ꠛꠤ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠀꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠟꠁꠀ ꠎꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX10_10","003_10_10","EXO","10","10","10","ꠚꠦꠞꠣꠃꠘꠦ ꠇꠁꠟ, “ꠀꠁꠌ꠆ꠍꠣ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠢꠣꠍꠣꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣ-ꠝꠥꠞꠥꠔ꠆ꠔꠣ ꠖꠤꠀ ꠍꠣꠠꠤ ꠖꠦꠁ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠅꠃ ꠝꠣꠛꠥꠖꠅ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠄꠉꠤ। ꠈꠛꠞꠖꠣꠞ! ꠔꠥꠝꠞꠣꠞ ꠝꠔꠟꠛ ꠔ ꠜꠣꠟꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX10_11","003_10_11","EXO","10","11","11","ꠘꠣ, ꠁꠟꠣ ꠔ ꠅꠁꠔ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠘꠤꠔꠦ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠣꠁꠔꠣꠄꠃ ꠌꠣꠁꠞꠣꠄ, ꠔꠦ ꠈꠣꠟꠤ ꠛꠦꠐꠣꠁꠘ ꠎꠣꠅꠉꠤ।” ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX10_12","003_10_12","EXO","10","12","12","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠙꠋꠉꠙꠣꠟꠞ ꠟꠣꠉꠤ ꠀꠔ ꠔꠥꠟꠅ, ꠙꠋꠉꠙꠣꠟꠦ ꠀꠁꠀ ꠝꠤꠡꠞꠞ ꠎꠝꠤꠘꠞ ꠢꠇꠟ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤ ꠈꠣꠁꠟꠤꠛ। ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠕꠣꠇꠤ ꠎꠔꠔꠣ ꠛꠣꠌꠤꠍꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠈꠣꠁꠟꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX10_13","003_10_13","EXO","10","13","13","ꠝꠥꠍꠣꠄ ꠝꠤꠡꠞꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠟꠣꠑꠤ ꠝꠦꠟꠤꠀ ꠗꠞꠟꠣ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠢꠣꠞꠣ ꠖꠤꠘ ꠢꠣꠞꠣ ꠞꠣꠁꠔ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠙꠥꠛꠣꠟꠤ ꠢꠣꠅꠀ ꠍꠣꠠꠟꠣ, ꠅꠃ ꠙꠥꠛꠣꠟꠤ ꠢꠣꠅꠀꠄ ꠛꠤꠀꠘꠦ ꠙꠋꠉꠙꠣꠟ ꠟꠁꠀ ꠀꠎꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX10_14","003_10_14","EXO","10","14","14","ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠙꠋꠉꠙꠣꠟꠦ ꠎꠣꠝ ꠅꠁꠉꠦꠟꠣ। ꠝꠤꠡꠞꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠙꠋꠉꠙꠣꠟꠦ ꠉꠤꠍꠉꠤꠍ ꠇꠞꠟꠣ, ꠈꠥꠛ ꠛꠦꠡꠤ ꠙꠋꠉꠙꠣꠟ ꠀꠁꠟꠣ, ꠅꠔ ꠙꠋꠉꠙꠣꠟ ꠄꠞ ꠀꠉꠦꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠁꠍꠂꠘ ꠘꠣ ꠀꠞ ꠛꠣꠖꠦꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX10_15","003_10_15","EXO","10","15","15","ꠔꠣꠞꠣ ꠀꠡ꠆ꠔꠣ ꠎꠝꠤꠘꠞ ꠃꠙꠞ ꠉꠥꠞꠤꠟꠤꠟꠣ, ꠖꠦꠡ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠟ, ꠀꠞ ꠎꠝꠤꠘꠞ ꠎꠔ ꠈꠦꠔ, ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤ ꠢꠤꠟ-ꠔꠥꠚꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠉꠦꠍꠤꠟ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠈꠣꠁꠟꠤꠟꠣ। ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞꠞ ꠇꠥꠘꠥ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤ ꠛꠣ ꠈꠦꠔꠞ ꠚꠡꠟ ꠇꠥꠘ꠆ꠔꠣꠃ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX10_16","003_10_16","EXO","10","16","16","ꠚꠦꠞꠣꠃꠘꠦ ꠎꠟꠖꠤ ꠇꠞꠤ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟ, “ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠁꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX10_17","003_10_17","EXO","10","17","17","ꠔꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠈꠣꠟꠤ ꠄꠇꠈꠣꠘ ꠛꠣꠞ ꠀꠝꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠦꠅ। ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠁ ꠝꠞꠘ ꠀꠙꠖꠞꠦ ꠢꠞꠣꠁ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX10_18","003_10_18","EXO","10","18","18","ꠅꠃ ꠝꠥꠍꠣꠄ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ ꠇꠞꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("EX10_19","003_10_19","EXO","10","19","19","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠈꠥꠛ ꠎꠥꠞꠦ ꠙꠌ꠆ꠌꠤꠝꠣ ꠢꠣꠅꠀ ꠍꠣꠠꠟꠣ, ꠁꠔꠣꠄ ꠙꠋꠉꠙꠣꠟ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠍꠣꠚ ꠇꠞꠤꠀ ꠘꠤꠟ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁꠟ, ꠝꠤꠡꠞꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠄꠉꠥ ꠙꠥꠇꠅ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX10_20","003_10_20","EXO","10","20","20","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟ꠆ꠟꠣ, ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠍꠣꠠꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX10_21","003_10_21","EXO","10","21","21","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠍꠝꠣꠘ ꠝꠥꠈꠣ ꠔꠥꠝꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠅ; ꠔꠦꠃ ꠢꠣꠞꠣ ꠖꠦꠡꠅ ꠅꠔ ꠊꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠛ, ꠁ ꠀꠘ꠆ꠖꠣꠁꠞ ꠀꠔ ꠖꠤꠀ ꠍꠥꠀ ꠎꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX10_22","003_10_22","EXO","10","22","22","ꠝꠥꠍꠣꠄ ꠀꠍꠝꠣꠘ ꠝꠥꠈꠣ ꠀꠔ ꠛꠣꠠꠣꠁꠟꠦ ꠔꠤꠘ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡ ꠈꠥꠛ ꠊꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX10_23","003_10_23","EXO","10","23","23","ꠔꠤꠘ ꠖꠤꠘ ꠇꠦꠃ ꠇꠦꠃꠞꠞ ꠝꠥꠈꠅ ꠖꠦꠈꠔ ꠙꠣꠞꠟ ꠘꠣ, ꠇꠦꠃ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠟꠠꠔ ꠙꠣꠞꠟ ꠘꠣ। ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠊꠞꠅ ꠇꠥꠘꠥ ꠞꠥꠡꠘꠤꠞ ꠅꠜꠣꠛ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX10_24","003_10_24","EXO","10","24","24","ꠚꠦꠞꠣꠃꠘꠦ ꠝꠥꠍꠣꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟ, “ꠎꠣꠅ, ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠅ, ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦꠅ ꠘꠦꠅꠉꠤ, ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠣꠟ ꠕꠣꠇꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("EX10_25","003_10_25","EXO","10","25","25","ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠁꠘ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠘꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX10_26","003_10_26","EXO","10","26","26","ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠀꠝꠞꠣꠞ ꠙꠡꠥꠁꠘꠅ ꠎꠣꠁꠛꠣ, ꠙꠡꠥꠞ ꠄꠇꠈꠣꠘ ꠈꠥꠞꠣꠅ ꠕꠁꠀ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔꠞ ꠟꠣꠉꠤ ꠅꠘ ꠕꠣꠇꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣ ꠟꠣꠉꠛ, ꠀꠞ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠔꠣꠝ, ꠁꠔꠣ ꠀꠝꠞꠣ ꠢꠘꠅ ꠘꠣ ꠉꠦꠟꠦ ꠇꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX10_27","003_10_27","EXO","10","27","27","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟ꠆ꠟꠣ, ꠢꠦ ꠄꠞꠣꠞꠦ ꠍꠣꠠꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX10_28","003_10_28","EXO","10","28","28","ꠚꠦꠞꠣꠃꠘꠦ ꠇꠁꠟ, “ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠜꠣꠉꠅ। ꠈꠛꠞꠖꠣꠞ! ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠍꠣꠝꠘꠦ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠀꠁꠅ ꠘꠣ। ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠦꠖꠤꠘ ꠀꠁꠛꠣꠄ, ꠢꠤꠖꠤꠘ ꠎꠣꠘ ꠈꠥꠀꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX10_29","003_10_29","EXO","10","29","29","ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠜꠣꠟꠣꠞꠦ ꠜꠣꠟꠣ! ꠀꠝꠤ ꠡꠈ ꠇꠞꠤꠀ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠀꠙꠘꠣꠞ ꠝꠥꠈ ꠖꠦꠈꠣꠔ ꠀꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX11_1","003_11_1","EXO","11","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠀꠞ ꠝꠣꠔ꠆ꠞ ꠄꠇꠐꠣ ꠉꠎꠛ ꠍꠣꠠꠝꠥ, ꠄꠞꠛꠣꠖꠦ ꠢꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠘꠕꠘꠦ ꠍꠣꠠꠤꠖꠤꠛ, ꠍꠣꠠꠣꠞ ꠛꠣꠟꠣ ꠢꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX11_2","003_11_2","EXO","11","2","2","ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠢꠤꠇꠣꠁ ꠖꠦꠅ, ꠢꠇ꠆ꠇꠟ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠝꠤꠡꠞꠤ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠞ ꠉꠄꠘꠣ-ꠉꠣꠐꠤ ꠈꠥꠎꠤꠀ ꠘꠦꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("EX11_3","003_11_3","EXO","11","3","3","ꠅꠃ ꠢꠣꠟꠔꠅ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠘꠎꠞꠅ ꠝꠣꠄꠀ ꠙꠣꠁꠔꠦ ꠝꠣꠛꠥꠖꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠟꠣ। ꠄꠞꠝꠣꠎꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠚꠦꠞꠣꠃꠘꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠀꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠈꠥꠛ ꠁꠎ꠆ꠎꠔꠤ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX11_4","003_11_4","EXO","11","4","4","ꠝꠥꠍꠣꠄ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠦ ꠇꠁꠞꠣ, ꠀꠝꠤ ꠀꠗꠣ ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠖꠤ ꠎꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX11_5","003_11_5","EXO","11","5","5","ꠄꠔꠦ ꠉꠖꠤꠔ ꠛꠅꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠛꠠ ꠙꠥꠀ ꠕꠣꠇꠤ ꠛꠣꠞꠣ-ꠜꠣꠘꠞꠣ ꠛꠣꠘ꠆ꠖꠤꠞ ꠙꠥꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠞꠅꠞꠣ ꠢꠇ꠆ꠇꠟ ꠙꠞꠤꠛꠣꠞꠞ ꠛꠠ ꠙꠥꠀꠂꠘ ꠝꠞꠤꠎꠤꠛꠣ। ꠄꠞꠟꠉꠦ ꠢꠇꠟ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠅ ꠝꠞꠤꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX11_6","003_11_6","EXO","11","6","6","ꠁ ꠟꠣꠈꠣꠘ ꠖꠡꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠁꠍꠦꠅ ꠘꠣ ꠀꠞ ꠅꠁꠔ-ꠅ ꠘꠣꠄ, ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠘ꠆ꠖꠘ ꠇꠣꠘ꠆ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX11_7","003_11_7","EXO","11","7","7","ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠛꠣ ꠙꠡꠥꠞ ꠛꠣꠄ ꠄꠉꠥ ꠇꠥꠔ꠆ꠔꠣꠄꠅ ꠃꠢ ꠇꠞꠔ ꠘꠣꠄ, ꠎꠣꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠛꠥꠎꠔꠣ ꠙꠣꠞꠂꠘ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞꠤ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠔꠚꠣꠔ ꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX11_8","003_11_8","EXO","11","8","8","ꠢꠦꠡꠦ ꠝꠥꠍꠣꠄ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠡꠝꠄ ꠀꠙꠘꠣꠞ ꠢꠇ꠆ꠇꠟ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠦ ꠀꠁꠀ ꠀꠝꠣꠞ ꠙꠣꠅꠔ ꠙꠠꠤꠀ ꠇꠁꠛꠣ, ꠀꠙꠘꠦ ꠀꠙꠘꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠛꠤꠖꠣꠄ ꠘꠦꠁꠘꠉꠤ, ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠛꠣꠞ ꠅꠁꠝꠥ।” ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX11_9","003_11_9","EXO","11","9","9","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠍꠟꠣ, “ꠚꠦꠞꠣꠃꠘꠦ ꠔꠥꠝꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠔ ꠘꠣꠄ, ꠎꠣꠔꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠝꠣꠞ ꠇꠦꠞꠣꠝꠔꠤꠞ ꠙꠞꠤꠝꠣꠘ ꠀꠞꠅ ꠛꠣꠠꠦ।” ");
INSERT INTO syls_vpl VALUES ("EX11_10","003_11_10","EXO","11","10","10","ꠄꠞꠟꠣꠉꠤ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠇꠦꠞꠣꠝꠔꠤ ꠅꠇꠟ ꠖꠦꠈꠣꠁꠟꠣ। ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟ꠆ꠟꠣ, ꠢꠦ ꠘꠤꠎꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠍꠣꠠꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_1","003_12_1","EXO","12","1","1","ꠛꠣꠖꠦ ꠅꠃ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX12_2","003_12_2","EXO","12","2","2","“ꠁ ꠌꠣꠘ꠆ꠖꠈꠣꠘ ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖ ꠅꠁꠛ, ꠔꠥꠝꠞꠣ ꠁ ꠌꠣꠘ꠆ꠖꠞꠦ ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖ ꠉꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX12_3","003_12_3","EXO","12","3","3","ꠔꠥꠝꠤꠔꠣꠁꠘ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠟꠣ ꠇꠞꠤ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠅꠃ ꠌꠣꠘ꠆ꠖꠞ ꠖꠡ ꠔꠣꠞꠤꠈꠅ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠥꠞꠛ꠆ꠛꠤꠄ, ꠎꠣꠞꠎꠤꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠇꠞꠤ ꠝꠦꠠꠣ ꠛꠣ ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠘꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX12_4","003_12_4","EXO","12","4","4","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠙꠞꠤꠛꠣꠞꠅ ꠄꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠅꠀꠞ ꠝꠣꠘꠥꠡ ꠇꠝ ꠅꠁꠟꠦ, ꠟꠣꠉꠣ ꠊꠞꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ, ꠖꠥꠁꠅ ꠙꠞꠤꠛꠣꠞꠦ ꠎꠔꠈꠣꠘ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠢꠃ ꠅꠘꠥꠝꠣꠘꠦ ꠝꠦꠠꠣ ꠛꠣ ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠘꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX12_5","003_12_5","EXO","12","5","5","ꠁ ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠁꠛ ꠘꠤꠈꠥꠔ, ꠄꠇ ꠛꠞꠍ ꠛꠄꠅꠡꠞ ꠙꠣꠑꠣ ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠁꠔꠦ ꠅꠁꠛ; ꠔꠥꠝꠞꠣ ꠝꠦꠠꠣ ꠛꠣ ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠘꠤꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX12_6","003_12_6","EXO","12","6","6","ꠀꠞ ꠅꠃ ꠌꠣꠘ꠆ꠖꠞ ꠌꠃꠖ꠆ꠖ ꠔꠣꠞꠤꠈ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠐꠣꠞ ꠎꠔꠘ ꠇꠞꠛꠣꠄ, ꠛꠣꠖꠦ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠄꠇꠟꠉꠦ ꠝꠤꠟꠤꠀ, ꠔꠣꠞꠣ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠎꠣꠞꠎꠤꠞ ꠙꠞꠤꠛꠣꠞꠦ ꠅꠃ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠎꠛ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_7","003_12_7","EXO","12","7","7","ꠎꠛ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠄꠞ ꠇꠤꠍꠥ ꠟꠃ ꠘꠤꠀ ꠎꠔ ꠊꠞꠅ ꠄꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛꠣ, ꠅꠔ ꠊꠞꠞ ꠖꠥꠀꠞꠞ ꠌꠃꠇꠣꠑꠞ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠔ ꠀꠞ ꠃꠙꠞꠞ ꠌꠃꠇꠣꠑꠅ ꠅꠃ ꠟꠃ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_8","003_12_8","EXO","12","8","8","ꠢꠃ ꠞꠣꠁꠔꠃ ꠔꠣꠞꠣ ꠁ ꠉꠥꠡ꠆ꠔ ꠀꠉꠥꠁꠘꠖꠤ ꠍꠦꠇꠤꠀ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠀꠞ ꠔꠤꠔ꠆ꠔꠣ ꠢꠣꠉꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠁꠀ ꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_9","003_12_9","EXO","12","9","9","ꠁ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠇꠣꠌꠣ, ꠛꠣ ꠙꠣꠘꠤꠖꠤ ꠞꠣꠘ꠆ꠖꠤꠀ ꠈꠣꠁꠅ ꠘꠣ। ꠈꠣꠟꠤ ꠀꠉꠥꠁꠘꠖꠤ ꠍꠦꠇꠤꠀ ꠈꠣꠁꠅ, ꠄꠞ ꠑꠦꠋ, ꠇꠟ꠆ꠟꠣ ꠡꠥꠖ꠆ꠖꠣ ꠜꠤꠔꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠄꠇꠈꠣꠘꠅ ꠍꠦꠇꠤꠅ, ꠛꠣꠖꠦ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX12_10","003_12_10","EXO","12","10","10","ꠞꠣꠁꠔ ꠙꠥꠀꠘꠤꠞ ꠀꠉꠦ ꠈꠣꠘꠤ ꠡꠦꠡ ꠇꠞꠤꠅ, ꠛꠤꠀꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠘ꠆ꠔꠣꠃ ꠛꠣꠇꠤ ꠕꠁꠅ ꠘꠣ। ꠎꠥꠖꠤ ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠇꠤ ꠞꠁꠎꠣꠄ, ꠔꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX12_11","003_12_11","EXO","12","11","11","ꠁ ꠈꠣꠘꠤ ꠈꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠝꠞꠞ ꠇꠣꠙꠠ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠚꠤꠘ꠆ꠖꠤꠅ, ꠙꠣꠅꠔ ꠎꠥꠔꠣ ꠟꠣꠉꠣꠁꠅ, ꠀꠔꠞ ꠟꠣꠑꠤ ꠟꠁꠅ। ꠎꠟꠖꠤ ꠇꠞꠤ ꠈꠣꠘꠤ ꠈꠣꠁꠅ। ꠁꠐꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠀꠎꠣꠖꠤ ꠁꠖ। ");
INSERT INTO syls_vpl VALUES ("EX12_12","003_12_12","EXO","12","12","12","ꠢꠃ ꠞꠣꠁꠔꠃ ꠀꠝꠤ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠖꠤ ꠎꠣꠁꠝꠥ, ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞ ꠛꠠ ꠙꠥꠀꠞꠦ ꠀꠞ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦꠅ ꠝꠣꠞꠤꠟꠤꠝꠥ। ꠝꠤꠡꠞꠞ ꠢꠇꠟ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠀ ꠡꠣꠎꠣ ꠖꠤꠝꠥ; ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("EX12_13","003_12_13","EXO","12","13","13","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠀꠞꠞ ꠌꠃꠇꠣꠑꠅ ꠟꠦꠙꠣ ꠟꠃ ꠖꠦꠈꠟꠦ ꠀꠝꠤ ꠛꠥꠎꠝꠥ ꠁ ꠊꠞꠅ ꠔꠥꠝꠞꠣ ꠞꠅ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠎꠛ ꠓꠣꠟꠤꠛꠣꠞ ꠡꠝꠄ, ꠟꠃ ꠟꠦꠙꠣ ꠅꠃ ꠊꠞ ꠛꠣꠖ ꠖꠤꠀ ꠍꠣꠝꠘꠦꠖꠤ ꠎꠣꠁꠝꠥ। ꠝꠃꠔꠞ ꠉꠎꠛ ꠕꠘꠦ ꠔꠥꠝꠞꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX12_14","003_12_14","EXO","12","14","14","ꠅꠃ ꠖꠤꠘꠞꠦ ꠔꠥꠝꠞꠣ ꠁꠀꠖ ꠞꠣꠈꠤꠅ ꠀꠞ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠁꠖꠞ ꠖꠤꠘ ꠝꠣꠘꠤꠅ। ꠁ ꠁꠖꠞꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠘꠅ ꠇꠞꠤꠀ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠝꠣꠘꠤꠀ ꠎꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX12_15","003_12_15","EXO","12","15","15","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠡꠣꠔ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠛꠣꠄ। ꠙꠄꠟꠣ ꠖꠤꠘꠃ ꠎꠣꠞꠎꠤꠞ ꠊꠞ ꠕꠣꠇꠤ ꠢꠇꠟ ꠈꠣꠝꠤꠞ ꠚꠣꠟꠣꠁ ꠖꠤꠛꠣꠄ। ꠁ ꠡꠣꠔꠅ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠉꠥꠄ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠘꠣꠘ ꠞꠥꠐꠤ ꠈꠣꠁꠛ, ꠔꠣꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠘꠦ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX12_16","003_12_16","EXO","12","16","16","ꠙꠄꠟꠣ ꠖꠤꠘ ꠀꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ, ꠁ ꠖꠥꠁ ꠖꠤꠘ ꠈꠣꠟꠤ ꠎꠞꠥꠞꠤ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠛꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_17","003_12_17","EXO","12","17","17","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ, ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠘꠅ ꠇꠞꠤꠀ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠁ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠅꠃ ꠖꠤꠘꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX12_18","003_12_18","EXO","12","18","18","ꠔꠥꠝꠞꠣ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠞ ꠌꠃꠖ꠆ꠖ ꠔꠣꠞꠤꠈꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠇꠞꠤꠀ, ꠄꠇꠥꠁꠡ ꠔꠣꠞꠤꠈꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX12_19","003_12_19","EXO","12","19","19","ꠅꠃ ꠡꠣꠔ ꠖꠤꠘ ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠊꠞꠅ ꠈꠣꠝꠤꠞꠞ ꠇꠥꠘꠥ ꠘꠣꠝ-ꠘꠤꠡꠣꠘꠣ ꠘꠣ ꠕꠣꠇꠦ, ꠅꠃ ꠡꠝꠄ ꠇꠦꠃ ꠎꠥꠖꠤ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠈꠣꠘꠤ ꠈꠣꠄ, ꠔꠦ ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠅꠃꠇ ꠛꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠅꠃꠇ, ꠔꠣꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX12_20","003_12_20","EXO","12","20","20","ꠁ ꠡꠣꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠎꠦꠘꠅꠃ ꠞꠅ ꠘꠣ ꠇꠦꠘꠦ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠈꠣꠁꠅ ꠘꠣ; ꠈꠣꠟꠤ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX12_21","003_12_21","EXO","12","21","21","ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠖꠟꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠎꠣꠃꠇ꠆ꠇꠣ, ꠉꠤꠀ ꠎꠣꠞꠎꠤꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠟꠣꠉꠤ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠤꠀ ꠎꠛ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_22","003_12_22","EXO","12","22","22","ꠀꠞ ‘ꠄꠍꠥꠛ’ ꠉꠣꠍꠞ ꠄꠇ ꠀꠐꠤ ꠒꠦꠐꠣ ꠟꠁꠀ, ꠙꠣꠔꠤꠟꠅ ꠕꠅꠀ ꠟꠃꠔ ꠛꠥꠠꠣꠁꠀ ꠖꠥꠀꠞꠞ ꠌꠃꠇꠣꠑꠞ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠔ ꠀꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠅ। ꠡꠣꠛꠗꠣꠘ! ꠡꠥꠞꠥꠎ ꠃꠑꠣꠞ ꠀꠉꠦ ꠇꠦꠃ ꠊꠞꠞ ꠛꠣꠞꠦ ꠛꠣꠞ ꠅꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_23","003_12_23","EXO","12","23","23","ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠖꠤ ꠔꠡꠞꠤꠚ ꠘꠤꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠌꠃꠇꠣꠑꠞ ꠃꠙꠞꠦ ꠀꠞ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠔ ꠟꠃ ꠖꠦꠈꠟꠦ, ꠔꠣꠁꠘ ꠁ ꠊꠞ ꠛꠣꠖ ꠖꠤꠀ ꠍꠣꠝꠘꠦꠖꠤ ꠀꠉꠥꠀꠁꠛꠣ। ꠀꠎꠞꠣꠁꠟ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠝꠣꠞꠔꠦ ꠖꠤꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX12_24","003_12_24","EXO","12","24","24","“ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠥꠇꠥꠝ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠁ ꠁꠖꠞꠦ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX12_25","003_12_25","EXO","12","25","25","ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠝꠥ, ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦꠅ ꠔꠥꠝꠞꠣ ꠁ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX12_26","003_12_26","EXO","12","26","26","ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠛꠣ, ꠁ ꠁꠖꠞ ꠇꠣꠞꠘ ꠇꠤꠔꠣ? ꠁꠐꠣ ꠇꠤꠟꠣ ꠀꠁꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("EX12_27","003_12_27","EXO","12","27","27","ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠅ, ꠁꠐꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤ। ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞꠦ ꠝꠣꠞꠛꠣꠞ ꠛꠣꠟꠣ ꠔꠣꠁꠘ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠊꠞ ꠛꠣꠖ ꠖꠤꠀ ꠍꠣꠝꠘꠦꠖꠤ ꠀꠉꠥꠀꠁ ꠉꠤꠀ, ꠀꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠍꠟꠣ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_28","003_12_28","EXO","12","28","28","ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠟꠣ ꠛꠣꠔꠣꠁ ꠖꠤꠍꠟꠣ, ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠔꠣꠞꠣꠞ ꠊꠞꠅ ꠉꠤꠀ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_29","003_12_29","EXO","12","29","29","ꠢꠦꠡꠦ ꠝꠣꠎ ꠞꠣꠁꠔꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠊꠐꠟ, ꠝꠣꠛꠥꠖꠦ ꠉꠖꠤꠔ ꠛꠅꠀ ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠀ ꠕꠘꠦ ꠎꠦꠟ ꠈꠣꠘꠣꠞ ꠛꠘ꠆ꠖꠤꠞ ꠙꠥꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇ꠆ꠇꠟꠞꠦ ꠝꠣꠞꠤꠟꠤꠟꠣ। ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟ ꠙꠞꠤꠛꠣꠞꠞ ꠛꠠ ꠙꠥꠀꠂꠘ ꠀꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦꠅ ꠔꠣꠁꠘ ꠝꠣꠞꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_30","003_12_30","EXO","12","30","30","ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠅꠇꠟ, ꠝꠤꠡꠞꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠢꠎꠣꠉ ꠅꠁꠀ ꠃꠑꠟꠣ, ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠛꠦꠕꠣꠄꠀ ꠇꠣꠘ꠆ꠖꠘꠞ ꠞꠥꠁꠟ ꠙꠠꠟ; ꠇꠣꠞꠘ ꠅꠟꠣ ꠇꠥꠘꠥ ꠊꠞ ꠞꠁꠍꠤꠟ ꠘꠣ, ꠎꠦ ꠊꠞꠅ ꠇꠦꠃ ꠘꠣ ꠇꠦꠃ ꠝꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_31","003_12_31","EXO","12","31","31","ꠢꠃ ꠞꠣꠁꠔꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟ, “ꠔꠥꠝꠞꠣ ꠎꠟꠖꠤ ꠎꠣꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠟꠁꠀ ꠀꠝꠣꠞ ꠙ꠆ꠞꠎꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠢꠞꠅ। ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠇꠁꠍ, ꠅꠃꠟꠣ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EX12_32","003_12_32","EXO","12","32","32","ꠔꠥꠝꠞꠣꠞ ꠎꠛꠣꠘ ꠝꠔꠃ ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠅꠇꠟꠞꠦꠅ ꠘꠦꠅꠉꠤ। ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦꠅ ꠘꠦꠇ ꠖꠥꠀ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX12_33","003_12_33","EXO","12","33","33","ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠈꠥꠛ ꠒꠞꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠟꠣ ꠔꠣꠞꠣꠅ ꠝꠞꠤꠎꠤꠛꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠔꠣꠉꠖꠣ ꠖꠤꠔꠣ ꠟꠣꠉꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠟꠖꠤ ꠇꠞꠤ ꠛꠤꠖꠣꠄ ꠅꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_34","003_12_34","EXO","12","34","34","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠝꠄꠖꠣꠞ ꠈꠣꠁꠞ ꠝꠣꠎꠦ ꠈꠣꠝꠤꠞ ꠙꠥꠞꠣꠁꠛꠣꠞ ꠀꠉꠦꠃ, ꠈꠣꠁ ꠡꠢ ꠉꠣꠝꠟꠣꠁꠘ ꠇꠣꠙꠠꠖꠤ ꠉꠣꠁꠐ ꠛꠣꠘ꠆ꠖꠤꠀ ꠇꠣꠘ꠆ꠖꠅ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_35","003_12_35","EXO","12","35","35","ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠥꠍꠣꠞ ꠙꠞꠣꠝꠤꠡ ꠝꠔ, ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠞ ꠉꠄꠘꠣ-ꠉꠣꠐꠤ ꠀꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠈꠥꠎꠤꠀ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_36","003_12_36","EXO","12","36","36","ꠝꠣꠛꠥꠖꠦ ꠀꠉ ꠕꠘꠦꠃ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠄꠇ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠙꠄꠖꠣ ꠇꠞꠍꠟꠣ, ꠎꠣꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠦꠔꠣ ꠈꠥꠎꠤꠛꠣ, ꠅꠔꠣꠃ ꠎꠣꠘꠥ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠁꠘ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠔꠣꠞꠣ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠛꠃꠔ ꠗꠘ-ꠖꠃꠟꠔꠅ ꠇꠛꠎꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_37","003_12_37","EXO","12","37","37","ꠅꠔꠣ ꠘꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠞꠣꠝꠣꠡꠦꠡ ꠄꠟꠣꠇꠣ ꠕꠣꠇꠤ ꠡꠥꠇ꠆ꠇꠔꠞ ꠝꠥꠈꠣ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠘꠥꠝꠣꠘ ꠍꠄ ꠟꠣꠈ ꠡꠛꠟ ꠛꠦꠐꠣꠁꠘ ꠀꠐꠤꠀ ꠉꠦꠟꠣ। ꠄꠞꠣꠞ ꠟꠉꠦ ꠛꠦꠐꠤꠘ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠅ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_38","003_12_38","EXO","12","38","38","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠛꠣꠖꠦꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠅꠞꠣ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ, ꠉꠞꠥ-ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠢꠇꠟꠔꠣ ꠝꠤꠟꠤꠀ ꠛꠃꠔ ꠛꠠ ꠖꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_39","003_12_39","EXO","12","39","39","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠀꠘꠣ ꠢꠃ ꠝꠄꠖꠣꠞ ꠈꠣꠁ ꠖꠤꠀ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠁꠟꠣ। ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠟꠖꠤ ꠇꠞꠤ ꠛꠤꠖꠣꠄ ꠖꠦꠅꠀꠄ ꠁ ꠈꠣꠁꠔ ꠈꠣꠝꠤꠞ ꠝꠣꠈꠣꠁꠛꠣꠞ ꠡꠝꠄꠃ ꠙꠣꠁꠍꠟꠣ ꠘꠣ, ꠀꠞ ꠙꠕꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠝꠍꠣꠅ ꠘꠤꠔꠣ ꠙꠣꠞꠍꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_40","003_12_40","EXO","12","40","40","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠝꠤꠡꠞꠅ ꠢꠇ꠆ꠇꠟꠔꠣꠄ ꠌꠣꠁꠞ-ꠡ ꠔꠤꠡ ꠛꠞꠍ ꠛꠡꠔ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_41","003_12_41","EXO","12","41","41","ꠑꠤꠇ ꠅꠃ ꠌꠣꠁꠞ-ꠡ ꠔꠤꠡ ꠛꠞꠍ ꠙꠥꠞꠣ ꠅꠁꠛꠣꠞ ꠖꠤꠘꠅ ꠝꠣꠛꠥꠖꠞ ꠢꠇ꠆ꠇꠟ ꠛꠘ꠆ꠖꠣ, ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠟꠣꠈꠣꠘ ꠢꠣꠎꠤꠀ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_42","003_12_42","EXO","12","42","42","ꠅꠃ ꠞꠣꠁꠔ ꠝꠣꠛꠥꠖꠦ ꠀꠙꠘ ꠇꠥꠖꠞꠔꠤ ꠍꠣꠄꠀꠄ ꠙꠣꠢꠣꠞꠣ ꠖꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠣꠄ, ꠁ ꠞꠣꠁꠔꠈꠣꠘ ꠄꠛꠣꠖꠔꠤꠞ ꠞꠣꠁꠔ। ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠃꠎꠣꠉꠞꠤ ꠇꠞꠣꠞ ꠄꠇ ꠈꠣꠍ ꠞꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("EX12_43","003_12_43","EXO","12","43","43","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠤꠇꠣꠁ ꠖꠤꠀꠞ। ꠢꠥꠘꠅ, ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠄꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠦ ꠖꠤꠛꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_44","003_12_44","EXO","12","44","44","ꠅꠁꠟꠦ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠁꠔꠣ ꠈꠣꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("EX12_45","003_12_45","EXO","12","45","45","ꠅꠁꠘ꠆ꠘ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠔꠤꠞ ꠝꠥꠍꠣꠚꠤꠞ ꠛꠣ ꠛꠦꠔꠘꠖꠣꠞꠤ ꠇꠣꠝꠟꠣꠞꠦꠅ ꠁꠔꠣ ꠈꠣꠅꠀꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_46","003_12_46","EXO","12","46","46","ꠔꠥꠝꠞꠣ ꠎꠣꠞ ꠛꠣꠠꠤꠔ ꠙꠡꠥ ꠎꠛ ꠇꠞꠛꠣꠄ ꠢꠃ ꠛꠣꠠꠤꠔꠃ ꠄꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠦ ꠅꠁꠛ; ꠛꠣꠠꠤꠞ ꠛꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠤꠛꠣꠄ ꠘꠣ, ꠙꠡꠥꠞ ꠇꠥꠘꠥ ꠀꠒ꠆ꠒꠤ ꠜꠣꠋꠉꠤꠛꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_47","003_12_47","EXO","12","47","47","ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠃ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX12_48","003_12_48","EXO","12","48","48","ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠅꠞꠣ ꠇꠥꠘꠥ ꠀꠛꠣꠖꠤꠄ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠁ ꠁꠖ ꠝꠣꠘꠔ ꠌꠣꠄ, ꠔꠦ ꠙꠄꠟꠣ ꠔꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤ ꠟꠣꠉꠛ। ꠛꠣꠖꠦ ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠈꠣꠘ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠔ ꠙꠣꠞꠛ। ꠅꠁꠟꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤ ꠍꠣꠠꠣ ꠇꠦꠃ ꠁ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX12_49","003_12_49","EXO","12","49","49","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠀꠞ ꠀꠛꠣꠖꠤꠞ ꠟꠣꠉꠤꠅ ꠄꠇ ꠢꠝꠣꠘ ꠀꠁꠘ ꠎꠣꠞꠤ ꠅꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("EX12_50","003_12_50","EXO","12","50","50","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠢꠣꠍꠣꠞꠞ ꠅꠃꠟꠣꠃ ꠀꠝꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX12_51","003_12_51","EXO","12","51","51","ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠖꠤꠘꠃ ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠟꠣꠈꠣꠘ ꠇꠞꠤ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX13_1","003_13_1","EXO","13","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX13_2","003_13_2","EXO","13","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇ꠆ꠇꠟ ꠙꠞꠤꠛꠣꠞꠞ ꠛꠠ ꠙꠥꠀꠂꠘꠞꠦ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠀꠟꠉ ꠇꠞꠤꠀ ꠡꠙꠤꠀ ꠖꠦꠅ। ꠁꠔꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠙꠥꠀ ꠅꠃꠇ ꠛꠣ ꠙꠡꠥꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠃꠇ। ꠢꠇꠟꠔꠣꠞ ꠛꠠ ꠙꠥꠀꠂꠘ ꠈꠣꠟꠤ ꠀꠝꠣꠞꠃ।” ");
INSERT INTO syls_vpl VALUES ("EX13_3","003_13_3","EXO","13","3","3","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠁ ꠖꠤꠘ ꠈꠣꠘꠞꠦ ꠔꠥꠝꠞꠣ ꠁꠀꠖ ꠞꠣꠈꠤꠅ, ꠅꠃ ꠖꠤꠘꠃ ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠅꠁꠍ। ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠍꠂꠘ। ꠁ ꠖꠤꠘ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠈꠣꠘꠣ ꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX13_4","003_13_4","EXO","13","4","4","ꠀꠛꠤꠛ ꠌꠣꠘ꠆ꠖꠞ ꠅꠃ ꠔꠣꠞꠤꠈꠅ ꠔꠥꠝꠞꠣ ꠛꠣꠞ ꠅꠁꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX13_5","003_13_5","EXO","13","5","5","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠇꠦꠘꠣꠘꠤ, ꠢꠤꠐ꠆ꠐꠤ, ꠀꠝꠥꠞꠤ, ꠢꠤꠛ꠆ꠛꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠛꠣꠉꠤ। ꠁ ꠖꠦꠡ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠖꠦꠡ। ꠔꠦ ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦꠅ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠛꠍꠞ ꠀꠛꠤꠛ ꠌꠣꠘ꠆ꠖꠞ ꠅꠃ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX13_6","003_13_6","EXO","13","6","6","“ꠔꠥꠝꠞꠣ ꠡꠣꠔ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠅ, ꠛꠣꠖꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX13_7","003_13_7","EXO","13","7","7","ꠁ ꠡꠣꠔꠅ ꠖꠤꠘ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠅꠀ ꠟꠣꠉꠛ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠈꠣꠘꠣ ꠎꠣꠔꠦ ꠘꠣ ꠖꠦꠈꠤ, ꠔꠥꠝꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠅ ꠎꠣꠘꠥ ꠇꠥꠘꠥ ꠈꠣꠝꠤꠞ ꠘꠣ ꠝꠤꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("EX13_8","003_13_8","EXO","13","8","8","ꠁ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠇꠁꠅ, ‘ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠞꠢꠝ ꠇꠞꠍꠟꠣ, ꠅꠔꠣꠞꠦ ꠝꠘꠅ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤꠅ ꠅꠈꠘ ꠅꠟꠣ ꠇꠞꠞꠣꠝ।’ ");
INSERT INTO syls_vpl VALUES ("EX13_9","003_13_9","EXO","13","9","9","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠔꠣꠟꠤꠝ ꠖꠤꠅ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠞꠄ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। ꠔꠥꠝꠞꠣꠞ ꠀꠔꠞ ꠛꠣ ꠇꠙꠣꠟꠞ ꠔꠣꠛꠤꠎ-ꠇꠛꠎꠞ ꠟꠣꠈꠣꠘ, ꠅꠃ ꠔꠣꠟꠤꠝꠞꠦꠅ ꠢꠣꠝꠦꠡꠣ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX13_10","003_13_10","EXO","13","10","10","ꠄꠞꠟꠣꠉꠤ ꠙꠞꠔꠦꠇ ꠛꠞꠍ ꠅꠃ ꠅꠇ꠆ꠔ ꠀꠁꠟꠦꠃ ꠔꠥꠝꠞꠣ ꠁ ꠘꠤꠅꠝ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX13_11","003_13_11","EXO","13","11","11","“ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠎꠦꠟꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ꠔꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠘꠅ ꠘꠤꠀ ꠢꠣꠞꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("EX13_12","003_13_12","EXO","13","12","12","ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠠ ꠙꠥꠀꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠡꠙꠤꠀ ꠖꠤꠟꠣꠁꠅ; ꠄꠞꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦꠅ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠤꠟꠣꠁꠅ, ꠁꠔꠣ ꠔ ꠝꠣꠛꠥꠖꠞꠃ। ");
INSERT INTO syls_vpl VALUES ("EX13_13","003_13_13","EXO","13","13","13","ꠅꠁꠟꠦ ꠢꠇꠟ ꠉꠣꠗꠤꠘ꠆ꠔꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠛꠖꠟꠣ, ꠔꠥꠝꠞꠣ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠖꠤꠀ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠁꠅ। ꠈꠣꠟꠣꠍ ꠘꠣ ꠇꠞꠣꠁꠟꠦ ꠉꠣꠗꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠉꠞ꠆ꠖꠘꠣ ꠜꠣꠋꠉꠤ ꠖꠤꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠙꠞꠤꠛꠣꠞꠞ ꠛꠠ ꠙꠥꠀꠂꠘꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX13_14","003_13_14","EXO","13","14","14","“ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠎꠦꠛꠟꠣ ꠎꠤꠇꠣꠁꠛꠣ, ꠁꠔꠣ ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ ꠇꠞꠣ ꠟꠣꠉꠦ? ꠔꠥꠝꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠅ, ‘ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠖꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠝꠤꠡꠞꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX13_15","003_13_15","EXO","13","15","15","ꠚꠦꠞꠣꠃꠘꠦ ꠘꠣ-ꠢꠥꠝꠣꠞꠤ ꠇꠞꠤꠀ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣꠞꠦ ꠀꠁꠔꠦ ꠖꠤꠟ ꠘꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇꠟ ꠙꠞꠤꠛꠣꠞꠞ ꠛꠠ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ, ꠝꠣꠘꠡꠞ ꠙꠥꠀꠂꠘ ꠀꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘꠞꠦ ꠝꠣꠞꠤꠟ꠆ꠟꠣ। ꠅꠃ ꠇꠣꠞꠘꠦ ꠀꠝꠞꠣꠞ ꠛꠠ ꠙꠥꠀꠂꠘꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠁ, ꠀꠞ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("EX13_16","003_13_16","EXO","13","16","16","ꠁꠐꠣ ꠅꠝꠘ ꠄꠇ ꠁꠀꠖꠉꠣꠞꠤꠞ ꠁꠖ, ꠀꠔ ꠛꠣ ꠇꠙꠣꠟꠅ ꠛꠣꠘ꠆ꠖꠣ ꠔꠣꠛꠤꠎ-ꠇꠛꠎꠞ ꠟꠣꠈꠣꠘ ꠎꠣꠘꠥ ꠢꠣꠝꠦꠡꠣ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠞꠄ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠖꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠅꠈꠣꠘ ꠝꠘꠅ ꠞꠄ।’ ” ");
INSERT INTO syls_vpl VALUES ("EX13_17","003_13_17","EXO","13","17","17","ꠚꠦꠞꠣꠃꠘꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠍꠣꠠꠣꠞ ꠛꠣꠖꠦ, ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠖꠤ ꠡꠤꠗꠣ ꠙꠕ ꠕꠣꠇꠟꠦꠅ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠢꠤ ꠙꠕꠦꠖꠤ ꠘꠤꠟꠣ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠟꠣ, ꠢꠦꠡꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠎꠥꠖ꠆ꠖꠞ ꠝꠥꠇꠣꠛꠤꠟꠣ ꠇꠞꠣ ꠟꠣꠉꠦ, ꠔꠦ ꠝꠣꠘꠡꠦ ꠎꠥꠖ꠆ꠖꠞ ꠒꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠝꠤꠡꠞꠅ ꠚꠤꠞꠤꠎꠤꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("EX13_18","003_13_18","EXO","13","18","18","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠘꠤꠟ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠦꠖꠤ ꠝꠞꠥꠜꠥꠝꠤ ꠛꠣꠄ ꠘꠦꠅꠀꠁꠟꠣ; ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠟꠣꠈꠣꠘ ꠢꠣꠎꠤ-ꠙꠣꠠꠤ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX13_19","003_13_19","EXO","13","19","19","ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠢꠎꠞꠔ ꠁꠃꠍꠥꠚꠞ ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠔꠣꠘ ꠀꠒ꠆ꠒꠤ-ꠉꠥꠒ꠆ꠒꠤ ꠟꠉꠦ ꠇꠞꠤ ꠘꠤꠟꠣ। ꠁꠃꠍꠥꠚꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠇꠍꠝ ꠇꠞꠣꠁ ꠇꠁꠍꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠌꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠛꠣ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠀꠝꠣꠞ ꠀꠒ꠆ꠒꠤꠉꠥꠁꠘ ꠔꠥꠟꠤꠀ ꠟꠉꠦ ꠇꠞꠤ ꠘꠤꠅꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX13_20","003_13_20","EXO","13","20","20","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠡꠥꠇ꠆ꠇꠔ ꠉꠣꠅ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠤꠘꠣꠞꠅ ꠄꠕꠝ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠀꠁꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX13_21","003_13_21","EXO","13","21","21","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞꠦ ꠙꠕ ꠌꠤꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠞ ꠍꠥꠞꠔꠦ ꠞꠁꠔꠣ, ꠀꠞ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣꠄ ꠚꠞ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠉꠥꠘꠤꠞ ꠈꠥꠐꠤꠞ ꠍꠥꠞꠔꠦ ꠔꠣꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠎꠣꠁꠔꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠞꠣꠁꠔ-ꠖꠤꠘ ꠢꠝꠣꠘꠦ ꠌꠟꠔꠣ ꠙꠣꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX13_22","003_13_22","EXO","13","22","22","ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠢꠣꠝꠦꠡꠣ ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠀꠞ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠀꠉꠥꠘꠤꠞ ꠈꠥꠐꠤ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("EX14_1","003_14_1","EXO","14","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX14_2","003_14_2","EXO","14","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠊꠥꠞꠤꠀ ꠀꠁꠀ ꠚꠣꠝꠣ-ꠢꠤꠞꠥꠔ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠝꠤꠉꠖꠥꠟ ꠀꠞ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠣꠝꠣꠎꠤ, ꠛꠣꠀꠟ-ꠎꠣꠚꠘ ꠄꠟꠣꠇꠣꠞ ꠍꠣꠝꠘꠦ ꠖꠞꠤꠀꠞ ꠌꠞꠞ ꠝꠣꠎꠦ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_3","003_14_3","EXO","14","3","3","ꠁꠔꠣ ꠖꠦꠈꠟꠦ ꠚꠦꠞꠣꠃꠘꠦ ꠝꠘꠅ ꠇꠞꠛ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠇꠥꠘꠥꠛꠣꠄ ꠙꠕ ꠘꠣ ꠙꠣꠁꠀ ꠊꠥꠞꠣꠊꠥꠞꠤ ꠇꠞꠔꠦ ꠇꠞꠔꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠐꠇꠤ ꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX14_4","003_14_4","EXO","14","4","4","ꠀꠝꠤ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠝꠥ, ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠈꠦꠖꠣꠘꠤꠔ ꠀꠁꠛ। ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦꠖꠤ ꠀꠝꠣꠞ ꠘꠣꠝ ꠃꠎꠤꠟꠣ ꠅꠁꠛ; ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦꠅ ꠛꠥꠎꠤꠟꠤꠛꠣ, ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ।” ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠃꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_5","003_14_5","EXO","14","5","5","ꠢꠣꠍꠣꠃ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠦ ꠎꠦꠛꠟꠣ ꠈꠛꠞ ꠙꠣꠁꠟ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ ꠜꠣꠉꠤ ꠉꠦꠍꠂꠘ, ꠢꠥꠘꠤꠀꠃ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠖꠤꠟ ꠚꠤꠞꠤꠉꠦꠟ। ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠢꠣꠄ, ꠢꠣꠄ! ꠀꠝꠞꠣ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠍꠤ? ꠁꠔꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠇꠦꠘꠦ ꠍꠣꠠꠟꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("EX14_6","003_14_6","EXO","14","6","6","ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠞ ꠎꠥꠖ꠆ꠖꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ ꠢꠣꠎꠣꠘꠤꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠀ, ꠔꠣꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠎꠥꠁꠔ ꠇꠞꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX14_7","003_14_7","EXO","14","7","7","ꠢꠦ ꠔꠣꠞ ꠈꠣꠍ ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠍꠄꠡ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ, ꠝꠤꠡꠞꠞ ꠡꠛ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠘ ꠀꠞ ꠄꠞꠣꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠍꠤꠙꠣꠁꠞꠦꠅ ꠟꠉꠦ ꠟꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX14_8","003_14_8","EXO","14","8","8","ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠟ꠆ꠟꠣ, ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠈꠞꠦ ꠈꠞꠦ ꠈꠦꠖꠣꠘꠤꠔ ꠀꠁꠟ। ꠄꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠢꠦ ꠄꠞꠣꠞꠦ ꠗꠞꠣꠔ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX14_9","003_14_9","EXO","14","9","9","ꠢꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠢꠇꠟ ꠊꠥꠠ-ꠍꠅꠀꠞ ꠍꠤꠙꠣꠁ, ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠀꠟꠣ ꠍꠤꠙꠣꠁ ꠡꠢ ꠀꠡ꠆ꠔꠣ ꠀꠞ꠆ꠝꠤ ꠖꠟ ꠟꠁꠀ ꠄꠞꠣꠞꠦ ꠗꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟ꠆ꠟ। ꠅꠃ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠅ ꠛꠣꠀꠟ-ꠎꠣꠚꠘꠞ ꠍꠣꠝꠘꠦ ꠚꠣꠝꠣ-ꠢꠤꠞꠥꠔꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_10","003_14_10","EXO","14","10","10","ꠔꠣꠞꠣ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠔꠣꠞꠣꠞ ꠈꠞꠦ ꠅꠁꠀ ꠝꠤꠡꠞꠤ ꠍꠤꠙꠣꠁ ꠀꠁꠞꠣ; ꠖꠦꠈꠤꠀꠃ ꠎꠣꠘꠞ ꠒꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠣꠘ꠆ꠖꠘ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_11","003_14_11","EXO","14","11","11","ꠔꠣꠞꠣ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠤꠡꠞꠅ ꠇꠄꠛꠞ ꠖꠤꠛꠣꠞ ꠎꠣꠉꠣ ꠘꠣꠁ ꠖꠦꠈꠤꠀ, ꠀꠝꠞꠣꠞꠦ ꠝꠣꠞꠔꠣꠄ ꠇꠞꠤ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠟꠁꠀ ꠀꠁꠍ ꠘꠤ? ꠔꠥꠝꠤ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠟꠣꠄ? ꠇꠦꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("EX14_12","003_14_12","EXO","14","12","12","ꠝꠤꠡꠞꠞ ꠜꠤꠔꠞꠦ ꠀꠝꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠍꠤ ꠘꠣ ꠘꠤ, ꠀꠝꠞꠣꠞꠦ ꠅꠘꠅ ꠞꠁꠔꠦ ꠖꠦꠅ, ꠀꠝꠞꠣ ꠝꠤꠡꠞꠤꠘ꠆ꠔꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠤ? ꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠞꠣꠞ ꠌꠣꠁꠔꠦ ꠝꠤꠡꠞꠤꠘ꠆ꠔꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠃ ꠔ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ ꠀꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("EX14_13","003_14_13","EXO","14","13","13","ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠢꠇꠟꠦ ꠘꠤꠞꠣꠁ ꠅꠁꠀ ꠖꠦꠈꠅ, ꠝꠣꠛꠥꠖꠦ ꠀꠁꠎ ꠇꠤꠟꠣ ꠛꠣꠌꠣꠁꠘ। ꠅꠃ ꠎꠦꠔꠣ ꠝꠤꠡꠞꠤꠘ꠆ꠔꠞꠦ ꠅꠈꠘ ꠖꠦꠈꠞꠣꠄ, ꠁꠔꠣꠞꠦ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠖꠦꠈꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX14_14","003_14_14","EXO","14","14","14","ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠡꠣꠘ꠆ꠔꠤ ꠅꠅ, ꠖꠦꠈꠅ, ꠝꠣꠛꠥꠖꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠙꠇ꠆ꠇ ꠅꠁꠀ ꠎꠥꠖ꠆ꠖ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX14_15","003_14_15","EXO","14","15","15","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠣꠘ꠆ꠖꠤꠞꠣꠄ? ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ ꠘꠣ, ꠍꠣꠝꠘꠦꠖꠤ ꠀꠉꠥꠀꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_16","003_14_16","EXO","14","16","16","ꠀꠞ ꠔꠥꠝꠣꠞ ꠀꠔꠞ ꠟꠣꠑꠤꠞꠦ ꠛꠣꠠꠣꠁꠀ ꠖꠞꠤꠀꠞ ꠃꠙꠞꠦ ꠃꠌꠣ ꠇꠞꠤ ꠗꠞꠅ, ꠖꠞꠤꠀꠞꠦ ꠖꠥꠁ ꠜꠣꠉ ꠇꠞꠤꠟꠣꠅ। ꠔꠦꠃ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠢꠥꠇꠘꠣ ꠛꠣꠄ ꠀꠐꠤꠀ ꠖꠞꠤꠀ ꠙꠣꠞ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_17","003_14_17","EXO","14","17","17","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠖꠤꠟ ꠅꠟꠣ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠝꠥ, ꠔꠣꠞꠣ ꠄꠞꠣꠞꠦ ꠗꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠖꠞꠤꠀꠔ ꠢꠣꠝꠣꠁꠛꠣ। ꠄꠞꠛꠣꠖꠦ ꠚꠦꠞꠣꠃꠘ, ꠔꠣꠞ ꠍꠤꠙꠣꠁ, ꠔꠣꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠘ, ꠔꠣꠞ ꠊꠥꠠ-ꠍꠅꠀꠞ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠣꠞ ꠎꠣꠟꠣꠟ-ꠡꠣꠘ ꠎꠣꠁꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX14_18","003_14_18","EXO","14","18","18","ꠚꠦꠞꠣꠃꠘꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠖꠦꠈꠤꠀ ꠛꠣꠇꠤ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦꠅ ꠛꠥꠎꠤꠟꠤꠛꠣ, ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("EX14_19","003_14_19","EXO","14","19","19","ꠄꠞꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠉꠦ ꠅꠁꠀ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ, ꠄꠁꠘ ꠎꠣꠉꠣ ꠛꠖꠟꠣꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠈꠞꠦ ꠉꠦꠟꠣꠉꠤ। ꠄꠘ ꠟꠉꠦ ꠅꠁꠀ ꠇꠥꠖꠞꠔꠤ ꠢꠃ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠅ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠈꠞꠦ ꠀꠁꠟ꠆ꠟ। ");
INSERT INTO syls_vpl VALUES ("EX14_20","003_14_20","EXO","14","20","20","ꠈꠞꠦ ꠀꠁꠀ ꠝꠤꠡꠞꠤ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠤ ꠖꠥꠁꠅ ꠖꠟꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣꠁꠟ। ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠞ ꠀꠘ꠆ꠖꠣꠁꠞꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟ ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠙꠠꠤꠉꠦꠟꠣ, ꠔꠣꠞꠣ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠣꠘ꠆ꠖꠣ ꠟꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣꠅ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠞ ꠚꠞꠡꠣ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX14_21","003_14_21","EXO","14","21","21","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠖꠞꠤꠀꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠀꠔ ꠛꠣꠠꠣꠁꠟꠣ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠢꠣꠞꠣ ꠞꠣꠁꠔ ꠈꠥꠛ ꠎꠥꠞꠦ ꠙꠥꠛꠣꠟꠤ ꠢꠣꠅꠀ ꠖꠤꠀ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤ ꠢꠞꠣꠁꠀ ꠖꠥꠁ ꠛꠣꠐ ꠇꠞꠤꠟ꠆ꠟꠣ, ꠖꠞꠤꠀ ꠢꠥꠇꠣꠁꠀ ꠝꠣꠎꠦꠖꠤ ꠢꠥꠇꠘꠣ ꠙꠕ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX14_22","003_14_22","EXO","14","22","22","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠦ ꠢꠥꠇꠘꠣ ꠙꠣꠅꠄ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠖꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤ ꠔꠣꠞꠣꠞ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠅꠀꠟꠞ ꠟꠣꠈꠣꠘ ꠃꠛꠣꠁ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX14_23","003_14_23","EXO","14","23","23","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠞꠤꠀꠞ ꠢꠃ ꠢꠥꠇꠘꠣ ꠙꠕꠦꠖꠤ ꠉꠦꠟꠣ। ꠚꠦꠞꠣꠃꠘꠞ ꠢꠇ꠆ꠇꠟ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ, ꠊꠥꠠꠣ, ꠀꠞ ꠊꠥꠠ-ꠍꠅꠀꠞ ꠅꠇꠟ ꠈꠦꠖꠣꠁ ꠈꠦꠖꠣꠁ ꠖꠞꠤꠀꠞ ꠢꠃ ꠙꠕꠅ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_24","003_14_24","EXO","14","24","24","ꠀꠞ ꠙꠔꠣꠛꠣꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠇꠥꠖꠞꠔꠤ ꠀꠉꠥꠁꠘ ꠀꠞ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠕꠣꠇꠤ ꠝꠤꠡꠞꠤ ꠍꠤꠙꠣꠁꠞ ꠛꠣꠄ ꠟꠣꠘ꠆ꠘꠔꠤ ꠘꠎꠞꠦ ꠌꠣꠁꠟꠣ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠛꠦꠖꠤꠡꠣ ꠟꠣꠉꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_25","003_14_25","EXO","14","25","25","ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠞ ꠌꠣꠇ꠆ꠇꠣ ꠘꠡ꠆ꠐ ꠇꠞꠤ ꠖꠤꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠇꠞꠤꠀꠅ ꠉꠣꠠꠤ ꠌꠣꠟꠣꠘꠤꠔ ꠞꠁꠟ; ꠄꠞꠝꠣꠎꠦ ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠇꠁꠟ, “ꠅꠁꠍꠦ, ꠀꠞ ꠛꠣꠖ ꠖꠦꠅ, ꠀꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠈꠞ ꠕꠘꠦ ꠢꠞꠤ ꠎꠣꠁ। ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠦ ꠔꠣꠞꠣꠞ ꠙꠇ꠆ꠇ ꠅꠁꠀ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX14_26","003_14_26","EXO","14","26","26","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠖꠞꠤꠀꠞ ꠃꠙꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠅ। ꠔꠥꠝꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠁꠟꠦ ꠙꠣꠘꠤ ꠢꠤꠞꠛꠣꠞ ꠝꠤꠡꠞꠤꠘ꠆ꠔꠞ ꠃꠙꠞꠦ, ꠔꠣꠞꠣꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ ꠀꠞ ꠊꠥꠠ-ꠍꠅꠀꠞꠞ ꠃꠙꠞꠦ ꠀꠁꠛ꠆ꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX14_27","003_14_27","EXO","14","27","27","ꠝꠥꠍꠣꠄ ꠖꠞꠤꠀꠞ ꠃꠙꠞꠦ ꠀꠔ ꠛꠣꠠꠣꠁꠟꠣ, ꠀꠞ ꠛꠤꠀꠘ ꠅꠀꠞ ꠀꠉꠦꠃ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤ ꠢꠤꠞꠛꠣꠞ ꠢꠝꠣꠘ ꠅꠁꠉꠦꠟ; ꠝꠤꠡꠞꠤꠘ꠆ꠔꠦ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠖꠃꠠꠣ-ꠖꠃꠠꠤ ꠟꠣꠉꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞꠦ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤꠖꠤ ꠜꠣꠅꠀꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_28","003_14_28","EXO","14","28","28","ꠙꠣꠘꠤ ꠢꠤꠞꠛꠣꠞ ꠎꠣꠉꠣꠔ ꠀꠁꠟ꠆ꠟ, ꠔꠣꠞꠣꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠘ, ꠍꠤꠙꠣꠁꠘ, ꠀꠞ ꠊꠥꠠ-ꠍꠅꠀꠞ ꠅꠇꠟ, ꠝꠣꠘꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠈꠞꠦ ꠅꠁꠀ ꠈꠦꠖꠣꠘꠤꠔ ꠀꠅꠞꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠣꠘꠤꠄ ꠛꠥꠠꠤꠉꠦꠟ, ꠄꠉꠥꠅ ꠎꠤꠔꠣ ꠞꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX14_29","003_14_29","EXO","14","29","29","ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠦ ꠢꠥꠇꠘꠣ ꠙꠕꠦ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠖꠤ ꠉꠦꠟꠣ, ꠔꠣꠞꠣꠞ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠙꠣꠘꠤ ꠅꠀꠟꠞ ꠟꠣꠈꠣꠘ ꠃꠛꠣꠁ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX14_30","003_14_30","EXO","14","30","30","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠝꠣꠛꠥꠖꠦ ꠢꠤ ꠖꠤꠘ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠛꠣꠌꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠟꠣ, ꠝꠤꠡꠞꠤꠘ꠆ꠔꠞ ꠝꠞꠣ ꠟꠣꠡ ꠖꠞꠤꠀꠞ ꠌꠞꠅ ꠙꠠꠤꠀ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX14_31","003_14_31","EXO","14","31","31","ꠝꠤꠡꠞꠤꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠤꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦꠅ ꠝꠣꠛꠥꠖꠞꠦ ꠒꠞꠣꠁꠉꠦꠟꠣ। ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦ ꠀꠞ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠃꠙꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX15_1","003_15_1","EXO","15","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠦ ꠘꠤꠟ ꠖꠞꠤꠀ ꠙꠣꠞ ꠅꠁꠀ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠅꠃ ꠡꠥꠇꠥꠞꠣꠘꠣ ꠉꠎꠟ ꠉꠣꠁꠟꠣ: “ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠉꠎꠟ ꠉꠣꠁ, ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣ ꠛꠣꠠꠤꠍꠦ, ꠊꠥꠠ-ꠍꠅꠀꠞ ꠡꠥꠖ꠆ꠖꠣ ꠊꠥꠠꠣꠁꠘꠞꠦ ꠔꠣꠁꠘꠃ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤꠔ ꠚꠣꠟꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX15_2","003_15_2","EXO","15","2","2","ꠀꠟ꠆ꠟꠣꠃ ꠔ ꠀꠝꠣꠞ ꠛꠟ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞ ꠉꠎꠟ, ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠇꠟ-ꠇꠛꠎꠣ ꠔꠣꠘ ꠀꠔꠅ ꠀꠍꠦ। ꠅꠃ ꠀꠟ꠆ꠟꠣꠃ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠣꠛꠥꠖ, ꠀꠝꠤ ꠔꠣꠘ ꠢꠣꠝꠖ ꠉꠣꠁꠝꠥ, ꠔꠣꠘ ꠟꠤꠟꠣ-ꠈꠦꠟꠣꠞ ꠛꠄꠀꠘ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX15_3","003_15_3","EXO","15","3","3","ꠝꠣꠛꠥꠖ ꠅꠁꠟꠣ ꠙꠄꠟꠥꠀꠘ ꠍꠤꠙꠣꠁ, ꠔꠣꠘ ꠘꠣꠝꠃ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("EX15_4","003_15_4","EXO","15","4","4","ꠚꠦꠞꠣꠃꠘꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠞꠦ ꠀꠞ ꠍꠤꠙꠣꠁꠞꠦ ꠔꠣꠁꠘ ꠙꠣꠘꠤꠔ ꠚꠣꠟꠣꠁꠟꠣ, ꠔꠣꠞ ꠘꠣꠝꠇꠞꠣ ꠍꠥꠛꠦꠖꠣꠞ ꠅꠇꠟ ꠘꠤꠟ ꠖꠞꠤꠀꠔ ꠛꠥꠠꠤꠀ ꠝꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX15_5","003_15_5","EXO","15","5","5","ꠉꠁꠘ ꠙꠣꠘꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠉꠤꠟꠤꠟ꠆ꠟ, ꠀꠞ ꠜꠣꠞꠤ ꠙꠣꠔ꠆ꠔꠞꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠖꠞꠤꠀꠞ ꠔꠟꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX15_6","003_15_6","EXO","15","6","6","ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠀꠔꠈꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣꠄ ꠜꠞꠣ, ꠔꠥꠝꠣꠞ ꠀꠔꠦ ꠘꠤꠌ꠆ꠌꠄ ꠖꠥꠡꠝꠘꠞꠦ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX15_7","003_15_7","EXO","15","7","7","ꠔꠥꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠦꠔꠣꠄ ꠟꠣꠉꠍꠤꠟꠣ, ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠉꠁꠘ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁꠟꠣꠄ। ꠔꠥꠝꠣꠞ ꠙꠣꠑꠣꠁꠟ ꠉꠎꠛꠤ ꠀꠉꠥꠁꠘꠦ, ꠢꠥꠇꠘꠣ ꠈꠦꠞ-ꠘꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX15_8","003_15_8","EXO","15","8","8","ꠔꠥꠝꠣꠞ ꠘꠣꠇꠞ ꠖꠝꠦ ꠢꠇꠟ ꠙꠣꠘꠤ ꠖꠟꠣ ꠅꠁꠉꠦꠟ, ꠙꠣꠘꠤꠞ ꠚꠥꠔ ꠅꠇꠟ ꠎꠣꠉꠣꠔ ꠃꠛꠣꠁ ꠞꠁꠟ, ꠖꠞꠤꠀꠞ ꠉꠁꠘ ꠙꠣꠘꠤ ꠌꠣꠇ꠆ꠇꠣ ꠛꠘꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX15_9","003_15_9","EXO","15","9","9","ꠖꠥꠡꠝꠘꠦ ꠇꠁꠍꠤꠟ, ‘ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠘꠤꠝꠥ, ꠖꠃꠠꠣꠁꠀ ꠘꠤꠀ ꠗꠞꠝꠥ, ꠔꠣꠞꠣꠞ ꠢꠇꠟꠔꠣ ꠇꠣꠠꠤꠀ ꠀꠘꠤꠀ ꠛꠣꠐꠤꠝꠥ। ꠔꠣꠞꠣꠞ ꠝꠣꠟꠖꠤ ꠀꠝꠤ ꠝꠣꠟꠖꠣꠞ ꠅꠁꠝꠥ, ꠁꠔꠣꠖꠤ ꠀꠝꠣꠞ ꠝꠘꠞ ꠈꠣꠁꠡ ꠙꠥꠞꠣꠁꠝꠥ। ꠀꠝꠣꠞ ꠔꠟꠥꠀꠞꠖꠤ ꠝꠣꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("EX15_10","003_15_10","EXO","15","10","10","ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠚꠥ ꠖꠤꠀ ꠛꠣꠔꠣꠡ ꠖꠤꠟꠣꠄ, ꠀꠞ ꠖꠞꠤꠀꠄ ꠔꠣꠞꠣꠞꠦ ꠉꠥꠞꠤꠟꠤꠟ, ꠔꠣꠞꠣ ꠡꠤꠡꠣꠞ ꠟꠣꠈꠣꠘ ꠉꠁꠘ ꠙꠣꠘꠤꠔ ꠔꠟꠣꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX15_11","003_15_11","EXO","15","11","11","ꠅ ꠝꠣꠛꠥꠖ, ꠇꠥꠘ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠔꠥꠝꠣꠞ ꠢꠝꠣꠘ? ꠇꠦ ꠔꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠔ ꠙꠛꠤꠔ꠆ꠞ ꠝꠢꠣꠘ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠝꠔ ꠜꠄꠅꠋꠇꠞ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣ ꠇꠣꠞ ꠀꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("EX15_12","003_15_12","EXO","15","12","12","ꠔꠥꠝꠣꠞ ꠛꠟꠀꠟꠣ ꠒꠣꠁꠘ ꠀꠔꠈꠣꠘ ꠛꠣꠠꠣꠁꠟꠣꠄ, ꠀꠞ ꠖꠥꠘꠤꠀꠄ ꠔꠣꠞꠣꠞꠦ ꠉꠤꠟꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX15_13","003_15_13","EXO","15","13","13","ꠔꠥꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠄ ꠎꠦꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠍ, ꠔꠣꠞꠣꠞꠦ ꠔ ꠔꠥꠝꠤꠃ ꠌꠣꠟꠣꠁꠞꠣꠄ, ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠔꠥꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠛꠡꠔ ꠈꠣꠘꠣꠔ ꠘꠤꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX15_14","003_15_14","EXO","15","14","14","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠄ ꠇꠣꠙꠤꠞꠣ, ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠛꠦ-ꠖꠤꠘ ꠅꠇꠟꠞ ꠝꠘ ꠍꠐꠚꠐ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("EX15_15","003_15_15","EXO","15","15","15","ꠁꠖꠥꠝꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟ ꠒꠞꠣꠁꠀ ꠛꠦꠖꠤꠡꠣ ꠟꠣꠉꠤꠉꠦꠟꠣ, ꠝꠥꠀꠛꠞ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠕꠞ-ꠕꠞꠣꠁꠀ ꠇꠣꠙꠤꠟꠣ, ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟ ꠒꠞꠣꠁꠀ ꠢꠞꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX15_16","003_15_16","EXO","15","16","16","ꠔꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠒꠞ-ꠈꠚ ꠀꠁꠀ ꠢꠣꠝꠣꠁꠍꠦ, ꠔꠥꠝꠣꠞ ꠀꠔꠞ ꠑꠦꠟꠣꠄ ꠙꠣꠔ꠆ꠔꠞꠞ ꠟꠣꠈꠣꠘ ꠘꠤꠞꠣꠁ ꠅꠁꠉꠦꠍꠦ। ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟ, ꠔꠥꠝꠣꠞ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝ ꠅꠇꠟ, ꠙꠥꠞꠣꠙꠥꠞ ꠙꠣꠞ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠤ ꠅꠃꠟꠣ ꠞꠣꠈꠍ। ");
INSERT INTO syls_vpl VALUES ("EX15_17","003_15_17","EXO","15","17","17","ꠔꠥꠝꠤ ꠄꠞꠣꠞꠦ ꠘꠤꠀ ꠉꠣꠍꠞ ꠌꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ, ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠙꠣꠠꠅ ꠞꠥꠁꠛꠣꠄ। ꠅ ꠝꠣꠛꠥꠖ, ꠢꠈꠣꠘꠃ ꠔꠥꠝꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣ, ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠀꠔꠞ ꠉꠠꠣ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚ। ");
INSERT INTO syls_vpl VALUES ("EX15_18","003_15_18","EXO","15","18","18","ꠅ ꠝꠣꠛꠥꠖ, ꠎꠥꠉ ꠎꠥꠉ ꠗꠞꠤ ꠔꠥꠝꠤꠃ ꠈꠣꠟꠤ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX15_19","003_15_19","EXO","15","19","19","ꠚꠦꠞꠣꠃꠘꠞ ꠊꠥꠠꠣꠁꠘ, ꠔꠣꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠘ ꠀꠞ ꠊꠥꠠ-ꠍꠅꠀꠞ ꠅꠇꠟ ꠎꠦꠛꠟꠣ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠁꠉꠦꠟ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤ ꠚꠤꠞꠣꠁ ꠀꠘꠟꠣ, ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠢꠇꠟ ꠔ ꠢꠥꠇꠘꠣ ꠙꠕꠦ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠦꠖꠤ ꠀꠉꠦ ꠀꠐꠤꠀ ꠉꠦꠍꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX15_20","003_15_20","EXO","15","20","20","ꠢꠣꠞꠥꠘꠞ ꠛꠁꠘ ꠢꠎꠞꠔ ꠝꠞꠤꠅꠝꠅ ꠘꠛꠤ ꠀꠍꠟꠣ, ꠔꠣꠁꠘ ꠒꠥꠉꠤ ꠀꠔꠅ ꠟꠁꠀ ꠛꠣꠎꠣꠁꠟꠣ, ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠦꠅ ꠔꠣꠘ ꠈꠞꠦꠖꠤ ꠒꠥꠉꠤ ꠟꠁꠀ ꠘꠣꠌꠤ ꠘꠣꠌꠤ ꠛꠣꠞ ꠅꠁ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX15_21","003_15_21","EXO","15","21","21","ꠀꠞ ꠝꠞꠤꠅꠝꠦꠅ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠅꠃꠟꠣ ꠉꠣꠁꠟꠣ: “ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠉꠎꠟ ꠉꠣꠅ, ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣ ꠛꠣꠠꠤꠍꠦ, ꠊꠥꠠ-ꠍꠅꠀꠞ ꠡꠥꠖ꠆ꠖꠣ ꠊꠥꠠꠣꠁꠘꠞꠦ ꠔꠣꠁꠘꠃ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤꠔ ꠚꠣꠟꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX15_22","003_15_22","EXO","15","22","22","ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠘꠤꠟ ꠖꠞꠤꠀ ꠕꠣꠇꠤ ꠍꠣꠝꠘꠦꠖꠤ ꠟꠁꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ, ꠀꠞ ꠡꠥꠞ ꠘꠣꠝꠞ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠦꠟꠣ। ꠔꠣꠞꠣꠞ ꠎꠣꠅꠀꠞ ꠙꠕꠅ ꠔꠤꠘ ꠖꠤꠘ ꠗꠞꠤ ꠇꠥꠘꠥ ꠙꠣꠘꠤ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX15_23","003_15_23","EXO","15","23","23","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠝꠣꠞꠥꠀ ꠘꠣꠝꠞ ꠄꠇ ꠎꠣꠉꠣꠔ ꠀꠁꠟꠣ, ꠅꠁꠟꠦ ꠢꠤꠘꠞ ꠙꠣꠘꠤꠅ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠢꠤꠘꠞ ꠙꠣꠘꠤ ꠈꠥꠛ ꠔꠤꠔ꠆ꠔꠣ। ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠟꠣꠉꠟ ꠝꠣꠞꠥꠀ ꠝꠣꠘꠤ, ꠔꠤꠔ꠆ꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX15_24","003_15_24","EXO","15","24","24","ꠀꠞ ꠝꠣꠘꠡꠦ ꠝꠥꠍꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠅꠈꠘ ꠙꠣꠘꠤ ꠈꠣꠁꠔꠣꠝ ꠇꠤꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("EX15_25","003_15_25","EXO","15","25","25","ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠚꠞꠤꠀꠖ ꠇꠞꠟꠣ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠄꠉꠥ ꠉꠣꠍ ꠖꠦꠈꠣꠁ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠢꠃ ꠉꠣꠍꠞꠦ ꠘꠤꠀ ꠙꠣꠘꠤꠔ ꠚꠣꠟꠣꠁꠟꠣ, ꠀꠞ ꠙꠣꠘꠤ ꠝꠤꠑꠣ ꠅꠁꠉꠦꠟ। ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠎꠣꠉꠣꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠟꠁꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠛꠣꠔꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX15_26","003_15_26","EXO","15","26","26","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠅ ꠀꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠝꠟ ꠇꠞꠅ, ꠀꠝꠤ ꠎꠦꠔꠣ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠅꠔꠣ ꠇꠞꠅ, ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠅ, ꠔꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞꠦ ꠎꠦꠔꠣ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠖꠤꠍꠤ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠛꠦꠝꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠖꠤꠔꠣꠝ ꠘꠣꠄ; ꠎꠣꠘ ꠔ, ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠞꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠘꠦꠀꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX15_27","003_15_27","EXO","15","27","27","ꠢꠦꠡꠦ ꠔꠣꠞꠣ ꠄꠟꠤꠝꠅ ꠉꠤꠀ ꠙꠃꠍꠟꠣ, ꠢꠤꠘꠅ ꠛꠣꠞꠅꠉꠥ ꠙꠣꠘꠤꠞ ꠁꠘ꠆ꠖꠣꠞꠣ ꠀꠞ ꠡꠔ꠆ꠔꠁꠞꠉꠥ ꠈꠦꠎꠥꠞ ꠉꠣꠍ ꠀꠍꠤꠟ। ꠔꠣꠞꠣ ꠅꠃ ꠙꠣꠘꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_1","003_16_1","EXO","16","1","1","ꠛꠣꠖꠦ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠄꠟꠤꠝ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ। ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞꠘꠤꠞ ꠛꠣꠖꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠘꠞ ꠔꠣꠞꠤꠈꠅ ꠔꠣꠞꠣ ꠍꠤꠘ ꠘꠣꠝꠞ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠁꠀ ꠀꠎꠤꠟꠣ। ꠍꠤꠘ ꠅꠁꠟ ꠔꠥꠞ ꠙꠣꠠ ꠀꠞ ꠄꠟꠤꠝꠞ ꠝꠣꠎꠈꠣꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("EX16_2","003_16_2","EXO","16","2","2","ꠅꠃ ꠡꠝꠄ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_3","003_16_3","EXO","16","3","3","ꠄꠞꠣ ꠖꠥꠁꠅꠎꠘꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠇꠁꠟꠣ, “ꠢꠣꠄꠞꠦ ꠢꠣꠄ, ꠁꠔꠣꠞ ꠇꠕꠣꠄ ꠀꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠁꠟꠣꠝ, ꠝꠣꠛꠥꠖꠦ ꠇꠦꠘꠦ ꠘꠤꠎꠞ ꠀꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠝꠣꠞꠟꠣ ꠘꠣ? ꠢꠤ ꠡꠝꠄ ꠀꠝꠞꠣ ꠉꠥꠡ꠆ꠔꠞ ꠒꠦꠉꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠁꠔꠣꠝ, ꠙꠦꠐ ꠜꠞꠤꠀ ꠉꠥꠡ꠆ꠔ-ꠞꠥꠐꠤ ꠈꠣꠁꠔꠣꠝ, ꠅꠁꠟꠦ ꠁꠔꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠃꠙꠣꠡꠦ ꠀꠞ ꠙꠦꠐꠞ ꠜꠥꠇꠦ ꠝꠣꠞꠔꠣ ꠇꠞꠤ ꠅꠘꠅ ꠀꠘꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX16_4","003_16_4","EXO","16","4","4","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠝꠥ, ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠂꠘ ꠇꠤ ꠘꠣ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤ ꠝꠦꠊꠞ ꠎꠠꠤꠞ ꠟꠣꠈꠣꠘ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠎꠝꠤꠘꠅ ꠍꠣꠠꠤꠝꠥ। ꠝꠣꠘꠡꠦ ꠛꠣꠁꠞꠦ ꠀꠁꠀ ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠞꠔꠦꠇ ꠖꠤꠘꠞ ꠈꠣꠘꠤ ꠙꠞꠔꠤ ꠖꠤꠘ ꠔꠥꠟꠤꠀ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_5","003_16_5","EXO","16","5","5","ꠈꠣꠟꠤ ꠢꠣꠙ꠆ꠔꠣꠞ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠔꠥꠟꠤꠀ ꠀꠘꠛꠣ, ꠁꠔꠣ ꠔꠂꠀꠞ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠅꠁꠘ꠆ꠘ ꠖꠤꠘꠞ ꠈꠣꠘꠤ ꠕꠣꠇꠤ ꠒꠣꠛꠥꠟ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX16_6","003_16_6","EXO","16","6","6","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠟꠣꠉꠣꠁꠍ, ꠔꠦ ꠀꠁꠎ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣꠃ ꠛꠥꠎꠛꠣꠄ, ꠅꠃ ꠝꠣꠛꠥꠖꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX16_7","003_16_7","EXO","16","7","7","ꠛꠤꠀꠘ ꠅꠁꠟꠦꠃ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠘꠥꠞ ꠖꠦꠈꠛꠣꠄ, ꠔꠣꠁꠘ ꠔ ꠢꠥꠘꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠍ। ꠔꠦ ꠀꠝꠞꠣ ꠀꠞ ꠇꠤꠔꠣ ꠎꠦꠘ, ꠔꠥꠝꠞꠣ ꠀꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠅꠔꠔꠣ ꠝꠣꠔꠤꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("EX16_8","003_16_8","EXO","16","8","8","ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠉꠥꠡ꠆ꠔ ꠖꠤꠛꠣ, ꠀꠞ ꠛꠤꠀꠘꠦ ꠙꠦꠐ ꠜꠞꠣ ꠞꠥꠐꠤꠅ ꠖꠤꠛꠣ। ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠍ, ꠁꠔꠣ ꠔꠣꠁꠘ ꠢꠥꠘꠍꠂꠘ। ꠀꠍꠟꠦ ꠀꠝꠞꠣ ꠖꠥꠁꠎꠘ ꠇꠤꠔꠣ ꠎꠦꠘ, ꠔꠥꠝꠞꠣ ꠀꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠅꠔꠔꠣ ꠝꠣꠔꠤꠞꠣꠄ? ꠁ ꠝꠣꠔ ꠔ ꠀꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠘꠣꠄ, ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦꠃ ꠝꠣꠔꠤꠞꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX16_9","003_16_9","EXO","16","9","9","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠦꠔꠣ ꠝꠣꠔꠤꠍ, ꠁꠔꠣ ꠔꠣꠁꠘ ꠢꠥꠘꠍꠂꠘ। ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠀꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX16_10","003_16_10","EXO","16","10","10","ꠔꠦꠃ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠡꠋꠛꠣꠖ ꠎꠣꠘꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠙꠠꠔꠦꠃ ꠖꠦꠈꠂꠘ, ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤꠞ ꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠘꠥꠞ ꠎꠣꠁꠞ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX16_11","003_16_11","EXO","16","11","11","ꠄꠞꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX16_12","003_16_12","EXO","16","12","12","“ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠔ-ꠇꠕꠣ ꠢꠥꠘꠍꠤ। ꠅꠈꠘ ꠔꠥꠝꠤ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠈꠣꠁꠛꠣ ꠉꠥꠡ꠆ꠔ ꠀꠞ ꠛꠤꠀꠘꠦ ꠈꠣꠁꠛꠣ ꠙꠦꠐ ꠜꠞꠣ ꠞꠥꠐꠤ। ꠔꠦꠃ ꠔꠣꠞꠣ ꠛꠥꠎꠛꠣ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠣꠞꠣꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("EX16_13","003_16_13","EXO","16","13","13","ꠢꠣꠍꠣꠃ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠇꠥꠄꠟ ꠙꠣꠈꠤꠞ ꠙꠣꠟ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠇꠦꠝ꠆ꠙꠅ ꠎꠣꠝ ꠅꠁꠉꠦꠟ, ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠈꠥꠀ ꠙꠠꠤꠀ ꠇꠦꠝ꠆ꠙꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠜꠤꠎꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX16_14","003_16_14","EXO","16","14","14","ꠛꠦꠁꠟ ꠅꠀꠞ ꠛꠣꠖꠦ ꠅꠃ ꠈꠥꠀ ꠢꠥꠇꠣꠁꠟꠦ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠡꠣꠉꠥꠞ ꠖꠣꠘꠣꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠎꠣꠔꠞ ꠙꠣꠔꠟꠣ ꠎꠤꠘꠤꠡ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠙꠠꠤ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX16_15","003_16_15","EXO","16","15","15","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠛꠣ, ꠁꠔꠣ ꠇꠤꠔꠣ? ꠁꠔꠣ ꠇꠤꠔꠣ ꠙꠠꠍꠦ, ꠀꠝꠞꠣ ꠇꠦꠃ ꠔ ꠌꠤꠘꠞꠣꠝ ꠘꠣ।” ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠈꠣꠘꠤ, ꠔꠥꠝꠞꠣ ꠈꠣꠁꠔꠣꠄ ꠇꠞꠤ ꠝꠣꠛꠥꠖꠦ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX16_16","003_16_16","EXO","16","16","16","ꠅꠃ ꠈꠣꠘꠤꠞ ꠇꠕꠣꠃ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠙꠞꠔꠦꠇ ꠎꠘꠦ ꠎꠣꠞꠎꠤꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠤ ꠔꠥꠇꠣꠁꠀ ꠘꠦꠅ। ꠊꠞꠞ ꠢꠇꠟꠞ ꠟꠣꠉꠤ ꠎꠘ-ꠙꠤꠍꠦ ꠄꠇ ꠙꠦꠐꠥ ꠇꠞꠤ ꠔꠥꠇꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX16_17","003_16_17","EXO","16","17","17","ꠔꠦꠃ ꠔꠣꠞꠣ ꠅꠃꠟꠣ ꠇꠞꠟꠣ, ꠝꠣꠘꠥꠡ ꠅꠘꠥꠝꠣꠘꠦ ꠇꠦꠃ ꠛꠦꠡ ꠇꠞꠤ ꠘꠤꠟꠣ, ꠇꠦꠃ ꠇꠝ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_18","003_16_18","EXO","16","18","18","ꠛꠣꠖꠦ ꠙꠦꠐꠥꠖꠤ ꠝꠣꠙꠤꠀ ꠖꠦꠈꠟꠣ, ꠎꠦꠁꠘ ꠛꠦꠡꠤ ꠔꠥꠇꠣꠁꠍꠟꠣ, ꠔꠣꠘꠅ ꠛꠦꠡꠤ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠞ ꠎꠦꠁꠘ ꠕꠥꠠꠣ ꠔꠥꠇꠣꠁꠍꠟꠣ, ꠔꠣꠘꠅ ꠇꠝ ꠅꠁꠍꠦ ꠘꠣ; ꠢꠇꠟꠦꠃ ꠎꠣꠞꠎꠤꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠈꠣꠘꠤꠞ ꠅꠘꠥꠝꠣꠘꠦ ꠔꠥꠇꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX16_19","003_16_19","EXO","16","19","19","ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠣꠁꠟ ꠛꠤꠀꠘꠇꠥꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠝꠥꠐꠦꠃ ꠎꠝꠣꠁ ꠕꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX16_20","003_16_20","EXO","16","20","20","ꠔꠣ-ꠅ ꠇꠦꠃ ꠇꠦꠃ ꠝꠥꠍꠣꠞ ꠇꠕꠣ ꠘꠣ ꠝꠣꠘꠤꠀ ꠛꠣꠖꠞ ꠖꠤꠘꠞ ꠟꠣꠉꠤꠅ ꠕꠥꠠꠣ ꠕꠁꠟ। ꠄꠞꠟꠣꠉꠤ ꠁꠔꠣ ꠙꠌꠤꠀ ꠇꠤꠠꠣ-ꠙꠥꠇ ꠎꠘꠝꠤꠀ ꠉꠘ꠆ꠖ ꠛꠣꠞ ꠅꠁꠟ; ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠥꠍꠣ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠛ ꠉꠥꠍꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_21","003_16_21","EXO","16","21","21","ꠅꠟꠣ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠚꠎꠞꠦ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠈꠣꠘꠤꠞ ꠅꠘꠥꠝꠣꠘꠦ ꠔꠥꠇꠣꠁꠔ, ꠅꠁꠟꠦ ꠞꠂꠖ ꠉꠞꠝ ꠅꠁꠟꠦꠃ ꠁꠔꠣ ꠉꠟꠤꠎꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("EX16_22","003_16_22","EXO","16","22","22","ꠛꠣꠖꠦ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠔꠣꠞꠣꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠒꠣꠛꠥꠟ ꠈꠣꠘꠤ, ꠝꠣꠘꠤ ꠖꠥꠁ ꠙꠦꠐꠥ ꠇꠞꠤ ꠔꠥꠇꠣꠁꠟ, ꠀꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠀꠁꠀ ꠝꠥꠍꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_23","003_16_23","EXO","16","23","23","ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠑꠤꠇ ꠀꠍꠦ, ꠝꠣꠛꠥꠖꠦꠃ ꠅꠃꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ; ꠇꠣꠁꠟ ꠔ ꠢꠣꠙ꠆ꠔꠣꠞ ꠡꠦꠡ ꠖꠤꠘ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ; ꠝꠣꠛꠥꠖꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠖꠤꠘ। ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠞꠣꠘ꠆ꠖꠣꠞ ꠖꠞꠇꠣꠞ ꠀꠍꠦ ꠁꠔꠣ ꠀꠁꠎ ꠞꠣꠘ꠆ꠖꠤꠟꠣꠅ, ꠀꠞ ꠛꠤꠞꠣꠘ ꠇꠞꠣꠞ ꠎꠞꠥꠞ ꠅꠁꠟꠦ ꠛꠤꠞꠣꠘ ꠇꠞꠅ, ꠛꠣꠇꠤ ꠢꠇꠟꠔꠣ ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠇꠥꠞ ꠟꠣꠉꠤ ꠕꠁ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX16_24","003_16_24","EXO","16","24","24","ꠅꠃ ꠝꠥꠍꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣ ꠛꠣꠖꠞ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠊꠞꠅ ꠕꠁꠟ, ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠉꠘ꠆ꠖꠅ ꠛꠣꠞ ꠅꠁꠟ ꠘꠣ, ꠇꠤꠠꠣꠄꠅ ꠗꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_25","003_16_25","EXO","16","25","25","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠁꠎ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠈꠣꠅ, ꠇꠣꠞꠘ ꠀꠁꠎ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠖꠤꠘ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ। ꠀꠁꠎ ꠔꠥꠝꠞꠣ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠁ ꠈꠣꠘꠤ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX16_26","003_16_26","EXO","16","26","26","ꠔꠥꠝꠞꠣ ꠢꠣꠙ꠆ꠔꠣꠔ ꠍꠄ ꠖꠤꠘ ꠁ ꠈꠣꠘꠤ ꠔꠥꠇꠣꠁꠅ, ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠔ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ, ꠁ ꠖꠤꠘ ꠁꠔꠣ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX16_27","003_16_27","EXO","16","27","27","ꠔꠣ-ꠅ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠅꠃ ꠈꠣꠘꠤ ꠔꠥꠇꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞꠦ ꠉꠦꠟ, ꠉꠤꠀ ꠇꠥꠘ꠆ꠔꠣ ꠙꠣꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_28","003_16_28","EXO","16","28","28","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠞ ꠇꠔꠖꠤꠘ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠜꠣꠋꠉꠤꠔꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("EX16_29","003_16_29","EXO","16","29","29","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠎꠤꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠔ ꠝꠣꠛꠥꠖꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠢꠣꠙ꠆ꠔꠣꠞ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠁ ꠖꠤꠘꠞ ꠈꠣꠘꠤ ꠖꠦꠁꠘ; ꠅꠈꠘ ꠕꠣꠇꠤ ꠅꠃ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ, ꠝꠣꠘꠤ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠊꠞꠅ ꠞꠁꠀ ꠎꠤꠞꠣꠁꠅ, ꠇꠦꠃ ꠊꠞꠞ ꠛꠣꠞꠦ ꠎꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX16_30","003_16_30","EXO","16","30","30","ꠄꠞꠛꠣꠖ ꠕꠣꠇꠤ ꠢꠣꠙ꠆ꠔꠣꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠝꠣꠘꠡꠦ ꠎꠤꠞꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("EX16_31","003_16_31","EXO","16","31","31","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠁ ꠈꠣꠘꠤꠞ ꠘꠣꠝ ꠕꠁꠟ, ꠝꠣꠘ꠆ꠘꠣ; ꠁꠔꠣ ꠖꠦꠈꠔꠦ ꠗꠟꠣ ꠒꠥꠟꠣ ꠛꠤꠌꠤꠞ ꠟꠣꠈꠣꠘ, ꠀꠞ ꠈꠣꠁꠔꠦ ꠝꠃ ꠝꠣꠈꠣꠁꠟ ꠙꠤꠑꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_32","003_16_32","EXO","16","32","32","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠄꠇ ꠙꠦꠐꠥ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠘ꠆ꠘꠣ ꠔꠥꠟꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠖꠞ ꠛꠋꠡꠗꠞ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠎꠝꠣ ꠇꠞꠤ ꠕꠅ, ꠔꠦꠃ ꠔꠣꠞꠣꠅ ꠖꠦꠈꠛꠣ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠘꠦꠅꠀꠞ ꠇꠣꠟꠅ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠔꠣꠁꠘ ꠇꠤꠔꠣ ꠈꠣꠅꠀꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX16_33","003_16_33","EXO","16","33","33","ꠝꠥꠍꠣꠄ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠄꠉꠥ ꠛꠂꠀꠝꠞ ꠝꠣꠎꠦ ꠄꠇ ꠙꠦꠐꠥ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠘ꠆ꠘꠣ ꠔꠥꠟꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠅ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠎꠝꠣ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX16_34","003_16_34","EXO","16","34","34","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠟꠣ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠣꠞꠥꠘꠦ ꠅꠃ ꠝꠣꠘ꠆ꠘꠣ ꠛꠂꠀꠝꠅ ꠜꠞꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠙꠛꠤꠔ꠆ꠞ ꠡꠘ꠆ꠖꠥꠇꠞ ꠜꠤꠔꠞꠦ ꠡꠣꠢꠣꠖꠔ ꠙꠣꠔ꠆ꠔꠞꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_35","003_16_35","EXO","16","35","35","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠗꠞꠤ ꠁ ꠝꠣꠘ꠆ꠘꠣ ꠈꠣꠁꠟ, ꠔꠣꠞꠣ ꠎꠔꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠝꠣꠘꠥꠡ ꠛꠡꠔ ꠇꠞꠣꠞ ꠎꠣꠉꠣ, ꠝꠣꠘꠤ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠀꠁꠀ ꠘꠣ ꠙꠃꠍꠤꠟ, ꠅꠔꠖꠤꠘ ꠅꠃ ꠈꠣꠘꠤꠃ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX16_36","003_16_36","EXO","16","36","36","ꠄꠇ ꠙꠦꠐꠥ ꠅꠁꠟꠉꠤ, ꠄꠇ ꠚꠥꠞꠣꠞꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ। ");
INSERT INTO syls_vpl VALUES ("EX17_1","003_17_1","EXO","17","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠦ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠍꠤꠘ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠀ, ꠄꠇ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠉꠤꠀ ꠢꠦꠡꠦ ꠞꠚꠤꠖꠤꠝꠅ ꠀꠁꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ, ꠅꠁꠟꠦ ꠢꠤꠘꠅ ꠝꠣꠘꠡꠞ ꠈꠣꠅꠀꠞ ꠙꠣꠘꠤ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX17_2","003_17_2","EXO","17","2","2","ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞꠦ ꠈꠣꠅꠀꠞ ꠙꠣꠘꠤ ꠖꠦꠃꠇ꠆ꠇꠣ।” ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠞꠣꠄ? ꠇꠦꠘꠦ ꠝꠣꠛꠥꠖꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("EX17_3","003_17_3","EXO","17","3","3","ꠝꠣꠘꠡꠦ ꠙꠣꠘꠤꠞ ꠙꠤꠀꠍꠦ ꠇꠣꠢꠤꠟ ꠅꠁꠀ ꠝꠥꠍꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠉꠣꠟꠤ-ꠉꠣꠟꠣꠎ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞꠦ ꠝꠣꠞꠔꠣꠄ ꠇꠞꠤ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠘꠍ ꠘꠤ? ꠀꠝꠞꠣꠞꠦ, ꠀꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ, ꠀꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞꠦ ꠀꠘꠣ-ꠙꠣꠘꠤꠄ ꠝꠣꠞꠔꠣꠄ ꠇꠞꠤ ꠅꠘꠅ ꠀꠘꠍ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("EX17_4","003_17_4","EXO","17","4","4","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠚꠞꠤꠀꠖ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠁ ꠝꠣꠘꠡꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ? ꠀꠞ ꠕꠥꠠꠣ ꠖꠦꠞꠤ ꠅꠁꠟꠦꠃ ꠔ ꠔꠣꠞꠣ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠁꠐꠣꠁꠀ ꠀꠝꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX17_5","003_17_5","EXO","17","5","5","ꠝꠣꠛꠥꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤ ꠎꠦ ꠟꠣꠑꠤꠖꠤ ꠘꠤꠟ ꠘꠖꠅ ꠛꠣꠠꠤ ꠝꠣꠞꠍꠟꠣꠄ, ꠢꠃ ꠟꠣꠑꠤ ꠀꠔꠅ ꠟꠅ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠄꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠝꠣꠘꠡꠞ ꠀꠉꠦ ꠀꠉꠦ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EX17_6","003_17_6","EXO","17","6","6","ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠀꠝꠤ ꠔꠥꠞ ꠙꠣꠠꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠀꠎꠤꠞ ꠅꠁꠝꠥ, ꠔꠥꠝꠤ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠅ ꠛꠣꠠꠤ ꠝꠣꠞꠟꠦ ꠅꠉꠥ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠛ, ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ।” ꠢꠣꠍꠣꠃ ꠝꠥꠍꠣꠄ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠅꠃꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX17_7","003_17_7","EXO","17","7","7","ꠅꠃ ꠞꠚꠤꠖꠤꠝꠅ ꠀꠁꠀ ꠝꠣꠘꠡꠦ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠤ ꠇꠁꠍꠟꠣ, “ꠝꠣꠛꠥꠖ ꠇꠤꠔꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ ꠘꠤ, ꠘꠣ ꠢꠞꠤ ꠉꠦꠍꠂꠘ?” ꠅꠃꠟꠣ ꠇꠁꠀ ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠍꠟꠣ ꠇꠞꠤ, ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠝꠣꠍꠣ ꠝꠣꠘꠤ, ꠙꠞꠤꠇ꠆ꠇꠣ ꠀꠞ ꠝꠦꠞꠤꠛꠣ ꠝꠣꠘꠤ, ꠇꠣꠁꠎ꠆ꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("EX17_8","003_17_8","EXO","17","8","8","ꠅꠃ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠟꠦꠇꠤ ꠍꠤꠙꠣꠁ ꠅꠇꠟ ꠞꠚꠤꠖꠤꠝꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX17_9","003_17_9","EXO","17","9","9","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠈꠣꠖꠤꠝ ꠢꠎꠞꠔ ꠁꠃꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ ꠟꠣꠠꠣꠁ ꠇꠞꠞꠣ ꠎꠘ ꠛꠣꠍꠤꠀ ꠘꠤꠀ, ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠔ ꠎꠣꠅ। ꠀꠝꠤꠅ ꠇꠣꠁꠟ ꠀꠟ꠆ꠟꠣꠁ ꠇꠥꠖꠞꠔꠤ ꠟꠣꠑꠤ ꠀꠔꠅ ꠟꠁꠀ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠛꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX17_10","003_17_10","EXO","17","10","10","ꠁꠃꠍꠣꠄꠅ ꠝꠥꠍꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠟꠣ। ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠟꠣ, ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ, ꠀꠞ ꠢꠥꠞ, ꠅꠃ ꠔꠤꠘꠅ ꠎꠘ ꠉꠤꠀ ꠙꠣꠠꠞ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX17_11","003_17_11","EXO","17","11","11","ꠛꠣꠖꠦ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠝꠥꠍꠣꠄ ꠎꠔ ꠡꠝꠄ ꠀꠔ ꠃꠌꠣ ꠇꠞꠤ ꠞꠣꠈꠂꠘ, ꠅꠔ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠟ ꠎꠤꠔꠂꠘ, ꠅꠁꠟꠦ ꠝꠥꠍꠣꠄ ꠀꠔ ꠟꠣꠝꠣꠁꠟꠦꠃ ꠀꠝꠣꠟꠦꠇꠤ ꠖꠟ ꠎꠤꠔꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX17_12","003_17_12","EXO","17","12","12","ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠝꠥꠍꠣꠞ ꠀꠔ ꠜꠣꠞ ꠅꠀ ꠗꠞꠟ। ꠅꠃ ꠔꠣꠞꠣ ꠄꠇꠈꠣꠘ ꠙꠣꠔ꠆ꠔꠞ ꠀꠘꠤꠀ ꠝꠥꠍꠣꠞꠦ ꠛꠁꠛꠣꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠖꠤꠟꠣ। ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠝꠥꠍꠣ ꠛꠁꠟꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠢꠥꠞ ꠖꠥꠁꠅꠎꠘꠦ ꠝꠥꠍꠣꠞ ꠖꠥꠁ ꠉꠣꠟꠣꠔ ꠃꠛꠣꠁꠀ ꠔꠣꠘ ꠀꠔ ꠃꠌꠣ ꠇꠞꠤ ꠗꠞꠟꠣ। ꠔꠦꠃ ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠘ ꠀꠔ ꠃꠌꠣ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX17_13","003_17_13","EXO","17","13","13","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠟꠦꠇꠤ ꠍꠤꠙꠣꠁꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠤꠀ ꠁꠃꠍꠣ ꠎꠤꠔꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX17_14","003_17_14","EXO","17","14","14","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠁꠀꠖ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠄꠇꠈꠣꠘ ꠇꠤꠔꠣꠛꠞ ꠝꠣꠎꠦ ꠟꠦꠈꠤꠀ ꠕꠅ ꠀꠞ ꠁꠃꠍꠣꠞꠦꠅ ꠎꠣꠘꠣꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠖꠥꠘꠤꠀꠞ ꠛꠥꠇ ꠕꠣꠇꠤ ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX17_15","003_17_15","EXO","17","15","15","ꠝꠥꠍꠣꠄ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠀ ꠄꠞ ꠘꠣꠝ ꠕꠁꠟꠣ, ꠝꠣꠛꠥꠖꠃ ꠀꠝꠣꠞ ꠎꠥꠖ꠆ꠖꠞ ꠏꠣꠘ꠆ꠒꠣ। ");
INSERT INTO syls_vpl VALUES ("EX17_16","003_17_16","EXO","17","16","16","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠞ ꠎꠥꠖ꠆ꠖꠞ ꠏꠣꠘ꠆ꠒꠣ ꠀꠝꠞꠣ ꠀꠔꠅ ꠟꠁ, ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦꠅ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX18_1","003_18_1","EXO","18","1","1","ꠀꠟ꠆ꠟꠣꠄ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞꠦ ꠀꠞ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠞꠢꠝ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠝꠥꠍꠣꠞ ꠢꠃꠞ ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠞ ꠁꠝꠣꠝ ꠡꠥꠀꠁꠛꠞ ꠇꠣꠘꠅ ꠉꠦꠟ। ꠝꠣꠛꠥꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠇꠤꠟꠣ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠄꠅꠔꠣ ꠔꠣꠁꠘ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_2","003_18_2","EXO","18","2","2","ꠝꠥꠍꠣꠄ ꠀꠉꠦ ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠚꠥꠞꠣꠞꠦ ꠢꠃꠞ ꠛꠣꠠꠤꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠍꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠢꠃꠞꠦ ꠝꠥꠍꠣꠞ ꠛꠤꠛꠤꠞꠦ ꠀꠞ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠘꠤꠎꠞ ꠉꠦꠍꠦ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_3","003_18_3","EXO","18","3","3","ꠁ ꠖꠥꠁꠅ ꠙꠥꠀꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠎꠣꠞꠍꠥꠝ ꠝꠣꠘꠤ, ꠛꠂꠔꠟ। ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠜꠤꠘ ꠖꠦꠡꠅ ꠛꠂꠔꠟꠞ ꠟꠣꠈꠣꠘ ꠞꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("EX18_4","003_18_4","EXO","18","4","4","ꠀꠞ ꠖꠥꠍꠞꠣ ꠎꠘꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠄꠟꠤꠄꠎꠦꠞ ꠝꠣꠘꠤ, ꠀꠟ꠆ꠟꠣ ꠡꠢꠣꠄ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠀꠟ꠆ꠟꠣ ꠀꠝꠣꠞ ꠡꠢꠣꠄ ꠅꠁꠀ ꠀꠝꠣꠞꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠔꠟꠥꠀꠞ ꠕꠣꠇꠤ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX18_5","003_18_5","EXO","18","5","5","ꠝꠥꠍꠣꠞ ꠢꠃꠞ ꠡꠥꠀꠁꠛꠦ ꠝꠥꠍꠣꠞ ꠛꠤꠛꠤ ꠀꠞ ꠔꠣꠘ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠟꠁꠀ ꠝꠥꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠞ ꠝꠥꠍꠣꠞ ꠔꠣꠝ꠆ꠛꠥ ꠀꠍꠤꠟ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠠ ꠔꠥꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("EX18_6","003_18_6","EXO","18","6","6","ꠔꠣꠘ ꠢꠃꠞ ꠅꠘꠅ ꠀꠁꠀ ꠝꠥꠍꠣꠞꠦ ꠈꠛꠞ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠢꠃꠞ ꠡꠥꠀꠁꠛ। ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠤꠛꠤ ꠀꠞ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠟꠁꠀ ꠅꠘꠅ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX18_7","003_18_7","EXO","18","7","7","ꠈꠛꠞ ꠙꠣꠁꠀ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠢꠃꠞꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠛꠣꠞ ꠅꠁꠟꠣ। ꠔꠣꠁꠘ ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠔꠣꠘ ꠢꠃꠞꠞꠦ ꠍꠣꠟꠣꠝ ꠇꠞꠟꠣ ꠀꠞ ꠝꠣꠄꠀꠞ ꠢꠥꠋꠉꠣ ꠖꠤꠟꠣ। ꠛꠣꠖꠦ ꠖꠥꠁꠅꠎꠘꠦ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠎꠤꠇꠣꠁꠀ ꠢꠣꠞꠤ ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_8","003_18_8","EXO","18","8","8","ꠝꠣꠛꠥꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠣꠘ ꠢꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ। ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠔꠣꠞꠣꠞ ꠇꠔ ꠇꠡ꠆ꠐ ꠅꠁꠍꠤꠟ ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠇꠤꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠍꠂꠘ ꠄꠅꠔꠣꠅ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_9","003_18_9","EXO","18","9","9","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠀꠍꠣꠘ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠘ ꠢꠃꠞ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_10","003_18_10","EXO","18","10","10","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠇꠟ ꠔꠣꠞꠤꠚ ꠝꠣꠛꠥꠖꠞ, ꠎꠦꠁꠘ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠀꠔ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX18_11","003_18_11","EXO","18","11","11","ꠅꠈꠘ ꠀꠝꠤ ꠘꠤꠎꠦꠅ ꠛꠥꠎꠤꠀꠞ, ꠢꠇꠟ ꠖꠦꠛꠔꠣꠞ ꠌꠣꠁꠔꠦ ꠀꠟ꠆ꠟꠣꠃ ꠝꠢꠣꠘ। ꠇꠣꠞꠘ ꠝꠤꠡꠞꠤꠘ꠆ꠔꠦ ꠎꠦꠔꠣ ꠛꠦꠙꠣꠞ ꠟꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠣꠢꠣꠖꠥꠞꠤ ꠇꠞꠔꠣ, ꠁꠔꠣꠞ ꠇꠛꠎꠣ ꠕꠣꠇꠤ ꠔꠣꠁꠘꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX18_12","003_18_12","EXO","18","12","12","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠞ ꠢꠃꠞ ꠡꠥꠀꠁꠛꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠎꠥꠁꠔ ꠇꠞꠤ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠢꠦꠡꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠀꠁꠀ, ꠝꠥꠍꠣꠞ ꠢꠃꠞꠞ ꠟꠉꠦ ꠛꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_13","003_18_13","EXO","18","13","13","ꠛꠣꠖꠞ ꠖꠤꠘ ꠝꠥꠍꠣꠄ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ-ꠡꠣꠟꠤꠡ ꠇꠞꠣꠔ ꠛꠁꠟꠣ। ꠛꠤꠌꠣꠞꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠛꠤꠀꠘ ꠕꠣꠇꠤ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠣꠞꠣꠖꠤꠘ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_14","003_18_14","EXO","18","14","14","ꠝꠥꠍꠣꠄ ꠅꠟꠣ ꠇꠞꠞꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠢꠃꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠞꠣꠄ? ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠄꠇꠟꠣ ꠅꠘꠅ ꠛꠤꠌꠣꠞꠅ ꠛꠁꠍ, ꠀꠞ ꠛꠤꠀꠘ ꠕꠣꠇꠤ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("EX18_15","003_18_15","EXO","18","15","15","ꠝꠥꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠛꠤꠌꠣꠞꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠚꠄꠍꠣꠟꠣ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠥꠡ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("EX18_16","003_18_16","EXO","18","16","16","ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠇꠞꠟꠦ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠘ, ꠀꠁꠟꠦ ꠀꠝꠤ ꠖꠥꠁꠅ ꠖꠟꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠔꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("EX18_17","003_18_17","EXO","18","17","17","ꠔꠦꠃ ꠝꠥꠍꠣꠞ ꠢꠃꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠦꠟꠣꠈꠣꠘ ꠁꠔꠣ ꠇꠞꠞꠣꠄ, ꠁꠔꠣ ꠔ ꠜꠣꠟꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX18_18","003_18_18","EXO","18","18","18","ꠁꠟꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡꠅ ꠇꠣꠢꠤꠟ ꠅꠁꠎꠤꠛꠣꠄ। ꠁ ꠇꠣꠝ ꠔꠥꠝꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠕꠣꠇꠤ ꠛꠦꠡꠤ, ꠔꠥꠝꠤ ꠄꠇꠟꠣ ꠁꠔꠣ ꠇꠥꠟꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX18_19","003_18_19","EXO","18","19","19","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠀꠞ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠙꠞꠣꠝꠤꠡ ꠢꠥꠘꠅ, ꠄꠔꠦ ꠀꠟ꠆ꠟꠣꠅ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠞꠁꠛꠣ। ꠔꠥꠝꠤ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ-ꠀꠌꠣꠞ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠔꠣꠞꠣꠞ ꠁꠝꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠢꠇꠟ ꠛꠦꠙꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX18_20","003_18_20","EXO","18","20","20","ꠀꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠔꠣꠟꠤꠝ ꠖꠤꠅ। ꠔꠣꠞꠣ ꠇꠤꠟꠣ ꠌꠟꠔꠣ, ꠇꠤꠔꠣ ꠇꠞꠔꠣ ꠘꠣ ꠇꠞꠔꠣ, ꠅꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠛꠥꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX18_21","003_18_21","EXO","18","21","21","ꠀꠞ ꠔꠥꠝꠤ ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠍꠤꠀ ꠅꠃꠟꠣ ꠎꠁꠉ꠆ꠉ ꠝꠣꠘꠥꠡ ꠛꠣꠞ ꠇꠞꠅ, ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠘ, ꠢꠇ ꠙꠕꠦ ꠌꠟꠂꠘ, ꠀꠞ ꠊꠥꠡ ꠈꠣꠅꠀꠞꠦ ꠊꠤꠘ ꠇꠞꠂꠘ। ꠄꠞꠣꠞꠦ ꠔꠥꠝꠤ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ-ꠀꠌꠣꠞꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠦꠅ। ꠄꠞꠣ ꠇꠥꠘꠥ ꠎꠘꠞꠦ ꠀꠎꠣꠞ ꠎꠘꠞ ꠃꠙꠞꠦ, ꠇꠦꠃꠞꠞꠦ ꠡ ꠎꠘ, ꠇꠦꠃꠞꠞꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ, ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠖꠡ ꠎꠘꠞ ꠃꠙꠞꠦ ꠛꠤꠌꠣꠞ-ꠀꠌꠣꠞꠞ ꠜꠣꠞ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("EX18_22","003_18_22","EXO","18","22","22","ꠄꠞꠣꠃ ꠢꠣꠝꠦꠡꠣ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ-ꠁꠘꠍꠣꠚ ꠇꠞꠛꠣ। ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠢꠇꠟ ꠛꠤꠌꠣꠞ ꠔꠣꠞꠣ ꠇꠞꠛꠣ, ꠈꠣꠟꠤ ꠛꠠ ꠛꠠ ꠛꠤꠌꠣꠞ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠛꠣ। ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠜꠣꠞ ꠇꠤꠍꠥ ꠇꠝꠛ, ꠔꠣꠞꠣꠅ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠇꠤꠍꠥ ꠜꠣꠞ ꠛꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_23","003_18_23","EXO","18","23","23","ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠅꠃꠟꠣ ꠇꠞ, ꠔꠦ ꠔꠥꠝꠤ ꠇꠥꠟꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠀꠞ ꠝꠣꠘꠡꠦꠅ ꠀꠞꠣꠝꠦ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠉꠣꠔ ꠎꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX18_24","003_18_24","EXO","18","24","24","ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠢꠃꠞꠞ ꠙꠞꠣꠝꠤꠡ ꠝꠣꠘꠟꠣ, ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠇꠁꠟꠣ ꠝꠥꠍꠣꠄ ꠅꠃꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_25","003_18_25","EXO","18","25","25","ꠝꠥꠍꠣꠄ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠛꠣꠍꠤꠀ ꠃꠙꠎꠥꠇ꠆ꠔ ꠝꠣꠘꠥꠡ ꠔꠥꠇꠣꠁꠀ, ꠔꠣꠞꠣ ꠇꠦꠃꠞꠞꠦ ꠀꠎꠣꠞ ꠎꠘ, ꠇꠦꠃꠞꠞꠦ ꠡ ꠎꠘ, ꠇꠦꠃꠞꠞꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠖꠡ ꠎꠘꠞ ꠃꠙꠞꠦ ꠘꠦꠔꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_26","003_18_26","EXO","18","26","26","ꠄꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ-ꠀꠌꠣꠞ ꠇꠞꠔꠣ। ꠈꠣꠟꠤ ꠛꠠ ꠛꠠ ꠊꠐꠘꠣ ꠅꠇꠟ ꠝꠥꠍꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠘꠔꠣ, ꠀꠞ ꠢꠥꠞꠥ ꠢꠥꠞꠥ ꠢꠇꠟꠔꠣ ꠔꠣꠞꠣ ꠝꠤꠐꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX18_27","003_18_27","EXO","18","27","27","ꠢꠦꠡꠦ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠢꠃꠞꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠦ, ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠖꠦꠡꠅ ꠔꠡꠞꠤꠚ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX19_1","003_19_1","EXO","19","1","2","ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ ꠛꠣꠞꠘꠤꠞ ꠛꠣꠖꠦ, ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘꠃ ꠔꠣꠞꠣ ꠞꠚꠤꠖꠤꠝ ꠅꠁꠀ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠙꠃꠍꠤꠟꠣ। ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠞꠣ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠔꠥꠞ ꠙꠣꠠꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX19_3","003_19_3","EXO","19","3","3","ꠄꠞꠝꠣꠎꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠉꠦꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠔꠣꠘꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠝꠥꠍꠣ, ꠔꠥꠝꠤ ꠁꠀꠇꠥꠛꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠇꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ");
INSERT INTO syls_vpl VALUES ("EX19_4","003_19_4","EXO","19","4","4","ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠖꠡꠣ ꠇꠤꠔꠣ ꠊꠐꠣꠁꠍꠤ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠍ। ꠌꠤꠟꠦ ꠎꠦꠟꠣ ꠔꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠒꠣꠈꠘꠣꠖꠤ ꠛꠁꠀ ꠘꠦꠄ, ꠀꠝꠤꠅ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠛꠁꠀ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX19_5","003_19_5","EXO","19","5","5","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠔꠣꠝꠣꠝ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠟꠉꠞ ꠅꠀꠖꠣ ꠀꠖꠣꠄ ꠇꠞꠅ, ꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠃ ꠅꠁꠛꠣꠄ ꠀꠝꠣꠞ ꠈꠣꠍ ꠡꠝ꠆ꠙꠖ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠣꠞ ꠄꠈꠔꠤꠀꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EX19_6","003_19_6","EXO","19","6","6","ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠀꠃ ꠇꠣꠁꠝ ꠅꠁꠛ ꠀꠝꠣꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣꠁ, ꠔꠥꠝꠞꠣꠃ ꠅꠁꠛꠣꠄ ꠀꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠔꠤ। ꠔꠦ ꠀꠝꠣꠞ ꠅꠃ ꠛꠥꠟꠤ ꠈꠣꠘꠣꠁꠘ ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX19_7","003_19_7","EXO","19","7","7","ꠅꠃ ꠝꠥꠍꠣꠄ ꠀꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠟꠣ ꠇꠞꠣꠁꠟꠣ। ꠖꠟꠣ ꠇꠞꠣꠁꠀ ꠇꠁꠟꠣ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX19_8","003_19_8","EXO","19","8","8","ꠔꠦꠃ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠄꠇꠟꠉꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠎꠦꠟꠣ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠀꠝꠞꠣ ꠅꠟꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠇꠞꠝꠥ।” ꠝꠣꠘꠡꠦ ꠎꠦꠝꠘꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, ꠝꠥꠍꠣꠄ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠅꠟꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX19_9","003_19_9","EXO","19","9","9","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠝꠥ, ꠅꠃ ꠛꠣꠔꠌꠤꠔ ꠎꠣꠔꠦ ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞ ꠇꠣꠘꠦ ꠢꠥꠘꠔ ꠙꠣꠞꠦ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠊꠘ ꠄꠇ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤꠞ ꠝꠣꠎꠦ ꠞꠁꠀ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠝꠥ। ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠢꠥꠘꠛꠣ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠄꠇꠤꠘ ꠞꠣꠈꠛꠣ।” ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠉꠤꠀ ꠔꠣꠞꠣꠞꠅ ꠢꠇꠟ ꠇꠕꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX19_10","003_19_10","EXO","19","10","10","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠁꠎ ꠀꠞ ꠇꠣꠁꠟ ꠖꠥꠁꠅ ꠖꠤꠘ ꠝꠣꠘꠡꠞ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠅ। ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("EX19_11","003_19_11","EXO","19","11","11","ꠔꠣꠞꠣ ꠙꠞꠡꠥ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠔꠂꠀꠞ ꠅꠃꠇ, ꠅꠃ ꠖꠤꠘ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠔꠣꠞꠣ ꠢꠇꠟꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX19_12","003_19_12","EXO","19","12","12","ꠔꠦ ꠔꠥꠝꠤ ꠙꠣꠠꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠄꠇꠐꠣ ꠡꠤꠝꠣꠘꠣ ꠑꠤꠇ ꠇꠞꠤꠀ ꠖꠤꠟꠣꠅ। ꠖꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤ ꠇꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠁ ꠙꠣꠠꠅ ꠘꠣ ꠃꠑꠦ ꠀꠞ ꠙꠣꠠꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠘꠣ ꠍꠄ। ꠇꠦꠃ ꠎꠥꠖꠤ ꠁ ꠙꠣꠠꠅ ꠍꠄ, ꠔꠦ ꠔꠣꠞ ꠡꠣꠎꠣ ꠅꠁꠟ ꠝꠃꠔ। ");
INSERT INTO syls_vpl VALUES ("EX19_13","003_19_13","EXO","19","13","13","ꠝꠣꠞꠣꠞ ꠛꠣꠟꠣ ꠔꠣꠞ ꠉꠔꠞꠅ ꠀꠔ ꠘꠣ ꠖꠤꠀ, ꠔꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠛꠣ ꠔꠤꠞ ꠝꠣꠞꠤꠀ ꠝꠣꠞꠛꠣꠄ। ꠢꠦ ꠝꠣꠘꠥꠡ ꠅꠃꠇ ꠛꠣ ꠎꠣꠘꠥꠀꠞ ꠅꠃꠇ ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ꠈꠣꠟꠤ ꠄꠇꠟꠉꠦ ꠛꠃꠔ ꠡꠝꠄ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠘꠤꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠦ, ꠔꠣꠞꠣ ꠅꠃ ꠙꠣꠠꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠔꠣ ꠙꠣꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX19_14","003_19_14","EXO","19","14","14","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠙꠣꠠꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠟꠣ, ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX19_15","003_19_15","EXO","19","15","15","ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠙꠞꠡꠥ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠅꠅ, ꠄꠞꠝꠣꠎꠦ ꠇꠦꠃ ꠛꠤꠛꠤꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX19_16","003_19_16","EXO","19","16","16","ꠢꠣꠍꠣꠃ ꠢꠃ ꠙꠞꠡꠥ ꠖꠤꠘ ꠀꠁꠟꠦ ꠛꠤꠀꠘꠇꠥ ꠛꠣꠟꠣ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠊꠘ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠈꠥꠛ ꠛꠦꠡꠤ ꠝꠦꠊꠞ ꠒꠣꠇ-ꠎꠤꠟꠇꠣꠘꠤ ꠡꠥꠞꠥ ꠅꠁꠟ। ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠡꠤꠋꠉꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣ ꠉꠦꠟ, ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠣ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX19_17","003_19_17","EXO","19","17","17","ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠇꠦꠝ꠆ꠙ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠟꠣ। ꠔꠣꠞꠣ ꠢꠇꠟ ꠉꠤꠀ ꠙꠣꠠꠞ ꠟꠣꠝꠣꠔ ꠃꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX19_18","003_19_18","EXO","19","18","18","ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠔꠥꠞ ꠙꠣꠠ ꠗꠥꠝꠣꠄ ꠜꠞꠤꠉꠦꠟ, ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣꠄ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠘꠥꠞꠞ ꠍꠥꠞꠔꠦ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠟꠣ। ꠁꠐ-ꠜꠣꠐ꠆ꠐꠣꠞ ꠗꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠗꠥꠝꠣ ꠃꠠꠣ ꠡꠥꠞꠥ ꠅꠁꠟ ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠙꠣꠠ ꠎꠥꠠꠤ ꠛꠦꠎꠥꠁꠔꠣ ꠇꠣꠙ ꠡꠥꠞꠥ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX19_19","003_19_19","EXO","19","19","19","ꠡꠤꠋꠉꠣꠞ ꠀꠅꠀꠎ ꠀꠞꠅ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠛꠣꠎꠤꠟ। ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠟꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄꠅ ꠘꠤꠎꠞ ꠀꠅꠀꠎꠖꠤ ꠝꠥꠍꠣꠞ ꠝꠣꠔꠞ ꠎꠥꠀꠙ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX19_20","003_19_20","EXO","19","20","20","ꠝꠣꠛꠥꠖ ꠘꠤꠎꠦ ꠔꠥꠞ ꠙꠣꠠꠞ ꠝꠣꠕꠣꠔ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠝꠥꠍꠣꠞꠦ ꠒꠣꠇꠤꠟꠣ, ꠔꠦꠃ ꠝꠥꠍꠣ ꠃꠑꠤꠀ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX19_21","003_19_21","EXO","19","21","21","ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠟꠣꠝꠣꠔ ꠎꠣꠅ, ꠉꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠇꠠꠣ ꠇꠞꠤ ꠇꠁꠀ ꠀꠅ, ꠀꠞꠘꠣꠄ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠡꠤꠝꠣꠘꠣ ꠙꠣꠞ ꠅꠁꠀ ꠃꠙꠞꠦ ꠀꠁꠛ꠆ꠛꠣ। ꠀꠁꠟꠦ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠝꠣꠞꠣ ꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX19_22","003_19_22","EXO","19","22","22","ꠀꠞ ꠎꠦ ꠁꠝꠣꠝ ꠅꠇꠟ ꠢꠣꠝꠦꠡꠣ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠘ, ꠀꠍꠟꠦ ꠔꠣꠞꠣꠞ ꠇꠣꠝꠃ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠀ, ꠔꠣꠞꠣꠅ ꠘꠤꠎꠦ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠛꠣ। ꠀꠞꠘꠣꠄ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦꠅ ꠉꠎꠛ ꠓꠣꠟꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX19_23","003_19_23","EXO","19","23","23","ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠣꠞꠣ ꠔ ꠄꠝꠘꠦꠃ ꠔꠥꠞ ꠙꠣꠠꠅ ꠀꠁꠔꠣ ꠘꠣꠄ, ꠀꠙꠘꠦ ꠀꠉꠦꠃ ꠀꠝꠞꠣꠞꠦ ꠇꠠꠣ ꠢꠥꠡꠤꠀꠞꠤ ꠖꠤꠍꠂꠘ। ꠀꠝꠞꠣꠅ ꠙꠣꠠꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠖꠣꠉ ꠖꠤꠀ ꠀꠙꠘꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠇ ꠡꠤꠝꠣꠘꠣ ꠀꠟꠉꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX19_24","003_19_24","EXO","19","24","24","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠔꠥꠝꠤ ꠟꠣꠝꠣꠔ ꠎꠣꠅ। ꠛꠣꠖꠦ ꠔꠥꠝꠤ ꠀꠞ ꠢꠣꠞꠥꠘ ꠖꠥꠁꠅꠎꠘꠦ ꠝꠤꠟꠤꠀ ꠃꠙꠞꠦ ꠀꠁꠅ। ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠇꠥꠘꠥ ꠁꠝꠣꠝ ꠛꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠎꠣꠔꠦ ꠡꠤꠝꠣꠘꠣ ꠍꠣꠠꠤꠀ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠘꠣ ꠀꠁꠘ, ꠀꠁꠟꠦ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔꠤ ꠉꠎꠛ ꠓꠣꠟꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX19_25","003_19_25","EXO","19","25","25","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣ ꠟꠣꠝꠣꠔ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_1","003_20_1","EXO","20","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠚꠞꠝꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX20_2","003_20_2","EXO","20","2","2","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX20_3","003_20_3","EXO","20","3","3","“ꠀꠝꠣꠞ ꠛꠖꠟꠣ ꠔꠥꠝꠞꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣ ꠝꠣꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_4","003_20_4","EXO","20","4","4","“ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ, ꠀꠍꠝꠣꠘ, ꠎꠝꠤꠘ ꠛꠣ ꠙꠣꠘꠤꠞ ꠔꠟꠦ ꠎꠔꠔꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠇꠥꠘꠥꠔꠣꠞ ꠍꠥꠞꠔꠦ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_5","003_20_5","EXO","20","5","5","ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠁꠔꠣꠞ ꠡꠦꠛꠣ-ꠎꠔꠘ ꠇꠞꠤꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠔ ꠟꠣ-ꠡꠞꠤꠇ ꠝꠣꠛꠥꠖ, ꠇꠥꠘꠥ ꠡꠞꠤꠇ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤ ꠘꠣ। ꠢꠥꠘꠅ, ꠀꠝꠣꠞꠦ ꠎꠦꠞꠣ ꠝꠣꠘꠦ ꠘꠣ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠖꠦꠁ, ꠔꠣꠞꠣꠞ ꠔꠤꠘ-ꠌꠣꠁꠞ ꠍꠤꠠꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠡꠣꠎꠣ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("EX20_6","003_20_6","EXO","20","6","6","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠀꠝꠣꠞ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠦ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠅꠀꠞꠤꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠣꠞ ꠅꠛꠤꠞꠣꠝ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠖꠦꠈꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX20_7","003_20_7","EXO","20","7","7","“ꠛꠦꠇꠣꠝꠣ ꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠝꠥꠈꠅ ꠟꠁꠅ ꠘꠣ। ꠇꠦꠃ ꠎꠥꠖꠤ ꠈꠣꠝꠈꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ ꠟꠄ, ꠔꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠝꠣꠞ ꠡꠣꠎꠣ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX20_8","003_20_8","EXO","20","8","8","“ꠁꠀꠖ ꠇꠞꠤꠀ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠖꠤꠘ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX20_9","003_20_9","EXO","20","9","9","ꠢꠣꠙ꠆ꠔꠣꠞ ꠍꠄꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠖꠞꠇꠣꠞꠤ ꠢꠇꠟ ꠇꠣꠝ ꠡꠣꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX20_10","003_20_10","EXO","20","10","10","ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠅꠁꠟ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ, ꠔꠥꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠎꠤꠞꠣꠁꠛꠣꠞ ꠖꠤꠘ। ꠁ ꠖꠤꠘ ꠔꠥꠝꠤ, ꠔꠥꠝꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤꠘ, ꠔꠥꠝꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟ, ꠔꠥꠝꠣꠞ ꠉꠣꠃꠔ ꠛꠣ ꠐꠣꠃꠘꠅ ꠞꠅꠞꠣ ꠝꠥꠍꠣꠚꠤꠞ ꠛꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ, ꠇꠦꠃ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_11","003_20_11","EXO","20","11","11","ꠎꠣꠘ ꠔ, ꠝꠣꠛꠥꠖꠦ ꠍꠄꠖꠤꠘꠦ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ, ꠖꠞꠤꠀ ꠀꠞ ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠢꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠛꠣꠖꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠎꠤꠞꠣꠁꠍꠂꠘ, ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠍꠂꠘ ꠘꠣ। ꠅꠃ ꠖꠤꠘꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠞꠢꠝꠔ ꠖꠤꠀ ꠙꠣꠇ ꠖꠤꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX20_12","003_20_12","EXO","20","12","12","“ꠔꠥꠝꠞꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣ, ꠢꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠛꠣꠠꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX20_13","003_20_13","EXO","20","13","13","“ꠈꠥꠘ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_14","003_20_14","EXO","20","14","14","“ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_15","003_20_15","EXO","20","15","15","“ꠌꠥꠞꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_16","003_20_16","EXO","20","16","16","“ꠇꠦꠃꠞꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_17","003_20_17","EXO","20","17","17","“ꠙꠞꠞ ꠊꠞ-ꠖꠥꠀꠞꠞ ꠛꠣꠄ ꠟꠣꠟꠌ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠞ ꠛꠃ, ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ, ꠉꠞꠥ-ꠉꠣꠗꠣ, ꠛꠣ ꠇꠥꠘꠥ ꠇꠤꠌ꠆ꠍꠥꠞ ꠛꠣꠄ ꠟꠣꠟꠌ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX20_18","003_20_18","EXO","20","18","18","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠦꠛꠟꠣ ꠙꠣꠠ ꠕꠣꠇꠤ ꠝꠦꠊꠞ ꠒꠣꠇ, ꠎꠤꠟꠇꠣꠘꠤ, ꠡꠤꠋꠉꠣꠞ ꠀꠅꠀꠎ, ꠀꠞ ꠗꠥꠝꠣ ꠛꠣꠞꠘꠤꠔ ꠖꠦꠈꠟꠣ, ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠖꠥꠞꠁ ꠕꠣꠇꠤꠃ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠣ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_19","003_20_19","EXO","20","19","19","ꠔꠣꠞꠣ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦꠃ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣ ꠢꠥꠘꠝꠥ; ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠦ ꠔ ꠀꠝꠞꠣ ꠝꠞꠤꠎꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX20_20","003_20_20","EXO","20","20","20","ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠚꠣꠟꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠅ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ ꠢꠣꠝꠣꠄ, ꠒꠞꠣꠁꠀ ꠔꠥꠝꠞꠣ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠞꠅ। ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX20_21","003_20_21","EXO","20","21","21","ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠖꠥꠞꠁ ꠃꠛꠣꠁ ꠞꠁꠟꠣ, ꠀꠞ ꠝꠥꠍꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠣꠎꠤꠞꠣꠞ ꠢꠃ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤꠞ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_22","003_20_22","EXO","20","22","22","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠔ ꠖꠦꠈꠟꠣꠄ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EX20_23","003_20_23","EXO","20","23","23","ꠄꠞꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠀꠝꠣꠞ ꠛꠖꠟꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠖꠦꠛꠔꠣ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠡꠥꠘꠣ ꠛꠣ ꠞꠥꠙꠣꠖꠤꠅ ꠘꠤꠎꠞ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX20_24","003_20_24","EXO","20","24","24","“ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠈꠣꠟꠤ ꠝꠣꠐꠤ ꠖꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠅ। ꠄꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠀꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ꠎꠦꠔꠣ ꠎꠣꠉꠣꠁꠘ꠆ꠔꠅ ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠣꠝ ꠁꠀꠖ ꠇꠞꠣꠁ ꠖꠤꠝꠥ, ꠢꠃ ꠎꠣꠉꠣꠁꠘ꠆ꠔꠅ ꠀꠝꠤ ꠘꠤꠎꠦ ꠀꠎꠤꠞ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX20_25","003_20_25","EXO","20","25","25","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠇꠥꠘꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠘꠤꠔ ꠟꠣꠉꠟꠦ, ꠢꠤ ꠙꠣꠔ꠆ꠔꠞꠉꠥꠁꠘ ꠇꠣꠐꠤꠅ ꠘꠣ। ꠄꠞ ꠃꠙꠞꠦ ꠀꠔꠤꠀꠞ ꠌꠣꠟꠣꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX20_26","003_20_26","EXO","20","26","26","ꠀꠝꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠅꠃꠟꠣ ꠇꠞꠤ ꠛꠣꠘꠣꠁꠅ, ꠎꠣꠔꠦ ꠄꠞ ꠃꠙꠞꠦ ꠃꠑꠔꠦ ꠇꠥꠘꠥ ꠝꠁ ꠛꠣ ꠍꠤꠠꠤ ꠘꠣ ꠟꠣꠉꠦ, ꠝꠁ ꠛꠣ ꠍꠤꠠꠤ ꠛꠣꠄ ꠃꠑꠣꠔ ꠉꠦꠟꠦ ꠇꠤꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠝ ꠖꠦꠈꠣ ꠎꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX21_1","003_21_1","EXO","21","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠝꠣꠞ ꠅꠃ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠅꠇꠟ ꠎꠣꠘꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EX21_2","003_21_2","EXO","21","2","2","“ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠁꠛꠞꠣꠘꠤ ꠛꠦꠐꠣꠞꠦ ꠈꠞꠤꠖ ꠇꠞꠤꠀ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠅ, ꠔꠦ ꠅꠃ ꠉꠥꠟꠣꠝꠦ ꠍꠄ ꠛꠍꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠛ, ꠛꠣꠖꠦ ꠡꠣꠔ ꠛꠍꠞꠞ ꠛꠣꠟꠣ ꠔꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠘꠤꠀ, ꠔꠣꠞꠦ ꠄꠝꠘꠦꠃ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX21_3","003_21_3","EXO","21","3","3","ꠢꠦ ꠎꠥꠖꠤ ꠄꠇꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠄ ꠔꠦ ꠄꠇꠟꠣꠃ ꠎꠣꠁꠛ; ꠀꠞ ꠎꠥꠖꠤ ꠛꠃꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠀꠄ, ꠔꠦ ꠛꠃ ꠟꠁꠀ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_4","003_21_4","EXO","21","4","4","ꠅꠁꠟꠦ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠎꠥꠖꠤ ꠔꠣꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠁ ꠕꠣꠇꠦ, ꠀꠞ ꠔꠣꠞ ꠇꠥꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣ-ꠝꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠘ, ꠔꠣꠁꠟꠦ ꠁ ꠛꠦꠐꠤ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠝꠥꠘꠤꠛꠞ ꠉꠦꠍꠦꠃ ꠞꠁꠛꠣ; ꠢꠦ ꠈꠣꠟꠤ ꠄꠇꠟꠣ ꠀꠎꠣꠖ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_5","003_21_5","EXO","21","5","5","ꠀꠞ ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠎꠥꠖꠤ ꠍꠣꠚ ꠇꠞꠤ ꠇꠄ ꠎꠦꠘ, ꠢꠦ ꠔꠣꠞ ꠝꠥꠘꠤꠛ ꠀꠞ ꠔꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠝꠣꠄꠀꠄ, ꠄꠞꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠎꠣꠁꠔ ꠘꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("EX21_6","003_21_6","EXO","21","6","6","ꠔꠦ ꠁ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠞꠦ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠅꠁꠛ। ꠔꠣꠞꠦ ꠖꠥꠀꠞꠞ ꠇꠙꠣꠐ ꠛꠣ ꠌꠃꠇꠣꠑꠞ ꠟꠉꠦ ꠃꠛꠣ ꠇꠞꠤꠀ ꠝꠥꠘꠤꠛꠦ ꠡꠤꠇ ꠖꠤꠀ ꠔꠣꠞ ꠇꠣꠘꠅ ꠚꠥꠠ ꠇꠞꠛ। ꠔꠦꠃ ꠢꠦ ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠜꠞ ꠝꠥꠘꠤꠛꠞ ꠉꠥꠟꠣꠝꠤꠔ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_7","003_21_7","EXO","21","7","7","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠉꠤꠞꠤꠔ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠘꠤꠎꠞ ꠙꠥꠠꠤꠞꠦ ꠛꠦꠌꠤꠟꠣꠄ, ꠔꠦ ꠉꠥꠟꠣꠝ ꠅꠇꠟ ꠎꠦꠟꠣ ꠍꠄ ꠛꠍꠞ ꠛꠣꠖꠦ ꠝꠥꠘꠤꠛꠞ ꠛꠣꠠꠤ ꠕꠣꠇꠤ ꠄꠝꠘꠦꠃ ꠀꠎꠣꠖ ꠅꠁꠎꠣꠁꠘ, ꠅꠃ ꠙꠥꠠꠤ ꠔ ꠁꠟꠣ ꠀꠎꠣꠖ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX21_8","003_21_8","EXO","21","8","8","ꠔꠣꠁꠞ ꠝꠥꠘꠤꠛ ꠎꠥꠖꠤ ꠔꠣꠁꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠤ ꠘꠣ ꠅꠁꠘ, ꠔꠦ ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠞ ꠛꠖꠟꠣ ꠔꠣꠁꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠔꠣꠁꠞꠦ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠛꠦꠌꠤꠛꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠘꠣꠁ, ꠇꠣꠞꠘ ꠝꠥꠘꠤꠛꠦ ꠔ ꠔꠣꠘ ꠘꠤꠎꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠇꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX21_9","003_21_9","EXO","21","9","9","ꠅꠁꠟꠦ ꠝꠥꠘꠤꠛꠦ ꠎꠥꠖꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠘꠦꠁꠘ, ꠔꠦ ꠔꠣꠁꠞꠦ ꠀꠙꠘ ꠙꠥꠠꠤꠞ ꠟꠣꠈꠣꠘ ꠢꠇꠟ ꠈꠦꠝꠔꠣ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_10","003_21_10","EXO","21","10","10","ꠝꠥꠘꠤꠛꠦ ꠎꠥꠖꠤ ꠅꠃ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠞ ꠛꠣꠖꠦ, ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠇꠁꠘꠣꠞꠦ ꠛꠤꠀ ꠇꠞꠦ, ꠔꠣ-ꠅ ꠁ ꠛꠣꠘ꠆ꠖꠤꠞ ꠈꠥꠞꠣꠇꠤ, ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠀꠞ ꠡꠞꠤꠟꠞ ꠙꠣꠅꠘꠣ ꠢꠇ ꠔꠣꠁꠞꠦ ꠖꠦꠅꠀ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_11","003_21_11","EXO","21","11","11","ꠢꠦ ꠎꠥꠖꠤ ꠅꠃ ꠔꠤꠘꠅ ꠢꠇ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠖꠣꠄ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠁ ꠙꠥꠠꠤꠞꠦ ꠄꠇꠖꠝ ꠛꠤꠘꠣ ꠙꠄꠡꠣꠄ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_12","003_21_12","EXO","21","12","12","“ꠝꠣꠁꠞ ꠈꠣꠁꠀ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠎꠦꠉꠤꠄ ꠔꠣꠞꠦ ꠝꠣꠞꠍꠦ, ꠔꠣꠞꠦꠅ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_13","003_21_13","EXO","21","13","13","ꠅꠁꠟꠦ ꠢꠦ ꠘꠤꠎꠦ ꠎꠥꠖꠤ ꠈꠥꠘ ꠘꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠝꠣꠞꠦ, ꠀꠈꠔꠣ ꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠊꠐꠤꠎꠣꠄ ꠛꠣ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤꠄ ꠁꠔꠣ ꠅꠄ, ꠔꠦ ꠅꠃ ꠈꠥꠘꠤ ꠎꠘ ꠉꠤꠀ ꠅꠟꠣ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠜꠣꠉꠤꠔ ꠙꠣꠞꠛ, ꠎꠦ ꠎꠣꠉꠣꠞ ꠇꠕꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX21_14","003_21_14","EXO","21","14","14","ꠀꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠎꠣꠘꠤꠀ-ꠢꠥꠘꠤꠀ ꠁꠌ꠆ꠍꠣ ꠇꠞꠤ ꠇꠦꠃꠞꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠀ, ꠛꠣꠖꠦ ꠀꠁꠀ ꠀꠝꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠉꠦꠍꠦꠅ ꠀꠡꠞꠄ ꠟꠄ, ꠔꠣ-ꠅ ꠢꠘ ꠕꠣꠇꠤ ꠗꠞꠤꠀ ꠘꠤꠀ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_15","003_21_15","EXO","21","15","15","“ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠀꠙꠘ ꠝꠣ ꠛꠣ ꠛꠣꠚꠞ ꠃꠙꠞꠦ ꠀꠔ ꠔꠥꠟꠦ, ꠔꠣꠞꠦ ꠘꠤꠌꠄ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_16","003_21_16","EXO","21","16","16","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠌꠥꠞꠤ ꠇꠞꠤꠀ ꠀꠘꠤꠀ ꠛꠦꠌꠤꠟꠣꠄ, ꠛꠣ ꠅꠃ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠅꠀ ꠎꠣꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠄ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_17","003_21_17","EXO","21","17","17","“ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠙꠘ ꠝꠣ ꠛꠣ ꠛꠣꠚꠞꠦ ꠉꠣꠟꠤ-ꠉꠣꠟꠣꠎ ꠇꠞꠦ, ꠔꠣꠞꠦꠅ ꠘꠤꠌ꠆ꠌꠄ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_18","003_21_18","EXO","21","18","18","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠇꠣꠁꠎ꠆ꠎꠣꠔ ꠟꠣꠉꠤꠀ ꠎꠥꠖꠤ ꠟꠉꠞ ꠎꠘꠞꠦ ꠑꠥꠡꠤ ꠛꠣ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠝꠣꠞꠦ, ꠁ ꠝꠣꠁꠞ ꠈꠣꠁꠀ ꠅꠃ ꠎꠘ ꠘꠣ ꠝꠞꠟꠦꠅ ꠛꠤꠍꠘꠣꠔ ꠢꠥꠔꠤꠀ ꠙꠠꠘꠅ ꠕꠣꠇꠦ, ");
INSERT INTO syls_vpl VALUES ("EX21_19","003_21_19","EXO","21","19","19","ꠢꠦꠡꠦ ꠃꠑꠤꠀ ꠟꠣꠑꠤ ꠜꠞ ꠖꠤꠀ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠣꠞ ꠎꠞꠥꠞ ꠅꠄ, ꠔꠦ ꠎꠦꠉꠤꠄ ꠔꠣꠞꠦ ꠝꠣꠞꠍꠦ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠅ ꠘꠣ। ꠈꠣꠟꠤ ꠢꠃ ꠎꠘꠞ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠈꠦꠔꠤ ꠀꠞ ꠔꠣꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠖꠣꠅꠀꠁ ꠈꠞꠌ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_20","003_21_20","EXO","21","20","20","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠟꠣꠑꠤ ꠖꠤꠀ ꠝꠣꠞꠦ ꠀꠞ ꠝꠣꠁꠞ ꠈꠣꠁꠀ ꠅꠉꠥ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠄꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_21","003_21_21","EXO","21","21","21","ꠅꠁꠟꠦ ꠝꠣꠁꠞ ꠈꠣꠅꠀꠞ ꠖꠥꠁ-ꠄꠇꠖꠤꠘ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠛꠣꠌꠤꠀ ꠞꠄ, ꠔꠦ ꠇꠥꠘꠥ ꠡꠣꠎꠣ ꠖꠦꠅꠀ ꠟꠣꠉꠔ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠅꠃ ꠉꠥꠟꠣꠝ ꠔ ꠔꠣꠞ ꠘꠤꠎꠞ ꠍꠣꠝꠣꠘꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX21_22","003_21_22","EXO","21","22","22","“ꠝꠣꠞꠣ-ꠝꠣꠞꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠀ ꠎꠥꠖꠤ ꠀꠈꠔꠣ ꠇꠦꠃ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠞꠦ ꠝꠣꠞꠦ ꠀꠞ ꠔꠣꠁꠞ ꠙꠦꠐꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ, ꠅꠁꠟꠦ ꠀꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠘꠣ ꠅꠄ, ꠔꠦ ꠅꠃ ꠛꠦꠐꠤꠞ ꠎꠣꠝꠣꠁꠞ ꠖꠣꠛꠤ ꠀꠞ ꠛꠤꠌꠣꠞꠤ-ꠡꠣꠟꠤꠡꠞ ꠛꠤꠛꠦꠌꠘꠣ ꠝꠣꠚꠤꠇ ꠄꠞꠦ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_23","003_21_23","EXO","21","23","23","ꠅꠁꠟꠦ ꠎꠥꠖꠤ ꠔꠣꠁꠞ ꠀꠞꠅ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠅꠄ, ꠔꠣꠁꠟꠦ ꠄꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠡꠣꠎꠣ ꠖꠤꠛꠣꠄ: ");
INSERT INTO syls_vpl VALUES ("EX21_24","003_21_24","EXO","21","24","24","ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠎꠣꠘ, ꠌꠃꠈꠞ ꠛꠖꠟꠣ ꠌꠃꠈ, ꠖꠣꠔꠞ ꠛꠖꠟꠣ ꠖꠣꠔ, ꠀꠔꠞ ꠛꠖꠟꠣ ꠀꠔ, ꠙꠣꠅꠞ ꠛꠖꠟꠣ ꠙꠣꠅ, ");
INSERT INTO syls_vpl VALUES ("EX21_25","003_21_25","EXO","21","25","25","ꠎꠣꠟꠣꠘꠤꠞ ꠛꠖꠟꠣ ꠎꠣꠟꠣꠘꠤ, ꠎꠈꠝꠞ ꠛꠖꠟꠣ ꠎꠈꠝ, ꠖꠣꠉꠞ ꠛꠖꠟꠣ ꠖꠣꠉ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_26","003_21_26","EXO","21","26","26","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝ ꠛꠣ ꠛꠣꠘ꠆ꠖꠤꠞ ꠇꠥꠘꠥ ꠌꠈꠥꠔ ꠝꠣꠞꠣꠄ ꠌꠃꠈ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠅꠃ ꠌꠃꠈꠞ ꠛꠖꠟꠣ ꠢꠦ ꠁ ꠉꠥꠟꠣꠝꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_27","003_21_27","EXO","21","27","27","ꠎꠥꠖꠤ ꠝꠣꠞꠤꠀ ꠄꠞ ꠖꠣꠔ ꠚꠣꠟꠣꠁ ꠖꠦꠄ, ꠔꠣ-ꠅ ꠄꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠦꠅꠀ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_28","003_21_28","EXO","21","28","28","“ꠇꠥꠘꠥ ꠉꠞꠥꠄ ꠉꠥꠔꠣꠁꠀ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠞꠦ ꠝꠣꠞꠤꠟꠣꠄ, ꠔꠦ ꠉꠞꠥꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠇꠥꠘꠥ ꠡꠣꠎꠣ ꠖꠦꠅꠀ ꠟꠣꠉꠔ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠢꠤ ꠉꠞꠥꠞꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠁꠐꠣꠁꠀ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ, ꠁ ꠉꠞꠥꠞ ꠉꠥꠡ꠆ꠔ ꠇꠦꠃ ꠈꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX21_29","003_21_29","EXO","21","29","29","ꠅꠁꠟꠦ ꠁ ꠉꠞꠥꠞ ꠎꠥꠖꠤ ꠢꠣꠝꠦꠡꠣ ꠅꠃꠟꠣ ꠉꠥꠔꠣꠘꠤꠞ ꠈꠣꠁꠌ꠆ꠍꠔ ꠕꠣꠇꠦ, ꠀꠞ ꠢꠤ ꠝꠣꠟꠤꠇꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠣꠞ ꠛꠣꠖꠦꠅ ꠢꠦ ꠁꠐꠣꠞꠦ ꠀꠐꠇꠣꠄ ꠘꠣ, ꠄꠞꠝꠣꠎꠦ ꠁ ꠉꠞꠥꠄ ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠞꠦ ꠝꠣꠞꠤꠟꠣꠄ, ꠔꠦ ꠁ ꠉꠞꠥꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠔꠣꠞ ꠝꠣꠟꠤꠇꠞꠦꠅ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_30","003_21_30","EXO","21","30","30","ꠎꠥꠖꠤ ꠁ ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍꠦ ꠇꠥꠘꠥ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠌꠣꠅꠀ ꠅꠄ, ꠔꠣꠁꠟꠦ ꠢꠦ ꠅꠃ ꠎꠞꠤꠝꠣꠘꠣ ꠖꠤꠀ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_31","003_21_31","EXO","21","31","31","ꠁ ꠉꠞꠥꠄ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠉꠥꠔꠣꠁꠀ ꠝꠣꠞꠤꠟꠣꠄ, ꠔꠣꠁꠟꠦ ꠄꠞꠟꠣꠉꠤꠅ ꠅꠃ ꠢꠝꠣꠘ ꠘꠤꠅꠝ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_32","003_21_32","EXO","21","32","32","ꠇꠥꠘꠥ ꠉꠞꠥꠄ ꠎꠥꠖꠤ ꠇꠦꠃꠞꠞ ꠉꠥꠟꠣꠝ ꠛꠣ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠉꠥꠔꠣꠁꠀ ꠝꠣꠞꠤꠟꠣꠄ, ꠔꠣꠁꠟꠦ ꠉꠞꠥꠞ ꠝꠣꠟꠤꠇꠦ ꠢꠤ ꠉꠥꠟꠣꠝꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠔꠤꠡ ꠔꠟꠣ ꠙꠞꠤꠝꠣꠘ ꠞꠥꠙꠣ ꠖꠤꠔꠦ ꠅꠁꠛ ꠀꠞ ꠢꠤ ꠉꠞꠥꠞꠦꠅ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX21_33","003_21_33","EXO","21","33","33","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠉꠣꠔꠞ ꠝꠥꠈ ꠈꠥꠟꠤꠀ ꠕꠄ ꠛꠣ ꠉꠣꠔ ꠈꠥꠖꠤꠀ ꠁꠉꠥꠞ ꠝꠥꠈ ꠉꠥꠞꠤꠀ ꠘꠣ ꠕꠄ, ꠀꠞ ꠁ ꠉꠣꠔꠞ ꠜꠤꠔꠞꠦ ꠇꠥꠘꠥ ꠉꠞꠥ ꠛꠣ ꠉꠣꠗꠣ ꠙꠠꠤꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("EX21_34","003_21_34","EXO","21","34","34","ꠔꠣꠁꠟꠦ ꠉꠣꠔꠞ ꠝꠣꠟꠤꠇꠦ ꠙꠡꠥꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠅꠁꠟꠦ ꠁ ꠝꠞꠣ ꠙꠡꠥ ꠙꠣꠁꠛ ꠉꠣꠔꠞ ꠝꠣꠟꠤꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("EX21_35","003_21_35","EXO","21","35","35","“ꠇꠦꠃꠞꠞ ꠉꠞꠥꠄ ꠎꠥꠖꠤ ꠀꠞꠇ ꠎꠘꠞ ꠉꠞꠥꠞꠦ ꠉꠥꠔꠣꠁꠀ ꠝꠣꠞꠤꠟꠣꠄ, ꠔꠦ ꠢꠃ ꠎꠤꠔꠣ ꠉꠞꠥꠞꠦ ꠛꠦꠌꠤꠀ, ꠄꠞ ꠖꠣꠝ ꠀꠞ ꠝꠞꠣ ꠉꠞꠥꠞ ꠖꠣꠝꠅ ꠄꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠢꠝꠣꠘ ꠢꠝꠣꠘ ꠇꠞꠤ ꠛꠣꠐꠤꠀ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX21_36","003_21_36","EXO","21","36","36","ꠅꠁꠟꠦ ꠀꠉ ꠕꠣꠇꠤ ꠎꠥꠖꠤ ꠎꠣꠘꠣ-ꠢꠥꠘꠣ ꠕꠣꠇꠦ ꠎꠦꠘ, ꠁ ꠉꠞꠥꠄ ꠅꠟꠣ ꠉꠥꠔꠣꠄ, ꠀꠞ ꠔꠣꠞ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠞꠦ ꠘꠣ ꠀꠐꠇꠣꠄ, ꠔꠦ ꠉꠞꠥꠞ ꠛꠖꠟꠣ ꠉꠞꠥ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠛꠖꠟꠣ ꠖꠦꠅꠞꠣ ꠎꠘꠦ ꠅꠃ ꠝꠞꠣ ꠉꠞꠥꠐꠣ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_1","003_22_1","EXO","22","1","1","“ꠇꠦꠃ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠞꠥ ꠛꠣ ꠝꠦꠠꠣ-ꠍꠣꠉꠟ ꠌꠥꠞꠤ ꠇꠞꠤꠀ ꠀꠘꠤꠀ ꠎꠥꠖꠤ ꠛꠦꠌꠤꠟꠣꠄ ꠛꠣ ꠎꠛ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠄꠇ ꠉꠞꠥꠞ ꠛꠖꠟꠣ ꠙꠣꠌꠉꠥ, ꠄꠇ ꠝꠦꠠꠣ ꠛꠣ ꠍꠣꠉꠟꠞ ꠛꠖꠟꠣ ꠌꠣꠁꠞꠉꠥ ꠚꠤꠞꠔ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_2","003_22_2","EXO","22","2","4","ꠌꠥꠞꠦ ꠔꠣꠞ ꠌꠥꠞꠤꠞ ꠝꠣꠟꠞ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠔꠣꠞ ꠎꠥꠖꠤ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠛꠣꠞ ꠇꠥꠘꠥ ꠔꠣꠇ꠆ꠇꠔ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠛꠦꠌꠤꠀ ꠄꠞ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠀꠖꠣꠄ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠌꠥꠞꠤ ꠇꠞꠣ ꠉꠞꠥ-ꠉꠣꠗꠣ ꠛꠣ ꠝꠦꠠꠣ-ꠍꠣꠉꠟ ꠎꠥꠖꠤ ꠌꠥꠞꠞ ꠉꠦꠍꠦ ꠎꠤꠔꠣ ꠙꠣꠅꠀ ꠎꠣꠄ, ꠔꠣꠁꠟꠦ ꠢꠦ ꠁꠔꠣ ꠄꠉꠥꠞ ꠛꠖꠟꠣ ꠖꠥꠉꠥ ꠚꠤꠞꠔ ꠖꠤꠔꠦ ꠅꠁꠛ। “ꠇꠥꠘꠥ ꠌꠥꠞꠦ ꠎꠥꠖꠤ ꠌꠥꠞꠤꠔ ꠉꠤꠀ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠛꠣꠞ ꠛꠣꠟꠣ ꠗꠞꠣ ꠈꠣꠁꠟꠣꠄ ꠀꠞ ꠎꠈꠝ ꠅꠁꠀ ꠝꠞꠤꠎꠣꠄ, ꠔꠣꠁꠟꠦ ꠔꠣꠞꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠞꠞꠣ ꠎꠘ ꠖꠣꠄꠁ ꠅꠁꠔ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠡꠥꠞꠥꠎ ꠃꠑꠣꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠁꠟꠣ ꠅꠄ, ꠔꠦ ꠁ ꠈꠥꠘꠞ ꠟꠣꠉꠤ ꠢꠦ ꠖꠣꠄꠁ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_5","003_22_5","EXO","22","5","5","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠘꠤꠎꠞ ꠛꠣꠉꠣꠘꠅ ꠛꠣ ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠞꠣꠈꠣꠔ ꠉꠤꠀ ꠍꠣꠠꠤ ꠖꠦꠄ, ꠀꠞ ꠁꠔꠣꠄ ꠉꠤꠀ ꠝꠣꠘꠡꠞ ꠈꠦꠔꠞ ꠚꠡꠟ ꠈꠣꠁꠟꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠈꠦꠔꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠅꠋꠡ ꠛꠖꠟꠣ ꠖꠤꠀ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_6","003_22_6","EXO","22","6","6","“ꠇꠥꠘꠥ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠀꠉꠥꠁꠘ ꠟꠣꠉꠤꠀ ꠎꠥꠖꠤ ꠎꠥꠙ-ꠎꠋꠉꠟ ꠎꠟꠦ, ꠀꠞ ꠛꠣꠖꠦ ꠅꠃ ꠀꠉꠥꠁꠘ ꠉꠤꠀ ꠇꠦꠃꠞꠞ ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠛꠣꠘ꠆ꠖꠣ ꠝꠥꠁꠐ, ꠐꠦꠇꠤ ꠛꠣ ꠀꠡ꠆ꠔꠣ ꠈꠦꠔ ꠎꠟꠤ ꠎꠣꠄ, ꠔꠦ ꠀꠉꠥꠁꠘ ꠎꠦꠉꠤꠄ ꠎꠣꠟꠣꠁꠍꠤꠟ, ꠢꠦ ꠁꠔꠣꠞ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_7","003_22_7","EXO","22","7","7","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠞꠇ ꠎꠘꠞ ꠉꠦꠍꠦ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠛꠣ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠀꠝꠣꠘꠔ ꠕꠄ, ꠀꠞ ꠀꠝꠣꠘꠔ-ꠖꠣꠞꠞ ꠊꠞ ꠕꠣꠇꠤ ꠁꠔꠣ ꠌꠥꠞꠤ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠅꠃ ꠌꠥꠞ ꠗꠞꠣ ꠙꠠꠟꠦ, ꠌꠥꠞꠦ ꠄꠞ ꠒꠣꠛꠥꠟ ꠚꠤꠞꠔ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_8","003_22_8","EXO","22","8","8","ꠅꠁꠟꠦ ꠌꠥꠞ ꠗꠞꠣ ꠘꠣ ꠙꠠꠟꠦ, ꠢꠤ ꠊꠞꠞ ꠝꠣꠟꠤꠇꠦ ꠘꠤꠎꠦꠃ ꠁꠔꠣ ꠟꠥꠇꠣꠁꠍꠦ ꠘꠤ, ꠅꠈꠣꠘ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX22_9","003_22_9","EXO","22","9","9","“ꠀꠞꠇ ꠎꠘꠞ ꠖꠈꠟꠅ ꠀꠍꠦ, ꠅꠃꠟꠣ ꠇꠥꠘꠥ ꠉꠞꠥ-ꠉꠣꠗꠣ, ꠝꠦꠠꠣ-ꠍꠣꠉꠟ, ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠛꠣ ꠎꠦꠇꠥꠘꠥ ꠀꠞꠣꠁꠟ ꠍꠣꠝꠣꠘꠣ ꠖꠦꠈꠤꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠘꠅ ꠇꠞꠦ ꠁꠐꠣ ꠔꠣꠞ ꠝꠣꠟ, ꠔꠣꠁꠟꠦ ꠁꠐꠣꠞ ꠡꠣꠟꠤꠡꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘ ꠉꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠅꠁꠛ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠛꠣ, ꠢꠦ ꠔꠣꠞ ꠛꠤꠞꠥꠗꠤ ꠎꠘꠞꠦ ꠄꠞ ꠒꠣꠛꠥꠟ ꠚꠤꠞꠔ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_10","003_22_10","EXO","22","10","10","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠉꠞꠥ-ꠉꠣꠗꠣ, ꠍꠣꠉꠟ-ꠝꠦꠠꠣ ꠛꠣ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠙꠡꠥꠞꠦ ꠇꠥꠘꠥ ꠉꠤꠞꠡ꠆ꠔꠞ ꠉꠦꠍꠦ ꠞꠣꠈꠣꠔ ꠖꠦꠄ, ꠀꠞ ꠅꠉꠥ ꠝꠞꠤꠎꠣꠄ, ꠎꠈꠝ ꠅꠁꠎꠣꠄ ꠛꠣ ꠀꠞꠣꠁꠎꠣꠄ, ꠅꠁꠟꠦ ꠄꠞ ꠇꠥꠘꠥ ꠡꠣꠇ꠆ꠇꠤ ꠘꠣ ꠝꠤꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("EX22_11","003_22_11","EXO","22","11","11","ꠔꠦ ꠅꠃ ꠉꠤꠞꠡ꠆ꠔꠦ ꠘꠤꠎꠦꠃ ꠎꠦꠘ ꠁꠔꠣ ꠇꠞꠍꠦ ꠘꠣ, ꠁꠐꠣ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠉꠤꠀ ꠇꠍꠝ ꠇꠞꠤꠀ ꠝꠤꠐ-ꠝꠣꠐ ꠇꠞꠛ। ꠁ ꠙꠡꠥꠞ ꠝꠣꠟꠤꠇꠦꠅ ꠁꠈꠣꠘ ꠝꠣꠘꠔꠦ ꠅꠁꠛ, ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠙꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX22_12","003_22_12","EXO","22","12","12","ꠅꠁꠟꠦ ꠁ ꠉꠤꠞꠡ꠆ꠔꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠥꠖꠤ ꠁꠐꠣ ꠌꠥꠞꠤ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠝꠣꠟꠤꠇꠦ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_13","003_22_13","EXO","22","13","13","ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠗꠞꠤꠀ ꠁꠉꠥꠞꠦ ꠝꠣꠞꠤꠟꠣꠄ, ꠔꠣꠁꠟꠦ ꠄꠞ ꠙꠞꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠅꠉꠥꠞ ꠚꠣꠞꠣ-ꠍꠤꠠꠣ ꠐꠥꠇꠞꠣꠁꠘ ꠀꠘꠤꠀ ꠖꠦꠈꠣꠘꠤ ꠟꠣꠉꠛ। ꠔꠦꠃ ꠄꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠟꠣꠉꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX22_14","003_22_14","EXO","22","14","14","“ꠇꠦꠃꠞꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠈꠥꠎꠤꠀ ꠀꠘꠣ ꠇꠥꠘꠥ ꠙꠡꠥ ꠎꠥꠖꠤ ꠝꠣꠟꠤꠇꠞ ꠀꠚꠞꠈꠦ ꠎꠈꠝ ꠅꠄ ꠛꠣ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠎꠦꠁꠘ ꠈꠥꠎꠤꠀ ꠀꠘꠍꠂꠘ, ꠄꠁꠘ ꠄꠞ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX22_15","003_22_15","EXO","22","15","15","ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇꠞ ꠍꠣꠝꠘꠦꠃ ꠎꠥꠖꠤ ꠅꠃꠟꠣ ꠅꠄ, ꠔꠦ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠟꠣꠉꠔ ꠘꠣꠄ। ꠁ ꠙꠡꠥ ꠎꠥꠖꠤ ꠐꠦꠇꠣ ꠖꠤꠀ ꠜꠣꠠꠣ ꠇꠞꠤ ꠀꠘꠣ ꠅꠄ, ꠔꠦ ꠅꠃ ꠜꠣꠠꠣꠞ ꠐꠦꠇꠣꠃ ꠅꠁꠛ ꠄꠞ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ। ");
INSERT INTO syls_vpl VALUES ("EX22_16","003_22_16","EXO","22","16","16","“ꠛꠤꠀꠞ ꠀꠈꠔ ꠅꠁꠍꠦ ꠘꠣ, ꠅꠃꠟꠣ ꠇꠥꠘꠥ ꠡꠔꠤ ꠙꠥꠠꠤꠞꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠤꠍꠣ ꠝꠣꠔꠤꠀ ꠀꠘꠤꠀ ꠔꠣꠁꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠤꠟꠣꠄ, ꠔꠣꠁꠟꠦ ꠢꠃ ꠛꠦꠐꠣꠄ ꠙꠥꠠꠤꠞ ꠛꠣꠚꠞꠦ ꠎꠞꠤꠝꠣꠘꠣ ꠖꠤꠀ ꠅꠃ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_17","003_22_17","EXO","22","17","17","ꠅꠁꠟꠦ ꠙꠥꠠꠤꠞ ꠛꠣꠚꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠙꠥꠠꠤꠞꠦ ꠁ ꠙꠥꠀꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠖꠤꠔꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠞꠣꠎꠤ ꠘꠣ ꠅꠄ, ꠔꠣ-ꠅ ꠁ ꠎꠞꠤꠝꠣꠘꠣ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_18","003_22_18","EXO","22","18","18","“ꠇꠥꠘꠥ ꠎꠣꠖꠥꠉꠤꠞ ꠛꠦꠐꠤꠞꠦ ꠔꠥꠝꠤ ꠎꠤꠔꠣ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX22_19","003_22_19","EXO","22","19","19","“ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠟꠉꠦ ꠇꠦꠃ ꠎꠤꠘꠣ ꠇꠞꠟꠦ, ꠔꠣꠞꠦ ꠘꠤꠌꠄ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_20","003_22_20","EXO","22","20","20","“ꠈꠣꠟꠤ ꠝꠣꠛꠥꠖ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠞ ꠘꠣꠝꠦ ꠎꠥꠖꠤ ꠇꠦꠃ ꠇꠥꠘꠥ ꠛꠟꠤ-ꠙꠡꠣꠖ ꠖꠦꠄ, ꠔꠦ ꠔꠣꠞꠦꠅ ꠡꠦꠡ ꠇꠞꠤꠟꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX22_21","003_22_21","EXO","22","21","21","“ꠇꠥꠘꠥ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠛꠣꠖ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠅ ꠄꠇ ꠡꠝꠄ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠝꠥꠍꠣꠚꠤꠞ ꠀꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX22_22","003_22_22","EXO","22","22","22","“ꠇꠥꠘꠥ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠞꠦ ꠛꠣ ꠇꠥꠘꠥ ꠄꠔꠤꠝ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠖꠥꠈ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX22_23","003_22_23","EXO","22","23","23","ꠔꠣꠞꠣꠞꠦ ꠖꠥꠈ ꠖꠤꠟꠦ ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠇꠣꠘ꠆ꠖꠦ, ꠔꠦ ꠁ ꠇꠣꠘ꠆ꠖꠘ ꠘꠤꠌꠄ ꠀꠝꠤ ꠇꠛꠥꠟ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX22_24","003_22_24","EXO","22","24","24","ꠄꠔꠦ ꠀꠝꠣꠞ ꠉꠥꠍꠣ ꠅꠁꠛ ꠀꠉꠥꠁꠘ ꠛꠞꠣꠛꠞ। ꠔꠥꠝꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠙꠠꠤꠀ ꠝꠞꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠛꠃꠅ ꠠꠣꠠꠤ ꠅꠁꠛ, ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠅ ꠅꠃꠟꠣ ꠄꠔꠤꠝ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX22_25","003_22_25","EXO","22","25","25","“ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠇꠥꠘꠥ ꠅꠜꠣꠛꠤ ꠛꠘ꠆ꠖꠣꠞꠦ ꠇꠞꠎ ꠖꠦꠅ, ꠔꠣꠁꠟꠦ ꠡꠥꠖꠈꠥꠞꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠥꠖ ꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX22_26","003_22_26","EXO","22","26","26","ꠇꠦꠃꠞꠞ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞ ꠛꠘ꠆ꠖꠇ ꠞꠣꠈꠟꠦ, ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣꠞ ꠀꠉꠦꠃ ꠔꠣꠞ ꠌꠣꠖ꠆ꠖꠞ ꠚꠤꠞꠔ ꠖꠤꠟꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX22_27","003_22_27","EXO","22","27","27","ꠇꠣꠞꠘ ꠃꠠꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠅꠐꠣꠃ ꠔꠣꠞ ꠄꠇꠝꠣꠔ꠆ꠞ ꠡꠝ꠆ꠛꠟ। ꠁꠈꠣꠘ ꠘꠤꠟꠦꠉꠤ ꠢꠦ ꠇꠤꠔꠣ ꠃꠠꠤꠀ ꠢꠥꠔꠤꠛ? ꠢꠥꠘꠅ, ꠢꠦ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠣꠘ꠆ꠖꠦ, ꠔꠦ ꠀꠝꠤ ꠔ ꠞꠢꠝꠣꠘꠥꠞ ꠞꠢꠤꠝ, ꠀꠝꠤ ꠔꠣꠞ ꠇꠣꠘ꠆ꠖꠘ ꠢꠥꠘꠝꠥꠃ। ");
INSERT INTO syls_vpl VALUES ("EX22_28","003_22_28","EXO","22","28","28","“ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠔꠤꠅ ꠘꠣ, ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠛꠤꠌꠣꠞꠇ-ꠡꠣꠟꠤꠡꠞꠦꠅ ꠛꠖ꠆ꠖꠥꠀ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX22_29","003_22_29","EXO","22","29","29","“ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠡꠟ ꠛꠣ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔꠞ ꠎꠦ ꠛꠣꠐ ꠀꠝꠣꠞꠦ ꠖꠤꠛꠣꠞ ꠇꠕꠣ, ꠀꠝꠣꠞ ꠁ ꠛꠣꠐ ꠖꠤꠔꠦ ꠖꠦꠞꠤ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠛꠠ ꠙꠥꠀꠂꠘ ꠀꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX22_30","003_22_30","EXO","22","30","30","ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠛꠣꠍꠥꠞ ꠀꠞ ꠍꠣꠉꠟ-ꠝꠦꠠꠣꠞ ꠟꠣꠉꠤꠅ ꠅꠃ ꠄꠇ ꠡꠝꠣꠘ ꠢꠥꠇꠥꠝ। ꠁꠔꠣꠞ ꠢꠇꠟ ꠛꠠ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠡꠣꠔꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠣꠞ ꠝꠣʼꠞ ꠉꠦꠍꠦ ꠞꠁꠛꠣ, ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠀꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX22_31","003_22_31","EXO","22","31","31","“ꠔꠥꠝꠞꠣꠃ ꠅꠁꠛꠣꠄ ꠀꠝꠣꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠛꠘ꠆ꠖꠣ। ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠝꠣꠞꠤꠀ ꠚꠣꠟꠣꠁꠍꠦ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ; ꠁꠔꠣ ꠇꠥꠇꠥꠞꠞꠦ ꠈꠣꠅꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX23_1","003_23_1","EXO","23","1","1","“ꠔꠥꠝꠞꠣ ꠝꠤꠍꠣ ꠇꠥꠘꠥ ꠛꠖꠘꠣꠝ ꠛꠣꠞ ꠇꠞꠤꠅ ꠘꠣ। ꠙꠇ꠆ꠇꠙꠣꠔꠤ ꠇꠞꠤ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠀ ꠇꠥꠘꠥ ꠈꠛꠤꠍ ꠝꠣꠘꠡꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_2","003_23_2","EXO","23","2","2","ꠡꠝꠣꠎꠞ ꠖꠡꠎꠘꠦ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠦꠞ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠤꠅ ꠅꠃꠟꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠇꠥꠘꠥ ꠝꠣꠝꠟꠣ-ꠝꠇꠖ꠆ꠖꠝꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠅꠀꠔ ꠉꠤꠀ, ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠖꠟꠞ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠣꠝ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_3","003_23_3","EXO","23","3","3","ꠀꠞ ꠇꠥꠘꠥ ꠉꠞꠤꠛꠞ ꠛꠤꠌꠣꠞꠅ ꠉꠤꠀ, ꠢꠦ ꠉꠞꠤꠛ ꠉꠔꠤꠇꠦꠃ ꠔꠣꠞ ꠙꠇ꠆ꠇ ꠟꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_4","003_23_4","EXO","23","4","4","“ꠔꠥꠝꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠇꠥꠘꠥ ꠉꠞꠥ-ꠉꠣꠗꠣꠞꠦ ꠛꠦ-ꠙꠕꠦ ꠎꠣꠅꠀꠔ ꠖꠦꠈꠟꠦ, ꠁꠐꠣ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠤꠀ ꠔꠣꠞ ꠉꠦꠍꠦ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX23_5","003_23_5","EXO","23","5","5","ꠔꠥꠝꠣꠞꠦ ꠁꠋꠡꠣ ꠇꠞꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠣꠗꠣꠞꠦ ꠜꠣꠞꠞ ꠔꠟꠦ ꠙꠠꠤꠉꠦꠍꠦ ꠖꠦꠈꠟꠦ, ꠔꠣꠞꠦ ꠁꠟꠣ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠁꠅ ꠘꠣ। ꠅꠃ ꠉꠣꠗꠣꠞꠦ ꠔꠥꠟꠣꠔ ꠔꠥꠝꠤ ꠅꠛꠡ꠆ꠡꠁ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_6","003_23_6","EXO","23","6","6","“ꠇꠥꠘꠥ ꠉꠞꠤꠛꠞ ꠝꠣꠝꠟꠣ-ꠝꠇꠖ꠆ꠖꠝꠣꠔ ꠅꠁꠘ꠆ꠘꠣꠄ ꠡꠣꠟꠤꠡꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_7","003_23_7","EXO","23","7","7","ꠢꠣꠎꠣꠁꠟ ꠝꠤꠍꠣ ꠝꠣꠝꠟꠣ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠁꠅ। ꠇꠥꠘꠥ ꠛꠦ-ꠇꠍꠥꠞ ꠛꠣ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠝꠣꠘꠡꠞꠦ ꠝꠃꠔꠞ ꠡꠣꠎꠣ ꠖꠤꠅ ꠘꠣ। ꠎꠦꠉꠤꠄ ꠁꠟꠣ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠛ, ꠔꠣꠞꠦ ꠀꠝꠤ ꠍꠣꠠꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_8","003_23_8","EXO","23","8","8","ꠊꠥꠡ ꠈꠣꠁꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠊꠥꠡꠦ ꠌꠃꠈ ꠀꠟꠣ ꠝꠣꠘꠡꠞꠦꠅ ꠀꠘ꠆ꠖꠣ ꠇꠞꠤꠟꠣꠄ। ꠊꠥꠡꠦ ꠜꠣꠟꠣ ꠝꠣꠘꠡꠞ ꠝꠣꠔꠞ ꠝꠣꠎꠦꠅ ꠙꠦꠌ ꠟꠣꠉꠣꠁ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_9","003_23_9","EXO","23","9","9","“ꠇꠥꠘꠥ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠝꠥꠍꠣꠚꠤꠞꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠅ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠝꠥꠍꠣꠚꠤꠞ ꠀꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_10","003_23_10","EXO","23","10","10","“ꠔꠥꠝꠞꠣ ꠄꠇꠟꠣꠉꠣꠞꠦ ꠍꠄ ꠛꠞꠍ ꠎꠝꠤꠘꠅ ꠈꠦꠔ ꠇꠞꠤꠅ ꠀꠞ ꠚꠡꠟ ꠇꠣꠐꠤꠅ, ");
INSERT INTO syls_vpl VALUES ("EX23_11","003_23_11","EXO","23","11","11","ꠛꠣꠖꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠛꠞꠍꠅ ꠎꠝꠤꠘꠅ ꠇꠥꠘꠥ ꠈꠦꠔ ꠘꠣ ꠇꠞꠤꠀ ꠙꠔꠤꠔ ꠞꠣꠈꠤꠅ, ꠎꠝꠤꠘꠞꠦ ꠀꠞꠣꠝ ꠖꠤꠅ। ꠄꠔꠦ ꠎꠝꠤꠘꠅ ꠄꠝꠘꠦꠃ ꠎꠦꠔꠣ ꠚꠟꠤꠛ, ꠅꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠞꠤꠛ ꠅꠇꠟꠦ ꠈꠣꠁꠀ ꠛꠣꠌꠤꠛꠣ। ꠔꠣꠞꠣ ꠘꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠙꠠꠤ ꠞꠁꠛ, ꠁꠔꠣ ꠎꠋꠟꠤ ꠙꠡꠥ-ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠈꠣꠁꠛꠣ। ꠔꠥꠝꠞꠣꠞ ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘ ꠛꠣ ꠎꠄꠔꠥꠘ ꠛꠣꠉꠣꠘꠞ ꠟꠣꠉꠤꠅ ꠅꠃ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX23_12","003_23_12","EXO","23","12","12","“ꠔꠥꠝꠞꠣ ꠢꠣꠙ꠆ꠔꠣꠔ ꠍꠄ ꠖꠤꠘ ꠇꠣꠝ ꠇꠞꠤꠅ, ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠔ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ, ꠁꠖꠤꠘ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠉꠣꠗꠣꠄ ꠎꠤꠞꠣꠁꠛꠣ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠠꠤꠔ ꠎꠘꠝꠤꠍꠦ ꠁ ꠉꠥꠟꠣꠝ ꠀꠞ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠇꠟꠞ ꠎꠣꠘꠦꠅ ꠀꠞꠣꠝ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX23_13","003_23_13","EXO","23","13","13","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣꠝ, ꠁꠔꠣ ꠈꠥꠛ ꠢꠥꠡꠤꠀꠞ ꠅꠁꠀ ꠀꠝꠟ ꠇꠞꠤꠅ। ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝ ꠝꠥꠈꠅ ꠟꠁꠅ ꠘꠣ, ꠁꠔꠣꠞ ꠘꠣꠝ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈꠅ ꠘꠣ ꠢꠥꠘꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_14","003_23_14","EXO","23","14","14","“ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠛꠞꠍ ꠔꠤꠘꠛꠣꠞ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX23_15","003_23_15","EXO","23","15","15","ꠙꠄꠟꠣ, ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠀꠝꠤ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠤ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠛꠤꠛ ꠌꠣꠘ꠆ꠖꠞ ꠡꠣꠔꠖꠤꠘ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠅ, ꠇꠣꠞꠘ ꠅꠃ ꠌꠣꠘ꠆ꠖꠅ ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠟꠣꠄ। ꠁꠖꠞ ꠡꠝꠄ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠍꠣꠠꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠦꠃ ꠎꠣꠘꠥ ꠈꠣꠟꠤ ꠀꠔꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠘꠣ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_16","003_23_16","EXO","23","16","16","ꠖꠥꠍꠞꠣ, ꠔꠥꠝꠞꠣ ꠚꠡꠟ ꠖꠣꠅꠀꠞ ꠁꠖ ꠝꠣꠘꠤꠅ। ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠞꠥꠁꠍ, ꠁꠔꠣ ꠖꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠙꠄꠟꠣ ꠚꠡꠟ ꠖꠤꠀꠃ ꠁꠖ ꠇꠞꠤꠅ। ꠔꠤꠍꠞꠣ ꠁꠖ, ꠛꠍꠞꠞ ꠢꠦꠡ ꠌꠣꠘ꠆ꠖꠅ ꠛꠣꠉꠣꠘꠞ ꠙꠣꠇꠘꠣ ꠚꠟ ꠛꠣꠠꠤꠔ ꠀꠘꠣꠞ ꠛꠣꠖꠦ ꠒꠦꠞꠣ-ꠊꠞꠞ ꠁꠖ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX23_17","003_23_17","EXO","23","17","17","ꠅꠃ ꠔꠤꠘꠅ ꠁꠖꠞ ꠡꠝꠄ, ꠛꠍꠞꠅ ꠔꠤꠘꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ ꠀꠁꠀ ꠢꠎ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠝꠣꠟꠤꠇꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX23_18","003_23_18","EXO","23","18","18","“ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅ, ꠅꠃ ꠡꠝꠄ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠞꠥꠐꠤ ꠁꠔꠣꠞ ꠟꠉꠦ ꠙꠥꠞꠣꠁꠀ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠅ ꠘꠣ। ꠁꠖꠞ ꠡꠝꠄ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠎꠦꠔꠣ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ, ꠁꠔꠣꠞ ꠌꠞ꠆ꠛꠤꠀꠟꠣ ꠐꠥꠇꠞꠣꠁꠘ ꠛꠤꠀꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_19","003_23_19","EXO","23","19","19","ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠚꠡꠟ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠅ ꠀꠘꠤꠅ। “ꠀꠞ ꠢꠥꠘꠅ, ꠇꠥꠘꠥ ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠉꠥꠡ꠆ꠔ ꠔꠣꠞ ꠝꠣʼꠞ ꠖꠥꠗ ꠖꠤꠀ ꠞꠣꠘ꠆ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_20","003_23_20","EXO","23","20","20","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦ ꠎꠣꠉꠣ ꠎꠥꠁꠔ ꠇꠞꠤ ꠞꠣꠈꠍꠤ, ꠢꠘꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠦꠚꠣꠎꠔꠦ ꠙꠃꠍꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠙꠣꠑꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX23_21","003_23_21","EXO","23","21","21","ꠔꠥꠝꠞꠣ ꠄꠘ ꠇꠕꠣ ꠝꠘ ꠖꠤꠀ ꠢꠥꠘꠤꠅ ꠀꠞ ꠝꠣꠘꠤꠅ, ꠄꠘ ꠟꠉꠦ ꠔ ꠀꠝꠤꠅ ꠀꠍꠤ। ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠄꠘ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠣꠁꠅ ꠘꠣ। ꠀꠞꠘꠣꠄ ꠄꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠅꠙꠞꠣꠗ ꠝꠣꠚ ꠇꠞꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_22","003_23_22","EXO","23","22","22","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠄꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠅ, ꠀꠞ ꠀꠝꠤ ꠎꠦꠟꠣ ꠇꠁꠍꠤ ꠅꠃꠟꠣ ꠌꠟꠅ, ꠔꠣꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠟꠉꠦ ꠀꠝꠤ ꠖꠥꠡꠝꠘꠤ ꠇꠞꠝꠥ, ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠟꠣꠉꠛ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠟꠣꠉꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX23_23","003_23_23","EXO","23","23","23","ꠀꠝꠥꠞꠤ, ꠢꠤꠐ꠆ꠐꠤ, ꠚꠣꠞꠤꠎꠤ, ꠇꠦꠘꠣꠘꠤ, ꠢꠤꠛ꠆ꠛꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠀꠝꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠀ ꠢꠣꠞꠣꠁꠛꠣ। ꠀꠝꠤ ꠔꠣꠞꠣ ꠢꠇꠟꠐꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX23_24","003_23_24","EXO","23","24","24","ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠖꠦꠛꠔꠣꠞꠦ ꠙꠥꠎꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠈꠦꠎꠝꠔꠅ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠇꠞꠂꠘ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠝꠥꠞ꠆ꠔꠤꠘ ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠥꠎꠣꠞ ꠝꠘ꠆ꠒꠙ ꠅꠇꠟ ꠜꠣꠋꠉꠤꠀ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠤꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX23_25","003_23_25","EXO","23","25","25","ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ, ꠝꠣꠘꠤ ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠞꠤꠎꠦꠇꠞ ꠝꠣꠎꠦ ꠞꠢꠝꠔ ꠖꠤꠝꠥ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠖꠥꠞ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX23_26","003_23_26","EXO","23","26","26","ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠞ ꠙꠦꠐꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠘꠡ꠆ꠐ ꠅꠁꠔ ꠘꠣꠄ, ꠇꠦꠃ ꠀꠐꠈꠥꠞꠣ ꠞꠁꠔ ꠘꠣꠄ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠢꠣꠄꠀꠔꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠣꠌꠣꠁꠀ ꠞꠣꠈꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX23_27","003_23_27","EXO","23","27","27","ꠔꠥꠝꠞꠣ ꠎꠔ ꠎꠣꠔꠤꠞ ꠇꠣꠍꠣꠔ ꠎꠣꠁꠛꠣꠄ, ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠀꠉ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠒꠞ-ꠈꠚ ꠙꠄꠖꠣ ꠇꠞꠝꠥ, ꠔꠣꠞꠣꠞꠦ ꠛꠦꠖꠤꠡꠣ ꠛꠣꠘꠣꠁꠟꠤꠝꠥ। ꠔꠥꠝꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠖꠥꠡꠝꠘ ꠈꠞꠦꠖꠤ ꠜꠣꠉꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_28","003_23_28","EXO","23","28","28","ꠢꠤꠛ꠆ꠛꠤ, ꠇꠦꠘꠣꠘꠤ ꠀꠞ ꠢꠤꠐ꠆ꠐꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠣ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠇꠞꠤ ꠜꠤꠋꠉꠥꠟꠞ ꠙꠣꠟ ꠙꠣꠑꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX23_29","003_23_29","EXO","23","29","29","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠞꠦ ꠄꠇꠁ ꠛꠍꠞꠞ ꠜꠤꠔꠞꠦ ꠈꠦꠖꠣꠁꠔꠣꠝ ꠘꠣꠄ, ꠀꠞꠘꠣꠄ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠙꠔꠤꠔ ꠞꠁꠀ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠜꠞꠤꠎꠤꠛꠣ, ꠛꠣꠖꠦ ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠔꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_30","003_23_30","EXO","23","30","30","ꠀꠝꠤ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠝꠥ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠥꠡ ꠛꠣꠠꠤꠀ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠀꠛꠣꠖ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_31","003_23_31","EXO","23","31","31","ꠀꠝꠤ ꠘꠤꠟ ꠖꠞꠤꠀ ꠕꠣꠇꠤ ꠚꠤꠟꠤꠡ꠆ꠔꠤꠘꠤ ꠖꠦꠡꠞ ꠡꠣꠉꠞ, ꠝꠣꠘꠤ ꠜꠥꠝꠗꠤꠅ ꠡꠣꠉꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠞ ꠖꠃꠇꠘꠞ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠚꠥꠞꠣꠔ ꠉꠣꠋ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣ ꠉꠣꠠꠝꠥ। ꠁ ꠖꠦꠡꠅ ꠎꠦꠞꠣ ꠛꠡꠔ ꠇꠞꠦꠞ ꠔꠣꠞꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠝꠥ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠁ ꠖꠦꠡ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX23_32","003_23_32","EXO","23","32","32","ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠣ ꠔꠣꠞꠣꠞ ꠖꠦꠛꠔꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX23_33","003_23_33","EXO","23","33","33","ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠞꠁꠛꠣꠞ ꠖꠤꠅ ꠘꠣ। ꠀꠞꠘꠣꠄ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠤꠀ ꠘꠤꠛꠉꠤ। ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠔꠣꠞꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠅ, ꠔꠣꠁꠟꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠔꠥꠝꠞꠣꠅ ꠔꠣꠞꠣꠞ ꠚꠣꠘ꠆ꠖꠅ ꠢꠣꠝꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX24_1","003_24_1","EXO","24","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠞ ꠢꠣꠞꠥꠘ, ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ ꠘꠣꠖꠣꠛ ꠀꠞ ꠀꠛꠤꠢꠥ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠃꠑꠤꠀ ꠀꠅ। ꠀꠁꠛꠣꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣ ꠖꠥꠞꠁ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX24_2","003_24_2","EXO","24","2","2","ꠅꠁꠟꠦ ꠈꠣꠟꠤ ꠔꠥꠝꠤ ꠄꠇꠟꠣ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠃꠙꠞꠦ ꠀꠁꠛꠣꠄ, ꠀꠞ ꠇꠦꠃ ꠘꠣꠄ। ꠄꠞꠣꠞ ꠟꠉꠦ ꠀꠞ ꠇꠥꠘꠥ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠘꠥ ꠘꠣ ꠃꠑꠦ।” ");
INSERT INTO syls_vpl VALUES ("EX24_3","003_24_3","EXO","24","3","3","ꠝꠥꠍꠣꠄ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠢꠇ꠆ꠇꠟ ꠇꠣꠟꠣꠝ ꠀꠞ ꠀꠁꠘ-ꠇꠣꠘꠥꠘ ꠢꠥꠘꠣꠁꠟꠣ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠄꠇꠟꠉꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠎꠔꠔꠣ ꠛꠣꠔꠣꠁꠍꠂꠘ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠀꠝꠞꠣ ꠝꠣꠘꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX24_4","003_24_4","EXO","24","4","4","ꠝꠣꠛꠥꠖꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠇꠟ ꠇꠣꠟꠣꠝ ꠝꠥꠍꠣꠄ ꠟꠦꠈꠤꠀ ꠕꠁꠟꠣ। ꠛꠣꠖꠞ ꠖꠤꠘ ꠚꠎꠞꠦ ꠃꠑꠤꠀ ꠙꠣꠠꠞ ꠟꠣꠝꠣꠔ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠉꠥꠡ꠆ꠐꠤꠞꠦ ꠁꠀꠖ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞꠅꠉꠥ ꠈꠥꠐꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX24_5","003_24_5","EXO","24","5","5","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠥꠀꠘ ꠅꠇꠟꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ ꠀꠞ ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠛꠃꠔ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ, ꠀꠞ ꠛꠃꠔ ꠛꠤꠍꠣꠟ ꠎꠛ ꠇꠞꠤꠀ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX24_6","003_24_6","EXO","24","6","6","ꠝꠥꠍꠣꠄ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃꠞ ꠅꠞ꠆ꠗꠦꠇ ꠘꠤꠀ ꠇꠄꠐꠣ ꠛꠣꠐꠤꠔ ꠕꠁꠟꠣ, ꠀꠞ ꠛꠣꠇꠤ ꠅꠞ꠆ꠗꠦꠇ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠍꠤꠐꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX24_7","003_24_7","EXO","24","7","7","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠟꠦꠈꠣ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠤ ꠝꠣꠘꠡꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ। ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ ꠢꠥꠘꠝꠥ, ꠔꠣꠁꠘ ꠎꠔꠔꠣ ꠇꠁꠍꠂꠘ ꠢꠇꠟꠔꠣ ꠝꠣꠘꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX24_8","003_24_8","EXO","24","8","8","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣꠄ ꠟꠃ ꠟꠁꠀ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠍꠤꠐꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁ ꠟꠃ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠁ ꠝꠤꠟꠘꠞ ꠢꠃ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠟꠃ, ꠎꠦ ꠃꠍꠤꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠢꠇꠟ ꠡꠞ꠆ꠔ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX24_9","003_24_9","EXO","24","9","9","ꠔꠦꠃ ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ, ꠘꠣꠖꠣꠛ, ꠀꠛꠤꠢꠥ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX24_10","003_24_10","EXO","24","10","10","ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠖꠤꠖꠣꠞ ꠖꠦꠈꠟꠣ। ꠔꠣꠞꠣ ꠖꠦꠈꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠅ ꠝꠥꠛꠣꠞꠇꠞ ꠔꠟꠦ ꠀꠍꠦ, ꠌꠇꠌꠇꠣ ꠟꠤꠟ ꠝꠘꠤ ꠙꠣꠔ꠆ꠔꠞꠞ ꠔꠂꠀꠞꠤ ꠍꠣꠔꠞ ꠟꠣꠈꠣꠘ, ꠀꠍꠝꠣꠘꠞ ꠘꠝꠥꠘꠣꠄ ꠍꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("EX24_11","003_24_11","EXO","24","11","11","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠀꠟ꠆ꠟꠣꠞꠦ ꠖꠦꠈꠟꠦꠅ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠔ ꠔꠥꠟꠟꠣ ꠘꠣ। ꠔꠣꠞꠣ ꠔꠣꠘ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠟꠣ ꠀꠞ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX24_12","003_24_12","EXO","24","12","12","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠅꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠅ, ꠀꠁꠀ ꠇꠄꠖꠤꠘ ꠞꠅ। ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠎꠦ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠟꠦꠈꠍꠤ, ꠅꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX24_13","003_24_13","EXO","24","13","13","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠈꠣꠖꠤꠝ ꠁꠃꠍꠣꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠙꠣꠠꠅ ꠃꠑꠟꠣ, ꠀꠞ ꠝꠥꠍꠣ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠠꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX24_14","003_24_14","EXO","24","14","14","ꠔꠣꠁꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠀ ꠉꠦꠟꠣ, “ꠀꠝꠞꠣ ꠚꠤꠞꠔ ꠀꠁꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠙꠘꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠘꠅ ꠛꠣꠞ ꠌꠣꠁꠛꠣ। ꠢꠣꠞꠥꠘ ꠀꠞ ꠢꠥꠞ ꠀꠙꠘꠣꠞꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠍꠂꠘ, ꠇꠥꠘꠥ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠟꠣꠉꠟꠦ ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX24_15","003_24_15","EXO","24","15","15","ꠝꠥꠍꠣ ꠙꠣꠠꠅ ꠃꠑꠔꠦꠃ ꠀꠡ꠆ꠔꠣ ꠙꠣꠠ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤꠄ ꠉꠥꠞꠤꠉꠦꠟ, ");
INSERT INTO syls_vpl VALUES ("EX24_16","003_24_16","EXO","24","16","16","ꠀꠞ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠥꠞꠞ ꠔꠎꠟ꠆ꠟꠤ ꠎꠣꠁꠞ ꠅꠁꠟ। ꠍꠄ ꠖꠤꠘ ꠀꠡ꠆ꠔꠣ ꠙꠣꠠ ꠇꠣꠟꠘꠤꠄ ꠉꠥꠞꠣ ꠞꠁꠟ। ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠅꠃ ꠇꠣꠟꠘꠤ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠒꠣꠇꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX24_17","003_24_17","EXO","24","17","17","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠥꠞꠞ ꠔꠎꠟ꠆ꠟꠤ ꠖꠦꠈꠟꠣ, ꠔꠣꠞꠣ ꠖꠦꠈꠟꠣ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠎꠟꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("EX24_18","003_24_18","EXO","24","18","18","ꠙꠣꠠ ꠛꠣꠁꠀ ꠃꠑꠤ ꠃꠑꠤ ꠝꠥꠍꠣ ꠢꠃ ꠇꠣꠟꠘꠤꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁ ꠉꠦꠟꠣ। ꠔꠣꠁꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ ꠢꠃ ꠙꠣꠠꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX25_1","003_25_1","EXO","25","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX25_2","003_25_2","EXO","25","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠃꠇ। ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠎꠦꠔꠣ ꠖꠣꠘ ꠇꠞꠛꠣ, ꠅꠔꠣ ꠔꠥꠝꠤ ꠡꠝꠎꠤꠀ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_3","003_25_3","EXO","25","3","3","ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠟ ꠡꠝꠎꠤꠅ: ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠙꠤꠔꠟ; ");
INSERT INTO syls_vpl VALUES ("EX25_4","003_25_4","EXO","25","4","4","ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠞꠋꠉꠞ ꠡꠥꠔꠣ; ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠀꠞ ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣ; ");
INSERT INTO syls_vpl VALUES ("EX25_5","003_25_5","EXO","25","5","5","ꠟꠣꠟ ꠞꠋ ꠟꠣꠉꠣꠁꠟ ꠝꠦꠠꠣꠞ ꠌꠣꠝꠠꠣ, ꠖꠞꠤꠀ ꠚꠥʼ ꠝꠣꠍꠞ ꠌꠣꠝꠠꠣ; ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤ; ");
INSERT INTO syls_vpl VALUES ("EX25_6","003_25_6","EXO","25","6","6","ꠌꠦꠞꠣꠉ ꠅꠇꠟ ꠎꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ; ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠔꠦꠟꠞ ꠝꠡꠟꠣ ꠀꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠛꠣꠘꠣꠘꠤꠞ ꠝꠡꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("EX25_7","003_25_7","EXO","25","7","7","ꠁꠝꠣꠝꠞ ꠟꠦꠛꠣꠍꠞ ꠄꠚꠞꠘ ꠀꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠔ ꠟꠣꠉꠣꠘꠤꠞ ꠀꠇꠤꠇ ꠝꠘꠤ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟ ꠎꠣꠔꠞ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("EX25_8","003_25_8","EXO","25","8","8","“ꠀꠝꠣꠞ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞꠦꠖꠤ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠄꠇꠈꠣꠘ ꠎꠣꠉꠣ ꠔꠂꠀꠞ ꠇꠞꠣꠁꠛꠣꠄ। ꠔꠦꠃ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX25_9","003_25_9","EXO","25","9","9","ꠀꠝꠣꠞ ꠞꠅꠀꠞ ꠊꠞ ꠀꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠘꠝꠥꠘꠣ ꠖꠦꠈꠣꠁꠝꠥ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠢꠇꠟꠔꠣ ꠔꠤꠀꠞ ꠇꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_10","003_25_10","EXO","25","10","10","“ꠔꠣꠞꠣ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤ ꠖꠤꠀ ꠄꠉꠥ ꠡꠘ꠆ꠖꠥꠇ ꠛꠣꠘꠣꠁꠛꠣ। ꠁꠐꠣ ꠟꠣꠝ꠆ꠛꠣꠄ ꠀꠠꠣꠁ ꠀꠔ, ꠖꠦꠠ ꠀꠔ ꠙꠣꠡ ꠀꠞ ꠖꠦꠠ ꠀꠔ ꠃꠌꠣ। ");
INSERT INTO syls_vpl VALUES ("EX25_11","003_25_11","EXO","25","11","11","ꠄꠞ ꠛꠣꠞꠦ-ꠜꠤꠔꠞꠦ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠀ ꠖꠤꠅ, ꠀꠞ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠅ ꠡꠥꠘꠣꠞ ꠘꠇꠡꠣ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_12","003_25_12","EXO","25","12","12","ꠀꠉꠥꠁꠘꠖꠤ ꠡꠥꠘꠣ ꠉꠟꠣꠁꠀ ꠌꠣꠁꠞꠐꠣ ꠇꠠꠣ ꠄꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠔ ꠟꠣꠉꠣꠁꠅ, ꠅꠉꠣꠟꠣꠔ ꠖꠥꠁꠐꠣ ꠀꠞ ꠢꠉꠣꠟꠣꠔ ꠖꠥꠁꠐꠣ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_13","003_25_13","EXO","25","13","13","ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠖꠥꠉꠥ ꠛꠦꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠀ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠀ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_14","003_25_14","EXO","25","14","14","ꠡꠘ꠆ꠖꠥꠇꠞꠦ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠞ ꠇꠠꠣꠞ ꠝꠣꠎꠦꠖꠤ, ꠅꠃ ꠖꠥꠁꠅ ꠛꠦꠘ꠆ꠖꠣ ꠢꠣꠞꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_15","003_25_15","EXO","25","15","15","ꠛꠦꠘ꠆ꠖꠣ ꠖꠥꠁꠅꠐꠣ ꠡꠘ꠆ꠖꠥꠇꠞ ꠇꠠꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠞꠣꠁꠟ ꠞꠁꠛ, ꠁꠉꠥꠁꠘ ꠈꠥꠟꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX25_16","003_25_16","EXO","25","16","16","ꠀꠝꠤ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠟꠦꠈꠣ ꠎꠦ ꠙꠛꠤꠔ꠆ꠞ ꠡꠣꠢꠣꠖꠔ ꠙꠣꠔ꠆ꠔꠞ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠝꠥ, ꠔꠥꠝꠤ ꠁꠐꠣ ꠅꠃ ꠡꠘ꠆ꠖꠥꠇꠞ ꠜꠤꠔꠞꠦ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_17","003_25_17","EXO","25","17","17","“ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠡꠘ꠆ꠖꠥꠇꠞ ꠄꠇꠈꠣꠘ ꠓꠣꠇꠘꠣ ꠛꠣꠘꠣꠁꠅ, ꠅꠈꠣꠘꠞ ꠃꠙꠞꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠛ। ꠁ ꠓꠣꠇꠘꠣ ꠟꠣꠝ꠆ꠛꠣꠄ ꠀꠠꠣꠁ ꠀꠔ ꠀꠞ ꠙꠣꠡꠦ ꠖꠦꠠ ꠀꠔ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_18","003_25_18","EXO","25","18","19","ꠔꠥꠝꠤ ꠢꠃ ꠓꠣꠇꠘꠣꠞ ꠇꠤꠘꠣꠞꠅ ꠡꠥꠘꠣ ꠙꠤꠐꠣꠁꠀ ꠖꠥꠉꠥ ꠇꠣꠞꠥꠛꠤ ꠛꠣꠘꠣꠁꠅ। ꠅꠃ ꠇꠣꠞꠥꠛꠤ ꠖꠦꠈꠔꠦ ꠖꠥꠟꠖꠥꠟ ꠊꠥꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠒꠣꠈꠘꠣ ꠀꠟꠣ। ꠛꠣꠘꠣꠁꠀ ꠡꠘ꠆ꠖꠥꠇꠞ ꠖꠥꠁ ꠉꠣꠟꠣꠔ ꠟꠣꠉꠣꠁꠅ, ꠅꠉꠣꠟꠣꠔ ꠄꠇꠐꠣ, ꠀꠞ ꠢꠉꠣꠟꠣꠔ ꠄꠇꠐꠣ। ꠖꠥꠁꠅ ꠇꠣꠞꠥꠛꠤ ꠓꠣꠇꠘꠣꠞ ꠟꠉꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ, ꠎꠦꠐꠣ ꠀꠡ꠆ꠔꠣꠐꠣꠄ ꠈꠣꠟꠤ ꠄꠇ ꠌꠤꠎ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EX25_20","003_25_20","EXO","25","20","20","ꠄꠞ ꠒꠣꠈꠘꠣ ꠖꠥꠁꠅꠈꠣꠘ ꠃꠙꠞꠦꠖꠤ ꠝꠦꠟꠣꠁꠟ ꠞꠁꠛ, ꠀꠞ ꠄꠞ ꠍꠣꠄꠀꠞ ꠔꠟꠦ ꠕꠣꠇꠛ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣ। ꠖꠥꠁꠅ ꠇꠣꠞꠥꠛꠤ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠃꠛꠣ ꠕꠣꠇꠛ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠞꠁꠛ ꠓꠣꠇꠘꠣꠞ ꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX25_21","003_25_21","EXO","25","21","21","ꠁ ꠓꠣꠇꠘꠣꠞꠦ ꠡꠘ꠆ꠖꠥꠇꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠟꠦꠈꠣ ꠎꠦ ꠡꠣꠢꠣꠖꠔ ꠙꠣꠔ꠆ꠔꠞ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠝꠥ, ꠅꠃ ꠙꠣꠔ꠆ꠔꠞ ꠔꠥꠝꠤ ꠡꠘ꠆ꠖꠥꠇꠞ ꠜꠤꠔꠞꠦ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_22","003_25_22","EXO","25","22","22","ꠁ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣꠞ ꠃꠙꠞꠦ ꠖꠥꠁꠅ ꠇꠣꠞꠥꠛꠤꠞ ꠝꠣꠎꠈꠣꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠝꠥ। ꠅꠃ ꠖꠤꠖꠣꠞꠞ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠢꠇꠟ ꠀꠁꠘ-ꠇꠣꠘꠥꠘ ꠎꠣꠘꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX25_23","003_25_23","EXO","25","23","23","“ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤ ꠖꠤꠀ ꠖꠥꠁ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ, ꠄꠇ ꠀꠔ ꠙꠣꠡ ꠀꠞ ꠖꠦꠠ ꠀꠔ ꠃꠌꠣ ꠇꠞꠤ ꠄꠇꠈꠣꠘ ꠐꠦꠛꠥꠟ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_24","003_25_24","EXO","25","24","24","ꠅꠈꠣꠘꠞꠦ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠀ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠅ ꠘꠇꠡꠣ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_25","003_25_25","EXO","25","25","25","ꠐꠦꠛꠥꠟꠞ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠅ ꠌꠣꠁꠞ ꠀꠋꠉꠥꠟ ꠃꠌꠣ ꠇꠞꠤ ꠄꠇ ꠢꠣꠎ ꠖꠤꠛꠣꠄ, ꠢꠣꠎꠞ ꠝꠣꠎꠦ ꠡꠥꠘꠣꠖꠤ ꠘꠇꠡꠣ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX25_26","003_25_26","EXO","25","26","26","ꠐꠦꠛꠥꠟꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠔ ꠌꠣꠁꠞꠅ ꠙꠣꠄꠀꠞ ꠃꠙꠞꠦ ꠡꠥꠘꠣꠞ ꠌꠣꠁꠞꠐꠣ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX25_27","003_25_27","EXO","25","27","27","ꠁ ꠌꠣꠁꠞꠅ ꠇꠠꠣꠁꠘ ꠐꠦꠛꠥꠟꠞ ꠇꠥꠘꠣꠞ ꠢꠃ ꠃꠌꠣ ꠢꠣꠎꠞ ꠔꠟꠦ ꠟꠣꠉꠣꠁꠅ, ꠎꠣꠔꠦ ꠐꠦꠛꠥꠟ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠣꠟꠣ ꠇꠠꠣꠞ ꠜꠤꠔꠞꠦ ꠛꠦꠘ꠆ꠖꠣ ꠢꠣꠞꠣꠁꠟ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX25_28","003_25_28","EXO","25","28","28","ꠛꠦꠘ꠆ꠖꠣ ꠖꠥꠁꠅꠐꠣ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠀ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠛꠣꠄ, ꠅꠃ ꠛꠦꠘ꠆ꠖꠣꠖꠤ ꠐꠦꠛꠥꠟ ꠛꠁꠀ ꠘꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX25_29","003_25_29","EXO","25","29","29","ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠞ ꠕꠣꠟ-ꠛꠣꠡꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠓꠣꠟꠤꠀ ꠖꠤꠛꠣꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠎꠉ ꠀꠞ ꠝꠉ, ꠢꠇꠟꠔꠣ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_30","003_25_30","EXO","25","30","30","ꠅꠃ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠢꠣꠝꠦꠡꠣ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ ꠞꠣꠈꠛꠣꠄ, ꠁ ꠞꠥꠐꠤ ꠎꠣꠘꠥ ꠡꠛ ꠡꠝꠄ ꠕꠅꠀ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX25_31","003_25_31","EXO","25","31","31","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠄꠇꠈꠣꠘ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ ꠛꠣꠘꠣꠁꠛꠣꠄ, ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠔꠟꠣ ꠀꠞ ꠒꠣꠘ꠆ꠒꠤ ꠈꠣꠐꠤ ꠡꠥꠘꠣ ꠙꠤꠐꠣꠁꠀ ꠉꠠꠣꠁꠛꠣꠄ। ꠅꠃ ꠒꠣꠘ꠆ꠒꠤ, ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠙꠤꠀꠟꠣ, ꠇꠥꠠꠤ ꠀꠞ ꠙꠣꠙꠠꠤ ꠅꠇꠟ, ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠢꠇꠟꠔꠣꠄ ꠄꠇꠟꠉꠦ ꠄꠇ ꠙꠤꠍ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_32","003_25_32","EXO","25","32","32","ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠒꠣꠘ꠆ꠒꠤꠞ ꠖꠥꠁ ꠉꠣꠟꠣꠔ ꠔꠤꠘꠐꠣ ꠇꠞꠤ ꠝꠥꠐ ꠍꠄꠐꠣ ꠒꠣꠟ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_33","003_25_33","EXO","25","33","33","ꠙꠞꠔꠦꠇ ꠒꠣꠟꠞ ꠝꠣꠎꠦ ꠎꠛꠣ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠔꠤꠘꠉꠥ ꠇꠞꠤ ꠙꠤꠀꠟꠣ ꠕꠣꠇꠛ। ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠍꠄꠅ ꠒꠣꠟꠅ ꠄꠇꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_34","003_25_34","EXO","25","34","34","ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠝꠥꠟ ꠒꠣꠘ꠆ꠒꠤꠞ ꠝꠣꠎꠦꠅ ꠎꠛꠣ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠌꠣꠁꠞꠐꠣ ꠙꠤꠀꠟꠣ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_35","003_25_35","EXO","25","35","35","ꠅꠃ ꠝꠥꠟ ꠒꠣꠘ꠆ꠒꠤ ꠕꠣꠇꠤ ꠛꠣꠞꠅꠁꠟ ꠍꠄꠐꠣ ꠒꠣꠟꠞ ꠝꠣꠎꠦ, ꠙꠄꠟꠣ ꠖꠥꠁꠅ ꠒꠣꠟꠞ ꠎꠥꠠꠣꠔ ꠄꠉꠥ ꠇꠥꠠꠤ, ꠖꠥꠍꠞꠣ ꠖꠥꠁꠅ ꠒꠣꠟꠞ ꠎꠥꠠꠣꠔ ꠀꠞꠇ ꠇꠥꠠꠤ, ꠀꠞ ꠢꠦꠡꠞ ꠖꠥꠁꠅ ꠒꠣꠟꠞ ꠎꠥꠠꠣꠔꠅ ꠇꠥꠠꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX25_36","003_25_36","EXO","25","36","36","ꠇꠥꠠꠤ ꠀꠞ ꠒꠣꠟ ꠢꠇꠟꠔꠣ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠛ, ꠢꠇꠟꠔꠣ ꠝꠤꠟꠤꠀ ꠄꠇ ꠌꠤꠎ ꠅꠁꠛ। ꠀꠡ꠆ꠔꠣꠐꠣꠃ ꠈꠣꠐꠤ ꠡꠥꠘꠣ ꠙꠤꠐꠣꠁꠀ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_37","003_25_37","EXO","25","37","37","ꠄꠞꠛꠣꠖꠦ ꠡꠣꠔꠐꠣ ꠌꠦꠞꠣꠉ ꠛꠣꠘꠣꠁꠀ ꠅꠃ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠟꠣꠉꠣꠘꠤ ꠟꠣꠉꠛ, ꠎꠣꠔꠦ ꠌꠦꠞꠣꠉ ꠅꠇꠟ ꠎꠣꠟꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠍꠣꠝꠘꠣ ꠚꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EX25_38","003_25_38","EXO","25","38","38","ꠌꠦꠞꠣꠉꠞ ꠚꠤꠔꠣ ꠍꠣꠚ ꠇꠞꠣꠞ ꠌꠤꠝꠐꠣ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠚꠤꠔꠣꠞ ꠍꠣꠟꠤ ꠕꠅꠀꠞ ꠟꠣꠉꠤ ꠇꠄꠉꠥ ꠛꠣꠐꠤ, ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_39","003_25_39","EXO","25","39","39","ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠢꠇꠟꠔꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇ ꠝꠘ ꠈꠣꠐꠤ ꠡꠥꠘꠣ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX25_40","003_25_40","EXO","25","40","40","“ꠢꠥꠘꠅ, ꠅꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠘꠇꠡꠣ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠟ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠢꠇꠟꠔꠣ ꠛꠣꠘꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX26_1","003_26_1","EXO","26","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠖꠡ ꠐꠥꠇꠞꠣ ꠙꠦꠌꠣꠁꠟ ꠡꠥꠔꠣꠞ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠀꠝꠣꠞ ꠊꠞꠞ ꠙꠞ꠆ꠖꠣꠁꠘ ꠛꠣꠘꠣꠁꠅ। ꠀꠞ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣꠖꠤ ꠜꠣꠟꠣ ꠃꠡ꠆ꠔꠣꠖꠞꠦꠖꠤ ꠄꠞ ꠝꠣꠎꠦ ꠇꠣꠞꠥꠛꠤ ꠅꠇꠟꠞ ꠍꠛꠤ ꠛꠣꠁꠘ ꠇꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX26_2","003_26_2","EXO","26","2","2","ꠢꠇꠟ ꠐꠥꠇꠞꠣꠁꠘ ꠄꠇ ꠝꠣꠙꠞ ꠅꠁꠛ, ꠟꠣꠝ꠆ꠛꠣꠄ ꠀꠐꠣꠁꠡ ꠀꠔ ꠀꠞ ꠚꠣꠠꠦ ꠌꠣꠁꠞ ꠀꠔ। ");
INSERT INTO syls_vpl VALUES ("EX26_3","003_26_3","EXO","26","3","3","ꠁ ꠐꠥꠇꠞꠣꠁꠘ꠆ꠔꠞ ꠙꠣꠌꠈꠣꠘ ꠙꠣꠌꠈꠣꠘ ꠇꠞꠤ ꠄꠇꠈꠣꠘꠅ ꠎꠥꠠꠣ ꠖꠤꠀ, ꠖꠥꠈꠣꠘ ꠛꠠ ꠉꠤꠟꠣꠚ ꠛꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_4","003_26_4","EXO","26","4","4","ꠛꠠ ꠉꠤꠟꠣꠚꠞ ꠙꠄꠟꠣ ꠐꠥꠇꠞꠣꠞ ꠙꠣꠡꠞ ꠄꠇ ꠇꠤꠘꠣꠞꠅ ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣꠖꠤ ꠢꠥꠇꠞ ꠚꠥꠠ ꠛꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ। ꠖꠥꠍꠞꠣ ꠐꠥꠇꠞꠣꠔꠅ ꠅꠃꠟꠣ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_5","003_26_5","EXO","26","5","5","ꠙꠄꠟꠣ ꠉꠤꠟꠣꠚꠞ ꠇꠤꠘꠣꠞꠅ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇꠞ ꠚꠥꠠ ꠀꠞ ꠖꠥꠍꠞꠣ ꠉꠤꠟꠣꠚꠅ ꠅꠃꠟꠣ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠚꠥꠠ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠖꠥꠁꠅ ꠛꠠ ꠉꠤꠟꠣꠚꠞ ꠢꠥꠇꠞ ꠚꠥꠠ ꠄꠉꠥ ꠀꠞꠦꠉꠥꠞ ꠃꠟꠐꠣꠝꠥꠈꠣ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_6","003_26_6","EXO","26","6","6","ꠛꠣꠖꠦ ꠡꠥꠘꠣꠖꠤ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇ ꠛꠣꠘꠣꠁꠀ ꠢꠃ ꠚꠥꠠꠞ ꠝꠣꠎꠦꠖꠤ ꠢꠣꠞꠣꠁꠀ, ꠛꠠ ꠖꠥꠁꠅ ꠉꠤꠟꠣꠚꠞꠦ ꠀꠐꠇꠣꠁ ꠖꠤꠅ। ꠔꠦꠃ ꠁ ꠖꠥꠁꠅ ꠐꠥꠇꠞꠣꠖꠤ ꠄꠇꠈꠣꠘ ꠊꠞ ꠔꠤꠀꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_7","003_26_7","EXO","26","7","7","“ꠀꠝꠣꠞ ꠊꠞꠞ ꠃꠙꠞ ꠉꠥꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣ ꠖꠤꠀ ꠉꠤꠟꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠄꠉꠣꠞꠅꠈꠣꠘ ꠐꠥꠇꠞꠣ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_8","003_26_8","EXO","26","8","8","ꠢꠇꠟ ꠐꠥꠇꠞꠣꠁꠘ ꠄꠇ ꠝꠣꠙꠞ ꠅꠁꠛ, ꠔꠤꠡ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ ꠀꠞ ꠌꠣꠁꠞ ꠀꠔ ꠚꠣꠠ। ");
INSERT INTO syls_vpl VALUES ("EX26_9","003_26_9","EXO","26","9","9","ꠅꠘ ꠕꠣꠇꠤ ꠙꠣꠌ ꠐꠥꠇꠞꠣ ꠄꠇꠟꠉꠦ ꠎꠥꠠꠣ ꠖꠤꠀ ꠛꠠ ꠄꠇ ꠉꠤꠟꠣꠚ ꠛꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ। ꠀꠞ ꠛꠣꠇꠤ ꠍꠄ ꠐꠥꠇꠞꠣ ꠎꠥꠠꠣ ꠖꠤꠀ, ꠛꠠ ꠀꠞꠇ ꠉꠤꠟꠣꠚ ꠛꠣꠘꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠅꠃ ꠖꠥꠍꠞꠣ ꠉꠤꠟꠣꠚꠞ ꠎꠦ ꠐꠥꠇꠞꠣ ꠛꠣꠠꠔꠤ ꠞꠁꠛ, ꠅꠈꠣꠘꠞꠦ ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠞ ꠛꠣꠄ ꠖꠥꠁ ꠜꠣꠁꠘ꠆ꠎ ꠇꠞꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_10","003_26_10","EXO","26","10","10","ꠙꠄꠟꠣ ꠛꠠ ꠉꠤꠟꠣꠚꠞ ꠙꠣꠡꠞ ꠄꠇ ꠇꠤꠘꠣꠞꠅ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇꠞ ꠚꠥꠠ ꠛꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠖꠥꠍꠞꠣ ꠉꠤꠟꠣꠚꠅ-ꠅ ꠅꠃꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_11","003_26_11","EXO","26","11","11","ꠛꠣꠖꠦ ꠙꠤꠔꠟ ꠖꠤꠀ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇ ꠛꠣꠘꠣꠁꠀ ꠢꠃ ꠢꠥꠇꠞ ꠚꠥꠠꠞ ꠝꠣꠎꠦ ꠢꠣꠞꠣꠁꠀ, ꠅꠃ ꠛꠠ ꠖꠥꠁꠅ ꠉꠤꠟꠣꠚ ꠄꠇꠈꠣꠘꠅ ꠎꠥꠠꠣ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠔꠦꠃ ꠁ ꠖꠥꠁꠅ ꠉꠤꠟꠣꠚ ꠝꠤꠟꠤꠀ ꠄꠇꠈꠣꠘ ꠍꠣꠘꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_12","003_26_12","EXO","26","12","12","ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣꠞ ꠛꠠ ꠉꠤꠟꠣꠚꠞ ꠎꠦ ꠀꠗꠣ ꠐꠥꠇꠞꠣ ꠛꠣꠠꠔꠤ ꠅꠁꠛ, ꠁꠈꠣꠘ ꠈꠞꠦꠖꠤ ꠟꠐꠇꠣꠁꠟ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_13","003_26_13","EXO","26","13","13","ꠁ ꠉꠤꠟꠣꠚ ꠈꠣꠘ ꠔꠟꠞ ꠇꠣꠙꠠ ꠕꠣꠇꠤ ꠄꠇ ꠀꠔ ꠛꠠ ꠅꠀꠄ ꠁꠈꠣꠘ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠟꠐꠇꠣꠁꠟ ꠞꠁꠀ ꠢꠣꠞꠣ ꠊꠞꠞꠦ ꠉꠥꠞꠤꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_14","003_26_14","EXO","26","14","14","ꠄꠞ ꠃꠙꠞ ꠉꠥꠞꠣꠞ ꠟꠣꠉꠤ ꠟꠣꠟ ꠞꠋ ꠇꠞꠣ ꠝꠦꠠꠣꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠀꠞꠅꠈꠣꠘ ꠉꠤꠟꠣꠚ ꠛꠣꠘꠣꠁꠀ ꠉꠥꠞꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠛꠣꠖꠦ ꠄꠞ ꠃꠙꠞꠦ ꠖꠞꠤꠀꠞ ꠚꠥʼ ꠝꠣꠍꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠍꠣꠘꠤ ꠔꠂꠀꠞ ꠇꠞꠤ ꠉꠥꠞꠤ ꠖꠤꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX26_15","003_26_15","EXO","26","15","15","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠊꠞꠞ ꠟꠣꠉꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠇʼꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_16","003_26_16","EXO","26","16","16","ꠙꠞꠔꠦꠇ ꠚ꠆ꠞꠦꠁꠝ ꠛꠣꠘꠣꠁꠛꠣꠄ ꠖꠡ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ ꠀꠞ ꠖꠦꠠ ꠀꠔ ꠚꠣꠠ। ");
INSERT INTO syls_vpl VALUES ("EX26_17","003_26_17","EXO","26","17","17","ꠅꠃ ꠚ꠆ꠞꠦꠁꠝꠅ ꠖꠥꠉꠥ ꠇꠞꠤ ꠙꠣꠄꠀ ꠕꠣꠇꠛ। ꠢꠇꠟ ꠚ꠆ꠞꠦꠁꠝ ꠄꠇꠟꠣꠈꠣꠘ ꠛꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_18","003_26_18","EXO","26","18","18","ꠖꠇ꠆ꠇꠤꠘ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ ꠛꠤꠡꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_19","003_26_19","EXO","26","19","19","ꠁ ꠚ꠆ꠞꠦꠁꠝꠞ ꠙꠣꠄꠀꠞ ꠔꠟꠦ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠌꠣꠟ꠆ꠟꠤꠡꠉꠥ ꠞꠥꠙꠣꠞ ꠌꠥꠘ꠆ꠉꠤ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ, ꠙꠞꠔꠦꠇ ꠚ꠆ꠞꠦꠁꠝꠞ ꠖꠥꠁ ꠙꠣꠄꠀꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_20","003_26_20","EXO","26","20","20","ꠀꠝꠣꠞ ꠊꠞꠞ ꠃꠔ꠆ꠔꠞ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤꠀꠅ ꠛꠤꠡꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠟꠣꠉꠛ, ");
INSERT INTO syls_vpl VALUES ("EX26_21","003_26_21","EXO","26","21","21","ꠀꠞ ꠙꠞꠔꠦꠇ ꠚ꠆ꠞꠦꠁꠝꠞ ꠙꠣꠄꠀꠞ ꠔꠟꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠇꠞꠤ ꠌꠣꠟ꠆ꠟꠤꠡꠉꠥ ꠞꠥꠙꠣꠞ ꠌꠥꠘ꠆ꠉꠤ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_22","003_26_22","EXO","26","22","22","ꠙꠁꠌꠝꠞ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ, ꠝꠣꠘꠤ ꠈꠞ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ ꠍꠄꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ, ");
INSERT INTO syls_vpl VALUES ("EX26_23","003_26_23","EXO","26","23","23","ꠀꠞ ꠈꠞꠞ ꠖꠥꠁꠅ ꠇꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠖꠥꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_24","003_26_24","EXO","26","24","24","ꠁ ꠖꠥꠁ ꠚ꠆ꠞꠦꠁꠝꠞꠦ ꠖꠥꠁ ꠇꠥꠘꠣꠞ ꠖꠥꠁꠅ ꠚ꠆ꠞꠦꠁꠝꠞ ꠟꠉꠦ ꠔꠟꠦ-ꠃꠙꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠎꠥꠠꠣ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠙꠞꠔꠦꠇ ꠇꠥꠘꠣꠞ ꠖꠥꠁ ꠚ꠆ꠞꠦꠁꠝ ꠗꠣꠞꠞ ꠚ꠆ꠞꠦꠁꠝꠞ ꠟꠉꠦ ꠛꠣꠔ꠆ꠔꠤ ꠝꠣꠞꠤꠀ ꠄꠇꠟꠉꠦ ꠎꠥꠠꠣ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠖꠥꠁꠅ ꠇꠥꠘꠣ ꠄꠇꠟꠣꠈꠣꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_25","003_26_25","EXO","26","25","25","ꠔꠦꠃ ꠈꠞꠦꠖꠤ ꠀꠐꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠅꠁꠛ, ꠀꠞ ꠙꠞꠔꠦꠇ ꠚ꠆ꠞꠦꠁꠝꠞ ꠔꠟꠦ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠇꠞꠤ ꠡꠥꠟꠉꠥ ꠞꠥꠙꠣꠞ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_26","003_26_26","EXO","26","26","26","“ꠔꠥꠝꠤ ꠚ꠆ꠞꠦꠁꠝꠞꠦ ꠎꠥꠠꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠇꠄꠉꠥ ꠟꠣꠝ꠆ꠛꠣ ꠛꠣꠔ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX26_27","003_26_27","EXO","26","27","27","ꠄꠞ ꠝꠣꠎꠦ ꠙꠣꠌꠉꠥ ꠛꠣꠔ꠆ꠔꠤ ꠊꠞꠞ ꠄꠇ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠛꠣꠇꠤ ꠙꠣꠌꠉꠥ ꠀꠞꠇ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠙꠣꠌꠉꠥ ꠟꠣꠉꠛ ꠈꠞ ꠉꠣꠟꠣ, ꠝꠣꠘꠤ ꠙꠌꠤꠝ ꠉꠣꠟꠣꠞ ꠚ꠆ꠞꠦꠁꠝꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX26_28","003_26_28","EXO","26","28","28","ꠚ꠆ꠞꠦꠁꠝꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠟꠣꠉꠣꠁꠟ ꠅꠃ ꠛꠣꠔ꠆ꠔꠤꠖꠤ ꠢꠇꠟ ꠚ꠆ꠞꠦꠁꠝꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠐꠇꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX26_29","003_26_29","EXO","26","29","29","ꠚ꠆ꠞꠦꠁꠝ ꠈꠣꠘꠣꠁꠘ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠛꠣꠔ꠆ꠔꠤ ꠢꠣꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠛꠣꠘꠣꠁꠀ ꠚ꠆ꠞꠦꠁꠝꠅ ꠟꠣꠉꠣꠁꠔꠦ ꠅꠁꠛ। ꠁ ꠛꠣꠔ꠆ꠔꠤ ꠅꠇꠟꠅ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX26_30","003_26_30","EXO","26","30","30","ꠀꠝꠣꠞ ꠊꠞꠞ ꠎꠦ ꠘꠇꠡꠣ ꠔꠥꠝꠣꠞꠦ ꠅꠃ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠖꠦꠈꠣꠁꠟꠣꠝ, ꠔꠥꠝꠤ ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠁꠐꠣ ꠔꠂꠀꠞ ꠇꠞꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX26_31","003_26_31","EXO","26","31","31","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠟꠤꠟꠥꠀ, ꠟꠣꠟ, ꠛꠣꠁꠋꠉꠘꠤ ꠡꠥꠔꠣ ꠀꠞ ꠙꠦꠌꠣꠁꠟ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠄꠇꠈꠣꠘ ꠙꠞ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠅ। ꠜꠣꠟꠣ ꠇꠥꠘꠥ ꠃꠡ꠆ꠔꠣꠖꠞꠦꠖꠤ ꠄꠞ ꠃꠙꠞꠦ ꠇꠣꠞꠥꠛꠤ ꠅꠇꠟꠞ ꠍꠛꠤ ꠛꠣꠁꠘ ꠇꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX26_32","003_26_32","EXO","26","32","32","ꠁ ꠙꠞ꠆ꠖꠣꠈꠣꠘ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠌꠣꠁꠞꠐꠣ ꠈꠥꠐꠤꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠀ ꠡꠥꠘꠣꠞ ꠇꠠꠣꠖꠤ ꠟꠐꠇꠣꠁ ꠖꠤꠛꠣꠄ, ꠈꠥꠐꠤꠞ ꠝꠣꠕꠣꠔ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠛꠣꠄ। ꠀꠞ ꠈꠥꠐꠤꠉꠥꠁꠘ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠣꠁꠛꠣꠄ, ꠈꠥꠐꠤꠞ ꠔꠟꠣꠔ ꠞꠥꠙꠣꠞ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX26_33","003_26_33","EXO","26","33","33","ꠙꠞ꠆ꠖꠣꠞ ꠃꠙꠞꠞ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠅ ꠟꠣꠉꠣꠁꠟ ꠢꠥꠇꠞ ꠟꠉꠦ ꠙꠞ꠆ꠖꠣꠈꠣꠘ ꠟꠐꠇꠣꠁꠟ ꠞꠁꠛ। ꠁ ꠙꠞ꠆ꠖꠣꠞ ꠈꠞꠦ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ ꠕꠁꠛꠣꠄ। ꠙꠞ꠆ꠖꠣꠖꠤ ꠀꠝꠣꠞ ꠊꠞꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚ, ꠝꠣꠘꠤ ꠈꠣꠍ ꠙꠣꠇ ꠎꠣꠉꠣ ꠀꠞ ꠙꠣꠇ ꠎꠣꠉꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠛꠦꠠꠣ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX26_34","003_26_34","EXO","26","34","34","ꠅꠃ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠜꠤꠔꠞꠦ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠃꠙꠞꠦ ꠄꠞ ꠓꠣꠇꠘꠣ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX26_35","003_26_35","EXO","26","35","35","ꠁ ꠙꠞ꠆ꠖꠣꠞ ꠛꠣꠞꠦ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠃꠔ꠆ꠔꠞ ꠉꠣꠟꠣꠔ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ ꠞꠣꠈꠣꠞ ꠐꠦꠛꠥꠟꠈꠣꠘ ꠕꠁꠅ, ꠀꠞ ꠄꠞ ꠃꠟꠐꠣꠝꠥꠈꠣ ꠖꠇ꠆ꠇꠤꠘ ꠉꠣꠟꠣꠔ ꠕꠁꠅ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("EX26_36","003_26_36","EXO","26","36","36","“ꠀꠝꠣꠞ ꠊꠞꠞ ꠖꠥꠀꠞꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘ ꠙꠞ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠅ, ꠁꠈꠣꠘ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠛꠣꠘꠣꠁꠀ ꠢꠣꠞꠤ, ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠞꠋꠉꠞ ꠡꠥꠔꠣꠖꠤ ꠘꠇꠡꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX26_37","003_26_37","EXO","26","37","37","ꠁ ꠙꠞ꠆ꠖꠣꠞ ꠟꠣꠉꠤ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠀꠞ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠞ ꠙꠣꠌꠐꠣ ꠈꠥꠐꠤ ꠛꠣꠘꠣꠁꠅ। ꠈꠥꠐꠤꠉꠥꠁꠘ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠣꠁꠅ, ꠈꠥꠐꠤꠞ ꠔꠟꠣꠔ ꠙꠤꠔꠟꠞ ꠙꠣꠌꠉꠥ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX27_1","003_27_1","EXO","27","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠙꠣꠌ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ, ꠙꠣꠌ ꠀꠔ ꠙꠣꠡ ꠀꠞ ꠔꠤꠘ ꠀꠔ ꠃꠛꠤ ꠖꠤꠀ ꠌꠣꠁꠞꠇꠥꠘꠤ ꠇꠞꠤ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠔꠂꠀꠞ ꠇꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_2","003_27_2","EXO","27","2","2","ꠄꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠇꠠꠤꠖꠤ ꠌꠣꠁꠞꠐꠣ ꠢꠤꠋ ꠖꠤꠅ। ꠅꠃ ꠢꠤꠋ ꠇꠥꠘꠣꠞ ꠟꠣꠇꠠꠤ ꠈꠥꠖꠤꠀ ꠛꠣꠘꠣꠘꠤ ꠟꠣꠉꠛ, ꠁ ꠀꠡ꠆ꠔꠣꠈꠣꠘ ꠄꠇ ꠌꠤꠎ ꠅꠁꠛ। ꠛꠣꠖꠦ ꠙꠥꠞꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠙꠤꠔꠟꠖꠤ ꠟꠦꠙꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_3","003_27_3","EXO","27","3","3","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠍꠣꠟꠤ ꠔꠥꠟꠣꠞ ꠛꠠ ꠌꠣꠝꠌ ꠀꠞ ꠉꠣꠝꠟꠣ, ꠟꠃ ꠕꠅꠀꠞ ꠛꠣꠐꠤ, ꠉꠥꠡ꠆ꠔ ꠔꠥꠟꠣꠞ ꠛꠠ ꠇꠣꠐꠣ-ꠍꠤꠚ, ꠀꠋꠞꠣ ꠕꠅꠀꠞ ꠙꠣꠔꠤꠟ, ꠢꠇꠟꠔꠣ ꠙꠤꠔꠟꠖꠤ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_4","003_27_4","EXO","27","4","4","ꠙꠤꠔꠟꠖꠤ ꠄꠇꠈꠣꠘ ꠎꠣꠟꠤ ꠛꠣꠘꠣꠁꠛꠣꠄ। ꠄꠞ ꠌꠣꠁꠞ ꠇꠥꠘꠣꠔ ꠌꠣꠁꠞꠐꠣ ꠙꠤꠔꠟꠞ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_5","003_27_5","EXO","27","5","5","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠣ ꠕꠣꠇꠤ ꠃꠙꠞꠞ ꠝꠣꠎꠣꠝꠣꠎꠤ ꠎꠣꠉꠣꠞ ꠔꠣꠠꠤꠀꠞ ꠔꠟꠦ ꠅꠃ ꠎꠣꠟꠤ ꠛꠅꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_6","003_27_6","EXO","27","6","6","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠁꠀ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠖꠥꠉꠥ ꠛꠦꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠅ, ꠛꠣꠘꠣꠁꠀ ꠖꠥꠁꠅꠉꠥ ꠙꠤꠔꠟꠖꠤ ꠟꠦꠙꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_7","003_27_7","EXO","27","7","7","ꠁ ꠛꠦꠘ꠆ꠖꠣꠁꠘ ꠇꠠꠣꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠢꠣꠞꠣꠘꠤ ꠟꠣꠉꠛ। ꠔꠦꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠣꠟꠣ ꠖꠥꠁꠅ ꠛꠦꠘ꠆ꠖꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠖꠥꠁ ꠉꠣꠟꠣꠛꠣꠄ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("EX27_8","003_27_8","EXO","27","8","8","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠔꠇ꠆ꠔꠣꠖꠤ ꠛꠣꠘꠣꠁꠀ ꠄꠞ ꠜꠤꠔꠞꠦ ꠚꠣꠇ ꠞꠣꠈꠤꠅ। ꠀꠝꠤ ꠅꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠘꠇꠡꠣ ꠖꠦꠈꠣꠁꠟꠣꠝ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠛꠣꠘꠣꠘꠤ ꠟꠅꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_9","003_27_9","EXO","27","9","9","“ꠀꠝꠣꠞ ꠊꠞꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠃꠑꠣꠘ ꠕꠣꠇꠛ। ꠄꠞ ꠖꠇ꠆ꠇꠤꠘ ꠉꠣꠟꠣꠛꠣꠄ ꠄꠇ-ꠡ ꠀꠔ ꠞꠣꠈꠤꠅ, ꠁ ꠝꠥꠈꠣ ꠖꠤꠛꠣꠄ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠞ ꠙꠞ꠆ꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("EX27_10","003_27_10","EXO","27","10","10","ꠁ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠤꠡꠉꠥ ꠈꠥꠐꠤ ꠖꠤꠛꠣꠄ। ꠈꠥꠐꠤꠞ ꠔꠟꠣꠔ ꠖꠤꠛꠣꠄ ꠄꠇꠐꠣ ꠇꠞꠤ ꠙꠤꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ, ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠞꠥꠙꠣꠞ ꠇꠠꠣ ꠀꠞ ꠛꠣꠘ꠆ꠖꠤꠛꠣꠞ ꠔꠣꠞ ꠟꠣꠉꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX27_11","003_27_11","EXO","27","11","11","ꠃꠔ꠆ꠔꠞ ꠉꠣꠟꠣꠛꠣꠄ ꠄꠇ-ꠡ ꠀꠔ ꠃꠑꠣꠘ ꠞꠣꠈꠛꠣꠄ। ꠢꠘꠅ-ꠅ ꠙꠞ꠆ꠖꠣ ꠖꠤꠅ, ꠛꠤꠡꠉꠥ ꠈꠥꠐꠤ, ꠛꠤꠡꠉꠥ ꠙꠤꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ, ꠈꠥꠐꠤꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠅ ꠞꠥꠙꠣꠞ ꠇꠠꠣ ꠀꠞ ꠔꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("EX27_12","003_27_12","EXO","27","12","12","ꠙꠁꠌꠝꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠔ ꠃꠑꠣꠘ ꠞꠣꠈꠤꠅ, ꠢꠘꠅ-ꠅ ꠇꠄꠈꠣꠘ ꠙꠞ꠆ꠖꠣ, ꠖꠡꠉꠥ ꠈꠥꠐꠤ, ꠙꠞꠔꠦꠇ ꠈꠥꠐꠤꠞ ꠔꠟꠣꠔ ꠄꠇꠐꠣ ꠇꠞꠤ ꠌꠥꠘ꠆ꠉꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_13","003_27_13","EXO","27","13","13","ꠙꠥꠛꠦꠖꠤꠅ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠔ ꠃꠑꠣꠘ ꠞꠣꠈꠤꠅ; ");
INSERT INTO syls_vpl VALUES ("EX27_14","003_27_14","EXO","27","14","14","ꠉꠦꠁꠐꠞ ꠄꠇ ꠉꠣꠟꠣꠔ ꠙꠘꠞ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ ꠙꠞ꠆ꠖꠣ, ꠔꠤꠘꠐꠣ ꠈꠥꠐꠤ ꠀꠞ ꠔꠤꠘꠐꠣ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠣꠁꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("EX27_15","003_27_15","EXO","27","15","15","ꠅꠟꠣ ꠖꠥꠍꠞꠣ ꠉꠣꠟꠣꠔꠅ ꠙꠘꠞ ꠀꠔ ꠙꠞ꠆ꠖꠣ, ꠔꠤꠘꠐꠣ ꠈꠥꠐꠤ ꠀꠞ ꠔꠤꠘꠐꠣ ꠌꠥꠘ꠆ꠉꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_16","003_27_16","EXO","27","16","16","ꠃꠑꠣꠘꠞ ꠉꠦꠁꠐꠞ ꠟꠣꠉꠤ ꠌꠣꠁꠞꠐꠣ ꠈꠥꠐꠤ, ꠌꠣꠁꠞꠐꠣ ꠌꠥꠘ꠆ꠉꠤ ꠀꠞ ꠛꠤꠡ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ ꠄꠇꠈꠣꠘ ꠙꠞ꠆ꠖꠣ। ꠙꠞ꠆ꠖꠣꠈꠣꠘ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠛꠣꠘꠣꠁꠀ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣꠖꠤ ꠘꠇꠡꠣ ꠇꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX27_17","003_27_17","EXO","27","17","17","ꠃꠑꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠢꠇ꠆ꠇꠟ ꠈꠥꠐꠤꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠛꠣꠞ ꠔꠣꠞ ꠀꠞ ꠇꠠꠣ ꠅꠁꠛ ꠞꠥꠙꠣꠞ, ꠄꠞ ꠔꠟꠦ ꠙꠤꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("EX27_18","003_27_18","EXO","27","18","18","ꠃꠑꠣꠘꠈꠣꠘ ꠟꠣꠝ꠆ꠛꠣꠄ ꠄꠇ-ꠡ ꠀꠔ ꠀꠞ ꠙꠣꠡꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠔ ꠅꠁꠛ। ꠄꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠙꠣꠌ ꠀꠔ ꠃꠛꠤ ꠙꠞ꠆ꠖꠣ ꠖꠤꠅ, ꠙꠞ꠆ꠖꠣ ꠅꠁꠛ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠞ, ꠀꠞ ꠈꠥꠐꠤꠘ꠆ꠔꠞ ꠔꠟꠦ ꠖꠤꠅ ꠙꠤꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX27_19","003_27_19","EXO","27","19","19","ꠀꠝꠣꠞ ꠊꠞꠞ ꠇꠣꠝꠞ ꠢꠇꠟ ꠌꠤꠎ ꠙꠤꠔꠟꠖꠤ ꠛꠣꠘꠣꠁꠛꠣꠄ, ꠝꠥꠟ ꠔꠣꠝ꠆ꠛꠥ ꠀꠞ ꠃꠑꠣꠘꠞ ꠛꠦꠠꠣꠞ ꠐꠣꠘꠣꠞ ꠞꠡꠤꠞ ꠔꠟꠞ ꠙꠦꠞꠦꠉ ꠅꠇꠟ ꠙꠤꠔꠟꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX27_20","003_27_20","EXO","27","20","20","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠅ, ꠔꠣꠞꠣ ꠎꠄꠔꠥꠘ ꠍꠦꠌꠤꠀ ꠔꠦꠟ ꠛꠣꠘꠣꠁꠀ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠔ, ꠎꠣꠔꠦ ꠌꠦꠞꠣꠉ ꠅꠇꠟ ꠢꠣꠝꠦꠡꠣ ꠎꠣꠟꠣꠁꠟ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("EX27_21","003_27_21","EXO","27","21","21","ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠍꠣꠝꠘꠦ ꠎꠦ ꠙꠞ꠆ꠖꠣꠈꠣꠘ ꠕꠣꠇꠛ, ꠅꠃ ꠙꠞ꠆ꠖꠣꠞ ꠛꠣꠞꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠕꠣꠇꠤ ꠚꠎꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠌꠦꠞꠣꠉ ꠉꠥꠁꠘ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠛꠣ। ꠀꠝꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠎꠣꠘꠥ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠝꠟ ꠇꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("EX28_1","003_28_1","EXO","28","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠥꠍꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘ, ꠔꠣꠞ ꠙꠥꠀ ꠘꠣꠖꠣꠛ, ꠀꠛꠤꠢꠥ, ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠁꠍꠣꠝꠣꠞꠞꠦ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_2","003_28_2","EXO","28","2","2","“ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘꠞ ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠡꠥꠘ꠆ꠖꠞ ꠛꠣꠠꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠔꠂꠀꠞ ꠇꠞꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_3","003_28_3","EXO","28","3","3","ꠀꠝꠤ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠀ ꠎꠦꠔꠣ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟꠞꠦ ꠇꠣꠞꠤꠉꠞꠤ ꠇꠣꠝꠞ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠖꠤꠍꠤ, ꠔꠥꠝꠤ ꠢꠃ ꠇꠣꠞꠤꠉꠞ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠢꠣꠞꠥꠘꠞ ꠟꠣꠉꠤ ꠅꠃꠟꠣ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠛꠣꠘꠣꠃꠇ꠆ꠇꠣ, ꠎꠦ ꠟꠦꠛꠣꠍ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("EX28_4","003_28_4","EXO","28","4","4","ꠁ ꠟꠦꠛꠣꠍꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤ, ꠄꠚꠞꠘ, ꠀꠟꠈꠦꠟ꠆ꠟꠣ, ꠌꠦꠉꠞ ꠇꠣꠙꠠꠞ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ, ꠙꠣꠃꠉꠠꠤ ꠀꠞ ꠇꠝꠞꠞ ꠛꠘ꠆ꠖꠘꠤ ꠛꠣꠘꠣꠁꠅ। ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_5","003_28_5","EXO","28","5","5","ꠟꠦꠛꠣꠍ ꠛꠣꠘꠣꠁꠔꠦ ꠔꠣꠞꠣ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠀꠞ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ, ꠄꠞ ꠟꠉꠦ ꠡꠥꠘꠣꠅ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX28_6","003_28_6","EXO","28","6","6","“ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠄꠚꠞꠘ ꠛꠣꠘꠣꠁꠛꠣꠄ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ, ꠀꠞ ꠡꠥꠘꠣꠖꠤ। ꠁꠔꠣ ꠜꠣꠟꠣ ꠇꠥꠘꠥ ꠃꠡ꠆ꠔꠣꠖꠞꠦꠖꠤ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_7","003_28_7","EXO","28","7","7","ꠄꠚꠞꠘꠞ ꠇꠣꠘ꠆ꠖꠞ ꠖꠥꠁ ꠉꠣꠟꠣ ꠎꠥꠠꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠈꠣꠘ ꠙꠐ꠆ꠐꠤ ꠛꠣꠘꠣꠁꠀ, ꠄꠚꠞꠘꠞ ꠃꠙꠞꠞ ꠇꠥꠘꠣꠔ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_8","003_28_8","EXO","28","8","8","ꠄꠚꠞꠘꠞ ꠟꠉꠦ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠁꠟ ꠙꠦꠐꠞ ꠃꠙꠞꠞ ꠛꠦꠟꠐ ꠈꠣꠘꠅ ꠄꠚꠞꠘꠞ ꠟꠣꠈꠣꠘ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ, ꠀꠞ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_9","003_28_9","EXO","28","9","9","“ꠔꠥꠝꠤ ꠖꠥꠁꠐꠣ ꠀꠇꠤꠇ ꠙꠣꠔ꠆ꠔꠞ ꠀꠘꠤꠀ ꠄꠞ ꠃꠙꠞꠦ ꠁꠍꠞꠣꠁꠟ, ꠝꠣꠘꠤ ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠈꠥꠖꠣꠁꠀ ꠟꠦꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_10","003_28_10","EXO","28","10","10","ꠙꠄꠟꠣ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ, ꠔꠣꠞꠣꠞ ꠎꠘꠝꠞ ꠢꠤꠡꠣꠛꠦ ꠛꠠ ꠕꠣꠇꠤ ꠢꠥꠞꠥ ꠝꠥꠈꠣ ꠍꠄ ꠎꠘꠞ ꠘꠣꠝ, ꠀꠞ ꠖꠥꠍꠞꠣ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦꠅ ꠛꠣꠇꠤ ꠍꠄ ꠎꠘꠞ ꠘꠣꠝ ꠈꠥꠖꠣꠁꠀ ꠟꠦꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_11","003_28_11","EXO","28","11","11","ꠢꠥꠘꠣꠞ ꠅꠇꠟꠦ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠈꠥꠖꠤꠀ ꠎꠦꠟꠣ ꠡꠤꠟ ꠛꠣꠘꠣꠁꠘ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠖꠥꠉꠥ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠈꠥꠖꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_12","003_28_12","EXO","28","12","12","ꠙꠣꠔ꠆ꠔꠞ ꠖꠥꠁꠅꠉꠥ ꠡꠥꠘꠣꠞ ꠎꠣꠎꠁꠞꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠣꠁꠀ ꠄꠚꠞꠘꠞ ꠇꠣꠘ꠆ꠖꠞ ꠙꠐ꠆ꠐꠤꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠅ। ꠁꠍꠞꠣꠁꠟꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠛꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ, ꠁ ꠙꠣꠔ꠆ꠔꠞ ꠢꠣꠞꠥꠘꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞ ꠇꠣꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX28_13","003_28_13","EXO","28","13","14","ꠖꠥꠁꠅ ꠎꠣꠎꠁꠞꠞ ꠟꠉꠦ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠖꠥꠇꠍꠣ ꠌꠦꠁꠘ ꠟꠣꠉꠣꠁꠅ। ꠅꠃ ꠖꠥꠁꠅ ꠌꠦꠁꠘ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠞꠡꠤꠞ ꠘꠝꠥꠘꠣꠄ ꠙꠦꠌꠣꠁꠀ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_15","003_28_15","EXO","28","15","15","“ꠀꠝꠣꠞ ꠞꠣꠄ-ꠚꠄꠍꠣꠟꠣ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤ ꠛꠣꠘꠣꠁꠅ। ꠜꠣꠟꠣ ꠃꠡ꠆ꠔꠣꠖ ꠇꠥꠘꠥ ꠖꠞ꠆ꠎꠤꠞꠦꠖꠤ ꠛꠣꠘꠣꠁꠅ। ꠄꠚꠞꠘꠞ ꠇꠣꠝꠞ ꠟꠣꠈꠣꠘ ꠁꠐꠣꠅ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ, ꠀꠞ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_16","003_28_16","EXO","28","16","16","ꠁꠐꠣ ꠅꠁꠛ ꠟꠣꠝ꠆ꠛꠣꠄ ꠀꠗꠣ ꠀꠔ, ꠙꠣꠡꠦ ꠀꠗꠣ ꠀꠔ, ꠌꠣꠁꠞ ꠇꠥꠘꠣ ꠀꠟꠣ ꠖꠥꠁ ꠜꠣꠁꠘ꠆ꠎ ꠇꠞꠣ ꠄꠇꠈꠣꠘ ꠇꠣꠙꠠ। ");
INSERT INTO syls_vpl VALUES ("EX28_17","003_28_17","EXO","28","17","17","ꠄꠞ ꠃꠙꠞꠦ ꠢꠣꠁꠞ ꠗꠞꠣꠁꠀ ꠌꠣꠁꠞ ꠢꠣꠁꠞ ꠙꠣꠔ꠆ꠔꠞ ꠟꠣꠉꠣꠁꠛꠣꠄ। ꠙꠄꠟꠣ ꠢꠣꠞꠤꠔ ꠁꠀꠇꠥꠔ, ꠙꠤꠔ, ꠀꠞ ꠙꠣꠘ꠆ꠘꠣ ꠝꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("EX28_18","003_28_18","EXO","28","18","18","ꠖꠥꠍꠞꠣ ꠢꠣꠞꠤꠔ ꠟꠣꠟꠝꠘꠤ, ꠟꠤꠟ ꠝꠘꠤ ꠀꠞ ꠢꠤꠞꠣ; ");
INSERT INTO syls_vpl VALUES ("EX28_19","003_28_19","EXO","28","19","19","ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠢꠣꠞꠤꠔ ꠚꠤꠞꠥꠎ, ꠉꠥꠝꠦꠖ ꠀꠞ ꠙꠖ꠆ꠖꠞꠣꠉ ꠝꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("EX28_20","003_28_20","EXO","28","20","20","ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠢꠣꠁꠞꠅ ꠙꠥꠈꠞꠣꠎ, ꠛꠂꠖꠥꠞ꠆ꠎ ꠀꠞ ꠡꠥꠞꠥꠎ ꠝꠘꠤ। ꠁ ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟ ꠡꠥꠘꠣꠞ ꠎꠣꠎꠁꠞꠖꠤ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_21","003_28_21","EXO","28","21","21","ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠛꠣꠞꠅꠐꠣ ꠙꠣꠔ꠆ꠔꠞ ꠟꠣꠉꠛ। ꠁꠔꠣ ꠄꠇꠅ ꠙꠣꠔ꠆ꠔꠞꠅ ꠄꠇ ꠄꠇ ꠙꠥꠀꠞ ꠘꠣꠝ ꠈꠥꠖꠤꠀ ꠟꠦꠈꠣꠁꠅ, ꠎꠦꠟꠣ ꠈꠥꠖꠤꠀ ꠡꠤꠟ ꠛꠣꠘꠣꠁꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EX28_22","003_28_22","EXO","28","22","22","“ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠞ ꠟꠣꠉꠤ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠞꠡꠤꠞ ꠟꠣꠈꠣꠘ ꠙꠦꠌꠣꠁꠀ ꠖꠥꠇꠍꠣ ꠌꠦꠁꠘ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_23","003_28_23","EXO","28","23","23","ꠡꠥꠘꠣꠞ ꠖꠥꠁꠐꠣ ꠇꠠꠣ ꠛꠣꠘꠣꠁꠀ ꠛꠥꠇꠥꠞ ꠅꠃ ꠕꠟꠤꠞ ꠃꠙꠞꠞ ꠇꠥꠘꠣꠔ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_24","003_28_24","EXO","28","24","24","ꠀꠞ ꠌꠦꠁꠘ ꠖꠥꠁꠅꠉꠦꠍꠣ ꠖꠥꠁꠅ ꠇꠠꠣꠞ ꠟꠉꠦ ꠀꠐꠇꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_25","003_28_25","EXO","28","25","25","ꠖꠥꠁꠅ ꠇꠣꠘ꠆ꠖꠞ ꠄꠚꠞꠘꠞ ꠍꠣꠝꠘꠞ ꠚꠤꠔꠣꠔ ꠡꠥꠘꠣꠞ ꠎꠣꠎꠁꠞꠞ ꠟꠉꠦ ꠌꠦꠁꠘꠞ ꠄꠇ ꠝꠣꠕꠣ ꠛꠣꠘ꠆ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_26","003_28_26","EXO","28","26","26","ꠀꠞꠅ ꠖꠥꠁꠐꠣ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠛꠣꠘꠣꠁꠀ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠞ ꠖꠥꠁ ꠇꠥꠘꠣꠔ ꠟꠣꠉꠣꠁꠅ। ꠁ ꠖꠥꠁꠅꠐꠣ ꠄꠚꠞꠘꠞ ꠟꠉꠦ ꠛꠥꠇꠥꠞ ꠕꠟꠤꠞ ꠔꠟꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX28_27","003_28_27","EXO","28","27","27","ꠛꠣꠖꠦ ꠀꠞꠅ ꠖꠥꠁꠐꠣ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠛꠣꠘꠣꠁꠀ, ꠄꠚꠞꠘꠞ ꠇꠣꠘ꠆ꠖꠞ ꠙꠐ꠆ꠐꠤꠞ ꠡꠁ ꠔꠟꠦꠖꠤ, ꠙꠦꠐꠞ ꠃꠙꠞꠞ ꠛꠦꠟꠐꠞ ꠃꠙꠞꠞ ꠡꠤꠟꠣꠁꠞ ꠇꠣꠍꠣꠔ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_28","003_28_28","EXO","28","28","28","ꠛꠣꠖꠦ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠞ ꠔꠟꠞ ꠇꠠꠣꠞ ꠟꠉꠦ ꠙꠦꠐꠞ ꠃꠙꠞꠞ ꠘꠇꠡꠣ ꠇꠞꠣ ꠛꠦꠟꠐꠞ ꠇꠠꠣ ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠅ। ꠔꠦꠃ ꠅꠃ ꠕꠟꠤ ꠄꠚꠞꠘꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠢꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX28_29","003_28_29","EXO","28","29","29","“ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠢꠣꠝꠣꠁꠛꠣꠞ ꠛꠣꠟꠣ ꠢꠣꠞꠥꠘꠦ ꠀꠝꠣꠞ ꠞꠣꠄ-ꠚꠄꠍꠣꠟꠣ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ, ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠞ ꠃꠙꠞꠦ ꠟꠦꠈꠣ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠙꠥꠀꠞ ꠘꠣꠝ ꠟꠣꠉꠣꠁꠔꠦ ꠅꠁꠛ, ꠁ ꠕꠟꠤꠐꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠞꠣꠈꠛ। ");
INSERT INTO syls_vpl VALUES ("EX28_30","003_28_30","EXO","28","30","30","ꠀꠝꠣꠞ ꠞꠣꠄ-ꠚꠄꠍꠣꠟꠣꠞ ꠅꠃ ꠕꠟꠤꠞ ꠜꠤꠔꠞꠦ ꠃꠞꠤꠝ ꠀꠞ ꠔꠥꠝ꠆ꠝꠤꠝ ꠘꠣꠝꠞ ꠙꠛꠤꠔ꠆ꠞ ꠙꠣꠔ꠆ꠔꠞꠉꠥꠁꠘ ꠞꠣꠈꠤꠅ। ꠢꠣꠞꠥꠘ ꠎꠦꠛꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠁꠔꠣ ꠔꠣꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠦ ꠞꠁꠛ। ꠢꠣꠞꠥꠘꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠞꠣꠄ-ꠚꠄꠍꠣꠟꠣ ꠎꠣꠘꠣꠞ ꠃꠙꠣꠄ ꠢꠤꠡꠣꠛꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠔꠣꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠦꠅꠀ ꠅꠃ ꠌꠤꠎ ꠞꠣꠈꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX28_31","003_28_31","EXO","28","31","31","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠄꠚꠞꠘꠞ ꠔꠟꠦ ꠟꠣꠝ꠆ꠛꠣ ꠎꠦ ꠀꠟꠈꠦꠟ꠆ꠟꠣ ꠞꠁꠛ, ꠁꠇꠐꠣ ꠙꠥꠞꠣꠐꠣꠃ ꠟꠤꠟꠥꠀ ꠞꠋꠉꠞ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_32","003_28_32","EXO","28","32","32","ꠝꠣꠕꠣ ꠢꠣꠞꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠄꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠚꠣꠇ ꠞꠣꠈꠤꠅ। ꠁ ꠚꠣꠇ ꠎꠣꠉꠣ ꠎꠣꠔꠦ ꠘꠣ ꠍꠤꠠꠦ, ꠄꠞꠟꠣꠉꠤ ꠄꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠛꠣꠁꠘ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX28_33","003_28_33","EXO","28","33","33","ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠞꠋꠉꠞ ꠡꠥꠔꠣꠖꠤ ꠀꠘꠥꠀꠞ ꠚꠟꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠘꠣꠁꠀ, ꠅꠃ ꠀꠟꠈꠦꠟ꠆ꠟꠣꠞ ꠔꠟꠞ ꠝꠥꠠꠤꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠟꠣꠉꠣꠁꠅ। ꠀꠞ ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠝꠣꠎꠦ ꠖꠤꠅ ꠡꠥꠘꠣꠞ ꠊꠥꠋꠉꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("EX28_34","003_28_34","EXO","28","34","34","ꠁ ꠝꠥꠠꠤꠔ ꠖꠤꠛꠣꠄ ꠄꠉꠥ ꠇꠞꠤ ꠀꠘꠥꠀꠞ ꠀꠞ ꠄꠉꠥ ꠊꠥꠋꠉꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("EX28_35","003_28_35","EXO","28","35","35","ꠁꠝꠣꠝꠔꠤ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠢꠣꠞꠥꠘꠦ ꠁ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠛ। ꠢꠦ ꠎꠦꠛꠟꠣ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠛ, ꠀꠞ ꠢꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠦ ꠛꠣꠞ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠅꠃ ꠊꠥꠋꠉꠥꠞ ꠅꠇꠟꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣ ꠎꠣꠁꠛ, ꠔꠦꠃ ꠢꠦ ꠝꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX28_36","003_28_36","EXO","28","36","36","“ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠄꠇꠈꠣꠘ ꠙꠣꠔ ꠛꠣꠘꠣꠁꠀ ꠄꠞ ꠃꠙꠞꠦ ꠡꠤꠟꠞ ꠟꠣꠈꠣꠘ ꠈꠥꠖꠤꠀ ꠅꠃ ꠀꠄꠀꠔ ꠟꠦꠈꠣꠁꠅ, ‘ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ।’ ");
INSERT INTO syls_vpl VALUES ("EX28_37","003_28_37","EXO","28","37","37","ꠁ ꠙꠣꠔꠈꠣꠘ ꠙꠣꠃꠉꠠꠤꠞ ꠍꠣꠝꠘꠞ ꠉꠣꠟꠣꠔ ꠟꠣꠉꠣꠁꠀ ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_38","003_28_38","EXO","28","38","38","ꠁꠐꠣ ꠢꠣꠞꠥꠘꠞ ꠇꠙꠣꠟꠞ ꠃꠙꠞꠦ ꠞꠁꠛ। ꠎꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠣꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠟꠁꠀ ꠀꠁꠛꠣ, ꠁꠔꠣꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠖꠥꠡ-ꠔꠤꠞꠥꠐꠤꠞ ꠜꠣꠞ ꠢꠣꠞꠥꠘꠦ ꠛꠁꠛ। ꠝꠣꠛꠥꠖꠦ ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠢꠣꠞꠥꠘꠦ ꠇꠙꠣꠟꠞ ꠃꠙꠞꠦ ꠁ ꠡꠥꠘꠣꠞ ꠙꠣꠔꠈꠣꠘ ꠢꠣꠝꠦꠡꠣ ꠟꠣꠉꠣꠁꠀ ꠞꠣꠈꠛ। ");
INSERT INTO syls_vpl VALUES ("EX28_39","003_28_39","EXO","28","39","39","ꠁꠝꠣꠝꠞ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ ꠀꠞ ꠙꠣꠃꠉꠠꠤ ꠔꠂꠀꠞ ꠇꠞꠣꠁꠅ ꠌꠦꠉꠞ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ। ꠇꠝꠞꠞ ꠛꠘ꠆ꠖꠘꠤ ꠈꠣꠘ ꠡꠥꠁ-ꠡꠥꠔꠣꠖꠤ ꠘꠇꠡꠣ ꠇꠞꠤ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_40","003_28_40","EXO","28","40","40","“ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠡꠥꠘ꠆ꠖꠞꠞ ꠟꠣꠉꠤ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ, ꠔꠇꠤ ꠀꠞ ꠇꠝꠞꠞ ꠛꠘ꠆ꠖꠘꠤ ꠔꠂꠀꠞ ꠇꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_41","003_28_41","EXO","28","41","41","ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠁ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠣꠁꠅ। ꠔꠣꠞꠣꠞ ꠝꠣꠕꠣꠔ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠓꠣꠟꠤꠀ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠣꠁꠀ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠅ। ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠁꠝꠣꠝ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX28_42","003_28_42","EXO","28","42","42","ꠇꠝꠞ ꠕꠣꠇꠤ ꠃꠞꠣꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠡꠞꠝꠞ ꠎꠣꠉꠣ ꠉꠥꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠢꠣꠚ-ꠙꠦꠘ꠆ꠐꠞ ꠟꠣꠈꠣꠘ ꠎꠣꠋꠉꠤꠀ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX28_43","003_28_43","EXO","28","43","43","ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ ꠎꠦꠛꠟꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠁꠛꠣ, ꠛꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠢꠣꠝꠣꠁꠀ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠅꠃ ꠎꠣꠋꠉꠤꠀ ꠚꠤꠘꠛꠣ। ꠔꠦꠃ ꠔꠣꠞꠣ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠞꠁꠛꠣ, ꠝꠞꠔꠣ ꠘꠣꠄ। ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠍꠤꠟꠍꠤꠟꠣꠞ ꠟꠣꠉꠤ ꠁ ꠀꠁꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠌꠣꠟꠥ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX29_1","003_29_1","EXO","29","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠅꠇꠟꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠤꠅ, ꠎꠣꠔꠦ ꠁꠝꠣꠝ ꠛꠘꠤꠀ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠣꠝ ꠌꠣꠟꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ। ꠔꠥꠝꠤ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠞ ꠖꠥꠉꠥ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠀꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_2","003_29_2","EXO","29","2","2","ꠄꠞꠟꠉꠦ ꠝꠄꠖꠣꠖꠤ ꠞꠥꠐꠤ, ꠔꠦꠟꠖꠤ ꠜꠣꠎꠣ ꠙꠤꠑꠣ, ꠀꠞ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠌꠣꠙꠣꠐꠤ ꠛꠣꠘꠣꠁꠅ। ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠔꠃ ꠈꠣꠝꠤꠞ ꠝꠤꠡꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_3","003_29_3","EXO","29","3","3","ꠅꠔꠣ ꠛꠣꠘꠣꠁꠀ ꠄꠇ ꠐꠥꠇꠞꠤꠔ ꠟꠁꠅ, ꠄꠞꠟꠉꠦ ꠢꠃ ꠛꠤꠍꠣꠟ ꠀꠞ ꠖꠥꠁꠅ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠟꠁꠀ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_4","003_29_4","EXO","29","4","4","ꠛꠣꠖꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠍꠣꠔ ꠀꠘꠤꠀ, ꠙꠣꠘꠤꠖꠤ ꠘꠣꠅꠀꠁ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_5","003_29_5","EXO","29","5","5","ꠀꠞ ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠅꠇꠟ ꠀꠘꠤꠀ ꠢꠣꠞꠥꠘꠞꠦ ꠚꠤꠘ꠆ꠖꠣꠁꠅ। ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ, ꠀꠟꠈꠦꠟ꠆ꠟꠣ, ꠄꠚꠞꠘ ꠀꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤ ꠢꠇꠟꠔꠣ ꠚꠤꠘ꠆ꠖꠣꠁꠅ। ꠄꠚꠞꠘꠞ ꠟꠉꠦ ꠃꠡ꠆ꠔꠣꠖꠤ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠢꠃ ꠙꠦꠐꠞ ꠃꠙꠞꠞ ꠛꠦꠟꠐ ꠈꠣꠘꠅ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_6","003_29_6","EXO","29","6","6","ꠔꠣꠞ ꠝꠣꠕꠣꠔ ꠙꠣꠃꠉꠠꠤ ꠚꠤꠘ꠆ꠖꠣꠁꠅ ꠀꠞ ꠡꠥꠘꠣꠞ ꠙꠣꠔꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠙꠛꠤꠔ꠆ꠞ ꠔꠣꠎ ꠈꠣꠘꠅ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_7","003_29_7","EXO","29","7","7","ꠛꠣꠖꠦ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ ꠔꠣꠞ ꠝꠣꠕꠣꠔ ꠓꠣꠟꠤꠀ ꠔꠣꠞꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_8","003_29_8","EXO","29","8","8","ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦꠅ ꠀꠘꠤꠀ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ ꠚꠤꠘ꠆ꠖꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_9","003_29_9","EXO","29","9","9","ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠇꠝꠞꠞ ꠛꠘ꠆ꠖꠘꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠅ। ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠝꠣꠕꠣꠔ ꠖꠤꠅ ꠔꠇꠤ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠁꠝꠣꠝꠞ ꠙꠖꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠤꠅ, ꠎꠣꠔꠦ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠘꠤꠅꠝ ꠢꠤꠡꠣꠛꠦ ꠁꠝꠣꠝꠔꠤꠞ ꠙꠖ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠛꠋꠡꠔ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("EX29_10","003_29_10","EXO","29","10","10","“ꠛꠣꠖꠦ ꠢꠃ ꠛꠤꠍꠣꠟꠞꠦ ꠔꠥꠝꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠤꠅ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠉꠥꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁꠀ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_11","003_29_11","EXO","29","11","11","ꠀꠔꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠅꠃ ꠛꠤꠍꠣꠟꠞꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠍꠣꠔ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠎꠛ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_12","003_29_12","EXO","29","12","12","ꠎꠛ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠕꠥꠠꠣ ꠟꠃ ꠔꠥꠝꠣꠞ ꠀꠋꠉꠥꠟꠤꠔ ꠟꠣꠉꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠤꠋꠉꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠣꠁꠅ, ꠀꠞ ꠛꠣꠇꠤ ꠟꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_13","003_29_13","EXO","29","13","13","ꠛꠤꠍꠣꠟꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠀꠔ-ꠜꠠꠞ ꠌꠞ꠆ꠛꠤ, ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ, ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠀꠞ ꠄꠞ ꠌꠞ꠆ꠛꠤ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_14","003_29_14","EXO","29","14","14","ꠄꠞ ꠉꠥꠡ꠆ꠔ, ꠈꠣꠟ, ꠀꠔ-ꠜꠠ ꠉꠥꠚꠞ ꠡꠥꠖ꠆ꠖꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠟꠤꠅ, ꠁꠔꠣ ꠔ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("EX29_15","003_29_15","EXO","29","15","15","“ꠛꠣꠖꠦ ꠢꠃ ꠖꠥꠁꠅ ꠝꠦꠠꠣ ꠕꠣꠇꠤ ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠘꠤꠅ, ꠀꠘꠟꠦ ꠢꠣꠞꠥꠘꠦ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠉꠥꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁꠀ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_16","003_29_16","EXO","29","16","16","ꠀꠞ ꠅꠃ ꠝꠦꠠꠣꠞꠦ ꠎꠛ ꠇꠞꠤꠀ ꠄꠞ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_17","003_29_17","EXO","29","17","17","ꠝꠦꠠꠣꠞꠦ ꠇꠣꠐꠤꠀ ꠐꠥꠇꠞꠣꠁꠀ ꠔꠣꠞ ꠑꠦꠋ ꠀꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣ ꠗꠁꠀ, ꠇꠟ꠆ꠟꠣ ꠀꠞ ꠛꠣꠇꠤ ꠐꠥꠇꠞꠣꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_18","003_29_18","EXO","29","18","18","ꠢꠦꠡꠦ ꠁ ꠀꠡ꠆ꠔꠣꠉꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠟꠤꠅ। ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠝꠣꠛꠥꠖꠞ ꠘꠤꠅꠔꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠍꠖꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_19","003_29_19","EXO","29","19","19","“ꠛꠣꠖꠦ ꠖꠥꠍꠞꠣ ꠝꠦꠠꠣꠞꠦꠅ ꠀꠘꠤꠀ ꠢꠣꠞꠥꠘꠦ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_20","003_29_20","EXO","29","20","20","ꠀꠔꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠅꠉꠥꠞꠦ ꠎꠛ ꠇꠞꠤꠀ ꠄꠞ ꠕꠥꠠꠣ ꠟꠃ ꠘꠤꠀ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠒꠣꠁꠘ ꠇꠣꠘꠞ ꠟꠔꠤꠔ, ꠒꠣꠁꠘ ꠀꠔꠞ ꠀꠞ ꠒꠣꠁꠘ ꠙꠣꠅꠞ ꠛꠥꠠꠤ ꠀꠋꠉꠥꠟꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠣꠁꠅ। ꠀꠞ ꠛꠣꠇꠤ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠍꠤꠐꠣꠁ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_21","003_29_21","EXO","29","21","21","ꠛꠣꠖꠦ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠟꠃ ꠟꠁꠀ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠉꠔꠞꠅ ꠀꠞ ꠟꠦꠛꠣꠍꠞ ꠃꠙꠞꠦ ꠍꠤꠐꠣꠁ ꠖꠤꠅ। ꠔꠦꠃ ꠟꠦꠛꠣꠍ ꠡꠥꠖ꠆ꠖꠣ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_22","003_29_22","EXO","29","22","22","ꠔꠥꠝꠤ ꠅꠃ ꠝꠦꠠꠣꠞ ꠌꠞ꠆ꠛꠤ, ꠌꠞ꠆ꠛꠤ ꠀꠟꠣ ꠟꠦꠋꠉꠥꠠ, ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ, ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ, ꠄꠞ ꠌꠞ꠆ꠛꠤ, ꠀꠞ ꠒꠣꠁꠘꠞ ꠞꠣꠘ ꠘꠤꠅ, ꠁꠐꠣ ꠅꠁꠟ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟꠞ ꠟꠣꠉꠤ ꠛꠈꠡꠤꠀ ꠖꠤꠛꠣꠞ ꠝꠦꠠꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_23","003_29_23","EXO","29","23","23","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞꠅ ꠕꠅꠀ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠐꠥꠇꠞꠤ ꠕꠣꠇꠤ ꠄꠇꠈꠣꠘ ꠞꠥꠐꠤ, ꠔꠦꠟꠖꠤ ꠜꠣꠎꠣ ꠄꠇꠈꠣꠘ ꠙꠤꠑꠣ ꠀꠞ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠌꠣꠙꠣꠐꠤ ꠄꠇꠈꠣꠘ ꠟꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_24","003_29_24","EXO","29","24","24","ꠟꠁꠀ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠀꠔꠅ ꠖꠤꠀ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠞꠣꠈꠣꠞ ꠘꠤꠅꠔꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠥꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX29_25","003_29_25","EXO","29","25","25","ꠀꠞ ꠅꠔꠣ ꠔꠣꠞꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠘꠤꠀ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ, ꠢꠃ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣꠄ। ꠁꠐꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠍꠖꠉꠣ। ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX29_26","003_29_26","EXO","29","26","26","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘꠞꠦ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠝꠦꠠꠣꠞ ꠍꠤꠘꠣꠞ ꠐꠥꠇꠞꠣ ꠟꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠥꠟꠣꠁꠛꠣꠄ। ꠁꠐꠣ ꠅꠁꠟ ꠔꠥꠝꠣꠞ ꠛꠣꠐ। ");
INSERT INTO syls_vpl VALUES ("EX29_27","003_29_27","EXO","29","27","27","ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟꠞ ꠟꠣꠉꠤ ꠖꠥꠟꠣꠁꠟ ꠅꠃ ꠍꠤꠘꠣ ꠀꠞ ꠞꠣꠘ ꠔꠥꠝꠤ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_28","003_29_28","EXO","29","28","28","ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠅꠀ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠐꠥꠇꠞꠣꠁꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠙꠣꠁꠛꠣ। ꠁꠔꠣ ꠅꠁꠛ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠅꠀ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠄꠇꠐꠣ ꠅꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("EX29_29","003_29_29","EXO","29","29","29","“ꠢꠣꠞꠥꠘꠞ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠅꠇꠟ ꠔꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠦ ꠙꠣꠁꠛꠣ। ꠅꠃ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠀ ꠔꠣꠞꠣ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠁꠛꠣ ꠀꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_30","003_29_30","EXO","29","30","30","ꠢꠣꠞꠥꠘꠞ ꠛꠣꠖꠦ ꠔꠣꠞ ꠎꠦ ꠙꠥꠀ ꠁꠝꠣꠝ ꠅꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠇꠣꠝ ꠇꠞꠛ, ꠢꠦ ꠡꠣꠔꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁ ꠟꠦꠛꠣꠍ ꠔꠣꠞ ꠉꠔꠞꠅ ꠞꠣꠈꠛ। ");
INSERT INTO syls_vpl VALUES ("EX29_31","003_29_31","EXO","29","31","31","“ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠝꠦꠠꠣꠞ ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠈꠣꠘꠣꠁꠘ ꠘꠤꠀ ꠇꠥꠘꠥ ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠉꠣꠔ ꠞꠣꠘ꠆ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX29_32","003_29_32","EXO","29","32","32","ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠍꠣꠔ ꠛꠁꠀ, ꠐꠥꠇꠞꠤꠔ ꠕꠅꠀ ꠢꠃ ꠞꠥꠐꠤꠞ ꠟꠉꠦ ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_33","003_29_33","EXO","29","33","33","ꠁꠝꠣꠝꠞ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠞꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠈꠣꠘꠤꠞ ꠎꠦꠔꠣ ꠌꠤꠎ ꠅꠇꠟ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠁꠔꠣ ꠈꠣꠟꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠈꠣꠁꠛꠣ। ꠀꠞ ꠇꠦꠃ ꠁꠔꠣ ꠈꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠁꠔꠣ ꠅꠁꠟ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠈꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_34","003_29_34","EXO","29","34","34","ꠅꠃ ꠛꠅꠀꠁꠟ ꠇꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠇꠥꠘꠥ ꠉꠥꠡ꠆ꠔ ꠛꠣ ꠞꠥꠐꠤ ꠎꠥꠖꠤ ꠛꠤꠀꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠞꠁꠎꠣꠄ, ꠔꠦ ꠁꠔꠣ ꠎꠣꠟꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ, ꠇꠦꠃ ꠈꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠁꠔꠣ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("EX29_35","003_29_35","EXO","29","35","35","“ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠣꠉꠤ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠔꠔꠣ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ, ꠔꠥꠝꠤ ꠅꠃꠟꠣ ꠇꠞꠤꠅ। ꠛꠅꠀꠁꠟ ꠇꠞꠣꠞ ꠅꠃ ꠇꠣꠝ ꠔꠥꠝꠤ ꠡꠣꠔꠖꠤꠘ ꠜꠞꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_36","003_29_36","EXO","29","36","36","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠤ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠄꠉꠥ ꠇꠞꠤ ꠛꠤꠍꠣꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ, ꠀꠞ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠟꠣꠉꠤ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠓꠣꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX29_37","003_29_37","EXO","29","37","37","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠔꠖꠤꠘ ꠜꠞꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ, ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ꠔꠦꠃ ꠁ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠄꠇ ꠝꠢꠣ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠉꠣ ꠅꠁꠛ। ꠎꠦꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠁ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠍꠥꠀꠁꠟꠦ, ꠁꠔꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX29_38","003_29_38","EXO","29","38","38","“ꠄꠞ ꠛꠣꠖ ꠕꠣꠇꠤ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠁ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ, ꠄꠇ ꠛꠞꠍ ꠛꠄꠅꠡꠞ ꠖꠥꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("EX29_39","003_29_39","EXO","29","39","39","ꠄꠉꠥ ꠛꠤꠀꠘꠦ ꠀꠞ ꠄꠉꠥ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX29_40","003_29_40","EXO","29","40","40","ꠙꠄꠟꠣ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠖꠥꠁ ꠡꠦꠞ ꠝꠄꠖꠣ ꠀꠞ ꠄꠇ ꠡꠦꠞ ꠎꠄꠔꠥꠘꠞ ꠙꠤꠡꠣ ꠔꠦꠟ ꠝꠤꠡꠣꠁꠔꠦ ꠅꠁꠛ। ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠀꠋꠉꠥꠞꠞ ꠄꠇ ꠡꠦꠞ ꠡꠞꠛꠔꠅ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX29_41","003_29_41","EXO","29","41","41","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠎꠦ ꠝꠦꠠꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ, ꠄꠞꠟꠉꠦꠅ ꠛꠤꠀꠘꠇꠥꠞ ꠟꠣꠈꠣꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠢꠇꠟꠔꠣ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠤꠅꠔꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("EX29_42","003_29_42","EXO","29","42","42","“ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ, ꠝꠣꠘꠤ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠁ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠢꠘꠅ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠝꠥ, ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX29_43","003_29_43","EXO","29","43","43","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠢꠘꠅ ꠖꠤꠖꠣꠞ ꠖꠤꠝꠥ, ꠀꠞ ꠀꠝꠣꠞ ꠇꠥꠖꠞꠔꠦ ꠅꠃ ꠎꠣꠉꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX29_44","003_29_44","EXO","29","44","44","ꠀꠝꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠝꠥ। ꠀꠝꠣꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦꠅ ꠀꠝꠤ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX29_45","003_29_45","EXO","29","45","45","ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠛꠥꠖ ꠅꠁꠀ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX29_46","003_29_46","EXO","29","46","46","ꠔꠦꠃ ꠔꠣꠞꠣ ꠎꠣꠘꠛꠣ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠣꠞꠣꠞ ꠝꠣꠛꠥꠖ। ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠔ ꠔꠣꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠤ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠣꠞꠣꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("EX30_1","003_30_1","EXO","30","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠄꠇꠈꠣꠘ ꠐꠦꠛꠥꠟ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX30_2","003_30_2","EXO","30","2","2","ꠁꠉꠥ ꠅꠁꠛ ꠌꠣꠁꠞꠇꠥꠘꠣ ꠀꠟꠣ, ꠄꠇ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ, ꠄꠇ ꠀꠔ ꠙꠣꠡ, ꠖꠥꠁ ꠀꠔ ꠃꠛꠤ। ꠀꠡ꠆ꠔꠣ ꠈꠣꠘꠃ ꠢꠤꠋ ꠡꠥꠖ꠆ꠖꠣ ꠄꠇꠈꠣꠘꠅ ꠟꠣꠉꠣꠁꠟ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX30_3","003_30_3","EXO","30","3","3","ꠄꠞ ꠃꠙꠞꠞ ꠍꠣꠘꠤ, ꠍꠣꠘꠤꠞ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠣ ꠀꠞ ꠢꠤꠋ, ꠢꠇꠟꠔꠣ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠛꠣꠄ। ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠅ ꠡꠥꠘꠣꠞ ꠘꠇꠡꠣ ꠇꠞꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX30_4","003_30_4","EXO","30","4","4","ꠄꠞ ꠖꠥꠁ ꠇꠤꠘꠣꠞꠞ ꠘꠇꠡꠣꠞ ꠔꠟꠦ ꠖꠥꠉꠥ ꠇꠞꠤ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠅ। ꠁ ꠇꠠꠣꠞ ꠜꠤꠔꠞꠦ ꠛꠦꠘ꠆ꠖꠣ ꠢꠣꠞꠣꠁꠀ ꠅꠉꠥ ꠛꠁꠀ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX30_5","003_30_5","EXO","30","5","5","ꠁ ꠛꠦꠘ꠆ꠖꠣ ꠉꠥꠁꠘ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠀ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX30_6","003_30_6","EXO","30","6","6","ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣꠞ ꠇꠣꠍꠣꠔ ꠎꠦ ꠙꠞ꠆ꠖꠣꠈꠣꠘ ꠀꠍꠦ, ꠅꠃ ꠐꠦꠛꠥꠟ ꠄꠞ ꠍꠣꠝꠘꠦ ꠞꠣꠈꠤꠅ। ꠅꠃ ꠎꠣꠉꠣꠔ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX30_7","003_30_7","EXO","30","7","7","“ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠌꠦꠞꠣꠉ ꠉꠥꠁꠘ ꠎꠥꠁꠔ-ꠎꠣꠁꠔ ꠇꠞꠣꠞ ꠛꠣꠟꠣ, ꠢꠣꠞꠥꠘꠦ ꠅꠃ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠀꠉꠞ ꠎꠣꠟꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX30_8","003_30_8","EXO","30","8","8","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠌꠦꠞꠣꠉ ꠎꠣꠟꠣꠘꠤꠞ ꠡꠝꠄ, ꠢꠦ ꠢꠤꠞꠛꠣꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠛ। ꠔꠥꠝꠞꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠅꠃ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("EX30_9","003_30_9","EXO","30","9","9","ꠁ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠅ ꠘꠣ। ꠇꠥꠘꠥ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠛꠣ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX30_10","003_30_10","EXO","30","10","10","ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠇꠚꠞꠣ ꠢꠤꠡꠣꠛꠦ, ꠢꠣꠞꠥꠘꠦ ꠛꠍꠞꠅ ꠄꠇꠛꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ, ꠐꠦꠛꠥꠟꠞ ꠢꠤꠋ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠔꠦ ꠅꠁꠛ। ꠔꠦꠃ ꠁꠈꠣꠘ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠝꠢꠣ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠛ। ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠛꠍꠞꠅ ꠄꠇꠛꠣꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX30_11","003_30_11","EXO","30","11","11","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX30_12","003_30_12","EXO","30","12","12","“ꠔꠥꠝꠤ ꠎꠦꠛꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠘꠡꠞ ꠙꠞꠤꠝꠣꠘ ꠉꠘꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠞꠥꠙꠣ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠎꠣꠔꠦ ꠁ ꠉꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠉꠎꠛ ꠘꠣ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("EX30_13","003_30_13","EXO","30","13","13","ꠔꠣꠞꠣꠞꠦ ꠉꠘꠣꠞ ꠛꠣꠟꠣ ꠅꠃꠟꠣ ꠛꠖꠟꠣ ꠟꠁꠅ, ꠉꠘꠣ ꠅꠁꠍꠦ ꠖꠟꠅ ꠎꠦꠞꠣ ꠢꠣꠝꠣꠁꠛꠣ, ꠄꠞꠣ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠀꠗꠣ ꠔꠟꠣ ꠞꠥꠙꠣ ꠖꠤꠛꠣ। ꠙꠞꠔꠦꠇ ꠛꠤꠡ ꠞꠔꠤꠄ ꠄꠇ ꠔꠟꠣ ꠉꠘꠤꠅ। ꠁ ꠞꠥꠙꠣ ꠅꠁꠛ ꠝꠣꠛꠥꠖꠞ। ");
INSERT INTO syls_vpl VALUES ("EX30_14","003_30_14","EXO","30","14","14","ꠛꠤꠡ ꠛꠞꠍ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠎꠦꠇꠥꠘꠥ ꠎꠘ ꠉꠘꠣ ꠡꠦꠡ ꠅꠀ ꠖꠟꠅ ꠢꠣꠝꠣꠁꠟꠦ, ꠄꠘ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠅꠃ ꠞꠥꠙꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX30_15","003_30_15","EXO","30","15","15","ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠗꠘꠤ ꠅꠇꠟꠦ ꠅꠃ ꠀꠗꠣ ꠔꠟꠣꠞ ꠛꠦꠡꠤ ꠖꠤꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣꠄ, ꠀꠞ ꠉꠞꠤꠛꠦꠅ ꠇꠝ ꠖꠤꠟꠦ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX30_16","003_30_16","EXO","30","16","16","ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠅꠃ ꠞꠥꠙꠣ ꠘꠤꠀ, ꠀꠝꠣꠞ ꠊꠞꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠅ। ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠁ ꠞꠥꠙꠣꠄ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠁꠀꠖ ꠇꠞꠣꠁ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX30_17","003_30_17","EXO","30","17","17","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX30_18","003_30_18","EXO","30","18","18","“ꠅꠎꠥ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠙꠤꠔꠟꠞ ꠄꠇꠐꠣ ꠉꠣꠝꠟꠣ, ꠀꠞ ꠉꠣꠝꠟꠣ ꠕꠅꠀꠞ ꠟꠣꠉꠤ ꠙꠤꠔꠟꠞ ꠄꠇꠈꠣꠘ ꠌꠇꠤ-ꠈꠣꠐ ꠛꠣꠘꠣꠁꠅ। ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠙꠣꠘꠤ ꠜꠞꠤꠀ ꠅꠉꠥ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX30_19","003_30_19","EXO","30","19","19","ꠁ ꠙꠣꠘꠤꠖꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠎꠥ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX30_20","003_30_20","EXO","30","20","20","ꠔꠣꠞꠣ ꠎꠣꠔꠦ ꠘꠣ ꠝꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠙꠞꠔꠦꠇꠛꠣꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠁꠛꠣꠞ ꠛꠣꠟꠣ ꠅꠃ ꠙꠣꠘꠤꠖꠤ ꠅꠎꠥ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠁꠝꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠎꠦꠇꠥꠘꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠡꠝꠄꠅ ꠅꠎꠥ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX30_21","003_30_21","EXO","30","21","21","ꠔꠣꠞꠣ ꠎꠣꠘꠦ ꠛꠣꠌꠤꠀ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠅꠃ ꠅꠎꠥ ꠇꠞꠛꠣ। ꠁ ꠢꠥꠇꠥꠝ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠌꠣꠟꠥ ꠞꠁꠛ, ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠛꠅꠀꠁꠟ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX30_22","003_30_22","EXO","30","22","22","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX30_23","003_30_23","EXO","30","23","23","“ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠉꠦꠍꠦ ꠈꠥꠡꠛꠄꠖꠣꠞ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠝꠡꠟꠣ ꠅꠇꠟ ꠖꠟꠣ ꠇꠞꠅ। ꠔꠥꠝꠤ ꠙꠣꠌ-ꠡ ꠔꠟꠣ ꠝꠥꠞꠣ ꠘꠣꠝꠞ ꠀꠔꠞ, ꠀꠠꠣꠁ-ꠡ ꠔꠟꠣ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠒꠣꠁꠟꠌꠤꠘꠤ, ꠀꠞ ꠀꠠꠣꠁ-ꠡ ꠔꠟꠣ ꠛꠍ, ");
INSERT INTO syls_vpl VALUES ("EX30_24","003_30_24","EXO","30","24","24","ꠡꠣꠗꠣꠞꠘ ꠒꠣꠁꠟꠌꠤꠘꠤ ꠙꠣꠌ-ꠡ ꠔꠟꠣ, ꠀꠞ ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ ꠌꠣꠁꠞ ꠡꠦꠞ ꠖꠟꠣ ꠇꠞꠤꠅ। ꠁ ꠝꠣꠙ ꠅꠁꠟ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ। ");
INSERT INTO syls_vpl VALUES ("EX30_25","003_30_25","EXO","30","25","25","ꠅꠃ ꠝꠡꠟꠣ ꠅꠇꠟ ꠖꠤꠀ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠝꠡꠟꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠇꠣꠞꠤꠉꠞꠞ ꠘꠤꠅꠝꠦ ꠔꠥꠝꠤ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠔꠦꠟ ꠛꠣꠘꠣꠁꠅ, ꠁ ꠔꠦꠟ ꠔ ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("EX30_26","003_30_26","EXO","30","26","26","ꠅꠃ ꠔꠦꠟ ꠖꠤꠀ ꠔꠥꠝꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ, ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ, ");
INSERT INTO syls_vpl VALUES ("EX30_27","003_30_27","EXO","30","27","27","ꠐꠦꠛꠥꠟ, ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠞ ꠢꠇꠟ ꠍꠣꠝꠣꠘꠣ, ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠢꠇꠟꠔꠣ, ꠀꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ, ");
INSERT INTO syls_vpl VALUES ("EX30_28","003_30_28","EXO","30","28","28","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠄꠞ ꠝꠣꠎꠞ ꠢꠇꠟ ꠍꠣꠝꠣꠘꠣ, ꠅꠎꠥꠞ ꠉꠣꠝꠟꠣ ꠀꠞ ꠄꠞ ꠔꠟꠞ ꠌꠇꠤ-ꠈꠣꠐ ꠢꠇꠟꠔꠣꠞꠦ ꠚꠥꠍꠤꠀ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX30_29","003_30_29","EXO","30","29","29","ꠔꠦꠃ ꠁ ꠢꠇꠟꠔꠣ ꠝꠢꠣ-ꠙꠛꠤꠔ꠆ꠞ ꠍꠣꠝꠣꠘꠣ ꠅꠁꠛ। ꠁꠔꠣ ꠍꠣꠝꠣꠘꠣ ꠇꠦꠃ ꠍꠁꠟꠦ, ꠢꠦ-ꠅ ꠝꠢꠣ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("EX30_30","003_30_30","EXO","30","30","30","“ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘꠞꠦ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘꠞꠦ ꠀꠝꠣꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ ꠖꠤꠀ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX30_31","003_30_31","EXO","30","31","31","ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠤꠅ, ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠁꠐꠣꠃ ꠅꠁꠛ ꠀꠝꠣꠞ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX30_32","003_30_32","EXO","30","32","32","ꠁ ꠔꠦꠟ ꠝꠣꠘꠡꠞ ꠉꠔꠞꠅ ꠖꠦꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠁ ꠘꠤꠅꠝꠦ ꠔꠣꠞꠣ ꠎꠣꠔꠦ ꠀꠞ ꠇꠥꠘꠥ ꠔꠦꠟ ꠘꠣ ꠛꠣꠘꠣꠄ। ꠁ ꠔꠦꠟ ꠔ ꠙꠛꠤꠔ꠆ꠞ। ꠔꠥꠝꠞꠣ ꠁꠐꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠘꠅ ꠇꠞꠤꠀ ꠁꠎ꠆ꠎꠔ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX30_33","003_30_33","EXO","30","33","33","ꠇꠦꠃ ꠎꠥꠖꠤ ꠁ ꠟꠣꠈꠣꠘ ꠔꠦꠟ ꠔꠂꠀꠞ ꠇꠞꠦ, ꠛꠣ ꠁꠝꠣꠝ ꠍꠣꠛ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠁ ꠔꠦꠟ ꠉꠔꠞꠅ ꠝꠣꠈꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠘꠤꠎꠞ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠤꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX30_34","003_30_34","EXO","30","34","34","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠘꠤꠎꠞ ꠉꠦꠍꠦ ꠇꠤꠍꠥ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠝꠡꠟꠣ: ꠉꠥꠉꠉꠥꠟꠥ, ꠘꠈꠤ, ꠇꠥꠘ꠆ꠖꠥꠞꠥ ꠀꠞ ꠈꠣꠐꠤ ꠟꠥꠛꠣꠘ ꠖꠟꠣ ꠇꠞꠤꠅ। ꠖꠟꠣ ꠇꠞꠤꠀ ꠅꠔꠣ ꠢꠝꠣꠘ ꠢꠝꠣꠘ ꠇꠞꠤ ꠝꠤꠡꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX30_35","003_30_35","EXO","30","35","35","ꠀꠞ ꠎꠦꠞꠣ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠛꠣꠘꠣꠁꠘ, ꠔꠣꠞꠣꠞꠦꠖꠤ ꠅꠃ ꠇꠣꠝ ꠇꠞꠣꠁꠅ। ꠁꠔꠣꠞ ꠟꠉꠦ ꠘꠥꠘ ꠝꠤꠡꠣꠁꠅ, ꠁꠔꠣ ꠅꠁꠛ ꠘꠤꠞꠜꠦꠎꠣꠟ ꠈꠣꠐꠤ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠀꠉꠞ। ");
INSERT INTO syls_vpl VALUES ("EX30_36","003_30_36","EXO","30","36","36","ꠅꠃ ꠀꠉꠞꠞ ꠕꠥꠠꠣ ꠉꠥꠠꠣ ꠘꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠅ। ꠢꠘꠅ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠝꠥ। ꠔꠥꠝꠞꠣ ꠁ ꠀꠉꠞꠞꠦ ꠝꠢꠣ-ꠙꠛꠤꠔ꠆ꠞ ꠍꠣꠝꠣꠘꠣ ꠝꠘꠅ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX30_37","003_30_37","EXO","30","37","37","ꠅꠃ ꠝꠡꠟꠣ ꠖꠤꠀ ꠁ ꠘꠤꠅꠝꠦ ꠇꠦꠃ ꠎꠣꠔꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠘꠣ ꠛꠣꠘꠣꠄ। ꠁꠔꠣ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠌꠤꠎ, ꠁꠈꠣꠘ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX30_38","003_30_38","EXO","30","38","38","ꠈꠥꠡꠛꠄꠖꠣꠞ ꠌꠤꠎ ꠝꠘꠅ ꠇꠞꠤꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠔꠣ ꠔꠂꠀꠞ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠁ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠤꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX31_1","003_31_1","EXO","31","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX31_2","003_31_2","EXO","31","2","2","“ꠢꠥꠘꠅ, ꠀꠝꠤ ꠄꠢꠥꠖꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠢꠥꠞꠞ ꠘꠣꠔꠤ, ꠃꠞꠤꠞ ꠙꠥꠀ ꠛꠣꠔꠍꠦꠟꠟꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX31_3","003_31_3","EXO","31","3","3","ꠀꠝꠤ ꠔꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠁ ꠞꠥꠢꠥ ꠖꠤꠀ ꠇꠣꠝꠤꠟ ꠇꠞꠍꠤ। ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠇꠣꠞꠤꠉꠞꠤ ꠇꠣꠝꠞ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ, ꠛꠤꠖ꠆ꠖꠣꠄ ꠃꠡ꠆ꠔꠣꠖꠤ ꠇꠣꠝꠞ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX31_4","003_31_4","EXO","31","4","4","ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠙꠤꠔꠟꠞ ꠃꠙꠞꠦ ꠡꠥꠘ꠆ꠖꠞ ꠡꠥꠘ꠆ꠖꠞ ꠘꠇꠡꠣ ꠛꠣꠘꠣꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("EX31_5","003_31_5","EXO","31","5","5","ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ ꠇꠣꠐꠤꠀ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣ ꠟꠣꠉꠣꠘꠤ, ꠟꠣꠇꠠꠤꠞ ꠃꠙꠞꠦ ꠘꠇꠡꠣꠞ ꠇꠣꠝ ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠀꠔꠞ ꠇꠣꠝ ꠇꠞꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("EX31_6","003_31_6","EXO","31","6","6","ꠔꠣꠞ ꠎꠥꠉꠣꠟꠤ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠤ ꠖꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠅꠢꠤꠍꠣꠝꠣꠇꠞ ꠙꠥꠀ ꠀꠢꠟꠤꠀꠛꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ। ꠎꠦ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟꠦ ꠁ ꠇꠣꠝ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ, ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠇꠣꠝꠞ ꠀꠈꠟ ꠖꠤꠍꠤ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞꠦ ꠛꠣꠔꠣꠁꠟ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠣꠞꠣ ꠛꠣꠘꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX31_7","003_31_7","EXO","31","7","7","ꠔꠣꠞꠣ ꠛꠣꠘꠣꠁꠛꠣ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ, ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ, ꠄꠞ ꠃꠙꠞꠞ ꠓꠣꠇꠘꠣ, ꠔꠣꠝ꠆ꠛꠥꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("EX31_8","003_31_8","EXO","31","8","8","ꠐꠦꠛꠥꠟ, ꠐꠦꠛꠥꠟꠞ ꠟꠉꠞ ꠌꠤꠎ ꠅꠇꠟ, ꠈꠣꠐꠤ ꠡꠥꠘꠣꠞ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ, ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠟꠉꠞ ꠢꠇꠟꠔꠣ ꠀꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ, ");
INSERT INTO syls_vpl VALUES ("EX31_9","003_31_9","EXO","31","9","9","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠄꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠢꠣꠘ꠆ꠒꠤ-ꠛꠣꠡꠘ, ꠅꠎꠥꠞ ꠙꠣꠘꠤꠞ ꠉꠣꠝꠟꠣ ꠀꠞ ꠄꠞ ꠌꠇꠤ-ꠈꠣꠐ, ");
INSERT INTO syls_vpl VALUES ("EX31_10","003_31_10","EXO","31","10","10","ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠥꠘꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠟꠦꠛꠣꠍ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠦꠛꠣꠍ, ");
INSERT INTO syls_vpl VALUES ("EX31_11","003_31_11","EXO","31","11","11","ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ, ꠙꠣꠇ ꠎꠣꠉꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠀꠉꠞ। ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠛꠣꠘꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX31_12","003_31_12","EXO","31","12","12","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX31_13","003_31_13","EXO","31","13","13","“ꠔꠥꠝꠤ ꠘꠤꠎꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠙꠞꠔꠦꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠝꠣꠘꠤꠅ। ꠁ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠄꠇ ꠘꠤꠡꠣꠘꠣ ꠅꠁꠛ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ, ꠀꠞ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠛꠘ꠆ꠖꠣ ꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠟꠣꠖꠣ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EX31_14","003_31_14","EXO","31","14","14","“ꠔꠥꠝꠞꠣ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠝꠣꠘꠤꠅ, ꠅꠃ ꠖꠤꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠇ ꠖꠤꠘ ꠇꠞꠣ ꠅꠁꠍꠦ। ꠇꠦꠃ ꠎꠥꠖꠤ ꠁ ꠖꠤꠘ ꠘꠣ ꠝꠣꠘꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠁꠖꠤꠘ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ ꠇꠞꠛ, ꠔꠣꠞꠦ ꠔꠣꠞ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX31_15","003_31_15","EXO","31","15","15","ꠔꠥꠝꠞꠣ ꠢꠣꠙ꠆ꠔꠣꠞ ꠍꠄꠖꠤꠘ ꠇꠣꠝ ꠇꠞꠤꠅ, ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠞꠣꠝꠞ ꠖꠤꠘ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ। ꠡꠥꠇ꠆ꠞꠛꠣꠞ ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣ ꠕꠣꠇꠤ ꠡꠘꠤꠛꠣꠞ ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ। ꠁ ꠖꠤꠘ ꠎꠦ ꠝꠣꠘꠡꠦ ꠇꠣꠝ ꠇꠞꠛ, ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX31_16","003_31_16","EXO","31","16","16","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠦ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠘꠤꠅꠝ ꠢꠤꠡꠣꠛꠦ, ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠁ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠝꠣꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX31_17","003_31_17","EXO","31","17","17","ꠁ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠞ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠟꠣꠉꠤ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠄꠇ ꠘꠤꠡꠣꠘꠣ। ꠇꠣꠞꠘ ꠍꠄꠖꠤꠘꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠢꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠟꠣ, ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠇꠥꠘꠥ ꠇꠣꠝ ꠘꠣ ꠇꠞꠤꠀ ꠎꠤꠞꠣꠁꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX31_18","003_31_18","EXO","31","18","18","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠅꠃ ꠛꠣꠔꠌꠤꠔ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠝꠥꠍꠣꠞ ꠀꠔꠅ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠡꠣꠢꠣꠖꠔ ꠙꠣꠔ꠆ꠔꠞ ꠖꠤꠟꠣ। ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠔꠦ ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠟꠦꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX32_1","003_32_1","EXO","32","1","1","ꠝꠥꠍꠣ ꠘꠛꠤ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠔꠦ ꠖꠦꠞꠤ ꠅꠞ ꠖꠦꠈꠤꠀ, ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠢꠣꠞꠥꠘꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠖꠟꠣ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞꠦ ꠙꠕ ꠌꠤꠘꠣꠁꠀ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ, ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠖꠦꠛꠔꠣ ꠛꠣꠘꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠇꠣꠞꠘ, ꠎꠦ ꠝꠥꠍꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠦ, ꠔꠣꠞ ꠇꠤꠔꠣ ꠊꠐꠍꠦ ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX32_2","003_32_2","EXO","32","2","2","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠃ ꠀꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠇꠣꠘꠅ ꠕꠣꠇꠤ ꠡꠥꠘꠣꠞ ꠉꠄꠘꠣ ꠈꠥꠟꠤꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX32_3","003_32_3","EXO","32","3","3","ꠔꠦꠃ ꠢꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠇꠣꠘꠞ ꠉꠄꠘꠣ ꠈꠥꠟꠤꠀ ꠢꠣꠞꠥꠘꠞ ꠉꠦꠍꠦ ꠀꠘꠤꠀ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX32_4","003_32_4","EXO","32","4","4","ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠡꠥꠘꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠢꠣꠞꠥꠘꠦ ꠅꠔꠣ ꠘꠤꠀ ꠀꠉꠥꠁꠘꠖꠤ ꠉꠟꠣꠁꠀ, ꠢꠥꠘꠣꠞꠞ ꠀꠔꠤꠀꠞꠖꠤ ꠄꠇ ꠛꠣꠍꠥꠞꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠟꠣ। ꠅꠉꠥ ꠖꠦꠈꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁ ꠅꠇꠟ, ꠅꠃ ꠄꠁꠘꠃ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠛꠔꠣ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX32_5","003_32_5","EXO","32","5","5","ꠁ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠢꠣꠞꠥꠘꠦ ꠢꠃ ꠛꠣꠍꠥꠞꠞ ꠍꠣꠝꠘꠦ ꠄꠇ ꠛꠟꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠀ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣ, “ꠍꠣꠝꠘꠞ ꠇꠣꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX32_6","003_32_6","EXO","32","6","6","ꠔꠦꠃ ꠛꠣꠖꠞ ꠖꠤꠘ ꠈꠥꠛ ꠍꠛꠞꠦ ꠃꠑꠤꠀ ꠝꠣꠘꠡꠦ ꠖꠦꠛꠔꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠝꠋꠉꠟ ꠛꠟꠤ ꠀꠞ ꠙꠡꠥ ꠎꠣꠟꠣꠁꠀ ꠛꠟꠤ ꠖꠤꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠤꠀ ꠢꠣꠞꠤ, ꠢꠂ-ꠢꠥꠟ꠆ꠟꠣ ꠇꠞꠤ ꠘꠣꠌ-ꠉꠣꠘ, ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX32_7","003_32_7","EXO","32","7","7","ꠅꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠙꠣꠠꠞ ꠟꠣꠝꠣꠔ ꠎꠣꠅ। ꠔꠥꠝꠣꠞ ꠅꠃ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍ, ꠁꠔꠣ ꠔ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠘꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX32_8","003_32_8","EXO","32","8","8","ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠌꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣꠝ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠛꠣꠖ ꠖꠤꠀ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠄꠇ ꠛꠣꠍꠥꠞꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠀ, ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀ ꠅꠉꠥꠞꠦ ꠙꠞꠘꠣꠝ ꠇꠞꠦꠞ। ꠅꠉꠥꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣ ꠙꠡꠥ ꠛꠟꠤ ꠖꠦꠞ ꠀꠞ ꠇꠞ, ꠜꠣꠁ ꠅꠇꠟ, ꠅꠃ ꠄꠁꠘꠃ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠛꠔꠣ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX32_9","003_32_9","EXO","32","9","9","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠁꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠌꠤꠘꠤ, ꠁꠔꠣ ꠔ ꠉꠣꠠꠔꠦꠠꠣ-ꠄꠇꠉꠥꠁꠀ ꠎꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("EX32_10","003_32_10","EXO","32","10","10","ꠅꠈꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠛꠣꠗꠣ ꠖꠤꠅ ꠘꠣ, ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠉꠥꠍꠣ ꠀꠉꠥꠁꠘꠞ ꠟꠣꠈꠣꠘ ꠖꠣꠃ ꠖꠣꠃ ꠇꠞꠤ ꠎꠟꠦꠞ, ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠍꠣꠞꠈꠣꠞ ꠇꠞꠤꠟꠤꠝꠥ। ꠛꠣꠖꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠇ ꠝꠢꠣ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX32_11","003_32_11","EXO","32","11","11","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠖꠤꠀ ꠔꠥꠝꠣꠞ ꠝꠢꠣ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠎꠦꠔꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍ, ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠅꠔ ꠉꠥꠍꠣ ꠅꠁꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("EX32_12","003_32_12","EXO","32","12","12","ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠇꠦꠘꠦ ꠁꠈꠣꠘ ꠝꠣꠔꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠔꠣ, ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠔ ꠀꠘꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠈꠔꠝ ꠇꠞꠤꠀ, ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍ? ꠝꠣꠛꠥꠖ ꠉ, ꠔꠥꠝꠣꠞ ꠁ ꠛꠦꠕꠣꠄꠀ ꠉꠥꠍꠣꠈꠣꠘ ꠔꠥꠝꠤ ꠕꠣꠝꠣꠁꠟꠣꠅ। ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ, ꠔꠥꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠁ ꠉꠎꠛꠈꠣꠘ ꠀꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX32_13","003_32_13","EXO","32","13","13","ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠉꠥꠟꠣꠝ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠅ। ꠔꠥꠝꠤ ꠘꠤꠎꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠍꠟꠣꠄ, ꠔꠣꠞꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠤ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠠꠣꠁꠛꠣꠄ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠅꠃ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣꠅ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠛꠣꠄ, ꠀꠞ ꠔꠣꠞꠣ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠟꠣꠉꠤ ꠄꠞ ꠖꠈꠟ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX32_14","003_32_14","EXO","32","14","14","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠅꠁꠟ। ꠔꠣꠁꠘ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠎꠦ ꠉꠎꠛ ꠓꠣꠟꠤꠔꠣ ꠌꠣꠁꠍꠟꠣ, ꠁꠔꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX32_15","003_32_15","EXO","32","15","15","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠖꠥꠁꠅꠈꠣꠘ ꠡꠣꠢꠣꠖꠔ ꠙꠣꠔ꠆ꠔꠞ ꠟꠁꠀ ꠟꠣꠝꠣꠔ ꠀꠁꠟꠣ। ꠁ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠟꠐꠣ-ꠜꠣꠐꠤꠅꠟ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠔ ꠟꠦꠈꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX32_16","003_32_16","EXO","32","16","16","ꠁ ꠖꠥꠁꠅ ꠙꠣꠔ꠆ꠔꠞ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠘꠤꠎꠞ ꠀꠔꠞ ꠇꠣꠝ, ꠀꠞ ꠁ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠈꠥꠖꠤꠀ ꠟꠦꠈꠣ ꠈꠣꠘꠅ ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠔꠞ ꠟꠦꠈꠣ। ");
INSERT INTO syls_vpl VALUES ("EX32_17","003_32_17","EXO","32","17","17","ꠝꠥꠍꠣꠞ ꠈꠣꠖꠤꠝ ꠁꠃꠍꠣꠄ ꠝꠣꠘꠡꠞ ꠁꠔꠣ ꠢꠂ-ꠢꠥꠟ꠆ꠟꠣ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠀꠝꠞꠣꠞ ꠇꠦꠝ꠆ꠙꠞ ꠝꠣꠎꠦ ꠎꠥꠖ꠆ꠖꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣ ꠎꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("EX32_18","003_32_18","EXO","32","18","18","ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠔ ꠇꠥꠘꠥ ꠎꠥꠖ꠆ꠖꠞ ꠀꠞꠣ-ꠎꠤꠔꠣꠞ ꠀꠅꠀꠎ ꠘꠣꠄ। ꠀꠝꠤ ꠎꠦꠔꠣ ꠢꠥꠘꠤꠀꠞ, ꠁꠔꠣ ꠔ ꠉꠣꠘꠞ ꠀꠅꠀꠎꠞ ꠟꠣꠈꠣꠘ ꠟꠣꠉꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("EX32_19","003_32_19","EXO","32","19","19","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠇꠦꠝ꠆ꠙꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠀ ꠝꠣꠘꠡꠞ ꠘꠣꠌꠣ-ꠘꠣꠌꠤ ꠀꠞ ꠛꠣꠍꠥꠞꠞ ꠝꠥꠞ꠆ꠔꠤ ꠖꠦꠈꠟꠣ। ꠖꠦꠈꠤꠀꠃ ꠔꠣꠁꠘ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠀ, ꠀꠔꠞ ꠙꠣꠔ꠆ꠔꠞ ꠖꠥꠁꠅꠈꠣꠘ ꠁꠐꠣ ꠝꠣꠞꠤ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ। ꠔꠦꠃ ꠙꠣꠔ꠆ꠔꠞ ꠖꠥꠁꠅꠈꠣꠘ ꠙꠣꠠꠞ ꠔꠟꠦ ꠙꠠꠤꠀ ꠌꠥꠞꠝꠣꠞ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX32_20","003_32_20","EXO","32","20","20","ꠀꠞ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠛꠣꠍꠥꠞꠞ ꠝꠥꠞ꠆ꠔꠤ ꠘꠤꠀ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ꠛꠣꠖꠦ ꠅꠉꠥꠞꠦ ꠙꠤꠡꠤꠀ ꠉꠥꠠꠣ ꠛꠣꠘꠣꠁꠀ ꠙꠣꠘꠤꠔ ꠝꠤꠡꠣꠁꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞꠦ ꠈꠣꠅꠀꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX32_21","003_32_21","EXO","32","21","21","ꠔꠣꠁꠘ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠍꠤꠟ, ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠔꠣꠞꠣꠞꠦꠖꠤ ꠡꠤꠞꠤꠇꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("EX32_22","003_32_22","EXO","32","22","22","ꠢꠣꠞꠥꠘꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠝꠣꠟꠤꠇ, ꠀꠙꠘꠦ ꠉꠥꠍꠣ ꠇꠞꠂꠘ ꠘꠣ ꠎꠣꠘꠥ, ꠀꠙꠘꠦ ꠔ ꠎꠣꠘꠂꠘꠃ, ꠁꠔꠣ ꠝꠣꠘꠥꠡ ꠈꠣꠟꠤ ꠈꠣꠞꠣꠙ ꠇꠣꠝꠞ ꠀꠡꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("EX32_23","003_32_23","EXO","32","23","23","ꠔꠣꠞꠣ ꠀꠁꠀ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠀꠝꠞꠣꠞꠦ ꠙꠕ ꠌꠤꠘꠣꠁꠀ ꠟꠁꠀ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠖꠦꠛꠔꠣ ꠛꠣꠘꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠇꠣꠞꠘ ꠎꠦ ꠝꠥꠍꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠄꠘ ꠇꠤꠔꠣ ꠅꠁꠍꠦ, ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤꠀꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX32_24","003_32_24","EXO","32","24","24","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠡꠥꠘꠣ-ꠖꠣꠘꠣ ꠀꠍꠦ, ꠅꠔꠣ ꠈꠥꠟꠤꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠅ। ꠔꠣꠞꠣ ꠀꠘꠤꠀ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠤꠟꠣ, ꠀꠞ ꠀꠝꠤ ꠅꠈꠘꠣꠁꠘ ꠁꠐꠣ ꠝꠣꠞꠤ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠟꠣꠝ, ꠔꠦꠃ ꠅꠃ ꠛꠣꠍꠥꠞ ꠅꠉꠥ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("EX32_25","003_32_25","EXO","32","25","25","ꠝꠥꠍꠣꠄ ꠖꠦꠈꠟꠣ, ꠁ ꠝꠣꠘꠥꠡ ꠉꠥꠁꠘ ꠛꠦꠙꠞꠥꠀ ꠅꠁꠉꠦꠍꠂꠘ। ꠔꠣꠁꠘ ꠛꠥꠎꠟꠣ, ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠦꠙꠞꠥꠀ ꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠦ ꠀꠡꠤꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX32_26","003_32_26","EXO","32","26","26","ꠅꠃ ꠝꠥꠍꠣꠄ ꠇꠦꠝ꠆ꠙꠞ ꠉꠦꠁꠐꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠔ ꠎꠘ ꠝꠣꠛꠥꠖꠞ ꠙꠇ꠆ꠇꠦ ꠀꠍ, ꠢꠇꠟ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠅ।” ꠔꠦꠃ ꠟꠦꠛꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX32_27","003_32_27","EXO","32","27","27","ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠇꠝꠞꠅ ꠔꠟꠥꠀꠞ ꠛꠣꠘ꠆ꠖꠅ, ꠀꠞ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠎꠣꠞꠦ ꠍꠣꠝꠘꠦ ꠙꠣꠅ ꠎꠣꠘꠦ ꠝꠣꠞꠅ। ꠀꠡ꠆ꠔꠣ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠜꠣꠁ-ꠛꠘ꠆ꠖꠥ, ꠀꠞꠤ-ꠚꠞꠤ ꠎꠣꠞꠦ ꠙꠣꠅ ꠝꠣꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX32_28","003_32_28","EXO","32","28","28","ꠔꠦꠃ ꠟꠦꠛꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠣꠘꠡꠦ ꠝꠥꠍꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠟꠣ। ꠢꠤ ꠖꠤꠘ ꠅꠘꠥꠝꠣꠘ ꠔꠤꠘ ꠀꠎꠣꠞ ꠝꠣꠘꠥꠡ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX32_29","003_32_29","EXO","32","29","29","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠁꠎ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠣꠞꠎꠤꠞ ꠙꠥꠀ ꠀꠞ ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞꠞ ꠃꠙꠞꠦ ꠀꠔ ꠔꠥꠟꠔꠦ ꠈꠞꠦꠖꠤ ꠉꠦꠍ ꠘꠣ, ꠝꠣꠛꠥꠖꠞ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠟꠣꠖꠣ ꠅꠁꠍ, ꠄꠞꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝꠔ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX32_30","003_32_30","EXO","32","30","30","ꠛꠣꠖꠞ ꠖꠤꠘ ꠝꠥꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠛꠦꠎꠥꠁꠔꠣ ꠉꠥꠘꠣ ꠇꠞꠍ। ꠔꠦ ꠀꠝꠤ ꠅꠈꠘ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠞ ꠙꠣꠠꠅ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠎꠣꠁꠞꠣꠝ, ꠙꠣꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠘꠥ ꠙꠕ ꠛꠣꠞ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX32_31","003_32_31","EXO","32","31","31","ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠉꠤꠀ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠁ ꠝꠣꠘꠥꠡ ꠉꠥꠁꠘ꠆ꠔꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠉꠥꠘꠣ ꠇꠞꠤꠟꠤꠍꠦ। ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠡꠥꠘꠣꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX32_32","003_32_32","EXO","32","32","32","ꠔꠦ ꠔꠥꠝꠤ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞꠦ ꠅꠈꠘ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠅ, ꠀꠞ ꠎꠥꠖꠤ ꠝꠣꠚ ꠘꠣ ꠇꠞꠅ, ꠔꠣꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠟꠦꠈꠣ ꠈꠣꠔꠣ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠘꠣꠝꠈꠣꠘꠅ ꠇꠣꠐꠤꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX32_33","003_32_33","EXO","32","33","33","ꠝꠣꠛꠥꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠦꠞꠣ ꠉꠥꠘꠣ ꠇꠞꠍꠦ, ꠀꠝꠤ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠘꠣꠝꠞꠦꠃ ꠀꠝꠣꠞ ꠈꠣꠔꠣ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX32_34","003_32_34","EXO","32","34","34","ꠔꠦ ꠔꠥꠝꠤ ꠅꠈꠘ ꠎꠣꠅꠉꠤ, ꠀꠞ ꠀꠝꠤ ꠎꠦ ꠖꠦꠡꠞ ꠇꠕꠣ ꠇꠁꠍꠤ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠢꠃ ꠖꠦꠡꠅ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠅ। ꠀꠝꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠕ ꠖꠦꠈꠣꠁꠀ ꠘꠤꠛꠣ। ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠡꠣꠎꠣ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠀꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX32_35","003_32_35","EXO","32","35","35","ꠢꠣꠞꠥꠘꠞ ꠀꠔꠦ ꠛꠣꠘꠣꠁꠟ ꠢꠃ ꠛꠣꠍꠥꠞꠞ ꠝꠥꠞ꠆ꠔꠤꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠇꠞꠍꠤꠟꠣ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX33_1","003_33_1","EXO","33","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠎꠣꠅ, ꠔꠥꠝꠤ ꠅꠃ ꠎꠦꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠀꠘꠍ, ꠄꠞꠣꠞꠦ ꠟꠁꠀ ꠅꠈꠘꠃ ꠁ ꠎꠣꠉꠣ ꠍꠣꠠꠤꠀ ꠎꠣꠅꠉꠤ। ꠀꠝꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠅ। ꠀꠝꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣꠝ, ꠔꠣꠞꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠅꠃ ꠖꠦꠡ ꠅꠇꠟ ꠖꠤꠝꠥ, ꠔꠦ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠢꠘꠅ ꠎꠣꠅꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX33_2","003_33_2","EXO","33","2","2","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠇꠞꠤ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠙꠣꠑꠣꠁꠝꠥ। ꠄꠁꠘ ꠉꠤꠀ ꠢꠘꠞ ꠇꠦꠘꠣꠘꠤ, ꠀꠝꠥꠞꠤ, ꠢꠤꠐ꠆ꠐꠤ, ꠚꠣꠞꠤꠎꠤ, ꠢꠤꠛ꠆ꠛꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX33_3","003_33_3","EXO","33","3","3","ꠁꠔꠣ ꠔ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠖꠦꠡ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠉꠣꠠꠔꠦꠠꠣ-ꠄꠇꠉꠥꠁꠀ ꠎꠣꠔ, ꠇꠤꠎꠣꠘꠥ ꠀꠝꠤ ꠙꠕꠞ ꠝꠣꠎꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠙꠣꠔ ꠇꠞꠤꠟꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("EX33_4","003_33_4","EXO","33","4","4","ꠁ ꠛꠤꠙꠖꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠟꠣꠉꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠇꠦꠃ ꠇꠥꠘꠥꠎꠣꠔ ꠉꠄꠘꠣ-ꠉꠣꠐꠤ ꠚꠤꠘꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX33_5","003_33_5","EXO","33","5","5","ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠍꠟꠣ, “ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞꠦ ꠇꠅ, ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠉꠣꠠꠔꠦꠠꠣ-ꠄꠇꠉꠥꠁꠀ ꠎꠣꠔ। ꠀꠝꠤ ꠄꠇ ꠙꠟꠇꠞ ꠟꠣꠉꠤ ꠉꠦꠟꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠙꠣꠔ ꠇꠞꠤꠟꠤꠝꠥ। ꠔꠥꠝꠞꠣꠞ ꠉꠔꠞꠅ ꠕꠣꠇꠤ ꠢꠇꠟ ꠉꠄꠘꠣ-ꠉꠣꠐꠤ ꠈꠥꠟꠤꠟꠣꠅ, ꠔꠦꠃ ꠀꠝꠤ ꠛꠥꠎꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("EX33_6","003_33_6","EXO","33","6","6","ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠥꠞ ꠙꠣꠠꠅꠃ ꠔꠣꠞꠣꠞ ꠉꠄꠘꠣ-ꠉꠣꠐꠤ ꠢꠇꠟꠔꠣ ꠈꠥꠟꠤꠟꠤꠟꠣ, ꠁꠔꠣ ꠀꠞ ꠚꠤꠘꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX33_7","003_33_7","EXO","33","7","7","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠄꠇ ꠔꠣꠝ꠆ꠛꠥ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠖꠥꠞꠁ ꠘꠤꠀ ꠅꠃ ꠔꠣꠝ꠆ꠛꠥ ꠙꠣꠔꠤꠔꠣ, ꠁ ꠔꠣꠝ꠆ꠛꠥꠞꠦ ꠔꠣꠁꠘ ꠈꠣꠘꠦꠇꠣ-ꠔꠣꠝ꠆ꠛꠥ ꠇꠁꠀ ꠒꠣꠇꠤꠔꠣ। ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠎꠣꠘꠔꠦ ꠌꠣꠁꠟꠦ ꠔꠣꠞꠣ ꠅꠃ ꠈꠣꠘꠦꠇꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX33_8","003_33_8","EXO","33","8","8","ꠝꠥꠍꠣ ꠎꠦꠛꠟꠣ ꠢꠤ ꠈꠣꠘꠦꠇꠣ ꠡꠞꠤꠚꠅ ꠞꠅꠀꠘꠣ ꠖꠤꠔꠣ, ꠅꠃ ꠡꠝꠄ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠥꠡ ꠎꠣꠞꠎꠤꠞ ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠅ ꠃꠛꠣꠁꠔꠣ ꠀꠞ ꠝꠥꠍꠣ ꠈꠣꠘꠦꠇꠣꠔ ꠘꠣ ꠢꠣꠝꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇꠟꠦ ꠔꠣꠘ ꠛꠣꠄ ꠌꠣꠁ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("EX33_9","003_33_9","EXO","33","9","9","ꠔꠣꠁꠘ ꠢꠤ ꠈꠣꠘꠦꠇꠣ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠛꠣꠖꠦꠃ ꠀꠟ꠆ꠟꠣꠁ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠈꠣꠘꠦꠇꠣꠞ ꠖꠥꠀꠞꠞ ꠝꠥꠈꠅ ꠟꠣꠝꠤꠀ ꠀꠁꠔ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠎꠔꠛꠁꠟ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣ, ꠅꠔꠛꠁꠟ ꠁ ꠈꠥꠐꠤ ꠅꠘꠅ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("EX33_10","003_33_10","EXO","33","10","10","ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣꠃ ꠁ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠞꠦ ꠈꠣꠘꠦꠇꠣꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠖꠦꠈꠔ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("EX33_11","003_33_11","EXO","33","11","11","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠖꠥꠡ꠆ꠔꠞ ꠟꠉꠦ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠛꠁꠀ ꠎꠦꠟꠣ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠦ, ꠝꠣꠛꠥꠖꠦꠅ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠅꠃꠟꠣ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣ। ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠇꠦꠝ꠆ꠙꠅ ꠚꠤꠞꠤꠀ ꠀꠁꠔꠣ, ꠅꠁꠟꠦ ꠔꠣꠘ ꠈꠣꠖꠤꠝ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ ꠘꠣꠝꠞ ꠁ ꠎꠥꠀꠘ, ꠈꠣꠘꠦꠇꠣ ꠡꠞꠤꠚ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX33_12","003_33_12","EXO","33","12","12","ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠔ ꠇꠁꠞꠣꠄ ꠀꠝꠤ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠎꠣꠁꠔꠣꠝꠉꠤ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠞ ꠇꠣꠞꠦ ꠖꠤꠞꠣꠄ, ꠁꠈꠣꠘ ꠔ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣꠄ ꠘꠣ। ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠇꠁꠟꠣꠄ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠘ ꠝꠘꠅ ꠇꠞꠅ ꠀꠞ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠘꠎꠞꠅ ꠞꠣꠈꠍ। ");
INSERT INTO syls_vpl VALUES ("EX33_13","003_33_13","EXO","33","13","13","ꠔꠦ ꠢꠣꠍꠣꠃ ꠎꠥꠖꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠘꠎꠞꠅ ꠕꠣꠇꠤ, ꠔꠣꠁꠟꠦ ꠔꠥꠝꠤ ꠇꠥꠘ ꠈꠤꠀꠟꠦ ꠇꠤꠔꠣ ꠇꠞꠅ, ꠅꠔꠣ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠣꠅ, ꠎꠣꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠘꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠞꠢꠝꠔꠞ ꠝꠣꠎꠦ ꠞꠁ। ꠔꠥꠝꠤ ꠔ ꠎꠣꠘꠃ, ꠁ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠔꠥꠝꠣꠞꠃ ꠙ꠆ꠞꠎꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX33_14","003_33_14","EXO","33","14","14","ꠝꠣꠛꠥꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠘꠤꠎꠦꠃ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠁꠝꠥ ꠀꠞ ꠔꠥꠝꠣꠞꠦ ꠀꠞꠣꠝ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("EX33_15","003_33_15","EXO","33","15","15","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠘꠣ ꠎꠣꠅ, ꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠁꠘ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX33_16","003_33_16","EXO","33","16","16","ꠔꠥꠝꠤ ꠘꠣ ꠉꠦꠟꠦ ꠝꠣꠘꠡꠦ ꠇꠤꠟꠣ ꠛꠥꠎꠛꠣ, ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠁ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠣꠞ ꠞꠢꠝꠔ ꠀꠍꠦ? ꠀꠝꠞꠣꠃ ꠎꠦꠘ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠀꠟꠣꠖꠣ, ꠁꠈꠣꠘ ꠇꠤꠟꠣ ꠛꠥꠎꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("EX33_17","003_33_17","EXO","33","17","17","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠑꠤꠇ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠎꠦꠟꠣ ꠇꠁꠟꠣꠄ, ꠀꠝꠤ ꠅꠟꠣ ꠇꠞꠝꠥ। ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠘꠎꠞꠅ ꠀꠍ, ꠔꠥꠝꠣꠞꠦ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠀꠙꠘ ꠝꠘꠅ ꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("EX33_18","003_33_18","EXO","33","18","18","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠔꠦ ꠔꠥꠝꠣꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠅꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX33_19","003_33_19","EXO","33","19","19","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠣꠞꠦ ꠈꠥꠡꠤ ꠖꠄꠀ ꠇꠞꠝꠥ, ꠀꠞ ꠎꠣꠞꠦ ꠈꠥꠡꠤ ꠞꠢꠝ ꠇꠞꠝꠥ। ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦꠖꠤ ꠀꠝꠤ ꠀꠝꠣꠞ ꠢꠇ꠆ꠇꠟ ꠘꠦꠇ ꠍꠥꠞꠔ ꠎꠣꠁꠞ ꠇꠞꠝꠥ। ‘ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠀꠍꠂꠘ’ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠅꠃ ꠘꠣꠝ ꠄꠟꠣꠘ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX33_20","003_33_20","EXO","33","20","20","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠝꠥꠈ ꠖꠦꠈꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠔꠥꠝꠣꠞ ꠅꠁꠔ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠤꠟ꠆ꠟꠦ ꠇꠥꠘꠥ ꠀꠖꠝ ꠎꠣꠔ ꠛꠣꠌꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX33_21","003_33_21","EXO","33","21","21","ꠔꠦ ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠞ ꠅꠃ ꠎꠣꠉꠣ ꠛꠣꠄ ꠌꠣꠅ, ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠙꠣꠔ꠆ꠔꠞꠞ ꠄꠇ ꠕꠣꠇ ꠀꠍꠦ, ꠅꠃ ꠕꠣꠇꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠤ ꠃꠛꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EX33_22","003_33_22","EXO","33","22","22","ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠖꠤꠀ ꠀꠝꠣꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠚꠣꠐꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠞꠣꠁꠝꠥ। ꠀꠝꠤ ꠘꠣ ꠎꠣꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠝꠣꠞ ꠀꠔ ꠖꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX33_23","003_33_23","EXO","33","23","23","ꠛꠣꠖꠦ ꠀꠝꠣꠞ ꠀꠔ ꠢꠞꠣꠁꠟꠦ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠈꠞ ꠉꠣꠟꠣ ꠖꠦꠈꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠇꠦꠃ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("EX34_1","003_34_1","EXO","34","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠉꠞ ꠙꠣꠔ꠆ꠔꠞꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠤ ꠘꠄꠀ ꠖꠥꠈꠣꠘ ꠙꠣꠔ꠆ꠔꠞ ꠔꠤꠀꠞ ꠇꠞꠅ। ꠔꠥꠝꠤ ꠎꠦ ꠖꠥꠈꠣꠘ ꠜꠣꠋꠉꠤꠍꠟꠣꠄ, ꠢꠤ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠎꠦ ꠢꠥꠇꠥꠝ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, ꠅꠃ ꠢꠥꠇꠥꠝ ꠅꠇꠟ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠁ ꠖꠥꠁꠅ ꠙꠣꠔ꠆ꠔꠞꠅ ꠟꠦꠈꠤꠀ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX34_2","003_34_2","EXO","34","2","2","ꠚꠎꠞ ꠛꠣꠖꠦꠃ ꠔꠥꠝꠤ ꠔꠤꠀꠞ ꠅꠁꠀ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠅ। ꠃꠑꠤꠀ ꠙꠣꠠꠞ ꠝꠣꠕꠣꠔ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX34_3","003_34_3","EXO","34","3","3","ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠀꠘꠤꠅ ꠘꠣ, ꠁ ꠙꠣꠠꠞ ꠇꠥꠘꠥꠈꠣꠘꠅ ꠎꠣꠔꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠘꠣ ꠀꠄ। ꠙꠣꠠꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠇꠥꠘꠥ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠛꠣ ꠝꠦꠠꠣ-ꠝꠦꠠꠤꠞꠦ ꠞꠣꠈꠔꠦ ꠖꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX34_4","003_34_4","EXO","34","4","4","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠀꠉꠞ ꠙꠣꠔ꠆ꠔꠞꠞ ꠟꠣꠈꠣꠘ ꠖꠥꠈꠣꠘ ꠙꠣꠔ꠆ꠔꠞ ꠛꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠚꠎꠞꠦ ꠃꠑꠤꠀ ꠙꠣꠔ꠆ꠔꠞ ꠖꠥꠁꠅꠈꠣꠘ ꠀꠔꠅ ꠟꠁꠀ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_5","003_34_5","EXO","34","5","5","ꠀꠞ ꠝꠣꠛꠥꠖꠅ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤꠞ ꠝꠣꠎꠦ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ। ꠔꠣꠁꠘ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠗꠣꠞꠅ ꠃꠛꠣꠁꠀ ꠔꠣꠘ “ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠀꠍꠂꠘ” ꠘꠣꠝ ꠄꠟꠣꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_6","003_34_6","EXO","34","6","6","ꠔꠣꠁꠘ ꠝꠥꠍꠣꠞ ꠍꠣꠝꠘꠣ ꠖꠤꠀ ꠔꠡꠞꠤꠚ ꠘꠤꠟꠣ, ꠀꠞ ꠅꠃ ꠇꠣꠟꠣꠝ ꠄꠟꠣꠘ ꠇꠞꠤ ꠇꠞꠤ ꠉꠦꠟꠣ, “ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠀꠍꠂꠘ, ꠞꠢꠝꠣꠘ ꠀꠞ ꠞꠢꠤꠝ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠁꠘ ꠉꠥꠍꠣ ꠇꠞꠂꠘ ꠗꠤꠞ ꠉꠔꠤꠄ, ꠔꠣꠘ ꠅꠛꠤꠞꠣꠝ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠀꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤꠞ ꠇꠥꠘꠥ ꠡꠤꠝꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("EX34_7","003_34_7","EXO","34","7","7","ꠔꠣꠁꠘ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠅꠀꠞꠤꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠛꠤꠞꠣꠝ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠝꠣꠘꠡꠞ ꠅꠁꠘ꠆ꠘꠣꠄ-ꠅꠙꠞꠣꠗ, ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠖꠦꠁꠘ, ꠅꠁꠟꠦ ꠖꠥꠡꠤ ꠎꠘꠞꠦ ꠡꠣꠎꠣꠅ ꠖꠦꠁꠘ। ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠡꠣꠎꠣ, ꠔꠣꠞꠣꠞ ꠘꠣꠔꠤ-ꠙꠥꠔꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠞ꠆ꠔꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX34_8","003_34_8","EXO","34","8","8","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠝꠥꠍꠣ ꠘꠛꠤ ꠟꠉꠦ ꠟꠉꠦ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX34_9","003_34_9","EXO","34","9","9","“ꠅ ꠝꠣꠟꠤꠇ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠞꠢꠝꠔ ꠙꠣꠁ, ꠔꠦ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠔꠥꠝꠤꠅ ꠀꠝꠞꠣꠞ ꠟꠉ ꠈꠣꠘꠅ ꠌꠟꠅ। ꠅꠃ ꠎꠣꠔꠤ ꠎꠥꠖꠤꠅ ꠈꠥꠛ ꠉꠣꠠꠔꠦꠠꠣ-ꠄꠇꠉꠥꠁꠀ ꠎꠣꠔ, ꠔꠣ-ꠅ ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞ ꠉꠥꠘꠣ ꠀꠞ ꠇꠍꠥꠞꠤꠞꠦ ꠝꠣꠚ ꠇꠞꠤꠀ ꠖꠤꠟꠣꠅ। ꠀꠝꠞꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠙ꠆ꠞꠎꠣ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠤꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("EX34_10","003_34_10","EXO","34","10","10","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠄꠇ ꠃꠍꠤꠟ꠆ꠟꠣ ꠛꠅꠀꠁꠟ ꠇꠞꠤꠀꠞ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠝꠥ, ꠎꠦꠔꠣ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠇꠥꠘꠥ ꠎꠣꠔꠤꠞ ꠍꠣꠝꠘꠦ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ। ꠔꠥꠝꠤ ꠅꠃ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣꠄ, ꠔꠣꠞꠣ ꠖꠦꠈꠛꠣ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠤꠔꠣ ꠇꠞꠤꠀꠞ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣꠞ ꠎꠣꠘꠅ ꠒꠞ ꠢꠣꠝꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX34_11","003_34_11","EXO","34","11","11","ꠀꠝꠤ ꠀꠁꠎ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠝꠥ, ꠁꠔꠣ ꠈꠤꠀꠟ ꠇꠞꠤ ꠀꠝꠟ ꠇꠞꠅ। ꠀꠝꠤ ꠀꠝꠥꠞꠤ, ꠇꠦꠘꠣꠘꠤ, ꠢꠤꠐ꠆ꠐꠤ, ꠚꠣꠞꠤꠎꠤ, ꠢꠤꠛ꠆ꠛꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠣ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("EX34_12","003_34_12","EXO","34","12","12","ꠅꠁꠟꠦ ꠈꠛꠞꠖꠣꠞ! ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡꠅ ꠎꠣꠁꠞꠣꠄ, ꠁ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞꠘꠣꠄ ꠚꠣꠘ꠆ꠖꠅ ꠢꠣꠝꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX34_13","003_34_13","EXO","34","13","13","ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠙꠥꠎꠣ-ꠝꠘ꠆ꠒꠙ ꠜꠣꠋꠉꠤꠀ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠛꠣꠄ, ꠔꠣꠞꠣꠞ ꠛꠟꠤ ꠈꠣꠘꠣꠁꠘ ꠜꠣꠋꠉꠤꠟꠤꠛꠣꠄ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠀꠡꠦꠞꠣ-ꠖꠦꠛꠤꠞ ꠘꠤꠡꠣꠘꠣ ꠈꠥꠐꠤ ꠅꠇꠟ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX34_14","003_34_14","EXO","34","14","14","ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠔ ꠟꠣ-ꠡꠞꠤꠇ ꠝꠣꠛꠥꠖ, ꠇꠥꠘꠥ ꠡꠞꠤꠇ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤ ꠘꠣ, ꠀꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠄꠛꠣꠖꠔ ꠀꠝꠤ ꠌꠣꠁꠃ ꠌꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("EX34_15","003_34_15","EXO","34","15","15","“ꠢꠃ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞꠘꠣꠄ ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠡꠤꠞꠤꠇꠤ ꠇꠣꠝꠞ ꠘꠤꠅꠔꠦ, ꠔꠣꠞꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠎꠞꠦ ꠡꠙꠤꠀ ꠖꠤꠛꠣ, ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠛꠟꠤ ꠖꠤꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠖꠣꠅꠔ ꠖꠤꠛꠣ ꠀꠞ ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠅꠃ ꠛꠟꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX34_16","003_34_16","EXO","34","16","16","ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠖꠤꠛꠣꠄ, ꠀꠞ ꠅꠃ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠖꠦꠛꠔꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠡꠤꠞꠤꠇꠤ ꠇꠣꠝ ꠇꠞꠛꠣ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦꠅ ꠐꠣꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_17","003_34_17","EXO","34","17","17","“ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_18","003_34_18","EXO","34","18","18","“ꠔꠥꠝꠞꠣ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠡꠣꠔ ꠖꠤꠘ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠅ। ꠀꠛꠤꠛ ꠌꠣꠘ꠆ꠖꠞ ꠑꠤꠇ ꠇꠞꠣ ꠔꠣꠞꠤꠈꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠅꠃ ꠌꠣꠘ꠆ꠖꠅ ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX34_19","003_34_19","EXO","34","19","19","“ꠔꠥꠝꠞꠣꠞ ꠙꠦꠐꠞ ꠙꠄꠖꠣ ꠢꠇꠟ ꠙꠄꠟꠣ ꠙꠥꠀ ꠀꠝꠣꠞ ꠅꠁꠛ। ꠄꠞꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠛꠣ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠅ ꠀꠝꠣꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX34_20","003_34_20","EXO","34","20","20","ꠈꠣꠟꠤ ꠉꠣꠗꠤꠘ꠆ꠔꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠛꠖꠟꠣ, ꠀꠝꠣꠞꠦ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠛꠖꠟꠣ ꠖꠤꠀ ꠅꠉꠥꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠘꠤꠅ। ꠈꠣꠟꠣꠍ ꠘꠣ ꠇꠞꠣꠁꠟꠦ ꠅꠉꠥꠞ ꠉꠞ꠆ꠖꠘꠣ ꠜꠣꠋꠉꠤꠟꠤꠅ। ꠔꠥꠝꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠛꠠ ꠙꠥꠀꠂꠘꠞꠦ ꠅꠟꠣ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠁ ꠘꠤꠅ। “ꠢꠥꠘꠅ, ꠁꠖꠞ ꠡꠝꠄ ꠇꠦꠃ ꠈꠣꠟꠤ ꠀꠔꠦ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_21","003_34_21","EXO","34","21","21","“ꠢꠣꠙ꠆ꠔꠣꠞ ꠍꠄꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠇꠣꠝ ꠇꠞꠤꠅ, ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠎꠤꠞꠣꠁꠅ। ꠈꠦꠔ ꠇꠞꠣ ꠀꠞ ꠚꠡꠟ ꠖꠣꠅꠀꠞ ꠛꠣꠟꠣꠅ ꠎꠤꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX34_22","003_34_22","EXO","34","22","22","“ꠅꠃ ꠔꠤꠘꠅ ꠁꠖ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠤꠅ, ꠙꠘ꠆ꠌꠣꠁꠡꠣ ꠁꠖ, ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠖꠣꠅꠀ ꠉꠝ ꠖꠤꠀ ꠘꠄꠀ ꠚꠡꠟꠞ ꠁꠖ, ꠀꠞ ꠛꠍꠞꠞ ꠢꠦꠡ ꠝꠣꠡꠅ ꠛꠣꠉꠣꠘꠞ ꠙꠣꠇꠘꠣ ꠚꠟ ꠛꠣꠠꠤꠔ ꠀꠘꠤꠀ ꠒꠦꠞꠣ-ꠊꠞꠞ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX34_23","003_34_23","EXO","34","23","23","ꠛꠍꠞꠅ ꠔꠤꠘꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ ꠀꠁꠀ ꠢꠎ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠎꠤꠞ ꠅꠁꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_24","003_34_24","EXO","34","24","24","ꠀꠝꠤ ꠢꠃ ꠖꠦꠡꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠝꠥ। ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣ ꠛꠣꠠꠣꠁꠀ ꠛꠠ ꠇꠞꠝꠥ। ꠔꠥꠝꠞꠣ ꠛꠍꠞꠅ ꠔꠤꠘꠛꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠉꠣ-ꠎꠝꠤꠘꠞ ꠛꠣꠄ ꠇꠦꠃ ꠟꠣꠟꠌ ꠇꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX34_25","003_34_25","EXO","34","25","25","“ꠀꠝꠣꠞ ꠘꠣꠝꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠟꠤꠟ꠆ꠟꠣ-ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ ꠘꠣ। ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠇꠥꠘꠥꠎꠣꠔ ꠈꠣꠘꠤ ꠛꠤꠀꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_26","003_34_26","EXO","34","26","26","“ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠖꠣꠅꠀ ꠙꠄꠟꠣ ꠚꠡꠟꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠅꠋꠡ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠊꠞꠅ ꠟꠁꠀ ꠀꠁꠅ। “ꠀꠞ ꠢꠥꠘꠅ, ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠉꠥꠡ꠆ꠔ ꠔꠣꠞ ꠝꠣʼꠞ ꠖꠥꠗꠖꠤ ꠞꠣꠘ꠆ꠖꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX34_27","003_34_27","EXO","34","27","27","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠁ ꠇꠣꠟꠣꠝ ꠅꠇꠟ ꠟꠦꠈꠤꠀ ꠕꠅ। ꠀꠝꠤ ꠅꠃ ꠇꠣꠟꠣꠝ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠝꠤꠟꠘꠞ ꠃꠍꠤꠟ꠆ꠟꠣ ꠛꠅꠀꠁꠟ ꠇꠞꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("EX34_28","003_34_28","EXO","34","28","28","ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣ ꠘꠛꠤ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ ꠝꠣꠛꠥꠖꠞ ꠗꠣꠞꠅ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠞꠁꠟꠣ। ꠔꠣꠁꠘ ꠇꠥꠘꠥꠎꠣꠔ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ ꠈꠣꠁꠟꠣ ꠘꠣ। ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠖꠥꠁꠅ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠅꠃ ꠀꠄꠀꠔ ꠅꠇꠟ, ꠝꠣꠘꠤ ꠡꠞꠤꠅꠔꠞ ꠖꠡꠐꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠟꠦꠈꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_29","003_34_29","EXO","34","29","29","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠡꠣꠢꠣꠖꠔ ꠙꠣꠔ꠆ꠔꠞ ꠖꠥꠁꠅꠈꠣꠘ ꠀꠔꠅ ꠟꠁꠀ ꠔꠥꠞ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ। ꠝꠣꠛꠥꠖꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠣꠄ ꠝꠥꠍꠣꠞ ꠝꠥꠈꠞ ꠍꠥꠞꠔ ꠘꠥꠞꠣꠘꠤ ꠅꠁꠉꠦꠟ, ꠅꠁꠟꠦ ꠝꠥꠍꠣꠄ ꠁꠈꠣꠘ ꠐꠦꠞ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_30","003_34_30","EXO","34","30","30","ꠅꠃ ꠡꠝꠄ ꠢꠣꠞꠥꠘ ꠀꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠥꠍꠣꠞ ꠘꠥꠞꠣꠘꠤ ꠍꠥꠞꠔ ꠖꠦꠈꠟꠣ, ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠇꠣꠍꠣꠔ ꠀꠁꠔꠦ ꠒꠞꠣꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_31","003_34_31","EXO","34","31","31","ꠅꠁꠟꠦ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠒꠣꠇ ꠖꠤꠟꠣ, ꠔꠦꠃ ꠢꠣꠞꠥꠘ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟꠣ, ꠀꠞ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_32","003_34_32","EXO","34","32","32","ꠛꠣꠖꠦ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠔꠣꠘ ꠇꠣꠍꠣꠔ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠦꠅꠀ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_33","003_34_33","EXO","34","33","33","ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔ-ꠇꠕꠣ ꠡꠦꠡ ꠅꠁꠉꠦꠟꠦ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠘꠥꠞꠣꠘꠤ ꠌꠦꠢꠣꠞꠣ ꠟꠥꠇꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠥꠈꠅ ꠙꠞ꠆ꠖꠣ ꠟꠣꠉꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_34","003_34_34","EXO","34","34","34","ꠅꠁꠟꠦ ꠝꠥꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠦꠇꠣꠞ ꠜꠤꠔꠞꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠎꠣꠁꠔꠣ, ꠅꠃ ꠡꠝꠄ ꠁ ꠙꠞ꠆ꠖꠣ ꠈꠥꠟꠤꠟꠤꠔꠣ। ꠛꠣꠖꠦ ꠛꠣꠞꠦ ꠀꠁꠀ ꠙꠞ꠆ꠖꠣ ꠟꠣꠉꠣꠁꠔꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠢꠥꠇꠥꠝ ꠅꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX34_35","003_34_35","EXO","34","35","35","ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠖꠦꠈꠔꠣ ꠝꠥꠍꠣꠞ ꠝꠥꠈ ꠘꠥꠞꠣꠘꠤ ꠅꠁꠉꠦꠍꠦ। ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠝꠥꠈ ꠉꠥꠞꠤꠟꠤꠔꠣ ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠘ ꠝꠥꠈ ꠉꠥꠞꠣ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("EX35_1","003_35_1","EXO","35","1","1","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠉꠥꠡ꠆ꠐꠤꠞꠦ ꠖꠟꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠔꠣꠘ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EX35_2","003_35_2","EXO","35","2","2","ꠔꠥꠝꠞꠣ ꠢꠣꠙ꠆ꠔꠣꠞ ꠍꠄꠖꠤꠘ ꠇꠣꠝ ꠇꠞꠤꠅ, ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠖꠤꠘ, ꠀꠞꠣꠝꠞ ꠖꠤꠘ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ। ꠁ ꠖꠤꠘ ꠎꠦ ꠝꠣꠘꠡꠦ ꠇꠣꠝ ꠇꠞꠛ, ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX35_3","003_35_3","EXO","35","3","3","ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠦꠃꠞꠞ ꠊꠞꠅ ꠀꠉꠥꠁꠘ ꠎꠣꠟꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX35_4","003_35_4","EXO","35","4","4","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("EX35_5","003_35_5","EXO","35","5","5","ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠖꠤꠟꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ ꠟꠁꠀ ꠀꠅ। ꠀꠘꠣꠞ ꠡꠝꠄ ꠅꠃꠟꠣ ꠌꠤꠎ ꠅꠇꠟ ꠟꠤꠟ꠆ꠟꠣ ꠀꠘꠤꠅ: ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠙꠤꠔꠟ; ");
INSERT INTO syls_vpl VALUES ("EX35_6","003_35_6","EXO","35","6","6","ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠞꠋꠉꠞ ꠡꠥꠔꠣ; ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠀꠞ ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣ; ");
INSERT INTO syls_vpl VALUES ("EX35_7","003_35_7","EXO","35","7","7","ꠟꠣꠟ ꠞꠋ ꠟꠣꠉꠣꠁꠟ ꠝꠦꠠꠣꠞ ꠌꠣꠝꠠꠣ, ꠚꠥʼꠞ ꠌꠣꠝꠠꠣ; ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤ; ");
INSERT INTO syls_vpl VALUES ("EX35_8","003_35_8","EXO","35","8","8","ꠌꠦꠞꠣꠉ ꠎꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ; ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠔꠦꠟꠞ ꠝꠡꠟꠣ ꠀꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠛꠣꠘꠣꠘꠤꠞ ꠝꠡꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("EX35_9","003_35_9","EXO","35","9","9","ꠁꠝꠣꠝꠞ ꠄꠚꠞꠘ ꠀꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠔ ꠟꠣꠉꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠇꠤꠇ ꠝꠘꠤ ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("EX35_10","003_35_10","EXO","35","10","10","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠣꠞꠣ ꠜꠣꠟꠣ ꠃꠡ꠆ꠔꠣꠖ ꠇꠣꠞꠤꠉꠞ, ꠔꠣꠞꠣ ꠀꠁꠀ ꠅꠃ ꠢꠇꠟꠔꠣ ꠛꠣꠘꠣꠁꠛꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ: ");
INSERT INTO syls_vpl VALUES ("EX35_11","003_35_11","EXO","35","11","11","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ, ꠊꠞꠞ ꠌꠣꠟ, ꠢꠥꠇ, ꠚ꠆ꠞꠦꠁꠝ, ꠛꠣꠔ꠆ꠔꠤ, ꠈꠥꠐꠤ, ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ; ");
INSERT INTO syls_vpl VALUES ("EX35_12","003_35_12","EXO","35","12","12","ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ, ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣ, ꠡꠘ꠆ꠖꠥꠇ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ; ꠡꠘ꠆ꠖꠥꠇꠞꠦ ꠀꠉꠟꠣ ꠖꠤꠛꠣꠞ ꠙꠞ꠆ꠖꠣ; ");
INSERT INTO syls_vpl VALUES ("EX35_13","003_35_13","EXO","35","13","13","ꠛꠦꠘ꠆ꠖꠣ ꠡꠥꠖ꠆ꠖꠣ ꠐꠦꠛꠥꠟ, ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠞ ꠢꠇꠟ ꠌꠤꠎ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ; ");
INSERT INTO syls_vpl VALUES ("EX35_14","003_35_14","EXO","35","14","14","ꠚꠞ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠢꠇꠟ ꠌꠤꠎ ꠀꠞ ꠌꠦꠞꠣꠉ ꠅꠇꠟ, ꠌꠦꠞꠣꠉ ꠎꠣꠟꠣꠘꠤꠞ ꠔꠦꠟ; ");
INSERT INTO syls_vpl VALUES ("EX35_15","003_35_15","EXO","35","15","15","ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ, ꠁꠈꠣꠘ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ; ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ, ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠀꠉꠞ, ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠖꠥꠀꠞꠞ ꠙꠞ꠆ꠖꠣ; ");
INSERT INTO syls_vpl VALUES ("EX35_16","003_35_16","EXO","35","16","16","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ; ꠄꠞ ꠙꠤꠔꠟꠞ ꠎꠣꠟꠤ ꠀꠞ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ; ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ; ꠅꠎꠥꠞ ꠉꠣꠝꠟꠣ ꠀꠞ ꠉꠣꠝꠟꠣ ꠕꠅꠀꠞ ꠌꠇꠤ-ꠈꠣꠐ; ");
INSERT INTO syls_vpl VALUES ("EX35_17","003_35_17","EXO","35","17","17","ꠃꠑꠣꠘꠞ ꠙꠞ꠆ꠖꠣꠁꠘ, ꠈꠥꠐꠤꠘ ꠀꠞ ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ; ꠃꠑꠣꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠉꠦꠁꠐꠞ ꠙꠞ꠆ꠖꠣ; ");
INSERT INTO syls_vpl VALUES ("EX35_18","003_35_18","EXO","35","18","18","ꠊꠞꠞ ꠙꠦꠞꠦꠉ ꠀꠞ ꠖꠠꠤ, ꠃꠑꠣꠘꠞ ꠙꠦꠞꠦꠉ ꠀꠞ ꠖꠠꠤ; ");
INSERT INTO syls_vpl VALUES ("EX35_19","003_35_19","EXO","35","19","19","ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠟꠣꠉꠤ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ, ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠅ ꠁꠝꠣꠝꠔꠤꠞ ꠟꠦꠛꠣꠍ।” ");
INSERT INTO syls_vpl VALUES ("EX35_20","003_35_20","EXO","35","20","20","ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠛꠄꠀꠘ ꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠉꠥꠡ꠆ꠐꠤ ꠛꠤꠖꠣꠄ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_21","003_35_21","EXO","35","21","21","ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠄꠡꠇꠤ ꠝꠣꠚꠤꠇ ꠎꠣꠞꠎꠤꠞ ꠁꠌ꠆ꠍꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍꠞ ꠟꠣꠉꠤ ꠀꠞ ꠄꠛꠣꠖꠔ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠅꠔꠣ ꠟꠁꠀ ꠔꠣꠞꠣ ꠀꠎꠤꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_22","003_35_22","EXO","35","22","22","ꠛꠦꠐꠣꠁꠘ ꠛꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠎꠣꠞꠣꠞ ꠝꠘꠦ ꠌꠣꠁꠟ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠇꠣꠙꠠꠞ ꠙꠤꠋ, ꠇꠣꠘꠞ ꠁꠀꠞꠤꠋ, ꠀꠋꠐꠤ, ꠉꠟꠣꠞ ꠢꠣꠞ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠡꠥꠘꠣꠞ ꠉꠄꠘꠣ ꠀꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_23","003_35_23","EXO","35","23","23","ꠀꠞ ꠎꠦꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ, ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣ, ꠟꠣꠟ ꠞꠋ ꠇꠞꠣ ꠝꠦꠠꠣꠞ ꠌꠣꠝꠠꠣ, ꠚꠥʼꠞ ꠌꠣꠝꠠꠣ ꠀꠍꠤꠟ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_24","003_35_24","EXO","35","24","24","ꠎꠦꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠥꠙꠣ ꠀꠞ ꠙꠤꠔꠟ ꠀꠍꠤꠟ, ꠔꠣꠞꠣꠅ ꠁꠔꠣ ꠀꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠟꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠘꠤꠞ ꠎꠥꠇꠣ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤ ꠎꠦꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠍꠤꠟ, ꠔꠣꠞꠣꠅ ꠁꠔꠣ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_25","003_35_25","EXO","35","25","25","ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠡꠥꠔꠣ ꠛꠣꠘꠣꠘꠤꠔ ꠃꠡ꠆ꠔꠣꠖ, ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠀꠔꠦ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠞꠋꠉꠞ ꠡꠥꠔꠣ, ꠀꠞ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠛꠣꠘꠣꠁꠀ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_26","003_35_26","EXO","35","26","26","ꠀꠞ ꠡꠥꠔꠣ ꠛꠣꠘꠣꠅꠞꠣ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠄꠡꠇꠤ ꠙꠄꠖꠣ ꠅꠁꠟ, ꠔꠣꠞꠣ ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣ ꠖꠤꠀ ꠡꠥꠔꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_27","003_35_27","EXO","35","27","27","ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠄꠚꠞꠘ ꠀꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠔ ꠟꠣꠉꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠀꠇꠤꠇ ꠝꠘꠤ ꠀꠞ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_28","003_35_28","EXO","35","28","28","ꠌꠦꠞꠣꠉ ꠎꠣꠟꠣꠘꠤꠞ ꠔꠦꠟ, ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠔꠦꠟ, ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠛꠣꠘꠣꠘꠤꠞ ꠝꠡꠟꠣ ꠀꠞ ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟꠅ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_29","003_35_29","EXO","35","29","29","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠁꠔꠣ ꠙꠥꠞꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ꠆ꠔꠦ, ꠎꠣꠞꠎꠤꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠟꠤꠟ꠆ꠟꠣ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX35_30","003_35_30","EXO","35","30","30","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠄꠢꠥꠖꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠢꠥꠞꠞ ꠘꠣꠔꠤ, ꠃꠞꠤꠞ ꠙꠥꠀ ꠛꠣꠔꠍꠦꠟꠟꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX35_31","003_35_31","EXO","35","31","31","ꠔꠣꠁꠘ ꠄꠞꠦ ꠘꠤꠎꠞ ꠞꠥꠢꠥ ꠝꠥꠛꠣꠞꠇ ꠖꠤꠀ ꠇꠣꠝꠤꠟ ꠛꠣꠘꠣꠁꠀ, ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠇꠣꠞꠤꠉꠞꠤ ꠇꠣꠝꠞ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ, ꠛꠤꠖ꠆ꠖꠣꠄ ꠃꠡ꠆ꠔꠣꠖꠤ ꠇꠣꠝꠞ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX35_32","003_35_32","EXO","35","32","32","ꠄꠞꠟꠣꠉꠤ ꠄꠁꠘ ꠇꠣꠞꠤꠉꠞꠤ ꠇꠣꠝ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠘꠤꠎꠞ ꠀꠈꠟ ꠈꠣꠐꠣꠁꠀ ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠙꠤꠔꠟꠞ ꠃꠙꠞꠦ ꠡꠥꠘ꠆ꠖꠞ ꠡꠥꠘ꠆ꠖꠞ ꠘꠇꠡꠣ ꠛꠣꠘꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_33","003_35_33","EXO","35","33","33","ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ ꠇꠣꠐꠣ, ꠟꠣꠇꠠꠤꠞ ꠃꠙꠞꠦ ꠘꠇꠡꠣ, ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠀꠔꠞ ꠇꠣꠝ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EX35_34","003_35_34","EXO","35","34","34","ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞꠦꠅ ꠁꠔꠣ ꠇꠣꠝ ꠢꠤꠇꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠣꠔꠍꠦꠟꠟ ꠀꠞ ꠖꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠅꠢꠤꠍꠣꠝꠣꠇꠞ ꠙꠥꠀ ꠀꠢꠟꠤꠀꠛꠞ ꠖꠤꠟꠅ ꠝꠣꠛꠥꠖꠦ ꠀꠈꠟ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EX35_35","003_35_35","EXO","35","35","35","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠞ ꠘꠇꠡꠣꠞ ꠇꠣꠝ, ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣꠖꠤ ꠇꠣꠙꠠ ꠛꠣꠁꠘ ꠇꠞꠣ, ꠘꠇꠡꠣ ꠇꠞꠣ, ꠡꠤꠟꠣꠁ ꠇꠞꠣ, ꠀꠞ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠡꠤꠟꠣꠁ ꠇꠞꠣꠞꠅ ꠀꠈꠟ ꠖꠤꠍꠂꠘ। ꠔꠣꠞꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠀꠔꠞ ꠇꠣꠝ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ, ꠀꠞ ꠘꠤꠎꠞ ꠝꠘ ꠕꠣꠇꠤ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠘꠇꠡꠣ ꠛꠣꠘꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX36_1","003_36_1","EXO","36","1","1","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠄꠅꠈꠣꠘ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠛꠣꠔꠍꠦꠟꠟ, ꠀꠢꠟꠤꠀꠛ ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠇꠣꠞꠤꠉꠞ ꠅꠇꠟꠞꠦ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠖꠣꠘ ꠇꠞꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ꠝꠣꠛꠥꠖꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠢꠇꠟꠔꠣ ꠛꠣꠘꠣꠁꠘ ꠀꠞ ꠢꠣꠎꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("EX36_2","003_36_2","EXO","36","2","2","ꠅꠃ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠥꠍꠣꠄ ꠛꠣꠔꠍꠦꠟꠟ ꠀꠞ ꠀꠢꠟꠤꠀꠛꠞꠦ ꠀꠘꠣꠁꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠎꠦꠔꠣ ꠃꠡ꠆ꠔꠣꠖ ꠇꠣꠞꠤꠉꠞ ꠅꠇꠟꠞꠦ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠖꠤꠍꠂꠘ, ꠀꠞ ꠁ ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣꠞ ꠖꠤꠟꠅ ꠈꠣꠁꠡ ꠙꠄꠖꠣ ꠅꠁꠍꠦ, ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦꠅ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_3","003_36_3","EXO","36","3","3","ꠔꠣꠞꠣ ꠀꠁꠀ ꠙꠛꠤꠔ꠆ꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠅꠀ ꠟꠤꠟ꠆ꠟꠣꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠝꠥꠍꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠝꠎꠤꠀ ꠘꠤꠟꠣ। ꠝꠣꠘꠡꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠘꠤꠎꠞ ꠁꠌ꠆ꠍꠣꠄ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠀꠞꠅ ꠌꠤꠎ ꠅꠇꠟ ꠀꠘꠤꠀ ꠅꠘꠅ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_4","003_36_4","EXO","36","4","4","ꠎꠦ ꠃꠡ꠆ꠔꠣꠖ ꠇꠣꠞꠤꠉꠞ ꠅꠇꠟ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠇꠣꠝꠅ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠖꠦꠈꠤꠀ, ꠘꠤꠎꠞ ꠇꠣꠝ ꠕꠁꠀ ꠀꠁꠀ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX36_5","003_36_5","EXO","36","5","5","“ꠝꠣꠛꠥꠖꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠖꠞꠇꠣꠞ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠦꠡꠤ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠁꠀ ꠀꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("EX36_6","003_36_6","EXO","36","6","6","ꠔꠦꠃ ꠝꠥꠍꠣꠞ ꠢꠥꠇꠥꠝꠦ ꠝꠣꠘꠡꠦ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣ, ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠇꠦꠃ ꠎꠣꠘꠥ ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠤꠟ꠆ꠟꠣ ꠘꠣ ꠖꠦꠁꠘ। ꠅꠃꠉꠤ ꠝꠣꠘꠡꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠦꠅꠀ ꠛꠘ꠆ꠖ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_7","003_36_7","EXO","36","7","7","ꠇꠣꠞꠘ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠖꠞꠇꠣꠞ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠦꠡꠤ ꠌꠤꠎ ꠎꠥꠉꠣꠠ ꠅꠁꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_8","003_36_8","EXO","36","8","8","ꠛꠣꠖꠦ ꠇꠣꠝ ꠇꠞꠞꠣ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟꠦ ꠙꠦꠌꠣꠁꠟ ꠡꠥꠔꠣꠞ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ, ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠀꠞ ꠟꠣꠟ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠖꠡ ꠐꠥꠇꠞꠣ ꠇꠣꠙꠠ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠙꠞ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠣ। ꠀꠞ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟꠦ ꠄꠞ ꠃꠙꠞꠦ ꠇꠣꠞꠥꠛꠤ ꠅꠇꠟꠞ ꠘꠇꠡꠣ ꠛꠣꠁꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_9","003_36_9","EXO","36","9","9","ꠙꠞꠔꠦꠇ ꠐꠥꠇꠞꠣꠁꠘ ꠄꠇ ꠝꠣꠙꠞ ꠀꠍꠤꠟ, ꠟꠣꠝ꠆ꠛꠣꠄ ꠀꠐꠣꠁꠡ ꠀꠔ ꠀꠞ ꠙꠣꠡꠦ ꠌꠣꠁꠞ ꠀꠔ। ");
INSERT INTO syls_vpl VALUES ("EX36_10","003_36_10","EXO","36","10","10","ꠛꠣꠖꠦ ꠙꠣꠌꠈꠣꠘ ꠙꠣꠌꠈꠣꠘ ꠇꠞꠤ ꠄꠇꠈꠣꠘꠅ ꠎꠥꠠꠣ ꠖꠤꠀ ꠛꠠ ꠇꠞꠤ ꠖꠥꠈꠣꠘ ꠉꠤꠟꠣꠚ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_11","003_36_11","EXO","36","11","11","ꠀꠞ ꠖꠥꠁꠅ ꠉꠤꠟꠣꠚꠞ ꠙꠣꠡꠞ ꠄꠇ ꠇꠤꠘꠣꠞꠅ, ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣꠖꠤ ꠢꠥꠇꠞ ꠚꠥꠠ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_12","003_36_12","EXO","36","12","12","ꠅꠃꠟꠣ ꠙꠄꠟꠣ ꠉꠤꠟꠣꠚꠞ ꠇꠤꠘꠣꠞꠅ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇꠞ ꠚꠥꠠ ꠀꠞ ꠖꠥꠍꠞꠣ ꠉꠤꠟꠣꠚꠞ ꠇꠤꠘꠣꠞꠅ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇꠞ ꠚꠥꠠ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ। ꠁ ꠖꠥꠁꠅ ꠢꠥꠇꠞ ꠚꠥꠠ ꠄꠉꠥ ꠀꠞꠦꠉꠥꠞ ꠃꠟꠐꠣꠝꠥꠈꠣ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_13","003_36_13","EXO","36","13","13","ꠛꠣꠖꠦ ꠡꠥꠘꠣꠖꠤ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇ ꠛꠣꠘꠣꠁꠀ ꠢꠃ ꠢꠥꠇꠞ ꠚꠥꠠꠞ ꠝꠣꠎꠦꠖꠤ ꠢꠣꠞꠣꠁꠀ, ꠛꠠ ꠖꠥꠁꠅ ꠉꠤꠟꠣꠚꠞꠦ ꠎꠥꠠꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠔꠦꠃ ꠄꠇꠈꠣꠘ ꠊꠞ ꠔꠤꠀꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_14","003_36_14","EXO","36","14","14","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠌꠣꠟꠞ ꠟꠣꠉꠤ ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣ ꠖꠤꠀ ꠉꠤꠟꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠄꠉꠣꠞꠅꠈꠣꠘ ꠐꠥꠇꠞꠣ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_15","003_36_15","EXO","36","15","15","ꠁꠔꠣ ꠙꠞꠔꠦꠇ ꠈꠣꠘ ꠄꠇꠁ ꠝꠣꠙꠞ ꠀꠍꠤꠟ, ꠔꠤꠡ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ ꠀꠞ ꠌꠣꠁꠞ ꠀꠔ ꠙꠣꠡ। ");
INSERT INTO syls_vpl VALUES ("EX36_16","003_36_16","EXO","36","16","16","ꠅꠘ ꠕꠣꠇꠤ ꠙꠣꠌ ꠐꠥꠇꠞꠣ ꠄꠇꠟꠉꠦ ꠎꠥꠠꠣ ꠖꠤꠀ ꠛꠠ ꠄꠇ ꠉꠤꠟꠣꠚ ꠛꠣꠘꠣꠁꠟꠣ। ꠀꠞ ꠛꠣꠇꠤ ꠍꠄ ꠐꠥꠇꠞꠣ ꠎꠥꠠꠣ ꠖꠤꠀ, ꠀꠞꠅꠈꠣꠘ ꠛꠠ ꠉꠤꠟꠣꠚ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_17","003_36_17","EXO","36","17","17","ꠙꠄꠟꠣ ꠛꠠ ꠉꠤꠟꠣꠚꠞ ꠙꠣꠡꠞ ꠄꠇ ꠇꠤꠘꠣꠞꠅ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇꠞ ꠚꠥꠠ ꠟꠣꠉꠣꠁꠟꠣ, ꠀꠞ ꠖꠥꠍꠞꠣ ꠉꠤꠟꠣꠚꠅ-ꠅ ꠅꠃꠟꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_18","003_36_18","EXO","36","18","18","ꠛꠣꠖꠦ ꠙꠤꠔꠟ ꠖꠤꠀ ꠙꠁꠘ꠆ꠌꠣꠡꠉꠥ ꠢꠥꠇ ꠛꠣꠘꠣꠁꠀ ꠢꠃ ꠢꠥꠇꠞ ꠚꠥꠠꠞ ꠝꠣꠎꠦꠖꠤ ꠢꠣꠞꠣꠁꠀ, ꠅꠃ ꠛꠠ ꠖꠥꠁꠅ ꠉꠤꠟꠣꠚ ꠄꠇꠈꠣꠘꠅ ꠎꠥꠠꠣ ꠖꠤꠟꠣ। ꠔꠦꠃ ꠁ ꠖꠥꠁꠅ ꠉꠤꠟꠣꠚ ꠝꠤꠟꠤꠀ ꠄꠇꠈꠣꠘ ꠍꠣꠘꠤ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_19","003_36_19","EXO","36","19","19","ꠟꠣꠟ ꠞꠋ ꠇꠞꠣ ꠝꠦꠠꠣꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠄꠞ ꠃꠙꠞꠞ ꠍꠣꠘꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ, ꠛꠣꠖꠦ ꠚꠥʼꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠀꠞꠅꠈꠣꠘ ꠍꠣꠘꠤ ꠔꠂꠀꠞ ꠇꠞꠤꠀ ꠄꠞ ꠃꠙꠞꠦ ꠉꠥꠞꠤ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_20","003_36_20","EXO","36","20","20","ꠛꠣꠖꠦ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠇꠄꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_21","003_36_21","EXO","36","21","21","ꠙꠞꠔꠦꠇ ꠚ꠆ꠞꠦꠁꠝ ꠀꠍꠤꠟ ꠟꠣꠝ꠆ꠛꠣꠄ ꠖꠡ ꠀꠔ ꠀꠞ ꠚꠣꠠꠦ ꠖꠦꠠ ꠀꠔ। ");
INSERT INTO syls_vpl VALUES ("EX36_22","003_36_22","EXO","36","22","22","ꠙꠞꠔꠦꠇ ꠚ꠆ꠞꠦꠁꠝꠅ ꠖꠥꠉꠥ ꠇꠞꠤ ꠙꠣꠄꠀ ꠟꠣꠉꠣꠁꠀ ꠊꠞꠞ ꠢꠇꠟ ꠚ꠆ꠞꠦꠁꠝ ꠄꠇꠟꠣꠈꠣꠘ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_23","003_36_23","EXO","36","23","23","ꠅꠃ ꠊꠞꠞ ꠖꠇ꠆ꠇꠤꠘ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ ꠛꠤꠡꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠎꠥꠁꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_24","003_36_24","EXO","36","24","24","ꠁ ꠛꠤꠡꠅ ꠚ꠆ꠞꠦꠁꠝꠞ ꠙꠣꠄꠀꠞ ꠔꠟꠦ ꠌꠣꠟ꠆ꠟꠤꠡꠉꠥ ꠞꠥꠙꠣꠞ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠣꠁꠟꠣ। ꠙꠞꠔꠦꠇ ꠚ꠆ꠞꠦꠁꠝꠞ ꠖꠥꠁ ꠙꠣꠄꠀꠞ ꠔꠟꠦ ꠖꠥꠉꠥ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_25","003_36_25","EXO","36","25","25","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠔ꠆ꠔꠞ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤꠀꠅ ꠛꠤꠡꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠎꠥꠁꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_26","003_36_26","EXO","36","26","26","ꠁ ꠙꠞꠔꠦꠇ ꠚ꠆ꠞꠦꠁꠝꠞ ꠙꠣꠄꠀꠞ ꠔꠟꠦ ꠌꠣꠟ꠆ꠟꠤꠡꠉꠥ ꠞꠥꠙꠣꠞ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠣꠁꠟꠣ। ꠄꠇꠅ ꠚ꠆ꠞꠦꠁꠝꠞ ꠔꠟꠦ ꠖꠥꠉꠥ ꠇꠞꠤ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_27","003_36_27","EXO","36","27","27","ꠀꠞ ꠙꠌꠤꠝ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ, ꠝꠣꠘꠤ ꠈꠞ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ ꠍꠄꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_28","003_36_28","EXO","36","28","28","ꠀꠞ ꠈꠞꠞ ꠖꠥꠁꠅ ꠇꠥꠘꠣꠔ ꠖꠥꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_29","003_36_29","EXO","36","29","29","ꠁ ꠖꠥꠁꠅ ꠇꠥꠘꠣꠞ ꠚ꠆ꠞꠦꠁꠝꠞꠦ ꠇꠣꠍꠣꠞ ꠚ꠆ꠞꠦꠁꠝꠞ ꠟꠉꠦ ꠔꠟꠦ-ꠃꠙꠞꠦ ꠎꠥꠠꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠙꠞꠔꠦꠇ ꠇꠥꠘꠣꠞ ꠖꠥꠁꠅ ꠚ꠆ꠞꠦꠁꠝꠞꠦ ꠗꠣꠞꠞ ꠚ꠆ꠞꠦꠁꠝꠞ ꠟꠉꠦ ꠛꠣꠔ꠆ꠔꠤ ꠝꠣꠞꠤꠀ ꠎꠥꠠꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_30","003_36_30","EXO","36","30","30","ꠔꠦꠃ ꠀꠐꠈꠣꠘ ꠚ꠆ꠞꠦꠁꠝ ꠀꠞ ꠡꠥꠟꠉꠥ ꠞꠥꠙꠣꠞ ꠌꠥꠘ꠆ꠉꠤ ꠟꠣꠉꠟ, ꠄꠇꠅ ꠚ꠆ꠞꠦꠁꠝꠞ ꠔꠟꠦ ꠖꠥꠁꠐꠣ ꠇꠞꠤ ꠌꠥꠘ꠆ꠉꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_31","003_36_31","EXO","36","31","31","ꠛꠣꠖꠦ ꠚ꠆ꠞꠦꠁꠝꠞꠦ ꠎꠥꠠꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠇꠄꠉꠥ ꠟꠣꠝ꠆ꠛꠣ ꠛꠣꠔ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_32","003_36_32","EXO","36","32","32","ꠊꠞꠞ ꠄꠇ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠌꠉꠥ ꠛꠣꠔ꠆ꠔꠤ, ꠀꠞꠇ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠙꠣꠌꠉꠥ, ꠀꠞ ꠙꠣꠌꠉꠥ ꠛꠣꠔ꠆ꠔꠤ ꠈꠞ ꠉꠣꠟꠣ, ꠝꠣꠘꠤ ꠙꠌꠤꠝ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_33","003_36_33","EXO","36","33","33","ꠚ꠆ꠞꠦꠁꠝꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠟꠣꠉꠣꠁꠟ ꠅꠃ ꠛꠣꠔ꠆ꠔꠤꠖꠤ ꠢꠇꠟ ꠚ꠆ꠞꠦꠁꠝꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣ ꠀꠐꠇꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_34","003_36_34","EXO","36","34","34","ꠛꠣꠖꠦ ꠁ ꠚ꠆ꠞꠦꠁꠝ ꠈꠣꠘꠣꠁꠘ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠟꠣ। ꠀꠞ ꠛꠣꠔ꠆ꠔꠤ ꠟꠣꠉꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠀ, ꠛꠣꠔ꠆ꠔꠤꠞꠦꠅ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_35","003_36_35","EXO","36","35","35","ꠅꠃ ꠃꠡ꠆ꠔꠣꠖ ꠇꠣꠞꠤꠉꠞ ꠅꠇꠟꠦ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠄꠇꠈꠣꠘ ꠙꠞ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠣ। ꠙꠞ꠆ꠖꠣꠞ ꠃꠙꠞꠦ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ ꠖꠤꠀ ꠇꠣꠞꠥꠛꠤ ꠅꠇꠟꠞ ꠍꠛꠤ ꠛꠣꠁꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_36","003_36_36","EXO","36","36","36","ꠁ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠌꠣꠁꠞꠐꠣ ꠈꠥꠐꠤ ꠛꠣꠘꠣꠁꠟꠣ, ꠛꠣꠘꠣꠁꠀ ꠅꠃ ꠈꠥꠐꠤꠘ꠆ꠔꠞꠦꠅ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠟꠣ, ꠈꠥꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠕꠣꠔ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠟꠣ। ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠟꠣꠉꠤ ꠞꠥꠙꠣꠞ ꠌꠣꠁꠞꠐꠣ ꠌꠥꠘ꠆ꠉꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX36_37","003_36_37","EXO","36","37","37","ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠟꠣꠉꠤ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ ꠀꠞ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠘꠇꠡꠣ ꠇꠞꠤ ꠄꠇꠈꠣꠘ ꠙꠞ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX36_38","003_36_38","EXO","36","38","38","ꠁ ꠙꠞ꠆ꠖꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠌꠐꠣ ꠇꠠꠣ ꠀꠞ ꠙꠣꠌꠐꠣ ꠈꠥꠐꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ꠈꠥꠐꠤꠞ ꠝꠣꠕꠣ ꠀꠞ ꠔꠟ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠣ ꠅꠁꠟ, ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠟꠣꠉꠤ ꠙꠤꠔꠟꠞ ꠙꠣꠌꠉꠥ ꠌꠥꠘ꠆ꠉꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_1","003_37_1","EXO","37","1","1","ꠛꠣꠔꠍꠦꠟꠟꠦ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠙꠛꠤꠔ꠆ꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ ꠛꠣꠘꠣꠁꠟꠣ। ꠁꠐꠣ ꠀꠠꠣꠁ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ, ꠖꠦꠠ ꠀꠔ ꠙꠣꠡ ꠀꠞ ꠖꠦꠠ ꠀꠔ ꠃꠌꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_2","003_37_2","EXO","37","2","2","ꠄꠞ ꠛꠣꠞꠦ-ꠜꠤꠔꠞꠦ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠟꠣ, ꠄꠞ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠅ ꠡꠥꠘꠣꠞ ꠘꠇꠡꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_3","003_37_3","EXO","37","3","3","ꠀꠉꠥꠁꠘꠖꠤ ꠡꠥꠘꠣ ꠉꠟꠣꠁꠀ ꠌꠣꠁꠞꠐꠣ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠄꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠔ ꠟꠣꠉꠣꠁꠟꠣ, ꠅꠉꠣꠟꠣꠔ ꠖꠥꠁꠐꠣ ꠀꠞ ꠢꠉꠣꠟꠣꠔ ꠖꠥꠁꠐꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_4","003_37_4","EXO","37","4","4","ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠖꠥꠉꠥ ꠛꠦꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠀ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_5","003_37_5","EXO","37","5","5","ꠡꠘ꠆ꠖꠥꠇ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠁ ꠖꠥꠁꠅ ꠛꠦꠘ꠆ꠖꠣ, ꠡꠘ꠆ꠖꠥꠇꠞ ꠖꠥꠁ ꠉꠣꠟꠣꠞ ꠇꠠꠣꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠢꠣꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_6","003_37_6","EXO","37","6","6","ꠛꠣꠖꠦ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠡꠘ꠆ꠖꠥꠇꠞ ꠄꠇꠈꠣꠘ ꠓꠣꠇꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ, ꠅꠈꠣꠘꠞ ꠃꠙꠞꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ꠁ ꠓꠣꠇꠘꠣ ꠟꠣꠝ꠆ꠛꠣꠄ ꠀꠠꠣꠁ ꠀꠔ, ꠀꠞ ꠙꠣꠡꠦ ꠖꠦꠠ ꠀꠔ। ");
INSERT INTO syls_vpl VALUES ("EX37_7","003_37_7","EXO","37","7","7","ꠡꠥꠘꠣ ꠙꠤꠐꠣꠁꠀ ꠓꠣꠇꠘꠣꠞ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠔ ꠖꠥꠁꠐꠣ ꠇꠣꠞꠥꠛꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_8","003_37_8","EXO","37","8","8","ꠖꠥꠁꠅ ꠇꠣꠞꠥꠛꠤ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣꠞ ꠖꠥꠁ ꠇꠤꠘꠣꠞꠅ ꠞꠁꠟ। ꠁ ꠖꠥꠁꠅ ꠇꠣꠞꠥꠛꠤ ꠓꠣꠇꠘꠣꠞ ꠟꠉꠦ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ, ꠁ ꠀꠡ꠆ꠔꠣꠐꠣ ꠈꠣꠟꠤ ꠄꠇ ꠌꠤꠎ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX37_9","003_37_9","EXO","37","9","9","ꠇꠣꠞꠥꠛꠤ ꠖꠦꠈꠔꠦ ꠖꠥꠟꠖꠥꠟ ꠊꠥꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠒꠣꠈꠘꠣ ꠀꠟꠣ, ꠄꠞ ꠖꠥꠁꠅ ꠒꠣꠈꠘꠣ ꠃꠙꠞꠦꠖꠤ ꠝꠦꠟꠤꠀ ꠖꠦꠅꠀꠄ, ꠅꠃ ꠒꠣꠈꠘꠣꠞ ꠍꠣꠄꠀꠞ ꠔꠟꠦ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣ ꠢꠣꠝꠣꠁꠉꠦꠟ। ꠁꠐꠣ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠃꠛꠣ ꠞꠁꠟ। ꠀꠞ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠞꠁꠟ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣꠞ ꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX37_10","003_37_10","EXO","37","10","10","ꠛꠣꠔꠍꠦꠟꠟꠦ ꠛꠣꠖꠦ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠖꠥꠁ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ, ꠄꠇ ꠀꠔ ꠙꠣꠡ ꠀꠞ ꠖꠦꠠ ꠀꠔ ꠃꠌꠣ ꠇꠞꠤ ꠄꠇꠈꠣꠘ ꠐꠦꠛꠥꠟ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_11","003_37_11","EXO","37","11","11","ꠛꠣꠘꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠀ ꠄꠞ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠅ ꠘꠇꠡꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_12","003_37_12","EXO","37","12","12","ꠀꠞ ꠄꠞ ꠍꠣꠘꠤꠞ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠅ ꠌꠣꠁꠞ ꠀꠋꠉꠥꠟ ꠃꠌꠣ ꠇꠞꠤ ꠄꠇ ꠢꠣꠎ ꠖꠤꠟꠣ, ꠢꠣꠎꠞ ꠝꠣꠎꠦ ꠡꠥꠘꠣꠖꠤ ꠘꠇꠡꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_13","003_37_13","EXO","37","13","13","ꠐꠦꠛꠥꠟꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠞ ꠙꠣꠄꠀꠞ ꠃꠙꠞꠦ ꠡꠥꠘꠣꠞ ꠌꠣꠁꠞꠐꠣ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_14","003_37_14","EXO","37","14","14","ꠁ ꠌꠣꠁꠞꠅ ꠇꠠꠣꠁꠘ ꠐꠦꠛꠥꠟꠞ ꠇꠥꠘꠣꠞ ꠢꠃ ꠃꠌꠣ ꠢꠣꠎꠞ ꠔꠟꠦ ꠟꠣꠉꠣꠘꠤ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠐꠦꠛꠥꠟ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠣꠟꠣ ꠇꠠꠣꠞ ꠜꠤꠔꠞꠦ ꠛꠦꠘ꠆ꠖꠣ ꠢꠣꠞꠣꠁꠟ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX37_15","003_37_15","EXO","37","15","15","ꠐꠦꠛꠥꠟꠞꠦ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠖꠥꠉꠥ ꠛꠦꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠀ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_16","003_37_16","EXO","37","16","16","ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠞ ꠕꠣꠟ-ꠛꠣꠡꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠎꠉ ꠀꠞ ꠝꠉ, ꠢꠇꠟꠔꠣ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠉꠠꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_17","003_37_17","EXO","37","17","17","ꠛꠣꠖꠦ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠄꠇꠈꠣꠘ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ ꠔꠤꠀꠞ ꠇꠞꠟꠣ। ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠔꠟꠣ ꠀꠞ ꠃꠙꠞꠞ ꠒꠣꠘ꠆ꠒꠤ ꠈꠣꠐꠤ ꠡꠥꠘꠣ ꠙꠤꠐꠣꠁꠀ ꠉꠠꠣꠁꠟꠣ। ꠄꠞ ꠒꠣꠘ꠆ꠒꠤ, ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠙꠤꠀꠟꠣ, ꠇꠥꠠꠤ ꠀꠞ ꠙꠣꠙꠠꠤ ꠅꠇꠟ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠟꠉꠦ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_18","003_37_18","EXO","37","18","18","ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠒꠣꠘ꠆ꠒꠤꠞ ꠖꠥꠁ ꠉꠣꠟꠣꠔ ꠔꠤꠘꠐꠣ ꠇꠞꠤ ꠝꠥꠐ ꠍꠄꠐꠣ ꠒꠣꠟ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX37_19","003_37_19","EXO","37","19","19","ꠙꠞꠔꠦꠇ ꠒꠣꠟꠞ ꠝꠣꠎꠦ ꠎꠛꠣ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠔꠤꠘꠉꠥ ꠇꠞꠤ ꠙꠤꠀꠟꠣ ꠔꠤꠀꠞ ꠇꠞꠣ ꠅꠁꠟ। ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠍꠄꠅ ꠒꠣꠟꠅ ꠄꠇꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX37_20","003_37_20","EXO","37","20","20","ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠝꠥꠟ ꠒꠣꠘ꠆ꠒꠤꠞ ꠝꠣꠎꠦꠅ ꠎꠛꠣ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠌꠣꠁꠞꠐꠣ ꠙꠤꠀꠟꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX37_21","003_37_21","EXO","37","21","21","ꠅꠃ ꠝꠥꠟ ꠒꠣꠘ꠆ꠒꠤ ꠕꠣꠇꠤ ꠛꠣꠞꠅꠁꠟ ꠍꠄꠐꠣ ꠒꠣꠟꠞ ꠝꠣꠎꠦ, ꠙꠄꠟꠣ ꠖꠥꠁꠅ ꠒꠣꠟꠞ ꠎꠥꠠꠣꠔ ꠄꠉꠥ ꠇꠞꠤ ꠇꠥꠠꠤ, ꠖꠥꠍꠞꠣ ꠖꠥꠁꠅ ꠒꠣꠟꠞ ꠎꠥꠠꠣꠔ ꠀꠞꠇ ꠇꠥꠠꠤ, ꠀꠞ ꠢꠦꠡꠞ ꠖꠥꠁꠅ ꠒꠣꠟꠞ ꠎꠥꠠꠣꠔꠅ ꠇꠥꠠꠤ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX37_22","003_37_22","EXO","37","22","22","ꠇꠥꠠꠤ ꠀꠞ ꠒꠣꠟ ꠢꠇꠟꠔꠣ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠟ, ꠢꠇꠟꠔꠣ ꠝꠤꠟꠤꠀ ꠄꠇ ꠌꠤꠎ ꠅꠁꠟ। ꠀꠡ꠆ꠔꠣꠐꠣꠃ ꠈꠣꠐꠤ ꠡꠥꠘꠣ ꠙꠤꠐꠣꠁꠀ ꠛꠣꠘꠣꠘꠤ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX37_23","003_37_23","EXO","37","23","23","ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠡꠣꠔꠐꠣ ꠌꠦꠞꠣꠉ, ꠌꠦꠞꠣꠉꠞ ꠚꠤꠔꠣ ꠍꠣꠚ ꠇꠞꠣꠞ ꠌꠤꠝꠐꠣ, ꠎꠣꠟꠣꠁꠟ ꠚꠤꠔꠣꠞ ꠍꠣꠟꠤ ꠕꠅꠀꠞ ꠟꠣꠉꠤ ꠇꠄꠉꠥ ꠛꠣꠐꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX37_24","003_37_24","EXO","37","24","24","ꠄꠇ ꠝꠘ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠁ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ, ꠀꠞ ꠟꠉꠞ ꠢꠇꠟꠔꠣ ꠔꠤꠀꠞ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX37_25","003_37_25","EXO","37","25","25","ꠛꠣꠖꠦ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠌꠣꠁꠞ ꠇꠥꠘꠣ ꠀꠟꠣ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ꠄꠇ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ, ꠄꠇ ꠀꠔ ꠙꠣꠡ, ꠀꠞ ꠖꠥꠁ ꠀꠔ ꠃꠛꠤ ꠖꠤꠀ ꠁ ꠐꠦꠛꠥꠟ ꠛꠣꠘꠣꠁꠟꠣ। ꠄꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠢꠤꠋꠅ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_26","003_37_26","EXO","37","26","26","ꠍꠣꠘꠤ, ꠍꠣꠘꠤꠞ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞ ꠀꠞ ꠢꠤꠋ, ꠢꠇꠟꠔꠣ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠀ ꠌꠣꠁꠞꠅ ꠇꠤꠘꠣꠞꠅ ꠡꠥꠘꠣꠞ ꠘꠇꠡꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_27","003_37_27","EXO","37","27","27","ꠄꠞ ꠖꠥꠁ ꠇꠤꠘꠣꠞꠞ ꠘꠇꠡꠣꠞ ꠔꠟꠦ ꠖꠥꠉꠥ ꠇꠞꠤ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠄꠞ ꠜꠤꠔꠞꠦ ꠛꠦꠘ꠆ꠖꠣ ꠢꠣꠞꠣꠁꠀ ꠛꠁꠀ ꠘꠦꠅꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EX37_28","003_37_28","EXO","37","28","28","ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠣ, ꠁꠐꠣꠞꠦꠅ ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX37_29","003_37_29","EXO","37","29","29","ꠛꠣꠖꠦ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠝꠡꠟꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠇꠣꠞꠤꠉꠞꠞ ꠘꠤꠅꠝꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠀꠞ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠈꠣꠐꠤ ꠀꠉꠞ ꠔꠤꠀꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_1","003_38_1","EXO","38","1","1","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠙꠣꠌ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ, ꠙꠣꠌ ꠀꠔ ꠙꠣꠡ ꠀꠞ ꠔꠤꠘ ꠀꠔ ꠃꠛꠤ ꠖꠤꠀ ꠌꠣꠁꠞꠇꠥꠘꠤ ꠇꠞꠤ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_2","003_38_2","EXO","38","2","2","ꠄꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠇꠠꠤꠖꠤ ꠌꠣꠁꠞꠐꠣ ꠢꠤꠋ ꠖꠤꠟꠣ। ꠅꠃ ꠢꠤꠋ ꠛꠣꠘꠣꠁꠟꠣ ꠍꠣꠘꠤꠞ ꠃꠙꠞꠞ ꠇꠥꠘꠣꠞ ꠟꠣꠇꠠꠤ ꠈꠥꠖꠤꠀ, ꠄꠞꠟꠣꠉꠤ ꠁ ꠀꠡ꠆ꠔꠣꠈꠣꠘ ꠄꠇ ꠌꠤꠎ ꠅꠁꠟ। ꠛꠣꠖꠦ ꠙꠥꠞꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠙꠤꠔꠟꠖꠤ ꠟꠦꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_3","003_38_3","EXO","38","3","3","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠍꠣꠟꠤ ꠔꠥꠟꠣꠞ ꠛꠠ ꠌꠣꠝꠌ ꠀꠞ ꠍꠣꠟꠤ ꠕꠅꠀꠞ ꠉꠣꠝꠟꠣ, ꠟꠃ ꠕꠅꠀꠞ ꠛꠣꠐꠤ, ꠉꠥꠡ꠆ꠔ ꠔꠥꠟꠣꠞ ꠛꠠ ꠇꠣꠐꠣ-ꠍꠤꠚ, ꠀꠋꠞꠣ ꠕꠅꠀꠞ ꠙꠣꠔꠤꠟ, ꠢꠇꠟꠔꠣ ꠙꠤꠔꠟꠖꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_4","003_38_4","EXO","38","4","4","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠙꠤꠔꠟꠖꠤ ꠄꠇꠈꠣꠘ ꠎꠣꠟꠤ ꠛꠣꠘꠣꠁꠟꠣ, ꠛꠣꠘꠣꠁꠀ ꠁ ꠎꠣꠟꠤꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠜꠤꠔꠞꠞ ꠝꠣꠎꠈꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠔꠣꠠꠤꠀꠞ ꠔꠟꠦ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_5","003_38_5","EXO","38","5","5","ꠀꠞ ꠛꠦꠘ꠆ꠖꠣ ꠢꠣꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠣꠟꠤꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠔ ꠌꠣꠁꠞꠐꠣ ꠇꠠꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_6","003_38_6","EXO","38","6","6","ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠣ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ, ꠛꠣꠘꠣꠁꠀ ꠖꠥꠁꠅꠉꠥ ꠙꠤꠔꠟꠖꠤ ꠟꠦꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_7","003_38_7","EXO","38","7","7","ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠛꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠄꠞ ꠇꠥꠘꠣꠞ ꠇꠠꠣꠞ ꠜꠤꠔꠞꠦ ꠅꠃ ꠛꠦꠘ꠆ꠖꠣ ꠢꠣꠞꠣꠁꠟꠣ। ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ ꠔꠇ꠆ꠔꠣꠖꠤ, ꠀꠞ ꠄꠞ ꠜꠤꠔꠞꠦ ꠚꠣꠇ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_8","003_38_8","EXO","38","8","8","ꠅꠎꠥꠞ ꠙꠣꠘꠤ ꠕꠅꠀꠞ ꠟꠣꠉꠤ ꠙꠤꠔꠟꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠛꠣꠘꠣꠁꠟꠣ। ꠄꠛꠣꠖꠔꠤ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠔꠣ, ꠔꠣꠞꠣꠞ ꠙꠤꠔꠟꠞ ꠀꠄꠘꠣꠖꠤ ꠁ ꠉꠣꠝꠟꠣ ꠀꠞ ꠄꠞ ꠌꠇꠤ-ꠈꠣꠐ ꠔꠂꠀꠞ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_9","003_38_9","EXO","38","9","9","ꠛꠣꠔꠍꠦꠟꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠃꠑꠣꠘꠞ ꠎꠣꠉꠣ ꠞꠣꠈꠟꠣ। ꠃꠑꠣꠘꠞ ꠖꠇ꠆ꠇꠤꠘ ꠉꠣꠟꠣꠞ ꠄꠇ-ꠡ ꠀꠔ ꠎꠣꠉꠣꠞ ꠟꠣꠉꠤ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠙꠞ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_10","003_38_10","EXO","38","10","10","ꠁ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠤꠡꠉꠥ ꠈꠥꠐꠤ ꠛꠣꠘꠣꠁꠟꠣ। ꠈꠥꠐꠤꠞ ꠔꠟꠣꠔ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠙꠤꠔꠟꠞ ꠛꠤꠡꠉꠥ ꠌꠥꠘ꠆ꠉꠤ ꠛꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠞꠥꠙꠣꠞ ꠇꠠꠣ ꠀꠞ ꠛꠣꠘ꠆ꠖꠤꠛꠣꠞ ꠔꠣꠞ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_11","003_38_11","EXO","38","11","11","ꠃꠑꠣꠘꠞ ꠃꠔ꠆ꠔꠞ ꠉꠣꠟꠣꠞ ꠄꠇ-ꠡ ꠀꠔ ꠎꠣꠉꠣꠞ ꠟꠣꠉꠤ ꠛꠤꠡꠉꠥ ꠈꠥꠐꠤ, ꠈꠥꠐꠤꠞ ꠔꠟꠦ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠙꠤꠔꠟꠞ ꠛꠤꠡꠉꠥ ꠌꠥꠘ꠆ꠉꠤ, ꠀꠞ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠞꠥꠙꠣꠞ ꠇꠠꠣ ꠀꠞ ꠛꠣꠘ꠆ꠖꠤꠛꠣꠞ ꠔꠣꠞ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_12","003_38_12","EXO","38","12","12","ꠙꠌꠤꠝ ꠉꠣꠟꠣꠞ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠔ ꠃꠑꠣꠘꠞ ꠟꠣꠉꠤ ꠙꠞ꠆ꠖꠣ, ꠖꠡꠉꠥ ꠈꠥꠐꠤ, ꠖꠡꠉꠥ ꠌꠥꠘ꠆ꠉꠤ, ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠞꠥꠙꠣꠞ ꠇꠠꠣ ꠀꠞ ꠛꠣꠘ꠆ꠖꠤꠛꠣꠞ ꠔꠣꠞ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_13","003_38_13","EXO","38","13","13","ꠙꠥꠛ ꠉꠣꠟꠣꠞ ꠃꠑꠣꠘꠅ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_14","003_38_14","EXO","38","14","14","ꠃꠑꠣꠘꠞ ꠉꠦꠁꠐꠞ ꠄꠇ ꠉꠣꠟꠣꠞ ꠟꠣꠉꠤ ꠙꠘꠞ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ ꠙꠞ꠆ꠖꠣ, ꠔꠤꠘꠐꠣ ꠈꠥꠐꠤ, ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠔꠤꠘꠉꠥ ꠌꠥꠘ꠆ꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("EX38_15","003_38_15","EXO","38","15","15","ꠀꠞ ꠖꠥꠍꠞꠣ ꠉꠣꠟꠣꠔꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠔꠤꠘꠐꠣ ꠈꠥꠐꠤ, ꠔꠤꠘꠐꠣ ꠌꠥꠘ꠆ꠉꠤ ꠀꠞ ꠙꠘꠞ ꠀꠔ ꠙꠞ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_16","003_38_16","EXO","38","16","16","ꠃꠑꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠢꠇ꠆ꠇꠟ ꠙꠞ꠆ꠖꠣꠁꠘ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_17","003_38_17","EXO","38","17","17","ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠢꠇ꠆ꠇꠟ ꠌꠥꠘ꠆ꠉꠤ ꠙꠤꠔꠟꠞ, ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠇꠠꠣ ꠀꠞ ꠛꠣꠘ꠆ꠖꠤꠛꠣꠞ ꠔꠣꠞ ꠅꠁꠟ ꠞꠥꠙꠣꠞ, ꠈꠥꠐꠤꠞ ꠝꠣꠕꠣꠅ ꠞꠥꠙꠣꠖꠤ ꠙꠦꠌꠣꠁꠟ ꠅꠁꠟ। ꠃꠑꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠢꠇ꠆ꠇꠟ ꠈꠥꠐꠤꠔ ꠞꠥꠙꠣꠞ ꠔꠣꠞꠖꠤ ꠛꠣꠘ꠆ꠖꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_18","003_38_18","EXO","38","18","18","ꠃꠑꠣꠘꠞ ꠉꠦꠁꠐꠞ ꠟꠣꠉꠤ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠄꠇꠈꠣꠘ ꠙꠞ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ꠛꠣꠖꠦ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣꠖꠤ ꠘꠇꠡꠣ ꠇꠞꠣ ꠅꠁꠟ। ꠙꠞ꠆ꠖꠣ ꠈꠣꠘ ꠛꠤꠡ ꠀꠔ ꠟꠣꠝ꠆ꠛꠣ, ꠀꠞ ꠃꠑꠣꠘꠞ ꠛꠣꠇꠤ ꠙꠞ꠆ꠖꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠐꠣꠅ ꠙꠣꠌ ꠀꠔ ꠃꠌꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_19","003_38_19","EXO","38","19","19","ꠄꠞ ꠌꠣꠁꠞꠅ ꠈꠥꠐꠤ ꠀꠞ ꠌꠥꠘ꠆ꠉꠤ ꠙꠤꠔꠟꠞ, ꠈꠥꠐꠤꠞ ꠇꠠꠣ ꠀꠞ ꠛꠣꠘ꠆ꠖꠣꠞ ꠔꠣꠞ ꠞꠥꠙꠣꠞ, ꠈꠥꠐꠤꠞ ꠝꠣꠕꠣꠅ ꠞꠥꠙꠣꠖꠤ ꠙꠦꠌꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_20","003_38_20","EXO","38","20","20","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠀꠞ ꠃꠑꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠈꠥꠐꠤꠞ ꠙꠦꠞꠦꠉ ꠅꠇꠟ ꠙꠤꠔꠟꠖꠤ ꠛꠣꠘꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_21","003_38_21","EXO","38","21","21","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠝꠣꠘꠤ ꠅꠃ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥ ꠛꠣꠘꠣꠁꠔꠦ ꠎꠦꠔꠣ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠣꠉꠍꠤꠟ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠁꠍꠣꠝꠣꠞꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠁꠔꠣꠞ ꠢꠤꠡꠣꠛ ꠞꠣꠈꠟꠣ। ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠅꠃ ꠢꠤꠡꠣꠛ ꠞꠣꠈꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_22","003_38_22","EXO","38","22","22","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠁ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠄꠢꠥꠖꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠃꠞꠤꠞ ꠙꠥꠀ ꠛꠣꠔꠍꠦꠟꠟꠦ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠣꠘꠣꠁꠟꠣ, ꠔꠣꠁꠘ ꠀꠍꠟꠣ ꠢꠥꠞꠞ ꠘꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("EX38_23","003_38_23","EXO","38","23","23","ꠖꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠅꠢꠤꠍꠣꠝꠣꠇꠞ ꠙꠥꠀ ꠀꠢꠟꠤꠀꠛꠦ ꠛꠣꠔꠍꠦꠟꠟꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠟꠣ। ꠢꠇꠟ ꠎꠣꠔꠞ ꠀꠔꠞ ꠇꠣꠝ ꠀꠞ ꠘꠇꠡꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠇꠣꠝꠅ ꠔꠣꠁꠘ ꠃꠡ꠆ꠔꠣꠖ ꠀꠍꠟꠣ। ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠞ ꠝꠣꠎꠦ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣꠖꠤ ꠘꠇꠡꠣ ꠇꠞꠣꠞ ꠇꠣꠝꠅ-ꠅ ꠔꠣꠁꠘ ꠃꠡ꠆ꠔꠣꠖ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_24","003_38_24","EXO","38","24","24","ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠃꠘꠔꠤꠡ ꠝꠘ ꠡꠣꠔ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠡꠥꠘꠣ ꠅꠃ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠔꠦ ꠟꠣꠉꠍꠦ। ꠁ ꠝꠣꠙ ꠅꠁꠟ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠔꠟꠣꠞ ꠝꠣꠙꠦ। ");
INSERT INTO syls_vpl VALUES ("EX38_25","003_38_25","EXO","38","25","25","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠘꠥꠡ ꠉꠘꠤꠛꠣꠞ ꠛꠣꠟꠣ ꠎꠦꠞꠣꠞꠦ ꠉꠘꠣ ꠅꠁꠍꠤꠟ, ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠄꠇ-ꠡ ꠝꠘ ꠄꠇ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠙꠌꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠞꠥꠙꠣ ꠙꠣꠅꠀ ꠉꠦꠍꠤꠟ, ꠁ ꠝꠣꠙ ꠅꠁꠟ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ। ");
INSERT INTO syls_vpl VALUES ("EX38_26","003_38_26","EXO","38","26","26","ꠉꠘꠣ ꠅꠁꠍꠦ ꠅꠃꠟꠣ ꠝꠣꠘꠥꠡ, ꠝꠣꠘꠤ ꠛꠤꠡ ꠛꠞꠍ ꠛꠣ ꠄꠞ ꠌꠣꠁꠔꠦ ꠛꠦꠡꠤ ꠛꠄꠅꠡ ꠀꠟꠣ, ꠢꠃ ꠍꠄ ꠟꠣꠈ ꠔꠤꠘ ꠀꠎꠣꠞ ꠡꠣꠠꠦ ꠙꠣꠌ-ꠡ ꠝꠣꠘꠡꠦ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠝꠣꠕꠣ ꠙꠤꠍꠥ ꠀꠗꠣ ꠔꠟꠣ ꠇꠞꠤ ꠞꠥꠙꠣ ꠖꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX38_27","003_38_27","EXO","38","27","27","ꠁ ꠞꠥꠙꠣ ꠕꠣꠇꠤ ꠄꠇ-ꠡ ꠝꠘ ꠞꠥꠙꠣ ꠖꠤꠀ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠀꠞ ꠙꠞ꠆ꠖꠣꠞ ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠤꠟ। ꠄꠇ ꠄꠇ ꠌꠥꠘ꠆ꠉꠤꠔ ꠄꠇ ꠝꠘ ꠞꠥꠙꠣ ꠖꠤꠀ ꠝꠥꠐ ꠄꠇ-ꠡꠉꠥ ꠌꠥꠘ꠆ꠉꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX38_28","003_38_28","EXO","38","28","28","ꠀꠞ ꠛꠣꠇꠤ ꠄꠇ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠙꠌꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠞꠥꠙꠣ ꠈꠥꠐꠤꠞ ꠇꠠꠣ, ꠈꠥꠐꠤꠞ ꠝꠣꠕꠣ ꠙꠦꠌꠣꠘꠤ, ꠀꠞ ꠛꠣꠘ꠆ꠖꠤꠛꠣꠞ ꠔꠣꠞ ꠛꠣꠘꠣꠘꠤꠔ ꠟꠣꠉꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX38_29","003_38_29","EXO","38","29","29","ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠕꠣꠇꠤ ꠟꠤꠟ꠆ꠟꠣꠞ ꠙꠤꠔꠟ ꠖꠟꠣ ꠅꠁꠍꠤꠟ ꠡꠔ꠆ꠔꠁꠞ ꠝꠘ ꠖꠥꠁ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠔꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX38_30","003_38_30","EXO","38","30","30","ꠁꠔꠣ ꠖꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠌꠥꠘ꠆ꠉꠤ, ꠙꠤꠔꠟꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ, ꠄꠞ ꠙꠤꠔꠟꠞ ꠎꠣꠟꠤ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠇ꠆ꠇꠟ ꠌꠤꠎ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("EX38_31","003_38_31","EXO","38","31","31","ꠃꠑꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠌꠥꠘ꠆ꠉꠤ, ꠉꠦꠁꠐꠞ ꠌꠥꠘ꠆ꠉꠤ, ꠔꠣꠝ꠆ꠛꠥ ꠀꠞ ꠃꠑꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠈꠥꠐꠤꠞ ꠙꠦꠞꠦꠉ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EX39_1","003_39_1","EXO","39","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠡꠝꠄ ꠚꠤꠘ꠆ꠖꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠞꠣ ꠟꠣꠟ, ꠛꠣꠁꠋꠉꠘꠤ ꠀꠞ ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣꠖꠤ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠟꠦꠛꠣꠍ ꠛꠣꠘꠣꠁꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠟꠣꠉꠤ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_2","003_39_2","EXO","39","2","2","ꠅꠃ ꠃꠡ꠆ꠔꠣꠖ ꠇꠣꠞꠤꠉꠞ ꠅꠇꠟꠦ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠀꠞ ꠡꠥꠘꠣꠖꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠄꠚꠞꠘ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_3","003_39_3","EXO","39","3","3","ꠡꠥꠘꠣ ꠙꠤꠐꠣꠁꠀ ꠙꠣꠔ ꠛꠣꠘꠣꠁꠀ, ꠡꠥꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠡꠥꠘꠣꠞ ꠔꠣꠞ ꠔꠤꠀꠞ ꠇꠞꠟꠣ। ꠛꠣꠖꠦ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠀꠞ ꠡꠥꠘꠣꠞ ꠔꠣꠞ ꠄꠇꠟꠉꠦ ꠝꠤꠟꠣꠁꠀ ꠇꠣꠙꠠ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_4","003_39_4","EXO","39","4","4","ꠄꠚꠞꠘꠞ ꠇꠣꠘ꠆ꠖꠞ ꠉꠣꠟꠣ ꠎꠥꠠꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠈꠣꠘ ꠙꠐ꠆ꠐꠤ ꠛꠣꠘꠣꠁꠀ, ꠄꠚꠞꠘꠞ ꠃꠙꠞꠞ ꠇꠥꠘꠣꠔ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_5","003_39_5","EXO","39","5","5","ꠄꠚꠞꠘꠞ ꠟꠉꠦ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠁꠟ ꠙꠦꠐꠞ ꠃꠙꠞꠞ ꠛꠦꠟꠐ ꠈꠣꠘꠅ ꠄꠚꠞꠘꠞ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠘꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠀꠞ ꠡꠥꠘꠣꠞ ꠔꠣꠞ ꠖꠤꠀ ꠑꠤꠇ ꠄꠚꠞꠘꠞ ꠘꠝꠥꠘꠣꠄ ꠛꠣꠘꠣꠁꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX39_6","003_39_6","EXO","39","6","6","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠐꠣ ꠀꠇꠤꠇ ꠙꠣꠔ꠆ꠔꠞ ꠇꠣꠐꠤꠀ, ꠄꠞ ꠃꠙꠞꠦ ꠡꠥꠘꠣꠞ ꠎꠣꠎꠁꠞ ꠛꠅꠀꠁꠟꠣ। ꠢꠥꠘꠣꠞ ꠅꠇꠟꠦ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ ꠈꠥꠖꠤꠀ ꠎꠦꠟꠣ ꠡꠤꠟ ꠛꠣꠘꠣꠁꠘ, ꠅꠃꠟꠣ ꠙꠣꠔ꠆ꠔꠞ ꠈꠥꠖꠤꠀ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠘꠣꠝ ꠟꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_7","003_39_7","EXO","39","7","7","ꠀꠞ ꠅꠃ ꠖꠥꠁꠅ ꠙꠣꠔ꠆ꠔꠞ ꠡꠥꠘꠣꠞ ꠎꠣꠎꠁꠞꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠣꠁꠀ, ꠄꠚꠞꠘꠞ ꠇꠣꠘ꠆ꠖꠞ ꠚꠤꠔꠣꠞ ꠟꠉꠦ ꠛꠣꠘ꠆ꠖꠤꠟꠣ। ꠁꠍꠞꠣꠁꠟꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠛꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠁꠟꠣ ꠇꠞꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠅꠃꠟꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX39_8","003_39_8","EXO","39","8","8","ꠛꠣꠖꠦ ꠄꠚꠞꠘꠞ ꠟꠣꠈꠣꠘ ꠜꠣꠟꠣ ꠃꠡ꠆ꠔꠣꠖ ꠖꠞ꠆ꠎꠤꠞꠦꠖꠤ ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠡꠥꠔꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠀꠞ ꠡꠥꠘꠣꠖꠤ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX39_9","003_39_9","EXO","39","9","9","ꠁꠐꠣ ꠅꠁꠟ ꠟꠣꠝ꠆ꠛꠣꠄ ꠀꠗꠣ ꠀꠔ, ꠙꠣꠡꠦ ꠀꠗꠣ ꠀꠔ, ꠌꠣꠁꠞꠇꠥꠘꠤ ꠖꠥꠁ ꠜꠣꠁꠘ꠆ꠎ ꠇꠞꠣ ꠇꠣꠙꠠ। ");
INSERT INTO syls_vpl VALUES ("EX39_10","003_39_10","EXO","39","10","10","ꠄꠞ ꠃꠙꠞꠦ ꠔꠣꠞꠣ ꠌꠣꠁꠞ ꠢꠣꠁꠞ ꠇꠞꠤ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ ꠟꠣꠉꠣꠁꠟꠣ। ꠙꠄꠟꠣ ꠢꠣꠞꠤꠔ ꠁꠀꠇꠥꠔ, ꠙꠤꠔ ꠀꠞ ꠙꠣꠘ꠆ꠘꠣ ꠝꠘꠤ; ");
INSERT INTO syls_vpl VALUES ("EX39_11","003_39_11","EXO","39","11","11","ꠖꠥꠍꠞꠣ ꠢꠣꠞꠤꠔ ꠟꠣꠟꠝꠘꠤ, ꠟꠤꠟ ꠝꠘꠤ ꠀꠞ ꠢꠤꠞꠣ; ");
INSERT INTO syls_vpl VALUES ("EX39_12","003_39_12","EXO","39","12","12","ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠢꠣꠞꠤꠔ ꠚꠤꠞꠥꠎ, ꠉꠥꠝꠦꠖ ꠀꠞ ꠙꠖ꠆ꠖꠞꠣꠉ ꠝꠘꠤ; ");
INSERT INTO syls_vpl VALUES ("EX39_13","003_39_13","EXO","39","13","13","ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠢꠣꠞꠤꠔ ꠙꠥꠈꠞꠣꠎ, ꠛꠂꠖꠥꠞ꠆ꠎ ꠀꠞ ꠡꠥꠞꠥꠎ ꠝꠘꠤ। ꠁ ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟ ꠡꠥꠘꠣꠞ ꠎꠣꠎꠁꠞꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX39_14","003_39_14","EXO","39","14","14","ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠙꠥꠀꠞ ꠟꠣꠉꠤ ꠛꠣꠞꠅꠐꠣ ꠙꠣꠔ꠆ꠔꠞ ꠟꠣꠉꠣꠁꠟꠣ। ꠁꠔꠣ ꠄꠇꠅ ꠙꠣꠔ꠆ꠔꠞꠅ ꠄꠇ ꠄꠇ ꠙꠥꠀꠞ ꠘꠣꠝ ꠈꠥꠖꠤꠀ ꠟꠦꠈꠣ ꠅꠁꠟ, ꠎꠦꠟꠣ ꠈꠥꠖꠤꠀ ꠡꠤꠟ ꠛꠣꠘꠣꠁꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EX39_15","003_39_15","EXO","39","15","15","ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠞ ꠟꠣꠉꠤ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠞꠡꠤꠞ ꠟꠣꠈꠣꠘ ꠙꠦꠌꠣꠁꠀ ꠖꠥꠇꠍꠣ ꠌꠦꠁꠘ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_16","003_39_16","EXO","39","16","16","ꠀꠞ ꠡꠥꠘꠣꠞ ꠖꠥꠈꠣꠘ ꠎꠣꠎꠁꠞ ꠀꠞ ꠖꠥꠁꠐꠣ ꠇꠠꠣ ꠛꠣꠘꠣꠁꠀ, ꠛꠥꠇꠥꠞ ꠅꠃ ꠕꠟꠤꠞ ꠃꠙꠞꠞ ꠖꠥꠁ ꠇꠥꠘꠣꠔ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_17","003_39_17","EXO","39","17","17","ꠀꠞ ꠌꠦꠁꠘ ꠖꠥꠁꠅꠉꠦꠍꠣ ꠖꠥꠁꠅ ꠇꠠꠣꠞ ꠟꠉꠦ ꠀꠐꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_18","003_39_18","EXO","39","18","18","ꠖꠥꠁꠅ ꠇꠣꠘ꠆ꠖꠞ ꠄꠚꠞꠘꠞ ꠍꠣꠝꠘꠞ ꠚꠤꠔꠣꠔ ꠡꠥꠘꠣꠞ ꠎꠣꠎꠁꠞꠞ ꠟꠉꠦ ꠌꠦꠁꠘꠞ ꠄꠇ ꠝꠣꠕꠣ ꠛꠣꠘ꠆ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_19","003_39_19","EXO","39","19","19","ꠀꠞꠅ ꠖꠥꠁꠐꠣ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠛꠣꠘꠣꠁꠀ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠞ ꠖꠥꠁ ꠇꠥꠘꠣꠔ ꠟꠣꠉꠣꠁꠟꠣ। ꠁ ꠖꠥꠁꠅꠐꠣ ꠄꠚꠞꠘꠞ ꠟꠉꠦ ꠛꠥꠇꠥꠞ ꠕꠟꠤꠞ ꠔꠟꠦ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX39_20","003_39_20","EXO","39","20","20","ꠛꠣꠖꠦ ꠀꠞꠅ ꠖꠥꠁꠐꠣ ꠡꠥꠘꠣꠞ ꠇꠠꠣ ꠛꠣꠘꠣꠁꠀ, ꠄꠚꠞꠘꠞ ꠇꠣꠘ꠆ꠖꠞ ꠙꠐ꠆ꠐꠤꠞ ꠡꠁ ꠔꠟꠦꠖꠤ, ꠙꠦꠐꠞ ꠃꠙꠞꠞ ꠛꠦꠟꠐꠞ ꠃꠙꠞꠞ ꠡꠤꠟꠣꠁꠞ ꠇꠣꠍꠣꠔ ꠟꠣꠉꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_21","003_39_21","EXO","39","21","21","ꠀꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤꠞ ꠔꠟꠞ ꠇꠠꠣꠞ ꠟꠉꠦ ꠙꠦꠐꠞ ꠃꠙꠞꠞ ꠘꠇꠡꠣ ꠇꠞꠣ ꠛꠦꠟꠐꠞ ꠇꠠꠣ ꠛꠣꠘ꠆ꠖꠤꠟꠣ, ꠀꠞ ꠅꠃ ꠕꠟꠤꠄ ꠟꠠꠣ-ꠌꠠꠣ ꠘꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠟꠞ ꠇꠠꠣꠞ ꠟꠉꠦ ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠘ꠆ꠖꠤ ꠖꠤꠟꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_22","003_39_22","EXO","39","22","22","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠄꠚꠞꠘꠞ ꠔꠟꠞ ꠀꠟꠈꠦꠟ꠆ꠟꠣ ꠟꠤꠟꠥꠀ ꠞꠋꠉꠞ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠁꠘ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX39_23","003_39_23","EXO","39","23","23","ꠀꠞ ꠝꠣꠕꠣ ꠢꠣꠞꠣꠁꠛꠣꠞ ꠛꠣꠟꠣ ꠉꠟꠣꠞ ꠚꠣꠇ ꠍꠤꠠꠔ ꠘꠣ ꠇꠞꠤ ꠄꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣ ꠙꠐ꠆ꠐꠤ ꠖꠤꠀ ꠖꠠ ꠇꠞꠤ ꠛꠣꠁꠘ ꠇꠞꠟꠣ, ꠉꠟꠣꠞ ꠅꠃ ꠚꠣꠇ ꠞꠣꠈꠟꠣ ꠝꠣꠎ ꠛꠞꠣꠛꠞ। ");
INSERT INTO syls_vpl VALUES ("EX39_24","003_39_24","EXO","39","24","24","ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ, ꠟꠣꠟ ꠞꠋꠉꠞ ꠙꠦꠌꠣꠁꠟ ꠡꠥꠔꠣꠖꠤ ꠀꠘꠥꠀꠞ ꠚꠟꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠘꠣꠁꠟꠣ। ꠛꠣꠘꠣꠁꠀ ꠅꠉꠥꠁꠘꠞꠦ ꠀꠟꠈꠦꠟ꠆ꠟꠣꠞ ꠔꠟꠞ ꠝꠥꠠꠤꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_25","003_39_25","EXO","39","25","25","ꠛꠣꠖꠦ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠞ ꠊꠥꠋꠉꠥꠞ ꠛꠣꠘꠣꠁꠀ ꠅꠃ ꠀꠘꠥꠀꠞꠞ ꠚꠣꠇꠦ ꠚꠣꠇꠦ ꠟꠣꠉꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX39_26","003_39_26","EXO","39","26","26","ꠀꠡ꠆ꠔꠣ ꠔꠟꠞ ꠝꠥꠠꠤꠔ ꠄꠉꠥ ꠇꠞꠤ ꠀꠘꠥꠀꠞ ꠀꠞ ꠄꠉꠥ ꠇꠞꠤ ꠊꠥꠋꠉꠥꠞ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ। ꠄꠛꠣꠖꠔꠤ ꠇꠣꠝꠞ ꠛꠣꠟꠣ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠅꠃ ꠀꠟꠈꠦꠟ꠆ꠟꠣ ꠚꠤꠘ꠆ꠖꠤꠔꠣ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃꠟꠣ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX39_27","003_39_27","EXO","39","27","27","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠡꠥꠔꠣꠖꠤ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_28","003_39_28","EXO","39","28","28","ꠝꠣꠕꠣꠞ ꠙꠣꠃꠉꠠꠤ ꠀꠞ ꠔꠇꠤꠉꠥꠁꠘꠅ ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠛꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠢꠣꠚ-ꠙꠦꠘ꠆ꠐꠞ ꠟꠣꠈꠣꠘ ꠎꠣꠋꠉꠤꠀꠅ ꠛꠣꠘꠣꠁꠟꠣ ꠅꠃ ꠇꠣꠙꠠꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("EX39_29","003_39_29","EXO","39","29","29","ꠇꠝꠞꠞ ꠄꠇꠈꠣꠘ ꠛꠘ꠆ꠖꠘꠤ ꠛꠣꠘꠣꠁꠟꠣ, ꠖꠣꠝꠤ ꠡꠥꠔꠤ ꠇꠣꠙꠠ, ꠟꠤꠟꠥꠀ, ꠛꠣꠁꠋꠉꠘꠤ ꠀꠞ ꠟꠣꠟ ꠡꠥꠔꠣꠖꠤ ꠘꠇꠡꠣ ꠇꠞꠤ ꠛꠣꠘꠣꠁꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃꠟꠣ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX39_30","003_39_30","EXO","39","30","30","ꠀꠞ ꠙꠣꠃꠉꠠꠤꠞ ꠍꠣꠝꠘꠦ ꠟꠣꠉꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠈꠣꠐꠤ ꠡꠥꠘꠣꠞ ꠙꠣꠔꠖꠤ ꠄꠇꠈꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠔꠣꠎ ꠔꠤꠀꠞ ꠇꠞꠟꠣ। ꠡꠤꠟꠞ ꠃꠙꠞꠦ ꠎꠦꠟꠣ ꠈꠥꠖꠤꠀ ꠟꠦꠈꠣ ꠅꠄ, ꠅꠃ ꠙꠣꠔꠞ ꠃꠙꠞꠦ ꠅꠟꠣ ꠈꠥꠖꠤꠀ ꠟꠦꠈꠟꠣ, “ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠛꠤꠔ꠆ꠞ।” ");
INSERT INTO syls_vpl VALUES ("EX39_31","003_39_31","EXO","39","31","31","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠅꠃ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇꠃ ꠁ ꠙꠣꠔꠞꠦ ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣꠖꠤ ꠙꠣꠃꠉꠠꠤꠞ ꠍꠣꠝꠘꠦ ꠛꠣꠘ꠆ꠖꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_32","003_39_32","EXO","39","32","32","ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠡꠢ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠢꠇ꠆ꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠡꠦꠡ ꠅꠁꠟ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_33","003_39_33","EXO","39","33","33","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠟꠣꠉꠤ ꠛꠣꠘꠣꠁꠟ ꠢꠇ꠆ꠇꠟꠔꠣ ꠝꠥꠍꠣꠞ ꠇꠣꠍꠣꠔ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠔꠣꠞꠣ ꠀꠘꠟꠣ: ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ, ꠔꠣꠝ꠆ꠛꠥꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠢꠥꠇ, ꠚ꠆ꠞꠦꠁꠝ, ꠛꠣꠔ꠆ꠔꠤ, ꠈꠥꠐꠤ, ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ; ");
INSERT INTO syls_vpl VALUES ("EX39_34","003_39_34","EXO","39","34","34","ꠟꠣꠟ ꠞꠋ ꠇꠞꠣ ꠝꠦꠠꠣꠞ ꠌꠣꠝꠠꠣꠞ ꠍꠣꠘꠤ, ꠚꠥʼꠞ ꠌꠣꠝꠠꠣꠞ ꠍꠣꠘꠤ, ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠛꠦꠠꠣꠞ ꠙꠞ꠆ꠖꠣ; ");
INSERT INTO syls_vpl VALUES ("EX39_35","003_39_35","EXO","39","35","35","ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ, ꠡꠘ꠆ꠖꠥꠇ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ, ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣ; ");
INSERT INTO syls_vpl VALUES ("EX39_36","003_39_36","EXO","39","36","36","ꠐꠦꠛꠥꠟ, ꠐꠦꠛꠥꠟꠞ ꠢꠇꠟ ꠌꠤꠎ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ; ");
INSERT INTO syls_vpl VALUES ("EX39_37","003_39_37","EXO","39","37","37","ꠈꠣꠐꠤ ꠡꠥꠘꠣꠞ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠢꠇꠟ ꠌꠤꠎ, ꠎꠣꠟꠣꠘꠤꠞ ꠔꠦꠟ; ");
INSERT INTO syls_vpl VALUES ("EX39_38","003_39_38","EXO","39","38","38","ꠡꠥꠘꠣꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ, ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ, ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠀꠉꠞ, ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠖꠥꠀꠞꠞ ꠙꠞ꠆ꠖꠣ; ");
INSERT INTO syls_vpl VALUES ("EX39_39","003_39_39","EXO","39","39","39","ꠙꠤꠔꠟꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ, ꠙꠤꠔꠟꠞ ꠎꠣꠟꠤ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠅꠎꠥꠞ ꠉꠣꠝꠟꠣ ꠀꠞ ꠄꠞ ꠔꠟꠞ ꠌꠇꠤ-ꠈꠣꠐ; ");
INSERT INTO syls_vpl VALUES ("EX39_40","003_39_40","EXO","39","40","40","ꠃꠑꠣꠘꠞ ꠙꠞ꠆ꠖꠣꠁꠘ, ꠈꠥꠐꠤꠘ, ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ, ꠃꠑꠣꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠉꠦꠁꠐꠞ ꠙꠞ꠆ꠖꠣ, ꠃꠑꠣꠘꠞ ꠙꠦꠞꠦꠉ ꠀꠞ ꠖꠠꠤ; ꠄꠇ ꠇꠕꠣꠄ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠡꠢ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ; ");
INSERT INTO syls_vpl VALUES ("EX39_41","003_39_41","EXO","39","41","41","ꠀꠞ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ, ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠅ ꠁꠝꠣꠝꠔꠤꠞ ꠟꠦꠛꠣꠍ। ");
INSERT INTO syls_vpl VALUES ("EX39_42","003_39_42","EXO","39","42","42","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠦ ꠢꠇꠟ ꠇꠣꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX39_43","003_39_43","EXO","39","43","43","ꠢꠦꠡꠦ ꠝꠥꠍꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠤꠀ ꠛꠥꠎꠟꠣ, ꠝꠣꠛꠥꠖꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠅꠃ ꠟꠣꠈꠣꠘꠃ ꠇꠞꠣ ꠅꠁꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_1","003_40_1","EXO","40","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("EX40_2","003_40_2","EXO","40","2","2","“ꠔꠥꠝꠤ ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠔꠣꠞꠤꠈꠅ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠡꠢ ꠀꠝꠣꠞ ꠊꠞꠞꠦ ꠈꠣꠠꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_3","003_40_3","EXO","40","3","3","ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞꠦ ꠢꠣꠞꠣꠁꠀ, ꠝꠣꠎꠦ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠁꠀ ꠡꠘ꠆ꠖꠥꠇꠞꠦ ꠀꠅꠠꠦ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_4","003_40_4","EXO","40","4","4","ꠐꠦꠛꠥꠟꠞꠦꠅ ꠜꠤꠔꠞꠦ ꠢꠣꠞꠣꠁꠀ, ꠄꠞ ꠃꠙꠞꠞ ꠌꠤꠎ ꠅꠇꠟ ꠢꠣꠎꠣꠁꠅ। ꠛꠣꠖꠦ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ ꠜꠤꠔꠞꠦ ꠀꠘꠤꠀ ꠔꠣꠞ ꠌꠦꠞꠣꠉ ꠅꠇꠟ ꠎꠣꠟꠣꠁ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_5","003_40_5","EXO","40","5","5","ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠅ, ꠕꠁꠀ ꠀꠝꠣꠞ ꠊꠞꠞ ꠖꠥꠀꠞꠞ ꠙꠞ꠆ꠖꠣ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_6","003_40_6","EXO","40","6","6","ꠀꠝꠣꠞ ꠊꠞꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_7","003_40_7","EXO","40","7","7","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠅꠎꠥꠞ ꠉꠣꠝꠟꠣ ꠙꠣꠘꠤꠖꠤ ꠜꠞꠤꠀ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_8","003_40_8","EXO","40","8","8","ꠛꠣꠖꠦ ꠃꠑꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠁꠅ, ꠀꠞ ꠃꠑꠣꠘꠞ ꠉꠦꠁꠐꠅ-ꠅ ꠙꠞ꠆ꠖꠣ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_9","003_40_9","EXO","40","9","9","“ꠛꠣꠖꠦ ꠔꠥꠝꠤ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ ꠖꠤꠀ ꠀꠝꠣꠞ ꠊꠞ ꠀꠞ ꠀꠝꠣꠞ ꠊꠞꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ꠔꠦꠃ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠝꠢꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX40_10","003_40_10","EXO","40","10","10","ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦꠅ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ ꠖꠤꠀ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞꠦꠅ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ꠔꠦꠃ ꠁ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠝꠢꠣ-ꠙꠛꠤꠔ꠆ꠞ ꠌꠤꠎ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EX40_11","003_40_11","EXO","40","11","11","ꠅꠎꠥꠞ ꠙꠣꠘꠤꠞ ꠉꠣꠝꠟꠣ ꠀꠞ ꠄꠞ ꠔꠟꠞ ꠌꠇꠤ-ꠈꠣꠐꠞꠦꠅ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ ꠖꠤꠀ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_12","003_40_12","EXO","40","12","12","“ꠛꠣꠖꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘꠞꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠅꠀꠁ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_13","003_40_13","EXO","40","13","13","ꠘꠣꠅꠀꠘꠤꠞ ꠛꠣꠖꠦ ꠢꠣꠞꠥꠘꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠅꠇꠟ ꠚꠤꠘ꠆ꠖꠣꠁꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠁꠝꠣꠝ ꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠟꠣꠉꠣꠁꠀ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠀ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_14","003_40_14","EXO","40","14","14","ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠀꠘꠤꠀ ꠁꠝꠣꠝꠔꠤꠞ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ ꠚꠤꠘ꠆ꠖꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EX40_15","003_40_15","EXO","40","15","15","ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞꠦ ꠎꠦꠟꠣ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟꠖꠤ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠍ, ꠔꠣꠞꠣꠞꠦꠅ ꠅꠃꠟꠣ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠅ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠅ ꠀꠝꠣꠞ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ꠁ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠝꠣꠎꠖꠤ ꠁꠝꠣꠝꠔꠤꠞ ꠎꠦ ꠘꠤꠅꠝ ꠌꠣꠟꠥ ꠅꠁꠛ, ꠁꠔꠣ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠌꠣꠟꠥ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("EX40_16","003_40_16","EXO","40","16","16","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_17","003_40_17","EXO","40","17","17","ꠖꠥꠍꠞꠣ ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠔꠣꠞꠤꠈꠅ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠈꠣꠠꠣ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("EX40_18","003_40_18","EXO","40","18","18","ꠝꠥꠍꠣꠄ ꠁ ꠊꠞ ꠈꠣꠠꠣ ꠇꠞꠟꠣ, ꠙꠄꠟꠣ ꠄꠞ ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ ꠛꠅꠀꠁꠟꠣ, ꠈꠥꠐꠤꠘ ꠃꠛꠣ ꠇꠞꠟꠣ, ꠛꠦꠠꠣꠞ ꠚ꠆ꠞꠦꠁꠝ ꠟꠣꠉꠣꠁꠟꠣ, ꠚ꠆ꠞꠦꠁꠝꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠛꠣꠔ꠆ꠔꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_19","003_40_19","EXO","40","19","19","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠁꠘ ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣ ꠖꠤꠀ ꠊꠞꠞ ꠙꠄꠟꠣ ꠍꠣꠘꠤ ꠖꠤꠟꠣ, ꠄꠞ ꠃꠙꠞꠦ ꠖꠤꠟꠣ ꠀꠞꠅ ꠖꠥꠁꠐꠣ ꠍꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("EX40_20","003_40_20","EXO","40","20","20","ꠛꠣꠖꠦ ꠢꠃ ꠖꠥꠁꠅꠈꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠡꠣꠢꠣꠖꠔ ꠙꠣꠔ꠆ꠔꠞ ꠀꠘꠤꠀ ꠡꠘ꠆ꠖꠥꠇꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠞꠣꠁꠟꠣ। ꠡꠘ꠆ꠖꠥꠇ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ ꠟꠣꠉꠣꠁꠟꠣ, ꠡꠘ꠆ꠖꠥꠇꠞ ꠃꠙꠞꠞ ꠓꠣꠇꠘꠣꠅ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_21","003_40_21","EXO","40","21","21","ꠀꠞ ꠡꠘ꠆ꠖꠥꠇꠞꠦ ꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠞꠣꠁꠟꠣ। ꠢꠣꠞꠣꠁꠀ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠁꠀ ꠡꠘ꠆ꠖꠥꠇꠞꠦ ꠀꠅꠠꠦ ꠞꠣꠈꠟꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_22","003_40_22","EXO","40","22","22","ꠡꠘ꠆ꠖꠥꠇꠞ ꠅꠃ ꠙꠞ꠆ꠖꠣꠞ ꠛꠣꠞꠦ ꠃꠔ꠆ꠔꠞ ꠉꠣꠟꠣꠛꠣꠄ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠣꠎꠦ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤꠞ ꠐꠦꠛꠥꠟ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_23","003_40_23","EXO","40","23","23","ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ ꠢꠣꠎꠣꠁꠀ ꠕꠁꠟꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_24","003_40_24","EXO","40","24","24","ꠐꠦꠛꠥꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠇ꠆ꠇꠤꠘ ꠉꠣꠟꠣꠔ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_25","003_40_25","EXO","40","25","25","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠌꠦꠞꠣꠉ ꠉꠥꠁꠘ ꠎꠣꠟꠣꠁꠟꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_26","003_40_26","EXO","40","26","26","ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠣꠎꠈꠣꠘꠞ ꠙꠞ꠆ꠖꠣꠞ ꠍꠣꠝꠘꠦ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_27","003_40_27","EXO","40","27","27","ꠅꠈꠣꠘꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠀꠉꠞ ꠎꠣꠟꠣꠁꠟꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_28","003_40_28","EXO","40","28","28","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠖꠥꠀꠞꠞ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_29","003_40_29","EXO","40","29","29","ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠕꠁꠟꠣ। ꠕꠁꠀ ꠄꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠖꠤꠟꠣ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_30","003_40_30","EXO","40","30","30","ꠛꠣꠖꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠅꠎꠥꠞ ꠉꠣꠝꠟꠣ ꠕꠁꠟꠣ, ꠕꠁꠀ ꠅꠎꠥꠞ ꠙꠣꠘꠤ ꠜꠞꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_31","003_40_31","EXO","40","31","31","ꠅꠃ ꠙꠣꠘꠤ ꠖꠤꠀ ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠎꠥ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_32","003_40_32","EXO","40","32","32","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠘꠤꠞ ꠀꠉꠦ, ꠛꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠅꠀꠞ ꠀꠉꠦ ꠅꠎꠥ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_33","003_40_33","EXO","40","33","33","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠁꠀ ꠃꠑꠣꠘ ꠛꠣꠘꠣꠁꠟꠣ। ꠃꠑꠣꠘꠞ ꠉꠦꠁꠐꠞ ꠙꠞ꠆ꠖꠣ ꠟꠣꠉꠣꠁꠟꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠥꠍꠣꠄ ꠔꠣꠘ ꠢꠇꠟ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_34","003_40_34","EXO","40","34","34","ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠉꠣꠁꠛꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠀꠁꠀ ꠅꠃ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞꠦ ꠉꠥꠞꠤꠟꠤꠟ, ꠝꠣꠛꠥꠖꠞ ꠝꠢꠤꠝꠣ ꠀꠞ ꠇꠥꠖꠞꠔꠦ ꠀꠡ꠆ꠔꠣ ꠊꠞ ꠜꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("EX40_35","003_40_35","EXO","40","35","35","ꠄꠞꠟꠣꠉꠤ ꠝꠥꠍꠣ ꠀꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠄꠞ ꠃꠙꠞꠦ ꠢꠃ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠀꠍꠤꠟ, ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣꠄ ꠀꠡ꠆ꠔꠣ ꠊꠞ ꠜꠞꠤ ꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("EX40_36","003_40_36","EXO","40","36","36","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠅꠃ ꠀꠡ꠆ꠔꠣ ꠍꠚꠞꠞ ꠝꠣꠎꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠢꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠀꠐꠤꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_37","003_40_37","EXO","40","37","37","ꠅꠁꠟꠦ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠘꠣ ꠢꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠣ ꠛꠣꠞ ꠅꠁꠔꠣ ꠘꠣ, ꠅꠃ ꠈꠥꠐꠤ ꠢꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("EX40_38","003_40_38","EXO","40","38","38","ꠇꠣꠞꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠅꠃ ꠀꠡ꠆ꠔꠣ ꠍꠚꠞꠞ ꠝꠣꠎꠦꠃ, ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠔꠣꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠙꠞꠦ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠞꠁꠔ, ꠀꠞ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠞꠁꠔ ꠀꠉꠥꠁꠘꠞ ꠈꠥꠐꠤ॥");
INSERT INTO syls_vpl VALUES ("LV1_1","004_1_1","LEV","1","1","1","ꠅꠃ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞ ꠝꠣꠘꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠛꠣꠘꠣꠘꠤꠞ ꠛꠣꠖꠦ, ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠅꠘꠅ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV1_2","004_1_2","LEV","1","2","2","“ꠔꠥꠝꠤ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠥꠘꠥ ꠙꠡꠥ ꠖꠤꠔ ꠌꠣꠄ, ꠔꠦ ꠉꠞꠥ ꠛꠣ ꠍꠣꠉꠟ-ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠙꠡꠥ ꠀꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LV1_3","004_1_3","LEV","1","3","3","“ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠎꠥꠖꠤ ꠉꠞꠥꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠔ ꠌꠣꠄ, ꠔꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠘꠔꠦ ꠅꠁꠛ। ꠀꠘꠤꠀ ꠝꠣꠛꠥꠖꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠅꠃ ꠛꠤꠍꠣꠟꠞꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV1_4","004_1_4","LEV","1","4","4","ꠀꠁꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠀꠘꠣ ꠅꠃ ꠛꠤꠍꠣꠟꠞ ꠇꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠀꠔ ꠕꠁꠛ, ꠔꠦꠃ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠢꠤꠡꠣꠛꠦ ꠁꠐꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV1_5","004_1_5","LEV","1","5","5","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠛꠤꠍꠣꠟꠞꠦ ꠢꠦ ꠎꠛ ꠇꠞꠛ। ꠀꠞ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠎꠦ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠅꠃ ꠛꠤꠍꠣꠟꠞ ꠟꠃ ꠘꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV1_6","004_1_6","LEV","1","6","6","ꠛꠣꠖꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠅꠃ ꠛꠤꠍꠣꠟꠞ ꠈꠣꠟ ꠈꠣꠟꠤꠀ ꠢꠣꠞꠤ, ꠅꠉꠥꠞ ꠉꠥꠡ꠆ꠔ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV1_7","004_1_7","LEV","1","7","7","ꠀꠞ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟ ꠀꠋꠞꠣ ꠕꠁꠛꠣ, ꠄꠞ ꠃꠙꠞꠦ ꠖꠣꠞꠥ ꠢꠣꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV1_8","004_1_8","LEV","1","8","8","ꠢꠣꠎꠣꠁꠀ ꠅꠃ ꠖꠣꠞꠥꠞ ꠃꠙꠞꠦ ꠛꠤꠍꠣꠟꠞ ꠇꠟ꠆ꠟꠣ, ꠌꠞ꠆ꠛꠤ, ꠉꠥꠡ꠆ꠔꠞ ꠐꠥꠇꠞꠣꠁꠘ ꠕꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV1_9","004_1_9","LEV","1","9","9","ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠉꠞꠥꠞ ꠑꠦꠋ ꠀꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠣꠘꠤ ꠖꠤꠀ ꠗꠁꠀ ꠍꠣꠚ ꠇꠞꠤꠀ ꠖꠤꠛꠣ, ꠀꠞ ꠁꠝꠣꠝꠦ ꠅꠔꠣ ꠘꠤꠀ ꠀꠡ꠆ꠔꠣ ꠛꠤꠍꠣꠟꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠐꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠅꠃ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV1_10","004_1_10","LEV","1","10","10","“ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠍꠣꠉꠟ-ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠤ ꠅꠄ, ꠔꠦ ꠁꠇꠐꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠙꠣꠑꠣ ꠅꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV1_11","004_1_11","LEV","1","11","11","ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠁꠇꠐꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠔ꠆ꠔꠞ ꠉꠣꠟꠣꠔ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠎꠛ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠎꠦ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠅꠉꠥꠞ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV1_12","004_1_12","LEV","1","12","12","ꠛꠣꠖꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠁꠐꠣꠞ ꠉꠥꠡ꠆ꠔ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤ ꠇꠣꠐꠤꠀ ꠖꠤꠟꠦ, ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠅꠉꠥꠞ ꠌꠞ꠆ꠛꠤ, ꠇꠟ꠆ꠟꠣ ꠀꠞ ꠉꠥꠡ꠆ꠔꠞ ꠐꠥꠇꠞꠣꠁꠘ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠎꠣꠟꠣꠁꠟ ꠀꠋꠞꠣꠞ ꠃꠙꠞꠞ ꠖꠣꠞꠥꠞ ꠃꠙꠞꠦ ꠢꠣꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV1_13","004_1_13","LEV","1","13","13","ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠁꠐꠣꠞ ꠑꠦꠋ, ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠣꠘꠤ ꠖꠤꠀ ꠗꠁꠀ ꠍꠣꠚ ꠇꠞꠤꠀ ꠖꠤꠛꠣ, ꠀꠞ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠡꠝꠦꠔ ꠀꠡ꠆ꠔꠣ ꠙꠡꠥꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠐꠣ ꠅꠁꠟ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ, ꠅꠃ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV1_14","004_1_14","LEV","1","14","14","“ꠀꠞ ꠇꠥꠘꠥ ꠙꠣꠈꠤ ꠖꠤꠀ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠅꠃ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠅꠄ, ꠔꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠛꠣ ꠙꠣꠞꠅ ꠟꠁꠀ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV1_15","004_1_15","LEV","1","15","15","ꠀꠁꠟꠦ, ꠁꠝꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠗꠣꠞꠅ ꠉꠤꠀ ꠅꠃ ꠙꠣꠈꠤꠞ ꠇꠟ꠆ꠟꠣ ꠝꠥꠞꠣ ꠝꠣꠞꠤꠀ ꠍꠤꠠꠤꠀ ꠀꠟꠉꠣꠁꠀ ꠢꠣꠞꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠅꠃ ꠇꠟ꠆ꠟꠣꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ, ꠀꠞ ꠅꠉꠥꠞ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠄꠇ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV1_16","004_1_16","LEV","1","16","16","ꠁꠝꠣꠝꠦ ꠙꠣꠈꠤꠞ ꠜꠤꠔꠞꠞ ꠉꠤꠟꠣ-ꠕꠟꠤ ꠀꠞ ꠚꠁꠞ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠙꠥꠛ ꠉꠣꠟꠣꠞ ꠍꠣꠟꠤꠞ ꠐꠦꠇꠤꠞ ꠝꠣꠎꠦ ꠚꠣꠟꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV1_17","004_1_17","LEV","1","17","17","ꠀꠞ ꠅꠉꠥꠞ ꠒꠣꠈꠘꠣꠔ ꠗꠞꠤꠀ ꠅꠟꠣ ꠛꠣꠐꠦ ꠍꠤꠠꠤꠛꠣ, ꠎꠣꠔꠦ ꠁꠐꠣꠞ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠟꠉ ꠘꠣ ꠅꠄ। ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠁꠐꠣ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠎꠣꠟꠣꠁꠟ ꠀꠋꠞꠣꠞ ꠃꠙꠞꠞ ꠖꠣꠞꠥꠞ ꠃꠙꠞꠦ ꠕꠁꠀ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠐꠣꠅ ꠅꠁꠟ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ, ꠅꠃ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV2_1","004_2_1","LEV","2","1","1","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠗꠣꠘ-ꠉꠝ ꠖꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠖꠤꠔ ꠌꠣꠄ, ꠔꠦ ꠘꠤꠞꠦꠇ ꠝꠄꠖꠣ ꠖꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠛ। ꠅꠃ ꠝꠄꠖꠣꠞ ꠃꠙꠞꠦ ꠢꠦ ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ ꠀꠞ ꠟꠥꠛꠣꠘ-ꠀꠉꠞꠞ ꠗꠥꠘꠣ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV2_2","004_2_2","LEV","2","2","2","ꠖꠤꠀ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠎꠦ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠂꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠅꠔꠣ ꠟꠁꠀ ꠀꠁꠛ। ꠁꠝꠣꠝꠦ ꠅꠔꠣ ꠕꠣꠇꠤ ꠔꠦꠟ ꠝꠤꠡꠣꠁꠟ ꠄꠇ ꠝꠥꠁꠐ ꠝꠄꠖꠣ ꠀꠞ ꠢꠇꠟ ꠀꠉꠞ ꠟꠁꠀ, ꠔꠣꠞ ꠀꠘꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠛꠖꠟꠣ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠅꠃ ꠅꠋꠡꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV2_3","004_2_3","LEV","2","3","3","ꠎꠣꠟꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠎꠔꠈꠣꠘ ꠛꠣꠇꠤ ꠞꠁꠛ, ꠁꠔꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠙꠣꠁꠛꠣ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠋꠡ ꠅꠀꠄ, ꠛꠣꠌꠤ ꠎꠣꠅꠀ ꠅꠃ ꠝꠄꠖꠣ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("LV2_4","004_2_4","LEV","2","4","4","“ꠀꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠘ꠆ꠖꠥꠞꠤ ꠃꠘ꠆ꠖꠣꠟꠅ ꠢꠦꠖꠤꠀ ꠀꠘꠣ ꠇꠥꠘꠥ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠔ ꠌꠣꠄ, ꠔꠦ ꠔꠦꠟ ꠝꠤꠡꠣꠁꠟ ꠘꠤꠞꠦꠇ ꠝꠄꠖꠣ ꠖꠤꠀ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠛꠣ ꠛꠣꠘꠣꠁꠟ ꠞꠥꠐꠤꠔ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠀ ꠟꠁꠀ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV2_5","004_2_5","LEV","2","5","5","ꠀꠞ ꠅꠃ ꠍꠖꠉꠣꠞ ꠞꠥꠐꠤ ꠎꠥꠖꠤ ꠔꠣꠅꠀꠔ ꠢꠦꠖꠤꠀ ꠀꠘꠣ ꠅꠄ, ꠔꠦ ꠁꠔꠣ ꠔꠦꠟ ꠝꠤꠡꠣꠁꠟ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠘꠤꠞꠦꠇ ꠝꠄꠖꠣ ꠖꠤꠀ ꠛꠣꠘꠣꠁꠀ ꠀꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV2_6","004_2_6","LEV","2","6","6","ꠀꠘꠤꠀ ꠁꠔꠣ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤꠀ ꠄꠞ ꠃꠙꠞꠦ ꠔꠦꠟ ꠓꠣꠟꠤꠀ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠁꠔꠣꠅ ꠗꠣꠘ-ꠉꠝꠞ ꠄꠇ ꠘꠝꠥꠘꠣꠞ ꠍꠖꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("LV2_7","004_2_7","LEV","2","7","7","ꠀꠞ ꠅꠃ ꠍꠖꠉꠣꠞ ꠞꠥꠐꠤ ꠎꠥꠖꠤ ꠟꠥꠀꠠꠤꠞ ꠝꠣꠎꠦ ꠜꠣꠎꠤꠀ ꠀꠘꠣ ꠅꠄ, ꠔꠦ ꠁꠔꠣꠅ ꠔꠦꠟ ꠀꠞ ꠘꠤꠞꠦꠇ ꠝꠄꠖꠣ ꠖꠤꠀ ꠛꠣꠘꠣꠁꠀ ꠀꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV2_8","004_2_8","LEV","2","8","8","ꠅꠟꠣ ꠎꠦꠇꠥꠘꠥ ꠘꠝꠥꠘꠣꠄ ꠛꠣꠘꠣꠁꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠘꠤꠀ ꠁꠝꠣꠝꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠛꠣꠄ, ꠁꠝꠣꠝꠦ ꠁꠔꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠉꠦꠍꠦ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV2_9","004_2_9","LEV","2","9","9","ꠘꠤꠀ ꠔꠣꠞ ꠀꠘꠣ ꠅꠃ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠛꠖꠟꠣ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ, ꠁꠝꠣꠝꠦ ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠅꠋꠡ ꠀꠟꠉꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV2_10","004_2_10","LEV","2","10","10","ꠅꠃ ꠅꠋꠡ ꠎꠣꠟꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠎꠦꠔꠣ ꠞꠁꠛ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠙꠣꠁꠛꠣ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠋꠡ ꠅꠀꠄ, ꠛꠣꠌꠤ ꠎꠣꠅꠀ ꠅꠃ ꠍꠖꠉꠣꠞ ꠞꠥꠐꠤ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("LV2_11","004_2_11","LEV","2","11","11","“ꠀꠞ ꠢꠥꠘꠅ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠎꠔꠔꠣ ꠀꠘꠣ ꠅꠁꠛ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠎꠣꠘꠥ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠔꠤꠀꠞ ꠇꠞꠣ ꠅꠄ। ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣꠞ ꠝꠣꠟꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠈꠣꠝꠤꠞ ꠛꠣ ꠝꠃ ꠎꠣꠟꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV2_12","004_2_12","LEV","2","12","12","ꠔꠣ-ꠅ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠚꠄ-ꠚꠡꠟꠞ ꠍꠖꠉꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣ ꠝꠃ ꠛꠣ ꠈꠣꠝꠤꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠤꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠈꠣꠝꠤꠞ ꠛꠣ ꠝꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠎꠣꠟꠣꠁꠟ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV2_13","004_2_13","LEV","2","13","13","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠎꠔꠔꠣ ꠛꠣꠘꠣꠁꠀ ꠀꠘꠛꠣꠄ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠣꠎꠦ ꠘꠥꠘ ꠝꠤꠡꠣꠁꠛꠣꠄ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠀ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠔ ꠘꠥꠘ ꠖꠤꠔꠦ ꠚꠣꠃꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠘꠥꠘ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV2_14","004_2_14","LEV","2","14","14","“ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠖꠣꠅꠀ ꠗꠣꠘ-ꠉꠝꠞ ꠇꠥꠘꠥ ꠚꠡꠟ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠟꠁꠀ ꠀꠅ, ꠔꠦ ꠁꠔꠣ ꠝꠣꠠꠣ ꠖꠦꠅꠀ ꠇꠣꠌꠣ ꠘꠄꠀ ꠗꠣꠘ-ꠉꠝ ꠛꠣ ꠀꠡ꠆ꠔꠣ ꠍꠠꠣꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠢꠦꠖꠤꠀ ꠀꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV2_15","004_2_15","LEV","2","15","15","ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠔꠦꠟ ꠀꠞ ꠟꠥꠛꠣꠘ-ꠀꠉꠞ ꠖꠤꠛꠣꠄ, ꠁꠔꠣ ꠅꠁꠟ ꠄꠇ ꠘꠝꠥꠘꠣꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("LV2_16","004_2_16","LEV","2","16","16","ꠅꠃ ꠍꠖꠉꠣ ꠟꠁꠀ ꠀꠁꠟꠦ, ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠅꠃ ꠎꠘꠞ ꠀꠘꠣ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠇꠤꠍꠥ ꠅꠋꠡ, ꠇꠤꠍꠥ ꠔꠦꠟ ꠀꠞ ꠢꠇꠟ ꠀꠉꠞ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ, ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV3_1","004_3_1","LEV","3","1","1","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠉꠣꠁ ꠛꠣ ꠛꠤꠍꠣꠟꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔ ꠌꠣꠄ, ꠔꠦ ꠁ ꠉꠞꠥ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠅꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV3_2","004_3_2","LEV","3","2","2","ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠅꠃ ꠙꠡꠥꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁꠀ ꠖꠤꠀ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠁꠐꠣꠞꠦ ꠎꠛ ꠇꠞꠛ। ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠝꠣꠎꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠅꠉꠥꠞ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV3_3","004_3_3","LEV","3","3","3","ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠘꠣ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠅꠃ ꠅꠋꠡ ꠅꠇꠟ ꠖꠤꠛꠣ। ꠅꠉꠥꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ");
INSERT INTO syls_vpl VALUES ("LV3_4","004_3_4","LEV","3","4","4","ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠀꠞ ꠅꠔꠣꠞ ꠌꠞ꠆ꠛꠤ, ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ, ꠅꠃ ꠢꠇꠟꠔꠣ ꠀꠘꠤꠀ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV3_5","004_3_5","LEV","3","5","5","ꠛꠣꠖꠦ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠢꠣꠎꠣꠁꠟ ꠖꠣꠞꠥ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠃꠙꠞꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠞꠣꠈꠤꠀ ꠄꠇꠟꠉꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠔꠣ ꠔ ꠄꠇ ꠘꠝꠥꠘꠣꠞ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV3_6","004_3_6","LEV","3","6","6","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠣꠉꠟ-ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠙꠡꠥꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔ ꠇꠞꠦ, ꠔꠦ ꠁ ꠙꠡꠥ ꠝꠦꠖꠣ ꠛꠣ ꠝꠦꠖꠤ ꠅꠁꠟꠦꠅ ꠌꠟꠛ, ꠅꠁꠟꠦ ꠁꠐꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠅꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV3_7","004_3_7","LEV","3","7","7","ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠎꠥꠖꠤ ꠝꠦꠠꠣ ꠀꠘꠦ, ꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠁꠐꠣ ꠀꠎꠤꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV3_8","004_3_8","LEV","3","8","8","ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠅꠃ ꠝꠦꠠꠣꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁ ꠖꠤꠀ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠁꠐꠣꠞꠦ ꠎꠛ ꠇꠞꠛ। ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠝꠣꠎꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠅꠉꠥꠞ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV3_9","004_3_9","LEV","3","9","9","ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠀꠘꠣ, ꠅꠃ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠖꠤꠛꠣ। ꠔꠣꠁꠘ ꠌꠞ꠆ꠛꠤ ꠀꠟꠣ ꠟꠦꠋꠉꠥꠠ, ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠁꠔꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠟ ꠌꠞ꠆ꠛꠤ, ");
INSERT INTO syls_vpl VALUES ("LV3_10","004_3_10","LEV","3","10","10","ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠀꠞ ꠅꠔꠣꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤ, ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ, ꠅꠔꠣ ꠢꠇꠟꠔꠣ ꠀꠘꠤꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV3_11","004_3_11","LEV","3","11","11","ꠁꠝꠣꠝꠦ ꠁꠔꠣ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠀꠉꠥꠘꠤꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ, ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠈꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV3_12","004_3_12","LEV","3","12","12","“ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠢꠦ ꠎꠥꠖꠤ ꠍꠣꠉꠟ ꠀꠘꠦ, ꠔꠦ ꠢꠦ ꠁꠐꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV3_13","004_3_13","LEV","3","13","13","ꠢꠦ ꠅꠉꠥꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁ ꠖꠤꠀ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠁꠐꠣꠞꠦ ꠎꠛ ꠇꠞꠛ, ꠛꠣꠖꠦ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠉꠥꠞ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV3_14","004_3_14","LEV","3","14","14","ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠄ ꠙꠡꠥꠞ ꠅꠃ ꠅꠋꠡ ꠅꠇꠟ ꠘꠤꠀ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠖꠤꠛ। ꠢꠦ ꠙꠡꠥꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠁꠔꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠟ ꠌꠞ꠆ꠛꠤ, ");
INSERT INTO syls_vpl VALUES ("LV3_15","004_3_15","LEV","3","15","15","ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠀꠞ ꠅꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ, ꠅꠔꠣ ꠢꠇꠟꠔꠣ ꠀꠘꠤꠀ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV3_16","004_3_16","LEV","3","16","16","ꠁꠝꠣꠝꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ, ꠁꠔꠣ ꠔ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠈꠣꠘꠤ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ। “ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠢꠇ꠆ꠇꠟ ꠌꠞ꠆ꠛꠤ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ। ");
INSERT INTO syls_vpl VALUES ("LV3_17","004_3_17","LEV","3","17","17","ꠔꠥꠝꠞꠣ ꠛꠋꠡꠞ ꠙꠞ ꠛꠋꠡ ꠗꠞꠤꠀ ꠅꠃ ꠘꠤꠅꠝ ꠝꠣꠘꠤꠅ, ꠎꠦꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠛꠡꠔ ꠇꠞꠅ ꠘꠣ ꠇꠦꠘꠦ ꠇꠥꠘꠥꠖꠤꠘ ꠌꠞ꠆ꠛꠤ ꠛꠣ ꠟꠃ ꠈꠣꠁꠅ ꠘꠣ, ꠁꠔꠣ ꠢꠣꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LV4_1","004_4_1","LEV","4","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV4_2","004_4_2","LEV","4","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠘꠣ ꠎꠣꠘꠣꠞ ꠇꠣꠞꠘꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠜꠥꠟ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠘꠤꠡꠦꠗ ꠇꠞꠣ ꠇꠥꠘꠥ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠔꠣꠁꠘ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_3","004_4_3","LEV","4","3","3","“ꠄꠁꠘ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠅꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠍꠣꠛ ꠅꠁꠟꠦ, ꠔꠣꠘ ꠉꠥꠘꠣꠞ ꠖꠣꠄ-ꠜꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠛꠞ꠆ꠔꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠘ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_4","004_4_4","LEV","4","4","4","ꠅꠃ ꠛꠤꠍꠣꠟ ꠟꠁꠀ ꠔꠣꠁꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠛꠣ, ꠀꠁꠀ ꠅꠉꠥꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁ ꠖꠤꠀ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠎꠛ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_5","004_4_5","LEV","4","5","5","ꠇꠞꠤꠀ ꠅꠃ ꠛꠤꠍꠣꠟꠞ ꠕꠥꠠꠣ ꠟꠃ ꠘꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_6","004_4_6","LEV","4","6","6","ꠉꠤꠀ ꠟꠃꠞ ꠝꠣꠎꠦ ꠘꠤꠎꠞ ꠀꠋꠉꠥꠟ ꠍꠥꠛꠣꠁꠀ ꠟꠃ ꠟꠣꠉꠣꠁꠀ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣꠞ ꠛꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠡꠣꠔ ꠛꠣꠞ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_7","004_4_7","LEV","4","7","7","ꠛꠣꠖꠦ ꠀꠞꠅ ꠕꠥꠠꠣ ꠟꠃ ꠟꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠞ ꠢꠤꠋ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠣꠁꠛꠣ। ꠀꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠟꠃ ꠘꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_8","004_4_8","LEV","4","8","8","ꠛꠣꠖꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠛꠤꠍꠣꠟꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤ ꠛꠣꠞ ꠇꠞꠛꠣ, ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠁꠔꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠟ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤ, ");
INSERT INTO syls_vpl VALUES ("LV4_9","004_4_9","LEV","4","9","9","ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠀꠞ ꠅꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠀꠞ ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("LV4_10","004_4_10","LEV","4","10","10","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠞꠥꠞ ꠌꠞ꠆ꠛꠤꠞ ꠟꠣꠈꠣꠘ, ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠛꠤꠍꠣꠟꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤꠞꠦꠅ ꠅꠟꠣ ꠛꠣꠞ ꠇꠞꠛꠣ। ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠅꠃ ꠌꠞ꠆ꠛꠤ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_11","004_4_11","LEV","4","11","11","ꠅꠁꠟꠦ ꠅꠃ ꠛꠤꠍꠣꠟꠞ ꠇꠟ꠆ꠟꠣ, ꠈꠣꠟ, ꠉꠥꠡ꠆ꠔ, ꠑꠦꠋ, ꠀꠔ-ꠜꠠ, ꠉꠥꠚꠞ, ");
INSERT INTO syls_vpl VALUES ("LV4_12","004_4_12","LEV","4","12","12","ꠢꠇꠟꠔꠣ ꠘꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠎꠦꠈꠣꠘꠅ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠍꠣꠟꠤꠞ ꠐꠦꠇꠤ ꠕꠂꠘ, ꠢꠃ ꠙꠣꠇ-ꠍꠣꠚ ꠎꠣꠉꠣꠞ ꠍꠣꠟꠤꠞ ꠐꠦꠇꠤꠞ ꠃꠙꠞꠦ ꠅꠔꠣ ꠕꠁꠀ ꠢꠣꠞꠤ, ꠟꠣꠇꠠꠤꠞ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_13","004_4_13","LEV","4","13","13","“ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎ ꠘꠣ ꠎꠣꠘꠣꠞ ꠇꠣꠞꠘꠦ ꠎꠥꠖꠤ ꠜꠥꠟ ꠇꠞꠤꠀ ꠇꠥꠘꠥ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠤꠟꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠤꠡꠦꠗ ꠇꠞꠣ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠤꠀ ꠖꠥꠡꠤ ꠛꠘꠤꠎꠣꠄ, ꠔꠦ ꠘꠣ ꠎꠣꠘꠤꠀ ꠇꠞꠟꠦꠅ ꠔꠣꠞꠣ ꠢꠇꠟꠃ ꠉꠥꠘꠣꠉꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LV4_14","004_4_14","LEV","4","14","14","ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠞꠣ ꠎꠣꠘꠛꠣ, ꠎꠣꠘꠤꠀ ꠢꠣꠞꠤ ꠅꠃ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠇꠟꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠄꠉꠥ ꠛꠤꠍꠣꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣ, ꠅꠃ ꠛꠤꠍꠣꠟ ꠟꠁꠀ ꠔꠣꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_15","004_4_15","LEV","4","15","15","ꠅꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠅꠃ ꠛꠤꠍꠣꠟꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁ ꠖꠤꠛꠣ, ꠀꠞ ꠁꠝꠣꠝꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠅꠇꠐꠣ ꠎꠛ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_16","004_4_16","LEV","4","16","16","ꠎꠛꠞ ꠛꠣꠖꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠅꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠛꠤꠍꠣꠟꠞ ꠕꠥꠠꠣ ꠟꠃ ꠟꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_17","004_4_17","LEV","4","17","17","ꠢꠣꠝꠣꠁꠀ ꠅꠃ ꠟꠃꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠔꠞ ꠀꠋꠉꠥꠁꠟ ꠍꠥꠛꠣꠁꠀ, ꠕꠥꠠꠣ ꠟꠃ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣꠞ ꠛꠣꠄ ꠡꠣꠔ ꠛꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠍꠤꠐꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_18","004_4_18","LEV","4","18","18","ꠛꠣꠖꠦ ꠀꠞꠅ ꠕꠥꠠꠣ ꠟꠃ ꠟꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠅꠀ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟꠞ ꠢꠤꠋ ꠅꠇꠟꠅ ꠟꠣꠉꠣꠁꠛꠣ। ꠛꠣꠖ-ꠛꠣꠇꠤ ꠟꠃ ꠚꠥꠐꠣꠁꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_19","004_4_19","LEV","4","19","19","ꠀꠞ ꠛꠤꠍꠣꠟꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_20","004_4_20","LEV","4","20","20","ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠤꠍꠣꠟꠞꠦ ꠎꠦꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠄ, ꠁꠝꠣꠝꠦ ꠅꠃ ꠛꠤꠍꠣꠟꠞꠦꠅ ꠅꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠛꠣ। ꠔꠣꠁꠘ ꠅꠃ ꠡꠝꠣꠎꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠟꠦ, ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠝꠤꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("LV4_21","004_4_21","LEV","4","21","21","ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠛꠤꠍꠣꠟꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟꠔꠣ ꠟꠁꠀ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠎꠣꠁꠛꠣ। ꠉꠤꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠢꠃ ꠛꠤꠍꠣꠟꠞ ꠟꠣꠈꠣꠘ ꠅꠃ ꠛꠤꠍꠣꠟꠞ ꠢꠇꠟꠔꠣꠅ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠅꠟꠣ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠀꠡ꠆ꠔꠣ ꠡꠝꠣꠎꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV4_22","004_4_22","LEV","4","22","22","“ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠥꠘꠥ ꠡꠞ꠆ꠖꠣꠞꠦ ꠘꠣ ꠎꠣꠘꠣꠞ ꠇꠣꠞꠘꠦ ꠎꠥꠖꠤ ꠜꠥꠟ ꠇꠞꠤꠀ ꠅꠟꠣ ꠉꠥꠘꠣ ꠇꠞꠤꠟꠣꠁꠘ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠤꠡꠦꠗ ꠇꠞꠣ ꠇꠣꠝ ꠇꠞꠣꠄ ꠔꠣꠁꠘ ꠔ ꠖꠥꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("LV4_23","004_4_23","LEV","4","23","23","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠅꠃ ꠉꠥꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠣꠘꠤꠟꠤꠛꠣ, ꠎꠣꠘꠣꠞ ꠛꠣꠖꠦ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟ ꠟꠁꠀ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_24","004_4_24","LEV","4","24","24","ꠀꠁꠀ ꠅꠃ ꠙꠣꠑꠣꠞ ꠇꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠀ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ ꠎꠛ ꠇꠞꠣꠞ ꠎꠣꠉꠣꠔ ꠘꠤꠀ ꠅꠉꠥꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠎꠛ ꠇꠞꠛꠣ। ꠁꠔꠣ ꠔ ꠔꠣꠘ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV4_25","004_4_25","LEV","4","25","25","ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠅꠃ ꠙꠡꠥꠞ ꠕꠥꠠꠣ ꠟꠃ ꠔꠣꠘ ꠀꠔꠞ ꠀꠋꠉꠥꠟꠤꠔ ꠇꠞꠤ ꠟꠁꠀ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠤꠋ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠛꠣ। ꠛꠣꠖ-ꠛꠣꠇꠤ ꠟꠃ ꠘꠤꠀ ꠔꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_26","004_4_26","LEV","4","26","26","ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠌꠞ꠆ꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠅꠉꠥꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠁꠝꠣꠝꠦ ꠢꠃ ꠡꠞ꠆ꠖꠣꠞꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠟꠦ, ꠔꠣꠁꠘ ꠝꠣꠚꠤ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_27","004_4_27","LEV","4","27","27","“ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠥꠘꠥ ꠡꠣꠗꠣꠞꠘ ꠎꠘꠦ ꠘꠣ ꠎꠣꠘꠣꠞ ꠇꠣꠞꠘꠦ ꠎꠥꠖꠤ ꠜꠥꠟ ꠇꠞꠤꠀ ꠇꠥꠘꠥ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠤꠟꠣꠄ, ꠝꠣꠛꠥꠖꠞ ꠘꠤꠡꠦꠗ ꠇꠞꠣ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠤꠀ ꠖꠥꠡꠤ ꠛꠘꠤꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV4_28","004_4_28","LEV","4","28","28","ꠔꠦ ꠢꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠣꠘꠤꠟꠤꠛ, ꠎꠣꠘꠤꠀ ꠅꠃ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠦ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠍꠣꠉꠤ ꠟꠁꠀ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV4_29","004_4_29","LEV","4","29","29","ꠀꠁꠀ ꠅꠃ ꠍꠣꠉꠤꠞ ꠇꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠀ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠛꠞ ꠎꠣꠉꠣꠔ ꠘꠤꠀ ꠅꠉꠥꠞꠦ ꠎꠛ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV4_30","004_4_30","LEV","4","30","30","ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠣꠘ ꠀꠔꠞ ꠀꠋꠉꠥꠟꠤꠔ ꠇꠞꠤ ꠅꠉꠥꠞ ꠕꠥꠠꠣ ꠟꠃ ꠟꠣꠉꠣꠁꠀ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠤꠋ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠛꠣ। ꠛꠣꠖ-ꠛꠣꠇꠤ ꠟꠃ ꠔꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_31","004_4_31","LEV","4","31","31","ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠌꠞ꠆ꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠅꠉꠥꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠁꠝꠣꠝꠦ ꠢꠃ ꠎꠘꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠟꠦ, ꠔꠣꠞ ꠝꠣꠚꠤ ꠝꠤꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("LV4_32","004_4_32","LEV","4","32","32","“ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠦꠠꠣ ꠀꠘꠦ, ꠔꠦ ꠁꠐꠣ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠤ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV4_33","004_4_33","LEV","4","33","33","ꠢꠦ ꠅꠉꠥꠞ ꠇꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠀ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠎꠛꠞ ꠎꠣꠉꠣꠔ ꠘꠤꠀ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠅꠉꠥꠞꠦ ꠎꠛ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV4_34","004_4_34","LEV","4","34","34","ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠣꠘ ꠀꠔꠞ ꠀꠋꠉꠥꠟꠤꠔ ꠇꠞꠤ ꠅꠃ ꠝꠦꠠꠤꠞ ꠕꠥꠠꠣ ꠟꠃ ꠟꠁꠀ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠤꠋ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠛꠣ। ꠛꠣꠖ-ꠛꠣꠇꠤ ꠟꠃ ꠔꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV4_35","004_4_35","LEV","4","35","35","ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠌꠞ꠆ꠛꠤ ꠎꠦꠟꠣ ꠛꠣꠞ ꠇꠞꠂꠘ, ꠅꠉꠥꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤꠞꠦꠅ ꠅꠟꠣ ꠛꠣꠞ ꠇꠞꠛꠣ। ꠛꠣꠞ ꠇꠞꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞꠦ ꠕꠁꠀ ꠅꠃ ꠌꠞ꠆ꠛꠤꠞꠦꠅ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ, ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠁꠝꠣꠝꠦ ꠢꠃ ꠎꠘꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠢꠦ ꠝꠣꠚꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_1","004_5_1","LEV","5","1","1","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠣ ꠛꠣ ꠇꠣꠘꠦ ꠢꠥꠘꠣ ꠇꠥꠘꠥ ꠊꠐꠘꠣ ꠎꠣꠘꠦ, ꠀꠞ ꠛꠤꠌꠣꠞꠞ ꠇꠣꠟꠅ ꠀꠖꠣꠟꠔꠅ ꠡꠣꠇ꠆ꠇꠤꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠀꠅ ꠡꠣꠇ꠆ꠇꠤ ꠘꠣ ꠖꠦꠄ, ꠔꠦ ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠢꠦ ꠉꠥꠘꠣ ꠇꠞꠦ, ꠔꠣꠞ ꠁ ꠅꠙꠞꠣꠗꠞ ꠡꠣꠎꠣ ꠢꠦ ꠛꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_2","004_5_2","LEV","5","2","2","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠣ ꠎꠣꠘꠤꠀ ꠇꠥꠘꠥ ꠘꠣꠙꠣꠇ ꠎꠤꠘꠤꠡ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠢꠦ ꠘꠣꠙꠣꠇ ꠀꠞ ꠖꠥꠡꠤ ꠛꠘꠛ। ꠁꠔꠣ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠎꠋꠟꠤ ꠢꠣꠞꠣꠝ ꠝꠞꠣ ꠙꠡꠥ, ꠊꠞꠅ ꠙꠣꠟꠣ ꠇꠥꠘꠥ ꠝꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠛꠣ ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠦꠇꠥꠘꠥ ꠝꠞꠣ ꠎꠣꠘꠖꠣꠞꠞꠦ ꠘꠣ ꠎꠣꠘꠤꠀ ꠍꠁꠟꠦꠅ ꠖꠥꠡꠤ-ꠘꠣꠙꠣꠇ ꠛꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_3","004_5_3","LEV","5","3","3","“ꠝꠣꠘꠡꠞ ꠡꠞꠤꠟꠞꠦ ꠎꠦꠔꠣꠄ ꠘꠣꠙꠣꠇ ꠇꠞꠤꠟꠣꠄ, ꠡꠞꠤꠟ ꠕꠣꠇꠤ ꠛꠣꠞꠅꠁꠟ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥꠔꠣ ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠣ ꠎꠣꠘꠤꠀ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠁꠔꠣ ꠎꠣꠘꠣꠞ ꠛꠣꠖꠦ ꠢꠦ ꠖꠥꠡꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_4","004_5_4","LEV","5","4","4","“ꠀꠈꠟ-ꠛꠤꠛꠦꠇ ꠘꠣ ꠈꠣꠐꠣꠁꠀ ꠀꠈꠔꠣ ꠎꠥꠖꠤ ꠇꠦꠃ ꠇꠥꠘꠥ ꠇꠍꠝ ꠇꠞꠤꠟꠣꠄ, ꠜꠣꠟꠣ ꠛꠣ ꠛꠥꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠝꠥ ꠇꠁꠀ ꠝꠘꠞ ꠛꠦ-ꠈꠤꠀꠟꠦ ꠇꠦꠃ ꠇꠥꠘꠥ ꠇꠍꠝ ꠈꠣꠁꠟꠦꠅ, ꠢꠦ ꠎꠦꠛꠟꠣ ꠁꠈꠣꠘ ꠛꠥꠎꠤꠟꠤꠛ ꠅꠃ ꠡꠝꠄ ꠢꠦ ꠖꠥꠡꠤ ꠛꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_5","004_5_5","LEV","5","5","5","“ꠅꠃ ꠟꠣꠈꠣꠘ ꠎꠦꠇꠥꠘꠥ ꠅꠙꠞꠣꠗ ꠇꠞꠤꠀ ꠇꠦꠃ ꠖꠥꠡꠤ ꠛꠘꠤꠉꠦꠟꠦ, ꠢꠦ ꠘꠤꠎꠞ ꠉꠥꠘꠣꠞꠦ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_6","004_5_6","LEV","5","6","6","ꠀꠞ ꠅꠃ ꠉꠥꠘꠣꠞ ꠎꠞꠤꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠄꠇꠐꠣ ꠝꠦꠠꠤ ꠛꠣ ꠍꠣꠉꠤ ꠀꠘꠛ, ꠀꠞ ꠁꠝꠣꠝꠦ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV5_7","004_5_7","LEV","5","7","7","“ꠀꠞ ꠢꠦ ꠎꠥꠖꠤ ꠝꠦꠠꠤ ꠛꠣ ꠍꠣꠉꠤ ꠀꠘꠔꠦ ꠅꠙꠣꠞꠉ ꠅꠄ, ꠔꠦ ꠅꠃ ꠉꠥꠘꠣꠞ ꠎꠞꠤꠝꠣꠘꠣ ꠛꠣꠛꠔ ꠖꠥꠁꠐꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠛꠣ ꠙꠣꠞꠅ ꠀꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠁꠔꠣꠞ ꠝꠣꠎꠞ ꠄꠉꠥ ꠅꠁꠛ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠖꠥꠍꠞꠣꠐꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV5_8","004_5_8","LEV","5","8","8","ꠀꠞ ꠢꠦ ꠁꠔꠣ ꠀꠘꠤꠀ ꠁꠝꠣꠝꠞ ꠀꠔꠅ ꠖꠤꠛ, ꠁꠝꠣꠝꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠙꠄꠟꠣ ꠄꠉꠥ ꠙꠣꠈꠤꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣ। ꠔꠣꠁꠘ ꠅꠉꠥꠞ ꠇꠟ꠆ꠟꠣ ꠝꠥꠞꠣꠁꠀ ꠝꠣꠞꠛꠣ, ꠅꠁꠟꠦ ꠇꠟ꠆ꠟꠣ ꠀꠟꠉꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV5_9","004_5_9","LEV","5","9","9","ꠛꠣꠖꠦ ꠅꠉꠥꠞ ꠕꠥꠠꠣ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ, ꠀꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠟꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤ ꠖꠤꠛꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV5_10","004_5_10","LEV","5","10","10","ꠀꠞ ꠖꠥꠍꠞꠣ ꠙꠣꠈꠤꠐꠣꠞꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣ। ꠖꠤꠀ, ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ꠔꠦꠃ ꠢꠦ ꠝꠣꠚꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_11","004_5_11","LEV","5","11","11","“ꠀꠞ ꠎꠥꠖꠤ ꠅꠃ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠁꠐꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠛꠣ ꠙꠣꠞꠅ ꠀꠘꠔ ꠘꠣ ꠙꠣꠞꠦ, ꠔꠦ ꠢꠦ ꠖꠥꠁ ꠡꠦꠞ ꠝꠄꠖꠣ ꠀꠘꠔꠦ ꠅꠁꠛ। ꠁꠔꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠀꠄ ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠔꠦꠟ ꠛꠣ ꠟꠥꠛꠣꠘ-ꠀꠉꠞ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV5_12","004_5_12","LEV","5","12","12","ꠅꠃ ꠝꠄꠖꠣ ꠟꠁꠀ ꠢꠦ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛ, ꠉꠦꠟꠦ ꠅꠃ ꠀꠡ꠆ꠔꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠛꠖꠟꠣ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠄꠇ ꠝꠥꠁꠐ ꠝꠄꠖꠣ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV5_13","004_5_13","LEV","5","13","13","ꠢꠦ ꠎꠦ ꠅꠙꠞꠣꠗ ꠇꠞꠍꠦ, ꠅꠔꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠁꠝꠣꠝꠦ ꠅꠟꠣ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ꠔꠦꠃ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠙꠣꠁꠛ। ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠁ ꠝꠄꠖꠣꠞ ꠎꠔꠈꠣꠘ ꠞꠁꠛ, ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠁꠝꠣꠝꠦ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LV5_14","004_5_14","LEV","5","14","14","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV5_15","004_5_15","LEV","5","15","15","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠣ ꠎꠣꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠘꠥ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠄꠝꠘꠦꠃ ꠇꠥꠘꠥ ꠖꠥꠡ-ꠇꠍꠥꠞꠤ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠅꠃ ꠉꠥꠘꠣꠞ ꠎꠞꠤꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠎꠔ ꠔꠟꠣ ꠞꠥꠙꠣꠖꠤ ꠝꠦꠠꠣꠞ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠣ ꠅꠄ, ꠔꠦ ꠢꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠅꠃ ꠙꠞꠤꠝꠣꠘ ꠖꠣꠝꠞ ꠛꠣ ꠢꠝꠣꠘ ꠖꠣꠝꠖꠤ ꠇꠤꠘꠤꠀ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠁꠔꠣ ꠔ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV5_16","004_5_16","LEV","5","16","16","ꠀꠞ ꠢꠦ ꠅꠃ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠦ ꠖꠥꠡ-ꠇꠍꠥꠞꠤ ꠇꠞꠍꠦ, ꠁꠔꠣꠞ ꠈꠦꠔꠤ-ꠙꠥꠞꠘꠅ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠢꠦ ꠅꠃ ꠝꠦꠠꠣꠞ ꠖꠣꠝꠞ ꠟꠉꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠙꠞꠤꠝꠣꠘ ꠘꠉꠖ ꠐꠦꠇꠣ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠀꠔꠅ ꠖꠤꠛ। ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞ ꠇꠍꠥꠞꠤ ꠝꠣꠚꠤꠞ ꠘꠤꠅꠔꠦ ꠅꠃ ꠝꠦꠠꠣꠞꠦ ꠘꠤꠀ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠢꠦ ꠝꠣꠚꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_17","004_5_17","LEV","5","17","17","“ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠜꠥꠟ ꠇꠞꠤꠀ ꠘꠣ ꠎꠣꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠘꠤꠡꠦꠗ ꠇꠞꠣ ꠇꠥꠘꠥ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠣꠝ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠢꠦ ꠖꠥꠡꠤ। ꠁ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠖꠣꠄꠁ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_18","004_5_18","LEV","5","18","18","ꠢꠦ ꠔꠣꠞ ꠅꠃ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣ ꠢꠤꠡꠣꠛꠦ, ꠄꠉꠥ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠛꠣ ꠄꠞ ꠖꠣꠝ ꠀꠘꠤꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠖꠤꠛ। ꠢꠦ ꠘꠣ ꠎꠣꠘꠤꠀ ꠎꠦ ꠖꠥꠡ-ꠇꠍꠥꠞꠤ ꠇꠞꠤꠟꠤꠍꠦ, ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠅꠔꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ꠔꠦꠃ ꠔꠣꠞ ꠝꠣꠚꠤ ꠝꠤꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("LV5_19","004_5_19","LEV","5","19","19","ꠁꠔꠣ ꠔ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠡ ꠇꠞꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LV6_1","004_6_1","LEV","6","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV6_2","004_6_2","LEV","6","2","2","“ꠢꠥꠘꠅ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠟꠉꠦ ꠢꠣꠞꠣꠝꠤ ꠇꠞꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠉꠥꠘꠣ ꠇꠞꠦ, ꠔꠣꠞ ꠉꠦꠍꠦ ꠕꠅꠀ ꠀꠝꠣꠘꠔ ꠛꠣ ꠛꠘ꠆ꠗꠇꠤ ꠎꠤꠘꠤꠡꠞ ꠈꠤꠀꠘꠔ ꠇꠞꠦ, ꠛꠣ ꠌꠥꠞꠤ ꠇꠞꠤ ꠇꠥꠘꠥ ꠝꠣꠟ ꠘꠦꠄ ꠛꠣ ꠐꠉꠣ-ꠐꠉꠤ ꠇꠞꠦ, ꠍꠟ-ꠌꠔꠥꠞꠤ ꠇꠞꠤꠀ ꠛꠦꠁꠝꠣꠘꠤ ꠝꠣꠔꠦ, ");
INSERT INTO syls_vpl VALUES ("LV6_3","004_6_3","LEV","6","3","3","ꠔꠥꠛꠣꠁꠀ ꠙꠣꠅꠀ ꠝꠣꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠝꠣꠔꠦ ꠛꠣ ꠅꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘꠥ ꠝꠤꠍꠣ ꠇꠍꠝ ꠈꠣꠄ, ꠛꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠞꠅ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠇꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("LV6_4","004_6_4","LEV","6","4","4","ꠔꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠞ ꠉꠥꠘꠣ ꠇꠞꠤꠀ ꠅꠙꠞꠣꠗꠤ ꠛꠘꠣꠄ, ꠢꠦ ꠎꠦꠔꠣ ꠝꠣꠟ ꠀꠔ꠆ꠔꠡꠣꠔ ꠇꠞꠍꠦ, ꠛꠣ ꠍꠟ-ꠌꠔꠥꠞꠤ ꠇꠞꠤꠀ ꠘꠤꠍꠦ, ꠛꠣ ꠀꠝꠣꠘꠔꠞ ꠈꠤꠀꠘꠔ ꠇꠞꠍꠦ, ꠔꠥꠛꠣꠁ ꠙꠣꠅꠀ ꠝꠣꠟ ꠟꠥꠇꠣꠁꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LV6_5","004_6_5","LEV","6","5","5","ꠛꠣ ꠎꠦꠇꠥꠘꠥ ꠝꠣꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠤꠍꠣ ꠇꠍꠝ ꠈꠣꠁꠍꠦ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠢꠦ ꠚꠤꠞꠔ ꠖꠤꠛ, ꠄꠞꠟꠉꠦ ꠎꠞꠤꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠛꠦꠡꠤ ꠖꠤꠛ। ꠢꠦ ꠎꠦꠖꠤꠘ ꠔꠣꠞ ꠖꠥꠡ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠛ, ꠅꠃ ꠖꠤꠘ ꠝꠣꠟꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠁꠔꠣ ꠚꠤꠞꠣꠁ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV6_6","004_6_6","LEV","6","6","6","ꠀꠞ ꠘꠤꠎꠞ ꠖꠥꠡ-ꠇꠍꠥꠞꠤ ꠝꠣꠚꠤꠞ ꠘꠤꠅꠔꠦ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠥꠞꠛꠣꠘꠤ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠛ, ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠑꠤꠇ ꠇꠞꠣ ꠖꠣꠝꠞ ꠄꠉꠥ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠟꠁꠀ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV6_7","004_6_7","LEV","6","7","7","ꠁꠝꠣꠝꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ꠢꠦ ꠅꠔꠣꠞ ꠝꠣꠎꠞ ꠎꠦꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠇꠞꠟꠦ, ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠙꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LV6_8","004_6_8","LEV","6","8","8","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV6_9","004_6_9","LEV","6","9","9","“ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠢꠤꠇꠣꠁ ꠖꠦꠅ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠝꠥꠍꠟꠣ ꠅꠁꠟ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ ꠚꠎꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠣꠞꠣ ꠞꠣꠁꠔ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠀꠉꠥꠘꠤꠞ ꠃꠙꠞꠦ ꠞꠁꠛ, ꠀꠞ ꠀꠉꠥꠁꠘꠅ ꠎꠣꠟꠣꠁꠟ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV6_10","004_6_10","LEV","6","10","10","ꠛꠤꠀꠘꠤ ꠛꠣꠟꠣ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠢꠣꠚ-ꠙꠦꠘ꠆ꠐꠞ ꠟꠣꠈꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠋꠉꠤꠀꠈꠣꠘ ꠀꠞ ꠔꠣꠘ ꠁꠝꠣꠝꠔꠤꠞ ꠛꠣꠇꠤ ꠢꠇꠟ ꠡꠥꠔꠤꠞ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠛꠣ। ꠚꠤꠘ꠆ꠖꠤꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ ꠎꠣꠟꠣꠘꠤꠞ ꠍꠣꠟꠤ ꠔꠥꠟꠤꠀ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠕꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV6_11","004_6_11","LEV","6","11","11","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠃ ꠟꠦꠛꠣꠍ ꠛꠖꠟꠣꠁꠀ, ꠖꠥꠍꠞꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠀ, ꠅꠃ ꠍꠣꠟꠤꠞꠦ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠇꠥꠘꠥ ꠙꠣꠇ-ꠍꠣꠚ ꠎꠣꠉꠣꠔ ꠘꠤꠀ ꠚꠣꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV6_12","004_6_12","LEV","6","12","12","ꠅꠁꠟꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠀꠉꠥꠁꠘ ꠎꠣꠟꠣꠁꠟ ꠞꠁꠛ, ꠁꠔꠣ ꠘꠤꠜꠔ ꠘꠣ। ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠁꠝꠣꠝꠦ ꠅꠃ ꠀꠉꠥꠘꠤꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠘꠤꠞ ꠖꠣꠞꠥ ꠖꠤꠛꠣ, ꠖꠤꠀ ꠖꠣꠞꠥꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞꠦ ꠢꠣꠎꠣꠁꠛꠣ, ꠢꠣꠎꠣꠁꠀ ꠄꠞ ꠃꠙꠞꠦ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠌꠞ꠆ꠛꠤꠞꠦ ꠎꠣꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV6_13","004_6_13","LEV","6","13","13","ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠀꠉꠥꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠎꠟꠣꠔ ꠞꠁꠛ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠘꠤꠜꠔ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV6_14","004_6_14","LEV","6","14","14","“ꠗꠣꠘ-ꠉꠝ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠝ ꠅꠁꠟ, ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ ꠕꠣꠇꠤ ꠄꠇꠎꠘ ꠁꠝꠣꠝꠦ ꠅꠃ ꠍꠖꠉꠣꠞ ꠝꠄꠖꠣ ꠀꠞ ꠖꠞꠇꠣꠞꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠟꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV6_15","004_6_15","LEV","6","15","15","ꠀꠞ ꠁꠝꠣꠝꠦ ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠄꠇ ꠝꠥꠁꠐ ꠝꠄꠖꠣ, ꠇꠤꠍꠥ ꠔꠦꠟ ꠀꠞ ꠍꠖꠉꠣꠞ ꠢꠇꠟ ꠟꠥꠛꠣꠘ-ꠀꠉꠞ ꠘꠤꠀ ꠀꠡ꠆ꠔꠣ ꠍꠖꠉꠣꠞ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠅꠃ ꠅꠋꠡꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠛꠣ। ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠔ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV6_16","004_6_16","LEV","6","16","16","ꠍꠖꠉꠣꠞ ꠝꠣꠟꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠅꠋꠡ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠈꠣꠁꠛꠣ। ꠔꠣꠞꠣ ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠈꠣꠝꠤꠞ ꠘꠣ ꠝꠤꠡꠣꠁꠀ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠁꠛꠣ, ꠛꠣꠘꠣꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠃꠑꠣꠘꠅ ꠇꠥꠘꠥ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠛꠁꠀ ꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV6_17","004_6_17","LEV","6","17","17","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠇꠥꠘꠥ ꠈꠣꠝꠤꠞ ꠙꠥꠞꠣꠁꠀ ꠁꠔꠣꠞꠦ ꠍꠦꠇꠤꠅ ꠘꠣ। ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠅꠋꠡ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠟꠣꠝ। ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠅꠃ ꠅꠋꠡꠅ ꠅꠁꠟ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("LV6_18","004_6_18","LEV","6","18","18","ꠈꠣꠟꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠛꠋꠡꠞ ꠢꠇꠟ ꠛꠦꠐꠣ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠅꠋꠡ ꠔ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠔꠣꠞꠣꠃ ꠙꠣꠁꠛꠣ। ꠈꠥꠛ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠎꠦꠍꠣꠔꠣꠄ ꠁꠔꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠛ, ꠅꠔꠣꠅ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠛꠘꠤꠎꠤꠛ, ꠝꠣꠘꠤ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LV6_19","004_6_19","LEV","6","19","19","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV6_20","004_6_20","LEV","6","20","20","“ꠢꠣꠞꠥꠘꠦ ꠎꠦꠖꠤꠘ ꠁꠝꠣꠝꠔꠤꠞ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠀ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟ ꠅꠁꠛꠣ, ꠅꠃ ꠖꠤꠘ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠖꠥꠁ ꠡꠦꠞ ꠝꠄꠖꠣ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠘꠛꠣ। ꠁꠔꠣꠞ ꠅꠞ꠆ꠗꠦꠇ ꠛꠤꠀꠘꠦ ꠀꠞ ꠅꠞ꠆ꠗꠦꠇ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV6_21","004_6_21","LEV","6","21","21","ꠔꠣꠞꠣ ꠔꠦꠟ ꠖꠤꠀ ꠈꠣꠁ ꠛꠣꠘꠣꠁꠀ ꠔꠣꠅꠀꠔ ꠍꠦꠇꠤꠀ ꠢꠣꠞꠟꠦ ꠁꠔꠣ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠀꠎꠤꠞ ꠇꠞꠛꠣ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV6_22","004_6_22","LEV","6","22","22","ꠢꠣꠞꠥꠘꠞ ꠛꠣꠖꠦ ꠔꠣꠞ ꠎꠦ ꠙꠥꠀꠞꠦ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠢꠦ-ꠅ ꠅꠃꠟꠣ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠛ। ꠁꠔꠣ ꠔ ꠝꠣꠛꠥꠖꠞ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠙꠣꠅꠘꠣ, ꠅꠃ ꠍꠖꠉꠣꠞ ꠙꠥꠞꠣ ꠅꠋꠡ ꠎꠣꠟꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV6_23","004_6_23","LEV","6","23","23","ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠘꠤꠎꠞ ꠖꠦꠅꠀ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠟꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ, ꠁꠔꠣ ꠈꠣꠅꠀꠞ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LV6_24","004_6_24","LEV","6","24","24","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV6_25","004_6_25","LEV","6","25","25","“ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠝ ꠢꠤꠇꠣꠅ। ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠎꠛ ꠇꠞꠂꠘ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞꠦꠅ ꠅꠘꠅ ꠎꠛ ꠇꠞꠛꠣ। ꠁ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("LV6_26","004_6_26","LEV","6","26","26","ꠎꠦ ꠁꠝꠣꠝꠦ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ꠄꠁꠘ ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛꠣ। ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠃꠑꠣꠘꠅ ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠉꠣꠔ ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV6_27","004_6_27","LEV","6","27","27","ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡꠦ ꠅꠃ ꠉꠥꠡ꠆ꠔꠞꠦ ꠍꠁꠛ, ꠁꠔꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠎꠤꠛ। ꠇꠥꠘꠥ ꠇꠣꠙꠠꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠄꠞ ꠟꠃꠞ ꠍꠤꠐꠣ ꠟꠣꠉꠦ, ꠔꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠁꠔꠣ ꠗꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV6_28","004_6_28","LEV","6","28","28","ꠀꠞ ꠝꠣꠐꠤꠞ ꠎꠦ ꠙꠣꠔꠤꠟꠅ ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠞꠣꠘ꠆ꠖꠣ ꠅꠁꠛ, ꠁꠔꠣ ꠛꠣꠖꠦ ꠜꠣꠋꠉꠤꠟꠤꠛꠣꠄ। ꠅꠁꠟꠦ ꠙꠤꠔꠟꠞ ꠙꠣꠔꠤꠟꠅ ꠞꠣꠘ꠆ꠖꠤꠟꠦ ꠁꠐꠣ ꠝꠣꠘ꠆ꠎꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠗꠁꠀ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV6_29","004_6_29","LEV","6","29","29","ꠁꠝꠣꠝ ꠛꠋꠡꠞ ꠎꠦꠇꠥꠘꠥ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ, ꠁꠔꠣ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠉꠥꠡ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("LV6_30","004_6_30","LEV","6","30","30","ꠅꠁꠟꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠟꠃ ꠎꠥꠖꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠘꠦꠅꠀ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠁ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠅꠀ ꠘꠤꠡꠦꠗ, ꠁꠔꠣ ꠎꠣꠟꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_1","004_7_1","LEV","7","1","1","“ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠥꠍꠟꠣ ꠅꠁꠟ, ꠁ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("LV7_2","004_7_2","LEV","7","2","2","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠎꠛ ꠇꠞꠣ ꠅꠄ, ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞꠦꠅ ꠅꠘꠅ ꠎꠛ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠁꠔꠣꠞ ꠟꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠍꠤꠐꠣꠁ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_3","004_7_3","LEV","7","3","3","ꠀꠞ ꠁꠔꠣꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤꠞꠦ ꠟꠁꠛ, ꠝꠣꠘꠤ ꠌꠞ꠆ꠛꠤ ꠀꠟꠣ ꠟꠦꠋꠉꠥꠠ, ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ");
INSERT INTO syls_vpl VALUES ("LV7_4","004_7_4","LEV","7","4","4","ꠄꠞ ꠟꠉꠦ ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠀꠞ ꠅꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠀꠞ ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ, ꠁ ꠢꠇꠟꠔꠣ ꠀꠟꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_5","004_7_5","LEV","7","5","5","ꠀꠟꠉꠣꠁꠀ ꠁꠝꠣꠝꠦ ꠅꠃ ꠢꠇꠟꠔꠣ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ, ꠁꠔꠣ ꠅꠁꠟ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV7_6","004_7_6","LEV","7","6","6","ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠁꠝꠣꠝ ꠙꠞꠤꠛꠣꠞꠞ ꠎꠦꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠝꠣꠘꠡꠦ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ꠁꠔꠣ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠎꠦꠇꠥꠘꠥ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠛꠁꠀ ꠈꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_7","004_7_7","LEV","7","7","7","“ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠔ ꠄꠇꠁ ꠘꠝꠥꠘꠣꠞ। ꠎꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠅꠃ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞꠦ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ꠄꠁꠘ ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_8","004_7_8","LEV","7","8","8","ꠀꠞ ꠎꠦ ꠁꠝꠣꠝꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ꠄꠁꠘ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠌꠣꠝꠠꠣꠅ ꠘꠤꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_9","004_7_9","LEV","7","9","9","ꠟꠥꠀꠠꠤꠔ, ꠔꠣꠅꠀꠔ ꠛꠣ ꠔꠥꠘ꠆ꠖꠥꠞꠤ ꠃꠘ꠆ꠖꠣꠟꠅ ꠢꠦꠖꠤꠀ ꠀꠘꠣ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠞꠥꠐꠤ ꠈꠣꠟꠤ ꠢꠃ ꠁꠝꠣꠝꠦ ꠙꠣꠁꠛꠣ, ꠎꠦꠁꠘ ꠁ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LV7_10","004_7_10","LEV","7","10","10","ꠅꠁꠟꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟ ꠍꠖꠉꠣ, ꠁꠔꠣ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠛꠣ ꠢꠥꠇꠘꠣ ꠎꠦꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠅꠃꠇ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠢꠇꠟ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠁꠔꠣꠞ ꠢꠝꠣꠘ ꠛꠣꠐ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_11","004_7_11","LEV","7","11","11","“ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠝ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("LV7_12","004_7_12","LEV","7","12","12","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠄ, ꠔꠦ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠟꠉꠦ ꠔꠦꠟ ꠝꠤꠡꠣꠁꠟ ꠘꠤꠞꠦꠇ ꠝꠄꠖꠣ ꠖꠤꠀ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠛꠣ ꠛꠣꠘꠣꠁꠟ ꠞꠥꠐꠤꠔ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠀ ꠟꠁꠀ ꠀꠁꠛ, ꠛꠣ ꠔꠦꠟ ꠝꠤꠡꠣꠁꠟ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠘꠤꠞꠦꠇ ꠝꠄꠖꠣꠞ ꠙꠤꠑꠣ ꠛꠣꠘꠣꠁꠀ ꠀꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_13","004_7_13","LEV","7","13","13","ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠤꠘꠤꠡꠞ ꠟꠉꠦ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠕꠥꠠꠣ ꠞꠥꠐꠤꠅ ꠀꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_14","004_7_14","LEV","7","14","14","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠦ ꠅꠃ ꠙꠞꠔꠦꠇ ꠎꠤꠘꠤꠡ ꠕꠣꠇꠤ ꠄꠇꠐꠣ ꠄꠇꠐꠣ ꠇꠞꠤ ꠀꠘꠛ। ꠎꠦ ꠁꠝꠣꠝꠦ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠟꠃ ꠍꠤꠐꠣꠁꠛꠣ, ꠄꠁꠘ ꠁꠔꠣ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_15","004_7_15","LEV","7","15","15","ꠡꠥꠇꠥꠞꠣꠘꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠖꠦꠅꠀ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠅꠃ ꠖꠤꠘꠃ ꠈꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ꠁꠔꠣ ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠇꠥꠞ ꠟꠣꠉꠤ ꠕꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV7_16","004_7_16","LEV","7","16","16","“ꠅꠃ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠘ꠆ꠘꠔ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠖꠦꠅ, ꠛꠣ ꠄꠝꠘꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅ, ꠔꠦ ꠁꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠅꠃ ꠖꠤꠘꠃ ꠈꠣꠁꠅ, ꠀꠞ ꠇꠤꠍꠥ ꠛꠣꠇꠤ ꠞꠁꠟꠦ ꠛꠣꠖꠞ ꠖꠤꠘꠅ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV7_17","004_7_17","LEV","7","17","17","ꠅꠁꠟꠦ ꠖꠥꠁ ꠖꠤꠘ ꠛꠣꠖꠦ ꠁ ꠉꠥꠡ꠆ꠔ ꠞꠁꠟꠦ, ꠁꠔꠣ ꠎꠣꠟꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_18","004_7_18","LEV","7","18","18","ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠁ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠟꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠛꠥꠟ ꠅꠁꠔ ꠘꠣꠄ। ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠞ ꠀꠝꠟ-ꠘꠣꠝꠣꠔ ꠁꠔꠣ ꠃꠐꠔ ꠘꠣꠄ, ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠔ ꠘꠣꠙꠣꠇ ꠅꠁꠉꠦꠍꠦ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠈꠣꠁꠟꠦ ꠔꠣꠞꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠉꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_19","004_7_19","LEV","7","19","19","“ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠘꠣꠙꠣꠇ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠟꠣꠉꠤꠉꠦꠟꠦ, ꠁ ꠉꠥꠡ꠆ꠔꠞ ꠁ ꠅꠋꠡ ꠀꠞ ꠈꠣꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ, ꠁꠔꠣ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ꠅꠁꠟꠦ ꠛꠣꠇꠤ ꠉꠥꠡ꠆ꠔ ꠈꠣꠅꠀ ꠎꠣꠁꠛ, ꠙꠣꠇ-ꠍꠣꠚ ꠢꠣꠟꠔꠦ ꠎꠦ ꠇꠥꠘꠥ ꠎꠘꠦ ꠁꠔꠣ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_20","004_7_20","LEV","7","20","20","ꠀꠞ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀ ꠅꠃ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠟꠣꠄ, ꠔꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_21","004_7_21","LEV","7","21","21","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠙꠡꠥꠞ ꠛꠣ ꠝꠣꠘꠡꠞ ꠇꠥꠘꠥ ꠘꠣꠙꠣꠇ ꠎꠤꠘꠤꠡ ꠍꠁꠀ ꠢꠣꠞꠤ ꠛꠣ ꠖꠥꠍꠞꠣ ꠘꠣꠙꠣꠇ ꠇꠥꠘ꠆ꠔꠣ ꠍꠁꠀ ꠢꠣꠞꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠟꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠘꠣꠝꠅ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠝꠤꠐꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LV7_22","004_7_22","LEV","7","22","22","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV7_23","004_7_23","LEV","7","23","23","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠥꠝꠞꠣ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠛꠣ ꠝꠦꠠꠣꠞ ꠇꠥꠘꠥꠎꠣꠔ ꠌꠞ꠆ꠛꠤ ꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_24","004_7_24","LEV","7","24","24","ꠇꠥꠘꠥ ꠝꠞꠣ ꠙꠡꠥꠞ ꠛꠣ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠝꠣꠞꠣ ꠙꠡꠥꠞ ꠌꠞ꠆ꠛꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV7_25","004_7_25","LEV","7","25","25","ꠎꠔ ꠘꠝꠥꠘꠣꠞ ꠙꠡꠥ ꠖꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠄ, ꠁꠔꠣ ꠎꠣꠔꠞ ꠙꠡꠥꠞ ꠌꠞ꠆ꠛꠤ ꠎꠦꠉꠥꠄ ꠈꠣꠁꠛ, ꠔꠣꠞ ꠘꠣꠝꠞꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV7_26","004_7_26","LEV","7","26","26","ꠔꠥꠝꠞꠣ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠛꠡꠔ ꠇꠞꠅ ꠘꠣ ꠇꠦꠘꠦ, ꠇꠥꠘꠥꠎꠣꠔ ꠙꠡꠥ ꠛꠣ ꠙꠣꠈꠤꠞ ꠟꠃ ꠈꠣꠅꠀ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV7_27","004_7_27","LEV","7","27","27","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠟꠃ ꠈꠣꠄ, ꠔꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LV7_28","004_7_28","LEV","7","28","28","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV7_29","004_7_29","LEV","7","29","29","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠎꠦꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠇꠥꠘꠥ ꠙꠡꠥ ꠖꠤꠀ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠟꠦ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔꠞ ꠄꠇꠐꠣ ꠅꠋꠡ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV7_30","004_7_30","LEV","7","30","30","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠅꠋꠡ, ꠝꠣꠘꠤ ꠍꠤꠘꠣ ꠀꠞ ꠍꠤꠘꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ ꠢꠦ ꠘꠤꠎꠞ ꠀꠔꠦ ꠀꠘꠤꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞꠦ ꠖꠤꠛ। ꠁꠝꠣꠝꠦ ꠁꠔꠣꠞꠦ ꠃꠌꠣ ꠇꠞꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠖꠥꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_31","004_7_31","LEV","7","31","31","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠌꠞ꠆ꠛꠤꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ, ꠅꠁꠟꠦ ꠅꠃ ꠍꠤꠘꠣꠞ ꠉꠥꠡ꠆ꠔ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_32","004_7_32","LEV","7","32","32","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠒꠣꠁꠘꠞ ꠞꠣꠘꠞ ꠉꠥꠡ꠆ꠔ ꠁꠝꠣꠝ ꠍꠣꠛꠞꠦ ꠖꠤꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV7_33","004_7_33","LEV","7","33","33","ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠛꠋꠡꠞ ꠎꠦ ꠇꠦꠃ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠟꠃ ꠀꠞ ꠌꠞ꠆ꠛꠤꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣ, ꠔꠣꠘ ꠙꠣꠅꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠅꠃ ꠞꠣꠘꠞ ꠉꠥꠡ꠆ꠔ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV7_34","004_7_34","LEV","7","34","34","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠅꠀ ꠢꠇꠟ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠕꠣꠇꠤ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠍꠤꠘꠣ ꠀꠞ ꠒꠣꠁꠘꠞ ꠞꠣꠘꠞ ꠉꠥꠡ꠆ꠔ ꠀꠝꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠖꠤꠟꠣꠝ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠁ ꠅꠋꠡ ꠅꠁꠟ ꠔꠣꠞꠣꠞ ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠙꠣꠅꠘꠣ ꠢꠇ।” ");
INSERT INTO syls_vpl VALUES ("LV7_35","004_7_35","LEV","7","35","35","ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠎꠦꠖꠤꠘ ꠕꠣꠇꠤ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠢꠃ ꠖꠤꠘ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠅꠋꠡꠞꠦ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠢꠇ ꠢꠤꠡꠣꠛꠦ ꠗꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV7_36","004_7_36","LEV","7","36","36","ꠔꠣꠞꠣꠞꠦ ꠎꠦꠖꠤꠘ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠣꠁꠀ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠢꠃ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔꠞ ꠅꠃ ꠅꠋꠡ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠄꠞꠣꠞꠦ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LV7_37","004_7_37","LEV","7","37","37","ꠁꠔꠣ ꠅꠁꠟ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠝꠣꠝꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠍꠖꠉꠣ, ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠝ। ");
INSERT INTO syls_vpl VALUES ("LV7_38","004_7_38","LEV","7","38","38","ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠖꠤꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ ꠔꠣꠘ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠤꠘꠤꠡ ꠀꠘꠣꠞ ꠟꠣꠉꠤ, ꠢꠃ ꠖꠤꠘ ꠔꠣꠁꠘ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠅꠃ ꠢꠇ꠆ꠇꠟ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠎꠣꠘꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_1","004_8_1","LEV","8","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV8_2","004_8_2","LEV","8","2","2","“ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠟꠁꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠎꠤꠞ ꠅꠅ। ꠄꠞ ꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠟꠦꠛꠣꠍ, ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠔꠦꠟ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠛꠤꠍꠣꠟ, ꠖꠥꠉꠥ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠀꠞ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠐꠥꠇꠞꠤꠅ ꠀꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV8_3","004_8_3","LEV","8","3","3","ꠀꠞ ꠔꠥꠝꠤ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠖꠟꠣ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("LV8_4","004_8_4","LEV","8","4","4","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ, ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠖꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_5","004_8_5","LEV","8","5","5","ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ ꠁꠔꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("LV8_6","004_8_6","LEV","8","6","6","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠍꠣꠝꠘꠦ ꠀꠘꠤꠀ ꠙꠣꠘꠤ ꠖꠤꠀ ꠘꠣꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_7","004_8_7","LEV","8","7","7","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠣꠞꠥꠘꠞꠦ ꠁꠝꠣꠝꠔꠤ ꠟꠦꠛꠣꠍꠞ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ ꠚꠤꠘ꠆ꠖꠣꠁꠀ ꠢꠣꠞꠤ ꠇꠝꠞꠞ ꠛꠘ꠆ꠖꠘꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠀꠟꠈꠦꠟ꠆ꠟꠣ ꠀꠞ ꠄꠚꠞꠘ ꠚꠤꠘ꠆ꠖꠣꠁꠀ ꠙꠦꠐꠞ ꠃꠙꠞꠞ ꠘꠇꠡꠣ ꠇꠞꠣ ꠇꠣꠙꠠꠞꠦ ꠚꠤꠔꠣꠖꠤ ꠛꠣꠘ꠆ꠖꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_8","004_8_8","LEV","8","8","8","ꠛꠣꠖꠦ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠕꠟꠤ ꠚꠤꠘ꠆ꠖꠣꠁꠀ ꠄꠞ ꠜꠤꠔꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠃꠞꠤꠝ ꠀꠞ ꠔꠥꠝ꠆ꠝꠤꠝ ꠢꠣꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_9","004_8_9","LEV","8","9","9","ꠄꠞꠛꠣꠖꠦ ꠢꠣꠞꠥꠘꠞ ꠝꠣꠕꠣꠔ ꠙꠣꠃꠉꠠꠤ ꠚꠤꠘ꠆ꠖꠣꠁꠀ ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠔꠣꠎ, ꠝꠣꠘꠤ ꠡꠥꠘꠣꠞ ꠙꠣꠔꠈꠣꠘ ꠙꠣꠃꠉꠠꠤꠞ ꠍꠣꠝꠘꠣꠛꠣꠄ ꠟꠣꠉꠣꠁꠟꠣ। ꠝꠥꠍꠣꠄ ꠁ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("LV8_10","004_8_10","LEV","8","10","10","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠀꠞ ꠄꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞꠦ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠔꠦꠟ ꠖꠤꠀ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_11","004_8_11","LEV","8","11","11","ꠅꠃ ꠔꠦꠟ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠔꠦꠟ ꠘꠤꠀ ꠔꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠡꠣꠔ ꠛꠣꠞ ꠍꠤꠐꠣꠁꠟꠣ। ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠢꠣꠘ꠆ꠒꠤ-ꠛꠣꠡꠘ, ꠀꠞ ꠅꠎꠥꠞ ꠙꠣꠘꠤꠞ ꠉꠣꠝꠟꠣ ꠀꠞ ꠄꠞ ꠔꠟꠞ ꠌꠇꠤ-ꠈꠣꠐꠞꠦ, ꠔꠦꠟ ꠖꠤꠀ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_12","004_8_12","LEV","8","12","12","ꠀꠞꠅ ꠕꠥꠠꠣ ꠔꠦꠟ ꠘꠤꠀ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠝꠣꠕꠣꠞ ꠝꠣꠎꠦ ꠓꠣꠟꠤꠀ ꠔꠣꠘꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠛꠘꠣꠞ ꠟꠣꠉꠤ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_13","004_8_13","LEV","8","13","13","ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠍꠣꠝꠘꠦ ꠀꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠔꠞꠅ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ, ꠇꠝꠞꠞ ꠛꠘ꠆ꠖꠘꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠢꠣꠞꠤ ꠝꠣꠕꠣꠞ ꠔꠇꠤ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ। ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ ꠔꠣꠁꠘ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("LV8_14","004_8_14","LEV","8","14","14","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠛꠤꠍꠣꠟ ꠀꠘꠟꠣ, ꠀꠘꠟꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠛꠤꠍꠣꠟꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_15","004_8_15","LEV","8","15","15","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠅꠃ ꠛꠤꠍꠣꠟꠞꠦ ꠎꠛ ꠇꠞꠤꠀ ꠅꠉꠥꠞ ꠇꠤꠍꠥ ꠟꠃ ꠘꠤꠀ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠅꠈꠣꠘꠞ ꠢꠤꠋ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠀꠔꠞ ꠀꠋꠉꠥꠁꠟꠖꠤ ꠟꠃ ꠝꠣꠈꠣꠁꠟꠣ। ꠛꠣꠇꠤ ꠟꠃ ꠔꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤ ꠖꠤꠟꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠁꠘ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ ꠖꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_16","004_8_16","LEV","8","16","16","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠛꠤꠍꠣꠟꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤ, ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ, ꠌꠞ꠆ꠛꠤ ꠡꠝꠦꠔ ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_17","004_8_17","LEV","8","17","17","ꠅꠁꠟꠦ ꠛꠤꠍꠣꠟꠞ ꠈꠣꠟ, ꠉꠥꠡ꠆ꠔ, ꠉꠥꠚꠞ ꠘꠤꠀ ꠔꠣꠁꠘ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠎꠣꠟꠣꠁꠟꠣ। ꠝꠥꠍꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("LV8_18","004_8_18","LEV","8","18","18","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣꠞꠦ ꠀꠘꠟꠣ। ꠀꠘꠟꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠉꠥꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_19","004_8_19","LEV","8","19","19","ꠀꠞ ꠝꠥꠍꠣꠄ ꠅꠃ ꠝꠦꠠꠣꠞꠦ ꠎꠛ ꠇꠞꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠟꠃ ꠍꠤꠐꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_20","004_8_20","LEV","8","20","20","ꠔꠣꠁꠘ ꠝꠦꠠꠣꠞꠦ ꠐꠥꠇꠞꠣꠁꠀ ꠅꠉꠥꠞ ꠇꠟ꠆ꠟꠣ, ꠉꠥꠡ꠆ꠔꠞ ꠐꠥꠇꠞꠣ ꠀꠞ ꠌꠞ꠆ꠛꠤꠞꠦ ꠎꠣꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_21","004_8_21","LEV","8","21","21","ꠀꠞ ꠅꠃ ꠝꠦꠠꠣꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣ, ꠔꠣꠞ ꠌꠣꠁꠞꠅ ꠑꠦꠋ ꠙꠣꠘꠤ ꠖꠤꠀ ꠗꠁꠀ ꠢꠣꠞꠤ, ꠀꠡ꠆ꠔꠣ ꠝꠦꠠꠣꠞꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ꠁꠔꠣ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ꠝꠥꠍꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("LV8_22","004_8_22","LEV","8","22","22","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟꠞ ꠘꠤꠅꠔꠦ, ꠖꠥꠍꠞꠣ ꠝꠦꠠꠣꠞꠦ ꠀꠘꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠝꠦꠠꠣꠞ ꠇꠟ꠆ꠟꠣ ꠀꠔꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_23","004_8_23","LEV","8","23","23","ꠝꠥꠍꠣꠄ ꠅꠃ ꠝꠦꠠꠣꠞꠦ ꠎꠛ ꠇꠞꠤꠀ, ꠅꠉꠥꠞ ꠕꠥꠠꠣ ꠟꠃ ꠘꠤꠀ ꠢꠣꠞꠥꠘꠞ ꠒꠣꠁꠘ ꠇꠣꠘꠞ ꠟꠔꠤꠔ, ꠒꠣꠁꠘ ꠀꠔꠞ ꠀꠞ ꠒꠣꠁꠘ ꠙꠣꠅꠞ ꠛꠥꠠꠤ ꠀꠋꠉꠥꠟꠤꠔ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_24","004_8_24","LEV","8","24","24","ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦꠅ ꠍꠣꠝꠘꠦ ꠀꠘꠤꠀ, ꠔꠣꠞꠣꠞ ꠒꠣꠁꠘ ꠇꠣꠘꠞ ꠟꠔꠤꠔ, ꠀꠞ ꠒꠣꠁꠘ ꠀꠔ, ꠒꠣꠁꠘ ꠙꠣꠅꠞ ꠛꠥꠠꠤ ꠀꠋꠉꠥꠟꠤꠔ ꠕꠥꠠꠣ ꠟꠃ ꠟꠣꠉꠣꠁ ꠖꠤꠟꠣ। ꠀꠞꠅ ꠕꠥꠠꠣ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_25","004_8_25","LEV","8","25","25","ꠔꠣꠁꠘ ꠝꠦꠠꠣꠞ ꠌꠞ꠆ꠛꠤ, ꠌꠞ꠆ꠛꠤ ꠀꠟꠣ ꠟꠦꠋꠉꠥꠠ, ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀ, ꠌꠞ꠆ꠛꠤ ꠡꠝꠦꠔ ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ, ꠀꠞ ꠒꠣꠁꠘꠞ ꠞꠣꠘ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_26","004_8_26","LEV","8","26","26","ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠅꠀ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠐꠥꠇꠞꠤ ꠕꠣꠇꠤ ꠄꠇꠈꠣꠘ ꠞꠥꠐꠤ, ꠀꠞ ꠔꠦꠟꠖꠤ ꠜꠣꠎꠣ ꠄꠇꠈꠣꠘ ꠙꠤꠑꠣ, ꠀꠞ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠄꠇꠈꠣꠘ ꠞꠥꠐꠤ ꠘꠤꠀ ꠢꠃ ꠌꠞ꠆ꠛꠤ ꠀꠞ ꠞꠣꠘꠞ ꠃꠙꠞꠦ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_27","004_8_27","LEV","8","27","27","ꠕꠁꠀ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠀꠔꠅ ꠖꠤꠀ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠖꠥꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_28","004_8_28","LEV","8","28","28","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠁꠔꠣ ꠔꠣꠞꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠘꠤꠀ ꠢꠣꠞꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠙꠡꠥꠞ ꠃꠙꠞꠦ ꠕꠁꠀ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ꠁꠔꠣ ꠔ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV8_29","004_8_29","LEV","8","29","29","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠙꠣꠅꠘꠣ ꠅꠋꠡ, ꠝꠣꠘꠤ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠍꠤꠘꠣ ꠘꠤꠀ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠖꠥꠟꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("LV8_30","004_8_30","LEV","8","30","30","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠕꠥꠠꠣ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠘꠤꠟꠣ, ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠟꠃ ꠀꠘꠤꠀ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠦꠛꠣꠍꠞ ꠃꠙꠞꠦ ꠍꠤꠐꠣꠁ ꠖꠤꠟꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠦꠛꠣꠍꠞꠦꠅ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LV8_31","004_8_31","LEV","8","31","31","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠢꠣꠞꠥꠘ ꠀꠞ ꠄꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠞꠣꠘ꠆ꠖꠅ, ꠞꠣꠘ꠆ꠖꠤꠀ ꠢꠘꠅ ꠛꠁꠀ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠐꠥꠇꠞꠤꠞ ꠞꠥꠐꠤ ꠖꠤꠀ ꠅꠔꠣ ꠈꠣꠅ। ꠀꠝꠣꠞꠦ ꠔ ꠀꠉꠦ ꠅꠃ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠈꠣꠟꠤ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV8_32","004_8_32","LEV","8","32","32","ꠈꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠉꠥꠡ꠆ꠔ ꠀꠞ ꠞꠥꠐꠤ ꠛꠣꠇꠤ ꠞꠁꠛ, ꠁꠔꠣꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV8_33","004_8_33","LEV","8","33","33","ꠔꠥꠝꠞꠣꠞꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠅꠃ ꠝꠣꠢꠚꠤꠟ ꠡꠣꠔ ꠖꠤꠘ ꠗꠞꠤ ꠌꠟꠛ। ꠁ ꠡꠣꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠘ꠆ꠖꠣ ꠕꠣꠇꠤ ꠢꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV8_34","004_8_34","LEV","8","34","34","ꠀꠁꠎ ꠎꠦꠔꠣ ꠇꠞꠟꠣꠝ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV8_35","004_8_35","LEV","8","35","35","ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠦ ꠛꠣꠌꠤꠀ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠁꠎ ꠕꠣꠇꠤ ꠡꠣꠔ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠞꠁꠅ। ꠖꠤꠘ-ꠞꠣꠁꠔ ꠅꠘꠅ ꠞꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠤꠅ। ꠔꠥꠝꠞꠣ ꠅꠟꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔ ꠀꠝꠤ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("LV8_36","004_8_36","LEV","8","36","36","ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠝꠣꠛꠥꠖꠦ ꠎꠔꠔꠣ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_1","004_9_1","LEV","9","1","1","ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠝꠣꠢꠚꠤꠟꠞ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞꠦ, ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦꠅ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_2","004_9_2","LEV","9","2","2","ꠀꠘꠣꠁꠀ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠄꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠘꠅ, ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠟꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠅꠅ। ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ ꠉꠥꠁꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("LV9_3","004_9_3","LEV","9","3","3","ꠀꠞ ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠄ। ꠔꠣꠞꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠉꠞꠥ-ꠛꠣꠍꠥꠞ, ꠀꠞ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠦ, ");
INSERT INTO syls_vpl VALUES ("LV9_4","004_9_4","LEV","9","4","4","ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠞ ꠄꠉꠥ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠄ। ꠁꠔꠣꠞ ꠟꠉꠦ ꠔꠣꠞꠣ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠅ ꠀꠘꠛꠣ। ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞꠦ ꠀꠁꠎ ꠖꠤꠖꠣꠞ ꠖꠤꠛꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠅꠔꠣ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LV9_5","004_9_5","LEV","9","5","5","ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠟꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠟꠣ। ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠃꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_6","004_9_6","LEV","9","6","6","ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠀꠖꠣꠄ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠘꠥꠞ ꠎꠣꠁꠞ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LV9_7","004_9_7","LEV","9","7","7","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠉꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠅ, ꠉꠤꠀ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠀꠞ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠅ। ꠀꠞ ꠝꠣꠘꠡꠞ ꠀꠘꠣ ꠇꠥꠞꠛꠣꠘꠤꠅ ꠀꠖꠣꠄ ꠇꠞꠅ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠅꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LV9_8","004_9_8","LEV","9","8","8","ꠔꠦꠃ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠤꠀ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠛꠣꠍꠥꠞ ꠎꠛ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_9","004_9_9","LEV","9","9","9","ꠎꠛꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠉꠥꠞ ꠟꠃ ꠟꠁꠀ ꠔꠣꠘ ꠗꠣꠞꠅ ꠉꠦꠟꠣ। ꠔꠣꠁꠘ ꠅꠃ ꠟꠃꠞ ꠝꠣꠎꠦ ꠀꠋꠉꠥꠟ ꠒꠥꠛꠣꠁꠀ ꠕꠥꠠꠣ ꠟꠃ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠤꠋ ꠅꠇꠟꠅ ꠝꠣꠈꠣꠁꠟꠣ, ꠀꠞ ꠛꠣꠇꠤ ꠟꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠓꠣꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_10","004_9_10","LEV","9","10","10","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠛꠣꠍꠥꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠀꠞ ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_11","004_9_11","LEV","9","11","11","ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠀꠞ ꠌꠣꠝꠠꠣ ꠘꠤꠀ ꠔꠣꠁꠘ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠎꠣꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_12","004_9_12","LEV","9","12","12","ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞꠦ ꠎꠛ ꠇꠞꠟꠣ। ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠉꠥꠞ ꠟꠃ ꠘꠤꠀ ꠔꠣꠘ ꠀꠔꠅ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠅꠃ ꠟꠃꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_13","004_9_13","LEV","9","13","13","ꠔꠣꠞꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠇꠟ꠆ꠟꠣ ꠀꠞ ꠉꠥꠡ꠆ꠔꠞ ꠐꠥꠇꠞꠣꠁꠘ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠢꠣꠞꠥꠘꠞ ꠀꠔꠅ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠁꠔꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_14","004_9_14","LEV","9","14","14","ꠝꠦꠠꠣꠞ ꠑꠦꠋ ꠀꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣ ꠙꠣꠘꠤ ꠖꠤꠀ ꠗꠁꠀ ꠍꠣꠚ ꠇꠞꠤꠀ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠙꠡꠥꠞ ꠟꠉꠦ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠅ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_15","004_9_15","LEV","9","15","15","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠡꠝꠣꠎꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ ꠅꠇꠟ ꠀꠘꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠍꠣꠉꠟ ꠎꠛ ꠇꠞꠟꠣ, ꠀꠞ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_16","004_9_16","LEV","9","16","16","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞꠦꠅ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_17","004_9_17","LEV","9","17","17","ꠀꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠀꠘꠣ ꠍꠣꠝꠣꠘꠣ ꠕꠣꠇꠤ ꠄꠇ ꠝꠥꠁꠐ ꠘꠤꠀ ꠢꠣꠞꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠣ। ꠁꠔꠣ ꠍꠣꠠꠣꠅ ꠔꠣꠁꠘ ꠛꠤꠀꠘꠤ ꠛꠣꠟꠣꠞ ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_18","004_9_18","LEV","9","18","18","ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠉꠞꠥ ꠀꠞ ꠝꠦꠠꠣꠞꠦ ꠎꠛ ꠇꠞꠟꠣ। ꠎꠛꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠅꠉꠥꠞ ꠟꠃ ꠀꠘꠤꠀ ꠔꠣꠘ ꠀꠔꠅ ꠖꠤꠟꠣ, ꠟꠃ ꠘꠤꠀ ꠔꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠍꠤꠐꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_19","004_9_19","LEV","9","19","19","ꠀꠞ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞꠦ ꠢꠃ ꠉꠞꠥ ꠀꠞ ꠝꠦꠠꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠟ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤ, ꠝꠣꠘꠤ ꠌꠞ꠆ꠛꠤ ꠀꠟꠣ ꠟꠦꠋꠉꠥꠠ, ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠖꠥꠁꠅ ꠇꠤꠒꠘꠤ ꠀꠞ ꠅꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠞ꠆ꠛꠤ, ꠇꠁꠟꠎꠣꠞ ꠟꠉꠞ ꠝꠣꠐꠤꠀꠅ ꠀꠘꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_20","004_9_20","LEV","9","20","20","ꠔꠣꠞꠣ ꠅꠃ ꠢꠇꠟ ꠌꠞ꠆ꠛꠤꠞꠦ ꠢꠃ ꠙꠡꠥꠞ ꠍꠤꠘꠣꠞ ꠃꠙꠞꠦ ꠕꠁꠟꠣ। ꠀꠞ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠅꠃ ꠌꠞ꠆ꠛꠤ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_21","004_9_21","LEV","9","21","21","ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠢꠣꠞꠥꠘꠦ ꠛꠣꠖꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠍꠤꠘꠣ ꠀꠞ ꠒꠣꠁꠘꠞ ꠞꠣꠘ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠥꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_22","004_9_22","LEV","9","22","22","ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠝꠣꠘꠡꠞ ꠛꠣꠄꠖꠤ ꠔꠣꠘ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_23","004_9_23","LEV","9","23","23","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤ ꠀꠞ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠉꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ, ꠛꠣꠖꠦ ꠢꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠘꠥꠞ ꠎꠣꠁꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV9_24","004_9_24","LEV","9","24","24","ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠖꠞꠔꠤ ꠀꠉꠥꠁꠘ ꠀꠁꠀ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠌꠞ꠆ꠛꠤꠞꠦ ꠎꠣꠟꠣꠁꠀ ꠍꠣꠟꠤ ꠇꠞꠤꠟꠤꠟ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠈꠥꠡꠤꠄ ꠍꠥꠛꠢꠣꠘ ꠀꠟ꠆ꠟꠣ ꠇꠁꠀ ꠌꠤꠇ ꠖꠤꠀ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV10_1","004_10_1","LEV","10","1","1","ꠛꠣꠖꠦ ꠅꠟꠣ ꠅꠁꠟ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠘꠣꠖꠣꠛ ꠀꠞ ꠀꠛꠤꠢꠥꠄ ꠔꠣꠞꠣꠞ ꠎꠣꠞꠎꠤꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠖꠣꠘꠤꠔ ꠀꠉꠥꠁꠘ ꠎꠣꠟꠣꠁꠟꠣ, ꠀꠞ ꠅꠃ ꠀꠉꠥꠘꠤꠞ ꠃꠙꠞꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠉꠤꠀ ꠖꠥꠍꠞꠣ ꠀꠉꠥꠁꠘ ꠖꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV10_2","004_10_2","LEV","10","2","2","ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠉꠥꠁꠘ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠟ, ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠝꠞꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV10_3","004_10_3","LEV","10","3","3","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠔ ꠀꠉꠦꠃ ꠎꠣꠘꠣꠁ ꠖꠤꠍꠟꠣ, ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠦꠞꠣ ꠀꠎꠤꠞ ꠅꠄ, ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠝꠣꠘꠛ, ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠛ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠣꠞꠥꠘ ꠌꠥꠙꠌꠣꠙ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV10_4","004_10_4","LEV","10","4","4","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠢꠣꠞꠥꠘꠞ ꠌꠣꠌꠣ ꠃꠎ꠆ꠎꠟꠞ ꠙꠥꠀꠂꠘ ꠝꠤꠡꠣꠄꠄꠟ ꠀꠞ ꠄꠟꠎꠣꠚꠘꠞꠦ ꠈꠛꠞ ꠖꠤꠀ ꠀꠘꠣꠁꠟꠣ, ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠁꠅ ꠜꠣꠔꠤꠎꠣꠞ ꠟꠣꠡꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("LV10_5","004_10_5","LEV","10","5","5","ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠔꠣꠞꠣ ꠉꠤꠀ ꠘꠣꠖꠣꠛ ꠀꠞ ꠀꠛꠤꠢꠥꠞ ꠟꠣꠡꠞꠦ ꠁꠝꠣꠝꠔꠤ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤꠞ ꠇꠣꠙꠠꠅ ꠗꠞꠤ ꠐꠣꠘꠤꠀ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV10_6","004_10_6","LEV","10","6","6","ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠁꠍꠣꠝꠣꠞꠞꠦ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠣꠞꠣꠞ ꠝꠃꠔꠞ ꠖꠥꠈꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠌꠥꠟꠞꠦ ꠀꠃꠟꠣ-ꠎꠣꠃꠟꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠣꠞꠤꠅ ꠘꠣ। ꠁꠔꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣꠅ ꠝꠞꠛꠣꠄ, ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠡꠝꠣꠎꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠎꠛꠤ ꠉꠥꠍꠣ ꠟꠣꠝꠛ। ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠞꠣꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁ ꠝꠣꠞꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠖꠥꠈꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠐꠥꠝ-ꠈꠦꠡ ꠝꠣꠘꠤ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠣꠔ꠆ꠔꠝ-ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV10_7","004_10_7","LEV","10","7","7","ꠔꠥꠝꠞꠣꠞ ꠉꠔꠞꠅ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠛꠣꠞꠦ ꠎꠣꠁꠅ ꠘꠣ, ꠉꠦꠟꠦꠃ ꠝꠞꠛꠣꠄ।” ꠔꠣꠞꠣꠅ ꠝꠥꠍꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV10_8","004_10_8","LEV","10","8","8","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV10_9","004_10_9","LEV","10","9","9","“ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠛꠣ ꠡꠞꠣꠛ ꠈꠣꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠅ ꠘꠣ, ꠢꠣꠝꠣꠁꠟꠦꠃ ꠝꠞꠛꠣꠄ। ꠁ ꠢꠥꠇꠥꠝ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV10_10","004_10_10","LEV","10","10","10","ꠇꠥꠘꠐꠣ ꠢꠣꠞꠣꠝ ꠀꠞ ꠇꠥꠘꠐꠣ ꠢꠣꠟꠣꠟ, ꠇꠥꠘꠐꠣ ꠙꠣꠇ ꠀꠞ ꠇꠥꠘꠐꠣ ꠘꠣꠙꠣꠇ, ꠁꠔꠣ ꠛꠥꠎꠤꠀ-ꠢꠥꠘꠤꠀ ꠌꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV10_11","004_10_11","LEV","10","11","11","ꠀꠞ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞ ꠝꠣꠞꠚꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠔ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠛꠣꠔꠣꠁꠍꠤ, ꠁꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LV10_12","004_10_12","LEV","10","12","12","ꠛꠣꠖꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠛꠣꠇꠤ ꠖꠥꠁꠅ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠁꠍꠣꠝꠣꠞꠞꠦ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠎꠦ ꠅꠋꠡ ꠛꠣꠇꠤ ꠞꠁꠍꠦ, ꠅꠔꠣ ꠖꠤꠀ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ। ꠁꠔꠣ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("LV10_13","004_10_13","LEV","10","13","13","ꠔꠥꠝꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠜꠤꠔꠞꠦ ꠅꠔꠣ ꠈꠣꠁꠅ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠅꠋꠡ ꠔ ꠔꠥꠝꠣꠞ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠙꠣꠅꠘꠣ। ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠅꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LV10_14","004_10_14","LEV","10","14","14","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠍꠤꠘꠣ ꠀꠞ ꠞꠣꠘꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠦꠅ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠎꠦꠇꠥꠘꠥ ꠙꠣꠇ-ꠍꠣꠚ ꠎꠣꠉꠣꠔ ꠛꠁꠀ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠈꠣꠁꠅ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔꠞ ꠅꠃ ꠅꠋꠡ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV10_15","004_10_15","LEV","10","15","15","ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠌꠞ꠆ꠛꠤ ꠎꠦꠛꠟꠣ ꠀꠘꠣ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠍꠤꠘꠣ ꠀꠞ ꠞꠣꠘꠞ ꠉꠥꠡ꠆ꠔꠅ ꠀꠘꠣ ꠟꠣꠉꠛ। ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠅꠃ ꠞꠣꠘ ꠀꠞ ꠍꠤꠘꠣꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠙꠣꠅꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LV10_16","004_10_16","LEV","10","16","16","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠔꠣꠟ꠆ꠟꠣꠡꠤ ꠇꠞꠤꠀ ꠎꠣꠘꠟꠣ, ꠎꠦ ꠍꠣꠉꠟ ꠖꠤꠀ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠅꠉꠥꠞ ꠢꠇꠟ ꠉꠥꠡ꠆ꠔ ꠔꠣꠞꠣ ꠎꠣꠟꠣꠁꠟꠤꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠝꠥꠍꠣꠄ ꠢꠣꠞꠥꠘꠞ ꠛꠣꠇꠤ ꠖꠥꠁꠅ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠁꠍꠣꠝꠣꠞꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV10_17","004_10_17","LEV","10","17","17","“ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠈꠣꠁꠟꠣꠄ ꠘꠣ ꠇꠦꠘꠦ? ꠁꠔꠣ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ। ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠀ, ꠔꠣꠞꠣꠞ ꠖꠥꠡ-ꠇꠍꠥꠞꠤ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LV10_18","004_10_18","LEV","10","18","18","ꠇꠥꠞꠛꠣꠘꠤꠞ ꠍꠣꠉꠟꠞ ꠟꠃ ꠎꠦꠛꠟꠣ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠜꠤꠔꠞꠦ ꠘꠦꠅꠀ ꠅꠁꠍꠦ ꠘꠣ, ꠔꠦ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠁꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠔ ꠔꠥꠝꠞꠣ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠜꠤꠔꠞꠦ ꠈꠣꠅꠀ ꠎꠞꠥꠞ ꠀꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("LV10_19","004_10_19","LEV","10","19","19","ꠢꠣꠞꠥꠘꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠁꠎ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦꠖꠤ ꠅꠔꠔꠣ ꠊꠐꠤꠟ। ꠔꠦ ꠀꠁꠎꠇꠥꠞ ꠖꠤꠘꠅ ꠀꠝꠤ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠟꠦ ꠝꠣꠛꠥꠖ ꠇꠥꠘꠥ ꠈꠥꠡꠤ ꠅꠁꠛꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LV10_20","004_10_20","LEV","10","20","20","ꠁ ꠎꠥꠀꠙ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣ ꠘꠛꠤ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV11_1","004_11_1","LEV","11","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV11_2","004_11_2","LEV","11","2","2","“ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠝꠣꠐꠤꠞ ꠃꠙꠞꠞ ꠙꠡꠥꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠙꠡꠥ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠟꠣꠟ, ꠅꠔꠣ ꠅꠁꠟ: ");
INSERT INTO syls_vpl VALUES ("LV11_3","004_11_3","LEV","11","3","3","“ꠎꠦꠔꠣ ꠙꠡꠥꠞ ꠙꠣꠅꠞ ꠈꠥꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠞꠣ, ꠀꠞ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠄ, ꠁꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("LV11_4","004_11_4","LEV","11","4","4","ꠔꠣ-ꠅ ꠄꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠙꠡꠥꠄ ꠈꠣꠟꠤ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠄ, ꠀꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠈꠣꠟꠤ ꠈꠥꠞꠣ ꠌꠤꠞꠣ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ꠃꠐꠦ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠁꠟꠦꠅ ꠔꠣꠞ ꠈꠥꠞꠣ ꠌꠤꠞꠣ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠃꠐ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV11_5","004_11_5","LEV","11","5","5","ꠡꠣꠚꠘ-ꠃꠘ꠆ꠖꠥꠞꠦ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠁꠟꠦꠅ, ꠁꠔꠣꠞ ꠈꠥꠞꠣ ꠌꠤꠞꠣ ꠘꠣꠄ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠁꠔꠣꠅ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV11_6","004_11_6","LEV","11","6","6","ꠈꠞꠉꠥꠡꠦꠅ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠄ, ꠅꠁꠟꠦ ꠁꠔꠣꠞ ꠈꠥꠞꠣ ꠌꠤꠞꠣ ꠘꠣꠄ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV11_7","004_11_7","LEV","11","7","7","ꠡꠥꠅꠞꠞ ꠈꠥꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠞꠣ, ꠅꠁꠟꠦ ꠁꠔꠣꠄ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠄ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV11_8","004_11_8","LEV","11","8","8","ꠁꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ, ꠁꠔꠣꠞ ꠝꠞꠣ ꠟꠣꠡꠞꠦꠅ ꠍꠁꠅ ꠘꠣ। ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV11_9","004_11_9","LEV","11","9","9","“ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠎꠣꠘꠖꠣꠞꠦ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣꠞ ꠚꠁꠞ ꠀꠞ ꠒꠣꠈꠘꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("LV11_10","004_11_10","LEV","11","10","10","ꠅꠁꠟꠦ ꠎꠦꠔꠣꠞ ꠚꠁꠞ ꠀꠞ ꠒꠣꠈꠘꠣ ꠘꠣꠁ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠎꠣꠁꠎ। ꠁꠔꠣ ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠙꠣꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠊꠥꠞꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠅꠃꠇ ꠛꠣ ꠀꠞꠅ ꠇꠥꠘꠥ ꠎꠣꠘꠖꠣꠞ ꠅꠃꠇ, ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠊꠤꠘ꠆ꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_11","004_11_11","LEV","11","11","11","ꠘꠣꠎꠣꠁꠎ ꠅꠀꠄ ꠁꠔꠣꠞꠦ ꠢꠣꠞꠣꠝ ꠝꠘꠅ ꠇꠞꠤꠅ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ। ꠁꠔꠣꠞ ꠝꠞꠣ ꠟꠣꠡꠞꠦꠅ ꠔꠥꠝꠞꠣ ꠊꠤꠘ꠆ꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_12","004_11_12","LEV","11","12","12","ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠦ, ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠚꠁꠞ ꠛꠣ ꠒꠣꠈꠘꠣ ꠘꠣꠁ, ꠁꠟꠣꠈꠣꠘ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞꠦ ꠔꠥꠝꠞꠣ ꠊꠤꠘ꠆ꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_13","004_11_13","LEV","11","13","13","“ꠀꠞ ꠙꠣꠈꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠙꠣꠈꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠊꠤꠘ꠆ꠘꠣꠁꠅ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ। ꠅꠔꠣ ꠅꠁꠟꠣ, ꠛꠠ ꠌꠤꠟ, ꠢꠇꠥꠘ, ꠢꠣꠚ-ꠈꠣꠃꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("LV11_14","004_11_14","LEV","11","14","14","ꠢꠇꠟ ꠎꠣꠔꠞ ꠌꠤꠟ, ꠢꠇꠟ ꠎꠣꠔ ꠇꠣꠃꠀ, ");
INSERT INTO syls_vpl VALUES ("LV11_15","004_11_15","LEV","11","15","15","ꠃꠐ ꠙꠣꠈꠤ, ");
INSERT INTO syls_vpl VALUES ("LV11_16","004_11_16","LEV","11","16","16","ꠘꠤꠝ ꠙꠣꠈꠤ, ꠉꠣꠋꠌꠤꠟ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠣꠎ ꠙꠣꠈꠤ, ");
INSERT INTO syls_vpl VALUES ("LV11_17","004_11_17","LEV","11","17","17","ꠢꠇꠟ ꠎꠣꠔ ꠙꠦꠌꠣ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠇꠥꠠꠣ, ꠍꠟꠣ-ꠇꠣꠇ, ꠛꠟꠥꠀ ꠙꠣꠈꠤ, ");
INSERT INTO syls_vpl VALUES ("LV11_18","004_11_18","LEV","11","18","18","ꠙꠣꠘꠤ-ꠈꠣꠃꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("LV11_19","004_11_19","LEV","11","19","19","ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠣꠐꠤꠀ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠉꠟꠣ, ꠝꠘ-ꠌꠥꠞꠣ ꠙꠣꠈꠤ ꠀꠞ ꠛꠣꠖꠥꠞ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV11_20","004_11_20","LEV","11","20","20","“ꠙꠥꠇ-ꠚꠞꠤꠋ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠙꠥꠇ-ꠚꠞꠤꠋ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠎꠣꠁꠎ, ꠎꠦꠔꠣꠄ ꠙꠣꠅꠖꠤ ꠀꠐꠦ ꠀꠞ ꠃꠠꠣꠟ ꠖꠦꠄ, ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠊꠤꠘ꠆ꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_21","004_11_21","LEV","11","21","21","ꠅꠁꠟꠦ ꠁꠔꠣꠞ ꠝꠣꠎꠞ ꠎꠦꠔꠣꠞ ꠀꠐꠥ ꠀꠍꠦ, ꠀꠞ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠚꠣꠟꠣꠁ ꠚꠣꠟꠣꠁ ꠌꠟꠦ, ꠁꠔꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥꠐꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("LV11_22","004_11_22","LEV","11","22","22","ꠁꠔꠣ ꠅꠁꠟ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠋꠉꠙꠣꠟ, ꠛꠣꠊꠣ-ꠚꠞꠤꠋ, ꠊꠣꠡ-ꠚꠞꠤꠋ। ");
INSERT INTO syls_vpl VALUES ("LV11_23","004_11_23","LEV","11","23","23","ꠅꠁꠟꠦ ꠁꠔꠣ ꠍꠣꠠꠣ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠎꠔ ꠙꠥꠇ-ꠚꠞꠤꠋꠄ ꠌꠣꠁꠞ ꠙꠣꠅꠄ ꠀꠐꠦ ꠀꠞ ꠃꠠꠤꠔ ꠙꠣꠞꠦ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠥꠝꠞꠣ ꠊꠤꠘ꠆ꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_24","004_11_24","LEV","11","24","24","“ꠔꠥꠝꠞꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠟꠦ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛꠣꠄ; ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠅꠃ ꠢꠣꠞꠣꠝ ꠙꠡꠥ, ꠙꠣꠈꠤ, ꠝꠣꠍ, ꠙꠥꠇ-ꠚꠞꠤꠋ ꠅꠔꠣꠞ ꠝꠞꠣ ꠟꠣꠡ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠢꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_25","004_11_25","LEV","11","25","25","ꠀꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠅꠔꠣ ꠢꠣꠞꠣꠝ ꠎꠤꠘꠤꠡꠞ ꠟꠣꠡꠞ ꠇꠥꠘꠥ ꠅꠋꠡꠞꠦ ꠀꠔꠖꠤ ꠗꠞꠤꠀ ꠛꠁꠀ ꠘꠦꠄ, ꠔꠦ ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_26","004_11_26","LEV","11","26","26","“ꠀꠞ ꠎꠦꠔꠣ ꠙꠡꠥꠞ ꠙꠣꠅꠞ ꠈꠥꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠞꠣ ꠘꠣꠄ, ꠛꠣ ꠎꠦ ꠙꠡꠥꠄ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠄ ꠘꠣ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ꠅꠃ ꠢꠣꠞꠣꠝ ꠙꠡꠥꠞꠦ ꠎꠦ ꠎꠘꠦ ꠍꠁꠛ, ꠢꠦ ꠘꠣꠙꠣꠇ ꠛꠘꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_27","004_11_27","LEV","11","27","27","ꠌꠣꠁꠞ ꠙꠣꠅꠄ ꠀꠐꠞꠣ ꠎꠣꠘꠥꠀꠞ ꠅꠇꠟꠞ ꠝꠣꠎꠦ, ꠎꠦ ꠙꠡꠥꠄ ꠙꠣꠅꠞ ꠔꠣꠟꠥꠔ ꠜꠞ ꠖꠤꠀ ꠀꠐꠦ, ꠁꠔꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠔꠣꠞ ꠝꠞꠣ ꠟꠣꠡ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_28","004_11_28","LEV","11","28","28","ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠁꠔꠣꠞ ꠟꠣꠡ ꠀꠔꠖꠤ ꠗꠞꠤꠀ ꠛꠁꠀ ꠘꠦꠄ, ꠔꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ꠁꠔꠣ ꠎꠣꠘꠥꠀꠞ ꠅꠇꠟ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV11_29","004_11_29","LEV","11","29","29","“ꠀꠞ ꠝꠣꠐꠤꠔ ꠌꠟꠞꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠝꠣꠎꠦ ꠘꠦꠃꠟ, ꠃꠘ꠆ꠖꠥꠞ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠉꠤꠞꠉꠤꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("LV11_30","004_11_30","LEV","11","30","30","ꠐꠤꠇꠐꠤꠇꠤ, ꠉꠥꠁꠟ-ꠢꠣꠚ, ꠝꠁ-ꠢꠣꠚ, ꠀꠁꠘ꠆ꠎꠣꠁꠟ ꠀꠞ ꠇꠣꠇꠟꠣꠡ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV11_31","004_11_31","LEV","11","31","31","ꠝꠣꠐꠤꠔ ꠌꠟꠞꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠝꠣꠎꠞ ꠅꠃ ꠎꠣꠔꠞ ꠎꠣꠘꠖꠣꠞ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠎꠣꠁꠎ। ꠁꠔꠣꠞ ꠝꠞꠣ ꠟꠣꠡ ꠇꠦꠃ ꠍꠁꠟꠦ, ꠢꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_32","004_11_32","LEV","11","32","32","ꠅꠔꠣꠞ ꠝꠣꠎꠞ ꠎꠦꠇꠥꠘꠥ ꠄꠉꠥꠞ ꠝꠞꠣ ꠟꠣꠡ ꠎꠥꠖꠤ ꠅꠁꠘ꠆ꠘ ꠎꠤꠘꠤꠡꠞ ꠃꠙꠞꠦ ꠙꠠꠦ, ꠎꠦꠟꠣꠘ ꠟꠣꠇꠠꠤ, ꠇꠣꠙꠠ-ꠌꠥꠙꠠ, ꠌꠣꠝꠠꠣ ꠛꠣ ꠍꠟꠣꠞ ꠌꠐ ꠖꠤꠀ ꠛꠣꠘꠣꠁꠟ ꠎꠦꠇꠥꠘꠥ ꠝꠣꠟꠞ ꠃꠙꠞꠦ ꠙꠠꠟꠦꠃ ꠁꠔꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ꠘꠣꠙꠣꠇ ꠝꠣꠟꠞꠦ ꠙꠣꠘꠤꠔ ꠜꠤꠎꠣꠁꠀ ꠕꠁꠛꠣꠄ। ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠘꠣꠙꠣꠇ ꠞꠁꠛ, ꠛꠣꠖꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_33","004_11_33","LEV","11","33","33","ꠀꠞ ꠅꠃ ꠘꠣꠙꠣꠇ ꠎꠣꠘꠖꠣꠞꠞ ꠇꠥꠘꠥꠐꠣꠞ ꠝꠞꠣ ꠟꠣꠡ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠐꠤꠞ ꠛꠣꠡꠘꠞ ꠝꠣꠎꠦ ꠙꠠꠦ, ꠔꠦ ꠁꠉꠥꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟꠔꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ, ꠁ ꠛꠣꠡꠘꠞꠦꠅ ꠜꠣꠋꠉꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV11_34","004_11_34","LEV","11","34","34","ꠅꠃ ꠛꠣꠡꠘꠞ ꠙꠣꠘꠤ ꠛꠣ ꠞꠡ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠈꠣꠘꠤꠞ ꠎꠤꠘꠤꠡꠞ ꠃꠙꠞꠦ ꠙꠠꠦ, ꠔꠦ ꠁ ꠈꠣꠘꠤ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ꠁꠇꠐꠣꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠙꠣꠘꠤ ꠎꠣꠔꠤꠅ ꠇꠥꠘꠥꠔꠣ ꠕꠅꠀ ꠕꠣꠇꠦ, ꠔꠦ ꠁꠔꠣꠅ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_35","004_11_35","LEV","11","35","35","ꠀꠞ ꠅꠔꠣꠞ ꠝꠞꠣ ꠟꠣꠡ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠞ ꠃꠙꠞꠦ ꠙꠠꠦ, ꠔꠦ ꠁꠔꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ꠁꠔꠣ ꠇꠥꠘꠥ ꠃꠘ꠆ꠖꠣꠟꠅ ꠙꠠꠟꠦ, ꠁ ꠃꠘ꠆ꠖꠣꠟ ꠜꠣꠋꠉꠤꠟꠤꠛꠣꠄ। ꠁ ꠃꠘ꠆ꠖꠣꠟ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠙꠣꠇ, ꠁꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠉꠁꠘ꠆ꠘ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_36","004_11_36","LEV","11","36","36","ꠅꠁꠟꠦ ꠁꠔꠣ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠇꠥꠀꠞ ꠜꠤꠔꠞꠦ ꠛꠣ ꠁꠘ꠆ꠖꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠙꠠꠦ, ꠔꠦ ꠁ ꠇꠥꠀ ꠛꠣ ꠁꠘ꠆ꠖꠣꠞꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠔ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠁꠔꠣꠞ ꠝꠞꠣ ꠟꠣꠡ ꠎꠦ ꠎꠘꠦ ꠍꠁꠛ, ꠢꠦ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_37","004_11_37","LEV","11","37","37","ꠎꠝꠤꠘꠅ ꠛꠣꠁꠘ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠕꠅꠀ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠛꠤꠌꠞ ꠃꠙꠞꠦ ꠎꠥꠖꠤ ꠅꠔꠣꠞ ꠟꠣꠡ ꠙꠠꠦ, ꠔꠦ ꠁꠔꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV11_38","004_11_38","LEV","11","38","38","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠛꠤꠌꠞ ꠃꠙꠞꠦ ꠙꠣꠘꠤ ꠖꠤꠀ ꠜꠤꠎꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠁꠔꠣ ꠙꠠꠦ, ꠔꠦ ꠁ ꠛꠤꠌ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV11_39","004_11_39","LEV","11","39","39","“ꠔꠥꠝꠞꠣꠞ ꠢꠣꠟꠣꠟ ꠇꠥꠘꠥ ꠙꠡꠥ ꠝꠞꠤꠉꠦꠟꠦ, ꠁꠉꠥꠞ ꠟꠣꠡ ꠎꠦ ꠎꠘꠦ ꠍꠁꠛ, ꠢꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_40","004_11_40","LEV","11","40","40","ꠇꠦꠃ ꠎꠥꠖꠤ ꠅꠃ ꠝꠞꠣ ꠙꠡꠥꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠄ, ꠔꠦ ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠢꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ꠀꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠅꠃ ꠙꠡꠥꠞ ꠟꠣꠡꠞꠦ ꠀꠔ ꠖꠤꠀ ꠔꠥꠟꠦ, ꠔꠦ ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠢꠦ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV11_41","004_11_41","LEV","11","41","41","“ꠢꠥꠘꠅ, ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠌꠟꠞꠣ ꠢꠇꠟ ꠎꠣꠔꠞ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞ ꠈꠣꠅꠀ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ, ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠊꠤꠘ꠆ꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_42","004_11_42","LEV","11","42","42","ꠁꠔꠣ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠅꠃꠇ, ꠛꠣ ꠌꠣꠁꠞ ꠙꠣꠅꠄ ꠀꠐꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠛꠣ ꠛꠃꠔ ꠙꠣꠅꠄ ꠌꠟꠞꠣ ꠅꠃꠇ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠝꠣꠐꠤꠔ ꠌꠟꠞꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ, ꠁꠔꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_43","004_11_43","LEV","11","43","43","ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠇꠥꠘꠥꠔꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠞ ꠎꠘ ꠛꠣꠘꠣꠁꠅ ꠘꠣ, ꠛꠣ ꠅꠔꠣꠄꠅ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠘꠣ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV11_44","004_11_44","LEV","11","44","44","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ꠀꠝꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠞꠣꠈꠤꠅ। ꠎꠣꠘ ꠔ, ꠀꠝꠤ ꠘꠤꠎꠦꠅ ꠙꠛꠤꠔ꠆ꠞ। ꠄꠞꠟꠣꠉꠤ ꠝꠣꠐꠤꠔ ꠌꠟꠞꠣ ꠇꠥꠘꠥ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV11_45","004_11_45","LEV","11","45","45","ꠀꠝꠤ ꠔ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠅꠀꠞ ꠈꠤꠀꠟꠦ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠤ। ꠀꠝꠤ ꠘꠤꠎꠦ ꠙꠛꠤꠔ꠆ꠞ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠅ ꠙꠛꠤꠔ꠆ꠞ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_46","004_11_46","LEV","11","46","46","“ꠔꠦ ꠙꠡꠥ, ꠙꠣꠈꠤ, ꠙꠣꠘꠤꠔ ꠛꠡꠔ ꠇꠞꠞꠣ ꠎꠣꠘꠖꠣꠞ, ꠀꠞ ꠝꠣꠐꠤꠞ ꠝꠣꠎꠦ ꠌꠟꠞꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV11_47","004_11_47","LEV","11","47","47","ꠇꠥꠘꠐꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠁꠎ ꠀꠞ ꠇꠥꠘꠐꠣ ꠘꠣꠎꠣꠁꠎ, ꠇꠥꠘ ꠙꠡꠥꠞ ꠉꠥꠡ꠆ꠔ ꠢꠣꠟꠣꠟ ꠀꠞ ꠇꠥꠘꠐꠣ ꠢꠣꠞꠣꠝ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠤꠀ-ꠢꠥꠘꠤꠀ ꠌꠟꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LV12_1","004_12_1","LEV","12","1","1","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV12_2","004_12_2","LEV","12","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠇꠥꠘꠥ ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠄ, ꠔꠦ ꠛꠦꠐꠤꠀꠞꠣ ꠛꠦꠝꠣꠞꠞ ꠡꠝꠄꠇꠥꠞ ꠟꠣꠈꠣꠘ ꠁ ꠛꠦꠐꠤ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ꠔꠣꠁꠞ ꠅꠃ ꠘꠣꠙꠣꠇꠤ ꠢꠣꠟꠔ ꠡꠣꠔ ꠖꠤꠘ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV12_3","004_12_3","LEV","12","3","3","ꠛꠣꠖꠦ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠙꠥꠀꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV12_4","004_12_4","LEV","12","4","4","ꠀꠞ ꠅꠃ ꠛꠦꠐꠤꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠎꠘꠝꠞ ꠟꠃ ꠎꠣꠅꠀꠞ ꠇꠣꠞꠘꠦ ꠔꠦꠔ꠆ꠞꠤꠡ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ꠅꠃ ꠝꠤꠀꠖ ꠘꠣ ꠙꠥꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠁ ꠇꠥꠘꠥ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡꠅ ꠗꠞꠣ-ꠍꠀ ꠎꠣꠁꠎ ꠘꠣꠄ। ꠀꠞ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠎꠣꠁꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV12_5","004_12_5","LEV","12","5","5","ꠅꠁꠟꠦ ꠁ ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠎꠥꠖꠤ ꠙꠥꠠꠤꠞ ꠎꠘꠝ ꠅꠄ, ꠔꠦ ꠛꠦꠐꠤꠀꠞꠣ ꠝꠣꠡꠤꠇ ꠛꠦꠝꠣꠞꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠁ ꠘꠣꠙꠣꠇ ꠞꠁꠛ, ꠔꠣ-ꠅ ꠁ ꠘꠣꠙꠣꠇꠤ ꠢꠣꠟꠔ ꠙꠥꠞꠣ ꠖꠥꠁ ꠢꠣꠙ꠆ꠔꠣ ꠌꠟꠛ। ꠛꠣꠖꠦ ꠅꠃ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠍꠄꠡꠐ꠆ꠐꠤ ꠖꠤꠘ ꠛꠣꠞ ꠌꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV12_6","004_12_6","LEV","12","6","6","“ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠅꠀꠞ ꠡꠝꠄ ꠀꠁꠟꠦ, ꠛꠦꠐꠤꠄ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛ। ꠎꠣꠁꠔꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ, ꠀꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠞꠅ ꠛꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠟꠉꠦ ꠘꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV12_7","004_12_7","LEV","12","7","7","ꠔꠦꠃ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠟꠃ ꠎꠣꠅꠀ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠛꠦꠐꠤꠞꠦ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠇꠞꠛꠣ। ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠊꠞꠅ ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠅꠀꠞ ꠟꠣꠉꠤ ꠅꠃ ꠘꠤꠅꠝ ꠎꠣꠞꠤ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LV12_8","004_12_8","LEV","12","8","8","ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠦꠠꠣ ꠀꠘꠣꠞ ꠔꠚꠤꠇ ꠎꠥꠖꠤ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠖꠥꠉꠥ ꠙꠣꠞꠅ ꠛꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠀꠘꠛ। ꠄꠞ ꠝꠣꠎꠞ ꠄꠉꠥ ꠅꠁꠛ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠖꠥꠍꠞꠣꠐꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠔꠣꠁꠞꠦ ꠘꠣꠙꠣꠇꠤ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠛꠣ, ꠔꠦꠃ ꠁ ꠛꠦꠐꠤ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠛꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV13_1","004_13_1","LEV","13","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV13_2","004_13_2","LEV","13","2","2","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠔꠞꠞ ꠌꠣꠝꠠꠣꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣ ꠎꠥꠖꠤ ꠀꠈꠔꠣ ꠚꠥꠟꠤ ꠎꠣꠄ, ꠛꠣ ꠇꠥꠘꠥ ꠇꠥꠟꠡ ꠃꠑꠦ ꠛꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠖꠣꠉ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠀꠞ ꠝꠘꠅ ꠡꠘ꠆ꠖꠄ ꠅꠄ ꠎꠦꠘ, ꠁꠔꠣ ꠛꠣꠖꠦ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠅꠁꠔ ꠙꠣꠞꠦ, ꠔꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠛꠣ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠔꠣꠞꠦ ꠟꠁꠀ ꠎꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_3","004_13_3","LEV","13","3","3","ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠣꠞ ꠌꠣꠝꠠꠣꠞ ꠅꠃ ꠎꠣꠉꠣ ꠖꠦꠈꠛꠣ, ꠢꠤ ꠎꠣꠉꠣꠞ ꠞꠥꠝꠣ ꠎꠥꠖꠤ ꠗꠟꠣ ꠅꠁꠎꠣꠄ, ꠀꠞ ꠛꠥꠎꠣ ꠎꠣꠄ ꠁ ꠛꠦꠝꠣꠞ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠞ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠤꠉꠦꠍꠦ, ꠔꠦ ꠛꠥꠎꠛꠣꠄ, ꠁꠔꠣ ꠘꠣꠙꠣꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ। ꠁꠟꠣ ꠛꠦꠝꠣꠞꠤ ꠖꠦꠈꠟꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_4","004_13_4","LEV","13","4","4","ꠅꠁꠟꠦ ꠔꠣꠞ ꠌꠣꠝꠠꠣꠞ ꠝꠣꠎꠦ ꠅꠃ ꠖꠣꠉ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠗꠟꠣ ꠅꠄ, ꠀꠞ ꠁꠔꠣ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠞ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠘꠣ ꠟꠣꠉꠦ, ꠅꠘꠞ ꠞꠥꠝꠣ ꠗꠟꠣ ꠘꠣ ꠅꠄ, ꠔꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠅꠃ ꠎꠘꠞꠦ ꠡꠣꠔ ꠖꠤꠘ ꠗꠞꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_5","004_13_5","LEV","13","5","5","ꠛꠣꠖꠦ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠛꠣ। ꠎꠥꠖꠤ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠅꠃ ꠛꠦꠝꠣꠞ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠦꠖꠤ ꠘꠣ ꠉꠤꠀ ꠎꠦꠟꠣ ꠀꠍꠤꠟ ꠅꠟꠣ ꠞꠁꠍꠦ, ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠀꠞꠅ ꠡꠣꠔ ꠖꠤꠘ ꠀꠟꠉꠣ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_6","004_13_6","LEV","13","6","6","ꠀꠞ ꠢꠤꠞꠛꠣꠞ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠞꠦ ꠖꠦꠈꠛꠣ, ꠄꠞꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠛꠦꠝꠣꠞ ꠘꠣ ꠛꠣꠠꠤꠀ ꠢꠥꠇꠣꠁꠀ ꠇꠝꠤ ꠎꠣꠄ, ꠔꠦ ꠛꠥꠎꠛꠣ, ꠁꠔꠣ ꠈꠣꠟꠤ ꠇꠥꠟꠡ ꠃꠑꠍꠦ। ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV13_7","004_13_7","LEV","13","7","7","ꠅꠁꠟꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠉꠔꠞꠞ ꠇꠥꠟꠡ ꠀꠞꠅ ꠛꠣꠠꠤ ꠎꠣꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠖꠦꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_8","004_13_8","LEV","13","8","8","ꠁꠝꠣꠝꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠛꠣ, ꠎꠥꠖꠤ ꠅꠃ ꠛꠦꠝꠣꠞ ꠌꠣꠝꠠꠣꠞ ꠃꠙꠞꠦ ꠀꠞꠅ ꠛꠣꠠꠤ ꠎꠣꠄ, ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ, ꠁꠔꠣ ꠘꠣꠙꠣꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ, ꠔꠣꠁꠘ ꠄꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_9","004_13_9","LEV","13","9","9","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠌꠣꠝꠠꠣꠔ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠞ ꠟꠣꠈꠣꠘ ꠖꠦꠈꠣ ꠉꠦꠟꠦ ꠔꠣꠞꠦ ꠘꠤꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠖꠦꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_10","004_13_10","LEV","13","10","10","ꠁꠝꠣꠝꠦ ꠖꠦꠈꠛꠣ, ꠔꠣꠞ ꠉꠔꠞꠅ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠞ ꠌꠣꠝꠠꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠖꠤ ꠗꠟꠣ ꠅꠁꠀ ꠚꠥꠟꠤ ꠎꠣꠄ, ꠀꠞ ꠢꠘꠞ ꠞꠥꠝꠣ ꠗꠟꠣ ꠅꠁꠎꠣꠄ, ꠅꠃ ꠚꠥꠟꠣ ꠎꠣꠉꠣꠔ ꠇꠣꠌꠣ ꠊꠣ ꠕꠣꠇꠦ, ");
INSERT INTO syls_vpl VALUES ("LV13_11","004_13_11","LEV","13","11","11","ꠔꠦ ꠔ ꠁꠐꠣ ꠄꠇꠐꠣ ꠙꠥꠞꠣꠘꠣ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ। ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ꠔꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣꠞ ꠟꠣꠉꠤ ꠡꠝꠣꠎꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠝꠤꠀꠖꠦ ꠖꠥꠞꠁ ꠞꠣꠈꠣꠞ ꠎꠞꠥꠞ ꠘꠣꠄ, ꠢꠦ ꠔ ꠄꠝꠘꠦꠃ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV13_12","004_13_12","LEV","13","12","12","“ꠅꠁꠟꠦ ꠁ ꠛꠦꠝꠣꠞ ꠎꠥꠖꠤ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠅ ꠅꠁꠎꠣꠄ, ꠀꠞ ꠁꠝꠣꠝꠦ ꠡꠞꠤꠟꠞ ꠎꠔ ꠎꠣꠉꠣ ꠖꠦꠈꠔꠣ ꠙꠣꠞꠂꠘ, ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠎꠥꠖꠤ ꠔꠣꠘ ꠝꠘꠅ ꠅꠄ, ꠁ ꠛꠦꠝꠣꠞ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠙꠣꠅ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LV13_13","004_13_13","LEV","13","13","13","ꠔꠦ ꠔꠣꠞꠦ ꠀꠞꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠖꠦꠈꠛꠣ, ꠀꠞ ꠖꠦꠈꠤꠀ ꠎꠥꠖꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠁ ꠛꠦꠝꠣꠞꠦ ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠉꠔꠞ ꠗꠟꠣ ꠅꠁꠉꠦꠍꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠉꠔꠞ ꠗꠟꠣ ꠅꠀꠄ ꠢꠦ ꠘꠣꠙꠣꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_14","004_13_14","LEV","13","14","14","ꠅꠁꠟꠦ ꠄꠞꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠇꠣꠌꠣ ꠊꠣ ꠖꠦꠈꠣ ꠖꠦꠄ, ꠔꠦ ꠢꠦ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV13_15","004_13_15","LEV","13","15","15","ꠁꠝꠣꠝꠦ ꠅꠃ ꠊꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ꠅꠃ ꠊꠣ ꠔ ꠘꠣꠙꠣꠇ, ꠔꠣꠞ ꠘꠣꠙꠣꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV13_16","004_13_16","LEV","13","16","16","ꠛꠣꠖꠦ ꠅꠃ ꠇꠣꠌꠣ ꠊꠣ ꠢꠥꠇꠣꠁꠀ ꠎꠥꠖꠤ ꠗꠟꠣ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_17","004_13_17","LEV","13","17","17","ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠛꠣ, ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠉꠔꠞꠞ ꠛꠦꠝꠣꠞ ꠎꠥꠖꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠗꠟꠣ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ, ꠢꠦ ꠀꠍꠟꠦꠃ ꠙꠣꠇ-ꠍꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("LV13_18","004_13_18","LEV","13","18","18","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠔꠞꠅ ꠎꠥꠖꠤ ꠛꠞꠘ ꠅꠁꠀ ꠁꠐꠣ ꠜꠣꠟꠣ ꠅꠁꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV13_19","004_13_19","LEV","13","19","19","ꠀꠞ ꠅꠃ ꠎꠣꠉꠣ ꠛꠣꠖꠦ ꠗꠟꠣ ꠅꠁꠀ ꠚꠥꠟꠤ ꠎꠣꠄ, ꠛꠣ ꠟꠣꠟꠐꠤ-ꠗꠟꠣ ꠖꠣꠉ ꠅꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_20","004_13_20","LEV","13","20","20","ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠖꠦꠈꠛꠣ, ꠢꠤ ꠛꠦꠝꠣꠞ ꠎꠥꠖꠤ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠦ ꠉꠤꠀ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠤꠎꠣꠄ, ꠞꠥꠝꠣ ꠗꠟꠣ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠁꠐꠣ ꠔ ꠛꠞꠘꠞ ꠎꠣꠉꠣꠔ ꠎꠘꠝ ꠟꠅꠀ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ, ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_21","004_13_21","LEV","13","21","21","ꠅꠁꠟꠦ ꠁꠝꠣꠝꠦ ꠇꠥꠘꠥ ꠗꠟꠣ ꠞꠥꠝꠣ ꠘꠣ ꠖꠦꠈꠟꠦ, ꠀꠞ ꠅꠃ ꠊꠣ ꠎꠥꠖꠤ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠦ ꠘꠣ ꠉꠤꠀ ꠢꠥꠇꠣꠁꠎꠤꠛꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠄ, ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠡꠣꠔ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠀꠟꠉ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_22","004_13_22","LEV","13","22","22","ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠁꠔꠣ ꠌꠣꠝꠠꠣꠞ ꠃꠙꠞꠦ ꠍꠤꠔ꠆ꠞꠤ ꠎꠣꠞ, ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ, ꠁꠔꠣ ꠄꠇꠟꠣꠈꠣꠘ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LV13_23","004_13_23","LEV","13","23","23","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠇꠝ-ꠛꠦꠡꠤ ꠘꠣ ꠅꠁꠟꠦ, ꠘꠣ ꠍꠤꠔ꠆ꠞꠤꠟꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ ꠁꠔꠣ ꠈꠣꠟꠤ ꠛꠞꠘꠞ ꠖꠣꠉ, ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_24","004_13_24","LEV","13","24","24","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠔꠞꠞ ꠇꠥꠘꠥ ꠅꠋꠡ ꠎꠥꠖꠤ ꠀꠉꠥꠁꠘꠦ ꠎꠟꠤ ꠎꠣꠄ, ꠀꠞ ꠅꠃ ꠎꠟꠣꠞ ꠎꠣꠉꠣꠔ ꠇꠣꠌꠣ ꠊꠣꠞ ꠝꠣꠎꠦ ꠟꠣꠟꠐꠤ ꠛꠣ ꠗꠟꠣ ꠖꠣꠉ ꠖꠦꠈꠣ ꠖꠦꠄ, ");
INSERT INTO syls_vpl VALUES ("LV13_25","004_13_25","LEV","13","25","25","ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠖꠦꠈꠛꠣ। ꠀꠞ ꠎꠥꠖꠤ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠞꠥꠝꠣ ꠗꠟꠣ ꠅꠁꠉꠦꠍꠦ, ꠅꠃ ꠊꠣ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠦ ꠉꠤꠀ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠤꠉꠦꠍꠦ, ꠔꠦ ꠁꠐꠣ ꠔ ꠎꠣꠟꠣꠁꠟ ꠎꠣꠉꠣꠔ ꠎꠘꠝ ꠟꠅꠀ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠅꠁꠀ ꠛꠣꠞ ꠅꠁꠍꠦ। ꠁꠔꠣ ꠔ ꠘꠣꠙꠣꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ, ꠄꠞꠟꠣꠉꠤ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_26","004_13_26","LEV","13","26","26","ꠅꠁꠟꠦ ꠁꠝꠣꠝꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠁ ꠎꠣꠉꠣꠞ ꠞꠥꠝꠣ ꠗꠟꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠞ ꠊꠣ ꠍꠤꠔ꠆ꠞꠤꠀ ꠉꠤꠀ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠘꠣ ꠟꠣꠉꠤꠀ ꠝꠤꠟꠤ ꠎꠣꠞ, ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠡꠣꠔ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠀꠟꠉ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_27","004_13_27","LEV","13","27","27","ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠛꠣ, ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠅꠃ ꠛꠦꠝꠣꠞ ꠛꠣꠠꠤ ꠎꠣꠞ, ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ꠁꠔꠣ ꠄꠇꠟꠣꠈꠣꠘ ꠘꠣꠙꠣꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LV13_28","004_13_28","LEV","13","28","28","ꠅꠁꠟꠦ ꠁ ꠎꠣꠉꠣ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠇꠝ-ꠛꠦꠡ ꠘꠣ ꠅꠁꠀ ꠎꠦꠟꠣ ꠀꠍꠤꠟ ꠅꠟꠣ ꠕꠣꠇꠦ, ꠀꠞ ꠌꠣꠝꠠꠣꠞ ꠝꠣꠎꠦ ꠘꠣ ꠍꠤꠔ꠆ꠞꠤꠀ ꠝꠤꠟꠤ ꠎꠣꠅꠀꠔ ꠞꠄ, ꠔꠦ ꠁꠔꠣ ꠀꠉꠥꠁꠘꠦ ꠎꠟꠣꠞ ꠚꠥꠟꠣ ꠇꠁꠀ ꠗꠞꠣ ꠅꠁꠛ। ꠁꠔꠣ ꠔ ꠄꠇꠟꠣꠈꠣꠘ ꠎꠟꠣꠞ ꠖꠣꠉ, ꠀꠞ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_29","004_13_29","LEV","13","29","29","“ꠀꠞ ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠞ ꠝꠣꠕꠣ ꠛꠣ ꠖꠣꠠꠤ-ꠝꠥꠍꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠊꠣꠞ ꠀꠟꠣꠝꠔ ꠖꠦꠈꠣ ꠖꠦꠄ, ");
INSERT INTO syls_vpl VALUES ("LV13_30","004_13_30","LEV","13","30","30","ꠔꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠖꠦꠈꠛꠣ। ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠛꠦꠝꠣꠞꠤ ꠎꠣꠉꠣꠞ ꠌꠥꠟ ꠛꠣ ꠞꠥꠝ ꠅꠟꠖꠤꠀ ꠅꠁꠀ ꠌꠤꠇꠘ ꠅꠁꠉꠦꠍꠦ, ꠀꠞ ꠊꠣ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠦ ꠉꠤꠀ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠤꠉꠦꠍꠦ, ꠔꠦ ꠁꠐꠣ ꠔ ꠄꠇꠟꠣꠈꠣꠘ ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤꠞ ꠝꠥꠈ, ꠁꠔꠣ ꠖꠣꠠꠤ-ꠝꠥꠍ ꠛꠣ ꠝꠣꠕꠣꠞ ꠌꠣꠝꠠꠣꠔ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠛꠣꠞ ꠅꠁꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_31","004_13_31","LEV","13","31","31","ꠅꠁꠟꠦ ꠁꠝꠣꠝꠦ ꠎꠥꠖꠤ ꠛꠦꠝꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠂꠘ, ꠁ ꠊꠣ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠦ ꠉꠦꠍꠦ ꠘꠣ, ꠀꠞ ꠅꠘꠞ ꠌꠥꠟ ꠛꠣ ꠞꠥꠝ ꠔ ꠇꠣꠟꠣ ꠘꠣꠄ, ꠔꠦ ꠅꠃ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠡꠣꠔ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠀꠟꠉ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_32","004_13_32","LEV","13","32","32","ꠛꠣꠖꠦ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠁꠝꠣꠝꠦ ꠢꠤꠞꠛꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠁ ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤ ꠛꠦꠝꠣꠞ ꠛꠣꠠꠍꠦ ꠘꠣ, ꠛꠣ ꠌꠥꠟ-ꠞꠥꠝꠅ ꠅꠟꠖꠤꠀ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠞ ꠅꠘꠞ ꠊꠣ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠞ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠍꠦ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("LV13_33","004_13_33","LEV","13","33","33","ꠔꠦ ꠅꠃ ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤꠞ ꠎꠣꠉꠣ ꠛꠣꠖ ꠖꠤꠀ, ꠔꠣꠞ ꠡꠞꠤꠟꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠌꠥꠟ ꠛꠣ ꠖꠣꠠꠤ-ꠝꠥꠍ ꠇꠣꠝꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠀꠞꠅ ꠡꠣꠔ ꠖꠤꠘ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠀꠟꠉ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_34","004_13_34","LEV","13","34","34","ꠀꠞ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠁꠝꠣꠝꠦ ꠢꠤꠞꠛꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠁ ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤ ꠌꠣꠝꠠꠣꠞ ꠃꠙꠞꠦ ꠍꠤꠔ꠆ꠞꠤꠍꠦ ꠘꠣ, ꠛꠣ ꠌꠣꠝꠠꠣꠞ ꠔꠟꠦꠖꠤ ꠉꠥꠡ꠆ꠔꠞ ꠝꠣꠎꠦꠅ ꠟꠣꠉꠍꠦ ꠘꠣ, ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ꠀꠞ ꠢꠦ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠛꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV13_35","004_13_35","LEV","13","35","35","ꠔꠣ-ꠅ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠣꠞ ꠛꠣꠖꠦꠅ ꠎꠥꠖꠤ ꠁ ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤ ꠌꠣꠝꠠꠣꠞ ꠃꠙꠞꠦ ꠍꠤꠔ꠆ꠞꠤ ꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV13_36","004_13_36","LEV","13","36","36","ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠛꠣ। ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠁ ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠍꠦ, ꠔꠦ ꠌꠥꠟ ꠛꠣ ꠞꠥꠝ ꠅꠟꠖꠤꠀ ꠅꠁꠍꠦ ꠇꠤ ꠘꠣ ꠁꠔꠣ ꠀꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠎꠞꠥꠞ ꠘꠣꠄ, ꠢꠦ ꠔ ꠄꠝꠘꠦꠃ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV13_37","004_13_37","LEV","13","37","37","ꠅꠁꠟꠦ ꠁꠝꠣꠝꠦ ꠎꠥꠖꠤ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠁꠔꠣ ꠎꠦꠟꠣ ꠀꠍꠤꠟ ꠅꠟꠣꠃ ꠞꠁꠍꠦ, ꠀꠞ ꠁ ꠎꠣꠉꠣꠔ ꠇꠣꠟꠣ ꠞꠥꠝꠣ ꠃꠑꠦꠞ, ꠔꠦ ꠛꠥꠎꠛꠣ, ꠁꠔꠣ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍꠦ। ꠢꠦ ꠔ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠀꠍꠦ। ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_38","004_13_38","LEV","13","38","38","“ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠞ ꠌꠣꠝꠠꠣꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠗꠟꠣ ꠌꠇꠌꠇꠣ ꠖꠣꠉ ꠖꠦꠈꠣ ꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV13_39","004_13_39","LEV","13","39","39","ꠔꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠖꠦꠈꠛꠣ। ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠔꠣꠞ ꠖꠣꠉ ꠗꠟꠣ ꠚꠣꠁꠘꠡꠣ ꠅꠁꠉꠦꠍꠦ, ꠔꠦ ꠁꠐꠣ ꠔ ꠈꠣꠟꠤ ꠗꠟ-ꠚꠤꠡ꠆ꠔꠤ ꠅꠁꠍꠦ। ꠁꠔꠣꠄ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠅꠁꠔ ꠘꠣꠄ, ꠢꠦ ꠔ ꠙꠣꠇ-ꠍꠣꠚ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV13_40","004_13_40","LEV","13","40","40","“ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠎꠥꠖꠤ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠙꠠꠤꠀ ꠐꠣꠇ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠢꠦ ꠘꠣꠙꠣꠇ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_41","004_13_41","LEV","13","41","41","ꠔꠣꠞ ꠝꠣꠕꠣꠞ ꠍꠣꠝꠘꠞ ꠉꠣꠟꠣꠞ ꠌꠥꠟ ꠙꠠꠤꠀ ꠎꠥꠖꠤ ꠇꠙꠣꠟꠞ ꠛꠣꠄ ꠐꠣꠇ ꠙꠠꠤ ꠎꠣꠄ, ꠔꠦ ꠢꠦ-ꠅ ꠘꠣꠙꠣꠇ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_42","004_13_42","LEV","13","42","42","ꠅꠁꠟꠦ ꠁ ꠐꠣꠇ ꠙꠠꠣ ꠝꠣꠕꠣ ꠛꠣ ꠇꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠟꠣꠟꠐꠤ ꠖꠣꠉ ꠖꠦꠈꠣ ꠖꠦꠄ, ꠔꠦ ꠛꠥꠎꠛꠣꠄ, ꠔꠣꠞ ꠝꠣꠕꠣ ꠛꠣ ꠇꠙꠣꠟꠅ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠛꠣꠞ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV13_43","004_13_43","LEV","13","43","43","ꠀꠞ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠔꠣꠞ ꠇꠙꠣꠟꠅ ꠛꠣ ꠝꠣꠕꠣꠔ ꠘꠣꠙꠣꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤꠞ ꠟꠣꠈꠣꠘ ꠢꠃ ꠖꠣꠉ ꠔ ꠚꠥꠟꠤ ꠉꠦꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LV13_44","004_13_44","LEV","13","44","44","ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ, ꠔꠣꠞ ꠘꠣꠙꠣꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠅꠁꠍꠦ, ꠢꠦ ꠔ ꠘꠣꠙꠣꠇ। ꠔꠣꠞ ꠝꠣꠕꠣꠞ ꠅꠃ ꠛꠦꠝꠣꠞꠞ ꠟꠣꠉꠤ ꠁꠝꠣꠝꠦ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_45","004_13_45","LEV","13","45","45","“ꠀꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠎꠦ ꠝꠣꠘꠡꠞ ꠅꠁꠛ, ꠢꠦ ꠚꠣꠞꠣ-ꠌꠤꠞꠣ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠔꠦ ꠅꠁꠛ। ꠔꠣꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠀꠃꠟꠣ-ꠎꠣꠃꠟꠣ ꠞꠁꠛ। ꠔꠣꠞ ꠝꠥꠈꠞꠦ ꠢꠤꠎꠣꠛꠞ ꠟꠣꠈꠣꠘ ꠇꠣꠙꠠꠖꠤ ꠉꠥꠞꠤꠀ ꠌꠤꠟ꠆ꠟꠣꠁ ꠌꠤꠟ꠆ꠟꠣꠁ ꠇꠁꠛ, ꠘꠣꠙꠣꠇ, ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV13_46","004_13_46","LEV","13","46","46","ꠁ ꠛꠦꠝꠣꠞ ꠔꠣꠞ ꠉꠔꠞꠅ ꠎꠔꠖꠤꠘ ꠞꠁꠛ, ꠅꠔꠖꠤꠘ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠄꠇꠟꠣ ꠄꠇꠟꠣ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV13_47","004_13_47","LEV","13","47","47","“ꠇꠥꠘꠥ ꠇꠣꠙꠠꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠍꠣꠛꠣ ꠍꠣꠛꠣ ꠖꠣꠉ ꠟꠣꠉꠦ, ꠃꠟꠞ ꠇꠣꠙꠠ ꠛꠣ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠚꠦꠃꠇꠘꠤ ꠙꠠꠣꠞ ꠀꠟꠣꠝꠔ ꠝꠤꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("LV13_48","004_13_48","LEV","13","48","48","ꠁꠔꠣ ꠃꠟꠞ ꠇꠣꠙꠠ ꠛꠣ ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠛꠣꠘꠣꠘꠤꠞ ꠐꠣꠘꠣ ꠛꠣ ꠔꠣꠔꠞ ꠝꠣꠎꠦ ꠅꠃꠇ, ꠛꠣ ꠌꠣꠝꠠꠣ ꠀꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠎꠦꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠚꠦꠃꠇꠘꠤꠞ ꠖꠣꠉ ꠝꠤꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("LV13_49","004_13_49","LEV","13","49","49","ꠀꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠꠞ ꠐꠣꠘꠣ ꠛꠣ ꠔꠣꠔꠞ ꠝꠣꠎꠦ, ꠌꠣꠝꠠꠣꠞ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠅ ꠎꠥꠖꠤ ꠟꠣꠟꠐꠤ ꠛꠣ ꠇꠌꠥꠀ ꠇꠥꠘꠥꠎꠣꠔ ꠖꠣꠉ ꠝꠤꠟꠦ, ꠔꠦ ꠁꠔꠣ ꠅꠁꠟ ꠚꠦꠃꠇꠘꠤꠞ ꠀꠟꠣꠝꠔ। ꠁꠟꠣ ꠅꠁꠟꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠖꠦꠈꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("LV13_50","004_13_50","LEV","13","50","50","ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠁꠔꠣ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠖꠦꠈꠤꠀ, ꠅꠃ ꠎꠤꠘꠤꠡꠞꠦ ꠡꠣꠔ ꠖꠤꠘ ꠢꠇꠟꠔꠣ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_51","004_13_51","LEV","13","51","51","ꠛꠣꠖꠦ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠁꠝꠣꠝꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠛꠣ। ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠅꠃ ꠇꠣꠙꠠꠞ ꠐꠣꠘꠣꠔ ꠛꠣ ꠔꠣꠔꠅ, ꠛꠣ ꠌꠣꠝꠠꠣꠞ ꠎꠤꠘꠤꠡꠅ ꠟꠣꠟꠐꠤ ꠛꠣ ꠇꠌꠥꠀ ꠖꠣꠉ ꠛꠣꠠꠤꠍꠦ, ꠔꠦ ꠢꠃ ꠚꠦꠃꠇꠘꠤ ꠛꠦꠝꠣꠞ ꠛꠠ ꠝꠣꠞꠣꠔ꠆ꠔꠇ, ꠅꠃ ꠎꠤꠘꠤꠡ ꠔ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV13_52","004_13_52","LEV","13","52","52","ꠄꠞꠟꠣꠉꠤ ꠁ ꠇꠣꠙꠠ, ꠛꠣ ꠌꠣꠝꠠꠣꠞ ꠅꠃ ꠎꠤꠘꠤꠡ, ꠉꠣꠝꠍꠣ ꠛꠣ ꠃꠠꠘꠣ ꠎꠦꠔꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠚꠦꠃꠇꠘꠤꠞ ꠖꠣꠉ ꠝꠤꠟꠛ, ꠁꠔꠣ ꠢꠣꠍꠞꠤꠛ ꠇꠞꠤ ꠢꠇꠟꠔꠣ ꠎꠣꠟꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV13_53","004_13_53","LEV","13","53","53","“ꠅꠁꠟꠦ ꠁꠝꠣꠝꠦ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠁ ꠇꠣꠙꠠ ꠛꠣ ꠌꠣꠝꠠꠣꠞ ꠎꠤꠘꠤꠡꠞ ꠖꠣꠉ ꠘꠣ ꠍꠤꠔ꠆ꠞꠤꠀ ꠄꠇꠁ ꠎꠣꠉꠣꠔ ꠞꠁꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LV13_54","004_13_54","LEV","13","54","54","ꠔꠦ ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠙꠣꠘꠤꠖꠤ ꠗꠁꠀ ꠖꠤꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ। ꠗꠁꠀ ꠢꠣꠞꠤ ꠅꠃ ꠎꠤꠘꠤꠡꠞꠦ ꠡꠣꠔ ꠖꠤꠘ ꠖꠥꠍꠞꠣ ꠢꠇꠟꠔꠣ ꠕꠣꠇꠤ ꠢꠞꠣꠁ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV13_55","004_13_55","LEV","13","55","55","ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠛꠣ। ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠁ ꠚꠦꠃꠇꠘꠤꠞ ꠖꠣꠉ ꠇꠥꠘꠥꠛꠣꠄ ꠘꠣ ꠍꠤꠔ꠆ꠞꠤꠟꠦꠅ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠞꠋ ꠞꠁꠍꠦ, ꠔꠦ ꠁꠔꠣ ꠘꠣꠙꠣꠇ। ꠁꠉꠥꠞ ꠃꠟꠐꠣ-ꠜꠣꠐꠤꠅꠟ ꠎꠦꠇꠥꠘꠥ ꠉꠣꠟꠣꠛꠣꠄ ꠁ ꠖꠣꠉ ꠞꠃꠇ, ꠁꠉꠥꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV13_56","004_13_56","LEV","13","56","56","ꠅꠁꠟꠦ ꠁꠔꠣ ꠗꠁꠀ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠁꠝꠣꠝꠦ ꠖꠦꠈꠂꠘ, ꠁ ꠎꠣꠉꠣꠞ ꠞꠋ ꠚꠣꠁꠘꠡꠣ ꠅꠁꠉꠦꠍꠦ, ꠔꠦ ꠅꠃ ꠎꠣꠉꠣ ꠍꠤꠠꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_57","004_13_57","LEV","13","57","57","ꠀꠞ ꠗꠅꠀꠞ ꠛꠣꠖꠦꠅ ꠎꠥꠖꠤ ꠅꠃ ꠎꠤꠘꠤꠡꠅ ꠢꠤꠞꠛꠣꠞ ꠚꠦꠃꠇꠘꠤꠞ ꠖꠣꠉ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠔꠦ ꠛꠥꠎꠛꠣꠄ, ꠁꠔꠣ ꠍꠤꠔ꠆ꠞꠤ ꠎꠣꠅꠀ ꠛꠦꠝꠣꠞ, ꠄꠞꠟꠣꠉꠤ ꠁ ꠎꠤꠘꠤꠡꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_58","004_13_58","LEV","13","58","58","ꠀꠞ ꠅꠃ ꠎꠤꠘꠤꠡ ꠗꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠅꠃ ꠖꠣꠉ ꠝꠤꠟꠣꠁꠉꠦꠍꠦ, ꠔꠦ ꠁꠔꠣ ꠢꠤꠞꠛꠣꠞ ꠗꠁꠀ ꠢꠣꠞꠟꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠥꠎꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV13_59","004_13_59","LEV","13","59","59","“ꠅꠃ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠤꠀ ꠃꠟꠞ ꠇꠣꠙꠠ, ꠡꠥꠔꠤ ꠇꠣꠙꠠ ꠛꠣ ꠌꠣꠝꠠꠣꠞ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠅ ꠚꠦꠃꠇꠘꠤꠞ ꠖꠣꠉ ꠟꠣꠉꠟꠦ, ꠙꠣꠇ ꠛꠣ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LV14_1","004_14_1","LEV","14","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV14_2","004_14_2","LEV","14","2","2","“ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠖꠤꠘ ꠅꠃ ꠘꠤꠅꠝ ꠝꠣꠘꠤꠅ। ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("LV14_3","004_14_3","LEV","14","3","3","ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠉꠤꠀ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠛꠣ। ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ ꠢꠦ ꠢꠣꠍꠣꠃ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LV14_4","004_14_4","LEV","14","4","4","ꠔꠦ ꠁꠝꠣꠝꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ, ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀ ꠎꠘꠞ ꠘꠤꠅꠔꠦ ꠎꠤꠔꠣ ꠖꠥꠁꠐꠣ ꠢꠣꠟꠣꠟ ꠙꠣꠈꠤ, ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍꠞ ꠇꠤꠍꠥ ꠟꠣꠇꠠꠤ, ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠒꠦꠐꠣ ꠀꠞ ꠟꠣꠟ ꠡꠥꠔꠣ ꠟꠁꠀ ꠀꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_5","004_14_5","LEV","14","5","5","ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ, ꠚꠥꠔꠞ ꠙꠣꠘꠤ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠀꠘꠤꠀ ꠝꠣꠐꠤꠞ ꠉꠣꠝꠟꠣꠔ ꠕꠅꠀ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ, ꠢꠃ ꠖꠥꠁꠅ ꠙꠣꠈꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠐꠣꠞꠦ ꠎꠛ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LV14_6","004_14_6","LEV","14","6","6","ꠎꠛꠞ ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠛꠣꠇꠤ ꠢꠃ ꠎꠤꠔꠣ ꠙꠣꠈꠤꠞꠦ, ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍꠞ ꠟꠣꠇꠠꠤꠞꠦ, ꠟꠣꠟ ꠡꠥꠔꠣꠞꠦ ꠀꠞ ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠒꠦꠐꠣꠞꠦ, ꠚꠥꠔꠞ ꠙꠣꠘꠤꠞ ꠉꠣꠝꠟꠣꠞ ꠃꠙꠞꠦ ꠎꠛ ꠇꠞꠣ ꠢꠃ ꠙꠣꠈꠤꠞ ꠟꠃꠞ ꠝꠣꠎꠦ ꠍꠥꠛꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_7","004_14_7","LEV","14","7","7","ꠀꠞ ꠅꠃ ꠎꠦ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠔ, ꠁꠝꠣꠝꠦ ꠔꠣꠞ ꠃꠙꠞꠦ ꠢꠃ ꠟꠃ ꠡꠣꠔ ꠛꠣꠞ ꠍꠤꠐꠣꠁꠀ ꠢꠣꠞꠤ, ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠢꠃ ꠎꠤꠔꠣ ꠙꠣꠈꠤꠞꠦ ꠈꠥꠟꠣ ꠎꠣꠉꠣꠔ ꠍꠣꠠꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_8","004_14_8","LEV","14","8","8","ꠀꠞ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠘꠞꠣ ꠅꠃ ꠛꠦꠝꠣꠞꠤꠄ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠛ, ꠔꠣꠞ ꠉꠔꠞꠞ ꠀꠞ ꠝꠣꠕꠣꠞ ꠢꠇꠟ ꠌꠥꠟ-ꠞꠥꠝ ꠇꠣꠝꠣꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠘꠤ ꠖꠤꠀ ꠘꠣꠁꠔꠦ ꠅꠁꠛ, ꠔꠦꠃ ꠢꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠘꠛ। ꠄꠞꠛꠣꠖꠦ ꠢꠦ ꠀꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠛ, ꠅꠁꠟꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠔꠣꠝ꠆ꠛꠥꠞ ꠛꠣꠞꠦ ꠡꠣꠔ ꠖꠤꠘ ꠞꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV14_9","004_14_9","LEV","14","9","9","ꠛꠣꠖꠦ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠞ ꠡꠞꠤꠟꠞ ꠢꠇꠟ ꠌꠥꠟ, ꠝꠣꠘꠤ ꠝꠣꠕꠣꠞ ꠌꠥꠟ, ꠖꠣꠠꠤ-ꠝꠥꠍ, ꠌꠈꠥꠞ ꠜꠥꠞꠤ ꠀꠞ ꠉꠔꠞꠞ ꠢꠇꠟ ꠞꠥꠝꠣ ꠇꠣꠝꠣꠁꠔꠦ ꠅꠁꠛ। ꠛꠣꠖꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠘꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠢꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV14_10","004_14_10","LEV","14","10","10","“ꠛꠣꠖꠞ ꠖꠤꠘ ꠢꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠖꠥꠁꠐꠣ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠞ ꠄꠇ ꠛꠍꠞꠞ ꠄꠉꠥ ꠝꠦꠠꠤ ꠟꠁꠀ ꠀꠁꠛ। ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠢꠦ ꠍꠄ ꠡꠦꠞ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ ꠀꠞ ꠄꠇ ꠙꠣꠅꠀ ꠔꠦꠟ ꠀꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV14_11","004_14_11","LEV","14","11","11","ꠀꠘꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞ ꠙꠣꠇ-ꠍꠣꠚꠞ ꠟꠣꠉꠤ ꠎꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠇꠣꠝ ꠇꠞꠞꠣ, ꠄꠁꠘ ꠅꠃ ꠎꠘꠞꠦ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_12","004_14_12","LEV","14","12","12","“ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠢꠃ ꠖꠥꠁꠅ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠕꠣꠇꠤ ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠢꠃ ꠔꠦꠟ ꠘꠤꠀ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ꠇꠞꠤꠀ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠁꠔꠣ ꠖꠥꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_13","004_14_13","LEV","14","13","13","ꠛꠣꠖꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠎꠦ ꠎꠣꠉꠣꠔ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ ꠎꠛ ꠇꠞꠣ ꠅꠄ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠅꠃ ꠙꠡꠥꠞꠦꠅ ꠎꠛ ꠇꠞꠛꠣ। ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔꠅ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠙꠣꠁꠛꠣ, ꠁꠔꠣ ꠔ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠉꠥꠡ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("LV14_14","004_14_14","LEV","14","14","14","ꠎꠦ ꠎꠘꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠛ, ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠇꠤꠍꠥ ꠟꠃ ꠘꠤꠀ ꠔꠣꠞ ꠒꠣꠁꠘ ꠇꠣꠘꠞ ꠟꠔꠤꠔ, ꠒꠣꠁꠘ ꠀꠔꠞ ꠀꠞ ꠒꠣꠁꠘ ꠙꠣꠅꠞ ꠛꠥꠠꠤ ꠀꠋꠉꠥꠟꠤꠔ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_15","004_14_15","LEV","14","15","15","ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠢꠃ ꠔꠦꠟ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠔꠦꠟ ꠔꠣꠘ ꠛꠣꠃ ꠀꠔꠞ ꠔꠣꠟꠥꠞ ꠝꠣꠎꠦ ꠓꠣꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_16","004_14_16","LEV","14","16","16","ꠀꠞ ꠒꠣꠁꠘ ꠀꠔꠞ ꠀꠋꠉꠥꠁꠟ ꠖꠤꠀ, ꠛꠣꠃ ꠀꠔ ꠕꠣꠇꠤ ꠔꠦꠟ ꠔꠥꠟꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠡꠣꠔ ꠛꠣꠞ ꠍꠤꠐꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_17","004_14_17","LEV","14","17","17","ꠛꠣꠖꠦ ꠀꠔꠞ ꠔꠣꠟꠥꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠔꠦꠟ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠔꠦꠟ ꠘꠤꠀ ꠁꠝꠣꠝꠦ ꠢꠃ ꠎꠘꠞ ꠒꠣꠁꠘ ꠇꠣꠘꠞ ꠟꠔꠤꠔ, ꠒꠣꠁꠘ ꠀꠔꠞ ꠀꠞ ꠒꠣꠁꠘ ꠙꠣꠅꠞ ꠛꠥꠠꠤ ꠀꠋꠉꠥꠟꠤꠔ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_18","004_14_18","LEV","14","18","18","ꠀꠞ ꠀꠔꠞ ꠔꠣꠟꠥꠞ ꠛꠣꠇꠤ ꠔꠦꠟ ꠔꠣꠁꠘ ꠢꠃ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀ ꠎꠘꠞ ꠝꠣꠕꠣꠔ ꠟꠣꠉꠣꠁꠛꠣ। “ꠀꠞ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("LV14_19","004_14_19","LEV","14","19","19","ꠎꠦ ꠎꠘꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠛ, ꠔꠣꠞ ꠀꠘꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠎꠛ ꠇꠞꠛꠣ। ꠛꠣꠖꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠅ ꠎꠛ ꠇꠞꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("LV14_20","004_14_20","LEV","14","20","20","ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠎꠤꠘꠤꠡꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠁꠀ, ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠁꠔꠣ ꠖꠤꠛꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠔꠣꠞ ꠘꠣꠙꠣꠇꠤ ꠢꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_21","004_14_21","LEV","14","21","21","“ꠅꠁꠟꠦ ꠅꠃ ꠎꠘ ꠎꠥꠖꠤ ꠉꠞꠤꠛ ꠅꠄ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠀꠘꠣꠞ ꠔꠚꠤꠇ ꠔꠣꠞ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠈꠣꠟꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠔꠦ ꠅꠁꠛ, ꠀꠘꠟꠦ ꠁꠝꠣꠝꠦ ꠔꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠇꠐꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ ꠖꠥꠟꠣꠁꠛꠣ। ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠞ ꠀꠘꠣ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠖꠥꠁ ꠡꠦꠞ ꠝꠄꠖꠣ, ꠄꠇ ꠙꠣꠅꠀ ꠔꠦꠟ ");
INSERT INTO syls_vpl VALUES ("LV14_22","004_14_22","LEV","14","22","22","ꠀꠞ ꠔꠣꠞ ꠖꠥꠁꠐꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠛꠣ ꠙꠣꠞꠅ ꠀꠘꠔꠦ ꠅꠁꠛ, ꠎꠦꠟꠣ ꠔꠣꠞ ꠔꠣꠇ꠆ꠇꠔꠦ ꠇꠥꠟꠣꠄ। ꠖꠥꠁꠅ ꠙꠣꠈꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠐꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠄꠇꠐꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LV14_23","004_14_23","LEV","14","23","23","ꠛꠣꠖꠦ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠘꠤꠅꠔꠦ ꠢꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠀꠘꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠗꠣꠞꠅ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠡꠝꠎꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV14_24","004_14_24","LEV","14","24","24","ꠁꠝꠣꠝꠦ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣ ꠀꠞ ꠅꠃ ꠔꠦꠟ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠥꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_25","004_14_25","LEV","14","25","25","ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠝꠦꠠꠣꠞꠦ ꠎꠛ ꠇꠞꠤꠀ ꠅꠉꠥꠞ ꠇꠤꠍꠥ ꠟꠃ ꠘꠤꠀ ꠢꠃ ꠎꠘꠞ ꠒꠣꠁꠘ ꠇꠣꠘꠞ ꠟꠔꠤꠔ, ꠒꠣꠁꠘ ꠀꠔꠞ ꠀꠞ ꠒꠣꠁꠘ ꠙꠣꠅꠞ ꠛꠥꠠꠤ ꠀꠋꠉꠥꠟꠤꠔ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_26","004_14_26","LEV","14","26","26","ꠛꠣꠖꠦ ꠢꠃ ꠔꠦꠟ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠔꠦꠟ ꠔꠣꠘ ꠛꠣꠃ ꠀꠔꠞ ꠔꠣꠟꠥꠞ ꠝꠣꠎꠦ ꠓꠣꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_27","004_14_27","LEV","14","27","27","ꠀꠞ ꠒꠣꠁꠘ ꠀꠔꠞ ꠀꠋꠉꠥꠁꠟ ꠖꠤꠀ ꠁꠝꠣꠝꠦ ꠛꠣꠃ ꠀꠔꠞ ꠇꠤꠍꠥ ꠔꠦꠟ ꠔꠥꠟꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠡꠣꠔ ꠛꠣꠞ ꠍꠤꠐꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_28","004_14_28","LEV","14","28","28","ꠄꠞꠟꠉꠦ ꠔꠣꠞ ꠒꠣꠁꠘ ꠇꠣꠘꠞ ꠟꠔꠤꠔ, ꠒꠣꠁꠘ ꠀꠔꠞ ꠀꠞ ꠒꠣꠁꠘ ꠙꠣꠅꠞ ꠛꠥꠠꠤ ꠀꠋꠉꠥꠟꠤꠞ ꠎꠦ ꠎꠣꠉꠣꠔ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠍꠦ, ꠢꠃ ꠎꠣꠉꠣꠞ ꠃꠙꠞꠦ ꠅꠃ ꠔꠦꠟꠅ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_29","004_14_29","LEV","14","29","29","ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠢꠃ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀ ꠎꠘꠞ ꠇꠚꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠁꠝꠣꠝꠞ ꠀꠔꠞ ꠛꠣꠇꠤ ꠔꠦꠟ ꠔꠣꠞ ꠝꠣꠕꠣꠔ ꠓꠣꠟꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_30","004_14_30","LEV","14","30","30","ꠛꠣꠖꠦ ꠢꠃ ꠎꠘꠞ ꠔꠣꠇ꠆ꠇꠔ ꠝꠣꠚꠤꠇ ꠀꠘꠣ ꠒꠥꠙꠤ ꠛꠣ ꠙꠣꠞꠅ ꠎꠥꠠꠣ ꠘꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("LV14_31","004_14_31","LEV","14","31","31","ꠁꠝꠣꠝꠦ ꠄꠉꠥꠞꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ, ꠀꠞ ꠖꠥꠍꠞꠣꠐꠣꠞꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣ। ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞꠦꠅ ꠖꠤꠛꠣ। ꠁꠝꠣꠝꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_32","004_14_32","LEV","14","32","32","ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠦꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠇꠕꠣ, ꠁꠔꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠎꠦꠞꠣꠞ ꠘꠣꠁ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠘꠤꠅꠝ ꠖꠦꠅꠀ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LV14_33","004_14_33","LEV","14","33","33","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV14_34","004_14_34","LEV","14","34","34","“ꠀꠝꠤ ꠎꠦ ꠖꠦꠡꠈꠣꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣꠄ ꠖꠤꠝꠥ, ꠅꠃ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠛꠣꠖꠦ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠢꠘꠞ ꠇꠥꠘꠥ ꠊꠞꠞ ꠝꠣꠎꠦ ꠘꠣꠙꠣꠇ-ꠚꠦꠃꠇꠘꠤ ꠛꠦꠝꠣꠞ ꠙꠣꠑꠣꠁ, ");
INSERT INTO syls_vpl VALUES ("LV14_35","004_14_35","LEV","14","35","35","ꠔꠦ ꠊꠞꠞ ꠝꠣꠟꠤꠇꠦ ꠉꠤꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞꠦ ꠇꠁꠛꠣ, ꠀꠝꠣꠞ ꠊꠞꠅ ꠘꠣꠙꠣꠇ-ꠚꠦꠃꠇꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠇꠤꠔꠣ ꠎꠣꠘꠥ ꠖꠦꠈꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("LV14_36","004_14_36","LEV","14","36","36","ꠔꠦꠃ ꠁꠝꠣꠝꠦ ꠁ ꠚꠦꠃꠇꠘꠤ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠣꠔ ꠀꠁꠀ, ꠊꠞꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞꠦ ꠎꠣꠔꠦ ꠘꠣꠙꠣꠇ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠣ ꠘꠣ ꠟꠣꠉꠦ, ꠅꠃ ꠘꠤꠅꠔꠦ ꠔꠣꠁꠘ ꠝꠣꠟꠤꠇꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ, ꠀꠝꠤ ꠊꠞꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠀꠉꠦ ꠔꠥꠝꠣꠞ ꠊꠞꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠛꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠟꠣꠅ। ꠢꠇꠟꠔꠣ ꠛꠣꠞ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_37","004_14_37","LEV","14","37","37","ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠊꠞꠞ ꠅꠀꠟꠞ ꠇꠥꠘꠥ ꠚꠦꠃꠇꠘꠤꠞ ꠖꠣꠉ ꠉꠤꠀ ꠜꠤꠔꠞꠦꠖꠤ ꠢꠣꠝꠣꠁꠍꠦ, ꠀꠞ ꠅꠃ ꠖꠣꠉꠞ ꠞꠋ ꠇꠌꠥꠀ ꠛꠣ ꠟꠣꠟꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("LV14_38","004_14_38","LEV","14","38","38","ꠔꠦ ꠔꠣꠁꠘ ꠁ ꠊꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁ ꠀꠁꠀ, ꠊꠞꠞ ꠖꠥꠀꠞ ꠡꠣꠔ ꠖꠤꠘ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠕꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_39","004_14_39","LEV","14","39","39","ꠅꠃ ꠡꠣꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠖꠦꠈꠛꠣ, ꠎꠥꠖꠤ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠁ ꠖꠣꠉ ꠅꠀꠟꠞ ꠝꠣꠎꠦ ꠀꠞꠅ ꠍꠤꠔ꠆ꠞꠤꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LV14_40","004_14_40","LEV","14","40","40","ꠔꠦ ꠔꠣꠁꠘ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ, ꠅꠃ ꠅꠀꠟꠞ ꠖꠣꠉ ꠀꠟꠣ ꠙꠣꠔ꠆ꠔꠞ ꠛꠣ ꠁꠐ ꠈꠥꠟꠤꠀ ꠢꠣꠞꠤ, ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠘꠣꠙꠣꠇ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_41","004_14_41","LEV","14","41","41","ꠛꠣꠖꠦ ꠀꠡ꠆ꠔꠣ ꠊꠞꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟ ꠅꠀꠟ ꠌꠣꠍꠤꠀ ꠀꠡ꠆ꠔꠞ ꠔꠥꠟꠤꠀ ꠢꠣꠞꠤ, ꠅꠔꠣ ꠘꠤꠀ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠚꠣꠟꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_42","004_14_42","LEV","14","42","42","ꠀꠞ ꠅꠀꠟꠞ ꠎꠦ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠙꠣꠔ꠆ꠔꠞ ꠛꠣ ꠁꠐ ꠈꠥꠟꠣ ꠅꠁꠍꠦ, ꠢꠘꠅ ꠘꠄꠀ ꠙꠣꠔ꠆ꠔꠞ ꠟꠣꠉꠣꠁꠛꠣ, ꠟꠣꠉꠣꠁꠀ ꠀꠡ꠆ꠔꠣ ꠊꠞ ꠢꠤꠞꠛꠣꠞ ꠘꠄꠀ ꠀꠡ꠆ꠔꠞ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_43","004_14_43","LEV","14","43","43","“ꠅꠀꠟꠞ ꠙꠣꠔ꠆ꠔꠞ ꠈꠥꠟꠤꠀ ꠚꠣꠟꠣꠁꠀ ꠌꠣꠍꠤꠀ ꠀꠡ꠆ꠔꠞ ꠔꠥꠟꠣꠞ ꠛꠣꠖꠦ, ꠘꠄꠀ ꠀꠡ꠆ꠔꠞ ꠟꠣꠉꠣꠁꠀ ꠢꠣꠞꠟꠦꠅ ꠎꠥꠖꠤ ꠅꠀꠟꠅ ꠢꠤꠞꠛꠣꠞ ꠅꠟꠣ ꠖꠣꠉ ꠖꠦꠈꠣ ꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV14_44","004_14_44","LEV","14","44","44","ꠔꠦ ꠁꠝꠣꠝꠦ ꠢꠤꠞꠛꠣꠞ ꠉꠤꠀ ꠁꠔꠣ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠖꠦꠈꠛꠣ। ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠅꠀꠟꠞ ꠝꠣꠎꠞ ꠖꠣꠉ ꠍꠤꠔ꠆ꠞꠤꠀ ꠀꠞꠅ ꠛꠣꠠꠍꠦ, ꠔꠦ ꠛꠥꠎꠛꠣ, ꠅꠃ ꠊꠞꠅ ꠘꠣꠙꠣꠇ-ꠚꠦꠃꠇꠘꠤ ꠛꠦꠝꠣꠞ ꠀꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠁ ꠊꠞ ꠈꠣꠘ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV14_45","004_14_45","LEV","14","45","45","ꠘꠣꠙꠣꠇ ꠅꠃ ꠊꠞꠞ ꠢꠇꠟ ꠙꠣꠔ꠆ꠔꠞ ꠛꠣ ꠁꠐ, ꠢꠇꠟ ꠀꠡ꠆ꠔꠞ, ꠊꠞꠞ ꠟꠣꠇꠠꠤ, ꠢꠇ꠆ꠇꠟꠔꠣ ꠜꠣꠋꠉꠤꠀ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠇꠥꠘꠥ ꠘꠣꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠘꠤꠀ ꠚꠣꠟꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV14_46","004_14_46","LEV","14","46","46","“ꠀꠞ ꠢꠃ ꠡꠣꠔ ꠖꠤꠘ ꠛꠘ꠆ꠖ ꠞꠣꠈꠣꠞ ꠇꠣꠟꠅ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠉꠤꠀ ꠁ ꠊꠞꠅ ꠢꠣꠝꠣꠄ, ꠔꠦ ꠢꠦ ꠅꠃ ꠖꠤꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV14_47","004_14_47","LEV","14","47","47","ꠀꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠅꠃ ꠊꠞꠅ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠄ ꠛꠣ ꠊꠥꠝꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV14_48","004_14_48","LEV","14","48","48","“ꠅꠁꠟꠦ ꠁ ꠊꠞ ꠀꠡ꠆ꠔꠞ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ, ꠅꠀꠟꠞ ꠖꠣꠉ ꠀꠞ ꠖꠦꠈꠣ ꠎꠣꠞ ꠘꠣ, ꠔꠦ ꠁꠝꠣꠝꠦ ꠁ ꠊꠞꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠁꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣ। ꠁ ꠊꠞꠅ ꠔ ꠘꠣꠙꠣꠇ-ꠚꠦꠃꠇꠘꠤ ꠛꠦꠝꠣꠞꠞ ꠇꠥꠘꠥ ꠀꠟꠣꠝꠔ ꠅꠈꠘ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LV14_49","004_14_49","LEV","14","49","49","ꠀꠞ ꠊꠞꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠖꠥꠁꠐꠣ ꠙꠣꠈꠤ, ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍꠞ ꠇꠤꠍꠥ ꠟꠣꠇꠠꠤ, ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠒꠦꠐꠣ, ꠀꠞ ꠟꠣꠟ ꠞꠋꠉꠞ ꠡꠥꠔꠣ ꠟꠁꠀ ꠅꠘꠅ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_50","004_14_50","LEV","14","50","50","ꠀꠁꠀ ꠚꠥꠔꠞ ꠙꠣꠘꠤ ꠕꠣꠇꠤ ꠀꠘꠣ ꠝꠣꠐꠤꠞ ꠉꠣꠝꠟꠣꠔ ꠕꠅꠀ ꠅꠃ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠄꠇꠐꠣ ꠙꠣꠈꠤꠞꠦ ꠎꠛ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_51","004_14_51","LEV","14","51","51","ꠀꠞ ꠖꠥꠍꠞꠣ ꠎꠤꠔꠣ ꠙꠣꠈꠤꠞꠦ, ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍꠞ ꠟꠣꠇꠠꠤꠞꠦ, ꠟꠣꠟ ꠡꠥꠔꠣ ꠀꠞ ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠒꠦꠐꠣꠞꠦ, ꠚꠥꠔꠞ ꠙꠣꠘꠤꠞ ꠉꠣꠝꠟꠣꠞ ꠃꠙꠞꠦ ꠎꠛ ꠇꠞꠣ ꠢꠃ ꠙꠣꠈꠤꠞ ꠟꠃꠞ ꠝꠣꠎꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠍꠥꠛꠣꠁꠛꠣ, ꠍꠥꠛꠣꠁꠀ ꠢꠣꠞꠤ ꠅꠃ ꠊꠞꠞ ꠝꠣꠎꠦ ꠡꠣꠔ ꠛꠣꠞ ꠍꠤꠐꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV14_52","004_14_52","LEV","14","52","52","ꠙꠣꠈꠤꠞ ꠟꠃ, ꠚꠥꠔꠞ ꠙꠣꠘꠤ, ꠎꠤꠔꠣ ꠙꠣꠈꠤ, ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍꠞ ꠟꠣꠇꠠꠤ, ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠒꠦꠐꠣ ꠀꠞ ꠟꠣꠟ ꠡꠥꠔꠣ ꠖꠤꠀ ꠅꠃ ꠊꠞꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV14_53","004_14_53","LEV","14","53","53","ꠄꠞꠛꠣꠖꠦ ꠅꠃ ꠎꠤꠔꠣ ꠙꠣꠈꠤꠞꠦ ꠘꠤꠀ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠈꠥꠟꠣ ꠎꠣꠉꠣꠔ ꠍꠣꠠꠤ ꠖꠤꠛꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠢꠃ ꠊꠞꠞ ꠘꠣꠙꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠁꠈꠣꠘ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LV14_54","004_14_54","LEV","14","54","54","ꠔꠦ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ, ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤ, ");
INSERT INTO syls_vpl VALUES ("LV14_55","004_14_55","LEV","14","55","55","ꠇꠣꠙꠠ ꠛꠣ ꠊꠞꠞ ꠅꠀꠟꠞ ꠚꠦꠃꠇꠘꠤꠞ ꠖꠣꠉ, ");
INSERT INTO syls_vpl VALUES ("LV14_56","004_14_56","LEV","14","56","56","ꠉꠔꠞꠞ ꠌꠣꠝꠠꠣꠔ ꠇꠥꠟꠡ ꠃꠑꠣ, ꠛꠞꠘ ꠛꠣ ꠇꠥꠘꠥ ꠎꠣꠔꠞ ꠖꠣꠉꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠥꠇꠥꠝ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LV14_57","004_14_57","LEV","14","57","57","ꠁꠔꠣ ꠛꠦꠝꠣꠞꠦ ꠇꠥꠘ ꠡꠝꠄ ꠙꠣꠇ, ꠀꠞ ꠇꠥꠘ ꠡꠝꠄ ꠘꠣꠙꠣꠇ, ꠅꠈꠣꠘ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠅꠃ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LV15_1","004_15_1","LEV","15","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV15_2","004_15_2","LEV","15","2","2","“ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠅ, ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠝꠣꠘꠡꠞ ꠙꠦꠡꠣꠛꠞ ꠞꠣꠡ꠆ꠔꠣꠄ ꠎꠥꠖꠤ ꠢꠣꠝꠦꠡꠣ ꠗꠣꠔꠥ ꠛꠣꠞ ꠅꠄ, ꠔꠦ ꠔꠣꠞ ꠡꠞꠤꠟ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV15_3","004_15_3","LEV","15","3","3","ꠔꠣꠞ ꠡꠞꠤꠟ ꠕꠣꠇꠤ ꠗꠣꠔꠥ ꠛꠣꠞꠘꠤꠔ ꠞꠁꠟꠦ ꠛꠣ ꠡꠞꠤꠟꠅ ꠀꠐꠇꠤ ꠞꠁꠟꠦꠅ ꠢꠦ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LV15_4","004_15_4","LEV","15","4","4","ꠅꠟꠣ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠢꠦ ꠎꠦ ꠛꠤꠍꠘꠣꠔ ꠢꠥꠔꠤꠛ, ꠛꠣ ꠎꠦ ꠎꠣꠉꠣꠔ ꠛꠁꠛ, ꠢꠃ ꠛꠤꠍꠘꠣ ꠀꠞ ꠢꠃ ꠎꠣꠉꠣꠅ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_5","004_15_5","LEV","15","5","5","ꠅꠃ ꠗꠣꠔꠥ ꠎꠣꠅꠞꠣ ꠘꠣꠙꠣꠇ ꠛꠦꠐꠣꠞ ꠛꠤꠍꠘꠣ ꠎꠦ ꠎꠘꠦ ꠍꠁꠛ, ꠢꠦ ꠘꠤꠎꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_6","004_15_6","LEV","15","6","6","ꠅꠟꠣꠈꠣꠘ ꠢꠃ ꠛꠦꠐꠣꠞ ꠛꠅꠀꠞ ꠎꠣꠉꠣꠔ ꠎꠦ ꠎꠘ ꠛꠁꠛ, ꠢꠦ-ꠅ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_7","004_15_7","LEV","15","7","7","ꠀꠞ ꠁ ꠗꠣꠔꠥ ꠎꠣꠅꠞꠣ ꠛꠦꠐꠣꠞꠦ ꠎꠦ ꠎꠘꠦ ꠍꠁꠛ ꠢꠦ-ꠅ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_8","004_15_8","LEV","15","8","8","ꠢꠃ ꠗꠣꠔꠥ ꠎꠣꠅꠞꠣ ꠛꠦꠐꠣꠄ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠙꠣꠇ-ꠍꠣꠚ ꠝꠣꠘꠡꠞ ꠉꠔꠞꠅ ꠍꠦꠚ ꠚꠣꠟꠣꠄ, ꠔꠦ ꠅꠃ ꠎꠘꠦꠅ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_9","004_15_9","LEV","15","9","9","ꠅꠃ ꠗꠣꠔꠥ ꠎꠣꠅꠞꠣ ꠛꠦꠐꠣꠄ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠎꠣꠁꠛꠣꠞ ꠇꠣꠟꠅ ꠉꠣꠠꠤ-ꠊꠥꠠꠣ ꠇꠥꠘꠥꠔꠣꠞ ꠍꠤꠐꠅ ꠛꠁꠀ ꠉꠦꠟꠦ, ꠁ ꠍꠤꠐ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_10","004_15_10","LEV","15","10","10","ꠅꠃ ꠍꠤꠐ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠍꠁꠟꠦ ꠢꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ꠅꠃ ꠍꠤꠐ ꠎꠦ ꠎꠘꠦ ꠔꠥꠟꠛ, ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_11","004_15_11","LEV","15","11","11","ꠅꠃ ꠗꠣꠔꠥ ꠎꠣꠅꠞꠣ ꠛꠦꠐꠣꠄ ꠙꠣꠘꠤꠖꠤ ꠀꠔ ꠘꠣ ꠗꠁꠀ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠎꠣꠞꠦ ꠍꠁꠛ, ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_12","004_15_12","LEV","15","12","12","ꠀꠞ ꠗꠣꠔꠥ ꠎꠣꠅꠞꠣ ꠛꠦꠐꠣꠄ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠐꠤꠞ ꠛꠣꠡꠘ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠁꠔꠣ ꠜꠣꠋꠉꠤꠟꠤꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠍꠁꠟꠦ, ꠁꠔꠣ ꠙꠣꠘꠤꠖꠤ ꠗꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_13","004_15_13","LEV","15","13","13","“ꠢꠃ ꠗꠣꠔꠥ ꠎꠣꠅꠞꠣ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣꠞ ꠛꠦꠝꠣꠞ ꠎꠦ ꠖꠤꠘ ꠇꠝꠤꠎꠤꠛ, ꠅꠃ ꠖꠤꠘ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠚꠥꠔꠞ ꠙꠣꠘꠤꠔ ꠘꠣꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_14","004_15_14","LEV","15","14","14","ꠛꠣꠖꠦ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠢꠦ ꠖꠥꠁꠐꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠛꠣ ꠖꠥꠉꠥ ꠙꠣꠞꠅ ꠟꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠀꠎꠤꠞ ꠅꠁꠀ, ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠀꠔꠅ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_15","004_15_15","LEV","15","15","15","ꠁꠝꠣꠝꠦ ꠢꠃ ꠖꠥꠁꠐꠣꠞ ꠄꠉꠥꠞꠦ ꠖꠤꠀ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠖꠥꠍꠞꠣꠐꠣ ꠖꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ꠗꠣꠔꠥ ꠎꠣꠅꠞꠣ ꠛꠦꠐꠣꠞ ꠘꠣꠙꠣꠇꠤ ꠢꠞꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ, ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV15_16","004_15_16","LEV","15","16","16","“ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠝꠣꠘꠡꠞ ꠎꠃꠛꠘꠞ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠉꠦꠟꠦ ꠢꠦ ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠞꠦ ꠙꠣꠘꠤꠖꠤ ꠗꠁꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_17","004_15_17","LEV","15","17","17","ꠅꠃ ꠎꠃꠛꠘꠞ ꠙꠣꠘꠤ ꠇꠥꠘꠥ ꠇꠣꠙꠠ ꠛꠣ ꠌꠣꠝꠠꠣꠞ ꠎꠤꠘꠤꠡꠅ ꠟꠣꠉꠤꠉꠦꠟꠦ, ꠁꠔꠣ ꠙꠣꠘꠤꠖꠤ ꠗꠁꠔꠦ ꠅꠁꠛ, ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_18","004_15_18","LEV","15","18","18","ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠔꠣꠞ ꠛꠃꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣꠞ ꠇꠣꠟꠅ ꠎꠃꠛꠘꠞ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠟꠦ, ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠔꠦ ꠅꠁꠛ, ꠖꠥꠁꠅꠎꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_19","004_15_19","LEV","15","19","19","“ꠇꠥꠘꠥ ꠛꠦꠐꠤꠞ ꠝꠣꠡꠤꠇ ꠛꠦꠝꠣꠞꠞ ꠟꠃ ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠔꠣꠁ ꠡꠣꠔ ꠖꠤꠘ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ꠅꠃ ꠡꠝꠄ ꠁ ꠛꠦꠐꠤꠞꠦ ꠎꠦ ꠎꠘꠦ ꠍꠁꠛ, ꠢꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_20","004_15_20","LEV","15","20","20","ꠅꠃ ꠛꠦꠐꠤꠀꠞꠣ ꠛꠦꠝꠣꠞꠞ ꠡꠝꠄ ꠔꠣꠁ ꠎꠦꠔꠣꠞ ꠃꠙꠞꠦ ꠛꠁꠛ ꠛꠣ ꠢꠥꠔꠤꠛ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_21","004_15_21","LEV","15","21","21","ꠔꠣꠁꠞ ꠛꠤꠍꠘꠣ ꠎꠦ ꠎꠘꠦ ꠍꠁꠛ, ꠢꠦ-ꠅ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_22","004_15_22","LEV","15","22","22","ꠅꠃ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠤ ꠎꠦꠔꠣꠞ ꠃꠙꠞꠦ ꠛꠁꠍꠦ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠇꠦꠃ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠢꠦ-ꠅ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_23","004_15_23","LEV","15","23","23","ꠔꠣꠁꠞ ꠛꠤꠍꠘꠣ ꠛꠣ ꠌꠦꠀꠞꠅ ꠇꠦꠃ ꠍꠁꠟꠦ, ꠛꠣ ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠕꠅꠀ ꠇꠥꠘ꠆ꠔꠣ ꠍꠁꠟꠦꠅ, ꠢꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_24","004_15_24","LEV","15","24","24","ꠛꠦꠐꠤꠀꠞꠣ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠤꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡ ꠎꠥꠖꠤ ꠢꠥꠔꠦ, ꠀꠞ ꠔꠣꠁꠞ ꠝꠣꠡꠤꠇꠞ ꠟꠃ ꠔꠣꠞ ꠡꠞꠤꠟꠅ ꠟꠣꠉꠦ, ꠔꠦ ꠅꠃ ꠛꠦꠐꠣꠅ ꠡꠣꠔ ꠖꠤꠘ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ꠅꠃ ꠡꠣꠔ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠢꠦ ꠎꠦ ꠛꠤꠍꠘꠣꠔ ꠢꠥꠔꠤꠛ, ꠁꠔꠣꠅ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_25","004_15_25","LEV","15","25","25","“ꠇꠥꠘꠥ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞ ꠎꠥꠖꠤ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠟꠃ ꠎꠣꠅꠀꠔ ꠞꠄ, ꠝꠣꠡꠤꠇ ꠛꠦꠝꠣꠞꠞ ꠡꠣꠔ ꠖꠤꠘ ꠙꠣꠞꠘꠤꠞ ꠛꠣꠖꠦꠅ ꠎꠥꠖꠤ ꠟꠃ ꠎꠣꠅꠀꠔ ꠞꠄ, ꠔꠦ ꠎꠔꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠟꠣ ꠟꠃ ꠎꠣꠁꠛ, ꠅꠔꠖꠤꠘ ꠔꠣꠁ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_26","004_15_26","LEV","15","26","26","ꠛꠦꠐꠤꠀꠞꠣ ꠝꠣꠡꠤꠇ ꠛꠦꠝꠣꠞꠞ ꠟꠣꠈꠣꠘ ꠅꠃ ꠟꠃ ꠎꠣꠁꠛꠣꠞ ꠡꠝꠄ ꠔꠣꠁ ꠎꠦꠔꠣꠔ ꠢꠥꠔꠤꠛ ꠛꠣ ꠛꠁꠛ, ꠁꠔꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_27","004_15_27","LEV","15","27","27","ꠁ ꠛꠤꠍꠘꠣ ꠛꠣ ꠌꠦꠀꠞ ꠎꠦ ꠎꠘꠦ ꠍꠁꠛ, ꠢꠦ-ꠅ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠛ, ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_28","004_15_28","LEV","15","28","28","ꠅꠃ ꠛꠦꠐꠤꠞ ꠟꠃ ꠎꠣꠅꠀ ꠛꠘ꠆ꠖ ꠅꠀꠞ ꠛꠣꠖꠦꠅ, ꠔꠣꠁ ꠉꠘꠤꠀ ꠀꠞꠅ ꠡꠣꠔ ꠖꠤꠘ ꠛꠣꠞ ꠌꠣꠁꠔꠦ ꠅꠁꠛ, ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_29","004_15_29","LEV","15","29","29","ꠀꠞ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠁ ꠖꠥꠁꠐꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠛꠣ ꠙꠣꠞꠅ ꠟꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠗꠣꠞꠅ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV15_30","004_15_30","LEV","15","30","30","ꠁꠝꠣꠝꠦ ꠢꠃ ꠖꠥꠁꠅ ꠙꠣꠈꠤꠞ ꠝꠣꠎꠞ ꠄꠉꠥꠖꠤ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠖꠥꠍꠞꠣꠐꠣ ꠖꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠁꠝꠣꠝꠦ ꠔꠣꠁꠞ ꠟꠃ ꠎꠣꠁꠛꠣꠞ ꠘꠣꠙꠣꠇꠤ ꠢꠞꠣꠘꠤꠞ ꠇꠚꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV15_31","004_15_31","LEV","15","31","31","“ꠅ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ, ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠞꠦ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠣꠙꠣꠇꠤ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠅ, ꠀꠞꠘꠣꠄ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠞꠅꠀ ꠀꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠛꠡꠔ ꠈꠣꠘꠣꠞꠦ ꠎꠥꠖꠤ ꠔꠣꠞꠣ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠘ, ꠔꠦ ꠅꠃ ꠘꠣꠙꠣꠇꠤꠞ ꠖꠣꠄ ꠔ ꠔꠣꠞꠣꠞ ꠝꠞꠘ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LV15_32","004_15_32","LEV","15","32","33","ꠔꠦ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠗꠣꠔꠥ ꠎꠣꠅꠀ ꠛꠦꠝꠣꠞ, ꠎꠃꠛꠘꠞ ꠙꠣꠘꠤ ꠛꠣꠞꠘꠤ, ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠡꠤꠇ ꠛꠦꠝꠣꠞ, ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠎꠦꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠗꠣꠔꠥ ꠎꠣꠅꠀ, ꠘꠣꠙꠣꠇ ꠛꠃꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ, ꠁꠔꠣ ꠎꠦꠇꠥꠘꠥ ꠎꠘꠞ ꠟꠣꠉꠤ ꠅꠃ ꠘꠤꠅꠝ ꠎꠣꠞꠤ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LV16_1","004_16_1","LEV","16","1","1","ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠛꠠ ꠖꠥꠁ ꠙꠥꠀꠄ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠙꠠꠤꠀ ꠝꠣꠞꠣ ꠉꠦꠟ ꠇꠞꠤ, ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV16_2","004_16_2","LEV","16","2","2","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠅ, ꠢꠦ ꠎꠣꠘꠥ ꠎꠦꠛꠟꠣ ꠝꠘꠦ ꠌꠣꠄ ꠄꠛꠟꠣ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣꠞ ꠜꠤꠔꠞꠦ ꠘꠣ ꠢꠣꠝꠣꠄ, ꠀꠞꠘꠣꠄ ꠢꠦ ꠝꠞꠛꠃ। ꠎꠣꠘ ꠔ, ꠅꠃ ꠓꠣꠇꠘꠣꠞ ꠃꠙꠞꠞ ꠗꠥꠝꠣꠞ ꠀꠘ꠆ꠖꠣꠁꠞꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠘꠤꠎꠦ ꠀꠎꠤꠞ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("LV16_3","004_16_3","LEV","16","3","3","“ꠁꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠀꠉꠦ ꠢꠦ ꠎꠣꠘꠥ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠟꠁꠀ ꠁꠘꠅ ꠀꠁꠀ ꠢꠣꠝꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV16_4","004_16_4","LEV","16","4","4","ꠡꠣꠖꠣ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠙꠛꠤꠔ꠆ꠞ ꠀꠟꠈꠦꠟ꠆ꠟꠣ ꠀꠞ ꠢꠣꠚ-ꠙꠦꠘ꠆ꠐꠞ ꠟꠣꠈꠣꠘ ꠎꠣꠋꠉꠤꠀ ꠚꠤꠘ꠆ꠖꠤꠀ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠛ। ꠔꠣꠞ ꠇꠝꠞꠅ ꠛꠣꠘ꠆ꠖꠣꠞ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠞ ꠛꠘ꠆ꠖꠘꠤ ꠛꠣꠘ꠆ꠖꠤꠛ ꠀꠞ ꠝꠣꠕꠣꠔ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠞ ꠙꠣꠃꠉꠠꠤ ꠟꠣꠉꠣꠁꠛ। ꠁꠔꠣ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ, ꠁꠔꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠛꠣꠞ ꠀꠉꠦ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_5","004_16_5","LEV","16","5","5","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠁꠐꠣ ꠙꠣꠑꠣ ꠍꠣꠉꠟ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠝꠦꠠꠣꠞ ꠙꠣꠑꠣ ꠘꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_6","004_16_6","LEV","16","6","6","ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠀꠞ ꠔꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠛꠤꠍꠣꠟꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_7","004_16_7","LEV","16","7","7","ꠛꠣꠖꠦ ꠢꠃ ꠍꠣꠉꠟ ꠖꠥꠁꠅꠐꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_8","004_16_8","LEV","16","8","8","ꠀꠘꠤꠀ ꠢꠦ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠖꠦꠈꠛ, ꠇꠥꠘ ꠍꠣꠉꠟ ꠝꠣꠛꠥꠖꠞ ꠟꠣꠉꠤ ꠀꠞ ꠇꠥꠘꠐꠣ ꠀꠎꠣꠎꠤꠟꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LV16_9","004_16_9","LEV","16","9","9","ꠟꠐꠣꠞꠤꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠦ ꠍꠣꠉꠟ ꠃꠑꠛ, ꠢꠣꠞꠥꠘꠦ ꠅꠉꠥꠖꠤ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_10","004_16_10","LEV","16","10","10","ꠀꠞ ꠀꠎꠣꠎꠤꠟꠞ ꠘꠣꠝꠦ ꠎꠦ ꠍꠣꠉꠟ ꠃꠑꠛ, ꠅꠉꠥꠞꠦ ꠎꠤꠔꠣ ꠢꠣꠟꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠛ, ꠎꠣꠔꠦ ꠛꠣꠖꠦ ꠅꠉꠥꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠘꠤꠀ ꠀꠎꠣꠎꠤꠟꠞ ꠘꠣꠝꠦ ꠀꠃꠞꠤ ꠍꠣꠠꠤ ꠖꠦꠅꠀ ꠅꠄ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV16_11","004_16_11","LEV","16","11","11","“ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠀꠞ ꠔꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠞ ꠘꠤꠎꠞ ꠀꠘꠣ ꠢꠃ ꠛꠤꠍꠣꠟꠞꠦ ꠎꠛ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_12","004_16_12","LEV","16","12","12","ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠎꠦ ꠐꠦꠛꠥꠟ ꠀꠍꠦ ꠅꠃ ꠐꠦꠛꠥꠟ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠎꠣꠟꠣꠁꠟ ꠀꠋꠞꠣ ꠟꠁꠀ ꠢꠦ ꠀꠉꠞ ꠖꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠜꠞꠛ, ꠀꠞ ꠖꠥꠁ ꠝꠥꠁꠐ ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠞ ꠉꠥꠠꠣꠅ ꠟꠁꠛ, ꠛꠣꠖꠦ ꠙꠞ꠆ꠖꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_13","004_16_13","LEV","16","13","13","ꠢꠣꠝꠣꠁꠀ ꠅꠃ ꠀꠋꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠖꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠟꠣꠁꠛ, ꠔꠦꠃ ꠅꠔꠣꠞ ꠗꠥꠝꠣꠄ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣꠞ ꠃꠙꠞꠞ ꠉꠣꠟꠣ ꠀꠘ꠆ꠖꠣꠁꠞꠦ ꠉꠥꠞꠤꠎꠤꠛ, ꠎꠣꠔꠦ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠘꠣ ꠝꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LV16_14","004_16_14","LEV","16","14","14","ꠛꠣꠖꠦ ꠢꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠢꠃ ꠛꠤꠍꠣꠟꠞ ꠕꠥꠠꠣ ꠟꠃ ꠘꠤꠀ ꠀꠔꠞ ꠀꠋꠉꠥꠁꠟ ꠖꠤꠀ ꠅꠃ ꠓꠣꠇꠘꠣꠞ ꠍꠣꠝꠘꠞ ꠉꠣꠟꠣꠛꠣꠄ ꠍꠤꠐꠣꠁ ꠖꠤꠛ। ꠄꠞꠛꠣꠖꠦ ꠀꠋꠉꠥꠟꠤꠞ ꠝꠣꠎꠦ ꠀꠞꠅ ꠕꠥꠠꠣ ꠟꠃ ꠟꠣꠉꠣꠁꠀ ꠓꠣꠇꠘꠣꠞ ꠍꠣꠝꠘꠞ ꠛꠣꠄ ꠡꠣꠔ ꠛꠣꠞ ꠍꠤꠐꠣꠁꠀ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_15","004_16_15","LEV","16","15","15","“ꠀꠞ ꠢꠦ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠘꠣ ꠍꠣꠉꠟꠐꠣꠞꠦ ꠎꠛ ꠇꠞꠛ, ꠇꠞꠤꠀ ꠅꠉꠥꠞ ꠟꠃ ꠘꠤꠀ ꠙꠞ꠆ꠖꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠉꠤꠀ, ꠛꠤꠍꠣꠟꠞ ꠟꠃꠖꠤ ꠎꠦꠟꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠅꠉꠥꠞ ꠟꠃꠖꠤꠅ ꠅꠟꠣ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣꠞ ꠃꠙꠞꠦ ꠀꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠟꠃ ꠍꠤꠐꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_16","004_16_16","LEV","16","16","16","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠥꠘꠣ, ꠘꠣꠙꠣꠇꠤ, ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠄ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞꠦꠅ ꠘꠣꠙꠣꠇ ꠇꠞꠤꠟꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠀꠍꠦ, ꠅꠈꠣꠘꠞ ꠘꠣꠙꠣꠇꠤ ꠢꠞꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV16_17","004_16_17","LEV","16","17","17","ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠢꠣꠞꠤ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠘ ꠘꠤꠎꠞ, ꠔꠣꠘ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠡꠝꠣꠎꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠤꠀ ꠎꠔꠛꠤꠟ ꠘꠣ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠘ, ꠅꠔꠛꠤꠟ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠘꠤ ꠘꠤꠡꠦꠗ। ");
INSERT INTO syls_vpl VALUES ("LV16_18","004_16_18","LEV","16","18","18","ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠥꠘꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠎꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ ꠀꠍꠦ ꠅꠃ ꠐꠦꠛꠥꠟꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠁꠛꠣ, ꠎꠣꠁꠀ ꠐꠦꠛꠥꠟꠞ ꠟꠣꠉꠤꠅ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ꠢꠃ ꠛꠤꠍꠣꠟ ꠀꠞ ꠍꠣꠉꠟꠞ ꠕꠥꠠꠣ ꠟꠃ ꠘꠤꠀ ꠔꠣꠁꠘ ꠅꠃ ꠐꠦꠛꠥꠟꠞ ꠢꠤꠋꠉꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV16_19","004_16_19","LEV","16","19","19","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠥꠘꠣꠞ ꠇꠣꠞꠘꠦ ꠐꠦꠛꠥꠟꠞ ꠝꠣꠎꠦ ꠎꠦ ꠘꠣꠙꠣꠇꠤ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠍꠦ, ꠢꠃ ꠘꠣꠙꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠅꠃ ꠐꠦꠛꠥꠟꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞ ꠀꠔꠞ ꠀꠋꠉꠥꠁꠟ ꠖꠤꠀ ꠅꠃ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠡꠣꠔ ꠛꠣꠞ ꠟꠃ ꠍꠤꠐꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_20","004_16_20","LEV","16","20","20","“ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ, ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠘꠣꠙꠣꠇꠤ ꠢꠞꠣꠘꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠣꠞꠥꠘꠦ ꠀꠎꠣꠎꠤꠟꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠃ ꠎꠤꠔꠣ ꠍꠣꠉꠟꠞꠦ ꠟꠁꠀ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV16_21","004_16_21","LEV","16","21","21","ꠀꠁꠀ ꠅꠃ ꠍꠣꠉꠟꠞ ꠇꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠞ ꠖꠥꠁꠅ ꠀꠔ ꠕꠁꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠉꠥꠘꠣ-ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠛꠖ ꠇꠣꠝꠞ ꠇꠕꠣ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤꠀ ꠍꠣꠉꠟꠞ ꠇꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠅꠔꠣ ꠛꠞ꠆ꠔꠣꠁ ꠖꠤꠛ। ꠛꠣꠖꠦ ꠀꠉ ꠕꠣꠇꠤ ꠎꠥꠁꠔ ꠅꠀ ꠄꠇ ꠛꠦꠐꠣꠞꠦ ꠖꠤꠀ ꠅꠃ ꠍꠣꠉꠟꠞꠦ ꠢꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_22","004_16_22","LEV","16","22","22","ꠢꠃ ꠛꠦꠐꠣꠄ ꠘꠤꠀ ꠅꠉꠥꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠍꠣꠠꠤꠀ ꠀꠁꠛ। ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠅꠃ ꠍꠣꠉꠟꠦ ꠟꠁꠀ ꠘꠤꠞꠣꠁ ꠘꠤꠞ꠆ꠎꠘ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠎꠤꠛꠘ ꠊꠥꠞꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_23","004_16_23","LEV","16","23","23","“ꠀꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠁꠛꠣꠞ ꠇꠣꠟꠅ ꠢꠣꠞꠥꠘꠦ ꠡꠣꠖꠣ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠞ ꠎꠔ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠍꠟꠣ, ꠔꠣꠁꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠔ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠁꠔꠣ ꠈꠥꠟꠤꠀ ꠕꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV16_24","004_16_24","LEV","16","24","24","ꠈꠥꠟꠤꠀ ꠔꠣꠁꠘ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠜꠤꠔꠞꠦ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠛꠣ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠛꠣꠞꠦ ꠀꠁꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠇꠞꠤ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠀ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠞ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠅ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV16_25","004_16_25","LEV","16","25","25","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠌꠞ꠆ꠛꠤꠞꠦ ꠔꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV16_26","004_16_26","LEV","16","26","26","ꠎꠦ ꠛꠦꠐꠣꠄ ꠀꠎꠣꠎꠤꠟꠞ ꠘꠣꠝꠞ ꠍꠣꠉꠟꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠍꠣꠠꠤꠀ ꠀꠁꠛ, ꠢꠦ-ꠅ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠘꠤ ꠖꠤꠀ ꠘꠣꠁꠀ ꠛꠣꠖꠦ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_27","004_16_27","LEV","16","27","27","ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠦ ꠛꠤꠍꠣꠟ ꠀꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠦ ꠍꠣꠉꠟꠞ ꠟꠃꠞꠦ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠘꠤꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠔꠣꠞ ꠢꠇꠟ ꠉꠥꠡ꠆ꠔ, ꠈꠣꠟ, ꠉꠥꠚꠞ ꠀꠞ ꠢꠇꠟꠔꠣꠞꠦ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠄꠇꠎꠘꠦ ꠎꠣꠟꠣꠁꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV16_28","004_16_28","LEV","16","28","28","ꠎꠦ ꠎꠘꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠣꠞꠦ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠛ, ꠢꠦ-ꠅ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ, ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠀ ꠢꠣꠞꠤ ꠛꠣꠖꠦ ꠀꠁꠀ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_29","004_16_29","LEV","16","29","29","“ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠁꠞꠣꠝ, ꠁꠔꠣ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠘꠤꠅꠝ। ꠙꠞꠔꠦꠇ ꠛꠍꠞꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠖꠡ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ, ꠔꠥꠝꠞꠣꠞ ꠙꠞꠔꠦꠇ ꠎꠘꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠀꠞ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞ ꠛꠣꠖ ꠖꠤꠀ, ꠘꠔ ꠅꠁꠀ ꠖꠤꠟ ꠡꠙꠤꠀ ꠖꠤꠛꠣꠄ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠢꠇꠟ ꠎꠘꠦ ꠁꠔꠣ ꠝꠣꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_30","004_16_30","LEV","16","30","30","ꠇꠣꠞꠘ ꠅꠃꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠛ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV16_31","004_16_31","LEV","16","31","31","ꠅꠃꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠛꠣꠖ ꠖꠤꠀ ꠀꠞꠣꠝ ꠇꠞꠛꠣꠄ, ꠙꠞꠔꠦꠇꠦ ꠘꠔ ꠅꠁꠀ ꠎꠣꠞꠎꠤꠞ ꠖꠤꠟ ꠡꠙꠤꠀ ꠖꠤꠛꠣꠄ। ꠁꠐꠣ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠘꠤꠅꠝ। ");
INSERT INTO syls_vpl VALUES ("LV16_32","004_16_32","LEV","16","32","32","ꠎꠦꠇꠥꠘꠥ ꠁꠝꠣꠝꠞꠦ ꠎꠦꠛꠟꠣ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠞ ꠛꠣꠚꠞ ꠎꠣꠉꠣꠔ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠣꠁꠀ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠅꠁꠛ, ꠢꠦ-ꠅ ꠅꠟꠣ ꠡꠣꠖꠣ ꠡꠥꠔꠤ ꠇꠣꠙꠠꠞ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠀ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_33","004_16_33","LEV","16","33","33","ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚ, ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ, ꠛꠣꠇꠤ ꠁꠝꠣꠝ ꠅꠇꠟ, ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV16_34","004_16_34","LEV","16","34","34","ꠁꠐꠣ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠘꠤꠅꠝ। ꠙꠞꠔꠦꠇ ꠛꠍꠞ ꠄꠇꠛꠣꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠅꠟꠣ ꠀꠖꠣꠄ ꠇꠞꠔꠦ ꠅꠁꠛ।” ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠇꠟꠔꠣ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LV17_1","004_17_1","LEV","17","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV17_2","004_17_2","LEV","17","2","2","“ꠀꠝꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠈꠣꠘ ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞꠦ, ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠀꠞ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ। ꠔꠣꠞꠣꠞꠦ ꠇꠅ, ");
INSERT INTO syls_vpl VALUES ("LV17_3","004_17_3","LEV","17","3","3","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠉꠞꠥ, ꠍꠣꠉꠟ ꠛꠣ ꠝꠦꠠꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠛꠡꠔ ꠔꠣꠝ꠆ꠛꠥ ꠄꠟꠣꠇꠣꠔ ꠛꠣ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠎꠦ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠇꠥꠞꠛꠣꠘꠤ ꠘꠤꠅꠔꠦ ꠎꠛ ꠇꠞꠤꠟꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV17_4","004_17_4","LEV","17","4","4","ꠅꠃ ꠙꠡꠥꠞꠦ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠍꠣꠝꠘꠦ, ꠝꠣꠘꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠎꠛ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠅꠃ ꠙꠡꠥꠞ ꠈꠥꠘꠞ ꠖꠣꠄꠁ ꠅꠁꠛ, ꠄꠞꠟꠣꠉꠤ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV17_5","004_17_5","LEV","17","5","5","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠈꠘ ꠉꠣꠃ-ꠉꠦꠞꠣꠝꠞ ꠈꠥꠟꠣ ꠎꠣꠉꠣꠔ ꠎꠦꠔꠣ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠁꠘ, ꠅꠃ ꠙꠡꠥ ꠎꠣꠘꠥ ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠀꠘꠦ। ꠀꠘꠤꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁꠀ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠁꠔꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV17_6","004_17_6","LEV","17","6","6","ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠙꠡꠥ ꠎꠛ ꠇꠞꠤꠀ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠎꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠍꠦ, ꠢꠘꠅ ꠅꠉꠥꠞ ꠟꠃ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ, ꠀꠞ ꠙꠡꠥꠞ ꠌꠞ꠆ꠛꠤꠞꠦ ꠔꠣꠁꠘ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠎꠣꠟꠣꠁꠟꠤꠛꠣ, ꠅꠃ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV17_7","004_17_7","LEV","17","7","7","ꠈꠛꠞꠖꠣꠞ! ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠝꠣꠛꠥꠖꠞ ꠟꠉꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠍꠣꠉꠟꠞꠥꠙꠤ ꠖꠦꠅ-ꠜꠥꠔꠞ ꠘꠣꠝꠦ ꠀꠁꠎ ꠕꠣꠇꠤ ꠀꠞ ꠇꠥꠘꠥ ꠙꠡꠥ ꠛꠟꠤ ꠘꠣ ꠖꠦꠄ। ꠅꠃ ꠢꠥꠇꠥꠝ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠎꠣꠞꠤ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV17_8","004_17_8","LEV","17","8","8","“ꠀꠞ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠥꠘꠥ ꠎꠘ ꠛꠣ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠇꠥꠘꠥ ꠜꠤꠘ-ꠖꠦꠡꠤꠄ ꠎꠥꠖꠤ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠛꠣ ꠎꠦꠇꠥꠘꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("LV17_9","004_17_9","LEV","17","9","9","ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠙꠡꠥꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠡꠙꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠘꠣ ꠀꠘꠦ, ꠔꠦ ꠁ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("LV17_10","004_17_10","LEV","17","10","10","“ꠔꠥꠝꠤ ꠀꠞꠅ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠇꠥꠘꠥ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠛꠣ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠇꠥꠘꠥ ꠜꠤꠘ-ꠖꠦꠡꠤꠄ ꠎꠥꠖꠤ ꠇꠥꠘꠥꠎꠣꠔ ꠟꠃ ꠈꠣꠄ, ꠔꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠎꠤꠝꠥ, ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV17_11","004_17_11","LEV","17","11","11","ꠟꠃꠞ ꠝꠣꠎꠦꠃ ꠔ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠎꠣꠘ ꠕꠣꠇꠦ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠍꠤꠐꠣꠁꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠍꠤ। ꠟꠃꠞ ꠝꠣꠎꠦ ꠎꠣꠘ ꠀꠍꠦ ꠇꠞꠤꠃ ꠟꠃꠞ ꠛꠖꠟꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LV17_12","004_17_12","LEV","17","12","12","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠀꠞ, ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠇꠥꠘꠥ ꠜꠤꠘ-ꠖꠦꠡꠤꠄꠅ ꠎꠣꠘꠥ ꠟꠃ ꠘꠣ ꠈꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV17_13","004_17_13","LEV","17","13","13","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠦꠇꠥꠘꠥ ꠎꠘꠦ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠇꠥꠘꠥ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ, ꠡꠤꠇꠣꠞꠅ ꠉꠤꠀ ꠢꠣꠟꠣꠟ ꠇꠥꠘꠥ ꠙꠡꠥ ꠛꠣ ꠙꠣꠈꠤ ꠡꠤꠇꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠦ, ꠔꠦ ꠅꠉꠥꠞ ꠟꠃ ꠛꠣꠞ ꠇꠞꠤꠀ ꠝꠣꠐꠤꠔ ꠉꠣꠠꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV17_14","004_17_14","LEV","17","14","14","ꠎꠣꠘ ꠔ, ꠎꠤꠘ꠆ꠖꠣ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠟꠃꠞ ꠝꠣꠎꠦꠃ ꠔꠣꠞ ꠎꠣꠘ ꠕꠣꠇꠦ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠀꠞ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠇꠥꠘꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠟꠃ ꠘꠣ ꠈꠣꠄ, ꠟꠃ ꠅꠁꠟ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠎꠣꠘ। ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠟꠃ ꠈꠣꠁꠛ, ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV17_15","004_17_15","LEV","17","15","15","“ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠞꠣ ꠙꠡꠥꠞ ꠛꠣ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠝꠣꠞꠣ ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠟꠣꠄ, ꠔꠦ ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠃꠇ, ꠛꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠃꠇ, ꠢꠦ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠖꠤꠀ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠔꠦ ꠅꠁꠛ। ꠔꠣ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛ, ꠄꠞꠛꠣꠖꠦ ꠢꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LV17_16","004_17_16","LEV","17","16","16","ꠅꠁꠟꠦ ꠢꠦ ꠎꠥꠖꠤ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠘꠣ ꠖꠦꠄ ꠀꠞ ꠙꠣꠘꠤꠖꠤ ꠘꠣ ꠘꠣꠄ, ꠔꠦ ꠁ ꠇꠍꠥꠞꠤꠞ ꠟꠣꠉꠤ ꠢꠦ ꠖꠣꠄꠁ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LV18_1","004_18_1","LEV","18","1","1","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV18_2","004_18_2","LEV","18","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV18_3","004_18_3","LEV","18","3","3","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠎꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠛꠡꠔ ꠇꠞꠔꠣꠄ, ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠇꠞꠦ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠞ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠘꠤꠞꠣꠝ, ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ, ꠢꠘꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠇꠞꠦ ꠁꠔꠣꠅ ꠔꠥꠝꠞꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠣꠞꠣ ꠎꠦꠟꠣ ꠌꠟꠦ, ꠔꠥꠝꠞꠣ ꠁꠟꠣ ꠌꠟꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV18_4","004_18_4","LEV","18","4","4","ꠛꠞꠋ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠛꠣꠄ। ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠛꠣꠄ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV18_5","004_18_5","LEV","18","5","5","ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠞ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠔꠥꠝꠞꠣ ꠀꠝꠟ ꠇꠞꠛꠣꠄ, ꠎꠦ ꠎꠘꠦ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠦ ꠢꠦ ꠄꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠛ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV18_6","004_18_6","LEV","18","6","6","“ꠀꠙꠘ ꠟꠃꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠛꠣ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠣꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV18_7","004_18_7","LEV","18","7","7","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠎꠣꠘꠥ ꠘꠤꠎꠞ ꠝꠣʼꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠤꠀ ꠔꠣꠞ ꠛꠣꠚꠞ ꠝꠣꠘ-ꠁꠎ꠆ꠎꠔ ꠘꠣ ꠟꠥꠐꠦ। ꠄꠁꠘ ꠔ ꠔꠣꠞ ꠝꠣ, ꠄꠘ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV18_8","004_18_8","LEV","18","8","8","ꠢꠣꠔꠘ ꠝꠣʼꠞ ꠟꠉꠦꠅ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠀꠞꠘꠣꠄ ꠛꠣꠚꠞ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV18_9","004_18_9","LEV","18","9","9","ꠘꠤꠎꠞ ꠛꠁꠘ ꠛꠣ ꠢꠣꠔꠘ ꠛꠁꠘꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣꠅ ꠢꠣꠞꠣꠝ, ꠀꠙꠘ ꠛꠣꠚꠞ ꠔꠞꠚꠣ ꠛꠁꠘ ꠛꠣ ꠝꠣʼꠞ ꠔꠞꠚꠣ ꠛꠁꠘ ꠅꠁꠟꠦꠅ ꠢꠣꠞꠣꠝ। ꠔꠣꠞꠣ ꠄꠇ ꠛꠣꠠꠤꠔ ꠎꠘꠝ ꠅꠃꠇ ꠛꠣ ꠀꠟꠣꠖꠣ ꠛꠣꠠꠤꠔ ꠎꠘꠝ ꠅꠁꠟꠦꠅ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV18_10","004_18_10","LEV","18","10","10","ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤꠞ ꠊꠞꠞ ꠘꠣꠔꠤꠘꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠁꠔꠣꠄ ꠔ ꠘꠤꠎꠞ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LV18_11","004_18_11","LEV","18","11","11","ꠢꠣꠔꠘ ꠝꠣʼꠞ ꠊꠞꠞ ꠛꠁꠘꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠔꠣꠁ ꠔ ꠛꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV18_12","004_18_12","LEV","18","12","12","ꠀꠙꠘ ꠚꠥꠚꠥꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠄꠁꠘ ꠔ ꠛꠣꠚꠞ ꠟꠃꠞ ꠇꠥꠐꠥꠝ। ");
INSERT INTO syls_vpl VALUES ("LV18_13","004_18_13","LEV","18","13","13","ꠀꠙꠘ ꠝꠁꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠄꠁꠘ ꠔ ꠝꠣʼꠞ ꠟꠃꠞ ꠇꠥꠐꠥꠝ। ");
INSERT INTO syls_vpl VALUES ("LV18_14","004_18_14","LEV","18","14","14","ꠀꠙꠘ ꠌꠣꠌꠣꠞ ꠝꠣꠘ-ꠁꠎ꠆ꠎꠔ ꠟꠥꠐꠤꠀ ꠔꠣꠘ ꠛꠃꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠄꠁꠘ ꠔ ꠌꠣꠌꠤ। ");
INSERT INTO syls_vpl VALUES ("LV18_15","004_18_15","LEV","18","15","15","ꠀꠙꠘ ꠙꠥꠀꠞ ꠛꠃꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠔꠣꠁ ꠔ ꠘꠤꠎꠞ ꠛꠃꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("LV18_16","004_18_16","LEV","18","16","16","ꠜꠣꠁꠞ ꠛꠃꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠀꠞꠘꠣꠄ ꠜꠣꠁꠞ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV18_17","004_18_17","LEV","18","17","17","ꠇꠥꠘꠥ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠁꠞ ꠙꠥꠠꠤꠞ ꠟꠉꠦ, ꠔꠣꠁꠞ ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤꠞ ꠊꠞꠞ ꠘꠣꠔꠤꠘꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠄꠞꠣ ꠔ ꠔꠣꠁꠞ ꠟꠃꠞ ꠇꠥꠐꠥꠝ, ꠁꠔꠣ ꠛꠠ ꠈꠛꠤꠍꠤ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV18_18","004_18_18","LEV","18","18","18","ꠀꠞ ꠛꠃ ꠎꠤꠔꠣ ꠕꠣꠇꠣ ꠢꠣꠟꠔꠦ ꠢꠣꠟꠤ ꠛꠣ ꠎꠦꠑꠣꠟꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠢꠔꠤꠀꠟꠣ ꠇꠞꠣꠅ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV18_19","004_18_19","LEV","18","19","19","“ꠢꠣꠄꠄꠎ ꠛꠣ ꠛꠦꠐꠤꠀꠞꠣ ꠝꠣꠡꠤꠇ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠣ ꠢꠣꠟꠔꠦ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV18_20","004_18_20","LEV","18","20","20","ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠛꠦꠐꠣꠞ ꠛꠃꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠤꠀ, ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV18_21","004_18_21","LEV","18","21","21","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠘꠤꠎꠞ ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠀ, ꠝꠥꠟꠇ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠛꠟꠤ ꠖꠤꠀ, ꠀꠙꠘ ꠀꠟ꠆ꠟꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠘꠣꠝꠞꠦ ꠅꠡꠝ꠆ꠝꠣꠘ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV18_22","004_18_22","LEV","18","22","22","“ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠎꠦꠟꠣ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠂꠘ, ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ-ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠅꠟꠣ ꠈꠛꠤꠍꠤ ꠙꠥꠋꠉꠣꠝꠤ ꠇꠞꠣ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV18_23","004_18_23","LEV","18","23","23","ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠟꠉꠦ ꠈꠛꠤꠍꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠤꠀ, ꠇꠥꠘꠥ ꠛꠦꠐꠣꠁꠘ ꠘꠣꠙꠣꠇ ꠛꠘꠤꠅ ꠘꠣ। ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠘ꠆ꠔꠦꠅ ꠈꠛꠤꠍꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠁꠟꠣꠈꠣꠘ ꠈꠛꠤꠍꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠔ ꠎꠉꠔꠞ ꠘꠤꠅꠝꠞ ꠃꠟꠐꠣ। ");
INSERT INTO syls_vpl VALUES ("LV18_24","004_18_24","LEV","18","24","24","“ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠈꠛꠤꠍꠤ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠣꠝ ꠇꠞꠤꠀ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠎꠣꠘꠥ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠘꠣ ꠛꠣꠘꠣꠄ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠎꠔ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠀꠝꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠞꠣꠝ, ꠔꠣꠞꠣ ꠔ ꠅꠔꠣ ꠈꠛꠤꠍꠤ ꠇꠞꠤꠀ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠞꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LV18_25","004_18_25","LEV","18","25","25","ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠖꠦꠡꠞ ꠝꠣꠐꠤ ꠘꠣꠙꠣꠇ ꠛꠘꠤꠉꠦꠍꠦ, ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠇꠣꠞꠘꠦ ꠀꠝꠤ ꠅꠃ ꠖꠦꠡꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠞꠣꠝ, ꠅꠃ ꠖꠦꠡꠞ ꠝꠣꠐꠤꠄ ꠔꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞꠦ ꠛꠝꠤ ꠇꠞꠤ ꠚꠣꠟꠣꠁ ꠖꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("LV18_26","004_18_26","LEV","18","26","26","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠡꠞꠤꠅꠔ ꠀꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠅ। ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠇꠦꠃ ꠎꠣꠘꠥ ꠅꠟꠣ ꠈꠛꠤꠍꠤ ꠛꠦꠁꠎ꠆ꠎꠔꠤꠞ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ ꠘꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LV18_27","004_18_27","LEV","18","27","27","ꠀꠉꠦ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠎꠣꠔꠤ ꠅꠇꠟ ꠢꠃ ꠖꠦꠡꠅ ꠛꠡꠔ ꠇꠞꠦꠞ, ꠔꠣꠞꠣ ꠅꠃ ꠘꠝꠥꠘꠣꠞ ꠈꠛꠤꠍꠤ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠣꠝ ꠅꠇꠟ ꠇꠞꠣꠄ ꠢꠘꠞ ꠝꠣꠐꠤꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV18_28","004_18_28","LEV","18","28","28","ꠅꠈꠘ ꠔꠥꠝꠞꠣꠅ ꠢꠘꠅ ꠉꠤꠀ ꠎꠥꠖꠤ ꠢꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠙꠣꠇꠤ ꠇꠣꠝ ꠇꠞꠅ, ꠔꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠢꠃ ꠖꠦꠡꠞ ꠝꠣꠐꠤꠄ ꠛꠝꠤ ꠇꠞꠤ ꠚꠣꠟꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV18_29","004_18_29","LEV","18","29","29","“ꠁꠟꠣ ꠈꠛꠤꠍꠤ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠦꠃ ꠇꠞꠟꠦ, ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV18_30","004_18_30","LEV","18","30","30","ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠤꠅ, ꠔꠥꠝꠞꠣ ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠤ ꠢꠘꠞ ꠙꠥꠞꠣꠘꠣ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠌꠣꠟ-ꠌꠟꠘꠦ ꠌꠟꠤꠅ ꠘꠣ। ꠔꠣꠞꠣꠞ ꠈꠛꠤꠍꠤ ꠞꠤꠔꠤ-ꠞꠦꠅꠀꠎ ꠝꠣꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("LV19_1","004_19_1","LEV","19","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV19_2","004_19_2","LEV","19","2","2","“ꠔꠥꠝꠤ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠅ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("LV19_3","004_19_3","LEV","19","3","3","ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠎꠣꠞꠎꠤꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠔꠣꠎꠤꠝ ꠇꠞꠤꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠢꠇꠟ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠝꠣꠘꠤꠅ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_4","004_19_4","LEV","19","4","4","ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠚꠞ꠆ꠝꠣꠔ ꠓꠣꠟꠤꠀ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ, ꠙꠤꠔꠟ-ꠔꠣꠝꠣꠖꠤ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠝꠥꠞ꠆ꠔꠤꠅ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_5","004_19_5","LEV","19","5","5","“ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠘꠥ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅ, ꠅꠃ ꠡꠝꠄ ꠅꠟꠣ ꠜꠣꠛ ꠟꠁꠀ ꠖꠤꠅ, ꠎꠣꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠁꠔꠣ ꠇꠛꠥꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LV19_6","004_19_6","LEV","19","6","6","ꠀꠞ ꠁꠔꠣꠞ ꠢꠇꠟ ꠉꠥꠡ꠆ꠔ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠖꠤꠘ ꠛꠣ ꠛꠣꠖꠞ ꠖꠤꠘ ꠈꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠇꠥꠘꠥ ꠉꠥꠡ꠆ꠔ ꠛꠣꠇꠤ ꠞꠁꠟꠦ, ꠁꠔꠣ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV19_7","004_19_7","LEV","19","7","7","ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔ ꠁ ꠉꠥꠡ꠆ꠔ ꠘꠣꠙꠣꠇ ꠛꠘꠤꠎꠣꠄ, ꠁꠔꠣ ꠈꠣꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠛꠥꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV19_8","004_19_8","LEV","19","8","8","ꠁ ꠉꠥꠡ꠆ꠔ ꠇꠦꠃ ꠈꠣꠁꠟꠦ ꠢꠦ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠖꠣꠠꠅ ꠙꠠꠛ, ꠢꠦ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠍꠦ। ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV19_9","004_19_9","LEV","19","9","9","“ꠈꠦꠔꠞ ꠚꠡꠟ ꠇꠣꠐꠣꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠎꠝꠤꠘꠞ ꠀꠁꠟꠞ ꠇꠣꠘ꠆ꠖꠣꠞ ꠚꠡꠟ ꠍꠣꠚ ꠇꠞꠤꠀ ꠇꠣꠐꠤꠅ ꠘꠣ, ꠀꠞ ꠇꠣꠐꠣꠞ ꠛꠣꠖꠦ ꠎꠝꠤꠘꠅ ꠚꠣꠟꠣꠁꠟ ꠚꠡꠟ ꠟꠥꠞꠤꠀ ꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_10","004_19_10","LEV","19","10","10","ꠀꠋꠉꠥꠞ ꠈꠦꠔꠞ ꠀꠋꠉꠥꠞ ꠙꠣꠠꠤꠛꠣꠞ ꠇꠣꠟꠅ, ꠔꠟꠦ ꠚꠣꠟꠣꠁꠟ ꠀꠋꠉꠥꠞ ꠔꠥꠛꠣꠁꠀ ꠔꠥꠟꠤꠅ ꠘꠣ, ꠀꠞ ꠢꠇꠟ ꠀꠋꠉꠥꠞ ꠍꠣꠚ ꠇꠞꠤ ꠙꠣꠠꠤꠀ ꠘꠤꠅ ꠘꠣ। ꠡꠝꠣꠎꠞ ꠉꠞꠤꠛ-ꠖꠥꠈꠤ ꠀꠞ ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠇꠤꠍꠥ ꠕꠁꠀ ꠎꠣꠁꠅ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_11","004_19_11","LEV","19","11","11","“ꠌꠥꠞꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠝꠤꠍꠣ ꠝꠣꠔꠤꠅ ꠘꠣ, ꠀꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠐꠉꠣ-ꠐꠉꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_12","004_19_12","LEV","19","12","12","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠝꠤꠍꠣ ꠇꠍꠝ ꠈꠣꠁꠅ ꠘꠣ, ꠁꠟꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠞꠦ ꠅꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠣ ꠅꠄ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_13","004_19_13","LEV","19","13","13","“ꠇꠥꠘꠥ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠃꠙꠞꠦ ꠎꠥꠞ-ꠎꠥꠟꠥꠝ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠇꠣꠠꠤꠀ ꠘꠤꠅ ꠘꠣ। ꠞꠥꠎꠤ ꠇꠣꠝꠟꠣꠞ ꠛꠦꠔꠘ ꠅꠃ ꠖꠤꠘꠞ ꠝꠣꠎꠦꠃ ꠀꠖꠣꠄ ꠇꠞꠤꠅ, ꠛꠣꠖꠞ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞ ꠛꠦꠔꠘ ꠀꠐꠇꠣꠁ ꠕꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_14","004_19_14","LEV","19","14","14","ꠇꠥꠘꠥ ꠈꠣꠟꠥꠀꠞꠦ ꠛꠖ꠆ꠖꠥꠀ ꠖꠤꠅ ꠘꠣ, ꠇꠣꠘꠣ ꠛꠣ ꠀꠘ꠆ꠖꠣꠄ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠙꠕꠞ ꠝꠣꠎꠦ ꠇꠥꠘ꠆ꠔꠣ ꠕꠁꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠁꠎ꠆ꠎꠔ-ꠔꠣꠎꠤꠝ ꠇꠞꠤꠅ, ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_15","004_19_15","LEV","19","15","15","“ꠘꠣ-ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠅ ꠘꠣ, ꠛꠤꠌꠣꠞꠞ ꠝꠣꠎꠦ ꠉꠞꠤꠛ-ꠗꠘꠤ, ꠛꠣ ꠢꠥꠞꠥ-ꠛꠠꠞ ꠙꠇ꠆ꠇꠙꠣꠔꠤ ꠅꠁꠅ ꠘꠣ, ꠢꠇꠟꠞ ꠟꠣꠉꠤ ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV19_16","004_19_16","LEV","19","16","16","ꠝꠣꠘꠡꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠀ ꠉꠣꠁꠀ ꠊꠥꠞꠤꠅ ꠘꠣ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠎꠣꠘꠞ ꠈꠦꠔꠤ ꠅꠄ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_17","004_19_17","LEV","19","17","17","“ꠀꠙꠘ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠛꠣꠄ ꠁꠋꠡꠣ-ꠖꠥꠡꠝꠘꠤꠞ ꠜꠣꠛ ꠝꠘꠞ ꠝꠣꠎꠦ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠤꠅ ꠘꠣ। ꠔꠣꠞ ꠅꠙꠞꠣꠗ ꠔꠣꠞꠦ ꠛꠥꠎꠣꠁ ꠖꠤꠅ, ꠔꠦꠃ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠜꠣꠞ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV19_18","004_19_18","LEV","19","18","18","ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞ ꠛꠖꠟꠣ ꠟꠁꠅ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠎꠤꠖ-ꠁꠋꠡꠣꠞ ꠜꠣꠛ ꠝꠘꠞ ꠝꠣꠎꠦ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠤꠅ ꠘꠣ। ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠤꠅ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_19","004_19_19","LEV","19","19","19","“ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠅ। ꠄꠇ ꠎꠣꠔꠞ ꠙꠡꠥꠞ ꠟꠉꠦ ꠀꠞꠇ ꠎꠣꠔꠞ ꠙꠡꠥꠞꠦ ꠚꠣꠟ ꠈꠣꠛꠣꠁꠅ ꠘꠣ। ꠄꠇ ꠎꠝꠤꠘꠅ ꠖꠥꠁ ꠎꠣꠔꠞ ꠛꠤꠌ ꠈꠦꠔ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠖꠥꠁ ꠎꠣꠔꠞ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_20","004_19_20","LEV","19","20","20","“ꠇꠥꠘꠥ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤꠞ ꠛꠤꠀ ꠑꠤꠇ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠅꠁꠟꠦ ꠔꠣꠁꠞ ꠝꠢꠞꠣꠘꠣꠞ ꠐꠦꠇꠣ ꠖꠦꠅꠀ ꠅꠁꠍꠦ ꠘꠣ, ꠛꠣ ꠝꠣꠟꠤꠇꠦ ꠎꠦꠉꠥꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤꠀ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠛꠣꠘ꠆ꠖꠤꠞ ꠟꠉꠦ ꠇꠦꠃ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠟꠦ, ꠔꠦ ꠢꠦ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠁ ꠖꠥꠁꠅ ꠎꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠅꠃ ꠛꠣꠘ꠆ꠖꠤ ꠙꠥꠠꠤ ꠔ ꠀꠎꠣꠖ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_21","004_19_21","LEV","19","21","21","ꠅꠁꠟꠦ ꠅꠃ ꠛꠦꠐꠣꠄ ꠔꠣꠞ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠝꠦꠠꠣ ꠟꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV19_22","004_19_22","LEV","19","22","22","ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠘꠣ ꠢꠃ ꠙꠡꠥꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ, ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠛꠣꠖꠦ, ꠢꠦ ꠅꠃ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV19_23","004_19_23","LEV","19","23","23","“ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠤ ꠇꠥꠘꠥ ꠚꠟꠞ ꠉꠣꠍ ꠟꠣꠉꠣꠁꠟꠦ, ꠔꠤꠘ ꠛꠍꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁ ꠉꠣꠍꠞ ꠚꠟ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ꠅꠃ ꠔꠤꠘ ꠛꠍꠞꠞ ꠝꠣꠎꠦ ꠁ ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠅꠀ ꠘꠣꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("LV19_24","004_19_24","LEV","19","24","24","ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞꠅ ꠁ ꠉꠣꠍꠞ ꠢꠇꠟ ꠚꠟ ꠝꠣꠛꠥꠖꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞꠤꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠘ ꠘꠣꠝꠦ ꠖꠤꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV19_25","004_19_25","LEV","19","25","25","ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞ ꠕꠣꠇꠤ ꠅꠃ ꠉꠣꠍꠞ ꠚꠟ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠟꠣꠟ। ꠁꠔꠣ ꠝꠣꠘꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠍꠅ ꠛꠃꠔ ꠚꠟ ꠀꠁꠛ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_26","004_19_26","LEV","19","26","26","“ꠔꠥꠝꠞꠣ ꠟꠃ ꠡꠝꠦꠔ ꠇꠥꠘꠥ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠅ ꠘꠣ। ꠇꠥꠘꠥ ꠎꠣꠔꠞ ꠎꠣꠖꠥ-ꠝꠘꠔ꠆ꠞ ꠛꠣ ꠉꠘꠣ-ꠛꠣꠍꠣ ꠢꠤꠇꠤꠅ ꠘꠣ, ꠀꠞ ꠛꠦꠛꠢꠣꠞꠅ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_27","004_19_27","LEV","19","27","27","ꠝꠣꠕꠣꠞ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠞ ꠌꠥꠟ ꠍꠣꠐꠣ, ꠛꠣ ꠖꠣꠠꠤꠞ ꠀꠉꠣ ꠇꠣꠐꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_28","004_19_28","LEV","19","28","28","ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠉꠤ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠣꠔ ꠉꠤꠀ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠅ ꠎꠈꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠉꠔꠞꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠌꠣꠙ-ꠍꠛꠤ ꠀꠇꠤꠅ ꠘꠣ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_29","004_19_29","LEV","19","29","29","“ꠐꠦꠇꠣ ꠞꠥꠎꠤꠞ ꠘꠤꠅꠔꠦ ꠘꠤꠎꠞ ꠙꠥꠠꠤꠞꠦ ꠍꠤꠟꠣꠘꠤ-ꠛꠖꠝꠣꠁꠡꠤꠔ ꠟꠣꠉꠣꠁꠅ ꠘꠣ। ꠀꠞꠘꠣꠄ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠎꠤꠘꠣꠄ ꠜꠞꠤꠎꠤꠛ, ꠙꠥꠞꠣ ꠖꠦꠡꠅ ꠈꠛꠤꠍꠤ ꠛꠣꠠꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV19_30","004_19_30","LEV","19","30","30","ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠎꠤꠞꠣꠁꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠇꠣꠛꠣ ꠊꠞꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_31","004_19_31","LEV","19","31","31","“ꠎꠤꠘ꠆ꠘꠣꠔ ꠛꠣ ꠙꠦꠞꠔ ꠡꠣꠗꠇ, ꠉꠘꠇ ꠛꠣ ꠎꠣꠖꠥ-ꠐꠥꠘꠣ ꠇꠞꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠅ ꠘꠣ, ꠁꠔꠣꠞ ꠟꠉꠦ ꠝꠤꠡꠤꠅ ꠘꠣ। ꠀꠞꠘꠣꠄ ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠟꠤꠛꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_32","004_19_32","LEV","19","32","32","“ꠝꠥꠞꠛ꠆ꠛꠤ ꠝꠣꠘꠥꠡ ꠗꠣꠞꠅ ꠀꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠃꠛꠣꠁꠀ ꠁꠎ꠆ꠎꠔ ꠖꠤꠅ। ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚꠦ ꠞꠁꠅ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_33","004_19_33","LEV","19","33","33","“ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_34","004_19_34","LEV","19","34","34","ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠟꠉꠦ ꠎꠦꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠅ, ꠔꠣꠞꠣꠞ ꠟꠉꠦꠅ ꠅꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤꠅ, ꠔꠣꠞꠣꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠤꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠅ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠢꠣꠟꠔꠦ ꠀꠍꠟꠣꠄ, ꠀꠞ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV19_35","004_19_35","LEV","19","35","35","“ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠝꠣꠙ-ꠎꠥꠇꠅ ꠀꠞ ꠙꠣꠟ꠆ꠟꠣꠞ ꠃꠎꠘꠅ ꠛꠦ-ꠁꠘꠍꠣꠚꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV19_36","004_19_36","LEV","19","36","36","ꠔꠥꠝꠞꠣꠞ ꠙꠣꠟ꠆ꠟꠣ-ꠙꠣꠔ꠆ꠔꠞ, ꠢꠦꠞ-ꠚꠥꠞꠣ, ꠘꠟ-ꠖꠠꠤ, ꠝꠣꠙꠞ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠥ ꠑꠤꠇ-ꠑꠣꠇ ꠕꠣꠇꠦ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠀꠞ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LV19_37","004_19_37","LEV","19","37","37","ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠇꠟ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠡꠞꠤꠅꠔ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠅ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("LV20_1","004_20_1","LEV","20","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV20_2","004_20_2","LEV","20","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤꠞꠦ ꠝꠥꠟꠇ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠛꠟꠤ ꠖꠦꠄ, ꠔꠦ ꠅꠉꠥꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ, ꠖꠦꠡꠞ ꠝꠣꠘꠡꠦ ꠝꠤꠟꠤꠀ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠁꠐꠣꠁꠀ ꠔꠣꠞꠦ ꠝꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV20_3","004_20_3","LEV","20","3","3","ꠢꠦ ꠘꠤꠎꠞ ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠀ ꠝꠥꠟꠇ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠛꠟꠤ ꠖꠤꠀ, ꠀꠝꠣꠞ ꠇꠣꠛꠣ ꠊꠞꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠍꠦ ꠀꠞ ꠀꠝꠣꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠘꠣꠝꠞꠦ ꠅꠡꠝ꠆ꠝꠣꠘ ꠇꠞꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠝꠥ, ꠁ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV20_4","004_20_4","LEV","20","4","4","ꠅꠃ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠔꠣꠞ ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤꠞꠦ ꠛꠟꠤ ꠖꠦꠅꠀꠞ ꠡꠝꠄ, ꠁ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠖꠦꠈꠤꠀꠅ ꠘꠣ-ꠖꠦꠈꠣꠞ ꠜꠣꠘ ꠇꠞꠂꠘ, ꠀꠞ ꠁ ꠛꠟꠤ ꠖꠦꠅꠞꠣꠞꠦ ꠎꠣꠘꠦ ꠘꠣ ꠝꠣꠞꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("LV20_5","004_20_5","LEV","20","5","5","ꠔꠦ ꠀꠝꠤ ꠘꠤꠎꠦ ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠀꠞ ꠔꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠎꠤꠝꠥ। ꠀꠝꠤ ꠅꠉꠥꠞ ꠘꠣꠝ ꠀꠞ ꠅꠉꠥꠞ ꠟꠣꠈꠣꠘ ꠀꠞꠅ ꠎꠦꠉꠥꠁꠘ꠆ꠔꠦ ꠁꠟꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠛ, ꠅꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠘꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠝꠤꠐꠣꠁꠟꠤꠝꠥ। ꠄꠞꠣ ꠔ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠢꠃ ꠝꠥꠟꠇ ꠖꠦꠛꠔꠣꠞ ꠀꠔꠅ ꠘꠤꠎꠞꠦ ꠡꠙꠤ ꠖꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV20_6","004_20_6","LEV","20","6","6","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠤꠀ, ꠎꠤꠘ-ꠜꠥꠔ ꠡꠣꠗꠇ ꠛꠣ ꠉꠘꠇꠞ ꠟꠉꠦ ꠝꠤꠡꠤꠀ ꠘꠤꠎꠞꠦ ꠡꠙꠤ ꠖꠤꠟꠣꠄ, ꠔꠦ ꠔꠣꠞꠅ ꠈꠦꠔꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠎꠤꠝꠥ ꠀꠞ ꠁ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV20_7","004_20_7","LEV","20","7","7","“ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞꠦ ꠀꠟꠣꠖꠣ ꠇꠞꠅ ꠀꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV20_8","004_20_8","LEV","20","8","8","ꠀꠝꠣꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠝꠟ ꠇꠞꠤꠅ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ, ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("LV20_9","004_20_9","LEV","20","9","9","“ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠙꠘ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠉꠣꠟꠤ-ꠉꠣꠟꠣꠎ ꠇꠞꠤꠀ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠦ, ꠔꠣꠞꠦꠅ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣꠄ। ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠖꠣꠄ ꠔꠣꠞ ꠝꠃꠔꠞ ꠟꠣꠉꠤ ꠢꠦ ꠘꠤꠎꠦꠃ ꠖꠣꠄꠁ। ");
INSERT INTO syls_vpl VALUES ("LV20_10","004_20_10","LEV","20","10","10","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠇꠥꠘꠥ ꠎꠘꠞ ꠛꠃꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠅꠃ ꠛꠦꠐꠣ-ꠛꠦꠐꠤ ꠖꠥꠁꠅ ꠎꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV20_11","004_20_11","LEV","20","11","11","ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠢꠣꠔꠘ ꠝꠣʼꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠔꠣꠞ ꠛꠣꠚꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠦ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠀꠞ ꠢꠣꠔꠘ ꠝꠣʼꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣꠄ। ꠔꠣꠞꠣꠞ ꠝꠃꠔꠞ ꠟꠣꠉꠤ ꠔ ꠔꠣꠞꠣꠃ ꠖꠣꠄꠁ। ");
INSERT INTO syls_vpl VALUES ("LV20_12","004_20_12","LEV","20","12","12","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠀꠙꠘ ꠙꠥꠀꠞ ꠛꠃꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠎꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣꠄ। ꠔꠣꠞꠣ ꠝꠣꠘꠛ ꠡꠝꠣꠎꠞ ꠃꠟꠐꠣ ꠌꠟꠣꠄ, ꠔꠣꠞꠣꠞ ꠝꠃꠔꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠦꠃ ꠖꠣꠄꠁ। ");
INSERT INTO syls_vpl VALUES ("LV20_13","004_20_13","LEV","20","13","13","ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠎꠥꠖꠤ ꠀꠞꠇ ꠛꠦꠐꠣꠞ ꠟꠉꠦ ꠎꠤꠘꠣ-ꠙꠥꠋꠉꠣꠝꠤ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠎꠘꠦꠃ ꠛꠠ ꠈꠛꠤꠍꠤ ꠇꠞꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠖꠥꠁꠅ ꠎꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ, ꠔꠣꠞꠣꠞ ꠝꠃꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠃ ꠖꠣꠄꠁ। ");
INSERT INTO syls_vpl VALUES ("LV20_14","004_20_14","LEV","20","14","14","“ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠀꠞ ꠔꠣꠁꠞ ꠝꠣʼꠞꠦꠅ ꠢꠣꠋꠉꠣ ꠇꠞꠦ, ꠔꠦ ꠅꠃ ꠛꠦꠐꠣ ꠀꠞ ꠝꠣ-ꠙꠥꠠꠤ ꠔꠤꠘꠅ ꠎꠘꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠀ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ, ꠎꠣꠔꠦ ꠁꠟꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣ ꠊꠐꠦ। ");
INSERT INTO syls_vpl VALUES ("LV20_15","004_20_15","LEV","20","15","15","ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠤꠘꠣ ꠇꠞꠟꠦ, ꠢꠃ ꠝꠣꠘꠥꠡ ꠀꠞ ꠙꠡꠥ ꠖꠥꠁꠅꠉꠥꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV20_16","004_20_16","LEV","20","16","16","ꠇꠥꠘꠥ ꠛꠦꠐꠤꠄ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠣꠔ ꠎꠣꠄ, ꠔꠦ ꠢꠃ ꠛꠦꠐꠤ ꠀꠞ ꠙꠡꠥꠞꠦꠅ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣꠄ। ꠔꠣꠞꠣꠞ ꠝꠃꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠃ ꠖꠣꠄꠁ। ");
INSERT INTO syls_vpl VALUES ("LV20_17","004_20_17","LEV","20","17","17","“ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠎꠥꠖꠤ ꠔꠣꠞ ꠀꠙꠘ ꠛꠁꠘ, ꠢꠣꠔꠘ ꠝꠣ ꠛꠣ ꠢꠣꠔꠘ ꠛꠣꠚꠞ ꠊꠞꠞ ꠛꠁꠘꠞ ꠟꠉꠦ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠦ, ꠁꠔꠣ ꠔ ꠡꠞꠝꠞ ꠇꠣꠝ। ꠔꠣꠞꠣꠞꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟꠤꠛꠣꠄ, ꠀꠞ ꠢꠦ ꠡꠣꠎꠣ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV20_18","004_20_18","LEV","20","18","18","ꠇꠥꠘꠥ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞ ꠝꠣꠡꠤꠇ ꠛꠦꠝꠣꠞꠞ ꠡꠝꠄ ꠔꠣꠁꠞ ꠟꠉꠦ ꠎꠦ ꠛꠦꠐꠣꠄ ꠡꠞꠤꠟꠤ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠦ, ꠁ ꠛꠦꠐꠤꠄ ꠔ ꠔꠣꠁꠞ ꠝꠣꠡꠤꠇ ꠇꠣꠟꠞ ꠁꠎ꠆ꠎꠔ ꠖꠦꠄ ꠘꠣ, ꠀꠞ ꠁ ꠛꠦꠐꠣꠄꠅ ꠔꠣꠁꠞ ꠝꠣꠡꠤꠇꠞꠦ ꠖꠣꠝ ꠖꠦꠄ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠁ ꠖꠥꠁꠅꠉꠥꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV20_19","004_20_19","LEV","20","19","19","ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠎꠣꠘꠥ ꠔꠣꠞ ꠈꠣꠟꠣ ꠛꠣ ꠚꠥꠚꠥꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠘꠣ ꠇꠞꠦ, ꠀꠞꠘꠣꠄ ꠀꠙꠘ ꠟꠃꠞ ꠇꠥꠐꠥꠝꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠣꠄ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠎꠘꠦ ꠡꠣꠎꠣ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV20_20","004_20_20","LEV","20","20","20","ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠌꠣꠌꠤ ꠛꠣ ꠝꠣꠝꠤꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠎꠘꠦ ꠡꠣꠎꠣ ꠙꠣꠁꠛ, ꠘꠤꠀꠅꠟꠣꠖꠤ ꠢꠣꠟꠔꠦ ꠔꠣꠞꠣꠞ ꠝꠞꠘ ꠅꠁꠛ, ꠢꠦ ꠔ ꠔꠣꠞ ꠌꠣꠌꠣ ꠛꠣ ꠝꠣꠝꠣꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV20_21","004_20_21","LEV","20","21","21","ꠜꠣꠁ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠔꠦ ꠎꠥꠖꠤ ꠀꠞꠇ ꠜꠣꠁꠄ ꠔꠣꠞ ꠜꠣꠛꠤꠞꠦ ꠢꠣꠋꠉꠣ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞ ꠜꠣꠁꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠣꠄ, ꠁꠐꠣ ꠛꠠ ꠘꠣꠚꠞꠝꠣꠘꠤ। ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠀꠅꠟꠣꠖ ꠙꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV20_22","004_20_22","LEV","20","22","22","“ꠔꠥꠝꠞꠣ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠅ ꠘꠤꠀꠞ, ꠢꠃ ꠖꠦꠡꠞ ꠝꠣꠐꠤꠄ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠝꠤ ꠇꠞꠤꠀ ꠘꠣ ꠚꠣꠟꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠇꠟ ꠡꠞꠤꠅꠔ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠅꠇꠟ ꠀꠝꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV20_23","004_20_23","LEV","20","23","23","ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠀꠝꠤ ꠎꠦꠔꠣ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠞꠣꠝ, ꠁꠔꠣꠞ ꠌꠣꠟ-ꠌꠟꠘꠦ ꠔꠥꠝꠞꠣ ꠌꠟꠤꠅ ꠘꠣ। ꠔꠣꠞꠣꠞ ꠢꠃ ꠌꠣꠟ-ꠌꠟꠘꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠍꠤ, ");
INSERT INTO syls_vpl VALUES ("LV20_24","004_20_24","LEV","20","24","24","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠀꠖꠣ ꠖꠤꠍꠟꠣꠝ ꠔꠣꠞꠣꠞ ꠖꠦꠡꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠈꠟꠦ ꠖꠤꠝꠥ, ꠔꠣꠞꠣꠞ ꠢꠃ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠖꠦꠡ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠝꠥ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠎꠉꠔꠞ ꠢꠇꠟ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟꠣꠖꠣ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LV20_25","004_20_25","LEV","20","25","25","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠢꠣꠟꠣꠟ ꠀꠞ ꠢꠣꠞꠣꠝ ꠙꠡꠥꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠔꠚꠣꠔ ꠞꠣꠈꠤꠅ, ꠢꠣꠟꠣꠟ ꠀꠞ ꠢꠣꠞꠣꠝ ꠙꠣꠈꠤꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠔꠚꠣꠔ ꠞꠣꠈꠤꠅ। ꠙꠡꠥ-ꠙꠣꠈꠤ ꠀꠞ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠌꠟꠞꠣ ꠢꠥꠞꠥ ꠢꠥꠞꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣꠞꠦ ꠀꠝꠤ ꠢꠣꠞꠣꠝ ꠇꠁꠍꠤ, ꠅꠔꠣ ꠖꠤꠀ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠀ ꠟꠣꠘ꠆ꠘꠔꠤ ꠛꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV20_26","004_20_26","LEV","20","26","26","ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠅ ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠔꠦ ꠅꠁꠛ। ꠀꠝꠣꠞ ꠀꠙꠘ ꠙ꠆ꠞꠎꠣ ꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠉꠔꠞ ꠢꠇꠟ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠛꠣꠍꠤꠀ ꠀꠟꠉ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LV20_27","004_20_27","LEV","20","27","27","“ꠎꠦꠔꠣ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠎꠤꠘ-ꠜꠥꠔ ꠡꠣꠗꠘ, ꠉꠘꠇ ꠛꠣ ꠎꠣꠖꠥ-ꠐꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠦ, ꠁꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠁꠐꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ, ꠔꠣꠞꠣꠞ ꠝꠃꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠃ ꠖꠣꠄꠁ।” ");
INSERT INTO syls_vpl VALUES ("LV21_1","004_21_1","LEV","21","1","1","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘꠞ ꠛꠋꠡꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠞꠦ ꠇꠁꠅ, ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠇꠥꠐꠥꠝ-ꠈꠦꠡꠞ ꠝꠃꠔꠞ ꠇꠣꠞꠘꠦ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠘꠣ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV21_2","004_21_2","LEV","21","2","2","ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠝꠣ-ꠛꠣꠚ, ꠙꠥꠀ-ꠙꠥꠠꠤ ꠛꠣ ꠀꠙꠘ ꠜꠣꠁ ꠝꠣꠞꠣ ꠉꠦꠟꠦ ꠔꠣꠞꠣ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠘꠤ ꠎꠣꠁꠎ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV21_3","004_21_3","LEV","21","3","3","ꠀꠞ ꠜꠣꠁꠞ ꠊꠞꠅ ꠞꠅꠞꠣ ꠀꠛꠤꠀꠔꠤ ꠇꠥꠘꠥ ꠛꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠟꠦ ꠔꠣꠁꠞꠦ ꠖꠣꠚꠘ-ꠇꠣꠚꠘꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠞ ꠜꠣꠁ ꠘꠣꠙꠣꠇ ꠛꠘꠣ ꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("LV21_4","004_21_4","LEV","21","4","4","ꠅꠁꠟꠦ ꠢꠃꠞ ꠛꠣꠠꠤꠞ ꠇꠥꠘꠥ ꠇꠥꠐꠥꠝ-ꠈꠦꠡꠞ ꠝꠃꠔꠞ ꠖꠣꠄ ꠇꠥꠘꠥ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠘꠤꠎꠞ ꠙꠛꠤꠔ꠆ꠞ ꠢꠣꠟꠔ ꠕꠣꠇꠤ ꠘꠣꠙꠣꠇ ꠛꠘꠣ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV21_5","004_21_5","LEV","21","5","5","“ꠁꠝꠣꠝ ꠍꠣꠛ ꠅꠇꠟꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠘꠤ, ꠖꠣꠠꠤꠞ ꠀꠉꠣ ꠍꠣꠐꠣ, ꠛꠣ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠅ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠐꠣ-ꠌꠤꠞꠣ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV21_6","004_21_6","LEV","21","6","6","ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠀꠙꠘ ꠀꠟ꠆ꠟꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠘꠣꠝꠞꠦ ꠅꠡꠝ꠆ꠝꠣꠘ ꠘꠣ ꠇꠞꠂꠘ, ꠀꠞ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠞꠁꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠘ। ꠅꠈꠣꠘ ꠝꠘꠅ ꠞꠣꠈꠂꠘ ꠎꠦꠘ, ꠅꠃ ꠁꠝꠣꠝ ꠅꠇꠟꠦꠃ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠍꠖꠉꠣ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠇꠟ ꠀꠖꠣꠄ ꠇꠞꠂꠘ, ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠣꠟ ꠔ ꠘꠤꠎꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠞ ꠞꠤꠎꠦꠇ। ");
INSERT INTO syls_vpl VALUES ("LV21_7","004_21_7","LEV","21","7","7","ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠇꠥꠘꠥ ꠛꠖꠝꠣꠁꠡ, ꠍꠤꠟꠣꠘ ꠛꠣ ꠔꠣꠟꠣꠇ ꠙꠣꠅꠀ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠔꠣꠞꠣꠞ ꠀꠙꠘ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣ ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("LV21_8","004_21_8","LEV","21","8","8","ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠥꠝꠞꠣ ꠁꠝꠣꠝ ꠍꠣꠛ ꠅꠇꠟꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠙꠛꠤꠔ꠆ꠞ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠤꠅ, ꠔꠣꠞꠣꠃ ꠔ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠈꠣꠘꠤ ꠡꠙꠤꠀ ꠖꠦꠁꠘ। ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠞꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠝꠣꠘꠤꠅ, ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠘꠣꠁꠍꠤ, ꠀꠞ ꠀꠝꠤ ꠘꠤꠎꠦ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("LV21_9","004_21_9","LEV","21","9","9","ꠇꠥꠘꠥ ꠁꠝꠣꠝꠞ ꠙꠥꠠꠤ ꠎꠥꠖꠤ ꠍꠤꠟꠣꠘꠤ-ꠛꠖꠝꠣꠁꠡꠤꠞ ꠙꠕꠦ ꠉꠤꠀ ꠘꠣꠙꠣꠇ ꠛꠘꠤꠎꠣꠄ, ꠔꠦ ꠔꠣꠁꠞ ꠛꠣꠚꠞꠦꠅ ꠔꠣꠁ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠟꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠀ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV21_10","004_21_10","LEV","21","10","10","“ꠀꠞ ꠁꠝꠣꠝ ꠙꠞꠤꠛꠣꠞꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠢꠇꠟ ꠛꠠ ꠎꠦꠁꠘ, ꠄꠁꠘꠃ ꠔ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ, ꠄꠘ ꠝꠣꠕꠣꠔ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠔꠦꠟ ꠓꠣꠟꠣ ꠅꠁꠍꠦ, ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠀ ꠔꠣꠁꠘ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠙꠛꠤꠔ꠆ꠞ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠛꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠙꠣꠁꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠉꠤꠀ ꠇꠣꠘ꠆ꠖꠘ-ꠀꠢꠣꠎꠣꠞꠤꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠘ ꠝꠣꠕꠣꠞ ꠙꠣꠃꠉꠠꠤ ꠈꠥꠟꠤꠀ ꠌꠥꠟ ꠀꠃꠟꠣ-ꠎꠣꠃꠟꠣ ꠇꠞꠣ, ꠛꠣ ꠔꠣꠘ ꠚꠤꠘ꠆ꠘꠞ ꠟꠦꠛꠣꠍ ꠍꠤꠠꠣꠅ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV21_11","004_21_11","LEV","21","11","11","ꠄꠁꠘ ꠇꠥꠘꠥ ꠝꠞꠣ ꠟꠣꠡꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠅꠀ ꠎꠣꠁꠎ ꠘꠣꠄ। ꠘꠤꠎꠞ ꠝꠣ-ꠛꠣꠚ ꠝꠣꠞꠣ ꠉꠦꠟꠦꠅ ꠄꠁꠘ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠘꠤ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV21_12","004_21_12","LEV","21","12","12","ꠎꠦꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞ ꠍꠣꠠꠤꠀ ꠇꠥꠘꠥꠈꠣꠘꠅ ꠉꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠊꠞꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠘꠤ ꠔꠣꠘ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠣꠘ ꠀꠙꠘ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠞ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠔꠦꠟ ꠓꠣꠟꠤꠀ ꠔꠣꠘꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV21_13","004_21_13","LEV","21","13","13","“ꠇꠥꠘꠥ ꠀꠛꠤꠀꠔꠤ ꠡꠔꠤ ꠇꠁꠘꠣꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠣ ꠔꠣꠘ ꠟꠣꠉꠤ ꠎꠣꠁꠎ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV21_14","004_21_14","LEV","21","14","14","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠠꠣꠠꠤ ꠛꠦꠐꠤ, ꠛꠖꠝꠣꠁꠡ-ꠍꠤꠟꠣꠘ ꠛꠦꠐꠤ ꠛꠣ ꠔꠣꠟꠣꠇ ꠙꠣꠅꠀ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠞꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠡꠣꠖꠤ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠘꠤꠎꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠇꠥꠘꠥ ꠀꠛꠤꠀꠔꠤ ꠡꠔꠤ ꠇꠁꠘꠣꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠣ ꠔꠣꠘ ꠟꠣꠉꠤ ꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("LV21_15","004_21_15","LEV","21","15","15","ꠀꠞꠘꠣꠄ ꠔꠣꠘ ꠇꠣꠞꠘꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠙꠛꠤꠔ꠆ꠞ ꠢꠣꠟꠔ ꠕꠣꠇꠤ ꠘꠣꠙꠣꠇ ꠛꠘꠛ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ, ꠀꠝꠤꠃ ꠔꠣꠘꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠘꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("LV21_16","004_21_16","LEV","21","16","16","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV21_17","004_21_17","LEV","21","17","17","“ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠞ ꠡꠞꠤꠟꠞ ꠈꠥꠔ ꠀꠟꠣ ꠇꠥꠘꠥ ꠎꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠅꠀ ꠘꠤꠡꠦꠗ। ");
INSERT INTO syls_vpl VALUES ("LV21_18","004_21_18","LEV","21","18","18","ꠎꠦ ꠎꠘꠞ ꠡꠞꠤꠟꠅ ꠈꠥꠔ ꠀꠍꠦ, ꠝꠣꠘꠤ ꠀꠘ꠆ꠖꠣ, ꠟꠦꠋꠠꠣ, ꠘꠣꠇ-ꠇꠣꠐꠣ, ꠀꠔ-ꠙꠣꠅ ꠘꠤꠅꠝꠞ ꠛꠦꠡꠤ ꠟꠣꠝ꠆ꠛꠣ-ꠛꠣꠐ꠆ꠐꠤ ꠛꠣ ꠀꠋꠉꠥꠁꠟ ꠇꠝ-ꠛꠦꠡꠤ, ");
INSERT INTO syls_vpl VALUES ("LV21_19","004_21_19","LEV","21","19","19","ꠀꠔ ꠛꠣ ꠙꠣꠅ ꠜꠣꠋꠉꠣ, ");
INSERT INTO syls_vpl VALUES ("LV21_20","004_21_20","LEV","21","20","20","ꠙꠤꠑ ꠉꠥꠎꠣ, ꠛꠣꠐ꠆ꠐꠤ ꠜꠦꠋꠉꠣꠁ ꠝꠣꠘꠥꠡ, ꠌꠃꠈꠞ ꠛꠦꠝꠣꠞꠤ, ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤ, ꠙꠌꠣ-ꠊꠣ ꠛꠦꠝꠣꠞꠤ ꠛꠣ ꠅꠘ꠆ꠒꠇꠥꠡ ꠘꠡ꠆ꠐ, ꠁꠟꠣ ꠈꠥꠔ ꠀꠟꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠅꠀ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV21_21","004_21_21","LEV","21","21","21","ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠛꠋꠡꠞ ꠡꠞꠤꠟꠞ ꠈꠥꠔ ꠀꠟꠣ ꠇꠥꠘꠥ ꠎꠘꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣ ꠘꠤꠡꠦꠗ। ꠔꠣꠞ ꠉꠔꠞꠅ ꠈꠥꠔ ꠕꠣꠇꠣꠄ ꠢꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠤꠀ ꠀꠝꠣꠞ ꠘꠣꠝꠞ ꠈꠣꠘꠤꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV21_22","004_21_22","LEV","21","22","22","ꠅꠁꠟꠦ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠈꠣꠘꠤ ꠈꠣꠅꠀ ꠔꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠁꠎ, ꠁꠔꠣ ꠙꠛꠤꠔ꠆ꠞ ꠛꠣ ꠈꠣꠍ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠟꠦꠅ ꠎꠣꠁꠎ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV21_23","004_21_23","LEV","21","23","23","ꠔꠣꠞ ꠡꠞꠤꠟꠅ ꠈꠥꠔ ꠕꠣꠇꠣꠄ ꠢꠦ ꠇꠣꠛꠣ ꠊꠞꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠅꠀ ꠘꠤꠡꠦꠗ, ꠢꠦ ꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠉꠣ ꠅꠇꠟꠞꠦ ꠘꠣꠙꠣꠇ ꠘꠣ ꠛꠣꠘꠣꠄ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ, ꠀꠞ ꠀꠝꠤꠃ ꠅꠃ ꠎꠣꠉꠣꠁꠘ꠆ꠔꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("LV21_24","004_21_24","LEV","21","24","24","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠉꠤꠀ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ, ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠀꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV22_1","004_22_1","LEV","22","1","1","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV22_2","004_22_2","LEV","22","2","2","“ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠇꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠎꠔꠔꠣ ꠀꠘꠂꠘ, ꠁꠔꠣ ꠔ ꠙꠛꠤꠔ꠆ꠞ। ꠄꠞꠟꠣꠉꠤ ꠅꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠁꠎ꠆ꠎꠔ-ꠔꠣꠎꠤꠝ ꠇꠞꠣ ꠎꠞꠥꠞ। ꠁ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠘꠣꠝꠞꠦ ꠅꠡꠝ꠆ꠝꠣꠘ ꠘꠣ ꠇꠞꠦ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV22_3","004_22_3","LEV","22","3","3","“ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟꠤꠛꠣꠄ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV22_4","004_22_4","LEV","22","4","4","ꠢꠣꠞꠥꠘꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤ ꠛꠣ ꠗꠣꠔꠥ ꠎꠣꠅꠀ ꠛꠦꠝꠣꠞꠤ ꠅꠄ, ꠔꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠇꠥꠘꠥꠔꠣ ꠈꠣꠅꠀ ꠘꠣꠎꠣꠁꠎ। ꠀꠞ ꠝꠞꠣ ꠟꠣꠡꠞꠦ ꠛꠣ ꠅꠃ ꠟꠣꠡꠞ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠍꠦ ꠁꠔꠣ ꠇꠥꠘꠥꠔꠣ ꠍꠁꠀ ꠎꠥꠖꠤ ꠇꠦꠃ ꠘꠣꠙꠣꠇ ꠛꠘꠦ, ꠛꠣ ꠇꠦꠃꠞꠞ ꠎꠃꠛꠘꠞ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("LV22_5","004_22_5","LEV","22","5","5","ꠀꠞ ꠎꠦ ꠎꠘ ꠇꠥꠘꠥꠎꠣꠔ ꠝꠣꠐꠤꠔ ꠌꠟꠞꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠘꠣꠙꠣꠇ ꠎꠣꠘꠖꠣꠞ ꠛꠣ ꠎꠦꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠘꠣꠙꠣꠇ ꠅꠀ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠍꠁꠀ ꠢꠦ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV22_6","004_22_6","LEV","22","6","6","ꠔꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦꠃ ꠞꠁꠛ, ꠀꠞ ꠙꠣꠘꠤꠖꠤ ꠘꠣꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠇꠥꠘꠥ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ ꠈꠣꠅꠀ ꠔꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV22_7","004_22_7","LEV","22","7","7","ꠛꠣꠖꠦ ꠡꠥꠞꠥꠎ ꠒꠥꠛꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠦ ꠎꠦꠛꠟꠣ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠢꠦ ꠁꠔꠣ ꠈꠣꠁꠔ ꠙꠣꠞꠛ। ꠁꠔꠣ ꠔ ꠔꠣꠞꠃ ꠈꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("LV22_8","004_22_8","LEV","22","8","8","ꠁꠝꠣꠝꠦ ꠇꠥꠘꠥ ꠝꠞꠣ ꠙꠡꠥ ꠛꠣ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠞ ꠕꠣꠛꠣꠄ ꠝꠣꠞꠣ ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠀ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV22_9","004_22_9","LEV","22","9","9","“ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠎꠦꠔꠣ ꠀꠁꠘ-ꠇꠣꠘꠥꠘ ꠖꠤꠍꠤ, ꠁꠔꠣ ꠔꠣꠞꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠃꠇ। ꠀꠞꠘꠣꠄ ꠖꠥꠡꠤ ꠛꠘꠛꠣꠄ ꠀꠞ ꠘꠣꠙꠣꠇꠤꠞ ꠖꠞꠥꠘ ꠔꠣꠞꠣꠞ ꠝꠞꠘ ꠅꠁꠛ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦꠃ ꠔꠣꠞꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("LV22_10","004_22_10","LEV","22","10","10","“ꠁꠝꠣꠝ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠘꠥꠡ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠎꠘꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ ꠈꠣꠅꠀ ꠘꠤꠡꠦꠗ। ꠁꠝꠣꠝꠞ ꠇꠥꠘꠥ ꠝꠦꠝꠣꠘ ꠛꠣ ꠇꠣꠝꠟꠣꠄꠅ ꠁꠔꠣ ꠈꠣꠅꠀ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV22_11","004_22_11","LEV","22","11","11","ꠅꠁꠟꠦ ꠁꠝꠣꠝꠞ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝꠦ ꠛꠣ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠎꠘꠝꠤꠍꠦ ꠁꠟꠣꠈꠣꠘ ꠉꠥꠟꠣꠝꠦ ꠁꠔꠣ ꠈꠣꠅꠀ ꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("LV22_12","004_22_12","LEV","22","12","12","ꠁꠝꠣꠝꠞ ꠙꠥꠠꠤ ꠎꠥꠖꠤ ꠀꠞꠇ ꠁꠝꠣꠝ ꠍꠣꠠꠣ ꠛꠣꠁꠞꠣ ꠇꠥꠘꠥ ꠖꠣꠝꠣꠘ꠆ꠖꠞ ꠟꠉꠦ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠅꠄ, ꠔꠦ ꠔꠣꠁꠅ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ ꠈꠣꠅꠀ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV22_13","004_22_13","LEV","22","13","13","ꠅꠁꠟꠦ ꠁꠝꠣꠝꠞ ꠇꠥꠘꠥ ꠠꠣꠠꠤ ꠙꠥꠠꠤ ꠛꠣ ꠔꠣꠟꠣꠇ ꠙꠣꠅꠀ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠇꠥꠘꠥ ꠙꠥꠠꠤ ꠎꠥꠖꠤ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠞꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠅꠄ, ꠔꠦ ꠔꠣꠁ ꠔ ꠛꠣꠚꠞ ꠈꠣꠘꠤꠞ ꠅꠋꠡ ꠙꠣꠁꠛ। “ꠁꠝꠣꠝ ꠙꠞꠤꠛꠣꠞꠞ ꠛꠣꠁꠞꠣ ꠇꠥꠘꠥ ꠎꠘꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠘꠥ ꠈꠣꠘꠤ ꠈꠣꠅꠀ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV22_14","004_22_14","LEV","22","14","14","ꠇꠦꠃ ꠎꠥꠖꠤ ꠜꠥꠟ ꠇꠞꠤꠀ ꠁꠔꠣ ꠈꠣꠁꠟꠣꠄ, ꠔꠦ ꠁ ꠎꠘꠦ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠅꠃ ꠈꠣꠘꠤꠞ ꠖꠣꠝꠞ ꠟꠉꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠖꠣꠝ ꠛꠦꠡꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV22_15","004_22_15","LEV","22","15","15","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣꠞ ꠎꠦ ꠎꠤꠘꠤꠡ ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠣꠘ ꠇꠞꠂꠘ, ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠎꠣꠘꠥ ꠁꠔꠣꠞꠦ ꠅꠙꠛꠤꠔ꠆ꠞ ꠘꠣ ꠛꠣꠘꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV22_16","004_22_16","LEV","22","16","16","ꠔꠣꠞꠣ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠁꠔꠣ ꠈꠣꠁꠔꠦ ꠖꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠡꠤ ꠛꠣꠘꠣꠁꠀ ꠈꠦꠔꠤ-ꠙꠥꠞꠘꠞ ꠖꠣꠠꠅ ꠎꠣꠘꠥ ꠘꠣ ꠚꠣꠟꠣꠁꠘ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦꠁ ꠔꠣꠞꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("LV22_17","004_22_17","LEV","22","17","17","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV22_18","004_22_18","LEV","22","18","18","“ꠔꠥꠝꠤ ꠉꠤꠀ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ, ꠔꠣꠞ ꠙꠥꠀꠂꠘ ꠀꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠇꠥꠘꠥ ꠎꠘꠦ ꠎꠥꠖꠤ ꠝꠣꠘ꠆ꠘꠔ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠣ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠘꠚꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥꠔꠣ ꠟꠁꠀ ꠀꠄ, ");
INSERT INTO syls_vpl VALUES ("LV22_19","004_22_19","LEV","22","19","19","ꠔꠦ ꠁꠇꠐꠣ ꠅꠁꠔꠦ ꠅꠁꠛ ꠄꠉꠥ ꠘꠤꠈꠥꠔ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣ ꠛꠣ ꠍꠣꠉꠟꠞ ꠙꠣꠑꠣ। ꠁꠟꠣ ꠘꠣ ꠅꠁꠟꠦ ꠔ ꠝꠣꠛꠥꠖꠦ ꠇꠛꠥꠟ ꠇꠞꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV22_20","004_22_20","LEV","22","20","20","ꠈꠥꠔ ꠀꠟꠣ ꠇꠥꠘꠥ ꠙꠡꠥꠖꠤ ꠎꠣꠘꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠘꠣ ꠇꠞꠦ, ꠇꠞꠟꠦꠅ ꠔꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV22_21","004_22_21","LEV","22","21","21","ꠇꠥꠘꠥ ꠝꠣꠘ꠆ꠘꠔ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠣ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠘꠚꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔ ꠌꠣꠄ, ꠔꠦ ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠘꠤꠈꠥꠔ ꠉꠞꠥ, ꠝꠦꠠꠣ ꠛꠣ ꠍꠣꠉꠟ ꠀꠘꠔꠦ ꠅꠁꠛ। ꠉꠔꠞꠅ ꠈꠥꠔ ꠀꠟꠣ ꠇꠥꠘꠥ ꠙꠡꠥꠖꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠦ ꠁꠔꠣ ꠇꠛꠥꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV22_22","004_22_22","LEV","22","22","22","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠣꠘꠥ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠀꠘ꠆ꠖꠣ, ꠟꠦꠋꠠꠣ, ꠇꠣꠐꠣ-ꠌꠤꠞꠣ, ꠇꠥꠘꠥ ꠅꠋꠉ ꠇꠣꠐꠣ, ꠙꠥꠎꠀꠟꠣ ꠊꠣ, ꠛꠣ ꠖꠣꠃꠖ-ꠈꠣꠃꠎꠟꠤ ꠇꠥꠘꠥ ꠙꠡꠥꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠘꠣ ꠀꠘꠦ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠅꠟꠣ ꠈꠥꠔ ꠀꠟꠣ ꠇꠥꠘꠥ ꠙꠡꠥꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠔꠥꠟꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV22_23","004_22_23","LEV","22","23","23","ꠔꠣ-ꠅ ꠙꠡꠥꠞ ꠇꠥꠘꠥ ꠅꠋꠉ ꠘꠤꠅꠝꠞ ꠛꠦꠡꠤ ꠟꠣꠝ꠆ꠛꠣ ꠛꠣ ꠛꠣꠐ꠆ꠐꠤ ꠕꠣꠇꠟꠦ, ꠅꠟꠣꠈꠣꠘ ꠙꠡꠥꠞꠦ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠘꠚꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠔꠣ ꠙꠣꠞꠛꠣ, ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘ꠆ꠘꠔ ꠙꠥꠞꠘꠞ ꠟꠣꠉꠤ ꠁꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠛꠥꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV22_24","004_22_24","LEV","22","24","24","ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠅꠘ꠆ꠒꠇꠥꠡ ꠎꠥꠖꠤ ꠕꠦꠔꠟꠣ, ꠍꠦꠌꠣ, ꠇꠣꠐꠣ-ꠌꠤꠞꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ ꠘꠣ, ꠘꠤꠎꠞ ꠖꠦꠡꠅ ꠉꠤꠀ ꠁꠟꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV22_25","004_22_25","LEV","22","25","25","ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠟꠣꠈꠣꠘ ꠙꠡꠥ ꠀꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ ꠘꠣ। ꠁꠔꠣꠞ ꠉꠔꠞꠅ ꠈꠥꠔ ꠕꠣꠇꠣꠄ ꠁꠔꠣꠖꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LV22_26","004_22_26","LEV","22","26","26","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV22_27","004_22_27","LEV","22","27","27","“ꠎꠘꠝꠞ ꠛꠣꠖ ꠕꠣꠇꠤ ꠡꠣꠔ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠞꠥ ꠛꠣ ꠍꠣꠉꠟ ꠛꠣ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠔꠣꠞ ꠝꠣʼꠞ ꠟꠉꠦ ꠞꠁꠔꠦ ꠖꠤꠛꠣꠄ। ꠀꠐ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠕꠣꠇꠤ ꠁꠔꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠦꠅꠀ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV22_28","004_22_28","LEV","22","28","28","ꠔꠣ-ꠅ ꠉꠣꠁ ꠀꠞ ꠔꠣꠁꠞ ꠛꠣꠍꠥꠞꠞꠦ, ꠝꠦꠠꠤ ꠛꠣ ꠍꠣꠉꠤ ꠀꠞ ꠔꠣꠁꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ, ꠄꠇꠁ ꠖꠤꠘꠦ ꠎꠛ ꠇꠞꠣ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV22_29","004_22_29","LEV","22","29","29","ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠘꠥ ꠡꠥꠇꠥꠞꠣꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠦ ꠌꠣꠁꠟꠦ, ꠁꠔꠣ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠀꠖꠣꠄ ꠇꠞꠤꠅ ꠎꠦꠟꠣ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV22_30","004_22_30","LEV","22","30","30","ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠈꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ, ꠁꠔꠣ ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠕꠅꠀ ꠢꠣꠞꠣꠝ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV22_31","004_22_31","LEV","22","31","31","“ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠅ ꠀꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠌꠟꠤꠅ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV22_32","004_22_32","LEV","22","32","32","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠘꠣꠝꠞꠦ ꠅꠡꠝ꠆ꠝꠣꠘ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠣꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠅꠁ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LV22_33","004_22_33","LEV","22","33","33","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠅꠀꠞ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠤ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("LV23_1","004_23_1","LEV","23","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV23_2","004_23_2","LEV","23","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠁꠖ ꠅꠇꠟ ꠑꠤꠇ ꠇꠞꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟꠞ ꠖꠤꠘ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV23_3","004_23_3","LEV","23","3","3","“ꠢꠣꠙ꠆ꠔꠣꠔ ꠍꠄ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ, ꠀꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠅꠁꠟ ꠎꠤꠞꠣꠁꠛꠣꠞ ꠖꠤꠘ, ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ। ꠁ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠛꠡꠔ ꠇꠞꠅ, ꠁ ꠖꠤꠘ ꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠛꠤꠔ꠆ꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_4","004_23_4","LEV","23","4","4","“ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠑꠤꠇ ꠇꠞꠣ ꠎꠔ ꠁꠖ ꠀꠍꠦ, ꠝꠣꠘꠤ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟꠞ ꠖꠤꠘ ꠢꠤꠡꠣꠛꠦ ꠎꠦꠔꠣ ꠝꠣꠘꠔꠣꠄ, ꠁꠔꠣ ꠀꠝꠤ ꠇꠁꠞꠣꠝ। ꠁꠔꠣ ꠅꠁꠟ: ");
INSERT INTO syls_vpl VALUES ("LV23_5","004_23_5","LEV","23","5","5","“ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠞ ꠌꠃꠖ꠆ꠖ ꠔꠣꠞꠤꠈꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠞꠝ꠆ꠛ ꠅꠁꠛ, ");
INSERT INTO syls_vpl VALUES ("LV23_6","004_23_6","LEV","23","6","6","ꠀꠞ ꠅꠃ ꠌꠣꠘ꠆ꠖꠞ ꠙꠘꠞ ꠔꠣꠞꠤꠈꠅ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖ ꠀꠞꠝ꠆ꠛ ꠅꠁꠛ। ꠙꠥꠞꠣ ꠡꠣꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV23_7","004_23_7","LEV","23","7","7","ꠅꠃ ꠡꠣꠔ ꠖꠤꠘꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠅꠁꠛ, ꠅꠃ ꠖꠤꠘ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV23_8","004_23_8","LEV","23","8","8","ꠅꠃ ꠡꠣꠔ ꠖꠤꠘꠞ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ꠛꠣꠖꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠅꠁꠛ, ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣ ꠢꠣꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LV23_9","004_23_9","LEV","23","9","9","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV23_10","004_23_10","LEV","23","10","10","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠅꠇꠟꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠞꠣꠝ, ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠔꠛꠣꠞ ꠎꠝꠤꠘꠞ ꠚꠡꠟ ꠖꠣꠁꠛꠣꠄ, ꠅꠔꠛꠣꠞ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠇꠣꠐꠣ ꠄꠇꠈꠣꠘ ꠝꠥꠁꠐ ꠟꠁꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_11","004_23_11","LEV","23","11","11","ꠉꠦꠟꠦ ꠁꠝꠣꠝꠦ ꠅꠃ ꠝꠥꠁꠐ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠖꠥꠟꠣꠁꠛꠣ। ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠛꠣꠖꠞ ꠖꠤꠘ ꠔꠣꠁꠘ ꠁꠈꠣꠘ ꠖꠥꠟꠣꠁꠛꠣ, ꠔꠦꠃ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠤ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV23_12","004_23_12","LEV","23","12","12","ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠎꠦꠖꠤꠘ ꠅꠃ ꠝꠥꠁꠐ ꠖꠥꠟꠣꠁꠛꠣ, ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV23_13","004_23_13","LEV","23","13","13","ꠄꠞꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠌꠣꠁꠞ ꠡꠦꠞ ꠝꠄꠖꠣ ꠖꠤꠛꠣꠄ। ꠁꠔꠣ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠍꠖꠉꠣ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠋꠉꠥꠞꠞ ꠄꠇ ꠡꠦꠞ ꠡꠞꠛꠔꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV23_14","004_23_14","LEV","23","14","14","ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠡꠟ ꠖꠣꠁꠀ ꠢꠣꠞꠤ, ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠞ ꠅꠃ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠄꠀ ꠚꠡꠟ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ। ꠁꠔꠣꠖꠤ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠁꠀ ꠛꠣ ꠀꠉꠥꠘꠤꠔ ꠜꠣꠎꠤꠀ ꠈꠣꠅꠀꠅ ꠘꠤꠡꠦꠗ। ꠔꠥꠝꠞꠣ ꠎꠦꠘꠅꠃ ꠞꠅ ꠘꠣ ꠇꠦꠘꠦ, ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠌꠤꠞꠇꠣꠟ ꠅꠃ ꠘꠤꠅꠝ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_15","004_23_15","LEV","23","15","15","“ꠀꠞ ꠅꠃ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠛꠣꠖꠞ ꠖꠤꠘ, ꠝꠣꠘꠤ ꠎꠦꠖꠤꠘ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠟꠣꠉꠤ ꠚꠡꠟꠞ ꠝꠥꠁꠐ ꠟꠁꠀ ꠀꠁꠛꠣꠄ, ꠅꠃ ꠖꠤꠘ ꠕꠣꠇꠤ ꠡꠣꠔ ꠢꠣꠙ꠆ꠔꠣꠄ ꠡꠣꠔ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠉꠘꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV23_16","004_23_16","LEV","23","16","16","ꠅꠃ ꠡꠣꠔ ꠎꠥꠝ꠆ꠝꠣꠞ ꠛꠣꠖꠞ ꠖꠤꠘ, ꠝꠣꠘꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠘꠄꠀ ꠚꠡꠟꠞ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV23_17","004_23_17","LEV","23","17","17","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠛꠣꠠꠤ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠚꠡꠟ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠚꠡꠟ ꠀꠘꠤꠅ। ꠔꠥꠝꠞꠣ ꠌꠣꠁꠞ ꠡꠦꠞ ꠝꠄꠖꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠈꠣꠝꠤꠞ ꠙꠥꠞꠣꠁꠟ ꠖꠥꠈꠣꠘ ꠘꠣꠘ ꠞꠥꠐꠤ ꠀꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_18","004_23_18","LEV","23","18","18","ꠅꠃ ꠞꠥꠐꠤꠞ ꠟꠉꠦ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠡꠣꠔꠐꠣ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣꠞ ꠖꠥꠁꠐꠣ ꠙꠣꠑꠣ ꠀꠘꠤꠅ। ꠅꠃ ꠙꠡꠥ ꠅꠇꠟ ꠖꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠄꠇꠈꠣꠘ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ, ꠅꠔꠣꠞ ꠟꠉꠦ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ꠁꠔꠣ ꠔ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠄꠇ ꠘꠝꠥꠘꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LV23_19","004_23_19","LEV","23","19","19","ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟ, ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠖꠥꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV23_20","004_23_20","LEV","23","20","20","ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠖꠥꠁꠅ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠞ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠚꠡꠟꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠞꠥꠐꠤ ꠘꠤꠀ ꠖꠥꠟꠣꠁꠛꠣ। ꠁꠔꠣ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠍꠣꠝꠣꠘꠣ, ꠁꠔꠣ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠙꠣꠅꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV23_21","004_23_21","LEV","23","21","21","ꠈꠦꠔꠞ ꠚꠡꠟ ꠖꠣꠅꠀꠞ ꠅꠃ ꠁꠖꠞ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠄꠇꠐꠣ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠤꠅ। ꠅꠃ ꠖꠤꠘ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠎꠦꠘꠅꠃ ꠞꠅ ꠘꠣ ꠇꠦꠘꠦ, ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_22","004_23_22","LEV","23","22","22","“ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠈꠦꠔꠞ ꠚꠡꠟ ꠖꠣꠁꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠎꠝꠤꠘꠞ ꠀꠁꠟꠞ ꠇꠣꠘ꠆ꠖꠣꠞ ꠚꠡꠟ ꠍꠣꠚ ꠇꠞꠤꠀ ꠇꠣꠐꠤꠅ ꠘꠣ, ꠀꠞ ꠖꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠅꠃ ꠎꠝꠤꠘꠅ ꠚꠣꠟꠣꠁꠟ ꠚꠡꠟ ꠟꠥꠞꠤꠅ ꠘꠣ। ꠉꠞꠤꠛ-ꠖꠥꠈꠤ ꠀꠞ ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠕꠁꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("LV23_23","004_23_23","LEV","23","23","23","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV23_24","004_23_24","LEV","23","24","24","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠛꠍꠞꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘꠞꠦ ꠔꠥꠝꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠤꠞꠣꠘꠤꠞ ꠖꠤꠘ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠤꠅ। ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠁꠅ ꠀꠞ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠁꠖꠞ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_25","004_23_25","LEV","23","25","25","ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ, ꠈꠣꠟꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LV23_26","004_23_26","LEV","23","26","26","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV23_27","004_23_27","LEV","23","27","27","“ꠅꠃ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠖꠡ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠅꠁꠟ ꠇꠚꠞꠣꠞ ꠁꠖꠞ ꠖꠤꠘ। ꠁ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠄꠇꠐꠣ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠤꠅ। ꠙꠞꠔꠦꠇ ꠎꠘꠦ ꠘꠔ ꠅꠁꠀ ꠎꠣꠞꠎꠤꠞ ꠖꠤꠟ ꠡꠙꠤꠀ ꠖꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_28","004_23_28","LEV","23","28","28","ꠁꠔꠣ ꠅꠁꠟ ꠇꠚꠞꠣꠞ ꠁꠖ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠛ, ꠀꠡ꠆ꠔꠣ ꠁ ꠖꠤꠘꠅ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV23_29","004_23_29","LEV","23","29","29","ꠎꠦ ꠝꠣꠘꠡꠦ ꠢꠃ ꠖꠤꠘ ꠘꠔ ꠅꠁꠀ ꠘꠤꠎꠞ ꠖꠤꠟ ꠡꠙꠤꠀ ꠘꠣ ꠖꠦꠄ, ꠔꠣꠞ ꠘꠣꠝ ꠁ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV23_30","004_23_30","LEV","23","30","30","ꠀꠞ ꠢꠃ ꠖꠤꠘ ꠎꠥꠖꠤ ꠇꠦꠃ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞ ꠘꠣꠝ ꠀꠝꠤ ꠁ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠡꠦꠡ ꠇꠞꠤꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV23_31","004_23_31","LEV","23","31","31","ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠎꠦꠘꠅꠃ ꠞꠅ ꠘꠣ ꠇꠦꠘꠦ, ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠅꠃ ꠘꠤꠅꠝ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_32","004_23_32","LEV","23","32","32","ꠅꠃ ꠖꠤꠘ ꠅꠁꠛ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠛꠤꠔ꠆ꠞ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ, ꠄꠞꠟꠣꠉꠤ ꠘꠔ ꠅꠁꠀ ꠖꠤꠟ ꠡꠙꠤꠀ ꠖꠤꠅ। ꠅꠃ ꠌꠣꠘ꠆ꠖꠞ ꠘꠄ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠕꠣꠇꠤ ꠛꠣꠖꠞ ꠖꠤꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠙꠛꠤꠔ꠆ꠞ ꠅꠃ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠝꠣꠘꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LV23_33","004_23_33","LEV","23","33","33","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV23_34","004_23_34","LEV","23","34","34","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠅꠃ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠘꠞ ꠔꠣꠞꠤꠈ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠒꠦꠞꠣ-ꠊꠞꠞ ꠁꠖ ꠀꠞꠝ꠆ꠛ ꠅꠁꠀ, ꠡꠣꠔ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠖ ꠌꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("LV23_35","004_23_35","LEV","23","35","35","ꠅꠃ ꠡꠣꠔ ꠖꠤꠘꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠅꠁꠛ। ꠁ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV23_36","004_23_36","LEV","23","36","36","ꠅꠃ ꠁꠖꠞ ꠡꠣꠔꠅ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ꠛꠣꠖꠦ ꠀꠐ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠔꠥꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠛꠣꠄ ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ꠁꠐꠣ ꠅꠁꠟ ꠡꠦꠡ ꠖꠤꠘꠞ ꠀꠈꠦꠞꠤ ꠝꠣꠢꠚꠤꠟ, ꠅꠃ ꠖꠤꠘꠅ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV23_37","004_23_37","LEV","23","37","37","“ꠀꠡ꠆ꠔꠣ ꠛꠍꠞꠞ ꠝꠣꠎꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠁꠖ ꠀꠍꠦ, ꠅꠔꠣ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠁꠖ ꠅꠇꠟ ꠔ ꠝꠣꠛꠥꠖꠦꠃ ꠗꠣꠁꠞ꠆ꠎ ꠇꠞꠤ ꠖꠤꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠁꠖꠞ ꠅꠃ ꠖꠤꠘ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟꠞ ꠖꠤꠘ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠤꠅ, ꠄꠞ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠁꠔꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠝꠣꠘꠤ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ। ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠇꠟ ꠀꠟ꠆ꠟꠣꠞ ꠗꠣꠁꠞ꠆ꠎ ꠇꠞꠣ ꠖꠤꠘꠅ ꠔꠥꠝꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_38","004_23_38","LEV","23","38","38","ꠅꠁꠟꠦ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠔꠣꠁꠟ ꠅꠔꠣ ꠢꠇ꠆ꠇꠟ ꠟꠣꠈꠣꠘ ꠁꠖ ꠅꠇꠟꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣꠞꠦ ꠀꠖꠣꠄ ꠇꠞꠤꠀ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ, ꠝꠣꠘ꠆ꠘꠔ ꠀꠞ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠖꠦꠅꠀ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞꠦꠅ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠢꠔꠣ ꠁꠖ ꠅꠇꠟꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠉꠦ ꠁꠔꠣꠞꠦ ꠝꠤꠟꠣꠁꠅ ꠘꠣ, ꠀꠟꠣꠖꠣ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_39","004_23_39","LEV","23","39","39","“ꠀꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠘꠞ ꠔꠣꠞꠤꠈꠅ, ꠈꠦꠔꠞ ꠢꠇꠟ ꠚꠟ-ꠚꠡꠟ ꠔꠥꠟꠣꠞ ꠛꠣꠖꠦ, ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠡꠣꠔ ꠖꠤꠘ ꠗꠞꠤꠀ ꠒꠦꠞꠣ-ꠊꠞꠞ ꠅꠃ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠅꠃ ꠡꠣꠔ ꠖꠤꠘꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠀꠞ ꠡꠦꠡꠞ ꠀꠐ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠤꠞꠣꠁꠛꠣꠞ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("LV23_40","004_23_40","LEV","23","40","40","ꠄꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠔꠞꠔꠣꠎꠣ ꠉꠣꠍꠞ ꠒꠣꠟ ꠙꠣꠟꠣ, ꠝꠣꠘꠤ ꠈꠦꠎꠥꠞ ꠙꠣꠔꠣ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠙꠣꠔꠣ-ꠛꠣꠢꠣꠞ ꠉꠣꠍꠞ ꠒꠣꠟ ꠙꠣꠟꠣ, ꠀꠞ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠞ ꠁꠎꠟ ꠉꠣꠍꠞ ꠒꠣꠟ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠅ। ꠅꠁꠀ ꠅꠃ ꠡꠣꠔꠅ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_41","004_23_41","LEV","23","41","41","ꠙꠞꠔꠦꠇ ꠛꠍꠞꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠡꠣꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠁ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠁꠔꠣ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_42","004_23_42","LEV","23","42","42","ꠙꠥꠞꠣ ꠡꠣꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠉꠤꠀ ꠒꠦꠞꠣ-ꠊꠞꠅ ꠞꠁꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠅꠃ ꠡꠝꠄ ꠒꠦꠞꠣ-ꠊꠞꠅ ꠕꠣꠇꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV23_43","004_23_43","LEV","23","43","43","ꠔꠦꠃ ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦꠅ ꠛꠥꠎꠛꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠤꠀ ꠢꠣꠞꠟꠦ ꠀꠝꠤ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣꠞꠦ ꠅꠟꠣ ꠒꠦꠞꠣ-ꠊꠞꠅ ꠛꠡꠔ ꠇꠞꠣꠁꠍꠟꠣꠝ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("LV23_44","004_23_44","LEV","23","44","44","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠔꠣꠁꠟ ꠅꠃ ꠢꠇꠟ ꠁꠖꠞ ꠇꠕꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV24_1","004_24_1","LEV","24","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV24_2","004_24_2","LEV","24","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠅ, ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠌꠦꠞꠣꠉ ꠅꠇꠟ ꠢꠣꠝꠦꠡꠣ ꠎꠣꠟꠣꠁꠀ ꠞꠣꠈꠣꠞ ꠘꠤꠅꠔꠦ, ꠔꠣꠞꠣ ꠎꠄꠔꠥꠘ ꠍꠦꠌꠤꠀ ꠈꠣꠐꠤ ꠔꠦꠟ ꠛꠣꠘꠣꠁꠀ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("LV24_3","004_24_3","LEV","24","3","3","ꠀꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠙꠞ꠆ꠖꠣꠞ ꠛꠣꠞꠦ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠕꠣꠇꠤ ꠚꠎꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠌꠦꠞꠣꠉ ꠅꠇꠟ ꠎꠣꠟꠣꠁ ꠞꠣꠈꠛꠣ। ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠁꠔꠣ ꠎꠣꠞꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV24_4","004_24_4","LEV","24","4","4","ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠅꠀ ꠅꠃ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠞ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠌꠦꠞꠣꠉ ꠅꠇꠟꠞꠦ ꠔꠣꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠎꠣꠄ-ꠎꠔꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV24_5","004_24_5","LEV","24","5","5","“ꠀꠞ ꠢꠥꠘꠅ, ꠝꠄꠖꠣ ꠖꠤꠀ ꠛꠣꠞꠅ ꠈꠣꠘ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠁꠅ, ꠙꠞꠔꠦꠇ ꠞꠥꠐꠤ ꠅꠁꠛ ꠖꠥꠁ ꠡꠦꠞ ꠝꠄꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LV24_6","004_24_6","LEV","24","6","6","ꠛꠣꠘꠣꠁꠀ ꠅꠃ ꠞꠥꠐꠤꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠞ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠞ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠍꠄꠈꠣꠘ ꠍꠄꠈꠣꠘ ꠇꠞꠤ ꠖꠥꠁ ꠟꠣꠁꠘꠦ ꠢꠣꠎꠣꠁ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV24_7","004_24_7","LEV","24","7","7","ꠙꠞꠔꠦꠇ ꠟꠣꠁꠘꠞ ꠞꠥꠐꠤꠞ ꠗꠣꠞꠅ ꠈꠣꠐꠤ ꠟꠥꠛꠣꠘ-ꠀꠉꠞ ꠕꠁꠅ। ꠕꠁꠀ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠞꠥꠐꠤꠞ ꠛꠖꠟꠣ ꠅꠃ ꠀꠉꠞꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV24_8","004_24_8","LEV","24","8","8","ꠙꠞꠔꠦꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠇ꠆ꠇ ꠕꠣꠇꠤ ꠙꠛꠤꠔ꠆ꠞ ꠅꠃ ꠞꠥꠐꠤꠞꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞꠞ ꠍꠣꠝꠘꠦ ꠢꠣꠎꠣꠁꠀ ꠕꠁꠛꠣ। ꠔꠣꠞꠣꠞ ꠅꠃ ꠞꠥꠐꠤ ꠖꠦꠅꠀ ꠔ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV24_9","004_24_9","LEV","24","9","9","ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠛꠋꠡꠗꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠜꠤꠔꠞꠦ ꠅꠃ ꠞꠥꠐꠤ ꠈꠣꠁꠛꠣ, ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠤꠘꠤꠡꠞ ꠝꠣꠎꠦ ꠄꠇ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ। ꠁꠔꠣ ꠔ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠙꠣꠅꠘꠣ, ꠅꠃ ꠘꠤꠅꠝ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠣꠞꠤ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LV24_10","004_24_10","LEV","24","10","10","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠅꠟꠣ ꠄꠇ ꠛꠦꠐꠣ ꠀꠍꠤꠟ, ꠎꠦꠉꠥꠞ ꠛꠣꠚ ꠅꠁꠟ ꠝꠤꠡꠞꠤ ꠀꠞ ꠝꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞ। ꠁ ꠛꠦꠐꠣꠄ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠞꠇ ꠛꠦꠐꠣꠄ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠝꠣꠞꠣ-ꠝꠣꠞꠤ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("LV24_11","004_24_11","LEV","24","11","11","ꠅꠃ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠤ ꠛꠦꠐꠤꠞ ꠙꠥꠀꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠀ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠟ। ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠅꠃ ꠛꠦꠐꠣꠞ ꠝꠣʼꠞ ꠘꠣꠝ ꠡꠣꠟꠥꠝꠤ, ꠔꠣꠁ ꠀꠍꠤꠟ ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠖꠤꠛꠞꠤꠞ ꠙꠥꠠꠤ। ");
INSERT INTO syls_vpl VALUES ("LV24_12","004_24_12","LEV","24","12","12","ꠀꠞ ꠝꠣꠘꠡꠦ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠝꠞ꠆ꠎꠤ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠀꠐꠇꠣꠁꠀ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV24_13","004_24_13","LEV","24","13","13","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV24_14","004_24_14","LEV","24","14","14","“ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠦꠅꠞꠣ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠟꠁꠀ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠎꠣꠅ। ꠉꠦꠟꠦ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠅꠃ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠢꠥꠘꠍꠦ, ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠅꠉꠥꠞ ꠝꠣꠕꠣ ꠀꠔꠣꠁ ꠖꠦꠃꠇ, ꠛꠣꠖꠦ ꠡꠝꠣꠎꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LV24_15","004_24_15","LEV","24","15","15","ꠀꠞ ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠦꠄ, ꠔꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠦ ꠘꠤꠎꠦꠃ ꠖꠣꠄꠁ। ");
INSERT INTO syls_vpl VALUES ("LV24_16","004_24_16","LEV","24","16","16","ꠀꠞ ꠎꠦ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠛ, ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠝꠣꠎꠦ ꠔꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣ। ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠤ ꠅꠃꠇ ꠛꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ ꠅꠃꠇ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠎꠦꠉꠤꠄ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠛ, ꠔꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV24_17","004_24_17","LEV","24","17","17","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠖꠥꠍꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠦꠅ ꠈꠥꠘ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV24_18","004_24_18","LEV","24","18","18","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠖꠥꠍꠞꠣ ꠝꠣꠘꠡꠞ ꠇꠥꠘꠥ ꠙꠡꠥꠞꠦ ꠝꠣꠞꠤꠟꠣꠄ, ꠔꠦ ꠅꠉꠥꠞ ꠛꠖꠟꠣ ꠢꠦ ꠀꠞꠇ ꠙꠡꠥꠞ ꠖꠣꠝ ꠖꠤꠀ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠛ। ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠎꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("LV24_19","004_24_19","LEV","24","19","19","ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠞꠇ ꠎꠘꠞꠦ ꠝꠣꠞꠦ, ꠀꠞ ꠅꠃ ꠝꠣꠁꠞꠞ ꠟꠣꠉꠤ ꠡꠞꠤꠟꠞ ꠇꠥꠘꠥ ꠅꠋꠉꠞ ꠈꠦꠔꠤ ꠅꠄ, ꠔꠦ ꠢꠦ ꠎꠦꠟꠣ ꠈꠦꠔꠤ ꠇꠞꠍꠦ, ꠔꠣꠞ ꠅꠋꠉꠞꠦꠅ ꠅꠟꠣ ꠈꠦꠔꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV24_20","004_24_20","LEV","24","20","20","ꠀꠒ꠆ꠒꠤ ꠜꠣꠋꠉꠣꠞ ꠛꠖꠟꠣ ꠀꠒ꠆ꠒꠤ ꠜꠣꠋꠉꠤꠛꠣꠄ, ꠌꠃꠈꠞ ꠛꠖꠟꠣ ꠌꠃꠈ, ꠖꠣꠔꠞ ꠛꠖꠟꠣ ꠖꠣꠔ। ꠢꠃ ꠎꠘꠞ ꠎꠦ ꠅꠋꠉꠞꠦ ꠢꠦ ꠈꠦꠔꠤ ꠇꠞꠍꠦ, ꠔꠣꠞꠅ ꠅꠟꠣ ꠈꠦꠔꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV24_21","004_24_21","LEV","24","21","21","ꠇꠥꠘꠥ ꠙꠡꠥꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠟꠦ ꠄꠞ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡꠞꠦ ꠈꠥꠘ ꠇꠞꠟꠦ ꠔꠣꠞꠦꠃ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV24_22","004_24_22","LEV","24","22","22","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠅꠃ ꠄꠇꠁ ꠀꠁꠘ ꠎꠣꠞꠤ ꠞꠁꠛ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("LV24_23","004_24_23","LEV","24","23","23","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ꠔꠦꠃ ꠎꠦ ꠛꠦꠐꠣꠄ ꠢꠃ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔꠤꠍꠤꠟ, ꠝꠣꠘꠡꠦ ꠅꠉꠥꠞꠦ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠑꠤꠇ ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_1","004_25_1","LEV","25","1","1","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV25_2","004_25_2","LEV","25","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠀꠝꠤ ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠀꠞ, ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠢꠘꠞ ꠎꠝꠤ-ꠝꠣꠐꠤꠄ ꠎꠣꠘꠥ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠞꠣꠝ ꠇꠞꠣꠞ ꠡꠝꠄ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV25_3","004_25_3","LEV","25","3","3","ꠔꠥꠝꠞꠣ ꠍꠄ ꠛꠍꠞ ꠎꠝꠤꠘꠅ ꠈꠦꠔ-ꠈꠣꠝꠣꠞ ꠇꠞꠤꠅ, ꠀꠋꠉꠥꠞ ꠉꠣꠍꠞ ꠒꠣꠟ ꠙꠣꠟꠣ ꠍꠣꠐꠤꠀ ꠚꠄ-ꠚꠡꠟ ꠛꠣꠠꠤꠔ ꠀꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV25_4","004_25_4","LEV","25","4","4","ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞ ꠎꠝꠤ-ꠎꠝꠣꠞꠦ ꠎꠤꠞꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠅ। ꠁꠐꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠘꠤꠅꠔꠦ ꠀꠞꠣꠝꠞ ꠛꠍꠞ। ꠅꠃ ꠛꠍꠞ ꠔꠥꠝꠞꠣ ꠎꠝꠤꠘꠅ ꠈꠦꠔ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠋꠉꠥꠞ ꠉꠣꠍꠞ ꠒꠣꠟ ꠙꠣꠟꠣ ꠍꠣꠐꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_5","004_25_5","LEV","25","5","5","ꠀꠞ ꠎꠝꠤꠘꠞ ꠝꠣꠎꠦ ꠄꠝꠘꠦꠃ ꠎꠦꠔꠣ ꠚꠟꠤꠛ, ꠁꠔꠣ ꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠃꠉꠣꠞꠅ ꠕꠁꠅ ꠘꠣ। ꠛꠤꠘꠣ ꠎꠔꠘꠦ ꠀꠋꠉꠥꠞ ꠉꠣꠍꠅ ꠎꠦꠔꠣ ꠚꠟ ꠗꠞꠛ, ꠁꠔꠣ ꠙꠣꠠꠤꠀ ꠘꠤꠀ ꠎꠝꠣꠁꠅ ꠘꠣ। ꠢꠇꠟ ꠎꠝꠤ-ꠎꠝꠣꠞꠦ ꠙꠥꠞꠣ ꠄꠇ ꠛꠍꠞ ꠎꠤꠞꠣꠘꠤꠞ ꠡꠝꠄ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV25_6","004_25_6","LEV","25","6","6","ꠎꠤꠞꠣꠘꠤꠞ ꠛꠍꠞ ꠎꠝꠤꠘꠅ ꠄꠝꠘꠦ ꠎꠦꠔꠣ ꠚꠟꠤꠛ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ, ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤꠞ, ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ, ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎꠞ ꠝꠦꠘꠔꠤ ꠇꠣꠝꠟꠣ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠝꠣꠘꠡꠞ, ");
INSERT INTO syls_vpl VALUES ("LV25_7","004_25_7","LEV","25","7","7","ꠔꠥꠝꠞꠣꠞ ꠙꠣꠟꠣ ꠢꠦꠝꠣꠘ, ꠀꠞ ꠖꠦꠡꠞ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇ ꠅꠁꠛ। ꠅꠃ ꠛꠍꠞ ꠎꠝꠤꠘꠅ ꠄꠝꠘꠦ ꠎꠦꠔꠣ ꠚꠟꠤꠛ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV25_8","004_25_8","LEV","25","8","8","“ꠀꠞ ꠢꠥꠘꠅ, ꠡꠣꠔ ꠛꠍꠞ ꠇꠞꠤ ꠇꠞꠤ ꠡꠣꠔꠈꠣꠘ ꠎꠤꠞꠣꠘꠤꠞ ꠛꠍꠞꠞꠦ ꠔꠥꠝꠞꠣ ꠉꠘꠤꠅ, ꠉꠘꠤꠟꠦ ꠡꠣꠔꠛꠣꠞ ꠡꠣꠔ ꠛꠍꠞꠦ ꠃꠘꠥꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_9","004_25_9","LEV","25","9","9","ꠄꠞ ꠛꠣꠖꠞ ꠛꠍꠞ, ꠝꠣꠘꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞ, ꠅꠃ ꠛꠍꠞꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠖꠡ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ, ꠁꠔꠣ ꠔ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠖꠤꠘ, ꠢꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV25_10","004_25_10","LEV","25","10","10","ꠅꠃ ꠙꠁꠘ꠆ꠌꠣꠡ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞꠞꠦ ꠔꠥꠝꠞꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠣꠘꠤꠅ, ꠖꠦꠡꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠀꠎꠣꠖꠤꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠅ। ꠁ ꠛꠍꠞ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞ। ꠅꠃ ꠛꠍꠞ ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠙꠞꠤꠛꠣꠞ ꠀꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠚꠤꠞꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV25_11","004_25_11","LEV","25","11","11","ꠙꠞꠔꠦꠇ ꠙꠁꠘ꠆ꠌꠣꠡ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞ ꠅꠁꠛ, ꠔꠥꠝꠞꠣꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞ। ꠅꠃ ꠛꠍꠞ ꠔꠥꠝꠞꠣ ꠎꠝꠤꠘꠅ ꠇꠥꠘꠥ ꠛꠤꠌꠤ ꠛꠣꠁꠘ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠝꠤꠘꠅ ꠄꠝꠘꠦꠃ ꠎꠦꠔꠣ ꠎꠘꠝꠤꠛ ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠘꠤꠅ ꠘꠣ। ꠀꠞ ꠛꠤꠘꠣ ꠎꠔꠘꠦ ꠀꠋꠉꠥꠞ ꠉꠣꠍꠅ ꠎꠦꠔꠣ ꠚꠟ ꠗꠞꠛ, ꠁꠔꠣꠅ ꠔꠥꠝꠞꠣ ꠊꠞꠅ ꠀꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_12","004_25_12","LEV","25","12","12","ꠅꠃ ꠛꠍꠞ ꠅꠁꠟ ꠚꠤꠞꠔ ꠙꠣꠁꠛꠣꠞ ꠛꠍꠞ। ꠔꠥꠝꠞꠣ ꠅꠃ ꠛꠍꠞꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠤꠅ। ꠎꠝꠤꠘꠅ ꠎꠦꠔꠣ ꠚꠡꠟ ꠙꠣꠁꠛꠣꠄ, ꠅꠔꠣꠃ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV25_13","004_25_13","LEV","25","13","13","“ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞꠅ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠎꠣꠞꠎꠤꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡꠅ ꠚꠤꠞꠤꠀ ꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LV25_14","004_25_14","LEV","25","14","14","ꠘꠤꠎꠞ ꠎꠝꠤ-ꠎꠝꠣ ꠈꠞꠤꠖ-ꠛꠤꠇꠤꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠀꠙꠘ ꠛꠣ ꠙꠞ ꠇꠦꠃꠞꠞ ꠃꠙꠞꠦ ꠎꠥꠞ-ꠎꠛꠞꠖꠡ꠆ꠔꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_15","004_25_15","LEV","25","15","15","ꠎꠝꠤ ꠈꠞꠤꠖ ꠇꠞꠣꠞ ꠡꠝꠄ ꠈꠞꠤꠖ-ꠛꠤꠇꠤ ꠇꠞꠞꠣ ꠖꠥꠁꠅ ꠎꠘꠦ ꠈꠤꠀꠟ ꠞꠣꠈꠛꠣꠄ, ꠚꠤꠞꠔ ꠀꠅꠀꠞ ꠢꠃ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠛꠣꠖꠦ ꠇꠔꠖꠤꠘ ꠉꠦꠍꠦꠉꠤ, ꠀꠞ ꠍꠣꠝꠘꠞ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠙꠥꠞꠔꠦ ꠇꠔꠖꠤꠘ ꠛꠣꠇꠤ ꠀꠍꠦ, ꠅꠈꠣꠘ ꠢꠤꠡꠣꠛ ꠇꠞꠤꠀ ꠎꠝꠤꠘꠞ ꠖꠞꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV25_16","004_25_16","LEV","25","16","16","ꠎꠥꠖꠤ ꠛꠦꠡꠤ ꠛꠍꠞ ꠚꠡꠟ ꠙꠣꠅꠀꠞ ꠡꠝꠄ ꠕꠣꠇꠦ ꠔꠦ ꠖꠣꠝꠅ ꠛꠦꠡꠤ ꠅꠁꠛ, ꠀꠞ ꠇꠝ ꠅꠁꠟꠦ ꠖꠣꠝꠅ ꠇꠝꠛ। ꠀꠍꠟꠦ ꠚꠡꠟ ꠙꠣꠅꠀꠞ ꠛꠍꠞꠞ ꠃꠙꠞꠦꠃ ꠈꠞꠤꠖ-ꠛꠤꠇꠤꠞ ꠖꠣꠝ ꠑꠤꠇ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_17","004_25_17","LEV","25","17","17","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠡꠝꠣꠎꠞ ꠇꠦꠃꠞꠞ ꠃꠙꠞꠦ ꠎꠥꠞ-ꠎꠥꠟꠥꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠙꠞꠔꠦꠇ ꠎꠘꠃ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚꠦ ꠌꠟꠤꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV25_18","004_25_18","LEV","25","18","18","“ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠡꠞꠤꠅꠔ ꠀꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠢꠣꠝꠦꠡꠣ ꠝꠣꠘꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡ ꠅꠁꠛ ꠘꠤꠞꠣꠙꠖ ꠛꠡꠔ ꠈꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_19","004_25_19","LEV","25","19","19","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠚꠡꠟ ꠙꠣꠁꠛꠣꠄ, ꠙꠣꠁꠀ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠁꠀ ꠖꠣꠁꠀ ꠢꠘꠅ ꠘꠤꠞꠣꠙꠖꠦ ꠛꠡꠔ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV25_20","004_25_20","LEV","25","20","20","ꠔꠥꠝꠞꠣ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠔꠣꠄ ꠙꠣꠞ, ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞꠅ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠈꠦꠔ ꠘꠣ ꠇꠞꠤ ꠀꠞ ꠚꠡꠟ ꠘꠣ ꠇꠣꠐꠤ, ꠔꠦ ꠀꠝꠞꠣ ꠈꠣꠁꠝꠥ ꠇꠤꠔꠣ? ");
INSERT INTO syls_vpl VALUES ("LV25_21","004_25_21","LEV","25","21","21","ꠄꠞ ꠎꠥꠀꠙ ꠅꠁꠟ, ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞꠅ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠎꠝꠤꠘꠅ ꠅꠟꠣ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠝꠥ, ꠎꠝꠤꠘꠅ ꠔꠤꠘ ꠛꠍꠞꠞ ꠢꠝꠣꠘ ꠚꠡꠟ ꠙꠣꠁꠀ ꠈꠣꠁꠀ-ꠚꠤꠘ꠆ꠖꠤꠀ ꠛꠣꠌꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV25_22","004_25_22","LEV","25","22","22","ꠄꠞꠟꠣꠉꠤ ꠀꠐ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞꠅ ꠈꠦꠔ ꠇꠞꠣꠞ ꠛꠤꠌ ꠛꠣꠁꠘ ꠖꠦꠅꠀꠞ ꠡꠝꠄꠅ ꠅꠃ ꠙꠥꠞꠣꠘꠣ ꠚꠡꠟ ꠈꠣꠁꠛꠣꠄ, ꠀꠞ ꠘꠄ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞꠞ ꠚꠡꠟ ꠖꠣꠁꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠚꠡꠟꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠌꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_23","004_25_23","LEV","25","23","23","“ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠇꠦꠃꠞꠞ ꠎꠝꠤ-ꠎꠝꠣ ꠈꠞꠤꠖ-ꠛꠤꠇꠤ ꠌꠟꠔ ꠘꠣꠄ। ꠀꠍꠟꠦ ꠢꠇꠟ ꠎꠝꠤꠘꠞ ꠝꠣꠟꠤꠇ ꠔ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠢꠘꠅ ꠈꠣꠟꠤ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ। ");
INSERT INTO syls_vpl VALUES ("LV25_24","004_25_24","LEV","25","24","24","ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠞ ꠈꠞꠤꠖꠣ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠛꠤꠇꠤꠖꠣꠞꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠚꠤꠞꠔ ꠘꠤꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV25_25","004_25_25","LEV","25","25","25","ꠔꠥꠝꠞꠣꠞ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠜꠣꠁ ꠅꠜꠣꠛꠅ ꠙꠠꠤꠀ ꠎꠥꠖꠤ ꠔꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠎꠝꠤꠘꠞ ꠇꠤꠍꠥ ꠅꠋꠡ ꠛꠦꠌꠤꠟꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠀꠙꠘ ꠎꠘꠦ ꠀꠁꠀ ꠅꠃ ꠛꠦꠌꠣ ꠎꠝꠤ ꠍꠣꠠꠣꠁꠀ ꠘꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_26","004_25_26","LEV","25","26","26","ꠇꠦꠃꠞꠞ ꠎꠥꠖꠤ ꠍꠣꠠꠣꠁꠀ ꠘꠤꠛꠣꠞ ꠝꠣꠘꠥꠡ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠢꠦ ꠘꠤꠎꠦ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠎꠝꠣꠁꠀ ꠢꠣꠞꠤ ꠘꠤꠎꠦꠃ ꠎꠥꠖꠤ ꠍꠣꠠꠣꠁꠀ ꠘꠤꠔ ꠌꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV25_27","004_25_27","LEV","25","27","27","ꠔꠦ ꠔꠣꠞ ꠛꠤꠇꠤꠞ ꠛꠍꠞ ꠕꠣꠇꠤ ꠍꠣꠠꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠡꠝꠄ ꠢꠤꠡꠣꠛ ꠇꠞꠤꠀ, ꠝꠣꠟꠤꠇꠞ ꠙꠣꠅꠘꠣ ꠐꠦꠇꠣ ꠖꠤꠀ ꠔꠣꠞ ꠎꠝꠤ ꠚꠤꠞꠔ ꠘꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_28","004_25_28","LEV","25","28","28","ꠅꠁꠟꠦ ꠎꠝꠤ ꠚꠤꠞꠔ ꠘꠤꠛꠣꠞ ꠍꠣꠝꠣꠘꠣ ꠢꠦ ꠎꠝꠣꠁꠔꠦ ꠘꠣ ꠙꠣꠞꠟꠦ, ꠔꠣꠞ ꠛꠦꠌꠣ ꠎꠝꠤꠘ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠢꠃ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠙꠥꠞꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠈꠞꠤꠖꠖꠣꠞꠦ ꠈꠣꠁꠛꠣ, ꠀꠞ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞꠞ ꠇꠣꠟꠅ ꠔꠣꠞꠦ ꠚꠤꠞꠔ ꠖꠤꠛꠣ, ꠢꠦ ꠔꠣꠞ ꠎꠝꠤꠘ ꠄꠝꠘꠦꠃ ꠛꠤꠘꠣ ꠙꠄꠡꠣꠄ ꠚꠤꠞꠔ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_29","004_25_29","LEV","25","29","29","“ꠀꠞ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠇꠞꠣ ꠘꠤꠞꠣꠙꠖ ꠐꠣꠃꠘꠞ ꠇꠥꠘꠥ ꠛꠣꠡꠣ-ꠛꠣꠠꠤ ꠎꠥꠖꠤ ꠇꠦꠃ ꠛꠦꠌꠤꠟꠣꠄ, ꠔꠦ ꠛꠦꠌꠣꠞ ꠛꠣꠖꠦ ꠙꠥꠞꠣ ꠄꠇ ꠛꠍꠞꠞ ꠝꠣꠎꠦ ꠢꠦ ꠅꠃ ꠛꠣꠠꠤ ꠚꠤꠞꠔ ꠘꠤꠔ ꠙꠣꠞꠛ। ꠙꠥꠞꠣ ꠄꠇ ꠛꠍꠞꠞ ꠝꠣꠎꠦ ꠢꠦ ꠚꠤꠞꠔ ꠘꠤꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_30","004_25_30","LEV","25","30","30","ꠄꠇ ꠛꠍꠞꠞ ꠝꠣꠎꠦ ꠁꠐꠣ ꠚꠤꠞꠔ ꠘꠣ ꠘꠤꠟꠦ, ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠅꠃ ꠛꠣꠠꠤ ꠈꠞꠤꠖꠖꠣꠞ ꠀꠞ ꠔꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠅꠁꠛ। ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞꠅ ꠁꠐꠣ ꠚꠤꠞꠔ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV25_31","004_25_31","LEV","25","31","31","ꠅꠁꠟꠦ ꠎꠦꠔꠣ ꠉꠣꠃ-ꠉꠦꠞꠣꠝꠅ ꠇꠥꠘꠥ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠘꠣꠄ, ꠅꠃ ꠎꠣꠉꠣꠞ ꠛꠣꠠꠤ-ꠊꠞꠞꠦ ꠈꠦꠔꠞ ꠎꠝꠤꠘꠞ ꠟꠣꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠛꠣꠄ। ꠁꠔꠣ ꠍꠣꠠꠣꠁꠀ ꠀꠘꠣ ꠎꠣꠁꠛ, ꠀꠞ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞꠅ ꠚꠤꠞꠔ ꠖꠤꠔꠦ ꠅꠁꠛꠃ। ");
INSERT INTO syls_vpl VALUES ("LV25_32","004_25_32","LEV","25","32","32","“ꠈꠣꠟꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠐꠣꠃꠘꠞ ꠛꠣꠠꠤ-ꠊꠞ ꠅꠇꠟ ꠢꠣꠝꠦꠡꠣ ꠚꠤꠞꠔ ꠀꠘꠣ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_33","004_25_33","LEV","25","33","33","ꠔꠣꠞꠣꠞ ꠐꠣꠃꠘꠞ ꠇꠥꠘꠥ ꠛꠣꠠꠤ-ꠊꠞ ꠛꠦꠌꠤꠟꠦ, ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞꠅ ꠁꠐꠣ ꠚꠤꠞꠔ ꠙꠣꠁꠛꠣ। ꠔꠥꠝꠞꠣꠞ ꠔ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠈꠣꠟꠤ ꠐꠣꠃꠘꠞ ꠛꠣꠠꠤ-ꠊꠞꠃ ꠅꠁꠟ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣ ꠅꠃ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤꠃ ꠙꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LV25_34","004_25_34","LEV","25","34","34","ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠐꠣꠃꠘꠞ ꠗꠣꠞꠅ ꠙꠡꠥ ꠞꠣꠈꠣꠞ ꠛꠘ꠆ꠖꠞ ꠎꠣꠉꠣ ꠔꠣꠞꠣ ꠈꠞꠤꠖ-ꠛꠤꠇꠤ ꠇꠞꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣꠄ, ꠁꠔꠣ ꠔ ꠔꠣꠞꠣꠞ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("LV25_35","004_25_35","LEV","25","35","35","“ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠡꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠜꠣꠁ ꠎꠥꠖꠤ ꠉꠞꠤꠛꠤ ꠢꠣꠟꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠘꠤꠎꠞ ꠈꠣꠅꠀ-ꠚꠤꠘ꠆ꠖꠣ ꠎꠥꠉꠣꠁꠔ ꠘꠣ ꠙꠣꠞꠦ, ꠔꠦ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠦꠅ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠤꠅ, ꠎꠣꠔꠦ ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LV25_36","004_25_36","LEV","25","36","36","ꠔꠥꠝꠞꠣ ꠔꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠘꠝꠥꠘꠣꠞ ꠡꠥꠖ ꠈꠣꠁꠅ ꠘꠣ। ꠛꠞꠋ ꠢꠦ ꠎꠣꠔꠦ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠁꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠄ, ꠅꠃ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚ ꠜꠤꠔꠞꠦ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV25_37","004_25_37","LEV","25","37","37","ꠔꠥꠝꠞꠣ ꠡꠥꠖ ꠈꠣꠁꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠞꠦ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠇꠞ꠆ꠎ ꠖꠤꠅ ꠘꠣ। ꠔꠣꠞ ꠉꠦꠍꠦ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤꠞ ꠝꠣꠟ ꠛꠦꠌꠟꠦ ꠁꠔꠣꠞ ꠟꠣꠜ ꠟꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_38","004_25_38","LEV","25","38","38","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ꠀꠡ꠆ꠔꠣ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠙꠘ ꠝꠣꠛꠥꠖ ꠅꠀꠞ ꠈꠤꠀꠟꠦ, ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LV25_39","004_25_39","LEV","25","39","39","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠤ ꠡꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠜꠣꠁ ꠎꠥꠖꠤ ꠉꠞꠤꠛꠤ ꠢꠣꠟꠔꠅ ꠙꠠꠤꠀ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠦꠃꠞꠞ ꠉꠦꠍꠦ ꠛꠤꠇꠤ ꠈꠣꠁꠟꠣꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝꠞ ꠟꠣꠈꠣꠘ ꠈꠣꠐꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_40","004_25_40","LEV","25","40","40","ꠔꠥꠝꠞꠣꠞ ꠝꠥꠍꠣꠚꠤꠞ ꠀꠞ ꠞꠥꠎꠤ ꠇꠣꠝꠟꠣꠞ ꠟꠉꠦ ꠎꠦꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠅ, ꠔꠣꠞ ꠟꠉꠦꠅ ꠅꠟꠣ ꠇꠞꠤꠅ। ꠢꠦ ꠢꠃ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_41","004_25_41","LEV","25","41","41","ꠛꠣꠖꠦ ꠔꠣꠞꠦ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠅ। ꠔꠦꠃ ꠢꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠎꠝꠤꠘꠅ ꠚꠤꠞꠔ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_42","004_25_42","LEV","25","42","42","ꠢꠥꠘꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠔ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝ। ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠇꠞꠤ ꠀꠘꠍꠤ, ꠄꠞꠟꠣꠉꠤ ꠖꠥꠍꠞꠣ ꠇꠦꠃꠞꠞ ꠉꠥꠟꠣꠝꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞꠦ ꠛꠦꠌꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LV25_43","004_25_43","LEV","25","43","43","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖꠞ ꠒꠞ-ꠈꠚꠦ ꠌꠟꠤꠅ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠙꠣꠡꠣꠘ-ꠘꠤꠡ꠆ꠐꠥꠞ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_44","004_25_44","LEV","25","44","44","“ꠔꠥꠝꠞꠣꠞ ꠀꠞꠤ-ꠚꠞꠤ ꠎꠔ ꠎꠣꠔꠤ ꠀꠍꠂꠘ, ꠅꠔꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ ꠘꠤꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV25_45","004_25_45","LEV","25","45","45","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠎꠦꠔꠣ ꠀꠅꠟꠣꠖ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠅ ꠎꠘꠝꠤꠍꠂꠘ, ꠅꠔꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠅ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ ꠘꠤꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV25_46","004_25_46","LEV","25","46","46","ꠅꠃ ꠟꠣꠈꠣꠘ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠘꠤꠎꠞ ꠍꠣꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦꠅ ꠖꠤꠀ ꠎꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠁꠔꠣꠞꠦ ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠙꠣꠡꠣꠘ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠈꠣꠐꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LV25_47","004_25_47","LEV","25","47","47","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠎꠥꠖꠤ ꠗꠘꠤ ꠛꠘꠤꠎꠣꠄ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠜꠣꠁ ꠎꠥꠖꠤ ꠅꠜꠣꠛꠅ ꠙꠠꠤꠀ ꠔꠣꠞ ꠉꠦꠍꠦ ꠛꠣ ꠔꠣꠞ ꠇꠥꠘꠥ ꠀꠅꠟꠣꠖꠞ ꠉꠦꠍꠦ ꠘꠤꠎꠞꠦ ꠛꠦꠌꠤꠟꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV25_48","004_25_48","LEV","25","48","48","ꠔꠦ ꠢꠦ ꠘꠤꠎꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠛ। ꠔꠣꠞ ꠘꠤꠎꠞ ꠇꠥꠘꠥ ꠜꠣꠁꠄ ꠔꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_49","004_25_49","LEV","25","49","49","ꠔꠣꠞ ꠌꠣꠌꠣ ꠛꠣ ꠌꠣꠌꠣꠞ ꠊꠞꠞ ꠜꠣꠁꠄ, ꠛꠣ ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠀꠙꠘ ꠎꠦꠇꠥꠘꠥ ꠎꠘꠦ ꠔꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ꠘꠤꠎꠞ ꠢꠣꠟꠔ ꠛꠖꠟꠣꠁꠟꠤꠔꠦ ꠙꠣꠞꠟꠦ, ꠢꠦ ꠘꠤꠎꠞꠦ ꠘꠤꠎꠦ ꠀꠎꠣꠖ ꠇꠞꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_50","004_25_50","LEV","25","50","50","ꠎꠦ ꠛꠍꠞ ꠘꠤꠎꠞꠦ ꠛꠦꠌꠤꠍꠤꠟ ꠅꠃ ꠛꠍꠞ ꠕꠣꠇꠤ ꠢꠤꠡꠣꠛ ꠇꠞꠤꠀ ꠚꠤꠞꠔ ꠀꠅꠀꠞ ꠛꠍꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠔ ꠛꠍꠞ ꠛꠣꠇꠤ ꠕꠣꠇꠦ ꠅꠃ ꠡꠝꠄꠇꠥꠞ ꠇꠣꠝꠞ ꠛꠦꠔꠘꠞ ꠢꠤꠡꠣꠛ-ꠘꠤꠇꠣꠡ ꠝꠣꠚꠤꠇ ꠔꠣꠞ ꠀꠎꠣꠖꠤꠞ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_51","004_25_51","LEV","25","51","51","ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞ ꠎꠥꠖꠤ ꠛꠦꠡꠤ ꠖꠥꠞꠁ ꠅꠄ, ꠔꠦ ꠎꠦ ꠖꠣꠝꠦ ꠢꠦ ꠘꠤꠎꠞꠦ ꠛꠦꠌꠤꠍꠤꠟ, ꠅꠃ ꠖꠣꠝꠞ ꠛꠠ ꠄꠇ ꠅꠋꠡ ꠔꠣꠞ ꠀꠎꠣꠖꠤꠞ ꠛꠖꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_52","004_25_52","LEV","25","52","52","ꠀꠞ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞ ꠀꠁꠔꠦ ꠎꠥꠖꠤ ꠇꠝ ꠡꠝꠄ ꠛꠣꠇꠤ ꠞꠄ, ꠔꠦ ꠅꠃ ꠡꠝꠄ ꠢꠤꠡꠣꠛꠦ ꠐꠦꠇꠣ ꠖꠤꠀ ꠢꠦ ꠘꠤꠎꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_53","004_25_53","LEV","25","53","53","ꠔꠣꠞꠦ ꠛꠍꠞ ꠌꠥꠇ꠆ꠔꠤ ꠇꠣꠝꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠖꠦꠈꠤꠅ, ꠀꠞ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠝꠣꠟꠤꠇꠦ ꠎꠣꠘꠥ ꠔꠣꠞ ꠟꠉꠦ ꠙꠣꠡꠣꠘ ꠛꠦꠛꠢꠣꠞ ꠘꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LV25_54","004_25_54","LEV","25","54","54","ꠅꠟꠣ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠃꠙꠣꠄꠄ ꠎꠥꠖꠤ ꠢꠦ ꠀꠎꠣꠖ ꠅꠁꠔ ꠘꠣ ꠙꠣꠞꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠞꠦ ꠚꠤꠞꠔ ꠙꠣꠅꠀ ꠛꠍꠞꠞ ꠡꠝꠄ ꠄꠝꠘꠦꠃ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠟꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV25_55","004_25_55","LEV","25","55","55","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠔ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝ। ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠇꠞꠤ ꠀꠘꠍꠤ, ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠀꠝꠣꠞ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV26_1","004_26_1","LEV","26","1","1","“ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠘꠝꠥꠘꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠝꠥꠞ꠆ꠔꠤ, ꠛꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠖꠦꠛꠔꠣ ꠢꠤꠡꠣꠛꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠤꠅ ꠘꠣ। ꠙꠥꠎꠣꠞ ꠘꠤꠅꠔꠦ ꠙꠣꠔ꠆ꠔꠞ ꠈꠥꠖꠤꠀ ꠛꠣꠘꠣꠁꠟ ꠇꠥꠘꠥꠎꠣꠔ ꠝꠥꠞ꠆ꠔꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠞꠣꠈꠤꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV26_2","004_26_2","LEV","26","2","2","ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠙꠞꠔꠦꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠤꠅ, ꠀꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞꠞꠦ ꠔꠥꠝꠞꠣ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV26_3","004_26_3","LEV","26","3","3","“ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠤꠀ ꠀꠝꠟ ꠇꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("LV26_4","004_26_4","LEV","26","4","4","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠑꠤꠇꠝꠔ ꠝꠦꠊ-ꠙꠣꠘꠤ ꠖꠤꠝꠥ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠎꠝꠤꠘꠅ ꠚꠄ-ꠚꠡꠟ ꠚꠟꠤꠛ ꠀꠞ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤꠄꠅ ꠚꠟ-ꠝꠥꠟ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_5","004_26_5","LEV","26","5","5","ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠄ-ꠚꠡꠟ ꠅꠔ ꠛꠦꠡꠤ ꠅꠁꠛ ꠎꠦꠘ, ꠀꠋꠉꠥꠞ ꠔꠥꠟꠣꠞ ꠡꠝꠄ ꠀꠎꠤꠟꠦꠅ, ꠔꠥꠝꠞꠣꠞ ꠚꠡꠟ ꠝꠣꠠꠣ ꠖꠦꠅꠀꠔ ꠞꠁꠛꠣꠄ। ꠀꠞ ꠎꠝꠤꠘꠞ ꠝꠣꠎꠦ ꠘꠄꠀ ꠛꠤꠌ ꠛꠣꠁꠘ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠀꠎꠤꠟꠦꠅ, ꠅꠃ ꠡꠝꠄ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠋꠉꠥꠞ ꠔꠥꠟꠣꠔ ꠞꠁꠛꠣꠄ। ꠔꠥꠝꠞꠣ ꠙꠦꠐ ꠜꠞꠤꠀ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁꠛꠣꠄ, ꠀꠞ ꠘꠤꠞꠣꠙꠖꠦ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠛꠡꠔ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_6","004_26_6","LEV","26","6","6","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠅ ꠡꠣꠘ꠆ꠔꠤ ꠖꠤꠝꠥ, ꠔꠥꠝꠞꠣ ꠡꠣꠘ꠆ꠔꠤꠄ ꠊꠥꠝꠣꠁꠛꠣꠄ, ꠇꠦꠃ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠥꠘꠥ ꠒꠞ-ꠈꠚ ꠖꠦꠈꠣꠁꠔ ꠘꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠢꠇꠟ ꠎꠣꠔꠞ ꠢꠤꠋꠡ꠆ꠞ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠀꠝꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠝꠥ, ꠀꠞ ꠇꠥꠘꠥ ꠍꠤꠙꠣꠁ ꠖꠟꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠅ ꠢꠣꠝꠟꠣ ꠇꠞꠣꠔ ꠀꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_7","004_26_7","LEV","26","7","7","ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠘꠤꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠣꠞ ꠝꠞꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_8","004_26_8","LEV","26","8","8","ꠔꠥꠝꠞꠣꠞ ꠈꠣꠟꠤ ꠙꠣꠌ ꠎꠘ ꠍꠤꠙꠣꠁꠄ ꠄꠇ-ꠡ ꠖꠥꠡꠝꠘꠞꠦ, ꠀꠞ ꠄꠇ-ꠡ ꠍꠤꠙꠣꠁꠄ ꠖꠡ ꠀꠎꠣꠞ ꠎꠘꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠘꠤꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠔꠟꠥꠀꠞꠞ ꠔꠟꠦ ꠝꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_9","004_26_9","LEV","26","9","9","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠖꠄꠀꠞ ꠘꠎꠞꠦ ꠌꠣꠁꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠣꠠꠣꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠛꠠ ꠇꠞꠝꠥ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠛꠅꠀꠁꠟ ꠞꠣꠈꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV26_10","004_26_10","LEV","26","10","10","ꠘꠄꠀ ꠛꠍꠞꠞ ꠚꠡꠟ ꠔꠥꠟꠣꠞ ꠟꠣꠉꠤ ꠃꠉꠣꠞ ꠈꠣꠟꠤ ꠇꠞꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠉꠞ ꠛꠍꠞꠞ ꠚꠡꠟꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠌꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_11","004_26_11","LEV","26","11","11","ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠔꠣꠝ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦꠃ ꠞꠁꠛ ꠀꠝꠣꠞ ꠛꠡꠔ ꠊꠞ। ");
INSERT INTO syls_vpl VALUES ("LV26_12","004_26_12","LEV","26","12","12","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠝꠥ, ꠀꠝꠤ ꠅꠁꠝꠥ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠞꠣ ꠅꠁꠛꠣꠄ ꠀꠝꠣꠞ ꠈꠣꠍ ꠙ꠆ꠞꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("LV26_13","004_26_13","LEV","26","13","13","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤ ꠀꠘꠍꠤ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣ ꠘꠣ ꠟꠣꠉꠦ। ꠔꠥꠝꠞꠣꠞ ꠉꠞ꠆ꠖꠘꠣ ꠕꠣꠇꠤ ꠎꠥꠀꠟ ꠜꠣꠋꠉꠤꠀ ꠚꠣꠟꠣꠁꠀ, ꠝꠣꠕꠣ ꠃꠌꠣ ꠇꠞꠤ ꠀꠐꠤꠛꠣꠞ ꠢꠣꠟꠔꠅ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LV26_14","004_26_14","LEV","26","14","14","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠇꠕꠣ ꠘꠣ ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠘꠣ ꠝꠣꠘꠅ, ");
INSERT INTO syls_vpl VALUES ("LV26_15","004_26_15","LEV","26","15","15","ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠀꠁꠘ-ꠇꠣꠘꠥꠘꠞꠦ ꠘꠣꠙꠍꠘ꠆ꠖ ꠇꠞꠅ, ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠡꠞꠤꠅꠔꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠘꠣ ꠝꠣꠘꠤꠀ, ꠀꠝꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠃꠟꠐꠣ ꠌꠟꠅ, ");
INSERT INTO syls_vpl VALUES ("LV26_16","004_26_16","LEV","26","16","16","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠅꠟꠣ ꠈꠣꠠꠣ ꠝꠍꠤꠛꠔ ꠖꠤꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟ ꠇ꠆ꠇꠄ ꠅꠀꠞ ꠛꠦꠝꠣꠞ ꠖꠤꠝꠥ, ꠉꠎꠛꠤ ꠎꠇ꠆ꠇꠣ ꠛꠦꠝꠣꠞ ꠀꠞ ꠛꠦꠎꠥꠁꠔꠣ ꠔꠣꠙ ꠅꠁꠛ, ꠅꠔꠣ ꠛꠦꠝꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠙꠣꠅꠀꠞ ꠇ꠆ꠇꠄ ꠅꠁꠛ, ꠡꠞꠤꠟꠞ ꠇꠝꠎꠥꠞꠤ ꠀꠁꠛ। ꠔꠥꠝꠞꠣ ꠎꠝꠤꠘꠅ ꠈꠦꠔ ꠇꠞꠟꠦꠅ ꠚꠣꠄꠖꠣ ꠅꠁꠔ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠚꠡꠟ ꠖꠥꠡꠝꠘꠦ ꠈꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_17","004_26_17","LEV","26","17","17","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠎꠤꠝꠥ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠖꠥꠡꠝꠘꠞ ꠉꠦꠍꠦ ꠀꠞꠤꠛꠣꠄ। ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣꠄ ꠁꠋꠡꠣ ꠇꠞꠂꠘ, ꠅꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠣꠡꠘ ꠇꠞꠛꠣ, ꠀꠞ ꠇꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣ ꠈꠦꠖꠣꠁꠟꠦꠅ, ꠔꠥꠝꠞꠣ ꠎꠣꠘꠞ ꠒꠞꠦ ꠄꠝꠘꠦꠃ ꠜꠣꠉꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_18","004_26_18","LEV","26","18","18","“ꠄꠞꠛꠣꠖꠦꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠘꠣ ꠢꠥꠘꠅ, ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠔ ꠉꠥꠘ ꠛꠦꠡꠤ ꠡꠣꠎꠣ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV26_19","004_26_19","LEV","26","19","19","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤꠞ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠜꠣꠋꠉꠤꠀ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠤꠟꠤꠝꠥ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠞ ꠀꠍꠝꠣꠘꠞꠦ ꠟꠥꠀꠞ ꠟꠣꠈꠣꠘ, ꠀꠞ ꠙꠣꠅꠞ ꠔꠟꠞ ꠝꠣꠐꠤꠞꠦ ꠔꠣꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠡꠇ꠆ꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV26_20","004_26_20","LEV","26","20","20","ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠅꠔ ꠝꠦꠘꠔ ꠇꠞꠤꠀꠅ ꠇꠥꠘꠥ ꠚꠟ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ꠈꠦꠔꠞ ꠎꠝꠤꠘꠅ ꠚꠡꠟ ꠗꠞꠔ ꠘꠣꠄ, ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤꠔ ꠚꠟ ꠝꠤꠟꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_21","004_26_21","LEV","26","21","21","“ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠖꠥꠡꠝꠘꠤ ꠕꠣꠇꠦ, ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠥꠇꠥꠝ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠘꠅ ꠘꠣ ꠢꠣꠝꠣꠄ, ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠡꠣꠔ ꠉꠥꠘ ꠛꠦꠡꠤ ꠡꠣꠎꠣ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV26_22","004_26_22","LEV","26","22","22","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠢꠤꠋꠡ꠆ꠞ ꠎꠣꠘꠥꠀꠞ ꠙꠣꠑꠣꠁꠝꠥ, ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠈꠣꠁꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠡꠞ ꠙꠞꠤꠝꠣꠘꠅ ꠇꠝꠣꠁꠟꠤꠛꠣ, ꠖꠦꠡꠞ ꠙꠕ-ꠊꠣꠐ ꠈꠣꠟꠤ ꠙꠠꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_23","004_26_23","LEV","26","23","23","“ꠅꠃ ꠢꠇꠟ ꠊꠐꠘꠣ ꠊꠐꠣꠞ ꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠀꠁꠘ-ꠇꠣꠘꠥꠘꠞ ꠃꠟꠐꠣ ꠌꠟꠅ, ");
INSERT INTO syls_vpl VALUES ("LV26_24","004_26_24","LEV","26","24","24","ꠔꠦ ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠛꠘꠤꠀ, ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠔ ꠉꠥꠘ ꠛꠦꠡꠤ ꠡꠣꠎꠣ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV26_25","004_26_25","LEV","26","25","25","ꠀꠝꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞꠦ ꠘꠣ ꠝꠣꠘꠣꠄ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠠꠣꠁ-ꠎꠥꠖ꠆ꠖ ꠀꠘꠣꠁꠝꠥ। ꠖꠥꠡꠝꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠛꠣꠄ, ꠢꠘꠅ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠉꠎꠛꠤ ꠝꠞꠇꠤ ꠍꠣꠠꠤꠝꠥ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣ ꠙꠠꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_26","004_26_26","LEV","26","26","26","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤꠞ ꠝꠣꠎꠦ ꠅꠜꠣꠛ ꠊꠐꠣꠁꠝꠥ, ꠔꠦꠃ ꠖꠡ ꠎꠘ ꠛꠦꠐꠤꠄ ꠞꠣꠘ꠆ꠖꠤꠔꠦ ꠄꠇ ꠌꠥꠟꠣꠞ ꠛꠦꠡꠤ ꠟꠣꠉꠔ ꠘꠣꠄ। ꠈꠣꠘꠤꠔ ꠛꠁꠀ ꠔꠥꠝꠞꠣ ꠞꠥꠐꠤ ꠝꠣꠙꠤ ꠝꠣꠙꠤ ꠈꠣꠁꠛꠣꠄ, ꠙꠦꠐ ꠜꠞꠣ ꠈꠣꠘꠤ ꠎꠥꠐꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_27","004_26_27","LEV","26","27","27","“ꠁꠔꠣ ꠢꠇꠟꠔꠣꠞ ꠛꠣꠖꠦꠅ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠇꠕꠣ ꠘꠣ ꠢꠥꠘꠤꠀ ꠀꠝꠣꠞ ꠃꠟꠐꠣ ꠌꠟꠅ, ");
INSERT INTO syls_vpl VALUES ("LV26_28","004_26_28","LEV","26","28","28","ꠔꠦ ꠀꠝꠤ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠀ ꠀꠝꠤꠅ ꠔꠥꠝꠞꠣꠞ ꠃꠟꠐꠣ ꠌꠟꠝꠥ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠔ ꠉꠥꠘ ꠡꠣꠎꠣ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV26_29","004_26_29","LEV","26","29","29","ꠙꠦꠐꠞ ꠜꠥꠇꠦ ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠌꠤꠛꠣꠁꠀ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_30","004_26_30","LEV","26","30","30","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠎꠣꠞ ꠢꠇꠟ ꠝꠣꠘ꠆ꠒꠛ ꠀꠞ ꠗꠥꠙ-ꠗꠥꠘꠣ ꠎꠣꠟꠣꠘꠤꠞ ꠎꠣꠉꠣꠞꠦꠅ ꠛꠤꠘꠣꠡ ꠇꠞꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠝꠥꠞ꠆ꠔꠤꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠡꠞ ꠐꠦꠇꠤ ꠕꠁꠝꠥ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠈꠥꠛ ꠊꠤꠘ꠆ꠘꠣꠞ ꠘꠎꠞꠦ ꠌꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV26_31","004_26_31","LEV","26","31","31","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠃ ꠀꠞ ꠐꠣꠃꠘ ꠅꠇꠟ, ꠀꠞ ꠢꠇꠟ ꠝꠍꠤꠖ-ꠝꠘ꠆ꠖꠤꠞ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠝꠥ। ꠔꠥꠝꠞꠣꠞ ꠍꠖꠉꠣ-ꠇꠥꠞꠛꠣꠘꠤꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘ ꠀꠝꠤ ꠀꠞ ꠇꠛꠥꠟ ꠇꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_32","004_26_32","LEV","26","32","32","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠅꠟꠣ ꠉꠎꠛ ꠖꠤꠝꠥ, ꠎꠦꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠦꠅ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV26_33","004_26_33","LEV","26","33","33","ꠘꠣꠘꠣꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠤꠔ꠆ꠞꠣꠁ ꠖꠤꠝꠥ, ꠔꠟꠥꠀꠞ ꠀꠔꠅ ꠟꠁꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠝꠥ। ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡ ꠛꠤꠘꠣꠡ ꠅꠁꠛ, ꠔꠥꠝꠞꠣꠞ ꠐꠣꠃꠘ ꠀꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠈꠣꠟꠤ ꠙꠠꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_34","004_26_34","LEV","26","34","34","“ꠔꠥꠝꠞꠣ ꠖꠥꠡꠝꠘꠞ ꠖꠦꠡꠅ ꠕꠣꠇꠣꠞ ꠡꠝꠄ, ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠖꠦꠡꠞ ꠎꠝꠤꠘꠦ ꠔꠣꠞ ꠙꠣꠅꠘꠣ ꠎꠤꠞꠣꠘꠤꠞ ꠛꠍꠞ ꠎꠤꠞꠣꠁꠛ। ꠅꠃ ꠡꠝꠄ ꠖꠦꠡꠞ ꠝꠣꠐꠤꠄ ꠔꠣꠞ ꠙꠣꠅꠘꠣ ꠀꠞꠣꠝ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_35","004_26_35","LEV","26","35","35","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠕꠣꠇꠣꠞ ꠡꠝꠄ ꠎꠦꠛꠟꠣ ꠅꠃ ꠎꠝꠤꠘ ꠅꠇꠟꠦ ꠎꠤꠞꠣꠘꠤꠞ ꠛꠍꠞ ꠙꠣꠁꠍꠤꠟ ꠘꠣ, ꠅꠈꠘ ꠖꠦꠡ ꠛꠤꠘꠣꠡꠞ ꠡꠝꠄ ꠁꠔꠣꠄ ꠢꠃ ꠙꠣꠅꠘꠣ ꠎꠤꠞꠣꠘꠤ ꠎꠤꠞꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_36","004_26_36","LEV","26","36","36","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠎꠦꠞꠣ ꠉꠤꠀ ꠖꠥꠡꠝꠘꠞ ꠖꠦꠡꠅ ꠛꠣꠌꠤꠀ ꠞꠁꠛꠣ, ꠔꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠀꠝꠤ ꠅꠃ ꠟꠣꠈꠣꠘ ꠒꠞ-ꠈꠚ ꠢꠣꠞꠣꠁ ꠖꠤꠝꠥ, ꠟꠣꠠꠣꠁꠞ ꠇꠣꠟꠅ ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠖꠥꠡꠝꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠞ ꠟꠣꠉꠤ ꠖꠃꠠꠤꠀ ꠜꠣꠉꠦ, ꠅꠃꠟꠣ ꠄꠉꠥ ꠙꠣꠔꠣ ꠙꠠꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠦꠃ ꠔꠣꠞꠣ ꠖꠃꠠꠤꠀ ꠜꠣꠉꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV26_37","004_26_37","LEV","26","37","37","ꠔꠟꠥꠀꠞꠞ ꠔꠟ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠎꠣꠘ ꠟꠁꠀ ꠖꠃꠠꠣꠄ, ꠇꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣ ꠖꠃꠠꠣꠁꠟꠦꠅ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠖꠃꠠꠣꠁꠀ ꠅꠟꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠃꠙꠞꠦ ꠙꠠꠛꠣꠄ। ꠖꠥꠡꠝꠘꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣ ꠃꠛꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV26_38","004_26_38","LEV","26","38","38","ꠔꠥꠝꠞꠣ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠍꠤꠔ꠆ꠞꠤꠀ ꠝꠞꠛꠣꠄ, ꠀꠞ ꠖꠥꠡꠝꠘꠞ ꠖꠦꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠉꠤꠟꠤꠀ ꠈꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV26_39","004_26_39","LEV","26","39","39","ꠄꠞꠛꠣꠖꠦꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠢꠘꠅ ꠛꠣꠌꠤꠀ ꠞꠄ, ꠔꠦ ꠔꠣꠞꠣꠅ ꠘꠤꠎꠞ ꠀꠞ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇ꠆ꠇꠄ ꠅꠀꠔ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV26_40","004_26_40","LEV","26","40","40","“ꠔꠣꠞꠣ ꠅꠈꠣꠘ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠣ ꠟꠣꠉꠛ ꠎꠦꠘ, ꠔꠣꠞꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠄ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠍꠦ, ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠤꠀ ꠉꠥꠘꠣ ꠇꠞꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LV26_41","004_26_41","LEV","26","41","41","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠖꠥꠡꠝꠘꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠍꠤ, ꠔꠣꠞꠣꠞꠦ ꠜꠤꠐꠣ-ꠝꠣꠐꠤ ꠍꠣꠠꠣꠁꠀ ꠖꠥꠡꠝꠘꠞ ꠖꠦꠡꠅ ꠀꠘꠣꠁꠍꠤ। ꠅꠔꠣ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠇꠣꠔꠞ ꠅꠁꠀ ꠘꠞꠝ ꠖꠤꠟꠦ ꠔꠃꠛꠣ ꠇꠞꠤꠀ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠛꠁꠔꠦ ꠞꠣꠎꠤ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("LV26_42","004_26_42","LEV","26","42","42","ꠔꠦ ꠀꠝꠤ ꠁꠀꠇꠥꠛꠞ ꠟꠉꠦ ꠇꠣꠁꠝ ꠇꠞꠣ ꠀꠝꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠝꠥ, ꠁꠍꠢꠣꠇꠞ ꠟꠉꠦ ꠇꠞꠣ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠇꠕꠣꠞꠦꠅ ꠝꠘꠅ ꠇꠞꠝꠥ, ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠉꠦ ꠇꠞꠣ ꠀꠝꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞꠦ ꠁꠀꠖ ꠇꠞꠝꠥ, ꠔꠣꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠖꠦꠡꠞ ꠇꠕꠣꠅ ꠈꠤꠀꠟ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LV26_43","004_26_43","LEV","26","43","43","“ꠔꠣꠞꠣ ꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞ ꠛꠤꠘꠣꠡ ꠅꠀ ꠖꠦꠡ ꠈꠣꠟꠤ ꠙꠠꠤ ꠞꠁꠛ, ꠎꠝꠤꠘꠞ ꠙꠣꠅꠘꠣ ꠎꠤꠞꠣꠘꠤꠞ ꠛꠍꠞ ꠅꠇꠟꠅ ꠎꠤꠞꠣꠁꠛꠃ ꠎꠤꠞꠣꠁꠛ। ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠤꠀ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠣꠄ, ꠀꠝꠣꠞ ꠀꠁꠘꠞ ꠃꠟꠐꠣ ꠌꠟꠣꠄ ꠔꠣꠞꠣ ꠅꠟꠣ ꠡꠣꠎꠣ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV26_44","004_26_44","LEV","26","44","44","ꠅꠁꠟꠦ ꠖꠥꠡꠝꠘꠞ ꠖꠦꠡꠅ ꠕꠣꠇꠣꠞ ꠇꠣꠟꠅ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠅꠟꠣ ꠇꠥꠘꠥ ꠊꠤꠘ꠆ꠘꠣ ꠛꠣ ꠄꠟꠣꠝꠤꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠔꠣꠝ ꠘꠣꠄ, ꠔꠣꠞꠣꠞꠦ ꠄꠇ꠆ꠇꠦꠞꠦ ꠛꠤꠘꠣꠡ ꠅꠁꠔꠦ ꠖꠤꠔꠣꠝ ꠘꠣꠄ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠇꠞꠣ ꠀꠝꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠜꠋꠉ ꠘꠣ ꠅꠄ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠣꠞꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("LV26_45","004_26_45","LEV","26","45","45","ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠟꠉꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞꠦ ꠁꠀꠖ ꠇꠞꠝꠥ। ꠅꠃ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠛꠥꠖ ꠅꠀꠞ ꠘꠤꠅꠔꠦ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠍꠣꠝꠘ ꠖꠤꠀ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠤ। ꠀꠝꠤꠃ ꠔ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("LV26_46","004_26_46","LEV","26","46","46","ꠁꠔꠣ ꠅꠁꠟ ꠢꠃ ꠡꠞꠤꠅꠔ, ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ, ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ, ꠎꠦꠔꠣ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠞꠚꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LV27_1","004_27_1","LEV","27","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LV27_2","004_27_2","LEV","27","2","2","“ꠔꠥꠝꠤ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀꠞ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠦ, ꠔꠦ ꠅꠃ ꠎꠘꠞ ꠛꠖꠟꠣ ꠅꠟꠣꠈꠣꠘ ꠢꠣꠖꠤꠀ ꠖꠤꠔꠦ ꠅꠁꠛ: ");
INSERT INTO syls_vpl VALUES ("LV27_3","004_27_3","LEV","27","3","3","ꠛꠤꠡ ꠕꠣꠇꠤ ꠡꠣꠁꠐ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠉꠤ, ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠔꠟꠣ ꠞꠥꠙꠣ ꠢꠣꠖꠤꠀ ꠖꠤꠔꠦ ꠅꠁꠛ, ");
INSERT INTO syls_vpl VALUES ("LV27_4","004_27_4","LEV","27","4","4","ꠅꠃ ꠛꠄꠅꠡꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠔꠤꠡ ꠔꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV27_5","004_27_5","LEV","27","5","5","ꠙꠣꠌ ꠛꠍꠞ ꠕꠣꠇꠤ ꠛꠤꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠛꠤꠡ ꠔꠟꠣ ꠞꠥꠙꠣ, ꠅꠃ ꠛꠄꠅꠡꠤ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠖꠡ ꠔꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LV27_6","004_27_6","LEV","27","6","6","ꠄꠇꠝꠣꠡ ꠕꠣꠇꠤ ꠙꠣꠌ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠙꠣꠌ ꠔꠟꠣ ꠞꠥꠙꠣ, ꠅꠃ ꠛꠄꠅꠡꠤ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠔꠤꠘ ꠔꠟꠣ ꠞꠥꠙꠣ। ");
INSERT INTO syls_vpl VALUES ("LV27_7","004_27_7","LEV","27","7","7","ꠡꠣꠁꠐ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠤ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠙꠘꠞ ꠔꠟꠣ, ꠅꠃ ꠛꠄꠅꠡꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠖꠡ ꠔꠟꠣ ꠞꠥꠙꠣ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_8","004_27_8","LEV","27","8","8","“ꠅꠁꠟꠦ ꠅꠃ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠞꠣ ꠎꠘ ꠎꠥꠖꠤ ꠉꠞꠤꠛ ꠝꠣꠘꠥꠡ ꠅꠄ, ꠔꠣꠞ ꠝꠣꠘ꠆ꠘꠔꠞ ꠢꠣꠖꠤꠀ ꠖꠤꠛꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠟꠁꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛꠣꠄ, ꠉꠦꠟꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠣꠞ ꠢꠣꠟꠔ ꠛꠥꠎꠤꠀ ꠢꠣꠖꠤꠀ ꠑꠤꠇ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LV27_9","004_27_9","LEV","27","9","9","“ꠎꠥꠖꠤ ꠇꠛꠥꠟ ꠅꠀꠞ ꠎꠥꠇꠣ ꠇꠥꠘꠥ ꠙꠡꠥꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠣ ꠅꠄ, ꠔꠦ ꠅꠃ ꠙꠡꠥꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV27_10","004_27_10","LEV","27","10","10","ꠅꠃ ꠙꠡꠥꠞ ꠛꠖꠟꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠙꠡꠥ ꠖꠤꠟꠦ ꠇꠛꠥꠟ ꠅꠁꠔ ꠘꠣꠄ। ꠁꠐꠣ ꠜꠣꠟꠣ ꠅꠁꠟꠦ ꠄꠞ ꠛꠖꠟꠣ ꠛꠣꠖ ꠙꠡꠥ, ꠛꠣ ꠛꠣꠖ ꠅꠁꠟꠦ ꠄꠞ ꠛꠖꠟꠣ ꠜꠣꠟꠣ ꠇꠥꠘꠥ ꠙꠡꠥ ꠖꠤꠟꠦꠅ ꠇꠛꠥꠟ ꠅꠁꠔ ꠘꠣꠄ। ꠢꠦ ꠎꠥꠖꠤ ꠄꠇꠐꠣꠞ ꠛꠖꠟꠣ ꠀꠞꠇꠐꠣ ꠙꠡꠥꠞꠦ ꠖꠤꠟꠣꠄ, ꠔꠦ ꠅꠃ ꠖꠥꠁꠅꠐꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV27_11","004_27_11","LEV","27","11","11","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠛꠥꠟ ꠅꠀꠞ ꠎꠥꠇꠣ ꠘꠣꠄ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠘꠣꠙꠣꠇ ꠎꠣꠔꠞ ꠙꠡꠥꠞꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠣꠘ꠆ꠘꠔ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠤꠟꠣꠄ, ꠔꠦ ꠅꠇꠐꠣꠞꠦ ꠟꠁꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠅ, ");
INSERT INTO syls_vpl VALUES ("LV27_12","004_27_12","LEV","27","12","12","ꠉꠦꠟꠦ ꠔꠣꠁꠘ ꠅꠇꠐꠣꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠛꠥꠎꠤꠀ ꠢꠣꠞꠤ ꠎꠦ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠛꠣ, ꠅꠃ ꠖꠣꠝꠃ ꠅꠁꠛ ꠁꠐꠣꠞ ꠡꠑꠤꠇ ꠖꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV27_13","004_27_13","LEV","27","13","13","ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠞꠣꠄ ꠁꠐꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠅꠁꠟꠦ, ꠅꠃ ꠖꠣꠝꠞ ꠟꠉꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠖꠣꠝ ꠛꠦꠡꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_14","004_27_14","LEV","27","14","14","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠇꠥꠘꠥ ꠛꠣꠠꠤ-ꠊꠞꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠍꠣꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠅꠃ ꠛꠣꠠꠤꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠛꠥꠎꠤꠀ ꠎꠦ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠛꠣ, ꠁꠐꠣꠃ ꠅꠁꠛ ꠄꠞ ꠡꠑꠤꠇ ꠖꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV27_15","004_27_15","LEV","27","15","15","ꠅꠈꠘ ꠅꠃ ꠛꠣꠠꠤꠞꠦ ꠢꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠘꠤꠔ ꠌꠣꠁꠟꠦ, ꠅꠃ ꠖꠣꠝꠞ ꠟꠉꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠛꠦꠡꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠔꠦꠃ ꠛꠣꠠꠤ ꠈꠣꠘ ꠔꠣꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_16","004_27_16","LEV","27","16","16","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠘꠤꠎꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡꠞ ꠇꠥꠘꠥ ꠄꠇ ꠅꠋꠡꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠤꠀ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠀꠟꠉ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠅꠃ ꠎꠝꠤꠘꠅ ꠎꠦ ꠙꠞꠤꠝꠣꠘꠦ ꠈꠦꠔ ꠅꠄ, ꠅꠃ ꠚꠡꠟꠞ ꠙꠞꠤꠝꠣꠘ ꠛꠥꠎꠤꠀ ꠄꠞ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠙꠞꠔꠦꠇ ꠙꠣꠌ ꠝꠘ ꠛꠣꠞ꠆ꠟꠤ ꠛꠤꠌꠞ ꠖꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠀꠗꠣ ꠡꠦꠞ ꠞꠥꠙꠣ ꠗꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LV27_17","004_27_17","LEV","27","17","17","ꠀꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞ ꠎꠥꠖꠤ ꠢꠦ ꠔꠣꠞ ꠎꠝꠤꠘꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠦ, ꠔꠦ ꠅꠃ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠎꠦ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠛꠣ, ꠁꠐꠣꠃ ꠅꠁꠛ ꠄꠞ ꠡꠑꠤꠇ ꠖꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LV27_18","004_27_18","LEV","27","18","18","ꠅꠁꠟꠦ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠢꠦ ꠔꠣꠞ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠦ, ꠔꠦ ꠛꠣꠖꠞ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠤꠡꠣꠛ ꠇꠞꠤꠀ ꠎꠔ ꠛꠍꠞ ꠅꠄ, ꠅꠔ ꠛꠍꠞꠞ ꠚꠡꠟꠞ ꠢꠤꠡꠣꠛꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠄꠞ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠛꠣ, ꠛꠍꠞ ꠢꠤꠡꠣꠛꠦ ꠎꠝꠤꠘꠞ ꠖꠣꠝ ꠇꠝꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_19","004_27_19","LEV","27","19","19","ꠀꠞ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠞꠣ ꠎꠘꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠎꠝꠤꠘꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠘꠤꠔ ꠌꠣꠄ, ꠔꠦ ꠑꠤꠇ ꠇꠞꠣ ꠅꠃ ꠖꠣꠝꠞ ꠟꠉꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠛꠦꠡꠤ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠔꠦꠃ ꠎꠝꠤ ꠈꠣꠘ ꠔꠣꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_20","004_27_20","LEV","27","20","20","ꠅꠁꠟꠦ ꠢꠦ ꠎꠥꠖꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠘꠣ ꠘꠦꠄ, ꠛꠣ ꠖꠥꠍꠞꠣ ꠎꠘꠞ ꠉꠦꠍꠦ ꠛꠦꠌꠤꠟꠣꠄ, ꠔꠦ ꠅꠃ ꠎꠝꠤꠘ ꠈꠣꠘ ꠀꠞ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠘꠤꠛꠣꠞ ꠙꠕ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LV27_21","004_27_21","LEV","27","21","21","ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠚꠤꠞꠔ ꠙꠣꠁꠛꠣꠞ ꠛꠍꠞ ꠎꠦꠛꠟꠣ ꠎꠝꠤ ꠈꠣꠘ ꠄꠝꠘꠦꠃ ꠈꠣꠟꠣꠍ ꠅꠁꠎꠤꠛ, ꠅꠃ ꠡꠝꠄ ꠁ ꠎꠝꠤ ꠈꠣꠘ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠍꠣꠚ-ꠇꠛꠣꠟꠣ ꠎꠝꠤꠘꠞ ꠟꠣꠈꠣꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠍꠣꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠅꠁꠛ। ꠁꠈꠣꠘ ꠅꠁꠎꠤꠛ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠎꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("LV27_22","004_27_22","LEV","27","22","22","ꠘꠤꠎꠞ ꠛꠣꠚꠣꠁꠔꠤ ꠎꠝꠤ ꠘꠣꠄ ꠁꠟꠣ ꠇꠥꠘꠥ ꠈꠞꠤꠖꠣ ꠎꠝꠤꠘꠞꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠣꠘ꠆ꠘꠔ ꠝꠣꠘꠤꠀ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("LV27_23","004_27_23","LEV","27","23","23","ꠔꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠛꠍꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠤꠡꠣꠛ ꠇꠞꠤꠀ ꠁꠈꠣꠘꠞ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠛꠣ, ꠀꠞ ꠢꠃ ꠖꠤꠘꠃ ꠅꠃ ꠎꠝꠤꠘꠞ ꠖꠣꠝꠞꠦ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠍꠣꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠟꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_24","004_27_24","LEV","27","24","24","ꠀꠞ ꠎꠝꠤ ꠈꠣꠘ ꠢꠦ ꠎꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠟꠁꠍꠤꠟ, ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠚꠤꠞꠔ ꠙꠣꠁꠛꠣꠞ ꠛꠍꠞ ꠁꠈꠣꠘ ꠢꠤꠞꠛꠣꠞ ꠢꠃ ꠝꠥꠟ ꠝꠣꠟꠤꠇꠞ ꠀꠔꠅ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_25","004_27_25","LEV","27","25","25","ꠢꠇꠟ ꠎꠤꠘꠤꠡꠞ ꠖꠣꠝ ꠑꠤꠇ ꠇꠞꠤꠅ, ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ। ꠙꠞꠔꠦꠇ ꠛꠤꠡ ꠞꠔꠤꠄ ꠄꠇ ꠔꠟꠣ ꠉꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LV27_26","004_27_26","LEV","27","26","26","“ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠇꠦꠃ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠁꠐꠣ ꠔ ꠄꠝꠘꠦꠃ ꠝꠣꠛꠥꠖꠞ। ꠁꠔꠣ ꠉꠞꠥ-ꠍꠣꠉꠟ, ꠝꠦꠠꠣ ꠎꠦꠔꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠃ ꠅꠃꠇ, ꠁꠐꠣ ꠝꠣꠛꠥꠖꠞ। ");
INSERT INTO syls_vpl VALUES ("LV27_27","004_27_27","LEV","27","27","27","ꠎꠥꠖꠤ ꠁꠐꠣ ꠇꠥꠘꠥ ꠢꠣꠞꠣꠝ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠄ, ꠔꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠑꠤꠇ ꠇꠞꠣ ꠖꠣꠝꠞ ꠟꠉꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠛꠦꠡꠤ ꠖꠤꠀ ꠁꠐꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠘꠤꠔ ꠙꠣꠞꠛ। ꠀꠞ ꠢꠦ ꠎꠥꠖꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠘꠣ ꠘꠦꠄ, ꠔꠦ ꠅꠃ ꠖꠣꠝꠦ ꠁꠐꠣꠞꠦ ꠛꠦꠌꠤꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_28","004_27_28","LEV","27","28","28","“ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠘꠤꠎꠞ ꠇꠥꠘꠥ ꠍꠣꠝꠣꠘꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠍꠣꠚ-ꠇꠛꠣꠟꠣ ꠖꠟꠤꠟꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠅꠃ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠣ ꠍꠣꠝꠣꠘꠣ ꠀꠞ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠚꠤꠞꠔ ꠘꠤꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠛꠣ ꠛꠦꠌꠔ-ꠅ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠁꠔꠣ ꠎꠝꠤ-ꠎꠝꠣ ꠅꠃꠇ, ꠛꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ, ꠛꠣ ꠙꠡꠥ ꠅꠁꠟꠦꠅ, ꠁꠔꠣ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠍꠣꠝꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_29","004_27_29","LEV","27","29","29","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠅꠟꠣ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠤꠀ ꠖꠤꠟꠣꠁꠟꠦ, ꠔꠣꠞꠦ ꠀꠞ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠘꠦꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ, ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_30","004_27_30","LEV","27","30","30","“ꠎꠝꠤꠘꠅ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠚꠟ-ꠚꠡꠟ ꠝꠤꠟꠦ, ꠁꠔꠣꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠔ ꠝꠣꠛꠥꠖꠞ। ꠁꠔꠣ ꠈꠦꠔꠞ ꠚꠡꠟ ꠅꠃꠇ ꠛꠣ ꠉꠣꠍꠞ ꠚꠟ ꠅꠃꠇ, ꠢꠇꠟꠔꠣꠃ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("LV27_31","004_27_31","LEV","27","31","31","ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠅꠃ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠘꠤꠔ ꠌꠣꠄ, ꠔꠦ ꠄꠞ ꠟꠉꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠛꠦꠡꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LV27_32","004_27_32","LEV","27","32","32","ꠙꠞꠔꠦꠇ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠝꠣꠛꠥꠖꠞ, ꠝꠣꠘꠤ ꠙꠣꠟꠦ ꠙꠡꠥ ꠉꠘꠣꠞ ꠡꠝꠄ ꠙꠞꠔꠦꠇ ꠖꠡ ꠘꠝ꠆ꠛꠞ ꠙꠡꠥ ꠅꠉꠥ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("LV27_33","004_27_33","LEV","27","33","33","ꠅꠃ ꠖꠡ ꠘꠝ꠆ꠛꠞ ꠙꠡꠥ ꠅꠉꠥꠁꠘ ꠛꠣꠖ ꠛꠣ ꠜꠣꠟꠣ ꠁꠔꠣ ꠖꠦꠈꠣꠞ ꠇꠥꠘꠥ ꠎꠞꠥꠞ ꠘꠣꠄ, ꠛꠣ ꠁꠐꠣ ꠛꠖꠟꠣꠁꠀ ꠖꠤꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠘꠣꠁ। ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠐꠣꠞ ꠛꠖꠟꠣ ꠖꠦꠄ, ꠔꠦ ꠅꠃ ꠖꠡ ꠘꠝ꠆ꠛꠞ ꠙꠡꠥ ꠀꠞ ꠛꠖꠟꠣ ꠙꠡꠥ ꠖꠥꠁꠅꠐꠣꠃ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠎꠤꠛ, ꠁꠔꠣ ꠀꠞ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠘꠦꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LV27_34","004_27_34","LEV","27","34","34","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠉꠦꠍꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠅꠇꠟ ꠖꠣꠘ ꠇꠞꠍꠤꠟꠣ॥");
INSERT INTO syls_vpl VALUES ("NU1_1","005_1_1","NUM","1","1","1","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠅꠀꠞ ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞꠞ ꠡꠝꠄ, ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ, ꠝꠣꠛꠥꠖꠦ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU1_2","005_1_2","NUM","1","2","2","“ꠅꠈꠘ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠘꠣꠝ ꠟꠦꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("NU1_3","005_1_3","NUM","1","3","3","ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘꠦ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠤ, ꠝꠣꠘꠤ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠚꠃꠎꠤ ꠖꠟ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("NU1_4","005_1_4","NUM","1","4","4","ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠇꠎꠘꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ, ꠄꠞꠣ ꠅꠁꠛꠣ ꠘꠤꠎꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠙꠞꠗꠣꠘ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("NU1_5","005_1_5","NUM","1","5","5","ꠎꠣꠞꠣ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ, ꠄꠞꠣꠞ ꠘꠣꠝ ꠅꠁꠟ, ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠣꠖꠤꠃꠞꠞ ꠙꠥꠀ ꠀꠟꠤꠍꠥꠞ, ");
INSERT INTO syls_vpl VALUES ("NU1_6","005_1_6","NUM","1","6","6","ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠥꠞꠡꠣꠖꠣꠄꠅꠞ ꠙꠥꠀ ꠡꠣꠟꠥꠝꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("NU1_7","005_1_7","NUM","1","7","7","ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠀꠝꠤꠘꠣꠖꠣꠛꠞ ꠙꠥꠀ ꠘꠣꠢꠤꠡ, ");
INSERT INTO syls_vpl VALUES ("NU1_8","005_1_8","NUM","1","8","8","ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠍꠥꠉꠣꠞꠞ ꠙꠥꠀ ꠘꠕꠘꠦꠟ, ");
INSERT INTO syls_vpl VALUES ("NU1_9","005_1_9","NUM","1","9","9","ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠢꠦꠟꠘꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠛ, ");
INSERT INTO syls_vpl VALUES ("NU1_10","005_1_10","NUM","1","10","10","ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠝꠣꠎ ꠕꠣꠇꠤ: ꠀꠚꠞꠣꠁꠝ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠀꠝꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠀꠟꠤꠡꠣꠝꠣ, ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠚꠣꠔꠡꠥꠞꠞ ꠙꠥꠀ ꠉꠝꠟꠤꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("NU1_11","005_1_11","NUM","1","11","11","ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠤꠖꠣꠃꠘꠤꠞ ꠙꠥꠀ ꠀꠛꠤꠖꠣꠘ, ");
INSERT INTO syls_vpl VALUES ("NU1_12","005_1_12","NUM","1","12","12","ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠀꠝꠤꠡꠣꠖꠣꠞ ꠙꠥꠀ ꠀꠈꠤꠀꠎꠣꠞ, ");
INSERT INTO syls_vpl VALUES ("NU1_13","005_1_13","NUM","1","13","13","ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠃꠇꠞꠣꠘꠞ ꠙꠥꠀ ꠚꠎꠤꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("NU1_14","005_1_14","NUM","1","14","14","ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠖꠥꠄꠟꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠍꠚ, ");
INSERT INTO syls_vpl VALUES ("NU1_15","005_1_15","NUM","1","15","15","ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠘꠣꠘꠞ ꠙꠥꠀ ꠀꠢꠤꠞ।” ");
INSERT INTO syls_vpl VALUES ("NU1_16","005_1_16","NUM","1","16","16","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠅꠃ ꠛꠣꠞꠅ ꠎꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠘꠦꠅꠀ ꠅꠁꠟ। ꠄꠞꠣ ꠅꠁꠟꠣ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠗꠣꠘ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠚꠃꠎꠤ ꠖꠟꠞ ꠡꠞ꠆ꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU1_17","005_1_17","NUM","1","17","17","ꠝꠣꠛꠥꠖꠦ ꠎꠦꠞꠣꠞ ꠘꠣꠝ ꠇꠁꠍꠟꠣ, ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠅꠃ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠈꠛꠞꠖꠤ ꠀꠘꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU1_18","005_1_18","NUM","1","18","18","ꠀꠞ ꠅꠃ ꠛꠍꠞꠞ ꠖꠥꠍꠞꠣ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠟꠣ। ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞ ꠘꠣꠝ ꠟꠦꠈꠣꠁꠟ। ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_19","005_1_19","NUM","1","19","19","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠥꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU1_20","005_1_20","NUM","1","20","20","ꠁꠀꠇꠥꠛ ꠃꠞꠚꠦ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠠ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠥꠛꠦꠘ, ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_21","005_1_21","NUM","1","21","21","ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠍꠄꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_22","005_1_22","NUM","1","22","22","ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_23","005_1_23","NUM","1","23","23","ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠃꠘꠥꠡꠣꠁꠐ ꠀꠎꠣꠞ ꠔꠤꠘ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_24","005_1_24","NUM","1","24","24","ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_25","005_1_25","NUM","1","25","25","ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠙꠄꠔꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_26","005_1_26","NUM","1","26","26","ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_27","005_1_27","NUM","1","27","27","ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠌꠃꠀꠔ꠆ꠔꠁꠞ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_28","005_1_28","NUM","1","28","28","ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_29","005_1_29","NUM","1","29","29","ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠌꠃꠀꠘ꠆ꠘ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_30","005_1_30","NUM","1","30","30","ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_31","005_1_31","NUM","1","31","31","ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠡꠣꠔꠣꠘ꠆ꠘ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_32","005_1_32","NUM","1","32","32","ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠀꠚꠞꠣꠁꠝ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_33","005_1_33","NUM","1","33","33","ꠀꠚꠞꠣꠁꠝ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_34","005_1_34","NUM","1","34","34","ꠀꠞ ꠔꠣꠘ ꠜꠣꠁ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_35","005_1_35","NUM","1","35","35","ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠛꠔ꠆ꠔꠤꠡ ꠀꠎꠣꠞ ꠖꠥꠁ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_36","005_1_36","NUM","1","36","36","ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_37","005_1_37","NUM","1","37","37","ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠙꠣꠄꠔꠤꠡ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_38","005_1_38","NUM","1","38","38","ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_39","005_1_39","NUM","1","39","39","ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠛꠣꠡꠐ꠆ꠐꠤ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_40","005_1_40","NUM","1","40","40","ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_41","005_1_41","NUM","1","41","41","ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠄꠇꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_42","005_1_42","NUM","1","42","42","ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠣꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ, ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠞꠤꠌꠄ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_43","005_1_43","NUM","1","43","43","ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠉꠦꠟ ꠔꠦꠙ꠆ꠙꠣꠘ꠆ꠘ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU1_44","005_1_44","NUM","1","44","44","ꠢꠎꠞꠔ ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣꠄ ꠅꠃ ꠝꠣꠘꠡꠞꠦ ꠉꠘꠤꠟꠣ। ꠅꠃ ꠛꠣꠞꠅ ꠎꠘ ꠘꠦꠔꠣ ꠀꠍꠟꠣ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU1_45","005_1_45","NUM","1","45","45","ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠔꠣꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠛꠄꠅꠡ, ꠎꠣꠞꠎꠤꠞ ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_46","005_1_46","NUM","1","46","46","ꠉꠘꠤꠀ ꠢꠇ꠆ꠇꠟꠔꠣꠄ ꠍꠄ ꠟꠣꠈ ꠔꠤꠘ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU1_47","005_1_47","NUM","1","47","47","ꠅꠁꠟꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ, ꠝꠣꠘꠤ ꠁꠝꠣꠝ ꠛꠋꠡꠞꠦ ꠄꠞꠣꠞ ꠟꠉꠦ ꠉꠘꠣ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU1_48","005_1_48","NUM","1","48","48","ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦꠃ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU1_49","005_1_49","NUM","1","49","49","“ꠔꠥꠝꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠉꠘꠛꠣꠄ ꠘꠣ, ꠉꠘꠣꠞ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠄꠞꠣꠞꠦ ꠢꠤꠡꠣꠛ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU1_50","005_1_50","NUM","1","50","50","ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥ, ꠝꠣꠘꠤ ꠀꠝꠣꠞ ꠊꠞꠞ ꠡꠣꠎ-ꠡꠞꠘ꠆ꠎꠣꠝ ꠀꠞ ꠢꠇꠟꠔꠣꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣꠞ ꠜꠣꠞ ꠖꠤꠛꠣꠄ। ꠔꠣꠞꠣꠞ ꠇꠣꠝ ꠅꠁꠛ, ꠀꠝꠣꠞ ꠊꠞ ꠀꠞ ꠄꠞ ꠢꠇꠟ ꠡꠣꠎ-ꠡꠞꠘ꠆ꠎꠣꠝ ꠛꠁꠀ ꠘꠦꠅꠀ। ꠔꠣꠞꠣ ꠄꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠎꠣꠞꠎꠤꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠋꠉꠣꠁꠀ ꠞꠁꠛꠣ ꠀꠞ ꠀꠝꠣꠞ ꠊꠞꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU1_51","005_1_51","NUM","1","51","51","ꠀꠝꠣꠞ ꠊꠞꠞꠦ ꠄꠇ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠎꠣꠉꠣꠔ ꠘꠤꠔꠦ ꠅꠁꠟꠦ, ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠁꠈꠣꠘ ꠈꠥꠟꠛꠣ, ꠛꠣꠖꠦ ꠀꠞꠇ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠘꠣꠁꠛꠣ। ꠈꠣꠟꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘ ꠍꠣꠠꠣ ꠅꠁꠘ꠆ꠘ ꠇꠦꠃ ꠁꠔꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟꠦ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU1_52","005_1_52","NUM","1","52","52","ꠛꠣꠖ-ꠛꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠚꠃꠎꠤ ꠖꠟ ꠝꠣꠚꠤꠇ ꠎꠣꠞꠎꠤꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠋꠉꠣꠁꠛꠣ। ꠙꠞꠔꠦꠇꠦ ꠎꠣꠞꠎꠤꠞ ꠖꠟꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠝꠣꠎꠦ, ꠖꠟꠞ ꠘꠤꠡꠣꠘꠣ ꠟꠣꠉꠣꠁꠟ ꠙꠔꠣꠇꠣꠞ ꠔꠟꠦ ꠞꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU1_53","005_1_53","NUM","1","53","53","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠎꠣꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠎꠛ ꠘꠣ ꠟꠣꠝꠦ, ꠄꠞꠟꠣꠉꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥꠞ ꠙꠣꠞꠣꠖꠣꠞꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠊꠞꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠔꠣꠞꠣꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠋꠉꠣꠁꠀ ꠞꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU1_54","005_1_54","NUM","1","54","54","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠑꠤꠇ ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU2_1","005_2_1","NUM","2","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU2_2","005_2_2","NUM","2","2","2","“ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠕꠥꠠꠣ ꠈꠣꠟꠤ ꠎꠣꠉꠣ ꠕꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠘꠣꠁꠛꠣ। ꠙꠞꠔꠦꠇꠦ ꠎꠣꠞꠎꠤꠞ ꠚꠃꠎꠤ ꠖꠟꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠙꠔꠣꠇꠣꠞ ꠗꠣꠞꠅ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU2_3","005_2_3","NUM","2","3","3","“ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠙꠥꠛꠦꠖꠤ, ꠡꠥꠞꠥꠎ ꠃꠑꠣꠞ ꠝꠥꠈꠣ, ꠄꠢꠥꠖꠣꠞ ꠙꠔꠣꠇꠣꠞ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠚꠃꠎꠤ ꠖꠟꠦ ꠔꠣꠞꠣꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠘꠣꠁꠛꠣ। ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠀꠝꠤꠘꠣꠖꠣꠛꠞ ꠙꠥꠀ ꠘꠣꠢꠤꠡ, ");
INSERT INTO syls_vpl VALUES ("NU2_4","005_2_4","NUM","2","4","4","ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠌꠃꠀꠔ꠆ꠔꠁꠞ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_5","005_2_5","NUM","2","5","5","ꠄꠞꠣꠞ ꠄꠇ ꠉꠣꠟꠣꠔ ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠞꠁꠛꠣ, ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠍꠥꠉꠣꠞꠞ ꠙꠥꠀ ꠘꠕꠘꠦꠟ, ");
INSERT INTO syls_vpl VALUES ("NU2_6","005_2_6","NUM","2","6","6","ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠌꠃꠀꠘ꠆ꠘ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_7","005_2_7","NUM","2","7","7","ꠖꠥꠍꠞꠣ ꠉꠣꠟꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠛꠣ ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠦ, ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠢꠦꠟꠘꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠛ, ");
INSERT INTO syls_vpl VALUES ("NU2_8","005_2_8","NUM","2","8","8","ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠡꠣꠔꠣꠘ꠆ꠘ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_9","005_2_9","NUM","2","9","9","ꠄꠢꠥꠖꠣꠞ ꠙꠔꠣꠇꠣꠞ ꠅꠃ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠉꠘꠣ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠥꠐ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠄꠇ ꠟꠣꠈ ꠍꠤꠀꠡꠤ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ। ꠍꠚꠞꠞ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠇꠣꠚꠦꠟꠣ ꠢꠇꠟꠞ ꠀꠉꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU2_10","005_2_10","NUM","2","10","10","“ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠇ꠆ꠇꠤꠘ ꠉꠣꠟꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠛꠣ, ꠞꠥꠛꠦꠘꠞ ꠙꠔꠣꠇꠣꠞ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠚꠃꠎꠤ ꠖꠟꠦ। ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠡꠣꠖꠤꠃꠞꠞ ꠙꠥꠀ ꠀꠟꠤꠍꠥꠞ, ");
INSERT INTO syls_vpl VALUES ("NU2_11","005_2_11","NUM","2","11","11","ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠍꠄꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_12","005_2_12","NUM","2","12","12","ꠄꠞꠣꠞ ꠄꠇ ꠉꠣꠟꠣꠔ ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠞꠁꠛꠣ, ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠥꠞꠡꠣꠖꠣꠄꠅꠞ ꠙꠥꠀ ꠡꠣꠟꠥꠝꠤꠟ ꠅꠁꠟꠣ ꠔꠣꠞꠣꠞ ꠡꠞ꠆ꠖꠣꠞ, ");
INSERT INTO syls_vpl VALUES ("NU2_13","005_2_13","NUM","2","13","13","ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠃꠘꠥꠡꠣꠁꠐ ꠀꠎꠣꠞ ꠔꠤꠘ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_14","005_2_14","NUM","2","14","14","ꠖꠥꠍꠞꠣ ꠉꠣꠟꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠛꠣ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠦ, ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠖꠥꠄꠟꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠍꠚ, ");
INSERT INTO syls_vpl VALUES ("NU2_15","005_2_15","NUM","2","15","15","ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠙꠣꠌ꠆ꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_16","005_2_16","NUM","2","16","16","ꠞꠥꠛꠦꠘꠞ ꠙꠔꠣꠇꠣꠞ ꠅꠃ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠉꠘꠣ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠥꠐ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠄꠇ ꠟꠣꠈ ꠄꠇꠣꠘ꠆ꠘ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ। ꠍꠚꠞꠞ ꠡꠝꠄ ꠔꠣꠞꠣ ꠖꠥꠍꠞꠣ ꠇꠣꠚꠦꠟꠣꠔ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU2_17","005_2_17","NUM","2","17","17","“ꠛꠣꠖꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞꠦ ꠟꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣ, ꠢꠇꠟꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠄꠞꠣ ꠞꠁꠛꠣ। ꠎꠣꠞꠎꠤꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠘꠣꠘꠤꠞ ꠍꠤꠞꠤꠀꠟ ꠝꠣꠚꠤꠇ ꠟꠣꠁꠘ ꠗꠞꠤꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠛꠣ। ꠚꠃꠎꠤ ꠖꠟꠞ ꠎꠣꠞꠎꠤꠞ ꠙꠔꠣꠇꠣꠞ ꠝꠣꠘꠥꠡ ꠘꠤꠎꠞ ꠖꠟꠞ ꠟꠉꠦ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU2_18","005_2_18","NUM","2","18","18","“ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠙꠁꠌꠝꠞ ꠉꠣꠟꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠛꠣ, ꠀꠚꠞꠣꠁꠝ ꠙꠔꠣꠇꠣꠞ ꠔꠤꠘꠅ ꠚꠃꠎꠤ ꠖꠟꠞ ꠝꠣꠘꠡꠦ। ꠀꠚꠞꠣꠁꠝ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠀꠝꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠀꠟꠤꠡꠣꠝꠣ, ");
INSERT INTO syls_vpl VALUES ("NU2_19","005_2_19","NUM","2","19","19","ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_20","005_2_20","NUM","2","20","20","ꠄꠞꠣꠞ ꠄꠇ ꠉꠣꠟꠣꠔ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠛꠣ, ꠚꠣꠔꠡꠥꠞꠞ ꠙꠥꠀ ꠉꠝꠟꠤꠄꠟ ꠅꠁꠟꠣ ꠔꠣꠞꠣꠞ ꠡꠞ꠆ꠖꠣꠞ, ");
INSERT INTO syls_vpl VALUES ("NU2_21","005_2_21","NUM","2","21","21","ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠛꠔ꠆ꠔꠤꠡ ꠀꠎꠣꠞ ꠖꠥꠁ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_22","005_2_22","NUM","2","22","22","ꠀꠞ ꠖꠥꠍꠞꠣ ꠉꠣꠟꠣꠔ ꠞꠁꠛꠣ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠄꠞꠣꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠎꠤꠖꠣꠃꠘꠤꠞ ꠙꠥꠀ ꠀꠛꠤꠖꠣꠘ, ");
INSERT INTO syls_vpl VALUES ("NU2_23","005_2_23","NUM","2","23","23","ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠙꠣꠄꠔꠤꠡ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_24","005_2_24","NUM","2","24","24","ꠀꠚꠞꠣꠁꠝꠞ ꠙꠔꠣꠇꠣꠞ ꠅꠃ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠉꠘꠣ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠥꠐ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠄꠇ ꠟꠣꠈ ꠀꠐ ꠀꠎꠣꠞ ꠄꠇ-ꠡ ꠎꠘ। ꠔꠣꠞꠣ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠇꠣꠚꠦꠟꠣꠔ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU2_25","005_2_25","NUM","2","25","25","“ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠃꠔ꠆ꠔꠞ ꠉꠣꠟꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠛꠣ ꠖꠣꠘ ꠙꠔꠣꠇꠣꠞ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠚꠃꠎꠤ ꠖꠟꠞ ꠝꠣꠘꠡꠦ, ꠔꠣꠞꠣꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠀꠝꠤꠡꠣꠖꠣꠞ ꠙꠥꠀ ꠀꠈꠤꠀꠎꠣꠞ, ");
INSERT INTO syls_vpl VALUES ("NU2_26","005_2_26","NUM","2","26","26","ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠛꠣꠡꠐ꠆ꠐꠤ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_27","005_2_27","NUM","2","27","27","ꠄꠞꠣꠞ ꠄꠇ ꠉꠣꠟꠣꠔ ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠛꠣ, ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ, ꠃꠇꠞꠣꠘꠞ ꠙꠥꠀ ꠚꠎꠤꠄꠟ। ");
INSERT INTO syls_vpl VALUES ("NU2_28","005_2_28","NUM","2","28","28","ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠄꠇꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_29","005_2_29","NUM","2","29","29","ꠀꠞ ꠖꠥꠍꠞꠣ ꠉꠣꠟꠣꠔ ꠞꠁꠛꠣ ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ, ꠁꠘꠣꠘꠞ ꠙꠥꠀ ꠀꠢꠤꠞ। ");
INSERT INTO syls_vpl VALUES ("NU2_30","005_2_30","NUM","2","30","30","ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠔꠦꠙ꠆ꠙꠣꠘ꠆ꠘ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_31","005_2_31","NUM","2","31","31","ꠖꠣꠘꠞ ꠙꠔꠣꠇꠣꠞ ꠅꠃ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠉꠘꠣ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠥꠐ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠄꠇ ꠟꠣꠈ ꠡꠣꠔꠣꠘ꠆ꠘ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠎꠘ। ꠄꠞꠣ ꠢꠇꠟ ꠢꠦꠡꠞ ꠇꠣꠚꠦꠟꠣꠔ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU2_32","005_2_32","NUM","2","32","32","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠉꠘꠣ ꠅꠁꠟ। ꠉꠘꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠇꠟ ꠚꠃꠎꠤ ꠖꠟꠦ ꠍꠤꠙꠣꠁꠞ ꠎꠥꠇꠣ ꠝꠥꠐ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ, ꠍꠄ ꠟꠣꠈ ꠔꠤꠘ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU2_33","005_2_33","NUM","2","33","33","ꠔꠣ-ꠅ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠉꠘꠣꠞ ꠡꠝꠄ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠉꠘꠣꠔ ꠗꠞꠣ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU2_34","005_2_34","NUM","2","34","34","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠔꠣ ꠅꠃ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ। ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠖꠟꠞ ꠎꠣꠉꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠘꠣꠁꠔꠣ, ꠀꠞ ꠍꠚꠞꠅ ꠞꠅꠀꠘꠣ ꠅꠁꠔꠣ ꠘꠤꠎꠞ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠀꠙꠘ ꠚꠃꠎꠤ ꠖꠟꠞ ꠙꠔꠣꠇꠣꠞ ꠗꠣꠞꠅ ꠞꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("NU3_1","005_3_1","NUM","3","1","1","ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠟꠣ, ꠢꠃ ꠡꠝꠄ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠜꠣꠁ ꠝꠥꠍꠣꠞ ꠛꠋꠡ-ꠛꠥꠘꠤꠀꠖ ꠀꠍꠟꠣ ꠅꠃ ꠄꠁꠘꠔꠣꠁꠘ: ");
INSERT INTO syls_vpl VALUES ("NU3_2","005_3_2","NUM","3","2","2","ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠘꠣꠖꠣꠛ, ꠀꠛꠤꠢꠥ, ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠁꠍꠣꠝꠣꠞ। ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣꠖꠣꠛ ꠀꠍꠟꠣ ꠛꠠ। ");
INSERT INTO syls_vpl VALUES ("NU3_3","005_3_3","NUM","3","3","3","ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠥꠘꠞ ꠅꠃ ꠌꠣꠁꠞꠅ ꠙꠥꠀꠂꠘꠞꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠀ ꠄꠛꠣꠖꠔꠤ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_4","005_3_4","NUM","3","4","4","ꠅꠁꠟꠦ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠞꠅꠀꠞ ꠇꠣꠟꠅ, ꠘꠣꠖꠣꠛ ꠀꠞ ꠀꠛꠤꠢꠥꠄ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠔꠣꠁꠟ ꠘꠤꠅꠝ ꠜꠣꠋꠉꠤꠀ, ꠖꠥꠍꠞꠣ ꠀꠉꠥꠁꠘꠖꠤ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦꠃ ꠔꠣꠞꠣꠞ ꠝꠞꠘ ꠅꠁꠉꠦꠟ। ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠀꠅꠟꠣꠖ ꠘꠣ ꠕꠣꠇꠣꠄ, ꠔꠣꠞꠣꠞ ꠛꠣꠚ ꠢꠣꠞꠥꠘ ꠘꠛꠤꠞ ꠟꠉꠦ ꠞꠁꠀ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠁꠍꠣꠝꠣꠞꠦ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_5","005_3_5","NUM","3","5","5","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU3_6","005_3_6","NUM","3","6","6","“ꠔꠥꠝꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠘꠤꠀ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠅ, ꠔꠣꠞꠣ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠅ ꠔꠣꠘꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_7","005_3_7","NUM","3","7","7","ꠔꠣꠞꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠊꠞꠞ ꠈꠣꠖꠤꠝꠖꠣꠞꠤ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_8","005_3_8","NUM","3","8","8","ꠔꠣꠞꠣꠃ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠇ꠆ꠇꠦ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_9","005_3_9","NUM","3","9","9","ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠈꠣꠖꠤꠝ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠦꠅ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠞꠣꠞꠦ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_10","005_3_10","NUM","3","10","10","ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠛꠋꠡꠞꠦ ꠛꠣꠍꠤꠀ ꠘꠦꠅ। ꠔꠣꠞꠣ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠣꠔ ꠉꠦꠟꠦ ꠅꠉꠥꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU3_11","005_3_11","NUM","3","11","11","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠄꠅꠈꠣꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU3_12","005_3_12","NUM","3","12","12","“ꠢꠥꠘꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠊꠞꠅ ꠎꠘꠝ ꠟꠅꠀ ꠙꠄꠟꠣ ꠙꠥꠀꠞ ꠛꠖꠟꠣ ꠛꠣꠛꠔ, ꠀꠝꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ। ꠄꠞꠟꠣꠉꠤ ꠟꠦꠛꠤ ꠅꠇꠟ ꠀꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU3_13","005_3_13","NUM","3","13","13","ꠀꠍꠟꠦ ꠢꠇ꠆ꠇꠟ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘꠃ ꠀꠝꠣꠞ। ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠢꠇꠟ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠖꠤꠘ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠔꠦꠇ ꠙꠄꠟꠣ ꠙꠥꠀꠞꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠤ, ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠙꠥꠔ ꠅꠃꠇ ꠛꠣ ꠙꠡꠥꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠃꠇ। ꠔꠣꠞꠣ ꠔ ꠀꠝꠣꠞ, ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("NU3_14","005_3_14","NUM","3","14","14","ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU3_15","005_3_15","NUM","3","15","15","“ꠔꠥꠝꠤ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠉꠘꠅ। ꠄꠇ ꠝꠣꠡ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞꠦ ꠉꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU3_16","005_3_16","NUM","3","16","16","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠁꠘ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_17","005_3_17","NUM","3","17","17","ꠉꠘꠣꠞ ꠇꠣꠟꠅ ꠙꠣꠁꠟꠣ, ꠟꠦꠛꠤꠞ ꠙꠥꠀꠂꠘ ꠎꠣꠞꠍꠥꠘ, ꠇꠣꠢꠣꠔ ꠀꠞ ꠝꠣꠞꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("NU3_18","005_3_18","NUM","3","18","18","ꠎꠣꠞꠍꠥꠘꠞ ꠙꠥꠀꠂꠘ ꠟꠤꠛꠘꠤ ꠀꠞ ꠡꠤꠝꠦꠁ ꠀꠍꠟꠣ ꠖꠥꠁ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_19","005_3_19","NUM","3","19","19","ꠇꠣꠢꠣꠔꠞ ꠙꠥꠀꠂꠘ ꠁꠝꠞꠣꠘ, ꠁꠎꠢꠣꠞ, ꠢꠦꠛꠞꠘ ꠀꠞ ꠃꠎ꠆ꠎꠟ ꠅꠁꠟꠣ ꠌꠣꠁꠞ ꠜꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("NU3_20","005_3_20","NUM","3","20","20","ꠝꠣꠞꠣꠞꠤꠞ ꠙꠥꠀꠂꠘ ꠝꠢꠟꠤ ꠀꠞ ꠝꠥꠡꠤ ꠅꠁꠟꠣ ꠖꠥꠁ ꠜꠣꠁ। ꠄꠞꠣ ꠅꠁꠟꠣ ꠛꠋꠡ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("NU3_21","005_3_21","NUM","3","21","21","ꠎꠣꠞꠍꠥꠘ ꠀꠍꠟꠣ ꠟꠤꠛꠘꠤꠀ ꠀꠞ ꠡꠤꠝꠦꠁꠀ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("NU3_22","005_3_22","NUM","3","22","22","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠄꠇ ꠝꠣꠡ ꠀꠞ ꠄꠇ ꠝꠣꠡꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠢꠇꠟ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠉꠘꠤꠀ ꠡꠣꠠꠦ ꠡꠣꠔ ꠀꠎꠣꠞ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_23","005_3_23","NUM","3","23","23","ꠙꠌ꠆ꠌꠤꠝ ꠉꠣꠟꠣꠛꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠈꠞꠦꠖꠤ ꠎꠣꠞꠍꠥꠘꠤ ꠅꠇꠟꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠋꠉꠣꠘꠤ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("NU3_24","005_3_24","NUM","3","24","24","ꠎꠣꠞꠍꠥꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠙꠞꠗꠣꠘ ꠀꠍꠟꠣ ꠟꠣꠄꠄꠟꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠍꠚ। ");
INSERT INTO syls_vpl VALUES ("NU3_25","005_3_25","NUM","3","25","25","ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠣꠞꠍꠥꠘꠤ ꠅꠇꠟꠞ ꠃꠙꠞꠦ, ꠎꠦꠔꠣ ꠇꠣꠙꠠꠣꠁꠘ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠛꠣꠘꠣꠘꠤ ꠅꠁꠍꠦ ꠈꠣꠟꠤ ꠅꠔꠣ ꠇꠣꠙꠠ ꠅꠇꠟ, ꠛꠣꠞꠣ ꠛꠣꠎꠥꠞ ꠉꠤꠟꠣꠚ ꠀꠞ ꠍꠣꠘꠤ ꠅꠇꠟ ꠀꠞ ꠅꠃ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠛꠣꠞ ꠙꠞ꠆ꠖꠣ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_26","005_3_26","NUM","3","26","26","ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠎꠦ ꠃꠑꠣꠘ ꠀꠍꠦ ꠅꠉꠥꠞ ꠙꠞ꠆ꠖꠣꠁꠘ, ꠀꠞ ꠃꠑꠣꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠦ ꠉꠦꠁꠐ ꠀꠍꠦ ꠅꠃ ꠉꠦꠁꠐꠞ ꠙꠞ꠆ꠖꠣ, ꠀꠞ ꠡꠛ ꠞꠡꠤ ꠅꠇꠟꠞꠃ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣ, ꠀꠞ ꠅꠔꠣ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣ, ꠅꠃ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔꠣꠘꠔꠣꠘꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_27","005_3_27","NUM","3","27","27","ꠇꠣꠢꠣꠔ ꠀꠍꠟꠣ ꠁꠝꠞꠣꠘ, ꠁꠎꠢꠣꠞ, ꠢꠦꠛꠞꠘ ꠀꠞ ꠃꠎ꠆ꠎꠟ, ꠅꠃ ꠌꠣꠁꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("NU3_28","005_3_28","NUM","3","28","28","ꠅꠃ ꠉꠥꠡ꠆ꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠄꠇ ꠝꠣꠡ ꠛꠣ ꠔꠣꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠢꠇꠟ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠉꠘꠤꠀ ꠀꠐ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ꠄꠞꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠙꠛꠤꠔ꠆ꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_29","005_3_29","NUM","3","29","29","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠖꠇ꠆ꠇꠤꠘ ꠉꠣꠟꠣꠛꠣꠄ ꠇꠣꠢꠣꠔꠤ ꠅꠇꠟꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠋꠉꠣꠘꠤ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("NU3_30","005_3_30","NUM","3","30","30","ꠇꠣꠢꠣꠔꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠙꠞꠗꠣꠘ ꠀꠍꠟꠣ ꠃꠎ꠆ꠎꠟꠞ ꠙꠥꠀ ꠁꠟꠤꠎꠣꠚꠘ। ");
INSERT INTO syls_vpl VALUES ("NU3_31","005_3_31","NUM","3","31","31","ꠅꠃ ꠇꠣꠢꠣꠔꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ, ꠐꠦꠛꠥꠟ, ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ, ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟ, ꠙꠛꠤꠔ꠆ꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠄꠛꠣꠖꠔꠤꠞ ꠢꠇꠟ ꠎꠤꠘꠤꠡ ꠀꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣ, ꠟꠉꠦ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠇꠣꠝ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_32","005_3_32","NUM","3","32","32","ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠙꠞꠗꠣꠘ ꠀꠍꠟꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞ। ꠄꠞꠟꠉꠦ ꠙꠛꠤꠔ꠆ꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠎꠦꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠄꠞꠣꠞꠦ ꠘꠎꠞꠖꠣꠞꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_33","005_3_33","NUM","3","33","33","ꠝꠣꠞꠣꠞꠤ ꠀꠍꠟꠣ ꠝꠢꠟꠤ ꠀꠞ ꠝꠥꠡꠤꠞ ꠅꠃ ꠖꠥꠁ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("NU3_34","005_3_34","NUM","3","34","34","ꠅꠃ ꠉꠥꠡ꠆ꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠄꠇ ꠝꠣꠡ ꠛꠣ ꠔꠣꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠢꠇꠟ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠉꠘꠤꠀ ꠍꠄ ꠀꠎꠣꠞ ꠖꠥꠁ-ꠡ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_35","005_3_35","NUM","3","35","35","ꠝꠣꠞꠣꠞꠤꠀ ꠉꠥꠡ꠆ꠐꠤꠞ ꠙꠞꠗꠣꠘ ꠀꠍꠟꠣ ꠀꠛꠤꠄꠟꠞ ꠙꠥꠀ ꠍꠥꠞꠤꠄꠟ। ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠔꠞꠦꠖꠤ ꠔꠣꠞꠣꠞ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠋꠉꠣꠘꠤ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("NU3_36","005_3_36","NUM","3","36","36","ꠄꠞꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠚ꠆ꠞꠦꠁꠝ, ꠚ꠆ꠞꠦꠁꠝꠞ ꠛꠣꠔ꠆ꠔꠤ, ꠈꠥꠐꠤ, ꠌꠥꠘ꠆ꠉꠤ ꠀꠞ ꠄꠞ ꠢꠇꠟ ꠌꠤꠎ, ");
INSERT INTO syls_vpl VALUES ("NU3_37","005_3_37","NUM","3","37","37","ꠃꠑꠣꠘꠞ ꠛꠦꠠꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠈꠥꠐꠤ, ꠌꠥꠘ꠆ꠉꠤ, ꠛꠦꠠꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠞꠡꠤ ꠀꠞ ꠙꠦꠞꠦꠉꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_38","005_3_38","NUM","3","38","38","ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦꠖꠤ ꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠙꠥꠛꠦꠖꠤ ꠢꠎꠞꠔ ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠔꠣꠝ꠆ꠛꠥ ꠅꠇꠟ ꠐꠣꠋꠉꠣꠘꠤ ꠅꠁꠔ। ꠄꠞꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠙꠛꠤꠔ꠆ꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠔ ꠢꠇꠟ ꠄꠛꠣꠖꠔꠤ ꠇꠣꠝ ꠀꠖꠣꠄ ꠇꠞꠣ। ꠄꠞꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟꠦ ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠣꠅꠀ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("NU3_39","005_3_39","NUM","3","39","39","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ, ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠇ ꠝꠣꠡ ꠛꠣ ꠔꠣꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠢꠇꠟ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠉꠘꠤꠟꠣ, ꠉꠘꠤꠀ ꠛꠣꠁꠡ ꠀꠎꠣꠞ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_40","005_3_40","NUM","3","40","40","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘꠞꠦ ꠉꠘꠅ, ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠄꠇ ꠝꠣꠡ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠄꠞꠣꠞꠦ ꠉꠘꠤꠀ ꠄꠞꠣꠞ ꠘꠣꠝ ꠄꠇ ꠈꠣꠔꠣꠔ ꠟꠦꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("NU3_41","005_3_41","NUM","3","41","41","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠀꠝꠣꠞ ꠇꠁꠀ ꠉꠘꠣ ꠅꠁꠛ। ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠛꠖꠟꠣ ꠟꠦꠛꠤ ꠅꠇꠟꠞ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠀꠝꠣꠞ ꠇꠁꠀ ꠉꠘꠣ ꠅꠁꠛ। ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("NU3_42","005_3_42","NUM","3","42","42","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠙꠞꠤꠛꠣꠞꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_43","005_3_43","NUM","3","43","43","ꠔꠦꠃ ꠄꠇ ꠝꠣꠡ ꠛꠣ ꠔꠣꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠤ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠉꠘꠤꠀ ꠝꠥꠐ ꠛꠣꠁꠡ ꠀꠎꠣꠞ ꠖꠥꠁ-ꠡ ꠔꠦꠀꠔ꠆ꠔꠁꠞ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU3_44","005_3_44","NUM","3","44","44","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU3_45","005_3_45","NUM","3","45","45","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠛꠖꠟꠣ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠄꠟꠣ ꠙꠡꠥꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠛꠖꠟꠣ ꠟꠦꠛꠤ ꠅꠇꠟꠞ ꠙꠄꠟꠣ ꠙꠡꠥꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠀꠝꠣꠞ ꠇꠁꠀ ꠗꠞꠣ ꠅꠁꠛ। ꠟꠦꠛꠤ ꠅꠇꠟ ꠔ ꠀꠝꠣꠞ ꠅꠁꠛꠣ। ꠀꠝꠤꠃ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("NU3_46","005_3_46","NUM","3","46","46","ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠥꠐ ꠙꠞꠤꠝꠣꠘ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠙꠞꠤꠝꠣꠘ ꠖꠥꠁ-ꠡ ꠔꠦꠀꠔ꠆ꠔꠁꠞ ꠎꠘ ꠛꠦꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("NU3_47","005_3_47","NUM","3","47","47","ꠅꠃ ꠖꠥꠁ-ꠡ ꠔꠦꠀꠔ꠆ꠔꠁꠞ ꠎꠘꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠢꠤꠡꠣꠛꠦ, ꠙꠞꠔꠦꠇ ꠎꠘꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠙꠣꠌ ꠔꠟꠣ ꠞꠥꠙꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU3_48","005_3_48","NUM","3","48","48","ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠃ ꠞꠥꠙꠣ ꠘꠤꠀ ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠖꠤꠟꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU3_49","005_3_49","NUM","3","49","49","ꠔꠦꠃ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠖꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠘꠤꠛꠣꠞ ꠛꠣꠖꠦ, ꠔꠣꠞꠣꠞ ꠎꠔ ꠎꠘ ꠛꠣꠇꠤ ꠞꠁꠟꠣ, ꠄꠞꠣꠞ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠞꠥꠙꠣ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_50","005_3_50","NUM","3","50","50","ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ ꠀꠎꠣꠞ ꠔꠤꠘ-ꠡ ꠙꠄꠡꠐ꠆ꠐꠤ ꠔꠟꠣ ꠞꠥꠙꠣ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU3_51","005_3_51","NUM","3","51","51","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣꠄ ꠅꠃ ꠞꠥꠙꠣ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_1","005_4_1","NUM","4","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU4_2","005_4_2","NUM","4","2","2","“ꠔꠥꠝꠞꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠞ ꠇꠣꠢꠣꠔꠤ ꠅꠇꠟ ꠀꠟꠣꠖꠣ ꠇꠞꠤ ꠉꠘꠅ, ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠙꠞꠤꠛꠣꠞ ꠀꠞ ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠉꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("NU4_3","005_4_3","NUM","4","3","3","ꠔꠤꠡ ꠕꠣꠇꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠞ ꠎꠦꠔꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣꠔ ꠀꠁꠛꠣ, ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU4_4","005_4_4","NUM","4","4","4","“ꠇꠣꠢꠣꠔꠤ ꠅꠇꠟꠞ ꠇꠣꠝ ꠅꠁꠛ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠌꠤꠎ ꠅꠇꠟꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_5","005_4_5","NUM","4","5","5","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠍꠚꠞꠅ ꠛꠣꠞꠘꠤꠞ ꠡꠝꠄ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠀꠝꠣꠞ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ, ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣ ꠈꠥꠟꠤꠀ ꠢꠣꠞꠤ, ꠅꠈꠣꠘꠖꠤ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞꠦ ꠉꠥꠞꠤꠀ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_6","005_4_6","NUM","4","6","6","ꠄꠞ ꠃꠙꠞꠦ ꠖꠞꠤꠀꠞ ꠚꠥʼ ꠝꠣꠍꠞ ꠌꠣꠝꠠꠣꠞ ꠉꠤꠟꠣꠚꠖꠤ ꠉꠥꠞꠤꠛꠣ, ꠛꠣꠖꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠟꠤꠟꠥꠀ ꠞꠋꠉꠞ ꠄꠇꠈꠣꠘ ꠇꠣꠙꠠꠖꠤ ꠉꠥꠞꠤꠀ ꠖꠤꠀ, ꠡꠘ꠆ꠖꠥꠇ ꠛꠁꠀ ꠘꠤꠛꠣꠞ ꠛꠦꠘ꠆ꠖꠣ ꠉꠥꠁꠘ ꠎꠣꠉꠣ ꠝꠔ ꠢꠣꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_7","005_4_7","NUM","4","7","7","ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ ꠞꠣꠈꠣꠞ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠔꠣꠞꠣ ꠟꠤꠟꠥꠀ ꠞꠋꠉꠞ ꠄꠇꠈꠣꠘ ꠇꠣꠙꠠ ꠛꠤꠍꠣꠁꠀ, ꠅꠈꠣꠘꠞ ꠃꠙꠞꠦ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟ ꠕꠣꠟ-ꠛꠣꠡꠘ, ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠓꠣꠟꠤꠛꠣꠞ ꠎꠉ-ꠝꠉ ꠕꠁꠛꠣ। ꠙꠛꠤꠔ꠆ꠞ ꠎꠦꠔꠣ ꠞꠥꠐꠤ ꠢꠣꠝꠦꠡꠣ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠕꠅꠀ ꠕꠣꠇꠦ, ꠁꠔꠣ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦꠃ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU4_8","005_4_8","NUM","4","8","8","ꠅꠔꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠟ ꠄꠇꠈꠣꠘ ꠇꠣꠙꠠ ꠛꠤꠍꠣꠁꠀ, ꠚꠥʼꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠅꠈꠣꠘꠞꠦ ꠉꠥꠞꠤꠛꠣ, ꠀꠞ ꠐꠦꠛꠥꠟ ꠛꠁꠀ ꠘꠤꠛꠣꠞ ꠛꠦꠘ꠆ꠖꠣ ꠉꠥꠁꠘ ꠎꠣꠉꠣ ꠝꠔ ꠢꠣꠞꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_9","005_4_9","NUM","4","9","9","ꠛꠣꠖꠦ ꠟꠤꠟꠥꠀ ꠄꠇꠈꠣꠘ ꠇꠣꠙꠠꠖꠤ ꠀꠡ꠆ꠔꠣ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ, ꠄꠞ ꠌꠦꠞꠣꠉ ꠅꠇꠟ, ꠌꠦꠞꠣꠉꠞ ꠚꠤꠔꠣ ꠍꠣꠚ ꠇꠞꠣꠞ ꠌꠤꠝꠐꠣ, ꠎꠣꠟꠣꠁꠟ ꠚꠤꠔꠣꠞ ꠍꠣꠟꠤ ꠕꠅꠀꠞ ꠛꠣꠐꠤ ꠀꠞ ꠔꠦꠟꠞ ꠚꠤꠚꠣꠞꠦ ꠉꠥꠞꠤꠀ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_10","005_4_10","NUM","4","10","10","ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠡꠝꠦꠔ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞꠦ ꠚꠥʼꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠛꠦꠞꠣꠁꠀ, ꠛꠁꠀ ꠘꠤꠛꠣꠞ ꠈꠣꠐꠤꠀꠞ ꠃꠙꠞꠦ ꠕꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_11","005_4_11","NUM","4","11","11","ꠀꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠡꠥꠘꠣꠞ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠟꠤꠟꠥꠀ ꠄꠇꠈꠣꠘ ꠇꠣꠙꠠ ꠛꠤꠍꠣꠁꠀ, ꠚꠥʼꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠉꠥꠞꠤꠀ ꠖꠤꠛꠣ, ꠛꠣꠖꠦ ꠅꠃ ꠐꠦꠛꠥꠟ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠛꠦꠘ꠆ꠖꠣ ꠉꠥꠁꠘ ꠎꠣꠉꠣ ꠝꠔ ꠢꠣꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_12","005_4_12","NUM","4","12","12","ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠈꠦꠎꠝꠔꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠔꠣꠞꠣ ꠟꠤꠟꠥꠀ ꠇꠣꠙꠠꠖꠤ ꠙꠦꠌꠣꠁꠀ, ꠚꠥʼꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠉꠥꠞꠤꠀ ꠢꠣꠞꠤ, ꠅꠔꠣ ꠛꠁꠀ ꠘꠤꠛꠣꠞ ꠈꠣꠐꠤꠀꠞ ꠃꠙꠞꠦ ꠕꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_13","005_4_13","NUM","4","13","13","“ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟ ꠍꠣꠟꠤ ꠚꠣꠟꠣꠁꠀ, ꠛꠣꠁꠋꠉꠘꠤ ꠞꠋꠉꠞ ꠄꠇꠈꠣꠘ ꠉꠤꠟꠣꠚꠖꠤ ꠉꠥꠞꠤꠀ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_14","005_4_14","NUM","4","14","14","ꠛꠣꠖꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠅꠇꠟ, ꠅꠞ꠆ꠕꠣꠔ ꠀꠋꠞꠣ ꠕꠅꠀꠞ ꠙꠣꠔꠤꠟ, ꠉꠥꠡ꠆ꠔ ꠔꠥꠟꠣꠞ ꠛꠠ ꠇꠣꠐꠣ-ꠍꠤꠚ, ꠍꠣꠟꠤ ꠔꠥꠟꠣꠞ ꠛꠠ ꠌꠣꠝꠌ, ꠟꠃ ꠕꠅꠀꠞ ꠛꠣꠐꠤ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠕꠁꠛꠣ। ꠕꠁꠀ ꠚꠥʼꠞ ꠌꠣꠝꠠꠣꠖꠤ ꠉꠥꠞꠤꠀ ꠖꠤꠀ, ꠄꠞ ꠛꠦꠘ꠆ꠖꠣ ꠉꠥꠁꠘ ꠑꠤꠇ ꠎꠣꠉꠣꠔ ꠢꠣꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_15","005_4_15","NUM","4","15","15","ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠎꠦꠛꠟꠣ ꠅꠃ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ ꠅꠇꠟ ꠀꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠢꠇꠟꠔꠣ ꠉꠥꠞꠤꠟꠤꠛꠣ, ꠔꠣꠞꠣ ꠔꠣꠝ꠆ꠛꠥ ꠔꠥꠟꠤꠀ ꠍꠚꠞꠅ ꠛꠣꠞꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠦꠛꠟꠣ ꠔꠤꠀꠞ ꠅꠁꠎꠤꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠅꠔꠣ ꠛꠁꠀ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠢꠣꠔꠤ ꠅꠇꠟ ꠀꠁꠛꠣ। ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠌꠤꠎꠞꠦ ꠀꠔꠖꠤ ꠍꠁꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣꠄ, ꠍꠁꠟꠦꠃ ꠝꠞꠛꠣ। ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠅꠃ ꠢꠇ꠆ꠇꠟ ꠎꠤꠘꠤꠡ ꠔꠣꠞꠣ ꠛꠁꠀ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_16","005_4_16","NUM","4","16","16","“ꠀꠞ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞꠞ ꠃꠙꠞꠦ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠔꠦꠟ, ꠎꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ, ꠙꠞ꠆ꠔꠤꠖꠤꠘꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠈꠦꠟꠣꠚꠔꠤ ꠡꠝꠎꠤꠛꠣꠞ ꠔꠦꠟꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠞꠁꠛ। ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ, ꠊꠞꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠝꠣꠘꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠀꠞ ꠔꠣꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞ ꠔꠖꠣꠞꠇꠤ ꠞꠁꠛ ꠀꠟꠤ-ꠀꠎꠞꠞ ꠃꠙꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU4_17","005_4_17","NUM","4","17","17","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU4_18","005_4_18","NUM","4","18","18","“ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠇꠣꠢꠣꠔꠤ ꠛꠋꠡ ꠕꠣꠇꠤ ꠇꠦꠃ ꠇꠦꠃ ꠎꠣꠔꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠕꠣꠇꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU4_19","005_4_19","NUM","4","19","19","ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠌꠤꠎ ꠅꠇꠟꠞ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠘꠣ ꠝꠞꠦ ꠛꠞꠋ ꠛꠣꠌꠤꠀ ꠞꠄ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠀꠝꠣꠞ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠉꠤꠀ ꠎꠣꠞꠎꠤꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠛꠥꠎꠣꠁ ꠖꠤꠛꠣ। ꠀꠞ ꠇꠦ ꠇꠤꠔꠣ ꠛꠁꠀ ꠘꠤꠔꠣ, ꠅꠔꠣꠅ ꠑꠤꠇ ꠇꠞꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_20","005_4_20","NUM","4","20","20","ꠅꠁꠟꠦ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠜꠤꠔꠞꠞ ꠅꠃ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ ꠄꠇ ꠙꠟꠇꠞ ꠟꠣꠉꠤꠅ ꠖꠦꠈꠣꠞ ꠘꠤꠅꠔꠦ ꠇꠣꠢꠣꠔꠤ ꠅꠇꠟ ꠜꠤꠔꠞꠦ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘꠃ ꠢꠣꠝꠣꠁꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣꠄ, ꠅꠃ ꠘꠤꠅꠔꠦ ꠢꠣꠝꠣꠁꠟꠦꠃ ꠝꠞꠤ ꠎꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU4_21","005_4_21","NUM","4","21","21","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU4_22","005_4_22","NUM","4","22","22","“ꠔꠥꠝꠤ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠎꠣꠞꠍꠥꠘꠤ ꠅꠇꠟꠞꠦ ꠉꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("NU4_23","005_4_23","NUM","4","23","23","ꠔꠤꠡ ꠕꠣꠇꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠞ ꠎꠦꠔꠣ ꠎꠣꠞꠍꠥꠘꠤ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ, ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU4_24","005_4_24","NUM","4","24","24","“ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠣ ꠀꠞ ꠜꠣꠞ ꠛꠅꠀꠞ ꠡꠝꠄ ꠎꠣꠞꠍꠥꠘꠤ ꠅꠇꠟꠞ ꠇꠣꠝ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("NU4_25","005_4_25","NUM","4","25","25","ꠀꠝꠣꠞ ꠊꠞꠞ ꠢꠇꠟ ꠙꠞ꠆ꠖꠣꠁꠘ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠀꠞ ꠄꠞ ꠉꠤꠟꠣꠚ, ꠔꠣꠞ ꠃꠙꠞꠞ ꠚꠥʼꠞ ꠌꠣꠝꠠꠣꠞ ꠍꠣꠘꠤ, ꠀꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠙꠞ꠆ꠖꠣ ꠛꠁꠀ ꠘꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("NU4_26","005_4_26","NUM","4","26","26","ꠄꠞꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠑꠣꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠙꠞ꠆ꠖꠣ ꠀꠞ ꠄꠞ ꠖꠠꠤ ꠅꠇꠟ, ꠃꠑꠣꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠉꠦꠁꠐꠞ ꠙꠞ꠆ꠖꠣ, ꠅꠔꠣꠞ ꠟꠉꠞ ꠖꠞꠇꠣꠞꠤ ꠢꠇꠟ ꠝꠣꠟ ꠔꠣꠞꠣ ꠛꠁꠀ ꠘꠤꠛꠣ, ꠀꠞ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠎꠔ ꠇꠣꠝ-ꠇꠣꠎ ꠀꠍꠦ, ꠁꠔꠣ ꠔꠣꠞꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_27","005_4_27","NUM","4","27","27","ꠜꠣꠞ ꠛꠁꠛꠣꠞ ꠇꠣꠝ ꠅꠃꠇ ꠛꠣ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠇꠣꠝ ꠅꠃꠇ, ꠢꠇꠟꠔꠣ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠎꠣꠞꠍꠥꠘꠤ ꠅꠇꠟꠦ ꠇꠞꠛꠣ। ꠔꠣꠞꠣ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠛꠁꠀ ꠘꠤꠔ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠃ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠀ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU4_28","005_4_28","NUM","4","28","28","ꠅꠔꠣꠃ ꠅꠁꠟ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝꠅ ꠎꠣꠞꠍꠥꠘꠤ ꠅꠇꠟꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ। ꠔꠣꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠔꠖꠣꠞꠇꠤ ꠇꠞꠛꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠁꠍꠣꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("NU4_29","005_4_29","NUM","4","29","29","“ꠔꠥꠝꠞꠣ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠝꠣꠞꠣꠞꠤꠀ ꠅꠇꠟꠞ ꠙꠞꠤꠝꠣꠘ ꠉꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("NU4_30","005_4_30","NUM","4","30","30","ꠔꠤꠡ ꠕꠣꠇꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠞ ꠎꠦꠔꠣ ꠝꠣꠞꠣꠞꠤꠀ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ, ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU4_31","005_4_31","NUM","4","31","31","ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠣꠎꠦ ꠝꠣꠞꠣꠞꠤꠀ ꠅꠇꠟꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠢꠇꠟ ꠚ꠆ꠞꠦꠁꠝ, ꠚ꠆ꠞꠦꠁꠝꠞ ꠛꠣꠔ꠆ꠔꠤ, ꠈꠥꠐꠤ ꠀꠞ ꠈꠥꠐꠤꠞ ꠔꠟꠞ ꠌꠥꠘ꠆ꠉꠤ ꠛꠁꠀ ꠘꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("NU4_32","005_4_32","NUM","4","32","32","ꠄꠞꠟꠉꠦ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠃꠑꠣꠘꠞ ꠢꠇꠟ ꠈꠥꠐꠤ ꠀꠞ ꠌꠥꠘ꠆ꠉꠤ, ꠃꠑꠣꠘꠞ ꠙꠞ꠆ꠖꠣ ꠐꠣꠘꠣꠘꠤꠞ ꠙꠦꠞꠦꠉ ꠀꠞ ꠖꠠꠤ ꠀꠞ ꠅꠔꠣꠞ ꠟꠉꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠎꠦꠔꠣ ꠖꠞꠇꠣꠞꠤ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠣꠞꠣ ꠛꠁꠀ ꠘꠤꠛꠣ। ꠔꠣꠞꠣ ꠇꠦ ꠇꠤꠔꠣ ꠛꠁꠀ ꠘꠤꠔ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠇꠁꠀ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU4_33","005_4_33","NUM","4","33","33","ꠅꠔꠣꠃ ꠅꠁꠟ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠣꠎꠦ ꠝꠣꠞꠣꠞꠤꠀ ꠉꠥꠡ꠆ꠐꠤꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ। ꠔꠣꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠔꠖꠣꠞꠇꠤ ꠇꠞꠛꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠁꠍꠣꠝꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU4_34","005_4_34","NUM","4","34","34","ꠔꠦꠃ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠢꠎꠞꠔ ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠇꠣꠢꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_35","005_4_35","NUM","4","35","35","ꠔꠤꠡ ꠕꠣꠇꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠎꠦꠔꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣꠞ ꠇꠕꠣ, ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_36","005_4_36","NUM","4","36","36","ꠉꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠖꠥꠁ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU4_37","005_4_37","NUM","4","37","37","ꠄꠞꠣꠃ ꠀꠍꠟꠣ ꠇꠣꠢꠣꠔꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠐ ꠝꠣꠘꠥꠡ, ꠎꠦꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠔꠣ। ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠞꠚꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_38","005_4_38","NUM","4","38","38","ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠎꠣꠞꠍꠥꠘꠤ ꠅꠇꠟꠞꠦ ꠉꠘꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU4_39","005_4_39","NUM","4","39","39","ꠔꠤꠡ ꠕꠣꠇꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠞ ꠎꠦꠔꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣꠞ ꠇꠕꠣ, ");
INSERT INTO syls_vpl VALUES ("NU4_40","005_4_40","NUM","4","40","40","ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠀ ꠢꠣꠞꠤ ꠖꠥꠁ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠔꠤꠡ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU4_41","005_4_41","NUM","4","41","41","ꠄꠞꠣꠃ ꠀꠍꠟꠣ ꠎꠣꠞꠍꠥꠘꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠐ ꠝꠣꠘꠥꠡ, ꠎꠦꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠔꠣ। ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_42","005_4_42","NUM","4","42","42","ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠝꠣꠞꠣꠞꠤꠀ ꠅꠇꠟꠞꠦ ꠉꠘꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU4_43","005_4_43","NUM","4","43","43","ꠔꠤꠡ ꠕꠣꠇꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠞ ꠎꠦꠔꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣꠞ ꠇꠕꠣ, ");
INSERT INTO syls_vpl VALUES ("NU4_44","005_4_44","NUM","4","44","44","ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠀ ꠔꠤꠘ ꠀꠎꠣꠞ ꠖꠥꠁ-ꠡ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU4_45","005_4_45","NUM","4","45","45","ꠄꠞꠣꠃ ꠀꠍꠟꠣ ꠝꠣꠞꠣꠞꠤꠀ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠐ ꠝꠣꠘꠥꠡ, ꠎꠦꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠔꠣ। ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠝꠣꠞꠚꠔꠦ ꠙꠣꠅꠀ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_46","005_4_46","NUM","4","46","46","ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠙꠞꠤꠛꠣꠞ ꠝꠣꠚꠤꠇ ꠢꠎꠞꠔ ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠀꠡ꠆ꠔꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU4_47","005_4_47","NUM","4","47","47","ꠔꠤꠡ ꠕꠣꠇꠤ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠎꠦꠔꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠦꠎꠝꠔ ꠀꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠛꠁꠀ ꠘꠤꠛꠣꠞ ꠇꠕꠣ, ");
INSERT INTO syls_vpl VALUES ("NU4_48","005_4_48","NUM","4","48","48","ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞꠦ ꠉꠘꠤꠀ ꠀꠐ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠀꠡꠤ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU4_49","005_4_49","NUM","4","49","49","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠝꠣꠞꠚꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠄꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠀꠞ ꠇꠦ ꠇꠤꠔꠣ ꠛꠁꠀ ꠘꠤꠔꠣ, ꠢꠇꠟꠔꠣ ꠛꠥꠎꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ। ꠝꠣꠛꠥꠖꠞ ꠖꠦꠅꠀ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠉꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_1","005_5_1","NUM","5","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU5_2","005_5_2","NUM","5","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠇꠦꠝ꠆ꠙ ꠕꠣꠇꠤ ꠢꠇꠟ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠖꠦꠄ, ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠗꠣꠔꠥ ꠛꠦꠝꠣꠞꠤ, ꠝꠞꠣ ꠟꠣꠡ ꠍꠁꠀ ꠎꠦꠞꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠍꠦ ꠔꠣꠞꠣꠞꠦꠅ ꠇꠦꠝ꠆ꠙ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("NU5_3","005_5_3","NUM","5","3","3","ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤ ꠅꠃꠇ, ꠅꠉꠥꠞꠦ ꠇꠦꠝ꠆ꠙ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠛꠣꠄ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙ ꠎꠣꠔꠦ ꠄꠞꠣ ꠘꠣꠙꠣꠇ ꠘꠣ ꠛꠣꠘꠣꠄ, ꠅꠃ ꠘꠤꠅꠔꠦ ꠅꠔꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠛꠣꠄ, ꠎꠣꠘ ꠔ, ꠡ꠆ꠛꠄꠅꠋ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU5_4","005_5_4","NUM","5","4","4","ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠟꠣ ꠇꠞꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠔꠣꠞꠣ ꠑꠤꠇ ꠅꠃꠟꠣꠃ ꠇꠞꠟꠣ। ꠔꠣꠞꠣ ꠘꠣꠙꠣꠇ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠇꠦꠝ꠆ꠙ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_5","005_5_5","NUM","5","5","5","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU5_6","005_5_6","NUM","5","6","6","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠖꠥꠍꠞꠣ ꠝꠣꠘꠡꠞ ꠈꠦꠔꠤ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤ ꠅꠁꠟꠦꠅ ꠘꠤꠌ꠆ꠌꠄ ꠖꠥꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("NU5_7","005_5_7","NUM","5","7","7","ꠢꠦ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠡ꠆ꠛꠤꠇꠣꠞꠥꠇ꠆ꠔꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠀꠞ ꠢꠦ ꠎꠦ ꠝꠣꠘꠡꠞ ꠈꠦꠔꠤ ꠇꠞꠍꠦ, ꠔꠣꠞꠦ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠎꠦ ꠎꠤꠘꠤꠡꠞ ꠈꠦꠔꠤ ꠇꠞꠍꠦ, ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠢꠤꠡꠣꠛꠦ ꠅꠃ ꠎꠤꠘꠤꠡꠞ ꠝꠥꠟ ꠖꠣꠝꠞ ꠟꠉꠦ ꠀꠞꠅ ꠙꠣꠌ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠛꠦꠡꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU5_8","005_5_8","NUM","5","8","8","ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠘꠦꠅꠀꠞ ꠎꠥꠇꠣ ꠝꠣꠘꠥꠡ ꠎꠥꠖꠤ ꠘꠣ ꠞꠂꠘ ꠀꠞ ꠔꠣꠞ ꠇꠥꠘꠥ ꠀꠙꠘ ꠎꠘ ꠘꠣ ꠕꠣꠇꠂꠘ, ꠔꠦ ꠁꠔꠣ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠅꠘꠣ ꠅꠁꠛ। ꠅꠃ ꠈꠦꠔꠤ-ꠙꠥꠞꠘ ꠀꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠐꠣ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_9","005_5_9","NUM","5","9","9","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠔ ꠎꠤꠘꠤꠡ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠛꠣ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠁꠝꠣꠝꠦ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_10","005_5_10","NUM","5","10","10","ꠙꠞꠔꠦꠇ ꠎꠘꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠎꠤꠘꠤꠡ ꠁꠝꠣꠝꠦ ꠙꠣꠁꠛꠣ। ꠁꠝꠣꠝꠞ ꠀꠔꠅ ꠎꠦ ꠎꠤꠘꠤꠡ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠁꠔꠣ ꠁꠝꠣꠝꠞꠃ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU5_11","005_5_11","NUM","5","11","11","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU5_12","005_5_12","NUM","5","12","12","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠇꠦꠃꠞꠞ ꠛꠃ ꠎꠥꠖꠤ ꠇꠥ-ꠙꠕꠦ ꠎꠣꠄꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("NU5_13","005_5_13","NUM","5","13","13","ꠀꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠟꠥꠇꠣꠁꠀ ꠀꠞꠇ ꠛꠦꠐꠣꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠤꠀ ꠅꠡꠔꠤ ꠛꠘꠦ, ꠔꠣꠁꠞ ꠎꠣꠝꠣꠁꠄ ꠁꠈꠣꠘ ꠘꠣ ꠎꠣꠘꠦ ꠛꠣ ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠡꠣꠇ꠆ꠇꠤꠅ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠣꠁ ꠇꠥꠘꠥ ꠗꠞꠣ ꠘꠣ-ꠅ ꠈꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU5_14","005_5_14","NUM","5","14","14","ꠄꠞꠛꠣꠖꠦꠅ ꠎꠣꠝꠣꠁꠄ ꠛꠃꠞꠦ ꠡꠘ꠆ꠖꠄ ꠇꠞꠤꠟꠣꠄ, ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠅꠡꠣꠘ꠆ꠔꠤ ꠇꠞꠦꠞ, ꠇꠤꠛꠣ ꠛꠃꠄ ꠇꠥꠘꠥ ꠅꠡꠔꠤ ꠇꠣꠝ ꠘꠣ ꠇꠞꠟꠦꠅ ꠎꠣꠝꠣꠁꠄ ꠈꠣꠟꠤ ꠔꠣꠁꠞꠦ ꠡꠘ꠆ꠖꠄ ꠇꠞꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ ꠅꠡꠣꠘ꠆ꠔꠤ ꠢꠣꠝꠣꠁꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU5_15","005_5_15","NUM","5","15","15","ꠔꠦ ꠎꠣꠝꠣꠁꠄ ꠔꠣꠞ ꠛꠃꠞꠦ ꠟꠁꠀ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠦ ꠅꠁꠛ। ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠔꠣꠞ ꠛꠃꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠖꠥꠁ ꠡꠦꠞ ꠛꠣꠞ꠆ꠟꠤꠞ ꠝꠄꠖꠣ ꠘꠤꠔꠦ ꠅꠁꠛ। ꠅꠃ ꠝꠄꠖꠣ ꠅꠁꠟ ꠡꠘ꠆ꠖꠄꠞ ꠟꠣꠉꠤ ꠍꠖꠉꠣ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠅꠙꠞꠣꠗ ꠎꠣꠁꠞ ꠇꠞꠣꠞ ꠍꠖꠉꠣ, ꠄꠞꠟꠣꠉꠤ ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠔꠦꠟ ꠛꠣ ꠈꠥꠡꠛꠄꠖꠣꠞ ꠟꠥꠛꠣꠘ ꠝꠤꠡꠣꠘꠤ ꠘꠤꠡꠦꠗ। ");
INSERT INTO syls_vpl VALUES ("NU5_16","005_5_16","NUM","5","16","16","“ꠁꠝꠣꠝꠦ ꠅꠃ ꠛꠦꠐꠣꠞ ꠛꠃꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠈꠣꠠꠣ ꠇꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_17","005_5_17","NUM","5","17","17","ꠀꠞ ꠝꠣꠐꠤꠞ ꠄꠇ ꠉꠣꠝꠟꠣꠞ ꠝꠣꠎꠦ ꠇꠤꠍꠥ ꠙꠛꠤꠔ꠆ꠞ ꠙꠣꠘꠤ ꠜꠞꠛꠣ, ꠜꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠜꠤꠔꠞꠞ ꠝꠣꠐꠤꠞ ꠃꠙꠞ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠗꠥꠁꠟ ꠔꠥꠟꠤꠀ ꠅꠃ ꠙꠣꠘꠤꠔ ꠍꠣꠠꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_18","005_5_18","NUM","5","18","18","ꠛꠦꠐꠤꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠛꠦꠐꠤꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠈꠥꠟꠤꠀ ꠖꠤꠛꠣ, ꠀꠞ ꠛꠦꠐꠤꠞ ꠅꠙꠞꠣꠗꠞ ꠢꠣꠍꠣ-ꠝꠤꠍꠣ ꠎꠣꠁꠞ ꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠘꠣ ꠍꠖꠉꠣꠞ ꠛꠣꠞ꠆ꠟꠤꠞ ꠝꠄꠖꠣꠞꠦ ꠔꠣꠁꠞ ꠀꠔꠅ ꠖꠤꠛꠣ। ꠖꠤꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠔꠅ ꠟꠁꠛꠣ ꠢꠃ ꠟꠣꠘ꠆ꠘꠔ ꠒꠣꠇꠤꠀ ꠀꠘꠣꠞ ꠔꠤꠔ꠆ꠔꠣ ꠙꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("NU5_19","005_5_19","NUM","5","19","19","ꠙꠣꠘꠤ ꠟꠁꠀ ꠁꠝꠣꠝꠦ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠇꠍꠝ ꠇꠞꠣꠁꠀ ꠇꠁꠛꠣ, ‘ꠔꠥꠝꠣꠞ ꠛꠤꠀꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠘꠣ ꠇꠞꠦ, ꠛꠣ ꠇꠥ-ꠙꠕꠦ ꠉꠤꠀ ꠔꠥꠝꠤ ꠅꠡꠔꠤ ꠘꠣ ꠅꠅ, ꠔꠦ ꠅꠃ ꠟꠣꠘ꠆ꠘꠔ ꠀꠘꠣꠞ ꠔꠤꠔ꠆ꠔꠣ ꠙꠣꠘꠤꠄ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("NU5_20","005_5_20","NUM","5","20","20","ꠅꠁꠟꠦ ꠛꠤꠀꠞ ꠛꠣꠖꠦ ꠇꠥ-ꠙꠕꠦ ꠉꠤꠀ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠛꠦꠐꠣꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠅꠡꠔꠤ ꠅꠅ,’ ");
INSERT INTO syls_vpl VALUES ("NU5_21","005_5_21","NUM","5","21","21","—ꠅꠈꠣꠘ ꠇꠁꠀ ꠁꠝꠣꠝꠦ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠘꠤꠎꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠒꠣꠇꠤꠀ ꠀꠘꠣꠞ ꠇꠍꠝ ꠇꠞꠣꠁꠀ ꠢꠣꠞꠤ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠛꠣ— ‘ꠔꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞꠦ ꠅꠃ ꠉꠎꠛ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠔꠥꠝꠣꠞ ꠘꠣꠞꠤ-ꠅꠋꠉ ꠘꠤꠡ꠆ꠔꠦꠎ ꠅꠁꠎꠣꠃꠇ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠦꠐ ꠚꠥꠟꠤꠀ ꠝꠥꠐꠣ ꠅꠁꠎꠣꠃꠇ। ꠔꠦꠃ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠣꠞ ꠡꠝꠣꠎꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠇꠥꠘꠥ ꠛꠖ꠆ꠖꠥꠀ ꠀꠞ ꠟꠣꠘ꠆ꠘꠔꠤ ꠇꠍꠝ ꠈꠣꠅꠀꠞ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠔꠣꠞꠣ ꠁꠀꠖ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("NU5_22","005_5_22","NUM","5","22","22","ꠀꠞ ꠅꠃ ꠟꠣꠘ꠆ꠘꠔ ꠀꠘꠣꠞ ꠙꠣꠘꠤ ꠔꠥꠝꠣꠞ ꠡꠞꠤꠟꠅ ꠢꠣꠝꠣꠁꠀ ꠎꠣꠘꠥ ꠅꠟꠣ ꠇꠣꠝ ꠇꠞꠦ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞ ꠙꠦꠐ ꠚꠥꠟꠤꠎꠣꠄ ꠀꠞ ꠔꠥꠝꠣꠞ ꠘꠣꠞꠤ-ꠅꠋꠉ ꠘꠤꠡ꠆ꠔꠦꠎ ꠅꠁꠎꠣꠄ।’ ꠔꠦꠃ ꠛꠦꠐꠤꠄ ꠇꠁꠛ, ‘ꠀꠝꠤꠘ, ꠅꠟꠣꠃ ꠅꠃꠇ।’ ");
INSERT INTO syls_vpl VALUES ("NU5_23","005_5_23","NUM","5","23","23","“ꠁꠝꠣꠝꠦ ꠅꠃ ꠟꠣꠘ꠆ꠘꠔ ꠀꠘꠣ ꠇꠍꠝꠞ ꠇꠕꠣ ꠄꠇ ꠌꠣꠝꠠꠣꠞ ꠃꠙꠞꠦ ꠟꠦꠈꠤꠀ ꠢꠣꠞꠤ, ꠙꠣꠘꠤ ꠓꠣꠟꠤꠀ ꠅꠃ ꠟꠦꠈꠣꠞ ꠇꠣꠟꠤ ꠔꠤꠔ꠆ꠔꠣ ꠙꠣꠘꠤꠔ ꠚꠣꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_24","005_5_24","NUM","5","24","24","ꠟꠣꠘ꠆ꠘꠔ ꠀꠘꠣꠞ ꠅꠃ ꠔꠤꠔ꠆ꠔꠣ ꠙꠣꠘꠤ ꠛꠦꠐꠤꠞꠦ ꠈꠣꠅꠀꠘꠤꠞ ꠛꠣꠖꠦ ꠛꠦꠐꠤꠞ ꠙꠦꠐꠅ ꠈꠥꠛ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ ꠙꠄꠖꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU5_25","005_5_25","NUM","5","25","25","ꠁꠝꠣꠝꠦ ꠙꠄꠟꠣ ꠅꠃ ꠛꠦꠐꠤꠞ ꠀꠔ ꠕꠣꠇꠤ ꠡꠘ꠆ꠖꠄꠞ ꠍꠖꠉꠣꠞ ꠝꠄꠖꠣ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠖꠥꠟꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠟꠁꠀ ꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_26","005_5_26","NUM","5","26","26","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠙꠥꠞꠣ ꠍꠖꠉꠣꠞ ꠛꠖꠟꠣ ꠅꠃ ꠝꠄꠖꠣ ꠕꠣꠇꠤ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠄꠇ ꠝꠥꠁꠐ ꠙꠞꠤꠝꠣꠘ ꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠎꠣꠟꠣꠁꠛꠣ, ꠀꠞ ꠢꠃ ꠔꠤꠔ꠆ꠔꠣ ꠙꠣꠘꠤ ꠛꠦꠐꠤꠞꠦ ꠈꠣꠅꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_27","005_5_27","NUM","5","27","27","ꠛꠦꠐꠤꠄ ꠎꠥꠖꠤ ꠎꠣꠝꠣꠁꠞ ꠟꠉꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠅꠡꠔꠤ ꠅꠁꠀ ꠕꠣꠇꠦ, ꠔꠦ ꠁ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠞ ꠛꠣꠖꠦꠃ ꠔꠣꠁꠞ ꠙꠦꠐꠅ ꠈꠥꠛ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ ꠅꠁꠛ। ꠔꠣꠁꠞ ꠙꠦꠐ ꠚꠥꠟꠤꠀ ꠝꠥꠐꠣ ꠅꠁꠛ, ꠀꠞ ꠘꠣꠞꠤ-ꠅꠋꠉ ꠘꠤꠡ꠆ꠔꠦꠎ ꠅꠁꠀ ꠀꠐꠈꠥꠞꠣ ꠛꠘꠤꠎꠤꠛ, ꠝꠣꠘꠡꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠁꠞ ꠘꠣꠝ ꠟꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_28","005_5_28","NUM","5","28","28","ꠅꠁꠟꠦ ꠔꠣꠁ ꠎꠥꠖꠤ ꠅꠡꠔꠤ ꠘꠣ ꠅꠁꠀ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠞꠄ, ꠔꠦ ꠔꠣꠁ ꠁ ꠟꠣꠘ꠆ꠘꠔ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠛ, ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠎꠘꠝ ꠖꠦꠅꠀꠞ ꠈꠦꠝꠔꠣꠅ ꠎꠣꠞꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU5_29","005_5_29","NUM","5","29","29","ꠎꠣꠝꠣꠁ-ꠛꠃꠞ ꠡꠘ꠆ꠖꠄꠞ ꠛꠤꠡꠄꠄ ꠀꠟ꠆ꠟꠣꠞ ꠀꠁꠘ ꠔ ꠅꠟꠣ। ꠇꠥꠘꠥ ꠛꠃ ꠎꠥꠖꠤ ꠎꠣꠝꠣꠁꠞ ꠡꠋꠡꠣꠞꠅ ꠞꠁꠀ ꠇꠥ-ꠙꠕꠦ ꠉꠤꠀ ꠅꠡꠔꠤ ꠛꠘꠦ, ");
INSERT INTO syls_vpl VALUES ("NU5_30","005_5_30","NUM","5","30","30","ꠛꠣ ꠎꠣꠝꠣꠁꠄ ꠔꠣꠞ ꠛꠃꠞꠦ ꠛꠖꠝꠣꠁꠡꠤꠞ ꠡꠘ꠆ꠖꠄ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠀꠁꠘ। ꠛꠦꠐꠣꠄ ꠔꠣꠞ ꠛꠃꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠛ ꠀꠞ ꠁꠝꠣꠝꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠦꠐꠤꠞ ꠃꠙꠞꠦ ꠛꠞ꠆ꠔꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU5_31","005_5_31","NUM","5","31","31","ꠔꠦꠃ ꠎꠣꠝꠣꠁꠄ ꠔꠣꠞ ꠘꠣꠟꠤꠡ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠛ, ꠀꠞ ꠛꠃ ꠢꠣꠍꠣꠞꠞ ꠅꠙꠞꠣꠗꠤ ꠅꠁꠟꠦ ꠔꠣꠁꠞ ꠡꠣꠎꠣ ꠛꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU6_1","005_6_1","NUM","6","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU6_2","005_6_2","NUM","6","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠄ ꠎꠥꠖꠤ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚ ꠇꠞꠔꠣ ꠌꠣꠁꠘ, ꠝꠣꠘꠤ ꠈꠣꠟꠤ ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤꠞ ꠟꠣꠉꠤ ꠀꠟꠣꠖꠣ ꠞꠅꠀꠞ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠤꠟꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU6_3","005_6_3","NUM","6","3","3","ꠔꠦ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠛꠣ ꠎꠦꠇꠥꠘꠥ ꠘꠝꠥꠘꠣꠞ ꠡꠞꠣꠛ ꠈꠣꠅꠀ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠘꠤꠌ꠆ꠌꠄ ꠢꠞꠤꠀ ꠕꠣꠇꠔꠦ ꠅꠁꠛ। ꠀꠋꠉꠥꠞꠞ ꠡꠤꠞ꠆ꠇꠣ ꠛꠣ ꠎꠦꠇꠥꠘꠥ ꠘꠝꠥꠘꠣꠞ ꠡꠤꠞ꠆ꠇꠣ ꠈꠣꠅꠀ ꠕꠣꠇꠤꠅ ꠔꠣꠞꠣ ꠛꠣꠌꠤꠀ ꠞꠁꠛ। ꠀꠞ ꠔꠣꠞꠣ ꠔꠣꠎꠣ ꠀꠋꠉꠥꠞ, ꠇꠤꠍꠝꠤꠍ, ꠛꠣ ꠀꠋꠉꠥꠞꠞ ꠞꠡꠅ ꠈꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU6_4","005_6_4","NUM","6","4","4","ꠝꠥꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠄꠞꠣ ꠎꠔꠖꠤꠘ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚꠅ ꠞꠁꠛ, ꠅꠔꠖꠤꠘ ꠀꠋꠉꠥꠞ ꠔ ꠖꠥꠞꠞ ꠇꠕꠣ, ꠀꠋꠉꠥꠞꠞ ꠄꠇꠐꠣ ꠛꠤꠌꠤ ꠛꠣ ꠛꠣꠇꠟꠅ ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘꠃ ꠈꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU6_5","005_6_5","NUM","6","5","5","“ꠀꠞ ꠎꠔꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚꠞ ꠘꠤꠅꠔꠦ ꠘꠤꠎꠞꠦ ꠀꠟꠣꠖꠣ ꠞꠣꠈꠣꠞ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠍꠂꠘ, ꠅꠔꠖꠤꠘ ꠔꠣꠞꠣꠞ ꠝꠣꠕꠣꠔ ꠈꠥꠞ-ꠛꠦꠟꠦꠁꠐ ꠟꠣꠉꠣꠘꠤ ꠘꠤꠡꠦꠗ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠟꠣꠖꠣ ꠞꠅꠀꠞ ꠡꠝꠄ ꠄꠞꠣ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠞꠁꠔꠦ ꠅꠁꠛ। ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠟꠣꠝ꠆ꠛꠣ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU6_6","005_6_6","NUM","6","6","6","ꠁ ꠡꠝꠄ ꠇꠥꠘꠥ ꠝꠞꠣ ꠟꠣꠡꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU6_7","005_6_7","NUM","6","7","7","ꠔꠣꠞꠣꠞ ꠝꠣ-ꠛꠣꠛꠣ, ꠜꠣꠁ-ꠛꠁꠘ ꠇꠦꠃ ꠝꠣꠞꠣ ꠉꠦꠟꠦꠅ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠞꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠄꠞꠣꠞ ꠝꠣꠕꠣꠞ ꠝꠣꠎꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠀꠟꠣꠖꠣ ꠞꠅꠀꠞ ꠘꠤꠡꠣꠘꠣ ꠌꠥꠟ ꠟꠣꠉꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU6_8","005_6_8","NUM","6","8","8","ꠔꠣꠞꠣꠞ ꠁ ꠀꠟꠣꠖꠣ ꠞꠅꠀꠞ ꠝꠤꠀꠖ ꠘꠣ ꠙꠥꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠞꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU6_9","005_6_9","NUM","6","9","9","“ꠀꠞ ꠀꠈꠔꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠎꠥꠖꠤ ꠔꠣꠞ ꠍꠣꠝꠘꠦ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠅꠃ ꠝꠞꠣꠞ ꠖꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠞꠣꠈꠣ ꠔꠣꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠣꠁꠛ, ꠀꠞ ꠢꠤꠞꠛꠣꠞ ꠙꠣꠇ ꠅꠀꠞ ꠟꠣꠉꠤ ꠡꠣꠔ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠞ ꠝꠣꠕꠣ ꠇꠣꠝꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU6_10","005_6_10","NUM","6","10","10","ꠀꠞ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠢꠦ ꠖꠥꠁꠐꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠛꠣ ꠖꠥꠁꠐꠣ ꠙꠣꠞꠅ ꠟꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠅ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU6_11","005_6_11","NUM","6","11","11","ꠝꠞꠣ ꠟꠣꠡꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠢꠦ ꠘꠣꠙꠣꠇ ꠅꠀꠄ, ꠅꠈꠘ ꠔꠣꠞ ꠘꠣꠙꠣꠇꠤꠞ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠁꠝꠣꠝꠦ ꠄꠇꠐꠣ ꠙꠣꠈꠤ ꠖꠤꠀ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠖꠥꠍꠞꠣ ꠙꠣꠈꠤ ꠖꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ꠅꠃ ꠖꠤꠘꠃ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠣꠞ ꠝꠣꠕꠣꠞꠦ ꠘꠄꠀ ꠇꠞꠤ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠞꠣꠈꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU6_12","005_6_12","NUM","6","12","12","ꠀꠞ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠢꠤꠞꠛꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠟꠣꠖꠣ ꠞꠅꠀꠞ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠣ ꠟꠣꠉꠛ। ꠄꠞꠟꠉꠦ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛ। ꠔꠣ-ꠅ ꠀꠉꠦ ꠎꠔꠖꠤꠘ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠟꠣꠖꠣ ꠞꠁꠍꠤꠟ, ꠁꠔꠣ ꠛꠣꠔꠤꠟ ꠅꠁꠎꠤꠛ, ꠇꠣꠞꠘ ꠢꠤ ꠡꠝꠄ ꠢꠦ ꠘꠣꠙꠣꠇ ꠅꠁꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU6_13","005_6_13","NUM","6","13","13","“ꠎꠦꠇꠥꠘꠥ ꠎꠘꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚꠞ ꠝꠤꠀꠖ ꠙꠥꠞꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU6_14","005_6_14","NUM","6","14","14","ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ꠀꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠤ-ꠛꠣꠁꠌ꠆ꠌꠣ, ꠄꠞꠟꠉꠦ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠣ ꠀꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU6_15","005_6_15","NUM","6","15","15","ꠅꠔꠣꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠀꠘꠛ, ꠄꠞꠟꠉꠦ ꠘꠤꠞꠦꠇ ꠉꠥꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠔꠦꠟꠖꠤ ꠜꠣꠎꠣ ꠄꠇ ꠐꠥꠇꠞꠤ ꠙꠤꠑꠣ ꠀꠞ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠌꠣꠙꠣꠐꠤ ꠛꠣꠘꠣꠁꠅ। ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠔꠃ ꠈꠣꠝꠤꠞ ꠝꠤꠡꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU6_16","005_6_16","NUM","6","16","16","ꠁꠝꠣꠝꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠀ ꠢꠣꠞꠤ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠉꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU6_17","005_6_17","NUM","6","17","17","ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠟꠉꠦꠅ ꠅꠟꠣ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠖꠤꠛꠣ। ꠄꠞꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU6_18","005_6_18","NUM","6","18","18","ꠛꠣꠖꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚ ꠇꠞꠞꠣ ꠎꠘꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠁꠀ, ꠅꠃ ꠌꠥꠟ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠔꠟꠞ ꠀꠉꠥꠁꠘꠅ ꠚꠣꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU6_19","005_6_19","NUM","6","19","19","ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠞꠣꠈꠣ ꠅꠃ ꠌꠥꠟ ꠇꠣꠝꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣꠞ ꠡꠤꠖ꠆ꠖ ꠇꠞꠣ ꠄꠇꠈꠣꠘ ꠉꠞ꠆ꠖꠘꠣ ꠀꠞ ꠐꠥꠇꠞꠤ ꠕꠣꠇꠤ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠄꠇꠈꠣꠘ ꠙꠤꠑꠣ ꠀꠞ ꠄꠇꠈꠣꠘ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠌꠣꠙꠣꠐꠤ ꠘꠤꠀ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚ ꠇꠞꠞꠣ ꠎꠘꠞ ꠀꠔꠅ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU6_20","005_6_20","NUM","6","20","20","ꠛꠣꠖꠦ ꠁꠝꠣꠝꠦ ꠅꠔꠣ ꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠃꠌꠣ ꠇꠞꠤ ꠖꠥꠟꠣꠁꠛꠣ। ꠁꠔꠣ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠁꠝꠣꠝꠞ ꠙꠣꠅꠘꠣ। ꠖꠥꠟꠣꠁꠀ ꠕꠅꠀ ꠍꠤꠘꠣꠞ ꠅꠃ ꠉꠥꠡ꠆ꠔ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠞꠣꠘꠅ ꠁꠝꠣꠝꠞ ꠙꠣꠅꠘꠣ। ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚ ꠇꠞꠞꠣ ꠅꠃ ꠎꠘꠦ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU6_21","005_6_21","NUM","6","21","21","“ꠁꠔꠣ ꠔ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚ ꠇꠞꠞꠣ ꠎꠘꠞ ꠟꠣꠉꠤ ꠀꠁꠘ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠟꠣꠖꠣ ꠞꠁꠀ ꠘꠣꠎꠤꠞꠤꠀ ꠄꠔꠦꠇꠣꠚꠞ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ, ꠅꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠀꠞ ꠎꠥꠖꠤ ꠔꠣꠞꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠝꠣꠚꠤꠇ ꠀꠞꠅ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔ ꠇꠞꠦ, ꠔꠦ ꠅꠔꠣꠅ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠟꠣꠖꠣ ꠞꠅꠀꠞ ꠝꠣꠘ꠆ꠘꠔ ꠝꠣꠚꠤꠇ ꠄꠔꠦꠇꠣꠚꠞ ꠎꠞꠥꠞꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠄꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU6_22","005_6_22","NUM","6","22","22","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU6_23","005_6_23","NUM","6","23","23","“ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠣꠞ ꠡꠝꠄ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠅꠟꠣ ꠇꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("NU6_24","005_6_24","NUM","6","24","24","ꠝꠣꠛꠥꠖꠦ ꠖꠦꠃꠇ꠆ꠇꠣ ꠞꠢꠝ-ꠛꠞꠇꠔ, ꠀꠞ ꠇꠞꠃꠇ꠆ꠇꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠦꠚꠣꠎꠔ। ");
INSERT INTO syls_vpl VALUES ("NU6_25","005_6_25","NUM","6","25","25","ꠔꠣꠘ ꠘꠥꠞꠞ ꠞꠥꠡꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠙꠠꠃꠇ, ꠔꠣꠘ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠢꠣꠝꠦꠡꠣ ꠎꠣꠞꠤ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("NU6_26","005_6_26","NUM","6","26","26","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠝꠥꠈ ꠈꠣꠘ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠣꠁꠘ, ꠀꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠣꠄ-ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU6_27","005_6_27","NUM","6","27","27","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠘꠣꠝ ꠟꠁꠛꠣ, ꠔꠦꠃ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU7_1","005_7_1","NUM","7","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠛꠣꠘꠣꠘꠤꠞ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠤ, ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠍꠤꠐꠣꠁꠀ ꠊꠞꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠟꠣ। ꠀꠞ ꠊꠞꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠕꠣꠟ-ꠛꠣꠡꠘ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_2","005_7_2","NUM","7","2","2","ꠅꠃ ꠖꠤꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠞ ꠃꠙꠢꠣꠞ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠄꠞꠣ ꠅꠁꠟꠣ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠙꠞꠗꠣꠘ ꠝꠣꠘꠥꠡ, ꠔꠣꠞꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠉꠘꠤꠀ ꠀꠟꠉ ꠇꠞꠣ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_3","005_7_3","NUM","7","3","3","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣ ꠍꠣꠘꠤ ꠀꠟꠣ ꠍꠄꠈꠣꠘ ꠉꠞꠥꠞ ꠉꠣꠠꠤ, ꠛꠣꠞꠅꠉꠥ ꠉꠞꠥ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠟꠣ। ꠙꠞꠔꠦꠇ ꠡꠞ꠆ꠖꠣꠞꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠄꠇꠐꠣ ꠇꠞꠤ ꠉꠞꠥ ꠀꠞ ꠖꠥꠁ ꠎꠘꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠄꠇꠈꠣꠘ ꠇꠞꠤ ꠉꠞꠥꠞ ꠉꠣꠠꠤ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠔꠣꠞꠣ ꠁꠔꠣ ꠀꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_4","005_7_4","NUM","7","4","4","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_5","005_7_5","NUM","7","5","5","“ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠔꠣ ꠡꠝꠎꠤꠀ ꠞꠣꠈꠅ, ꠎꠣꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠘꠤ ꠎꠣꠄ। ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠈꠣꠖꠤꠝ ꠅꠇꠟꠞ ꠇꠣꠝ ꠛꠥꠎꠤꠀ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠔꠣ ꠛꠣꠐꠤꠀ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU7_6","005_7_6","NUM","7","6","6","ꠄꠞꠟꠣꠉꠤ ꠝꠥꠍꠣꠄ ꠅꠃ ꠉꠣꠠꠤ ꠀꠞ ꠉꠞꠥ ꠅꠉꠥꠁꠘ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠈꠣꠖꠤꠝ ꠅꠇꠟꠞꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_7","005_7_7","NUM","7","7","7","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠟꠦꠛꠤꠞ ꠙꠄꠟꠣ ꠙꠥꠀ ꠎꠣꠞꠍꠥꠘꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠇꠣꠝ ꠝꠣꠚꠤꠇ ꠖꠥꠈꠣꠘ ꠉꠞꠥꠞ ꠉꠣꠠꠤ ꠀꠞ ꠌꠣꠁꠞꠉꠥ ꠉꠞꠥ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_8","005_7_8","NUM","7","8","8","ꠀꠞ ꠀꠞꠇ ꠙꠥꠀ ꠝꠣꠞꠣꠞꠤꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠇꠣꠝ ꠛꠥꠎꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠟꠣ ꠌꠣꠁꠞ ꠈꠣꠘ ꠉꠣꠠꠤ ꠀꠞ ꠀꠐꠉꠥ ꠉꠞꠥ। ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠁꠍꠣꠝꠣꠞꠦ ꠅꠃ ꠇꠣꠝꠞ ꠔꠖꠣꠞꠇꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_9","005_7_9","NUM","7","9","9","ꠅꠁꠟꠦ ꠟꠦꠛꠤꠞ ꠙꠥꠀ ꠇꠣꠢꠣꠔꠞ ꠉꠥꠡ꠆ꠐꠤꠞꠦ ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣ ꠖꠤꠟꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠘꠤꠅꠝ ꠀꠍꠤꠟ ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠌꠤꠎ ꠅꠇꠟ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣ, ꠀꠞ ꠅꠔꠣꠞꠦ ꠇꠣꠘ꠆ꠖꠅ ꠇꠞꠤ ꠛꠁꠀ ꠘꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("NU7_10","005_7_10","NUM","7","10","10","ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠍꠤꠐꠣꠘꠤꠞ ꠡꠝꠄ, ꠁꠈꠣꠘꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠀꠘꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_11","005_7_11","NUM","7","11","11","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠄꠇ ꠄꠇ ꠡꠞ꠆ꠖꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠘ ꠛꠈꠡꠤꠡ ꠀꠘꠤꠀ ꠡꠝꠎꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU7_12","005_7_12","NUM","7","12","12","ꠙꠄꠟꠣ ꠖꠤꠘ ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠀꠝꠤꠘꠣꠖꠣꠛꠞ ꠙꠥꠀ ꠘꠣꠢꠤꠡꠦ ꠔꠣꠘ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_13","005_7_13","NUM","7","13","13","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_14","005_7_14","NUM","7","14","14","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_15","005_7_15","NUM","7","15","15","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_16","005_7_16","NUM","7","16","16","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_17","005_7_17","NUM","7","17","17","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠀꠝꠤꠘꠣꠖꠣꠛꠞ ꠙꠥꠀ ꠘꠣꠢꠤꠡꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_18","005_7_18","NUM","7","18","18","ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠍꠥꠉꠣꠞꠞ ꠙꠥꠀ ꠘꠕꠘꠦꠟꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_19","005_7_19","NUM","7","19","19","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_20","005_7_20","NUM","7","20","20","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_21","005_7_21","NUM","7","21","21","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_22","005_7_22","NUM","7","22","22","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_23","005_7_23","NUM","7","23","23","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠍꠥꠉꠣꠞꠞ ꠙꠥꠀ ꠘꠕꠘꠦꠟꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_24","005_7_24","NUM","7","24","24","ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠢꠦꠟꠘꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠛꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_25","005_7_25","NUM","7","25","25","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_26","005_7_26","NUM","7","26","26","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_27","005_7_27","NUM","7","27","27","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_28","005_7_28","NUM","7","28","28","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_29","005_7_29","NUM","7","29","29","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠢꠦꠟꠘꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠛꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_30","005_7_30","NUM","7","30","30","ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠡꠣꠖꠤꠃꠞꠞ ꠙꠥꠀ ꠀꠟꠤꠍꠥꠞꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_31","005_7_31","NUM","7","31","31","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_32","005_7_32","NUM","7","32","32","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_33","005_7_33","NUM","7","33","33","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_34","005_7_34","NUM","7","34","34","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_35","005_7_35","NUM","7","35","35","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠡꠣꠖꠤꠃꠞꠞ ꠙꠥꠀ ꠀꠟꠤꠍꠥꠞꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_36","005_7_36","NUM","7","36","36","ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠡꠥꠞꠡꠣꠖꠣꠄꠅꠞ ꠙꠥꠀ ꠡꠣꠟꠥꠝꠤꠟꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_37","005_7_37","NUM","7","37","37","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_38","005_7_38","NUM","7","38","38","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_39","005_7_39","NUM","7","39","39","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_40","005_7_40","NUM","7","40","40","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_41","005_7_41","NUM","7","41","41","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠡꠥꠞꠡꠣꠖꠣꠄꠅꠞ ꠙꠥꠀ ꠡꠣꠟꠥꠝꠤꠟꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_42","005_7_42","NUM","7","42","42","ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠖꠥꠄꠟꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠍꠚꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_43","005_7_43","NUM","7","43","43","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_44","005_7_44","NUM","7","44","44","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_45","005_7_45","NUM","7","45","45","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_46","005_7_46","NUM","7","46","46","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_47","005_7_47","NUM","7","47","47","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠖꠥꠄꠟꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠍꠚꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_48","005_7_48","NUM","7","48","48","ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠀꠚꠞꠣꠁꠝ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠀꠝꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠀꠟꠤꠡꠣꠝꠣꠄ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_49","005_7_49","NUM","7","49","49","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_50","005_7_50","NUM","7","50","50","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_51","005_7_51","NUM","7","51","51","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_52","005_7_52","NUM","7","52","52","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_53","005_7_53","NUM","7","53","53","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠀꠝꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠀꠟꠤꠡꠣꠝꠣꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_54","005_7_54","NUM","7","54","54","ꠀꠐ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠚꠣꠔꠡꠥꠞꠞ ꠙꠥꠀ ꠉꠝꠟꠤꠄꠟꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_55","005_7_55","NUM","7","55","55","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_56","005_7_56","NUM","7","56","56","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_57","005_7_57","NUM","7","57","57","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_58","005_7_58","NUM","7","58","58","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_59","005_7_59","NUM","7","59","59","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠚꠣꠔꠡꠥꠞꠞ ꠙꠥꠀ ꠉꠝꠟꠤꠄꠟꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_60","005_7_60","NUM","7","60","60","ꠘꠄ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠎꠤꠖꠣꠃꠘꠤꠞ ꠙꠥꠀ ꠀꠛꠤꠖꠣꠘꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_61","005_7_61","NUM","7","61","61","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_62","005_7_62","NUM","7","62","62","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_63","005_7_63","NUM","7","63","63","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_64","005_7_64","NUM","7","64","64","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_65","005_7_65","NUM","7","65","65","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠎꠤꠖꠣꠃꠘꠤꠞ ꠙꠥꠀ ꠀꠛꠤꠖꠣꠘꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_66","005_7_66","NUM","7","66","66","ꠖꠡ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠀꠝꠤꠡꠣꠖꠣꠞ ꠙꠥꠀ ꠀꠈꠤꠀꠎꠣꠞꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_67","005_7_67","NUM","7","67","67","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_68","005_7_68","NUM","7","68","68","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_69","005_7_69","NUM","7","69","69","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_70","005_7_70","NUM","7","70","70","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_71","005_7_71","NUM","7","71","71","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠀꠝꠤꠡꠣꠖꠣꠞ ꠙꠥꠀ ꠀꠈꠤꠀꠎꠣꠞꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_72","005_7_72","NUM","7","72","72","ꠄꠉꠣꠞꠅ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠃꠇꠞꠣꠘꠞ ꠙꠥꠀ ꠚꠎꠤꠄꠟꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_73","005_7_73","NUM","7","73","73","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_74","005_7_74","NUM","7","74","74","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_75","005_7_75","NUM","7","75","75","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_76","005_7_76","NUM","7","76","76","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_77","005_7_77","NUM","7","77","77","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠃꠇꠞꠣꠘꠞ ꠙꠥꠀ ꠚꠎꠤꠄꠟꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_78","005_7_78","NUM","7","78","78","ꠛꠣꠞꠅ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠁꠘꠣꠘꠞ ꠙꠥꠀ ꠀꠢꠤꠞꠦ ꠛꠈꠡꠤꠡ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_79","005_7_79","NUM","7","79","79","ꠔꠣꠁꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇꠈꠣꠘ ꠕꠣꠟ, ꠀꠞ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ ꠃꠎꠘꠞ ꠞꠥꠙꠣꠞ ꠄꠇ ꠉꠣꠝꠟꠣ ꠀꠘꠤꠀ ꠖꠤꠟꠣ, ꠅꠃ ꠕꠣꠟ ꠀꠞ ꠉꠣꠝꠟꠣꠔ ꠜꠞꠣ ꠀꠍꠤꠟ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_80","005_7_80","NUM","7","80","80","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠖꠡ ꠔꠟꠣ ꠃꠎꠘꠞ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠛꠣꠐꠤ, ");
INSERT INTO syls_vpl VALUES ("NU7_81","005_7_81","NUM","7","81","81","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ, ꠄꠇꠐꠣ ꠝꠦꠠꠣ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ");
INSERT INTO syls_vpl VALUES ("NU7_82","005_7_82","NUM","7","82","82","ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU7_83","005_7_83","NUM","7","83","83","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠉꠞꠥ, ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ, ꠙꠣꠌꠉꠥ ꠍꠣꠉꠟ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠙꠣꠌꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠀꠍꠤꠟ ꠁꠘꠣꠘꠞ ꠙꠥꠀ ꠀꠢꠤꠞꠞ ꠃꠙꠢꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU7_84","005_7_84","NUM","7","84","84","ꠔꠦ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠖꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠣꠞ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠎꠦꠔꠣ ꠖꠣꠘ ꠇꠞꠍꠟꠣ ꠁꠔꠣ ꠅꠁꠟ, ꠛꠣꠞꠅ ꠈꠣꠘ ꠞꠥꠙꠣꠞ ꠕꠣꠟ, ꠛꠣꠞꠅꠐꠣ ꠞꠥꠙꠣꠞ ꠉꠣꠝꠟꠣ ꠀꠞ ꠛꠣꠞꠅꠐꠣ ꠡꠥꠘꠣꠞ ꠛꠣꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("NU7_85","005_7_85","NUM","7","85","85","ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠙꠞꠔꠦꠇ ꠞꠥꠙꠣꠞ ꠕꠣꠟꠞ ꠃꠎꠘ ꠀꠍꠤꠟ ꠄꠇ-ꠡ ꠔꠤꠡ ꠔꠟꠣ ꠀꠞ ꠉꠣꠝꠟꠣꠞ ꠃꠎꠘ ꠀꠍꠤꠟ ꠡꠔ꠆ꠔꠁꠞ ꠔꠟꠣ। ꠞꠥꠙꠣꠞ ꠢꠇꠟ ꠕꠣꠟ-ꠛꠣꠡꠘꠞ ꠝꠥꠐ ꠃꠎꠘ ꠀꠍꠤꠟ ꠖꠥꠁ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠔꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_86","005_7_86","NUM","7","86","86","ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠙꠞꠔꠦꠇ ꠡꠥꠘꠣꠞ ꠛꠣꠐꠤꠞ ꠃꠎꠘ ꠀꠍꠤꠟ ꠖꠡ ꠔꠟꠣ, ꠡꠥꠘꠣꠞ ꠛꠣꠞꠅꠐꠣ ꠛꠣꠐꠤꠞ ꠝꠥꠐ ꠃꠎꠘ ꠀꠍꠤꠟ ꠄꠇ-ꠡ ꠛꠤꠡ ꠔꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU7_87","005_7_87","NUM","7","87","87","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠥꠐ ꠛꠣꠞꠅꠉꠥ ꠛꠤꠍꠣꠟ, ꠛꠣꠞꠅꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠛꠣꠞꠅꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠅ ꠄꠞꠣ ꠖꠣꠘ ꠇꠞꠍꠟꠣ। ꠀꠞ ꠄꠞꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠢꠇꠟ ꠎꠤꠘꠤꠡ। ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠥꠐ ꠛꠣꠞꠅꠉꠥ ꠍꠣꠉꠟ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU7_88","005_7_88","NUM","7","88","88","ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠥꠐ ꠌꠛ꠆ꠛꠤꠡꠉꠥ ꠉꠞꠥ, ꠡꠣꠁꠐꠉꠥ ꠝꠦꠠꠣ, ꠡꠣꠁꠐꠉꠥ ꠍꠣꠉꠟ, ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠡꠣꠁꠐꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ। ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠍꠤꠐꠣꠁꠀ ꠢꠣꠞꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠣꠞ ꠡꠝꠄ ꠃꠙꠢꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠁ ꠢꠇꠟꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU7_89","005_7_89","NUM","7","89","89","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠎꠦꠛꠟꠣꠃ ꠝꠣꠛꠥꠖꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠁꠔꠣ, ꠅꠃ ꠡꠝꠄ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠦ ꠖꠥꠁꠅ ꠇꠣꠞꠥꠛꠤ ꠞꠂꠘ, ꠄꠞꠣꠞ ꠝꠣꠎꠈꠣꠘ ꠕꠣꠇꠤ ꠔꠣꠘ ꠛꠥꠟꠤ ꠢꠥꠘꠔꠣ। ꠝꠣꠛꠥꠖꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_1","005_8_1","NUM","8","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU8_2","005_8_2","NUM","8","2","2","“ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠅ, ꠀꠝꠣꠞ ꠊꠞꠞ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠝꠣꠎꠞ ꠡꠣꠔꠅꠐꠣ ꠌꠦꠞꠣꠉ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠟꠣꠉꠣꠁꠔꠣ, ꠎꠣꠔꠦ ꠌꠦꠞꠣꠉꠞ ꠚꠞ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠍꠣꠝꠘꠣ ꠛꠣꠄ ꠙꠠꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU8_3","005_8_3","NUM","8","3","3","ꠢꠣꠞꠥꠘꠦ ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ꠝꠥꠍꠣꠞꠦ ꠛꠣꠔꠣꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠁꠘ ꠢꠇꠟ ꠌꠦꠞꠣꠉ ꠅꠟꠣꠈꠣꠘ ꠛꠅꠀꠁꠟꠣ, ꠎꠣꠔꠦ ꠌꠦꠞꠣꠉꠞ ꠚꠞ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠍꠣꠝꠘꠦꠖꠤ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("NU8_4","005_8_4","NUM","8","4","4","ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠞ ꠔꠟ ꠕꠣꠇꠤ ꠀꠉꠣꠞ ꠚꠥꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠡ꠆ꠔꠣꠐꠣ ꠈꠣꠐꠤ ꠡꠥꠘꠣ ꠙꠤꠐꠣꠁꠀ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠘꠇꠡꠣ ꠖꠦꠈꠣꠁꠍꠟꠣ, ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU8_5","005_8_5","NUM","8","5","5","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU8_6","005_8_6","NUM","8","6","6","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ, ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠀꠟꠉ ꠇꠞꠤꠀ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("NU8_7","005_8_7","NUM","8","7","7","ꠁ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠝ ꠅꠁꠟ, ꠙꠄꠟꠣ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠀꠞ ꠙꠣꠘꠤ ꠍꠤꠐꠣꠁꠀ ꠖꠤꠛꠣꠄ, ꠍꠤꠐꠣꠁꠀ ꠔꠣꠞꠣ ꠘꠤꠎꠦ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠁꠀ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_8","005_8_8","NUM","8","8","8","ꠀꠞ ꠔꠣꠞꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠘꠛꠣ, ꠛꠤꠍꠣꠟꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤꠅ ꠀꠞꠇꠐꠣ ꠛꠤꠍꠣꠟ ꠀꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("NU8_9","005_8_9","NUM","8","9","9","ꠛꠣꠖꠦ ꠔꠥꠝꠤ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠛꠣꠄ, ꠀꠁꠀ ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠢꠘꠅ ꠖꠟꠣ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU8_10","005_8_10","NUM","8","10","10","ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠇꠞꠛꠣꠄ ꠀꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠀꠔꠣꠁꠀ ꠡꠙꠤꠀ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_11","005_8_11","NUM","8","11","11","ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠇ꠆ꠇ ꠕꠣꠇꠤ, ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠛꠈꠡꠤꠀ ꠖꠤꠛꠣ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠈꠦꠎꠝꠔꠅ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_12","005_8_12","NUM","8","12","12","ꠛꠣꠖꠦ ꠟꠦꠛꠤ ꠅꠇꠟꠦ ꠢꠃ ꠖꠥꠁꠅ ꠛꠤꠍꠣꠟꠞ ꠇꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠛꠣ, ꠖꠤꠟꠦ ꠔꠥꠝꠤ ꠄꠞ ꠄꠇꠐꠣ ꠖꠤꠀ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠖꠥꠍꠞꠣꠐꠣ ꠖꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠅꠟꠣꠈꠣꠘ ꠟꠦꠛꠤ ꠅꠇꠟꠞ ꠘꠣꠙꠣꠇꠤꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU8_13","005_8_13","NUM","8","13","13","ꠔꠥꠝꠤ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣ ꠇꠞꠣꠁꠀ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠡꠙꠤꠀ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU8_14","005_8_14","NUM","8","14","14","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠤ ꠅꠁꠘ꠆ꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠀꠟꠉ ꠇꠞꠛꠣꠄ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_15","005_8_15","NUM","8","15","15","“ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠇꠞꠤꠀ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠡꠙꠤꠀ ꠖꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠦꠎꠝꠔꠅ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_16","005_8_16","NUM","8","16","16","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠛꠣꠍꠤꠀ ꠀꠟꠉ ꠇꠞꠣ ꠁ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘ ꠈꠣꠟꠤ ꠀꠝꠣꠞ, ꠀꠞ ꠇꠦꠃꠞꠞ ꠘꠣꠄ। ꠙꠞꠔꠦꠇ ꠁꠍꠞꠣꠁꠟꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠞ ꠛꠖꠟꠣ ꠀꠝꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠣꠘꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU8_17","005_8_17","NUM","8","17","17","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠊꠞꠅ ꠎꠘꠝ ꠟꠅꠀ ꠢꠇꠟ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ ꠀꠝꠣꠞ। ꠀꠝꠤ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠇꠣꠟꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠔꠦꠇ ꠙꠄꠟꠣ ꠙꠥꠀꠞꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠤ, ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠙꠥꠔ ꠅꠃꠇ ꠛꠣ ꠙꠡꠥꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠃꠇ, ꠁꠔꠣ ꠔ ꠀꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU8_18","005_8_18","NUM","8","18","18","ꠀꠞ ꠅꠈꠘ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠎꠣꠉꠣꠔ ꠈꠣꠟꠤ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU8_19","005_8_19","NUM","8","19","19","ꠅꠃ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠀꠝꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠡꠝꠎꠣꠁꠍꠤ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠅꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠂꠘ, ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠞꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠃ ꠀꠝꠣꠞ ꠊꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠦꠅ ꠔꠣꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠉꠎꠛ ꠟꠣꠝꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU8_20","005_8_20","NUM","8","20","20","ꠝꠣꠛꠥꠖꠦ ꠟꠦꠛꠤ ꠅꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠅꠃ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_21","005_8_21","NUM","8","21","21","ꠟꠦꠛꠤ ꠅꠇꠟꠦ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠞꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠꠅ ꠕꠁꠟꠣ। ꠛꠣꠖꠦ ꠢꠣꠞꠥꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠡꠙꠤꠀ ꠖꠤꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_22","005_8_22","NUM","8","22","22","ꠄꠞꠛꠣꠖꠦ ꠟꠦꠛꠤ ꠅꠇꠟꠅ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠣꠖꠤꠝꠖꠣꠞꠤꠔ ꠉꠦꠟꠣ। ꠉꠦꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠟꠦꠛꠤ ꠅꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠑꠤꠇ ꠅꠃꠟꠣ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU8_23","005_8_23","NUM","8","23","23","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU8_24","005_8_24","NUM","8","24","24","“ꠟꠦꠛꠤ ꠅꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠃ ꠘꠤꠅꠝ ꠌꠣꠟꠥ ꠅꠁꠛ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠙꠌꠤꠡ ꠛꠍꠞ ꠛꠣ ꠔꠣꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠤ ꠝꠣꠘꠡꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("NU8_25","005_8_25","NUM","8","25","25","ꠅꠁꠟꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠅꠛꠡꠞ ꠙꠣꠁꠟꠤꠛꠣ, ꠈꠦꠎꠝꠔ ꠇꠣꠝ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU8_26","005_8_26","NUM","8","26","26","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠀꠔꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠣ ꠘꠤꠡꠦꠗ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠝꠘꠦ ꠌꠣꠁꠟꠦ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝꠅ ꠡꠣꠄ-ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ। ꠅꠃ ꠘꠤꠅꠝꠦ ꠔꠥꠝꠤ ꠟꠦꠛꠤ ꠅꠇꠟꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠑꠤꠇ ꠇꠞꠤ ꠖꠤꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU9_1","005_9_1","NUM","9","1","1","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞꠘꠤꠞ ꠖꠥꠍꠞꠣ ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠅ, ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠛꠣꠔꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU9_2","005_9_2","NUM","9","2","2","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠣꠘꠥ ꠑꠤꠇ ꠡꠝꠄꠄ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU9_3","005_9_3","NUM","9","3","3","ꠔꠣꠞꠣ ꠅꠃ ꠌꠣꠘ꠆ꠖꠞ ꠌꠃꠖ꠆ꠖ ꠔꠣꠞꠤꠈ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠀꠝꠣꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠤꠀ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU9_4","005_9_4","NUM","9","4","4","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("NU9_5","005_9_5","NUM","9","5","5","ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠞ ꠌꠃꠖ꠆ꠖ ꠔꠣꠞꠤꠈ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠅꠃ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠔꠣꠞꠣ ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ ꠢꠇꠟꠔꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_6","005_9_6","NUM","9","6","6","ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠄꠎꠘꠦ ꠝꠞꠣ ꠟꠣꠡꠞꠦ ꠍꠁꠀ ꠘꠣꠙꠣꠇ ꠅꠀꠄ, ꠅꠃ ꠖꠤꠘ ꠀꠎꠣꠖꠤ ꠁꠖ ꠇꠞꠔ ꠙꠣꠞꠟ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠖꠤꠘꠃ ꠔꠣꠞꠣ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠀꠎꠤꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_7","005_9_7","NUM","9","7","7","ꠔꠣꠞꠣ ꠝꠥꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠝꠞꠣ ꠟꠣꠡ ꠍꠅꠀꠄ ꠀꠝꠞꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠍꠤ, ꠄꠞꠟꠣꠉꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠑꠤꠇ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("NU9_8","005_9_8","NUM","9","8","8","ꠝꠥꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠘꠣ ꠎꠣꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠞꠣ ꠛꠣꠞ ꠌꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU9_9","005_9_9","NUM","9","9","9","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU9_10","005_9_10","NUM","9","10","10","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠛꠣ ꠔꠣꠞꠣꠞ ꠛꠋꠡꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠞꠣ ꠟꠣꠡꠞꠦ ꠗꠞꠣ-ꠍꠥꠀꠞ ꠇꠣꠞꠘꠦ ꠘꠣꠙꠣꠇ ꠛꠘꠤꠎꠣꠄ, ꠛꠣ ꠝꠥꠍꠣꠚꠤꠞ ꠢꠣꠟꠔꠦ ꠟꠣꠝ꠆ꠛꠣ ꠍꠚꠞꠅ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠣꠞꠣꠅ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_11","005_9_11","NUM","9","11","11","ꠖꠥꠍꠞꠣ ꠌꠣꠘ꠆ꠖꠞ ꠌꠃꠖ꠆ꠖ ꠔꠣꠞꠤꠈ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠔꠣꠞꠣ ꠅꠃ ꠁꠖ ꠇꠞꠛꠣ। ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠉꠥꠡ꠆ꠔꠞ ꠟꠉꠦ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠀꠞ ꠔꠤꠔ꠆ꠔꠣ ꠢꠣꠉ ꠙꠥꠞꠣꠁꠀ ꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_12","005_9_12","NUM","9","12","12","ꠛꠤꠀꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠘꠥꠎꠣꠔ ꠈꠣꠘꠤ ꠎꠝꠣ ꠞꠣꠈꠣ ꠘꠤꠡꠦꠗ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔꠞ ꠎꠦꠇꠥꠘꠥ ꠀꠒ꠆ꠒꠤ ꠜꠣꠋꠉꠣ ꠘꠤꠡꠦꠗ। ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠅꠃ ꠢꠇꠟ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠔꠣꠞꠣ ꠝꠣꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU9_13","005_9_13","NUM","9","13","13","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠢꠣꠟꠔꠦ ꠀꠍꠦ, ꠀꠞ ꠎꠦꠞꠣ ꠍꠚꠞꠞ ꠝꠣꠎꠦ ꠘꠣꠄ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠎꠘꠦ ꠎꠥꠖꠤ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠘꠣ ꠖꠦꠄ, ꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠑꠤꠇ ꠇꠞꠣ ꠡꠝꠄꠄ ꠇꠥꠞꠛꠣꠘꠤ ꠘꠣ ꠖꠦꠅꠀꠄ, ꠔꠣꠞ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠢꠦ ꠙꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU9_14","005_9_14","NUM","9","14","14","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠛꠤꠖꠦꠡꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠔ ꠌꠣꠄ, ꠔꠦ ꠇꠞꠔ ꠙꠣꠞꠛ। ꠅꠁꠟꠦ ꠅꠃ ꠁꠖꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠛꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠢꠇꠟꠦꠃ ꠄꠇꠁ ꠘꠤꠅꠝ ꠝꠣꠘꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU9_15","005_9_15","NUM","9","15","15","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥ ꠎꠦꠖꠤꠘ ꠈꠣꠠꠣ ꠇꠞꠣ ꠅꠁꠟ, ꠅꠃ ꠖꠤꠘ ꠇꠥꠖꠞꠔꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠀꠁꠀ ꠀꠡ꠆ꠔꠣ ꠊꠞꠞꠦ ꠉꠥꠞꠤꠟꠤꠟ। ꠢꠣꠁꠘ꠆ꠎꠣ ꠕꠣꠇꠤ ꠛꠤꠀꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠣꠞꠣ ꠞꠣꠁꠔ ꠁ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠞꠦ ꠘꠥꠞꠞ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠖꠦꠈꠣ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU9_16","005_9_16","NUM","9","16","16","ꠄꠞꠛꠣꠖ ꠕꠣꠇꠤ ꠅꠟꠣ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠢꠣꠝꠦꠡꠣ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠄ ꠉꠥꠞꠣ ꠞꠁꠔ, ꠀꠞ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠝꠘꠅ ꠅꠁꠔ ꠁꠔꠣ ꠘꠥꠞꠞ ꠀꠉꠥꠘꠤꠞ ꠈꠥꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("NU9_17","005_9_17","NUM","9","17","17","ꠀꠞ ꠙꠛꠤꠔ꠆ꠞ ꠔꠣꠝ꠆ꠛꠥꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠎꠦꠛꠟꠣ ꠢꠞꠔ, ꠅꠃ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ ꠍꠚꠞꠅ ꠛꠣꠞ ꠅꠁꠔꠣ, ꠛꠣꠖꠦ ꠎꠦꠘꠅ ꠉꠤꠀ ꠅꠃ ꠈꠥꠐꠤ ꠕꠤꠞ ꠅꠁꠔ, ꠔꠣꠞꠣ ꠅꠈꠣꠘꠅꠃ ꠔꠣꠝ꠆ꠛꠥ ꠅꠇꠟ ꠉꠣꠠꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_18","005_9_18","NUM","9","18","18","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠦ ꠔꠣꠞꠣ ꠍꠚꠞꠅ ꠛꠣꠞ ꠅꠁꠔꠣ ꠀꠞ ꠔꠣꠘ ꠢꠥꠇꠥꠝꠦꠃ ꠍꠚꠞ ꠛꠘ꠆ꠖ ꠇꠞꠤꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠔꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠙꠞꠦ ꠎꠔꠛꠁꠟ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠞꠁꠔ, ꠔꠣꠞꠣ ꠅꠔꠛꠁꠟ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠞꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_19","005_9_19","NUM","9","19","19","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠙꠞꠦ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠛꠦꠡꠤ ꠖꠤꠘ ꠞꠁꠟꠦ, ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠍꠚꠞꠅ ꠛꠣꠞ ꠅꠁꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_20","005_9_20","NUM","9","20","20","ꠝꠣꠎꠦ ꠝꠣꠎꠦ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠙꠞꠦ ꠕꠥꠠꠣ ꠖꠤꠘ ꠞꠁꠔ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠔ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠦ ꠇꠦꠝ꠆ꠙꠅ ꠞꠁꠔꠣ ꠀꠞ ꠔꠣꠘ ꠢꠥꠇꠥꠝꠦꠃ ꠢꠤꠞꠛꠣꠞ ꠍꠚꠞꠅ ꠛꠣꠞ ꠅꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_21","005_9_21","NUM","9","21","21","ꠀꠞ ꠝꠣꠎꠦ ꠝꠣꠎꠦ ꠈꠣꠟꠤ ꠢꠣꠁꠘ꠆ꠎꠣ ꠕꠣꠇꠤ ꠛꠤꠀꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠞꠁꠔ। ꠛꠤꠀꠘꠦ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠢꠞꠤꠉꠦꠟꠦ ꠔꠣꠞꠣ ꠍꠚꠞꠅ ꠛꠣꠞ ꠅꠁꠔꠣ। ꠖꠤꠘꠅ ꠛꠣ ꠞꠣꠁꠔ ꠎꠦꠇꠥꠘꠥ ꠡꠝꠄ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠢꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞꠣ ꠍꠚꠞꠅ ꠛꠣꠞ ꠅꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_22","005_9_22","NUM","9","22","22","ꠎꠔꠖꠤꠘ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠙꠞꠦ ꠞꠁꠔ, ꠅꠔꠖꠤꠘ ꠔꠣꠞꠣ ꠇꠦꠝ꠆ꠙꠅ ꠞꠁꠔꠣ, ꠍꠚꠞꠅ ꠛꠣꠞ ꠅꠁꠔꠣ ꠘꠣ। ꠁꠔꠣ ꠖꠥꠁ ꠖꠤꠘ ꠅꠃꠇ, ꠄꠇ ꠝꠣꠡ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠅꠁꠟꠦꠅ ꠛꠣꠞ ꠅꠁꠔꠣ ꠘꠣ, ꠈꠣꠟꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠢꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠍꠚꠞꠅ ꠛꠣꠞ ꠅꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU9_23","005_9_23","NUM","9","23","23","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠦ ꠔꠣꠞꠣ ꠇꠦꠝ꠆ꠙ ꠉꠣꠠꠤꠔꠣ ꠀꠞ ꠔꠣꠘ ꠢꠥꠇꠥꠝꠦꠃ ꠍꠚꠞꠅ ꠞꠅꠀꠘꠣ ꠅꠁꠔꠣ। ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠞꠚꠔꠦ ꠙꠣꠅꠀ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ, ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠅꠃ ꠘꠤꠅꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_1","005_10_1","NUM","10","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU10_2","005_10_2","NUM","10","2","2","“ꠔꠥꠝꠤ ꠞꠥꠙꠣꠞ ꠙꠣꠔ ꠙꠤꠐꠣꠁꠀ ꠖꠥꠁꠐꠣ ꠌꠥꠋꠉꠣ ꠛꠣꠘꠣꠅ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠒꠣꠇꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠌꠥꠋꠉꠣ ꠛꠣꠎꠣꠁꠅ, ꠔꠣꠞꠣꠞ ꠘꠣꠘꠣꠘ ꠖꠟ ꠍꠚꠞꠅ ꠞꠅꠀꠘꠣ ꠅꠀꠞ ꠛꠣꠟꠣꠅ ꠔꠥꠝꠤ ꠅꠉꠥꠁꠘ ꠛꠣꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("NU10_3","005_10_3","NUM","10","3","3","ꠅꠃ ꠖꠥꠁꠅ ꠌꠥꠋꠉꠣ ꠎꠦꠛꠟꠣ ꠄꠇꠟꠉꠦ ꠛꠣꠎꠣꠘꠤ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠖꠟꠣ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_4","005_10_4","NUM","10","4","4","ꠅꠁꠟꠦ ꠄꠇꠐꠣ ꠌꠥꠋꠉꠣ ꠛꠣꠎꠣꠘꠤ ꠅꠁꠟꠦ ꠈꠣꠟꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠘꠣꠘꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠖꠟꠣ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_5","005_10_5","NUM","10","5","5","ꠙꠄꠟꠣ ꠛꠣꠞ ꠌꠥꠋꠉꠣ ꠛꠣꠎꠣꠁꠟꠦ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠙꠥꠛꠦꠖꠤ ꠎꠦꠞꠣ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠋꠉꠣꠁꠍꠦ, ꠔꠣꠞꠣ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_6","005_10_6","NUM","10","6","6","ꠖꠥꠍꠞꠣꠛꠣꠞ ꠛꠣꠎꠣꠁꠟꠦ ꠖꠃꠇꠘꠞ ꠉꠣꠟꠣꠞ ꠖꠟ ꠅꠇꠟ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣ। ꠁꠇꠐꠣ ꠔ ꠍꠚꠞꠅ ꠞꠅꠀꠘꠣ ꠖꠤꠛꠣꠞ ꠡꠋꠇꠦꠔ। ");
INSERT INTO syls_vpl VALUES ("NU10_7","005_10_7","NUM","10","7","7","ꠔꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠖꠟꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠖꠥꠁꠅ ꠌꠥꠋꠉꠣ ꠛꠣꠎꠣꠁꠅ, ꠅꠁꠟꠦ ꠄꠞ ꠡꠥꠞ ꠅꠁꠛ ꠀꠟꠣꠖꠣ ꠞꠇꠝꠞ। ");
INSERT INTO syls_vpl VALUES ("NU10_8","005_10_8","NUM","10","8","8","ꠅꠃ ꠌꠥꠋꠉꠣ ꠛꠣꠎꠣꠁꠛꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠛꠋꠡꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠦ। ꠁꠐꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠋꠡꠗꠞꠞ ꠟꠣꠉꠤꠅ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠘꠤꠅꠝ। ");
INSERT INTO syls_vpl VALUES ("NU10_9","005_10_9","NUM","10","9","9","“ꠘꠤꠎꠞ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠇꠥꠘꠥ ꠎꠥꠟꠥꠝꠛꠣꠎ ꠖꠥꠡꠝꠘꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁꠔ ꠛꠣꠞ ꠅꠁꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠖꠥꠁꠅ ꠌꠥꠋꠉꠣ ꠛꠣꠎꠣꠁꠀ ꠡꠋꠇꠦꠔ ꠖꠤꠛꠣꠄ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠖꠥꠡꠝꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_10","005_10_10","NUM","10","10","10","ꠔꠥꠝꠞꠣꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠞ ꠅꠘꠥꠡ꠆ꠐꠣꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠁꠖꠅ, ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠎꠦꠛꠟꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠛꠣ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ, ꠅꠃ ꠡꠝꠄꠅ ꠌꠥꠋꠉꠣ ꠛꠣꠎꠣꠁꠅ। ꠅꠃ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠌꠃꠈ ꠚꠤꠞꠣꠁꠛꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("NU10_11","005_10_11","NUM","10","11","11","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞꠘꠤꠞ ꠖꠥꠍꠞꠣ ꠛꠍꠞꠞ ꠖꠥꠍꠞꠣ ꠌꠣꠘ꠆ꠖꠞ ꠛꠤꠡ ꠔꠣꠞꠤꠈ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥ ꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠇꠥꠖꠞꠔꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠢꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU10_12","005_10_12","NUM","10","12","12","ꠅꠃ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠢꠃ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠚꠣꠞꠣꠘ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠁꠀ ꠕꠤꠞ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠣ ꠌꠟꠣꠔꠃ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_13","005_10_13","NUM","10","13","13","ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ, ꠔꠣꠞꠣ ꠙꠄꠟꠣ ꠛꠣꠞ ꠅꠃ ꠍꠚꠞꠅ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_14","005_10_14","NUM","10","14","14","ꠙꠄꠟꠣꠃ ꠄꠢꠥꠖꠣꠞ ꠙꠔꠣꠇꠣꠞ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠚꠃꠎꠤ ꠖꠟꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠄꠞꠣꠞ ꠘꠦꠔꠣ ꠀꠍꠟꠣ ꠀꠝꠤꠘꠣꠖꠣꠛꠞ ꠙꠥꠀ ꠘꠣꠢꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("NU10_15","005_10_15","NUM","10","15","15","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠍꠥꠉꠣꠞꠞ ꠙꠥꠀ ꠘꠕꠘꠦꠟꠞ ꠃꠙꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("NU10_16","005_10_16","NUM","10","16","16","ꠀꠞ ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠢꠦꠟꠘꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠛꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("NU10_17","005_10_17","NUM","10","17","17","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠢꠇꠟꠔꠣ ꠈꠥꠟꠣ ꠅꠁꠟ, ꠔꠦꠃ ꠎꠣꠞꠍꠥꠘꠤ ꠀꠞ ꠝꠣꠞꠣꠞꠤꠀ ꠅꠇꠟꠦ ꠅꠈꠣꠘꠞ ꠢꠇꠟꠔꠣ ꠛꠁꠀ ꠟꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_18","005_10_18","NUM","10","18","18","ꠄꠞꠣꠞ ꠛꠣꠖꠦ ꠞꠥꠛꠦꠘꠞ ꠙꠔꠣꠇꠣꠞ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠚꠃꠎꠤ ꠖꠟꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠄꠞꠣꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠡꠣꠖꠤꠃꠞꠞ ꠙꠥꠀ ꠀꠟꠤꠍꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("NU10_19","005_10_19","NUM","10","19","19","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠡꠥꠞꠡꠣꠖꠣꠄꠅꠞ ꠙꠥꠀ ꠡꠣꠟꠥꠝꠤꠟꠞ ꠃꠙꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("NU10_20","005_10_20","NUM","10","20","20","ꠀꠞ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ, ꠖꠥꠄꠟꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠍꠚꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("NU10_21","005_10_21","NUM","10","21","21","ꠄꠞꠣꠞ ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠁꠀ ꠇꠣꠢꠣꠔꠤ ꠅꠇꠟꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠇꠣꠢꠣꠔꠤ ꠅꠇꠟ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠙꠃꠍꠣꠞ ꠀꠉꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠈꠣꠠꠣ ꠇꠞꠣꠞ ꠇꠕꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU10_22","005_10_22","NUM","10","22","22","ꠄꠞꠛꠣꠖꠦ ꠀꠚꠞꠣꠁꠝ ꠙꠔꠣꠇꠣꠞ ꠔꠤꠘꠅ ꠚꠃꠎꠤ ꠖꠟꠞ ꠝꠣꠘꠡꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠄꠞꠣꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠀꠝꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠀꠟꠤꠡꠣꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_23","005_10_23","NUM","10","23","23","ꠄꠞ ꠝꠣꠎꠦ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠚꠣꠔꠡꠥꠞꠞ ꠙꠥꠀ ꠉꠝꠟꠤꠄꠟꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("NU10_24","005_10_24","NUM","10","24","24","ꠀꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠎꠤꠖꠣꠃꠘꠤꠞ ꠙꠥꠀ ꠀꠛꠤꠖꠣꠘꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("NU10_25","005_10_25","NUM","10","25","25","ꠢꠇꠟ ꠢꠦꠡꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ ꠖꠣꠘ ꠙꠔꠣꠇꠣꠞ ꠔꠤꠘꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠚꠃꠎꠤ ꠖꠟꠞ ꠝꠣꠘꠡꠦ, ꠔꠣꠞꠣꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ ꠀꠝꠤꠡꠣꠖꠣꠞ ꠙꠥꠀ ꠀꠈꠤꠀꠎꠣꠞ। ꠄꠞꠣꠞ ꠍꠣꠝꠘꠞ ꠢꠇꠟ ꠚꠃꠎꠤ ꠖꠟꠞꠦ ꠙꠣꠞꠣ ꠖꠤꠀ ꠔꠣꠞꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_26","005_10_26","NUM","10","26","26","ꠄꠞ ꠝꠣꠎꠦ ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠃꠇꠞꠣꠘꠞ ꠙꠥꠀ ꠚꠎꠤꠄꠟꠞ ꠃꠙꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("NU10_27","005_10_27","NUM","10","27","27","ꠀꠞ ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠁꠘꠣꠘꠞ ꠙꠥꠀ ꠀꠢꠤꠞꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("NU10_28","005_10_28","NUM","10","28","28","ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠘꠣꠘꠣꠘ ꠚꠃꠎꠤ ꠖꠟ ꠄꠇꠦ ꠄꠇꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU10_29","005_10_29","NUM","10","29","29","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠞ ꠔꠣꠘ ꠢꠃꠞ ꠡꠥꠀꠁꠛ ꠘꠛꠤꠞ ꠙꠥꠀ ꠢꠛꠛꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠝꠞꠣ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠁꠞꠣꠝꠉꠤ। ꠔꠦ ꠔꠥꠝꠤꠅ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠅ। ꠝꠣꠛꠥꠖꠦ ꠔ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠛꠃꠔ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠛꠣ। ꠅꠈꠘ ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠁꠟꠦ ꠀꠝꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠈꠥꠛ ꠝꠣꠄꠀ-ꠖꠄꠀ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU10_30","005_10_30","NUM","10","30","30","ꠢꠛꠛꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠘꠣ, ꠀꠝꠤ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠀꠝꠤ ꠀꠝꠣꠞ ꠖꠦꠡꠅ ꠘꠤꠎꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠎꠣꠁꠝꠥꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU10_31","005_10_31","NUM","10","31","31","ꠅꠁꠟꠦ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞꠦ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠁꠅ ꠘꠣ। ꠔꠥꠝꠤꠃ ꠀꠝꠞꠣꠞ ꠙꠕ ꠖꠦꠈꠣꠅꠞꠣ ꠎꠘ। ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠀꠝꠞꠣꠞ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠣ ꠃꠌꠤꠔ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤꠃ ꠅꠁꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠌꠃꠈ। ");
INSERT INTO syls_vpl VALUES ("NU10_32","005_10_32","NUM","10","32","32","ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠅ, ꠔꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠔ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠣꠞꠦꠅ ꠅꠔꠣꠞ ꠛꠣꠐ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU10_33","005_10_33","NUM","10","33","33","ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠠ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠔꠤꠘ ꠖꠤꠘꠞ ꠙꠕ ꠀꠉꠥꠀꠁ ꠉꠦꠟꠣ। ꠀꠞ ꠎꠤꠞꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘ ꠎꠣꠉꠣ ꠔꠥꠇꠣꠁꠀ ꠛꠣꠞ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ, ꠝꠣꠛꠥꠖꠞ ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ ꠔꠤꠘ ꠖꠤꠘ ꠗꠞꠤ ꠔꠣꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU10_34","005_10_34","NUM","10","34","34","ꠇꠦꠝ꠆ꠙ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠀꠞ ꠛꠣꠖꠦ, ꠖꠤꠘꠞ ꠛꠦꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠉꠣꠁꠛꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("NU10_35","005_10_35","NUM","10","35","35","ꠅꠃ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠦꠃ ꠝꠥꠍꠣꠄ ꠇꠁꠔꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠌꠟꠃꠇ꠆ꠇꠣ। ꠔꠥꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤ ꠎꠣꠃꠇ, ꠔꠥꠝꠣꠞꠦ ꠎꠦꠔꠣꠄ ꠁꠋꠡꠣꠁꠘ, ꠁꠔꠣ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠜꠣꠉꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("NU10_36","005_10_36","NUM","10","36","36","ꠀꠞ ꠎꠦꠛꠟꠣ ꠅꠃ ꠡꠘ꠆ꠖꠥꠇ ꠕꠣꠝꠤꠎꠤꠔ, ꠔꠣꠁꠘ ꠇꠁꠔꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠟꠣꠈ ꠟꠣꠈ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠤ ꠚꠤꠞꠤꠀ ꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU11_1","005_11_1","NUM","11","1","1","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠘꠤꠎꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠟꠣꠉꠤ ꠛꠦꠎꠣꠞ ꠅꠁꠀ ꠛꠇꠣ-ꠎꠇꠣ ꠇꠞꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠉꠥꠍꠣ ꠅꠁꠉꠦꠟꠣ। ꠔꠣꠁꠘ ꠉꠎꠛꠤ ꠀꠉꠥꠁꠘ ꠙꠣꠑꠣꠁꠟꠣ ꠀꠞ ꠅꠃ ꠀꠉꠥꠁꠘ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠟꠤꠟ, ꠄꠔꠦ ꠇꠦꠝ꠆ꠙꠞ ꠇꠤꠘꠣꠞꠣꠞ ꠇꠤꠍꠥ ꠅꠋꠡ ꠀꠉꠥꠁꠘꠦ ꠎꠟꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU11_2","005_11_2","NUM","11","2","2","ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠟꠣꠉꠣꠁꠟꠣ, ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠀ ꠇꠞꠣꠄ ꠀꠉꠥꠁꠘ ꠘꠤꠜꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU11_3","005_11_3","NUM","11","3","3","ꠝꠣꠛꠥꠖꠞ ꠀꠉꠥꠁꠘ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠟꠍꠤꠟ ꠇꠞꠤ, ꠅꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠉꠦꠟ ꠔꠣꠛꠦꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_4","005_11_4","NUM","11","4","4","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠖꠥꠍꠞꠣ ꠎꠣꠔꠞ ꠝꠎꠣꠞ ꠇꠥꠘꠥ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠙꠣꠉꠟ ꠛꠘꠤꠉꠦꠟꠣ, ꠀꠞ ꠄꠞꠣꠞ ꠖꠦꠈꠣ-ꠖꠦꠈꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦꠅ ꠢꠤꠞꠛꠣꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠁꠡ, ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ! ");
INSERT INTO syls_vpl VALUES ("NU11_5","005_11_5","NUM","11","5","5","ꠝꠤꠡꠞꠅ ꠕꠣꠇꠔꠦ ꠔ ꠛꠤꠘꠣ ꠙꠄꠡꠣꠄ ꠝꠣꠉꠘꠣ ꠝꠣꠍ ꠈꠣꠁꠔꠣꠝ, ꠢꠘꠅ ꠔꠞꠝꠥꠎ, ꠙꠤꠀꠎ-ꠞꠡꠥꠘ, ꠇꠤꠞꠣ, ꠢꠣꠉ-ꠔꠞꠇꠣꠞꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠈꠣꠁꠔꠣꠝ, ꠁꠔꠣ ꠅꠈꠘꠅ ꠝꠘꠅ ꠙꠠꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("NU11_6","005_11_6","NUM","11","6","6","ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠇꠁꠟꠎꠣ ꠢꠥꠇꠣꠁ ꠉꠦꠍꠦ। ꠁꠘꠅ ꠔ ꠈꠣꠟꠤ ꠝꠣꠘ꠆ꠘꠣ ꠍꠣꠠꠣ ꠈꠣꠅꠀꠞ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("NU11_7","005_11_7","NUM","11","7","7","ꠅꠃ ꠝꠣꠘ꠆ꠘꠣ ꠖꠦꠈꠔꠦ ꠓꠥꠟꠣ ꠛꠣꠈꠞꠞ ꠟꠣꠈꠣꠘ, ꠄꠞ ꠞꠋ ꠅꠁꠟ ꠇꠤꠍꠝꠤꠍꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("NU11_8","005_11_8","NUM","11","8","8","ꠝꠣꠘꠡꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠣꠇꠤ ꠝꠣꠘ꠆ꠘꠣ ꠔꠥꠇꠣꠁꠀ ꠀꠘꠤꠀ ꠊꠣꠁꠟ-ꠍꠤꠀꠖꠤ ꠇꠥꠐꠤꠀ ꠛꠣ ꠢꠤꠟ-ꠙꠣꠐꠣꠖꠤ ꠍꠦꠌꠤꠀ ꠉꠥꠠꠣ ꠇꠞꠔꠣ। ꠛꠣꠖꠦ ꠁꠔꠣ ꠙꠣꠔꠤꠟꠅ ꠃꠘꠣ ꠖꠤꠀ ꠛꠣ ꠙꠤꠑꠣ ꠛꠣꠘꠣꠁꠀ ꠈꠣꠁꠔꠣ। ꠁꠔꠣ ꠈꠣꠁꠔꠦ ꠔꠦꠟꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠙꠤꠑꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_9","005_11_9","NUM","11","9","9","ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠞ ꠀꠡꠦ-ꠙꠣꠡꠦ ꠈꠥꠀ ꠙꠠꠔ, ꠅꠃ ꠈꠥꠀꠞ ꠟꠉꠦ ꠅꠁꠀ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠈꠣꠘꠤ ꠝꠣꠘ꠆ꠘꠣꠅ ꠙꠠꠔ। ");
INSERT INTO syls_vpl VALUES ("NU11_10","005_11_10","NUM","11","10","10","ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠇꠣꠘꠅ ꠀꠁꠟ, ꠙꠞꠔꠦꠇ ꠊꠞꠞ ꠝꠣꠘꠡꠦ ꠎꠣꠞꠎꠤꠞ ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠤꠞꠣ। ꠄꠞꠖꠣꠄ ꠔꠣꠁꠘ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠟꠣ, ꠀꠞ ꠝꠣꠛꠥꠖꠅ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_11","005_11_11","NUM","11","11","11","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠔꠥꠝꠣꠞ ꠁ ꠉꠥꠟꠣꠝꠞꠦ ꠁꠟꠣ ꠛꠤꠙꠖꠅ ꠚꠣꠟꠣꠁꠟꠣꠄ? ꠀꠝꠤ ꠇꠤꠔꠣ ꠖꠥꠡ ꠇꠞꠟꠣꠝ, ꠎꠦ ꠇꠣꠞꠘꠦ ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠜꠣꠞ ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠖꠅ ꠖꠤꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("NU11_12","005_11_12","NUM","11","12","12","ꠀꠝꠤ ꠇꠥꠘꠥ ꠔꠣꠞꠣꠞꠦ ꠙꠦꠐꠅ ꠟꠁꠍꠤ ꠘꠤ, ꠛꠣ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠙꠦꠐ ꠕꠣꠇꠤ ꠎꠘꠝꠤꠍꠦ ꠘꠤ? ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠤꠟꠣꠄ, ꠔꠣꠞꠣꠞꠦ ꠢꠘꠅ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠇꠦꠘꠦ ꠔꠣꠞꠣꠞ ꠙꠣꠟꠇ-ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠘꠣꠁꠍ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠇꠥꠟꠅ ꠇꠞꠤ ꠘꠤꠛꠣꠞ ꠇꠕꠣ ꠇꠦꠘꠦ ꠇꠁꠞꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("NU11_13","005_11_13","NUM","11","13","13","ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠈꠘ ꠉꠥꠡ꠆ꠔ ꠇꠥꠀꠁ ꠙꠣꠁꠔꠣꠝ? ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠈꠣꠟꠤ ꠉꠥꠡ꠆ꠔ ꠉꠥꠡ꠆ꠔ ꠇꠁꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_14","005_11_14","NUM","11","14","14","ꠔꠣꠞꠣꠞ ꠎꠤꠝ꠆ꠝꠣ ꠘꠦꠅꠀ ꠛꠠ ꠝꠡꠇꠤꠟ, ꠀꠝꠣꠞ ꠄꠇꠣꠞ ꠙꠇ꠆ꠇꠦ ꠁ ꠎꠤꠝ꠆ꠝꠣ ꠘꠦꠅꠀ ꠡꠝ꠆ꠛꠛ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU11_15","005_11_15","NUM","11","15","15","ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠁ ꠝꠥꠡꠇꠤꠟꠅ ꠚꠣꠟꠣꠅ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠖꠥꠀꠁ ꠖꠤꠀ ꠇꠁꠀꠞ, ꠅꠈꠘꠃ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠅ। ꠀꠞ ꠇꠁꠞꠣꠝ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠞꠢꠝꠔꠞ ꠔꠟꠦ ꠕꠣꠇꠤ, ꠔꠦ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠘꠤꠎꠞ ꠛꠦꠢꠣꠟ꠆ꠟꠔꠤ ꠖꠡꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU11_16","005_11_16","NUM","11","16","16","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠤ ꠎꠣꠞꠣꠞꠦ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠀꠞ ꠁꠎ꠆ꠎꠔꠤ ꠢꠤꠡꠣꠛꠦ ꠌꠤꠘꠅ, ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣꠞꠦ ꠟꠁꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠅ। ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠃꠛꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_17","005_11_17","NUM","11","17","17","ꠀꠝꠤ ꠢꠘꠅ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠝꠥ। ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠞꠥꠢꠥ ꠀꠍꠂꠘ, ꠅꠃ ꠞꠥꠢꠥ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦꠅ ꠖꠣꠘ ꠇꠞꠝꠥ। ꠝꠣꠘꠡꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠤ ꠛꠁꠀ ꠘꠤꠔꠦ ꠔꠣꠞꠣꠅ ꠔꠥꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ। ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠄꠇꠟꠣ ꠛꠅꠀ ꠟꠣꠉꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU11_18","005_11_18","NUM","11","18","18","ꠀꠞ ꠔꠥꠝꠤ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠀ ꠇꠣꠁꠟꠇꠥꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠞꠁꠔꠣ, ꠇꠣꠁꠟꠃ ꠔꠣꠞꠣ ꠈꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠙꠣꠁꠛꠣ। ꠔꠣꠞꠣ ꠔ ꠉꠥꠡ꠆ꠔꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠤꠀ ꠇꠁꠍꠤꠟ, ꠝꠤꠡꠞꠅ ꠕꠣꠇꠔꠦꠃ ꠔꠣꠞꠣ ꠀꠞꠣꠝꠦ ꠀꠍꠤꠟ। ꠔꠦ ꠇꠣꠁꠟ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞꠦ ꠉꠥꠡ꠆ꠔ ꠖꠤꠛꠣ ꠀꠞ ꠔꠣꠞꠣ ꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_19","005_11_19","NUM","11","19","19","ꠁ ꠉꠥꠡ꠆ꠔ ꠈꠣꠟꠤ ꠄꠇꠖꠤꠘ-ꠖꠥꠁꠖꠤꠘ, ꠙꠣꠌꠖꠤꠘ-ꠖꠡꠖꠤꠘ, ꠛꠣ ꠛꠤꠡꠖꠤꠘ ꠘꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU11_20","005_11_20","NUM","11","20","20","ꠙꠥꠞꠣ ꠄꠇ ꠝꠣꠡ ꠜꠞꠤ ꠈꠣꠁꠛꠣ। ꠈꠣꠁꠔꠦ ꠈꠣꠁꠔꠦ ꠔꠣꠞꠣꠞ ꠘꠣꠇꠦꠖꠤ ꠛꠣꠞ ꠅꠁꠛ, ꠛꠣꠖꠦ ꠀꠞ ꠎꠣꠘꠦ ꠇꠥꠟꠣꠁꠔ ꠘꠣꠄ। ꠀꠝꠤ ꠁꠟꠣ ꠊꠐꠣꠁꠝꠥ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠦ ꠝꠣꠛꠥꠖ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠅꠃ ꠝꠣꠛꠥꠖꠞꠦ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠍ ꠘꠣ। ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠤꠀ ꠇꠁꠍ, ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠀꠅꠀ ꠛꠥꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU11_21","005_11_21","NUM","11","21","21","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠈꠣꠟꠤ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠎꠥꠇꠣꠃ ꠔ ꠍꠄ ꠟꠣꠈ ꠝꠣꠘꠥꠡ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ, ꠀꠞ ꠔꠥꠝꠤ ꠇꠁꠞꠣꠄ ꠙꠥꠞꠣ ꠄꠇ ꠝꠣꠡ ꠜꠞꠤ ꠔꠣꠞꠣꠞꠦ ꠉꠥꠡ꠆ꠔ ꠈꠣꠛꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU11_22","005_11_22","NUM","11","22","22","ꠔꠦ ꠢꠇ꠆ꠇꠟ ꠉꠞꠥ-ꠝꠦꠠꠣ ꠎꠛ ꠇꠞꠟꠦꠅ ꠔ ꠅꠔ ꠝꠣꠘꠡꠞ ꠚꠥꠁꠔ ꠘꠣꠄ, ꠀꠞ ꠖꠞꠤꠀꠞ ꠢꠇꠟ ꠝꠣꠍ ꠝꠣꠞꠤꠀ ꠀꠘꠤꠟ꠆ꠟꠦꠅ ꠇꠥꠟꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU11_23","005_11_23","NUM","11","23","23","ꠝꠣꠛꠥꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅ ꠝꠥꠍꠣ, ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟ ꠅꠔ ꠇꠝꠎꠥꠞ ꠘꠤ? ꠔꠦ ꠔꠥꠝꠤ ꠖꠦꠈꠛꠣꠄ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠤ, ꠁꠔꠣ ꠢꠣꠍꠣ, ꠘꠣ ꠝꠤꠍꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU11_24","005_11_24","NUM","11","24","24","ꠔꠦꠃ ꠝꠥꠍꠣ ꠛꠣꠞꠦ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠎꠣꠘꠣꠁꠟꠣ। ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣꠞꠦ ꠀꠘꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠈꠣꠠꠣ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_25","005_11_25","NUM","11","25","25","ꠅꠃ ꠡꠝꠄ ꠉꠣꠁꠛꠤ ꠝꠦꠊꠞ ꠌꠣꠈꠣꠔ ꠅꠁꠀ ꠝꠣꠛꠥꠖ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ। ꠝꠥꠍꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠁ ꠎꠦ ꠞꠥꠢꠥ ꠀꠍꠟꠣ, ꠝꠣꠛꠥꠖꠦ ꠅꠃ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ ꠘꠦꠔꠣꠞ ꠃꠙꠞꠦꠅ ꠅꠃ ꠞꠥꠢꠥꠞ ꠇꠤꠍꠥ ꠅꠋꠡ ꠖꠤꠟꠣ। ꠅꠃ ꠞꠥꠢꠥ ꠔꠣꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠣꠞ ꠛꠣꠖꠦ, ꠔꠣꠞꠣ ꠇꠤꠍꠥ ꠡꠝꠄ ꠍꠥꠚꠤ-ꠖꠞꠛꠦꠡꠞ ꠄꠡꠇꠤ ꠜꠣꠛ ꠖꠦꠈꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠛꠣꠖꠦ ꠀꠞ ꠁꠟꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_26","005_11_26","NUM","11","26","26","ꠀꠞ ꠅꠃ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣꠞ ꠝꠣꠎꠞ ꠖꠥꠁꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠞꠁꠉꠦꠟꠣ, ꠄꠞꠣꠞ ꠘꠣꠝ ꠁꠟꠖꠣꠖ ꠀꠞ ꠝꠤꠖꠣꠖ, ꠔꠣꠞꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠉꠦꠍꠦ ꠉꠦꠍꠟꠣ ꠘꠣ। ꠔꠦꠛꠃ ꠀꠟ꠆ꠟꠣꠁ ꠅꠃ ꠞꠥꠢꠥ ꠔꠣꠞꠣꠅ ꠙꠣꠁꠟꠣ, ꠙꠣꠁꠀ ꠔꠣꠞꠣ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠞꠁꠀ ꠍꠥꠚꠤ-ꠖꠞꠛꠦꠡꠞ ꠄꠡꠇꠤ ꠜꠣꠛ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_27","005_11_27","NUM","11","27","27","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠄꠇ ꠎꠥꠀꠘ ꠛꠦꠐꠣꠄ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠢꠥꠘꠍꠂꠘ ꠘꠤ? ꠁꠟꠖꠣꠖ ꠀꠞ ꠝꠤꠖꠣꠖ ꠘꠣꠝꠞ ꠖꠥꠁꠅ ꠝꠥꠞꠛ꠆ꠛꠤꠄ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠍꠥꠚꠤ-ꠖꠞꠛꠦꠡꠞ ꠄꠡꠇꠤ ꠜꠣꠛ ꠖꠦꠈꠣꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU11_28","005_11_28","NUM","11","28","28","ꠅꠃ ꠡꠝꠄ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣꠄ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ, ꠀꠙꠘꠦ ꠄꠞꠣꠞꠦ ꠘꠤꠡꠦꠗ ꠖꠦꠃꠇ꠆ꠇꠣ।” ꠅꠃ ꠁꠃꠍꠣ ꠎꠥꠀꠘꠇꠤꠞ ꠡꠥꠞꠥ ꠕꠣꠇꠤꠃ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠈꠣꠍ ꠈꠣꠖꠤꠝ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_29","005_11_29","NUM","11","29","29","ꠝꠥꠍꠣꠄ ꠄꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠣꠘ-ꠡꠝ꠆ꠝꠣꠘꠃ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠛꠠ ꠅꠁꠉꠦꠟ ꠘꠤ? ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠝꠣꠛꠥꠖꠞ ꠢꠇꠟ ꠛꠘ꠆ꠖꠣꠄꠃ ꠍꠥꠚꠤ-ꠖꠞꠛꠦꠡꠤ ꠙꠣꠃꠇ꠆ꠇꠣ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠀꠙꠘ ꠞꠥꠢꠥ ꠔꠣꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU11_30","005_11_30","NUM","11","30","30","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟ ꠇꠦꠝ꠆ꠙꠅ ꠚꠤꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("NU11_31","005_11_31","NUM","11","31","31","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠦ ꠛꠠ ꠄꠇ ꠔꠥꠚꠣꠘ ꠀꠁꠟ। ꠅꠃ ꠔꠥꠚꠣꠘꠦ ꠖꠞꠤꠀꠞ ꠙꠣꠞ ꠕꠣꠇꠤ ꠇꠥꠄꠟ ꠙꠣꠈꠤ ꠑꠦꠟꠤꠀ ꠀꠘꠤꠀ ꠇꠦꠝ꠆ꠙꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣ ꠜꠞꠣꠁ ꠖꠤꠟ। ꠄꠇꠖꠤꠘꠞ ꠙꠕ ꠙꠞꠤꠝꠣꠘ ꠎꠣꠉꠣ ꠙꠣꠈꠤꠄ ꠜꠞꠤꠉꠦꠟ। ꠙꠣꠈꠤꠞ ꠙꠣꠟ ꠝꠣꠐꠤ ꠕꠣꠇꠤ ꠖꠥꠁ ꠀꠔ ꠃꠌꠣ ꠔꠥꠛ ꠅꠁꠀ, ꠉꠤꠍ ꠟꠣꠉꠤꠀ ꠙꠠꠤ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU11_32","005_11_32","NUM","11","32","32","ꠔꠦꠃ ꠢꠃ ꠖꠤꠘ, ꠢꠃ ꠞꠣꠁꠔ, ꠀꠞ ꠛꠣꠖꠞ ꠀꠡ꠆ꠔꠣ ꠖꠤꠘ ꠝꠣꠘꠡꠦ ꠛꠣꠞꠦ ꠉꠤꠀ ꠇꠥꠄꠟ ꠙꠣꠈꠤꠘ ꠔꠥꠛꠣꠁꠀ ꠀꠘꠟꠣ। ꠔꠣꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠇꠝꠙꠇ꠆ꠇꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠝꠘ ꠇꠞꠤ ꠙꠣꠈꠤ ꠖꠟꠣ ꠇꠞꠟ। ꠙꠣꠈꠤꠘ ꠖꠟꠣ ꠇꠞꠤꠀ ꠇꠦꠝ꠆ꠙꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠔꠣꠞꠣ ꠛꠅꠀꠁꠀ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_33","005_11_33","NUM","11","33","33","ꠅꠁꠟꠦ ꠙꠣꠈꠤꠞ ꠉꠥꠡ꠆ꠔ ꠔꠣꠞꠣꠞ ꠝꠥꠈꠅ ꠢꠣꠞꠣꠘꠤꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠝꠣꠛꠥꠖ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ। ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠔꠣꠁꠘ ꠛꠦꠎꠥꠁꠔꠣ ꠉꠎꠛꠤ ꠛꠦꠝꠣꠞ ꠓꠣꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU11_34","005_11_34","NUM","11","34","34","ꠄꠞꠟꠣꠉꠤ ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠖꠦꠅꠀ ꠅꠁꠟ ꠇꠤꠛꠞꠥꠔ-ꠢꠥꠔꠣꠛꠣ, ꠝꠣꠘꠤ ꠟꠣꠟꠌꠤ ꠅꠇꠟꠞ ꠇꠄꠛꠞ, ꠇꠣꠞꠘ ꠅꠃ ꠟꠣꠟꠌꠤ ꠅꠇꠟꠞꠦ ꠝꠣꠘꠡꠦ ꠅꠘꠅ ꠇꠄꠛꠞ ꠖꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU11_35","005_11_35","NUM","11","35","35","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠇꠤꠛꠞꠥꠔ-ꠢꠥꠔꠣꠛꠣ ꠍꠣꠠꠤꠀ ꠉꠦꠟꠣꠉꠤ, ꠉꠤꠀ ꠢꠣꠎꠤꠞꠥꠔ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU12_1","005_12_1","NUM","12","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠁꠕꠤꠅꠙꠤꠀ ꠖꠦꠡꠞ ꠄꠇꠎꠘ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠟꠣ। ꠄꠘꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠄ ꠝꠥꠍꠣꠞ ꠛꠁꠘ ꠝꠞꠤꠅꠝ ꠀꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘꠦ ꠝꠥꠍꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU12_2","005_12_2","NUM","12","2","2","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠈꠣꠟꠤ ꠝꠥꠍꠣꠞ ꠝꠣꠞꠚꠔꠦ ꠝꠣꠔꠂꠘ ꠘꠤ? ꠀꠝꠞꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄꠅ ꠝꠣꠔꠂꠘ ꠘꠣ ꠘꠤ?” ꠁꠈꠣꠘ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU12_3","005_12_3","NUM","12","3","3","ꠀꠍꠟꠦ ꠝꠥꠍꠣ ꠘꠛꠤ ꠔ ꠀꠍꠟꠣ ꠄꠇꠎꠘ ꠉꠞꠤꠝꠣ ꠍꠣꠠꠣ ꠝꠣꠘꠥꠡ। ꠎꠉꠔꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠉꠞꠤꠝꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU12_4","005_12_4","NUM","12","4","4","ꠝꠥꠍꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠝꠞꠤꠅꠝꠞ ꠝꠣꠔ-ꠇꠕꠣ ꠢꠥꠘꠤꠀꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ, ꠢꠣꠞꠥꠘ ꠀꠞ ꠝꠞꠤꠅꠝꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔꠤꠘꠅꠎꠘ ꠛꠣꠞ ꠅꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠉꠦꠍꠦ ꠀꠅ।” ꠔꠦꠃ ꠄꠞꠣ ꠔꠤꠘꠅꠎꠘ ꠅꠘꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU12_5","005_12_5","NUM","12","5","5","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦꠅ ꠇꠥꠖꠞꠔꠤ ꠝꠦꠊꠞ ꠌꠣꠈꠣꠔ ꠅꠁꠀ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠝꠞꠤꠅꠝꠞꠦ ꠒꠣꠇꠤꠟꠣ। ꠔꠣꠞꠣ ꠀꠉꠥꠀꠁꠀ ꠀꠁꠟꠦ ");
INSERT INTO syls_vpl VALUES ("NU12_6","005_12_6","NUM","12","6","6","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠅ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠙꠤꠞ-ꠖꠞꠛꠦꠡ ꠕꠣꠇꠟꠦ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠖꠞꠡꠘꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞꠦ ꠔꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠤ ꠀꠞ ꠈꠥꠀꠛꠦ ꠔꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("NU12_7","005_12_7","NUM","12","7","7","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠁꠟꠣ ꠇꠞꠤ ꠘꠣ। ꠢꠦ ꠀꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠋꠡꠣꠞꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠤꠡ꠆ꠛꠣꠡꠤ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU12_8","005_12_8","NUM","12","8","8","ꠀꠝꠤ ꠔꠣꠞ ꠟꠉꠦ ꠍꠣꠝꠘꠣ-ꠍꠣꠝꠘꠤ ꠅꠁꠀ ꠈꠥꠟꠣ-ꠈꠥꠟꠤ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤ, ꠇꠥꠘꠥꠔꠣ ꠛꠣꠔꠥꠘꠤ ꠞꠣꠈꠤ ꠘꠣ। ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠎꠦ ꠍꠥꠞꠔꠦ ꠔꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠦꠁ, ꠢꠦ ꠀꠝꠣꠞꠦ ꠅꠟꠣ ꠖꠦꠈꠦ। ꠄꠞꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠝꠥꠍꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠔꠤꠔꠦ ꠃꠛꠣꠁꠟꠣꠄ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("NU12_9","005_12_9","NUM","12","9","9","ꠄꠞꠟꠣꠉꠤ ꠢꠣꠞꠥꠘ ꠀꠞ ꠝꠞꠤꠅꠝꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ, ꠅꠁꠀ ꠔꠣꠁꠘ ꠢꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("NU12_10","005_12_10","NUM","12","10","10","ꠝꠦꠊꠞ ꠌꠣꠈꠣ ꠎꠦꠛꠟꠣ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠕꠣꠇꠤ ꠃꠙꠞꠦ ꠃꠑꠤꠉꠦꠟ, ꠅꠃ ꠡꠝꠄ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠝꠞꠤꠅꠝꠞ ꠀꠡ꠆ꠔꠣ ꠉꠔꠞꠅ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠦ ꠖꠥꠗꠞ ꠟꠣꠈꠣꠘ ꠗꠟꠣ ꠅꠁꠉꠦꠍꠦ। ꠢꠣꠞꠥꠘꠦ ꠝꠞꠤꠅꠝꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠅꠃ ꠢꠣꠟꠔ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU12_11","005_12_11","NUM","12","11","11","ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ, ꠀꠝꠞꠣ ꠘꠣ ꠛꠥꠎꠤꠀ ꠎꠦ ꠉꠥꠘꠣ ꠇꠞꠤꠟꠤꠍꠤ, ꠁ ꠇꠍꠥꠞꠤ ꠈꠣꠘ ꠔꠥꠝꠤ ꠝꠘꠅ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU12_12","005_12_12","NUM","12","12","12","ꠝꠣʼꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠤ ꠎꠘꠝ ꠅꠀꠞ ꠛꠣꠟꠣ ꠎꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠅꠞ꠆ꠗꠦꠇ ꠡꠞꠤꠟ ꠇ꠆ꠇꠄ ꠅꠁꠉꠦꠍꠦ, ꠔꠥꠝꠤ ꠝꠞꠤꠅꠝꠞꠦ ꠁꠟꠣ ꠛꠣꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU12_13","005_12_13","NUM","12","13","13","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠇꠣꠘ꠆ꠖꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠅ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠛꠁꠘꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠤ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU12_14","005_12_14","NUM","12","14","14","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠣꠁꠞ ꠛꠣꠚꠦ ꠎꠥꠖꠤ ꠔꠣꠁꠞ ꠝꠥꠈꠅ ꠈꠣꠟꠤ ꠍꠦꠚ ꠚꠣꠟꠣꠁꠔꠣ, ꠔꠦ ꠡꠞꠝꠣꠁꠀ ꠔꠣꠁ ꠡꠣꠔ ꠖꠤꠘ ꠊꠞꠞ ꠛꠣꠞꠦ ꠞꠁꠟ ꠅꠘꠦ ꠘꠣ ꠘꠤ? ꠅꠟꠣ ꠡꠣꠔꠖꠤꠘ ꠔꠣꠁꠞꠦ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠀꠟꠉ ꠞꠣꠈꠅ, ꠛꠣꠖꠦ ꠜꠤꠔꠞꠦ ꠀꠘꠛꠣꠄ ꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU12_15","005_12_15","NUM","12","15","15","ꠄꠞꠟꠣꠉꠤ ꠝꠞꠤꠅꠝꠞꠦ ꠡꠣꠔ ꠖꠤꠘ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠢꠞꠣꠁ ꠕꠁꠟꠣ। ꠄꠘꠞꠦ ꠜꠤꠔꠞꠦ ꠀꠘꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠝꠣꠘꠡꠞ ꠍꠚꠞꠅ ꠛꠣꠞꠘꠤ ꠛꠘ꠆ꠖ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU12_16","005_12_16","NUM","12","16","16","ꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ ꠢꠣꠎꠤꠞꠥꠔ ꠍꠣꠠꠤꠀ ꠚꠣꠞꠣꠘ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠤꠀ ꠇꠦꠝ꠆ꠙ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU13_1","005_13_1","NUM","13","1","1","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU13_2","005_13_2","NUM","13","2","2","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠝꠤ ꠎꠦ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠖꠤꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠅꠃ ꠖꠦꠡꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠖꠦꠈꠤꠀ ꠀꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠎꠘ ꠡꠞ꠆ꠖꠣꠞ ꠙꠣꠑꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU13_3","005_13_3","NUM","13","3","3","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠝꠥꠍꠣꠄ ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠚꠣꠞꠣꠘ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠎꠦꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠄꠞꠣ ꠢꠇꠟꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠞ꠆ꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU13_4","005_13_4","NUM","13","4","4","ꠄꠞꠣ ꠅꠁꠟꠣ: ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠣꠇꠥꠞꠞ ꠙꠥꠀ ꠡꠣꠝ꠆ꠝꠥꠀ, ");
INSERT INTO syls_vpl VALUES ("NU13_5","005_13_5","NUM","13","5","5","ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠈꠥꠞꠤꠞ ꠙꠥꠀ ꠡꠚꠣꠔ, ");
INSERT INTO syls_vpl VALUES ("NU13_6","005_13_6","NUM","13","6","6","ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠤꠚꠥꠘ꠆ꠘꠤꠞ ꠙꠥꠀ ꠇꠣꠟꠥꠔ, ");
INSERT INTO syls_vpl VALUES ("NU13_7","005_13_7","NUM","13","7","7","ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠎꠤꠉꠣꠟ, ");
INSERT INTO syls_vpl VALUES ("NU13_8","005_13_8","NUM","13","8","8","ꠀꠚꠞꠣꠁꠝ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠥꠘꠞ ꠙꠥꠀ ꠢꠥꠍꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("NU13_9","005_13_9","NUM","13","9","9","ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠞꠚꠥꠞ ꠙꠥꠀ ꠚꠟꠔꠤ, ");
INSERT INTO syls_vpl VALUES ("NU13_10","005_13_10","NUM","13","10","10","ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠍꠁꠖꠞ ꠙꠥꠀ ꠉꠖ꠆ꠖꠤꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("NU13_11","005_13_11","NUM","13","11","11","ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠍꠥꠡꠤꠞ ꠙꠥꠀ ꠉꠣꠖ꠆ꠖꠤ, ");
INSERT INTO syls_vpl VALUES ("NU13_12","005_13_12","NUM","13","12","12","ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠉꠝꠟ꠆ꠟꠤꠞ ꠙꠥꠀ ꠀꠝ꠆ꠝꠤꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("NU13_13","005_13_13","NUM","13","13","13","ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠤꠇꠣꠁꠟꠞ ꠙꠥꠀ ꠍꠔꠥꠞ, ");
INSERT INTO syls_vpl VALUES ("NU13_14","005_13_14","NUM","13","14","14","ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠡꠤꠞꠞ ꠙꠥꠀ ꠘꠁꠛ, ");
INSERT INTO syls_vpl VALUES ("NU13_15","005_13_15","NUM","13","15","15","ꠀꠞ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠈꠤꠞ ꠙꠥꠀ ꠉꠥꠎꠄꠄꠟ। ");
INSERT INTO syls_vpl VALUES ("NU13_16","005_13_16","NUM","13","16","16","ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠎꠣꠘꠤꠀ ꠀꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠉꠥꠁꠀ ꠢꠤꠡꠣꠛꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠄꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠘꠥꠘꠞ ꠙꠥꠀ ꠢꠥꠍꠤꠀꠞꠦ ꠁꠃꠍꠣ ꠇꠁꠀ ꠒꠣꠇꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU13_17","005_13_17","NUM","13","17","17","ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠙꠣꠑꠣꠘꠤꠞ ꠛꠣꠟꠣ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠘꠦꠉꠦꠜ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦꠖꠤ ꠉꠤꠀ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠔ ꠢꠣꠝꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU13_18","005_13_18","NUM","13","18","18","ꠢꠣꠝꠣꠁꠀ ꠖꠦꠈꠛꠣꠄ, ꠅꠃ ꠖꠦꠡꠈꠣꠘ ꠇꠤꠟꠣ। ꠁ ꠖꠦꠡꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠝꠣꠘꠥꠡ ꠇꠝ ꠘꠣ ꠛꠦꠡꠤ, ꠔꠣꠞꠣ ꠇꠝꠎꠥꠞ ꠘꠣ ꠛꠟꠛꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("NU13_19","005_13_19","NUM","13","19","19","ꠔꠣꠞꠣꠞ ꠖꠦꠡꠈꠣꠘ ꠜꠣꠟꠣ ꠘꠣ ꠝꠘ꠆ꠖ? ꠖꠦꠡꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠃꠌꠣ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠅꠀꠟ ꠇꠞꠣ, ꠘꠣ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠍꠣꠠꠣ? ");
INSERT INTO syls_vpl VALUES ("NU13_20","005_13_20","NUM","13","20","20","ꠢꠤꠘꠞ ꠝꠣꠐꠤꠔ ꠞꠡ ꠀꠍꠦ ꠇꠤ ꠘꠣ, ꠉꠣꠍ-ꠙꠣꠟꠣ ꠀꠍꠦ ꠇꠤ ꠘꠣ? ꠀꠞ ꠀꠅꠀꠞ ꠡꠝꠄ ꠖꠦꠈꠤꠅ, ꠙꠣꠞꠟꠦ ꠢꠃ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠚꠟ-ꠝꠥꠟ ꠟꠁꠀ ꠀꠁꠅ।” ꠅꠃ ꠡꠝꠄ ꠔ ꠀꠋꠉꠥꠞ ꠙꠣꠇꠣꠞ ꠡꠝꠄ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU13_21","005_13_21","NUM","13","21","21","ꠔꠦꠃ ꠔꠣꠞꠣ ꠎꠤꠘ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠇꠞꠤꠀ ꠢꠣꠝꠣꠔꠞ ꠛꠣꠄ ꠞꠣꠢꠛ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠤꠀ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠖꠦꠈꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU13_22","005_13_22","NUM","13","22","22","ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠔꠣꠞꠣ ꠘꠦꠉꠦꠜ ꠝꠞꠥꠜꠥꠝꠤ ꠅꠁꠀ ꠢꠦꠛꠞꠘ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠀꠎꠤꠟꠣ। ꠁ ꠢꠦꠛꠞꠘ ꠐꠣꠃꠘ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠤꠟ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠍꠥꠀꠘ ꠐꠣꠃꠘ ꠛꠣꠘꠣꠘꠤꠞ ꠡꠣꠔ ꠛꠍꠞ ꠀꠉꠦ। ꠢꠤꠘꠅ ꠙꠄꠟꠥꠀꠘ ꠀꠘꠣꠇꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠔꠤꠘꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠍꠤꠟ, ꠄꠞꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠀꠢꠤꠝꠣꠘ, ꠡꠤꠍꠣꠁ, ꠀꠞ ꠔꠣꠟꠝꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("NU13_23","005_13_23","NUM","13","23","23","ꠛꠣꠖꠦ ꠅꠃ ꠉꠥꠁꠀ ꠅꠇꠟ ꠀꠡꠇꠥꠟ ꠘꠣꠝꠞ ꠙꠣꠠꠤꠀ ꠈꠣꠟꠞ ꠙꠣꠞꠅ ꠕꠣꠇꠤ ꠄꠇ ꠍꠠꠤ ꠀꠋꠉꠥꠞ ꠡꠥꠖ꠆ꠖꠣ ꠀꠡ꠆ꠔꠣ ꠄꠇ ꠟꠔ ꠇꠣꠐꠤꠀ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠁ ꠀꠋꠉꠥꠞꠞ ꠍꠠꠤ ꠔꠣꠞꠣꠞ ꠖꠥꠁꠎꠘꠦ ꠜꠣꠋ ꠖꠤꠀ ꠛꠁꠀ ꠀꠘꠟꠣ। ꠟꠉꠦ ꠇꠤꠍꠥ ꠀꠘꠥꠀꠞ ꠀꠞ ꠒꠥꠝꠥꠞ ꠚꠟꠅ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU13_24","005_13_24","NUM","13","24","24","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠢꠘ ꠕꠣꠇꠤ ꠅꠃ ꠀꠋꠉꠥꠞꠞ ꠍꠠꠤ ꠇꠣꠐꠣꠄ ꠅꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠉꠦꠟ, ꠀꠡꠇꠥꠟꠞ ꠈꠣꠟ, ꠝꠣꠘꠤ ꠍꠠꠤꠞ ꠈꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("NU13_25","005_13_25","NUM","13","25","25","ꠀꠡ꠆ꠔꠣ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ, ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠢꠇꠟ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU13_26","005_13_26","NUM","13","26","26","ꠅꠃ ꠉꠥꠁꠀ ꠅꠇꠟ ꠚꠣꠞꠣꠘ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠣꠖꠦꠡ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ, ꠅꠘꠅ ꠝꠥꠍꠣ ꠘꠛꠤ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ ꠀꠍꠟꠣ। ꠄꠞꠣ ꠀꠁꠀ ꠢꠇꠟꠞꠦ ꠢꠘꠞ ꠈꠛꠞ-ꠀꠘ꠆ꠔꠞ ꠎꠣꠘꠣꠁꠟꠣ ꠀꠞ ꠢꠃ ꠖꠦꠡꠞ ꠚꠟ-ꠝꠥꠟ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU13_27","005_13_27","NUM","13","27","27","ꠔꠣꠞꠣ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠅ ꠙꠣꠑꠣꠁꠍꠟꠣ, ꠀꠝꠞꠣ ꠢꠘꠅ ꠉꠤꠀ ꠖꠦꠈꠟꠣꠝ, ꠢꠤ ꠖꠦꠡꠈꠣꠘ ꠢꠣꠍꠣꠃ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠖꠦꠡ। ꠅꠃ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠢꠃ ꠖꠦꠡꠞ ꠚꠟ। ");
INSERT INTO syls_vpl VALUES ("NU13_28","005_13_28","NUM","13","28","28","ꠅꠁꠟꠦ ꠢꠤꠘꠞ ꠝꠣꠘꠥꠡ ꠈꠥꠛ ꠙꠄꠟꠥꠀꠘ ꠀꠞ ꠔꠣꠞꠣꠞ ꠐꠣꠃꠘꠅ ꠛꠠ ꠛꠠ ꠀꠞ ꠃꠌꠣ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠇꠞꠣ। ꠀꠝꠞꠣ ꠀꠘꠣꠇꠤ ꠙꠄꠟꠥꠀꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠢꠘꠅ ꠖꠦꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU13_29","005_13_29","NUM","13","29","29","ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟ ꠛꠡꠔ ꠇꠞꠂꠘ ꠘꠦꠉꠦꠜ ꠝꠞꠥꠜꠥꠝꠤꠔ। ꠢꠤꠐ꠆ꠐꠤ, ꠎꠤꠛꠥꠎꠤ ꠀꠞ ꠀꠝꠥꠞꠤ ꠅꠇꠟ ꠙꠣꠠꠤ ꠄꠟꠣꠇꠣꠔ ꠞꠂꠘ। ꠀꠞ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠞ ꠇꠦꠃ ꠇꠦꠃ ꠖꠞꠤꠀꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠅ ꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("NU13_30","005_13_30","NUM","13","30","30","ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠖꠟꠣ ꠀꠍꠟꠣ, ꠇꠣꠟꠥꠔꠦ ꠄꠞꠣꠞ ꠡꠥꠞꠉꠥꠟ ꠕꠣꠝꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠞꠥꠞ ꠅꠁꠟ ꠢꠘꠅ ꠉꠤꠀ ꠅꠃ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣ, ꠀꠞ ꠁꠔꠣ ꠀꠝꠞꠣ ꠙꠣꠞꠝꠥꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU13_31","005_13_31","NUM","13","31","31","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠘ ꠟꠉꠞ ꠉꠥꠁꠀ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠡꠝ꠆ꠛꠛ, ꠁꠔꠣ ꠀꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠛꠟꠀꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU13_32","005_13_32","NUM","13","32","32","ꠄꠞꠣ ꠢꠃ ꠖꠦꠡꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠘꠉꠠꠣ ꠝꠤꠍꠣ ꠝꠣꠔꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠎꠦ ꠖꠦꠡ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠝ, ꠁ ꠖꠦꠡꠦ ꠔꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞꠦ ꠉꠤꠟꠤꠀ ꠈꠣꠁꠟꠣꠄ। ꠢꠤꠘꠞ ꠝꠣꠘꠥꠡ ꠈꠥꠛ ꠃꠌꠣ-ꠝꠥꠐꠣ ꠙꠄꠟꠥꠀꠘ। ");
INSERT INTO syls_vpl VALUES ("NU13_33","005_13_33","NUM","13","33","33","ꠀꠝꠞꠣ ꠢꠤꠘꠅ ꠘꠦꠚꠤꠟꠤ ꠎꠣꠔꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠖꠦꠈꠍꠤ, ꠁꠔꠣ ꠖꠦꠈꠔꠦ ꠖꠂꠔ꠆ꠔ-ꠖꠣꠘꠛꠞ ꠟꠣꠈꠣꠘ। ꠀꠝꠞꠣ ꠔ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠥꠌ꠆ꠍ ꠙꠤꠙꠠꠣꠞ ꠟꠣꠈꠣꠘ, ꠔꠣꠞꠣꠅ ꠀꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠙꠤꠙꠠꠣ ꠝꠘꠅ ꠇꠞꠍꠦ।” ꠎꠣꠘ ꠔ, ꠅꠈꠘꠇꠥꠞ ꠀꠘꠣꠇꠤ ꠎꠣꠔꠤ ꠅꠃ ꠘꠦꠚꠤꠟꠤ ꠅꠇꠟꠞ ꠛꠋꠡꠗꠞ। ");
INSERT INTO syls_vpl VALUES ("NU14_1","005_14_1","NUM","14","1","1","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠌꠤꠟ꠆ꠟꠣ-ꠌꠤꠟ꠆ꠟꠤ ꠟꠣꠉꠣꠁꠟ। ꠔꠣꠞꠣ ꠢꠣꠞꠣ ꠞꠣꠁꠔ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("NU14_2","005_14_2","NUM","14","2","2","ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠃꠔ ꠇꠕꠣꠛꠣꠞ꠆ꠔꠣ ꠝꠣꠔꠤꠟ। ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟ, “ꠢꠣꠄꠞꠦ ꠢꠣꠄ! ꠀꠝꠞꠣ ꠇꠦꠘꠦ ꠢꠃ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠛꠣ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠞꠟꠣꠝ ꠘꠣ? ꠢꠘꠅ ꠝꠞꠣꠃ ꠔ ꠜꠣꠟꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU14_3","005_14_3","NUM","14","3","3","ꠝꠣꠛꠥꠖꠦ ꠇꠦꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠥꠖ꠆ꠖꠞ ꠝꠄꠖꠣꠘꠅ ꠝꠣꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠅꠃ ꠖꠦꠡꠅ ꠘꠤꠞꠣ? ꠢꠘꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠦ ꠀꠝꠞꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘꠞꠦ ꠇꠣꠠꠤꠀ ꠘꠤꠛꠣ। ꠄꠞ ꠕꠣꠇꠤ ꠝꠤꠡꠞꠅ ꠚꠤꠞꠤꠀ ꠎꠣꠅꠀꠃ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ ꠘꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("NU14_4","005_14_4","NUM","14","4","4","ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟ, “ꠀꠅ, ꠀꠝꠞꠣ ꠄꠇꠎꠘ ꠘꠦꠔꠣ ꠛꠣꠘꠣꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠝꠤꠡꠞꠅ ꠚꠤꠞꠤꠀ ꠎꠣꠁꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU14_5","005_14_5","NUM","14","5","5","ꠁ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU14_6","005_14_6","NUM","14","6","6","ꠀꠞ ꠎꠦ ꠉꠥꠁꠀ ꠖꠟꠦ ꠅꠃ ꠖꠦꠡꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠖꠦꠈꠤꠀ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ ꠀꠞ ꠎꠤꠚꠥꠘ꠆ꠘꠤꠞ ꠙꠥꠀ ꠇꠣꠟꠥꠔꠦ ꠝꠘꠞ ꠖꠥꠈꠦ ꠘꠤꠎꠞ ꠉꠔꠞꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠍꠤꠠꠤꠟ꠆ꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU14_7","005_14_7","NUM","14","7","7","ꠍꠤꠠꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠞ ꠢꠇ꠆ꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠎꠦ ꠖꠦꠡ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠝ, ꠁ ꠖꠦꠡꠈꠣꠘ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ। ");
INSERT INTO syls_vpl VALUES ("NU14_8","005_14_8","NUM","14","8","8","ꠝꠣꠛꠥꠖ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠡ ꠀꠞ ꠞꠣꠎꠤ ꠕꠣꠇꠂꠘ, ꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠢꠃ ꠖꠦꠡꠅ ꠘꠤꠀ ꠙꠣꠞ ꠇꠞꠛꠣ, ꠔꠣꠁꠘ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠅꠃ ꠖꠦꠡꠈꠣꠘ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU14_9","005_14_9","NUM","14","9","9","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠝꠞ꠆ꠎꠤꠞ ꠃꠟꠐꠣ ꠇꠣꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠢꠤ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠉꠤꠟꠤꠀ ꠈꠣꠁꠔꠦꠅ ꠀꠝꠞꠣꠞ ꠖꠦꠞꠤ ꠅꠁꠔ ꠘꠣꠄ। ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠞ ꠍꠣꠄꠀ ꠘꠣꠁ, ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠔ ꠝꠣꠛꠥꠖ ꠀꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("NU14_10","005_14_10","NUM","14","10","10","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠇꠁꠟꠣ ꠁꠃꠍꠣ ꠀꠞ ꠇꠣꠟꠥꠔꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠝꠣꠞꠤꠟꠔꠣ। ꠅꠃ ꠡꠝꠄ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠕꠣꠇꠤ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠘꠥꠞ ꠎꠣꠁꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU14_11","005_14_11","NUM","14","11","11","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠥꠍꠣ, ꠁꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠀꠞ ꠇꠔꠖꠤꠘ ꠄꠟꠣꠝꠤ ꠇꠞꠛ? ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠅꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣꠘꠤꠞ ꠛꠣꠖꠦꠅ, ꠔꠣꠞꠣ ꠀꠞ ꠇꠔꠖꠤꠘ ꠀꠝꠣꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠔ ꠘꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("NU14_12","005_14_12","NUM","14","12","12","ꠔꠦ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠠ ꠄꠇ ꠉꠎꠛ ꠓꠣꠟꠤꠝꠥ, ꠀꠝꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠇꠣꠠꠤꠀ ꠘꠤꠝꠥꠉꠤ। ꠛꠣꠖꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠁꠔꠣ ꠕꠘꠦ ꠀꠞꠅ ꠛꠟꠛꠣꠘ, ꠀꠞꠅ ꠛꠠ ꠘꠄꠀ ꠄꠇ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU14_13","005_14_13","NUM","14","13","13","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠁꠟꠣ ꠇꠞꠅ, ꠔꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠁꠔꠣ ꠢꠥꠘꠛꠣ। ꠀꠞ ꠔꠥꠝꠤ ꠔ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠁꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠇꠥꠖꠞꠔꠤꠄ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍ। ");
INSERT INTO syls_vpl VALUES ("NU14_14","005_14_14","NUM","14","14","14","ꠅꠈꠘ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠁ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠁꠔꠣ ꠎꠣꠘꠣꠁ ꠖꠤꠛꠣ। ꠔꠦ ꠅ ꠝꠣꠛꠥꠖ, ꠁꠘꠞ ꠝꠣꠘꠡꠦ ꠔ ꠄꠝꠘꠦꠃ ꠎꠣꠘꠤꠟꠤꠍꠂꠘ ꠎꠦꠘ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠟꠉꠦ ꠔꠥꠝꠤ ꠀꠍ, ꠔꠥꠝꠣꠞꠦ ꠈꠥꠛ ꠗꠣꠞꠅ ꠕꠣꠇꠤ ꠖꠦꠈꠣ ꠎꠣꠄ। ꠔꠣꠞꠣ ꠢꠥꠘꠍꠂꠘ, ꠔꠥꠝꠣꠞ ꠘꠥꠞꠞ ꠝꠦꠊꠞ ꠍꠣꠄꠀ ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠀꠞ ꠞꠣꠁꠔ ꠅꠁꠟꠦ ꠀꠉꠥꠁꠘꠞ ꠈꠥꠐꠤꠞ ꠍꠥꠞꠔꠦ ꠄꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("NU14_15","005_14_15","NUM","14","15","15","ꠅꠈꠘ ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠄꠇꠟꠉꠦ ꠝꠣꠞꠤꠟꠣꠅ, ꠔꠦ ꠎꠔ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞ ꠁꠔꠣ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝꠞ ꠈꠛꠞ ꠢꠥꠘꠍꠦ, ꠔꠣꠞꠣ ꠇꠁꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("NU14_16","005_14_16","NUM","14","16","16","ꠝꠣꠛꠥꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠢꠤ ꠖꠦꠡꠅ ꠟꠁꠀ ꠎꠣꠅꠀꠞ ꠈꠦꠝꠔꠣ ꠔꠣꠘ ꠘꠣꠁ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠘꠤꠀ ꠝꠣꠞꠤꠟꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU14_17","005_14_17","NUM","14","17","17","“ꠔꠦ, ꠅ ꠖꠤꠘ-ꠖꠥꠘꠤꠀꠞ ꠝꠣꠟꠤꠇ, ꠔꠥꠝꠤ ꠀꠉꠦ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣꠄ ꠅꠟꠣ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠎꠣꠁꠞ ꠇꠞꠅ। ꠔꠥꠝꠤ ꠘꠥ ꠇꠁꠍꠟꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU14_18","005_14_18","NUM","14","18","18","ꠝꠣꠛꠥꠖꠦ ꠉꠥꠍꠣ ꠇꠞꠂꠘ ꠗꠤꠞ ꠉꠔꠤꠄ, ꠔꠣꠘ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠞ ꠇꠥꠘꠥ ꠡꠤꠝꠣ ꠘꠣꠁ, ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞ ꠅꠁꠘ꠆ꠘꠣꠄ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠝꠣꠚꠤ ꠖꠦꠁꠘ। ꠅꠁꠟꠦ ꠖꠥꠡꠤ ꠎꠘꠞꠦ ꠡꠣꠎꠣꠅ ꠖꠦꠁꠘ, ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠡꠣꠎꠣ ꠔꠣꠞ ꠘꠣꠔꠤ-ꠙꠥꠔꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠞ꠆ꠔꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("NU14_19","005_14_19","NUM","14","19","19","ꠔꠦ ꠔꠥꠝꠣꠞ ꠖꠥꠀꠁ ꠖꠤꠀ ꠇꠁꠞꠣꠝ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠀꠅꠀ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠤ ꠄꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠝꠣꠚꠤ ꠖꠤꠞꠣꠄ, ꠔꠥꠝꠣꠞ ꠢꠃ ꠝꠣꠄꠀꠞ ꠈꠣꠔꠤꠞꠦ ꠔꠣꠞꠣꠞ ꠅꠈꠘꠇꠥꠞ ꠉꠥꠘꠣꠞꠦꠅ ꠅꠟꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU14_20","005_14_20","NUM","14","20","20","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠔꠥꠝꠣꠞ ꠇꠕꠣꠄ ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("NU14_21","005_14_21","NUM","14","21","21","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠤ ꠁꠈꠣꠘ ꠎꠦꠟꠣ ꠢꠣꠍꠣ, ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠅ ꠀꠝꠣꠞ ꠟꠤꠟꠣ-ꠈꠦꠟꠣꠄ ꠜꠞꠣ ꠁꠐꠣꠅ ꠎꠦꠟꠣ ꠢꠣꠍꠣ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠞꠇ ꠢꠣꠍꠣ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("NU14_22","005_14_22","NUM","14","22","23","ꠁꠔꠣ ꠄꠇꠎꠘꠦꠅ ꠀꠝꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠤ ꠖꠦꠡ ꠖꠦꠈꠣꠞ ꠡꠥꠎꠥꠉ ꠅꠁꠔ ꠘꠣꠄ, ꠎꠦ ꠖꠦꠡ ꠖꠤꠔꠣꠝ ꠇꠞꠤ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣꠝ। ꠇꠣꠞꠘ ꠁꠔꠣꠄ ꠀꠝꠣꠞ ꠘꠥꠞꠞ ꠔꠎꠟ꠆ꠟꠤ ꠖꠦꠈꠍꠂꠘ, ꠔꠣꠞꠣ ꠝꠤꠡꠞꠅ ꠕꠣꠇꠔꠦ ꠀꠞ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠁꠀꠅ ꠀꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠣꠞ ꠛꠣꠖꠦꠅ ꠁꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠝꠣꠘꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠖꠡ-ꠖꠡꠛꠣꠞ ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠍꠂꠘ। ꠔꠦ ꠔꠣꠞꠣ ꠎꠔꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠍꠦ, ꠁꠔꠣ ꠄꠇꠎꠘꠦꠅ ꠢꠤ ꠖꠦꠡ ꠖꠦꠈꠣꠞ ꠇꠙꠣꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU14_24","005_14_24","NUM","14","24","24","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠇꠣꠟꠥꠔꠞ ꠖꠤꠟꠞ ꠜꠣꠛ ꠁꠟꠣ ꠘꠣꠄ, ꠢꠦ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠣꠘꠦ। ꠄꠞꠟꠣꠉꠤ ꠎꠦ ꠖꠦꠡ ꠖꠦꠈꠣꠔ ꠢꠦ ꠉꠦꠍꠤꠟ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠢꠃ ꠖꠦꠡꠅ ꠘꠤꠝꠥ, ꠔꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠢꠤ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU14_25","005_14_25","NUM","14","25","25","ꠢꠥꠘꠅ, ꠢꠃ ꠖꠦꠡꠞ ꠙꠣꠠꠤꠀ ꠔꠟ ꠎꠣꠉꠣꠁꠘ꠆ꠔꠅ ꠅꠈꠘ ꠀꠝꠣꠟꠦꠇꠤ ꠀꠞ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠦ ꠛꠡꠔ ꠇꠞꠞꠣ। ꠔꠦ ꠍꠣꠝꠘꠞ ꠇꠣꠁꠟ ꠔꠥꠝꠞꠣ ꠙꠤꠍꠦꠖꠤ ꠉꠤꠀ ꠀꠇꠣꠛꠣ ꠡꠣꠉꠞꠞ ꠙꠣꠞꠦꠖꠤ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠅꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU14_26","005_14_26","NUM","14","26","26","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU14_27","005_14_27","NUM","14","27","27","“ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠎꠣꠔꠤꠄ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠞ ꠇꠔꠖꠤꠘ ꠛꠦꠞ-ꠛꠦꠞꠤ ꠇꠞꠔ? ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠦꠔꠣ ꠝꠣꠔ ꠝꠣꠔꠦꠞ, ꠁꠔꠣ ꠔ ꠀꠝꠤ ꠢꠥꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU14_28","005_14_28","NUM","14","28","28","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠞꠣꠝ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈꠞ ꠎꠦꠔꠣ ꠝꠣꠔ-ꠇꠕꠣ ꠢꠥꠘꠍꠤ, ꠀꠝꠤꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠑꠤꠇ ꠅꠟꠣꠃ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("NU14_29","005_14_29","NUM","14","29","29","ꠝꠣꠘꠥꠡ ꠉꠘꠤꠛꠣꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠔꠣꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠎꠦꠔꠣꠞꠦ ꠉꠘꠣ ꠅꠁꠍꠤꠟ, ꠝꠣꠘꠤ ꠎꠦꠔꠣꠄ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠦꠞ-ꠛꠦꠞꠤ ꠇꠞꠍꠦ, ꠁꠔꠣꠞ ꠟꠣꠡ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠙꠠꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU14_30","005_14_30","NUM","14","30","30","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠔꠣꠝ ꠇꠞꠤ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣꠝ, ꠈꠣꠟꠤ ꠎꠤꠚꠥꠘ꠆ꠘꠤꠞ ꠙꠥꠀ ꠇꠣꠟꠥꠔ ꠀꠞ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠉꠤꠀ ꠢꠤ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠇꠙꠣꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU14_31","005_14_31","NUM","14","31","31","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ ꠇꠁꠍꠟꠣꠄ, ꠀꠝꠤ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦꠃ ꠢꠃ ꠖꠦꠡꠅ ꠙꠣꠞ ꠇꠞꠝꠥ, ꠔꠣꠞꠣꠃ ꠅꠁꠛꠣ ꠢꠤ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇ, ꠎꠦ ꠖꠦꠡꠞꠦ ꠔꠥꠝꠞꠣ ꠄꠟꠣꠝꠤ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("NU14_32","005_14_32","NUM","14","32","32","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠡ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠙꠠꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU14_33","005_14_33","NUM","14","33","33","ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠙꠦꠐꠅ ꠔꠥꠝꠞꠣꠞ ꠄꠇ꠆ꠇꠦꠞꠦ ꠀꠈꠦꠞꠤ ꠎꠘ ꠘꠣ ꠝꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠔꠥꠝꠞꠣꠞ ꠛꠦꠁꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠅꠘꠅ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠞꠣꠈꠣꠟꠤ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU14_34","005_14_34","NUM","14","34","34","ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠖꠦꠈꠤꠀ ꠀꠁꠔꠦ ꠎꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠟꠣꠉꠍꠤꠟ, ꠄꠞ ꠄꠇ ꠖꠤꠘꠞ ꠛꠖꠟꠣ ꠄꠇ ꠛꠍꠞ, ꠅꠃꠟꠣ ꠝꠥꠐ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠡ꠆ꠐ ꠇꠞꠛꠣꠄ। ꠔꠦꠃ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠇꠦꠃꠞꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠤ ꠄꠞ ꠖꠡꠣ ꠇꠤꠟꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("NU14_35","005_14_35","NUM","14","35","35","ꠔꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠞꠣꠝ, ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠎꠣꠔꠤꠞ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠖꠟ ꠛꠣꠘ꠆ꠖꠤꠍꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU14_36","005_14_36","NUM","14","36","36","ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠝꠥꠍꠣꠄ ꠎꠦ ꠉꠥꠁꠀ ꠖꠟꠞꠦ ꠙꠣꠑꠣꠁꠍꠟꠣ, ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠎꠦꠉꠥꠁꠘ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠛꠦꠁꠝꠣꠘꠤ ꠈꠛꠞ ꠞꠐꠣꠁꠀ, ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠤꠀ ꠝꠥꠍꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠇꠣ-ꠎꠇꠣ ꠇꠞꠣꠁꠍꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("NU14_37","005_14_37","NUM","14","37","37","ꠝꠣꠘꠤ ꠎꠦꠞꠣ ꠢꠃ ꠖꠦꠡꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠎꠦ-ꠛꠣꠎꠦ ꠝꠣꠔ ꠞꠐꠣꠁꠍꠤꠟ, ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠃ ꠝꠢꠣ ꠉꠎꠛꠤ ꠛꠦꠝꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠝꠞꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU14_38","005_14_38","NUM","14","38","38","ꠅꠃ ꠉꠥꠁꠀ ꠖꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠈꠣꠟꠤ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ ꠀꠞ ꠎꠤꠚꠥꠘ꠆ꠘꠤꠞ ꠙꠥꠀ ꠇꠣꠟꠥꠔ ꠛꠣꠌꠤꠀ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU14_39","005_14_39","NUM","14","39","39","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠇꠕꠣ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠝꠘꠞ ꠖꠥꠈꠦ ꠇꠣꠔꠞ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU14_40","005_14_40","NUM","14","40","40","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠔꠣꠞꠣ ꠢꠃ ꠙꠣꠠꠤ ꠄꠟꠣꠇꠣꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠤꠀꠞ ꠅꠁꠀ ꠇꠁꠟ, “ꠅꠃ ꠖꠦꠈꠅ, ꠀꠝꠞꠣ ꠎꠣꠁꠞꠣꠝꠉꠤ। ꠀꠝꠞꠣ ꠔ ꠉꠥꠘꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠍꠤ, ꠔꠦ ꠅꠈꠘ ꠀꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠖꠦꠡꠅꠃ ꠎꠣꠁꠔꠣꠝꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU14_41","005_14_41","NUM","14","41","41","ꠅꠁꠟꠦ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠎꠣꠁꠞꠣꠄ ꠇꠦꠘꠦ? ꠔꠥꠝꠞꠣꠞ ꠘꠤꠅꠔ ꠙꠥꠞꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU14_42","005_14_42","NUM","14","42","42","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠎꠣꠁꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠘꠣꠄ। ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠞꠣ ꠀꠞꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU14_43","005_14_43","NUM","14","43","43","ꠢꠤꠘꠅ ꠉꠤꠀ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠟꠦꠇꠤ ꠀꠞ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠞ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠅꠁꠛꠣꠄ। ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠟꠉ ꠍꠣꠠꠤꠀ ꠉꠦꠍꠉꠤ ꠇꠞꠤ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠔꠣ ꠘꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠥꠖ꠆ꠖꠞ ꠝꠥꠈꠅ ꠝꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU14_44","005_14_44","NUM","14","44","44","ꠔꠦꠛꠃ ꠔꠣꠞꠣ ꠔꠣꠘ ꠇꠕꠣ ꠃꠟꠐꠣꠁꠀ ꠢꠃ ꠙꠣꠠꠤ ꠄꠟꠣꠇꠣ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠖꠤꠟ। ꠅꠁꠟꠦ ꠝꠥꠍꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠉꠦꠟꠣ ꠘꠣ ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠙꠛꠤꠔ꠆ꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠅ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠞꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU14_45","005_14_45","NUM","14","45","45","ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠢꠃ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠞ ꠀꠝꠣꠟꠦꠇꠤ ꠀꠞ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠢꠣꠝꠟꠣ ꠌꠣꠟꠣꠁꠟ, ꠀꠞ ꠢꠘꠞ ꠢꠞ꠆ꠝꠣ ꠐꠣꠃꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠈꠦꠖꠣꠁꠀ ꠘꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU15_1","005_15_1","NUM","15","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU15_2","005_15_2","NUM","15","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠀꠝꠤ ꠎꠦ ꠖꠦꠡꠈꠣꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠖꠦꠡ ꠢꠤꠡꠣꠛꠦ ꠖꠣꠘ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠃ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠎꠣꠁꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU15_3","005_15_3","NUM","15","3","3","ꠉꠤꠀ ꠀꠝꠣꠞꠦ ꠈꠥꠡ ꠞꠣꠈꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠎꠦꠇꠥꠘꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠎꠦꠛꠟꠣ ꠉꠣꠁ-ꠉꠞꠥ ꠛꠣ ꠝꠦꠠꠣ-ꠍꠣꠉꠟ ꠀꠘꠤꠀ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔ ꠇꠞꠛꠣꠄ, ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠇꠥꠘꠥ ꠝꠣꠘ꠆ꠘꠔ ꠙꠥꠞꠘꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠚꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠛꠣ ꠎꠦꠇꠥꠘꠥ ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("NU15_4","005_15_4","NUM","15","4","4","ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠞꠔꠦꠇ ꠙꠡꠥꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ꠅꠃ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠁ ꠡꠦꠞ ꠝꠄꠖꠣꠞꠦ ꠄꠇ ꠡꠦꠞ ꠔꠦꠟꠖꠤ ꠝꠣꠈꠣꠁꠀ ꠈꠣꠁ ꠛꠣꠘꠣꠁꠀ ꠀꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_5","005_15_5","NUM","15","5","5","ꠅꠁꠟꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠐꠣ ꠎꠥꠖꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠄ, ꠔꠦ ꠁꠐꠣꠞ ꠟꠉꠦ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠀꠋꠉꠥꠞꠞ ꠄꠇ ꠡꠦꠞ ꠡꠞꠛꠔꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_6","005_15_6","NUM","15","6","6","ꠀꠞ ꠅꠃ ꠙꠡꠥ ꠎꠥꠖꠤ ꠝꠦꠠꠣ ꠅꠄ, ꠔꠦ ꠔꠣꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠡꠥꠀ ꠡꠦꠞ ꠔꠦꠟꠖꠤ ꠝꠣꠈꠣꠁꠀ ꠌꠣꠁꠞ ꠡꠦꠞ ꠝꠄꠖꠣ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_7","005_15_7","NUM","15","7","7","ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠟꠣꠉꠛ ꠀꠋꠉꠥꠞꠞ ꠡꠥꠀ ꠡꠦꠞ ꠡꠞꠛꠔ। ꠁꠔꠣ ꠀꠘꠤꠀ ꠀꠝꠣꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU15_8","005_15_8","NUM","15","8","8","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠝꠣꠘ꠆ꠘꠔ ꠙꠥꠞꠘꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠛꠣ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠉꠞꠥ ꠟꠁꠀ ꠀꠅ, ");
INSERT INTO syls_vpl VALUES ("NU15_9","005_15_9","NUM","15","9","9","ꠔꠦ ꠄꠞꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠍꠄ ꠡꠦꠞ ꠝꠄꠖꠣꠞꠦ ꠖꠥꠁ ꠡꠦꠞ ꠔꠦꠟꠖꠤ ꠝꠣꠈꠣꠁꠀ ꠈꠣꠁ ꠀꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU15_10","005_15_10","NUM","15","10","10","ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠀꠋꠉꠥꠞꠞ ꠖꠥꠁ ꠡꠦꠞ ꠡꠞꠛꠔꠅ ꠀꠘꠔꠦ ꠅꠁꠛ। “ꠁꠔꠣ ꠅꠁꠟ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠁ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠀꠝꠤ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("NU15_11","005_15_11","NUM","15","11","11","ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠞꠔꠦꠇ ꠉꠞꠥ, ꠝꠦꠠꠣ, ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠛꠣ ꠍꠣꠉꠟꠞꠦ ꠅꠃ ꠘꠤꠅꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_12","005_15_12","NUM","15","12","12","ꠔꠥꠝꠞꠣ ꠎꠔ ꠙꠞꠤꠝꠣꠘ ꠙꠡꠥꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅ ꠘꠣ ꠇꠦꠘꠦ, ꠙꠞꠔꠦꠇ ꠙꠡꠥꠞ ꠟꠉꠦ ꠅꠃ ꠘꠤꠅꠝꠦ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_13","005_15_13","NUM","15","13","13","“ꠢꠥꠘꠅ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠎꠦꠇꠥꠘꠥ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠡꠝꠄ, ꠙꠞꠔꠦꠇ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠃ ꠘꠤꠅꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_14","005_15_14","NUM","15","14","14","ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠝꠥꠍꠣꠚꠤꠞ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠇꠥꠘꠥ ꠜꠤꠘ-ꠖꠦꠡꠤꠄ ꠎꠥꠖꠤ, ꠀꠝꠣꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔ ꠌꠣꠄ, ꠔꠦ ꠢꠦ-ꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠁ ꠘꠤꠅꠝ ꠝꠣꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU15_15","005_15_15","NUM","15","15","15","ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠅꠃ ꠘꠤꠅꠝ ꠎꠣꠞꠤ ꠞꠁꠛ। ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎꠞ ꠢꠇꠟꠞ ꠟꠣꠉꠤ ꠅꠃ ꠘꠤꠅꠝ ꠌꠣꠟꠥ ꠞꠁꠛ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠅꠅ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠁꠟꠦꠅ, ꠢꠇꠟꠞ ꠟꠣꠉꠤꠃ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠅꠃ ꠄꠇꠁ ꠘꠤꠅꠝ ꠎꠣꠞꠤ ꠞꠁꠛ। ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ, ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟꠅ ꠅꠃꠟꠣ, ꠢꠇꠟ ꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("NU15_16","005_15_16","NUM","15","16","16","ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠄꠇꠟꠣꠈꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠄꠇꠁ ꠡꠞꠤꠅꠔ ꠌꠣꠟꠥ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU15_17","005_15_17","NUM","15","17","17","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU15_18","005_15_18","NUM","15","18","18","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠅ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠅ ꠘꠤꠀꠞ, ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("NU15_19","005_15_19","NUM","15","19","19","ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠃ ꠖꠦꠡꠞ ꠚꠄ-ꠚꠡꠟ ꠈꠣꠁꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞ ꠇꠤꠍꠥ ꠅꠋꠡ ꠀꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_20","005_15_20","NUM","15","20","20","ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠖꠣꠅꠀ ꠚꠡꠟꠞ ꠝꠄꠖꠣ ꠖꠤꠀ ꠄꠇꠈꠣꠘ ꠞꠥꠐꠤ ꠛꠣꠘꠣꠁꠀ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠍꠖꠉꠣ ꠖꠤꠛꠣꠄ। ꠉꠤꠞꠡ꠆ꠔ-ꠛꠣꠠꠤꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠈꠣꠘ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_21","005_15_21","NUM","15","21","21","ꠙꠄꠟꠣ ꠖꠣꠅꠀ ꠚꠡꠟꠞ ꠅꠃ ꠍꠖꠉꠣ, ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_22","005_15_22","NUM","15","22","22","“ꠅ ꠝꠥꠍꠣ, ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞ ꠝꠣꠎꠖꠤ ꠎꠔ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠖꠤꠍꠤ, ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠘꠣ ꠎꠣꠘꠤꠀ ꠅꠔꠣ ꠇꠥꠘꠥ ꠄꠇꠐꠣ ꠢꠥꠇꠥꠝ ꠜꠣꠋꠉꠤꠟꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU15_23","005_15_23","NUM","15","23","23","ꠁꠔꠣ ꠢꠇꠟ ꠢꠥꠇꠥꠝ ꠔ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠕꠣꠇꠤ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠎꠣꠞꠤ ꠞꠄ, ");
INSERT INTO syls_vpl VALUES ("NU15_24","005_15_24","NUM","15","24","24","ꠔꠦ ꠁ ꠅꠎꠣꠘꠣ ꠛꠦꠙꠣꠞꠐꠣ ꠎꠣꠘꠣꠞ ꠛꠣꠖꠦꠃ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠦ ꠝꠤꠟꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠔꠣꠞꠣ ꠄꠇꠐꠣ ꠛꠤꠍꠣꠟ ꠖꠤꠀ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛ, ꠄꠞꠟꠉꠦ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠖꠤꠛ। ꠀꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠍꠣꠉꠟꠅ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("NU15_25","005_15_25","NUM","15","25","25","ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠞ ꠅꠃ ꠅꠎꠣꠘꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠝꠣꠚꠤ ꠙꠣꠁꠛꠣ। ꠔꠣꠞꠣ ꠔ ꠁꠌ꠆ꠍꠣ ꠇꠞꠤꠀ ꠁ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠍꠦ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠜꠥꠟꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠅ ꠀꠖꠣꠄ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU15_26","005_15_26","NUM","15","26","26","ꠔꠦꠃ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎ ꠀꠞ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠣꠘꠡꠞꠦꠅ ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠛ, ꠎꠥꠖꠤꠅ ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠁ ꠜꠥꠟ-ꠇꠍꠥꠞꠤ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU15_27","005_15_27","NUM","15","27","27","“ꠅꠁꠟꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠄꠇꠟꠣ ꠜꠥꠟ ꠇꠞꠤꠀ ꠝꠘꠞ ꠅꠎꠣꠘ꠆ꠔꠦ ꠇꠥꠘꠥ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠦ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠄꠇꠐꠣ ꠍꠣꠉꠤ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU15_28","005_15_28","NUM","15","28","28","ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠝꠘꠞ ꠅꠎꠣꠘ꠆ꠔꠦ ꠅꠃ ꠉꠥꠘꠣ ꠇꠞꠍꠦ, ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠛꠣ। ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠛꠥꠟ ꠅꠁꠟꠦ ꠢꠦ ꠝꠣꠚꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU15_29","005_15_29","NUM","15","29","29","ꠜꠥꠟ ꠇꠞꠤꠀ ꠝꠘꠞ ꠅꠎꠣꠘ꠆ꠔꠦ ꠎꠦ ꠝꠣꠘꠡꠦ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠤꠟꠣꠄ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠁ ꠘꠤꠅꠝ ꠌꠣꠟꠥ ꠞꠁꠛ, ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠃꠇ, ꠛꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠃꠇ, ꠄꠇꠁ ꠘꠤꠅꠝꠦ ꠌꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("NU15_30","005_15_30","NUM","15","30","30","“ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠛꠣ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠎꠣꠔꠤꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠌ꠆ꠍꠣ ꠇꠞꠤꠀ ꠇꠥꠘꠥ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠦ। ꠁꠟꠣ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠅꠉꠥꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU15_31","005_15_31","NUM","15","31","31","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠣꠄ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠣꠄ ꠅꠉꠥꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠔꠦ ꠅꠁꠛ, ꠔꠣꠞ ꠁ ꠉꠥꠘꠣꠞ ꠖꠣꠄ-ꠜꠣꠞ ꠔꠣꠞ ꠃꠙꠞꠦꠃ ꠛꠞ꠆ꠔꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU15_32","005_15_32","NUM","15","32","32","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠍꠚꠞꠞ ꠇꠣꠟꠅ ꠄꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠖꠣꠞꠥ ꠔꠥꠛꠣꠘꠤꠔ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU15_33","005_15_33","NUM","15","33","33","ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠖꠣꠞꠥ ꠔꠥꠛꠣꠘꠤꠔ ꠖꠦꠈꠣꠄ ꠅꠃ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠗꠞꠤꠀ ꠝꠥꠍꠣ ꠘꠛꠤ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠀꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU15_34","005_15_34","NUM","15","34","34","ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠔꠦ ꠅꠁꠛ, ꠁ ꠢꠥꠇꠥꠝ ꠔ ꠀꠟ꠆ꠟꠣꠄ ꠅꠈꠘꠅ ꠎꠣꠘꠣꠁꠍꠂꠘ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠄꠞꠦ ꠔꠣꠞꠣ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠕꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU15_35","005_15_35","NUM","15","35","35","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ, “ꠅꠃ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ। ꠔꠣꠞꠦ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠁꠐꠣꠁꠀ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU15_36","005_15_36","NUM","15","36","36","ꠔꠦꠃ ꠝꠥꠍꠣꠞ ꠝꠣꠞꠚꠔꠦ ꠙꠣꠅꠀ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠦ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠝꠣꠞꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU15_37","005_15_37","NUM","15","37","37","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU15_38","005_15_38","NUM","15","38","38","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠟꠦꠛꠣꠍꠞ ꠙꠣꠁꠠꠅ ꠎꠣꠎꠁꠞ ꠟꠣꠉꠣꠅ, ꠀꠞ ꠎꠣꠎꠁꠞꠞ ꠙꠞꠔꠦꠇ ꠉꠤꠐꠞꠦ ꠟꠤꠟꠥꠀ ꠡꠥꠔꠣꠖꠤ ꠙꠦꠌꠣꠁꠀ ꠝꠥꠟ ꠇꠣꠙꠠꠞ ꠟꠉꠦ ꠎꠥꠠꠣ ꠖꠤꠅ। ꠁ ꠢꠥꠇꠥꠝ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠝꠣꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_39","005_15_39","NUM","15","39","39","ꠁ ꠎꠣꠎꠁꠞ ꠟꠣꠉꠣꠘꠤꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠅꠔꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠢꠇ꠆ꠇꠟ ꠢꠥꠇꠥꠝꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠤꠀ ꠅꠔꠣ ꠀꠝꠟ ꠇꠞꠛꠣꠄ। ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠔꠣꠄ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠌꠃꠈꠞ ꠀꠞ ꠖꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠀꠔꠅ ꠘꠤꠎꠞꠦ ꠡꠙꠤꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_40","005_15_40","NUM","15","40","40","ꠀꠝꠣꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠣꠞ ꠇꠕꠣ ꠔꠥꠝꠞꠣꠞ ꠁꠀꠖ ꠞꠁꠛ, ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠞꠣ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘ꠆ꠖꠣꠞ ꠢꠣꠟꠔꠦ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU15_41","005_15_41","NUM","15","41","41","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠅꠀꠞ ꠈꠤꠀꠟꠦ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠤ। ꠀꠝꠤꠃ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("NU16_1","005_16_1","NUM","16","1","2","ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠇꠥꠞꠣꠢꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠖꠥꠡꠝꠘꠤ ꠟꠣꠉꠣꠁꠟ। ꠅꠃ ꠇꠥꠞꠣꠢ ꠅꠁꠟ ꠇꠣꠢꠣꠔꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠁꠎꠢꠣꠞꠞ ꠙꠥꠀ। ꠔꠣꠞ ꠟꠉꠦ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠟꠤꠀꠛꠞ ꠙꠥꠀ ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝ, ꠀꠞ ꠚꠟꠦꠔꠞ ꠙꠥꠀ ꠅꠃꠘꠦꠅ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠟ। ꠄꠞꠣꠞ ꠖꠟꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠞꠅ ꠀꠠꠣꠁ-ꠡ ꠎꠘ ꠘꠣꠝꠇꠞꠣ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣꠅ ꠡꠞꠤꠇ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_3","005_16_3","NUM","16","3","3","ꠅꠁꠀ ꠔꠣꠞꠣ ꠖꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠈꠥꠛ ꠛꠦꠡꠤ ꠛꠣꠠꠣꠛꠣꠠꠤ ꠇꠞꠞꠣꠄ। ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠥꠡꠃ ꠎꠦꠛꠟꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠝꠣꠛꠥꠖꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠃꠡ꠆ꠔꠣꠖꠤ ꠇꠞꠞꠣꠄ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("NU16_4","005_16_4","NUM","16","4","4","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣ ꠘꠛꠤ ꠃꠚꠁꠔ ꠅꠁꠀ ꠝꠣꠐꠤꠔ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_5","005_16_5","NUM","16","5","5","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠥꠞꠣꠢ ꠀꠞ ꠔꠣꠞ ꠖꠟꠞ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠇꠣꠁꠟ ꠛꠤꠀꠘꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠖꠦꠈꠣꠁꠛꠣ, ꠇꠦ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ, ꠀꠞ ꠇꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ। ꠔꠣꠁꠘ ꠎꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ, ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦꠃ ꠔꠣꠘ ꠇꠣꠍꠣꠔ ꠀꠁꠔꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_6","005_16_6","NUM","16","6","7","ꠅ ꠇꠥꠞꠣꠢ, ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠟꠉꠞ ꠢꠇꠟꠦ ꠄꠇ ꠇꠣꠝ ꠇꠞꠅ, ꠍꠣꠝꠘꠞ ꠇꠣꠁꠟ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠄꠇꠐꠣ ꠇꠞꠤ ꠀꠉꠞ ꠖꠣꠘꠤ ꠟꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠅ। ꠔꠣꠁꠘ ꠎꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠛꠥꠎꠤꠟꠤꠅ ꠢꠦ-ꠃ ꠔꠣꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠛꠘ꠆ꠖꠣ। ꠔꠥꠝꠞꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ ꠔ ꠛꠦꠡꠤ ꠛꠣꠠꠤꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU16_8","005_16_8","NUM","16","8","8","ꠝꠥꠍꠣꠄ ꠔꠣꠞꠦ ꠄꠅꠈꠣꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠟꠦꠛꠤ ꠅꠇꠟꠦ ꠀꠝꠣꠞ ꠄꠇꠈꠣꠘ ꠇꠕꠣ ꠢꠥꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("NU16_9","005_16_9","NUM","16","9","9","ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠇꠞꠞꠣꠄ ꠘꠤ ꠝꠣꠛꠥꠖꠞ ꠇꠣꠛꠣ ꠊꠞꠅ ꠄꠛꠣꠖꠔꠤ ꠇꠞꠣ ꠀꠞ ꠡꠝꠣꠎꠞ ꠝꠣꠘꠡꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠣ ꠁꠔꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠛꠦꠙꠣꠞ? ꠢꠥꠘꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠟ꠆ꠟꠣꠄ ꠡꠝꠣꠎꠞ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠍꠤꠀ ꠘꠤꠀ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠖꠤꠖꠣꠞꠅ ꠀꠘꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠅꠃ ꠇꠣꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("NU16_10","005_16_10","NUM","16","10","10","ꠔꠣꠁꠘ ꠔ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠘꠤꠎꠞ ꠗꠣꠞꠅ ꠀꠁꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠍꠂꠘ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠖꠦꠈꠤꠀꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠙꠖꠞꠦꠅ ꠖꠈꠟ ꠇꠞꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU16_11","005_16_11","NUM","16","11","11","ꠢꠣꠞꠥꠘ ꠀꠞ ꠇꠥꠘ ꠝꠣꠘꠥꠡ ꠎꠦꠘ, ꠔꠥꠝꠞꠣ ꠔꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠇꠣ-ꠎꠇꠣ ꠇꠞꠞꠣꠄ? ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠖꠟꠞ ꠝꠣꠘꠡꠦ ꠔ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦꠃ ꠖꠟ ꠛꠣꠘ꠆ꠖꠤꠍ।” ");
INSERT INTO syls_vpl VALUES ("NU16_12","005_16_12","NUM","16","12","12","ꠄꠞꠣꠞ ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠈꠛꠞ ꠖꠤꠟꠣ, ꠁꠟꠤꠀꠛꠞ ꠖꠥꠁ ꠙꠥꠀ ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝ ꠀꠁꠔꠣ ꠇꠞꠤ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠎꠣꠘꠣꠁꠟ, “ꠀꠝꠞꠣ ꠅꠔ ꠑꠦꠇꠣꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU16_13","005_16_13","NUM","16","13","13","ꠔꠥꠝꠤ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠘꠤꠀ ꠝꠣꠞꠔꠣꠄ ꠇꠞꠤ, ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠢꠃ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍ, ꠢꠤ ꠖꠦꠡꠅ ꠔ ꠇꠥꠘ꠆ꠔꠣꠞꠃ ꠅꠜꠣꠛ ꠀꠍꠤꠟ ꠘꠣ। ꠄꠞ ꠛꠣꠖꠦꠅ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠘꠤꠔ ꠟꠣꠉꠍ। ");
INSERT INTO syls_vpl VALUES ("NU16_14","005_16_14","NUM","16","14","14","ꠀꠞ ꠔꠥꠝꠤ ꠔ ꠀꠝꠞꠣꠞꠦ ꠢꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠖꠦꠡꠅ-ꠅ ꠘꠤꠍ ꠘꠣ, ꠇꠥꠘꠥ ꠎꠝꠤ-ꠎꠝꠣ ꠛꠣ ꠀꠋꠉꠥꠞ ꠛꠣꠉꠣꠘꠞ ꠝꠣꠟꠤꠇꠣꠘꠣꠅ ꠖꠤꠍ ꠘꠣ। ꠔꠥꠝꠤ ꠁꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠀꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠀ ꠞꠣꠈꠔꠣꠄ ꠌꠣꠅ ꠘꠤ? ꠘꠣ, ꠀꠝꠞꠣ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU16_15","005_16_15","NUM","16","15","15","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣ ꠈꠥꠛ ꠉꠞꠝ ꠅꠁꠀ ꠝꠣꠛꠥꠖꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠄꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠛꠥꠟ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠝꠤ ꠔ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠇꠞꠍꠤ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠄꠉꠥ ꠉꠣꠗꠣꠅ ꠀꠝꠤ ꠘꠤꠍꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU16_16","005_16_16","NUM","16","16","16","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠇꠥꠞꠣꠢꠞꠦ ꠇꠁꠟꠣ, “ꠇꠣꠁꠟ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠖꠟꠞ ꠢꠇꠟ ꠀꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠛꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠢꠣꠞꠥꠘꠅ ꠀꠎꠤꠞ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_17","005_16_17","NUM","16","17","17","ꠙꠞꠔꠦꠇꠦ ꠀꠁꠀ ꠎꠣꠞꠎꠤꠞ ꠀꠉꠞ ꠖꠣꠘꠤꠔ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠜꠞꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠣꠁꠛꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠀꠠꠣꠁ-ꠡ ꠎꠘꠞ ꠢꠇ꠆ꠇꠟꠦ ꠅꠟꠣ ꠎꠣꠞꠎꠤꠞ ꠀꠉꠞ ꠖꠣꠘꠤ ꠎꠣꠟꠣꠁꠅ। ꠄꠞꠟꠉꠦ ꠔꠥꠝꠤ ꠀꠞ ꠢꠣꠞꠥꠘꠦꠅ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU16_18","005_16_18","NUM","16","18","18","ꠝꠥꠍꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠙꠞꠔꠦꠇꠦ ꠎꠣꠞꠎꠤꠞ ꠀꠉꠞ ꠖꠣꠘꠤꠔ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠀꠞ ꠀꠉꠥꠁꠘ ꠟꠁꠀ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ, ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠟꠉꠦ ꠉꠤꠀ ꠃꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_19","005_16_19","NUM","16","19","19","ꠇꠥꠞꠣꠢꠦ ꠎꠦꠛꠟꠣ ꠡꠝꠣꠎꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠃꠡ꠆ꠇꠣꠁꠀ ꠖꠟꠣ ꠇꠞꠟ, ꠇꠞꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠃꠛꠣꠁꠟ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠘꠥꠞ ꠎꠣꠁꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU16_20","005_16_20","NUM","16","20","20","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU16_21","005_16_21","NUM","16","21","21","“ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠢꠞꠤ ꠎꠣꠅ, ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠌꠈꠥꠞ ꠙꠟꠇꠞ ꠟꠉꠦ ꠡꠦꠡ ꠇꠞꠤꠟꠤꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("NU16_22","005_16_22","NUM","16","22","22","ꠅꠁꠟꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠤ ꠔ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠜꠤꠔꠞꠦ ꠎꠣꠘ ꠖꠦꠅ। ꠅꠈꠘ ꠈꠣꠟꠤ ꠄꠇꠎꠘꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠖꠣꠄ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠤ ꠉꠎꠛ ꠓꠣꠟꠤꠔꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("NU16_23","005_16_23","NUM","16","23","23","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU16_24","005_16_24","NUM","16","24","24","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠇꠥꠞꠣꠢ, ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝꠞ ꠔꠣꠝ꠆ꠛꠥꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤ ꠎꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("NU16_25","005_16_25","NUM","16","25","25","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣ ꠍꠁꠎꠖꠣ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ, ꠔꠣꠘ ꠈꠞꠦ ꠅꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_26","005_16_26","NUM","16","26","26","ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠔꠣꠝ꠆ꠛꠥ ꠕꠣꠇꠤ ꠢꠞꠤ ꠎꠣꠅ, ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠔ ꠍꠁꠅ ꠘꠣ। ꠀꠞꠘꠣꠄ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠛꠤꠘꠣꠡ ꠇꠞꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU16_27","005_16_27","NUM","16","27","27","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠇꠥꠞꠣꠢ, ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝꠞ ꠔꠣꠝ꠆ꠛꠥꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠢꠞꠤ ꠉꠦꠟꠣ। ꠄꠞꠝꠣꠎꠦ ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝꠦ ꠔꠣꠞꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠀꠞ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠟꠁꠀ ꠀꠁꠀ ꠎꠣꠞꠎꠤꠞ ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU16_28","005_16_28","NUM","16","28","28","ꠅꠃ ꠡꠝꠄ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠃ ꠀꠟꠣꠝꠔ ꠖꠦꠈꠤꠀ ꠛꠥꠎꠤꠟꠤꠛꠣꠄ, ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠞꠤꠀꠞ ꠁꠔꠣ ꠀꠝꠣꠞ ꠝꠘꠉꠠꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ꠅꠃ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU16_29","005_16_29","NUM","16","29","29","ꠄꠞꠣꠞ ꠝꠞꠘ ꠎꠥꠖꠤ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠡ꠆ꠛꠣꠜꠣꠛꠤꠇ ꠢꠣꠟꠔꠦ ꠅꠄ, ꠔꠦ ꠝꠘꠅ ꠇꠞꠤꠅ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_30","005_16_30","NUM","16","30","30","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠎꠥꠖꠤ ꠀꠌꠣꠘꠇ ꠘꠄꠀ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠅꠃ ꠎꠝꠤꠘꠦ ꠝꠥꠈ ꠈꠥꠟꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠀꠞ ꠔꠣꠞꠣꠞ ꠢꠇꠟꠔꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠉꠤꠟꠤꠟꠣꠄ, ꠔꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦꠃ ꠝꠣꠐꠤꠞ ꠔꠟꠞ ꠙꠣꠔꠣꠟꠅ ꠎꠣꠄꠉꠤ, ꠔꠦ ꠛꠥꠎꠤꠟꠤꠅ, ꠄꠞꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU16_31","005_16_31","NUM","16","31","31","ꠝꠥꠍꠣꠄ ꠅꠈꠣꠘ ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠄꠞꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠞ ꠝꠣꠐꠤ ꠚꠣꠐꠤꠀ ꠖꠥꠁ ꠛꠣꠐ ꠅꠁꠉꠦꠟ, ");
INSERT INTO syls_vpl VALUES ("NU16_32","005_16_32","NUM","16","32","32","ꠀꠞ ꠝꠣꠐꠤꠄ ꠀ ꠇꠞꠤꠀ ꠇꠥꠞꠣꠢꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠞꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠡꠢ ꠉꠤꠟꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU16_33","005_16_33","NUM","16","33","33","ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠡꠥꠖ꠆ꠖꠣ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠔꠣꠞꠣ ꠝꠣꠐꠤꠞ ꠔꠟꠦ ꠉꠦꠟꠉꠤ, ꠛꠣꠖꠦ ꠝꠣꠐꠤꠞ ꠚꠣꠐꠣ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ। ꠅꠃꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠄꠇꠖꠝ ꠘꠤꠙꠣꠔ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU16_34","005_16_34","NUM","16","34","34","ꠔꠣꠞꠣꠞ ꠌꠤꠇ-ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠤꠀ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠣꠇꠤ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠖꠃꠠꠣꠁꠀ ꠜꠣꠉꠤꠟꠣ, ꠁꠔꠣꠄ ꠌꠤꠟ꠆ꠟꠣꠁ ꠌꠤꠟ꠆ꠟꠣꠁ ꠖꠃꠠꠣꠁꠀ ꠇꠁꠟꠣ, “ꠝꠣꠐꠤꠄ ꠢꠄꠔ ꠀꠝꠞꠣꠞꠦꠅ ꠉꠤꠟꠤꠟꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU16_35","005_16_35","NUM","16","35","35","ꠀꠞ ꠢꠃ ꠎꠦ ꠀꠠꠣꠁ-ꠡ ꠎꠘꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠍꠤꠟ, ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠉꠣꠁꠛꠤ ꠀꠉꠥꠁꠘ ꠀꠁꠀ ꠁꠔꠣꠞꠦ ꠎꠣꠟꠣꠁꠀ ꠍꠣꠟꠤ ꠇꠞꠤꠟ꠆ꠟ। ");
INSERT INTO syls_vpl VALUES ("NU16_36","005_16_36","NUM","16","36","36","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU16_37","005_16_37","NUM","16","37","37","“ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞꠞꠦ ꠇꠅ, ꠅꠃ ꠎꠣꠟꠣꠁꠟ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠀꠉꠞ ꠖꠣꠘꠤ ꠉꠥꠁꠘ ꠛꠣꠞ ꠇꠞꠤꠀ, ꠄꠞ ꠀꠋꠞꠣ-ꠍꠣꠟꠤ ꠘꠤꠀ ꠕꠥꠠꠣ ꠖꠥꠞꠁ ꠚꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠁ ꠀꠉꠞ ꠖꠣꠘꠤ ꠉꠥꠁꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠛꠘꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU16_38","005_16_38","NUM","16","38","38","ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠦꠉꠥꠁꠘ ꠝꠞꠤꠉꠦꠍꠂꠘ, ꠅꠃ ꠀꠉꠞ ꠖꠣꠘꠤ ꠔ ꠔꠣꠞꠣꠞ ꠀꠍꠤꠟ। ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠁꠔꠣ ꠀꠎꠤꠞ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠄꠞꠟꠣꠉꠤ ꠁ ꠢꠇꠟꠐꠤ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠉꠦꠍꠦ। ꠔꠦ ꠔꠥꠝꠤ ꠁꠔꠣ ꠜꠣꠋꠉꠣꠁꠀ ꠙꠣꠔ ꠛꠣꠘꠣꠁꠀ ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠉꠥꠞꠤꠀ ꠕꠁꠅ। ꠁꠔꠣ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU16_39","005_16_39","NUM","16","39","39","ꠔꠦꠃ ꠀꠉꠥꠁꠘꠦ ꠎꠟꠤꠀ ꠎꠦꠉꠥꠁꠘ ꠝꠞꠍꠤꠟꠣ, ꠅꠔꠣꠞ ꠀꠘꠣ ꠙꠤꠔꠟꠞ ꠀꠉꠞ ꠖꠣꠘꠤ ꠉꠥꠁꠘ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠟꠣ। ꠛꠣꠖꠦ ꠅꠔꠣ ꠜꠣꠋꠉꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠉꠥꠞꠤꠀ ꠕꠅꠀꠞ ꠙꠣꠔ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_40","005_16_40","NUM","16","40","40","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠄꠁꠘ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠟꠣ। ꠁꠇꠐꠣ ꠇꠞꠣ ꠅꠁꠟ ꠎꠣꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠘꠅ ꠕꠣꠇꠦ ꠎꠦꠘ, ꠈꠣꠟꠤ ꠢꠣꠞꠥꠘꠞ ꠛꠋꠡ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠎꠘ, ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠎꠥꠖꠤ ꠎꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠖꠡꠣ ꠅꠃ ꠇꠥꠞꠣꠢ ꠀꠞ ꠔꠣꠞ ꠖꠟꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU16_41","005_16_41","NUM","16","41","41","ꠅꠁꠟꠦ ꠛꠣꠖꠞ ꠖꠤꠘꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠘꠡꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠦꠞ-ꠛꠦꠞꠤ ꠟꠣꠉꠣꠁꠟ, ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣꠃ ꠝꠣꠞꠍ।” ");
INSERT INTO syls_vpl VALUES ("NU16_42","005_16_42","NUM","16","42","42","ꠀꠞ ꠡꠝꠣꠎꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠥꠈꠣ ꠊꠥꠞꠤꠀ ꠃꠛꠣꠁꠟ, ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠉꠣꠁꠛꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠄ ꠀꠈꠔꠣꠃ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥ ꠉꠥꠞꠤ ꠉꠦꠟ, ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠘꠥꠞ ꠎꠣꠁꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU16_43","005_16_43","NUM","16","43","43","ꠔꠦꠃ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦ ꠉꠦꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU16_44","005_16_44","NUM","16","44","44","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU16_45","005_16_45","NUM","16","45","45","“ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠢꠞꠤ ꠎꠣꠅ, ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠌꠈꠥꠞ ꠙꠟꠇꠞ ꠟꠉꠦ ꠡꠦꠡ ꠇꠞꠤꠟꠤꠀꠞ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠎꠘ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_46","005_16_46","NUM","16","46","46","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠉꠞ ꠖꠣꠘꠤ ꠀꠔꠅ ꠟꠅ, ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠀꠉꠥꠁꠘ ꠘꠦꠅ, ꠘꠤꠀ ꠄꠞ ꠃꠙꠞꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠀ, ꠎꠟꠖꠤ ꠇꠞꠤ ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠅ। ꠝꠣꠛꠥꠖ ꠔ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠍꠂꠘ, ꠔꠣꠘ ꠟꠣꠘ꠆ꠘꠔꠤ ꠝꠢꠣꠝꠣꠞꠤ ꠡꠥꠞꠥ ꠅꠁꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU16_47","005_16_47","NUM","16","47","47","ꠔꠦꠃ ꠝꠥꠍꠣꠞ ꠇꠕꠣꠝꠔ ꠢꠣꠞꠥꠘꠦ ꠀꠉꠞ ꠖꠣꠘꠤꠔ ꠀꠉꠥꠁꠘ ꠀꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠟꠁꠀ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠦꠟꠣ। ꠄꠞ ꠝꠣꠎꠦꠃ ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠡꠥꠞꠥ ꠅꠁꠉꠦꠍꠤꠟ, ꠅꠁꠟꠦ ꠢꠣꠞꠥꠘꠦ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠀ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_48","005_16_48","NUM","16","48","48","ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠎꠘꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣꠁꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠉꠎꠛ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU16_49","005_16_49","NUM","16","49","49","ꠇꠥꠞꠣꠢꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠝꠣꠞꠣ ꠉꠦꠍꠟꠣ, ꠁꠉꠥꠁꠘ ꠛꠣꠖꠦꠅ ꠀꠞꠅ ꠌꠃꠖ꠆ꠖ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠝꠣꠘꠥꠡ ꠉꠎꠛꠤ ꠝꠢꠣꠝꠣꠞꠤꠄ ꠝꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU16_50","005_16_50","NUM","16","50","50","ꠝꠢꠣꠝꠣꠞꠤ ꠛꠘ꠆ꠖ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠢꠣꠞꠥꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠝꠥꠍꠣꠞ ꠗꠣꠞꠅ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU17_1","005_17_1","NUM","17","1","1","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU17_2","005_17_2","NUM","17","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠄꠇꠐꠣ ꠇꠞꠤ ꠝꠥꠐ ꠛꠣꠞꠅꠐꠣ ꠟꠣꠑꠤ ꠀꠘꠤꠀ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠖꠦꠄ। ꠖꠤꠟꠦ ꠔꠥꠝꠤ ꠎꠣꠞꠎꠤꠞ ꠟꠣꠑꠤꠞ ꠃꠙꠞꠦ ꠅꠃ ꠎꠘꠞ ꠘꠣꠝ ꠟꠦꠈꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU17_3","005_17_3","NUM","17","3","3","ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠣꠑꠤꠔ ꠟꠦꠈꠤꠅ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠘꠣꠝ, ꠅꠟꠣ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠝꠣꠚꠤꠇ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞꠞ ꠟꠣꠉꠤ ꠄꠇꠅꠐꠣ ꠟꠣꠑꠤ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("NU17_4","005_17_4","NUM","17","4","4","ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠍꠣꠝꠘꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠖꠦꠈꠣ ꠅꠄ, ꠅꠃ ꠟꠣꠑꠤꠉꠥꠁꠘ ꠢꠘꠅ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("NU17_5","005_17_5","NUM","17","5","5","ꠔꠦꠃ ꠀꠝꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣꠞ ꠟꠣꠑꠤꠞ ꠝꠣꠎꠦ ꠉꠣꠍꠞ ꠈꠦꠋ ꠚꠥꠐꠤꠛ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠦꠞ-ꠛꠦꠞꠤ ꠇꠞꠣ ꠀꠝꠤ ꠛꠘ꠆ꠖ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU17_6","005_17_6","NUM","17","6","6","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠝꠣꠚꠤꠇ ꠙꠞꠔꠦꠇ ꠡꠞ꠆ꠖꠣꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠄꠉꠥ ꠇꠞꠤ, ꠝꠥꠐ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠣꠞꠅꠐꠣ ꠟꠣꠑꠤ ꠀꠘꠤꠀ ꠖꠤꠟꠣ। ꠅꠃ ꠟꠣꠑꠤꠘ꠆ꠔꠞ ꠄꠉꠥ ꠟꠣꠑꠤ ꠀꠍꠤꠟ ꠢꠣꠞꠥꠘ ꠘꠛꠤꠞ। ");
INSERT INTO syls_vpl VALUES ("NU17_7","005_17_7","NUM","17","7","7","ꠝꠥꠍꠣꠄ ꠅꠃ ꠟꠣꠑꠤꠉꠥꠁꠘ ꠘꠤꠀ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU17_8","005_17_8","NUM","17","8","8","ꠛꠣꠖꠞ ꠖꠤꠘ ꠝꠥꠍꠣ ꠉꠤꠀ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠖꠦꠈꠂꠘ, ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠢꠣꠞꠥꠘꠞ ꠘꠣꠝꠦ ꠎꠦ ꠟꠣꠑꠤ ꠞꠣꠈꠣ ꠅꠁꠍꠦ, ꠁ ꠟꠣꠑꠤꠔ ꠈꠣꠟꠤ ꠈꠦꠋ ꠘꠣꠄ, ꠇꠥꠠꠤ ꠖꠤꠀ ꠚꠥꠟ ꠚꠥꠐꠤꠀ ꠛꠣꠖꠣꠝꠅ ꠗꠞꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU17_9","005_17_9","NUM","17","9","9","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠟꠣꠑꠤ ꠉꠥꠁꠘ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠟꠣ। ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠟꠣꠑꠤ ꠉꠥꠁꠘ ꠖꠦꠈꠟꠣ, ꠖꠦꠈꠤꠀ ꠎꠣꠞꠎꠤꠞ ꠟꠣꠑꠤ ꠌꠤꠘꠤꠀ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU17_10","005_17_10","NUM","17","10","10","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠛꠤꠞꠥꠗꠤ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠝꠘꠅ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠤ ꠢꠣꠞꠥꠘꠞ ꠟꠣꠑꠤꠐꠣ ꠢꠤꠞꠛꠣꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠍꠣꠝꠘꠦ ꠕꠅ। ꠔꠦꠃ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠣꠞꠣꠞ ꠛꠇꠛꠇ ꠇꠞꠣ ꠈꠣꠘ ꠔꠥꠝꠤ ꠛꠘ꠆ꠖ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠔꠣꠞꠣꠅ ꠀꠞ ꠝꠞꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU17_11","005_17_11","NUM","17","11","11","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠝꠥꠍꠣꠄ ꠑꠤꠇ ꠅꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU17_12","005_17_12","NUM","17","12","12","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠝꠞꠤꠎꠣꠁꠀꠞ, ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠀꠞ, ꠀꠝꠞꠣꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠅꠁꠎꠣꠞ! ");
INSERT INTO syls_vpl VALUES ("NU17_13","005_17_13","NUM","17","13","13","ꠎꠦꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠝꠣꠛꠥꠖꠞ ꠊꠞꠞ ꠗꠣꠞꠅ ꠉꠦꠟꠦꠃ ꠝꠞꠤꠎꠣꠞ, ꠔꠦ ꠀꠝꠞꠣ ꠢꠇꠟꠃ ꠝꠞꠤꠎꠤꠝꠥ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("NU18_1","005_18_1","NUM","18","1","1","ꠝꠣꠛꠥꠖꠦ ꠢꠣꠞꠥꠘ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, “ꠙꠛꠤꠔ꠆ꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠔ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠣ ꠅꠁꠛ, ꠄꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠛꠞ꠆ꠔꠤꠛ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ, ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ ꠀꠞ ꠔꠥꠝꠣꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠢꠇꠟꠞ ꠃꠙꠞꠦꠅ। ꠀꠞ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠛꠣꠟꠣ ꠎꠔ ꠟꠣꠈꠣꠘ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠣ ꠅꠁꠛ, ꠁꠔꠣꠞ ꠖꠣꠄꠁ ꠅꠁꠛꠣꠄ ꠈꠣꠟꠤ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU18_2","005_18_2","NUM","18","2","2","ꠔꠦ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠀꠞꠅ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠤ ꠀꠘꠅ। ꠔꠣꠞꠣ ꠀꠁꠀ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘꠞꠦ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠞ ꠄꠛꠣꠖꠔꠤ ꠇꠣꠝꠅ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ। ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠞꠁꠀ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥꠞ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU18_3","005_18_3","NUM","18","3","3","ꠅꠁꠟꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠇꠥꠘꠥ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡꠞ ꠗꠣꠞꠅ ꠎꠣꠅꠀ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠡꠦꠗ। ꠘꠤꠡꠦꠗ ꠘꠣ ꠝꠣꠘꠟꠦ ꠔꠣꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠃ ꠝꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU18_4","005_18_4","NUM","18","4","4","ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠇꠣꠝꠅ ꠡꠞꠤꠇ ꠅꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠣꠖꠤꠝꠖꠣꠞꠤ ꠇꠞꠛꠣ, ꠢꠇꠟ ꠎꠣꠔ ꠇꠣꠝꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠘꠤꠛꠣ। ꠔꠣ-ꠅ ꠈꠣꠟꠤ ꠟꠦꠛꠤ ꠅꠇꠟ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀ ꠘꠤꠡꠦꠗ। ");
INSERT INTO syls_vpl VALUES ("NU18_5","005_18_5","NUM","18","5","5","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠎꠣꠘꠥ ꠢꠤꠞꠛꠣꠞ ꠘꠣꠞꠣꠎ ꠘꠣ ꠅꠁ, ꠄꠞꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠖꠦꠈꠣ-ꠢꠥꠘꠣꠞ ꠜꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU18_6","005_18_6","NUM","18","6","6","ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠙꠢꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠞ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ। ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠞꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠡꠙꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU18_7","005_18_7","NUM","18","7","7","ꠅꠁꠟꠦ ꠁꠝꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠈꠣꠟꠤ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠙꠞ꠆ꠖꠣꠞ ꠜꠤꠔꠞꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠈꠦꠎꠝꠔ ꠇꠣꠝ ꠇꠞꠛꠣꠄ। ꠁꠝꠣꠝꠔꠤꠞ ꠙꠖ ꠈꠣꠘ ꠀꠝꠤ ꠃꠙꠢꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠟꠣꠝ। ꠈꠣꠟꠤ ꠟꠦꠛꠤ ꠅꠇꠟ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠀꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU18_8","005_18_8","NUM","18","8","8","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠄ, ꠁꠔꠣꠞ ꠢꠇꠟ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠤ ꠀꠝꠤ ꠘꠤꠎꠦꠃ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁꠍꠤ। ꠔꠦ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣ ꠢꠇꠟ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠙꠣꠅꠘꠣ ꠛꠦꠔꠘ ꠢꠤꠡꠣꠛꠦ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("NU18_9","005_18_9","NUM","18","9","9","ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠦ ꠅꠋꠡ ꠀꠉꠥꠁꠘꠅ ꠎꠣꠟꠣꠘꠤ ꠟꠣꠉꠔ ꠘꠣꠄ, ꠅꠃ ꠛꠣꠐꠅ ꠔꠥꠝꠞꠣ ꠘꠤꠅꠉꠤ। ꠔꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠖꠥꠡ-ꠇꠍꠥꠞꠤꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠎꠔꠔꠣ ꠟꠁꠀ ꠀꠁꠛꠣ, ꠁꠔꠣ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞ ꠙꠣꠅꠘꠣ ꠢꠇ। ");
INSERT INTO syls_vpl VALUES ("NU18_10","005_18_10","NUM","18","10","10","ꠁꠔꠣ ꠘꠤꠀ ꠢꠣꠞꠤ ꠈꠣꠍ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ ꠛꠥꠎꠤꠀ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ। ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠁꠔꠣ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠁ ꠈꠣꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("NU18_11","005_18_11","NUM","18","11","11","ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠅꠀ ꠢꠇꠟ ꠖꠥꠟꠘꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠤꠘꠤꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠅꠁꠛ। ꠁꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠙꠣꠅꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠞꠣꠝ। ꠔꠥꠝꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠎꠦꠞꠣ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠢꠣꠟꠔꠦ ꠞꠁꠛꠣ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU18_12","005_18_12","NUM","18","12","12","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠈꠦꠔꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠎꠦ ꠔꠦꠟ, ꠘꠄꠀ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠀꠞ ꠚꠡꠟꠞ ꠎꠦ ꠅꠋꠡ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠍꠖꠉꠣ ꠖꠤꠛꠣ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("NU18_13","005_18_13","NUM","18","13","13","ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠀꠘꠣ ꠔꠣꠞꠣꠞ ꠚꠟꠣꠁꠟ ꠚꠄ-ꠚꠡꠟꠞ ꠙꠄꠟꠣ ꠅꠋꠡ ꠔꠥꠝꠣꠞ ꠅꠁꠛ। ꠔꠥꠝꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠎꠞ ꠎꠦꠞꠣ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠢꠣꠟꠔꠦ ꠕꠣꠇꠛꠣ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU18_14","005_18_14","NUM","18","14","14","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠣꠛꠤ-ꠖꠣꠅꠀ ꠍꠣꠠꠤꠀ ꠝꠣꠘ꠆ꠘꠔ ꠢꠤꠡꠣꠛꠦ ꠎꠔ ꠎꠤꠘꠤꠡ ꠖꠤꠛꠣ, ꠁꠔꠣꠅ ꠔꠥꠝꠤ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU18_15","005_18_15","NUM","18","15","15","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠡꠙꠤ ꠖꠦꠅꠀ ꠙꠞꠔꠦꠇ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣ ꠔꠥꠝꠣꠞ ꠅꠁꠛ, ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠀꠅꠟꠣꠖ ꠅꠃꠇ ꠛꠣ ꠙꠡꠥꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠃꠇ। ꠝꠣꠘꠡꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠞꠦ ꠔꠥꠝꠤ ꠘꠤꠌ꠆ꠌꠄ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠘꠤꠔꠦ ꠖꠤꠅ, ꠀꠞ ꠘꠣꠙꠣꠇ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦꠅ ꠅꠟꠣ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠘꠤꠔꠦ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU18_16","005_18_16","NUM","18","16","16","ꠝꠣꠘꠡꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠞ ꠛꠄꠅꠡ ꠄꠇ ꠝꠣꠡ ꠅꠁꠟꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠘꠤꠞ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠛꠣꠛꠔ, ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠙꠦ ꠙꠣꠌ ꠔꠟꠣ ꠞꠥꠙꠣ ꠘꠤꠀ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU18_17","005_18_17","NUM","18","17","17","ꠅꠁꠟꠦ ꠉꠣꠁ-ꠉꠞꠥ ꠛꠣ ꠝꠦꠠꠣ-ꠍꠣꠉꠟꠞ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠁ ꠘꠤꠔꠦ ꠖꠤꠅ ꠘꠣ, ꠁꠉꠥꠁꠘ ꠔ ꠢꠣꠟꠣꠟ। ꠁꠔꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ ꠔꠥꠝꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠟꠃ ꠍꠤꠐꠣꠁꠀ ꠖꠤꠅ, ꠀꠞ ꠌꠞ꠆ꠛꠤꠞꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠎꠣꠟꠣꠁꠅ। ꠁ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("NU18_18","005_18_18","NUM","18","18","18","ꠖꠥꠟꠘꠣ ꠇꠞꠣꠁꠟ ꠍꠤꠘꠣ ꠀꠞ ꠒꠣꠁꠘꠞ ꠞꠣꠘꠞ ꠉꠥꠡ꠆ꠔꠞ ꠟꠣꠈꠣꠘ, ꠅꠉꠥꠁꠘ꠆ꠔꠞ ꠉꠥꠡ꠆ꠔꠅ ꠔꠥꠝꠤ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU18_19","005_18_19","NUM","18","19","19","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣ ꠢꠇꠟ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠛꠣꠛꠔ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠣꠁꠟꠣꠝ। ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠟꠉꠦ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠟꠣꠉꠤ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠌꠥꠇ꠆ꠔꠤ, ꠄꠞ ꠇꠥꠘꠥ ꠞꠖ-ꠛꠖꠟ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU18_20","005_18_20","NUM","18","20","20","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠗꠘ-ꠖꠃꠟꠔꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠛꠣ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠇꠥꠘꠥ ꠛꠣꠐꠅ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠛꠣꠐ ꠅꠁꠟꠣꠝ ꠡ꠆ꠛꠄꠅꠋ ꠀꠝꠤ, ꠀꠝꠤꠃ ꠔꠥꠝꠣꠞ ꠗꠘ-ꠖꠃꠟꠔ।” ");
INSERT INTO syls_vpl VALUES ("NU18_21","005_18_21","NUM","18","21","21","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠔ ꠀꠝꠣꠞꠦ ꠖꠤꠛꠣ, ꠀꠝꠤꠅ ꠁꠔꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠙꠣꠅꠘꠣ ꠛꠦꠔꠘ ꠛꠣꠛꠔ ꠖꠤꠟꠣꠁꠟꠣꠝ। ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠔ ꠄꠛꠣꠖꠔꠤ ꠇꠣꠝꠞ ꠝꠎꠥꠞꠤ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠞꠣ ꠁꠔꠣ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU18_22","005_18_22","NUM","18","22","22","ꠀꠞ ꠀꠁꠎ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠣꠘꠥꠡ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠗꠣꠞꠅ ꠎꠣꠅꠀ ꠘꠤꠡꠦꠗ। ꠉꠦꠟꠦ ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠖꠣꠄ ꠔꠣꠞꠣ ꠝꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU18_23","005_18_23","NUM","18","23","23","ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠈꠣꠟꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠇꠞꠛꠣ, ꠅꠃ ꠇꠣꠝꠅ ꠎꠦꠇꠥꠘꠥ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠟꠦ ꠔꠣꠞꠣ ꠘꠤꠎꠦꠃ ꠖꠣꠄꠁ ꠅꠁꠛꠣ। ꠁꠔꠣ ꠅꠁꠛ ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠄꠇꠐꠣ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠘꠤꠅꠝ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠗꠘ-ꠖꠃꠟꠔꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU18_24","005_18_24","NUM","18","24","24","ꠄꠞ ꠛꠖꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞꠞ ꠎꠦ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠇꠞꠛꠣ, ꠁꠔꠣ ꠀꠝꠤ ꠄꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠟꠣꠁꠟꠣꠝ। ꠄꠞꠟꠣꠉꠤ ꠄꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠍꠤ, ꠟꠦꠛꠤ ꠅꠇꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠙꠣꠁꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU18_25","005_18_25","NUM","18","25","25","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU18_26","005_18_26","NUM","18","26","26","“ꠔꠥꠝꠤ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠅ, ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞꠞ ꠎꠦ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠙꠣꠅꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠟꠣꠝ, ꠁꠔꠣ ꠙꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣꠅ ꠅꠔꠣꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐꠞꠦ, ꠎꠇꠣꠔꠞ ꠎꠇꠣꠔ ꠛꠣꠛꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠤꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU18_27","005_18_27","NUM","18","27","27","ꠅꠃ ꠎꠇꠣꠔꠞꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠡꠟꠞ ꠀꠞ ꠘꠤꠎꠞ ꠛꠣꠘꠣꠁꠟ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔꠞ ꠎꠇꠣꠔ ꠢꠤꠡꠣꠛꠦ ꠉꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU18_28","005_18_28","NUM","18","28","28","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠇꠤ ꠄꠉꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠇꠣꠔ ꠛꠣꠛꠔ ꠎꠦ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠛꠣꠄ, ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠇꠣꠔ ꠖꠤꠛꠣꠄ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠅꠃ ꠅꠋꠡ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠀꠔꠅ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU18_29","005_18_29","NUM","18","29","29","ꠔꠥꠝꠞꠣꠞꠦ ꠎꠔꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠔꠥꠝꠞꠣꠅ ꠅꠔꠣꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠀꠞ ꠙꠛꠤꠔ꠆ꠞ ꠅꠋꠡ, ꠝꠣꠛꠥꠖꠞ ꠙꠣꠅꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠘꠞꠦ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU18_30","005_18_30","NUM","18","30","30","“ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠅꠋꠡ ꠝꠣꠛꠥꠖꠞꠦ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠛꠣꠇꠤ ꠞꠁꠛ, ꠅꠔꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠈꠦꠔꠞ ꠚꠡꠟ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠛꠣꠘꠣꠁꠟ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠢꠤꠡꠣꠛꠦ ꠉꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU18_31","005_18_31","NUM","18","31","31","ꠅꠃ ꠅꠋꠡ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝꠞ ꠛꠦꠔꠘ, ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠦꠎꠝꠔꠞ ꠛꠦꠔꠘ। ");
INSERT INTO syls_vpl VALUES ("NU18_32","005_18_32","NUM","18","32","32","ꠢꠇꠟ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠅꠋꠡ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠤꠟꠣꠁꠟꠦ, ꠛꠣꠇꠤꠔꠣ ꠈꠣꠁꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠖꠥꠡ ꠘꠣꠁ। ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠅꠀ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠣꠟꠞꠦ ꠔꠥꠝꠞꠣ ꠅꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠝꠞꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU19_1","005_19_1","NUM","19","1","1","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU19_2","005_19_2","NUM","19","2","2","“ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠝꠣꠛꠥꠖꠦ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠟꠣꠟ ꠞꠋꠉꠞ ꠄꠉꠥ ꠒꠦꠇꠤ ꠉꠞꠥ ꠟꠁꠀ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠅ, ꠅꠃ ꠒꠦꠇꠤ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠘꠤꠈꠥꠔ ꠅꠁꠔ, ꠀꠞ ꠔꠣꠁꠞ ꠇꠣꠘ꠆ꠖꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠎꠥꠀꠟ ꠟꠣꠉꠣꠘꠤ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_3","005_19_3","NUM","19","3","3","ꠅꠉꠥ ꠀꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠞ ꠉꠦꠍꠦ ꠖꠤꠛꠣꠄ। ꠁꠝꠣꠝꠦ ꠁꠐꠣꠞꠦ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠎꠛ ꠇꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_4","005_19_4","NUM","19","4","4","ꠎꠛꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠀꠋꠉꠥꠟꠅ ꠇꠤꠍꠥ ꠟꠃ ꠟꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠣ ꠛꠣꠄ ꠡꠣꠔ ꠛꠣꠞ ꠍꠤꠐꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_5","005_19_5","NUM","19","5","5","ꠔꠣꠘ ꠍꠣꠝꠘꠦꠃ ꠅꠃ ꠉꠣꠁꠞ ꠈꠣꠟ, ꠉꠥꠡ꠆ꠔ, ꠟꠃ ꠀꠞ ꠉꠥꠚꠞ ꠡꠥꠖ꠆ꠖꠣ ꠀꠔ-ꠜꠠ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU19_6","005_19_6","NUM","19","6","6","ꠅꠃ ꠒꠦꠇꠤꠞꠦ ꠎꠣꠟꠣꠘꠤꠞ ꠡꠝꠄ ꠁꠝꠣꠝꠦ ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍꠞ ꠇꠤꠍꠥ ꠖꠣꠞꠥ, ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠒꠦꠐꠣ, ꠀꠞ ꠟꠣꠟ ꠞꠋꠉꠞ ꠇꠤꠍꠥ ꠡꠥꠔꠣꠞꠦ ꠅꠃ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎꠦ ꠚꠣꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_7","005_19_7","NUM","19","7","7","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠘꠣꠁꠛꠣ, ꠀꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠꠅ ꠗꠁꠛꠣ। ꠘꠣꠁꠀ-ꠗꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠎꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ, ꠅꠁꠟꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠁꠘ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_8","005_19_8","NUM","19","8","8","ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠒꠦꠇꠤꠞ ꠢꠇꠟꠔꠣ ꠎꠣꠟꠣꠁꠛ, ꠢꠦ-ꠅ ꠘꠣꠁꠀ ꠢꠣꠞꠤ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠛ ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU19_9","005_19_9","NUM","19","9","9","ꠅꠃ ꠒꠦꠇꠤꠞ ꠎꠣꠟꠣꠁꠟ ꠍꠣꠟꠤ ꠈꠣꠘꠣꠁꠘ ꠇꠥꠘꠥ ꠙꠣꠇ-ꠍꠣꠚ ꠝꠣꠘꠡꠦ ꠔꠥꠟꠤꠀ ꠘꠤꠀ, ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠇꠥꠘꠥ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠕꠁꠛ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠙꠣꠘꠤ ꠔꠤꠀꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠍꠣꠟꠤꠞꠦ ꠎꠔꠘꠦ ꠕꠁꠛꠣ। ꠛꠣꠖꠦ ꠘꠣꠙꠣꠇ ꠕꠣꠇꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠇꠣꠟꠅ ꠅꠃ ꠙꠣꠘꠤ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_10","005_19_10","NUM","19","10","10","ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠍꠣꠟꠤ ꠔꠥꠟꠛ, ꠢꠦ-ꠅ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠔꠦ ꠅꠁꠛ ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ꠁꠐꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠞ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠟꠣꠉꠤ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠘꠤꠅꠝ। ");
INSERT INTO syls_vpl VALUES ("NU19_11","005_19_11","NUM","19","11","11","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠡ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠡꠣꠔ ꠖꠤꠘ ꠜꠞꠣ ꠢꠦ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU19_12","005_19_12","NUM","19","12","12","ꠟꠣꠡ ꠍꠅꠀꠞ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠀꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ, ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠙꠛꠤꠔ꠆ꠞ ꠙꠣꠘꠤ ꠖꠤꠀ ꠘꠤꠎꠞꠦ ꠗꠁꠀ ꠢꠣꠞꠟꠦ ꠢꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛ। ꠀꠞ ꠁ ꠘꠤꠅꠝ ꠘꠣ ꠝꠣꠘꠟꠦ ꠢꠦ ꠘꠣꠙꠣꠇꠃ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU19_13","005_19_13","NUM","19","13","13","ꠟꠣꠡ ꠍꠅꠀꠞ ꠛꠣꠖꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠘꠣ ꠅꠄ, ꠔꠦ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠊꠞꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ। ꠅꠃ ꠎꠘꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠤꠛꠣꠄ। ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠙꠣꠘꠤ ꠔꠣꠞ ꠡꠞꠤꠟꠅ ꠘꠣ ꠍꠤꠐꠣꠘꠤꠄ, ꠔꠣꠞ ꠘꠣꠙꠣꠇꠤ ꠔꠣꠞ ꠟꠉꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU19_14","005_19_14","NUM","19","14","14","“ꠀꠞ ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠝꠞꠤꠉꠦꠟꠦ, ꠎꠦꠞꠣ ꠅꠃ ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠁꠛꠣ ꠀꠞ ꠎꠦꠞꠣ ꠔꠣꠝ꠆ꠛꠥꠔ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠢꠇꠟꠃ ꠡꠣꠔ ꠖꠤꠘ ꠜꠞꠣ ꠘꠣꠙꠣꠇ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_15","005_19_15","NUM","19","15","15","ꠅꠃ ꠛꠡꠔ ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠞ ꠎꠦꠔꠣ ꠕꠣꠟ-ꠛꠣꠡꠘ ꠢꠞꠣ ꠖꠤꠀ ꠉꠥꠞꠣ ꠀꠍꠤꠟ ꠘꠣ, ꠅꠔꠣꠅ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("NU19_16","005_19_16","NUM","19","16","16","“ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠈꠥꠟꠣ ꠎꠣꠉꠣꠔ ꠚꠣꠟꠣꠁꠟ ꠇꠥꠘꠥ ꠟꠣꠡꠞꠦ ꠎꠥꠖꠤ ꠇꠦꠃ ꠍꠁꠟꠣꠄ, ꠔꠦ ꠢꠦ ꠡꠣꠔ ꠖꠤꠘ ꠜꠞꠣ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ꠁ ꠟꠣꠡ ꠇꠥꠘꠥ ꠟꠣꠠꠣꠁꠞ ꠇꠣꠞꠘꠦ ꠅꠃꠇ, ꠛꠣ ꠄꠝꠘꠦ ꠝꠞꠣ ꠅꠃꠇ, ꠎꠦꠞꠣ ꠍꠁꠛ ꠄꠞꠣ ꠘꠣꠙꠣꠇ। ꠇꠥꠘꠥ ꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠀꠒ꠆ꠒꠤ ꠛꠣ ꠇꠄꠛꠞꠞꠦ ꠍꠁꠟꠦ, ꠢꠦ-ꠅ ꠡꠣꠔ ꠖꠤꠘ ꠜꠞꠣ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU19_17","005_19_17","NUM","19","17","17","“ꠅꠟꠣ ꠘꠣꠙꠣꠇ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠎꠦ ꠟꠣꠟ ꠒꠦꠇꠤꠞ ꠉꠥꠡ꠆ꠔ ꠎꠣꠟꠣꠘꠤ ꠅꠁꠍꠦ, ꠅꠉꠥꠞ ꠇꠤꠍꠥ ꠍꠣꠟꠤ ꠄꠇꠐꠣ ꠉꠣꠝꠟꠣꠔ ꠟꠁꠀ, ꠅꠃ ꠉꠣꠝꠟꠣꠔ ꠚꠥꠔꠞ ꠙꠣꠘꠤ ꠜꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU19_18","005_19_18","NUM","19","18","18","ꠛꠣꠖꠦ ꠇꠥꠘꠥ ꠙꠣꠇ-ꠍꠣꠚ ꠝꠣꠘꠡꠦ ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠇꠄꠐꠣ ꠒꠦꠐꠣ ꠀꠘꠤꠀ ꠙꠣꠘꠤꠔ ꠛꠥꠠꠣꠁꠀ ꠢꠃ ꠝꠥꠞ꠆ꠖꠣꠞ ꠔꠣꠝ꠆ꠛꠥ, ꠄꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠀꠞ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ꠎꠔ ꠎꠘꠦ ꠄꠝꠘꠦ ꠝꠞꠣ, ꠛꠣ ꠈꠥꠘ ꠅꠁꠀ ꠝꠞꠣ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠡ, ꠝꠞꠣꠞ ꠀꠒ꠆ꠒꠤ-ꠉꠥꠒ꠆ꠒꠤ ꠛꠣ ꠇꠄꠛꠞ ꠍꠁꠍꠦ, ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦꠅ ꠅꠃ ꠙꠣꠘꠤ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_19","005_19_19","NUM","19","19","19","ꠙꠣꠇ-ꠍꠣꠚ ꠅꠃ ꠎꠘꠦ ꠘꠣꠙꠣꠇ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠢꠣꠙ꠆ꠔꠣꠞ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠀꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠙꠣꠘꠤ ꠍꠤꠐꠣꠁ ꠖꠤꠛꠣ, ꠀꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠔꠣꠞꠣ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛꠣ। ꠔꠣꠞꠣ ꠉꠥꠍꠟ ꠇꠞꠤꠀ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠛꠣ, ꠀꠞ ꠅꠃ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠕꠣꠇꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU19_20","005_19_20","NUM","19","20","20","ꠅꠁꠟꠦ ꠘꠣꠙꠣꠇ ꠅꠀꠞ ꠛꠣꠖꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠛꠣꠄ। ꠢꠦ ꠘꠤꠎꠞꠦ ꠘꠣꠙꠣꠇ ꠞꠣꠈꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞꠦꠅ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠍꠦ। ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠙꠣꠘꠤ ꠔꠣꠞ ꠃꠙꠞꠦ ꠘꠣ ꠍꠤꠐꠣꠘꠤꠄ, ꠢꠦ ꠘꠣꠙꠣꠇ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU19_21","005_19_21","NUM","19","21","21","ꠁꠔꠣ ꠅꠁꠛ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠘꠤꠅꠝ। “ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠙꠣꠘꠤ ꠍꠤꠐꠣꠁꠛꠣ, ꠄꠁꠘ ꠘꠤꠎꠦꠅ ꠔꠣꠘ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠔꠦ ꠅꠁꠛ। ꠁ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠙꠣꠘꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠍꠁꠟꠦ, ꠢꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU19_22","005_19_22","NUM","19","22","22","ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠁ ꠎꠘꠦ ꠎꠔꠔꠣ ꠍꠁꠛ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠤꠛ, ꠔꠣꠞ ꠍꠅꠀ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠎꠦꠉꠤꠄ ꠍꠁꠛ, ꠢꠦ-ꠅ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠙꠣꠇ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU20_1","005_20_1","NUM","20","1","1","ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠅ ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠤꠘ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠤꠀ ꠇꠣꠖꠦꠡ ꠄꠟꠣꠇꠣꠔ ꠀꠁꠀ ꠞꠁꠟꠣ। ꠢꠘꠅ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠛꠁꠘ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠞ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠅꠁꠟ ꠀꠞ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU20_2","005_20_2","NUM","20","2","2","ꠢꠤꠘꠅ ꠈꠣꠁꠛꠣꠞ ꠇꠥꠘꠥ ꠙꠣꠘꠤ ꠘꠣ ꠙꠣꠅꠀꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠖꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠄꠞꠣꠞ ꠙꠤꠍꠦ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU20_3","005_20_3","NUM","20","3","3","ꠔꠣꠞꠣ ꠝꠥꠍꠣꠞ ꠟꠉꠦ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠟꠉꠞ ꠜꠣꠁꠀꠁꠘ ꠎꠦꠛꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠝꠞꠍꠟꠣ, ꠢꠃ ꠡꠝꠄ ꠀꠝꠞꠣꠅ ꠝꠞꠤꠉꠦꠟꠦ ꠜꠣꠟꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU20_4","005_20_4","NUM","20","4","4","ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠘꠟꠣꠄ, ꠅꠈꠘ ꠙꠡꠥꠞ ꠙꠣꠟ ꠡꠥꠖ꠆ꠖꠣ ꠀꠝꠞꠣ ꠢꠇ꠆ꠇꠟꠦ ꠅꠘꠅ ꠎꠣꠘ ꠈꠥꠀꠁꠔꠣꠝ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("NU20_5","005_20_5","NUM","20","5","5","ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠎꠝꠞ ꠉꠣꠔꠅ ꠟꠁꠀ ꠀꠁꠟꠣꠄ? ꠁ ꠎꠣꠉꠣꠔ ꠘꠣ ꠀꠍꠦ ꠇꠥꠘꠥ ꠗꠣꠘ-ꠌꠣꠃꠟ ꠛꠣ ꠒꠥꠝꠥꠞ ꠚꠟ, ꠘꠣ ꠀꠍꠦ ꠀꠋꠉꠥꠞ ꠛꠣ ꠀꠘꠥꠀꠞ ꠚꠟ? ꠀꠞ ꠈꠣꠁꠛꠣꠞ ꠙꠣꠘꠤꠅ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("NU20_6","005_20_6","NUM","20","6","6","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠟꠣ। ꠔꠦꠃ ꠝꠣꠛꠥꠖꠞ ꠘꠥꠞꠞ ꠔꠎꠟ꠆ꠟꠤ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠁꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU20_7","005_20_7","NUM","20","7","7","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU20_8","005_20_8","NUM","20","8","8","“ꠔꠥꠝꠤ ꠢꠃ ꠟꠣꠑꠤꠐꠣ ꠟꠅ, ꠟꠁꠀ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘꠦ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠅ। ꠀꠞ ꠅꠃ ꠛꠠ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠉꠥ ꠖꠦꠈꠞꠣꠄ, ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠅ, ꠖꠤꠟꠦ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠦ ꠙꠣꠘꠤ ꠖꠤꠛ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠡꠥꠙꠣꠟ ꠢꠇꠟꠦ ꠎꠣꠔꠦ ꠙꠣꠘꠤ ꠈꠣꠁꠔ ꠙꠣꠞꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠛꠣꠞ ꠇꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU20_9","005_20_9","NUM","20","9","9","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠔ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠝꠥꠍꠣꠄ ꠟꠣꠑꠤꠐꠣ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU20_10","005_20_10","NUM","20","10","10","ꠟꠁꠀ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠦ ꠝꠣꠘꠡꠞꠦ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠉꠦꠍꠦ ꠖꠟꠣ ꠇꠞꠟꠣ। ꠀꠞ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠦꠁꠝꠣꠘꠞ ꠎꠣꠔ, ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠘꠤ ꠛꠣꠞ ꠇꠞꠔꠣꠝ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("NU20_11","005_20_11","NUM","20","11","11","ꠅꠈꠣꠘ ꠇꠁꠀ ꠝꠥꠍꠣꠄ ꠟꠣꠑꠤ ꠖꠤꠀ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠅ ꠖꠥꠁ ꠛꠣꠠꠤ ꠝꠣꠞꠟꠣ, ꠛꠣꠠꠤ ꠝꠣꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠙꠣꠔ꠆ꠔꠞ ꠕꠣꠇꠤ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠟ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠦ ꠙꠣꠘꠤ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU20_12","005_20_12","NUM","20","12","12","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠝꠣꠘꠟꠣꠄ ꠘꠣ, ꠀꠝꠣꠞ ꠎꠛꠣꠘꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠟꠣꠄ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠣꠘ ꠇꠞꠝꠥ, ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠢꠤꠘꠅ ꠎꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU20_13","005_20_13","NUM","20","13","13","ꠙꠣꠔ꠆ꠔꠞ ꠕꠣꠇꠤ ꠎꠦ ꠎꠣꠉꠣꠔ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠟ, ꠅꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠖꠦꠅꠀ ꠅꠁꠟ ꠝꠦꠞꠤꠛꠣ, ꠝꠣꠘꠤ ꠇꠣꠁꠎ꠆ꠎꠣ। ꠁꠘꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠟꠉꠦ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠍꠤꠟ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠅꠘꠅꠃ ꠔꠣꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞꠔꠣ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU20_14","005_20_14","NUM","20","14","14","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠇꠣꠖꠦꠡ ꠕꠣꠇꠤ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠁꠀ ꠁꠖꠥꠝ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠀꠙꠘꠣꠞ ꠍꠤꠟꠍꠤꠟꠣꠞ ꠜꠣꠁꠀꠁꠘ। ꠀꠙꠘꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣꠞ ꠄꠇꠈꠣꠘ ꠀꠞꠎꠤ ꠀꠍꠦ, ꠀꠙꠘꠦ ꠔ ꠀꠝꠞꠣꠞ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠇꠕꠣ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU20_15","005_20_15","NUM","20","15","15","ꠔꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ ꠔ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠦꠍꠟꠣ, ꠀꠞ ꠀꠝꠞꠣ ꠛꠃꠔ ꠛꠍꠞ ꠢꠘꠅ ꠀꠍꠟꠣꠝ। ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠀꠝꠞꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠇꠞꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU20_16","005_20_16","NUM","20","16","16","ꠀꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠟꠣꠝ। ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞ ꠚꠞꠤꠀꠖ ꠇꠛꠥꠟ ꠇꠞꠤꠀ, ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠙꠣꠑꠣꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠢꠃ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। “ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠅꠈꠘ ꠀꠙꠘꠣꠞ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠇꠣꠖꠦꠡ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU20_17","005_20_17","NUM","20","17","17","ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠀꠙꠘꠣꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠖꠤ ꠎꠣꠁꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠈꠣꠘ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠔ-ꠇꠤꠡꠤ ꠛꠣ ꠀꠋꠉꠥꠞ ꠛꠣꠉꠣꠘꠞ ꠝꠣꠎꠦꠖꠤ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ, ꠇꠥꠘꠥ ꠇꠥꠀ ꠕꠣꠇꠤ ꠙꠣꠘꠤꠅ ꠔꠥꠟꠤꠀ ꠈꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠞꠣꠎ ꠙꠕꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠝꠥ, ꠀꠙꠘꠣꠞ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣ ꠙꠣꠞꠘꠤꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠇꠥꠘꠥꠛꠣꠄ ꠙꠣꠅ ꠛꠣꠠꠣꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU20_18","005_20_18","NUM","20","18","18","ꠅꠁꠟꠦ ꠁꠖꠥꠝꠞ ꠛꠣꠖꠡꠣꠄ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠔꠥꠝꠞꠣ ꠁꠛꠣꠄ ꠎꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ꠎꠣꠁꠛꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠟꠦ ꠀꠝꠞꠣ ꠎꠥꠖ꠆ꠖꠔ ꠛꠣꠞ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU20_19","005_20_19","NUM","20","19","19","ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠈꠣꠟꠤ ꠞꠣꠎ ꠙꠕꠦꠖꠤ ꠎꠣꠁꠝꠥ। ꠀꠝꠞꠣ ꠛꠣ ꠀꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠦ ꠎꠥꠖꠤ ꠀꠙꠘꠣꠞ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠙꠣꠘꠤ ꠈꠣꠁ, ꠔꠦ ꠁꠔꠣꠞ ꠖꠣꠝ ꠖꠤꠟꠣꠁꠝꠥ। ꠀꠝꠞꠣ ꠙꠣꠅꠄ ꠀꠐꠤꠀ ꠈꠣꠟꠤ ꠖꠦꠡ ꠙꠣꠠꠤ ꠖꠤꠀ ꠎꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("NU20_20","005_20_20","NUM","20","20","20","ꠅꠁꠟꠦ ꠁꠖꠥꠝ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟ, “ꠘꠣ, ꠘꠣ, ꠁꠛꠣꠄꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠅꠀ ꠘꠤꠡꠦꠗ।” ꠛꠣꠖꠦ ꠁꠖꠥꠝ ꠖꠦꠡꠞ ꠛꠃꠔ ꠍꠤꠙꠣꠁꠄ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠔ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU20_21","005_20_21","NUM","20","21","21","ꠔꠣꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠎꠣꠁꠔꠦ ꠖꠤꠟ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠄꠞꠣ ꠢꠇꠟ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU20_22","005_20_22","NUM","20","22","22","ꠄꠞꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠇꠣꠖꠦꠡ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠢꠥꠞ ꠙꠣꠠꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠀꠎꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU20_23","005_20_23","NUM","20","23","23","ꠢꠤꠘꠅ ꠁꠖꠥꠝ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠗꠣꠞꠅ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU20_24","005_20_24","NUM","20","24","24","“ꠢꠣꠞꠥꠘ ꠔ ꠔꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠇꠄꠛꠞꠅ ꠎꠣꠁꠔꠦꠉꠤ ꠅꠁꠛ। ꠀꠞ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠝꠥ, ꠢꠦ ꠔ ꠢꠤ ꠖꠦꠡꠅ ꠎꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠝꠘꠅ ꠀꠍꠦ ꠘꠤ, ꠝꠦꠞꠤꠛꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠙꠣꠘꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠇꠣꠝ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("NU20_25","005_20_25","NUM","20","25","25","ꠔꠦ ꠢꠣꠞꠥꠘ ꠀꠞ ꠔꠣꠞ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞꠞꠦ ꠟꠁꠀ ꠔꠥꠝꠤ ꠢꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠅ। ");
INSERT INTO syls_vpl VALUES ("NU20_26","005_20_26","NUM","20","26","26","ꠃꠑꠤꠀ ꠢꠣꠞꠥꠘꠞ ꠉꠔꠞ ꠕꠣꠇꠤ ꠁꠝꠣꠝꠔꠤ ꠟꠦꠛꠣꠍ ꠈꠥꠟꠤꠀ ꠔꠣꠞ ꠙꠥꠀꠞꠦ ꠚꠤꠘ꠆ꠖꠣꠅ, ꠇꠣꠞꠘ ꠢꠣꠞꠥꠘ ꠔꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛꠉꠤ, ꠢꠘꠅꠃ ꠔꠣꠞ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU20_27","005_20_27","NUM","20","27","27","ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠅꠟꠣ ꠇꠞꠟꠣ। ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠣ ꠢꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU20_28","005_20_28","NUM","20","28","28","ꠃꠑꠣꠞ ꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠢꠣꠞꠥꠘꠞ ꠁꠝꠣꠝꠔꠤ ꠟꠦꠛꠣꠍ ꠈꠥꠟꠤꠀ ꠢꠣꠞꠤ ꠄꠘ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞꠞꠦ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ। ꠢꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠢꠣꠞꠥꠘꠦ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ। ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠀꠟꠤ-ꠀꠎꠞ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU20_29","005_20_29","NUM","20","29","29","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠢꠣꠞꠥꠘꠞ ꠝꠃꠔꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠙꠥꠞꠣ ꠔꠤꠡ ꠖꠤꠘ ꠔꠣꠘ ꠟꠣꠉꠤ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_1","005_21_1","NUM","21","1","1","ꠀꠞ ꠇꠦꠘꠣꠘꠤ ꠎꠣꠔꠤꠞ ꠅꠞꠣꠖ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣ ꠘꠦꠉꠦꠜ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠄꠁꠘ ꠈꠛꠞ ꠙꠣꠁꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠅꠕꠣꠞꠤꠝꠞ ꠙꠕꠦꠖꠤ ꠀꠐꠤꠀ ꠀꠁꠞꠣ, ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠤꠀ ꠇꠄꠎꠘꠞꠦ ꠗꠞꠤꠀ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("NU21_2","005_21_2","NUM","21","2","2","ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠝꠣꠘ꠆ꠘꠔ ꠝꠣꠘꠤꠀ ꠇꠁꠟ, “ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠅꠞꠣꠖꠞ ꠅꠃ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠀꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠦꠅ, ꠔꠦ ꠀꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠀꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU21_3","005_21_3","NUM","21","3","3","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞ ꠝꠤꠘꠔꠤ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠀꠞ ꠅꠘꠞ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠞꠦ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠞꠦ ꠀꠞ ꠄꠞꠣꠞ ꠐꠣꠃꠘ ꠅꠇꠟꠞꠦ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟ꠆ꠟ। ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠢꠞ꠆ꠝꠣ, ꠝꠣꠘꠤ ꠛꠤꠘꠣꠡ। ");
INSERT INTO syls_vpl VALUES ("NU21_4","005_21_4","NUM","21","4","4","ꠄꠞꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠁꠖꠥꠝ ꠖꠦꠡꠞ ꠉꠣꠟꠣꠛꠣꠄ ꠊꠥꠞꠤꠀ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠥꠞ ꠙꠣꠠꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠘꠤꠟ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠦꠖꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠅꠁꠟꠦ ꠙꠕꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣ ꠅꠗꠂꠞ꠆ꠎ ꠅꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("NU21_5","005_21_5","NUM","21","5","5","ꠝꠥꠍꠣ ꠘꠛꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠟꠣꠉꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠇꠦꠘꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣꠄ, ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠘꠤꠀ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤ? ꠁꠘꠅ ꠔ ꠈꠣꠘꠤꠅ ꠘꠣꠁ, ꠙꠣꠘꠤꠅ ꠘꠣꠁ। ꠀꠞ ꠅꠟꠣ ꠛꠣꠎꠦ ꠈꠣꠘꠤ ꠀꠝꠞꠣ ꠖꠥꠁ ꠌꠃꠈꠦ ꠖꠦꠈꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU21_6","005_21_6","NUM","21","6","6","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠛꠤꠡꠣꠇ꠆ꠔ ꠢꠣꠚ ꠙꠣꠑꠣꠁꠟꠣ। ꠢꠣꠚꠞ ꠇꠣꠝꠠꠦ ꠔꠣꠞꠣꠞ ꠛꠃꠔ ꠎꠘ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_7","005_21_7","NUM","21","7","7","ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠉꠤꠀ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠀꠙꠘꠣꠞ ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠔꠤꠀ ꠉꠥꠘꠣ ꠇꠞꠤꠟꠤꠍꠤ। ꠔꠦ ꠀꠙꠘꠦ ꠅꠈꠘ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠝꠤꠘꠔꠤ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠅꠃ ꠢꠣꠚ ꠉꠥꠁꠘ ꠀꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠘꠦꠁꠘꠉꠤ।” ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_8","005_21_8","NUM","21","8","8","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠄꠇꠐꠣ ꠢꠣꠚ ꠛꠣꠘꠣꠁꠀ ꠃꠌꠣ ꠄꠇ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠕꠅ। ꠎꠦ ꠝꠣꠘꠡꠞꠦ ꠢꠣꠚꠦ ꠇꠣꠝꠠꠣꠁꠛ, ꠢꠦ ꠔꠥꠝꠣꠞ ꠅꠃ ꠢꠣꠚꠞ ꠛꠣꠄ ꠌꠣꠁꠟꠦ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU21_9","005_21_9","NUM","21","9","9","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠈꠣꠐꠤ ꠔꠣꠝꠣꠖꠤ ꠄꠇ ꠢꠣꠚ ꠛꠣꠘꠣꠁꠀ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠕꠁꠟꠣ। ꠇꠥꠘꠥ ꠎꠘꠞꠦ ꠢꠣꠚꠦ ꠇꠣꠝꠠꠣꠁꠟꠦ ꠢꠦ ꠅꠃ ꠔꠣꠝꠣꠞ ꠢꠣꠚꠞ ꠛꠣꠄ ꠌꠣꠁꠔ, ꠀꠞ ꠛꠣꠌꠤꠎꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("NU21_10","005_21_10","NUM","21","10","10","ꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠀꠞ ꠅꠛꠥꠔ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_11","005_21_11","NUM","21","11","11","ꠀꠞ ꠅꠛꠥꠔ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠙꠥꠛꠞ ꠡꠤꠝꠣꠘꠣꠔ, ꠝꠞꠥꠜꠥꠝꠤꠞ ꠁꠀ-ꠀꠛꠣꠞꠤꠝꠅ ꠀꠁꠀ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_12","005_21_12","NUM","21","12","12","ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠎꠦꠞꠦꠖ ꠘꠣꠝꠞ ꠢꠥꠇꠘꠣ ꠈꠣꠟꠞ ꠙꠣꠞꠅ ꠉꠤꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_13","005_21_13","NUM","21","13","13","ꠎꠦꠞꠦꠖ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠀ ꠅꠞꠘꠘ ꠢꠥꠇꠘꠣ ꠈꠣꠟꠞ ꠢꠙꠣꠞꠅ ꠉꠤꠀ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠘꠣꠁꠟꠣ। ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠕꠣꠇꠤ ꠎꠦ ꠝꠞꠥꠜꠥꠝꠤ ꠡꠥꠞꠥ ꠅꠁꠍꠦ, ꠁ ꠈꠣꠟ ꠀꠍꠤꠟ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ। ꠈꠣꠟꠞ ꠄꠇ ꠙꠣꠞꠅ ꠝꠥꠀꠛ ꠖꠦꠡ, ꠅꠁꠘ꠆ꠘ ꠙꠣꠞꠅ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠖꠦꠡ। ");
INSERT INTO syls_vpl VALUES ("NU21_14","005_21_14","NUM","21","14","14","ꠝꠣꠛꠥꠖꠞ ꠎꠤꠢꠣꠖ ꠘꠣꠝꠞ ꠇꠤꠔꠣꠛꠅ ꠔ ꠀꠍꠦ, “ꠡꠥꠚꠣ ꠄꠟꠣꠇꠣꠞ ꠛꠣꠢꠦꠛ ꠀꠞ ꠅꠞꠘꠘ ꠢꠥꠇꠘꠣ ꠈꠣꠟ, ");
INSERT INTO syls_vpl VALUES ("NU21_15","005_21_15","NUM","21","15","15","ꠀꠃꠞ ꠐꠣꠃꠘꠞ ꠝꠥꠈꠣ ꠎꠣꠅꠞꠣ ꠃꠌꠣ-ꠘꠤꠌꠣ ꠘꠣꠟ, ꠁꠔꠣ ꠔ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠄꠇ ꠡꠤꠝꠣꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU21_16","005_21_16","NUM","21","16","16","ꠅꠈꠣꠘ ꠕꠘꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠔꠣꠞꠣ ꠛꠦꠞ ꠘꠣꠝꠞ ꠄꠇ ꠇꠥꠀꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠅꠘꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠅ, ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠘꠤ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU21_17","005_21_17","NUM","21","17","17","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠃ ꠉꠎꠟ ꠉꠣꠁꠟ, “ꠅ ꠇꠥꠀ, ꠔꠥꠝꠣꠞ ꠙꠣꠘꠤ ꠃꠕꠟꠤꠀ ꠙꠠꠃꠇ। ꠔꠥꠝꠞꠣ ꠇꠥꠀꠞ ꠈꠣꠔꠤꠞꠦ ꠉꠎꠟ ꠉꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("NU21_18","005_21_18","NUM","21","18","18","ꠁꠇꠐꠣ ꠔ ꠢꠃ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞ ꠇꠥꠀ, ꠞꠣꠎꠣ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠑꠤꠞ ꠛꠟꠦ ꠈꠥꠖꠤꠍꠂꠘ, ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠉꠟ꠆ꠟꠣꠞ ꠎꠥꠞꠦ ꠇꠞꠍꠂꠘ।” ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠝꠔ꠆ꠔꠣꠘꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_19","005_21_19","NUM","21","19","19","ꠝꠔ꠆ꠔꠣꠘꠣ ꠕꠣꠇꠤ ꠘꠢꠟꠤꠄꠟ, ꠘꠢꠟꠤꠄꠟ ꠕꠣꠇꠤ ꠛꠣꠝꠥꠔ, ");
INSERT INTO syls_vpl VALUES ("NU21_20","005_21_20","NUM","21","20","20","ꠛꠣꠝꠥꠔ ꠕꠣꠇꠤ ꠝꠥꠀꠛꠞ ꠙꠣꠠꠤꠀ ꠄꠇ ꠈꠣꠟꠞ ꠙꠣꠞꠅ ꠉꠦꠟꠣ। ꠅꠃ ꠈꠣꠟꠞ ꠇꠣꠘ꠆ꠖꠣꠞ ꠙꠤꠍꠉꠣ ꠙꠣꠠꠞ ꠃꠌꠣ ꠐꠤꠟ꠆ꠟꠣ ꠕꠣꠇꠤ ꠝꠞꠥꠜꠥꠝꠤ ꠖꠦꠈꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU21_21","005_21_21","NUM","21","21","21","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞ ꠉꠦꠍꠦ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠁꠀ ꠝꠤꠘꠔ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU21_22","005_21_22","NUM","21","22","22","“ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠙꠣꠞ ꠅꠁ ꠎꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠀꠝꠞꠣꠞꠦ ꠎꠣꠁꠛꠣꠞ ꠖꠤꠛꠣ ꠘꠤ? ꠀꠝꠞꠣ ꠔ ꠞꠣꠎ ꠙꠕ ꠍꠣꠠꠤꠀ ꠈꠦꠔ-ꠇꠤꠡꠤ ꠛꠣꠄ ꠛꠣ ꠀꠋꠉꠥꠞ ꠛꠣꠉꠣꠘꠦꠖꠤ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ, ꠇꠥꠘꠥ ꠇꠥꠀꠞ ꠙꠣꠘꠤꠅ ꠈꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠀꠙꠘꠣꠞ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣ ꠙꠣꠞꠘꠤꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠣꠝꠦꠡꠣ ꠞꠣꠎ ꠙꠕꠦꠖꠤ ꠀꠐꠣꠔ ꠞꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU21_23","005_21_23","NUM","21","23","23","ꠅꠁꠟꠦ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠦ ꠔꠣꠘ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠖꠤꠟꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠔꠣꠘ ꠍꠤꠙꠣꠁ ꠖꠟ ꠟꠁꠀ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖꠔ ꠛꠣꠞ ꠅꠁꠟꠣ। ꠔꠣꠁꠘ ꠁꠀꠢꠣꠎ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_24","005_21_24","NUM","21","24","24","ꠎꠥꠖ꠆ꠖꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠢꠃ ꠛꠣꠖꠡꠣꠞꠦ ꠔꠟꠥꠀꠞꠖꠤ ꠇꠣꠐꠤꠀ ꠅꠞꠘꠘ ꠈꠣꠟ ꠕꠣꠇꠤ ꠎꠣꠛ꠆ꠛꠥꠇ ꠈꠣꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠤꠟꠤꠟꠣ। ꠔꠣꠞꠣ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘꠞ ꠡꠤꠝꠣꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇꠟ ꠎꠣꠉꠣ ꠖꠈꠟ ꠇꠞꠟꠣ, ꠅꠁꠟꠦ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘꠞ ꠡꠤꠝꠣꠘꠣ ꠀꠍꠤꠟ ꠈꠥꠛ ꠝꠎꠛꠥꠔ, ꠁꠈꠣꠘꠞꠦ ꠒꠤꠋꠉꠣꠁꠀ ꠎꠣꠅꠀ ꠇꠑꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("NU21_25","005_21_25","NUM","21","25","25","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠢꠤꠡꠛꠘ ꠀꠞ ꠄꠞ ꠀꠡ-ꠙꠣꠡꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠡꠥꠖ꠆ꠖꠣ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠢꠇꠟ ꠐꠣꠃꠘ ꠖꠈꠟ ꠇꠞꠤꠀ ꠢꠘꠅ ꠛꠡꠔꠤ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_26","005_21_26","NUM","21","26","26","ꠢꠤꠡꠛꠘ ꠀꠍꠤꠟ ꠔ ꠀꠝꠥꠞꠤ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞ ꠞꠣꠎꠗꠣꠘꠤ। ꠔꠣꠁꠘ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠀꠉꠞ ꠛꠣꠖꠡꠣꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠤꠀ ꠅꠞꠘꠘ ꠈꠣꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠍꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_27","005_21_27","NUM","21","27","27","ꠄꠞꠟꠣꠉꠤ ꠇꠛꠤ ꠅꠇꠟꠦ ꠇꠂꠘ, “ꠀꠅ ꠔꠥꠝꠞꠣ ꠢꠇꠟ, ꠢꠤꠡꠛꠘ ꠐꠣꠃꠘꠅ ꠀꠅ, ꠞꠣꠎꠣ ꠍꠤꠢꠥꠘꠞ ꠐꠣꠃꠘꠞꠦ ꠘꠄꠀ ꠇꠞꠤ ꠛꠣꠘꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("NU21_28","005_21_28","NUM","21","28","28","ꠍꠤꠢꠥꠘꠞ ꠅꠃ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠀꠉꠥꠁꠘ ꠛꠣꠞ ꠅꠁꠀ, ꠝꠥꠀꠛꠞ ꠀꠃꠞ ꠐꠣꠃꠘꠞꠦ ꠍꠣꠞꠈꠣꠞ ꠇꠞꠟ ꠎꠣꠟꠣꠁꠀ, ꠅꠞꠘꠘ ꠈꠣꠟꠞ ꠃꠌꠣ ꠎꠣꠉꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ, ꠢꠘꠞ ꠢꠇꠟ ꠑꠣꠇꠥꠞꠞꠦ ꠎꠣꠟꠣꠁꠀ ꠝꠣꠔꠤꠟ꠆ꠟ। ");
INSERT INTO syls_vpl VALUES ("NU21_29","005_21_29","NUM","21","29","29","ꠢꠣꠄꠞꠦ ꠝꠥꠀꠛ, ꠡꠞ꠆ꠛꠘꠣꠡ! ꠅ ꠇꠝꠥꠡ-ꠖꠦꠛꠔꠣꠞ ꠜꠇ꠆ꠔ ꠅꠇꠟ ꠔꠥꠝꠞꠣ ꠔ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟꠣꠄ। ꠇꠝꠥꠡꠞ ꠙꠥꠀꠂꠘ ꠜꠣꠉꠤꠀ ꠢꠞꠤꠉꠦꠍꠦ, ꠔꠣꠞ ꠙꠥꠠꠤꠘ ꠅꠇꠟ ꠛꠘ꠆ꠖꠤ ꠅꠁꠍꠦ, ꠀꠝꠥꠞꠤ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞ ꠀꠔꠅ ꠛꠘ꠆ꠖꠤ ꠔꠣꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_30","005_21_30","NUM","21","30","30","ꠀꠝꠞꠣꠃ ꠔ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠍꠤ, ꠖꠤꠛꠣꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠡ꠆ꠔꠣ ꠢꠤꠡꠛꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠤ, ꠔꠣꠞꠣꠞ ꠛꠣꠔ꠆ꠔꠤ ꠀꠝꠞꠣ ꠘꠤꠜꠣꠁꠟꠤꠍꠤ, ꠘꠥꠚꠣ ꠀꠞ ꠝꠤꠖꠦꠛꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠗꠋꠡ-ꠟꠤꠟꠣ ꠌꠣꠟꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU21_31","005_21_31","NUM","21","31","31","ꠄꠞꠛꠣꠖ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠛꠡꠔ ꠇꠞꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_32","005_21_32","NUM","21","32","32","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠎꠣꠎꠤꠞꠣ ꠐꠣꠃꠘꠅ ꠉꠥꠁꠀ ꠙꠣꠑꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠃ ꠐꠣꠃꠘꠞ ꠀꠡ-ꠙꠣꠡꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠢꠇꠟꠔꠣ ꠖꠈꠟ ꠇꠞꠟꠣ, ꠀꠞ ꠢꠘꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU21_33","005_21_33","NUM","21","33","33","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠚꠤꠞꠤꠀ ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ꠔꠦꠃ ꠛꠣꠡꠘꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠦ ꠔꠣꠞ ꠢꠇꠟ ꠍꠤꠙꠣꠁ ꠟꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠖꠞꠤ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠀꠎꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU21_34","005_21_34","NUM","21","34","34","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠛꠣꠖꠡꠣ ꠃꠎꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠀꠝꠤ ꠔꠣꠞꠦ, ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞꠦ ꠀꠞ ꠢꠇꠟ ꠍꠤꠙꠣꠁꠞꠦ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠔꠥꠟꠤ ꠖꠤꠍꠤ। ꠄꠞꠟꠣꠉꠤ ꠢꠤꠡꠛꠘꠞ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞꠦ ꠔꠥꠝꠤ ꠎꠦ ꠖꠡꠣ ꠊꠐꠣꠁꠍꠟꠣꠄ, ꠅꠉꠥꠞꠦꠅ ꠅꠟꠣ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU21_35","005_21_35","NUM","21","35","35","ꠔꠦꠃ ꠔꠣꠞꠣ ꠛꠣꠖꠡꠣ ꠃꠎ, ꠔꠣꠞ ꠙꠥꠀꠂꠘ ꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠟꠣ। ꠢꠦꠡ-ꠝꠦꠡ ꠔꠣꠞꠣ ꠇꠦꠃ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠟ ꠘꠣ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠃ ꠙꠥꠞꠣ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_1","005_22_1","NUM","22","1","1","ꠄꠞꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠉꠤꠀ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠃꠟꠐꠣꠛꠣꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠗꠣꠞꠅ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠋꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_2","005_22_2","NUM","22","2","2","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠎꠦ ꠢꠣꠟꠔ ꠇꠞꠍꠤꠟ, ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇ ꠛꠤꠘ ꠡꠤꠙꠣꠞꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU22_3","005_22_3","NUM","22","3","3","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠅꠔ ꠝꠣꠘꠥꠡ ꠖꠦꠈꠤꠀ ꠝꠥꠀꠛꠤ ꠅꠇꠟ ꠒꠞꠣꠁꠉꠦꠟꠣ। ꠀꠍꠟꠦꠃ ꠔꠣꠞꠣ ꠈꠥꠛ ꠛꠦꠡꠤ ꠊꠣꠛꠠꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_4","005_22_4","NUM","22","4","4","ꠔꠣꠞꠣ ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠉꠞꠥꠄ ꠎꠦꠟꠣ ꠛꠘ꠆ꠖꠞ ꠈꠦꠍꠝꠣ ꠊꠣꠡꠞꠦ ꠟꠦꠁꠀ-ꠚꠥꠍꠤ ꠈꠣꠁꠟꠣꠄ, ꠅꠃ ꠖꠟꠦꠅ ꠅꠃꠟꠣ ꠀꠝꠞꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠢꠇꠟꠔꠣ ꠟꠦꠁꠀ-ꠚꠥꠍꠤ ꠈꠣꠁꠟꠤꠛ।” ꠅꠃ ꠡꠝꠄ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣ ꠀꠍꠟꠣ ꠛꠣꠟꠣꠇ ꠛꠤꠘ ꠡꠤꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU22_5","005_22_5","NUM","22","5","5","ꠛꠣꠖꠡꠣꠄ ꠒꠞꠣꠁꠀ ꠛꠣꠟꠣꠝ ꠛꠤꠘ ꠛꠣꠃꠞ ꠘꠣꠝꠞ ꠙꠤꠞ ꠍꠣꠛꠞꠦ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠟꠣ। ꠛꠣꠟꠣꠝ ꠔ ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠖꠦꠡꠞ ꠚꠥꠞꠣꠔ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠅ ꠚꠔꠥꠞ ꠐꠣꠃꠘꠅ ꠀꠍꠟꠣ। ꠛꠣꠟꠣꠇꠦ ꠈꠛꠞꠤꠀꠞꠦ ꠇꠁꠀ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠔꠣꠘꠞꠦ ꠇꠁꠅ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠄꠇꠖꠟ ꠝꠣꠘꠥꠡ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠦ। ꠀꠁꠀ ꠀꠡ꠆ꠔꠣ ꠎꠝꠤꠘ ꠜꠞꠤꠀ ꠈꠣꠟꠤ ꠉꠤꠍꠉꠤꠍ ꠇꠞꠞꠣ, ꠔꠣꠞꠣ ꠅꠈꠘ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠛꠡꠔ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_6","005_22_6","NUM","22","6","6","ꠁꠔꠣ ꠔ ꠀꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠛꠟꠛꠣꠘ। ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠦ ꠀꠃꠇ꠆ꠇꠣ, ꠀꠁꠀ ꠅꠔꠣꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠔꠦꠃ ꠀꠝꠤ ꠢꠄꠔ ꠔꠣꠞꠣꠞꠦ ꠝꠣꠞꠤꠀ ꠖꠦꠡ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ। ꠀꠞ ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ, ꠀꠙꠘꠦ ꠎꠣꠞꠦ ꠖꠥꠀ ꠖꠦꠁꠘ ꠢꠦ ꠑꠤꠇꠃ ꠖꠥꠀ ꠙꠣꠄ, ꠀꠞ ꠎꠣꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠦꠁꠘ ꠔꠣꠞ ꠃꠙꠞꠦ ꠢꠣꠍꠣꠃ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU22_7","005_22_7","NUM","22","7","7","ꠔꠦꠃ ꠝꠥꠀꠛ ꠀꠞ ꠝꠣꠖꠤꠀꠘꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠁꠡ꠆ꠔꠦꠈꠣꠞꠣ-ꠀꠎꠤꠞꠣꠔ ꠇꠞꠣꠘꠤꠞ ꠐꠦꠇꠣ ꠟꠁꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ। ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠎꠦꠟꠣ ꠢꠤꠇꠣꠁ ꠖꠤꠍꠟꠣ, ꠔꠣꠞꠣ ꠉꠤꠀ ꠛꠣꠟꠣꠝꠞ ꠉꠦꠍꠦ ꠅꠟꠣ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_8","005_22_8","NUM","22","8","8","ꠔꠦꠃ ꠛꠣꠟꠣꠝꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠀꠁꠎ ꠞꠣꠁꠔ ꠀꠝꠣꠞ ꠅꠘꠅ ꠞꠃꠇ꠆ꠇꠣ। ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠛꠣ, ꠀꠝꠤ ꠅꠔꠣ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠝꠥ।” ꠉꠔꠤꠇꠦꠃ ꠔꠣꠞꠣ ꠔꠣꠘ ꠅꠘꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_9","005_22_9","NUM","22","9","9","ꠝꠣꠛꠥꠖꠦ ꠛꠣꠟꠣꠝꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠅꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠄꠞꠣ ꠇꠣꠞꠣ?” ");
INSERT INTO syls_vpl VALUES ("NU22_10","005_22_10","NUM","22","10","10","ꠛꠣꠟꠣꠝꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠝꠥꠀꠛꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇ ꠛꠤꠘ ꠡꠤꠙꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("NU22_11","005_22_11","NUM","22","11","11","ꠇꠁꠍꠂꠘ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠄꠇꠖꠟ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠅ ꠉꠤꠍꠉꠤꠍ ꠇꠞꠞꠣ। ꠅꠈꠘ ꠀꠙꠘꠦ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠔꠦꠃ ꠀꠝꠤ ꠎꠥꠖ꠆ꠖ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠛꠥꠟꠦ ꠈꠦꠖꠣꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU22_12","005_22_12","NUM","22","12","12","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠛꠣꠟꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠄꠞꠣꠞ ꠟꠉꠦ ꠎꠣꠁꠅ ꠘꠣ, ꠀꠞ ꠢꠤꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠇꠥꠘꠥ ꠟꠣꠘ꠆ꠘꠔꠅ ꠖꠤꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠅꠀ ꠛꠘ꠆ꠖꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU22_13","005_22_13","NUM","22","13","13","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠛꠣꠟꠣꠝ ꠊꠥꠝ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠛꠣꠟꠣꠇꠞ ꠈꠛꠞꠤꠀ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠖꠦꠡꠅ ꠚꠤꠞꠔ ꠎꠣꠃꠇ꠆ꠇꠣꠉꠤ। ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠝꠣꠘꠣ ꠇꠞꠍꠂꠘ, ꠀꠙꠘꠣꠞꠣꠞ ꠟꠉꠦ ꠘꠣ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU22_14","005_22_14","NUM","22","14","14","ꠔꠦꠃ ꠝꠥꠀꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠚꠤꠞꠤꠀ ꠉꠤꠀ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠟꠣꠝ ꠔ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠁꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠍꠂꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU22_15","005_22_15","NUM","22","15","15","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠣꠟꠣꠇꠦ ꠄꠞꠣꠞ ꠌꠣꠁꠔꠦ ꠀꠞꠅ ꠛꠦꠡꠤ, ꠀꠞꠅ ꠁꠎ꠆ꠎꠔꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_16","005_22_16","NUM","22","16","16","ꠔꠣꠞꠣ ꠉꠤꠀ ꠛꠣꠟꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇ ꠛꠤꠘ ꠡꠤꠙꠣꠞꠦ ꠇꠁꠍꠂꠘ, ꠀꠙꠘꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠦ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠇꠥꠘꠥ ꠛꠣꠗꠣ ꠝꠣꠘꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_17","005_22_17","NUM","22","17","17","ꠔꠣꠁꠘ ꠀꠙꠘꠣꠞꠦ ꠛꠃꠔ ꠁꠎ꠆ꠎꠔ-ꠛꠈꠡꠤꠡ ꠖꠤꠛꠣ, ꠀꠞ ꠀꠙꠘꠦ ꠎꠦꠟꠣ ꠇꠁꠛꠣ, ꠔꠣꠁꠘ ꠅꠟꠣꠃ ꠇꠞꠛꠣ। ꠈꠣꠟꠤ ꠀꠙꠘꠦ ꠎꠣꠘꠥ ꠔꠣꠘ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠦꠁꠘ, ꠔꠣꠁꠘ ꠅꠈꠣꠘꠃ ꠌꠣꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU22_18","005_22_18","NUM","22","18","18","ꠛꠣꠟꠣꠝꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠎꠥꠖꠤ ꠔꠣꠘ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠄ ꠜꠞꠣ ꠞꠣꠎꠛꠣꠠꠤ ꠈꠣꠘꠅ ꠀꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠘ, ꠔꠣ-ꠅ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠉꠤꠀ ꠀꠝꠤ ꠄꠇꠈꠣꠘ ꠇꠣꠝꠅ ꠇꠞꠔꠣꠝ ꠘꠣꠄ, ꠁꠔꠣ ꠢꠥꠞꠥ ꠇꠣꠝ ꠅꠃꠇ ꠛꠣ ꠛꠠ ꠇꠣꠝ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("NU22_19","005_22_19","NUM","22","19","19","ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣꠅ ꠀꠉꠞ ꠄꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠁꠎꠇꠥꠞ ꠞꠣꠁꠔ ꠈꠣꠘ ꠅꠘꠅ ꠇꠣꠐꠣꠁ ꠟꠣꠃꠇ꠆ꠇꠣ। ꠀꠝꠤ ꠖꠦꠈꠤ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠘꠄꠀ ꠇꠥꠘ꠆ꠔꠣ ꠇꠂꠘ ꠘꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU22_20","005_22_20","NUM","22","20","20","ꠢꠃ ꠞꠣꠁꠔ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠁꠞ ꠅꠁꠀ ꠛꠣꠟꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠄꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠣꠞꠦ ꠘꠦꠅꠀꠔ ꠀꠁꠍꠦ, ꠔꠦ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠣꠅ। ꠉꠦꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠁꠝꠥ, ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠅꠟꠣꠃ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU22_21","005_22_21","NUM","22","21","21","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞ ꠊꠥꠝ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠔꠣꠘ ꠉꠣꠗꠤꠞ ꠃꠙꠞꠦ ꠉꠖꠤ ꠛꠤꠍꠣꠁꠀ ꠝꠥꠀꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_22","005_22_22","NUM","22","22","22","ꠔꠣꠘ ꠎꠣꠅꠀ ꠖꠦꠈꠤꠀ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔꠣꠘ ꠃꠙꠞꠦ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ। ꠔꠣꠘꠞꠦ ꠛꠣꠗꠣ ꠖꠤꠛꠣꠞ ꠈꠤꠀꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠙꠕ ꠀꠃꠉꠟꠤꠀ ꠃꠛꠣꠁ ꠞꠁꠟꠣ। ꠛꠣꠟꠣꠝ ꠔ ꠉꠣꠗꠤꠞ ꠃꠙꠞꠦ ꠌꠠꠤꠀ ꠎꠣꠁꠞꠣ, ꠔꠣꠘ ꠖꠥꠁꠎꠘ ꠌꠣꠇꠞ ꠔꠣꠘ ꠟꠉꠦ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU22_23","005_22_23","NUM","22","23","23","ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠟꠥꠀꠞ ꠀꠔꠅ ꠟꠁꠀ, ꠙꠕꠞ ꠝꠣꠎꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ ꠖꠦꠈꠤꠀ, ꠉꠣꠗꠤꠐꠣ ꠙꠕ ꠍꠣꠠꠤꠀ ꠎꠝꠤꠘꠦꠖꠤ ꠟꠣꠝꠤ ꠉꠦꠟ। ꠉꠣꠗꠤꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠙꠕꠅ ꠔꠥꠟꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠟꠣꠝꠦ ꠔꠣꠁꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_24","005_22_24","NUM","22","24","24","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠎꠝꠤꠘꠞ ꠀꠋꠉꠥꠞ ꠛꠣꠉꠣꠘꠞ ꠖꠥꠁ ꠈꠦꠔꠞ ꠝꠣꠎꠞ ꠀꠁꠟꠞ ꠃꠙꠞꠦ ꠃꠛꠣꠁ ꠞꠁꠟꠣ। ꠀꠁꠟꠞ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠙꠣꠇꠣ ꠅꠀꠟ ꠖꠦꠅꠀ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU22_25","005_22_25","NUM","22","25","25","ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠉꠣꠗꠤꠄ ꠅꠀꠟꠞ ꠉꠣꠟꠣꠛꠣꠄ ꠊꠦꠡꠤꠀ ꠉꠦꠟ। ꠄꠞꠖꠣꠄ ꠛꠣꠟꠣꠝꠞ ꠄꠇ ꠙꠣꠅ-ꠅ ꠈꠥꠛ ꠊꠡꠣ ꠟꠣꠉꠟ। ꠔꠦꠃ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠉꠣꠗꠤꠞꠦ ꠝꠣꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_26","005_22_26","NUM","22","26","26","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠉꠥꠀꠁꠀ ꠉꠤꠀ ꠙꠕꠞ ꠝꠣꠎꠞ ꠅꠟꠣ ꠄꠇ ꠌꠤꠙꠣ ꠎꠣꠉꠣꠔ ꠃꠛꠣꠁꠟꠣ, ꠎꠦꠘꠅ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠇꠥꠘꠥꠛꠣꠄ ꠢꠞꠣꠞ ꠃꠙꠣꠄ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("NU22_27","005_22_27","NUM","22","27","27","ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠉꠣꠗꠤꠄ ꠛꠣꠟꠣꠝꠞꠦ ꠟꠁꠀ ꠝꠣꠐꠤꠔ ꠢꠥꠔꠤ ꠉꠦꠟ। ꠔꠦꠃ ꠛꠣꠟꠣꠝ ꠀꠞꠅ ꠉꠞꠝ ꠅꠁꠀ ꠟꠣꠑꠤ ꠖꠤꠀ ꠉꠣꠗꠤꠞꠦ ꠝꠣꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_28","005_22_28","NUM","22","28","28","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠉꠣꠗꠤꠞ ꠝꠥꠈꠞ ꠎꠛꠣꠘ ꠈꠥꠟꠤ ꠖꠤꠟꠣ। ꠔꠣꠁ ꠛꠣꠟꠣꠝꠞꠦ ꠇꠁꠟ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠍꠤ, ꠀꠙꠘꠦ ꠔꠤꠘ-ꠔꠤꠘꠛꠣꠞ ꠀꠝꠣꠞꠦ ꠝꠣꠞꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("NU22_29","005_22_29","NUM","22","29","29","ꠛꠣꠟꠣꠝꠦ ꠉꠣꠗꠤꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠁ ꠀꠝꠣꠞꠦ ꠀꠃꠀ ꠛꠣꠘꠣꠁꠀ ꠈꠦꠁꠠ ꠈꠦꠟꠣꠁꠞꠦ ꠘꠤ? ꠢꠥꠘ, ꠀꠝꠣꠞ ꠀꠔꠅ ꠎꠥꠖꠤ ꠄꠇꠈꠣꠘ ꠔꠟꠥꠀꠞ ꠕꠣꠇꠔ, ꠔꠦ ꠔꠞꠦ ꠍꠦꠖ ꠝꠣꠞꠤ ꠅꠈꠘꠃ ꠇꠣꠐꠤꠟ꠆ꠟꠣꠝ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU22_30","005_22_30","NUM","22","30","30","ꠉꠣꠗꠤꠄ ꠛꠣꠟꠣꠝꠞꠦ ꠇꠁꠟ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠢꠃ ꠉꠣꠗꠤ ꠘꠣꠄ ꠘꠤ, ꠎꠦꠉꠥꠞ ꠃꠙꠞꠦ ꠀꠙꠘꠦ ꠢꠣꠞꠣ ꠎꠘꠝ ꠗꠞꠤ ꠌꠠꠤꠀ ꠀꠁꠞꠣ, ꠀꠞ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠀꠝꠤ ꠇꠥꠘꠥꠖꠤꠘ ꠁꠟꠣ ꠇꠞꠍꠤ ꠘꠤ?” ꠛꠣꠟꠣꠝꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠁꠟꠣ ꠇꠞꠍꠔ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU22_31","005_22_31","NUM","22","31","31","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠛꠣꠟꠣꠝꠞ ꠌꠃꠈ ꠈꠥꠟꠤꠀ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠟꠥꠀꠞ ꠟꠁꠀ ꠙꠕ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠀ ꠘꠣꠇ-ꠇꠙꠣꠟ ꠝꠣꠐꠤꠔ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_32","005_22_32","NUM","22","32","32","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠉꠣꠗꠤꠞꠦ ꠇꠦꠘꠦ ꠔꠤꠘ-ꠔꠤꠘꠛꠣꠞ ꠝꠣꠞꠟꠣꠄ? ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠣꠝ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄꠉꠤ ꠖꠦꠈꠤꠀ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠐꠇꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠅꠘꠅ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU22_33","005_22_33","NUM","22","33","33","ꠔꠥꠝꠣꠞ ꠉꠣꠗꠤꠄ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠤꠘ-ꠔꠤꠘꠛꠣꠞ ꠢꠞꠤꠀ ꠉꠦꠍꠦꠉꠤ। ꠔꠣꠁ ꠎꠥꠖꠤ ꠘꠣ ꠢꠞꠔ, ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠝꠣꠞꠤꠟ꠆ꠟꠣꠝ ꠅꠘꠦ, ꠀꠞ ꠔꠣꠁꠞꠦ ꠛꠣꠌꠣꠁ ꠞꠣꠈꠟꠣꠝ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU22_34","005_22_34","NUM","22","34","34","ꠅꠃ ꠡꠝꠄ ꠛꠣꠟꠣꠝꠦ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠉꠥꠘꠣ ꠇꠞꠍꠤ। ꠀꠍꠟꠦ ꠀꠝꠤ ꠛꠥꠎꠍꠤ ꠘꠣ, ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠀꠐꠇꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠙꠕꠅ ꠃꠛꠣꠔ ꠀꠍꠂꠘ। ꠔꠦ ꠀꠙꠘꠦ ꠘꠣꠞꠣꠎ ꠅꠁꠟꠦ ꠀꠝꠤ ꠚꠤꠞꠤꠀ ꠎꠣꠁꠝꠥꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU22_35","005_22_35","NUM","22","35","35","ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠛꠣꠟꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠑꠤꠇ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠎꠣꠅ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠤꠇꠣꠁ ꠖꠤꠝꠥ, ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠅꠟꠣꠃ ꠇꠁꠛꠣꠄ।” ꠔꠦꠃ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠞ ꠙꠣꠑꠣꠁꠟ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞ ꠌꠟꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_36","005_22_36","NUM","22","36","36","ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞ ꠀꠅꠀꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ, ꠔꠣꠘꠞꠦ ꠀꠉꠥꠀꠁꠀ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇ ꠅꠞꠘꠘ ꠈꠣꠟꠞ ꠙꠣꠞꠅ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠄꠇ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ। ꠁ ꠐꠣꠃꠘ ꠀꠍꠤꠟ ꠔꠣꠘ ꠖꠦꠡꠞ ꠢꠦꠡ ꠡꠤꠝꠣꠘꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("NU22_37","005_22_37","NUM","22","37","37","ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠀꠙꠘꠣꠞꠦ ꠎꠞꠥꠞꠤ ꠔꠟꠛ ꠇꠞꠟꠣꠝ। ꠔꠦ ꠀꠙꠘꠦ ꠇꠦꠘꠦ ꠙꠄꠟꠣ ꠛꠣꠞ ꠀꠁꠟꠣ ꠘꠣ? ꠀꠙꠘꠣꠞꠦ ꠎꠁꠉ꠆ꠉ ꠛꠈꠡꠤꠡ ꠖꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠇꠥꠘꠥ ꠀꠝꠣꠞ ꠘꠣꠁ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("NU22_38","005_22_38","NUM","22","38","38","ꠛꠣꠟꠣꠝꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠅꠈꠘ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠍꠤ। ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠇꠥꠘꠥ ꠝꠣꠔ ꠝꠣꠔꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠘꠣꠁ। ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦꠖꠤ ꠎꠦꠔꠣ ꠇꠅꠀꠁꠛꠣ, ꠀꠝꠤ ꠈꠣꠟꠤ ꠅꠈꠣꠘꠃ ꠇꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU22_39","005_22_39","NUM","22","39","39","ꠄꠞꠛꠣꠖꠦ ꠛꠣꠟꠣꠇ ꠛꠣꠖꠡꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠛꠣꠟꠣꠝ ꠙꠤꠞ ꠇꠤꠞꠤꠅꠔ-ꠢꠥꠍꠥꠔ ꠉꠣꠃꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_40","005_22_40","NUM","22","40","40","ꠉꠤꠀ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠉꠞꠥ ꠀꠞ ꠝꠦꠠꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ ꠇꠤꠍꠥ ꠉꠥꠡ꠆ꠔ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞꠦ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠃ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU22_41","005_22_41","NUM","22","41","41","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠅꠃ ꠛꠣꠟꠣꠝꠞꠦ ꠟꠁꠀ ꠛꠣꠝꠥꠔ-ꠛꠣꠀꠟ ꠙꠣꠠꠅ ꠉꠦꠟꠣ। ꠢꠘꠅ ꠃꠛꠣꠁꠀ ꠛꠣꠟꠣꠝꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠄꠇ ꠅꠋꠡꠞꠦ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU23_1","005_23_1","NUM","23","1","1","ꠀꠞ ꠅꠃ ꠛꠤꠀꠘꠇꠥ ꠛꠣꠟꠣ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠛꠣꠟꠣꠇ ꠛꠣꠖꠡꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠔꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠃꠇ꠆ꠇꠣ, ꠛꠣꠘꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠡꠣꠔꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠞ ꠡꠣꠔꠉꠥ ꠝꠦꠠꠣ ꠎꠥꠉꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU23_2","005_23_2","NUM","23","2","2","ꠛꠣꠟꠣꠝꠞ ꠇꠕꠣꠝꠔꠃ ꠛꠣꠟꠣꠇꠦ ꠅꠟꠣ ꠇꠞꠟꠣ, ꠇꠞꠤꠀ ꠖꠥꠁꠅꠎꠘꠦ ꠝꠤꠟꠤꠀ ꠙꠞꠔꠦꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠄꠉꠥ ꠇꠞꠤ ꠛꠤꠍꠣꠟ ꠀꠞ ꠄꠉꠥ ꠇꠞꠤ ꠝꠦꠠꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU23_3","005_23_3","NUM","23","3","3","ꠄꠞꠛꠣꠖꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠛꠣꠟꠣꠇꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠃ ꠙꠡꠥꠞ ꠇꠣꠍꠣꠔ ꠀꠙꠘꠦ ꠞꠃꠇ꠆ꠇꠣ। ꠀꠝꠤ ꠕꠥꠠꠣ ꠢꠞꠤꠀ ꠎꠣꠁꠞꠣꠝ, ꠅꠁꠔ ꠙꠣꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠛꠣ। ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠛꠣ, ꠀꠝꠤ ꠀꠁꠀ ꠀꠙꠘꠣꠞꠦ ꠇꠁꠝꠥꠘꠦ।” ꠅꠈꠣꠘ ꠇꠁꠀ ꠛꠣꠟꠣꠝ ꠙꠤꠞ ꠉꠤꠀ ꠙꠣꠠꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠃꠌꠣ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU23_4","005_23_4","NUM","23","4","4","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠟꠣ। ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠝꠣꠛꠥꠖꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠔ ꠖꠦꠈꠞꠣꠄ, ꠀꠝꠤ ꠡꠣꠔꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠍꠤ ꠀꠞ ꠙꠞꠔꠦꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠄꠉꠥ ꠇꠞꠤ ꠛꠤꠍꠣꠟ ꠀꠞ ꠄꠉꠥ ꠇꠞꠤ ꠝꠦꠠꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU23_5","005_23_5","NUM","23","5","5","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞꠦ ꠄꠇ ꠛꠥꠟꠤ ꠢꠤꠇꠣꠁ ꠖꠤꠟꠣ, ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠉꠤꠀ ꠛꠣꠟꠣꠇ ꠛꠣꠖꠡꠣꠞꠦ ꠅꠔꠣ ꠇꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU23_6","005_23_6","NUM","23","6","6","ꠔꠦꠃ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠢꠇꠟ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣꠞꠦ ꠟꠁꠀ ꠔꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣ ꠙꠡꠥꠞ ꠅꠘꠅ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU23_7","005_23_7","NUM","23","7","7","ꠅꠃ ꠡꠝꠄ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠢꠤꠇꠣꠁꠀ ꠖꠦꠅꠀ ꠅꠃ ꠛꠥꠟꠤ ꠢꠇꠟ ꠢꠥꠘꠣꠁꠟꠣ, ꠇꠁꠟꠣ, “ꠡꠤꠞꠤꠀ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠟꠣꠇꠦ ꠀꠝꠣꠞꠦ ꠀꠘꠣꠁꠍꠂꠘ, ꠙꠥꠛꠞ ꠙꠣꠠ ꠅꠇꠟꠞ ꠗꠣꠞꠅ ꠕꠣꠇꠤ ꠝꠥꠀꠛꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦꠃ ꠝꠞꠦ ꠎꠥꠉꠣꠁꠍꠂꠘ। ꠎꠥꠉꠣꠁꠀ ꠇꠁꠟꠣ, ꠀꠝꠣꠞ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠁꠀꠇꠥꠛꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠅꠔꠣꠞꠦ ꠛꠖ꠆ꠖꠥꠀ ꠖꠦꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("NU23_8","005_23_8","NUM","23","8","8","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠍꠂꠘ ꠘꠣ ꠎꠣꠞꠦ, ꠀꠝꠤ ꠇꠤꠟꠣꠘ ꠖꠤꠝꠥ ꠟꠣꠘ꠆ꠘꠔ ꠔꠣꠞꠦ? ꠝꠣꠛꠥꠖꠦ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠇꠕꠣ ꠘꠣ ꠇꠞꠍꠂꠘ ꠎꠣꠞ, ꠀꠝꠤ ꠇꠤꠟꠣꠘ ꠈꠦꠔꠤꠞ ꠇꠕꠣ ꠇꠁꠔꠣꠝ ꠔꠣꠞ? ");
INSERT INTO syls_vpl VALUES ("NU23_9","005_23_9","NUM","23","9","9","ꠖꠦꠈꠍꠤ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠃꠌꠣ ꠐꠤꠟ꠆ꠟꠣ ꠕꠣꠇꠤ, ꠔꠣꠞꠣꠞ ꠛꠣꠄꠖꠤ ꠌꠣꠁꠍꠤ ꠔ ꠙꠣꠠꠞ ꠌꠥꠠꠣ ꠕꠣꠇꠤ, ꠖꠦꠈꠟꠣꠝ ꠀꠝꠤ ꠄꠞꠣ ꠅꠁꠟꠣ ꠅꠟꠣ ꠄꠇ ꠎꠣꠔꠤ, ꠔꠣꠞꠣ ꠞꠂꠘ ꠀꠟꠉ ꠅꠁꠀ ꠛꠣꠇꠤ ꠢꠇꠟ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("NU23_10","005_23_10","NUM","23","10","10","ꠁꠀꠇꠥꠛꠞ ꠀꠅꠟꠣꠖ ꠖꠦꠈꠤ ꠛꠣꠟꠥꠞ ꠖꠣꠘꠣꠞ ꠝꠔ, ꠉꠘꠤꠀ ꠚꠥꠠꠣꠁꠔ ꠔꠣꠞꠦ ꠇꠣꠞ ꠀꠍꠦ ꠡꠣꠁꠖ꠆ꠖ? ꠝꠞꠘ ꠎꠣꠘꠥ ꠅꠄ ꠀꠝꠣꠞ ꠘꠦꠇꠇꠣꠞ ꠅꠃ ꠖꠟꠞ ꠟꠣꠈꠣꠘ ꠀꠈꠦꠞꠣꠔꠅ ꠅꠃꠇ ꠝꠞ ꠔꠣꠞꠣꠞꠃ ꠟꠣꠈꠣꠘ।” ");
INSERT INTO syls_vpl VALUES ("NU23_11","005_23_11","NUM","23","11","11","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠛꠣꠟꠣꠝꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠟꠣ? ꠀꠙꠘꠣꠞꠦ ꠀꠘꠣꠁꠟꠣꠝ ꠀꠝꠣꠞ ꠖꠥꠡꠝꠘꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠀꠙꠘꠦ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU23_12","005_23_12","NUM","23","12","12","ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠝꠥꠈꠅ ꠎꠦꠔꠣ ꠎꠥꠉꠣꠁ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠀꠝꠤ ꠇꠁꠝꠥ ꠘꠣ ꠇꠤꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("NU23_13","005_23_13","NUM","23","13","13","ꠛꠣꠖꠦ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠞꠇ ꠎꠣꠉꠣꠔ ꠀꠃꠇ꠆ꠇꠣ। ꠢꠘ ꠕꠘꠦ ꠀꠙꠘꠣꠞ ꠌꠃꠈꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠦꠈꠣ ꠙꠣꠁꠛꠣ। ꠔꠣꠞꠣ ꠢꠇꠟꠞꠦ ꠖꠦꠈꠣ ꠎꠣꠁꠔ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠄꠇ ꠅꠋꠡꠞꠦ ꠀꠙꠘꠦ ꠖꠦꠈꠛꠣ, ꠖꠦꠈꠤꠀ ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU23_14","005_23_14","NUM","23","14","14","ꠅꠈꠣꠘ ꠇꠁꠀ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠔꠣꠘꠞꠦ ꠟꠁꠀ ꠙꠤꠍꠉꠣ ꠙꠣꠠꠞ ꠃꠙꠞꠞ ꠎꠚꠤꠝ ꠘꠣꠝꠞ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠢꠘꠅ ꠡꠣꠔꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠀ ꠙꠞꠔꠦꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠄꠉꠥ ꠇꠞꠤ ꠛꠤꠍꠣꠟ ꠀꠞ ꠄꠉꠥ ꠇꠞꠤ ꠝꠦꠠꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU23_15","005_23_15","NUM","23","15","15","ꠛꠣꠖꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠞꠦ ꠇꠁꠟꠣ, “ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠎꠦꠔꠣ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠀꠙꠘꠦ ꠅꠔꠣꠞ ꠗꠣꠞꠅ ꠞꠃꠇ꠆ꠇꠣ। ꠀꠝꠤ ꠅꠤꠘ꠆ꠘꠛꠣꠄ ꠎꠣꠁꠞꠣꠝ, ꠝꠣꠛꠥꠖꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠅꠀꠞ ꠀꠡꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU23_16","005_23_16","NUM","23","16","16","ꠝꠣꠛꠥꠖꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠟꠣ, ꠀꠞ ꠔꠣꠞ ꠎꠛꠣꠘꠞ ꠝꠣꠎꠦ ꠇꠤꠍꠥ ꠛꠥꠟꠤ ꠎꠥꠉꠣꠁ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠢꠤꠇꠣꠁꠟ ꠅꠃ ꠝꠣꠔ ꠝꠣꠔꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU23_17","005_23_17","NUM","23","17","17","ꠔꠦꠃ ꠔꠣꠁꠘ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠖꠦꠈꠟꠣ ꠛꠣꠖꠡꠣꠄ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣ ꠙꠡꠥꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠛꠣꠖꠡꠣꠄ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠀꠙꠘꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠁꠍꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("NU23_18","005_23_18","NUM","23","18","18","ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠅꠃ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠞ ꠢꠤꠇꠣꠁꠟ ꠅꠃ ꠛꠥꠟꠤ ꠇꠁꠟꠣ, “ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇ ꠈꠤꠀꠟ ꠇꠞꠅ, ꠅꠈꠘ ꠢꠥꠘꠅ ꠖꠤꠀ ꠝꠘ, ꠄꠞꠦ ꠡꠤꠙꠣꠞꠞ ꠙꠥꠔ ꠛꠣꠟꠣꠇ, ꠝꠞ ꠇꠕꠣꠔ ꠖꠦꠅ ꠇꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("NU23_19","005_23_19","NUM","23","19","19","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠝꠣꠘꠥꠡ ꠘꠣꠄ ꠎꠦꠘ ꠝꠤꠍꠣ ꠝꠣꠔꠤꠛꠣ, ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠀꠖꠝ ꠡꠘ꠆ꠔꠣꠘ ꠘꠣꠄ ꠎꠦꠘ ꠖꠤꠟ ꠛꠖꠟꠣꠁꠛꠣ। ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠇꠕꠣ ꠇꠂꠘ ꠑꠤꠇ ꠅꠟꠣꠃ ꠇꠞꠂꠘ, ꠔꠣꠘ ꠅꠀꠖꠣ ꠅꠇꠟꠃ ꠘꠤꠌ꠆ꠌꠤꠔ ꠙꠥꠞꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU23_20","005_23_20","NUM","23","20","20","ꠘꠦꠇ ꠖꠥꠀ ꠖꠤꠔꠣꠝ ꠇꠞꠤ ꠢꠥꠇꠥꠝ ꠎꠦꠟꠣ ꠙꠣꠁꠍꠤ, ꠇꠤꠟꠣ ꠛꠖꠟꠣꠁꠝꠥ ꠀꠝꠤ ꠝꠥꠘꠤꠛꠞ ꠅꠃ ꠝꠞ꠆ꠎꠤ? ");
INSERT INTO syls_vpl VALUES ("NU23_21","005_23_21","NUM","23","21","21","ꠁꠀꠇꠥꠛꠞ ꠀꠅꠟꠣꠖꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥ ꠛꠖ-ꠘꠍꠤꠛ ꠖꠦꠈꠍꠂꠘ ꠘꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠙꠣꠟꠅ ꠇꠥꠘꠥ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠟꠦꠈꠍꠂꠘ ꠘꠣ। ꠔꠣꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ ꠔꠣꠞꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠎꠄ ꠉꠣꠘ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU23_22","005_23_22","NUM","23","22","22","ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠔꠣꠁꠘꠃ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ ꠔꠣꠞꠣꠞ ꠙꠇ꠆ꠇꠦ ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠎꠋꠟꠤ ꠛꠄꠞꠣꠞ ꠛꠟ। ");
INSERT INTO syls_vpl VALUES ("NU23_23","005_23_23","NUM","23","23","23","ꠁꠀꠇꠥꠛꠞ ꠀꠅꠟꠣꠖꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠎꠣꠖꠥ-ꠝꠘꠔ꠆ꠞ ꠌꠟꠔ ꠘꠣꠄ, ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠔꠣꠛꠤꠎ-ꠇꠛꠎꠦ ꠇꠣꠝ ꠀꠁꠔ ꠘꠣꠄ। ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠈꠘ ꠅꠃ ꠛꠥꠟꠤ ꠇꠅꠀ ꠎꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠇꠞꠍꠂꠘ ꠅꠔꠣ ꠌꠣꠁꠀ ꠖꠦꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("NU23_24","005_23_24","NUM","23","24","24","ꠅꠃ ꠎꠣꠔꠤ ꠔ ꠡꠤꠋꠢꠤꠞ ꠟꠣꠈꠣꠘ ꠉꠥꠘ꠆ꠎꠞꠤꠀ ꠃꠑꠤꠛ, ꠀꠞ ꠡꠤꠋꠢꠞ ꠟꠣꠈꠣꠘ ꠃꠑꠤꠀ ꠀꠉ ꠛꠣꠠꠤꠛ। ꠡꠤꠇꠣꠞꠞ ꠟꠃ ꠀꠞ ꠉꠥꠡ꠆ꠔ ꠘꠣ ꠈꠣꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠣ ꠖꠝ ꠟꠁꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU23_25","005_23_25","NUM","23","25","25","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠇꠁꠟꠣ, “ꠛꠘ꠆ꠖ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠀꠅ ꠖꠤꠛꠣ ꠘꠣ, ꠟꠣꠘ꠆ꠘꠔꠅ ꠖꠤꠛꠣ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU23_26","005_23_26","NUM","23","26","26","ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔ ꠀꠙꠘꠣꠞꠦ ꠀꠉꠦꠃ ꠇꠁꠍꠤ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠁꠛꠣ, ꠀꠝꠣꠞ ꠅꠟꠣꠃ ꠇꠞꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU23_27","005_23_27","NUM","23","27","27","ꠛꠣꠖꠦ ꠛꠣꠟꠣꠇ ꠛꠣꠖꠡꠣꠄ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞꠦ ꠇꠁꠟꠣ, “ꠀꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠀꠞꠇ ꠎꠣꠉꠣꠔ ꠟꠁꠀ ꠎꠣꠁꠝꠥ। ꠢꠘꠅ ꠉꠦꠟꠦ ꠅꠁꠔ ꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠈꠥꠡꠤ ꠅꠁꠀ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇ ꠟꠁꠛꠣ, ꠀꠞ ꠀꠙꠘꠣꠞꠦꠖꠤ ꠢꠔꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠔꠦ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU23_28","005_23_28","NUM","23","28","28","ꠅꠈꠣꠘ ꠇꠁꠀ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠘꠞꠦ ꠟꠁꠀ ꠙꠤꠃꠞ ꠘꠣꠝꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠉꠦꠟꠣ, ꠅꠃ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠝꠞꠥꠜꠥꠝꠤ ꠖꠦꠈꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU23_29","005_23_29","NUM","23","29","29","ꠅꠃ ꠡꠝꠄ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠇꠁꠟꠣ, “ꠅꠘꠅ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠔꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠀ, ꠡꠣꠔꠉꠥ ꠛꠤꠍꠣꠟ ꠀꠞ ꠡꠣꠔꠉꠥ ꠝꠦꠠꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU23_30","005_23_30","NUM","23","30","30","ꠙꠤꠞ ꠍꠣꠛꠞ ꠇꠕꠣꠝꠔ ꠛꠣꠖꠡꠣꠄ ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠙꠞꠔꠦꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠄꠉꠥ ꠇꠞꠤ ꠛꠤꠍꠣꠟ ꠀꠞ ꠄꠉꠥ ꠇꠞꠤ ꠝꠦꠠꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_1","005_24_1","NUM","24","1","1","ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠎꠦꠛꠟꠣ ꠛꠥꠎꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠥꠀ ꠖꠦꠅꠀꠃ ꠅꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠁꠌ꠆ꠍꠣ, ꠛꠥꠎꠤꠀ ꠔꠣꠁꠘ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠀꠞ ꠁꠡ꠆ꠔꠦꠈꠣꠞꠣ-ꠀꠎꠤꠞꠣꠔꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠟꠣ ꠘꠣ। ꠛꠞꠋ ꠔꠣꠘ ꠘꠤꠎꠞ ꠝꠥꠈ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠚꠤꠞꠣꠁꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_2","005_24_2","NUM","24","2","2","ꠚꠤꠞꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠘꠣꠘꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠔꠣꠝ꠆ꠛꠥ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠐꠣꠋꠉꠣꠘꠤ ꠅꠁꠍꠦ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU24_3","005_24_3","NUM","24","3","3","ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠅꠃ ꠅꠢꠤ ꠇꠁꠟꠣ, “ꠛꠣꠃꠞꠞ ꠙꠥꠔ ꠛꠣꠟꠣꠝꠦ ꠇꠁꠞꠣ, ꠌꠃꠈ ꠎꠣꠞ ꠈꠥꠟꠣ ꠀꠍꠦ ꠄꠁꠘ ꠅꠃ ꠛꠥꠟꠤ ꠇꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_4","005_24_4","NUM","24","4","4","ꠎꠦ ꠎꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠞꠣ, ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠞꠣ, ꠎꠦꠁꠘ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤꠀ ꠛꠣꠔꠥꠘꠤ ꠈꠛꠞ ꠖꠦꠈꠂꠘ, ꠄꠁꠘ ꠅꠈꠣꠘ ꠇꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_5","005_24_5","NUM","24","5","5","ꠅ ꠁꠀꠇꠥꠛ ꠛꠋꠡ, ꠔꠥꠝꠣꠞ ꠔꠣꠝ꠆ꠛꠥ ꠅꠇꠟ ꠈꠥꠛ ꠌꠇꠌꠇꠣ! ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠥꠝꠣꠞ ꠞꠅꠀꠞ ꠎꠣꠉꠣ ꠇꠔ ꠜꠣꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("NU24_6","005_24_6","NUM","24","6","6","ꠁꠔꠣ ꠔ ꠖꠦꠈꠣꠞ ꠝꠔ ꠛꠠ ꠈꠦꠎꠥꠞ ꠛꠣꠉꠣꠘꠞ ꠟꠣꠈꠣꠘ, ꠉꠣꠋꠉꠞ ꠙꠣꠞꠞ ꠢꠣꠎꠣꠁꠟ-ꠙꠣꠠꠣꠁꠟ ꠛꠘꠞ ꠟꠣꠈꠣꠘ, ꠝꠣꠛꠥꠖꠞ ꠟꠣꠉꠣꠁꠟ ꠀꠉꠞꠞ ꠉꠣꠍꠞ ꠟꠣꠈꠣꠘ ꠔꠞꠔꠣꠎꠣ, ꠙꠣꠘꠤꠞ ꠗꠣꠞꠞ ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍꠞ ꠟꠣꠈꠣꠘ ꠡꠥꠘ꠆ꠖꠞ। ");
INSERT INTO syls_vpl VALUES ("NU24_7","005_24_7","NUM","24","7","7","ꠔꠣꠞꠣꠞ ꠜꠞꠣ ꠇꠟꠡꠤ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠃꠕꠟꠤꠀ ꠙꠠꠛ, ꠛꠤꠌꠤ ꠀꠞ ꠌꠦꠞꠣꠄ ꠛꠃꠔ ꠙꠣꠘꠤ ꠙꠣꠁꠛ। ꠔꠣꠞꠣꠞ ꠛꠣꠖꠡꠣ ꠅꠁꠛꠣ ꠅꠉꠣꠉ ꠛꠣꠖꠡꠣ ꠕꠣꠇꠤꠅ ꠢꠤꠝ꠆ꠝꠔꠤ, ꠔꠣꠞꠣꠞ ꠖꠦꠡ ꠅꠁꠛ ꠘꠣꠝꠇꠞꠣ ꠁꠎ꠆ꠎꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("NU24_8","005_24_8","NUM","24","8","8","ꠀꠟ꠆ꠟꠣꠄ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠔꠣꠞꠣꠞ ꠙꠇ꠆ꠇꠦ ꠛꠟꠀꠟꠣ ꠎꠋꠟꠤ ꠛꠄꠞꠣ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠔ ꠎꠣꠔꠤꠄ ꠟꠣꠉꠛꠣ, ꠁꠔꠣꠞꠦ ꠔꠣꠞꠣ ꠉꠤꠟꠤꠀ ꠈꠣꠁꠟꠤꠛꠣ, ꠔꠣꠞꠣꠞ ꠀꠒ꠆ꠒꠤ-ꠉꠥꠒ꠆ꠒꠤꠞꠦ ꠉꠥꠠꠣ ꠉꠥꠠꠣ ꠇꠞꠛꠣ, ꠔꠤꠞ-ꠗꠘꠥꠇꠖꠤ ꠔꠣꠞꠣꠞꠦ ꠉꠣꠕꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_9","005_24_9","NUM","24","9","9","ꠡꠤꠋꠢꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠈꠣꠙ ꠗꠞꠤ ꠢꠥꠔꠤꠛ, ꠔꠣꠞꠣꠞꠦ ꠟꠣꠠꠣꠘꠤꠞ ꠡꠣꠅꠡ ꠅꠁꠛ ꠇꠥꠘ ꠛꠦꠐꠣꠞ? ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠞꠣ ꠖꠥꠀ ꠖꠤꠛꠣ, ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠖꠥꠀ ꠟꠣꠝꠃꠇ; ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣꠄ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠛꠣ, ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("NU24_10","005_24_10","NUM","24","10","10","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ। ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠔꠞ ꠙꠤꠑꠤꠔ ꠔꠣꠛꠠꠣꠁ ꠔꠣꠛꠠꠣꠁ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠈꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠀꠘꠣꠁꠟꠣꠝ ꠀꠝꠣꠞ ꠖꠥꠡꠝꠘꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠀꠙꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠟꠣꠉꠣꠁꠀ ꠔꠤꠘ-ꠔꠤꠘꠛꠣꠞ ꠖꠥꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_11","005_24_11","NUM","24","11","11","ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠢꠞꠃꠇ꠆ꠇꠣ, ꠘꠤꠎꠞ ꠎꠣꠉꠣꠔ ꠎꠣꠃꠇ꠆ꠇꠣ। ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠛꠃꠔ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠖꠤꠝꠥ ꠇꠁꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠖꠤꠟꠣ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU24_12","005_24_12","NUM","24","12","12","ꠔꠦꠃ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠙꠣꠑꠣꠁꠟ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠤ ꠀꠉꠦꠃ ꠇꠁꠍꠤ ꠘꠣ ꠘꠤ, ");
INSERT INTO syls_vpl VALUES ("NU24_13","005_24_13","NUM","24","13","13","ꠛꠣꠖꠡꠣꠄ ꠎꠥꠖꠤ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠄ ꠜꠞꠣ ꠔꠣꠘ ꠀꠡ꠆ꠔꠣ ꠞꠣꠎꠛꠣꠠꠤ ꠈꠣꠘꠃ ꠀꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠘ, ꠔꠦꠛꠃ ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠁꠌ꠆ꠍꠣꠄ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ, ꠀꠝꠤ ꠈꠣꠟꠤ ꠅꠟꠣꠃ ꠇꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("NU24_14","005_24_14","NUM","24","14","14","ꠔꠦ ꠀꠝꠤ ꠅꠈꠘ ꠀꠝꠣꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠔ ꠎꠣꠁꠞꠣꠝꠉꠤ, ꠅꠁꠟꠦ ꠅꠃ ꠎꠣꠔꠤꠄ ꠜꠛꠤꠡꠔꠦ ꠀꠙꠘꠣꠞ ꠎꠣꠔꠤꠞ ꠟꠉꠦ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠛꠣ, ꠀꠙꠘꠣꠞ ꠢꠥꠡꠤꠀꠞꠤꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠀꠉꠣꠝ ꠎꠣꠘꠣꠁ ꠖꠤꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("NU24_15","005_24_15","NUM","24","15","15","ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠅꠃ ꠀꠞꠇ ꠅꠢꠤ ꠇꠁꠟꠣ, “ꠛꠣꠃꠞꠞ ꠙꠥꠔ ꠛꠣꠟꠣꠝꠦ ꠇꠁꠞꠣ, ꠌꠃꠈ ꠎꠣꠞ ꠈꠥꠟꠣ ꠀꠍꠦ ꠄꠁꠘ ꠅꠃ ꠛꠥꠟꠤ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("NU24_16","005_24_16","NUM","24","16","16","ꠎꠦ ꠎꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠞꠣ, ꠎꠦꠁꠘ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠀꠍꠦ, ꠎꠦꠁꠘ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠞꠣ, ꠎꠦꠁꠘ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤꠀ ꠛꠣꠔꠥꠘꠤ ꠈꠛꠞ ꠖꠦꠈꠂꠘ, ꠄꠁꠘ ꠅꠈꠣꠘ ꠇꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_17","005_24_17","NUM","24","17","17","ꠀꠝꠤ ꠔ ꠢꠃ ꠎꠘꠞꠦ ꠖꠦꠈꠤꠀꠞ, ꠅꠈꠘ ꠍꠣꠝꠘꠦ ꠘꠣ ꠕꠣꠇꠟꠦꠅ ꠖꠦꠈꠤꠀꠞ। ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠘꠣ ꠅꠁꠟꠦꠅ, ꠀꠝꠣꠞ ꠌꠃꠈ ꠉꠤꠀ ꠔꠣꠘ ꠃꠙꠞꠦ ꠙꠠꠍꠦ। ꠁꠀꠇꠥꠛꠞ ꠛꠋꠡꠔ ꠀꠁꠛꠣ ꠀꠍꠝꠣꠘꠞ ꠄꠇ ꠔꠦꠞꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦꠃ ꠄꠇ ꠞꠣꠎ-ꠟꠣꠑꠤ ꠎꠘꠝꠤꠛꠣ। ꠄꠁꠘ ꠝꠥꠀꠛ ꠎꠣꠔꠤꠞ ꠝꠣꠕꠣ ꠚꠣꠐꠣꠁꠀ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠇꠞꠛꠣ, ꠡꠤꠡ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖꠞ ꠇꠟ꠆ꠟꠣ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_18","005_24_18","NUM","24","18","18","ꠁꠖꠥꠝ ꠖꠦꠡꠞꠦ ꠄꠘꠞ ꠖꠈꠟꠅ ꠀꠘꠛꠣ, ꠔꠣꠘ ꠖꠥꠡꠝꠘꠞ ꠅꠃ ꠍꠦꠁꠞ ꠙꠣꠠꠞꠦ ꠇꠛꠎꠣ ꠇꠞꠛꠣ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠄ ꠙꠄꠟꠥꠀꠘꠤ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU24_19","005_24_19","NUM","24","19","19","ꠁꠀꠇꠥꠛꠞ ꠛꠋꠡꠞ ꠄꠇꠎꠘꠦ ꠞꠣꠎ-ꠉꠖꠤ ꠌꠣꠟꠣꠁꠛꠣ, ꠁꠞ ꠐꠣꠃꠘꠅ ꠎꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠛꠣ ꠄꠁꠘ ꠔꠣꠞꠣꠞꠦꠅ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU24_20","005_24_20","NUM","24","20","20","ꠅꠈꠘꠣꠁꠘ ꠇꠅꠀꠞ ꠛꠣꠖꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠌꠃꠈ ꠝꠦꠟꠤꠀ ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠟꠣ। ꠖꠦꠈꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠅꠢꠤ ꠇꠁꠟꠣ, “ꠀꠝꠣꠟꠦꠇ ꠔ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠀꠍꠤꠟ ꠙꠞꠗꠣꠘ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠡꠦꠡ ꠖꠡꠣ ꠅꠁꠛ ꠡꠞ꠆ꠛꠘꠣꠡ।” ");
INSERT INTO syls_vpl VALUES ("NU24_21","005_24_21","NUM","24","21","21","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠦꠘꠤ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠟꠣ, ꠖꠦꠈꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠅꠢꠤ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠈꠥꠛ ꠝꠎꠛꠥꠔ, ꠔꠥꠝꠞꠣ ꠔ ꠙꠣꠔ꠆ꠔꠞꠞ ꠙꠣꠠꠅ ꠛꠣꠡꠣ ꠛꠣꠘꠣꠁꠍ, ");
INSERT INTO syls_vpl VALUES ("NU24_22","005_24_22","NUM","24","22","22","ꠅꠁꠟꠦ ꠀꠉꠦꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠘꠣꠡ ꠊꠐꠤꠛ, ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠀꠡꠤꠞꠤꠀ ꠖꠦꠡꠅ ꠘꠦꠅꠀ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU24_23","005_24_23","NUM","24","23","23","ꠛꠣꠖꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠅꠃ ꠡꠦꠡ ꠅꠢꠤ ꠇꠁꠟꠣ, “ꠢꠣꠄꠞꠦ ꠢꠣꠄ! ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠅꠔꠣ ꠊꠐꠣꠁꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠇꠦꠃ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠛ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("NU24_24","005_24_24","NUM","24","24","24","ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠖꠤꠙꠞ ꠎꠣꠎ ꠅꠇꠟ ꠀꠁꠛ, ꠀꠁꠀ ꠀꠡꠤꠞꠤꠀꠞꠦ ꠖꠥꠞ꠆ꠖꠡꠣ ꠖꠤꠛ, ꠀꠛꠦꠞꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠖꠝꠣꠁꠛ, ꠅꠁꠟꠦ ꠅꠃ ꠖꠤꠙ ꠘꠤꠎꠦꠅ ꠛꠣꠖꠦ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU24_25","005_24_25","NUM","24","25","25","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠛꠣꠟꠣꠝ ꠙꠤꠞ ꠃꠑꠤꠀ ꠘꠤꠎꠞ ꠊꠞꠅ ꠉꠦꠟꠣꠉꠤ, ꠛꠣꠟꠣꠇ ꠛꠣꠖꠡꠣꠅ ꠔꠣꠘ ꠙꠕꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU25_1","005_25_1","NUM","25","1","1","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠡꠤꠐꠤꠝ ꠄꠟꠣꠇꠣꠔ ꠛꠡꠔ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠅꠘꠅ ꠞꠁꠀ ꠞꠁꠀ ꠝꠥꠀꠛꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU25_2","005_25_2","NUM","25","2","2","ꠢꠘꠞ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠘꠣꠝꠦ ꠛꠟꠤ ꠖꠤꠛꠣꠞ ꠅꠘꠥꠡ꠆ꠐꠣꠘꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠟꠣ, ꠀꠞ ꠄꠞꠣ ꠉꠤꠀ ꠅꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠈꠣꠁꠀ ꠢꠃ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU25_3","005_25_3","NUM","25","3","3","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠞꠣ ꠢꠘꠞ ꠙꠤꠃꠞ ꠙꠣꠠꠞ ꠛꠣꠀꠟ ꠖꠦꠛꠔꠣꠞ ꠙꠥꠎꠣ-ꠜꠇ꠆ꠔꠤ ꠖꠦꠅꠀꠔ ꠟꠣꠉꠤ ꠉꠦꠟꠣ। ꠄꠞꠖꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠎꠛꠞ ꠀꠉꠥꠁꠘ ꠎꠟꠤꠀ ꠃꠑꠟ। ");
INSERT INTO syls_vpl VALUES ("NU25_4","005_25_4","NUM","25","4","4","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠡꠝꠣꠎꠞ ꠖꠥꠡꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠗꠞꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠅ, ꠀꠞ ꠅꠔꠣꠞ ꠟꠣꠡ ꠞꠂꠖꠞ ꠝꠣꠎꠦ ꠀꠘꠤꠀ ꠟꠐꠇꠣꠁ ꠕꠅ। ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠢꠃ ꠟꠣꠘ꠆ꠘꠔꠤ ꠉꠎꠛ ꠢꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU25_5","005_25_5","NUM","25","5","5","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠣꠇꠤꠝ-ꠡꠣꠟꠤꠡ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠕꠣꠇꠣ ꠎꠔ ꠝꠣꠘꠡꠦ ꠙꠤꠃꠞ ꠙꠣꠠꠞ ꠛꠣꠀꠟ ꠖꠦꠛꠔꠣꠞ ꠙꠥꠎꠣꠔ ꠡꠞꠤꠇ ꠅꠁꠍꠦ, ꠅꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU25_6","005_25_6","NUM","25","6","6","ꠄꠞꠝꠣꠎꠦ ꠅꠟꠣ ꠅꠁꠟ, ꠝꠥꠍꠣ ꠘꠛꠤ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠝꠤꠟꠤꠀ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦꠖꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠄꠇ ꠛꠦꠐꠣꠄ ꠝꠣꠖꠤꠀꠘꠤ ꠄꠇ ꠛꠦꠐꠤꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU25_7","005_25_7","NUM","25","7","7","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠘꠣꠔꠤ ꠙꠤꠘꠢꠡ ꠛꠤꠘ ꠀꠟꠤ-ꠀꠎꠞ ꠝꠎꠟꠤꠍ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠄꠇꠈꠣꠘ ꠍꠥꠟꠚꠤ ꠀꠔꠅ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU25_8","005_25_8","NUM","25","8","8","ꠟꠁꠀ ꠔꠣꠞꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠉꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠃ ꠛꠦꠐꠣꠞ ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠁꠀ ꠔꠣꠞ ꠀꠞ ꠢꠃ ꠛꠦꠐꠤꠞ ꠙꠦꠐꠦꠖꠤ ꠉꠣꠕꠤꠟ꠆ꠟꠣ। ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛ ꠢꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU25_9","005_25_9","NUM","25","9","9","ꠅꠁꠟꠦ ꠅꠃ ꠉꠎꠛꠞ ꠝꠣꠎꠦ ꠌꠛ꠆ꠛꠤꠡ ꠀꠎꠣꠞ ꠝꠣꠘꠥꠡ ꠝꠞꠤꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU25_10","005_25_10","NUM","25","10","10","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU25_11","005_25_11","NUM","25","11","11","“ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠘꠣꠔꠤ ꠙꠤꠘꠢꠡ ꠛꠤꠘ ꠀꠟꠤ-ꠀꠎꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠉꠎꠛ ꠢꠞꠣꠁꠍꠦ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠀꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠁꠎ꠆ꠎꠔ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠦ ꠔ ꠀꠝꠣꠞ ꠎꠣꠟꠣꠄꠃ ꠎꠟꠦꠞ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠁꠎ꠆ꠎꠔ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠘꠞ ꠎꠣꠟꠣ ꠕꠣꠇꠟꠦꠅ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠀꠞ ꠝꠣꠞꠟꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU25_12","005_25_12","NUM","25","12","12","ꠔꠦ ꠅꠈꠘ ꠔꠥꠝꠤ ꠔꠣꠞꠦ ꠇꠅ, ꠀꠝꠤ ꠔꠣꠞ ꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠈꠣꠍ ꠡꠣꠘ꠆ꠔꠤ-ꠌꠥꠇ꠆ꠔꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU25_13","005_25_13","NUM","25","13","13","ꠢꠦ ꠔꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠅꠘꠣ ꠁꠎ꠆ꠎꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠘꠤꠎꠞ ꠁꠌ꠆ꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠄ, ꠀꠝꠤꠅ ꠔꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠡꠣꠘ꠆ꠔꠤ-ꠌꠥꠇ꠆ꠔꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠤ। ꠄꠞꠟꠣꠉꠤ ꠁꠝꠣꠝꠔꠤꠞ ꠙꠖ ꠢꠦ ꠀꠞ ꠔꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠝꠣꠎꠦ ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU25_14","005_25_14","NUM","25","14","14","ꠝꠣꠖꠤꠀꠘꠤ ꠢꠃ ꠛꠦꠐꠤꠞ ꠟꠉꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠦ ꠛꠦꠐꠣꠞꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ, ꠢꠦ ꠅꠁꠟ ꠍꠣꠟꠥꠞ ꠙꠥꠀ ꠎꠤꠝꠞꠤ, ꠢꠦ ꠔ ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠇ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠦꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU25_15","005_25_15","NUM","25","15","15","ꠀꠞ ꠎꠦ ꠝꠣꠖꠤꠀꠘꠤ ꠛꠦꠐꠤꠞꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ, ꠔꠣꠁꠞ ꠘꠣꠝ ꠇꠍꠛꠤ, ꠔꠣꠁ ꠀꠍꠤꠟ ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠞ ꠡꠥꠞ ꠘꠣꠝꠞ ꠄꠇ ꠘꠦꠔꠣꠞ ꠙꠥꠠꠤ, ꠅꠃ ꠡꠥꠞꠅ ꠅꠁꠟꠣ ꠄꠇ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠦꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU25_16","005_25_16","NUM","25","16","16","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU25_17","005_25_17","NUM","25","17","17","“ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠝꠘꠅ ꠇꠞꠤꠅ, ꠁꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU25_18","005_25_18","NUM","25","18","18","ꠇꠣꠞꠘ ꠙꠤꠃꠞꠞ ꠖꠦꠛꠔꠣꠞ ꠙꠥꠎꠣ ꠀꠞ ꠇꠍꠛꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠚꠣꠘ꠆ꠖ ꠙꠣꠔꠣꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠜꠥꠟ ꠙꠕꠦ ꠘꠦꠅꠀꠄ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠛꠘꠍꠦ। ꠀꠞ ꠔꠥꠝꠤ ꠔ ꠎꠣꠘ, ꠅꠃ ꠇꠍꠛꠤ ꠀꠍꠤꠟ ꠔꠣꠞꠣꠞ ꠇꠥꠐꠥꠝ, ꠔꠣꠁ ꠔ ꠝꠣꠖꠤꠀꠘꠤ ꠄꠇ ꠡꠞ꠆ꠖꠣꠞꠞ ꠙꠥꠠꠤ। ꠙꠤꠃꠞꠞ ꠛꠣꠀꠟ ꠖꠦꠛꠔꠣꠞꠦ ꠙꠥꠎꠣ ꠇꠞꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠛꠟꠣ ꠟꠣꠘ꠆ꠘꠔꠤ ꠉꠎꠛ ꠟꠣꠝꠍꠤꠟ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("NU26_1","005_26_1","NUM","26","1","1","ꠟꠣꠘ꠆ꠘꠔꠤ ꠅꠃ ꠉꠎꠛ ꠕꠣꠝꠤ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠀꠞ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU26_2","005_26_2","NUM","26","2","2","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ, ꠝꠣꠘꠤ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠎꠁꠉ꠆ꠉ ꠎꠦꠞꠣ ꠅꠁꠉꠦꠍꠦ, ꠄꠞꠣꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠉꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU26_3","005_26_3","NUM","26","3","3","ꠄꠞꠟꠣꠉꠤ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠃꠟꠐꠣꠛꠣꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠅ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠎꠦ ꠔꠟ ꠎꠣꠉꠣ ꠀꠍꠦ, ꠢꠘꠅ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠀꠞ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU26_4","005_26_4","NUM","26","4","4","“ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠂꠘ, ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠤ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞꠦ ꠉꠘꠅ।” ꠔꠦꠃ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠔ ꠛꠦꠐꠣꠁꠘ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠟꠣ, ꠉꠘꠣꠞ ꠡꠝꠄ ꠄꠞꠣꠞ ꠛꠋꠡꠗꠞꠞ ꠘꠣꠝ ꠟꠦꠈꠣ ꠅꠁꠟ। ꠄꠞꠣ ꠅꠁꠟꠣ: ");
INSERT INTO syls_vpl VALUES ("NU26_5","005_26_5","NUM","26","5","5","ꠁꠀꠇꠥꠛ ꠃꠞꠚꠦ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠠ ꠙꠥꠀ ꠞꠥꠛꠦꠘꠞ ꠌꠣꠁꠞꠅ ꠙꠥꠀꠞ ꠛꠋꠡꠗꠞ: ꠞꠥꠛꠦꠘꠞ ꠛꠠ ꠙꠥꠀ ꠢꠘꠥꠇ ꠕꠣꠇꠤ ꠢꠘꠥꠇꠤ ꠛꠋꠡ, ꠚꠣꠟꠥ ꠕꠣꠇꠤ ꠚꠣꠟꠥꠁ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_6","005_26_6","NUM","26","6","6","ꠢꠣꠍꠤꠞ ꠕꠣꠇꠤ ꠢꠣꠍꠤꠞꠤ ꠛꠋꠡ, ꠀꠞ ꠇꠞ꠆ꠝꠤ ꠕꠣꠇꠤ ꠇꠞ꠆ꠝꠤꠀ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_7","005_26_7","NUM","26","7","7","ꠄꠞꠣ ꠢꠇꠟꠃ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠔꠦꠔꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠔꠤꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_8","005_26_8","NUM","26","8","8","ꠚꠣꠟꠥꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠁꠟꠤꠀꠛ, ");
INSERT INTO syls_vpl VALUES ("NU26_9","005_26_9","NUM","26","9","9","ꠁꠟꠤꠀꠛꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠘꠝꠥꠄꠟ, ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝ। ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠥꠁꠎꠘ ꠘꠦꠔꠣ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠟꠣꠉꠟꠣ। ꠀꠞ ꠇꠥꠞꠣꠢꠞ ꠖꠟ ꠎꠦꠛꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠍꠤꠟ, ꠅꠃ ꠡꠝꠄ ꠄꠞꠣꠅ ꠇꠥꠞꠣꠢꠞ ꠖꠟꠅ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU26_10","005_26_10","NUM","26","10","10","ꠇꠥꠞꠣꠢꠞ ꠟꠉꠦ ꠅꠃ ꠖꠥꠁꠎꠘꠞꠦꠅ ꠝꠣꠐꠤꠄ ꠀ ꠇꠞꠤ ꠉꠤꠟꠤꠟꠤꠍꠤꠟ ꠀꠞ ꠔꠣꠞ ꠖꠟꠞ ꠀꠠꠣꠁ-ꠡ ꠎꠘ ꠀꠉꠥꠁꠘꠦ ꠎꠟꠤꠀ ꠝꠞꠍꠤꠟ। ꠁꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠢꠥꠡꠤꠀꠞꠤꠞ ꠘꠤꠡꠣꠘꠣ ꠅꠁꠀ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_11","005_26_11","NUM","26","11","11","ꠅꠁꠟꠦ ꠇꠥꠞꠣꠢꠞ ꠙꠥꠀꠂꠘ ꠢꠤ ꠡꠝꠄ ꠝꠞꠍꠂꠘ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠛꠋꠡ ꠎꠣꠞꠤ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU26_12","005_26_12","NUM","26","12","12","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠡꠤꠝꠤꠅꠘꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠘꠝꠥꠄꠟ ꠕꠣꠇꠤ ꠘꠝꠥꠄꠟꠤ ꠛꠋꠡ, ꠎꠣꠝꠤꠘ ꠕꠣꠇꠤ ꠎꠣꠝꠤꠘꠤ ꠛꠋꠡ, ꠎꠣꠈꠤꠘ ꠕꠣꠇꠤ ꠎꠣꠈꠤꠘꠤ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_13","005_26_13","NUM","26","13","13","ꠎꠣꠞꠣꠢ ꠕꠣꠇꠤ ꠎꠣꠞꠣꠢꠤ ꠛꠋꠡ ꠀꠞ ꠡꠃꠟ ꠕꠣꠇꠤ ꠡꠃꠟꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_14","005_26_14","NUM","26","14","14","ꠁꠔꠣ ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠛꠣꠁꠡ ꠀꠎꠣꠞ ꠖꠥꠁ-ꠡ ꠎꠘ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_15","005_26_15","NUM","26","15","15","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠍꠣꠖꠥꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠍꠤꠚꠘ ꠕꠣꠇꠤ ꠍꠤꠚꠘꠤ ꠛꠋꠡ, ꠢꠉꠤ ꠕꠣꠇꠤ ꠢꠉꠤꠀ ꠛꠋꠡ, ꠡꠥꠘꠤ ꠕꠣꠇꠤ ꠡꠥꠘꠤꠀ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_16","005_26_16","NUM","26","16","16","ꠅꠎꠘꠤ ꠕꠣꠇꠤ ꠅꠎꠘꠤꠀ ꠛꠋꠡ, ꠄꠁꠞꠤ ꠕꠣꠇꠤ ꠄꠁꠞꠤꠀ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_17","005_26_17","NUM","26","17","17","ꠅꠞꠥꠖ ꠕꠣꠇꠤ ꠅꠞꠥꠖꠤ ꠛꠋꠡ, ꠀꠞ ꠅꠞꠦꠟꠤ ꠕꠣꠇꠤ ꠅꠞꠦꠟꠤꠀ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_18","005_26_18","NUM","26","18","18","ꠄꠞꠣ ꠅꠁꠟꠣ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠉꠘꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ ꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU26_19","005_26_19","NUM","26","19","19","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠄꠢꠥꠖꠣꠞ ꠖꠥꠁ ꠙꠥꠀꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠄꠁꠞ ꠀꠞ ꠅꠘꠘ, ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠕꠣꠇꠣꠞ ꠇꠣꠟꠅ ꠄꠞꠣ ꠝꠣꠞꠣ ꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_20","005_26_20","NUM","26","20","20","ꠅꠁꠟꠦ ꠄꠢꠥꠖꠣꠞ ꠀꠞꠅ ꠙꠥꠀꠂꠘ ꠀꠍꠟꠣ, ꠄꠞꠣꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠡꠦꠟꠣ ꠕꠣꠇꠤ ꠡꠦꠟꠣꠄꠁ ꠛꠋꠡ, ꠚꠤꠞꠥꠎ ꠕꠣꠇꠤ ꠚꠤꠞꠥꠎꠤ, ꠎꠣꠞꠣꠢ ꠕꠣꠇꠤ ꠎꠣꠞꠣꠢꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_21","005_26_21","NUM","26","21","21","ꠚꠤꠞꠥꠎꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ ꠢꠣꠍꠤꠞ ꠕꠣꠇꠤ ꠢꠣꠍꠤꠞꠤ ꠛꠋꠡ ꠀꠞ ꠢꠣꠝꠥꠟ ꠕꠣꠇꠤ ꠢꠣꠝꠥꠟꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_22","005_26_22","NUM","26","22","22","ꠄꠞꠣ ꠢꠇꠟꠃ ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠍꠤꠅꠔ꠆ꠔꠁꠞ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_23","005_26_23","NUM","26","23","23","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠁꠍꠣꠈꠞꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠔꠟꠣ ꠕꠣꠇꠤ ꠔꠟꠣꠄꠁ ꠛꠋꠡ, ꠚꠅꠀ ꠕꠣꠇꠤ ꠚꠅꠀꠁ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_24","005_26_24","NUM","26","24","24","ꠎꠣꠡꠥꠛ ꠕꠣꠇꠤ ꠎꠣꠡꠥꠛꠤ ꠛꠋꠡ ꠀꠞ ꠡꠤꠝꠞꠘ ꠕꠣꠇꠤ ꠡꠝꠞꠘꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_25","005_26_25","NUM","26","25","25","ꠄꠞꠣ ꠢꠇꠟ ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠌꠃꠡꠐ꠆ꠐꠤ ꠀꠎꠣꠞ ꠔꠤꠘ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_26","005_26_26","NUM","26","26","26","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠍꠛꠥꠟꠘꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ ꠍꠦꠞꠦꠖ ꠕꠣꠇꠤ ꠍꠦꠞꠦꠖꠤ ꠛꠋꠡ, ꠄꠟꠘ ꠕꠣꠇꠤ ꠄꠟꠘꠤ ꠛꠋꠡ ꠀꠞ ꠎꠢꠟꠦꠟ ꠕꠣꠇꠤ ꠎꠢꠟꠦꠟꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_27","005_26_27","NUM","26","27","27","ꠄꠞꠣ ꠢꠇꠟ ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠡꠣꠁꠐ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_28","005_26_28","NUM","26","28","28","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠝꠣꠘꠡꠣ ꠀꠞ ꠀꠚꠞꠣꠁꠝ। ");
INSERT INTO syls_vpl VALUES ("NU26_29","005_26_29","NUM","26","29","29","ꠄꠞꠣꠞ ꠝꠣꠎꠦ, ꠝꠣꠘꠡꠣꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠝꠣꠈꠤꠞ ꠕꠣꠇꠤ ꠝꠣꠈꠤꠞꠤ ꠛꠋꠡ, ꠀꠞ ꠝꠣꠈꠤꠞꠞ ꠙꠥꠀ ꠉꠤꠟꠤꠅꠖ ꠕꠣꠇꠤ ꠉꠤꠟꠤꠅꠖꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_30","005_26_30","NUM","26","30","30","ꠉꠤꠟꠤꠅꠖꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ ꠁꠀꠎꠤꠞ ꠕꠣꠇꠤ ꠁꠀꠎꠤꠞꠤ ꠛꠋꠡ, ꠢꠦꠟꠇ ꠕꠣꠇꠤ ꠢꠦꠟꠇꠤ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_31","005_26_31","NUM","26","31","31","ꠅꠍꠞꠤꠄꠟ ꠕꠣꠇꠤ ꠅꠍꠞꠤꠄꠟꠤ ꠛꠋꠡ, ꠡꠦꠈꠝ ꠕꠣꠇꠤ ꠡꠦꠈꠝꠤ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_32","005_26_32","NUM","26","32","32","ꠡꠤꠝꠤꠖꠣ ꠕꠣꠇꠤ ꠡꠤꠝꠤꠖꠣꠁ ꠛꠋꠡ ꠀꠞ ꠢꠦꠚꠞ ꠕꠣꠇꠤ ꠢꠦꠚꠞꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_33","005_26_33","NUM","26","33","33","ꠢꠦꠚꠞꠞ ꠙꠥꠀ ꠎꠟꠣꠙꠈꠣꠖ, ꠔꠣꠞ ꠇꠥꠘꠥ ꠙꠥꠀꠂꠘ ꠀꠍꠟꠣ ꠘꠣ, ꠈꠣꠟꠤ ꠙꠥꠠꠤꠘ ꠀꠍꠟꠣ। ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ, ꠝꠢꠟꠣ, ꠘꠥꠀ, ꠢꠉꠟꠣ, ꠝꠤꠟꠇꠣ ꠀꠞ ꠔꠤꠞꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("NU26_34","005_26_34","NUM","26","34","34","ꠄꠞꠣ ꠢꠇꠟꠃ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠛꠣꠄꠀꠘ꠆ꠘ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_35","005_26_35","NUM","26","35","35","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠀꠚꠞꠣꠁꠝꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠡꠥꠔꠟꠢ ꠕꠣꠇꠤ ꠡꠥꠔꠟꠢꠤ, ꠛꠦꠈꠞ ꠕꠣꠇꠤ ꠛꠦꠈꠞꠤ ꠀꠞ ꠔꠢꠘ ꠕꠣꠇꠤ ꠔꠢꠘꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_36","005_26_36","NUM","26","36","36","ꠡꠥꠔꠟꠢꠞ ꠛꠋꠡ, ꠄꠞꠘ ꠕꠣꠇꠤ ꠄꠞꠘꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_37","005_26_37","NUM","26","37","37","ꠄꠞꠣ ꠢꠇꠟ ꠀꠚꠞꠣꠁꠝ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠛꠔ꠆ꠔꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ꠈꠣꠘ꠆ꠖꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠄꠞꠣ ꠢꠇꠟꠃ ꠁꠃꠍꠥꠚꠞ ꠛꠋꠡꠗꠞ। ");
INSERT INTO syls_vpl VALUES ("NU26_38","005_26_38","NUM","26","38","38","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠛꠤꠘ-ꠁꠀꠝꠤꠘꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠛꠦꠟꠣ ꠕꠣꠇꠤ ꠛꠦꠟꠣꠄꠁ ꠛꠋꠡ, ꠅꠡꠛꠦꠟ ꠕꠣꠇꠤ ꠅꠡꠛꠦꠟꠤ ꠛꠋꠡ, ꠀꠢꠤꠞꠣꠝ ꠕꠣꠇꠤ ꠀꠢꠤꠞꠣꠝꠤ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_39","005_26_39","NUM","26","39","39","ꠡꠥꠚꠝ ꠕꠣꠇꠤ ꠡꠥꠚꠝꠤ ꠛꠋꠡ, ꠀꠞ ꠢꠥꠚꠝ ꠕꠣꠇꠤ ꠢꠥꠚꠝꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_40","005_26_40","NUM","26","40","40","ꠛꠦꠟꠣꠞ ꠙꠥꠀꠂꠘ ꠅꠞ꠆ꠖ ꠀꠞ ꠘꠣꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ ꠛꠦꠟꠣꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠅꠞ꠆ꠖ ꠕꠣꠇꠤ ꠅꠞ꠆ꠖꠤ ꠛꠋꠡ ꠀꠞ ꠘꠣꠝꠣꠘ ꠕꠣꠇꠤ ꠘꠣꠝꠣꠘꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_41","005_26_41","NUM","26","41","41","ꠄꠞꠣ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠙꠄꠔꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_42","005_26_42","NUM","26","42","42","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠖꠣꠘꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠡꠥꠢꠝ ꠕꠣꠇꠤ ꠡꠥꠢꠝꠤ ꠛꠋꠡ। ꠄꠞꠣꠃ ꠀꠍꠟꠣ ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_43","005_26_43","NUM","26","43","43","ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠌꠃꠡꠐ꠆ꠐꠤ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_44","005_26_44","NUM","26","44","44","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠀꠡꠤꠞꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠁꠝꠘꠣ ꠕꠣꠇꠤ ꠁꠝꠘꠣꠄꠁ ꠛꠋꠡ, ꠎꠤꠍꠛꠤ ꠕꠣꠇꠤ ꠎꠤꠍꠛꠤꠀ ꠛꠋꠡ ꠀꠞ ꠛꠞꠤꠀ ꠕꠣꠇꠤ ꠛꠞꠤꠀꠄꠁ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_45","005_26_45","NUM","26","45","45","ꠛꠞꠤꠀꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ ꠢꠦꠛꠞ ꠕꠣꠇꠤ ꠢꠦꠛꠞꠤ ꠛꠋꠡ, ꠀꠞ ꠝꠟꠇꠤꠄꠟ ꠕꠣꠇꠤ ꠝꠟꠇꠤꠄꠟꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_46","005_26_46","NUM","26","46","46","ꠀꠡꠤꠞꠞ ꠙꠥꠠꠤꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠍꠦꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("NU26_47","005_26_47","NUM","26","47","47","ꠄꠞꠣ ꠢꠇꠟꠃ ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠔꠦꠙ꠆ꠙꠣꠘ꠆ꠘ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_48","005_26_48","NUM","26","48","48","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠘꠙ꠆ꠔꠣꠟꠤꠞ ꠛꠋꠡꠗꠞ ꠅꠁꠟꠣ, ꠎꠢꠡꠤꠄꠟ ꠕꠣꠇꠤ ꠎꠢꠡꠤꠄꠟꠤ ꠛꠋꠡ, ꠉꠥꠘꠤ ꠕꠣꠇꠤ ꠉꠥꠘꠤꠀ ꠛꠋꠡ, ");
INSERT INTO syls_vpl VALUES ("NU26_49","005_26_49","NUM","26","49","49","ꠁꠎꠦꠞ ꠕꠣꠇꠤ ꠁꠎꠦꠞꠤ ꠛꠋꠡ, ꠀꠞ ꠡꠤꠟ꠆ꠟꠦꠝ ꠕꠣꠇꠤ ꠡꠤꠟ꠆ꠟꠦꠝꠤ ꠛꠋꠡ। ");
INSERT INTO syls_vpl VALUES ("NU26_50","005_26_50","NUM","26","50","50","ꠄꠞꠣ ꠢꠇꠟꠃ ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠛꠋꠡ। ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠉꠘꠤꠀ ꠙꠄꠔꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠌꠣꠁꠞ-ꠡ ꠎꠘꠞꠦ ꠙꠣꠅꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_51","005_26_51","NUM","26","51","51","ꠔꠦ ꠉꠘꠣꠞ ꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠙꠞꠤꠝꠣꠘ ꠅꠁꠟ, ꠝꠥꠐ ꠍꠄ ꠟꠣꠈ ꠄꠇ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠔꠤꠡ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("NU26_52","005_26_52","NUM","26","52","52","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU26_53","005_26_53","NUM","26","53","53","“ꠉꠘꠣ ꠅꠃ ꠝꠣꠘꠥꠡ ꠝꠣꠚꠤꠇ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠎꠝꠤꠘ ꠛꠣꠐꠤꠀ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠎꠣꠔꠦ ꠢꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠛꠣꠐ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU26_54","005_26_54","NUM","26","54","54","ꠎꠦ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ ꠛꠦꠡꠤ ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠛꠦꠡꠤ ꠀꠞ ꠎꠦ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ ꠇꠝ, ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠇꠝ ꠎꠣꠉꠣ ꠖꠤꠛꠣꠄ। ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠝꠣꠘꠥꠡ ꠢꠤꠡꠣꠛꠦ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU26_55","005_26_55","NUM","26","55","55","ꠀꠞ ꠇꠥꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠎꠝꠤꠘ ꠙꠣꠁꠛ, ꠁꠔꠣ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠑꠤꠇ ꠇꠞꠣ ꠅꠁꠛ। ꠙꠞꠔꠦꠇ ꠛꠋꠡꠞ ꠙꠣꠅꠘꠣ ꠅꠋꠡ ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀ ꠄꠟꠣꠇꠣꠞ ꠝꠣꠎꠦꠃ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("NU26_56","005_26_56","NUM","26","56","56","ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ ꠇꠝ ꠛꠣ ꠛꠦꠡꠤ ꠎꠦꠐꠣꠃ ꠅꠃꠇ, ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠎꠣꠉꠣ ꠑꠤꠇ ꠇꠞꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU26_57","005_26_57","NUM","26","57","57","ꠢꠇꠟ ꠢꠦꠡꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠋꠡꠗꠞ ꠉꠘꠣ ꠅꠁꠟ। ꠄꠞꠣ ꠅꠁꠟꠣ, ꠎꠣꠞꠍꠥꠘ ꠕꠣꠇꠤ ꠎꠣꠞꠍꠥꠘꠤ ꠉꠥꠡ꠆ꠐꠤ, ꠇꠣꠢꠣꠔ ꠕꠣꠇꠤ ꠇꠣꠢꠣꠔꠤ ꠉꠥꠡ꠆ꠐꠤ ꠀꠞ ꠝꠣꠞꠣꠞꠤ ꠕꠣꠇꠤ ꠝꠣꠞꠣꠞꠤꠀ ꠉꠥꠡ꠆ꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("NU26_58","005_26_58","NUM","26","58","58","ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠇꠤꠍꠥ ꠘꠣꠝꠇꠞꠣ ꠙꠞꠤꠛꠣꠞ ꠀꠍꠤꠟ, ꠄꠞꠣꠞ ꠝꠥꠟ ꠛꠣꠚꠞ ꠘꠣꠝ ꠅꠁꠟ ꠟꠤꠛꠘꠤ, ꠢꠦꠛꠞꠘ, ꠝꠢꠟꠤ, ꠝꠥꠡꠤ ꠀꠞ ꠇꠥꠞꠣꠢ। ꠇꠣꠢꠣꠔꠞ ꠄꠇ ꠙꠥꠀꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠁꠝꠞꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("NU26_59","005_26_59","NUM","26","59","59","ꠁꠝꠞꠣꠘꠞ ꠛꠃꠞ ꠘꠣꠝ ꠁꠃꠈꠣꠛꠦꠎ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠕꠣꠇꠔꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠄꠘ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ꠄꠘ ꠙꠦꠐ ꠕꠣꠇꠤ ꠁꠝꠞꠣꠘꠞ ꠙꠥꠀꠂꠘ ꠢꠣꠞꠥꠘ ꠀꠞ ꠝꠥꠍꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠁꠘ ꠝꠞꠤꠅꠝꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_60","005_26_60","NUM","26","60","60","ꠢꠣꠞꠥꠘꠞ ꠙꠥꠀꠂꠘ ꠅꠁꠟꠣ ꠘꠣꠖꠣꠛ, ꠀꠛꠤꠢꠥ, ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠁꠍꠣꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU26_61","005_26_61","NUM","26","61","61","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠜꠣꠋꠉꠤꠀ ꠖꠥꠍꠞꠣ ꠀꠉꠥꠁꠘ ꠖꠤꠀ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠔ ꠉꠤꠀ ꠘꠣꠖꠣꠛ ꠀꠞ ꠀꠛꠤꠢꠥ ꠅꠃ ꠖꠥꠁ ꠎꠘꠞ ꠝꠞꠘ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU26_62","005_26_62","NUM","26","62","62","ꠄꠇ ꠝꠣꠡ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠞ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠙꠞꠤꠝꠣꠘ ꠀꠍꠤꠟ ꠔꠦꠁꠡ ꠀꠎꠣꠞ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠜꠤꠔꠞꠦ ꠄꠞꠣꠞꠦ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠦꠅꠀ ꠅꠁꠍꠦ ꠘꠣ ꠉꠔꠤꠇꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠉꠦ ꠄꠞꠣꠞꠦ ꠄꠇꠟꠉꠦ ꠉꠘꠣꠅ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU26_63","005_26_63","NUM","26","63","63","ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠃꠟꠐꠣꠛꠣꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠗꠣꠞꠅ ꠝꠥꠀꠛꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠝꠣꠘꠥꠡ ꠉꠘꠣꠞ ꠡꠝꠄ ꠝꠥꠍꠣ ꠘꠛꠤ ꠀꠞ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠉꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU26_64","005_26_64","NUM","26","64","64","ꠅꠁꠟꠦ ꠙꠄꠟꠣ ꠛꠣꠞ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠥꠍꠣ ꠀꠞ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠣꠞꠣꠞꠦ ꠉꠘꠤꠍꠟꠣ, ꠅꠃ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠉꠘꠣꠞ ꠡꠝꠄ ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU26_65","005_26_65","NUM","26","65","65","ꠀꠍꠟꠦ ꠅꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦꠃ ꠇꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠘꠤꠌ꠆ꠌꠄ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠣꠞꠣ ꠎꠣꠁꠛꠣ। ꠀꠞ ꠢꠣꠍꠣꠃ ꠈꠣꠟꠤ ꠎꠤꠚꠥꠘ꠆ꠘꠤꠞ ꠙꠥꠀ ꠇꠣꠟꠥꠔ ꠀꠞ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ ꠍꠣꠠꠣ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU27_1","005_27_1","NUM","27","1","1","ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠝꠣꠘꠡꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠟꠣꠙꠈꠣꠖꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠍꠤꠟꠍꠤꠟꠣ ꠅꠁꠟ, ꠝꠣꠘꠡꠣꠞ ꠙꠥꠀ ꠝꠣꠈꠤꠞ, ꠝꠣꠈꠤꠞꠞ ꠙꠥꠀ ꠉꠤꠟꠤꠅꠖ, ꠉꠤꠟꠤꠅꠖꠞ ꠙꠥꠀ ꠢꠦꠚꠞ ꠀꠞ ꠢꠦꠚꠞꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠎꠟꠣꠙꠈꠣꠖ। ꠎꠟꠣꠙꠈꠣꠖꠞ ꠙꠥꠠꠤꠘ ꠅꠁꠟꠣ ꠝꠢꠟꠣ, ꠘꠥꠀ, ꠢꠉꠟꠣ, ꠝꠤꠟꠇꠣ ꠀꠞ ꠔꠤꠞꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("NU27_2","005_27_2","NUM","27","2","2","ꠅꠃ ꠙꠥꠠꠤꠘ ꠀꠁꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠀ ꠝꠥꠍꠣ ꠘꠛꠤ, ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ, ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠀꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU27_3","005_27_3","NUM","27","3","3","“ꠀꠝꠞꠣꠞ ꠛꠣꠛꠣ ꠔ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ। ꠀꠞ ꠇꠥꠞꠣꠢꠞ ꠖꠟꠞ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠍꠟꠣ, ꠔꠣꠁꠘ ꠔ ꠁꠔꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠈꠣꠟꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠥꠘꠣꠞ ꠖꠣꠄ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ। ꠀꠞ ꠀꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠜꠣꠁ ꠎꠘꠝꠤꠍꠂꠘ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("NU27_4","005_27_4","NUM","27","4","4","ꠔꠦ ꠜꠣꠁ ꠘꠣ ꠕꠣꠇꠣꠄ ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠛꠣꠚꠞ ꠘꠣꠝ ꠇꠤꠔꠣ ꠁ ꠛꠋꠡ ꠕꠣꠇꠤ ꠝꠤꠐꠤꠎꠤꠔ ꠘꠤ? ꠔꠣꠘ ꠡꠞꠤꠇꠣꠘꠞ ꠟꠉꠦ ꠀꠝꠞꠣꠞꠦꠅ ꠎꠣꠉꠣ-ꠎꠝꠤꠘꠞ ꠛꠣꠐ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU27_5","005_27_5","NUM","27","5","5","ꠔꠦꠃ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠞꠎ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU27_6","005_27_6","NUM","27","6","6","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU27_7","005_27_7","NUM","27","7","7","“ꠎꠟꠣꠙꠈꠣꠖꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠑꠤꠇ ꠇꠕꠣꠃ ꠇꠁꠍꠦ। ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞ ꠡꠞꠤꠇꠣꠘꠞ ꠟꠉꠦ ꠔꠣꠞꠣꠞꠦꠅ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠛꠣꠐ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠔꠣꠞꠣ ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠣꠁꠔꠤ ꠎꠝꠤꠘ ꠙꠣꠁꠘ, ꠁꠈꠣꠘ ꠔꠥꠝꠤ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU27_8","005_27_8","NUM","27","8","8","ꠀꠞ ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠝꠞꠣꠞ ꠇꠣꠟꠅ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠙꠥꠀꠂꠘ ꠘꠣ ꠕꠁꠀ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠛꠣꠐ ꠔꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU27_9","005_27_9","NUM","27","9","9","ꠔꠣꠞ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠘ ꠘꠣ ꠕꠣꠇꠟꠦ ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠁ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU27_10","005_27_10","NUM","27","10","10","ꠔꠣꠞ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠜꠣꠁ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠁꠔꠣ ꠔꠣꠞ ꠌꠣꠌꠣꠁꠘ꠆ꠔꠦ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU27_11","005_27_11","NUM","27","11","11","ꠀꠞ ꠔꠣꠞ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠌꠣꠌꠣꠅ ꠘꠣ ꠕꠣꠇꠂꠘ, ꠔꠦ ꠔꠣꠞ ꠛꠋꠡꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠀꠙꠘ ꠎꠘꠦ ꠁ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤ ꠙꠣꠁꠛꠣ, ꠄꠁꠘ ꠁꠔꠣꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠛꠣ। ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠛꠣꠔꠣꠁꠟ ꠝꠣꠛꠥꠖꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠅꠁꠟ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠀꠁꠘꠞ ꠄꠇ ꠗꠣꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU27_12","005_27_12","NUM","27","12","12","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠛꠣꠞꠤꠝ ꠙꠣꠠꠞ ꠅꠃ ꠃꠌꠣ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠃꠑꠅ, ꠃꠑꠤꠀ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠍꠤ, ꠅꠈꠣꠘ ꠖꠦꠈꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("NU27_13","005_27_13","NUM","27","13","13","ꠀꠞ ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘ ꠎꠦꠟꠣ ꠔꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠄꠛꠞꠅ ꠢꠥꠔꠤ ꠞꠁꠍꠦ, ꠅꠃ ꠖꠦꠡ ꠖꠦꠈꠣꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠤꠅ ꠅꠟꠣ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛꠣꠄꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("NU27_14","005_27_14","NUM","27","14","14","ꠝꠘꠅ ꠀꠍꠦ ꠘꠤ, ꠎꠤꠘ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠣꠖꠦꠡ ꠄꠟꠣꠇꠣꠞ ꠝꠦꠞꠤꠛꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠞ ꠢꠃ ꠙꠣꠘꠤꠞ ꠇꠕꠣ? ꠝꠞꠥꠜꠥꠝꠤꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠦꠛꠟꠣ ꠙꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠍꠤꠟ, ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣꠅ ꠀꠝꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠘꠣ ꠝꠣꠘꠤꠀ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠉꠦꠍꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU27_15","005_27_15","NUM","27","15","15","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣꠄ ꠀꠞꠎ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU27_16","005_27_16","NUM","27","16","16","“ꠅ ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠅꠟꠣ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠃꠇ꠆ꠇꠣ, ");
INSERT INTO syls_vpl VALUES ("NU27_17","005_27_17","NUM","27","17","17","ꠎꠦ ꠘꠦꠔꠣꠄ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠊꠞꠦ-ꠛꠣꠞꠦ, ꠝꠣꠑꠅ-ꠝꠄꠖꠣꠘꠅ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠌꠣꠟꠣꠁꠛꠣ। ꠔꠦꠃ ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠀ-ꠞꠣꠈꠣꠟꠤ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU27_18","005_27_18","NUM","27","18","18","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠘꠥꠘꠞ ꠙꠥꠔ ꠁꠃꠍꠣꠞ ꠜꠤꠔꠞꠦ ꠔ ꠀꠟ꠆ꠟꠣꠁ ꠞꠥꠢꠥ ꠀꠍꠂꠘ। ꠔꠥꠝꠤ ꠔꠣꠞꠦ ꠀꠘꠤꠀ ꠔꠣꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠣꠞ ꠀꠔ ꠕꠁꠀ ꠈꠦꠟꠣꠚꠔꠤ ꠛꠈꠡꠤꠀ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("NU27_19","005_27_19","NUM","27","19","19","ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠦ ꠀꠎꠤꠞ ꠇꠞꠤꠀ, ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦꠃ ꠔꠣꠞꠦ ꠖꠣꠄꠁꠔ꠆ꠔ ꠡꠝꠎꠣꠁ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("NU27_20","005_27_20","NUM","27","20","20","ꠔꠥꠝꠣꠞꠦ ꠎꠦ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠃ ꠈꠦꠝꠔꠣꠞ ꠇꠤꠍꠥ ꠛꠣꠐ ꠔꠣꠞꠦ ꠖꠦꠅ, ꠔꠦꠃ ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠔꠣꠞ ꠇꠕꠣꠄ ꠌꠟꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU27_21","005_27_21","NUM","27","21","21","ꠛꠣꠖꠦ ꠢꠦ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛ, ꠉꠦꠟꠦ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠃꠞꠤꠝ ꠀꠞ ꠔꠥꠝ꠆ꠝꠤꠝ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠝꠞ꠆ꠎꠤ ꠎꠣꠘꠔꠣ ꠙꠣꠞꠛꠣ। ꠅꠟꠣ ꠁꠃꠍꠣ ꠀꠞ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU27_22","005_27_22","NUM","27","22","22","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠁꠃꠍꠣꠞꠦ ꠘꠤꠀ ꠀꠎꠤꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU27_23","005_27_23","NUM","27","23","23","ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠘ ꠃꠙꠞꠦ ꠀꠔ ꠕꠁꠀ ꠔꠣꠘꠞꠦ ꠖꠣꠄꠁꠔ꠆ꠔ ꠡꠝꠎꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU28_1","005_28_1","NUM","28","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU28_2","005_28_2","NUM","28","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠝꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠀꠝꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠝꠣꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠡꠑꠤꠇ ꠡꠝꠄꠄ ꠀꠎꠤꠞ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU28_3","005_28_3","NUM","28","3","3","ꠔꠣꠞꠣꠞꠦ ꠄꠅꠈꠣꠘ ꠇꠅ, ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠞꠔꠤꠖꠤꠘꠞ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠅꠃ ꠙꠡꠥ ꠅꠇꠟ ꠀꠘꠤꠅ, ꠙꠞꠔꠤꠖꠤꠘ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠖꠥꠉꠥ ꠘꠤꠈꠥꠔ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU28_4","005_28_4","NUM","28","4","4","ꠀꠘꠤꠀ ꠄꠉꠥ ꠛꠤꠀꠘꠦ ꠀꠞ ꠄꠉꠥ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_5","005_28_5","NUM","28","5","5","ꠄꠞꠟꠉꠞ ꠙꠞꠔꠤꠖꠤꠘꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠁ ꠡꠦꠞ ꠝꠄꠖꠣ ꠀꠞ ꠄꠇ ꠡꠦꠞ ꠎꠄꠔꠥꠘꠞ ꠙꠤꠡꠣ ꠔꠦꠟ ꠀꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_6","005_28_6","NUM","28","6","6","ꠁꠐꠣ ꠅꠁꠟ ꠢꠃ ꠙꠞꠔꠤꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠎꠦꠔꠣ ꠔꠥꠞ ꠙꠣꠠꠅ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ꠀꠞ ꠁꠔꠣ ꠔ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠀꠝꠤ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("NU28_7","005_28_7","NUM","28","7","7","ꠙꠞꠔꠦꠇ ꠝꠦꠠꠣꠞ ꠟꠉꠦ ꠄꠇ ꠡꠦꠞ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠖꠤꠀ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠅꠃ ꠡꠞꠛꠔ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠃꠑꠣꠘꠅ ꠓꠣꠟꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_8","005_28_8","NUM","28","8","8","ꠝꠦꠠꠣꠞ ꠀꠞꠇ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ꠄꠞꠟꠉꠦ ꠛꠤꠀꠘꠇꠥꠞ ꠟꠣꠈꠣꠘ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ꠁꠔꠣ ꠅꠁꠟ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("NU28_9","005_28_9","NUM","28","9","9","“ꠙꠞꠔꠦꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠖꠥꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ꠄꠞꠟꠉꠦ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠍꠣꠝꠣꠘꠣ ꠀꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣꠞ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠌꠣꠁꠞ ꠡꠦꠞ ꠝꠄꠖꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_10","005_28_10","NUM","28","10","10","ꠙꠞꠔꠤꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠍꠣꠠꠣꠅ ꠙꠞꠔꠦꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠅꠃ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_11","005_28_11","NUM","28","11","11","“ꠙꠞꠔꠦꠇ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠉꠥ ꠛꠤꠍꠣꠟ, ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠡꠣꠔꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ, ꠁ ꠢꠇꠟ ꠙꠡꠥ ꠙꠥꠞꠣ ꠘꠤꠈꠥꠔ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("NU28_12","005_28_12","NUM","28","12","12","ꠅꠃ ꠙꠞꠔꠦꠇ ꠛꠤꠍꠣꠟꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠍꠄ ꠡꠦꠞ ꠝꠄꠖꠣ ꠖꠤꠛꠣꠄ, ꠀꠞ ꠝꠦꠠꠣꠞ ꠟꠉꠦ ꠌꠣꠁꠞ ꠡꠦꠞ ꠝꠄꠖꠣ ꠖꠤꠅ, ");
INSERT INTO syls_vpl VALUES ("NU28_13","005_28_13","NUM","28","13","13","ꠀꠞ ꠙꠞꠔꠦꠇ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠖꠥꠁ ꠡꠦꠞ ꠝꠄꠖꠣ ꠖꠤꠅ। ꠁꠔꠣ ꠅꠁꠟ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("NU28_14","005_28_14","NUM","28","14","14","ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠟꠣꠉꠤ ꠙꠞꠔꠦꠇ ꠛꠤꠍꠣꠟꠞ ꠟꠉꠦ ꠖꠥꠁ ꠡꠦꠞ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠖꠤꠛꠣꠄ। ꠙꠞꠔꠦꠇ ꠝꠦꠠꠣꠞ ꠟꠉꠦ ꠡꠥꠀ ꠡꠦꠞ ꠀꠞ ꠙꠞꠔꠦꠇ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠄꠇ ꠡꠦꠞ ꠡꠞꠛꠔ ꠖꠤꠅ। ꠁꠔꠣ ꠅꠁꠟ ꠝꠣꠡꠤꠇ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠛꠍꠞꠞ ꠙꠞꠔꠦꠇ ꠌꠣꠘ꠆ꠖꠅ ꠁꠔꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_15","005_28_15","NUM","28","15","15","ꠁꠔꠣꠞ ꠟꠉꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠄꠉꠥ ꠍꠣꠉꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ꠔꠣ-ꠅ ꠙꠞꠔꠦꠇ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU28_16","005_28_16","NUM","28","16","16","“ꠙꠞꠔꠦꠇ ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠞ ꠌꠃꠖ꠆ꠖ ꠔꠣꠞꠤꠈ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU28_17","005_28_17","NUM","28","17","17","ꠅꠃ ꠌꠣꠘ꠆ꠖꠞ ꠙꠘꠞ ꠔꠣꠞꠤꠈ ꠕꠣꠇꠤ ꠡꠣꠔ ꠖꠤꠘ ꠜꠞꠣ ꠀꠞꠇ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ, ꠁꠇꠐꠣꠞ ꠘꠣꠝ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖ। ");
INSERT INTO syls_vpl VALUES ("NU28_18","005_28_18","NUM","28","18","18","ꠄꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠤꠅ, ꠁ ꠖꠤꠘ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣ ꠘꠣꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("NU28_19","005_28_19","NUM","28","19","19","ꠅꠃ ꠖꠤꠘ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠖꠥꠉꠥ ꠛꠤꠍꠣꠟ, ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠡꠣꠔꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠖꠤ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠞꠔꠦꠇ ꠙꠡꠥ ꠘꠤꠈꠥꠔ ꠅꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU28_20","005_28_20","NUM","28","20","20","ꠅꠃ ꠙꠡꠥꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ ꠖꠤꠛꠣꠄ, ꠄꠇꠅꠐꠣ ꠛꠤꠍꠣꠟꠞ ꠟꠉꠦ ꠍꠄ ꠡꠦꠞ, ꠝꠦꠠꠣ ꠙꠣꠑꠣꠞ ꠟꠉꠦ ꠌꠣꠁꠞ ꠡꠦꠞ, ");
INSERT INTO syls_vpl VALUES ("NU28_21","005_28_21","NUM","28","21","21","ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠖꠥꠁ ꠡꠦꠞ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_22","005_28_22","NUM","28","22","22","ꠁꠔꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU28_23","005_28_23","NUM","28","23","23","ꠙꠞꠔꠦꠇ ꠖꠤꠘꠞ ꠛꠤꠀꠘꠇꠥꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠔ ꠖꠤꠛꠣꠄꠃ, ꠄꠞꠟꠉꠦ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠅ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_24","005_28_24","NUM","28","24","24","ꠅꠃ ꠟꠣꠈꠣꠘ ꠙꠥꠞꠣ ꠢꠣꠙ꠆ꠔꠣꠞ ꠡꠣꠔꠅꠖꠤꠘ ꠀꠝꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠈꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠅꠃ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ꠙꠞꠔꠤꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠟꠉꠦ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠅ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_25","005_28_25","NUM","28","25","25","ꠢꠦꠡꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠔꠥꠝꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠤꠅ, ꠅꠃ ꠖꠤꠘ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣ ꠘꠣꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("NU28_26","005_28_26","NUM","28","26","26","“ꠙꠘ꠆ꠌꠣꠁꠡꠣ ꠁꠖꠞ ꠖꠤꠘ, ꠝꠣꠘꠤ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠖꠣꠅꠀ ꠚꠡꠟ ꠖꠤꠀ ꠎꠦꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠛꠣꠄ, ꠢꠤ ꠖꠤꠘ ꠇꠥꠘꠥ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠣꠝ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU28_27","005_28_27","NUM","28","27","27","ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠖꠥꠉꠥ ꠛꠤꠍꠣꠟ, ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠡꠣꠔꠉꠥ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠖꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ, ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("NU28_28","005_28_28","NUM","28","28","28","ꠀꠞ ꠅꠔꠣꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠄꠇꠅꠐꠣ ꠛꠤꠍꠣꠟꠞ ꠟꠉꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠍꠄ ꠡꠦꠞ ꠝꠄꠖꠣ, ꠝꠦꠠꠣꠞ ꠟꠉꠦ ꠌꠣꠁꠞ ꠡꠦꠞ, ");
INSERT INTO syls_vpl VALUES ("NU28_29","005_28_29","NUM","28","29","29","ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠖꠥꠁ ꠡꠦꠞ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU28_30","005_28_30","NUM","28","30","30","ꠅꠔꠣꠞ ꠟꠉꠦ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("NU28_31","005_28_31","NUM","28","31","31","ꠅꠃ ꠢꠇꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠁꠔꠣꠞ ꠟꠉꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠞ ꠟꠉꠦ ꠙꠞꠔꠤꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ। ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠢꠇꠟ ꠙꠡꠥ ꠎꠣꠘꠥ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_1","005_29_1","NUM","29","1","1","ꠝꠣꠛꠥꠖꠦ ꠀꠞꠅ ꠇꠁꠞꠣ, “ꠙꠞꠔꠦꠇ ꠛꠍꠞꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠅꠁꠟ, ꠔꠥꠝꠞꠣꠞ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠘꠤꠞ ꠁꠖꠞ ꠖꠤꠘ। ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠤꠅ। ꠁ ꠖꠤꠘ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣ ꠘꠣꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("NU29_2","005_29_2","NUM","29","2","2","ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ, ꠄꠉꠥ ꠛꠤꠍꠣꠟ, ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠡꠣꠔꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ, ꠢꠇꠟ ꠙꠡꠥ ꠎꠣꠘꠥ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_3","005_29_3","NUM","29","3","3","ꠀꠞ ꠅꠔꠣꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠝꠄꠖꠣ ꠖꠤꠅ। ꠛꠤꠍꠣꠟꠞ ꠟꠉꠦ ꠍꠄ ꠡꠦꠞ, ꠝꠦꠠꠣꠞ ꠟꠉꠦ ꠌꠣꠁꠞ ꠡꠦꠞ, ");
INSERT INTO syls_vpl VALUES ("NU29_4","005_29_4","NUM","29","4","4","ꠀꠞ ꠙꠞꠔꠦꠇ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠖꠥꠁ ꠡꠦꠞ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_5","005_29_5","NUM","29","5","5","ꠁꠔꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_6","005_29_6","NUM","29","6","6","ꠙꠞꠔꠦꠇ ꠌꠣꠘ꠆ꠖꠞ ꠀꠞ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠔꠣꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ ꠍꠣꠠꠣꠅ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠇꠟ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠁꠔꠣ ꠔ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ, ꠁꠔꠣꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("NU29_7","005_29_7","NUM","29","7","7","“ꠀꠞ ꠅꠃ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠖꠡ ꠔꠣꠞꠤꠈꠅ ꠄꠇꠐꠣ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠛꠣꠄ। ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠘꠔ ꠅꠁꠀ ꠎꠣꠞꠎꠤꠞ ꠖꠤꠟ ꠡꠙꠤꠀ ꠖꠤꠛꠣꠄ, ꠁ ꠖꠤꠘ ꠇꠦꠃ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU29_8","005_29_8","NUM","29","8","8","ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠛꠤꠍꠣꠟ, ꠄꠉꠥ ꠝꠦꠠꠣ, ꠀꠞ ꠡꠣꠔꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_9","005_29_9","NUM","29","9","9","ꠀꠞ ꠅꠔꠣꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠛꠤꠍꠣꠟꠞ ꠟꠉꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠍꠄ ꠡꠦꠞ ꠝꠄꠖꠣ ꠖꠤꠅ, ꠝꠦꠠꠣꠞ ꠟꠉꠦ ꠌꠣꠁꠞ ꠡꠦꠞ, ");
INSERT INTO syls_vpl VALUES ("NU29_10","005_29_10","NUM","29","10","10","ꠀꠞ ꠙꠞꠔꠦꠇ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠖꠥꠁ ꠡꠦꠞ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_11","005_29_11","NUM","29","11","11","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠁꠖꠞ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠇꠟ ꠍꠣꠠꠣꠅ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_12","005_29_12","NUM","29","12","12","“ꠔꠥꠝꠞꠣ ꠒꠦꠞꠣ-ꠊꠞꠞ ꠁꠖꠞ ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠝꠣꠘꠤ, ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠘꠞ ꠔꠣꠞꠤꠈꠅ, ꠄꠇꠐꠣ ꠙꠛꠤꠔ꠆ꠞ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠛꠣꠄ, ꠅꠃ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ꠅꠃ ꠡꠣꠔ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠁꠖꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_13","005_29_13","NUM","29","13","13","“ꠁꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠔꠦꠞꠅꠉꠥ ꠛꠤꠍꠣꠟ, ꠖꠥꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠌꠃꠖ꠆ꠖꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠖꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠄꠞ ꠗꠥꠝꠣꠞ ꠊꠦꠞꠣꠘꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("NU29_14","005_29_14","NUM","29","14","14","ꠅꠔꠣꠞ ꠙꠞꠔꠦꠇ ꠛꠤꠍꠣꠟꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠟ ꠍꠄ ꠡꠦꠞ ꠝꠄꠖꠣ, ꠙꠞꠔꠦꠇ ꠝꠦꠠꠣꠞ ꠟꠉꠦ ꠌꠣꠁꠞ ꠡꠦꠞ, ");
INSERT INTO syls_vpl VALUES ("NU29_15","005_29_15","NUM","29","15","15","ꠀꠞ ꠙꠞꠔꠦꠇ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠖꠥꠁ ꠡꠦꠞ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_16","005_29_16","NUM","29","16","16","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠖꠤꠀ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_17","005_29_17","NUM","29","17","17","“ꠁꠖꠞ ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠛꠣꠞꠅꠉꠥ ꠛꠤꠍꠣꠟ, ꠖꠥꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠌꠃꠖ꠆ꠖꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_18","005_29_18","NUM","29","18","18","ꠅꠃ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ, ꠙꠡꠥꠞ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_19","005_29_19","NUM","29","19","19","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠖꠤꠀ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_20","005_29_20","NUM","29","20","20","“ꠁꠖꠞ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘꠅ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠄꠉꠣꠞꠅꠉꠥ ꠛꠤꠍꠣꠟ, ꠖꠥꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠌꠃꠖ꠆ꠖꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_21","005_29_21","NUM","29","21","21","ꠅꠃ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ, ꠙꠡꠥꠞ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_22","005_29_22","NUM","29","22","22","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠖꠤꠀ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_23","005_29_23","NUM","29","23","23","“ꠁꠖꠞ ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠖꠡꠉꠥ ꠛꠤꠍꠣꠟ, ꠖꠥꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠌꠃꠖ꠆ꠖꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_24","005_29_24","NUM","29","24","24","ꠅꠃ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ, ꠙꠡꠥꠞ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_25","005_29_25","NUM","29","25","25","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠖꠤꠀ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_26","005_29_26","NUM","29","26","26","“ꠁꠖꠞ ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠘꠤꠈꠥꠔ ꠘꠄꠉꠥ ꠛꠤꠍꠣꠟ, ꠖꠥꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠌꠃꠖ꠆ꠖꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_27","005_29_27","NUM","29","27","27","ꠅꠃ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ, ꠙꠡꠥꠞ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_28","005_29_28","NUM","29","28","28","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠖꠤꠀ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_29","005_29_29","NUM","29","29","29","“ꠁꠖꠞ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠘꠤꠈꠥꠔ ꠀꠐꠉꠥ ꠛꠤꠍꠣꠟ, ꠖꠥꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠌꠃꠖ꠆ꠖꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_30","005_29_30","NUM","29","30","30","ꠅꠃ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ, ꠙꠡꠥꠞ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_31","005_29_31","NUM","29","31","31","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠖꠤꠀ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_32","005_29_32","NUM","29","32","32","“ꠁꠖꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠡꠣꠔꠉꠥ ꠛꠤꠍꠣꠟ, ꠖꠥꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠌꠃꠖ꠆ꠖꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_33","005_29_33","NUM","29","33","33","ꠅꠃ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ, ꠙꠡꠥꠞ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_34","005_29_34","NUM","29","34","34","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠖꠤꠀ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_35","005_29_35","NUM","29","35","35","“ꠁꠖꠞ ꠀꠐ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠝꠣꠘꠤ, ꠀꠈꠦꠞꠤ ꠖꠤꠘ ꠛꠤꠖꠣꠄꠁ ꠝꠣꠢꠚꠤꠟ ꠇꠞꠤꠅ, ꠁ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU29_36","005_29_36","NUM","29","36","36","ꠀꠞ ꠝꠣꠛꠥꠖꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠊꠦꠞꠣꠘ ꠀꠟꠣ ꠀꠉꠥꠘꠤꠔ ꠖꠦꠅꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠄꠇꠈꠣꠘ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠘꠤꠈꠥꠔ ꠄꠉꠥ ꠛꠤꠍꠣꠟ, ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠡꠣꠔꠉꠥ ꠄꠇ ꠛꠍꠞ ꠛꠄꠅꠡꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_37","005_29_37","NUM","29","37","37","ꠅꠃ ꠛꠤꠍꠣꠟ, ꠝꠦꠠꠣ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠟꠉꠦ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ, ꠙꠡꠥꠞ ꠙꠞꠤꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU29_38","005_29_38","NUM","29","38","38","ꠢꠦꠡꠦ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠙꠣꠑꠣ ꠍꠣꠉꠟꠅ ꠖꠤꠛꠣꠄ। ꠖꠤꠀ ꠙꠞꠔꠤ ꠖꠤꠘꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠄꠞ ꠟꠉꠞ ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ ꠀꠞ ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU29_39","005_29_39","NUM","29","39","39","“ꠔꠦ ꠙꠞꠔꠦꠇ ꠁꠖꠞ ꠇꠣꠟꠅ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠞꠣꠞ ꠁꠖ ꠅꠇꠟꠞ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠁꠔꠣ ꠍꠣꠠꠣ, ꠝꠣꠘ꠆ꠘꠔ ꠙꠥꠞꠘꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠎꠦꠇꠥꠘꠥ ꠘꠚꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠗꠣꠘ-ꠉꠝꠞ ꠍꠖꠉꠣ, ꠡꠞꠛꠔ-ꠙꠣꠘꠤꠞ ꠍꠖꠉꠣ, ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠅ ꠀꠖꠣꠄ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU29_40","005_29_40","NUM","29","40","40","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠣꠘꠣꠁꠍꠟꠣ, ꠔꠣꠁꠘ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU30_1","005_30_1","NUM","30","1","1","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("NU30_2","005_30_2","NUM","30","2","2","ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠦ ꠛꠣ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠥꠘꠥꠔꠣ ꠇꠞꠣꠞ ꠅꠀꠖꠣꠄ ꠛꠘ꠆ꠖꠤ ꠅꠄ, ꠔꠦ ꠢꠦ ꠎꠣꠘꠥ ꠔꠣꠞ ꠅꠀꠖꠣ ꠜꠋꠉ ꠘꠣ ꠇꠞꠦ। ꠢꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠦ, ꠁꠔꠣ ꠙꠥꠞꠘ ꠇꠞꠣ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("NU30_3","005_30_3","NUM","30","3","3","“ꠇꠥꠘꠥ ꠀꠛꠤꠀꠔꠤ ꠙꠥꠠꠤꠄ ꠎꠥꠖꠤ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠕꠣꠇꠣꠞ ꠇꠣꠟꠅ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠦ ꠛꠣ ꠇꠥꠘꠥꠔꠣ ꠇꠞꠣꠞ ꠅꠀꠖꠣꠄ ꠛꠘ꠆ꠖꠤ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("NU30_4","005_30_4","NUM","30","4","4","ꠀꠞ ꠛꠣꠚꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀꠅ ꠙꠥꠠꠤꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠇꠂꠘ, ꠔꠦ ꠁ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣ ꠔꠣꠁ ꠙꠥꠞꠘ ꠇꠞꠣ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("NU30_5","005_30_5","NUM","30","5","5","ꠅꠁꠟꠦ ꠁꠈꠣꠘ ꠢꠥꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠛꠣꠚꠦ ꠎꠥꠖꠤ ꠙꠥꠠꠤꠞꠦ ꠁꠔꠣ ꠇꠞꠔꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠂꠘ, ꠔꠦ ꠁ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣ ꠛꠣꠔꠤꠟ ꠅꠁꠎꠤꠛ। ꠛꠣꠚꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠣꠄ ꠝꠣꠛꠥꠖꠦꠅ ꠁ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣ ꠜꠣꠋꠉꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU30_6","005_30_6","NUM","30","6","6","“ꠀꠞ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠄ ꠎꠥꠖꠤ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠘꠣ ꠇꠞꠤꠀ ꠀꠈꠔꠣ ꠇꠥꠘꠥ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣ ꠇꠞꠤꠟꠣꠄ ꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠁꠞ ꠛꠤꠀ ꠅꠁꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU30_7","005_30_7","NUM","30","7","7","ꠛꠤꠀꠞ ꠛꠣꠖꠦ ꠎꠣꠝꠣꠁꠄ ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠟꠉꠦ ꠟꠉꠦ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠇꠂꠘ, ꠔꠦ ꠁ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣꠞꠦ ꠔꠣꠁ ꠙꠥꠞꠘ ꠇꠞꠣ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("NU30_8","005_30_8","NUM","30","8","8","ꠅꠁꠟꠦ ꠁꠔꠣ ꠢꠥꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠎꠣꠝꠣꠁꠄ ꠎꠥꠖꠤ ꠘꠤꠡꠦꠗ ꠇꠞꠂꠘ, ꠔꠦ ꠁ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣꠞ ꠛꠣꠘ꠆ꠖꠘ ꠕꠣꠇꠤ ꠔꠣꠁ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠛ, ꠝꠣꠛꠥꠖꠦꠅ ꠁꠔꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU30_9","005_30_9","NUM","30","9","9","“ꠀꠞ ꠇꠥꠘꠥ ꠠꠣꠠꠤ ꠛꠦꠐꠤ ꠛꠣ ꠔꠣꠟꠣꠇ ꠙꠣꠅꠀ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠄ ꠎꠥꠖꠤ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠤꠀ ꠅꠀꠖꠣꠄ ꠛꠘ꠆ꠖꠤ ꠅꠄ, ꠔꠦ ꠁꠔꠣ ꠙꠥꠞꠘ ꠇꠞꠣ ꠟꠣꠉꠛꠃ। ");
INSERT INTO syls_vpl VALUES ("NU30_10","005_30_10","NUM","30","10","10","“ꠎꠣꠝꠣꠁꠞ ꠊꠞꠞ ꠇꠥꠘꠥ ꠛꠃꠄ ꠎꠥꠖꠤ ꠅꠟꠣ ꠝꠣꠘ꠆ꠘꠔ ꠝꠣꠘꠦ ꠛꠣ ꠇꠍꠝ ꠈꠣꠁꠀ ꠅꠀꠖꠣꠄ ꠛꠘ꠆ꠖꠤ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("NU30_11","005_30_11","NUM","30","11","11","ꠛꠣꠖꠦ ꠔꠣꠁꠞ ꠎꠣꠝꠣꠁꠄ ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠝꠣꠔꠂꠘ, ꠔꠣꠁꠞꠦ ꠘꠤꠡꠦꠗ ꠘꠣ ꠖꠦꠁꠘ, ꠔꠦ ꠔꠣꠁ ꠁꠔꠣ ꠙꠥꠞꠘ ꠇꠞꠣ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("NU30_12","005_30_12","NUM","30","12","12","ꠅꠁꠟꠦ ꠎꠣꠝꠣꠁꠄ ꠢꠥꠘꠤꠀ ꠎꠥꠖꠤ ꠟꠉꠦ ꠟꠉꠦ ꠘꠤꠡꠦꠗ ꠖꠦꠁꠘ, ꠔꠦ ꠁ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣ ꠛꠣꠔꠤꠟ ꠅꠁꠎꠤꠛ। ꠔꠣꠁꠞ ꠎꠣꠝꠣꠁꠄ ꠘꠤꠡꠦꠗ ꠇꠞꠣꠄ, ꠝꠣꠛꠥꠖꠦꠅ ꠁꠈꠣꠘ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU30_13","005_30_13","NUM","30","13","13","ꠛꠃꠄ ꠇꠍꠝ ꠈꠣꠁꠀ ꠅꠀꠖꠣ ꠇꠞꠟꠦ ꠛꠣ ꠇꠥꠘꠥ ꠝꠣꠘ꠆ꠘꠔ ꠝꠣꠘꠟꠦ ꠎꠣꠝꠣꠁꠞ ꠄꠈꠔꠤꠀꠞ ꠀꠍꠦ ꠁꠔꠣ ꠝꠣꠘꠣ ꠛꠣ ꠛꠣꠔꠤꠟ ꠇꠞꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("NU30_14","005_30_14","NUM","30","14","14","ꠅꠁꠟꠦ ꠎꠣꠝꠣꠁꠄ ꠎꠥꠖꠤ ꠛꠦꠡꠤ ꠖꠤꠘ ꠁ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠝꠣꠔꠤꠀ ꠘꠤꠞꠣꠁ ꠞꠂꠘ, ꠔꠦ ꠔꠣꠞ ꠛꠃꠞ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣꠞ ꠛꠣꠘ꠆ꠖꠘ ꠙꠣꠇ꠆ꠇꠣ ꠅꠁꠎꠣꠄ। ꠢꠇꠟꠔꠣ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦꠅ ꠎꠣꠝꠣꠁ ꠅꠃ ꠡꠝꠄ ꠘꠤꠞꠣꠁ ꠞꠅꠀꠄ ꠛꠃꠞ ꠝꠣꠘ꠆ꠘꠔ ꠛꠣ ꠅꠀꠖꠣꠞꠦ ꠙꠣꠇ꠆ꠇꠣ ꠛꠣꠘꠣꠁꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU30_15","005_30_15","NUM","30","15","15","ꠅꠁꠟꠦ ꠢꠇꠟꠔꠣ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦ ꠎꠣꠝꠣꠁꠄ ꠎꠥꠖꠤ ꠢꠃ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠝꠣꠔꠤꠀ ꠡꠝꠄ ꠙꠣꠞꠘꠤꠞ ꠛꠣꠖꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠦ, ꠔꠦ ꠛꠃꠄ ꠅꠃ ꠝꠣꠘ꠆ꠘꠔ ꠙꠥꠞꠣ ꠘꠣ ꠇꠞꠣꠄ ꠄꠞ ꠖꠣꠄ-ꠜꠣꠞ ꠔꠣꠁꠞ ꠎꠣꠝꠣꠁꠞ ꠃꠙꠞꠦ ꠙꠠꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU30_16","005_30_16","NUM","30","16","16","ꠎꠣꠝꠣꠁ-ꠛꠃꠞ ꠛꠦꠙꠣꠞꠦ, ꠛꠣꠚ ꠀꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠞꠅꠞꠣ ꠙꠥꠠꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠅꠟꠣ ꠀꠁꠘ ꠢꠤꠇꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_1","005_31_1","NUM","31","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU31_2","005_31_2","NUM","31","2","2","“ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠎꠦꠔꠣ ꠇꠞꠍꠦ, ꠔꠥꠝꠤ ꠅꠔꠣꠞ ꠅꠙꠞꠣꠗꠞ ꠛꠖꠟꠣ ꠖꠦꠅ। ꠄꠞꠛꠣꠖꠦ ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠢꠥꠔꠤ ꠞꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU31_3","005_31_3","NUM","31","3","3","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠤꠍꠥ ꠍꠤꠙꠣꠁꠞꠦ ꠎꠥꠁꠔ ꠇꠞꠅ, ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_4","005_31_4","NUM","31","4","4","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠄꠇ ꠀꠎꠣꠞ ꠇꠞꠤ ꠍꠤꠙꠣꠁꠞꠦ ꠎꠥꠖ꠆ꠖꠔ ꠙꠣꠑꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU31_5","005_31_5","NUM","31","5","5","ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠄꠇꠅ ꠀꠎꠣꠞ ꠇꠞꠤ ꠝꠥꠐ ꠛꠣꠞꠅ ꠀꠎꠣꠞ ꠍꠤꠙꠣꠁꠞꠦ ꠎꠥꠖ꠆ꠖꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU31_6","005_31_6","NUM","31","6","6","ꠝꠥꠍꠣꠄ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠄꠇ ꠀꠎꠣꠞ ꠎꠘ ꠍꠤꠙꠣꠁꠞꠦ ꠎꠥꠖ꠆ꠖꠔ ꠙꠣꠑꠣꠁꠟꠣ। ꠄꠞꠣꠞ ꠟꠉꠦ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠞ ꠙꠥꠀ ꠙꠤꠘꠢꠡꠅ ꠉꠦꠟꠣ, ꠎꠣꠁꠔꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠇꠤꠍꠥ ꠍꠣꠝꠣꠘꠣ ꠟꠉꠦ ꠇꠞꠤ ꠘꠤꠟꠣ ꠀꠞ ꠔꠣꠘ ꠀꠔꠅ ꠇꠞꠤ ꠎꠥꠖ꠆ꠖꠞ ꠀꠅꠀꠎꠞ ꠌꠥꠋꠉꠣ ꠅꠇꠟꠅ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_7","005_31_7","NUM","31","7","7","ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠖꠦꠅꠀ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣ ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠤꠀ ꠅꠔꠣꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞꠦ ꠝꠣꠞꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_8","005_31_8","NUM","31","8","8","ꠡꠣꠗꠣꠞꠘ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟꠞ ꠙꠣꠌ ꠎꠘ ꠛꠣꠖꠡꠣꠞꠦꠅ ꠔꠣꠞꠣ ꠝꠣꠞꠤꠟꠤꠟꠣ। ꠅꠃ ꠛꠣꠖꠡꠣꠁꠘ ꠅꠁꠟꠣ, ꠁꠛꠤ, ꠞꠦꠇꠝ, ꠡꠥꠞ, ꠢꠥꠞ ꠀꠞ ꠞꠦꠛꠣ। ꠀꠞ ꠄꠞꠣꠞ ꠟꠉꠦ ꠛꠣꠟꠣꠝ ꠛꠤꠘ ꠛꠣꠃꠞ ꠘꠣꠝꠞ ꠢꠃ ꠙꠤꠞꠞꠦꠅ ꠔꠣꠞꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_9","005_31_9","NUM","31","9","9","ꠔꠣꠞꠣ ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠞ ꠢꠇꠟ ꠛꠦꠐꠤꠘ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠟꠣ, ꠔꠣꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠥꠐꠤꠀ ꠀꠘꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_10","005_31_10","NUM","31","10","10","ꠝꠣꠖꠤꠀꠘꠤ ꠅꠇꠟ ꠎꠔ ꠐꠣꠃꠘꠅ ꠛꠡꠔ ꠇꠞꠔꠣ, ꠅꠃ ꠐꠣꠃꠘ ꠅꠇꠟ ꠀꠞ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠞ ꠢꠇꠟ ꠔꠣꠝ꠆ꠛꠥ ꠔꠣꠞꠣ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_11","005_31_11","NUM","31","11","11","ꠎꠥꠖ꠆ꠖꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞ ꠛꠘ꠆ꠖꠤ ꠇꠞꠣ ꠢꠇꠟ ꠝꠣꠘꠥꠡ, ꠉꠘꠤꠝꠔꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠀꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠟꠁꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_12","005_31_12","NUM","31","12","12","ꠔꠣꠞꠣ ꠝꠥꠍꠣ ꠘꠛꠤ, ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠅ ꠚꠤꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠔꠣꠝ꠆ꠛꠥ ꠀꠍꠤꠟ ꠎꠤꠞꠤꠢꠅ ꠄꠟꠣꠇꠣꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠗꠣꠞꠅ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠔꠟ ꠎꠣꠉꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("NU31_13","005_31_13","NUM","31","13","13","ꠔꠣꠞꠣꠞ ꠈꠛꠞ ꠙꠣꠁꠀ ꠝꠥꠍꠣ ꠘꠛꠤ, ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠝꠥꠞꠛ꠆ꠛꠤ ꠇꠦꠝ꠆ꠙ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_14","005_31_14","NUM","31","14","14","ꠉꠤꠀ ꠎꠥꠖ꠆ꠖ ꠕꠣꠇꠤ ꠚꠤꠞꠔ ꠀꠅꠀ ꠢꠇꠟ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞꠞ ꠃꠙꠞꠦ ꠝꠣꠘꠤ ꠀꠎꠣꠞ ꠍꠤꠙꠣꠁꠞ ꠀꠞ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠝꠥꠍꠣꠄ ꠈꠥꠛ ꠉꠞꠝ ꠅꠁꠀ ");
INSERT INTO syls_vpl VALUES ("NU31_15","005_31_15","NUM","31","15","15","ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠖꠥꠡꠝꠘꠞ ꠢꠇꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠞꠣꠈꠟꠣꠄ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("NU31_16","005_31_16","NUM","31","16","16","ꠝꠘꠅ ꠘꠣꠁ ꠘꠤ, ꠅꠉꠥꠁꠘ꠆ꠔꠦ ꠙꠤꠃꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞ ꠙꠞꠣꠝꠤꠡꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠢꠞꠣꠁꠍꠤꠟ, ꠄꠞꠟꠣꠉꠤ ꠔ ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠉꠎꠛꠤ ꠛꠦꠝꠣꠞ ꠘꠣꠎꠤꠟ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU31_17","005_31_17","NUM","31","17","17","ꠔꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠅꠔꠣꠞ ꠢꠇꠟ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠅ, ꠛꠤꠀꠔꠤ ꠛꠣ ꠅꠡꠔꠤ ꠢꠇꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦꠅ ꠝꠣꠞꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("NU31_18","005_31_18","NUM","31","18","18","ꠈꠣꠟꠤ ꠀꠛꠤꠀꠔꠤ ꠡꠔꠤ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠔꠣ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU31_19","005_31_19","NUM","31","19","19","“ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠍ ꠛꠣ ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠡ ꠍꠁꠍ, ꠔꠥꠝꠞꠣ ꠡꠣꠔꠖꠤꠘ ꠜꠞꠣ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠞꠁꠅ। ꠄꠞꠝꠣꠎꠦ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠀꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠀꠞ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠀꠘꠣ ꠝꠣꠘꠡꠞꠦꠅ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU31_20","005_31_20","NUM","31","20","20","ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ, ꠌꠣꠝꠠꠣꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ꠟꠣꠇꠠꠤ ꠀꠞ ꠍꠣꠉꠟꠞ ꠞꠥꠝꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠢꠇ꠆ꠇꠟ ꠍꠣꠝꠣꠘꠞꠦꠅ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU31_21","005_31_21","NUM","31","21","21","ꠎꠦꠔꠣ ꠍꠤꠙꠣꠁ ꠅꠇꠟ ꠎꠥꠖ꠆ꠖꠔ ꠉꠦꠍꠟꠣ, ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠅꠁꠟ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠀꠔꠦ ꠖꠦꠅꠀ ꠝꠣꠛꠥꠖꠞ ꠡꠞꠤꠅꠔꠞ ꠄꠇꠈꠣꠘ ꠀꠁꠘ: ");
INSERT INTO syls_vpl VALUES ("NU31_22","005_31_22","NUM","31","22","22","ꠔꠥꠝꠞꠣ ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠙꠤꠔꠟ, ꠟꠥꠀ, ꠐꠤꠘ, ꠡꠤꠡꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("NU31_23","005_31_23","NUM","31","23","23","ꠝꠣꠘꠤ ꠎꠦꠔꠣ ꠝꠣꠟ ꠀꠉꠥꠘꠤꠔ ꠖꠤꠟꠦ ꠎꠟꠦ ꠘꠣ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎꠦ ꠖꠤꠛꠣꠄ, ꠔꠦꠃ ꠁꠔꠣ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠛ। ꠅꠁꠟꠦ ꠎꠣꠟꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠁꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠙꠣꠘꠤꠖꠤ ꠗꠁꠀ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠇꠞꠣ ꠟꠣꠉꠛ। ꠀꠞ ꠎꠦꠔꠣ ꠀꠉꠥꠁꠘꠦ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ, ꠁꠔꠣꠞꠦ ꠈꠣꠟꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠙꠣꠘꠤꠖꠤ ꠗꠁꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU31_24","005_31_24","NUM","31","24","24","ꠛꠣꠖꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠢꠣꠞꠟꠦ, ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠛꠘꠤꠀ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("NU31_25","005_31_25","NUM","31","25","25","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU31_26","005_31_26","NUM","31","26","26","“ꠔꠥꠝꠤ ꠀꠞ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠡꠝꠣꠎꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠝꠤꠟꠤꠀ, ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠀꠘꠣ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠀꠞ ꠙꠡꠥꠁꠘ꠆ꠔꠞꠦ ꠉꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("NU31_27","005_31_27","NUM","31","27","27","ꠉꠘꠤꠀ ꠢꠇꠟ ꠝꠣꠟ ꠖꠥꠁ ꠛꠣꠐ ꠇꠞꠅ। ꠁꠔꠣꠞ ꠄꠇ ꠛꠣꠐ ꠖꠤꠛꠣꠄ ꠎꠥꠖ꠆ꠖꠔ ꠎꠦꠔꠣ ꠍꠤꠙꠣꠁ ꠅꠇꠟ ꠉꠦꠍꠤꠟ ꠔꠣꠞꠣꠞꠦ, ꠀꠞ ꠖꠥꠍꠞꠣ ꠛꠣꠐ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠝꠣꠘꠡꠞꠦ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU31_28","005_31_28","NUM","31","28","28","ꠅꠃ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞ ꠛꠣꠐꠅ ꠎꠔ ꠝꠣꠘꠥꠡ, ꠉꠞꠥ-ꠍꠣꠉꠟ ꠙꠠꠛ, ꠁꠔꠣꠞ ꠙꠞꠔꠦꠇ ꠙꠣꠌ-ꠡꠐꠣ ꠕꠣꠇꠤ ꠄꠇꠐꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠟꠣꠉꠤ ꠀꠟꠉꠣꠁ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("NU31_29","005_31_29","NUM","31","29","29","ꠀꠟꠉꠣꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠅꠘꠣ ꠅꠃ ꠛꠣꠐꠞꠦ ꠔꠥꠝꠤ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠞ ꠀꠔꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU31_30","005_31_30","NUM","31","30","30","ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠐꠅ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ, ꠉꠞꠥ-ꠍꠣꠉꠟ ꠙꠣꠁꠛꠣ, ꠁꠔꠣꠞ ꠙꠞꠔꠦꠇ ꠙꠁꠘ꠆ꠌꠣꠡꠐꠣ ꠕꠣꠇꠤ ꠄꠇꠐꠣꠞꠦ ꠀꠟꠉ ꠇꠞꠤ ꠕꠁꠅ। ꠕꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣ, ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠔꠣꠝ꠆ꠛꠥꠞ ꠈꠣꠖꠤꠝ ꠟꠦꠛꠤ ꠅꠇꠟꠞ ꠀꠔꠅ ꠁꠔꠣ ꠡꠝꠎꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("NU31_31","005_31_31","NUM","31","31","31","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠔꠣꠁꠘ ꠀꠞ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_32","005_31_32","NUM","31","32","32","ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠎꠤꠔꠤꠀ ꠀꠘꠣ ꠉꠘꠤꠝꠔꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠍꠣꠠꠣꠅ ꠀꠞꠅ ꠀꠍꠤꠟ, ꠍꠄ ꠟꠣꠈ ꠙꠌꠔ꠆ꠔꠁꠞ ꠀꠎꠣꠞ ꠝꠦꠠꠣ ꠀꠞ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU31_33","005_31_33","NUM","31","33","33","ꠛꠣꠅꠔ꠆ꠔꠁꠞ ꠀꠎꠣꠞ ꠉꠞꠥ, ");
INSERT INTO syls_vpl VALUES ("NU31_34","005_31_34","NUM","31","34","34","ꠄꠇꠡꠐ꠆ꠐꠤ ꠀꠎꠣꠞ ꠉꠣꠗꠣ ");
INSERT INTO syls_vpl VALUES ("NU31_35","005_31_35","NUM","31","35","35","ꠀꠞ ꠛꠔ꠆ꠔꠤꠡ ꠀꠎꠣꠞ ꠀꠛꠤꠀꠔꠤ ꠡꠔꠤ ꠙꠥꠠꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("NU31_36","005_31_36","NUM","31","36","36","ꠔꠦꠃ ꠎꠥꠖ꠆ꠖ ꠇꠞꠞꠣ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞ ꠛꠣꠐꠅ ꠙꠠꠟ, ꠔꠤꠘ ꠟꠣꠈ ꠡꠣꠠꠔꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡꠐꠣ ꠝꠦꠠꠣ ꠀꠞ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU31_37","005_31_37","NUM","31","37","37","ꠁꠔꠣ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠅꠘꠣ ꠛꠣꠐꠅ ꠙꠠꠟ, ꠍꠄ-ꠡ ꠙꠌꠔ꠆ꠔꠁꠞꠉꠥ ꠍꠣꠉꠟ-ꠝꠦꠠꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_38","005_31_38","NUM","31","38","38","ꠀꠞ ꠉꠞꠥ ꠀꠍꠤꠟ ꠍꠄꠔꠤꠡ ꠀꠎꠣꠞ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠐꠅ ꠙꠠꠟ ꠛꠣꠅꠔ꠆ꠔꠁꠞꠐꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_39","005_31_39","NUM","31","39","39","ꠄꠞꠝꠣꠎꠦ ꠉꠣꠗꠣ ꠀꠍꠤꠟ ꠔꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡꠐꠣ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠐꠅ ꠙꠠꠟ ꠄꠇꠡꠐ꠆ꠐꠤꠉꠥ। ");
INSERT INTO syls_vpl VALUES ("NU31_40","005_31_40","NUM","31","40","40","ꠀꠞ ꠀꠛꠤꠀꠔꠤ ꠡꠔꠤ ꠙꠥꠠꠤꠘ ꠀꠍꠟꠣ ꠡꠥꠟ꠆ꠟ ꠀꠎꠣꠞ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠐꠅ ꠙꠠꠟ ꠛꠔ꠆ꠔꠤꠡꠐꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_41","005_31_41","NUM","31","41","41","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠔꠣꠁꠘ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠅꠘꠣ ꠛꠣꠐ ꠘꠤꠀ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠞ ꠀꠔꠅ ꠅꠟꠣ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_42","005_31_42","NUM","31","42","42","ꠀꠞ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠎꠦ ꠛꠣꠐ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠘꠤꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU31_43","005_31_43","NUM","31","43","43","ꠁ ꠛꠣꠐꠅ ꠔꠤꠘ ꠟꠣꠈ ꠡꠣꠠꠔꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡꠉꠥ ꠝꠦꠠꠣ ꠀꠞ ꠍꠣꠉꠟ, ");
INSERT INTO syls_vpl VALUES ("NU31_44","005_31_44","NUM","31","44","44","ꠍꠄꠔꠤꠡ ꠀꠎꠣꠞ ꠉꠞꠥ, ");
INSERT INTO syls_vpl VALUES ("NU31_45","005_31_45","NUM","31","45","45","ꠔꠤꠡ ꠀꠎꠣꠞ ꠙꠣꠌ-ꠡꠐꠣ ꠉꠣꠗꠣ, ");
INSERT INTO syls_vpl VALUES ("NU31_46","005_31_46","NUM","31","46","46","ꠀꠞ ꠡꠥꠟ꠆ꠟ ꠀꠎꠣꠞ ꠀꠛꠤꠀꠔꠤ ꠡꠔꠤ ꠙꠥꠠꠤꠘ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_47","005_31_47","NUM","31","47","47","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠣꠅꠀ ꠛꠣꠐꠞ, ꠙꠞꠔꠦꠇ ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘ ꠀꠛꠤꠀꠔꠤ ꠙꠥꠠꠤꠘ ꠀꠞ ꠙꠡꠥꠁꠘ ꠕꠣꠇꠤꠅ, ꠄꠉꠥ ꠇꠞꠤ ꠙꠥꠠꠤ ꠀꠞ ꠙꠡꠥ ꠘꠤꠀ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠖꠤꠟꠣ, ꠎꠦꠞꠣꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠤ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU31_48","005_31_48","NUM","31","48","48","ꠄꠞꠛꠣꠖꠦ ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠀꠎꠣꠞ ꠍꠤꠙꠣꠁꠞ ꠀꠞ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞ ꠅꠇꠟ ꠝꠥꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU31_49","005_31_49","NUM","31","49","49","ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠀꠝꠞꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠕꠣꠇꠣ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠉꠘꠤꠟꠣꠝ। ꠉꠘꠤꠀ ꠖꠦꠈꠟꠣꠝ, ꠔꠣꠞꠣ ꠢꠇꠟ ꠙꠥꠞꠣ ꠀꠍꠂꠘ, ꠎꠥꠖ꠆ꠖꠔ ꠇꠦꠃ ꠝꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_50","005_31_50","NUM","31","50","50","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠙꠞꠔꠦꠇꠞ ꠛꠣꠐꠅ ꠎꠦꠔꠣ ꠡꠥꠘꠣꠞ ꠛꠣꠎꠥ, ꠛꠣꠟꠣ, ꠀꠔꠞ ꠀꠋꠐꠤ, ꠇꠣꠘꠞ ꠖꠥꠟ ꠀꠞ ꠉꠟꠣꠞ ꠢꠣꠞ ꠙꠣꠁꠍꠤ, ꠀꠝꠞꠣ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠟꠁꠀ ꠀꠁꠍꠤ। ꠀꠝꠞꠣꠞ ꠎꠣꠘꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠅꠔꠣ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠤꠟꠣꠁꠔꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("NU31_51","005_31_51","NUM","31","51","51","ꠔꠦꠃ ꠝꠥꠍꠣ ꠀꠞ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠥꠘꠣꠞ ꠢꠇꠟ ꠉꠄꠘꠣ ꠡꠝꠎꠤꠀ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_52","005_31_52","NUM","31","52","52","ꠔꠣꠞꠣ ꠀꠎꠣꠞ ꠍꠤꠙꠣꠁꠞ ꠀꠞ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀ ꠎꠦ ꠡꠥꠘꠣꠞ ꠉꠄꠘꠣ ꠡꠝꠎꠤꠀ ꠙꠣꠁꠟꠣ, ꠁꠔꠣꠞ ꠃꠎꠘ ꠀꠍꠤꠟ ꠡꠥꠟ꠆ꠟ ꠀꠎꠣꠞ ꠡꠣꠔ-ꠡ ꠙꠁꠘ꠆ꠌꠣꠡ ꠔꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU31_53","005_31_53","NUM","31","53","54","ꠝꠥꠍꠣ ꠘꠛꠤ ꠀꠞ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞꠦ ꠀꠎꠣꠞ ꠍꠤꠙꠣꠁ ꠀꠞ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠃ ꠡꠥꠘꠣ ꠅꠇꠟ ꠡꠝꠎꠤꠀ ꠞꠣꠈꠟꠣ। ꠞꠣꠈꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠁꠀꠖꠉꠣꠞꠤꠞ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠅꠔꠣ ꠡꠥꠘꠣ ꠅꠇꠟ ꠇꠣꠛꠣ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠕꠁꠟꠣ। ꠁꠔꠣ ꠍꠣꠠꠣꠅ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠉꠘꠤꠝꠔꠞ ꠀꠞꠅ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠎꠣꠞꠎꠤꠞ ꠉꠦꠍꠦ ꠞꠣꠈꠍꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_1","005_32_1","NUM","32","1","1","ꠞꠥꠛꠦꠘ ꠀꠞ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠛꠠ ꠛꠠ ꠙꠣꠟ ꠀꠍꠤꠟ। ꠔꠣꠞꠣ ꠖꠦꠈꠟꠣ, ꠎꠣꠎꠤꠞꠣ ꠀꠞ ꠉꠤꠟꠤꠅꠖ ꠄꠟꠣꠇꠣ ꠙꠡꠥ ꠙꠣꠟꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠛ ꠜꠣꠟꠣ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_2","005_32_2","NUM","32","2","2","ꠔꠦꠃ ꠔꠣꠞꠣ ꠝꠥꠍꠣ ꠘꠛꠤ, ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠗꠣꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU32_3","005_32_3","NUM","32","3","4","“ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠔ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠙꠣꠟꠤ। ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖꠦ ꠅꠐꠣꠞꠥꠔ, ꠖꠤꠛꠣꠘ, ꠎꠣꠎꠤꠞꠣ, ꠘꠤꠝ꠆ꠞꠣ, ꠢꠤꠡꠛꠘ, ꠁꠟꠤꠀꠟꠤ, ꠍꠦꠛꠣꠝ, ꠘꠛꠅ ꠀꠞ ꠛꠤꠃꠘ ꠘꠣꠝꠞ ꠎꠦꠔꠣ ꠎꠣꠉꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠈꠟꠅ ꠀꠘꠍꠂꠘ, ꠁꠔꠣ ꠔ ꠙꠡꠥ ꠙꠣꠟꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠛ ꠜꠣꠟꠣ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_5","005_32_5","NUM","32","5","5","ꠅꠈꠘ ꠀꠙꠘꠦ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠂꠘ, ꠔꠦ ꠅꠃ ꠎꠣꠉꠣ ꠈꠣꠘꠣꠁꠘ ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ। ꠀꠝꠞꠣꠞꠦ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠤꠙꠣꠞꠅ ꠘꠦꠁꠘ ꠘꠣ ꠎꠣꠘꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU32_6","005_32_6","NUM","32","6","6","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠀꠁꠘ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠔ ꠎꠣꠁꠛꠣ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠛꠁ ꠞꠁꠛꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("NU32_7","005_32_7","NUM","32","7","7","ꠝꠣꠛꠥꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠦ ꠎꠣꠉꠣ ꠈꠣꠘꠣꠁꠘ ꠖꠤꠍꠂꠘ, ꠢꠤꠘꠅ ꠎꠣꠁꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠔꠣꠞꠣꠞ ꠝꠘꠅꠛꠟ ꠜꠣꠋꠉꠤ ꠖꠤꠞꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("NU32_8","005_32_8","NUM","32","8","8","ꠢꠥꠘꠅ, ꠀꠉꠦ ꠎꠦꠛꠟꠣ ꠅꠃ ꠖꠦꠡ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘꠞꠦ ꠀꠝꠤ ꠇꠣꠖꠦꠡ-ꠛꠞꠘꠦꠀ ꠕꠣꠇꠤ ꠙꠣꠑꠣꠁꠍꠟꠣꠝ, ꠢꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠅ ꠅꠟꠣ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_9","005_32_9","NUM","32","9","9","ꠔꠣꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠞ ꠖꠣꠘ ꠇꠞꠣ ꠖꠦꠡ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠤꠟ, ꠉꠤꠀ ꠀꠡꠇꠥꠟꠞ ꠙꠣꠠꠤꠀ ꠈꠣꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠦꠈꠍꠤꠟ, ꠖꠦꠈꠤꠀ ꠀꠁꠀ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠦ ꠄꠞꠣꠞ ꠝꠘꠅꠛꠟ ꠜꠣꠋꠉꠤ ꠖꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU32_10","005_32_10","NUM","32","10","10","ꠄꠞꠟꠣꠉꠤ ꠢꠃ ꠖꠤꠘ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠀ ꠝꠣꠛꠥꠖꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU32_11","005_32_11","NUM","32","11","11","ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠈꠣꠁꠍꠟꠣꠝ, ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠅꠀ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠛꠤꠡ ꠛꠍꠞ ꠛꠣ ꠄꠞ ꠛꠦꠡꠤ ꠛꠄꠅꠡꠤ ꠇꠥꠘꠥ ꠎꠘꠦ ꠁ ꠖꠦꠡ ꠖꠦꠈꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠔꠣ ꠘꠣꠄ, ꠇꠦꠘꠦꠘꠣ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠝꠣꠘꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_12","005_32_12","NUM","32","12","12","ꠈꠣꠟꠤ ꠇꠘꠤꠎꠤ ꠎꠤꠚꠥꠘ꠆ꠘꠤꠞ ꠙꠥꠀ ꠇꠣꠟꠥꠔ ꠀꠞ ꠘꠥꠘꠞ ꠙꠥꠔ ꠁꠃꠍꠣꠄ ꠅꠃ ꠖꠦꠡ ꠖꠦꠈꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠛꠣ। ꠔꠣꠞꠣ ꠔ ꠀꠝꠣꠞ ꠇꠕꠣꠞꠦ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠝꠣꠘꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU32_13","005_32_13","NUM","32","13","13","ꠢꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠍꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠘꠎꠞꠅ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠞꠣ ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠛꠤꠘꠣꠡ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠗꠞꠤ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠘꠣꠘꠣꠘ ꠎꠣꠉꠣꠔ ꠁꠔꠣꠞꠦ ꠌꠇ꠆ꠇꠞ ꠖꠦꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_14","005_32_14","NUM","32","14","14","“ꠀꠞ ꠢꠃ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞ ꠀꠅꠟꠣꠖ ꠅꠀꠄ, ꠅꠈꠘ ꠔꠥꠝꠞꠣꠅ ꠎꠣꠞꠎꠤꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠈꠣꠁꠍꠟꠔ ꠙꠣꠁꠍ, ꠄꠞꠟꠣꠉꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘꠞꠦ ꠀꠞꠅ ꠛꠣꠠꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU32_15","005_32_15","NUM","32","15","15","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠘꠣ ꠌꠟꠅ, ꠔꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠚꠣꠟꠣꠁ ꠕꠁꠛꠣ, ꠔꠣꠘ ꠁ ꠟꠣꠘ꠆ꠘꠔꠞ ꠇꠣꠞꠘ ꠅꠁꠛꠣꠄ ꠔꠥꠝꠞꠣꠃ।” ");
INSERT INTO syls_vpl VALUES ("NU32_16","005_32_16","NUM","32","16","16","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠝꠥꠍꠣꠞ ꠗꠣꠞꠅ ꠜꠤꠠꠤꠀ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠀꠝꠞꠣ ꠔ ꠈꠣꠟꠤ ꠙꠡꠥꠞ ꠙꠣꠟ ꠞꠣꠈꠣꠞ ꠎꠣꠉꠣ ꠛꠣꠘꠣꠘꠤ ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠕꠅꠀꠞ ꠟꠣꠉꠤ ꠅꠘꠅ ꠐꠣꠃꠘ ꠅꠇꠟ ꠛꠣꠘꠣꠘꠤꠞ ꠁꠎꠣꠎꠔ ꠌꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU32_17","005_32_17","NUM","32","17","17","ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠘꠤꠎꠞ ꠎꠣꠉꠣꠔ ꠘꠣ ꠙꠃꠍꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠞꠣ ꠎꠥꠖ꠆ꠖꠞ ꠍꠤꠙꠣꠁꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠎꠣꠁꠝꠥ। ꠄꠞꠝꠣꠎꠦ ꠀꠝꠞꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠇꠞꠣ ꠅꠃ ꠐꠣꠃꠘꠅ ꠞꠁꠟꠦ, ꠅꠔꠣ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞ ꠀꠔ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠘꠤꠞꠣꠙꠖꠦ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_18","005_32_18","NUM","32","18","18","ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠘꠣ ꠡꠝꠎꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠞꠣ ꠘꠤꠎꠞ ꠊꠞꠅ ꠚꠤꠞꠤꠀ ꠀꠁꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU32_19","005_32_19","NUM","32","19","19","ꠀꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠛꠣꠐꠅ ꠘꠤꠔꠣꠝ ꠘꠣꠄ, ꠇꠦꠘꠦꠘꠣ ꠀꠝꠞꠣꠞ ꠛꠣꠐ ꠔ ꠉꠣꠋꠉꠞ ꠅꠃ ꠙꠥꠛꠞ ꠙꠣꠞꠅꠃ ꠝꠤꠟꠤꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("NU32_20","005_32_20","NUM","32","20","20","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠢꠣꠍꠣꠃ ꠁꠟꠣ ꠇꠞꠅ, ꠀꠟ꠆ꠟꠣꠞꠦ ꠀꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠎꠣꠘꠤꠀ ꠎꠥꠖ꠆ꠖꠞ ꠢꠣꠎꠦ ꠀꠔꠤꠀꠞ ꠟꠁꠀ ꠎꠥꠖꠤ ꠢꠘꠅ ꠟꠣꠠꠣꠁꠔ ꠎꠣꠅ, ");
INSERT INTO syls_vpl VALUES ("NU32_21","005_32_21","NUM","32","21","21","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠎꠔꠛꠁꠟ ꠔꠣꠘ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠀ ꠘꠣ ꠖꠦꠁꠘ ꠅꠔꠛꠁꠟ ꠔꠥꠝꠞꠣ ꠎꠥꠖ꠆ꠖꠞ ꠢꠣꠎꠦ ꠔꠣꠘ ꠟꠣꠉꠤ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠙꠣꠞꠅ ꠎꠥꠖꠤ ꠎꠣꠅ, ");
INSERT INTO syls_vpl VALUES ("NU32_22","005_32_22","NUM","32","22","22","ꠔꠦ ꠢꠃ ꠖꠦꠡꠅ ꠝꠣꠛꠥꠖꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠇꠣꠁꠝ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠚꠤꠞꠔ ꠀꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠔꠦꠃ ꠝꠣꠛꠥꠖ ꠀꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠎꠦ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠅꠁꠛꠣꠄ; ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠅꠃ ꠎꠝꠤꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠇꠣꠁꠝ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU32_23","005_32_23","NUM","32","23","23","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠁꠟꠣ ꠘꠣ ꠇꠞꠅ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠉꠥꠘꠣꠉꠣꠞ ꠛꠘꠛꠣꠄ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠙꠣꠙꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠠꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU32_24","005_32_24","NUM","32","24","24","ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠣꠉꠤ ꠐꠣꠃꠘ ꠅꠇꠟ ꠀꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠕꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠣꠉꠣꠅ ꠛꠣꠘꠣꠁꠔꠣꠄ ꠙꠣꠞꠅ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠈꠣꠘ ꠅꠀꠖꠣ ꠇꠞꠍ, ꠁꠔꠣ ꠙꠥꠞꠘ ꠇꠞꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU32_25","005_32_25","NUM","32","25","25","ꠔꠦꠃ ꠍꠣꠖꠥ ꠀꠞ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠔ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ, ꠀꠙꠘꠣꠞ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠀꠙꠘꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠀꠝꠞꠣ ꠅꠟꠣꠃ ꠌꠟꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("NU32_26","005_32_26","NUM","32","26","26","ꠀꠝꠞꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠀꠞ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠣꠟ ꠅꠘꠞ ꠉꠤꠟꠤꠅꠖ ꠄꠟꠣꠇꠣꠞ ꠐꠣꠃꠘ ꠅꠇꠟꠅ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_27","005_32_27","NUM","32","27","27","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠎꠥꠖ꠆ꠖꠞ ꠡꠣꠎ-ꠡꠞꠘ꠆ꠎꠣꠝ ꠟꠁꠀ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠔ ꠎꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("NU32_28","005_32_28","NUM","32","28","28","ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠛꠦꠙꠣꠞꠦ ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ, ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_29","005_32_29","NUM","32","29","29","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠍꠣꠖꠥ ꠀꠞ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ ꠎꠥꠖꠤ ꠢꠣꠍꠣꠃ ꠎꠥꠖ꠆ꠖꠞ ꠡꠣꠎ-ꠡꠞꠘ꠆ꠎꠣꠝ ꠟꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠘ, ꠔꠦ ꠢꠃ ꠖꠦꠡ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠈꠟꠅ ꠀꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠉꠤꠟꠤꠅꠖ ꠄꠟꠣꠇꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣꠄ ꠡꠝꠎꠣꠁ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU32_30","005_32_30","NUM","32","30","30","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠁꠟꠣ ꠘꠣ ꠇꠞꠂꠘ, ꠔꠦ ꠢꠃ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅꠃ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠐ ꠘꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU32_31","005_32_31","NUM","32","31","31","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠖꠥ ꠀꠞ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠁ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠀꠝꠞꠣ ꠅꠟꠣꠃ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("NU32_32","005_32_32","NUM","32","32","32","ꠀꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠥꠖ꠆ꠖꠞ ꠡꠣꠎ-ꠡꠞꠘ꠆ꠎꠣꠝ ꠟꠁꠀ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠎꠣꠁꠝꠥ, ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠛꠣꠐ ꠉꠣꠋꠉꠞ ꠅꠙꠣꠞꠅ ꠞꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("NU32_33","005_32_33","NUM","32","33","33","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠥꠍꠣ ꠘꠛꠤ ꠞꠣꠎꠤ ꠅꠁꠟꠣ। ꠔꠣꠁꠘ ꠍꠣꠖꠥ ꠀꠞ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ, ꠄꠞꠟꠉꠦ ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠅꠞ꠆ꠗꠦꠇ ꠝꠣꠘꠡꠞꠦ, ꠅꠃ ꠎꠣꠉꠣꠁꠘ ꠖꠤꠟꠣ। ꠝꠥꠍꠣꠄ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘ ꠀꠞ ꠛꠣꠡꠘꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠞ ꠀꠡ꠆ꠔꠣ ꠞꠣꠎꠔ꠆ꠔꠞ ꠢꠇꠟ ꠐꠣꠃꠘ ꠀꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠡꠢ ꠡꠛ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_34","005_32_34","NUM","32","34","34","ꠔꠦꠃ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠖꠤꠛꠣꠘ, ꠅꠐꠣꠞꠥꠔ, ꠀꠞꠥꠀꠞ, ");
INSERT INTO syls_vpl VALUES ("NU32_35","005_32_35","NUM","32","35","35","ꠀꠐꠞꠥꠔ-ꠡꠥꠚꠣꠘ, ꠎꠣꠎꠤꠞꠣ, ꠎꠉꠛꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("NU32_36","005_32_36","NUM","32","36","36","ꠛꠣꠄꠔ-ꠘꠤꠝꠞꠣ, ꠛꠣꠄꠔ-ꠢꠣꠞꠣꠘ ꠘꠣꠝꠞ ꠉꠣꠃꠀꠁꠘ ꠀꠞ ꠐꠣꠃꠘ ꠅꠇꠟꠞꠦ ꠃꠌꠣ ꠃꠌꠣ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠅꠀꠟ ꠉꠣꠕꠤꠀ ꠝꠎꠛꠥꠔ ꠇꠞꠟꠣ। ꠄꠞꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠕꠁꠛꠣꠞ ꠎꠣꠉꠣꠅ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_37","005_32_37","NUM","32","37","37","ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠢꠤꠡꠛꠘ, ꠁꠟꠤꠀꠟꠤ, ꠇꠤꠞꠤꠀꠔꠣꠁꠝ ꠐꠣꠃꠘ, ");
INSERT INTO syls_vpl VALUES ("NU32_38","005_32_38","NUM","32","38","38","ꠀꠞ ꠘꠛꠅ, ꠛꠣꠀꠟ-ꠝꠤꠃꠘ, ꠍꠤꠛꠝꠣ ꠘꠣꠝꠞ ꠉꠣꠃꠀꠁꠘ ꠑꠤꠇ-ꠑꠣꠇ ꠇꠞꠟꠣ। ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠁꠔꠣꠞ ꠘꠄꠀ ꠘꠣꠝ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_39","005_32_39","NUM","32","39","39","ꠝꠣꠘꠡꠣꠞ ꠙꠥꠀ ꠝꠣꠈꠤꠞꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠉꠤꠟꠤꠅꠖꠅ ꠉꠤꠀ ꠀꠉꠦꠃ ꠁꠔꠣ ꠖꠈꠟ ꠇꠞꠤꠟꠤꠍꠤꠟ, ꠀꠞ ꠢꠘꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU32_40","005_32_40","NUM","32","40","40","ꠄꠞꠟꠣꠉꠤ ꠝꠥꠍꠣꠄ ꠝꠣꠘꠡꠣꠞ ꠅꠃ ꠀꠅꠟꠣꠖ ꠝꠣꠈꠤꠞꠤ ꠅꠇꠟꠞ ꠛꠣꠐꠅ ꠉꠤꠟꠤꠅꠖ ꠄꠟꠣꠇꠣꠞꠦ ꠖꠤꠟꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠅꠘꠅ ꠛꠡꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU32_41","005_32_41","NUM","32","41","41","ꠄꠞꠝꠣꠎꠦ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠣꠄꠁꠞ ꠘꠣꠝꠞ ꠄꠇꠎꠘꠦ ꠉꠤꠀ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠢꠇꠟ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠖꠈꠟ ꠇꠞꠤꠟꠤꠍꠤꠟ, ꠀꠞ ꠁꠔꠣꠞ ꠘꠣꠝ ꠖꠤꠍꠤꠟ ꠢꠣꠛ꠆ꠛꠥꠔ-ꠎꠣꠄꠁꠞ। ");
INSERT INTO syls_vpl VALUES ("NU32_42","005_32_42","NUM","32","42","42","ꠀꠞ ꠘꠥꠛꠣ ꠘꠣꠝꠞ ꠄꠇꠎꠘꠦ ꠉꠤꠀ ꠇꠘꠣꠔ ꠀꠞ ꠄꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠅꠇꠟ ꠖꠈꠟ ꠇꠞꠤꠀ, ꠔꠣꠞ ꠘꠤꠎꠞ ꠘꠣꠝꠦ ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠖꠤꠟ ꠘꠥꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_1","005_33_1","NUM","33","1","1","ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠘꠛꠤꠞ ꠘꠦꠔꠣꠉꠤꠞꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠚꠃꠎꠤ ꠖꠟ ꠢꠣꠎꠤꠀ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠅꠀꠞ ꠛꠣꠖꠦ ꠘꠣꠘꠣꠘ ꠎꠣꠉꠣꠔ ꠖꠝ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_2","005_33_2","NUM","33","2","2","ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔꠣꠞꠣꠞ ꠖꠝ ꠟꠅꠀꠞ ꠎꠣꠉꠣꠁꠘ꠆ꠔꠞ ꠘꠣꠝ ꠟꠦꠈꠤꠀ ꠕꠁꠟꠣ। ꠅꠃ ꠎꠣꠉꠣꠁꠘ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("NU33_3","005_33_3","NUM","33","3","3","ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠌꠣꠘ꠆ꠖꠞ ꠙꠘꠞ ꠔꠣꠞꠤꠈ, ꠝꠣꠘꠤ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠛꠣꠖꠞ ꠖꠤꠘ, ꠔꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠞꠣꠝꠣꠡꠦꠡ ꠄꠟꠣꠇꠣ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ꠝꠤꠡꠞꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦꠖꠤ ꠔꠣꠞꠣ ꠛꠥꠇ ꠚꠥꠟꠣꠁꠀ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_4","005_33_4","NUM","33","4","4","ꠅꠃ ꠡꠝꠄ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠛꠠ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠣꠡ ꠖꠣꠚꠘ ꠇꠞꠣꠔ ꠀꠍꠤꠟ। ꠝꠣꠛꠥꠖꠦ ꠀꠉꠞ ꠞꠣꠁꠔ ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠊꠞꠞ ꠛꠠ ꠙꠥꠀꠂꠘꠞꠦ ꠝꠣꠞꠤꠟꠤꠍꠟꠣ। ꠔꠣꠁꠘ ꠅꠔꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠃꠙꠞꠦꠅ ꠉꠎꠛ ꠓꠣꠟꠤꠀ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_5","005_33_5","NUM","33","5","5","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠞꠣꠝꠣꠡꠦꠡ ꠄꠟꠣꠇꠣ ꠍꠣꠠꠤꠀ ꠡꠥꠇ꠆ꠇꠔꠅ ꠀꠁꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_6","005_33_6","NUM","33","6","6","ꠛꠣꠖꠦ ꠡꠥꠇ꠆ꠇꠔ ꠕꠣꠇꠤ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠄꠕꠝ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠀꠁꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_7","005_33_7","NUM","33","7","7","ꠀꠞ ꠄꠕꠝ ꠕꠣꠇꠤ ꠛꠣꠀꠟ-ꠎꠣꠚꠘꠞ ꠍꠣꠝꠘꠦ ꠝꠤꠉꠖꠥꠟꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠚꠣꠝꠣ-ꠢꠤꠞꠥꠔ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠀꠁꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_8","005_33_8","NUM","33","8","8","ꠛꠣꠖꠦ ꠚꠣꠝꠣ-ꠢꠤꠞꠥꠔ ꠕꠣꠇꠤ ꠖꠞꠤꠀ ꠙꠣꠞ ꠅꠁꠀ ꠄꠕꠝ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠦꠟꠣ, ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤ ꠛꠣꠄ ꠔꠤꠘ ꠖꠤꠘꠞ ꠙꠕ ꠙꠣꠠꠤ ꠖꠤꠀ ꠝꠣꠞꠥꠀꠔ ꠉꠤꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_9","005_33_9","NUM","33","9","9","ꠛꠣꠖꠦ ꠝꠣꠞꠥꠀ ꠕꠣꠇꠤ ꠄꠟꠤꠝꠅ ꠉꠦꠟꠣ, ꠁꠘꠅ ꠙꠣꠘꠤꠞ ꠛꠣꠞꠅꠉꠥ ꠁꠘ꠆ꠖꠣꠞꠣ ꠀꠞ ꠡꠔ꠆ꠔꠁꠞꠉꠥ ꠈꠦꠎꠥꠞ ꠉꠣꠍ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("NU33_10","005_33_10","NUM","33","10","10","ꠄꠞꠛꠣꠖꠦ ꠄꠟꠤꠝ ꠍꠣꠠꠤꠀ ꠘꠤꠟ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠅ ꠉꠤꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_11","005_33_11","NUM","33","11","11","ꠢꠘꠅ ꠕꠣꠇꠤ ꠍꠤꠘ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠁꠀ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_12","005_33_12","NUM","33","12","12","ꠀꠞ ꠍꠤꠘ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠖꠙꠇꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠇꠦꠝ꠆ꠙ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_13","005_33_13","NUM","33","13","13","ꠛꠣꠖꠦ ꠖꠙꠇꠣ ꠍꠣꠠꠤꠀ ꠀꠟꠥꠡꠅ ꠉꠤꠀ ꠇꠦꠝ꠆ꠙ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_14","005_33_14","NUM","33","14","14","ꠀꠟꠥꠡ ꠕꠣꠇꠤ ꠞꠚꠤꠖꠤꠝꠅ ꠉꠦꠟꠣ, ꠁꠘꠅ ꠈꠣꠁꠛꠣꠞ ꠇꠥꠘꠥ ꠙꠣꠘꠤ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_15","005_33_15","NUM","33","15","15","ꠔꠦꠃ ꠞꠚꠤꠖꠤꠝ ꠍꠣꠠꠤꠀ ꠔꠣꠞꠣ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠤꠀ ꠇꠦꠝ꠆ꠙ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_16","005_33_16","NUM","33","16","16","ꠄꠞꠛꠣꠖꠦ ꠍꠤꠘꠣꠁ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠇꠤꠛꠞꠥꠔ-ꠢꠥꠔꠣꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_17","005_33_17","NUM","33","17","17","ꠇꠤꠛꠞꠥꠔ-ꠢꠥꠔꠣꠛꠣ ꠕꠣꠇꠤ ꠢꠣꠎꠤꠞꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("NU33_18","005_33_18","NUM","33","18","18","ꠢꠣꠎꠤꠞꠥꠔ ꠕꠣꠇꠤ ꠞꠤꠔꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_19","005_33_19","NUM","33","19","19","ꠞꠤꠔꠝꠣ ꠕꠣꠇꠤ ꠞꠤꠝ꠆ꠝꠘ-ꠙꠦꠞꠡ। ");
INSERT INTO syls_vpl VALUES ("NU33_20","005_33_20","NUM","33","20","20","ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠟꠤꠛꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_21","005_33_21","NUM","33","21","21","ꠟꠤꠛꠘꠣ ꠕꠣꠇꠤ ꠞꠤꠍꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_22","005_33_22","NUM","33","22","22","ꠞꠤꠍꠍꠣ ꠕꠣꠇꠤ ꠇꠢꠦꠟꠣꠔꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_23","005_33_23","NUM","33","23","23","ꠛꠣꠖꠦ ꠉꠦꠟꠣ ꠡꠦꠚꠞ ꠙꠣꠠꠅ। ");
INSERT INTO syls_vpl VALUES ("NU33_24","005_33_24","NUM","33","24","24","ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠢꠞꠣꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_25","005_33_25","NUM","33","25","25","ꠢꠞꠣꠖꠣ ꠕꠣꠇꠤ ꠝꠈꠦꠟꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("NU33_26","005_33_26","NUM","33","26","26","ꠅꠘ ꠕꠣꠇꠤ ꠔꠢꠔ। ");
INSERT INTO syls_vpl VALUES ("NU33_27","005_33_27","NUM","33","27","27","ꠛꠣꠖꠦ ꠔꠣꠞꠦꠈ। ");
INSERT INTO syls_vpl VALUES ("NU33_28","005_33_28","NUM","33","28","28","ꠔꠣꠞꠦꠈ ꠕꠣꠇꠤ ꠝꠤꠔꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_29","005_33_29","NUM","33","29","29","ꠝꠤꠔꠇꠣ ꠕꠣꠇꠤ ꠢꠡꠝꠥꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_30","005_33_30","NUM","33","30","30","ꠛꠣꠖꠦ ꠝꠍꠦꠞꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("NU33_31","005_33_31","NUM","33","31","31","ꠅꠘ ꠕꠣꠇꠤ ꠛꠘꠤ-ꠁꠀꠇꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("NU33_32","005_33_32","NUM","33","32","32","ꠛꠣꠖꠦ ꠢꠥꠞ-ꠢꠉ꠆ꠉꠤꠖꠉꠖ। ");
INSERT INTO syls_vpl VALUES ("NU33_33","005_33_33","NUM","33","33","33","ꠅꠘ ꠕꠣꠇꠤ ꠎꠔꠛꠣꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_34","005_33_34","NUM","33","34","34","ꠎꠔꠛꠣꠔꠣ ꠕꠣꠇꠤ ꠅꠛꠞꠥꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_35","005_33_35","NUM","33","35","35","ꠛꠣꠖꠦ ꠁꠎꠤꠅꠘ-ꠉꠦꠛꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("NU33_36","005_33_36","NUM","33","36","36","ꠀꠞ ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠎꠤꠘ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠇꠣꠖꠦꠡ ꠄꠟꠣꠇꠣꠔ ꠉꠤꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_37","005_33_37","NUM","33","37","37","ꠛꠣꠖꠦ ꠇꠣꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠁꠖꠥꠝ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠉꠦꠍꠦ ꠢꠥꠞ ꠙꠣꠠꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_38","005_33_38","NUM","33","38","38","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁ ꠀꠅꠀꠞ ꠛꠣꠖꠦ, ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞꠞ ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠌꠣꠘ꠆ꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠦ ꠢꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠍꠟꠣ, ꠀꠞ ꠢꠘꠅ ꠔꠣꠘ ꠃꠚꠣꠔ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU33_39","005_33_39","NUM","33","39","39","ꠔꠣꠁꠘ ꠄꠇ-ꠡ ꠔꠦꠁꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠅ ꠢꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_40","005_33_40","NUM","33","40","40","ꠄꠞꠝꠣꠎꠦ ꠅꠞꠣꠖ ꠄꠟꠣꠇꠣꠞ ꠇꠦꠘꠣꠘꠤ ꠛꠣꠖꠡꠣꠄ ꠈꠛꠞ ꠙꠣꠁꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠘꠅ ꠀꠁꠍꠂꠘ। ꠔꠣꠁꠘ ꠔ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠘꠦꠉꠦꠜ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠞꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_41","005_33_41","NUM","33","41","41","ꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠢꠥꠞ ꠙꠣꠠ ꠍꠣꠠꠤꠀ ꠍꠟꠝꠥꠘꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_42","005_33_42","NUM","33","42","42","ꠍꠟꠝꠥꠘꠣ ꠕꠣꠇꠤ ꠙꠥꠘꠘ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_43","005_33_43","NUM","33","43","43","ꠙꠥꠘꠘ ꠕꠣꠇꠤ ꠅꠛꠥꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_44","005_33_44","NUM","33","44","44","ꠅꠛꠥꠔ ꠕꠣꠇꠤ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠁꠀ-ꠀꠛꠣꠞꠤꠝꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_45","005_33_45","NUM","33","45","45","ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠖꠤꠛꠣꠘ-ꠍꠣꠖꠥ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_46","005_33_46","NUM","33","46","46","ꠅꠘ ꠕꠣꠇꠤ ꠀꠟꠝꠥꠘ-ꠖꠤꠛ꠆ꠟꠣꠔꠤꠝꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_47","005_33_47","NUM","33","47","47","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠀꠛꠣꠞꠤꠝ ꠙꠣꠠꠅ ꠃꠑꠤꠀ ꠘꠛꠅ ꠘꠣꠝꠞ ꠐꠤꠟ꠆ꠟꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠇꠦꠝ꠆ꠙ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_48","005_33_48","NUM","33","48","48","ꠄꠞꠛꠣꠖꠦ ꠀꠛꠣꠞꠤꠝ ꠙꠣꠠ ꠍꠣꠠꠤꠀ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠃꠟꠐꠣꠛꠣꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_49","005_33_49","NUM","33","49","49","ꠁ ꠇꠦꠝ꠆ꠙꠞ ꠡꠤꠝꠣꠘꠣ ꠀꠍꠤꠟ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠅ ꠝꠥꠀꠛ ꠄꠟꠣꠇꠣꠞ ꠔꠟ ꠎꠣꠉꠣ ꠛꠣꠄꠔ-ꠎꠤꠡꠤꠝꠥꠔ ꠕꠣꠇꠤ ꠀꠛꠦꠟ-ꠡꠤꠐꠤꠝ ꠐꠣꠃꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("NU33_50","005_33_50","NUM","33","50","50","ꠀꠞ ꠅꠃ ꠡꠝꠄ ꠎꠤꠞꠤꠢꠅ ꠄꠟꠣꠇꠣꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠗꠣꠞꠅ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU33_51","005_33_51","NUM","33","51","51","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠉꠤꠀ ꠀꠎꠤꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU33_52","005_33_52","NUM","33","52","52","ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠢꠘꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠛꠣꠄ। ꠈꠦꠖꠣꠁꠀ ꠔꠣꠞꠣꠞ ꠙꠣꠔ꠆ꠔꠞ ꠈꠥꠖꠤꠀ ꠛꠣꠘꠣꠁꠟ ꠢꠇꠟ ꠝꠥꠞ꠆ꠔꠤ ꠜꠣꠋꠉꠤꠀ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠛꠣꠄ। ꠢꠥꠘꠣꠞꠞ ꠀꠔꠤꠀꠞꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠢꠇꠟ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣꠄ। ꠀꠞ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠞ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠞ ꠙꠡꠥꠞ-ꠛꠟꠤ ꠈꠣꠘꠣꠁꠘ ꠔꠥꠟꠤꠀ ꠚꠣꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU33_53","005_33_53","NUM","33","53","53","ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠤꠀ ꠢꠘꠅ ꠛꠡꠔ ꠇꠞꠛꠣꠄ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠖꠈꠟꠖꠣꠞꠤꠞ ꠟꠣꠉꠤ ꠁ ꠖꠦꠡꠈꠣꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("NU33_54","005_33_54","NUM","33","54","54","ꠢꠘꠅ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠎꠣꠉꠣ ꠛꠣꠐꠤꠀ ꠘꠤꠅ। ꠎꠦ ꠉꠥꠡ꠆ꠐꠤꠔ ꠛꠦꠡꠤ ꠝꠣꠘꠥꠡ ꠔꠣꠞꠣꠞꠦ ꠛꠦꠡꠤ ꠎꠣꠉꠣ, ꠀꠞ ꠇꠝ ꠅꠁꠟꠦ ꠇꠝ ꠎꠣꠉꠣ ꠖꠤꠅ। ꠟꠐꠣꠞꠤꠔ ꠎꠦ ꠉꠥꠡ꠆ꠐꠤꠄ ꠎꠦ ꠎꠣꠉꠣ ꠙꠣꠁꠛꠣ, ꠔꠣꠞꠣ ꠅꠘꠅꠃ ꠛꠡꠔ ꠇꠞꠛꠣ। ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠄ ꠎꠣꠞꠎꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠟꠣꠇꠣꠞ ꠝꠣꠎꠦ ꠎꠣꠉꠣ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_55","005_33_55","NUM","33","55","55","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠢꠘꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠘꠣ ꠖꠦꠈꠣꠅ, ꠔꠦ ꠔꠣꠞꠣꠞ ꠎꠦꠉꠥꠁꠘ ꠞꠁꠛꠣ, ꠁꠉꠥꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠇꠣꠐꠣ ꠀꠞ ꠛꠥꠇꠥꠞ ꠍꠦꠟ ꠛꠘꠤꠀ ꠞꠁꠛꠣ। ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠡꠔꠤ ꠎꠝꠤꠘꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔꠅ ꠚꠣꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU33_56","005_33_56","NUM","33","56","56","ꠢꠃ ꠡꠝꠄ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠡꠣꠎꠣ ꠖꠤꠝꠥ, ꠎꠦ ꠡꠣꠎꠣ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠑꠤꠇ ꠇꠞꠤꠀ ꠕꠁꠍꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("NU34_1","005_34_1","NUM","34","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU34_2","005_34_2","NUM","34","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠝꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠎꠣꠘꠣꠁ ꠖꠦꠅ, ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠢꠘꠅ ꠎꠦ ꠎꠣꠉꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠙꠣꠁꠛꠣꠄ, ꠁ ꠎꠣꠉꠣꠞ ꠡꠤꠝꠣꠘꠣ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("NU34_3","005_34_3","NUM","34","3","3","ꠁꠖꠥꠝ ꠖꠦꠡꠞ ꠛꠒꠣꠞꠞ ꠎꠤꠘ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠤꠍꠥ ꠄꠟꠣꠇꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠖꠃꠇꠘꠞ ꠡꠤꠝꠣꠘꠣ। ꠛꠣꠖꠦ ꠅꠃ ꠖꠃꠇꠘꠞ ꠡꠤꠝꠣꠘꠣ ꠕꠣꠇꠤ ꠙꠥꠛꠦꠖꠤ ꠉꠤꠀ ꠟꠥꠘꠣ ꠡꠣꠉꠞꠞ ꠢꠦꠡ ꠝꠣꠕꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("NU34_4","005_34_4","NUM","34","4","4","ꠄꠞꠟꠉꠦ ꠀꠇꠞꠣꠛ꠆ꠛꠤꠝ ꠙꠣꠠꠞ ꠙꠕ ꠙꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠤ ꠎꠤꠘ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠢꠣꠝꠣꠁꠀ ꠇꠣꠖꠦꠡ-ꠛꠞꠘꠦꠀꠞ ꠖꠃꠇꠘꠦꠖꠤ ꠡꠤꠝꠣꠘꠣ ꠎꠣꠁꠛ। ꠉꠤꠀ ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠢꠣꠎꠞ-ꠀꠖꠞ ꠅꠁꠀ ꠅꠎꠝꠥꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠞꠣꠞ ꠡꠤꠝꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU34_5","005_34_5","NUM","34","5","5","ꠀꠞ ꠅꠎꠝꠥꠘ ꠕꠣꠇꠤ ꠊꠥꠞꠤꠀ ꠝꠤꠡꠞꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠢꠥꠇꠘꠣ ꠈꠣꠟꠞ ꠙꠣꠞꠦꠖꠤ ꠜꠥꠝꠗꠤꠅ ꠡꠣꠉꠞꠅ ꠉꠤꠀ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("NU34_6","005_34_6","NUM","34","6","6","“ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠙꠁꠌꠝꠞ ꠡꠤꠝꠣꠘꠣ ꠅꠁꠛ ꠜꠥꠝꠗꠤꠅ ꠡꠣꠉꠞ। ꠁꠐꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠙꠁꠌꠝꠞ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("NU34_7","005_34_7","NUM","34","7","7","“ꠔꠥꠝꠞꠣꠞ ꠃꠔꠞꠞ ꠡꠤꠝꠣꠘꠣ ꠅꠁꠛ, ꠜꠥꠝꠗꠤꠅ ꠡꠣꠉꠞ ꠕꠣꠇꠤ ꠢꠥꠞ ꠘꠣꠝꠞ ꠙꠣꠠ, ");
INSERT INTO syls_vpl VALUES ("NU34_8","005_34_8","NUM","34","8","8","ꠅꠃ ꠙꠣꠠ ꠕꠣꠇꠤ ꠢꠣꠝꠣꠔꠅ ꠎꠣꠁꠛꠣꠞ ꠙꠕ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠢꠣꠝꠣꠔꠞ ꠙꠕ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠡꠤꠝꠣꠘꠣ ꠎꠤꠖꠣꠖ ꠉꠣꠃ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU34_9","005_34_9","NUM","34","9","9","ꠀꠞ ꠎꠤꠖꠣꠖ ꠕꠣꠇꠤ ꠎꠤꠚꠞꠥꠘ ꠅꠁꠀ ꠢꠣꠎꠞ-ꠅꠘꠘꠅ ꠉꠤꠀ ꠡꠦꠡ ꠅꠁꠛ। ꠁꠐꠣꠃ ꠅꠁꠛ ꠔꠥꠝꠞꠣꠞ ꠃꠔꠞꠞ ꠡꠤꠝꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU34_10","005_34_10","NUM","34","10","10","“ꠖꠦꠡꠞ ꠙꠥꠛꠞ ꠡꠤꠝꠣꠘꠣ ꠅꠁꠟ, ꠢꠣꠎꠞ-ꠅꠘꠘ ꠕꠣꠇꠤ ꠡꠚꠣꠝ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠄꠇꠐꠣ ꠡꠤꠝꠣꠘꠣ ꠀꠁꠟ ꠑꠤꠇ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("NU34_11","005_34_11","NUM","34","11","11","ꠅꠃ ꠡꠚꠣꠝꠞ ꠡꠤꠝꠣꠘꠣ ꠕꠣꠇꠤ ꠅꠂꠘ ꠉꠣꠃꠞ ꠙꠥꠛꠦꠖꠤ ꠉꠤꠀ ꠞꠤꠛꠟꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠁꠀ ꠟꠣꠝꠛ, ꠟꠣꠝꠤꠀ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠌꠞꠦꠖꠤ ꠎꠣꠁꠛ, ");
INSERT INTO syls_vpl VALUES ("NU34_12","005_34_12","NUM","34","12","12","ꠉꠤꠀ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠦꠖꠤ ꠟꠥꠘꠣ ꠡꠣꠉꠞꠅ ꠀꠁꠀ ꠡꠦꠡ ꠅꠁꠛ। ꠅꠃ ꠡꠛ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠡꠤꠝꠣꠘꠣ ꠀꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("NU34_13","005_34_13","NUM","34","13","13","ꠀꠞ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠅ, ꠝꠣꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠘꠄ ꠈꠣꠘ꠆ꠖꠣꠘ ꠀꠞ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠅꠞ꠆ꠗꠦꠇ ꠝꠣꠘꠡꠞꠦ ꠅꠃ ꠖꠦꠡꠞ ꠎꠝꠤ-ꠝꠣꠐꠤ ꠛꠣꠐꠤꠀ ꠖꠤꠀ, ꠔꠥꠝꠞꠣꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠇꠣꠁꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("NU34_14","005_34_14","NUM","34","14","14","ꠎꠣꠘ ꠔ, ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘ ꠀꠞ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠅꠞ꠆ꠗꠦꠇ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠡ꠆ꠐꠤ ꠝꠣꠚꠤꠇ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠛꠣꠐ ꠀꠉꠦꠃ ꠙꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("NU34_15","005_34_15","NUM","34","15","15","ꠔꠣꠞꠣ ꠎꠤꠞꠤꠢꠅ ꠄꠟꠣꠇꠣꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛꠞ ꠙꠣꠞꠅ ꠔꠣꠞꠣꠞ ꠛꠣꠐ ꠀꠉꠦꠃ ꠛꠣꠍꠤꠀ ꠘꠤꠍꠂꠘꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU34_16","005_34_16","NUM","34","16","16","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU34_17","005_34_17","NUM","34","17","17","“ꠅꠃ ꠖꠦꠡꠞ ꠎꠝꠤ-ꠝꠣꠐꠤꠞꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠔꠦ ꠎꠦꠞꠣ ꠝꠣꠔꠛ꠆ꠛꠞꠤ ꠇꠞꠛꠣ, ꠄꠞꠣꠞ ꠘꠣꠝ ꠅꠁꠟ, ꠁꠝꠣꠝ ꠀꠟꠤ-ꠀꠎꠞ ꠀꠞ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("NU34_18","005_34_18","NUM","34","18","18","ꠎꠝꠤ-ꠎꠝꠣ ꠛꠣꠐꠤꠛꠣꠞ ꠇꠣꠟꠅ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠕꠣꠇꠤ ꠄꠇꠎꠘ ꠇꠞꠤ ꠡꠞ꠆ꠖꠣꠞ ꠘꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU34_19","005_34_19","NUM","34","19","19","ꠅꠃ ꠡꠞ꠆ꠖꠣꠞ ꠅꠁꠟꠣ, ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠤꠚꠥꠘ꠆ꠘꠤꠞ ꠙꠥꠀ ꠇꠣꠟꠥꠔ, ");
INSERT INTO syls_vpl VALUES ("NU34_20","005_34_20","NUM","34","20","20","ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠀꠝꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠡꠣꠝꠥꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("NU34_21","005_34_21","NUM","34","21","21","ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠇꠤꠍꠟꠥꠘꠞ ꠙꠥꠀ ꠁꠟꠤꠖꠖ, ");
INSERT INTO syls_vpl VALUES ("NU34_22","005_34_22","NUM","34","22","22","ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠃꠎꠟꠤꠞ ꠙꠥꠀ ꠛꠥꠇ꠆ꠇꠤ, ");
INSERT INTO syls_vpl VALUES ("NU34_23","005_34_23","NUM","34","23","23","ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠁꠚꠣꠖꠞ ꠙꠥꠀ ꠢꠣꠘ꠆ꠘꠤꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("NU34_24","005_34_24","NUM","34","24","24","ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠀꠚꠞꠣꠁꠝ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠡꠤꠙ꠆ꠔꠘꠞ ꠙꠥꠀ ꠇꠝꠥꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("NU34_25","005_34_25","NUM","34","25","25","ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠚꠞ꠆ꠘꠣꠈꠞ ꠙꠥꠀ ꠁꠟꠤꠎꠣꠚꠘ, ");
INSERT INTO syls_vpl VALUES ("NU34_26","005_34_26","NUM","34","26","26","ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠀꠎꠣꠘꠞ ꠙꠥꠀ ꠚꠟꠔꠤꠄꠟ, ");
INSERT INTO syls_vpl VALUES ("NU34_27","005_34_27","NUM","34","27","27","ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠡꠟꠝꠤꠞ ꠙꠥꠀ ꠅꠢꠤꠢꠥꠖ, ");
INSERT INTO syls_vpl VALUES ("NU34_28","005_34_28","NUM","34","28","28","ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠀꠝꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠙꠖꠢꠦꠟ।” ");
INSERT INTO syls_vpl VALUES ("NU34_29","005_34_29","NUM","34","29","29","ꠝꠣꠛꠥꠖꠦ ꠅꠃ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠤ ꠡꠝꠎꠣꠁꠟꠣ, ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠝꠤ-ꠎꠝꠣ ꠛꠣꠐꠤꠀ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("NU35_1","005_35_1","NUM","35","1","1","ꠛꠣꠖꠦ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠇꠣꠍꠣꠔ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠗꠣꠞꠅ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU35_2","005_35_2","NUM","35","2","2","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠛꠣꠐ ꠙꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠅꠔꠣ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠐꠣꠃꠘ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠖꠤꠟꠣꠁꠔꠣ, ꠄꠞꠣ ꠅꠘꠅ ꠞꠁꠛꠣ, ꠄꠞꠟꠉꠦ ꠛꠘ꠆ꠖꠞ ꠇꠤꠍꠥ ꠎꠝꠤꠅ ꠄꠞꠣꠞꠦ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("NU35_3","005_35_3","NUM","35","3","3","ꠅꠃ ꠐꠣꠃꠘꠅ ꠔꠣꠞꠣ ꠛꠡꠔ ꠇꠞꠛꠣ, ꠀꠞ ꠛꠘ꠆ꠖꠞ ꠎꠝꠤꠘꠅ ꠔꠣꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU35_4","005_35_4","NUM","35","4","4","ꠔꠥꠝꠞꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠎꠦ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠤꠛꠣꠄ, ꠁꠔꠣꠞ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠅꠀꠟꠞ ꠛꠣꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠅ ꠄꠇ ꠀꠎꠣꠞ ꠀꠔ ꠎꠣꠉꠣ ꠖꠤꠛꠣꠄ, ꠔꠣꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("NU35_5","005_35_5","NUM","35","5","5","ꠔꠥꠝꠞꠣ ꠎꠔ ꠐꠣꠃꠘ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠛꠣꠄ, ꠁꠔꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠅꠀꠟꠞ ꠛꠣꠞꠦ, ꠝꠣꠘꠤ ꠃꠔꠞꠦ-ꠖꠃꠇꠘꠦ, ꠙꠥꠛꠦ-ꠙꠁꠌꠝꠦ, ꠢꠇ꠆ꠇꠟꠛꠣꠄ ꠀꠞꠅ ꠖꠥꠁ ꠀꠎꠣꠞ ꠀꠔ ꠛꠘ꠆ꠖꠞ ꠎꠣꠉꠣ ꠝꠣꠙꠤꠀ ꠖꠤꠅ। ꠅꠘꠅ ꠔꠣꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU35_6","005_35_6","NUM","35","6","6","“ꠔꠥꠝꠞꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠎꠦꠔꠣ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠤꠛꠣꠄ, ꠄꠞꠝꠣꠎꠞ ꠍꠄꠈꠣꠘ ꠐꠣꠃꠘ ꠅꠁꠛ ꠈꠥꠘꠤ ꠝꠣꠘꠡꠞ ꠀꠡꠞꠄ ꠐꠣꠃꠘ। ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠀꠈꠔꠣ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠞꠤꠟꠤꠟꠦ, ꠢꠦ ꠅꠃ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠀꠡꠞꠄ ꠟꠁꠛ। ꠅꠃ ꠍꠄ ꠐꠣꠃꠘ ꠛꠣꠖꠦꠅ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠀꠞꠅ ꠛꠦꠀꠟ꠆ꠟꠤꠡ ꠈꠣꠘ ꠐꠣꠃꠘ ꠖꠤꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_7","005_35_7","NUM","35","7","7","ꠝꠥꠐ ꠀꠐꠌꠣꠟ꠆ꠟꠤꠡ ꠈꠣꠘ ꠐꠣꠃꠘ ꠟꠦꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠤꠛꠣꠄ, ꠀꠞ ꠄꠞꠟꠉꠦ ꠙꠡꠥꠞ ꠙꠣꠟ ꠞꠣꠈꠣꠞ ꠛꠘ꠆ꠖꠞ ꠎꠣꠉꠣꠅ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_8","005_35_8","NUM","35","8","8","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠝꠤ-ꠎꠝꠣ ꠕꠣꠇꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠎꠦꠛꠟꠣ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠤꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠙꠣꠅꠀ ꠎꠝꠤꠘꠞ ꠛꠣꠐ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠛꠣꠄ। ꠎꠦ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠛꠦꠡꠤ ꠙꠣꠁꠍꠦ ꠄꠞꠣ ꠛꠦꠡꠤ ꠖꠤꠛꠣ, ꠀꠞ ꠎꠦꠞꠣ ꠇꠝ ꠙꠣꠁꠍꠦ ꠄꠞꠣ ꠇꠝ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("NU35_9","005_35_9","NUM","35","9","9","ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("NU35_10","005_35_10","NUM","35","10","10","“ꠔꠥꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠅ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU35_11","005_35_11","NUM","35","11","11","ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠇꠄꠈꠣꠘ ꠀꠡꠞꠄ ꠐꠣꠃꠘ ꠑꠤꠇ ꠇꠞꠤꠅ। ꠔꠦꠃ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠀꠈꠔꠣ ꠇꠎꠣ ꠇꠞꠤꠀ ꠇꠦꠃꠞꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠜꠣꠉꠤꠀ ꠢꠘꠅ ꠉꠤꠀ ꠀꠡꠞꠄ ꠟꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU35_12","005_35_12","NUM","35","12","12","ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠟꠅꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠀ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁ ꠀꠡꠞꠄ ꠐꠣꠃꠘ। ꠄꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠖꠣꠟꠔꠅ ꠛꠤꠌꠣꠞꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠈꠥꠘꠞ ꠀꠡꠣꠝꠤꠞꠦ ꠇꠦꠃ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_13","005_35_13","NUM","35","13","13","ꠄꠞꠟꠣꠉꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠔꠥꠝꠞꠣ ꠎꠦ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠤꠛꠣꠄ, ꠁꠔꠣꠞ ꠝꠣꠎꠞ ꠍꠄꠈꠣꠘ ꠐꠣꠃꠘ ꠅꠁꠛ ꠔꠥꠝꠞꠣꠞ ꠀꠡꠞꠄ ꠐꠣꠃꠘ। ");
INSERT INTO syls_vpl VALUES ("NU35_14","005_35_14","NUM","35","14","14","ꠄꠞꠝꠣꠎꠞ ꠔꠤꠘꠈꠣꠘ ꠐꠣꠃꠘ ꠅꠁꠛ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛꠞ ꠙꠣꠞꠅ, ꠀꠞ ꠔꠤꠘꠈꠣꠘ ꠅꠁꠛ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("NU35_15","005_35_15","NUM","35","15","15","ꠅꠃ ꠍꠄꠅꠈꠣꠘ ꠐꠣꠃꠘ ꠅꠁꠛ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠅꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠀꠞ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠀꠡꠞꠄ ꠐꠣꠃꠘ। ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠈꠔꠣ ꠛꠦ-ꠈꠤꠀꠟꠦ ꠇꠦꠃꠞꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠅꠈꠣꠘꠅ ꠉꠤꠀ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU35_16","005_35_16","NUM","35","16","16","“ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠟꠥꠀꠞ ꠇꠥꠘꠥ ꠀꠔꠤꠀꠞ ꠖꠤꠀ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠞꠦ ꠀꠞ ꠢꠃ ꠎꠘ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠅꠉꠥ ꠈꠥꠘꠤ। ꠅꠃ ꠈꠥꠘꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_17","005_35_17","NUM","35","17","17","ꠎꠦ ꠙꠣꠔ꠆ꠔꠞ ꠖꠤꠀ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠘ ꠇꠞꠣ ꠎꠣꠁꠛ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠙꠣꠔ꠆ꠔꠞ ꠎꠥꠖꠤ ꠇꠦꠃꠞꠞ ꠀꠔꠅ ꠕꠣꠇꠦ, ꠀꠞ ꠅꠉꠥꠖꠤ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠞꠣꠄ ꠢꠃ ꠝꠣꠘꠥꠡ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠅꠉꠥꠅ ꠈꠥꠘꠤ। ꠁ ꠈꠥꠘꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_18","005_35_18","NUM","35","18","18","ꠝꠣꠘꠥꠡ ꠈꠥꠘ ꠅꠀꠞ ꠝꠔ ꠇꠥꠘꠥ ꠟꠣꠇꠠꠤꠞ ꠎꠤꠘꠤꠡ ꠎꠥꠖꠤ ꠇꠦꠃꠞꠞ ꠀꠔꠅ ꠕꠣꠇꠦ, ꠀꠞ ꠅꠉꠥ ꠖꠤꠀ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠞꠣꠄ ꠢꠃ ꠝꠣꠘꠥꠡ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠅꠉꠥꠅ ꠈꠥꠘꠤ। ꠁ ꠈꠥꠘꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_19","005_35_19","NUM","35","19","19","ꠈꠥꠘ ꠅꠀ ꠎꠘꠞ ꠀꠙꠘ ꠎꠦ ꠝꠣꠘꠡꠦ ꠁ ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠟꠅꠀꠞ ꠇꠕꠣ, ꠈꠣꠟꠤ ꠢꠦ-ꠃ ꠅꠃ ꠈꠥꠘꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛ। ꠈꠥꠘꠤꠞ ꠖꠦꠈꠣ ꠙꠣꠁꠟꠦꠃ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("NU35_20","005_35_20","NUM","35","20","20","“ꠀꠞ ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠄꠇ ꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞꠦ ꠒꠦꠇ꠆ꠇꠣ ꠝꠣꠞꠦ, ꠛꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠅꠡꠔ꠆ꠞꠖꠤ ꠁꠌ꠆ꠍꠣ ꠇꠞꠤꠀ ꠁꠐꠣ ꠝꠣꠞꠦ ꠀꠞ ꠢꠃ ꠝꠣꠘꠥꠡ ꠝꠞꠤꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU35_21","005_35_21","NUM","35","21","21","ꠛꠣ ꠖꠥꠡꠝꠘꠤꠞ ꠜꠣꠛꠦ ꠇꠦꠃꠞꠞꠦ ꠊꠥꠡꠤ ꠝꠣꠞꠦ ꠀꠞ ꠢꠦ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠎꠦ ꠝꠣꠞꠍꠦ ꠢꠦ ꠈꠥꠘꠤ। ꠁ ꠈꠥꠘꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ꠈꠥꠘ ꠅꠀ ꠎꠘꠞ ꠀꠙꠘ ꠎꠦ ꠝꠣꠘꠡꠦ ꠁ ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠟꠅꠀꠞ ꠇꠕꠣ, ꠢꠦ ꠅꠃ ꠈꠥꠘꠤꠞ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠟꠦꠃ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("NU35_22","005_35_22","NUM","35","22","22","“ꠅꠁꠟꠦ ꠝꠘꠅ ꠇꠥꠘꠥ ꠖꠥꠡꠝꠘꠤ ꠘꠣ ꠞꠣꠈꠤꠀ ꠜꠥꠟꠦ ꠀꠈꠔꠣ ꠇꠦꠃꠞꠞꠦ ꠒꠦꠇ꠆ꠇꠣ ꠝꠣꠞꠟꠦ, ꠛꠣ ꠝꠘꠅ ꠇꠥꠘꠥ ꠈꠣꠞꠣꠙꠤ ꠘꠣ ꠕꠣꠇꠟꠦꠅ ꠜꠥꠟꠦ ꠔꠣꠞ ꠃꠙꠞꠦ ꠁꠐꠣ ꠝꠣꠞꠤ ꠖꠤꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("NU35_23","005_35_23","NUM","35","23","23","ꠛꠣ ꠘꠣ ꠖꠦꠈꠤꠀ, ꠝꠣꠘꠥꠡ ꠝꠞꠤꠎꠤꠛꠣꠞ ꠎꠥꠇꠣ ꠇꠥꠘꠥ ꠙꠣꠔ꠆ꠔꠞ ꠇꠦꠃꠞꠞ ꠃꠙꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠦ ꠢꠦ ꠎꠥꠖꠤ ꠝꠞꠤꠎꠣꠄ, ꠔꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠖꠥꠡꠝꠘꠤꠞ ꠜꠣꠛ ꠘꠣ ꠕꠣꠇꠣꠄ, ꠀꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠇꠥꠘꠥ ꠁꠌ꠆ꠍꠣ ꠘꠣ ꠕꠣꠇꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("NU35_24","005_35_24","NUM","35","24","24","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠖꠣꠟꠔꠞ ꠝꠣꠘꠡꠦ, ꠅꠃ ꠈꠥꠘꠤꠞ ꠀꠞ ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠟꠅꠞꠣ ꠎꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠃ ꠘꠤꠅꠝ ꠝꠣꠘꠤꠀ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("NU35_25","005_35_25","NUM","35","25","25","ꠅꠃ ꠡꠝꠄ ꠀꠖꠣꠟꠔꠞ ꠝꠣꠘꠡꠦ ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠟꠅꠞꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠈꠥꠘꠤ ꠎꠘꠞꠦ ꠛꠣꠌꠣꠁꠛꠣ, ꠛꠣꠌꠣꠁꠀ ꠢꠦ ꠀꠉꠦ ꠎꠦꠈꠣꠘꠅ ꠜꠣꠉꠤꠀ ꠉꠦꠍꠤꠟ, ꠢꠃ ꠀꠡꠞꠄ ꠐꠣꠃꠘꠅ ꠔꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠙꠃꠍꠣꠁ ꠖꠤꠛꠣ। ꠀꠞ ꠙꠛꠤꠔ꠆ꠞ ꠔꠦꠟ ꠖꠤꠀ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠅꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠝꠃꠔꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠢꠘꠅ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU35_26","005_35_26","NUM","35","26","26","ꠅꠁꠟꠦ ꠢꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠡꠝꠄ ꠢꠃ ꠀꠡꠞꠄ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠄꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("NU35_27","005_35_27","NUM","35","27","27","ꠀꠞ ꠛꠖꠟꠣ ꠟꠅꠞꠣꠄ ꠔꠣꠞꠦ ꠙꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠄ, ꠔꠦ ꠢꠦ ꠈꠥꠘꠞ ꠖꠣꠄꠁ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_28","005_35_28","NUM","35","28","28","ꠇꠣꠞꠘ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠝꠃꠔ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠀꠡꠞꠄ ꠐꠣꠃꠘꠅ ꠞꠅꠀꠞ ꠇꠕꠣ। ꠈꠣꠟꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠢꠦ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠚꠤꠞꠤꠀ ꠀꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("NU35_29","005_35_29","NUM","35","29","29","ꠔꠥꠝꠞꠣ ꠖꠦꠡꠞ ꠎꠦꠘꠅꠃ ꠛꠡꠔ ꠇꠞꠅ ꠘꠣ ꠇꠦꠘꠦ, ꠅꠀꠞꠤꠡꠞ ꠙꠞ ꠅꠀꠞꠤꠡ ꠗꠞꠤ ꠁꠔꠣ ꠝꠣꠘꠔꠦ ꠅꠁꠛ, ꠁꠔꠣ ꠔ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠄꠇꠐꠣ ꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("NU35_30","005_35_30","NUM","35","30","30","“ꠡꠣꠇ꠆ꠇꠤꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤꠞ ꠃꠙꠞꠦ ꠘꠤꠞꠜꠞ ꠇꠞꠤꠀ ꠈꠥꠘꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠅꠀ ꠅꠁꠛ। ꠅꠁꠟꠦ ꠈꠣꠟꠤ ꠄꠇꠎꠘ ꠡꠣꠇ꠆ꠇꠤꠞ ꠇꠕꠣꠄ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠞꠤꠟꠣꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_31","005_35_31","NUM","35","31","31","ꠝꠃꠔꠃ ꠎꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠈꠥꠘꠤꠞꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠐꠦꠇꠣꠞ ꠛꠖꠟꠣ ꠈꠣꠟꠣꠍ ꠖꠦꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔꠦꠃ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU35_32","005_35_32","NUM","35","32","32","ꠀꠡꠞꠄ ꠐꠣꠃꠘꠅ ꠞꠅꠞꠣ ꠇꠥꠘꠥ ꠀꠡꠣꠝꠤꠞꠦ ꠐꠦꠇꠣꠞ ꠛꠖꠟꠣ, ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠝꠃꠔꠞ ꠀꠉꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠚꠤꠞꠣꠁ ꠀꠘꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("NU35_33","005_35_33","NUM","35","33","33","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠁꠔꠣ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠖꠦꠡꠞ ꠝꠣꠐꠤꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠞꠤꠅ ꠘꠣ। ꠎꠣꠘ ꠔ, ꠈꠥꠘꠞ ꠟꠃꠄ ꠖꠦꠡ ꠘꠣꠙꠣꠇ ꠅꠁꠎꠣꠄ। ꠀꠞ ꠎꠦ ꠖꠦꠡꠅ ꠈꠥꠘꠞ ꠟꠃ ꠏꠞꠍꠦ, ꠢꠃ ꠈꠥꠘꠤꠞ ꠟꠃ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠢꠤ ꠖꠦꠡꠞ ꠘꠣꠙꠣꠇꠤꠞ ꠇꠚꠞꠣ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("NU35_34","005_35_34","NUM","35","34","34","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡꠅ ꠞꠁꠛꠣꠄ ꠀꠝꠤꠅ ꠔ ꠢꠘꠅ ꠞꠁꠝꠥ, ꠄꠞꠟꠣꠉꠤ ꠁ ꠖꠦꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ꠇꠣꠞꠘ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU36_1","005_36_1","NUM","36","1","1","ꠁꠃꠍꠥꠚ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠅꠇꠟ ꠕꠣꠇꠤ, ꠝꠣꠘꠡꠣꠞ ꠘꠣꠔꠤ ꠝꠣꠈꠤꠞꠞ ꠙꠥꠀ ꠉꠤꠟꠤꠅꠖ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠣꠘꠣꠘ ꠙꠞꠤꠛꠣꠞ ꠕꠣꠇꠤ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠔꠣꠞꠣ ꠝꠥꠍꠣ ꠘꠛꠤ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠘꠣꠘꠣꠘ ꠉꠥꠡ꠆ꠐꠤꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU36_2","005_36_2","NUM","36","2","2","ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞ ꠁ ꠝꠣꠟꠤꠇꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠖꠦꠡꠞ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠛꠣꠐꠤꠀ ꠖꠤꠔꠣ। ꠖꠤꠛꠣꠞ ꠡꠝꠄ ꠀꠝꠞꠣꠞ ꠜꠣꠁ ꠎꠟꠣꠙꠈꠣꠖꠞ ꠎꠝꠤ-ꠎꠝꠣ ꠈꠣꠘꠣꠁꠘ ꠔꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠖꠤꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("NU36_3","005_36_3","NUM","36","3","3","ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠎꠥꠖꠤ ꠅꠃ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠛꠤꠀ ꠅꠄ, ꠔꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠍꠣꠝꠣꠘꠣ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠣꠘꠣ ꠛꠣꠞ ꠅꠁꠀ ꠉꠤꠀ, ꠔꠣꠞꠣꠞ ꠎꠣꠝꠣꠁꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠝꠤ-ꠎꠝꠣꠔ ꠢꠣꠝꠣꠁꠎꠤꠛ, ꠄꠔꠦ ꠀꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡꠞ ꠇꠤꠍꠥ ꠅꠋꠡ ꠇꠝꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("NU36_4","005_36_4","NUM","36","4","4","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠚꠤꠞꠔ ꠙꠣꠅꠀꠞ ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞꠞ ꠇꠣꠟꠅ, ꠔꠣꠞꠣꠞ ꠎꠝꠤ-ꠎꠝꠣ ꠉꠤꠀ ꠔ ꠔꠣꠞꠣꠞ ꠎꠣꠝꠣꠁꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠍꠣꠝꠣꠘꠣ ꠅꠁꠎꠤꠛ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠅꠋꠡ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠛꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("NU36_5","005_36_5","NUM","36","5","5","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, “ꠁꠃꠍꠥꠚꠞ ꠀꠅꠟꠣꠖꠞ ꠅꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠇꠁꠞꠣ, ꠁꠔꠣ ꠔ ꠢꠣꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("NU36_6","005_36_6","NUM","36","6","6","ꠄꠞꠟꠣꠉꠤ ꠎꠟꠣꠙꠈꠣꠖꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣ, ꠔꠣꠞꠣ ꠎꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ ꠔꠣꠞ ꠉꠦꠍꠦꠃ ꠛꠤꠀ ꠛꠁꠔꠣ ꠙꠣꠞꠛꠣ। ꠅꠁꠟꠦ ꠡꠞ꠆ꠔ ꠅꠁꠟ, ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠜꠤꠔꠞꠦ ꠛꠤꠀ ꠛꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU36_7","005_36_7","NUM","36","7","7","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠄꠇ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠀꠞꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠎꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠔꠦꠇ ꠎꠘꠦ ꠔꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠛꠣꠌꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("NU36_8","005_36_8","NUM","36","8","8","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠔꠦꠇꠦ ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠐꠤꠇꠣꠁ ꠞꠣꠈꠔ ꠙꠣꠞꠦ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠙꠣꠅꠀ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠡꠣꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠛꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("NU36_9","005_36_9","NUM","36","9","9","ꠄꠇ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠀꠞꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠇꠥꠘꠥ ꠎꠝꠤ-ꠎꠝꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠔꠣꠞꠣꠞ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠗꠞꠤꠀ ꠞꠣꠈꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("NU36_10","005_36_10","NUM","36","10","10","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠎꠟꠣꠙꠈꠣꠖꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠅꠟꠣ ꠝꠣꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU36_11","005_36_11","NUM","36","11","11","ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠛꠁꠟꠣ। ꠎꠟꠣꠙꠈꠣꠖꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠘꠣꠝ ꠅꠁꠟ, ꠝꠢꠟꠣ, ꠔꠤꠞꠎꠣ, ꠢꠉꠟꠣ, ꠝꠤꠟꠇꠣ, ꠀꠞ ꠘꠥꠀ। ");
INSERT INTO syls_vpl VALUES ("NU36_12","005_36_12","NUM","36","12","12","ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠝꠣꠘꠡꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠉꠥꠡ꠆ꠐꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦꠃ ꠔꠣꠞꠣ ꠛꠤꠀ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("NU36_13","005_36_13","NUM","36","13","13","ꠀꠞ ꠢꠥꠘꠅ, ꠎꠤꠞꠤꠢꠅ ꠄꠟꠣꠇꠣꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠗꠣꠞꠅ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠔꠟ ꠎꠣꠉꠣꠔ, ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠅꠇꠟ ꠖꠤꠍꠟꠣ॥");
INSERT INTO syls_vpl VALUES ("DT1_1","006_1_1","DEU","1","1","1","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛ ꠙꠣꠞꠞ ꠀꠞꠣꠛꠣ ꠘꠣꠝꠞ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞꠦ ꠅꠃ ꠛꠄꠀꠘ ꠇꠞꠍꠟꠣ, ꠔꠣꠁꠘ ꠡꠥꠚ ꠉꠣꠃꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠟꠣ। ꠄꠞ ꠄꠇꠛꠣꠄ ꠀꠍꠤꠟ ꠚꠣꠞꠣꠘ, ꠀꠞ ꠅꠁꠘ꠆ꠘꠛꠣꠄ ꠀꠍꠤꠟ ꠔꠥꠚꠟ, ꠟꠣꠛꠘ, ꠢꠣꠎꠤꠞꠥꠔ ꠀꠞ ꠖꠤꠎꠣꠢꠣꠛ, ꠅꠃ ꠌꠣꠁꠞ ꠉꠣꠃ। ");
INSERT INTO syls_vpl VALUES ("DT1_2","006_1_2","DEU","1","2","2","ꠍꠦꠁꠞꠞ ꠙꠣꠠꠤꠀ ꠙꠕꠦꠖꠤ ꠔꠥꠞ ꠙꠣꠠ ꠕꠣꠇꠤ ꠇꠣꠖꠦꠡ-ꠛꠞꠘꠦꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠐꠤꠀ ꠎꠣꠁꠔꠦ ꠈꠣꠟꠤ ꠄꠉꠣꠞꠅ ꠖꠤꠘ ꠟꠣꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("DT1_3","006_1_3","DEU","1","3","3","ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠃꠘꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠄꠉꠣꠞꠅ ꠝꠣꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠅꠞ꠆ꠕꠣꠔ ꠍꠚꠞꠞ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠌꠟꠣꠞ ꠇꠣꠟꠅ, ꠅꠘꠅ ꠊꠥꠞꠤꠟꠣ। ꠛꠣꠖꠦ ꠅꠃ ꠝꠣꠡꠞ ꠙꠄꠟꠣ ꠔꠣꠞꠤꠈꠅ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_4","006_1_4","DEU","1","4","4","ꠔꠣꠁꠘ ꠟꠣꠠꠣꠁ ꠇꠞꠤ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞꠦ ꠀꠞ ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠞꠦ ꠀꠞꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠁꠔꠣ ꠇꠁꠟꠣ। ꠅꠃ ꠍꠤꠢꠥꠘꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠔꠣ ꠢꠤꠡꠛꠘ ꠐꠣꠃꠘꠅ, ꠀꠞ ꠃꠎꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠔꠣ ꠅꠡ꠆ꠐꠣꠞꠥꠔ ꠀꠞ ꠁꠖꠞꠤ ꠐꠣꠃꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("DT1_5","006_1_5","DEU","1","5","5","ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛ ꠙꠣꠞꠞ ꠝꠥꠀꠛ ꠖꠦꠡꠅ, ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠔꠃꠞꠣꠔꠞ ꠔꠣꠟꠤꠝ ꠛꠄꠀꠘ ꠇꠞꠤꠀ ꠛꠥꠎꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT1_6","006_1_6","DEU","1","6","6","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠔꠥꠞ ꠙꠣꠠꠞ ꠉꠣꠟꠣꠔ ꠕꠣꠇꠣꠞ ꠇꠣꠟꠅ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠇꠁꠍꠟꠣ, ꠅꠃ ꠙꠣꠠꠞ ꠉꠣꠟꠣꠔ ꠔꠥꠝꠞꠣꠞ ꠛꠃꠔ ꠖꠤꠘ ꠉꠥꠎꠞꠤ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT1_7","006_1_7","DEU","1","7","7","ꠔꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠔꠣꠝ꠆ꠛꠥ ꠔꠥꠟꠤꠀ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣ ꠀꠞ ꠅꠃ ꠄꠟꠣꠇꠣꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠞꠅꠀꠘꠣ ꠅꠅ। ꠁ ꠎꠣꠉꠣ ꠢꠇꠟꠔꠣ ꠅꠁꠟ ꠉꠤꠀ: ꠀꠞꠣꠛꠣ ꠝꠞꠥꠜꠥꠝꠤ ꠀꠞ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠃꠌꠣ ꠙꠣꠠꠤꠀ ꠎꠣꠉꠣ ꠀꠞ ꠘꠤꠌꠣ ꠙꠣꠠꠤꠀ ꠎꠣꠉꠣ, ꠘꠦꠉꠦꠜ ꠝꠞꠥꠜꠥꠝꠤ ꠀꠞ ꠖꠞꠤꠀꠞ ꠇꠤꠘꠣꠞꠣ, ꠝꠣꠘꠤ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠞꠝ꠆ꠛ ꠇꠞꠤꠀ ꠟꠦꠛꠣꠘꠘ ꠖꠦꠡ ꠅꠁꠀ ꠚꠥꠞꠣꠔ ꠉꠣꠋ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠢꠇꠟ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_8","006_1_8","DEU","1","8","8","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠁꠔꠣ ꠢꠇꠟ ꠎꠣꠉꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠟꠣꠁꠍꠤ। ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠔꠣꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠦꠅꠀꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠉꠤꠀ ꠁꠔꠣ ꠢꠇꠟ ꠎꠣꠉꠣ ꠖꠈꠟ ꠇꠞꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("DT1_9","006_1_9","DEU","1","9","9","“ꠔꠦ ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠢꠃ ꠡꠝꠄ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠜꠣꠞ ꠔ ꠀꠝꠤ ꠄꠇꠟꠣ ꠛꠁꠛꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT1_10","006_1_10","DEU","1","10","10","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠔ ꠀꠅꠟꠣꠖ ꠛꠣꠠꠣꠁ ꠖꠤꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠁꠎ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠍ, ꠉꠘꠤꠀ ꠚꠥꠠꠣꠁꠟ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_11","006_1_11","DEU","1","11","11","ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞꠅ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠉꠥꠘ ꠛꠣꠠꠣꠃꠇ꠆ꠇꠣ, ꠀꠞ ꠔꠣꠘ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠦꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_12","006_1_12","DEU","1","12","12","ꠅꠁꠟꠦ ꠀꠝꠤ ꠄꠇꠟꠣ ꠇꠦꠝꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠝꠤꠐꠣꠁꠔꠣꠝ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠤꠞ ꠜꠣꠞ ꠛꠁꠔꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("DT1_13","006_1_13","DEU","1","13","13","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠇꠄꠎꠘ ꠀꠈꠟꠖꠣꠞ, ꠎꠣꠘꠞꠣ-ꠢꠥꠘꠞꠣ ꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠁꠎ꠆ꠎꠔꠤ ꠎꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠤ ꠄꠞꠣꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT1_14","006_1_14","DEU","1","14","14","“ꠔꠥꠝꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠍꠟꠣꠄ, ꠀꠁꠌ꠆ꠍꠣ, ꠀꠙꠘꠦ ꠎꠦꠟꠣ ꠇꠁꠞꠣ, ꠅꠟꠣꠃ ꠜꠣꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT1_15","006_1_15","DEU","1","15","15","ꠔꠦꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠀꠈꠟꠖꠣꠞ, ꠛꠥꠖ꠆ꠖꠤꠝꠣꠘ ꠀꠞ ꠎꠣꠘꠞꠣ-ꠢꠥꠘꠞꠣ ꠎꠘꠞꠦ ꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠀꠎꠣꠞ ꠎꠘꠞ ꠃꠙꠞꠦ, ꠡ ꠎꠘꠞ ꠃꠙꠞꠦ, ꠙꠁꠘ꠆ꠌꠣꠡ ꠎꠘꠞ ꠃꠙꠞꠦ, ꠖꠡ ꠎꠘꠞ ꠃꠙꠞꠦ ꠡꠞ꠆ꠖꠣꠞ ꠛꠣꠘꠣꠁ ꠖꠤꠍꠟꠣꠝ, ꠀꠞ ꠅꠚꠤꠡꠣꠞ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT1_16","006_1_16","DEU","1","16","16","“ꠢꠃ ꠡꠝꠄ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠢꠣꠇꠤꠝ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣꠝ, ꠇꠁꠍꠟꠣꠝ, ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖꠞ ꠛꠤꠌꠣꠞꠅ ꠛꠣꠖꠤ-ꠛꠤꠛꠣꠖꠤ ꠖꠥꠁꠅ ꠙꠇ꠆ꠇꠞ ꠝꠣꠔ ꠢꠥꠘꠤꠀ ꠢꠇ ꠁꠘꠍꠣꠚ ꠇꠞꠤꠅ, ꠁꠔꠣ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠅꠃꠇ ꠛꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("DT1_17","006_1_17","DEU","1","17","17","ꠛꠤꠌꠣꠞꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠙꠇ꠆ꠇ ꠟꠁꠅ ꠘꠣ, ꠗꠘꠤ-ꠉꠞꠤꠛ ꠢꠇꠟꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠅ। ꠀꠍꠟꠦ ꠛꠤꠌꠣꠞꠞ ꠝꠣꠟꠤꠇ ꠔ ꠀꠟ꠆ꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠎꠦ ꠛꠤꠌꠣꠞꠞ ꠝꠤꠝꠣꠋꠡꠣ ꠇꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠑꠤꠘ ꠅꠄ, ꠁꠈꠣꠘ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠤꠅ, ꠀꠝꠤ ꠖꠦꠈꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT1_18","006_1_18","DEU","1","18","18","ꠀꠞ ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠄ, ꠁꠔꠣ ꠔ ꠀꠝꠤ ꠢꠃ ꠡꠝꠄ ꠇꠁꠀ ꠖꠤꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT1_19","006_1_19","DEU","1","19","19","“ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ, ꠔꠥꠞ ꠙꠣꠠ ꠍꠣꠠꠤꠀ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣ ꠝꠥꠈꠣ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣꠝ। ꠔꠥꠝꠞꠣ ꠔ ꠖꠦꠈꠍ, ꠇꠔ ꠛꠠ ꠀꠞ ꠇꠔ ꠝꠣꠞꠣꠔ꠆ꠔꠇ ꠝꠞꠥꠜꠥꠝꠤ ꠙꠣꠞ ꠅꠁꠀ ꠀꠝꠞꠣ ꠇꠣꠖꠦꠡ-ꠛꠞꠘꠦꠀ ꠀꠁꠀ ꠀꠎꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT1_20","006_1_20","DEU","1","20","20","ꠀꠎꠤꠀ ꠢꠣꠞꠤ ꠀꠝꠤ ꠇꠁꠍꠟꠣꠝ, ꠅꠈꠘ ꠔ ꠔꠥꠝꠞꠣ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠢꠃ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠔ ꠀꠁꠀ ꠙꠃꠍꠤ ꠉꠦꠍ, ꠁ ꠖꠦꠡꠈꠣꠘ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠟꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_21","006_1_21","DEU","1","21","21","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠣꠘ ꠇꠞꠣ ꠅꠃ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠃ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠙꠠꠤ ꠞꠁꠍꠦ। ꠅꠈꠘ ꠎꠣꠅ, ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠅꠃ ꠖꠦꠡꠞꠦ ꠖꠈꠟ ꠇꠞꠅ। ꠇꠦꠃ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠘꠤꠞꠣꠡ ꠅꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_22","006_1_22","DEU","1","22","22","“ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠀꠁꠀ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣꠄ, ꠔꠦ ꠙꠄꠟꠣ ꠇꠄꠎꠘ ꠉꠥꠁꠀꠞꠦ ꠅꠃ ꠖꠦꠡꠅ ꠙꠣꠑꠣꠁꠟ ꠅꠃꠇ, ꠔꠣꠞꠣ ꠉꠤꠀ ꠖꠦꠡꠈꠣꠘ ꠖꠦꠈꠤꠀ ꠀꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠇꠁꠛꠣ, ꠇꠥꠘ ꠙꠕꠦ ꠎꠣꠅꠀ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ ꠀꠞ ꠎꠣꠅꠀꠞ ꠙꠕꠅ ꠇꠥꠘ ꠇꠥꠘ ꠐꠣꠃꠘ ꠙꠠꠛ। ");
INSERT INTO syls_vpl VALUES ("DT1_23","006_1_23","DEU","1","23","23","“ꠔꠥꠝꠞꠣꠞ ꠙꠞꠣꠝꠤꠡ ꠀꠝꠣꠞ ꠙꠍꠘ꠆ꠖ ꠅꠁꠟ, ꠄꠞꠟꠣꠉꠤ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠄꠇꠎꠘ ꠇꠞꠤ ꠝꠥꠐ ꠛꠣꠞꠅ ꠎꠘꠞꠦ ꠀꠟꠉ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT1_24","006_1_24","DEU","1","24","24","ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠘꠅ ꠕꠁꠀ ꠅꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠟ, ꠀꠞ ꠀꠡꠇꠥꠟ ꠘꠣꠝꠞ ꠙꠣꠠꠤꠀ ꠈꠣꠟꠅ ꠉꠤꠀ ꠜꠣꠟꠣ ꠇꠞꠤ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("DT1_25","006_1_25","DEU","1","25","25","ꠔꠣꠞꠣ ꠢꠃ ꠖꠦꠡ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠚꠟ-ꠝꠥꠟ ꠀꠘꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠀ ꠇꠁꠟ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠁꠈꠣꠘ ꠔ ꠛꠠ ꠜꠣꠟꠣ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_26","006_1_26","DEU","1","26","26","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠅꠃ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠟꠣꠄ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT1_27","006_1_27","DEU","1","27","27","ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠔꠣꠝ꠆ꠛꠥꠔ ꠢꠣꠝꠣꠁꠀ ꠛꠇꠣ-ꠎꠇꠣ ꠡꠥꠞꠥ ꠇꠞꠟꠣꠄ, ꠀꠞ ꠇꠁꠟꠣꠄ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠖꠥꠡꠝꠘꠤ ꠇꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠀꠔꠅ ꠚꠣꠟꠣꠁꠀ ꠝꠣꠞꠣꠞ ꠈꠤꠀꠟꠦ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT1_28","006_1_28","DEU","1","28","28","ꠀꠝꠞꠣ ꠇꠤꠟꠣ ꠢꠤꠘꠅ ꠎꠣꠁꠝꠥ? ꠀꠝꠞꠣꠞ ꠉꠥꠁꠀ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠀꠁꠀ ꠎꠣꠘꠅ ꠒꠞ ꠢꠣꠞꠣꠁ ꠖꠤꠍꠂꠘ। ꠔꠣꠞꠣ ꠇꠁꠍꠂꠘ, ꠢꠤꠘꠞ ꠝꠣꠘꠥꠡ ꠛꠥꠟꠦ ꠀꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠃꠌꠣ-ꠝꠥꠐꠣ ꠙꠄꠟꠥꠀꠘ। ꠔꠣꠞꠣꠞ ꠐꠣꠃꠘ ꠅꠇꠟꠅ ꠛꠠ ꠛꠠ, ꠁꠔꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠃꠌꠣ ꠃꠌꠣ ꠅꠀꠟ ꠖꠤꠀ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠇꠞꠣ, ꠀꠍꠝꠣꠘꠅ ꠍꠁꠟꠣꠞ ꠟꠣꠉꠦꠞ। ꠀꠞ ꠙꠄꠟꠥꠀꠘ ꠀꠘꠣꠇꠤ ꠅꠇꠟꠞꠦꠅ ꠛꠥꠟꠦ ꠢꠘꠅ ꠖꠦꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT1_29","006_1_29","DEU","1","29","29","“ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠝꠘ ꠊꠣꠛꠠꠣꠁꠅ ꠘꠣ, ꠁꠔꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_30","006_1_30","DEU","1","30","30","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠎꠣꠁꠞꠣ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠎꠦꠟꠣ ꠎꠥꠖ꠆ꠖ ꠇꠞꠍꠟꠣ, ꠅꠈꠘꠅ ꠅꠃꠟꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_31","006_1_31","DEU","1","31","31","ꠀꠞ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦꠅ ꠔ ꠔꠥꠝꠞꠣ ꠖꠦꠈꠍ, ꠅꠘꠅ ꠀꠁꠀ ꠙꠃꠍꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠛꠣꠚꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠀꠙꠘ ꠙꠥꠔꠞꠦ ꠇꠥꠟꠅ ꠇꠞꠤ ꠛꠁꠀ ꠘꠦꠁꠘ, ꠅꠃꠟꠣꠈꠣꠘ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠀꠡ꠆ꠔꠣ ꠙꠕ ꠛꠁꠀ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT1_32","006_1_32","DEU","1","32","32","ꠅꠔꠔꠣ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠟꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_33","006_1_33","DEU","1","33","33","ꠔꠣꠁꠘꠦꠃ ꠔ ꠔꠣꠝ꠆ꠛꠥ ꠉꠣꠠꠤꠛꠣꠞ ꠎꠣꠉꠣ ꠌꠤꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠞ ꠙꠕ ꠌꠤꠘꠣꠁꠀ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠞꠣꠁꠔꠇꠥꠞ ꠡꠝꠄ ꠀꠉꠥꠘꠤꠞ ꠈꠥꠐꠤ ꠀꠞ ꠖꠤꠘꠇꠥꠞ ꠡꠝꠄ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠞ ꠘꠝꠥꠘꠣ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT1_34","006_1_34","DEU","1","34","34","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠁꠔꠣ ꠎꠥꠀꠙ ꠢꠥꠘꠤꠀ ꠝꠣꠛꠥꠖꠦ ꠈꠥꠛ ꠉꠥꠍꠣ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT1_35","006_1_35","DEU","1","35","35","ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠈꠣꠁꠍꠟꠣꠝ ꠅꠃ ꠖꠦꠡꠈꠣꠘ ꠖꠤꠔꠣꠝ ꠇꠞꠤ, ꠔꠣ-ꠅ ꠅꠈꠘꠇꠥꠞ ꠁꠔꠣ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠦ ꠁ ꠜꠣꠟꠣ ꠎꠣꠉꠣ ꠈꠣꠘ ꠖꠦꠈꠣꠞ ꠘꠍꠤꠛ ꠅꠁꠔ ꠘꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT1_36","006_1_36","DEU","1","36","36","ꠈꠣꠟꠤ ꠎꠤꠚꠥꠘ꠆ꠘꠤꠞ ꠙꠥꠀ ꠇꠣꠟꠥꠔ ꠍꠣꠠꠣ। ꠁꠈꠣꠘ ꠖꠦꠈꠣꠞ ꠡꠃꠜꠣꠁꠉ꠆ꠉ ꠅꠃ ꠇꠣꠟꠥꠔꠦ ꠙꠣꠁꠛ, ꠢꠦ ꠀꠝꠣꠞ ꠇꠕꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠣꠘꠍꠦ, ꠢꠦ ꠎꠦꠔꠣ ꠎꠣꠉꠣ ꠙꠣꠅꠖꠤ ꠙꠣꠠꠣꠁꠀ ꠀꠁꠍꠦ, ꠁꠔꠣ ꠎꠣꠉꠣ ꠀꠝꠤ ꠔꠣꠞꠦ ꠀꠞ ꠔꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT1_37","006_1_37","DEU","1","37","37","“ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠇꠣꠞꠘꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦꠅ ꠉꠥꠍꠣ ꠇꠞꠟꠣ, ꠉꠥꠍꠣ ꠇꠞꠤ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠔꠥꠝꠤ ꠝꠥꠍꠣꠅ ꠢꠃ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT1_38","006_1_38","DEU","1","38","38","ꠈꠣꠟꠤ ꠔꠥꠝꠣꠞ ꠈꠣꠖꠤꠝ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ ꠉꠤꠀ ꠢꠘꠅ ꠢꠣꠝꠣꠁꠛ। ꠔꠥꠝꠤ ꠔꠣꠞꠦ ꠡꠣꠅꠡ ꠖꠤꠅ, ꠢꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠁ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠀ ꠝꠣꠟꠤꠇ ꠛꠣꠘꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT1_39","006_1_39","DEU","1","39","39","ꠔꠥꠝꠞꠣ ꠇꠁꠍꠟꠣꠄ, ꠀꠝꠞꠣꠞ ꠛꠦꠛꠥꠎ ꠘꠣꠛꠣꠟꠤꠇ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠢꠃ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠦ ꠗꠞꠤꠀ ꠘꠤꠛꠉꠤ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠄꠞꠣꠞꠦꠃ ꠅꠃ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇ ꠛꠣꠘꠣꠁꠝꠥ, ꠄꠞꠣ ꠁꠈꠣꠘ ꠖꠈꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_40","006_1_40","DEU","1","40","40","ꠔꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠙꠤꠍꠣꠁꠀ ꠉꠤꠀ ꠘꠤꠟ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠦꠖꠤ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("DT1_41","006_1_41","DEU","1","41","41","“ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠇꠁꠍꠟꠣꠄ, ꠀꠝꠞꠣ ꠔ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠁꠉꠦꠍꠤ। ꠔꠣ-ꠅ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠅꠈꠘ ꠉꠤꠀ ꠎꠥꠖ꠆ꠖ ꠇꠞꠝꠥ। ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠥꠝꠞꠣ ꠅꠡꠔ꠆ꠞ-ꠡꠡꠔ꠆ꠞ ꠟꠁꠟꠣꠄ, ꠀꠞ ꠝꠘꠅ ꠇꠞꠍꠟꠣꠄ, ꠙꠣꠠꠤ ꠄꠟꠣꠇꠣꠔ ꠃꠑꠤꠀ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠅ ꠈꠥꠛ ꠡꠥꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_42","006_1_42","DEU","1","42","42","“ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠎꠥꠖ꠆ꠖꠞ ꠟꠣꠉꠤ ꠙꠣꠠꠅ ꠘꠣ ꠃꠑꠦ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠔꠣꠝ ꠘꠣꠄ, ꠀꠞ ꠀꠝꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠁꠌ꠆ꠍꠣꠄ ꠎꠣꠅ, ꠔꠦ ꠖꠥꠡꠝꠘꠞ ꠉꠦꠍꠦ ꠀꠞꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT1_43","006_1_43","DEU","1","43","43","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞꠤ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠝꠣꠘꠟꠣꠄ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠉꠤꠀ ꠛꠥꠇ ꠚꠥꠟꠣꠁꠀ ꠅꠃ ꠙꠣꠠꠅ ꠃꠑꠣꠔ ꠟꠣꠉꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT1_44","006_1_44","DEU","1","44","44","ꠔꠦꠃ ꠙꠣꠠꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠀꠝꠥꠞꠤ ꠎꠣꠔꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠙꠣꠟ ꠛꠣꠘ꠆ꠖꠤ ꠛꠣꠞ ꠅꠁꠟ, ꠝꠃꠌꠣꠇꠞ ꠝꠃ-ꠙꠥꠇꠞ ꠟꠣꠈꠣꠘ ꠙꠣꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠟ, ꠀꠞ ꠝꠣꠞꠔꠦ ꠝꠣꠞꠔꠦ ꠍꠦꠁꠞꠞ ꠢꠞ꠆ꠝꠣ ꠐꠣꠃꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠈꠦꠖꠣꠁꠀ ꠘꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT1_45","006_1_45","DEU","1","45","45","ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠀꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠇꠣꠘ꠆ꠖꠘ ꠟꠣꠉꠣꠁꠟꠣꠄ, ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠇꠣꠘ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟ꠆ꠟꠣ, ꠁ ꠇꠣꠘ꠆ꠖꠘ ꠢꠥꠘꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT1_46","006_1_46","DEU","1","46","46","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣ ꠛꠃꠔ ꠖꠤꠘ ꠇꠣꠖꠦꠡ ꠄꠟꠣꠇꠣꠔ ꠞꠁꠟꠣꠄ, ꠟꠣꠝ꠆ꠛꠣ ꠡꠝꠄ ꠅꠘꠅ ꠉꠥꠎꠞꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("DT2_1","006_2_1","DEU","2","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠅꠃꠟꠣ ꠀꠝꠞꠣ ꠙꠤꠍꠣꠁꠀ ꠉꠤꠀ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦꠖꠤ ꠘꠤꠟ ꠖꠞꠤꠀꠞ ꠝꠥꠈꠣ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠝ। ꠍꠦꠁꠞꠞ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣ ꠌꠇ꠆ꠇꠞ ꠖꠤꠀ ꠎꠣꠁꠔꠦ ꠀꠝꠞꠣꠞ ꠛꠃꠔ ꠖꠤꠘ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("DT2_2","006_2_2","DEU","2","2","2","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT2_3","006_2_3","DEU","2","3","3","ꠔꠥꠝꠞꠣ ꠛꠣꠇ꠆ꠇꠣ ꠖꠤꠘ ꠕꠣꠇꠤ ꠅꠃ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠔ ꠌꠇ꠆ꠇꠞ ꠖꠤꠞꠣꠄ, ꠅꠈꠘ ꠃꠔ꠆ꠔꠞ ꠝꠥꠈꠣ ꠞꠅꠀꠘꠣ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("DT2_4","006_2_4","DEU","2","4","4","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠔꠣꠝ ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠡꠦꠈ ꠁꠡʼꠞ ꠀꠅꠟꠣꠖꠞ ꠖꠈꠟꠦ ꠕꠣꠇꠣ ꠍꠦꠁꠞ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠎꠣꠁꠔꠦ ꠅꠁꠛ। ꠉꠦꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠒꠞꠣꠁꠛꠣ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠄꠞꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("DT2_5","006_2_5","DEU","2","5","5","ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠇꠞꠤꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠣꠞꠣꠞ ꠖꠦꠡꠞ ꠄꠇ ꠁꠘ꠆ꠌꠤ ꠎꠝꠤꠅ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠀꠡ꠆ꠔꠣ ꠍꠦꠁꠞ ꠙꠣꠠꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠀꠝꠤ ꠡꠦꠈ ꠁꠡʼꠞꠦ ꠖꠤꠟꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT2_6","006_2_6","DEU","2","6","6","ꠔꠣꠞꠣꠞ ꠅꠃ ꠖꠦꠡ ꠙꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠛꠣꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠟꠣꠉꠟꠦ ꠐꠦꠇꠣꠖꠤ ꠟꠁꠀ ꠈꠣꠁꠛꠣꠄ, ꠅꠃꠟꠣ ꠙꠣꠘꠤꠅ ꠟꠁꠀ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT2_7","006_2_7","DEU","2","7","7","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠢꠇꠟ ꠇꠣꠝꠞ ꠝꠣꠎꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠍꠂꠘ। ꠅꠃ ꠅꠔ ꠛꠠ ꠝꠞꠥꠜꠥꠝꠤ ꠙꠣꠞꠘꠤꠞ ꠛꠣꠟꠣ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠍꠂꠘ। ꠅꠃ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠗꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠅꠜꠣꠛ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_8","006_2_8","DEU","2","8","8","“ꠔꠦꠃ ꠀꠝꠞꠣ ꠚꠣꠔꠣꠞꠤ ꠙꠕꠦ ꠀꠐꠤꠟꠣꠝ, ꠀꠐꠤꠀ ꠀꠝꠞꠣꠞ ꠜꠣꠁ ꠍꠦꠁꠞꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠁꠡʼꠞ ꠀꠅꠟꠣꠖꠞ ꠖꠦꠡ ꠚꠣꠟꠣꠁꠀ ꠉꠦꠟꠣꠝ। ꠀꠝꠞꠣ ꠀꠞꠣꠛꠣ ꠔꠟꠜꠥꠝꠤꠞ ꠎꠦ ꠞꠣꠡ꠆ꠔꠣ ꠄꠟꠣꠔ ꠀꠞ ꠁꠎꠤꠅꠘ-ꠉꠦꠛꠦꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠦ, ꠅꠃ ꠙꠕꠦꠖꠤ ꠘꠣ ꠉꠤꠀ ꠝꠥꠀꠛꠞ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠥꠈꠣ ꠀꠐꠣ ꠗꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT2_9","006_2_9","DEU","2","9","9","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠔꠥꠝꠞꠣ ꠝꠥꠀꠛꠤ ꠅꠇꠟꠞꠦ ꠍꠣꠔꠣꠁꠅ ꠘꠣ, ꠇꠥꠘꠥ ꠎꠥꠖ꠆ꠖꠞ ꠜꠣꠛ-ꠡꠣꠛ ꠖꠦꠈꠣꠁꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠣꠞꠣꠞ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠎꠝꠤꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ꠔꠣꠞꠣꠞ ꠞꠣꠎꠗꠣꠘꠤ ꠀꠃꠞ ꠐꠣꠃꠘꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠀꠝꠤ ꠟꠥꠔ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖ ꠝꠥꠀꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠤꠟꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("DT2_10","006_2_10","DEU","2","10","10","(ꠀꠉꠦ ꠄꠁꠝꠤ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ ꠅꠃ ꠄꠟꠣꠇꠣꠔ ꠞꠁꠔꠣ, ꠁꠔꠣ ꠀꠍꠟꠣ ꠙꠄꠟꠥꠀꠘ ꠎꠣꠔꠤ, ꠔꠣꠞꠣ ꠙꠞꠤꠝꠣꠘꠦ ꠀꠍꠟꠣ ꠛꠃꠔ ꠎꠘ, ꠀꠞ ꠖꠦꠈꠔꠦ ꠀꠘꠣꠇꠤ ꠎꠣꠔꠤꠞ ꠟꠣꠈꠣꠘ ꠃꠌꠣ-ꠝꠥꠐꠣ ꠟꠣꠝ꠆ꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_11","006_2_11","DEU","2","11","11","ꠀꠘꠣꠇꠤ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠄꠁꠝꠤ ꠅꠇꠟꠞꠦꠅ ꠞꠚꠣꠄꠁ ꠘꠣꠝꠦ ꠒꠣꠇꠣ ꠅꠁꠔ, ꠅꠁꠟꠦ ꠝꠥꠀꠛꠤ ꠅꠇꠟꠦ ꠁꠔꠣꠞꠦ ꠄꠁꠝꠤ ꠇꠁꠀ ꠒꠣꠇꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_12","006_2_12","DEU","2","12","12","ꠍꠦꠁꠞ ꠙꠣꠠꠅ ꠢꠥꠞꠤꠅ ꠅꠇꠟꠦ ꠛꠡꠔ ꠇꠞꠔꠣ, ꠛꠣꠖꠦ ꠁꠡʼꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠀ ꠁꠈꠣꠘ ꠖꠈꠟ ꠇꠞꠟꠣ। ꠝꠣꠛꠥꠖꠞ ꠀꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠦꠟꠣ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠙꠣꠁꠀ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁꠛꠣ, ꠑꠤꠇ ꠅꠟꠣ ꠁꠡʼꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦꠅ ꠇꠞꠍꠟꠣ। ꠔꠣꠞꠣ ꠢꠥꠞꠤꠅ ꠅꠇꠟꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠀ ꠢꠇꠟ ꠎꠝꠤ-ꠝꠣꠐꠤ ꠖꠈꠟ ꠇꠞꠤꠀ ꠘꠤꠎꠦ ꠢꠘꠅ ꠛꠡꠔ ꠇꠞꠟꠣ।) ");
INSERT INTO syls_vpl VALUES ("DT2_13","006_2_13","DEU","2","13","13","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠔꠥꠝꠞꠣ ꠎꠟꠖꠤ ꠇꠞꠤ ꠞꠅꠀꠘꠣ ꠅꠅ, ꠀꠞ ꠎꠦꠞꠦꠖ ꠙꠣꠠꠤꠀ ꠈꠣꠟ ꠙꠣꠞ ꠅꠁꠀ ꠢꠙꠣꠞꠅ ꠎꠣꠅ। ꠔꠦꠃ ꠀꠝꠞꠣ ꠙꠣꠞ ꠅꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT2_14","006_2_14","DEU","2","14","14","ꠀꠞ ꠇꠣꠖꠦꠡ-ꠛꠞꠘꠦꠀ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠤ ꠎꠦꠞꠦꠖ ꠉꠥꠟ꠆ꠟꠣ ꠙꠣꠞ ꠅꠁꠀ ꠀꠁꠔꠦ ꠀꠝꠞꠣꠞ ꠀꠐꠔꠤꠡ ꠛꠍꠞ ꠟꠣꠉꠍꠤꠟ। ꠄꠞꠝꠣꠎꠦ ꠅꠃꠟꠣ ꠅꠁꠟ, ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣ, ꠅꠃꠟꠣ ꠇꠣꠖꠦꠡ-ꠛꠞꠘꠦꠀ ꠕꠣꠇꠤ ꠛꠣꠞꠘꠤꠞ ꠇꠣꠟꠅ ꠀꠝꠞꠣꠞ ꠎꠔ ꠍꠤꠙꠣꠁ ꠀꠍꠟꠣ, ꠄꠞꠣ ꠢꠇꠟꠃ ꠅꠃ ꠀꠐꠔꠤꠡ ꠛꠍꠞꠦ ꠝꠞꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_15","006_2_15","DEU","2","15","15","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠝꠣꠛꠥꠖ ꠔꠣꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_16","006_2_16","DEU","2","16","16","“ꠅꠃ ꠢꠇꠟ ꠍꠤꠙꠣꠁ ꠝꠞꠤꠀ ꠡꠦꠡ ꠅꠁꠀ ꠢꠣꠞꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("DT2_17","006_2_17","DEU","2","17","17","ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT2_18","006_2_18","DEU","2","18","18","ꠀꠁꠎ ꠔꠥꠝꠞꠣ ꠝꠥꠀꠛꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣ ꠙꠣꠞ ꠅꠁꠛꠣꠄ, ꠔꠣꠞꠣꠞ ꠞꠣꠎꠗꠣꠘꠤ ꠀꠃꠞ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠛꠣꠄ ꠎꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT2_19","006_2_19","DEU","2","19","19","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘ ꠖꠦꠡꠞ ꠇꠣꠍꠣꠔ ꠎꠣꠁꠛꠣꠄꠉꠤ, ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠍꠣꠔꠣꠁꠅ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠎꠥꠖ꠆ꠖꠞ ꠜꠣꠛ-ꠡꠣꠛ ꠖꠦꠈꠣꠁꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠣꠞꠣꠞ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠔꠣꠝ ꠘꠣꠄ, ꠁꠈꠣꠘꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠔ ꠀꠝꠤ ꠟꠥꠔ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘꠞꠦ ꠖꠤꠟꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("DT2_20","006_2_20","DEU","2","20","20","(ꠀꠉꠦ ꠞꠚꠣꠄꠁ ꠅꠇꠟ ꠅꠘꠅ ꠞꠁꠔꠣ, ꠄꠞꠟꠣꠉꠤ ꠁꠈꠣꠘꠞꠦ ꠞꠚꠣꠄꠁ ꠅꠇꠟꠞ ꠖꠦꠡ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠁꠔ। ꠀꠞ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘꠦ ꠁꠔꠣꠞꠦ ꠎꠣꠝ-ꠎꠣꠝꠤꠝꠤ ꠇꠁꠀ ꠒꠣꠇꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_21","006_2_21","DEU","2","21","21","ꠞꠚꠣꠄꠁ ꠎꠣꠔꠤ ꠙꠄꠟꠥꠀꠘ ꠀꠍꠟꠣ, ꠖꠦꠈꠔꠦ ꠀꠘꠣꠇꠤ ꠎꠣꠔꠤꠞ ꠟꠣꠈꠣꠘ ꠃꠌꠣ-ꠝꠥꠐꠣ ꠟꠣꠝ꠆ꠛꠣ ꠀꠞ ꠙꠞꠤꠝꠣꠘꠦꠅ ꠛꠃꠔ ꠛꠦꠡꠤ ꠀꠍꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘ ꠎꠣꠔꠤꠞ ꠀꠔꠅ ꠁꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠁꠟꠣ, ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘꠦ ꠞꠚꠣꠄꠁ ꠎꠣꠔꠤꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠀ ꠅꠃ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_22","006_2_22","DEU","2","22","22","ꠝꠣꠛꠥꠖꠦ ꠁꠡʼꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦꠖꠤ ꠅꠃ ꠄꠇꠁ ꠇꠣꠝ ꠇꠞꠣꠁꠟꠣ, ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠀꠔꠅ ꠢꠥꠞꠤꠅ ꠎꠣꠔꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠟꠣ। ꠄꠞꠣ ꠢꠥꠞꠤꠅ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠀ, ꠔꠣꠞꠣꠞ ꠍꠦꠁꠞ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠤꠀ ꠛꠡꠔ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_23","006_2_23","DEU","2","23","23","ꠄꠞꠝꠣꠎꠦ ꠇꠙ꠆ꠔꠥꠞ ꠖꠤꠙ ꠕꠣꠇꠤ ꠇꠙ꠆ꠔꠥꠞꠤ ꠎꠣꠔꠤꠄ ꠀꠁꠀ ꠅꠛ꠆ꠛꠤ ꠎꠣꠔꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠟꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠐꠤꠞꠦ ꠖꠈꠟ ꠇꠞꠤꠀ ꠛꠡꠔ ꠇꠞꠟꠣ। ꠅꠃ ꠅꠛ꠆ꠛꠤ ꠅꠇꠟ ꠉꠣꠎꠣ ꠐꠣꠃꠘꠞ ꠗꠣꠞꠅ ꠛꠡꠔ ꠇꠞꠔꠣ, ꠢꠘꠞ ꠢꠇꠟ ꠉꠣꠃ-ꠉꠦꠞꠣꠝꠅ ꠔꠣꠞꠣ ꠞꠁꠔꠣ।) ");
INSERT INTO syls_vpl VALUES ("DT2_24","006_2_24","DEU","2","24","24","“ꠄꠞꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠍꠟꠣ, ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠥꠝꠞꠣ ꠛꠣꠞ ꠅꠅ, ꠛꠣꠞ ꠅꠁꠀ ꠅꠞꠘꠘ ꠈꠣꠟꠞ ꠢꠙꠣꠞꠅ ꠎꠣꠅ। ꠢꠥꠘꠅ, ꠀꠝꠥꠞꠤ ꠎꠣꠔꠤꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘ ꠀꠞ ꠔꠣꠞ ꠢꠤꠡꠛꠘ ꠖꠦꠡꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠍꠤ। ꠁꠈꠣꠘ ꠖꠈꠟ ꠇꠞꠣꠔ ꠉꠤꠀ ꠛꠣꠖꠡꠣꠞꠦ ꠎꠥꠖ꠆ꠖꠞ ꠚꠤꠟꠒꠅ ꠟꠣꠝꠣꠅ, ");
INSERT INTO syls_vpl VALUES ("DT2_25","006_2_25","DEU","2","25","25","ꠔꠦꠃ ꠖꠦꠈꠛꠣꠄ, ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠀꠁꠎ ꠕꠣꠇꠤ ꠎꠉꠔꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠖꠤꠟꠅ ꠒꠞ ꠢꠣꠞꠣꠁ ꠖꠤꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠒꠞꠦ ꠔꠣꠞꠣ ꠇꠣꠙꠤꠛꠣ। ꠔꠥꠝꠞꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠦꠃ ꠔꠣꠞꠣꠞ ꠎꠣꠘꠅ ꠗꠠꠚꠠ ꠡꠥꠞꠥ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("DT2_26","006_2_26","DEU","2","26","26","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠛꠣꠖꠦ ꠀꠝꠤ ꠡꠣꠘ꠆ꠔꠤ-ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠈꠣꠖꠤꠝꠥꠔ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠢꠤꠡꠛꠘꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞ ꠉꠦꠍꠦ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠟꠣꠝ, ꠇꠁꠟꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("DT2_27","006_2_27","DEU","2","27","27","ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠙꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠔꠣꠝ ꠌꠣꠁ, ꠅꠘꠥꠝꠔꠤ ꠖꠤꠛꠣ ꠘꠤ? ꠀꠝꠞꠣ ꠀꠔꠣꠞꠦ-ꠚꠣꠔꠣꠞꠦ ꠇꠥꠘꠥꠛꠣꠄ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠝꠥꠟ ꠡꠠꠇꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT2_28","006_2_28","DEU","2","28","29","ꠀꠝꠞꠣ ꠘꠉꠖ ꠐꠦꠇꠣꠖꠤ ꠀꠙꠘꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠛꠣ ꠙꠣꠘꠤꠅ ꠈꠞꠤꠖ ꠇꠞꠤꠀ ꠈꠣꠁꠝꠥ। ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠖꠤꠔꠣ ꠌꠣꠁꠞꠣ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠁꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠙꠘꠣꠞ ꠖꠦꠡꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠝꠞꠣꠞꠦ ꠀꠐꠤꠀ ꠎꠣꠁꠔꠦ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠍꠦꠁꠞꠞ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠁꠡʼꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ, ꠀꠞ ꠀꠃꠞ ꠐꠣꠃꠘꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠝꠥꠀꠛꠤ ꠅꠇꠟꠦꠅ ꠀꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠙꠣꠞ ꠅꠁꠔꠦ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT2_30","006_2_30","DEU","2","30","30","“ꠅꠁꠟꠦ ꠢꠤꠡꠛꠘꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘ ꠞꠣꠎꠤ ꠅꠁꠟ ꠘꠣ, ꠀꠝꠞꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠖꠤꠟ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠣꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠟ꠆ꠟꠣ, ꠔꠣꠞ ꠝꠘꠞ ꠜꠣꠛ ꠟꠥꠀꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠉꠦꠟ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠔꠣꠞ ꠛꠤꠘꠣꠡ ꠅꠄ, ꠀꠞ ꠑꠤꠇꠃ ꠅꠟꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("DT2_31","006_2_31","DEU","2","31","31","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠅ ꠝꠥꠍꠣ, ꠍꠤꠢꠥꠘ ꠀꠞ ꠔꠣꠞ ꠛꠣꠖꠡꠣꠁꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠟꠣꠝ। ꠅꠈꠘ ꠔꠥꠝꠤ ꠢꠘꠅ ꠎꠣꠅ, ꠉꠤꠀ ꠅꠃ ꠖꠦꠡ ꠖꠈꠟꠦ ꠀꠘꠣꠔ ꠟꠣꠉꠅ, ꠀꠞ ꠢꠘꠅ ꠛꠡꠔ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("DT2_32","006_2_32","DEU","2","32","32","“ꠔꠦꠃ ꠁꠀꠢꠣꠎ ꠄꠟꠣꠇꠣꠔ ꠍꠤꠢꠥꠘꠦ ꠔꠣꠞ ꠢꠇꠟ ꠍꠤꠙꠣꠁ ꠖꠟ ꠟꠁꠀ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠔ ꠀꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("DT2_33","006_2_33","DEU","2","33","33","ꠅꠃ ꠡꠝꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠀꠔꠅ ꠚꠣꠟꠣꠁꠟꠣ। ꠀꠝꠞꠣ ꠛꠣꠖꠡꠣꠞꠦ, ꠔꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ, ꠔꠣꠞ ꠍꠤꠙꠣꠁ ꠖꠟꠞꠦ ꠘꠤꠙꠣꠔ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT2_34","006_2_34","DEU","2","34","34","ꠀꠞ ꠀꠝꠞꠣ ꠔꠣꠞ ꠢꠇꠟ ꠐꠣꠃꠘ, ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠢꠇꠟꠔꠣ ꠖꠈꠟ ꠇꠞꠟꠣꠝ, ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠟꠣꠝ। ꠄꠇꠎꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_35","006_2_35","DEU","2","35","35","ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟ ꠀꠞ ꠉꠘꠤꠝꠔꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠘꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT2_36","006_2_36","DEU","2","36","36","ꠅꠞꠘꠘ ꠈꠣꠟꠞ ꠡꠤꠝꠣꠘꠣꠞ ꠀꠞꠥꠀꠞ ꠐꠣꠃꠘ, ꠀꠞ ꠅꠃ ꠄꠟꠣꠇꠣꠞ ꠄꠇ ꠉꠣꠃ ꠕꠣꠇꠤ ꠀꠞꠇ ꠉꠣꠃ ꠖꠈꠟ ꠇꠞꠤ ꠇꠞꠤ, ꠉꠤꠟꠤꠅꠖ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠘꠥ ꠎꠣꠉꠣ ꠀꠝꠞꠣꠞ ꠖꠈꠟꠞ ꠛꠣꠁꠞꠦ ꠞꠁꠟ ꠘꠣ। ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠀꠝꠞꠣꠞ ꠀꠔꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT2_37","006_2_37","DEU","2","37","37","ꠈꠣꠟꠤ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘ ꠎꠣꠔꠤꠞ ꠖꠦꠡ, ꠎꠣꠛ꠆ꠛꠥꠇ ꠙꠣꠠꠤꠀ ꠈꠣꠟꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠢꠇꠟ ꠎꠤꠟꠣ, ꠙꠣꠠꠞ ꠃꠙꠞꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠎꠣꠉꠣ ꠖꠈꠟ ꠇꠞꠔꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠎꠣꠉꠣ ꠈꠣꠘꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠖꠈꠟꠞ ꠛꠣꠁꠞꠦ ꠞꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("DT3_1","006_3_1","DEU","3","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠢꠤꠡꠛꠘ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠝꠞꠣ ꠛꠣꠡꠘ ꠖꠦꠡꠅ ꠎꠣꠅꠀꠞ ꠙꠕꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣꠝ। ꠛꠣꠡꠘꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠦ ꠈꠛꠞ ꠙꠣꠁꠀ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠢꠇꠟ ꠍꠤꠙꠣꠁ ꠖꠟ ꠟꠁꠀ ꠁꠖꠞꠤ ꠐꠣꠃꠘꠅ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("DT3_2","006_3_2","DEU","3","2","2","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠅ ꠝꠥꠍꠣ, ꠁ ꠛꠣꠖꠡꠣꠞꠦ ꠔꠥꠝꠤ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠣꠞꠦ, ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞꠦ, ꠔꠣꠞ ꠍꠤꠙꠣꠁ ꠖꠟꠞꠦ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠔꠥꠟꠤꠀ ꠖꠤꠟꠣꠁꠍꠤ। ꠔꠥꠝꠤ ꠢꠤꠡꠛꠘ ꠖꠦꠡꠅ ꠀꠝꠥꠞꠤ ꠎꠣꠔꠤꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞ ꠎꠦ ꠖꠡꠣ ꠊꠐꠣꠁꠍ, ꠅꠉꠥꠞꠦꠅ ꠅꠃꠟꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT3_3","006_3_3","DEU","3","3","3","“ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠞꠦ, ꠔꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ꠀꠝꠞꠣꠅ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠟꠣꠝ, ꠇꠥꠘꠥꠉꠥꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠞꠣꠈꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT3_4","006_3_4","DEU","3","4","4","ꠀꠝꠞꠣ ꠔꠣꠞ ꠖꠦꠡꠞ ꠢꠇꠟ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ, ꠐꠣꠃꠘ-ꠛꠘ꠆ꠖꠞ ꠖꠈꠟ ꠇꠞꠟꠣꠝ। ꠔꠣꠞꠣꠞ ꠡꠣꠁꠐ ꠈꠣꠘ ꠐꠣꠃꠘꠃ ꠖꠈꠟ ꠇꠞꠤꠟ꠆ꠟꠣꠝ, ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠖ ꠞꠁꠟ ꠘꠣ। ꠀꠡ꠆ꠔꠣ ꠅꠞꠉꠥꠛ ꠄꠟꠣꠇꠣ, ꠝꠣꠘꠤ ꠛꠣꠡꠘꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠞ ꠙꠥꠞꠣ ꠛꠣꠖꠡꠣꠁ ꠀꠝꠞꠣꠞ ꠖꠈꠟꠅ ꠘꠤꠟꠣꠝꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("DT3_5","006_3_5","DEU","3","5","5","ꠅꠃ ꠐꠣꠃꠘ ꠅꠇꠟꠅ ꠃꠌꠣ ꠃꠌꠣ ꠅꠀꠟ ꠖꠤꠀ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠇꠞꠣ ꠀꠍꠤꠟ, ꠁꠔꠣꠞ ꠉꠦꠁꠐꠅ ꠀꠍꠤꠟ ꠛꠠ ꠛꠠ ꠈꠤꠟ। ꠀꠞ ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠍꠣꠠꠣꠅ ꠛꠃꠔ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT3_6","006_3_6","DEU","3","6","6","ꠀꠝꠞꠣ ꠢꠇꠟ ꠐꠣꠃꠘ ꠀꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝꠞꠦ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠤ। ꠀꠉꠦ ꠢꠤꠡꠛꠘꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞ ꠎꠦ ꠖꠡꠣ ꠊꠐꠣꠁꠍꠤ, ꠅꠈꠘ ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ, ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠢꠇꠟ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠀꠞ ꠐꠣꠃꠘꠞꠦꠅ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT3_7","006_3_7","DEU","3","7","7","ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠙꠡꠥꠞ ꠙꠣꠟ ꠀꠞ ꠉꠘꠤꠝꠔꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠀꠝꠞꠣ ꠟꠁꠀ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT3_8","006_3_8","DEU","3","8","8","“ꠀꠝꠞꠣ ꠅꠃ ꠡꠝꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛ ꠙꠣꠞꠞ ꠀꠝꠥꠞꠤ ꠎꠣꠔꠤꠞ ꠖꠥꠁꠅ ꠛꠣꠖꠡꠣꠞ ꠖꠈꠟꠞ, ꠅꠞꠘꠘ ꠈꠣꠟ ꠕꠣꠇꠤ ꠢꠞ꠆ꠝꠥꠘ ꠙꠣꠠ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠛꠎꠣ ꠇꠞꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT3_9","006_3_9","DEU","3","9","9","(ꠍꠤꠖꠘꠞ ꠝꠣꠘꠡꠦ ꠅꠃ ꠢꠞ꠆ꠝꠥꠘ ꠄꠟꠣꠇꠣꠞꠦ ꠍꠤꠞꠤꠅꠘ ꠇꠁꠀ ꠒꠣꠇꠂꠘ, ꠀꠞ ꠀꠝꠥꠞꠤ ꠎꠣꠔꠤꠄ ꠇꠂꠘ ꠍꠘꠤꠞ।) ");
INSERT INTO syls_vpl VALUES ("DT3_10","006_3_10","DEU","3","10","10","ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠞ ꠅꠃ ꠕꠟ ꠎꠣꠉꠣꠞ ꠢꠇꠟ ꠐꠣꠃꠘ ꠀꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ, ꠀꠡ꠆ꠔꠣ ꠉꠤꠟꠤꠅꠖ ꠄꠟꠣꠇꠣ, ꠛꠣꠖꠡꠣ ꠃꠎꠞ ꠍꠥꠟꠈꠣ ꠀꠞ ꠁꠖꠞꠤ ꠐꠣꠃꠘ ꠡꠢ ꠀꠡ꠆ꠔꠣ ꠛꠣꠡꠘ ꠖꠦꠡꠞꠦ ꠀꠝꠞꠣ ꠖꠈꠟ ꠇꠞꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("DT3_11","006_3_11","DEU","3","11","11","(ꠙꠥꠞꠣ ꠞꠚꠣꠄꠁ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠈꠣꠟꠤ ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠛꠣꠖꠡꠣ ꠃꠎ ꠎꠤꠔꠣ ꠞꠁꠍꠟꠣ। ꠅꠃ ꠛꠣꠖꠡꠣ ꠟꠥꠀꠞ ꠙꠣꠟꠋꠉꠅ ꠢꠥꠔꠤꠔꠣ, ꠁꠈꠣꠘ ꠟꠣꠝ꠆ꠛꠣꠄ ꠘꠄ ꠀꠔ ꠀꠞ ꠚꠣꠠꠦ ꠌꠣꠁꠞ ꠀꠔ। ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘ ꠎꠣꠔꠤꠞ ꠞꠣꠛ꠆ꠛꠣ ꠐꠣꠃꠘꠅ ꠁꠈꠣꠘ ꠅꠈꠘꠅ ꠕꠅꠀ ꠀꠍꠦ।) ");
INSERT INTO syls_vpl VALUES ("DT3_12","006_3_12","DEU","3","12","12","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠞꠣ, “ꠀꠝꠞꠣꠞ ꠖꠈꠟ ꠇꠞꠣ ꠅꠞꠘꠘ ꠈꠣꠟꠞ ꠙꠣꠞꠅ ꠀꠞꠥꠀꠞ ꠐꠣꠃꠘꠞ ꠛꠣꠁꠞꠞ ꠃꠔꠞꠞ ꠄꠟꠣꠇꠣ, ꠀꠞ ꠙꠣꠠꠤꠀ ꠉꠤꠟꠤꠅꠖ ꠄꠟꠣꠇꠣꠞ ꠅꠞ꠆ꠗꠦꠇ ꠎꠣꠉꠣ, ꠢꠘꠞ ꠢꠇꠟ ꠐꠣꠃꠘ ꠀꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝ ꠅꠇꠟ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠞꠥꠛꠦꠘ ꠀꠞ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠖꠤꠟꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT3_13","006_3_13","DEU","3","13","13","ꠉꠤꠟꠤꠅꠖ ꠖꠦꠡꠞ ꠛꠣꠇꠤ ꠅꠋꠡ ꠀꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠘꠣ ꠀꠡ꠆ꠔꠣ ꠛꠣꠡꠘ ꠖꠦꠡꠞꠦ ꠀꠝꠤ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠅꠞ꠆ꠗꠦꠇ ꠝꠣꠘꠡꠞꠦ ꠖꠤꠟꠣꠝ।” (ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠀꠡ꠆ꠔꠣ ꠅꠞꠉꠥꠛ ꠄꠟꠣꠇꠣꠞꠦ ꠞꠚꠣꠄꠁ ꠎꠣꠔꠤꠞ ꠖꠦꠡ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("DT3_14","006_3_14","DEU","3","14","14","ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠇ ꠎꠘꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠎꠣꠄꠁꠞ, ꠢꠦ ꠀꠡ꠆ꠔꠣ ꠅꠞꠉꠥꠛ ꠄꠟꠣꠇꠣ ꠝꠣꠘꠤ, ꠉꠡꠥꠞꠤ ꠀꠞ ꠝꠣꠈꠣꠔꠤ ꠎꠣꠔꠤꠞ ꠡꠤꠝꠣꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠈꠟ ꠇꠞꠤꠀ ꠔꠣꠞ ꠘꠤꠎꠞ ꠘꠣꠝꠞ ꠝꠤꠟꠦ ꠅꠃ ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠘꠣꠝ ꠖꠤꠟ ꠢꠣꠛ꠆ꠛꠥꠔ-ꠎꠣꠄꠁꠞ। ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘꠅ ꠁꠈꠣꠘꠞꠦ ꠅꠃ ꠘꠣꠝꠦ ꠒꠣꠇꠣ ꠅꠄ।) ");
INSERT INTO syls_vpl VALUES ("DT3_15","006_3_15","DEU","3","15","15","“ꠀꠞ ꠉꠤꠟꠤꠅꠖꠞ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣ ꠀꠝꠤ ꠝꠣꠈꠤꠞꠞꠦ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT3_16","006_3_16","DEU","3","16","16","ꠅꠁꠟꠦ ꠉꠤꠟꠤꠅꠖ ꠕꠣꠇꠤ ꠅꠞꠘꠘꠞ ꠙꠣꠠꠤꠀ ꠈꠣꠟꠞ ꠝꠣꠎꠣꠝꠣꠎꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇꠟ ꠎꠣꠉꠣ, ꠀꠞ ꠢꠘ ꠕꠣꠇꠤ ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘ ꠎꠣꠔꠤꠞ ꠡꠤꠝꠣꠘꠣ ꠎꠣꠛ꠆ꠛꠥꠇ ꠈꠣꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠤ ꠞꠥꠛꠦꠘ ꠀꠞ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT3_17","006_3_17","DEU","3","17","17","ꠔꠣꠞꠣꠞ ꠖꠦꠡꠞ ꠙꠁꠌꠝꠞ ꠡꠤꠝꠣꠘꠣ ꠀꠍꠤꠟ, ꠀꠞꠣꠛꠣ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠎꠦ ꠅꠋꠡ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠗꠣꠞꠦꠖꠤ, ꠙꠤꠍꠉꠣ ꠘꠣꠝꠞ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠞ ꠀꠞꠣꠛꠣ ꠡꠣꠉꠞ ꠛꠣ ꠟꠥꠘꠣ ꠡꠣꠉꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠦꠍꠦ, ꠅꠃ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("DT3_18","006_3_18","DEU","3","18","18","“ꠅꠃ ꠎꠣꠉꠣ ꠅꠈꠘꠣꠁꠘ ꠡꠝꠎꠣꠁ ꠖꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣꠝ, ꠁꠈꠘꠣꠁꠘ ꠜꠥꠉ-ꠖꠈꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠍꠂꠘ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠡꠞꠤꠟꠅ ꠛꠟ ꠀꠍꠦ, ꠎꠦꠞꠣ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠈ, ꠄꠞꠣ ꠎꠥꠁꠔ-ꠎꠣꠁꠔ ꠅꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠉꠦ ꠉꠤꠀ ꠉꠣꠋ ꠙꠣꠞ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("DT3_19","006_3_19","DEU","3","19","19","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠐꠣꠃꠘ ꠀꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝꠅ ꠔꠥꠝꠞꠣꠞ ꠛꠃ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠀꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠢꠇꠟꠔꠣ ꠞꠁꠛꠣ। ꠀꠝꠤ ꠎꠣꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠃꠔ ꠙꠡꠥ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT3_20","006_3_20","DEU","3","20","20","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣ ꠖꠤꠟꠣꠁꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠔꠣꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠅꠈꠣꠘꠞ ꠖꠈꠟ ꠙꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠥꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠅꠃ ꠎꠣꠉꠣꠔ ꠚꠤꠞꠤꠀ ꠀꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("DT3_21","006_3_21","DEU","3","21","21","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠞꠣ, “ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠁꠃꠍꠣꠞꠦ ꠇꠁꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠖꠥꠁꠅ ꠛꠣꠖꠡꠣꠞ ꠇꠥꠘ ꠖꠡꠣ ꠊꠐꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠔ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠍ। ꠔꠦ ꠅꠈꠘ ꠎꠞ꠆ꠖꠣꠘ ꠙꠣꠞ ꠅꠁꠀ ꠔꠥꠝꠞꠣ ꠎꠔ ꠖꠦꠡꠣꠁꠘ꠆ꠔꠅ ꠎꠣꠁꠞꠣꠄ, ꠝꠣꠛꠥꠖꠦ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟ ꠖꠦꠡꠣꠁꠘ꠆ꠔꠞ ꠖꠡꠣꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠊꠐꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT3_22","006_3_22","DEU","3","22","22","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠞꠣꠞ ꠙꠇ꠆ꠇ ꠅꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT3_23","006_3_23","DEU","3","23","23","“ꠀꠞ ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠞꠎ ꠇꠞꠟꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("DT3_24","006_3_24","DEU","3","24","24","ꠅ ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣ, ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠔ ꠅꠈꠘꠃ ꠖꠦꠈꠣꠘꠤ ꠗꠞꠍ, ꠔꠥꠝꠤ ꠇꠔ ꠝꠢꠣꠘ ꠀꠞ ꠇꠔ ꠛꠟꠛꠣꠘ। ꠔꠥꠝꠤ ꠅꠃ ꠎꠔꠔꠣ ꠇꠞꠍ, ꠁꠔꠣ ꠇꠞꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠇꠣꠞ ꠀꠍꠦ, ꠀꠍꠝꠣꠘꠅ ꠛꠣ ꠎꠝꠤꠘꠞ ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠀꠍꠦ ꠘꠤ, ꠔꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠖꠣꠙꠐ ꠖꠦꠈꠣꠁꠔ? ");
INSERT INTO syls_vpl VALUES ("DT3_25","006_3_25","DEU","3","25","25","ꠝꠃꠟꠣ ꠉ, ꠀꠝꠣꠞ ꠛꠠ ꠡꠈ ꠅꠁꠟ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠉꠤꠀ ꠔꠥꠝꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠅꠃ ꠡꠥꠘ꠆ꠖꠞ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣ ꠀꠞ ꠟꠦꠛꠣꠘꠘ ꠖꠦꠡ ꠖꠦꠈꠔꠣꠝ, ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠎꠣꠁꠔꠦ ꠖꠤꠛꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("DT3_26","006_3_26","DEU","3","26","26","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠘꠣ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠀꠞꠎꠤ ꠢꠥꠘꠟꠣ ꠘꠣ, ꠔꠥꠝꠞꠣꠞ ꠇꠣꠞꠘꠦꠃ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠘꠣꠞꠣꠎ ꠀꠍꠟꠣ। ꠝꠣꠛꠥꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, ꠔꠥꠝꠤ ꠛꠃꠔ ꠇꠁꠍ, ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠞ ꠝꠣꠋꠉꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT3_27","006_3_27","DEU","3","27","27","ꠀꠁꠌ꠆ꠍꠣ, ꠔꠥꠝꠤ ꠅꠃ ꠙꠤꠍꠉꠣ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠃꠑꠅ, ꠃꠑꠤꠀ ꠃꠔꠞꠦ-ꠖꠃꠇꠘꠦ ꠀꠞ ꠙꠥꠛꠦ-ꠙꠁꠌꠝꠦ ꠌꠃꠈ ꠚꠣꠟꠣꠅ। ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞꠘꠤ ꠘꠤꠡꠦꠗ ꠅꠁꠟꠦꠅ, ꠅꠘ ꠕꠣꠇꠤ ꠃꠛꠣꠁꠀ ꠢꠃ ꠖꠦꠡꠞꠦ ꠖꠦꠈꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("DT3_28","006_3_28","DEU","3","28","28","ꠀꠞ ꠔꠥꠝꠣꠞ ꠈꠣꠖꠤꠝ ꠁꠃꠍꠣꠞꠦ ꠢꠤꠇꠣꠁ ꠖꠦꠅ, ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠣ ꠟꠣꠉꠛ। ꠔꠣꠞ ꠢꠤꠝ꠆ꠝꠔ ꠛꠣꠠꠣꠅ, ꠜꠤꠔꠞꠦ ꠡꠣꠅꠡ ꠖꠦꠅ, ꠇꠣꠞꠘ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠀꠉꠦ ꠞꠁꠀ ꠢꠦ ꠉꠣꠋ ꠙꠣꠞ ꠇꠞꠣꠁꠛ, ꠀꠞ ꠔꠥꠝꠤ ꠅꠘ ꠕꠣꠇꠤ ꠎꠦ ꠖꠦꠡ ꠖꠦꠈꠞꠣꠄ, ꠢꠦ ꠄꠞꠣꠞꠦꠖꠤ ꠅꠃ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT3_29","006_3_29","DEU","3","29","29","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠀꠝꠞꠣ ꠛꠣꠄꠔ-ꠙꠤꠃꠞꠞ ꠍꠣꠝꠘꠞ ꠘꠤꠌꠣ ꠎꠣꠉꠣꠔ ꠞꠁꠉꠦꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("DT4_1","006_4_1","DEU","4","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠀꠝꠤ ꠅꠈꠘ ꠎꠦ ꠡꠞꠤꠅꠔ ꠀꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠇꠁꠝꠥ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟ ꠇꠞꠤ ꠢꠥꠘꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠦ ꠛꠣꠌꠛꠣꠄ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠖꠈꠟ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT4_2","006_4_2","DEU","4","2","2","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠁ ꠢꠥꠇꠥꠝꠞ ꠟꠉꠦ ꠖꠥꠍꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠠꠣꠁꠅ ꠘꠣ ꠛꠣ ꠇꠝꠣꠁꠅ ꠘꠣ। ꠀꠝꠤ ꠎꠦꠟꠣꠈꠣꠘ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠑꠤꠇ ꠅꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT4_3","006_4_3","DEU","4","3","3","“ꠔꠥꠝꠞꠣ ꠔ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠍ, ꠀꠉꠦ ꠝꠣꠛꠥꠖꠦ ꠛꠣꠀꠟ-ꠙꠤꠃꠞꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠍꠂꠘ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠎꠔ ꠎꠘꠦ ꠙꠤꠃꠞ ꠄꠟꠣꠇꠣꠞ ꠛꠣꠀꠟ ꠖꠦꠛꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠍꠤꠟ, ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT4_4","006_4_4","DEU","4","4","4","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇ ꠀꠍꠟꠣꠄ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠃ ꠅꠈꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("DT4_5","006_4_5","DEU","4","5","5","“ꠅꠈꠘ ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠖꠤꠍꠟꠣ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠑꠤꠇ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠢꠤꠇꠣꠁꠍꠤ। ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠎꠦ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄ, ꠢꠃ ꠖꠦꠡꠅ ꠁꠔꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("DT4_6","006_4_6","DEU","4","6","6","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠢꠥꠡꠤꠀꠞ ꠅꠁꠀ ꠁꠔꠣ ꠝꠣꠘꠤꠅ, ꠀꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠅ। ꠔꠦꠃ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦꠃ ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠢꠤꠡꠣꠛꠦ ꠎꠣꠁꠞ ꠅꠁꠛ। ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠞ ꠇꠕꠣ ꠢꠥꠘꠟꠦ ꠔꠣꠞꠣ ꠇꠁꠛꠣ, ꠢꠣꠍꠣꠃ ꠄꠞꠣ ꠈꠥꠛ ꠛꠠ ꠎꠣꠔꠤ ꠀꠞ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠀꠟꠣ ꠎꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("DT4_7","006_4_7","DEU","4","7","7","ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠎꠦꠟꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠂꠘ, ꠔꠣꠘꠞꠦ ꠒꠣꠇꠤꠟꠦ ꠎꠦꠟꠣ ꠗꠣꠞꠅ ꠙꠣꠁ, ꠅꠃ ꠖꠥꠘꠤꠀꠞ ꠛꠥꠇꠥꠔ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠛꠠ ꠎꠣꠔꠤ ꠀꠍꠂꠘ ꠘꠤ, ꠎꠦꠔꠣꠞ ꠖꠦꠛꠔꠣ ꠅꠟꠣ ꠟꠉꠦ ꠟꠉꠦ ꠞꠂꠘ? ");
INSERT INTO syls_vpl VALUES ("DT4_8","006_4_8","DEU","4","8","8","ꠛꠣ ꠀꠝꠤ ꠅꠈꠘ ꠎꠦ ꠡꠞꠤꠅꠔꠞ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠁꠔꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠛꠠ ꠎꠣꠔꠤꠞ ꠀꠍꠦ ꠘꠤ? ꠁꠟꠣ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠞ ꠘꠤꠈꠥꠔ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠔꠣꠞꠣꠞ ꠀꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("DT4_9","006_4_9","DEU","4","9","9","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠔꠖꠤꠘ ꠛꠣꠌꠤꠀ ꠞꠁꠛꠣꠄ, ꠅꠔꠖꠤꠘ ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠛ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠘꠤꠎꠞ ꠖꠤꠟꠞꠦ ꠡꠣꠛꠗꠣꠘꠦ ꠞꠣꠈꠤꠅ, ꠀꠞꠘꠣꠄ ꠘꠤꠎꠞ ꠌꠈꠥꠞ ꠖꠦꠈꠣ ꠊꠐꠘꠣ ꠅꠇꠟ ꠚꠣꠃꠞꠤꠟꠤꠛꠣꠄ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠈꠥꠀꠁꠟꠤꠛꠣꠄ। ꠀꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦ ꠢꠤꠇꠣꠅ, ꠔꠣꠞꠣꠅ ꠅꠟꠣ ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖꠞꠦ ꠢꠤꠇꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_10","006_4_10","DEU","4","10","10","ꠀꠞ ꠔꠥꠝꠞꠣ ꠢꠃ ꠖꠤꠘꠞ ꠊꠐꠘꠣ ꠝꠘꠅ ꠇꠞꠅ, ꠎꠦ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠔꠥꠞ ꠙꠣꠠꠅ ꠀꠙꠘ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠍꠟꠣꠄ। ꠎꠦꠛꠟꠣ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠇꠁꠍꠟꠣ, ꠀꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠖꠟꠣ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠅ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠤꠇꠛꠣ, ꠁ ꠎꠉꠔꠅ ꠔꠣꠞꠣ ꠎꠔꠖꠤꠘ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠛꠣ, ꠅꠔꠖꠤꠘ ꠀꠝꠣꠞꠦ ꠒꠞꠣꠁꠀ ꠞꠁꠔꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦꠅ ꠅꠟꠣ ꠌꠟꠣꠞ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_11","006_4_11","DEU","4","11","11","ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠤꠀ ꠅꠃ ꠙꠣꠠꠞ ꠟꠣꠝꠣꠔ ꠃꠛꠣꠁꠍꠟꠣꠄ, ꠃꠛꠣꠁꠀ ꠖꠦꠈꠟꠣꠄ, ꠀꠡ꠆ꠔꠣ ꠙꠣꠠꠅ ꠖꠣꠃ ꠖꠣꠃ ꠇꠞꠤ ꠘꠥꠞꠞ ꠀꠉꠥꠁꠘ ꠎꠟꠦꠞ, ꠀꠉꠥꠁꠘꠦ ꠉꠤꠀ ꠀꠍꠝꠣꠘ ꠍꠁꠟꠤꠍꠦ, ꠀꠞ ꠉꠁꠘ ꠊꠘ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤꠄ ꠀꠘ꠆ꠖꠣꠁꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT4_12","006_4_12","DEU","4","12","12","ꠢꠃ ꠘꠥꠞꠞ ꠀꠉꠥꠘꠤꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ, ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠣꠁꠟꠣ। ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠝꠥꠈꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠄ, ꠅꠁꠟꠦ ꠔꠣꠘ ꠇꠥꠘꠥ ꠍꠥꠞꠔ-ꠀꠇꠣꠞ ꠖꠦꠈꠣꠁꠍꠂꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠍ। ");
INSERT INTO syls_vpl VALUES ("DT4_13","006_4_13","DEU","4","13","13","ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠀꠟ꠆ꠟꠣꠁ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠈꠣꠍ ꠖꠡꠐꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠖꠤꠟꠣ, ꠀꠞ ꠇꠁꠟꠣ ꠅꠉꠥꠁꠘ ꠝꠣꠘꠤꠀ ꠌꠟꠣꠞ ꠟꠣꠉꠤ। ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠦ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠁꠔꠣ ꠟꠦꠈꠤꠀꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_14","006_4_14","DEU","4","14","14","ꠢꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠢꠤꠇꠣꠁꠔꠣꠝ, ꠎꠣꠔꠦ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡ ꠖꠈꠟꠅ ꠎꠣꠁꠞꠣꠄ, ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠅꠔꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("DT4_15","006_4_15","DEU","4","15","15","“ꠝꠣꠛꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠘꠥꠞꠞ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠥꠞ ꠙꠣꠠꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠟꠣ, ꠢꠃ ꠖꠤꠘ ꠔ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠇꠥꠘꠥ ꠍꠥꠞꠔ-ꠀꠇꠣꠞ ꠖꠦꠈꠍ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠛ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ ");
INSERT INTO syls_vpl VALUES ("DT4_16","006_4_16","DEU","4","16","16","ꠎꠣꠔꠦ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠔꠤ ꠘꠣ ꠛꠣꠘꠣꠅ, ꠛꠦ-ꠙꠕꠤ ꠛꠘꠤꠀ ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠞ ꠍꠥꠞꠔꠦ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_17","006_4_17","DEU","4","17","17","ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠌꠟꠞꠣ ꠇꠥꠘꠥ ꠎꠤꠛ-ꠎꠣꠘꠥꠀꠞꠞ ꠍꠥꠞꠔꠦ, ꠀꠍꠝꠣꠘꠅ ꠃꠠꠞꠣ ꠇꠥꠘꠥ ꠙꠣꠈꠤꠞ ꠍꠥꠞꠔꠦ, ");
INSERT INTO syls_vpl VALUES ("DT4_18","006_4_18","DEU","4","18","18","ꠛꠥꠇ ꠍꠦꠌꠠꠣꠁꠀ ꠌꠟꠞꠣ ꠇꠥꠘꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠍꠥꠞꠔꠦ, ꠛꠣ ꠙꠣꠘꠤꠔ ꠞꠅꠞꠣ ꠇꠥꠘꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠍꠥꠞꠔꠦ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_19","006_4_19","DEU","4","19","19","ꠀꠍꠝꠣꠘꠦꠖꠤ ꠌꠣꠁꠀ ꠢꠣꠞꠤ ꠌꠣꠘ꠆ꠖ, ꠡꠥꠞꠥꠎ, ꠔꠦꠞꠣ ꠅꠇꠟ ꠖꠦꠈꠤꠀ ꠅꠃ ꠘꠣꠝꠞ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠛꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠄꠞꠣꠞ ꠈꠦꠎꠝꠔꠅ ꠟꠣꠉꠤꠅ ꠘꠣ। ꠁꠔꠣꠞꠦ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠍꠝꠣꠘꠞ ꠔꠟꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠟꠣꠉꠤ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT4_20","006_4_20","DEU","4","20","20","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ ꠟꠥꠀ ꠉꠟꠣꠘꠤꠞ ꠉꠞꠝ ꠀꠉꠥꠘꠤꠞ ꠉꠣꠔꠅ ꠕꠣꠇꠤ, ꠔꠣꠁꠘ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠀꠙꠘ ꠙ꠆ꠞꠎꠣ ꠅꠅ, ꠀꠞ ꠅꠈꠘ ꠔ ꠢꠣꠍꠣꠃ ꠔꠣꠘ ꠙ꠆ꠞꠎꠣ ꠅꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("DT4_21","006_4_21","DEU","4","21","21","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠥꠝꠞꠣꠞ ꠇꠣꠞꠘꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦꠅ ꠉꠥꠍꠣ ꠇꠞꠍꠂꠘ। ꠔꠣꠁꠘ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠍꠂꠘ, ꠀꠝꠣꠞꠦ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠎꠣꠁꠔꠦ ꠖꠤꠔꠣ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠞꠣ, ꠅꠃ ꠀꠞꠣꠝꠞ ꠖꠦꠡꠅ ꠀꠝꠣꠞ ꠎꠣꠅꠀ ꠘꠤꠡꠦꠗ। ");
INSERT INTO syls_vpl VALUES ("DT4_22","006_4_22","DEU","4","22","22","ꠀꠝꠣꠞ ꠝꠃꠔ ꠅꠘꠅꠃ ꠅꠁꠛ। ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞꠘꠤꠞ ꠢꠥꠇꠥꠝ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠃ ꠀꠞꠣꠝꠞ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT4_23","006_4_23","DEU","4","23","23","ꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠦ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠇꠣꠁꠝ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠚꠣꠃꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠤꠡꠦꠗ ꠅꠝꠣꠁꠘ꠆ꠘ ꠇꠞꠤꠀ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_24","006_4_24","DEU","4","24","24","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔ ꠝꠢꠣ ꠗꠋꠡꠞ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ, ꠔꠣꠁꠘ ꠔ ꠟꠣ-ꠡꠞꠤꠇ, ꠇꠥꠘꠥ ꠡꠞꠤꠇ ꠡꠁꠎ꠆ꠎ ꠇꠞꠂꠘ ꠘꠣ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠣꠅꠘꠣ ꠄꠛꠣꠖꠔ ꠌꠣꠁꠘꠃ ꠌꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("DT4_25","006_4_25","DEU","4","25","25","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠄꠅꠈꠣꠘ ꠇꠁꠟꠣ, “ꠢꠃ ꠀꠞꠣꠝꠞ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠤ, ꠔꠥꠝꠞꠣ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠘꠣꠔꠤ-ꠙꠥꠔꠤꠞ ꠎꠘꠝ ꠖꠤꠀ ꠛꠃꠔ ꠖꠤꠘ ꠛꠡꠔ ꠇꠞꠣꠞ ꠛꠣꠖꠦꠅ ꠎꠥꠖꠤ ꠇꠥ-ꠙꠕꠦ ꠎꠣꠅꠉꠤ, ꠀꠞ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠞ ꠍꠥꠞꠔꠦ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣ ꠅꠔꠣ ꠇꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("DT4_26","006_4_26","DEU","4","26","26","ꠔꠦ ꠀꠝꠤ ꠅꠈꠘ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠁꠀꠞ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠎꠦ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄ, ꠢꠤꠘꠅ ꠈꠥꠛ ꠎꠟꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠤꠎꠤꠛ। ꠛꠦꠡꠤ ꠖꠤꠘ ꠐꠤꠇꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ, ꠘꠤꠌ꠆ꠌꠤꠔ ꠛꠤꠘꠣꠡ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT4_27","006_4_27","DEU","4","27","27","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠍꠤꠔ꠆ꠞꠣꠁ ꠖꠤꠛꠣ, ꠔꠣꠁꠘ ꠈꠦꠖꠣꠁ ꠖꠤꠀ ꠎꠦꠈꠣꠘꠅ ꠙꠣꠑꠣꠁꠛꠣ, ꠢꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠈꠥꠛ ꠇꠝ ꠝꠣꠘꠥꠡ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_28","006_4_28","DEU","4","28","28","ꠅꠃ ꠢꠣꠟꠔꠦ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠥꠡ-ꠀꠔꠦ ꠛꠣꠘꠣꠁꠟ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠛꠣꠄ, ꠎꠦꠔꠣꠄ ꠌꠃꠈꠦ ꠖꠦꠈꠦ ꠘꠣ, ꠇꠣꠘꠦ ꠢꠥꠘꠦ ꠘꠣ, ꠈꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠇꠥꠘꠥꠎꠣꠔ ꠊꠦꠞꠣꠘꠅ ꠢꠥꠋꠉꠤꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠟꠣꠇꠠꠤꠞ ꠀꠞ ꠙꠣꠔ꠆ꠔꠞꠞ ꠅꠔꠣ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT4_29","006_4_29","DEU","4","29","29","ꠔꠣ-ꠅ ꠢꠘꠅ ꠞꠁꠀ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠅ, ꠔꠦ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠛꠣ। ꠇꠕꠣ ꠅꠁꠟ, ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠇꠣꠔꠞ ꠅꠁꠀ ꠔꠣꠘꠦ ꠒꠣꠇꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT4_30","006_4_30","DEU","4","30","30","ꠢꠦꠡ-ꠝꠦꠡ ꠔꠥꠝꠞꠣ ꠝꠍꠤꠛꠔꠅ ꠙꠠꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠔꠃꠛꠣ ꠇꠞꠤꠀ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠟꠁꠛꠣꠄ, ꠀꠞ ꠔꠣꠘ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT4_31","006_4_31","DEU","4","31","31","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠞꠢꠝꠣꠘꠥꠞ ꠞꠢꠤꠝ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠚꠣꠟꠣꠁꠔꠣ ꠘꠣꠄ ꠛꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠔꠣ ꠘꠣꠄ। ꠀꠞ ꠔꠣꠁꠘ ꠇꠍꠝ ꠈꠣꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠟꠉꠦ ꠎꠦ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠍꠂꠘ, ꠁꠔꠣꠅ ꠚꠣꠃꠞꠤꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT4_32","006_4_32","DEU","4","32","32","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠄꠅꠈꠣꠘ ꠇꠁꠞꠣ, “ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠎꠝꠤꠘꠅ ꠝꠣꠘꠥꠡ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠛꠣꠖ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠔꠥꠝꠞꠣꠞ ꠀꠉꠞ ꠢꠇ꠆ꠇꠟ ꠎꠝꠣꠘꠣꠞ ꠁꠔꠤꠢꠣꠡ ꠔꠥꠇꠣꠅ, ꠀꠡ꠆ꠔꠣ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣ ꠔꠥꠇꠣꠁꠀ ꠖꠦꠈꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠎꠔ ꠀꠎꠛ ꠊꠐꠘꠣ ꠊꠐꠤꠍꠦ, ꠁꠔꠣ ꠟꠣꠈꠣꠘ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠊꠐꠘꠣ ꠊꠐꠍꠦ ꠘꠤ? ꠛꠣ ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠇꠥꠘꠥꠖꠤꠘ ꠢꠥꠘꠣ ꠉꠦꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("DT4_33","006_4_33","DEU","4","33","33","ꠀꠞ ꠘꠥꠞꠞ ꠀꠉꠥꠁꠘ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠛꠥꠟꠤ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦ, ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠎꠣꠔꠤ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("DT4_34","006_4_34","DEU","4","34","34","ꠔꠥꠝꠞꠣ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤ ꠖꠦꠈꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠔꠔꠣ ꠇꠞꠍꠂꠘ, ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠄ ꠁꠟꠣ ꠇꠞꠔ ꠙꠣꠞꠍꠦ ꠘꠤ? ꠁꠟꠣ ꠙꠞꠤꠇ꠆ꠇꠣ ꠟꠅꠀ, ꠇꠥꠖꠞꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣꠘꠤ, ꠟꠣꠠꠣꠁ-ꠎꠥꠖ꠆ꠖ ꠇꠞꠣ, ꠝꠎꠛꠥꠔ ꠀꠔꠞ ꠛꠟ ꠖꠦꠈꠣꠘꠤ, ꠛꠠ ꠛꠠ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠀꠞ ꠒꠞ-ꠈꠚ ꠖꠦꠈꠣꠁꠀ, ꠎꠦꠇꠥꠘꠥ ꠎꠣꠔꠤꠞꠦ ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠤꠀ ꠘꠤꠎꠞ ꠙ꠆ꠞꠎꠣ ꠛꠣꠘꠣꠁꠔ ꠙꠣꠞꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("DT4_35","006_4_35","DEU","4","35","35","“ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠔꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠥꠎꠅ, ꠅꠃ ꠀꠟ꠆ꠟꠣꠃ ꠅꠁꠟꠣ ꠝꠣꠛꠥꠖ, ꠔꠣꠁꠘ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠛꠥꠖ ꠘꠣꠁ, ꠅꠈꠣꠘ ꠛꠥꠎꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠔꠔꠣ ꠖꠦꠈꠣꠘꠤ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT4_36","006_4_36","DEU","4","36","36","ꠔꠥꠝꠞꠣꠞꠦ ꠢꠦꠖꠣꠄꠅꠔ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠔꠣꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠀꠞꠡ ꠕꠣꠇꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠥꠟꠤ ꠢꠥꠘꠣꠁꠟꠣ, ꠀꠞ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠖꠦꠈꠣꠁꠟꠣ ꠘꠥꠞꠞ ꠀꠉꠥꠘꠤꠞ ꠇꠥꠘ꠆ꠒꠟꠤ। ꠅꠃ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠞꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠁ ꠛꠥꠟꠤ ꠔꠥꠝꠞꠣ ꠢꠥꠘꠍ। ");
INSERT INTO syls_vpl VALUES ("DT4_37","006_4_37","DEU","4","37","37","ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠔꠣ, ꠄꠞꠟꠣꠉꠤ ꠄꠞꠣꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦꠅ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ। ꠀꠞ ꠔꠣꠁꠘ ꠡ꠆ꠛꠄꠅꠋ ꠀꠎꠤꠞ ꠅꠁꠀ ꠔꠣꠘ ꠝꠢꠣ ꠇꠥꠖꠞꠔꠤ ꠈꠦꠝꠔꠣ ꠈꠣꠐꠣꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT4_38","006_4_38","DEU","4","38","38","ꠔꠣꠘ ꠈꠤꠀꠟ ꠀꠍꠤꠟ, ꠔꠥꠝꠣꠔꠣꠘ ꠕꠣꠇꠤ ꠛꠠ ꠀꠞ ꠛꠟꠛꠣꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠀ ꠢꠣꠞꠤ, ꠔꠣꠞꠣꠞ ꠖꠦꠡꠅ ꠘꠤꠀ ꠢꠃ ꠢꠇꠟ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠔꠣ। ꠅꠈꠘ ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠔꠣꠁꠘ ꠔ ꠁꠔꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT4_39","006_4_39","DEU","4","39","39","“ꠔꠦ ꠅꠈꠘꠇꠥꠞ ꠅꠃ ꠔꠣꠟꠤꠝ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠉꠣꠕꠤꠀ ꠕꠁꠅ, ꠢꠥꠘꠅ, ꠈꠣꠟꠤ ꠅꠃ ꠀꠟ꠆ꠟꠣꠃ ꠃꠙꠞꠦ ꠀꠍꠝꠣꠘ ꠀꠞ ꠔꠟꠦ ꠎꠝꠤꠘꠞ ꠝꠣꠟꠤꠇ, ꠔꠣꠁꠘ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠛꠥꠖ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT4_40","006_4_40","DEU","4","40","40","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠈꠘ ꠎꠦ ꠡꠞꠤꠅꠔ ꠀꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠅꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠟꠣꠝ꠆ꠛꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("DT4_41","006_4_41","DEU","4","41","41","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛ-ꠙꠣꠞꠞ ꠔꠤꠘꠈꠣꠘ ꠐꠣꠃꠘ ꠀꠟꠉꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT4_42","006_4_42","DEU","4","42","42","ꠎꠣꠔꠦ ꠇꠥꠘꠥ ꠈꠥꠘꠤ ꠝꠣꠘꠥꠡ ꠜꠣꠉꠤꠀ ꠉꠤꠀ ꠅꠃ ꠐꠣꠃꠘꠅ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ ꠙꠣꠞꠦ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠇꠥꠘꠥ ꠌꠤꠘ꠆ꠔꠣ ꠛꠣ ꠖꠥꠡꠝꠘꠤ ꠜꠣꠛ ꠀꠍꠤꠟ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠈꠔꠣ ꠅꠘꠤꠌ꠆ꠍꠣꠄ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠞꠤꠟꠣꠄ, ꠢꠦ ꠜꠣꠉꠤꠀ ꠛꠘꠛꠣꠡꠤ ꠛꠘꠤꠀ ꠅꠘꠅ ꠞꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("DT4_43","006_4_43","DEU","4","43","43","ꠔꠤꠘꠅ ꠐꠣꠃꠘ ꠅꠁꠟ, ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠣꠉꠤ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠤꠘꠣꠞꠣꠞ ꠙꠣꠠꠤꠀ ꠕꠟ ꠎꠣꠉꠣꠞ ꠛꠣꠍꠤꠞ ꠘꠣꠝꠞ ꠐꠣꠃꠘ। ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠣꠉꠤ ꠉꠤꠟꠤꠅꠖ ꠄꠟꠣꠇꠣꠞ ꠞꠣꠝꠥꠔ ꠐꠣꠃꠘ। ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠣꠉꠤ ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠉꠥꠟꠣꠘ ꠐꠣꠃꠘ। ");
INSERT INTO syls_vpl VALUES ("DT4_44","006_4_44","DEU","4","44","44","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠡꠞꠤꠅꠔꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠛꠄꠀꠘ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT4_45","006_4_45","DEU","4","45","45","ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠅꠀꠞ ꠛꠣꠖꠦ, ꠢꠇꠟ ꠢꠥꠡꠤꠀꠞꠤꠞ ꠇꠕꠣ, ꠡꠞꠤꠅꠔꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_46","006_4_46","DEU","4","46","46","ꠔꠣꠁꠘ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛꠞ ꠙꠣꠞꠅ, ꠢꠤꠡꠛꠘ ꠄꠟꠣꠇꠣꠞ ꠀꠝꠥꠞꠤ ꠎꠣꠔꠤꠞ ꠞꠣꠎꠣ ꠍꠤꠢꠥꠘꠞ ꠖꠦꠡꠞ ꠛꠣꠄꠔ-ꠙꠤꠃꠞꠞ ꠍꠣꠝꠘꠞ ꠔꠟ ꠎꠣꠉꠣꠔ ꠁꠔꠣ ꠇꠁꠟꠣ। ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠤ ꠅꠃ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞꠦ ꠀꠞꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT4_47","006_4_47","DEU","4","47","47","ꠔꠣꠞꠣ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘꠞ ꠖꠦꠡ ꠀꠞ ꠛꠣꠡꠘꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠞ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠍꠟꠣ। ꠀꠝꠥꠞꠤ ꠎꠣꠔꠤꠞ ꠅꠃ ꠖꠥꠁꠅ ꠛꠣꠖꠡꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠍꠤꠟ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛꠞ ꠙꠣꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("DT4_48","006_4_48","DEU","4","48","48","ꠅꠞꠘꠘ ꠈꠣꠟꠞ ꠙꠣꠞꠞ ꠀꠞꠥꠀꠞ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠍꠤꠞꠤꠅꠘ ꠙꠣꠠ, ꠝꠣꠘꠤ ꠢꠞ꠆ꠝꠥꠘ ꠙꠣꠠ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠖꠥꠁꠅ ꠞꠣꠎꠣꠞ ꠡꠤꠝꠣꠘꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT4_49","006_4_49","DEU","4","49","49","ꠄꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠦ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠥꠛꠞ ꠙꠣꠞꠞ ꠀꠡ꠆ꠔꠣ ꠄꠟꠣꠇꠣ। ꠁꠇꠐꠣ ꠙꠤꠍꠉꠣ ꠙꠣꠠꠞ ꠐꠤꠟ꠆ꠟꠣꠞ ꠔꠟꠦꠖꠤ ꠀꠞꠣꠛꠣ ꠡꠣꠉꠞꠞ ꠇꠤꠘꠣꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT5_1","006_5_1","DEU","5","1","1","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠟꠣ ꠇꠞꠣꠁꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠀꠝꠤ ꠅꠈꠘ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠀꠁꠘ-ꠇꠣꠘꠥꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠝꠥ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟ ꠇꠞꠤ ꠢꠥꠘꠤꠅ, ꠢꠥꠘꠤꠀ ꠖꠤꠟꠅ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠤꠅ ꠀꠞ ꠀꠝꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT5_2","006_5_2","DEU","5","2","2","ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠞ ꠙꠣꠠꠅ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠄꠇ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT5_3","006_5_3","DEU","5","3","3","ꠅꠃ ꠌꠥꠇ꠆ꠔꠤ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠟꠉꠦ ꠘꠣ ꠇꠞꠤꠀ, ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠇꠞꠍꠂꠘ, ꠀꠝꠞꠣ ꠎꠔ ꠎꠘ ꠅꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠤ, ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT5_4","006_5_4","DEU","5","4","4","ꠝꠣꠛꠥꠖꠦ ꠅꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠘꠥꠞꠞ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠍꠣꠝꠘꠣ-ꠍꠣꠝꠘꠤ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT5_5","006_5_5","DEU","5","5","5","ꠔꠥꠝꠞꠣ ꠀꠉꠥꠘꠤꠞ ꠒꠞꠦ ꠢꠃ ꠡꠝꠄ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠟꠣꠄ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣ ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣꠁꠀ, ꠔꠣꠘ ꠝꠥꠈꠞ ꠛꠥꠟꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠥꠘꠣꠁꠍꠤ। ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT5_6","006_5_6","DEU","5","6","6","“ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ। ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT5_7","006_5_7","DEU","5","7","7","“ꠀꠝꠣꠞ ꠛꠖꠟꠣ ꠔꠥꠝꠞꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣ ꠝꠣꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_8","006_5_8","DEU","5","8","8","“ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ, ꠀꠍꠝꠣꠘ, ꠎꠝꠤꠘ ꠛꠣ ꠙꠣꠘꠤꠞ ꠔꠟꠦ ꠎꠔꠔꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠇꠥꠘꠥꠔꠣꠞ ꠍꠥꠞꠔꠦ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_9","006_5_9","DEU","5","9","9","ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠁꠔꠣꠞ ꠡꠦꠛꠣ-ꠎꠔꠘ ꠇꠞꠤꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠇꠥꠘꠥ ꠡꠞꠤꠇ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤ ꠘꠣ। ꠀꠝꠣꠞꠦ ꠎꠦꠞꠣ ꠝꠣꠘꠦ ꠘꠣ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠖꠦꠁ, ꠔꠣꠞꠣꠞ ꠙꠄꠟꠣ ꠍꠤꠠꠤ ꠕꠣꠇꠤ ꠌꠣꠁꠞ ꠍꠤꠠꠤ ꠀꠅꠟꠣꠖ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠡꠣꠎꠣ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("DT5_10","006_5_10","DEU","5","10","10","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠀꠝꠣꠞ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠦ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠅꠀꠞꠤꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠣꠞ ꠅꠛꠤꠞꠣꠝ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠖꠦꠈꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT5_11","006_5_11","DEU","5","11","11","“ꠛꠦꠇꠣꠝꠣ ꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠝꠥꠈꠅ ꠟꠁꠅ ꠘꠣ। ꠇꠦꠃ ꠎꠥꠖꠤ ꠈꠣꠝꠈꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ ꠟꠄ, ꠔꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠝꠣꠞ ꠡꠣꠎꠣ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT5_12","006_5_12","DEU","5","12","12","“ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠖꠤꠘ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT5_13","006_5_13","DEU","5","13","13","ꠢꠣꠙ꠆ꠔꠣꠞ ꠍꠄꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠖꠞꠇꠣꠞꠤ ꠢꠇꠟ ꠇꠣꠝ ꠡꠣꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT5_14","006_5_14","DEU","5","14","14","ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠅꠁꠟ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠎꠤꠞꠣꠁꠛꠣꠞ ꠖꠤꠘ। ꠁ ꠖꠤꠘ ꠔꠥꠝꠞꠣ, ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤꠘ, ꠉꠞꠥ-ꠉꠣꠗꠣꠁꠘ, ꠔꠥꠝꠞꠣꠞ ꠉꠣꠃꠔ ꠛꠣ ꠐꠣꠃꠘꠅ ꠞꠅꠞꠣ ꠝꠥꠍꠣꠚꠤꠞ ꠛꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ, ꠇꠦꠃ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤꠄꠅ ꠔꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠎꠤꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_15","006_5_15","DEU","5","15","15","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠕꠣꠇꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠄ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠛꠟꠀꠟꠣ-ꠝꠎꠛꠥꠔ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠖꠤꠘ ꠝꠣꠘꠔꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT5_16","006_5_16","DEU","5","16","16","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠖꠦꠡ ꠖꠤꠞꠣ, ꠢꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠛꠣꠠꠤꠛ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT5_17","006_5_17","DEU","5","17","17","“ꠈꠥꠘ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_18","006_5_18","DEU","5","18","18","“ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_19","006_5_19","DEU","5","19","19","“ꠌꠥꠞꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_20","006_5_20","DEU","5","20","20","“ꠇꠦꠃꠞꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_21","006_5_21","DEU","5","21","21","“ꠙꠞꠞ ꠛꠃꠞ ꠛꠣꠄ ꠟꠣꠟꠌ ꠇꠞꠤꠅ ꠘꠣ। ꠙꠞꠞ ꠊꠞ-ꠛꠣꠠꠤ, ꠎꠝꠤ-ꠝꠤꠞꠣꠡ, ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ, ꠉꠞꠥ-ꠉꠣꠗꠣ, ꠛꠣ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠞ ꠛꠣꠄ ꠟꠣꠟꠌ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_22","006_5_22","DEU","5","22","22","“ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠞ ꠢꠃ ꠘꠥꠞꠞ ꠀꠉꠥꠁꠘ ꠕꠣꠇꠤ, ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤ ꠀꠞ ꠉꠁꠘ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ, ꠈꠥꠛ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ। ꠈꠣꠟꠤ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠍꠣꠠꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞ ꠇꠥꠘꠥꠔꠣ ꠇꠁꠍꠂꠘ ꠘꠣ। ꠛꠣꠖꠦ ꠅꠃ ꠇꠣꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠦ ꠟꠦꠈꠤꠀ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_23","006_5_23","DEU","5","23","23","ꠅꠁꠟꠦ ꠔꠣꠘ ꠘꠥꠞꠞ ꠔꠎꠟ꠆ꠟꠤꠄ ꠎꠦꠛꠟꠣ ꠙꠣꠠ ꠎꠟꠦꠞ, ꠄꠞꠝꠣꠎꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠇꠣꠘꠦ ꠢꠥꠘꠟꠣꠄ, ꠢꠃ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ, ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠀꠝꠤꠞ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠃꠑꠤꠀ ꠀꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT5_24","006_5_24","DEU","5","24","24","ꠀꠁꠀ ꠇꠁꠟꠣ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠔꠣꠘ ꠎꠣꠟꠣꠟ ꠀꠞ ꠝꠢꠤꠝꠣ ꠀꠝꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠘꠥꠞꠞ ꠀꠉꠥꠁꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅꠁꠟ ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠀꠝꠞꠣ ꠢꠥꠘꠍꠤ। ꠀꠞ ꠅꠈꠘ ꠀꠝꠞꠣ ꠛꠥꠎꠟꠣꠝ, ꠇꠥꠘꠥ ꠀꠖꠝ ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠣꠞ ꠛꠣꠖꠦꠅ, ꠁ ꠀꠖꠝ ꠛꠣꠌꠤꠀ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("DT5_25","006_5_25","DEU","5","25","25","ꠅꠁꠟꠦ ꠅꠈꠘ ꠇꠦꠘꠦ ꠀꠝꠞꠣ ꠁꠘꠅ ꠝꠞꠔꠣꠝ? ꠇꠥꠖꠞꠔꠤ ꠁ ꠀꠉꠥꠁꠘꠦ ꠔ ꠀꠝꠞꠣꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛ, ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠞꠅ ꠛꠦꠡ ꠇꠞꠤ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣꠔ ꠞꠁ, ꠔꠦ ꠔ ꠘꠤꠞ꠆ꠉꠣꠔ ꠝꠞꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT5_26","006_5_26","DEU","5","26","26","ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠟꠣ ꠀꠞ ꠇꠥꠘꠥ ꠀꠖꠝ ꠎꠣꠔ ꠀꠍꠂꠘ ꠘꠤ, ꠎꠦꠞꠣ ꠘꠥꠞꠞ ꠀꠉꠥꠁꠘ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦꠅ ꠎꠤꠔꠣ ꠀꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("DT5_27","006_5_27","DEU","5","27","27","ꠔꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠔꠔꠣ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠤꠀ ꠀꠙꠘꠦꠃ ꠅꠔꠣ ꠢꠥꠘꠤꠀ ꠀꠁꠃꠇ꠆ꠇꠣ। ꠔꠣꠁꠘ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠛꠣ, ꠀꠙꠘꠦ ꠀꠁꠀ ꠅꠔꠣ ꠀꠝꠞꠣꠞꠦ ꠢꠥꠘꠣꠁꠛꠣ। ꠔꠦꠃ ꠀꠝꠞꠣ ꠅꠔꠣ ꠀꠝꠟ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT5_28","006_5_28","DEU","5","28","28","“ꠀꠞ ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠞꠣꠄ, ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠦ ꠁꠔꠣ ꠢꠥꠘꠟꠣ, ꠢꠥꠘꠤꠀ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞ ꠝꠣꠔ-ꠇꠕꠣ ꠔ ꠀꠝꠤ ꠢꠥꠘꠍꠤ, ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠂꠘ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_29","006_5_29","DEU","5","29","29","ꠢꠣꠍꠣꠃ ꠎꠥꠖꠤ ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠅꠟꠣ ꠒꠞꠣꠁꠘ, ꠢꠣꠝꠦꠡꠣ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠣꠞ ꠈꠤꠀꠟꠤ ꠅꠁꠘ, ꠔꠦ ꠔꠣꠞꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠜꠣꠟꠣꠁ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT5_30","006_5_30","DEU","5","30","30","“ꠅꠈꠘ ꠔꠥꠝꠤ ꠟꠣꠝꠣꠔ ꠎꠣꠅ ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠇꠅ, ꠔꠣꠞꠣꠞ ꠔꠣꠝ꠆ꠛꠥꠔ ꠚꠤꠞꠤꠀ ꠎꠣꠁꠔꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("DT5_31","006_5_31","DEU","5","31","31","ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠅꠘꠅ ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠞꠁꠅ। ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠝꠣꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ, ꠀꠁꠘ-ꠇꠣꠘꠥꠘ ꠀꠞ ꠡꠞꠤꠅꠔ ꠛꠣꠔꠣꠁꠝꠥ, ꠔꠥꠝꠤ ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠅꠔꠣ ꠢꠤꠇꠣꠁꠛꠣꠄ। ꠔꠦꠃ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠀꠞ, ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠞꠣ ꠅꠔꠣ ꠀꠝꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_32","006_5_32","DEU","5","32","32","“ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠎꠔꠘ ꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠅ, ꠁꠔꠣꠞ ꠔꠤꠟ ꠙꠞꠤꠝꠣꠘ ꠢꠦꠞ-ꠚꠦꠞ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT5_33","006_5_33","DEU","5","33","33","ꠔꠣꠁꠘ ꠎꠦ ꠙꠕꠦ ꠌꠟꠣꠞ ꠟꠣꠉꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠑꠤꠇ ꠅꠃ ꠙꠕꠦ ꠌꠟꠤꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠦ ꠛꠣꠌꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠛꠣꠄ, ꠢꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠛꠃꠔ ꠟꠣꠝ꠆ꠛꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT6_1","006_6_1","DEU","6","1","1","“ꠔꠥꠝꠞꠣꠞꠦ ꠢꠤꠇꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ, ꠡꠞꠤꠅꠔ ꠀꠞ ꠀꠁꠘ-ꠇꠣꠘꠥꠘ ꠖꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠢꠃ ꠎꠦ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠞꠣꠄ, ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("DT6_2","006_6_2","DEU","6","2","2","ꠔꠦꠃ ꠔꠥꠝꠞꠣ, ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠀꠞ ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠒꠞꠣꠁꠀ ꠔꠣꠘ ꠖꠦꠅꠀ ꠘꠤꠅꠝ ꠀꠞ ꠢꠥꠇꠥꠝ ꠅꠇꠟ ꠀꠝꠟ ꠇꠞꠤꠅ। ꠅꠟꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠛꠃꠔ ꠖꠤꠘ ꠛꠣꠌꠤꠀ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT6_3","006_6_3","DEU","6","3","3","ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠅ ꠀꠞ ꠢꠥꠡꠤꠀꠞ ꠅꠁꠀ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ, ꠢꠃ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ ꠀꠞ ꠔꠥꠝꠞꠣ ꠛꠃꠔ ꠛꠣꠠꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT6_4","006_6_4","DEU","6","4","4","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠔꠣꠁꠘꠃ ꠄꠇ। ");
INSERT INTO syls_vpl VALUES ("DT6_5","006_6_5","DEU","6","5","5","ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠤꠟ, ꠀꠡ꠆ꠔꠣ ꠎꠣꠘ ꠀꠞ ꠢꠇꠟ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT6_6","006_6_6","DEU","6","6","6","ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT6_7","006_6_7","DEU","6","7","7","ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠁꠔꠣ ꠈꠤꠀꠟ ꠇꠞꠤ ꠢꠤꠇꠣꠁꠅ। ꠀꠞ ꠊꠞꠅ ꠛꠁꠀ, ꠙꠕꠦ-ꠊꠣꠐꠦ ꠌꠟꠣꠞ ꠡꠝꠄ, ꠊꠥꠝꠣꠘꠤꠞ ꠡꠝꠄ, ꠊꠥꠝ ꠕꠣꠇꠤ ꠃꠑꠣꠞ ꠛꠣꠖꠦꠅ ꠅꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT6_8","006_6_8","DEU","6","8","8","ꠝꠘꠅ ꠞꠣꠈꠣꠞ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠁꠔꠣ ꠀꠔꠅ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠣꠈꠤꠅ ꠀꠞ ꠇꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT6_9","006_6_9","DEU","6","9","9","ꠔꠥꠝꠞꠣꠞ ꠖꠥꠀꠞꠞ ꠌꠃꠇꠣꠑꠅ ꠀꠞ ꠝꠥꠟ ꠉꠦꠁꠐꠅ ꠟꠦꠈꠤꠀ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT6_10","006_6_10","DEU","6","10","10","“ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦ ꠖꠦꠡ ꠖꠦꠅꠀꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠖꠦꠡ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠛꠣ। ꠢꠤꠘꠅ ꠡꠥꠘ꠆ꠖꠞ ꠡꠥꠘ꠆ꠖꠞ ꠀꠞ ꠛꠠ ꠛꠠ ꠐꠣꠃꠘ ꠅꠇꠟ ꠀꠍꠦ, ꠎꠦꠔꠣ ꠔꠥꠝꠞꠣ ꠛꠣꠘꠣꠁꠍ ꠘꠣ, ꠈꠣꠟꠤ ꠄꠝꠘꠦꠃ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT6_11","006_6_11","DEU","6","11","11","ꠀꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠄ ꠜꠞꠣ ꠢꠣꠎꠣꠁꠟ-ꠙꠣꠠꠣꠁꠟ ꠊꠞ-ꠖꠥꠀꠞ ꠙꠣꠁꠛꠣꠄ, ꠎꠦꠔꠣ ꠔꠥꠝꠞꠣ ꠎꠥꠉꠣꠁꠍ ꠘꠣ, ꠙꠣꠘꠤꠞ ꠇꠥꠀ ꠙꠣꠁꠛꠣꠄ ꠎꠦꠔꠣ ꠔꠥꠝꠞꠣ ꠈꠥꠖꠤꠍ ꠘꠣ, ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘ ꠀꠞ ꠎꠄꠔꠥꠘꠞ ꠛꠣꠉꠣꠘ ꠙꠣꠁꠛꠣꠄ ꠎꠦꠔꠣ ꠔꠥꠝꠞꠣ ꠟꠣꠉꠣꠁꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT6_12","006_6_12","DEU","6","12","12","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠙꠣꠁꠀ ꠢꠣꠞꠤ ꠝꠣꠟꠖꠣꠞ ꠛꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠚꠣꠃꠞꠤꠅ ꠘꠣ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT6_13","006_6_13","DEU","6","13","13","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠀ ꠌꠟꠤꠅ, ꠈꠣꠟꠤ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠤꠅ, ꠀꠞ ꠔꠣꠘ ꠘꠣꠝꠦ ꠇꠍꠝ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT6_14","006_6_14","DEU","6","14","14","ꠔꠥꠝꠞꠣ ꠀꠞꠤ-ꠚꠞꠤ ꠎꠣꠔꠤꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT6_15","006_6_15","DEU","6","15","15","ꠎꠣꠘ ꠔ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ, ꠔꠣꠁꠘ ꠔ ꠟꠣ-ꠡꠞꠤꠇ ꠝꠣꠛꠥꠖ, ꠇꠥꠘꠥ ꠡꠞꠤꠇ ꠡꠁꠎ꠆ꠎ ꠇꠞꠂꠘ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠁꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠟꠦ ꠔꠣꠁꠘ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT6_16","006_6_16","DEU","6","16","16","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠅ ꠘꠣ, ꠎꠦꠟꠣ ꠀꠉꠦ ꠢꠃ ꠝꠣꠍꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠇꠞꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT6_17","006_6_17","DEU","6","17","17","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠔ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ, ꠢꠥꠡꠤꠀꠞꠤ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟ ꠇꠞꠤ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT6_18","006_6_18","DEU","6","18","19","ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞꠅ ꠎꠦꠔꠣ ꠡꠑꠤꠇ, ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠜꠣꠟꠣ ꠙꠣꠁꠘ, ꠔꠥꠝꠞꠣ ꠅꠔꠣꠃ ꠇꠞꠤꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ। ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠇꠍꠝ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘꠞꠦ ꠔꠣꠁꠘ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠛꠣ। ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠢꠃ ꠀꠞꠣꠝꠞ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤꠅ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT6_20","006_6_20","DEU","6","20","20","“ꠜꠛꠤꠡꠔꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠛꠣ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ, ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ, ꠀꠞ ꠢꠥꠡꠤꠀꠞꠤ ꠖꠤꠍꠂꠘ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ? ");
INSERT INTO syls_vpl VALUES ("DT6_21","006_6_21","DEU","6","21","21","ꠅꠃ ꠡꠝꠄ ꠎꠥꠀꠙ ꠖꠤꠅ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠝꠞꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠛꠟꠀꠟꠣ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠖꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT6_22","006_6_22","DEU","6","22","22","ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠛꠣꠠꠤꠞ ꠢꠇꠟꠞ ꠃꠙꠞꠦ, ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠛꠠ ꠛꠠ ꠉꠎꠛꠤ ꠘꠤꠡꠣꠘꠣ, ꠛꠦꠎꠥꠁꠔꠣ ꠛꠣꠟꠣ-ꠝꠍꠤꠛꠔ ꠀꠞ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT6_23","006_6_23","DEU","6","23","23","ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠢꠃ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠟꠣ, ꠎꠣꠔꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠈꠣꠁꠍꠟꠣ, ꠢꠃ ꠖꠦꠡꠅ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠞ ꠇꠞꠤꠀ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("DT6_24","006_6_24","DEU","6","24","24","ꠀꠞ ꠔꠣꠁꠘ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠔꠣꠘ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤ, ꠔꠣꠘꠞꠦ ꠒꠞꠣꠁꠀ ꠌꠟꠤ, ꠔꠦꠃ ꠀꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ ꠀꠞ ꠀꠝꠞꠣ ꠅꠈꠘꠇꠥꠞ ꠟꠣꠈꠣꠘ ꠢꠣꠝꠦꠡꠣ ꠛꠣꠌꠤꠀ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT6_25","006_6_25","DEU","6","25","25","ꠅꠈꠘ ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠘ ꠖꠦꠅꠀ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠝꠣꠘꠤ, ꠔꠦ ꠁꠐꠣꠃ ꠅꠁꠟ ꠀꠝꠞꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("DT7_1","006_7_1","DEU","7","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠘꠅ ꠘꠤꠛꠣ ꠀꠞ ꠛꠃꠔ ꠎꠣꠔꠤꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠀ ꠢꠣꠞꠤ ꠁꠔꠣ ꠖꠈꠟ ꠇꠞꠣꠁꠛꠣ। ꠔꠣꠁꠘ ꠢꠤꠐ꠆ꠐꠤ, ꠉꠤꠞ꠆ꠉꠣꠡꠤ, ꠀꠝꠥꠞꠤ, ꠇꠦꠘꠣꠘꠤ, ꠚꠣꠞꠤꠎꠤ, ꠢꠤꠛ꠆ꠛꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠎꠣꠔꠤꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠛꠣ, ꠁ ꠡꠣꠔꠅ ꠎꠣꠔꠤꠃ ꠙꠞꠤꠝꠣꠘꠦ ꠔꠥꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠠ ꠀꠞ ꠛꠟꠀꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_2","006_7_2","DEU","7","2","2","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠤꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠅ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠇꠥꠘꠥ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠖꠦꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_3","006_7_3","DEU","7","3","3","ꠁꠔꠣꠞ ꠟꠉꠦ ꠛꠤꠀ-ꠡꠣꠖꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘꠥ ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠔꠣꠞꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠖꠤꠅ ꠘꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠥꠠꠤꠘꠞꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀꠂꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠀꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_4","006_7_4","DEU","7","4","4","ꠇꠣꠞꠘ ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠣꠁꠛ। ꠔꠦꠃ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣ ꠅꠁꠀ, ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_5","006_7_5","DEU","7","5","5","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠙꠥꠎꠣ-ꠝꠘ꠆ꠒꠙ ꠜꠣꠋꠉꠤꠟꠤꠅ, ꠙꠥꠎꠣꠞ ꠎꠣꠉꠣ ꠅꠇꠟ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠅ, ꠀꠡꠦꠞꠣ-ꠖꠦꠛꠤꠞ ꠘꠤꠡꠣꠘꠣ ꠈꠥꠐꠤ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁꠅ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠝꠥꠞ꠆ꠔꠤꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT7_6","006_7_6","DEU","7","6","6","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠃ ꠅꠁꠟꠣꠄ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠙꠛꠤꠔ꠆ꠞ ꠙ꠆ꠞꠎꠣ। ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠁꠘꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠎꠞ ꠙ꠆ꠞꠎꠣ ꠀꠞ ꠈꠣꠍ ꠡꠝ꠆ꠙꠖ ꠢꠤꠡꠣꠛꠦ ꠀꠟꠉ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT7_7","006_7_7","DEU","7","7","7","“ꠇꠦꠘꠦ ꠀꠟꠉ ꠇꠞꠍꠂꠘ? ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠥꠡ ꠛꠦꠡꠤ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠘꠤ? ꠘꠣ, ꠝꠥꠐꠦꠃ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠔ ꠢꠇꠟ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠇꠝ ꠀꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT7_8","006_7_8","DEU","7","8","8","ꠔꠣ-ꠅ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠥꠛ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠦ ꠇꠍꠝ ꠇꠞꠍꠟꠣ, ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟꠉ ꠇꠞꠍꠂꠘ। ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠟꠣꠉꠣꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ, ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠞ ꠉꠥꠟꠣꠝꠤꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT7_9","006_7_9","DEU","7","9","9","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠃ ꠅꠁꠟꠣ ꠀꠍꠟ ꠝꠣꠛꠥꠖ। ꠔꠣꠁꠘꠃ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠢꠇ-ꠢꠣꠟꠣꠟ। ꠎꠦꠞꠣ ꠀꠡꠤꠇ ꠅꠁꠀ ꠔꠣꠘꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ ꠀꠞ ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠦ, ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠍꠤꠠꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠤꠎꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠎꠛꠣꠘ ꠀꠞ ꠖꠄꠀ ꠛꠅꠀꠁꠟ ꠞꠣꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT7_10","006_7_10","DEU","7","10","10","ꠅꠁꠟꠦ ꠎꠦꠔꠣꠄ ꠛꠖ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠔꠣꠘ ꠛꠣꠄ ꠙꠤꠍ ꠖꠤꠟꠣꠄ, ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠀ ꠎꠟꠖꠤ ꠇꠞꠤ ꠛꠖꠟꠣ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("DT7_11","006_7_11","DEU","7","11","11","ꠄꠞꠟꠣꠉꠤ ꠀꠁꠎ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ, ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠞ ꠡꠞꠤꠅꠔ ꠖꠤꠞꠣꠝ, ꠁꠔꠣ ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠀꠝꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT7_12","006_7_12","DEU","7","12","12","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠞ ꠇꠕꠣ ꠇꠣꠘ ꠙꠣꠔꠤꠀ ꠢꠥꠘꠅ, ꠀꠞ ꠁꠔꠣ ꠈꠤꠀꠟ ꠇꠞꠤ ꠀꠝꠟ ꠇꠞꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠞ ꠟꠉꠦ, ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠍꠟꠣ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠅꠀꠁꠟ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_13","006_7_13","DEU","7","13","13","ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠛꠣ, ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠡꠞ ꠙꠞꠤꠝꠣꠘ ꠛꠣꠠꠣꠁꠛꠣ। ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠈꠣꠁꠍꠟꠣ, ꠅꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ꠔꠥꠝꠞꠣꠞꠦ ꠀꠅꠟꠣꠖ ꠛꠣꠠꠣꠁ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠉꠣꠘꠞ ꠚꠟ-ꠝꠥꠟ, ꠈꠦꠔꠞ ꠚꠡꠟ, ꠀꠋꠉꠥꠞꠞ ꠞꠡ, ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ, ꠉꠞꠥ-ꠛꠣꠍꠥꠞ, ꠝꠦꠠꠣ-ꠍꠣꠉꠟ ꠢꠇꠟꠔꠣꠞꠦ ꠛꠣꠠꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_14","006_7_14","DEU","7","14","14","ꠢꠇꠟ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠛꠦꠡꠤ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠇꠦꠃ ꠀꠐꠈꠥꠞꠣ ꠞꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT7_15","006_7_15","DEU","7","15","15","ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠛꠣ। ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠇꠑꠤꠘ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠖꠦꠈꠍ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠔꠣ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_16","006_7_16","DEU","7","16","16","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠔ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠛꠣ, ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠡꠦꠡ ꠇꠞꠤꠟꠣꠁꠅ, ꠇꠥꠘꠥ ꠖꠄꠀ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞ ꠖꠦꠛꠔꠣꠞꠦ ꠙꠥꠎꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞꠘꠣꠄ ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠙꠕꠞ ꠇꠣꠐꠣ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_17","006_7_17","DEU","7","17","17","“ꠔꠥꠝꠞꠣ ꠢꠄꠔ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠛꠣꠄ, ꠀꠝꠞꠣ ꠇꠤꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠝꠥ? ꠁꠔꠣ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ ꠔ ꠙꠞꠤꠝꠣꠘꠦ ꠀꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠣꠇ꠆ꠇꠣ ꠛꠦꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("DT7_18","006_7_18","DEU","7","18","18","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠇꠤꠔꠣ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠚꠣꠃꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_19","006_7_19","DEU","7","19","19","ꠝꠣꠛꠥꠖꠦ ꠇꠔ ꠛꠠ ꠛꠠ ꠉꠎꠛ-ꠝꠍꠤꠛꠔ ꠓꠣꠟꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠔ ꠘꠤꠎꠞ ꠌꠃꠈꠦꠅ ꠖꠦꠈꠍ। ꠔꠣꠘ ꠛꠃꠔ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ, ꠛꠃꠔ ꠟꠣꠈꠣꠘ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠍ, ꠔꠣꠘ ꠛꠟꠀꠟꠣ ꠝꠎꠛꠥꠔ ꠀꠔ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠅ। ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠎꠦꠔꠣ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠤꠀ ꠒꠞꠣꠁꠞꠣꠄ, ꠁꠔꠣꠞ ꠃꠙꠞꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠑꠤꠇ ꠅꠃꠟꠣ ꠊꠐꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_20","006_7_20","DEU","7","20","20","ꠄꠞꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠟꠥꠇꠣꠁꠀ ꠎꠦꠉꠥꠁꠘ ꠎꠤꠔꠣ ꠞꠁꠎꠤꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠜꠤꠋꠉꠥꠟꠞ ꠙꠣꠟ ꠙꠣꠑꠣꠁꠀ ꠁꠔꠣ ꠢꠇꠟꠐꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_21","006_7_21","DEU","7","21","21","ꠔꠦ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠎꠣꠘ ꠔ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠄꠁꠘ ꠛꠠ ꠜꠄꠅꠋꠇꠞ ꠀꠞ ꠝꠢꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("DT7_22","006_7_22","DEU","7","22","22","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠅꠔꠣ ꠎꠣꠔꠤꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠛꠣ। ꠅꠁꠟꠦ ꠢꠇꠟꠐꠤꠞꠦ ꠔ ꠔꠥꠝꠞꠣ ꠄꠇꠟꠉꠦ ꠈꠦꠖꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ, ꠈꠦꠖꠣꠁꠟꠦ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠜꠞꠤꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_23","006_7_23","DEU","7","23","23","ꠔꠣ-ꠅ ꠔꠣꠞꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠅꠡꠣꠘ꠆ꠔꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT7_24","006_7_24","DEU","7","24","24","ꠔꠣꠞꠣꠞ ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣ ꠅꠇꠟꠞꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠁꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ, ꠁꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠦꠃ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠘꠤꠞ ꠔꠣꠇ꠆ꠇꠔ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT7_25","006_7_25","DEU","7","25","25","“ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤ ꠅꠇꠟꠞꠦ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠟꠣꠁꠟꠤꠅ। ꠔꠣꠞꠣꠞ ꠉꠔꠞꠞ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠞ ꠛꠣꠄ ꠟꠣꠟꠌ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞꠘꠣꠄ ꠚꠣꠘ꠆ꠖꠅ ꠙꠠꠛꠣꠄ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("DT7_26","006_7_26","DEU","7","26","26","ꠊꠤꠘ꠆ꠘꠣꠞ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠔꠥꠝꠞꠣꠞ ꠊꠞꠅ ꠢꠣꠞꠣꠁꠟꠦ ꠔꠥꠝꠞꠣꠅ ꠅꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠤꠎꠤꠛꠣꠄ। ꠛꠞꠋ ꠔꠥꠝꠞꠣꠅ ꠁꠔꠣꠞꠦ ꠈꠥꠛ ꠊꠤꠘ꠆ꠘꠣꠁꠅ ꠀꠞ ꠔꠥꠌ꠆ꠍ ꠇꠞꠤꠅ, ꠁꠔꠣ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("DT8_1","006_8_1","DEU","8","1","1","“ꠅꠈꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠤꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠛꠣꠌꠤꠀ ꠞꠁꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠣꠠꠤꠛ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠁꠀ ꠖꠈꠟ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT8_2","006_8_2","DEU","8","2","2","ꠀꠞ ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠤꠟꠣ ꠟꠁꠀ ꠀꠁꠍꠟꠣ, ꠔꠥꠝꠞꠣꠞ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠜꠣꠋꠉꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠛꠣꠄ ꠇꠤ ꠘꠣ ꠅꠈꠣꠘ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠈꠛꠞ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT8_3","006_8_3","DEU","8","3","3","ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠘꠣ ꠖꠤꠀ ꠃꠙꠣꠡ ꠞꠣꠈꠟꠣ, ꠛꠣꠖꠦ ꠎꠦ ꠈꠣꠘꠤ ꠔꠣꠞꠣ ꠌꠤꠘꠔꠣ ꠘꠣ, ꠝꠣꠘ꠆ꠘꠣ ꠘꠣꠝꠞ ꠅꠃ ꠈꠣꠘꠤ ꠈꠣꠅꠀꠁꠀ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠜꠣꠋꠉꠤꠍꠂꠘ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠤꠇꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ, ꠈꠣꠟꠤ ꠞꠥꠐꠤ ꠈꠣꠁꠟꠦꠃ ꠝꠣꠘꠥꠡ ꠛꠣꠌꠦ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠙꠞꠔꠦꠇ ꠇꠣꠟꠣꠝꠦꠃ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠦ। ");
INSERT INTO syls_vpl VALUES ("DT8_4","006_8_4","DEU","8","4","4","ꠅꠃ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠔꠞꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠘꠡ꠆ꠐ ꠅꠁꠍꠦ ꠘꠣ, ꠖꠤꠘ-ꠞꠣꠁꠔ ꠀꠐꠤꠟꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅ ꠚꠥꠟꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT8_5","006_8_5","DEU","8","5","5","ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠤꠅ, ꠛꠣꠚꠦ ꠎꠦꠟꠣ ꠘꠤꠎꠞ ꠙꠥꠀꠞꠦ ꠡꠣꠡꠘ ꠇꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠅꠟꠣ ꠡꠣꠡꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT8_6","006_8_6","DEU","8","6","6","“ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠤꠅ, ꠔꠣꠘ ꠙꠕꠦ ꠌꠟꠤꠅ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠒꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT8_7","006_8_7","DEU","8","7","7","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠀꠞꠣꠝꠞ ꠖꠦꠡꠅ ꠘꠤꠞꠣ, ꠁ ꠎꠣꠉꠣꠔ ꠙꠣꠠ-ꠙꠞꠛꠔ, ꠙꠣꠠꠤꠀ ꠈꠣꠟ, ꠙꠣꠘꠤꠞ ꠁꠘ꠆ꠖꠣꠞꠣ ꠀꠍꠦ, ꠀꠞ ꠝꠣꠐꠤꠞ ꠔꠟꠦꠅ ꠙꠣꠘꠤ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT8_8","006_8_8","DEU","8","8","8","ꠢꠤꠘꠅ ꠉꠝ, ꠛꠣꠞ꠆ꠟꠤ, ꠀꠋꠉꠥꠞ, ꠒꠥꠝꠥꠞ ꠉꠣꠍ, ꠀꠘꠥꠀꠞ ꠚꠟ, ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ ꠀꠞ ꠝꠃ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT8_9","006_8_9","DEU","8","9","9","ꠢꠤ ꠖꠦꠡꠅ ꠛꠃꠔ ꠈꠣꠘꠤ-ꠙꠣꠘꠤ ꠙꠣꠁꠛꠣꠄ, ꠇꠥꠘ꠆ꠔꠣꠞ ꠅꠜꠣꠛ ꠔꠥꠝꠞꠣꠞ ꠅꠁꠔ ꠘꠣꠄ। ꠢꠤꠘꠞ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠟꠥꠀ ꠀꠍꠦ, ꠢꠘꠞ ꠙꠣꠠ ꠈꠥꠖꠤꠟꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠝꠣ-ꠙꠤꠔꠟ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT8_10","006_8_10","DEU","8","10","10","ꠢꠃ ꠖꠦꠡꠅ ꠙꠦꠐ ꠜꠞꠤꠀ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠅꠃ ꠀꠞꠣꠝꠞ ꠖꠦꠡꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT8_11","006_8_11","DEU","8","11","11","“ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠇꠥꠘꠥ ꠡꠝꠄ ꠚꠣꠃꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠀꠝꠤ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ, ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ, ꠀꠞ ꠡꠞꠤꠅꠔ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠔꠦ ꠇꠥꠘꠥ ꠉꠣꠚꠟꠔꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT8_12","006_8_12","DEU","8","12","12","ꠢꠘꠅ ꠉꠤꠀ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁꠀ, ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠊꠞ-ꠛꠣꠠꠤ ꠛꠣꠘꠣꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("DT8_13","006_8_13","DEU","8","13","13","ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠣꠟ ꠛꠣꠠꠤꠟꠦ, ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠎꠝꠣꠁꠀ, ꠢꠇꠟ ꠝꠘ꠆ꠔꠦ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠛꠣꠠꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT8_14","006_8_14","DEU","8","14","14","ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠔꠦ ꠖꠤꠅ ꠘꠣ। ꠀꠞ ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠚꠣꠃꠞꠤꠅ ꠘꠣ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ, ꠢꠃ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT8_15","006_8_15","DEU","8","15","15","ꠔꠣꠁꠘ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠛꠤꠙꠖ-ꠀꠙꠖꠦ ꠜꠞꠣ ꠛꠤꠞꠣꠐ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ, ꠇꠑꠤꠘ ꠛꠤꠡꠣꠇ꠆ꠔ ꠢꠣꠚ, ꠛꠤꠡꠣꠇ꠆ꠔ ꠇꠣꠇꠠꠣ-ꠛꠤꠍꠣꠄ ꠜꠞꠣ ꠙꠕꠦꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। ꠡꠇ꠆ꠔ ꠙꠣꠔ꠆ꠔꠞꠞ ꠜꠤꠔꠞ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠘꠤ ꠛꠣꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT8_16","006_8_16","DEU","8","16","16","ꠔꠣꠁꠘ ꠢꠃ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠘ꠆ꠘꠣ ꠈꠣꠛꠣꠁꠍꠂꠘ, ꠎꠦꠔꠣꠞ ꠘꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠢꠥꠘꠍꠂꠘꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠜꠤꠔꠞꠞ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠜꠣꠋꠉꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦꠃ ꠁꠔꠣ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠢꠦꠡꠦ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("DT8_17","006_8_17","DEU","8","17","17","ꠔꠥꠝꠞꠣ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠅ ꠘꠣ, ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤꠄ ꠘꠤꠎꠞ ꠇꠣꠝꠣꠁ ꠖꠤꠀ ꠗꠘꠤ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT8_18","006_8_18","DEU","8","18","18","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦꠔꠣ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠍꠟꠣ, ꠅꠔꠣ ꠅꠈꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠁ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠖꠤꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT8_19","006_8_19","DEU","8","19","19","“ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠚꠣꠃꠞꠤꠟꠣꠅ, ꠀꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠅ, ꠅꠔꠣꠞ ꠈꠦꠎꠝꠔ ꠛꠣ ꠜꠎꠘꠣ ꠇꠞꠅ, ꠔꠦ ꠀꠝꠤ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞꠤ ꠖꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT8_20","006_8_20","DEU","8","20","20","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠘꠣ ꠝꠣꠘꠟꠦ, ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠢꠃ ꠎꠦꠔꠣ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠔꠣꠁꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣꠞꠦꠅ ꠅꠟꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("DT9_1","006_9_1","DEU","9","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠟꠀꠟꠣ ꠀꠞ ꠙꠞꠤꠝꠣꠘꠦꠅ ꠛꠃꠔ ꠛꠦꠡꠤ, ꠛꠠ ꠛꠠ ꠎꠣꠔꠤꠞ ꠖꠦꠡꠞꠦ ꠖꠈꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠈꠘ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠛꠣꠄ, ꠔꠣꠞꠣꠞ ꠐꠣꠃꠘ ꠅꠇꠟꠅ ꠛꠠ ꠛꠠ, ꠅꠃ ꠐꠣꠃꠘꠞ ꠛꠣꠃꠘ꠆ꠒꠞꠤꠞ ꠅꠀꠟ ꠀꠍꠝꠣꠘꠅ ꠍꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT9_2","006_9_2","DEU","9","2","2","ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠃꠌꠣ-ꠝꠥꠐꠣ ꠙꠄꠟꠥꠀꠘ, ꠄꠞꠣ ꠢꠇꠟꠃ ꠀꠘꠣꠇꠤ ꠛꠋꠡꠞ ꠝꠣꠘꠥꠡ। ꠔꠥꠝꠞꠣ ꠔ ꠀꠉꠦꠃ ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠘꠍ, ꠀꠘꠣꠇꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠇꠣꠞ ꠀꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("DT9_3","006_9_3","DEU","9","3","3","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠅꠈꠣꠘ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠎꠣꠁꠞꠣ, ꠔꠣꠁꠘ ꠎꠣꠟꠣꠁꠀ ꠍꠣꠞꠈꠣꠞ ꠇꠞꠞꠣ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ। ꠔꠣꠁꠘꠃ ꠁꠔꠣꠞꠦ ꠖꠝꠣꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠔꠟꠥꠀ ꠛꠣꠘꠣꠁꠛꠣ। ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠇꠁꠍꠟꠣ, ꠔꠥꠝꠞꠣ ꠅꠟꠣꠃ ꠔꠣꠞꠣꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠀ ꠎꠟꠖꠤ ꠇꠞꠤ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT9_4","006_9_4","DEU","9","4","4","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠛꠣ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠅ ꠘꠣ, ꠀꠝꠞꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠚꠟ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞꠦ ꠅꠃ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠘꠍꠂꠘ। ꠀꠍꠟꠦ ꠢꠃ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT9_5","006_9_5","DEU","9","5","5","ꠔꠥꠝꠞꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠛꠣ ꠡꠔꠔꠣꠞ ꠟꠣꠉꠤ ꠔ ꠢꠤ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠞꠣꠄ ꠘꠣ, ꠛꠞꠋ ꠢꠃ ꠎꠣꠔꠤꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠎꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠅꠈꠣꠘ ꠙꠥꠞꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠁꠔꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT9_6","006_9_6","DEU","9","6","6","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠤꠀ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠖꠦꠈꠤꠀ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠀꠞꠣꠝꠞ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠞꠣ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠉꠣꠠꠔꠦꠠꠣ-ꠄꠇꠉꠥꠁꠀ ꠎꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("DT9_7","006_9_7","DEU","9","7","7","“ꠀꠞ ꠢꠃ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠉꠥꠍꠣ ꠔꠥꠟꠣꠁꠍꠟꠣꠄ, ꠁꠈꠣꠘ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠇꠥꠘꠥꠖꠤꠘ ꠚꠣꠃꠞꠤꠅ ꠘꠣ। ꠝꠤꠡꠞ ꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠀꠅꠀꠞ ꠖꠤꠘ ꠕꠣꠇꠤ ꠅꠈꠣꠘꠅ ꠀꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠜꠤꠔꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT9_8","006_9_8","DEU","9","8","8","ꠔꠥꠞ ꠙꠣꠠꠞ ꠝꠣꠎꠦꠅ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠍꠣ ꠔꠥꠟꠣꠁꠍꠟꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT9_9","006_9_9","DEU","9","9","9","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠦ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠌꠥꠇ꠆ꠔꠤ ꠘꠣꠝꠣ ꠟꠦꠈꠣ ꠖꠥꠁꠅ ꠈꠣꠘ ꠙꠣꠔ꠆ꠔꠞ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠙꠣꠠꠅ ꠃꠑꠤꠍꠟꠣꠝ, ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ ꠇꠥꠘꠥ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ ꠘꠣ ꠈꠣꠁꠀ ꠀꠝꠤ ꠞꠥꠎꠣ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT9_10","006_9_10","DEU","9","10","10","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠀꠔꠞ ꠀꠋꠉꠥꠁꠟꠖꠤ ꠟꠦꠈꠣ ꠢꠃ ꠖꠥꠁꠅ ꠈꠣꠘ ꠙꠣꠔ꠆ꠔꠞ ꠀꠝꠣꠞꠦ ꠖꠤꠟꠣ। ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠎꠦꠖꠤꠘ ꠔꠥꠞ ꠙꠣꠠꠅ ꠀꠁꠀ ꠖꠟꠣ ꠅꠁꠟꠣꠄ, ꠅꠃ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠦ ꠎꠣꠟꠣꠁꠟ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠍꠟꠣ, ꠅꠃ ꠖꠥꠁꠅ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠔ ꠅꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT9_11","006_9_11","DEU","9","11","11","“ꠢꠃ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠀꠞ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔꠞ ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠅꠃ ꠌꠥꠇ꠆ꠔꠤ ꠘꠣꠝꠣ ꠟꠦꠈꠣ ꠙꠣꠔ꠆ꠔꠞ ꠖꠥꠁꠅ ꠈꠣꠘ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT9_12","006_9_12","DEU","9","12","12","ꠖꠤꠀ ꠇꠁꠟꠣ, ꠎꠣꠅ, ꠔꠥꠝꠤ ꠎꠟꠖꠤ ꠇꠞꠤ ꠟꠣꠝꠣꠔ ꠎꠣꠅ, ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍ, ꠁꠔꠣ ꠇꠥ-ꠙꠕꠦ ꠉꠦꠍꠂꠘꠉꠤ। ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠙꠕ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠅꠔ ꠎꠟꠖꠤ ꠛꠦ-ꠙꠕꠤ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠞꠣ ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠥꠘꠣ ꠉꠟꠣꠁꠀ ꠄꠇ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT9_13","006_9_13","DEU","9","13","13","ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, ꠀꠝꠤ ꠔ ꠁꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠖꠦꠈꠟꠣꠝ, ꠁꠔꠣ ꠛꠠ ꠉꠣꠠꠔꠦꠠꠣ-ꠄꠇꠉꠥꠁꠀ ꠎꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("DT9_14","006_9_14","DEU","9","14","14","ꠅꠈꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤ ꠎꠣꠅ, ꠇꠥꠘꠥ ꠛꠣꠗꠣ ꠖꠤꠅ ꠘꠣ, ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠝꠥ, ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠁꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠝꠥ। ꠀꠞ ꠔꠥꠝꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠇ ꠘꠄꠀ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠝꠥ, ꠁꠔꠣ ꠀꠞꠅ ꠛꠠ ꠀꠞꠅ ꠛꠟꠀꠟꠣ ꠎꠣꠔꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT9_15","006_9_15","DEU","9","15","15","“ꠔꠦꠃ ꠀꠝꠤ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣꠝ, ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠀꠉꠥꠁꠘ ꠎꠟꠦꠞ, ꠀꠞ ꠀꠝꠣꠞ ꠀꠔꠅ ꠀꠍꠤꠟ ꠌꠥꠇ꠆ꠔꠤ ꠘꠣꠝꠣ ꠟꠦꠈꠣ ꠢꠃ ꠖꠥꠁꠅ ꠈꠣꠘ ꠙꠣꠔ꠆ꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("DT9_16","006_9_16","DEU","9","16","16","ꠛꠣꠖꠦ ꠀꠝꠤ ꠌꠣꠁꠟꠣꠝ, ꠌꠣꠁꠀ ꠖꠦꠈꠤ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠉꠥꠘꠣ ꠇꠞꠞꠣꠄ। ꠔꠥꠝꠞꠣ ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠥꠘꠣ ꠉꠟꠣꠁꠀ ꠚꠞ꠆ꠝꠣꠔ ꠓꠣꠟꠤꠀ ꠄꠇ ꠉꠞꠥꠞ ꠛꠣꠍꠥꠞ ꠛꠣꠘꠣꠁꠟꠣꠄ। ꠝꠣꠛꠥꠖꠞ ꠛꠣꠔꠣꠁꠟ ꠙꠕ ꠍꠣꠠꠤꠀ ꠔꠥꠝꠞꠣ ꠅꠔ ꠎꠟꠖꠤ ꠛꠦ-ꠙꠕꠦ ꠉꠦꠟꠣꠄꠉꠤ! ");
INSERT INTO syls_vpl VALUES ("DT9_17","006_9_17","DEU","9","17","17","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠃ ꠖꠥꠁꠅ ꠈꠣꠘ ꠙꠣꠔ꠆ꠔꠞ ꠀꠝꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣꠝ, ꠔꠦꠃ ꠁꠔꠣ ꠜꠣꠋꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("DT9_18","006_9_18","DEU","9","18","18","“ꠝꠣꠛꠥꠖꠦ ꠎꠦꠔꠣꠞꠦ ꠘꠣꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ, ꠅꠟꠣꠈꠣꠘ ꠉꠥꠘꠣ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠉꠥꠍꠣ ꠔꠥꠟꠣꠁꠟꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠢꠤꠞꠛꠣꠞ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ ꠇꠥꠘꠥ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ ꠘꠣ ꠈꠣꠁꠀ, ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤ ꠞꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT9_19","006_9_19","DEU","9","19","19","ꠝꠣꠛꠥꠖꠞ ꠛꠦꠎꠥꠁꠔꠣ ꠉꠥꠍꠣꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠒꠞꠣꠁꠟꠣꠝ, ꠔꠣꠁꠘ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠅꠃꠛꠣꠞꠅ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT9_20","006_9_20","DEU","9","20","20","ꠝꠣꠛꠥꠖꠦ ꠢꠣꠞꠥꠘꠞ ꠃꠙꠞꠦꠅ ꠈꠥꠛ ꠉꠥꠍꠣ ꠅꠁꠀ ꠔꠣꠘꠞꠦ ꠡꠦꠡ ꠇꠞꠤꠟꠔꠣ ꠌꠣꠁꠟꠣ, ꠔꠦꠃ ꠀꠝꠤ ꠢꠣꠞꠥꠘꠞ ꠟꠣꠉꠤꠅ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠝꠤꠘꠔꠤ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT9_21","006_9_21","DEU","9","21","21","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠀꠔꠤꠀꠞ ꠝꠣꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠢꠃ ꠛꠣꠍꠥꠞꠞ ꠝꠥꠞ꠆ꠔꠤꠞꠦ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠟꠣꠁꠀ ꠍꠣꠞꠈꠣꠞ ꠇꠞꠟꠣꠝ। ꠅꠉꠥꠞ ꠎꠣꠟꠣꠁꠟ ꠐꠥꠇꠞꠣꠞꠦ ꠙꠤꠡꠤꠀ ꠍꠣꠟꠤ ꠛꠣꠘꠣꠁꠀ ꠙꠣꠠꠤꠀ ꠉꠣꠋꠉꠞ ꠙꠣꠘꠤꠞ ꠚꠥꠔꠞ ꠝꠣꠎꠦ ꠚꠣꠟꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT9_22","006_9_22","DEU","9","22","22","“ꠔꠥꠝꠞꠣ ꠔ ꠔꠣꠛꠦꠞꠣꠔ, ꠝꠣꠍꠣꠔ ꠀꠞ ꠇꠤꠛꠞꠥꠔ-ꠢꠥꠔꠣꠛꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠍꠣ ꠔꠥꠟꠣꠁꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT9_23","006_9_23","DEU","9","23","23","ꠄꠞꠛꠣꠖꠦ ꠇꠣꠖꠦꠡ-ꠛꠞꠘꠦꠀ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠀꠞ ꠇꠣꠟꠅ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠇꠁꠟꠣ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞꠣꠝꠞ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠍꠤ, ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠅꠈꠣꠘ ꠖꠈꠟ ꠇꠞꠅ, ꠢꠃ ꠡꠝꠄꠅ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠟꠣꠄ, ꠔꠣꠘꠞꠦ ꠝꠣꠘꠟꠣꠄ ꠘꠣ, ꠔꠣꠘ ꠇꠕꠣꠞꠦꠅ ꠄꠇꠤꠘ ꠇꠞꠟꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT9_24","006_9_24","DEU","9","24","24","ꠀꠍꠟꠦ ꠀꠝꠤ ꠎꠦꠖꠤꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠌꠤꠘꠤ, ꠢꠃ ꠖꠤꠘ ꠕꠣꠇꠤꠃ ꠖꠦꠈꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠌꠟꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT9_25","006_9_25","DEU","9","25","25","“ꠎꠣꠁ ꠅꠃꠇ, ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠇꠕꠣ ꠇꠅꠀꠄ ꠀꠝꠤ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ, ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤ ꠞꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT9_26","006_9_26","DEU","9","26","26","ꠀꠝꠤ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣꠝ, ꠅ ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣ, ꠔꠥꠝꠤ ꠄꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠅ ꠘꠣ, ꠄꠞꠣ ꠔ ꠔꠥꠝꠣꠞꠃ ꠛꠘ꠆ꠖꠣ, ꠔꠥꠝꠣꠞꠃ ꠈꠣꠍ ꠡꠝ꠆ꠙꠖ। ꠔꠥꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠖꠤꠀ, ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠟꠀꠟꠣ ꠀꠔꠖꠤ ꠎꠦꠔꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍ, ꠁꠔꠣꠞꠦ ꠝꠣꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT9_27","006_9_27","DEU","9","27","27","ꠁꠔꠣꠞ ꠉꠣꠠꠔꠦꠠꠣꠝꠤ, ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠉꠥꠘꠣꠞ ꠛꠣꠄ ꠘꠣ ꠌꠣꠁꠀ, ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠇꠕꠣ ꠝꠘꠅ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("DT9_28","006_9_28","DEU","9","28","28","ꠅꠈꠘ ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠁꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠣꠅ, ꠔꠦ ꠔꠥꠝꠤ ꠎꠦ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍ, ꠢꠃ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠦ ꠇꠁꠛ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠅꠀꠖꠣ ꠇꠞꠣ ꠖꠦꠡꠅ ꠁꠔꠣꠞꠦ ꠘꠤꠔꠣ ꠙꠣꠞꠍꠂꠘ ꠘꠣ, ꠛꠣ ꠔꠣꠞꠣꠞꠦ ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠘꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT9_29","006_9_29","DEU","9","29","29","ꠀꠍꠟꠦ ꠄꠞꠣ ꠔ ꠔꠥꠝꠣꠞꠃ ꠛꠘ꠆ꠖꠣ, ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠡꠝ꠆ꠙꠖ। ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠟꠣꠉꠣꠁꠀ, ꠔꠥꠝꠣꠞ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔ ꠈꠣꠐꠣꠁꠀ ꠄꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍ।” ");
INSERT INTO syls_vpl VALUES ("DT10_1","006_10_1","DEU","10","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠞꠣ, “ꠢꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, ꠔꠥꠝꠤ ꠙꠣꠔ꠆ꠔꠞ ꠇꠣꠐꠤꠀ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠖꠥꠈꠣꠘ ꠐꠥꠇꠞꠣ ꠛꠣꠘꠣꠅ, ꠀꠞ ꠅꠈꠘꠣꠁꠘ ꠟꠁꠀ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠀ ꠀꠝꠣꠞ ꠗꠣꠞꠅ ꠀꠅ। ꠄꠞꠟꠉꠦ ꠟꠣꠇꠠꠤꠖꠤ ꠄꠇꠐꠣ ꠡꠘ꠆ꠖꠥꠇꠅ ꠛꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT10_2","006_10_2","DEU","10","2","2","ꠔꠥꠝꠤ ꠀꠉꠦ ꠎꠦ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠙꠣꠔ꠆ꠔꠞ ꠜꠣꠋꠉꠤꠟꠤꠍ, ꠢꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠎꠦꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, ꠅꠔꠣ ꠀꠝꠤ ꠅꠃ ꠖꠥꠁꠅ ꠙꠣꠔ꠆ꠔꠞ ꠐꠥꠇꠞꠣꠞ ꠃꠙꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠟꠦꠈꠤꠀ ꠖꠤꠝꠥ, ꠛꠣꠖꠦ ꠔꠥꠝꠤ ꠅꠈꠘꠣꠁꠘ ꠘꠤꠀ ꠢꠃ ꠡꠘ꠆ꠖꠥꠇꠞ ꠜꠤꠔꠞꠦ ꠕꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT10_3","006_10_3","DEU","10","3","3","“ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠀꠝꠤ ꠛꠣꠛꠟꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠄꠇ ꠡꠘ꠆ꠖꠥꠇ ꠛꠣꠘꠣꠁꠟꠣꠝ, ꠀꠞ ꠖꠥꠉꠥ ꠙꠣꠔ꠆ꠔꠞ ꠇꠣꠐꠤꠀ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠇꠞꠟꠣꠝ, ꠛꠣꠖꠦ ꠅꠃ ꠖꠥꠁꠅ ꠐꠥꠇꠞꠣ ꠀꠔꠅ ꠟꠁꠀ ꠀꠝꠤ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT10_4","006_10_4","DEU","10","4","4","ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠙꠄꠟꠣ ꠖꠥꠁꠅ ꠙꠣꠔ꠆ꠔꠞ ꠐꠥꠇꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠔꠣ ꠟꠦꠈꠤꠍꠟꠣ, ꠅꠔꠣ ꠢꠤꠞꠛꠣꠞ ꠅꠃ ꠖꠥꠁꠅ ꠐꠥꠇꠞꠣꠞ ꠃꠙꠞꠦ ꠟꠦꠈꠤꠀ ꠀꠝꠣꠞꠦ ꠖꠤꠟꠣ, ꠅꠃ ꠟꠦꠈꠣ ꠀꠄꠀꠔ ꠅꠁꠟ, ꠡꠞꠤꠅꠔꠞ ꠈꠣꠍ ꠖꠡ ꠢꠥꠇꠥꠝ। ꠀꠉꠦ ꠎꠦꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠔꠥꠞ ꠙꠣꠠꠅ ꠀꠁꠍꠟꠣꠄ, ꠢꠃ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠦ ꠎꠣꠟꠣꠁꠟ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠛꠣꠔꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT10_5","006_10_5","DEU","10","5","5","ꠛꠣꠖꠦ ꠀꠝꠤ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠣꠔ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠀꠝꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠢꠃ ꠡꠘ꠆ꠖꠥꠇꠞ ꠜꠤꠔꠞꠦ ꠖꠥꠁꠅ ꠈꠣꠘ ꠙꠣꠔ꠆ꠔꠞ ꠕꠁꠟꠣꠝ, ꠎꠦꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ। ꠁꠔꠣ ꠅꠈꠘꠅ ꠢꠘꠅ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("DT10_6","006_10_6","DEU","10","6","6","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠛꠤꠞꠥꠔ-ꠛꠘꠤ-ꠁꠀꠇꠣꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠝꠥꠍꠦꠞꠣꠔ ꠉꠦꠟꠣꠉꠤ। ꠅꠃ ꠎꠣꠉꠣꠔ ꠢꠣꠞꠥꠘ ꠘꠛꠤꠞ ꠃꠚꠣꠔ ꠅꠀꠄ, ꠔꠣꠘꠞꠦ ꠅꠘꠅ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠟ। ꠛꠣꠖꠦ ꠔꠣꠘ ꠛꠖꠟꠣ ꠔꠣꠘ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT10_7","006_10_7","DEU","10","7","7","ꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠣꠚꠦꠟꠣ ꠉꠥꠖꠉꠥꠖꠣꠔ ꠉꠦꠟꠣꠉꠤ, ꠢꠘ ꠕꠣꠇꠤ ꠎꠔꠛꠣꠔꠣꠔ ꠉꠦꠟꠣ, ꠁ ꠎꠣꠉꠣꠔ ꠙꠣꠘꠤꠞ ꠚꠥꠔ ꠀꠟꠣ ꠛꠃꠔ ꠈꠣꠟ-ꠘꠣꠟꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT10_8","006_10_8","DEU","10","8","8","ꠅꠃ ꠡꠝꠄ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠣ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ ꠛꠁꠀ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠔꠣꠘ ꠘꠣꠝꠦ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠀ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ꠅꠃ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝ ꠔꠣꠞꠣ ꠅꠈꠘꠅ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("DT10_9","006_10_9","DEU","10","9","9","ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠥꠍꠞꠣ ꠈꠣꠘ꠆ꠖꠣꠘ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠎꠝꠤ-ꠎꠝꠣꠞ ꠇꠥꠘꠥ ꠛꠣꠐ ꠛꠣ ꠇꠥꠘꠥ ꠝꠤꠞꠣꠡꠖꠣꠞꠤ ꠙꠣꠁꠟꠣ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠎꠛꠣꠘ ꠝꠣꠚꠤꠇ ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠃ ꠅꠁꠟꠣ ꠔꠣꠞꠣꠞ ꠝꠤꠞꠣꠡ। ");
INSERT INTO syls_vpl VALUES ("DT10_10","006_10_10","DEU","10","10","10","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠉꠞ ꠛꠣꠞꠞ ꠟꠣꠈꠣꠘ ꠁꠛꠣꠞꠅ ꠀꠝꠤ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠀꠍꠟꠣꠝ, ꠁꠛꠣꠞꠅ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠚꠞꠤꠀꠖ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT10_11","006_10_11","DEU","10","11","11","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠤ ꠃꠑꠅ, ꠃꠑꠤꠀ ꠀꠉꠦꠖꠤ ꠀꠉꠥꠀꠘꠤꠞ ꠟꠣꠉꠤ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠎꠥꠁꠔ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠀꠉ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠦꠅ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠍꠝ ꠈꠣꠁꠀ ꠅꠀꠖꠣ ꠇꠞꠍꠤ, ꠔꠣꠞꠣ ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠁꠔꠣ ꠖꠈꠟ ꠇꠞꠃꠇ।’ ");
INSERT INTO syls_vpl VALUES ("DT10_12","006_10_12","DEU","10","12","12","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠤꠔꠣ ꠌꠣꠁꠘ। ꠔꠣꠁꠘ ꠌꠣꠁꠞꠣ, ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠔꠣꠘ ꠒꠞ-ꠈꠚ ꠜꠤꠔꠞꠦ ꠞꠣꠈꠅ, ꠔꠣꠘ ꠙꠕꠦ ꠌꠟꠅ, ꠔꠣꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ, ꠔꠥꠝꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠤꠟ-ꠝꠘ ꠖꠤꠀ ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("DT10_13","006_10_13","DEU","10","13","13","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠦꠅꠀ ꠎꠦ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠡꠞꠤꠅꠔ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠁꠔꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠝꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("DT10_14","006_10_14","DEU","10","14","14","“ꠎꠣꠘ ꠔ, ꠀꠍꠝꠣꠘ ꠀꠞ ꠀꠍꠝꠣꠘꠤ ꠢꠇ꠆ꠇꠟꠔꠣ, ꠎꠝꠤꠘ ꠀꠞ ꠎꠝꠤꠘꠞ ꠔꠣꠝꠣꠝ ꠍꠣꠝꠣꠘꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("DT10_15","006_10_15","DEU","10","15","15","ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠛꠣꠄ ꠔꠣꠘ ꠐꠣꠘ ꠕꠣꠇꠣꠄ, ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠔꠣ। ꠔꠣꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠝꠣꠘꠤ, ꠅꠈꠘꠇꠥꠞ ꠎꠝꠣꠘꠣꠞ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT10_16","006_10_16","DEU","10","16","16","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠞꠎꠤꠞ ꠖꠤꠟꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠅ, ꠉꠣꠠꠔꠦꠠꠣ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠘꠤꠀ ꠞꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT10_17","006_10_17","DEU","10","17","17","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔ ꠢꠇꠟ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠃꠙꠞꠦ, ꠝꠥꠘꠤꠛ ꠅꠇꠟꠞ ꠝꠥꠘꠤꠛ, ꠔꠣꠁꠘꠃ ꠝꠢꠣꠘ, ꠛꠟꠛꠣꠘ ꠀꠞ ꠒꠞ-ꠈꠚ ꠙꠄꠖꠣ ꠇꠞꠞꠣ ꠀꠟ꠆ꠟꠣ। ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠙꠇ꠆ꠇꠙꠣꠔꠤ ꠇꠞꠂꠘ ꠘꠣ, ꠊꠥꠡ ꠈꠣꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT10_18","006_10_18","DEU","10","18","18","ꠄꠔꠤꠝ ꠅꠇꠟ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠛꠣꠄ ꠢꠇ ꠁꠘꠍꠣꠚ ꠇꠞꠂꠘ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟꠞꠦ ꠈꠣꠅꠀ-ꠚꠤꠘ꠆ꠖꠣꠞ ꠢꠇꠟꠔꠣ ꠖꠤꠀ ꠔꠣꠘ ꠝꠢꠛ꠆ꠛꠔꠞ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("DT10_19","006_10_19","DEU","10","19","19","ꠀꠉꠦ ꠔ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠀꠍꠟꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠝꠞꠣ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT10_20","006_10_20","DEU","10","20","20","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠀ ꠌꠟꠤꠅ, ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠤꠅ, ꠔꠣꠘ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠞꠁꠅ, ꠀꠞ ꠈꠣꠟꠤ ꠔꠣꠘ ꠘꠣꠝꠦ ꠇꠍꠝ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT10_21","006_10_21","DEU","10","21","21","ꠔꠣꠁꠘꠃ ꠔꠥꠝꠞꠣꠞ ꠔꠣꠞꠤꠚꠞ ꠈꠥꠐꠤ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ। ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠎꠔ ꠀꠌꠣꠘꠇ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠀꠞ ꠛꠦꠎꠥꠁꠔꠣ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠍ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘꠃ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT10_22","006_10_22","DEU","10","22","22","ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠦꠍꠟꠣ, ꠄꠞꠣ ꠀꠍꠟꠣ ꠝꠥꠐ ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ, ꠀꠞ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠞꠍꠂꠘ, ꠎꠦꠔꠣ ꠉꠘꠤꠀ ꠚꠥꠠꠣꠁꠟ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT11_1","006_11_1","DEU","11","1","1","“ꠄꠞꠟꠣꠉꠤ, ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ, ꠀꠞ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠤꠅ, ꠔꠣꠘ ꠖꠦꠅꠀ ꠡꠞꠤꠅꠔ, ꠢꠇꠟ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ, ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT11_2","006_11_2","DEU","11","2","2","ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠁꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠘꠣ ꠇꠁꠀ ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠁꠀꠞ, ꠔꠣꠞꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠦꠖꠣꠄꠅꠔ ꠖꠦꠈꠍꠦ ꠘꠣ, ꠁꠔꠣ ꠌꠤꠘꠦꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠘ ꠀꠙꠘ ꠝꠢꠤꠝꠣ, ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠞ ꠛꠣꠢꠣꠖꠥꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("DT11_3","006_11_3","DEU","11","3","3","ꠀꠞ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠃꠙꠞꠦ, ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠔꠣꠁꠘ ꠎꠔ ꠘꠝꠥꠘꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠣꠁꠍꠂꠘ ꠁꠔꠣ ꠔ ꠔꠣꠞꠣ ꠖꠦꠈꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT11_4","006_11_4","DEU","11","4","4","ꠔꠣꠞꠣ ꠝꠤꠡꠞꠞ ꠍꠤꠙꠣꠁ ꠖꠟ, ꠁꠔꠣꠞ ꠊꠥꠠꠣ, ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠘ ꠀꠞ ꠁꠔꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠤꠟꠣ ꠘꠤꠟ ꠖꠞꠤꠀꠔ ꠛꠥꠠꠣꠁꠀ ꠝꠣꠞꠤꠀ ꠄꠇ꠆ꠇꠦꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠂꠘ, ꠁꠔꠣꠅ ꠔ ꠖꠦꠈꠍꠦ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("DT11_5","006_11_5","DEU","11","5","5","ꠅꠃ ꠎꠣꠉꠣꠔ ꠀꠁꠀ ꠔꠥꠝꠞꠣ ꠙꠃꠍꠤꠛꠣꠞ ꠀꠉꠦ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠔꠔꠣ ꠊꠐꠣꠁꠍꠂꠘ, ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠦ ꠁꠔꠣꠅ ꠖꠦꠈꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT11_6","006_11_6","DEU","11","6","6","ꠔꠣꠁꠘ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠟꠤꠀꠛꠞ ꠙꠥꠀ ꠖꠣꠕꠘ ꠀꠞ ꠀꠛꠤꠞꠣꠝꠞꠦ ꠎꠦ ꠡꠣꠎꠣ ꠖꠤꠍꠂꠘ ꠝꠣꠘꠤ, ꠖꠥꠘꠤꠀꠞ ꠝꠣꠐꠤ ꠚꠣꠐꠤꠀ ꠀ ꠇꠞꠤꠀ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠈꠣꠘ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠉꠤꠟꠤꠟꠤꠟ, ꠔꠣꠞꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠡꠥꠖ꠆ꠖꠣ ꠀꠡ꠆ꠔꠣ ꠙꠞꠤꠛꠣꠞ, ꠔꠣꠞꠣꠞ ꠊꠞ-ꠖꠥꠀꠞ, ꠀꠞ ꠢꠦꠝꠣꠘ-ꠎꠣꠘꠥꠀꠞ ꠡꠢ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠝꠣꠐꠤꠞ ꠔꠟꠦ ꠢꠣꠝꠣꠁꠉꠦꠟ, ꠁꠔꠣꠅ ꠄꠞꠣ ꠖꠦꠈꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT11_7","006_11_7","DEU","11","7","7","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠇꠟ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠍ। ");
INSERT INTO syls_vpl VALUES ("DT11_8","006_11_8","DEU","11","8","8","“ꠔꠦ ꠅꠈꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠝꠣꠘꠤꠅ, ꠔꠦꠃ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠎꠦ ꠖꠦꠡ ꠖꠈꠟꠞ ꠟꠣꠉꠤ ꠎꠣꠁꠞꠣꠄ, ꠔꠥꠝꠞꠣ ꠛꠟꠀꠟꠣ ꠛꠘꠤꠀ ꠢꠘꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT11_9","006_11_9","DEU","11","9","9","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠀꠞ ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠍꠝ ꠈꠣꠁꠍꠟꠣ, ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠢꠃ ꠀꠞꠣꠝꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠟꠣꠝ꠆ꠛꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT11_10","006_11_10","DEU","11","10","10","ꠁ ꠖꠦꠡꠈꠣꠘ ꠔ ꠢꠃ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ ꠎꠦꠈꠣꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍ, ꠝꠘꠅ ꠅꠞ ꠘꠤ, ꠢꠣꠉ-ꠔꠞꠇꠣꠞꠤꠞ ꠈꠦꠔꠅ ꠎꠦꠟꠣ ꠙꠣꠘꠤ ꠖꠦꠁꠘ, ꠢꠃ ꠖꠦꠡꠅ ꠛꠤꠌꠤ ꠛꠣꠁꠘ ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠙꠣꠅꠞ ꠘꠣꠃꠠꠣ ꠖꠤꠀ ꠅꠟꠣ ꠙꠣꠘꠤ ꠢꠤꠌꠤꠔꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("DT11_11","006_11_11","DEU","11","11","11","ꠅꠁꠟꠦ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠎꠦ ꠖꠦꠡ ꠔꠥꠝꠞꠣ ꠖꠈꠟ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄ, ꠁ ꠖꠦꠡꠅ ꠙꠣꠠꠤꠀ ꠔꠟ ꠎꠣꠉꠣ ꠀꠞ ꠙꠣꠠ-ꠙꠞꠛꠔꠦ ꠜꠞꠣ, ꠁ ꠎꠝꠤꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠝꠦꠊꠞ ꠙꠣꠘꠤ ꠈꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT11_12","006_11_12","DEU","11","12","12","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠁ ꠖꠦꠡꠞ ꠈꠤꠀꠟ ꠞꠣꠈꠂꠘ। ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠘ ꠖꠄꠀꠞ ꠘꠎꠞ ꠕꠣꠇꠦ ꠁ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("DT11_13","006_11_13","DEU","11","13","13","“ꠔꠦ ꠀꠝꠤ ꠀꠁꠎ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠝꠣꠘꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ, ꠀꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT11_14","006_11_14","DEU","11","14","14","ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠎꠞꠥꠞ ꠝꠣꠚꠤꠇ ꠛꠍꠞꠞ ꠙꠄꠟꠣ ꠀꠞ ꠡꠦꠡꠦꠅ ꠞꠢꠝꠔꠤ ꠝꠦꠊ ꠖꠤꠀ, ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠡꠟ, ꠀꠋꠉꠥꠞꠞ ꠞꠡ, ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠥꠉꠣꠘ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT11_15","006_11_15","DEU","11","15","15","ꠔꠥꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠞ ꠟꠣꠉꠤ ꠎꠝꠤꠘꠅ ꠊꠣꠡ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠔꠥꠡ꠆ꠐ ꠅꠁꠀ ꠈꠣꠘꠤ-ꠙꠣꠘꠤ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT11_16","006_11_16","DEU","11","16","16","“ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠀꠞꠘꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠘ ꠇꠥ-ꠙꠕꠦ ꠎꠣꠁꠛꠉꠤ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠛꠦ-ꠙꠕꠤ ꠛꠘꠤꠀ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠛꠣꠄ, ꠁꠔꠣꠞꠦ ꠜꠇ꠆ꠔꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT11_17","006_11_17","DEU","11","17","17","ꠁꠟꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘ ꠉꠞꠝ ꠅꠁꠛ, ꠔꠣꠁꠘ ꠀꠍꠝꠣꠘꠞ ꠞꠢꠝꠔꠤ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟꠤꠛꠣ, ꠔꠦꠃ ꠝꠦꠊ-ꠙꠣꠘꠤ ꠛꠘ꠆ꠖ ꠅꠁꠀ ꠎꠝꠤꠘꠅ ꠀꠞ ꠚꠡꠟ ꠚꠟꠤꠔ ꠘꠣꠄ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠢꠃ ꠀꠞꠣꠝꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠟꠖꠤ ꠇꠞꠤ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT11_18","006_11_18","DEU","11","18","18","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ, ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠦ ꠀꠝꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠈꠣꠘ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠖꠥꠁꠅ ꠀꠔꠅ ꠁꠔꠣ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠕꠁꠅ, ꠀꠞ ꠇꠙꠣꠟꠞ ꠝꠣꠎꠦꠅ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT11_19","006_11_19","DEU","11","19","19","ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦꠅ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠅ। ꠔꠥꠝꠞꠣ ꠊꠞꠅ ꠞꠅꠀꠞ ꠡꠝꠄ, ꠙꠕꠦ-ꠊꠣꠐꠦ ꠀꠐꠤꠛꠣꠞ ꠡꠝꠄ, ꠢꠥꠔꠤꠛꠣꠞ ꠡꠝꠄ ꠀꠞ ꠢꠥꠔꠘꠅ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠣꠝꠦꠡꠣ ꠅꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT11_20","006_11_20","DEU","11","20","20","ꠁꠔꠣ ꠟꠦꠈꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠠꠤꠞ ꠉꠦꠁꠐꠅ ꠀꠞ ꠖꠥꠀꠞꠞ ꠌꠃꠇꠣꠑꠅ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT11_21","006_11_21","DEU","11","21","21","ꠁꠔꠣ ꠝꠣꠘꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠇꠍꠝ ꠈꠣꠁꠍꠟꠣ, ꠢꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠢꠣꠄꠀꠔꠤ ꠅꠔꠖꠤꠘ ꠞꠁꠛ, ꠎꠔꠖꠤꠘ ꠁ ꠖꠥꠘꠤꠀꠞ ꠃꠙꠞꠦ ꠀꠍꠝꠣꠘ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT11_22","006_11_22","DEU","11","22","22","“ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠖꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠁꠔꠣ ꠝꠣꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ, ꠔꠣꠘ ꠛꠣꠔꠣꠁꠟ ꠙꠕꠦ ꠌꠟꠅ ꠀꠞ ꠔꠣꠘ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("DT11_23","006_11_23","DEU","11","23","23","ꠔꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠢꠃ ꠖꠦꠡꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠛꠣ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠠ ꠛꠠ ꠀꠞ ꠛꠟꠀꠟꠣ ꠎꠣꠔꠤꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠢꠘꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT11_24","006_11_24","DEU","11","24","24","ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅꠖꠤ ꠎꠦꠔꠣ ꠎꠣꠉꠣꠞ ꠃꠙꠞꠦ ꠀꠐꠤꠛꠣꠄ, ꠁꠔꠣ ꠢꠇꠟ ꠎꠣꠉꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠈꠟꠅ ꠀꠁꠛ। ꠖꠃꠇꠘꠞ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠟꠦꠛꠣꠘꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠚꠥꠞꠣꠔ ꠉꠣꠋ ꠕꠣꠇꠤ ꠙꠁꠌꠝꠞ ꠖꠞꠤꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT11_25","006_11_25","DEU","11","25","25","ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠘꠤꠞ ꠔꠣꠇ꠆ꠇꠔ ꠅꠁꠔ ꠘꠣꠄ, ꠔꠥꠝꠞꠣ ꠢꠃ ꠖꠦꠡꠞ ꠎꠦꠈꠣꠘꠅ ꠎꠣꠁꠛꠣꠄ, ꠅꠈꠣꠘꠞ ꠝꠣꠘꠡꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠒꠞꠣꠁꠛꠣ, ꠔꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠇꠣꠙꠤꠛ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇꠃ ꠇꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT11_26","006_11_26","DEU","11","26","26","“ꠢꠥꠘꠅ, ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠞꠢꠝꠔ ꠀꠞ ꠟꠣꠘ꠆ꠘꠔ ꠖꠥꠁꠅꠔꠣ ꠖꠦꠈꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT11_27","006_11_27","DEU","11","27","27","ꠀꠝꠤ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠅ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠅꠃ ꠞꠢꠝꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT11_28","006_11_28","DEU","11","28","28","ꠀꠞ ꠁꠔꠣ ꠘꠣ ꠝꠣꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠌꠟꠅ, ꠁ ꠙꠕ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠈꠞꠦ ꠈꠞꠦ ꠎꠣꠅ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠟꠣꠘ꠆ꠘꠔꠤ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT11_29","006_11_29","DEU","11","29","29","“ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠁꠞꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠃ ꠖꠦꠡꠅ ꠘꠤꠀ ꠢꠣꠞꠣꠁꠛꠣ, ꠢꠣꠞꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠅꠃ ꠞꠢꠝꠔꠞ ꠇꠕꠣ ꠉꠞꠤꠍꠤꠝ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠀ ꠄꠟꠣꠘ ꠇꠞꠛꠣꠄ, ꠀꠞ ꠅꠃ ꠟꠣꠘ꠆ꠘꠔꠞ ꠇꠕꠣ ꠄꠟꠣꠘ ꠇꠞꠛꠣꠄ ꠁꠛꠣꠟ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("DT11_30","006_11_30","DEU","11","30","30","ꠔꠥꠝꠞꠣ ꠔ ꠌꠤꠘꠅ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠙꠕꠞ ꠙꠁꠌꠝꠦꠖꠤ ꠉꠤꠟꠉꠟꠞ ꠗꠣꠞꠅ ꠅꠃ ꠖꠥꠁꠅ ꠙꠣꠠ ꠀꠍꠦ, ꠀꠞꠣꠛꠣ ꠘꠣꠝꠞ ꠔꠟ ꠎꠣꠉꠣꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠇꠦꠘꠣꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠞ ꠝꠥꠞꠤꠞ ꠄꠟꠘ ꠛꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠞ ꠅꠃ ꠖꠥꠁꠅ ꠙꠣꠠ ꠌꠤꠘꠅ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("DT11_31","006_11_31","DEU","11","31","31","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠃ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠁꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠘꠅ ꠛꠡꠔ ꠇꠞꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT11_32","006_11_32","DEU","11","32","32","ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠀꠝꠟ ꠇꠞꠤꠅ, ꠎꠦꠔꠣ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT12_1","006_12_1","DEU","12","1","1","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠍꠂꠘ, ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_2","006_12_2","DEU","12","2","2","ꠢꠘꠞ ꠎꠔ ꠎꠣꠔꠤꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠞꠣꠄ, ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟ ꠙꠣꠠ-ꠙꠞꠛꠔꠞ ꠃꠙꠞꠦ, ꠒꠣꠟ-ꠙꠣꠟꠣ ꠝꠦꠟꠣꠁꠟ ꠔꠞꠔꠣꠎꠣ ꠢꠇꠟ ꠉꠣꠍꠞ ꠔꠟꠦ ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠀꠡ꠆ꠔꠣꠘꠣ ꠜꠣꠋꠉꠤꠀ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠤꠟꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_3","006_12_3","DEU","12","3","3","ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠛꠟꠤ ꠈꠣꠘꠣ ꠜꠣꠋꠉꠤꠟꠤꠅ, ꠙꠥꠎꠣꠞ ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠤꠅ, ꠀꠡꠦꠞꠣ-ꠖꠦꠛꠤꠞ ꠘꠤꠡꠣꠘꠣ ꠈꠥꠐꠤ ꠅꠇꠟ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠅ, ꠔꠣꠞꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠥꠞ꠆ꠔꠤ ꠅꠇꠟ ꠜꠣꠋꠉꠤꠟꠤꠅ, ꠁꠔꠣꠞ ꠘꠣꠝ ꠢꠤ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_4","006_12_4","DEU","12","4","4","“ꠀꠞ ꠔꠣꠞꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣꠞ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT12_5","006_12_5","DEU","12","5","5","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠖꠣꠞ-ꠖꠞꠡꠘ ꠖꠤꠛꠣꠞ ꠈꠤꠀꠟꠦ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠢꠤꠡꠣꠛꠦ, ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠖꠦꠅꠀ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠎꠦ ꠎꠣꠉꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠄꠛꠣꠖꠔꠤꠞ ꠟꠣꠉꠤ ꠢꠃ ꠎꠣꠉꠣꠔ ꠀꠎꠤꠞ ꠅꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_6","006_12_6","DEU","12","6","6","ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ, ꠢꠇꠟ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ, ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ, ꠝꠣꠘ꠆ꠘꠔꠞ ꠇꠥꠞꠛꠣꠘꠤ, ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠅꠃ ꠎꠣꠉꠣꠔ ꠀꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_7","006_12_7","DEU","12","7","7","ꠅꠈꠣꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠞꠦ ꠟꠁꠀ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠇꠞꠤꠅ, ꠀꠞ ꠔꠣꠘ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠅꠀ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠇꠣꠝꠣꠁ-ꠞꠥꠎꠉꠣꠞꠞ ꠟꠣꠉꠤ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_8","006_12_8","DEU","12","8","8","“ꠀꠞ ꠅꠈꠘ ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠎꠦꠝꠘꠦ ꠈꠥꠡꠤ ꠅꠝꠘꠦꠃ ꠌꠟꠞꠣꠝ, ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠁꠟꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT12_9","006_12_9","DEU","12","9","9","ꠔꠥꠝꠞꠣ ꠡꠥꠈ-ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠎꠣꠉꠣꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠔꠥꠝꠞꠣ ꠔ ꠅꠈꠘꠅ ꠢꠤꠘꠅ ꠉꠦꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT12_10","006_12_10","DEU","12","10","10","ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠖꠦꠡꠅ ꠉꠤꠀ ꠛꠡꠔꠤ ꠇꠞꠛꠣꠄ, ꠢꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠡꠣꠘ꠆ꠔꠤ ꠖꠤꠀ ꠢꠣꠞꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("DT12_11","006_12_11","DEU","12","11","11","ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠢꠤꠡꠣꠛꠦ ꠎꠦ ꠎꠣꠉꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠇꠟꠔꠣ ꠟꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠅ। ꠔꠥꠝꠞꠣꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ, ꠢꠇꠟ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ, ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ, ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠝꠣꠘ꠆ꠘꠔꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠟꠁꠀ ꠅꠘꠅ ꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_12","006_12_12","DEU","12","12","12","ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ, ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠘ꠆ꠖꠤ-ꠉꠥꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠉꠣꠃ ꠀꠞ ꠐꠣꠃꠘꠞ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟ, ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠎꠣꠉꠣ-ꠎꠝꠤ ꠙꠣꠁꠍꠦ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_13","006_12_13","DEU","12","13","13","ꠀꠞ ꠈꠥꠛ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠙꠍꠘ꠆ꠖ ꠝꠔ ꠎꠦꠍꠣ ꠎꠣꠉꠣꠔ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT12_14","006_12_14","DEU","12","14","14","ꠛꠞꠋ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠅꠇꠟꠞꠦ ꠖꠦꠅꠀ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠎꠦ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠎꠣꠉꠣ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠈꠣꠟꠤ ꠢꠃ ꠎꠣꠉꠣꠔ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ, ꠀꠞ ꠢꠃ ꠎꠣꠉꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_15","006_12_15","DEU","12","15","15","“ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠡꠈ ꠅꠁꠟꠦ ꠙꠣꠇ-ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦꠅ ꠢꠇꠟꠦꠃ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠔꠞ ꠎꠋꠟꠤ ꠅꠞꠤꠘꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠅꠀ ꠎꠦꠟꠣ ꠎꠣꠁꠎ ꠀꠍꠦ, ꠅꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝ-ꠛꠞꠇꠔꠦ ꠙꠣꠅꠀ ꠙꠡꠥꠞꠦ ꠎꠛ ꠇꠞꠤꠀ, ꠔꠥꠝꠞꠣꠞ ꠄꠟꠣꠇꠣꠞ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠅ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT12_16","006_12_16","DEU","12","16","16","ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠟꠃ ꠈꠣꠁꠅ ꠘꠣ, ꠟꠃꠞꠦ ꠙꠣꠘꠤꠞ ꠘꠝꠥꠘꠣꠄ ꠝꠣꠐꠤꠔ ꠓꠣꠟꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT12_17","006_12_17","DEU","12","17","17","“ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠚꠄ-ꠚꠡꠟꠞ, ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔꠞ ꠀꠞ ꠔꠦꠟꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ, ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘ꠆ꠘꠔꠞ ꠢꠇꠟꠔꠣ, ꠔꠥꠝꠞꠣꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ, ꠖꠣꠘ-ꠈꠄꠞꠣꠔ, ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠡꠔꠤ ꠄꠟꠣꠇꠣꠞ ꠇꠥꠘꠥ ꠉꠣꠃꠔ ꠛꠣ ꠐꠣꠃꠘꠅ ꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT12_18","006_12_18","DEU","12","18","18","ꠁꠔꠣ ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠘꠤꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠈꠣꠁꠅ। ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ, ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠈꠣꠁꠛꠣ। ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠝꠣꠎꠦ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_19","006_12_19","DEU","12","19","19","ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠅ ꠎꠔꠖꠤꠘ ꠛꠡꠔ ꠇꠞꠛꠣꠄ, ꠅꠔꠖꠤꠘ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠈꠤꠀꠟ-ꠘꠎꠞ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_20","006_12_20","DEU","12","20","20","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣ ꠛꠣꠠꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠇꠁꠛꠣꠄ, ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠣꠝ ꠝꠘꠦ ꠌꠣꠞ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠡꠈ ꠝꠤꠐꠣꠁꠀ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_21","006_12_21","DEU","12","21","21","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠢꠤꠡꠣꠛꠦ ꠎꠦ ꠎꠣꠉꠣ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠢꠤ ꠎꠣꠉꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠇ꠆ꠇꠣ ꠖꠥꠞꠁ ꠅꠄ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠖꠦꠅꠀ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠙꠡꠥ ꠘꠤꠀ ꠎꠛ ꠇꠞꠤꠅ, ꠀꠞ ꠎꠣꠞꠎꠤꠞ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠅ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_22","006_12_22","DEU","12","22","22","ꠡꠤꠇꠣꠞꠞ ꠎꠋꠟꠤ ꠅꠞꠤꠘꠞ ꠉꠥꠡ꠆ꠔꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠈꠣꠁꠅ, ꠙꠣꠇ-ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠢꠇꠟꠦꠃ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_23","006_12_23","DEU","12","23","23","ꠅꠁꠟꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠟꠃ ꠈꠣꠁꠅ ꠘꠣ, ꠟꠃ ꠅꠁꠟꠉꠤ ꠎꠣꠘ, ꠔꠥꠝꠞꠣ ꠉꠥꠡ꠆ꠔꠞ ꠟꠉꠦ ꠎꠣꠘ ꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT12_24","006_12_24","DEU","12","24","24","ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠟꠃ ꠈꠣꠁꠅ ꠘꠣ, ꠁꠔꠣꠞꠦ ꠙꠣꠘꠤꠞ ꠘꠝꠥꠘꠣꠄ ꠝꠣꠐꠤꠔ ꠓꠣꠟꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_25","006_12_25","DEU","12","25","25","ꠔꠥꠝꠞꠣ ꠟꠃ ꠈꠣꠁꠅ ꠘꠣ, ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞꠅ ꠎꠦꠇꠐꠣ ꠡꠑꠤꠇ, ꠅꠇꠐꠣ ꠀꠝꠟ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠜꠛꠤꠡꠔ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT12_26","006_12_26","DEU","12","26","26","“ꠝꠣꠛꠥꠖꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘꠤꠡ ꠀꠞ ꠝꠣꠘ꠆ꠘꠔꠞ ꠎꠤꠘꠤꠡ ꠟꠁꠀ ꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_27","006_12_27","DEU","12","27","27","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠀꠞ ꠟꠃ ꠎꠣꠟꠣꠁꠅ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠅꠁꠘ꠆ꠘ ꠢꠇꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠝꠣꠎꠦ ꠓꠣꠟꠤꠅ ꠀꠞ ꠁ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT12_28","006_12_28","DEU","12","28","28","ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠜꠛꠤꠡꠔ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠎꠣꠔꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠄ-ꠃꠘ꠆ꠘꠔꠤ ꠅꠄ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠅꠃ ꠢꠥꠇꠥꠝ ꠈꠣꠘꠣꠁꠘ ꠎꠔꠘ ꠇꠞꠤ ꠝꠣꠘꠤꠅ, ꠁꠟꠣ ꠌꠟꠟꠦ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞꠅ ꠎꠦꠔꠣ ꠡꠑꠤꠇ ꠀꠞ ꠜꠣꠟꠣ, ꠅꠐꠣꠃ ꠔꠥꠝꠞꠣ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT12_29","006_12_29","DEU","12","29","29","“ꠔꠥꠝꠞꠣ ꠎꠔ ꠎꠣꠔꠤꠞꠦ ꠛꠦ-ꠖꠈꠟ ꠇꠞꠛꠣꠄ, ꠔꠣꠞꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠃ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠀ ꠢꠘꠅ ꠛꠡꠔ ꠇꠞꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT12_30","006_12_30","DEU","12","30","30","ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠀꠞꠘꠣꠄ ꠔꠥꠝꠞꠣꠅ ꠔꠣꠞꠣꠞ ꠚꠣꠘ꠆ꠖꠅ ꠙꠠꠤꠀ ꠔꠣꠞꠣꠞ ꠖꠦꠛꠔꠣꠞ ꠜꠎꠘꠣ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠇꠅ, ꠅꠔꠣ ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠔꠣꠞꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠂꠘ, ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠙꠥꠎꠣ ꠇꠞꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT12_31","006_12_31","DEU","12","31","31","ꠈꠛꠞꠖꠣꠞ! ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠔꠣꠞꠣꠞ ꠙꠥꠎꠣꠞ ꠘꠝꠥꠘꠣꠄ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠣꠞꠣ ꠔ ꠎꠣꠞꠎꠤꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠘꠣꠝꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠙꠍꠘ꠆ꠖꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠀꠇꠣꠝ-ꠇꠥꠇꠣꠝ ꠇꠞꠦ, ꠄꠝꠘꠇꠤ ꠔꠣꠞꠣꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠘꠣꠝꠦ ꠘꠤꠎꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦ ꠀꠉꠥꠘꠤꠔ ꠎꠣꠟꠣꠁꠀ ꠛꠟꠤ ꠖꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT12_32","006_12_32","DEU","12","32","32","“ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠣꠘꠣꠁꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠅꠔꠣꠃ ꠝꠣꠘꠤꠅ। ꠁꠔꠣꠞ ꠟꠉꠦ ꠖꠥꠍꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠠꠣꠁꠅ ꠘꠣ, ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠖꠅ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT13_1","006_13_1","DEU","13","1","1","“ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠙꠤꠞ-ꠖꠞꠛꠦꠡꠦ ꠛꠣ ꠁꠡ꠆ꠔꠦꠈꠣꠞꠣ ꠇꠞꠞꠣꠄ ꠇꠥꠘ꠆ꠔꠣ ꠊꠐꠤꠛ ꠇꠁꠀ ꠎꠥꠖꠤ ꠀꠉꠣꠝ ꠈꠛꠞ ꠎꠣꠘꠣꠄ, ꠀꠞ ꠇꠥꠘꠥ ꠇꠦꠞꠣꠝꠔꠤꠞ ꠇꠕꠣ ꠇꠄ, ");
INSERT INTO syls_vpl VALUES ("DT13_2","006_13_2","DEU","13","2","2","ꠇꠅꠀꠞ ꠛꠣꠖꠦ ꠢꠣꠍꠣꠃ ꠎꠥꠖꠤ ꠅꠟꠣ ꠚꠟꠤ ꠎꠣꠄ, ꠀꠞ ꠅꠃ ꠎꠘꠦꠃ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠇꠕꠣ ꠢꠥꠘꠣꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠄ, ꠌꠟꠅ, ꠀꠝꠞꠣ ꠉꠤꠀ ꠢꠃ ꠖꠦꠛꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("DT13_3","006_13_3","DEU","13","3","3","ꠔꠦ ꠔꠥꠝꠞꠣ ꠅꠃ ꠙꠤꠞ-ꠖꠞꠛꠦꠡ ꠛꠣ ꠁꠡ꠆ꠔꠦꠈꠣꠞꠣ ꠇꠞꠞꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠤꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣ ꠎꠣꠘꠦ-ꠙꠞꠣꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠞꠣꠄ ꠇꠤ ꠘꠣ, ꠅꠃꠈꠣꠘ ꠎꠣꠌꠣꠁ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT13_4","006_13_4","DEU","13","4","4","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠌꠟꠤꠅ, ꠈꠣꠟꠤ ꠔꠣꠘꠞꠦꠃ ꠒꠞꠣꠁꠅ, ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠅ, ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠤꠀ ꠀꠝꠟ ꠇꠞꠤꠅ, ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠤꠅ, ꠀꠞ ꠔꠣꠘ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT13_5","006_13_5","DEU","13","5","5","ꠄꠞꠟꠣꠉꠤ ꠢꠃ ꠜꠘ꠆ꠒ ꠙꠤꠞ-ꠖꠞꠛꠦꠡ ꠛꠣ ꠁꠡ꠆ꠔꠦꠈꠣꠞꠣ ꠇꠞꠞꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠁꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠎꠦ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ, ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠜꠘ꠆ꠒꠄ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠃ ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠐꠣꠘꠦꠞ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠙꠕ ꠕꠣꠇꠤ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠔ ꠌꠣꠞ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠅꠃ ꠈꠣꠞꠣꠙꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT13_6","006_13_6","DEU","13","6","6","“ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠀꠙꠘ ꠜꠣꠁ, ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠙꠥꠀ ꠛꠣ ꠙꠥꠠꠤ, ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠞ ꠐꠥꠇꠞꠣ ꠛꠃ, ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠄꠀꠞ ꠛꠘ꠆ꠖꠥ ꠀꠁꠀ ꠎꠥꠖꠤ ꠘꠤꠞꠣꠟꠣꠄ ꠇꠄ, ‘ꠌꠟꠅ, ꠀꠝꠞꠣ ꠉꠤꠀ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠜꠎꠘꠣ ꠇꠞꠤ।’ ꠁꠔꠣ ꠖꠦꠛꠔꠣꠁꠘ ꠔꠥꠝꠣꠞ ꠛꠣ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠅꠌꠤꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("DT13_7","006_13_7","DEU","13","7","7","ꠔꠥꠝꠣꠞ ꠀꠡ-ꠙꠣꠡ ꠄꠟꠣꠇꠣꠞ ꠛꠣ ꠖꠥꠞꠁꠞ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣ ꠅꠃꠇ, ꠖꠥꠘꠤꠀꠞ ꠄꠇ ꠡꠤꠝꠣꠘꠣ ꠕꠣꠇꠤ ꠀꠞꠦꠇ ꠡꠤꠝꠣꠘꠣꠞ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠔꠤꠞ ꠎꠦꠇꠥꠘꠥ ꠖꠦꠛꠔꠣ ꠅꠃꠇ, ");
INSERT INTO syls_vpl VALUES ("DT13_8","006_13_8","DEU","13","8","8","ꠢꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠢꠘꠅ ꠘꠤꠔ ꠌꠣꠄ, ꠔꠦ ꠔꠥꠝꠤ ꠎꠣꠁꠅ ꠘꠣ, ꠔꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠅ ꠘꠣ, ꠔꠣꠞꠦ ꠖꠄꠀ ꠖꠦꠈꠣꠁꠅ ꠘꠣ, ꠔꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠅ ꠘꠣ, ꠀꠞ ꠟꠥꠇꠣꠘꠤꠞ ꠎꠣꠉꠣ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT13_9","006_13_9","DEU","13","9","9","ꠔꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠁꠅ। ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠙꠄꠟꠣ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠀꠔꠖꠤ ꠡꠥꠞꠥ ꠇꠞꠅ, ꠛꠣꠖꠦ ꠢꠇꠟꠦ ꠀꠁꠀ ꠡꠞꠤꠇ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT13_10","006_13_10","DEU","13","10","10","ꠅꠉꠥꠞꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠁꠐꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠅ, ꠢꠦ ꠔ ꠔꠥꠝꠣꠞꠦ ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔꠤ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠇꠥ-ꠙꠕꠦ ꠘꠤꠔ ꠌꠣꠞ, ꠎꠦꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT13_11","006_13_11","DEU","13","11","11","ꠅꠉꠥꠞꠦ ꠝꠣꠞꠤꠟꠣꠅꠀꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠒꠞꠣꠁꠛꠣ, ꠄꠞꠛꠣꠖꠦ ꠁꠟꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠣꠞ ꠡꠣꠅꠡ ꠀꠞ ꠇꠦꠃꠞꠞ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT13_12","006_13_12","DEU","13","12","12","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠎꠦ ꠉꠣꠃ ꠀꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠢꠥꠘꠅ, ");
INSERT INTO syls_vpl VALUES ("DT13_13","006_13_13","DEU","13","13","13","ꠢꠘꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠖꠟ ꠛꠣꠞ ꠅꠁꠀ, ꠢꠃ ꠎꠣꠉꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠙꠕꠦ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠞ, ꠌꠟꠅ, ꠀꠝꠞꠣ ꠉꠤꠀ ꠘꠄꠀ ꠘꠄꠀ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("DT13_14","006_13_14","DEU","13","14","14","ꠔꠦ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠈꠥꠎ-ꠈꠛꠞ ꠟꠁꠅ ꠀꠞ ꠔꠖꠘ꠆ꠔ ꠇꠞꠤꠅ। ꠔꠖꠘ꠆ꠔ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠁꠔꠣ ꠎꠊꠁꠘ꠆ꠘ ꠇꠣꠝꠞ ꠙꠞꠝꠣꠘ ꠝꠤꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("DT13_15","006_13_15","DEU","13","15","15","ꠔꠦ ꠢꠘꠞ ꠢꠇꠟ ꠛꠣꠡꠤꠘ꠆ꠖꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠅ। ꠢꠃ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠀꠞ ꠙꠡꠥ-ꠙꠋꠇꠤꠞꠦ ꠔꠟꠥꠀꠞꠖꠤ ꠇꠣꠐꠤꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT13_16","006_13_16","DEU","13","16","16","ꠢꠤꠘ ꠕꠣꠇꠤ ꠀꠘꠣ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠐꠣꠃꠘꠞ ꠝꠄꠖꠣꠘꠅ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠟꠤꠅ। ꠢꠃ ꠀꠡ꠆ꠔꠣ ꠉꠣꠃꠞꠦ ꠛꠣ ꠐꠣꠃꠘꠞꠦꠅ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠎꠣꠟꠣꠁꠀ ꠍꠣꠟꠤ ꠇꠞꠤꠅ। ꠢꠃ ꠎꠣꠉꠣꠞꠦ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠅ, ꠇꠦꠃ ꠎꠣꠘꠥ ꠇꠥꠘꠥꠖꠤꠘ ꠢꠤꠘꠅ ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠘꠣꠁꠔ ꠘꠣ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("DT13_17","006_13_17","DEU","13","17","17","ꠝꠣꠛꠥꠖꠞ ꠛꠦꠎꠥꠁꠔꠣ ꠉꠥꠍꠣ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ, ꠢꠘꠞ ꠇꠥꠘꠥ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠘꠣ ꠞꠄ, ꠁꠔꠣ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ ꠝꠣꠟ। ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠀꠞ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠟꠉꠞ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ-ꠅꠀꠞꠤꠡ ꠛꠣꠠꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT13_18","006_13_18","DEU","13","18","18","ꠈꠣꠟꠤ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠣꠘꠣꠁꠀꠞ, ꠅꠔꠣ ꠢꠇꠟꠔꠣ ꠝꠣꠘꠤꠅ, ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT14_1","006_14_1","DEU","14","1","1","“ꠔꠥꠝꠞꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠙ꠆ꠞꠎꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠛꠣ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠣꠔ ꠉꠤꠀ, ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞꠦ ꠇꠣꠐꠣ-ꠌꠤꠞꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠝꠣꠕꠣꠞ ꠍꠣꠝꠘꠞ ꠉꠣꠟꠣꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT14_2","006_14_2","DEU","14","2","2","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠔꠤ। ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠈꠣꠍ ꠙ꠆ꠞꠎꠣ ꠀꠞ ꠔꠣꠘ ꠘꠤꠎꠞ ꠡꠝ꠆ꠙꠖ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟꠉ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT14_3","006_14_3","DEU","14","3","3","“ꠔꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠘꠚꠞꠔꠤ ꠈꠣꠘꠤ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT14_4","006_14_4","DEU","14","4","4","ꠅꠃ ꠟꠣꠈꠣꠘ ꠙꠡꠥꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ: ꠉꠞꠥ, ꠝꠦꠠꠣ, ꠍꠣꠉꠟ, ꠁꠔꠣ ꠔ ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("DT14_5","006_14_5","DEU","14","5","5","ꠀꠞ ꠅꠞꠤꠘ, ꠝꠣꠄꠀ-ꠅꠞꠤꠘ, ꠌꠤꠔꠞꠣ-ꠅꠞꠤꠘ, ꠎꠋꠟꠤ ꠍꠣꠉꠟ, ꠟꠣꠝ꠆ꠛꠣ ꠢꠤꠋꠉꠤ ꠞꠣꠝ-ꠍꠣꠉꠟ, ꠙꠤꠍꠘꠦ ꠗꠟꠣ ꠅꠞꠤꠘ ꠀꠞ ꠙꠣꠠꠤꠀ ꠝꠦꠠꠣ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT14_6","006_14_6","DEU","14","6","6","ꠎꠦꠔꠣ ꠙꠡꠥꠞ ꠈꠥꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠥꠁ ꠅꠋꠡ ꠟꠣꠈꠣꠘ ꠌꠤꠞꠣ, ꠀꠞ ꠎꠦꠔꠣ ꠙꠡꠥꠁꠘ꠆ꠔꠦ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠁꠘ, ꠁꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("DT14_7","006_14_7","DEU","14","7","7","ꠅꠁꠟꠦ ꠎꠦꠔꠣ ꠙꠡꠥꠞ ꠈꠣꠟꠤ ꠈꠥꠞꠣ ꠌꠤꠞꠣ ꠅꠁꠟꠦ ꠙꠣꠎꠣꠁꠘ ꠘꠣ, ꠛꠣ ꠎꠦꠔꠣ ꠙꠡꠥꠁꠘ꠆ꠔꠦ ꠈꠣꠟꠤ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠁꠘ ꠅꠁꠟꠦ ꠈꠥꠞꠣ ꠌꠤꠞꠣ ꠘꠣꠁ, ꠅꠔꠣ ꠙꠡꠥꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠃꠐ, ꠈꠞꠉꠥꠡ ꠛꠣ ꠡꠣꠚꠘ-ꠃꠘ꠆ꠖꠥꠞꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠅ ꠘꠣ, ꠁꠔꠣꠄ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠁꠘ ꠅꠁꠟꠦ ꠁꠔꠣꠞ ꠈꠥꠞꠣ ꠌꠤꠞꠣ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT14_8","006_14_8","DEU","14","8","8","ꠀꠞ ꠡꠥꠅꠞꠞ ꠉꠥꠡ꠆ꠔꠅ ꠢꠣꠞꠣꠝ, ꠁꠔꠣꠞ ꠈꠥꠞꠣ ꠌꠤꠞꠣ ꠅꠁꠟꠦꠅ ꠁꠔꠣꠄ ꠈꠣꠘꠤꠞꠦ ꠙꠣꠎꠣꠁꠘ ꠘꠣ। ꠁꠔꠣ ꠙꠡꠥ ꠅꠇꠟꠞ ꠝꠞꠣ ꠟꠣꠡꠅ ꠗꠞꠣ-ꠍꠀ ꠘꠣꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("DT14_9","006_14_9","DEU","14","9","9","“ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠎꠦꠔꠣ ꠎꠣꠘꠖꠣꠞꠞ ꠚꠁꠞ ꠀꠞ ꠒꠣꠈꠘꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("DT14_10","006_14_10","DEU","14","10","10","ꠅꠁꠟꠦ ꠎꠦꠔꠣꠞ ꠚꠁꠞ ꠀꠞ ꠒꠣꠈꠘꠣ ꠘꠣꠁ, ꠁꠔꠣ ꠘꠣꠎꠣꠁꠎ। ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT14_11","006_14_11","DEU","14","11","11","“ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠙꠣꠈꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("DT14_12","006_14_12","DEU","14","12","12","ꠅꠁꠟꠦ ꠛꠠ ꠌꠤꠟ, ꠢꠇꠥꠘ, ꠢꠣꠚ-ꠈꠣꠃꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("DT14_13","006_14_13","DEU","14","13","13","ꠢꠇꠟ ꠎꠣꠔꠞ ꠌꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("DT14_14","006_14_14","DEU","14","14","14","ꠢꠇꠟ ꠎꠣꠔ ꠇꠣꠃꠀ, ");
INSERT INTO syls_vpl VALUES ("DT14_15","006_14_15","DEU","14","15","15","ꠃꠐꠙꠣꠈꠤ, ꠘꠤꠝ ꠙꠣꠈꠤ, ꠉꠣꠋꠌꠤꠟ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠣꠎ ꠙꠣꠈꠤ, ");
INSERT INTO syls_vpl VALUES ("DT14_16","006_14_16","DEU","14","16","16","ꠢꠇꠟ ꠎꠣꠔ ꠙꠦꠌꠣ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠇꠥꠠꠣ, ");
INSERT INTO syls_vpl VALUES ("DT14_17","006_14_17","DEU","14","17","17","ꠍꠟꠣ-ꠇꠣꠇ, ꠛꠟꠥꠀ ꠙꠣꠈꠤ, ꠙꠣꠘꠤ-ꠈꠣꠃꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("DT14_18","006_14_18","DEU","14","18","18","ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠣꠐꠤꠀ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠉꠟꠣ, ꠝꠘ-ꠌꠥꠞꠣ ꠙꠣꠈꠤ ꠀꠞ ꠛꠣꠖꠥꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT14_19","006_14_19","DEU","14","19","19","“ꠀꠞ ꠒꠣꠈꠘꠣ ꠀꠟꠣ ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠥꠇ-ꠎꠥꠇ, ꠎꠦꠔꠣꠄ ꠑꠦꠋ ꠖꠤꠀ ꠀꠐꠂꠘ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ, ꠁꠔꠣ ꠔ ꠘꠣꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("DT14_20","006_14_20","DEU","14","20","20","ꠅꠁꠟꠦ ꠒꠣꠈꠘꠣ ꠀꠟꠣ ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠚꠞꠤꠋ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("DT14_21","006_14_21","DEU","14","21","21","“ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠄꠇꠐꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠔꠤ, ꠄꠞꠟꠣꠉꠤ ꠅꠝꠘꠦ ꠅꠝꠘꠦ ꠝꠞꠤ ꠎꠣꠅꠀ ꠇꠥꠘꠥ ꠎꠤꠛ-ꠎꠣꠘꠥꠀꠞꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠅ ꠘꠣ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠃꠔ ꠛꠣ ꠐꠣꠃꠘꠅ ꠛꠡꠔ ꠇꠞꠞꠣ ꠖꠥꠍꠞꠣ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠁꠔꠣ ꠈꠣꠛꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠛꠦꠌꠔꠣꠄꠅ ꠙꠣꠞꠛꠣꠄ। “ꠀꠞ ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠛꠇꠞꠤꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠔꠣꠞ ꠝꠣʼꠞ ꠖꠥꠗ ꠖꠤꠀ ꠞꠣꠘ꠆ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT14_22","006_14_22","DEU","14","22","22","“ꠙꠞꠔꠦꠇ ꠛꠍꠞ ꠔꠥꠝꠞꠣꠞ ꠎꠝꠤꠘꠅ ꠎꠦꠔꠣ ꠚꠄ-ꠚꠡꠟ ꠙꠣꠅ, ꠁꠔꠣꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠔꠞꠣ ꠇꠞꠤ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT14_23","006_14_23","DEU","14","23","23","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠢꠤꠡꠣꠛꠦ ꠎꠦ ꠎꠣꠉꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠅꠔꠣ ꠟꠁꠀ ꠀꠁꠅ। ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠡꠟ, ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ, ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠘꠤꠅ। ꠁꠔꠣ ꠚꠡꠟꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠟꠣ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠎꠛ ꠇꠞꠤꠀ ꠢꠇ꠆ꠇꠟꠔꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠈꠣꠁꠅ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠀ ꠌꠟꠣ ꠢꠤꠇꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT14_24","006_14_24","DEU","14","24","24","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣ ꠎꠥꠖꠤ ꠛꠣꠇ꠆ꠇꠣ ꠖꠥꠞꠁ ꠅꠄ, ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠞꠢꠝ-ꠛꠞꠇꠔꠦ ꠙꠣꠅꠀ ꠅꠃ ꠍꠣꠝꠣꠘꠣ ꠟꠁꠀ ꠢꠤꠘꠅ ꠎꠣꠁꠔꠣꠄ ꠘꠣ ꠙꠣꠞ, ");
INSERT INTO syls_vpl VALUES ("DT14_25","006_14_25","DEU","14","25","25","ꠔꠦ ꠅꠃ ꠍꠣꠝꠣꠘꠣ ꠛꠦꠌꠤꠀ ꠁꠔꠣꠞ ꠐꠦꠇꠣ ꠟꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠢꠃ ꠎꠣꠉꠣꠔ ꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT14_26","006_14_26","DEU","14","26","26","ꠉꠤꠀ ꠅꠃ ꠐꠦꠇꠣꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠉꠞꠥ-ꠍꠣꠉꠟ, ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ, ꠔꠣꠠꠤ, ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠙꠍꠘ꠆ꠖꠞ ꠎꠦꠇꠥꠘꠥꠔꠣ ꠇꠤꠘꠤꠟꠣꠁꠅ। ꠛꠣꠖꠦ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠞꠦ ꠟꠁꠀ ꠁꠔꠣ ꠈꠣꠘꠤ-ꠖꠣꠘꠤ ꠈꠣꠁꠀ ꠢꠣꠞꠤ, ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT14_27","006_14_27","DEU","14","27","27","ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠅ ꠛꠡꠔ ꠇꠞꠞꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠚꠣꠃꠞꠤꠅ ꠘꠣ। ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠔ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT14_28","006_14_28","DEU","14","28","28","“ꠙꠞꠔꠦꠇ ꠔꠤꠘ ꠛꠍꠞ ꠛꠣꠖꠦ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠡꠟꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠘꠤꠀ ꠐꠣꠃꠘꠅ ꠖꠟꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT14_29","006_14_29","DEU","14","29","29","ꠔꠦꠃ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ, ꠎꠦꠞꠣ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠛꠣ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠛꠣꠐ ꠙꠣꠁꠍꠦ ꠘꠣ ꠄꠞꠣ, ꠀꠞ ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠇꠟꠦ, ꠄꠔꠤꠝ ꠅꠇꠟꠦ, ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠁꠔꠣ ꠙꠦꠐ ꠜꠞꠤꠀ ꠈꠣꠁꠛꠣ। ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝꠞ ꠝꠣꠎꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT15_1","006_15_1","DEU","15","1","1","“ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠣꠅꠘꠣ ꠙꠞꠔꠦꠇ ꠡꠣꠔ ꠛꠞꠍ ꠛꠣꠖꠦ ꠛꠣꠖꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT15_2","006_15_2","DEU","15","2","2","ꠁꠔꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠚꠤ ꠖꠤꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠙꠞꠔꠦꠇꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠙꠣꠅꠘꠣꠞꠦ ꠝꠣꠚꠤ ꠖꠤꠅ। ꠝꠣꠛꠥꠖꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ ꠙꠣꠅꠘꠣ ꠝꠣꠚꠤ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠄꠞꠟꠣꠉꠤ ꠀꠞ ꠇꠥꠘꠥ ꠙꠣꠅꠘꠣ ꠖꠣꠛꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT15_3","006_15_3","DEU","15","3","3","ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠞ ꠙꠣꠅꠘꠣ ꠖꠣꠛꠤ ꠛꠅꠀꠁꠟ ꠕꠣꠇꠔ ꠙꠣꠞꠦ, ꠅꠁꠟꠦ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁꠞ ꠉꠦꠍꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠣꠅꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT15_4","006_15_4","DEU","15","4","4","ꠀꠍꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠢꠃ ꠎꠝꠤꠘꠅ ꠔꠣꠁꠘ ꠘꠤꠌ꠆ꠌꠤꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠉꠞꠤꠛ ꠞꠅꠀꠞ ꠇꠕꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT15_5","006_15_5","DEU","15","5","5","ꠔꠣꠁꠘ ꠔ ꠁꠟꠣ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠀꠁꠎ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠁꠔꠣ ꠢꠥꠇꠥꠝ ꠅꠇꠟ ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠣꠘꠤꠀ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("DT15_6","006_15_6","DEU","15","6","6","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠎꠦ ꠡꠝꠄ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠛꠃꠔ ꠎꠣꠔꠤꠞꠦ ꠀꠅꠟꠣꠔ ꠖꠤꠛꠣꠄ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠔ ꠇꠞꠣꠞ ꠇꠥꠘꠥ ꠖꠞꠇꠣꠞ ꠅꠁꠔ ꠘꠣꠄ। ꠀꠞ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠞꠣꠎꠔ꠆ꠔ ꠇꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠇꠦꠃ ꠞꠣꠎꠔ꠆ꠔ ꠇꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT15_7","006_15_7","DEU","15","7","7","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠞꠣ, ꠢꠃ ꠖꠦꠡꠞ ꠇꠥꠘꠥꠈꠣꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠉꠞꠤꠛ ꠅꠄ, ꠔꠦ ꠔꠣꠞ ꠛꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠔ ꠝꠥꠁꠐ ꠇꠞꠤꠀ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT15_8","006_15_8","DEU","15","8","8","ꠀꠔ ꠈꠥꠟꠣ ꠞꠣꠈꠤꠀ ꠔꠣꠞ ꠎꠞꠥꠞ ꠛꠥꠎꠤꠀ ꠀꠅꠟꠣꠔ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT15_9","006_15_9","DEU","15","9","9","ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠛꠍꠞ ꠝꠣꠘꠤ, ꠀꠅꠟꠣꠔ ꠝꠣꠚꠤꠞ ꠛꠍꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠌ꠆ꠌꠦ ꠖꠦꠈꠤꠀ ꠝꠘꠞ ꠇꠥ-ꠝꠔꠟꠛꠦ ꠔꠥꠝꠞꠣꠞ ꠅꠜꠣꠛꠤ ꠜꠣꠁꠞꠦ ꠈꠣꠟꠤ ꠀꠔꠦ ꠚꠤꠞꠣꠁ ꠖꠤꠅ ꠘꠣ, ꠀꠞꠘꠣꠄ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠚꠞꠤꠀꠖ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠉꠥꠘꠣꠞ ꠜꠣꠉꠤ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT15_10","006_15_10","DEU","15","10","10","ꠝꠘꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠛꠦꠎꠣꠞꠤ ꠘꠣ ꠀꠘꠤꠀ ꠔꠣꠞꠦ ꠖꠤꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝꠅ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠎꠦ ꠇꠣꠝꠅ ꠀꠔ ꠖꠤꠛꠣꠄ, ꠅꠃ ꠇꠣꠝꠅꠃ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT15_11","006_15_11","DEU","15","11","11","ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠔ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠉꠞꠤꠛ ꠝꠣꠘꠥꠡ ꠞꠁꠛꠣ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠛꠣꠄ, ꠖꠦꠡꠞ ꠉꠞꠤꠛ-ꠖꠥꠈꠤ, ꠅꠜꠣꠛꠤ ꠝꠣꠘꠡꠞ ꠛꠣꠄ ꠘꠤꠎꠞ ꠀꠔ ꠈꠥꠟꠣ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT15_12","006_15_12","DEU","15","12","12","“ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠁꠛꠞꠣꠘꠤ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠄ ꠎꠥꠖꠤ ꠘꠤꠎꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠛꠦꠌꠤꠟꠣꠄ, ꠔꠦ ꠍꠄ ꠛꠞꠍ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠛꠞꠍ ꠀꠞꠝ꠆ꠛ ꠅꠀꠞ ꠇꠣꠟꠅ ꠔꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT15_13","006_15_13","DEU","15","13","13","ꠀꠎꠣꠖ ꠇꠞꠛꠣꠞ ꠇꠣꠟꠅ ꠔꠣꠞꠦ ꠈꠣꠟꠤ ꠀꠔꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT15_14","006_15_14","DEU","15","14","14","ꠔꠥꠝꠞꠣ ꠔꠣꠞꠦ ꠈꠥꠟꠣ ꠀꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠟꠅ ꠕꠣꠇꠤ ꠝꠦꠠꠣ-ꠍꠣꠉꠟ, ꠈꠦꠔ-ꠈꠣꠝꠣꠞ ꠕꠣꠇꠤ ꠚꠡꠟ ꠀꠞ ꠀꠋꠉꠥꠞ ꠝꠣꠠꠣꠞ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠖꠤꠅ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠞꠣꠅ ꠔꠣꠞꠦ ꠅꠟꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT15_15","006_15_15","DEU","15","15","15","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠅ ꠀꠉꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠄ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤꠃ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT15_16","006_15_16","DEU","15","16","16","“ꠅꠁꠟꠦ ꠢꠃ ꠉꠥꠟꠣꠝꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠡꠥꠈ ꠙꠣꠁꠀ, ꠔꠥꠝꠞꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠘꠡꠞꠦ ꠜꠣꠟꠣ ꠙꠣꠅꠀꠄ ꠎꠥꠖꠤ ꠇꠄ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠣꠁꠔ ꠘꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT15_17","006_15_17","DEU","15","17","17","ꠔꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠞ ꠇꠣꠘꠞ ꠟꠔꠤꠞꠦ ꠖꠥꠀꠞꠞ ꠇꠙꠣꠐꠅ ꠟꠣꠉꠣꠁꠀ ꠡꠤꠇ ꠖꠤꠀ ꠚꠥꠠ ꠇꠞꠤ ꠖꠤꠛꠣꠄ, ꠔꠦꠃ ꠢꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠜꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝꠤꠔ ꠞꠁꠛ। ꠁ ꠢꠥꠇꠥꠝ ꠉꠥꠟꠣꠝ ꠛꠣ ꠛꠣꠘ꠆ꠖꠤꠞ ꠟꠣꠉꠤ ꠄꠇ ꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("DT15_18","006_15_18","DEU","15","18","18","ꠉꠥꠟꠣꠝ ꠛꠣ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤ ꠖꠤꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠇꠡ꠆ꠐ ꠀꠘꠣ ꠑꠤꠇ ꠘꠣꠄ, ꠢꠦ ꠔ ꠍꠄ ꠛꠞꠍ ꠗꠞꠤ ꠛꠦꠔꠘꠖꠣꠞꠤ ꠇꠣꠝꠟꠣꠞ ꠌꠣꠁꠔꠦꠅ ꠒꠣꠛꠟ ꠇꠣꠝ ꠇꠞꠍꠦ। ꠅꠈꠘ ꠔꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝꠅ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT15_19","006_15_19","DEU","15","19","19","“ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠞꠔꠦꠇ ꠙꠄꠟꠣ ꠝꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠀꠟꠉꠣꠁꠀ ꠕꠁꠅ। ꠉꠞꠥꠞ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠖꠤ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠣꠁꠅ ꠘꠣ, ꠝꠦꠠꠣ-ꠍꠣꠉꠟꠞ ꠙꠄꠟꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠞꠥꠝꠣ ꠇꠣꠐꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT15_20","006_15_20","DEU","15","20","20","ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠘꠤꠀ, ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠞꠦ ꠟꠁꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠙꠞꠔꠦꠇ ꠛꠍꠞ ꠅꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT15_21","006_15_21","DEU","15","21","21","ꠅꠁꠟꠦ ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠈꠥꠔ ꠕꠣꠇꠦ, ꠁꠔꠣ ꠟꠦꠋꠠꠣ, ꠀꠘ꠆ꠖꠣ ꠛꠣ ꠀꠞꠅ ꠇꠥꠘꠥ ꠎꠣꠔꠞ ꠈꠥꠔ ꠕꠣꠇꠦ, ꠔꠦ ꠁꠉꠥꠞꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("DT15_22","006_15_22","DEU","15","22","22","ꠅꠁꠟꠦ ꠁꠔꠣ ꠈꠥꠔꠀꠟꠣ ꠙꠡꠥ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠄꠟꠣꠇꠣꠔ ꠎꠛ ꠇꠞꠤ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠡꠤꠇꠣꠞꠞ ꠅꠞꠤꠘꠞ ꠟꠣꠈꠣꠘ ꠎꠛ ꠇꠞꠤꠀ ꠙꠣꠇ-ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠎꠦꠇꠥꠘꠥ ꠎꠘꠦ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT15_23","006_15_23","DEU","15","23","23","ꠈꠣꠟꠤ ꠟꠃ ꠈꠣꠁꠅ ꠘꠣ, ꠟꠃꠞꠦ ꠙꠣꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠐꠤꠔ ꠓꠣꠟꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_1","006_16_1","DEU","16","1","1","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠀꠛꠤꠛ ꠝꠣꠡꠞ ꠌꠣꠘ꠆ꠖꠅ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠇꠣꠞꠘ ꠅꠃ ꠌꠣꠘ꠆ꠖꠞ ꠄꠇꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT16_2","006_16_2","DEU","16","2","2","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠞ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠢꠤꠡꠣꠛꠦ ꠎꠦ ꠎꠣꠉꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠅꠃ ꠎꠣꠉꠣꠔ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠘꠣꠝꠦ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠣꠟ ꠕꠣꠇꠤ ꠙꠡꠥ ꠘꠤꠀ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_3","006_16_3","DEU","16","3","3","ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠉꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠘꠣꠘ ꠞꠥꠐꠤꠖꠤ ꠈꠣꠁꠅ ꠘꠣ। ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠣꠠꠣ-ꠃꠠꠣ ꠇꠞꠤ ꠎꠦꠝꠘꠦ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠢꠣꠟꠔꠦ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠟꠣꠄ, ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠥꠞꠣ ꠡꠣꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠅꠟꠣ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠅ। ꠢꠃ ꠖꠤꠘꠞꠦ ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠜꠞ ꠝꠘꠅ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠅꠟꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_4","006_16_4","DEU","16","4","4","ꠅꠃ ꠡꠣꠔꠅ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠎꠣꠘꠥ ꠈꠣꠝꠤꠞ ꠀꠟꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠈꠣꠘꠤ ꠘꠣ ꠝꠤꠟꠦ। ꠙꠄꠟꠣ ꠖꠤꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠎꠦ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠄ, ꠁꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠎꠣꠘꠥ ꠚꠎꠞꠞ ꠡꠝꠄ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("DT16_5","006_16_5","DEU","16","5","5","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠣꠘ ꠇꠞꠛꠣ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT16_6","006_16_6","DEU","16","6","6","ꠈꠣꠟꠤ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠁꠘ ꠎꠦ ꠎꠣꠉꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ꠌꠣꠘ꠆ꠖꠞ ꠎꠦ ꠔꠣꠞꠤꠈꠅ ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠟꠣꠄ, ꠙꠞꠔꠦꠇ ꠛꠍꠞ ꠅꠃ ꠔꠣꠞꠤꠈꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_7","006_16_7","DEU","16","7","7","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠞꠣꠘ꠆ꠖꠤꠀ ꠈꠣꠁꠅ। ꠛꠣꠖꠦ ꠛꠤꠀꠘ ꠅꠁꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠊꠞꠅ ꠚꠤꠞꠤꠀ ꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_8","006_16_8","DEU","16","8","8","ꠙꠥꠞꠣ ꠍꠄ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠁꠅ, ꠀꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠝꠤꠟꠘ-ꠝꠣꠢꠚꠤꠟ ꠇꠞꠤꠅ, ꠅꠃ ꠖꠤꠘ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT16_9","006_16_9","DEU","16","9","9","“ꠈꠦꠔꠞ ꠚꠡꠟ ꠇꠣꠐꠣꠔ ꠙꠄꠟꠣ ꠇꠣꠌꠤ ꠟꠣꠉꠣꠘꠤꠞ ꠖꠤꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠡꠣꠔ ꠢꠣꠙ꠆ꠔꠣ ꠉꠘꠣ ꠡꠥꠞꠥ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_10","006_16_10","DEU","16","10","10","ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝ-ꠛꠞꠇꠔꠦ ꠎꠔ ꠚꠡꠟ ꠙꠣꠁꠍ, ꠅꠔꠣ ꠕꠣꠇꠤ ꠘꠤꠎꠦ ꠈꠥꠡ ꠅꠁꠀ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠀ ꠔꠣꠘ ꠘꠣꠝꠦ ꠙꠘ꠆ꠌꠣꠁꠡꠣ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_11","006_16_11","DEU","16","11","11","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠢꠤꠡꠣꠛꠦ ꠎꠦ ꠎꠣꠉꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠔꠥꠝꠞꠣ ꠢꠃ ꠎꠣꠉꠣꠔ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ, ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟ, ꠄꠔꠤꠝ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ, ꠢꠇ꠆ꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠁꠖꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_12","006_16_12","DEU","16","12","12","ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠉꠦ ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠄ, ꠔꠦ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠅꠃ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_13","006_16_13","DEU","16","13","13","“ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠡꠟ ꠀꠞ ꠀꠋꠉꠥꠞ ꠝꠣꠠꠣꠞ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠢꠇꠟꠔꠣ ꠃꠉꠣꠞꠅ ꠔꠥꠟꠤꠀ ꠢꠣꠞꠟꠦ, ꠙꠥꠞꠣ ꠡꠣꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠒꠦꠞꠣ-ꠊꠞꠞ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_14","006_16_14","DEU","16","14","14","ꠁꠖꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ, ꠜꠤꠘ-ꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ, ꠄꠔꠤꠝ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_15","006_16_15","DEU","16","15","15","ꠝꠣꠛꠥꠖꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠥꠞꠣ ꠡꠣꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠅꠃ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠝꠣꠛꠥꠖꠦ ꠔ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠚꠡꠟꠞ ꠝꠣꠎꠦ, ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎꠅ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT16_16","006_16_16","DEU","16","16","16","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠛꠍꠞꠅ ꠔꠤꠘꠛꠣꠞ ꠔꠣꠘ ꠖꠤꠖꠣꠞꠅ ꠀꠎꠤꠞ ꠅꠁꠅ। ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖ, ꠙꠘ꠆ꠌꠣꠁꠡꠣ ꠁꠖ, ꠒꠦꠞꠣ-ꠊꠞꠞ ꠁꠖ, ꠅꠃ ꠔꠤꠘꠅ ꠁꠖꠞ ꠇꠣꠟꠅ ꠀꠎꠤꠞ ꠅꠁꠅ। ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠇꠦꠃ ꠎꠣꠘꠥ ꠈꠣꠟꠤ ꠀꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠘꠣ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("DT16_17","006_16_17","DEU","16","17","17","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠦ ꠎꠦ ꠟꠣꠈꠣꠘ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠍꠂꠘ, ꠅꠃ ꠢꠤꠡꠣꠛꠦ ꠘꠤꠎꠞ ꠔꠚꠤꠇ ꠀꠘꠝꠣꠘ ꠙꠞꠔꠦꠇ ꠎꠘꠦ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT16_18","006_16_18","DEU","16","18","18","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠁꠔꠣ ꠢꠇꠟ ꠐꠣꠃꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠢꠣꠇꠤꠝ-ꠡꠣꠟꠤꠡ ꠀꠞ ꠅꠚꠤꠡꠣꠞ ꠛꠅꠀꠁꠟ ꠇꠞꠤꠅ। ꠄꠞꠣ ꠢꠇ ꠛꠤꠌꠣꠞ-ꠡꠣꠟꠤꠡ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT16_19","006_16_19","DEU","16","19","19","ꠔꠥꠝꠞꠣ ꠢꠇ ꠛꠤꠌꠣꠞ ꠕꠣꠇꠤ ꠟꠠꠤꠅ ꠘꠣ, ꠇꠦꠃꠞꠞ ꠝꠥꠈ ꠌꠣꠁꠀ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠤꠅ ꠘꠣ। ꠊꠥꠡ ꠈꠣꠁꠅ ꠘꠣ, ꠊꠥꠡꠦ ꠔ ꠀꠈꠟꠖꠣꠞꠞ ꠌꠃꠈꠞꠦꠅ ꠀꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠣꠄ, ꠀꠞ ꠙꠞꠦꠎꠉꠣꠞꠞ ꠝꠥꠈꠞ ꠎꠛꠣꠘꠅ ꠛꠖꠟꠣꠁꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT16_20","006_16_20","DEU","16","20","20","ꠢꠇꠟ ꠘꠝꠥꠘꠣꠄ ꠎꠦꠐꠣ ꠡꠑꠤꠇ, ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠅꠃ ꠙꠕꠦ ꠌꠟꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠅꠔꠣ ꠖꠈꠟ ꠇꠞꠤꠀ ꠟꠣꠝ꠆ꠛꠣ ꠢꠣꠄꠀꠔꠤ ꠙꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT16_21","006_16_21","DEU","16","21","21","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠞꠣ ꠎꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠛꠣꠄ, ꠄꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠔ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠀꠡꠦꠞꠣ-ꠖꠦꠛꠤꠞ ꠇꠥꠘꠥ ꠘꠤꠡꠣꠘꠣ ꠈꠥꠐꠤ ꠕꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT16_22","006_16_22","DEU","16","22","22","ꠙꠥꠎꠣꠞ ꠘꠤꠅꠔꠦ ꠙꠣꠔ꠆ꠔꠞꠞ ꠇꠥꠘꠥ ꠈꠥꠐꠤ ꠉꠣꠠꠤꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣꠞꠦ ꠊꠤꠘ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("DT17_1","006_17_1","DEU","17","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠁꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠉꠞꠥ-ꠍꠣꠉꠟꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠅ ꠘꠣ, ꠎꠦꠔꠣꠞ ꠉꠔꠞꠅ ꠈꠥꠔ ꠀꠍꠦ, ꠔꠣꠁꠘ ꠔ ꠈꠥꠔ ꠀꠟꠣ ꠇꠥꠞꠛꠣꠘꠤꠞꠦ ꠊꠤꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT17_2","006_17_2","DEU","17","2","2","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠉꠣꠃ ꠀꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠖꠣꠘ ꠇꠞꠛꠣ, ꠅꠃ ꠎꠣꠉꠣꠔ ꠎꠥꠖꠤ ꠁꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤ ꠝꠤꠟꠦ, ꠎꠦꠉꠥꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠃꠟꠐꠣ ꠉꠤꠀ ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠇꠣꠝ ꠊꠤꠘ ꠇꠞꠂꠘ ꠅꠔꠣ ꠇꠣꠝ ꠇꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("DT17_3","006_17_3","DEU","17","3","3","ꠅꠉꠥꠄ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠦ, ꠌꠣꠘ꠆ꠖ, ꠡꠥꠞꠥꠎ, ꠔꠦꠞꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("DT17_4","006_17_4","DEU","17","4","4","ꠀꠞ ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠟ ꠅꠄ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠡꠣꠛꠗꠣꠘꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤꠀ ꠖꠦꠈꠤꠅ ꠁꠔꠣ ꠢꠣꠍꠣ ꠘꠣ ꠝꠤꠍꠣ। ꠢꠣꠍꠣ ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠜꠤꠔꠞꠦ ꠁꠟꠣ ꠟꠣꠘ꠆ꠘꠔꠤ ꠇꠣꠝ ꠇꠞꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT17_5","006_17_5","DEU","17","5","5","ꠢꠃ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠅ। ꠅꠉꠥꠞꠦ ꠗꠞꠤꠀ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠙꠣꠁꠘ꠆ꠌꠣꠁꠔꠤ ꠛꠂꠑꠇ ꠈꠣꠘꠣꠔ ꠀꠘꠤꠅ, ꠀꠘꠤꠀ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠝꠣꠞꠤꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT17_6","006_17_6","DEU","17","6","6","ꠅꠁꠟꠦ ꠝꠞꠣꠞ ꠎꠥꠇꠣ ꠅꠙꠞꠣꠗ ꠙꠞꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠖꠥꠁ ꠛꠣ ꠔꠤꠘ ꠎꠘꠞ ꠡꠣꠇ꠆ꠇꠤ ꠟꠣꠉꠛ, ꠄꠇꠟꠣ ꠄꠇ ꠎꠘꠞ ꠡꠣꠇ꠆ꠇꠤꠄ ꠝꠣꠞꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT17_7","006_17_7","DEU","17","7","7","ꠔꠣꠞꠦ ꠝꠣꠞꠣꠞ ꠛꠣꠟꠣ ꠙꠄꠟꠣ ꠡꠣꠇ꠆ꠇꠤ ꠅꠇꠟꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠛꠣ, ꠛꠣꠖꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠝꠣꠞꠛꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎꠞ ꠜꠤꠔꠞ ꠕꠣꠇꠤ ꠅꠟꠣꠈꠣꠘ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠈꠦꠖꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT17_8","006_17_8","DEU","17","8","8","“ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠥꠖꠤ ꠁꠟꠣꠈꠣꠘ ꠇꠑꠤꠘ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠀꠄ, ꠎꠦꠔꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠀꠖꠣꠟꠔꠞ ꠘꠣꠁ, ꠔꠦ ꠁꠔꠣ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠎꠣꠁꠅ। ꠗꠞꠤꠟꠣꠅ, ꠇꠥꠘꠥ ꠈꠥꠘ-ꠈꠣꠞꠣꠙꠤ, ꠝꠣꠞꠣ-ꠝꠣꠞꠤ, ꠎꠛꠞ-ꠖꠈꠟꠖꠣꠞꠤ ꠙꠞꠝꠣꠘ-ꠔꠖꠘ꠆ꠔꠞ ꠛꠤꠌꠣꠞ-ꠀꠌꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("DT17_9","006_17_9","DEU","17","9","9","ꠉꠤꠀ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠝꠣꠝ ꠅꠇꠟ ꠀꠞ ꠢꠃ ꠀꠝꠟꠞ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ ꠍꠣꠛꠞ ꠖꠞꠛꠣꠞꠅ ꠘꠣꠟꠤꠡ ꠢꠥꠘꠣꠁꠅ, ꠢꠥꠘꠣꠁꠟꠦ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠌꠣꠞꠞ ꠞꠣꠄ ꠛꠣꠔꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT17_10","006_17_10","DEU","17","10","10","ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠔꠣꠞꠣ ꠎꠦ ꠞꠣꠄ ꠎꠣꠘꠣꠁꠛꠣ, ꠅꠃ ꠞꠣꠄꠅꠞ ꠝꠞ꠆ꠝ ꠛꠥꠎꠤꠀ ꠔꠥꠝꠞꠣ ꠇꠣꠝ ꠇꠞꠛꠣꠄ, ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠢꠤꠇꠣꠁ ꠖꠤꠛꠣ, ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠁꠔꠣ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT17_11","006_17_11","DEU","17","11","11","ꠀꠟ꠆ꠟꠣꠁ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞꠣ ꠎꠦꠟꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣ, ꠔꠣꠞꠣ ꠎꠦꠟꠣꠈꠣꠘ ꠛꠤꠌꠣꠞꠞ ꠞꠣꠄ ꠖꠤꠛꠣ, ꠅꠔꠣꠞ ꠝꠞ꠆ꠝ ꠛꠥꠎꠤꠀ ꠔꠥꠝꠞꠣ ꠇꠣꠝ ꠇꠞꠤꠅ, ꠔꠣꠞꠣꠞ ꠇꠕꠣ ꠕꠣꠇꠤ ꠃꠘ꠆ꠘꠤꠡ-ꠛꠤꠡ ꠇꠤꠌ꠆ꠍꠥ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT17_12","006_17_12","DEU","17","12","12","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠀ ꠎꠥꠖꠤ ꠢꠃ ꠢꠣꠇꠤꠝꠞ ꠞꠣꠄ ꠘꠣ ꠝꠣꠘꠦ, ꠛꠣ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠈꠣꠖꠤꠝ ꠅꠃ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠢꠥꠇꠥꠝ ꠘꠣ ꠝꠣꠘꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠅ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠈꠦꠖꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT17_13","006_17_13","DEU","17","13","13","ꠔꠦꠃ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠒꠞꠣꠁꠛꠣ, ꠔꠣꠞꠣ ꠀꠞ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠘꠤꠞ ꠡꠣꠅꠡ ꠙꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT17_14","006_17_14","DEU","17","14","14","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠢꠘꠅ ꠉꠤꠀ ꠛꠡꠔ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠁꠛꠣꠄ, ꠀꠅ, ꠀꠝꠞꠣꠞ ꠀꠡ-ꠙꠣꠡꠞ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠟꠣꠉꠤꠅ ꠄꠇꠎꠘ ꠛꠣꠖꠡꠣ ꠛꠣꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT17_15","006_17_15","DEU","17","15","15","ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠔꠣꠞꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠘꠣꠁꠅ। ꠢꠦ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁ ꠅꠄ, ꠇꠥꠘꠥ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT17_16","006_17_16","DEU","17","16","16","ꠁ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠊꠥꠠꠣ ꠎꠣꠘꠥ ꠘꠣ ꠎꠝꠣꠄ, ꠊꠥꠠꠣ ꠎꠥꠉꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠢꠦ ꠎꠣꠘꠥ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠘꠡꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠘꠣ ꠙꠣꠑꠣꠄ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠣꠛꠥꠖꠦ ꠀꠉꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠢꠤ ꠙꠕꠦꠖꠤ ꠎꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT17_17","006_17_17","DEU","17","17","17","ꠁ ꠛꠣꠖꠡꠣꠄ ꠎꠣꠘꠥ ꠛꠃꠔ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠘꠣ ꠇꠞꠦ, ꠀꠞꠘꠣꠄ ꠔꠣꠞ ꠖꠤꠟ ꠛꠦ-ꠙꠕꠦ ꠎꠣꠁꠛꠉꠤ। ꠢꠦ ꠎꠣꠘꠥ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠛꠦꠡ ꠇꠞꠤ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠘꠣ ꠎꠝꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT17_18","006_17_18","DEU","17","18","18","“ꠔꠣꠞꠦ ꠞꠣꠎ-ꠉꠖꠤꠔ ꠛꠅꠀꠘꠤꠞ ꠇꠣꠟꠅ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠝꠣꠝ ꠍꠣꠛ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠦ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛ ꠕꠣꠇꠛ, ꠅꠃ ꠇꠤꠔꠣꠛꠞ ꠀꠞꠅ ꠄꠇ ꠇꠙꠤ ꠟꠦꠈꠤꠀ ꠔꠣꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠘꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT17_19","006_17_19","DEU","17","19","19","ꠁꠈꠣꠘ ꠔꠣꠞ ꠘꠤꠎꠞ ꠉꠦꠍꠦ ꠞꠁꠛ, ꠔꠣꠞ ꠖꠤꠟꠅ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠒꠞ-ꠈꠚ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠔꠃꠞꠣꠔ ꠀꠞ ꠄꠞ ꠜꠤꠔꠞꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠣꠘꠤꠀ ꠌꠟꠣꠞ ꠘꠤꠅꠔꠦ, ꠢꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠜꠞ ꠅꠃ ꠇꠤꠔꠣꠛ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("DT17_20","006_17_20","DEU","17","20","20","ꠔꠦꠃ ꠔꠣꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁꠀꠁꠘ ꠕꠣꠇꠤ ꠘꠤꠎꠞꠦ ꠛꠠ ꠝꠘꠅ ꠇꠞꠔ ꠘꠣꠄ, ꠢꠦ ꠔꠃꠞꠣꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠞ ꠃꠘ꠆ꠘꠤꠡ-ꠛꠤꠡ ꠇꠞꠔ ꠘꠣꠄ। ꠔꠦꠃ ꠢꠦ ꠀꠞ ꠔꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠉꠖꠤ ꠡ꠆ꠕꠣꠄꠁ ꠅꠁꠛ, ꠔꠣꠞꠣ ꠛꠃꠔ ꠖꠤꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT18_1","006_18_1","DEU","18","1","1","“ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠛꠣ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠙꠣꠁꠔꠣ ꠘꠣꠄ। ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠖꠦꠅꠀ ꠢꠇꠟ ꠎꠣꠔꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠀꠞ ꠢꠇꠟ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣꠞ ꠛꠣꠐꠅ ꠔꠣꠞꠣ ꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT18_2","006_18_2","DEU","18","2","2","ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠙꠣꠁꠔꠣ ꠘꠣꠄ। ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠃ ꠔꠣꠞꠣꠞ ꠝꠤꠞꠣꠡ, ꠔꠣꠁꠘ ꠘꠤꠎꠦꠅ ꠔꠣꠞꠣꠞꠦ ꠁ ꠅꠀꠖꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT18_3","006_18_3","DEU","18","3","3","“ꠝꠣꠘꠡꠦ ꠎꠔ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣ, ꠁꠔꠣꠞ ꠇꠣꠘ꠆ꠖꠞ ꠉꠥꠡ꠆ꠔ, ꠖꠥꠁꠅ ꠉꠣꠟ ꠀꠞ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠁꠝꠣꠝ ꠍꠣꠛꠞꠦ ꠖꠤꠛꠣꠄ, ꠁꠔꠣ ꠔꠣꠘ ꠙꠣꠅꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT18_4","006_18_4","DEU","18","4","4","ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠚꠡꠟ, ꠛꠣꠉꠣꠘꠞ ꠀꠋꠉꠥꠞ ꠕꠣꠇꠤ ꠛꠣꠘꠣꠁꠟ ꠙꠄꠟꠣ ꠡꠞꠛꠔ ꠀꠞ ꠎꠄꠔꠥꠘ ꠕꠣꠇꠤ ꠛꠣꠘꠣꠁꠟ ꠔꠦꠟꠞ ꠙꠄꠟꠣ ꠅꠋꠡ, ꠍꠣꠉꠟ-ꠝꠦꠠꠣꠞ ꠙꠄꠟꠣ ꠛꠣꠞ ꠇꠣꠐꠣ ꠞꠥꠝꠣ ꠁꠝꠣꠝ ꠍꠣꠛꠞꠦ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT18_5","006_18_5","DEU","18","5","5","ꠎꠣꠘ ꠔ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠀꠟꠉ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤꠞ ꠇꠣꠝꠅ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT18_6","006_18_6","DEU","18","6","6","“ꠀꠞ ꠁꠍꠞꠣꠁꠟ ꠖꠦꠡꠞ ꠎꠦꠇꠥꠘꠥ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠇꠥꠘꠥ ꠀꠅꠟꠣꠖ ꠎꠥꠖꠤ ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠀꠄ, ");
INSERT INTO syls_vpl VALUES ("DT18_7","006_18_7","DEU","18","7","7","ꠔꠦ ꠢꠦ-ꠅ ꠔꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠣꠈꠣꠘ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤꠞ ꠇꠣꠝ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("DT18_8","006_18_8","DEU","18","8","8","ꠛꠣꠇꠤ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠢꠦ-ꠅ ꠔꠣꠞ ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠞ ꠛꠣꠐ ꠙꠣꠁꠛ, ꠄꠞꠟꠉꠦ ꠔꠣꠞ ꠝꠃꠞꠡꠤ ꠍꠣꠝꠣꠘꠣ ꠛꠦꠌꠣꠞ ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠅ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT18_9","006_18_9","DEU","18","9","9","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠞꠣ, ꠢꠃ ꠖꠦꠡꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠦ ꠎꠦꠟꠣ ꠎꠊꠁꠘ꠆ꠘ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠢꠤꠇꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT18_10","006_18_10","DEU","18","10","10","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠣꠘꠥ ꠁꠟꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠘꠣ ꠝꠤꠟꠦ, ꠎꠦꠉꠥꠄ ꠔꠣꠞ ꠘꠤꠎꠞ ꠀꠅꠟꠣꠖꠞꠦ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠛꠟꠤ ꠖꠦꠄ, ꠔꠣꠛꠎꠣꠔꠤ ꠝꠘꠔ꠆ꠞ ꠙꠠꠦ, ꠉꠘꠣ-ꠛꠣꠍꠣ ꠇꠞꠦ, ꠎꠣꠖꠥ-ꠐꠥꠘꠣ ꠇꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("DT18_11","006_18_11","DEU","18","11","11","ꠎꠦꠉꠥꠄ ꠔꠘꠔ꠆ꠞ-ꠝꠘꠔ꠆ꠞ ꠌꠣꠟꠣꠄ, ꠎꠤꠘ-ꠜꠥꠔ-ꠙꠦꠞꠔ ꠡꠣꠗꠘ ꠇꠞꠦ ꠀꠞ ꠝꠥꠞ꠆ꠖꠣꠞ ꠞꠥꠢꠖꠤ ꠀꠎꠤꠞꠣꠔ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("DT18_12","006_18_12","DEU","18","12","12","ꠁꠔꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠣꠝ ꠎꠦꠉꠥꠄ ꠇꠞꠦ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠦ ꠊꠤꠘ ꠇꠞꠂꠘ। ꠅꠔꠣ ꠇꠣꠝ ꠇꠞꠣꠄ ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("DT18_13","006_18_13","DEU","18","13","13","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠞ꠆ꠖꠥꠡꠤ ꠞꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("DT18_14","006_18_14","DEU","18","14","14","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠞꠣꠄ, ꠁꠔꠣ ꠔ ꠎꠣꠖꠥꠉꠤꠞ ꠀꠞ ꠉꠘꠇ ꠅꠇꠟꠞ ꠇꠕꠣꠄ ꠌꠟꠦ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠘꠤꠡꠦꠗ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT18_15","006_18_15","DEU","18","15","15","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ, ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠝꠣꠎ ꠕꠣꠇꠤ, ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠎꠘ ꠘꠛꠤ ꠙꠣꠑꠣꠁꠛꠣ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠄꠘ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT18_16","006_18_16","DEU","18","16","16","ꠢꠃ ꠔꠥꠞ ꠙꠣꠠꠞ ꠗꠣꠞꠅ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠎꠦ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠍꠟꠣꠄ, ꠢꠃ ꠖꠤꠘ ꠔ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠝꠣꠋꠉꠤꠀ ꠇꠁꠍꠟꠣꠄ, ꠀꠝꠞꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠝꠥꠈꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠔꠣꠘ ꠘꠥꠞꠞ ꠀꠉꠥꠁꠘꠅ ꠀꠞ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠀꠞꠘꠣꠄ ꠀꠝꠞꠣ ꠝꠞꠤꠎꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT18_17","006_18_17","DEU","18","17","17","“ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠔꠣꠞꠣ ꠑꠤꠇ ꠝꠣꠔꠃ ꠝꠣꠔꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT18_18","006_18_18","DEU","18","18","18","ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠜꠣꠁꠀꠁꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠎꠘ ꠘꠛꠤ ꠙꠣꠑꠣꠁꠝꠥ, ꠄꠘ ꠝꠥꠈꠅ ꠀꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠡꠞꠤꠚ ꠖꠤꠝꠥ, ꠀꠞ ꠀꠝꠤ ꠄꠘꠞꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠢꠤꠇꠣꠁ ꠖꠤꠝꠥ, ꠄꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠔꠣ ꠎꠣꠘꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT18_19","006_18_19","DEU","18","19","19","ꠀꠞ ꠀꠝꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠅꠇꠟ ꠛꠣꠔꠣꠁꠛꠣ, ꠘꠣ-ꠝꠣꠘꠞꠣ ꠅꠇꠟꠞꠦ ꠀꠝꠤ ꠖꠣꠄꠁ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT18_20","006_18_20","DEU","18","20","20","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠁꠍꠤ ꠘꠣ ꠇꠥꠘꠥ ꠘꠛꠤꠄ ꠎꠥꠖꠤ ꠛꠖ ꠡꠣꠅꠡ ꠇꠞꠤ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠇꠣꠟꠣꠝ ꠛꠣꠔꠣꠄ, ꠛꠣ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠘꠣꠝ ꠟꠁꠀ ꠁꠟꠣꠈꠣꠘ ꠝꠣꠔ ꠝꠣꠔꠦ, ꠔꠦ ꠢꠦ ꠝꠞꠔꠦꠃ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT18_21","006_18_21","DEU","18","21","21","“ꠅꠈꠘ ꠇꠥꠘꠥ ꠛꠥꠟꠤ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ ꠌꠤꠘ꠆ꠔꠣ ꠀꠁꠔ ꠙꠣꠞꠦ, ꠁꠈꠣꠘ ꠝꠣꠛꠥꠖꠦ ꠛꠣꠔꠣꠁꠍꠂꠘ ꠇꠤ ꠘꠣ, ꠇꠤꠟꠣ ꠛꠥꠎꠝꠥ? ");
INSERT INTO syls_vpl VALUES ("DT18_22","006_18_22","DEU","18","22","22","ꠄꠞꠟꠣꠉꠤ ꠢꠥꠘꠅ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ ꠟꠁꠀ ꠇꠥꠘꠥ ꠘꠛꠤꠄ ꠇꠥꠘ꠆ꠔꠣ ꠇꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠁꠔꠣ ꠘꠣ ꠚꠟꠦ, ꠛꠣ ꠅꠟꠣ ꠘꠣ ꠊꠐꠦ, ꠔꠦ ꠛꠥꠎꠤꠟꠤꠅ ꠁꠈꠣꠘ ꠝꠣꠛꠥꠖꠞ ꠇꠕꠣ ꠘꠣꠄ। ꠢꠃ ꠘꠛꠤꠄ ꠔꠣꠞ ꠛꠖ ꠡꠣꠅꠡꠦ ꠁꠔꠣ ꠇꠁꠍꠦ, ꠁꠟꠣꠈꠣꠘ ꠎꠘꠞꠦ ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("DT19_1","006_19_1","DEU","19","1","1","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠢꠘꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠔꠣꠁꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠣꠞꠣꠞ ꠛꠣꠠꠤ-ꠊꠞ ꠀꠞ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠁꠀ ꠛꠡꠔ ꠇꠞꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT19_2","006_19_2","DEU","19","2","3","ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠅꠃ ꠎꠝꠤꠘꠞꠦ ꠔꠤꠘ ꠛꠣꠐꠦ ꠛꠣꠐꠤꠅ, ꠀꠞ ꠄꠇꠐꠣ ꠄꠇꠐꠣ ꠇꠞꠤ ꠝꠥꠐ ꠔꠤꠘꠐꠣ ꠐꠣꠃꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠀꠟꠉ ꠇꠞꠤꠅ, ꠀꠞ ꠅꠔꠣ ꠐꠣꠃꠘꠅ ꠎꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠞꠣꠡ꠆ꠔꠣ ꠎꠥꠁꠔ-ꠎꠣꠁꠔ ꠞꠣꠈꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠅꠘꠤꠌ꠆ꠍꠣꠄ ꠇꠦꠃꠞꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠞ ꠈꠥꠘꠤ ꠜꠣꠉꠤꠀ ꠉꠤꠀ ꠢꠃ ꠐꠣꠃꠘꠅ ꠛꠘꠛꠣꠡꠤ ꠅꠁꠀ ꠀꠡꠞꠄ ꠟꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT19_4","006_19_4","DEU","19","4","4","“ꠝꠘꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠁꠋꠡꠣ-ꠖꠥꠡꠝꠘꠤ ꠍꠣꠠꠣ ꠁꠌ꠆ꠍꠣ ꠘꠣ ꠇꠞꠤꠀ ꠀꠈꠔꠣ ꠎꠥꠖꠤ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞꠦ ꠈꠥꠘ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠅꠃ ꠈꠥꠘꠤ ꠜꠣꠉꠤꠀ ꠉꠤꠀ ꠔꠣꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠛꠘꠛꠣꠡꠤ ꠐꠣꠃꠘꠅ ꠀꠡꠞꠄ ꠟꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT19_5","006_19_5","DEU","19","5","5","ꠝꠘꠅ ꠇꠞꠅ, ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠖꠥꠍꠞꠣ ꠎꠘꠞ ꠟꠉ ꠅꠁꠀ ꠎꠋꠉꠟꠅ ꠟꠣꠇꠠꠤ ꠇꠣꠐꠣꠔ ꠉꠦꠟ, ꠉꠤꠀ ꠇꠥꠠꠣꠟꠖꠤ ꠉꠣꠍ ꠇꠣꠐꠤꠛꠣꠞ ꠛꠣꠟꠣ ꠀꠈꠔꠣꠃ ꠇꠥꠠꠣꠟꠞ ꠀꠍꠣꠞꠤ ꠕꠣꠇꠤ ꠇꠥꠠꠣꠟ ꠍꠥꠐꠤꠀ, ꠖꠥꠍꠞꠣ ꠎꠘꠞ ꠉꠔꠞꠅ ꠟꠣꠉꠤꠀ ꠢꠦ ꠝꠞꠤꠉꠦꠟ, ꠅꠃ ꠢꠣꠟꠔꠦ ꠈꠥꠘꠤ ꠉꠤꠀ ꠔꠣꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠀꠡꠞꠄ ꠐꠣꠃꠘꠅ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT19_6","006_19_6","DEU","19","6","6","ꠀꠞꠘꠣꠄ ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠟꠅꠞꠣꠄ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠛꠖꠟꠣ ꠟꠁꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠅꠃ ꠝꠣꠘꠡꠞꠦ ꠗꠞꠔ ꠌꠣꠁꠛ, ꠀꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠀꠡꠞꠄ ꠐꠣꠃꠘ ꠗꠣꠞꠅ ꠘꠣ ꠞꠁꠟꠦ ꠔꠣꠞꠦ ꠗꠞꠤꠀ ꠝꠣꠞꠤꠟꠔ ꠙꠣꠞꠦ। ꠀꠍꠟꠦ ꠔ ꠢꠤ ꠛꠦꠐꠣꠄ ꠁꠌ꠆ꠍꠣ ꠇꠞꠤꠀ ꠈꠥꠘ ꠇꠞꠍꠦ ꠘꠣ, ꠢꠦ ꠡꠣꠎꠣ ꠙꠣꠁꠛꠣꠞ ꠇꠕꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT19_7","006_19_7","DEU","19","7","7","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠤꠘꠐꠣ ꠀꠡꠞꠄ ꠐꠣꠃꠘ ꠀꠟꠉ ꠇꠞꠤ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT19_8","006_19_8","DEU","19","8","8","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠟꠉꠦ ꠇꠍꠝ ꠝꠣꠚꠤꠇ ꠎꠣꠉꠣ ꠛꠣꠠꠣꠁꠀ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("DT19_9","006_19_9","DEU","19","9","9","ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠀꠞꠅ ꠔꠤꠘꠈꠣꠘ ꠀꠡꠞꠄ ꠐꠣꠃꠘ ꠀꠟꠉ ꠇꠞꠤ ꠞꠣꠈꠛꠣꠄ। ꠈꠣꠟꠤ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠁꠔꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠅ ꠀꠞ ꠎꠥꠖꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ ꠀꠞ ꠔꠣꠘ ꠙꠕꠦ ꠌꠟꠅ, ꠔꠦ ꠔꠣꠁꠘ ꠘꠤꠌ꠆ꠌꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠛꠣꠃ। ");
INSERT INTO syls_vpl VALUES ("DT19_10","006_19_10","DEU","19","10","10","ꠅꠃ ꠀꠡꠞꠄ ꠐꠣꠃꠘ ꠞꠣꠈꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠞꠣ, ꠢꠃ ꠎꠝꠤꠘꠅ ꠎꠣꠘꠥ ꠇꠥꠘꠥ ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞ ꠟꠃ ꠘꠣ ꠙꠠꠦ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠈꠥꠘꠞ ꠖꠣꠄꠁ ꠘꠣ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("DT19_11","006_19_11","DEU","19","11","11","“ꠅꠁꠟꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠞꠣꠉ-ꠉꠥꠍꠣ, ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠀꠞꠇ ꠎꠘꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠃꠔ ꠙꠣꠔꠤꠀ ꠞꠄ, ꠛꠣꠖꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠤꠀ ꠈꠥꠘ ꠇꠞꠤꠟꠣꠄ, ꠀꠞ ꠅꠃ ꠈꠥꠘꠤ ꠉꠤꠀ ꠇꠥꠘꠥ ꠀꠡꠞꠄ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠁ ꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT19_12","006_19_12","DEU","19","12","12","ꠔꠦ ꠔꠣꠞ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠝꠥꠞꠛ꠆ꠛꠤ-ꠡꠣꠟꠤꠡ ꠅꠇꠟꠦ, ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠁꠀ ꠔꠣꠞꠦ ꠗꠞꠣꠁ ꠀꠘꠤꠀ, ꠅꠉꠥꠞꠦ ꠝꠣꠞꠤꠟꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠈꠥꠘꠞ ꠛꠖꠟꠣ ꠟꠅꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT19_13","006_19_13","DEU","19","13","13","ꠅꠃ ꠈꠥꠘꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞꠦ ꠈꠥꠘꠞ ꠖꠣꠄ-ꠜꠣꠞ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT19_14","006_19_14","DEU","19","14","14","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠢꠃ ꠖꠦꠡꠞ ꠎꠝꠤꠘꠞ ꠙꠥꠞꠣꠘ ꠀꠝꠟꠅ ꠉꠣꠠꠣ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠇꠥꠘꠥ ꠡꠤꠝꠣꠘꠣ ꠈꠥꠐꠤ ꠃꠘ꠆ꠘꠁꠡ-ꠛꠤꠡ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT19_15","006_19_15","DEU","19","15","15","“ꠇꠦꠃꠞꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠉꠥꠘꠣ ꠛꠣ ꠅꠙꠞꠣꠗꠞ ꠘꠣꠟꠤꠡ ꠀꠁꠟꠦ, ꠔꠦ ꠈꠣꠟꠤ ꠄꠇꠎꠘꠞ ꠡꠣꠇ꠆ꠇꠤ ꠢꠥꠘꠤꠀ ꠞꠣꠄ ꠖꠤꠅ ꠘꠣ, ꠖꠥꠁ ꠛꠣ ꠔꠤꠘ ꠎꠘꠞ ꠡꠣꠇ꠆ꠇꠤ ꠙꠞꠝꠣꠘ ꠟꠁꠀ ꠛꠤꠌꠣꠞ-ꠡꠣꠟꠤꠡꠞ ꠞꠣꠄ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT19_16","006_19_16","DEU","19","16","16","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠀꠞꠇ ꠎꠘꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠖꠦꠄ, ");
INSERT INTO syls_vpl VALUES ("DT19_17","006_19_17","DEU","19","17","17","ꠔꠦ ꠅꠃ ꠛꠣꠖꠤ ꠀꠞ ꠛꠤꠛꠣꠖꠤ ꠖꠥꠁꠅ ꠙꠇ꠆ꠇ ꠢꠃ ꠀꠝꠟꠞ ꠢꠣꠇꠤꠝ ꠀꠞ ꠁꠝꠣꠝ ꠍꠣꠛ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT19_18","006_19_18","DEU","19","18","18","ꠛꠣꠖꠦ ꠡꠣꠟꠤꠡ ꠅꠇꠟꠦ ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠁꠔꠣꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠛꠣ, ꠔꠣꠟ꠆ꠟꠣꠡꠤ ꠇꠣꠟꠅ ꠎꠥꠖꠤ ꠗꠞꠣ ꠙꠠꠦ ꠢꠦ ꠔꠣꠞ ꠀꠙꠘ ꠎꠣꠔꠤꠞ ꠜꠣꠁꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠤꠍꠣ ꠘꠣꠟꠤꠡ ꠖꠤꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("DT19_19","006_19_19","DEU","19","19","19","ꠔꠦ ꠅꠃ ꠘꠣꠟꠤꠡ ꠖꠤꠀ ꠢꠦ ꠢꠃ ꠎꠘꠞ ꠎꠦꠔꠣ ꠈꠦꠔꠤ ꠇꠞꠔ ꠌꠣꠁꠍꠤꠟ, ꠔꠥꠝꠞꠣ ꠅꠉꠥꠞ ꠅꠃꠟꠣ ꠈꠦꠔꠤ ꠇꠞꠤꠅ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT19_20","006_19_20","DEU","19","20","20","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠛꠣꠇꠤ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠒꠞꠣꠁꠛꠣ, ꠔꠦꠃ ꠁꠟꠣ ꠇꠣꠝ ꠀꠞ ꠇꠦꠃ ꠇꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT19_21","006_19_21","DEU","19","21","21","ꠁꠟꠣ ꠅꠙꠞꠣꠗꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠎꠣꠘ, ꠌꠃꠈꠞ ꠛꠖꠟꠣ ꠌꠃꠈ, ꠖꠣꠔꠞ ꠛꠖꠟꠣ ꠖꠣꠔ, ꠀꠔꠞ ꠛꠖꠟꠣ ꠀꠔ, ꠙꠣꠅꠞ ꠛꠖꠟꠣ ꠙꠣꠅ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT20_1","006_20_1","DEU","20","1","1","“ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠔ ꠉꠤꠀ ꠎꠥꠖꠤ ꠖꠦꠈꠅ, ꠔꠣꠞꠣꠞ ꠊꠥꠠꠣ, ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ, ꠔꠣꠞꠣꠞ ꠍꠤꠙꠣꠁ ꠔꠥꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠦꠡꠤ, ꠔꠦ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠎꠣꠘ ꠔ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT20_2","006_20_2","DEU","20","2","2","ꠟꠣꠠꠣꠁꠞ ꠘꠤꠅꠔꠦ ꠛꠣꠞꠘꠤꠞ ꠀꠉꠦ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠀꠁꠀ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠇꠁꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("DT20_3","006_20_3","DEU","20","3","3","ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠀꠁꠎ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄ, ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞꠦ ꠇꠝꠎꠥꠞ ꠛꠣꠘꠣꠁꠅ ꠘꠣ, ꠒꠞꠣꠁꠅ ꠘꠣ, ꠒꠞꠣꠁꠀ ꠘꠤꠞꠣꠡ ꠅꠁꠅ ꠘꠣ, ꠖꠥꠡꠝꠘꠞ ꠒꠞꠦ ꠇꠣꠙꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT20_4","006_20_4","DEU","20","4","4","ꠖꠥꠡꠝꠘꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁꠔ ꠎꠤꠔꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("DT20_5","006_20_5","DEU","20","5","5","“ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞ ꠅꠚꠤꠡꠣꠞ ꠅꠇꠟ ꠀꠁꠀ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠍꠤꠙꠣꠁ ꠀꠍꠦ ꠘꠤ, ꠎꠦꠉꠥꠄ ꠘꠄꠀ ꠊꠞ ꠛꠣꠘꠣꠁꠀ ꠢꠣꠞꠤ, ꠅꠃ ꠊꠞꠅ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀꠞ ꠅꠘꠥꠡ꠆ꠑꠣꠘ ꠛꠣꠇꠤ ꠞꠣꠈꠍꠦ? ꠔꠦ ꠔꠥꠝꠤ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ, ꠀꠞꠘꠣꠄ ꠟꠣꠠꠣꠁꠔ ꠉꠤꠀ ꠝꠞꠤꠉꠦꠟꠦ ꠖꠥꠍꠞꠣ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠅꠃ ꠅꠘꠥꠡ꠆ꠑꠣꠘ ꠇꠞꠤꠟꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT20_6","006_20_6","DEU","20","6","6","ꠀꠞ ꠇꠥꠘꠥ ꠍꠤꠙꠣꠁ ꠀꠍꠦ ꠘꠤ, ꠎꠦꠉꠥꠄ ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘ ꠇꠞꠤꠀ ꠙꠄꠟꠣꠇꠥꠞ ꠚꠟ ꠘꠣ ꠈꠣꠁꠀ ꠟꠣꠠꠣꠁꠔ ꠀꠁꠍꠦ? ꠔꠦ ꠔꠥꠝꠤꠅ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ, ꠀꠞꠘꠣꠄ ꠟꠣꠠꠣꠁꠔ ꠉꠤꠀ ꠝꠞꠤꠉꠦꠟꠦ ꠖꠥꠍꠞꠣ ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠔꠥꠝꠣꠞ ꠛꠣꠉꠣꠘꠞ ꠚꠟ ꠈꠣꠁꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT20_7","006_20_7","DEU","20","7","7","ꠀꠞ ꠔꠥꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠀꠈꠔ ꠇꠞꠤꠀ ꠢꠣꠞꠤ ꠛꠣꠡꠞ ꠞꠣꠁꠔ ꠛꠣꠇꠤ ꠞꠁꠍꠦ ꠘꠤ? ꠔꠦ ꠔꠥꠝꠤꠅ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ, ꠀꠞꠘꠣꠄ ꠟꠣꠠꠣꠁꠔ ꠉꠤꠀ ꠝꠞꠤꠉꠦꠟꠦ ꠖꠥꠍꠞꠣ ꠛꠦꠐꠣꠄ ꠀꠁꠀ ꠅꠃ ꠇꠁꠘꠣꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT20_8","006_20_8","DEU","20","8","8","ꠅꠃ ꠅꠚꠤꠡꠣꠞ ꠅꠇꠟꠦ ꠀꠞꠅ ꠎꠤꠇꠣꠁꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠍꠤꠙꠣꠁ ꠀꠍꠦ ꠘꠤ, ꠎꠦꠉꠥꠞ ꠎꠣꠘꠅ ꠒꠞ ꠇꠞꠦꠞ, ꠝꠘꠦ ꠇꠣꠙꠦꠞ? ꠔꠦ ꠔꠥꠝꠤꠅ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ, ꠀꠞꠘꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠟꠉꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠅ ꠇꠝꠎꠥꠞ ꠅꠁꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT20_9","006_20_9","DEU","20","9","9","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠅꠚꠤꠡꠣꠞ ꠅꠇꠟꠞ ꠎꠤꠇꠣꠘꠤ ꠡꠦꠡ ꠅꠁꠟꠦ, ꠔꠣꠞꠣ ꠍꠤꠙꠣꠁ ꠖꠟ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞ ꠛꠅꠀꠁꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT20_10","006_20_10","DEU","20","10","10","“ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠎꠦꠛꠟꠣ ꠢꠃ ꠎꠣꠉꠣꠞ ꠗꠣꠞꠅ ꠎꠣꠁꠛꠣꠄ, ꠉꠤꠀ ꠢꠘꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠀ ꠇꠁꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠀꠙꠥꠡꠦ ꠔꠥꠝꠞꠣꠞ ꠔꠣꠛꠦꠖꠣꠞꠤ ꠝꠣꠘꠤꠟꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("DT20_11","006_20_11","DEU","20","11","11","ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠞꠣꠎꠤ ꠅꠁꠀ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠉꠦꠁꠐ ꠈꠥꠟꠤꠀ ꠖꠤꠟꠣꠁꠘ, ꠔꠦ ꠔꠣꠞꠣ ꠢꠇꠟ ꠔꠥꠝꠞꠣꠞ ꠞꠣꠁꠅꠔ ꠛꠘꠤꠀ ꠈꠣꠎꠘꠣ ꠖꠤꠛꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT20_12","006_20_12","DEU","20","12","12","ꠀꠞ ꠞꠣꠎꠤ ꠘꠣ ꠅꠁꠀ ꠟꠣꠠꠣꠁ ꠇꠞꠔ ꠌꠣꠁꠟꠦ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠐꠣꠃꠘꠞꠦ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT20_13","006_20_13","DEU","20","13","13","ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠢꠃ ꠎꠣꠉꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT20_14","006_20_14","DEU","20","14","14","ꠅꠁꠟꠦ ꠢꠘꠞ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ, ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠙꠡꠥꠞ ꠙꠣꠟ ꠀꠞ ꠢꠃ ꠎꠣꠉꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠉꠘꠤꠝꠔꠞ ꠝꠣꠟ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠖꠥꠡꠝꠘꠞ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠉꠘꠤꠝꠔꠞ ꠝꠣꠟ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠔꠔꠣ ꠖꠣꠘ ꠇꠞꠛꠣ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠜꠥꠉ-ꠖꠈꠟ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT20_15","006_20_15","DEU","20","15","15","ꠎꠦꠔꠣ ꠐꠣꠃꠘ ꠅꠇꠟ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠇ꠆ꠇꠣ ꠖꠥꠞꠁ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠐꠣꠃꠘ ꠘꠣꠄ, ꠅꠔꠣ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT20_16","006_20_16","DEU","20","16","16","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠎꠦꠔꠣ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠖꠤꠞꠣ, ꠁꠔꠣ ꠇꠥꠘꠥꠉꠥꠞꠦꠃ ꠎꠤꠘ꠆ꠖꠣ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT20_17","006_20_17","DEU","20","17","17","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ, ꠢꠤꠐ꠆ꠐꠤ, ꠀꠝꠥꠞꠤ, ꠇꠦꠘꠣꠘꠤ, ꠚꠣꠞꠤꠎꠤ, ꠢꠤꠛ꠆ꠛꠤ ꠀꠞ ꠎꠤꠛꠥꠎꠤ ꠅꠇꠟꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠙꠣꠔ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT20_18","006_20_18","DEU","20","18","18","ꠀꠞꠘꠣꠄ ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞꠦ ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠎꠔ ꠎꠊꠁꠘ꠆ꠘ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠂꠘ, ꠔꠣꠞꠣꠞ ꠅꠔꠣ ꠔꠥꠝꠞꠣꠅ ꠢꠤꠇꠤꠛꠣꠄ, ꠢꠤꠇꠤꠀ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT20_19","006_20_19","DEU","20","19","19","“ꠇꠥꠘꠥ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁꠔ ꠉꠤꠀ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠛꠃꠔ ꠟꠣꠝ꠆ꠛꠣ ꠡꠝꠄ ꠗꠞꠤ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠅ, ꠅꠃ ꠡꠝꠄ ꠢꠘꠞ ꠚꠟꠖꠣꠞ ꠇꠥꠘꠥꠎꠣꠔ ꠉꠣꠍ-ꠙꠣꠟꠣ ꠇꠥꠠꠣꠟꠖꠤ ꠇꠣꠐꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞ ꠚꠟ ꠈꠣꠁꠅ, ꠅꠁꠟꠦ ꠉꠣꠍ ꠇꠣꠐꠤꠅ ꠘꠣ। ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠘꠣꠄ ꠎꠦꠘ ꠅꠔꠣꠞꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠔꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT20_20","006_20_20","DEU","20","20","20","ꠔꠣ-ꠅ ꠎꠦꠔꠣ ꠉꠣꠍ ꠇꠥꠘꠥ ꠚꠟ-ꠚꠟꠣꠖꠤꠞ ꠉꠣꠍ ꠘꠣꠄ, ꠁꠔꠣ ꠇꠣꠐꠤꠀ ꠢꠘꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠟꠣꠠꠣꠁꠔ ꠀꠞꠣꠘꠤꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠅꠔꠣ ꠖꠤꠀ ꠀꠔꠤꠀꠞ ꠛꠣꠘꠣꠁꠀ ꠢꠣꠝꠟꠣ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT21_1","006_21_1","DEU","21","1","1","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠢꠘꠅ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠟꠣꠡ ꠙꠠꠤ ꠞꠁꠍꠦ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠀꠞ ꠔꠣꠞ ꠈꠥꠘꠤꠞ ꠇꠥꠘꠥ ꠙꠞꠤꠌꠄ ꠘꠣ ꠝꠤꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("DT21_2","006_21_2","DEU","21","2","2","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠢꠣꠇꠤꠝ-ꠡꠣꠟꠤꠡ ꠅꠇꠟ ꠛꠣꠞ ꠅꠁ ꠀꠁꠀ, ꠝꠣꠙꠤꠀ ꠖꠦꠈꠛꠣ ꠅꠃ ꠟꠣꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘ ꠉꠣꠃ ꠇꠔꠈꠣꠘ ꠖꠥꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("DT21_3","006_21_3","DEU","21","3","3","ꠖꠦꠈꠤꠀ ꠢꠇꠟ ꠕꠣꠇꠤ ꠇꠣꠍꠣꠞ ꠉꠣꠃꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠄꠇ ꠉꠣꠁ-ꠛꠣꠍꠥꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠎꠦꠐꠣ ꠖꠤꠀ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ-ꠇꠣꠎ, ꠀꠟ-ꠌꠣꠡ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT21_4","006_21_4","DEU","21","4","4","ꠛꠣꠖꠦ ꠢꠘꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠅꠃ ꠛꠣꠍꠥꠞ ꠟꠁꠀ ꠅꠝꠘ ꠄꠇ ꠎꠣꠉꠣꠔ ꠎꠣꠁꠛꠣ, ꠎꠦꠈꠣꠘꠅ ꠙꠣꠘꠤꠞ ꠚꠥꠔ ꠀꠟꠣ ꠈꠣꠟ ꠀꠍꠦ, ꠀꠞ ꠈꠣꠟꠞ ꠙꠣꠞꠞ ꠎꠝꠤꠘꠅ ꠇꠥꠘꠥꠎꠣꠔ ꠀꠟ-ꠌꠣꠡ ꠛꠣ ꠀꠟꠤ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠍꠦ ꠘꠣ। ꠢꠘꠅ ꠉꠤꠀ ꠅꠃ ꠛꠣꠍꠥꠞꠞ ꠉꠞ꠆ꠖꠘꠣ ꠜꠣꠋꠉꠤꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT21_5","006_21_5","DEU","21","5","5","ꠛꠣꠖꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠝꠣꠝ ꠅꠇꠟ ꠅꠃ ꠎꠣꠉꠣꠔ ꠀꠁꠛꠣ। ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠣ, ꠔꠣꠘ ꠘꠣꠝꠦ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠖꠥꠀ-ꠖꠥꠞꠥꠖ ꠇꠞꠣ, ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠚꠤꠔꠘꠣ-ꠚꠍꠣꠖ, ꠝꠣꠞꠣ-ꠝꠣꠞꠤꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("DT21_6","006_21_6","DEU","21","6","6","ꠛꠣꠍꠥꠞꠞ ꠉꠞ꠆ꠖꠘꠣ ꠜꠣꠋꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠉꠣꠃꠞ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ, ꠅꠃ ꠈꠣꠟꠞ ꠙꠣꠘꠤꠖꠤ ꠛꠣꠍꠥꠞꠞ ꠃꠙꠞꠦ ꠔꠣꠞꠣꠞ ꠀꠔ ꠗꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT21_7","006_21_7","DEU","21","7","7","ꠗꠁꠀ ꠇꠁꠛꠣ, ꠅꠃ ꠝꠣꠘꠥꠡ ꠈꠥꠘ ꠅꠁꠔꠦ ꠀꠝꠞꠣ ꠇꠦꠃ ꠖꠦꠈꠍꠤ ꠘꠣ, ꠀꠝꠞꠣꠞ ꠀꠔꠦ ꠔꠣꠞꠦ ꠝꠣꠞꠍꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT21_8","006_21_8","DEU","21","8","8","ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠀꠎꠣꠖ ꠇꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠔꠥꠝꠤ ꠅꠈꠘ ꠝꠣꠚꠤ ꠖꠦꠅ, ꠈꠥꠘ ꠅꠀ ꠅꠃ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠎꠘꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠁ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠤ ꠖꠣꠄꠁ ꠇꠞꠤꠅ ꠘꠣ। ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠟꠦ ꠢꠃ ꠈꠥꠘꠞ ꠖꠣꠄ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT21_9","006_21_9","DEU","21","9","9","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠝꠣꠘꠡꠞ ꠈꠥꠘꠞ ꠖꠣꠄ-ꠜꠣꠞ ꠢꠞꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠟꠣ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣ ꠅꠟꠣꠃ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("DT21_10","006_21_10","DEU","21","10","10","“ꠖꠥꠡꠝꠘꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁꠔ ꠉꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠤꠛꠣ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT21_11","006_21_11","DEU","21","11","11","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠡꠥꠘ꠆ꠖꠞꠤ ꠛꠦꠐꠤꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠡꠤꠇ ꠛꠘꠤꠎꠣꠄ, ꠀꠞ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("DT21_12","006_21_12","DEU","21","12","12","ꠔꠦ ꠔꠣꠁꠞꠦ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠀꠘꠛꠣꠄ। ꠛꠣꠖꠦ ꠔꠣꠁ ꠘꠤꠎꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠁꠛ, ꠘꠃꠇ ꠇꠣꠐꠤꠛ, ");
INSERT INTO syls_vpl VALUES ("DT21_13","006_21_13","DEU","21","13","13","ꠀꠞ ꠛꠘ꠆ꠖꠤ ꠇꠣꠟꠤꠘ ꠢꠣꠟꠔꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠣꠟꠣꠁꠀ, ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠞꠁꠀ ꠔꠣꠁꠞ ꠝꠣ-ꠛꠣꠚꠞ ꠟꠣꠉꠤ ꠙꠥꠞꠣ ꠄꠇ ꠝꠣꠡ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ, ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠛ। ꠅꠃ ꠄꠇ ꠝꠣꠡ ꠛꠣꠖꠦ ꠔꠣꠁꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠥꠝꠞꠣ ꠎꠣꠝꠣꠁ-ꠛꠃ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT21_14","006_21_14","DEU","21","14","14","ꠛꠤꠀ-ꠡꠣꠖꠤꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠤ ꠅꠃ ꠛꠦꠐꠤꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠤ ꠘꠣ ꠅꠅ, ꠔꠦ ꠔꠣꠁꠞꠦ ꠔꠣꠁꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠍꠣꠠꠤ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠔꠣꠁꠞꠦ ꠛꠣꠘ꠆ꠖꠤ ꠢꠤꠡꠣꠛꠦ ꠞꠣꠈꠣ ꠛꠣ ꠛꠦꠌꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠔꠥꠝꠣꠞ ꠘꠣꠁ, ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠔꠣꠁꠞ ꠁꠎ꠆ꠎꠔ ꠘꠡ꠆ꠐ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("DT21_15","006_21_15","DEU","21","15","15","“ꠇꠥꠘꠥ ꠛꠦꠐꠣꠞ ꠎꠥꠖꠤ ꠖꠥꠁ ꠛꠃ ꠅꠄ, ꠀꠞ ꠛꠦꠐꠣꠄ ꠄꠇ ꠛꠃꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠖꠥꠍꠞꠣ ꠛꠃꠞꠦ ꠝꠣꠄꠀ ꠘꠣ ꠇꠞꠦ। ꠅꠃ ꠖꠥꠁꠅ ꠛꠃꠞ ꠊꠞꠅ ꠎꠥꠖꠤ ꠙꠥꠀꠂꠘ ꠅꠁꠘ, ꠄꠞ ꠝꠣꠎꠞ ꠛꠠ ꠙꠥꠀ ꠎꠥꠖꠤ ꠢꠃ ꠝꠣꠄꠀ ꠘꠣ ꠇꠞꠣ ꠛꠃꠞ ꠊꠞꠅ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("DT21_16","006_21_16","DEU","21","16","16","ꠔꠦ ꠔꠣꠘ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠛꠣꠐꠤꠀ ꠖꠤꠛꠣꠞ ꠇꠣꠟꠅ, ꠔꠣꠘ ꠝꠣꠄꠀꠞ ꠛꠃꠞ ꠊꠞꠞ ꠙꠥꠀꠞꠦ ꠛꠠ ꠙꠥꠀꠞ ꠢꠇ ꠖꠤꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT21_17","006_21_17","DEU","21","17","17","ꠛꠞꠋ ꠛꠠ ꠙꠥꠀꠞꠦ ꠔꠣꠘ ꠅꠁꠘ꠆ꠘ ꠙꠥꠀꠂꠘ ꠕꠣꠇꠤ ꠒꠣꠛꠟ ꠖꠤꠔꠦ ꠅꠁꠛ। ꠢꠦ ꠔ ꠅꠁꠟ ꠔꠣꠘ ꠎꠥꠀꠘꠇꠤꠞ ꠙꠄꠟꠣ ꠚꠟ, ꠛꠠ ꠙꠥꠔꠞ ꠖꠣꠛꠤꠖꠣꠞ ꠈꠣꠟꠤ ꠢꠦ-ꠃ। ");
INSERT INTO syls_vpl VALUES ("DT21_18","006_21_18","DEU","21","18","18","“ꠇꠦꠃꠞꠞ ꠇꠥꠘꠥ ꠙꠥꠀꠄ ꠎꠥꠖꠤ ꠝꠣ-ꠛꠣꠚꠞ ꠇꠕꠣ ꠘꠣ ꠢꠥꠘꠦ, ꠝꠣ-ꠛꠣꠚꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠌꠟꠦ, ꠔꠣꠞꠣꠞ ꠛꠥꠎ-ꠡꠣꠡꠘ ꠘꠣ ꠝꠣꠘꠤꠀ ꠇꠥ-ꠙꠕꠦ ꠎꠣꠄꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("DT21_19","006_21_19","DEU","21","19","19","ꠔꠦ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠦ ꠔꠣꠞꠦ ꠗꠞꠤꠀ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠘꠤꠛꠣ, ꠔꠣꠞꠣꠞ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠉꠦꠁꠐꠞ ꠉꠦꠍꠦ ꠙꠣꠁꠘ꠆ꠌꠣꠁꠔꠤ ꠛꠂꠑꠇ ꠈꠣꠘꠣꠔ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT21_20","006_21_20","DEU","21","20","20","ꠘꠤꠀ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠛꠣ, ꠀꠝꠞꠣꠞ ꠅꠃ ꠙꠥꠀ ꠈꠥꠛ ꠘꠣꠚꠞꠝꠣꠘ ꠀꠞ ꠇꠥ-ꠙꠕꠤ ꠛꠘꠤꠉꠦꠍꠦ, ꠢꠦ ꠀꠝꠞꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠦ ꠘꠣ, ꠝꠖ ꠈꠣꠁꠀ ꠝꠣꠔꠟꠣꠝꠤ ꠇꠞꠦ, ꠀꠞ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠃꠠꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT21_21","006_21_21","DEU","21","21","21","ꠔꠦꠃ ꠢꠃ ꠐꠣꠃꠘꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠅꠟꠣꠈꠣꠘ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠛꠣꠄ। ꠀꠞ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠒꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT21_22","006_21_22","DEU","21","22","22","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠃꠔꠞ ꠡꠣꠎꠣ ꠙꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠅꠙꠞꠣꠗ ꠇꠞꠦ, ꠀꠞ ꠔꠣꠞꠦ ꠝꠣꠞꠣꠞ ꠛꠣꠖꠦ ꠟꠣꠡ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠟ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("DT21_23","006_21_23","DEU","21","23","23","ꠔꠦ ꠔꠣꠞ ꠟꠣꠡꠞꠦ ꠞꠣꠁꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠀ ꠞꠣꠈꠤꠅ ꠘꠣ, ꠖꠤꠘ ꠕꠣꠇꠔꠦꠃ ꠔꠣꠞꠦ ꠝꠣꠐꠤ ꠖꠤꠟꠣꠁꠅ। ꠎꠣꠘ ꠔ, ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠟ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠞꠣ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_1","006_22_1","DEU","22","1","1","“ꠔꠥꠝꠞꠣꠞ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠜꠣꠁꠞ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠎꠥꠖꠤ ꠙꠕ ꠀꠞꠣꠁꠀ ꠎꠣꠅꠀꠔ ꠖꠦꠈꠅ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠞꠣꠁ ꠘꠣ ꠕꠣꠇꠤꠀ, ꠁꠐꠣꠞꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠤꠀ ꠔꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍꠦ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT22_2","006_22_2","DEU","22","2","2","ꠅꠃ ꠝꠣꠟꠤꠇ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠗꠣꠞꠅ-ꠇꠣꠍꠞ ꠘꠣ ꠅꠄ, ꠛꠣ ꠅꠌꠤꠘꠣ ꠇꠥꠘꠥ ꠎꠘ ꠅꠄ, ꠔꠦ ꠁꠐꠣ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠘꠤꠛꠣꠄꠉꠤ, ꠛꠣꠖꠦ ꠢꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠇꠣꠘꠤꠔ ꠀꠁꠛ ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠦ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT22_3","006_22_3","DEU","22","3","3","ꠔꠥꠝꠞꠣꠞ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠜꠣꠁꠞ ꠉꠣꠗꠣ, ꠔꠣꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ, ꠛꠣ ꠔꠣꠞ ꠀꠞꠣꠁꠟ ꠎꠦꠇꠥꠘꠥ ꠍꠣꠝꠣꠘꠣ ꠙꠣꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠅꠟꠣ ꠇꠞꠤꠅ, ꠘꠤꠞꠣꠁ ꠢꠞꠤꠀ ꠎꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_4","006_22_4","DEU","22","4","4","“ꠔꠥꠝꠣꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁꠞ ꠇꠥꠘꠥ ꠉꠞꠥ-ꠉꠣꠗꠣ ꠙꠕꠞ ꠝꠣꠎꠦ ꠙꠠꠤꠉꠦꠍꠦ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠤ ꠢꠞꠤꠀ ꠎꠣꠁꠅ ꠘꠣ, ꠁꠐꠣ ꠃꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠗꠞꠤꠀ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT22_5","006_22_5","DEU","22","5","5","“ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠇꠣꠙꠠ ꠀꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠅ ꠘꠣ। ꠎꠦꠉꠤꠄ ꠁꠟꠣ ꠇꠣꠝ ꠇꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠦ ꠊꠤꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT22_6","006_22_6","DEU","22","6","6","“ꠙꠕꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠔꠦ ꠡꠝꠄ ꠇꠥꠘꠥ ꠉꠣꠍꠞ ꠒꠣꠟꠅ, ꠛꠣ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠙꠣꠈꠤꠞ ꠛꠣꠖꠣ ꠖꠦꠈꠟꠦ, ꠛꠣꠖꠣꠔ ꠇꠥꠘꠥ ꠙꠣꠈꠤꠄ ꠒꠤꠝꠅ ꠃꠝ ꠖꠦꠞ, ꠛꠣ ꠔꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠀꠍꠦ, ꠔꠦ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠔꠣꠞ ꠝꠣʼꠞꠦ ꠗꠞꠤꠀ ꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_7","006_22_7","DEU","22","7","7","ꠡꠈ ꠅꠁꠟꠦ ꠛꠣꠁꠌ꠆ꠌꠣ ꠘꠤꠅꠉꠤ, ꠅꠁꠟꠦ ꠔꠣꠞ ꠝꠣʼꠞꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠍꠣꠠꠤꠀ ꠎꠣꠁꠅ। ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ, ꠔꠥꠝꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠛꠣꠠꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT22_8","006_22_8","DEU","22","8","8","“ꠘꠄꠀ ꠊꠞ ꠛꠣꠘꠣꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠊꠞꠞ ꠍꠣꠔꠞ ꠃꠙꠞꠦ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠛꠦꠠꠣ ꠖꠤꠛꠣꠄ, ꠀꠞꠘꠣꠄ ꠍꠣꠔꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠇꠦꠃ ꠙꠠꠤꠀ ꠝꠞꠤꠉꠦꠟꠦ ꠔꠥꠝꠞꠣ ꠈꠥꠘꠞ ꠖꠣꠄꠁ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT22_9","006_22_9","DEU","22","9","9","“ꠔꠥꠝꠞꠣꠞ ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘꠅ ꠖꠥꠁ ꠎꠣꠔꠞ ꠛꠤꠌꠤ ꠟꠣꠉꠣꠁꠅ ꠘꠣ, ꠁꠟꠣ ꠇꠞꠟꠦ ꠀꠋꠉꠥꠞ ꠚꠟ ꠀꠞ ꠖꠥꠍꠞꠣ ꠎꠣꠔꠞ ꠛꠤꠌꠤꠞ ꠚꠟꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠞꠣꠝ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT22_10","006_22_10","DEU","22","10","10","“ꠉꠞꠥ ꠀꠞ ꠉꠣꠗꠣꠞꠦ ꠄꠇ ꠎꠥꠀꠟꠅ ꠟꠣꠉꠣꠁꠀ ꠀꠟ-ꠌꠣꠡ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_11","006_22_11","DEU","22","11","11","“ꠔꠥꠝꠞꠣ ꠖꠥꠁ ꠎꠣꠔꠞ ꠡꠥꠔꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_12","006_22_12","DEU","22","12","12","“ꠔꠥꠝꠞꠣꠞ ꠃꠠꠤꠛꠣꠞ ꠌꠣꠖ꠆ꠖꠞꠞ ꠌꠣꠁꠞꠅ ꠇꠥꠘꠣꠔ ꠡꠥꠔꠣꠉꠦꠍꠣ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT22_13","006_22_13","DEU","22","13","13","“ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠛꠤꠀ ꠇꠞꠤꠀ ꠛꠣꠡꠞ ꠊꠞ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠛꠃꠞꠦ ꠙꠍꠘ꠆ꠖ ꠘꠣ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("DT22_14","006_22_14","DEU","22","14","14","ꠢꠦ ꠎꠥꠖꠤ ꠛꠃꠞ ꠘꠣꠝꠦ ꠛꠖꠘꠣꠝ ꠞꠐꠣꠁꠀ ꠔꠣꠁꠞ ꠉꠤꠛꠔ ꠉꠣꠁꠀ ꠇꠄ, ꠀꠝꠤ ꠔ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠤ ꠑꠤꠇꠃ, ꠅꠁꠟꠦ ꠔꠣꠁꠞ ꠡꠔꠤꠔ꠆ꠔꠞ ꠇꠥꠘꠥ ꠌꠤꠘ꠆ꠘꠔ ꠙꠣꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_15","006_22_15","DEU","22","15","15","ꠔꠦ ꠅꠃ ꠇꠁꠘꠣꠞ ꠝꠣ-ꠛꠣꠚꠦ ꠔꠣꠞꠣꠞ ꠙꠥꠠꠤꠞ ꠡꠔꠤꠔ꠆ꠔꠞ ꠌꠤꠘ ꠟꠣꠉꠣꠁꠟ ꠛꠤꠍꠘꠣꠞ ꠇꠣꠙꠠ ꠟꠁꠀ, ꠢꠘꠞ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠉꠦꠁꠐꠞ ꠝꠥꠈꠅ ꠝꠥꠞꠛ꠆ꠛꠤ-ꠡꠣꠟꠤꠡ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_16","006_22_16","DEU","22","16","16","ꠉꠤꠀ ꠇꠁꠘꠣꠞ ꠛꠣꠚꠦ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠛꠣ, ꠀꠝꠤ ꠔ ꠅꠃ ꠖꠣꠝꠣꠘ꠆ꠖꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠞꠦ ꠡꠣꠖꠤ ꠖꠤꠍꠟꠣꠝ, ꠅꠈꠘ ꠢꠦ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_17","006_22_17","DEU","22","17","17","ꠀꠞ ꠢꠦ ꠛꠖꠘꠣꠝ ꠞꠐꠣꠁꠀ ꠇꠁꠍꠦ, ꠢꠦ ꠛꠥꠟꠦ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠞ ꠡꠔꠤꠔ꠆ꠔꠞ ꠌꠤꠘ꠆ꠘꠔ ꠙꠣꠁꠍꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞ ꠙꠥꠠꠤꠞ ꠡꠔꠤꠔ꠆ꠔꠞ ꠌꠤꠘ꠆ꠘꠔ ꠟꠁꠀ ꠀꠝꠤ ꠀꠎꠤꠞ ꠅꠁꠍꠤ। ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠦ ꠅꠃ ꠛꠤꠍꠘꠣꠞ ꠇꠣꠙꠠ ꠝꠦꠟꠤꠀ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠌꠤꠘ꠆ꠘꠔ ꠖꠦꠈꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT22_18","006_22_18","DEU","22","18","18","ꠔꠦꠃ ꠢꠤ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠅꠃ ꠖꠣꠝꠣꠘ꠆ꠖꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_19","006_22_19","DEU","22","19","19","ꠔꠣꠞ ꠎꠞꠤꠝꠣꠘꠣ ꠛꠣꠛꠔ ꠄꠇ-ꠡ ꠔꠟꠣ ꠞꠥꠙꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠇꠁꠘꠣꠞ ꠛꠣꠚꠞꠦ ꠖꠤꠛꠣ, ꠇꠣꠞꠘ ꠅꠃ ꠖꠣꠝꠣꠘ꠆ꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠤ ꠄꠇ ꠡꠔꠤ ꠇꠁꠘꠣꠞ ꠛꠖꠘꠣꠝ ꠞꠐꠣꠁꠍꠦ। ꠀꠞ ꠅꠃ ꠇꠁꠘꠣꠞꠦ ꠟꠁꠀ ꠢꠦ ꠡꠋꠡꠣꠞ ꠇꠞꠔꠦ ꠅꠁꠛ, ꠎꠤꠘ꠆ꠖꠦꠉꠤꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠔꠣꠁꠞꠦ ꠍꠣꠠꠣꠞ ꠇꠥꠘꠥ ꠙꠕ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT22_20","006_22_20","DEU","22","20","20","“ꠀꠞ ꠖꠣꠝꠣꠘ꠆ꠖꠞ ꠇꠕꠣ ꠢꠣꠍꠣ ꠅꠁꠟꠦ, ꠅꠃ ꠇꠁꠘꠣꠞ ꠡꠔꠤꠔ꠆ꠔꠞ ꠌꠤꠘ꠆ꠘꠔ ꠘꠣ ꠙꠣꠁꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("DT22_21","006_22_21","DEU","22","21","21","ꠇꠁꠘꠣꠞꠦ ꠔꠣꠁꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠞ ꠉꠦꠁꠐꠞ ꠉꠦꠍꠦ ꠘꠤꠀ, ꠢꠘꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠔꠣꠁꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣ। ꠔꠣꠁ ꠔ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠕꠣꠇꠣꠞ ꠇꠣꠟꠅ ꠎꠤꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠤꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠎꠊꠁꠘ꠆ꠘ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠍꠦ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠅꠟꠣ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT22_22","006_22_22","DEU","22","22","22","“ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠎꠥꠖꠤ ꠀꠞꠇ ꠛꠦꠐꠣꠞ ꠛꠃꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠣꠔ ꠗꠞꠣ ꠈꠣꠄ, ꠔꠦ ꠅꠃ ꠛꠦꠐꠣ-ꠛꠦꠐꠤ ꠖꠥꠁꠅ ꠎꠘꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠁ ꠟꠣꠈꠣꠘ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT22_23","006_22_23","DEU","22","23","23","“ꠛꠤꠀ ꠑꠤꠇ ꠅꠁꠉꠦꠍꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠇꠦꠃ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦ ꠙꠣꠁꠀ ꠎꠥꠖꠤ ꠔꠣꠁꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("DT22_24","006_22_24","DEU","22","24","24","ꠔꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠅꠉꠥꠞꠦ ꠢꠃ ꠎꠣꠉꠣꠞ ꠝꠦꠁꠘ ꠉꠦꠁꠐꠞ ꠉꠦꠍꠦ ꠘꠤꠀ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ। ꠙꠥꠠꠤꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠔꠣꠁ ꠔ ꠢꠘꠅ ꠕꠣꠇꠤ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠌꠤꠇ-ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠖꠤꠍꠦ ꠘꠣ, ꠀꠞ ꠛꠦꠐꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠢꠦ ꠀꠞꠇ ꠛꠦꠐꠣꠞ ꠛꠃꠞ ꠁꠎ꠆ꠎꠔ ꠝꠣꠞꠍꠦ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠅꠟꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT22_25","006_22_25","DEU","22","25","25","“ꠛꠤꠀ ꠑꠤꠇ ꠅꠁꠉꠦꠍꠦ ꠅꠝꠘ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠇꠦꠃ ꠇꠥꠘꠥ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠙꠣꠁꠀ ꠢꠣꠞꠤ, ꠎꠥꠞ ꠇꠞꠤꠀ ꠔꠣꠁꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠟꠦ, ꠈꠣꠟꠤ ꠅꠃ ꠛꠦꠐꠣ ꠝꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("DT22_26","006_22_26","DEU","22","26","26","ꠀꠞ ꠅꠃ ꠙꠥꠠꠤꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠛꠣꠄ, ꠔꠣꠁ ꠔ ꠝꠞꠣꠞ ꠎꠥꠇꠣ ꠉꠥꠘꠣ ꠇꠞꠍꠦ ꠘꠣ। ꠁꠔꠣ ꠔ ꠄꠇꠎꠘꠦ ꠖꠥꠍꠞꠣ ꠎꠘꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠟꠣꠈꠣꠘꠃ। ");
INSERT INTO syls_vpl VALUES ("DT22_27","006_22_27","DEU","22","27","27","ꠇꠣꠞꠘ ꠅꠃ ꠛꠦꠐꠣꠄ ꠔꠣꠁꠞꠦ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠗꠞꠍꠦ, ꠌꠤꠇ-ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠖꠤꠟꠦꠅ ꠔꠣꠁꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠇꠦꠃ ꠔ ꠁꠘꠅ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT22_28","006_22_28","DEU","22","28","28","“ꠛꠤꠀ-ꠡꠣꠖꠤ ꠑꠤꠇ ꠅꠁꠍꠦ ꠘꠣ, ꠅꠝꠘ ꠇꠥꠘꠥ ꠙꠥꠠꠤꠞꠦ ꠙꠣꠁꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠎꠥꠞ ꠇꠞꠤꠀ ꠔꠣꠁꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠦ, ꠀꠞ ꠔꠣꠞꠣ ꠗꠞꠣ ꠈꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT22_29","006_22_29","DEU","22","29","29","ꠔꠦ ꠅꠃ ꠛꠦꠐꠣꠄ ꠙꠥꠠꠤꠞ ꠛꠣꠚꠞꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠔꠟꠣ ꠞꠥꠙꠣ ꠖꠤꠛ, ꠀꠞ ꠙꠥꠠꠤꠞ ꠁꠎ꠆ꠎꠔ ꠝꠣꠞꠣꠄ ꠔꠣꠁꠞꠦ ꠛꠤꠀ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠎꠤꠘ꠆ꠖꠦꠉꠤꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠔꠣꠁꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠤꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT22_30","006_22_30","DEU","22","30","30","“ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠔꠣꠞ ꠢꠣꠔꠘ ꠝꠣʼꠞꠦ ꠛꠤꠀ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠣꠄ, ꠁꠟꠣ ꠇꠞꠟꠦ ꠢꠦ ꠔꠣꠞ ꠛꠣꠚꠞ ꠛꠃꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠤꠀ ꠛꠣꠚꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("DT23_1","006_23_1","DEU","23","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠞꠣ, “ꠇꠥꠘꠥ ꠛꠦꠐꠣꠞ ꠎꠥꠖꠤ ꠅꠘ꠆ꠒꠇꠥꠡ ꠍꠦꠌꠣ ꠅꠄ, ꠛꠣ ꠔꠣꠞ ꠙꠥꠞꠥꠡꠣꠟꠤ ꠘꠚꠍ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠄ, ꠔꠦ ꠢꠤ ꠛꠦꠐꠣ ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠢꠚꠤꠟꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT23_2","006_23_2","DEU","23","2","2","“ꠇꠥꠘꠥ ꠚꠥꠋꠉꠣ ꠝꠣꠘꠥꠡ ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠢꠚꠤꠟꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠘꠣꠁ, ꠔꠣꠞ ꠌꠃꠖ꠆ꠖ ꠍꠤꠠꠤꠞ ꠇꠦꠃꠞꠞ ꠢꠣꠝꠣꠘꠤꠞ ꠙꠕ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT23_3","006_23_3","DEU","23","3","3","“ꠛꠘꠤ-ꠀꠝ꠆ꠝꠣꠘ ꠛꠣ ꠝꠥꠀꠛꠤ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠢꠚꠤꠟꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠘꠣꠁ, ꠔꠣꠞꠣꠞ ꠌꠃꠖ꠆ꠖ ꠍꠤꠠꠤꠞ ꠇꠦꠃ ꠢꠣꠝꠣꠘꠤꠞ ꠙꠕ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT23_4","006_23_4","DEU","23","4","4","ꠝꠘꠅ ꠀꠍꠦ ꠘꠤ, ꠔꠥꠝꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠛꠣꠞ ꠇꠣꠟꠅ, ꠙꠕꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤ-ꠙꠣꠘꠤ ꠟꠁꠀ ꠀꠉꠥꠀꠁ ꠀꠁꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠖ꠆ꠖꠥꠀ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠟꠣꠝ ꠛꠤꠘ ꠛꠣꠃꠞ ꠘꠣꠝꠞ ꠄꠇ ꠙꠤꠞꠞꠦ ꠔꠣꠞꠣ ꠊꠥꠡ ꠖꠤꠍꠤꠟ, ꠖꠤꠀ ꠅꠞꠣꠝ-ꠘꠢꠞꠄꠁꠝ ꠖꠦꠡꠞ ꠚꠔꠥꠞ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠔꠣꠞꠦ ꠜꠣꠠꠣ ꠇꠞꠤ ꠀꠘꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT23_5","006_23_5","DEU","23","5","5","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠛꠣꠟꠣꠝꠞ ꠀꠞꠎꠤꠔ ꠡꠣꠄ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠔꠣꠁꠘ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠢꠃ ꠛꠣꠟꠣꠝ ꠙꠤꠞꠞ ꠛꠖ꠆ꠖꠥꠀꠞꠦ ꠛꠖꠟꠣꠁꠀ ꠔꠣꠁꠘ ꠘꠦꠇ-ꠖꠥꠀ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT23_6","006_23_6","DEU","23","6","6","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠜꠣꠟꠣꠁ ꠛꠣ ꠃꠙꠇꠣꠞ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT23_7","006_23_7","DEU","23","7","7","“ꠔꠣ-ꠅ ꠁꠖꠥꠝꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣ ꠁꠋꠡꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠄꠞꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁ। ꠝꠤꠡꠞꠤ ꠝꠣꠘꠡꠞꠦ ꠁꠋꠡꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠝꠥꠍꠣꠚꠤꠞ ꠢꠣꠟꠔꠦ ꠀꠉꠦ ꠔꠣꠞꠣꠞ ꠖꠦꠡꠅ ꠛꠡꠔ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("DT23_8","006_23_8","DEU","23","8","8","ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠣꠞ ꠔꠤꠘ ꠍꠤꠠꠤ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠢꠚꠤꠟꠅ ꠢꠣꠝꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT23_9","006_23_9","DEU","23","9","9","“ꠖꠥꠡꠝꠘꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁꠔ ꠛꠣꠞ ꠅꠁꠀ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠣꠙꠣꠇꠤ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT23_10","006_23_10","DEU","23","10","10","ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠇꠥꠘꠥ ꠍꠤꠙꠣꠁꠞ ꠎꠃꠛꠘꠞ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠀ ꠘꠣꠙꠣꠇ ꠛꠘꠤꠉꠦꠟꠦ, ꠢꠦ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT23_11","006_23_11","DEU","23","11","11","ꠛꠣꠖꠦ ꠛꠤꠀꠟꠤ ꠛꠣꠟꠣ ꠢꠦ ꠘꠣꠁꠀ ꠢꠣꠞꠤ, ꠡꠥꠞꠥꠎ ꠒꠥꠛꠤꠀ ꠢꠣꠞꠟꠦ ꠇꠦꠝ꠆ꠙꠅ ꠀꠁꠀ ꠢꠣꠝꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT23_12","006_23_12","DEU","23","12","12","“ꠙꠣꠄꠈꠣꠘꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠄꠇ ꠎꠣꠉꠣ ꠛꠣꠘꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT23_13","006_23_13","DEU","23","13","13","ꠔꠥꠝꠞꠣꠞ ꠀꠔꠤꠀꠞ-ꠙꠔ꠆ꠞꠞ ꠟꠉꠦ ꠝꠣꠐꠤ ꠈꠥꠠꠤꠛꠣꠞ ꠇꠥꠖꠣꠟ ꠞꠣꠈꠤꠅ। ꠙꠣꠄꠈꠣꠘꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠇꠥꠖꠣꠟꠖꠤ ꠉꠣꠔ ꠈꠥꠖꠤꠀ ꠝꠣꠐꠤꠞ ꠔꠟꠦ ꠢꠣꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT23_14","006_23_14","DEU","23","14","14","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠖꠥꠡꠝꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠛꠣꠞ ꠈꠤꠀꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠊꠥꠞꠣ-ꠚꠤꠞꠣ ꠇꠞꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠦꠝ꠆ꠙꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠞꠣꠈꠤꠅ, ꠀꠞꠘꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠙꠣꠇꠤ ꠖꠦꠈꠤꠀ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT23_15","006_23_15","DEU","23","15","15","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠇꠤꠘꠣ ꠉꠥꠟꠣꠝ ꠜꠣꠉꠤꠀ ꠀꠁꠀ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠡꠞꠄ ꠟꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠔꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠣꠁ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT23_16","006_23_16","DEU","23","16","16","ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠎꠦꠈꠣꠘꠅ ꠞꠁꠔ ꠌꠣꠄ, ꠅꠘꠅꠃ ꠔꠣꠞꠦ ꠎꠣꠉꠣ ꠖꠤꠅ, ꠔꠣꠞꠦ ꠖꠥꠈ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT23_17","006_23_17","DEU","23","17","17","“ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠎꠣꠘꠥ ꠝꠘ꠆ꠖꠤꠞ-ꠀꠈꠠꠣꠞ ꠘꠐꠤꠉꠤꠞꠤ ꠘꠣ ꠇꠞꠦ। ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄꠅ ꠎꠣꠘꠥ ꠅꠟꠣ ꠘꠐꠣꠉꠤꠞꠤ ꠘꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("DT23_18","006_23_18","DEU","23","18","18","ꠘꠐꠤ ꠛꠦꠐꠤ ꠛꠣ ꠘꠐꠣ ꠛꠦꠐꠣꠞ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞꠞ ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠞ ꠇꠥꠘꠥꠎꠣꠔ ꠝꠣꠘ꠆ꠘꠔ-ꠇꠥꠞꠛꠣꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠅ ꠀꠘꠤꠅ ꠘꠣ। ꠁꠟꠣꠈꠣꠘ ꠛꠦꠐꠣ-ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠔ ꠝꠣꠛꠥꠖꠦ ꠊꠤꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT23_19","006_23_19","DEU","23","19","19","“ꠔꠥꠝꠞꠣꠞ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠜꠣꠁꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠥꠖ ꠈꠣꠁꠅ ꠘꠣ, ꠁꠔꠣ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ, ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤꠞ ꠎꠤꠘꠤꠡ ꠛꠣ ꠀꠞꠅ ꠇꠥꠘꠥꠔꠣ ꠅꠁꠟꠦꠅ ꠇꠥꠘꠥꠎꠣꠔ ꠡꠥꠖ ꠟꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT23_20","006_23_20","DEU","23","20","20","ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠥꠖ ꠘꠤꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠡꠥꠖ ꠈꠣꠅꠀ ꠢꠣꠞꠣꠝ। ꠁꠔꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠞꠣꠄ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎꠅ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT23_21","006_23_21","DEU","23","21","21","“ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠘꠥꠔꠣ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠟꠦ, ꠁꠔꠣ ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ, ꠁꠔꠣ ꠀꠖꠣꠄ ꠘꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣ ꠅꠁꠛ। ꠀꠞ ꠁ ꠢꠤꠡꠣꠛ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠖ ꠖꠤꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT23_22","006_23_22","DEU","23","22","22","ꠅꠁꠟꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠝꠣꠘ꠆ꠘꠔ ꠘꠣ ꠇꠞꠟꠦ ꠉꠥꠘꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT23_23","006_23_23","DEU","23","23","23","ꠔꠥꠝꠞꠣꠞ ꠎꠛꠣꠘ ꠕꠣꠇꠤ ꠎꠦ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠍ, ꠁꠐꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠀꠖꠣꠄ ꠇꠞꠛꠣꠄ, ꠇꠣꠞꠘ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠛꠣꠘꠦ, ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠁꠔꠣ ꠝꠣꠘꠍ, ꠄꠞꠟꠣꠉꠤ ꠀꠖꠣꠄꠅ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT23_24","006_23_24","DEU","23","24","24","“ꠔꠥꠝꠞꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘꠅ ꠢꠣꠝꠣꠁꠟꠦ ꠘꠤꠎꠞ ꠢꠣꠃꠍ ꠝꠤꠐꠣꠁꠀ ꠀꠋꠉꠥꠞ ꠈꠣꠁꠅ, ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠛꠃꠟ ꠛꠣ ꠛꠡ꠆ꠔꠣꠔ ꠇꠞꠤ ꠇꠥꠘ꠆ꠔꠣ ꠘꠤꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT23_25","006_23_25","DEU","23","25","25","ꠇꠦꠃꠞꠞ ꠎꠝꠤꠘꠅ ꠉꠤꠀ ꠀꠔꠖꠤ ꠇꠥꠘꠥꠎꠣꠔ ꠚꠄ-ꠚꠍꠟꠞ ꠍꠠꠣ ꠍꠤꠠꠤꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠇꠣꠌꠤ ꠖꠤꠀ ꠖꠣꠁꠀ ꠘꠤꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT24_1","006_24_1","DEU","24","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠞꠣ, “ꠛꠤꠀꠞ ꠛꠣꠖꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠎꠣꠝꠣꠁꠄ ꠔꠣꠞ ꠛꠃꠞ ꠝꠣꠎꠦ ꠈꠥꠔ ꠙꠣꠄ, ꠙꠣꠁꠀ ꠔꠣꠁꠞ ꠃꠙꠞꠦ ꠘꠣꠞꠣꠎ ꠅꠄ, ꠀꠞ ꠔꠣꠟꠣꠇ ꠘꠣꠝꠣ ꠟꠦꠈꠤꠀ ꠔꠣꠁꠞ ꠀꠔꠅ ꠖꠤꠀ ꠛꠤꠖꠣꠄ ꠇꠞꠤ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("DT24_2","006_24_2","DEU","24","2","2","ꠀꠞ ꠅꠃ ꠛꠃꠄ ꠉꠤꠀ ꠎꠥꠖꠤ ꠖꠥꠍꠞꠣ ꠎꠣꠝꠣꠁꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠛꠄ, ");
INSERT INTO syls_vpl VALUES ("DT24_3","006_24_3","DEU","24","3","3","ꠛꠣꠖꠦ ꠢꠃ ꠖꠥꠍꠞꠣ ꠎꠣꠝꠣꠁꠄꠅ ꠔꠣꠁꠞꠦ ꠘꠣꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠅꠟꠣ ꠔꠣꠟꠣꠇ ꠖꠤꠟꠣꠄ, ꠛꠣ ꠢꠃ ꠎꠣꠝꠣꠁ ꠝꠞꠤꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT24_4","006_24_4","DEU","24","4","4","ꠔꠦ ꠔꠣꠁꠞ ꠢꠃ ꠙꠄꠟꠣ ꠎꠣꠝꠣꠁꠄ ꠔꠣꠁꠞꠦ ꠀꠞ ꠛꠤꠀ ꠇꠞꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠔꠣꠁ ꠔ ꠄꠘ ꠟꠣꠉꠤ ꠘꠣꠙꠣꠇ ꠅꠁꠉꠦꠍꠦ। ꠁꠟꠣꠈꠣꠘ ꠛꠤꠀ-ꠡꠣꠖꠤꠞꠦ ꠝꠣꠛꠥꠖꠦ ꠊꠤꠘ ꠇꠞꠂꠘ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠞꠣ, ꠔꠥꠝꠞꠣ ꠁꠟꠣ ꠉꠥꠘꠣ ꠇꠞꠤꠀ ꠁ ꠖꠦꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT24_5","006_24_5","DEU","24","5","5","“ꠘꠄꠀ ꠛꠤꠀ ꠇꠞꠣ ꠇꠥꠘꠥ ꠛꠦꠐꠣꠞꠦ ꠎꠥꠖ꠆ꠖꠔ ꠙꠣꠑꠣꠁꠅ ꠘꠣ, ꠎꠥꠞ-ꠎꠛꠞꠖꠡ꠆ꠔꠤ ꠇꠞꠤꠀ ꠔꠣꠞꠦ ꠇꠥꠘꠥ ꠇꠣꠝꠞ ꠜꠣꠞ ꠖꠤꠅ ꠘꠣ। ꠢꠦ ꠙꠥꠞꠣ ꠄꠇ ꠛꠍꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠘꠣ ꠇꠞꠤꠀ, ꠔꠣꠞ ꠛꠃꠞ ꠟꠉꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT24_6","006_24_6","DEU","24","6","6","“ꠀꠅꠟꠣꠔꠤ ꠝꠣꠟꠞ ꠛꠘ꠆ꠖꠇ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠊꠣꠁꠟ-ꠍꠤꠀ, ꠛꠣ ꠈꠣꠟꠤ ꠍꠤꠀ ꠛꠘ꠆ꠖꠇ ꠞꠣꠈꠤꠅ ꠘꠣ। ꠁꠟꠣ ꠇꠞꠟꠦ ꠔꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤꠞ ꠙꠕ ꠛꠘ꠆ꠖ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT24_7","006_24_7","DEU","24","7","7","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠞꠇ ꠜꠣꠁꠞꠦ ꠌꠥꠞꠤ ꠇꠞꠤꠀ ꠘꠤꠀ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠁꠟꠣꠄ, ꠛꠣ ꠖꠥꠍꠞꠣ ꠎꠣꠉꠣꠔ ꠛꠦꠌꠤꠀ ꠢꠣꠞꠤ ꠗꠞꠣ ꠈꠣꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣꠄ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠁꠟꠣ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT24_8","006_24_8","DEU","24","8","8","“ꠇꠦꠃꠞꠞ ꠉꠔꠞꠅ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠖꠦꠈꠣ ꠖꠤꠟꠦ, ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠙꠞꠣꠝꠤꠡ ꠝꠣꠚꠤꠇ ꠌꠟꠤꠅ। ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ, ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠁꠔꠣ ꠝꠣꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT24_9","006_24_9","DEU","24","9","9","ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠛꠣꠞ ꠙꠕꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞ ꠛꠁꠘ ꠝꠞꠤꠅꠝꠞ ꠎꠦ ꠖꠡꠣ ꠊꠐꠣꠁꠍꠤꠟ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT24_10","006_24_10","DEU","24","10","10","“ꠔꠥꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠀꠅꠟꠣꠔ ꠖꠤꠟꠦ, ꠔꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠝꠣꠟ ꠛꠘ꠆ꠖꠇ ꠘꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ, ꠔꠥꠝꠤ ꠔꠣꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT24_11","006_24_11","DEU","24","11","11","ꠔꠥꠝꠤ ꠊꠞꠞ ꠛꠣꠞꠦ ꠃꠛꠣꠁꠅ, ꠀꠞ ꠎꠣꠞꠦ ꠀꠅꠟꠣꠔ ꠖꠤꠍ, ꠢꠦ ꠔꠣꠞ ꠊꠞ ꠕꠣꠇꠤ ꠛꠘ꠆ꠖꠇꠤ ꠝꠣꠟ ꠀꠘꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT24_12","006_24_12","DEU","24","12","12","ꠀꠅꠟꠣꠔ ꠘꠦꠅꠞꠣ ꠎꠘ ꠉꠞꠤꠛ-ꠖꠥꠈꠤ ꠅꠁꠟꠦ, ꠔꠣꠞ ꠖꠦꠅꠀ ꠛꠘ꠆ꠖꠇꠤ ꠈꠦꠔꠣ-ꠇꠝꠟꠤ ꠘꠤꠀ ꠔꠥꠝꠤ ꠞꠣꠁꠔ ꠊꠥꠝꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT24_13","006_24_13","DEU","24","13","13","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠔꠥꠝꠤ ꠔꠣꠞ ꠝꠣꠟ ꠚꠤꠞꠣꠁ ꠖꠤꠅ, ꠅꠔꠣ ꠃꠠꠤꠀ ꠢꠦ ꠞꠣꠁꠔ ꠊꠥꠝꠣꠁꠀ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠛ। ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ, ꠀꠞ ꠛꠘ꠆ꠖꠇꠤ ꠍꠣꠝꠣꠘꠣ ꠚꠤꠞꠔ ꠖꠦꠅꠀ ꠔ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠘꠦꠇꠤꠞ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT24_14","006_24_14","DEU","24","14","14","“ꠔꠥꠝꠞꠣꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠜꠣꠁ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠅ ꠞꠅꠞꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠙꠣꠅꠘꠣ ꠕꠣꠇꠟꠦ, ꠀꠞ ꠢꠦ ꠉꠞꠤꠛ-ꠖꠥꠈꠤ, ꠞꠥꠎꠤ ꠇꠣꠝꠟꠣ ꠎꠘ ꠅꠁꠟꠦ, ꠔꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT24_15","006_24_15","DEU","24","15","15","ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣꠞ ꠀꠉꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠞ ꠙꠣꠅꠘꠣ ꠝꠎꠥꠞꠤ ꠖꠤꠟꠣꠁꠅ, ꠢꠦ ꠔ ꠉꠞꠤꠛ ꠝꠣꠘꠥꠡ, ꠅꠃ ꠝꠎꠥꠞꠤ ꠖꠤꠀꠃ ꠔꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠌꠟꠦ। ꠀꠞꠘꠣꠄ ꠝꠎꠥꠞꠤꠞ ꠟꠣꠉꠤ ꠢꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠚꠞꠤꠀꠖ ꠇꠞꠟꠦ, ꠔꠥꠝꠞꠣ ꠉꠥꠘꠣꠞ ꠜꠣꠉꠤ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT24_16","006_24_16","DEU","24","16","16","“ꠙꠥꠀ-ꠙꠥꠠꠤꠞ ꠅꠙꠞꠣꠗꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ, ꠛꠣ ꠝꠣ-ꠛꠣꠚꠞ ꠅꠙꠞꠣꠗꠦ ꠙꠥꠀ-ꠙꠥꠠꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠙꠞꠔꠦꠇ ꠎꠘꠦ ꠘꠤꠎꠞ ꠅꠙꠞꠣꠗꠞ ꠡꠣꠎꠣ ꠘꠤꠎꠦ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT24_17","006_24_17","DEU","24","17","17","“ꠇꠥꠘꠥ ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ ꠛꠣ ꠄꠔꠤꠝꠞ ꠃꠙꠞꠦ ꠘꠣ-ꠢꠇ ꠛꠤꠌꠣꠞ ꠅꠁꠔꠦ ꠖꠤꠅ ꠘꠣ। ꠇꠥꠘꠥ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠞ ꠚꠤꠘ꠆ꠖꠤꠛꠣꠞ ꠇꠣꠙꠠ ꠛꠘ꠆ꠖꠇ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT24_18","006_24_18","DEU","24","18","18","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠘ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠇꠞꠤ ꠀꠘꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠇꠣꠝ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT24_19","006_24_19","DEU","24","19","19","“ꠔꠥꠝꠞꠣꠞ ꠎꠝꠤꠘꠞ ꠗꠣꠘ ꠇꠣꠐꠣꠞ ꠛꠣꠖꠦ, ꠗꠣꠘꠞ ꠇꠥꠘꠥ ꠝꠥꠁꠐ ꠚꠣꠃꠞꠤꠀ ꠉꠦꠟꠦꠉꠤ, ꠁꠐꠣ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠚꠤꠞꠔ ꠎꠣꠁꠅ ꠘꠣ। ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ, ꠄꠔꠤꠝ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠁꠐꠣ ꠖꠤꠟꠣꠁꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎꠅ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT24_20","006_24_20","DEU","24","20","20","ꠎꠄꠔꠥꠘ ꠉꠣꠍꠞ ꠚꠟ ꠙꠣꠠꠤꠛꠣꠞ ꠇꠣꠟꠅ ꠄꠇꠁ ꠒꠣꠟꠞ ꠚꠟ ꠖꠥꠁꠛꠣꠞ ꠙꠣꠠꠤꠅ ꠘꠣ। ꠄꠇꠛꠣꠞ ꠙꠣꠠꠣꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠞꠄ, ꠁꠔꠣ ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ, ꠄꠔꠤꠝ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠕꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT24_21","006_24_21","DEU","24","21","21","ꠔꠥꠝꠞꠣꠞ ꠀꠋꠉꠥꠞ ꠛꠣꠉꠣꠘꠞ ꠄꠇ ꠟꠔ ꠕꠣꠇꠤ ꠖꠥꠁ ꠛꠣꠞ ꠀꠋꠉꠥꠞ ꠙꠣꠠꠤꠅ ꠘꠣ, ꠄꠇꠛꠣꠞ ꠙꠣꠠꠣꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠞꠄ, ꠁꠔꠣ ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ, ꠄꠔꠤꠝ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠕꠁ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT24_22","006_24_22","DEU","24","22","22","ꠚꠣꠃꠞꠤꠅ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠔ ꠀꠉꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("DT25_1","006_25_1","DEU","25","1","1","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠞꠣ, “ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠟꠣꠉꠤꠀ ꠎꠥꠖꠤ ꠁꠔꠣ ꠢꠣꠇꠤꠝꠞ ꠀꠖꠣꠟꠔꠅ ꠎꠣꠄ, ꠔꠦ ꠢꠣꠇꠤꠝ ꠅꠇꠟꠦ ꠅꠙꠞꠣꠗꠤ ꠎꠘꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠛꠣ, ꠀꠞ ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT25_2","006_25_2","DEU","25","2","2","ꠅꠃ ꠛꠤꠌꠣꠞꠅ ꠖꠥꠡꠤ ꠎꠘꠞꠦ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠣꠞ ꠞꠣꠄ ꠖꠤꠟꠦ, ꠢꠣꠇꠤꠝꠦ ꠔꠣꠞꠦ ꠝꠣꠐꠤꠔ ꠢꠥꠔꠣꠁꠀ ꠔꠣꠞ ꠙꠣꠅꠘꠣ ꠝꠣꠁꠞ ꠔꠣꠘ ꠘꠤꠎꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠞꠣꠁꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("DT25_3","006_25_3","DEU","25","3","3","ꠅꠁꠟꠦ ꠌꠣꠟ꠆ꠟꠤꠡꠐꠣꠞ ꠛꠦꠡꠤ ꠝꠣꠞꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠀꠞꠘꠣꠄ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠄꠇ ꠜꠣꠁꠞꠦ ꠡꠝꠣꠎꠞ ꠍꠣꠝꠘꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT25_4","006_25_4","DEU","25","4","4","“ꠗꠣꠘ ꠝꠣꠠꠣ ꠖꠤꠛꠣꠞ ꠇꠣꠟꠅ ꠉꠞꠥꠞ ꠝꠥꠈꠅ ꠢꠥꠚꠤ ꠟꠣꠉꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT25_5","006_25_5","DEU","25","5","5","“ꠄꠇ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟ ꠜꠣꠁꠀꠁꠘ ꠄꠇꠈꠣꠘꠅ ꠞꠅꠀꠞ ꠇꠣꠟꠅ ꠎꠥꠖꠤ ꠛꠤꠀꠔꠤ ꠇꠥꠘꠥ ꠜꠣꠁ ꠝꠞꠤꠎꠣꠄ, ꠀꠞ ꠔꠣꠞ ꠇꠥꠘꠥ ꠙꠥꠀꠂꠘ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠣꠞ ꠠꠣꠠꠤ ꠛꠃꠄ ꠔꠣꠁꠞ ꠖꠦꠅꠞ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃꠞꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠛꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠔꠣꠁꠞ ꠖꠦꠅꠞꠦ ꠔꠣꠁꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠔꠣꠞ ꠃꠙꠞꠦ ꠛꠞ꠆ꠔꠣꠁꠟ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("DT25_6","006_25_6","DEU","25","6","6","ꠔꠣꠞꠣꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟꠦ, ꠁ ꠙꠥꠀ ꠅꠃ ꠝꠞꠣ ꠜꠣꠁꠞ ꠅꠀꠞꠤꠡ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠅꠁꠛ, ꠔꠦꠃ ꠅꠃ ꠜꠣꠁꠞ ꠘꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠝꠥꠍꠤ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT25_7","006_25_7","DEU","25","7","7","ꠅꠁꠟꠦ ꠔꠣꠁꠞ ꠖꠦꠅꠞꠦ ꠎꠥꠖꠤ ꠔꠣꠁꠞꠦ ꠛꠤꠀ ꠇꠞꠔ ꠞꠣꠎꠤ ꠘꠣ ꠅꠄ, ꠔꠦ ꠔꠣꠁ ꠢꠃ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠙꠣꠁꠘ꠆ꠌꠣꠁꠔꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠢꠘꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠛ, ꠀꠝꠣꠞ ꠖꠦꠅꠞꠦ ꠀꠝꠣꠞꠦ ꠛꠤꠀ ꠇꠞꠔ ꠞꠣꠎꠤ ꠘꠣꠄ, ꠢꠦ ꠔꠣꠞ ꠝꠞꠣ ꠜꠣꠁꠞ ꠘꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠣ ꠞꠣꠈꠔ ꠌꠣꠄ ꠘꠣ। ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞ ꠃꠙꠞꠦ ꠛꠞ꠆ꠔꠣꠁꠟ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠇꠞꠦꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT25_8","006_25_8","DEU","25","8","8","ꠔꠦꠃ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠞꠦ ꠀꠘꠣꠁꠀ ꠛꠥꠎꠣꠁꠛꠣ, ꠄꠞꠛꠣꠖꠦꠅ ꠢꠦ ꠘꠤꠇꠣ ꠇꠞꠔꠦ ꠞꠣꠎꠤ ꠘꠣ ꠅꠁꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("DT25_9","006_25_9","DEU","25","9","9","ꠅꠃ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠄ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ, ꠔꠣꠞ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠔꠣꠞ ꠙꠣꠅꠞ ꠄꠇꠈꠣꠘ ꠎꠥꠔꠣ ꠘꠤꠎꠦ ꠈꠥꠟꠤꠀ ꠘꠤꠛꠉꠤ, ꠀꠞ ꠔꠣꠞ ꠝꠥꠈꠅ ꠍꠦꠚ ꠚꠣꠟꠣꠁꠀ ꠇꠁꠛ, ꠀꠙꠘ ꠜꠣꠁꠞ ꠛꠋꠡ ꠎꠦꠉꠤꠄ ꠛꠣꠌꠣꠁꠔ ꠌꠣꠄ ꠘꠣ, ꠅꠉꠥꠞ ꠖꠡꠣ ꠅꠟꠣ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("DT25_10","006_25_10","DEU","25","10","10","ꠛꠣꠖꠦ ꠅꠃ ꠛꠦꠐꠣꠞ ꠛꠋꠡꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ, ꠎꠥꠔꠣ ꠀꠞꠣꠅꠀꠞꠣꠞ ꠛꠋꠡ ꠘꠣꠝꠦ ꠒꠣꠇꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT25_11","006_25_11","DEU","25","11","11","“ꠖꠥꠁ ꠛꠦꠐꠣꠄ ꠝꠣꠞꠣ-ꠝꠣꠞꠤꠞ ꠇꠣꠟꠅ ꠎꠥꠖꠤ, ꠄꠇꠎꠘꠞ ꠛꠃ ꠉꠤꠀ ꠔꠣꠁꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠢꠃ ꠛꠦꠐꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ, ꠢꠃ ꠛꠦꠐꠣꠞ ꠙꠥꠞꠥꠡꠣꠟꠤ ꠘꠚꠍꠅ ꠌꠤꠙꠤꠀ ꠗꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("DT25_12","006_25_12","DEU","25","12","12","ꠔꠦ ꠔꠥꠝꠞꠣ ꠢꠃ ꠛꠦꠐꠤꠞ ꠀꠔ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠅ। ꠔꠣꠁꠞꠦ ꠇꠥꠘꠥ ꠖꠄꠀ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT25_13","006_25_13","DEU","25","13","13","“ꠝꠣꠙꠅ ꠐꠉꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠕꠟꠤꠞ ꠝꠣꠎꠦ ꠄꠇꠁ ꠝꠣꠙꠞ ꠢꠥꠞꠥ-ꠛꠠ ꠖꠥꠁ ꠙꠣꠔ꠆ꠔꠞ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT25_14","006_25_14","DEU","25","14","14","ꠔꠥꠝꠞꠣꠞ ꠊꠞꠅ ꠄꠇꠁ ꠝꠣꠙꠞ ꠢꠥꠞꠥ-ꠛꠠ ꠖꠥꠁꠐꠣ ꠢꠦꠞ-ꠙꠦꠐꠥ ꠞꠣꠈꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT25_15","006_25_15","DEU","25","15","15","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠢꠘꠅ ꠟꠣꠝ꠆ꠛꠣ ꠢꠣꠄꠀꠔꠤ ꠙꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠙꠤꠛꠣꠞ ꠙꠣꠔ꠆ꠔꠞ ꠀꠞ ꠢꠦꠞ-ꠙꠦꠐꠥꠞ ꠃꠎꠘ ꠡꠑꠤꠇ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT25_16","006_25_16","DEU","25","16","16","ꠇꠣꠞꠘ ꠎꠦꠉꠤꠄ ꠝꠣꠙꠞ ꠝꠣꠎꠦ ꠐꠉꠣ-ꠐꠉꠤ ꠇꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠦ ꠊꠤꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT25_17","006_25_17","DEU","25","17","17","“ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠛꠣꠞ ꠙꠕꠅ, ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠦ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠍꠤꠟ, ꠁꠔꠣ ꠚꠣꠃꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT25_18","006_25_18","DEU","25","18","18","ꠀꠐꠤꠔꠦ ꠀꠐꠤꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠦꠃ ꠇꠦꠃ ꠎꠦꠛꠟꠣ ꠢꠦꠞꠣꠘ ꠅꠁꠀ ꠙꠤꠍꠦ ꠙꠠꠤ ꠉꠦꠍꠤꠟ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠦ ꠀꠁꠀ ꠢꠣꠝꠟꠣ ꠇꠞꠍꠤꠟ, ꠔꠣꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞꠦꠅ ꠒꠞꠣꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT25_19","006_25_19","DEU","25","19","19","ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠞꠣ, ꠢꠃ ꠖꠦꠡꠞ ꠀꠡ-ꠙꠣꠡꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠣꠘ꠆ꠔꠤ ꠖꠤꠛꠣ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠀꠝꠣꠟꠦꠇꠤ ꠅꠇꠟꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ। ꠁ ꠢꠥꠇꠥꠝ ꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠖꠤꠘꠃ ꠚꠣꠃꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT26_1","006_26_1","DEU","26","1","1","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠞꠣ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠃ ꠖꠦꠡꠞ ꠖꠈꠟ ꠙꠣꠁꠀ ꠢꠘꠅ ꠛꠡꠔꠤ ꠇꠞꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT26_2","006_26_2","DEU","26","2","2","ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠎꠝꠤꠘꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠚꠡꠟ ꠕꠣꠇꠤ, ꠙꠄꠟꠣ ꠙꠣꠅꠀ ꠚꠡꠟꠞ ꠄꠇꠐꠣ ꠅꠋꠡ ꠄꠇ ꠐꠥꠇꠞꠤꠔ ꠜꠞꠤꠀ ꠀꠟꠉꠣꠁꠀ ꠕꠁꠅ। ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠞ ꠛꠣꠄꠔꠥꠟ꠆ꠟꠣ ꠡꠞꠤꠚ ꠢꠤꠡꠣꠛꠦ ꠎꠦ ꠎꠣꠉꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣ, ꠅꠃ ꠚꠡꠟ ꠟꠁꠀ ꠢꠘꠅ ꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT26_3","006_26_3","DEU","26","3","3","ꠉꠤꠀ ꠢꠘꠅ ꠀꠎꠤꠞ ꠁꠝꠣꠝ ꠍꠣꠛꠞꠦ ꠇꠁꠅ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠀꠝꠞꠣ ꠅꠈꠘ ꠅꠘꠅ ꠀꠁꠍꠤ, ꠀꠁꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT26_4","006_26_4","DEU","26","4","4","ꠔꠦꠃ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠚꠟꠞ ꠐꠥꠇꠞꠤ ꠘꠤꠀ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT26_5","006_26_5","DEU","26","5","5","ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠀ ꠇꠁꠅ, ꠀꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ ꠢꠎꠞꠔ ꠁꠀꠇꠥꠛ ꠀꠍꠟꠣ ꠄꠇꠎꠘ ꠅꠞꠣꠝꠤ ꠝꠥꠍꠣꠚꠤꠞ, ꠔꠣꠁꠘ ꠕꠥꠠꠣ ꠇꠄꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠉꠦꠍꠟꠣꠉꠤ। ꠉꠤꠀ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠝꠥꠍꠣꠚꠤꠞ ꠢꠣꠟꠔꠦ ꠛꠡꠔ ꠇꠞꠣꠞ ꠇꠣꠟꠅ ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣ ꠄꠇ ꠝꠢꠣꠘ ꠎꠣꠔꠤ, ꠀꠞ ꠛꠃꠔ ꠛꠠ ꠛꠟꠀꠟꠣ ꠎꠣꠔꠤ ꠛꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT26_6","006_26_6","DEU","26","6","6","ꠛꠣꠖꠦ ꠝꠤꠡꠞꠞ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠎ꠆ꠎꠣꠔꠤ ꠇꠞꠟꠣ, ꠀꠝꠞꠣꠞꠦ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠖꠤꠀ, ꠀꠝꠞꠣꠞꠦꠖꠤ ꠇꠑꠤꠘ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("DT26_7","006_26_7","DEU","26","7","7","ꠀꠝꠞꠣ ꠖꠥꠈ ꠙꠣꠁꠀ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠣꠘ꠆ꠖꠤꠟꠣꠝ। ꠔꠦꠃ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠤꠀ, ꠀꠝꠞꠣꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐ, ꠇꠑꠤꠘ ꠉꠥꠟꠣꠝꠤ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠞ ꠎꠥꠟꠥꠝꠞ ꠛꠣꠄ ꠘꠎꠞ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT26_8","006_26_8","DEU","26","8","8","ꠀꠞ ꠔꠣꠘ ꠛꠟꠀꠟꠣ-ꠝꠎꠛꠥꠔ ꠀꠔ ꠛꠣꠠꠣꠁꠀ, ꠈꠥꠛ ꠒꠞ-ꠈꠚ ꠖꠦꠈꠣꠁꠀ, ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠤꠀ ꠀꠞ ꠀꠌꠣꠘꠇ ꠉꠎꠛ ꠓꠣꠟꠤꠀ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT26_9","006_26_9","DEU","26","9","9","ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞꠦ ꠅꠃ ꠖꠦꠡꠅ ꠀꠘꠍꠂꠘ, ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠀꠞꠣꠝꠞ ꠅꠃ ꠖꠦꠡ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT26_10","006_26_10","DEU","26","10","10","ꠄꠞꠟꠣꠉꠤ ꠅ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠖꠦꠅꠀ ꠎꠝꠤꠘꠞ ꠚꠡꠟꠞ ꠙꠄꠟꠣ ꠛꠣꠐ ꠟꠁꠀ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠍꠤ। ꠅꠈꠣꠘ ꠇꠁꠀ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠐꠥꠇꠞꠤ ꠕꠁꠅ, ꠕꠁꠀ ꠔꠣꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT26_11","006_26_11","DEU","26","11","11","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠙꠞꠤꠛꠣꠞꠞꠦ ꠎꠔ ꠘꠝꠥꠘꠣꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠍꠂꠘ, ꠅꠔꠣ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ, ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠢꠇꠟꠦ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠅꠞꠣ ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠇꠟꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT26_12","006_26_12","DEU","26","12","12","“ꠙꠞꠔꠤ ꠔꠤꠘ ꠛꠍꠞ ꠛꠣꠖꠦ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠚꠄ-ꠚꠡꠟꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞꠦ, ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠇꠟꠞꠦ, ꠄꠔꠤꠝ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠛꠤꠟꠣꠁ ꠖꠤꠅ। ꠔꠦꠃ ꠄꠞꠣ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠀꠞꠣꠝꠦ ꠞꠁꠛꠣ। ꠄꠞꠟꠣꠉꠤ ꠁꠇꠐꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠖꠡꠝꠣꠋꠡꠞ ꠛꠍꠞ। ");
INSERT INTO syls_vpl VALUES ("DT26_13","006_26_13","DEU","26","13","13","ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠇꠁꠅ, ꠝꠣꠛꠥꠖ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠀꠝꠣꠞ ꠞꠥꠎꠤꠞ ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠐꠞꠦ, ꠀꠝꠣꠞ ꠊꠞ ꠕꠣꠇꠤ ꠘꠤꠀ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ, ꠝꠥꠍꠣꠚꠤꠞ ꠅꠇꠟꠞꠦ, ꠄꠔꠤꠝ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠤꠍꠤ। ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝꠞ ꠈꠦꠟꠣꠚ ꠇꠞꠍꠤ ꠘꠣ, ꠛꠣ ꠚꠣꠃꠞꠤꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT26_14","006_26_14","DEU","26","14","14","ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠣꠞ ꠡꠝꠄ ꠀꠝꠤ ꠅꠃ ꠙꠛꠤꠔ꠆ꠞ ꠅꠋꠡꠞ ꠇꠥꠘꠥꠔꠣ ꠈꠣꠁꠍꠤ ꠘꠣ, ꠛꠣ ꠘꠣꠙꠣꠇ ꠢꠣꠟꠔꠦ ꠁꠔꠣ ꠛꠣꠠꠤꠞ ꠛꠣꠞꠦ ꠘꠤꠍꠤ ꠘꠣ, ꠀꠞ ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠅꠋꠡ ꠝꠥꠞ꠆ꠖꠣꠞ ꠘꠣꠝꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔꠅ ꠇꠞꠍꠤ ꠘꠣ। ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠌꠟꠍꠤ, ꠔꠥꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠢꠇꠟ ꠇꠣꠝ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT26_15","006_26_15","DEU","26","15","15","ꠅꠈꠘ, ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠕꠣꠇꠤ, ꠔꠥꠝꠣꠞ ꠀꠞꠡꠦ-ꠀꠎꠤꠝ ꠕꠣꠇꠤ ꠔꠟꠦꠖꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠅ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠈꠣꠍ ꠙ꠆ꠞꠎꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠦꠅ। ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠟꠉꠦ ꠇꠍꠝ ꠇꠞꠣ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ, ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞꠦ ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠅꠃ ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠖꠣꠘ ꠇꠞꠍ, ꠄꠞ ꠝꠣꠐꠤꠔ ꠔꠥꠝꠤ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("DT26_16","006_26_16","DEU","26","16","16","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠀꠁꠎ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠛꠣꠔꠣꠁꠟ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠅ। ꠔꠥꠝꠞꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT26_17","006_26_17","DEU","26","17","17","ꠔꠥꠝꠞꠣ ꠔ ꠀꠁꠎ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠍ, ꠅꠃ ꠀꠟ꠆ꠟꠣꠃ ꠅꠁꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠙꠕꠦ ꠌꠟꠛꠣꠄ, ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ, ꠔꠣꠘ ꠡꠞꠤꠅꠔ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠛꠣꠄ, ꠔꠣꠘ ꠇꠕꠣ ꠢꠥꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT26_18","006_26_18","DEU","26","18","18","ꠄꠞꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦꠅ ꠀꠁꠎ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠔꠣꠘ ꠙ꠆ꠞꠎꠣ, ꠔꠥꠝꠞꠣꠃ ꠔꠣꠘ ꠈꠣꠍ ꠡꠝ꠆ꠙꠖ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT26_19","006_26_19","DEU","26","19","19","ꠔꠣꠁꠘ ꠀꠞꠅ ꠇꠁꠞꠣ, ꠔꠣꠘ ꠙꠄꠖꠣ ꠇꠞꠣ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠠ ꠇꠞꠛꠣ। ꠔꠥꠝꠞꠣꠞ ꠁꠎ꠆ꠎꠔ, ꠡꠥꠘꠣꠝ ꠀꠞ ꠔꠣꠞꠤꠚ, ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠞꠁꠛ। ꠔꠣꠘ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣ ꠅꠁꠛꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠄꠇ ꠙꠛꠤꠔ꠆ꠞ ꠙ꠆ꠞꠎꠣ।” ");
INSERT INTO syls_vpl VALUES ("DT27_1","006_27_1","DEU","27","1","1","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠁꠎ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠝꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT27_2","006_27_2","DEU","27","2","2","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠁꠛꠣꠄ, ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠇꠁꠄꠇꠐꠣ ꠛꠠ ꠛꠠ ꠙꠣꠔ꠆ꠔꠞ ꠈꠣꠠꠣ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠀ, ꠁꠔꠣꠞꠦ ꠌꠥꠘꠣ ꠖꠤꠀ ꠙꠣꠇꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT27_3","006_27_3","DEU","27","3","3","ꠀꠞ ꠅꠔꠣꠞ ꠃꠙꠞꠦ ꠅꠃ ꠔꠃꠞꠣꠔꠞ ꠔꠣꠝꠣꠝ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠟꠦꠈꠤꠅ। ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ, ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠁꠘ ꠕꠣꠇꠤ ꠢꠃ ꠖꠦꠡꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("DT27_4","006_27_4","DEU","27","4","4","ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠁꠛꠣꠟ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠀ, ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠀꠁꠎꠇꠥꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣ ꠢꠃ ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟ ꠢꠣꠎꠣꠁꠀ ꠈꠣꠠꠣ ꠇꠞꠤꠅ, ꠀꠞ ꠁꠔꠣꠞꠦ ꠌꠥꠘꠣ ꠖꠤꠀ ꠙꠣꠇꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT27_5","006_27_5","DEU","27","5","5","ꠀꠞ ꠢꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠅ। ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠟꠥꠀꠞ ꠇꠥꠘꠥ ꠀꠔꠤꠀꠞ ꠟꠣꠉꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT27_6","006_27_6","DEU","27","6","6","ꠀꠡ꠆ꠔꠣ ꠀꠡ꠆ꠔꠣ ꠙꠣꠔ꠆ꠔꠞ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠅ, ꠛꠣꠘꠣꠁꠀ ꠄꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT27_7","006_27_7","DEU","27","7","7","ꠀꠞ ꠍꠣꠟꠣꠝꠔꠤ ꠇꠥꠞꠛꠣꠘꠤꠅ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT27_8","006_27_8","DEU","27","8","8","ꠀꠞ ꠌꠥꠘꠣ ꠟꠦꠙꠣ ꠢꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠔꠃꠞꠣꠔꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠅꠇꠟ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠟꠦꠈꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("DT27_9","006_27_9","DEU","27","9","9","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠘꠤꠞꠣꠁ ꠅꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠅ, ꠅꠈꠘ ꠔ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠙ꠆ꠞꠎꠣ ꠛꠘꠤꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("DT27_10","006_27_10","DEU","27","10","10","ꠔꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠤꠅ, ꠀꠞ ꠀꠝꠤ ꠀꠁꠎ ꠎꠦꠔꠣ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ, ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠣꠘꠣꠁꠟꠣꠝ, ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("DT27_11","006_27_11","DEU","27","11","11","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠅꠃ ꠖꠤꠘ ꠝꠣꠘꠡꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT27_12","006_27_12","DEU","27","12","12","“ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠅꠃ ꠡꠝꠄ ꠡꠤꠝꠤꠅꠘ, ꠟꠦꠛꠤ, ꠄꠢꠥꠖꠣ, ꠁꠍꠣꠈꠞ, ꠁꠃꠍꠥꠚ, ꠀꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠉꠤꠀ ꠘꠦꠇ ꠖꠥꠀꠞ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠉꠞꠤꠍꠤꠝ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT27_13","006_27_13","DEU","27","13","13","ꠀꠞ ꠛꠖ꠆ꠖꠥꠀꠞ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠞꠥꠛꠦꠘ, ꠍꠣꠖꠥ, ꠀꠡꠤꠞ, ꠍꠛꠥꠟꠘ, ꠖꠣꠘ ꠀꠞ ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ ꠉꠤꠀ ꠁꠛꠣꠟ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT27_14","006_27_14","DEU","27","14","14","ꠛꠣꠖꠦ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠃꠛꠣꠁꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠔꠣꠝꠣꠝ ꠝꠣꠘꠡꠞꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("DT27_15","006_27_15","DEU","27","15","15","“ꠎꠦ ꠝꠣꠘꠡꠦ ꠟꠣꠇꠠꠤ ꠛꠣ ꠙꠣꠔ꠆ꠔꠞ ꠈꠥꠖꠤꠀ, ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠛꠣ ꠙꠤꠔꠟ ꠉꠟꠣꠁꠀ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠄ, ꠀꠞ ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠅꠉꠥꠞꠦ ꠘꠤꠀ ꠟꠥꠇꠣꠁꠟ ꠎꠣꠉꠣꠔ ꠕꠄ, ꠢꠦ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁ ꠝꠥꠞ꠆ꠔꠤꠞꠦ ꠔ ꠝꠣꠛꠥꠖꠦ ꠊꠤꠘ ꠇꠞꠂꠘ, ꠁꠔꠣ ꠈꠣꠟꠤ ꠇꠣꠝꠣꠞꠞ ꠀꠔꠞ ꠇꠣꠝ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_16","006_27_16","DEU","27","16","16","“ꠝꠣ-ꠛꠣꠚꠞꠦ ꠎꠦꠉꠤꠄ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠦ, ꠢꠦ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_17","006_27_17","DEU","27","17","17","“ꠖꠈꠟꠖꠣꠞꠤꠞ ꠘꠤꠅꠔꠦ ꠎꠝꠤꠘꠞ ꠀꠁꠟ ꠛꠣ ꠡꠤꠝꠣꠘꠣ ꠈꠥꠐꠤ ꠎꠦꠉꠤꠄ ꠢꠞꠣꠄ, ꠢꠦ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_18","006_27_18","DEU","27","18","18","“ꠀꠘ꠆ꠖꠣ ꠝꠣꠘꠡꠞꠦ ꠎꠦꠉꠤꠄ ꠜꠥꠟ ꠙꠕ ꠖꠦꠈꠣꠁ ꠖꠦꠄ, ꠢꠦ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_19","006_27_19","DEU","27","19","19","“ꠛꠤꠖꠦꠡꠤ ꠝꠥꠍꠣꠚꠤꠞ, ꠄꠔꠤꠝ, ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠛꠤꠌꠣꠞ-ꠡꠣꠟꠤꠡꠤꠔ ꠎꠦꠉꠤꠄ ꠛꠦ-ꠁꠘꠍꠣꠚꠤ ꠇꠞꠦ, ꠢꠦ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_20","006_27_20","DEU","27","20","20","“ꠢꠣꠔꠘ ꠝꠣʼꠞ ꠟꠉꠦ ꠎꠦꠉꠤꠄ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠀꠙꠘ ꠛꠣꠚꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠦ। ꠢꠦ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_21","006_27_21","DEU","27","21","21","“ꠇꠥꠘꠥ ꠙꠡꠥꠞ ꠟꠉꠦ ꠎꠦꠉꠤꠄ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_22","006_27_22","DEU","27","22","22","“ꠎꠦꠉꠤꠄ ꠘꠤꠎꠞ ꠛꠁꠘꠞ ꠟꠉꠦ, ꠢꠣꠔꠘ ꠝꠣʼꠞ, ꠛꠣ ꠢꠣꠔꠘ ꠛꠣꠚꠞ ꠔꠞꠚꠣ ꠛꠁꠘꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_23","006_27_23","DEU","27","23","23","“ꠘꠤꠎꠞ ꠢꠠꠤꠞ ꠟꠉꠦ ꠎꠦꠉꠤꠄ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_24","006_27_24","DEU","27","24","24","“ꠎꠦꠉꠤꠄ ꠟꠥꠇꠣꠁꠀ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠘ ꠇꠞꠦ, ꠢꠦ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_25","006_27_25","DEU","27","25","25","“ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠌꠥꠇ꠆ꠔꠤꠄ ꠎꠦꠉꠤꠄ ꠐꠦꠇꠣ ꠈꠣꠄ, ꠢꠦ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT27_26","006_27_26","DEU","27","26","26","“ꠅꠃ ꠡꠞꠤꠅꠔꠞ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠦꠉꠤꠄ ꠝꠣꠘꠦ ꠘꠣ, ꠎꠦꠉꠤꠄ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠦ ꠘꠣ, ꠢꠦ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦ ꠇꠁꠅ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT28_1","006_28_1","DEU","28","1","1","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠀꠝꠤ ꠀꠁꠎ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠖꠤꠞꠣꠝ, ꠅꠔꠣ ꠀꠝꠟ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞꠦ ꠈꠤꠀꠟ ꠇꠞꠤ ꠝꠣꠘꠅ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠖꠥꠘꠤꠀꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠌꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_2","006_28_2","DEU","28","2","2","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠟꠦ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠞꠢꠝꠔ ꠙꠣꠁꠛꠣꠄ, ꠀꠞ ꠅꠃ ꠞꠢꠝꠔ ꠅꠇꠟ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠛ, ");
INSERT INTO syls_vpl VALUES ("DT28_3","006_28_3","DEU","28","3","3","“ꠔꠥꠝꠞꠣꠞ ꠛꠡꠔ-ꠛꠣꠠꠤ ꠀꠞ ꠈꠦꠔ-ꠈꠣꠝꠣꠞꠞ ꠝꠣꠎꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_4","006_28_4","DEU","28","4","4","“ꠔꠣꠘ ꠞꠢꠝꠔꠦ ꠔꠥꠝꠞꠣ ꠛꠃꠔ ꠀꠅꠟꠣꠖ ꠙꠣꠁꠛꠣꠄ, ꠎꠝꠤꠘꠅ ꠛꠃꠔ ꠚꠡꠟ ꠚꠟꠤꠛ, ꠉꠞꠥ-ꠍꠣꠉꠟꠦ ꠛꠃꠔ ꠛꠣꠁꠌ꠆ꠌꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_5","006_28_5","DEU","28","5","5","“ꠔꠥꠝꠣꠞ ꠃꠉꠣꠞꠅ ꠀꠞ ꠔꠥꠝꠣꠞ ꠌꠣꠃꠟꠞ ꠝꠐꠇꠤꠔ ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_6","006_28_6","DEU","28","6","6","“ꠢꠇꠟ ꠢꠣꠟꠔꠦ ꠢꠇꠟ ꠇꠣꠝꠅ ꠔꠥꠝꠤ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_7","006_28_7","DEU","28","7","7","“ꠖꠥꠡꠝꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠎꠦꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠛꠣ, ꠝꠣꠛꠥꠖꠦ ꠁꠔꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠞꠣꠁꠛꠣ। ꠔꠣꠞꠣ ꠄꠇ ꠖꠥꠀꠞꠦꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠞꠣꠔ ꠀꠁꠟꠦ, ꠡꠣꠔ ꠖꠥꠀꠞꠦꠖꠤ ꠜꠣꠉꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_8","006_28_8","DEU","28","8","8","“ꠔꠥꠝꠞꠣꠞ ꠃꠉꠣꠞꠞ ꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠦ ꠛꠞꠇꠔ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠎꠦ ꠇꠣꠝꠅ ꠀꠔ ꠖꠤꠛꠣꠄ, ꠅꠃ ꠇꠣꠝꠅꠃ ꠔꠣꠁꠘ ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠣꠘ ꠇꠞꠞꠣ, ꠢꠘꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_9","006_28_9","DEU","28","9","9","“ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ, ꠔꠣꠘ ꠛꠣꠔꠣꠁꠟ ꠙꠕꠦ ꠌꠟꠅ, ꠔꠦ ꠔꠣꠁꠘ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦꠟꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠅꠟꠣ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠛꠤꠔ꠆ꠞ ꠙ꠆ꠞꠎꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠣꠁꠝ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_10","006_28_10","DEU","28","10","10","ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠖꠦꠈꠛꠣ, ꠔꠥꠝꠞꠣꠃ ꠅꠁꠟꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠈꠣꠍ ꠝꠣꠘꠥꠡ, ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠒꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_11","006_28_11","DEU","28","11","11","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠍꠝ ꠈꠣꠁꠍꠟꠣ, ꠅꠃ ꠖꠦꠡꠅ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠃꠔ ꠜꠣꠟꠣꠁ ꠇꠞꠛꠣ, ꠔꠥꠝꠞꠣꠞꠦ ꠛꠃꠔ ꠀꠅꠟꠣꠖ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠙꠣꠟꠣꠁꠘ꠆ꠔꠦ ꠛꠃꠔ ꠛꠣꠁꠌ꠆ꠌꠣ ꠖꠤꠛꠣ, ꠎꠝꠤꠘꠅ ꠛꠃꠔ ꠚꠡꠟ ꠚꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_12","006_28_12","DEU","28","12","12","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠀꠍꠝꠣꠘꠤ ꠞꠢꠝꠔꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠀ ꠖꠤꠛꠣ, ꠎꠞꠥꠞ ꠝꠣꠚꠤꠇ ꠝꠦꠊ-ꠙꠣꠘꠤ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠞ ꠢꠇꠟ ꠇꠣꠝꠞ ꠝꠣꠎꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ, ꠛꠃꠔ ꠎꠣꠔꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠀꠅꠟꠣꠔ ꠖꠤꠛꠣꠄ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠀꠅꠟꠣꠔ ꠘꠤꠛꠣꠞ ꠖꠞꠇꠣꠞ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_13","006_28_13","DEU","28","13","13","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠛꠣꠘꠣꠁꠛꠣ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠦ ꠞꠅ, ꠇꠦꠃꠞꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ ꠘꠣ ꠕꠣꠇꠅ। ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠅꠇꠟ ꠈꠥꠛ ꠎꠔꠘ ꠇꠞꠤꠀ ꠀꠝꠟ ꠇꠞꠤꠅ, ꠎꠦꠔꠣ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠀꠞ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠞꠁꠛꠣꠄ, ꠔꠟꠦ ꠙꠠꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_14","006_28_14","DEU","28","14","14","ꠀꠞ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠀꠝꠣꠞ ꠅꠃ ꠔꠣꠟꠤꠝ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠢꠞꠤꠅ ꠘꠣ। ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠈꠞꠦꠖꠤ ꠖꠃꠠꠣꠁꠀ ꠁꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_15","006_28_15","DEU","28","15","15","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠘꠣ ꠝꠣꠘꠅ, ꠔꠣꠘ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠁꠎ ꠀꠝꠤ ꠎꠣꠘꠣꠁꠍꠤ, ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠁꠔꠣ ꠘꠣ ꠝꠣꠘꠟꠦ, ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠅꠃ ꠟꠣꠘ꠆ꠘꠔ ꠅꠇꠟ ꠙꠠꠛ, ꠁꠔꠣ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠛ: ");
INSERT INTO syls_vpl VALUES ("DT28_16","006_28_16","DEU","28","16","16","“ꠔꠥꠝꠞꠣꠞ ꠛꠡꠔ-ꠛꠣꠠꠤ, ꠈꠦꠔ-ꠈꠣꠝꠣꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_17","006_28_17","DEU","28","17","17","“ꠔꠥꠝꠞꠣꠞ ꠃꠉꠣꠞꠅ ꠀꠞ ꠌꠣꠃꠟꠞ ꠝꠐꠇꠤꠔ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_18","006_28_18","DEU","28","18","18","“ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠇꠝ ꠎꠘꠝꠤꠛꠣ, ꠎꠝꠤꠘꠅ ꠚꠄ-ꠚꠡꠟ ꠇꠝꠤꠎꠤꠛ, ꠉꠞꠥ-ꠍꠣꠉꠟꠦ ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠝ ꠖꠤꠛꠣ, ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_19","006_28_19","DEU","28","19","19","“ꠊꠞꠅ ꠛꠣ ꠛꠣꠁꠞꠣ ꠢꠇꠟ ꠈꠣꠘꠅ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠤ ꠖꠤꠘ ꠟꠣꠘ꠆ꠘꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_20","006_28_20","DEU","28","20","20","“ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤ ꠎꠣꠅꠀꠄ, ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠝꠣꠎꠦ ꠔꠣꠁꠘ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠛꠣ। ꠛꠣꠟꠣ-ꠝꠍꠤꠛꠔꠅ ꠙꠠꠤꠀ, ꠀꠟ꠆ꠟꠣꠁ ꠉꠎꠛꠞ ꠎꠣꠔꠣꠄ, ꠔꠥꠝꠞꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠈꠣꠟꠤ ꠇ꠆ꠇꠄ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_21","006_28_21","DEU","28","21","21","ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠞꠣꠄ, ꠝꠣꠛꠥꠖꠦ ꠢꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠝꠣꠞ ꠍꠣꠠꠤꠛꠣ, ꠛꠦꠝꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠝꠞꠔꠦ ꠝꠞꠔꠦ ꠢꠃ ꠖꠦꠡꠅ ꠕꠣꠇꠤ ꠛꠤꠘꠣꠡ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_22","006_28_22","DEU","28","22","22","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟꠅ ꠘꠡ꠆ꠐ ꠅꠀ ꠛꠦꠝꠣꠞ, ꠛꠣꠇ꠆ꠇꠣ ꠔꠣꠙ ꠀꠞ ꠎꠟꠣ-ꠚꠥꠠꠣ, ꠅꠔꠣ ꠛꠦꠝꠣꠞꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠖꠤꠛꠣ। ꠀꠞ ꠝꠞꠇꠤ, ꠢꠥꠇꠘꠣ ꠉꠞꠝ ꠛꠣꠔꠣꠡ, ꠚꠡꠟꠞ ꠢꠥꠘꠣ-ꠇꠣꠘꠤ ꠢꠥꠇꠣꠁ ꠎꠣꠅꠀꠞ ꠛꠦꠝꠣꠞ ꠀꠞ ꠙꠣꠔꠣ ꠝꠞꠣ, ꠅꠔꠣ ꠉꠎꠛ ꠅꠇꠟ ꠔꠥꠝꠞꠣꠞ ꠎꠝꠤꠘꠅ ꠖꠤꠛꠣ। ꠔꠥꠝꠞꠣ ꠝꠞꠤꠀ ꠚꠥꠠꠣꠘꠤꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁ ꠉꠎꠛ ꠔꠥꠝꠞꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_23","006_28_23","DEU","28","23","23","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠞ ꠀꠍꠝꠣꠘ ꠅꠁꠛ ꠙꠤꠔꠟꠞ ꠟꠣꠈꠣꠘ ꠡꠇ꠆ꠔ, ꠀꠞ ꠙꠣꠅꠞ ꠔꠟꠞ ꠎꠝꠤꠘ ꠅꠁꠛ ꠟꠥꠀꠞ ꠟꠣꠈꠣꠘ ꠇꠑꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT28_24","006_28_24","DEU","28","24","24","ꠝꠣꠛꠥꠖꠦ ꠝꠦꠊꠞ ꠛꠖꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠡꠅ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠗꠥꠁꠟ ꠍꠣꠠꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠢꠣꠝꠦꠡꠣ ꠙꠠꠣꠔ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_25","006_28_25","DEU","28","25","25","“ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞ ꠝꠥꠇꠣꠛꠤꠟꠣꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞꠣꠁꠛꠣ, ꠄꠞꠣꠞꠦ ꠄꠇ ꠙꠕꠦꠖꠤ ꠝꠣꠞꠣꠔ ꠉꠦꠟꠦ ꠡꠣꠔ ꠙꠕꠦꠖꠤ ꠜꠣꠉꠤꠛꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠖꠡꠣ ꠖꠦꠈꠤꠀ ꠎꠉꠔꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_26","006_28_26","DEU","28","26","26","ꠔꠥꠝꠞꠣꠞ ꠟꠣꠡ ꠅꠁꠛ ꠙꠡꠥ-ꠙꠣꠈꠤꠘ꠆ꠔꠞ ꠈꠥꠞꠣꠇ। ꠁꠔꠣꠞꠦ ꠈꠦꠖꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠦꠃ ꠞꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_27","006_28_27","DEU","28","27","27","ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠉꠔꠞꠅ ꠉꠎꠛꠤ ꠛꠤꠡ-ꠚꠥꠞꠤ, ꠐꠤꠃꠝꠣꠞ, ꠚꠥꠐ-ꠈꠣꠃꠎꠟꠤ ꠛꠦꠝꠣꠞ ꠖꠤꠛꠣ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠇꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT28_28","006_28_28","DEU","28","28","28","ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠉꠟ, ꠀꠘ꠆ꠖꠣ ꠀꠞ ꠛꠦꠖꠤꠡꠣ ꠛꠣꠘꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_29","006_28_29","DEU","28","29","29","ꠀꠘ꠆ꠖꠣꠄ ꠎꠦꠟꠣ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠀꠔꠣꠁ ꠀꠔꠣꠁ ꠀꠐꠦ, ꠔꠥꠝꠞꠣ ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠅꠟꠣ ꠀꠐꠤꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠇꠣꠝꠃ ꠇꠣꠝꠤꠀꠛ ꠅꠁꠔ ꠘꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠎꠥꠟꠥꠝ ꠀꠞ ꠟꠥꠐ-ꠔꠞꠣꠎ ꠌꠟꠛ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠦꠃ ꠀꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_30","006_28_30","DEU","28","30","30","“ꠡꠣꠖꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦ ꠇꠁꠘꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠣꠞ ꠀꠈꠔ ꠅꠁꠛ, ꠀꠞꠇ ꠛꠦꠐꠣꠄ ꠀꠁꠀ ꠅꠃ ꠇꠁꠘꠣꠞ ꠁꠎ꠆ꠎꠔ ꠟꠥꠐꠤꠛ। ꠔꠥꠝꠤ ꠊꠞ ꠛꠣꠘꠣꠁꠛꠣꠄ, ꠅꠁꠟꠦ ꠊꠞꠅ ꠛꠡꠔ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘ ꠇꠞꠤꠀ, ꠚꠟ ꠈꠣꠅꠀ ꠇꠙꠣꠟꠅ ꠎꠥꠐꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_31","006_28_31","DEU","28","31","31","ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ ꠎꠛ ꠇꠞꠣ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠄꠇ ꠐꠥꠇꠞꠣ ꠉꠥꠡ꠆ꠔꠅ ꠔꠥꠝꠞꠣꠞ ꠙꠦꠐꠅ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠉꠣꠗꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ, ꠁꠔꠣ ꠀꠞ ꠚꠤꠞꠔ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠝꠦꠠꠣ-ꠍꠣꠉꠟ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠎꠣꠁꠛ, ꠅꠔꠣ ꠛꠤꠙꠖ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠦꠃ ꠀꠉꠥꠀꠁ ꠀꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_32","006_28_32","DEU","28","32","32","ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠖꠥꠍꠞꠣ ꠎꠣꠔꠤꠞ ꠀꠔꠅ ꠀꠐꠇ ꠅꠁꠛꠣ, ꠔꠣꠞꠣꠞ ꠀꠡꠣꠄ ꠛꠣꠞ ꠌꠣꠁꠔꠦ ꠌꠣꠁꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠎꠥꠔꠤ ꠘꠡ꠆ꠐ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_33","006_28_33","DEU","28","33","33","ꠔꠥꠝꠞꠣꠞ ꠅꠌꠤꠘꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠞ ꠚꠄ-ꠚꠡꠟ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠦꠘꠔꠞ ꠢꠇꠟ ꠝꠎꠥꠞꠤ ꠟꠥꠐꠤꠀ ꠘꠤꠛꠉꠤ, ꠔꠥꠝꠞꠣ ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠣꠟꠤ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠙꠣꠁꠛꠣꠄ ꠀꠞ ꠌꠥꠞꠝꠣꠞ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_34","006_28_34","DEU","28","34","34","ꠔꠥꠝꠞꠣꠞ ꠌꠃꠈꠦ ꠁ ꠟꠣꠈꠣꠘ ꠀꠞꠅ ꠎꠦꠔꠣ ꠖꠦꠈꠛꠣꠄ, ꠖꠦꠈꠤꠀ ꠝꠣꠕꠣ ꠈꠣꠞꠣꠙ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_35","006_28_35","DEU","28","35","35","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠞꠣꠔꠅ ꠀꠞ ꠀꠐꠥꠔ ꠡꠥꠞꠥ ꠇꠞꠤꠀ, ꠙꠣꠅꠞ ꠔꠟꠣ ꠕꠣꠇꠤ ꠝꠣꠕꠣꠞ ꠔꠣꠟꠥ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠡ꠆ꠔꠣ ꠉꠔꠞꠅ ꠛꠤꠡ-ꠚꠥꠞꠤ ꠖꠤꠛꠣ, ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠡꠤꠚꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT28_36","006_28_36","DEU","28","36","36","“ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠣꠞꠦ ꠉꠖꠤꠔ ꠛꠅꠀꠁꠛꠣꠄ, ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠛꠣꠖꠡꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠣꠁꠀ ꠅꠝꠘ ꠄꠇ ꠎꠣꠔꠤꠞ ꠀꠔꠅ ꠚꠣꠟꠣꠁꠛꠣ, ꠎꠦꠔꠣꠞ ꠘꠣꠝꠃ ꠔꠥꠝꠞꠣ ꠢꠥꠘꠍ ꠘꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠄꠅ ꠢꠥꠘꠍꠂꠘ ꠘꠣ। ꠢꠘꠅ ꠉꠤꠀ ꠔꠥꠝꠞꠣ ꠙꠣꠔ꠆ꠔꠞ ꠀꠞ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_37","006_28_37","DEU","28","37","37","ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠛꠣ, ꠢꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠌꠝꠇꠤꠎꠤꠛ, ꠔꠥꠝꠞꠣꠞ ꠖꠡꠣ ꠌꠤꠠ ꠀꠞ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣꠞ ꠛꠤꠡꠄ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_38","006_28_38","DEU","28","38","38","“ꠔꠥꠝꠞꠣ ꠈꠦꠔ ꠇꠞꠛꠣꠄ ꠛꠃꠔ, ꠅꠁꠟꠦ ꠚꠡꠟ ꠙꠣꠁꠛꠣꠄ ꠕꠥꠠꠣ, ꠇꠣꠞꠘ ꠙꠋꠉꠙꠣꠟꠦ ꠈꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_39","006_28_39","DEU","28","39","39","ꠔꠥꠝꠞꠣ ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘ ꠇꠞꠤꠀ ꠎꠣꠄ-ꠎꠔꠘ ꠇꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠇꠤꠠꠣ ꠀꠞ ꠙꠥꠇꠦ ꠛꠣꠉꠣꠘ ꠈꠣꠁꠟꠤꠛ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠋꠉꠥꠞꠅ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ, ꠄꠞ ꠡꠞꠛꠔꠅ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_40","006_28_40","DEU","28","40","40","ꠔꠥꠝꠞꠣꠞ ꠢꠣꠞꠣ ꠖꠦꠡ ꠎꠄꠔꠥꠘ ꠉꠣꠍꠦ ꠜꠞꠣ ꠞꠁꠟꠦꠅ, ꠎꠄꠔꠥꠘ ꠚꠟ ꠏꠞꠤꠀ ꠙꠠꠤꠎꠤꠛ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟꠅ ꠔꠦꠟ ꠝꠣꠈꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_41","006_28_41","DEU","28","41","41","ꠔꠥꠝꠞꠣꠞ ꠎꠔ ꠀꠅꠟꠣꠖ ꠅꠁꠛꠣ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠁꠔꠣ ꠘꠣꠄ, ꠁꠔꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_42","006_28_42","DEU","28","42","42","ꠉꠎꠛꠤ ꠝꠃꠀ-ꠙꠥꠇꠞ ꠙꠣꠟ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤ ꠀꠞ ꠚꠡꠟ ꠈꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_43","006_28_43","DEU","28","43","43","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠃꠙꠞꠦꠖꠤ ꠃꠑꠛꠣ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠟꠦꠖꠤ ꠟꠣꠝꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_44","006_28_44","DEU","28","44","44","ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠀꠅꠟꠣꠔ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠀꠅꠟꠣꠔ ꠖꠤꠛꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠅꠁꠔ ꠘꠣꠄ। ꠔꠣꠞꠣ ꠞꠁꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠦ, ꠔꠥꠝꠞꠣ ꠞꠁꠛꠣꠄ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("DT28_45","006_28_45","DEU","28","45","45","“ꠅꠃ ꠔꠣꠝꠣꠝ ꠟꠣꠘ꠆ꠘꠔ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠙꠠꠛ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠘꠣ ꠌꠟꠣꠄ, ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠘꠣ ꠝꠣꠘꠣꠄ ꠅꠃ ꠟꠣꠘ꠆ꠘꠔ ꠅꠇꠟ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠟ ꠞꠁꠛ। ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠔꠤꠀ ꠗꠞꠤꠀ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_46","006_28_46","DEU","28","46","46","ꠅꠃ ꠟꠣꠘ꠆ꠘꠔ ꠅꠇꠟ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠃꠙꠞꠦ, ꠎꠥꠉ ꠎꠥꠉ ꠗꠞꠤ ꠇꠥꠖꠞꠔꠤ ꠢꠥꠡꠤꠀꠞꠤ ꠢꠤꠡꠣꠛꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_47","006_28_47","DEU","28","47","47","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠡꠥꠖꠤꠘꠞ ꠇꠣꠟꠅ ꠝꠘꠞ ꠈꠥꠡꠤꠄ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠍ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("DT28_48","006_28_48","DEU","28","48","48","ꠄꠞꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠈꠞꠦꠖꠤ ꠖꠥꠡꠝꠘ ꠟꠣꠉꠣꠁꠛꠣ, ꠔꠥꠝꠞꠣ ꠙꠦꠐꠞ ꠜꠥꠇꠦ, ꠙꠣꠘꠤꠞ ꠙꠤꠀꠍꠦ, ꠅꠜꠣꠛ-ꠅꠘꠐꠘꠦ ꠢꠇꠤꠞ ꠛꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠛꠣꠄ। ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠅ ꠟꠥꠀꠞ ꠎꠥꠀꠟ ꠚꠤꠘ꠆ꠖꠣꠁꠛꠣ, ꠅꠃ ꠎꠥꠀꠟꠤꠞ ꠔꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠘꠣꠡ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_49","006_28_49","DEU","28","49","49","“ꠝꠣꠛꠥꠖꠦ ꠛꠃꠔ ꠖꠥꠞꠁ ꠕꠣꠇꠤ, ꠎꠉꠔꠞ ꠢꠦꠡ ꠡꠤꠝꠣꠘꠣ ꠕꠣꠇꠤ, ꠅꠟꠣ ꠄꠇ ꠎꠣꠔꠤꠞꠦ ꠌꠤꠟꠞ ꠘꠝꠥꠘꠣꠄ ꠃꠠꠣꠁꠀ ꠀꠘꠛꠣ, ꠎꠦꠔꠣꠞ ꠝꠥꠈꠞ ꠛꠥꠟꠤ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_50","006_28_50","DEU","28","50","50","ꠁꠔꠣꠞ ꠉꠑꠘ ꠅꠁꠛ ꠛꠖꠍꠥꠞꠔ, ꠁꠔꠣꠄ ꠇꠥꠘꠥ ꠛꠥꠠꠣ-ꠛꠥꠠꠤꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠤꠔꠣ ꠘꠣꠄ, ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦꠅ ꠝꠣꠄꠀ ꠇꠞꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_51","006_28_51","DEU","28","51","51","ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠙꠡꠥꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠞ ꠈꠦꠔꠞ ꠚꠡꠟ ꠈꠣꠁꠟꠤꠛꠣ, ꠢꠦꠡ-ꠝꠦꠡ ꠔꠥꠝꠞꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠛꠣꠄ। ꠔꠣꠞꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠚꠡꠟ, ꠘꠄꠀ ꠇꠥꠘꠥ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ, ꠔꠦꠟ, ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣ, ꠇꠥꠘ꠆ꠔꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠕꠁꠔꠣ ꠘꠣꠄ, ꠢꠦꠡ-ꠝꠦꠡ ꠔꠥꠝꠞꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_52","006_28_52","DEU","28","52","52","ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠛꠣ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠞꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠃꠌꠣ ꠃꠌꠣ ꠝꠎꠛꠥꠔ ꠛꠣꠃꠘ꠆ꠒꠞꠤꠞ ꠅꠀꠟ ꠅꠇꠟ ꠢꠦꠡ-ꠝꠦꠡ ꠜꠣꠋꠉꠤꠀ ꠙꠠꠤꠎꠤꠛ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠞꠣ, ꠢꠃ ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟ ꠉꠣꠃ ꠀꠞ ꠐꠣꠃꠘ ꠔꠣꠞꠣ ꠛꠦꠞꠤꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_53","006_28_53","DEU","28","53","53","“ꠀꠞ ꠖꠥꠡꠝꠘꠦ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠣꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠞꠣ ꠅꠔ ꠛꠠ ꠝꠍꠤꠛꠔꠅ ꠙꠠꠛꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠞꠦ ꠈꠣꠁꠟꠤꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠀꠅꠟꠣꠖꠞ ꠉꠥꠡ꠆ꠔ ꠘꠤꠎꠦ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_54","006_28_54","DEU","28","54","54","ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣ ꠜꠣꠟꠣ ꠝꠣꠘꠥꠡ, ꠎꠦꠞꠣ ꠡꠥꠈꠦ ꠀꠞ ꠀꠞꠣꠝ-ꠀꠄꠄꠡꠦ ꠀꠍꠦ, ꠔꠣꠞꠣꠞ ꠝꠘ-ꠝꠤꠎꠣꠎꠅ ꠅꠟꠣꠈꠣꠘ ꠅꠁꠎꠤꠛ, ꠔꠣꠞꠣ ꠀꠙꠘ ꠜꠣꠁꠞꠦ, ꠘꠤꠎꠞ ꠛꠃꠞꠦ ꠀꠞ ꠛꠣꠇꠤ ꠙꠥꠀ-ꠙꠥꠠꠤꠞꠦ ꠇꠥꠘꠥ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_55","006_28_55","DEU","28","55","55","ꠢꠦ ꠔꠣꠞ ꠎꠦ ꠀꠅꠟꠣꠖꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛ, ꠁꠔꠣꠞ ꠄꠇꠈꠣꠘ ꠐꠥꠇꠞꠣꠅ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠔ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠖꠥꠡꠝꠘꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠙꠦꠐꠞ ꠜꠥꠇ ꠝꠤꠐꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥꠔꠣꠅ ꠝꠤꠟꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_56","006_28_56","DEU","28","56","56","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠈꠥꠛ ꠘꠞꠝ ꠖꠤꠟꠞ ꠎꠦ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠀꠍꠦ, ꠎꠦ ꠛꠦꠐꠤꠄ ꠡꠥꠇꠤꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠖꠣꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠝꠣꠐꠤꠔ ꠙꠣꠅ ꠚꠣꠟꠣꠁꠍꠦ ꠘꠣ, ꠢꠃ ꠛꠦꠐꠤꠄꠅ ꠔꠣꠁꠞ ꠎꠣꠘꠞ ꠐꠥꠇꠞꠣ ꠎꠣꠝꠣꠁ ꠛꠣ ꠀꠅꠟꠣꠖꠞ ꠛꠣꠄ ꠇꠥꠘꠥ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_57","006_28_57","DEU","28","57","57","ꠖꠥꠡꠝꠘꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠣꠄ ꠙꠦꠐꠞ ꠜꠥꠇꠞ ꠎꠣꠟꠣꠄ ꠀꠅꠟꠣꠖꠞ ꠎꠘꠝ ꠖꠦꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦ, ꠅꠃ ꠝꠣʼꠄ ꠘꠤꠎꠞ ꠀꠅꠟꠣꠖꠞ ꠉꠥꠡ꠆ꠔ, ꠀꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠤ ꠛꠣꠞꠅꠁꠟ ꠙꠥꠀꠔꠤ-ꠚꠥꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠟꠥꠇꠣꠁꠀ ꠈꠣꠁꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_58","006_28_58","DEU","28","58","58","“ꠅꠃ ꠇꠤꠔꠣꠛꠞ ꠝꠣꠎꠦ ꠡꠞꠤꠅꠔꠞ ꠎꠔ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠀꠝꠟ ꠘꠣ ꠇꠞꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ ꠀꠞ ꠒꠞ-ꠈꠚ ꠀꠟꠣ ꠘꠣꠝꠞ ꠁꠎ꠆ꠎꠔ ꠘꠣ ꠇꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("DT28_59","006_28_59","DEU","28","59","59","ꠔꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠛꠦꠝꠣꠞ ꠖꠤꠛꠣ, ꠅꠃ ꠛꠦꠝꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠟꠣꠝ꠆ꠛꠣ ꠡꠝꠄ ꠜꠥꠉꠣꠘ꠆ꠔꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_60","006_28_60","DEU","28","60","60","ꠝꠤꠡꠞꠅ ꠕꠣꠇꠔꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠎꠔ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣ ꠇꠣꠙꠤꠔꠣꠄ, ꠢꠃ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠖꠤꠛꠣ, ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠙꠤꠍ ꠍꠣꠠꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_61","006_28_61","DEU","28","61","61","ꠀꠞ ꠅꠃ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠅ ꠎꠦꠔꠣ ꠛꠦꠝꠣꠞꠞ ꠘꠣꠝ ꠟꠦꠈꠣ ꠘꠣꠁ, ꠅꠟꠣ ꠇꠑꠤꠘ ꠉꠎꠛꠤ ꠀꠞꠅ ꠛꠃꠔ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠍꠣꠠꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠌꠣꠟꠥ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_62","006_28_62","DEU","28","62","62","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠘꠣ ꠝꠣꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠡꠞ ꠙꠞꠤꠝꠣꠘ ꠅꠈꠘ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠃꠔ ꠛꠦꠡꠤ ꠅꠁꠟꠦꠅ, ꠁꠔꠣ ꠝꠞꠤꠀ ꠈꠥꠛ ꠕꠥꠠꠣ ꠛꠣꠌꠤꠀ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_63","006_28_63","DEU","28","63","63","ꠝꠣꠛꠥꠖꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠀꠄ-ꠃꠘ꠆ꠘꠔꠤ ꠖꠤꠀ ꠛꠣꠠꠣꠁꠍꠟꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠡꠞ ꠙꠞꠤꠝꠣꠘ ꠛꠠ ꠇꠞꠍꠟꠣ, ꠢꠃ ꠟꠣꠈꠣꠘ ꠈꠥꠡꠤ ꠇꠞꠤꠀ ꠅꠈꠘ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠀ ꠘꠤꠙꠣꠔ ꠇꠞꠛꠣ। ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠞꠣꠄ, ꠢꠃ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT28_64","006_28_64","DEU","28","64","64","“ꠛꠣꠖꠦ ꠎꠉꠔꠞ ꠄꠇ ꠇꠤꠘꠣꠞꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠇꠤꠘꠣꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠤꠔ꠆ꠞꠣꠁ ꠖꠤꠛꠣ। ꠢꠘꠅ ꠞꠁꠀ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠅꠌꠤꠘꠣ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠡꠦꠛꠣ ꠇꠞꠛꠣꠄ, ꠟꠣꠇꠠꠤ ꠀꠞ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠥꠞ꠆ꠔꠤꠞꠦ ꠙꠥꠎꠣ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_65","006_28_65","DEU","28","65","65","ꠢꠃ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠞꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠡꠣꠘ꠆ꠔꠤ ꠝꠤꠟꠔ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠀꠞꠣꠝꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠎꠣꠉꠣ ꠞꠁꠔ ꠘꠣꠄ। ꠢꠘꠅ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ ꠢꠣꠄ-ꠢꠥꠔꠣꠡ ꠛꠣꠠꠣꠁꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠢꠇꠟ ꠀꠡꠣ-ꠜꠞꠡꠣ, ꠀꠞ ꠖꠤꠟꠞ ꠡꠈꠞꠦ ꠔꠣꠁꠘ ꠘꠤꠞꠣꠡ, ꠘꠤꠡ꠆ꠔꠦꠎ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT28_66","006_28_66","DEU","28","66","66","ꠇꠤꠔꠣ ꠊꠐꠤꠛ ꠛꠣ ꠘꠣ ꠊꠐꠤꠛ ꠅꠔꠣ ꠌꠤꠘ꠆ꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠘ ꠉꠥꠎꠞꠤꠛ, ꠖꠤꠘ-ꠞꠣꠁꠔ ꠢꠣꠝꠦꠡꠣ ꠈꠣꠟꠤ ꠎꠣꠘꠞ ꠒꠞ-ꠜꠄꠄ ꠅꠡꠣꠘ꠆ꠔꠤꠔ ꠞꠁꠛꠣꠄ, ꠛꠣꠌꠤꠀ ꠞꠅꠀꠞ ꠇꠥꠘꠥ ꠘꠤꠌ꠆ꠌꠄꠅꠔꠣ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT28_67","006_28_67","DEU","28","67","67","ꠔꠥꠝꠞꠣ ꠝꠘꠞ ꠒꠞꠦ, ꠎꠣꠘꠞ ꠝꠣꠁꠞꠦ, ꠌꠃꠈꠦ ꠇꠥꠘꠥ ꠇꠥꠟ-ꠇꠤꠘꠣꠞ ꠘꠣ ꠖꠦꠈꠤꠀ ꠈꠣꠟꠤ ꠢꠣꠄ ꠢꠣꠄ ꠇꠞꠛꠣꠄ। ꠛꠤꠀꠘ ꠅꠁꠟꠦ ꠇꠁꠛꠣꠄ ꠎꠟꠖꠤ ꠞꠣꠁꠔ ꠅꠃꠇ, ꠀꠞ ꠞꠣꠁꠔ ꠅꠁꠟꠦ ꠇꠁꠛꠣꠄ ꠎꠟꠖꠤ ꠖꠤꠘ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("DT28_68","006_28_68","DEU","28","68","68","ꠢꠃ ꠎꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠇꠁꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠤꠘꠅ ꠀꠞ ꠎꠣꠅꠀ ꠅꠁꠔ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠢꠃ ꠉꠎꠛꠞ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠎꠅ ꠇꠞꠤ ꠢꠤꠞꠛꠣꠞ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠘꠦꠅꠀꠁꠛꠣ, ꠘꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠘꠅ ꠛꠤꠇꠤ ꠈꠣꠁꠔꠣꠄ ꠌꠣꠁꠛꠣꠄ, ꠅꠁꠟꠦ ꠇꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠤꠘꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT29_1","006_29_1","DEU","29","1","1","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠞꠚꠔꠦ ꠔꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞ ꠟꠉꠦ ꠀꠉꠦ ꠄꠇ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠇꠞꠍꠟꠣ, ꠅꠈꠘ ꠝꠥꠀꠛ ꠖꠦꠡꠅ ꠝꠣꠛꠥꠖꠦ ꠖꠥꠍꠞꠣ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠟꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠅꠃ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠡꠞ꠆ꠔ ꠅꠇꠟ। ");
INSERT INTO syls_vpl VALUES ("DT29_2","006_29_2","DEU","29","2","2","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠝꠤꠡꠞꠞ ꠚꠦꠞꠣꠃꠘꠞ ꠟꠉꠦ, ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠟꠉꠦ, ꠀꠞ ꠝꠤꠡꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠟꠉꠦ ꠎꠦꠔꠣ ꠇꠞꠍꠤꠟꠣ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣ ꠖꠦꠈꠍ। ");
INSERT INTO syls_vpl VALUES ("DT29_3","006_29_3","DEU","29","3","3","ꠛꠠ ꠛꠠ ꠀꠎꠛ ꠊꠐꠘꠣ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠘꠣꠘ ꠟꠣꠈꠣꠘ ꠘꠤꠡꠣꠘꠣ, ꠀꠞ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠔ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠍ। ");
INSERT INTO syls_vpl VALUES ("DT29_4","006_29_4","DEU","29","4","4","ꠅꠁꠟꠦ ꠁꠔꠣꠞ ꠝꠞ꠆ꠝ ꠛꠥꠎꠣꠞ ꠝꠔ ꠝꠘ, ꠖꠦꠈꠣꠞ ꠝꠔ ꠌꠃꠈ, ꠢꠥꠘꠣꠞ ꠝꠔ ꠇꠣꠘ, ꠝꠣꠛꠥꠖꠦ ꠅꠈꠘꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT29_5","006_29_5","DEU","29","5","5","ꠀꠝꠤ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠗꠞꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠍꠚꠞ ꠇꠞꠣꠁꠍꠤ, ꠄꠞꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠘꠡ꠆ꠐ ꠅꠁꠍꠦ ꠘꠣ, ꠙꠣꠅꠞ ꠎꠥꠔꠣꠅ ꠍꠤꠠꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT29_6","006_29_6","DEU","29","6","6","ꠇꠥꠘꠥ ꠜꠣꠔ-ꠞꠥꠐꠤꠅ ꠈꠣꠁꠍ ꠘꠣ, ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠛꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠡꠞꠣꠛ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠁꠍ ꠘꠣ। ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔ ꠔꠣꠁꠘꠃ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠅ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT29_7","006_29_7","DEU","29","7","7","“ꠔꠥꠝꠞꠣ ꠢꠃ ꠎꠣꠉꠣꠔ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ, ꠢꠤꠡꠛꠘꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘ ꠀꠞ ꠛꠣꠡꠘꠞ ꠛꠣꠖꠡꠣ ꠃꠎꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠔ ꠀꠁꠍꠟꠣ, ꠀꠁꠟꠦ ꠀꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠣꠁ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT29_8","006_29_8","DEU","29","8","8","ꠔꠣꠞꠣꠞ ꠖꠦꠡꠞꠦ ꠖꠈꠟꠅ ꠀꠘꠤꠀ ꠀꠝꠞꠣ ꠀꠡ꠆ꠔꠣ ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠀꠡ꠆ꠔꠣ ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘ ꠀꠞ ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠅꠞ꠆ꠗꠦꠇ ꠝꠣꠘꠡꠞꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT29_9","006_29_9","DEU","29","9","9","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠅꠃ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠝꠣꠘꠤꠅ, ꠝꠣꠘꠟꠦ ꠢꠇꠟ ꠇꠣꠝ-ꠇꠣꠎꠅ ꠔꠥꠝꠞꠣꠞ ꠚꠣꠄꠖꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT29_10","006_29_10","DEU","29","10","10","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠎ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠀꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠍ, ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠀꠝꠤꠞ ꠅꠇꠟ, ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ, ꠅꠚꠤꠡꠣꠞ ꠅꠇꠟ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("DT29_11","006_29_11","DEU","29","11","11","ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠃ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘ, ꠀꠞ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠢꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠎꠦꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠣꠞꠥ ꠚꠣꠠꠂꠘ ꠀꠞ ꠙꠣꠘꠤ ꠛꠁꠀ ꠀꠘꠂꠘ ꠔꠣꠞꠣꠅ ꠀꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT29_12","006_29_12","DEU","29","12","12","ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠅꠘꠅ ꠀꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠍ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠀꠁꠎ ꠛꠅꠀꠁꠟ ꠇꠞꠞꠣ, ꠅꠃ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠔ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠀꠁꠎ ꠢꠣꠝꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("DT29_13","006_29_13","DEU","29","13","13","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠀꠉꠞ ꠀꠝꠟꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ, ꠀꠞ ꠁꠀꠇꠥꠛ ꠘꠛꠤꠞ ꠟꠉꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠎꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠢꠃ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠅꠈꠘ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠈꠣꠍ ꠙ꠆ꠞꠎꠣ ꠛꠘꠤꠀ ꠞꠁꠔꠦ ꠞꠣꠎꠤ ꠀꠍ, ꠅꠈꠣꠘ ꠝꠣꠘꠣꠔ ꠀꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("DT29_14","006_29_14","DEU","29","14","15","ꠔꠦ ꠀꠝꠤ ꠅꠈꠘ ꠎꠦ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠞꠣꠝ, ꠁꠔꠣ ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠘꠣꠄ, ꠛꠞꠋ ꠔꠥꠝꠞꠣ ꠎꠔ ꠎꠘ ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠀꠍ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠀꠅꠟꠣꠖꠞ ꠎꠘꠝ ꠅꠈꠘꠅ ꠅꠁꠍꠦ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠟꠉꠦꠅ ꠅꠃ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠎꠣꠞꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT29_16","006_29_16","DEU","29","16","16","“ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠔ ꠎꠣꠘ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠝꠞꠣ ꠇꠤꠟꠣ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠍꠤ, ꠛꠣꠖꠦ ꠇꠔ ꠖꠦꠡ ꠀꠞ ꠇꠔ ꠙꠕ-ꠊꠣꠐ ꠙꠣꠞ ꠅꠁꠀ ꠅꠘꠅ ꠀꠁꠀ ꠀꠎꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT29_17","006_29_17","DEU","29","17","17","ꠔꠥꠝꠞꠣ ꠔ ꠅꠔꠣ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞꠦ ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠙꠣꠔ꠆ꠔꠞ ꠀꠞ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠎꠊꠁꠘ꠆ꠘ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠝꠥꠞ꠆ꠔꠤ ꠅꠇꠟꠞ ꠙꠥꠎꠣ ꠇꠞꠔꠦ ꠖꠦꠈꠍ। ");
INSERT INTO syls_vpl VALUES ("DT29_18","006_29_18","DEU","29","18","18","ꠔꠥꠝꠞꠣ ꠈꠥꠎ-ꠈꠛꠞ ꠟꠁꠀ ꠖꠦꠈꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠣꠘꠥ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠛꠦꠐꠣ ꠛꠣ ꠛꠦꠐꠤ, ꠇꠥꠘꠥ ꠛꠋꠡ ꠛꠣ ꠈꠣꠘ꠆ꠖꠣꠘ ꠘꠣ ꠕꠣꠇꠦ, ꠎꠦꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠛꠣꠖ ꠖꠤꠀ ꠢꠔꠣ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟꠤ ꠅꠁꠎꠣꠄ। ꠎꠥꠖꠤ ꠁꠟꠣ ꠇꠥꠘꠥꠉꠥ ꠕꠣꠇꠦ, ꠔꠦ ꠅꠉꠥ ꠅꠁꠟ ꠅꠟꠣ ꠛꠤꠡꠣꠇ꠆ꠔ ꠉꠣꠍꠞ ꠎꠠ, ꠎꠦ ꠎꠠꠞ ꠒꠦꠝ ꠅꠃ ꠛꠤꠡꠣꠇ꠆ꠔ ꠔꠤꠔ꠆ꠔꠣ ꠉꠣꠍ ꠛꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("DT29_19","006_29_19","DEU","29","19","19","ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠅꠃ ꠇꠍꠝ ꠈꠣꠅꠀꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀꠅ ꠎꠥꠖꠤ ꠔꠣꠞ ꠘꠤꠎꠞꠦ ꠈꠥꠛ ꠇꠙꠣꠟꠤ ꠝꠘꠅ ꠇꠞꠦ, ꠀꠞ ꠛꠦꠙꠞꠥꠀ ꠅꠁꠀ ꠌꠟꠟꠦꠅ ꠇꠥꠘꠥ ꠡꠝꠁꠡꠣ ꠘꠣꠁ ꠁꠟꠣ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠖꠥꠁꠅꠐꠣꠞ ꠃꠙꠞꠦ ꠅꠔꠣ ꠝꠣꠘꠡꠦ ꠡꠞ꠆ꠛꠘꠣꠡ ꠒꠣꠇꠤꠀ ꠀꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("DT29_20","006_29_20","DEU","29","20","20","ꠝꠣꠛꠥꠖꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠄꠞꠣꠞꠦ ꠝꠣꠚꠤ ꠖꠤꠔꠣ ꠘꠣꠄ, ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘ ꠖꠣꠃ ꠖꠣꠃ ꠇꠞꠤ ꠎꠟꠤꠀ ꠃꠑꠛ। ꠀꠞ ꠅꠃ ꠇꠤꠔꠣꠛꠞ ꠝꠣꠎꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠟꠣꠘ꠆ꠘꠔꠞ ꠇꠕꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠓꠣꠟꠤꠛꠣ, ꠝꠣꠛꠥꠖꠦ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT29_21","006_29_21","DEU","29","21","21","ꠔꠣꠁꠘ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠅ ꠚꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠍꠤꠀ ꠀꠟꠉ ꠇꠞꠛꠣ, ꠅꠃ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠝꠣꠎꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠟꠣꠘ꠆ꠘꠔꠞ ꠇꠕꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠍꠣꠠꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT29_22","006_29_22","DEU","29","22","22","“ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠅꠃ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠎꠔ ꠘꠝꠥꠘꠣꠞ ꠟꠣꠘ꠆ꠘꠔꠤ ꠉꠎꠛ ꠀꠞ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠓꠣꠟꠤꠛꠣ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠀꠞ ꠜꠤꠘ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠅꠀ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠇꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠁ ꠖꠡꠣ ꠖꠦꠈꠤꠀ ꠇꠣꠞꠘ ꠎꠤꠇꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT29_23","006_29_23","DEU","29","23","23","ꠘꠥꠘ ꠀꠞ ꠉꠘ꠆ꠖꠇꠦ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠝꠣꠐꠤ ꠎꠟꠤꠎꠤꠛ, ꠁ ꠝꠣꠐꠤꠔ ꠇꠥꠘ꠆ꠔꠣ ꠚꠟꠤꠔ ꠘꠣꠄ, ꠇꠥꠘ꠆ꠔꠣ ꠟꠣꠉꠣꠁꠟꠦ ꠅꠁꠔ ꠘꠣꠄ, ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠊꠣꠡ, ꠟꠔꠣ-ꠙꠣꠔꠣ ꠎꠘꠝꠤꠔ ꠘꠣꠄ। ꠁꠈꠣꠘ ꠢꠃ ꠟꠣꠘ꠆ꠘꠔꠤ ꠖꠦꠡ ꠍꠣꠖꠥꠝ, ꠀꠝꠥꠞꠣ, ꠅꠖꠝꠣ ꠀꠞ ꠍꠛꠂꠁꠝꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠤꠎꠤꠛ, ꠝꠣꠛꠥꠖꠞ ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘ ꠎꠟꠤꠀ ꠃꠑꠣꠄ ꠔꠣꠁꠘ ꠔ ꠁꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT29_24","006_29_24","DEU","29","24","24","ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠦ ꠎꠤꠇꠣꠁꠛꠣ, ꠝꠣꠛꠥꠖꠦ ꠁ ꠖꠦꠡꠞ ꠢꠣꠟꠔ ꠇꠦꠘꠦ ꠁꠟꠣ ꠇꠞꠟꠣ? ꠔꠣꠁꠘ ꠇꠦꠘꠦ ꠅꠔ ꠛꠠ ꠉꠥꠍꠣ ꠇꠞꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("DT29_25","006_29_25","DEU","29","25","25","“ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠎꠥꠀꠙ ꠖꠤꠛꠣ, ꠅꠃ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠢꠃ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍꠦ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠣꠞ ꠛꠣꠖꠦ ꠎꠦ ꠌꠥꠇ꠆ꠔꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("DT29_26","006_29_26","DEU","29","26","26","ꠔꠣꠞꠣ ꠢꠃ ꠝꠣꠛꠥꠖꠞꠦ ꠛꠣꠖ ꠖꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠘꠄꠀ, ꠅꠔꠣ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣꠔ ꠟꠣꠉꠍꠦ, ꠎꠦꠔꠣ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠇꠕꠣ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠍꠂꠘ ꠘꠣ, ꠅꠔꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT29_27","006_29_27","DEU","29","27","27","ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘ ꠎꠟꠤꠀ ꠃꠑꠍꠦ, ꠔꠣꠁꠘ ꠅꠃ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠟꠣꠘ꠆ꠘꠔꠤ ꠉꠎꠛ ꠁ ꠖꠦꠡꠅ ꠘꠣꠎꠤꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT29_28","006_29_28","DEU","29","28","28","ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘꠦ ꠎꠟꠤꠀ, ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠉꠎꠛ ꠓꠣꠟꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠖꠦꠡ ꠕꠣꠇꠤ ꠎꠠꠦ-ꠚꠠꠦ ꠔꠥꠟꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠜꠤꠘ ꠖꠦꠡꠅ ꠘꠤꠀ ꠀꠍꠣꠠ ꠝꠣꠞꠤ ꠚꠣꠟꠣꠁꠍꠂꠘ, ꠀꠞ ꠅꠈꠘꠅ ꠔꠣꠞꠣ ꠢꠘꠅ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT29_29","006_29_29","DEU","29","29","29","“ꠛꠣꠔꠥꠘꠤ ꠢꠇꠟꠔꠣꠃ ꠔ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠀꠔꠅ, ꠅꠁꠟꠦ ꠎꠣꠁꠞ ꠇꠞꠣ ꠢꠇꠟꠔꠣ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠀꠔꠅ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠅꠃ ꠡꠞꠤꠅꠔꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("DT30_1","006_30_1","DEU","30","1","1","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠇꠁꠞꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠦ ꠞꠢꠝꠔ ꠀꠞ ꠟꠣꠘ꠆ꠘꠔꠞ ꠙꠕ ꠖꠦꠈꠣꠁꠍꠤ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠚꠟꠤꠛ। ꠚꠟꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠍꠤꠔ꠆ꠞꠣꠁ ꠖꠤꠛꠣ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠈꠤꠀꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT30_2","006_30_2","DEU","30","2","2","ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠀꠅ, ꠀꠞ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠁꠔꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠝꠟ ꠇꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("DT30_3","006_30_3","DEU","30","3","3","ꠔꠦ ꠢꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠢꠣꠟꠔ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠇꠞꠛꠣ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ ꠇꠞꠛꠣ, ꠀꠞ ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠤꠔ꠆ꠞꠣꠁꠀ ꠖꠤꠍꠟꠣ, ꠅꠔꠣ ꠕꠣꠇꠤ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠀꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT30_4","006_30_4","DEU","30","4","4","ꠖꠥꠘꠤꠀꠞ ꠀꠈꠦꠞꠤ ꠇꠤꠘꠣꠞꠣꠔꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠚꠣꠟꠣꠁꠟ ꠅꠄ, ꠔꠦ ꠢꠘꠅ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠀꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT30_5","006_30_5","DEU","30","5","5","ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠛꠣ, ꠁꠔꠣ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣ ꠖꠈꠟ ꠇꠞꠛꠣꠄ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠃꠔ ꠛꠣꠠꠣꠁ ꠖꠤꠛꠣ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠌꠣꠁꠔꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠙꠞꠤꠝꠣꠘ ꠀꠞꠅ ꠛꠣꠠꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT30_6","006_30_6","DEU","30","6","6","ꠔꠥꠝꠞꠣ ꠎꠣꠔꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠛꠣꠌꠤꠀ ꠞꠅ, ꠅꠃ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠖꠤꠟꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT30_7","006_30_7","DEU","30","7","7","ꠀꠞ ꠅꠃ ꠟꠣꠘ꠆ꠘꠔ ꠅꠇꠟ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠖꠥꠡꠝꠘꠞ ꠃꠙꠞꠦ ꠚꠣꠟꠣꠁꠛꠣ, ꠎꠦꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠋꠡꠣ ꠀꠞ ꠎꠥꠟꠥꠝ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("DT30_8","006_30_8","DEU","30","8","8","ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠛꠣꠄ, ꠔꠣꠘ ꠛꠣꠔꠣꠁꠟ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠅꠔꠣ ꠢꠇꠟꠔꠣ ꠀꠝꠟ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT30_9","006_30_9","DEU","30","9","9","“ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠄ-ꠃꠘ꠆ꠘꠔꠤ ꠖꠤꠛꠣ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎꠅ ꠛꠞꠇꠔ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠙꠞꠤꠝꠣꠘ ꠛꠣꠠꠣꠁꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ ꠀꠞ ꠎꠝꠤꠘꠞ ꠚꠡꠟ ꠛꠣꠠꠣꠁ ꠖꠤꠛꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠃꠙꠞꠦ ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠈꠥꠡꠤ ꠀꠍꠟꠣ, ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦꠅ ꠅꠟꠣ ꠈꠥꠡꠤ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠄ ꠛꠣꠠꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT30_10","006_30_10","DEU","30","10","10","ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠤꠀ, ꠅꠃ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠔꠣꠘ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠟꠦ, ꠀꠡ꠆ꠔꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠔꠣꠘ ꠛꠣꠄ ꠚꠤꠞꠟꠦ, ꠔꠣꠁꠘ ꠅꠃ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT30_11","006_30_11","DEU","30","11","11","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠢꠥꠘꠅ, ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠁꠔꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠦꠡꠤ ꠇꠡ꠆ꠐꠞ ꠇꠥꠘꠥ ꠇꠣꠝ ꠘꠣꠄ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠣꠟꠞ ꠛꠣꠞꠦꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT30_12","006_30_12","DEU","30","12","12","ꠁꠔꠣ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠥꠟꠤꠀ ꠕꠅꠀ ꠇꠥꠘꠥ ꠌꠤꠎ ꠘꠣꠄ ꠎꠦꠘ ꠔꠥꠝꠞꠣ ꠇꠁꠔꠣꠄ, ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠕꠣꠇꠤ ꠇꠦꠉꠤꠄ ꠟꠣꠝꠣꠁ ꠀꠘꠤꠀ ꠁꠔꠣ ꠀꠝꠞꠣꠞꠦ ꠢꠥꠘꠣꠁꠔ, ꠀꠞ ꠀꠝꠞꠣ ꠀꠝꠟ ꠇꠞꠔꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("DT30_13","006_30_13","DEU","30","13","13","ꠁꠔꠣ ꠖꠞꠤꠀꠞ ꠢꠙꠣꠞꠞ ꠇꠥꠘꠥ ꠌꠤꠎꠅ ꠘꠣꠄ ꠎꠦꠘ ꠔꠥꠝꠞꠣ ꠇꠁꠔꠣꠄ, ꠖꠞꠤꠀ ꠙꠣꠞ ꠅꠁꠀ ꠇꠦꠉꠤꠄ ꠉꠤꠀ ꠁꠔꠣ ꠀꠘꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠢꠥꠘꠣꠁꠔ, ꠀꠞ ꠀꠝꠞꠣ ꠀꠝꠟ ꠇꠞꠔꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("DT30_14","006_30_14","DEU","30","14","14","ꠛꠞꠋ ꠝꠣꠛꠥꠖꠞ ꠇꠣꠟꠣꠝ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦꠃ ꠀꠍꠦ, ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈꠞ ꠝꠣꠎꠦ ꠀꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠦ ꠁꠔꠣ ꠀꠍꠦ, ꠎꠣꠔꠦ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("DT30_15","006_30_15","DEU","30","15","15","“ꠢꠥꠘꠅ, ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠦꠔꠣ ꠔꠥꠟꠤꠀ ꠗꠞꠍꠤ, ꠁꠔꠣ ꠅꠁꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠞ ꠜꠣꠟꠣꠁ, ꠛꠣ ꠝꠃꠔ ꠀꠞ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ। ");
INSERT INTO syls_vpl VALUES ("DT30_16","006_30_16","DEU","30","16","16","ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ, ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠤꠅ, ꠔꠣꠘ ꠖꠦꠅꠀ ꠡꠞꠤꠅꠔ, ꠢꠇꠟ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ, ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠣꠘꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠦ ꠛꠣꠌꠛꠣꠄ, ꠙꠞꠤꠝꠣꠘꠦ ꠛꠣꠠꠛꠣꠄ, ꠀꠞ ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠖꠈꠟ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄ, ꠢꠃ ꠖꠦꠡꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT30_17","006_30_17","DEU","30","17","17","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠘ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠄ ꠕꠣꠇꠤ ꠚꠤꠞꠤꠎꠣꠄ, ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠘꠣ ꠝꠣꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣꠔ ꠟꠣꠉꠤꠀ ꠅꠔꠣꠞꠦ ꠙꠞꠘꠣꠝ ꠇꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("DT30_18","006_30_18","DEU","30","18","18","ꠔꠦ ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠘꠤꠡ꠆ꠌꠤꠔ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛꠣꠄ। ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠎꠦ ꠖꠦꠡ ꠔꠥꠝꠞꠣ ꠖꠈꠟ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄ, ꠢꠤꠘꠅ ꠔꠥꠝꠞꠣ ꠛꠦꠡꠤ ꠖꠤꠘ ꠛꠣꠌꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT30_19","006_30_19","DEU","30","19","19","“ꠅꠃ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠤꠀ ꠇꠁꠀꠞ, ꠀꠁꠎ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠞ ꠝꠃꠔ, ꠞꠢꠝꠔ ꠀꠞ ꠟꠣꠘ꠆ꠘꠔꠞꠦ ꠔꠥꠟꠤꠀ ꠗꠞꠍꠤ। ꠄꠞꠟꠣꠉꠤ ꠅ ꠜꠣꠁꠀꠁꠘ, ꠔꠥꠝꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠟꠣꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠎꠣꠘ ꠛꠣꠌꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("DT30_20","006_30_20","DEU","30","20","20","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ, ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠅ, ꠔꠣꠘ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠔꠣꠘꠞꠦ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠞꠣꠈꠤꠅ, ꠅꠔꠣꠞ ꠝꠣꠎꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ꠔꠣꠁꠘ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ, ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠟꠉꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠅꠀꠖꠣ ꠖꠤꠍꠂꠘ, ꠢꠃ ꠖꠦꠡꠅ ꠅꠔꠣ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠣꠞ ꠝꠣꠎꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("DT31_1","006_31_1","DEU","31","1","1","ꠄꠞꠛꠣꠖꠦ ꠝꠥꠍꠣꠄ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT31_2","006_31_2","DEU","31","2","2","“ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠛꠄꠅꠡ ꠔ ꠄꠇ-ꠡ ꠛꠤꠡ ꠛꠍꠞ ꠅꠁꠉꠦꠍꠦ, ꠀꠝꠤ ꠀꠞ ꠀꠝꠣꠞ ꠇꠣꠝ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤꠀꠞ ꠘꠣ, ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠣꠁꠍꠂꠘ, ꠀꠝꠤ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠤꠙꠣꠞꠅ ꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT31_3","006_31_3","DEU","31","3","3","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠞꠁꠀ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠛꠣ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠤ ꠢꠘꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠢꠃ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠛꠣꠄ। ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠇꠕꠣ ꠝꠣꠚꠤꠇ ꠢꠎꠞꠔ ꠁꠃꠍꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠢꠙꠣꠞꠅ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT31_4","006_31_4","DEU","31","4","4","ꠝꠣꠛꠥꠖꠦ ꠀꠝꠥꠞꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠍꠤꠢꠥꠘ ꠀꠞ ꠃꠎꠞꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠤꠟꠣ, ꠢꠃ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦꠅ ꠅꠟꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT31_5","006_31_5","DEU","31","5","5","ꠔꠣꠁꠘ ꠢꠤꠔꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠤꠛꠣ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT31_6","006_31_6","DEU","31","6","6","ꠔꠥꠝꠞꠣꠞ ꠛꠥꠇꠥꠔ ꠛꠟ ꠞꠣꠈꠅ ꠀꠞ ꠡꠣꠅꠡ ꠇꠞꠅ। ꠒꠞꠣꠁꠅ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠊꠣꠛꠠꠣꠁꠅ ꠘꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠎꠣꠁꠞꠣ, ꠔꠣꠁꠘ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠠꠔꠣ ꠘꠣꠄ, ꠇꠥꠘꠥ ꠢꠣꠟꠔꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠚꠣꠟꠣꠁꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT31_7","006_31_7","DEU","31","7","7","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠁꠃꠍꠣ ꠘꠛꠤꠞꠦ ꠀꠘꠣꠁꠟꠣ, ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠛꠥꠇꠥꠔ ꠛꠟ ꠞꠣꠈꠅ ꠀꠞ ꠡꠣꠅꠡ ꠇꠞꠅ। ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠔꠥꠝꠤ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠁꠛꠣꠄ, ꠢꠃ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠔ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ। ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠢꠘꠅ ꠘꠤꠀ ꠢꠘꠞ ꠎꠝꠤ-ꠎꠝꠣ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("DT31_8","006_31_8","DEU","31","8","8","ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠞꠁꠛꠣ, ꠔꠥꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ, ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞꠦꠅ ꠍꠣꠠꠔꠣ ꠘꠣꠄ ꠀꠞ ꠔꠥꠝꠣꠞꠦ ꠚꠣꠟꠣꠁꠔꠣꠅ ꠘꠣꠄ, ꠔꠦ ꠔꠥꠝꠤ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠡꠣꠅꠡ ꠀꠞꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("DT31_9","006_31_9","DEU","31","9","9","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔꠃꠞꠣꠔꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠅꠇꠟ ꠟꠦꠈꠟꠣ, ꠟꠦꠈꠤꠀ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠢꠃ ꠁꠝꠣꠝ ꠅꠇꠟ, ꠎꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ ꠛꠁꠀ ꠘꠤꠔꠣ, ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠀꠔꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT31_10","006_31_10","DEU","31","10","10","ꠖꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠙꠞꠔꠦꠇ ꠡꠣꠔ ꠛꠍꠞ ꠛꠣꠖꠦ ꠛꠣꠖꠦ, ꠀꠅꠟꠣꠔ ꠝꠣꠚꠤꠞ ꠛꠍꠞꠞ ꠇꠣꠟꠅ, ꠒꠦꠞꠣ-ꠊꠞꠞ ꠁꠖꠞ ꠅꠇ꠆ꠔꠅ, ");
INSERT INTO syls_vpl VALUES ("DT31_11","006_31_11","DEU","31","11","11","ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠛꠣ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠤ ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠤꠀ ꠢꠥꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("DT31_12","006_31_12","DEU","31","12","12","ꠛꠦꠐꠣꠁꠘ, ꠛꠦꠐꠤꠘ, ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠞꠣ ꠉꠣꠃ ꠛꠣ ꠐꠣꠃꠘꠞ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠄꠇ ꠎꠣꠉꠣꠔ ꠖꠟꠣ ꠇꠞꠤꠀ ꠁꠔꠣ ꠢꠥꠘꠣꠁꠅ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠛꠣ, ꠀꠞ ꠅꠃ ꠡꠞꠤꠅꠔꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠔꠘ ꠇꠞꠤ ꠀꠝꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT31_13","006_31_13","DEU","31","13","13","ꠀꠞ ꠔꠣꠞꠣꠞ ꠎꠦꠔꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠄ ꠔꠃꠞꠣꠔꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠢꠥꠘꠍꠂꠘ ꠘꠣ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠞꠣꠄ, ꠔꠥꠝꠞꠣ ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣꠅ ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠜꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚꠦ ꠌꠟꠣ ꠢꠤꠇꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("DT31_14","006_31_14","DEU","31","14","14","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠔ ꠀꠞ ꠛꠦꠡꠤ ꠘꠣꠁ, ꠝꠃꠔ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ, ꠔꠦ ꠔꠥꠝꠤ ꠁꠃꠍꠣꠞꠦ ꠀꠘꠣꠅ, ꠀꠘꠣꠁꠀ ꠖꠥꠁꠅ ꠎꠘ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦ ꠀꠅ, ꠀꠝꠤ ꠔꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠞ ꠘꠄꠀ ꠇꠣꠝ ꠡꠝꠎꠣꠁ ꠖꠤꠝꠥ।” ꠔꠦꠃ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠎꠘ ꠉꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT31_15","006_31_15","DEU","31","15","15","ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠞ ꠝꠣꠎꠦ ꠕꠣꠇꠤꠀ ꠝꠤꠟꠘ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠟꠣ, ꠅꠃ ꠈꠥꠐꠤ ꠔꠣꠝ꠆ꠛꠥꠞ ꠖꠥꠀꠞꠞ ꠃꠙꠞꠦ ꠃꠛꠣꠁ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("DT31_16","006_31_16","DEU","31","16","16","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠔ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠀꠞꠣꠝ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠄꠉꠤ, ꠅꠁꠟꠦ ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠎꠦ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠁꠞꠣ, ꠢꠣꠝꠣꠘꠤꠞ ꠕꠥꠠꠣ ꠛꠣꠖꠦꠃ ꠀꠝꠣꠞ ꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞꠦ ꠔꠣꠞꠣ ꠜꠋꠉ ꠇꠞꠛꠣ, ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠛꠣꠖ ꠖꠤꠀ ꠢꠘꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠀꠔꠅ ꠘꠤꠎꠞꠦ ꠡꠙꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT31_17","006_31_17","DEU","31","17","17","ꠔꠣꠞꠣ ꠁꠔꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠀꠝꠣꠞ ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘ ꠎꠟꠤꠛ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠉ ꠍꠣꠠꠤ ꠖꠤꠝꠥ, ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠟꠤꠝꠥ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠛꠤꠘꠣꠡꠞ ꠙꠕꠅ ꠎꠣꠁꠛꠣ। ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠘꠣꠘꠣꠘ ꠛꠣꠟꠣ-ꠝꠍꠤꠛꠔ ꠀꠁꠛ। ꠢꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠇꠁꠛꠣ, ꠀꠝꠞꠣꠞ ꠖꠡꠣ ꠁꠟꠣ ꠅꠁꠟ ꠇꠦꠘꠦ? ꠘꠤꠡ꠆ꠌꠄ, ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠘꠣꠄ ꠇꠞꠤꠃ, ꠁꠔꠣ ꠊꠐꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("DT31_18","006_31_18","DEU","31","18","18","ꠀꠍꠟꠦ ꠔꠣꠞꠣꠞ ꠢꠃ ꠖꠦꠛ-ꠖꠦꠛꠤꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠎꠦꠔꠣ ꠇꠥ-ꠇꠣꠝ ꠇꠞꠍꠂꠘ, ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠢꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠟꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("DT31_19","006_31_19","DEU","31","19","19","“ꠔꠦ ꠔꠥꠝꠞꠣ ꠅꠃ ꠉꠎꠟꠐꠣ ꠟꠦꠈꠤꠟꠣꠅ, ꠟꠦꠈꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠢꠤꠇꠣꠅ ꠀꠞ ꠔꠣꠞꠣ ꠉꠣꠁꠛꠣ। ꠅꠃ ꠉꠎꠟ ꠔ ꠔꠣꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠝꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠅꠁꠀ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT31_20","006_31_20","DEU","31","20","20","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠤ, ꠖꠥꠗ ꠀꠞ ꠝꠃꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠀꠟꠣ ꠀꠞꠣꠝꠞ ꠢꠃ ꠖꠦꠡꠅ ꠔꠣꠞꠣꠞꠦ ꠘꠤꠀ ꠢꠣꠞꠟꠦꠃ, ꠔꠣꠞꠣ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁꠀ ꠝꠥꠐꠣ-ꠔꠣꠎꠣ ꠅꠁꠛꠣ। ꠅꠁꠀ ꠢꠘꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠛꠣ, ꠢꠔꠣꠞ ꠜꠎꠘꠣ ꠇꠞꠛꠣ, ꠀꠝꠣꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠟꠉꠞ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠜꠣꠋꠉꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("DT31_21","006_31_21","DEU","31","21","21","ꠔꠦꠃ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠛꠟꠣ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠛꠣꠟꠣ-ꠝꠍꠤꠛꠔ ꠀꠞ ꠛꠤꠙꠖ-ꠀꠙꠖ ꠀꠁꠛ, ꠢꠃ ꠡꠝꠄ ꠅꠃ ꠉꠎꠟꠦ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛ, ꠅꠃ ꠉꠎꠟ ꠔ ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠚꠣꠃꠞꠤꠔꠣ ꠘꠣꠄ। ꠢꠣꠍꠣ ꠇꠕꠣ ꠅꠁꠟ, ꠀꠝꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠖꠦꠡꠅ ꠘꠤꠛꠣꠞ ꠀꠉꠦꠃ, ꠔꠣꠞꠣ ꠝꠘꠦ ꠝꠘꠦ ꠇꠤꠔꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠦꠞ, ꠁꠔꠣ ꠔ ꠀꠝꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("DT31_22","006_31_22","DEU","31","22","22","ꠝꠥꠍꠣꠄ ꠟꠉꠦ ꠟꠉꠦ ꠅꠃ ꠉꠎꠟ ꠟꠦꠈꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠢꠤꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT31_23","006_31_23","DEU","31","23","23","ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣꠞꠦ ꠔꠣꠘ ꠘꠄꠀ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠅꠃꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤ ꠛꠥꠇꠥꠔ ꠛꠟ ꠞꠣꠈꠅ ꠀꠞ ꠡꠣꠅꠡ ꠇꠞꠅ। ꠀꠝꠤ ꠇꠍꠝ ꠈꠣꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠅꠀꠖꠣ ꠇꠞꠍꠤ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠁꠛꠣꠄ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("DT31_24","006_31_24","DEU","31","24","24","ꠡꠞꠤꠅꠔꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠞ ꠢꠇꠟꠔꠣ ꠝꠥꠍꠣꠄ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠟꠦꠈꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT31_25","006_31_25","DEU","31","25","25","ꠟꠦꠈꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ ꠛꠁꠀ ꠘꠦꠅꠞꠣ ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT31_26","006_31_26","DEU","31","26","26","“ꠅꠃ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇꠞ ꠇꠣꠍꠣꠔ ꠕꠁꠅ। ꠁꠈꠣꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠡꠣꠇ꠆ꠇꠤ ꠢꠤꠡꠣꠛꠦ ꠢꠘꠅ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("DT31_27","006_31_27","DEU","31","27","27","ꠔꠥꠝꠞꠣ ꠇꠔ ꠛꠠ ꠉꠣꠠꠔꠦꠠꠣ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ। ꠀꠝꠤ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠍ, ꠔꠦ ꠀꠝꠣꠞ ꠝꠞꠘꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠇꠤꠔꠣ ꠘꠣ ꠇꠞꠛꠣꠄ! ");
INSERT INTO syls_vpl VALUES ("DT31_28","006_31_28","DEU","31","28","28","ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠅꠚꠤꠡꠣꠞ ꠅꠇꠟꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠅ, ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠅꠔꠣ ꠈꠥꠟꠣꠍꠣ ꠇꠞꠤꠀ ꠇꠁꠀ ꠎꠣꠁꠝꠥ, ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞꠦ ꠔꠣꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠔꠣꠝ ꠌꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT31_29","006_31_29","DEU","31","29","29","ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ, ꠀꠝꠤ ꠌꠃꠈ ꠝꠥꠎꠣꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠘꠤꠎꠤꠛꠣꠄ, ꠀꠝꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠙꠕ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠢꠞꠤꠎꠤꠛꠣꠄ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠟꠣꠝꠛ। ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠔꠣ ꠊꠤꠘ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣ ꠅꠔꠣ ꠇꠣꠝ ꠇꠞꠤꠀ, ꠘꠤꠎꠞ ꠀꠔꠦ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠀ, ꠔꠣꠘ ꠉꠥꠍꠣ ꠔꠥꠟꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT31_30","006_31_30","DEU","31","30","30","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠉꠎꠟꠞ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠀꠈꠦꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠥꠘꠣꠁꠟꠣ; ꠔꠣꠁꠘ ꠉꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT32_1","006_32_1","DEU","32","1","1","ꠅ ꠀꠍꠝꠣꠘ, ꠇꠣꠘ ꠙꠣꠔꠤꠀ ꠢꠥꠘꠅ ꠀꠝꠤ ꠎꠦꠔꠣ ꠉꠣꠁ, ꠅ ꠎꠝꠤꠘ, ꠔꠥꠝꠤꠅ ꠢꠥꠘꠅ ꠀꠝꠤ ꠎꠣ ꠛꠣꠔꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT32_2","006_32_2","DEU","32","2","2","ꠀꠝꠣꠞ ꠔꠣꠟꠤꠝ ꠟꠣꠝꠃꠇ ꠝꠦꠊꠞ ꠚꠥꠐꠣꠞ ꠟꠣꠈꠣꠘ, ꠈꠥꠀꠞ ꠝꠔꠘ ꠙꠠꠃꠇ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠛꠄꠀꠘ। ꠈꠦꠍꠝꠣ ꠊꠣꠡꠞ ꠃꠙꠞꠦ ꠚꠥꠐꠣ ꠚꠥꠐꠣ ꠝꠦꠊ ꠅꠁꠀ ꠙꠠꠃꠇ, ꠘꠄꠀ ꠌꠦꠞꠣ ꠉꠣꠍꠞ ꠃꠙꠞꠦ ꠡꠣꠘ꠆ꠔꠤꠞ ꠝꠦꠊ ꠅꠁꠀ ꠟꠣꠝꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("DT32_3","006_32_3","DEU","32","3","3","ꠀꠝꠤ ꠔ ꠄꠟꠣꠘ ꠇꠞꠝꠥ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ, ꠔꠥꠝꠞꠣꠅ ꠉꠣꠁꠅ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ ꠉꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("DT32_4","006_32_4","DEU","32","4","4","ꠔꠣꠁꠘꠃ ꠔ ꠀꠡꠞꠄ ꠐꠤꠟ꠆ꠟꠣ, ꠘꠤꠈꠥꠔ ꠔꠣꠘ ꠇꠣꠝ, ꠢꠇ-ꠢꠣꠍꠣ ꠔꠣꠘ ꠙꠕ ꠡꠑꠤꠇ ꠔꠣꠝꠣꠝ। ꠍꠟ-ꠌꠔꠥꠞꠤ ꠘꠣꠁ ꠔꠣꠘ, ꠢꠇ-ꠢꠣꠟꠣꠟ ꠀꠍꠦ ꠡꠞ꠆ꠛꠖꠣ, ꠢꠇ ꠁꠘꠍꠣꠚ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠀꠍꠦ ꠡꠔꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_5","006_32_5","DEU","32","5","5","ꠔꠣ-ꠅ ꠔꠣꠘ ꠈꠛꠤꠍ ꠛꠘ꠆ꠖꠣꠄ ꠇꠞꠍꠦ ꠛꠦꠁꠝꠣꠘꠤ, ꠖꠤꠟꠞ ꠈꠣꠞꠣꠙꠤꠄ ꠔꠣꠞꠣ ꠛꠘꠍꠦ ꠇꠟꠋꠇꠤꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("DT32_6","006_32_6","DEU","32","6","6","ꠢꠣꠄꠞꠦ ꠀꠝ꠆ꠝꠇ ꠘꠣꠖꠣꠘ, ꠢꠣꠄꠞꠦ ꠛꠦꠀꠈꠟ, ꠅꠃꠘꠤ ꠔꠥꠝꠞꠣ ꠛꠖꠟꠣ ꠖꠤꠟꠣꠄ, ꠝꠣꠛꠥꠖꠞ ꠖꠣꠘꠞ? ꠔꠣꠁꠘꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠞꠣ ꠙꠞꠅꠀꠞ ꠖꠤꠉꠣꠞ ꠘꠤ? ꠛꠅꠀꠁꠟ ꠇꠞꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("DT32_7","006_32_7","DEU","32","7","7","ꠁꠀꠖ ꠇꠞꠅ ꠔꠥꠝꠞꠣ ꠢꠃ ꠀꠉꠞ ꠀꠝꠟꠞ ꠝꠣꠔ, ꠝꠘꠅ ꠞꠣꠈꠅ ꠇꠤꠔꠣ ꠅꠁꠍꠤꠟ ꠙꠥꠞꠣꠘ ꠎꠝꠣꠘꠣꠔ। ꠛꠣꠚ-ꠖꠣꠖꠣꠞꠦ ꠎꠤꠇꠣꠞ ꠇꠞꠤ ꠁꠔꠤꠢꠣꠡ ꠢꠥꠘꠅ, ꠛꠥꠠꠣ-ꠛꠥꠠꠤꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("DT32_8","006_32_8","DEU","32","8","8","ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠄ ꠖꠤꠟꠣ ꠎꠦꠛꠟꠣ ꠎꠝꠤꠘ ꠛꠣꠐꠤꠀ, ꠘꠣꠘꠣꠘ ꠎꠣꠔꠤꠞꠦ ꠖꠤꠟꠣ ꠜꠣꠉ-ꠛꠣꠐꠥꠞꠣ ꠇꠞꠤꠀ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠤꠝꠣꠘ ꠔ ꠎꠣꠘꠣ ꠀꠍꠤꠟ ꠔꠣꠘ, ꠄꠞꠣꠞ ꠅꠋꠡ ꠀꠟꠉꠣꠁ ꠕꠁꠀ ꠛꠣꠇꠤ ꠇꠞꠟꠣ ꠖꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("DT32_9","006_32_9","DEU","32","9","9","ꠝꠣꠛꠥꠖꠞ ꠈꠣꠍ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤ ꠔ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙ꠆ꠞꠎꠣ, ꠁꠀꠇꠥꠛ ꠛꠋꠡ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠀꠙꠘ ꠍꠣꠝꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_10","006_32_10","DEU","32","10","10","ꠔꠣꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠔꠥꠇꠣꠁ ꠙꠣꠁꠟꠣ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠖꠦꠡꠅ, ꠘꠤꠞꠣꠁ-ꠘꠤꠞ꠆ꠎꠘ ꠖꠦꠡ ꠀꠞ ꠛꠣꠊ-ꠡꠤꠋꠢꠞ ꠉꠞ꠆ꠎꠘꠅ। ꠇꠥꠖꠞꠔꠤ ꠒꠣꠈꠘꠣꠖꠤ ꠊꠥꠞꠤꠀ ꠎꠔꠘ ꠇꠞꠤꠟꠣ, ꠌꠈꠥꠞ ꠝꠘꠤꠞ ꠟꠣꠈꠣꠘꠃ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_11","006_32_11","DEU","32","11","11","ꠌꠤꠟꠦ ꠎꠦꠟꠣ ꠘꠤꠎꠞ ꠛꠣꠖꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠘꠣꠌꠣꠄ, ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠃꠠꠤ ꠃꠠꠤ ꠒꠣꠈꠘꠣꠞꠦ ꠟꠣꠠꠣꠄ, ꠒꠣꠈꠘꠣ ꠝꠦꠟꠤꠀ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘꠞꠦ ꠃꠙꠞꠦ ꠔꠥꠟꠦ, ꠔꠥꠟꠤꠀ ꠢꠣꠞꠤ ꠃꠠꠣꠟ ꠖꠤꠀ ꠟꠁꠀ ꠟꠁꠀ ꠊꠥꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("DT32_12","006_32_12","DEU","32","12","12","ꠝꠣꠛꠥꠖꠦ ꠄꠇꠟꠣ ꠅꠃꠟꠣ ꠇꠞꠤ ꠔꠣꠞꠣꠞꠦ ꠘꠤꠟꠣ, ꠇꠥꠘꠥꠎꠣꠔꠞ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠔꠣꠘ ꠟꠉꠦ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_13","006_32_13","DEU","32","13","13","ꠙꠣꠠꠦ ꠙꠣꠠꠦ ꠃꠠꠣꠁ ꠃꠠꠣꠁ ꠘꠤꠟꠣ ꠔꠣꠞꠣꠞꠦ, ꠙꠣꠠꠤꠀ ꠖꠦꠡꠞ ꠖꠈꠟ ꠖꠤꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ। ꠈꠦꠔꠞ ꠜꠣꠟꠣ ꠚꠡꠟ ꠖꠤꠟꠣ ꠈꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ, ꠙꠣꠠꠤꠀ ꠌꠣꠇꠞ ꠝꠃ ꠈꠣꠛꠣꠁꠟꠣ ꠚꠣꠐꠣ-ꠌꠤꠙꠣ ꠕꠣꠇꠤ। ꠈꠣꠛꠣꠁꠟꠣ ꠝꠣꠟꠤꠇꠦ ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ, ꠟꠥꠀꠞ ꠟꠣꠈꠣꠘ ꠡꠇ꠆ꠔ ꠝꠣꠐꠤꠔ ꠔꠦꠟ ꠚꠟꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("DT32_14","006_32_14","DEU","32","14","14","ꠈꠣꠛꠣꠁꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠉꠞꠥꠞ ꠖꠥꠗꠞ ꠖꠁ, ꠍꠣꠉꠟ-ꠝꠦꠠꠣꠞ ꠖꠥꠗꠅ ꠈꠣꠁꠟꠣ ꠎꠣꠘꠤꠅ ꠘꠤꠌ꠆ꠌꠄ। ꠝꠥꠐꠣ-ꠔꠣꠎꠣ ꠝꠦꠠꠣꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠟꠣ ꠝꠎꠣ ꠇꠞꠤ, ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠉꠞꠥ-ꠈꠡꠤ ꠈꠣꠁꠟꠣ ꠞꠥꠐꠤꠖꠤ। ꠔꠣꠎꠣ-ꠙꠥꠡ꠆ꠐ ꠉꠝꠞ ꠞꠥꠐꠤ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ, ꠒꠦꠝꠖꠤ ꠃꠑꠣ ꠀꠋꠉꠥꠞ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠘꠤꠀꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("DT32_15","006_32_15","DEU","32","15","15","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠟꠣꠕ ꠝꠣꠞꠤꠟꠣ ꠙꠦꠐꠟꠣ ꠛꠘꠤꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠟꠣꠕ ꠝꠣꠞꠟꠣ ꠔꠣꠞꠣꠞ ꠙꠣꠅ ꠖꠤꠀ। ꠈꠣꠁꠀ ꠈꠣꠁꠀ ꠙꠦꠐ ꠚꠥꠟꠣꠁꠀ ꠝꠣꠞꠟ ꠅꠈꠘ ꠟꠣꠕ, ꠚꠣꠃꠞꠤꠟꠤꠟ ꠢꠃ ꠀꠟ꠆ꠟꠣꠞꠦ ꠎꠦꠁꠘ ꠖꠤꠟꠣ ꠜꠣꠔ। ꠙꠄꠖꠣ ꠇꠞꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉ ꠔꠣꠞꠣ ꠍꠣꠠꠤ ꠖꠤꠟ, ꠀꠡꠞꠄ ꠐꠤꠟ꠆ꠟꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠔꠣꠞꠣ ꠢꠥꠞꠥ ꠝꠘꠅ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("DT32_16","006_32_16","DEU","32","16","16","ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠀꠉꠥꠁꠘ, ꠄꠇ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠤꠀ ꠔꠣꠞꠣ ꠜꠎꠤꠟ ꠢꠉꠥꠁꠘ। ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘ ꠎꠣꠟꠣꠁꠟ ꠔꠣꠘ ꠀꠞꠡꠞ ꠝꠣꠎꠦ, ꠝꠥꠞ꠆ꠔꠤ ꠙꠥꠎꠣ ꠊꠤꠘ ꠇꠞꠂꠘ ꠝꠢꠣꠘ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_17","006_32_17","DEU","32","17","17","ꠜꠥꠔꠞ ꠘꠣꠝꠦ ꠛꠟꠤ ꠖꠤꠟ ꠔꠣꠘꠞꠦ ꠍꠣꠠꠤꠀ, ꠜꠥꠔ ꠔ ꠇꠥꠘꠥ ꠀꠟ꠆ꠟꠣ ꠘꠣꠄ ꠔꠣ-ꠅ ꠙꠣꠁꠟ ꠙꠥꠎꠣ। ꠘꠄꠀ ꠘꠄꠀ ꠖꠦꠛꠔꠣ ꠎꠦꠔꠣ ꠇꠄꠖꠤꠘ ꠕꠣꠇꠤ ꠌꠤꠘꠦ, ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠅꠌꠤꠘ ꠖꠦꠛꠔꠣ ꠅꠈꠘ ꠔꠣꠞꠣ ꠜꠎꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_18","006_32_18","DEU","32","18","18","ꠎꠘꠝ ꠖꠣꠔꠣ ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠎꠦꠁꠘ ꠀꠡꠞꠄ ꠐꠤꠟ꠆ꠟꠣ, ꠔꠣꠘꠞꠦ ꠔꠥꠝꠞꠣ ꠚꠣꠃꠞꠤꠀ ꠢꠣꠞꠤ ꠇꠞꠟꠣꠄ ꠅꠛꠢꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_19","006_32_19","DEU","32","19","19","ꠀꠅꠟꠣꠖꠞ ꠅꠃ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ, ꠞꠣꠉꠦ-ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠟꠣ ꠔꠣꠞꠣꠞꠃ ꠛꠖ ꠀꠝꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_20","006_32_20","DEU","32","20","20","ꠉꠥꠍꠣ ꠇꠞꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠟꠣꠝ ꠀꠝꠤ, ꠔꠣꠞꠣꠞ ꠢꠦꠡ ꠖꠡꠣ ꠇꠤꠔꠣ ꠀꠝꠤ ꠘꠤꠌ꠆ꠌꠤꠔ ꠎꠣꠘꠤ। ꠖꠦꠈꠝꠥ ꠌꠣꠁꠀ ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠛꠦꠁꠝꠣꠘꠤꠞ ꠡꠣꠎꠣ, ꠛꠦ-ꠙꠕꠤ ꠛꠦꠁꠝꠣꠘ ꠎꠣꠔꠦ ꠛꠥꠎꠛꠣ ꠘꠤꠎꠞ ꠖꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_21","006_32_21","DEU","32","21","21","ꠎꠦꠐꠣ ꠀꠟ꠆ꠟꠣ ꠘꠣꠁ ꠁꠟꠣ ꠖꠦꠛꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠤꠀ, ꠀꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠖꠤꠍꠦ ꠔꠣꠞꠣ ꠉꠥꠍꠣ ꠔꠥꠟꠤꠀ। ꠎꠦꠐꠣ ꠎꠣꠔꠤ ꠘꠣꠁ ꠁꠟꠣ ꠎꠣꠔꠤ ꠖꠤꠀ ꠁꠋꠡꠣ ꠇꠞꠣꠁꠝꠥ, ꠀꠝ꠆ꠝꠇ ꠎꠣꠔꠤ ꠖꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠥꠍꠣ ꠔꠥꠟꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("DT32_22","006_32_22","DEU","32","22","22","ꠀꠝꠣꠞ ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘ ꠅꠈꠘ ꠖꠣꠃ ꠖꠣꠃ ꠇꠞꠤ ꠎꠟꠦꠞ, ꠝꠣꠐꠤꠞ ꠔꠟꠞ ꠙꠣꠔꠣꠟꠞꠦꠅ ꠎꠣꠟꠣꠁꠀ ꠍꠣꠞꠈꠣꠞ ꠇꠞꠦꠞ। ꠢꠣꠞꠣ ꠎꠉꠔ ꠀꠞ ꠚꠄ-ꠚꠡꠟ ꠎꠣꠟꠣꠁ ꠇꠞꠛ ꠍꠣꠟꠤ, ꠙꠣꠠꠞ ꠔꠟꠣꠔ ꠀꠉꠥꠁꠘ ꠎꠟꠛ, ꠎꠟꠛ ꠗꠥꠁꠟ ꠛꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("DT32_23","006_32_23","DEU","32","23","23","ꠟꠣꠈꠅ ꠟꠣꠈꠅ ꠛꠤꠙꠖ ꠖꠤꠝꠥ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞ, ꠀꠝꠣꠞ ꠔꠣꠝꠣꠝ ꠔꠤꠞ ꠝꠣꠞꠝꠥ ꠙꠦꠐꠞ ꠜꠥꠇꠦ ꠇꠞꠝꠥ ꠇꠣꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("DT32_24","006_32_24","DEU","32","24","24","ꠃꠙꠣꠡꠤ ꠘꠤꠖꠣꠘꠦ ꠔꠣꠞꠣ ꠢꠥꠇꠣꠁ ꠢꠥꠇꠣꠁ ꠝꠞꠛꠣ, ꠉꠎꠛꠤ ꠛꠦꠝꠣꠞꠞ ꠟꠉꠦ ꠖꠥꠈ-ꠔꠇꠟꠤꠚ ꠙꠣꠁꠛꠣ। ꠖꠣꠔ ꠀꠟꠣ ꠎꠋꠟꠤ ꠙꠡꠥ ꠙꠣꠑꠣꠁꠝꠥ ꠀꠝꠤ, ꠛꠤꠡꠣꠇ꠆ꠔ ꠡꠛ ꠢꠣꠚꠞ ꠙꠣꠟꠦ ꠖꠤꠛꠣ ꠇꠣꠝꠠꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("DT32_25","006_32_25","DEU","32","25","25","ꠛꠣꠞꠦ ꠉꠦꠟꠦ ꠝꠞꠛꠣ ꠔꠣꠞꠣ ꠔꠟꠥꠀꠞꠞ ꠔꠟꠦ, ꠊꠞꠅ ꠞꠁꠟꠦ ꠝꠞꠛꠣ ꠢꠇꠟ ꠎꠣꠘꠞ ꠒꠞ-ꠈꠚꠦ। ꠎꠥꠀꠘ ꠙꠥꠀ ꠎꠥꠀꠘ ꠙꠥꠠꠤꠘ ꠖꠥꠗꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ, ꠛꠤꠘꠣꠡꠤ ꠉꠎꠛꠦ ꠝꠞꠛꠣ ꠖꠣꠠꠤ ꠌꠥꠟ ꠙꠣꠇꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_26","006_32_26","DEU","32","26","26","ꠇꠁꠍꠟꠣꠝ ꠀꠝꠤ ꠃꠠꠣꠁ ꠝꠣꠞꠝꠥ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ, ꠁꠔꠣꠞ ꠘꠣꠝ ꠚꠥꠍꠤꠟꠣꠁꠝꠥ ꠝꠣꠘꠡꠞ ꠝꠘ ꠕꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_27","006_32_27","DEU","32","27","27","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ ꠖꠥꠡꠝꠘꠞ ꠜꠣꠛ-ꠡꠣꠛ, ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠛꠣ ꠔꠣꠞꠣ ꠅꠁꠛ ꠔꠣꠞꠣꠞ ꠟꠣꠜ। ꠘꠣ ꠛꠥꠎꠤꠀ ꠇꠁꠛ ꠔꠣꠞꠣ ꠎꠤꠔꠍꠦ ꠘꠤꠎꠞ ꠛꠟꠦ, ꠝꠣꠛꠥꠖ ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠔ ꠘꠣꠄ ꠎꠤꠔꠍꠤ ꠇꠟꠦ-ꠛꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_28","006_32_28","DEU","32","28","28","ꠛꠤꠌꠣꠞ-ꠛꠤꠛꠦꠇ ꠈꠥꠀꠁꠀ ꠅꠈꠘ ꠘꠣꠝꠦ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ, ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠀꠞꠣꠁꠀ ꠔꠣꠞꠣ ꠅꠁꠍꠦ ꠛꠦ-ꠙꠕꠤ। ");
INSERT INTO syls_vpl VALUES ("DT32_29","006_32_29","DEU","32","29","29","ꠀꠈꠟ ꠕꠣꠇꠟꠦ ꠛꠥꠎꠔ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠖꠥꠞ꠆ꠖꠡꠣ, ꠛꠤꠛꠦꠇ ꠈꠣꠐꠣꠁ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠀ ꠞꠁꠔ ꠢꠣꠝꠦꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_30","006_32_30","DEU","32","30","30","ꠄꠇ ꠖꠥꠡꠝꠘꠦ ꠀꠁꠀ ꠇꠤꠟꠣ ꠀꠎꠣꠞ ꠎꠘ ꠈꠦꠖꠣꠄ, ꠖꠥꠁ ꠍꠤꠙꠣꠁꠞꠦ ꠖꠦꠈꠤꠀ ꠇꠦꠘꠦ ꠖꠡ ꠀꠎꠣꠞ ꠖꠃꠠꠣꠄ। ꠘꠤꠎꠞ ꠀꠡꠞꠄ ꠐꠤꠟ꠆ꠟꠣ ꠎꠥꠖꠤ ꠔꠣꠞꠣꠞꠦ ꠘꠣ ꠛꠦꠌꠤꠔꠣ, ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠦ ꠎꠥꠖꠤ ꠍꠣꠠꠤꠀ ꠘꠣ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_31","006_32_31","DEU","32","31","31","ꠖꠥꠡꠝꠘꠞ ꠀꠡꠞꠄ ꠐꠤꠟ꠆ꠟꠣ ꠅꠔ ꠝꠎꠛꠥꠔ ꠘꠣꠄ, ꠔꠣꠞꠣꠃ ꠁꠈꠣꠘ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤ ꠢꠇꠟꠞꠦ ꠢꠥꠘꠣꠄ। ꠀꠝꠞꠣꠞ ꠀꠡꠞꠄ ꠐꠤꠟ꠆ꠟꠣ ꠔ ꠛꠃꠔ ꠛꠠ ꠛꠟꠛꠣꠘ, ꠔꠣꠞꠣꠞ ꠝꠥꠈꠦ ꠉꠣꠁꠀ ꠁꠔꠣ ꠎꠙꠦ ꠔꠣꠘ ꠡꠥꠘꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("DT32_32","006_32_32","DEU","32","32","32","ꠝꠣꠛꠥꠖꠦ ꠛꠣꠔꠣꠁꠞꠣ ꠅꠈꠘ ꠔꠣꠞꠣꠞ ꠈꠦꠔꠞ ꠇꠕꠣ, ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠀꠁꠍꠦ ꠁꠔꠣꠞ ꠀꠋꠉꠥꠞꠞ ꠟꠔꠣ, ꠀꠝꠥꠞꠣ ꠡꠢꠞ ꠕꠣꠇꠤ ꠁꠔꠣꠄ ꠀꠋꠉꠥꠞ ꠚꠟ ꠙꠣꠁꠍꠦ, ꠛꠤꠡ ꠀꠞ ꠔꠤꠔ꠆ꠔꠣꠄ ꠁ ꠚꠟꠞ ꠍꠠꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_33","006_32_33","DEU","32","33","33","ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠎꠦꠟꠣ ꠘꠣꠉ-ꠘꠣꠉꠤꠘꠤꠞ ꠛꠤꠡ, ꠀꠟꠖ ꠢꠣꠚꠞ ꠛꠤꠡꠅ ꠅꠟꠣ ꠝꠣꠞꠣꠔ꠆ꠔꠇ ꠎꠤꠘꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("DT32_34","006_32_34","DEU","32","34","34","ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠉꠎꠛ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠣꠠꠣ, ꠀꠝꠣꠞ ꠜꠣꠘ꠆ꠒꠣꠞꠅ ꠕꠅꠀ ꠡꠛ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_35","006_32_35","DEU","32","35","35","ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠡꠣꠎꠣ ꠖꠦꠅꠀ ꠀꠝꠣꠞꠃ ꠇꠣꠝ, ꠀꠝꠟ ꠝꠣꠚꠤꠇ ꠛꠖꠟꠣ ꠖꠤꠝꠥ ꠔꠣꠝꠣꠝ ꠁꠘꠍꠣꠘ। ꠡꠝꠄ ꠅꠁꠟꠦ ꠙꠤꠍꠟꠤꠎꠤꠛ ꠖꠥꠡꠝꠘꠞ ꠙꠣꠅ, ꠝꠍꠤꠛꠔꠞ ꠖꠤꠘ ꠔꠣꠞꠣꠞ ꠘꠎꠖꠤꠇ ꠎꠣꠘꠤꠟꠣꠅ। ꠑꠤꠇ ꠇꠞꠤ ꠕꠅꠀ ꠀꠍꠦ ꠔꠣꠞꠣꠞ ꠇꠣꠝꠞ ꠛꠖꠟꠣ, ꠎꠟꠖꠤ ꠇꠞꠤ ꠙꠣꠁꠛꠣ ꠘꠤꠎꠞ ꠀꠝꠟ-ꠘꠣꠝꠣ ꠎꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_36","006_32_36","DEU","32","36","36","ꠝꠣꠛꠥꠖꠦ ꠖꠦꠈꠛꠣ ꠎꠦꠛꠟꠣ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠘꠣꠁ, ꠔꠣꠘ ꠛꠘ꠆ꠖꠣꠞ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔ ꠉꠦꠍꠦꠉꠤ ꠚꠥꠠꠣꠁ। ꠉꠥꠟꠣꠝ ꠇꠤꠛꠣ ꠀꠎꠣꠖ ꠛꠘ꠆ꠖꠣ ꠢꠇꠟꠃ ꠝꠣꠎꠥꠞ, ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠙꠇ꠆ꠇ ꠟꠁꠛꠣ ꠀꠙꠘ ꠉꠥꠟꠣꠝꠞ। ꠝꠣꠄꠀ-ꠖꠄꠀ ꠇꠞꠛꠣ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠉꠥꠟꠣꠝꠞꠦ, ꠝꠣꠎꠥꠞ ꠕꠣꠇꠤ ꠡꠛꠟ ꠇꠞꠛꠣ ꠖꠄꠀ-ꠞꠢꠝꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_37","006_32_37","DEU","32","37","37","ꠇꠁꠛꠣ ꠔꠣꠁꠘ ꠢꠃ ꠡꠝꠄ ꠇꠥꠀꠁ ꠉꠦꠟꠣ ꠢꠤꠔꠣ, ꠅꠔꠖꠤꠘ ꠜꠎꠤꠍꠟꠣ ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠖꠦꠛꠔꠣ। ꠜꠣꠉꠤꠀ ꠉꠦꠟꠉꠤ ꠇꠥꠀꠁ ꠔꠣꠞꠣꠞ ꠀꠡꠞꠄ ꠙꠣꠠ, ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠅꠡꠣꠠꠞ ꠅꠡꠣꠠ। ");
INSERT INTO syls_vpl VALUES ("DT32_38","006_32_38","DEU","32","38","38","ꠇꠁ ꠉꠦꠟꠣ ꠢꠃ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠎꠦꠔꠣꠄ ꠈꠣꠁꠍꠟꠣ ꠌꠞ꠆ꠛꠤ, ꠌꠞ꠆ꠛꠤ ꠀꠟꠣ ꠛꠟꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠍꠤꠟ ꠛꠦꠡ ꠇꠞꠤ। ꠎꠦꠔꠣ ꠖꠦꠛꠔꠣꠁꠘ ꠈꠣꠁꠍꠤꠟ ꠍꠖꠉꠣꠞ ꠡꠞꠛꠔ, ꠅꠈꠘ ꠔꠣꠞꠣ ꠛꠣꠌꠣꠃꠇ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠃꠝ꠆ꠝꠔ। ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠃꠇ ꠘꠣ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠑꠣꠇꠥꠞ, ꠀꠡꠞꠄ ꠖꠦꠄ ꠘꠣ ꠇꠦꠘꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠖꠈꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("DT32_39","006_32_39","DEU","32","39","39","ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠅ ꠢꠃ ꠔꠣꠁꠘꠃ ꠀꠝꠤ, ꠀꠝꠤ ꠍꠣꠠꠣ ꠝꠣꠛꠥꠖ ꠘꠣꠁ ꠁꠈꠣꠘ ꠎꠣꠘꠍ ꠘꠤ। ꠀꠝꠤꠃ ꠝꠣꠞꠤꠟꠣꠁ ꠀꠝꠤꠃ ꠛꠣꠌꠣꠁ, ꠀꠝꠤꠃ ꠔ ꠎꠈꠝ ꠇꠞꠤ ꠀꠝꠤ ꠖꠦꠁ ꠜꠣꠟꠣꠁ। ꠀꠝꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠟꠤꠔ ꠡꠣꠁꠖ꠆ꠖ ꠀꠍꠦ ꠇꠣꠞ, ꠢꠣꠄꠀꠔ ꠝꠃꠔꠞ ꠝꠣꠟꠤꠇ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠢꠥ ꠀꠇꠛꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("DT32_40","006_32_40","DEU","32","40","40","ꠀꠞꠡꠞ ꠛꠣꠄ ꠀꠔ ꠔꠥꠟꠤꠀ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁ, ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠝꠤ ꠎꠣꠘꠤꠅ ꠘꠤꠌ꠆ꠌꠄ। ");
INSERT INTO syls_vpl VALUES ("DT32_41","006_32_41","DEU","32","41","41","ꠖꠣꠞ ꠎꠦꠛꠟꠣ ꠖꠤꠝꠥ ꠀꠝꠣꠞ ꠌꠇꠌꠇꠣ ꠔꠟꠥꠀꠞ, ꠇꠣꠁꠝ ꠇꠞꠣꠔ ꠟꠣꠉꠝꠥ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠞꠣꠄ-ꠛꠤꠌꠣꠞ। ꠢꠃ ꠡꠝꠄ ꠡꠣꠎꠣ ꠖꠤꠝꠥ ꠀꠝꠣꠞ ꠢꠇꠟ ꠖꠥꠡꠝꠘꠞꠦ, ꠀꠝꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠘꠤꠞ ꠛꠖꠟꠣ ꠖꠤꠝꠥ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_42","006_32_42","DEU","32","42","42","ꠔꠤꠞ-ꠗꠘꠥꠇꠦ ꠟꠃ ꠈꠣꠁꠀ ꠇꠞꠛ ꠝꠣꠔꠟꠣꠝꠤ, ꠀꠝꠣꠞ ꠔꠟꠥꠀꠞꠦꠅ ꠔ ꠟꠃ ꠈꠣꠁꠛ ꠎꠣꠘꠤ। ꠝꠥꠞ꠆ꠖꠣ ꠀꠞ ꠛꠘ꠆ꠖꠤ ꠅꠇꠟꠞ ꠟꠃ ꠢꠦ ꠈꠣꠁꠛ, ꠖꠥꠡꠝꠘꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠀ ꠙꠦꠐ ꠚꠥꠟꠣꠁꠛ। ꠟꠣꠝ꠆ꠛꠣ-ꠌꠥꠟꠤ ꠍꠤꠙꠣꠁꠞ ꠇꠟ꠆ꠟꠣ ꠈꠣꠁꠛꠞꠦ ꠝꠥꠈꠦ, ꠔꠣꠞꠣꠞ ꠇꠟ꠆ꠟꠣ ꠌꠤꠛꠣꠁ ꠈꠣꠁꠛ ꠀꠝꠣꠞ ꠗꠘꠥꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("DT32_43","006_32_43","DEU","32","43","43","ꠝꠣꠄꠀꠞ ꠙ꠆ꠞꠎꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠀꠍꠝꠣꠘ ꠈꠥꠡꠤ ꠅꠅ, ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠢꠇꠟ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘꠦ ꠍꠁꠎꠖꠣ ꠖꠦꠅ। ꠎꠉꠔꠞ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠄ ꠉꠣꠅ ꠉꠥꠘꠉꠣꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠟ ꠛꠘ꠆ꠖꠣꠞ ꠟꠉꠦ ꠟꠅ ꠔꠣꠘ ꠝꠢꠣ ꠘꠣꠝ। ꠔꠣꠘ ꠉꠥꠟꠣꠝꠞ ꠟꠃꠞ ꠛꠖꠟꠣ ꠅꠈꠘ ꠟꠁꠛꠣ ꠔꠣꠁꠘ, ꠖꠥꠡꠝꠘꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠀ ꠍꠣꠚ ꠇꠞꠛꠣ ꠎꠝꠤꠈꠣꠘ। ꠔꠣꠘ ꠛꠘ꠆ꠖꠣꠄ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠙꠣꠁꠟꠤꠛꠣ ꠞꠦꠢꠣꠁ, ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠖꠤꠀ ꠖꠤꠛꠣ ꠔꠣꠞ ꠛꠖꠟꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT32_44","006_32_44","DEU","32","44","44","ꠝꠥꠍꠣ ꠘꠛꠤ ꠀꠞ ꠔꠣꠘ ꠈꠣꠖꠤꠝ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣ ꠉꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠅꠃ ꠉꠎꠟꠞ ꠡꠛ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_45","006_32_45","DEU","32","45","45","ꠝꠥꠍꠣꠄ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠁꠀ ꠢꠣꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("DT32_46","006_32_46","DEU","32","46","46","ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠅꠃ ꠎꠔ ꠢꠥꠡꠤꠀꠞꠤꠞ ꠇꠕꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠍꠤ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠤꠅ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠡꠣꠇ꠆ꠇꠤ ꠛꠘꠤꠀ ꠞꠁꠛ। ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠅ, ꠅꠃ ꠡꠞꠤꠅꠔꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠀꠝꠟ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("DT32_47","006_32_47","DEU","32","47","47","ꠁꠔꠣ ꠔ ꠀꠎꠦ-ꠛꠣꠎꠦ ꠇꠥꠘꠥ ꠝꠣꠔ-ꠇꠕꠣ ꠘꠣꠄ, ꠁꠔꠣ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ! ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣ ꠎꠦ ꠖꠦꠡꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠞꠣꠄ, ꠅꠔꠣ ꠀꠝꠟ ꠇꠞꠟꠦ ꠢꠘꠅ ꠔꠥꠝꠞꠣ ꠟꠣꠝ꠆ꠛꠣ ꠢꠣꠄꠀꠔꠤ ꠙꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT32_48","006_32_48","DEU","32","48","48","ꠢꠃ ꠖꠤꠘꠃ ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("DT32_49","006_32_49","DEU","32","49","49","“ꠔꠥꠝꠤ ꠉꠤꠀ ꠅꠃ ꠀꠛꠣꠞꠤꠝ ꠙꠣꠠꠅ ꠃꠑꠅ, ꠁꠐꠣ ꠔ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠀꠍꠦ। ꠢꠘꠅ ꠃꠑꠤꠀ ꠘꠛꠅ ꠘꠣꠝꠞ ꠢꠃ ꠃꠌꠣ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠅ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠝꠤ ꠎꠦ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠞꠣꠝ, ꠅꠃ ꠇꠦꠘꠣꠘ ꠖꠦꠡ ꠄꠇꠛꠣꠞ ꠖꠦꠈꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("DT32_50","006_32_50","DEU","32","50","50","ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠣꠞꠥꠘ ꠎꠦꠟꠣ ꠢꠥꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠃꠚꠣꠔ ꠅꠁꠍꠤꠟ, ꠛꠣꠖꠦ ꠔꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠇꠣꠔꠣꠞꠅ ꠉꠤꠀ ꠀꠎꠤꠍꠤꠟ, ꠅꠃ ꠘꠛꠅ ꠙꠣꠠꠅ ꠃꠑꠣꠞ ꠛꠣꠖꠦ ꠅꠃꠟꠣ ꠔꠥꠝꠣꠞꠅ ꠃꠚꠣꠔ ꠅꠁꠛ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠅꠃꠟꠣꠈꠣꠘ ꠔꠥꠝꠤꠅ ꠀꠎꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT32_51","006_32_51","DEU","32","51","51","ꠝꠘꠅ ꠀꠍꠦ ꠘꠤ, ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣ ꠖꠥꠁꠅ ꠜꠣꠁꠄ ꠀꠝꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠝꠣꠁꠘ꠆ꠘ ꠇꠞꠍ ꠘꠣ, ꠢꠃ ꠎꠤꠘ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠣꠖꠦꠡ ꠄꠟꠣꠇꠣꠞ ꠝꠦꠞꠤꠛꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠙꠣꠘꠤꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠎꠣꠟꠤꠀꠔꠤ ꠇꠞꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT32_52","006_32_52","DEU","32","52","52","ꠢꠘꠅ ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠢꠃ ꠖꠦꠡ ꠖꠦꠈꠛꠣꠄ, ꠎꠦ ꠖꠦꠡꠈꠣꠘ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠣꠘ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠌꠃꠈꠖꠤ ꠖꠦꠈꠛꠣꠄ, ꠅꠁꠟꠦ ꠢꠤ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠁꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠔꠥꠝꠣꠞ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT33_1","006_33_1","DEU","33","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠛꠘ꠆ꠖꠣ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠃꠚꠣꠔꠞ ꠀꠉꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠔꠣꠁꠘ ꠅꠃ ꠖꠥꠀ ꠖꠤꠟꠣ: ");
INSERT INTO syls_vpl VALUES ("DT33_2","006_33_2","DEU","33","2","2","ꠔꠡꠞꠤꠚ ꠀꠘꠟꠣ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠞ ꠙꠣꠠ ꠕꠣꠇꠤ, ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠖꠦꠈꠣ ꠙꠣꠁꠟꠣꠝ ꠘꠥꠞꠦ ꠄꠟꠣꠢꠤ। ꠍꠦꠁꠞ ꠀꠞ ꠚꠣꠞꠣꠘ ꠙꠣꠠ ꠕꠣꠇꠤ ꠖꠦꠈꠣꠁꠘ ꠘꠥꠞꠞ ꠔꠦꠎ, ꠟꠣꠈꠅ ꠟꠣꠈꠅ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠇꠤꠛꠣ ꠀꠞꠅ ꠛꠦꠡ। ꠖꠤꠖꠣꠞ ꠖꠤꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠘꠦ, ꠒꠣꠁꠘ ꠀꠔꠅ ꠜꠞꠣ ꠀꠍꠤꠟ ꠘꠥꠞꠞ ꠀꠉꠥꠁꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("DT33_3","006_33_3","DEU","33","3","3","ꠢꠣꠍꠣꠃ ꠔꠣꠁꠘ ꠝꠣꠄꠀ ꠇꠞꠂꠘ ꠘꠤꠎꠞ ꠛꠘ꠆ꠖꠣꠞꠦ, ꠔꠣꠝꠣꠝ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘ꠆ꠖꠣ ꠔꠣꠘ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠦ। ꠍꠁꠎꠖꠣ ꠇꠞꠣꠔ ꠀꠍꠂꠘ ꠔꠣꠞꠣ ꠔꠣꠘ ꠙꠣꠅꠞ ꠔꠟꠣꠔ, ꠢꠥꠇꠥꠝ ꠙꠣꠁꠟꠦ ꠔꠣꠝꠤꠟ ꠇꠞꠂꠘ ꠞꠂꠘ ꠔꠣꠘ ꠇꠕꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("DT33_4","006_33_4","DEU","33","4","4","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠎꠦ ꠡꠞꠤꠅꠔ ꠖꠤꠍꠟꠣ ꠀꠝꠞꠣꠞꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠗꠘ ꠁꠔꠣ ꠎꠣꠘꠦ ꠢꠇꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("DT33_5","006_33_5","DEU","33","5","5","ꠖꠟꠣ ꠅꠁꠀ ꠀꠁꠟꠣ ꠎꠦꠛꠟꠣ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠖꠟ, ꠟꠉ ꠅꠁꠀ ꠀꠁꠍꠟꠣ ꠁꠍꠞꠣꠁꠟꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠢꠇꠟ, ꠢꠃ ꠡꠝꠄ ꠔ ꠝꠣꠛꠥꠖ ꠀꠍꠟꠣ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠞ ꠛꠣꠖꠡꠣ, ꠄꠞꠣ ꠢꠇꠟ ꠔꠣꠘ ꠙ꠆ꠞꠎꠣ ꠔꠣꠁꠘꠃ ꠡꠣꠢꠣꠘꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("DT33_6","006_33_6","DEU","33","6","6","ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ: ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠎꠤꠘ꠆ꠖꠣ ꠞꠃꠇ, ꠘꠤꠙꠣꠔ ꠘꠣꠄ ꠇꠥꠘꠥꠖꠤꠘ, ꠔꠣ-ꠅ ꠔꠣꠞ ꠊꠞꠅ ꠙꠄꠖꠣ ꠅꠁꠛ ꠇꠝ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("DT33_7","006_33_7","DEU","33","7","7","ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠟꠣ: ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠅꠈꠘ ꠄꠢꠥꠖꠣꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠅ, ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞꠞ ꠗꠣꠞꠅ ꠔꠣꠞꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠅ। ꠖꠥꠁꠅ ꠀꠔ ꠔꠣꠞ ꠡꠛꠟ ꠞꠣꠈꠅ ꠟꠣꠠꠣꠁꠞ ꠡꠝꠄ, ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠅ ꠔꠥꠝꠤ ꠔꠣꠞꠦ ꠖꠥꠡꠝꠘꠞꠦ ꠖꠦꠅ ꠀꠞꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("DT33_8","006_33_8","DEU","33","8","8","ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠟꠣ: ꠔꠥꠝꠣꠞ ꠀꠡꠤꠇꠞ ꠀꠔꠅ ꠀꠍꠦ ꠔꠥꠝ꠆ꠝꠤꠝ ꠀꠞ ꠃꠞꠤꠝ, ꠇꠥꠖꠞꠔꠤ ꠢꠃ ꠖꠥꠁ ꠍꠣꠝꠣꠘꠣꠞ ꠝꠣꠟꠤꠇ ꠈꠣꠟꠤ ꠅꠃ ꠟꠦꠛꠤꠘ। ꠝꠣꠍꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠟꠁꠍ ꠔꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣ, ꠝꠦꠞꠤꠛꠣ ꠘꠣꠝꠞ ꠙꠣꠘꠤꠞ ꠎꠣꠉꠣꠔ ꠅꠁꠍꠤꠟ ꠅꠃ ꠇꠣꠁꠎ꠆ꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("DT33_9","006_33_9","DEU","33","9","9","ꠝꠣ-ꠛꠣꠚꠞꠦꠅ ꠔꠥꠟꠍꠦ ꠘꠣ ꠢꠦ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ, ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠖꠤꠍꠦ ꠔꠣꠞ ꠝꠣʼꠞ ꠙꠦꠐꠞ ꠜꠣꠁꠞꠦ। ꠖꠣꠛꠤ ꠍꠣꠠꠤꠀ ꠡꠙꠤ ꠖꠤꠍꠦ ꠀꠙꠘ ꠙꠥꠀ-ꠙꠥꠠꠤ, ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠦ ꠔꠥꠝꠣꠞ ꠀꠁꠘ ꠝꠣꠘꠤ। ꠔꠥꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠙꠣꠞꠣ ꠖꠤꠍꠦ ꠝꠣꠘꠍꠦ ꠡꠞꠤꠅꠔ, ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠝꠣꠘꠤꠀ ꠌꠟꠍꠦ, ꠘꠣ ꠇꠞꠤ ꠈꠤꠀꠘꠔ। ");
INSERT INTO syls_vpl VALUES ("DT33_10","006_33_10","DEU","33","10","10","ꠔꠥꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠔꠣꠞꠣ ꠢꠤꠇꠣꠄ ꠁꠀꠇꠥꠛ ꠛꠋꠡꠞꠦ, ꠔꠥꠝꠣꠞ ꠡꠞꠤꠅꠔ ꠛꠥꠎꠣꠄ ꠔꠣꠞꠣ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞꠦ। ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠄ ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠄ ꠇꠥꠞꠛꠣꠘ-ꠉꠣꠔ ꠉꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("DT33_11","006_33_11","DEU","33","11","11","ꠔꠣꠞ ꠍꠣꠝꠣꠘꠣꠔ ꠛꠞꠇꠔ ꠖꠦꠅ ꠉ ꠅ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ, ꠞꠣꠎꠤ-ꠈꠥꠡꠤ ꠞꠅ ꠔꠥꠝꠤ ꠔꠣꠞ ꠃꠙꠞꠦ ꠛꠃꠔ। ꠔꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠇꠝꠞ ꠔꠥꠝꠤ ꠜꠣꠋꠉꠤ-ꠌꠥꠞꠤ ꠖꠦꠅ, ꠊꠤꠘ꠆ꠘꠣ ꠇꠞꠞꠣꠞ ꠇꠝꠞ ꠜꠣꠋꠉꠤ ꠛꠞꠛꠣꠖ ꠇꠞꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("DT33_12","006_33_12","DEU","33","12","12","ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ: ꠝꠣꠛꠥꠖꠞ ꠝꠣꠄꠀꠞ ꠛꠘ꠆ꠖꠣ ꠡꠣꠄ-ꠡꠣꠘ꠆ꠔꠤꠄ ꠞꠁꠛ, ꠘꠤꠞꠣꠙꠖꠦ ꠞꠁꠛ ꠢꠦ ꠔꠣꠘ ꠒꠣꠈꠘꠣꠞ ꠔꠟꠅ। ꠢꠣꠞꠣ ꠖꠤꠘ ꠢꠣꠞꠣ ꠞꠣꠁꠔ ꠍꠣꠄꠀꠔ ꠞꠣꠈꠛꠣ ꠔꠣꠞꠦ, ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠉꠥꠎꠞꠤꠛ ꠔꠣꠞ ꠔꠣꠘ ꠛꠉꠟ ꠔꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("DT33_13","006_33_13","DEU","33","13","13","ꠁꠃꠍꠥꠚ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ: ꠞꠢꠝ-ꠛꠞꠇꠔ ꠇꠞꠅ ꠝꠣꠛꠥꠖ ꠔꠣꠞ ꠖꠦꠡꠈꠣꠘꠞꠦ, ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠎꠤꠘꠤꠡ ꠖꠦꠅ ꠔꠣꠞꠦ। ꠈꠥꠀ ꠖꠤꠀ ꠜꠤꠎꠣꠁ ꠖꠦꠅ ꠃꠙꠞꠞ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ, ꠀꠞꠅ ꠖꠦꠅ ꠔꠣꠞ ꠎꠝꠤꠘꠅ ꠝꠣꠐꠤꠞ ꠝꠥꠞꠞ ꠙꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("DT33_14","006_33_14","DEU","33","14","14","ꠡꠥꠞꠥꠎꠞ ꠔꠦꠎꠦ ꠙꠣꠇꠣꠁꠀ ꠖꠦꠅ ꠜꠣꠟꠣ ꠚꠟ, ꠌꠣꠘ꠆ꠖꠦ ꠌꠣꠘ꠆ꠖꠦ ꠖꠦꠅ ꠔꠣꠞꠦ ꠝꠎꠣꠞ ꠚꠡꠟ। ");
INSERT INTO syls_vpl VALUES ("DT33_15","006_33_15","DEU","33","15","15","ꠙꠥꠞꠣꠘꠣ ꠙꠣꠠ ꠕꠣꠇꠤ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠖꠦꠅ, ꠌꠤꠞꠇꠣꠟꠤꠘ ꠙꠣꠠꠤꠀ ꠝꠣꠟ ꠔꠣꠞ ꠎꠝꠤꠘꠅ ꠘꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("DT33_16","006_33_16","DEU","33","16","16","ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠖꠦꠅ ꠉ ꠝꠣꠛꠥꠖ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠝꠣꠟ, ꠎꠣꠟꠣꠁꠟ ꠎꠋꠟꠣꠞ ꠘꠥꠞꠞ ꠝꠣꠟꠤꠇ ꠞꠢꠝ ꠇꠞꠅ ꠌꠤꠞꠇꠣꠟ, ꠁꠃꠍꠥꠚꠞ ꠝꠣꠕꠣꠔ ꠟꠣꠝꠃꠇ ꠀꠝꠣꠞ ꠅꠃ ꠖꠥꠀ, ꠜꠣꠁꠀꠁꠘ ꠕꠣꠇꠤ ꠝꠢꠣꠘ ꠎꠘꠞ ꠔꠣꠟꠥꠔ ꠟꠣꠝꠃꠇ ꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("DT33_17","006_33_17","DEU","33","17","17","ꠒꠦꠇꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠝꠔ ꠅꠃꠇ ꠔꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠀꠞ ꠡꠣꠘ, ꠔꠣꠞ ꠝꠣꠕꠣꠞ ꠢꠤꠋ ꠎꠥꠠꠣ ꠔ ꠎꠋꠟꠤ ꠛꠄꠞꠣꠞ ꠟꠣꠈꠣꠘ। ꠢꠤꠋ ꠖꠤꠀ ꠉꠥꠔꠣꠁꠛ ꠢꠦ ꠢꠣꠞꠣ ꠎꠉꠔꠞꠦ, ꠙꠥꠛ ꠙꠌꠤꠝ ꠃꠔ꠆ꠔꠞ ꠖꠇ꠆ꠇꠤꠘ ꠖꠃꠠꠣꠁꠛ ꠢꠇꠟꠞꠦ। ꠀꠚꠞꠣꠁꠝꠞ ꠅꠁꠛꠣ ꠅꠟꠣ ꠟꠣꠈꠅ ꠟꠣꠈꠅ ꠎꠘ, ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠎꠘ ꠅꠁꠛꠣ ꠝꠣꠘꠡꠣꠞ ꠝꠥꠟ ꠗꠘ। ");
INSERT INTO syls_vpl VALUES ("DT33_18","006_33_18","DEU","33","18","18","ꠍꠛꠥꠟꠘ ꠀꠞ ꠁꠍꠣꠈꠞꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ: ꠍꠛꠥꠟꠘꠦ ꠈꠥꠡꠤ ꠇꠞꠃꠇ ꠛꠣꠁꠞꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠟꠁꠀ, ꠁꠍꠣꠈꠞ ꠈꠥꠡꠤ ꠞꠃꠇ ꠊꠞꠞ ꠇꠣꠝꠅ ꠞꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("DT33_19","006_33_19","DEU","33","19","19","ꠒꠣꠇꠤ ꠒꠣꠇꠤ ꠙꠣꠠꠞ ꠗꠣꠞꠅ ꠀꠘꠛ ꠝꠣꠘꠡꠞꠦ, ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛ ꠢꠘꠅ ꠈꠣꠍ ꠍꠢꠤ ꠖꠤꠟꠦ। ꠖꠞꠤꠀ ꠕꠣꠇꠤ ꠔꠥꠟꠛꠣ ꠔꠣꠞꠣ ꠖꠞꠤꠀꠞ ꠙꠦꠐꠞ ꠗꠘ, ꠛꠣꠟꠤ ꠕꠣꠇꠤ ꠔꠥꠟꠤꠀ ꠀꠘꠛꠣ ꠟꠥꠇꠣꠁꠟ ꠡꠛ ꠞꠔꠘ। ");
INSERT INTO syls_vpl VALUES ("DT33_20","006_33_20","DEU","33","20","20","ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ: ꠝꠥꠛꠣꠞꠇ ꠢꠃ ꠎꠘ, ꠍꠣꠖꠥꠞ ꠎꠣꠄꠉꠣ ꠛꠣꠠꠣꠁ ꠖꠤꠛꠣ ꠎꠦꠁꠘ, ꠍꠣꠖꠥ ꠔ ꠡꠤꠋꠢꠞ ꠟꠣꠈꠣꠘ ꠈꠣꠙ ꠗꠞꠤ ꠞꠄ, ꠖꠥꠡꠝꠘꠞ ꠀꠔ ꠀꠞ ꠇꠟ꠆ꠟꠣ ꠍꠤꠠꠤꠀ ꠚꠣꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("DT33_21","006_33_21","DEU","33","21","21","ꠢꠇꠟ ꠕꠣꠇꠤ ꠡꠞꠟ ꠎꠝꠤ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠘꠤꠍꠦ, ꠎꠁꠉ꠆ꠉ ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠀꠡꠘ ꠔꠣꠞ ꠟꠣꠉꠤ ꠕꠅꠀ ꠅꠁꠍꠦ। ꠎꠣꠔꠤꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟ ꠖꠟꠣ ꠅꠀꠞ ꠇꠣꠟꠅ, ꠝꠣꠛꠥꠖꠞ ꠘꠤꠀꠄ ꠛꠤꠌꠣꠞ ꠢꠦ ꠔꠣꠝꠤꠟ ꠇꠞꠤꠟ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠦꠅꠀ ꠢꠥꠇꠥꠝ ꠙꠥꠞꠣ ꠝꠣꠁꠘ꠆ꠘ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("DT33_22","006_33_22","DEU","33","22","22","ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞ ꠔꠣꠁꠘ ꠇꠁꠟꠣ: ꠚꠥꠞꠚꠥꠞꠣ ꠡꠤꠋꠢꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠁꠟ ꠖꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠛꠣꠡꠘ ꠖꠦꠡ ꠕꠘ ꠚꠣꠟꠖꠤ ꠀꠁꠀ ꠇꠞꠦ ꠛꠠꠣꠁ ꠡꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("DT33_23","006_33_23","DEU","33","23","23","ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ: ꠘꠙ꠆ꠔꠣꠟꠤ ꠔ ꠝꠣꠛꠥꠖꠞ ꠝꠣꠄꠀ-ꠝꠝꠔꠣꠔ ꠢꠣꠛꠥꠒꠥꠛꠥ ꠈꠣꠞ, ꠔꠣꠘ ꠞꠢꠝ-ꠛꠞꠇꠔꠅ ꠢꠦ ꠢꠣꠔꠣꠞ ꠇꠣꠐꠦꠞ। ꠔꠥꠝꠤ ꠔꠣꠞꠦ ꠔꠣꠞ ꠀꠙꠘ ꠡꠤꠝꠣꠘꠣꠔ ꠀꠘꠅ, ꠍꠁ-ꠍꠣꠟꠣꠝꠔꠦ ꠉꠣꠟꠤꠟ ꠀꠅꠞ ꠀꠞ ꠖꠃꠇꠘꠞ ꠖꠦꠡꠅ ꠘꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("DT33_24","006_33_24","DEU","33","24","24","ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ: ꠀꠡꠤꠞꠦ ꠙꠣꠁꠛ ꠞꠢꠝꠔ ꠅꠁꠘ꠆ꠘ ꠕꠣꠇꠤ ꠛꠦꠡꠤ, ꠢꠇꠟ ꠜꠣꠁꠄ ꠝꠣꠄꠀ ꠇꠞꠛꠣ ꠔꠣꠞꠦ ꠞꠣꠡꠤ ꠞꠣꠡꠤ। ꠅꠔ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠁꠀ ꠈꠥꠡꠤ ꠕꠣꠇꠣꠞ ꠇꠣꠟꠅ, ꠖꠥꠁ ꠙꠣꠅ ꠔꠣꠞ ꠒꠥꠛꠣꠁꠟ ꠞꠁꠛ ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("DT33_25","006_33_25","DEU","33","25","25","ꠔꠣꠞ ꠉꠦꠁꠐ ꠅꠇꠟ ꠛꠣꠘ꠆ꠖꠣꠁꠟ ꠅꠃꠇ ꠟꠥꠀ ꠀꠞ ꠔꠣꠝꠣꠖꠤ, ꠢꠦ ꠛꠟꠀꠟꠣ ꠝꠎꠛꠥꠔ ꠞꠃꠇ ꠔꠣꠞ ꠙꠥꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("DT33_26","006_33_26","DEU","33","26","26","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠀꠞꠅ ꠇꠁꠟꠣ: ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠟ꠆ꠟꠣꠞ ꠢꠝꠣꠘꠤ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠘꠣꠁ, ꠔꠥꠝꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ ꠀꠍꠝꠣꠘꠅ ꠛꠦꠠꠣꠁꠘ। ꠔꠣꠘ ꠘꠤꠎꠞ ꠡꠣꠘ-ꠝꠢꠤꠝꠣꠄ ꠝꠦꠊꠞ ꠌꠣꠇꠣꠔ ꠌꠠꠤꠀ, ꠡꠣꠁꠎ꠆ꠎꠇꠣꠞꠤ ꠅꠁꠔꠣ ꠌꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("DT33_27","006_33_27","DEU","33","27","27","ꠢꠇꠟ ꠙꠄꠟꠣꠇꠥꠞ ꠄꠇ ꠀꠟ꠆ꠟꠣꠃ ꠅꠁꠟꠣ ꠀꠡꠞꠄ ꠑꠤꠇꠣꠘꠣ, ꠔꠣꠘ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠀꠔ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠣꠈꠍꠂꠘ ꠗꠞꠤꠀ। ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠞ ꠢꠇꠟ ꠖꠥꠡꠝꠘ ꠔꠣꠁꠘꠃ ꠈꠦꠖꠣꠁ ꠖꠦꠁꠘ, ꠁꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠅ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ ꠔꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("DT33_28","006_33_28","DEU","33","28","28","ꠄꠞꠟꠣꠉꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠜꠣꠟꠣ-ꠀꠚꠔꠣ ꠞꠂꠘ, ꠁꠀꠇꠥꠛ ꠛꠋꠡꠞ ꠙꠣꠘꠤꠞ ꠏꠞꠘꠣ ꠘꠤꠞꠣꠙꠖ ꠕꠣꠇꠂꠘ। ꠢꠤꠘꠅ ꠞꠁꠛ ꠚꠄ-ꠚꠡꠟ ꠀꠞ ꠀꠋꠉꠥꠞ ꠞꠡꠦ ꠜꠞꠣ, ꠔꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠝꠛ ꠀꠍꠝꠣꠘꠤ ꠈꠥꠀ। ");
INSERT INTO syls_vpl VALUES ("DT33_29","006_33_29","DEU","33","29","29","ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠝꠥꠛꠣꠞꠇ ꠀꠅꠟꠣꠖ ꠔꠥꠝꠤ! ꠔꠥꠝꠤ ꠅꠁꠟꠣꠄ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠀꠎꠣꠖ ꠇꠞꠣ ꠎꠣꠔꠤ। ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖ ꠅꠁꠟꠣ ꠔꠥꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠓꠣꠟ, ꠔꠣꠁꠘꠃ ꠅꠁꠟꠣ ꠔꠥꠝꠣꠞ ꠎꠄꠅꠞ ꠗꠣꠞꠣꠁꠟ ꠔꠟꠥꠀꠞ। ꠖꠥꠡꠝꠘ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠟꠦ ꠕꠞ-ꠕꠞꠣꠁꠀ ꠇꠣꠙꠦ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠦ ꠝꠣꠠꠣ ꠖꠤꠛꠣꠄ ꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("DT34_1","006_34_1","DEU","34","1","1","ꠛꠣꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠔꠟ ꠎꠣꠉꠣ ꠕꠣꠇꠤ, ꠘꠛꠅ ꠙꠣꠠꠞ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠟꠣ, ꠅꠃ ꠐꠤꠟ꠆ꠟꠣ ꠔ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠍꠣꠝꠘꠦ ꠙꠤꠍꠉꠣ ꠙꠣꠠꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠃꠌꠣ ꠐꠤꠟ꠆ꠟꠣ। ꠢꠘꠅ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠢꠇꠟ ꠖꠦꠡ ꠖꠦꠈꠣꠁꠟꠣ, ꠉꠤꠟꠤꠅꠖ ꠕꠣꠇꠤ ꠖꠣꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ");
INSERT INTO syls_vpl VALUES ("DT34_2","006_34_2","DEU","34","2","2","ꠀꠡ꠆ꠔꠣ ꠘꠙ꠆ꠔꠣꠟꠤ ꠖꠦꠡ, ꠀꠚꠞꠣꠁꠝ ꠀꠞ ꠝꠣꠘꠡꠣ ꠖꠦꠡ, ꠀꠞ ꠙꠁꠌꠝꠞ ꠖꠞꠤꠀꠞ ꠙꠣꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠙꠥꠞꠣ ꠄꠢꠥꠖꠣ ꠖꠦꠡ, ");
INSERT INTO syls_vpl VALUES ("DT34_3","006_34_3","DEU","34","3","3","ꠖꠃꠇꠘꠞ ꠘꠦꠉꠦꠜ ꠝꠞꠥꠜꠥꠝꠤ, ꠈꠦꠎꠥꠞꠤ ꠐꠣꠃꠘ ꠎꠤꠞꠤꠢꠅ, ꠀꠞ ꠄꠞ ꠇꠣꠘ꠆ꠖꠣꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠖꠃꠇꠘꠞ ꠝꠞꠥꠜꠥꠝꠤ ꠕꠣꠇꠤ ꠍꠥꠀꠞ ꠉꠣꠃ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇꠟ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("DT34_4","006_34_4","DEU","34","4","4","ꠅꠔꠣ ꠖꠦꠈꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠁꠈꠣꠘ ꠅꠁꠟ ꠢꠃ ꠖꠦꠡ, ꠎꠦꠈꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍꠦ ꠇꠍꠝ ꠈꠣꠁꠍꠟꠣꠝ। ꠔꠣꠞꠣꠞꠦ ꠇꠁꠍꠟꠣꠝ, ꠖꠦꠡꠈꠣꠘ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞꠦ ꠖꠤꠝꠥ। ꠔꠦ ꠁꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠡꠞꠣꠡꠞꠤ ꠖꠦꠈꠣꠁꠟꠣꠝ, ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋ ꠙꠣꠞ ꠅꠁꠀ ꠢꠤꠘꠅ ꠢꠣꠝꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("DT34_5","006_34_5","DEU","34","5","5","ꠝꠣꠛꠥꠖꠞ ꠎꠛꠣꠘ ꠝꠣꠚꠤꠇ, ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠃꠚꠣꠔ ꠅꠃ ꠝꠥꠀꠛ ꠖꠦꠡꠅꠃ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("DT34_6","006_34_6","DEU","34","6","6","ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠛꠣꠄꠔ-ꠙꠤꠃꠞꠞ ꠗꠣꠞꠅ ꠙꠣꠠꠤꠀ ꠔꠟ ꠎꠣꠉꠣꠔ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠦ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠘ ꠞꠅꠎꠣ ꠡꠞꠤꠚꠞꠦ ꠅꠈꠘꠅ ꠇꠦꠃ ꠌꠤꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT34_7","006_34_7","DEU","34","7","7","ꠃꠚꠣꠔꠞ ꠇꠣꠟꠅ ꠔꠣꠘ ꠛꠄꠅꠡ ꠀꠍꠤꠟ ꠄꠇ-ꠡ ꠛꠤꠡ ꠛꠍꠞ। ꠢꠃ ꠡꠝꠄꠅ ꠔꠣꠘ ꠌꠃꠈꠞ ꠙꠣꠅꠀꠞ ꠇꠝꠍꠦ ꠘꠣ, ꠔꠣꠘ ꠡꠞꠤꠟ ꠇꠝꠎꠥꠞ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT34_8","006_34_8","DEU","34","8","8","ꠃꠚꠣꠔꠞ ꠛꠣꠖꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠤꠡ ꠖꠤꠘ ꠗꠞꠤ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠘꠤꠌꠣ ꠔꠟ ꠎꠣꠉꠣꠔ ꠔꠣꠘ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠟꠣ। ꠅꠃ ꠔꠤꠡ ꠖꠤꠘ ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞ ꠖꠥꠈ-ꠀꠢꠣꠎꠣꠞꠤ ꠡꠦꠡ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("DT34_9","006_34_9","DEU","34","9","9","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠘꠥꠘꠞ ꠙꠥꠀ ꠁꠃꠍꠣꠞ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠦ ꠀꠔ ꠞꠣꠈꠣꠞ ꠇꠣꠞꠘꠦ, ꠅꠃ ꠡꠝꠄ ꠕꠘꠦ ꠁꠃꠍꠣ ꠀꠈꠟꠞ ꠞꠥꠢꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠟ ꠅꠁꠉꠦꠟꠣ। ꠔꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ ꠔꠣꠘ ꠙꠞꠣꠝꠤꠡꠦ ꠌꠟꠟꠣ, ꠀꠞ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠞꠚꠔꠦ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("DT34_10","006_34_10","DEU","34","10","10","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠟꠣ ꠇꠥꠘꠥ ꠘꠛꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠎꠘꠝ ꠟꠁꠍꠂꠘ ꠘꠣ, ꠎꠣꠘ ꠟꠉꠦ ꠝꠣꠛꠥꠖꠦ ꠍꠣꠝꠘꠣ-ꠍꠣꠝꠘꠤ ꠅꠁꠀ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("DT34_11","006_34_11","DEU","34","11","11","ꠝꠣꠛꠥꠖꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠛꠦꠎꠤꠀ ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘ ꠀꠞ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ, ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠀꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠁꠔꠣꠅ ꠀꠞ ꠇꠦꠃ ꠇꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("DT34_12","006_34_12","DEU","34","12","12","ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠎꠦꠟꠣ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠀꠞ ꠒꠞ-ꠈꠚꠞ ꠘꠣꠘꠣꠘ ꠇꠦꠞꠣꠝꠔꠤꠞ ꠇꠣꠝ ꠇꠞꠍꠂꠘ, ꠁꠟꠣ ꠇꠣꠝ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠇꠞꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠅꠁꠍꠦ ꠘꠣ। ꠈꠔꠝ॥");
INSERT INTO syls_vpl VALUES ("RT1_1","009_1_1","RUT","1","1","2","ꠢꠎꠞꠔ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠔꠤꠘ ꠍꠤꠠꠤ ꠀꠉꠦ ꠀꠝꠤꠞ ꠅꠇꠟꠞ ꠢꠥꠇꠥꠝꠔꠞ ꠀꠝꠟꠅ, ꠄꠢꠥꠖꠣ ꠖꠦꠡꠅ ꠀꠟꠤ ꠝꠣꠟꠤꠇ ꠘꠣꠝꠦ ꠄꠇ ꠛꠦꠐꠣ ꠀꠍꠟꠣ, ꠔꠣꠘ ꠛꠤꠛꠤꠞ ꠘꠣꠝ ꠘꠄꠅꠝꠤ, ꠝꠢꠟꠥꠘ ꠀꠞ ꠇꠤꠟꠤꠅꠘ ꠘꠣꠝꠞ ꠔꠣꠞꠣꠞ ꠖꠥꠁ ꠙꠥꠀ ꠀꠍꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠖꠦꠡꠅ ꠈꠥꠛ ꠛꠦꠎꠥꠁꠔꠣ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠟ। ꠘꠤꠖꠣꠘꠞ ꠑꠦꠟꠣꠄ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃꠞ ꠁꠚ꠆ꠞꠣꠕꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠅꠃ ꠀꠟꠤ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠛꠤꠛꠤ ꠀꠞ ꠙꠥꠀꠂꠘꠞꠦ ꠟꠁꠀ ꠝꠥꠀꠛ ꠖꠦꠡꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RT1_3","009_1_3","RUT","1","3","3","ꠢꠘꠅ ꠎꠣꠅꠀꠞ ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠀꠟꠤ ꠝꠣꠟꠤꠇ ꠝꠞꠤꠉꠦꠟꠣ, ꠔꠣꠘ ꠛꠃ ꠘꠄꠅꠝꠤ ꠀꠞ ꠖꠥꠁꠅ ꠙꠥꠀ ꠄꠔꠤꠝ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RT1_4","009_1_4","RUT","1","4","5","ꠛꠣꠖꠦ ꠛꠤꠛꠤ ꠘꠄꠅꠝꠤꠄ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠅꠃ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠖꠥꠁ ꠇꠁꠘꠣꠞ ꠟꠉꠦ ꠡꠣꠖꠤ ꠖꠤꠟꠣ। ꠄꠇ ꠇꠁꠘꠣꠞ ꠘꠣꠝ ꠞꠥꠔ, ꠀꠞꠇ ꠇꠁꠘꠣꠞ ꠘꠣꠝ ꠅꠞꠙꠣ। ꠡꠣꠖꠤꠞ ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠖꠥꠁꠅ ꠙꠥꠀꠅ ꠝꠞꠤꠉꠦꠟꠣ। ꠅꠃꠟꠣ ꠄꠇ ꠖꠡ ꠛꠞꠍ ꠉꠦꠟ। ꠛꠤꠛꠤ ꠘꠄꠅꠝꠤꠄ ꠔꠣꠘ ꠖꠥꠁꠅ ꠛꠃꠞꠦ ꠟꠁꠀ ꠠꠣꠠꠤ ꠢꠣꠟꠔꠦ ꠢꠃ ꠝꠥꠀꠛ ꠖꠦꠡꠅꠃ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT1_6","009_1_6","RUT","1","6","6","ꠀꠈꠔꠣ ꠄꠇꠖꠤꠘ ꠔꠣꠁꠘ ꠈꠛꠞ ꠙꠣꠁꠟꠣ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠢꠃ ꠄꠢꠥꠖꠣ ꠖꠦꠡꠅ ꠝꠣꠛꠥꠖꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠤꠀ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RT1_7","009_1_7","RUT","1","7","7","ꠅꠃ ꠈꠛꠞ ꠙꠣꠁꠀ ꠔꠣꠁꠘ ꠖꠥꠁꠅ ꠙꠥꠀꠞ ꠛꠃꠞꠦ ꠟꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠣꠉꠤ ꠇꠞꠤ ꠔꠤꠀꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT1_8","009_1_8","RUT","1","8","8","ꠙꠕꠅ ꠛꠣꠞ ꠅꠁꠀ ꠛꠤꠛꠤ ꠘꠄꠅꠝꠤꠄ ꠔꠣꠘ ꠙꠥꠀꠞ ꠛꠃꠀꠁꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠦꠐꠤꠘ, ꠔꠥꠝꠤꠔꠣꠁꠘ ꠔꠥꠝꠣꠞꠔꠣꠘꠞ ꠝꠣʼꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠉꠤ, ꠢꠘꠅ ꠉꠦꠟꠦ ꠔꠥꠝꠞꠣ ꠡꠥꠈ ꠙꠣꠁꠛꠣꠄ। ꠝꠣ-ꠛꠣꠚꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠘꠄꠀ ꠊꠞ-ꠡꠋꠡꠣꠞ ꠇꠞꠛꠣꠄ। ꠀꠞ ꠝꠣꠁ ꠅꠇꠟꠞꠦ, ꠀꠝꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠜꠣꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠍ, ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃꠟꠣ ꠜꠣꠟꠣꠁ ꠇꠞꠃꠇ꠆ꠇꠣ, ");
INSERT INTO syls_vpl VALUES ("RT1_9","009_1_9","RUT","1","9","9","ꠔꠥꠝꠞꠣꠞꠦ ꠜꠣꠟꠣ ꠛꠦꠐꠣ ꠝꠤꠟꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠔꠥꠝꠞꠣ ꠎꠣꠔꠦ ꠡꠥꠈ-ꠡꠣꠘ꠆ꠔꠤꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔꠣꠄ ꠙꠣꠞ।” ꠇꠁꠀ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞꠦ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠝꠣꠄꠀ ꠖꠤꠟꠣ। ꠔꠦꠃ ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠀꠃ ꠀꠃ ꠇꠞꠤ ꠒꠣꠇꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RT1_10","009_1_10","RUT","1","10","10","“ꠝꠣꠁ ꠉ, ꠀꠝꠞꠣꠞꠦꠅ ꠀꠙꠘꠣꠞ ꠟꠉꠈꠣꠘꠅ ꠀꠙꠘꠣꠞ ꠖꠦꠡꠅ ꠘꠦꠃꠇ꠆ꠇꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("RT1_11","009_1_11","RUT","1","11","11","ꠢꠠꠤꠄ ꠇꠁꠟꠣ, “ꠘꠣ ꠞꠦꠉ ꠝꠣꠁ, ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣꠟ꠆ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠎꠣꠁꠔꠣꠄ? ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠝꠣʼꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠉꠤ। ꠀꠝꠣꠞ ꠟꠉꠦ ꠉꠦꠟꠦ ꠔ ꠟꠣꠜ-ꠃꠛ ꠅꠁꠔ ꠘꠣꠄ। ꠁꠟꠣ ꠔ ꠘꠣꠄ ꠎꠦꠘ ꠀꠝꠣꠞ ꠀꠞꠅ ꠙꠥꠀꠂꠘ ꠀꠍꠂꠘ, ꠅꠔꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠣꠈꠝꠥ, ");
INSERT INTO syls_vpl VALUES ("RT1_12","009_1_12","RUT","1","12","12","ꠛꠣ ꠀꠝꠤ ꠀꠞꠇ ꠡꠋꠡꠣꠞ ꠙꠣꠔꠤꠀ ꠢꠃ ꠔꠞꠚꠣ ꠙꠥꠀꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠣꠈꠔꠣꠝ ꠙꠣꠞꠝꠥ। ꠀꠝꠣꠞ ꠔ ꠀꠞ ꠁ ꠛꠄꠅꠡꠅ ꠞꠁꠍꠦ ꠘꠣ। ꠀꠞ ꠞꠁꠟꠦꠅ ꠀꠝꠤ ꠀꠁꠎ ꠞꠣꠁꠔꠃ ꠀꠞꠇ ꠡꠋꠡꠣꠞ ꠙꠣꠔꠤꠀ ꠢꠣꠞꠤ ꠀꠝꠣꠞ ꠊꠞꠅ ꠇꠥꠘꠥ ꠙꠥꠔ ꠎꠘꠝꠤꠟꠦꠅ, ");
INSERT INTO syls_vpl VALUES ("RT1_13","009_1_13","RUT","1","13","13","ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠅꠔꠖꠤꠘ ꠛꠣꠠ ꠌꠣꠁꠛꠣꠄ ꠘꠤ? ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ, ꠀꠝꠤ ꠔ ꠅꠜꠣꠉꠤ, ꠇꠙꠣꠟ-ꠙꠥꠠꠣ। ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠑꠣꠐꠣ ꠚꠣꠟꠣꠁ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("RT1_14","009_1_14","RUT","1","14","14","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠀꠃ ꠀꠃ ꠇꠞꠤ ꠇꠣꠘ꠆ꠖꠘ ꠗꠞꠟꠣ। ꠇꠔ ꠡꠝꠄ ꠇꠣꠘ꠆ꠖꠤꠀ ꠢꠣꠞꠤ ꠅꠞꠙꠣꠄ ꠔꠣꠘ ꠢꠠꠤꠞꠦ ꠝꠣꠄꠀ ꠖꠤꠀ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣꠉꠤ। ꠅꠁꠟꠦ ꠞꠥꠔ ꠔꠣꠘ ꠢꠠꠤꠞ ꠟꠉꠦꠃ ꠞꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT1_15","009_1_15","RUT","1","15","15","ꠄꠁꠘ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠠꠤꠄ ꠞꠥꠔꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠦꠐꠤ, ꠔꠥꠝꠣꠞ ꠎꠣꠟ ꠔ ꠔꠣꠁꠞ ꠘꠤꠎꠞ ꠛꠣꠠꠤ ꠀꠞ ꠖꠦꠛꠔꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠞꠉꠤ, ꠔꠦ ꠔꠥꠝꠤꠅ ꠔꠣꠁꠞ ꠟꠉꠦ ꠎꠣꠅꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("RT1_16","009_1_16","RUT","1","16","16","ꠞꠥꠔꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠎꠤ ꠘꠣ ꠀꠝ꠆ꠝꠣ, ꠀꠙꠘꠦ ꠁꠟꠣ ꠝꠣꠔꠂꠘ ꠘꠣ ꠎꠣꠘꠥ, ꠀꠙꠘꠣꠞ ꠈꠞ ꠅꠁꠀ ꠞꠁꠔꠦ ꠀꠝꠣꠞꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠂꠘ ꠘꠣ ꠎꠣꠘꠥ। ꠀꠙꠘꠦ ꠎꠦꠘꠅꠃ ꠎꠣꠁꠘ ꠘꠣ ꠇꠦꠘꠦ ꠀꠝꠤꠅ ꠎꠣꠁꠝꠥ, ꠀꠙꠘꠦ ꠎꠦꠘꠅ ꠞꠁꠛꠣ ꠀꠝꠤꠅ ꠅꠘꠅ ꠞꠁꠝꠥ। ꠀꠙꠘꠣꠞ ꠎꠣꠔꠤꠃ ꠅꠁꠛ ꠀꠝꠣꠞ ꠎꠣꠔꠤ, ꠀꠙꠘꠣꠞ ꠝꠣꠛꠥꠖꠃ ꠅꠁꠛꠣ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("RT1_17","009_1_17","RUT","1","17","17","ꠎꠦ ꠎꠣꠉꠣꠔ ꠀꠙꠘꠦ ꠝꠞꠤꠎꠤꠛꠣꠄ, ꠅꠘꠅ ꠀꠝꠤꠅ ꠝꠞꠤꠎꠤꠝꠥ, ꠀꠞ ꠅꠘꠅꠃ ꠀꠝꠣꠞ ꠇꠄꠛꠞ ꠅꠁꠛ। ꠈꠣꠟꠤ ꠝꠞꠘ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥꠔꠣꠄ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠀꠙꠘꠣꠞ ꠟꠉ ꠍꠣꠠꠣꠁꠔ ꠙꠣꠞꠦ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠘꠥ ꠀꠝꠣꠞꠦ ꠉꠎꠛꠤ ꠡꠣꠡ꠆ꠔꠤ ꠖꠦꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("RT1_18","009_1_18","RUT","1","18","18","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠠꠤꠄ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠟꠣ ꠘꠣ, ꠔꠣꠁꠘ ꠛꠥꠎꠤꠟꠤꠟꠣ ꠞꠥꠔꠦ ꠔꠣꠘ ꠟꠉꠦ ꠎꠣꠁꠔ ꠇꠞꠤ ꠖꠤꠟ ꠛꠣꠘ꠆ꠖꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RT1_19","009_1_19","RUT","1","19","19","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠀꠐꠣ ꠗꠞꠟꠣ, ꠀꠐꠤ ꠀꠐꠤ ꠔꠣꠞꠣ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃꠔ ꠀꠁꠀ ꠙꠃꠍꠤꠟꠣ। ꠉꠣꠃꠔ ꠀꠁꠔꠦꠃ ꠉꠣꠃꠞ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠃꠟꠁꠡ꠆ꠔꠟ ꠟꠣꠉꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁꠀꠟ꠆ꠟꠣꠞꠦ, ꠘꠄꠅꠝꠤꠞ ꠅꠃ ꠢꠣꠟꠔ ꠅꠁꠍꠦ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("RT1_20","009_1_20","RUT","1","20","20","“ꠅꠄ ꠉ ꠡꠥꠘꠣ, ꠀꠝꠣꠞꠦ ꠀꠞ ꠘꠄꠅꠝꠤ ꠝꠣꠘꠤ, ꠡꠥꠈꠤ ꠇꠁꠀ ꠒꠣꠇꠤꠅ ꠘꠣ, ꠝꠣꠞꠥꠀ ꠝꠣꠘꠤ, ꠔꠤꠔ꠆ꠔꠣ ꠇꠁꠀ ꠒꠣꠇꠤꠅ, ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠀꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠔꠤꠔ꠆ꠔꠣ ꠛꠣꠘꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RT1_21","009_1_21","RUT","1","21","21","ꠀꠝꠤ ꠅꠜꠣꠉꠤꠘꠤ ꠇꠙꠣꠟ-ꠙꠥꠠꠣ। ꠀꠝꠣꠞꠦ ꠀꠞ ꠇꠤꠔꠣꠟ꠆ꠟꠣꠉꠤ ꠘꠄꠅꠝꠤ ꠇꠁꠀ ꠒꠣꠇꠤꠞꠣꠄ? ꠖꠦꠡ ꠕꠣꠇꠤ ꠉꠦꠍꠟꠣꠝ ꠜꠞꠣ ꠀꠔꠦ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠀꠘꠟꠣ ꠈꠣꠟꠤ ꠀꠔꠦ। ꠡ꠆ꠛꠄꠅꠋ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘꠦꠃ ꠀꠝꠣꠞ ꠜꠞꠣ ꠒꠥꠛꠤ ꠇꠞꠤꠟꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("RT1_22","009_1_22","RUT","1","22","22","ꠅꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠝꠥꠀꠛꠤ ꠞꠥꠔꠞꠦ ꠟꠁꠀ ꠘꠄꠅꠝꠤꠄ ꠝꠥꠀꠛ ꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠛꠣꠞ꠆ꠟꠤ ꠚꠡꠟ ꠇꠣꠐꠣꠞ ꠝꠃꠡꠥꠝ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RT2_1","009_2_1","RUT","2","1","3","ꠛꠣꠠꠤꠔ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠄꠇꠖꠤꠘ ꠝꠥꠀꠛꠤ ꠞꠥꠔꠦ ꠔꠣꠘ ꠢꠠꠤꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠁꠎꠤ, ꠀꠝꠤ ꠌꠣꠁꠍꠟꠣꠝ ꠛꠘ꠆ꠖꠅ ꠎꠣꠁꠔꠣꠝ, ꠀꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠔꠣꠞ ꠎꠝꠤꠘꠅ ꠟꠥꠞꠤꠔꠦ ꠖꠦꠄ, ꠔꠦ ꠟꠥꠞꠤꠟꠣꠝ ꠅꠘꠦ। ꠔꠦ ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠂꠘ?” ꠘꠄꠅꠝꠤꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠔꠥꠝꠣꠞ ꠜꠣꠟꠣ ꠟꠣꠉꠟꠦ ꠎꠣꠅ।” ꠔꠦꠃ ꠞꠥꠔ ꠟꠥꠞꠣꠔ ꠉꠦꠟꠣ। ꠛꠘ꠆ꠖꠅ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠛꠣꠞ꠆ꠟꠤ ꠖꠣꠁꠞꠣ, ꠅꠁꠟꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠝꠣꠝꠦꠟꠣ ꠅꠁꠟ, ꠞꠥꠔꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠟꠥꠞꠤꠔꠣ ꠉꠦꠟꠣ, ꠁ ꠈꠦꠔꠞ ꠝꠣꠟꠤꠇ ꠀꠍꠟꠣ ꠔꠣꠘ ꠢꠃꠞ ꠀꠟꠤ ꠝꠣꠟꠤꠇꠞ ꠇꠥꠐꠥꠝ ꠛꠥꠀꠎ। ꠄꠁꠘ ꠅꠁꠟꠣ ꠢꠤ ꠄꠟꠣꠇꠣꠞ ꠘꠣꠝꠤ-ꠖꠣꠝꠤ ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠝꠣꠘꠥꠡ। ꠞꠥꠔꠦ ꠢꠤꠘꠅ ꠇꠣꠝꠟꠣꠁꠘ꠆ꠔꠞ ꠈꠞꠦ ꠈꠞꠦ ꠟꠥꠞꠤꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RT2_4","009_2_4","RUT","2","4","4","ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠈꠦꠔꠞ ꠝꠣꠟꠤꠇ ꠛꠥꠀꠎ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃ ꠕꠣꠇꠤ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ, ꠇꠤꠔꠣ ꠛꠣ ꠔꠥꠝꠞꠣ ꠜꠣꠟꠣ ꠀꠍ ꠘꠤ?” ꠍꠣꠟꠣꠝꠞ ꠀꠟꠦꠇ ꠟꠁꠀ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ ꠍꠣꠛ, ꠜꠣꠟꠣ ꠀꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("RT2_5","009_2_5","RUT","2","5","5","ꠔꠦꠃ ꠛꠥꠀꠎꠦ ꠔꠣꠘ ꠙꠞꠗꠣꠘ ꠇꠣꠝꠟꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠛꠣ, ꠅꠃ ꠎꠦꠘ ꠟꠥꠞꠦꠞ ꠁ ꠛꠦꠐꠤꠉꠥ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("RT2_6","009_2_6","RUT","2","6","6","ꠅꠃ ꠢꠦ ꠇꠁꠟ, “ꠍꠣꠛ, ꠄꠘꠞꠦ ꠌꠤꠘꠍꠂꠘ ꠘꠣ ꠘꠤ? ꠄꠁꠘ ꠔ ꠀꠙꠘꠣꠞꠣꠞ ꠇꠥꠐꠥꠝ ꠘꠄꠅꠝꠤ ꠛꠦꠐꠤꠞ ꠙꠥꠀꠞ ꠛꠃ, ꠁ ꠛꠦꠐꠤꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤ ꠀꠍꠤꠟ ꠝꠥꠀꠛ ꠖꠦꠡꠅ। ");
INSERT INTO syls_vpl VALUES ("RT2_7","009_2_7","RUT","2","7","7","ꠛꠦꠐꠤꠄ ꠀꠁꠀ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠅꠃ ꠎꠦꠞꠣ ꠛꠣꠞ꠆ꠟꠤ ꠖꠣꠁꠞꠣ, ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠄꠞꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠟꠥꠞꠤꠔꠦ ꠖꠤꠛꠣ ꠘꠤ? ꠛꠦꠐꠤ ꠔ ꠛꠤꠀꠘ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠘꠅ ꠀꠍꠂꠘ, ꠝꠣꠎꠈꠣꠘꠅ ꠈꠣꠟꠤ ꠃꠠꠣꠞ ꠔꠟꠦ ꠕꠥꠠꠣ ꠎꠤꠞꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("RT2_8","009_2_8","RUT","2","8","8","ꠅꠃ ꠛꠥꠀꠎꠦ ꠞꠥꠔꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠁꠘ, ꠔꠥꠝꠤ ꠢꠣꠝꠦꠡꠣ ꠀꠝꠣꠞ ꠎꠝꠤꠘꠅ ꠟꠥꠞꠤꠅ, ꠀꠝꠣꠞ ꠅꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠅ, ꠛꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠎꠝꠤꠘꠅ ꠎꠣꠁꠅ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("RT2_9","009_2_9","RUT","2","9","9","ꠀꠝꠤ ꠀꠝꠣꠞ ꠇꠣꠝꠟꠣꠁꠘ꠆ꠔꠞꠦ ꠇꠁꠍꠤ, ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠍꠣꠔꠣꠁꠔ ꠘꠣꠄ, ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ ꠔꠣꠞꠣ ꠇꠥꠘꠖꠤꠘ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠖꠣꠁꠞꠣ। ꠀꠞ ꠇꠣꠝꠟꠣꠁꠘ꠆ꠔꠦ ꠈꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠙꠣꠘꠤ-ꠃꠘꠤ ꠀꠘꠍꠂꠘ, ꠙꠤꠀꠍꠦ ꠗꠞꠟꠦ ꠔꠥꠝꠤꠅ ꠅꠘ ꠕꠘꠦ ꠈꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("RT2_10","009_2_10","RUT","2","10","10","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠞꠥꠔꠦ ꠛꠥꠀꠎꠞ ꠙꠣꠅꠔ ꠗꠞꠤꠀ ꠇꠖꠝꠛꠥꠍꠤ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠀꠝꠤ ꠔ ꠄꠇ ꠛꠤꠖꠦꠡꠤ ꠛꠦꠐꠤ, ꠔꠦꠛꠃ ꠀꠙꠘꠦ ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠅꠔ ꠝꠣꠄꠀ-ꠖꠄꠀ ꠇꠞꠞꠣ?” ");
INSERT INTO syls_vpl VALUES ("RT2_11","009_2_11","RUT","2","11","11","ꠔꠦꠃ ꠛꠥꠀꠎꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤ ꠠꠣꠠꠤ ꠛꠦꠐꠤ ꠅꠁꠀꠅ ꠔꠥꠝꠣꠞ ꠢꠠꠤꠞ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠇꠞꠞꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠤ ꠢꠥꠘꠍꠤ, ꠔꠥꠝꠣꠞ ꠝꠣ-ꠛꠣꠚ ꠀꠞ ꠎꠘꠝ-ꠝꠣꠐꠤ ꠍꠣꠠꠤꠀ ꠁ ꠅꠌꠤꠘ ꠎꠣꠉꠣꠔ ꠀꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("RT2_12","009_2_12","RUT","2","12","12","ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠃꠇ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠛꠥꠖ, ꠎꠦꠘ ꠒꠣꠈꠘꠣꠞ ꠔꠟꠦ ꠀꠁꠀ ꠔꠥꠝꠤ ꠀꠡꠞꠄ ꠟꠁꠍ, ꠄꠁꠘ ꠔꠥꠝꠣꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠙꠣꠅꠘꠣ ꠢꠇ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("RT2_13","009_2_13","RUT","2","13","13","ꠅꠃ ꠞꠥꠔꠦ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠀꠙꠘꠦ ꠎꠦꠘ ꠀꠝꠣꠞꠦ ꠅꠔ ꠝꠣꠄꠀꠖꠣꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠀ ꠀꠙꠘꠣꠞ ꠁ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠡꠣꠅꠡ ꠎꠥꠉꠣꠁ ꠖꠤꠍꠂꠘ, ꠀꠝꠤ ꠔ ꠀꠙꠘꠣꠞ ꠁꠔꠣ ꠄꠇ ꠇꠣꠝꠟꠣ ꠛꠦꠐꠤꠞꠅ ꠢꠝꠣꠘꠤ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("RT2_14","009_2_14","RUT","2","14","14","ꠛꠣꠖꠦ ꠈꠣꠘꠤꠞ ꠅꠇ꠆ꠔ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠛꠥꠀꠎꠦ ꠞꠥꠔꠞꠦ ꠒꠣꠇꠖꠤ ꠀꠘꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠛꠁꠘ, ꠀꠁꠅ, ꠅꠘ ꠕꠣꠇꠤ ꠞꠥꠐꠤ ꠘꠤꠀ ꠕꠣꠟꠅ ꠜꠤꠎꠣꠁꠀ ꠈꠣꠅ।” ꠞꠥꠔ ꠀꠁꠀ ꠇꠣꠝꠟꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠉꠣꠟꠣꠔ ꠈꠣꠘꠤꠔ ꠛꠁꠟꠣ, ꠛꠁꠀ ꠢꠣꠞꠟꠦ ꠛꠥꠀꠎꠦ ꠔꠣꠘꠞꠦ ꠇꠤꠍꠥ ꠌꠤꠠꠣ-ꠝꠥꠠꠤ ꠖꠤꠟꠣ। ꠔꠦꠃ ꠞꠥꠔꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠈꠣꠁꠟꠣ, ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠎꠦꠔꠣ ꠃꠙꠞꠤꠟ ꠁꠔꠣ ꠔꠣꠘ ꠛꠦꠉꠅ ꠢꠣꠞꠣꠁꠀ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT2_15","009_2_15","RUT","2","15","16","ꠛꠣꠖꠦ ꠞꠥꠔ ꠃꠑꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠟꠥꠞꠣꠔ ꠎꠣꠁꠔꠣ ꠔꠤꠀꠞ ꠅꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠛꠥꠀꠎꠦ ꠔꠣꠘ ꠇꠣꠝꠟꠣꠁꠘ꠆ꠔꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠞꠣ ꠛꠣꠞ꠆ꠟꠤ ꠖꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠕꠥꠠꠣꠕꠥꠠꠤ ꠍꠠꠣꠁꠘ ꠕꠁꠀ ꠎꠣꠁꠅ, ꠔꠦꠃ ꠄꠁꠘ ꠟꠥꠞꠤꠟꠦ ꠅꠔꠣ ꠙꠣꠁꠛꠣ। ꠄꠁꠘ ꠇꠣꠐꠣ ꠝꠥꠁꠐ ꠕꠣꠇꠤ ꠍꠠꠣꠁꠘ ꠍꠤꠠꠤꠀ ꠘꠤꠟꠦꠅ ꠄꠘꠞꠦ ꠗꠝꠇ-ꠐꠝꠇ ꠖꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("RT2_17","009_2_17","RUT","2","17","17","ꠞꠥꠔꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠘꠅ ꠟꠥꠞꠤꠀ ꠝꠣꠠꠣ ꠖꠤꠀ ꠏꠣꠠꠤꠀ ꠍꠣꠚ ꠇꠞꠤꠀ ꠅꠘꠥꠝꠣꠘ ꠄꠇ ꠚꠥꠞꠣꠞ ꠛꠣꠞ꠆ꠟꠤ ꠟꠁꠀ ꠔꠣꠁꠘ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT2_18","009_2_18","RUT","2","18","18","ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘ ꠛꠦꠉꠞ ꠝꠍꠣ ꠛꠣꠞ ꠇꠞꠤꠀ ꠢꠠꠤꠞꠦ ꠖꠤꠟꠣ, ꠀꠞ ꠟꠥꠞꠣꠞ ꠛꠣꠞ꠆ꠟꠤꠞ ꠉꠣꠁꠐ ꠈꠥꠟꠤꠀ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT2_19","009_2_19","RUT","2","19","19","ꠛꠣꠞ꠆ꠟꠤ ꠖꠦꠈꠤꠀ ꠘꠄꠅꠝꠤꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠣꠞ ꠎꠝꠤꠘꠅ ꠟꠥꠞꠣꠔ ꠉꠦꠍꠟꠣꠄ ꠉ? ꠔꠥꠝꠣꠞꠦ ꠎꠣꠞ ꠎꠝꠤꠘꠅ ꠟꠥꠞꠤꠔꠦ ꠖꠤꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞ ꠜꠣꠟꠣ ꠇꠞꠃꠇ।” ꠔꠦꠃ ꠞꠥꠔꠦ ꠇꠁꠟꠣ, “ꠝꠣꠁꠎꠤ, ꠎꠦ ꠉꠤꠞꠡ꠆ꠔꠞ ꠎꠝꠤꠘꠅ ꠀꠝꠤ ꠟꠥꠞꠤꠍꠤ, ꠄꠘ ꠘꠣꠝ ꠅꠁꠟ ꠛꠥꠀꠎ।” ");
INSERT INTO syls_vpl VALUES ("RT2_20","009_2_20","RUT","2","20","20","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠘꠄꠅꠝꠤꠄ ꠇꠁꠟꠣ, “ꠔꠣꠝꠣꠝ ꠎꠤꠘ꠆ꠖꠣ ꠀꠞ ꠝꠥꠞ꠆ꠖꠣꠞ ꠃꠙꠞꠦ ꠢꠇ ꠁꠘꠍꠣꠚ ꠇꠞꠘꠦꠀꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠄꠞꠦ ꠞꠢꠝꠔ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠄꠁꠘ ꠔ ꠔꠥꠝꠣꠞ ꠢꠃꠞꠞ ꠇꠞꠤꠛ ꠝꠣꠘꠥꠡ। ꠀꠝꠞꠣꠞ ꠙꠞꠤꠛꠣꠞꠞꠦ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠀꠞ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠎꠦꠞꠣꠞ ꠀꠍꠦ, ꠄꠁꠘ ꠅꠁꠟꠣ ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("RT2_21","009_2_21","RUT","2","21","21","ꠞꠥꠔꠦ ꠇꠁꠟꠣ, “ꠝꠣꠁꠎꠤ, ꠄꠝꠘ ꠇꠤ ꠅꠃ ꠍꠣꠛꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠍꠂꠘ, ꠅ ꠛꠁꠘ, ꠎꠔꠖꠤꠘ ꠀꠝꠣꠞ ꠖꠣꠅꠀ-ꠇꠣꠐꠤ ꠀꠍꠦ, ꠅꠔꠖꠤꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠎꠝꠤꠘꠅ ꠀꠁꠀ ꠀꠝꠣꠞ ꠛꠣꠘ꠆ꠖꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠞꠁꠀ ꠟꠥꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("RT2_22","009_2_22","RUT","2","22","22","ꠘꠄꠅꠝꠤꠄ ꠇꠁꠟꠣ, “ꠁꠈꠣꠘ ꠔ ꠜꠣꠟꠣ ꠅꠁꠛꠞꠦ ꠝꠣꠁ, ꠔꠥꠝꠤ ꠄꠘ ꠎꠝꠤꠘꠅ ꠉꠤꠀ ꠔꠣꠘ ꠛꠣꠘ꠆ꠖꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠞꠁꠀ ꠟꠥꠞꠤꠅ। ꠛꠣꠞꠣ ꠎꠝꠤꠘꠅ ꠎꠣꠁꠅ ꠘꠣ, ꠔꠦꠃ ꠇꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠍꠣꠔꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("RT2_23","009_2_23","RUT","2","23","23","ꠛꠣꠞ꠆ꠟꠤ ꠀꠞ ꠉꠝ ꠖꠣꠅꠀ ꠎꠔꠖꠤꠘ ꠀꠍꠤꠟ ꠅꠔꠖꠤꠘꠃ ꠞꠥꠔꠦ ꠉꠤꠀ ꠛꠥꠀꠎꠞ ꠇꠣꠝꠟꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠞꠁꠀ ꠟꠥꠞꠤꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠢꠠꠤꠞ ꠟꠉꠦ ꠝꠤꠟꠤ-ꠝꠤꠡꠤ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT3_1","009_3_1","RUT","3","1","1","ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠛꠤꠛꠤ ꠘꠄꠅꠝꠤꠄ ꠞꠥꠔꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠞꠣꠝ ꠔꠥꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠡꠥꠈꠤ-ꠡꠋꠡꠣꠞꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("RT3_2","009_3_2","RUT","3","2","2","ꠔꠥꠝꠤ ꠎꠣꠞ ꠇꠣꠝꠟꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠞꠁꠀ ꠟꠥꠞꠤꠛꠣꠄ, ꠅꠃ ꠛꠥꠀꠎ ꠔ ꠄꠝꠘꠦꠃ ꠀꠝꠞꠣꠞ ꠇꠥꠐꠥꠝ। ꠀꠁꠎ ꠞꠣꠁꠔ ꠔꠣꠁꠘ ꠈꠟꠣꠔ ꠀꠁꠀ ꠛꠣꠞ꠆ꠟꠤ ꠝꠣꠠꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RT3_3","009_3_3","RUT","3","3","3","ꠔꠦ ꠔꠥꠝꠤ ꠄꠇ ꠇꠣꠝ ꠇꠞꠅ, ꠔꠥꠝꠤ ꠘꠣꠁꠀ-ꠗꠁꠀ, ꠔꠦꠟ-ꠔꠥꠟ ꠝꠣꠈꠤꠀ, ꠢꠣꠎꠤ-ꠙꠣꠠꠤ ꠔꠣꠘ ꠈꠟꠣꠔ ꠎꠣꠅꠉꠤ। ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠂꠘ ꠘꠣ ꠎꠣꠘꠥ। ");
INSERT INTO syls_vpl VALUES ("RT3_4","009_3_4","RUT","3","4","4","ꠞꠣꠁꠔꠇꠥꠞ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠛꠣꠖꠦ ꠄꠁꠘ ꠎꠦꠛꠟꠣ ꠢꠥꠔꠤꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠤ ꠄꠘ ꠛꠤꠍꠘꠣ ꠌꠤꠘꠤꠀ ꠞꠣꠈꠤꠅ। ꠛꠣꠖꠦ ꠢꠘꠅ ꠉꠤꠀ ꠔꠣꠘ ꠙꠣꠅꠞ ꠃꠙꠞꠞ ꠈꠦꠔꠣ ꠢꠞꠣꠁꠀ ꠢꠘꠅ ꠢꠥꠔꠤꠞꠁꠅ। ꠢꠥꠔꠤꠀ ꠢꠣꠞꠟꠦ ꠇꠤꠔꠣ ꠅꠁꠛ, ꠔꠣꠁꠘ ꠄꠝꠘꠦꠃ ꠇꠁꠀ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("RT3_5","009_3_5","RUT","3","5","5","ꠞꠥꠔꠦ ꠇꠁꠟꠣ, “ꠎꠤ ꠀꠁꠌ꠆ꠍꠣ, ꠀꠙꠘꠦ ꠎꠦꠟꠣ ꠇꠁꠞꠣ ꠅꠟꠣꠃ ꠇꠞꠝꠥꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("RT3_6","009_3_6","RUT","3","6","6","ꠛꠣꠖꠦ ꠡꠝꠄ ꠝꠔ ꠔꠣꠁꠘ ꠈꠟꠣꠔ ꠉꠦꠟꠣ, ꠀꠞ ꠢꠠꠤꠄ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣ ꠅꠟꠣꠃ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT3_7","009_3_7","RUT","3","7","7","ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠛꠣꠖꠦ ꠛꠥꠀꠎ ꠎꠦꠛꠟꠣ ꠈꠥꠡ ꠝꠤꠎꠣꠎꠦ ꠔꠣꠘ ꠈꠟꠣꠞ ꠃꠠꠣꠞ ꠔꠟꠦ ꠉꠤꠀ ꠢꠥꠔꠤꠟꠣ, ꠞꠥꠔꠅ ꠟꠣꠄ ꠟꠣꠄ ꠢꠘꠅ ꠉꠤꠀ ꠛꠥꠀꠎꠞ ꠙꠣꠅꠞ ꠃꠙꠞ ꠕꠘꠦ ꠈꠦꠔꠣ ꠢꠞꠣꠁꠀ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠢꠥꠔꠤꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT3_8","009_3_8","RUT","3","8","9","ꠀꠗꠣ ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠛꠥꠀꠎꠦ ꠇꠞꠐ ꠚꠤꠞꠣꠁꠀ ꠄꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠌꠝꠇꠤꠀ ꠃꠑꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠦ ꠉ?” ꠞꠥꠔꠦ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠛꠣꠘ꠆ꠖꠤ ꠞꠥꠔ, ꠀꠙꠘꠦ ꠀꠙꠘꠣꠞ ꠈꠦꠔꠣꠞ ꠔꠟꠈꠣꠘꠅ ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠄꠇꠎꠞꠣ ꠑꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠀꠝꠞꠣꠞꠦ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠞꠣ ꠇꠥꠐꠥꠝ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠀꠙꠘꠦ ꠔ ꠄꠇꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("RT3_10","009_3_10","RUT","3","10","10","ꠛꠥꠀꠎꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠛꠁꠘꠞꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠔꠥꠝꠤ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠎꠦꠟꠣ ꠢꠞꠤꠞ ꠛꠤꠡ꠆ꠛꠣꠡꠤ ꠀꠍꠟꠣꠄ, ꠔꠣꠁꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠀꠁꠎ ꠀꠞꠅ ꠛꠦꠡꠤ ꠛꠤꠡ꠆ꠛꠣꠡꠤ ꠎꠣꠁꠞ ꠇꠞꠟꠣꠄ, ꠔꠥꠝꠤ ꠔ ꠗꠘꠤ-ꠉꠞꠤꠛ ꠇꠥꠘꠥ ꠎꠥꠀꠘ ꠛꠦꠐꠣꠞ ꠟꠉꠦ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RT3_11","009_3_11","RUT","3","11","11","ꠀꠡ꠆ꠔꠣ ꠉꠣꠃꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠜꠣꠟꠣ ꠙꠣꠄ। ꠔꠥꠝꠤ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠥꠝꠤ ꠎꠦꠟꠣ ꠌꠣꠁꠞꠣꠄ, ꠀꠝꠤ ꠅꠟꠣꠃ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RT3_12","009_3_12","RUT","3","12","12","ꠅꠁꠟꠦ ꠀꠝꠣ ꠕꠘꠦ ꠀꠞꠅ ꠇꠞꠤꠛ ꠔꠥꠝꠣꠔꠣꠘꠞ ꠄꠇꠎꠘ ꠀꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("RT3_13","009_3_13","RUT","3","13","13","ꠇꠣꠁꠟ ꠛꠤꠀꠘꠇꠥ ꠛꠣꠟꠣ ꠀꠝꠤ ꠔꠣꠘ ꠟꠉꠦ ꠝꠣꠔꠤꠝꠥ, ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠘ ꠔꠦ ꠔ ꠜꠣꠟꠣ, ꠔꠣꠁꠘꠃ ꠡꠣꠖꠤ ꠇꠞꠤꠟ꠆ꠟꠣ। ꠀꠞ ꠘꠣ ꠅꠁꠟꠦ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠀꠞ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠡꠝꠎꠤꠀ ꠟꠁꠝꠥ। ꠅꠈꠘ ꠔꠥꠝꠤ ꠅꠘꠅꠃ ꠞꠣꠁꠔ ꠇꠣꠐꠣꠁꠟꠣꠅ, ꠞꠣꠁꠔꠇꠣꠟ ꠀꠞ ꠎꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("RT3_14","009_3_14","RUT","3","14","14","ꠚꠎꠞꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠞꠥꠔ ꠛꠥꠀꠎꠞ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠢꠥꠔꠤꠞꠁꠟꠣ। ꠛꠥꠀꠎꠦ ꠞꠥꠔꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠦꠘ ꠁꠘꠅ ꠀꠁꠍ, ꠁꠈꠣꠘ ꠎꠣꠘꠥ ꠇꠦꠃ ꠘꠣ ꠎꠣꠘꠦ।” ꠔꠦꠃ ꠀꠘ꠆ꠖꠣꠁꠞ ꠞꠁꠔꠦꠃ ꠞꠥꠔ ꠛꠣꠠꠤꠔ ꠎꠣꠁꠔꠣꠉꠤ ꠇꠞꠤ ꠎꠥꠁꠔ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT3_15","009_3_15","RUT","3","15","15","ꠀꠞ ꠛꠥꠀꠎꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠠꠤꠞ ꠍꠣꠝꠘꠦ ꠈꠣꠟꠤ ꠀꠔꠦ ꠇꠤꠟꠣ ꠎꠣꠁꠔꠣꠄ? ꠖꠦꠈꠤ, ꠔꠥꠝꠣꠞ ꠌꠣꠖ꠆ꠖꠞꠈꠣꠘ ꠝꠦꠟꠣꠅ।” ꠞꠥꠔꠦ ꠌꠣꠖ꠆ꠖꠞ ꠝꠦꠟꠤꠀ ꠇꠥꠘꠣꠔ ꠗꠞꠟꠣ ꠀꠞ ꠛꠥꠀꠎꠦ ꠍꠄ ꠙꠦꠐꠥ ꠛꠣꠞ꠆ꠟꠤ ꠀꠘꠤꠀ ꠌꠣꠖ꠆ꠖꠞꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠅ ꠔꠥꠟꠤꠀ ꠖꠤꠟꠣ। ꠞꠥꠔꠦ ꠅꠃ ꠉꠣꠁꠐ ꠟꠁꠀ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RT3_16","009_3_16","RUT","3","16","16","ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘ ꠢꠠꠤꠄ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠉ ꠝꠣꠁ, ꠈꠛꠞ ꠇꠤꠔꠣ?” ꠔꠦꠃ ꠛꠥꠀꠎꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠁꠍꠂꠘ ꠅꠔꠣ ꠔꠣꠘ ꠢꠠꠤꠞ ꠉꠦꠍꠦ ꠈꠥꠟꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RT3_17","009_3_17","RUT","3","17","17","ꠟꠉꠦ ꠄꠅꠈꠣꠘꠅ ꠇꠁꠟꠣ, “ꠛꠥꠀꠎꠦ ꠇꠁꠍꠂꠘ ꠔꠥꠝꠤ ꠢꠠꠤꠞ ꠉꠦꠍꠦ ꠈꠣꠟꠤ ꠀꠔꠦ ꠇꠤꠟꠣ ꠎꠣꠁꠔꠣꠄ, ꠇꠁꠀ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠍꠄ ꠙꠦꠐꠥ ꠛꠣꠞ꠆ꠟꠤꠅ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("RT3_18","009_3_18","RUT","3","18","18","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠠꠤꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠤꠔꠣ ꠅꠄ ꠖꠦꠈꠅ, ꠁ ꠝꠣꠘꠡꠦ ꠀꠁꠎꠇꠥꠞ ꠝꠣꠎꠦꠃ ꠄꠞ ꠄꠇ ꠉꠣꠟꠣ ꠘꠣ ꠟꠣꠉꠣꠁꠀ ꠖꠝ ꠟꠁꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("RT4_1","009_4_1","RUT","4","1","1","ꠛꠤꠀꠘꠦ ꠃꠑꠤꠀ ꠛꠥꠀꠎ ꠉꠣꠃꠞ ꠙꠣꠁꠘ꠆ꠌꠣꠁꠔꠤ ꠛꠂꠑꠇ ꠈꠣꠘꠣꠔ ꠀꠁꠀ ꠛꠁꠞꠁꠟꠣ, ꠝꠘꠦ ꠝꠘꠦ, ꠢꠃ ꠇꠥꠐꠥꠝꠞ ꠛꠣꠞ ꠌꠣꠁꠞꠣ ꠎꠣꠞ ꠇꠕꠣ ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ। ꠀꠈꠔꠣꠃ ꠖꠦꠈꠟꠣ, ꠢꠃ ꠝꠣꠘꠥꠡ ꠙꠕꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ, ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠄꠘꠞꠦ ꠒꠣꠇ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠜꠣꠁ ꠍꠣꠛ, ꠅꠛꠣꠄ ꠕꠥꠠꠣ ꠢꠥꠘꠤ ꠎꠣꠅ।” ꠔꠦꠃ ꠢꠦꠁꠘ ꠀꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RT4_2","009_4_2","RUT","4","2","2","ꠀꠞ ꠛꠥꠀꠎꠦ ꠉꠣꠃꠞ ꠛꠥꠎꠖꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠖꠡ ꠎꠘꠞꠦ ꠀꠘꠤꠀ ꠛꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT4_3","009_4_3","RUT","4","3","3","ꠛꠁꠀ ꠢꠣꠞꠟꠦ ꠛꠥꠀꠎꠦ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠢꠃ ꠎꠘꠞꠦ ꠇꠁꠟꠣ, “ꠘꠄꠅꠝꠤ ꠛꠦꠐꠤꠄ ꠝꠥꠀꠛ ꠖꠦꠡ ꠕꠣꠇꠤ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠇꠥꠐꠥꠝ ꠀꠟꠤ ꠝꠣꠟꠤꠇꠞ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠅꠔꠣ ꠛꠦꠌꠤꠟꠣꠁꠔꠣ ꠌꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RT4_4","009_4_4","RUT","4","4","4","ꠀꠝꠤ ꠢꠇꠟꠞꠦ ꠄꠇꠟꠉꠦ ꠖꠟꠣ ꠇꠞꠍꠤ, ꠔꠦ ꠔꠥꠝꠤ ꠅꠁꠟꠣꠄ ꠔꠣꠘ ꠇꠞꠤꠛ ꠝꠣꠘꠥꠡ, ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠀꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠅꠈꠘꠣꠁꠘꠔꠣ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠟꠁꠟꠣꠅ। ꠀꠞ ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠘꠣ ꠘꠦꠅ, ꠔꠦ ꠀꠝꠣꠞꠦ ꠇꠅ, ꠀꠝꠤ ꠘꠤꠝꠥ। ꠁ ꠙꠞꠤꠛꠣꠞꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤꠃ ꠛꠠ ꠇꠞꠤꠛ, ꠄꠞꠛꠣꠖꠦ ꠅꠁꠟꠣꠝ ꠀꠝꠤ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠦꠁꠘ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠀꠝꠤ ꠟꠁꠝꠥꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("RT4_5","009_4_5","RUT","4","5","5","ꠔꠦꠃ ꠛꠥꠀꠎꠦ ꠃꠑꠤꠀ ꠇꠁꠟꠣ, “ꠔꠦ ꠔꠥꠝꠤ ꠀꠞꠅ ꠄꠇꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠔꠦ ꠅꠁꠛ, ꠔꠥꠝꠤ ꠘꠄꠅꠝꠤ ꠛꠦꠐꠤꠞ ꠎꠝꠤꠘꠞ ꠟꠉꠦ ꠇꠞꠤ ꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠈꠣꠘ ꠇꠣꠁꠝ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠞ ꠠꠣꠠꠤ ꠛꠃ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠞꠥꠔꠞꠦꠅ ꠡꠣꠖꠤ ꠇꠞꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("RT4_6","009_4_6","RUT","4","6","6","ꠔꠦꠃ ꠢꠦꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠘꠣ, ꠔꠦ ꠀꠝꠤ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ। ꠀꠞꠘꠣꠄ ꠀꠝꠣꠞ ꠘꠤꠎꠞꠔꠣ ꠟꠁꠀꠃ ꠜꠦꠎꠣꠟ ꠟꠣꠉꠤꠎꠤꠛ। ꠀꠞ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠙꠣꠞꠤꠀꠞ ꠘꠣ, ꠔꠦ ꠀꠙꠘꠦꠃ ꠁꠔꠣ ꠉꠍꠤꠟꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("RT4_7","009_4_7","RUT","4","7","8","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠢꠤ ꠀꠝꠟꠞ ꠡꠞꠤꠅꠔꠞ ꠀꠁꠘ, ꠀꠞ ꠁꠍꠞꠣꠁꠟ ꠡꠝꠣꠎꠞ ꠇꠥꠐꠝꠞ ꠎꠣꠉꠣ-ꠎꠝꠤꠘ ꠈꠞꠤꠖ-ꠛꠤꠇꠤꠞ ꠞꠦꠅꠀꠎ ꠝꠣꠚꠤꠇ ꠢꠦꠁꠘ ꠔꠣꠘ ꠙꠣꠅꠞ ꠎꠥꠔꠣ ꠈꠥꠟꠤꠀ ꠛꠥꠀꠎꠞꠦ ꠖꠤꠟꠣꠁꠟꠣ, ꠀꠞ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦꠃ ꠁꠔꠣ ꠟꠁꠟꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("RT4_9","009_4_9","RUT","4","9","9","ꠔꠦꠃ ꠛꠥꠀꠎꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠤ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠤꠀ ꠇꠁꠀꠞ, ꠀꠝꠤ ꠘꠄꠅꠝꠤ ꠛꠦꠐꠤꠞ ꠉꠦꠍ ꠕꠘꠦ ꠀꠟꠤ ꠝꠣꠟꠤꠇꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠀꠞ ꠔꠣꠘ ꠖꠥꠁ ꠙꠥꠀ ꠝꠢꠟꠥꠘ ꠀꠞ ꠇꠤꠟꠤꠅꠘꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠅ ꠟꠁꠟꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RT4_10","009_4_10","RUT","4","10","10","ꠀꠞ ꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠘꠣꠝ ꠎꠤꠘ꠆ꠖꠣ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠀꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠝꠢꠟꠥꠘꠞ ꠠꠣꠠꠤ ꠛꠃ ꠝꠥꠀꠛ ꠖꠦꠡꠞ ꠞꠥꠔꠞꠦꠅ ꠇꠛꠥꠟ ꠇꠞꠤꠟ꠆ꠟꠣꠝ, ꠎꠣꠔꠦ ꠁ ꠉꠣꠃ ꠀꠞ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠣꠎꠦ ꠝꠞꠣꠞ ꠘꠣꠝꠈꠣꠘ ꠇꠣꠁꠝ ꠞꠄ। ꠀꠁꠎ ꠀꠙꠘꠣꠞꠣ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠞꠁꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("RT4_11","009_4_11","RUT","4","11","11","ꠔꠦꠃ ꠝꠎꠟꠤꠍꠞ ꠢꠇꠟꠦ ꠇꠁꠟꠣ, “ꠅꠄ, ꠀꠝꠞꠣ ꠁꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠞꠁꠟꠣꠝ।” ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠔꠣꠞꠣ ꠖꠥꠀ ꠇꠞꠟꠣ, “ꠅꠃ ꠎꠦ ꠇꠁꠘꠣꠞꠦ ꠀꠙꠘꠦ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠝꠣꠛꠥꠖꠦ ꠁꠀꠇꠥꠛ ꠘꠛꠤꠞ ꠖꠥꠁ ꠛꠤꠛꠤ ꠞꠣꠢꠦꠟꠣ ꠀꠞ ꠟꠦꠀ, ꠎꠦ ꠖꠥꠁꠎꠘꠦ ꠀꠡ꠆ꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠍꠦ, ꠄꠞꠣꠞ ꠟꠣꠈꠣꠘꠃ ꠁ ꠇꠁꠘꠣꠞꠦ ꠃꠎꠤꠟꠣ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠀꠡ꠆ꠔꠣ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃꠔ ꠀꠙꠘꠣꠞ ꠡꠥꠘꠣꠝ ꠛꠣꠠꠃꠇ, ꠁꠚ꠆ꠞꠣꠕꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠙꠘꠣꠞꠦ ꠗꠘꠤ-ꠍꠣꠝꠘꠤ ꠛꠣꠘꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("RT4_12","009_4_12","RUT","4","12","12","ꠞꠥꠔꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠙꠘꠣꠞꠦ ꠎꠔ ꠀꠅꠟꠣꠖ ꠖꠤꠛꠣ, ꠄꠞꠣ ꠎꠣꠘꠥ ꠔꠣꠝꠣꠞ ꠀꠞ ꠄꠢꠥꠖꠣꠞ ꠙꠥꠔ ꠚꠤꠞꠥꠎꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("RT4_13","009_4_13","RUT","4","13","13","ꠛꠥꠀꠎꠦ ꠛꠤꠛꠤ ꠞꠥꠔꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠤꠀ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠟꠁꠀ ꠉꠦꠟꠣ, ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠊꠞ-ꠡꠋꠡꠣꠞ ꠇꠞꠟꠣ, ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠞꠢꠝꠔꠦ ꠔꠣꠞꠣꠞ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RT4_14","009_4_14","RUT","4","14","14","ꠔꠦꠃ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠖꠦꠈꠤꠀ ꠘꠄꠅꠝꠤꠞꠦ ꠇꠁꠟꠣ, “ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞꠦ ꠉ ꠡꠥꠘꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠁꠎ ꠀꠎꠣꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇ ꠘꠄꠀ ꠎꠣꠝꠣꠁ ꠖꠤꠍꠂꠘ। ꠀꠡ꠆ꠔꠣ ꠁꠍꠞꠣꠁꠟ ꠖꠦꠡ ꠎꠥꠠꠤ ꠄꠘ ꠡꠥꠘꠣꠝ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("RT4_15","009_4_15","RUT","4","15","15","ꠄꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠛꠥꠠꠣ ꠇꠣꠟꠅ ꠚꠥꠞꠚꠥꠞꠣ ꠇꠞꠤ ꠔꠥꠟꠃꠇ꠆ꠇꠣ, ꠛꠥꠠꠤꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠔꠥꠝꠣꠞ ꠙꠥꠔꠞ ꠅꠃ ꠛꠃ ꠔ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠔ ꠙꠥꠀ ꠕꠣꠇꠤꠅ ꠖꠣꠝꠤ, ꠔꠣꠁ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠅꠃ ꠛꠃꠞ ꠙꠦꠐ ꠕꠘꠦꠃ ꠁ ꠀꠅꠟꠣꠖꠞ ꠎꠘꠝ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RT4_16","009_4_16","RUT","4","16","16","ꠔꠦꠃ ꠛꠤꠛꠤ ꠘꠄꠅꠝꠤꠄ ꠁ ꠘꠣꠔꠤꠞꠦ ꠃꠞꠅ ꠟꠁꠀ ꠔꠣꠞ ꠎꠄ-ꠎꠔꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RT4_17","009_4_17","RUT","4","17","17","ꠀꠞ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠒꠋ ꠇꠞꠤ ꠇꠁꠔꠞꠣ, “ꠅꠈꠘ ꠘꠄꠅꠝꠤꠄ ꠄꠇ ꠘꠄꠀ ꠢꠣꠁ ꠙꠣꠁꠍꠦ।” ꠇꠁꠀ ꠔꠣꠞꠣ ꠁ ꠉꠦꠖꠣ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠃꠛꠣꠄꠖ। ꠃꠛꠣꠄꠖꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠁꠀꠍ, ꠀꠞ ꠁꠀꠍꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠢꠎꠞꠔ ꠖꠣꠃꠖ। ");
INSERT INTO syls_vpl VALUES ("RT4_18","009_4_18","RUT","4","18","18","ꠅꠃ ꠅꠁꠟ ꠁꠀꠇꠥꠛꠞ ꠘꠣꠔꠤ ꠚꠤꠞꠥꠎꠞ ꠈꠣꠘ꠆ꠖꠣꠘ-ꠘꠣꠝꠣ। ꠚꠤꠞꠥꠎꠞ ꠙꠥꠀꠞ ꠘꠣꠝ ꠢꠣꠍꠤꠞ, ");
INSERT INTO syls_vpl VALUES ("RT4_19","009_4_19","RUT","4","19","19","ꠢꠣꠍꠤꠞꠞ ꠙꠥꠀ ꠞꠣꠄꠀꠝ, ꠞꠣꠄꠀꠝꠞ ꠙꠥꠀ ꠀꠝꠤꠘꠣꠖꠣꠛ, ");
INSERT INTO syls_vpl VALUES ("RT4_20","009_4_20","RUT","4","20","20","ꠀꠝꠤꠘꠣꠖꠣꠛꠞ ꠙꠥꠀ ꠘꠣꠢꠤꠡ, ꠘꠣꠢꠤꠡꠞ ꠙꠥꠀ ꠍꠦꠟꠤꠝ, ");
INSERT INTO syls_vpl VALUES ("RT4_21","009_4_21","RUT","4","21","21","ꠍꠦꠟꠤꠝꠞ ꠙꠥꠀ ꠛꠥꠀꠎ, ꠛꠥꠀꠎꠞ ꠙꠥꠀ ꠃꠛꠣꠄꠖ, ");
INSERT INTO syls_vpl VALUES ("RT4_22","009_4_22","RUT","4","22","22","ꠃꠛꠣꠄꠖꠞ ꠙꠥꠀ ꠁꠀꠍ, ꠁꠀꠍꠞ ꠙꠥꠀ ꠢꠎꠞꠔ ꠖꠣꠃꠖ॥");
INSERT INTO syls_vpl VALUES ("PS1_1","020_1_1","PSA","1","1","1","ꠡꠥꠈꠤ ꠢꠃ ꠎꠘ, ꠘꠣꠚꠞꠝꠣꠘꠞ ꠍꠣꠟ꠆ꠟꠣꠄ ꠎꠦ ꠌꠟꠦ ꠘꠣ, ꠙꠣꠙꠤꠞ ꠙꠕꠅ ꠎꠦ ꠃꠛꠣꠄ ꠘꠣ, ꠝꠡꠇꠞꠣ ꠇꠞꠞꠣꠞ ꠀꠒ꠆ꠒꠣꠔ ꠛꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS1_2","020_1_2","PSA","1","2","2","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠦꠅꠀ ꠢꠦꠖꠣꠄꠅꠔꠃ ꠔꠣꠞ ꠈꠥꠡꠤ, ꠁ ꠢꠦꠖꠣꠄꠅꠔꠞꠦ ꠗꠤꠀꠘ ꠇꠞꠦ ꠢꠦ ꠖꠤꠘ-ꠞꠣꠁꠔ ꠗꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS1_3","020_1_3","PSA","1","3","3","ꠔꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠔ ꠙꠣꠘꠤꠞ ꠚꠥꠔꠞ ꠗꠣꠞꠞ ꠉꠣꠍꠞ ꠟꠣꠈꠣꠘ, ꠎꠦ ꠉꠣꠍꠦ ꠡꠑꠤꠇ ꠡꠝꠄꠄ ꠚꠟ ꠗꠞꠦ, ꠈꠞꠣꠞ ꠖꠤꠘꠅ ꠔꠣꠞ ꠙꠣꠔꠣ ꠢꠥꠇꠣꠄ ꠘꠣ, ꠢꠦ ꠎꠦꠔꠣꠔꠃ ꠀꠔ ꠖꠦꠄ, ꠅꠔꠣꠔꠃ ꠟꠣꠜꠛꠣꠘ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("PS1_4","020_1_4","PSA","1","4","4","ꠅꠁꠟꠦ ꠈꠛꠤꠍ-ꠛꠎ꠆ꠎꠣꠔꠞ ꠌꠟꠣ ꠔ ꠅꠟꠣ ꠘꠣꠄ, ꠁꠔꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠗꠣꠘꠞ ꠍꠥꠍꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠔꠣꠡꠦ ꠃꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("PS1_5","020_1_5","PSA","1","5","5","ꠢꠣꠡꠞꠞ ꠖꠤꠘ ꠃꠛꠣꠁꠔ ꠔꠣꠞꠣꠞ ꠅꠟꠣ ꠡꠣꠅꠡ ꠘꠣꠁ, ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠞ ꠝꠎꠟꠤꠍꠅ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠘꠣꠁ ꠇꠥꠘꠥ ꠑꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS1_6","020_1_6","PSA","1","6","6","ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘ꠆ꠖꠣꠞ ꠌꠟꠣ-ꠚꠤꠞꠣꠞ ꠙꠕꠅ ꠝꠣꠛꠥꠖꠦ ꠘꠎꠞ ꠞꠣꠈꠂꠘ, ꠅꠁꠟꠦ ꠈꠛꠤꠍ-ꠛꠎ꠆ꠎꠣꠔꠞ ꠙꠕꠅ ꠀꠍꠦ ꠡꠞ꠆ꠛꠘꠣꠡ॥ ");
INSERT INTO syls_vpl VALUES ("PS2_1","020_2_1","PSA","2","1","1","ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠄ ꠇꠦꠘꠦ ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠞꠣ, ꠇꠤꠅꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠛꠦꠢꠥꠖꠣ ꠚꠘ꠆ꠖꠤ ꠇꠞꠦꠞ? ");
INSERT INTO syls_vpl VALUES ("PS2_2","020_2_2","PSA","2","2","2","ꠎꠉꠔꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟ ꠛꠤꠉꠠꠤ ꠉꠦꠟ, ꠞꠣꠎꠣ ꠅꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠟ, ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠞ ꠔꠣꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ। ");
INSERT INTO syls_vpl VALUES ("PS2_3","020_2_3","PSA","2","3","3","ꠄꠞꠣ ꠖꠟꠣ ꠅꠁꠀ ꠇꠁꠟ, ꠀꠅ, ꠍꠤꠠꠤꠀ ꠚꠣꠟꠣꠁ ꠔꠣꠞꠣꠞ ꠒꠣꠘ꠆ꠒꠣ-ꠛꠦꠠꠤ, ꠔꠣꠞꠣꠞ ꠛꠣꠘ꠆ꠖꠘ ꠈꠥꠟꠤꠀ ꠡ꠆ꠛꠣꠗꠤꠘ ꠛꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS2_4","020_2_4","PSA","2","4","4","ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠞ ꠇꠥꠞꠍꠤꠔ ꠛꠁꠀ ꠝꠣꠛꠥꠖꠦ ꠀꠡꠂꠘ, ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠟꠁꠀ ꠝꠡꠇꠞꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS2_5","020_2_5","PSA","2","5","5","ꠔꠣꠘ ꠉꠞꠝ ꠖꠦꠈꠣꠁꠀ ꠛꠦꠚꠣꠘꠣ ꠟꠣꠉꠣꠁꠛꠣ, ꠀꠞ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠀ ꠅꠔꠣꠞꠦ ꠇꠁꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("PS2_6","020_2_6","PSA","2","6","6","ꠀꠝꠤ ꠡ꠆ꠛꠄꠅꠋ ꠀꠝꠣꠞ ꠛꠣꠖꠡꠣꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠤ, ꠀꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠍꠤꠅꠘ ꠙꠣꠠꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS2_7","020_2_7","PSA","2","7","7","ꠀꠞ ꠢꠃ ꠛꠣꠖꠡꠣꠄ ꠇꠁꠞꠣ, ꠀꠝꠤ ꠈꠣꠟꠤ ꠝꠣꠛꠥꠖꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠎꠣꠘꠣꠁ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠇꠁꠍꠂꠘ, ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞ ꠙꠥꠔ, ꠀꠁꠎꠃ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PS2_8","020_2_8","PSA","2","8","8","ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠌꠣꠅ, ꠌꠣꠁꠟꠦ ꠎꠉꠔꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤ ꠔꠥꠝꠣꠞꠃ ꠅꠁꠛ, ꠖꠥꠘꠤꠀꠞ ꠢꠦꠡ ꠝꠣꠕꠣꠞ ꠖꠈꠟꠅ ꠙꠣꠁꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("PS2_9","020_2_9","PSA","2","9","9","ꠔꠥꠝꠤ ꠟꠥꠀꠞ ꠟꠣꠑꠤ ꠖꠤꠀ ꠁꠔꠣꠞꠦ ꠜꠣꠋꠉꠤꠛꠣꠄ, ꠝꠣꠐꠤꠞ ꠙꠣꠔꠤꠟꠞ ꠟꠣꠈꠣꠘ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS2_10","020_2_10","PSA","2","10","10","ꠅ ꠞꠣꠎꠣ ꠅꠇꠟ, ꠡꠑꠤꠇ ꠀꠈꠟ ꠈꠣꠐꠣꠅ, ꠎꠉꠔꠞ ꠡꠣꠡꠇ ꠅꠇꠟ, ꠢꠥꠡꠤꠀꠞ ꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("PS2_11","020_2_11","PSA","2","11","11","ꠖꠤꠟꠞ ꠒꠞ-ꠈꠚꠦ ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠅ, ꠇꠣꠙꠤ ꠇꠣꠙꠤ ");
INSERT INTO syls_vpl VALUES ("PS2_12","020_2_12","PSA","2","12","12","ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠇꠖꠝꠅ ꠌꠥꠝꠣ ꠖꠦꠅ, ꠔꠣꠁꠘ ꠔ ꠌꠈꠥꠞ ꠙꠟꠇꠦ ꠉꠥꠍꠣꠄ ꠎꠟꠤꠀ ꠃꠑꠂꠘ, ꠉꠥꠍꠣꠄ ꠔꠣꠘ ꠉꠎꠛ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠦ, ꠔꠥꠝꠞꠣ ꠝꠣꠎꠙꠕꠅ ꠀꠈꠔꠣꠃ ꠛꠤꠘꠣꠡ ꠅꠁꠛꠣꠄ। ꠔꠣꠞꠣꠃ ꠔ ꠛꠠ ꠇꠙꠣꠟꠤ, ꠎꠦꠞꠣ ꠔꠣꠘ ꠍꠣꠄꠀꠔ ꠀꠡꠞꠄ ꠟꠂꠘ॥ ");
INSERT INTO syls_vpl VALUES ("PS3_1","020_3_1","PSA","3","1","1","ꠀꠙꠘ ꠙꠥꠀ ꠀꠛꠍꠣꠟꠝꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠛꠣꠞ ꠇꠣꠟꠅ ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠙꠞꠤꠝꠣꠘ ꠇꠔ ꠛꠣꠠꠤꠉꠦꠍꠦ, ꠖꠦꠈꠞꠣ ꠘꠤ, ꠇꠔ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("PS3_2","020_3_2","PSA","3","2","2","ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠔ ꠎꠘꠦ ꠝꠣꠔꠤꠞꠣ, ꠇꠁꠞꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠙꠕ ꠘꠣꠁ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS3_3","020_3_3","PSA","3","3","3","ꠅꠁꠟꠦ ꠅ ꠝꠣꠛꠥꠖ, ꠈꠞꠞ ꠖꠥꠡꠝꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠞꠁꠇ꠆ꠇꠣꠇꠣꠞꠤ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠡꠣꠘ-ꠛꠠꠣꠁ, ꠛꠤꠙꠖꠞ ꠝꠣꠎꠦ ꠀꠝꠣꠞꠦ ꠡꠣꠅꠡ ꠖꠤꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS3_4","020_3_4","PSA","3","4","4","ꠀꠝꠤ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠝꠣꠛꠥꠖꠞꠦ ꠒꠣꠇꠤ, ꠘꠤꠎꠞ ꠙꠛꠤꠔ꠆ꠞ ꠙꠣꠠꠅ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠀꠞꠎꠤ ꠢꠥꠘꠂꠘ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS3_5","020_3_5","PSA","3","5","5","ꠀꠝꠤ ꠢꠥꠔꠤꠟꠣꠝ, ꠢꠥꠔꠤꠀ ꠊꠥꠝꠣꠁꠟꠣꠝ, ꠛꠣꠖꠦ ꠢꠎꠣꠉꠅ ꠅꠁꠟꠣꠝ, ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠦꠃ ꠀꠝꠣꠞꠦ ꠔꠣꠘ ꠇꠥꠟꠅ ꠑꠣꠁ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS3_6","020_3_6","PSA","3","6","6","ꠀꠝꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠢꠣꠎꠣꠞꠦ ꠢꠣꠎꠣꠞ ꠖꠥꠡꠝꠘꠦ ꠛꠦꠞꠤꠀ ꠃꠛꠣꠁ ꠞꠁꠍꠦ, ꠃꠛꠣꠁꠟꠦꠅ ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠒꠞꠣꠁ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS3_7","020_3_7","PSA","3","7","7","ꠅ ꠝꠣꠛꠥꠖ, ꠎꠟꠖꠤ ꠇꠞꠅ! ꠅ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅ! ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞ ꠢꠇ꠆ꠇꠟ ꠖꠥꠡꠝꠘꠞ ꠝꠥꠈꠅ ꠊꠥꠡꠤ ꠝꠣꠞꠛꠣꠄ, ꠛꠎ꠆ꠎꠣꠔ ꠅꠇꠟꠞ ꠖꠣꠔ ꠜꠣꠋꠉꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS3_8","020_3_8","PSA","3","8","8","ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤ ꠔ ꠝꠣꠛꠥꠖꠞꠃ ꠇꠣꠝ, ꠀꠙꠘ ꠙ꠆ꠞꠎꠣꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠣꠞ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠎꠣꠞꠤ ꠞꠃꠇ॥ (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS4_1","020_4_1","PSA","4","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠔꠣꠞꠀꠟꠣ ꠛꠣꠎꠘꠣꠖꠤ ꠉꠣꠁꠔꠦ ꠅꠁꠛ। ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠒꠣꠇꠅ ꠇꠣꠘ ꠖꠤꠅ, ꠀꠝꠣꠞꠦ ꠘꠤꠞ꠆ꠖꠥꠡ ꠇꠁꠀ ꠔꠥꠝꠤ ꠔ ꠎꠣꠁꠞ ꠇꠞꠍ। ꠝꠍꠤꠛꠔꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠎꠣꠘꠅ ꠀꠞꠣꠝ ꠖꠤꠍ, ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS4_2","020_4_2","PSA","4","2","2","ꠅ ꠝꠣꠘꠥꠡ ꠅꠇꠟ, ꠀꠝꠣꠞ ꠁꠎ꠆ꠎꠔꠞꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠇꠔꠖꠤꠘ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠔꠣꠄ, ꠇꠔꠖꠤꠘ ꠛꠦꠇꠣꠝꠣ ꠝꠣꠔꠞ ꠝꠣꠄꠀꠔ ꠞꠁꠔꠣꠄ, ꠝꠤꠍꠣ ꠝꠣꠔꠞ ꠈꠞꠦ ꠈꠞꠦ ꠊꠥꠞꠔꠣꠄ? (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS4_3","020_4_3","PSA","4","3","3","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠀꠟꠉ ꠇꠞꠍꠂꠘ, ꠔꠦ ꠀꠝꠤ ꠒꠣꠇꠟꠦꠃ ꠔꠣꠁꠘ ꠢꠥꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS4_4","020_4_4","PSA","4","4","4","ꠔꠥꠝꠞꠣꠞ ꠞꠣꠉ-ꠉꠥꠍꠣꠞ ꠡꠝꠄ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠛꠤꠍꠘꠣꠔ ꠢꠥꠔꠤꠀ ꠖꠤꠟ ꠖꠤ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠅ, ꠀꠞ ꠘꠤꠞꠣꠁ ꠕꠣꠇꠅ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS4_5","020_4_5","PSA","4","5","5","ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠅ, ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠜꠞꠡꠣ ꠞꠣꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("PS4_6","020_4_6","PSA","4","6","6","ꠛꠃꠔ ꠎꠘꠦ ꠇꠄ, “ꠀꠝꠞꠣꠞꠦ ꠇꠦꠉꠤꠄ ꠜꠣꠟꠣꠁꠞ ꠙꠕ ꠖꠦꠈꠣꠁꠛ?” ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠝꠥꠈꠞ ꠘꠥꠞꠞ ꠖꠤꠖꠣꠞ ꠈꠣꠘ ꠀꠝꠞꠣꠞ ꠘꠍꠤꠛ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PS4_7","020_4_7","PSA","4","7","7","ꠛꠦꠡ ꠇꠞꠤ ꠚꠄ-ꠚꠡꠟ ꠙꠣꠁꠀ ꠔꠣꠞꠣꠞ ꠎꠔ ꠚꠥꠞ꠆ꠔꠤ ꠎꠥꠉꠣꠄ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠛꠦꠡꠤ ꠚꠥꠞ꠆ꠔꠤ ꠔ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠖꠤꠟꠅ ꠖꠤꠍ। ");
INSERT INTO syls_vpl VALUES ("PS4_8","020_4_8","PSA","4","8","8","ꠀꠝꠤ ꠔ ꠡꠣꠄ-ꠡꠣꠘ꠆ꠔꠤ ꠀꠞ ꠀꠞꠣꠝꠦ ꠊꠥꠝꠣꠁ, ꠅ ꠝꠣꠛꠥꠖ, ꠈꠣꠟꠤ ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞꠦ ꠛꠡꠔ ꠇꠞꠣꠅ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS5_1","020_5_1","PSA","5","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠛꠣꠡꠤꠞ ꠡꠥꠞꠦ। ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠚꠞꠤꠀꠖ ꠇꠛꠥꠟ ꠇꠞꠅ, ꠖꠤꠟꠞ ꠇꠣꠘ꠆ꠖꠘ ꠀꠝꠣꠞ ꠔꠥꠝꠣꠞ ꠇꠣꠘꠦ ꠢꠥꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("PS5_2","020_5_2","PSA","5","2","2","ꠅ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠛꠣꠖꠡꠣ ꠔꠥꠝꠤ, ꠀꠝꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠅ ꠔꠥꠝꠤ ꠖꠄꠀ ꠇꠞꠤ, ꠖꠥꠀ-ꠝꠤꠘꠔꠤ ꠇꠞꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦꠃ ꠈꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("PS5_3","020_5_3","PSA","5","3","3","ꠔꠥꠝꠤ ꠙꠞꠔꠤ ꠖꠤꠘ ꠚꠎꠞꠦ ꠀꠝꠣꠞ ꠛꠥꠟꠤ ꠔ ꠢꠥꠘꠅ, ꠖꠤꠟꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠢꠣꠎꠣꠁ ꠞꠣꠈꠤ ꠔꠥꠝꠣꠞ ꠖꠤꠖꠣꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS5_4","020_5_4","PSA","5","4","4","ꠔꠥꠝꠤ ꠔ ꠁꠟꠣ ꠀꠟ꠆ꠟꠣ ꠘꠣꠄ ꠈꠣꠞꠣꠙꠤ ꠎꠣꠞ ꠙꠍꠘ꠆ꠖ, ꠔꠥꠝꠣꠞ ꠝꠦꠝꠣꠘ ꠅꠁꠔ ꠘꠣꠄ ꠇꠥꠘꠥ ꠙꠣꠙꠤ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("PS5_5","020_5_5","PSA","5","5","5","ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠅꠞꠣꠞ ꠑꠣꠁ ꠘꠣꠁ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ, ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠔꠥꠝꠤ ꠊꠤꠘ꠆ꠘꠣ ꠇꠞꠅ ꠘꠤꠎꠦ। ");
INSERT INTO syls_vpl VALUES ("PS5_6","020_5_6","PSA","5","6","6","ꠝꠤꠍꠣ ꠇꠕꠣ ꠝꠣꠔꠞꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠄ ꠛꠤꠘꠣꠡ ꠇꠞꠅ ꠔꠥꠝꠤ, ꠝꠣꠛꠥꠖꠦ ꠔ ꠊꠤꠘ꠆ꠘꠣꠁꠘ ꠛꠦꠡꠤ ꠈꠥꠘ-ꠈꠣꠞꠣꠙꠤ ꠍꠟ-ꠌꠔꠥꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS5_7","020_5_7","PSA","5","7","7","ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀꠄ ꠔꠥꠝꠣꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠝꠥ ꠀꠝꠤ, ꠘꠔ ꠅꠁꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠝꠥ ꠔꠥꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠊꠞ ꠝꠥꠈꠤ। ");
INSERT INTO syls_vpl VALUES ("PS5_8","020_5_8","PSA","5","8","8","ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠔ ꠖꠥꠡꠝꠘꠦ ꠜꠞꠣ, ꠔꠥꠝꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠙꠕꠦ ꠝꠞꠦ ꠘꠦꠅ ꠌꠣꠟꠣꠁꠀ, ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠣꠞ ꠙꠕ ꠇꠞꠅ ꠍꠢꠤ-ꠡꠥꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("PS5_9","020_5_9","PSA","5","9","9","ꠔꠣꠞꠣꠞ ꠝꠥꠈꠞ ꠇꠥꠘꠥ ꠇꠕꠣꠃ ꠄꠇꠤꠘꠞ ꠎꠥꠇꠣ ꠘꠣꠄ, ꠔꠣꠞꠣꠞ ꠖꠤꠟ-ꠝꠘ ꠜꠞꠣ ꠈꠣꠟꠤ ꠛꠤꠘꠣꠡꠞ ꠌꠤꠘ꠆ꠔꠣꠄ, ꠈꠥꠟꠣ ꠇꠄꠛꠞꠞ ꠙꠌꠣ ꠟꠣꠡꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞ ꠉꠟꠣ, ꠚꠣꠝ-ꠙꠐ꠆ꠐꠤ ꠝꠣꠞꠣꠞ ꠃꠡ꠆ꠔꠣꠖ ꠔ ꠔꠣꠞꠣꠞ ꠎꠤꠚꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS5_10","020_5_10","PSA","5","10","10","ꠅ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠤ ꠁꠔꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠅ, ꠔꠣꠞꠣꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠅꠃꠇ ꠔꠣꠞꠣꠞ ꠙꠣꠔꠣꠁꠟ ꠚꠣꠘ꠆ꠖꠅ, ꠡꠤꠝꠣ ꠍꠣꠠꠣ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠖꠣꠄ ꠈꠦꠖꠣꠅ ꠅꠔꠣꠞꠦ, ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠞꠣ ꠔ ꠅꠔꠣꠄ ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("PS5_11","020_5_11","PSA","5","11","11","ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠍꠣꠄꠀꠔ ꠛꠡꠔꠇꠣꠞꠤ ꠈꠥꠡꠦ-ꠛꠣꠡꠦ ꠞꠃꠇ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠈꠥꠡꠤꠞ ꠉꠎꠟ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠉꠣꠃꠇ। ꠔꠥꠝꠤ ꠛꠣꠌꠣꠅ ꠔꠣꠞꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠀꠡꠤꠇ ꠎꠣꠞꠣ, ꠀꠝꠥꠖ-ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠃꠇ ꠡꠛꠦ ꠔꠥꠝꠣꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS5_12","020_5_12","PSA","5","12","12","ꠔꠥꠝꠤꠃ ꠝꠣꠛꠥꠖꠦ ꠙꠞꠦꠎꠉꠣꠞꠞꠦ ꠖꠦꠅ ꠞꠢꠝ-ꠛꠞꠇꠔ, ꠞꠢꠝꠔꠞ ꠛꠦꠠꠣꠖꠤ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠞꠣꠈꠅ ꠘꠤꠞꠣꠙꠖ॥ ");
INSERT INTO syls_vpl VALUES ("PS6_1","020_6_1","PSA","6","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠔꠣꠞꠀꠟꠣ ꠛꠣꠎꠘꠣꠖꠤ ꠉꠣꠁꠔꠦ ꠅꠁꠛ, ꠛꠣꠎꠘꠣ ꠡꠥꠞ ‘ꠡꠦꠝꠤꠘꠤꠕ’। ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠗꠣꠝꠇꠤ ꠖꠤꠅ ꠘꠣ ꠉ ꠝꠣꠛꠥꠖ ꠉꠥꠍꠣ ꠇꠞꠤꠀ, ꠡꠣꠎꠣ ꠖꠤꠅ ꠘꠣ ꠝꠞꠦ ꠞꠣꠉ ꠇꠞꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS6_2","020_6_2","PSA","6","2","2","ꠖꠄꠀ ꠇꠞꠅ ꠀꠝꠣꠄ ꠝꠣꠛꠥꠖ ꠢꠥꠇꠣꠁ ꠎꠣꠁꠀꠞ ꠀꠝꠤ, ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠅ ꠔꠥꠝꠤ ꠇꠣꠙꠦꠞ ꠝꠞ ꠀꠒ꠆ꠒꠤ। ");
INSERT INTO syls_vpl VALUES ("PS6_3","020_6_3","PSA","6","3","3","ꠒꠞꠞ ꠌꠥꠐꠦ ꠀꠝꠣꠞ ꠎꠣꠘ ꠗꠠꠚꠠ ꠗꠠꠚꠠ ꠇꠞꠦ, ꠀꠞ ꠇꠔꠖꠤꠘ ꠌꠟꠛ ꠁꠟꠣ ꠝꠞ ꠎꠤꠛꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("PS6_4","020_6_4","PSA","6","4","4","ꠚꠤꠞꠤꠀ ꠌꠣꠅ ꠉ ꠝꠣꠛꠥꠖ ꠛꠣꠌꠣꠅ ꠀꠝꠣꠞ ꠎꠣꠘ, ꠔꠥꠝꠣꠞ ꠖꠄꠀꠞ ꠖꠥꠀꠁ ꠟꠣꠉꠦ ꠇꠞꠅ ꠝꠞ ꠀꠍꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS6_5","020_6_5","PSA","6","5","5","ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠣꠞꠦ ꠔ ꠒꠣꠇꠣꠞ ꠘꠣꠁ ꠃꠙꠣꠄ, ꠙꠣꠔꠣꠟꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠣꠞ ꠉꠥꠘꠉꠣꠘ ꠇꠦ ꠉꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("PS6_6","020_6_6","PSA","6","6","6","ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ ꠀꠝꠣꠞ ꠛꠤꠍꠘꠣ ꠙꠞꠔꠤ ꠞꠣꠁꠔ ꠜꠤꠎꠣꠁꠟꠣꠁ, ꠀꠝꠣꠞ ꠌꠃꠈꠞ ꠙꠣꠘꠤꠄ ꠛꠤꠍꠘꠣ-ꠛꠣꠟꠤꠡ ꠜꠤꠎꠤꠀ ꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("PS6_7","020_6_7","PSA","6","7","7","ꠖꠤꠟꠞ ꠖꠥꠈꠦ ꠀꠝꠣꠞ ꠌꠃꠈ ꠢꠥꠇꠣꠁ ꠎꠣꠞ, ꠖꠥꠡꠝꠘꠞ ꠒꠞꠦ ꠌꠃꠈ ꠀꠝꠣꠞ ꠇꠝꠎꠥꠞ ꠛꠘꠤꠎꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS6_8","020_6_8","PSA","6","8","8","ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠅ ꠢꠇꠟ ꠘꠣꠚꠞꠝꠣꠘ, ꠝꠣꠛꠥꠖꠦ ꠔ ꠢꠥꠘꠍꠂꠘ ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠇꠣꠘ꠆ꠖꠘ। ");
INSERT INTO syls_vpl VALUES ("PS6_9","020_6_9","PSA","6","9","9","ꠙꠥꠞꠣꠙꠥꠞ ꠢꠥꠘꠍꠂꠘ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠝꠤꠘꠔꠤ, ꠇꠛꠥꠟ ꠇꠞꠍꠂꠘ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠀꠞꠎꠤ। ");
INSERT INTO syls_vpl VALUES ("PS6_10","020_6_10","PSA","6","10","10","ꠀꠝꠣꠞ ꠢꠇ꠆ꠇꠟ ꠖꠥꠡꠝꠘ ꠒꠞꠞ ꠌꠥꠐꠦ ꠇꠣꠙꠃꠇ, ꠡꠞꠝ ꠙꠣꠁꠀ ꠅꠈꠘꠃ ꠀꠝꠣꠞ ꠙꠤꠍ ꠍꠣꠠꠃꠇ॥ ");
INSERT INTO syls_vpl VALUES ("PS7_1","020_7_1","PSA","7","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠡꠥꠞ ‘ꠡꠤꠉ꠆ꠉꠣꠁꠅꠘ’। ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠇꠥꠡꠦ ꠔꠣꠘꠞꠦ ꠉꠣꠟꠤ ꠖꠦꠅꠀꠄ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠘ ꠚꠞꠤꠀꠖ। ꠅꠉ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠄꠟꠣꠢꠤ ꠔꠥꠝꠣꠞ ꠍꠣꠄꠀꠔ ꠀꠡꠞꠄ ꠟꠁꠍꠤ, ꠈꠞꠦ ꠅꠁꠀ ꠈꠦꠖꠣꠁꠞꠣ ꠎꠣꠞꠣ ꠀꠝꠣꠞꠦ, ꠔꠣꠞꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠅ ꠝꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS7_2","020_7_2","PSA","7","2","2","ꠘꠣꠁꠟꠦ ꠡꠤꠋꠢꠞ ꠟꠣꠈꠣꠘ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠛ ꠝꠞꠦ, ꠚꠣꠞꠤꠀ-ꠌꠤꠞꠤꠀ ꠝꠣꠞꠛ ꠔ ꠛꠣꠌꠣꠘꠤꠔ ꠇꠦꠃ ꠘꠣ ꠀꠁꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("PS7_3","020_7_3","PSA","7","3","3","ꠅꠉ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠄꠟꠣꠢꠤ, ꠎꠥꠖꠤ ꠇꠞꠤꠀ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠈꠣꠞꠣꠙꠤ, ꠀꠝꠣꠞ ꠀꠔꠅ ꠞꠄ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠘꠣꠚꠞꠝꠣꠘꠤ, ");
INSERT INTO syls_vpl VALUES ("PS7_4","020_7_4","PSA","7","4","4","ꠝꠞ ꠛꠤꠞꠥꠗꠤ ꠘꠣꠄ ꠔꠦꠛꠥꠅ ꠎꠥꠖꠤ ꠈꠦꠔꠤ ꠇꠞꠤꠀ ꠕꠣꠇꠤ, —ꠛꠞꠋ ꠛꠤꠘꠣ ꠇꠣꠞꠘꠦ ꠎꠦ ꠖꠥꠡꠝꠘ ꠅꠁꠍꠦ ꠔꠣꠞꠅ ꠃꠙꠇꠣꠞ ꠇꠞꠍꠤ— ");
INSERT INTO syls_vpl VALUES ("PS7_5","020_7_5","PSA","7","5","5","ꠔꠦ ꠖꠥꠡꠝꠘꠦ ꠀꠝꠣꠞꠦ ꠗꠞꠤꠟꠣꠃꠇ ꠈꠦꠖꠣꠁꠀ, ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠙꠣꠅꠖꠤ ꠙꠣꠠꠣꠁꠀ, ꠗꠥꠟꠣꠔ ꠝꠤꠡꠣꠁꠟꠣꠃꠇ ꠀꠝꠣꠞ ꠇꠣꠄꠀ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS7_6","020_7_6","PSA","7","6","6","ꠝꠣꠛꠥꠖ ꠉ, ꠔꠥꠝꠣꠞ ꠝꠢꠣ ꠉꠥꠍꠣꠄ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠃꠛꠣꠅ, ꠎꠣꠞꠣ ꠝꠞꠦ ꠁꠋꠡꠣꠄ ꠅꠔꠣ ꠖꠥꠡꠝꠘꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠈꠣꠠꠣ ꠅꠅ, ꠅ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠢꠇ ꠛꠤꠌꠣꠞ ꠎꠣꠞꠤ ꠇꠞꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS7_7","020_7_7","PSA","7","7","7","ꠔꠥꠝꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠎꠝꠣ ꠅꠃꠇ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤ, ꠀꠞꠡꠅ ꠛꠁꠀ ꠖꠦꠈꠅ ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠇꠥ-ꠇꠤꠞ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS7_8","020_7_8","PSA","7","8","8","ꠝꠣꠛꠥꠖ ꠅꠔꠣ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠛꠤꠌꠣꠞꠇ ꠔ ꠔꠥꠝꠤ, ꠞꠣꠄ ꠖꠤꠅ ꠖꠦꠈꠤꠀ ꠝꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠀꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("PS7_9","020_7_9","PSA","7","9","9","ꠘꠣꠚꠞꠝꠣꠘꠞ ꠎꠥꠟꠥꠝ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟꠣꠃꠇ꠆ꠇꠣ, ꠙꠞꠦꠎꠉꠣꠞꠞꠦ ꠝꠎꠛꠥꠔ ꠛꠣꠘꠣꠅ ꠅ ꠢꠇ ꠀꠟ꠆ꠟꠣ, ꠖꠤꠟ-ꠝꠘꠞ ꠜꠤꠔꠞ ꠔꠥꠝꠤ ꠎꠣꠌꠣꠁ ꠇꠞꠅ ꠢꠇꠟꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("PS7_10","020_7_10","PSA","7","10","10","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠝꠞ ꠞꠇ꠆ꠇꠣꠇꠣꠞꠤ, ꠎꠣꠘ ꠛꠣꠌꠣꠁꠘ ꠀꠝꠣꠞ, ꠔꠣꠁꠘꠃ ꠛꠣꠌꠣꠘꠦꠀꠟꠣ ꠡꠞꠟ ꠝꠘꠞ ꠛꠘ꠆ꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS7_11","020_7_11","PSA","7","11","11","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠇꠞꠂꠘ ꠢꠇ ꠛꠤꠌꠣꠞ, ꠘꠣꠚꠞꠝꠣꠘꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣ ꠇꠞꠂꠘ ꠛꠞꠣꠛꠞ, ");
INSERT INTO syls_vpl VALUES ("PS7_12","020_7_12","PSA","7","12","12","ꠝꠣꠘꠡꠦ ꠔꠃꠛꠣ ꠘꠣ ꠇꠞꠤꠟꠦ ꠔꠣꠘ ꠔꠟꠥꠀꠞ ꠗꠣꠞꠣꠁꠛꠣ, ꠔꠤꠞ-ꠗꠘꠥꠇ ꠟꠁꠀ ꠔꠣꠁꠘ ꠗꠘꠥꠇꠅ ꠔꠤꠞ ꠟꠣꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS7_13","020_7_13","PSA","7","13","13","ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠀꠔꠤꠀꠞ ꠔꠣꠁꠘ ꠎꠥꠁꠔ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠔꠤꠞ ꠅꠇꠟꠞꠦ ꠔꠣꠁꠘ ꠀꠉꠥꠁꠘꠖꠤ ꠢꠣꠎꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS7_14","020_7_14","PSA","7","14","14","ꠘꠣꠚꠞꠝꠣꠘꠦ ꠛꠖ ꠇꠣꠝꠞꠦ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠦ ꠞꠣꠈꠦ, ꠛꠖ ꠇꠣꠝꠦ ꠙꠦꠐ ꠜꠞꠤ ꠉꠦꠟꠦ ꠎꠘꠝ ꠖꠦꠄ ꠝꠤꠍꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS7_15","020_7_15","PSA","7","15","15","ꠝꠣꠐꠤ ꠈꠥꠠꠤꠀ ꠇꠥꠙ ꠈꠥꠖꠦ ꠢꠦ ꠉꠁꠘ ꠇꠞꠤꠀ, ꠔꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠅꠃ ꠇꠥꠙꠅ ꠘꠤꠎꠦ ꠎꠣꠄ ꠙꠠꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS7_16","020_7_16","PSA","7","16","16","ꠔꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠔ ꠔꠣꠞ ꠝꠣꠕꠣꠔ ꠚꠤꠞꠤꠀ ꠀꠄ, ꠔꠣꠞ ꠎꠥꠟꠥꠝ ꠀꠁꠀ ꠘꠤꠎꠞ ꠔꠣꠟꠥꠔ ꠙꠠꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS7_17","020_7_17","PSA","7","17","17","ꠝꠣꠛꠥꠖꠞ ꠢꠇ ꠛꠤꠌꠣꠞꠞ ꠟꠣꠉꠤ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠝꠥ ꠔꠣꠘ, ꠞꠣꠛ꠆ꠛꠥꠟ ꠀꠟꠣꠝꠤꠘꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠇꠞꠝꠥ ꠉꠥꠘꠉꠣꠘ॥ ");
INSERT INTO syls_vpl VALUES ("PS8_1","020_8_1","PSA","8","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠡꠥꠞ ‘ꠉꠤꠔ꠆ꠔꠤꠔ’। ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ, ꠔꠥꠝꠣꠞ ꠡꠣꠘ-ꠡꠃꠇꠔꠦ ꠜꠞꠣ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀ! ꠔꠥꠝꠣꠞ ꠘꠥꠞꠞ ꠔꠎꠟ꠆ꠟꠤ ꠇꠣꠁꠝ ꠇꠞꠍ ꠀꠍꠝꠣꠘ ꠊꠦꠞꠤꠀ! ");
INSERT INTO syls_vpl VALUES ("PS8_2","020_8_2","PSA","8","2","2","ꠔꠥꠝꠣꠞ ꠛꠤꠞꠥꠗꠤ ꠅꠇꠟꠞ ꠛꠤꠙꠇ꠆ꠇꠦ, ꠉꠦꠖꠣ ꠀꠞ ꠘꠣꠛꠣꠟꠤꠇ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠝꠥꠈꠞ ꠎꠛꠣꠘꠖꠤ ꠔꠥꠝꠤ ꠡꠇ꠆ꠔꠤꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠛꠣꠘꠣꠁꠍ। ꠅꠟꠣ ꠇꠞꠤꠀ ꠖꠥꠡꠝꠘ ꠀꠞ ꠎꠤꠖꠈꠥꠞꠞꠦ ꠔꠥꠝꠤ ꠟꠦꠐꠣꠁꠟꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS8_3","020_8_3","PSA","8","3","3","ꠔꠥꠝꠣꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠀꠍꠝꠣꠘꠞ ꠛꠣꠄꠖꠤ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠌꠣꠁ, ꠢꠘꠅ ꠔꠥꠝꠣꠞ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠌꠣꠘ꠆ꠖ-ꠔꠦꠞꠣ ꠖꠦꠈꠔꠣꠝ ꠙꠣꠁ, ");
INSERT INTO syls_vpl VALUES ("PS8_4","020_8_4","PSA","8","4","4","ꠖꠦꠈꠤꠀ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁ, ꠝꠣꠘꠥꠡ ꠀꠞꠇꠔꠣ ꠇꠤꠔꠣ ꠎꠦꠘ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠁꠀꠖ ꠇꠞꠅ? ꠀꠖꠝ ꠎꠣꠔꠤ ꠅꠔ ꠇꠤꠔꠣ ꠎꠦꠘ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠈꠤꠀꠟ ꠞꠣꠈꠅ? ");
INSERT INTO syls_vpl VALUES ("PS8_5","020_8_5","PSA","8","5","5","ꠝꠣꠘꠥꠡꠞꠦ ꠛꠣꠘꠣꠁꠍ ꠈꠣꠟꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠇꠝ ꠉꠥꠘꠤ, ꠅꠁꠟꠦ ꠉꠃꠞꠛ-ꠁꠎ꠆ꠎꠔꠞ ꠝꠣꠟꠣ ꠔ ꠔꠣꠞꠣꠞꠦ ꠚꠤꠘ꠆ꠖꠣꠁꠍ ꠔꠥꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("PS8_6","020_8_6","PSA","8","6","6","ꠔꠥꠝꠣꠞ ꠙꠄꠖꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠡꠣꠡꠘꠞ ꠈꠦꠝꠔꠣ ꠄꠞꠣꠞ ꠀꠔꠅ ꠖꠤꠍ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠄꠞꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ, ꠄꠞꠣꠞ ꠀꠅꠔꠣꠄ ꠞꠣꠈꠍ— ");
INSERT INTO syls_vpl VALUES ("PS8_7","020_8_7","PSA","8","7","7","ꠉꠞꠥ-ꠍꠣꠉꠟꠞ ꠙꠣꠟ ꠀꠞ ꠎꠉꠔꠞ ꠔꠣꠝꠣꠝ ꠎꠣꠘꠥꠀꠞ, ");
INSERT INTO syls_vpl VALUES ("PS8_8","020_8_8","PSA","8","8","8","ꠀꠍꠝꠣꠘꠅ ꠃꠠꠞꠣ ꠙꠣꠈꠤ ꠀꠞ ꠖꠞꠤꠀꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠍ, ꠡꠣꠉꠞꠞ ꠙꠣꠘꠤꠔ ꠌꠟꠞꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠎꠣꠘꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS8_9","020_8_9","PSA","8","9","9","ꠅ ꠝꠣꠛꠥꠖ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ, ꠔꠥꠝꠣꠞ ꠡꠣꠘ-ꠡꠃꠇꠔꠦ ꠜꠞꠣ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀ॥ ");
INSERT INTO syls_vpl VALUES ("PS9_1","020_9_1","PSA","9","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠡꠥꠞ ‘ꠝꠃꠔ-ꠟꠣꠛ꠆ꠛꠦꠘ’। ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠀꠝꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁꠝꠥ, ꠔꠥꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠇꠕꠣ ꠀꠝꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS9_2","020_9_2","PSA","9","2","2","ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠟꠁꠀꠃ ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖ ꠇꠞꠝꠥ, ꠅ ꠞꠣꠛ꠆ꠛꠥꠟ ꠀꠟꠣꠝꠤꠘ, ꠔꠥꠝꠣꠞ ꠘꠣꠝꠞ ꠔꠣꠞꠤꠚ ꠉꠤꠔ ꠉꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS9_3","020_9_3","PSA","9","3","3","ꠖꠥꠡꠝꠘ ꠅꠇꠟ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠈꠞ ꠕꠣꠇꠤ ꠚꠤꠞꠤꠀ ꠎꠣꠄ, ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠀ ꠙꠠꠤꠀ ꠔꠣꠞꠣ ꠝꠞꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS9_4","020_9_4","PSA","9","4","4","ꠘꠣꠟꠤꠡ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠞꠣꠄ ꠖꠤꠍ, ꠞꠣꠎ-ꠉꠖꠤꠔ ꠛꠁꠀ ꠔꠥꠝꠤ ꠔ ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("PS9_5","020_9_5","PSA","9","5","5","ꠔꠥꠝꠤ ꠜꠤꠘ ꠎꠣꠔꠤꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠀ ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠍ, ꠔꠥꠝꠤ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤꠀ ꠁꠔꠣꠞ ꠘꠣꠝ ꠝꠤꠐꠣꠁꠟꠤꠍ। ");
INSERT INTO syls_vpl VALUES ("PS9_6","020_9_6","PSA","9","6","6","ꠁꠔꠣ ꠖꠥꠡꠝꠘ ꠅꠇꠟ ꠉꠦꠍꠦ ꠘꠤꠙꠣꠔ ꠅꠁꠀ, ꠔꠣꠞꠣꠞ ꠛꠣꠠꠤ-ꠊꠞ ꠛꠤꠘꠣꠡ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤꠀ, ꠔꠣꠞꠣꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠔꠥꠝꠤ ꠚꠣꠟꠣꠁꠍ ꠔꠥꠟꠤꠀ, ꠇꠥꠘꠥ ꠌꠤꠘ ꠘꠣꠝ-ꠘꠤꠡꠣꠘꠣ ꠘꠣ ꠞꠣꠈꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS9_7","020_9_7","PSA","9","7","7","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖ ꠔ ꠞꠂꠘ ꠌꠤꠞꠇꠣꠟ, ꠔꠣꠁꠘ ꠇꠞꠍꠂꠘ ꠛꠤꠌꠣꠞꠞ ꠉꠖꠤ ꠛꠅꠀꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("PS9_8","020_9_8","PSA","9","8","8","ꠢꠇ-ꠁꠘꠍꠣꠚꠦ ꠎꠉꠔꠞ ꠛꠤꠌꠣꠞ-ꠚꠄꠍꠣꠟꠣ ꠇꠞꠛꠣ, ꠢꠇ-ꠢꠣꠟꠣꠟꠤꠄ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS9_9","020_9_9","PSA","9","9","9","ꠎꠥꠟꠥꠝꠅ ꠙꠠꠣ ꠎꠘꠞ ꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠃ ꠔꠣꠞ ꠀꠡꠞꠄ, ꠝꠍꠤꠛꠔꠞ ꠇꠣꠟꠅ ꠔꠣꠁꠘ ꠘꠤꠞꠣꠙꠖ ꠑꠤꠇꠣꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("PS9_10","020_9_10","PSA","9","10","10","ꠔꠥꠝꠣꠞꠦ ꠌꠤꠘꠦ ꠎꠣꠞꠣ, ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠦ ꠔꠣꠞꠣ, ꠝꠣꠛꠥꠖ ꠉ, ꠔꠥꠝꠣꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠞꠣ ꠀꠡꠤꠇꠞ ꠟꠉ ꠔꠥꠝꠤ ꠍꠣꠠꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS9_11","020_9_11","PSA","9","11","11","ꠍꠤꠅꠘ ꠘꠉꠞꠅ ꠛꠡꠔ ꠇꠣꠞꠤ ꠝꠣꠛꠥꠖꠞ ꠔꠣꠞꠤꠚ-ꠉꠎꠟ ꠉꠣꠅ, ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣꠞ ꠛꠄꠀꠘ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠎꠣꠘꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS9_12","020_9_12","PSA","9","12","12","ꠈꠥꠘ-ꠈꠣꠞꠣꠙꠤꠞ ꠛꠖꠟꠣ ꠖꠦꠅꠞꠣꠄ ꠝꠘꠅ ꠞꠣꠈꠂꠘ ꠢꠇꠟꠔꠣ, ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟꠞ ꠇꠣꠘ꠆ꠖꠘ ꠔꠣꠁꠘ ꠇꠥꠘꠥꠖꠤꠘ ꠚꠣꠃꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS9_13","020_9_13","PSA","9","13","13","ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠖꠥꠞ꠆ꠖꠡꠣ ꠖꠦꠈꠤꠀ ꠞꠢꠝ ꠇꠞꠅ ꠝꠣꠛꠥꠖ ꠉ, ꠝꠃꠔꠞ ꠖꠥꠀꠞ ꠕꠣꠇꠤ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠔꠥꠟꠤꠀ ꠘꠦꠅ ꠉ, ");
INSERT INTO syls_vpl VALUES ("PS9_14","020_9_14","PSA","9","14","14","ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞ ꠡꠥꠇꠞꠤꠀ-ꠔꠣꠞꠤꠚ ꠀꠝꠤ ꠉꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠄ ꠀꠝꠤ ꠇꠞꠝꠥ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ, ꠍꠤꠅꠘ ꠘꠉꠞꠤꠞ ꠙꠣꠠꠣꠄ ꠙꠣꠠꠣꠄ ꠇꠞꠝꠥ ꠘꠣꠌꠣ-ꠘꠣꠌꠤ। ");
INSERT INTO syls_vpl VALUES ("PS9_15","020_9_15","PSA","9","15","15","ꠘꠤꠎꠞ ꠈꠥꠠꠣ ꠉꠣꠔꠅ ꠙꠠꠤꠀ ꠜꠤꠘ ꠎꠣꠔꠤ ꠛꠥꠠꠤꠉꠦꠍꠦ, ꠔꠣꠞꠣꠞ ꠙꠣꠔꠣꠁꠟ ꠟꠥꠇꠣꠁꠟ ꠚꠣꠘ꠆ꠖꠅ ꠔꠣꠞꠣꠞꠃ ꠙꠣꠅ ꠢꠣꠝꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS9_16","020_9_16","PSA","9","16","16","ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠞꠦ ꠎꠣꠁꠞ ꠇꠞꠤꠀ ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠍꠂꠘ, ꠘꠣꠚꠞꠝꠣꠘ ꠖꠟꠞ ꠛꠣꠘꠣꠁꠟ ꠚꠣꠘ꠆ꠖꠅ ꠔꠣꠞꠣꠃ ꠀꠐꠇꠤꠍꠂꠘ। (ꠢꠤꠉ꠆ꠉꠣꠄꠅꠘ-ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS9_17","020_9_17","PSA","9","17","17","ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟ ꠢꠣꠝꠣꠃꠇ ꠉꠤꠀ ꠉꠁꠘ ꠙꠣꠔꠣꠟꠦ, ꠅꠔꠣꠞ ꠟꠉꠦ ꠜꠤꠘ ꠎꠣꠔꠤꠅ ꠜꠥꠟꠤ ꠎꠣꠁꠘ ꠎꠦꠔꠣꠄ ꠀꠟ꠆ꠟꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS9_18","020_9_18","PSA","9","18","18","ꠘꠤꠞꠣꠡ꠆ꠞꠄꠞꠦ ꠚꠣꠃꠞꠂꠘ ꠘꠣ ꠔꠣꠁꠘ ꠌꠤꠞꠇꠣꠟꠞ ꠖꠣꠄ, ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟꠞ ꠀꠡꠣꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠛꠤꠚꠟꠦ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS9_19","020_9_19","PSA","9","19","19","ꠎꠟꠖꠤ ꠀꠅ ꠉ ꠝꠣꠛꠥꠖ! ꠝꠣꠘꠡꠦ ꠎꠣꠘꠥ ꠘꠣ ꠖꠦꠈꠣꠄ ꠛꠣꠠꠔꠤ ꠛꠣꠢꠣꠖꠥꠞꠤ, ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠛꠤꠌꠣꠞ ꠅꠃꠇ ꠢꠇꠟ ꠜꠤꠘ ꠎꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS9_20","020_9_20","PSA","9","20","20","ꠒꠞ-ꠜꠄ ꠖꠦꠈꠣꠅ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ, ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠝꠣꠐꠤꠞ ꠝꠣꠘꠥꠡ ꠎꠣꠘꠃꠇ ꠜꠤꠘ ꠎꠣꠔꠤꠄ। (ꠍꠦꠟꠣ)॥ ");
INSERT INTO syls_vpl VALUES ("PS10_1","020_10_1","PSA","10","1","1","ꠝꠣꠛꠥꠖ ꠉ, ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠖꠥꠞꠁ ꠞꠁꠞꠣꠄ? ꠛꠤꠙꠖꠞ ꠇꠣꠟꠅ ꠇꠤꠔꠣꠟ꠆ꠟꠣꠉꠤ ꠟꠥꠇꠣꠁꠞꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("PS10_2","020_10_2","PSA","10","2","2","ꠎꠣꠟꠤꠝꠞ ꠛꠣꠢꠣꠖꠥꠞꠤꠄ ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟ ꠜꠥꠉꠦ, ꠢꠦꠡꠦ ꠔꠣꠞꠣꠞ ꠌꠔꠥꠞꠤꠞ ꠚꠣꠘ꠆ꠖꠅ ꠔꠣꠞꠣꠃ ꠗꠞꠣ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("PS10_3","020_10_3","PSA","10","3","3","ꠝꠘ꠆ꠖ ꠎꠘꠦ ꠔꠣꠞ ꠝꠘꠞ ꠛꠎ꠆ꠎꠣꠔꠤꠞ ꠛꠣꠢꠣꠖꠥꠞꠤ ꠖꠦꠈꠣꠄ, ꠟꠥꠜꠤ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞꠦ ꠔꠥꠌ꠆ꠍ ꠝꠘꠅ ꠇꠞꠤꠀ ꠉꠣꠟꠤꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("PS10_4","020_10_4","PSA","10","4","4","ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠤꠀ ꠝꠘ꠆ꠖ ꠟꠥꠇꠦ ꠌꠣꠄ ꠘꠣ ꠔꠣꠘ ꠖꠤꠖꠣꠞ, ꠀꠟ꠆ꠟꠣ ꠛꠟꠔꠦ ꠇꠦꠃ ꠘꠣꠁ, ꠅꠟꠣ ꠄꠇꠤꠘ ꠔꠣꠞꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS10_5","020_10_5","PSA","10","5","5","ꠖꠥꠘꠤꠀꠛꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠢꠣꠝꠦꠡꠣ ꠟꠣꠜꠛꠣꠘ ꠔꠣꠞꠣꠞ, ꠔꠣꠞꠣꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠦ ꠘꠣ ꠔ ꠢꠇ ꠁꠘꠍꠣꠚ ꠔꠥꠝꠣꠞ, “ꠁꠔꠣ ꠛꠥꠟꠦ ꠛꠃꠔ ꠃꠙꠞꠦ,” ꠅꠈꠣꠘ ꠔꠣꠞꠣ ꠇꠄ, “ꠀꠝꠣꠞ ꠛꠤꠞꠥꠗꠤꠞꠦ ꠚꠥ ꠖꠤꠀ ꠃꠠꠣꠁꠟꠤꠝꠥ ꠘꠤꠌ꠆ꠌꠄ।” ");
INSERT INTO syls_vpl VALUES ("PS10_6","020_10_6","PSA","10","6","6","ꠝꠘꠦ ꠝꠘꠦ ꠇꠄ ꠔꠣꠞꠣ, “ꠀꠝꠣꠞ ꠇꠥꠘꠥ ꠙꠔꠘ ꠘꠣꠁ, ꠇꠥꠘꠥ ꠎꠥꠉꠦ ꠇꠥꠘꠥ ꠖꠤꠘꠃ ꠛꠤꠙꠖ-ꠀꠙꠖ ꠀꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("PS10_7","020_10_7","PSA","10","7","7","ꠔꠣꠞ ꠝꠣꠔꠅ ꠟꠣꠘ꠆ꠘꠔ ꠀꠞ ꠗꠣꠘ꠆ꠖꠣ, ꠎꠥꠞ-ꠎꠥꠟꠥꠝꠦ ꠜꠞꠣ, ꠎꠤꠚꠞꠣ ꠜꠞꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠛꠎ꠆ꠎꠣꠔꠤꠞ ꠛꠡꠔ ꠈꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS10_8","020_10_8","PSA","10","8","9","ꠘꠤꠞꠣꠁ ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠢꠦ ꠃꠔ ꠙꠣꠔꠤꠀ ꠛꠄ, ꠘꠤꠞ꠆ꠎꠘ ꠎꠣꠉꠣꠔ ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠔ ꠞꠄ। ꠅꠡꠢꠣꠄ-ꠅꠜꠣꠉꠣ ꠅꠇꠟ ꠔꠣꠞꠣꠞ ꠖꠥꠁꠅ ꠌꠃꠈꠞ ꠘꠤꠡꠣꠘꠣ, ꠡꠤꠋꠢꠄ ꠎꠦꠟꠣ ꠈꠣꠙ ꠗꠞꠤꠀ ꠎꠋꠟꠣꠔ ꠛꠄ ꠟꠥꠇꠣꠁꠀ, ꠖꠥꠈꠤ ꠎꠘꠞꠦ ꠗꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠅ ꠅꠟꠣ ꠛꠄ, ꠗꠞꠤꠀ ꠔꠣꠞꠦ ꠐꠣꠘꠤꠀ ꠀꠘꠤ ꠚꠣꠘ꠆ꠖꠅ ꠢꠣꠞꠣꠁ ꠕꠄ। ");
INSERT INTO syls_vpl VALUES ("PS10_10","020_10_10","PSA","10","10","10","ꠚꠣꠘ꠆ꠖꠅ ꠢꠣꠞꠣꠁ ꠘꠞꠝ ꠇꠞꠤ ꠙꠤꠡꠤꠀ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠦ, ꠅꠡꠢꠣꠄ-ꠅꠜꠣꠉꠣ ꠎꠘ ꠔꠣꠞꠣꠞ ꠘꠈꠥꠞ ꠕꠣꠛꠣꠔ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("PS10_11","020_10_11","PSA","10","11","11","ꠝꠘꠦ ꠝꠘꠦ ꠇꠄ ꠔꠣꠞꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣ ꠖꠦꠈꠂꠘ ꠘꠣ, ꠔꠣꠘ ꠝꠥꠈ ꠔ ꠟꠥꠇꠣꠁꠟꠤꠍꠂꠘ, ꠁꠔꠣꠞ ꠛꠣꠄꠖꠤ ꠌꠣꠁꠘꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("PS10_12","020_10_12","PSA","10","12","12","ꠅ ꠝꠣꠛꠥꠖ ꠎꠟꠖꠤ ꠀꠅ, ꠔꠥꠝꠣꠞ ꠀꠔ ꠈꠣꠘ ꠛꠣꠠꠣꠅ, ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟꠞꠦ ꠘꠣ ꠚꠣꠃꠞꠤꠀ ꠎꠣꠘ ꠈꠣꠘ ꠛꠣꠌꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS10_13","020_10_13","PSA","10","13","13","ꠘꠣꠚꠞꠝꠣꠘꠦ ꠇꠦꠘꠦ ꠇꠞꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠄꠟꠣꠝꠤ? ꠝꠘꠦ ꠝꠘꠦ ꠇꠦꠘꠦ ꠇꠄ, “ꠔꠣꠁꠘ ꠢꠤꠡꠣꠛ ꠟꠁꠛꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("PS10_14","020_10_14","PSA","10","14","14","ꠅꠕꠌ ꠔꠥꠝꠤ ꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠖꠦꠈꠞꠣꠄ, ꠄꠞꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠤ ꠔꠥꠝꠣꠞ ꠀꠔꠞ ꠇꠛꠎꠣꠄ। ꠅꠡꠢꠣꠄ ꠎꠘꠦ ꠔ ꠔꠥꠝꠣꠞ ꠀꠔꠅꠃ ꠘꠤꠎꠞꠦ ꠡꠙꠦ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦꠃ ꠀꠡꠞꠄ ꠙꠣꠄ ꠄꠔꠤꠝ-ꠝꠤꠍꠇꠤꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("PS10_15","020_10_15","PSA","10","15","15","ꠘꠣꠚꠞꠝꠣꠘ ꠛꠎ꠆ꠎꠣꠔꠞ ꠛꠟ ꠅꠈꠘ ꠜꠣꠋꠉꠤꠟꠣꠅ, ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠛꠖ ꠇꠣꠝꠞ ꠢꠤꠡꠣꠛ ꠔꠥꠝꠤ ꠟꠁꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS10_16","020_10_16","PSA","10","16","16","ꠌꠤꠞꠖꠤꠘ ꠌꠤꠞꠇꠣꠟ ꠝꠣꠛꠥꠖꠃ ꠅꠁꠟꠣ ꠛꠣꠖꠡꠣ, ꠔꠣꠘ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠛꠤꠗꠞ꠆ꠝꠤ ꠎꠣꠔꠤ ꠡꠞ꠆ꠛꠘꠣꠡ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS10_17","020_10_17","PSA","10","17","17","ꠝꠣꠛꠥꠖ ꠉ, ꠇꠣꠋꠉꠣꠟ-ꠖꠥꠈꠤꠞ ꠀꠡꠣ ꠔꠥꠝꠤ ꠙꠥꠞꠣ ꠇꠞꠅ, ꠔꠣꠞꠣꠞ ꠝꠘꠅ ꠡꠣꠅꠡ ꠎꠥꠉꠣꠁ ꠖꠤꠟꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("PS10_18","020_10_18","PSA","10","18","18","ꠄꠔꠤꠝꠞ ꠛꠣꠄ ꠌꠣꠅ ꠉ ꠀꠟ꠆ꠟꠣ, ꠛꠤꠌꠣꠞ ꠇꠞꠅ ꠡꠛ ꠎꠣꠟꠤꠝꠞ, ꠒꠞ ꠖꠦꠈꠣꠘꠤ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟꠣꠅ ꠝꠣꠐꠤꠞ ꠙꠄꠖꠣ ꠝꠣꠘꠥꠡꠞ॥ ");
INSERT INTO syls_vpl VALUES ("PS11_1","020_11_1","PSA","11","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠀꠝꠤ ꠔ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦꠃ ꠀꠡꠞꠄ ꠟꠁꠍꠤ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠞꠣꠄ, “ꠅ ꠙꠣꠈꠤ, ꠔꠥꠝꠣꠞ ꠀꠡꠞꠄ ꠙꠣꠠꠦꠖꠤ ꠜꠣꠉꠤꠀ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS11_2","020_11_2","PSA","11","2","2","ꠛꠎ꠆ꠎꠣꠔꠞ ꠖꠟꠦ ꠗꠘꠥꠇꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠥꠁꠔ ꠇꠞꠤ ꠗꠞꠍꠦ, ꠡꠞꠟ ꠝꠣꠘꠡꠞꠦ ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠝꠣꠞꠔ ꠇꠞꠤ ꠔꠤꠞ ꠟꠣꠉꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS11_3","020_11_3","PSA","11","3","3","ꠜꠣꠋꠉꠤꠀ ꠙꠠꠤ ꠎꠣꠄ ꠎꠥꠖꠤ ꠡꠝꠣꠎꠞ ꠝꠥꠟ ꠙꠤꠟꠣꠞ, ꠁꠟꠣ ꠅꠁꠟꠦ ꠇꠤꠔꠣ ꠇꠞꠛ ꠎꠣꠞꠣ ꠙꠞꠦꠎꠉꠣꠞ?” ");
INSERT INTO syls_vpl VALUES ("PS11_4","020_11_4","PSA","11","4","4","ꠝꠣꠛꠥꠖ ꠔ ꠞꠂꠘ ꠔꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠝꠥꠇꠣꠝꠅ, ꠔꠣꠘ ꠀꠞꠡ-ꠇꠥꠞꠍꠤ ꠛꠅꠀꠁꠟ ꠀꠍꠦ ꠀꠍꠝꠣꠘꠅ, ꠀꠖꠝ ꠎꠣꠔꠤꠞꠦ ꠞꠣꠈꠂꠘ ꠔꠣꠘ ꠌꠈꠥꠞ ꠘꠎꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS11_5","020_11_5","PSA","11","5","5","ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠢꠇꠟꠞꠦ ꠎꠣꠌꠣꠁ ꠇꠞꠂꠘ ꠝꠣꠛꠥꠖꠦ, ꠎꠣꠟꠤꠝ ꠅꠇꠟ ꠔꠣꠘ ꠖꠥꠡꠝꠘ, ꠊꠤꠘ ꠇꠞꠂꠘ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS11_6","020_11_6","PSA","11","6","6","ꠛꠎ꠆ꠎꠣꠔꠞ ꠃꠙꠞꠦ ꠓꠣꠟꠤꠛꠣ ꠔꠣꠁꠘ ꠎꠣꠟꠣꠁꠟ ꠉꠘ꠆ꠖꠇ ꠀꠞ ꠀꠋꠞꠣ, ꠉꠞꠝ ꠀꠉꠥꠘꠤꠞ ꠉꠥꠟ꠆ꠟꠣꠃ ꠅꠁꠛ ꠔꠣꠞꠣꠞ ꠈꠣꠘꠤ-ꠙꠣꠘꠤ ꠢꠣꠝꠦꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("PS11_7","020_11_7","PSA","11","7","7","ꠝꠣꠛꠥꠖ ꠘꠤꠎꠦ ꠙꠞꠦꠎꠉꠣꠞ, ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ ꠙꠞꠦꠎꠉꠣꠞꠞꠦ, ꠢꠇ-ꠘꠤꠈꠥꠔ ꠛꠘ꠆ꠖꠣꠄ ꠙꠣꠁꠛꠣ ꠔꠣꠘ ꠝꠥꠈꠞ ꠖꠤꠖꠣꠞꠞꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS12_1","020_12_1","PSA","12","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠡꠥꠞ ‘ꠡꠦꠝꠤꠘꠤꠕ’। ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ, ꠎꠣꠘꠦ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ, ꠅꠈꠘ ꠀꠞ ꠘꠣꠁ ꠇꠥꠘꠥ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣ, ꠀꠖꠝ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠢꠇ ꠇꠥꠘꠥ ꠎꠘ ꠔꠥꠇꠣꠁꠀ ꠝꠤꠟꠦꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS12_2","020_12_2","PSA","12","2","2","ꠙꠞꠔꠦꠇꠦꠃ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠤꠍꠣ ꠝꠣꠔ ꠝꠣꠔꠦ, ꠈꠣꠟꠤ ꠚꠣꠝ-ꠙꠐ꠆ꠐꠤ ꠝꠣꠞꠦ ꠀꠞ ꠝꠥꠘꠣꠚꠤꠇꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS12_3","020_12_3","PSA","12","3","3","ꠅ ꠝꠣꠛꠥꠖ, ꠚꠣꠝ-ꠙꠐ꠆ꠐꠤ ꠝꠣꠞꠞꠣ ꠢꠇ꠆ꠇꠟ ꠑꠥꠐ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠅ, ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠅꠞꠣꠞ ꠎꠤꠚꠞꠣ ꠔꠥꠝꠤ ꠇꠣꠐꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS12_4","020_12_4","PSA","12","4","4","ꠔꠣꠞꠣ ꠇꠄ, “ꠎꠤꠔꠤꠝꠥ ꠘꠤꠌ꠆ꠌꠤꠔ ꠀꠝꠞꠣꠞ ꠎꠤꠚꠞꠣꠞ ꠛꠟꠦ, ꠀꠞ ꠇꠦꠉꠥ ꠅꠁꠛ ꠌꠣꠟꠇꠖꠣꠞ ꠘꠤꠎꠞ ꠑꠥꠐ ꠕꠣꠇꠔꠦ?” ");
INSERT INTO syls_vpl VALUES ("PS12_5","020_12_5","PSA","12","5","5","“ꠉꠞꠤꠛ-ꠖꠥꠈꠤꠞ ꠎꠥꠟꠥꠝ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠝꠣꠛꠥꠖ ꠃꠛꠣꠁꠝꠥ, ꠘꠤꠞꠥꠙꠣꠄꠞ ꠖꠤꠟꠞ ꠇꠣꠘ꠆ꠖꠘ ꠀꠝꠤ ꠘꠤꠌ꠆ꠌꠤꠔ ꠢꠥꠘꠤꠝꠥ। ꠡꠣꠄ-ꠡꠣꠘ꠆ꠔꠤꠄ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠔ ꠎꠣꠞꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠌꠣꠄ, ꠔꠣꠞꠣꠞ ꠀꠡꠣ ꠇꠞꠝꠥ ꠙꠥꠞꠘ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("PS12_6","020_12_6","PSA","12","6","6","ꠝꠣꠛꠥꠖꠞ ꠎꠛꠣꠘꠅ ꠔ ꠇꠥꠘꠥ ꠈꠣꠖ ꠘꠣꠁ, ꠇꠡ꠆ꠐꠤ-ꠙꠣꠔ꠆ꠔꠞꠅ ꠎꠦꠟꠣ ꠞꠥꠙꠣ ꠅꠄ ꠎꠣꠌꠣꠁ, ꠡꠣꠔꠛꠣꠞꠞ ꠀꠉꠥꠁꠘꠖꠤ ꠍꠣꠚ ꠇꠞꠣ ꠞꠥꠙꠣ, ꠔꠣꠘ ꠎꠛꠣꠘ ꠈꠣꠐꠤ ꠘꠤꠈꠥꠔ-ꠘꠤꠈꠣꠖ ꠅꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS12_7","020_12_7","PSA","12","7","7","ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠘꠤꠌ꠆ꠌꠄ ꠀꠝꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠛꠣꠄ, ꠅꠟꠣ ꠝꠣꠘꠡꠞ ꠀꠔ ꠕꠣꠇꠤ ꠌꠤꠞꠇꠣꠟ ꠛꠣꠌꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS12_8","020_12_8","PSA","12","8","8","ꠘꠣꠚꠞꠝꠣꠘ-ꠛꠎ꠆ꠎꠣꠔꠦ ꠎꠦꠛꠟꠣ ꠌꠣꠁꠞꠅꠛꠣꠄꠖꠤ ꠊꠥꠞꠦ, ꠀꠖꠝ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠅꠛꠟꠣ ꠈꠣꠞꠣꠙꠤ ꠇꠣꠝ ꠛꠣꠠꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS13_1","020_13_1","PSA","13","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ, ꠀꠞ ꠇꠔꠖꠤꠘ? ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠞꠇꠣꠟꠃ ꠚꠣꠃꠞꠤꠀ ꠞꠁꠔꠣꠄ ꠘꠤ? ꠔꠥꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠝꠥꠈ ꠈꠣꠘ ꠀꠞ ꠇꠔꠖꠤꠘ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠟꠥꠇꠣꠁ ꠞꠣꠈꠔꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("PS13_2","020_13_2","PSA","13","2","2","ꠀꠞ ꠇꠔꠖꠤꠘ ꠀꠝꠤ ꠝꠘꠞ ꠌꠤꠘ꠆ꠔꠣꠞ ꠜꠣꠞ, ꠖꠤꠟꠞ ꠇꠡ꠆ꠐꠞ ꠛꠥꠏꠣ ꠙꠞꠔꠤꠖꠤꠘ ꠡꠁꠔꠣꠝ ꠘꠤ? ꠀꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟ ꠇꠔꠖꠤꠘ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠘꠣꠌꠤꠔ? ");
INSERT INTO syls_vpl VALUES ("PS13_3","020_13_3","PSA","13","3","3","ꠅ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠛꠣꠄꠖꠤ ꠌꠣꠅ, ꠝꠣꠛꠥꠖ ꠉ, ꠀꠝꠣꠞ ꠝꠤꠘꠔꠤꠞ ꠎꠥꠀꠙ ꠖꠦꠅ, ꠀꠝꠣꠞ ꠌꠃꠈꠅ ꠛꠟ-ꠞꠥꠡꠘꠤ ꠖꠦꠅ, ꠀꠞꠘꠣꠄ ꠀꠝꠤ ꠢꠄꠔ ꠀꠈꠦꠞꠤ ꠊꠥꠝꠅ ꠙꠠꠤꠎꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS13_4","020_13_4","PSA","13","4","4","ꠛꠣꠖꠦ ꠖꠥꠡꠝꠘꠦ ꠇꠁꠛꠣ, “ꠅꠈꠘ ꠔ ꠀꠝꠞꠣ ꠎꠤꠔꠤ ꠉꠦꠍꠤ,” ꠀꠞ ꠀꠝꠤ ꠅꠡꠢꠣꠄ-ꠝꠣꠎꠥꠞ ꠛꠘꠤꠉꠦꠟꠦ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠗꠤ ꠅꠇꠟꠦ ꠔ ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS13_5","020_13_5","PSA","13","5","5","ꠅꠁꠟꠦ ꠀꠝꠤ ꠜꠞꠡꠣ ꠇꠞꠤ ꠔꠥꠝꠣꠞ ꠖꠄꠀꠞ ꠃꠙꠞꠦꠃ, ꠔꠥꠝꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠛꠣꠄ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠖꠤꠟ ꠈꠥꠡꠤꠄ ꠜꠞꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS13_6","020_13_6","PSA","13","6","6","ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠉꠎꠟ ꠉꠣꠁꠝꠥ, ꠀꠝꠣꠞ ꠜꠣꠟꠣꠁ ꠔ ꠔꠣꠁꠘꠃ ꠇꠞꠍꠂꠘ॥ ");
INSERT INTO syls_vpl VALUES ("PS14_1","020_14_1","PSA","14","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠛꠦꠀꠈꠟꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠄ, “ꠀꠟ꠆ꠟꠣ ꠛꠟꠔꠦ ꠇꠦꠃ ꠘꠣꠁ।” ꠀꠍꠟꠦ ꠔꠣꠞꠣ ꠛꠦꠖꠤꠘ-ꠛꠦꠁꠝꠣꠘ, ꠇꠞꠦꠞ ꠈꠣꠟꠤ ꠎꠊꠁꠘ꠆ꠘ ꠇꠣꠝ, ꠢꠇ ꠇꠣꠝ ꠇꠞꠦ ꠁꠟꠣ ꠇꠦꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS14_2","020_14_2","PSA","14","2","2","ꠀꠞꠡꠦ-ꠀꠎꠤꠝ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠖꠝ ꠎꠣꠔꠤꠞ ꠛꠣꠄ ꠌꠣꠁꠘ, ꠌꠣꠁꠀ ꠖꠦꠈꠂꠘ, ꠢꠣꠍꠣꠞꠞ ꠀꠈꠟꠖꠣꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠀꠍꠦ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠀꠡꠤꠇ-ꠖꠦꠅꠀꠘꠣ ꠇꠦꠃ ꠀꠍꠦ ꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS14_3","020_14_3","PSA","14","3","3","ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠛꠦ-ꠙꠕꠤ ꠅꠁꠉꠦꠍꠦ, ꠢꠇ꠆ꠇꠟ ꠄꠇꠟꠉꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠘꠤꠉꠦꠍꠦ, ꠢꠇ ꠇꠣꠝ ꠇꠞꠦ ꠁꠟꠣ ꠇꠦꠃ ꠘꠣꠁ, ꠄꠇꠎꠘꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS14_4","020_14_4","PSA","14","4","4","ꠅꠃ ꠛꠎ꠆ꠎꠣꠔ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠀꠈꠟ ꠘꠣꠁ ꠘꠤ? ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠈꠣꠘꠣ-ꠈꠣꠁꠖ꠆ꠖ ꠈꠣꠁꠘ, ꠔꠣꠞꠣ ꠅꠟꠣ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣꠞꠦ ꠈꠣꠁꠟꠣꠄ, ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠅ ꠀꠄ ꠘꠣ ꠔꠣꠞꠣꠞ ꠝꠥꠈꠦꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("PS14_5","020_14_5","PSA","14","5","5","ꠔꠣꠞꠣ ꠒꠞꠞ ꠌꠥꠐꠦ ꠕꠞ-ꠕꠞꠣꠁꠀ ꠇꠣꠙꠤꠛꠣ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠔꠣꠘ ꠀꠡꠤꠇꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS14_6","020_14_6","PSA","14","6","6","ꠔꠥꠝꠞꠣꠞ ꠌꠤꠘ꠆ꠔꠣ ꠅꠁꠟ ꠛꠤꠘꠣꠡ ꠇꠞꠣ ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟꠞ ꠀꠡꠣ-ꠜꠞꠡꠣ, ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠃ ꠔꠣꠞꠣꠞ ꠀꠡꠞꠄ ꠑꠤꠇꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS14_7","020_14_7","PSA","14","7","7","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠌꠣꠞ ꠙꠕ ꠍꠤꠅꠘ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠃꠇ! ꠝꠣꠛꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠢꠣꠟꠔ ꠛꠖꠟꠣꠁꠛꠣ, ꠁꠀꠇꠥꠛꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠦ ꠅꠃ ꠡꠝꠄ ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖ ꠇꠞꠛꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠈꠥꠡꠤꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞꠤ ꠉꠣꠁꠛꠣ॥ ");
INSERT INTO syls_vpl VALUES ("PS15_1","020_15_1","PSA","15","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠝꠦꠝꠣꠘ ꠅꠀꠞ ꠇꠦ ꠎꠁꠉ꠆ꠉ, ꠇꠥꠘ ꠝꠣꠘꠥꠡ ꠔꠥꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠙꠣꠠꠅ ꠞꠅꠀꠞ ꠎꠁꠉ꠆ꠉ? ");
INSERT INTO syls_vpl VALUES ("PS15_2","020_15_2","PSA","15","2","2","ꠎꠦ ꠎꠘꠦ ꠘꠤꠈꠥꠔ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠄ, ꠘꠦꠇ ꠀꠝꠟꠦ ꠖꠤꠘ ꠉꠥꠎꠞꠣꠄ, ꠎꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠢꠇ ꠝꠣꠔ ꠛꠣꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("PS15_3","020_15_3","PSA","15","3","3","ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠛꠖꠘꠣꠝ ꠎꠦ ꠎꠘꠦ ꠉꠣꠄ ꠘꠣ, ꠔꠣꠞ ꠇꠥꠘꠥ ꠖꠥꠡ꠆ꠔꠞ ꠈꠦꠔꠤ ꠢꠦ ꠇꠞꠦ ꠘꠣ, ꠀꠞꠤ-ꠚꠞꠤꠞ ꠖꠥꠞꠘꠣꠝꠅ ꠢꠦ ꠞꠐꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS15_4","020_15_4","PSA","15","4","4","ꠇꠥ-ꠙꠕꠤ ꠘꠣꠚꠞꠝꠣꠘ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠄ ꠎꠦ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠙꠤꠀꠞꠣ ꠛꠘ꠆ꠖꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠦ ꠢꠦ, ꠀꠞ ꠘꠤꠎꠞ ꠈꠦꠔꠤ ꠝꠣꠘꠤꠀꠅ ꠅꠀꠖꠣ ꠙꠥꠞꠘ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS15_5","020_15_5","PSA","15","5","5","ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠇꠞꠎ ꠖꠦꠄ ꠡꠥꠖ ꠘꠣ ꠟꠁꠀ, ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞ ꠙꠇ꠆ꠇ ꠟꠄ ꠊꠥꠡ ꠘꠣ ꠈꠣꠁꠀ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠝꠟꠦ ꠌꠟꠦ ꠎꠦꠁ ꠎꠘ, ꠇꠥꠘꠥ ꠖꠤꠘꠃ ꠊꠣꠛꠠꠤꠔ ꠘꠣꠄ ꠢꠃ ꠡꠣꠗꠥ ꠝꠘ॥ ");
INSERT INTO syls_vpl VALUES ("PS16_1","020_16_1","PSA","16","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠚꠞꠤꠀꠖ। ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠢꠦꠚꠣꠎꠔꠦ ꠞꠣꠈꠅ ꠀꠟ꠆ꠟꠣ ꠉ, ꠀꠝꠤ ꠔ ꠀꠡꠞꠄ ꠟꠁꠍꠤ ꠔꠥꠝꠣꠞꠃ ꠖꠞꠛꠣꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS16_2","020_16_2","PSA","16","2","2","ꠝꠣꠛꠥꠖꠞꠦ ꠇꠁꠍꠤ ꠀꠝꠤ, “ꠀꠝꠣꠞꠃ ꠝꠥꠘꠤꠛ ꠔꠥꠝꠤ, ꠔꠥꠝꠤ ꠍꠣꠠꠣ ꠘꠣꠁ ꠔ ꠜꠣꠟꠣꠁ ꠀꠝꠤ ꠘꠤꠌ꠆ꠌꠤꠔ ꠎꠣꠘꠤ।” ");
INSERT INTO syls_vpl VALUES ("PS16_3","020_16_3","PSA","16","3","3","ꠎꠝꠤꠘꠞ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘ꠆ꠖꠣꠁꠘ ꠔꠥꠝꠣꠞ ꠌꠈꠥꠔ ꠁꠎ꠆ꠎꠔꠤ, ꠔꠣꠞꠣꠞ ꠟꠉꠦꠃ ꠀꠝꠣꠞ ꠖꠥꠡ꠆ꠔꠤ ꠀꠞ ꠙꠤꠞꠤꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS16_4","020_16_4","PSA","16","4","4","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠅꠘ꠆ꠘ ꠘꠣꠝ ꠎꠦꠔꠣ ꠎꠘꠦ ꠟꠄ, ꠔꠣꠞꠣꠞ ꠛꠠ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠛꠣꠠꠤꠛ ꠘꠤꠌ꠆ꠌꠄ। ꠎꠦꠔꠣꠞ ꠘꠣꠝꠦ ꠖꠦꠄ ꠔꠣꠞꠣ ꠛꠟꠤꠞ ꠟꠃ ꠛꠤꠟꠣꠁꠀ, ꠁꠔꠣꠞ ꠘꠣꠝ ꠔ ꠟꠁꠔꠣꠝ ꠘꠣꠄ ꠀꠝꠣꠞ ꠝꠥꠈꠦ ꠖꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS16_5","020_16_5","PSA","16","5","5","ꠝꠣꠛꠥꠖꠃ ꠀꠝꠣꠞ ꠗꠘ, ꠀꠝꠣꠞ ꠙꠤꠀꠍꠞ ꠙꠣꠘꠤ, ꠀꠝꠣꠞ ꠇꠙꠣꠟ ꠀꠍꠦ ꠔ ꠔꠣꠘ ꠀꠔꠅꠃ ꠎꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS16_6","020_16_6","PSA","16","6","6","ꠀꠝꠣꠞ ꠛꠣꠐꠅ ꠙꠠꠍꠦ ꠎꠦꠔꠣ ꠖꠃꠟꠔꠞ ꠡꠤꠝꠣꠘꠣ, ꠝꠤꠞꠣꠡꠖꠣꠞꠤ ꠖꠦꠈꠤꠀ ꠌꠃꠈꠦ ꠖꠤꠟ ꠖꠦꠅꠀꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS16_7","020_16_7","PSA","16","7","7","ꠝꠣꠛꠥꠖꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁ! ꠛꠥꠖ꠆ꠖꠤ-ꠙꠞꠣꠝꠤꠡ ꠔ ꠖꠦꠁꠘ ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞꠦ, ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠣꠈꠦ ꠀꠝꠣꠞ ꠛꠤꠛꠦꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("PS16_8","020_16_8","PSA","16","8","8","ꠀꠝꠣꠞ ꠌꠃꠈ ꠢꠣꠝꠦꠡꠣ ꠞꠄ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠄ ꠈꠣꠟꠤ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ, ꠀꠟꠤꠔꠣꠝ ꠘꠣꠄ ꠀꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("PS16_9","020_16_9","PSA","16","9","9","ꠔꠦ ꠈꠥꠡꠤꠄ ꠜꠞꠣ ꠀꠝꠣꠞ ꠖꠤꠟ, ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠦꠞ ꠙꠞꠣꠘ, ꠀꠝꠣꠞ ꠇꠣꠄꠀꠄ ꠜꠞꠡꠣ ꠙꠣꠁꠀ ꠇꠞꠦ ꠡꠣꠘ꠆ꠔꠤ-ꠀꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PS16_10","020_16_10","PSA","16","10","10","ꠀꠝꠣꠞꠦ ꠚꠣꠟꠣꠁꠔꠣꠄ ꠘꠣꠄ ꠔꠥꠝꠤ ꠉꠁꠘ ꠙꠣꠔꠣꠟꠅ, ꠔꠥꠝꠣꠞ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣꠞ ꠇ꠆ꠇꠄ ꠘꠣꠁ ꠔ ꠇꠄꠛꠞꠞ ꠉꠣꠔꠅ। ");
INSERT INTO syls_vpl VALUES ("PS16_11","020_16_11","PSA","16","11","11","ꠖꠦꠈꠣꠁꠞꠣꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠙꠕ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠤ, ꠔꠥꠝꠣꠞ ꠖꠤꠖꠣꠞꠞ ꠝꠣꠎꠦ ꠀꠍꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠚꠥꠞ꠆ꠔꠤ, ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠍꠦ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠡꠥꠈ-ꠡꠣꠘ꠆ꠔꠤ॥ ");
INSERT INTO syls_vpl VALUES ("PS17_1","020_17_1","PSA","17","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠖꠥꠀ ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠢꠇ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠝꠤꠘꠔꠤꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠅ, ꠀꠝꠣꠞ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠅ ꠉ ꠔꠥꠝꠤ, ꠀꠝꠣꠞ ꠝꠥꠈꠅ ꠘꠣꠄ ꠇꠥꠘꠥ ꠍꠟ-ꠌꠔꠥꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS17_2","020_17_2","PSA","17","2","2","ꠀꠝꠣꠞ ꠢꠇ ꠁꠘꠍꠣꠚ ꠔꠥꠝꠣꠞ ꠀꠞꠡ ꠕꠣꠇꠤ ꠀꠃꠇ, ꠔꠥꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠌꠃꠈꠦ ꠢꠇ-ꠢꠣꠟꠣꠟꠤꠞ ꠛꠣꠄ ꠌꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PS17_3","020_17_3","PSA","17","3","3","ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠈꠛꠞ ꠟꠁꠟꠦ, ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣꠅ ꠎꠣꠌꠣꠁ ꠇꠞꠟꠦ, ꠢꠥꠘꠣꠞꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠇꠣꠁꠟꠦꠅ ꠈꠣꠖ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ, ꠘꠤꠅꠔ ꠇꠞꠍꠤ ꠝꠥꠈꠖꠤ ꠔ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS17_4","020_17_4","PSA","17","4","4","ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠇꠞꠦ ꠛꠖ ꠇꠣꠝ ꠀꠝꠤ ꠁꠟꠣ ꠇꠞꠤ ꠘꠣ, ꠎꠣꠟꠤꠝꠞ ꠙꠕ ꠢꠞꠣꠁꠀ ꠕꠁ ꠔꠥꠝꠣꠞ ꠙꠣꠇ ꠛꠥꠟꠤ ꠢꠥꠘꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS17_5","020_17_5","PSA","17","5","5","ꠀꠝꠣꠞ ꠙꠣꠅꠞꠦ ꠡꠇ꠆ꠔ ꠇꠞꠍꠤ ꠔꠥꠝꠣꠞ ꠙꠕꠅ ꠞꠁꠔ, ꠟꠠꠍꠦ ꠘꠣ ꠝꠞ ꠙꠣꠅ ꠖꠥꠈꠣꠘ ꠄꠇ ꠌꠥꠟ ꠙꠞꠤꠝꠣꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("PS17_6","020_17_6","PSA","17","6","6","ꠀꠟ꠆ꠟꠣ ꠔꠥꠝꠤ ꠢꠥꠘꠛꠣꠄ ꠇꠞꠤꠃ ꠔꠥꠝꠣꠞꠦ ꠒꠣꠇꠤꠀꠞ, ꠇꠣꠘ ꠙꠣꠔꠤꠀ ꠢꠥꠘꠅ ꠛꠘ꠆ꠖꠥ ꠚꠞꠤꠀꠖ ꠀꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS17_7","020_17_7","PSA","17","7","7","ꠇꠔ ꠀꠌꠣꠘꠇ ꠖꠦꠈꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀ, ꠅꠃ ꠝꠤꠘꠔꠤ ꠇꠞꠅ ꠇꠛꠥꠟ ꠅꠉ ꠖꠄꠀꠟ ꠀꠟ꠆ꠟꠣ, ꠛꠣꠌꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠡꠞꠄ ꠟꠄ ꠎꠣꠞꠣ, ꠖꠥꠡꠝꠘ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠅ ꠔꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠀꠔ ꠖꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS17_8","020_17_8","PSA","17","8","8","ꠌꠈꠥꠞ ꠝꠘꠤ ꠎꠦꠟꠣ ꠘꠤꠞꠣꠙꠖ ꠅꠟꠣ ꠞꠣꠈꠅ ꠀꠝꠣꠞꠦ, ꠀꠝꠣꠞꠦ ꠟꠥꠇꠣꠅ ꠔꠥꠝꠣꠞ ꠒꠣꠈꠘꠣꠞ ꠔꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("PS17_9","020_17_9","PSA","17","9","9","ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠉꠥꠁꠘ ꠀꠁꠀ ꠛꠦꠞꠤꠟꠤꠍꠂꠘ ꠝꠞꠦ, ꠅꠟꠣ ꠎꠣꠟꠤꠝ-ꠛꠎ꠆ꠎꠣꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠅ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS17_10","020_17_10","PSA","17","10","10","ꠔꠣꠞꠣꠞ ꠅꠡꠣꠠ ꠖꠤꠟꠞ ꠖꠥꠀꠞ ꠔꠣꠟꠣ ꠝꠣꠞꠤ ꠞꠣꠈꠦ, ꠔꠣꠞꠣꠞ ꠎꠛꠣꠘ ꠜꠞꠣ ꠈꠣꠟꠤ ꠛꠦꠐꠣꠉꠤꠞꠤꠞ ꠝꠣꠔꠦ। ");
INSERT INTO syls_vpl VALUES ("PS17_11","020_17_11","PSA","17","11","11","ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠀ ꠔꠣꠞꠣ ꠛꠦꠞꠤꠟꠤꠍꠦ ꠝꠞꠦ, ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠁ ꠝꠣꠞꠔ ꠇꠞꠤ ꠇꠠꠣ ꠘꠎꠞ ꠞꠣꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("PS17_12","020_17_12","PSA","17","12","12","ꠡꠤꠇꠣꠞꠤ ꠡꠤꠋꠢꠄ ꠎꠦꠟꠣ ꠈꠣꠙ ꠗꠞꠤꠀ ꠞꠄ ꠛꠘꠅ, ꠔꠣꠞꠣ ꠅꠟꠣ ꠟꠥꠇꠣꠁ ꠛꠁꠍꠦ ꠀꠝꠣꠞ ꠎꠣꠘ ꠘꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("PS17_13","020_17_13","PSA","17","13","13","ꠀꠅ ꠉ ꠝꠣꠛꠥꠖ, ꠎꠣꠟꠤꠝꠞꠦ ꠀꠐꠇꠣꠁꠀ ꠝꠣꠐꠤꠔ ꠢꠥꠔꠣꠁꠟꠣꠅ, ꠔꠥꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠔꠟꠥꠀꠞ ꠖꠤꠀ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS17_14","020_17_14","PSA","17","14","14","ꠔꠥꠝꠣꠞ ꠀꠔꠦ ꠛꠣꠌꠣꠅ ꠝꠣꠛꠥꠖ ꠅꠔꠣ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ, ꠖꠥꠘꠤꠀꠈꠥꠞꠞ ꠇꠛꠎꠣ ꠕꠣꠇꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠅ ꠔꠥꠝꠤ। ꠔꠣꠞꠣꠞ ꠝꠘꠞ ꠀꠡꠣ ꠈꠣꠟꠤ ꠅꠃ ꠎꠉꠔꠞ ꠃꠙꠞꠦ, ꠔꠣꠞꠣꠞ ꠙꠦꠐ ꠜꠞꠣꠅ ꠔꠥꠝꠣꠞ ꠟꠣꠘ꠆ꠘꠔꠤ ꠉꠎꠛꠦ। ꠅꠔꠣ ꠈꠣꠁꠀ ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖꠦ ꠙꠦꠐ ꠜꠞꠤꠟꠣꠃꠇ, ꠅꠔꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠇꠤ ꠅꠋꠡ ꠛꠦꠡ ꠇꠞꠤ ꠕꠁꠀ ꠎꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PS17_15","020_17_15","PSA","17","15","15","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠣꠘꠥ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠞꠁ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ, ꠢꠎꠣꠉ ꠅꠁꠀ ꠡ꠆ꠛꠣꠖ ꠝꠤꠐꠣꠁꠀ ꠞꠁꠝꠥ ꠔꠥꠝꠣꠞ ꠖꠤꠖꠣꠞꠅ॥ ");
INSERT INTO syls_vpl VALUES ("PS18_1","020_18_1","PSA","18","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠝꠣꠛꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠛꠣꠖꠡꠣ ꠔꠣꠟꠥꠔ ꠀꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟ ꠖꠥꠡꠝꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠖꠣꠃꠖꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠖꠣꠃꠖꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠅꠃ ꠝꠤꠎꠝꠞ ꠉꠣꠁꠟꠣ। ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠃ ꠀꠡꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("PS18_2","020_18_2","PSA","18","2","2","ꠀꠟ꠆ꠟꠣꠃ ꠀꠝꠣꠞ ꠘꠤꠞꠣꠙꠖ ꠝꠤꠘꠣꠞ, ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠝꠣꠟꠤꠇ, ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠙꠣꠠ, ꠔꠣꠘ ꠍꠣꠄꠀꠔ ꠀꠡꠞꠄ ꠟꠁꠍꠤ। ꠎꠥꠖ꠆ꠖꠞ ꠝꠄꠖꠣꠘꠅ ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞ ꠓꠣꠟ, ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔ, ꠀꠝꠣꠞ ꠀꠡꠞꠄ ꠝꠥꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PS18_3","020_18_3","PSA","18","3","3","ꠉꠥꠘꠉꠣꠘ ꠙꠣꠅꠀꠞ ꠟꠣꠈ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝ ꠟꠁꠝꠥ, ꠔꠦꠃ ꠖꠥꠡꠝꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠝꠤ ꠎꠣꠘꠦ ꠛꠣꠌꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS18_4","020_18_4","PSA","18","4","4","ꠝꠞꠘꠞ ꠖꠠꠤꠄ ꠙꠦꠌꠣꠁꠟꠤꠍꠤꠟ ꠀꠝꠣꠞꠦ, ꠡꠞ꠆ꠛꠘꠣꠡꠣ ꠚꠥꠔꠞ ꠙꠣꠘꠤꠔ ꠒꠥꠛꠣꠁꠟꠤꠍꠤꠟ ꠝꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("PS18_5","020_18_5","PSA","18","5","5","ꠙꠣꠔꠣꠟꠞ ꠖꠠꠤ ꠖꠤꠀ ꠅꠁꠍꠤꠟ ꠝꠞꠦ ꠛꠣꠘ꠆ꠖꠣ, ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠅꠁꠍꠤꠟ ꠇꠄꠛꠞꠞ ꠉꠣꠔ ꠈꠥꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_6","020_18_6","PSA","18","6","6","ꠅꠟꠣꠈꠣꠘ ꠛꠤꠙꠖꠅ ꠙꠠꠤꠀ ꠝꠣꠛꠥꠖꠞꠦ ꠒꠣꠇꠤꠟꠣꠝ, ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠔꠣꠘ ꠡꠣꠁꠎ꠆ꠎ ꠀꠝꠤ ꠝꠣꠋꠉꠤꠟꠣꠝ, ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠀꠞꠡ ꠕꠣꠇꠤ ꠢꠥꠘꠟꠣ ꠀꠝꠣꠞ ꠒꠣꠇ, ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠟ ꠀꠝꠣꠞ ꠚꠞꠤꠀꠖ। ");
INSERT INTO syls_vpl VALUES ("PS18_7","020_18_7","PSA","18","7","7","ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀ ꠇꠣꠙꠤꠀ ꠕꠞ-ꠕꠞꠣꠘꠤ ꠗꠞꠟ, ꠙꠣꠠ-ꠐꠤꠟ꠆ꠟꠣꠞ ꠜꠤꠔ ꠅꠇꠟ ꠟꠠꠣ-ꠌꠠꠣ ꠇꠞꠟ, ꠉꠥꠍꠣꠞ ꠀꠉꠥꠁꠘꠦ ꠔꠣꠘ ꠁꠔꠣꠄ ꠔ ꠇꠣꠙꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("PS18_8","020_18_8","PSA","18","8","8","ꠘꠣꠇꠦꠖꠤ ꠛꠣꠞ ꠅꠁꠟ ꠔꠣꠘ ꠉꠥꠍꠣꠞ ꠉꠞꠝ ꠗꠥꠝꠣ, ꠝꠥꠈ ꠕꠣꠇꠤ ꠀꠁꠟ ꠔꠣꠘ ꠀꠉꠥꠘꠤꠞ ꠟꠥꠇ꠆ꠇꠣ, ꠀꠞꠅ ꠔ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟ ꠎꠣꠟꠣꠁꠟ ꠀꠋꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_9","020_18_9","PSA","18","9","9","ꠀꠍꠝꠣꠘꠞꠦ ꠟꠣꠝꠣꠁꠀ ꠔꠣꠁꠘ ꠔꠟꠦ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ, ꠔꠣꠘ ꠇꠖꠝꠞ ꠔꠟꠦ ꠀꠍꠤꠟ ꠊꠘ ꠇꠣꠟꠣ ꠝꠦꠊꠞ ꠌꠣꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_10","020_18_10","PSA","18","10","10","ꠔꠣꠁꠘ ꠇꠣꠞꠥꠛꠤꠞ ꠃꠙꠞꠦ ꠌꠠꠤꠀ ꠃꠠꠣꠟ ꠖꠤꠟꠣ, ꠛꠣꠔꠣꠡꠞ ꠒꠣꠈꠘꠣꠔ ꠜꠞ ꠖꠤꠀ ꠃꠠꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_11","020_18_11","PSA","18","11","11","ꠔꠣꠁꠘ ꠀꠘ꠆ꠖꠣꠁꠞꠞ ꠜꠤꠔꠞꠦ ꠘꠤꠎꠞꠦ ꠀꠅꠠ ꠇꠞꠤꠟ꠆ꠟꠣ, ꠊꠘ ꠝꠦꠊꠞ ꠌꠣꠇꠣꠄ ꠔꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠔꠣꠝ꠆ꠛꠥ ꠉꠥꠞꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_12","020_18_12","PSA","18","12","12","ꠘꠥꠞꠞ ꠎꠤꠟꠇꠤꠄ ꠔꠣꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠝꠦꠊ ꠢꠞꠤ ꠉꠦꠟ, ꠝꠦꠊꠞ ꠢꠤꠟ ꠀꠞ ꠎꠣꠟꠣꠁꠟ ꠀꠋꠞꠣ ꠎꠝꠤꠘꠅ ꠙꠠꠟ। ");
INSERT INTO syls_vpl VALUES ("PS18_13","020_18_13","PSA","18","13","13","ꠝꠣꠛꠥꠖꠦ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠉꠞ꠆ꠎꠤꠀ ꠃꠑꠤꠟꠣ, ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠄ ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_14","020_18_14","PSA","18","14","14","ꠔꠣꠘ ꠗꠘꠥꠇꠞ ꠔꠤꠞ ꠝꠣꠞꠤꠀ ꠖꠥꠡꠝꠘꠞꠦ ꠍꠤꠔꠞꠣꠁꠟ꠆ꠟꠣ, ꠝꠦꠊꠞ ꠎꠤꠟꠇꠣꠘꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠛꠦꠚꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_15","020_18_15","PSA","18","15","15","ꠔꠥꠝꠣꠞ ꠗꠝꠇꠦ ꠀꠞ ꠘꠣꠇꠞ ꠡ꠆ꠛꠣꠡꠦ, ꠝꠣꠛꠥꠖ ꠉ, ꠖꠞꠤꠀꠞ ꠝꠥꠞꠞ ꠙꠣꠘꠤꠞ ꠚꠥꠔ ꠅꠇꠟ ꠖꠦꠈꠣ ꠖꠤꠟ, ꠎꠉꠔꠞ ꠝꠥꠟ ꠜꠤꠔ ꠅꠇꠟꠅ ꠃꠖꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("PS18_16","020_18_16","PSA","18","16","16","ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠔꠣꠁꠘ ꠝꠞꠦ ꠗꠞꠟꠣ, ꠉꠁꠘ ꠙꠣꠘꠤ ꠕꠘꠦ ꠀꠝꠣꠞꠦ ꠐꠣꠘꠤꠀ ꠔꠥꠟꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_17","020_18_17","PSA","18","17","17","ꠛꠣꠌꠣꠁꠟꠣ ꠀꠝꠣꠞꠦ ꠔꠣꠁꠘ ꠙꠄꠟꠥꠀꠘ ꠖꠥꠡꠝꠘ ꠕꠣꠇꠤ, ꠛꠣꠌꠣꠁꠟꠣ ꠖꠥꠡꠝꠘ-ꠞꠤꠙꠥ ꠅꠇꠟꠞ ꠇꠛꠎꠣ ꠕꠣꠇꠤ, ꠎꠦꠔꠣꠞ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔ ꠔ ꠀꠝꠣꠞ ꠕꠣꠇꠤꠅ ꠛꠃꠔ ꠛꠦꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("PS18_18","020_18_18","PSA","18","18","18","ꠀꠝꠣꠞ ꠝꠍꠤꠛꠔꠞ ꠖꠤꠘꠅ-ꠅ ꠔꠣꠞꠣ ꠝꠞꠦ ꠝꠣꠞꠣꠔ ꠀꠁꠟꠣ, ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔ ꠀꠝꠣꠞ ꠡꠢꠣꠄ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_19","020_18_19","PSA","18","19","19","ꠈꠥꠟꠣ ꠝꠄꠖꠣꠘꠅ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣ, ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠡ ꠅꠀꠄ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_20","020_18_20","PSA","18","20","20","ꠝꠣꠛꠥꠖꠦ ꠖꠤꠟꠣ ꠀꠝꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠛꠖꠟꠣ, ꠀꠝꠣꠞ ꠀꠔꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠛꠈꠡꠤꠡ ꠔꠣꠁꠘ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_21","020_18_21","PSA","18","21","21","ꠝꠣꠛꠥꠖꠞ ꠙꠕꠦꠃ ꠌꠟꠍꠤ ꠀꠝꠤ, ꠇꠞꠍꠤ ꠘꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ, ꠁꠟꠣ ꠇꠣꠝ ꠇꠞꠍꠤ ꠘꠣ ꠎꠦꠔꠣꠄ ꠢꠞꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠖꠤꠖꠣꠞ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("PS18_22","020_18_22","PSA","18","22","22","ꠔꠣꠘ ꠔꠣꠝꠣꠝ ꠢꠇ-ꠚꠄꠍꠣꠟꠣ ꠀꠝꠣꠞ ꠌꠈꠥꠞ ꠀꠄꠘꠣ, ꠀꠝꠤ ꠔ ꠔꠣꠘ ꠢꠥꠇꠥꠝꠞ ꠇꠥꠘꠥ ꠈꠦꠟꠣꠚ ꠇꠞꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_23","020_18_23","PSA","18","23","23","ꠔꠣꠘ ꠘꠎꠞꠅ ꠀꠝꠤ ꠘꠤꠈꠥꠔ ꠞꠁꠍꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ, ꠉꠥꠘꠣ-ꠘꠣꠚꠞꠝꠣꠘꠤ ꠕꠣꠇꠤ ꠘꠤꠎꠞꠦ ꠞꠣꠈꠍꠤ ꠢꠞꠣꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("PS18_24","020_18_24","PSA","18","24","24","ꠄꠞꠖꠣꠄ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠖꠤꠍꠂꠘ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ, ꠀꠝꠣꠞ ꠘꠦꠇ ꠇꠣꠝ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠇꠞꠍꠂꠘ ꠅꠃ ꠛꠤꠌꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS18_25","020_18_25","PSA","18","25","25","ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠞꠣꠞꠦ ꠔꠥꠝꠤꠅ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞ, ꠈꠣꠐꠤ ꠛꠘ꠆ꠖꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠤꠅ ꠈꠣꠐꠤ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS18_26","020_18_26","PSA","18","26","26","ꠘꠤꠞꠜꠦꠎꠣꠟꠤꠞ ꠛꠣꠄ ꠔꠥꠝꠤꠅ ꠘꠤꠞꠜꠦꠎꠣꠟ, ꠀꠞ ꠇꠝꠤꠘꠞꠦ ꠖꠦꠈꠣꠅ ꠔꠥꠝꠣꠞ ꠙꠦꠌꠞ ꠚꠣꠘ꠆ꠖ। ");
INSERT INTO syls_vpl VALUES ("PS18_27","020_18_27","PSA","18","27","27","ꠘꠞꠝ ꠖꠤꠟꠞ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠝꠤꠃ ꠛꠣꠌꠣꠅ, ꠅꠁꠟꠦ ꠛꠠꠣꠁ-ꠉꠞꠤꠝꠣ ꠖꠦꠈꠣꠅꠞꠣꠞꠦ ꠔꠟꠦꠖꠤ ꠟꠣꠝꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS18_28","020_18_28","PSA","18","28","28","ꠈꠣꠟꠤ ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠄ ꠚꠞ ꠇꠞꠅ ꠀꠝꠣꠞ ꠝꠥꠡꠣꠟꠞꠦ, ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖꠦ ꠃꠎꠤꠟꠣ ꠇꠞꠂꠘ ꠀꠝꠣꠞ ꠀꠘ꠆ꠖꠣꠁꠞꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS18_29","020_18_29","PSA","18","29","29","ꠔꠥꠝꠣꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠖꠥꠡꠝꠘꠞ ꠍꠤꠙꠣꠁ ꠖꠟꠞꠦ ꠀꠞꠣꠁꠝꠥ, ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠟꠉꠦ ꠃꠌꠣ ꠖꠦꠅꠀꠟꠅ ꠚꠣꠟꠖꠤ ꠙꠣꠞ ꠅꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS18_30","020_18_30","PSA","18","30","30","ꠔꠣꠁꠘꠃ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠘ ꠙꠕ ꠔ ꠘꠤꠈꠥꠔ, ꠝꠣꠛꠥꠖꠞ ꠎꠛꠣꠘ ꠅꠇ꠆ꠇꠄ। ꠔꠣꠘ ꠉꠦꠍꠦ ꠎꠔ ꠎꠘꠦ ꠀꠡꠞꠄ ꠟꠂꠘ, ꠔꠣꠁꠘꠃ ꠔꠣꠞꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠀꠔꠤꠀꠞ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS18_31","020_18_31","PSA","18","31","31","ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠀꠞ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠛꠥꠖ ꠀꠍꠦ ꠘꠤ? ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠛꠣꠖꠦ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠀꠡꠞꠄ ꠙꠣꠠ ꠝꠤꠟꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("PS18_32","020_18_32","PSA","18","32","32","ꠀꠟ꠆ꠟꠣꠄꠃ ꠀꠝꠣꠞ ꠇꠝꠞꠅ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠍꠂꠘ, ꠔꠣꠁꠘ ꠔ ꠀꠝꠣꠞ ꠌꠟꠣꠞ ꠙꠕ ꠘꠤꠈꠥꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS18_33","020_18_33","PSA","18","33","33","ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠙꠣꠅꠞꠦ ꠖꠤꠍꠂꠘ ꠅꠞꠤꠘꠞ ꠟꠣꠈꠣꠘ ꠢꠦꠇꠝꠔ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠐꠤꠇꠣꠁ ꠞꠣꠈꠂꠘ ꠙꠣꠠꠤꠀ ꠇꠑꠤꠘ ꠐꠤꠟ꠆ꠟꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("PS18_34","020_18_34","PSA","18","34","34","ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞ ꠀꠔꠞꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠞ ꠇꠟꠣ-ꠇꠃꠡꠟ ꠢꠤꠇꠣꠁꠘ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠀꠔꠦ ꠙꠤꠔꠟꠞ ꠔꠤꠞ-ꠗꠘꠥꠇꠞꠦꠅ ꠛꠦꠇꠣ ꠇꠞꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS18_35","020_18_35","PSA","18","35","35","ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠀꠔꠤꠀꠞ ꠖꠣꠘ ꠇꠞꠍ, ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠀꠔꠖꠤ ꠀꠝꠣꠞꠦ ꠗꠞꠤꠀ ꠞꠣꠈꠍ, ꠔꠥꠝꠣꠞ ꠖꠦꠅꠀ ꠘꠞꠝ ꠝꠘꠦ ꠀꠝꠤ ꠅꠁꠍꠤ ꠛꠠ। ");
INSERT INTO syls_vpl VALUES ("PS18_36","020_18_36","PSA","18","36","36","ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠌꠟꠣꠞ ꠙꠕꠞꠦ ꠇꠞꠍ ꠡꠥꠎꠣ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠙꠣꠅ ꠔ ꠙꠤꠍꠟꠤꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_37","020_18_37","PSA","18","37","37","ꠀꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠖꠟꠞ ꠈꠞꠦ ꠖꠃꠠꠣꠁꠀ ꠁꠔꠣꠞꠦ ꠗꠞꠍꠤ, ꠅꠔꠣꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠘꠣ ꠇꠞꠤꠀ ꠀꠝꠤ ꠚꠤꠞꠔ ꠘꠣ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("PS18_38","020_18_38","PSA","18","38","38","ꠌꠥꠞꠝꠣꠞ ꠇꠞꠍꠤ ꠔꠣꠞꠣꠞꠦ, ꠃꠛꠣꠁꠔ ꠀꠞ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠙꠤꠡꠤꠍꠤ ꠔꠣꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS18_39","020_18_39","PSA","18","39","39","ꠎꠥꠖ꠆ꠖꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠇꠝꠞꠅ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠍ, ꠀꠝꠣꠞ ꠛꠤꠞꠥꠗꠤ ꠍꠤꠙꠣꠁꠞꠦ ꠀꠝꠣꠞ ꠙꠣꠅꠔ ꠚꠣꠟꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("PS18_40","020_18_40","PSA","18","40","40","ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠖꠟꠞꠦ ꠜꠣꠉꠣꠁꠍ ꠍꠣꠝꠘ ꠕꠣꠇꠤ, ꠀꠝꠣꠞꠦ ꠎꠦꠔꠣꠄ ꠁꠋꠡꠣꠁꠘ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("PS18_41","020_18_41","PSA","18","41","41","ꠛꠣꠌꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠍꠤꠟ, ꠛꠣꠌꠣꠘꠤꠔ ꠇꠦꠃ ꠀꠁꠍꠤꠟ ꠘꠣ, ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠡꠣꠁꠎ꠆ꠎ ꠌꠣꠁꠍꠤꠟ, ꠔꠣꠁꠘꠅ ꠁꠔꠣ ꠢꠥꠘꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS18_42","020_18_42","PSA","18","42","42","ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠝꠣꠞꠤꠀ ꠗꠥꠁꠟ-ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠔꠣꠡꠅ ꠃꠠꠣꠁꠟꠣꠝ, ꠙꠕꠞ ꠛꠣꠖꠣ-ꠍꠣꠖꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠔꠣꠞꠦ ꠢꠞꠣꠁꠀ ꠚꠣꠟꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PS18_43","020_18_43","PSA","18","43","43","ꠅ ꠝꠣꠛꠥꠖ, ꠝꠣꠘꠡꠞ ꠉꠘ꠆ꠒꠉꠥꠟ ꠕꠣꠇꠤ ꠔꠥꠝꠤꠃ ꠛꠣꠌꠣꠁꠍ ꠀꠝꠣꠞꠦ, ꠀꠝꠣꠞꠦ ꠌꠣꠟꠇꠖꠣꠞ ꠛꠣꠘꠣꠁꠍ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ, ꠅꠈꠘ ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠦꠞ ꠅꠌꠤꠘꠣ ꠎꠣꠔꠤꠄ। ");
INSERT INTO syls_vpl VALUES ("PS18_44","020_18_44","PSA","18","44","44","ꠀꠝꠣꠞ ꠘꠣꠝ ꠢꠥꠘꠟꠦꠃ ꠔꠣꠞꠣ ꠀꠁꠅꠁꠘ ꠀꠝꠣꠞ ꠔꠟꠦ, ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS18_45","020_18_45","PSA","18","45","45","ꠢꠃ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟ ꠘꠤꠞꠣꠡ ꠅꠁꠀ ꠎꠣꠄ, ꠔꠣꠞꠣ ꠛꠣꠋꠇꠣꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠇꠣꠙꠤ ꠇꠣꠙꠤ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("PS18_46","020_18_46","PSA","18","46","46","ꠝꠣꠛꠥꠖ ꠔ ꠎꠤꠘ꠆ꠖꠣ! ꠀꠝꠣꠞ ꠀꠡꠞꠄ ꠙꠣꠠꠞ ꠔꠣꠞꠤꠚ ꠅꠃꠇ! ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠅꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠁꠎ꠆ꠎꠔ-ꠔꠣꠎꠤꠝ ꠛꠣꠠꠃꠇ! ");
INSERT INTO syls_vpl VALUES ("PS18_47","020_18_47","PSA","18","47","47","ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦ ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠅꠗꠤꠘꠦ ꠀꠘꠂꠘ, ꠔꠣꠁꠘꠃ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠛꠖꠟꠣ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS18_48","020_18_48","PSA","18","48","48","ꠖꠥꠡꠝꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠘ, ꠔꠥꠝꠤꠃ ꠀꠟ꠆ꠟꠣ, ꠛꠤꠙꠇ꠆ꠇ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞꠦ ꠔꠥꠟꠍ, ꠁꠋꠡꠣ-ꠉꠘ꠆ꠒꠉꠥꠟ ꠇꠞꠞꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("PS18_49","020_18_49","PSA","18","49","49","ꠄꠞꠟꠣꠉꠤ ꠅ ꠝꠣꠛꠥꠖ, ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠝꠥ, ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠣꠞ ꠙꠣꠇ ꠘꠣꠝꠞ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS18_50","020_18_50","PSA","18","50","50","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠛꠣꠖꠡꠣꠞꠦ ꠛꠃꠔ ꠛꠣꠞ ꠝꠢꠣ ꠎꠄꠁ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠅꠀ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖ ꠀꠞ ꠔꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠖꠄꠀ-ꠝꠣꠄꠀꠔ ꠞꠣꠈꠍꠂꠘ॥ ");
INSERT INTO syls_vpl VALUES ("PS19_1","020_19_1","PSA","19","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠀꠍꠝꠣꠘ ꠅꠇꠟꠦ ꠛꠄꠀꠘ ꠇꠞꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠢꠤꠝꠣ, ꠌꠣꠘ-ꠡꠥꠞꠥꠎ ꠉ꠆ꠞꠢ-ꠔꠦꠞꠣꠄ ꠖꠦꠈꠣꠄ ꠔꠣꠘ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS19_2","020_19_2","PSA","19","2","2","ꠖꠤꠘꠦ ꠖꠤꠘꠦ ꠉꠣꠄ ꠔꠣꠘ ꠎꠣꠟꠣꠟ ꠀꠞ ꠡꠣꠘ, ꠞꠣꠁꠔꠦ ꠞꠣꠁꠔꠦ ꠢꠤꠇꠣꠄ ꠔꠣꠘ ꠀꠈꠟꠞ ꠛꠄꠀꠘ। ");
INSERT INTO syls_vpl VALUES ("PS19_3","020_19_3","PSA","19","3","3","ꠘꠣꠁ ꠇꠥꠘꠥ ꠝꠣꠔ-ꠇꠕꠣ ꠘꠣꠁ ꠇꠥꠘꠥ ꠛꠥꠟꠤ, ꠀꠅꠀꠎ-ꠡꠥꠞ ꠎꠣꠄ ꠘꠣ ꠢꠥꠘꠣ ꠄꠞꠣꠞ ꠝꠥꠈꠅ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("PS19_4","020_19_4","PSA","19","4","4","ꠔꠣ-ꠅ ꠔꠣꠞꠣꠞ ꠀꠅꠀꠎ ꠝꠤꠟꠦ ꠖꠥꠘꠤꠀꠁ ꠎꠥꠠꠤ, ꠙꠥꠛ ꠙꠌꠤꠝ ꠃꠔ꠆ꠔꠞ ꠖꠇ꠆ꠇꠤꠘ ꠢꠣꠞꠣ ꠎꠉꠔ ꠜꠞꠤ। ꠉꠣꠠꠤꠟꠣ ꠀꠟ꠆ꠟꠣꠄ ꠅꠘꠅ ꠡꠥꠞꠥꠎꠞ ꠛꠡꠔ ꠊꠞ, ꠔꠣꠝ꠆ꠛꠥꠞ ꠝꠣꠎꠦ ꠞꠁꠀ ꠡꠥꠞꠥꠎ ꠇꠞꠦ ꠎꠉꠔ ꠚꠞ। ");
INSERT INTO syls_vpl VALUES ("PS19_5","020_19_5","PSA","19","5","5","ꠛꠣꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠘ ꠎꠦꠟꠣ ꠘꠄꠀ ꠛꠤꠀꠔꠤ ꠖꠣꠝꠣꠘ꠆ꠖ, ꠖꠃꠠꠣꠁ ꠖꠃꠠꠣꠁ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠂꠘ ꠎꠄꠁ ꠎꠘꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS19_6","020_19_6","PSA","19","6","6","ꠀꠍꠝꠣꠘꠞ ꠄꠇ ꠇꠤꠘꠣꠞ ꠕꠣꠇꠤ ꠎꠣꠁꠘ ꠀꠞꠇ ꠇꠤꠘꠣꠞꠅ, ꠁꠐꠣꠞ ꠉꠞꠝ ꠕꠣꠇꠤ ꠡꠣꠁꠖ꠆ꠖ ꠘꠣꠁ ꠇꠥꠘꠥ ꠇꠤꠌ꠆ꠍꠥ ꠟꠥꠇꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("PS19_7","020_19_7","PSA","19","7","7","ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠢꠦꠖꠣꠄꠅꠔ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ, ꠛꠘ꠆ꠖꠣꠞ ꠎꠣꠘꠞꠦ ꠇꠞꠦ ꠁꠈꠣꠘ ꠔꠞꠔꠣꠎꠣ ꠝꠎꠛꠥꠔ। ꠀꠟ꠆ꠟꠣꠞ ꠚꠞꠝꠣꠘ ꠢꠇ ꠀꠞ ꠡꠑꠤꠇ ꠌꠤꠞꠇꠣꠟ ꠛꠅꠀꠁꠟ, ꠛꠦꠀꠈꠟ ꠎꠘꠞꠦ ꠛꠣꠘꠣꠄ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠈꠟꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS19_8","020_19_8","PSA","19","8","8","ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠘꠤꠅꠝ-ꠘꠤꠔꠤ ꠡꠑꠤꠇ ꠢꠣꠝꠦꠡꠣ, ꠝꠘꠞ ꠝꠣꠎꠦ ꠎꠥꠉꠣꠄ ꠁꠔꠣꠄ ꠈꠥꠡꠤꠞ ꠚꠥꠀꠞꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠔ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ, ꠃꠎꠤꠟꠣ ꠇꠞꠦ ꠁꠔꠣꠄ ꠖꠤꠟꠞ ꠌꠃꠈ ꠀꠝꠞꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS19_9","020_19_9","PSA","19","9","9","ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚ ꠔ ꠘꠤꠈꠥꠔ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠣꠞꠤ, ꠙꠥꠞꠣꠙꠥꠞ ꠡꠑꠤꠇ ꠞꠣꠄ ꠖꠦꠁꠘ ꠢꠇ-ꠁꠘꠍꠣꠚꠇꠣꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("PS19_10","020_19_10","PSA","19","10","10","ꠡꠥꠘꠣ ꠕꠣꠇꠤꠅ ꠛꠃꠔ ꠖꠣꠝꠤ, ꠝꠥꠟ꠆ꠟꠛꠣꠘ ꠀꠞ ꠈꠣꠐꠤ, ꠝꠃꠌꠣꠇꠞ ꠚꠥꠐꠣ ꠙꠠꠣ ꠝꠃ ꠕꠣꠇꠤꠅ ꠝꠤꠡ꠆ꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("PS19_11","020_19_11","PSA","19","11","11","ꠔꠥꠝꠣꠞ ꠁ ꠉꠥꠟꠣꠝꠦ ꠅꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠥꠡꠤꠀꠞ ꠞꠄ, ꠀꠝꠟ ꠇꠞꠟꠦ ꠁꠔꠣ ꠘꠤꠌ꠆ꠌꠄ ꠛꠃꠔ ꠚꠣꠄꠖꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("PS19_12","020_19_12","PSA","19","12","12","ꠛꠘ꠆ꠖꠣꠄ ꠇꠥꠘꠥ ꠘꠤꠎꠞ ꠜꠥꠟ ꠘꠤꠎꠦꠃ ꠛꠥꠎꠦ ꠘꠤ? ꠛꠦꠈꠤꠀꠟꠦ ꠇꠞꠣ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠝꠣꠚꠤ ꠝꠣꠋꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("PS19_13","020_19_13","PSA","19","13","13","ꠝꠘꠞ ꠉꠞꠤꠝꠣꠄ ꠇꠞꠣ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠅ ꠀꠝꠣꠞꠦ, ꠁꠔꠣꠄ ꠎꠣꠘꠥ ꠇꠛꠎꠣ ꠇꠞꠔ ꠘꠣ ꠙꠣꠞꠦ ꠝꠞꠦ। ꠔꠦꠃꠉꠤ ꠀꠝꠤ ꠘꠦꠇꠇꠣꠞ ꠛꠘ꠆ꠖꠣ ꠛꠘꠤꠔꠣꠝ ꠙꠣꠞꠝꠥ, ꠛꠠ ꠛꠠ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠝꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS19_14","020_19_14","PSA","19","14","14","ꠔꠞꠣꠘꠦꠀꠟꠣ ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠀꠡꠞꠄ ꠐꠤꠟ꠆ꠟꠣ, ꠖꠤꠟꠞ ꠗꠤꠀꠘ ꠝꠥꠈꠞ ꠎꠛꠣꠘ ꠇꠛꠥꠟ ꠇꠞꠅ ꠉ ꠀꠟ꠆ꠟꠣ॥ ");
INSERT INTO syls_vpl VALUES ("PS20_1","020_20_1","PSA","20","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠝꠍꠤꠛꠔꠞ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠁꠀꠇꠥꠛꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠔꠥꠝꠣꠞꠦ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠞꠣꠈꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS20_2","020_20_2","PSA","20","2","2","ꠔꠣꠘ ꠙꠣꠇ ꠝꠥꠇꠣꠝ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠁꠎ꠆ꠎ ꠙꠣꠑꠣꠃꠇ꠆ꠇꠣ, ꠙꠛꠤꠔ꠆ꠞ ꠍꠤꠅꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔ ꠖꠦꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS20_3","020_20_3","PSA","20","3","3","ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣꠞꠦ ꠝꠘꠅ ꠞꠣꠈꠃꠇ꠆ꠇꠣ, ꠇꠛꠥꠟ ꠇꠞꠃꠇ꠆ꠇꠣ ꠔꠥꠝꠣꠞ ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS20_4","020_20_4","PSA","20","4","4","ꠔꠥꠝꠣꠞ ꠖꠤꠟꠞ ꠀꠞꠎꠤꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠝꠘꠞ ꠀꠡꠣ ꠅꠇꠟ ꠙꠥꠞꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS20_5","020_20_5","PSA","20","5","5","ꠔꠥꠝꠤ ꠎꠄꠁ ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠞ ꠉꠎꠟ ꠉꠣꠁꠝꠥ, ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠏꠣꠘ꠆ꠒꠣ ꠃꠠꠣꠁꠝꠥ, ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠝꠤꠘꠔꠤ ꠙꠥꠞꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS20_6","020_20_6","PSA","20","6","6","ꠀꠝꠤ ꠔ ꠅꠈꠘ ꠎꠣꠘꠤꠃ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠅꠀ ꠎꠘꠞꠦ ꠛꠣꠌꠣꠁꠛꠣ। ꠔꠣꠘ ꠀꠙꠘ ꠒꠣꠁꠘ ꠀꠔꠞ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔꠦ ꠎꠥꠖ꠆ꠖꠔ ꠎꠤꠔꠣꠁꠛꠣ, ꠘꠤꠎꠞ ꠙꠛꠤꠔ꠆ꠞ ꠀꠞꠡ ꠕꠣꠇꠤ ꠄꠘ ꠝꠤꠘꠔꠤ ꠢꠥꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS20_7","020_20_7","PSA","20","7","7","ꠇꠦꠃꠞꠞ ꠜꠞꠡꠣ ꠅꠁꠟ ꠔꠣꠞ ꠎꠥꠖ꠆ꠖꠞ ꠞꠕ, ꠀꠞ ꠇꠦꠃꠞꠞ ꠜꠞꠡꠣ ꠔꠣꠞ ꠊꠥꠠꠣꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦ, ꠀꠝꠞꠣꠞ ꠜꠞꠡꠣ ꠈꠣꠟꠤ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS20_8","020_20_8","PSA","20","8","8","ꠔꠣꠞꠣ ꠔ ꠃꠘ꠆ꠖꠣ ꠅꠁꠀ ꠟꠦꠐꠤꠎꠣꠁꠘ, ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠡꠤꠗꠣ ꠅꠁꠀ ꠢꠣꠝꠦꠡꠣ ꠈꠣꠠꠣ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("PS20_9","020_20_9","PSA","20","9","9","ꠅ ꠝꠣꠛꠥꠖ, ꠛꠣꠖꠡꠣꠞꠦ ꠎꠄꠁ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣꠞ ꠒꠣꠇ ꠢꠥꠘꠤꠀ ꠎꠥꠀꠙ ꠖꠦꠃꠇ꠆ꠇꠣ॥ ");
INSERT INTO syls_vpl VALUES ("PS21_1","020_21_1","PSA","21","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔꠦ ꠛꠣꠖꠡꠣꠄ ꠈꠥꠡꠤ ꠇꠞꠞꠣ, ꠔꠥꠝꠤ ꠎꠥꠖ꠆ꠖꠔ ꠎꠤꠔꠣꠘꠤꠄ ꠔꠣꠁꠘ ꠈꠥꠛ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS21_2","020_21_2","PSA","21","2","2","ꠔꠣꠘ ꠝꠘꠞ ꠀꠡꠣ ꠔꠥꠝꠤ ꠙꠥꠞꠣꠁꠍ, ꠔꠣꠘ ꠝꠥꠈꠞ ꠀꠛꠖꠣꠞꠞꠦ ꠔꠥꠝꠤ ꠚꠤꠞꠣꠁ ꠖꠤꠍ ꠘꠣ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS21_3","020_21_3","PSA","21","3","3","ꠛꠃꠔ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠟꠁꠀ ꠔꠥꠝꠤ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠍ, ꠈꠣꠐꠤ ꠡꠥꠘꠣꠞ ꠝꠥꠇꠥꠐ-ꠔꠣꠎ ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠚꠤꠘ꠆ꠖꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("PS21_4","020_21_4","PSA","21","4","4","ꠛꠣꠖꠡꠣꠄ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠌꠣꠁꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠖꠤꠟꠣꠄ ꠔꠥꠝꠤ ꠌꠤꠞꠇꠣꠟꠞ ꠢꠣꠄꠀꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS21_5","020_21_5","PSA","21","5","5","ꠔꠥꠝꠣꠞ ꠖꠦꠅꠀ ꠎꠄꠄ ꠛꠣꠠꠣꠁꠍꠦ ꠔꠣꠘ ꠁꠎ꠆ꠎꠔ, ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣ ꠖꠤꠍ ꠔꠣꠘꠦ ꠔꠥꠝꠣꠞꠃ ꠞꠢꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("PS21_6","020_21_6","PSA","21","6","6","ꠔꠣꠘꠞꠦ ꠖꠤꠍ ꠔꠥꠝꠤ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠛꠞꠇꠔ, ꠔꠥꠝꠣꠞ ꠙꠣꠇ ꠖꠤꠖꠣꠞꠅ ꠖꠤꠍ ꠔꠣꠘꠞꠦ ꠈꠥꠡꠤꠞ ꠘꠤꠀꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("PS21_7","020_21_7","PSA","21","7","7","ꠛꠣꠖꠡꠣꠄ ꠔ ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦꠃ ꠜꠞꠡꠣ ꠇꠞꠂꠘ, ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀꠄ ꠔꠣꠁꠘ ꠝꠎꠛꠥꠔ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS21_8","020_21_8","PSA","21","8","8","ꠅ ꠛꠣꠖꠡꠣ, ꠔꠥꠝꠣꠞ ꠀꠔꠦ ꠖꠥꠡꠝꠘ ꠙꠣꠟꠞꠦ ꠗꠞꠛ, ꠒꠣꠁꠘ ꠀꠔꠦ ꠔꠥꠝꠣꠞ ꠛꠤꠞꠥꠗꠤꠞꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤ ꠀꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("PS21_9","020_21_9","PSA","21","9","9","ꠔꠥꠝꠤ ꠀꠁꠛꠣꠞ ꠇꠣꠟꠅ ꠁꠔꠣꠞꠦ ꠀꠉꠥꠘꠤꠞ ꠇꠥꠘ꠆ꠒꠟꠤ ꠛꠣꠘꠣꠁꠛꠣꠄ, ꠀꠉꠥꠁꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠀ ꠇꠞꠤ ꠉꠤꠟꠛ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠍꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS21_10","020_21_10","PSA","21","10","10","ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠝꠤꠐꠣꠁꠟꠤꠛꠣꠄ ꠁꠔꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠘꠣꠝ, ꠀꠖꠝ ꠎꠣꠔ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠤꠛꠣꠄ ꠔꠣꠞꠣꠞ ꠡꠛ ꠈꠣꠘ꠆ꠖꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS21_11","020_21_11","PSA","21","11","11","ꠔꠥꠝꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠇꠥ-ꠝꠔꠟꠛꠦ ꠚꠣꠘ꠆ꠖ ꠙꠣꠔꠤꠍꠦ ꠔꠣꠞꠣ, ꠔꠣꠞꠣꠞ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠅꠁꠛ ꠛꠦꠇꠣꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("PS21_12","020_21_12","PSA","21","12","12","ꠔꠣꠞꠣꠞ ꠝꠥꠈꠞꠦ ꠘꠤꠡꠣꠘ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞ ꠗꠘꠥꠇꠅ ꠝꠣꠞꠟꠦ ꠐꠣꠘ, ꠙꠤꠑ ꠊꠥꠞꠣꠁꠀ ꠜꠣꠉꠤꠀ ꠔꠣꠞꠣ ꠛꠣꠌꠣꠁꠔ ꠌꠣꠁꠛ ꠎꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS21_13","020_21_13","PSA","21","13","13","ꠔꠥꠝꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠎꠣꠁꠞ ꠇꠞꠅ ꠅꠉ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠉꠣꠘ-ꠛꠣꠎꠘꠣꠄ ꠉꠣꠁꠝꠥ ꠀꠝꠞꠣ ꠔꠥꠝꠣꠞ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ॥ ");
INSERT INTO syls_vpl VALUES ("PS22_1","020_22_1","PSA","22","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ‘ꠛꠤꠀꠘꠇꠥꠞ ꠢꠞꠤꠘꠤ’ ꠡꠥꠞꠦ। ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠝꠃꠟꠣ, ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠟꠉ ꠍꠣꠠꠤ ꠖꠤꠟꠣꠄ? ꠀꠝꠣꠞꠦ ꠘꠣ ꠛꠣꠌꠣꠁꠀ ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠖꠘ ꠘꠣ ꠢꠥꠘꠤꠀ ꠇꠦꠘꠦ ꠖꠥꠞꠁ ꠢꠞꠤꠀ ꠞꠁꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("PS22_2","020_22_2","PSA","22","2","2","ꠅ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠤ ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠒꠣꠇꠤꠟꠣꠝ ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠘꠣ ꠖꠤꠟꠣꠄ, ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣꠅ ꠘꠣ ꠒꠣꠇꠤꠀ ꠀꠝꠤ ꠞꠁ ꠘꠣ ꠘꠤꠞꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS22_3","020_22_3","PSA","22","3","3","ꠅꠁꠟꠦ ꠔꠥꠝꠤꠃ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠣꠅꠀ ꠙ꠆ꠞꠡꠋꠡꠣ-ꠔꠣꠞꠤꠚꠃ ꠔꠥꠝꠣꠞ ꠞꠣꠎ-ꠉꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("PS22_4","020_22_4","PSA","22","4","4","ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠄ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠄꠇꠤꠘ ꠞꠣꠈꠍꠂꠘ, ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠣꠄ ꠔꠥꠝꠤꠅ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠔꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS22_5","020_22_5","PSA","22","5","5","ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠚꠞꠤꠀꠖ ꠇꠞꠤꠀ ꠎꠣꠘ-ꠝꠣꠘ ꠛꠣꠌꠣꠁꠔꠣ, ꠔꠣꠞꠣ ꠜꠞꠡꠣ ꠇꠞꠤꠀ ꠔ ꠡꠞꠝ ꠙꠣꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS22_6","020_22_6","PSA","22","6","6","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔ ꠝꠣꠘꠥꠡ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠄꠟꠣꠝꠤꠞ ꠄꠇ ꠇꠤꠠꠣ-ꠙꠥꠇ, ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞꠦ ꠟꠁꠀ ꠈꠣꠃꠞꠤ ꠈꠣꠄ ꠑꠣꠐ꠆ꠐꠣ ꠇꠞꠤꠀ ꠍꠤꠠꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS22_7","020_22_7","PSA","22","7","7","ꠎꠔ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠦ, ꠢꠇ꠆ꠇꠟꠦ ꠑꠥꠐ ꠛꠦꠇꠣꠁꠀ ꠐꠤꠐꠇꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠇꠄ, ");
INSERT INTO syls_vpl VALUES ("PS22_8","020_22_8","PSA","22","8","8","“ꠢꠦ ꠎꠦꠛꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦ ꠇꠞꠦ ꠜꠞꠡꠣ, ꠔꠦ ꠅꠈꠘ ꠖꠦꠈꠤ ꠔꠣꠁꠘ ꠔꠣꠞꠦ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ, ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠔꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠤ ꠀꠞ ꠞꠣꠎꠤ, ꠅꠈꠘ ꠔꠣꠞꠦ ꠞꠇ꠆ꠇꠣ ꠇꠞꠂꠘ ꠘꠤ ꠖꠦꠈꠤ।” ");
INSERT INTO syls_vpl VALUES ("PS22_9","020_22_9","PSA","22","9","9","ꠝꠣʼꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠤ ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞꠦ ꠎꠉꠔꠅ ꠀꠘꠟꠣꠄ, ꠝꠣʼꠞ ꠖꠥꠗ ꠈꠣꠅꠀꠞ ꠡꠝꠄꠅ ꠀꠝꠣꠞꠦ ꠜꠞꠡꠣ ꠖꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS22_10","020_22_10","PSA","22","10","10","ꠎꠘꠝ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠝꠣʼꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠤꠃ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS22_11","020_22_11","PSA","22","11","11","ꠅꠈꠘ ꠀꠝꠣꠞꠦ ꠚꠣꠟꠣꠁꠀ ꠔꠥꠝꠤ ꠢꠞꠤꠀ ꠞꠁꠅ ꠘꠣ, ꠍꠣꠝꠘꠦ ꠛꠃꠔ ꠛꠠ ꠛꠤꠙꠖ, ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS22_12","020_22_12","PSA","22","12","12","ꠎꠋꠟꠤ ꠛꠤꠍꠣꠟꠞ ꠙꠣꠟꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠛꠦꠞꠤꠟꠤꠍꠂꠘ, ꠛꠣꠡꠘ ꠖꠦꠡꠞ ꠙꠄꠟꠥꠀꠘ ꠛꠟꠖ ꠅꠇꠟꠦ ꠀꠝꠣꠞꠦ ꠀꠐꠇꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS22_13","020_22_13","PSA","22","13","13","ꠉꠞ꠆ꠎꠘ ꠇꠞꠞꠣ ꠙꠣꠡꠣꠘ ꠡꠤꠋꠢꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ, ꠀ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠉꠤꠟꠤꠟꠤꠔꠣ ꠌꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS22_14","020_22_14","PSA","22","14","14","ꠛꠞꠛꠣꠖ ꠙꠣꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠣꠞꠦ ꠓꠣꠟꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠀꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠞ ꠀꠒ꠆ꠒꠤ-ꠉꠥꠒ꠆ꠒꠤꠞ ꠎꠥꠠꠣ ꠍꠥꠐꠤ ꠉꠦꠍꠦ, ꠀꠝꠣꠞ ꠇꠁꠟꠎꠣ-ꠉꠥꠞ꠆ꠖꠣ ꠝꠝꠞ ꠟꠣꠈꠣꠘ ꠉꠟꠤꠀ, ꠙꠦꠐꠞ ꠀꠔ-ꠜꠠꠅ ꠢꠣꠝꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS22_15","020_22_15","PSA","22","15","15","ꠀꠝꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠢꠥꠇꠣꠁꠀ ꠝꠣꠐꠤꠞ ꠍꠣꠠꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠍꠦ, ꠀꠞ ꠎꠤꠚꠞꠣ ꠢꠥꠇꠣꠁꠀ ꠔꠣꠟꠥꠔ ꠟꠣꠉꠤꠉꠦꠍꠦ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠗꠥꠟꠣ-ꠛꠣꠟꠥꠞ ꠇꠄꠛꠞꠅ ꠢꠣꠞꠣꠁ ꠕꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("PS22_16","020_22_16","PSA","22","16","16","ꠈꠛꠤꠍ ꠅꠇꠟꠦ ꠀꠝꠣꠞꠦ ꠇꠥꠔ꠆ꠔꠣꠞ ꠙꠣꠟꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠞꠤꠟꠤꠍꠂꠘ, ꠀꠝꠣꠞ ꠀꠔ-ꠙꠣꠅꠞꠦ ꠉꠣꠕꠤꠟꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS22_17","020_22_17","PSA","22","17","17","ꠀꠝꠤ ꠔ ꠀꠝꠣꠞ ꠢꠇ꠆ꠇꠟ ꠀꠒ꠆ꠒꠤ ꠉꠘꠤꠔꠣꠝ ꠙꠣꠞꠤ, ꠅꠔꠣꠄ ꠀꠝꠣꠞ ꠛꠣꠄ ꠌꠃꠈ ꠝꠦꠟꠤꠀ ꠌꠣꠁ ꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS22_18","020_22_18","PSA","22","18","18","ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠎꠦ ꠀꠝꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠛꠣꠐꠣ-ꠛꠣꠐꠤ ꠇꠞꠍꠦ, ꠀꠝꠣꠞ ꠇꠥꠞ꠆ꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠟꠐꠣꠞꠤꠅ ꠝꠣꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS22_19","020_22_19","PSA","22","19","19","ꠅꠁꠟꠦ ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠖꠥꠞꠁ ꠢꠞꠤꠀ ꠞꠁꠅ ꠘꠣ, ꠅ ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠒꠣꠞꠤ, ꠀꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ ꠎꠟꠖꠤ ꠀꠉꠥꠀꠁ ꠀꠅ। ");
INSERT INTO syls_vpl VALUES ("PS22_20","020_22_20","PSA","22","20","20","ꠔꠟꠥꠀꠞꠞ ꠔꠟ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠅ ꠀꠝꠣꠞ ꠎꠣꠘ, ꠅꠔꠣ ꠇꠥꠇꠞꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠅ ꠝꠞ ꠙꠞꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS22_21","020_22_21","PSA","22","21","21","ꠡꠤꠋꠢ ꠙꠣꠟꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠞꠇ꠆ꠇꠣ ꠇꠞꠅ ꠝꠞꠦ, ꠎꠋꠟꠤ ꠛꠤꠍꠣꠟꠞ ꠗꠣꠞꠣꠁꠟ ꠢꠤꠋꠉꠞꠦ ꠢꠞꠣꠅ ꠛꠃꠔ ꠖꠥꠞꠦ! ꠅꠃ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠍ, ");
INSERT INTO syls_vpl VALUES ("PS22_22","020_22_22","PSA","22","22","22","ꠔꠦ ꠀꠝꠤꠅ ꠀꠝꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠝꠥ, ꠡꠝꠣꠎꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠣꠞ ꠔꠣꠞꠤꠚ-ꠉꠎꠟ ꠉꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS22_23","020_22_23","PSA","22","23","23","ꠔꠥꠝꠞꠣ ꠎꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠒꠞ-ꠈꠚꠦ ꠞꠅ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠔꠣꠞꠤꠚ-ꠉꠎꠟ ꠉꠣꠅ। ꠅ ꠁꠀꠇꠥꠛꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠢꠥꠘꠅ, ꠝꠣꠛꠥꠖ ꠄꠟꠣꠢꠤꠞꠦ ꠔꠣꠎꠤꠝ ꠇꠞꠅ। ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠅ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘ ꠄꠇꠈꠣꠘꠅ ꠝꠤꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("PS22_24","020_22_24","PSA","22","24","24","ꠖꠥꠈꠤ ꠎꠘꠞ ꠖꠥꠈ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠢꠞꠂꠘ ꠘꠣ, ꠇꠣꠋꠉꠣꠟꠞꠦ ꠖꠦꠈꠟꠦ ꠔꠣꠁꠘ ꠢꠞꠤꠀ ꠎꠣꠁꠘ ꠘꠣ, ꠀꠙꠘ ꠙꠣꠇ ꠝꠥꠈ ꠟꠥꠇꠣꠁꠘ ꠘꠣ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠟꠦ, ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠘ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠟꠣ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS22_25","020_22_25","PSA","22","25","25","ꠔꠥꠝꠣꠞ ꠘꠣꠝꠦ ꠝꠢꠣ ꠝꠣꠢꠚꠤꠟꠅ ꠎꠔ ꠔꠣꠞꠤꠚ-ꠉꠎꠟ ꠉꠣꠁ, ꠔꠥꠝꠣꠞꠦ ꠒꠞꠣꠅꠞꠣ ꠎꠘꠞ ꠍꠣꠝꠘꠦ ꠝꠞ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠝꠥ ꠀꠖꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS22_26","020_22_26","PSA","22","26","26","ꠙꠦꠐ ꠜꠞꠣ ꠈꠣꠘꠤ ꠈꠣꠁꠛꠣ ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟ ꠎꠘꠦ, ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠉꠣꠁꠛꠣ ꠔꠣꠘ ꠀꠡꠤꠇ ꠖꠟꠦ। ꠌꠤꠞꠇꠣꠟ ꠎꠤꠘ꠆ꠖꠣ ꠞꠃꠇ ꠀꠡꠤꠇꠞ ꠅꠘ꠆ꠔꠞ! ");
INSERT INTO syls_vpl VALUES ("PS22_27","020_22_27","PSA","22","27","27","ꠎꠉꠔꠞ ꠢꠦꠡ ꠡꠤꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠦꠅ ꠔꠃꠛꠣ ꠇꠞꠤ ꠚꠤꠞꠤꠀ ꠀꠁꠛꠣ, ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠢꠇ꠆ꠇꠟ ꠉꠥꠡ꠆ꠐꠤꠄ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠇꠞꠛꠣ ꠍꠁꠎꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("PS22_28","020_22_28","PSA","22","28","28","ꠞꠣꠎ-ꠡꠤꠋꠢꠣꠡꠘ ꠘꠤꠌ꠆ꠌꠤꠔ ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣꠞꠃ, ꠔꠣꠁꠘꠃ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS22_29","020_22_29","PSA","22","29","29","ꠎꠉꠔꠞ ꠛꠟꠛꠣꠘ ꠅꠇꠟꠦ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠛꠣ, ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠄꠛꠣꠖꠔ ꠇꠞꠛꠣ, ꠀꠞ ꠎꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠃꠙꠣꠄ ꠘꠣꠁ, ꠔꠣꠞꠣꠅ ꠀꠁꠀ ꠘꠔ ꠅꠁꠀ ꠔꠣꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS22_30","020_22_30","PSA","22","30","30","ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠛꠣ ꠍꠣꠝꠘꠞ ꠎꠥꠉꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠦ, ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠞ ꠈꠛꠞ ꠢꠥꠘꠛꠣ ꠢꠃ ꠎꠝꠣꠘꠣꠞ ꠢꠇꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("PS22_31","020_22_31","PSA","22","31","31","ꠜꠛꠤꠡꠔꠦ ꠎꠘꠝ ꠅꠁꠛ ꠖꠥꠘꠤꠀꠁꠔ ꠎꠣꠞꠣꠞ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠛ ꠅꠃ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠞꠛꠣꠞ॥ ");
INSERT INTO syls_vpl VALUES ("PS23_1","020_23_1","PSA","23","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠟꠂꠘ, ꠀꠝꠣꠞ ꠔ ꠀꠞ ꠅꠜꠣꠛ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS23_2","020_23_2","PSA","23","2","2","ꠈꠦꠍꠝꠣ ꠊꠣꠡꠅ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠢꠥꠔꠣꠁꠘ, ꠀꠞꠣꠝꠞ ꠈꠣꠟꠞ ꠙꠣꠞꠦꠖꠤ ꠀꠝꠣꠞꠦ ꠀꠐꠣꠁꠘ, ");
INSERT INTO syls_vpl VALUES ("PS23_3","020_23_3","PSA","23","3","3","ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ ꠔꠞꠔꠣꠎꠣ ꠇꠞꠂꠘ, ꠔꠣꠘ ꠁꠎ꠆ꠎꠔꠞ ꠟꠣꠉꠤ ꠍꠢꠤ ꠙꠕꠦ ꠀꠝꠣꠞꠦ ꠌꠣꠟꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS23_4","020_23_4","PSA","23","4","4","ꠉꠁꠘ ꠊꠘ ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠀꠐꠤꠟꠦꠅ ꠀꠝꠤ ꠒꠞꠣꠁ ꠘꠣ, ꠔꠥꠝꠣꠞ ꠀꠔꠖꠤ ꠔ ꠀꠝꠣꠞꠦ ꠗꠞꠤꠀ ꠞꠣꠈꠍ, ꠔꠥꠝꠣꠞ ꠝꠥꠐꠤꠔ ꠔ ꠀꠍꠦ ꠝꠥꠘꠤꠛ ꠞꠣꠈꠣꠟꠞ ꠟꠣꠑꠤ-ꠍꠥꠟꠚꠤ, ꠀꠝꠤ ꠀꠞ ꠒꠞꠣꠁꠔꠣꠝ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("PS23_5","020_23_5","PSA","23","5","5","ꠖꠥꠡꠝꠘ ꠖꠟꠞ ꠍꠣꠝꠘꠦꠃ ꠀꠝꠣꠞꠦ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠅꠀꠁꠍ, ꠀꠝꠣꠞ ꠝꠣꠕꠣꠔ ꠈꠥꠡꠛꠄ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠍ, ꠡꠞꠛꠔꠞ ꠙꠤꠀꠟꠣ ꠜꠞꠤꠀ ꠃꠕꠟꠤꠀ ꠙꠠꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("PS23_6","020_23_6","PSA","23","6","6","ꠅ ꠝꠥꠘꠤꠛ, ꠔꠥꠝꠣꠞ ꠅꠡꠤꠝ ꠝꠣꠄꠀ-ꠖꠄꠀ ꠀꠞ ꠜꠣꠟꠣꠁ ꠀꠝꠣꠞ ꠟꠉꠦ ꠢꠣꠞꠣ ꠎꠤꠛꠘ ꠞꠁꠛ, ꠀꠝꠤ ꠌꠤꠞꠇꠣꠟ ꠝꠣꠛꠥꠖꠞ ꠊꠞꠅ ꠛꠡꠔ ꠇꠞꠝꠥ॥ ");
INSERT INTO syls_vpl VALUES ("PS24_1","020_24_1","PSA","24","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠁ ꠎꠉꠔ ꠀꠞ ꠎꠉꠔꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠝꠣꠛꠥꠖꠞ, ꠖꠥꠘꠤꠀ ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟ ꠔ ꠔꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS24_2","020_24_2","PSA","24","2","2","ꠔꠣꠁꠘ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠖꠥꠘꠤꠀꠞ ꠜꠤꠔ ꠛꠅꠀꠁꠟ ꠇꠞꠟꠣ, ꠉꠣꠋ-ꠈꠣꠟꠞ ꠃꠙꠞꠦ ꠁꠀꠘ ꠈꠥꠐꠤ ꠛꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS24_3","020_24_3","PSA","24","3","3","ꠇꠦ ꠉꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠔ, ꠔꠣꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠥꠇꠣꠝꠅ ꠇꠥꠘ ꠎꠘ ꠈꠣꠠꠣ ꠞꠁꠛ? ");
INSERT INTO syls_vpl VALUES ("PS24_4","020_24_4","PSA","24","4","4","ꠢꠃ ꠎꠘꠃ ꠔ, ꠎꠣꠞ ꠀꠔ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ, ꠎꠣꠞ ꠖꠤꠟ ꠙꠣꠇ-ꠍꠣꠚ; ꠢꠦ ꠎꠉꠔꠞ ꠝꠣꠄꠀ ꠎꠣꠟꠅ ꠛꠘ꠆ꠖꠤ ꠘꠣꠄ, ꠀꠞ ꠐꠉꠣꠐꠉꠤꠞ ꠘꠤꠅꠔꠦ ꠇꠍꠝ ꠈꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS24_5","020_24_5","PSA","24","5","5","ꠢꠦ-ꠃ ꠙꠣꠁꠛ ꠀꠟ꠆ꠟꠣꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠞꠢꠝ-ꠛꠞꠇꠔ, ꠔꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅꠞꠣ ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PS24_6","020_24_6","PSA","24","6","6","ꠄꠞꠣꠃ ꠅꠁꠟꠣ ꠔꠣꠘ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣꠞ ꠖꠟ, ꠔꠥꠝꠣꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠔ ꠌꠣꠄ, ꠅ ꠁꠀꠇꠥꠛꠞ ꠀꠟ꠆ꠟꠣ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS24_7","020_24_7","PSA","24","7","7","ꠅ ꠉꠦꠁꠐ ꠅꠇꠟ, ꠝꠣꠕꠣ ꠃꠌꠣ ꠇꠞꠅ, ꠃꠌꠣ ꠅꠁꠎꠣꠅ, ꠅ ꠌꠤꠞꠡ꠆ꠕꠣꠄꠁ ꠖꠥꠀꠞ ꠅꠇꠟ, ꠎꠣꠟꠣꠟ-ꠡꠣꠘꠞ ꠛꠣꠖꠡꠣꠄ ꠔꠡꠞꠤꠚ ꠀꠘꠤꠟꠣꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS24_8","020_24_8","PSA","24","8","8","ꠅꠃ ꠎꠣꠟꠣꠟ-ꠡꠣꠘꠞ ꠛꠣꠖꠡꠣ ꠇꠦ? ꠛꠟꠛꠣꠘ ꠀꠞ ꠙꠄꠟꠥꠀꠘ ꠝꠣꠛꠥꠖ, ꠟꠣꠠꠣꠁ-ꠎꠥꠖ꠆ꠖꠔ ꠙꠄꠟꠥꠀꠘ ꠝꠣꠛꠥꠖ। ");
INSERT INTO syls_vpl VALUES ("PS24_9","020_24_9","PSA","24","9","9","ꠅ ꠉꠦꠁꠐ ꠅꠇꠟ, ꠝꠣꠕꠣ ꠃꠌꠣ ꠇꠞꠅ, ꠃꠌꠣ ꠅꠅ, ꠅ ꠌꠤꠞꠡ꠆ꠕꠣꠄꠁ ꠖꠥꠀꠞ ꠅꠇꠟ, ꠎꠣꠟꠣꠟ-ꠡꠣꠘꠞ ꠛꠣꠖꠡꠣꠄ ꠔꠡꠞꠤꠚ ꠀꠘꠤꠟꠣꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS24_10","020_24_10","PSA","24","10","10","ꠎꠣꠟꠣꠟ-ꠡꠣꠘꠞ ꠅꠃ ꠛꠣꠖꠡꠣ ꠇꠦ? ꠍꠤꠙꠣꠁ ꠖꠟ ꠅꠇꠟꠞ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞ ꠝꠣꠛꠥꠖ, ꠔꠣꠁꠘꠃ ꠎꠣꠟꠣꠟ-ꠡꠣꠘꠞ ꠛꠣꠖꠡꠣ। (ꠍꠦꠟꠣ)॥ ");
INSERT INTO syls_vpl VALUES ("PS25_1","020_25_1","PSA","25","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠤꠟꠣꠁꠍꠤ ꠡꠙꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("PS25_2","020_25_2","PSA","25","2","2","ꠈꠣꠟꠤ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦꠃ ꠜꠞꠡꠣ ꠇꠞꠤ, ꠅꠉ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ। ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠅ ꠘꠣ ꠝꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠍꠣꠝꠘꠦ, ꠛꠣꠢꠣꠖꠥꠞꠤ ꠘꠣ ꠇꠞꠃꠇ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS25_3","020_25_3","PSA","25","3","3","ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠇꠞꠦ ꠎꠣꠞꠣ ꠀꠡꠣ-ꠜꠞꠡꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠎꠘ ꠅꠁꠔ ꠘꠣꠄ ꠔ ꠡꠞꠝꠤꠘ꠆ꠖꠣ, ꠡꠞꠝ ꠙꠣꠁꠛ ꠔꠣꠞꠣ, ꠈꠣꠝꠈꠣ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠦ ꠎꠣꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS25_4","020_25_4","PSA","25","4","4","ꠅ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠙꠕ ꠅꠇꠟ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠣꠅ, ꠔꠥꠝꠣꠞ ꠡꠑꠤꠇ ꠞꠣꠡ꠆ꠔꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS25_5","020_25_5","PSA","25","5","5","ꠔꠥꠝꠣꠞ ꠢꠇꠦ ꠀꠝꠣꠞꠦ ꠌꠣꠟꠣꠅ ꠀꠞ ꠢꠤꠇꠣꠅ, ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠝꠣꠟꠤꠇ ꠔ ꠔꠥꠝꠤꠃ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠡꠣ ꠞꠣꠈꠤ। ");
INSERT INTO syls_vpl VALUES ("PS25_6","020_25_6","PSA","25","6","6","ꠅꠉ ꠝꠣꠛꠥꠖ, ꠁꠀꠖ ꠇꠞꠅ ꠔꠥꠝꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀ, ꠡꠥꠞꠥ ꠕꠣꠇꠤ ꠔ ꠄꠛ ꠇꠞꠣꠔ ꠀꠍ ꠅꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("PS25_7","020_25_7","PSA","25","7","7","ꠀꠝꠣꠞ ꠎꠥꠀꠘ ꠇꠣꠟꠞ ꠉꠥꠘꠣ-ꠘꠣꠚꠞꠝꠣꠘꠤ ꠘꠣ ꠞꠣꠈꠤꠅ ꠝꠘꠅ, ꠅ ꠉ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀꠄ ꠝꠞꠦ ꠁꠀꠖ ꠇꠞꠅ, ꠔꠥꠝꠣꠞ ꠅꠐꠟ ꠝꠦꠢꠦꠞꠛꠣꠘꠤꠞ ꠈꠣꠔꠤꠞꠦ ꠔꠥꠝꠤ ꠅꠟꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS25_8","020_25_8","PSA","25","8","8","ꠝꠣꠛꠥꠖ ꠔ ꠖꠄꠀꠟꠥ, ꠅꠔꠤ ꠢꠇ ꠔꠣꠁꠘ, ꠄꠞꠟꠣꠉꠤ ꠉꠥꠘꠣꠉꠣꠞꠞꠦꠅ ꠔꠣꠘ ꠙꠕ ꠌꠤꠘꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS25_9","020_25_9","PSA","25","9","9","ꠢꠇ ꠙꠕꠦ ꠌꠣꠟꠣꠁꠘ ꠔꠣꠁꠘ ꠘꠞꠝ ꠖꠤꠟꠞ ꠝꠣꠘꠡꠞꠦ, ꠔꠣꠘ ꠙꠕ ꠖꠦꠈꠣꠁ ꠖꠦꠁꠘ ꠔꠣꠞꠣ ꠢꠇꠟꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS25_10","020_25_10","PSA","25","10","10","ꠔꠣꠘ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠦ ꠎꠣꠞꠣ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠙꠕ ꠅꠇꠟ ꠢꠇ ꠀꠞ ꠖꠄꠀꠄ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS25_11","020_25_11","PSA","25","11","11","ꠛꠃꠔ ꠛꠖ ꠇꠣꠝ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠤꠟꠤꠍꠤ ꠀꠝꠤ, ꠔꠥꠝꠣꠞ ꠘꠣꠝꠞ ꠖꠥꠀꠁ ꠉ ꠝꠣꠛꠥꠖ, ꠖꠤꠟꠣꠅ ꠝꠞꠦ ꠝꠣꠚꠤ। ");
INSERT INTO syls_vpl VALUES ("PS25_12","020_25_12","PSA","25","12","12","ꠝꠣꠛꠥꠖꠞꠦ ꠢꠣꠍꠣꠃ ꠒꠞꠣꠁꠀ ꠌꠟꠦꠞ ꠅꠟꠣ ꠀꠖꠝ ꠇꠦ? ꠇꠥꠘ ꠙꠕ ꠛꠣꠍꠤꠀ ꠘꠤꠔ, ꠝꠣꠛꠥꠖꠦꠃ ꠖꠦꠈꠣꠁꠘ ꠔꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS25_13","020_25_13","PSA","25","13","13","ꠡꠥꠈ-ꠡꠣꠘ꠆ꠔꠤ ꠀꠞꠣꠝꠦ ꠇꠣꠐꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠣꠘꠤ, ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖꠦꠅ ꠙꠣꠁꠛꠣ ꠖꠦꠡꠞ ꠝꠤꠞꠣꠡꠖꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS25_14","020_25_14","PSA","25","14","14","ꠝꠣꠛꠥꠖꠞ ꠒꠞ-ꠈꠚꠦ ꠎꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠘ, ꠔꠣꠞꠣꠞꠦꠃ ꠔꠣꠘ ꠖꠤꠟꠞ ꠉꠥꠙꠘ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠘ, ꠔꠣꠘ ꠅꠀꠖꠣ-ꠌꠥꠇ꠆ꠔꠤꠞ ꠛꠦꠙꠣꠞ ꠔꠣꠞꠣꠞꠦ ꠢꠤꠇꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS25_15","020_25_15","PSA","25","15","15","ꠀꠝꠣꠞ ꠌꠃꠈꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠄ ꠌꠣꠁ ꠞꠁꠍꠦ, ꠡꠤꠇꠣꠞꠤꠞ ꠎꠣꠟ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠛꠣꠌꠣꠁꠘ ꠀꠝꠣꠞ ꠙꠣꠅꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS25_16","020_25_16","PSA","25","16","16","ꠞꠢꠝ ꠇꠞꠅ ꠔꠥꠝꠤ ꠝꠞꠦ, ꠀꠝꠣꠞ ꠛꠣꠄꠖꠤ ꠌꠣꠁꠀ, ꠀꠝꠤ ꠅꠁꠟꠣꠝ ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟ, ꠀꠍꠤ ꠛꠠ ꠄꠇꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS25_17","020_25_17","PSA","25","17","17","ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠖꠥꠈ-ꠎꠘꠔ꠆ꠞꠘꠣ ꠖꠤꠟꠣꠅ ꠢꠞꠣꠁꠀ, ꠢꠇ꠆ꠇꠟ ꠛꠣꠟꠣ-ꠝꠍꠤꠛꠔ ꠕꠣꠇꠤ ꠞꠣꠈꠅ ꠛꠣꠌꠣꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("PS25_18","020_25_18","PSA","25","18","18","ꠖꠦꠈꠅ ꠝꠞ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠛꠦꠢꠣꠟꠔ ꠖꠡꠣ, ꠝꠣꠚ ꠇꠞꠤꠀ ꠖꠤꠟꠣꠅ ꠝꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠉꠥꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS25_19","020_25_19","PSA","25","19","19","ꠖꠦꠈꠞꠣꠄ ꠘꠤ ꠇꠔ ꠖꠥꠡꠝꠘ ꠟꠣꠉꠍꠦ ꠀꠝꠣꠞ ꠈꠞꠦ, ꠔꠣꠞꠣ ꠌꠞꠝ ꠁꠋꠡꠣ-ꠊꠤꠘ꠆ꠘꠣ ꠇꠞꠦꠞ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS25_20","020_25_20","PSA","25","20","20","ꠚꠣꠘꠣ ꠖꠦꠅ ꠀꠝꠣꠞꠦ, ꠛꠣꠌꠣꠅ ꠀꠝꠣꠞ ꠎꠣꠘ ꠈꠣꠘ, ꠀꠡꠞꠄ ꠟꠁꠍꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ, ꠞꠣꠈꠅ ꠀꠝꠣꠞ ꠝꠣꠘ-ꠡꠝ꠆ꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS25_21","020_25_21","PSA","25","21","21","ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠡꠞꠟꠔꠣ ꠇꠞꠃꠇ ꠀꠝꠣꠞꠦ ꠞꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠔ ꠔꠥꠝꠣꠞꠃ ꠃꠙꠞꠦ ꠇꠞꠍꠤ ꠜꠞꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("PS25_22","020_25_22","PSA","25","22","22","ꠅ ꠉ ꠀꠟ꠆ꠟꠣ, ꠈꠣꠟꠣꠍ ꠇꠞꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ, ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠝꠍꠤꠛꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠅ ꠔꠣꠞꠣꠞꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS26_1","020_26_1","PSA","26","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠀꠝꠤ ꠎꠦꠘ ꠘꠤꠞ꠆ꠖꠥꠡꠤ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠔꠣ ꠇꠞꠅ ꠉ ꠎꠣꠁꠞ, ꠀꠝꠤ ꠔ ꠢꠇ ꠙꠕꠦꠃ ꠌꠟꠤꠀꠞ, ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦꠃ ꠜꠞꠡꠣ ꠇꠞꠤꠀꠞ, ꠛꠖꠟꠣꠁꠔꠣꠝ ꠘꠣꠄ ꠘꠤꠅꠔ ꠀꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS26_2","020_26_2","PSA","26","2","2","ꠝꠣꠛꠥꠖ ꠉ, ꠀꠝꠣꠞꠦ ꠀꠎꠝꠣꠁꠀ ꠖꠦꠈꠅ, ꠀꠝꠣꠞ ꠖꠤꠟ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠎꠣꠌꠣꠁ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS26_3","020_26_3","PSA","26","3","3","ꠔꠥꠝꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠔ ꠀꠝꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ, ꠀꠝꠤ ꠌꠟꠤ ꠔꠥꠝꠣꠞ ꠖꠦꠈꠣꠁꠟ ꠢꠇ ꠙꠕꠦ। ");
INSERT INTO syls_vpl VALUES ("PS26_4","020_26_4","PSA","26","4","4","ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣꠞ ꠀꠒ꠆ꠒꠣꠔ ꠀꠝꠤ ꠛꠁ ꠘꠣ, ꠛꠦꠁꠝꠣꠘ-ꠝꠥꠘꠣꠚꠤꠇꠞ ꠗꠣꠞꠅ ꠇꠣꠍꠦ ꠎꠣꠁ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS26_5","020_26_5","PSA","26","5","5","ꠈꠛꠤꠍ-ꠘꠣꠚꠞꠝꠣꠘꠞ ꠡꠋ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠁ, ꠛꠎ꠆ꠎꠣꠔ ꠅꠇꠟꠞ ꠀꠒ꠆ꠒꠣꠔ ꠀꠝꠤ ꠘꠣ ꠛꠁ। ");
INSERT INTO syls_vpl VALUES ("PS26_6","020_26_6","PSA","26","6","6","ꠈꠣꠟꠣꠍꠞ ꠞꠣꠄ ꠙꠣꠁꠀ ꠉ ꠝꠣꠛꠥꠖ, ꠀꠔ ꠗꠁꠍꠤ ꠀꠝꠤ, ꠔꠥꠝꠣꠞ ꠊꠞ ꠔꠅꠀꠚ ꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ ꠇꠥꠞꠛꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS26_7","020_26_7","PSA","26","7","7","ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠔꠥꠝꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠔꠥꠝꠣꠞ ꠢꠇ꠆ꠇꠟ ꠇꠦꠞꠣꠝꠔꠤꠞ ꠇꠕꠣ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PS26_8","020_26_8","PSA","26","8","8","ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠛꠡꠔ ꠊꠞ ꠀꠝꠤ ꠜꠣꠟꠛꠣꠡꠤ, ꠎꠦ ꠎꠣꠉꠣꠔ ꠔꠥꠝꠣꠞ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣꠞ ꠛꠡꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS26_9","020_26_9","PSA","26","9","9","ꠉꠥꠘꠣꠉꠣꠞꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠎꠣꠘ ꠘꠣ ꠘꠤꠅ, ꠈꠥꠘꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠝꠞꠘ ꠘꠣ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("PS26_10","020_26_10","PSA","26","10","10","ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠀꠍꠦ ꠈꠣꠟꠤ ꠘꠣꠚꠞꠝꠣꠘꠤ, ꠒꠣꠁꠘ ꠀꠔ ꠜꠞꠣ ꠔꠣꠞꠣꠞ ꠊꠥꠡꠞ ꠐꠦꠇꠣꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("PS26_11","020_26_11","PSA","26","11","11","ꠀꠝꠤ ꠔ ꠌꠟꠤ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠙꠕꠦ, ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠤꠀ ꠈꠣꠟꠣꠍ ꠇꠞꠅ ꠝꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS26_12","020_26_12","PSA","26","12","12","ꠢꠝꠣꠘ ꠎꠣꠉꠣꠔ ꠝꠎꠛꠥꠔ ꠀꠍꠦ ꠀꠝꠣꠞ ꠖꠥꠁꠅ ꠙꠣꠅ, ꠝꠣꠛꠥꠖꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠝꠥ ꠀꠝꠤ ꠝꠢꠣ ꠝꠎꠟꠤꠍꠅ॥ ");
INSERT INTO syls_vpl VALUES ("PS27_1","020_27_1","PSA","27","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠝꠣꠛꠥꠖꠃ ꠀꠝꠣꠞ ꠞꠥꠡꠘꠤ, ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠘꠦꠀꠟꠣ, ꠀꠝꠤ ꠇꠣꠞꠦ ꠒꠞꠣꠁꠔꠣꠝ? ꠝꠣꠛꠥꠖꠃ ꠀꠝꠣꠞ ꠀꠡꠞꠄ ꠑꠤꠇꠣꠘꠣ, ꠇꠣꠞ ꠒꠞꠦ ꠀꠝꠤ ꠇꠣꠙꠤꠔꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("PS27_2","020_27_2","PSA","27","2","2","ꠀꠝꠣꠞꠦ ꠉꠤꠟꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟ, ꠀꠉꠥꠁꠀ ꠀꠄ ꠎꠦꠛꠟꠣ ꠅꠃ ꠖꠥꠡꠝꠘ ꠖꠟ, ꠅꠃ ꠡꠝꠄ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠀ ꠔꠣꠞꠣ ꠙꠠꠤ ꠎꠣꠄ, ꠙꠠꠤ ꠎꠣꠅꠀꠄ ꠔꠣꠞꠣ ꠛꠤꠚꠟ ꠛꠘꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS27_3","020_27_3","PSA","27","3","3","ꠡꠦꠘꠣ ꠛꠣꠢꠤꠘꠤꠄ ꠎꠥꠖꠤ ꠛꠦꠞꠤꠟꠣꠄ ꠝꠞꠦ, ꠀꠝꠣꠞ ꠖꠤꠟꠦ ꠒꠞꠣꠁꠔ ꠘꠣꠄ ꠔꠣꠞꠣꠞꠦ। ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠥꠖꠤ ꠎꠥꠖ꠆ꠖ ꠟꠣꠉꠣꠄ, ꠀꠝꠤ ꠔ ꠞꠁꠝꠥ ꠔꠥꠝꠣꠞꠃ ꠜꠞꠡꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS27_4","020_27_4","PSA","27","4","4","ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠅꠃ ꠝꠤꠘꠔꠤ ꠎꠣꠘꠣꠁ, ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠈꠣꠟꠤ ꠅꠔꠈꠣꠘꠃ ꠌꠣꠁ— ꠞꠁꠔꠣꠝ ꠌꠣꠁ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠊꠞꠅ, ꠀꠝꠣꠞ ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠃꠇ ꠢꠘꠅ, ꠔꠣꠘ ꠡꠥꠘ꠆ꠖꠞ ꠍꠥꠞꠔ ꠈꠣꠘ ꠀꠝꠤ ꠎꠣꠘꠥ ꠖꠦꠈꠤ, ꠔꠣꠘ ꠝꠥꠇꠣꠝꠅ ꠞꠁꠀ ꠀꠝꠤ ꠎꠤꠇꠤꠞ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS27_5","020_27_5","PSA","27","5","5","ꠝꠍꠤꠛꠔꠞ ꠖꠤꠘꠅ ꠔꠣꠁꠘꠃ ꠔ ꠝꠞꠦ ꠟꠥꠇꠣꠁꠀ ꠞꠣꠈꠛꠣ ꠔꠣꠘ ꠀꠡꠞꠄ ꠛꠣꠋꠇꠣꠞꠦ, ꠔꠥꠟꠤꠀ ꠞꠣꠈꠛꠣ ꠝꠞꠦ ꠙꠣꠠꠞ ꠃꠌꠣ ꠐꠤꠟ꠆ꠟꠣꠔ, ꠘꠤꠞꠣꠙꠖꠦ ꠞꠣꠈꠛꠣ ꠝꠞꠦ ꠔꠣꠘ ꠛꠡꠔ ꠈꠣꠘꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("PS27_6","020_27_6","PSA","27","6","6","ꠅꠃ ꠡꠝꠄ ꠝꠞꠦ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠍꠦ ꠎꠦꠔꠣ ꠖꠥꠡꠝꠘꠦ, ꠀꠝꠣꠞ ꠁꠎ꠆ꠎꠔ ꠛꠣꠠꠤꠛ ꠅꠔꠣ ꠎꠘꠞ ꠃꠙꠞꠦ। ꠈꠥꠡꠤꠞ ꠌꠥꠐꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠉꠎꠟ ꠉꠣꠁꠝꠥ ꠀꠝꠤ, ꠔꠣꠘ ꠊꠞꠅ ꠖꠣꠘ ꠇꠞꠝꠥ ꠟꠤꠟ꠆ꠟꠣ-ꠇꠥꠞꠛꠣꠘꠤ, ꠛꠣꠎꠘꠣꠞ ꠔꠣꠟꠦ ꠔꠣꠟꠦ ꠔꠣꠘ ꠘꠣꠝꠦ ꠉꠣꠁꠝꠥ ꠀꠝꠤ, ꠃꠌꠣ ꠉꠟꠣꠄ ꠉꠣꠁꠝꠥ ꠀꠝꠤ ꠉꠎꠟ-ꠇꠣꠅꠀꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("PS27_7","020_27_7","PSA","27","7","7","ꠀꠝꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠅ ꠝꠣꠛꠥꠖ, ꠇꠞꠤ ꠝꠤꠘꠔꠤ, ꠖꠄꠀ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠒꠣꠇꠞ ꠎꠥꠀꠙ ꠖꠦꠅ ꠔꠥꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("PS27_8","020_27_8","PSA","27","8","8","ꠔꠥꠝꠣ ꠕꠣꠇꠤ ꠅꠃ ꠇꠣꠟꠣꠝ ꠖꠤꠟꠅ ꠀꠁꠍꠦ ꠝꠞ, “ꠀꠝꠣꠞ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠅ ꠝꠞ ꠖꠤꠖꠣꠞ।” ꠝꠣꠛꠥꠖ ꠉ, ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠣꠞꠦ ꠒꠣꠇꠤꠀꠞ, ");
INSERT INTO syls_vpl VALUES ("PS27_9","020_27_9","PSA","27","9","9","ꠘꠣ ꠟꠥꠇꠣꠁꠀ ꠖꠦꠈꠣꠅ ꠉ ꠀꠝꠣꠞꠦ ꠝꠥꠈ ꠈꠣꠘ ꠔꠥꠝꠣꠞ। ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠈꠦꠖꠣꠁ ꠖꠤꠅ ꠘꠣ ꠔꠥꠝꠣꠞ ꠁ ꠉꠥꠟꠣꠝꠞꠦ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠜꠞꠡꠣ, ꠢꠞꠣꠁ ꠖꠤꠅ ꠘꠣ ꠝꠞꠦ, ꠍꠣꠠꠤꠀ ꠎꠣꠁꠅ ꠘꠣ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠚꠣꠟꠣꠁꠀ, ꠝꠣꠛꠥꠖ ꠉ ꠔꠥꠝꠤꠃ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠛꠣꠌꠣꠘꠦꠀꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS27_10","020_27_10","PSA","27","10","10","ꠝꠣ-ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠦꠅ, ꠝꠣꠛꠥꠖꠦ ꠔ ꠟꠁꠍꠂꠘ ꠝꠞꠦ ꠔꠣꠘꠃ ꠇꠥꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("PS27_11","020_27_11","PSA","27","11","11","ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠙꠕ ꠌꠤꠘꠣꠅ ꠀꠝꠣꠞꠦ, ꠡꠞꠟ ꠙꠕꠦ ꠌꠣꠟꠣꠅ ꠝꠞꠦ, ꠛꠣꠌꠣꠅ ꠖꠥꠡꠝꠘ ꠕꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("PS27_12","020_27_12","PSA","27","12","12","ꠖꠥꠡꠝꠘ ꠖꠟꠞ ꠝꠞ꠆ꠎꠤꠞ ꠀꠔꠅ ꠖꠤꠅ ꠘꠣ ꠡꠙꠤꠀ, ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤꠞ ꠖꠟ ꠀꠁꠀ ꠖꠝꠦ ꠖꠝꠦ ꠍꠣꠠꠦꠞ ꠁꠋꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("PS27_13","020_27_13","PSA","27","13","13","ꠀꠝꠣꠞ ꠝꠎꠛꠥꠔ ꠄꠇꠤꠘ ꠀꠍꠦ ꠝꠘꠞ ꠜꠤꠔꠞꠦ, ꠝꠣꠛꠥꠖꠞ ꠀꠍꠣꠘ ꠖꠦꠈꠝꠥ ꠀꠝꠤ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ। ");
INSERT INTO syls_vpl VALUES ("PS27_14","020_27_14","PSA","27","14","14","ꠝꠎꠛꠥꠔ ꠅꠅ ꠝꠣꠛꠥꠖꠞ ꠀꠡꠣꠄ, ꠅꠞꠦ ꠎꠣꠘ ꠀꠝꠣꠞ, ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠡꠣꠅꠡ ꠀꠘꠅ, ꠞꠅ ꠀꠡꠣꠄ ꠝꠣꠛꠥꠖꠞ॥ ");
INSERT INTO syls_vpl VALUES ("PS28_1","020_28_1","PSA","28","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞ ꠀꠡꠞꠄ ꠙꠣꠠ, ꠔꠥꠝꠣꠞꠦ ꠒꠣꠇꠤꠀꠞ, ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠛꠘ꠆ꠖ ꠇꠞꠤꠅ ꠘꠣ ꠖꠥꠁꠅ ꠇꠣꠘ ꠔꠥꠝꠣꠞ, ꠘꠤꠞꠣꠁ ꠞꠁꠟꠦ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠟꠣꠉꠤꠀ, ꠞꠡꠣꠔꠟꠅ ꠎꠣꠅꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠛ ꠝꠞ ꠖꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("PS28_2","020_28_2","PSA","28","2","2","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠣꠘ꠆ꠖꠤ, ꠔꠥꠝꠣꠞ ꠈꠣꠍ ꠙꠣꠇ ꠎꠣꠉꠣꠞ ꠛꠣꠄ ꠖꠥꠁꠅ ꠀꠔ ꠔꠥꠟꠤ, ꠅꠃ ꠡꠝꠄ ꠢꠥꠘꠤꠅ ꠉ ꠖꠄꠀꠟ ꠀꠝꠣꠞ ꠝꠤꠘꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS28_3","020_28_3","PSA","28","3","3","ꠘꠣꠚꠞꠝꠣꠘ ꠛꠖꠈꠥꠞꠞ ꠟꠉꠦ ꠇꠞꠤ ꠘꠤꠅ ꠘꠣ ꠝꠞꠦ ꠐꠣꠘꠤꠀ, ꠔꠣꠞꠣ ꠝꠥꠈꠦ ꠝꠥꠈꠦ ꠖꠦꠈꠣꠄ ꠜꠣꠟꠣ ꠖꠤꠟꠅ ꠈꠣꠞꠣꠙꠤ ꠞꠣꠈꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS28_4","020_28_4","PSA","28","4","4","ꠔꠣꠞꠣꠞ ꠇꠣꠝ ꠝꠣꠚꠤꠇ ꠚꠟ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠅ, ꠔꠣꠞꠣꠞ ꠈꠣꠞꠣꠙ ꠇꠣꠝꠞ ꠚꠟ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠅ, ꠔꠣꠞꠣꠞ ꠀꠔꠞ ꠛꠖ ꠇꠣꠝꠞ ꠛꠖꠟꠣꠁ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠅ, ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠑꠤꠇ ꠡꠣꠎꠣ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS28_5","020_28_5","PSA","28","5","5","ꠝꠣꠛꠥꠖꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠣꠉꠣ ꠘꠣ ꠙꠣꠄ, ꠔꠣꠘ ꠀꠔꠞ ꠇꠣꠝꠞ ꠛꠣꠄ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠈꠤꠀꠟ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠝꠣꠛꠥꠖꠦ ꠁꠔꠣꠞꠦ ꠇꠞꠤꠟꠤꠛꠣ ꠌꠥꠞꠝꠣꠞ, ꠛꠣꠖꠦ ꠇꠥꠘꠥ ꠖꠤꠘꠃ ꠁꠔꠣꠞꠦ ꠉꠠꠤꠔꠣ ꠘꠣꠄ ꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("PS28_6","020_28_6","PSA","28","6","6","ꠢꠇꠟ ꠔꠣꠞꠤꠚ-ꠉꠥꠘꠉꠣꠘ ꠈꠣꠟꠤ ꠝꠣꠛꠥꠖꠞ, ꠔꠣꠁꠘꠃ ꠔ ꠢꠥꠘꠍꠂꠘ ꠝꠤꠘꠔꠤ ꠝꠞ! ");
INSERT INTO syls_vpl VALUES ("PS28_7","020_28_7","PSA","28","7","7","ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤ, ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠀꠔꠤꠀꠞ, ꠔꠣꠘ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠦ ꠖꠤꠟ-ꠎꠣꠘ ꠀꠝꠣꠞ, ꠔꠣꠘ ꠡꠣꠁꠎ꠆ꠎ ꠙꠣꠁꠀ ꠢꠣꠞꠤ ꠈꠥꠡꠤꠄ ꠜꠞꠍꠦ ꠝꠞ ꠖꠤꠟ, ꠀꠝꠣꠞ ꠉꠟꠣꠄ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁ ꠇꠞꠤ ꠔꠣꠘ ꠎꠤꠇꠤꠞ। ");
INSERT INTO syls_vpl VALUES ("PS28_8","020_28_8","PSA","28","8","8","ꠝꠣꠛꠥꠖꠃ ꠔ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠔꠣꠘ ꠀꠙꠘ ꠙ꠆ꠞꠎꠣꠞ, ꠔꠣꠘ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠅꠀ ꠎꠘꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠛꠣꠋꠇꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS28_9","020_28_9","PSA","28","9","9","ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠙ꠆ꠞꠎꠣꠞꠦ ꠔꠥꠝꠤ ꠛꠣꠌꠣꠅ ꠉ, ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠗꠘ-ꠖꠃꠟꠔ, ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠦꠅ, ꠔꠥꠝꠤ ꠔ ꠔꠣꠞꠣꠞ ꠞꠣꠈꠣꠟ, ꠌꠤꠞꠇꠣꠟ ꠛꠁꠀ ꠘꠦꠅ॥ ");
INSERT INTO syls_vpl VALUES ("PS29_1","020_29_1","PSA","29","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ, ꠎꠣꠘꠣꠅ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠘꠉꠣꠘ, ꠉꠃꠞꠛ ꠀꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠅ ꠔꠣꠘ, ");
INSERT INTO syls_vpl VALUES ("PS29_2","020_29_2","PSA","29","2","2","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠣꠘ ꠙꠣꠅꠘꠣ ꠉꠃꠞꠛ ꠎꠣꠘꠣꠅ, ꠙꠛꠤꠔ꠆ꠞꠔꠣꠞ ꠢꠣꠎꠦ ꠢꠣꠎꠤꠀ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS29_3","020_29_3","PSA","29","3","3","ꠝꠣꠛꠥꠖꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠖꠞꠤꠀꠞ ꠃꠙꠞꠦ ꠎꠣꠞꠤ ꠀꠍꠦ, ꠛꠠꠣꠁ-ꠡꠣꠘꠞ ꠀꠟ꠆ꠟꠣꠞ ꠉꠞ꠆ꠎꠘ ꠛꠣꠎ ꠙꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠒꠣꠇꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠋꠇꠣꠞ ꠎꠣꠞꠤ ꠀꠍꠦ ꠉꠁꠘ ꠖꠞꠤꠀꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS29_4","020_29_4","PSA","29","4","4","ꠝꠣꠛꠥꠖꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠛꠃꠔ ꠛꠟꠛꠣꠘ, ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠅꠔꠤ ꠝꠢꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS29_5","020_29_5","PSA","29","5","5","ꠝꠣꠛꠥꠖꠞ ꠉꠟꠣꠞ ꠡꠥꠞꠦ ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍ ꠜꠣꠋꠉꠤꠎꠣꠄ, ꠟꠦꠛꠣꠘꠘꠞ ꠖꠦꠛꠖꠣꠞꠥ ꠉꠣꠍꠅ ꠜꠣꠋꠉꠤꠀ ꠙꠠꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS29_6","020_29_6","PSA","29","6","6","ꠔꠣꠘ ꠡꠥꠞꠦ ꠛꠣꠍꠥꠞꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠌꠦ ꠟꠦꠛꠣꠘꠘ, ꠎꠋꠟꠤ ꠛꠄꠞꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠣꠈꠣꠘ ꠚꠣꠟꠣꠄ ꠍꠤꠞꠤꠅꠘ। ");
INSERT INTO syls_vpl VALUES ("PS29_7","020_29_7","PSA","29","7","7","ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠤꠀ, ꠀꠍꠝꠣꠘ ꠃꠑꠦ ꠎꠤꠟꠇꠣꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("PS29_8","020_29_8","PSA","29","8","8","ꠝꠣꠛꠥꠖꠞ ꠉꠟꠣꠞ ꠡꠥꠞꠦ ꠝꠞꠥꠜꠥꠝꠤ ꠇꠣꠙꠤꠀ ꠃꠑꠦ, ꠇꠣꠖꠦꠡ ꠖꠦꠡꠞ ꠝꠞꠥꠜꠥꠝꠤ ꠇꠣꠙꠣꠁꠘ ꠝꠣꠛꠥꠖꠦ। ");
INSERT INTO syls_vpl VALUES ("PS29_9","020_29_9","PSA","29","9","9","ꠄꠟꠘ ꠉꠣꠍꠅ ꠀꠟꠤꠎꠣꠄ ꠝꠣꠛꠥꠖꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠤꠀ, ꠎꠋꠟꠣꠞ ꠙꠣꠔꠣ-ꠍꠣꠔꠣ ꠙꠠꠤ ꠎꠣꠄ ꠍꠤꠠꠤꠀ, ꠇꠣꠛꠣ ꠊꠞꠞ ꠢꠇꠟꠦ ꠇꠄ, ꠍꠥꠛꠢꠣꠘ ꠀꠟ꠆ꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("PS29_10","020_29_10","PSA","29","10","10","ꠝꠢꠣ ꠛꠁꠘ꠆ꠘꠣꠞ ꠙꠣꠘꠤ ꠀꠍꠤꠟ ꠝꠣꠛꠥꠖꠞ ꠎꠤꠝ꠆ꠝꠣꠄ, ꠌꠤꠞꠇꠣꠟꠤꠘ ꠛꠣꠖꠡꠣ ꠔꠣꠁꠘ, ꠛꠁꠍꠂꠘ ꠀꠞꠡ ꠈꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS29_11","020_29_11","PSA","29","11","11","ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠖꠦꠁꠘ ꠝꠣꠛꠥꠖ ꠔꠣꠘ ꠀꠙꠘ ꠙ꠆ꠞꠎꠣꠞꠦ, ꠡꠣꠘ꠆ꠔꠤ ꠖꠤꠀ ꠞꠢꠝ ꠇꠞꠂꠘ ꠔꠣꠞꠣ ꠢꠇꠟꠞꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS30_1","020_30_1","PSA","30","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠁꠀꠘ ꠖꠤꠛꠣꠞ ꠇꠣꠟꠅ ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠔꠥꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠝꠥ ꠝꠣꠛꠥꠖ ꠔꠥꠟꠤꠀ ꠀꠘꠍ ꠝꠞꠦ, ꠖꠥꠡꠝꠘꠞꠦ ꠖꠤꠍ ꠘꠣ ꠡꠥꠎꠥꠉ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠔ ꠝꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS30_2","020_30_2","PSA","30","2","2","ꠅꠉ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠚꠣꠘꠣ ꠌꠣꠁꠍꠤ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠦ, ꠚꠞꠤꠀꠖ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠤꠃ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠡꠤꠚꠣ ꠇꠞꠍ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS30_3","020_30_3","PSA","30","3","3","ꠙꠣꠔꠣꠟ ꠕꠣꠇꠤꠀ ꠝꠣꠛꠥꠖ ꠔꠥꠟꠤꠀ ꠀꠘꠍ ꠝꠞꠦ, ꠢꠣꠝꠣꠁ ꠉꠦꠍꠟꠣꠝ ꠉꠁꠘ ꠉꠣꠔꠅ ꠛꠣꠌꠣꠁꠍ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS30_4","020_30_4","PSA","30","4","4","ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣꠄ ꠉꠣꠅ ꠔꠣꠘ ꠉꠥꠘꠉꠣꠘ, ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠘꠤꠀ ꠔꠣꠘꠦ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠅ ꠔꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS30_5","020_30_5","PSA","30","5","5","ꠔꠣꠘ ꠉꠥꠍꠣ ꠞꠄ ꠘꠣ ꠔ ꠛꠦꠡꠤ ꠡꠝꠄ, ꠢꠣꠞꠣ ꠎꠤꠛꠘꠃ ꠔꠣꠘ ꠖꠄꠀ-ꠞꠢꠝ ꠞꠄ, ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠎꠣꠄ ꠈꠣꠟꠤ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠤ, ꠛꠤꠀꠘ ꠅꠁꠔꠦꠃ ꠀꠄ ꠈꠥꠡꠤ ꠀꠞ ꠚꠥꠞ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS30_6","020_30_6","PSA","30","6","6","ꠡꠥꠖꠤꠘꠞ ꠇꠣꠟꠅ ꠇꠁꠍꠟꠣꠝ ꠔ ꠀꠝꠤꠃ, ꠀꠝꠣꠞ ꠛꠤꠘꠣꠡ ꠅꠁꠔ ꠘꠣꠄ ꠇꠥꠘꠥ ꠖꠤꠘꠃ। ");
INSERT INTO syls_vpl VALUES ("PS30_7","020_30_7","PSA","30","7","7","ꠔꠥꠝꠣꠞ ꠞꠢꠝꠔꠦ ꠝꠣꠛꠥꠖ ꠙꠣꠠꠞ ꠟꠣꠈꠣꠘ ꠝꠎꠛꠥꠔ ꠇꠞꠍꠦ ꠝꠞꠦ, ꠎꠦꠛꠟꠣ ꠔꠥꠝꠣꠞ ꠝꠥꠈ ꠟꠥꠇꠣꠁꠟꠣꠄ ꠒꠞ ꠢꠣꠝꠣꠁꠍꠦ ꠝꠞ ꠜꠤꠔꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS30_8","020_30_8","PSA","30","8","8","ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠒꠣꠇꠍꠤ ꠉ ꠝꠣꠛꠥꠖ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ, ꠖꠄꠀ ꠝꠣꠋꠉꠤꠍꠤ ꠀꠝꠤ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS30_9","020_30_9","PSA","30","9","9","ꠀꠝꠤ ꠎꠥꠖꠤ ꠢꠣꠝꠣꠁ ꠎꠣꠁ ꠉꠁꠘ ꠞꠡꠣꠔꠟꠦ, ꠟꠣꠜ ꠇꠤꠔꠣ ꠅꠁꠛ ꠔꠥꠝꠣꠞ ꠀꠝꠤ ꠝꠞꠤ ꠉꠦꠟꠦ? ꠝꠥꠞ꠆ꠖꠣꠞ ꠇꠣꠄꠀꠞ ꠗꠥꠁꠟ-ꠛꠣꠟꠥꠄ ꠇꠞꠛ ꠘꠤ ꠔꠥꠝꠣꠞ ꠉꠥꠘꠉꠣꠘ, ꠉꠣꠁꠛ ꠘꠤ ꠁꠔꠣꠄ ꠔꠥꠝꠣꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤꠞ ꠛꠄꠀꠘ? ");
INSERT INTO syls_vpl VALUES ("PS30_10","020_30_10","PSA","30","10","10","ꠢꠥꠘꠤꠀ ꠝꠞ ꠚꠞꠤꠀꠖ ꠝꠣꠛꠥꠖ ꠞꠢꠝ ꠇꠞꠅ ꠝꠞꠦ, ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠅ ꠅꠉ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS30_11","020_30_11","PSA","30","11","11","ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠢꠣꠟꠔ ꠕꠣꠇꠤ ꠅꠈꠘ ꠀꠝꠣꠞꠦ ꠔꠥꠟꠤꠀ ꠀꠘꠍ ꠔꠥꠝꠤꠃ ꠝꠞꠦ ꠈꠥꠡꠤꠞ ꠝꠣꠢꠚꠤꠟꠦ, ꠍꠟꠣꠞ ꠌꠐꠞ ꠟꠦꠛꠣꠍ ꠝꠞ ꠔꠥꠝꠤ ꠛꠖꠟꠣꠁꠍ, ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠞ ꠡꠥꠘ꠆ꠖꠞ ꠟꠦꠛꠣꠍ ꠝꠞꠦ ꠚꠤꠘ꠆ꠖꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("PS30_12","020_30_12","PSA","30","12","12","ꠀꠝꠣꠞ ꠖꠤꠟꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁꠛ ꠔꠥꠝꠣꠞ, ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠝꠥ ꠌꠤꠞꠇꠣꠟ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞ॥ ");
INSERT INTO syls_vpl VALUES ("PS31_1","020_31_1","PSA","31","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠀꠡꠞꠄ ꠟꠁꠍꠤ ꠉ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠣꠞ ꠍꠣꠄꠀꠄ, ꠝꠞꠦ ꠎꠣꠘꠥ ꠘꠣ ꠙꠣꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠡꠞꠝ-ꠟꠎ꠆ꠎꠣꠄ, ꠔꠥꠝꠣꠞ ꠢꠇ ꠛꠤꠌꠣꠞꠦ ꠞꠦꠢꠣꠁ ꠖꠦꠅ ꠀꠝꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS31_2","020_31_2","PSA","31","2","2","ꠀꠝꠣꠞ ꠝꠤꠘꠔꠤ ꠢꠥꠘꠤꠀ ꠎꠟꠖꠤ ꠛꠣꠌꠣꠅ ꠝꠞꠦ, ꠙꠣꠠꠞ ꠡꠥꠠꠋ ꠅꠁꠀ ꠔꠥꠝꠤ ꠛꠣꠌꠣꠅ ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ, ꠀꠡꠞꠄ ꠛꠣꠋꠇꠣꠞ ꠅꠅ ꠉ ꠔꠥꠝꠤ ꠘꠤꠞꠣꠙꠖꠦ ꠞꠣꠈꠅ ꠝꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS31_3","020_31_3","PSA","31","3","3","ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠀꠡꠞꠄ-ꠡꠥꠠꠋ, ꠝꠎꠛꠥꠔ ꠛꠣꠋꠇꠣꠞ, ꠙꠕ ꠖꠦꠈꠣꠁꠀ ꠌꠣꠟꠣꠅ ꠝꠞꠦ ꠖꠥꠀꠁ ꠟꠣꠉꠦ ꠔꠥꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS31_4","020_31_4","PSA","31","4","4","ꠟꠥꠇꠣꠁꠀ ꠙꠣꠔꠣꠁꠟ ꠚꠣꠘ꠆ꠖꠅ ꠕꠣꠇꠤ ꠝꠞꠦ ꠇꠞꠅ ꠃꠖ꠆ꠖꠣꠞ, ꠔꠥꠝꠤꠃ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠀꠡꠞꠄ, ꠀꠝꠣꠞ ꠛꠣꠋꠇꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS31_5","020_31_5","PSA","31","5","5","ꠀꠝꠣꠞ ꠞꠥꠢꠥ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠤꠟꠣꠁꠟꠣꠝ, ꠅ ꠝꠣꠛꠥꠖ, ꠢꠇ ꠀꠟ꠆ꠟꠣ, ꠛꠣꠌꠣꠁꠍ ꠔ ꠀꠝꠣꠞ ꠎꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS31_6","020_31_6","PSA","31","6","6","ꠅꠡꠣꠠ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣꠞꠤꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁ ꠀꠝꠤ, ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦꠃ ꠀꠝꠤ ꠜꠞꠡꠣ ꠇꠞꠤ ꠈꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("PS31_7","020_31_7","PSA","31","7","7","ꠀꠝꠣꠞ ꠎꠣꠘꠞ ꠡꠛ ꠝꠍꠤꠛꠔ ꠛꠦꠢꠣꠟ ꠖꠡꠣ ꠖꠦꠈꠍ ꠔꠥꠝꠤ, ꠔꠥꠝꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠙꠣꠁꠀ ꠈꠥꠡꠤ-ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠝꠥ ꠀꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("PS31_8","020_31_8","PSA","31","8","8","ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠔꠥꠝꠤ ꠖꠤꠍ ꠘꠣ ꠝꠞꠦ ꠔꠥꠟꠤꠀ, ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠝꠣꠑꠅ ꠝꠞꠦ ꠞꠣꠈꠍ ꠃꠛꠣ ꠇꠞꠣꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("PS31_9","020_31_9","PSA","31","9","9","ꠖꠄꠀ ꠇꠞꠅ ꠅꠉ ꠝꠣꠛꠥꠖ ꠝꠍꠤꠛꠔꠅ ꠀꠍꠤ, ꠌꠃꠈ ꠀꠞ ꠖꠦꠢ-ꠇꠣꠄꠀꠄ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦ ꠎꠤꠔꠣ ꠞꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("PS31_10","020_31_10","PSA","31","10","10","ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠝꠞ ꠇ꠆ꠇꠄ ꠅꠁꠟ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠄ ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ, ꠉꠥꠘꠣꠞ ꠖꠣꠄ ꠛꠟ ꠇꠝꠤꠀ ꠢꠥꠇꠣꠁ ꠉꠦꠍꠦ ꠝꠞ ꠀꠒ꠆ꠒꠤ। ");
INSERT INTO syls_vpl VALUES ("PS31_11","020_31_11","PSA","31","11","11","ꠖꠥꠡꠝꠘ ꠅꠇꠟꠦ ꠝꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠀꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠄꠅ ꠘꠤꠘ꠆ꠖꠣꠄ, ꠌꠤꠘꠣ-ꠎꠣꠘꠣ ꠎꠘꠦ ꠖꠦꠈꠟꠦ ꠒꠞꠣꠁꠀ ꠢꠞꠦ, ꠖꠃꠠꠣꠁꠀ ꠜꠣꠉꠦ ꠝꠣꠘꠡꠦ ꠙꠕꠦ-ꠊꠣꠐꠦ ꠖꠦꠈꠟꠦ ꠝꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS31_12","020_31_12","PSA","31","12","12","ꠝꠥꠞ꠆ꠖꠣ ꠎꠘꠞ ꠟꠣꠈꠣꠘ ꠔ ꠚꠣꠃꠞꠤꠟꠤꠍꠦ ꠝꠞꠦ, ꠜꠣꠋꠉꠣ-ꠘꠡ꠆ꠐ ꠝꠣꠟꠞ ꠟꠣꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠦ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS31_13","020_31_13","PSA","31","13","13","ꠛꠃꠔꠞ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠀꠝꠤ ꠢꠥꠘꠤꠀꠞ, ꠒꠞ-ꠈꠚꠦ ꠜꠞꠣ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠀꠝꠣꠞ, ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠣꠞꠣ ꠢꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠅꠁꠍꠦ, ꠎꠣꠘ ꠇꠣꠠꠤꠀ ꠘꠤꠔꠉꠤ ꠇꠞꠤ ꠚꠘ꠆ꠖꠤ ꠇꠞꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS31_14","020_31_14","PSA","31","14","14","ꠀꠝꠤ ꠔ ꠜꠞꠡꠣ ꠇꠞꠍꠤ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠎꠣꠘꠣꠁ ꠢꠇꠟꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS31_15","020_31_15","PSA","31","15","15","ꠀꠝꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠔ ꠔꠥꠝꠣꠞꠃ ꠀꠔꠅ, ꠈꠦꠖꠣꠅꠞꠣ ꠖꠥꠡꠝꠘ ꠕꠣꠇꠤ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS31_16","020_31_16","PSA","31","16","16","ꠔꠥꠝꠣꠞ ꠘꠥꠞꠞ ꠖꠤꠖꠣꠞ ꠖꠦꠈꠣꠅ ꠀꠝꠤ ꠉꠥꠟꠣꠝꠞꠦ, ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠖꠄꠀ-ꠝꠣꠄꠀꠄ ꠛꠣꠌꠣꠅ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS31_17","020_31_17","PSA","31","17","17","ꠡꠞꠝ ꠖꠤꠅ ꠘꠣ ꠝꠞꠦ ꠝꠣꠛꠥꠖ ꠎꠣꠘꠣꠁ ꠝꠤꠘꠔꠤ, ꠘꠣꠚꠞꠝꠣꠘꠦ ꠡꠞꠝ ꠙꠣꠁꠀ ꠞꠡꠣꠔꠟꠦ ꠎꠣꠃꠇꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("PS31_18","020_31_18","PSA","31","18","18","ꠖꠥꠁꠅ ꠑꠥꠐ ꠛꠘ꠆ꠖ ꠅꠁꠎꠣꠃꠇ ꠛꠦꠁꠝꠣꠘꠤ ꠎꠦ ꠝꠣꠔꠦ, ꠛꠠꠣꠁ-ꠉꠞꠤꠝꠣ ꠖꠦꠈꠣꠄ ꠎꠣꠞꠣ ꠙꠞꠦꠎꠉꠣꠞꠞ ꠟꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("PS31_19","020_31_19","PSA","31","19","19","ꠔꠥꠝꠣꠞ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣꠞ ꠟꠣꠉꠤ ꠎꠝꠣ ꠀꠍꠦ ꠇꠔ ꠖꠄꠀ, ꠀꠡꠞꠄ ꠟꠁꠍꠦ ꠎꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠍꠣꠄꠀꠔ ꠀꠁꠀ, ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠍ ꠔꠥꠝꠣꠞ ꠅꠔ ꠝꠣꠄꠀ। ");
INSERT INTO syls_vpl VALUES ("PS31_20","020_31_20","PSA","31","20","20","ꠔꠣꠞꠣꠞꠦ ꠟꠥꠇꠣꠁꠀ ꠞꠣꠈꠅ ꠔꠥꠝꠣꠞꠃ ꠙꠣꠇ ꠖꠤꠖꠣꠞꠅ, ꠖꠥꠡꠝꠘꠞ ꠎꠤꠚꠞꠣꠞ ꠖꠣꠙꠐ ꠕꠣꠇꠤ ꠞꠣꠈꠅ ꠔꠥꠝꠣꠞ ꠛꠡꠔ ꠊꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS31_21","020_31_21","PSA","31","21","21","ꠝꠣꠛꠥꠖꠃ ꠝꠥꠛꠣꠞꠇ, ꠖꠥꠡꠝꠘꠞ ꠊꠦꠞꠣꠅ ꠇꠞꠣ ꠘꠉꠞꠅ, ꠀꠌꠣꠘꠇ ꠖꠄꠀ-ꠝꠣꠄꠀꠄ ꠞꠣꠈꠍꠂꠘ ꠝꠞꠦ ꠘꠤꠞꠣꠙꠖꠅ। ");
INSERT INTO syls_vpl VALUES ("PS31_22","020_31_22","PSA","31","22","22","ꠒꠞꠞ ꠌꠥꠐꠦ ꠇꠁꠍꠟꠣꠝ ꠔ ꠀꠝꠤ, “ꠢꠞꠤ ꠉꠦꠍꠤ ꠖꠥꠞꠁ ꠔꠥꠝꠣꠞ ꠘꠎꠞ ꠕꠣꠇꠤ,” ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠒꠣꠇꠤꠍꠟꠣꠝ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ, ꠒꠣꠇꠞ ꠎꠥꠀꠙ ꠖꠤꠟꠣꠄ ꠔꠥꠝꠤ ꠢꠥꠘꠟꠣꠄ ꠝꠤꠘꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS31_23","020_31_23","PSA","31","23","23","ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇ ꠛꠘꠅ ꠅꠞꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠢꠇꠟ ꠛꠘ꠆ꠖꠣ, ꠢꠇ ꠝꠣꠘꠡꠞꠦ ꠛꠣꠌꠣꠁꠀ ꠔꠣꠁꠘ ꠅꠢꠋꠇꠣꠞꠤꠞꠦ ꠖꠦꠁꠘ ꠇꠑꠤꠘ ꠡꠣꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("PS31_24","020_31_24","PSA","31","24","24","ꠛꠥꠇꠥꠔ ꠡꠣꠅꠡ ꠞꠣꠈꠅ ꠖꠤꠟꠅ ꠎꠥꠉꠣꠅ ꠛꠟ, ꠀꠍ ꠎꠔ ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ॥ ");
INSERT INTO syls_vpl VALUES ("PS32_1","020_32_1","PSA","32","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠣꠡ꠆ꠇꠤꠟ-ꠇꠣꠅꠀꠟꠤ। ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠇꠄ ꠔꠣꠞꠣꠞꠦ, ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠍꠦ ꠎꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ, ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣꠄ ꠎꠦꠞꠣꠞ ꠉꠥꠘꠣꠞꠦ ꠀꠝꠟ-ꠘꠣꠝꠣꠞ ꠢꠤꠡꠣꠛꠅ ꠗꠞꠔꠣ ꠘꠣꠄꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS32_2","020_32_2","PSA","32","2","2","ꠢꠃ ꠎꠘꠅ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞ ꠉꠥꠘꠣꠞꠦ ꠇꠣꠐꠤ ꠖꠤꠍꠂꠘ ꠈꠣꠔꠣ ꠕꠣꠇꠤ, ꠎꠣꠞ ꠝꠣꠎꠦ ꠘꠣꠁ ꠇꠥꠘꠥ ꠗꠥꠇꠣꠛꠣꠎꠤ। ");
INSERT INTO syls_vpl VALUES ("PS32_3","020_32_3","PSA","32","3","3","ꠔꠃꠛꠣ ꠇꠞꠍꠟꠣꠝ ꠘꠣ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ, ꠢꠣꠞꠣ ꠖꠤꠘ ꠇꠥꠇꠣꠁ ꠇꠥꠇꠣꠁ ꠇ꠆ꠇꠄ ꠅꠁꠍꠤꠟ ꠝꠞ ꠀꠒ꠆ꠒꠤ-ꠉꠥꠒ꠆ꠒꠤ। ");
INSERT INTO syls_vpl VALUES ("PS32_4","020_32_4","PSA","32","4","4","ꠔꠥꠝꠣꠞ ꠀꠔꠦ ꠎꠣꠔꠤꠀ ꠗꠞꠍꠤꠟ ꠖꠤꠘ-ꠞꠣꠁꠔ ꠀꠝꠣꠞꠦ, ꠇꠝꠤ ꠉꠦꠍꠤꠟ ꠝꠞ ꠇꠣꠄꠀꠞ ꠡꠇ꠆ꠔꠤ ꠌꠂꠔ-ꠝꠣꠁꠀ ꠉꠞꠝꠦ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS32_5","020_32_5","PSA","32","5","5","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠃꠛꠣ ꠇꠞꠟꠣꠝ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠦ, ꠅꠙꠞꠣꠗ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠟꠣꠝ ꠟꠥꠇꠣꠁꠟꠣꠝ ꠘꠣ ꠇꠥꠘꠥꠔꠣꠞꠦ, ꠇꠁꠟꠣꠝ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠝꠥ ꠅꠙꠞꠣꠗꠞꠦ, ꠟꠉꠦ ꠟꠉꠦꠃ ꠝꠣꠚꠤ ꠖꠤꠟꠣꠄ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠡꠛ ꠡꠣꠎꠣꠞꠦ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS32_6","020_32_6","PSA","32","6","6","ꠔꠦ ꠝꠍꠤꠛꠔꠞ ꠇꠣꠟꠅ ꠙꠞꠔꠦꠇ ꠙꠞꠦꠎꠉꠣꠞꠦ ꠖꠥꠀ ꠇꠞꠃꠇ ꠔꠥꠝꠣꠞꠃ ꠖꠞꠛꠣꠞꠦ, ꠝꠢꠣ ꠛꠁꠘ꠆ꠘꠣ ꠅꠁꠟꠦꠅ ꠙꠣꠁꠔ ꠘꠣꠄ ꠔ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS32_7","020_32_7","PSA","32","7","7","ꠝꠞ ꠟꠥꠇꠣꠘꠤꠞ ꠛꠣꠋꠇꠣꠞ ꠔꠥꠝꠤ ꠛꠣꠌꠣꠁꠍ ꠝꠞꠦ ꠝꠍꠤꠛꠔ ꠕꠣꠇꠤ, ꠀꠝꠤ ꠃꠖ꠆ꠖꠣꠞ ꠙꠣꠅꠀꠄ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠍ ꠔꠥꠝꠤ ꠝꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠈꠥꠡꠤꠞ ꠇꠣꠅꠀꠟꠤ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS32_8","020_32_8","PSA","32","8","8","ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠟꠤꠝ ꠖꠤꠝꠥ, ꠔꠥꠝꠣꠞꠦ ꠌꠟꠣꠞ ꠙꠕ ꠖꠦꠈꠣꠁꠝꠥ, ꠀꠝꠤ ꠔ ꠌꠃꠈꠖꠤ ꠘꠎꠞ ꠞꠣꠈꠝꠥ, ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠝꠥ, ");
INSERT INTO syls_vpl VALUES ("PS32_9","020_32_9","PSA","32","9","9","ꠉꠣꠗꠣ ꠇꠤꠛꠣ ꠊꠥꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠛꠥꠎ ꠅꠁꠅ ꠘꠣ, ꠁꠔꠣꠞꠦ ꠡꠣꠝꠟꠣꠁꠔꠦ ꠅꠄ ꠖꠠꠤ-ꠟꠣꠉꠣꠝ ꠖꠤꠀ, ꠘꠣ ꠖꠤꠟꠦ ꠝꠣꠘꠔ ꠘꠣꠄ ꠁꠔꠣ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠇꠕꠣ। ");
INSERT INTO syls_vpl VALUES ("PS32_10","020_32_10","PSA","32","10","10","ꠘꠣꠚꠞꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ ꠀꠍꠦ, ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠟꠦ ꠖꠄꠀ-ꠝꠣꠄꠀꠄ ꠛꠦꠞꠤꠀ ꠞꠣꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("PS32_11","020_32_11","PSA","32","11","11","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠘꠘ꠆ꠖ-ꠃꠟ꠆ꠟꠣꠡ ꠇꠞꠅ ꠡꠛ ꠙꠞꠦꠎꠉꠣꠞ, ꠎꠥꠞ ꠉꠟꠣꠄ ꠉꠣꠅ ꠉꠎꠟ-ꠉꠤꠔ ꠘꠤꠈꠥꠔ ꠖꠤꠟ ꠎꠣꠞ॥ ");
INSERT INTO syls_vpl VALUES ("PS33_1","020_33_1","PSA","33","1","1","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠉꠎꠟ ꠉꠣꠅ ꠅꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠛꠘ꠆ꠖꠣ, ꠘꠤꠈꠥꠔ ꠝꠥꠝꠤꠘꠞ ꠇꠣꠝ ꠅꠁꠟꠉꠤ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS33_2","020_33_2","PSA","33","2","2","ꠖꠥꠔꠣꠞꠣꠞ ꠔꠣꠟꠦ ꠔꠣꠟꠦ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠅ ꠔꠣꠘ, ꠖꠡ ꠔꠣꠞꠞ ꠛꠤꠘꠣ ꠛꠣꠎꠣꠁꠀ ꠇꠞꠅ ꠔꠣꠘ ꠉꠥꠘꠉꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS33_3","020_33_3","PSA","33","3","3","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠘꠄꠀ ꠘꠄꠀ ꠉꠤꠔ ꠛꠠ ꠉꠟꠣꠄ ꠉꠣꠅ, ꠘꠤꠈꠥꠔ ꠀꠔꠦ ꠔꠣꠘ ꠘꠤꠅꠔꠦ ꠛꠣꠎꠘꠣ ꠛꠣꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS33_4","020_33_4","PSA","33","4","4","ꠝꠣꠛꠥꠖꠞ ꠇꠣꠟꠣꠝ ꠔ ꠢꠇ ꠌꠤꠞꠇꠣꠟ, ꠔꠣꠘ ꠢꠇꠟ ꠇꠣꠝ ꠢꠣꠝꠦꠡꠣ ꠢꠇ-ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("PS33_5","020_33_5","PSA","33","5","5","ꠙꠞꠦꠎꠉꠣꠞꠤ ꠀꠞ ꠢꠇ-ꠁꠘꠍꠣꠚ ꠝꠣꠛꠥꠖꠦ ꠙꠣꠁꠘ ꠜꠣꠟꠣ, ꠀꠡ꠆ꠔꠣ ꠎꠉꠔ ꠜꠞꠣ ꠀꠍꠦ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ। ");
INSERT INTO syls_vpl VALUES ("PS33_6","020_33_6","PSA","33","6","6","ꠀꠍꠝꠣꠘ ꠔꠤꠀꠞ ꠅꠁꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠅꠃ ꠇꠣꠟꠣꠝꠦ, ꠄꠞ ꠝꠣꠎꠞ ꠡꠛꠔꠣꠃ ꠅꠁꠍꠦ ꠔꠣꠘ ꠝꠥꠈꠞ ꠚꠥꠄ। ");
INSERT INTO syls_vpl VALUES ("PS33_7","020_33_7","PSA","33","7","7","ꠖꠞꠤꠀꠞ ꠢꠇꠟ ꠙꠣꠘꠤꠞꠦ ꠇꠟꠡꠤꠔ ꠞꠣꠈꠂꠘ ꠔꠣꠁꠘ, ꠙꠣꠔꠣꠟꠞ ꠙꠣꠘꠤꠞꠦꠅ ꠔꠣꠁꠘ ꠜꠣꠘ꠆ꠒꠣꠞꠅ ꠎꠝꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS33_8","020_33_8","PSA","33","8","8","ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠄ ꠝꠣꠛꠥꠖꠞꠦ ꠒꠞꠣꠃꠇ, ꠖꠥꠘꠤꠀꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟ ꠔꠣꠘ ꠒꠞꠦ ꠇꠣꠙꠃꠇ, ");
INSERT INTO syls_vpl VALUES ("PS33_9","020_33_9","PSA","33","9","9","ꠔꠣꠘ ꠇꠕꠣꠄ ꠔ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠅꠁꠍꠦ ꠙꠄꠖꠣ, ꠔꠣꠘ ꠢꠥꠇꠥꠝꠞ ꠟꠉꠦ ꠟꠉꠦ ꠛꠅꠀꠁꠟ ꠅꠁꠍꠦ ꠢꠇꠟꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("PS33_10","020_33_10","PSA","33","10","10","ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠙꠞꠤꠇꠟ꠆ꠙꠘꠣ ꠝꠣꠛꠥꠖꠦ ꠇꠞꠂꠘ ꠛꠦꠇꠣꠝꠣ, ꠛꠤꠘꠣꠡ ꠇꠞꠂꠘ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS33_11","020_33_11","PSA","33","11","11","ꠝꠣꠛꠥꠖꠞꠃ ꠙꠞꠤꠇꠟ꠆ꠙꠘꠣ ꠌꠤꠞꠇꠣꠟ ꠐꠤꠇꠤꠀ ꠕꠣꠇꠦ, ꠔꠣꠘ ꠝꠘꠞ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠎꠥꠉ ꠎꠥꠉ ꠗꠞꠤ ꠛꠅꠀꠁꠟ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("PS33_12","020_33_12","PSA","33","12","12","ꠡꠥꠈꠤ ꠢꠃ ꠎꠣꠔꠤ, ꠀꠟ꠆ꠟꠣ ꠎꠣꠞ ꠀꠙꠘ ꠝꠣꠛꠥꠖ, ꠔꠣꠁꠘ ꠎꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ ꠇꠁꠀ ꠀꠙꠘ ꠖꠃꠟꠔ। ");
INSERT INTO syls_vpl VALUES ("PS33_13","020_33_13","PSA","33","13","13","ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠦ ꠌꠣꠁꠀ ꠖꠦꠈꠂꠘ, ꠢꠇ꠆ꠇꠟ ꠀꠖꠝ ꠡꠘ꠆ꠔꠣꠘꠞ ꠃꠙꠞꠦ ꠔꠣꠁꠘ ꠌꠃꠈ ꠞꠣꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS33_14","020_33_14","PSA","33","14","14","ꠁ ꠖꠥꠘꠤꠀꠔ ꠎꠦꠁꠘ-ꠔꠣꠁꠘ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠀꠞꠡ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠞꠣꠈꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("PS33_15","020_33_15","PSA","33","15","15","ꠙꠞꠔꠦꠇ ꠎꠘꠞ ꠖꠤꠟ ꠔ ꠔꠣꠁꠘ ꠉꠠꠤꠍꠂꠘ, ꠎꠦꠉꠤꠄ ꠎꠦꠔꠣ ꠇꠞꠦ ꠁꠔꠣ ꠛꠥꠎꠤꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS33_16","020_33_16","PSA","33","16","16","ꠛꠠ ꠍꠤꠙꠣꠁ ꠖꠟ ꠕꠣꠇꠟꠦꠅ ꠞꠣꠎꠣꠞ ꠞꠇ꠆ꠇꠣ ꠘꠣꠁ, ꠝꠢꠣꠡꠇ꠆ꠔꠤ ꠖꠤꠀꠅ ꠇꠥꠘꠥ ꠛꠤꠞ ꠎꠥꠖ꠆ꠖꠣꠄ ꠙꠣꠄ ꠘꠣ ꠞꠦꠢꠣꠁ, ");
INSERT INTO syls_vpl VALUES ("PS33_17","020_33_17","PSA","33","17","17","ꠎꠄꠅꠞ ꠟꠣꠉꠤ ꠊꠥꠠꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠣ ꠛꠦꠇꠣꠝꠣ, ꠊꠥꠠꠣꠞ ꠡꠇ꠆ꠔꠤ ꠎꠔꠃ ꠕꠣꠇꠃꠇ ꠛꠣꠌꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS33_18","020_33_18","PSA","33","18","18","ꠝꠣꠛꠥꠖꠞꠦ ꠎꠣꠞꠣ ꠒꠞꠣꠄ, ꠕꠣꠇꠦ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀꠞ ꠀꠡꠣꠄ, ꠔꠣꠁꠘ ꠈꠤꠀꠟ ꠞꠣꠈꠂꠘ ꠔꠣꠞꠣꠞ ꠛꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("PS33_19","020_33_19","PSA","33","19","19","ꠝꠞꠘ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠎꠤꠛꠘ ꠞꠇ꠆ꠇꠣ ꠇꠞꠂꠘ ꠔꠣꠁꠘ, ꠛꠠ ꠛꠠ ꠘꠤꠖꠣꠘ ꠇꠣꠟꠅ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS33_20","020_33_20","PSA","33","20","20","ꠝꠣꠛꠥꠖꠞ ꠅꠙꠦꠇ꠆ꠇꠣꠔ ꠀꠍꠤ ꠔ ꠀꠝꠞꠣ, ꠔꠣꠁꠘꠃ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠝꠣꠟꠤꠇ, ꠀꠝꠞꠣꠞ ꠜꠞꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("PS33_21","020_33_21","PSA","33","21","21","ꠔꠣꠘꠞꠦ ꠟꠁꠀꠃ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠚꠥꠞ꠆ꠔꠤ, ꠔꠣꠘ ꠙꠣꠇ ꠘꠣꠝꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS33_22","020_33_22","PSA","33","22","22","ꠅꠉ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞ ꠝꠣꠄꠀ-ꠖꠄꠀ ꠞꠃꠇ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ, ꠀꠝꠞꠣꠞ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠔꠥꠝꠣꠞꠃ ꠃꠙꠞꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS34_1","020_34_1","PSA","34","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ, ꠞꠣꠎꠣ ꠀꠛꠤꠝꠣꠟꠤꠇꠞ ꠍꠣꠝꠘꠦ ꠎꠦꠛꠟꠣ ꠙꠣꠉꠟ ꠛꠦꠡ ꠗꠞꠍꠟꠣ ꠀꠞ ꠔꠣꠘꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠟꠣ, ꠔꠣꠁꠘꠅ ꠉꠦꠟꠣꠉꠤ, ꠅꠃ ꠡꠝꠄꠇꠥꠞ ꠝꠤꠎꠝꠞ। ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠝꠥ, ꠔꠣꠘ ꠉꠥꠘꠉꠣꠘ ꠢꠣꠝꠦꠡꠣ ꠞꠁꠛ ꠝꠞ ꠝꠥꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("PS34_2","020_34_2","PSA","34","2","2","ꠀꠝꠣꠞ ꠎꠣꠘꠦ ꠛꠠꠣꠁ ꠇꠞꠦ ꠝꠣꠛꠥꠖꠞꠦ ꠟꠁꠀ, ꠖꠥꠈꠤ ꠎꠘꠦ ꠇꠞꠃꠇ ꠚꠥꠞ꠆ꠔꠤ ꠁꠔꠣ ꠢꠥꠘꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS34_3","020_34_3","PSA","34","3","3","ꠀꠝꠣꠞ ꠟꠉꠦ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠘꠉꠣꠘ ꠇꠞꠅ, ꠀꠅ ꠢꠇ꠆ꠇꠟꠦ ꠄꠇꠟꠉꠦ ꠔꠣꠘ ꠘꠣꠝꠦ ꠔꠣꠞꠤꠚ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS34_4","020_34_4","PSA","34","4","4","ꠀꠝꠤ ꠝꠣꠛꠥꠖꠞꠦ ꠒꠣꠇꠤꠍꠤ, ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠍꠂꠘ, ꠡꠛ ꠒꠞ-ꠈꠚ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠞꠇ꠆ꠇꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS34_5","020_34_5","PSA","34","5","5","ꠔꠣꠘ ꠛꠣꠄ ꠌꠣꠅ, ꠔꠥꠝꠞꠣ ꠘꠥꠞꠣꠘꠤ ꠅꠁꠎꠤꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈ ꠡꠞꠝ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS34_6","020_34_6","PSA","34","6","6","ꠁ ꠇꠣꠋꠉꠣꠟꠞ ꠒꠣꠇ ꠝꠣꠛꠥꠖꠦ ꠢꠥꠘꠍꠂꠘ, ꠡꠛ ꠝꠍꠤꠛꠔ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠛꠣꠌꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS34_7","020_34_7","PSA","34","7","7","ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠂꠘ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ, ꠖꠤꠀ ꠄꠞꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS34_8","020_34_8","PSA","34","8","8","ꠎꠣꠌꠣꠁ ꠇꠞꠤꠀ ꠖꠦꠈꠅ ꠝꠣꠛꠥꠖ ꠇꠔ ꠝꠦꠢꠦꠞꠛꠣꠘ, ꠛꠠ ꠇꠙꠣꠟꠤ ꠢꠃ ꠎꠘ ꠎꠦ ꠀꠡꠞꠄ ꠟꠄ ꠍꠣꠄꠀꠔ ꠔꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS34_9","020_34_9","PSA","34","9","9","ꠅ ꠝꠣꠛꠥꠖꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠔꠣꠘꠞꠦ ꠒꠞꠣꠅ, ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥꠔꠣꠞ ꠅꠜꠣꠛ ꠘꠣꠁ ꠎꠣꠞꠣ ꠒꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS34_10","020_34_10","PSA","34","10","10","ꠛꠟꠀꠟꠣ ꠡꠤꠋꠢꠞ ꠙꠣꠟ ꠈꠣꠘꠤꠞ ꠅꠜꠣꠛꠦ ꠃꠙꠣꠡ, ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇ ꠅꠇꠟꠞ ꠜꠣꠟꠣꠁꠞ ꠇꠥꠘꠥ ꠅꠜꠣꠛ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS34_11","020_34_11","PSA","34","11","11","ꠅꠞꠦ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠀꠅ, ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠒꠞ-ꠈꠚꠞ ꠇꠕꠣ ꠢꠤꠇꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS34_12","020_34_12","PSA","34","12","12","ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠡꠥꠈ ꠌꠣꠄ ꠇꠥꠘ ꠎꠘꠦ, ꠡꠥꠖꠤꠘ ꠖꠦꠈꠣꠞ ꠀꠡꠣ ꠇꠞꠦ ꠇꠦ? ");
INSERT INTO syls_vpl VALUES ("PS34_13","020_34_13","PSA","34","13","13","ꠔꠦ ꠢꠦ ꠛꠣꠖ ꠇꠕꠣ ꠕꠣꠇꠤ ꠎꠤꠚꠞꠣꠞꠦ ꠡꠣꠝꠟꠣꠃꠇ ꠍꠟ-ꠌꠔꠥꠞꠤ ꠕꠣꠇꠤ ꠑꠥꠐꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("PS34_14","020_34_14","PSA","34","14","14","ꠛꠣꠖ ꠇꠣꠝ ꠕꠣꠇꠤ ꠚꠤꠞꠤꠀ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠃꠇ, ꠡꠣꠘ꠆ꠔꠤꠞ ꠀꠡꠤꠇ ꠅꠁꠀ ꠄꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PS34_15","020_34_15","PSA","34","15","15","ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞ ꠔ ꠙꠞꠦꠎꠉꠣꠞꠞ ꠃꠙꠞꠦ, ꠔꠣꠞꠣꠞ ꠖꠥꠀ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠇꠣꠘ ꠈꠣꠠꠣ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("PS34_16","020_34_16","PSA","34","16","16","ꠛꠣꠖ ꠇꠣꠝ ꠇꠞꠞꠣꠞ ꠃꠙꠞ ꠝꠣꠛꠥꠖꠞ ꠛꠖ ꠘꠎꠞ, ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠟꠤꠛꠣ ꠘꠣꠝ-ꠘꠤꠡꠣꠘꠣ ꠔꠣꠞꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS34_17","020_34_17","PSA","34","17","17","ꠖꠤꠘꠖꠣꠞꠦ ꠚꠞꠤꠀꠖ ꠇꠞꠟꠦ ꠢꠥꠘꠂꠘ ꠝꠣꠛꠥꠖꠦ, ꠛꠣꠟꠣ-ꠝꠍꠤꠛꠔ ꠕꠣꠇꠤ ꠞꠇ꠆ꠇꠣ ꠇꠞꠂꠘ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS34_18","020_34_18","PSA","34","18","18","ꠝꠘ ꠎꠣꠞꠣꠞ ꠜꠣꠋꠉꠤ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖ ꠞꠂꠘ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ, ꠖꠤꠟ ꠎꠣꠞꠣꠞ ꠌꠥꠞꠝꠣꠞ ꠅꠁꠍꠦ ꠝꠣꠛꠥꠖꠦꠃ ꠛꠣꠌꠣꠁꠘ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS34_19","020_34_19","PSA","34","19","19","ꠢꠇ ꠙꠕꠦ ꠎꠦ ꠌꠟꠦ ꠔꠣꠞ ꠛꠃꠔ ꠝꠍꠤꠛꠔ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠦꠃ ꠔꠣꠞꠦ ꠇꠞꠂꠘ ꠢꠦꠚꠣꠎꠔ। ");
INSERT INTO syls_vpl VALUES ("PS34_20","020_34_20","PSA","34","20","20","ꠘꠤꠞꠣꠙꠖ ꠞꠣꠈꠂꠘ ꠔꠣꠁꠘ ꠔꠣꠞ ꠡꠛ ꠀꠒ꠆ꠒꠤꠞꠦ, ꠜꠣꠋꠉꠣ ꠅꠁꠔ ꠘꠣꠄ ꠔ ꠁꠔꠣ ꠇꠥꠘꠥꠐꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS34_21","020_34_21","PSA","34","21","21","ꠈꠣꠞꠣꠙ ꠇꠣꠝꠞ ꠖꠣꠄ ꠅꠄ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠝꠞꠘ ꠖꠡꠣ, ꠙꠞꠦꠎꠉꠣꠞꠞꠦ ꠁꠋꠡꠣꠄ ꠎꠣꠞꠣ, ꠡꠣꠎꠣ ꠙꠣꠁꠛ ꠔꠣꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS34_22","020_34_22","PSA","34","22","22","ꠝꠣꠛꠥꠖꠦ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠂꠘ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ, ꠔꠣꠘ ꠀꠡꠞꠄ ꠟꠄ ꠎꠣꠞꠣ, ꠡꠣꠎꠣ ꠖꠦꠁꠘ ꠘꠣ ꠁꠔꠣ ꠇꠦꠃꠞꠞꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS35_1","020_35_1","PSA","35","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠀꠝꠣꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠦꠞ ꠎꠣꠞꠣ, ꠔꠥꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠞꠅ ꠔꠣꠞꠣꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ, ꠟꠣꠠꠣꠁ ꠇꠞꠦꠞ ꠎꠣꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ, ꠔꠥꠝꠤꠅ ꠟꠣꠠꠣꠁ ꠇꠞꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("PS35_2","020_35_2","PSA","35","2","2","ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠀꠔꠤꠀꠞ ꠟꠅ ꠔꠥꠝꠣꠞ ꠀꠔꠅ, ꠀꠝꠣꠞ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ ꠎꠟꠖꠤ ꠀꠅ ꠉ। ");
INSERT INTO syls_vpl VALUES ("PS35_3","020_35_3","PSA","35","3","3","ꠀꠝꠣꠞꠦ ꠈꠦꠖꠣꠅꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠔꠅ ꠟꠅ ꠍꠥꠟꠚꠤ-ꠇꠥꠌꠣ, ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ ꠇꠅ ꠉ, “ꠀꠝꠤꠃ ꠔꠥꠝꠣꠞ ꠛꠣꠌꠣꠘꠦꠀꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("PS35_4","020_35_4","PSA","35","4","4","ꠀꠝꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠔ ꠌꠣꠄ ꠎꠣꠞꠣ, ꠛꠦꠁꠎ꠆ꠎꠔ-ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠃꠇ ꠔꠣꠞꠣ, ꠀꠝꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠔ ꠌꠣꠄ ꠎꠣꠞꠣ, ꠜꠣꠉꠤꠀ ꠎꠣꠃꠇ ꠔꠣꠞꠣ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("PS35_5","020_35_5","PSA","35","5","5","ꠗꠣꠘꠞ ꠍꠥꠍꠣꠞꠦ ꠎꠦꠟꠣ ꠔꠥꠚꠣꠘꠦ ꠘꠦꠄ ꠃꠠꠣꠁꠀ, ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠅꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠃꠇ꠆ꠇꠣ ꠈꠦꠖꠣꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("PS35_6","020_35_6","PSA","35","6","6","ꠔꠣꠞꠣꠞ ꠙꠕ ꠅꠃꠇ ꠀꠘ꠆ꠖꠣꠁꠞ ꠀꠞ ꠙꠤꠍꠟꠣ, ꠈꠦꠖꠣꠁꠀ ꠘꠦꠃꠇ꠆ꠇꠣ ꠔꠣꠞꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("PS35_7","020_35_7","PSA","35","7","7","ꠝꠞꠦ ꠗꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠙꠣꠔꠤꠍꠦ ꠎꠣꠟ ꠟꠥꠇꠣꠁꠀ, ꠀꠝꠣꠞ ꠎꠣꠘ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠖꠤꠍꠦ ꠉꠣꠔ ꠈꠣꠝꠈꠣ। ");
INSERT INTO syls_vpl VALUES ("PS35_8","020_35_8","PSA","35","8","8","ꠀꠈꠔꠣ ꠇꠞꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠡꠞ꠆ꠛꠘꠣꠡ ꠟꠣꠝꠃꠇ, ꠔꠣꠞꠣꠞ ꠙꠣꠔꠣꠁꠟ ꠎꠣꠟꠅ ꠔꠣꠞꠣꠃ ꠢꠣꠝꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PS35_9","020_35_9","PSA","35","9","9","ꠔꠦꠃꠉꠤ ꠀꠝꠣꠞ ꠖꠤꠟꠦ ꠉꠣꠁꠛ ꠝꠣꠛꠥꠖꠞ ꠈꠥꠡꠤꠞ ꠉꠣꠘ, ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠄ ꠉꠣꠁꠝꠥ ꠔꠣꠘ ꠡꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS35_10","020_35_10","PSA","35","10","10","ꠀꠝꠣꠞ ꠝꠘꠦ-ꠔꠘꠦ ꠇꠃꠇ, “ꠅ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠢꠝꠣꠘ ꠀꠞ ꠇꠦ ꠀꠍꠦ ꠎꠉꠔꠦ? ꠛꠟꠛꠣꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠅ ꠘꠤꠞꠣꠡ꠆ꠞꠄꠞꠦ, ꠟꠥꠐꠇꠣꠞꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠥꠝꠤ ꠛꠣꠌꠣꠁꠞꠣꠄ ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("PS35_11","020_35_11","PSA","35","11","11","ꠁꠋꠡꠣꠈꠥꠞ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤꠞ ꠖꠟ ꠟꠣꠉꠍꠤꠟ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ, ꠀꠝꠤ ꠎꠦꠔꠣ ꠎꠣꠘꠤ ꠘꠣ ꠅꠔꠣ ꠛꠤꠡꠄ ꠝꠞꠦ ꠎꠤꠇꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS35_12","020_35_12","PSA","35","12","12","ꠃꠙꠇꠣꠞꠞ ꠛꠖꠟꠣ ꠔꠣꠞꠣ ꠇꠞꠍꠦ ꠀꠝꠣꠞ ꠈꠦꠔꠤ, ꠇꠔ ꠇꠙꠣꠟ ꠙꠥꠠꠣ ꠀꠝꠤ, ꠢꠣꠄ-ꠢꠥꠔꠣꠡ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS35_13","020_35_13","PSA","35","13","13","ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠍꠟꠣꠞ ꠌꠐ ꠚꠤꠘ꠆ꠖꠤꠔꠣꠝ, ꠇꠡ꠆ꠐ ꠇꠞꠤ ꠞꠥꠎꠣ ꠞꠣꠈꠤꠀ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠖꠥꠀ ꠇꠞꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PS35_14","020_35_14","PSA","35","14","14","ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞ ꠖꠥꠡ꠆ꠔ ꠝꠞꠟꠦ ꠝꠣꠘꠡꠦ ꠇꠣꠘ꠆ꠖꠦ ꠎꠦꠟꠣ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤꠅ ꠔ ꠇꠣꠘ꠆ꠖꠤꠔꠣꠝ ꠅꠟꠣ, ꠝꠣ ꠝꠞꠟꠦ ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ ꠝꠣꠕꠣ ꠎꠦꠟꠣ ꠅꠁꠎꠣꠄ ꠘꠤꠌꠣ। ");
INSERT INTO syls_vpl VALUES ("PS35_15","020_35_15","PSA","35","15","15","ꠀꠝꠤ ꠇꠥꠘꠥ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠟꠦ ꠈꠥꠡꠤꠞ ꠑꠦꠟꠣꠄ ꠔꠣꠞꠣ ꠎꠝꠦ, ꠅꠌꠤꠘꠣ ꠝꠣꠘꠡꠦ ꠝꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠔꠦ ꠀꠞ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠔꠦ ꠘꠣ ꠕꠣꠝꠦ। ");
INSERT INTO syls_vpl VALUES ("PS35_16","020_35_16","PSA","35","16","16","ꠛꠦꠁꠝꠣꠘꠞ ꠖꠟꠦ ꠝꠤꠟꠤ ꠀꠡꠤ-ꠔꠣꠝꠡꠣ ꠇꠞꠟ ꠝꠞꠦ, ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠈꠣꠁꠟ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ। ");
INSERT INTO syls_vpl VALUES ("PS35_17","020_35_17","PSA","35","17","17","ꠌꠣꠁꠀ ꠌꠣꠁꠀ ꠇꠔꠖꠤꠘ ꠖꠦꠈꠔꠣꠄ ꠝꠣꠛꠥꠖ ꠔꠣꠞꠣꠞ ꠁꠋꠡꠣ-ꠊꠤꠘ꠆ꠘꠣ? ꠡꠤꠋꠢꠞ ꠖꠣꠔꠅ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠎꠣꠘꠈꠣꠘ ꠔꠥꠝꠤ ꠛꠣꠌꠣꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS35_18","020_35_18","PSA","35","18","18","ꠝꠢꠣ ꠝꠎꠟꠤꠍꠅ ꠀꠝꠤ ꠀꠖꠣꠄ ꠇꠞꠝꠥ ꠡꠥꠇꠞꠤꠀ, ꠔꠥꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠉꠣꠁꠝꠥ ꠀꠝꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠖꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS35_19","020_35_19","PSA","35","19","19","ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣ ꠖꠥꠡꠝꠘ ꠙꠣꠟꠦ ꠘꠣ ꠇꠞꠃꠇ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠝꠞꠦ ꠟꠁꠀ, ꠈꠣꠝꠈꠣ ꠊꠤꠘ꠆ꠘꠣꠄ ꠝꠞꠦ ꠎꠣꠞꠣ ꠌꠃꠈ ꠐꠤꠙꠣꠐꠤꠙꠤ ꠇꠞꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("PS35_20","020_35_20","PSA","35","20","20","ꠔꠣꠞꠣ ꠔ ꠡꠣꠘ꠆ꠔꠤꠞ ꠝꠣꠔ ꠝꠣꠔꠦ ꠘꠣ, ꠖꠦꠡꠞ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠇꠞꠦ ꠍꠟꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS35_21","020_35_21","PSA","35","21","21","ꠝꠥꠈ ꠜꠦꠋꠉꠣꠁꠀ ꠀꠝꠣꠞ ꠛꠣꠄ ꠔꠣꠝꠡꠣ ꠇꠞꠤ ꠇꠄ ꠔꠣꠞꠣ, “ꠇꠔ ꠝꠎꠣ, ꠇꠔ ꠝꠎꠣ, ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠟꠣꠝ ꠀꠝꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("PS35_22","020_35_22","PSA","35","22","22","ꠘꠤꠞꠣꠁ ꠞꠁꠅ ꠘꠣ ꠝꠣꠛꠥꠖ ꠉ ꠖꠦꠈꠞꠣꠄ ꠔ ꠢꠇꠟꠔꠣ, ꠀꠝꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠝꠣꠛꠥꠖ ꠢꠞꠤꠀ ꠞꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS35_23","020_35_23","PSA","35","23","23","ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠉꠥꠀꠁ ꠀꠅ ꠇꠞꠅ ꠀꠝꠣꠞ ꠢꠇ ꠛꠤꠌꠣꠞ, ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠞꠅ ꠉ ꠀꠟ꠆ꠟꠣ ꠔꠥꠝꠤꠃ ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS35_24","020_35_24","PSA","35","24","24","ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠅ ꠀꠟ꠆ꠟꠣ ꠘꠤꠎꠞ ꠙꠣꠇ ꠙꠞꠦꠎꠉꠣꠞꠤꠄ, ꠅꠉ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖ, ꠝꠞꠦ ꠟꠁꠀ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠈꠥꠡꠤ-ꠚꠥꠞ꠆ꠔꠤ ꠘꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS35_25","020_35_25","PSA","35","25","25","ꠔꠣꠞꠣꠞ ꠖꠤꠅ ꠘꠣ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠔꠦ, “ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠌꠣꠁꠍꠤ ꠅꠔꠣꠃ ꠔ ꠅꠁꠍꠦ।” ꠄꠅꠈꠣꠘ ꠇꠁꠔꠦ ꠖꠤꠅ ꠘꠣ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ, “ꠎꠤꠘ꠆ꠖꠣ ꠉꠤꠟꠤꠀ ꠢꠣꠞꠣꠁꠍꠤ ꠅꠉꠥꠞꠦ ꠙꠦꠐꠞ ꠜꠤꠔꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("PS35_26","020_35_26","PSA","35","26","26","ꠝꠍꠤꠛꠔ ꠖꠦꠈꠤꠀ ꠀꠝꠣꠞ ꠇꠞꠂꠘ ꠎꠦꠔꠣꠄ ꠈꠥꠡꠤ-ꠚꠥꠞ꠆ꠔꠤ, ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠛꠘꠤꠀ ꠔꠣꠞꠣ ꠅꠃꠇ ꠘꠤꠌꠣ ꠝꠥꠈꠤ, ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠔꠣꠄ ꠇꠞꠦ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ, ꠡꠞꠝ ꠀꠞ ꠛꠦꠁꠎ꠆ꠎꠔꠤꠔ ꠒꠥꠛꠃꠇ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("PS35_27","020_35_27","PSA","35","27","27","ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤ ꠖꠦꠈꠤꠀ ꠝꠞ ꠅꠄ ꠎꠣꠞꠣ ꠈꠥꠡ-ꠛꠣꠡ, ꠈꠥꠡꠤꠞ ꠌꠥꠐꠦ ꠔꠣꠞꠣ ꠇꠞꠃꠇ ꠀꠘꠘ꠆ꠖ-ꠃꠟ꠆ꠟꠣꠡ। ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠇꠃꠇ ꠔꠣꠞꠣ ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ, ꠘꠤꠎꠞ ꠛꠘ꠆ꠖꠣꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠦꠈꠤꠀ ꠈꠥꠡꠤ ꠅꠁꠘ ꠔ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS35_28","020_35_28","PSA","35","28","28","ꠔꠥꠝꠣꠞ ꠢꠇ ꠛꠤꠌꠣꠞꠞ ꠉꠥꠘ ꠉꠣꠁꠝꠥ ꠀꠝꠣꠞ ꠎꠤꠚꠞꠣꠖꠤ, ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁꠝꠥ ꠔꠥꠝꠣꠞ ꠖꠤꠘ-ꠞꠣꠁꠔ ꠜꠞꠤ॥ ");
INSERT INTO syls_vpl VALUES ("PS36_1","020_36_1","PSA","36","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠝꠣꠛꠥꠖꠞ ꠛꠘ꠆ꠖꠣ ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠘꠣꠚꠞꠝꠣꠘꠞ ꠈꠣꠞꠣꠙꠤꠞ ꠛꠦꠙꠣꠞꠦ, ꠝꠣꠛꠥꠖꠞ ꠇꠣꠟꠣꠝ ꠙꠣꠁꠍꠦ ꠀꠝꠣꠞ ꠖꠤꠟꠦ, ꠔꠣꠞꠣꠞ ꠌꠈꠥꠔ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚ ꠘꠣꠁꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS36_2","020_36_2","PSA","36","2","2","ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠦ ꠘꠤꠎꠞ ꠛꠣꠢꠣꠖꠥꠞꠤ, ꠘꠤꠎꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ ꠘꠣ ꠅꠙꠞꠣꠗ ꠇꠣꠝ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS36_3","020_36_3","PSA","36","3","3","ꠍꠟ-ꠌꠔꠥꠞꠤ ꠈꠣꠞꠣꠙꠤꠄ ꠜꠞꠣ ꠔꠣꠞꠣꠞ ꠝꠥꠈꠞ ꠇꠕꠣ, ꠀꠈꠟ ꠈꠣꠐꠣꠁ ꠌꠟꠣ, ꠘꠦꠇ ꠇꠣꠝ ꠕꠣꠇꠤ ꠞꠄ ꠢꠞꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS36_4","020_36_4","PSA","36","4","4","ꠛꠤꠍꠘꠣꠔ ꠢꠥꠔꠤꠀ ꠔꠣꠞꠣ ꠇꠥ-ꠇꠣꠝꠞ ꠗꠣꠘ꠆ꠖꠣ ꠇꠞꠦ, ꠛꠖ ꠇꠣꠝ ꠘꠣ ꠍꠣꠠꠤꠀ ꠝꠘ꠆ꠖ ꠙꠕꠦ ꠌꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("PS36_5","020_36_5","PSA","36","5","5","ꠅꠉ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀꠄ ꠀꠍꠝꠣꠘ ꠍꠁꠟꠣꠁꠍꠦ, ꠔꠥꠝꠣꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤꠔ ꠟꠣꠉꠤ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS36_6","020_36_6","PSA","36","6","6","ꠙꠣꠠ-ꠙꠞꠛꠔꠞ ꠟꠣꠈꠣꠘ ꠃꠌꠣ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠔꠥꠝꠣꠞ, ꠉꠁꠘ ꠖꠞꠤꠀꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠣꠞ ꠢꠇ ꠛꠤꠌꠣꠞ, ꠝꠣꠛꠥꠖꠦꠃ ꠛꠣꠌꠣꠅ ꠔ ꠡꠛ ꠝꠣꠘꠥꠡ ꠀꠞ ꠎꠣꠘꠥꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("PS36_7","020_36_7","PSA","36","7","7","ꠅꠉ ꠀꠟ꠆ꠟꠣ ꠔꠥꠝꠣꠞ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ ꠝꠢꠣ ꠝꠥꠁꠟ꠆ꠟꠛꠣꠘ, ꠀꠖꠝ ꠎꠣꠔꠤꠄ ꠀꠡꠞꠄ ꠙꠣꠄ ꠔꠥꠝꠣꠞ ꠒꠣꠈꠘꠣꠞ ꠍꠣꠄꠀꠔ। ");
INSERT INTO syls_vpl VALUES ("PS36_8","020_36_8","PSA","36","8","8","ꠔꠥꠝꠣꠞ ꠊꠞꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠄ ꠔꠣꠞꠣꠞ ꠙꠦꠐ ꠜꠞꠤ ꠎꠣꠄ, ꠔꠥꠝꠣꠞ ꠅꠝ꠆ꠞꠤꠔ ꠙꠣꠘꠤꠄ ꠔꠣꠞꠣꠞ ꠔꠤꠞꠣꠡ ꠝꠤꠐꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS36_9","020_36_9","PSA","36","9","9","ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠙꠣꠘꠤꠞ ꠁꠘ꠆ꠖꠣꠞꠣ, ꠔꠥꠝꠣꠞ ꠘꠥꠞꠦꠃ ꠔ ꠖꠦꠈꠤ ꠘꠥꠞ ꠀꠝꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS36_10","020_36_10","PSA","36","10","10","ꠔꠥꠝꠣꠞꠦ ꠎꠣꠞꠣ ꠌꠤꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠔꠥꠝꠤ ꠛꠤꠟꠣꠁ ꠖꠦꠅ ꠔꠥꠝꠣꠞ ꠖꠄꠀ-ꠝꠣꠄꠀ, ꠡꠞꠟ ꠖꠤꠟꠞ ꠝꠣꠘꠡꠦ ꠙꠣꠄ ꠔꠥꠝꠣꠞ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("PS36_11","020_36_11","PSA","36","11","11","ꠅꠢꠋꠇꠣꠞꠤ ꠎꠘꠦ ꠎꠣꠘꠥ ꠙꠣꠅ ꠘꠣ ꠛꠣꠠꠣꠄ ꠀꠝꠣꠞ ꠛꠣꠄ, ꠘꠣꠚꠞꠝꠣꠘꠞ ꠀꠔꠦ ꠎꠣꠘꠥ ꠀꠝꠣꠞꠦ ꠘꠣ ꠈꠦꠖꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS36_12","020_36_12","PSA","36","12","12","ꠖꠦꠈꠞꠣꠄ ꠘꠤ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠎꠦꠔꠣꠄ ꠇꠞꠍꠦ ꠁꠔꠣ ꠔ ꠟꠦꠐꠤ ꠉꠦꠍꠦ, ꠃꠑꠤꠔ ꠙꠣꠞꠦꠞ ꠘꠣ ꠔꠣꠞꠣ, ꠚꠣꠟꠣꠁ ꠖꠤꠍꠂꠘ ꠁꠔꠣꠞꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS37_1","020_37_1","PSA","37","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠘꠣꠚꠞꠝꠣꠘꠞ ꠃꠘ꠆ꠘꠔꠤ ꠖꠦꠈꠤꠀ ꠝꠘ ꠈꠣꠞꠣꠙ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠇꠞꠤꠅ ꠘꠣ ꠁꠋꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_2","020_37_2","PSA","37","2","2","ꠔꠣꠞꠣ ꠔ ꠊꠣꠡꠞ ꠟꠣꠈꠣꠘ ꠎꠟꠖꠤ ꠢꠥꠇꠣꠁ ꠎꠤꠛ, ꠛꠘ꠆ꠖꠞ ꠙꠣꠔꠣ-ꠍꠣꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠔꠣꠞ ꠛꠦꠢꠣꠟꠔ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PS37_3","020_37_3","PSA","37","3","3","ꠝꠣꠛꠥꠖꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠅ, ꠢꠇ-ꠢꠣꠟꠣꠟ ꠞꠁꠀ ꠢꠣꠞꠤ ꠛꠡꠔ ꠇꠞꠅ ꠖꠦꠡꠅ। ");
INSERT INTO syls_vpl VALUES ("PS37_4","020_37_4","PSA","37","4","4","ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠅ ꠔꠥꠝꠤ ꠝꠣꠛꠥꠖꠞꠦ ꠟꠁꠀ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠣꠞ ꠝꠘꠞ ꠀꠡꠣ ꠙꠥꠞꠘ ꠇꠞꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_5","020_37_5","PSA","37","5","5","ꠔꠥꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠢꠇꠟ ꠜꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠀꠔꠅ ꠍꠣꠠꠅ, ꠔꠣꠁꠘꠃ ꠌꠣꠟꠣꠁꠛꠣ ꠢꠇꠟꠔꠣ, ꠘꠤꠌ꠆ꠌꠤꠔ ꠜꠞꠡꠣ ꠞꠣꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("PS37_6","020_37_6","PSA","37","6","6","ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤꠞꠦ ꠇꠞꠛꠣ ꠃꠎꠤꠟꠣ, ꠔꠥꠝꠣꠞ ꠘꠤꠞ꠆ꠖꠥꠡꠤꠔꠣ ꠎꠣꠁꠞ ꠇꠞꠛꠣ ꠖꠥꠁꠚꠞꠞ ꠟꠣꠈꠣꠘ ꠌꠇꠌꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_7","020_37_7","PSA","37","7","7","ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠞꠣꠁ ꠞꠁꠀ ꠔꠣꠘ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠅ, ꠚꠘ꠆ꠖꠤꠛꠣꠎꠞ ꠃꠘ꠆ꠘꠔꠤ ꠖꠦꠈꠤꠀ ꠛꠦꠎꠣꠞ ꠘꠣ ꠅꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("PS37_8","020_37_8","PSA","37","8","8","ꠉꠥꠍꠣꠞꠦ ꠖꠝꠘ ꠇꠞꠤꠀ ꠕꠣꠝꠣꠅ ꠝꠤꠎꠣꠎ ꠖꠦꠈꠣꠘꠤ, ꠛꠦꠎꠣꠞ ꠅꠁꠅ ꠘꠣ ꠔꠥꠝꠤ, ꠈꠣꠞꠣꠙꠤꠃ ꠁꠔꠣꠞ ꠚꠟ ꠈꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("PS37_9","020_37_9","PSA","37","9","9","ꠝꠣꠛꠥꠖꠞ ꠜꠞꠡꠣ ꠇꠞꠞꠣꠄ ꠖꠦꠡꠞ ꠝꠃꠞꠡꠤ-ꠝꠣꠟꠤꠇ ꠛꠘꠤꠛ, ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠔ ꠘꠤꠌ꠆ꠌꠤꠔ ꠡꠞ꠆ꠛꠘꠣꠡ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PS37_10","020_37_10","PSA","37","10","10","ꠕꠥꠠꠣ ꠖꠤꠘ ꠛꠣꠖꠦꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠁꠛ ꠘꠤꠙꠣꠔ, ꠔꠥꠇꠣꠁꠟꠦꠅ ꠝꠤꠟꠔ ꠘꠣꠄ ꠀꠞ ꠔꠣꠞꠣꠞ ꠎꠣꠉꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("PS37_11","020_37_11","PSA","37","11","11","ꠘꠞꠝ ꠖꠤꠟꠞ ꠝꠣꠘꠡꠦ ꠙꠣꠁꠛꠣ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ, ꠡꠣꠄ-ꠡꠣꠘ꠆ꠔꠤꠄ ꠞꠁꠀ ꠔꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_12","020_37_12","PSA","37","12","12","ꠘꠣꠚꠞꠝꠣꠘꠦ ꠍꠟ-ꠌꠔꠥꠞꠤ ꠇꠞꠦ ꠙꠞꠦꠎꠉꠣꠞꠞ ꠛꠤꠙꠇ꠆ꠇꠦ, ꠖꠥꠡꠝꠘꠤ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS37_13","020_37_13","PSA","37","13","13","ꠔꠣꠞꠣꠞ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠝꠣꠛꠥꠖꠦ ꠔ ꠀꠡꠂꠘ, ꠘꠣꠚꠞꠝꠣꠘꠞ ꠖꠤꠘ ꠡꠦꠡ ꠁꠔꠣ ꠔꠣꠁꠘ ꠖꠦꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS37_14","020_37_14","PSA","37","14","14","ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟꠞꠦ ꠙꠣꠅꠖꠤ ꠃꠠꠤꠀ ꠈꠥꠘꠞ ꠈꠤꠀꠟꠦ, ꠘꠣꠚꠞꠝꠣꠘꠦ ꠔꠟꠥꠀꠞ ꠈꠥꠟꠤꠀ ꠔꠤꠞ-ꠗꠘꠥꠇ ꠢꠣꠎꠣꠁ ꠞꠣꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("PS37_15","020_37_15","PSA","37","15","15","ꠅꠃ ꠔꠟꠥꠀꠞ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠇꠟꠤꠎꠣꠔꠃ ꠢꠣꠝꠣꠁꠛ, ꠔꠣꠞꠣꠞ ꠔꠤꠞ-ꠗꠘꠥꠇꠅ ꠜꠣꠋꠉꠤꠀ ꠢꠣꠞꠤ ꠛꠦꠇꠣꠝꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PS37_16","020_37_16","PSA","37","16","16","ꠘꠣꠚꠞꠝꠣꠘꠞ ꠛꠦꠡꠤ ꠗꠘ-ꠖꠃꠟꠔ ꠕꠣꠇꠤꠀ, ꠙꠞꠦꠎꠉꠣꠞꠞ ꠕꠥꠠꠣ ꠗꠘꠃ ꠛꠃꠔ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_17","020_37_17","PSA","37","17","17","ꠘꠣꠚꠞꠝꠣꠘꠞ ꠀꠔ ꠔ ꠎꠣꠁꠛꠉꠤ ꠜꠣꠋꠉꠤꠀ, ꠙꠞꠦꠎꠉꠣꠞꠞꠦ ꠛꠣꠌꠣꠁꠘ ꠘꠤꠌ꠆ꠌꠄ ꠝꠣꠛꠥꠖꠦ ꠗꠞꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS37_18","020_37_18","PSA","37","18","18","ꠝꠣꠛꠥꠖꠦ ꠖꠦꠈꠂꠘ ꠖꠤꠘꠖꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠢꠣꠟꠔ, ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠞꠁꠛ ꠔꠣꠞꠣꠞ ꠝꠃꠞꠡꠤ ꠖꠃꠟꠔ। ");
INSERT INTO syls_vpl VALUES ("PS37_19","020_37_19","PSA","37","19","19","ꠝꠍꠤꠛꠔꠞ ꠖꠤꠘꠅ ꠔꠣꠞꠣ ꠅꠁꠔ ꠘꠣꠄ ꠡꠞꠝꠤꠘ꠆ꠖꠣ, ꠀꠇꠣꠟ-ꠘꠤꠖꠣꠘꠞ ꠇꠣꠟꠅ ꠔꠣꠞꠣ ꠙꠦꠐ ꠜꠞꠣ ꠈꠣꠘꠤ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_20","020_37_20","PSA","37","20","20","ꠘꠣꠝ-ꠘꠤꠡꠣꠘꠣ ꠝꠤꠐꠤꠎꠤꠛ ꠎꠣꠞꠣ ꠘꠣꠚꠞꠝꠣꠘ, ꠝꠣꠛꠥꠖꠞ ꠖꠥꠡꠝꠘ ꠢꠥꠇꠣꠁ ꠎꠤꠛ ꠀꠅꠞꠤ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ, ꠖꠦꠈꠛꠣꠄ ꠔꠣꠞꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠚꠥꠠꠣꠁ ꠎꠤꠛ, ꠗꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠔꠣ ꠛꠣꠔꠣꠡꠅ ꠝꠤꠡꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("PS37_21","020_37_21","PSA","37","21","21","ꠘꠣꠚꠞꠝꠣꠘꠦ ꠇꠞ꠆ꠎ ꠘꠤꠀ ꠚꠤꠞꠔ ꠘꠣ ꠖꠤꠟꠣꠄ, ꠙꠞꠦꠎꠉꠣꠞꠦ ꠖꠣꠘ ꠛꠤꠟꠣꠄ ꠝꠣꠄꠀ-ꠝꠝꠔꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS37_22","020_37_22","PSA","37","22","22","ꠝꠣꠛꠥꠖꠞ ꠞꠢꠝꠔꠤ ꠎꠘ ꠎꠣꠞꠣ ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠛ ꠔꠣꠞꠣ, ꠔꠣꠘ ꠟꠣꠘ꠆ꠘꠔꠤ ꠎꠘꠞ ꠔ ꠝꠤꠐꠤꠎꠤꠛ ꠘꠣꠝ-ꠘꠤꠡꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_23","020_37_23","PSA","37","23","23","ꠎꠣꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠖꠦꠈꠤꠀ ꠝꠣꠛꠥꠖ ꠅꠁꠘ ꠈꠥꠡꠤ, ꠔꠣꠁꠘꠃ ꠝꠎꠛꠥꠔ ꠇꠞꠂꠘ ꠔꠣꠞꠣꠞ ꠌꠟꠣꠞ ꠉꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS37_24","020_37_24","PSA","37","24","24","ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠗꠞꠤꠀ ꠞꠣꠈꠣꠄ, ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠟꠦꠅ ꠔꠣꠞꠣ ꠙꠠꠤꠀ ꠞꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS37_25","020_37_25","PSA","37","25","25","ꠀꠝꠤ ꠀꠉꠦ ꠎꠥꠀꠘ ꠀꠍꠟꠣꠝ ꠅꠈꠘ ꠛꠥꠠꠣ ꠅꠁꠍꠤ, ꠙꠞꠦꠎꠉꠣꠞꠞꠦ ꠍꠣꠠꠤꠀ ꠎꠣꠁꠔꠦ ꠀꠝꠤ ꠘꠣ ꠖꠦꠈꠍꠤ, ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖꠞꠦꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠜꠤꠇ ꠇꠞꠣꠔ ꠘꠣ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("PS37_26","020_37_26","PSA","37","26","26","ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠦ ꠝꠣꠘꠡꠞꠦ ꠞꠤꠘ ꠖꠦꠄ ꠢꠣꠝꠦꠡꠣ, ꠔꠣꠞꠣꠞ ꠀꠅꠟꠣꠖꠦꠅ ꠔ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_27","020_37_27","PSA","37","27","27","ꠛꠖ ꠇꠣꠝ ꠍꠣꠠꠅ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠅ, ꠔꠦꠃ ꠔꠥꠝꠤ ꠌꠤꠞꠇꠣꠟ ꠛꠡꠔ ꠇꠞꠛꠣꠄ ꠅꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("PS37_28","020_37_28","PSA","37","28","28","ꠝꠣꠛꠥꠖꠦ ꠔ ꠜꠣꠟꠣ ꠙꠣꠁꠘ ꠢꠇ ꠁꠘꠍꠣꠚ, ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠀꠡꠤꠇꠣꠘꠞꠦ ꠇꠞꠂꠘ ꠘꠣ ꠔ ꠔꠤꠀꠉ। ע ꠀꠁꠘ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠛꠤꠘꠣꠡ ꠅꠁꠛ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ, ꠔꠣꠞꠣꠞ ꠛꠋꠡ-ꠛꠥꠘꠤꠀꠖ ꠝꠤꠐꠤꠎꠤꠛ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("PS37_29","020_37_29","PSA","37","29","29","ꠖꠦꠡꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠙꠣꠁꠛꠣ ꠙꠞꠦꠎꠉꠣꠞꠦ, ꠌꠤꠞꠇꠣꠟ ꠞꠁꠛꠣ ꠔꠣꠞꠣ ꠅꠃ ꠎꠣꠉꠣꠞ ꠝꠣꠎꠦ। ");
INSERT INTO syls_vpl VALUES ("PS37_30","020_37_30","PSA","37","30","30","ꠙꠞꠦꠎꠉꠣꠞꠞ ꠝꠥꠈꠖꠤ ꠛꠣꠞ ꠅꠄ ꠉꠤꠀꠘꠞ ꠛꠥꠟꠤ, ꠢꠇ ꠛꠤꠌꠣꠞꠞ ꠝꠣꠔ ꠛꠣꠞ ꠅꠄ ꠔꠣꠞꠣꠞ ꠎꠤꠚꠞꠣꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("PS37_31","020_37_31","PSA","37","31","31","ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠉꠣꠕꠣ ꠀꠍꠦ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ, ꠙꠤꠍꠟꠤꠔ ꠘꠣꠄ ꠔꠣꠞꠣꠞ ꠙꠣꠅ ꠝꠎꠛꠥꠔ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PS37_32","020_37_32","PSA","37","32","32","ꠘꠣꠚꠞꠝꠣꠘꠦ ꠃꠔ ꠙꠣꠔꠤꠀ ꠞꠄ ꠙꠞꠦꠎꠉꠣꠞꠞ ꠛꠣꠄ, ꠄꠘꠞꠦ ꠈꠥꠘꠞ ꠀꠡꠣꠄ ꠢꠦ ꠡꠥꠎꠥꠉ ꠔꠥꠇꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS37_33","020_37_33","PSA","37","33","33","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠍꠣꠠꠔꠣ ꠘꠣꠄ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠀꠔꠅ, ꠔꠣꠘ ꠡꠣꠎꠣ ꠅꠁꠔꠦ ꠖꠤꠔꠣ ꠘꠣꠄ ꠀꠖꠣꠟꠔꠞ ꠛꠤꠌꠣꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS37_34","020_37_34","PSA","37","34","34","ꠝꠣꠛꠥꠖꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅ, ꠔꠣꠘ ꠖꠦꠈꠣꠁꠟ ꠙꠕꠦ ꠌꠟꠅ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠞꠛꠣ ꠛꠠ, ꠖꠦꠡꠞ ꠖꠈꠟ ꠙꠣꠁꠛꠣꠄ, ꠘꠣꠚꠞꠝꠣꠘ ꠖꠟꠞ ꠛꠤꠘꠣꠡ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS37_35","020_37_35","PSA","37","35","35","ꠙꠣꠡꠣꠘ ꠘꠣꠚꠞꠝꠣꠘꠞꠦ ꠖꠦꠈꠟꠣꠝ ꠛꠃꠔ ꠛꠠ ꠁꠎ꠆ꠎꠔꠤ, ꠔꠞꠔꠣꠎꠣ ꠉꠣꠍꠞ ꠟꠣꠈꠣꠘ ꠒꠣꠟ-ꠙꠣꠟꠣ ꠔꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("PS37_36","020_37_36","PSA","37","36","36","ꠢꠤꠞꠛꠣꠞ ꠉꠦꠟꠣꠝ ꠀꠝꠤ ꠔꠣꠞꠦ ꠀꠞ ꠙꠣꠁꠟꠣꠝ ꠘꠣ, ꠔꠥꠇꠣꠁꠟꠣꠝ ꠛꠃꠔ ꠀꠝꠤ ꠈꠥꠎ-ꠈꠛꠞ ꠝꠤꠟꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS37_37","020_37_37","PSA","37","37","37","ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞ ꠛꠣꠄ ꠌꠣꠅ ꠖꠦꠈꠅ ꠢꠇ ꠝꠣꠘꠡꠞ ꠛꠣꠄ, ꠐꠤꠇꠤꠀ ꠞꠄ ꠔꠣꠞ ꠀꠅꠟꠣꠖ ꠡꠣꠄ-ꠡꠣꠘ꠆ꠔꠤ ꠎꠦ ꠜꠣꠟꠣ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS37_38","020_37_38","PSA","37","38","38","ꠢꠇ꠆ꠇꠟ ꠈꠣꠞꠣꠙ ꠝꠣꠘꠡꠞ ꠅꠁꠛ ꠡꠞ꠆ꠛꠘꠣꠡ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠛꠋꠡ-ꠛꠥꠘꠤꠀꠖ ꠅꠁꠛ ꠛꠤꠘꠣꠡ। ");
INSERT INTO syls_vpl VALUES ("PS37_39","020_37_39","PSA","37","39","39","ꠙꠞꠦꠎꠉꠣꠞꠞ ꠘꠣꠎꠣꠔ ꠀꠄ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠔꠣꠞꠣꠞ ꠝꠍꠤꠛꠔꠞ ꠇꠣꠟꠅ ꠔꠣꠁꠘ ꠞꠂꠘ ꠛꠣꠋꠇꠣꠞ ꠛꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS37_40","020_37_40","PSA","37","40","40","ꠝꠣꠛꠥꠖꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠤꠀ ꠘꠤꠡ꠆ꠔꠣꠞ ꠖꠦꠁꠘ ꠔꠣꠞꠣꠞꠦ, ꠔꠣꠘ ꠀꠡꠞꠄ ꠟꠅꠀꠄ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠇꠛꠎꠣ ꠕꠣꠇꠤ ꠎꠣꠘꠦ ꠛꠣꠌꠣꠁꠘ ꠄꠞꠣꠞꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS38_1","020_38_1","PSA","38","1","1","ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠁꠀꠖꠉꠣꠞꠤ। ꠗꠣꠝꠇꠤ ꠖꠤꠅ ꠘꠣ ꠉ ꠝꠣꠛꠥꠖ ꠉꠥꠍꠣ ꠇꠞꠤꠀ, ꠡꠣꠎꠣ ꠖꠤꠅ ꠘꠣ ꠝꠞꠦ ꠞꠣꠉ ꠇꠞꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS38_2","020_38_2","PSA","38","2","2","ꠔꠥꠝꠣꠞ ꠔꠤꠞꠞ ꠚꠟꠣꠄ ꠔ ꠉꠣꠕꠤꠟꠤꠍꠦ ꠝꠞꠦ, ꠔꠥꠝꠣꠞ ꠀꠔꠦ ꠉ ꠝꠣꠛꠥꠖ ꠎꠣꠔꠤꠀ ꠗꠞꠍꠦ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS38_3","020_38_3","PSA","38","3","3","ꠔꠥꠝꠣꠞ ꠉꠥꠍꠣꠞ ꠌꠥꠐꠦ ꠀꠝꠣꠞ ꠇꠣꠄꠀꠞ ꠢꠇꠟ ꠅꠋꠉ ꠛꠦꠝꠣꠞ, ꠄꠉꠥ ꠀꠒ꠆ꠒꠤꠅ ꠜꠣꠟꠣ ꠘꠣꠄ ꠔ ꠉꠥꠘꠣꠞ ꠖꠣꠄ ꠀꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS38_4","020_38_4","PSA","38","4","4","ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠖ ꠇꠣꠝꠅ ꠀꠝꠤ ꠢꠣꠛꠥꠒꠥꠛꠥ ꠈꠣꠁꠀꠞ, ꠁꠔꠣ ꠛꠠ ꠇꠑꠤꠘ ꠛꠥꠏꠣ-ꠜꠣꠞ ꠟꠣꠉꠦꠞ ꠀꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS38_5","020_38_5","PSA","38","5","5","ꠀꠝꠣꠞ ꠛꠦꠀꠈꠟꠤꠞ ꠟꠣꠉꠤꠀ ꠎꠈꠝ ꠅꠇꠟ ꠕꠣꠇꠤꠀ, ꠙꠌꠣ ꠖꠥꠞ꠆ꠉꠘ꠆ꠖ ꠛꠣꠞ ꠅꠞ ꠙꠌꠣ ꠊꠣ ꠅꠁꠀ। ");
INSERT INTO syls_vpl VALUES ("PS38_6","020_38_6","PSA","38","6","6","ꠀꠝꠤ ꠃꠘ꠆ꠖꠣ ꠅꠁꠀ ꠉꠥꠎꠣ ꠛꠘꠤꠉꠦꠍꠤ, ꠝꠘꠞ ꠖꠥꠈꠦ ꠢꠣꠞꠣꠖꠤꠘ ꠇꠞꠤ ꠊꠥꠞꠣꠊꠥꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS38_7","020_38_7","PSA","38","7","7","ꠀꠝꠣꠞ ꠇꠝꠞꠞ ꠝꠣꠎꠦ ꠇꠔ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ, ꠀꠝꠣꠞ ꠇꠣꠄꠀꠞ ꠇꠥꠘꠥ ꠅꠋꠉꠃ ꠘꠣꠄ ꠔ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS38_8","020_38_8","PSA","38","8","8","ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠔꠦ ꠇꠞꠔꠦ ꠀꠝꠤ ꠜꠣꠋꠉꠤꠀ ꠌꠥꠞꠝꠣꠞ, ꠖꠤꠟꠞ ꠎꠣꠟꠣꠄ ꠀꠝꠤ ꠢꠣꠝꠦꠡꠣ ꠇꠣꠔꠞꠣꠁꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("PS38_9","020_38_9","PSA","38","9","9","ꠝꠣꠛꠥꠖ ꠉ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅꠃ ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠌꠣꠅꠀ-ꠙꠣꠅꠀ, ꠀꠝꠣꠞ ꠜꠤꠔꠞꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠔ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠟꠥꠇꠣꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS38_10","020_38_10","PSA","38","10","10","ꠀꠝꠣꠞ ꠖꠤꠟꠦ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠦꠞ, ꠡꠞꠤꠟꠞ ꠛꠟ ꠉꠦꠍꠦꠉꠤ ꠍꠣꠠꠤꠀ, ꠌꠃꠈꠦ ꠖꠦꠈꠣꠞ ꠈꠦꠝꠔꠣ ꠝꠞ ꠝꠥꠐꠦꠃ ꠘꠣꠄ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS38_11","020_38_11","PSA","38","11","11","ꠀꠙꠘ ꠎꠘ ꠀꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟꠦ ꠝꠞ ꠇꠡ꠆ꠐ ꠖꠦꠈꠤꠀ ꠢꠞꠤꠀ ꠕꠣꠇꠦ, ꠀꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤ ꠙꠞꠤꠌꠤꠔ ꠎꠘꠦꠅ ꠖꠥꠞꠁ ꠃꠛꠣꠁ ꠔꠣꠝꠡꠣ ꠖꠦꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("PS38_12","020_38_12","PSA","38","12","12","ꠀꠝꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠝꠔꠟꠛ ꠎꠣꠞꠣꠞ ꠔꠣꠞꠣ ꠚꠣꠘ꠆ꠖ ꠙꠣꠔꠦ, ꠡꠞ꠆ꠛꠘꠣꠡ ꠌꠣꠄ ꠎꠣꠞꠣ ꠝꠞ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠔꠦ। ꠍꠟ-ꠌꠔꠥꠞꠤꠞ ꠗꠣꠘ꠆ꠖꠣꠄ ꠔꠣꠞꠣ ꠢꠣꠞꠣ ꠖꠤꠘ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("PS38_13","020_38_13","PSA","38","13","13","ꠇꠣꠟꠥꠀꠞ ꠟꠣꠈꠣꠘ ꠔ ꠀꠝꠤ ꠇꠣꠘꠦ ꠇꠥꠘ꠆ꠔꠣ ꠢꠥꠘꠤ ꠘꠣ, ꠛꠥꠛꠣꠞ ꠟꠣꠈꠣꠘ ꠖꠡꠣ ꠀꠝꠣꠞ ꠝꠥꠈ ꠈꠥꠟꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS38_14","020_38_14","PSA","38","14","14","ꠅꠟꠣꠘ ꠝꠣꠘꠥꠡ ꠅꠁꠍꠤ ꠀꠝꠤ ꠎꠦꠉꠥꠄ ꠇꠥꠘ꠆ꠔꠣ ꠢꠥꠘꠦ ꠘꠣ, ꠝꠥꠈꠦꠖꠤ ꠎꠣꠞ ꠇꠥꠘꠥ ꠍꠅꠀꠟꠞ ꠎꠥꠀꠙ ꠛꠣꠞ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS38_15","020_38_15","PSA","38","15","15","ꠝꠣꠛꠥꠖ ꠉ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠃ ꠀꠡꠣꠄ, ꠅꠉ ꠝꠣꠛꠥꠖ ꠄꠟꠣꠢꠤ ꠝꠞ ꠝꠤꠘꠔꠤꠞ ꠎꠥꠀꠙ ꠔꠥꠝꠤ ꠔ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS38_16","020_38_16","PSA","38","16","16","ꠀꠝꠤ ꠔ ꠇꠁꠍꠤ, “ꠀꠝꠣꠞ ꠙꠣꠅ ꠙꠤꠍꠟꠤ ꠉꠦꠟꠦ, ꠀꠝꠣꠞꠦ ꠟꠁꠀ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠛꠠꠣꠁ ꠇꠞꠔ ꠘꠣ ꠙꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("PS38_17","020_38_17","PSA","38","17","17","ꠙꠠꠤ ꠎꠣꠁꠀꠞ ꠙꠠꠤ ꠎꠣꠁꠀꠞ ꠀꠝꠣꠞ ꠢꠣꠟꠔ ꠅꠟꠣ, ꠀꠝꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ ꠊꠥꠞꠦꠞ ꠈꠣꠟꠤ ꠖꠤꠟꠞ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS38_18","020_38_18","PSA","38","18","18","ꠀꠝꠣꠞ ꠢꠇꠟ ꠅꠙꠞꠣꠗ ꠀꠝꠤ ꠇꠞꠍꠤ ꠡ꠆ꠛꠤꠇꠣꠞ, ꠀꠝꠣꠞ ꠉꠥꠘꠣꠞ ꠛꠥꠏꠣ ꠟꠁꠀ ꠅꠡꠣꠘ꠆ꠔꠤ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("PS38_19","020_38_19","PSA","38","19","19","ꠀꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟ ꠛꠃꠔ ꠔꠞꠔꠣꠎꠣ ꠛꠟꠛꠣꠘ, ꠔꠣꠞꠣ ꠛꠃꠔ ꠛꠤꠘꠣ ꠇꠣꠞꠘꠦ ꠝꠞꠦ ꠎꠣꠞꠣ ꠊꠤꠘ꠆ꠘꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS38_20","020_38_20","PSA","38","20","20","ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠟꠦ ꠔꠣꠞꠣ ꠇꠞꠦ ꠈꠦꠔꠤ, ꠔꠣꠞꠣ ꠝꠞꠦ ꠖꠥꠡꠤ ꠇꠄ ꠜꠣꠟꠣꠁꠞ ꠙꠕꠦ ꠌꠟꠤ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS38_21","020_38_21","PSA","38","21","21","ꠅ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠎꠣꠁꠅ ꠘꠣ, ꠢꠞꠤꠀ ꠎꠣꠁꠅ ꠘꠣ ꠀꠝꠣ ꠕꠣꠇꠤ ꠅꠉ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS38_22","020_38_22","PSA","38","22","22","ꠀꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣꠔ ꠎꠟꠖꠤ ꠀꠅ ꠔꠥꠝꠤ, ꠅ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠇꠣꠘ꠆ꠒꠣꠞꠤ॥ ");
INSERT INTO syls_vpl VALUES ("PS39_1","020_39_1","PSA","39","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇ ꠎꠤꠖꠥꠔꠥꠘꠞ ꠟꠣꠉꠤ। ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠀꠝꠤ ꠇꠁꠍꠤ, “ꠢꠥꠡꠤꠀꠞ ꠞꠁꠝꠥ ꠀꠝꠤ ꠌꠟꠣꠞ ꠙꠕꠞ ꠛꠦꠙꠣꠞꠦ, ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠝꠥ ꠀꠝꠣꠞ ꠎꠤꠚꠞꠣꠞꠦ, ꠘꠣꠚꠞꠝꠣꠘ ꠎꠔ ꠡꠝꠄ ꠞꠁꠛ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ, ꠟꠣꠉꠣꠝ ꠟꠣꠉꠣꠁ ꠞꠣꠈꠝꠥ ꠔ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠝꠣꠎꠦ।” ");
INSERT INTO syls_vpl VALUES ("PS39_2","020_39_2","PSA","39","2","2","ꠎꠛꠣꠘ ꠛꠘ꠆ꠖ ꠇꠞꠤꠀ ꠀꠝꠤ ꠘꠤꠞꠣꠁ ꠞꠁꠟꠣꠝ, ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠇꠥꠘꠥꠔꠣꠃ ꠘꠣ ꠝꠣꠔꠤꠟꠣꠝ, ꠄꠞꠟꠣꠉꠤ ꠝꠞ ꠝꠘꠞ ꠖꠥꠈ ꠞꠁꠟ ꠀꠞꠅ ꠛꠣꠠꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("PS39_3","020_39_3","PSA","39","3","3","ꠖꠤꠟꠞ ꠇꠡ꠆ꠐꠄ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠣꠄ ꠀꠉꠥꠁꠘ ꠟꠣꠉꠟ ꠛꠥꠇꠅ, ꠔꠦꠃ ꠎꠤꠚꠞꠣꠖꠤ ꠇꠁꠟꠣꠝ, “ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ ꠉ, ");
INSERT INTO syls_vpl VALUES ("PS39_4","020_39_4","PSA","39","4","4","ꠀꠝꠣꠞꠦ ꠎꠣꠘꠣꠅ ꠉ ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞ ꠖꠡꠣ ꠅꠁꠛ ꠇꠤꠔꠣ? ꠇꠔꠖꠤꠘ ꠛꠣꠌꠤꠝꠥ ꠀꠝꠤ ꠡꠣꠋꠉ ꠅꠁꠛ ꠀꠄꠃ ꠇꠤꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("PS39_5","020_39_5","PSA","39","5","5","ꠄꠇ ꠝꠥꠁꠐ ꠇꠞꠍ ꠔꠥꠝꠤ ꠝꠞ ꠢꠣꠄꠀꠔꠤ, ꠔꠥꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠡꠥꠁꠘ꠆ꠘ ꠎꠣꠘꠥ ꠝꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠖꠥꠘꠤꠀꠞ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠥꠡ ꠅꠁꠟ ꠄꠇꠐꠣ ꠘꠤꠡ꠆ꠛꠣꠡ ꠈꠣꠟꠤ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS39_6","020_39_6","PSA","39","6","6","ꠍꠣꠄꠀꠞ ꠝꠔ ꠇꠞꠤ ꠝꠣꠘꠥꠡ ꠇꠞꠦ ꠀꠅꠀ-ꠎꠣꠅꠀ, ꠛꠦꠇꠣꠝꠣ ꠙꠦꠞꠦꠡꠣꠘꠤ ꠇꠞꠦ ꠗꠘ-ꠖꠃꠟꠔꠞ ꠟꠣꠉꠤꠀ, ꠅꠁꠟꠦ ꠁꠔꠣ ꠇꠦ ꠈꠣꠁꠛ ꠁꠈꠣꠘ ꠎꠣꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS39_7","020_39_7","PSA","39","7","7","ꠝꠣꠛꠥꠖ ꠉ, ꠇꠤꠔꠣꠞ ꠀꠡꠣꠄ ꠞꠁꠔꠣꠝ ꠀꠝꠤ ꠅꠙꠦꠇ꠆ꠇꠣꠔ? ꠀꠝꠣꠞ ꠢꠇꠟ ꠀꠡꠣ ꠔ ꠔꠥꠝꠣꠞꠦ ꠙꠣꠅꠀꠔ। ");
INSERT INTO syls_vpl VALUES ("PS39_8","020_39_8","PSA","39","8","8","ꠇꠞꠅ ꠉ ꠃꠖ꠆ꠖꠣꠞ ꠝꠞꠦ ꠢꠇꠟ ꠅꠘ꠆ꠘꠣꠄ ꠕꠣꠇꠤ, ꠛꠦꠀꠈꠟꠞ ꠀꠔꠅ ꠇꠞꠤꠅ ꠘꠣ ꠝꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS39_9","020_39_9","PSA","39","9","9","ꠝꠥꠈ ꠈꠥꠟꠍꠤ ꠘꠣ ꠀꠝꠤ ꠞꠁꠍꠤ ꠘꠤꠞꠣꠁ, ꠁꠔꠣ ꠇꠡ꠆ꠐ ꠔ ꠅꠁꠍꠦ ꠝꠞ ꠔꠥꠝꠣꠞ ꠁꠡꠣꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS39_10","020_39_10","PSA","39","10","10","ꠔꠥꠝꠣꠞ ꠡꠣꠡ꠆ꠔꠤ ꠢꠞꠣꠁꠟꠣꠅ ꠀꠝꠣꠞ ꠃꠙꠞ ꠕꠣꠇꠤ, ꠔꠥꠝꠣꠞ ꠀꠔꠞ ꠀꠊꠣꠔ ꠈꠣꠁꠀ ꠝꠥꠁ ꠡꠦꠡ ꠅꠁꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("PS39_11","020_39_11","PSA","39","11","11","ꠉꠥꠘꠣꠞ ꠖꠣꠄꠄ ꠗꠣꠝꠇꠤ ꠖꠤꠀ ꠎꠦꠛꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠡꠋꠡꠥꠗꠘ ꠇꠞꠅ ꠔꠥꠝꠤ, ꠔꠣꠞꠣꠞ ꠝꠣꠄꠀꠞ ꠗꠘ ꠙꠥꠇꠞ ꠟꠣꠈꠣꠘ ꠖꠦꠅ ꠘꠡ꠆ꠐ ꠇꠞꠤ, ꠝꠣꠘꠥꠡ ꠔ ꠅꠁꠟ ꠄꠇꠐꠣ ꠘꠤꠡ꠆ꠛꠣꠡ ꠈꠣꠟꠤ। (ꠍꠦꠟꠣ) ");
INSERT INTO syls_vpl VALUES ("PS39_12","020_39_12","PSA","39","12","12","ꠀꠝꠣꠞ ꠚꠞꠤꠀꠖ ꠝꠣꠛꠥꠖ ꠔꠥꠝꠤ ꠢꠥꠘꠅ, ꠇꠣꠘ ꠖꠦꠅ ꠔꠥꠝꠤ ꠝꠞ ꠇꠣꠘ꠆ꠖꠘꠅ, ꠖꠦꠈꠤꠀ ꠝꠞ ꠇꠣꠘ꠆ꠖꠘ ꠘꠤꠞꠣꠁ ꠞꠁꠅ ꠘꠣ ꠔꠥꠝꠤ, ꠔꠥꠝꠣꠞ ꠊꠞꠅ ꠔ ꠀꠝꠤ ꠛꠤꠖꠦꠡꠤ, ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠤꠅ ꠙ꠆ꠞꠛꠣꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("PS39_13","020_39_13","PSA","39","13","13","ꠇꠠꠣ ꠘꠎꠞ ꠢꠞꠣꠁꠟꠣꠅ ꠔꠥꠝꠣꠞ ꠀꠝꠣꠞ ꠃꠙꠞ ꠕꠣꠇꠤ, ꠎꠣꠁꠛꠣꠞ ꠀꠉꠦ, ꠡꠦꠡ ꠅꠁꠛꠣꠞ ꠀꠉꠦ ꠀꠝꠤ, ꠢꠤꠞꠛꠣꠞ ꠎꠣꠘꠥ ꠝꠥꠁ ꠈꠥꠡꠤ ꠅꠁꠔꠣꠝ ꠙꠣꠞꠤ॥ ");
INSERT INTO syls_vpl VALUES ("PS40_1","020_40_1","PSA","40","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠍꠛꠞ ꠇꠞꠤꠀ ꠌꠣꠁ ꠞꠁꠍꠟꠣꠝ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠉꠤ, ꠈꠤꠀꠟ ꠇꠞꠤ ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ ꠀꠝꠣꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS40_2","020_40_2","PSA","40","2","2","ꠉꠟꠣꠁꠝꠣ ꠉꠣꠠꠣ ꠕꠣꠇꠤ ꠔꠥꠟꠤꠀ ꠀꠘꠟꠣ ꠝꠞꠦ, ꠚꠦꠇꠞ ꠉꠣꠔꠞ ꠝꠞꠘ ꠖꠡꠣꠔ ꠛꠣꠌꠣꠁꠟꠣ ꠀꠝꠣꠞꠦ। ꠀꠝꠣꠞ ꠙꠣꠅꠞꠦ ꠜꠞ ꠖꠦꠅꠀꠁꠟꠣ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞ, ꠡꠇ꠆ꠔ ꠝꠣꠐꠤꠔ ꠑꠣꠁ ꠎꠥꠉꠣꠁꠟꠣ ꠀꠝꠣꠞ ꠖꠥꠁ ꠙꠣꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("PS40_3","020_40_3","PSA","40","3","3","ꠎꠥꠉꠣꠁ ꠖꠤꠟꠣ ꠀꠝꠣꠞ ꠝꠥꠈꠅ ꠘꠄꠀ ꠉꠎꠟ ꠔꠣꠘ, ꠅꠈꠘ ꠀꠝꠤ ꠉꠣꠁ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠉꠥꠘꠉꠣꠘ। ꠖꠦꠈꠛ ꠁꠔꠣ ꠛꠃꠔ ꠎꠘꠦ, ꠖꠦꠈꠤꠀ ꠒꠞꠣꠁꠛ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("PS40_4","020_40_4","PSA","40","4","4","ꠗꠁꠘ꠆ꠘ ꠈꠣꠟꠤ ꠢꠃ ꠛꠘ꠆ꠖꠣ, ꠝꠣꠛꠥꠖꠃ ꠎꠣꠞ ꠑꠤꠇꠣꠘꠣ, ꠜꠥꠟ ꠙꠕꠦ ꠉꠤꠀ ꠎꠦꠔꠣꠄ ꠇꠞꠦ ꠛꠠꠣꠁ-ꠉꠞꠤꠝꠣ, ꠁꠔꠣꠞ ꠛꠣꠄꠖꠤ ꠢꠦ ꠔ ꠚꠤꠞꠤꠀꠅ ꠌꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS40_5","020_40_5","PSA","40","5","5","ꠅꠉ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠉꠘꠤꠀ ꠚꠥꠠꠣꠁꠟ ꠎꠣꠁꠔ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝꠞ ꠢꠤꠡꠣꠛ ꠀꠞꠅ ꠘꠣꠘꠣꠘ ꠌꠤꠘ꠆ꠔꠣ-ꠃꠙꠣꠄ, ꠎꠣꠘꠣꠁꠀ ꠛꠣ ꠇꠁꠀ ꠀꠝꠤ ꠚꠥꠠꠣꠘꠤꠞ ꠡꠣꠁꠖ꠆ꠖ ꠘꠣꠁ, ꠔꠥꠝꠣꠞ ꠔꠥꠟ꠆ꠟ ꠇꠦ ꠀꠍꠦ, ꠇꠦꠃ ꠘꠣꠁ ꠇꠦꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS40_6","020_40_6","PSA","40","6","6","ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣꠄ ꠈꠥꠡꠤ ꠅꠅ ꠘꠣ ꠔꠥꠝꠤ, ꠈꠥꠡꠤ ꠅꠅ ꠘꠣ ꠔꠥꠝꠤ ꠉ, ꠈꠥꠡꠤ ꠅꠅ ꠘꠣ ꠔꠥꠝꠤ, ꠌꠣꠅ ꠘꠣ ꠔꠥꠝꠤ ꠎꠣꠟꠣꠁꠟ ꠇꠤꠛꠣ ꠇꠚꠞꠣꠞ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ, ꠢꠥꠘꠣꠞ ꠟꠣꠈ ꠖꠥꠁ ꠇꠣꠘ ꠖꠤꠍ ꠝꠞꠦ ꠢꠥꠘꠤꠀ ꠎꠣꠘꠥ ꠝꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS40_7","020_40_7","PSA","40","7","7","ꠔꠦꠃ ꠀꠝꠤ ꠇꠁꠟꠣꠝ ꠀꠟ꠆ꠟꠣ, ꠀꠁꠍꠤ ꠀꠝꠤ ꠅꠘꠅ, ꠟꠦꠈꠣ ꠀꠍꠦ ꠀꠝꠣꠞ ꠛꠦꠀꠙꠣꠞ ꠎꠦꠟꠣ ꠇꠤꠔꠣꠛꠅ, ");
INSERT INTO syls_vpl VALUES ("PS40_8","020_40_8","PSA","40","8","8","ꠅꠉ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠤ ꠈꠥꠡꠤ ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠙꠥꠞꠘꠦ, ꠢꠇ꠆ꠇꠟ ꠢꠥꠇꠥꠝ ꠉꠣꠕꠣ ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS40_9","020_40_9","PSA","40","9","9","ꠝꠢꠣ ꠎꠘ-ꠡꠝꠣꠛꠦꠡꠅ ꠀꠝꠤ ꠎꠣꠘꠣꠁꠍꠤ, ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠢꠇ꠆ꠇꠣꠘꠤ ꠇꠣꠝꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ, ꠀꠝꠣꠞ ꠀꠅꠀꠎ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠘꠣ ꠁꠔꠣ ꠔ ꠎꠣꠘ, ꠔꠥꠝꠤ ꠡ꠆ꠛꠄꠅꠋ ꠡꠣꠇ꠆ꠇꠤ ꠀꠝꠣꠞ, ꠅ ꠝꠣꠛꠥꠖ ꠉ। ");
INSERT INTO syls_vpl VALUES ("PS40_10","020_40_10","PSA","40","10","10","ꠟꠥꠇꠣꠁꠀ ꠞꠣꠈꠍꠤ ꠘꠣ ꠝꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞ, ꠔꠥꠝꠤ ꠎꠦ ꠡꠑꠤꠇ ꠢꠇ꠆ꠇꠣꠘꠤ ꠎꠣꠘꠣꠁꠍꠤ ꠈꠛꠞ, ꠔꠥꠝꠣꠞ ꠖꠦꠅꠀ ꠘꠣꠎꠣꠔ ꠀꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠇꠁꠍꠤ ꠢꠇꠟꠞꠦ, ꠖꠄꠀ-ꠝꠣꠄꠀ ꠀꠞ ꠢꠇ ꠔꠥꠝꠤ ꠎꠣꠘꠣꠁꠍꠤ ꠝꠢꠣ ꠡꠝꠣꠛꠦꠡꠦ। ");
INSERT INTO syls_vpl VALUES ("PS40_11","020_40_11","PSA","40","11","11","ꠅ ꠝꠣꠛꠥꠖ! ꠛꠘ꠆ꠖ ꠇꠞꠤꠅ ꠘꠣ ꠝꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠞꠢꠝꠔꠞ ꠖꠥꠀꠞ, ꠔꠥꠝꠣꠞ ꠖꠄꠀ ꠀꠞ ꠢꠇ ꠅꠃꠇ ꠝꠞ ꠌꠤꠞꠇꠣꠟꠞ ꠇꠣꠘ꠆ꠒꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("PS40_12","020_40_12","PSA","40","12","12","ꠖꠦꠈꠞꠣꠄ ꠘꠤ! ꠢꠤꠡꠣꠛ ꠍꠣꠠꠣ ꠝꠍꠤꠛꠔꠦ ꠛꠦꠞꠤꠟꠤꠍꠦ ꠝꠞꠦ, ꠙꠦꠌꠣꠁꠟꠤꠍꠦ ꠀꠁꠀ ꠀꠝꠣꠞ ꠢꠇꠟ ꠅꠙꠞꠣꠗꠦ, ꠖꠦꠈꠤꠀꠞ ꠘꠣ ꠇꠥꠘ꠆ꠔꠣ ꠀꠝꠤ ꠀꠝꠣꠞ ꠌꠃꠈꠦꠖꠤ, ꠀꠝꠣꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠕꠣꠇꠤꠅ ꠁꠔꠣ ꠔ ꠛꠦꠡꠤ, ꠝꠞ ꠙꠤꠘ꠆ꠎꠤꠞꠣꠞ ꠝꠘ ꠝꠄꠘꠣꠅ ꠍꠣꠠꠤꠀ ꠉꠦꠍꠂꠘꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("PS40_13","020_40_13","PSA","40","13","13","ꠅ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠖꠥꠢꠣꠁ ꠖꠤꠀꠞ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅ, ꠝꠣꠛꠥꠖ ꠉ, ꠀꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣꠔ ꠎꠟꠖꠤ ꠀꠅ। ");
INSERT INTO syls_vpl VALUES ("PS40_14","020_40_14","PSA","40","14","14","ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ ꠎꠦꠔꠣꠄ ꠘꠤꠔꠣ ꠌꠣꠁꠞꠣ ꠇꠣꠠꠤꠀ, ꠘꠤꠌꠣ ꠅꠃꠇ ꠔꠣꠞꠣꠞ ꠝꠣꠕꠣ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠛꠘꠤꠀ, ꠀꠝꠣꠞ ꠈꠦꠔꠤ ꠅꠁꠟꠦ ꠎꠦꠔꠣꠄ ꠇꠞꠛꠣ ꠈꠥꠡꠤ, ꠛꠦꠁꠎ꠆ꠎꠔ ꠛꠘꠤꠀ ꠔꠣꠞꠣ ꠜꠣꠉꠤ ꠎꠣꠃꠇ ꠈꠞꠦꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("PS40_15","020_40_15","PSA","40","15","15","ꠀꠝꠣꠞ ꠈꠦꠔꠤꠄ ꠎꠦꠔꠣꠄ ꠇꠁꠘ, ꠅꠁꠍꠦꠞꠦ ꠅꠁꠍꠦ, ꠝꠥꠈ ꠟꠥꠇꠣꠁꠀ ꠢꠞꠃꠇ ꠅꠔꠣ ꠘꠤꠎꠞ ꠟꠣꠎ-ꠡꠞꠝꠦ। ");
INSERT INTO syls_vpl VALUES ("PS40_16","020_40_16","PSA","40","16","16","ꠅꠁꠟꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠃꠇ ꠔꠥꠝꠣꠞ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣꠞ ꠖꠟꠦ, ꠔꠥꠝꠣꠞ ꠖꠦꠈꠣꠁꠟ ꠛꠣꠌꠣꠞ ꠙꠕ ꠜꠣꠟꠣ ꠙꠣꠁꠘ ꠎꠦꠔꠣ ꠎꠘꠦ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠙꠤ ꠎꠙꠤ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠃꠇ ꠔꠣꠞꠣ, ꠔꠥꠝꠤꠃ ꠝꠢꠣꠘ ꠝꠃꠟꠣ, ꠔꠥꠝꠤꠃ ꠝꠢꠣꠘ ꠀꠟ꠆ꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("PS40_17","020_40_17","PSA","40","17","17","ꠖꠥꠈꠤ ꠇꠣꠋꠉꠣꠟ ꠎꠘ ꠔ ꠀꠝꠤ ꠛꠠꠁ ꠅꠜꠣꠛꠤ, ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠔ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠂꠘ ꠝꠣꠛꠥꠖ ꠄꠟꠣꠢꠤ। ꠔꠥꠝꠤꠃ ꠝꠞ ꠡꠣꠁꠎ꠆ꠎꠇꠣꠞꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠑꠤꠇꠣꠘꠣ, ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠅ ꠉ ꠝꠣꠟꠤꠇ ꠖꠦꠞꠤ ꠇꠞꠤꠅ ꠘꠣ॥ ");
INSERT INTO syls_vpl VALUES ("PS41_1","020_41_1","PSA","41","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠝꠤꠎꠝꠞ। ꠢꠃ ꠝꠣꠘꠥꠡ ꠗꠁꠘ꠆ꠘ, ꠖꠥꠈꠤ-ꠇꠣꠋꠉꠣꠟꠞ ꠇꠕꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠦ ꠎꠦ, ꠝꠍꠤꠛꠔꠞ ꠖꠤꠘꠅ ꠝꠣꠛꠥꠖꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠛꠣ ꠔꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS41_2","020_41_2","PSA","41","2","2","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠦ ꠞꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠞꠣꠈꠛꠣ ꠛꠣꠌꠣꠁꠀ, ꠖꠦꠡꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠡꠥꠇꠤꠟꠣ ꠝꠣꠘꠥꠡ ꠇꠁꠛꠣ, ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞꠦ ꠡꠙꠤꠀ ꠘꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS41_3","020_41_3","PSA","41","3","3","ꠛꠦꠝꠣꠞꠦ ꠛꠤꠍꠘꠣꠔ ꠙꠠꠤ ꠉꠦꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠞ ꠀꠍꠣꠘ ꠇꠞꠂꠘ, ꠡꠤꠚꠣ ꠇꠞꠤꠀ ꠛꠤꠍꠘꠣ ꠕꠣꠇꠤ ꠔꠣꠞꠦ ꠔꠥꠟꠤꠀ ꠀꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS41_4","020_41_4","PSA","41","4","4","ꠀꠝꠤ ꠇꠁꠍꠤ, “ꠀꠝꠤ ꠔ ꠇꠞꠍꠤ ꠔꠥꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠉꠥꠘꠣ, ꠅꠉ ꠝꠣꠛꠥꠖ, ꠖꠄꠀ ꠇꠞꠤꠀ ꠇꠞꠅ ꠝꠞꠦ ꠡꠤꠚꠣ।” ");
INSERT INTO syls_vpl VALUES ("PS41_5","020_41_5","PSA","41","5","5","ꠀꠝꠣꠞ ꠈꠦꠔꠤ ꠌꠣꠁꠀ ꠖꠥꠡꠝꠘꠦ ꠇꠄ, “ꠅꠉꠥ ꠇꠥꠘ ꠡꠝꠄ ꠝꠞꠛ? ꠇꠥꠘ ꠡꠝꠄ ꠔꠣꠞ ꠘꠣꠝ-ꠘꠤꠡꠣꠘꠣ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠝꠥꠍꠤ ꠎꠤꠛ?” ");
INSERT INTO syls_vpl VALUES ("PS41_6","020_41_6","PSA","41","6","6","ꠔꠣꠞꠣ ꠝꠞꠦ ꠖꠦꠈꠣꠔ ꠀꠁꠟꠦ ꠜꠣꠅꠔꠣꠛꠣꠎꠤ ꠝꠣꠔꠦ, ꠔꠣꠞꠣꠞ ꠝꠘꠅ ꠎꠝꠣꠁꠟ ꠛꠖꠘꠣꠝ ꠞꠐꠣꠄ ꠉꠤꠀ ꠛꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS41_7","020_41_7","PSA","41","7","7","ꠀꠝꠣꠞ ꠛꠤꠞꠥꠗꠤ ꠅꠇꠟ ꠝꠤꠟꠤꠀ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠦ, ꠀꠝꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠔ ꠇꠤꠟꠣ ꠅꠃ ꠗꠣꠘ꠆ꠖꠣꠄ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("PS41_8","020_41_8","PSA","41","8","8","ꠇꠄ ꠔꠣꠞꠣ, “ꠛꠃꠔ ꠛꠠ ꠈꠣꠞꠣꠙꠤꠄ ꠔꠣꠞꠦ ꠎꠣꠔꠤꠀ ꠗꠞꠍꠦ, ꠃꠑꠤꠔ ꠙꠣꠞꠔ ꠘꠣꠄ ꠀꠞ ꠎꠦꠈꠣꠘꠅ ꠢꠦ ꠢꠥꠔꠣꠁꠟ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("PS41_9","020_41_9","PSA","41","9","9","ꠄꠇ ꠕꠣꠟꠅ ꠛꠁꠀ ꠎꠦꠉꠤꠄ ꠈꠣꠁꠔ, ꠜꠞꠡꠣ ꠇꠞꠔꠣꠝ ꠎꠣꠞ ꠃꠙꠞꠦ, ꠅꠈꠘ ꠅꠃ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔꠦꠅ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠟꠣꠉꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS41_10","020_41_10","PSA","41","10","10","ꠅꠉ ꠝꠣꠛꠥꠖ ꠞꠢꠝ ꠇꠞꠅ ꠔꠥꠝꠤ ꠘꠤꠎꠦ ꠝꠞꠦ, ꠔꠣꠞꠣꠞ ꠛꠖꠟꠣ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠟꠤꠟꠣꠅ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS41_11","020_41_11","PSA","41","11","11","ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠤ ꠔꠥꠝꠤ ꠁꠈꠣꠘ ꠀꠝꠤ ꠎꠣꠘꠤ, ꠖꠥꠡꠝꠘꠦ ꠔ ꠝꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠌꠤꠟ꠆ꠟꠣꠄ ꠘꠣ ꠀꠞ ꠎꠄꠅꠞ ꠌꠤꠟ꠆ꠟꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS41_12","020_41_12","PSA","41","12","12","ꠔꠥꠝꠤ ꠗꠞꠤꠀ ꠞꠣꠈꠍ ꠝꠞꠦ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠖꠦꠈꠤꠀ, ꠔꠥꠝꠣꠞ ꠖꠤꠖꠣꠞꠅ ꠎꠣꠉꠣ ꠖꠤꠍ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS41_13","020_41_13","PSA","41","13","13","ꠢꠇ꠆ꠇꠟ ꠙ꠆ꠞꠡꠋꠡꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃꠇ, ꠡꠥꠞꠥ ꠕꠣꠇꠤ ꠀꠈꠦꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠞꠃꠇ। ꠀꠝꠤꠘ ꠍꠥꠝ꠆ꠝꠣ-ꠀꠝꠤꠘ॥ ");
INSERT INTO syls_vpl VALUES ("PS70_1","020_70_1","PSA","70","1","1","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠙꠞꠤꠌꠣꠟꠇꠞ ꠟꠣꠉꠤ: ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠁꠀꠖꠉꠣꠞꠤꠞ ꠝꠤꠎꠝꠞ। ꠅ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠖꠥꠀꠁ ꠖꠤꠀꠞ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅ, ꠝꠣꠛꠥꠖ ꠉ, ꠀꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣꠔ ꠎꠟꠖꠤ ꠀꠅ। ");
INSERT INTO syls_vpl VALUES ("PS70_2","020_70_2","PSA","70","2","2","ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ ꠎꠦꠔꠣꠄ ꠘꠤꠔꠣ ꠌꠣꠁꠞꠣ, ꠘꠤꠌꠣ ꠅꠃꠇ ꠔꠣꠞꠣꠞ ꠝꠣꠕꠣ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠛꠘꠤꠀ, ꠀꠝꠣꠞ ꠈꠦꠔꠤ ꠅꠁꠟꠦ ꠎꠦꠔꠣꠄ ꠇꠞꠛꠣ ꠈꠥꠡꠤ, ꠛꠦꠁꠎ꠆ꠎꠔ ꠛꠘꠤꠀ ꠔꠣꠞꠣ ꠜꠣꠉꠤ ꠎꠣꠃꠇ ꠈꠞꠦꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("PS70_3","020_70_3","PSA","70","3","3","ꠀꠝꠣꠞ ꠈꠦꠔꠤꠄ ꠎꠦꠔꠣꠄ ꠇꠂꠘ, ꠅꠁꠍꠦꠞꠦ ꠅꠁꠍꠦ, ꠝꠥꠈ ꠟꠥꠇꠣꠁꠀ ꠢꠞꠃꠇ ꠅꠔꠣ ꠘꠤꠎꠞ ꠟꠣꠎ-ꠡꠞꠝꠦ। ");
INSERT INTO syls_vpl VALUES ("PS70_4","020_70_4","PSA","70","4","4","ꠅꠁꠟꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠃꠇ ꠔꠥꠝꠣꠞ ꠀꠡꠤꠇ ꠛꠘ꠆ꠖꠣꠞ ꠖꠟꠦ, ꠔꠥꠝꠣꠞ ꠖꠦꠈꠣꠁꠟ ꠛꠣꠌꠣꠞ ꠙꠕ ꠜꠣꠟꠣ ꠙꠣꠁꠘ ꠎꠦꠔꠣ ꠎꠘꠦ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠙꠤ ꠎꠙꠤ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠃꠇ ꠔꠣꠞꠣ, ꠔꠥꠝꠤꠃ ꠝꠢꠣꠘ ꠝꠃꠟꠣ, ꠔꠥꠝꠤꠃ ꠝꠢꠣꠘ ꠀꠟ꠆ꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("PS70_5","020_70_5","PSA","70","5","5","ꠖꠥꠈꠤ ꠇꠣꠋꠉꠣꠟ ꠎꠘ ꠔ ꠀꠝꠤ ꠛꠠꠁ ꠅꠜꠣꠛꠤ, ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠎꠟꠖꠤ ꠀꠅ ꠝꠣꠛꠥꠖ ꠄꠟꠣꠢꠤ। ꠔꠥꠝꠤꠃ ꠝꠞ ꠡꠣꠁꠎ꠆ꠎꠇꠣꠞꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠑꠤꠇꠣꠘꠣ, ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠅ ꠉ ꠝꠣꠟꠤꠇ ꠖꠦꠞꠤ ꠇꠞꠤꠅ ꠘꠣ॥ ");
INSERT INTO syls_vpl VALUES ("PS95_1","020_95_1","PSA","95","1","1","ꠀꠅ ꠀꠝꠞꠣ ꠈꠥꠡꠤꠞ ꠉꠎꠟ ꠉꠣꠁ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ, ꠞꠇ꠆ꠇꠣꠇꠣꠞꠤ ꠐꠤꠟ꠆ꠟꠣ ꠔꠣꠁꠘ, ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠤ ꠎꠥꠞꠦ ꠎꠥꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS95_2","020_95_2","PSA","95","2","2","ꠌꠟꠅ ꠀꠝꠞꠣ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠤ ꠇꠞꠤ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠎꠣꠁ, ꠛꠣꠎꠘꠣꠞ ꠔꠣꠟꠦ ꠔꠣꠟꠦ ꠔꠣꠘ ꠘꠣꠝꠦ ꠎꠥꠞꠦ-ꠡꠥꠞꠦ ꠉꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS95_3","020_95_3","PSA","95","3","3","ꠝꠣꠛꠥꠖꠃ ꠔ ꠃꠙꠞꠀꠟꠣ, ꠡꠞ꠆ꠛ ꠝꠢꠣꠘ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣ, ꠖꠥꠁ ꠎꠣꠢꠣꠘꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤꠞ ꠔꠣꠁꠘꠃ ꠛꠠ ꠛꠣꠖꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("PS95_4","020_95_4","PSA","95","4","4","ꠎꠝꠤꠘ ꠀꠞ ꠙꠣꠔꠣꠟ ꠡꠛꠃ ꠔꠣꠘ ꠀꠔꠅ, ꠙꠣꠠ-ꠙꠞꠛꠔꠞ ꠃꠌꠣ ꠐꠤꠟ꠆ꠟꠣꠅ ꠔꠣꠘꠃ ꠔ। ");
INSERT INTO syls_vpl VALUES ("PS95_5","020_95_5","PSA","95","5","5","ꠔꠣꠁꠘꠃ ꠖꠞꠤꠀꠞ ꠝꠣꠟꠤꠇ ꠛꠣꠘꠣꠁꠍꠂꠘ ꠁꠔꠣ, ꠢꠥꠇꠘꠣ ꠎꠝꠤꠘꠅ ꠔꠣꠘ ꠖꠥꠁꠅ ꠀꠔꠦ ꠉꠠꠣ। ");
INSERT INTO syls_vpl VALUES ("PS95_6","020_95_6","PSA","95","6","6","ꠀꠅ ꠀꠝꠞꠣ ꠍꠁꠎꠖꠣ ꠖꠤꠀ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠤ, ꠀꠝꠞꠣꠞꠦ ꠙꠄꠖꠣꠇꠣꠞꠤ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠘꠔꠎꠣꠘꠥ ꠛꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PS95_7","020_95_7","PSA","95","7","7","ꠔꠣꠁꠘꠃ ꠔ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣ, ꠀꠝꠞꠣ ꠔꠣꠘ ꠝꠦꠠꠣꠞ ꠙꠣꠟ, ꠔꠣꠘ ꠎꠝꠤꠘꠞ ꠛꠘ꠆ꠖꠣ। ꠀꠢ! ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠎꠥꠖꠤ ꠢꠥꠘꠔꠣꠄ ꠔꠥꠝꠞꠣ! ");
INSERT INTO syls_vpl VALUES ("PS95_8","020_95_8","PSA","95","8","8","ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠇꠞꠤꠅ ꠘꠣ ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠇꠞꠍꠟꠣꠄ ꠝꠦꠞꠤꠛꠣꠔ, ꠢꠃ ꠖꠤꠘ ꠇꠞꠍꠟꠣꠄ ꠎꠦꠔꠣ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠍꠣ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("PS95_9","020_95_9","PSA","95","9","9","ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠦ ꠢꠘꠅ ꠔ ꠖꠦꠈꠍꠤꠟ ꠝꠞꠦ ꠀꠎꠝꠣꠁꠀ, ꠀꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠤꠀꠅ ꠔꠣꠞꠣ ꠇꠞꠟꠣ ꠝꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PS95_10","020_95_10","PSA","95","10","10","ꠢꠃ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠎꠣꠟꠣ ꠡꠁꠟꠣꠝ ꠀꠝꠤ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠗꠞꠤꠀ, ꠢꠦꠡꠦ ꠇꠁꠟꠣꠝ, ꠁꠔꠣꠞ ꠖꠤꠟ ꠔ ꠛꠦ-ꠙꠕꠤ ꠀꠝꠣꠞ ꠙꠕꠞꠦ ꠌꠤꠘꠟ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("PS95_11","020_95_11","PSA","95","11","11","ꠔꠦꠃꠉꠤ ꠀꠝꠣꠞ ꠉꠥꠍꠣꠞ ꠌꠥꠐꠦ ꠇꠁꠟꠣꠝ ꠇꠍꠝ ꠇꠞꠤꠀ, ꠝꠞ ꠖꠦꠅꠀ ꠀꠞꠣꠝꠞ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠔ ꠘꠣꠄ ꠔꠣꠞꠣ॥ ");
INSERT INTO syls_vpl VALUES ("PS96_1","020_96_1","PSA","96","1","1","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠘꠄꠀ ꠉꠤꠔ ꠉꠣꠅ, ꠅ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀ, ꠝꠣꠛꠥꠖꠞ ꠉꠤꠔ ꠉꠣꠅ, ");
INSERT INTO syls_vpl VALUES ("PS96_2","020_96_2","PSA","96","2","2","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠉꠤꠔ ꠉꠣꠅ, ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠖꠤꠘꠦ ꠖꠤꠘꠦ ꠔꠣꠘ ꠖꠦꠅꠀ ꠘꠣꠎꠣꠔꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS96_3","020_96_3","PSA","96","3","3","ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠎꠣꠘꠣꠅ ꠔꠣꠘ ꠉꠃꠞꠛꠞ ꠇꠕꠣ, ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠇꠅ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝꠞ ꠝꠢꠤꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("PS96_4","020_96_4","PSA","96","4","4","ꠝꠣꠛꠥꠖꠃ ꠝꠢꠣꠘ, ꠝꠢꠣ ꠔꠣꠞꠤꠚ ꠔꠣꠘ, ꠢꠇꠟ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠕꠣꠇꠤ ꠛꠠ ꠜꠄꠅꠋꠇꠞ ꠔꠣꠁꠘ, ");
INSERT INTO syls_vpl VALUES ("PS96_5","020_96_5","PSA","96","5","5","ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠔ ꠛꠦꠇꠣꠝꠣ ꠙꠥꠔꠥꠟ ꠈꠣꠟꠤ, ꠝꠣꠛꠥꠖꠦꠃ ꠛꠣꠘꠣꠁꠍꠂꠘ ꠢꠇꠟ ꠀꠍꠝꠣꠘ ꠝꠘ꠆ꠒꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("PS96_6","020_96_6","PSA","96","6","6","ꠡꠣꠘ-ꠡꠃꠇꠔ ꠀꠞ ꠝꠢꠤꠝꠣ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠞꠁꠍꠦ, ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠀꠞ ꠎꠣꠇ-ꠎꠝꠇꠦ ꠔꠣꠘ ꠊꠞ ꠢꠣꠎꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PS96_7","020_96_7","PSA","96","7","7","ꠅ ꠎꠉꠔꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠅꠇꠟ, ꠎꠣꠘꠣꠅ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠘꠉꠣꠘ, ꠉꠃꠞꠛ ꠀꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠅ ꠔꠣꠘ, ");
INSERT INTO syls_vpl VALUES ("PS96_8","020_96_8","PSA","96","8","8","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠣꠘ ꠙꠣꠅꠘꠣ ꠉꠃꠞꠛ ꠎꠣꠘꠣꠅ, ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠀꠔꠅ ꠟꠁꠀ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠢꠣꠝꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PS96_9","020_96_9","PSA","96","9","9","ꠙꠣꠇ-ꠍꠣꠚ ꠖꠤꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠅ, ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠕꠞ-ꠕꠞꠣꠁꠀ ꠇꠣꠙꠤꠀ ꠃꠑꠅ। ");
INSERT INTO syls_vpl VALUES ("PS96_10","020_96_10","PSA","96","10","10","ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠄꠟꠣꠘ ꠇꠞꠅ, ꠝꠣꠛꠥꠖꠃ ꠛꠣꠖꠡꠣ। ꠎꠉꠔꠞꠦ ꠛꠣꠘꠣꠁꠍꠂꠘ ꠝꠎꠛꠥꠔ, ꠇꠞꠔ ꠘꠣꠄ ꠇꠥꠘꠥ ꠟꠠꠣ-ꠌꠠꠣ, ꠔꠣꠁꠘ ꠘꠤꠌ꠆ꠌꠤꠔ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS96_11","020_96_11","PSA","96","11","11","ꠀꠍꠝꠣꠘ ꠅꠇꠟ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠃꠇ, ꠖꠥꠘꠤꠀ ꠈꠥꠡꠤ ꠅꠃꠇ, ꠖꠞꠤꠀ ꠀꠞ ꠔꠣꠞ ꠝꠣꠎꠞ ꠡꠛ ꠎꠣꠘꠖꠣꠞ ꠉꠞ꠆ꠎꠤꠀ ꠃꠑꠃꠇ, ");
INSERT INTO syls_vpl VALUES ("PS96_12","020_96_12","PSA","96","12","12","ꠎꠝꠤꠘ ꠀꠞ ꠄꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠃꠇ, ꠛꠘ-ꠛꠣꠉꠣꠘꠞ ꠡꠛ ꠉꠣꠍ-ꠙꠣꠟꠣꠅ ꠀꠘꠘ꠆ꠖ-ꠃꠟ꠆ꠟꠣꠡ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PS96_13","020_96_13","PSA","96","13","13","ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠅꠟꠣꠃ ꠇꠞꠃꠇ ꠁꠔꠣ ꠢꠇꠟꠔꠣ, ꠔꠣꠁꠘ ꠔ ꠀꠁꠞꠣ ꠖꠥꠘꠤꠀꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠔꠣ। ꠎꠉꠔꠞ ꠛꠤꠌꠣꠞ-ꠚꠄꠍꠣꠟꠣ ꠇꠞꠛꠣ ꠢꠇ-ꠁꠘꠍꠣꠚꠦ, ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠛꠤꠌꠣꠞ-ꠚꠄꠍꠣꠟꠣ ꠇꠞꠛꠣ ꠢꠇ-ꠢꠣꠟꠣꠟꠤꠄ॥ ");
INSERT INTO syls_vpl VALUES ("PS97_1","020_97_1","PSA","97","1","1","ꠝꠣꠛꠥꠖꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠂꠘ, ꠖꠥꠘꠤꠀꠄ ꠇꠞꠃꠇ ꠚꠥꠞ꠆ꠔꠤ, ꠖꠥꠞ-ꠖꠥꠞꠣꠘ꠆ꠔꠞ ꠖꠤꠙ ꠅꠇꠟ ꠅꠃꠇ ꠝꠢꠣ ꠈꠥꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("PS97_2","020_97_2","PSA","97","2","2","ꠔꠣꠘ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠀꠍꠦ ꠔ ꠉꠁꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠀꠞ ꠇꠣꠟꠘꠤ, ꠔꠣꠘ ꠉꠖꠤꠞ ꠜꠤꠔ ꠅꠁꠟ ꠢꠇ ꠛꠤꠌꠣꠞ ꠀꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS97_3","020_97_3","PSA","97","3","3","ꠀꠉꠥꠁꠘ ꠎꠣꠄ ꠔꠣꠘ ꠀꠉꠦ ꠀꠉꠦ, ꠎꠣꠟꠣꠁꠀ ꠝꠣꠞꠦ ꠔꠣꠘ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠖꠥꠡꠝꠘꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS97_4","020_97_4","PSA","97","4","4","ꠔꠣꠘ ꠎꠤꠟꠇꠤꠄ ꠚꠞ ꠅꠁꠎꠣꠄ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔ ꠃꠑꠦ ꠇꠣꠙꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS97_5","020_97_5","PSA","97","5","5","ꠖꠤꠘ-ꠖꠥꠘꠤꠀꠞ ꠝꠣꠟꠤꠇ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ, ꠙꠣꠠ-ꠙꠞꠛꠔ ꠅꠇꠟ ꠝꠝꠞ ꠟꠣꠈꠣꠘ ꠉꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("PS97_6","020_97_6","PSA","97","6","6","ꠀꠍꠝꠣꠘ ꠅꠇꠟꠦ ꠄꠟꠣꠘ ꠇꠞꠦ ꠔꠣꠘ ꠙꠞꠦꠎꠉꠣꠞꠤ, ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠖꠦꠈꠦ ꠔꠣꠘ ꠝꠢꠤꠝꠣꠞ ꠛꠣꠢꠣꠖꠥꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS97_7","020_97_7","PSA","97","7","7","ꠅꠡꠣꠠ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠛꠠꠣꠁ ꠇꠞꠦ ꠎꠣꠞꠣ, ꠡꠞꠝ-ꠟꠁꠎ꠆ꠎꠣ ꠙꠣꠃꠇ ꠅꠔꠣ ꠝꠥꠞ꠆ꠔꠤ ꠙꠥꠎꠣꠞꠤꠞꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠃꠇ ꠅꠃ ꠖꠦꠛ-ꠖꠦꠛꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS97_8","020_97_8","PSA","97","8","8","ꠔꠥꠝꠣꠞ ꠢꠇ ꠛꠤꠌꠣꠞꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠍꠤꠅꠘ ꠅꠁꠟ ꠈꠥꠡꠤ, ꠄꠢꠥꠖꠣ ꠖꠦꠡꠞ ꠉꠣꠃ-ꠉꠦꠞꠣꠝꠦ ꠇꠞꠦꠞ ꠔ ꠚꠥꠞ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("PS97_9","020_97_9","PSA","97","9","9","ꠔꠥꠝꠤ ꠝꠣꠛꠥꠖ ꠔ ꠢꠣꠞꠣ ꠎꠉꠔꠞ ꠃꠙꠞꠀꠟꠣ, ꠢꠇꠟ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠛꠃꠔ ꠃꠙꠞꠦ ꠔꠥꠝꠣꠞ ꠑꠤꠇꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PS97_10","020_97_10","PSA","97","10","10","ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠅ ꠔꠥꠝꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇ ꠎꠣꠞꠣ, ꠀꠟ꠆ꠟꠣꠅꠀꠟꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠘ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠀꠔ ꠕꠣꠇꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS97_11","020_97_11","PSA","97","11","11","ꠙꠞꠦꠎꠉꠣꠞꠞ ꠟꠣꠉꠤ ꠛꠣꠠꠦ ꠘꠥꠞꠞ ꠇꠥꠠꠤ-ꠙꠣꠔꠣ, ꠈꠣꠐꠤ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠦ ꠔ ꠅꠄ ꠈꠥꠡꠤ-ꠚꠥꠞ꠆ꠔꠤ ꠖꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("PS97_12","020_97_12","PSA","97","12","12","ꠙꠞꠦꠎꠉꠣꠞ ꠎꠘ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ, ꠔꠣꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞꠔꠣꠞ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠅ ꠢꠇꠟꠦ॥ ");
INSERT INTO syls_vpl VALUES ("PS98_1","020_98_1","PSA","98","1","1","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠉꠤꠔ-ꠉꠎꠟ ꠉꠣꠅ ꠘꠄꠀ ꠘꠄꠀ, ꠔꠣꠁꠘ ꠔ ꠇꠞꠍꠂꠘ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠇꠣꠝ ꠎꠔꠔꠣ। ꠘꠤꠎꠞ ꠒꠣꠁꠘ ꠀꠔꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟ ꠖꠤꠀ, ꠇꠞꠍꠂꠘ ꠇꠔ ꠀꠌꠣꠘꠇ ꠎꠄꠅꠞ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS98_2","020_98_2","PSA","98","2","2","ꠝꠣꠛꠥꠖ ꠔꠣꠘ ꠃꠖ꠆ꠖꠣꠞ ꠇꠣꠝ ꠎꠣꠘꠣꠁꠍꠂꠘ ꠢꠇꠟꠞꠦ, ꠔꠣꠘ ꠢꠇ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠍꠂꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("PS98_3","020_98_3","PSA","98","3","3","ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠀꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ, ꠁꠀꠖ ꠞꠣꠈꠍꠂꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ, ꠖꠦꠈꠤꠍꠦ ꠎꠉꠔꠞ ꠢꠦꠡ ꠡꠤꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠦ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠣ ꠇꠣꠝꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS98_4","020_98_4","PSA","98","4","4","ꠅꠞꠦ ꠎꠉꠔꠛꠣꠡꠤ ꠉꠣꠅ ꠈꠥꠡꠤꠞ ꠉꠣꠘ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ, ꠛꠣꠁꠖ꠆ꠖ-ꠛꠣꠎꠘꠣꠞ ꠔꠣꠟꠦ ꠔꠣꠟꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ, ꠔꠣꠘ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠅ ꠔꠥꠝꠞꠣ ꠛꠠ ꠉꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS98_5","020_98_5","PSA","98","5","5","ꠛꠤꠘꠣ-ꠛꠦꠢꠣꠟꠣ ꠛꠣꠎꠣꠁꠀ ꠔꠣꠟꠦ ꠔꠣꠟꠦ ꠉꠣꠅ ꠉꠣꠘ, ꠝꠣꠛꠥꠖꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤ ꠉꠎꠟ-ꠉꠣꠘ ꠉꠣꠅ ꠔꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS98_6","020_98_6","PSA","98","6","6","ꠔꠥꠝꠞꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠥꠋꠉꠣ ꠀꠞ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠁꠀ, ꠀꠟ꠆ꠟꠣ ꠝꠣꠟꠤꠇꠞ ꠍꠣꠝꠘꠦ ꠉꠣꠅ ꠈꠥꠡꠤ ꠇꠞꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS98_7","020_98_7","PSA","98","7","7","ꠔꠣꠘ ꠔꠣꠞꠤꠚꠦ ꠉꠞ꠆ꠎꠤꠀ ꠃꠑꠃꠇ ꠛꠠ ꠉꠟꠣꠄ, ꠖꠞꠤꠀ ꠀꠞ ꠔꠣꠞ ꠝꠣꠎꠞ ꠢꠇꠟꠔꠣꠄ, ꠄꠞꠟꠉꠦ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ ꠎꠉꠔꠞ ꠡꠛ ꠛꠣꠡꠤꠘ꠆ꠖꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS98_8","020_98_8","PSA","98","8","8","ꠉꠣꠋꠉ ꠅꠇꠟꠦ ꠈꠥꠡꠤ ꠇꠞꠅ ꠀꠔꠞ ꠔꠣꠟꠤ ꠖꠤꠀ, ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ ꠄꠇꠟꠉꠦ ꠙꠣꠠ-ꠙꠞꠛꠔ ꠝꠤꠟꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("PS98_9","020_98_9","PSA","98","9","9","ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠉꠣꠅ ꠈꠥꠡꠤꠄ ꠉꠟꠣ ꠚꠣꠐꠣꠁꠀ, ꠖꠥꠘꠤꠀꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠔ ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖ ꠀꠁꠞꠣ, ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ ꠔꠣꠁꠘ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠞꠁꠀ, ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ ꠢꠇ-ꠁꠘꠍꠣꠚ ꠖꠤꠀ॥ ");
INSERT INTO syls_vpl VALUES ("PS99_1","020_99_1","PSA","99","1","1","ꠝꠣꠛꠥꠖꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠂꠘ, ꠎꠣꠔꠤ ꠅꠇꠟ ꠇꠣꠙꠃꠇ, ꠖꠥꠁꠅ ꠇꠣꠞꠥꠛꠤꠝꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠀꠡꠘ, ꠖꠥꠘꠤꠀꠄ ꠕꠞꠕꠞ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PS99_2","020_99_2","PSA","99","2","2","ꠙꠛꠤꠔ꠆ꠞ ꠍꠤꠅꠘ ꠘꠉꠞꠤꠞ ꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠃ ꠝꠢꠣꠘ, ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠁꠎ꠆ꠎꠔ-ꠡꠝ꠆ꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("PS99_3","020_99_3","PSA","99","3","3","ꠔꠣꠞꠣ ꠇꠞꠃꠇ ꠔꠥꠝꠣꠞ ꠉꠥꠘꠉꠣꠘ, ꠝꠢꠣꠘ ꠀꠞ ꠜꠄꠅꠋꠇꠞ ꠔꠥꠝꠣꠞ ꠘꠣꠝ, ꠔꠣꠞꠣ ꠇꠃꠇ, ꠝꠢꠣ ꠙꠛꠤꠔ꠆ꠞ ꠔꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS99_4","020_99_4","PSA","99","4","4","ꠅ ꠛꠟꠀꠟꠣ ꠛꠣꠖꠡꠣ, ꠢꠇ ꠛꠤꠌꠣꠞꠞꠦ ꠜꠣꠟꠣ ꠙꠣꠅ ꠔꠥꠝꠤ, ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠉꠣꠕꠤꠍ ꠔ ꠝꠎꠛꠥꠔ ꠇꠞꠤ, ꠁꠀꠇꠥꠛꠞ ꠛꠋꠡꠔ ꠛꠅꠀꠁꠟ ꠇꠞꠍ ꠢꠇ ꠛꠤꠌꠣꠞ ꠀꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PS99_5","020_99_5","PSA","99","5","5","ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠍꠁꠎꠖꠣ ꠇꠞꠅ ꠔꠣꠘ ꠇꠖꠝ ꠝꠥꠛꠣꠞꠇꠅ, ꠇꠅ, ꠝꠢꠣ ꠙꠛꠤꠔ꠆ꠞ ꠔꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PS99_6","020_99_6","PSA","99","6","6","ꠝꠥꠍꠣ ꠀꠞ ꠢꠣꠞꠥꠘ ꠀꠍꠟꠣ ꠔꠣꠘ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝꠅ, ꠡꠣꠝꠥꠄꠟ ꠘꠛꠤꠅ ꠞꠁꠔꠣ ꠔꠣꠘ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔꠅ, ꠎꠥꠀꠙ ꠙꠣꠁꠔꠣ ꠔꠣꠞꠣ ꠒꠣꠇꠤꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS99_7","020_99_7","PSA","99","7","7","ꠝꠦꠊꠞ ꠈꠥꠐꠤꠔ ꠞꠁꠀ ꠔꠣꠁꠘ ꠝꠣꠔꠤꠔꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ, ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠝꠣꠘꠤꠀ ꠔꠣꠞꠣ ꠌꠟꠔꠣ ꠔꠣꠘ ꠢꠥꠇꠥꠝꠦ। ");
INSERT INTO syls_vpl VALUES ("PS99_8","020_99_8","PSA","99","8","8","ꠅ ꠀꠟ꠆ꠟꠣ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ, ꠔꠣꠞꠣꠞ ꠝꠤꠘꠔꠤ ꠔꠥꠝꠤ ꠢꠥꠘꠔꠣꠄ, ꠔꠣꠞꠣꠞ ꠇꠍꠥꠞꠤꠞ ꠛꠖꠟꠣ ꠖꠤꠟꠦꠅ ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠚꠤ ꠖꠤꠔꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS99_9","020_99_9","PSA","99","9","9","ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠍꠁꠎꠖꠣ ꠇꠞꠅ ꠔꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠙꠣꠠꠅ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ॥ ");
INSERT INTO syls_vpl VALUES ("PS100_1","020_100_1","PSA","100","1","1","ꠡꠥꠇꠥꠞꠣꠘꠣ ꠉꠤꠔ ꠅꠞꠦ ꠎꠉꠔꠛꠣꠡꠤ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠅ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠥꠞ ꠉꠟꠣꠄ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS100_2","020_100_2","PSA","100","2","2","ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠅ ꠈꠥꠡ ꠖꠤꠟꠦ, ꠈꠥꠡꠤꠞ ꠉꠎꠟ ꠉꠣꠁꠀ ꠉꠣꠁꠀ ꠀꠅ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS100_3","020_100_3","PSA","100","3","3","ꠀꠟ꠆ꠟꠣꠃ ꠀꠍꠟ ꠝꠣꠛꠥꠖ, ꠝꠘꠅ ꠞꠣꠈꠤꠅ ꠔꠥꠝꠞꠣ, ꠀꠝꠞꠣꠞꠦ ꠛꠣꠘꠣꠁꠟꠣ ꠔꠣꠁꠘ, ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ ꠔ ꠀꠝꠞꠣ, ꠀꠝꠞꠣ ꠔꠣꠘ ꠝꠦꠠꠣꠞ ꠙꠣꠟ, ꠔꠣꠘ ꠎꠝꠤꠘꠅ ꠈꠣꠘꠤ ꠈꠣꠅꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PS100_4","020_100_4","PSA","100","4","4","ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠤ ꠇꠞꠤ ꠢꠣꠝꠣꠅ ꠔꠣꠘ ꠖꠥꠀꠞꠅ, ꠔꠣꠞꠤꠚ-ꠉꠤꠔ ꠉꠣꠁꠀ ꠉꠣꠁꠀ ꠀꠅ ꠔꠣꠘ ꠃꠑꠣꠘꠅ, ꠔꠣꠘ ꠘꠣꠝꠦ ꠡꠥꠇꠞꠤꠀ ꠔꠣꠞꠤꠚ ꠀꠖꠣꠄ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS100_5","020_100_5","PSA","100","5","5","ꠝꠣꠛꠥꠖꠃ ꠀꠍꠟ ꠜꠣꠟꠣ, ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ, ꠔꠣꠘ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠌꠣꠟꠥ ꠞꠄ ꠛꠋꠡꠞ ꠙꠞ ꠛꠋꠡ ꠗꠞꠤꠀ॥ ");
INSERT INTO syls_vpl VALUES ("PS117_1","020_117_1","PSA","117","1","1","ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠖꠦꠡ ꠀꠞ ꠉꠥꠡ꠆ꠐꠤꠄ ꠔꠣꠘ ꠘꠣꠝ ꠎꠚꠅ, ");
INSERT INTO syls_vpl VALUES ("PS117_2","020_117_2","PSA","117","2","2","ꠀꠝꠞꠣꠞ ꠛꠣꠄ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠇꠔ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ, ꠔꠣꠁꠘ ꠞꠂꠘ ꠢꠇ ꠢꠣꠟꠣꠟ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ, ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("PS118_1","020_118_1","PSA","118","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠅ, ꠔꠣꠁꠘ ꠔ ꠜꠣꠟꠣ, ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ। ");
INSERT INTO syls_vpl VALUES ("PS118_2","020_118_2","PSA","118","2","2","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠇꠃꠇ, ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ। ");
INSERT INTO syls_vpl VALUES ("PS118_3","020_118_3","PSA","118","3","3","ꠢꠣꠞꠥꠘꠞ ꠍꠤꠟꠍꠤꠟꠣꠄ ꠇꠃꠇ, ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ। ");
INSERT INTO syls_vpl VALUES ("PS118_4","020_118_4","PSA","118","4","4","ꠝꠣꠛꠥꠖꠞ ꠀꠡꠤꠇꠦ ꠇꠃꠇ, ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ। ");
INSERT INTO syls_vpl VALUES ("PS118_5","020_118_5","PSA","118","5","5","ꠝꠣꠛꠥꠖꠞꠦ ꠒꠣꠇꠤꠟꠣꠝ ꠀꠝꠤ ꠙꠠꠤꠀ ꠛꠤꠙꠖꠅ, ꠔꠣꠁꠘ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠤ ꠝꠞꠦ ꠘꠤꠟꠣ ꠈꠥꠟꠣ ꠝꠄꠖꠣꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("PS118_6","020_118_6","PSA","118","6","6","ꠝꠣꠛꠥꠖ ꠔ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ, ꠀꠝꠤ ꠒꠞꠣꠁꠔꠣꠝ ꠘꠣꠄ, ꠀꠖꠝꠦ ꠀꠝꠣꠞ ꠇꠤꠔꠣ ꠇꠞꠔ? ");
INSERT INTO syls_vpl VALUES ("PS118_7","020_118_7","PSA","118","7","7","ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞ ꠡꠢꠣꠄ, ꠖꠥꠡꠝꠘꠞ ꠛꠦꠢꠣꠟ ꠖꠡꠣ ꠖꠦꠈꠣꠁꠛꠣ ꠀꠟ꠆ꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS118_8","020_118_8","PSA","118","8","8","ꠀꠖꠝꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠣ ꠕꠣꠇꠤ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠄꠀꠔ ꠀꠡꠞꠄ ꠟꠅꠀ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS118_9","020_118_9","PSA","118","9","9","ꠛꠠꠟꠥꠇꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠣ ꠕꠣꠇꠤ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠄꠀꠔ ꠀꠡꠞꠄ ꠟꠅꠀ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS118_10","020_118_10","PSA","118","10","10","ꠢꠇꠟ ꠖꠦꠡꠦ ꠝꠤꠟꠤ ꠛꠦꠞꠤꠟꠤꠍꠤꠟ ꠀꠝꠣꠞꠦ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠡꠦꠡ ꠇꠞꠤꠟꠤꠍꠤ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS118_11","020_118_11","PSA","118","11","11","ꠢꠣꠍꠣꠃ ꠔꠣꠞꠣ ꠝꠞꠦ ꠛꠦꠞꠤꠟꠤꠍꠤꠟ ꠌꠣꠁꠞꠅꠛꠣꠄ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠡꠦꠡ ꠇꠞꠤꠟꠤꠍꠤ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS118_12","020_118_12","PSA","118","12","12","ꠜꠤꠋꠉꠥꠟꠞ ꠙꠣꠟꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠣꠞꠦ ꠛꠦꠞꠤꠍꠤꠟ, ꠢꠥꠇꠘꠣ ꠛꠘ-ꠎꠋꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠎꠟꠤꠀ ꠃꠑꠍꠤꠟ ꠔꠣꠞꠣ, ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠡꠦꠡ ꠇꠞꠤꠟꠤꠍꠤ ꠔꠣꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS118_13","020_118_13","PSA","118","13","13","ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠗꠣꠇ꠆ꠇꠣ ꠝꠣꠞꠍꠤꠟ ꠀꠝꠤ ꠎꠣꠘꠥ ꠙꠠꠤ ꠎꠣꠁ, ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠃ ꠀꠝꠣꠞ ꠡꠢꠣꠄ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PS118_14","020_118_14","PSA","118","14","14","ꠝꠣꠛꠥꠖꠃ ꠀꠝꠣꠞ ꠛꠟ, ꠀꠝꠣꠞ ꠈꠥꠡꠤꠞ ꠉꠤꠔ, ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠃꠙꠣꠄ ꠔꠣꠘ ꠀꠔꠅ ꠘꠤꠌ꠆ꠌꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("PS118_15","020_118_15","PSA","118","15","15","ꠙꠞꠦꠎꠉꠣꠞꠞ ꠊꠞꠅ ꠊꠞꠅ ꠎꠥꠖ꠆ꠖꠞ ꠎꠄꠅꠞ ꠉꠣꠘ, ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠦ ꠇꠞꠍꠂꠘ ꠀꠎꠛ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PS118_16","020_118_16","PSA","118","16","16","ꠝꠣꠛꠥꠖꠞ ꠒꠣꠁꠘ ꠀꠔ ꠃꠙꠞꠦ ꠔꠥꠟꠍꠂꠘ ꠔꠣꠁꠘ, ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠦ ꠇꠞꠍꠂꠘ ꠀꠎꠛ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PS118_17","020_118_17","PSA","118","17","17","ꠀꠝꠤ ꠔ ꠝꠞꠔꠣꠝ ꠘꠣꠄ, ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠝꠥ, ꠝꠣꠛꠥꠖꠦ ꠎꠦꠔꠣ ꠇꠞꠍꠂꠘ ꠢꠇꠟꠞꠦ ꠎꠣꠘꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PS118_18","020_118_18","PSA","118","18","18","ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠑꠤꠘ ꠡꠣꠎꠣ ꠖꠤꠍꠂꠘ, ꠅꠁꠟꠦ ꠝꠞꠘꠞ ꠀꠔꠅ ꠝꠞꠦ ꠘꠣꠢꠤ ꠡꠙꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS118_19","020_118_19","PSA","118","19","19","ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠟꠤꠀ ꠖꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠖꠥꠀꠞ, ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠡꠥꠇꠞꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠎꠣꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS118_20","020_118_20","PSA","118","20","20","ꠁꠔꠣ ꠔ ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠛꠥꠖꠞ ꠖꠥꠀꠞ, ꠈꠣꠟꠤ ꠙꠞꠦꠎꠉꠣꠞ ꠅꠇꠟ ꠅꠘꠅ ꠢꠣꠝꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS118_21","020_118_21","PSA","118","21","21","ꠔꠥꠝꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁ ꠀꠝꠣꠞ ꠀꠛꠖꠣꠞ ꠢꠥꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠀꠔꠅꠃ ꠘꠤꠌ꠆ꠌꠤꠔ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠃꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS118_22","020_118_22","PSA","118","22","22","ꠛꠦꠇꠣꠝꠣ ꠇꠁꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠍꠤꠟ ꠞꠣꠎ ꠝꠦꠡ꠆ꠔꠞꠤꠘ꠆ꠔꠦ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞ, ꠅꠇꠐꠣ ꠖꠤꠀꠃ ꠁꠀꠘ ꠈꠥꠐꠤ ꠅꠁꠟ ꠔꠣꠘ ꠊꠞꠞ। ");
INSERT INTO syls_vpl VALUES ("PS118_23","020_118_23","PSA","118","23","23","ꠝꠣꠛꠥꠖ ꠘꠤꠎꠦꠃ ꠁ ꠇꠣꠝ ꠇꠞꠣꠁꠟꠣ, ꠖꠦꠈꠤꠀ ꠔ ꠀꠝꠞꠣꠞ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠟꠣꠉꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("PS118_24","020_118_24","PSA","118","24","24","ꠁꠐꠣ ꠔ ꠢꠃ ꠖꠤꠘ ꠝꠣꠛꠥꠖꠞ ꠛꠣꠘꠣꠁꠟ ꠖꠤꠘ, ꠀꠅ ꠈꠥꠡꠤ ꠇꠞꠤ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠤ ꠡꠛꠦ ꠅꠃ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("PS118_25","020_118_25","PSA","118","25","25","ꠝꠤꠘꠔꠤ ꠇꠞꠤ ꠉ ꠝꠣꠛꠥꠖ ꠛꠣꠌꠣꠅ ꠀꠝꠞꠣꠞꠦ, ꠝꠤꠘꠔꠤ ꠇꠞꠤ ꠔꠥꠝꠤ ꠇꠣꠝꠤꠀꠛ ꠇꠞꠅ ꠀꠝꠞꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PS118_26","020_118_26","PSA","118","26","26","ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠦꠁꠘ ꠀꠁꠞꠣ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ, ꠝꠣꠛꠥꠖꠞ ꠊꠞꠅ ꠕꠣꠇꠤ ꠇꠁ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠞꠇꠔ ꠟꠣꠝꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PS118_27","020_118_27","PSA","118","27","27","ꠀꠟ꠆ꠟꠣꠃ ꠔ ꠝꠣꠛꠥꠖ, ꠀꠝꠞꠣꠞꠦ ꠖꠤꠍꠂꠘ ꠘꠥꠞ, ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥ ꠖꠠꠤꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠀꠘꠅ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠤꠋ ꠅꠇꠟꠅ ꠅꠉꠥ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠣꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("PS118_28","020_118_28","PSA","118","28","28","ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PS118_29","020_118_29","PSA","118","29","29","ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠅ, ꠔꠣꠁꠘꠃ ꠔ ꠜꠣꠟꠣ, ꠌꠤꠞꠇꠣꠟ ꠎꠣꠞꠤ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀ॥ ");
INSERT INTO syls_vpl VALUES ("PS121_1","020_121_1","PSA","121","1","1","ꠢꠎꠅ ꠎꠣꠅꠞꠣ ꠇꠣꠚꠦꠟꠣꠞ ꠇꠣꠅꠀꠟꠤ ꠀꠝꠤ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠙꠣꠠ-ꠙꠞꠛꠔꠞ ꠛꠣꠄ ꠌꠣꠁꠝꠥ, ꠀꠝꠣꠞ ꠡꠣꠄ-ꠡꠣꠁꠎ꠆ꠎ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠛ? ");
INSERT INTO syls_vpl VALUES ("PS121_2","020_121_2","PSA","121","2","2","ꠢꠃ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠀꠝꠣꠞ ꠡꠣꠁꠎ꠆ꠎ ꠀꠁꠛ, ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PS121_3","020_121_3","PSA","121","3","3","ꠔꠥꠝꠣꠞ ꠙꠣꠅꠞꠦ ꠔꠣꠁꠘ ꠙꠤꠍꠟꠣ ꠈꠣꠁꠔꠦ ꠖꠤꠔꠣ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠛꠣꠌꠣꠘꠦꠀꠟꠣ ꠔ ꠊꠥꠝꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS121_4","020_121_4","PSA","121","4","4","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠦꠁꠘ ꠛꠣꠌꠣꠁꠘ, ꠔꠣꠁꠘ ꠊꠥꠝꠣꠁꠔꠣ ꠘꠣꠄ, ꠃꠋꠉꠣꠁꠔꠣꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS121_5","020_121_5","PSA","121","5","5","ꠝꠣꠛꠥꠖꠃ ꠔꠥꠝꠣꠞ ꠢꠦꠚꠣꠎꠔꠇꠣꠞꠤ, ꠔꠥꠝꠣꠞ ꠀꠡꠞꠄ ꠍꠣꠄꠀ, ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠀꠔꠅ ꠗꠞꠤꠀ ꠔꠣꠁꠘ ꠀꠍꠂꠘ ꠈꠣꠠꠣ। ");
INSERT INTO syls_vpl VALUES ("PS121_6","020_121_6","PSA","121","6","6","ꠖꠤꠘꠞ ꠛꠣꠟꠣꠄ ꠡꠥꠞꠥꠎꠦ ꠀꠞ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣꠄ ꠌꠣꠘ꠆ꠖꠦ, ꠇꠥꠘꠥꠔꠣꠄꠃ ꠔꠥꠝꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PS121_7","020_121_7","PSA","121","7","7","ꠢꠇ꠆ꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠤꠙꠖ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠦꠃ ꠛꠣꠌꠣꠁꠛꠣ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠣꠞ ꠎꠣꠘꠞ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PS121_8","020_121_8","PSA","121","8","8","ꠔꠥꠝꠣꠞ ꠌꠟꠣ-ꠚꠤꠞꠣꠞ ꠡꠝꠄ ꠊꠞꠅ-ꠛꠣꠁꠞꠦ ꠝꠣꠛꠥꠖꠦꠃ ꠛꠣꠌꠣꠁꠛꠣ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ॥ ");
INSERT INTO syls_vpl VALUES ("PS150_1","020_150_1","PSA","150","1","1","ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠇꠅꠞꠦ ꠝꠥꠝꠤꠘ ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ, ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠇꠅ ꠛꠘ꠆ꠖꠣ ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ! ꠀꠟ꠆ꠟꠣꠞ ꠢꠦꠞꠦꠝꠅ ꠢꠣꠝꠣꠁꠀ ꠇꠅ ꠍꠥꠛꠢꠣꠘ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠘ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠉꠣꠅ ꠍꠥꠛꠢꠣꠘ ꠀꠟ꠆ꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("PS150_2","020_150_2","PSA","150","2","2","ꠔꠣꠘ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠔꠣꠘ ꠡꠣꠘ-ꠝꠢꠤꠝꠣꠞ ꠟꠣꠉꠤꠅ ꠔꠣꠞꠤꠚ ꠇꠞꠅ! ");
INSERT INTO syls_vpl VALUES ("PS150_3","020_150_3","PSA","150","3","3","ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠁꠀ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠛꠣꠡꠤ-ꠛꠦꠢꠣꠟꠣꠞ ꠡꠥꠞꠦ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("PS150_4","020_150_4","PSA","150","4","4","ꠔꠛꠟꠣꠞ ꠔꠣꠟꠦ ꠘꠣꠌꠤ ꠘꠣꠌꠤ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠖꠥꠔꠣꠞꠣ ꠀꠞ ꠛꠣꠡꠤꠞ ꠡꠥꠞꠦ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("PS150_5","020_150_5","PSA","150","5","5","ꠝꠘ꠆ꠖꠤꠞꠣꠞ ꠏꠥꠘ-ꠏꠥꠘꠣꠘꠤꠄ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠓꠥꠟ ꠀꠞ ꠈꠥꠟ-ꠇꠞꠔꠣꠟ ꠛꠣꠎꠣꠁꠀ ꠔꠣꠞꠤꠚ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PS150_6","020_150_6","PSA","150","6","6","ꠢꠇ꠆ꠇꠟ ꠎꠣꠘꠖꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ! ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠅ! ꠈꠔꠝ॥");
INSERT INTO syls_vpl VALUES ("JH1_1","033_1_1","JON","1","1","1","ꠝꠣꠔ꠆ꠔꠣꠞ ꠙꠥꠀ ꠁꠃꠘꠥꠍꠞ ꠉꠦꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠅꠃ ꠅꠢꠤ ꠘꠣꠎꠤꠟ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("JH1_2","033_1_2","JON","1","2","2","“ꠔꠥꠝꠤ ꠞꠅꠀꠘꠣ ꠖꠦꠅ, ꠀꠞ ꠘꠤꠘꠜ ꠘꠣꠝꠞ ꠢꠃ ꠛꠠ ꠐꠣꠃꠘꠅ ꠎꠣꠅ, ꠉꠤꠀ ꠀꠝꠣꠞ ꠉꠎꠛꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠅ। ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠎꠣꠁꠞ ꠅꠁꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JH1_3","033_1_3","JON","1","3","3","ꠅꠁꠟꠦ ꠁꠃꠘꠥꠍꠦ ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠤꠀ ꠜꠣꠉꠤꠀ ꠡ꠆ꠙꠦꠘ ꠖꠦꠡꠅ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ। ꠔꠣꠁꠘ ꠎꠣꠚꠣ ꠘꠣꠝꠞ ꠎꠣꠎꠞ ꠊꠣꠐꠅ ꠉꠤꠀ ꠡ꠆ꠙꠦꠘ ꠖꠦꠡꠅ ꠎꠣꠅꠞꠣ ꠄꠇꠈꠣꠘ ꠎꠣꠎ ꠙꠣꠁꠀ, ꠎꠣꠎꠞ ꠜꠣꠠꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠘꠦ ꠜꠣꠉꠤꠔꠣ ꠇꠞꠤ ꠘꠣꠁꠀꠂꠘ꠆ꠔꠞ ꠟꠉꠦ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH1_4","033_1_4","JON","1","4","4","ꠅꠁꠟꠦ ꠝꠣꠛꠥꠖꠦ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠦ ꠄꠇ ꠛꠦꠎꠥꠁꠔꠣ ꠔꠥꠚꠣꠘ ꠍꠣꠠꠤꠟꠣ। ꠔꠥꠚꠣꠘꠞ ꠑꠦꠟꠣꠄ ꠎꠣꠎꠈꠣꠘ ꠜꠣꠋꠉꠤ ꠎꠣꠅꠀꠞ ꠖꠡꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JH1_5","033_1_5","JON","1","5","5","ꠘꠣꠁꠀꠂꠘ꠆ꠔꠦ ꠒꠞꠣꠁꠀ ꠎꠣꠞꠎꠤꠞ ꠖꠦꠛꠔꠣꠞ ꠉꠦꠍꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ꠀꠞ ꠎꠣꠎꠞ ꠜꠣꠞ ꠇꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠟ। ꠅꠁꠟꠦ ꠁꠃꠘꠥꠍ ꠎꠣꠎꠞ ꠔꠟꠞ ꠔꠣꠟꠣꠔ ꠟꠣꠝꠤꠀ ꠢꠥꠔꠤ ꠞꠁꠟꠣ, ꠢꠥꠔꠤꠀ ꠛꠦꠖꠥꠝ ꠊꠥꠝꠅ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH1_6","033_1_6","JON","1","6","6","ꠅꠃ ꠡꠝꠄ ꠎꠣꠎꠞ ꠡꠣꠞꠋ ꠁꠃꠘꠥꠍꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠅꠂ ꠝꠤꠀ! ꠔꠥꠝꠤ ꠇꠦꠝꠘꠦ ꠊꠥꠝꠣꠁꠞꠣꠄ? ꠇꠥꠘ꠆ꠔꠣ ꠢꠥꠘꠞꠣꠄ ꠘꠣꠄ ꠘꠤ? ꠃꠑꠅ, ꠔꠥꠝꠣꠞ ꠖꠦꠛꠔꠣꠞꠦ ꠒꠣꠇꠅ। ꠅꠁꠔ ꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠛꠣ, ꠀꠝꠞꠣꠞ ꠎꠣꠘ ꠛꠤꠘꠣꠡ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JH1_7","033_1_7","JON","1","7","7","ꠛꠣꠖꠦ ꠘꠣꠁꠀꠂꠘ꠆ꠔꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟ, “ꠀꠅ ꠀꠝꠞꠣ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠖꠦꠈꠤ, ꠇꠣꠞ ꠖꠥꠡꠦ ꠁ ꠝꠍꠤꠛꠔ ꠀꠁꠍꠦ।” ꠔꠦꠃ ꠔꠣꠞꠣ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠟ ꠀꠞ ꠟꠐꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠁꠃꠘꠥꠍꠞ ꠘꠣꠝ ꠃꠑꠟ। ");
INSERT INTO syls_vpl VALUES ("JH1_8","033_1_8","JON","1","8","8","ꠅꠃ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠇꠣꠞ ꠖꠥꠡꠦ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠁ ꠝꠍꠤꠛꠔ ꠀꠁꠍꠦ? ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠇꠣꠝ ꠇꠞꠅ? ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍ? ꠇꠥꠘ ꠖꠦꠡꠞ ꠝꠣꠘꠥꠡ? ꠔꠥꠝꠤ ꠇꠥꠘ ꠎꠣꠔꠞ ꠝꠣꠘꠥꠡ?” ");
INSERT INTO syls_vpl VALUES ("JH1_9","033_1_9","JON","1","9","9","ꠁꠃꠘꠥꠍꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠤ ꠄꠇꠎꠘ ꠁꠛꠞꠣꠘꠤ, ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ। ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠟꠤꠇ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠤ, ꠔꠣꠁꠘꠃ ꠖꠞꠤꠀ ꠀꠞ ꠎꠝꠤꠘ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JH1_10","033_1_10","JON","1","10","10","ꠔꠣꠁꠘ ꠀꠞꠅ ꠇꠁꠟꠣ, ꠝꠣꠛꠥꠖꠞ ꠍꠣꠝꠘꠦ ꠕꠘꠦ ꠜꠣꠉꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠁꠘ ꠀꠁꠀ ꠎꠣꠎꠅ ꠃꠑꠍꠂꠘ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠒꠞꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠣꠄ, ꠢꠣꠄ! ꠔꠥꠝꠤ ꠁꠔꠣ ꠇꠥꠘ ꠎꠣꠔꠞ ꠇꠣꠝ ꠇꠞꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("JH1_11","033_1_11","JON","1","11","11","ꠖꠞꠤꠀꠞ ꠔꠥꠚꠣꠘ ꠎꠦꠛꠟꠣ ꠀꠞꠅ ꠛꠦꠎꠥꠁꠔꠣ ꠜꠣꠛ ꠗꠞꠟ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟ, “ꠀꠝꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠟꠦ ꠖꠞꠤꠀ ꠕꠤꠞ ꠅꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("JH1_12","033_1_12","JON","1","12","12","ꠁꠃꠘꠥꠍꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠣꠞꠦ ꠗꠞꠤꠀ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠦꠅ, ꠔꠦꠃ ꠖꠞꠤꠀ ꠡꠣꠘ꠆ꠔꠤ ꠅꠁꠎꠤꠛ। ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ, ꠀꠝꠣꠞ ꠖꠥꠡꠦꠃ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠁ ꠉꠎꠛꠤ ꠔꠥꠚꠣꠘ ꠀꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JH1_13","033_1_13","JON","1","13","13","ꠅꠁꠟꠦ ꠘꠣꠁꠀꠂꠘ꠆ꠔꠦ ꠔꠣꠘꠦ ꠘꠣ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠎꠈꠣꠘ ꠇꠤꠘꠣꠞꠅ ꠜꠤꠠꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠣꠘ-ꠙꠞꠣꠘ ꠡꠙꠤꠀ ꠖꠣꠠ ꠛꠣꠁꠟꠣ, ꠔꠥꠚꠣꠘꠞ ꠎꠥꠞ ꠈꠣꠟꠤ ꠛꠣꠠꠔꠦꠃ ꠞꠁꠟ, ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠎꠣꠎꠈꠣꠘ ꠇꠤꠘꠣꠞꠅ ꠘꠤꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JH1_14","033_1_14","JON","1","14","14","ꠔꠦꠃ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠚꠞꠤꠀꠖ ꠇꠞꠟ, ꠇꠁꠟ “ꠅ ꠝꠣꠛꠥꠖ, ꠞꠢꠝ ꠇꠞꠅ, ꠅꠃ ꠝꠣꠘꠡꠞ ꠎꠣꠘꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞꠦ ꠝꠣꠞꠤꠅ ꠘꠣ, ꠁ ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞ ꠎꠣꠘꠞ ꠇꠣꠞꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠄꠁ ꠇꠞꠤꠅ ꠘꠣ। ꠅ ꠝꠣꠛꠥꠖ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠔ ꠔꠥꠝꠣꠞ ꠝꠥꠘꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("JH1_15","033_1_15","JON","1","15","15","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠁꠃꠘꠥꠍ ꠘꠛꠤꠞꠦ ꠗꠞꠤꠀ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠟ, ꠀꠞ ꠖꠞꠤꠀꠞ ꠔꠥꠚꠣꠘꠞ ꠓꠦꠃ ꠖꠝ ꠟꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JH1_16","033_1_16","JON","1","16","16","ꠁ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞꠦ ꠈꠥꠛ ꠒꠞꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠙꠡꠥ-ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ ꠀꠞ ꠝꠣꠘ꠆ꠘꠔ ꠝꠣꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH1_17","033_1_17","JON","1","17","17","ꠝꠣꠛꠥꠖꠦ ꠈꠥꠛ ꠛꠠ ꠄꠇ ꠝꠣꠍꠞꠦ ꠎꠥꠉꠣꠁ ꠕꠁꠍꠟꠣ ꠁꠃꠘꠥꠍꠞꠦ ꠉꠤꠟꠤꠟꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠁꠘ ꠔꠤꠘ ꠖꠤꠘ, ꠔꠤꠘ ꠞꠣꠁꠔ ꠢꠃ ꠝꠣꠍꠞ ꠙꠦꠐꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH2_1","033_2_1","JON","2","1","1","ꠁꠃꠘꠥꠍꠦ ꠝꠣꠍꠞ ꠙꠦꠐꠅ ꠕꠘꠦ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH2_2","033_2_2","JON","2","2","2","ꠝꠍꠤꠛꠔꠅ ꠙꠁꠠꠣ ꠝꠃꠟꠣ ꠒꠣꠇꠤꠟꠣꠝ ꠔꠞꠦ, ꠞꠢꠝ ꠇꠞꠤꠀ ꠔꠥꠁ ꠎꠥꠀꠙ ꠖꠤꠟꠦ ꠝꠞꠦ। ꠙꠣꠔꠣꠟꠞ ꠙꠦꠐꠅ ꠛꠁꠀ ꠀꠝꠤ ꠇꠣꠘ꠆ꠖꠤꠟꠣꠝ, ꠇꠛꠥꠟ ꠇꠞꠤꠟꠣꠄ ꠀꠞꠎ ꠞꠢꠤꠝ ꠞꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("JH2_3","033_2_3","JON","2","3","3","ꠖꠞꠤꠀꠞ ꠝꠥꠞꠅ ꠛꠘ꠆ꠖꠥ ꠝꠞꠦ ꠚꠣꠟꠣꠁꠟꠣꠄ, ꠔꠥꠝꠣꠞ ꠙꠣꠘꠤꠞ ꠓꠦꠃꠄ ꠀꠝꠣꠄ ꠜꠣꠡꠣꠁ ꠟꠁꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JH2_4","033_2_4","JON","2","4","4","ꠝꠤꠟꠦ ꠘꠣ ꠖꠤꠖꠣꠞ ꠔꠥꠝꠣꠞ ꠘꠣꠁ ꠇꠣꠘ꠆ꠒꠣꠞꠤ, ꠔꠣꠟ꠆ꠟꠣꠡꠤ ꠇꠞꠤꠀ ꠝꠥꠇꠣꠝ ꠎꠤꠇꠤꠞ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("JH2_5","033_2_5","JON","2","5","5","ꠓꠦꠃꠅꠞ ꠝꠣꠎꠦꠔꠦ ꠙꠠꠤ ꠎꠣꠘ ꠗꠠꠚꠠ ꠇꠞꠦ, ꠖꠞꠤꠀꠞ ꠟꠔꠣ-ꠙꠣꠔꠣꠄ ꠙꠦꠌꠤꠟꠤꠟ ꠝꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("JH2_6","033_2_6","JON","2","6","6","ꠙꠣꠔꠣꠟꠞ ꠔꠟꠦ ꠉꠤꠀ ꠝꠤꠟꠦꠞ ꠘꠣ ꠇꠤꠘꠣꠞ, ꠈꠞꠦꠖꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠤ ꠖꠥꠀꠞ ꠘꠣꠁ ꠀꠞ। ꠛꠘ꠆ꠖꠤ ꠅꠁꠀ ꠇꠣꠘ꠆ꠖꠤ ꠀꠝꠤ ꠘꠤꠞꠣꠡ ꠛꠖꠘꠦ, ꠀꠎꠣꠖ ꠇꠞꠤꠟꠣꠄ ꠝꠃꠟꠣ ꠉꠁꠘ ꠉꠣꠠꠣ ꠕꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("JH2_7","033_2_7","JON","2","7","7","ꠎꠣꠘ ꠀꠝꠣꠞ ꠎꠣꠄ ꠎꠣꠄ ꠅꠁꠟ ꠎꠈꠘ, ꠇꠣꠔꠞ ꠅꠁꠀ ꠉ ꠛꠘ꠆ꠖꠥ ꠇꠞꠤꠘꠥ ꠡꠞꠘ। ꠜꠤꠇ꠆ꠇꠣ ꠝꠣꠋꠉꠤꠟꠣꠝ ꠇꠣꠋꠉꠣꠟ ꠖꠞꠛꠣꠞꠦ ꠔꠥꠝꠣꠞ, ꠀꠞꠡꠅ ꠕꠣꠇꠤꠀ ꠖꠄꠀꠟ ꠖꠦꠈꠣꠁꠟꠣꠄ ꠖꠤꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("JH2_8","033_2_8","JON","2","8","8","ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠇꠞꠦ ꠎꠣꠞꠣ ꠘꠣ ꠙꠣꠁꠛ ꠞꠢꠝꠔ, ꠄꠟꠣꠝꠤ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠀꠞꠣꠁꠟ ꠇꠥꠖꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("JH2_9","033_2_9","JON","2","9","9","ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠅ ꠁꠃꠘꠥꠍ ꠝꠣꠛꠥꠖ ꠝꠦꠢꠦꠞꠛꠣꠘ, ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠦ ꠀꠝꠤ ꠇꠞꠤꠝꠥ ꠇꠥꠞꠛꠣꠘ। ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠡꠙꠤꠝꠥ ꠔꠞꠦ, ꠘꠣꠎꠣꠔꠞ ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠄ ꠛꠣꠌꠣꠅ ꠀꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("JH2_10","033_2_10","JON","2","10","10","ꠛꠣꠖꠦ ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠝꠣꠍꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠝꠣꠍꠦ ꠁꠃꠘꠥꠍꠞꠦ ꠘꠤꠀ ꠢꠥꠇꠘꠣ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠛꠣꠁꠔ ꠇꠞꠤ ꠚꠣꠟꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JH3_1","033_3_1","JON","3","1","1","ꠛꠣꠖꠦ ꠁꠃꠘꠥꠍꠞ ꠃꠙꠞꠦ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠝꠣꠛꠥꠖꠞ ꠅꠃ ꠅꠢꠤ ꠘꠣꠎꠤꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JH3_2","033_3_2","JON","3","2","2","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠞꠅꠀꠘꠣ ꠖꠦꠅ, ꠅꠈꠘ ꠢꠃ ꠛꠠ ꠐꠣꠃꠘ ꠘꠤꠘꠜ ꠎꠣꠅ, ꠀꠞ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁ ꠖꠤꠝꠥ ꠔꠥꠝꠤ ꠅꠃꠔꠣ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠄꠟꠣꠘ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("JH3_3","033_3_3","JON","3","3","3","ꠝꠣꠛꠥꠖꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠁꠃꠘꠥꠍ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠘꠤꠘꠜ ꠉꠦꠟꠣ। ꠘꠤꠘꠜ ꠅꠁꠟ ꠈꠥꠛ ꠛꠠ ꠐꠣꠃꠘ, ꠁ ꠐꠣꠃꠘꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣꠔ ꠎꠣꠁꠔꠦ ꠔꠤꠘ ꠖꠤꠘ ꠟꠣꠉꠔ। ");
INSERT INTO syls_vpl VALUES ("JH3_4","033_3_4","JON","3","4","4","ꠁꠃꠘꠥꠍ ꠢꠃ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠁꠀ ꠄꠇꠖꠤꠘꠞ ꠙꠕ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠄꠟꠣꠘ ꠇꠞꠟꠣ, ꠇꠁꠟꠣ, “ꠅ ꠘꠤꠘꠜꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠀꠞ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠛꠣꠖꠦ ꠘꠤꠘꠜ ꠐꠣꠃꠘ ꠃꠟꠐ-ꠙꠣꠟꠐ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("JH3_5","033_3_5","JON","3","5","5","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠘꠤꠘꠜꠞ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ, ꠔꠣꠞꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠄꠟꠣꠘ ꠇꠞꠟꠣ, ꠀꠞ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟꠦ ꠖꠥꠈ ꠎꠣꠁꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠟꠣꠞ ꠌꠐ ꠚꠤꠘ꠆ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH3_6","033_3_6","JON","3","6","6","ꠁ ꠈꠛꠞ ꠉꠤꠀ ꠛꠣꠖꠡꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠟ, ꠔꠣꠁꠘꠅ ꠛꠣꠖꠡꠣꠁ ꠉꠖꠤ ꠍꠣꠠꠤꠀ ꠚꠤꠘ꠆ꠘꠞ ꠟꠦꠛꠣꠍ ꠈꠥꠟꠤꠀ, ꠍꠟꠣꠞ ꠌꠐ ꠚꠤꠘ꠆ꠖꠤꠀ ꠍꠣꠟꠤꠞ ꠝꠣꠎꠦ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH3_7","033_3_7","JON","3","7","7","ꠀꠞ ꠔꠣꠁꠘ ꠀꠡ꠆ꠔꠣ ꠘꠤꠘꠜ ꠐꠣꠃꠘꠅ ꠅꠃ ꠄꠟꠣꠘ ꠇꠞꠣꠁꠟꠣ, “ꠛꠣꠖꠡꠣ ꠀꠞ ꠔꠣꠘ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠅꠇꠟꠞ ꠢꠥꠇꠥꠝ ꠅꠁꠟ: ꠝꠣꠘꠥꠡ ꠛꠣ ꠙꠡꠥ, ꠉꠞꠥ-ꠍꠣꠉꠟ ꠇꠦꠃ ꠇꠥꠘꠥꠎꠣꠔ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠝꠥꠈꠅ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JH3_8","033_3_8","JON","3","8","8","ꠝꠣꠘꠥꠡ ꠀꠞ ꠙꠡꠥ, ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠍꠟꠣꠞ ꠌꠐ ꠚꠤꠘ꠆ꠖꠤꠀ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠟꠅ, ꠢꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠙꠕ ꠍꠣꠠꠅ ꠀꠞ ꠎꠥꠞ-ꠎꠥꠟꠥꠝ ꠛꠣꠖ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JH3_9","033_3_9","JON","3","9","9","ꠅꠁꠔ ꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠞꠢꠝ ꠇꠞꠛꠣ, ꠉꠎꠛꠞ ꠈꠤꠀꠟ ꠛꠖꠟꠣꠁꠟꠤꠛꠣ, ꠔꠣꠘ ꠖꠣꠃ ꠖꠣꠃ ꠇꠞꠣ ꠉꠥꠍꠣ ꠅꠘꠦ ꠑꠣꠘ꠆ꠒꠣ ꠅꠁꠎꠤꠛ, ꠀꠞ ꠀꠝꠞꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JH3_10","033_3_10","JON","3","10","10","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠁ ꠢꠣꠟꠔ ꠖꠦꠈꠟꠣ, ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠙꠕ ꠛꠣꠖ ꠖꠤꠀ ꠔꠃꠛꠣ ꠇꠞꠍꠂꠘ। ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘꠅ ꠔꠣꠘ ꠀꠉꠞ ꠌꠤꠘ꠆ꠔꠣ ꠛꠖꠟꠣꠁꠟꠤꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠇꠕꠣ ꠇꠁꠟꠦꠅ ꠅꠈꠘ ꠀꠞ ꠛꠤꠘꠣꠡ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JH4_1","033_4_1","JON","4","1","1","ꠅꠁꠟꠦ ꠁꠃꠘꠥꠍꠦ ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠦꠈ꠆ꠔ ꠅꠁꠀ ꠈꠥꠛ ꠉꠥꠍꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH4_2","033_4_2","JON","4","2","2","ꠔꠣꠁꠘ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠚꠞꠤꠀꠖ ꠇꠞꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠤ ꠖꠦꠡꠅ ꠕꠣꠇꠔꠦꠃ ꠔ ꠎꠣꠘꠔꠣꠝ ꠁꠟꠣꠈꠣꠘ ꠅꠁꠛ। ꠄꠞꠖꠣꠄ ꠀꠝꠤ ꠀꠉꠦꠃ ꠡ꠆ꠙꠦꠘ ꠖꠦꠡꠅ ꠢꠞꠤꠀ ꠎꠣꠁꠔꠣꠝꠉꠤ ꠌꠣꠁꠍꠟꠣꠝ। ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ, ꠔꠥꠝꠤ ꠖꠄꠀ-ꠝꠝꠔꠣꠄ ꠜꠞꠣ ꠀꠟ꠆ꠟꠣ, ꠉꠥꠍꠣ ꠇꠞ ꠗꠤꠞ ꠉꠔꠤꠄ, ꠞꠢꠝ ꠇꠞ ꠛꠦꠢꠤꠡꠣꠛ, ꠀꠞ ꠉꠎꠛ ꠘꠣꠎꠤꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠛꠖꠟꠣꠁꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("JH4_3","033_4_3","JON","4","3","3","ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠤ ꠅꠈꠘ ꠀꠞꠎ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠎꠣꠘꠈꠣꠘ ꠘꠦꠅꠉꠤ, ꠀꠝꠣꠞ ꠔ ꠛꠣꠌꠣ ꠕꠣꠇꠤ ꠝꠞꠣꠃ ꠜꠣꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("JH4_4","033_4_4","JON","4","4","4","ꠝꠣꠛꠥꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠣꠞ ꠉꠥꠍꠣ ꠇꠞꠣ ꠑꠤꠇ ꠅꠞ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JH4_5","033_4_5","JON","4","5","5","ꠛꠣꠖꠦ ꠁꠃꠘꠥꠍ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠣ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠙꠥꠛꠦꠖꠤ ꠄꠇ ꠎꠣꠉꠣꠔ ꠒꠦꠞꠣ ꠐꠣꠋꠉꠣꠁꠀ, ꠒꠦꠞꠣꠞ ꠍꠦꠛꠣꠔ ꠛꠁꠞꠁꠟꠣ। ꠀꠞ ꠐꠣꠃꠘꠞ ꠇꠤꠔꠣ ꠖꠡꠣ ꠅꠄ ꠅꠃꠔꠣ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH4_6","033_4_6","JON","4","6","6","ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠢꠘꠅ ꠄꠇ ꠉꠣꠍ ꠎꠥꠉꠣꠁꠟꠣ। ꠁ ꠉꠣꠍꠞ ꠟꠔ ꠛꠣꠠꠤꠀ ꠟꠣꠝ꠆ꠛꠣ ꠅꠁꠀ, ꠁꠃꠘꠥꠍꠞ ꠇꠡ꠆ꠐ ꠇꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠦ ꠀꠞꠣꠝꠞ ꠍꠦꠛꠣ ꠖꠤꠟ। ꠀꠞ ꠁꠃꠘꠥꠍꠦꠅ ꠁ ꠉꠣꠍꠞ ꠍꠦꠛꠣ ꠙꠣꠁꠀ ꠈꠥꠛ ꠀꠟ꠆ꠟꠣꠖꠦ ꠉꠖꠉꠖ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JH4_7","033_4_7","JON","4","7","7","ꠅꠁꠟꠦ ꠛꠣꠖꠞ ꠖꠤꠘ ꠚꠎꠞ ꠅꠇ꠆ꠔꠅ ꠀꠟ꠆ꠟꠣꠄ ꠄꠉꠥ ꠙꠥꠇ ꠎꠥꠉꠣꠁꠟꠣ। ꠙꠥꠇꠦ ꠀꠁꠀ ꠉꠣꠍꠞ ꠉꠥꠠꠤ ꠇꠣꠐꠤꠖꠤꠟ, ꠇꠣꠐꠣꠞ ꠛꠣꠖꠦ ꠁꠉꠥ ꠢꠥꠇꠣꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("JH4_8","033_4_8","JON","4","8","8","ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠡꠥꠞꠥꠎ ꠃꠑꠟ, ꠅꠃ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠄ ꠙꠥꠛꠣꠟꠤ ꠉꠞꠝ ꠢꠣꠅꠀ ꠎꠥꠉꠣꠁꠟꠣ। ꠞꠂꠖꠦ ꠁꠃꠘꠥꠍꠞ ꠝꠣꠕꠣꠔ ꠈꠥꠛ ꠉꠞꠝ ꠟꠣꠉꠟ, ꠔꠣꠁꠘ ꠛꠦꠃꠡ ꠅꠁꠎꠤꠛꠣꠞ ꠖꠡꠣ। ꠔꠦꠃ ꠁꠃꠘꠥꠍꠦ ꠝꠞꠘ ꠝꠣꠋꠉꠤꠟꠣ, ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠔ ꠛꠣꠌꠣ ꠕꠣꠇꠤ ꠝꠞꠘꠃ ꠜꠣꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("JH4_9","033_4_9","JON","4","9","9","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠁꠃꠘꠥꠍꠞꠦ ꠇꠁꠟꠣ, “ꠁ ꠉꠣꠍꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠉꠥꠍꠣ ꠇꠞꠣ ꠇꠥꠘꠥ ꠑꠤꠇ ꠅꠞ ꠘꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠔꠣꠞ ꠇꠣꠞꠘ ꠀꠍꠦ। ꠀꠝꠤ ꠉꠥꠍꠣ ꠇꠞꠤꠀꠃ ꠝꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JH4_10","033_4_10","JON","4","10","10","ꠝꠣꠛꠥꠖꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔ ꠁ ꠉꠣꠍꠞ ꠟꠣꠉꠤꠀ ꠇꠥꠘꠥ ꠇꠡ꠆ꠐ ꠇꠞꠍ ꠘꠣ, ꠀꠞ ꠁꠉꠥ ꠛꠠꠅ ꠇꠞꠍ ꠘꠣ। ꠁꠉꠥ ꠔ ꠈꠣꠟꠤ ꠄꠇ ꠞꠣꠁꠔꠦ ꠅꠁꠍꠦ, ꠀꠞ ꠄꠇ ꠞꠣꠁꠔꠦꠃ ꠝꠞꠤꠉꠦꠍꠦ, ꠔꠦꠛꠃ ꠁꠉꠥꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠄꠀ ꠟꠣꠉꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JH4_11","033_4_11","JON","4","11","11","ꠅꠁꠟꠦ ꠁ ꠘꠤꠘꠜ ꠐꠣꠃꠘꠅ ꠔ ꠄꠇ ꠟꠣꠈ ꠛꠤꠡ ꠀꠎꠣꠞꠞꠅ ꠛꠦꠡꠤ ꠝꠣꠘꠥꠡ ꠀꠍꠂꠘ, ꠎꠦꠞꠣ ꠘꠤꠎꠞ ꠒꠣꠁꠘ-ꠛꠣꠃ ꠇꠤꠔꠣ ꠌꠤꠘꠦ ꠘꠣ। ꠀꠞ ꠛꠃꠔ ꠢꠦꠝꠣꠘ-ꠎꠣꠘꠥꠀꠞꠅ ꠀꠍꠂꠘ, ꠔꠦ ꠅꠔ ꠛꠠ ꠐꠣꠃꠘꠞ ꠛꠣꠄ ꠀꠝꠤ ꠇꠤꠔꠣ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ ꠇꠞꠔꠣꠝ ꠘꠣ ꠘꠤ?” ꠈꠔꠝ॥");
INSERT INTO syls_vpl VALUES ("MT1_1","070_1_1","MAT","1","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠅꠁꠟꠣ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠛꠋꠡꠗꠞ, ꠀꠞ ꠖꠣꠃꠖ ꠅꠁꠟꠣ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠛꠋꠡꠗꠞ। ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠙꠞꠤꠌꠄ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT1_2","070_1_2","MAT","1","2","2","ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠙꠥꠀ ꠢꠎꠞꠔ ꠁꠍꠢꠣꠇ, ꠁꠍꠢꠣꠇꠞ ꠙꠥꠀ ꠢꠎꠞꠔ ꠁꠀꠇꠥꠛ, ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠄꠢꠥꠖꠣ ꠀꠞ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ, ");
INSERT INTO syls_vpl VALUES ("MT1_3","070_1_3","MAT","1","3","3","ꠄꠢꠥꠖꠣꠞ ꠙꠥꠀꠂꠘ ꠚꠤꠞꠥꠎ ꠀꠞ ꠎꠣꠞꠣꠢ, ꠄꠞꠣꠞ ꠝꠣʼꠞ ꠘꠣꠝ ꠔꠣꠝꠣꠞ। ꠚꠤꠞꠥꠎꠞ ꠙꠥꠀ ꠢꠣꠍꠤꠞ, ꠢꠣꠍꠤꠞꠞ ꠙꠥꠀ ꠞꠣꠄꠀꠝ, ");
INSERT INTO syls_vpl VALUES ("MT1_4","070_1_4","MAT","1","4","4","ꠞꠣꠄꠀꠝꠞ ꠙꠥꠀ ꠀꠝꠤꠘꠣꠖꠣꠛ, ꠀꠝꠤꠘꠣꠖꠣꠛꠞ ꠙꠥꠀ ꠘꠣꠢꠤꠡ, ꠘꠣꠢꠤꠡꠞ ꠙꠥꠀ ꠍꠦꠟꠤꠝ, ");
INSERT INTO syls_vpl VALUES ("MT1_5","070_1_5","MAT","1","5","5","ꠍꠦꠟꠤꠝꠞ ꠙꠥꠀ ꠛꠥꠀꠎ, ꠔꠣꠘ ꠝꠣʼꠞ ꠘꠣꠝ ꠞꠣꠢꠛꠣ। ꠛꠥꠀꠎꠞ ꠙꠥꠀ ꠃꠛꠣꠄꠖ, ꠔꠣꠘ ꠝꠣ ꠅꠁꠟꠣ ꠞꠥꠔ। ꠃꠛꠣꠄꠖꠞ ꠙꠥꠀ ꠁꠀꠍ, ");
INSERT INTO syls_vpl VALUES ("MT1_6","070_1_6","MAT","1","6","6","ꠁꠀꠍꠞ ꠙꠥꠀ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖ। ꠖꠣꠃꠖꠞ ꠙꠥꠀ ꠘꠛꠤ ꠍꠥꠟꠣꠁꠝꠣꠘ, ꠄꠘ ꠝꠣ ꠀꠍꠟꠣ ꠃꠞꠤꠀꠞ ꠠꠣꠠꠤ ꠛꠃ ꠛꠣꠔꠍꠦꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT1_7","070_1_7","MAT","1","7","7","ꠍꠥꠟꠣꠁꠝꠣꠘꠞ ꠙꠥꠀ ꠞꠢꠛꠤꠀꠝ, ꠞꠢꠛꠤꠀꠝꠞ ꠙꠥꠀ ꠀꠛꠤꠀ, ꠀꠛꠤꠀꠞ ꠙꠥꠀ ꠀꠍꠣ, ");
INSERT INTO syls_vpl VALUES ("MT1_8","070_1_8","MAT","1","8","8","ꠀꠍꠣꠞ ꠙꠥꠀ ꠎꠤꠢꠥꠍꠣꠚꠐ, ꠎꠤꠢꠥꠍꠣꠚꠐꠞ ꠙꠥꠀ ꠃꠞꠣꠝ, ꠃꠞꠣꠝꠞ ꠙꠥꠀ ꠃꠎꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("MT1_9","070_1_9","MAT","1","9","9","ꠃꠎꠤꠀꠞ ꠙꠥꠀ ꠎꠥꠕꠝ, ꠎꠥꠕꠝꠞ ꠙꠥꠀ ꠀꠢꠣꠎ, ꠀꠢꠣꠎꠞ ꠙꠥꠀ ꠢꠤꠎꠇꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("MT1_10","070_1_10","MAT","1","10","10","ꠢꠤꠎꠇꠤꠀꠞ ꠙꠥꠀ ꠝꠣꠘꠡꠣ, ꠝꠣꠘꠡꠣꠞ ꠙꠥꠀ ꠀꠝꠘ, ꠀꠝꠘꠞ ꠙꠥꠀ ꠁꠃꠡꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("MT1_11","070_1_11","MAT","1","11","11","ꠁꠃꠡꠤꠀꠞ ꠙꠥꠀ ꠁꠀꠇꠥꠘꠤꠀ ꠀꠞ ꠔꠣꠞ ꠜꠣꠁꠀꠁꠘ। ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞꠦ ꠛꠣꠛꠤꠟ ꠖꠦꠡꠅ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠘꠦꠅꠀꠞ ꠛꠣꠟꠣ ꠄꠞꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT1_12","070_1_12","MAT","1","12","12","ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞꠦ ꠛꠣꠛꠤꠟ ꠖꠦꠡꠅ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠘꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠁꠀꠇꠥꠘꠤꠀꠞ ꠙꠥꠀ ꠍꠣꠟꠔꠤꠄꠟꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ꠍꠣꠟꠔꠤꠄꠟꠞ ꠙꠥꠀ ꠎꠦꠞꠛꠣꠛꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("MT1_13","070_1_13","MAT","1","13","13","ꠎꠦꠞꠛꠣꠛꠤꠟꠞ ꠙꠥꠀ ꠀꠛꠤꠢꠥꠖ, ꠀꠛꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠁꠟꠤꠀꠇꠤꠝ, ꠁꠟꠤꠀꠇꠤꠝꠞ ꠙꠥꠀ ꠀꠎꠞ, ");
INSERT INTO syls_vpl VALUES ("MT1_14","070_1_14","MAT","1","14","14","ꠀꠎꠞꠞ ꠙꠥꠀ ꠍꠣꠖꠤꠇ, ꠍꠣꠖꠤꠇꠞ ꠙꠥꠀ ꠀꠈꠤꠝ, ꠀꠈꠤꠝꠞ ꠙꠥꠀ ꠄꠟꠤꠢꠥꠖ, ");
INSERT INTO syls_vpl VALUES ("MT1_15","070_1_15","MAT","1","15","15","ꠄꠟꠤꠢꠥꠖꠞ ꠙꠥꠀ ꠀꠟꠤ-ꠀꠎꠞ, ꠀꠟꠤ-ꠀꠎꠞꠞ ꠙꠥꠀ ꠝꠔꠤꠘ, ꠝꠔꠤꠘꠞ ꠙꠥꠀ ꠁꠀꠇꠥꠛ, ");
INSERT INTO syls_vpl VALUES ("MT1_16","070_1_16","MAT","1","16","16","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠁꠃꠍꠥꠚ, ꠅꠃ ꠁꠃꠍꠥꠚ ꠅꠁꠟꠣ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠞ ꠎꠣꠝꠣꠁ। ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠞ ꠙꠦꠐꠅ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ, ꠄꠘꠞꠦ ꠒꠣꠇꠣ ꠅꠄ ꠀꠟ-ꠝꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("MT1_17","070_1_17","MAT","1","17","17","ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠕꠣꠇꠤ ꠖꠣꠃꠖ ꠘꠛꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠌꠃꠖ꠆ꠖ ꠍꠤꠠꠤ। ꠖꠣꠃꠖ ꠘꠛꠤ ꠕꠣꠇꠤ ꠛꠣꠛꠤꠟꠅ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠘꠦꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠌꠃꠖ꠆ꠖ ꠍꠤꠠꠤ। ꠛꠣꠛꠤꠟꠅ ꠛꠘ꠆ꠖꠤ ꠅꠀ ꠕꠣꠇꠤ ꠀꠟ-ꠝꠍꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠌꠃꠖ꠆ꠖ ꠍꠤꠠꠤ। ");
INSERT INTO syls_vpl VALUES ("MT1_18","070_1_18","MAT","1","18","18","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ ꠅꠃ ꠟꠣꠈꠣꠘ। ꠁꠃꠍꠥꠚ ꠘꠣꠝꠞ ꠄꠇꠎꠘꠞ ꠟꠉꠦ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠞ ꠡꠣꠖꠤ ꠑꠤꠇ ꠅꠁꠍꠤꠟ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠄꠇꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣꠞ ꠀꠉꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠝꠞꠤꠅꠝꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT1_19","070_1_19","MAT","1","19","19","ꠁꠃꠍꠥꠚ ꠀꠍꠟꠣ ꠢꠇ ꠝꠣꠘꠥꠡ, ꠝꠞꠤꠅꠝꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠍꠦ, ꠁ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠘ ꠝꠞꠤꠅꠝꠞꠦ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠡꠞꠝ ꠖꠤꠔꠣ ꠌꠣꠁꠟꠣ ꠘꠣ, ꠄꠞꠖꠣꠄ ꠝꠘꠦ ꠝꠘꠦ ꠑꠤꠇ ꠇꠞꠟꠣ, ꠟꠥꠇꠣꠁꠀ ꠁ ꠛꠤꠀ ꠜꠣꠋꠉꠤꠟꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MT1_20","070_1_20","MAT","1","20","20","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠅꠟꠣꠈꠣꠘ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠈꠥꠀꠛꠞ ꠝꠣꠎꠦ ꠔꠣꠘꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠁꠃꠍꠥꠚ ꠛꠤꠘ ꠖꠣꠃꠖ, ꠔꠥꠝꠤ ꠝꠞꠤꠅꠝꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠔꠦ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠔꠣꠘ ꠙꠦꠐꠅ ꠎꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠍꠦ, ꠁꠔꠣ ꠔ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦꠃ ꠅꠁꠍꠦ। ꠔꠣꠘ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀꠄ ꠎꠘꠝ ꠟꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT1_21","070_1_21","MAT","1","21","21","ꠔꠥꠝꠤ ꠁ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠤꠅ ꠁꠍꠣ। ꠇꠣꠞꠘ ꠁ ꠘꠣꠝꠞ ꠝꠣꠘꠤ ꠔꠞꠣꠘꠦꠀꠟꠣ, ꠄꠁꠘ ꠘꠤꠎꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠔꠞꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT1_22","070_1_22","MAT","1","22","22","ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠟꠣ ꠛꠣꠔꠣꠁꠍꠟꠣ, ꠅꠈꠣꠘ ꠚꠟꠤꠛꠣꠞ ꠟꠣꠉꠤꠃ ꠁꠔꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT1_23","070_1_23","MAT","1","23","23","ꠝꠣꠛꠥꠖꠦ ꠛꠣꠔꠣꠁꠍꠟꠣ, “ꠢꠥꠘꠅ, ꠄꠇꠎꠘ ꠀꠛꠤꠀꠔꠤ ꠡꠔꠤ ꠘꠣꠞꠤꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠛ, ꠔꠣꠁꠘ ꠄꠇ ꠙꠥꠀꠞ ꠎꠘꠝ ꠖꠤꠛꠣ, ꠁ ꠙꠥꠀꠞꠦ ꠒꠣꠇꠣ ꠅꠁꠛ ꠁꠝ꠆ꠝꠣꠘꠥꠄꠟ।” ꠁ ꠘꠣꠝꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT1_24","070_1_24","MAT","1","24","24","ꠛꠣꠖꠦ ꠊꠥꠝ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠁꠃꠍꠥꠚꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT1_25","070_1_25","MAT","1","25","25","ꠅꠁꠟꠦ ꠅꠃ ꠙꠥꠀꠞ ꠎꠘꠝꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠁꠘ ꠝꠞꠤꠅꠝꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠟꠣ ꠘꠣ। ꠡꠝꠄ ꠝꠔ ꠅꠃ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠅꠃ ꠙꠥꠀꠞ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠁꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("MT2_1","070_2_1","MAT","2","1","1","ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠀꠝꠟꠅ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃꠔ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ। ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠙꠥꠛꠞ ꠖꠦꠡꠞ ꠇꠄꠎꠘ ꠉꠘꠇ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT2_2","070_2_2","MAT","2","2","2","“ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤꠞ ꠎꠦ ꠛꠣꠖꠡꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠦ, ꠄꠁꠘ ꠇꠥꠀꠁ? ꠀꠝꠞꠣ ꠀꠍꠝꠣꠘꠞ ꠙꠥꠛꠦꠖꠤ ꠔꠣꠘ ꠎꠘꠝꠞ ꠔꠦꠞꠣ ꠖꠦꠈꠍꠤ, ꠖꠦꠈꠤꠀ ꠔꠣꠘꠞꠦ ꠜꠇ꠆ꠔꠤ ꠖꠦꠅꠀꠔ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT2_3","070_2_3","MAT","2","3","3","ꠘꠄꠀ ꠛꠣꠖꠡꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖ ꠀꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠈꠥꠛ ꠌꠤꠘ꠆ꠔꠣꠔ ꠙꠠꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT2_4","070_2_4","MAT","2","4","4","ꠄꠞꠟꠣꠉꠤ ꠢꠦꠞꠥꠖꠦ ꠖꠦꠡꠞ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠤ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠎꠣꠘꠂꠘ ꠘꠤ, ꠀꠟ-ꠝꠍꠤ ꠇꠥꠀꠁ ꠎꠘꠝ ꠟꠁꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("MT2_5","070_2_5","MAT","2","5","5","ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠔꠣꠘ ꠎꠘꠝ ꠅꠁꠛ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃꠔ। ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠄꠇ ꠘꠛꠤꠞ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("MT2_6","070_2_6","MAT","2","6","6","ꠅ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠛꠦꠕꠦꠟꠢꠣꠝ, ꠄꠢꠥꠖꠤꠀꠞ ꠘꠣꠝꠤ-ꠖꠣꠝꠤ ꠎꠣꠉꠣꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠢꠥꠞꠥ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠃ ꠔ ꠅꠟꠣ ꠄꠇꠎꠘ ꠛꠣꠖꠡꠣ ꠙꠄꠖꠣ ꠅꠁꠛꠣ, ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞꠦ ꠌꠣꠟꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT2_7","070_2_7","MAT","2","7","7","ꠔꠦꠃ ꠢꠦꠞꠥꠖꠦ ꠢꠃ ꠉꠘꠇ ꠅꠇꠟꠞꠦ ꠘꠤꠞꠣꠟꠣꠄ ꠘꠤꠀ ꠎꠤꠇꠣꠁꠀ ꠎꠣꠘꠟꠣ, ꠑꠤꠇ ꠇꠥꠘ ꠡꠝꠄ ꠢꠃ ꠎꠘꠝꠞ ꠔꠦꠞꠣ ꠖꠦꠈꠣ ꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT2_8","070_2_8","MAT","2","8","8","ꠔꠣꠁꠘ ꠅꠃ ꠉꠘꠇ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠎꠣꠃꠇ꠆ꠇꠣ, ꠉꠤꠀ ꠜꠣꠟꠣ ꠇꠞꠤ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠔꠣꠘ ꠇꠥꠘꠥ ꠈꠛꠞ ꠙꠣꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠣꠁꠛꠣ, ꠔꠦꠃ ꠀꠝꠤꠅ ꠉꠤꠀ ꠔꠣꠘꠞꠦ ꠜꠇ꠆ꠔꠤ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT2_9","070_2_9","MAT","2","9","9","ꠞꠣꠎꠣꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠉꠘꠇ ꠅꠇꠟ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠙꠥꠛꠞ ꠀꠍꠝꠣꠘꠅ ꠎꠦ ꠎꠘꠝ ꠔꠦꠞꠣ ꠖꠦꠈꠍꠤꠟꠣ, ꠅꠃ ꠔꠦꠞꠣ ꠔꠣꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠉꠦꠟ। ꠀꠞ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠎꠦ ꠎꠣꠉꠣꠔ ꠀꠍꠟꠣ, ꠑꠤꠇ ꠅꠃ ꠎꠣꠉꠣꠔ ꠀꠁꠀ ꠔꠦꠞꠣ ꠕꠣꠝꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT2_10","070_2_10","MAT","2","10","10","ꠔꠦꠞꠣ ꠕꠣꠝꠤꠉꠦꠍꠦ ꠖꠦꠈꠤꠀ ꠉꠘꠇ ꠅꠇꠟꠞ ꠜꠤꠔꠞꠦ ꠈꠥꠡꠤꠞ ꠓꠦꠃ ꠃꠑꠟ, ꠈꠥꠡꠤꠞ ꠝꠣꠁꠞꠦ ꠔꠣꠞꠣ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT2_11","070_2_11","MAT","2","11","11","ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠔꠣꠘ ꠝꠣ ꠝꠞꠤꠅꠝꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠖꠦꠈꠟꠣ। ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠝꠣꠐꠤꠔ ꠙꠠꠤ ꠔꠣꠘꠞꠦ ꠜꠇ꠆ꠔꠤ ꠖꠤꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠦꠉ ꠈꠥꠟꠤꠀ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠃꠙꠢꠣꠞ ꠖꠤꠟꠣ। ꠅꠃ ꠃꠙꠢꠣꠞ ꠅꠁꠟ ꠡꠥꠘꠣ, ꠟꠥꠛꠣꠘ-ꠀꠉꠞ ꠀꠞ ꠝꠥꠞꠣ-ꠀꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("MT2_12","070_2_12","MAT","2","12","12","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠈꠥꠀꠛꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤ ꠖꠤꠟꠣ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠉꠦꠍꠦ ꠀꠞ ꠚꠤꠞꠤꠀ ꠘꠣ ꠎꠣꠁꠘ। ꠔꠦꠃ ꠔꠣꠞꠣ ꠖꠥꠍꠞꠣ ꠙꠕꠦ ꠘꠤꠎꠞ ꠖꠦꠡꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT2_13","070_2_13","MAT","2","13","13","ꠉꠘꠇ ꠅꠇꠟ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠈꠥꠀꠛꠞ ꠝꠣꠎꠦ ꠁꠃꠍꠥꠚꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠁꠃꠍꠥꠚ ꠃꠑꠅ, ꠙꠥꠀ ꠀꠞ ꠔꠣꠘ ꠝꠣʼꠞꠦ ꠟꠁꠀ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠜꠣꠉꠤꠀ ꠎꠣꠅꠉꠤ, ꠛꠣꠖꠦ ꠀꠝꠤ ꠎꠔꠖꠤꠘ ꠘꠣ ꠇꠁ, ꠅꠔꠖꠤꠘ ꠢꠘꠅꠃ ꠞꠁꠅ। ꠁ ꠙꠥꠀꠞꠦ ꠝꠣꠞꠤꠟꠤꠔ ꠇꠞꠤ ꠢꠦꠞꠥꠖꠦ ꠔꠥꠇꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT2_14","070_2_14","MAT","2","14","14","ꠔꠦꠃ ꠁꠃꠍꠥꠚ ꠃꠑꠤꠀ ꠅꠃ ꠞꠣꠁꠔꠃ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠝꠤꠡꠞꠅ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT2_15","070_2_15","MAT","2","15","15","ꠀꠞ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖ ꠝꠞꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠘꠅ ꠞꠁꠟꠣ। ꠁꠔꠣ ꠊꠐꠤꠍꠤꠟ, ꠎꠣꠔꠦ ꠀꠉꠞ ꠄꠇ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠍꠟꠣ, ꠅꠔꠣ ꠙꠥꠞꠣ ꠅꠄ। ꠝꠣꠛꠥꠖꠦ ꠛꠣꠔꠣꠁꠍꠟꠣ, “ꠀꠝꠤ ꠀꠝꠣꠞ ꠙꠥꠔꠞꠦ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠒꠣꠇꠤꠀ ꠀꠘꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("MT2_16","070_2_16","MAT","2","16","16","ꠉꠘꠇ ꠅꠇꠟꠦ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞꠦ ꠐꠉꠤꠍꠂꠘ ꠇꠞꠤꠀ ꠔꠣꠁꠘ ꠈꠥꠛ ꠉꠥꠍꠣ ꠇꠞꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠉꠘꠇ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠎꠦ ꠡꠝꠄꠅꠞ ꠇꠕꠣ ꠢꠥꠘꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠚꠤꠇ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃ ꠀꠞ ꠄꠞ ꠀꠡ-ꠙꠣꠡ ꠄꠟꠣꠇꠣꠔ ꠖꠥꠁ ꠛꠍꠞ ꠛꠣ ꠔꠣꠞ ꠇꠝ ꠛꠄꠅꠡꠤ ꠎꠔ ꠙꠥꠀꠂꠘ ꠀꠍꠟꠣ, ꠁꠔꠣ ꠢꠇꠟꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT2_17","070_2_17","MAT","2","17","17","ꠄꠔꠦ ꠘꠛꠤ ꠁꠀꠞꠝꠤꠀꠞ ꠝꠣꠎꠖꠤ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠍꠟꠣ, ꠅꠔꠣ ꠚꠟꠤꠉꠦꠟ। ꠝꠣꠛꠥꠖꠦ ꠛꠣꠔꠣꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT2_18","070_2_18","MAT","2","18","18","ꠞꠣꠝꠣꠔ ꠈꠥꠛ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣ ꠎꠣꠞ, ꠞꠣꠢꠦꠟꠣꠄ ꠔꠣꠁꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠦꠞ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠡꠣꠘ꠆ꠔꠤ ꠅꠞ ꠘꠣ, ꠔꠣꠁꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠡꠦꠡ ꠅꠁꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT2_19","070_2_19","MAT","2","19","19","ꠛꠣꠖꠦ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖ ꠝꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠁꠀ, ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠁꠃꠍꠥꠚꠞꠦ ꠈꠥꠀꠛꠞ ꠝꠣꠎꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT2_20","070_2_20","MAT","2","20","20","“ꠅ ꠁꠃꠍꠥꠚ, ꠃꠑꠅ, ꠅꠃ ꠙꠥꠀ ꠀꠞ ꠔꠣꠘ ꠝꠣʼꠞꠦ ꠟꠁꠀ ꠁꠍꠞꠣꠁꠟ ꠖꠦꠡꠅ ꠎꠣꠅꠉꠤ। ꠙꠥꠀꠞꠦ ꠎꠦꠔꠣꠄ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠌꠣꠁꠍꠟꠣ, ꠁꠔꠣ ꠔ ꠝꠞꠤꠉꠦꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT2_21","070_2_21","MAT","2","21","21","ꠔꠦꠃ ꠁꠃꠍꠥꠚ ꠃꠑꠤꠀ ꠙꠥꠀ ꠀꠞ ꠙꠥꠀꠞ ꠝꠣʼꠞꠦ ꠟꠁꠀ ꠁꠍꠞꠣꠁꠟ ꠖꠦꠡꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT2_22","070_2_22","MAT","2","22","22","ꠀꠁꠀ ꠢꠥꠘꠟꠣ, ꠢꠃ ꠢꠦꠞꠥꠖꠞ ꠙꠥꠀ ꠀꠞ꠆ꠈꠤꠟꠣꠃꠍ ꠅꠈꠘ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠞꠣꠎꠣ ꠅꠁꠉꠦꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠢꠤꠘꠅ ꠎꠣꠁꠔꠦ ꠒꠞꠣꠁꠟꠣ। ꠛꠣꠖꠦ ꠈꠥꠀꠛꠦ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT2_23","070_2_23","MAT","2","23","23","ꠉꠣꠟꠤꠟꠅ ꠉꠤꠀ ꠘꠣꠍꠣꠞꠔ ꠘꠣꠝꠞ ꠄꠇ ꠉꠣꠃꠔ ꠛꠡꠔ ꠇꠞꠟꠣ। ꠁꠔꠣ ꠊꠐꠤꠟ, ꠎꠣꠔꠦ ꠀꠉꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠅꠔꠣ ꠅꠈꠘ ꠙꠥꠞꠣ ꠅꠄ। ꠎꠣꠘꠣꠁꠟ ꠅꠁꠍꠤꠟ, “ꠔꠣꠘꠞꠦ ꠘꠣꠍꠣꠞꠔꠤ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT3_1","070_3_1","MAT","3","1","1","ꠅꠃ ꠡꠝꠄ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠁꠀ ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT3_2","070_3_2","MAT","3","2","2","“ꠔꠃꠛꠣ ꠇꠞꠅ, ꠖꠥꠘꠤꠀꠞ ꠝꠣꠎꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠌꠣꠟꠥ ꠅꠁꠔꠦ ꠀꠞ ꠛꠦꠡꠤ ꠖꠦꠞꠤ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT3_3","070_3_3","MAT","3","3","3","ꠅꠃ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠛꠦꠙꠣꠞꠦꠃ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠀꠉꠦ ꠛꠣꠔꠣꠁꠍꠟꠣ, ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠄꠟꠣꠘ ꠇꠞꠞꠣ, ‘ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇꠞ ꠙꠕ ꠍꠢꠤ ꠇꠞꠅ, ꠔꠣꠘ ꠌꠟꠣꠞ ꠞꠣꠡ꠆ꠔꠣ ꠅꠇꠟ ꠡꠤꠗꠣ ꠇꠞꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT3_4","070_3_4","MAT","3","4","4","ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠔ ꠃꠐꠞ ꠞꠥꠝꠞ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠔꠣ ꠀꠞ ꠇꠝꠞꠅ ꠌꠣꠝꠠꠣꠞ ꠛꠦꠟꠐ ꠛꠣꠘ꠆ꠖꠤꠔꠣ। ꠔꠣꠁꠘ ꠙꠣꠠꠤꠀ ꠝꠃ ꠀꠞ ꠚꠞꠤꠋ ꠈꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MT3_5","070_3_5","MAT","3","5","5","ꠔꠣꠘ ꠔꠛꠟꠤꠉ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠡ꠆ꠔꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ ꠀꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠣꠇꠤ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT3_6","070_3_6","MAT","3","6","6","ꠀꠁꠀ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠘꠣ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠟꠣ, ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠅ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT3_7","070_3_7","MAT","3","7","7","ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠚꠞꠤꠡꠤ ꠀꠞ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠝꠎꠛꠞ ꠝꠣꠘꠥꠡꠅ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠞꠣ। ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅ ꠢꠣꠚꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ, ꠀꠍꠝꠣꠘꠤ ꠉꠎꠛ ꠀꠁꠅꠞ ꠖꠦꠈꠤꠀ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠙꠕ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠦꠉꠤꠄ ꠛꠣꠔꠣꠁ ꠖꠤꠟ? ");
INSERT INTO syls_vpl VALUES ("MT3_8","070_3_8","MAT","3","8","8","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠢꠣꠍꠣꠞꠞ ꠔꠃꠛꠣ ꠇꠞꠤꠀ ꠕꠣꠇ, ꠔꠦ ꠄꠞ ꠚꠟꠅ ꠖꠦꠈꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("MT3_9","070_3_9","MAT","3","9","9","ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠅ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠅꠟꠣꠖ। ꠢꠥꠘꠅ, ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠁꠟꠦ ꠔ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟ ꠕꠣꠇꠤꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠅꠟꠣꠖ ꠛꠣꠘꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT3_10","070_3_10","MAT","3","10","10","ꠉꠣꠍꠞ ꠉꠥꠠꠤꠔ ꠔ ꠇꠥꠠꠣꠟ ꠟꠣꠉꠣꠁꠟꠃ ꠀꠍꠦ। ꠎꠦ ꠉꠣꠍꠅ ꠜꠣꠟꠣ ꠚꠟ ꠗꠞꠦ ꠘꠣ, ꠁ ꠉꠣꠍ ꠇꠣꠐꠤꠀ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT3_11","070_3_11","MAT","3","11","11","“ꠔꠃꠛꠣ ꠇꠞꠍ ꠉꠔꠤꠇꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠘꠤꠖꠤ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠟꠣꠝ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠣꠖꠦ ꠀꠞꠅ ꠄꠇꠎꠘ ꠀꠁꠞꠣ, ꠄꠁꠘ ꠀꠝꠣ ꠕꠘꠦꠅ ꠢꠤꠝ꠆ꠝꠔ ꠀꠟꠣ, ꠔꠣꠘ ꠙꠣꠅꠞ ꠎꠥꠔꠣ ꠛꠅꠀꠞ ꠟꠣꠈꠅ ꠀꠝꠤ ꠘꠣꠄ। ꠔꠣꠁꠘ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠞ ꠀꠉꠥꠁꠘꠖꠤ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT3_12","070_3_12","MAT","3","12","12","ꠔꠣꠘ ꠇꠥꠟꠣ ꠔ ꠔꠣꠘ ꠀꠔꠅꠃ ꠀꠍꠦ, ꠁꠈꠣꠘ ꠖꠤꠀ ꠔꠣꠁꠘ ꠗꠣꠘ ꠃꠀꠁꠀ ꠃꠉꠣꠞꠅ ꠔꠥꠟꠛꠣ, ꠀꠞ ꠍꠥꠍꠣꠞꠦ ꠅꠃ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠟꠣꠁꠛꠣ, ꠎꠦ ꠀꠉꠥꠁꠘ ꠇꠥꠘꠥ ꠡꠝꠄ ꠘꠤꠜꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT3_13","070_3_13","MAT","3","13","13","ꠅꠃ ꠡꠝꠄ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣ ꠕꠣꠇꠤ ꠢꠎꠞꠔ ꠁꠍꠣꠅ ꠙꠣꠇ ꠉꠥꠍꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠅ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT3_14","070_3_14","MAT","3","14","14","ꠅꠁꠟꠦ ꠄꠢꠤꠀꠄ ꠔꠣꠘꠞꠦ ꠅꠈꠣꠘ ꠇꠁꠀ ꠘꠣ ꠇꠞꠟꠣ, “ꠀꠙꠘꠦ ꠀꠁꠍꠂꠘ ꠘꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ, ꠀꠝꠣꠞꠃ ꠎꠞꠥꠞ ꠀꠍꠤꠟ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠉꠥꠍꠟ ꠇꠞꠣ!” ");
INSERT INTO syls_vpl VALUES ("MT3_15","070_3_15","MAT","3","15","15","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠅꠈꠘ ꠅꠟꠣꠃ ꠅꠃꠇ, ꠇꠣꠞꠘ ꠀꠝꠞꠣꠞ ꠃꠌꠤꠔ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠙꠥꠞꠘ ꠇꠞꠣ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠄꠢꠤꠀ ꠞꠣꠎꠤ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT3_16","070_3_16","MAT","3","16","16","ꠙꠣꠇ ꠉꠥꠍꠟ ꠇꠞꠤꠀ ꠙꠣꠘꠤ ꠕꠣꠇꠤ ꠃꠑꠔꠦꠃ ꠁꠍꠣꠄ ꠖꠦꠈꠟꠣ, ꠀꠍꠝꠣꠘ ꠖꠥꠁ ꠜꠣꠉ ꠅꠁꠉꠦꠍꠦ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥ ꠙꠣꠞꠅꠞ ꠍꠥꠞꠔ ꠗꠞꠤꠀ ꠔꠣꠘ ꠃꠙꠞꠦ ꠟꠣꠝꠤꠀ ꠀꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT3_17","070_3_17","MAT","3","17","17","ꠅꠃ ꠡꠝꠄ ꠀꠍꠝꠣꠘ ꠕꠘꠦ ꠉꠣꠁꠛꠤ ꠀꠅꠀꠎ ꠅꠁꠟ, “ꠄꠁꠘꠃ ꠀꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠄꠘ ꠃꠙꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT4_1","070_4_1","MAT","4","1","1","ꠙꠣꠇ ꠉꠥꠍꠟ ꠇꠞꠣꠞ ꠛꠣꠖꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠁꠡꠣꠞꠣꠄ ꠁꠍꠣꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠘꠦꠅꠀ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠅꠃ ꠡꠝꠄ ꠁꠛꠟꠤꠍꠦ ꠔꠣꠘꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT4_2","070_4_2","MAT","4","2","2","ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠔꠣꠁꠘ ꠄꠇꠟꠣꠉꠣꠞꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠞꠣꠁꠔ ꠞꠥꠎꠣ ꠀꠍꠟꠣ। ꠄꠞꠛꠣꠖꠦ ꠔꠣꠘ ꠈꠥꠛ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("MT4_3","070_4_3","MAT","4","3","3","ꠅꠃ ꠡꠝꠄ ꠁꠛꠟꠤꠍꠦ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠅꠅ, ꠔꠦ ꠅꠔꠣ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠇꠅ ꠘꠣ ꠞꠥꠐꠤ ꠅꠁꠎꠤꠔ।” ");
INSERT INTO syls_vpl VALUES ("MT4_4","070_4_4","MAT","4","4","4","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠈꠣꠟꠤ ꠞꠥꠐꠤ ꠈꠣꠁꠟꠦꠃ ꠝꠣꠘꠥꠡ ꠛꠣꠌꠦ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠙꠞꠔꠦꠇ ꠇꠣꠟꠣꠝꠦꠃ ꠝꠣꠘꠥꠡ ꠛꠣꠌꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT4_5","070_4_5","MAT","4","5","5","ꠔꠦꠃ ꠢꠦ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠙꠛꠤꠔ꠆ꠞ ꠐꠣꠃꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠦꠟ, ꠉꠤꠀ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠇꠣꠛꠣ ꠊꠞꠞ ꠝꠤꠘꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠘꠦ ꠃꠛꠣ ꠇꠞꠣꠁꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT4_6","070_4_6","MAT","4","6","6","“ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠅꠅ, ꠔꠦ ꠖꠦꠈꠤ ꠌꠣꠁꠘ, ꠅꠘ ꠕꠣꠇꠤ ꠚꠣꠟ ꠖꠤꠀ ꠟꠣꠝꠣꠔ ꠙꠠꠅ, ꠇꠤꠔꠣꠛꠅ ꠔ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ; ꠀꠞ ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠀꠔꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠗꠞꠤꠟꠤꠛꠣ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞ ꠙꠣꠅ-ꠅ ꠇꠥꠘꠥ ꠙꠣꠔ꠆ꠔꠞꠞ ꠌꠥꠐ ꠘꠣ ꠟꠣꠉꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT4_7","070_4_7","MAT","4","7","7","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠇꠤꠔꠣꠛꠅ ꠅꠃ ꠇꠕꠣꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT4_8","070_4_8","MAT","4","8","8","ꠛꠣꠖꠦ ꠁꠛꠟꠤꠍꠦ ꠔꠣꠘꠞꠦ ꠈꠥꠛ ꠃꠌꠣ ꠄꠇ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠟꠁꠀ ꠉꠦꠟ, ꠘꠤꠀ ꠄꠇ ꠙꠟꠇꠦ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠝꠥꠟ꠆ꠟꠥꠇ ꠀꠞ ꠅꠔꠣꠞ ꠢꠇꠟ ꠎꠣꠇ-ꠎꠝꠇ ꠖꠦꠈꠣꠁꠟ ꠀꠞ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT4_9","070_4_9","MAT","4","9","9","“ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠟꠣꠅ, ꠔꠦ ꠁ ꠢꠇ꠆ꠇꠟꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT4_10","070_4_10","MAT","4","10","10","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠗꠥꠞ ꠡꠄꠔꠣꠘ, ꠜꠣꠉ! ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦꠃ ꠒꠞꠣꠁꠅ, ꠈꠣꠟꠤ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT4_11","070_4_11","MAT","4","11","11","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠛꠟꠤꠍ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠦꠟꠉꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠀꠁꠀ ꠔꠣꠘ ꠈꠦꠎꠝꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT4_12","070_4_12","MAT","4","12","12","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠈꠛꠞ ꠙꠣꠁꠟꠣ, ꠄꠢꠤꠀ ꠘꠛꠤꠞꠦ ꠀꠐꠇ ꠇꠞꠤꠀ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠟ ꠅꠁꠍꠦ, ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠘ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT4_13","070_4_13","MAT","4","13","13","ꠢꠘꠅ ꠉꠤꠀ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃ ꠍꠣꠠꠤꠀ ꠍꠛꠥꠟꠘ-ꠘꠙ꠆ꠔꠣꠟꠤ ꠄꠟꠣꠇꠣꠞ ꠀꠅꠞꠞ ꠙꠣꠞꠞ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT4_14","070_4_14","MAT","4","14","14","ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠍꠟꠣ, ꠅꠔꠣ ꠅꠈꠘ ꠚꠟꠤꠎꠣꠄ। ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT4_15","070_4_15","MAT","4","15","15","ꠛꠤꠗꠞ꠆ꠝꠤ ꠝꠣꠘꠡꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠀꠅꠞꠞ ꠙꠣꠞꠞ ꠍꠛꠥꠟꠘ-ꠘꠙ꠆ꠔꠣꠟꠤ ꠄꠟꠣꠇꠣꠞ ꠝꠣꠘꠥꠡ, ꠀꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠖꠥꠍꠞꠣ ꠙꠣꠞꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞ ꠎꠣꠁꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT4_16","070_4_16","MAT","4","16","16","ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠛꠦ-ꠙꠕꠤ ꠛꠘꠤꠀ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠞꠣ, ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠞ ꠝꠢꠣ ꠞꠥꠡꠘꠤ ꠖꠦꠈꠛꠣ। ꠀꠞ ꠎꠦꠞꠣ ꠉꠁꠘ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞ ꠎꠣꠁꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT4_17","070_4_17","MAT","4","17","17","ꠅꠃ ꠡꠝꠄ ꠕꠣꠇꠤ ꠁꠍꠣꠄ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ꠇꠁꠟꠣ, “ꠔꠃꠛꠣ ꠇꠞꠅ, ꠇꠣꠞꠘ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠎꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠌꠣꠟꠥ ꠅꠁꠔꠦ ꠀꠞ ꠛꠦꠡꠤ ꠖꠦꠞꠤ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT4_18","070_4_18","MAT","4","18","18","ꠢꠎꠞꠔ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠙꠣꠞꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠖꠦꠈꠟꠣ, ꠍꠣꠁꠝꠘ ꠃꠞꠚꠦ ꠙꠤꠔꠞ ꠀꠞ ꠄꠘ ꠜꠣꠁ ꠀꠘ꠆ꠖꠞꠤꠀꠍꠦ ꠀꠅꠞꠅ ꠎꠣꠟ ꠛꠣꠁꠞꠣ, ꠄꠞꠣ ꠔ ꠎꠣꠟꠥꠀ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT4_19","070_4_19","MAT","4","19","19","ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠘꠥꠡ ꠗꠞꠣꠞ ꠎꠣꠟꠥꠀ ꠛꠣꠘꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT4_20","070_4_20","MAT","4","20","20","ꠟꠉꠦ ꠟꠉꠦ ꠄꠞꠣ ꠎꠣꠟ ꠚꠣꠟꠣꠁꠀ ꠁꠍꠣꠞ ꠟꠉꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT4_21","070_4_21","MAT","4","21","21","ꠅꠘ ꠕꠘꠦ ꠕꠥꠠꠣ ꠀꠉꠦ ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ ꠔꠣꠞꠣ ꠖꠥꠁꠅ ꠜꠣꠁꠄ ꠛꠣꠚꠞ ꠟꠉꠦ ꠘꠣꠅꠅ ꠛꠁꠀ ꠎꠣꠟ ꠎꠥꠁꠔ-ꠎꠣꠁꠔ ꠇꠞꠞꠣ। ꠄꠞꠣꠞ ꠛꠣꠚꠞ ꠘꠣꠝ ꠎꠤꠛꠥꠖꠤꠀ। ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠒꠣꠇ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT4_22","070_4_22","MAT","4","22","22","ꠒꠣꠇ ꠢꠥꠘꠤꠀ ꠄꠞꠣꠅ ꠔꠣꠞꠣꠞ ꠛꠣꠚꠞꠦ ꠘꠣꠅꠅ ꠕꠁꠀ ꠁꠍꠣꠞ ꠟꠉꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT4_23","070_4_23","MAT","4","23","23","ꠛꠣꠖꠦ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠊꠥꠞꠤ ꠊꠥꠞꠤ, ꠢꠘꠞ ꠘꠣꠘꠣꠘ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠘꠍꠤꠅꠔ ꠇꠞꠟꠣ, ꠀꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ꠄꠞꠟꠉꠦ ꠛꠃꠔ ꠘꠝꠥꠘꠣꠞ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT4_24","070_4_24","MAT","4","24","24","ꠀꠡ꠆ꠔꠣ ꠡꠤꠞꠤꠀ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠈꠛꠞ ꠞꠐꠤꠉꠦꠟ। ꠄꠔꠦ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠀꠞ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠄ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠇꠡ꠆ꠐ ꠙꠣꠁꠍꠤꠟ, ꠎꠦꠞꠣꠞꠦ ꠎꠤꠘ-ꠜꠥꠔꠦ ꠗꠞꠍꠤꠟ, ꠝꠤꠞꠉꠤ ꠀꠞ ꠅꠞ꠆ꠖꠋ ꠛꠦꠝꠣꠞꠤ ꠎꠔ ꠝꠣꠘꠥꠡ ꠀꠍꠤꠟ, ꠝꠣꠘꠡꠦ ꠅꠔꠣꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT4_25","070_4_25","MAT","4","25","25","ꠉꠣꠟꠤꠟ, ꠖꠤꠇꠣꠙꠟꠤ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝ, ꠄꠢꠥꠖꠤꠀ ꠀꠞ ꠎꠞ꠆ꠖꠣꠘꠞ ꠅꠁꠘ꠆ꠘ ꠙꠣꠞ ꠕꠣꠇꠤ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_1","070_5_1","MAT","5","1","1","ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠍꠂꠘ ꠖꠦꠈꠤꠀ ꠁꠍꠣ ꠉꠤꠀ ꠄꠇ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠟꠣ। ꠃꠑꠤꠀ ꠛꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_2","070_5_2","MAT","5","2","2","ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠅꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ, ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT5_3","070_5_3","MAT","5","3","3","“ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠅꠃ ꠝꠣꠘꠥꠡꠃ ꠎꠣꠞꠣ ꠖꠤꠟ ꠕꠣꠇꠤ ꠘꠤꠎꠞꠦ ꠉꠞꠤꠛ ꠝꠘꠅ ꠇꠞꠦ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠔ ꠔꠣꠞꠣꠃ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_4","070_5_4","MAT","5","4","4","ꠔꠣꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠎꠣꠞꠣꠞ ꠝꠘꠅ ꠅꠈꠘ ꠖꠥꠈ ꠀꠍꠦ, ꠔꠣꠞꠣꠃ ꠔ ꠡꠥꠈ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_5","070_5_5","MAT","5","5","5","ꠔꠣꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠎꠣꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠘꠞꠝ, ꠁ ꠖꠥꠘꠤꠀ ꠔ ꠔꠣꠞꠣꠞꠃ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT5_6","070_5_6","MAT","5","6","6","ꠔꠣꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠎꠣꠞꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠦ, ꠔꠣꠞꠣꠞ ꠅꠃ ꠀꠡꠣ ꠙꠥꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT5_7","070_5_7","MAT","5","7","7","ꠔꠣꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠎꠣꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠖꠄꠀ ꠇꠞꠦ, ꠔꠣꠞꠣꠃ ꠔ ꠖꠄꠀ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_8","070_5_8","MAT","5","8","8","ꠔꠣꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠎꠣꠞꠣꠞ ꠖꠤꠟ ꠈꠣꠐꠤ, ꠇꠣꠞꠘ ꠔꠣꠞꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_9","070_5_9","MAT","5","9","9","ꠔꠣꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠎꠣꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠡꠣꠘ꠆ꠔꠤꠄ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠝꠦꠘꠔ ꠇꠞꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠘ ꠀꠙꠘ ꠀꠅꠟꠣꠖ ꠇꠁꠀ ꠒꠣꠇꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_10","070_5_10","MAT","5","10","10","ꠔꠣꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠎꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠌꠟꠣꠔ ꠉꠤꠀ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠦ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠔ ꠔꠣꠞꠣꠃ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_11","070_5_11","MAT","5","11","11","“ꠀꠞ ꠔꠥꠝꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠎꠣꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠦ ꠀꠞ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠝꠤꠍꠣ ꠛꠖꠘꠣꠝ ꠉꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT5_12","070_5_12","MAT","5","12","12","ꠁꠟꠣ ꠅꠁꠟꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠎꠦ ꠘꠛꠤ ꠅꠇꠟ ꠀꠁꠍꠟꠣ, ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠅꠃ ꠘꠛꠤꠞ ꠃꠙꠞꠦꠅ ꠅꠟꠣ ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠀꠞ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠤꠅ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠅ ꠅꠃ ꠘꠛꠤ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠛꠃꠔ ꠛꠠ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT5_13","070_5_13","MAT","5","13","13","“ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠖꠥꠘꠤꠀꠞ ꠘꠥꠘ, ꠅꠁꠟꠦ ꠘꠥꠘꠞ ꠉꠥꠘ ꠎꠥꠖꠤ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠀꠞ ꠘꠥꠘꠔꠣ ꠇꠞꠣ ꠎꠣꠄ ꠘꠤ? ꠁ ꠘꠥꠘ ꠔ ꠀꠞ ꠇꠥꠘꠥ ꠇꠣꠝꠅ ꠟꠣꠉꠦ ꠘꠣ। ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠛꠣꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠦꠁꠘ ꠀꠞ ꠁꠔꠣꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT5_14","070_5_14","MAT","5","14","14","“ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠖꠥꠘꠤꠀꠞ ꠛꠣꠔ꠆ꠔꠤ। ꠙꠣꠠꠞ ꠃꠙꠞꠞ ꠇꠥꠘꠥ ꠐꠣꠃꠘ ꠔ ꠟꠥꠇꠣꠁꠟ ꠞꠣꠈꠣ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_15","070_5_15","MAT","5","15","15","ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠟꠦꠝ ꠎꠣꠟꠣꠁꠀ ꠐꠥꠇꠞꠤꠞ ꠔꠟꠦ ꠕꠄ ꠘꠣ, ꠁꠇꠐꠣ ꠟꠦꠝ-ꠖꠣꠘꠤꠞ ꠃꠙꠞꠦꠃ ꠕꠄ, ꠎꠣꠔꠦ ꠊꠞꠞ ꠢꠇꠟꠦ ꠚꠞ ꠖꠦꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT5_16","070_5_16","MAT","5","16","16","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠚꠞꠅ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠎꠟꠃꠇ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣ ꠇꠣꠝ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT5_17","070_5_17","MAT","5","17","17","“ꠔꠥꠝꠞꠣ ꠁꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠝꠤ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠍꠢꠤꠚꠣ ꠛꠣꠔꠤꠟ ꠇꠞꠣꠔ ꠀꠁꠍꠤ। ꠀꠝꠤ ꠔ ꠁꠔꠣ ꠛꠣꠔꠤꠟ ꠇꠞꠣꠔ ꠘꠣꠄ, ꠛꠞꠋ ꠙꠥꠞꠣ ꠇꠞꠣꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("MT5_18","070_5_18","MAT","5","18","18","ꠀꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠞ ꠢꠇꠟ ꠇꠕꠣ ꠎꠔꠖꠤꠘ ꠘꠣ ꠚꠟꠤꠍꠦ, ꠅꠔ ꠖꠤꠘ ꠁ ꠇꠤꠔꠣꠛꠞ ꠄꠇꠐꠣ ꠢꠞꠚ ꠛꠣ ꠎꠦꠞ-ꠎꠛꠞꠅ ꠛꠣꠔꠤꠟ ꠅꠁꠔ ꠘꠣꠄ। ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠇ꠆ꠇꠄ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠁꠈꠣꠘ ꠛꠣꠔꠤꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT5_19","070_5_19","MAT","5","19","19","ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠞ ꠇꠥꠘꠥ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠢꠥꠇꠥꠝꠅ ꠎꠥꠖꠤ ꠇꠦꠃ ꠘꠣ ꠝꠣꠘꠦ, ꠛꠣ ꠁ ꠢꠥꠇꠥꠝ ꠘꠣ ꠝꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠦꠄ, ꠔꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠔꠣꠞꠦꠅ ꠢꠇꠟ ꠕꠣꠇꠤ ꠢꠥꠞꠥ ꠇꠅꠀ ꠅꠁꠛ। ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠁ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠦ ꠀꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠢꠤꠇꠣꠄ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠔꠣꠞꠦ ꠛꠃꠔ ꠖꠣꠝ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT5_20","070_5_20","MAT","5","20","20","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠟꠤꠝ-ꠃꠟꠣꠝꠣ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞ ꠀꠝꠟ ꠕꠣꠇꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠀꠝꠟ ꠎꠥꠖꠤ ꠀꠞꠅ ꠜꠣꠟꠣ ꠘꠣ ꠅꠄ, ꠔꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT5_21","070_5_21","MAT","5","21","21","“ꠔꠥꠝꠞꠣ ꠢꠥꠘꠍ, ꠀꠉꠞ ꠀꠝꠟꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠇꠅꠀ ꠅꠁꠍꠦ, ‘ꠈꠥꠘ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠦꠉꠤꠄ ꠈꠥꠘ ꠇꠞꠛ, ꠢꠦ ꠁ ꠈꠥꠘꠞ ꠖꠣꠠꠅ ꠙꠠꠛ।’ ");
INSERT INTO syls_vpl VALUES ("MT5_22","070_5_22","MAT","5","22","22","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞꠞ ꠟꠉꠦ ꠞꠣꠉ-ꠉꠥꠍꠣ ꠇꠞꠦ, ꠢꠦ ꠛꠤꠌꠣꠞꠞ ꠖꠣꠠꠅ ꠙꠠꠛ। ꠢꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠜꠣꠁꠞꠦ ꠇꠄ, ‘ꠔꠥꠝꠤ ꠔ ꠛꠦꠀꠈꠟ’ ꠔꠦ ꠀꠞꠅ ꠛꠠ ꠛꠤꠌꠣꠞꠞ ꠖꠣꠠꠅ ꠙꠠꠛ। ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠔꠣꠞ ꠜꠣꠁꠞꠦ ꠇꠄ, ‘ꠔꠥꠝꠤ ꠛꠦꠅꠇꠥꠚ,’ ꠢꠦ ꠖꠥꠎꠈꠞ ꠀꠉꠥꠁꠘꠅ ꠎꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("MT5_23","070_5_23","MAT","5","23","23","“ꠄꠞꠖꠣꠄ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠉꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠖꠤꠛꠣꠞ ꠡꠝꠄ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠝꠘꠅ ꠅꠁꠎꠣꠄ, ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠜꠣꠁꠞ ꠛꠤꠛꠣꠖ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("MT5_24","070_5_24","MAT","5","24","24","ꠔꠦ ꠔꠥꠝꠣꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠅꠃ ꠎꠣꠉꠣꠔ ꠕꠁꠀ, ꠀꠉꠦ ꠉꠤꠀ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞ ꠟꠉꠦ ꠝꠤꠐ-ꠝꠣꠐ ꠇꠞꠅ, ꠛꠣꠖꠦ ꠉꠤꠀ ꠔꠥꠝꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("MT5_25","070_5_25","MAT","5","25","25","“ꠇꠦꠃ ꠔꠥꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠥꠘꠥ ꠝꠣꠝꠟꠣ ꠇꠞꠟꠦ ꠀꠖꠣꠟꠔꠅ ꠎꠣꠅꠀꠞ ꠀꠉꠦꠃ ꠔꠣꠞ ꠟꠉꠦ ꠎꠟꠖꠤ ꠝꠤꠐ-ꠝꠣꠐ ꠇꠞꠤꠟꠤꠅ। ꠁꠟꠣ ꠘꠣ ꠇꠞꠟꠦ, ꠢꠦ ꠔꠥꠝꠣꠞꠦ ꠢꠣꠇꠤꠝꠞ ꠀꠔꠅ ꠖꠤꠛ, ꠢꠣꠇꠤꠝꠦ ꠔꠥꠝꠣꠞꠦ ꠙꠥꠟꠤꠡꠞ ꠢꠣꠅꠟꠣ ꠇꠞꠛꠣ, ꠀꠞ ꠙꠥꠟꠤꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_26","070_5_26","MAT","5","26","26","ꠢꠦꠡꠦ ꠔꠣꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠙꠣꠅꠘꠣ ꠀꠖꠣꠄ ꠘꠣ ꠇꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠔꠥꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠍꠣꠠꠣ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠍꠟ ꠇꠕꠣ ꠇꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("MT5_27","070_5_27","MAT","5","27","27","“ꠔꠥꠝꠞꠣ ꠢꠥꠘꠍ, ꠀꠉꠦ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ‘ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT5_28","070_5_28","MAT","5","28","28","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠇꠥꠘꠥ ꠛꠦꠐꠣꠄ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞ ꠛꠣꠄ ꠇꠥ-ꠘꠎꠞꠦ ꠌꠣꠄ, ꠔꠦ ꠢꠦ ꠅꠃ ꠡꠝꠄ ꠝꠘꠦ ꠝꠘꠦ ꠔꠣꠁꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT5_29","070_5_29","MAT","5","29","29","“ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠌꠃꠈꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠦ, ꠔꠦ ꠁ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠅ। ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟ ꠟꠁꠀ ꠖꠥꠎꠈꠅ ꠎꠣꠅꠀ ꠕꠣꠇꠤ, ꠄꠇꠐꠣ ꠅꠋꠉ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠅꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_30","070_5_30","MAT","5","30","30","ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠀꠔꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠦ, ꠁ ꠀꠔ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠅ। ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟ ꠟꠁꠀ ꠖꠥꠎꠈꠅ ꠎꠣꠅꠀ ꠕꠣꠇꠤ, ꠄꠇꠐꠣ ꠅꠋꠉ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠅꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_31","070_5_31","MAT","5","31","31","“ꠀꠞꠅ ꠇꠅꠀ ꠅꠁꠍꠦ, ‘ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠦꠄ, ꠢꠦ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠘꠣꠝꠣ ꠖꠦꠃꠇ।’ ");
INSERT INTO syls_vpl VALUES ("MT5_32","070_5_32","MAT","5","32","32","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠎꠤꠘꠣ ꠍꠣꠠꠣ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠘꠤꠎꠞ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠦꠄ, ꠢꠦ ꠔ ꠔꠣꠞ ꠛꠃꠞꠦ ꠎꠤꠘꠣꠇꠥꠞ ꠛꠣꠘꠣꠄ। ꠀꠞ ꠔꠣꠟꠣꠇ ꠙꠣꠅꠀ ꠛꠦꠐꠤꠞꠦ ꠎꠦꠉꠤꠄ ꠛꠤꠀ ꠇꠞꠦ, ꠢꠦ-ꠅ ꠎꠤꠘꠣꠇꠥꠞ ꠛꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("MT5_33","070_5_33","MAT","5","33","33","“ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ‘ꠝꠤꠍꠣ ꠇꠥꠘꠥ ꠇꠍꠝ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠎꠦꠇꠥꠘꠥ ꠇꠍꠝ ꠇꠞꠟꠦ ꠁꠐꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠀꠖꠣꠄ ꠇꠞꠤꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT5_34","070_5_34","MAT","5","34","34","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠇꠥꠘꠥꠎꠣꠔ ꠇꠍꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠤꠅ ꠘꠣ, ꠁꠈꠣꠘ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠀꠞꠡ। ");
INSERT INTO syls_vpl VALUES ("MT5_35","070_5_35","MAT","5","35","35","ꠖꠥꠘꠤꠀꠞ ꠘꠣꠝꠦ ꠇꠞꠤꠅ ꠘꠣ, ꠁꠈꠣꠘ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠇꠖꠝ ꠝꠥꠛꠣꠞꠇ ꠕꠅꠀꠞ ꠎꠣꠉꠣ। ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠘꠣꠝꠦꠅ ꠇꠍꠝ ꠇꠞꠤꠅ ꠘꠣ, ꠁꠈꠣꠘ ꠅꠁꠟ ꠝꠢꠣꠘ ꠛꠣꠖꠡꠣ ꠀꠟ꠆ꠟꠣꠞ ꠐꠣꠃꠘ। ");
INSERT INTO syls_vpl VALUES ("MT5_36","070_5_36","MAT","5","36","36","ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠕꠣꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠤꠅ ꠘꠣ, ꠁ ꠝꠣꠕꠣꠞ ꠄꠇꠍꠣ ꠌꠥꠟꠞꠦ ꠗꠟꠣ ꠛꠣ ꠇꠣꠟꠣ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠔ ꠔꠥꠝꠣꠞ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("MT5_37","070_5_37","MAT","5","37","37","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠔꠞ ꠅꠄ ꠈꠣꠘ ꠅꠄ, ꠀꠞ ꠘꠣ ꠈꠣꠘ ꠘꠣ ꠅꠃꠇ। ꠢꠥꠘꠅ, ꠁꠔꠣꠞ ꠛꠣꠞꠦ ꠀꠞ ꠎꠔꠔꠣꠃ ꠅꠄ, ꠁꠔꠣ ꠁꠛꠟꠤꠍ ꠕꠣꠇꠤ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT5_38","070_5_38","MAT","5","38","38","“ꠔꠥꠝꠞꠣ ꠔ ꠢꠥꠘꠍ, ꠀꠉꠦ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦ ꠙꠞꠤꠝꠣꠘꠦ ꠈꠦꠔꠤ ꠅꠁꠍꠦ, ꠅꠃ ꠙꠞꠤꠝꠣꠘꠦ ꠡꠣꠎꠣ ꠖꠤꠅ, ‘ꠌꠃꠈꠞ ꠛꠖꠟꠣ ꠌꠃꠈ ꠀꠞ ꠖꠣꠔꠞ ꠛꠖꠟꠣ ꠖꠣꠔ।’ ");
INSERT INTO syls_vpl VALUES ("MT5_39","070_5_39","MAT","5","39","39","ꠅꠁꠟꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠈꠣꠞꠣꠙ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠦ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠄꠞ ꠛꠖꠟꠣ ꠟꠁꠅ ꠘꠣ, ꠛꠞꠋ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠅ ꠌꠠ ꠝꠣꠞꠟꠦ, ꠔꠣꠞꠦ ꠛꠣꠃ ꠉꠣꠟꠅ ꠙꠣꠔꠤꠀ ꠖꠤꠟꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MT5_40","070_5_40","MAT","5","40","40","ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠣꠝꠟꠣ-ꠝꠇꠖ꠆ꠖꠝꠣ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞ ꠇꠥꠞ꠆ꠔꠣ ꠘꠤꠔꠉꠤ ꠌꠣꠄ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠌꠣꠖ꠆ꠖꠞꠅ ꠖꠤꠟꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MT5_41","070_5_41","MAT","5","41","41","ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠄ, ꠔꠣꠞ ꠉꠣꠁꠐ ꠛꠁꠀ ꠟꠁꠀ ꠄꠇ ꠝꠣꠁꠟ ꠎꠣꠁꠔꠣꠄ, ꠔꠦ ꠔꠥꠝꠤ ꠔꠣꠞ ꠟꠉꠦ ꠖꠥꠁ ꠝꠣꠁꠟ ꠎꠣꠁꠅꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT5_42","070_5_42","MAT","5","42","42","ꠇꠦꠃ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘ꠆ꠔꠣ ꠈꠥꠎꠤꠟꠦ ꠔꠣꠞꠦ ꠖꠤꠅ। ꠇꠦꠃ ꠀꠅꠟꠣꠔ ꠌꠣꠁꠟꠦ, ꠔꠣꠞꠦ ꠚꠤꠞꠣꠁ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT5_43","070_5_43","MAT","5","43","43","“ꠔꠥꠝꠞꠣ ꠎꠣꠘ, ꠀꠉꠦ ꠔ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠤꠟ, ‘ꠔꠥꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠤꠅ ꠀꠞ ꠖꠥꠡꠝꠘꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT5_44","070_5_44","MAT","5","44","44","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘꠞꠦꠅ ꠝꠣꠄꠀ ꠇꠞꠤꠅ। ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("MT5_45","070_5_45","MAT","5","45","45","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠛꠣ, ꠔꠥꠝꠞꠣ ꠢꠣꠍꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠣꠄꠀꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠤꠉꠦꠍ। ꠔꠣꠁꠘ ꠔ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠡꠥꠞꠥꠎ ꠃꠑꠣꠁꠘ, ꠖꠤꠘꠖꠣꠞ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠢꠇꠟꠞ ꠃꠙꠞꠦꠃ ꠝꠦꠊ-ꠙꠣꠘꠤ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("MT5_46","070_5_46","MAT","5","46","46","ꠎꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦꠃ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛꠣꠄ? ꠊꠥꠡꠈꠥꠞ ꠔꠡꠤꠟꠖꠣꠞ ꠅꠇꠟꠦꠅ ꠁꠟꠣ ꠇꠞꠦ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT5_47","070_5_47","MAT","5","47","47","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠘꠤꠎꠞ ꠜꠣꠁꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠦꠅ, ꠔꠦ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠀꠞ ꠇꠤꠔꠣ ꠇꠞꠞꠣꠄ? ꠛꠤꠗꠞ꠆ꠝꠤ ꠅꠇꠟꠦꠅ ꠁꠟꠣ ꠇꠞꠂꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT5_48","070_5_48","MAT","5","48","48","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠎꠦꠟꠣ ꠈꠣꠐꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠈꠣꠐꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("MT6_1","070_6_1","MAT","6","1","1","“ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠝꠣꠘꠡꠞꠦ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠁꠟꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT6_2","070_6_2","MAT","6","2","2","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠤꠟꠦ ꠜꠘ꠆ꠒ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠖꠤꠅ ꠘꠣ। ꠔꠣꠞꠣ ꠔ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠞꠤꠚ ꠙꠣꠁꠔꠣ ꠇꠞꠤ ꠝꠍꠤꠖꠅ-ꠝꠘ꠆ꠖꠤꠞꠅ ꠀꠞ ꠙꠕꠦ-ꠊꠣꠐꠦ, ꠒꠥꠟ-ꠒꠙꠇꠤ ꠛꠣꠎꠣꠁꠀ ꠟꠤꠟ꠆ꠟꠣ-ꠎꠇꠣꠔ ꠖꠦꠁꠘ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠔꠣꠞꠣꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠔ ꠔꠣꠞꠣ ꠙꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT6_3","070_6_3","MAT","6","3","3","ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠤꠟꠦ, ꠔꠥꠝꠣꠞ ꠒꠣꠁꠘ ꠀꠔꠦ ꠛꠤꠟꠣꠁꠟꠦ ꠛꠣꠃ ꠀꠔꠦ ꠎꠣꠘꠥ ꠘꠣ ꠎꠣꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("MT6_4","070_6_4","MAT","6","4","4","ꠅꠃꠟꠣ ꠟꠥꠇꠣꠁꠀ ꠖꠣꠘ ꠇꠞꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ, ꠎꠦꠁꠘ ꠟꠥꠇꠣꠁꠀ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠂꠘ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠣꠞꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_5","070_6_5","MAT","6","5","5","“ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠖꠥꠀ ꠇꠞꠅ, ꠅꠃ ꠡꠝꠄ ꠜꠘ꠆ꠒ ꠅꠇꠟꠞ ꠜꠣꠛ ꠗꠞꠤꠅ ꠘꠣ। ꠔꠣꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠍꠤꠖꠅ-ꠝꠘ꠆ꠖꠤꠞꠅ ꠀꠞ ꠙꠕꠞ ꠝꠥꠈꠅ ꠃꠛꠣꠁꠀ ꠖꠥꠀ ꠇꠞꠦ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠁꠔꠣꠄ ꠔ ꠔꠣꠞꠣꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT6_6","070_6_6","MAT","6","6","6","ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠖꠥꠀ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠊꠞꠞ ꠖꠞꠎꠣ-ꠎꠣꠘꠣꠟꠣ ꠟꠣꠉꠣꠁꠀ ꠖꠥꠀ ꠇꠞꠤꠅ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠘꠤꠞꠣꠇꠣꠞ ꠛꠣꠚ, ꠎꠦꠘꠞꠦ ꠖꠦꠈꠣ ꠘꠣ ꠉꠦꠟꠦꠅ ꠀꠎꠤꠞ ꠀꠍꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠌꠣꠁꠅ। ꠔꠣꠁꠘ ꠔ ꠉꠥꠙꠘ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠂꠘ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠣꠞꠦ ꠚꠟ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_7","070_6_7","MAT","6","7","7","“ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠖꠥꠀ ꠇꠞꠅ, ꠅꠃ ꠡꠝꠄ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠈꠣꠝꠈꠣ ꠛꠦꠞ-ꠛꠦꠞꠤ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠛꠦꠡꠤ ꠛꠦꠡꠤ ꠇꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_8","070_6_8","MAT","6","8","8","ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠅ ꠘꠣ, ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠌꠣꠅꠀꠞ ꠀꠉꠦꠃ, ꠔꠣꠁꠘ ꠎꠣꠘꠂꠘ ꠔꠥꠝꠞꠣꠞ ꠇꠤꠔꠣ ꠖꠞꠇꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("MT6_9","070_6_9","MAT","6","9","9","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠅꠟꠣꠈꠣꠘ ꠖꠥꠀ ꠇꠞꠤꠅ, ꠅ ꠛꠣꠛꠣ, ꠀꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ, ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠣꠘꠣ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT6_10","070_6_10","MAT","6","10","10","ꠖꠥꠘꠤꠀꠁꠔ ꠔꠥꠝꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠎꠟꠖꠤ ꠀꠃꠇ, ꠡꠛ ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠇꠞꠣ ꠎꠣꠃꠇ, ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠎꠦꠟꠣ ꠅꠃꠟꠣ ꠖꠥꠘꠤꠀꠁꠔ, ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠎꠦꠟꠣ ꠅꠃꠟꠣ ꠖꠥꠘꠤꠀꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("MT6_11","070_6_11","MAT","6","11","11","ꠅ ꠛꠣꠛꠣ, ꠀꠁꠎꠇꠥꠞ ꠈꠣꠘꠤ ꠀꠁꠎꠇꠥ ꠖꠦꠅ, ꠝꠣꠚ ꠇꠞꠅ ꠀꠝꠞꠣꠞ ꠢꠇꠟ ꠅꠙꠞꠣꠗ, ");
INSERT INTO syls_vpl VALUES ("MT6_12","070_6_12","MAT","6","12","12","ꠎꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠞꠍꠦ ꠙꠣꠙ, ꠀꠝꠞꠣ ꠔ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠟꠣꠁꠍꠤ ꠝꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("MT6_13","070_6_13","MAT","6","13","13","ꠚꠣꠟꠣꠁꠅ ꠘꠣ ꠀꠝꠞꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣꠔ, ꠡꠄꠔꠣꠘꠞ ꠇꠛꠎꠣ ꠕꠣꠇꠤ ꠇꠞꠅ ꠈꠣꠟꠣꠍ॥ ");
INSERT INTO syls_vpl VALUES ("MT6_14","070_6_14","MAT","6","14","14","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠞꠇ ꠎꠘꠞ ꠅꠙꠞꠣꠗ ꠝꠣꠚ ꠇꠞꠅ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠥꠝꠞꠣꠞ ꠅꠙꠞꠣꠗ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_15","070_6_15","MAT","6","15","15","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠣꠚ ꠘꠣ ꠇꠞꠅ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚꠦ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠝꠣꠚ ꠇꠞꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT6_16","070_6_16","MAT","6","16","16","“ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠅ, ꠅꠃ ꠡꠝꠄ ꠜꠘ꠆ꠒ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠝꠥꠈ ꠇꠣꠟꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠣꠞꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠍꠂꠘ, ꠅꠈꠣꠘ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠌꠃꠈ-ꠝꠥꠈ ꠇꠣꠟꠣ ꠇꠞꠤ ꠞꠣꠈꠂꠘ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠁꠔꠣꠄ ꠔ ꠔꠣꠞꠣꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT6_17","070_6_17","MAT","6","17","17","ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠞꠥꠎꠣ ꠞꠣꠈꠟꠦ ꠝꠥꠈ-ꠀꠔ ꠗꠁꠅ, ꠝꠣꠕꠣꠔ ꠔꠦꠟ-ꠙꠣꠘꠤ ꠖꠤꠅ, ");
INSERT INTO syls_vpl VALUES ("MT6_18","070_6_18","MAT","6","18","18","ꠎꠦꠟꠣ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠔ ꠘꠣ ꠙꠣꠞꠦ, ꠔꠥꠝꠤ ꠞꠥꠎꠣ ꠞꠣꠈꠍ। ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠘꠤꠞꠣꠇꠣꠞ ꠛꠣꠚ, ꠎꠦꠘꠞꠦ ꠖꠦꠈꠣ ꠘꠣ ꠉꠦꠟꠦꠅ ꠀꠎꠤꠞ ꠀꠍꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠄꠃ ꠁꠔꠣ ꠖꠦꠈꠛꠣ। ꠔꠣꠁꠘ ꠔ ꠉꠥꠙꠘ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠂꠘ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠣꠞꠦ ꠚꠟ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_19","070_6_19","MAT","6","19","19","“ꠁ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠅꠔ ꠗꠘ-ꠡꠝ꠆ꠙꠖ ꠎꠝꠣꠁꠅ ꠘꠣ। ꠖꠥꠘꠤꠀꠞ ꠡꠝ꠆ꠙꠖꠞ ꠝꠣꠎꠦ ꠎꠋꠉꠣꠞꠦ ꠗꠞꠦ, ꠙꠥꠇꠦ ꠈꠣꠄ ꠀꠞ ꠢꠤꠋ ꠈꠥꠖꠤꠀ ꠌꠥꠞꠦ ꠘꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("MT6_20","070_6_20","MAT","6","20","20","ꠅꠁꠟꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠍꠣꠝꠣꠘꠣ ꠎꠝꠣꠅ, ꠢꠤꠘꠅ ꠎꠋꠉꠣꠞꠦ ꠗꠞꠦ ꠘꠣ, ꠙꠥꠇꠦꠅ ꠈꠣꠄ ꠘꠣ ꠀꠞ ꠌꠥꠞꠤꠅ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_21","070_6_21","MAT","6","21","21","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠣꠞ ꠗꠘ ꠎꠦꠘꠅ, ꠝꠘꠅ ꠢꠘꠅ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("MT6_22","070_6_22","MAT","6","22","22","“ꠎꠣꠘ ꠔ, ꠌꠃꠈ ꠅꠁꠟ ꠡꠞꠤꠟꠞ ꠛꠣꠔ꠆ꠔꠤ। ꠔꠥꠝꠣꠞ ꠌꠃꠈ ꠎꠥꠖꠤ ꠜꠣꠟꠣ ꠅꠄ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠅ ꠌꠇꠌꠇꠣ ꠚꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT6_23","070_6_23","MAT","6","23","23","ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠌꠃꠈ ꠎꠥꠖꠤ ꠈꠣꠞꠣꠙ ꠅꠄ, ꠔꠦ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠃ ꠇꠣꠟꠣ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠎꠤꠛ। ꠔꠥꠝꠣꠞ ꠖꠤꠟꠞ ꠛꠣꠔ꠆ꠔꠤ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠟꠦ, ꠁ ꠀꠘ꠆ꠖꠣꠁꠞ ꠛꠠ ꠛꠦꠎꠥꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_24","070_6_24","MAT","6","24","24","“ꠎꠣꠘ ꠘꠤ, ꠇꠥꠘꠥ ꠉꠥꠟꠣꠝꠦꠃ ꠖꠥꠁ ꠝꠥꠘꠤꠛꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠢꠦ ꠄꠇꠎꠘꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠛ ꠀꠞꠇꠎꠘꠞꠦ ꠜꠣꠟꠣ ꠙꠣꠁꠛ। ꠀꠞꠘꠣꠄ ꠄꠇꠎꠘꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠛ, ꠀꠞꠇꠎꠘꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠛ। ꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ, ꠖꠥꠁꠅꠔꠣꠞ ꠈꠦꠎꠝꠔ ꠄꠇꠟꠉꠦ ꠇꠞꠔꠣꠄ ꠙꠣꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_25","070_6_25","MAT","6","25","25","“ꠄꠞꠖꠣꠄ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠇꠤꠟꠣ ꠈꠣꠁꠔꠣꠝ ꠀꠞ ꠇꠤꠟꠣ ꠚꠤꠘ꠆ꠖꠤꠔꠣꠝ, ꠁꠔꠣ ꠟꠁꠀ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠈꠣꠘꠤ ꠕꠣꠇꠤ ꠎꠣꠘ ꠛꠠ, ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠕꠣꠇꠤ ꠡꠞꠤꠟ ꠛꠠ। ");
INSERT INTO syls_vpl VALUES ("MT6_26","070_6_26","MAT","6","26","26","“ꠀꠍꠝꠣꠘꠞ ꠅꠃ ꠙꠣꠈꠤꠘ꠆ꠔꠞ ꠛꠣꠄ ꠌꠣꠅ, ꠔꠣꠞꠣ ꠎꠣꠟꠣꠅ ꠛꠣꠁꠘ ꠇꠞꠦ ꠘꠣ, ꠚꠡꠟꠅ ꠇꠣꠐꠦ ꠘꠣ, ꠃꠉꠣꠞꠅ ꠇꠥꠘ꠆ꠔꠣ ꠎꠝꠣꠄ ꠘꠣ, ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠈꠥꠞꠣꠇ ꠖꠦꠁꠘ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠁꠔꠣ ꠕꠣꠇꠤ ꠀꠞꠅ ꠖꠣꠝꠤ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT6_27","070_6_27","MAT","6","27","27","ꠇꠅ ꠌꠣꠁꠘ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠇꠞꠤꠀ ꠔꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠄꠇꠈꠣꠘ ꠊꠘ꠆ꠐꠣ ꠛꠣꠠꠣꠁꠔ ꠙꠣꠞꠛ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT6_28","070_6_28","MAT","6","28","28","“ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠꠞ ꠟꠣꠉꠤ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞ ꠇꠦꠘꠦ? ꠔꠥꠝꠞꠣ ꠅꠃ ꠎꠋꠟꠤ ꠚꠥꠟꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠖꠦꠈꠅ, ꠁꠔꠣ ꠇꠔ ꠛꠦꠡꠤ ꠡꠥꠘ꠆ꠖꠞ! ꠁꠔꠣꠄ ꠔ ꠘꠤꠎꠞ ꠡꠥꠘ꠆ꠖꠞꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠦ ꠘꠣ, ꠇꠥꠘꠥ ꠞꠋꠉꠅ ꠡꠤꠟꠣꠁ ꠇꠞꠦ ꠘꠣ, ꠛꠣꠁꠘꠅ ꠇꠞꠦ ꠘꠣ, ꠄꠝꠘꠦꠃ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT6_29","070_6_29","MAT","6","29","29","ꠔꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠛꠣꠖꠡꠣ ꠍꠥꠟꠣꠁꠝꠣꠘ ꠅꠔ ꠎꠣꠇ-ꠎꠝꠇꠞ ꠝꠣꠎꠦ ꠞꠁꠟꠦꠅ ꠔꠣꠘ ꠟꠦꠛꠣꠍ ꠔ ꠅꠔꠣ ꠄꠉꠥ ꠎꠋꠟꠤ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘꠅ ꠡꠥꠘ꠆ꠖꠞ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_30","070_6_30","MAT","6","30","30","ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠎꠋꠉꠟꠞ ꠝꠣꠎꠦ ꠅꠃ ꠎꠦꠔꠣ ꠡꠥꠘ꠆ꠖꠞ ꠚꠥꠟ ꠅꠈꠘ ꠀꠍꠦ, ꠇꠣꠁꠟ ꠅꠁꠟꠦꠃ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠖꠣꠞꠥ ꠛꠣꠘꠣꠁꠀ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠛ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠥꠖꠤ ꠅꠃ ꠎꠋꠉꠟꠞꠦ ꠅꠟꠣ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠍꠂꠘ, ꠔꠦ ꠅ ꠇꠝꠎꠥꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞꠦꠅ ꠔꠣꠁꠘ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠔꠣ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT6_31","070_6_31","MAT","6","31","31","ꠄꠞꠖꠣꠄ ꠇꠤꠔꠣ ꠈꠣꠁꠔꠣꠄ ꠀꠞ ꠇꠤꠔꠣ ꠚꠤꠘ꠆ꠖꠤꠔꠣꠄ, ꠁꠔꠣ ꠟꠁꠀ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT6_32","070_6_32","MAT","6","32","32","ꠁ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠈꠣꠟꠤ ꠅꠔꠣ ꠟꠁꠀꠃ ꠗꠣꠘ꠆ꠖꠣ ꠇꠞꠦ। ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠎꠣꠘꠂꠘꠃ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠎꠞꠥꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT6_33","070_6_33","MAT","6","33","33","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠙꠄꠟꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠅ, ꠔꠣꠘ ꠛꠣꠖꠡꠣꠁꠞ ꠗꠣꠘ꠆ꠖꠣꠔ ꠞꠅ। ꠔꠦꠃ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠅ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT6_34","070_6_34","MAT","6","34","34","ꠇꠣꠁꠟꠇꠥꠞ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠇꠣꠁꠟꠇꠥꠞ ꠛꠦꠙꠣꠞ ꠇꠣꠁꠟꠇꠥꠞ ꠃꠙꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ। ꠖꠤꠘꠞ ꠀꠎꠣꠛ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠎꠕꠦꠡ꠆ꠐ। ");
INSERT INTO syls_vpl VALUES ("MT7_1","070_7_1","MAT","7","1","1","“ꠔꠥꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠖꠥꠡ ꠔꠥꠇꠣꠘꠤꠔ ꠞꠁꠅ ꠘꠣ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠅ ꠔꠥꠇꠣꠁꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT7_2","070_7_2","MAT","7","2","2","ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠝꠣꠘꠡꠞ ꠖꠥꠡ ꠔꠥꠇꠣꠅ, ꠀꠟ꠆ꠟꠣꠄꠅ ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡ ꠔꠥꠇꠣꠁꠛꠣ। ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠙꠣꠟ꠆ꠟꠣꠖꠤ ꠝꠣꠙꠤꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠅꠟꠣ ꠝꠣꠙꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT7_3","070_7_3","MAT","7","3","3","“ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞ ꠌꠃꠈꠞ ꠜꠤꠔꠞꠦ ꠉꠥꠠꠣ ꠀꠍꠦ ꠁꠈꠣꠘ ꠖꠦꠈꠞꠣꠄ, ꠅꠁꠟꠦ ꠘꠤꠎꠞ ꠌꠃꠈꠅ ꠉꠣꠍꠞ ꠌꠦꠟꠤ ꠀꠍꠦ ꠁꠈꠣꠘ ꠖꠦꠈꠞꠣꠄ ꠘꠣ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("MT7_4","070_7_4","MAT","7","4","4","ꠔꠥꠝꠣꠞ ꠌꠈꠥꠔ ꠌꠦꠟꠤ ꠢꠣꠝꠣꠁꠍꠦ ꠁꠈꠣꠘ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠞꠣꠄ ꠘꠣ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞꠦ ꠇꠤꠟꠣ ꠇꠁꠛꠣꠄ, ꠜꠣꠁ, ꠔꠥꠝꠣꠞ ꠌꠈꠥꠔ ꠉꠥꠠꠣ ꠢꠣꠝꠣꠁꠍꠦ, ꠀꠅ, ꠛꠣꠞ ꠇꠞꠤꠀ ꠖꠦꠁ? ");
INSERT INTO syls_vpl VALUES ("MT7_5","070_7_5","MAT","7","5","5","ꠢꠣꠄꠞꠦ ꠜꠘ꠆ꠒ, ꠙꠄꠟꠣ ꠘꠤꠎꠞ ꠌꠃꠈ ꠕꠣꠇꠤ ꠌꠦꠟꠤ ꠛꠣꠞ ꠇꠞꠅ, ꠛꠣꠖꠦ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞ ꠌꠃꠈ ꠕꠣꠇꠤ ꠉꠥꠠꠣ ꠛꠣꠞ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠦ ꠜꠣꠟꠣ ꠇꠞꠤ ꠖꠦꠈꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT7_6","070_7_6","MAT","7","6","6","“ꠢꠥꠘꠅ, ꠇꠥꠔ꠆ꠔꠣꠞ ꠍꠣꠝꠘꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠘꠥ ꠌꠤꠎ ꠖꠤꠅ ꠘꠣ। ꠡꠥꠅꠞꠞ ꠍꠣꠝꠘꠦ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣ ꠍꠤꠐꠣꠁꠅ ꠘꠣ। ꠀꠞꠘꠣꠄ ꠅꠃ ꠌꠤꠎꠞꠦ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠖꠤ ꠃꠠꠤꠀ, ꠃꠟꠐꠣ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠢꠣꠝꠟꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT7_7","070_7_7","MAT","7","7","7","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠌꠣꠅ, ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠅ, ꠔꠦꠃ ꠙꠣꠁꠛꠣꠄ। ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣ ꠖꠦꠅ, ꠔꠦꠃ ꠖꠥꠀꠞ ꠈꠥꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT7_8","070_7_8","MAT","7","8","8","ꠎꠣꠞꠣ ꠌꠣꠄ, ꠔꠣꠞꠣꠃ ꠔ ꠙꠣꠄ। ꠎꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠦ ꠢꠦ ꠙꠣꠄ। ꠎꠦ ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣꠄ, ꠔꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀꠞ ꠈꠥꠟꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT7_9","070_7_9","MAT","7","9","9","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠝꠣ-ꠛꠣꠚ ꠀꠍꠦ ꠘꠤ, ꠎꠣꠞ ꠙꠥꠔꠦ ꠞꠥꠐꠤ ꠌꠣꠁꠟꠦ ꠝꠣꠐꠤ ꠖꠤꠛ? ");
INSERT INTO syls_vpl VALUES ("MT7_10","070_7_10","MAT","7","10","10","ꠝꠣꠍ ꠌꠣꠁꠟꠦ ꠢꠣꠚ ꠖꠤꠛ? ");
INSERT INTO syls_vpl VALUES ("MT7_11","070_7_11","MAT","7","11","11","ꠔꠥꠝꠞꠣ ꠈꠣꠞꠣꠙ ꠅꠁꠀꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠌꠤꠎ ꠖꠤꠔꠣꠄ ꠎꠣꠘ, ꠔꠦ ꠎꠣꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠦꠍꠦ ꠌꠣꠁꠛ, ꠔꠣꠁꠘ ꠔ ꠘꠤꠌꠄ ꠔꠣꠞꠣꠞꠦ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠌꠤꠎ ꠖꠣꠘ ꠇꠞꠛꠣ, ꠁꠔꠣ ꠔ ꠡ꠆ꠛꠣꠜꠣꠛꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("MT7_12","070_7_12","MAT","7","12","12","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦꠟꠣꠈꠣꠘ ꠛꠦꠛꠢꠣꠞ ꠙꠣꠁꠔꠣꠄ ꠌꠣꠅ, ꠔꠥꠝꠞꠣꠅ ꠢꠇꠟꠞ ꠟꠉꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠅ। ꠅꠔꠣꠃ ꠅꠁꠟ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠍꠢꠤꠚꠣꠞ ꠝꠥꠟ ꠔꠣꠟꠤꠝ। ");
INSERT INTO syls_vpl VALUES ("MT7_13","070_7_13","MAT","7","13","13","“ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠌꠤꠙꠣ ꠖꠥꠀꠞꠦꠖꠤ ꠢꠣꠝꠣꠁꠅ, ꠇꠣꠞꠘ ꠎꠦ ꠙꠕꠦ ꠛꠤꠘꠣꠡꠞ ꠛꠣꠄ ꠐꠣꠘꠦ, ꠁ ꠙꠕ ꠝꠥꠐꠣ, ꠙꠕꠞ ꠖꠥꠀꠞꠅ ꠛꠠ, ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠅꠃ ꠖꠥꠀꠞꠦꠖꠤ ꠢꠣꠝꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("MT7_14","070_7_14","MAT","7","14","14","ꠅꠁꠟꠦ ꠎꠦ ꠙꠕꠦ ꠉꠦꠟꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠝꠤꠟꠦ, ꠁ ꠙꠕꠞ ꠖꠥꠀꠞ ꠌꠤꠙꠣ, ꠙꠕꠅ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ। ꠈꠥꠛ ꠇꠝ ꠝꠣꠘꠡꠦꠃ ꠁ ꠖꠥꠀꠞꠞ ꠈꠥꠎ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("MT7_15","070_7_15","MAT","7","15","15","“ꠜꠘ꠆ꠒ ꠘꠛꠤ ꠅꠇꠟ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ। ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠝꠦꠠꠣꠞ ꠍꠥꠞꠔꠦ ꠀꠄ, ꠅꠁꠟꠦ ꠜꠤꠔꠞꠦ ꠜꠤꠔꠞꠦ ꠔꠣꠞꠣ ꠞꠣꠁꠇ꠆ꠇꠡ ꠛꠣꠊꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("MT7_16","070_7_16","MAT","7","16","16","ꠔꠣꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠦꠈꠤꠀꠃ ꠌꠤꠘꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠎꠣꠘ ꠔ, ꠉꠍꠣ-ꠇꠣꠐꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠀꠋꠉꠥꠞ ꠗꠞꠦ ꠘꠤ ꠛꠣ ꠛꠘ-ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠒꠥꠝꠥꠞ ꠚꠟ ꠗꠞꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT7_17","070_7_17","MAT","7","17","17","ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠜꠣꠟꠣ ꠉꠣꠍꠦ ꠔ ꠜꠣꠟꠣ ꠚꠟꠃ ꠗꠞꠦ ꠀꠞ ꠝꠘ꠆ꠖ ꠉꠣꠍꠦ ꠝꠘ꠆ꠖ ꠚꠟꠃ ꠗꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT7_18","070_7_18","MAT","7","18","18","ꠜꠣꠟꠣ ꠉꠣꠍꠦ ꠔ ꠝꠘ꠆ꠖ ꠚꠟ ꠗꠞꠦ ꠘꠣ, ꠀꠞ ꠝꠘ꠆ꠖ ꠉꠣꠍꠦ ꠜꠣꠟꠣ ꠚꠟ ꠗꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT7_19","070_7_19","MAT","7","19","19","ꠎꠦ ꠉꠣꠍꠦ ꠜꠣꠟꠣ ꠚꠟ ꠗꠞꠦ ꠘꠣ, ꠁꠉꠥꠞꠦ ꠇꠣꠐꠤꠀ ꠖꠣꠞꠥ ꠎꠣꠟꠣꠁꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT7_20","070_7_20","MAT","7","20","20","ꠅꠟꠣꠃ ꠜꠘ꠆ꠒ ꠘꠛꠤ ꠅꠇꠟꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠚꠟ ꠖꠦꠈꠟꠦꠃ ꠁꠔꠣꠞꠦ ꠌꠤꠘꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT7_21","070_7_21","MAT","7","21","21","“ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠣꠞꠦ ‘ꠢꠥꠎꠥꠞ, ꠢꠥꠎꠥꠞ!’ ꠇꠁꠟꠦꠃ ꠎꠦꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠁꠎꠤꠛꠣꠄ, ꠁꠈꠣꠘ ꠑꠤꠇ ꠘꠣꠄ। ꠛꠞꠋ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠦ, ꠈꠣꠟꠤ ꠢꠦ-ꠃ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("MT7_22","070_7_22","MAT","7","22","22","ꠢꠃ ꠖꠤꠘ ꠀꠁꠟꠦ ꠛꠃꠔꠦ ꠇꠁꠛꠣ, ‘ꠝꠥꠘꠤꠛ, ꠝꠥꠘꠤꠛ, ꠀꠝꠞꠣ ꠔꠥꠝꠣꠞ ꠘꠣꠝꠦ ꠉꠣꠁꠛꠤ ꠈꠛꠞ ꠇꠁꠍꠤ ꠘꠣ ꠘꠤ? ꠔꠥꠝꠣꠞ ꠘꠣꠝꠦ ꠎꠤꠘ-ꠜꠥꠔ ꠍꠣꠠꠣꠁꠍꠤ ꠘꠣ ꠘꠤ? ꠔꠥꠝꠣꠞ ꠘꠣꠝꠦ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠍꠤ ꠘꠣ ꠘꠤ?’ ");
INSERT INTO syls_vpl VALUES ("MT7_23","070_7_23","MAT","7","23","23","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠝꠥ, ‘ꠗꠥꠞ, ꠁꠛꠟꠤꠍꠞ ꠖꠟ! ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠌꠤꠘꠤꠃ ꠘꠣ, ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT7_24","070_7_24","MAT","7","24","24","“ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠅꠃ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠀꠝꠟ ꠇꠞꠦ, ꠢꠦ ꠀꠈꠟꠖꠣꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠝꠎꠛꠥꠔ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠔꠣꠞ ꠊꠞ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT7_25","070_7_25","MAT","7","25","25","ꠛꠣꠖꠦ ꠝꠦꠊ-ꠔꠥꠚꠣꠘ ꠀꠞ ꠎꠥꠀꠞ ꠀꠁꠀ ꠅꠃ ꠊꠞꠞꠦ ꠑꠦꠟꠣ ꠖꠤꠟꠦꠅ ꠚꠣꠟꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠁꠈꠣꠘ ꠔ ꠝꠎꠛꠥꠔ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT7_26","070_7_26","MAT","7","26","26","ꠅꠁꠟꠦ ꠎꠦ ꠀꠝꠣꠞ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀꠅ ꠀꠝꠟ ꠇꠞꠦ ꠘꠣ, ꠢꠦ ꠛꠦꠀꠈꠟꠞ ꠟꠣꠈꠣꠘ ꠘꠞꠝ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠊꠞ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT7_27","070_7_27","MAT","7","27","27","ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠝꠦꠊ-ꠔꠥꠚꠣꠘ ꠀꠞ ꠎꠥꠀꠞ ꠀꠁꠀ ꠅꠃ ꠊꠞꠞꠦ ꠑꠦꠟꠣ ꠖꠦꠄ, ꠅꠃ ꠡꠝꠄ ꠁꠈꠣꠘ ꠙꠠꠤꠀ ꠌꠦꠙ꠆ꠐꠣ ꠅꠁꠎꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT7_28","070_7_28","MAT","7","28","28","ꠁꠍꠣꠞ ꠁꠔꠣ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT7_29","070_7_29","MAT","7","29","29","ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠔ ꠔꠣꠞꠣꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠘꠣ ꠖꠤꠀ, ꠈꠦꠝꠔꠣꠛꠣꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_1","070_8_1","MAT","8","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠦ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_2","070_8_2","MAT","8","2","2","ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤꠄ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠙꠣꠅꠔ ꠙꠠꠤꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠝꠞ꠆ꠎꠤ ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠅꠃ ꠘꠣꠙꠣꠇ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT8_3","070_8_3","MAT","8","3","3","ꠔꠦꠃ ꠔꠣꠁꠘ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠔꠣꠞꠦ ꠍꠁꠀ ꠇꠁꠟꠣ, “ꠅꠄ ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠅ।” ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT8_4","070_8_4","MAT","8","4","4","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠁꠔꠣ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ, ꠈꠣꠟꠤ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠖꠦꠈꠣꠅ। ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠦꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠦꠃ ꠡꠝꠣꠎꠦ ꠎꠣꠘꠤꠟꠤꠛꠣ ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍ।” ");
INSERT INTO syls_vpl VALUES ("MT8_5","070_8_5","MAT","8","5","5","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣ ꠉꠤꠀ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠁꠟꠣ। ꠢꠤꠘꠅ ꠞꠥꠝꠣꠘ ꠍꠤꠙꠣꠁꠞ ꠄꠇ ꠍꠥꠛꠦꠖꠣꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠀ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠟꠣꠉꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT8_6","070_8_6","MAT","8","6","6","“ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝꠞ ꠅꠛꠡ ꠛꠦꠝꠣꠞ ꠅꠁꠀ ꠛꠤꠍꠘꠣꠔ ꠙꠠꠤ ꠞꠁꠍꠦ, ꠢꠦ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT8_7","070_8_7","MAT","8","7","7","ꠁꠍꠣꠄ ꠄꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠀꠝꠤ ꠎꠣꠁꠝꠥꠘꠦ, ꠉꠤꠀ ꠔꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT8_8","070_8_8","MAT","8","8","8","ꠔꠦꠃ ꠍꠥꠛꠦꠖꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠝꠔ ꠎꠘꠦ ꠀꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠔꠡꠞꠤꠚ ꠘꠤꠔꠣ, ꠀꠝꠤ ꠔ ꠄꠞ ꠟꠣꠈ ꠘꠣꠄ। ꠀꠙꠘꠦ ꠈꠣꠟꠤ ꠝꠥꠈ-ꠈꠣꠘꠖꠤ ꠇꠁꠟꠦꠃ ꠢꠦ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT8_9","070_8_9","MAT","8","9","9","ꠀꠙꠘꠦ ꠔ ꠛꠥꠎꠞꠣ, ꠀꠝꠤꠅ ꠀꠝꠣꠞ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞꠞ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠤ, ꠅꠃꠟꠣ ꠀꠝꠣꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠅ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠂꠘ। ꠀꠝꠤ ꠄꠞꠣ ꠄꠇꠎꠘꠞꠦ ꠀꠅ ꠇꠁꠟꠦ ꠀꠄ, ꠎꠣꠅ ꠇꠁꠟꠦ ꠎꠣꠄ। ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠎꠥꠖꠤ ꠇꠁ, ꠅꠈꠣꠘ ꠇꠞꠅ, ꠢꠦ ꠁꠈꠣꠘ ꠇꠞꠦ, ꠔꠦ ꠀꠙꠘꠦꠅ ꠅꠟꠣ ꠝꠥꠈꠖꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠦꠃ ꠢꠦ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT8_10","070_8_10","MAT","8","10","10","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ, ꠔꠣꠘ ꠈꠞꠦ ꠅꠁꠀ ꠎꠔ ꠝꠣꠘꠥꠡ ꠀꠅꠀꠔ ꠀꠍꠤꠟ, ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠁ ꠍꠥꠛꠦꠖꠣꠞ ꠔ ꠛꠤꠗꠞ꠆ꠝꠤ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠥꠡ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦꠅ ꠅꠔ ꠛꠠ ꠝꠎꠛꠥꠔ ꠁꠝꠣꠘꠖꠣꠞ ꠀꠝꠤ ꠀꠞ ꠖꠦꠈꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_11","070_8_11","MAT","8","11","11","ꠢꠥꠘꠅ, ꠙꠥꠛ ꠀꠞ ꠙꠁꠌꠝꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠃꠔ ꠎꠘ ꠀꠁꠛꠣ, ꠔꠣꠞꠣ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛ ꠘꠛꠤꠞ ꠟꠉꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠈꠣꠘꠤꠔ ꠛꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_12","070_8_12","MAT","8","12","12","ꠅꠁꠟꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠎꠣꠞꠣ ꠕꠣꠇꠣꠞ ꠇꠕꠣ, ꠔꠣꠞꠣꠞꠦ ꠛꠣꠞꠦ ꠀꠘ꠆ꠖꠣꠁꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠢꠤꠘꠅ ꠔꠣꠞꠣ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠛꠣ ꠀꠞ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠄ ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠈꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT8_13","070_8_13","MAT","8","13","13","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠅꠃ ꠍꠥꠛꠦꠖꠣꠞꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠣꠅꠉꠤ। ꠔꠥꠝꠤ ꠎꠦꠟꠣ ꠄꠇꠤꠘ ꠇꠞꠍ, ꠅꠟꠣꠃ ꠅꠃꠇ।” ꠢꠣꠍꠣꠃ, ꠟꠉꠦ ꠟꠉꠦꠃ ꠢꠃ ꠉꠥꠟꠣꠝ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT8_14","070_8_14","MAT","8","14","14","ꠄꠞꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠢꠎꠞꠔ ꠙꠤꠔꠞꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠙꠤꠔꠞꠞ ꠢꠠꠤꠞ ꠈꠥꠛ ꠔꠣꠙ ꠃꠑꠍꠦ, ꠔꠣꠁꠘ ꠛꠤꠍꠘꠣꠔ ꠙꠠꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("MT8_15","070_8_15","MAT","8","15","15","ꠔꠣꠘꠦ ꠖꠦꠈꠤꠀ ꠁꠍꠣꠄ ꠔꠣꠘ ꠀꠔꠅ ꠍꠁꠟꠣ, ꠀꠞ ꠟꠉꠦ ꠟꠉꠦ ꠔꠣꠙ ꠍꠣꠠꠤ ꠖꠤꠟ। ꠛꠦꠐꠤꠄ ꠃꠑꠤꠀ ꠁꠍꠣꠞ ꠝꠦꠝꠣꠘꠖꠣꠞꠤꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_16","070_8_16","MAT","8","16","16","ꠅꠃ ꠖꠤꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠝꠣꠘꠡꠦ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠟꠣ ꠛꠃꠔ ꠎꠘꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠁꠍꠣꠄ ꠔꠣꠘ ꠝꠥꠈꠞ ꠇꠕꠣꠄꠃ ꠄꠞꠣꠞ ꠎꠤꠘ ꠍꠣꠠꠣꠁꠟꠣ, ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_17","070_8_17","MAT","8","17","17","ꠁꠔꠣ ꠊꠐꠟ, ꠎꠣꠔꠦ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠛꠃꠔ ꠀꠉꠦ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠅꠔꠣ ꠅꠈꠘ ꠙꠥꠞꠣ ꠅꠄ। ꠢꠘꠅ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠀꠝꠞꠣꠞ ꠢꠇꠟ ꠇꠝꠎꠥꠞꠤ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠅ ꠘꠤꠟꠣ, ꠀꠝꠞꠣꠞ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠢꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_18","070_8_18","MAT","8","18","18","ꠁꠍꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠜꠤꠠ ꠟꠣꠉꠤꠉꠦꠍꠦ ꠖꠦꠈꠤꠀ, ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠎꠣꠁꠔꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT8_19","070_8_19","MAT","8","19","19","ꠅꠃ ꠡꠝꠄ ꠄꠇꠎꠘ ꠝꠃꠟꠣꠘꠣ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠎꠦꠘꠅ ꠎꠣꠁꠛꠣ, ꠀꠝꠤꠅ ꠢꠘꠅ ꠎꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT8_20","070_8_20","MAT","8","20","20","ꠁꠍꠣꠄ ꠄꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠢꠤꠀꠟꠞ ꠉꠣꠔ ꠀꠍꠦ, ꠙꠣꠈꠤꠞꠅ ꠛꠣꠖꠣ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠝꠣꠕꠣ ꠕꠅꠀꠞ ꠑꠣꠁ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("MT8_21","070_8_21","MAT","8","21","21","ꠀꠞꠇ ꠎꠘ ꠡꠣꠉꠞꠤꠖꠦ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞꠦ ꠛꠣꠠꠤꠔ ꠎꠣꠁꠔꠦ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠙꠄꠟꠣ ꠉꠤꠀ ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞ ꠖꠣꠚꠘ-ꠇꠣꠚꠘ ꠇꠞꠤꠀ ꠀꠁ।” ");
INSERT INTO syls_vpl VALUES ("MT8_22","070_8_22","MAT","8","22","22","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠞꠣ ꠅꠇꠟꠦꠃ ꠔꠣꠞꠣꠞ ꠝꠞꠣꠞꠦ ꠝꠣꠐꠤ ꠖꠦꠃꠇ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠌꠟꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT8_23","070_8_23","MAT","8","23","23","ꠁꠍꠣ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠎꠣꠁꠔꠣ ꠇꠞꠤ, ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠄꠇ ꠘꠣꠅꠅ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_24","070_8_24","MAT","8","24","24","ꠁꠍꠣ ꠘꠣꠅꠞ ꠝꠣꠎꠦ ꠊꠥꠝꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠀꠅꠞꠞ ꠝꠣꠎꠦ ꠛꠠ ꠄꠇ ꠔꠥꠚꠣꠘ ꠀꠁꠟ, ꠔꠥꠚꠣꠘꠦ ꠘꠣꠅꠈꠣꠘ ꠛꠥꠠꠤꠎꠤꠛꠣꠞ ꠖꠡꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT8_25","070_8_25","MAT","8","25","25","ꠁ ꠖꠡꠣ ꠖꠦꠈꠤꠀ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣꠘꠥ ꠝꠞꠤ ꠎꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("MT8_26","070_8_26","MAT","8","26","26","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅ ꠇꠝꠎꠥꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠞꠣꠄ ꠇꠦꠘꠦ?” ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠃꠑꠤꠀ ꠔꠥꠚꠣꠘ ꠀꠞ ꠀꠅꠞꠞꠦ ꠗꠝꠇ ꠖꠤꠟꠣ, ꠔꠦꠃ ꠢꠇ꠆ꠇꠟꠔꠣ ꠕꠤꠞ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT8_27","070_8_27","MAT","8","27","27","ꠁ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠀꠍꠟꠦ ꠇꠦ? ꠔꠥꠚꠣꠘ ꠀꠞ ꠀꠅꠞꠦꠅ ꠖꠦꠈꠤ ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠦ!” ");
INSERT INTO syls_vpl VALUES ("MT8_28","070_8_28","MAT","8","28","28","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣ ꠀꠅꠞ ꠙꠣꠠꠤ ꠖꠤꠀ ꠎꠦꠞꠣꠍꠤꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠀꠁꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠜꠥꠔꠦ ꠗꠞꠣ ꠖꠥꠁꠎꠘ ꠝꠣꠘꠥꠡ ꠇꠛꠞꠡ꠆ꠕꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ। ꠔꠣꠞꠣ ꠅꠟꠣ ꠎꠘꠥꠘ ꠙꠣꠉꠟ ꠀꠍꠟꠣ ꠎꠦꠘ, ꠔꠣꠞꠣꠞꠦ ꠒꠞꠣꠁꠀ ꠇꠦꠃ ꠅꠃ ꠙꠕꠦꠖꠤ ꠎꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_29","070_8_29","MAT","8","29","29","ꠔꠣꠞꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟ, “ꠅ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠙꠘꠣꠞ ꠇꠤꠔꠣ ꠖꠞꠇꠣꠞ? ꠡꠝꠄ ꠅꠀꠞ ꠀꠉꠦꠃ ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠍꠣꠔꠣꠘꠤꠔ ꠀꠁꠌ꠆ꠍꠂꠘ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT8_30","070_8_30","MAT","8","30","30","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠖꠥꠞꠁ ꠛꠠ ꠄꠇ ꠡꠥꠅꠞꠞ ꠙꠣꠟꠦ ꠈꠣꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_31","070_8_31","MAT","8","31","31","ꠜꠥꠔ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟ, “ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠔꠦ ꠌꠣꠁꠟꠦ, ꠅꠃ ꠡꠥꠅꠞꠞ ꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠙꠣꠑꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT8_32","070_8_32","MAT","8","32","32","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠁꠎꠣꠎꠔ ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠉꠤꠀ ꠅꠃ ꠡꠥꠅꠞꠞ ꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠁꠉꠦꠟ। ꠀꠞ ꠡꠥꠅꠞꠞ ꠙꠣꠟꠦ ꠀꠅꠞꠞ ꠈꠣꠠꠣ ꠌꠞꠦꠖꠤ ꠈꠥꠛ ꠎꠥꠞꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠛꠥꠠꠤꠀ ꠝꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_33","070_8_33","MAT","8","33","33","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠡꠥꠅꠞꠞ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠉꠣꠃꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟꠣ, ꠄꠞꠟꠉꠦ ꠅꠃ ꠜꠥꠔꠦ ꠗꠞꠣ ꠝꠣꠘꠡꠞ ꠇꠕꠣꠅ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT8_34","070_8_34","MAT","8","34","34","ꠁ ꠊꠐꠘꠣ ꠢꠥꠘꠤꠀ ꠉꠣꠃꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠀꠁꠟꠣ। ꠔꠣꠘ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠀꠝꠞꠣꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠎꠣꠃꠇ꠆ꠇꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT9_1","070_9_1","MAT","9","1","1","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠘꠣꠅꠅ ꠇꠞꠤ ꠀꠅꠞ ꠙꠣꠠꠤ ꠖꠤꠀ ꠘꠤꠎꠞ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_2","070_9_2","MAT","9","2","2","ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠇꠄꠎꠘ ꠝꠣꠘꠡꠦ ꠄꠇꠎꠘ ꠅꠛꠡ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠙꠟꠅꠖꠤ ꠛꠁꠀ ꠟꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ। ꠔꠣꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠟ ꠖꠦꠈꠤꠀ ꠁꠍꠣꠄ ꠅꠃ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠇꠁꠟꠣ, “ꠝꠘꠅ ꠛꠟ ꠞꠣꠈꠅ ꠞꠦ ꠙꠥꠔ, ꠔꠥꠝꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT9_3","070_9_3","MAT","9","3","3","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠇꠄꠎꠘ ꠝꠃꠟꠣꠘꠣꠄ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, “ꠁ ꠛꠦꠐꠣꠄ ꠔ ꠡꠤꠞꠤꠇꠤ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT9_4","070_9_4","MAT","9","4","4","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠜꠣꠛ ꠛꠥꠎꠤꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠇꠦꠘꠦ ꠁꠟꠣ ꠇꠥ-ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠣ? ");
INSERT INTO syls_vpl VALUES ("MT9_5","070_9_5","MAT","9","5","5","ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠈꠣꠘ ꠇꠅꠀ ꠡꠥꠎꠣ, ꠔꠥꠝꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠁꠟꠣꠝ, ꠘꠣ ꠃꠑꠅ, ꠔꠥꠝꠣꠞ ꠛꠤꠍꠘꠣ ꠟꠁꠀ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ? ");
INSERT INTO syls_vpl VALUES ("MT9_6","070_9_6","MAT","9","6","6","ꠔꠦ ꠅꠈꠘ ꠀꠙꠘꠣꠞꠣ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁ ꠖꠥꠘꠤꠀꠔ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠈꠦꠝꠔꠣ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠀꠍꠦ।” ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ ꠃꠑꠅ, ꠔꠥꠝꠣꠞ ꠈꠦꠔꠣ-ꠛꠣꠟꠤꠡ ꠟꠁꠀ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT9_7","070_9_7","MAT","9","7","7","ꠇꠁꠔꠦꠃ ꠢꠤ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣ ꠃꠑꠤꠀ ꠔꠣꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT9_8","070_9_8","MAT","9","8","8","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠅꠔ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠂꠘ ꠇꠞꠤ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_9","070_9_9","MAT","9","9","9","ꠁꠍꠣꠄ ꠙꠕꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠖꠦꠈꠟꠣ, ꠝꠕꠤ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠣꠞ ꠅꠚꠤꠡꠅ ꠛꠁꠞꠁꠍꠂꠘ। ꠖꠦꠈꠤꠀ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠅ।” ꠔꠦꠃ ꠝꠕꠤ ꠃꠑꠤꠀ ꠁꠍꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_10","070_9_10","MAT","9","10","10","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠝꠕꠤꠞ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠈꠣꠅꠀꠔ ꠛꠁꠟꠣ। ꠔꠣꠘ ꠟꠉꠦ ꠛꠃꠔ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠅ ꠈꠣꠘꠤꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_11","070_9_11","MAT","9","11","11","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠝꠥꠞꠡꠤꠖꠦ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠀꠞ ꠈꠛꠤꠍ ꠅꠇꠟꠞ ꠟꠉꠦ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠂꠘ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT9_12","070_9_12","MAT","9","12","12","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠜꠣꠟꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠇꠛꠤꠞꠣꠎ ꠟꠣꠉꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠛꠦꠝꠣꠞꠤꠞ ꠟꠣꠉꠤ ꠔ ꠟꠣꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("MT9_13","070_9_13","MAT","9","13","13","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ‘ꠀꠝꠤ ꠇꠥꠘꠥ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠖꠄꠀ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁ।’ ꠔꠦ ꠅꠃ ꠀꠄꠀꠔꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ, ꠅꠈꠣꠘ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠝꠘꠅ ꠞꠣꠈꠛꠣ, ꠀꠝꠤ ꠇꠥꠘꠥ ꠙꠞꠦꠎꠉꠣꠞꠞꠦ ꠖꠣꠅꠔ ꠖꠦꠅꠀꠔ ꠀꠁꠍꠤ ꠘꠣ, ꠈꠣꠟꠤ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞꠦꠃ ꠖꠣꠅꠔ ꠖꠤꠔꠣꠝ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT9_14","070_9_14","MAT","9","14","14","ꠄꠞꠛꠣꠖꠦ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠀꠞ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠝꠣꠘꠡꠦ ꠢꠣꠝꠦꠡꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠤ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠞꠥꠎꠣ ꠞꠣꠈꠂꠘ ꠘꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT9_15","070_9_15","MAT","9","15","15","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠘꠡꠣ ꠟꠉꠦ ꠕꠣꠇꠟꠦ ꠟꠉꠞ ꠛꠂꠞꠣꠔꠤꠞꠦ ꠇꠥꠘꠥ ꠖꠥꠈ ꠖꠦꠅꠀ ꠎꠣꠄ ꠘꠤ? ꠖꠦꠈꠛꠣꠘꠦ, ꠁꠟꠣ ꠡꠝꠄ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠘꠡꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟ ꠅꠁꠎꠤꠛ, ꠢꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_16","070_9_16","MAT","9","16","16","“ꠀꠘꠣ-ꠗꠅꠀ ꠘꠄꠀ ꠇꠣꠙꠠꠞ ꠐꠥꠇꠞꠣꠖꠤ ꠇꠦꠃ ꠙꠥꠞꠣꠘ ꠇꠥꠞ꠆ꠔꠣꠔ ꠔꠣꠟꠤ ꠖꠦꠄ ꠘꠣ। ꠁꠟꠣ ꠇꠞꠟꠦ ꠗꠁꠀ ꠢꠣꠞꠟꠦ ꠙꠥꠞꠣꠘ ꠇꠣꠙꠠ ꠕꠣꠇꠤ ꠘꠄꠀ ꠔꠣꠟꠤ ꠈꠥꠍ ꠅꠁꠀ ꠍꠤꠠꠤꠎꠣꠄ, ꠀꠞ ꠍꠤꠠꠣꠈꠣꠘ ꠀꠞꠅ ꠛꠠ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT9_17","070_9_17","MAT","9","17","17","ꠙꠥꠞꠣꠘ ꠌꠣꠝꠠꠣꠞ ꠕꠟꠤꠔ ꠇꠦꠃ ꠘꠄꠀ ꠀꠋꠉꠥꠞꠞ ꠞꠡ ꠜꠞꠦ ꠘꠣ। ꠜꠞꠟꠦ ꠅꠃ ꠔꠣꠎꠣ ꠞꠡꠞ ꠚꠣꠚꠦ ꠕꠟꠤ ꠚꠣꠐꠤꠀ ꠞꠡ ꠀꠞ ꠕꠟꠤ ꠖꠥꠁꠅꠔꠣ ꠛꠞꠛꠣꠖ ꠅꠄ। ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠔꠣꠎꠣ ꠞꠡ ꠘꠄꠀ ꠕꠟꠤꠔ ꠕꠂꠘ। ꠔꠦꠃ ꠖꠥꠁꠅꠔꠣ ꠛꠣꠌꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT9_18","070_9_18","MAT","9","18","18","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠅꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠘꠦꠔꠣ ꠀꠁꠀ ꠔꠣꠘ ꠙꠣꠅ-ꠅ ꠙꠠꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠙꠥꠠꠤꠉꠥ ꠅꠃ ꠝꠣꠔ꠆ꠞ ꠝꠣꠞꠣ ꠉꠦꠍꠦ। ꠔꠦ ꠀꠙꠘꠦ ꠀꠁꠀ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠔꠣꠁꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠟꠦꠃ ꠙꠥꠠꠤꠉꠥ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT9_19","070_9_19","MAT","9","19","19","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠄꠘ ꠟꠉꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_20","070_9_20","MAT","9","20","20","ꠎꠣꠅꠀꠞ ꠙꠕꠦ ꠄꠇ ꠛꠦꠐꠤꠄ ꠈꠞꠦꠖꠤ ꠀꠁꠀ ꠁꠍꠣꠞ ꠌꠣꠖ꠆ꠖꠞꠞ ꠇꠥꠘꠣꠔ ꠍꠁꠟ। ꠛꠣꠞꠅ ꠛꠍꠞ ꠗꠞꠤ ꠁ ꠛꠦꠐꠤꠞ ꠛꠦꠐꠤꠀꠞꠣ ꠛꠦꠝꠣꠞꠞ ꠟꠃ ꠎꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("MT9_21","070_9_21","MAT","9","21","21","ꠛꠦꠐꠤꠞ ꠄꠇꠤꠘ ꠀꠍꠤꠟ, ꠔꠣꠁ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠔꠣꠘ ꠌꠣꠖ꠆ꠖꠞꠞ ꠇꠥꠘꠣꠔ ꠍꠁꠟꠤꠔ ꠙꠣꠞꠦ, ꠔꠦ ꠛꠦꠝꠣꠞ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT9_22","070_9_22","MAT","9","22","22","ꠁꠍꠣꠄ ꠐꠦꠞ ꠙꠣꠁꠀ ꠈꠞꠦꠖꠤ ꠌꠣꠁꠀ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ ꠉ ꠝꠣꠁ, ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠅꠁꠟꠣꠄ।” ꠅꠈꠣꠘ ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦ ꠛꠦꠐꠤ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT9_23","070_9_23","MAT","9","23","23","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣ ꠢꠃ ꠘꠦꠔꠣꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠀꠡ꠆ꠔꠣ ꠛꠣꠠꠤꠞ ꠝꠣꠘꠡꠦ ꠢꠂ-ꠢꠥꠟ꠆ꠟꠣ ꠇꠞꠞꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠡꠝꠣꠎꠞ ꠞꠦꠅꠀꠎ ꠝꠣꠚꠤꠇ ꠝꠞꠣ ꠛꠣꠠꠤꠔ ꠛꠣꠡꠤ-ꠛꠣꠎꠘꠣ ꠛꠣꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_24","070_9_24","MAT","9","24","24","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠊꠞ ꠕꠣꠇꠤ ꠛꠣꠞꠦ ꠎꠣꠅ। ꠙꠥꠠꠤꠉꠥ ꠝꠞꠍꠦ ꠘꠣ, ꠔꠣꠁ ꠔ ꠊꠥꠝꠣꠞ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠟꠁꠀ ꠀꠡꠣ-ꠀꠡꠤ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_25","070_9_25","MAT","9","25","25","ꠝꠣꠘꠡꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠁꠘ ꠉꠤꠀ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠙꠥꠠꠤꠞ ꠀꠔꠅ ꠗꠞꠟꠣ, ꠗꠞꠔꠦꠃ ꠔꠣꠁ ꠃꠑꠤꠀ ꠛꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT9_26","070_9_26","MAT","9","26","26","ꠀꠞ ꠁ ꠊꠐꠘꠣꠞ ꠇꠕꠣ ꠅꠃ ꠄꠟꠣꠇꠣꠞ ꠢꠇꠟꠛꠣꠄ ꠞꠐꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT9_27","070_9_27","MAT","9","27","27","ꠁꠍꠣ ꠅꠃ ꠘꠦꠔꠣꠞ ꠛꠣꠠꠤ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠖꠥꠁꠎꠘ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟ। ꠔꠣꠞꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟ, “ꠅ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ, ꠀꠝꠞꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT9_28","070_9_28","MAT","9","28","28","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠁꠀ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠟꠦ, ꠢꠃ ꠖꠥꠁꠅ ꠀꠘ꠆ꠖꠣꠅ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ। ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠞꠣꠄ ꠘꠤ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠝꠥ?” ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠎꠤꠅꠄ ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦꠃ ꠙꠣꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT9_29","070_9_29","MAT","9","29","29","ꠔꠦꠃ ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠌꠃꠈ ꠀꠔꠣꠁ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠄꠇꠤꠘ ꠇꠞꠍ, ꠅꠟꠣꠃ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MT9_30","070_9_30","MAT","9","30","30","ꠅꠈꠣꠘ ꠇꠁꠔꠦꠃ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠈꠥꠛ ꠖꠠꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠁꠔꠣ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT9_31","070_9_31","MAT","9","31","31","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠛꠣꠞ ꠅꠁꠀ ꠉꠤꠀ ꠀꠡ-ꠙꠣꠡ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠔꠣꠘ ꠁ ꠈꠛꠞ ꠞꠐꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT9_32","070_9_32","MAT","9","32","32","ꠢꠃ ꠖꠥꠁꠅ ꠀꠘ꠆ꠖꠣ ꠎꠦꠛꠟꠣ ꠜꠣꠟꠣ ꠅꠁꠀ ꠎꠣꠁꠞꠣꠉꠤ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠘꠡꠦ ꠜꠥꠔꠦ ꠗꠞꠣ ꠄꠇ ꠛꠥꠛꠣ ꠛꠦꠐꠣꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT9_33","070_9_33","MAT","9","33","33","ꠔꠣꠁꠘ ꠁ ꠛꠦꠐꠣꠞ ꠜꠥꠔ ꠍꠣꠠꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠔꠣꠞ ꠎꠛꠣꠘ ꠈꠥꠟꠤꠉꠦꠟ, ꠢꠦ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠟ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠀꠡ꠆ꠔꠣ ꠁꠍꠞꠣꠁꠟ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠇꠣꠝ ꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠖꠦꠈꠍꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT9_34","070_9_34","MAT","9","34","34","ꠅꠁꠟꠦ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠁꠉꠤꠄ ꠔ ꠜꠥꠔꠞ ꠛꠣꠖꠡꠣꠞ ꠡꠣꠁꠎ꠆ꠎꠄ ꠜꠥꠔ ꠍꠣꠠꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT9_35","070_9_35","MAT","9","35","35","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠉꠣꠃꠄ ꠉꠣꠃꠄ ꠀꠞ ꠐꠣꠃꠘꠦ ꠐꠣꠃꠘꠦ ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠝꠍꠤꠖꠅ ꠢꠣꠝꠣꠁꠀ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_36","070_9_36","MAT","9","36","36","ꠅꠃ ꠡꠝꠄ ꠝꠣꠘꠡꠞ ꠜꠤꠠ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠈꠥꠛ ꠖꠥꠈ ꠟꠣꠉꠟ, ꠁꠔꠣ ꠝꠣꠘꠥꠡ ꠔ ꠀ-ꠞꠣꠈꠣꠟꠤ ꠝꠦꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠚꠣꠘꠣ ꠟꠣꠉꠤ ꠊꠥꠞꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT9_37","070_9_37","MAT","9","37","37","ꠔꠦꠃ ꠁꠍꠣꠄ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠎꠝꠤꠘꠅ ꠔ ꠚꠡꠟ ꠛꠃꠔ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠇꠣꠝꠟꠣ ꠈꠥꠛ ꠇꠝ। ");
INSERT INTO syls_vpl VALUES ("MT9_38","070_9_38","MAT","9","38","38","ꠄꠞꠟꠣꠉꠤ ꠎꠝꠤꠘꠞ ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍꠦ ꠖꠥꠀ ꠇꠞꠅ, ꠔꠣꠘ ꠚꠡꠟ ꠔꠥꠟꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠇꠣꠝꠟꠣ ꠙꠣꠑꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT10_1","070_10_1","MAT","10","1","1","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠒꠣꠇꠣꠁꠀ ꠀꠘꠟꠣ, ꠀꠘꠤꠀ ꠎꠤꠘ-ꠜꠥꠔ ꠍꠣꠠꠣꠘꠤ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT10_2","070_10_2","MAT","10","2","2","ꠅꠃ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠁꠟꠣ, ꠍꠣꠁꠝꠘ ꠃꠞꠚꠦ ꠙꠤꠔꠞ ꠀꠞ ꠔꠣꠘ ꠜꠣꠁ ꠀꠘ꠆ꠖꠞꠤꠀꠍ, ꠎꠤꠛꠥꠖꠤꠀꠞ ꠙꠥꠀꠂꠘ ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ, ꠚꠤꠟꠤꠚ ꠀꠞ ꠛꠞ꠆ꠕꠟꠝꠄ, ");
INSERT INTO syls_vpl VALUES ("MT10_3","070_10_3","MAT","10","3","3","ꠕꠥꠝꠣꠍ ꠀꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠝꠕꠤ, ꠀꠟꠚꠤꠞ ꠙꠥꠀ ꠁꠀꠇꠥꠛ ꠀꠞ ꠕꠖ꠆ꠖꠦ, ");
INSERT INTO syls_vpl VALUES ("MT10_4","070_10_4","MAT","10","4","4","ꠝꠥꠇ꠆ꠔꠤꠎꠥꠖ꠆ꠖꠣ ꠍꠣꠁꠝꠘ ꠀꠞ ꠁꠢꠥꠖꠣ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔ। ꠅꠃ ꠁꠢꠥꠖꠣꠄ ꠛꠣꠖꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠁꠍꠣꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT10_5","070_10_5","MAT","10","5","5","ꠅꠃ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠁꠍꠣꠄ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠇꠁꠟꠣ, “ꠔꠥꠝꠤꠔꠣꠁꠘ ꠔꠛꠟꠤꠉꠅ ꠎꠣꠅ, ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠛꠤꠗꠞ꠆ꠝꠤꠞ ꠉꠦꠍꠦ ꠛꠣ ꠡꠝꠞꠤꠀ ꠎꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠉꠣꠃꠔ ꠎꠣꠁꠅ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("MT10_6","070_10_6","MAT","10","6","6","ꠈꠣꠟꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠞꠣꠁꠟ ꠝꠦꠠꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("MT10_7","070_10_7","MAT","10","7","7","ꠎꠣꠅꠀꠞ ꠙꠕꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠤ ꠇꠞꠤ ꠎꠣꠁꠅ, ꠇꠁꠅ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT10_8","070_10_8","MAT","10","8","8","ꠀꠞ ꠔꠥꠝꠞꠣ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠤꠅ, ꠝꠞꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠅ, ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠤꠅ, ꠀꠞ ꠎꠤꠘ-ꠜꠥꠔ ꠍꠣꠠꠣꠁꠅ। ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠛꠤꠘꠣ ꠐꠦꠇꠣꠄ ꠙꠣꠁꠍ, ꠅꠃꠟꠣ ꠛꠤꠘꠣ ꠐꠦꠇꠣꠄꠃ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("MT10_9","070_10_9","MAT","10","9","9","ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠟꠉꠦ ꠇꠞꠤ ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠞ ꠕꠟꠤ, ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠛꠣ ꠄꠇꠐꠣ ꠡꠤꠇꠤꠅ ꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT10_10","070_10_10","MAT","10","10","10","ꠔꠥꠝꠞꠣ ꠙꠕꠞ ꠟꠣꠉꠤ ꠟꠣꠑꠤ, ꠉꠣꠁꠐ-ꠛꠥꠍꠇꠤ, ꠎꠥꠔꠣ, ꠛꠣ ꠖꠥꠁꠐꠣ ꠇꠥꠞ꠆ꠔꠣꠅ ꠟꠉꠦ ꠘꠤꠅ ꠘꠣ। ꠎꠦ ꠎꠘꠦ ꠇꠣꠝ ꠇꠞꠦ, ꠢꠦ ꠈꠣꠅꠀ-ꠚꠤꠘ꠆ꠖꠣ ꠙꠣꠅꠀꠞ ꠎꠥꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("MT10_11","070_10_11","MAT","10","11","11","ꠔꠥꠝꠞꠣ ꠎꠦ ꠉꠣꠃꠔ ꠢꠣꠝꠣꠁꠛꠣꠄ, ꠅꠃ ꠉꠣꠃꠞ ꠄꠇꠎꠘ ꠎꠁꠉ꠆ꠉ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠛꠣꠞ ꠇꠞꠤꠅ, ꠁ ꠉꠣꠃ ꠍꠣꠠꠤꠀ ꠎꠣꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠄꠘ ꠛꠣꠠꠤꠔꠃ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MT10_12","070_10_12","MAT","10","12","12","ꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠘꠤꠞ ꠛꠣꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("MT10_13","070_10_13","MAT","10","13","13","ꠁ ꠛꠣꠠꠤ ꠎꠥꠖꠤ ꠍꠣꠟꠣꠝ ꠙꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠅꠄ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠦꠅꠀ ꠅꠃ ꠡꠣꠘ꠆ꠔꠤ ꠔꠣꠞꠣ ꠙꠣꠁꠛꠣ, ꠀꠞ ꠎꠥꠇꠣ ꠘꠣ ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠡꠣꠘ꠆ꠔꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦꠃ ꠚꠤꠞꠤꠀ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT10_14","070_10_14","MAT","10","14","14","ꠁ ꠎꠣꠉꠣꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠘꠣ ꠇꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣ ꠘꠣ ꠢꠥꠘꠦ, ꠔꠦ ꠁ ꠛꠣꠠꠤ ꠛꠣ ꠉꠣꠃ ꠕꠣꠇꠤ ꠛꠣꠞꠘꠤꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅꠞ ꠗꠥꠁꠟ ꠏꠣꠠꠤꠀ ꠚꠣꠟꠣꠁꠀ ꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MT10_15","070_10_15","MAT","10","15","15","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠢꠣꠡꠞꠞ ꠖꠤꠘ ꠅꠃ ꠉꠣꠃꠞ ꠖꠡꠣ ꠕꠣꠇꠤ, ꠢꠃ ꠟꠣꠘ꠆ꠘꠔꠤ ꠍꠣꠖꠥꠝ ꠀꠞ ꠀꠝꠥꠞꠣ ꠐꠣꠃꠘꠞ ꠖꠡꠣ ꠛꠃꠔ ꠜꠣꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT10_16","070_10_16","MAT","10","16","16","“ꠢꠥꠘꠅ, ꠞꠣꠁꠇ꠆ꠇꠡ ꠛꠣꠊꠞ ꠍꠣꠝꠘꠦ ꠝꠦꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠞꠣꠝ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠢꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠌꠣꠟꠣꠇ-ꠌꠔꠥꠞ ꠀꠞ ꠙꠣꠞꠅ ꠙꠣꠈꠤꠞ ꠟꠣꠈꠣꠘ ꠡꠞꠟ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("MT10_17","070_10_17","MAT","10","17","17","ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠗꠞꠤꠀ ꠀꠖꠣꠟꠔꠅ ꠡꠝꠎꠣꠁꠛꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠝꠍꠤꠖꠅ ꠘꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT10_18","070_10_18","MAT","10","18","18","ꠀꠝꠣꠞ ꠘꠣꠝ ꠟꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣꠞ ꠍꠣꠝꠘꠦ ꠘꠦꠅꠀ ꠅꠁꠛ। ꠔꠥꠝꠞꠣ ꠄꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠞ ꠛꠤꠗꠞ꠆ꠝꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT10_19","070_10_19","MAT","10","19","19","ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠗꠞꠣꠁ ꠖꠤꠛ, ꠅꠃ ꠡꠝꠄ ꠇꠤꠔꠣ ꠝꠣꠔꠔꠣꠄ ꠛꠣ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠄ, ꠁꠔꠣ ꠟꠁꠀ ꠇꠥꠘꠥ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠢꠤꠇꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT10_20","070_10_20","MAT","10","20","20","ꠀꠍꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈꠖꠤ ꠎꠦꠘ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠝꠣꠔꠛꠣꠄ, ꠁꠈꠣꠘ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚꠞ ꠎꠦ ꠞꠥꠢꠥ ꠔꠥꠝꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠦ, ꠢꠃ ꠞꠥꠢꠦꠃ ꠁꠔꠣꠞ ꠎꠥꠀꠙ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT10_21","070_10_21","MAT","10","21","21","“ꠜꠣꠁꠄ ꠜꠣꠁꠞꠦ ꠀꠞ ꠛꠣꠚꠦ ꠙꠥꠀꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠗꠞꠣꠁ ꠖꠤꠛ। ꠙꠥꠀ-ꠙꠥꠠꠤꠄꠅ ꠔꠣꠞꠣꠞ ꠝꠣ-ꠛꠣꠚꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT10_22","070_10_22","MAT","10","22","22","ꠀꠝꠣꠞ ꠇꠣꠞꠘꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠛ, ꠅꠁꠟꠦ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠦ ꠐꠤꠇꠤꠀ ꠞꠁꠛ, ꠢꠦ-ꠃ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT10_23","070_10_23","MAT","10","23","23","ꠇꠥꠘꠥ ꠉꠣꠃꠞ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠟꠦ, ꠁ ꠉꠣꠃ ꠍꠣꠠꠤꠀ ꠅꠁꠘ꠆ꠘ ꠉꠣꠃꠔ ꠎꠣꠁꠅꠉꠤ। ꠢꠥꠘꠅ, ꠀꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠁꠍꠞꠣꠁꠟ ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟ ꠐꠣꠃꠘ ꠀꠞ ꠉꠣꠃꠔ ꠔꠥꠝꠞꠣꠞ ꠔꠛꠟꠤꠉ ꠡꠦꠡ ꠅꠀꠞ ꠀꠉꠦꠃ ꠛꠤꠘ-ꠀꠖꠝ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT10_24","070_10_24","MAT","10","24","24","“ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠃꠡ꠆ꠔꠣꠖ ꠕꠣꠇꠤ ꠡꠣꠉꠞꠤꠖ ꠛꠠ ꠘꠣꠄ, ꠀꠞ ꠝꠥꠘꠤꠛ ꠕꠣꠇꠤ ꠔꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠠ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT10_25","070_10_25","MAT","10","25","25","ꠔꠦ ꠡꠣꠉꠞꠤꠖ ꠔꠣꠞ ꠃꠡ꠆ꠔꠣꠖꠞ ꠡꠝꠣꠘ, ꠀꠞ ꠉꠥꠟꠣꠝ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠡꠝꠣꠘ ꠅꠀꠃ ꠎꠕꠦꠡ꠆ꠐ। ꠢꠥꠘꠞꠣꠄ ꠘꠤ, ꠊꠞꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠎꠦꠛꠟꠣ ꠜꠥꠔꠞ ꠛꠣꠖꠡꠣ ꠛꠦꠟ-ꠍꠛꠥꠟ ꠇꠁꠞꠣ, ꠔꠦ ꠊꠞꠞ ꠛꠣꠇꠤ ꠢꠇꠟꠞꠦ ꠔꠣꠞꠣ ꠀꠞꠅ ꠇꠔꠔꠣ ꠇꠁꠛꠣ! ");
INSERT INTO syls_vpl VALUES ("MT10_26","070_10_26","MAT","10","26","26","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠁꠟꠣ ꠉꠥꠙꠘ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ ꠎꠦꠔꠣ ꠎꠣꠁꠞ ꠅꠁꠔ ꠘꠣꠄ। ꠁꠟꠣ ꠟꠥꠇꠣꠁꠟꠅ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ ꠎꠦꠔꠣ ꠇꠦꠃ ꠢꠥꠘꠔ ꠘꠣꠄ ꠛꠣ ꠎꠣꠘꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT10_27","070_10_27","MAT","10","27","27","ꠀꠝꠤ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠤ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠚꠞꠞ ꠝꠣꠎꠦ ꠇꠁꠅ। ꠎꠦꠔꠣ ꠇꠣꠘꠦ ꠇꠣꠘꠦ ꠢꠥꠘꠍ, ꠁꠔꠣ ꠍꠣꠐꠞ ꠃꠙꠞꠦ ꠉꠤꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠄꠟꠣꠘ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("MT10_28","070_10_28","MAT","10","28","28","ꠎꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠇꠣꠄꠀꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠔ ꠙꠣꠞꠦ, ꠅꠁꠟꠦ ꠞꠥꠢꠥꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠎꠦꠁꠘ ꠇꠣꠄꠀ ꠀꠞ ꠞꠥꠢꠥ ꠖꠥꠁꠅꠔꠣꠞꠦ ꠖꠥꠎꠈꠅ ꠎꠣꠟꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠈꠣꠟꠤ ꠔꠣꠘꠞꠦꠃ ꠒꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MT10_29","070_10_29","MAT","10","29","29","ꠢꠥꠘꠅ, ꠖꠥꠁꠐꠣ ꠌꠠꠣ ꠙꠣꠈꠤ ꠈꠣꠟꠤ ꠖꠥꠁ ꠐꠦꠇꠣꠄ ꠛꠤꠇꠦ ꠘꠣ ꠘꠤ? ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠘꠣ ꠅꠁꠟꠦ ꠅꠔꠣ ꠄꠉꠥ ꠌꠠꠣ ꠙꠣꠈꠤꠅ ꠝꠣꠐꠤꠔ ꠙꠠꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT10_30","070_10_30","MAT","10","30","30","ꠎꠣꠘ ꠔ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟꠉꠦꠍꠣꠁꠘꠅ ꠉꠘꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT10_31","070_10_31","MAT","10","31","31","ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠖꠣꠝ ꠔ ꠛꠃꠔ ꠌꠠꠣ ꠕꠣꠇꠤꠅ ꠛꠦꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("MT10_32","070_10_32","MAT","10","32","32","“ꠡꠝꠣꠎꠞ ꠍꠣꠝꠘꠦ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠀꠝꠤꠅ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("MT10_33","070_10_33","MAT","10","33","33","ꠅꠁꠟꠦ ꠎꠦ ꠝꠣꠘꠡꠦ ꠡꠝꠣꠎꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠛ, ꠀꠝꠤꠅ ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("MT10_34","070_10_34","MAT","10","34","34","“ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠇꠞꠞꠣꠄ ꠘꠤ, ꠀꠝꠤ ꠖꠥꠘꠤꠀꠔ ꠡꠣꠘ꠆ꠔꠤ ꠖꠤꠔꠣꠝ ꠀꠁꠍꠤ? ꠘꠣ, ꠝꠥꠐꠦꠃ ꠘꠣꠄ, ꠀꠝꠤ ꠔ ꠖꠥꠘꠤꠀꠔ ꠄꠇ ꠝꠔꠜꠦꠖ ꠟꠣꠉꠣꠘꠤꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("MT10_35","070_10_35","MAT","10","35","35","ꠀꠝꠤ ꠛꠣꠚꠦ-ꠙꠥꠀꠄ, ꠝꠣꠄ-ꠙꠥꠠꠤꠄ, ꠀꠞ ꠢꠠꠤꠄ-ꠛꠃꠄ ꠛꠤꠛꠣꠖ ꠟꠣꠉꠣꠘꠤꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("MT10_36","070_10_36","MAT","10","36","36","ꠝꠣꠘꠡꠞ ꠘꠤꠎꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠎꠘꠦꠃ ꠔꠣꠞ ꠟꠉꠦ ꠖꠥꠡꠝꠘꠤ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("MT10_37","070_10_37","MAT","10","37","37","“ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠝꠣ ꠕꠣꠇꠤ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠢꠦ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣ ꠕꠣꠇꠤ ꠔꠣꠞ ꠙꠥꠀꠞꠦ ꠛꠣ ꠔꠣꠞ ꠙꠥꠠꠤꠞꠦ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠢꠦ-ꠅ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔꠞ ꠎꠥꠇꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT10_38","070_10_38","MAT","10","38","38","ꠎꠦ ꠎꠘꠦ ꠘꠤꠎꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛ ꠛꠁꠀ ꠟꠁꠀ ꠀꠝꠣꠞ ꠈꠞꠦ ꠘꠣ ꠀꠄ, ꠢꠦ-ꠅ ꠀꠝꠣꠞ ꠎꠥꠇꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT10_39","070_10_39","MAT","10","39","39","ꠎꠦ ꠎꠘꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ ꠌꠣꠄ, ꠢꠦ ꠔꠣꠞ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠥꠀꠁꠛ। ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣꠄ, ꠢꠦ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT10_40","070_10_40","MAT","10","40","40","“ꠎꠦ ꠎꠘꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠀꠝꠣꠞꠦꠃ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠀꠞ ꠎꠦ ꠀꠝꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠀꠍꠟꠦ ꠢꠃ ꠀꠟ꠆ꠟꠣꠞꠦꠃ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT10_41","070_10_41","MAT","10","41","41","ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠘꠛꠤꠞꠦ ꠘꠛꠤ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠔꠦ ꠅꠃ ꠘꠛꠤꠄ ꠎꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛꠣ, ꠢꠦ-ꠅ ꠅꠃ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛ। ꠇꠥꠘꠥ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠔꠦ ꠅꠃ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠝꠣꠘꠡꠦ ꠎꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛꠣ, ꠢꠦ-ꠅ ꠅꠃ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT10_42","070_10_42","MAT","10","42","42","ꠀꠞ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠎꠣꠘꠤꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇ ꠘꠉꠁꠘ꠆ꠘ ꠎꠘꠞꠦꠅ ꠄꠇ ꠉꠦꠟꠣꠡ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠄ, ꠔꠦ ꠢꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠄꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠕꠣꠇꠤ ꠛꠣꠖ ꠙꠠꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT11_1","070_11_1","MAT","11","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠅꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠁꠘ ꠉꠣꠃꠄ ꠉꠣꠃꠄ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠀꠞ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT11_2","070_11_2","MAT","11","2","2","ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠎꠦꠟꠅ ꠕꠣꠇꠤ ꠎꠦꠛꠟꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠣꠝꠞ ꠇꠕꠣ ꠢꠥꠘꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠇꠄꠎꠘ ꠡꠣꠉꠞꠤꠖꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ ꠈꠛꠞ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ। ꠄꠞꠣ ꠉꠤꠀ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT11_3","070_11_3","MAT","11","3","3","“ꠢꠥꠎꠥꠞꠦ ꠇꠁꠍꠂꠘ, ꠎꠦꠁꠘ ꠀꠁꠛꠣꠞ ꠇꠕꠣ ꠀꠍꠤꠟ, ꠀꠙꠘꠦꠃ ꠢꠦꠁꠘ ꠘꠤ? ꠘꠣ ꠀꠝꠞꠣ ꠀꠞ ꠇꠦꠃꠞꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("MT11_4","070_11_4","MAT","11","4","4","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠅꠘꠅ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠎꠦꠔꠣ ꠖꠦꠈꠍ ꠀꠞ ꠢꠥꠘꠍ, ꠅꠔꠣ ꠉꠤꠀ ꠄꠢꠤꠀꠞꠦ ꠇꠅ। ");
INSERT INTO syls_vpl VALUES ("MT11_5","070_11_5","MAT","11","5","5","ꠔꠣꠘꠞꠦ ꠇꠁꠅ, ꠀꠘ꠆ꠖꠣ ꠝꠣꠘꠡꠦ ꠌꠃꠈꠦ ꠖꠦꠈꠞꠣ, ꠟꠦꠋꠠꠣꠄꠅ ꠀꠐꠤꠞꠣ, ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤ ꠜꠣꠟꠣ ꠅꠁꠞꠣ, ꠈꠣꠟꠥꠀ ꠅꠇꠟꠦ ꠢꠥꠘꠞꠣ, ꠝꠞꠣ ꠝꠣꠘꠥꠡ ꠎꠤꠔꠣ ꠅꠁꠞꠣ, ꠀꠞ ꠉꠞꠤꠛ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("MT11_6","070_11_6","MAT","11","6","6","ꠢꠥꠘꠅ, ꠢꠦ-ꠃ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ, ꠎꠣꠞ ꠖꠤꠟꠅ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘꠥ ꠛꠣꠗꠣ ꠀꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT11_7","070_11_7","MAT","11","7","7","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟ ꠎꠣꠁꠞꠣꠉꠤ, ꠅꠃ ꠡꠝꠄ ꠄꠢꠤꠀꠞ ꠛꠦꠙꠣꠞꠦ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠝꠞꠥꠜꠥꠝꠤꠔ ꠇꠤꠔꠣ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ? ꠛꠣꠔꠣꠡ ꠀꠁꠟꠦ ꠎꠦꠔꠣ ꠘꠟ-ꠈꠣꠉꠠꠣꠄ ꠟꠠꠦ, ꠅꠔꠣ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT11_8","070_11_8","MAT","11","8","8","ꠘꠣ, ꠇꠤꠔꠣ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ? ꠡꠥꠘ꠆ꠖꠞ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠘ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠘꠤ? ꠀꠍꠟꠦ, ꠎꠦꠞꠣ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠂꠘ, ꠔꠣꠞꠣ ꠔ ꠞꠣꠎꠛꠣꠠꠤꠔ ꠕꠣꠇꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT11_9","070_11_9","MAT","11","9","9","ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ? ꠇꠥꠘꠥ ꠘꠛꠤꠞꠦ ꠖꠦꠈꠣꠔ ꠘꠤ? ꠢꠥꠘꠅ, ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠄꠢꠤꠀ ꠔ ꠈꠣꠟꠤ ꠘꠛꠤ ꠘꠣꠄ, ꠘꠛꠤ ꠕꠣꠇꠤꠅ ꠛꠠ। ");
INSERT INTO syls_vpl VALUES ("MT11_10","070_11_10","MAT","11","10","10","ꠄꠁꠘ ꠔ ꠢꠃ ꠎꠘ, ꠎꠦꠘ ꠛꠦꠙꠣꠞꠦ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞ ꠀꠉꠦ ꠙꠣꠑꠣꠁꠀꠞ ꠀꠝꠤ, ꠀꠝꠣꠞ ꠙꠦꠉꠣꠝ꠆ꠛꠞ, ꠄꠁꠘ ꠉꠤꠀ ꠑꠤꠇ-ꠑꠣꠇ ꠇꠞꠛꠣ ꠔꠥꠝꠣꠞ ꠌꠟꠣꠞ ꠙꠕ। ");
INSERT INTO syls_vpl VALUES ("MT11_11","070_11_11","MAT","11","11","11","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠄꠢꠤꠀ ꠕꠣꠇꠤ ꠛꠠ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠔꠃ ꠇꠥꠘꠥ ꠀꠖꠝ ꠀꠍꠟꠣ ꠘꠣ। ꠅꠁꠟꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠝꠣꠎꠦ ꠢꠇꠟ ꠕꠣꠇꠤ ꠢꠥꠞꠥ ꠎꠘꠅ, ꠄꠢꠤꠀ ꠕꠣꠇꠤ ꠝꠢꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("MT11_12","070_11_12","MAT","11","12","12","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠀꠝꠟ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠈꠥꠛ ꠝꠎꠛꠥꠔ ꠅꠁꠀ ꠀꠉꠥꠀꠞ, ꠀꠞ ꠎꠦꠞꠣ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ, ꠔꠣꠞꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠁꠀ ꠄꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT11_13","070_11_13","MAT","11","13","13","ꠢꠥꠘꠅ, ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠀꠝꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛ ꠀꠞ ꠡꠛ ꠘꠛꠤꠞ ꠍꠢꠤꠚꠣꠞ ꠝꠣꠎꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠅꠀꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT11_14","070_11_14","MAT","11","14","14","ꠅꠈꠘ ꠎꠥꠖꠤ ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞ ꠝꠣꠔ ꠄꠇꠤꠘ ꠇꠞꠂꠘ, ꠔꠦ ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠎꠦ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠄ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠛꠣꠞ ꠇꠕꠣ ꠀꠍꠤꠟ, ꠅꠃ ꠄꠢꠤꠀꠃ ꠅꠁꠟꠣ ꠢꠃ ꠁꠟꠤꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("MT11_15","070_11_15","MAT","11","15","15","ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ, ꠢꠦ ꠢꠥꠘꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT11_16","070_11_16","MAT","11","16","16","“ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠤ ꠇꠤꠔꠣꠞ ꠟꠉꠦ ꠔꠥꠟꠘꠣ ꠇꠞꠔꠣꠝ? ꠔꠣꠞꠣ ꠔ ꠅꠝꠘ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ, ꠎꠦꠔꠣꠄ ꠛꠣꠎꠣꠞꠅ ꠛꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("MT11_17","070_11_17","MAT","11","17","17","‘ꠢꠂ, ꠀꠝꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠡꠤ ꠛꠣꠎꠣꠁꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠔ ꠘꠣꠌꠟꠣꠄ ꠘꠣ, ꠀꠢꠣꠎꠣꠞꠤꠞ ꠉꠣꠘ ꠉꠣꠁꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠔ ꠇꠣꠘꠟꠣꠄ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT11_18","070_11_18","MAT","11","18","18","ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ, ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠀꠁꠀ ꠡꠝꠣꠎꠞ ꠟꠉꠦ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠘꠣ ꠇꠞꠣꠄ, ꠝꠣꠘꠡꠦ ꠇꠁꠞꠣ ꠔꠣꠘꠦ ꠜꠥꠔꠦ ꠗꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT11_19","070_11_19","MAT","11","19","19","ꠅꠁꠟꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠁꠀ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠣꠄ ꠔꠥꠝꠞꠣ ꠇꠁꠞꠣꠄ, ‘ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁ ꠛꠦꠐꠣ ꠔ ꠙꠦꠐꠥꠀ, ꠝꠖꠈꠥꠞ, ꠢꠦ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠟꠉꠦ ꠖꠥꠡ꠆ꠔꠤ ꠇꠞꠦ।’ ꠔꠦ ꠀꠈꠟ ꠈꠣꠐꠣꠁꠀ ꠎꠦꠞꠣ ꠌꠟꠦ, ꠔꠣꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠕꠣꠇꠤꠃ ꠙꠞꠝꠣꠘ ꠝꠤꠟꠦ, ꠀꠈꠟꠃ ꠅꠁꠟ ꠈꠣꠐꠤ-ꠘꠤꠈꠥꠔ ꠌꠤꠎ।” ");
INSERT INTO syls_vpl VALUES ("MT11_20","070_11_20","MAT","11","20","20","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠎꠦꠔꠣ ꠉꠣꠃꠀꠁꠘ꠆ꠔꠅ ꠀꠞ ꠐꠣꠃꠘꠅ ꠛꠦꠡꠤꠞ ꠜꠣꠉ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠍꠟꠣ, ꠁꠔꠣꠞ ꠝꠣꠘꠡꠦ ꠔꠃꠛꠣ ꠇꠞꠍꠂꠘ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠁ ꠉꠣꠃ ꠀꠞ ꠐꠣꠃꠘꠞ ꠃꠙꠞꠦ ꠛꠦꠎꠣꠞ ꠅꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT11_21","070_11_21","MAT","11","21","21","“ꠢꠣꠄꠞꠦ ꠛꠣꠄꠔ-ꠍꠄꠖꠣ ꠀꠞ ꠈꠥꠞꠣꠍꠤꠘ ꠉꠣꠃ, ꠔꠥꠝꠞꠣ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠡꠥꠞ ꠀꠞ ꠍꠤꠖꠘ ꠄꠟꠣꠇꠣꠔ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠔ, ꠔꠦ ꠛꠃꠔ ꠀꠉꠦꠃ ꠔꠣꠞꠣ ꠇꠣꠔꠞ ꠅꠁꠀ ꠔꠃꠛꠣ ꠇꠞꠟ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("MT11_22","070_11_22","MAT","11","22","22","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠡꠥꠞ ꠀꠞ ꠍꠤꠖꠘ ꠄꠟꠣꠇꠣꠞ ꠖꠡꠣ ꠕꠣꠇꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠖꠡꠣ ꠛꠃꠔ ꠇꠑꠤꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT11_23","070_11_23","MAT","11","23","23","ꠅ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘ, ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠛꠥꠟꠦ ꠃꠌꠣ ꠅꠁꠀ ꠀꠍꠝꠣꠘꠅ ꠉꠤꠀ ꠟꠣꠉꠔꠣꠄ? ꠘꠣ, ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ! ꠔꠥꠝꠣꠞꠦ ꠙꠣꠔꠣꠟꠅ ꠟꠣꠝꠣꠘꠤ ꠅꠁꠛ। ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠇꠥꠖꠞꠔꠤ ꠝꠥꠎꠦꠎꠣ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘꠅ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠔ, ꠔꠦ ꠁ ꠐꠣꠃꠘ ꠅꠈꠘꠅ ꠐꠤꠇꠤꠀ ꠞꠁꠟ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("MT11_24","070_11_24","MAT","11","24","24","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠢꠣꠡꠞꠞ ꠖꠤꠘ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘꠞ ꠢꠣꠟꠔꠅ ꠔꠥꠝꠞꠣꠞ ꠕꠣꠇꠤ ꠛꠃꠔ ꠜꠣꠟꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT11_25","070_11_25","MAT","11","25","25","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠤ ꠔ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠝꠣꠟꠤꠇ। ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠀꠈꠟꠖꠣꠞ ꠀꠞ ꠛꠥꠖ꠆ꠖꠤꠝꠣꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠎꠣꠁꠞ ꠘꠣ ꠇꠞꠤꠀ, ꠛꠦꠛꠥꠎ-ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("MT11_26","070_11_26","MAT","11","26","26","ꠛꠣꠛꠣ, ꠀꠍꠟꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ। ");
INSERT INTO syls_vpl VALUES ("MT11_27","070_11_27","MAT","11","27","27","“ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠛꠣꠄ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠍꠂꠘ। ꠛꠣꠚ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠅꠃ ꠙꠥꠔꠞꠦ ꠌꠤꠘꠦ ꠘꠣ, ꠀꠞ ꠙꠥꠔ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠅꠃ ꠛꠣꠚꠞꠦ ꠌꠤꠘꠦ ꠘꠣ। ꠙꠥꠔꠦ ꠛꠣꠚꠞꠦ ꠎꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠅꠄ, ꠈꠣꠟꠤ ꠢꠦ-ꠃ ꠛꠣꠚꠞ ꠙꠞꠤꠌꠄ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT11_28","070_11_28","MAT","11","28","28","“ꠜꠣꠞ-ꠛꠥꠏꠣ ꠛꠁꠔꠦ ꠛꠁꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠢꠦꠞꠣꠘ ꠅꠁꠉꠦꠍ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞꠣꠝ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("MT11_29","070_11_29","MAT","11","29","30","ꠀꠝꠣꠞ ꠎꠥꠀꠟ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠅ ꠔꠥꠟꠅ ꠀꠞ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠟꠤꠝ ꠟꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠀꠞꠣꠝ ꠅꠁꠛ। ꠀꠝꠣꠞ ꠎꠥꠀꠟ ꠛꠁꠀ ꠘꠦꠅꠀ ꠡꠥꠎꠣ, ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠜꠣꠞ ꠈꠥꠛ ꠙꠣꠔꠟꠣ। ꠀꠝꠣꠞ ꠝꠤꠎꠣꠎ ꠈꠥꠛ ꠘꠞꠝ ꠀꠞ ꠑꠣꠘ꠆ꠒꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT12_1","070_12_1","MAT","12","1","1","ꠄꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠈꠦꠔꠞ ꠀꠁꠟꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ। ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠣꠄ, ꠔꠣꠞꠣ ꠗꠣꠘꠞ ꠍꠠꠣ ꠍꠤꠠꠤ ꠍꠤꠠꠤ ꠈꠣꠅꠀꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_2","070_12_2","MAT","12","2","2","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠡꠞꠤꠅꠔꠦ ꠇꠄ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠣꠄ, ꠔꠦ ꠀꠙꠘꠣꠞ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠗꠣꠘꠞ ꠍꠠꠣ ꠍꠤꠠꠤꠞꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT12_3","070_12_3","MAT","12","3","3","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠖꠣꠃꠖ ꠘꠛꠤ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠝꠣꠘꠡꠦ ꠄꠇꠛꠣꠞ ꠙꠦꠐꠞ ꠜꠥꠇꠦ ꠎꠦꠔꠣ ꠇꠞꠍꠟꠣ, ꠁꠔꠣ ꠀꠙꠘꠣꠞꠣ ꠙꠠꠍꠂꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT12_4","070_12_4","MAT","12","4","4","ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠛꠣ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ ꠈꠣꠁꠍꠟꠣ, ꠁ ꠞꠥꠐꠤ ꠈꠣꠅꠀ ꠔ ꠔꠣꠁꠘ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠘꠣꠎꠣꠁꠎ, ꠁꠔꠣ ꠈꠣꠟꠤ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠟꠣꠉꠤ ꠎꠣꠁꠎ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT12_5","070_12_5","MAT","12","5","5","ꠀꠞ ꠀꠙꠘꠣꠞꠣ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠅ ꠙꠠꠍꠂꠘ ꠘꠣ ꠘꠤ, ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘꠞ ꠘꠤꠅꠝ ꠜꠣꠋꠟꠦꠅ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_6","070_12_6","MAT","12","6","6","ꠅꠁꠟꠦ ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠕꠣꠇꠤꠅ ꠖꠣꠝꠤ ꠄꠇ ꠝꠣꠘꠥꠡ ꠅꠘꠅ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT12_7","070_12_7","MAT","12","7","7","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠅꠃ ꠀꠄꠀꠔꠞ ꠜꠦꠖ ꠎꠥꠖꠤ ꠀꠙꠘꠣꠞꠣ ꠛꠥꠎꠔꠣ, ꠎꠦ ꠀꠄꠀꠔꠅ ꠀꠍꠦ, ‘ꠀꠝꠤ ꠖꠄꠀ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁ, ꠙꠡꠥ-ꠇꠥꠞꠛꠣꠘꠤ ꠘꠣꠄ।’ ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞꠦ ꠅꠙꠞꠣꠗꠤ ꠛꠣꠘꠣꠁꠟꠣ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("MT12_8","070_12_8","MAT","12","8","8","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠔꠣꠝꠣꠝ ꠄꠈꠔꠤꠀꠞ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠀꠔꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT12_9","070_12_9","MAT","12","9","9","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠁꠘ ꠕꠘꠦ ꠉꠤꠀ ꠅꠃ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞ ꠝꠍꠤꠖꠅ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_10","070_12_10","MAT","12","10","10","ꠢꠘꠅ ꠅꠟꠣ ꠄꠇ ꠛꠦꠐꠣ ꠀꠍꠤꠟ, ꠔꠣꠞ ꠄꠇ ꠀꠔ ꠛꠦꠝꠣꠞꠦ ꠢꠥꠇꠣꠁ ꠉꠦꠍꠦ। ꠁꠍꠣꠞ ꠇꠥꠘꠥ ꠈꠥꠔ ꠛꠣꠞ ꠇꠞꠤꠀ ꠔꠣꠘꠞꠦ ꠖꠥꠡꠤ ꠛꠣꠘꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ, ꠅꠃ ꠝꠍꠤꠖꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟ, “ꠍꠣꠛ, ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠇꠦꠃꠞꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT12_11","070_12_11","MAT","12","11","11","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠗꠞꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞꠣ ꠄꠇꠎꠘꠞ ꠄꠉꠥ ꠝꠦꠠꠣ ꠎꠥꠖꠤ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠉꠣꠔꠞ ꠝꠣꠎꠦ ꠙꠠꠤꠎꠣꠄ, ꠔꠦ ꠅꠃ ꠖꠤꠘ ꠁ ꠝꠦꠠꠣꠞꠦ ꠉꠣꠔꠅ ꠕꠣꠇꠤ ꠔꠥꠟꠔꠣ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT12_12","070_12_12","MAT","12","12","12","ꠀꠞ ꠝꠣꠘꠡꠞ ꠖꠣꠝ ꠔ ꠝꠦꠠꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠛꠦꠡꠤ। ꠄꠞꠟꠣꠉꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦꠅ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣ ꠎꠣꠁꠎ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT12_13","070_12_13","MAT","12","13","13","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠃ ꠢꠥꠇꠘꠣ ꠀꠔꠀꠟꠣ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠔꠈꠣꠘ ꠛꠣꠠꠣꠅ।” ꠢꠦ ꠔꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠁꠔꠦꠃ ꠢꠥꠇꠘꠣ ꠀꠔ ꠅꠁꠘ꠆ꠘ ꠀꠔꠞ ꠟꠣꠈꠣꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT12_14","070_12_14","MAT","12","14","14","ꠛꠣꠖꠦ ꠢꠃ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠛꠣꠞꠦ ꠉꠤꠀ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ, ꠁꠍꠣꠞꠦ ꠇꠤꠟꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_15","070_12_15","MAT","12","15","15","ꠔꠣꠞꠣꠞ ꠅꠃ ꠙꠞꠣꠝꠤꠡꠞ ꠈꠛꠞ ꠁꠍꠣꠄ ꠎꠣꠘꠤꠟꠤꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠢꠤꠘ ꠕꠘꠦ ꠢꠞꠤꠉꠦꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠟꠣ। ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠔ ꠛꠦꠝꠣꠞꠤ ꠀꠍꠟꠣ, ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_16","070_12_16","MAT","12","16","16","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠖꠠꠣꠁꠀ ꠇꠁꠟꠣ, “ꠈꠛꠞꠖꠣꠞ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠙꠞꠤꠌꠄ ꠎꠣꠁꠞ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT12_17","070_12_17","MAT","12","17","17","ꠁꠔꠣ ꠅꠁꠍꠤꠟ ꠎꠣꠔꠦ ꠀꠉꠞ ꠀꠝꠟꠞ ꠘꠛꠤ ꠁꠡꠣꠄꠀꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠅꠔꠣ ꠚꠟꠤꠎꠣꠄ। ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT12_18","070_12_18","MAT","12","18","18","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠅꠃ ꠉꠥꠟꠣꠝꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ। ꠄꠁꠘꠃ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠔꠣꠘ ꠃꠙꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ। ꠄꠘ ꠃꠙꠞꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠞꠥꠢꠥ ꠖꠤꠝꠥ, ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠢꠇ ꠛꠤꠌꠣꠞꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_19","070_12_19","MAT","12","19","19","ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠛꠣ ꠌꠤꠟ꠆ꠟꠣ-ꠌꠤꠟ꠆ꠟꠤ ꠇꠞꠔꠣ ꠘꠣꠄ, ꠙꠕꠦ-ꠊꠣꠐꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠀꠅꠀꠎ ꠢꠥꠘꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_20","070_12_20","MAT","12","20","20","ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠣꠁꠝ ꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠔꠣꠁꠘ ꠍꠦꠌꠣ ꠘꠟ-ꠈꠣꠉꠠꠣ ꠜꠣꠋꠉꠤꠔꠣ ꠘꠣꠄ, ꠀꠞ ꠝꠤꠐ ꠝꠤꠐ ꠇꠞꠤ ꠎꠟꠞꠣ ꠟꠦꠝꠞ ꠚꠤꠔꠣꠅ ꠟꠤꠝꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_21","070_12_21","MAT","12","21","21","ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠔꠣꠘ ꠃꠙꠞꠦꠃ ꠜꠞꠡꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_22","070_12_22","MAT","12","22","22","ꠛꠣꠖꠦ ꠝꠣꠘꠡꠦ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠟꠣ ꠄꠇ ꠛꠦꠐꠣꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠟ। ꠁ ꠛꠦꠐꠣ ꠀꠍꠤꠟ ꠀꠘ꠆ꠖꠣ ꠀꠞ ꠛꠥꠛꠣ। ꠔꠣꠁꠘ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ꠢꠦ ꠜꠣꠟꠣ ꠅꠁꠀ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠟ ꠀꠞ ꠌꠃꠈꠦꠅ ꠖꠦꠈꠟ। ");
INSERT INTO syls_vpl VALUES ("MT12_23","070_12_23","MAT","12","23","23","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅ ꠎꠦꠁꠘ ꠎꠘꠝ ꠅꠀꠞ ꠇꠕꠣ, ꠄꠁꠘꠃ ꠢꠦꠁꠘ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT12_24","070_12_24","MAT","12","24","24","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠁꠉꠤꠄ ꠔ ꠎꠤꠘꠞ ꠛꠣꠖꠡꠣ ꠛꠦꠟ-ꠍꠛꠥꠟꠞ ꠛꠟꠦ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT12_25","070_12_25","MAT","12","25","25","ꠔꠣꠞꠣꠞ ꠝꠘꠞ ꠌꠤꠘ꠆ꠔꠣ ꠛꠥꠎꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠇꠥꠘꠥ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠤꠉꠦꠟꠦ, ꠁ ꠖꠦꠡ ꠔ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠣꠄ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠎꠦ ꠛꠣ ꠇꠥꠘꠥ ꠐꠣꠃꠘꠅ ꠎꠦꠛꠟꠣ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠤꠎꠣꠄ, ꠁꠔꠣꠅ ꠀꠞ ꠐꠤꠇꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_26","070_12_26","MAT","12","26","26","ꠅꠃꠟꠣ ꠡꠄꠔꠣꠘꠦ ꠎꠥꠖꠤ ꠡꠄꠔꠣꠘꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠦꠄ, ꠔꠦ ꠔ ꠔꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠎꠦꠃ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠤꠉꠦꠟ। ꠔꠣꠞ ꠞꠣꠎꠔ꠆ꠔ ꠀꠞ ꠇꠤꠟꠣ ꠐꠤꠇꠛ? ");
INSERT INTO syls_vpl VALUES ("MT12_27","070_12_27","MAT","12","27","27","ꠀꠝꠤ ꠎꠥꠖꠤ ꠛꠦꠟ-ꠍꠛꠥꠟꠞ ꠛꠟꠦ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠡꠦ ꠇꠣꠞ ꠛꠟꠦ ꠍꠣꠠꠣꠄ? ꠔꠥꠝꠞꠣꠞ ꠝꠣꠔꠞ ꠛꠤꠌꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠡꠦꠃ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_28","070_12_28","MAT","12","28","28","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁ, ꠔꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔꠥꠝꠞꠣꠞ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT12_29","070_12_29","MAT","12","29","29","“ꠇꠥꠘꠥ ꠛꠟꠀꠟꠣ ꠝꠣꠘꠡꠞ ꠛꠣꠠꠤꠔ ꠟꠥꠐ-ꠔꠞꠣꠎ ꠇꠞꠣꠔ ꠀꠁꠀ, ꠙꠄꠟꠣ ꠛꠟꠀꠟꠣ ꠎꠘꠞꠦ ꠘꠣ ꠛꠣꠘ꠆ꠖꠤꠟꠦ, ꠇꠦꠝꠘꠦ ꠟꠥꠐ-ꠔꠞꠣꠎ ꠇꠞꠛ? ꠅꠁꠟꠦ ꠔꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠟꠥꠐ-ꠙꠣꠐ ꠇꠞꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("MT12_30","070_12_30","MAT","12","30","30","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠘꠣ ꠕꠣꠇꠦ, ꠢꠦ ꠔ ꠀꠝꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ। ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠔꠥꠇꠣꠄ ꠘꠣ, ꠢꠦ ꠔ ꠍꠤꠔ꠆ꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_31","070_12_31","MAT","12","31","31","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠝꠣꠘꠡꠞ ꠔꠣꠝꠣꠝ ꠘꠝꠥꠘꠣꠞ ꠉꠥꠘꠣ ꠀꠞ ꠇꠥꠚꠥꠞꠤꠞ ꠝꠣꠚꠤ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠚꠥꠞꠤ ꠇꠞꠟꠦ, ꠁ ꠇꠥꠚꠥꠞꠤꠞ ꠇꠥꠘꠥ ꠝꠣꠚꠤ ꠝꠤꠟꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_32","070_12_32","MAT","12","32","32","ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠤꠟꠦꠅ ꠢꠦ ꠝꠣꠚꠤ ꠙꠣꠁꠛ, ꠅꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠔꠤꠟꠦ ꠔꠣꠞ ꠇꠥꠘꠥ ꠝꠣꠚꠤ ꠘꠣꠁ, ꠁ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔꠅ ꠘꠣꠁ, ꠀꠈꠦꠞꠅ-ꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("MT12_33","070_12_33","MAT","12","33","33","“ꠝꠘꠅ ꠞꠣꠈꠛꠣ, ꠉꠣꠍ ꠜꠣꠟꠣ ꠅꠁꠟꠦ ꠔꠣꠞ ꠚꠟꠅ ꠜꠣꠟꠣ ꠅꠄ, ꠀꠞ ꠉꠣꠍ ꠛꠥꠞꠣ ꠅꠁꠟꠦ ꠔꠣꠞ ꠚꠟꠅ ꠛꠥꠞꠣ ꠅꠄ। ꠚꠟ ꠖꠤꠀꠃ ꠉꠣꠍ ꠌꠤꠘꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_34","070_12_34","MAT","12","34","34","ꠅ ꠢꠣꠚꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠔ ꠈꠣꠞꠣꠙ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈ ꠕꠘꠦ ꠜꠣꠟꠣ ꠛꠥꠟꠤ ꠇꠦꠝꠘꠦ ꠛꠣꠞ ꠅꠁꠛ? ꠝꠣꠘꠡꠞ ꠖꠤꠟ ꠎꠦꠔꠣꠖꠤ ꠜꠞꠣ, ꠝꠥꠈ ꠕꠣꠇꠤ ꠔ ꠅꠔꠣꠃ ꠛꠣꠞꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_35","070_12_35","MAT","12","35","35","ꠜꠣꠟꠣ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠞ ꠜꠣꠟꠣꠁ ꠕꠘꠦ ꠜꠣꠟꠣ ꠛꠥꠟꠤ ꠛꠣꠞꠅꠄ, ꠀꠞ ꠛꠣꠖ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠛꠥꠞꠣꠁ ꠕꠘꠦ ꠛꠣꠖ ꠛꠥꠟꠤ ꠛꠣꠞꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_36","070_12_36","MAT","12","36","36","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠎꠦ-ꠛꠣꠎꠦ ꠛꠦꠞ-ꠛꠦꠞꠤ ꠇꠞꠦ, ꠢꠣꠡꠞꠞ ꠝꠄꠖꠣꠘꠅ ꠔꠣꠞ ꠙꠞꠔꠦꠇ ꠝꠣꠔꠞ ꠢꠤꠡꠣꠛ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT12_37","070_12_37","MAT","12","37","37","ꠔꠥꠝꠣꠞ ꠎꠛꠣꠘꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠡꠤ ꠛꠣꠘꠣꠁꠛ, ꠀꠞ ꠅꠃ ꠎꠛꠣꠘꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠘꠤꠞ꠆ꠖꠥꠡꠤꠅ ꠛꠣꠘꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT12_38","070_12_38","MAT","12","38","38","ꠛꠣꠖꠦ ꠇꠄꠎꠘ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤꠄ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠄꠇꠈꠣꠘ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("MT12_39","070_12_39","MAT","12","39","39","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠁ ꠎꠝꠣꠘꠣꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠀꠞ ꠛꠦꠁꠝꠣꠘ ꠅꠇꠟꠦ ꠈꠣꠟꠤ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠔꠣ ꠌꠣꠁꠘ, ꠅꠁꠟꠦ ꠁꠃꠘꠥꠍ ꠘꠛꠤꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠇꠦꠞꠣꠝꠔꠤ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT12_40","070_12_40","MAT","12","40","40","ꠁꠃꠘꠥꠍ ꠘꠛꠤ ꠎꠦꠟꠣ ꠝꠣꠍꠞ ꠙꠦꠐꠅ ꠔꠤꠘ ꠖꠤꠘ, ꠔꠤꠘ ꠞꠣꠁꠔ ꠀꠍꠟꠣ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠅ ꠅꠃꠟꠣ ꠔꠤꠘ ꠖꠤꠘ, ꠔꠤꠘ ꠞꠣꠁꠔ ꠝꠣꠐꠤꠞ ꠔꠟꠦ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("MT12_41","070_12_41","MAT","12","41","41","ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠢꠃ ꠘꠤꠘꠜ ꠐꠣꠃꠘꠞ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠃꠑꠤꠀ ꠢꠣꠞꠤ, ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠖꠥꠡ ꠎꠣꠁꠞ ꠇꠞꠛꠣ। ꠇꠣꠞꠘ ꠁꠃꠘꠥꠍ ꠘꠛꠤꠞ ꠔꠛꠟꠤꠉ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠍꠤꠟꠣ। ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠁꠃꠘꠥꠍ ꠕꠣꠇꠤꠅ ꠀꠞꠅ ꠝꠢꠣꠘ ꠄꠇꠎꠘ ꠁꠘꠅ ꠀꠍꠂꠘ, ꠔꠣ-ꠅ ꠝꠣꠘꠡꠦ ꠔꠃꠛꠣ ꠇꠞꠦꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_42","070_12_42","MAT","12","42","42","ꠞꠥꠎ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠖꠃꠇꠘꠞ ꠖꠦꠡꠞ ꠞꠣꠘꠤ ꠃꠑꠤꠀ ꠀꠁꠀ ꠅꠃ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠖꠥꠡ ꠎꠣꠁꠞ ꠇꠞꠛꠣ। ꠇꠣꠞꠘ ꠛꠣꠖꠡꠣ ꠍꠥꠟꠣꠁꠝꠣꠘꠞ ꠀꠈꠟꠞ ꠇꠕꠣ ꠢꠥꠘꠣꠞ ꠈꠤꠀꠟꠦ ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀꠞ ꠢꠦꠡ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠁꠍꠟꠣ। ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠍꠥꠟꠣꠁꠝꠣꠘ ꠕꠣꠇꠤꠅ ꠀꠞꠅ ꠝꠢꠣꠘ ꠄꠇꠎꠘ ꠅꠘꠅ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT12_43","070_12_43","MAT","12","43","43","“ꠢꠥꠘꠅ, ꠇꠥꠘꠥ ꠜꠥꠔꠦ ꠎꠦꠛꠟꠣ ꠝꠣꠘꠡꠞ ꠟꠉ ꠍꠣꠠꠤꠀ ꠎꠣꠄꠉꠤ, ꠅꠃ ꠡꠝꠄ ꠢꠦ ꠀꠞꠣꠝꠦ ꠕꠣꠇꠣꠞ ꠈꠤꠀꠟꠦ ꠢꠇꠟ ꠢꠥꠇꠘꠣ ꠎꠣꠉꠣꠔ ꠀꠡꠞꠄ ꠔꠥꠇꠣꠄ। ꠅꠁꠟꠦ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣ ꠘꠣ ꠙꠣꠁꠀ ꠛꠣꠖꠦ ꠇꠄ, ");
INSERT INTO syls_vpl VALUES ("MT12_44","070_12_44","MAT","12","44","44","‘ꠗꠥꠞ, ꠀꠝꠣꠞ ꠀꠉꠞ ꠊꠞꠃ ꠜꠣꠟꠣ, ꠎꠦꠉꠥꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠤ, ꠅꠉꠥꠞ ꠉꠦꠍꠦꠃ ꠚꠤꠞꠤꠀ ꠎꠣꠁꠉꠤ।’ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠖꠦꠈꠦ ꠁ ꠊꠞꠈꠣꠘ ꠈꠣꠟꠤ, ꠍꠣꠚ-ꠍꠚꠣ ꠀꠞ ꠢꠣꠎꠣꠁꠟ-ꠙꠣꠠꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT12_45","070_12_45","MAT","12","45","45","ꠖꠦꠈꠤꠀ ꠢꠦ ꠉꠤꠀ ꠔꠣꠞ ꠕꠘꠦ ꠀꠞꠅ ꠈꠣꠞꠣꠙ ꠡꠣꠔꠉꠥ ꠜꠥꠔ ꠟꠉꠦ ꠟꠁꠀ ꠀꠄ, ꠀꠁꠀ ꠅꠃ ꠊꠞꠅ ꠞꠄ। ꠄꠞꠖꠣꠄ ꠅꠃ ꠝꠣꠘꠡꠞ ꠖꠡꠣ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠢꠦꠡꠦ ꠀꠞꠅ ꠛꠦꠡꠤ ꠈꠣꠞꠣꠙ ꠅꠄ। ꠔꠦ ꠁ ꠎꠝꠣꠘꠣꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠖꠡꠣꠅ ꠅꠟꠣꠈꠣꠘ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT12_46","070_12_46","MAT","12","46","46","ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ ꠛꠣꠞꠦ ꠀꠁꠀ, ꠔꠣꠘ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT12_47","070_12_47","MAT","12","47","47","ꠔꠦꠃ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT12_48","070_12_48","MAT","12","48","48","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠣ ꠇꠦ, ꠀꠞ ꠀꠝꠣꠞ ꠜꠣꠁꠀꠁꠘꠃ ꠛꠣ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT12_49","070_12_49","MAT","12","49","49","ꠛꠣꠖꠦ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠣꠁꠀ ꠇꠁꠟꠣ, “ꠄꠞꠣꠃ ꠀꠝꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("MT12_50","070_12_50","MAT","12","50","50","ꠎꠣꠞꠣ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠂꠘ, ꠔꠣꠞꠣꠃ ꠀꠝꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁ-ꠛꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT13_1","070_13_1","MAT","13","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠅꠃ ꠖꠤꠘ ꠊꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠅꠞꠞ ꠙꠣꠞꠅ ꠉꠤꠀ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_2","070_13_2","MAT","13","2","2","ꠛꠁꠀ ꠢꠣꠞꠟꠦ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠀ ꠜꠤꠠ ꠟꠣꠉꠣꠁ ꠖꠤꠟꠣ, ꠜꠤꠠ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠉꠤꠀ ꠄꠇ ꠘꠣꠅꠅ ꠃꠑꠤꠀ ꠛꠁꠟꠣ ꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠙꠣꠞꠅ ꠃꠛꠣꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_3","070_13_3","MAT","13","3","3","ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁ ꠢꠥꠘꠣꠁ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠘꠅ ꠇꠞꠅ, ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠦ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠇꠞꠣꠔ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_4","070_13_4","MAT","13","4","4","ꠉꠤꠀ ꠛꠣꠁꠘ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠀꠁꠟꠞ ꠝꠣꠎꠦ ꠙꠠꠟ, ꠀꠞ ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠁꠔꠣ ꠈꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_5","070_13_5","MAT","13","5","5","ꠔꠣꠞ ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠢꠥꠇꠘꠣ-ꠡꠇ꠆ꠔ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠙꠠꠟ, ꠁ ꠎꠣꠟꠣ ꠚꠥꠐꠤꠀ ꠀꠟꠤ ꠛꠣꠞ ꠅꠁꠟꠦꠅ ꠔꠟꠦ ꠛꠦꠡꠤ ꠝꠣꠐꠤ ꠘꠣ ꠕꠣꠇꠣꠄ, ꠎꠟꠖꠤ ꠛꠣꠠꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_6","070_13_6","MAT","13","6","6","ꠛꠣꠖꠦ ꠡꠥꠞꠥꠎ ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠎꠁꠞ ꠈꠣꠁꠟꠤꠟ, ꠀꠞ ꠔꠟꠞ ꠎꠠꠦ ꠞꠡ ꠘꠣ ꠙꠣꠅꠀꠄ ꠢꠥꠇꠣꠁꠀ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_7","070_13_7","MAT","13","7","7","ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠛꠘ-ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠙꠠꠟ, ꠀꠞ ꠅꠃ ꠛꠘ-ꠎꠋꠟꠣ ꠛꠣꠠꠤꠀ ꠁꠔꠣꠞꠦ ꠎꠣꠔꠤꠀ ꠗꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_8","070_13_8","MAT","13","8","8","ꠅꠁꠟꠦ ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠜꠣꠟꠣ ꠎꠝꠤꠘꠅ ꠙꠠꠟ, ꠁ ꠎꠣꠟꠣꠄ ꠜꠣꠟꠣ ꠗꠣꠘ ꠅꠁꠟ, ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠍꠠꠣꠄ ꠔꠤꠡ, ꠇꠥꠘꠥ ꠍꠠꠣꠄ ꠡꠣꠁꠐ, ꠇꠥꠘꠥ ꠍꠠꠣꠄ ꠄꠇ-ꠡ ꠉꠥꠘ ꠛꠦꠡꠤ ꠗꠣꠘ ꠗꠞꠟ।” ");
INSERT INTO syls_vpl VALUES ("MT13_9","070_13_9","MAT","13","9","9","ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ, ꠢꠦ ꠢꠥꠘꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MT13_10","070_13_10","MAT","13","10","10","ꠛꠣꠖꠦ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠈꠣꠟꠤ ꠇꠤꠌ꠆ꠍꠣ ꠇꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT13_11","070_13_11","MAT","13","11","11","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠉꠥꠙꠘ ꠞꠢꠁꠡ꠆ꠡ ꠎꠣꠘꠣꠞ ꠡꠥꠎꠥꠉ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠁꠟꠦ ꠛꠣꠇꠤ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠛꠣꠔꠥꠘꠤ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT13_12","070_13_12","MAT","13","12","12","ꠢꠥꠘꠅ, ꠎꠣꠞ ꠀꠍꠦ, ꠔꠣꠞꠦ ꠀꠞꠅ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠔꠣꠞ ꠀꠞꠅ ꠛꠣꠠꠤꠛ। ꠅꠁꠟꠦ ꠎꠣꠞ ꠘꠣꠁ, ꠔꠣꠞ ꠎꠦꠔꠣ ꠀꠍꠦ, ꠅꠔꠣꠅ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT13_13","070_13_13","MAT","13","13","13","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠎꠖꠤ ꠄꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠣꠝ, ꠄꠞꠣ ꠔ ꠖꠦꠈꠤꠀꠅ ꠖꠦꠈꠦ ꠘꠣ, ꠢꠥꠘꠤꠀꠅ ꠢꠥꠘꠦ ꠘꠣ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠦꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_14","070_13_14","MAT","13","14","14","ꠄꠞꠣꠞ ꠝꠣꠎꠖꠤꠀꠃ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠛꠣꠔꠣꠁꠟ ꠅꠃ ꠀꠄꠀꠔ ꠙꠥꠞꠣ ꠅꠁꠍꠦ, ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, ꠔꠥꠝꠞꠣ ꠇꠣꠘꠦ ꠢꠥꠘꠟꠦꠅ ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠔꠣꠄ ꠘꠣꠄ, ꠌꠃꠈꠦ ꠖꠦꠈꠟꠦꠅ ꠇꠥꠘ꠆ꠔꠣ ꠌꠤꠘꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT13_15","070_13_15","MAT","13","15","15","ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠖꠤꠟ ꠅꠡꠣꠠ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠞꠣꠞ ꠇꠣꠘꠅ ꠔꠣꠟꠣ ꠟꠣꠉꠤꠉꠦꠍꠦ। ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠌꠃꠈ ꠝꠥꠎꠤ ꠛꠁꠞꠁꠍꠦ, ꠎꠣꠔꠦ ꠌꠃꠈꠦ ꠘꠣ ꠖꠦꠈꠦ, ꠇꠣꠘꠦ ꠘꠣ ꠢꠥꠘꠦ, ꠖꠤꠟ ꠖꠤꠀ ꠘꠣ ꠛꠥꠎꠦ। ꠇꠤꠎꠣꠘꠥ ꠔꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠎꠣꠁꠘ, ꠀꠞ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠤꠟꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("MT13_16","070_13_16","MAT","13","16","16","ꠅꠁꠟꠦ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠔ ꠔꠥꠝꠞꠣ, ꠔꠥꠝꠞꠣꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠦ, ꠀꠞ ꠇꠣꠘꠦ ꠢꠥꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("MT13_17","070_13_17","MAT","13","17","17","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠌꠃꠈꠦ ꠎꠦꠔꠣ ꠖꠦꠈꠞꠣꠄ ꠀꠞ ꠇꠣꠘꠦ ꠎꠦꠔꠣ ꠢꠥꠘꠞꠣꠄ, ꠁꠔꠣ ꠛꠃꠔ ꠘꠛꠤ ꠀꠞ ꠅꠟꠤ-ꠀꠃꠟꠤꠀꠄ ꠖꠦꠈꠣꠞ ꠀꠡꠣ ꠇꠞꠟꠦꠅ ꠖꠦꠈꠣꠞ ꠇꠙꠣꠟ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠞ ꠢꠥꠘꠣꠞ ꠀꠡꠣ ꠇꠞꠟꠦꠅ ꠢꠥꠘꠣꠞ ꠇꠙꠣꠟ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_18","070_13_18","MAT","13","18","18","“ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠉꠤꠞꠡ꠆ꠔꠞ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠣꠁ ꠖꠤꠞꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("MT13_19","070_13_19","MAT","13","19","19","ꠢꠥꠘꠅ, ꠀꠁꠟꠞ ꠝꠣꠎꠦ ꠙꠠꠣ ꠎꠣꠟꠣ ꠖꠤꠀ ꠅꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀꠅ ꠛꠥꠎꠦ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠁꠛꠟꠤꠍꠦ ꠀꠁꠀ ꠅꠃ ꠎꠘꠞ ꠖꠤꠟꠅ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠇꠣꠟꠣꠝ ꠛꠣꠁꠘ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠅꠔꠣ ꠇꠣꠠꠤꠀ ꠘꠦꠄꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT13_20","070_13_20","MAT","13","20","20","ꠢꠥꠇꠘꠣ-ꠡꠇ꠆ꠔ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠙꠠꠣ ꠎꠣꠟꠣꠖꠤ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ ꠀꠞ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("MT13_21","070_13_21","MAT","13","21","21","ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠢꠣꠝꠣꠄ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠁꠔꠣ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠞꠄ, ꠛꠣꠖꠦ ꠁ ꠇꠣꠟꠣꠝꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠀꠁꠟꠦꠃ ꠔꠣꠞꠣ ꠈꠞꠟꠣꠝꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT13_22","070_13_22","MAT","13","22","22","ꠛꠘ-ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠙꠠꠣ ꠎꠣꠟꠣꠖꠤ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ, ꠅꠁꠟꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠀꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠝꠣꠄꠀꠄ ꠁ ꠇꠣꠟꠣꠝꠞꠦ ꠎꠣꠔꠤꠀ ꠗꠞꠤꠟꠣꠄ, ꠄꠞꠖꠣꠄ ꠇꠣꠟꠣꠝꠦ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_23","070_13_23","MAT","13","23","23","ꠀꠞ ꠜꠣꠟꠣ ꠎꠝꠤꠘꠅ ꠙꠠꠣ ꠎꠣꠟꠣꠖꠤ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ, ꠢꠥꠘꠤꠀ ꠛꠥꠎꠦ ꠀꠞ ꠀꠝꠟ ꠇꠞꠦ। ꠇꠦꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠔꠤꠡ ꠉꠥꠘ, ꠇꠦꠃ ꠡꠣꠁꠐ ꠉꠥꠘ, ꠇꠦꠃ ꠄꠇ-ꠡ ꠉꠥꠘ ꠛꠦꠡꠤ ꠚꠟ ꠖꠦꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT13_24","070_13_24","MAT","13","24","24","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠇ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ। ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠟꠣ ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠞ ꠟꠣꠈꠣꠘ, ꠎꠦꠁꠘ ꠘꠤꠎꠞ ꠎꠝꠤꠘꠅ ꠜꠣꠟꠣ ꠗꠣꠘꠞ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_25","070_13_25","MAT","13","25","25","ꠛꠣꠖꠦ ꠞꠣꠁꠔ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠎꠦꠛꠟꠣ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠊꠥꠝꠣꠁ ꠉꠦꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠄꠇ ꠖꠥꠡꠝꠘꠦ ꠀꠁꠀ ꠛꠣꠁꠘ ꠖꠦꠅꠀ ꠅꠃ ꠎꠝꠤꠘꠞ ꠝꠣꠎꠦ ꠚꠥꠚꠞꠣ ꠉꠣꠍꠞ ꠛꠤꠌꠤ ꠍꠤꠐꠣꠁꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT13_26","070_13_26","MAT","13","26","26","ꠢꠦꠡꠦ ꠗꠣꠘꠞ ꠉꠣꠍ ꠎꠦꠛꠟꠣ ꠛꠠ ꠅꠁꠀ ꠍꠠꠣ ꠍꠣꠠꠟ, ꠅꠃ ꠡꠝꠄ ꠄꠞꠝꠣꠎꠦ ꠚꠥꠚꠞꠣ ꠉꠣꠍꠅ ꠖꠦꠈꠣ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_27","070_13_27","MAT","13","27","27","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠛꠣꠠꠤꠞ ꠌꠣꠇꠞ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠇꠁꠟꠣ, ‘ꠀꠙꠘꠦ ꠎꠝꠤꠘꠅ ꠈꠣꠟꠤ ꠜꠣꠟꠣ ꠗꠣꠘ ꠛꠣꠁꠘ ꠖꠤꠍꠟꠣ ꠘꠣ ꠘꠤ? ꠅꠈꠘ ꠚꠥꠚꠞꠣ ꠉꠣꠍ ꠅꠁꠟ ꠇꠥꠀꠁ ꠕꠣꠇꠤ?’ ");
INSERT INTO syls_vpl VALUES ("MT13_28","070_13_28","MAT","13","28","28","“ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠇꠥꠘꠥ ꠖꠥꠡꠝꠘꠦ ꠁ ꠇꠣꠝ ꠇꠞꠍꠦ।’ ꠌꠣꠇꠞ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟ, ‘ꠔꠦ ꠀꠝꠞꠣ ꠉꠤꠀ ꠅꠃ ꠚꠥꠚꠞꠣ ꠉꠣꠍ ꠍꠣꠚ ꠇꠞꠤꠟꠔꠣꠝ ꠘꠤ?’ ");
INSERT INTO syls_vpl VALUES ("MT13_29","070_13_29","MAT","13","29","29","ꠝꠥꠘꠤꠛꠦ ꠇꠁꠟꠣ, ‘ꠘꠣ, ꠘꠣ, ꠔꠥꠝꠞꠣ ꠚꠥꠚꠞꠣ ꠉꠣꠍ ꠍꠣꠚ ꠇꠞꠣꠔ ꠉꠤꠀ, ꠗꠣꠘꠞ ꠉꠣꠍꠅ ꠔꠥꠟꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT13_30","070_13_30","MAT","13","30","30","ꠄꠞꠟꠣꠉꠤ ꠗꠣꠘ ꠖꠣꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠕꠣꠇꠃꠇ। ꠛꠣꠖꠦ ꠖꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠀꠝꠤ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠝꠥ, ꠙꠄꠟꠣ ꠢꠇꠟ ꠚꠥꠚꠞꠣ ꠉꠣꠍ ꠔꠥꠟꠔꠣ, ꠀꠞ ꠖꠣꠞꠥ ꠎꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠐꠤ ꠛꠣꠘ꠆ꠖꠤꠔꠣ, ꠛꠣꠖꠦ ꠗꠣꠘ ꠖꠣꠁꠀ ꠀꠝꠣꠞ ꠃꠉꠣꠞꠅ ꠔꠥꠟꠛꠣ।’ ” ");
INSERT INTO syls_vpl VALUES ("MT13_31","070_13_31","MAT","13","31","31","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠞꠇ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ। ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟ ꠄꠉꠥ ꠒꠦꠋꠉꠣ ꠛꠤꠌꠤꠞ ꠟꠣꠈꠣꠘ। ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠄꠉꠥ ꠒꠦꠋꠉꠣꠞ ꠛꠤꠌꠤ ꠔꠣꠞ ꠎꠝꠤꠘꠅ ꠛꠣꠁꠘ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_32","070_13_32","MAT","13","32","32","ꠁ ꠛꠤꠌꠤ ꠔ ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠤꠌꠤ ꠕꠣꠇꠤ ꠢꠥꠞꠥ। ꠅꠁꠟꠦ ꠛꠣꠁꠘ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠁ ꠉꠣꠍ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠢꠣꠉ-ꠔꠞꠇꠣꠞꠤ ꠕꠣꠇꠤ ꠛꠠ ꠅꠄ, ꠀꠞ ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠔꠣꠞ ꠒꠣꠟ-ꠙꠣꠟꠣꠔ ꠛꠣꠖꠣ ꠛꠣꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT13_33","070_13_33","MAT","13","33","33","ꠄꠞꠛꠣꠖꠦ ꠀꠞꠇ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠎꠦ ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟ ꠈꠣꠝꠤꠞꠞ ꠟꠣꠈꠣꠘ। ꠄꠇꠎꠘ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠦ ꠔꠤꠘ ꠛꠡ꠆ꠔꠣ ꠝꠄꠖꠣꠞ ꠝꠣꠎꠦ ꠕꠥꠠꠣ ꠈꠣꠝꠤꠞ ꠝꠤꠡꠣꠁꠟ। ꠈꠣꠝꠤꠞꠞ ꠚꠣꠚꠦ ꠢꠇꠟ ꠝꠄꠖꠣ ꠚꠥꠟꠤꠀ ꠃꠑꠟ।” ");
INSERT INTO syls_vpl VALUES ("MT13_34","070_13_34","MAT","13","34","34","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁ ꠢꠥꠘꠣꠁ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ꠇꠤꠌ꠆ꠍꠣ ꠍꠣꠠꠣ ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_35","070_13_35","MAT","13","35","35","ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠅꠔꠣ ꠅꠈꠘ ꠙꠥꠞꠣ ꠅꠄ, ꠔꠣꠟꠤꠝꠦ ꠜꠞꠣ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁ ꠢꠥꠘꠣꠁ ꠀꠝꠤ ꠝꠣꠔꠤꠝꠥ, ꠖꠥꠘꠤꠀꠞ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠎꠔꠔꠣ ꠛꠣꠔꠥꠘꠤ ꠀꠍꠤꠟ, ꠅꠔꠣ ꠅꠈꠘ ꠈꠥꠟꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("MT13_36","070_13_36","MAT","13","36","36","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠀ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠚꠥꠚꠞꠣ ꠉꠣꠍꠞ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠘꠤꠈꠣꠘ ꠀꠝꠞꠣꠞꠦ ꠛꠥꠎꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT13_37","070_13_37","MAT","13","37","37","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠜꠣꠟꠣ ꠗꠣꠘꠞ ꠎꠣꠟꠣ ꠎꠦꠁꠘ ꠛꠣꠁꠘ ꠇꠞꠂꠘ, ꠄꠁꠘ ꠅꠁꠟꠣꠝ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ। ");
INSERT INTO syls_vpl VALUES ("MT13_38","070_13_38","MAT","13","38","38","ꠎꠝꠤꠘ ꠅꠁꠟ ꠅꠃ ꠎꠉꠔ, ꠀꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ ꠜꠣꠟꠣ ꠛꠤꠌ। ꠁꠛꠟꠤꠍꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠅꠁꠟ ꠅꠃ ꠚꠥꠚꠞꠣ ꠉꠣꠍ। ");
INSERT INTO syls_vpl VALUES ("MT13_39","070_13_39","MAT","13","39","39","ꠎꠦ ꠖꠥꠡꠝꠘꠦ ꠚꠥꠚꠞꠣ ꠉꠣꠍ ꠛꠣꠁꠘ ꠖꠤꠍꠤꠟ, ꠢꠦ ꠅꠁꠟ ꠁꠛꠟꠤꠍ। ꠗꠣꠘ ꠖꠣꠅꠀꠞ ꠡꠝꠄ ꠅꠁꠟ ꠇꠤꠀꠝꠔ, ꠀꠞ ꠖꠣꠅꠞꠣ ꠅꠇꠟ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_40","070_13_40","MAT","13","40","40","ꠚꠥꠚꠞꠣ ꠉꠣꠍ ꠀꠐꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠎꠦꠟꠣ ꠖꠣꠞꠥ ꠎꠣꠟꠣꠘꠤ ꠅꠄ, ꠇꠤꠀꠝꠔꠞ ꠡꠝꠄ ꠑꠤꠇ ꠅꠟꠣꠃ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT13_41","070_13_41","MAT","13","41","41","ꠛꠤꠘ-ꠀꠖꠝꠦ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠙꠣꠑꠣꠁꠛꠣ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠘꠤꠎꠦ ꠉꠥꠘꠣ ꠇꠞꠦ ꠀꠞ ꠀꠞꠇ ꠎꠘꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠦ, ꠔꠣꠞꠣ ꠢꠇꠟꠞꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("MT13_42","070_13_42","MAT","13","42","42","ꠖꠥꠎꠈꠞ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠛꠣ। ꠢꠤꠘꠅ ꠝꠣꠘꠡꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠛꠣ ꠀꠞ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠄ ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_43","070_13_43","MAT","13","43","43","ꠢꠤ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠘꠥꠞꠣꠘꠤ ꠍꠥꠞꠔꠦ ꠡꠥꠞꠥꠎꠞ ꠟꠣꠈꠣꠘ ꠏꠤꠟꠝꠤꠟ ꠇꠞꠛꠣ। ꠢꠥꠘꠣꠞ ꠟꠣꠈ ꠇꠣꠘ ꠎꠣꠞ ꠀꠍꠦ, ꠢꠦ ꠢꠥꠘꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT13_44","070_13_44","MAT","13","44","44","“ꠢꠥꠘꠅ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟ, ꠝꠣꠐꠤꠞ ꠔꠟꠦ ꠟꠥꠇꠣꠁꠟ ꠇꠥꠘꠥ ꠗꠘꠞ ꠟꠣꠈꠣꠘ। ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠅꠃ ꠗꠘ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟ, ꠙꠣꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠉꠣꠠꠤꠀ ꠕꠁ ꠖꠤꠟ। ꠁ ꠗꠘ ꠙꠣꠁꠀ ꠈꠥꠡꠤ ꠅꠁꠀ ꠢꠦ ꠔꠣꠞ ꠢꠇꠟ ꠍꠣꠝꠣꠘꠣ ꠛꠦꠌꠤꠀ, ꠅꠃ ꠎꠝꠤꠘꠈꠣꠘ ꠈꠞꠤꠖ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_45","070_13_45","MAT","13","45","45","“ꠢꠤꠞꠛꠣꠞ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟ ꠅꠟꠣ ꠄꠇ ꠡꠖꠣꠉꠞꠞ ꠟꠣꠈꠣꠘ, ꠁ ꠡꠖꠣꠉꠞꠦ ꠈꠣꠐꠤ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣ ꠔꠥꠇꠣꠘꠤꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_46","070_13_46","MAT","13","46","46","ꠢꠦ ꠄꠇꠐꠣ ꠖꠣꠝꠤ ꠝꠥꠇ꠆ꠔꠣꠞ ꠈꠛꠞ ꠙꠣꠁꠀ, ꠔꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠦꠌꠤꠀ ꠅꠃ ꠝꠥꠇ꠆ꠔꠣ ꠈꠞꠤꠖ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_47","070_13_47","MAT","13","47","47","“ꠛꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠟꠣ ꠄꠇ ꠎꠣꠟꠞ ꠟꠣꠈꠣꠘ, ꠁ ꠎꠣꠟꠖꠤ ꠀꠅꠞꠅ ꠐꠣꠘ ꠖꠤꠟꠦ ꠄꠞ ꠜꠤꠔꠞꠦ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠝꠣꠍ ꠢꠣꠝꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_48","070_13_48","MAT","13","48","48","ꠝꠣꠍꠦ ꠎꠣꠟ ꠜꠞꠤꠉꠦꠟꠦ ꠎꠣꠟꠥꠀ ꠅꠇꠟꠦ ꠁꠈꠣꠘꠞꠦ ꠐꠣꠘꠤꠀ ꠙꠣꠞꠅ ꠔꠥꠟꠟ। ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠝꠣꠍ ꠛꠣꠍꠤꠀ ꠌꠣꠋꠉꠣꠔ ꠕꠁꠟ ꠀꠞ ꠛꠣꠖ ꠉꠥꠁꠘ ꠚꠣꠟꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT13_49","070_13_49","MAT","13","49","49","ꠔꠦ ꠢꠣꠡꠞꠞ ꠝꠄꠖꠣꠘꠅ ꠅꠃ ꠢꠣꠟꠔ ꠅꠁꠛ। ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠀꠁꠀ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠝꠣꠘꠡꠞ ꠖꠟ ꠕꠣꠇꠤ, ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞꠦ ꠀꠟꠉꠣꠁꠀ ꠖꠥꠎꠈꠞ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT13_50","070_13_50","MAT","13","50","50","ꠢꠤꠘꠅ ꠔꠣꠞꠣ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠛꠣ ꠀꠞ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠄ ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT13_51","070_13_51","MAT","13","51","51","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠥꠎꠍ ꠘꠤ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠛꠥꠎꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT13_52","070_13_52","MAT","13","52","52","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠎꠦ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍꠂꠘ, ꠔꠣꠞꠣ ꠅꠟꠣ ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠞ ꠟꠣꠈꠣꠘ, ꠎꠦ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠘ ꠡꠘ꠆ꠖꠥꠇ ꠕꠣꠇꠤ ꠘꠄꠀ ꠀꠞ ꠙꠥꠞꠣꠘꠣ ꠝꠣꠟ ꠛꠣꠞ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT13_53","070_13_53","MAT","13","53","53","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠤꠌ꠆ꠍꠣ ꠇꠁꠀ ꠇꠁꠀ ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠁꠘ ꠕꠘꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT13_54","070_13_54","MAT","13","54","54","ꠉꠤꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠣꠃꠞ ꠝꠍꠤꠖꠅ ꠢꠣꠝꠣꠁꠀ ꠅꠀꠎ-ꠘꠍꠤꠅꠔ ꠇꠞꠟꠣ। ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠁ ꠛꠦꠐꠣꠄ ꠇꠦꠝꠘꠦ ꠅꠔ ꠁꠟꠤꠝ ꠀꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠙꠣꠁꠟ? ");
INSERT INTO syls_vpl VALUES ("MT13_55","070_13_55","MAT","13","55","55","ꠄ ꠇꠤꠔꠣ ꠢꠃ ꠇꠣꠑ ꠝꠦꠡ꠆ꠔꠞꠤꠞ ꠙꠥꠀ ꠘꠣꠄ ꠘꠤ? ꠔꠣꠞ ꠝꠣʼꠞ ꠘꠣꠝ ꠝꠞꠤꠅꠝ ꠘꠣꠄ ꠘꠤ? ꠢꠦ ꠁꠀꠇꠥꠛ, ꠁꠃꠍꠥꠚ, ꠍꠣꠁꠝꠘ ꠀꠞ ꠄꠢꠥꠖꠣꠞ ꠜꠣꠁ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT13_56","070_13_56","MAT","13","56","56","ꠔꠣꠞ ꠛꠁꠘꠣꠁꠘ ꠔ ꠀꠝꠞꠣꠞ ꠉꠣꠃꠔꠃ ꠞꠁꠞꠣ? ꠔꠦ ꠢꠦ ꠁꠔꠣ ꠁꠟꠤꠝ ꠇꠁ ꠕꠣꠇꠤ ꠙꠣꠁꠟ?” ");
INSERT INTO syls_vpl VALUES ("MT13_57","070_13_57","MAT","13","57","57","ꠅꠃ ꠟꠣꠈꠣꠘ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠅ ꠛꠤꠔꠤꠡꠘꠣ ꠀꠁꠟ। ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠘꠤꠎꠞ ꠛꠣꠠꠤ-ꠊꠞ ꠛꠣ ꠉꠣꠃ-ꠖꠦꠡ ꠍꠣꠠꠣ ꠀꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔꠃ ꠘꠛꠤ ꠅꠇꠟꠦ ꠡꠝ꠆ꠝꠣꠘ ꠙꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT13_58","070_13_58","MAT","13","58","58","ꠉꠣꠃꠞ ꠝꠣꠘꠡꠞ ꠁꠝꠣꠘ ꠘꠣꠁ ꠖꠦꠈꠤꠀ, ꠔꠣꠁꠘ ꠢꠤꠈꠣꠘꠅ ꠛꠦꠡꠤ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_1","070_14_1","MAT","14","1","1","ꠅꠃ ꠡꠝꠄ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠦ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠘꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT14_2","070_14_2","MAT","14","2","2","ꠢꠥꠘꠤꠀ ꠔꠣꠘ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞꠦ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠔ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠅꠞꠣ ꠄꠢꠤꠀ। ꠄꠁꠘ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠄ ꠅꠃ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT14_3","070_14_3","MAT","14","3","3","ꠅꠃ ꠢꠦꠞꠥꠖꠦ ꠔꠣꠞ ꠜꠣꠁ ꠚꠤꠟꠤꠚꠞ ꠛꠃ ꠢꠦꠞꠥꠖꠤꠀꠞꠦ ꠢꠣꠋꠉꠣ ꠇꠞꠍꠤꠟ। ꠔꠣꠁꠞ ꠝꠘ ꠎꠥꠉꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠦ ꠄꠢꠤꠀ ꠘꠛꠤꠞꠦ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤꠀ ꠕꠁꠍꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("MT14_4","070_14_4","MAT","14","4","4","ꠇꠣꠞꠘ ꠄꠢꠤꠀꠄ ꠢꠦꠞꠥꠖꠞꠦ ꠇꠁꠔꠣ, “ꠔꠣꠁꠞꠦ ꠢꠣꠋꠉꠣ ꠇꠞꠣ ꠔ ꠔꠥꠝꠣꠞ ꠑꠤꠇ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT14_5","070_14_5","MAT","14","5","5","ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠄꠢꠤꠀ ꠘꠛꠤꠞꠦ ꠝꠣꠞꠤꠟꠤꠔ ꠌꠣꠁꠟ, ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞ ꠒꠞꠦ ꠝꠣꠞꠔ ꠙꠣꠞꠟ ꠘꠣ, ꠝꠣꠘꠡꠦ ꠎꠣꠘꠔꠣ ꠄꠁꠘ ꠄꠇꠎꠘ ꠘꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("MT14_6","070_14_6","MAT","14","6","6","ꠛꠣꠖꠦ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠎꠘꠝ ꠖꠤꠘꠞ ꠅꠘꠥꠡ꠆ꠑꠣꠘꠅ ꠢꠦꠞꠥꠖꠤꠀꠞ ꠙꠥꠠꠤꠄ ꠘꠣꠌꠤꠀ ꠞꠣꠎꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT14_7","070_14_7","MAT","14","7","7","ꠄꠞꠖꠣꠄ ꠞꠣꠎꠣꠄ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠟ, “ꠅꠃ ꠙꠥꠠꠤꠄ ꠎꠦꠔꠣ ꠌꠣꠁꠛ, ꠅꠔꠣ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT14_8","070_14_8","MAT","14","8","8","ꠙꠥꠠꠤꠄ ꠔꠣꠁꠞ ꠝꠣʼꠞ ꠟꠉꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠤ ꠇꠁꠟ, “ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠅꠞꠣ ꠄꠢꠤꠀꠞ ꠇꠟ꠆ꠟꠣ ꠇꠣꠐꠤꠀ ꠄꠇꠈꠣꠘ ꠕꠣꠟꠅ ꠇꠞꠤ, ꠅꠈꠘ ꠀꠘꠤꠀ ꠀꠝꠣꠞꠦ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT14_9","070_14_9","MAT","14","9","9","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠞꠣꠎꠣꠞ ꠝꠘ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠉꠦꠟ। ꠅꠁꠟꠦ ꠔꠣꠞ ꠟꠉꠦ ꠛꠅꠀ ꠝꠦꠝꠣꠘ-ꠝꠥꠍꠣꠚꠤꠞꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠎꠦ ꠇꠍꠝ ꠇꠞꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠅꠃ ꠇꠟ꠆ꠟꠣ ꠇꠣꠐꠤꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT14_10","070_14_10","MAT","14","10","10","ꠔꠣꠞ ꠎꠟ꠆ꠟꠣꠖ ꠙꠣꠑꠣꠁꠀ ꠎꠦꠟꠞ ꠜꠤꠔꠞꠦ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠇꠟ꠆ꠟꠣ ꠇꠣꠐꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT14_11","070_14_11","MAT","14","11","11","ꠛꠣꠖꠦ ꠅꠃ ꠇꠟ꠆ꠟꠣ ꠄꠇ ꠕꠣꠟꠅ ꠇꠞꠤ ꠀꠘꠤꠀ ꠅꠃ ꠙꠥꠠꠤꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠙꠥꠠꠤꠄ ꠘꠤꠀ ꠔꠣꠁꠞ ꠝꠣʼꠞ ꠉꠦꠍꠦ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT14_12","070_14_12","MAT","14","12","12","ꠄꠞꠛꠣꠖꠦ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠔꠣꠘ ꠟꠣꠡ ꠘꠤꠀ ꠖꠣꠚꠘ ꠇꠞꠟꠣ, ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠅꠃ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_13","070_14_13","MAT","14","13","13","ꠄꠢꠤꠀꠞ ꠝꠃꠔꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠄꠇꠈꠣꠘ ꠘꠣꠅꠔ ꠃꠑꠤꠀ ꠘꠤꠞꠣꠁ ꠄꠇ ꠎꠣꠉꠣꠔ ꠉꠦꠟꠣꠉꠤ। ꠔꠣꠁꠘ ꠉꠦꠍꠂꠘꠉꠤ ꠢꠥꠘꠤꠀ, ꠘꠣꠘꠣꠘ ꠎꠣꠉꠣꠞ ꠝꠣꠘꠥꠡ ꠢꠥꠇꠘꠣ ꠛꠣꠄ ꠀꠐꠤ ꠀꠐꠤ ꠔꠣꠘ ꠈꠞꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_14","070_14_14","MAT","14","14","14","ꠔꠣꠁꠘ ꠘꠣꠅ ꠕꠘꠦ ꠟꠣꠝꠣꠞ ꠛꠣꠖꠦ ꠝꠣꠘꠡꠞ ꠜꠤꠠ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠜꠤꠔꠞꠦ ꠖꠄꠀ ꠢꠣꠝꠣꠁꠉꠦꠟ। ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠔ ꠛꠦꠝꠣꠞꠤ ꠀꠍꠟꠣ, ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_15","070_14_15","MAT","14","15","15","ꠛꠤꠀꠟꠤ ꠛꠣꠟꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁꠈꠣꠘ ꠔ ꠈꠥꠛ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣ, ꠀꠞ ꠛꠦꠁꠟꠅ ꠎꠣꠞꠉꠤ। ꠔꠦ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ, ꠄꠞꠣ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠉꠣꠃꠀꠁꠘ꠆ꠔꠅ ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠟꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MT14_16","070_14_16","MAT","14","16","16","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠘꠣ, ꠔꠣꠞꠣ ꠎꠣꠅꠀꠞ ꠖꠞꠇꠣꠞ ꠘꠣꠁ, ꠔꠥꠝꠞꠣꠃ ꠄꠞꠣꠞꠦ ꠈꠣꠘꠤ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT14_17","070_14_17","MAT","14","17","17","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠈꠣꠟꠤ ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠞ ꠖꠥꠁꠐꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("MT14_18","070_14_18","MAT","14","18","18","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠈꠘꠣꠁꠘ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT14_19","070_14_19","MAT","14","19","19","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, ꠊꠣꠡꠞ ꠃꠙꠞꠦ ꠛꠁꠎꠤꠔꠣ। ꠔꠣꠁꠘ ꠢꠃ ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠞ ꠖꠥꠁꠐꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍ ꠀꠔꠅ ꠟꠁꠟꠣ, ꠀꠞ ꠀꠍꠝꠣꠘꠦꠖꠤ ꠌꠣꠁꠀ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ꠛꠣꠖꠦ ꠅꠃ ꠞꠥꠐꠤ ꠐꠥꠇꠞꠣꠁꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠀꠔꠅ ꠖꠤꠟꠦ, ꠄꠞꠣ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_20","070_14_20","MAT","14","20","20","ꠅꠔꠣꠖꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠁꠟꠣ। ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠛꠣꠠꠔꠤ ꠎꠦꠔꠣ ꠞꠁꠟ, ꠅꠈꠘꠣꠁꠘ ꠖꠟꠣ ꠇꠞꠟꠦ ꠛꠣꠞꠅ ꠐꠥꠇꠞꠤ ꠜꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT14_21","070_14_21","MAT","14","21","21","ꠅꠘꠥꠝꠣꠘ ꠙꠣꠌ ꠀꠎꠣꠞ ꠛꠦꠐꠣ ꠝꠣꠘꠡꠦ ꠅꠃ ꠈꠣꠘꠣ ꠈꠣꠁꠟꠣ, ꠄꠞꠣꠞ ꠟꠉꠦ ꠛꠦꠐꠤꠘ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠅ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_22","070_14_22","MAT","14","22","22","ꠈꠣꠘꠤꠞ ꠛꠣꠖꠦꠃ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠎꠣꠁꠛꠣꠞ ꠀꠉꠦ ꠔꠣꠞꠣ ꠘꠣꠅꠅ ꠃꠑꠤꠀ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠎꠣꠁꠔꠣꠉꠤ। ꠇꠁꠀ ꠔꠣꠁꠘ ꠅꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_23","070_14_23","MAT","14","23","23","ꠄꠞꠣ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠖꠥꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠟꠣ। ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠖ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠘꠅ ꠄꠇꠟꠣ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_24","070_14_24","MAT","14","24","24","ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠘꠣꠅ ꠀꠅꠞꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠉꠦꠍꠦꠉꠤ, ꠀꠞ ꠃꠚꠔꠣ ꠛꠣꠔꠣꠡꠞ ꠓꠦꠃꠄ ꠘꠣꠅ ꠈꠥꠛ ꠁꠟꠇꠣꠘꠤ ꠗꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT14_25","070_14_25","MAT","14","25","25","ꠙꠔꠣꠛꠣꠟꠣ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠅꠞꠞ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_26","070_14_26","MAT","14","26","26","ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠈꠥꠛ ꠒꠞꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠜꠥꠔ ꠝꠘꠅ ꠇꠞꠤꠀ ꠜꠥꠔ, ꠜꠥꠔ ꠇꠁꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_27","070_14_27","MAT","14","27","27","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ, ꠡꠣꠅꠡ ꠇꠞꠅ, ꠁ ꠔ ꠀꠝꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT14_28","070_14_28","MAT","14","28","28","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦꠃ ꠎꠥꠖꠤ ꠅꠁꠘ, ꠔꠦ ꠀꠝꠣꠞꠦ ꠁꠎꠣꠎꠔ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠀꠝꠤꠅ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠤꠀ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("MT14_29","070_14_29","MAT","14","29","29","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠅ।” ꠔꠦꠃ ꠙꠤꠔꠞ ꠘꠣꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠣ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_30","070_14_30","MAT","14","30","30","ꠅꠁꠟꠦ ꠛꠣꠔꠣꠡꠞ ꠎꠥꠞ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠒꠞꠣꠁꠉꠦꠟꠣ, ꠀꠞ ꠛꠥꠠꠤꠎꠤꠞꠣ ꠖꠦꠈꠤꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠁꠍꠣꠞꠦ ꠒꠣꠇ ꠖꠤꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT14_31","070_14_31","MAT","14","31","31","ꠟꠉꠦ ꠟꠉꠦ ꠁꠍꠣꠄ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠔꠣꠘꠞꠦ ꠗꠞꠤꠀ ꠇꠁꠟꠣ, “ꠅꠃꠘꠤ ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘ? ꠝꠘꠅ ꠡꠘ꠆ꠖꠄ ꠀꠘꠟꠣꠄ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT14_32","070_14_32","MAT","14","32","32","ꠛꠣꠖꠦ ꠁꠍꠣ ꠀꠞ ꠙꠤꠔꠞ ꠘꠣꠅꠅ ꠃꠑꠔꠦꠃ ꠛꠣꠔꠣꠡ ꠕꠣꠝꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT14_33","070_14_33","MAT","14","33","33","ꠔꠦꠃ ꠘꠣꠅꠞ ꠢꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠍꠟꠦꠃ ꠀꠙꠘꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠁꠛꠘꠥꠟ꠆ꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT14_34","070_14_34","MAT","14","34","34","ꠀꠅꠞ ꠙꠣꠠꠤ ꠖꠤꠀ ꠔꠣꠞꠣ ꠉꠤꠘꠦꠡꠞꠔ ꠄꠟꠣꠇꠣꠔ ꠀꠁꠀ ꠘꠣꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT14_35","070_14_35","MAT","14","35","35","ꠟꠣꠝꠔꠦꠃ ꠢꠘꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠈꠛꠞ ꠙꠣꠑꠣꠁꠟꠣ। ꠈꠛꠞ ꠙꠣꠁꠀ ꠝꠣꠘꠡꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠟꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT14_36","070_14_36","MAT","14","36","36","ꠔꠣꠞꠣ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟ, ꠅꠃ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠦ ꠎꠣꠘꠥ ꠔꠣꠘ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞꠞ ꠇꠥꠘꠣꠈꠣꠘꠅ ꠍꠁꠔꠣ ꠙꠣꠞꠂꠘ। ꠀꠞ ꠎꠔ ꠝꠣꠘꠡꠦ ꠍꠁꠟꠣ, ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠃ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT15_1","070_15_1","MAT","15","1","1","ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠇꠄꠎꠘ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT15_2","070_15_2","MAT","15","2","2","“ꠀꠙꠘꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠛꠣꠔꠣꠁꠟ ꠞꠍꠥꠝꠔ ꠝꠣꠘꠂꠘ ꠘꠣ ꠇꠦꠘꠦ? ꠔꠣꠞꠣ ꠔ ꠅꠎꠥ ꠘꠣ ꠇꠞꠤꠀꠃ ꠈꠣꠘꠤ ꠈꠣꠁꠟꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT15_3","070_15_3","MAT","15","3","3","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅꠃ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠞꠍꠥꠝꠔ ꠝꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠣ ꠇꠦꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠞꠣ? ");
INSERT INTO syls_vpl VALUES ("MT15_4","070_15_4","MAT","15","4","4","ꠀꠟ꠆ꠟꠣꠄ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ‘ꠝꠣ-ꠛꠣꠚꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ, ꠀꠞ ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠄ, ꠔꠣꠞꠦ ꠘꠤꠌꠄ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ।’ ");
INSERT INTO syls_vpl VALUES ("MT15_5","070_15_5","MAT","15","5","5","ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠇꠂꠘ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣꠄ, ‘ꠀꠝꠣꠞ ꠎꠦꠔꠣ ꠍꠣꠝꠣꠘꠣ ꠖꠤꠀ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠔꠣꠝ ꠀꠍꠤꠟ, ꠁꠔꠣ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠟꠣꠁꠍꠤ,’ ");
INSERT INTO syls_vpl VALUES ("MT15_6","070_15_6","MAT","15","6","6","ꠔꠦ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠣ ꠟꠣꠉꠦ ꠘꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠙꠘꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠘꠉꠠꠣ ꠘꠤꠅꠝ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠛꠣꠔꠤꠟ ꠇꠞꠤꠟꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT15_7","070_15_7","MAT","15","7","7","ꠅ ꠜꠘ꠆ꠒ ꠅꠇꠟ! ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠑꠤꠇꠃ ꠇꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("MT15_8","070_15_8","MAT","15","8","8","ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠝꠥꠈ ꠖꠤꠀ ꠈꠣꠟꠤ ꠀꠝꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠦ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠀꠝꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠖꠥꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("MT15_9","070_15_9","MAT","15","9","9","ꠔꠣꠞꠣ ꠢꠥꠖꠣꠞ ꠈꠣꠝꠈꠣ ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠔꠣꠟꠤꠝ ꠅꠇꠟ ꠔ ꠝꠣꠘꠡꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠘꠉꠠꠣ ꠞꠍꠥꠝꠔ।” ");
INSERT INTO syls_vpl VALUES ("MT15_10","070_15_10","MAT","15","10","10","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠔꠣꠟꠤꠝ ꠈꠣꠘꠣꠁꠘ ꠈꠤꠀꠟ ꠇꠞꠤ ꠢꠥꠘꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("MT15_11","070_15_11","MAT","15","11","11","ꠛꠣꠁꠞꠦ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡ ꠝꠣꠘꠡꠞ ꠝꠥꠈꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠄ, ꠁꠔꠣꠄ ꠔ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ ꠘꠣ। ꠛꠞꠋ ꠝꠣꠘꠡꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠛꠣꠞꠅꠄ, ꠅꠔꠣꠄꠃ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT15_12","070_15_12","MAT","15","12","12","ꠔꠦꠃ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠛꠥꠎꠍꠂꠘ ꠘꠤ, ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠝꠘꠅ ꠇꠞꠞꠣ, ꠅꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠀꠙꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠍꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("MT15_13","070_15_13","MAT","15","13","14","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠔꠣꠞ ꠝꠣꠔ ꠚꠣꠟꠣꠅ। ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠉꠣꠍ ꠟꠣꠉꠣꠁꠍꠂꠘ ꠘꠣ, ꠁ ꠉꠣꠍ ꠔꠣꠘ ꠛꠣꠉꠣꠘ ꠕꠣꠇꠤ ꠢꠥꠞꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠛ। ꠔꠣꠞꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠍꠤꠟ ꠀꠘ꠆ꠖꠣ ꠝꠣꠘꠡꠞꠦ ꠙꠕ ꠖꠦꠈꠣꠁꠔ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠘꠤꠎꠦꠃ ꠀꠘ꠆ꠖꠣ ꠛꠘꠤꠉꠦꠍꠦ। ꠇꠥꠘꠥ ꠀꠘ꠆ꠖꠣꠄ ꠀꠞꠇ ꠀꠘ꠆ꠖꠣꠞꠦ ꠙꠕ ꠖꠦꠈꠣꠘꠤꠔ ꠉꠦꠟꠦ, ꠖꠥꠁꠅ ꠀꠘ꠆ꠖꠣꠃ ꠉꠣꠔꠅ ꠙꠠꠤ ꠝꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT15_15","070_15_15","MAT","15","15","15","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ, ꠅꠔꠣ ꠀꠝꠞꠣꠞꠦ ꠛꠥꠎꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT15_16","070_15_16","MAT","15","16","16","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠈꠘꠅ ꠛꠦꠛꠥꠎ ꠞꠁꠍ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT15_17","070_15_17","MAT","15","17","17","ꠔꠥꠝꠞꠣ ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠛꠣꠁꠞꠦ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡ ꠝꠣꠘꠡꠞ ꠝꠥꠈꠅ ꠢꠣꠝꠣꠄ, ꠁꠔꠣ ꠔ ꠈꠣꠟꠤ ꠙꠦꠐꠅ ꠢꠣꠝꠣꠄ, ꠀꠞ ꠙꠦꠐ ꠕꠣꠇꠤ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠞ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT15_18","070_15_18","MAT","15","18","18","ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠛꠣꠞꠅꠄ, ꠁꠔꠣ ꠖꠤꠟꠅ ꠕꠣꠇꠤ ꠀꠄ, ꠀꠞ ꠅꠔꠣꠄꠃ ꠝꠣꠘꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT15_19","070_15_19","MAT","15","19","19","ꠝꠣꠘꠡꠞ ꠖꠤꠟ ꠕꠣꠇꠤꠃ ꠔ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠇꠥ-ꠌꠤꠘ꠆ꠔꠣ ꠛꠣꠞꠅꠄ, ꠎꠦꠝꠘ ꠈꠥꠘ, ꠎꠤꠘꠣ, ꠌꠥꠞꠤ, ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ, ꠀꠞ ꠁꠋꠡꠣ-ꠘꠤꠘ꠆ꠖꠣ ꠛꠣꠞꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT15_20","070_15_20","MAT","15","20","20","ꠅꠔꠣꠄꠃ ꠝꠣꠘꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ, ꠅꠁꠟꠦ ꠅꠎꠥ ꠍꠣꠠꠣ ꠈꠣꠘꠤ ꠈꠣꠁꠟꠦ ꠇꠦꠃ ꠘꠣꠙꠣꠇ ꠅꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT15_21","070_15_21","MAT","15","21","21","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠘꠤꠎꠞ ꠖꠦꠡ ꠍꠣꠠꠤꠀ ꠡꠥꠞ ꠀꠞ ꠍꠤꠖꠘ ꠖꠦꠡꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT15_22","070_15_22","MAT","15","22","22","ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠇꠦꠘꠣꠘꠤ ꠎꠣꠔꠤꠞ ꠄꠇ ꠛꠤꠗꠞ꠆ꠝꠤ ꠛꠦꠐꠤ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟ, “ꠅ ꠢꠥꠎꠥꠞ, ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ, ꠀꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠂꠘ। ꠀꠝꠣꠞ ꠙꠥꠠꠤꠉꠥꠞꠦ ꠎꠤꠘꠦ ꠗꠞꠣꠄ ꠔꠣꠁ ꠛꠠ ꠇꠡ꠆ꠐ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT15_23","070_15_23","MAT","15","23","23","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠤꠟꠣ ꠘꠣ। ꠔꠦꠃ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠃ ꠛꠦꠐꠤꠉꠥꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ, ꠔꠣꠁ ꠀꠝꠞꠣꠞ ꠈꠞꠦ ꠅꠁꠀ ꠌꠤꠟ꠆ꠟꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT15_24","070_15_24","MAT","15","24","24","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞꠦ ꠔ ꠙꠣꠑꠣꠁꠟ ꠅꠁꠍꠦ, ꠈꠣꠟꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠀꠞꠣꠁꠟ ꠝꠦꠠꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT15_25","070_15_25","MAT","15","25","25","ꠅꠁꠟꠦ ꠅꠃ ꠛꠦꠐꠤ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠇꠖꠝꠛꠥꠍꠤ ꠇꠞꠤꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞꠦ ꠅꠃ ꠀꠍꠣꠘꠈꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT15_26","070_15_26","MAT","15","26","26","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠘꠤꠎꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠞꠤꠎꠦꠇ ꠇꠥꠔ꠆ꠔꠣꠞ ꠍꠣꠝꠘꠦ ꠖꠦꠅꠀ ꠑꠤꠇ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT15_27","070_15_27","MAT","15","27","27","ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠎꠤꠅꠄ ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠇꠕꠣꠃ ꠑꠤꠇ, ꠅꠁꠟꠦ ꠝꠥꠘꠤꠛꠞ ꠈꠣꠘꠤ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠉꠥꠠꠣ-ꠉꠣꠠꠣ ꠉꠣꠟꠣꠛꠣꠄ ꠙꠠꠦ, ꠁꠔꠣ ꠔ ꠇꠥꠇꠞꠦ ꠈꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT15_28","070_15_28","MAT","15","28","28","ꠔꠦꠃ ꠔꠣꠁꠘ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠀꠍꠟꠦ ꠉ ꠝꠣꠁ, ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘ ꠛꠠ ꠝꠎꠛꠥꠔ। ꠀꠁꠌ꠆ꠍꠣ, ꠔꠥꠝꠤ ꠎꠦꠟꠣ ꠌꠣꠁꠞꠣꠄ, ꠅꠟꠣꠃ ꠅꠃꠇ।” ꠅꠈꠣꠘ ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠙꠥꠠꠤ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT15_29","070_15_29","MAT","15","29","29","ꠛꠣꠖꠦ ꠁꠍꠣ ꠢꠘ ꠕꠘꠦ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠙꠣꠞꠦꠖꠤ ꠀꠐꠤꠀ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠄꠇ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠀ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT15_30","070_15_30","MAT","15","30","30","ꠛꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠘꠡꠦ ꠟꠥꠟꠣ-ꠟꠦꠋꠠꠣ, ꠀꠔꠥꠞ, ꠀꠘ꠆ꠖꠣ, ꠛꠥꠛꠣ, ꠅꠟꠣꠈꠣꠘ ꠀꠞꠅ ꠛꠃꠔ ꠎꠣꠔꠞ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠖꠟꠦ ꠖꠟꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠟ। ꠀꠘꠤꠀ ꠔꠣꠘ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠕꠁꠟ, ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT15_31","070_15_31","MAT","15","31","31","ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣ, ꠟꠥꠟꠣ-ꠟꠦꠋꠠꠣ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠞꠣ, ꠛꠥꠛꠣ ꠅꠇꠟꠦ ꠝꠣꠔꠤꠞꠣ, ꠀꠔꠥꠞ ꠝꠣꠘꠡꠦ ꠀꠐꠤꠞꠣ, ꠀꠘ꠆ꠖꠣꠄ ꠌꠃꠈꠦ ꠖꠦꠈꠞꠣ, ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠢꠇꠟ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT15_32","070_15_32","MAT","15","32","32","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠘꠤꠀ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠠ ꠖꠞꠖ ꠟꠣꠉꠦꠞ, ꠀꠁꠎ ꠔꠤꠘ ꠖꠤꠘ ꠗꠞꠤ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠊꠥꠞꠤꠞꠣ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠈꠣꠘꠤꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ। ꠔꠦ ꠅꠃ ꠢꠣꠟꠔꠦ ꠄꠞꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠀꠞꠘꠣꠄ ꠁꠔꠣ ꠙꠕꠅꠃ ꠛꠦꠃꠡ ꠅꠁꠎꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT15_33","070_15_33","MAT","15","33","33","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠘꠤꠞꠣꠁ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠅꠔ ꠝꠣꠘꠡꠞꠦ ꠈꠣꠅꠀꠘꠤꠞ ꠟꠣꠉꠤ ꠞꠥꠐꠤ ꠀꠝꠞꠣ ꠇꠥꠀꠁ ꠙꠣꠁꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("MT15_34","070_15_34","MAT","15","34","34","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠄꠈꠣꠘ ꠀꠍꠦ?” ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠡꠣꠔꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠞ ꠛꠤꠞꠣꠘ ꠇꠞꠣ ꠇꠄꠐꠣ ꠢꠥꠞꠥ ꠝꠣꠍ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT15_35","070_15_35","MAT","15","35","35","ꠔꠦꠃ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠝꠣꠐꠤꠔ ꠛꠅꠀꠞ ꠟꠣꠉꠤ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT15_36","070_15_36","MAT","15","36","36","ꠇꠁꠀ ꠔꠣꠁꠘ ꠅꠃ ꠡꠣꠔꠅꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠞ ꠛꠤꠞꠣꠘ ꠝꠣꠍ ꠀꠔꠅ ꠟꠁꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠅꠈꠘꠣꠁꠘ ꠐꠥꠇꠞꠣꠁꠟꠣ, ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦꠖꠤ ꠛꠣꠐꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT15_37","070_15_37","MAT","15","37","37","ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠦ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠁꠟꠣ। ꠈꠣꠁꠀ ꠎꠦꠔꠣ ꠞꠁꠍꠤꠟ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠅꠔꠣ ꠖꠟꠣ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠡꠣꠔ ꠐꠥꠇꠞꠤ ꠜꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT15_38","070_15_38","MAT","15","38","38","ꠅꠘꠥꠝꠣꠘ ꠌꠣꠁꠞ ꠀꠎꠣꠞ ꠛꠦꠐꠣ ꠝꠣꠘꠡꠦ ꠅꠃ ꠈꠣꠘꠣ ꠈꠣꠁꠟꠣ, ꠄꠞꠣꠞ ꠟꠉꠦ ꠛꠦꠐꠤꠘ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠅ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT15_39","070_15_39","MAT","15","39","39","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠀ ꠘꠣꠅꠅ ꠃꠑꠤꠀ ꠝꠉꠖꠘ ꠄꠟꠣꠇꠣꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT16_1","070_16_1","MAT","16","1","1","ꠛꠣꠖꠦ ꠁꠍꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠚꠞꠤꠡꠤ ꠀꠞ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠝꠎꠛꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠀꠍꠝꠣꠘꠤ ꠇꠥꠘꠥ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT16_2","070_16_2","MAT","16","2","2","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠛꠤꠀꠟꠤ ꠛꠣꠟꠣ ꠀꠍꠝꠣꠘꠞ ꠟꠣꠟ ꠞꠋ ꠖꠦꠈꠤꠀ ꠀꠙꠘꠣꠞꠣ ꠇꠂꠘ, ꠇꠣꠁꠟꠇꠥꠞ ꠖꠤꠘ ꠔ ꠜꠣꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT16_3","070_16_3","MAT","16","3","3","ꠀꠞ ꠛꠤꠀꠘꠤ ꠛꠣꠟꠣ ꠀꠍꠝꠣꠘꠅ ꠇꠣꠟꠘꠤ ꠖꠦꠈꠤꠀ ꠇꠂꠘ, ꠀꠁꠎ ꠝꠦꠊ-ꠔꠥꠚꠣꠘ ꠅꠁꠛ। ꠔꠦ ꠀꠍꠝꠣꠘꠞ ꠢꠣꠟꠔ ꠀꠙꠘꠣꠞꠣ ꠑꠤꠇꠃ ꠛꠥꠎꠂꠘ, ꠅꠁꠟꠦ ꠎꠝꠣꠘꠣꠞ ꠢꠣꠟꠔ ꠀꠙꠘꠣꠞꠣ ꠛꠥꠎꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT16_4","070_16_4","MAT","16","4","4","ꠅꠃ ꠎꠝꠣꠘꠣꠞ ꠛꠦꠁꠝꠣꠘ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠦ ꠈꠣꠟꠤ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠔꠣ ꠌꠣꠁꠘ, ꠅꠁꠟꠦ ꠁꠃꠘꠥꠍ ꠘꠛꠤꠞ ꠘꠤꠡꠣꠘꠣ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠘꠤꠡꠣꠘꠣ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠔ ꠘꠣꠄ।” ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠕꠁꠀ ꠢꠞꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT16_5","070_16_5","MAT","16","5","5","ꠛꠣꠖꠦ ꠀꠅꠞ ꠙꠣꠠꠤ ꠖꠤꠀ ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠟꠉꠦ ꠇꠞꠤ ꠞꠥꠐꠤ ꠘꠤꠔꠣ ꠚꠣꠃꠞꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT16_6","070_16_6","MAT","16","6","6","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠡꠣꠛꠗꠣꠘ ꠅꠅ, ꠚꠞꠤꠡꠤ ꠀꠞ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠖꠟꠞ ꠈꠣꠝꠤꠞ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT16_7","070_16_7","MAT","16","7","7","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠞꠥꠐꠤ ꠀꠘꠍꠤ ꠘꠣ ꠇꠞꠤ ꠝꠘꠅꠟꠄ ꠔꠣꠁꠘ ꠅꠈꠣꠘ ꠇꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT16_8","070_16_8","MAT","16","8","8","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠜꠣꠛ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠛꠥꠎꠤꠀ ꠇꠁꠟꠣ, “ꠢꠣꠄꠞꠦ ꠇꠝꠎꠥꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠥꠐꠤ ꠘꠣꠁ, ꠁꠈꠣꠘ ꠇꠁꠞꠣꠄ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("MT16_9","070_16_9","MAT","16","9","9","ꠔꠥꠝꠞꠣ ꠅꠈꠘꠅ ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠅ ꠘꠣ ꠘꠤ, ꠇꠥꠘ꠆ꠔꠣ ꠝꠘꠅ ꠅꠞ ꠘꠣ ꠘꠤ? ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤꠖꠤ ꠙꠣꠌ ꠀꠎꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠈꠣꠅꠀꠁꠍꠟꠣꠝ, ꠈꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠇꠔ ꠐꠥꠇꠞꠤ ꠉꠥꠠꠣ-ꠉꠣꠠꠣ ꠖꠟꠣ ꠇꠞꠍꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("MT16_10","070_16_10","MAT","16","10","10","ꠀꠞ ꠢꠃ ꠎꠦ ꠡꠣꠔꠈꠣꠘ ꠞꠥꠐꠤꠖꠤ ꠌꠣꠁꠞ ꠀꠎꠣꠞ ꠝꠣꠘꠡꠦ ꠈꠣꠁꠍꠟꠣ, ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠇꠔ ꠐꠥꠇꠞꠤ ꠖꠟꠣ ꠇꠞꠍꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("MT16_11","070_16_11","MAT","16","11","11","ꠔꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠅ ꠘꠣ ꠇꠦꠘꠦ, ꠀꠝꠤ ꠅꠃ ꠞꠥꠐꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠀꠞ ꠘꠣ? ꠢꠥꠘꠅ, ꠚꠞꠤꠡꠤ ꠀꠞ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠅꠇꠟꠞ ꠈꠣꠝꠤꠞ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞ ꠅꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT16_12","070_16_12","MAT","16","12","12","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠛꠥꠎꠟꠣ, ꠔꠣꠁꠘ ꠀꠍꠟꠦ ꠈꠣꠁꠛꠣꠞ ꠈꠣꠝꠤꠞ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞꠞ ꠇꠕꠣ ꠇꠁꠞꠣ ꠘꠣ, ꠛꠞꠋ ꠚꠞꠤꠡꠤ ꠀꠞ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠅꠇꠟꠞ ꠔꠣꠟꠤꠝ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞ ꠅꠁꠔꠦ ꠇꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT16_13","070_16_13","MAT","16","13","13","ꠛꠣꠖꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠇꠂꠍꠞꠤꠀ-ꠚꠤꠟꠤꠙꠤ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠔ ꠉꠦꠟꠣ। ꠙꠕꠅ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠝꠣꠘꠡꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT16_14","070_16_14","MAT","16","14","14","ꠄꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠇꠂꠘ, ꠀꠙꠘꠦ ꠄꠢꠤꠀ ꠘꠛꠤ। ꠇꠥꠘꠥ ꠎꠘꠦ ꠇꠂꠘ ꠁꠟꠤꠀꠍ ꠘꠛꠤ। ꠇꠦꠃ ꠇꠦꠃ ꠇꠄ ꠁꠀꠞꠝꠤꠀ ꠘꠛꠤ, ꠛꠣ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠘꠛꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT16_15","070_16_15","MAT","16","15","15","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠅ, ꠀꠝꠤ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT16_16","070_16_16","MAT","16","16","16","ꠍꠣꠢꠣꠛꠤ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT16_17","070_16_17","MAT","16","17","17","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠍꠣꠁꠝꠘ ꠛꠤꠘ ꠁꠃꠘꠥꠍ, ꠔꠥꠝꠤ ꠛꠠ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ, ꠇꠣꠞꠘ, ꠖꠥꠘꠤꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠁꠔꠣ ꠎꠣꠘꠣꠁꠍꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄꠃ ꠎꠣꠘꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT16_18","070_16_18","MAT","16","18","18","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠔ ꠙꠣꠔ꠆ꠔꠞ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠖꠤꠍꠟꠣꠝ ꠙꠤꠔꠞ, ꠀꠞ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦꠃ ꠀꠝꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠔꠣꠝꠣꠝ ꠎꠝꠣꠔ ꠉꠠꠤꠀ ꠔꠥꠟꠝꠥ। ꠖꠥꠎꠈꠤ ꠇꠥꠘꠥ ꠡꠇ꠆ꠔꠤꠄꠃ ꠄꠞ ꠟꠉꠦ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT16_19","070_16_19","MAT","16","19","19","ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠌꠣꠛꠤ ꠖꠤꠝꠥ, ꠅꠃ ꠖꠥꠘꠤꠀꠔ ꠔꠥꠝꠤ ꠎꠦꠔꠣꠞꠦ ꠘꠣꠎꠣꠁꠎ ꠇꠁꠛꠣꠄ, ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠘꠣꠎꠣꠁꠎ ꠅꠁꠎꠤꠛ, ꠀꠞ ꠔꠥꠝꠤ ꠎꠦꠔꠣꠞꠦ ꠎꠣꠁꠎ ꠇꠁꠛꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ-ꠅ ꠁꠔꠣ ꠎꠣꠁꠎ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT16_20","070_16_20","MAT","16","20","20","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠖꠠꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠎꠦꠘ ꠢꠃ ꠀꠟ-ꠝꠍꠤ, ꠁꠔꠣ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT16_21","070_16_21","MAT","16","21","21","ꠅꠃ ꠡꠝꠄ ꠕꠣꠇꠤ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠣꠘꠤ ꠗꠞꠟꠣ, ꠔꠣꠁꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠁꠔꠦ ꠅꠁꠛ। ꠢꠘꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ, ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠛꠃꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠅ ꠚꠣꠟꠣꠁꠛꠣ। ꠛꠣꠖꠦ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT16_22","070_16_22","MAT","16","22","22","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠔꠣꠘꠞꠦ ꠕꠥꠠꠣ ꠢꠞꠣꠁꠀ ꠘꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠡꠝ꠆ꠛꠛ, ꠀꠙꠘꠣꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠁꠔꠣ ꠅꠁꠔꠦ ꠙꠣꠞꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT16_23","070_16_23","MAT","16","23","23","ꠁꠍꠣꠄ ꠙꠤꠔꠞꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠀ ꠇꠁꠟꠣ, “ꠗꠥꠞ ꠁꠛꠟꠤꠍ, ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉ! ꠔꠥꠁ ꠀꠝꠣꠞ ꠙꠕꠞ ꠎꠁꠘ꠆ꠎꠣꠟ। ꠔꠥꠁ ꠀꠟ꠆ꠟꠣꠁ ꠝꠥꠘꠡꠣꠞꠦ ꠛꠣꠖ ꠖꠤꠀ, ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT16_24","070_16_24","MAT","16","24","24","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠔꠞꠤꠇꠣꠔ ꠀꠁꠔ ꠌꠣꠄ, ꠔꠦ ꠢꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠌꠟꠣ ꠛꠣꠖ ꠖꠦꠃꠇ, ꠔꠣꠞ ꠀꠙꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛ ꠛꠁꠀ ꠟꠁꠀ ꠀꠝꠣꠞ ꠈꠞꠦ ꠀꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT16_25","070_16_25","MAT","16","25","25","ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ ꠌꠣꠄ, ꠢꠦ ꠔꠣꠞ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠥꠀꠁꠛ। ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠄ, ꠢꠦ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT16_26","070_16_26","MAT","16","26","26","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀ ꠙꠣꠁꠀꠅ ꠎꠥꠖꠤ ꠔꠣꠞ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠥꠀꠁꠟꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠟ ꠘꠤ? ꠢꠦꠡꠦ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠦ ꠇꠥꠘ ꠗꠘ ꠛꠤꠟꠣꠁꠛ? ");
INSERT INTO syls_vpl VALUES ("MT16_27","070_16_27","MAT","16","27","27","ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣꠄ ꠎꠉꠔꠅ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠞ ꠀꠝꠟ ꠝꠣꠚꠤꠇ ꠚꠟ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("MT16_28","070_16_28","MAT","16","28","28","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠅꠘꠅ ꠁꠟꠣꠈꠣꠘ ꠇꠄꠎꠘ ꠀꠎꠤꠞ ꠀꠍꠂꠘ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠛꠣꠖꠡꠣ ꠢꠣꠟꠔꠦ ꠘꠣ ꠀꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠄꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT17_1","070_17_1","MAT","17","1","1","ꠄꠞ ꠍꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠈꠣꠟꠤ ꠙꠤꠔꠞ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠜꠣꠁ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠟꠁꠀ ꠃꠌꠣ ꠄꠇ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT17_2","070_17_2","MAT","17","2","2","ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠄꠞꠣꠞ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠍꠥꠞꠔ ꠛꠖꠟꠤ ꠉꠦꠟ। ꠔꠣꠘ ꠝꠥꠈ ꠅꠁꠉꠦꠟ ꠡꠥꠞꠥꠎꠞ ꠟꠣꠈꠣꠘ ꠏꠟꠝꠟ, ꠀꠞ ꠚꠤꠘ꠆ꠘꠞ ꠟꠦꠛꠣꠍ ꠅꠁꠟ ꠗꠟꠣ ꠌꠇꠌꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("MT17_3","070_17_3","MAT","17","3","3","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠖꠦꠈꠟꠣ, ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠄ ꠀꠁꠀ ꠔꠣꠘ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT17_4","070_17_4","MAT","17","4","4","ꠅꠃ ꠡꠝꠄ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠔ ꠅꠘꠅ ꠀꠍꠤ, ꠈꠥꠛ ꠜꠣꠟꠣ ꠅꠁꠍꠦ। ꠀꠙꠘꠦ ꠌꠣꠁꠟꠦ ꠀꠝꠤ ꠔꠤꠘꠈꠣꠘ ꠒꠦꠞꠣ-ꠊꠞ ꠛꠣꠘꠣꠁꠟꠣꠁ, ꠄꠇꠈꠣꠘ ꠀꠙꠘꠣꠞ, ꠄꠇꠈꠣꠘ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠀꠞ ꠄꠇꠈꠣꠘ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT17_5","070_17_5","MAT","17","5","5","ꠔꠣꠁꠘ ꠁꠍꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠞꠣ, ꠀꠈꠔꠣꠃ ꠗꠟꠣ ꠗꠛꠗꠛꠣ ꠝꠦꠊꠞ ꠄꠇ ꠐꠥꠇꠞꠣꠄ ꠀꠁꠀ ꠄꠞꠣꠞꠦ ꠉꠥꠞꠤꠟꠤꠟ, ꠀꠞ ꠅꠃ ꠐꠥꠇꠞꠣ ꠕꠣꠇꠤ ꠉꠣꠁꠛꠤ ꠀꠅꠀꠎ ꠀꠁꠟ, “ꠄꠁꠘꠃ ꠀꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠄꠘ ꠃꠙꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ, ꠔꠥꠝꠞꠣ ꠄꠘ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT17_6","070_17_6","MAT","17","6","6","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠈꠥꠛ ꠒꠞꠣꠁꠟꠣ, ꠒꠞꠣꠁꠀ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT17_7","070_17_7","MAT","17","7","7","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠍꠁꠀ ꠇꠁꠟꠣ, “ꠃꠑꠅ, ꠒꠞꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT17_8","070_17_8","MAT","17","8","8","ꠔꠦꠃ ꠔꠣꠞꠣ ꠌꠃꠈ ꠔꠥꠟꠤ ꠌꠣꠁꠟꠣ, ꠌꠣꠁꠀ ꠈꠣꠟꠤ ꠁꠍꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠁꠘꠅ ꠖꠦꠈꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT17_9","070_17_9","MAT","17","9","9","ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠅꠀꠞ ꠛꠣꠟꠣ ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠀꠁꠎ ꠎꠦꠔꠣ ꠖꠦꠈꠟꠣꠄ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT17_10","070_17_10","MAT","17","10","10","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠇꠦꠘꠦ ꠇꠂꠘ, ꠀꠟ-ꠝꠍꠤ ꠀꠁꠛꠣꠞ ꠀꠉꠦ, ꠙꠄꠟꠣ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞ ꠀꠅꠀ ꠎꠞꠥꠞ?” ");
INSERT INTO syls_vpl VALUES ("MT17_11","070_17_11","MAT","17","11","11","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠈꠣꠘ ꠢꠣꠍꠣ ꠇꠕꠣ, ꠙꠄꠟꠣ ꠢꠎꠞꠔ ꠁꠟꠤꠀꠍꠦ ꠀꠁꠀ ꠢꠇ꠆ꠇꠟꠔꠣ ꠀꠉꠞ ꠢꠣꠟꠔꠅ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT17_12","070_17_12","MAT","17","12","12","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠁꠟꠤꠀꠍ ꠘꠛꠤ ꠑꠤꠇꠃ ꠀꠁꠍꠟꠣ। ꠁ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠘꠣ ꠌꠤꠘꠣꠄ, ꠔꠣꠘ ꠟꠉꠦ ꠎꠦꠔꠣ ꠝꠘꠅꠟꠄ ꠅꠔꠣ ꠇꠞꠍꠦ। ꠀꠞ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠙꠥꠀꠘꠤ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT17_13","070_17_13","MAT","17","13","13","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠔꠣꠁꠘ ꠅꠈꠘ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠇꠕꠣ ꠇꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT17_14","070_17_14","MAT","17","14","14","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ। ꠅꠘꠅ ꠝꠣꠘꠡꠞ ꠜꠤꠠ ꠀꠍꠤꠟ, ꠅꠃ ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠄꠇ ꠛꠦꠐꠣ ꠀꠁꠀ ꠁꠍꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠐꠥ ꠉꠣꠟꠣꠖꠤ ꠛꠁꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT17_15","070_17_15","MAT","17","15","15","“ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠙꠥꠀꠉꠥꠞꠦ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ, ꠢꠦ ꠝꠤꠞꠇꠤ ꠛꠦꠝꠣꠞꠦ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠇꠞꠦꠞ। ꠅꠃ ꠛꠦꠝꠣꠞ ꠃꠑꠟꠦ ꠢꠦ ꠢꠣꠝꠦꠡꠣ ꠀꠉꠥꠘꠤꠔ ꠀꠞ ꠙꠣꠘꠤꠔ ꠙꠠꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT17_16","070_17_16","MAT","17","16","16","ꠀꠝꠤ ꠔꠣꠞꠦ ꠟꠁꠀ ꠀꠙꠘꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠁꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠜꠣꠟꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠍꠂꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT17_17","070_17_17","MAT","17","17","17","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠣꠄꠞꠦ ꠛꠦꠁꠝꠣꠘ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠎꠣꠔ, ꠀꠝꠤ ꠀꠞ ꠇꠔꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠎꠣꠟꠣ ꠇꠔꠖꠤꠘ ꠡꠁꠎ꠆ꠎ ꠇꠞꠝꠥ? ꠖꠦꠈꠤ, ꠔꠥꠝꠣꠞ ꠙꠥꠀꠞꠦ ꠅꠘꠅ ꠀꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT17_18","070_17_18","MAT","17","18","18","ꠁꠍꠣꠄ ꠙꠥꠀꠞ ꠟꠉꠞ ꠢꠃ ꠎꠤꠘ꠆ꠘꠣꠔꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠟꠣ, ꠗꠣꠝꠇꠤ ꠈꠣꠁꠀ ꠎꠤꠘꠦ ꠙꠥꠀꠞꠦ ꠍꠣꠠꠤꠀ ꠉꠦꠟꠉꠤ, ꠟꠉꠦ ꠟꠉꠦ ꠢꠦ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT17_19","070_17_19","MAT","17","19","19","ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠘꠤꠞꠣꠟꠣꠄ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠇꠦꠘꠦ ꠅꠃ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠘꠣ?” ");
INSERT INTO syls_vpl VALUES ("MT17_20","070_17_20","MAT","17","20","20","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠇꠝꠎꠥꠞꠤꠞ ꠟꠣꠉꠤꠃ ꠙꠣꠞꠍ ꠘꠣ। ꠀꠝꠤ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠥꠖꠤ ꠄꠉꠥ ꠒꠦꠋꠉꠣ ꠛꠤꠌꠤ ꠙꠞꠤꠝꠣꠘ ꠁꠝꠣꠘ ꠕꠣꠇꠦ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠃ ꠙꠣꠠꠞꠦ ꠇꠅ, ‘ꠅꠘ ꠕꠣꠇꠤ ꠒꠥꠟꠤꠀ ꠢꠘꠅ ꠎꠣꠅꠉꠤ,’ ꠔꠦ ꠅꠃ ꠙꠣꠠꠅ ꠒꠥꠟꠤꠎꠤꠛ। ꠔꠥꠝꠞꠣꠞ ꠅꠡꠣꠁꠖ꠆ꠖ ꠇꠥꠘ꠆ꠔꠣꠃ ꠞꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT17_21","070_17_21","MAT","17","21","21","ꠢꠥꠘꠅ, ꠖꠥꠀ ꠀꠞ ꠞꠥꠎꠣ ꠞꠣꠈꠣ ꠍꠣꠠꠣ ꠁ-ꠎꠣꠔ ꠎꠤꠘ ꠍꠣꠠꠣꠁꠟ ꠎꠣꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT17_22","070_17_22","MAT","17","22","22","ꠛꠣꠖꠦ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠀꠁꠀ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠝꠣꠘꠡꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT17_23","070_17_23","MAT","17","23","23","ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣ, ꠝꠞꠣꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠝꠥ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT17_24","070_17_24","MAT","17","24","24","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠅꠇꠟꠦ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣꠞ ꠃꠡ꠆ꠔꠣꠖꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠇꠣꠛꠣ ꠡꠞꠤꠚꠞ ꠌꠣꠘ꠆ꠖꠣ ꠖꠦꠁꠘ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT17_25","070_17_25","MAT","17","25","25","ꠙꠤꠔꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠎꠤꠅꠄ, ꠖꠦꠁꠘ ꠔ।” ꠅꠈꠣꠘ ꠇꠁꠀ ꠙꠤꠔꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠣꠞ ꠀꠉꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠙꠤꠔꠞ, ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠅ? ꠖꠥꠘꠤꠀꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠦ ꠇꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠈꠣꠎꠘꠣ-ꠌꠣꠘ꠆ꠖꠣ ꠀꠖꠣꠄ ꠇꠞꠂꠘ? ꠘꠤꠎꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠘꠣ ꠛꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT17_26","070_17_26","MAT","17","26","26","ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ।” ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠔ ꠘꠤꠎꠞ ꠝꠣꠘꠥꠡ ꠁꠔꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠤ ꠉꠦꠟ, ꠀꠞ ꠀꠝꠞꠣꠅ ꠀꠟ꠆ꠟꠣꠞ ꠀꠙꠘ ꠝꠣꠘꠥꠡ ꠅꠀꠄ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠈꠣꠎꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠤ ꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("MT17_27","070_17_27","MAT","17","27","27","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠄꠞꠣꠞꠦ ꠛꠦꠎꠣꠞ ꠇꠞꠔꠣꠝ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠀꠅꠞꠅ ꠎꠣꠅ, ꠉꠤꠀ ꠝꠣꠍ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠞꠤ ꠚꠣꠟꠣꠅ, ꠛꠞꠤꠔ ꠙꠄꠟꠣ ꠎꠦ ꠝꠣꠍ ꠟꠣꠉꠛ, ꠅꠉꠥꠞ ꠝꠥꠈꠞ ꠜꠤꠔꠞꠦ ꠄꠇꠐꠣ ꠞꠥꠙꠣꠞ ꠐꠦꠇꠣ ꠙꠣꠁꠛꠣꠄ। ꠅꠃ ꠐꠦꠇꠣ ꠘꠤꠀ ꠔꠥꠝꠣꠞ ꠀꠞ ꠀꠝꠣꠞ ꠌꠣꠘ꠆ꠖꠣ ꠖꠤꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT18_1","070_18_1","MAT","18","1","1","ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠝꠣꠎꠦ ꠢꠇ꠆ꠇꠟ ꠕꠣꠇꠤ ꠛꠠ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT18_2","070_18_2","MAT","18","2","2","ꠔꠦꠃ ꠁꠍꠣꠄ ꠄꠇ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠒꠣꠇꠤꠀ ꠀꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠃꠛꠣ ꠇꠞꠣꠁ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT18_3","070_18_3","MAT","18","3","3","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠝꠘ ꠚꠤꠞꠣꠁꠀ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠘꠣ ꠅꠅ, ꠔꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT18_4","070_18_4","MAT","18","4","4","ꠎꠦ ꠎꠘꠦ ꠘꠤꠎꠞꠦ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠢꠥꠞꠥ ꠝꠘꠅ ꠇꠞꠦ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠦ-ꠃ ꠢꠇꠟ ꠕꠣꠇꠤ ꠖꠣꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("MT18_5","070_18_5","MAT","18","5","5","ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠍꠣꠛꠣꠟꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠀꠝꠣꠞꠦꠃ ꠇꠛꠥꠟ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT18_6","070_18_6","MAT","18","6","6","“ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠅꠃ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠄꠇꠎꠘꠞꠦ ꠎꠦꠉꠤꠄ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠤꠀ ꠘꠦꠄ, ꠅꠉꠥꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠜꠣꠟꠣ ꠅꠁꠟ ꠅꠘꠦ, ꠅꠉꠥꠞ ꠉꠟꠣꠔ ꠙꠣꠔ꠆ꠔꠞ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("MT18_7","070_18_7","MAT","18","7","7","ꠢꠣꠄꠞꠦ ꠖꠥꠘꠤꠀ, ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠇꠔ ꠃꠍꠇꠣꠘꠤ ꠀꠍꠦ! ꠃꠍꠇꠣꠘꠤ ꠔ ꠀꠁꠛꠃ ꠀꠁꠛ। ꠅꠁꠟꠦ ꠟꠣꠘ꠆ꠘꠔ ꠢꠃ ꠎꠘꠞ ꠃꠙꠞꠦ, ꠎꠦꠉꠤꠄ ꠉꠥꠘꠣ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠃꠍꠇꠣꠘꠤ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("MT18_8","070_18_8","MAT","18","8","8","ꠔꠥꠝꠣꠞ ꠀꠔ ꠛꠣ ꠙꠣꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠦ, ꠔꠦ ꠁ ꠀꠔ-ꠙꠣꠅ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠅ। ꠖꠥꠁꠅ ꠀꠔ-ꠙꠣꠅ ꠟꠁꠀ ꠖꠥꠎꠈꠅ ꠎꠟꠣ ꠕꠣꠇꠤ, ꠀꠔꠥꠞ ꠅꠁꠀꠅ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠎꠣꠅꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_9","070_18_9","MAT","18","9","9","ꠔꠥꠝꠣꠞ ꠌꠃꠈꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠦ, ꠔꠦ ꠁ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠅ। ꠖꠥꠁꠅ ꠌꠃꠈ ꠟꠁꠀ ꠖꠥꠎꠈꠅ ꠎꠟꠣ ꠕꠣꠇꠤ, ꠇꠣꠘꠣ ꠅꠁꠀꠅ ꠀꠈꠦꠞ ꠙꠣꠅꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_10","070_18_10","MAT","18","10","10","“ꠢꠥꠘꠅ, ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠍꠣꠛꠣꠟꠞꠦꠅ ꠄꠟꠣꠝꠤ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠣꠞꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠥꠈ ꠖꠦꠈꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_11","070_18_11","MAT","18","11","11","ꠎꠣꠘ ꠘꠤ, ꠎꠦꠞꠣ ꠛꠦ-ꠙꠕꠦ ꠉꠦꠍꠦꠉꠤ, ꠄꠞꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠁ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("MT18_12","070_18_12","MAT","18","12","12","“ꠝꠘꠅ ꠇꠞꠅ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠄꠇ-ꠡꠉꠥ ꠝꠦꠠꠣ ꠀꠍꠦ, ꠄꠞ ꠝꠣꠎꠞ ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠞꠣꠁ ꠉꠦꠟꠦ ꠢꠦ ꠛꠣꠇꠤ ꠘꠤꠞꠣꠘ꠆ꠘꠛ꠆ꠛꠁꠐꠣ ꠛꠘ꠆ꠖꠅ ꠕꠁꠀ, ꠢꠃ ꠀꠞꠣꠁꠟ ꠅꠉꠥ ꠔꠥꠇꠣꠘꠤꠔ ꠎꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT18_13","070_18_13","MAT","18","13","13","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠢꠦ ꠎꠥꠖꠤ ꠁꠇꠐꠣ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠄ, ꠔꠦ ꠎꠦ ꠘꠤꠞꠣꠘ꠆ꠘꠛ꠆ꠛꠁꠉꠥ ꠀꠞꠍꠤꠟ ꠘꠣ, ꠅꠉꠥꠁꠘ ꠕꠁꠀ ꠎꠦꠉꠥ ꠀꠞꠤ ꠉꠦꠍꠤꠟ, ꠅꠉꠥꠞ ꠟꠣꠉꠤꠃ ꠢꠦ ꠈꠥꠛ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT18_14","070_18_14","MAT","18","14","14","ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄꠅ ꠌꠣꠁꠘ ꠘꠣ, ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠞ ꠄꠉꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠅ ꠛꠤꠘꠣꠡ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT18_15","070_18_15","MAT","18","15","15","“ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠜꠣꠁꠄ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠖꠥꠡ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠢꠦ ꠎꠦꠛꠟꠣ ꠘꠤꠞꠣꠟꠣꠄ ꠕꠣꠇꠦ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠤ ꠄꠇꠟꠣ ꠉꠤꠀ ꠔꠣꠞꠦ ꠛꠥꠎꠣꠁꠅ। ꠔꠥꠝꠣꠞ ꠛꠥꠎ ꠎꠥꠖꠤ ꠝꠣꠘꠤꠟꠣꠄ, ꠔꠦ ꠅꠃ ꠜꠣꠁꠞ ꠟꠉꠦ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠀꠟꠤ ꠛꠣꠌꠣꠁꠟꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT18_16","070_18_16","MAT","18","16","16","ꠅꠁꠟꠦ ꠢꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠛꠥꠎ ꠘꠣ ꠝꠣꠘꠦ, ꠔꠦ ꠀꠞꠅ ꠖꠥꠁ-ꠄꠇꠎꠘ ꠝꠣꠎꠞ ꠝꠣꠘꠥꠡ ꠟꠁꠀ ꠎꠣꠁꠅ। ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠦ ꠛꠥꠎꠣꠁꠅ। ꠔꠦꠃ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠙꠥꠞꠣ ꠅꠁꠛ, ‘ꠖꠥꠁ-ꠔꠤꠘꠎꠘ ꠡꠣꠇ꠆ꠇꠤꠞ ꠇꠕꠣꠄ ꠎꠦꠇꠥꠘꠥ ꠛꠦꠙꠣꠞ ꠙꠞꠝꠣꠘ ꠅꠄ।’ ");
INSERT INTO syls_vpl VALUES ("MT18_17","070_18_17","MAT","18","17","17","ꠄꠞꠣꠞ ꠛꠥꠎꠅ ꠎꠥꠖꠤ ꠢꠦ ꠘꠣ ꠝꠣꠘꠦ, ꠔꠦ ꠔꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠝꠣꠔꠅ ꠘꠣꠟꠤꠡ ꠖꠦꠅ। ꠎꠝꠣꠔꠞ ꠇꠕꠣ ꠎꠥꠖꠤ ꠝꠣꠘꠤꠟꠣꠄ ꠔꠦ ꠜꠣꠟꠣ, ꠀꠞ ꠘꠣ ꠝꠣꠘꠟꠦ ꠔꠣꠞꠦ ꠛꠤꠗꠞ꠆ꠝꠤ ꠛꠣ ꠊꠥꠡꠈꠥꠞ ꠔꠡꠤꠟꠖꠣꠞ ꠝꠘꠅ ꠇꠞꠤꠀ, ꠔꠣꠞꠦ ꠔꠣꠞ ꠙꠕꠦ ꠍꠣꠠꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("MT18_18","070_18_18","MAT","18","18","18","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠅꠃ ꠖꠥꠘꠤꠀꠁꠔ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣꠞꠦ ꠘꠣꠎꠣꠁꠎ ꠇꠁꠛꠣꠄ, ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠘꠣꠎꠣꠁꠎ ꠅꠁꠎꠤꠛ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣꠞꠦ ꠎꠣꠁꠎ ꠇꠁꠛꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ-ꠅ ꠁꠔꠣ ꠎꠣꠁꠎ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT18_19","070_18_19","MAT","18","19","19","“ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠖꠥꠁꠎꠘ ꠎꠥꠖꠤ ꠄꠇꠝꠔ ꠅꠁꠀ ꠇꠥꠘꠥ ꠛꠦꠙꠣꠞꠦ ꠖꠥꠀ ꠇꠞꠦ, ꠔꠦ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_20","070_18_20","MAT","18","20","20","ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠖꠥꠁ ꠛꠣ ꠔꠤꠘ ꠎꠘ ꠎꠝꠣ ꠅꠄ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠀꠝꠤꠅ ꠀꠎꠤꠞ ꠕꠣꠇꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT18_21","070_18_21","MAT","18","21","21","ꠅꠃ ꠡꠝꠄ ꠙꠤꠔꠞꠦ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠜꠣꠁꠄ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠛꠣꠞ ꠛꠣꠞ ꠖꠥꠡ ꠇꠞꠦ, ꠔꠦ ꠀꠝꠤ ꠇꠔꠛꠣꠞ ꠔꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠔꠣꠝ? ꠡꠣꠔ ꠛꠣꠞ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT18_22","070_18_22","MAT","18","22","22","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠈꠣꠟꠤ ꠡꠣꠔ ꠛꠣꠞ ꠘꠣꠄ, ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠔꠣꠞꠦ ꠡꠔ꠆ꠔꠁꠞ ꠉꠥꠘ ꠡꠣꠔ ꠛꠣꠞ ꠝꠣꠚ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("MT18_23","070_18_23","MAT","18","23","23","“ꠢꠥꠘꠅ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠟꠣ ꠄꠇ ꠛꠣꠖꠡꠣꠞ ꠟꠣꠈꠣꠘ, ꠎꠦꠁꠘ ꠔꠣꠘ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠉꠦꠍꠦ ꠢꠤꠡꠣꠛ-ꠘꠤꠇꠣꠡ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_24","070_18_24","MAT","18","24","24","ꠛꠣꠖꠡꠣꠄ ꠢꠤꠡꠣꠛ ꠟꠅꠀꠔ ꠛꠁꠟꠦ ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠅꠟꠣ ꠄꠇ ꠎꠘꠞꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠘꠣ ꠅꠁꠟ, ꠛꠣꠖꠡꠣꠄ ꠄꠞ ꠉꠦꠍꠦ ꠟꠣꠈ ꠟꠣꠈ ꠐꠦꠇꠣ ꠙꠣꠅꠘꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_25","070_18_25","MAT","18","25","25","ꠅꠃ ꠙꠣꠅꠘꠣ ꠚꠤꠞꠔ ꠖꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠄꠞ ꠘꠣꠁ। ꠄꠞꠖꠣꠄ ꠛꠣꠖꠡꠣꠄ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠢꠦ ꠡꠥꠖ꠆ꠖꠣ ꠔꠣꠞ ꠛꠃ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠉꠥꠟꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠛꠤꠇꠤ ꠈꠣꠁꠀ, ꠢꠇꠟ ꠡꠄ-ꠡꠝ꠆ꠙꠔ꠆ꠔꠤ ꠛꠦꠌꠤꠀ ꠔꠣꠘ ꠙꠣꠅꠘꠣ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT18_26","070_18_26","MAT","18","26","26","ꠅꠃ ꠢꠥꠇꠥꠝ ꠢꠥꠘꠤꠀ ꠢꠦ ꠛꠣꠖꠡꠣꠞ ꠙꠣꠅꠔ ꠗꠞꠤꠀ ꠇꠣꠘ꠆ꠖꠤꠀ ꠇꠁꠟ, ‘ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞꠦ ꠕꠥꠠꠣ ꠡꠥꠎꠥꠉ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠢꠇꠟ ꠙꠣꠅꠘꠣ ꠖꠤꠟꠣꠁꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("MT18_27","070_18_27","MAT","18","27","27","ꠅꠃ ꠔꠣꠁꠘ ꠖꠄꠀ ꠇꠞꠤꠀ ꠔꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠟꠣ, ꠀꠞ ꠢꠇꠟ ꠖꠦꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_28","070_18_28","MAT","18","28","28","“ꠛꠣꠖꠦ ꠢꠦ ꠛꠣꠞꠦ ꠉꠤꠀ ꠔꠣꠞ ꠟꠉꠞ ꠀꠞꠇ ꠌꠣꠇꠞꠤꠀꠘꠞꠦ ꠙꠣꠁꠟ। ꠅꠃ ꠎꠘꠞ ꠉꠦꠍꠦ ꠢꠦ ꠄꠇ-ꠡ ꠐꠦꠇꠣ ꠙꠣꠅꠘꠣ ꠀꠍꠤꠟ। ꠙꠣꠁꠀ ꠔꠣꠞꠦ ꠉꠟꠣꠔ ꠐꠤꠙꠣ ꠝꠣꠞꠤ ꠗꠞꠤꠀ ꠇꠁꠟ, ‘ꠅꠂ, ꠔꠥꠁ ꠀꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠐꠦꠇꠣ ꠖꠦ।’ ");
INSERT INTO syls_vpl VALUES ("MT18_29","070_18_29","MAT","18","29","29","ꠢꠃ ꠎꠘꠦ ꠔꠣꠞ ꠙꠣꠅ-ꠅ ꠙꠠꠤ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟ, ‘ꠀꠝꠣꠞꠦ ꠕꠥꠠꠣ ꠡꠥꠎꠥꠉ ꠖꠦꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠙꠣꠅꠘꠣ ꠖꠤꠟꠣꠁꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("MT18_30","070_18_30","MAT","18","30","30","ꠅꠁꠟꠦ ꠢꠦ ꠄꠞ ꠇꠕꠣ ꠝꠣꠘꠟ ꠘꠣ। ꠔꠣꠞ ꠐꠦꠇꠣ ꠘꠣ ꠖꠦꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁ ꠕꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT18_31","070_18_31","MAT","18","31","31","“ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞ ꠟꠉꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠅꠇꠟ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠟꠣ। ꠔꠣꠞꠣ ꠉꠤꠀ ꠁꠔꠣ ꠛꠣꠖꠡꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_32","070_18_32","MAT","18","32","32","ꠛꠣꠖꠡꠣꠄ ꠢꠃ ꠌꠣꠇꠞꠤꠀꠘꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, ‘ꠢꠣꠄꠞꠦ ꠘꠣꠚꠞꠝꠣꠘ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠣꠄ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠖꠦꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠁꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("MT18_33","070_18_33","MAT","18","33","33","ꠔꠦ ꠀꠝꠤ ꠎꠦꠟꠣ ꠔꠥꠝꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠍꠟꠣꠝ, ꠔꠥꠝꠤꠅ ꠅꠃꠟꠣ ꠔꠥꠝꠣꠞ ꠟꠉꠞ ꠌꠣꠇꠞꠤꠀꠘꠞꠦ ꠖꠄꠀ ꠇꠞꠣ ꠃꠌꠤꠔ ꠀꠍꠤꠟ ꠘꠣ ꠘꠤ?’ ");
INSERT INTO syls_vpl VALUES ("MT18_34","070_18_34","MAT","18","34","34","ꠛꠣꠖꠦ ꠛꠣꠖꠡꠣꠄ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠔꠣꠞꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠟꠣ, ꠔꠣꠘ ꠙꠣꠅꠘꠣ ꠀꠖꠣꠄ ꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠦꠟꠞ ꠎꠟ꠆ꠟꠣꠖ ꠍꠤꠙꠣꠁꠄ ꠔꠣꠞꠦ ꠇꠠꠣꠇꠠꠤ ꠡꠣꠎꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT18_35","070_18_35","MAT","18","35","35","“ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠔꠥꠝꠞꠣꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁꠞꠦ ꠖꠤꠟ ꠕꠣꠇꠤ ꠝꠣꠚ ꠇꠞꠤ ꠘꠣ ꠖꠦꠅ, ꠔꠦ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃꠟꠣ ꠡꠣꠎꠣ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT19_1","070_19_1","MAT","19","1","1","ꠅꠃ ꠔꠣꠟꠤꠝꠞ ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣ ꠕꠣꠇꠤ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠙꠥꠛ ꠄꠟꠣꠇꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT19_2","070_19_2","MAT","19","2","2","ꠅꠃ ꠡꠝꠄ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠟꠣ, ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇꠟꠞ ꠛꠦꠝꠣꠞ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT19_3","070_19_3","MAT","19","3","3","ꠀꠞ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠦꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠔꠣꠞ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠦꠅꠀ ꠎꠣꠁꠎ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT19_4","070_19_4","MAT","19","4","4","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠙꠣꠁꠍꠂꠘ ꠘꠣ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠙꠄꠟꠣ ꠀꠖꠝ ꠀꠞ ꠢꠣꠅꠀꠞꠦ ꠛꠦꠐꠣ ꠀꠞ ꠛꠦꠐꠤ ꠛꠣꠘꠣꠁ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠇꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("MT19_5","070_19_5","MAT","19","5","5","‘ꠄꠞꠟꠣꠉꠤꠃ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠍꠣꠠꠤꠀ ꠛꠃꠞ ꠟꠉꠦ ꠕꠣꠇꠛꠣ, ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘ ꠄꠇ ꠡꠞꠤꠟ ꠅꠁꠛꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT19_6","070_19_6","MAT","19","6","6","ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠖꠥꠁ ꠞꠁꠔꠣ ꠘꠣꠄ, ꠄꠇ ꠇꠣꠄꠀ ꠅꠁꠛꠣ। ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠞꠣꠞꠦ ꠎꠥꠠꠣ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠍꠂꠘ, ꠝꠣꠘꠡꠦ ꠁꠔꠣꠞꠦ ꠀꠟꠉ ꠘꠣ ꠇꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MT19_7","070_19_7","MAT","19","7","7","ꠔꠦꠃ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠇꠦꠘꠦ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠔꠣꠟꠣꠇ ꠘꠣꠝꠣ ꠟꠦꠈꠤꠀ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠦꠅꠀ ꠎꠣꠁꠎ?” ");
INSERT INTO syls_vpl VALUES ("MT19_8","070_19_8","MAT","19","8","8","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠉꠔꠤꠇꠦꠃ ꠝꠥꠍꠣꠄ ꠁ ꠅꠘꠥꠝꠔꠤ ꠖꠤꠍꠂꠘ। ꠅꠁꠟꠦ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠁꠟꠣ ꠘꠤꠅꠝ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT19_9","070_19_9","MAT","19","9","9","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠎꠤꠘꠣꠞ ꠖꠥꠡ ꠍꠣꠠꠣ ꠅꠁꠘ꠆ꠘ ꠎꠦꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠔꠣꠞ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠤꠀ ꠀꠞꠇ ꠛꠦꠐꠤꠞꠦ ꠢꠣꠋꠉꠣ ꠇꠞꠦ, ꠢꠦ ꠘꠤꠎꠦꠃ ꠎꠤꠘꠣ ꠇꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT19_10","070_19_10","MAT","19","10","10","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠎꠣꠝꠣꠁ-ꠛꠃꠞ ꠝꠣꠎꠦꠅ ꠎꠥꠖꠤ ꠅꠟꠣ ꠊꠐꠘꠣ ꠊꠐꠦ, ꠔꠦ ꠔ ꠛꠤꠀ ꠘꠣ ꠇꠞꠣꠃ ꠜꠣꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT19_11","070_19_11","MAT","19","11","11","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔ ꠁꠟꠣ ꠞꠁꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠞꠣꠞꠦ ꠁ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠂꠘ, ꠔꠣꠞꠣꠃ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT19_12","070_19_12","MAT","19","12","12","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠘꠣ-ꠝꠞ꠆ꠖ ꠢꠣꠟꠔꠦꠃ ꠖꠥꠘꠤꠀꠔ ꠎꠘꠝ ꠟꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠛꠤꠀ ꠇꠞꠦ ꠘꠣ। ꠀꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠞꠦ ꠝꠣꠘꠡꠦꠃ ꠘꠣ-ꠝꠞ꠆ꠖ ꠛꠣꠘꠣꠁꠟꠣꠄ, ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣꠅ ꠛꠤꠀ ꠇꠞꠦ ꠘꠣ। ꠢꠤꠞꠛꠣꠞ ꠇꠦꠃ ꠇꠦꠃ ꠀꠍꠦ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠘꠣ ꠇꠞꠤꠀ, ꠈꠣꠟꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠈꠦꠎꠝꠔꠅ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠘꠤꠞ ꠘꠤꠅꠔ ꠇꠞꠤꠟꠣꠄ। ꠔꠦ ꠁꠈꠣꠘ ꠎꠦꠞꠣ ꠀꠝꠟ ꠇꠞꠔ ꠙꠣꠞꠦ, ꠔꠣꠞꠣ ꠀꠝꠟ ꠇꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MT19_13","070_19_13","MAT","19","13","13","ꠛꠣꠖꠦ ꠝꠣꠘꠡꠦ ꠢꠥꠞꠥ ꠢꠥꠞꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠟꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ, ꠔꠣꠞꠣ ꠌꠣꠁꠟꠣ ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠕꠣꠉꠥ ꠀꠔꠣꠁ ꠖꠤꠀ ꠖꠥꠀ ꠇꠞꠂꠘ। ꠅꠁꠟꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠄꠞꠣꠞꠦ ꠛꠇꠣ-ꠎꠇꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT19_14","070_19_14","MAT","19","14","14","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠀꠐꠇꠣꠁꠅ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠦ ꠖꠦꠅ। ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠄꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤꠃ।” ");
INSERT INTO syls_vpl VALUES ("MT19_15","070_19_15","MAT","19","15","15","ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠕꠣ ꠀꠔꠣꠁꠀ ꠖꠥꠀ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠁꠘ ꠢꠤꠘ ꠕꠣꠇꠤ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT19_16","070_19_16","MAT","19","16","16","ꠛꠣꠖꠦ ꠄꠇ ꠎꠥꠀꠘ ꠛꠦꠐꠣꠄ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠈꠦꠞꠣꠔ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠇꠥꠘ ꠢꠇ ꠇꠣꠝ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("MT19_17","070_19_17","MAT","19","17","17","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠇ ꠇꠣꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠣꠞꠦ ꠇꠦꠘꠦ ꠎꠤꠇꠣꠁꠞꠣꠄ? ꠢꠇ ꠔ ꠈꠣꠟꠤ ꠄꠇꠎꠘꠃ ꠀꠍꠂꠘ, ꠔꠥꠝꠤ ꠀꠈꠦꠞꠣꠔ ꠙꠣꠁꠔꠦ ꠌꠣꠁꠟꠦ, ꠔꠣꠘ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT19_18","070_19_18","MAT","19","18","18","ꠢꠃ ꠎꠥꠀꠘꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠇꠥꠘ ꠇꠥꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠔꠣꠝ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠈꠥꠘ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠌꠥꠞꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠅ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("MT19_19","070_19_19","MAT","19","19","19","ꠝꠣ-ꠛꠣꠚꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ ꠀꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT19_20","070_19_20","MAT","19","20","20","ꠛꠦꠐꠣꠄ ꠇꠁꠟ, “ꠍꠣꠛ, ꠁꠔꠣ ꠔ ꠀꠝꠤ ꠄꠝꠘꠦꠃ ꠀꠝꠟ ꠇꠞꠤꠀꠞ, ꠅꠁꠟꠦ ꠀꠞ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ ꠇꠃꠇ꠆ꠇꠣ?” ");
INSERT INTO syls_vpl VALUES ("MT19_21","070_19_21","MAT","19","21","21","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠈꠣꠐꠤ ꠅꠁꠔꠣꠄ ꠌꠣꠅ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅ, ꠉꠤꠀ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠛꠦꠌꠤꠀ ꠉꠞꠤꠛ-ꠖꠥꠈꠤꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅ। ꠔꠦꠃ ꠔꠥꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠙꠣꠁꠛꠣꠄ। ꠄꠞꠛꠣꠖꠦ ꠀꠁꠀ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT19_22","070_19_22","MAT","19","22","22","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠦꠐꠣ ꠛꠦꠎꠣꠞ ꠅꠁꠀ ꠉꠦꠟꠉꠤ, ꠔꠣꠞ ꠔ ꠛꠃꠔ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT19_23","070_19_23","MAT","19","23","23","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠗꠘꠤ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠘꠤ ꠛꠠ ꠝꠡꠇꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT19_24","070_19_24","MAT","19","24","24","ꠢꠥꠘꠅ, ꠗꠘꠤ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠘꠤꠞ ꠌꠣꠁꠔꠦ, ꠍꠥꠁꠞ ꠚꠥꠠꠦꠖꠤ ꠃꠐ ꠢꠣꠝꠣꠘꠤ ꠀꠞꠅ ꠡꠥꠎꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT19_25","070_19_25","MAT","19","25","25","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠔꠦ ꠇꠥꠘ ꠝꠣꠘꠥꠡ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛ, ꠇꠦ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("MT19_26","070_19_26","MAT","19","26","26","ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠅꠡꠝ꠆ꠛꠛ ꠅꠁꠔ ꠙꠣꠞꠦ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠁꠔꠣ ꠔ ꠝꠣꠝꠥꠟꠤ। ꠔꠣꠁꠘ ꠢꠇꠟꠔꠣꠃ ꠙꠣꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT19_27","070_19_27","MAT","19","27","27","ꠅꠃ ꠡꠝꠄ ꠙꠤꠔꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠔ ꠢꠇ꠆ꠇꠟꠔꠣ ꠚꠣꠟꠣꠁ ꠕꠁꠀ ꠀꠙꠘꠣꠞ ꠈꠞꠦ ꠀꠁꠍꠤ। ꠔꠦ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠙꠣꠁꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("MT19_28","070_19_28","MAT","19","28","28","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠣ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠍ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠉꠖꠤꠔ ꠛꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠅ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠛꠣꠞꠅꠐꠣ ꠔꠈ꠆ꠔꠅ ꠛꠁꠛꠣꠄ, ꠛꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠉꠥꠡ꠆ꠐꠤꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT19_29","070_19_29","MAT","19","29","29","ꠢꠥꠘꠅ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠛꠣꠠꠤ-ꠊꠞ, ꠝꠣ-ꠛꠣꠚ, ꠜꠣꠁ-ꠛꠁꠘ, ꠙꠥꠀ-ꠙꠥꠠꠤ, ꠀꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠚꠣꠟꠣꠁꠀ ꠀꠁꠍꠦ, ꠢꠦ ꠅꠃ ꠖꠥꠘꠤꠀꠔ ꠁꠔꠣꠞ ꠄꠇ-ꠡ ꠉꠥꠘ ꠛꠦꠡꠤ ꠙꠣꠁꠛ, ꠄꠞꠟꠉꠦ ꠀꠈꠦꠞꠅ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT19_30","070_19_30","MAT","19","30","30","ꠅꠁꠟꠦ ꠅꠈꠘ ꠎꠦꠞꠣ ꠀꠉꠞ ꠇꠣꠔꠣꠞꠅ ꠀꠍꠦ, ꠄꠞꠣꠞ ꠛꠃꠔ ꠎꠘ ꠈꠞꠦ ꠙꠠꠤꠎꠤꠛ, ꠀꠞ ꠈꠞꠞ ꠇꠣꠔꠣꠞꠞ ꠛꠃꠔ ꠎꠘ ꠀꠉꠦ ꠀꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT20_1","070_20_1","MAT","20","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠔ ꠅꠟꠣ ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠞ ꠟꠣꠈꠣꠘ। ꠁ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠘ ꠈꠦꠔꠞ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠈꠥꠛ ꠛꠤꠀꠘꠦ ꠃꠑꠤꠀ ꠇꠣꠝꠟꠣ ꠔꠥꠇꠣꠘꠤꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT20_2","070_20_2","MAT","20","2","2","ꠉꠤꠀ ꠇꠣꠝꠟꠣ ꠌꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠄꠇ-ꠡ ꠐꠦꠇꠣ ꠞꠥꠎ ꠚꠥꠠꠣꠁꠀ ꠔꠣꠘ ꠀꠋꠉꠥꠞ ꠛꠣꠉꠣꠘꠅ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT20_3","070_20_3","MAT","20","3","3","ꠇꠤꠍꠥ ꠛꠦꠁꠟ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠞ ꠅꠁꠟꠣ, ꠛꠣꠞ ꠅꠁꠀ ꠖꠦꠈꠟꠣ ꠀꠞꠅ ꠇꠄꠎꠘ ꠇꠣꠝꠟꠣ ꠛꠦꠇꠣꠞ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT20_4","070_20_4","MAT","20","4","4","ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠞꠣꠅ ꠉꠤꠀ ꠀꠝꠣꠞ ꠛꠣꠉꠣꠘꠅ ꠇꠣꠝꠅ ꠟꠣꠉꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠌꠤꠔ ꠐꠦꠇꠣ ꠖꠤꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("MT20_5","070_20_5","MAT","20","5","5","ꠔꠦꠃ ꠔꠣꠞꠣ ꠉꠤꠀ ꠇꠣꠝꠅ ꠟꠣꠉꠟꠣ। ꠅꠟꠣꠈꠣꠘ ꠛꠦꠁꠟ ꠖꠥꠁꠚꠞꠤ ꠛꠣꠟꠣ ꠀꠞ ꠎꠥꠢꠞꠞ ꠛꠣꠖꠦ ꠉꠤꠞꠡ꠆ꠔ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠞ ꠅꠁꠀ ꠉꠤꠀ ꠀꠞꠅ ꠇꠣꠝꠟꠣꠁꠘ ꠀꠘꠤꠀ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT20_6","070_20_6","MAT","20","6","6","ꠢꠦꠡꠦ ꠛꠤꠀꠟꠤ ꠛꠣꠟꠣ ꠔꠣꠁꠘ ꠛꠣꠞꠦ ꠉꠤꠀ, ꠀꠞꠅ ꠇꠣꠝꠟꠣꠁꠘ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠞꠣ ꠢꠣꠞꠣꠖꠤꠘ ꠗꠞꠤ ꠁꠘꠅ ꠃꠛꠣꠁ ꠞꠁꠍ ꠇꠦꠘꠦ?’ ");
INSERT INTO syls_vpl VALUES ("MT20_7","070_20_7","MAT","20","7","7","ꠄꠞꠣ ꠇꠁꠟꠣ, ‘ꠍꠣꠛ, ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠇꠣꠝ ꠙꠣꠁꠍꠤ ꠘꠣ।’ ꠉꠤꠞꠡ꠆ꠔꠦ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠞꠣꠅ ꠉꠤꠀ ꠀꠝꠣꠞ ꠛꠣꠉꠣꠘꠅ ꠇꠣꠝꠅ ꠟꠣꠉꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT20_8","070_20_8","MAT","20","8","8","“ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠌꠣꠇꠞꠞꠦ ꠇꠁꠟꠣ, ‘ꠅꠛꠣ, ꠛꠣꠉꠣꠘꠞ ꠅꠃ ꠇꠣꠝꠟꠣꠁꠘ꠆ꠔꠞꠦ ꠀꠘꠤꠀ, ꠡꠦꠡꠞ ꠎꠘ ꠕꠣꠇꠤ ꠙꠄꠟꠣ ꠎꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇꠟꠞ ꠞꠥꠎ ꠖꠤꠟꠣꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT20_9","070_20_9","MAT","20","9","9","ꠛꠤꠀꠟꠤ ꠛꠣꠟꠣ ꠎꠦꠞꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠍꠤꠟ, ꠔꠣꠞꠣ ꠄꠇ-ꠡ ꠇꠞꠤ ꠙꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT20_10","070_20_10","MAT","20","10","10","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠙꠄꠟꠣ ꠎꠣꠞꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠍꠤꠟ, ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠟ ꠔꠣꠞꠣ ꠀꠞꠅ ꠛꠦꠡꠤ ꠐꠦꠇꠣ ꠙꠣꠁꠛ, ꠅꠁꠟꠦ ꠉꠤꠞꠡ꠆ꠔꠦ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠄꠇ ꠢꠝꠣꠘ ꠞꠥꠎ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT20_11","070_20_11","MAT","20","11","11","ꠄꠞꠖꠣꠄ ꠙꠄꠟꠣ ꠖꠟ ꠅꠃ ꠉꠤꠞꠡ꠆ꠔꠞ ꠃꠙꠞꠦ ꠛꠦꠎꠣꠞ ꠅꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT20_12","070_20_12","MAT","20","12","12","‘ꠀꠝꠞꠣ ꠢꠣꠞꠣ ꠖꠤꠘ ꠗꠞꠤ ꠞꠂꠖꠦ ꠎꠟꠤ-ꠙꠥꠠꠤ ꠇꠣꠝ ꠇꠞꠤꠀ ꠄꠇ-ꠡ ꠐꠦꠇꠣ ꠙꠣꠁꠟꠣꠝ। ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠢꠦꠡꠦ ꠀꠁꠀ ꠕꠥꠠꠣ ꠡꠝꠄ ꠇꠣꠝ ꠇꠞꠣꠄꠅ, ꠀꠙꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠢꠝꠣꠘ ꠐꠦꠇꠣ ꠖꠤꠟꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT20_13","070_20_13","MAT","20","13","13","“ꠔꠦꠃ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠄꠇꠎꠘꠞꠦ ꠇꠁꠟꠣ, ‘ꠅꠛꠣ, ꠀꠝꠤ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠍꠤ ꠘꠤ, ꠔꠥꠝꠤ ꠘꠤꠎꠦꠃ ꠔ ꠄꠇ-ꠡ ꠐꠦꠇꠣꠄ ꠇꠣꠝ ꠇꠞꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠍ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT20_14","070_20_14","MAT","20","14","14","ꠅꠈꠘ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠟꠁꠀ ꠔꠥꠝꠤ ꠎꠣꠅ। ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠁꠌ꠆ꠍꠣꠄ ꠢꠇꠟꠞꠦ ꠄꠇ ꠢꠝꠣꠘ ꠖꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("MT20_15","070_20_15","MAT","20","15","15","ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠍꠣꠝꠣꠘꠣ, ꠘꠤꠎꠞ ꠁꠌ꠆ꠍꠣꠝꠔ ꠈꠞꠌ ꠇꠞꠣꠞ ꠅꠗꠤꠇꠣꠞ ꠘꠣꠁ ꠘꠤ? ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠣꠄ ꠔꠥꠝꠣꠞ ꠌꠈꠥꠔ ꠎꠟꠦꠞ ꠘꠤ?’ ” ");
INSERT INTO syls_vpl VALUES ("MT20_16","070_20_16","MAT","20","16","16","ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠛꠥꠎꠍ ꠘꠤ, ꠎꠦꠞꠣ ꠈꠞꠞ ꠇꠣꠔꠣꠞꠅ ꠀꠍꠦ ꠔꠣꠞꠣ ꠀꠉꠦ ꠀꠁꠛ, ꠀꠞ ꠀꠉꠞ ꠇꠣꠔꠣꠞꠞ ꠔꠣꠞꠣ ꠈꠞꠦ ꠎꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT20_17","070_20_17","MAT","20","17","17","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠝꠥꠈꠣ ꠞꠅꠀꠘꠣ ꠅꠁꠎꠤꠔꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠀꠟꠉꠣ ꠢꠞꠣꠁꠀ ꠘꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT20_18","070_20_18","MAT","20","18","18","“ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠅꠈꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠎꠣꠁꠞꠣꠝ। ꠢꠘꠅ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠗꠞꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠔꠣꠞꠣ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠞꠣꠄ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT20_19","070_20_19","MAT","20","19","19","ꠀꠝꠣꠞꠦ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁꠛꠣ। ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠇꠞꠤꠀ, ꠛꠦꠎꠥꠁꠔꠣ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠤꠀ, ꠟꠣꠇꠠꠤꠞ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣ। ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT20_20","070_20_20","MAT","20","20","20","ꠛꠣꠖꠦ ꠎꠤꠛꠥꠖꠤꠀꠞ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠟꠁꠀ ꠔꠣꠞꠣꠞ ꠝꠣʼꠄ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠇꠥꠘ꠆ꠔꠣ ꠌꠣꠅꠀꠞ ꠀꠡꠣꠄ ꠔꠣꠘ ꠙꠣꠅ-ꠅ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT20_21","070_20_21","MAT","20","21","21","ꠁꠍꠣꠄ ꠛꠦꠐꠤꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠌꠣꠁꠘ?” ꠛꠦꠐꠤꠄ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠄꠉꠥ ꠙꠥꠀꠞꠦ ꠀꠙꠘꠣꠞ ꠞꠣꠎꠔ꠆ꠔꠞ ꠒꠣꠁꠘꠞ ꠉꠖꠤ, ꠀꠞ ꠀꠞꠅꠉꠥꠞꠦ ꠛꠣꠃꠞ ꠉꠖꠤꠈꠣꠘꠅ ꠛꠁꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠛꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT20_22","070_20_22","MAT","20","22","22","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠛꠥꠎꠞꠣꠄ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠌꠣꠁꠞꠣꠄ। ꠀꠝꠤ ꠎꠦ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠙꠤꠀꠟꠣꠖꠤ ꠈꠣꠁꠝꠥ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ ꠘꠤ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠙꠣꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT20_23","070_20_23","MAT","20","23","23","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠀꠝꠤ ꠎꠦ ꠙꠤꠀꠟꠣꠖꠤ ꠈꠣꠁꠝꠥ ꠔꠥꠝꠞꠣꠅ ꠅꠃ ꠙꠤꠀꠟꠣꠖꠤ ꠈꠣꠁꠛꠣꠄ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠒꠣꠁꠘꠦ ꠛꠣ ꠛꠣꠃꠄ ꠛꠅꠀꠘꠤꠞ ꠄꠈꠔꠤꠀꠞ ꠔ ꠀꠝꠣꠞ ꠀꠔꠅ ꠘꠣꠄ। ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠁ ꠉꠖꠤ ꠑꠤꠇ ꠇꠞꠍꠂꠘ, ꠈꠣꠟꠤ ꠔꠣꠞꠣꠃ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT20_24","070_20_24","MAT","20","24","24","ꠎꠤꠛꠥꠖꠤꠀꠞ ꠖꠥꠁꠅ ꠙꠥꠀꠞ ꠀꠞꠎꠤ ꠢꠥꠘꠤꠀ, ꠛꠣꠇꠤ ꠖꠡꠅꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠛ ꠛꠤꠞꠇ꠆ꠔ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT20_25","070_20_25","MAT","20","25","25","ꠔꠦꠃ ꠁꠍꠣꠄ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠘꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠛꠤꠗꠞ꠆ꠝꠤ ꠎꠣꠔꠤꠞ ꠞꠣꠎꠣ ꠅꠇꠟ ꠔꠣꠞꠣꠞ ꠙ꠆ꠞꠎꠣꠞ ꠃꠙꠞꠦ ꠢꠥꠇꠥꠝ ꠎꠣꠞꠤ ꠇꠞꠦ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠎꠝꠤꠖꠣꠞ ꠅꠇꠟꠦ ꠉꠥꠟꠣꠝꠞ ꠃꠙꠞꠦ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT20_26","070_20_26","MAT","20","26","26","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠔ ꠁꠟꠣ ꠅꠀ ꠑꠤꠇ ꠘꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠇꠦꠃ ꠖꠣꠝꠤ ꠛꠘꠔꠦ ꠌꠣꠁꠟꠦ, ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT20_27","070_20_27","MAT","20","27","27","ꠀꠞ ꠇꠦꠃ ꠛꠠ ꠅꠁꠔꠦ ꠌꠣꠁꠟꠦ, ꠢꠦ ꠢꠇꠟꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT20_28","070_20_28","MAT","20","28","28","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦꠅ ꠈꠦꠎꠝꠔ ꠙꠣꠅꠀꠔ ꠀꠁꠍꠤ ꠘꠣ, ꠀꠁꠍꠤ ꠔ ꠈꠦꠎꠝꠔ ꠇꠞꠣꠔ। ꠀꠞ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀꠔ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT20_29","070_20_29","MAT","20","29","29","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT20_30","070_20_30","MAT","20","30","30","ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠖꠥꠁ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣ ꠛꠅꠀꠔ ꠀꠍꠤꠟ। ꠔꠣꠁꠘ ꠅꠃ ꠙꠕꠦꠖꠤ ꠎꠣꠁꠞꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠅ ꠢꠥꠎꠥꠞ, ꠅ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖ, ꠀꠝꠞꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT20_31","070_20_31","MAT","20","31","31","ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠤꠀ ꠅꠘꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞꠦ ꠗꠝꠇ ꠖꠤꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠀꠞꠅ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠅ ꠢꠥꠎꠥꠞ, ꠅ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖ, ꠀꠝꠞꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT20_32","070_20_32","MAT","20","32","32","ꠄꠞꠣꠞ ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠘ ꠃꠛꠣꠁ ꠉꠦꠟꠣ, ꠃꠛꠣꠁꠀ ꠅꠃ ꠖꠥꠁꠅ ꠀꠘ꠆ꠖꠣꠞꠦ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠘꠣꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠇꠤꠔꠣ ꠌꠣꠅ? ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("MT20_33","070_20_33","MAT","20","33","33","ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞ ꠌꠃꠈ ꠉꠥꠁꠘ ꠜꠣꠟꠣ ꠇꠞꠤ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT20_34","070_20_34","MAT","20","34","34","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠘ ꠖꠞꠖ ꠢꠣꠝꠣꠁ ꠉꠦꠟ। ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠀꠔꠣꠁ ꠖꠤꠟꠣ, ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ꠛꠣꠖꠦ ꠔꠣꠞꠣꠅ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT21_1","070_21_1","MAT","21","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠇꠣꠍꠣꠔ, ꠎꠄꠔꠥꠘ ꠙꠣꠠꠞ ꠟꠉꠦ ꠛꠣꠄꠔ-ꠚꠣꠁꠎ꠆ꠎꠣ ꠉꠣꠃꠔ ꠀꠁꠀ ꠀꠎꠤꠟꠣ। ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠘ ꠖꠥꠁꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT21_2","070_21_2","MAT","21","2","2","“ꠔꠥꠝꠞꠣ ꠅꠃ ꠍꠣꠝꠘꠞ ꠉꠣꠃꠔ ꠎꠣꠅ। ꠉꠣꠃꠔ ꠢꠣꠝꠣꠁꠔꠦꠃ ꠖꠦꠈꠛꠣꠄ ꠄꠉꠥ ꠉꠣꠗꠣ ꠛꠣꠘ꠆ꠖꠣ ꠀꠍꠦ, ꠟꠉꠦ ꠔꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠅ ꠛꠣꠘ꠆ꠖꠣ। ꠅꠉꠥꠁꠘ꠆ꠔꠞ ꠉꠟꠣꠞ ꠖꠠꠤ ꠈꠥꠟꠤꠀ ꠅꠘꠅ ꠟꠁꠀ ꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MT21_3","070_21_3","MAT","21","3","3","ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠎꠤꠇꠣꠁꠟꠦ ꠇꠁꠅ, ꠢꠥꠎꠥꠞꠞ ꠖꠞꠇꠣꠞ ꠀꠍꠦ, ꠄꠞꠖꠣꠄ ꠘꠤꠞꠣꠝ। ꠔꠦꠃ ꠢꠦ ꠟꠉꠦ ꠟꠉꠦ ꠞꠣꠎꠤ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT21_4","070_21_4","MAT","21","4","4","ꠁꠔꠣ ꠅꠁꠟ ꠎꠣꠔꠦ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠢꠃ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ꠅꠔꠣ ꠅꠈꠘ ꠚꠟꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT21_5","070_21_5","MAT","21","5","5","ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, “ꠍꠤꠅꠘ-ꠇꠁꠘꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞꠦ ꠔꠥꠝꠞꠣ ꠇꠁꠅ, ꠔꠥꠝꠣꠞ ꠛꠣꠖꠡꠣ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠞꠣ। ꠔꠣꠁꠘ ꠈꠥꠛ ꠘꠞꠝ ꠝꠤꠎꠣꠎꠤ। ꠔꠣꠁꠘ ꠉꠣꠗꠣ ꠌꠠꠤꠀ, ꠉꠣꠗꠤꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠌꠠꠤꠀ ꠀꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT21_6","070_21_6","MAT","21","6","6","ꠔꠦꠃ ꠁꠍꠣꠄ ꠎꠦꠟꠣ ꠢꠤꠇꠣꠁ ꠖꠤꠍꠟꠣ, ꠖꠥꠁꠅ ꠍꠣꠢꠣꠛꠤꠄ ꠉꠤꠀ ꠅꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_7","070_21_7","MAT","21","7","7","ꠅꠃ ꠉꠣꠗꠣ ꠀꠞ ꠔꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠘꠣꠞ ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠘꠤꠎꠞ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞ ꠈꠥꠟꠤꠀ ꠉꠣꠗꠣꠞ ꠙꠤꠑꠤꠔ ꠛꠤꠍꠣꠁ ꠖꠤꠟꠣ, ꠔꠦꠃ ꠁꠍꠣ ꠄꠞ ꠃꠙꠞꠦ ꠍꠅꠀꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_8","070_21_8","MAT","21","8","8","ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞ ꠈꠥꠟꠤꠀ ꠙꠕꠞ ꠝꠣꠎꠦ ꠛꠤꠍꠣꠁ ꠖꠤꠟꠣ, ꠀꠞ ꠛꠃꠔꠦ ꠡꠥꠘ꠆ꠖꠞ ꠡꠥꠘ꠆ꠖꠞ ꠉꠣꠍꠞ ꠙꠣꠔꠣꠁꠘ ꠍꠤꠠꠤꠀ ꠀꠘꠤꠀ ꠙꠕꠅ ꠛꠤꠍꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_9","070_21_9","MAT","21","9","9","ꠁꠍꠣꠞ ꠀꠉꠦ-ꠈꠞꠦ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠎꠣꠅꠀꠔ ꠀꠍꠤꠟ, ꠄꠞꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠝꠤꠍꠤꠟ ꠖꠤꠟꠣ, “ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ, ꠝꠣꠞꠢꠣꠛꠣ! ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠦꠁꠘ ꠀꠁꠞꠣ, ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ꠛꠦꠢꠦꠡ꠆ꠔꠅ-ꠅ ꠝꠣꠞꠢꠣꠛꠣ!” ");
INSERT INTO syls_vpl VALUES ("MT21_10","070_21_10","MAT","21","10","10","ꠢꠎꠞꠔ ꠁꠍꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠀꠡ꠆ꠔꠣ ꠐꠣꠃꠘꠅ ꠃꠟꠁꠡ꠆ꠔꠟ ꠟꠣꠉꠤꠉꠦꠟ। ꠢꠇꠟꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠛꠣ, ꠄꠁꠘ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT21_11","070_21_11","MAT","21","11","11","ꠝꠣꠘꠡꠦ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠔ ꠢꠃ ꠁꠍꠣ ꠘꠛꠤ, ꠄꠘ ꠛꠣꠠꠤ ꠉꠣꠟꠤꠟꠞ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠔ।” ");
INSERT INTO syls_vpl VALUES ("MT21_12","070_21_12","MAT","21","12","12","ꠛꠣꠖꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠀꠁꠀ ꠔꠣꠁꠘ ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠁꠟꠣ। ꠢꠘꠅ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠎꠦꠞꠣ ꠈꠞꠤꠖ-ꠛꠤꠇꠤꠞ ꠇꠣꠞꠛꠣꠞꠤ ꠀꠍꠤꠟ, ꠁꠔꠣꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠐꠦꠇꠣꠞ ꠛꠣꠐ꠆ꠐꠣꠞ ꠇꠣꠞꠛꠣꠞꠤ ꠅꠇꠟꠞ ꠇꠦꠡ ꠛꠣꠇ꠆ꠡ, ꠀꠞ ꠒꠥꠙꠤ-ꠙꠣꠞꠅ ꠛꠦꠌꠞꠣ ꠅꠇꠟꠞ ꠀꠡꠘ ꠃꠟꠐꠣꠁꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_13","070_21_13","MAT","21","13","13","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ꠀꠝꠣꠞ ꠊꠞ ꠅꠁꠛ ꠄꠛꠣꠖꠔꠞ ꠊꠞ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠁꠈꠣꠘꠞꠦ ꠒꠣꠇꠣꠁꠔꠞ ꠀꠒ꠆ꠒꠣꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠤꠍ।” ");
INSERT INTO syls_vpl VALUES ("MT21_14","070_21_14","MAT","21","14","14","ꠄꠞꠛꠣꠖꠦ ꠀꠘ꠆ꠖꠣ, ꠟꠥꠟꠣ-ꠟꠦꠋꠠꠣ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠀꠁꠟꠣ, ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_15","070_21_15","MAT","21","15","15","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠎꠦ ꠇꠥꠖꠞꠔꠤ ꠝꠥꠎꠦꠎꠣ ꠇꠣꠝ ꠇꠞꠍꠟꠣ, ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠁꠔꠣ ꠖꠦꠈꠟꠣ। ꠔꠣꠞꠣ ꠢꠥꠘꠟꠣ, ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠜꠤꠔꠞꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠦ ꠇꠁꠞꠣ, “ꠝꠣꠞꠢꠣꠛꠣ, ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ, ꠝꠣꠞꠢꠣꠛꠣ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠎꠟꠤ-ꠙꠥꠠꠤ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_16","070_21_16","MAT","21","16","16","ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠦ ꠇꠤꠔꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠞꠣ, ꠁꠔꠣ ꠔꠥꠝꠤ ꠢꠥꠘꠞꠣꠄ ꠘꠣ ꠘꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠄ, ꠢꠥꠘꠤꠀꠞ ꠔ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠙꠠꠍꠂꠘ ꠘꠣ ꠘꠤ, ‘ꠘꠣꠛꠣꠟꠤꠇ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠀꠖꠣꠄ ꠇꠞꠍ’?” ");
INSERT INTO syls_vpl VALUES ("MT21_17","070_21_17","MAT","21","17","17","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠉꠦꠟꠣꠉꠤ, ꠉꠤꠀ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠉꠣꠃꠔ ꠞꠣꠁꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_18","070_21_18","MAT","21","18","18","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠕꠣꠇꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠀꠅꠀꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("MT21_19","070_21_19","MAT","21","19","19","ꠅꠃ ꠔꠣꠁꠘ ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠄꠉꠥ ꠒꠥꠝꠥꠞ ꠉꠣꠍ ꠖꠦꠈꠤꠀ, ꠅꠉꠥꠞ ꠚꠟ ꠈꠣꠅꠀꠞ ꠈꠤꠀꠟꠦ ꠉꠣꠍꠞ ꠗꠣꠞꠅ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠉꠣꠍꠞ ꠝꠣꠎꠦ ꠈꠣꠟꠤ ꠙꠣꠔꠣ, ꠇꠥꠘꠥ ꠚꠟ ꠘꠣꠁ। ꠔꠣꠁꠘ ꠅꠃ ꠉꠣꠍꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠎꠣꠘꠥ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠚꠟ ꠘꠣ ꠗꠞꠦ।” ꠅꠈꠣꠘ ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠉꠣꠍꠐꠣ ꠢꠥꠇꠣꠁꠀ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT21_20","070_21_20","MAT","21","20","20","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠉꠣꠍꠐꠣ ꠅꠔ ꠎꠟꠖꠤ ꠢꠥꠇꠣꠁ ꠉꠦꠟ ꠇꠤꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("MT21_21","070_21_21","MAT","21","21","21","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠡꠘ꠆ꠖꠄ ꠘꠣ ꠇꠞꠤꠀ, ꠙꠥꠞꠣꠙꠥꠞ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠕꠣꠇ, ꠔꠦ ꠀꠝꠤ ꠅꠃ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠞꠦ ꠎꠦꠔꠣ ꠇꠞꠍꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠙꠣꠞꠛꠣꠄ। ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠅꠃ ꠙꠣꠠꠞꠦ ꠇꠅ, ‘ꠃꠠꠤꠀ ꠉꠤꠀ ꠖꠞꠤꠀꠔ ꠙꠠꠅ,’ ꠔꠦ ꠅꠟꠣꠃ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT21_22","070_21_22","MAT","21","22","22","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠣꠟꠤꠍ ꠘꠤꠅꠔꠦ ꠄꠇꠤꠘ ꠇꠞꠤꠀ ꠖꠥꠀ ꠇꠞꠅ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠌꠣꠁꠛꠣꠄ, ꠅꠔꠣꠃ ꠙꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT21_23","070_21_23","MAT","21","23","23","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠀꠁꠀ ꠅꠀꠎ-ꠘꠍꠤꠅꠔ ꠇꠞꠣꠔ ꠀꠍꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠇꠅ ꠌꠣꠁꠘ, ꠔꠥꠝꠤ ꠇꠥꠘ ꠄꠈꠔꠤꠀꠞꠦ ꠁꠔꠣ ꠇꠞꠞꠣꠄ? ꠇꠦ ꠔꠥꠝꠣꠞꠦ ꠁ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT21_24","070_21_24","MAT","21","24","24","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤꠅ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠄꠇꠈꠣꠘ ꠍꠅꠀꠟ ꠇꠞꠤꠀꠞ, ꠀꠙꠘꠣꠞꠣ ꠄꠞ ꠎꠥꠀꠙ ꠖꠤꠟꠣꠁꠟꠦ ꠀꠝꠤꠅ ꠇꠁꠝꠥ, ꠇꠥꠘ ꠄꠈꠔꠤꠀꠞꠦ ꠀꠝꠤ ꠁꠔꠣ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("MT21_25","070_21_25","MAT","21","25","25","ꠀꠙꠘꠣꠞꠣ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠢꠎꠞꠔ ꠄꠢꠤꠀꠄ ꠔꠞꠤꠇꠣꠞ ꠉꠥꠍꠟ ꠖꠦꠅꠀꠞ ꠄꠈꠔꠤꠀꠞ ꠇꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍꠟꠣ? ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠘꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ?” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠣꠘꠦ ꠇꠣꠘꠦ ꠝꠣꠔꠤꠟꠣ, “ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠁ, ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠔꠦ ꠢꠦ ꠇꠁꠛ, ꠔꠣꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣꠄ ꠘꠣ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("MT21_26","070_21_26","MAT","21","26","26","ꠀꠞ ꠎꠥꠖꠤ ꠇꠁ, ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠔꠦ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞꠦ ꠝꠣꠞꠛꠣ, ꠇꠣꠞꠘ ꠝꠣꠘꠡꠦ ꠔ ꠄꠢꠤꠀꠞꠦ ꠘꠛꠤ ꠇꠁꠀ ꠝꠣꠘꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT21_27","070_21_27","MAT","21","27","27","ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠞꠣ ꠁꠈꠣꠘ ꠎꠣꠘꠤ ꠘꠣ।” ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠤꠅ ꠇꠁꠔꠣꠝ ꠘꠣꠄ, ꠇꠥꠘ ꠈꠦꠝꠔꠣꠄ ꠀꠝꠤ ꠁꠔꠣ ꠇꠞꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("MT21_28","070_21_28","MAT","21","28","28","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠀꠙꠘꠣꠞꠣ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠂꠘ? ꠗꠞꠃꠇ꠆ꠇꠣ, ꠄꠇ ꠛꠦꠐꠣꠞ ꠖꠥꠁ ꠙꠥꠀ ꠀꠍꠤꠟ। ꠛꠦꠐꠣꠄ ꠔꠣꠞ ꠛꠠ ꠙꠥꠀꠞꠦ ꠇꠁꠟ, ‘ꠔꠥꠝꠤ ꠀꠁꠎ ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘꠅ ꠇꠣꠝꠅ ꠎꠣꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT21_29","070_21_29","MAT","21","29","29","ꠙꠥꠀꠄ ꠙꠄꠟꠣ ꠇꠁꠟ, ‘ꠀꠝꠤ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ।’ ꠅꠁꠟꠦ ꠛꠣꠖꠦ ꠔꠣꠞ ꠝꠘ ꠛꠖꠟꠣꠁꠀ ꠇꠣꠝꠅ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT21_30","070_21_30","MAT","21","30","30","ꠛꠣꠖꠦ ꠛꠦꠐꠣꠄ ꠔꠣꠞ ꠢꠥꠞꠥ ꠙꠥꠀꠞ ꠉꠦꠍꠦ ꠉꠦꠟ, ꠉꠤꠀ ꠅꠃ ꠇꠣꠝꠞ ꠇꠕꠣ ꠇꠁꠟ। ꠢꠦ ꠎꠥꠀꠙ ꠖꠤꠟ, ‘ꠀꠁꠌ꠆ꠍꠣ ꠀꠝꠤ ꠎꠣꠁꠝꠥꠘꠦ,’ ꠅꠁꠟꠦ ꠛꠣꠖꠦ ꠉꠦꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_31","070_21_31","MAT","21","31","31","ꠔꠦ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠅꠃ ꠖꠥꠁꠅ ꠙꠥꠀꠞ ꠝꠣꠎꠦ ꠇꠦ ꠛꠣꠚꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠟ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠛꠠ ꠙꠥꠀꠄ।” ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠊꠥꠡꠈꠥꠞ ꠔꠡꠤꠟꠖꠣꠞ ꠀꠞ ꠍꠤꠟꠣꠘ ꠛꠦꠐꠤꠘ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠀꠉꠦ ꠅꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠁꠎꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_32","070_21_32","MAT","21","32","32","ꠇꠣꠞꠘ ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠢꠇ ꠙꠕ ꠛꠣꠔꠣꠁꠀ ꠖꠦꠅꠀꠔ ꠀꠁꠍꠟꠣ, ꠔꠣ-ꠅ ꠀꠙꠘꠣꠞꠣ ꠔꠣꠘ ꠇꠕꠣꠄ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ ꠘꠣ। ꠅꠁꠟꠦ ꠊꠥꠡꠈꠥꠞ ꠔꠡꠤꠟꠖꠣꠞ ꠀꠞ ꠍꠤꠟꠣꠘ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ꠅꠔꠣ ꠖꠦꠈꠣꠞ ꠛꠣꠖꠦꠅ ꠀꠙꠘꠣꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ ꠘꠣ, ꠔꠃꠛꠣꠅ ꠇꠞꠍꠂꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT21_33","070_21_33","MAT","21","33","33","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠅꠈꠘ ꠀꠞꠇ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠃꠇ꠆ꠇꠣ। ꠄꠇꠎꠘ ꠉꠤꠞꠡ꠆ꠔꠦ ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘ ꠇꠞꠤꠀ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠛꠦꠠꠣ ꠖꠤꠟ। ꠛꠣꠖꠦ ꠌꠇꠤꠖꠣꠞꠞ ꠟꠣꠉꠤ ꠃꠌꠣ ꠇꠞꠤ ꠄꠇꠈꠣꠘ ꠐꠋ-ꠊꠞ ꠛꠣꠘꠣꠁꠟ ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠞꠡ ꠛꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠉꠣꠔ ꠈꠥꠖꠤꠟ। ꠢꠦꠡꠦ ꠈꠦꠔ ꠛꠣꠉꠤ ꠖꠤꠀ ꠉꠤꠞꠡ꠆ꠔ ꠛꠤꠖꠦꠡ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT21_34","070_21_34","MAT","21","34","34","ꠀꠋꠉꠥꠞ ꠙꠣꠇꠤꠀ ꠢꠣꠞꠟꠦ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠞ ꠛꠣꠐ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠔꠣꠞ ꠌꠣꠇꠞ ꠅꠇꠟ ꠙꠣꠑꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT21_35","070_21_35","MAT","21","35","35","ꠅꠁꠟꠦ ꠛꠣꠉꠤꠖꠣꠞꠦ ꠉꠤꠞꠡ꠆ꠔꠞ ꠄꠇ ꠌꠣꠇꠞꠞꠦ ꠗꠞꠤꠀ ꠈꠥꠛ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠟ, ꠖꠥꠍꠞꠣ ꠌꠣꠇꠞꠞꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠝꠣꠞꠤꠀ ꠎꠈꠝ ꠇꠞꠟ ꠀꠞ ꠀꠞꠇ ꠌꠣꠇꠞꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT21_36","070_21_36","MAT","21","36","36","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠞꠅ ꠛꠦꠡ ꠇꠞꠤ ꠄꠇ ꠖꠟ ꠌꠣꠇꠞ ꠙꠣꠑꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠟꠉꠦꠅ ꠅꠃꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT21_37","070_21_37","MAT","21","37","37","ꠢꠦꠡ-ꠝꠦꠡ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠥꠀꠞꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠝꠘꠅ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠔꠣꠘ ꠙꠥꠀꠞꠦ ꠖꠣꠝ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT21_38","070_21_38","MAT","21","38","38","ꠅꠁꠟꠦ ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠦ ꠙꠥꠀꠞꠦ ꠖꠦꠈꠤꠀ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠤ ꠇꠁꠟ, ꠅꠃ ꠙꠥꠀꠃ ꠔ ꠛꠣꠖꠦ ꠁ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠛ। ꠔꠦ ꠀꠅ, ꠅꠉꠥꠞꠦ ꠝꠣꠞꠤꠟꠣꠁ, ꠔꠦꠃ ꠀꠝꠞꠣꠃ ꠁꠔꠣꠞ ꠝꠣꠟꠤꠇ ꠛꠘꠤꠎꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("MT21_39","070_21_39","MAT","21","39","39","ꠇꠁꠀꠃ ꠔꠣꠞꠣ ꠙꠥꠀꠞꠦ ꠗꠞꠤꠀ ꠀꠋꠉꠥꠞ ꠛꠣꠉꠣꠘꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT21_40","070_21_40","MAT","21","40","40","ꠅꠈꠘ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠛꠣꠉꠣꠘꠞ ꠝꠣꠟꠤꠇ ꠎꠦꠛꠟꠣ ꠀꠁꠛꠣ, ꠀꠁꠀ ꠅꠃ ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("MT21_41","070_21_41","MAT","21","41","41","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠔꠣꠁꠘ ꠀꠁꠀ ꠔ ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞꠦ ꠈꠥꠘ ꠇꠞꠛꠣ ꠀꠞ ꠡꠝꠄ ꠝꠔ ꠎꠦꠞꠣ ꠚꠡꠟꠞ ꠛꠣꠐ ꠖꠤꠛ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠈꠦꠔ ꠛꠣꠉꠤ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT21_42","070_21_42","MAT","21","42","42","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠙꠠꠍꠂꠘ ꠘꠣ ꠘꠤ, ꠞꠣꠎ ꠝꠦꠡ꠆ꠔꠁꠞ ꠅꠇꠟꠦ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠛꠦꠇꠣꠝꠣ ꠇꠁꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠍꠤꠟ, ꠅꠇꠐꠣ ꠖꠤꠀꠃ ꠊꠞꠞ ꠁꠀꠘ ꠈꠥꠐꠤ ꠅꠁꠟ। ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠦꠃ ꠁꠔꠣ ꠅꠀꠁꠟꠣ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔ ꠀꠝꠞꠣꠞ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠟꠣꠉꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("MT21_43","070_21_43","MAT","21","43","43","ꠄꠞꠟꠣꠉꠤ ꠇꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠙꠘꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ। ꠀꠞ ꠎꠦꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠅꠃ ꠛꠣꠖꠡꠣꠁꠞ ꠚꠟ ꠖꠦꠈꠣ ꠎꠣꠁꠛ, ꠔꠣꠞꠣꠞꠦꠃ ꠅꠃ ꠛꠣꠖꠡꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT21_44","070_21_44","MAT","21","44","44","ꠢꠥꠘꠅ, ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠎꠦ ꠎꠘ ꠙꠠꠛ, ꠢꠦ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠅꠁꠎꠤꠛ। ꠀꠞ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠅ ꠎꠣꠞ ꠃꠙꠞꠦ ꠙꠠꠛ, ꠢꠦ-ꠅ ꠌꠥꠞꠝꠣꠞ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT21_45","070_21_45","MAT","21","45","45","ꠁꠍꠣꠞ ꠅꠃ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠔꠣꠁꠘ ꠁꠔꠣ ꠔꠣꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦꠃ ꠇꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT21_46","070_21_46","MAT","21","46","46","ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠟꠤꠔ ꠌꠣꠁꠟ। ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞꠦ ꠒꠞꠣꠁꠀ ꠔꠣꠘꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠟ ꠘꠣ। ꠝꠣꠘꠡꠦ ꠔ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠘꠛꠤ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_1","070_22_1","MAT","22","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠅ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT22_2","070_22_2","MAT","22","2","2","“ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠟꠣ ꠄꠇ ꠛꠣꠖꠡꠣꠞ ꠟꠣꠈꠣꠘ, ꠎꠦ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠘ ꠙꠥꠀꠞ ꠛꠤꠀꠞ ꠈꠣꠘꠤꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_3","070_22_3","MAT","22","3","3","ꠀꠞ ꠖꠣꠅꠔꠤ ꠝꠦꠝꠣꠘ ꠅꠇꠟꠞꠦ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠇꠄꠎꠘ ꠌꠣꠇꠞꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠇꠦꠃ ꠀꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_4","070_22_4","MAT","22","4","4","ꠛꠣꠖꠦ ꠔꠣꠘ ꠀꠞꠅ ꠌꠣꠇꠞꠞꠦ ꠅꠈꠣꠘ ꠢꠤꠇꠣꠁ ꠖꠤꠀ ꠙꠣꠑꠣꠁꠟꠣ, ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠝꠦꠝꠣꠘ ꠅꠇꠟꠞꠦ ꠇꠁꠅ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠔꠣꠎꠣ ꠛꠤꠍꠣꠟ ꠀꠞ ꠒꠦꠇꠣꠁꠘ ꠎꠛ ꠇꠞꠤꠀ ꠈꠣꠘꠤ ꠎꠥꠁꠔ ꠇꠞꠍꠤ। ꠅꠈꠘ ꠈꠣꠘꠤ ꠔꠤꠀꠞ ꠅꠁꠉꠦꠍꠦ, ꠀꠙꠘꠣꠞꠣ ꠀꠁꠀ ꠈꠣꠁꠟꠣꠃꠇ꠆ꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT22_5","070_22_5","MAT","22","5","5","“ꠖꠣꠅꠔꠤ ꠅꠇꠟꠦ ꠄꠞꠣꠞ ꠇꠕꠣꠅ ꠘꠣ ꠢꠥꠘꠤꠀ, ꠇꠦꠃ ꠔꠣꠞ ꠘꠤꠎꠞ ꠈꠣꠝꠣꠞꠅ ꠀꠞ ꠇꠦꠃ ꠔꠣꠞ ꠖꠥꠇꠣꠘꠅ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT22_6","070_22_6","MAT","22","6","6","ꠀꠞ ꠛꠣꠇꠤ ꠝꠣꠘꠡꠦ ꠅꠃ ꠌꠣꠇꠞ ꠅꠇꠟꠞꠦ ꠗꠞꠤꠀ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠀ ꠈꠥꠘ ꠇꠞꠤꠟ꠆ꠟ। ");
INSERT INTO syls_vpl VALUES ("MT22_7","070_22_7","MAT","22","7","7","ꠛꠣꠖꠡꠣꠄ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ। ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠍꠤꠙꠣꠁ ꠖꠟ ꠙꠣꠑꠣꠁꠀ ꠢꠃ ꠈꠥꠘꠤ ꠅꠇꠟꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠟꠣ, ꠔꠣꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠐꠣꠃꠘ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_8","070_22_8","MAT","22","8","8","ꠛꠣꠖꠦ ꠔꠣꠘ ꠌꠣꠇꠞ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ‘ꠈꠣꠘꠤ ꠔ ꠔꠤꠀꠞ ꠅꠁꠉꠦꠍꠦ, ꠅꠁꠟꠦ ꠎꠦꠔꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠟꠣꠝ, ꠁꠔꠣ ꠔ ꠁ ꠖꠣꠅꠔꠞ ꠎꠥꠇꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT22_9","070_22_9","MAT","22","9","9","ꠔꠦ ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠞꠣꠡ꠆ꠔꠣꠞ ꠝꠥꠠꠣꠄ ꠝꠥꠠꠣꠄ ꠎꠣꠅ, ꠉꠤꠀ ꠎꠔ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠁꠛꠣꠄ, ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠞꠦ ꠛꠤꠀꠞ ꠀꠡꠞꠅ ꠟꠁꠀ ꠀꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT22_10","070_22_10","MAT","22","10","10","ꠛꠣꠖꠡꠣꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠔꠣꠞꠣ ꠛꠣꠞ ꠅꠁꠀ ꠉꠤꠀ ꠛꠣꠖ-ꠜꠣꠟꠣ ꠎꠔ ꠎꠘꠞꠦ ꠙꠣꠁꠟ, ꠢꠇꠟꠞꠦ ꠀꠘꠟ। ꠄꠞꠟꠣꠉꠤ ꠝꠦꠝꠣꠘꠦ ꠀꠡ꠆ꠔꠣ ꠛꠤꠀ ꠛꠣꠠꠤ ꠜꠞꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT22_11","070_22_11","MAT","22","11","11","“ꠄꠞꠛꠣꠖꠦ ꠛꠣꠖꠡꠣꠄ ꠝꠦꠝꠣꠘꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠝꠎꠟꠤꠍꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠖꠦꠈꠂꠘ, ꠄꠇ ꠛꠦꠐꠣꠄ ꠡꠣꠗꠣꠞꠘ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠈꠣꠘꠤꠔ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT22_12","070_22_12","MAT","22","12","12","ꠔꠣꠁꠘ ꠄꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, ‘ꠅꠛꠣ, ꠛꠤꠀ ꠛꠣꠠꠤꠞ ꠎꠥꠇꠣ ꠇꠣꠙꠠ ꠘꠣ ꠚꠤꠘ꠆ꠖꠤꠀ ꠁꠘꠅ ꠢꠣꠝꠣꠁꠟꠦ ꠇꠤꠟꠣ?’ ꠅꠁꠟꠦ ꠢꠦ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠔ ꠙꠣꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_13","070_22_13","MAT","22","13","13","ꠔꠦꠃ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ‘ꠅꠉꠥꠞ ꠀꠔ-ꠙꠣꠅ ꠛꠣꠘ꠆ꠖꠤꠀ ꠛꠣꠞꠦ ꠘꠤꠀ ꠀꠘ꠆ꠖꠣꠁꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁ ꠖꠦꠅ।’ ꠢꠘꠅ ꠝꠣꠘꠡꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠛꠣ ꠀꠞ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠄ ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠈꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT22_14","070_22_14","MAT","22","14","14","ꠇꠤꠌ꠆ꠍꠣꠞ ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠖꠣꠅꠔ ꠙꠣꠁꠍꠂꠘ ꠛꠃꠔꠦ, ꠅꠁꠟꠦ ꠙꠍꠘ꠆ꠖ ꠅꠁꠍꠂꠘ ꠇꠝ।” ");
INSERT INTO syls_vpl VALUES ("MT22_15","070_22_15","MAT","22","15","15","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ, ꠉꠤꠀ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ ꠔꠣꠘꠞꠦ ꠇꠤꠟꠣ ꠇꠕꠣꠞ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠁꠟ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT22_16","070_22_16","MAT","22","16","16","ꠔꠦꠃ ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠇꠄꠎꠘ ꠡꠣꠉꠞꠤꠖ ꠀꠞ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠖꠟꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ। ꠅꠔꠣꠄ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠀꠙꠘꠦ ꠄꠇꠎꠘ ꠢꠇ ꠝꠣꠘꠥꠡ। ꠢꠇ-ꠢꠣꠟꠣꠟ ꠙꠕꠦ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠣꠡ꠆ꠔꠣ ꠛꠣꠔꠣꠁ ꠖꠤꠞꠣ। ꠇꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠦ ꠛꠣ ꠘꠣ ꠇꠞꠦ, ꠁꠔꠣꠄ ꠀꠙꠘꠣꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠎꠣꠄ ꠀꠄ ꠘꠣ, ꠀꠙꠘꠦ ꠔ ꠝꠥꠈ ꠌꠣꠁꠀ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_17","070_22_17","MAT","22","17","17","ꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠔꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠞꠦ ꠈꠣꠎꠘꠣ ꠖꠦꠅꠀ ꠎꠣꠁꠎ ꠘꠤ? ꠀꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠈꠣꠎꠘꠣ ꠖꠤꠔꠣꠝ ꠘꠤ, ꠘꠣ ꠖꠤꠔꠣꠝ ꠘꠣ?” ");
INSERT INTO syls_vpl VALUES ("MT22_18","070_22_18","MAT","22","18","18","ꠁꠔꠣꠞ ꠇꠥ-ꠙꠞꠣꠝꠤꠡ ꠔꠣꠁꠘ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠛꠥꠎꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠜꠘ꠆ꠒ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠞꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("MT22_19","070_22_19","MAT","22","19","19","ꠎꠦ ꠐꠦꠇꠣꠖꠤ ꠈꠣꠎꠘꠣ ꠖꠦꠁꠘ, ꠅꠔꠣ ꠄꠉꠥ ꠐꠦꠇꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠅ।” ꠅꠃ ꠔꠣꠞꠣ ꠄꠇꠐꠣ ꠖꠤꠘꠣꠞ ꠀꠘꠤꠀ ꠁꠍꠣꠞ ꠀꠔꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_20","070_22_20","MAT","22","20","20","ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁ ꠙꠄꠡꠣꠞ ꠃꠙꠞꠦ ꠇꠣꠞ ꠘꠣꠝ ꠀꠞ ꠍꠛꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT22_21","070_22_21","MAT","22","21","21","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠞ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠦ ꠢꠥꠘꠅ, ꠛꠣꠖꠡꠣꠞ ꠎꠦꠔꠣ ꠁꠔꠣ ꠛꠣꠖꠡꠣꠞꠦ ꠖꠦꠅ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦꠔꠣ ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT22_22","070_22_22","MAT","22","22","22","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠀ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT22_23","070_22_23","MAT","22","23","23","ꠅꠃ ꠖꠤꠘ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠝꠎꠛꠞ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠣ। ꠄꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠂꠘ, ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠂꠘ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT22_24","070_22_24","MAT","22","24","24","“ꠢꠥꠎꠥꠞ, ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠇꠁꠍꠂꠘ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠛꠃꠞꠦ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠢꠣꠟꠔꠦ ꠕꠁꠀ ꠝꠣꠞꠣ ꠎꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠜꠣꠁꠄ ꠅꠃ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠔꠣꠞ ꠜꠣꠁꠞ ꠛꠋꠡ ꠛꠣꠌꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT22_25","070_22_25","MAT","22","25","25","ꠔꠦ ꠀꠝꠞꠣꠞ ꠅꠘꠅ ꠄꠇ ꠙꠞꠤꠛꠣꠞꠅ ꠡꠣꠔ ꠜꠣꠁ ꠀꠍꠤꠟ। ꠛꠠ ꠎꠘꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠢꠣꠟꠔꠦ ꠝꠣꠞꠣ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT22_26","070_22_26","MAT","22","26","26","ꠛꠣꠖꠦ ꠖꠥꠍꠞꠣ ꠜꠣꠁꠄ ꠔꠣꠞ ꠅꠃ ꠠꠣꠠꠤ ꠜꠣꠛꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠤ ꠝꠣꠞꠣ ꠉꠦꠟ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠤꠍꠞꠣ ꠜꠣꠁ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠇꠞꠤꠀ ꠡꠣꠔꠅ ꠜꠣꠁꠄ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT22_27","070_22_27","MAT","22","27","27","ꠢꠦꠡꠦ ꠅꠃ ꠛꠦꠐꠤꠅ ꠝꠣꠞꠣ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT22_28","070_22_28","MAT","22","28","28","ꠔꠦ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠝꠞꠘ ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠁ ꠛꠦꠐꠤ, ꠄꠞꠣ ꠇꠥꠘ ꠜꠣꠁꠞ ꠛꠃ ꠅꠁꠛ? ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠔ ꠁ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MT22_29","070_22_29","MAT","22","29","29","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠎꠣꠘꠂꠘ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠦꠙꠣꠞꠅ ꠛꠥꠎꠂꠘ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠀꠙꠘꠣꠞꠣ ꠁ ꠜꠥꠟ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_30","070_22_30","MAT","22","30","30","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠎꠦꠛꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠔꠣ ꠘꠣꠄ, ꠇꠦꠃ ꠔꠣꠞꠣꠞꠦ ꠛꠤꠀ ꠖꠤꠔ-ꠅ ꠘꠣꠄ। ꠄꠞꠣ ꠔ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠤꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_31","070_22_31","MAT","22","31","31","ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠀꠙꠘꠣꠞꠣ ꠇꠤꠔꠣꠛꠅ ꠙꠠꠍꠂꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT22_32","070_22_32","MAT","22","32","32","ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ‘ꠀꠝꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ, ꠁꠍꠢꠣꠇꠞ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠀꠟ꠆ꠟꠣ।’ ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠅꠃ ꠘꠛꠤ ꠅꠇꠟꠞ ꠃꠚꠣꠔ ꠅꠁꠟꠦꠅ ꠄꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠌꠈꠥꠔ ꠅꠈꠘꠅ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ। ꠀꠟ꠆ꠟꠣ ꠔ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠛꠥꠖ ꠘꠣꠄ, ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠛꠥꠖ।” ");
INSERT INTO syls_vpl VALUES ("MT22_33","070_22_33","MAT","22","33","33","ꠁ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_34","070_22_34","MAT","22","34","34","ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣ, ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠝꠎꠛꠞ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞ ꠝꠣꠔꠞ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠔꠣ ꠙꠣꠞꠍꠂꠘ ꠘꠣ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT22_35","070_22_35","MAT","22","35","35","ꠔꠣꠞꠣꠞ ꠖꠟꠞ ꠄꠇꠎꠘ ꠝꠃꠟꠣꠘꠣ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT22_36","070_22_36","MAT","22","36","36","“ꠢꠥꠎꠥꠞ, ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠝꠣꠎꠦ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ ꠢꠥꠇꠥꠝ ꠇꠥꠘꠐꠣ?” ");
INSERT INTO syls_vpl VALUES ("MT22_37","070_22_37","MAT","22","37","38","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ ꠢꠥꠇꠥꠝ ꠅꠁꠟ, ‘ꠔꠥꠝꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠤꠟ, ꠀꠡ꠆ꠔꠣ ꠎꠣꠘ, ꠀꠡ꠆ꠔꠣ ꠝꠘ ꠀꠞ ꠢꠇꠟ ꠡꠇ꠆ꠔꠤ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT22_39","070_22_39","MAT","22","39","39","ꠖꠥꠍꠞꠣ ꠢꠥꠇꠥꠝꠅ ꠅꠃ ꠟꠣꠈꠣꠘ, ‘ꠔꠥꠝꠞꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠤꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT22_40","070_22_40","MAT","22","40","40","ꠅꠃ ꠖꠥꠁꠅ ꠢꠥꠇꠥꠝꠞ ꠃꠙꠞꠦ ꠀꠡ꠆ꠔꠣ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚ ꠀꠞ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛ ꠅꠇꠟ ꠘꠤꠞꠜꠞ ꠇꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT22_41","070_22_41","MAT","22","41","41","ꠚꠞꠤꠡꠤ ꠅꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠞꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT22_42","070_22_42","MAT","22","42","42","“ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠇꠤꠔꠣ ꠎꠣꠘꠂꠘ? ꠔꠣꠁꠘ ꠇꠣꠞ ꠀꠅꠟꠣꠖ?” ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖ।” ");
INSERT INTO syls_vpl VALUES ("MT22_43","070_22_43","MAT","22","43","43","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠖꠣꠃꠖ ꠘꠛꠤꠄ ꠇꠤꠟꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠝꠥꠘꠤꠛ ꠇꠁꠍꠂꠘ? ꠖꠣꠃꠖꠦ ꠔ ꠇꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("MT22_44","070_22_44","MAT","22","44","44","ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠇꠁꠟꠣ, ‘ꠀꠝꠤ ꠎꠔ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ ꠘꠣ ꠚꠣꠟꠣꠁ, ꠅꠔ ꠡꠝꠄ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠛꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT22_45","070_22_45","MAT","22","45","45","ꠖꠣꠃꠖꠦ ꠎꠦꠛꠟꠣ ꠘꠤꠎꠦꠃ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠣꠘ ꠝꠥꠘꠤꠛ ꠇꠁꠍꠂꠘ, ꠔꠦ ꠀꠟ-ꠝꠍꠤ ꠇꠦꠝꠘꠦ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ ꠅꠁꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("MT22_46","070_22_46","MAT","22","46","46","ꠔꠣꠞꠣ ꠄꠞ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠀꠞ ꠅꠃ ꠖꠤꠘ ꠕꠣꠇꠤ ꠇꠦꠃ ꠔꠣꠘꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠎꠤꠇꠣꠘꠤꠞꠅ ꠡꠣꠅꠡ ꠙꠣꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_1","070_23_1","MAT","23","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠟꠉꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT23_2","070_23_2","MAT","23","2","2","“ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠔ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞ ꠀꠔꠅ। ");
INSERT INTO syls_vpl VALUES ("MT23_3","070_23_3","MAT","23","3","3","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠇꠂꠘ, ꠅꠔꠣ ꠝꠣꠘꠤꠅ, ꠀꠞ ꠎꠦꠔꠣ ꠀꠝꠟ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠦꠁꠘ, ꠅꠔꠣ ꠀꠝꠟ ꠇꠞꠤꠅ। ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠘꠤꠎꠦ ꠎꠦꠔꠣ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠇꠣꠞꠘ, ꠔꠣꠞꠣ ꠝꠥꠈ ꠖꠤꠀ ꠎꠦꠟꠣ ꠇꠂꠘ, ꠁꠟꠣ ꠇꠣꠝ ꠇꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_4","070_23_4","MAT","23","4","4","ꠔꠣꠞꠣ ꠀꠝ ꠝꠣꠘꠡꠞ ꠇꠣꠘ꠆ꠖꠅ ꠛꠠ ꠛꠠ ꠉꠣꠁꠐ ꠔꠥꠟꠤꠀ ꠖꠦꠁꠘ, ꠅꠁꠟꠦ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠄꠇꠐꠣ ꠀꠋꠉꠥꠟꠅ ꠟꠣꠠꠣꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_5","070_23_5","MAT","23","5","5","ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠝꠣꠘꠡꠞꠦ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠇꠟꠔꠣ ꠇꠞꠂꠘ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠀꠄꠀꠔ ꠖꠤꠀ ꠛꠠ ꠛꠠ ꠔꠣꠛꠤꠎ ꠛꠣꠘ꠆ꠖꠂꠘ ꠀꠞ ꠘꠤꠎꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠟꠣꠝ꠆ꠛꠣ ꠟꠣꠝ꠆ꠛꠣ ꠙꠣꠃꠉꠠꠤ ꠛꠣꠘ꠆ꠖꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT23_6","070_23_6","MAT","23","6","6","ꠔꠣꠞꠣ ꠈꠣꠘꠤꠞ ꠝꠎꠟꠤꠍꠅ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠎꠣꠉꠣ ꠔꠥꠇꠣꠁꠘ ꠀꠞ ꠝꠍꠤꠖꠅ ꠢꠣꠝꠣꠁꠀ ꠍꠣꠝꠘꠞ ꠇꠣꠔꠣꠞꠅ ꠛꠁꠔꠣ ꠌꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("MT23_7","070_23_7","MAT","23","7","7","ꠛꠣꠎꠣꠞ-ꠀꠐꠅ ꠉꠤꠀ ꠍꠣꠟꠣꠝ ꠙꠣꠁꠔꠦ ꠈꠥꠛ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ, ꠀꠞ ꠌꠣꠁꠘ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞꠦ ꠢꠥꠎꠥꠞ ꠢꠥꠎꠥꠞ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT23_8","070_23_8","MAT","23","8","8","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠦꠃ ꠢꠥꠎꠥꠞ ꠢꠥꠎꠥꠞ ꠇꠞꠃꠇ, ꠁꠔꠣ ꠀꠡꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠀꠍꠟ ꠢꠥꠎꠥꠞ ꠔ ꠈꠣꠟꠤ ꠄꠇꠎꠘꠃ ꠀꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠜꠣꠁ ꠜꠣꠁ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MT23_9","070_23_9","MAT","23","9","9","ꠁ ꠖꠥꠘꠤꠀꠔ ꠇꠦꠃꠞꠞꠦ ꠛꠣꠛꠣ ꠇꠁꠀ ꠒꠣꠇꠤꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚ ꠔ ꠄꠇꠎꠘꠃ, ꠔꠣꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT23_10","070_23_10","MAT","23","10","10","ꠇꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠦꠔꠣ ꠇꠁꠀ ꠒꠣꠇꠃꠇ, ꠁꠔꠣ ꠀꠡꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠘꠦꠔꠣ ꠔ ꠄꠇꠎꠘꠃ, ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠀꠟ-ꠝꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("MT23_11","070_23_11","MAT","23","11","11","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠁꠘ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ, ꠄꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT23_12","070_23_12","MAT","23","12","12","ꠎꠦ ꠎꠘꠦ ꠘꠤꠎꠞꠦ ꠛꠠ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠣꠞꠦ ꠢꠥꠞꠥ ꠇꠞꠣ ꠅꠁꠛ। ꠀꠞ ꠎꠦ ꠘꠤꠎꠞꠦ ꠢꠥꠞꠥ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠣꠞꠦ ꠛꠠ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT23_13","070_23_13","MAT","23","13","13","“ꠢꠣꠄꠞꠦ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠖꠟ, ꠀꠚꠍꠥꠍ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣ ꠜꠘ꠆ꠒ! ꠔꠥꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠕꠁꠍ। ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦꠅ ꠅꠘꠅ ꠢꠣꠝꠣꠁꠞꠣꠄ ꠘꠣ, ꠝꠣꠘꠡꠞꠦꠅ ꠢꠣꠝꠣꠁꠔꠦ ꠖꠤꠞꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_14","070_23_14","MAT","23","14","14","ꠢꠣꠄꠞꠦ ꠜꠘ꠆ꠒ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠖꠟ, ꠝꠣꠘꠡꠞꠦ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠟꠣꠝ꠆ꠛꠣ ꠟꠣꠝ꠆ꠛꠣ ꠖꠥꠀ ꠇꠞꠅ, ꠢꠤꠞꠛꠣꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠎꠣꠉꠣ-ꠝꠤꠞꠣꠡꠅ ꠖꠈꠟ ꠇꠞꠅ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠑꠤꠘ ꠡꠣꠎꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT23_15","070_23_15","MAT","23","15","15","ꠢꠣꠄꠞꠦ ꠜꠘ꠆ꠒ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠖꠟ! ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠟꠅ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠔ ꠡꠝꠥꠖ꠆ꠞ ꠔꠦꠞꠅ ꠘꠖꠤ ꠙꠣꠞ ꠅꠁꠀ ꠔꠥꠝꠞꠣ ꠖꠃꠠꠣꠅ। ꠅꠁꠟꠦ ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠟꠅ ꠢꠣꠝꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠠ ꠖꠥꠎꠈꠤ ꠛꠣꠘꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("MT23_16","070_23_16","MAT","23","16","16","“ꠢꠣꠄꠞꠦ ꠀꠘ꠆ꠖꠣ ꠙꠕ ꠖꠦꠈꠣꠅꠞꠣ! ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠀꠘ꠆ꠖꠣ ꠅꠁꠀ ꠅꠁꠘ꠆ꠘꠞꠦ ꠇꠤꠟꠣ ꠙꠕ ꠖꠦꠈꠣꠅ? ꠔꠥꠝꠞꠣ ꠔ ꠇꠅ, ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠈꠣꠁꠟꠦ ꠇꠥꠘ꠆ꠔꠣ ꠅꠄ ꠘꠣ, ꠅꠁꠟꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠡꠥꠘꠣꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠈꠣꠁꠟꠦ ꠝꠣꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT23_17","070_23_17","MAT","23","17","17","ꠢꠣꠄꠞꠦ ꠀꠘ꠆ꠖꠣ ꠛꠦꠀꠈꠟꠞ ꠖꠟ, ꠇꠥꠘꠈꠣꠘ ꠛꠠ? ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ, ꠘꠣ ꠡꠥꠘꠣ? ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠦꠃ ꠔ ꠅꠃ ꠡꠥꠘꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT23_18","070_23_18","MAT","23","18","18","ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣ ꠇꠅ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠘꠣꠝꠦ ꠇꠦꠃ ꠇꠍꠝ ꠇꠞꠟꠦ ꠇꠥꠘ꠆ꠔꠣ ꠅꠄ ꠘꠣ, ꠅꠁꠟꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠌꠤꠎꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠟꠦ ꠝꠣꠘꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT23_19","070_23_19","MAT","23","19","19","ꠅ ꠀꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠇꠥꠘꠈꠣꠘ ꠛꠠ? ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ, ꠘꠣ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠌꠤꠎ? ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠄꠃ ꠅꠃ ꠌꠤꠎꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠦ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT23_20","070_23_20","MAT","23","20","20","ꠄꠞꠟꠣꠉꠤ ꠎꠦ ꠎꠘꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠦ, ꠢꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠌꠤꠎ, ꠁ ꠖꠥꠁꠅꠔꠣꠞ ꠘꠣꠝꠦꠃ ꠇꠍꠝ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT23_21","070_23_21","MAT","23","21","21","ꠅꠟꠣꠃ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠘꠣꠝꠦ ꠎꠦ ꠎꠘꠦ ꠇꠍꠝ ꠇꠞꠦ, ꠢꠦ-ꠅ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠀꠞ ꠄꠞ ꠜꠤꠔꠞꠦ ꠎꠦꠁꠘ ꠕꠣꠇꠂꠘ, ꠔꠣꠘ ꠘꠣꠝꠦꠃ ꠇꠍꠝ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT23_22","070_23_22","MAT","23","22","22","ꠎꠦ ꠎꠘꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠦ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠀꠞꠡ ꠀꠞ ꠀꠞꠡꠅ ꠎꠦꠁꠘ ꠀꠍꠂꠘ, ꠔꠣꠘ ꠘꠣꠝꠦꠃ ꠇꠍꠝ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MT23_23","070_23_23","MAT","23","23","23","“ꠢꠣꠄꠞꠦ ꠜꠘ꠆ꠒ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠖꠟ! ꠔꠥꠝꠞꠣ ꠉꠥꠀꠝꠥꠞꠤ, ꠙꠖꠤꠘꠣ ꠙꠣꠔꠣ, ꠀꠞ ꠎꠤꠞꠣꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠡ꠆ꠔꠦ ꠎꠇꠣꠔ ꠖꠤꠞꠣꠄ, ꠅꠁꠟꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠀꠞꠅ ꠎꠞꠥꠞꠤ ꠛꠦꠙꠣꠞ, ꠝꠣꠘꠤ ꠢꠇ ꠁꠘꠍꠣꠚ, ꠖꠄꠀ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔ ꠔꠥꠝꠞꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍ। ꠔꠦ ꠙꠄꠟꠣ ꠢꠥꠇꠥꠝ ꠀꠝꠟ ꠇꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠛꠣꠖꠞꠔꠣꠅ ꠀꠝꠟ ꠇꠞꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("MT23_24","070_23_24","MAT","23","24","24","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠀꠘ꠆ꠖꠣ, ꠅꠕꠌ ꠀꠞꠇ ꠎꠘꠞꠦ ꠙꠕ ꠖꠦꠈꠣꠁꠞꠣꠄ। ꠔꠥꠝꠞꠣ ꠄꠉꠥ ꠝꠡꠣꠅ ꠍꠣꠇꠤꠀ ꠔꠥꠟꠅ, ꠅꠁꠟꠦ ꠃꠐꠞꠦ ꠉꠤꠟꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("MT23_25","070_23_25","MAT","23","25","25","“ꠢꠣꠄꠞꠦ ꠜꠘ꠆ꠒ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠖꠟ! ꠔꠥꠝꠞꠣ ꠔ ꠛꠣꠡꠘ-ꠛꠞ꠆ꠔꠘꠞ ꠛꠣꠞꠉꠣꠟꠣ ꠜꠣꠟꠣ ꠇꠞꠤ ꠍꠣꠚ ꠇꠞꠅ, ꠅꠁꠟꠦ ꠁꠔꠣꠞ ꠜꠤꠔꠞ ꠉꠣꠟꠣ ꠎꠥꠟꠥꠝ ꠀꠞ ꠟꠥꠜ-ꠟꠣꠟꠌꠦ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_26","070_23_26","MAT","23","26","26","ꠢꠣꠄꠞꠦ ꠀꠘ꠆ꠖꠣ ꠚꠞꠤꠡꠤꠞ ꠖꠟ, ꠔꠥꠝꠞꠣ ꠙꠄꠟꠣ ꠅꠔꠣꠞ ꠜꠤꠔꠞ ꠍꠣꠚ ꠇꠞꠅ, ꠔꠦꠃ ꠛꠣꠞꠉꠣꠟꠣ ꠄꠝꠘꠦꠃ ꠍꠣꠚ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT23_27","070_23_27","MAT","23","27","27","“ꠢꠣꠄꠞꠦ ꠜꠘ꠆ꠒ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠖꠟ! ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠌꠥꠘ-ꠇꠣꠝ ꠇꠞꠣ ꠇꠄꠛꠞꠞ ꠟꠣꠈꠣꠘ, ꠄꠞ ꠛꠣꠞꠉꠣꠟꠣ ꠌꠇꠌꠇꠣ ꠅꠁꠟꠦꠅ ꠜꠤꠔꠞꠦ ꠔ ꠈꠣꠟꠤ ꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠀꠒ꠆ꠒꠤ-ꠉꠥꠒ꠆ꠒꠤ ꠀꠞ ꠈꠣꠍꠞꠣꠄ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_28","070_23_28","MAT","23","28","28","ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠝꠣꠘꠡꠦ ꠝꠘꠦ ꠇꠞꠂꠘ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠙꠞꠦꠎꠉꠣꠞ, ꠀꠍꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠔ ꠜꠘ꠆ꠒꠣꠝꠤ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠄ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_29","070_23_29","MAT","23","29","29","“ꠢꠣꠄꠞꠦ ꠜꠘ꠆ꠒ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠖꠟ! ꠔꠥꠝꠞꠣ ꠘꠛꠤ ꠅꠇꠟꠞ ꠞꠅꠎꠣꠞꠦ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠙꠣꠇ꠆ꠇꠣ ꠇꠞꠅ, ꠀꠞ ꠅꠟꠤ-ꠀꠃꠟꠤꠀꠞ ꠝꠣꠎꠣꠞꠞꠦ ꠌꠇꠌꠇꠣ ꠇꠞꠤ ꠢꠣꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("MT23_30","070_23_30","MAT","23","30","30","ꠀꠞ ꠔꠥꠝꠞꠣ ꠇꠅ, ‘ꠁꠡ, ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠎꠝꠣꠘꠣꠔ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠔꠣꠝ, ꠔꠦ ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠇꠣꠟꠅ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠟꠉꠦ ꠉꠦꠟꠣꠝ ꠘꠣ ꠅꠘꠦ।’ ");
INSERT INTO syls_vpl VALUES ("MT23_31","070_23_31","MAT","23","31","31","ꠅꠃ ꠝꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠙꠞꠝꠣꠘ ꠖꠤꠞꠣꠄ, ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠦꠔꠣꠄ ꠎꠣꠘꠦ ꠝꠣꠞꠍꠟꠣ, ꠅꠔꠣꠞ ꠛꠋꠡꠗꠞꠃ ꠔꠥꠝꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_32","070_23_32","MAT","23","32","32","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠦ ꠎꠦꠔꠣ ꠡꠥꠞꠥ ꠇꠞꠤꠀ ꠉꠦꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠅꠔꠣꠞ ꠛꠣꠇꠤ ꠉꠣꠟꠣ ꠙꠥꠞꠣ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT23_33","070_23_33","MAT","23","33","33","“ꠅ ꠢꠣꠚꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ, ꠖꠥꠎꠈꠞ ꠀꠎꠣꠛ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣ ꠛꠣꠌꠔꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("MT23_34","070_23_34","MAT","23","34","34","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠘꠛꠤ-ꠞꠍꠥꠟ, ꠀꠞ ꠀꠟꠤꠝ-ꠃꠟꠣꠝꠣ ꠙꠣꠑꠣꠁꠀꠞ। ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠄꠎꠘꠞꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠄ, ꠇꠄꠎꠘꠞꠦ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠛꠣꠄ। ꠀꠞ ꠇꠄꠎꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠍꠤꠖꠅ ꠢꠣꠞꠣꠁꠀ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠤꠀ, ꠄꠇ ꠉꠣꠃ ꠕꠣꠇꠤ ꠀꠞꠇ ꠉꠣꠃꠔ ꠈꠦꠖꠣꠁꠀ ꠘꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT23_35","070_23_35","MAT","23","35","35","ꠄꠞꠖꠣꠄꠃ ꠘꠤꠞ꠆ꠖꠥꠡꠤ ꠢꠃ ꠢꠣꠛꠤꠟꠞ ꠈꠥꠘ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠇꠞꠤꠀ ꠛꠣꠞꠣꠈꠤꠀꠞ ꠙꠥꠔ ꠎꠣꠇꠣꠞꠤꠀꠞ ꠈꠥꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠖꠥꠘꠤꠀꠔ ꠎꠔ ꠈꠥꠘ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠢꠇꠟ ꠈꠥꠘꠞ ꠖꠣꠄꠁ ꠅꠁꠛꠣꠄ ꠔꠥꠝꠞꠣ। ꠅꠃ ꠎꠣꠇꠣꠞꠤꠀꠞꠦ ꠔ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠜꠤꠔꠞꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚ ꠅꠃ ꠖꠥꠁ ꠎꠣꠉꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠈꠥꠘ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT23_36","070_23_36","MAT","23","36","36","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠅꠃ ꠔꠣꠝꠣꠝ ꠈꠥꠘꠞ ꠖꠣꠄꠁ ꠅꠁꠛꠣꠄ ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("MT23_37","070_23_37","MAT","23","37","37","“ꠎꠦꠞꠥꠎꠣꠟꠦꠝ! ꠢꠣꠄꠞꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ! ꠔꠥꠝꠤ ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠅ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠟ ꠅꠄ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠅ। ꠝꠥꠞꠉꠤꠄ ꠎꠦꠟꠣ ꠔꠣꠁꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠒꠣꠈꠘꠣꠞ ꠔꠟꠦ ꠀꠡꠞꠄ ꠖꠦꠄ, ꠀꠝꠤꠅ ꠅꠃꠟꠣ ꠔꠥꠝꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠡꠞꠄ ꠖꠤꠔꠣꠝ ꠌꠣꠁꠍꠤ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠢꠥꠘꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT23_38","070_23_38","MAT","23","38","38","ꠅ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠍꠣꠝꠘꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠈꠣꠟꠤ ꠛꠣꠠꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT23_39","070_23_39","MAT","23","39","39","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠎꠔꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠁꠈꠣꠘ ꠘꠣ ꠇꠁꠛꠣꠄ, ‘ꠝꠥꠛꠣꠞꠇ ꠔꠣꠁꠘꠃ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠎꠦꠁꠘ ꠀꠁꠞꠣ,’ ꠅꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT24_1","070_24_1","MAT","24","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠞꠣꠉꠤ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟꠣ, ꠔꠣꠘꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠡꠥꠘ꠆ꠖꠞ ꠡꠥꠘ꠆ꠖꠞ ꠖꠟꠣꠘ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT24_2","070_24_2","MAT","24","2","2","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠎꠦꠔꠣ ꠛꠠ ꠛꠠ ꠖꠟꠣꠘ ꠖꠦꠈꠞꠣꠄ, ꠁꠔꠣꠞ ꠖꠥꠁ ꠁꠐ ꠄꠇꠈꠣꠘꠅ ꠞꠁꠔ ꠘꠣꠄ, ꠢꠇꠟꠔꠣ ꠝꠣꠐꠤꠔ ꠝꠤꠡꠤꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT24_3","070_24_3","MAT","24","3","3","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠎꠄꠔꠥꠘ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠘꠤꠞꠣꠟꠣꠄ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞꠦ ꠇꠁꠛꠣ ꠘꠤ, ꠁꠔꠣ ꠇꠥꠘ ꠡꠝꠄ ꠅꠁꠛ? ꠇꠥꠘ ꠀꠟꠣꠝꠔ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠛꠥꠎꠝꠥ, ꠀꠙꠘꠣꠞ ꠀꠅꠀꠞ ꠡꠝꠄ ꠀꠞ ꠇꠤꠀꠝꠔꠞꠅ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("MT24_4","070_24_4","MAT","24","4","4","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠖꠦꠈꠤꠅ, ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣ ꠐꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("MT24_5","070_24_5","MAT","24","5","5","ꠛꠃꠔ ꠎꠘꠦ ꠀꠝꠣꠞ ꠘꠣꠝ ꠗꠞꠤꠀ ꠀꠁꠛ, ꠀꠁꠀ ꠇꠁꠛ, ꠀꠝꠤꠃ ꠀꠟ-ꠝꠍꠤ, ꠇꠁꠀ ꠛꠃꠔꠞꠦ ꠐꠉꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_6","070_24_6","MAT","24","6","6","ꠢꠥꠘꠅ, ꠎꠥꠖ꠆ꠖꠞ ꠀꠅꠀꠎ ꠀꠞ ꠟꠣꠠꠣꠁꠞ ꠈꠛꠞ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠛꠣꠄ, ꠅꠁꠟꠦ ꠁꠔꠣꠄ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠁꠔꠣ ꠘꠤꠌꠄ ꠊꠐꠛ, ꠊꠐꠟꠦꠅ ꠁꠔꠣ ꠔ ꠡꠦꠡ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT24_7","070_24_7","MAT","24","7","7","ꠄꠇ ꠎꠣꠔꠤꠄ ꠀꠞꠇ ꠎꠣꠔꠤꠞ ꠟꠉꠦ, ꠄꠇ ꠖꠦꠡꠦ ꠀꠞꠇ ꠖꠦꠡꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠛ। ꠛꠃꠔ ꠎꠣꠉꠣꠔ ꠜꠂꠍꠣꠟ ꠀꠞ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_8","070_24_8","MAT","24","8","8","ꠅꠁꠟꠦ ꠁꠔꠣ ꠔ ꠈꠣꠟꠤ ꠝꠍꠤꠛꠔꠞ ꠡꠥꠞꠥ। ");
INSERT INTO syls_vpl VALUES ("MT24_9","070_24_9","MAT","24","9","9","“ꠅꠃ ꠡꠝꠄ ꠀꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠗꠞꠣꠁ ꠖꠤꠛ ꠀꠞ ꠈꠥꠘ ꠇꠞꠣꠁꠛ। ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_10","070_24_10","MAT","24","10","10","ꠔꠦꠃ ꠛꠃꠔ ꠎꠘ ꠙꠤꠍꠟꠤꠎꠤꠛ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠛ ꠀꠞ ꠗꠞꠣꠁ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_11","070_24_11","MAT","24","11","11","ꠛꠃꠔ ꠜꠘ꠆ꠒ ꠘꠛꠤ ꠀꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠐꠉꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_12","070_24_12","MAT","24","12","12","ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠙꠞꠤꠝꠣꠘ ꠛꠣꠠꠤꠎꠤꠛ, ꠄꠞꠟꠣꠉꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ ꠇꠝꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_13","070_24_13","MAT","24","13","13","ꠅꠁꠟꠦ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠦꠞꠣ ꠐꠤꠇꠤꠀ ꠞꠁꠛꠣ, ꠄꠞꠣꠃ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_14","070_24_14","MAT","24","14","14","ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠡꠣꠇ꠆ꠇꠤ ꠢꠤꠡꠣꠛꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠛ, ꠄꠞꠛꠣꠖꠦꠃ ꠇꠤꠀꠝꠔ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_15","070_24_15","MAT","24","15","15","“ꠢꠎꠞꠔ ꠖꠣꠘꠤꠀꠟ ꠘꠛꠤꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠎꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠘꠚꠞꠔꠤ ꠎꠤꠘꠤꠡꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠁ ꠎꠤꠘꠤꠡ ꠖꠦꠈꠛꠣꠄ। ꠎꠦ ꠎꠘꠦ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠦꠞ, ꠢꠦ ꠛꠥꠎꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT24_16","070_24_16","MAT","24","16","16","ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠕꠣꠇꠛꠣ, ꠔꠣꠞꠣ ꠙꠣꠠꠦꠖꠤ ꠉꠤꠀ ꠜꠣꠉꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT24_17","070_24_17","MAT","24","17","17","ꠢꠤꠖꠤꠘ ꠇꠦꠃ ꠎꠥꠖꠤ ꠊꠞꠞ ꠌꠣꠟꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠦ, ꠢꠦ ꠔꠣꠞ ꠊꠞꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠟꠣꠝꠣꠔ ꠟꠣꠝꠤꠀ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠘꠣ ꠢꠣꠝꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT24_18","070_24_18","MAT","24","18","18","ꠎꠦꠞꠣ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ ꠀꠍꠦ, ꠔꠣꠞꠣꠞ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠠꠤꠔ ꠘꠣ ꠀꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MT24_19","070_24_19","MAT","24","19","19","ꠅꠃ ꠡꠝꠄ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ, ꠀꠞ ꠎꠦꠞꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠛꠥꠇꠥꠞ ꠖꠥꠗ ꠈꠣꠅꠀꠁꠞꠣ, ꠔꠣꠞꠣꠞ ꠛꠠ ꠝꠍꠤꠛꠔ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_20","070_24_20","MAT","24","20","20","ꠔꠥꠝꠞꠣ ꠖꠥꠀ ꠇꠞꠅ, ꠡꠤꠔꠞ ꠖꠤꠘꠅ ꠛꠣ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠉꠤꠀ ꠎꠣꠅꠀ ꠘꠣ ꠟꠣꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("MT24_21","070_24_21","MAT","24","21","21","ꠅꠃ ꠡꠝꠄ ꠅꠔ ꠛꠦꠎꠥꠁꠔꠣ ꠇꠡ꠆ꠐ ꠅꠁꠛ, ꠎꠦꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠀꠁꠎ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠞ ꠅꠁꠔ-ꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT24_22","070_24_22","MAT","24","22","22","ꠝꠣꠛꠥꠖꠦ ꠎꠥꠖꠤ ꠁ ꠡꠝꠄꠞꠦ ꠇꠝꠣꠁꠀ ꠘꠣ ꠖꠤꠔꠣ, ꠔꠦ ꠇꠦꠃ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠟ ꠘꠣ ꠅꠘꠦ। ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠁ ꠡꠝꠄ ꠇꠝꠣꠁꠀ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_23","070_24_23","MAT","24","23","23","“ꠢꠤ ꠡꠝꠄ ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠄ, ‘ꠢꠥꠘꠍ ꠘꠤ, ꠀꠟ-ꠝꠍꠤ ꠛꠥꠟꠦ ꠅꠘꠅ ꠀꠁꠍꠂꠘ’ ꠛꠣ ‘ꠢꠘꠅ ꠀꠁꠍꠂꠘ’ ꠔꠦ ꠔꠥꠝꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_24","070_24_24","MAT","24","24","24","ꠇꠣꠞꠘ ꠀꠟ-ꠝꠍꠤ ꠘꠣꠝ ꠟꠁꠀ ꠛꠃꠔ ꠜꠘ꠆ꠒ ꠀꠁꠛꠣ, ꠘꠛꠤ ꠢꠣꠎꠤꠀꠅ ꠛꠃꠔ ꠜꠘ꠆ꠒ ꠀꠁꠛꠣ। ꠁꠔꠣꠄ ꠛꠃꠔ ꠛꠠ ꠛꠠ ꠀꠌꠣꠘꠇ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠛꠣ। ꠔꠣꠞꠣ ꠌꠣꠁꠛꠣ, ꠡꠥꠎꠥꠉ ꠙꠣꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣꠞꠦ ꠗꠥꠇꠣ ꠖꠤꠀ ꠛꠦ-ꠙꠕꠦ ꠘꠤꠔꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT24_25","070_24_25","MAT","24","25","25","ꠖꠦꠈꠤꠅ, ꠀꠝꠤ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠉꠦꠃ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("MT24_26","070_24_26","MAT","24","26","26","“ꠢꠥꠘꠅ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠄ, ‘ꠀꠟ-ꠝꠍꠤ ꠛꠥꠟꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠍꠂꠘ,’ ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠁꠅ ꠘꠣ। ꠎꠥꠖꠤ ꠇꠄ, ‘ꠔꠣꠁꠘ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠂꠘ,’ ꠔꠦ ꠄꠇꠤꠘ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_27","070_24_27","MAT","24","27","27","ꠝꠦꠊꠞ ꠎꠤꠟꠇꠤꠞ ꠟꠉꠦ ꠙꠥꠛꠦ-ꠙꠁꠌꠝꠦ ꠢꠇꠟꠛꠣꠄ ꠎꠦꠟꠣ ꠚꠞ ꠅꠁꠎꠣꠄ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠁꠟꠦꠅ ꠅꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_28","070_24_28","MAT","24","28","28","ꠢꠥꠘꠅ, ꠟꠣꠡ ꠎꠦꠘꠅ ꠕꠣꠇꠦ, ꠢꠇꠥꠘ ꠄꠝꠘꠦꠃ ꠢꠘꠅ ꠖꠟꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT24_29","070_24_29","MAT","24","29","29","“ꠅꠃ ꠝꠍꠤꠛꠔꠞ ꠡꠝꠄ ꠡꠦꠡ ꠅꠀꠞ ꠛꠣꠖꠦꠃ, ‘ꠡꠥꠞꠥꠎ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠎꠤꠛ, ꠌꠣꠘ꠆ꠖꠦ ꠀꠞ ꠚꠞ ꠖꠤꠔ ꠘꠣꠄ। ꠔꠦꠞꠣ ꠅꠇꠟ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠙꠠꠤꠎꠤꠛ, ꠀꠍꠝꠣꠘꠞ ꠇꠥꠘꠥ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠌꠤꠎꠃ ꠑꠤꠇ-ꠑꠣꠇ ꠞꠁꠔ ꠘꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("MT24_30","070_24_30","MAT","24","30","30","ꠅꠃ ꠡꠝꠄ ꠀꠍꠝꠣꠘꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣ ꠎꠣꠁꠛ। ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠛꠣ। ꠔꠣꠞꠣ ꠖꠦꠈꠛꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠡꠇ꠆ꠔꠤ ꠀꠞ ꠘꠥꠞꠞ ꠝꠢꠤꠝꠣꠄ, ‘ꠝꠦꠊꠞ ꠈꠥꠐꠤꠔ ꠅꠁꠀ ꠛꠤꠘ-ꠀꠖꠝ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠞꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT24_31","070_24_31","MAT","24","31","31","ꠅꠃ ꠡꠝꠄ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠡꠤꠋꠉꠣꠞ ꠀꠅꠀꠎ ꠅꠁꠛ, ꠄꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠖꠥꠘꠤꠀꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣꠔ ꠔꠣꠁꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠙꠣꠑꠣꠁꠛꠣ, ꠄꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠘꠦ ꠖꠟꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_32","070_24_32","MAT","24","32","32","“ꠅꠃ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠔꠣꠟꠤꠝ ꠟꠅ। ꠉꠣꠍꠞ ꠒꠣꠟ-ꠙꠣꠟꠣ ꠘꠞꠝ ꠅꠁꠀ ꠎꠦꠛꠟꠣ ꠘꠄꠀ ꠇꠥꠠꠤ ꠛꠣꠞꠅꠄ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠤꠟꠣꠅ ꠉꠞꠝꠞ ꠖꠤꠘ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT24_33","070_24_33","MAT","24","33","33","ꠔꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠛꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠊꠐꠦꠞ, ꠖꠦꠈꠤꠀ ꠛꠥꠎꠤꠟꠤꠅ, ꠛꠤꠘ-ꠀꠖꠝꠅ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠂꠘ। ꠈꠣꠟꠤ ꠗꠣꠞꠅ ꠘꠣꠄ, ꠔꠣꠁꠘ ꠀꠁꠀ ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_34","070_24_34","MAT","24","34","34","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠁꠔꠣ ꠘꠣ ꠊꠐꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠥꠡ ꠚꠥꠠꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT24_35","070_24_35","MAT","24","35","35","ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠢꠇꠟꠔꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠣꠝꠦꠡꠣ ꠎꠣꠞꠤ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_36","070_24_36","MAT","24","36","36","“ꠢꠃ ꠖꠤꠘ ꠀꠞ ꠢꠤ ꠡꠝꠄꠅꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠎꠣꠘꠂꠘ ꠘꠣ। ꠀꠍꠝꠣꠘꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠣ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠄꠅ ꠎꠣꠘꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_37","070_24_37","MAT","24","37","37","ꠘꠥꠢ ꠘꠛꠤꠞ ꠀꠝꠟꠅ ꠎꠦ ꠢꠣꠟꠔ ꠅꠁꠍꠤꠟ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠀꠅꠀꠞ ꠡꠝꠄ ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘꠃ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_38","070_24_38","MAT","24","38","38","ꠛꠁꠘ꠆ꠘꠣ ꠡꠥꠞꠥ ꠅꠀꠞ ꠀꠉꠦ ꠘꠥꠢ ꠘꠛꠤ ꠎꠣꠎꠅ ꠃꠑꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠝꠣꠘꠡꠦ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠍꠦ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT24_39","070_24_39","MAT","24","39","39","ꠘꠥꠢ ꠘꠛꠤꠞ ꠛꠁꠘ꠆ꠘꠣꠞ ꠙꠣꠘꠤꠄ ꠁꠔꠣꠞꠦ ꠜꠣꠡꠣꠁꠀ ꠘꠦꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠐꠦꠞ ꠙꠣꠁꠟꠣ ꠘꠣ। ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠁꠛꠣꠞ ꠡꠝꠄꠅ ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_40","070_24_40","MAT","24","40","40","ꠅꠃ ꠡꠝꠄ ꠖꠥꠁꠎꠘ ꠝꠣꠘꠥꠡ ꠄꠇꠟꠉꠦ ꠛꠘ꠆ꠖꠅ ꠕꠣꠇꠟꠦ, ꠄꠇꠎꠘꠞꠦ ꠘꠦꠅꠀ ꠅꠁꠛ ꠀꠞ ꠖꠥꠍꠞꠣ ꠎꠘꠞꠦ ꠛꠣꠖ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_41","070_24_41","MAT","24","41","41","ꠖꠥꠁ ꠛꠦꠐꠤꠄ ꠄꠇꠟꠉꠦ ꠛꠣꠞꠣ-ꠜꠣꠘꠣꠔ ꠕꠣꠇꠟꠦꠅ, ꠄꠞꠣꠞ ꠄꠇꠎꠘꠞꠦ ꠘꠦꠅꠀ ꠅꠁꠛ, ꠀꠞꠇ ꠎꠘ ꠛꠣꠖ ꠙꠠꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_42","070_24_42","MAT","24","42","42","ꠄꠞꠟꠣꠉꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠇꠥꠘꠖꠤꠘ ꠀꠁꠛꠣ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_43","070_24_43","MAT","24","43","43","ꠅꠁꠟꠦ ꠁꠈꠣꠘ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠌꠥꠞ ꠇꠥꠘ ꠡꠝꠄ ꠀꠁꠛ, ꠁꠈꠣꠘ ꠎꠥꠖꠤ ꠉꠤꠞꠡ꠆ꠔꠦ ꠎꠣꠘꠔ, ꠔꠦ ꠔ ꠢꠦ ꠢꠎꠣꠉ ꠞꠁꠟ ꠅꠘꠦ ꠀꠞ ꠌꠥꠞꠞꠦ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠔꠦ ꠖꠤꠟ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("MT24_44","070_24_44","MAT","24","44","44","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠅ ꠢꠣꠝꠦꠡꠣ ꠔꠤꠀꠞ ꠞꠁꠅ, ꠎꠦ ꠡꠝꠄꠅꠞ ꠇꠕꠣ ꠔꠥꠝꠞꠣ ꠌꠤꠘ꠆ꠔꠣꠅ ꠇꠞꠔꠣꠄ ꠘꠣꠄ, ꠢꠃ ꠡꠝꠄ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_45","070_24_45","MAT","24","45","45","“ꠁꠟꠣ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠀꠞ ꠀꠈꠟꠖꠣꠞ ꠌꠣꠇꠞ ꠇꠦ ꠀꠍꠦ, ꠎꠣꠞ ꠀꠔꠅ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠤꠟꠣ ꠢꠦ ꠅꠇ꠆ꠔꠞ ꠇꠣꠟꠅ ꠅꠁꠘ꠆ꠘ ꠌꠣꠇꠞ ꠅꠇꠟꠞꠦ ꠈꠣꠘꠤ ꠛꠣꠐꠤꠀ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT24_46","070_24_46","MAT","24","46","46","ꠇꠙꠣꠟꠤ ꠔ ꠢꠃ ꠌꠣꠇꠞ, ꠎꠣꠞꠦ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠀꠁꠀ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_47","070_24_47","MAT","24","47","47","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠝꠥꠘꠤꠛꠦ ꠅꠃ ꠌꠣꠇꠞꠞ ꠀꠔꠅꠃ ꠔꠣꠘ ꠘꠤꠎꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠜꠣꠞ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_48","070_24_48","MAT","24","48","48","ꠅꠁꠟꠦ ꠗꠞꠅ, ꠢꠃ ꠌꠣꠇꠞꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟ, ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠀꠁꠔꠦ ꠔ ꠛꠃꠔ ꠖꠦꠞꠤ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("MT24_49","070_24_49","MAT","24","49","49","ꠀꠞ ꠅꠃ ꠚꠣꠇꠦ ꠢꠦ ꠢꠇ꠆ꠇꠟ ꠌꠣꠇꠞ-ꠛꠣꠇꠞꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠟ, ꠀꠞ ꠝꠖꠈꠥꠞꠞ ꠟꠉꠦ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠇꠞꠤꠀ ꠝꠖ ꠈꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT24_50","070_24_50","MAT","24","50","50","ꠛꠣꠖꠦ ꠎꠦ ꠖꠤꠘ ꠀꠞ ꠎꠦ ꠅꠇ꠆ꠔꠞ ꠇꠕꠣ ꠢꠦ ꠌꠤꠘ꠆ꠔꠣꠃ ꠇꠞꠔ ꠘꠣꠄ, ꠢꠃ ꠖꠤꠘ ꠀꠞ ꠢꠃ ꠅꠇ꠆ꠔꠅ ꠔꠣꠞ ꠝꠥꠘꠤꠛ ꠀꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT24_51","070_24_51","MAT","24","51","51","ꠔꠣꠁꠘ ꠀꠁꠀ ꠔꠣꠞꠦ ꠇꠣꠐꠤꠀ ꠐꠥꠇꠞꠣꠁꠀ ꠜꠘ꠆ꠒ ꠅꠇꠟꠞ ꠟꠉꠦ ꠝꠤꠡꠣꠁꠛꠣ। ꠢꠤꠘꠅ ꠝꠣꠘꠡꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠛꠣ, ꠀꠞ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠄ ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT25_1","070_25_1","MAT","25","1","1","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟ ꠅꠟꠣ ꠖꠡꠉꠥ ꠙꠥꠠꠤꠞ ꠟꠣꠈꠣꠘ, ꠎꠦꠔꠣ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠛꠤꠀꠞ ꠖꠣꠝꠣꠘ꠆ꠖꠞꠦ ꠀꠉꠥꠀꠁꠀ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠟꠦꠝ-ꠟꠦꠝꠐꠘ ꠟꠁꠀ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT25_2","070_25_2","MAT","25","2","2","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠙꠣꠌ ꠎꠘ ꠀꠍꠤꠟ ꠀꠈꠟꠖꠣꠞ ꠀꠞ ꠙꠣꠌ ꠎꠘ ꠀꠍꠤꠟ ꠛꠦꠀꠈꠟ। ");
INSERT INTO syls_vpl VALUES ("MT25_3","070_25_3","MAT","25","3","3","ꠛꠦꠀꠈꠟ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠈꠣꠟꠤ ꠟꠦꠝ ꠟꠁꠀ ꠛꠣꠞ ꠅꠁꠟ, ꠟꠦꠝꠞ ꠇꠥꠘꠥ ꠔꠦꠟ ꠘꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_4","070_25_4","MAT","25","4","4","ꠅꠁꠟꠦ ꠀꠈꠟꠖꠣꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠟꠦꠝꠞ ꠟꠉꠦ ꠚꠤꠚꠣꠔ ꠇꠞꠤ ꠔꠦꠟꠅ ꠘꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT25_5","070_25_5","MAT","25","5","5","ꠖꠣꠝꠣꠘ꠆ꠖ ꠀꠁꠔꠦ ꠖꠦꠞꠤ ꠅꠀꠄ ꠔꠣꠞꠣ ꠢꠇꠟꠃ ꠃꠋꠉꠣꠁꠔꠦ ꠃꠋꠉꠣꠁꠔꠦ ꠊꠥꠝꠣꠁ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT25_6","070_25_6","MAT","25","6","6","“ꠛꠣꠖꠦ ꠀꠗꠣ-ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠣ ꠉꠦꠟ, ‘ꠖꠣꠝꠣꠘ꠆ꠖ ꠀꠁꠌ꠆ꠍꠂꠘ, ꠖꠣꠝꠣꠘ꠆ꠖ ꠀꠁꠌ꠆ꠍꠂꠘ, ꠎꠟꠖꠤ ꠛꠣꠞꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_7","070_25_7","MAT","25","7","7","ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠤꠀ ꠅꠃ ꠙꠥꠠꠤꠘ ꠃꠑꠤꠀ ꠟꠦꠝ-ꠟꠦꠝꠐꠘ ꠑꠤꠇ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_8","070_25_8","MAT","25","8","8","ꠢꠃ ꠛꠦꠀꠈꠟ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠀꠈꠟꠖꠣꠞ ꠙꠥꠠꠤꠘꠞꠦ ꠇꠁꠟꠣ, ‘ꠀꠝꠞꠣꠞꠦ ꠕꠥꠠꠣ ꠔꠦꠟ ꠖꠦꠅ ꠘꠣ, ꠀꠝꠞꠣꠞ ꠟꠦꠝ ꠟꠤꠝꠤꠀꠞꠉꠤ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_9","070_25_9","MAT","25","9","9","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, ‘ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠔꠦꠟ ꠀꠍꠦ, ꠁꠔꠣ ꠔ ꠀꠝꠞꠣꠞꠃ ꠟꠣꠉꠛ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠖꠥꠇꠣꠘ ꠕꠣꠇꠤ ꠔꠦꠟ ꠀꠘꠣꠁꠟꠣꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_10","070_25_10","MAT","25","10","10","ꠅꠃ ꠛꠦꠀꠈꠟ ꠙꠥꠠꠤꠘ ꠔꠦꠟ ꠀꠘꠣꠔ ꠉꠤꠀ ꠢꠣꠞꠟꠦꠃ ꠖꠣꠝꠣꠘ꠆ꠖ ꠀꠁꠟ꠆ꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠀꠈꠟꠖꠣꠞ ꠅꠃ ꠙꠥꠠꠤꠘ ꠎꠥꠁꠔ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠖꠣꠝꠣꠘ꠆ꠖꠞꠦ ꠟꠁꠀ ꠛꠤꠀ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠟ। ꠔꠣꠞꠣ ꠢꠣꠝꠣꠘꠤꠞ ꠛꠣꠖꠦꠃ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT25_11","070_25_11","MAT","25","11","11","ꠛꠣꠖꠦ ꠅꠃ ꠛꠦꠀꠈꠟ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, ‘ꠢꠥꠘꠞꠣ ꠘꠤ, ꠖꠥꠀꠞꠈꠣꠘ ꠈꠥꠟꠃꠇ꠆ꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_12","070_25_12","MAT","25","12","12","ꠖꠣꠝꠣꠘ꠆ꠖꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, ‘ꠀꠝꠤ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠌꠤꠘꠤ ꠘꠣ।’ ” ");
INSERT INTO syls_vpl VALUES ("MT25_13","070_25_13","MAT","25","13","13","ꠅꠃ ꠇꠤꠌ꠆ꠍꠣꠞ ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠢꠤ ꠖꠤꠘ ꠀꠞ ꠢꠤ ꠡꠝꠄꠅꠞ ꠇꠕꠣ ꠔ ꠇꠦꠃꠞꠞ ꠎꠣꠘꠣ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("MT25_14","070_25_14","MAT","25","14","14","ꠔꠣꠁꠘ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁ ꠅꠟꠣ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ, ꠄꠁꠘ ꠛꠤꠖꠦꠡ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠔꠣꠘ ꠌꠣꠇꠞ ꠅꠇꠟꠞ ꠀꠔꠅ ꠀꠡ꠆ꠔꠣ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤꠞ ꠜꠣꠞ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_15","070_25_15","MAT","25","15","15","ꠄꠞꠣꠞ ꠎꠁꠉ꠆ꠉꠔꠣ ꠝꠣꠚꠤꠇ ꠔꠣꠁꠘ ꠄꠇꠎꠘꠞꠦ ꠙꠣꠌ ꠀꠎꠣꠞ ꠐꠦꠇꠣ, ꠖꠥꠍꠞꠣ ꠎꠘꠞꠦ ꠖꠥꠁ ꠀꠎꠣꠞ ꠀꠞ ꠀꠞꠇ ꠎꠘꠞꠦ ꠄꠇ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_16","070_25_16","MAT","25","16","16","ꠙꠣꠌ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠎꠦ ꠙꠣꠁꠍꠤꠟ, ꠢꠦ ꠅꠃ ꠐꠦꠇꠣꠖꠤ ꠇꠣꠞꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠞꠅ ꠙꠣꠌ ꠀꠎꠣꠞ ꠟꠣꠜ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT25_17","070_25_17","MAT","25","17","17","ꠖꠥꠁ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠎꠦ ꠙꠣꠁꠍꠤꠟ, ꠢꠦ-ꠅ ꠀꠞꠅ ꠖꠥꠁ ꠀꠎꠣꠞ ꠟꠣꠜ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT25_18","070_25_18","MAT","25","18","18","ꠅꠁꠟꠦ ꠄꠇ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠎꠦ ꠙꠣꠁꠍꠤꠟ, ꠢꠦ ꠔꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠁ ꠐꠦꠇꠣ ꠇꠣꠝꠅ ꠘꠣ ꠟꠣꠉꠣꠁꠀ ꠉꠣꠔ ꠈꠥꠖꠤꠀ ꠝꠣꠐꠤꠞ ꠔꠟꠦ ꠕꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT25_19","070_25_19","MAT","25","19","19","“ꠛꠃꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠃ ꠝꠣꠟꠤꠇ ꠖꠦꠡꠅ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠢꠤꠡꠣꠛ-ꠘꠤꠇꠣꠡ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_20","070_25_20","MAT","25","20","20","ꠔꠦꠃ ꠙꠣꠌ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠎꠦ ꠙꠣꠁꠍꠤꠟ, ꠢꠦ ꠀꠞꠅ ꠙꠣꠌ ꠀꠎꠣꠞ ꠟꠁꠀ ꠀꠁꠀ ꠝꠣꠟꠤꠇꠞꠦ ꠇꠁꠟ, ‘ꠍꠣꠛ, ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠌ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠖꠤꠍꠟꠣ, ꠅꠃ ꠐꠦꠇꠣꠖꠤ ꠀꠝꠤ ꠀꠞꠅ ꠙꠣꠌ ꠀꠎꠣꠞ ꠟꠣꠜ ꠇꠞꠍꠤ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_21","070_25_21","MAT","25","21","21","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠟꠤꠇꠦ ꠇꠁꠟꠣ, ‘ꠡꠣꠛ꠆ꠛꠣꠡ, ꠔꠥꠝꠤ ꠈꠥꠛ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠝꠣꠘꠥꠡ। ꠔꠥꠝꠤ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠛꠦꠙꠣꠞꠦꠃ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠞꠁꠍ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞꠅ ꠛꠃꠔ ꠛꠠ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠤꠝꠥ। ꠀꠅ, ꠀꠝꠣꠞ ꠈꠥꠡꠤꠞ ꠜꠣꠉꠤ ꠅꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_22","070_25_22","MAT","25","22","22","ꠛꠣꠖꠦ ꠖꠥꠁ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠎꠦ ꠙꠣꠁꠍꠤꠟ, ꠢꠦ ꠀꠁꠀ ꠇꠁꠟ, ‘ꠍꠣꠛ, ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠖꠥꠁ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠖꠤꠍꠟꠣ। ꠀꠝꠤ ꠔ ꠀꠞꠅ ꠖꠥꠁ ꠀꠎꠣꠞ ꠟꠣꠜ ꠇꠞꠍꠤ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_23","070_25_23","MAT","25","23","23","ꠔꠦꠃ ꠝꠣꠟꠤꠇꠦ ꠇꠁꠟꠣ, ‘ꠡꠣꠛ꠆ꠛꠣꠡ, ꠔꠥꠝꠤ ꠈꠥꠛ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠝꠣꠘꠥꠡ। ꠔꠥꠝꠤ ꠕꠥꠠꠣ ꠛꠦꠙꠣꠞꠦꠃ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠞꠁꠍ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞꠅ ꠛꠃꠔ ꠛꠠ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠤꠝꠥ। ꠀꠅ, ꠀꠝꠣꠞ ꠈꠥꠡꠤꠞ ꠜꠣꠉꠤ ꠅꠅ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_24","070_25_24","MAT","25","24","24","ꠅꠁꠟꠦ ꠄꠇ ꠀꠎꠣꠞ ꠐꠦꠇꠣ ꠎꠣꠞꠦ ꠖꠤꠍꠟꠣ, ꠢꠦ ꠀꠁꠀ ꠇꠁꠟ, ‘ꠍꠣꠛ, ꠀꠝꠤ ꠎꠣꠘꠤ ꠀꠙꠘꠦ ꠈꠥꠛ ꠇꠠꠣ ꠝꠣꠘꠥꠡ। ꠀꠙꠘꠦ ꠈꠦꠔ ꠘꠣ ꠇꠞꠤꠀꠅ ꠗꠣꠘ ꠇꠣꠐꠂꠘ ꠀꠞ ꠛꠣꠁꠘ ꠘꠣ ꠖꠤꠟꠦꠅ ꠀꠟꠤ ꠢꠥꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT25_25","070_25_25","MAT","25","25","25","ꠄꠞꠖꠣꠄ ꠀꠝꠤ ꠒꠞꠣꠁꠀ ꠀꠙꠘꠣꠞ ꠐꠦꠇꠣ ꠝꠣꠐꠤꠞ ꠔꠟꠦ ꠟꠥꠇꠣꠁꠀ ꠕꠁꠍꠟꠣꠝ। ꠅꠃ ꠘꠦꠃꠇ꠆ꠇꠣ ꠀꠙꠘꠣꠞ ꠐꠦꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_26","070_25_26","MAT","25","26","26","ꠝꠣꠟꠤꠇꠦ ꠇꠁꠟꠣ, ‘ꠢꠣꠄꠞꠦ ꠈꠛꠤꠍ, ꠔꠥꠁꠘ ꠔ ꠇꠥꠠꠤꠀ। ꠔꠥꠁ ꠎꠥꠖꠤ ꠁꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠟꠦ, ꠀꠝꠤ ꠈꠦꠔ ꠘꠣ ꠇꠞꠟꠦꠅ ꠗꠣꠘ ꠇꠣꠐꠤ ꠀꠞ ꠛꠣꠁꠘ ꠘꠣ ꠖꠤꠟꠦꠅ ꠀꠟꠤ ꠢꠥꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("MT25_27","070_25_27","MAT","25","27","27","ꠔꠦ ꠀꠝꠣꠞ ꠐꠦꠇꠣ ꠔꠥꠁ ꠛꠦꠙꠣꠞꠤꠞ ꠉꠦꠍꠦ ꠖꠤꠟꠦ ꠘꠣ ꠇꠦꠘꠦ? ꠔꠦ ꠔ ꠀꠝꠤ ꠀꠁꠀ ꠝꠥꠟ ꠐꠦꠇꠣꠞ ꠟꠉꠦ ꠇꠤꠍꠥ ꠟꠣꠜ ꠙꠣꠁꠟꠣꠝ ꠅꠘꠦ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_28","070_25_28","MAT","25","28","28","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠁꠘ꠆ꠘ ꠌꠣꠇꠞ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠞꠣ ꠅꠉꠥꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠃ ꠐꠦꠇꠣ ꠘꠤꠀ, ꠖꠡ ꠀꠎꠣꠞ ꠎꠣꠞ ꠉꠦꠍꠦ ꠀꠍꠦ ꠔꠣꠞꠦ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("MT25_29","070_25_29","MAT","25","29","29","ꠢꠥꠘꠅ, ꠎꠣꠞ ꠀꠍꠦ ꠔꠣꠞꠦ ꠀꠞꠅ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠔꠣꠞ ꠀꠞꠅ ꠛꠣꠠꠤꠛ। ꠅꠁꠟꠦ ꠎꠣꠞ ꠘꠣꠁ, ꠔꠣꠞ ꠎꠦꠔꠣ ꠀꠍꠦ ꠅꠔꠣꠅ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT25_30","070_25_30","MAT","25","30","30","ꠅꠃ ꠛꠎ꠆ꠎꠣꠔ ꠌꠣꠇꠞꠞꠦ ꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠀꠘ꠆ꠖꠣꠁꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁ ꠖꠦꠅ। ꠢꠃ ꠉꠣꠔꠅ ꠝꠣꠘꠡꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠛ ꠀꠞ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠄ ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠖꠤꠛ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_31","070_25_31","MAT","25","31","31","“ꠛꠤꠘ-ꠀꠖꠝꠦ ꠎꠦꠛꠟꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠘꠤꠎꠞ ꠝꠢꠤꠝꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠛꠣ, ꠀꠁꠀ ꠘꠤꠎꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠉꠖꠤꠔ ꠛꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_32","070_25_32","MAT","25","32","32","ꠅꠃ ꠡꠝꠄ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠘꠣ ꠅꠁꠛ। ꠞꠣꠈꠣꠟꠦ ꠎꠦꠟꠣ ꠝꠦꠠꠣ ꠀꠞ ꠍꠣꠉꠟꠞꠦ ꠀꠟꠣꠖꠣ ꠇꠞꠦ, ꠔꠣꠁꠘꠅ ꠅꠃꠟꠣ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠀꠟꠉꠣꠁꠀ ꠖꠥꠁ ꠜꠣꠉ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_33","070_25_33","MAT","25","33","33","ꠔꠣꠘ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠛꠣꠄ ꠝꠦꠠꠣ ꠀꠞ ꠛꠣꠃ ꠉꠣꠟꠣꠛꠣꠄ ꠍꠣꠉꠟꠞꠦ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_34","070_25_34","MAT","25","34","34","“ꠄꠞꠛꠣꠖꠦ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠘ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠛꠣ, ‘ꠔꠥꠝꠞꠣ ꠎꠣꠞꠣ ꠀꠝꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚꠞ ꠞꠢꠝ ꠙꠣꠁꠍ, ꠔꠥꠝꠞꠣ ꠀꠅ। ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦ ꠛꠣꠖꠡꠣꠁ ꠔꠤꠀꠞ ꠇꠞꠤ ꠞꠣꠈꠣ ꠅꠁꠍꠦ, ꠅꠃ ꠛꠣꠖꠡꠣꠁꠞ ꠖꠈꠟ ꠡꠝꠎꠤꠀ ꠘꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("MT25_35","070_25_35","MAT","25","35","35","ꠝꠘꠅ ꠀꠍꠦ ꠘꠤ, ꠀꠝꠣꠞ ꠎꠦꠛꠟꠣ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠍꠤꠟ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠈꠣꠘꠤ ꠖꠤꠍꠟꠣꠄ, ꠙꠤꠀꠍꠞ ꠡꠝꠄ ꠙꠣꠘꠤ ꠖꠤꠍꠟꠣꠄ, ꠀꠞ ꠝꠥꠍꠣꠚꠤꠞ ꠢꠣꠟꠔꠦ ꠀꠝꠣꠞꠦ ꠀꠡꠞꠄ ꠖꠤꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT25_36","070_25_36","MAT","25","36","36","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠃꠖꠟꠣ ꠀꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠇꠣꠙꠠ ꠖꠤꠍꠟꠣꠄ, ꠛꠦꠝꠣꠞꠞ ꠡꠝꠄ ꠈꠦꠎꠝꠔ ꠇꠞꠍꠟꠣꠄ, ꠀꠞ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_37","070_25_37","MAT","25","37","37","“ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠀꠟ꠆ꠟꠣꠅꠀꠟꠣ ꠝꠣꠘꠡꠦ ꠇꠁꠛꠣ, ‘ꠝꠣꠟꠤꠇ, ꠀꠙꠘꠣꠞ ꠜꠥꠇ ꠟꠣꠉꠣꠄ ꠀꠝꠞꠣ ꠇꠥꠘ ꠡꠝꠄ ꠀꠙꠘꠣꠞꠦ ꠈꠣꠅꠀꠁꠟꠣꠝ? ꠇꠥꠘ ꠡꠝꠄ ꠀꠙꠘꠣꠞꠦ ꠙꠣꠘꠤ ꠖꠤꠟꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("MT25_38","070_25_38","MAT","25","38","38","ꠀꠞ ꠇꠥꠘ ꠡꠝꠄ ꠝꠥꠍꠣꠚꠤꠞ ꠢꠣꠟꠔꠦ ꠀꠙꠘꠣꠞꠦ ꠀꠡꠞꠄ ꠖꠤꠟꠣꠝ, ꠈꠣꠟꠤ ꠉꠣ ꠖꠦꠈꠤꠀ ꠇꠥꠘ ꠡꠝꠄ ꠇꠣꠙꠠ ꠖꠤꠟꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("MT25_39","070_25_39","MAT","25","39","39","ꠀꠞ ꠇꠥꠘ ꠡꠝꠄꠃ ꠛꠣ ꠛꠦꠝꠣꠞꠤ ꠢꠣꠟꠔꠅ ꠀꠙꠘꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠟꠣꠝ, ꠛꠣ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠖꠦꠈꠣꠔ ꠉꠦꠟꠣꠝ?’ ");
INSERT INTO syls_vpl VALUES ("MT25_40","070_25_40","MAT","25","40","40","ꠅꠃ ꠡꠝꠄ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠛꠣ, ‘ꠀꠝꠤ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠀꠝꠣꠞ ꠅꠃ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠁꠔꠣ ꠇꠞꠍ, ꠄꠞ ꠝꠣꠘꠤ ꠀꠝꠣꠞꠦꠃ ꠇꠞꠍ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_41","070_25_41","MAT","25","41","41","“ꠛꠣꠖꠦ ꠛꠣꠖꠡꠣꠄ ꠔꠣꠘ ꠛꠣꠃ ꠉꠣꠟꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠛꠣ, ‘ꠅ ꠟꠣꠘ꠆ꠘꠔꠤꠞ ꠖꠟ, ꠀꠝꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠜꠣꠉꠅ। ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘ ꠀꠞ ꠔꠣꠞ ꠌꠣꠝꠌꠣ ꠎꠤꠘ꠆ꠘꠣꠔ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠖꠥꠎꠈꠞ ꠎꠦ ꠀꠉꠥꠁꠘ ꠔꠤꠀꠞ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠢꠘꠅ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("MT25_42","070_25_42","MAT","25","42","42","ꠀꠝꠣꠞ ꠙꠦꠐꠅ ꠜꠥꠇꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠈꠣꠅꠀꠁꠍ ꠘꠣ, ꠙꠤꠀꠍꠞ ꠡꠝꠄ ꠙꠣꠘꠤ ꠖꠤꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT25_43","070_25_43","MAT","25","43","43","ꠀꠝꠣꠞ ꠝꠥꠍꠣꠚꠤꠞ ꠢꠣꠟꠔꠅ ꠞꠁꠛꠣꠞ ꠀꠡꠞꠄ ꠖꠤꠍ ꠘꠣ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠃꠖꠟꠣ ꠀꠍꠟꠣꠝ, ꠇꠣꠙꠠ ꠖꠤꠍ ꠘꠣ, ꠛꠦꠝꠣꠞꠞ ꠡꠝꠄ ꠌꠣꠁꠍ ꠘꠣ, ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠟꠈꠣꠘꠣꠔꠅ ꠉꠦꠍ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT25_44","070_25_44","MAT","25","44","44","“ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠇꠁꠛꠣ, ‘ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠇꠥꠘ ꠡꠝꠄ ꠁꠔꠣ ꠇꠞꠟꠣꠝ? ꠀꠙꠘꠣꠞꠦ ꠜꠥꠇꠣꠡꠤ, ꠙꠤꠀꠍꠤ, ꠝꠥꠍꠣꠚꠤꠞ, ꠃꠖꠟꠣ ꠉꠔꠞ, ꠛꠦꠝꠣꠞꠤ ꠀꠞ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠖꠦꠈꠤꠀꠅ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠟꠣꠝ ꠘꠣ?’ ");
INSERT INTO syls_vpl VALUES ("MT25_45","070_25_45","MAT","25","45","45","ꠛꠣꠖꠡꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠛꠣ, ‘ꠀꠝꠤ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠀꠝꠣꠞ ꠅꠃ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠁꠔꠣ ꠇꠞꠍ ꠘꠣ, ꠄꠞ ꠝꠣꠘꠤ ꠀꠝꠣꠞꠦꠃ ꠇꠞꠍ ꠘꠣ।’ ” ");
INSERT INTO syls_vpl VALUES ("MT25_46","070_25_46","MAT","25","46","46","ꠢꠦꠡꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠦ ꠀꠈꠦꠞꠣꠔꠅ ꠌꠤꠞꠇꠣꠟ ꠡꠣꠎꠣ ꠙꠣꠁꠛꠣ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠅꠀꠟꠣ ꠝꠣꠘꠡꠦ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT26_1","070_26_1","MAT","26","1","1","ꠅꠃ ꠛꠄꠀꠘ ꠡꠦꠡ ꠅꠁꠀ ꠢꠣꠞꠟꠦ, ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT26_2","070_26_2","MAT","26","2","2","“ꠔꠥꠝꠞꠣꠞ ꠔ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠀꠞ ꠖꠥꠁ ꠖꠤꠘ ꠛꠣꠖꠦꠃ ꠀꠎꠣꠖꠤ ꠁꠖ। ꠁꠖꠞ ꠡꠝꠄ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠗꠞꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT26_3","070_26_3","MAT","26","3","3","ꠅꠃ ꠡꠝꠄ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠀꠁꠀ, ꠔꠣꠞꠣꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠇꠣꠄꠀꠚꠣꠞ ꠛꠣꠠꠤꠔ ꠖꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_4","070_26_4","MAT","26","4","4","ꠖꠟꠣ ꠅꠁꠀ ꠅꠃ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ, ꠁꠍꠣꠞꠦ ꠇꠤꠟꠣ ꠟꠥꠇꠣꠁꠀ ꠀꠐꠇ ꠇꠞꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT26_5","070_26_5","MAT","26","5","5","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠁꠖꠞ ꠡꠝꠄ ꠔꠣꠞꠦ ꠗꠞꠔꠣꠝ ꠘꠣꠄ। ꠗꠞꠟꠦ ꠝꠣꠘꠡꠦ ꠉꠘ꠆ꠒꠉꠥꠟ ꠟꠣꠉꠣꠁ ꠖꠤꠔ ꠙꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT26_6","070_26_6","MAT","26","6","6","ꠁꠍꠣ ꠎꠦꠛꠟꠣ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠉꠣꠃꠞ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤ ꠍꠣꠁꠝꠘꠞ ꠛꠣꠠꠤꠔ ꠀꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT26_7","070_26_7","MAT","26","7","7","ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠛꠦꠐꠤꠄ ꠌꠤꠘꠞ ꠄꠇ ꠛꠂꠀꠝꠅ ꠇꠞꠤ ꠈꠥꠛ ꠖꠣꠝꠤ ꠈꠣꠐꠤ ꠀꠔꠞ ꠀꠘꠍꠤꠟꠣ। ꠁꠍꠣ ꠈꠣꠅꠀꠔ ꠛꠁꠀ ꠢꠣꠞꠟꠦ ꠛꠦꠐꠤꠄ ꠢꠇꠟ ꠀꠔꠞ ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠓꠣꠟꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_8","070_26_8","MAT","26","8","8","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠛꠤꠞꠇ꠆ꠔ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠅꠃ ꠀꠔꠞ ꠚꠥꠐꠣꠁꠘ ꠇꠦꠘꠦ ꠛꠞꠛꠣꠖ ꠇꠞꠣ ꠅꠁꠟ? ");
INSERT INTO syls_vpl VALUES ("MT26_9","070_26_9","MAT","26","9","9","ꠁ ꠚꠥꠐꠤꠘ ꠛꠦꠌꠤꠟꠦ ꠔ ꠛꠃꠔ ꠐꠦꠇꠣ ꠙꠣꠁꠀ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀ ꠉꠦꠟ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT26_10","070_26_10","MAT","26","10","10","ꠁꠈꠣꠘ ꠛꠥꠎꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁ ꠛꠦꠐꠤꠉꠥꠞꠦ ꠖꠥꠈ ꠖꠤꠞꠣꠄ ꠇꠦꠘꠦ? ꠔꠣꠁꠘ ꠔ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠇꠣꠝꠃ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT26_11","070_26_11","MAT","26","11","11","ꠉꠞꠤꠛ ꠅꠇꠟ ꠔ ꠢꠣꠝꠦꠡꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠛꠣ। ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠔ ꠢꠣꠝꠦꠡꠣ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT26_12","070_26_12","MAT","26","12","12","ꠄꠁꠘ ꠀꠁꠀ ꠀꠝꠣꠞ ꠉꠔꠞꠅ ꠀꠔꠞ ꠝꠣꠈꠣꠁꠀ, ꠖꠣꠚꠘ-ꠇꠣꠚꠘꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠎꠥꠁꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT26_13","070_26_13","MAT","26","13","13","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠖꠥꠘꠤꠀꠞ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠀꠟ꠆ꠟꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠡꠝꠄ, ꠅꠃ ꠛꠦꠌꠣꠠꠤꠞꠦ ꠝꠘꠅ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠘ ꠁ ꠘꠦꠇ ꠇꠣꠝꠞ ꠇꠕꠣꠈꠣꠘꠅ ꠇꠅꠀ ꠎꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT26_14","070_26_14","MAT","26","14","14","ꠛꠣꠖꠦ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ, ꠄꠘ ꠘꠣꠝ ꠁꠢꠥꠖꠣ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔ, ꠄꠁꠘ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT26_15","070_26_15","MAT","26","15","15","“ꠁꠍꠣꠞꠦ ꠀꠙꠘꠣꠞꠣꠞ ꠀꠔꠅ ꠗꠞꠣꠁꠀ ꠖꠤꠟꠦ ꠀꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠖꠤꠛꠣ?” ꠔꠦꠃ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠔꠣꠞꠦ ꠞꠥꠙꠣꠞ ꠔꠤꠡ ꠐꠦꠇꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_16","070_26_16","MAT","26","16","16","ꠄꠞꠛꠣꠖ ꠕꠣꠇꠤꠃ ꠁꠢꠥꠖꠣꠄ ꠁꠍꠣꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠦꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠔꠥꠇꠣꠘꠤꠔ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT26_17","070_26_17","MAT","26","17","17","ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ ꠈꠣꠅꠀꠞ ꠁꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠀꠙꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠈꠣꠘꠣ ꠔꠤꠀꠞ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("MT26_18","070_26_18","MAT","26","18","18","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠐꠣꠃꠘꠅ ꠎꠣꠅ। ꠉꠤꠀ ꠅꠝꠥꠇ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠅ, ‘ꠢꠥꠎꠥꠞꠦ ꠇꠁꠍꠂꠘ, ꠀꠝꠣꠞ ꠡꠝꠄ ꠊꠘꠣꠁꠀ ꠀꠁꠌ꠆ꠍꠦ, ꠔꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠁꠖ ꠇꠞꠝꠥ।’ ” ");
INSERT INTO syls_vpl VALUES ("MT26_19","070_26_19","MAT","26","19","19","ꠁꠍꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠉꠤꠀ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠈꠣꠘꠤ ꠔꠤꠀꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_20","070_26_20","MAT","26","20","20","ꠛꠣꠖꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠟꠁꠀ ꠈꠣꠘꠤꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_21","070_26_21","MAT","26","21","21","ꠛꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇ ꠎꠘꠦꠃ ꠔ ꠀꠝꠣꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT26_22","070_26_22","MAT","26","22","22","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠉꠦꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠎꠘ ꠇꠤꠔꠣ ꠀꠝꠤ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT26_23","070_26_23","MAT","26","23","23","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠕꠣꠟꠅ ꠀꠔ ꠢꠣꠞꠣꠞ, ꠢꠦ-ꠃ ꠀꠝꠣꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MT26_24","070_26_24","MAT","26","24","24","ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠝꠃꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠎꠦꠟꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠝꠣꠞ ꠝꠃꠔ ꠔ ꠅꠃꠟꠣꠃ ꠅꠁꠛ। ꠅꠁꠟꠦ ꠀꠚꠍꠥꠍ ꠢꠃ ꠎꠘꠞ ꠟꠣꠉꠤ, ꠎꠦꠉꠤꠄ ꠀꠝꠣꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠤꠛ। ꠖꠥꠘꠤꠀꠔ ꠔꠣꠞ ꠎꠘꠝ ꠘꠣ ꠅꠀꠃ, ꠔꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠜꠣꠟꠣ ꠀꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MT26_25","070_26_25","MAT","26","25","25","ꠎꠦ ꠁꠢꠥꠖꠣꠄ ꠁꠍꠣꠞꠦ ꠗꠞꠣꠁ ꠖꠤꠔ ꠌꠣꠞ, ꠢꠦ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠢꠤ ꠎꠘ ꠇꠤꠔꠣ ꠀꠝꠤ ꠘꠤ?” ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠑꠤꠇꠃ ꠇꠁꠞꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT26_26","070_26_26","MAT","26","26","26","ꠔꠣꠞꠣ ꠈꠣꠘꠣ ꠈꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠞꠥꠐꠤ ꠀꠔꠅ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠞꠥꠐꠤ ꠍꠤꠠꠤꠀ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠤꠟꠣ। ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅꠃ ꠘꠦꠅ, ꠈꠣꠅ, ꠝꠘꠅ ꠇꠞꠅ ꠁꠔꠣ ꠀꠝꠣꠞ ꠇꠣꠄꠀ।” ");
INSERT INTO syls_vpl VALUES ("MT26_27","070_26_27","MAT","26","27","27","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠡꠞꠛꠔꠞ ꠙꠤꠀꠟꠣ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠄꠞꠣꠞꠦ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠅꠃ ꠙꠤꠀꠟꠣ ꠕꠣꠇꠤ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠈꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("MT26_28","070_26_28","MAT","26","28","28","ꠝꠘꠅ ꠇꠞꠤꠅ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠟꠃ। ꠅꠃ ꠟꠃꠞ ꠎꠞꠤꠀꠄ ꠀꠖꠝ ꠎꠣꠔꠤꠞ ꠛꠃꠔꠞ ꠉꠥꠘꠣ ꠝꠣꠚꠤ ꠅꠁꠛ। ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠣꠘꠡꠞ ꠝꠤꠟꠘꠞ ꠃꠍꠤꠟ꠆ꠟꠣ ꠅꠁꠟ ꠅꠃ ꠟꠃ। ");
INSERT INTO syls_vpl VALUES ("MT26_29","070_26_29","MAT","26","29","29","ꠀꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠀꠞ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠖꠣꠈꠤꠟ ꠅꠁꠀ ꠢꠣꠞꠤ, ꠔꠥꠝꠞꠣꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠎꠔꠖꠤꠘ ꠘꠄꠀ ꠢꠣꠟꠔꠦ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠘꠣ ꠈꠣꠁꠍꠤ, ꠅꠔ ꠖꠤꠘ ꠁ ꠡꠞꠛꠔ ꠀꠞ ꠈꠣꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT26_30","070_26_30","MAT","26","30","30","ꠢꠦꠡꠦ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤ ꠄꠇ ꠉꠎꠟ ꠉꠣꠁꠀ, ꠊꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠎꠄꠔꠥꠘ ꠙꠣꠠꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT26_31","070_26_31","MAT","26","31","31","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠁꠎ ꠞꠣꠁꠔ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠔ ꠀꠝꠣꠞꠦ ꠚꠣꠟꠣꠁꠀ ꠜꠣꠉꠤꠛꠣꠄ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ‘ꠀꠝꠤ ꠝꠦꠠꠣꠞ ꠙꠣꠟꠞ ꠞꠣꠈꠣꠟꠞꠦ ꠝꠣꠞꠝꠥ, ꠔꠦꠃ ꠙꠣꠟꠞ ꠝꠦꠠꠣꠁꠘ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤꠎꠤꠛꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MT26_32","070_26_32","MAT","26","32","32","ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣꠞ ꠛꠣꠖꠦ, ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦꠃ ꠀꠝꠤ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠎꠣꠁꠝꠥꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT26_33","070_26_33","MAT","26","33","33","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠢꠇꠟ ꠜꠣꠉꠤ ꠉꠦꠟꠦꠅ ꠀꠝꠤ ꠜꠣꠉꠤꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT26_34","070_26_34","MAT","26","34","34","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠀꠁꠎ ꠙꠔꠣꠛꠣꠟꠣ ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠛꠣꠞ ꠀꠉꠦꠃ ꠔꠥꠝꠤ ꠔꠤꠘꠛꠣꠞ ꠇꠁꠛꠣꠄ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT26_35","070_26_35","MAT","26","35","35","ꠅꠁꠟꠦ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠃ ꠇꠤꠔꠣ ꠇꠂꠘ, ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠝꠞꠘꠅ ꠅꠄ, ꠔꠣ-ꠅ ꠀꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠙꠘꠣꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠔꠣꠝ ꠘꠣꠄ।” ꠢꠇꠟ ꠍꠣꠢꠣꠛꠤꠄ ꠅꠃ ꠄꠇꠟꠣꠈꠣꠘ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_36","070_26_36","MAT","26","36","36","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠉꠦꠔꠡꠤꠝꠣꠘꠤ ꠘꠣꠝꠞ ꠄꠇ ꠛꠣꠉꠣꠘꠅ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠛꠅ, ꠀꠝꠤ ꠢꠉꠣꠟꠣꠔ ꠉꠤꠀ ꠖꠥꠀ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT26_37","070_26_37","MAT","26","37","37","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠙꠤꠔꠞ ꠀꠞ ꠎꠤꠛꠥꠖꠤꠀꠞ ꠖꠥꠁ ꠙꠥꠀꠞꠦ ꠔꠣꠘ ꠟꠉꠦ ꠘꠤꠟꠣ। ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠔꠣꠘ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠖꠥꠈ ꠀꠞ ꠢꠣꠄ-ꠢꠥꠔꠣꠡ ꠛꠣꠠꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT26_38","070_26_38","MAT","26","38","38","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠖꠥꠈꠦ ꠀꠝꠣꠞ ꠇꠁꠟꠎꠣ ꠚꠣꠐꠤꠎꠣꠞ। ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠛꠁꠞꠅ ꠀꠞ ꠀꠝꠣꠞ ꠟꠉꠦ ꠢꠎꠣꠉ ꠞꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT26_39","070_26_39","MAT","26","39","39","ꠅꠈꠣꠘ ꠇꠁꠀ ꠕꠥꠠꠣ ꠢꠞꠤꠀ ꠉꠤꠀ ꠔꠣꠁꠘ ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠀꠛ꠆ꠛꠣ, ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠅꠃ ꠎꠦ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠀꠁꠅꠞ, ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠃꠙꠣꠄ ꠕꠣꠇꠟꠦ ꠁꠈꠣꠘꠔꠣ ꠢꠞꠣꠁꠟꠣꠅ। ꠅꠁꠟꠦ ꠁꠔꠣ ꠀꠝꠣꠞ ꠁꠌ꠆ꠍꠣꠄ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇꠃ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MT26_40","070_26_40","MAT","26","40","40","ꠍꠁꠎꠖꠣ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠄꠞꠣ ꠊꠥꠝꠣꠁ ꠉꠦꠍꠂꠘ। ꠅꠃ ꠔꠣꠁꠘ ꠙꠤꠔꠞꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠄꠇꠈꠣꠘ ꠊꠘ꠆ꠐꠣꠅ ꠢꠎꠣꠉ ꠞꠁꠔꠣꠄ ꠙꠣꠞꠟꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT26_41","070_26_41","MAT","26","41","41","ꠢꠎꠣꠉ ꠞꠅ ꠖꠥꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠖꠥꠀ ꠇꠞꠅ ꠙꠞꠤꠇ꠆ꠇꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠞ ꠟꠣꠉꠤ। ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠘꠤꠌꠄ ꠈꠤꠀꠟ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠇꠣꠄꠀ ꠔ ꠇꠝꠎꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT26_42","070_26_42","MAT","26","42","42","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠉꠤꠀ ꠖꠥꠀ ꠇꠞꠟꠣ, “ꠅ ꠀꠝꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠀꠛ꠆ꠛꠣ, ꠅꠃ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠀꠝꠤ ꠡꠁꠎ꠆ꠎ ꠘꠣ ꠇꠞꠟꠦ, ꠎꠥꠖꠤ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠙꠕ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠣꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇꠃ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MT26_43","070_26_43","MAT","26","43","43","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠄꠞꠣ ꠊꠥꠝꠣꠁ ꠉꠦꠍꠂꠘ, ꠊꠥꠝꠦ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠚꠣꠟꠣꠁ ꠖꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("MT26_44","070_26_44","MAT","26","44","44","ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠕꠁꠀ ꠔꠣꠁꠘ ꠔꠤꠍꠞꠣ ꠛꠣꠞ ꠉꠤꠀ ꠄꠇꠁ ꠖꠥꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_45","070_26_45","MAT","26","45","45","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠖꠦꠈꠤ ꠅꠈꠘꠅ ꠀꠞꠣꠝꠦ ꠊꠥꠝꠣꠁꠞꠣꠄ। ꠢꠥꠘꠅ, ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MT26_46","070_26_46","MAT","26","46","46","ꠃꠑꠅ, ꠀꠝꠞꠣ ꠞꠅꠀꠘꠣ ꠖꠦꠁ। ꠀꠝꠣꠞꠦ ꠎꠦꠉꠤꠄ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠛ, ꠢꠦ ꠀꠁꠀ ꠀꠎꠤꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT26_47","070_26_47","MAT","26","47","47","ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠅ ꠞꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠣ ꠢꠘꠅ ꠀꠁꠟ। ꠢꠦ ꠀꠍꠤꠟ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ। ꠔꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠀꠞꠅ ꠛꠃꠔꠦ ꠟꠣꠑꠤ-ꠍꠐꠣ, ꠔꠟꠥꠀꠞ ꠟꠁꠀ ꠀꠁꠟ। ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠄꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT26_48","070_26_48","MAT","26","48","48","ꠔꠣꠘꠞꠦ ꠎꠦꠉꠤꠄ ꠗꠞꠣꠁꠀ ꠖꠤꠔ, ꠅꠃ ꠁꠢꠥꠖꠣꠄ ꠔꠣꠞ ꠟꠉꠞ ꠄꠞꠣꠞꠦ ꠀꠉꠦ ꠢꠤꠇꠣꠁꠀ ꠖꠤꠍꠤꠟ, “ꠀꠝꠤ ꠉꠤꠀ ꠎꠣꠞ ꠉꠣꠟꠅ ꠢꠥꠋꠉꠣ ꠖꠤꠝꠥ, ꠢꠦ-ꠃ ꠢꠃ ꠎꠘ। ꠔꠥꠝꠞꠣ ꠄꠞꠦ ꠀꠐꠇ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT26_49","070_26_49","MAT","26","49","49","ꠄꠞꠟꠣꠉꠤ ꠁꠢꠥꠖꠣꠄ ꠡꠥꠎꠣ-ꠡꠥꠎꠤ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ।” ꠇꠁꠀ ꠢꠦ ꠔꠣꠘꠞꠦ ꠢꠥꠋꠉꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT26_50","070_26_50","MAT","26","50","50","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁꠞꠦ, ꠎꠦꠔꠣ ꠇꠞꠣꠔ ꠀꠁꠍ, ꠇꠞꠤꠟꠣꠅ।” ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞꠣ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT26_51","070_26_51","MAT","26","51","51","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠞ ꠟꠉꠞ ꠄꠇꠎꠘꠦ ꠘꠤꠎꠞ ꠔꠟꠥꠀꠞ ꠛꠣꠞ ꠇꠞꠤꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠍꠦꠖ ꠝꠣꠞꠟꠣ, ꠍꠦꠖꠞ ꠟꠉꠦ ꠔꠣꠞ ꠄꠇ ꠇꠣꠘ ꠇꠣꠐꠤꠀ ꠙꠠꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT26_52","070_26_52","MAT","26","52","52","ꠔꠦꠃ ꠁꠍꠣꠄ ꠄꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠔꠟꠥꠀꠞ ꠛꠦꠉꠅ ꠢꠣꠞꠣꠁꠟꠣꠅ। ꠔꠟꠥꠀꠞꠖꠤ ꠎꠣꠞꠣ ꠈꠦꠟꠣꠄ, ꠔꠟꠥꠀꠞꠞ ꠔꠟꠦꠃ ꠔꠣꠞꠣꠞ ꠎꠣꠘ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT26_53","070_26_53","MAT","26","53","53","ꠔꠥꠝꠤ ꠁꠈꠣꠘ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠅ ꠘꠣ ꠘꠤ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠞꠎ ꠇꠞꠟꠦ, ꠔꠣꠁꠘ ꠇꠁꠄꠇ ꠀꠎꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠙꠣꠑꠣꠁꠔꠣ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MT26_54","070_26_54","MAT","26","54","54","ꠅꠁꠟꠦ ꠀꠝꠤ ꠁꠟꠣ ꠇꠞꠟꠦ ꠇꠤꠔꠣꠛꠞ ꠇꠕꠣ ꠇꠤꠟꠣ ꠚꠟꠤꠛ? ꠇꠤꠔꠣꠛꠅ ꠎꠔꠔꠣ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠔ ꠊꠐꠛꠃ।” ");
INSERT INTO syls_vpl VALUES ("MT26_55","070_26_55","MAT","26","55","55","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠀꠝꠤ ꠇꠥꠘꠥ ꠌꠥꠞ-ꠒꠣꠇꠣꠁꠔ ꠘꠤ, ꠔꠥꠝꠞꠣ ꠖꠦꠈꠤ ꠟꠣꠑꠤ-ꠍꠐꠣ, ꠔꠟꠥꠀꠞ ꠟꠁꠀ ꠀꠝꠣꠞꠦ ꠗꠞꠣꠔ ꠀꠁꠍ। ꠀꠝꠤ ꠔ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠛꠁꠀ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣꠝ। ꠅꠃ ꠡꠝꠄ ꠔ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠗꠞꠟꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_56","070_26_56","MAT","26","56","56","ꠀꠍꠟꠦ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠊꠐꠦꠞ, ꠎꠣꠔꠦ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠘꠛꠤ ꠅꠇꠟꠦ ꠎꠦꠟꠣ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠅꠔꠣ ꠙꠥꠞꠣ ꠅꠄ।” ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠕꠁꠀ ꠜꠣꠉꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_57","070_26_57","MAT","26","57","57","ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠀ ꠢꠣꠞꠤ ꠅꠃ ꠝꠣꠘꠡꠦ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠇꠣꠄꠀꠚꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟ। ꠢꠘꠅ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_58","070_26_58","MAT","26","58","58","ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞ ꠁꠍꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠖꠥꠞꠁ ꠢꠞꠤ ꠢꠞꠤ ꠞꠁꠀ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠛꠣꠠꠤꠞ ꠃꠑꠣꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠢꠦꠡ-ꠝꠦꠡ ꠇꠤꠔꠣ ꠅꠄ, ꠅꠈꠣꠘ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠃꠑꠣꠘꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ, ꠢꠘꠞ ꠙꠣꠞꠣꠖꠣꠞ ꠅꠇꠟꠞ ꠟꠉꠦ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT26_59","070_26_59","MAT","26","59","59","ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠀꠞ ꠝꠎꠟꠤꠍꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠔꠥꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT26_60","070_26_60","MAT","26","60","60","ꠅꠁꠟꠦ ꠙꠣꠁꠟꠣ ꠘꠣ। ꠝꠎꠟꠤꠍꠅ ꠁꠍꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠛꠃꠔꠦ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠟꠦꠅ, ꠔꠣꠞꠣꠞ ꠡꠣꠇ꠆ꠇꠤꠞ ꠝꠤꠟ ꠅꠁꠟ ꠘꠣ। ꠛꠣꠖꠦ ꠖꠥꠁꠎꠘ ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠔꠣꠘ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT26_61","070_26_61","MAT","26","61","61","“ꠀꠝꠞꠣ ꠢꠥꠘꠍꠤ, ꠢꠦ ꠇꠁꠍꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠛꠣ ꠡꠞꠤꠚ, ꠝꠣꠘꠤ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞꠦ ꠢꠦ ꠜꠣꠋꠉꠤꠟꠤꠛ, ꠀꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠜꠤꠔꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠘꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT26_62","070_26_62","MAT","26","62","62","ꠔꠦꠃ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠃꠛꠣꠁꠀ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠝꠣꠔꠞ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ ꠘꠣ ꠘꠤ? ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠤꠔꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ, ꠢꠥꠘꠞꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT26_63","070_26_63","MAT","26","63","63","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠘꠣ ꠖꠤꠀ ꠘꠤꠞꠣꠁ ꠞꠁꠟꠣ। ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠔꠣꠘꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠅ ꠌꠣꠁꠘ, ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ ꠘꠤ, ꠔꠥꠝꠤꠃ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MT26_64","070_26_64","MAT","26","64","64","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠣꠞꠣꠃ ꠔ ꠇꠁꠞꠣ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠀꠙꠘꠣꠞꠣ ꠖꠦꠈꠛꠣꠘꠦ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠀꠟ꠆ꠟꠣ ꠞꠣꠛ꠆ꠛꠥꠟ ꠀꠟꠣꠝꠤꠘꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠤ। ꠀꠞꠅ ꠖꠦꠈꠛꠣ, ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠔ ꠅꠁꠀ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT26_65","070_26_65","MAT","26","65","65","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠘꠤꠎꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠍꠤꠠꠤꠀ ꠇꠁꠟꠣ, “ꠢꠦ ꠔ ꠡꠤꠞꠤꠇꠤ ꠇꠞꠟ, ꠔꠦ ꠀꠞ ꠇꠥꠘꠥ ꠡꠣꠇ꠆ꠇꠤꠞ ꠎꠞꠥꠞ ꠀꠍꠦ ꠘꠤ? ꠀꠙꠘꠣꠞꠣ ꠘꠤꠎꠞ ꠇꠣꠘꠦꠃ ꠔ ꠢꠥꠘꠟꠣ, ꠢꠦ ꠡꠤꠞꠤꠇꠤ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT26_66","070_26_66","MAT","26","66","66","ꠔꠦ ꠅꠈꠘ ꠀꠙꠘꠣꠞꠣ ꠇꠤꠔꠣ ꠞꠣꠄ ꠖꠤꠛꠣ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠄꠞꠦ ꠔ ꠝꠣꠞꠤꠟꠣꠅꠀ ꠖꠞꠇꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT26_67","070_26_67","MAT","26","67","67","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠔꠣꠘ ꠝꠥꠈꠅ ꠍꠦꠚ ꠖꠤꠟ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠌꠠ-ꠔꠣꠛꠠ ꠝꠣꠞꠟ। ꠇꠦꠃ ꠇꠦꠃ ꠊꠥꠡꠤ ꠝꠣꠞꠤꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT26_68","070_26_68","MAT","26","68","68","“ꠢꠂ ꠀꠟ-ꠝꠍꠤ, ꠉꠣꠁꠛꠤ ꠇꠅ ꠌꠣꠁꠘ, ꠔꠞꠦ ꠇꠦꠉꠤꠄ ꠝꠣꠞꠟ?” ");
INSERT INTO syls_vpl VALUES ("MT26_69","070_26_69","MAT","26","69","69","ꠙꠤꠔꠞ ꠃꠑꠣꠘꠅ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠇꠁꠟ, “ꠉꠣꠟꠤꠟꠞ ꠅꠃ ꠁꠍꠣꠞ ꠟꠉꠦ ꠔ ꠀꠙꠘꠦꠅ ꠀꠍꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT26_70","070_26_70","MAT","26","70","70","ꠅꠁꠟꠦ ꠙꠤꠔꠞꠦ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠘꠣ ꠉ, ꠔꠥꠝꠤ ꠁꠔꠣ ꠇꠤꠔꠣ ꠝꠣꠔꠅ? ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠀꠝꠤ ꠎꠣꠘꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT26_71","070_26_71","MAT","26","71","71","ꠅꠈꠣꠘ ꠇꠁꠀ ꠙꠤꠔꠞ ꠉꠦꠁꠐꠞ ꠗꠣꠞꠅ ꠉꠦꠟꠣꠉꠤ। ꠔꠣꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠀꠞꠇ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠅꠃ ꠛꠦꠐꠣꠅ ꠔ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠞ ꠁꠍꠣꠞ ꠟꠉꠦ ꠀꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MT26_72","070_26_72","MAT","26","72","72","ꠅꠁꠟꠦ ꠙꠤꠔꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠍꠝ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠌꠤꠘꠤꠃ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT26_73","070_26_73","MAT","26","73","73","ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠦꠞꠣ ꠃꠛꠣ ꠀꠍꠤꠟ, ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠤꠅ ꠘꠤꠌ꠆ꠌꠄ ꠄꠞꠣꠞ ꠟꠉꠞ, ꠔꠥꠝꠣꠞ ꠝꠣꠔ-ꠇꠕꠣꠄꠃ ꠔ ꠛꠥꠎꠣ ꠎꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT26_74","070_26_74","MAT","26","74","74","ꠔꠦꠃ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛ ꠙꠠꠃꠇ, ꠀꠝꠤ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠀꠞ, ꠀꠝꠤ ꠝꠥꠐꠦꠃ ꠔꠣꠞꠦ ꠌꠤꠘꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT26_75","070_26_75","MAT","26","75","75","ꠅꠈꠣꠘ ꠇꠁꠔꠦꠃ ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠟꠣꠁꠟ। ꠛꠣꠋ ꠢꠥꠘꠔꠦꠃ ꠙꠤꠔꠞꠞ ꠝꠘꠅ ꠅꠁꠉꠦꠟ, ꠁꠍꠣꠄ ꠀꠉꠦ ꠇꠁꠍꠟꠣ, “ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠛꠣꠞ ꠀꠉꠦꠃ ꠔꠥꠝꠤ ꠔꠤꠘꠛꠣꠞ ꠇꠁꠛꠣꠄ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠅ ꠘꠣ।” ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠛꠣꠞꠦ ꠉꠤꠀ ꠀꠃ-ꠀꠃ ꠇꠞꠤ ꠇꠣꠘ꠆ꠖꠘ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_1","070_27_1","MAT","27","1","1","ꠛꠤꠀꠘꠦ ꠃꠑꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_2","070_27_2","MAT","27","2","2","ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠥꠝꠣꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_3","070_27_3","MAT","27","3","3","ꠎꠦ ꠎꠘꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠍꠤꠟ, ꠢꠃ ꠁꠢꠥꠖꠣꠄ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟ ꠛꠤꠌꠣꠞꠅ ꠔꠣꠘꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠅꠃ ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠈꠥꠛ ꠖꠥꠈ ꠢꠣꠝꠣꠁꠟ। ꠢꠦ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠢꠃ ꠞꠥꠙꠣꠞ ꠔꠤꠡ ꠐꠦꠇꠣ ꠟꠁꠀ ꠀꠁꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT27_4","070_27_4","MAT","27","4","4","“ꠀꠝꠤ ꠔ ꠄꠇꠎꠘ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠗꠞꠣꠁ ꠖꠤꠀ ꠉꠥꠘꠣ ꠇꠞꠍꠤ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠔꠦꠃ ꠀꠝꠞꠣꠞ ꠇꠤꠔꠣ ꠅꠁꠟ? ꠁꠔꠣ ꠔ ꠔꠥꠝꠣꠞ ꠛꠦꠙꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT27_5","070_27_5","MAT","27","5","5","ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠣꠄ ꠢꠃ ꠔꠤꠡ ꠐꠦꠇꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠁꠐꠣ ꠝꠣꠞꠤ ꠚꠣꠟꠣꠁꠀ ꠉꠦꠟꠉꠤ, ꠉꠤꠀ ꠘꠤꠎꠦ ꠘꠤꠎꠦꠃ ꠚꠣꠡ ꠟꠣꠉꠤꠀ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_6","070_27_6","MAT","27","6","6","ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠁ ꠐꠦꠇꠣ ꠀꠔꠅ ꠟꠁꠀ ꠇꠁꠟꠣ, “ꠁꠉꠥꠁꠘ ꠔ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠔꠢꠛꠤꠟꠅ ꠞꠣꠈꠣ ꠑꠤꠇ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠁꠔꠣ ꠅꠁꠟ ꠟꠃꠞ ꠖꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("MT27_7","070_27_7","MAT","27","7","7","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠤꠀ ꠅꠃ ꠐꠦꠇꠣꠖꠤ ꠝꠥꠍꠣꠚꠤꠞ ꠝꠣꠘꠡꠞ ꠇꠛꠞꠡ꠆ꠕꠣꠘꠞ ꠟꠣꠉꠤ ꠄꠇ ꠇꠥꠝꠣꠞꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠣꠉꠣ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_8","070_27_8","MAT","27","8","8","ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠎꠣꠉꠣꠞꠦ ꠅꠈꠘꠅ ‘ꠟꠃꠞ ꠎꠣꠉꠣ’ ꠇꠅꠀ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MT27_9","070_27_9","MAT","27","9","9","ꠁꠔꠣ ꠅꠀꠄ, ꠁꠀꠞꠝꠤꠀ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠅꠔꠣ ꠚꠟꠤꠉꠦꠟ। ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, “ꠔꠣꠞꠣ ꠎꠦ ꠔꠤꠡ ꠐꠦꠇꠣ ꠘꠤꠟ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠔꠣꠘ ꠖꠣꠝ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠔꠣꠘ ꠅꠃ ꠖꠣꠝ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_10","070_27_10","MAT","27","10","10","ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠅꠟꠣꠃ ꠔꠣꠞꠣ ꠇꠥꠝꠣꠞꠞ ꠎꠣꠉꠣ ꠟꠅꠀꠞ ꠟꠣꠉꠤ ꠐꠦꠇꠣ ꠉꠥꠁꠘ ꠖꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MT27_11","070_27_11","MAT","27","11","11","ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠞꠥꠝꠣꠘ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠀꠖꠣꠟꠔꠅ ꠀꠎꠤꠞ ꠇꠞꠣ ꠅꠁꠟ। ꠢꠣꠇꠤꠝꠦ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠔꠥꠝꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠘꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠀꠙꠘꠦ ꠑꠤꠇꠃ ꠇꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT27_12","070_27_12","MAT","27","12","12","ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘ ꠘꠣꠝꠦ ꠛꠃꠔ ꠘꠣꠟꠤꠡ ꠖꠤꠟꠣ। ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_13","070_27_13","MAT","27","13","13","ꠅꠃ ꠡꠝꠄ ꠙꠤꠟꠣꠔꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ ꠘꠣ ꠘꠤ? ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠔ ꠘꠣꠟꠤꠡ ꠖꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT27_14","070_27_14","MAT","27","14","14","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠁꠔꠣꠞ ꠄꠇꠈꠣꠘꠅ ꠎꠥꠀꠙ ꠘꠣ ꠖꠦꠅꠀꠄ ꠙꠤꠟꠣꠔ ꠈꠥꠛ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_15","070_27_15","MAT","27","15","15","ꠖꠦꠡꠞ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝꠞ ꠘꠤꠅꠝ ꠀꠍꠤꠟ, ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠡꠝꠄ ꠝꠣꠘꠡꠞ ꠙꠍꠘ꠆ꠖ ꠝꠣꠚꠤꠇ ꠄꠇꠎꠘ ꠀꠎꠔꠤꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_16","070_27_16","MAT","27","16","16","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣ-ꠛꠣꠞꠣꠛ꠆ꠛꠣ ꠘꠣꠝꠞ ꠄꠇ ꠘꠣꠝꠇꠞꠣ ꠀꠎꠔꠤ ꠎꠦꠟꠅ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_17","070_27_17","MAT","27","17","17","ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠀꠞ ꠛꠣꠖꠦ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠅ? ꠀꠝꠤ ꠇꠣꠞꠦ ꠍꠣꠠꠔꠣꠝ, ꠁꠍꠣ-ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞꠦ, ꠘꠣ ꠢꠃ ꠁꠍꠣꠞꠦ, ꠎꠣꠞꠦ ꠀꠟ-ꠝꠍꠤ ꠇꠅꠀ ꠅꠄ?” ");
INSERT INTO syls_vpl VALUES ("MT27_18","070_27_18","MAT","27","18","18","ꠙꠤꠟꠣꠔꠦ ꠎꠣꠘꠔꠣ, ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠘꠤꠀ ꠔꠣꠘ ꠀꠔꠅ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT27_19","070_27_19","MAT","27","19","19","ꠙꠤꠟꠣꠔ ꠎꠦꠛꠟꠣ ꠢꠣꠇꠤꠝꠞ ꠀꠡꠘꠅ ꠛꠅꠀꠔ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠛꠤꠛꠤꠄ ꠈꠛꠞ ꠙꠣꠑꠣꠁꠀ ꠎꠣꠘꠣꠁꠟꠣ, “ꠅꠃ ꠘꠤꠅꠙꠞꠣꠗ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠝꠤ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠀꠁꠎ ꠄꠇꠐꠣ ꠈꠥꠀꠛ ꠖꠦꠈꠤꠀ ꠛꠠ ꠖꠥꠈ ꠟꠣꠉꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT27_20","070_27_20","MAT","27","20","20","ꠅꠁꠟꠦ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠝꠣꠘꠡꠞꠦ ꠃꠍꠇꠣꠁꠀ ꠖꠤꠟꠣ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞ ꠝꠥꠇ꠆ꠔꠤ ꠌꠣꠁꠘ ꠀꠞ ꠁꠍꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MT27_21","070_27_21","MAT","27","21","21","ꠛꠣꠖꠦ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠦ ꠅꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠃ ꠖꠥꠁꠅꠎꠘꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠇꠣꠞꠦ ꠍꠣꠠꠔꠣꠝ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MT27_22","070_27_22","MAT","27","22","22","ꠔꠦꠃ ꠙꠤꠟꠣꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠞꠦ ꠀꠟ-ꠝꠍꠤ ꠇꠅ, ꠢꠃ ꠁꠍꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠟꠣꠉꠣꠁꠟ, “ꠔꠣꠞꠦ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠤꠀ ꠝꠣꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT27_23","070_27_23","MAT","27","23","23","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠇꠦꠘꠦ, ꠢꠦ ꠇꠤꠔꠣ ꠖꠥꠡ ꠇꠞꠍꠦ?” ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠀꠞꠅ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠝꠤꠍꠤꠟ ꠟꠣꠉꠣꠁꠟ, “ꠍꠟꠤꠛꠅ ꠖꠦꠅ, ꠍꠟꠤꠛꠅ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT27_24","070_27_24","MAT","27","24","24","ꠙꠤꠟꠣꠔꠦ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣ, ꠔꠣꠁꠘ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠁꠍꠣꠞꠦ ꠛꠣꠌꠣꠁꠔꠣ ꠙꠣꠞꠞꠣ ꠘꠣ, ꠛꠞꠋ ꠉꠘ꠆ꠒꠉꠥꠟ ꠀꠞꠅ ꠛꠣꠠꠦꠞ। ꠅꠃ ꠔꠣꠁꠘ ꠙꠣꠘꠤ ꠖꠤꠀ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠘ ꠀꠔ ꠗꠁꠀ ꠇꠁꠟꠣ, “ꠁ ꠝꠣꠘꠡꠞ ꠟꠃꠞ ꠖꠣꠄꠁ ꠀꠝꠤ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠃ ꠄꠞ ꠎꠥꠀꠙ ꠖꠤꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MT27_25","070_27_25","MAT","27","25","25","ꠔꠦꠃ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠇꠁꠟꠣ, “ꠑꠤꠇ ꠀꠍꠦ, ꠀꠝꠞꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠁ ꠟꠃꠞ ꠖꠣꠄꠁ ꠅꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT27_26","070_27_26","MAT","27","26","26","ꠔꠦꠃ ꠙꠤꠟꠣꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠔꠣ ꠇꠞꠤ ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠟꠣꠁꠟꠣ। ꠀꠞ ꠁꠍꠣꠞꠦ ꠛꠦꠡ ꠇꠞꠤ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠤꠀ, ꠍꠟꠤꠛꠅ ꠖꠦꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। (ꠍꠟꠤꠛ ꠅꠁꠟ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠝꠣꠘꠡꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣꠞ ꠄꠇ ꠎꠤꠘꠤꠡ।) ");
INSERT INTO syls_vpl VALUES ("MT27_27","070_27_27","MAT","27","27","27","ꠛꠣꠖꠦ ꠙꠤꠟꠣꠔꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠇꠦꠝ꠆ꠙꠞ ꠜꠤꠔꠞꠦ ꠟꠁꠀ ꠉꠦꠟ। ꠢꠘꠅ ꠀꠡ꠆ꠔꠣ ꠍꠤꠙꠣꠁ ꠖꠟ ꠖꠤꠀ ꠔꠣꠘꠞꠦ ꠛꠦꠞ ꠇꠞꠤ ꠞꠣꠈꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_28","070_27_28","MAT","27","28","28","ꠔꠣꠞꠣ ꠔꠣꠘ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠈꠥꠟꠤꠀ, ꠟꠣꠟ-ꠛꠣꠁꠋꠉꠘꠤ ꠞꠋꠉꠞ ꠛꠣꠖꠡꠣꠁ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_29","070_27_29","MAT","27","29","29","ꠀꠞ ꠉꠍꠣ-ꠇꠣꠐꠣ ꠖꠤꠀ ꠞꠣꠎ-ꠝꠥꠇꠥꠐ ꠛꠣꠘꠣꠁꠀ ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠖꠤꠟ। ꠔꠣꠘ ꠒꠣꠁꠘ ꠀꠔꠅ ꠖꠤꠟ ꠄꠇꠐꠣ ꠞꠣꠎ-ꠟꠣꠑꠤ। ꠔꠣꠘꠦ ꠁꠎ꠆ꠎꠔ ꠖꠦꠈꠣꠘꠤꠞ ꠜꠣꠘ ꠇꠞꠤꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠐꠥ ꠉꠣꠠꠤꠀ ꠛꠁꠀ ꠇꠁꠟ, “ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ, ꠝꠣꠞꠢꠣꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT27_30","070_27_30","MAT","27","30","30","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠍꠦꠚ ꠖꠤꠟ ꠀꠞ ꠅꠃ ꠟꠣꠑꠤ ꠖꠤꠀ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠝꠣꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_31","070_27_31","MAT","27","31","31","ꠅꠃ ꠟꠣꠈꠣꠘ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠀꠞ ꠛꠦꠔ꠆ꠔꠝꠤꠎꠤ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠚꠤꠘ꠆ꠘꠞ ꠛꠣꠁꠋꠉꠘꠤ ꠟꠦꠛꠣꠍ ꠈꠥꠟꠤꠀ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠣꠁꠟ। ꠔꠣꠘꠞꠦ ꠍꠟꠤꠛꠅ ꠘꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠇꠞꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_32","070_27_32","MAT","27","32","32","ꠍꠤꠙꠣꠁ ꠖꠟꠦ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠎꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠇꠥꠞꠤꠘꠤ ꠄꠟꠣꠇꠣꠞ ꠍꠣꠁꠝꠘ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠖꠦꠈꠟ। ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠎꠥꠞ ꠇꠞꠤꠀ ꠄꠘꠦꠖꠤ ꠢꠃ ꠍꠟꠤꠛ ꠛꠅꠀꠁꠀ ꠘꠦꠅꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_33","070_27_33","MAT","27","33","33","ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠉꠟꠉꠣꠕꠣ, ꠝꠣꠘꠤ ꠇꠟ꠆ꠟꠣꠞ ꠌꠣꠠ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_34","070_27_34","MAT","27","34","34","ꠢꠘꠅ ꠘꠤꠀ ꠢꠣꠞꠤ ꠝꠥꠞꠣ ꠘꠣꠝꠞ ꠅꠡꠥꠗ ꠙꠥꠞꠣꠁꠟ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠔꠣꠘ ꠝꠥꠈꠅ ꠖꠤꠟ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠁꠔꠣ ꠈꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_35","070_27_35","MAT","27","35","35","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠘꠤꠀ ꠅꠃ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠤꠟ। ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠔꠣꠘ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠛꠣꠐꠤꠀ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠜꠣꠁꠉ꠆ꠉ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_36","070_27_36","MAT","27","36","36","ꠀꠞ ꠔꠣꠞꠣ ꠅꠘꠅ ꠛꠁꠀ ꠔꠣꠘꠞꠦ ꠙꠣꠞꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_37","070_27_37","MAT","27","37","37","ꠍꠟꠤꠛꠅ ꠔꠣꠘ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠦ ꠅꠙꠞꠣꠗ-ꠘꠣꠝꠣꠞ ꠝꠣꠎꠦ ꠟꠦꠈꠟ, “ꠄꠘ ꠘꠣꠝ ꠁꠍꠣ, ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT27_38","070_27_38","MAT","27","38","38","ꠖꠥꠁꠎꠘ ꠒꠣꠇꠣꠁꠔꠞꠦꠅ ꠔꠣꠘ ꠟꠉꠦ ꠟꠐꠇꠣꠁꠟ ꠅꠁꠟ, ꠄꠇꠎꠘ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ, ꠅꠁꠘ꠆ꠘꠎꠘ ꠛꠣꠃ ꠉꠣꠟꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("MT27_39","070_27_39","MAT","27","39","39","ꠙꠕꠦꠖꠤ ꠎꠦꠞꠣ ꠎꠣꠅꠀꠔ ꠀꠍꠤꠟ ꠔꠣꠞꠣ ꠝꠣꠕꠣ ꠟꠣꠠꠣꠁꠀ ꠁꠍꠣꠞꠦ ꠍꠤꠠꠣꠁꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MT27_40","070_27_40","MAT","27","40","40","“ꠅꠂ ꠝꠤꠀ, ꠔꠥꠝꠤ ꠛꠥꠟꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠇꠣꠛꠣ ꠊꠞ ꠜꠣꠋꠉꠤꠀ ꠔꠤꠘ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠘꠣꠁꠟꠤꠛꠣꠄ! ꠔꠦ ꠅꠈꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅ ꠘꠣ। ꠔꠥꠝꠤ ꠛꠥꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠔꠦ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT27_41","070_27_41","MAT","27","41","41","ꠛꠠ ꠁꠝꠣꠝ, ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦꠅ ꠔꠣꠘꠞꠦ ꠍꠤꠠꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT27_42","070_27_42","MAT","27","42","42","“ꠢꠦ ꠛꠥꠟꠦ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ, ꠅꠈꠘ ꠔ ꠘꠤꠎꠞ ꠎꠣꠘꠃ ꠛꠣꠌꠣꠁꠔ ꠙꠣꠞꠦꠞ ꠘꠣ। ꠢꠤꠞꠛꠣꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠖꠡꠣꠅ ꠛꠥꠟꠦ ꠢꠦ! ꠔꠦ ꠅꠈꠘ ꠙꠣꠞꠟꠦ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠃꠇ, ꠔꠦꠃ ꠀꠝꠞꠣꠅ ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("MT27_43","070_27_43","MAT","27","43","43","ꠢꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠦ। ꠅꠈꠘ ꠀꠟ꠆ꠟꠣ ꠎꠥꠖꠤ ꠔꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠤ ꠕꠣꠇꠂꠘ, ꠔꠦ ꠔꠣꠞꠦ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ। ꠢꠦ ꠔ ꠖꠣꠛꠤ ꠇꠞꠔ, ꠢꠦ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("MT27_44","070_27_44","MAT","27","44","44","ꠔꠣꠘ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠎꠦ ꠖꠥꠁ ꠒꠣꠇꠣꠁꠔꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠔꠣꠞꠣꠅ ꠔꠣꠘꠞꠦ ꠅꠔꠣ ꠇꠁꠀ ꠍꠤꠠꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_45","070_27_45","MAT","27","45","45","ꠅꠃ ꠖꠤꠘ ꠖꠥꠁꠚꠞ ꠕꠣꠇꠤ ꠎꠥꠢꠞꠞ ꠛꠣꠖ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠤꠘ ꠊꠘ꠆ꠐꠣ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_46","070_27_46","MAT","27","46","46","ꠀꠞ ꠁꠍꠣꠄ ꠈꠥꠛ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠄꠟꠥꠁ, ꠄꠟꠥꠁ, ꠟꠣꠝꠣ ꠡꠣꠛꠣꠇ꠆ꠔꠣꠘꠤ?” ꠝꠣꠘꠤ, “ꠅ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠝꠃꠟꠣ, ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠟꠉ ꠍꠣꠠꠤ ꠖꠤꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("MT27_47","070_27_47","MAT","27","47","47","ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠗꠣꠞꠅ ꠎꠣꠞꠣ ꠃꠛꠣ ꠀꠍꠤꠟ, ꠔꠣꠞꠣ ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠢꠥꠘꠅ, ꠢꠦ ꠢꠎꠞꠔ ꠁꠟꠤꠀꠍꠞꠦ ꠒꠣꠇꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MT27_48","070_27_48","MAT","27","48","48","ꠔꠣꠞꠣ ꠄꠇꠎꠘꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠄꠇꠈꠣꠘ ꠔꠦꠘꠣ ꠀꠘꠤꠀ ꠐꠦꠋꠉꠣ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔꠞ ꠝꠣꠎꠦ ꠜꠤꠎꠣꠁꠀ, ꠄꠇ ꠟꠣꠑꠤꠞ ꠝꠣꠕꠣꠔ ꠛꠣꠘ꠆ꠖꠤꠀ ꠃꠌꠣ ꠇꠞꠤ ꠔꠣꠘꠞꠦ ꠈꠣꠁꠔꠦ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_49","070_27_49","MAT","27","49","49","ꠛꠣꠇꠤ ꠢꠇꠟꠦ ꠇꠁꠟ, “ꠀꠁꠌ꠆ꠍꠣ, ꠖꠦꠈꠤ ꠘꠣ, ꠁꠟꠤꠀꠍ ꠘꠛꠤ ꠔꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠔ ꠀꠁꠘ ꠘꠤ।” ");
INSERT INTO syls_vpl VALUES ("MT27_50","070_27_50","MAT","27","50","50","ꠢꠦꠡꠦ ꠁꠍꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠎꠥꠞꠦ ꠀꠅꠀꠎ ꠇꠞꠤꠀ ꠀꠈꠦꠞꠤ ꠖꠝ ꠚꠣꠟꠣꠁꠀ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_51","070_27_51","MAT","27","51","51","ꠟꠉꠦ ꠟꠉꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠝꠣꠘꠤ ꠇꠣꠛꠣ ꠊꠞꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣꠈꠣꠘ, ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠔꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠍꠤꠠꠤꠀ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠅꠁꠉꠦꠟ। ꠀꠞ ꠜꠂꠍꠣꠟꠞ ꠟꠉꠦ ꠛꠠ ꠛꠠ ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟ ꠚꠣꠐꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MT27_52","070_27_52","MAT","27","52","52","ꠛꠃꠔ ꠇꠄꠛꠞꠞ ꠝꠥꠈ ꠈꠥꠟꠤꠉꠦꠟ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠄꠀꠞ ꠎꠦ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠝꠣꠞꠣ ꠉꠦꠍꠟꠣ, ꠄꠞꠣ ꠛꠃꠔ ꠎꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_53","070_27_53","MAT","27","53","53","ꠔꠣꠞꠣ ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ। ꠁꠍꠣ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟꠣ, ꠀꠞ ꠛꠃꠔ ꠎꠘꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_54","070_27_54","MAT","27","54","54","ꠙꠞꠗꠣꠘ ꠍꠤꠙꠣꠁꠞ ꠟꠉꠦ ꠀꠞꠅ ꠎꠦꠔꠣ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠙꠣꠞꠣ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠅꠃ ꠜꠂꠍꠣꠟ ꠀꠞ ꠢꠇꠟ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠈꠥꠛ ꠒꠞꠣꠁꠀ ꠇꠁꠟꠣ, “ꠘꠤꠌ꠆ꠌꠄ, ꠄꠁꠘꠃ ꠀꠍꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠁꠛꠘꠥꠟ꠆ꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("MT27_55","070_27_55","MAT","27","55","55","ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠁꠍꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠟꠉꠦ ꠅꠁꠀ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣꠅ ꠖꠥꠞꠁ ꠃꠛꠣꠁꠀ ꠁꠔꠣ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_56","070_27_56","MAT","27","56","56","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠟꠣ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ, ꠁꠃꠍꠤ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠝꠣ ꠝꠞꠤꠅꠝ, ꠀꠞ ꠎꠤꠛꠥꠖꠤꠀꠞ ꠛꠃ। ");
INSERT INTO syls_vpl VALUES ("MT27_57","070_27_57","MAT","27","57","57","ꠅꠃ ꠖꠤꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠀꠞꠤꠝꠣꠕꠤꠀ ꠉꠣꠃꠞ ꠁꠃꠍꠥꠚ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠗꠘꠤ ꠝꠣꠘꠥꠡ ꠢꠘꠅ ꠀꠁꠟꠣ। ꠔꠣꠁꠘ ꠁꠍꠣꠞ ꠄꠇ ꠡꠣꠉꠞꠤꠖ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_58","070_27_58","MAT","27","58","58","ꠔꠣꠁꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠀꠁꠀ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠣꠡ ꠘꠤꠔꠣ ꠌꠣꠁꠟꠣ। ꠔꠦꠃ ꠙꠤꠟꠣꠔꠦ ꠔꠣꠘꠞꠦ ꠟꠣꠡ ꠘꠦꠅꠀꠞ ꠁꠎꠣꠎꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_59","070_27_59","MAT","27","59","59","ꠁꠃꠍꠥꠚꠦ ꠁꠍꠣꠞ ꠟꠣꠡ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠣꠁꠀ ꠇꠣꠚꠘ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_60","070_27_60","MAT","27","60","60","ꠔꠣꠁꠘ ꠙꠣꠠ ꠇꠣꠐꠤꠀ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠎꠦ ꠇꠄꠛꠞ ꠈꠥꠖꠤꠍꠟꠣ, ꠅꠃ ꠇꠄꠛꠞꠞ ꠝꠣꠎꠦ ꠁꠍꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ। ꠛꠣꠖꠦ ꠛꠠ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞ ꠑꠦꠟꠤꠀ ꠀꠘꠤꠀ ꠇꠄꠛꠞꠞ ꠝꠥꠈꠅ ꠖꠤꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT27_61","070_27_61","MAT","27","61","61","ꠅꠁꠟꠦ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ ꠀꠞ ꠀꠞꠇ ꠝꠞꠤꠅꠝ ꠅꠃ ꠇꠄꠛꠞꠞ ꠗꠣꠞꠅ ꠛꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT27_62","070_27_62","MAT","27","62","62","ꠛꠣꠖꠞ ꠖꠤꠘ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟ ꠀꠁꠀ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MT27_63","070_27_63","MAT","27","63","63","“ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞ ꠝꠘꠅ ꠀꠍꠦ, ꠅꠃ ꠐꠉꠦ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠔꠦ ꠇꠁꠍꠤꠟ, ꠢꠦ ꠛꠥꠟꠦ ꠝꠞꠣꠞ ꠔꠤꠘ ꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛ। ");
INSERT INTO syls_vpl VALUES ("MT27_64","070_27_64","MAT","27","64","64","ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠇꠄꠛꠞꠐꠣ ꠎꠣꠘꠥ ꠔꠤꠘ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠠꠣ ꠙꠣꠞꠣ ꠖꠤꠀ ꠞꠣꠈꠣ ꠅꠄ। ꠀꠞꠘꠣꠄ ꠔꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠔꠣꠞ ꠟꠣꠡ ꠌꠥꠞꠤ ꠇꠞꠤ ꠘꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠔ ꠙꠣꠞꠦ, ꠔꠣꠁꠘ ꠔ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠉꠦꠍꠂꠘ। ꠔꠣꠁꠟꠦ ꠀꠉꠦ ꠎꠦꠔꠣ ꠇꠁꠀ ꠗꠥꠇꠣ ꠖꠤꠍꠦ, ꠅꠈꠘ ꠀꠞꠅ ꠛꠦꠡꠤ ꠗꠥꠇꠣ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT27_65","070_27_65","MAT","27","65","65","ꠙꠤꠟꠣꠔꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠙꠣꠞꠣꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠘꠦꠅ, ꠘꠤꠀ ꠎꠦꠟꠣ ꠙꠣꠞ, ꠅꠟꠣ ꠙꠣꠞꠣ ꠖꠦꠅꠀꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("MT27_66","070_27_66","MAT","27","66","66","ꠅꠃ ꠔꠣꠞꠣ ꠉꠤꠀ ꠇꠄꠛꠞꠞ ꠝꠥꠈꠅ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞ ꠀꠍꠤꠟ, ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠤ ꠕꠁꠟꠣ ꠀꠞ ꠇꠠꠣꠇꠠꠤ ꠙꠣꠞꠣ ꠖꠦꠅꠀꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_1","070_28_1","MAT","28","1","1","ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠡꠦꠡ ꠅꠁꠀ ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠚꠎꠞ ꠅꠇ꠆ꠔꠅ, ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠝꠞꠤꠅꠝꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠇꠄꠛꠞ ꠖꠦꠈꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_2","070_28_2","MAT","28","2","2","ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠛꠠ ꠄꠇ ꠜꠂꠍꠣꠟ ꠅꠁꠟ ꠀꠞ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠔꠣꠁꠘ ꠇꠄꠛꠞꠞ ꠝꠥꠈꠞ ꠙꠣꠔ꠆ꠔꠞꠐꠣ ꠢꠞꠣꠁꠀ, ꠄꠞ ꠃꠙꠞꠦ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_3","070_28_3","MAT","28","3","3","ꠔꠣꠘ ꠍꠥꠞꠔ ꠀꠍꠤꠟ ꠈꠥꠛ ꠘꠥꠞꠣꠘꠤ ꠀꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠀꠍꠤꠟ ꠗꠟꠣ ꠌꠇꠌꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_4","070_28_4","MAT","28","4","4","ꠔꠣꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠙꠣꠞꠣꠖꠣꠞ ꠅꠇꠟꠦ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠣ ꠗꠞꠟꠣ ꠀꠞ ꠔꠣꠞꠣ ꠛꠦꠃꠡ ꠅꠁꠀ ꠙꠠꠤ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_5","070_28_5","MAT","28","5","5","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠅꠃ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ ꠉ। ꠀꠝꠤ ꠎꠣꠘꠤ, ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠦ, ꠔꠥꠝꠞꠣ ꠢꠃ ꠁꠍꠣꠞꠦꠃ ꠔꠥꠇꠣꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MT28_6","070_28_6","MAT","28","6","6","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠔ ꠁꠘꠅ ꠘꠣꠄ। ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣ, ꠅꠟꠣꠃ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠤ ꠉꠦꠍꠂꠘ। ꠀꠅ, ꠔꠣꠘꠞꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠢꠥꠔꠣꠁꠀ ꠞꠣꠈꠣ ꠅꠁꠍꠤꠟ, ꠅꠈꠣꠘ ꠀꠁꠀ ꠖꠦꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("MT28_7","070_28_7","MAT","28","7","7","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠟꠖꠤ ꠎꠣꠅ, ꠉꠤꠀ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠅ, ꠔꠣꠁꠘ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠔꠣꠞꠣꠞ ꠀꠉꠦ ꠅꠁꠀ ꠉꠣꠟꠤꠟꠅ ꠎꠣꠁꠞꠣꠉꠤ। ꠢꠘꠅꠃ ꠔꠣꠘ ꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠖꠦꠈꠣ ꠅꠁꠛ। ꠢꠥꠘꠅ, ꠀꠝꠤ ꠀꠉꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠈꠣꠘ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("MT28_8","070_28_8","MAT","28","8","8","ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠎꠥꠖꠤꠅ ꠒꠞꠣꠁꠍꠟꠣ, ꠔꠦꠛꠃ ꠔꠣꠞꠣ ꠈꠥꠡꠤꠞ ꠌꠥꠐꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠁ ꠈꠛꠞ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠃꠠꠣꠁꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_9","070_28_9","MAT","28","9","9","ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠁꠀ ꠄꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠟꠣ। ꠟꠉꠦ ꠟꠉꠦ ꠔꠣꠞꠣ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠙꠣꠅꠔ ꠗꠞꠤꠀ ꠇꠖꠝꠛꠥꠍꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_10","070_28_10","MAT","28","10","10","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ ꠉ। ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠀꠝꠣꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠉꠣꠟꠤꠟꠅ ꠎꠣꠁꠔꠣꠉꠤ। ꠢꠘꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠖꠦꠈꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MT28_11","070_28_11","MAT","28","11","11","ꠁꠍꠣꠞ ꠟꠉꠞ ꠛꠣꠔꠌꠤꠔ ꠡꠦꠡ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠣꠁꠞꠣꠉꠤ, ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠙꠣꠞꠣꠖꠣꠞꠞ ꠇꠄꠎꠘꠦ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠞꠦ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_12","070_28_12","MAT","28","12","12","ꠔꠦꠃ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠀ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ, ꠅꠃ ꠙꠣꠞꠣꠖꠣꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠛꠃꠔ ꠐꠦꠇꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MT28_13","070_28_13","MAT","28","13","13","ꠔꠣꠞꠣ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠁꠅ, ‘ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠊꠥꠝꠅ ꠀꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠀꠁꠀ ꠔꠣꠘ ꠟꠣꠡ ꠌꠥꠞꠤ ꠇꠞꠤ ꠘꠤꠍꠂꠘꠉꠤ।’ ");
INSERT INTO syls_vpl VALUES ("MT28_14","070_28_14","MAT","28","14","14","ꠁꠈꠣꠘ ꠎꠥꠖꠤ ꠖꠦꠡꠞ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ ꠍꠣꠛꠦ ꠢꠥꠘꠤꠟꠣꠁꠘ, ꠔꠦ ꠀꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠛꠥꠎ ꠖꠤꠝꠥ, ꠔꠣꠘ ꠀꠔ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MT28_15","070_28_15","MAT","28","15","15","ꠔꠦꠃ ꠙꠣꠞꠣꠖꠣꠞ ꠅꠇꠟꠦ ꠅꠃ ꠐꠦꠇꠣ ꠘꠤꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠢꠤꠇꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠅꠟꠣ ꠇꠁꠟꠣ। ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁ ꠝꠤꠍꠣ ꠇꠕꠣ ꠁꠢꠥꠖꠤ ꠡꠝꠣꠎꠅ ꠞꠐꠣꠁꠟ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT28_16","070_28_16","MAT","28","16","16","ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠉꠣꠟꠤꠟꠞ ꠎꠦ ꠙꠣꠠꠅ ꠎꠣꠅꠀꠞ ꠇꠕꠣ ꠇꠁꠍꠟꠣ, ꠢꠃ ꠄꠉꠣꠞꠅ ꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠃ ꠙꠣꠠꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MT28_17","070_28_17","MAT","28","17","17","ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ, ꠄꠞꠝꠣꠎꠦ ꠇꠄꠎꠘꠞ ꠜꠤꠔꠞꠦ ꠡꠘ꠆ꠖꠄ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MT28_18","070_28_18","MAT","28","18","18","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣ ꠔꠣꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔ ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠢꠇ꠆ꠇꠟ ꠈꠦꠝꠔꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MT28_19","070_28_19","MAT","28","19","19","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠛꠣꠘꠣꠅ। ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠛꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ, ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠘꠣꠝꠦ ꠝꠣꠘꠡꠞꠦ ꠔꠞꠤꠇꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("MT28_20","070_28_20","MAT","28","20","20","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ, ꠅꠔꠣ ꠀꠝꠟ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠇꠤꠀꠝꠔꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠡꠛ ꠡꠝꠄ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠤ।” ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("MK1_1","071_1_1","MRK","1","1","1","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠁꠘ꠆ꠎꠤꠟ, ꠝꠣꠘꠤ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠛꠄꠀꠘꠤꠞ ꠡꠥꠞꠥ। ");
INSERT INTO syls_vpl VALUES ("MK1_2","071_1_2","MRK","1","2","2","ꠛꠃꠔ ꠖꠤꠘ ꠀꠉꠦ, ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠇꠤꠔꠣꠛꠅ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠀꠉꠦ ꠀꠝꠣꠞ ꠙꠦꠉꠣꠝ꠆ꠛꠞꠞꠦ ꠛꠦꠎꠤꠀꠞ, ꠄꠁꠘ ꠔꠥꠝꠣꠞ ꠙꠕ ꠍꠢꠤ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_3","071_1_3","MRK","1","3","3","ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠄꠇꠎꠘꠦ ꠄꠟꠣꠘ ꠇꠞꠞꠣ, ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇꠞ ꠙꠕ ꠍꠢꠤ ꠇꠞꠅ, ꠔꠣꠘ ꠌꠟꠣꠞ ꠞꠣꠡ꠆ꠔꠣ ꠅꠇꠟ ꠡꠤꠗꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("MK1_4","071_1_4","MRK","1","4","4","ꠅꠃ ꠀꠄꠀꠔ ꠝꠣꠚꠤꠇ ꠢꠎꠞꠔ ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣ ꠀꠞ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠔꠣ। ꠔꠣꠁꠘ ꠄꠟꠣꠘ ꠇꠞꠔꠣ, ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠔꠃꠛꠣ ꠇꠞꠅ, ꠔꠞꠤꠇꠣꠛꠘ꠆ꠖꠤ ꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("MK1_5","071_1_5","MRK","1","5","5","ꠔꠦꠃ ꠀꠡ꠆ꠔꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣ ꠀꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠛꠣꠞ ꠅꠁꠀ ꠄꠢꠤꠀꠞ ꠉꠦꠍꠦ ꠀꠁꠀ, ꠎꠣꠞꠎꠤꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠃꠛꠣ ꠇꠞꠟꠣ, ꠀꠞ ꠄꠢꠤꠀꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠙꠣꠘꠤꠔ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_6","071_1_6","MRK","1","6","6","ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠃꠐꠞ ꠞꠥꠝꠞ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠔꠣ ꠀꠞ ꠇꠝꠞꠅ ꠌꠣꠝꠠꠣꠞ ꠛꠦꠟꠐ ꠛꠣꠘ꠆ꠖꠤꠔꠣ। ꠔꠣꠁꠘ ꠙꠣꠠꠤꠀ ꠝꠃ ꠀꠞ ꠚꠞꠤꠋ ꠈꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_7","071_1_7","MRK","1","7","7","ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠔꠣ, “ꠀꠝꠣꠞ ꠛꠣꠖꠦ ꠀꠞꠅ ꠄꠇꠎꠘꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠄꠁꠘ ꠀꠝꠣ ꠕꠘꠦꠅ ꠢꠤꠝ꠆ꠝꠔ ꠀꠟꠣ। ꠃꠘ꠆ꠖꠣ ꠅꠁꠀ ꠔꠣꠘ ꠙꠣꠅꠞ ꠎꠥꠔꠣꠞ ꠚꠤꠔꠣ ꠈꠥꠟꠣꠞ ꠟꠣꠈꠅ ꠀꠝꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK1_8","071_1_8","MRK","1","8","8","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠘꠤꠖꠤ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠟꠣꠝ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠀ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK1_9","071_1_9","MRK","1","9","9","ꠅꠃ ꠡꠝꠄ ꠢꠎꠞꠔ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃ ꠕꠘꠦ ꠄꠢꠤꠀꠞ ꠉꠦꠍꠦ ꠀꠁꠀ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠅ ꠔꠞꠤꠇꠣꠛꠘ꠆ꠖꠤ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_10","071_1_10","MRK","1","10","10","ꠀꠞ ꠙꠣꠘꠤꠔ ꠛꠥꠠ ꠖꠤꠀ ꠃꠑꠔꠦꠃ ꠁꠍꠣꠄ ꠟꠉꠦ ꠟꠉꠦ ꠖꠦꠈꠟꠣ ꠀꠍꠝꠣꠘ ꠖꠥꠁ ꠜꠣꠉ ꠅꠁꠉꠦꠍꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥ ꠙꠣꠞꠅꠞ ꠍꠥꠞꠔ ꠗꠞꠤꠀ ꠔꠣꠘ ꠃꠙꠞꠦ ꠟꠣꠝꠤꠀ ꠀꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_11","071_1_11","MRK","1","11","11","ꠅꠃ ꠡꠝꠄ ꠀꠍꠝꠣꠘ ꠕꠘꠦ ꠀꠅꠀꠎ ꠅꠁꠟ, “ꠅ ꠙꠥꠔ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK1_12","071_1_12","MRK","1","12","12","ꠄꠞꠛꠣꠖꠦꠃ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠔꠣꠉꠤꠖꠦ ꠔꠣꠘꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠛꠦꠎꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK1_13","071_1_13","MRK","1","13","13","ꠅꠃ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠡꠄꠔꠣꠘꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠗꠞꠤ ꠁꠍꠣꠞꠦ ꠟꠣꠟꠌ ꠖꠦꠈꠣꠁꠀ ꠉꠥꠘꠣ ꠇꠞꠣꠁꠔ ꠌꠣꠁꠟ। ꠢꠤꠘꠅ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠞ ꠟꠉꠦ ꠔꠣꠁꠘ ꠞꠁꠟꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘ ꠈꠦꠎꠝꠔ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_14","071_1_14","MRK","1","14","14","ꠢꠎꠞꠔ ꠄꠢꠤꠀ ꠎꠦꠟꠈꠣꠘꠣꠔ ꠛꠘ꠆ꠖꠤ ꠅꠀꠞ ꠛꠣꠖꠦ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠀꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK1_15","071_1_15","MRK","1","15","15","“ꠡꠝꠄ ꠙꠥꠞꠣ ꠅꠁꠉꠦꠍꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠘꠎꠖꠤꠇ ꠀꠁꠌ꠆ꠍꠦ। ꠀꠙꠘꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠃꠇ꠆ꠇꠣ ꠀꠞ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK1_16","071_1_16","MRK","1","16","16","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠙꠣꠞꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠖꠦꠈꠟꠣ, ꠍꠣꠁꠝꠘ ꠀꠞ ꠔꠣꠘ ꠜꠣꠁ ꠀꠘ꠆ꠖꠞꠤꠀꠍꠦ ꠀꠅꠞꠅ ꠎꠣꠟ ꠛꠣꠁꠞꠣ। ꠄꠞꠣ ꠔ ꠝꠣꠁꠝꠟ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_17","071_1_17","MRK","1","17","17","ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠘꠥꠡ ꠗꠞꠣꠞ ꠎꠣꠟꠥꠀ ꠛꠣꠘꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK1_18","071_1_18","MRK","1","18","18","ꠟꠉꠦ ꠟꠉꠦ ꠄꠞꠣ ꠎꠣꠟꠞ ꠟꠉ ꠍꠣꠠꠤꠀ ꠁꠍꠣꠞ ꠟꠉꠦ ꠟꠉ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_19","071_1_19","MRK","1","19","19","ꠅꠘ ꠕꠘꠦ ꠕꠥꠠꠣ ꠀꠉꠦ ꠉꠤꠀ ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ ꠖꠥꠁꠅ ꠜꠣꠁꠄ ꠘꠣꠅꠅ ꠛꠁꠀ ꠎꠣꠟ ꠎꠥꠁꠔ-ꠎꠣꠁꠔ ꠇꠞꠞꠣ, ꠄꠞꠣꠞ ꠛꠣꠚꠞ ꠘꠣꠝ ꠎꠤꠛꠥꠖꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("MK1_20","071_1_20","MRK","1","20","20","ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠒꠣꠇ ꠖꠤꠟꠣ, ꠒꠣꠇ ꠢꠥꠘꠤꠀ ꠄꠞꠣꠅ ꠘꠤꠎꠞ ꠛꠣꠚ ꠎꠤꠛꠥꠖꠤꠀꠞꠦ ꠇꠣꠝꠟꠣꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠘꠣꠅꠅ ꠕꠁꠀ ꠁꠍꠣꠞ ꠟꠉ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_21","071_1_21","MRK","1","21","21","ꠛꠣꠖꠦ ꠄꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ, ꠀꠞ ꠁꠢꠥꠖꠤꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠝꠍꠤꠖꠅ ꠢꠣꠝꠣꠁꠀ ꠁꠍꠣꠄ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠞꠦꠅꠀꠎ ꠝꠣꠚꠤꠇ ꠁꠢꠥꠖꠤꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠅꠁꠟ ꠡꠥꠇ꠆ꠞꠛꠣꠞ ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣ ꠕꠣꠇꠤ ꠡꠘꠤꠛꠣꠞꠞ ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ। ꠁ ꠖꠤꠘ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ ꠇꠞꠣ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("MK1_22","071_1_22","MRK","1","22","22","ꠔꠣꠘ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ, ꠔꠣꠁꠘ ꠔ ꠔꠣꠞꠣꠞ ꠀꠟꠤꠝ-ꠃꠟꠣꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠄꠀꠘ ꠇꠞꠞꠣ ꠘꠣ, ꠔꠣꠁꠘ ꠈꠦꠝꠔꠣꠀꠟꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_23","071_1_23","MRK","1","23","23","ꠅꠃ ꠡꠝꠄ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠟꠣ ꠄꠇ ꠛꠦꠐꠣꠅ ꠅꠃ ꠝꠍꠤꠖꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK1_24","071_1_24","MRK","1","24","24","ꠢꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠅ ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣ, ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠙꠘꠣꠞ ꠇꠥꠘꠥ ꠎꠣꠄ-ꠎꠞꠥꠞ ꠀꠍꠦ ꠘꠤ? ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠀꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠔ ꠀꠁꠍꠂꠘ ꠘꠤ? ꠀꠝꠤ ꠔ ꠀꠙꠘꠣꠞꠦ ꠌꠤꠘꠤ, ꠀꠙꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠢꠃ ꠙꠣꠇ ꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK1_25","071_1_25","MRK","1","25","25","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠟꠣ, “ꠌꠥꠙ, ꠅꠈꠘꠃ ꠄꠞꠦ ꠍꠣꠠꠤꠀ ꠎꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK1_26","071_1_26","MRK","1","26","26","ꠅꠃ ꠢꠤ ꠎꠤꠘꠦ ꠛꠦꠐꠣꠞꠦ ꠝꠥꠞꠣꠘꠤ ꠝꠣꠞꠤꠀ ꠎꠥꠞꠦ ꠌꠤꠇ ꠖꠤꠀ ꠍꠣꠠꠤꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK1_27","071_1_27","MRK","1","27","27","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟ, “ꠖꠦꠈꠞꠣꠄ ꠘꠤ! ꠀꠌꠣꠘꠇ ꠇꠣꠞꠛꠣꠞ! ꠁꠔꠣ ꠇꠥꠘ ꠎꠣꠔꠞ ꠘꠄꠀ ꠔꠣꠟꠤꠝ? ꠔꠣꠘ ꠈꠦꠝꠔꠣ ꠈꠣꠐꠣꠁꠀ ꠎꠤꠘ꠆ꠘꠣꠔꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠁꠘ, ꠀꠞ ꠔꠣꠞꠣꠅ ꠝꠣꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK1_28","071_1_28","MRK","1","28","28","ꠄꠞꠖꠣꠄ ꠁꠍꠣꠞ ꠘꠣꠝ ꠀꠡ꠆ꠔꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠈꠥꠛ ꠎꠟꠖꠤ ꠃꠠꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK1_29","071_1_29","MRK","1","29","29","ꠝꠍꠤꠖ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠔꠣꠁꠘ-ꠔꠣꠁꠘ ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞ ꠟꠉꠦ ꠅꠁꠀ ꠍꠣꠁꠝꠘ ꠀꠞ ꠀꠘ꠆ꠖꠞꠤꠀꠍꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_30","071_1_30","MRK","1","30","30","ꠍꠣꠁꠝꠘꠞ ꠢꠠꠤꠞ ꠈꠥꠛ ꠔꠣꠙ ꠅꠁꠍꠤꠟ, ꠔꠣꠁꠘ ꠛꠤꠍꠘꠣꠔ ꠙꠠꠘꠅ ꠀꠍꠟꠣ। ꠁꠍꠣꠄ ꠔꠡꠞꠤꠚ ꠀꠘꠔꠦꠃ ꠔꠣꠘꠞꠦ ꠛꠦꠝꠣꠞꠤꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK1_31","071_1_31","MRK","1","31","31","ꠛꠦꠝꠣꠞ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠘ ꠅꠃ ꠛꠦꠐꠤꠞ ꠀꠔꠅ ꠗꠞꠤ ꠔꠥꠟꠟꠣ, ꠀꠞ ꠟꠉꠦ ꠟꠉꠦ ꠔꠣꠙꠦ ꠍꠣꠠꠤ ꠖꠤꠟ, ꠛꠦꠐꠤ ꠃꠑꠤꠀ ꠉꠤꠀ ꠄꠞꠣꠞ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_32","071_1_32","MRK","1","32","32","ꠅꠃ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠡꠦꠡꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ, ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣꠞ ꠛꠣꠖꠦ ꠝꠣꠘꠡꠦ ꠢꠇꠟ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠀꠞ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK1_33","071_1_33","MRK","1","33","33","ꠀꠡ꠆ꠔꠣ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠅꠃ ꠛꠣꠠꠤꠞ ꠃꠑꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK1_34","071_1_34","MRK","1","34","34","ꠔꠦꠃ ꠁꠍꠣꠄ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠛꠃꠔ ꠛꠦꠝꠣꠞꠤꠞ ꠡꠤꠚꠣ ꠇꠞꠟꠣ ꠀꠞ ꠛꠃꠔꠞ ꠟꠉ ꠕꠘꠦ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁꠟꠣ। ꠅꠁꠟꠦ ꠎꠤꠘ꠆ꠘꠣꠔꠦ ꠔꠣꠘ ꠙꠞꠤꠌꠄ ꠎꠣꠘꠣꠁ ꠖꠤꠛꠣ ꠇꠞꠤ, ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠇꠥꠘꠥ ꠝꠣꠔ ꠝꠣꠔꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_35","071_1_35","MRK","1","35","35","ꠛꠣꠖꠦ ꠙꠔꠣꠛꠣꠟꠣ ꠃꠑꠤꠀ ꠔꠣꠁꠘ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠖꠥꠀ ꠇꠞꠣꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_36","071_1_36","MRK","1","36","36","ꠔꠦꠃ ꠍꠣꠁꠝꠘ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠣꠔ ꠛꠣꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_37","071_1_37","MRK","1","37","37","ꠛꠣꠞ ꠅꠁꠀ ꠔꠣꠘꠞꠦ ꠙꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠦ ꠀꠙꠘꠣꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK1_38","071_1_38","MRK","1","38","38","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠝꠞꠣ ꠅꠃ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠉꠣꠃꠀꠁꠘ꠆ꠔꠅ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠤ। ꠄꠞꠟꠣꠉꠤꠃ ꠔ ꠀꠝꠤ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK1_39","071_1_39","MRK","1","39","39","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠣꠞꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠝꠍꠤꠖꠣꠁꠘ꠆ꠔꠅ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ ꠀꠞ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK1_40","071_1_40","MRK","1","40","40","ꠄꠇꠖꠤꠘ ꠄꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤꠄ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠔꠣꠘ ꠙꠣꠅꠔ ꠙꠠꠤꠀ ꠝꠤꠘꠔ ꠇꠞꠤꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠝꠞ꠆ꠎꠤ ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠤꠀ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK1_41","071_1_41","MRK","1","41","41","ꠛꠦꠐꠣꠞ ꠛꠣꠄ ꠔꠣꠘ ꠈꠥꠛ ꠖꠄꠀ ꠢꠣꠝꠣꠁꠟ। ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠔꠣꠞꠦ ꠍꠁꠀ ꠇꠁꠟꠣ, “ꠅꠄ ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK1_42","071_1_42","MRK","1","42","42","ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦ ꠔꠣꠞ ꠛꠦꠝꠣꠞ ꠜꠣꠟꠣ ꠅꠁꠀ ꠢꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK1_43","071_1_43","MRK","1","43","43","ꠁꠍꠣꠄ ꠅꠃ ꠡꠝꠄꠃ ꠔꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣ ꠀꠞ ꠖꠠꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK1_44","071_1_44","MRK","1","44","44","“ꠢꠥꠘꠅ, ꠁꠔꠣ ꠈꠛꠞ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ। ꠈꠣꠟꠤ ꠁꠝꠣꠝ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠖꠦꠈꠣꠅ ꠀꠞ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠇꠤꠔꠣꠛꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ, ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠅ। ꠔꠦꠃ ꠡꠝꠣꠎꠦꠅ ꠎꠣꠘꠤꠟꠤꠛ, ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍ।” ");
INSERT INTO syls_vpl VALUES ("MK1_45","071_1_45","MRK","1","45","45","ꠅꠁꠟꠦ ꠢꠦ ꠛꠣꠞꠦ ꠉꠤꠀꠃ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟ ꠛꠣꠄ ꠞꠐꠣꠁ ꠖꠤꠟ। ꠄꠞꠖꠣꠄ ꠁꠍꠣ ꠀꠞ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠇꠥꠘꠥ ꠉꠣꠃꠔ ꠎꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠛꠣꠞꠣ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠞꠅꠀ ꠟꠣꠉꠟ, ꠅꠘꠅ-ꠅ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠘꠦ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK2_1","071_2_1","MRK","2","1","1","ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠢꠥꠘꠤꠟꠤꠟꠣ ꠔꠣꠁꠘ ꠊꠞꠅ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK2_2","071_2_2","MRK","2","2","2","ꠔꠦꠃ ꠅꠔ ꠝꠣꠘꠥꠡ ꠁꠘꠅ ꠎꠝꠣ ꠅꠁꠟꠣ, ꠊꠞꠅ ꠔ ꠖꠥꠞꠞ ꠇꠕꠣ, ꠊꠞꠞ ꠛꠣꠞꠦꠅ ꠀꠞ ꠎꠣꠉꠣ ꠞꠁꠟ ꠘꠣ। ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK2_3","071_2_3","MRK","2","3","3","ꠅꠃ ꠡꠝꠄ ꠌꠣꠁꠞ ꠎꠘ ꠝꠣꠘꠡꠦ ꠄꠇꠎꠘ ꠅꠞ꠆ꠖꠋ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠛꠁꠀ ꠟꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟ, ꠄꠞꠣꠞ ꠟꠉꠦ ꠀꠞꠅ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK2_4","071_2_4","MRK","2","4","4","ꠅꠁꠟꠦ ꠜꠤꠠꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠎꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠔꠣꠁꠘ ꠎꠦ ꠎꠣꠉꠣꠔ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠑꠤꠇ ꠔꠣꠞ ꠃꠙꠞꠞ ꠌꠣꠟ ꠚꠥꠠ ꠇꠞꠤꠀ ꠙꠟꠅ ꠡꠥꠖ꠆ꠖꠣ ꠅꠃ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠟꠣꠝꠣꠔ ꠟꠣꠝꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK2_5","071_2_5","MRK","2","5","5","ꠔꠣꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠟ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠅꠃ ꠅꠞ꠆ꠖꠋ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ, ꠔꠥꠝꠣꠞ ꠔꠣꠝꠣꠝ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠁꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("MK2_6","071_2_6","MRK","2","6","6","ꠅꠁꠟꠦ ꠢꠤꠈꠣꠘꠅ ꠇꠄꠎꠘ ꠝꠃꠟꠣꠘꠣ ꠛꠅꠀꠔ ꠀꠍꠟꠣ। ꠔꠣꠁꠘ-ꠔꠣꠁꠘ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK2_7","071_2_7","MRK","2","7","7","“ꠁ ꠝꠣꠘꠡꠦ ꠁꠟꠣꠈꠣꠘ ꠝꠣꠔꠦꠞ ꠇꠦꠘꠦ? ꠢꠦ ꠔ ꠡꠤꠞꠤꠇꠤ ꠇꠞꠦꠞ। ꠄꠇꠝꠣꠔ꠆ꠞ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠔ ꠙꠣꠞꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK2_8","071_2_8","MRK","2","8","8","ꠔꠣꠘꠞꠦ ꠟꠁꠀ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠎꠦ ꠅꠟꠣꠈꠣꠘ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠣ, ꠁꠍꠣꠄ ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠟꠦ ꠁꠈꠣꠘ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠛꠥꠎꠤꠀ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠇꠦꠘꠦ ꠝꠘꠦ ꠝꠘꠦ ꠁꠟꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠣ? ");
INSERT INTO syls_vpl VALUES ("MK2_9","071_2_9","MRK","2","9","9","ꠁ ꠅꠞ꠆ꠖꠋ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠇꠥꠘꠈꠣꠘ ꠇꠅꠀ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠡꠥꠎꠣ, ꠔꠥꠝꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠟ, ꠘꠣ, ꠃꠑꠅ ꠔꠥꠝꠣꠞ ꠙꠟꠅ ꠟꠁꠀ ꠀꠐꠤꠀ ꠎꠣꠅꠉꠤ? ");
INSERT INTO syls_vpl VALUES ("MK2_10","071_2_10","MRK","2","10","10","ꠔꠦ ꠅꠈꠘ ꠀꠙꠘꠣꠞꠣ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁ ꠖꠥꠘꠤꠀꠔ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠀꠍꠦ,” ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK2_11","071_2_11","MRK","2","11","11","“ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠀꠞ, ꠃꠑꠅ, ꠔꠥꠝꠣꠞ ꠙꠟꠅ ꠟꠁꠀ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK2_12","071_2_12","MRK","2","12","12","ꠔꠦꠃ ꠟꠉꠦ ꠟꠉꠦ ꠅꠃ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣ ꠃꠑꠤꠀ ꠔꠣꠞ ꠙꠟꠅ ꠟꠁꠀ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦꠃ ꠛꠣꠞ ꠅꠁꠀ ꠉꠦꠟ। ꠁꠈꠣꠘ ꠖꠦꠈꠤꠀ ꠢꠇꠟꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠍꠥꠛꠢꠣꠘ ꠀꠟ꠆ꠟꠣ, ꠎꠤꠘ꠆ꠖꠦꠉꠤꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠁꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠖꠦꠈꠍꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK2_13","071_2_13","MRK","2","13","13","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠞ ꠅꠁꠀ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠗꠣꠞꠅ ꠉꠦꠟꠣ, ꠔꠦꠃ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟ, ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK2_14","071_2_14","MRK","2","14","14","ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠙꠕꠦꠖꠤ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠖꠦꠈꠟꠣ, ꠀꠟꠚꠤꠞ ꠙꠥꠀ ꠟꠦꠛꠤ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠣꠞ ꠅꠚꠤꠡꠅ ꠛꠁ ꠞꠁꠍꠂꠘ। ꠖꠦꠈꠤꠀ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠅ।” ꠔꠦꠃ ꠟꠦꠛꠤ ꠃꠑꠤꠀ ꠁꠍꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK2_15","071_2_15","MRK","2","15","15","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠟꠦꠛꠤꠞ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠈꠣꠅꠀꠔ ꠛꠁꠟꠣ। ꠛꠃꠔ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠀꠞ ꠉꠥꠘꠣꠉꠣꠞ ꠝꠣꠘꠥꠡꠅ ꠁꠍꠣ ꠀꠞ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠟꠉꠦ ꠈꠣꠘꠤꠔ ꠀꠍꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠊꠥꠞꠣꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK2_16","071_2_16","MRK","2","16","16","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞ ꠟꠉꠦ ꠛꠁꠀ ꠈꠣꠘꠤ ꠈꠣꠁꠞꠣ ꠖꠦꠈꠤꠀ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠀꠞ ꠈꠛꠤꠍ ꠅꠇꠟꠞ ꠟꠉꠦ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠂꠘ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK2_17","071_2_17","MRK","2","17","17","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠅꠃ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠜꠣꠟꠣ ꠝꠣꠘꠡꠞ ꠇꠛꠤꠞꠣꠎ ꠟꠣꠉꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠛꠦꠝꠣꠞꠤꠞ ꠔ ꠟꠣꠉꠦ। ꠀꠝꠤ ꠙꠞꠦꠎꠉꠣꠞꠞ ꠉꠦꠍꠦ ꠀꠁꠍꠤ ꠘꠣ, ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞꠦꠃ ꠖꠣꠅꠔ ꠖꠤꠔꠣꠝ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK2_18","071_2_18","MRK","2","18","18","ꠄꠇꠛꠣꠞ ꠢꠎꠞꠔ ꠄꠢꠤꠀꠞ ꠃꠝ꠆ꠝꠔ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟ ꠞꠥꠎꠣ ꠀꠍꠟꠣ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠃꠝ꠆ꠝꠔ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠞꠥꠎꠣ ꠞꠣꠈꠂꠘ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠞꠥꠎꠣ ꠞꠣꠈꠂꠘ ꠘꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK2_19","071_2_19","MRK","2","19","19","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠘꠡꠣ ꠟꠉꠦ ꠕꠣꠇꠔꠦ ꠇꠤꠔꠣ ꠛꠂꠞꠣꠔꠤ ꠅꠇꠟꠦ ꠞꠥꠎꠣ ꠞꠣꠈꠔ ꠙꠣꠞꠦ ꠘꠤ? ꠘꠣ, ꠇꠦꠃ ꠞꠥꠎꠣ ꠞꠄ ꠘꠣ, ꠎꠔꠖꠤꠘ ꠘꠡꠣ ꠟꠉꠦ ꠕꠣꠇꠂꠘ, ꠅꠔ ꠖꠤꠘ ꠔꠣꠞꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK2_20","071_2_20","MRK","2","20","20","ꠅꠁꠟꠦ ꠅꠟꠣ ꠅꠇ꠆ꠔ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠘꠡꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠢꠞꠣꠁꠟ ꠅꠁꠎꠤꠛ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK2_21","071_2_21","MRK","2","21","21","ꠙꠥꠞꠣꠘ ꠇꠣꠙꠠꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠘꠄꠀ ꠇꠣꠙꠠ ꠎꠥꠠꠣ ꠖꠦꠄ ꠘꠣ। ꠎꠥꠠꠣ ꠖꠤꠟꠦ ꠅꠃ ꠇꠣꠙꠠ ꠗꠁꠀ ꠢꠣꠞꠟꠦ ꠈꠥꠍ ꠅꠁꠀ ꠍꠤꠠꠤꠀ ꠁ ꠚꠥꠠ ꠀꠞꠅ ꠛꠠ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK2_22","071_2_22","MRK","2","22","22","ꠙꠥꠞꠣꠘ ꠌꠣꠝꠠꠣꠞ ꠕꠟꠤꠔ ꠇꠦꠃ ꠔꠣꠎꠣ ꠀꠋꠉꠥꠞꠞ ꠞꠡ ꠜꠞꠦ ꠘꠣ। ꠜꠞꠟꠦ ꠅꠃ ꠔꠣꠎꠣ ꠞꠡꠞ ꠚꠣꠚꠦ ꠕꠟꠤ ꠚꠣꠐꠤꠀ ꠞꠡ ꠀꠞ ꠕꠟꠤ ꠖꠥꠁꠅꠔꠣ ꠛꠞꠛꠣꠖ ꠅꠄ। ꠔꠣꠎꠣ ꠞꠡ ꠘꠄꠀ ꠕꠟꠤꠔ ꠕꠁꠔꠦ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK2_23","071_2_23","MRK","2","23","23","ꠄꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠈꠦꠔꠞ ꠀꠁꠟꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ। ꠀꠐꠤ ꠀꠐꠤ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠗꠣꠘꠞ ꠍꠠꠣ ꠍꠤꠠꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK2_24","071_2_24","MRK","2","24","24","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠚꠞꠤꠡꠤ ꠖꠟꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠔ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠣꠄ, ꠔꠦ ꠔꠣꠞꠣ ꠁ ꠗꠣꠘꠞ ꠍꠠꠣ ꠍꠤꠠꠤꠞꠣ ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK2_25","071_2_25","MRK","2","25","25","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠖꠣꠃꠖ ꠘꠛꠤ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠦ ꠄꠇꠛꠣꠞ ꠙꠦꠐꠞ ꠜꠥꠇꠦ ꠎꠦꠔꠣ ꠇꠞꠍꠟꠣ, ꠁꠔꠣ ꠇꠤꠔꠣ ꠔꠥꠝꠤꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠡꠝꠄ ꠙꠠꠍ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MK2_26","071_2_26","MRK","2","26","26","ꠔꠣꠁꠘ ꠔ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠀꠛꠤꠀꠕꠞꠞ ꠀꠝꠟꠅ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ, ꠎꠦ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ ꠁꠝꠣꠝ ꠍꠣꠛ ꠛꠣꠖꠦ ꠀꠞ ꠇꠦꠃ ꠈꠣꠅꠀ ꠎꠣꠁꠎ ꠘꠣꠄ, ꠅꠃ ꠞꠥꠐꠤ ꠈꠣꠁꠍꠟꠣ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠖꠤꠍꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK2_27","071_2_27","MRK","2","27","27","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠔ ꠝꠣꠘꠡꠞꠦ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤꠃ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK2_28","071_2_28","MRK","2","28","28","ꠢꠥꠘꠅ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠔꠣꠝꠣꠝ ꠄꠈꠔꠤꠀꠞ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠀꠔꠅ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK3_1","071_3_1","MRK","3","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟꠣ, ꠢꠘꠅ ꠅꠟꠣ ꠄꠇ ꠛꠦꠐꠣ ꠀꠍꠤꠟ, ꠔꠣꠞ ꠄꠇ ꠀꠔ ꠛꠦꠝꠣꠞꠦ ꠢꠥꠇꠣꠁ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK3_2","071_3_2","MRK","3","2","2","ꠔꠣꠁꠘ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠂꠘ ꠇꠤ ꠘꠣ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠇꠄꠎꠘ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠛꠣꠄ ꠈꠥꠛ ꠈꠤꠀꠟ ꠞꠣꠈꠟꠣ, ꠔꠣꠞꠣ ꠌꠣꠁꠟꠣ ꠔꠣꠘ ꠇꠥꠘꠥ ꠈꠥꠔ ꠛꠣꠞ ꠇꠞꠤꠀ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_3","071_3_3","MRK","3","3","3","ꠁꠍꠣꠄ ꠅꠃ ꠢꠥꠇꠘꠣ ꠀꠔꠀꠟꠣ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠃꠛꠣꠅ ꠌꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK3_4","071_3_4","MRK","3","4","4","ꠛꠦꠐꠣ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠍꠣꠛ ꠅꠇꠟ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠘꠦꠇ ꠇꠣꠝ, ꠘꠣ ꠛꠖ ꠇꠣꠝ? ꠎꠣꠘꠞ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠣ, ꠘꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠣ?” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠝꠥꠈ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠛꠁꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_5","071_3_5","MRK","3","5","5","ꠔꠣꠞꠣꠞ ꠝꠘꠞ ꠁ ꠙꠣꠡꠣꠘ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ, ꠁꠍꠣꠞ ꠖꠤꠟꠅ ꠈꠥꠛ ꠖꠥꠈ ꠢꠣꠝꠣꠁꠟ। ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠉꠥꠍꠣ ꠇꠞꠤ ꠢꠃ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠔꠈꠣꠘ ꠛꠣꠠꠣꠅ।” ꠢꠦ ꠔꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠁꠔꠦꠃ ꠀꠉꠞ ꠟꠣꠈꠣꠘ ꠙꠥꠞꠣ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK3_6","071_3_6","MRK","3","6","6","ꠁꠈꠣꠘ ꠖꠦꠈꠤꠀꠃ ꠚꠞꠤꠡꠤ ꠅꠇꠟ ꠟꠉꠦ ꠟꠉꠦ ꠛꠣꠞ ꠅꠁꠉꠦꠟꠣ, ꠉꠤꠀ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠁꠍꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_7","071_3_7","MRK","3","7","8","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠀꠅꠞꠞ ꠙꠣꠞꠅ ꠉꠦꠟꠣꠉꠤ, ꠢꠘꠅ-ꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟꠣ। ꠔꠣꠘ ꠘꠣꠘꠣꠘ ꠝꠥꠎꠦꠎꠣ ꠀꠞ ꠇꠦꠞꠣꠝꠔꠤꠞ ꠈꠛꠞ ꠙꠣꠁꠀ, ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣ, ꠉꠣꠟꠤꠟ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝ, ꠁꠖꠥꠝ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞ, ꠡꠥꠞ ꠀꠞ ꠍꠤꠖꠘ ꠄꠟꠣꠇꠣ ꠕꠣꠇꠤ ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠀꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_9","071_3_9","MRK","3","9","9","ꠝꠣꠘꠡꠞ ꠜꠤꠠ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘ ꠘꠣꠅ ꠎꠥꠁꠔ ꠇꠞꠅ, ꠀꠞꠘꠣꠄ ꠝꠣꠘꠡꠦ ꠑꠦꠟꠣ-ꠗꠣꠇ꠆ꠇꠣ ꠈꠣꠁꠀ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠁꠀ ꠙꠠꠤꠎꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK3_10","071_3_10","MRK","3","10","10","ꠔꠣꠁꠘ ꠛꠃꠔ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠣꠄ ꠛꠦꠝꠣꠞꠤ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠦ ꠍꠁꠔꠣ ꠇꠞꠤ ꠑꠦꠟꠤꠀ ꠗꠣꠇ꠆ꠇꠣꠁꠀ ꠀꠁꠀ ꠔꠣꠘ ꠃꠙꠞꠦ ꠙꠠꠤꠎꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_11","071_3_11","MRK","3","11","11","ꠀꠞ ꠎꠤꠘ-ꠜꠥꠔ ꠅꠇꠟꠦ ꠔꠣꠘꠦ ꠖꠦꠈꠟꠦꠃ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠔ, “ꠀꠙꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK3_12","071_3_12","MRK","3","12","12","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠈꠥꠛ ꠇꠠꠣꠇꠠꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠔꠣ, “ꠈꠛꠞꠖꠣꠞ! ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠙꠞꠤꠌꠄ ꠎꠣꠁꠞ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK3_13","071_3_13","MRK","3","13","13","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠉꠦꠟꠣꠉꠤ, ꠉꠤꠀ ꠔꠣꠘ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠇꠤꠍꠥ ꠡꠣꠉꠞꠤꠖꠞꠦ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠒꠣꠇꠣꠁꠀ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_14","071_3_14","MRK","3","14","15","ꠄꠞꠣ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠘꠦ ꠛꠣꠞꠅꠎꠘꠞꠦ ꠔꠣꠁꠘ ꠀꠟꠉ ꠇꠞꠟꠣ, ꠄꠞꠣ ꠎꠣꠘꠥ ꠔꠣꠘ ꠟꠉꠦ ꠟꠉꠦ ꠞꠂꠘ, ꠀꠞ ꠎꠤꠘ-ꠜꠥꠔ ꠍꠣꠠꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠖꠤꠀ ꠄꠞꠣꠞꠦ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠅ ꠛꠦꠎꠤꠔꠣ ꠙꠣꠞꠂꠘ। ꠅꠃ ꠛꠣꠞꠅꠎꠘ ꠅꠁꠟꠣ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("MK3_16","071_3_16","MRK","3","16","16","ꠔꠣꠁꠘ ꠍꠣꠁꠝꠘꠞ ꠘꠄꠀ ꠘꠣꠝ ꠞꠣꠈꠟꠣ ꠙꠤꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("MK3_17","071_3_17","MRK","3","17","17","ꠎꠤꠛꠥꠖꠤꠀꠞ ꠖꠥꠁ ꠙꠥꠀ ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ, ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠘꠄꠀ ꠘꠣꠝ ꠖꠤꠟꠣ ꠛꠥꠘꠦꠞꠉꠡ, ꠝꠣꠘꠤ ꠝꠦꠊꠞ ꠒꠣꠇꠞ ꠙꠥꠀ। ");
INSERT INTO syls_vpl VALUES ("MK3_18","071_3_18","MRK","3","18","18","ꠀꠘ꠆ꠖꠞꠤꠀꠍ, ꠚꠤꠟꠤꠚ, ꠛꠞ꠆ꠕꠟꠝꠄ, ꠝꠕꠤ, ꠕꠥꠝꠣꠍ, ꠀꠟꠚꠤꠞ ꠙꠥꠀ ꠁꠀꠇꠥꠛ, ꠕꠖ꠆ꠖꠦ, ꠝꠥꠇ꠆ꠔꠤꠎꠥꠖ꠆ꠖꠣ ꠍꠣꠁꠝꠘ, ");
INSERT INTO syls_vpl VALUES ("MK3_19","071_3_19","MRK","3","19","19","ꠀꠞ ꠁꠢꠥꠖꠣ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔ, ꠅꠃ ꠁꠢꠥꠖꠣꠄ ꠛꠣꠖꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠁꠍꠣꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁꠀ ꠖꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK3_20","071_3_20","MRK","3","20","20","ꠢꠎꠞꠔ ꠁꠍꠣ ꠄꠇ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ। ꠅꠘꠅ ꠀꠁꠀꠅ ꠅꠔ ꠛꠦꠡꠤ ꠝꠣꠘꠡꠦ ꠜꠤꠠ ꠛꠣꠘ꠆ꠖꠤꠟꠣ, ꠜꠤꠠꠞ ꠟꠣꠉꠤ ꠁꠍꠣꠄ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦꠅ ꠈꠣꠘꠣ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_21","071_3_21","MRK","3","21","21","ꠔꠣꠘ ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞꠦ ꠁ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠔꠣꠘꠞꠦ ꠅꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠘꠦꠅꠀꠔ ꠀꠁꠟꠣ, ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠔꠣꠞ ꠔ ꠝꠣꠕꠣ ꠈꠣꠞꠣꠙ ꠅꠁꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK3_22","071_3_22","MRK","3","22","22","ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠇꠄꠎꠘ ꠝꠃꠟꠣꠘꠣ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤꠘꠞ ꠛꠣꠖꠡꠣ ꠛꠦꠟ-ꠍꠛꠥꠟꠦ ꠔꠣꠞꠦ ꠀꠍꠞ ꠇꠞꠍꠦ। ꠅꠃ ꠛꠦꠟ-ꠍꠛꠥꠟꠞ ꠛꠟꠦ ꠢꠦ ꠎꠤꠘ-ꠜꠥꠔ ꠍꠣꠠꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK3_23","071_3_23","MRK","3","23","23","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠅꠃ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞꠦ ꠗꠣꠞꠅ ꠀꠘꠣꠁꠀ ꠇꠤꠌ꠆ꠍꠣ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠡꠄꠔꠣꠘꠦ ꠇꠤꠟꠣ ꠡꠄꠔꠣꠘꠞꠦ ꠈꠦꠖꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("MK3_24","071_3_24","MRK","3","24","24","ꠇꠥꠘꠥ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠤꠉꠦꠟꠦ ꠁ ꠖꠦꠡ ꠔ ꠀꠞ ꠐꠤꠇꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_25","071_3_25","MRK","3","25","25","ꠅꠃꠟꠣ ꠇꠥꠘꠥ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠎꠦꠅ ꠎꠦꠛꠟꠣ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠤꠎꠣꠄ, ꠅꠃ ꠙꠞꠤꠛꠣꠞꠅ ꠀꠞ ꠐꠤꠇꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_26","071_3_26","MRK","3","26","26","ꠔꠦ ꠡꠄꠔꠣꠘꠦꠅ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠝꠣꠎꠦ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠣꠁ ꠖꠦꠄ, ꠢꠦ-ꠅ ꠔ ꠐꠤꠇꠔ ꠘꠣꠄ, ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MK3_27","071_3_27","MRK","3","27","27","ꠀꠍꠟ ꠢꠣꠍꠣ ꠇꠕꠣ ꠅꠁꠟ, ꠇꠥꠘꠥ ꠒꠣꠇꠣꠁꠔ ꠒꠣꠇꠣꠔꠤꠔ ꠀꠁꠀ ꠙꠄꠟꠣ ꠅꠃ ꠛꠣꠠꠤꠞ ꠛꠟꠀꠟꠣ ꠝꠥꠟ ꠉꠤꠞꠡ꠆ꠔꠞꠦ ꠘꠣ ꠛꠣꠘ꠆ꠖꠤꠟꠦ, ꠢꠦ ꠟꠥꠐ-ꠔꠞꠣꠎ ꠇꠞꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠔꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠟꠥꠐ-ꠔꠞꠣꠎ ꠇꠞꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("MK3_28","071_3_28","MRK","3","28","28","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠝꠣꠘꠡꠞ ꠔꠣꠝꠣꠝ ꠘꠝꠥꠘꠣꠞ ꠉꠥꠘꠣ ꠀꠞ ꠇꠥꠚꠥꠞꠤꠞ ꠝꠣꠚꠤ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("MK3_29","071_3_29","MRK","3","29","29","ꠅꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠚꠥꠞꠤ ꠇꠞꠟꠦ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠁ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠝꠤꠟꠔ ꠘꠣꠄ। ꠁ ꠉꠥꠘꠣ ꠞꠥꠎ ꠢꠣꠡꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠣꠞꠤ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK3_30","071_3_30","MRK","3","30","30","ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠎꠤꠘꠦ ꠀꠍꠞ ꠇꠞꠍꠦ, ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠅꠃ ꠇꠕꠣ ꠇꠅꠀꠄ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞꠦ ꠅꠃꠟꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_31","071_3_31","MRK","3","31","31","ꠅꠃ ꠡꠝꠄ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ ꠀꠁꠀ ꠛꠣꠞꠦ ꠕꠘꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠈꠛꠞ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK3_32","071_3_32","MRK","3","32","32","ꠅꠁꠟꠦ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠝꠣꠘꠡꠞ ꠜꠤꠠ ꠟꠣꠉꠣꠁꠟ ꠀꠍꠤꠟ, ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠀꠝ꠆ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ ꠀꠁꠀ ꠛꠣꠞꠦ ꠀꠙꠘꠣꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK3_33","071_3_33","MRK","3","33","33","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK3_34","071_3_34","MRK","3","34","34","ꠇꠁꠀ ꠔꠣꠁꠘ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠝꠣꠘꠡꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠄꠞꠣꠃ ꠔ ꠀꠝꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("MK3_35","071_3_35","MRK","3","35","35","ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠂꠘ, ꠔꠣꠞꠣꠃ ꠔ ꠀꠝꠣꠞ ꠝꠣ, ꠀꠞ ꠜꠣꠁ-ꠛꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK4_1","071_4_1","MRK","4","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠙꠣꠞꠅ ꠀꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣ ꠟꠣꠉꠟꠣ। ꠔꠣꠘ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠜꠤꠠ ꠛꠣꠘ꠆ꠖꠤꠟ꠆ꠟꠣ, ꠄꠞꠖꠣꠄ ꠔꠣꠁꠘ ꠄꠇ ꠘꠣꠅꠔ ꠃꠑꠤꠀ ꠛꠁꠟꠣ, ꠀꠞ ꠝꠣꠘꠡꠦ ꠙꠣꠞꠅ ꠕꠘꠦ ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK4_2","071_4_2","MRK","4","2","2","ꠔꠣꠁꠘ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁ ꠢꠥꠘꠣꠁ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ, ꠄꠞꠝꠣꠎꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK4_3","071_4_3","MRK","4","3","3","“ꠗꠞꠃꠇ꠆ꠇꠣ, ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠦ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠇꠞꠣꠔ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK4_4","071_4_4","MRK","4","4","4","ꠉꠤꠀ ꠛꠣꠁꠘ ꠇꠞꠣꠞ ꠡꠝꠄ ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠙꠠꠟ, ꠀꠞ ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠁꠔꠣ ꠈꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK4_5","071_4_5","MRK","4","5","5","ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠙꠣꠔ꠆ꠔꠞ ꠀꠟꠣ ꠝꠣꠐꠤꠔ ꠙꠠꠟ, ꠁꠔꠣꠞ ꠔꠟꠦ ꠛꠦꠡꠤ ꠝꠣꠐꠤ ꠀꠍꠤꠟ ꠘꠣ, ꠄꠞꠖꠣꠄ ꠔꠟꠦꠖꠤ ꠛꠟ ꠘꠣ ꠇꠞꠤꠀꠃ ꠎꠟꠖꠤ ꠇꠞꠤ ꠚꠥꠐꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK4_6","071_4_6","MRK","4","6","6","ꠛꠣꠖꠦ ꠡꠥꠞꠥꠎ ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠎꠁꠞ ꠈꠣꠁꠟꠤꠟ, ꠀꠞ ꠔꠟꠞ ꠎꠠꠦ ꠞꠡ ꠘꠣ ꠙꠣꠅꠀꠄ ꠢꠥꠇꠣꠁꠀ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK4_7","071_4_7","MRK","4","7","7","ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠙꠠꠟ, ꠔꠦꠃ ꠎꠋꠟꠣ ꠛꠠ ꠅꠁꠀ ꠁꠔꠣꠞꠦ ꠎꠣꠔꠤꠀ ꠗꠞꠟ, ꠄꠞꠖꠣꠄ ꠇꠥꠘꠥ ꠍꠠꠣ ꠍꠣꠠꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK4_8","071_4_8","MRK","4","8","8","ꠅꠁꠟꠦ ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠜꠣꠟꠣ ꠎꠝꠤꠘꠅ ꠙꠠꠟ, ꠁꠔꠣꠄ ꠀꠟꠤ ꠛꠣꠞ ꠅꠁꠀ ꠛꠠ ꠅꠁꠀ ꠍꠠꠣ ꠍꠣꠠꠟ, ꠇꠥꠘꠥ ꠍꠠꠣꠄ ꠔꠤꠡ, ꠇꠥꠘꠥ ꠍꠠꠣꠄ ꠡꠣꠁꠐ, ꠇꠥꠘꠥ ꠍꠠꠣꠄ ꠄꠇ-ꠡ ꠉꠥꠘ ꠛꠦꠡꠤ ꠗꠣꠘ ꠗꠞꠟ।” ");
INSERT INTO syls_vpl VALUES ("MK4_9","071_4_9","MRK","4","9","9","ꠢꠦꠡꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠘꠣꠞ ꠟꠣꠈ ꠇꠣꠘ ꠎꠣꠞ ꠀꠍꠦ, ꠢꠦ ꠢꠥꠘꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MK4_10","071_4_10","MRK","4","10","10","ꠛꠣꠖꠦ ꠜꠤꠠ ꠇꠝꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘ ꠟꠉꠞ ꠝꠣꠘꠡꠦ ꠀꠞ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠄ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠥꠟ ꠝꠣꠘꠤ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("MK4_11","071_4_11","MRK","4","11","11","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠉꠥꠙꠘ ꠞꠢꠁꠡ꠆ꠡ ꠎꠣꠘꠣꠞ ꠡꠥꠎꠥꠉ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠁꠟꠦ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠎꠖꠤ ꠇꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK4_12","071_4_12","MRK","4","12","12","ꠄꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠅꠃ ꠀꠄꠀꠔ ꠚꠟꠤꠔꠦ ꠅꠁꠛ, ꠔꠣꠞꠣ ꠌꠣꠁꠀ ꠕꠣꠇꠟꠦꠅ ꠇꠥꠘ꠆ꠔꠣꠃ ꠖꠦꠈꠔ ꠘꠣꠄ, ꠢꠥꠘꠟꠦꠅ ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠔ ꠘꠣꠄ। ꠇꠤꠎꠣꠘꠥ ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠎꠣꠁꠘ, ꠀꠞ ꠝꠣꠚꠤ ꠙꠣꠁꠟꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK4_13","071_4_13","MRK","4","13","13","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠃ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠘꠤ ꠈꠣꠘꠅ ꠛꠥꠎꠟꠣꠄ ꠘꠣ ꠘꠤ? ꠔꠦ ꠛꠣꠇꠤ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠘꠤ ꠇꠤꠟꠣ ꠛꠥꠎꠛꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("MK4_14","071_4_14","MRK","4","14","14","ꠢꠥꠘꠅ, ꠉꠤꠞꠡ꠆ꠔꠦ ꠎꠦ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠇꠞꠦꠞ, ꠁ ꠎꠣꠟꠣ ꠅꠁꠟꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("MK4_15","071_4_15","MRK","4","15","15","ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠙꠠꠣ ꠎꠣꠟꠣ ꠖꠤꠀ ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ, ꠅꠁꠟꠦ ꠟꠉꠦ ꠟꠉꠦ ꠁꠛꠟꠤꠍ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠁ ꠇꠣꠟꠣꠝꠞꠦ ꠇꠣꠠꠤꠀ ꠘꠦꠄꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK4_16","071_4_16","MRK","4","16","16","ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠙꠠꠣ ꠎꠣꠟꠣꠖꠤ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ ꠀꠞ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀ ꠟꠉꠦ ꠟꠉꠦ ꠇꠛꠥꠟ ꠇꠞꠤꠟꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("MK4_17","071_4_17","MRK","4","17","17","ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠢꠣꠝꠣꠄ ꠘꠣ ꠇꠞꠤꠀ, ꠁꠔꠣ ꠈꠣꠟꠤ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠇꠣꠁꠝ ꠞꠄ, ꠛꠣꠖꠦ ꠁ ꠇꠣꠟꠣꠝꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠀꠎꠤꠞ ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠙꠤꠍꠟꠣꠁ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK4_18","071_4_18","MRK","4","18","18","ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠙꠠꠣ ꠎꠣꠟꠣꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ, ");
INSERT INTO syls_vpl VALUES ("MK4_19","071_4_19","MRK","4","19","19","ꠅꠁꠟꠦ ꠎꠉꠔꠞ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ, ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠝꠣꠄꠀ ꠀꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠟꠣꠟꠌꠦ ꠁ ꠇꠣꠟꠣꠝꠞꠦ ꠎꠣꠔꠤꠀ ꠗꠞꠤꠟꠣꠄ, ꠄꠞꠖꠣꠄ ꠇꠣꠟꠣꠝꠦ ꠇꠥꠘꠥ ꠀꠝꠟ ꠇꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK4_20","071_4_20","MRK","4","20","20","ꠀꠞ ꠜꠣꠟꠣ ꠎꠝꠤꠘꠅ ꠙꠠꠣ ꠎꠣꠟꠣꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ, ꠇꠛꠥꠟ ꠇꠞꠦ ꠀꠞ ꠜꠣꠟꠣ ꠚꠟ ꠗꠞꠦ, ꠇꠦꠃ ꠔꠤꠡ, ꠇꠦꠃ ꠡꠣꠁꠐ, ꠇꠦꠃ ꠄꠇ-ꠡ ꠉꠥꠘ ꠚꠟ ꠗꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK4_21","071_4_21","MRK","4","21","21","ꠁꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠟꠦꠝ ꠎꠣꠟꠣꠁꠀ ꠐꠥꠇꠞꠤꠞ ꠔꠟꠦ ꠛꠣ ꠌꠇꠤꠞ ꠔꠟꠦ ꠕꠄ ꠘꠤ? ꠟꠦꠝ ꠎꠣꠟꠣꠁꠀ ꠉꠣꠍꠣꠞ ꠃꠙꠞꠦ ꠕꠂꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MK4_22","071_4_22","MRK","4","22","22","ꠔꠦ ꠁꠟꠣ ꠟꠥꠇꠣꠁꠟ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ, ꠎꠦꠔꠣ ꠛꠣꠞ ꠅꠁꠔ ꠘꠣꠄ। ꠀꠞ ꠁꠟꠣ ꠇꠥꠘꠥ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞꠅ ꠘꠣꠁ, ꠎꠦꠔꠣ ꠎꠣꠁꠞ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK4_23","071_4_23","MRK","4","23","23","ꠢꠥꠘꠣꠞ ꠟꠣꠈ ꠇꠣꠘ ꠎꠣꠞ ꠀꠍꠦ, ꠢꠦ ꠢꠥꠘꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MK4_24","071_4_24","MRK","4","24","24","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠝꠣꠙꠤꠀ ꠖꠦꠅ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃꠟꠣ ꠝꠣꠙꠣ ꠅꠁꠛ। ꠗꠞꠤꠟꠣꠅ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠛꠦꠡ ꠇꠞꠤ ꠝꠣꠙꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK4_25","071_4_25","MRK","4","25","25","ꠎꠣꠞ ꠀꠍꠦ ꠔꠣꠞꠦ ꠀꠞꠅ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠎꠣꠞ ꠘꠣꠁ, ꠔꠣꠞ ꠎꠦꠔꠣ ꠀꠍꠦ ꠄꠅꠔꠣ ꠘꠦꠅꠀ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK4_26","071_4_26","MRK","4","26","26","ꠔꠣꠁꠘ ꠀꠞꠇꠛꠣꠞ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟ ꠅꠃ ꠟꠣꠈꠣꠘ। ꠗꠞꠤꠟꠣꠅ, ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠞ ꠎꠝꠤꠘꠅ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MK4_27","071_4_27","MRK","4","27","27","ꠛꠣꠖꠦ ꠢꠦ ꠞꠣꠁꠔ ꠅꠁꠟꠦ ꠊꠥꠝꠣꠁꠟ ꠀꠞ ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠊꠥꠞꠣꠊꠥꠞꠤ ꠇꠞꠟ। ꠅꠁꠟꠦ ꠎꠣꠟꠣ ꠚꠥꠐꠤꠀ ꠇꠦꠝꠘꠦ ꠉꠣꠍ ꠅꠁꠟ, ꠢꠦ ꠔ ꠇꠥꠘ꠆ꠔꠣ ꠎꠣꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK4_28","071_4_28","MRK","4","28","28","ꠎꠝꠤꠘꠦ ꠘꠤꠎꠦ ꠘꠤꠎꠦꠃ ꠁꠔꠣ ꠚꠟꠣꠁꠟ, ꠙꠄꠟꠣ ꠌꠦꠞꠣ, ꠛꠣꠖꠦ ꠍꠠꠣ ꠀꠞ ꠍꠠꠣꠞ ꠝꠣꠎꠦ ꠙꠥꠡ꠆ꠐ ꠗꠣꠘ ꠗꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MK4_29","071_4_29","MRK","4","29","29","ꠗꠣꠘ ꠙꠣꠇꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠦ ꠛꠥꠎꠤꠟꠣꠄ ꠖꠣꠅꠀꠞ ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ, ꠔꠦꠃ ꠇꠣꠌꠤ ꠟꠣꠉꠣꠁꠀ ꠖꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK4_30","071_4_30","MRK","4","30","30","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞꠦ ꠀꠝꠞꠣ ꠇꠤꠔꠣꠞ ꠟꠉꠦ ꠔꠥꠟꠘꠣ ꠇꠞꠔꠣꠝ? ꠇꠤꠔꠣꠖꠤ ꠛꠥꠎꠣꠁꠔꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("MK4_31","071_4_31","MRK","4","31","31","ꠀꠁꠌ꠆ꠍꠣ, ꠝꠘꠦ ꠇꠞꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟ ꠄꠉꠥ ꠒꠦꠋꠉꠣ ꠛꠤꠌꠤꠞ ꠟꠣꠈꠣꠘ। ꠁ ꠛꠤꠌꠤ ꠛꠣꠁꠘ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠤꠌꠤ ꠕꠘꠦ ꠁꠐꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ। ");
INSERT INTO syls_vpl VALUES ("MK4_32","071_4_32","MRK","4","32","32","ꠅꠁꠟꠦ ꠛꠣꠁꠘ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠁꠐꠣ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠢꠣꠉ ꠕꠘꠦꠅ ꠛꠠ ꠛꠠ ꠙꠣꠔꠣ ꠀꠞ ꠉꠣꠍ ꠅꠄ। ꠀꠞ ꠝꠥꠐꠣ ꠝꠥꠐꠣ ꠒꠣꠟ ꠛꠣꠞꠅꠄ, ꠁ ꠒꠣꠟꠞ ꠍꠣꠄꠀꠔ ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠀꠡꠞꠄ ꠟꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK4_33","071_4_33","MRK","4","33","33","ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠃꠔ ꠘꠝꠥꠘꠣꠞ ꠇꠤꠌ꠆ꠍꠣ ꠇꠁꠔꠣ, ꠀꠞ ꠎꠦ ꠎꠦꠟꠣ ꠛꠥꠎꠔ ꠙꠣꠞꠦ, ꠔꠣꠞ ꠛꠥꠎ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK4_34","071_4_34","MRK","4","34","34","ꠇꠤꠌ꠆ꠍꠣ ꠍꠣꠠꠣ ꠔꠣꠞꠣꠞꠦ ꠇꠥꠘꠥ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣ ꠘꠣ। ꠅꠁꠟꠦ ꠈꠣꠟꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠟꠉꠦ ꠞꠁꠔꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠢꠇꠟ ꠜꠦꠖ ꠜꠣꠋꠉꠤꠀ ꠛꠥꠎꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK4_35","071_4_35","MRK","4","35","35","ꠅꠃ ꠖꠤꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠝꠞꠣ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠎꠣꠁꠔꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("MK4_36","071_4_36","MRK","4","36","36","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠟꠁꠀ, ꠁꠍꠣ ꠎꠦ ꠘꠣꠅꠅ ꠛꠅꠀꠔ ꠀꠍꠟꠣ ꠅꠃ ꠘꠣꠅꠅ ꠃꠑꠤꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ, ꠄꠞꠟꠉꠦ ꠀꠞꠅ ꠘꠣꠅꠀꠁꠘꠅ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK4_37","071_4_37","MRK","4","37","37","ꠘꠣꠅ ꠌꠟꠦꠞ, ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠈꠥꠛ ꠛꠠ ꠄꠇ ꠔꠥꠚꠣꠘ ꠀꠁꠟ, ꠔꠥꠚꠣꠘꠞ ꠖꠣꠄ ꠀꠚꠣꠟꠞ ꠙꠣꠘꠤ ꠢꠣꠝꠣꠁꠀ ꠘꠣꠅ ꠛꠥꠠꠤꠎꠤꠛꠣꠞ ꠖꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("MK4_38","071_4_38","MRK","4","38","38","ꠁꠍꠣ ꠘꠣꠅꠞ ꠈꠞ ꠉꠣꠟꠣꠔ ꠄꠇ ꠛꠣꠟꠤꠡꠅ ꠢꠤꠔꠣꠘ ꠖꠤꠀ ꠊꠥꠝꠅ ꠀꠍꠟꠣ। ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠈꠤꠀꠟ ꠇꠞꠞꠣ ꠘꠣ ꠘꠤ, ꠀꠝꠞꠣ ꠔ ꠝꠞꠤ ꠎꠣꠁꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK4_39","071_4_39","MRK","4","39","39","ꠔꠣꠁꠘ ꠃꠑꠤꠀ ꠔꠥꠚꠣꠘꠞꠦ ꠗꠝꠇ ꠖꠤꠟꠣ ꠀꠞ ꠀꠅꠞꠞꠦ ꠇꠁꠟꠣ, “ꠖꠝ ꠟꠅ, ꠕꠤꠞ ꠅꠅ।” ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦ ꠔꠥꠚꠣꠘ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ, ꠀꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠕꠤꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK4_40","071_4_40","MRK","4","40","40","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠔ ꠒꠞꠣꠟꠥꠇ ꠇꠦꠘꠦ? ꠔꠥꠝꠞꠣ ꠅꠈꠘꠅ ꠁꠝꠣꠘ ꠀꠘꠍ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK4_41","071_4_41","MRK","4","41","41","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠈꠥꠛ ꠒꠞꠣꠁꠟꠣ, ꠀꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠀꠍꠟꠦ ꠇꠦ? ꠙꠣꠘꠤꠄ ꠀꠞ ꠛꠣꠔꠣꠡꠦꠅ ꠖꠦꠈꠤ ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK5_1","071_5_1","MRK","5","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠉꠣꠟꠤꠟ ꠀꠅꠞ ꠙꠣꠠꠤ ꠖꠤꠀ ꠎꠦꠞꠣꠍꠤꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_2","071_5_2","MRK","5","2","2","ꠔꠣꠁꠘ ꠘꠣꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠔꠦꠃ ꠜꠥꠔꠦ ꠗꠞꠣ ꠄꠇ ꠛꠦꠐꠣ, ꠇꠛꠞꠡ꠆ꠕꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_3","071_5_3","MRK","5","3","3","ꠢꠦ ꠇꠄꠛꠞꠞ ꠝꠣꠎꠦ ꠞꠁꠔ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠟꠥꠀꠞ ꠎꠤꠘꠎꠥꠞꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠀꠅ ꠔꠣꠞꠦ ꠀꠐꠇꠣꠁꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_4","071_5_4","MRK","5","4","4","ꠔꠣꠞ ꠀꠔ-ꠙꠣꠅ ꠛꠃꠔ ꠛꠣꠞ ꠎꠤꠘꠎꠥꠞꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠟꠦꠅ ꠢꠦ ꠁꠔꠣ ꠍꠤꠠꠤꠀ, ꠙꠣꠅꠞ ꠛꠦꠠꠤꠅ ꠜꠣꠋꠉꠤꠟꠤꠔ। ꠔꠣꠞꠦ ꠇꠦꠃ ꠡꠣꠝꠟꠣꠁꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_5","071_5_5","MRK","5","5","5","ꠢꠦ ꠙꠣꠠꠞ ꠐꠤꠟ꠆ꠟꠣꠄ ꠐꠤꠟ꠆ꠟꠣꠄ, ꠇꠄꠛꠞꠦ ꠇꠄꠛꠞꠦ ꠢꠣꠞꠣ ꠖꠤꠘ-ꠞꠣꠁꠔ ꠊꠥꠞꠔ ꠀꠞ ꠌꠤꠟ꠆ꠟꠣꠁꠔ, ꠙꠣꠔ꠆ꠔꠞ ꠖꠤꠀ ꠔꠣꠞ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠅ ꠝꠣꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("MK5_6","071_5_6","MRK","5","6","6","ꠁꠍꠣꠞꠦ ꠢꠦ ꠖꠥꠞꠁ ꠕꠣꠇꠤ ꠖꠦꠈꠤꠀꠃ ꠖꠃꠠꠣꠁꠀ ꠀꠁꠀ ꠔꠣꠘ ꠙꠣꠅꠔ ꠙꠠꠤꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠟ, ");
INSERT INTO syls_vpl VALUES ("MK5_7","071_5_7","MRK","5","7","7","ꠀꠞ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠅ ꠁꠍꠣ, ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠙꠘꠦ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠍꠂꠘ? ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠀꠞ, ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠍꠣꠔꠣꠁꠘ ꠘꠣ ꠎꠣꠘꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK5_8","071_5_8","MRK","5","8","8","ꠁꠍꠣꠄ ꠀꠉꠦ ꠅꠃ ꠜꠥꠔꠞꠦ ꠇꠁꠍꠟꠣ, “ꠔꠥꠁ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣ,” ꠄꠞꠖꠣꠄ ꠢꠦ ꠁꠍꠣꠞꠦ ꠅꠃ ꠝꠤꠘꠔꠤ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_9","071_5_9","MRK","5","9","9","ꠔꠣꠁꠘ ꠅꠃ ꠜꠥꠔꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠞ ꠘꠣꠝ ꠇꠤꠔꠣ?” ꠢꠦ ꠇꠁꠟ, “ꠀꠝꠣꠞ ꠘꠣꠝ ꠚꠃꠎ, ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠛꠃꠔ ꠎꠘ ꠀꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK5_10","071_5_10","MRK","5","10","10","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟ, “ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠁ ꠄꠟꠣꠇꠣ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠘ ꠘꠣ ꠎꠣꠘꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK5_11","071_5_11","MRK","5","11","11","ꠅꠃ ꠡꠝꠄ ꠢꠘꠅ ꠙꠣꠠꠞ ꠉꠣꠟꠣꠔ ꠛꠠ ꠄꠇ ꠡꠥꠅꠞꠞ ꠙꠣꠟꠦ ꠈꠣꠅꠀꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_12","071_5_12","MRK","5","12","12","ꠜꠥꠔꠞ ꠙꠣꠟꠦ ꠁꠍꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞꠦ ꠅꠃ ꠡꠥꠅꠞꠞ ꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠙꠣꠑꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣ ꠉꠤꠀ ꠅꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("MK5_13","071_5_13","MRK","5","13","13","ꠁꠍꠣꠄ ꠁꠎꠣꠎꠔ ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠉꠤꠀ ꠅꠃ ꠡꠥꠅꠞꠞ ꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠁ ꠉꠦꠟ। ꠔꠦꠃ ꠡꠥꠅꠞꠞ ꠙꠣꠟꠦ ꠙꠣꠠꠞ ꠐꠤꠟ꠆ꠟꠣꠞ ꠙꠦꠐꠦꠖꠤ ꠈꠥꠛ ꠎꠥꠞꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠀꠅꠞꠞ ꠝꠣꠎꠦ ꠛꠥꠠꠤꠀ ꠝꠞꠟꠣ। ꠁ ꠙꠣꠟꠅ ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁ ꠀꠎꠣꠞ ꠡꠥꠅꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_14","071_5_14","MRK","5","14","14","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠡꠥꠅꠞꠞ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠉꠣꠃꠔ ꠀꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠢꠇꠟꠞꠦ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟꠣ। ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠖꠦꠈꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_15","071_5_15","MRK","5","15","15","ꠔꠣꠞꠣ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠜꠥꠔꠞ ꠚꠃꠎꠦ ꠎꠦ ꠛꠦꠐꠣꠞꠦ ꠗꠞꠍꠤꠟ, ꠁ ꠛꠦꠐꠣ ꠜꠣꠟꠣ ꠅꠁꠀ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠛꠁꠞꠁꠍꠦ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣꠞ ꠝꠘꠅ ꠒꠞ ꠢꠣꠝꠣꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_16","071_5_16","MRK","5","16","16","ꠔꠦꠃ ꠎꠦꠞꠣ ꠅꠃ ꠊꠐꠘꠣ ꠖꠦꠈꠍꠤꠟ, ꠔꠣꠞꠣ ꠢꠃ ꠜꠥꠔꠦ ꠗꠞꠣ ꠛꠦꠐꠣꠞ ꠇꠕꠣ ꠀꠞ ꠡꠥꠅꠞꠞ ꠊꠐꠘꠣ ꠄꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_17","071_5_17","MRK","5","17","17","ꠄꠞꠖꠣꠄ ꠝꠣꠘꠡꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠀꠝꠞꠣꠞ ꠄꠟꠣꠇꠣ ꠕꠣꠇꠤ ꠔꠡꠞꠤꠚ ꠘꠦꠃꠇ꠆ꠇꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK5_18","071_5_18","MRK","5","18","18","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠘꠣꠅꠔ ꠃꠑꠤꠎꠤꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠜꠥꠔꠦ ꠗꠞꠣ ꠛꠦꠐꠣꠅ ꠔꠣꠘ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠁꠔ ꠇꠞꠤ ꠝꠤꠘꠔ ꠟꠣꠉꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_19","071_5_19","MRK","5","19","19","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠅꠈꠣꠘ ꠇꠁꠀ ꠛꠤꠖꠣꠄ ꠇꠞꠤ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅ, ꠉꠤꠀ ꠛꠣꠠꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠖꠦꠈꠣꠅ, ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞꠦ ꠇꠔ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠀꠞ ꠛꠠ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠇꠣꠝ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK5_20","071_5_20","MRK","5","20","20","ꠔꠣꠘ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠛꠦꠐꠣ ꠉꠦꠟꠉꠤ ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠖꠤꠇꠣꠙꠟꠤ ꠄꠟꠣꠇꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟ, ꠁꠍꠣꠄ ꠔꠣꠞ ꠟꠣꠉꠤ ꠇꠔ ꠛꠠ ꠇꠣꠝ ꠇꠞꠍꠂꠘ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣꠅ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_21","071_5_21","MRK","5","21","21","ꠢꠎꠞꠔ ꠁꠍꠣ ꠘꠣꠅꠔ ꠇꠞꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ, ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠘꠦ ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠅꠃ ꠀꠅꠞꠞ ꠙꠣꠞꠅꠃ ꠜꠤꠠ ꠟꠣꠉꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_22","071_5_22","MRK","5","22","22","ꠅꠃ ꠡꠝꠄ ꠝꠍꠤꠖ ꠇꠝꠤꠐꠤꠞ ꠎꠣꠄꠁꠞ ꠘꠣꠝꠞ ꠄꠇ ꠘꠦꠔꠣ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠙꠣꠅꠔ ꠙꠠꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("MK5_23","071_5_23","MRK","5","23","23","ꠈꠥꠛ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠙꠥꠠꠤꠉꠥ ꠝꠞꠣꠞ ꠙꠕꠤ ꠅꠁꠉꠦꠍꠦ। ꠀꠙꠘꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠤꠀ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠉꠥꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠟꠦꠃ ꠔꠣꠁ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK5_24","071_5_24","MRK","5","24","24","ꠔꠦꠃ ꠔꠣꠁꠘ ꠅꠃ ꠘꠦꠔꠣꠞ ꠛꠣꠠꠤꠔ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ। ꠔꠣꠘ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠜꠤꠠ ꠛꠣꠘ꠆ꠖꠤꠀ ꠑꠦꠟꠣ-ꠑꠦꠟꠤ ꠇꠞꠤꠀ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_25","071_5_25","MRK","5","25","25","ꠅꠃ ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠄꠇꠎꠘ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ, ꠛꠣꠞꠅ ꠛꠞꠍ ꠗꠞꠤ ꠔꠣꠘ ꠛꠦꠐꠤꠀꠞꠣ ꠛꠦꠝꠣꠞꠞ ꠟꠃ ꠎꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("MK5_26","071_5_26","MRK","5","26","26","ꠛꠃꠔ ꠒꠣꠇ꠆ꠔꠞ ꠇꠛꠤꠞꠣꠎ ꠖꠦꠈꠣꠁꠀ ꠇꠡ꠆ꠐ ꠇꠞꠤ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠤꠀ, ꠢꠇꠟ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠈꠥꠀꠁꠀꠅ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠍꠦ ꠘꠣ। ꠖꠤꠘꠦ ꠖꠤꠘꠦ ꠛꠦꠝꠣꠞ ꠀꠞꠅ ꠛꠣꠠꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK5_27","071_5_27","MRK","5","27","27","ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠘꠤꠀ ꠛꠦꠐꠤꠄ ꠅꠃ ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠑꠤꠇ ꠔꠣꠘ ꠈꠞꠦꠖꠤ ꠀꠁꠀ, ꠔꠣꠘ ꠚꠤꠘ꠆ꠘꠞ ꠌꠣꠖ꠆ꠖꠞ ꠈꠣꠘꠞ ꠄꠇ ꠇꠥꠘꠣꠔ ꠍꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_28","071_5_28","MRK","5","28","28","ꠔꠣꠁ ꠄꠇꠤꠘ ꠇꠞꠍꠤꠟ ꠎꠦꠘ, ꠁꠍꠣꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠥꠘꠥ ꠇꠣꠙꠠꠞ ꠝꠣꠎꠦ ꠍꠁꠔꠦ ꠙꠣꠞꠟꠦꠃ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MK5_29","071_5_29","MRK","5","29","29","ꠢꠣꠍꠣꠃ, ꠁꠍꠣꠞ ꠌꠣꠖ꠆ꠖꠞꠞ ꠇꠥꠘꠣꠔ ꠍꠁꠔꠦꠃ, ꠛꠦꠐꠤꠞ ꠟꠃ ꠎꠣꠅꠀ ꠄꠇ꠆ꠇꠦꠞꠦ ꠇꠝꠤꠉꠦꠟ। ꠛꠦꠐꠤꠄ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞ ꠢꠣꠟꠔ ꠛꠥꠎꠤꠟꠤꠟ, ꠛꠦꠝꠣꠞ ꠇꠝꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK5_30","071_5_30","MRK","5","30","30","ꠁꠍꠣꠄꠅ ꠐꠦꠞ ꠙꠣꠁꠟꠣ, ꠔꠣꠘ ꠡꠞꠤꠟ ꠝꠥꠛꠣꠞꠇ ꠕꠣꠇꠤ ꠛꠟ ꠛꠣꠞ ꠅꠁꠍꠦ। ꠅꠃ ꠔꠣꠁꠘ ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠌꠣꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠝꠣꠞ ꠇꠣꠙꠠꠅ ꠇꠦ ꠍꠁꠟ?” ");
INSERT INTO syls_vpl VALUES ("MK5_31","071_5_31","MRK","5","31","31","ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠔ ꠖꠦꠈꠞꠣ, ꠝꠣꠘꠡꠦ ꠇꠤꠟꠣ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠑꠦꠟꠣ-ꠑꠦꠟꠤ ꠇꠞꠞꠣ, ꠔꠦ ꠀꠞ ꠇꠦꠘꠦ ꠎꠤꠇꠣꠁꠞꠣ, ꠇꠦ ꠀꠙꠘꠣꠞꠦ ꠍꠁꠟ?” ");
INSERT INTO syls_vpl VALUES ("MK5_32","071_5_32","MRK","5","32","32","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠌꠃꠈꠖꠤ ꠔꠣꠟ꠆ꠟꠣꠡꠤꠔ ꠞꠁꠟꠣ, ꠇꠦ ꠔꠣꠘꠦ ꠍꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_33","071_5_33","MRK","5","33","33","ꠔꠦꠃ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠅꠀ ꠛꠦꠐꠤꠄ ꠘꠤꠎꠞ ꠢꠣꠟꠔ ꠛꠥꠎꠤꠀ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠤ ꠇꠣꠙꠤ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠙꠣꠅꠔ ꠙꠠꠟ, ꠀꠞ ꠢꠇꠟꠔꠣ ꠈꠥꠟꠤꠀ ꠇꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK5_34","071_5_34","MRK","5","34","34","ꠁꠍꠣꠄ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠁ ꠉ, ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘꠦ ꠔꠥꠝꠤ ꠛꠣꠌꠟꠣꠄ। ꠅꠈꠘ ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠣꠠꠤꠔ ꠎꠣꠅ, ꠀꠞ ꠁ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠢꠦꠚꠣꠎꠔ ꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK5_35","071_5_35","MRK","5","35","35","ꠔꠣꠁꠘ ꠅꠔꠣ ꠝꠣꠔꠅ ꠞꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠝꠍꠤꠖꠞ ꠢꠃ ꠘꠦꠔꠣꠞ ꠛꠣꠠꠤ ꠕꠣꠇꠤ ꠈꠛꠞꠤꠀ ꠀꠁꠀ ꠘꠦꠔꠣꠞꠦ ꠇꠁꠟ, “ꠍꠣꠛ, ꠀꠙꠘꠣꠞ ꠙꠥꠠꠤ ꠔ ꠀꠞ ꠘꠣꠁ, ꠖꠥꠘꠤꠀ ꠍꠣꠠꠤꠀ ꠉꠦꠍꠂꠘꠉꠤ। ꠔꠦ ꠢꠥꠎꠥꠞꠞꠦ ꠀꠞ ꠔꠇꠟꠤꠚ ꠖꠤꠛꠣꠞ ꠇꠣꠝ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("MK5_36","071_5_36","MRK","5","36","36","ꠅꠁꠟꠦ ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠢꠃ ꠘꠦꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠛꠣ ꠘꠣ, ꠈꠣꠟꠤ ꠄꠇꠤꠘ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK5_37","071_5_37","MRK","5","37","37","ꠇꠁꠀ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞ, ꠁꠀꠇꠥꠛ, ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠜꠣꠁ ꠢꠣꠘ꠆ꠘꠣꠘ, ꠈꠣꠟꠤ ꠅꠃ ꠔꠤꠘꠎꠘ ꠛꠣꠖꠦ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠔꠣꠘ ꠟꠉꠦ ꠘꠤꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_38","071_5_38","MRK","5","38","38","ꠄꠞꠣꠞꠦ ꠟꠁꠀ ꠔꠣꠁꠘ ꠢꠃ ꠘꠦꠔꠣꠞ ꠛꠣꠠꠤꠔ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠝꠣꠘꠡꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ, ꠛꠤꠟꠣꠙ ꠀꠞ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_39","071_5_39","MRK","5","39","39","ꠔꠣꠁꠘ ꠜꠤꠔꠞꠦ ꠉꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠀꠞ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠞꠣꠄ ꠇꠦꠘꠦ? ꠁ ꠙꠥꠠꠤ ꠔ ꠝꠞꠍꠦ ꠘꠣ, ꠈꠣꠟꠤ ꠊꠥꠝꠣꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK5_40","071_5_40","MRK","5","40","40","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠍꠤꠠꠣꠁꠟꠣ। ꠔꠦꠃ ꠔꠣꠁꠘ ꠝꠥꠞ꠆ꠖꠣꠞ ꠇꠥꠑꠣ ꠕꠣꠇꠤ ꠢꠇꠟꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠀ, ꠈꠣꠟꠤ ꠙꠥꠠꠤꠞ ꠝꠣ-ꠛꠣꠚ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠇꠥꠑꠣꠔ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_41","071_5_41","MRK","5","41","41","ꠔꠣꠁꠘ ꠙꠥꠠꠤꠞ ꠀꠔꠅ ꠗꠞꠤꠀ ꠇꠁꠟꠣ, “ꠐꠣꠟꠤꠕꠣ ꠇꠥꠝ,” ꠝꠣꠘꠤ, “ꠅ ꠙꠥꠠꠤ, ꠔꠥꠝꠣꠞꠦ ꠇꠁꠀꠞ, ꠃꠑꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK5_42","071_5_42","MRK","5","42","42","ꠢꠣꠍꠣꠃ, ꠝꠥꠞ꠆ꠖꠣ ꠙꠥꠠꠤ ꠟꠉꠦ ꠟꠉꠦ ꠃꠑꠤꠀ ꠀꠐꠣ ꠗꠞꠟ, ꠙꠥꠠꠤꠞ ꠛꠄꠅꠡ ꠀꠍꠤꠟ ꠛꠣꠞꠅ ꠛꠍꠞ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠄꠞꠣ ꠀꠌꠣꠘꠇ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK5_43","071_5_43","MRK","5","43","43","ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠁꠔꠣ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ। ꠀꠞ ꠅꠃ ꠙꠥꠠꠤꠞꠦ ꠅꠈꠘ ꠈꠣꠁꠛꠣꠞ ꠇꠥꠘ꠆ꠔꠣ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("MK6_1","071_6_1","MRK","6","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠢꠘ ꠕꠘꠦ ꠘꠤꠎꠞ ꠉꠣꠃ ꠘꠣꠍꠣꠞꠔꠅ ꠔꠡꠞꠤꠚ ꠀꠘꠟꠣ। ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠅ ꠟꠉꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_2","071_6_2","MRK","6","2","2","ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠔꠣꠁꠘ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠟꠣ, ꠢꠥꠘꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠁ ꠛꠦꠐꠣꠄ ꠁꠔꠣ ꠔꠣꠟꠤꠝ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠙꠣꠁꠟ? ꠢꠦ ꠇꠦꠝꠘꠦ ꠁꠔꠣ ꠁꠟꠤꠝ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠦ, ꠀꠞ ꠎꠦꠔꠣ ꠝꠥꠎꠦꠎꠣ ꠅꠇꠟ ꠖꠦꠈꠣꠞ, ꠁꠔꠣꠞ ꠜꠦꠖ ꠇꠤꠔꠣ? ");
INSERT INTO syls_vpl VALUES ("MK6_3","071_6_3","MRK","6","3","3","ꠄ ꠔ ꠢꠃ ꠝꠞꠤꠅꠝꠞ ꠙꠥꠀ ꠇꠣꠑ-ꠝꠦꠡ꠆ꠔꠁꠞ ꠘꠣꠄ ꠘꠤ? ꠢꠦ ꠁꠀꠇꠥꠛ, ꠁꠃꠍꠤ, ꠄꠢꠥꠖꠣ ꠀꠞ ꠍꠣꠁꠝꠘꠞ ꠜꠣꠁ ꠘꠣꠄ ꠘꠤ? ꠔꠣꠞ ꠛꠘꠤꠘ ꠔ ꠀꠝꠞꠣꠞ ꠉꠣꠃꠔꠃ ꠞꠁꠞꠣ।” ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞ ꠟꠁꠀ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠛꠤꠔꠤꠡꠘꠣ ꠖꠦꠈꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK6_4","071_6_4","MRK","6","4","4","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠎꠦꠇꠥꠘꠥ ꠘꠛꠤꠃ ꠘꠤꠎꠞ ꠉꠣꠃ, ꠘꠤꠎꠞ ꠖꠦꠡ, ꠘꠤꠎꠞ ꠛꠣꠠꠤ, ꠈꠦꠡ-ꠇꠥꠐꠥꠝꠞ ꠛꠣꠁꠞꠣꠈꠣꠘꠅ ꠁꠎ꠆ꠎꠔ ꠙꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK6_5","071_6_5","MRK","6","5","5","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠄꠎꠘ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠀ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠟꠣ। ꠅꠁꠟꠦ ꠢꠤꠘꠅ ꠀꠞ ꠇꠥꠘꠥ ꠝꠥꠎꠦꠎꠣ ꠎꠣꠁꠞ ꠇꠞꠣꠞ ꠃꠙꠣꠄ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_6","071_6_6","MRK","6","6","6","ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠘꠣ ꠀꠘꠣꠄ ꠔꠣꠁꠘ ꠈꠥꠛ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠉꠣꠃꠄ ꠉꠣꠃꠄ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠚꠞ ꠇꠞꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_7","071_6_7","MRK","6","7","7","ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠘꠤꠎꠞ ꠗꠣꠞꠅ ꠀꠘꠤꠀ, ꠎꠤꠘ-ꠜꠥꠔꠞ ꠃꠙꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠤꠀ, ꠖꠥꠁꠎꠘ ꠖꠥꠁꠎꠘ ꠇꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠅ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_8","071_6_8","MRK","6","8","8","ꠍꠚꠞꠞ ꠡꠝꠄ ꠈꠣꠟꠤ ꠀꠔꠞ ꠟꠣꠑꠤ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠄꠞꠣꠞꠦ ꠟꠉꠦ ꠘꠤꠔꠦ ꠖꠤꠟꠣ ꠘꠣ। ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ, ꠛꠦꠉ ꠛꠣ ꠇꠝꠞꠞ ꠕꠟꠤꠔ ꠛꠣꠘ꠆ꠖꠤꠀ ꠇꠥꠘꠥ ꠙꠄꠡꠣ-ꠇꠠꠤ ꠘꠤꠔꠦꠅ ꠘꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_9","071_6_9","MRK","6","9","9","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠙꠣꠅꠔ ꠎꠥꠔꠣ ꠚꠤꠘ꠆ꠖꠤꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠚꠤꠘ꠆ꠘꠞ ꠄꠇ ꠇꠣꠙꠠ ꠛꠣꠖꠦ ꠀꠞ ꠇꠥꠘꠥ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠘꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK6_10","071_6_10","MRK","6","10","10","ꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠙꠄꠟꠣ ꠎꠦ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠛꠣꠄ, ꠁ ꠉꠣꠃ ꠍꠣꠠꠤꠀ ꠎꠣꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠛꠣꠠꠤꠔꠃ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MK6_11","071_6_11","MRK","6","11","11","ꠇꠥꠘꠥ ꠎꠣꠉꠣꠞ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠘꠣ ꠇꠞꠦ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠄꠀꠘ ꠘꠣ ꠢꠥꠘꠦ, ꠔꠦ ꠢꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠘꠤꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅꠞ ꠗꠥꠁꠟ ꠏꠣꠠꠤꠀ ꠚꠣꠟꠣꠁꠅ, ꠅꠃ ꠗꠥꠁꠟ ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠡꠣꠇ꠆ꠇꠤ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK6_12","071_6_12","MRK","6","12","12","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ꠝꠣꠘꠡꠞꠦ ꠔꠣꠉꠤꠖ ꠖꠤꠟꠣ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK6_13","071_6_13","MRK","6","13","13","ꠄꠞꠣ ꠛꠃꠔ ꠜꠥꠔ ꠍꠣꠠꠣꠁꠟꠣ, ꠀꠞ ꠛꠃꠔ ꠛꠦꠝꠣꠞꠤ ꠝꠣꠘꠡꠞ ꠝꠣꠕꠣꠔ ꠔꠦꠟ ꠝꠣꠈꠣꠁꠀ ꠛꠦꠝꠣꠞꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_14","071_6_14","MRK","6","14","14","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠡꠥꠘꠣꠝ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠞꠐꠤ ꠎꠣꠅꠀꠄ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠇꠣꠘꠅ-ꠅ ꠉꠤꠀ ꠀꠎꠤꠟ। ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠇꠁꠟꠣ, ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠄꠢꠤꠀ ꠘꠛꠤ, ꠄꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠤꠀ ꠀꠁꠍꠂꠘ ꠇꠞꠤꠃ ꠅꠃ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_15","071_6_15","MRK","6","15","15","ꠇꠦꠃ ꠇꠁꠟ, ꠄꠁꠘ ꠅꠁꠟꠣ ꠢꠎꠞꠔ ꠁꠟꠤꠀꠍ ꠘꠛꠤ। ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, ꠄꠁꠘ ꠙꠥꠞꠣꠘꠣ ꠎꠝꠣꠘꠣꠞ ꠇꠥꠘꠥ ꠘꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠘꠄꠀ ꠄꠇ ꠘꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("MK6_16","071_6_16","MRK","6","16","16","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠦꠞꠥꠖꠦ ꠇꠁꠟ, “ꠄꠁꠘ ꠔ ꠢꠃ ꠄꠢꠤꠀ, ꠎꠦꠘ ꠇꠟ꠆ꠟꠣ ꠀꠝꠤ ꠇꠣꠐꠣꠁꠍꠟꠣꠝ। ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK6_17","071_6_17","MRK","6","17","18","ꠄꠞ ꠀꠉꠦ ꠢꠦꠞꠥꠖꠦ ꠔꠣꠞ ꠜꠣꠛꠤ ꠢꠦꠞꠥꠖꠤꠀꠞ ꠝꠘ ꠎꠥꠉꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠄꠢꠤꠀ ꠘꠛꠤꠞꠦ ꠀꠐꠇ ꠇꠞꠣꠁꠀ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁ ꠕꠁꠍꠤꠟ। ꠢꠦ ꠔꠣꠞ ꠜꠣꠁ ꠚꠤꠟꠤꠚꠞ ꠛꠃꠞꠦ ꠢꠣꠋꠉꠣ ꠇꠞꠣꠄ ꠘꠛꠤꠄ ꠔꠣꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠇꠁꠔꠣ, “ꠀꠙꠘ ꠜꠣꠁꠞ ꠛꠃꠞꠦ ꠘꠤꠀ ꠢꠣꠋꠉꠣ ꠇꠞꠣ ꠔꠥꠝꠣꠞ ꠎꠣꠁꠎ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK6_19","071_6_19","MRK","6","19","19","ꠄꠞꠖꠣꠄ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠛꠣꠄ ꠢꠦꠞꠥꠖꠤꠀꠞ ꠈꠥꠛ ꠉꠥꠍꠣ ꠀꠍꠤꠟ। ꠔꠣꠁ ꠄꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠘꠤꠅꠔ ꠇꠞꠟ, ꠅꠁꠟꠦ ꠙꠣꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_20","071_6_20","MRK","6","20","20","ꠢꠦꠞꠥꠖꠦ ꠄꠘꠞꠦ ꠒꠞꠣꠁꠔ ꠀꠞ ꠎꠣꠘꠔ, ꠄꠁꠘ ꠄꠇꠎꠘ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ ꠇꠣꠝꠤꠟ ꠝꠣꠘꠥꠡ, ꠄꠞꠖꠣꠄ ꠢꠣꠝꠦꠡꠣ ꠄꠘꠞꠦ ꠔꠣꠁꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠔ। ꠄꠘ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠔꠦ ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠗꠠꠚꠠ ꠇꠞꠟꠦꠅ ꠢꠦ ꠁꠔꠣ ꠈꠥꠛ ꠙꠍꠘ꠆ꠖ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("MK6_21","071_6_21","MRK","6","21","21","ꠢꠦꠡꠦ ꠔꠣꠁ ꠄꠇ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠟ, ꠢꠦꠞꠥꠖꠞ ꠎꠘꠝ ꠖꠤꠘꠞ ꠅꠘꠥꠡ꠆ꠑꠣꠘꠅ ꠔꠣꠞ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞ, ꠍꠤꠙꠣꠁꠞ ꠅꠚꠤꠡꠣꠞ ꠅꠇꠟ, ꠀꠞ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠉꠁꠘ꠆ꠘ-ꠝꠣꠁꠘ꠆ꠘ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠤ ꠎꠥꠁꠔ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK6_22","071_6_22","MRK","6","22","22","ꠅꠃ ꠅꠘꠥꠡ꠆ꠑꠣꠘꠅ ꠢꠦꠞꠥꠖꠤꠀꠞ ꠙꠥꠠꠤꠄ ꠀꠁꠀ ꠘꠣꠌ ꠖꠦꠈꠣꠁꠀ ꠢꠇꠟ ꠝꠦꠝꠣꠘ ꠀꠞ ꠢꠦꠞꠥꠖꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠟ। ꠈꠥꠡꠤ ꠅꠁꠀ ꠢꠦꠞꠥꠖ ꠞꠣꠎꠣꠄ ꠙꠥꠠꠤꠞꠦ ꠇꠁꠟ, “ꠅ ꠝꠣ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠤꠔꠣ ꠌꠣꠅ? ꠎꠦꠔꠣ ꠌꠣꠁꠛꠣꠄ, ꠅꠔꠣꠃ ꠙꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK6_23","071_6_23","MRK","6","23","23","ꠢꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠌꠣꠁꠛꠣꠄ, ꠅꠔꠣꠃ ꠖꠤꠝꠥ। ꠀꠝꠣꠞ ꠞꠣꠁꠎ꠆ꠎꠞ ꠅꠞ꠆ꠗꠦꠇ ꠌꠣꠁꠟꠦꠅ ꠖꠤꠟꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK6_24","071_6_24","MRK","6","24","24","ꠅꠃ ꠙꠥꠠꠤꠄ ꠔꠣꠁꠞ ꠝꠣʼꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠎꠤꠇꠣꠁꠟ, “ꠝꠣꠁ ꠉ, ꠀꠝꠤ ꠇꠤꠔꠣ ꠌꠣꠁꠔꠣꠝ?” ꠝꠣ ꠢꠦꠞꠥꠖꠤꠀꠄ ꠢꠤꠇꠣꠁ ꠖꠤꠟ, “ꠔꠥꠝꠤ ꠢꠃ ꠄꠢꠤꠀꠞ ꠇꠟ꠆ꠟꠣ ꠌꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK6_25","071_6_25","MRK","6","25","25","ꠙꠥꠠꠤꠄ ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠁꠀ ꠞꠣꠎꠣꠞꠦ ꠇꠁꠟ, “ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠀꠙꠘꠦ ꠢꠃ ꠄꠢꠤꠀꠞ ꠇꠟ꠆ꠟꠣ ꠇꠣꠐꠤꠀ ꠄꠇ ꠕꠣꠟꠅ ꠇꠞꠤ ꠀꠝꠣꠞꠦ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK6_26","071_6_26","MRK","6","26","26","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠞꠣꠎꠣ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠉꠦꠟ, ꠅꠁꠟꠦ ꠅꠘꠥꠡ꠆ꠑꠣꠘꠞ ꠝꠦꠝꠣꠘ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠇꠍꠝ ꠇꠞꠣꠄ ꠅꠃ ꠙꠥꠠꠤꠞꠦ ꠘꠣ ꠇꠞꠣꠞ ꠇꠥꠘꠥ ꠃꠙꠣꠄ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_27","071_6_27","MRK","6","27","28","ꠔꠦꠃ ꠟꠉꠦ ꠟꠉꠦ ꠞꠣꠎꠣꠄ ꠎꠟ꠆ꠟꠣꠖꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟ ꠄꠢꠤꠀꠞ ꠝꠣꠕꠣ ꠇꠣꠐꠤꠀ ꠀꠘꠣꠞ ꠟꠣꠉꠤ। ꠎꠟ꠆ꠟꠣꠖꠦ ꠉꠤꠀ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠛꠘ꠆ꠖꠤ ꠢꠎꠞꠔ ꠄꠢꠤꠀꠞ ꠝꠣꠕꠣ ꠇꠣꠐꠤꠀ ꠄꠇ ꠕꠣꠟꠅ ꠇꠞꠤ ꠟꠁꠀ ꠀꠁꠟ। ꠞꠣꠎꠣꠄ ꠁ ꠕꠣꠟ ꠅꠃ ꠙꠥꠠꠤꠞ ꠀꠔꠅ ꠖꠤꠟꠦ, ꠔꠣꠁ ꠘꠤꠀ ꠔꠣꠁꠞ ꠝꠣʼꠞ ꠉꠦꠍꠦ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK6_29","071_6_29","MRK","6","29","29","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠁ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠎꠦꠟ ꠕꠘꠦ ꠔꠣꠘ ꠟꠣꠡ ꠘꠤꠀ ꠖꠣꠚꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_30","071_6_30","MRK","6","30","30","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠄ ꠔꠛꠟꠤꠉ ꠕꠘꠦ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ, ꠔꠛꠟꠤꠉꠅ ꠉꠤꠀ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠍꠂꠘ, ꠇꠤꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK6_31","071_6_31","MRK","6","31","31","ꠅꠃ ꠡꠝꠄ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠅꠀ-ꠎꠣꠅꠀꠔ ꠕꠣꠇꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠥꠘꠥ ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠞꠅ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠟꠣ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠀꠁꠀ ꠕꠥꠠꠣ ꠎꠤꠞꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK6_32","071_6_32","MRK","6","32","32","ꠇꠁꠀ ꠘꠣꠅꠔ ꠃꠑꠤꠀ ꠄꠇ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_33","071_6_33","MRK","6","33","33","ꠄꠞꠣꠞꠦ ꠎꠣꠅꠀꠔ ꠖꠦꠈꠤꠀ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠌꠤꠘꠤꠟꠤꠟꠣ, ꠔꠦꠃ ꠄꠞꠣ ꠙꠃꠍꠣꠞ ꠀꠉꠦꠃ ꠀꠡ-ꠙꠣꠡꠞ ꠉꠣꠃꠀꠁꠘ ꠕꠣꠇꠤ ꠝꠣꠘꠥꠡ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠢꠘꠅ ꠙꠃꠍꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_34","071_6_34","MRK","6","34","34","ꠁꠍꠣ ꠘꠣꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀꠃ ꠖꠦꠈꠟꠣ, ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠛꠣꠞ ꠌꠣꠁꠞꠣ। ꠖꠦꠈꠤꠀ ꠄꠞꠣꠞ ꠛꠣꠄ ꠔꠣꠘ ꠛꠠ ꠖꠞꠖ ꠢꠣꠝꠣꠁꠟ। ꠄꠞꠣ ꠀꠍꠤꠟ ꠀ-ꠞꠣꠈꠣꠟꠤ ꠝꠦꠠꠣꠞ ꠟꠣꠈꠣꠘ। ꠅꠃ ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠛꠃꠔ ꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_35","071_6_35","MRK","6","35","35","ꠢꠣꠁꠘ꠆ꠎꠣ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁꠈꠣꠘ ꠈꠥꠛ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣ, ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣꠅ ꠅꠁꠉꠦꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("MK6_36","071_6_36","MRK","6","36","36","ꠔꠦ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ, ꠄꠞꠣ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠅꠔꠣ ꠉꠣꠃꠀꠁꠘ꠆ꠔꠅ ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠟꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MK6_37","071_6_37","MRK","6","37","37","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠃ ꠄꠞꠣꠞ ꠈꠣꠘꠤꠞ ꠁꠘ꠆ꠔꠦꠎꠣꠝ ꠇꠞꠅ।” ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠖꠥꠁ-ꠡ ꠖꠤꠘꠣꠞꠞ ꠈꠣꠘꠤ ꠟꠁꠀ ꠀꠘꠤꠀ ꠄꠞꠣꠞꠦ ꠈꠣꠅꠀꠁꠔꠣꠝ ꠘꠤ?” ꠖꠥꠁ-ꠡ ꠖꠤꠘꠣꠞ ꠔ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠎꠣꠞ ꠐꠦꠇꠣꠞ ꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("MK6_38","071_6_38","MRK","6","38","38","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠌꠣꠁꠀ ꠖꠦꠈꠅ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠤ ꠙꠞꠤꠝꠣꠘ ꠞꠥꠐꠤ ꠀꠍꠦ।” ꠔꠣꠞꠣ ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠞ ꠖꠥꠁꠐꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK6_39","071_6_39","MRK","6","39","39","ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠃ ꠊꠣꠡꠞ ꠃꠙꠞꠦ ꠟꠣꠁꠘ ꠗꠞꠣꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠛꠅꠀꠁ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK6_40","071_6_40","MRK","6","40","40","ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠄꠇ-ꠡ ꠎꠘ ꠇꠞꠤ ꠇꠣꠔꠣꠞ ꠛꠣꠘ꠆ꠖꠤꠀ ꠙꠁꠘ꠆ꠌꠣꠡ ꠇꠣꠔꠣꠞ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_41","071_6_41","MRK","6","41","41","ꠁꠍꠣꠄ ꠢꠃ ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠞ ꠖꠥꠁꠐꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍ ꠀꠔꠅ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠀꠞꠡꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ, ꠝꠣꠘꠡꠞꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠞꠥꠐꠤ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠀꠔꠅ ꠖꠤꠟꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠍ ꠖꠥꠁꠐꠣꠅ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_42","071_6_42","MRK","6","42","42","ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_43","071_6_43","MRK","6","43","43","ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠛꠣꠠꠔꠤ ꠞꠥꠐꠤ ꠀꠞ ꠝꠣꠍꠞ ꠐꠥꠇꠞꠣꠁꠘ ꠘꠤꠀ ꠛꠣꠞꠅꠐꠣ ꠐꠥꠇꠞꠤ ꠜꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_44","071_6_44","MRK","6","44","44","ꠁ ꠖꠟꠞ ꠝꠣꠎꠦ ꠈꠣꠟꠤ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡꠃ ꠙꠣꠌ ꠀꠎꠣꠞ ꠎꠘꠦ ꠛꠁꠀ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_45","071_6_45","MRK","6","45","45","ꠈꠣꠘꠤꠞ ꠛꠣꠖꠦꠃ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠔꠣꠉꠖꠣ ꠖꠤꠟꠣ, ꠔꠣꠞꠣ ꠘꠣꠅꠔ ꠇꠞꠤ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠛꠣꠄꠔ-ꠍꠄꠖꠣ ꠉꠣꠃꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ, ꠔꠣꠁꠘ ꠅꠘꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_46","071_6_46","MRK","6","46","46","ꠝꠣꠘꠥꠡ ꠛꠤꠖꠣꠄ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠖꠥꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_47","071_6_47","MRK","6","47","47","ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠘꠣꠅ ꠀꠅꠞꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠁꠍꠣ ꠄꠇꠟꠣ ꠢꠥꠇꠘꠣꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_48","071_6_48","MRK","6","48","48","ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠃꠚꠔꠣ ꠛꠣꠔꠣꠡꠞ ꠝꠣꠎꠦ ꠄꠞꠣ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠇꠞꠤ ꠖꠣꠠ ꠛꠣꠁꠞꠣ। ꠙꠔꠣꠛꠣꠟꠣ ꠁꠍꠣꠄ ꠅꠃ ꠀꠅꠞꠞ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠤꠀ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠣꠟꠣꠛꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠞ ꠅꠁꠀ ꠀꠉꠦꠖꠤ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_49","071_6_49","MRK","6","49","50","ꠔꠣꠘꠞꠦ ꠀꠅꠞꠞ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠅꠀꠔ ꠖꠦꠈꠤꠀ, ꠜꠥꠔ ꠝꠘꠅ ꠇꠞꠤꠀ ꠒꠞꠣꠁꠀ ꠄꠞꠣ ꠢꠇꠟꠦ ꠌꠤꠇ-ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠟꠣꠉꠣꠁꠟꠣ। ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ, ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠅ, ꠁ ꠔ ꠀꠝꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK6_51","071_6_51","MRK","6","51","51","ꠔꠣꠁꠘ ꠀꠁꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠘꠣꠅꠔ ꠃꠑꠔꠦꠃ ꠃꠚꠔꠣ ꠛꠣꠔꠣꠡ ꠖꠝ ꠟꠁꠟꠤꠟ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠄꠞꠣ ꠀꠌꠣꠘꠇ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_52","071_6_52","MRK","6","52","52","ꠅꠁꠟꠦ ꠀꠉꠞ ꠢꠃ ꠞꠥꠐꠤ-ꠝꠣꠍꠞ ꠉꠣꠁꠛꠤ ꠈꠣꠘꠤꠞ ꠜꠦꠖ ꠄꠞꠣ ꠛꠥꠎꠟꠣ ꠘꠣ। ꠄꠞꠣꠞ ꠖꠤꠟꠞ ꠖꠥꠀꠞ ꠔ ꠛꠘ꠆ꠖ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK6_53","071_6_53","MRK","6","53","53","ꠀꠅꠞ ꠙꠣꠠꠤ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠄꠞꠣ ꠉꠤꠘꠦꠡꠞꠔ ꠄꠟꠣꠇꠣꠔ ꠀꠁꠀ ꠘꠣꠅ ꠜꠤꠠꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK6_54","071_6_54","MRK","6","54","55","ꠘꠣꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠔꠦꠃ ꠔꠣꠘꠦ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠡꠦ ꠌꠤꠘꠤꠟꠤꠟꠣ, ꠀꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠖꠃꠠꠣ-ꠖꠃꠠꠤ ꠟꠣꠉꠣꠁꠟꠣ। ꠖꠃꠠꠣꠁꠀ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞꠦ ꠙꠟꠅꠖꠤ ꠛꠁꠀ ꠀꠘꠤꠀ, ꠔꠣꠁꠘ ꠎꠦ ꠎꠣꠉꠣꠔ ꠀꠍꠟꠣ ꠅꠃ ꠎꠣꠉꠣꠔ ꠟꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK6_56","071_6_56","MRK","6","56","56","ꠐꠣꠃꠘꠅ ꠛꠣ ꠉꠣꠃꠔ, ꠅꠟ꠆ꠟꠤꠄ-ꠉꠟ꠆ꠟꠤꠄ ꠔꠣꠁꠘ ꠎꠦꠘꠅꠃ ꠔꠡꠞꠤꠚ ꠘꠤꠔꠣ, ꠅꠘꠅꠃ ꠝꠣꠘꠡꠦ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞꠦ ꠀꠘꠤꠀ ꠛꠣꠎꠣꠞꠅ ꠖꠟꠣ ꠇꠞꠔꠣ। ꠀꠞ ꠔꠣꠘꠞꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤꠀ ꠇꠁꠔꠣ, ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠦ ꠎꠣꠘꠥ ꠔꠣꠘ ꠌꠣꠖ꠆ꠖꠞꠞ ꠇꠥꠘꠣꠈꠣꠘꠅ ꠍꠁꠔꠣ ꠙꠣꠞꠂꠘ। ꠀꠞ ꠎꠦꠞꠣ ꠍꠁꠔꠣ, ꠢꠣꠍꠣꠃ ꠄꠞꠣꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠅꠁꠎꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("MK7_1","071_7_1","MRK","7","1","1","ꠛꠣꠖꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠇꠄꠎꠘ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK7_2","071_7_2","MRK","7","2","2","ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠁꠍꠣꠞ ꠇꠄꠎꠘ ꠃꠝ꠆ꠝꠔꠦ ꠀꠔ ꠘꠣ ꠗꠁꠀ ꠄꠝꠘꠦꠃ ꠈꠣꠘꠤꠔ ꠛꠁꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK7_3","071_7_3","MRK","7","3","3","ꠀꠍꠟꠦ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠛꠣꠔꠣꠁꠟ ꠞꠍꠥꠝꠔ ꠝꠣꠚꠤꠇ, ꠢꠇ꠆ꠇꠟ ꠁꠢꠥꠖꠤ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦꠅ ꠅꠎꠥ ꠘꠣ ꠇꠞꠤꠀ ꠇꠥꠘꠥ ꠈꠣꠘꠤ ꠈꠣꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK7_4","071_7_4","MRK","7","4","4","ꠛꠣꠎꠣꠞ-ꠀꠐ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠀꠘꠟꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠘꠣ ꠇꠞꠤꠀ ꠝꠥꠈꠅ ꠖꠦꠁꠘ ꠘꠣ, ꠕꠣꠟ-ꠛꠣꠡꠘ ꠗꠁꠀ ꠍꠣꠚ-ꠍꠥꠔꠞꠣ ꠇꠞꠣ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠃꠔ ꠞꠤꠔꠤ-ꠞꠦꠅꠀꠎ ꠔꠣꠞꠣ ꠝꠣꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("MK7_5","071_7_5","MRK","7","5","5","ꠄꠞꠖꠣꠄ ꠅꠃ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠛꠣꠔꠣꠁꠟ ꠞꠍꠥꠝꠔ ꠇꠦꠘꠦ ꠝꠣꠘꠂꠘ ꠘꠣ? ꠔꠣꠞꠣ ꠔ ꠘꠣꠙꠣꠇ ꠀꠔꠦ ꠈꠣꠘꠤ ꠈꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK7_6","071_7_6","MRK","7","6","6","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠔ ꠜꠘ꠆ꠒ! ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠑꠤꠇꠃ ꠇꠁꠍꠂꠘ, ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠝꠥꠈ ꠖꠤꠀ ꠈꠣꠟꠤ ꠀꠝꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠦ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠀꠝꠣ ꠕꠘꠦ ꠛꠃꠔ ꠖꠥꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("MK7_7","071_7_7","MRK","7","7","7","ꠔꠣꠞꠣ ꠢꠥꠖꠣꠞ ꠈꠣꠝꠈꠣ ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠔꠣꠟꠤꠝ ꠅꠇꠟ ꠔ ꠝꠣꠘꠡꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠘꠉꠠꠣ ꠡꠞꠤꠅꠔ। ");
INSERT INTO syls_vpl VALUES ("MK7_8","071_7_8","MRK","7","8","8","ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠛꠣꠖ ꠖꠤꠀ, ꠝꠣꠘꠡꠞ ꠛꠣꠘꠣꠁꠟ ꠞꠍꠥꠝꠔ ꠀꠝꠟ ꠇꠞꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK7_9","071_7_9","MRK","7","9","9","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠢꠥꠇꠥꠝ ꠛꠣꠖ ꠖꠤꠀ, ꠘꠤꠎꠞ ꠝꠘꠉꠠꠣ ꠞꠍꠥꠝꠔ ꠇꠣꠁꠝ ꠇꠞꠣꠞ ꠗꠣꠘ꠆ꠖꠣ ꠔ ꠀꠙꠘꠣꠞꠣ ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠞꠤꠃ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK7_10","071_7_10","MRK","7","10","10","ꠎꠦꠟꠣ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠇꠁꠍꠂꠘ, ꠝꠣ-ꠛꠣꠛꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠙꠘ ꠝꠣ-ꠛꠣꠚꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠄ, ꠔꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK7_11","071_7_11","MRK","7","11","11","ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠣ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠇꠁꠟꠣꠄ, ꠀꠝꠣꠞ ꠎꠦꠔꠣ ꠍꠣꠝꠣꠘꠣ ꠖꠤꠀ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠔꠣꠝ ꠀꠍꠤꠟ, ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠟꠣꠁꠍꠤ, ");
INSERT INTO syls_vpl VALUES ("MK7_12","071_7_12","MRK","7","12","12","ꠔꠦ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞ ꠟꠣꠉꠤ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠣ ꠟꠣꠉꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK7_13","071_7_13","MRK","7","13","13","ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠙꠘꠣꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠘꠉꠠꠣ ꠘꠤꠅꠝ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠛꠣꠔꠤꠟ ꠇꠞꠤꠟꠤꠍꠂꠘ। ꠁꠈꠣꠘ ꠛꠣꠖꠦꠅ ꠀꠙꠘꠣꠞꠣ ꠅꠃꠟꠣ ꠀꠞꠅ ꠛꠃꠔ ꠇꠣꠝ ꠇꠞꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK7_14","071_7_14","MRK","7","14","14","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠘꠤꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟꠦ ꠀꠝꠣꠞ ꠇꠕꠣ ꠈꠤꠀꠟ ꠇꠞꠤ ꠢꠥꠘꠃꠇ꠆ꠇꠣ ꠀꠞ ꠛꠥꠎꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("MK7_15","071_7_15","MRK","7","15","16","ꠛꠣꠁꠞꠦ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡ ꠝꠣꠘꠡꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠄ, ꠁꠔꠣꠄ ꠔ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ ꠘꠣ। ꠛꠞꠋ ꠝꠣꠘꠡꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠛꠣꠞꠅꠄ, ꠅꠔꠣꠄꠃ ꠔꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK7_17","071_7_17","MRK","7","17","17","ꠛꠄꠀꠘ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠤꠀ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠟꠣ, ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠄꠞ ꠝꠣꠘꠤ ꠎꠤꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK7_18","071_7_18","MRK","7","18","18","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠅꠃꠟꠣꠃ ꠛꠦꠀꠇ꠆ꠇꠟ ꠘꠤ? ꠔꠥꠝꠞꠣ ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠛꠣꠞꠦ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡ ꠝꠣꠘꠡꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠄ, ꠁꠔꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK7_19","071_7_19","MRK","7","19","19","ꠁꠔꠣ ꠔ ꠔꠣꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠄ ꠘꠣ, ꠈꠣꠟꠤ ꠙꠦꠐꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠄ, ꠀꠞ ꠙꠦꠐ ꠕꠣꠇꠤ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠞ ꠅꠁ ꠎꠣꠄ।” ꠁꠍꠣꠄ ꠅꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠛꠥꠎꠣꠁꠟꠣ, ꠇꠥꠘꠥꠎꠣꠔ ꠈꠣꠘꠤꠃ ꠘꠣꠙꠣꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK7_20","071_7_20","MRK","7","20","20","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠣꠘꠡꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠛꠣꠞꠅꠄ, ꠅꠔꠣꠄꠃ ꠝꠣꠘꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MK7_21","071_7_21","MRK","7","21","21","ꠝꠣꠘꠡꠞ ꠖꠤꠟ ꠕꠣꠇꠤꠃ ꠔ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠇꠥ-ꠌꠤꠘ꠆ꠔꠣ ꠀꠄ; ꠎꠤꠘꠣ, ꠌꠥꠞꠤ, ꠈꠥꠘ, ");
INSERT INTO syls_vpl VALUES ("MK7_22","071_7_22","MRK","7","22","22","ꠟꠥꠜ-ꠟꠣꠟꠌ, ꠙꠞꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠗꠣꠘ꠆ꠖꠣ, ꠍꠟ-ꠌꠔꠥꠞꠤ, ꠛꠖꠝꠣꠁꠡꠤ, ꠛꠖ-ꠘꠎꠞ, ꠁꠋꠡꠣ-ꠘꠤꠘ꠆ꠖꠣ, ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠀꠞ ꠡꠄꠔꠣꠘꠤ ꠛꠣꠞꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MK7_23","071_7_23","MRK","7","23","23","ꠅꠃ ꠔꠣꠝꠣꠝ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠝꠣꠘꠡꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK7_24","071_7_24","MRK","7","24","24","ꠛꠣꠖꠦ ꠁꠍꠣ ꠅꠃ ꠄꠟꠣꠇꠣ ꠕꠘꠦ ꠡꠤꠞꠤꠀ ꠖꠦꠡꠞ ꠡꠥꠞ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠔꠡꠞꠤꠚ ꠘꠤꠟꠣꠉꠤ। ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠁꠘ ꠄꠇ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠟꠥꠇꠣꠁ ꠞꠁꠟꠣ, ꠌꠣꠁꠟꠣ ꠝꠣꠘꠡꠦ ꠎꠣꠘꠥ ꠘꠣ ꠎꠣꠘꠂꠘ ꠔꠣꠁꠘ ꠀꠁꠍꠂꠘ ꠇꠞꠤ। ꠅꠁꠟꠦ ꠔꠣꠘ ꠈꠛꠞ ꠞꠐꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK7_25","071_7_25","MRK","7","25","25","ꠢꠘꠅ ꠄꠇ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞ ꠙꠥꠠꠤꠞꠦ ꠜꠥꠔꠦ ꠗꠞꠣꠄ, ꠁꠍꠣꠄ ꠔꠡꠞꠤꠚ ꠀꠘꠍꠂꠘ ꠢꠥꠘꠤꠀ ꠅꠃ ꠛꠦꠐꠤꠄ, ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠁꠀ ꠔꠣꠘ ꠙꠣꠅꠔ ꠙꠠꠟ। ");
INSERT INTO syls_vpl VALUES ("MK7_26","071_7_26","MRK","7","26","26","ꠁ ꠛꠦꠐꠤꠞ ꠛꠣꠠꠤ ꠡꠤꠞꠤꠀ ꠖꠦꠡꠞ ꠚꠂꠘꠤꠇꠤꠀ ꠄꠟꠣꠇꠣꠔ, ꠅꠁꠟꠦ ꠝꠣꠔꠤꠔ ꠁꠃꠘꠣꠘꠤ ꠜꠣꠡꠣꠄ। ꠔꠣꠁ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠜꠥꠔꠞ ꠇꠛꠎꠣ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠙꠥꠠꠤꠉꠥꠞꠦ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK7_27","071_7_27","MRK","7","27","27","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠉꠦ ꠘꠤꠎꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠦ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠃꠇ꠆ꠇꠣ, ꠘꠤꠎꠞ ꠍꠣꠛꠣꠟꠞ ꠈꠣꠘꠤ ꠇꠥꠇꠞꠞ ꠍꠣꠝꠘꠦ ꠚꠣꠟꠣꠘꠤ ꠑꠤꠇ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK7_28","071_7_28","MRK","7","28","28","ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠎꠤꠅꠄ ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠇꠕꠣꠃ ꠑꠤꠇ, ꠅꠁꠟꠦ ꠘꠤꠎꠞ ꠍꠣꠛꠣꠟꠞ ꠈꠣꠘꠤꠞ ꠎꠦꠔꠣ ꠉꠥꠠꠣ-ꠉꠣꠠꠣ ꠉꠣꠟꠣꠛꠣꠄ ꠙꠠꠦ, ꠁꠔꠣ ꠔ ꠇꠥꠇꠞꠦ ꠈꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK7_29","071_7_29","MRK","7","29","29","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔ ꠈꠣꠐꠤ ꠝꠣꠔꠃ ꠝꠣꠔꠍ। ꠔꠦ ꠎꠣꠅ, ꠉꠤꠀ ꠖꠦꠈꠅ, ꠜꠥꠔꠦ ꠔꠥꠝꠣꠞ ꠙꠥꠠꠤꠞꠦ ꠍꠣꠠꠤꠀ ꠉꠦꠍꠦꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK7_30","071_7_30","MRK","7","30","30","ꠢꠣꠍꠣꠃ ꠛꠦꠐꠤꠄ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠖꠦꠈꠟ, ꠔꠣꠁꠞ ꠙꠥꠠꠤ ꠜꠣꠟꠣ ꠅꠁꠀ ꠛꠤꠍꠘꠣꠔ ꠢꠥꠔꠤꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK7_31","071_7_31","MRK","7","31","31","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠡꠥꠞ ꠄꠟꠣꠇꠣ ꠕꠘꠦ ꠍꠤꠖꠘ ꠐꠣꠃꠘ ꠅꠁꠀ, ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠖꠤꠇꠣꠙꠟꠤ ꠄꠟꠣꠇꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK7_32","071_7_32","MRK","7","32","32","ꠅꠘꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠘꠡꠦ ꠄꠇ ꠈꠣꠟꠥꠀ ꠔꠥꠔꠟꠣ ꠛꠦꠐꠣꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠘꠤꠀ ꠝꠤꠘꠔ ꠟꠣꠉꠣꠁꠟꠣ, ꠔꠣꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK7_33","071_7_33","MRK","7","33","33","ꠔꠣꠁꠘ ꠄꠞꠦ ꠝꠣꠘꠡꠞ ꠜꠤꠠ ꠕꠘꠦ ꠛꠣꠞꠦ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠘꠤꠀ, ꠔꠣꠞ ꠖꠥꠁꠅ ꠇꠣꠘꠅ ꠔꠣꠘ ꠀꠔꠞ ꠀꠋꠉꠥꠁꠟ ꠢꠣꠞꠣꠁꠟꠣ, ꠔꠣꠘ ꠝꠥꠈꠞ ꠍꠦꠚ ꠟꠣꠉꠣꠁꠀ ꠔꠣꠞ ꠎꠤꠚꠞꠣ ꠀꠔꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK7_34","071_7_34","MRK","7","34","34","ꠀꠞ ꠃꠙꠞꠦ ꠀꠍꠝꠣꠘꠦꠖꠤ ꠌꠣꠁꠀ ꠟꠣꠝ꠆ꠛꠣ ꠇꠞꠤ ꠡꠣꠡ ꠚꠣꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁꠚꠚꠣꠔꠣ,” ꠝꠣꠘꠤ, “ꠈꠥꠟꠤ ꠎꠣꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MK7_35","071_7_35","MRK","7","35","35","ꠟꠉꠦ ꠟꠉꠦꠃ ꠛꠦꠐꠣꠞ ꠇꠣꠘ ꠈꠥꠟꠤꠉꠦꠟ। ꠔꠥꠔꠟꠣꠝꠤ ꠍꠣꠠꠤ ꠉꠦꠟ, ꠢꠦ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠝꠣꠔꠣ ꠗꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MK7_36","071_7_36","MRK","7","36","36","ꠢꠦꠡꠦ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠈꠛꠞꠖꠣꠞ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠎꠔ ꠛꠦꠡꠤ ꠘꠣ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠅꠔ ꠛꠦꠡ ꠇꠞꠤ ꠁꠔꠣ ꠞꠐꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK7_37","071_7_37","MRK","7","37","37","ꠔꠣꠞꠣ ꠀꠌꠣꠘꠇ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠔ ꠢꠇꠟ ꠇꠣꠝꠃ ꠈꠥꠛ ꠘꠤꠈꠥꠔ ꠇꠞꠤ ꠇꠞꠂꠘ। ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠔꠣꠁꠘ ꠈꠣꠟꠥꠀꠞꠦ ꠢꠥꠘꠣꠞ ꠡꠇ꠆ꠔꠤ, ꠀꠞ ꠛꠥꠛꠣꠞꠦ ꠝꠣꠔꠤꠛꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK8_1","071_8_1","MRK","8","1","1","ꠛꠣꠖꠦ ꠀꠞꠇꠛꠣꠞ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠖꠟꠣ ꠅꠁꠟꠣ। ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘꠥ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ ꠘꠣ ꠕꠣꠇꠣꠄ, ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠗꠣꠞꠅ ꠘꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK8_2","071_8_2","MRK","8","2","2","“ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠠ ꠖꠞꠖ ꠟꠣꠉꠦꠞ, ꠀꠁꠎ ꠔꠤꠘ ꠖꠤꠘ ꠗꠞꠤ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠂꠘ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠔꠣꠞꠣꠞ ꠈꠣꠘꠤꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("MK8_3","071_8_3","MRK","8","3","3","ꠅꠃ ꠢꠣꠟꠔꠦ ꠄꠞꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠇꠞꠤ ꠛꠣꠠꠤꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠦ, ꠁꠔꠣ ꠙꠕꠅꠃ ꠛꠦꠃꠡ ꠅꠁꠎꠤꠛꠣ, ꠄꠞꠣ ꠇꠦꠃ ꠇꠦꠃ ꠔ ꠛꠃꠔ ꠖꠥꠞꠁ ꠕꠣꠇꠤ ꠀꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK8_4","071_8_4","MRK","8","4","4","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠘꠤꠞꠣꠁ-ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠇꠦ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠅꠔ ꠞꠥꠐꠤ ꠎꠥꠉꠣꠁꠀ ꠄꠞꠣꠞꠦ ꠈꠣꠅꠀꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("MK8_5","071_8_5","MRK","8","5","5","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠥꠐꠤ ꠇꠄꠈꠣꠘ ꠀꠍꠦ?” ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠡꠣꠔꠈꠣꠘ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK8_6","071_8_6","MRK","8","6","6","ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠣꠐꠤꠔ ꠛꠁꠎꠣꠁꠘ।” ꠇꠁꠀ ꠞꠥꠐꠤ ꠡꠣꠔꠅꠈꠣꠘ ꠘꠤꠀ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ ꠅꠈꠘꠣꠁꠘ ꠍꠤꠠꠤꠟꠣ, ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠤꠀ ꠛꠣꠐꠤꠀ ꠖꠦꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK8_7","071_8_7","MRK","8","7","7","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠢꠥꠞꠥ ꠢꠥꠞꠥ ꠇꠄꠐꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍꠅ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠅꠃ ꠝꠣꠍꠞ ꠟꠣꠉꠤ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ, ꠀꠞ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK8_8","071_8_8","MRK","8","8","8","ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠁꠟꠣ। ꠈꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠞꠁꠍꠤꠟ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠅꠔꠣ ꠖꠟꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠡꠣꠔ ꠐꠥꠇꠞꠤ ꠜꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK8_9","071_8_9","MRK","8","9","9","ꠁ ꠖꠟꠞ ꠝꠣꠎꠦ ꠈꠣꠟꠤ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡꠃ ꠅꠘꠥꠝꠣꠘ ꠌꠣꠁꠞ ꠀꠎꠣꠞ ꠎꠘꠦ ꠈꠣꠁꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("MK8_10","071_8_10","MRK","8","10","10","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠘꠣꠅꠔ ꠇꠞꠤ ꠖꠣꠟꠝꠣꠘꠥꠕꠣ ꠎꠤꠟꠣꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK8_11","071_8_11","MRK","8","11","11","ꠅꠘꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠔꠣꠘ ꠟꠉꠦ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠟꠣꠉꠣꠁꠟꠣ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠎꠣꠌꠣꠁ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠀꠍꠝꠣꠘꠤ ꠇꠥꠘꠥ ꠝꠥꠎꠦꠎꠣ ꠖꠦꠈꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK8_12","071_8_12","MRK","8","12","12","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠟꠣꠝ꠆ꠛꠣ ꠇꠞꠤ ꠡꠣꠡ ꠚꠣꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠦ ꠈꠣꠟꠤ ꠝꠥꠎꠦꠎꠣ ꠔꠥꠇꠣꠁꠘ ꠇꠦꠘꠦ? ꠀꠝꠤ ꠢꠇ ꠇꠕꠣ ꠇꠁꠀꠞ, ꠄꠞꠣꠞꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠝꠥꠎꠦꠎꠣ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK8_13","071_8_13","MRK","8","13","13","ꠇꠁꠀ ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠉꠦꠟꠣ, ꠀꠞ ꠘꠣꠅꠔ ꠃꠑꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK8_14","071_8_14","MRK","8","14","14","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠟꠉꠦ ꠇꠞꠤ ꠞꠥꠐꠤ ꠘꠤꠔꠦ ꠚꠣꠃꠞꠤꠟꠤꠟꠣ। ꠘꠣꠅꠞ ꠝꠣꠎꠦ ꠄꠞꠣꠞ ꠟꠉꠦ ꠈꠣꠟꠤ ꠄꠇꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK8_15","071_8_15","MRK","8","15","15","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤꠔꠣꠁꠘ ꠢꠥꠡꠤꠀꠞ ꠅꠅ, ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖ ꠀꠞ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠈꠣꠝꠤꠞ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK8_16","071_8_16","MRK","8","16","16","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠟꠉꠦ ꠇꠞꠤ ꠞꠥꠐꠤ ꠘꠣ ꠀꠘꠣꠄ ꠔꠣꠁꠘ ꠝꠘꠅꠟꠄ ꠅꠈꠣꠘ ꠇꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK8_17","071_8_17","MRK","8","17","17","ꠅꠁꠟꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠤꠔꠣ ꠝꠣꠔꠤꠞꠣ, ꠁꠍꠣꠄ ꠁꠈꠣꠘ ꠛꠥꠎꠤꠀ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤꠔꠣꠁꠘ ꠇꠦꠘꠦ ꠇꠁꠞꠣꠄ, ꠞꠥꠐꠤ ꠀꠘꠍ ꠘꠣ ꠇꠞꠤ ꠀꠝꠤ ꠁꠈꠣꠘ ꠇꠁꠍꠤ? ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠅꠈꠘꠅ ꠇꠥꠘ꠆ꠔꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠇꠥꠘ꠆ꠔꠣꠃ ꠛꠥꠎ ꠘꠣ ꠘꠤ? ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠅꠁꠉꠦꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MK8_18","071_8_18","MRK","8","18","18","ꠔꠥꠝꠞꠣꠞ ꠌꠃꠈ ꠕꠣꠇꠔꠦꠅ ꠖꠦꠈꠞꠣꠄ ꠘꠣ ꠘꠤ? ꠇꠣꠘ ꠕꠣꠇꠔꠦꠅ ꠢꠥꠘꠞꠣꠄ ꠘꠣ ꠘꠤ? ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠙꠠꠦꠞ ꠘꠣ ꠘꠤ, ");
INSERT INTO syls_vpl VALUES ("MK8_19","071_8_19","MRK","8","19","19","ꠎꠦꠛꠟꠣ ꠀꠝꠤ ꠙꠣꠌ ꠀꠎꠣꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠈꠣꠟꠤ ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤ ꠍꠤꠠꠤꠍꠟꠣꠝ, ꠅꠃ ꠝꠣꠘꠡꠦ ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠔ ꠐꠥꠇꠞꠤ ꠉꠥꠠꠣ-ꠉꠣꠠꠣ ꠖꠟꠣ ꠇꠞꠍꠟꠣꠄ?” ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠛꠣꠞꠅ ꠐꠥꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK8_20","071_8_20","MRK","8","20","20","ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠌꠣꠁꠞ ꠀꠎꠣꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠡꠣꠔꠈꠣꠘ ꠞꠥꠐꠤ ꠍꠤꠠꠤꠍꠟꠣꠝ, ꠝꠣꠘꠡꠦ ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠄ ꠐꠥꠇꠞꠤ ꠖꠟꠣ ꠇꠞꠍꠟꠣꠄ?” ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠡꠣꠔ ꠐꠥꠇꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK8_21","071_8_21","MRK","8","21","21","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠄꠞꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠟꠣꠄ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK8_22","071_8_22","MRK","8","22","22","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠛꠣꠄꠔ-ꠍꠄꠖꠣ ꠉꠣꠃꠔ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠘꠡꠦ ꠄꠇ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠘꠤꠀ ꠇꠁꠟ ꠛꠦꠐꠣꠉꠥꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK8_23","071_8_23","MRK","8","23","23","ꠁꠍꠣꠄ ꠅꠃ ꠛꠦꠐꠣꠞ ꠀꠔꠅ ꠗꠞꠤ ꠉꠣꠃꠞ ꠛꠣꠞꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠔꠣꠘ ꠝꠥꠈꠞ ꠍꠦꠚ ꠛꠦꠐꠣꠞ ꠌꠈꠥꠔ ꠟꠣꠉꠣꠁꠀ ꠔꠣꠞ ꠉꠔꠞꠅ ꠀꠔ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠤ ꠇꠥꠘ꠆ꠔꠣ ꠖꠦꠈꠞꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK8_24","071_8_24","MRK","8","24","24","ꠛꠦꠐꠣꠄ ꠌꠃꠈ ꠈꠥꠟꠤꠀ ꠌꠣꠁꠀ ꠇꠁꠟ, “ꠎꠤꠅꠄ ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠔ ꠝꠣꠘꠥꠡ ꠖꠦꠈꠞꠣꠝ, ꠅꠁꠟꠦ ꠁꠔꠣꠞꠦ ꠉꠣꠍꠞ ꠟꠣꠈꠣꠘ ꠟꠣꠉꠦꠞ, ꠄꠞꠣ ꠀꠐꠣ-ꠃꠐꠤ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK8_25","071_8_25","MRK","8","25","25","ꠔꠦꠃ ꠁꠍꠣꠄ ꠀꠞꠇꠛꠣꠞ ꠔꠣꠞ ꠌꠈꠥꠞ ꠃꠙꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠟꠦ, ꠢꠦ ꠜꠣꠟꠣ ꠇꠞꠤ ꠌꠣꠁꠟ ꠀꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠖꠦꠈꠟ। ");
INSERT INTO syls_vpl VALUES ("MK8_26","071_8_26","MRK","8","26","26","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠔꠣꠞ ꠛꠣꠠꠤꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠛꠣꠄꠔ-ꠍꠄꠖꠣ ꠉꠣꠃꠔ ꠀꠞ ꠎꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK8_27","071_8_27","MRK","8","27","27","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠇꠂꠍꠞꠤꠀ-ꠚꠤꠟꠤꠙꠤ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠉꠣꠃꠀꠁꠘ꠆ꠔꠅ ꠉꠦꠟꠣ। ꠙꠕꠅ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠀꠝꠤ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK8_28","071_8_28","MRK","8","28","28","ꠄꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠇꠦꠃ ꠇꠄ, ꠀꠙꠘꠦ ꠢꠎꠞꠔ ꠄꠢꠤꠀ। ꠇꠦꠃ ꠇꠄ ꠁꠟꠤꠀꠍ ꠘꠛꠤ। ꠇꠦꠃ ꠇꠦꠃ ꠇꠂꠘ, ꠀꠙꠘꠦ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠘꠛꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK8_29","071_8_29","MRK","8","29","29","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞ, ꠀꠝꠤ ꠇꠦ?” ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK8_30","071_8_30","MRK","8","30","30","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK8_31","071_8_31","MRK","8","31","31","ꠛꠣꠖꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠅꠃ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠁꠟꠣ, “ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦ ꠛꠃꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠙꠥꠀꠘꠤ ꠟꠣꠉꠛ। ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ, ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ, ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦꠅ ꠀꠝꠣꠞꠦ ꠝꠣꠘꠔꠣ ꠘꠣꠄ। ꠀꠝꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK8_32","071_8_32","MRK","8","32","32","ꠔꠣꠁꠘ ꠈꠥꠛ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠇꠞꠤ ꠁꠔꠣ ꠇꠁꠟꠣ। ꠄꠞꠖꠣꠄ ꠙꠤꠔꠞꠦ ꠔꠣꠘꠞꠦ ꠀꠟꠉꠣ ꠢꠞꠣꠁꠀ ꠘꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠡꠣꠛꠗꠣꠘ, ꠁꠟꠣ ꠝꠣꠔ ꠝꠣꠔꠂꠘ ꠘꠣ ꠎꠣꠘꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK8_33","071_8_33","MRK","8","33","33","ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠛꠣꠄ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠀ ꠙꠤꠔꠞꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠗꠥꠞ ꠁꠛꠟꠤꠍ, ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉ! ꠔꠥꠁ ꠀꠟ꠆ꠟꠣꠁ ꠝꠥꠘꠡꠣꠞꠦ ꠛꠣꠖ ꠖꠤꠀ, ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK8_34","071_8_34","MRK","8","34","34","ꠛꠣꠖꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠀꠝ ꠝꠣꠘꠡꠞꠦꠅ ꠔꠣꠘ ꠗꠣꠞꠅ ꠘꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠔꠞꠤꠇꠣꠄ ꠇꠦꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔꠦ ꠌꠣꠁꠟꠦ, ꠢꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠌꠟꠣ ꠛꠣꠖ ꠖꠦꠃꠇ। ꠔꠣꠞ ꠀꠙꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛ ꠛꠁꠀ ꠟꠁꠀ ꠀꠝꠣꠞ ꠈꠞꠦ ꠀꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MK8_35","071_8_35","MRK","8","35","35","ꠎꠦ ꠎꠘꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠡ꠆ꠛꠣꠗꠤꠘꠦ ꠌꠟꠔ ꠌꠣꠄ, ꠢꠦ ꠔꠣꠞ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠥꠀꠁꠟꠤꠛ। ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠄ, ꠢꠦ ꠔꠣꠞ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠛꠣꠌꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK8_36","071_8_36","MRK","8","36","36","ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠟꠤꠇ ꠛꠘꠤꠀꠅ ꠔꠣꠞ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠝꠣꠘꠤ ꠀꠈꠦꠞ ꠈꠥꠀꠁꠟꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠟ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MK8_37","071_8_37","MRK","8","37","37","ꠢꠦꠡꠦ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠦ ꠇꠥꠘ ꠗꠘ ꠛꠤꠟꠣꠁꠛ? ");
INSERT INTO syls_vpl VALUES ("MK8_38","071_8_38","MRK","8","38","38","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠁ ꠎꠝꠣꠘꠣꠞ ꠛꠦꠁꠝꠣꠘ ꠀꠞ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞ ꠝꠣꠎꠦ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠛꠣ ꠀꠝꠣꠞ ꠔꠣꠟꠤꠝꠞ ꠟꠣꠉꠤꠀ ꠝꠥꠈ ꠟꠥꠇꠣꠄ, ꠔꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠎꠦꠛꠟꠣ ꠙꠛꠤꠔ꠆ꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠟꠉꠦ ꠟꠁꠀ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤꠄ ꠎꠉꠔꠅ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤꠅ ꠄꠞꠣꠞꠦ ꠖꠦꠈꠟꠦ ꠝꠥꠈ ꠟꠥꠇꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK9_1","071_9_1","MRK","9","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠁꠘꠅ ꠁꠟꠣꠈꠣꠘ ꠇꠄꠎꠘ ꠀꠎꠤꠞ ꠀꠍꠂꠘ, ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤꠞꠦ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠘꠣ ꠖꠦꠈꠣꠞ ꠀꠉꠦ ꠝꠃꠔ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK9_2","071_9_2","MRK","9","2","2","ꠁꠈꠣꠘ ꠇꠅꠀꠞ ꠍꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠈꠣꠟꠤ ꠢꠎꠞꠔ ꠙꠤꠔꠞ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠟꠁꠀ ꠃꠌꠣ ꠄꠇ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠟꠣ। ꠅꠃ ꠔꠤꠘꠅ ꠎꠘꠞ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠍꠥꠞꠔ ꠛꠖꠟꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK9_3","071_9_3","MRK","9","3","3","ꠔꠣꠘ ꠚꠤꠘ꠆ꠘꠞ ꠟꠦꠛꠣꠍ ꠅꠔ ꠛꠦꠡꠤ ꠗꠟꠣ ꠌꠇꠌꠇꠣ ꠅꠁꠟ ꠎꠦꠘ, ꠖꠥꠘꠤꠀꠞ ꠇꠥꠘꠥ ꠗꠥꠙꠣꠄꠃ ꠁꠟꠣ ꠌꠇꠌꠇꠣ ꠇꠞꠤ ꠗꠅꠀꠞ ꠔꠣꠇ꠆ꠇꠔ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("MK9_4","071_9_4","MRK","9","4","4","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞꠦ ꠖꠦꠈꠟꠣ, ꠄꠞꠣ ꠀꠁꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_5","071_9_5","MRK","9","5","5","ꠔꠦꠃ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠔ ꠅꠘꠅ ꠀꠍꠤ, ꠈꠥꠛ ꠜꠣꠟꠣ ꠅꠁꠍꠦ। ꠀꠝꠞꠣ ꠔꠤꠘꠈꠣꠘ ꠒꠦꠞꠣ-ꠊꠞ ꠔꠤꠀꠞ ꠇꠞꠤꠟꠣꠁ, ꠄꠇꠈꠣꠘ ꠀꠙꠘꠣꠞ ꠟꠣꠉꠤ, ꠄꠇꠈꠣꠘ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠄꠇꠈꠣꠘ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK9_6","071_9_6","MRK","9","6","6","ꠄꠞꠣ ꠈꠥꠛ ꠛꠦꠡꠤ ꠒꠞꠣꠁ ꠉꠦꠍꠟꠣ, ꠄꠞꠖꠣꠄ ꠇꠤꠔꠣ ꠝꠣꠔꠤꠔꠣ ꠇꠥꠘꠥ ꠔꠣꠟ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_7","071_9_7","MRK","9","7","7","ꠅꠃ ꠡꠝꠄ ꠉꠣꠁꠛꠤ ꠄꠇ ꠝꠦꠊꠞ ꠐꠥꠇꠞꠣꠄ ꠀꠁꠀ ꠄꠞꠣꠞꠦ ꠉꠥꠞꠤꠟꠤꠟ, ꠀꠞ ꠅꠃ ꠐꠥꠇꠞꠣ ꠕꠣꠇꠤ ꠉꠣꠁꠛꠤ ꠀꠅꠀꠎ ꠅꠁꠟ, “ꠄꠁꠘꠃ ꠀꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠔꠥꠝꠞꠣ ꠄꠘ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK9_8","071_9_8","MRK","9","8","8","ꠑꠤꠇ ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠌꠣꠁꠀ ꠈꠣꠟꠤ ꠁꠍꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠁꠘꠅ ꠖꠦꠈꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_9","071_9_9","MRK","9","9","9","ꠛꠣꠖꠦ ꠙꠣꠠ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠛꠣꠞ ꠛꠣꠟꠣ ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠀꠁꠎ ꠎꠦꠔꠣ ꠖꠦꠈꠟꠣꠄ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK9_10","071_9_10","MRK","9","10","10","ꠄꠞꠣ ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠟꠣ, ꠅꠁꠟꠦ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠜꠦꠖ ꠇꠤꠔꠣ ꠅꠈꠣꠘ ꠘꠣ ꠛꠥꠎꠣꠄ, ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_11","071_9_11","MRK","9","11","11","ꠛꠣꠖꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠇꠦꠘꠦ ꠇꠂꠘ, ꠢꠎꠞꠔ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠄ ꠙꠄꠟꠣ ꠔꠡꠞꠤꠚ ꠀꠘꠣ ꠎꠞꠥꠞ?” ");
INSERT INTO syls_vpl VALUES ("MK9_12","071_9_12","MRK","9","12","12","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠈꠣꠘ ꠢꠣꠍꠣ ꠇꠕꠣ, ꠙꠄꠟꠣ ꠢꠎꠞꠔ ꠁꠟꠤꠀꠍꠦ ꠀꠁꠀ ꠢꠇ꠆ꠇꠟꠔꠣ ꠀꠉꠞ ꠢꠣꠟꠔꠅ ꠚꠤꠞꠣꠁ ꠀꠘꠛꠣ। ꠅꠁꠟꠦ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠇꠦꠘꠦ ꠟꠦꠈꠣ ꠅꠁꠍꠦ, ꠔꠣꠁꠘ ꠈꠥꠛ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠙꠥꠀꠘꠤ ꠟꠣꠉꠛ, ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠔꠣ ꠘꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("MK9_13","071_9_13","MRK","9","13","13","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠀꠞ, ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠙꠣꠇ ꠇꠤꠔꠣꠛꠅ ꠎꠦꠟꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠅꠟꠣꠈꠣꠘꠃ ꠔꠣꠁꠘ ꠀꠁꠍꠟꠣ। ꠝꠣꠘꠡꠦꠅ ꠔꠣꠘ ꠟꠉꠦ ꠎꠦꠔꠣ ꠝꠘꠅꠟꠄ ꠅꠔꠣ ꠇꠞꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK9_14","071_9_14","MRK","9","14","14","ꠁꠍꠣꠄ ꠅꠃ ꠔꠤꠘꠅ ꠎꠘꠞꠦ ꠟꠁꠀ ꠙꠣꠠ ꠕꠘꠦ ꠟꠣꠝꠤꠀ ꠛꠣꠇꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠖꠟꠣ ꠅꠁꠍꠂꠘ, ꠀꠞ ꠇꠄꠎꠘ ꠝꠃꠟꠣꠘꠣꠄ ꠄꠞꠣꠞ ꠟꠉꠦ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_15","071_9_15","MRK","9","15","15","ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ, ꠖꠃꠠꠣꠁꠀ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠍꠣꠟꠣꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_16","071_9_16","MRK","9","16","16","ꠔꠣꠁꠘ ꠅꠃ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠇꠤꠔꠣ ꠟꠁꠀ ꠄꠞꠣꠞ ꠟꠉꠦ ꠔꠞ꠆ꠇ ꠇꠞꠞꠣ?” ");
INSERT INTO syls_vpl VALUES ("MK9_17","071_9_17","MRK","9","17","17","ꠜꠤꠠꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠇꠎꠘꠦ ꠇꠁꠟ, “ꠍꠣꠛ, ꠀꠝꠣꠞ ꠙꠥꠀꠉꠥꠞꠦ ꠟꠁꠀ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠍꠟꠣꠝ, ꠅꠉꠥꠞꠦ ꠛꠥꠛꠣ ꠎꠤꠘꠦ ꠀꠍꠞ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK9_18","071_9_18","MRK","9","18","18","ꠅꠃ ꠎꠤꠘꠦ ꠔꠣꠞꠦ ꠎꠦꠛꠟꠣꠃ ꠗꠞꠦ, ꠔꠣꠞꠦ ꠀꠍꠣꠠ ꠝꠣꠞꠤꠀ ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠄ। ꠔꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠚꠦꠘꠣ ꠛꠣꠞꠅꠄ, ꠖꠣꠔꠅ ꠇꠛꠐ ꠟꠣꠉꠤꠀ ꠒꠣꠐ꠆ꠐꠣ ꠅꠁꠎꠣꠄ। ꠀꠝꠤ ꠔꠣꠞꠦ ꠟꠁꠀ ꠀꠙꠘꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠁꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠄꠞꠣ ꠙꠣꠞꠍꠂꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK9_19","071_9_19","MRK","9","19","19","ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠣꠄꠞꠦ ꠛꠦꠁꠝꠣꠘ ꠅꠇꠟ! ꠀꠝꠤ ꠀꠞ ꠇꠔꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠎꠣꠟꠣ ꠇꠔꠖꠤꠘ ꠡꠁꠎ꠆ꠎ ꠇꠞꠝꠥ? ꠀꠁꠌ꠆ꠍꠣ, ꠙꠥꠀꠞꠦ ꠅꠘꠅ ꠀꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK9_20","071_9_20","MRK","9","20","20","ꠝꠣꠘꠡꠦ ꠙꠥꠀꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠘꠟꠣ। ꠔꠣꠘꠦ ꠖꠦꠈꠤꠀꠃ ꠎꠤꠘꠦ ꠔꠣꠞꠦ ꠈꠥꠛ ꠎꠣꠔꠤꠀ ꠗꠞꠟ। ꠙꠥꠀꠄ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀ ꠝꠥꠈꠞ ꠚꠦꠘꠣ ꠛꠣꠞ ꠇꠞꠤ ꠉꠠꠣꠉꠠꠤ ꠟꠣꠉꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK9_21","071_9_21","MRK","9","21","21","ꠁꠍꠣꠄ ꠔꠣꠞ ꠛꠣꠚꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠣꠞ ꠁ ꠖꠡꠣ ꠇꠔꠖꠤꠘ ꠕꠣꠇꠤ?” ꠛꠦꠐꠣꠄ ꠇꠁꠟ, “ꠢꠥꠞꠥꠝꠣꠘ ꠕꠣꠇꠤꠃ। ");
INSERT INTO syls_vpl VALUES ("MK9_22","071_9_22","MRK","9","22","22","ꠀꠞ ꠁ ꠎꠤꠘꠦ ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠔ ꠇꠞꠤ ꠛꠃꠔ ꠛꠣꠞ ꠔꠣꠞꠦ ꠀꠉꠥꠘꠤꠔ ꠀꠞ ꠙꠣꠘꠤꠔ ꠚꠣꠟꠣꠁꠍꠦ। ꠅꠈꠘ ꠀꠙꠘꠦ ꠎꠥꠖꠤ ꠙꠣꠞꠂꠘ, ꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK9_23","071_9_23","MRK","9","23","23","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠎꠥꠖꠤ ꠙꠣꠞꠂꠘ, ꠁ ꠇꠕꠣꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ? ꠎꠦ ꠄꠇꠤꠘ ꠇꠞꠦ ꠔꠣꠞ ꠟꠣꠉꠤ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK9_24","071_9_24","MRK","9","24","24","ꠅꠃ ꠛꠦꠐꠣꠄ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠄꠇꠤꠘ ꠇꠞꠍꠤ। ꠀꠝꠣꠞ ꠁꠝꠣꠘꠞ ꠇꠝꠎꠥꠞꠤ ꠢꠞꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK9_25","071_9_25","MRK","9","25","25","ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠖꠃꠠꠣꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠞꠣ ꠖꠦꠈꠤꠀ, ꠔꠣꠁꠘ ꠎꠤꠘꠞꠦ ꠗꠣꠝꠇꠤ ꠝꠣꠞꠤ ꠇꠁꠟꠣ, “ꠅꠂ ꠈꠣꠟꠥꠀ ꠀꠞ ꠛꠥꠛꠣ ꠎꠤꠘ, ꠀꠝꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠄꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁ ꠎꠣ। ꠔꠣꠞꠦ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠗꠞꠤꠍ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK9_26","071_9_26","MRK","9","26","26","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠎꠤꠘꠦ ꠔꠣꠞꠦ ꠈꠥꠛ ꠎꠥꠞꠦ ꠌꠤꠇ ꠖꠤꠀ ꠎꠣꠔꠣ ꠝꠣꠞꠤ ꠍꠣꠠꠤꠀ ꠉꠦꠟꠉꠤ। ꠔꠦꠃ ꠁ ꠙꠥꠀ ꠝꠥꠞ꠆ꠖꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠐꠤꠔ ꠙꠠꠤ ꠞꠁꠍꠦ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠡꠦ ꠇꠁꠟꠣ, “ꠄ ꠔ ꠝꠣꠞꠣ ꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK9_27","071_9_27","MRK","9","27","27","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠀꠔꠅ ꠗꠞꠤ ꠔꠥꠟꠔꠦꠃ ꠢꠦ ꠃꠛꠣꠁ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK9_28","071_9_28","MRK","9","28","28","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠘꠤꠞꠣꠟꠣꠄ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠙꠣꠞꠟꠣꠝ ꠘꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK9_29","071_9_29","MRK","9","29","29","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠖꠥꠀ ꠘꠣ ꠇꠞꠟꠦ ꠀꠞ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠁ ꠟꠣꠈꠣꠘ ꠎꠤꠘ ꠍꠣꠠꠣꠁꠟ ꠎꠣꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK9_30","071_9_30","MRK","9","30","30","ꠛꠣꠖꠦ ꠢꠇꠟꠦ ꠝꠤꠟꠤ ꠁ ꠎꠣꠉꠣ ꠍꠣꠠꠤꠀ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠝꠣꠎꠦꠖꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ꠌꠣꠁꠟꠣ, ꠝꠣꠘꠡꠦ ꠎꠣꠘꠥ ꠁꠔꠣ ꠘꠣ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK9_31","071_9_31","MRK","9","31","31","ꠅꠃ ꠡꠝꠄ ꠔ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠝꠣꠘꠡꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ, ꠀꠞ ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK9_32","071_9_32","MRK","9","32","32","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘ ꠁ ꠔꠣꠟꠤꠝꠞ ꠇꠥꠘꠥ ꠜꠦꠖ ꠛꠥꠎꠟꠣ ꠘꠣ, ꠀꠞ ꠔꠣꠘ ꠉꠦꠍꠦ ꠎꠤꠇꠣꠘꠤꠞꠅ ꠡꠣꠅꠡ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_33","071_9_33","MRK","9","33","33","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠄꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠙꠕꠅ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠟꠁꠀ ꠔꠞ꠆ꠇ ꠇꠞꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("MK9_34","071_9_34","MRK","9","34","34","ꠄꠞꠣ ꠝꠥꠈ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠛꠁꠞꠁꠟꠣ। ꠀꠍꠟꠦ ꠙꠕꠅ ꠔꠣꠞꠣ ꠔꠞ꠆ꠇ ꠇꠞꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦ ꠢꠇꠟ ꠕꠣꠇꠤ ꠖꠣꠝꠤ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("MK9_35","071_9_35","MRK","9","35","35","ꠁꠍꠣ ꠛꠁꠉꠦꠟꠣ, ꠛꠁꠀ ꠄꠞꠣ ꠛꠣꠞꠅꠎꠘꠞꠦ ꠔꠣꠘ ꠗꠣꠞꠅ ꠘꠤꠀ ꠇꠁꠟꠣ, “ꠇꠦꠃ ꠎꠥꠖꠤ ꠖꠣꠝꠤ ꠝꠣꠘꠥꠡ ꠅꠁꠔ ꠌꠣꠄ, ꠔꠦ ꠢꠦ ꠢꠇꠟꠞ ꠈꠞꠦ ꠞꠁꠔꠦ ꠅꠁꠛ। ꠀꠞ ꠢꠇꠟꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK9_36","071_9_36","MRK","9","36","36","ꠛꠣꠖꠦ ꠄꠇ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠀꠘꠤꠀ ꠄꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣ ꠇꠞꠣꠁꠟꠣ। ꠔꠣꠞꠦ ꠇꠥꠟꠅ ꠟꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK9_37","071_9_37","MRK","9","37","37","“ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠍꠣꠛꠣꠟꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠀꠝꠣꠞꠦꠃ ꠇꠛꠥꠟ ꠇꠞꠦ। ꠀꠞ ꠀꠝꠣꠞꠦ ꠎꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠈꠣꠟꠤ ꠀꠝꠣꠞꠦ ꠘꠣꠄ, ꠀꠝꠣꠞꠦ ꠎꠦꠁꠘ ꠛꠦꠎꠤꠍꠂꠘ ꠔꠣꠘꠞꠦꠅ ꠇꠛꠥꠟ ꠇꠞꠟ।” ");
INSERT INTO syls_vpl VALUES ("MK9_38","071_9_38","MRK","9","38","38","ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠄꠇ ꠛꠦꠐꠣꠞꠦ ꠖꠦꠈꠍꠤ, ꠢꠦ ꠀꠙꠘꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠄ। ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠔꠣꠞꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠍꠤ, ꠢꠦ ꠔ ꠀꠝꠞꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠝꠣꠘꠥꠡ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK9_39","071_9_39","MRK","9","39","39","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠄꠞꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠝꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠇꠦꠃ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠘꠤꠞ ꠛꠣꠖꠦ, ꠢꠦ ꠅꠔ ꠎꠟꠖꠤ ꠀꠝꠣꠞ ꠉꠤꠛꠔ ꠉꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK9_40","071_9_40","MRK","9","40","40","ꠎꠦꠞꠣ ꠀꠝꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠘꠣꠄ, ꠔꠣꠞꠣ ꠔ ꠀꠝꠞꠣꠞ ꠙꠇ꠆ꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("MK9_41","071_9_41","MRK","9","41","41","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠀꠞ, ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠞ ꠝꠣꠘꠥꠡ ꠅꠀꠞ ꠈꠣꠔꠤꠞꠦ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠄꠇ ꠉꠦꠟꠣꠡ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠄ, ꠔꠦ ꠢꠦ ꠄꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛꠃ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK9_42","071_9_42","MRK","9","42","42","“ꠀꠞ ꠀꠝꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠅꠃ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠄꠇꠎꠘꠞꠦ ꠎꠥꠖꠤ ꠇꠦꠃ ꠔꠣꠞ ꠁꠝꠣꠘꠞ ꠙꠕꠦ ꠛꠣꠗꠣ ꠖꠦꠄ, ꠔꠦ ꠄꠞ ꠌꠣꠁꠔꠦ ꠔꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠜꠣꠟꠣ ꠅꠁꠛ, ꠔꠣꠞ ꠉꠟꠣꠔ ꠙꠣꠔ꠆ꠔꠞ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("MK9_43","071_9_43","MRK","9","43","43","ꠔꠥꠝꠣꠞ ꠀꠔ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠞꠤꠙꠥ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠀꠔ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("MK9_44","071_9_44","MRK","9","44","44","ꠖꠥꠁꠅ ꠀꠔ ꠟꠁꠀ ꠎꠣꠢꠣꠘ꠆ꠘꠣꠝꠤ ꠅꠀ ꠕꠣꠇꠤ, ꠄꠇ ꠀꠔ ꠟꠁꠀ ꠎꠣꠘ꠆ꠘꠣꠔꠅ ꠎꠣꠅꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ। ꠎꠣꠢꠣꠘ꠆ꠘꠣꠝꠞ ꠀꠉꠥꠁꠘ ꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠘꠤꠜꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_45","071_9_45","MRK","9","45","45","ꠔꠥꠝꠣꠞ ꠙꠣꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠞꠤꠙꠥ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠙꠣꠅ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠅ। ꠖꠥꠁꠅ ꠙꠣꠅ ꠟꠁꠀ ꠎꠣꠢꠣꠘ꠆ꠘꠣꠝꠅ ꠎꠟꠣ ꠕꠣꠇꠤ, ꠟꠦꠋꠠꠣ ꠅꠁꠀ ꠎꠣꠘ꠆ꠘꠣꠔꠅ ꠎꠣꠅꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_46","071_9_46","MRK","9","46","47","ꠔꠥꠝꠣꠞ ꠌꠃꠈ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠞꠤꠙꠥ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠅ। ꠖꠥꠁꠅ ꠌꠃꠈ ꠟꠁꠀ ꠎꠣꠢꠣꠘ꠆ꠘꠣꠝꠅ ꠎꠟꠣ ꠕꠣꠇꠤ, ꠇꠣꠘꠣ ꠅꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠖꠣꠈꠤꠟ ꠅꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_48","071_9_48","MRK","9","48","48","ꠁ ꠎꠣꠢꠣꠘ꠆ꠘꠣꠝꠞ ꠛꠤꠌ꠆ꠍꠥ ꠅꠇꠟ ꠝꠞꠦ ꠘꠣ, ꠀꠞ ꠢꠤꠘꠞ ꠀꠉꠥꠁꠘꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠘꠤꠜꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK9_49","071_9_49","MRK","9","49","49","“ꠢꠥꠘꠅ, ꠙꠞꠔꠦꠇ ꠝꠣꠘꠥꠡꠃ ꠀꠉꠥꠘꠤꠔ ꠘꠥꠘꠔꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK9_50","071_9_50","MRK","9","50","50","ꠘꠥꠘ ꠔ ꠜꠣꠟꠣ ꠎꠤꠘꠤꠡ, ꠅꠁꠟꠦ ꠘꠥꠘꠦ ꠎꠥꠖꠤ ꠔꠣꠞ ꠘꠥꠘꠔꠣ ꠉꠥꠘ ꠈꠥꠀꠁꠟꠣꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠀꠞ ꠘꠥꠘꠔꠣ ꠛꠣꠘꠣꠁꠟ ꠎꠣꠁꠛ ꠘꠤ? ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠁ ꠘꠥꠘ ꠇꠣꠁꠝ ꠞꠣꠈꠅ, ꠀꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠡꠔ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK10_1","071_10_1","MRK","10","1","1","ꠇꠚꠞꠘꠣꠃꠝ ꠕꠣꠇꠤ ꠢꠎꠞꠔ ꠁꠍꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠀꠁꠟꠣ, ꠀꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠉꠦꠟꠣ। ꠅꠘꠅ ꠀꠁꠟꠦ ꠢꠤꠞꠛꠣꠞ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠖꠟꠣ ꠅꠁꠟꠣ। ꠔꠣꠁꠘꠅ ꠔꠣꠘ ꠞꠦꠅꠀꠎ ꠝꠣꠚꠤꠇ ꠄꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK10_2","071_10_2","MRK","10","2","2","ꠅꠃ ꠡꠝꠄ ꠔꠣꠘꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠇꠄꠎꠘꠦ ꠀꠁꠀ ꠎꠤꠇꠣꠁꠟ, “ꠍꠣꠛ, ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠦꠅꠀ ꠎꠣꠁꠎ ꠀꠍꠦ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK10_3","071_10_3","MRK","10","3","3","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠍꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("MK10_4","071_10_4","MRK","10","4","4","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠔꠣꠁꠘ ꠇꠁꠍꠂꠘ, ꠔꠣꠟꠣꠇ ꠘꠣꠝꠣ ꠟꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠛꠃ ꠔꠣꠟꠣꠇ ꠖꠦꠅꠀ ꠎꠣꠁꠎ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK10_5","071_10_5","MRK","10","5","5","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ, ꠄꠞꠟꠣꠉꠤꠃ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠁ ꠝꠥꠍꠟꠣ ꠟꠦꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK10_6","071_10_6","MRK","10","6","6","ꠅꠁꠟꠦ ꠄꠅꠈꠣꠘ ꠔ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠙꠄꠟꠣ ꠀꠖꠝ ꠀꠞ ꠢꠣꠅꠀꠞꠦ ꠝꠞ꠆ꠖ ꠀꠞ ꠀꠅꠞꠔ ꠛꠣꠘꠣꠁ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK10_7","071_10_7","MRK","10","7","7","ꠄꠞꠖꠣꠄ ꠝꠣꠘꠡꠦꠅ ꠔꠣꠞꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠕꠁꠀ ꠛꠃꠞ ꠟꠉꠦ ꠀꠡꠤꠇ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK10_8","071_10_8","MRK","10","8","8","ꠎꠣꠝꠣꠁ ꠀꠞ ꠛꠃ ꠄꠇ ꠇꠣꠄꠀ ꠅꠁꠛꠣ। ꠔꠣꠞꠣ ꠖꠥꠁ ꠞꠁꠔꠣ ꠘꠣꠄ, ꠄꠇ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK10_9","071_10_9","MRK","10","9","9","ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠁꠍꠂꠘ, ꠝꠣꠘꠡꠦ ꠁꠔꠣꠞꠦ ꠀꠟꠉ ꠘꠣ ꠇꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MK10_10","071_10_10","MRK","10","10","10","ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ, ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘꠞꠦ ꠅꠃ ꠝꠥꠍꠟꠣ ꠎꠤꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK10_11","071_10_11","MRK","10","11","11","ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠤꠀ ꠀꠞꠇ ꠛꠦꠐꠤꠞꠦ ꠘꠤꠇꠣ ꠇꠞꠦ, ꠢꠦ ꠔ ꠅꠃ ꠛꠃꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MK10_12","071_10_12","MRK","10","12","12","ꠅꠃꠟꠣ ꠛꠃꠄꠅ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠤꠀ ꠀꠞꠇ ꠛꠦꠐꠣꠞ ꠉꠦꠍꠦ ꠘꠤꠇꠣ ꠛꠄ, ꠔꠦ ꠔꠣꠁꠅ ꠎꠤꠘꠣ ꠇꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK10_13","071_10_13","MRK","10","13","13","ꠛꠣꠖꠦ ꠝꠣꠘꠡꠦ ꠢꠥꠞꠥ ꠢꠥꠞꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠟꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ꠅꠁꠟꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠄꠞꠣꠞꠦ ꠛꠇꠣ-ꠎꠇꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK10_14","071_10_14","MRK","10","14","14","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠁꠍꠣ ꠘꠣꠞꠣꠎ ꠅꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠦ ꠝꠣꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠄꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤꠃ। ");
INSERT INTO syls_vpl VALUES ("MK10_15","071_10_15","MRK","10","15","15","ꠀꠝꠤ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠢꠥꠞꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠦ ꠎꠦꠟꠣ ꠛꠠꠞ ꠡꠣꠡꠘ ꠝꠣꠘꠂꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠡꠘꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠘꠣ ꠝꠣꠘꠟꠦ, ꠝꠣꠘꠥꠡ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK10_16","071_10_16","MRK","10","16","16","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞꠦ ꠇꠥꠟꠅ ꠟꠁꠀ ꠔꠣꠞꠣꠞ ꠝꠣꠕꠣꠔ ꠀꠔ ꠞꠣꠈꠤꠀ ꠖꠥꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK10_17","071_10_17","MRK","10","17","17","ꠢꠎꠞꠔ ꠁꠍꠣ ꠎꠦꠛꠟꠣ ꠛꠣꠞ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠛꠦꠐꠣ ꠖꠃꠠꠣꠁꠀ ꠀꠁꠀ ꠀꠐꠥ ꠉꠣꠠꠤꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠛꠁꠀ ꠇꠁꠟ, “ꠃꠡ꠆ꠔꠣꠖ, ꠀꠙꠘꠦ ꠔ ꠝꠦꠢꠦꠞꠛꠣꠘ। ꠔꠦ ꠀꠝꠣꠞꠦ ꠛꠣꠔꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠀꠈꠦꠞ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("MK10_18","071_10_18","MRK","10","18","18","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞꠦ ꠇꠦꠘꠦ ꠝꠦꠢꠦꠞꠛꠣꠘ ꠇꠁꠞꠣꠄ? ꠄꠇ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠝꠦꠢꠦꠞꠛꠣꠘ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK10_19","071_10_19","MRK","10","19","19","ꠔꠥꠝꠤ ꠔ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠞ ꠢꠥꠇꠥꠝ ꠎꠣꠘ। ꠈꠥꠘ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠌꠥꠞꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠅ ꠘꠣ, ꠐꠉꠣ-ꠐꠉꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠝꠣ-ꠛꠣꠚꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK10_20","071_10_20","MRK","10","20","20","ꠛꠦꠐꠣꠄ ꠇꠁꠟ, “ꠍꠣꠛ, ꠀꠝꠤ ꠔ ꠢꠥꠞꠥꠝꠣꠘ ꠕꠘꠦꠃ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠤꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK10_21","071_10_21","MRK","10","21","21","ꠔꠦꠃ ꠁꠍꠣꠄ ꠝꠣꠄꠀꠞ ꠘꠎꠞꠦ ꠔꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠈꠣꠟꠤ ꠄꠇꠈꠣꠘ ꠎꠤꠘꠤꠡ ꠔꠥꠝꠣꠞ ꠛꠣꠇꠤ ꠞꠁꠍꠦ। ꠔꠥꠝꠤ ꠎꠣꠅ, ꠉꠤꠀ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠛꠦꠌꠤꠀ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅ। ꠔꠦꠃ ꠔꠥꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠥꠝꠣꠞ ꠍꠣꠝꠣꠘꠣ ꠇꠣꠝꠣꠁꠛꠣꠄ। ꠛꠣꠖꠦ ꠀꠁꠀ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK10_22","071_10_22","MRK","10","22","22","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠦꠐꠣꠞ ꠝꠥꠈ ꠇꠣꠟꠣ ꠅꠁꠉꠦꠟ। ꠔꠣꠞ ꠛꠃꠔ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠀꠍꠤꠟ ꠇꠞꠤ ꠝꠘꠅ ꠖꠥꠈ ꠟꠁꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK10_23","071_10_23","MRK","10","23","23","ꠔꠦꠃ ꠁꠍꠣꠄ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠌꠣꠁꠀ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠗꠘꠤ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠘꠤ ꠛꠠ ꠝꠡꠇꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MK10_24","071_10_24","MRK","10","24","24","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠄꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ꠁꠍꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ ꠅꠇꠟ, ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠖꠥꠘꠤꠀꠛꠤ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠞꠣ ꠜꠞꠡꠣ ꠇꠞꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠘꠤ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠝꠡꠇꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK10_25","071_10_25","MRK","10","25","25","ꠗꠘꠤ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠘꠤꠞ ꠌꠣꠁꠔꠦ, ꠍꠥꠁꠞ ꠚꠥꠠꠦꠖꠤ ꠃꠐ ꠢꠣꠝꠣꠘꠤ ꠀꠞꠅ ꠡꠥꠎꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK10_26","071_10_26","MRK","10","26","26","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠀꠞꠅ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠇꠥꠘ ꠝꠣꠘꠡꠦ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛ, ꠇꠦ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("MK10_27","071_10_27","MRK","10","27","27","ꠁꠍꠣꠄ ꠄꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠅꠡꠝ꠆ꠛꠛ ꠅꠁꠔ ꠙꠣꠞꠦ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠁꠔꠣ ꠔ ꠝꠣꠝꠥꠟꠤ। ꠔꠣꠁꠘ ꠢꠇꠟꠔꠣꠃ ꠙꠣꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK10_28","071_10_28","MRK","10","28","28","ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠔ ꠢꠇꠟꠔꠣ ꠚꠣꠟꠣꠁ ꠕꠁꠀ ꠀꠙꠘꠣꠞ ꠈꠞꠦ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK10_29","071_10_29","MRK","10","29","29","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠛꠣꠠꠤ-ꠊꠞ, ꠝꠣ-ꠛꠣꠚ, ꠜꠣꠁ-ꠛꠁꠘ, ꠙꠥꠀ-ꠙꠥꠠꠤ, ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠍꠣꠠꠤ ꠖꠤꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("MK10_30","071_10_30","MRK","10","30","30","ꠢꠦ ꠅꠃ ꠖꠥꠘꠤꠀꠔ ꠁꠔꠣꠞ ꠄꠇ-ꠡ ꠉꠥꠘ ꠛꠦꠡꠤ ꠛꠣꠠꠤ-ꠊꠞ, ꠝꠣ-ꠛꠣꠚ, ꠜꠣꠁ-ꠛꠁꠘ, ꠙꠥꠀ-ꠙꠥꠠꠤ, ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠙꠣꠁꠛ। ꠁꠔꠣꠞ ꠟꠉꠦ ꠢꠦ ꠎꠥꠟꠥꠝ-ꠔꠇꠟꠤꠚꠅ ꠙꠣꠁꠛ। ꠛꠣꠖꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠢꠦ ꠀꠈꠦꠞꠅ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK10_31","071_10_31","MRK","10","31","31","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠙꠄꠟꠣ ꠇꠣꠔꠣꠞꠅ ꠀꠍꠂꠘ, ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠎꠘ ꠈꠞꠦ ꠙꠠꠤꠎꠤꠛꠣ, ꠀꠞ ꠎꠦꠞꠣ ꠈꠞꠞ ꠇꠣꠔꠣꠞꠅ ꠀꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠛꠃꠔ ꠎꠘ ꠙꠄꠟꠣ ꠇꠣꠔꠣꠞꠅ ꠀꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK10_32","071_10_32","MRK","10","32","32","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠁꠞꠣ। ꠔꠣꠁꠘ ꠀꠉꠦ ꠅꠁꠀ ꠀꠐꠤꠞꠣ, ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠒꠞꠣꠁ ꠒꠞꠣꠁ ꠈꠞꠦ ꠈꠞꠦ ꠎꠣꠁꠞꠣ। ꠀꠞꠅ ꠎꠦꠞꠣ ꠔꠣꠘ ꠈꠞꠦ ꠅꠁꠀ ꠎꠣꠁꠞꠣ ꠔꠣꠞꠣꠞ ꠎꠣꠘꠅ-ꠅ ꠒꠞ ꠀꠍꠤꠟ। ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠀꠟꠉꠣ ꠢꠞꠣꠁꠀ ꠘꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, ꠔꠣꠘ ꠇꠥꠘ ꠖꠡꠣ ꠊꠐꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MK10_33","071_10_33","MRK","10","33","33","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠅꠈꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠎꠣꠁꠞꠣꠝ। ꠢꠘꠅ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠗꠞꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠔꠣꠞꠣ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠞꠣꠄ ꠖꠤꠛꠣ। ꠀꠝꠣꠞꠦ ꠛꠤꠗꠞ꠆ꠝꠤ ꠎꠣꠔꠤꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK10_34","071_10_34","MRK","10","34","34","ꠅꠃ ꠛꠤꠗꠞ꠆ꠝꠤ ꠅꠇꠟꠦ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠇꠞꠤꠀ, ꠡꠞꠤꠟꠅ ꠍꠦꠚ ꠍꠤꠐꠣꠁꠀ, ꠛꠦꠎꠥꠁꠔꠣ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠛꠣ, ꠀꠞ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣ। ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK10_35","071_10_35","MRK","10","35","35","ꠛꠣꠖꠦ ꠎꠤꠛꠥꠖꠤꠀꠞ ꠖꠥꠁ ꠙꠥꠔ ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ ꠘꠣꠝꠞ ꠖꠥꠁꠅ ꠍꠣꠢꠣꠛꠤ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠄꠇꠈꠣꠘ ꠀꠞꠎꠤ ꠟꠁꠀ ꠀꠁꠍꠤ, ꠝꠘꠅ ꠇꠞꠞꠣꠝ, ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞ ꠀꠞꠎꠤꠈꠣꠘ ꠞꠣꠈꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK10_36","071_10_36","MRK","10","36","36","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ, ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠌꠣꠁꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("MK10_37","071_10_37","MRK","10","37","37","ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠎꠦꠛꠟꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠣꠙꠐꠞ ꠟꠉꠦ ꠞꠣꠎ-ꠉꠖꠤꠔ ꠛꠁꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠞꠣ ꠄꠇꠎꠘꠞꠦ ꠀꠙꠘꠣꠞ ꠒꠣꠁꠘꠞ ꠉꠖꠤ, ꠅꠁꠘ꠆ꠘ ꠎꠘꠞꠦ ꠛꠣꠃꠅꠞ ꠉꠖꠤꠈꠣꠘ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK10_38","071_10_38","MRK","10","38","38","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠛꠥꠎꠞꠣꠄ ꠘꠣ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠌꠣꠁꠞꠣꠄ। ꠀꠝꠤ ꠎꠦ ꠔꠇꠟꠤꠚꠞ ꠙꠤꠀꠟꠣꠖꠤ ꠈꠣꠁꠝꠥ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠔꠥꠝꠞꠣ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ ꠘꠤ? ꠀꠝꠤ ꠎꠦ ꠔꠇꠟꠤꠚꠞ ꠉꠥꠍꠟ ꠇꠞꠝꠥ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠙꠣꠞꠛꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK10_39","071_10_39","MRK","10","39","39","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ ꠙꠣꠞꠝꠥ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠀꠝꠤ ꠎꠦ ꠙꠤꠀꠟꠣꠖꠤ ꠈꠣꠁꠝꠥ, ꠔꠥꠝꠞꠣꠅ ꠅꠉꠥꠖꠤ ꠈꠣꠁꠛꠣꠄ। ꠀꠝꠤ ꠎꠦ ꠉꠥꠍꠟ ꠇꠞꠝꠥ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK10_40","071_10_40","MRK","10","40","40","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠒꠣꠁꠘ ꠛꠣ ꠛꠣꠃ ꠉꠣꠟꠣꠔ ꠛꠅꠀꠘꠤꠞ ꠄꠈꠔꠤꠀꠞ ꠀꠝꠣꠞ ꠀꠔꠅ ꠘꠣꠄ। ꠁ ꠉꠖꠤ ꠅꠇꠟ ꠎꠦꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠈꠣꠟꠤ ꠔꠣꠞꠣꠃ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK10_41","071_10_41","MRK","10","41","41","ꠛꠣꠇꠤ ꠖꠡꠎꠘ ꠍꠣꠢꠣꠛꠤꠄ ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞ ꠁ ꠀꠞꠎꠤ ꠢꠥꠘꠤꠀ ꠈꠥꠛ ꠛꠤꠞꠇ꠆ꠔ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK10_42","071_10_42","MRK","10","42","42","ꠔꠦꠃ ꠁꠍꠣꠄ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠛꠤꠗꠞ꠆ꠝꠤ ꠎꠣꠔꠤꠞ ꠞꠣꠎꠣ ꠅꠇꠟ ꠔꠣꠞꠣꠞ ꠙ꠆ꠞꠎꠣꠞ ꠝꠥꠘꠤꠛ ꠅꠄ। ꠔꠣꠞꠣꠞ ꠎꠝꠤꠖꠣꠞ ꠅꠇꠟꠦ ꠘꠤꠎꠞ ꠉꠥꠟꠣꠝꠞ ꠃꠙꠞꠦ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("MK10_43","071_10_43","MRK","10","43","43","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠅꠀ ꠑꠤꠇ ꠘꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠇꠦꠃ ꠖꠣꠝꠤ ꠛꠘꠔꠦ ꠌꠣꠁꠟꠦ, ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MK10_44","071_10_44","MRK","10","44","44","ꠀꠞ ꠇꠦꠃ ꠛꠠ ꠅꠁꠔꠦ ꠌꠣꠁꠟꠦ, ꠢꠦ ꠢꠇꠟꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MK10_45","071_10_45","MRK","10","45","45","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦꠅ ꠈꠦꠎꠝꠔ ꠙꠣꠅꠀꠔ ꠀꠁꠍꠤ ꠘꠣ, ꠀꠁꠍꠤ ꠔ ꠈꠦꠎꠝꠔ ꠇꠞꠣꠔ। ꠀꠞ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀꠔ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK10_46","071_10_46","MRK","10","46","46","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠟꠁꠀ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ꠛꠣꠖꠦ ꠄꠞꠣꠞꠦ ꠀꠞ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠘꠤꠞ ꠛꠣꠟꠣ, ꠔꠤꠝꠄꠅꠞ ꠙꠥꠀ ꠛꠞꠔꠤꠝꠄ ꠘꠣꠝꠞ ꠄꠇ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣꠄ ꠙꠕꠞ ꠗꠣꠞꠅ ꠛꠁꠀ ꠜꠤꠇ ꠇꠞꠣꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK10_47","071_10_47","MRK","10","47","47","ꠄꠁꠘꠃ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠞ ꠁꠍꠣ, ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠦꠐꠣꠄ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁ ꠌꠤꠟ꠆ꠟꠣꠁ ꠇꠁꠟ, “ꠅ ꠁꠍꠣ, ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ, ꠀꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK10_48","071_10_48","MRK","10","48","48","ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠤꠀ ꠛꠃꠔꠦ ꠇꠁꠟꠣ, “ꠌꠥꠙ, ꠌꠤꠟ꠆ꠟꠣꠁꠍ ꠘꠣ।” ꠅꠁꠟꠦ ꠢꠦ ꠀꠞꠅ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ, ꠀꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK10_49","071_10_49","MRK","10","49","49","ꠔꠣꠞ ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠖꠝ ꠟꠁꠀ ꠇꠁꠟꠣ, “ꠄꠞꠦ ꠅꠘꠅ ꠀꠘꠅ।” ꠝꠣꠘꠡꠦ ꠅꠃ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ, ꠀꠅ। ꠢꠥꠎꠥꠞꠦ ꠔꠥꠝꠣꠞꠦ ꠒꠣꠇꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK10_50","071_10_50","MRK","10","50","50","ꠔꠦꠃ ꠛꠦꠐꠣꠄ ꠔꠣꠞ ꠡꠞꠤꠟꠞ ꠌꠣꠖ꠆ꠖꠞ ꠈꠥꠟꠤꠀ, ꠚꠣꠟꠖꠤ ꠃꠑꠤꠀ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK10_51","071_10_51","MRK","10","51","51","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠌꠣꠅ ꠛꠣ? ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ꠛꠦꠐꠣꠄ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠌꠃꠈꠦ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("MK10_52","071_10_52","MRK","10","52","52","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ ꠎꠣꠅ, ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠅꠁꠟꠣꠄ।” ꠇꠁꠔꠦꠃ ꠔꠣꠞ ꠖꠦꠈꠣꠞ ꠡꠇ꠆ꠔꠤ ꠀꠁꠟ ꠀꠞ ꠁꠍꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK11_1","071_11_1","MRK","11","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠟꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠇꠣꠍꠣꠔ, ꠎꠄꠔꠥꠘ ꠙꠣꠠꠞ ꠟꠉꠦ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠀꠞ ꠛꠣꠄꠔ-ꠚꠣꠁꠎ꠆ꠎꠣ ꠉꠣꠃꠔ ꠀꠁꠀ ꠀꠎꠤꠟꠣ। ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠁꠘ ꠖꠥꠁꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK11_2","071_11_2","MRK","11","2","2","“ꠔꠥꠝꠞꠣ ꠖꠥꠁꠅꠎꠘ ꠍꠣꠝꠘꠞ ꠅꠃ ꠉꠣꠃꠔ ꠎꠣꠅ। ꠉꠤꠀ ꠉꠣꠃꠔ ꠢꠣꠝꠣꠁꠔꠦꠃ ꠖꠦꠈꠛꠣꠄ ꠄꠉꠥ ꠉꠣꠗꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠛꠣꠘ꠆ꠖꠣ ꠀꠍꠦ। ꠄꠞ ꠃꠙꠞꠦ ꠇꠦꠃ ꠇꠥꠘꠥꠖꠤꠘ ꠍꠅꠀꠞ ꠅꠁꠍꠦ ꠘꠣ। ꠅꠉꠥꠞ ꠉꠟꠣꠞ ꠖꠠꠤ ꠈꠥꠟꠤꠀ ꠅꠘꠅ ꠟꠁꠀ ꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MK11_3","071_11_3","MRK","11","3","3","ꠇꠦꠃ ꠎꠤꠇꠣꠁꠟꠦ ꠇꠁꠅ, ꠢꠥꠎꠥꠞꠞ ꠖꠞꠇꠣꠞ ꠀꠍꠦ, ꠄꠞꠖꠣꠄ ꠘꠤꠞꠣꠝ। ꠔꠣꠁꠘ ꠎꠟꠖꠤ ꠇꠞꠤ ꠚꠤꠞꠔ ꠖꠤꠟꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK11_4","071_11_4","MRK","11","4","4","ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠄꠞꠣ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠢꠣꠍꠣꠃ ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠄꠇ ꠛꠣꠠꠤꠞ ꠃꠑꠣꠘꠅ ꠉꠣꠗꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠛꠣꠘ꠆ꠖꠣ ꠀꠍꠦ। ꠖꠦꠈꠤꠀ ꠄꠞꠣ ꠔꠣꠞ ꠛꠣꠘ꠆ꠖ ꠈꠥꠟꠤꠔꠣ ꠌꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK11_5","071_11_5","MRK","11","5","5","ꠅꠃ ꠡꠝꠄ ꠢꠘꠅ ꠃꠛꠣ ꠇꠄꠎꠘ ꠝꠣꠘꠡꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠞꠣ ꠁ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠖꠠꠤ ꠈꠥꠟꠞꠣꠄ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK11_6","071_11_6","MRK","11","6","6","ꠔꠦꠃ ꠁꠍꠣꠄ ꠎꠦꠟꠣ ꠢꠤꠇꠣꠁ ꠖꠤꠍꠟꠣ, ꠄꠞꠣ ꠅꠃꠟꠣꠃ ꠎꠥꠀꠙ ꠖꠤꠟꠣ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK11_7","071_11_7","MRK","11","7","7","ꠉꠣꠗꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠟꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞ ꠈꠥꠟꠤꠀ ꠉꠣꠗꠣꠞ ꠙꠤꠑꠤꠔ ꠛꠤꠍꠣꠁꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠄꠞ ꠃꠙꠞꠦ ꠌꠠꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK11_8","071_11_8","MRK","11","8","8","ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞ ꠈꠥꠟꠤꠀ ꠙꠕꠞ ꠝꠣꠎꠦ ꠛꠤꠍꠣꠁ ꠖꠤꠟꠣ, ꠀꠞ ꠛꠃꠔꠦ ꠉꠣꠍꠞ ꠙꠣꠔꠣꠁꠘ ꠍꠤꠠꠤꠀ ꠀꠘꠤꠀ ꠙꠕꠅ ꠛꠤꠍꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK11_9","071_11_9","MRK","11","9","9","ꠁꠍꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠀꠉꠦ-ꠈꠞꠦ ꠎꠦꠞꠣ ꠎꠣꠅꠀꠔ ꠀꠍꠤꠟ, ꠄꠞꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠄꠟꠣꠘ ꠖꠤꠟꠣ, “ꠝꠣꠞꠢꠣꠛꠣ! ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠦꠁꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MK11_10","071_11_10","MRK","11","10","10","ꠀꠝꠞꠣꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ ꠖꠣꠃꠖꠞ ꠛꠣꠖꠡꠣꠁ ꠇꠣꠁꠝ ꠅꠞ, ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ! ꠛꠦꠢꠦꠡ꠆ꠔꠅ-ꠅ ꠝꠣꠞꠢꠣꠛꠣ!” ");
INSERT INTO syls_vpl VALUES ("MK11_11","071_11_11","MRK","11","11","11","ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠀꠁꠀ ꠔꠣꠁꠘ ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠁꠟꠣ ꠀꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠌꠣꠁꠀ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠟꠣ। ꠛꠣꠖꠦ ꠢꠣꠁꠘ꠆ꠎꠣ ꠅꠁꠎꠣꠅꠀꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠟꠁꠀ ꠛꠣꠄꠔ-ꠀꠘꠤꠀꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK11_12","071_11_12","MRK","11","12","12","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠅꠀꠞ ꠡꠝꠄ ꠔꠣꠘ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("MK11_13","071_11_13","MRK","11","13","13","ꠅꠃ ꠔꠣꠁꠘ ꠖꠥꠞꠁ ꠕꠣꠇꠤ ꠙꠣꠔꠣꠄ ꠜꠞꠣ ꠄꠉꠥ ꠒꠥꠝꠥꠞ ꠉꠣꠍ ꠖꠦꠈꠤꠀ, ꠅꠉꠥꠞ ꠚꠟ ꠈꠣꠁꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠉꠣꠍꠞ ꠗꠣꠞꠅ ꠉꠦꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠅ ꠚꠟ ꠗꠞꠣꠞ ꠖꠤꠘ ꠘꠣꠄ। ꠔꠣꠁꠘ ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠉꠣꠍꠞ ꠝꠣꠎꠦ ꠈꠣꠟꠤ ꠙꠣꠔꠣ, ꠇꠥꠘꠥ ꠚꠟ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("MK11_14","071_11_14","MRK","11","14","14","ꠔꠣꠁꠘ ꠅꠃ ꠉꠣꠍꠞꠦ ꠇꠁꠟꠣ, “ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞ ꠚꠟ ꠘꠣ ꠈꠣꠄ।” ꠔꠣꠘ ꠁ ꠛꠥꠟꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠢꠥꠘꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK11_15","071_11_15","MRK","11","15","15","ꠛꠣꠖꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠀꠁꠀ ꠔꠣꠁꠘ ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠁꠟꠣ। ꠀꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠎꠔ ꠈꠞꠤꠖ-ꠛꠤꠇꠤꠞ ꠇꠣꠞꠛꠣꠞꠤ ꠀꠍꠤꠟ, ꠁꠔꠣꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠐꠦꠇꠣꠞ ꠛꠣꠐ꠆ꠐꠣꠞ ꠇꠣꠞꠛꠣꠞꠤ ꠅꠇꠟꠞ ꠇꠦꠡ ꠛꠣꠇ꠆ꠡ, ꠀꠞ ꠙꠣꠞꠅ ꠛꠦꠌꠞꠣ ꠅꠇꠟꠞ ꠀꠡꠘ ꠃꠟꠐꠣꠁꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK11_16","071_11_16","MRK","11","16","16","ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠃꠑꠣꠘꠦꠖꠤ ꠇꠥꠘꠥꠎꠣꠔ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠁꠀ ꠌꠟꠣꠌꠟ ꠇꠞꠔꠦ ꠘꠤꠡꠦꠗ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK11_17","071_11_17","MRK","11","17","17","ꠔꠣꠁꠘ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ ꠘꠣ ꠘꠤ, ꠀꠝꠣꠞ ꠊꠞꠞꠦ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠁꠛ? ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠁ ꠊꠞꠞꠦ ꠒꠣꠇꠣꠁꠔꠞ ꠀꠒ꠆ꠒꠣꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠤꠍ।” ");
INSERT INTO syls_vpl VALUES ("MK11_18","071_11_18","MRK","11","18","18","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠗꠣꠘ꠆ꠖꠣꠔ ꠟꠣꠉꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠈꠥꠛ ꠒꠞꠣꠁꠔꠣ, ꠇꠣꠞꠘ ꠔꠣꠘ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠀꠌꠣꠘꠇ ꠄꠡꠇꠤ ꠙꠄꠖꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK11_19","071_11_19","MRK","11","19","19","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK11_20","071_11_20","MRK","11","20","20","ꠛꠤꠀꠘꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠙꠕꠦꠖꠤ ꠀꠐꠤꠀ ꠀꠅꠀꠞ ꠛꠣꠟꠣ ꠖꠦꠈꠟꠣ, ꠅꠃ ꠒꠥꠝꠥꠞ ꠉꠣꠍ ꠄꠇ꠆ꠇꠦꠞꠦ ꠎꠠꠦ-ꠚꠠꠦ ꠢꠥꠇꠣꠁꠀ ꠝꠞꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK11_21","071_11_21","MRK","11","21","21","ꠖꠦꠈꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠞ ꠝꠘꠅ ꠅꠁꠉꠦꠟ। ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠎꠦ ꠉꠣꠍꠞꠦ ꠛꠖ꠆ꠖꠥꠀ ꠖꠤꠍꠟꠣ, ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁꠉꠥ ꠝꠞꠤꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK11_22","071_11_22","MRK","11","22","22","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠄꠇꠤꠘ ꠞꠣꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("MK11_23","071_11_23","MRK","11","23","23","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠡꠘ꠆ꠖꠄ ꠘꠣ ꠇꠞꠤꠀ, ꠙꠥꠞꠣꠙꠥꠞ ꠁꠝꠣꠘꠦ ꠎꠥꠖꠤ ꠅꠃ ꠙꠣꠠꠞꠦ ꠇꠄ, ‘ꠎꠣꠅ, ꠃꠠꠤꠀ ꠉꠤꠀ ꠖꠞꠤꠀꠔ ꠙꠠꠅ,’ ꠔꠦ ꠢꠦ ꠎꠦꠟꠣ ꠇꠁꠛ ꠔꠣꠞ ꠟꠣꠉꠤ ꠅꠟꠣ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK11_24","071_11_24","MRK","11","24","24","ꠄꠞꠖꠣꠄ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠖꠥꠀ ꠇꠞꠣꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠝꠣꠋꠉ, ꠄꠇꠤꠘ ꠇꠞꠤꠅ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠙꠣꠁꠟꠤꠍ। ꠔꠦꠃ ꠢꠣꠍꠣꠃ ꠁꠔꠣ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK11_25","071_11_25","MRK","11","25","26","ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣꠃ ꠖꠥꠀ ꠇꠞꠣꠔ ꠃꠛꠣꠅ, ꠅꠃ ꠡꠝꠄ ꠇꠦꠃꠞꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠕꠣꠇꠟꠦ, ꠔꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠥꠝꠞꠣꠞ ꠔꠣꠝꠣꠝ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK11_27","071_11_27","MRK","11","27","27","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠀꠁꠟꠣ। ꠔꠣꠁꠘ ꠇꠣꠛꠣ ꠊꠞꠞ ꠃꠑꠣꠘꠅ ꠀꠐꠤꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ, ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠔꠣꠘ ꠗꠣꠞꠅ ꠀꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK11_28","071_11_28","MRK","11","28","28","“ꠔꠥꠝꠤ ꠇꠥꠘ ꠄꠈꠔꠤꠀꠞꠦ ꠁꠔꠣ ꠇꠞꠞꠣꠄ? ꠇꠦ ꠔꠥꠝꠣꠞꠦ ꠁ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK11_29","071_11_29","MRK","11","29","29","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠄꠇꠈꠣꠘ ꠍꠅꠀꠟ ꠇꠞꠝꠥ। ꠀꠙꠘꠣꠞꠣ ꠄꠞ ꠎꠥꠀꠙ ꠖꠤꠟꠣꠁꠟꠦ, ꠀꠝꠤꠅ ꠇꠁꠝꠥ, ꠇꠣꠞ ꠄꠈꠔꠤꠀꠞꠦ ꠀꠝꠤ ꠁꠔꠣ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("MK11_30","071_11_30","MRK","11","30","30","ꠀꠁꠌ꠆ꠍꠣ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠢꠎꠞꠔ ꠄꠢꠤꠀꠄ ꠔꠞꠤꠇꠣꠞ ꠉꠥꠍꠟ ꠖꠦꠅꠀꠞ ꠄꠈꠔꠤꠀꠞ ꠇꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠘꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK11_31","071_11_31","MRK","11","31","31","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠣꠘꠦ ꠇꠣꠘꠦ ꠝꠣꠔꠤꠟꠣ, “ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠁ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠔꠦ ꠔꠣꠁꠘ ꠇꠁꠛꠣ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣꠄ ꠘꠣ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("MK11_32","071_11_32","MRK","11","32","32","ꠀꠞ ꠎꠥꠖꠤ ꠇꠁ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠔꠦ ꠔ?” ꠔꠣꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠛ ꠒꠞꠣꠁꠔꠣ, ꠇꠣꠞꠘ ꠢꠇꠟ ꠝꠣꠘꠡꠦꠃ ꠝꠣꠘꠔꠣ, ꠢꠎꠞꠔ ꠄꠢꠤꠀ ꠄꠇꠎꠘ ꠘꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("MK11_33","071_11_33","MRK","11","33","33","ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠞꠣ ꠁꠈꠣꠘ ꠎꠣꠘꠤ ꠘꠣ।” ꠔꠦꠃ ꠁꠍꠣꠄꠅ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠤꠅ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠇꠁꠔꠣꠝ ꠘꠣꠄ, ꠇꠣꠞ ꠄꠈꠔꠤꠀꠞꠦ ꠀꠝꠤ ꠁꠔꠣ ꠇꠞꠤꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK12_1","071_12_1","MRK","12","1","1","ꠔꠦꠃ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠢꠃ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞꠦ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠀ ꠛꠥꠎꠣꠁꠟꠣ, “ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠀꠋꠉꠥꠞ ꠈꠦꠔ ꠇꠞꠤꠀ ꠔꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠛꠦꠠꠣ ꠖꠤꠟꠣ। ꠛꠣꠖꠦ ꠀꠋꠉꠥꠞꠞ ꠞꠡ ꠛꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇ ꠉꠣꠔ ꠈꠥꠖꠤꠟꠣ ꠀꠞ ꠌꠇꠤꠖꠣꠞꠞ ꠟꠣꠉꠤ ꠃꠌꠣ ꠇꠞꠤ ꠄꠇꠈꠣꠘ ꠐꠋ-ꠊꠞ ꠛꠣꠘꠣꠁꠟꠣ। ꠢꠦꠡꠦ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠈꠦꠔ ꠛꠣꠉꠤ ꠖꠤꠀ ꠝꠣꠟꠤꠇ ꠛꠤꠖꠦꠡ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK12_2","071_12_2","MRK","12","2","2","ꠀꠋꠉꠥꠞ ꠙꠣꠇꠤꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠄꠇ ꠉꠥꠟꠣꠝꠞꠦ ꠛꠣꠉꠤꠖꠣꠞꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠔꠣꠘ ꠛꠣꠐ ꠀꠘꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK12_3","071_12_3","MRK","12","3","3","ꠅꠁꠟꠦ ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠦ ꠁ ꠉꠥꠟꠣꠝꠞꠦ ꠗꠞꠤ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠤ, ꠈꠣꠟꠤ ꠀꠔꠦ ꠛꠤꠖꠣꠄ ꠇꠞꠤ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_4","071_12_4","MRK","12","4","4","ꠔꠦꠃ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠀꠞꠅ ꠄꠇ ꠉꠥꠟꠣꠝꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ। ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠦ ꠔꠣꠞꠦꠅ ꠉꠣꠟꠣ-ꠉꠣꠟꠤ ꠇꠞꠤꠀ ꠝꠣꠞꠤꠀ ꠔꠣꠞ ꠝꠣꠕꠣ ꠚꠣꠐꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_5","071_12_5","MRK","12","5","5","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠞꠅ ꠄꠇꠎꠘꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ। ꠄꠘꠞꠦ ꠔꠣꠞꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠟ। ꠅꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠔꠣꠁꠘ ꠀꠞꠅ ꠛꠃꠔ ꠎꠘꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ। ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠄꠎꠘꠞꠦ ꠔꠣꠞꠣ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠟ, ꠀꠞ ꠇꠄꠎꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_6","071_12_6","MRK","12","6","6","ꠢꠦꠡꠦ ꠝꠣꠟꠤꠇꠞ ꠈꠣꠟꠤ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠛꠣꠇꠤ ꠞꠁꠍꠤꠟ, ꠢꠦ ꠅꠁꠟ ꠔꠣꠘ ꠝꠣꠄꠀꠞ ꠙꠥꠔ। ꠢꠦꠡ-ꠝꠦꠡ ꠔꠣꠁꠘ ꠅꠃ ꠙꠥꠀꠞꠦꠃ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠝꠘꠅ ꠇꠞꠟꠣ, ꠀꠝꠣꠞ ꠙꠥꠀꠞꠦ ꠔꠣꠞꠣ ꠁꠎ꠆ꠎꠔ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MK12_7","071_12_7","MRK","12","7","7","ꠅꠁꠟꠦ ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠤ ꠇꠁꠟ, ‘ꠅꠃ ꠙꠥꠀꠃ ꠔ ꠛꠣꠖꠦ ꠁ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠛ। ꠔꠦ ꠀꠅ, ꠄꠞꠦꠅ ꠀꠝꠞꠣ ꠝꠣꠞꠤꠟꠣꠁ, ꠔꠦꠃ ꠀꠝꠞꠣꠃ ꠁꠔꠣꠞ ꠝꠣꠟꠤꠇ ꠛꠘꠤꠎꠤꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("MK12_8","071_12_8","MRK","12","8","8","ꠇꠁꠀꠃ ꠔꠣꠞꠣ ꠙꠥꠀꠞꠦ ꠗꠞꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠀ, ꠀꠋꠉꠥꠞ ꠈꠦꠔꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_9","071_12_9","MRK","12","9","9","“ꠔꠦ ꠅꠈꠘ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠈꠦꠔꠞ ꠝꠣꠟꠤꠇꠦ ꠇꠤꠔꠣ ꠇꠞꠛꠣ? ꠔꠣꠁꠘ ꠀꠁꠀ ꠔ ꠅꠃ ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣ ꠀꠞ ꠈꠦꠔ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠛꠣꠉꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK12_10","071_12_10","MRK","12","10","10","ꠀꠙꠘꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠙꠠꠍꠂꠘ ꠘꠣ ꠘꠤ, ꠞꠣꠎ ꠝꠦꠡ꠆ꠔꠁꠞ ꠅꠇꠟꠦ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠛꠦꠇꠣꠝꠣ ꠇꠁꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠍꠤꠟ, ꠅꠇꠐꠣ ꠖꠤꠀꠃ ꠊꠞꠞ ꠁꠀꠘ ꠈꠥꠐꠤ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_11","071_12_11","MRK","12","11","11","ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠦꠃ ꠁꠔꠣ ꠅꠀꠁꠟꠣ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔ ꠀꠝꠞꠣꠞ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ ꠟꠣꠉꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK12_12","071_12_12","MRK","12","12","12","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠟꠤꠔ ꠌꠣꠁꠟ। ꠔꠣꠞꠣ ꠛꠥꠎꠤꠟꠤꠟ, ꠔꠣꠁꠘ ꠁ ꠇꠤꠌ꠆ꠍꠣ ꠔꠣꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦꠃ ꠇꠁꠞꠣ। ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞꠦ ꠒꠞꠣꠁꠀ ꠔꠣꠘꠞꠦ ꠍꠣꠠꠤꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK12_13","071_12_13","MRK","12","13","13","ꠛꠣꠖꠦ ꠅꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠚꠞꠤꠡꠤ ꠀꠞ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠖꠟꠞ ꠇꠄꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_14","071_12_14","MRK","12","14","14","ꠔꠣꠞꠣ ꠀꠁꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠀꠙꠘꠦ ꠄꠇꠎꠘ ꠢꠇ ꠝꠣꠘꠥꠡ। ꠝꠣꠘꠡꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠦ ꠛꠣ ꠘꠣ ꠇꠞꠦ, ꠁꠔꠣꠄ ꠀꠙꠘꠣꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠎꠣꠄ ꠀꠄ ꠘꠣ, ꠀꠙꠘꠦ ꠔ ꠇꠦꠃꠞꠞ ꠝꠥꠈꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠂꠘ ꠘꠣ। ꠢꠇ-ꠢꠣꠟꠣꠟ ꠘꠤꠅꠝꠦ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠣꠡ꠆ꠔꠣ ꠛꠣꠔꠣꠁ ꠖꠤꠞꠣ। ꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠔꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠞꠦ ꠈꠣꠎꠘꠣ ꠖꠦꠅꠀ ꠎꠣꠁꠎ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MK12_15","071_12_15","MRK","12","15","15","ꠀꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠈꠣꠎꠘꠣ ꠖꠤꠔꠣꠝ ꠘꠤ, ꠘꠣ ꠖꠤꠔꠣꠝ ꠘꠣ?” ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠜꠘ꠆ꠒꠣꠝꠤ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠛꠥꠎꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠞꠣꠄ? ꠖꠦꠈꠤ, ꠄꠇꠐꠣ ꠖꠤꠘꠣꠞ ꠀꠘꠤꠀ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK12_16","071_12_16","MRK","12","16","16","ꠔꠣꠞꠣ ꠖꠤꠘꠣꠞ ꠟꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟꠦ, ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁ ꠙꠄꠡꠣꠞ ꠃꠙꠞꠦ ꠇꠣꠞ ꠘꠣꠝ ꠀꠞ ꠍꠛꠤ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK12_17","071_12_17","MRK","12","17","17","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠦ ꠢꠥꠘꠅ, ꠛꠣꠖꠡꠣꠞ ꠎꠦꠔꠣ ꠁꠔꠣ ꠛꠣꠖꠡꠣꠞꠦ ꠖꠦꠅ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦꠔꠣ ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠖꠦꠅ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠀꠝ꠆ꠝꠇ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK12_18","071_12_18","MRK","12","18","18","ꠛꠣꠖꠦ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠝꠎꠛꠞ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠣ। ꠄꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠂꠘ, ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠂꠘ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK12_19","071_12_19","MRK","12","19","19","“ꠢꠥꠎꠥꠞ, ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠝꠥꠍꠟꠣ ꠟꠦꠈꠤꠀ ꠉꠦꠍꠂꠘ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠛꠤꠀ ꠇꠞꠤꠀ, ꠔꠣꠞ ꠛꠃꠞꠦ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠢꠣꠟꠔꠦ ꠕꠁꠀ ꠢꠦ ꠎꠥꠖꠤ ꠝꠣꠞꠣ ꠎꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠜꠣꠁꠄ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠔꠣꠞ ꠜꠣꠁꠞ ꠛꠋꠡ ꠛꠣꠌꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK12_20","071_12_20","MRK","12","20","20","ꠔꠦ ꠗꠞꠃꠇ꠆ꠇꠣ, ꠄꠇ ꠙꠞꠤꠛꠣꠞꠅ ꠡꠣꠔ ꠜꠣꠁ ꠀꠍꠤꠟ। ꠛꠠ ꠎꠘꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠢꠣꠟꠔꠦ ꠝꠣꠞꠣ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_21","071_12_21","MRK","12","21","21","ꠛꠣꠖꠦ ꠖꠥꠍꠞꠣ ꠜꠣꠁꠄ ꠔꠣꠞ ꠅꠃ ꠠꠣꠠꠤ ꠜꠣꠛꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠟ। ꠅꠁꠟꠦ ꠢꠦ-ꠅ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠞꠁꠀ ꠝꠣꠞꠣ ꠉꠦꠟ। ꠛꠣꠖꠦ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠜꠣꠁꠄ ꠛꠤꠀ ꠇꠞꠤꠀ ꠢꠦ-ꠅ ꠅꠃꠟꠣ ꠝꠣꠞꠣ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_22","071_12_22","MRK","12","22","22","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠞꠣ ꠡꠣꠔꠅ ꠜꠣꠁꠞ ꠇꠦꠃꠞꠞꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠟ ꠘꠣ। ꠢꠦꠡꠦ ꠅꠃ ꠛꠦꠐꠤꠅ ꠝꠣꠞꠣ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_23","071_12_23","MRK","12","23","23","ꠔꠦ ꠝꠞꠘ ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠝꠣꠘꠥꠡ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠁ ꠛꠦꠐꠤ, ꠄꠞꠣ ꠇꠥꠘ ꠜꠣꠁꠞ ꠛꠃ ꠅꠁꠛ? ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠔ ꠁ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MK12_24","071_12_24","MRK","12","24","24","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠎꠣꠘꠂꠘ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠔꠣꠇ꠆ꠇꠔꠅ ꠛꠥꠎꠂꠘ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠀꠙꠘꠣꠞꠣ ꠁ ꠜꠥꠟ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK12_25","071_12_25","MRK","12","25","25","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠎꠦꠛꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠔꠣ ꠘꠣꠄ, ꠇꠦꠃ ꠔꠣꠞꠣꠞꠦ ꠛꠤꠀ ꠖꠤꠔ-ꠅ ꠘꠣꠄ। ꠄꠞꠣ ꠔ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠤꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK12_26","071_12_26","MRK","12","26","26","ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠅ ꠔꠥꠞ ꠙꠣꠠꠞ ꠎꠋꠟꠣ ꠎꠟꠣꠞ ꠛꠄꠀꠘꠤꠞ ꠝꠣꠎꠦ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠤꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠀꠙꠘꠣꠞꠣ ꠙꠠꠍꠂꠘ ꠘꠣ ꠘꠤ? ꠀꠟ꠆ꠟꠣꠄ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠇꠁꠟꠣ, ‘ꠀꠝꠤꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠀꠟ꠆ꠟꠣ’। ");
INSERT INTO syls_vpl VALUES ("MK12_27","071_12_27","MRK","12","27","27","ꠔꠦ ꠀꠟ꠆ꠟꠣ ꠔ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ ꠘꠣꠄ, ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ। ꠀꠙꠘꠣꠞꠣ ꠔ ꠛꠃꠔ ꠛꠠ ꠜꠥꠟ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK12_28","071_12_28","MRK","12","28","28","ꠅꠃ ꠡꠝꠄ ꠄꠇꠎꠘ ꠝꠃꠟꠣꠘꠣ ꠀꠁꠀ ꠄꠞꠣꠞ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠢꠥꠘꠟꠣ। ꠀꠞ ꠁꠍꠣꠄ ꠎꠦꠘ ꠑꠤꠇ ꠎꠥꠀꠙ ꠖꠤꠍꠂꠘ ꠁꠈꠣꠘ ꠛꠥꠎꠤꠀ ꠄꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠞ ꠝꠣꠎꠦ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ ꠢꠥꠇꠥꠝ ꠇꠥꠘꠐꠣ?” ");
INSERT INTO syls_vpl VALUES ("MK12_29","071_12_29","MRK","12","29","29","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ ꠢꠥꠇꠥꠝ ꠅꠁꠟ, ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ ꠄꠇ। ");
INSERT INTO syls_vpl VALUES ("MK12_30","071_12_30","MRK","12","30","30","ꠔꠥꠝꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠤꠟ, ꠎꠣꠘ, ꠝꠘ ꠀꠞ ꠢꠇꠟ ꠡꠇ꠆ꠔꠤ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("MK12_31","071_12_31","MRK","12","31","31","ꠖꠥꠍꠞꠣ ꠢꠥꠇꠥꠝ ꠅꠁꠟ, ꠔꠥꠝꠞꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠤꠅ। ꠅꠃ ꠖꠥꠁꠅ ꠢꠥꠇꠥꠝ ꠕꠣꠇꠤ ꠛꠠ ꠀꠞ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK12_32","071_12_32","MRK","12","32","32","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠤ ꠝꠃꠟꠣꠘꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠝꠣꠞꠢꠣꠛꠣ! ꠀꠙꠘꠦ ꠔ ꠑꠤꠇꠃ ꠇꠁꠍꠂꠘ, ꠀꠟ꠆ꠟꠣ ꠄꠇ, ꠔꠣꠁꠘ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠛꠥꠖ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("MK12_33","071_12_33","MRK","12","33","33","ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠖꠤꠟ, ꠛꠤꠛꠦꠇ-ꠛꠥꠖ꠆ꠖꠤ, ꠢꠇꠟ ꠡꠇ꠆ꠔꠤ ꠖꠤꠀ ꠔꠣꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠣ, ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠣ ꠅꠁꠟ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠕꠣꠇꠤꠅ ꠎꠞꠥꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK12_34","071_12_34","MRK","12","34","34","ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣ, ꠅꠃ ꠝꠃꠟꠣꠘꠣꠄ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠎꠥꠀꠙ ꠖꠤꠍꠂꠘ, ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠕꠣꠇꠤ ꠀꠙꠘꠦ ꠔ ꠛꠦꠡꠤ ꠖꠥꠞꠁ ꠘꠣꠄ।” ꠄꠞꠛꠣꠖꠦ ꠕꠘꠦ ꠁꠍꠣꠞꠦ ꠇꠥꠘꠥ ꠍꠅꠀꠟ ꠇꠞꠣꠞ ꠡꠣꠅꠡ ꠀꠞ ꠇꠦꠃꠞꠞ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK12_35","071_12_35","MRK","12","35","35","ꠁꠍꠣꠄ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠎꠤꠇꠣꠁꠟꠣ, “ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠇꠦꠝꠘꠦ ꠇꠂꠘ, ꠀꠟ-ꠝꠍꠤ ꠅꠁꠟꠣ ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ? ");
INSERT INTO syls_vpl VALUES ("MK12_36","071_12_36","MRK","12","36","36","ꠖꠣꠃꠖꠦ ꠔ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠇꠁꠍꠂꠘ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠇꠁꠟꠣ, ꠀꠝꠤ ꠎꠔ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ ꠘꠣ ꠚꠣꠟꠣꠁ, ꠅꠔ ꠡꠝꠄ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠛꠅ। ");
INSERT INTO syls_vpl VALUES ("MK12_37","071_12_37","MRK","12","37","37","ꠖꠣꠃꠖꠦ ꠎꠦꠛꠟꠣ ꠘꠤꠎꠦꠃ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠣꠘ ꠝꠥꠘꠤꠛ ꠇꠁꠍꠂꠘ, ꠔꠦ ꠀꠟ-ꠝꠍꠤ ꠇꠦꠝꠘꠦ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ ꠅꠁꠛꠣ?” ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠁꠍꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_38","071_12_38","MRK","12","38","38","ꠛꠄꠀꠘꠞ ꠝꠣꠎꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ। ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠟꠣꠝ꠆ꠛꠣ ꠟꠣꠝ꠆ꠛꠣ ꠎꠥꠛ꠆ꠛꠣ ꠚꠤꠘ꠆ꠖꠤꠀ ꠛꠣꠎꠣꠞ-ꠀꠐꠅ ꠊꠥꠞꠣ-ꠚꠤꠞꠣ ꠇꠞꠂꠘ ꠀꠞ ꠁꠎ꠆ꠎꠔ ꠙꠣꠁꠔꠣ ꠌꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("MK12_39","071_12_39","MRK","12","39","39","ꠔꠣꠞꠣꠞ ꠡꠈ ꠅꠁꠟ ꠇꠥꠘꠥ ꠝꠎꠟꠤꠍꠅ ꠉꠦꠟꠦ ꠖꠣꠝꠤ ꠎꠣꠉꠣꠔ ꠛꠅꠀ, ꠈꠣꠘꠤꠞ ꠡꠝꠄ ꠍꠣꠝꠘꠞ ꠇꠣꠔꠣꠞꠅ ꠛꠁꠀ ꠈꠣꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("MK12_40","071_12_40","MRK","12","40","40","ꠄꠇꠛꠣꠄ ꠔꠣꠞꠣ ꠟꠣꠝ꠆ꠛꠣ ꠟꠣꠝ꠆ꠛꠣ ꠖꠥꠀ ꠇꠞꠤꠀ ꠝꠣꠘꠡꠞ ꠝꠘ ꠉꠟꠣꠁꠘ, ꠀꠞꠇꠛꠣꠄ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠎꠝꠤ-ꠝꠤꠞꠣꠡ ꠖꠈꠟ ꠇꠞꠤ ꠘꠦꠁꠘ। ꠢꠣꠡꠞꠞ ꠝꠄꠖꠣꠘꠅ ꠄꠞꠣꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ ꠝꠍꠤꠛꠔ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK12_41","071_12_41","MRK","12","41","41","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠟꠤꠟ꠆ꠟꠣꠞ ꠒꠦꠉꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠁꠀ ꠖꠦꠈꠟꠣ, ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠇꠦꠝꠘꠦ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠖꠤꠞꠣ। ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠛꠃꠔ ꠗꠘꠤ ꠝꠣꠘꠡꠦ ꠛꠦꠡ ꠇꠞꠤ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠖꠣꠘ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK12_42","071_12_42","MRK","12","42","42","ꠛꠣꠖꠦ ꠄꠇ ꠉꠞꠤꠛ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠄ ꠀꠁꠀ ꠈꠣꠟꠤ ꠖꠥꠁꠐꠣ ꠙꠄꠡꠣ ꠖꠣꠘ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_43","071_12_43","MRK","12","43","43","ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠕꠘꠦ ꠅꠃ ꠛꠦꠐꠤꠄ ꠛꠦꠡꠤ ꠖꠣꠘ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MK12_44","071_12_44","MRK","12","44","44","ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠛꠃꠔ ꠗꠘ-ꠍꠣꠝꠣꠘ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠅꠋꠡ ꠖꠣꠘ ꠇꠞꠍꠦ, ꠅꠁꠟꠦ ꠁ ꠛꠦꠐꠤ ꠅꠜꠣꠛꠤ ꠅꠁꠟꠦꠅ, ꠛꠦꠐꠤꠄ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠞꠣꠈꠤꠀ, ꠢꠇꠟꠔꠣꠃ ꠖꠣꠘ ꠇꠞꠤ ꠖꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MK13_1","071_13_1","MRK","13","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠔꠣꠘ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤꠄ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠃ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠇꠔ ꠛꠠ ꠛꠠ ꠙꠣꠔ꠆ꠔꠞꠞ ꠅꠀꠟ ꠀꠞ ꠡꠥꠘ꠆ꠖꠞ ꠡꠥꠘ꠆ꠖꠞ ꠖꠟꠣꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK13_2","071_13_2","MRK","13","2","2","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠅꠃ ꠎꠦꠔꠣ ꠛꠠ ꠛꠠ ꠖꠟꠣꠘ ꠖꠦꠈꠞꠣꠄ, ꠁꠔꠣꠞ ꠖꠥꠁ ꠙꠣꠔ꠆ꠔꠞ ꠄꠇꠈꠣꠘꠅ ꠟꠣꠉꠣꠁꠟ ꠞꠁꠔ ꠘꠣꠄ, ꠢꠇꠟꠔꠣ ꠜꠣꠋꠉꠣ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK13_3","071_13_3","MRK","13","3","3","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠎꠄꠔꠥꠘ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠇꠣꠛꠣ ꠡꠞꠤꠚ ꠝꠥꠈꠣ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞ, ꠁꠀꠇꠥꠛ, ꠢꠣꠘ꠆ꠘꠣꠘ ꠀꠞ ꠀꠘ꠆ꠖꠞꠤꠀꠍꠦ ꠔꠣꠘꠞꠦ ꠘꠤꠞꠣꠟꠣꠄ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK13_4","071_13_4","MRK","13","4","4","“ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠃꠇ꠆ꠇꠣ, ꠁꠔꠣ ꠇꠥꠘ ꠡꠝꠄ ꠅꠁꠛ? ꠇꠥꠘ ꠀꠟꠣꠝꠔ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠛꠥꠎꠝꠥ, ꠁꠔꠣ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("MK13_5","071_13_5","MRK","13","5","5","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠖꠦꠈꠤꠅ, ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣ ꠐꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("MK13_6","071_13_6","MRK","13","6","6","ꠛꠃꠔ ꠎꠘꠦ ꠀꠝꠣꠞ ꠘꠣꠝ ꠗꠞꠤꠀ ꠀꠁꠀ ꠇꠁꠛ, ꠀꠝꠤꠃ ꠢꠦꠁꠘ, ꠇꠁꠀ ꠛꠃꠔꠞꠦ ꠐꠉꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MK13_7","071_13_7","MRK","13","7","7","ꠅꠁꠟꠦ ꠎꠥꠖ꠆ꠖꠞ ꠀꠅꠀꠎ ꠀꠞ ꠟꠣꠠꠣꠁꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠁꠔꠣ ꠘꠤꠌꠄ ꠊꠐꠛ, ꠊꠐꠟꠦꠅ ꠁꠔꠣ ꠔ ꠡꠦꠡ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK13_8","071_13_8","MRK","13","8","8","ꠄꠇ ꠎꠣꠔꠤꠄ ꠀꠞꠇ ꠎꠣꠔꠤꠞ ꠟꠉꠦ, ꠄꠇ ꠖꠦꠡꠦ ꠀꠞꠇ ꠖꠦꠡꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠛ। ꠛꠃꠔ ꠎꠣꠉꠣꠔ ꠜꠂꠍꠣꠟ ꠀꠞ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠛ। ꠅꠁꠟꠦ ꠁꠔꠣ ꠔ ꠈꠣꠟꠤ ꠝꠍꠤꠛꠔꠞ ꠡꠥꠞꠥ। ");
INSERT INTO syls_vpl VALUES ("MK13_9","071_13_9","MRK","13","9","9","“ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ। ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠗꠞꠤꠀ ꠛꠤꠌꠣꠞꠞ ꠀꠖꠣꠟꠔꠅ ꠡꠝꠎꠣꠁꠛ। ꠝꠍꠤꠖꠞ ꠜꠤꠔꠞꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠣ ꠅꠁꠛ। ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠡꠞ ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣꠞ ꠍꠣꠝꠘꠦ ꠘꠦꠅꠀ ꠅꠁꠛ। ꠔꠥꠝꠞꠣ ꠄꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK13_10","071_13_10","MRK","13","10","10","ꠙꠄꠟꠣ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("MK13_11","071_13_11","MRK","13","11","11","ꠔꠥꠝꠞꠣꠞꠦ ꠗꠞꠤꠀ ꠎꠦꠛꠟꠣ ꠛꠤꠌꠣꠞꠅ ꠘꠦꠅꠀ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠇꠤꠔꠣ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ, ꠁꠔꠣ ꠟꠁꠀ ꠀꠉꠦ ꠇꠥꠘꠥ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠤꠇꠣꠁꠀ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠔꠥꠝꠞꠣ ꠅꠔꠣꠃ ꠇꠁꠅ। ꠀꠍꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠢꠤꠘꠅ ꠝꠣꠔꠔꠣꠄ ꠘꠣꠄ, ꠙꠣꠇ ꠞꠥꠢꠦꠃ ꠝꠣꠔꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_12","071_13_12","MRK","13","12","12","ꠜꠣꠁꠄ ꠜꠣꠁꠞꠦ, ꠛꠣꠚꠦ ꠙꠥꠀꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠗꠞꠣꠁ ꠖꠤꠛ। ꠙꠥꠀ-ꠙꠥꠠꠤꠄ ꠀꠙꠘ ꠝꠣ-ꠛꠣꠚꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠉꠤꠀ, ꠝꠣ-ꠛꠣꠚꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK13_13","071_13_13","MRK","13","13","13","ꠀꠞ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠢꠇꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠛ, ꠅꠁꠟꠦ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠦ ꠐꠤꠇꠤꠀ ꠞꠁꠛ, ꠢꠦ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK13_14","071_13_14","MRK","13","14","14","“ꠎꠦ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠦꠞ ꠢꠦ ꠛꠥꠎꠃꠇ, ꠛꠦꠎꠥꠁꠔꠣ ꠝꠍꠤꠛꠔꠞ ꠊꠤꠘ꠆ꠘꠣꠞ ꠁ ꠌꠤꠎ ꠎꠦ ꠎꠣꠉꠣꠔ ꠀꠅꠀꠞ ꠇꠕꠣ ꠘꠣꠄ, ꠁ ꠌꠤꠎꠞꠦ ꠎꠦꠛꠟꠣ ꠅꠘꠅ ꠖꠦꠈꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠀꠍꠂꠘ, ꠔꠣꠞꠣ ꠜꠣꠉꠤꠀ ꠙꠣꠠꠤꠀ ꠄꠟꠣꠇꠣꠔ ꠎꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MK13_15","071_13_15","MRK","13","15","15","ꠍꠣꠔꠞ ꠃꠙꠞꠦ ꠎꠦꠞꠣ ꠞꠁꠛꠣ, ꠔꠣꠞꠣ ꠟꠣꠝꠣꠔ ꠟꠣꠝꠤꠀ ꠇꠥꠘ꠆ꠔꠣ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠀꠞ ꠘꠣ ꠢꠣꠝꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MK13_16","071_13_16","MRK","13","16","16","ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣ ꠞꠁꠛꠣ, ꠔꠣꠞꠣꠞ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠛꠣꠠꠤꠔ ꠘꠣ ꠀꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("MK13_17","071_13_17","MRK","13","17","17","ꠅꠃ ꠡꠝꠄ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠔꠣ, ꠀꠞ ꠎꠦꠞꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠛꠥꠇꠥꠞ ꠖꠥꠗ ꠈꠣꠅꠀꠁꠞꠣ, ꠔꠣꠞꠣꠞ ꠛꠠ ꠎꠛꠞ ꠝꠍꠤꠛꠔ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK13_18","071_13_18","MRK","13","18","18","ꠔꠥꠝꠞꠣ ꠖꠥꠀ ꠇꠞꠅ, ꠁꠔꠣ ꠎꠣꠘꠥ ꠡꠤꠔꠞ ꠖꠤꠘꠅ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("MK13_19","071_13_19","MRK","13","19","19","ꠅꠃ ꠡꠝꠄ ꠔ ꠅꠔ ꠛꠦꠎꠥꠁꠔꠣ ꠇꠡ꠆ꠐ ꠅꠁꠛ, ꠎꠦꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠙꠄꠟꠣ ꠕꠘꠦ ꠀꠁꠎ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠁꠔ-ꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK13_20","071_13_20","MRK","13","20","20","ꠝꠣꠛꠥꠖꠦ ꠎꠥꠖꠤ ꠁ ꠡꠝꠄꠞꠦ ꠇꠝꠣꠁꠀ ꠘꠣ ꠖꠤꠔꠣ, ꠔꠦ ꠇꠦꠃ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠟ ꠘꠣ ꠅꠘꠦ। ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠁ ꠡꠝꠄ ꠇꠝꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK13_21","071_13_21","MRK","13","21","21","ꠢꠤ ꠡꠝꠄ ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠄ, ‘ꠢꠥꠘꠍ ꠘꠤ, ꠀꠟ-ꠝꠍꠤ ꠅꠘꠅ ꠀꠁꠍꠂꠘ’, ꠛꠣ ‘ꠖꠦꠈꠅ, ꠅꠃꠘꠥ ꠔꠣꠁꠘ’, ꠔꠦ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_22","071_13_22","MRK","13","22","22","ꠇꠣꠞꠘ ꠛꠃꠔ ꠜꠘ꠆ꠒꠄ ꠀꠁꠀ ꠇꠁꠛ, ꠀꠝꠤꠃ ꠀꠟ-ꠝꠍꠤ, ꠀꠞ ꠛꠃꠔ ꠜꠘ꠆ꠒ ꠘꠛꠤꠅ ꠀꠁꠛꠣ। ꠡꠝ꠆ꠛꠛ ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦꠅ ꠗꠥꠇꠣ ꠖꠤꠀ ꠛꠦ-ꠙꠕꠦ ꠘꠤꠔꠣ ꠇꠞꠤ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ-ꠝꠥꠎꠦꠎꠣ ꠖꠦꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_23","071_13_23","MRK","13","23","23","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠉꠦꠃ ꠁꠔꠣ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("MK13_24","071_13_24","MRK","13","24","24","“ꠅꠃ ꠝꠍꠤꠛꠔꠞ ꠡꠝꠄ ꠙꠣꠞꠘꠤꠞ ꠛꠣꠖꠦ, ꠡꠥꠞꠥꠎ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠎꠤꠛ, ꠌꠣꠘ꠆ꠖꠦ ꠀꠞ ꠚꠞ ꠖꠤꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK13_25","071_13_25","MRK","13","25","25","ꠔꠦꠞꠣ ꠅꠇꠟ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠈꠥꠟꠤꠀ ꠙꠠꠤꠎꠤꠛ, ꠀꠍꠝꠣꠘꠞ ꠇꠥꠘꠥ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠌꠤꠎꠃ ꠑꠤꠇ-ꠑꠣꠇ ꠞꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK13_26","071_13_26","MRK","13","26","26","ꠅꠃ ꠡꠝꠄ ꠝꠣꠘꠡꠦ ꠖꠦꠈꠛꠣ, ꠛꠤꠘ-ꠀꠖꠝꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠎꠣꠟꠣꠟ ꠀꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤꠄ, ꠝꠦꠊꠞ ꠐꠥꠇꠞꠣꠔ ꠅꠁꠀ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_27","071_13_27","MRK","13","27","27","ꠔꠣꠁꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠖꠥꠘꠤꠀꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣꠔ ꠙꠣꠑꠣꠁꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠘꠦ ꠖꠟꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_28","071_13_28","MRK","13","28","28","“ꠒꠥꠝꠥꠞ ꠉꠣꠍꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠁꠟꠤꠝ ꠇꠣꠝꠣꠁ ꠇꠞꠅ। ꠉꠣꠍꠞ ꠒꠣꠟ-ꠙꠣꠟꠣ ꠘꠞꠝ ꠅꠁꠀ ꠎꠦꠛꠟꠣ ꠘꠄꠀ ꠇꠥꠠꠤ ꠛꠣꠞꠅꠄ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠤꠟꠣꠅ ꠉꠞꠝꠞ ꠖꠤꠘ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("MK13_29","071_13_29","MRK","13","29","29","ꠔꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠛꠣꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠊꠐꠦꠞ, ꠖꠦꠈꠤꠀ ꠛꠥꠎꠤꠟꠤꠅ, ꠛꠤꠘ-ꠀꠖꠝꠅ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠂꠘ। ꠈꠣꠟꠤ ꠗꠣꠞꠅ ꠘꠣꠄ, ꠔꠣꠁꠘ ꠀꠁꠀ ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_30","071_13_30","MRK","13","30","30","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠁꠔꠣ ꠘꠣ ꠊꠐꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠥꠡ ꠚꠥꠠꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK13_31","071_13_31","MRK","13","31","31","ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠢꠇꠟꠔꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠣꠝꠦꠡꠣ ꠇꠣꠁꠝ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK13_32","071_13_32","MRK","13","32","32","“ꠢꠃ ꠖꠤꠘ ꠀꠞ ꠢꠤ ꠡꠝꠄꠅꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠛꠣꠖꠦ ꠀꠞ ꠇꠦꠃ ꠎꠣꠘꠂꠘ ꠘꠣ। ꠀꠍꠝꠣꠘꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠣ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠦꠅ ꠎꠣꠘꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_33","071_13_33","MRK","13","33","33","ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠅꠅ, ꠈꠤꠀꠟ ꠇꠞꠤ ꠌꠟꠅ ꠀꠞ ꠖꠥꠀ ꠇꠞꠅ। ꠢꠤ ꠖꠤꠘ ꠇꠥꠘ ꠡꠝꠄ ꠀꠁꠛ, ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠔ ꠎꠣꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_34","071_13_34","MRK","13","34","34","ꠅꠟꠣ ꠄꠇ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠢꠤ ꠖꠤꠘ ꠀꠁꠛ, ꠎꠦꠁꠘ ꠛꠤꠖꠦꠡ ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠀꠔꠅ ꠢꠇꠟꠔꠣ ꠡꠝꠎꠣꠁ ꠖꠤꠀ ꠎꠣꠞꠎꠤꠞ ꠇꠣꠝ ꠛꠥꠎꠣꠁ ꠖꠤꠟꠣ। ꠀꠞ ꠌꠇꠤꠖꠣꠞꠞꠦ ꠇꠁꠟꠣ ꠢꠎꠣꠉ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("MK13_35","071_13_35","MRK","13","35","35","ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠢꠎꠣꠉ ꠞꠁꠅ। ꠛꠣꠠꠤꠞ ꠝꠣꠟꠤꠇ ꠇꠥꠘ ꠡꠝꠄ ꠀꠁꠛꠣ, ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ, ꠝꠣꠎ ꠞꠣꠁꠔꠦ, ꠙꠔꠣꠛꠣꠟꠣ ꠘꠣ ꠚꠎꠞꠦ ꠀꠁꠛꠣ, ꠁꠈꠣꠘ ꠔ ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠎꠣꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK13_36","071_13_36","MRK","13","36","36","ꠔꠣꠁꠘ ꠀꠈꠔꠣ ꠀꠁꠟꠦ ꠎꠣꠘꠥ ꠘꠣ ꠖꠦꠈꠂꠘ, ꠔꠥꠝꠞꠣ ꠊꠥꠝꠣꠁ ꠞꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("MK13_37","071_13_37","MRK","13","37","37","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠁꠟꠣꠝ, ꠢꠇꠟꠞꠦꠃ ꠅꠃꠟꠣ ꠇꠁꠞꠣꠝ, ꠢꠎꠣꠉ ꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK14_1","071_14_1","MRK","14","1","1","ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠞ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖꠞ ꠈꠣꠟꠤ ꠖꠥꠁ ꠖꠤꠘ ꠛꠣꠇꠤ ꠞꠁꠍꠦ। ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ, ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠝꠣꠘꠡꠞ ꠀꠚꠞꠈꠦ ꠗꠞꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠗꠣꠘ꠆ꠖꠣ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_2","071_14_2","MRK","14","2","2","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠁꠖꠞ ꠡꠝꠄ ꠔꠣꠞꠦ ꠗꠞꠔꠣꠝ ꠘꠣꠄ। ꠗꠞꠟꠦ ꠝꠣꠘꠡꠦ ꠉꠘ꠆ꠒꠉꠥꠟ ꠟꠣꠉꠣꠁ ꠖꠤꠔ ꠙꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK14_3","071_14_3","MRK","14","3","3","ꠁꠍꠣ ꠅꠃ ꠡꠝꠄ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠉꠣꠃꠞ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤ ꠍꠣꠁꠝꠘꠞ ꠛꠣꠠꠤꠔ ꠀꠍꠟꠣ। ꠅꠘꠅ ꠛꠁꠀ ꠔꠣꠁꠘ ꠈꠣꠘꠣ ꠈꠣꠁꠞꠣ, ꠀꠈꠔꠣꠃ ꠄꠇ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠦ ꠌꠤꠘꠞ ꠄꠇ ꠛꠥꠔꠟꠅ ꠇꠞꠤ ꠈꠥꠛ ꠖꠣꠝꠤ ꠈꠣꠐꠤ ꠀꠔꠞ ꠟꠁꠀ ꠀꠁꠀ, ꠛꠥꠔꠟ ꠜꠣꠋꠉꠤꠀ ꠢꠇꠟ ꠀꠔꠞ ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠓꠣꠟꠤ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_4","071_14_4","MRK","14","4","4","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠤꠘꠅ ꠀꠎꠤꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠘꠣ-ꠈꠥꠡ ꠅꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟ, “ꠁ ꠀꠔꠞ ꠚꠥꠐꠣꠁꠘ ꠇꠦꠘꠦ ꠛꠞꠛꠣꠖ ꠇꠞꠣ ꠅꠁꠟ? ");
INSERT INTO syls_vpl VALUES ("MK14_5","071_14_5","MRK","14","5","5","ꠁ ꠚꠥꠐꠤꠘ ꠛꠦꠌꠤꠟꠦ ꠔ ꠔꠤꠘ-ꠡ ꠖꠤꠘꠣꠞ ꠙꠣꠁꠀ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀ ꠉꠦꠟ ꠅꠘꠦ।” ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠛꠦꠐꠤꠞꠦ ꠛꠇꠣ-ꠎꠇꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_6","071_14_6","MRK","14","6","6","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅꠁꠍꠦ, ꠔꠣꠘꠞꠦ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠅ ꠘꠣ। ꠔꠣꠁꠘ ꠔ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠇꠣꠝ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK14_7","071_14_7","MRK","14","7","7","ꠉꠞꠤꠛ ꠅꠇꠟ ꠔ ꠢꠣꠝꠦꠡꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠛꠣ। ꠔꠥꠝꠞꠣꠞ ꠎꠦꠛꠟꠣ ꠝꠘꠦ ꠌꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠔ ꠢꠣꠝꠦꠡꠣ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("MK14_8","071_14_8","MRK","14","8","8","ꠛꠦꠌꠣꠠꠤꠄ ꠎꠦꠈꠣꠘ ꠙꠣꠞꠍꠂꠘ ꠅꠈꠣꠘꠃ ꠇꠞꠍꠂꠘ। ꠄꠁꠘ ꠀꠁꠀ ꠀꠝꠣꠞ ꠉꠔꠞꠅ ꠀꠔꠞ ꠓꠣꠟꠤꠀ, ꠖꠣꠚꠘ-ꠇꠣꠚꠘꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠀꠉꠦꠃ ꠎꠥꠁꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK14_9","071_14_9","MRK","14","9","9","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠀꠞ, ꠖꠥꠘꠤꠀꠞ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ ꠀꠟ꠆ꠟꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠡꠝꠄ, ꠅꠃ ꠛꠦꠌꠣꠠꠤꠞꠦ ꠝꠘꠅ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠘ ꠁ ꠇꠣꠝꠞ ꠇꠕꠣ ꠈꠣꠘꠅ ꠇꠅꠀ ꠎꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK14_10","071_14_10","MRK","14","10","10","ꠛꠣꠖꠦ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ, ꠄꠘ ꠘꠣꠝ ꠁꠢꠥꠖꠣ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔ, ꠄꠁꠘ ꠁꠍꠣꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_11","071_14_11","MRK","14","11","11","ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠢꠥꠘꠤꠀ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠔꠣꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠤꠟꠦ ꠔꠥꠝꠣꠞꠦ ꠐꠦꠇꠣ ꠖꠤꠝꠥ।” ꠔꠦꠃ ꠁꠢꠥꠖꠣꠄ ꠔꠣꠘꠞꠦ ꠗꠞꠣꠁ ꠖꠦꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠔꠥꠇꠣꠘꠤꠔ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_12","071_14_12","MRK","14","12","12","ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖꠞ ꠙꠄꠟꠣ ꠖꠤꠘ, ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠟꠣꠉꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠎꠛ ꠇꠞꠣ ꠅꠁꠔ। ꠄꠞꠖꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠀꠙꠘꠣꠞ ꠟꠣꠉꠤ ꠁꠖꠞ ꠈꠣꠘꠣ ꠔꠤꠀꠞ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("MK14_13","071_14_13","MRK","14","13","13","ꠅꠃ ꠁꠍꠣꠄ ꠔꠣꠘ ꠖꠥꠁꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠐꠣꠃꠘꠅ ꠎꠣꠅ। ꠉꠤꠀ ꠖꠦꠈꠛꠣꠄ ꠢꠘꠅ ꠄꠇ ꠛꠦꠐꠣ ꠝꠣꠘꠡꠦ ꠈꠂꠟꠣꠖꠤ ꠙꠣꠘꠤ ꠜꠞꠤꠀ ꠘꠤꠞꠣ। ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠎꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("MK14_14","071_14_14","MRK","14","14","14","ꠔꠣꠁꠘ ꠎꠦ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠛꠣ, ꠢꠃ ꠛꠣꠠꠤꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠔꠥꠝꠞꠣ ꠇꠁꠅ, ‘ꠍꠣꠛ, ꠝꠥꠞꠡꠤꠖꠦ ꠇꠁꠍꠂꠘ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠀꠝꠤ ꠎꠦꠈꠣꠘꠅ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠈꠣꠘꠣ ꠈꠣꠁꠔꠣꠝ, ꠢꠃ ꠝꠥꠍꠣꠚꠤꠞꠈꠣꠘꠣ ꠈꠣꠘ ꠖꠦꠈꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MK14_15","071_14_15","MRK","14","15","15","ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠙꠞ ꠔꠣꠟꠣꠔ ꠢꠣꠎꠣꠁꠟ-ꠙꠣꠠꠣꠁꠟ ꠄꠇ ꠛꠠ ꠇꠥꠑꠣ ꠖꠦꠈꠣꠁ ꠖꠤꠛꠣ। ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠢꠇꠟꠔꠣ ꠔꠤꠀꠞ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK14_16","071_14_16","MRK","14","16","16","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠉꠤꠀ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠁꠟꠣ। ꠢꠣꠝꠣꠁꠀ ꠁꠍꠣꠄ ꠎꠦꠟꠣꠈꠣꠘ ꠇꠁꠍꠟꠣ, ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠇꠟꠔꠣ ꠙꠣꠁꠟꠣ ꠀꠞ ꠁꠖꠞ ꠈꠣꠘꠣ ꠔꠤꠀꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_17","071_14_17","MRK","14","17","17","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠟꠁꠀ ꠅꠘꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_18","071_14_18","MRK","14","18","18","ꠀꠁꠀ ꠈꠣꠘꠤ ꠈꠣꠅꠀꠞ ꠡꠝꠄ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇ ꠎꠘꠦꠃ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠗꠞꠣꠁ ꠖꠤꠛ, ꠢꠦ ꠅꠈꠘ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠁꠀ ꠈꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK14_19","071_14_19","MRK","14","19","19","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠉꠦꠟꠣ। ꠀꠞ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠎꠘ ꠇꠤꠔꠣ ꠀꠝꠤ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK14_20","071_14_20","MRK","14","20","20","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠦ ꠅꠃ ꠛꠣꠞꠅꠎꠘꠞ ꠝꠣꠎꠞꠃ ꠄꠇꠎꠘ। ꠢꠦ ꠅꠈꠘ ꠀꠝꠣꠞ ꠟꠉꠦ ꠕꠣꠟꠅ ꠀꠔ ꠢꠣꠞꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("MK14_21","071_14_21","MRK","14","21","21","ꠛꠤꠘ-ꠀꠖꠝꠞ ꠝꠃꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠎꠦꠟꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠣꠘ ꠝꠃꠔ ꠔ ꠅꠃꠟꠣꠃ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠀꠚꠍꠥꠍ ꠢꠃ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ, ꠎꠦ ꠔꠣꠘꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠤꠛ। ꠖꠥꠘꠤꠀꠔ ꠔꠣꠞ ꠎꠘꠝ ꠘꠣ ꠅꠀꠃ, ꠔꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠜꠣꠟꠣ ꠀꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MK14_22","071_14_22","MRK","14","22","22","ꠈꠣꠘꠣꠔ ꠞꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠞꠥꠐꠤ ꠀꠔꠅ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ, ꠍꠤꠠꠤꠀ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠀꠔꠅ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅꠃ ꠘꠦꠅ, ꠝꠘꠅ ꠇꠞꠅ ꠁꠔꠣ ꠀꠝꠣꠞ ꠡꠞꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("MK14_23","071_14_23","MRK","14","23","23","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔꠞ ꠙꠤꠀꠟꠣ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠀ ꠄꠞꠣꠞꠦ ꠖꠤꠟꠣ। ꠄꠞꠣ ꠢꠇꠟꠦ ꠅꠃ ꠙꠤꠀꠟꠣ ꠕꠣꠇꠤ ꠡꠞꠛꠔ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_24","071_14_24","MRK","14","24","24","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠈꠣꠅ, ꠝꠘꠅ ꠇꠞꠅ ꠁꠔꠣ ꠀꠝꠣꠞ ꠟꠃ। ꠅꠃ ꠟꠃꠞ ꠎꠞꠤꠀꠄ ꠀꠖꠝ ꠎꠣꠔꠤꠞ ꠛꠃꠔꠞ ꠛꠣꠌꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠣꠁꠝ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK14_25","071_14_25","MRK","14","25","25","ꠀꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠎꠦꠁ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠖꠣꠈꠤꠟ ꠅꠁꠀ ꠀꠝꠤ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠘꠣ ꠈꠣꠁꠍꠤ, ꠅꠔ ꠖꠤꠘ ꠁ ꠟꠣꠈꠣꠘ ꠡꠞꠛꠔ ꠀꠞ ꠈꠣꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK14_26","071_14_26","MRK","14","26","26","ꠢꠦꠡꠦ ꠢꠇꠟꠦ ꠝꠤꠟꠤ ꠄꠇ ꠉꠎꠟ ꠉꠣꠁꠀ, ꠊꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠎꠄꠔꠥꠘ ꠙꠣꠠꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK14_27","071_14_27","MRK","14","27","27","ꠙꠣꠠꠅ ꠉꠤꠀ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠔ ꠀꠝꠣꠞꠦ ꠚꠣꠟꠣꠁꠀ ꠜꠣꠉꠤꠛꠣꠄ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ‘ꠀꠝꠤ ꠙꠣꠟꠞ ꠞꠣꠈꠣꠟꠞꠦ ꠝꠣꠞꠤꠟꠤꠝꠥ, ꠔꠦꠃ ꠙꠣꠟꠞ ꠝꠦꠠꠣꠁꠘ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤꠎꠤꠛꠣ।’ ");
INSERT INTO syls_vpl VALUES ("MK14_28","071_14_28","MRK","14","28","28","ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣꠞ ꠛꠣꠖꠦ, ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦꠃ ꠀꠝꠤ ꠉꠣꠟꠤꠟꠅ ꠎꠣꠁꠝꠥꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK14_29","071_14_29","MRK","14","29","29","ꠙꠤꠔꠞꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠢꠇꠟ ꠜꠣꠉꠤ ꠉꠦꠟꠦꠅ ꠀꠝꠤ ꠜꠣꠉꠤꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK14_30","071_14_30","MRK","14","30","30","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠁꠎ ꠙꠔꠣꠛꠣꠟꠣ ꠝꠥꠞꠉꠣꠄ ꠖꠥꠁꠛꠣꠞ ꠛꠣꠋ ꠖꠤꠛꠣꠞ ꠀꠉꠦꠃ, ꠔꠥꠝꠤ ꠔꠤꠘꠛꠣꠞ ꠇꠁꠛꠣꠄ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK14_31","071_14_31","MRK","14","31","31","ꠅꠁꠟꠦ ꠙꠤꠔꠞꠦ ꠀꠞꠅ ꠛꠠ ꠉꠟꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ ꠅꠃ ꠇꠤꠔꠣ ꠇꠂꠘ, ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠝꠞꠘꠅ ꠅꠄ, ꠔꠣ-ꠅ ꠀꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠇꠁꠔꠣꠝ ꠘꠣꠄ ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠌꠤꠘꠤ ꠘꠣ।” ꠢꠇꠟ ꠍꠣꠢꠣꠛꠤꠄꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_32","071_14_32","MRK","14","32","32","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠉꠦꠔꠡꠤꠝꠣꠘꠤ ꠘꠣꠝꠞ ꠄꠇ ꠛꠣꠉꠣꠘꠅ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠔ ꠡꠝꠄ ꠗꠞꠤ ꠖꠥꠀ ꠇꠞꠝꠥ, ꠅꠔ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠛꠅꠀꠔ ꠞꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK14_33","071_14_33","MRK","14","33","33","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠙꠤꠔꠞ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠔꠣꠘ ꠟꠉꠦ ꠞꠣꠈꠟꠣ, ꠝꠘꠞ ꠖꠥꠈ ꠀꠞ ꠎꠣꠟꠣꠄ ꠔꠣꠁꠘ ꠛꠠ ꠔꠇꠟꠤꠚ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_34","071_14_34","MRK","14","34","34","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠖꠥꠈꠦ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠞ ꠅꠁ ꠎꠣꠞꠉꠤ। ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠅꠘꠅ ꠞꠅ ꠀꠞ ꠢꠎꠣꠉ ꠕꠣꠇꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK14_35","071_14_35","MRK","14","35","35","ꠇꠁꠀ ꠕꠥꠠꠣ ꠢꠞꠤꠀ ꠉꠤꠀ ꠔꠣꠁꠘ ꠝꠣꠐꠤꠔ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤꠀ ꠀꠞꠎ ꠇꠞꠟꠣ, ꠡꠝ꠆ꠛꠛ ꠅꠁꠟꠦ ꠁ ꠝꠍꠤꠛꠔꠞ ꠅꠇ꠆ꠔꠈꠣꠘ ꠢꠞꠤꠎꠤꠛꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("MK14_36","071_14_36","MRK","14","36","36","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅ ꠀꠛ꠆ꠛꠣ, ꠀꠝꠣꠞ ꠅꠟꠤ, ꠔꠥꠝꠤ ꠔ ꠢꠇꠟꠔꠣꠃ ꠇꠞꠔꠣꠄ ꠙꠣꠞ। ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠃꠙꠞ ꠕꠣꠇꠤ ꠀꠘꠦꠅꠀꠟꠣ ꠅꠃ ꠝꠍꠤꠛꠔ ꠈꠣꠘ ꠢꠞꠣꠁꠟꠣꠅ। ꠅꠁꠟꠦ ꠁꠔꠣ ꠀꠝꠣꠞ ꠁꠌ꠆ꠍꠣꠄ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇꠃ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("MK14_37","071_14_37","MRK","14","37","37","ꠍꠁꠎꠖꠣ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠄꠞꠣ ꠊꠥꠝꠣꠁ ꠉꠦꠍꠂꠘ। ꠅꠃ ꠔꠣꠁꠘ ꠙꠤꠔꠞꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠍꠣꠁꠝꠘ, ꠔꠥꠝꠤ ꠊꠥꠝꠣꠁ ꠉꠦꠟꠣꠄ ꠘꠤ? ꠄꠇꠈꠣꠘ ꠊꠘ꠆ꠐꠣꠅ ꠢꠎꠣꠉ ꠞꠁꠔꠣꠄ ꠙꠣꠞꠟꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MK14_38","071_14_38","MRK","14","38","38","ꠢꠎꠣꠉ ꠞꠅ, ꠙꠞꠤꠇ꠆ꠇꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠔꠣꠄ ꠇꠞꠤ ꠖꠥꠀ ꠇꠞꠅ। ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠘꠤꠌꠄ ꠈꠤꠀꠟ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠇꠣꠄꠀ ꠔ ꠇꠝꠎꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK14_39","071_14_39","MRK","14","39","39","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠉꠤꠀ ꠢꠃ ꠄꠇꠁ ꠖꠥꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_40","071_14_40","MRK","14","40","40","ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠄꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠊꠥꠝꠣꠁ ꠉꠦꠍꠂꠘ, ꠊꠥꠝꠦ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠚꠣꠟꠣꠁ ꠖꠦꠞ। ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠇꠤꠔꠣ ꠎꠥꠀꠙ ꠖꠤꠔꠣ, ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_41","071_14_41","MRK","14","41","41","ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠛꠣꠞ ꠔꠣꠁꠘ ꠀꠁꠀ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠖꠦꠈꠤ ꠅꠈꠘꠅ ꠀꠞꠣꠝꠦ ꠊꠥꠝꠣꠁꠞꠣꠄ। ꠀꠁꠌ꠆ꠍꠣ ꠅꠁꠍꠦ, ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ ꠔ। ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠦꠅꠀ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("MK14_42","071_14_42","MRK","14","42","42","ꠃꠑꠅ, ꠀꠝꠞꠣ ꠞꠅꠀꠘꠣ ꠖꠦꠁ। ꠀꠝꠣꠞꠦ ꠎꠦꠉꠤꠄ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠛ, ꠢꠦ ꠀꠁꠀ ꠀꠎꠤꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK14_43","071_14_43","MRK","14","43","43","ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠅ ꠞꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠣ ꠢꠘꠅ ꠀꠁꠟ। ꠢꠦ ꠀꠍꠤꠟ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ। ꠔꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠀꠞꠅ ꠛꠃꠔꠦ ꠟꠣꠑꠤ-ꠍꠐꠣ-ꠔꠟꠥꠀꠞ ꠟꠁꠀ ꠀꠁꠟ। ꠛꠠ ꠁꠝꠣꠝ, ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠄꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK14_44","071_14_44","MRK","14","44","44","ꠔꠣꠘꠞꠦ ꠎꠦꠉꠤꠄ ꠗꠞꠣꠁꠀ ꠖꠤꠔ, ꠢꠦ ꠔꠣꠞ ꠟꠉꠞ ꠄꠞꠣꠞꠦ ꠀꠉꠦ ꠢꠤꠇꠣꠁꠀ ꠖꠤꠍꠤꠟ, “ꠀꠝꠤ ꠉꠤꠀ ꠎꠦꠘ ꠉꠣꠟꠅ ꠢꠥꠋꠉꠣ ꠖꠤꠝꠥ, ꠄꠁꠘꠃ ꠢꠃ ꠎꠘ। ꠔꠥꠝꠞꠣ ꠄꠘꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤꠀ ꠈꠥꠛ ꠡꠣꠛꠗꠣꠘꠦ ꠟꠁꠀ ꠎꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK14_45","071_14_45","MRK","14","45","45","ꠔꠦꠃ ꠁꠢꠥꠖꠣꠄ ꠡꠥꠎꠣ-ꠡꠥꠎꠤ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ!” ꠇꠁꠀ ꠢꠦ ꠔꠣꠘꠞꠦ ꠢꠥꠋꠉꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_46","071_14_46","MRK","14","46","46","ꠟꠉꠦ ꠟꠉꠦ ꠔꠣꠞꠣ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_47","071_14_47","MRK","14","47","47","ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠦꠞꠣ ꠃꠛꠣꠔ ꠀꠍꠟꠣ, ꠄꠞꠣ ꠄꠇꠎꠘꠦ ꠘꠤꠎꠞ ꠔꠟꠥꠀꠞ ꠛꠣꠞ ꠇꠞꠤꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠍꠦꠖ ꠝꠣꠞꠟꠣ, ꠍꠦꠖꠞ ꠟꠉꠦ ꠔꠣꠞ ꠄꠇ ꠇꠣꠘ ꠇꠣꠐꠤꠀ ꠙꠠꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_48","071_14_48","MRK","14","48","48","ꠁꠍꠣꠄ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠀꠝꠤ ꠇꠥꠘꠥ ꠌꠥꠞ-ꠒꠣꠇꠣꠁꠔ ꠘꠤ, ꠔꠥꠝꠞꠣ ꠖꠦꠈꠤ ꠟꠣꠑꠤ-ꠍꠐꠣ-ꠔꠟꠥꠀꠞ ꠟꠁꠀ ꠀꠝꠣꠞꠦ ꠗꠞꠣꠔ ꠀꠁꠍ? ");
INSERT INTO syls_vpl VALUES ("MK14_49","071_14_49","MRK","14","49","49","ꠀꠝꠤ ꠔ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣꠝ। ꠅꠃ ꠡꠝꠄ ꠔ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠗꠞꠟꠣꠄ ꠘꠣ। ꠘꠤꠌꠄ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠀꠄꠀꠔ ꠔ ꠚꠟꠤꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK14_50","071_14_50","MRK","14","50","50","ꠔꠣꠘꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠔꠦꠃ ꠔꠣꠘ ꠢꠇꠟ ꠍꠣꠢꠣꠛꠤ ꠔꠣꠘꠦ ꠕꠁꠀ ꠜꠣꠉꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_51","071_14_51","MRK","14","51","51","ꠈꠣꠟꠤ ꠄꠇꠎꠘ ꠎꠥꠀꠘꠦ ꠄꠇꠈꠣꠘ ꠟꠋꠉꠤ ꠚꠤꠘ꠆ꠖꠤꠀ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟ। ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠞꠦꠅ ꠗꠞꠔꠣ ꠌꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("MK14_52","071_14_52","MRK","14","52","52","ꠢꠦ ꠔꠣꠞ ꠟꠋꠉꠤ ꠚꠣꠟꠣꠁꠀ ꠟꠦꠝꠐꠣ ꠅꠁꠀ ꠖꠃꠠꠣꠁꠀ ꠜꠣꠉꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_53","071_14_53","MRK","14","53","53","ꠅꠃ ꠝꠣꠘꠡꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠀ ꠢꠣꠞꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟ। ꠢꠘꠅ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟ, ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠅ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_54","071_14_54","MRK","14","54","54","ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞ ꠁꠍꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠖꠥꠞꠁ ꠢꠞꠤ ꠢꠞꠤ ꠞꠁꠀ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠉꠤꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠛꠣꠠꠤꠞ ꠃꠑꠣꠘꠅ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠢꠘꠅ ꠙꠣꠞꠣꠖꠣꠞ ꠅꠇꠟꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠀꠉꠥꠁꠘ ꠔꠣꠛꠣꠘꠤꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_55","071_14_55","MRK","14","55","55","ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠀꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠔꠥꠇꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_56","071_14_56","MRK","14","56","56","ꠝꠎꠟꠤꠍꠅ ꠁꠍꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠃꠔꠦ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠟꠦꠅ, ꠔꠣꠞꠣꠞ ꠡꠣꠇ꠆ꠇꠤꠞ ꠝꠤꠟ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_57","071_14_57","MRK","14","57","57","ꠔꠦꠃ ꠀꠞꠅ ꠇꠄꠎꠘꠦ ꠔꠣꠘ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠅꠃ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠟ। ꠔꠣꠞꠣ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("MK14_58","071_14_58","MRK","14","58","58","“ꠀꠝꠞꠣ ꠢꠥꠘꠍꠤ, ꠢꠦ ꠇꠁꠍꠦ, ꠝꠣꠘꠡꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠅꠃ ꠇꠣꠛꠣ ꠡꠞꠤꠚ, ꠀꠝꠤ ꠜꠣꠋꠉꠤꠟꠤꠝꠥ, ꠀꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠀꠔ ꠘꠣ ꠟꠣꠉꠣꠁꠀ ꠀꠝꠤ ꠀꠞꠇꠈꠣꠘ ꠛꠣꠘꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("MK14_59","071_14_59","MRK","14","59","59","ꠅꠁꠟꠦ ꠄꠞꠣꠞ ꠡꠣꠇ꠆ꠇꠤꠅ ꠝꠤꠟꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK14_60","071_14_60","MRK","14","60","60","ꠢꠦꠡꠦ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠃꠛꠣꠁꠀ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠝꠣꠔꠞ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ ꠘꠣ ꠘꠤ? ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠤꠔꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ, ꠢꠥꠘꠞꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK14_61","071_14_61","MRK","14","61","61","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠘꠣ ꠖꠤꠀ ꠘꠤꠞꠣꠁ ꠞꠁꠟꠣ। ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠔꠣꠘꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ ꠘꠤ, ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("MK14_62","071_14_62","MRK","14","62","62","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠎꠤꠅꠄ, ꠀꠝꠤꠃ ꠢꠦꠁꠘ। ꠀꠙꠘꠣꠞꠣ ꠖꠦꠈꠛꠣ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠀꠟ꠆ꠟꠣ ꠞꠣꠛ꠆ꠛꠥꠟ ꠀꠟꠣꠝꠤꠘꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠤ। ꠀꠞ ꠖꠦꠈꠛꠣ, ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠔ ꠅꠁꠀ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠤꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK14_63","071_14_63","MRK","14","63","63","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠘꠤꠎꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠍꠤꠠꠤꠀ ꠇꠁꠟꠣ, “ꠀꠞ ꠇꠥꠘꠥ ꠡꠣꠇ꠆ꠇꠤꠞ ꠎꠞꠥꠞ ꠀꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("MK14_64","071_14_64","MRK","14","64","64","ꠀꠙꠘꠣꠞꠣ ꠘꠤꠎꠞ ꠇꠣꠘꠦꠃ ꠔ ꠢꠥꠘꠟꠣ, ꠢꠦ ꠡꠤꠞꠤꠇꠤ ꠇꠞꠟ। ꠔꠦ ꠅꠈꠘ ꠀꠙꠘꠣꠞꠣ ꠇꠤꠔꠣ ꠞꠣꠄ ꠖꠤꠛꠣ?” ꠅꠃ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠔꠣꠘꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠤꠀ, ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_65","071_14_65","MRK","14","65","65","ꠇꠦꠃ ꠇꠦꠃ ꠔꠣꠘ ꠃꠙꠞꠦ ꠍꠦꠚ ꠖꠤꠟ। ꠔꠣꠘ ꠝꠥꠈ ꠛꠣꠘ꠆ꠖꠤꠀ ꠊꠥꠡꠤ ꠝꠣꠞꠤꠀ ꠇꠁꠟ, “ꠢꠂ, ꠔꠥꠁꠘ ꠛꠥꠟꠦ ꠘꠛꠤ, ꠔꠦ ꠅꠈꠘ ꠅꠢꠤ ꠇꠍ ꠘꠣ।” ꠛꠣꠖꠦ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦꠅ ꠔꠣꠘꠦ ꠘꠤꠀ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_66","071_14_66","MRK","14","66","66","ꠙꠤꠔꠞ ꠎꠦꠛꠟꠣ ꠟꠣꠝꠣꠔ ꠃꠑꠣꠘꠅ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠄꠇ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_67","071_14_67","MRK","14","67","67","ꠉꠤꠀ ꠔꠣꠘꠞꠦ ꠀꠉꠥꠁꠘ ꠔꠣꠛꠣꠘꠤꠔ ꠖꠦꠈꠤꠀ, ꠜꠣꠟꠣ ꠇꠞꠤ ꠔꠣꠘ ꠛꠣꠄ ꠌꠣꠁꠀ ꠢꠣꠞꠤ ꠇꠁꠟ, “ꠀꠙꠘꠦꠅ ꠔ ꠅꠃ ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK14_68","071_14_68","MRK","14","68","68","ꠙꠤꠔꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠘꠣ ꠉ, ꠔꠥꠝꠤ ꠅꠃ ꠇꠤꠔꠣ ꠇꠁꠞꠣꠄ? ꠀꠝꠤ ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠎꠣꠘꠤ ꠘꠣ, ꠛꠥꠎꠤꠅ ꠘꠣ।” ꠅꠈꠣꠘ ꠇꠁꠀ ꠙꠤꠔꠞ ꠉꠦꠁꠐꠞ ꠗꠣꠞꠅ ꠉꠦꠟꠣ, ꠀꠞ ꠅꠃ ꠡꠝꠄ ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠟꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK14_69","071_14_69","MRK","14","69","69","ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤꠄ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟ, ꠙꠤꠔꠞ ꠅꠘꠅ ꠉꠤꠀ ꠃꠛꠣꠁꠍꠂꠘ, ꠅꠃ ꠔꠣꠘ ꠇꠣꠍꠣꠔ ꠃꠛꠣ ꠝꠣꠘꠡꠞꠦ ꠉꠤꠀ ꠔꠣꠁ ꠇꠁꠟ, “ꠅꠃ ꠛꠦꠐꠣꠅ ꠄꠞꠣꠞ ꠟꠉꠞ ꠄꠇꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("MK14_70","071_14_70","MRK","14","70","70","ꠙꠤꠔꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠘꠣ ꠇꠞꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠦꠞꠣ ꠃꠛꠣ ꠀꠍꠤꠟ, ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠘꠤꠌ꠆ꠌꠄ ꠄꠞꠣꠞ ꠟꠉꠞ, ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠅ ꠔ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ।” ");
INSERT INTO syls_vpl VALUES ("MK14_71","071_14_71","MRK","14","71","71","ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛ ꠙꠠꠃꠇ, ꠀꠝꠤ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠀꠞ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠎꠣꠞ ꠇꠕꠣ ꠇꠁꠞꠣꠄ, ꠔꠣꠞꠦ ꠀꠝꠤ ꠌꠤꠘꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK14_72","071_14_72","MRK","14","72","72","ꠅꠈꠣꠘ ꠇꠁꠔꠦꠃ ꠝꠥꠞꠉꠣꠄ ꠖꠥꠀꠞꠣ ꠛꠣꠋ ꠖꠤꠟ। ꠛꠣꠋ ꠢꠥꠘꠤꠀꠃ ꠙꠤꠔꠞꠞ ꠝꠘꠅ ꠅꠁꠉꠦꠟ, ꠁꠍꠣꠄ ꠇꠁꠍꠟꠣ, “ꠝꠥꠞꠉꠣꠄ ꠖꠥꠁꠛꠣꠞ ꠛꠣꠋ ꠖꠤꠛꠣꠞ ꠀꠉꠦꠃ ꠔꠥꠝꠤ ꠔꠤꠘꠛꠣꠞ ꠇꠁꠛꠣꠄ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘ ꠘꠣ।” ꠅꠈꠣꠘ ꠝꠘꠅ ꠅꠁꠔꠦꠃ ꠔꠣꠁꠘ ꠀꠃ ꠀꠃ ꠇꠞꠤ ꠇꠣꠘ꠆ꠖꠘ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_1","071_15_1","MRK","15","1","1","ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠍꠛꠞꠦ ꠃꠑꠤꠀ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ, ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠢꠇꠟꠞ ꠟꠉꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠤꠀ, ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠥꠝꠣꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_2","071_15_2","MRK","15","2","2","ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠘꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠑꠤꠇ ꠇꠕꠣꠃ ꠇꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK15_3","071_15_3","MRK","15","3","3","ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠔꠣꠘ ꠘꠣꠝꠦ ꠛꠃꠔ ꠘꠣꠟꠤꠡ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_4","071_15_4","MRK","15","4","4","ꠙꠤꠟꠣꠔꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠥꠘ꠆ꠔꠣ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ ꠘꠣ ꠘꠤ? ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠔ ꠘꠣꠟꠤꠡ ꠖꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK15_5","071_15_5","MRK","15","5","5","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠘꠣ ꠖꠦꠅꠀꠄ ꠙꠤꠟꠣꠔ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_6","071_15_6","MRK","15","6","6","ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠡꠝꠄ ꠢꠣꠇꠤꠝꠦ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞ ꠙꠍꠘ꠆ꠖ ꠝꠣꠚꠤꠇ, ꠄꠇꠎꠘ ꠀꠎꠔꠤꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_7","071_15_7","MRK","15","7","7","ꠅꠃ ꠡꠝꠄ ꠛꠣꠞꠣꠛ꠆ꠛꠣ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠎꠦꠟꠅ ꠀꠍꠤꠟ। ꠡꠋꠉ꠆ꠞꠣꠝꠞ ꠡꠝꠄ ꠢꠦ ꠚꠃꠎꠞ ꠟꠉꠦ ꠞꠁꠀ ꠝꠣꠘꠥꠡ ꠈꠥꠘ ꠇꠞꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_8","071_15_8","MRK","15","8","8","ꠝꠣꠘꠡꠦ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠖꠣꠛꠤ ꠎꠣꠘꠣꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠙꠘꠣꠞ ꠘꠤꠎꠞ ꠞꠦꠅꠀꠎ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK15_9","071_15_9","MRK","15","9","9","ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠌꠣꠁꠞꠣꠄ ꠘꠤ, ꠀꠝꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("MK15_10","071_15_10","MRK","15","10","10","ꠙꠤꠟꠣꠔꠦ ꠎꠣꠘꠔꠣ, ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠁꠍꠣꠞꠦ ꠘꠤꠀ ꠔꠣꠘ ꠀꠔꠅ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK15_11","071_15_11","MRK","15","11","11","ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠝꠣꠘꠡꠞꠦ ꠃꠍꠇꠣꠁꠀ ꠖꠤꠟꠣ, ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞ ꠝꠥꠇ꠆ꠔꠤ ꠘꠣ ꠌꠣꠁꠀ ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞ ꠝꠥꠇ꠆ꠔꠤ ꠌꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("MK15_12","071_15_12","MRK","15","12","12","ꠄꠞꠖꠣꠄ ꠙꠤꠟꠣꠔꠦ ꠢꠤꠞꠛꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠞꠦ ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ ꠇꠅ, ꠔꠣꠞꠦ ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("MK15_13","071_15_13","MRK","15","13","13","ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠟꠣꠉꠣꠁꠟ, “ꠔꠣꠞꠦ ꠍꠟꠤꠛꠅ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK15_14","071_15_14","MRK","15","14","14","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠇꠦꠘꠦ, ꠢꠦ ꠇꠤꠔꠣ ꠖꠥꠡ ꠇꠞꠍꠦ?” ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠀꠞꠅ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠍꠟꠤꠛꠅ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("MK15_15","071_15_15","MRK","15","15","15","ꠔꠦꠃ ꠙꠤꠟꠣꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠔꠣ ꠇꠞꠤ ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠟꠣꠁꠟꠣ, ꠀꠞ ꠁꠍꠣꠞꠦ ꠛꠦꠡ ꠇꠞꠤ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠤꠀ, ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। (ꠍꠟꠤꠛ ꠅꠁꠟ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠝꠣꠘꠡꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣꠞ ꠄꠇ ꠎꠤꠘꠤꠡ।) ");
INSERT INTO syls_vpl VALUES ("MK15_16","071_15_16","MRK","15","16","16","ꠛꠣꠖꠦ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠀ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝꠞ ꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠢꠘꠅ ꠔꠣꠞꠣ ꠀꠞꠅ ꠍꠤꠙꠣꠁ ꠅꠇꠟ ꠖꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_17","071_15_17","MRK","15","17","17","ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠛꠣꠁꠋꠉꠘꠤ ꠞꠋꠉꠞ ꠛꠣꠖꠡꠣꠁ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ, ꠀꠞ ꠉꠍꠣ-ꠇꠣꠐꠣ ꠖꠤꠀ ꠝꠥꠇꠥꠐ ꠛꠣꠘꠣꠁꠀ ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_18","071_15_18","MRK","15","18","18","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠝꠡꠇꠞꠣ ꠇꠞꠤ ꠝꠤꠍꠤꠟ ꠖꠤꠟ, “ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ, ꠝꠣꠞꠢꠣꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK15_19","071_15_19","MRK","15","19","19","ꠀꠞ ꠄꠇ ꠟꠣꠑꠤ ꠀꠘꠤꠀ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠝꠣꠞꠟ, ꠉꠔꠞꠅ ꠍꠦꠚ ꠖꠤꠟ, ꠔꠣꠘꠦ ꠁꠎ꠆ꠎꠔ ꠖꠦꠈꠣꠘꠤꠞ ꠜꠣꠘ ꠇꠞꠤꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠐꠥ ꠉꠣꠠꠤꠀ ꠛꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_20","071_15_20","MRK","15","20","20","ꠅꠃ ꠟꠣꠈꠣꠘ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠀꠞ ꠛꠦꠔ꠆ꠔꠝꠤꠎꠤ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠚꠤꠘ꠆ꠘꠞ ꠛꠣꠁꠋꠉꠘꠤ ꠟꠦꠛꠣꠍ ꠈꠥꠟꠤꠀ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠣꠁꠟ ꠀꠞ ꠍꠟꠤꠛꠅ ꠘꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔ ꠇꠞꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_21","071_15_21","MRK","15","21","21","ꠔꠣꠞꠣ ꠟꠁꠀ ꠎꠣꠁꠞꠣ ꠅꠃ ꠡꠝꠄ ꠇꠥꠞꠤꠘꠤ ꠄꠟꠣꠇꠣꠞ ꠍꠤꠇꠘ꠆ꠖꠞ ꠀꠞ ꠞꠃꠚꠞ ꠛꠣꠚ, ꠍꠣꠁꠝꠘ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠉꠣꠃ ꠕꠣꠇꠤ ꠅꠃ ꠙꠕꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ। ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠎꠥꠞ ꠇꠞꠤꠀ ꠄꠘꠦꠖꠤ ꠢꠃ ꠍꠟꠤꠛ ꠛꠅꠀꠁꠀ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_22","071_15_22","MRK","15","22","22","ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠉꠟꠉꠣꠕꠣ, ꠝꠣꠘꠤ ꠇꠟ꠆ꠟꠣꠞ ꠌꠣꠠ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_23","071_15_23","MRK","15","23","23","ꠢꠘꠅ ꠘꠤꠀ ꠔꠣꠘꠞꠦ ꠝꠥꠞꠣ ꠘꠣꠝꠞ ꠅꠡꠥꠗ ꠙꠥꠞꠣꠁꠟ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠈꠣꠁꠔꠦ ꠖꠤꠟꠣ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠁꠔꠣ ꠈꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_24","071_15_24","MRK","15","24","24","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠍꠟꠤꠛꠅ, ꠝꠣꠘꠤ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠟ। ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠔꠣꠘ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠛꠣꠐꠤꠀ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠜꠣꠁꠉ꠆ꠉ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_25","071_15_25","MRK","15","25","25","ꠛꠤꠀꠘꠦ ꠘꠄꠐꠣꠞ ꠡꠝꠄ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_26","071_15_26","MRK","15","26","26","ꠀꠞ ꠔꠣꠘ ꠅꠙꠞꠣꠗ-ꠘꠣꠝꠣꠞ ꠝꠣꠎꠦ ꠟꠦꠈꠟ, “ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK15_27","071_15_27","MRK","15","27","27","ꠔꠣꠞꠣ ꠖꠥꠁꠎꠘ ꠒꠣꠇꠣꠁꠔꠞꠦꠅ ꠔꠣꠘ ꠟꠉꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠟ, ꠄꠇꠎꠘ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ, ꠅꠁꠘ꠆ꠘꠎꠘ ꠛꠣꠃ ꠉꠣꠟꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("MK15_28","071_15_28","MRK","15","28","28","ꠄꠞꠖꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠅꠃ ꠀꠄꠀꠔꠅ ꠚꠟꠤꠉꠦꠟ, “ꠔꠣꠘꠞꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠟꠉꠦ ꠉꠘꠣ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("MK15_29","071_15_29","MRK","15","29","29","ꠢꠃ ꠙꠕꠦꠖꠤ ꠎꠦꠞꠣ ꠎꠣꠅꠀꠔ ꠀꠍꠤꠟ ꠔꠣꠞꠣ ꠝꠣꠕꠣ ꠟꠣꠠꠣꠁꠀ ꠁꠍꠣꠞꠦ ꠍꠤꠠꠣꠁꠀ ꠇꠁꠟ, “ꠅꠂ ꠝꠤꠀ, ꠔꠥꠝꠤ ꠛꠥꠟꠦ ꠇꠣꠛꠣ ꠊꠞ ꠜꠣꠋꠉꠤꠀ ꠔꠤꠘ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠘꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ! ");
INSERT INTO syls_vpl VALUES ("MK15_30","071_15_30","MRK","15","30","30","ꠔꠦ ꠅꠈꠘ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK15_31","071_15_31","MRK","15","31","31","ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦꠅ ꠔꠣꠘꠞꠦ ꠍꠤꠠꠣꠁꠀ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠟꠣ, “ꠢꠦ ꠔ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ, ꠅꠈꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ ꠙꠣꠞꠦꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_32","071_15_32","MRK","15","32","32","ꠢꠦ ꠛꠥꠟꠦ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠖꠡꠣ! ꠔꠦ ꠙꠣꠞꠟꠦ ꠅꠈꠘ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠃꠇ, ꠔꠦꠃ ꠀꠝꠞꠣꠅ ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠁꠝꠣꠘ ꠀꠘꠝꠥ।” ꠔꠣꠘ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠎꠦꠞꠣꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠔꠣꠞꠣꠅ ꠔꠣꠘꠞꠦ ꠍꠤꠠꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_33","071_15_33","MRK","15","33","33","ꠛꠣꠖꠦ ꠛꠦꠁꠟ ꠖꠥꠁꠚꠞ ꠕꠣꠇꠤ ꠎꠥꠢꠞꠞ ꠛꠣꠖ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠤꠘ ꠊꠘ꠆ꠐꠣ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_34","071_15_34","MRK","15","34","34","ꠄꠞꠛꠣꠖꠦꠃ ꠔꠣꠁꠘ ꠈꠥꠛ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠄꠟꠥꠁ, ꠄꠟꠥꠁ, ꠟꠣꠝꠣ ꠍꠣꠛꠣꠇ꠆ꠔꠣꠘꠤ,” ꠝꠣꠘꠤ, “ꠅ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠣꠞ ꠝꠃꠟꠣ, ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠟꠉ ꠍꠣꠠꠤ ꠖꠤꠟꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("MK15_35","071_15_35","MRK","15","35","35","ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠣ ꠔꠣꠘ ꠗꠣꠞꠅ ꠃꠛꠣ ꠀꠍꠤꠟ, ꠔꠣꠞꠣ ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠢꠥꠘꠅ, ꠢꠦ ꠢꠎꠞꠔ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞꠦ ꠒꠣꠇꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("MK15_36","071_15_36","MRK","15","36","36","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠄꠇꠈꠣꠘ ꠔꠦꠘꠣ ꠀꠘꠤꠀ ꠐꠦꠋꠉꠣ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔꠞ ꠝꠣꠎꠦ ꠜꠤꠎꠣꠁꠀ, ꠄꠇ ꠟꠣꠑꠤꠞ ꠝꠣꠕꠣꠔ ꠛꠣꠘ꠆ꠖꠤꠀ ꠃꠌꠣ ꠇꠞꠤ ꠔꠣꠘꠞꠦ ꠈꠣꠁꠔꠦ ꠖꠤꠟ। ꠢꠦ ꠇꠁꠟ, “ꠅꠃꠇ, ꠖꠦꠈꠤ ꠘꠣ ꠁꠟꠤꠀꠍꠦ ꠔꠣꠞꠦ ꠟꠣꠝꠣꠁꠀ ꠘꠦꠅꠀꠔ ꠀꠁꠘ ꠘꠤ।” ");
INSERT INTO syls_vpl VALUES ("MK15_37","071_15_37","MRK","15","37","37","ꠢꠦꠡꠦ ꠁꠍꠣꠄ ꠎꠥꠞꠦ ꠀꠅꠀꠎ ꠇꠞꠤꠀ ꠀꠈꠦꠞꠤ ꠖꠝ ꠚꠣꠟꠣꠁꠀ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_38","071_15_38","MRK","15","38","38","ꠟꠉꠦ ꠟꠉꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠇꠣꠛꠣ ꠊꠞꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣꠈꠣꠘ, ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠔꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠍꠤꠠꠤꠀ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_39","071_15_39","MRK","15","39","39","ꠍꠤꠙꠣꠁꠞ ꠎꠦ ꠅꠚꠤꠡꠣꠞ ꠢꠘꠅ ꠙꠣꠞꠣ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ, ꠄꠁꠘ ꠁꠍꠣꠞ ꠝꠃꠔꠞ ꠁ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠘꠤꠌ꠆ꠌꠄ, ꠄꠁꠘꠃ ꠀꠍꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("MK15_40","071_15_40","MRK","15","40","40","ꠇꠄꠎꠘ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠦꠅ ꠖꠥꠞꠁ ꠃꠛꠣꠁꠀ ꠁꠔꠣ ꠖꠦꠈꠟꠣ, ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠟꠣ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ, ꠁꠃꠍꠤ ꠀꠞ ꠢꠥꠞꠥ ꠁꠀꠇꠥꠛꠞ ꠝꠣ ꠝꠞꠤꠅꠝ, ꠀꠞ ꠛꠤꠛꠤ ꠍꠣꠟꠥꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("MK15_41","071_15_41","MRK","15","41","41","ꠁꠍꠣ ꠎꠦꠛꠟꠣ ꠉꠣꠟꠤꠟꠅ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠅꠃ ꠛꠦꠐꠤꠘ ꠢꠣꠝꠦꠡꠣ ꠔꠣꠘ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠔꠣ ꠀꠞ ꠔꠣꠘ ꠈꠦꠎꠝꠔ ꠇꠞꠔꠣ। ꠀꠞꠅ ꠛꠃꠔ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ, ꠎꠦꠞꠣ ꠔꠣꠘ ꠟꠉꠦ ꠅꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣꠅ ꠁꠔꠣ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_42","071_15_42","MRK","15","42","42","ꠁ ꠖꠤꠘ ꠀꠍꠤꠟ ꠁꠘ꠆ꠔꠦꠎꠣꠝꠞ ꠖꠤꠘ, ꠝꠣꠘꠤ ꠁꠢꠥꠖꠤꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠀꠉꠞ ꠖꠤꠘ, ꠅꠃ ꠖꠤꠘ ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣꠞ ꠛꠣꠖꠦ ꠕꠘꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ ꠇꠞꠣ ꠢꠣꠞꠣꠝ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK15_43","071_15_43","MRK","15","43","43","ꠄꠞꠖꠣꠄ ꠅꠃ ꠛꠤꠀꠟꠤ ꠛꠣꠟꠣ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠁꠎ꠆ꠎꠔꠤ ꠝꠘꠔ꠆ꠞꠤ, ꠀꠞꠤꠝꠣꠕꠤꠀ ꠉꠣꠃꠞ ꠁꠃꠍꠥꠚ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ, ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠀꠁꠀ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠣꠡ ꠘꠤꠔꠣ ꠌꠣꠁꠟꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠇꠣꠁꠝ ꠅꠀꠞ ꠟꠣꠉꠤ ꠄꠁꠘ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_44","071_15_44","MRK","15","44","44","ꠙꠤꠟꠣꠔꠦ ꠢꠥꠘꠤꠀ ꠈꠥꠛ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ ꠎꠦꠘ, ꠁꠍꠣꠄ ꠅꠔ ꠎꠟꠖꠤ ꠇꠞꠤ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠚꠞꠝꠣꠁꠍꠂꠘ। ꠄꠞꠖꠣꠄ ꠔꠣꠁꠘ ꠍꠤꠙꠣꠁꠞ ꠍꠥꠛꠦꠖꠣꠞꠞꠦ ꠀꠘꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, ꠢꠣꠍꠣꠃ ꠁꠍꠣꠞ ꠞꠥꠢꠥ ꠛꠣꠞ ꠅꠁ ꠉꠦꠍꠦ ꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("MK15_45","071_15_45","MRK","15","45","45","ꠍꠥꠛꠦꠖꠣꠞꠦ ꠎꠦꠛꠟꠣ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠔꠣꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ”, ꠅꠃ ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞ ꠟꠣꠡ ꠁꠃꠍꠥꠚꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_46","071_15_46","MRK","15","46","46","ꠁꠃꠍꠥꠚꠦ ꠉꠤꠀ ꠇꠣꠚꠘꠞ ꠇꠣꠙꠠ ꠈꠞꠤꠖ ꠇꠞꠤ ꠀꠘꠤꠀ, ꠁꠍꠣꠞ ꠟꠣꠡ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠣꠁꠀ, ꠇꠣꠚꠘ ꠚꠤꠘ꠆ꠖꠣꠁꠀ, ꠙꠣꠔ꠆ꠔꠞ ꠇꠣꠐꠤꠀ ꠛꠣꠘꠣꠁꠟ ꠄꠇ ꠇꠄꠛꠞꠞ ꠝꠣꠎꠦ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ, ꠁ ꠟꠣꠈꠣꠘ ꠇꠄꠛꠞꠅ ꠝꠣꠐꠤ ꠖꠦꠅꠀ ꠟꠣꠉꠦ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠛꠠ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞ ꠉꠠꠤꠀꠁꠀ ꠀꠘꠤꠀ ꠇꠄꠛꠞꠞ ꠝꠥꠈꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK15_47","071_15_47","MRK","15","47","47","ꠅꠃ ꠡꠝꠄ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ ꠀꠞ ꠁꠃꠍꠤꠞ ꠝꠣ ꠝꠞꠤꠅꠝꠦ ꠖꠦꠈꠟꠣ, ꠔꠣꠘꠞꠦ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠖꠣꠚꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK16_1","071_16_1","MRK","16","1","1","ꠔꠣꠞꠣꠞ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠡꠦꠡ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ, ꠁꠀꠇꠥꠛꠞ ꠝꠣ ꠝꠞꠤꠅꠝ ꠀꠞ ꠛꠤꠛꠤ ꠍꠣꠟꠥꠝꠤꠄ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠣꠡꠅ ꠝꠣꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠝꠡꠟꠣ ꠟꠁꠀ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_2","071_16_2","MRK","16","2","2","ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠛꠤꠀꠘꠦ, ꠝꠣꠘꠤ ꠞꠛꠤꠛꠣꠞꠦ ꠚꠎꠞꠦ ꠡꠥꠞꠥꠎ ꠃꠑꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠄꠞꠣ ꠔꠣꠘ ꠇꠄꠛꠞꠞ ꠇꠣꠍꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_3","071_16_3","MRK","16","3","3","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠄꠛꠞꠞ ꠝꠥꠈꠞ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞ ꠇꠦ ꠢꠞꠣꠁꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("MK16_4","071_16_4","MRK","16","4","4","ꠝꠣꠔꠤ ꠝꠣꠔꠤ ꠔꠣꠞꠣ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠁ ꠙꠣꠔ꠆ꠔꠞ ꠢꠞꠣꠁꠟ ꠅꠁꠉꠦꠍꠦ। ꠙꠣꠔ꠆ꠔꠞꠐꠣ ꠀꠍꠤꠟ ꠈꠥꠛ ꠛꠠ। ");
INSERT INTO syls_vpl VALUES ("MK16_5","071_16_5","MRK","16","5","5","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠇꠄꠛꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠄꠇ ꠎꠥꠀꠘ ꠛꠦꠐꠣꠄ ꠗꠟꠣ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ ꠛꠁ ꠞꠁꠍꠂꠘ। ꠄꠘꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_6","071_16_6","MRK","16","6","6","ꠅꠃ ꠢꠦꠁꠘ ꠇꠁꠟꠣ, “ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠅ ꠘꠣ ꠉ। ꠔꠥꠝꠤꠔꠣꠁꠘ ꠔ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠞ ꠁꠍꠣꠞꠦꠃ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠞꠣꠄ, ꠎꠦꠘꠞꠦ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠦ? ꠔꠣꠁꠘ ꠅꠈꠘ ꠁꠘꠅ ꠘꠣꠄ, ꠔꠣꠘꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ। ꠖꠦꠈꠤ ꠎꠣꠅ, ꠅꠃ ꠎꠣꠉꠣꠔꠃ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK16_7","071_16_7","MRK","16","7","7","ꠔꠦ ꠔꠥꠝꠤꠔꠣꠁꠘ ꠅꠈꠘ ꠎꠣꠅ, ꠉꠤꠀ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠀꠞ ꠙꠤꠔꠞꠞꠦꠅ ꠇꠅ, ꠔꠣꠁꠘ ꠀꠉꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠇꠁꠍꠟꠣ, ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠀꠉꠦ ꠉꠣꠟꠤꠟꠅ ꠎꠣꠁꠞꠣ। ꠔꠥꠝꠞꠣ ꠢꠘꠅ ꠉꠦꠟꠦ ꠔꠣꠘ ꠖꠞꠡꠘ ꠙꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("MK16_8","071_16_8","MRK","16","8","8","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠖꠃꠠꠣꠁꠀ ꠜꠣꠉꠤꠟꠣ। ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ, ꠒꠞꠞ ꠌꠥꠐꠦ ꠇꠦꠃꠞꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_9","071_16_9","MRK","16","9","9","ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠚꠎꠞ ꠅꠇ꠆ꠔꠅ ꠁꠍꠣ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠟꠣ, ꠀꠞ ꠙꠄꠟꠣꠃ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠟꠣ। ꠅꠃ ꠝꠞꠤꠅꠝꠞ ꠟꠉ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠡꠣꠔꠉꠥ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_10","071_16_10","MRK","16","10","10","ꠔꠣꠘ ꠖꠞꠡꠘ ꠙꠣꠁꠀꠃ ꠝꠞꠤꠅꠝꠦ ꠉꠤꠀ ꠁꠍꠣꠞ ꠟꠉꠞ ꠢꠇꠟꠞꠦ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠣꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("MK16_11","071_16_11","MRK","16","11","11","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍꠂꠘ ꠀꠞ ꠝꠞꠤꠅꠝꠞꠦ ꠖꠞꠡꠘꠅ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠔꠣꠞꠣ ꠇꠦꠃ ꠄꠇꠤꠘ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_12","071_16_12","MRK","16","12","12","ꠛꠣꠖꠦ ꠔꠣꠘ ꠖꠥꠁꠎꠘ ꠃꠝ꠆ꠝꠔꠦ ꠀꠐꠤ ꠀꠐꠤ ꠉꠣꠃ ꠛꠣꠄꠖꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠥꠞꠔ ꠛꠖꠟꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_13","071_16_13","MRK","16","13","13","ꠔꠣꠞꠣ ꠉꠤꠀ ꠛꠣꠇꠤ ꠢꠇꠟꠞꠦ ꠅꠃ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠇꠕꠣꠅ ꠄꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_14","071_16_14","MRK","16","14","14","ꠢꠦꠡꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠄꠉꠣꠞꠅ ꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠄꠞꠣ ꠈꠣꠅꠀꠔ ꠀꠍꠟꠣ। ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠦꠞꠣ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠍꠤꠟ, ꠔꠣꠞꠣꠞ ꠇꠕꠣ ꠄꠇꠤꠘ ꠘꠣ ꠇꠞꠣꠄ, ꠄꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠇꠝꠎꠥꠞꠤ ꠀꠞ ꠖꠤꠟꠞ ꠘꠣ-ꠢꠥꠝꠣꠞꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠗꠝꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("MK16_15","071_16_15","MRK","16","15","15","ꠀꠞ ꠅꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠎꠣꠉꠣꠔ ꠎꠣꠅ, ꠉꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("MK16_16","071_16_16","MRK","16","16","16","ꠎꠦ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠦ, ꠢꠦ-ꠃ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠘ ꠀꠘꠔ ꠘꠣꠄ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠡꠤ ꠛꠘꠤꠀ ꠡꠣꠎꠣ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("MK16_17","071_16_17","MRK","16","17","17","ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠛ, ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠃ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣ ꠎꠣꠁꠛ: ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁꠛ, ꠘꠄꠀ ꠘꠄꠀ ꠜꠣꠡꠣꠄ ꠉꠣꠁꠛꠤ ꠛꠥꠟꠤ ꠝꠣꠔꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("MK16_18","071_16_18","MRK","16","18","18","ꠔꠣꠞꠣ ꠎꠣꠔꠤ ꠢꠣꠚꠞꠦ ꠀꠔꠅ ꠟꠁꠛꠣ, ꠛꠦꠎꠥꠁꠔꠣ ꠛꠤꠡꠣꠇ꠆ꠔ ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠁꠟꠦꠅ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠅꠁꠔ ꠘꠣꠄ। ꠀꠞ ꠇꠥꠘꠥ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠀꠔꠣꠁꠀ ꠖꠤꠟꠦ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("MK16_19","071_16_19","MRK","16","19","19","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠟ। ꠢꠘꠅ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠔꠡꠞꠤꠚ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("MK16_20","071_16_20","MRK","16","20","20","ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠄꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠇꠣꠝ ꠇꠞꠟꠣ, ꠀꠞ ꠄꠞꠣꠞꠦ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠔꠣꠇ꠆ꠇꠔ ꠖꠤꠀ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠟꠣ, ꠄꠞꠣ ꠎꠦꠔꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣ, ꠁꠔꠣ ꠢꠣꠍꠣ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("LK1_1","072_1_1","LUK","1","1","2","ꠝꠢꠣꠝꠣꠁꠘ꠆ꠘ ꠕꠤꠅꠚꠤꠟꠣꠍ, ꠀꠙꠘꠣꠞ ꠔ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠊꠐꠤꠍꠦ, ꠁꠔꠣ ꠎꠦꠞꠣ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠍꠂꠘ ꠀꠞ ꠔꠛꠟꠤꠉꠅ ꠇꠞꠍꠂꠘ, ꠄꠞꠣꠞ ꠝꠥꠈꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠡꠝꠎꠤꠀ ꠢꠣꠞꠤ, ꠛꠃꠔ ꠝꠥꠝꠤꠘꠦ ꠟꠦꠈꠣꠔ ꠟꠣꠉꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_3","072_1_3","LUK","1","3","3","ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘ ꠀꠝꠤꠅ ꠀꠖꠤ-ꠅꠘ꠆ꠔ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤꠀ, ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠤꠀ ꠀꠙꠘꠣꠞꠦ ꠎꠣꠘꠣꠘꠤ ꠈꠣꠘ ꠜꠣꠟꠣ ꠝꠘꠅ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK1_4","072_1_4","LUK","1","4","4","ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠀꠙꠘꠦ ꠡꠝꠎꠤꠔꠣ ꠙꠣꠞꠛꠣ, ꠀꠙꠘꠦ ꠀꠉꠦ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠍꠂꠘ, ꠁꠔꠣ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠑꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("LK1_5","072_1_5","LUK","1","5","5","ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠦ ꠎꠦꠛꠟꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣ ꠌꠣꠟꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠎꠣꠇꠣꠞꠤꠀ। ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠟ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠀꠛꠤꠀ ꠖꠟꠞ ꠝꠣꠘꠥꠡ। ꠔꠣꠘ ꠛꠤꠛꠤꠞ ꠘꠣꠝ ꠄꠟꠤꠍꠣꠛꠦꠔ, ꠄꠁꠘꠅ ꠢꠣꠞꠥꠘꠞ ꠛꠋꠡꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("LK1_6","072_1_6","LUK","1","6","6","ꠄꠞꠣ ꠖꠥꠁꠅꠎꠘꠃ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠇꠣꠝꠤꠟ ꠖꠤꠘꠖꠣꠞ ꠀꠍꠟꠣ। ꠝꠣꠛꠥꠖꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠀꠖꠣꠄ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_7","072_1_7","LUK","1","7","7","ꠅꠁꠟꠦ ꠄꠞꠣ ꠀꠍꠟꠣ ꠘꠤꠀꠅꠟꠣꠖꠤ, ꠛꠤꠛꠤ ꠄꠟꠤꠍꠣꠛꠦꠔ ꠅꠁꠟꠣ ꠀꠐꠇꠥꠞꠣ ꠛꠦꠝꠣꠞꠤ। ꠅꠃ ꠢꠣꠟꠔꠦ ꠖꠥꠁꠅꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠁꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_8","072_1_8","LUK","1","8","8","ꠄꠞꠝꠣꠎꠦ ꠅꠁꠘ꠆ꠘ ꠖꠟꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠖꠤꠘ ꠡꠦꠡ ꠅꠁꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠖꠟꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠛꠣꠞꠤ ꠀꠁꠟ, ꠔꠦꠃ ꠎꠣꠇꠣꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠅ ꠁꠝꠣꠝꠔꠤꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_9","072_1_9","LUK","1","9","9","ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠔꠣꠘꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠙꠛꠤꠔ꠆ꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠁꠀ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_10","072_1_10","LUK","1","10","10","ꠔꠣꠁꠘ ꠜꠤꠔꠞꠦ ꠅꠔꠣ ꠎꠣꠟꠣꠁꠞꠣ, ꠀꠞ ꠛꠣꠞꠦ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠖꠥꠀ-ꠖꠥꠞꠥꠖ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_11","072_1_11","LUK","1","11","11","ꠀꠈꠔꠣꠃ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤꠞ ꠐꠦꠛꠥꠟꠞ ꠒꠣꠁꠘꠦꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_12","072_1_12","LUK","1","12","12","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠔꠣꠘ ꠖꠤꠟ ꠇꠣꠙꠤꠉꠦꠟ, ꠎꠣꠘꠅ ꠒꠞ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK1_13","072_1_13","LUK","1","13","13","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠎꠣꠇꠣꠞꠤꠀ, ꠒꠞꠣꠁꠅ ꠘꠣ। ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠥꠝꠣꠞ ꠖꠥꠀ ꠇꠛꠥꠟ ꠅꠁꠍꠦ। ꠔꠥꠝꠣꠞ ꠛꠤꠛꠤ ꠄꠟꠤꠍꠣꠛꠦꠔꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠛꠣ, ꠔꠥꠝꠤ ꠄꠘ ꠘꠣꠝ ꠞꠣꠈꠤꠅ ꠄꠢꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("LK1_14","072_1_14","LUK","1","14","14","ꠅꠃ ꠙꠥꠔꠦ ꠔꠥꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠛꠃꠔ ꠈꠥꠡꠤ ꠛꠣꠠꠣꠁꠛꠣ, ꠔꠣꠁꠘ ꠎꠘꠝ ꠟꠅꠀꠄ ꠀꠞꠅ ꠛꠃꠔ ꠎꠘ ꠈꠥꠡꠤ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_15","072_1_15","LUK","1","15","15","ꠄꠁꠘ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞꠅ ꠛꠃꠔ ꠛꠠ ꠁꠎ꠆ꠎꠔꠤ ꠅꠁꠛꠣ। ꠎꠤꠘ꠆ꠖꠦꠉꠤꠄ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠣꠛ ꠛꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠘꠤꠡꠣ ꠈꠣꠁꠔꠣ ꠘꠣꠄ। ꠔꠣꠘ ꠝꠣʼꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠔꠦꠃ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_16","072_1_16","LUK","1","16","16","ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_17","072_1_17","LUK","1","17","17","ꠔꠣꠁꠘ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠢꠤꠝ꠆ꠝꠔ ꠀꠞ ꠔꠣꠇ꠆ꠇꠔꠦ ꠝꠣꠟꠤꠇꠞ ꠀꠉꠦ ꠅꠁꠀ ꠀꠁꠛꠣ। ꠀꠁꠀ ꠛꠣꠚ ꠅꠇꠟꠞ ꠖꠤꠟꠞꠦ ꠀꠅꠟꠣꠖꠞ ꠛꠣꠄ, ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠖꠤꠟꠞꠦ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠛꠣꠄ ꠚꠤꠞꠣꠁꠛꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠛꠥꠖꠞ ꠟꠣꠉꠤ ꠄꠇ ꠖꠟ ꠛꠘ꠆ꠖꠣꠞꠦ ꠔꠣꠁꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠔꠤꠀꠞ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK1_18","072_1_18","LUK","1","18","18","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠎꠣꠇꠣꠞꠤꠀꠄ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠄꠞ ꠙꠞꠝꠣꠘ ꠇꠤꠔꠣ, ꠀꠝꠤ ꠇꠦꠝꠘꠦ ꠄꠇꠤꠘ ꠇꠞꠔꠣꠝ? ꠀꠝꠤ ꠔ ꠛꠥꠠꠣ ꠅꠁꠉꠦꠍꠤ, ꠀꠝꠣꠞ ꠛꠃꠅ ꠄꠇ꠆ꠇꠦꠞꠦ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠁꠉꠦꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK1_19","072_1_19","LUK","1","19","19","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠤꠛꠞꠣꠁꠟ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠕꠣꠇꠤ। ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤꠀ, ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_20","072_1_20","LUK","1","20","20","ꠖꠦꠈꠤꠅ, ꠀꠝꠣꠞ ꠇꠕꠣ ꠡꠝꠄ ꠝꠔ ꠚꠟꠤꠛ। ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠝꠣꠔ ꠄꠇꠤꠘ ꠘꠣ ꠇꠞꠣꠄ, ꠁꠈꠣꠘ ꠚꠟꠤꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠤ ꠛꠥꠛꠣ ꠛꠘꠤꠎꠤꠛꠣꠄ, ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK1_21","072_1_21","LUK","1","21","21","ꠁꠛꠣꠄ ꠝꠣꠘꠡꠦ ꠎꠣꠇꠣꠞꠤꠀꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠞꠣ। ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠜꠤꠔꠞꠞ ꠅꠃ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠔꠣꠘ ꠖꠦꠞꠤ ꠅꠞ ꠖꠦꠈꠤꠀ, ꠔꠣꠞꠣ ꠢꠇꠟ ꠌꠤꠘ꠆ꠔꠣꠔ ꠙꠠꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_22","072_1_22","LUK","1","22","22","ꠛꠣꠖꠦ ꠎꠣꠇꠣꠞꠤꠀ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠥꠘ꠆ꠔꠣꠃ ꠝꠣꠔꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠛꠥꠛꠣ ꠅꠁꠉꠦꠟꠣ ꠀꠞ ꠁꠡꠣꠞꠣ-ꠀꠡꠣꠞꠣꠄ ꠛꠥꠎꠣꠁꠟꠣ। ꠁ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠙꠣꠇ ꠎꠣꠉꠣꠞ ꠜꠤꠔꠞꠦ ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠖꠞꠡꠘ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_23","072_1_23","LUK","1","23","23","ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠛꠣꠞꠤ ꠡꠦꠡ ꠅꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK1_24","072_1_24","LUK","1","24","24","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠘ ꠛꠤꠛꠤ ꠄꠟꠤꠍꠣꠛꠦꠔꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠁꠟ, ꠄꠞꠖꠣꠄ ꠄꠟꠤꠍꠣꠛꠦꠔ ꠙꠣꠌ ꠝꠣꠡ ꠛꠣꠠꠤꠞ ꠛꠣꠞꠦ ꠛꠣꠞ ꠅꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_25","072_1_25","LUK","1","25","25","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠔ ꠀꠟ꠆ꠟꠣꠁ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ। ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠎꠦ ꠈꠥꠐꠣꠞ ꠜꠣꠉꠤ ꠅꠁꠍꠤ, ꠅꠃ ꠈꠥꠐꠣꠞ ꠡꠞꠝ ꠢꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK1_26","072_1_26","LUK","1","26","27","ꠄꠟꠤꠍꠣꠛꠦꠔꠞ ꠙꠦꠐꠅ ꠎꠦꠛꠟꠣ ꠍꠄ ꠝꠣꠡꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ, ꠅꠃ ꠡꠝꠄ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠔ ꠄꠇꠎꠘ ꠀꠛꠤꠀꠔꠤ ꠡꠔꠤ ꠘꠣꠞꠤ ꠀꠍꠟꠣ, ꠄꠘ ꠘꠣꠝ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠤꠛꠞꠣꠁꠟ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠛꠦꠎꠤꠟꠣ। ꠔꠣꠘ ꠛꠤꠀ ꠑꠤꠇ ꠅꠁꠍꠤꠟ, ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠁꠃꠍꠥꠚ ꠘꠣꠝꠞ ꠄꠇꠎꠘꠞ ꠟꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("LK1_28","072_1_28","LUK","1","28","28","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠁꠀ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠞꠦ ꠇꠁꠟꠣ, “ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ; ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠙꠘꠣꠞꠦ ꠞꠢꠝꠔ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK1_29","072_1_29","LUK","1","29","29","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠞꠤꠅꠝꠞ ꠝꠘ ꠙꠦꠞꠦꠡꠣꠘ ꠅꠁꠉꠦꠟ। ꠔꠣꠁꠘ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, ꠁ ꠍꠣꠟꠣꠝꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ? ");
INSERT INTO syls_vpl VALUES ("LK1_30","072_1_30","LUK","1","30","30","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠝꠞꠤꠅꠝ, ꠀꠙꠘꠦ ꠒꠞꠣꠁꠛꠣ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠙꠘꠣꠞꠦ ꠞꠢꠝꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_31","072_1_31","LUK","1","31","31","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠙꠄꠖꠣ ꠅꠁꠛꠣ, ꠀꠙꠘꠦ ꠄꠘ ꠘꠣꠝ ꠞꠣꠈꠛꠣ, ꠁꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_32","072_1_32","LUK","1","32","32","ꠔꠣꠁꠘ ꠛꠃꠔ ꠛꠠ ꠁꠎ꠆ꠎꠔꠤ ꠅꠁꠛꠣ। ꠔꠣꠘꠞꠦ ꠇꠅꠀ ꠅꠁꠛ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ। ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖꠞ ꠉꠖꠤ ꠔꠣꠘꠞꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_33","072_1_33","LUK","1","33","33","ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀ ꠀꠈꠦꠞꠣꠔꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠛꠣ, ꠔꠣꠘ ꠛꠣꠖꠡꠣꠁ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠚꠥꠠꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK1_34","072_1_34","LUK","1","34","34","ꠔꠦꠃ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠇꠤꠟꠣꠘ ꠅꠁꠛ? ꠀꠝꠣꠞ ꠔ ꠛꠤꠀ-ꠡꠣꠖꠤꠃ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK1_35","072_1_35","LUK","1","35","35","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠙꠘꠣꠞ ꠃꠙꠞꠦ ꠘꠣꠎꠤꠟ ꠅꠁꠛꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠍꠣꠄꠀ ꠀꠙꠘꠣꠞ ꠃꠙꠞꠦ ꠀꠁꠛ। ꠄꠞꠖꠣꠄꠃ ꠀꠙꠘꠣꠞ ꠊꠞꠅ ꠎꠦ ꠙꠣꠇ ꠀꠅꠟꠣꠖꠦ ꠎꠘꠝ ꠟꠁꠛꠣ, ꠔꠣꠘꠞꠦ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK1_36","072_1_36","LUK","1","36","36","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞ ꠇꠥꠐꠥꠝ ꠛꠤꠛꠤ ꠄꠟꠤꠍꠣꠛꠦꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠘꠡꠦ ꠇꠁꠔꠣ ꠘꠣ ꠘꠤ, ꠔꠣꠘ ꠇꠥꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠃ ꠅꠁꠔꠣ ꠘꠣꠄ? ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠅꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠄꠅꠡꠅ ꠔꠣꠘ ꠙꠦꠐꠅ-ꠅ ꠍꠄ ꠝꠣꠡꠞ ꠙꠥꠀ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK1_37","072_1_37","LUK","1","37","37","ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠙꠣꠞꠂꠘ ꠘꠣ, ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK1_38","072_1_38","LUK","1","38","38","ꠝꠞꠤꠅꠝꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠘ꠆ꠖꠤ; ꠀꠙꠘꠣꠞ ꠇꠕꠣꠝꠔꠃ ꠢꠇꠟꠔꠣ ꠚꠟꠃꠇ।” ꠛꠣꠖꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_39","072_1_39","LUK","1","39","39","ꠄꠞꠛꠣꠖꠦ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝ ꠃꠠꠣ-ꠔꠣꠠꠣ ꠇꠞꠤ, ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠄꠇ ꠙꠣꠠꠤꠀ ꠉꠣꠃꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_40","072_1_40","LUK","1","40","40","ꠉꠤꠀ ꠢꠘꠅ ꠁꠝꠣꠝ ꠎꠣꠇꠣꠞꠤꠀꠞ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠀ, ꠔꠣꠘ ꠛꠤꠛꠤ ꠄꠟꠤꠍꠣꠛꠦꠔꠞꠦ ꠍꠣꠟꠣꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_41","072_1_41","LUK","1","41","41","ꠄꠟꠤꠍꠣꠛꠦꠔꠦ ꠝꠞꠤꠅꠝꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ, ꠔꠣꠘ ꠙꠦꠐꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠈꠔꠣ ꠟꠠꠤꠀ ꠃꠑꠤꠟꠣ। ꠔꠣꠁꠘ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("LK1_42","072_1_42","LUK","1","42","42","ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠤꠃ ꠇꠙꠣꠟꠤ, ꠔꠥꠝꠣꠞ ꠙꠦꠐꠞ ꠍꠣꠛꠣꠟꠅ ꠇꠙꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("LK1_43","072_1_43","LUK","1","43","43","ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠝꠣ ꠀꠝꠣꠞ ꠊꠞꠅ ꠔꠡꠞꠤꠚ ꠀꠘꠍꠂꠘ, ꠀꠝꠣꠞ ꠅꠔ ꠛꠠ ꠇꠙꠣꠟ ꠇꠤꠟꠣ ꠅꠁꠟ? ");
INSERT INTO syls_vpl VALUES ("LK1_44","072_1_44","LUK","1","44","44","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ, ꠀꠝꠣꠞ ꠙꠦꠐꠞ ꠉꠦꠖꠣꠄꠅ ꠈꠥꠡꠤꠄ ꠟꠠꠤꠀ ꠃꠑꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_45","072_1_45","LUK","1","45","45","ꠔꠥꠝꠤ ꠔ ꠇꠙꠣꠟꠤ ꠛꠦꠐꠤ, ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠦ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠍꠂꠘ, ꠔꠥꠝꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠁꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠍ।” ");
INSERT INTO syls_vpl VALUES ("LK1_46","072_1_46","LUK","1","46","46","ꠅꠃ ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠇꠟꠛꠦ ꠔꠣꠞꠤꠚ ꠇꠞꠦꠞ ꠀꠝꠣꠞ ꠝꠣꠛꠥꠖꠞ, ");
INSERT INTO syls_vpl VALUES ("LK1_47","072_1_47","LUK","1","47","47","ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠈꠥꠡꠤꠄ ꠜꠞꠤꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠅꠘ꠆ꠔꠞ, ꠔꠞꠣꠅꠞꠣ ꠌꠣꠘ꠆ꠖ ꠀꠁꠍꠂꠘ, ꠅꠜꠣꠉꠤꠘꠤꠞ ꠊꠞ। ");
INSERT INTO syls_vpl VALUES ("LK1_48","072_1_48","LUK","1","48","48","ꠌꠃꠈ ꠔꠥꠟꠤꠀ ꠌꠣꠁꠍꠂꠘ ꠖꠄꠀꠟ, ꠇꠣꠋꠉꠣꠟ ꠛꠣꠘ꠆ꠖꠤꠞ ꠛꠣꠄ, ꠄꠞꠖꠣꠄꠃ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠄ ꠡꠣꠛꠣꠡ ꠡꠣꠛꠣꠡ ꠉꠣꠄ, ꠛꠠ ꠇꠙꠣꠟꠤ ꠇꠁꠛꠣ ꠝꠞꠦ, ꠎꠥꠉ-ꠎꠥꠉꠣꠘ꠆ꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("LK1_49","072_1_49","LUK","1","49","49","ꠡꠇ꠆ꠔꠤꠝꠣꠘꠦ ꠇꠞꠟꠣ ꠝꠞꠦ ꠅꠔ ꠛꠠ ꠇꠣꠝ, ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠅꠁꠍꠂꠘ ꠔꠣꠁꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠍꠣꠘ, ꠔꠣꠁꠘꠃ ꠔ ꠍꠥꠛꠢꠣꠘ ꠀꠟ꠆ꠟꠣ, ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠔꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_50","072_1_50","LUK","1","50","50","ꠎꠦꠞꠣ ꠔꠣꠘꠦ ꠔꠣꠎꠤꠝ ꠇꠞꠤ ꠞꠂꠘ ꠒꠞꠣꠁꠀ, ꠞꠢꠝ ꠇꠞꠂꠘ ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠘꠤꠎꠞ ꠎꠣꠘꠤꠀ, ꠅꠀꠞꠤꠡꠦ ꠅꠀꠞꠤꠡꠦ ꠞꠢꠝ, ꠔꠣꠁꠘꠃ ꠛꠤꠟꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_51","072_1_51","LUK","1","51","51","ꠔꠣꠘꠃ ꠇꠥꠖꠞꠔꠤ ꠀꠔꠦ ꠇꠞꠍꠂꠘ ꠝꠢꠣ ꠇꠣꠝ, ꠝꠘꠞ ꠉꠞꠤꠝꠣꠄ ꠎꠦꠔꠣꠄ ꠇꠞꠦ ꠛꠠꠣꠁ ꠡꠣꠘ, ꠁꠔꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠀ, ꠛꠂꠔꠟ ꠛꠣꠘꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_52","072_1_52","LUK","1","52","52","ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣꠁꠘ ꠢꠇꠤꠞ ꠅꠁꠟꠣ ꠉꠖꠤ ꠈꠥꠀꠁꠀ, ꠢꠇꠤꠞ ꠅꠇꠟ ꠛꠣꠖꠡꠣ ꠅꠁꠟꠣ ꠞꠢꠝꠔ ꠙꠣꠁꠀ, ꠃꠌꠣ-ꠘꠤꠌꠣ ꠢꠇꠤꠞ-ꠛꠣꠖꠡꠣ, ꠔꠣꠁꠘꠃ ꠛꠣꠘꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_53","072_1_53","LUK","1","53","53","ꠃꠙꠣꠡꠤ ꠇꠣꠋꠉꠣꠟꠞꠦ ꠖꠤꠟꠣ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠈꠣꠘꠤ, ꠜꠥꠇꠣꠡꠤꠞ ꠙꠦꠐꠅ ꠉꠦꠟ ꠖꠣꠝꠤ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ, ꠗꠘꠤ ꠎꠘꠞꠦ ꠈꠣꠟꠤ ꠀꠔꠦ, ꠈꠦꠖꠣꠁꠀ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_54","072_1_54","LUK","1","54","54","ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠟꠉꠦ, ꠅꠟꠣꠃ ꠔ ꠀꠍꠣꠘ ꠇꠞꠍꠂꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠙꠘ ꠉꠥꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK1_55","072_1_55","LUK","1","55","55","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠁꠀꠖ ꠞꠣꠈꠍꠂꠘ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠛꠣ, ꠟꠉꠦ ꠔꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠦꠅ ꠅꠃ ꠖꠄꠀ ꠙꠣꠁꠛꠣ, ꠌꠤꠞꠇꠣꠟꠤꠘ ꠅꠃ ꠅꠀꠖꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠍꠂꠘ॥” ");
INSERT INTO syls_vpl VALUES ("LK1_56","072_1_56","LUK","1","56","56","ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝ ꠔꠣꠘ ꠇꠥꠐꠥꠝ ꠄꠟꠤꠍꠣꠛꠦꠔꠞ ꠉꠦꠍꠦ ꠔꠤꠘ ꠝꠣꠡ ꠞꠁꠟꠣ, ꠢꠦꠡꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK1_57","072_1_57","LUK","1","57","57","ꠛꠣꠖꠦ ꠝꠤꠀꠖ ꠙꠥꠞꠣ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠄꠟꠤꠍꠣꠛꠦꠔꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_58","072_1_58","LUK","1","58","58","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠅꠔ ꠛꠠ ꠞꠢꠝ ꠇꠞꠍꠂꠘ ꠢꠥꠘꠤꠀ, ꠀꠞꠤ-ꠚꠞꠤ ꠀꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠅꠇꠟ ꠀꠁꠀ ꠔꠣꠘ ꠟꠉꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_59","072_1_59","LUK","1","59","59","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠞꠦꠅꠀꠎ ꠝꠣꠚꠤꠇ ꠎꠘꠝꠞ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ, ꠙꠥꠀꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠀꠞ ꠀꠇꠤꠇꠣ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠢꠇꠟ ꠖꠟꠣ ꠅꠁꠟꠣ। ꠔꠣꠞꠣ ꠌꠣꠁꠟꠣ, ꠛꠣꠚꠞ ꠘꠣꠝꠞ ꠟꠣꠈꠣꠘ ꠙꠥꠀꠞ ꠘꠣꠝꠅ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LK1_60","072_1_60","LUK","1","60","60","ꠅꠁꠟꠦ ꠝꠣʼꠄ ꠁꠈꠣꠘ ꠝꠣꠘꠟꠣ ꠘꠣ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠘꠣ, ꠄꠞ ꠘꠣꠝ ꠅꠁꠛ ꠄꠢꠤꠀ।” ");
INSERT INTO syls_vpl VALUES ("LK1_61","072_1_61","LUK","1","61","61","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝꠞ ꠝꠣꠎꠦ ꠔ ꠁꠟꠣ ꠘꠣꠝ ꠇꠦꠃꠞꠞ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK1_62","072_1_62","LUK","1","62","62","ꠔꠦꠃ ꠔꠣꠞꠣ ꠁꠡꠣꠞꠣꠄ ꠙꠥꠀꠞ ꠛꠣꠚꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, ꠔꠣꠁꠘ ꠇꠥꠘ ꠘꠣꠝ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_63","072_1_63","LUK","1","63","63","ꠎꠣꠇꠣꠞꠤꠀꠄ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠈꠣꠔꠣ-ꠇꠟꠝ ꠘꠤꠀ ꠟꠦꠈꠟꠣ, “ꠔꠣꠞ ꠘꠣꠝ ꠄꠢꠤꠀ।” ꠅꠃ ꠔꠣꠞꠣ ꠢꠇꠟ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_64","072_1_64","LUK","1","64","64","ꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠎꠣꠇꠣꠞꠤꠀꠞ ꠎꠛꠣꠘ ꠈꠥꠟꠤꠉꠦꠟ, ꠔꠣꠁꠘ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠟꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK1_65","072_1_65","LUK","1","65","65","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠞꠤ-ꠚꠞꠤ ꠢꠇꠟꠦ ꠒꠞꠣꠁꠉꠦꠟꠣ। ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠙꠣꠠꠤꠀ ꠅꠘ꠆ꠌꠟꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠝꠥꠈꠦ ꠝꠥꠈꠦ ꠅꠃ ꠈꠛꠞ ꠞꠐꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK1_66","072_1_66","LUK","1","66","66","ꠎꠔ ꠝꠣꠘꠡꠦ ꠁ ꠊꠐꠘꠣ ꠢꠥꠘꠍꠤꠟ, ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠝꠘꠦ ꠝꠘꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ ꠇꠁꠟ, ꠛꠠ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠁ ꠙꠥꠀ ꠇꠤꠔꠣ ꠅꠁꠛ। ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠔꠣꠘ ꠃꠙꠞꠦ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK1_67","072_1_67","LUK","1","67","67","ꠛꠣꠖꠦ ꠙꠥꠀꠞ ꠛꠣꠚ ꠎꠣꠇꠣꠞꠤꠀ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ ꠅꠃ ꠉꠣꠁꠛꠤ ꠈꠛꠞ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK1_68","072_1_68","LUK","1","68","68","“ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁ ꠀꠝꠤ ꠛꠘ꠆ꠖꠣꠄ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ, ꠀꠍꠣꠘ ꠇꠞꠍꠂꠘ ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠀꠙꠘ ꠁꠍꠞꠣꠁꠟꠞ, ꠈꠤꠀꠟ ꠇꠞꠤ ꠇꠞꠟꠣ ꠀꠎꠣꠖ ꠘꠤꠎꠞ ꠉꠥꠟꠣꠝ ꠖꠟ। ");
INSERT INTO syls_vpl VALUES ("LK1_69","072_1_69","LUK","1","69","69","ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠣ ꠖꠣꠃꠖ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ, ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔꠤ ꠇꠣꠘ꠆ꠒꠣꠞꠤꠞꠦ ꠀꠘꠟꠣ ꠅꠈꠣꠘ ꠕꠘꠦ, ꠖꠦꠈꠣꠁꠟꠣꠄ ꠖꠄꠀꠟ ꠝꠞꠦ ꠘꠣꠎꠣꠔ ꠇꠞꠞꠣ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_70","072_1_70","LUK","1","70","70","ꠘꠛꠤ ꠅꠇꠟꠦ ꠎꠛꠣꠘꠖꠤ ꠇꠁꠍꠟꠣ ꠛꠃꠔ ꠀꠉꠦ, ꠔꠣꠁꠘꠃ ꠇꠅꠀꠁꠍꠟꠣ ꠁꠔꠣ ꠘꠛꠤ ꠅꠇꠟꠞ ꠝꠥꠈꠦ, ꠔꠣꠇ꠆ꠇꠔꠤ ꠇꠣꠘ꠆ꠒꠣꠞꠤꠃ ꠅꠁꠛꠣ ꠖꠣꠃꠖ ꠇꠥꠟꠞ ꠛꠟ। ");
INSERT INTO syls_vpl VALUES ("LK1_71","072_1_71","LUK","1","71","71","ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞ ꠇꠛꠎꠣ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠛꠣꠌꠣꠁꠟꠣ, ꠊꠤꠘ-ꠁꠋꠡꠣ ꠇꠞꠞꠣ ꠕꠣꠇꠤ ꠅꠈꠘ ꠚꠣꠘꠣ ꠖꠤꠟꠣ, ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠟꠣ ꠀꠁꠀ ꠖꠄꠀꠟ ꠝꠃꠟꠣꠞ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("LK1_72","072_1_72","LUK","1","72","72","ꠛꠣꠌꠣꠁꠟꠣ ꠀꠝꠞꠣꠞꠦ ꠈꠣꠟꠤ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠈꠣꠔꠤꠞꠦ, ꠇꠍꠝ ꠇꠞꠣ ꠙꠣꠇ ꠅꠀꠖꠣ ꠙꠥꠞꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ, ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠎꠛꠣꠘ ꠖꠦꠅꠀꠄ ꠀꠝꠞꠣ ꠛꠣꠌꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK1_73","072_1_73","LUK","1","73","73","ꠇꠍꠝ ꠇꠞꠤ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ ꠖꠄꠀꠟ ꠀꠟ꠆ꠟꠣꠄ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ ꠔꠣꠁꠘ ꠘꠣꠎꠣꠔꠞ ꠃꠙꠣꠄ, ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠃ ꠅꠁꠟꠣ ꠀꠝꠞꠣꠞ ꠀꠍꠟ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("LK1_74","072_1_74","LUK","1","74","75","ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠔꠣ ꠇꠞꠤ ꠝꠃꠟꠣꠞ ꠅꠃ ꠇꠍꠝ, ꠖꠥꠡꠝꠘ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠔꠣꠁ ꠖꠤꠟꠣ ꠘꠤꠅꠝ, ꠎꠤꠘ꠆ꠖꠣ ꠎꠥꠖꠤꠘ ꠀꠍꠤ ꠀꠝꠞꠣ ꠘꠤꠌꠤꠘ꠆ꠔꠣ ꠞꠁꠔꠣꠝ। ꠒꠞ-ꠈꠚ ꠍꠣꠠꠣ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠇꠞꠤ ꠄꠛꠣꠖꠔ, ꠙꠞꠦꠎꠉꠣꠞ ꠀꠞ ꠍꠢꠤ ꠙꠕꠦ ꠕꠣꠇꠤ ꠘꠤꠞꠣꠙꠖ, ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠞꠁꠀ ꠎꠣꠔꠦ ꠇꠞꠤ ꠔꠣꠘ ꠈꠦꠎꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("LK1_76","072_1_76","LUK","1","76","76","ꠅꠞꠦ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠙꠥꠔ ꠄꠢꠤꠀ ꠛꠣꠛꠣꠎꠤ, ꠔꠥꠝꠣꠞꠦ ꠔ ꠒꠣꠇꠣ ꠅꠁꠛ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠘꠛꠤ, ꠝꠥꠘꠤꠛꠞ ꠀꠉꠦ ꠞꠁꠀ ꠍꠢꠤ ꠇꠞꠛꠣꠄ ꠙꠕ। ");
INSERT INTO syls_vpl VALUES ("LK1_77","072_1_77","LUK","1","77","77","ꠛꠣꠔꠣꠁ ꠖꠤꠛꠣꠄ ꠔꠥꠝꠤ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ, ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠙꠕ ꠌꠤꠘꠛꠣ ꠔꠥꠝꠣꠞ ꠔꠣꠟꠤꠝꠦ, ꠛꠣꠔꠣꠁꠀ ꠖꠤꠛꠣꠄ ꠛꠣꠛꠣ ꠘꠣꠎꠣꠔ ꠙꠣꠅꠀꠞ ꠙꠕ। ");
INSERT INTO syls_vpl VALUES ("LK1_78","072_1_78","LUK","1","78","78","ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝ ꠀꠞ ꠢꠃ ꠝꠢꠛ꠆ꠛꠔꠦ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠘꠥꠞꠞ ꠄꠇ ꠡꠥꠞꠥꠎ ꠀꠁꠛꠣ ꠃꠙꠞꠦꠔꠦ, ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠁꠀ ꠢꠣꠞꠤ ꠞꠣꠈꠤꠛꠣ ꠘꠎꠞ। ");
INSERT INTO syls_vpl VALUES ("LK1_79","072_1_79","LUK","1","79","79","ꠝꠃꠔ ꠀꠞ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠉꠣꠔꠅ ꠎꠦꠞꠣ ꠇꠣꠐꠣꠄ ꠖꠤꠘ, ꠘꠥꠞꠞ ꠙꠕ ꠖꠦꠈꠛꠣ ꠔꠣꠞꠣ ꠇꠞꠤꠀ ꠄꠇꠤꠘ, ꠀꠝꠞꠣꠞꠦꠅ ꠡꠣꠘ꠆ꠔꠤꠞ ꠙꠕꠦ ꠌꠣꠟꠣꠁꠛꠣ ꠅꠃ ꠎꠘ। ꠅꠃ ꠢꠥꠎꠥꠞ ꠘꠣꠎꠤꠟ ꠅꠁꠀ ꠖꠦꠈꠣꠁꠛꠣ ꠇꠥꠖꠞꠔ, ꠔꠣꠁꠘꠃ ꠢꠃ ꠅꠀꠖꠣ ꠇꠞꠣ ꠀꠟ꠆ꠟꠣꠁ ꠞꠢꠝꠔ॥” ");
INSERT INTO syls_vpl VALUES ("LK1_80","072_1_80","LUK","1","80","80","ꠛꠣꠖꠦ ꠄꠢꠤꠀ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠛꠠ ꠅꠁꠟꠣ, ꠟꠉꠦ ꠅꠁꠀ ꠔꠣꠘ ꠞꠥꠢꠣꠘꠤ ꠛꠟꠅ ꠛꠣꠠꠤꠟ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠍꠣꠝꠘꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠎꠣꠁꠞ ꠅꠁꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠔꠣꠁꠘ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_1","072_2_1","LUK","2","1","1","ꠅꠃ ꠡꠝꠄ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣ ꠀꠉꠡ꠆ꠔ ꠇꠂꠍꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠔꠣꠘ ꠀꠡ꠆ꠔꠣ ꠛꠣꠖꠡꠣꠁꠞ ꠢꠇꠟ ꠙ꠆ꠞꠎꠣꠄ ꠎꠣꠞꠎꠤꠞ ꠘꠣꠝ ꠟꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK2_2","072_2_2","LUK","2","2","2","ꠡꠤꠞꠤꠀꠞ ꠢꠣꠇꠤꠝ ꠇꠥꠞꠤꠘꠤꠀꠍꠞ ꠀꠝꠟꠅ, ꠅꠃ ꠙꠄꠟꠣ ꠛꠣꠞ ꠝꠣꠘꠥꠡ ꠉꠘꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠝ ꠟꠦꠈꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK2_3","072_2_3","LUK","2","3","3","ꠔꠦꠃ ꠘꠣꠝ ꠟꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠎꠣꠞꠎꠤꠞ ꠛꠥꠘꠤꠀꠖꠤ ꠉꠣꠃꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_4","072_2_4","LUK","2","4","4","ꠅꠃ ꠟꠣꠈꠣꠘ ꠁꠃꠍꠥꠚꠅ ꠘꠣꠝ ꠟꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃ ꠕꠣꠇꠤ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖꠞ ꠉꠣꠃꠔ ꠀꠁꠟꠣ। ꠔꠣꠁꠘ ꠔ ꠖꠣꠃꠖꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ। ꠉꠣꠃꠞ ꠘꠣꠝ ꠛꠦꠕꠦꠟꠢꠣꠝ, ꠁꠐꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("LK2_5","072_2_5","LUK","2","5","5","ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠅ ꠅꠃ ꠁꠃꠍꠥꠚꠞ ꠟꠉꠦ ꠅꠁꠀ ꠘꠣꠝ ꠟꠦꠈꠣꠘꠤꠔ ꠉꠦꠟꠣ। ꠅꠃ ꠁꠃꠍꠥꠚꠞ ꠟꠉꠦꠃ ꠔꠣꠘ ꠡꠣꠖꠤ ꠑꠤꠇ ꠅꠁꠍꠤꠟ, ꠀꠞ ꠔꠣꠘ ꠙꠦꠐꠅ ꠅꠃ ꠡꠝꠄ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK2_6","072_2_6","LUK","2","6","6","ꠛꠦꠕꠦꠟꠢꠣꠝꠅ ꠕꠣꠇꠔꠦꠃ ꠝꠞꠤꠅꠝꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠛꠣꠞ ꠛꠤꠡꠦ ꠗꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK2_7","072_2_7","LUK","2","7","7","ꠀꠞ ꠔꠣꠘ ꠙꠄꠟꠣ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟ। ꠅꠁꠟꠦ ꠢꠤꠘꠅ ꠇꠥꠘꠥ ꠝꠦꠝꠣꠘ ꠈꠣꠘꠣꠔ ꠕꠣꠇꠣꠞ ꠎꠣꠉꠣ ꠝꠤꠟꠟ ꠘꠣ, ꠄꠞꠖꠣꠄ ꠝꠞꠤꠅꠝꠦ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠔꠦꠘꠣꠖꠤ ꠛꠦꠞꠣꠁꠀ ꠉꠥꠀꠟ ꠊꠞꠞ ꠈꠦꠞꠞ ꠉꠣꠝꠟꠣꠔ ꠢꠥꠔꠣꠁ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_8","072_2_8","LUK","2","8","8","ꠅꠃ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠘ꠆ꠖꠞ ꠝꠣꠎꠦ, ꠝꠦꠠꠣꠞ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠔꠣꠞꠣꠞ ꠝꠦꠠꠣ ꠙꠣꠞꠣ ꠖꠦꠅꠀꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK2_9","072_2_9","LUK","2","9","9","ꠀꠈꠔꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠖꠞꠡꠘ ꠖꠤꠟꠣ, ꠀꠞ ꠝꠣꠛꠥꠖꠞ ꠘꠥꠞꠞ ꠔꠦꠎꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠚꠞ ꠅꠁꠉꠦꠟ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠞꠣꠈꠣꠟ ꠅꠇꠟ ꠒꠞꠞ ꠌꠥꠐꠦ ꠛꠦꠖꠤꠡꠣ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_10","072_2_10","LUK","2","10","10","ꠅꠁꠟꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠛ ꠈꠥꠡꠤꠞ ꠈꠛꠞ ꠟꠁꠀ ꠀꠁꠍꠤ। ꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK2_11","072_2_11","LUK","2","11","11","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠀꠁꠎ ꠖꠣꠃꠖꠞ ꠉꠣꠃꠔ ꠎꠘꠝ ꠟꠁꠍꠂꠘ। ꠔꠣꠁꠘꠃ ꠀꠟ-ꠝꠍꠤ, ꠔꠣꠁꠘꠃ ꠝꠣꠟꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("LK2_12","072_2_12","LUK","2","12","12","ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠄꠞ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠛꠣꠄ, ꠖꠦꠈꠛꠣꠄ ꠄꠇ ꠇꠣꠌꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠔꠦꠘꠣꠖꠤ ꠛꠦꠞꠣꠁꠀ, ꠉꠥꠀꠟ ꠊꠞꠞ ꠈꠦꠞꠞ ꠉꠣꠝꠟꠣꠔ ꠢꠥꠔꠣꠁꠀ ꠕꠅꠀ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK2_13","072_2_13","LUK","2","13","13","ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠟꠉꠦ ꠀꠞꠅ ꠛꠃꠔ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠖꠦꠈꠣ ꠉꠦꠟ। ꠄꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠎꠤꠇꠤꠞ-ꠀꠎꠇꠣꠞ ꠇꠞꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK2_14","072_2_14","LUK","2","14","14","“ꠀꠍꠝꠣꠘꠅ ꠀꠟ꠆ꠟꠣꠞ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠣ ꠎꠣꠃꠇ, ꠖꠥꠘꠤꠀꠞ ꠛꠥꠇꠥꠔ ꠔꠣꠘ ꠙꠤꠀꠞꠣ ꠛꠘ꠆ꠖꠣꠞ ꠡꠣꠘ꠆ꠔꠤ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("LK2_15","072_2_15","LUK","2","15","15","ꠛꠣꠖꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠍꠝꠣꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ, ꠞꠣꠈꠣꠟ ꠅꠇꠟꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠇꠁꠟ, “ꠀꠅ, ꠀꠝꠞꠣ ꠛꠦꠕꠦꠟꠢꠣꠝꠅ ꠎꠣꠁ। ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟꠣ, ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK2_16","072_2_16","LUK","2","16","16","ꠝꠣꠔꠤ ꠝꠣꠔꠤ ꠔꠣꠞꠣ ꠎꠟꠖꠤ ꠇꠞꠤ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠝꠞꠤꠅꠝ, ꠁꠃꠍꠥꠚ ꠀꠞ ꠈꠦꠞꠞ ꠉꠣꠝꠟꠣꠔ ꠢꠥꠔꠣꠁꠟ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_17","072_2_17","LUK","2","17","17","ꠙꠣꠁꠀ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠦ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠁꠔꠣ ꠔꠣꠞꠣ ꠢꠇꠟꠞꠦ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_18","072_2_18","LUK","2","18","18","ꠔꠣꠞꠣꠞ ꠝꠣꠔ ꠢꠥꠘꠤꠀ ꠢꠇꠟꠦꠃ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_19","072_2_19","LUK","2","19","19","ꠅꠁꠟꠦ ꠝꠞꠤꠅꠝꠦ ꠢꠇꠟꠔꠣ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠟꠣ, ꠀꠞ ꠝꠘꠦ ꠝꠘꠦ ꠌꠤꠘ꠆ꠔꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_20","072_2_20","LUK","2","20","20","ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠞꠣꠈꠣꠟ ꠅꠇꠟꠞꠦ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣ, ꠄꠞꠣ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠥꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠎꠤꠇꠤꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤ ꠇꠞꠤ ꠚꠤꠞꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK2_21","072_2_21","LUK","2","21","21","ꠛꠣꠖꠦ ꠎꠘꠝꠞ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠀꠇꠤꠇꠣ ꠀꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤꠞ ꠛꠣꠟꠣ, ꠔꠣꠘ ꠘꠣꠝ ꠞꠣꠈꠣ ꠅꠁꠟ ꠁꠍꠣ। ꠝꠣʼꠞ ꠙꠦꠐꠅ ꠀꠁꠛꠣꠞ ꠀꠉꠦꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠅꠃ ꠘꠣꠝ ꠕꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_22","072_2_22","LUK","2","22","22","ꠄꠞꠝꠣꠎꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠡꠝꠄ ꠅꠁꠟ। ꠔꠦꠃ ꠁꠍꠣꠞꠦ ꠝꠣꠛꠥꠖꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ, ꠁꠃꠍꠥꠚ ꠀꠞ ꠝꠞꠤꠅꠝꠦ ꠔꠣꠘꠦ ꠟꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_23","072_2_23","LUK","2","23","23","ꠝꠣꠛꠥꠖꠞ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠀꠍꠤꠟ, ꠙꠞꠔꠦꠇ ꠎꠣꠘꠖꠣꠞꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠡꠙꠤꠀ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK2_24","072_2_24","LUK","2","24","24","ꠄꠞꠟꠉꠦ, ꠄꠇ ꠎꠥꠠꠣ ꠒꠥꠙꠤ ꠙꠣꠈꠤ ꠛꠣ ꠙꠣꠞꠅꠞ ꠖꠥꠁꠐꠣ ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠦ ꠅꠁꠛ, ꠡꠞꠤꠅꠔꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_25","072_2_25","LUK","2","25","25","ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠍꠣꠝꠣꠃꠘ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠛꠥꠎꠥꠞ꠆ꠉ ꠀꠍꠟꠣ, ꠔꠣꠁꠘ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ। ꠔꠣꠁꠘ ꠝꠘꠦ ꠝꠘꠦ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠡꠣꠘ꠆ꠔꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_26","072_2_26","LUK","2","26","26","ꠙꠣꠇ ꠞꠥꠢꠥ ꠔꠣꠘ ꠟꠉꠦ ꠀꠍꠟꠣ, ꠅꠃ ꠞꠥꠢꠦ ꠔꠣꠘꠞꠦ ꠛꠣꠔꠣꠁꠍꠟꠣ, ꠔꠣꠘ ꠝꠃꠔꠞ ꠀꠉꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠣꠁꠘ ꠖꠦꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_27","072_2_27","LUK","2","27","27","ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠁꠡꠣꠞꠣꠄ ꠍꠣꠝꠣꠃꠘ ꠅꠃ ꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠀꠎꠤꠞ ꠅꠁꠟꠣ। ꠁꠍꠣꠞ ꠝꠣ-ꠛꠣꠚꠦꠅ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠉꠦꠖꠣ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠅꠘꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_28","072_2_28","LUK","2","28","28","ꠅꠃ ꠇꠣꠝꠤꠟ ꠛꠥꠎꠥꠞ꠆ꠉ ꠍꠣꠝꠣꠃꠘꠦ ꠁꠍꠣꠞꠦ ꠇꠥꠟꠅ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK2_29","072_2_29","LUK","2","29","29","“ꠅ ꠝꠣꠟꠤꠇ, ꠔꠥꠝꠣꠞ ꠎꠛꠣꠘ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠣꠞ ꠁ ꠉꠥꠟꠣꠝꠞꠦ ꠅꠈꠘ ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠤꠖꠣꠄ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("LK2_30","072_2_30","LUK","2","30","31","ꠀꠖꠝ ꠎꠣꠔꠤꠞꠦ ꠔꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠔꠣꠝꠣꠝ ꠝꠣꠘꠡꠞ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ, ꠔꠥꠝꠤ ꠎꠦ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠣꠁꠝ ꠇꠞꠍ ꠢꠃ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠀꠝꠣꠞ ꠘꠤꠎ ꠌꠃꠈꠦ ꠖꠦꠈꠤꠀ ꠉꠦꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK2_32","072_2_32","LUK","2","32","32","ꠔꠥꠝꠣꠞ ꠈꠣꠍ ꠙ꠆ꠞꠎꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠃꠞꠛ ꠔ ꠄꠁꠘꠃ, ꠛꠣꠖ-ꠛꠣꠇꠤ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞꠦꠅ ꠙꠕ ꠖꠦꠈꠣꠘꠤꠞ ꠘꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK2_33","072_2_33","LUK","2","33","33","ꠍꠣꠝꠣꠃꠘꠦ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠃ ꠎꠦꠔꠣ ꠇꠁꠟꠣ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠞ ꠝꠣ-ꠛꠣꠚ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_34","072_2_34","LUK","2","34","34","ꠍꠣꠝꠣꠃꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠁꠍꠣꠞ ꠝꠣ ꠝꠞꠤꠅꠝꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠈꠤꠀꠟ ꠅꠁꠟ, ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠖꠞꠥꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠃꠔ ꠎꠘꠦ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛꠣ, ꠀꠞ ꠛꠃꠔ ꠎꠘ ꠟꠣꠘ꠆ꠘꠔꠤ ꠅꠁꠛꠣ। ꠔꠣꠁꠘ ꠅꠃ ꠟꠣꠈꠣꠘ ꠄꠇ ꠘꠤꠡꠣꠘꠣ, ꠔꠣꠘ ꠛꠤꠙꠇ꠆ꠇꠦ ꠛꠃꠔꠦꠃ ꠝꠣꠔꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LK2_35","072_2_35","LUK","2","35","35","ꠅꠔꠣ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠛꠥꠎꠣ ꠎꠣꠁꠛ। ꠀꠞ ꠢꠥꠘꠅ, ꠔꠟꠥꠀꠞꠦ ꠇꠣꠐꠤꠟꠦ ꠎꠦꠟꠣ ꠅꠄ, ꠔꠥꠝꠣꠞ ꠖꠤꠟꠅ-ꠅ ꠅꠟꠣ ꠖꠥꠈꠞ ꠍꠦꠟ ꠢꠣꠝꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK2_36","072_2_36","LUK","2","36","36","ꠅꠃ ꠡꠝꠄ ꠢꠣꠘ꠆ꠘꠣ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡꠅ ꠀꠍꠟꠣ, ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠘꠛꠤ। ꠔꠣꠘ ꠛꠣꠚꠞ ꠘꠣꠝ ꠙꠣꠘꠥꠄꠟ, ꠀꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠝ ꠀꠡꠤꠞ। ꠔꠣꠘ ꠛꠃꠔ ꠛꠄꠅꠡ ꠅꠁꠉꠦꠍꠦ, ꠡꠣꠔ ꠛꠍꠞ ꠎꠣꠝꠣꠁꠞ ꠊꠞ ꠇꠞꠤꠀ ꠢꠣꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("LK2_37","072_2_37","LUK","2","37","37","ꠌꠃꠞꠣꠡꠤ ꠛꠍꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠠꠣꠠꠤ ꠢꠣꠟꠔꠦ ꠀꠍꠟꠣ। ꠔꠣꠁꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠜꠤꠔꠞꠦ ꠞꠥꠎꠣ ꠞꠣꠈꠔꠣ ꠀꠞ ꠖꠥꠀ ꠇꠞꠔꠣ। ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤꠞ ꠝꠣꠎꠦ ꠞꠣꠁꠔ-ꠖꠤꠘ ꠇꠣꠐꠣꠁꠔꠣ, ꠛꠣꠞꠦ ꠛꠣꠞ ꠅꠁꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_38","072_2_38","LUK","2","38","38","ꠑꠤꠇ ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘꠅ ꠅꠘꠅ ꠀꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ꠀꠞ ꠎꠦꠞꠣꠞ ꠖꠤꠟꠅ ꠅꠃ ꠀꠡꠣ ꠀꠍꠤꠟ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠛꠣ, ꠔꠣꠞꠣꠞ ꠟꠉꠦꠅ ꠔꠣꠁꠘ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_39","072_2_39","LUK","2","39","39","ꠝꠞꠤꠅꠝ ꠀꠞ ꠁꠃꠍꠥꠚꠦ ꠝꠣꠛꠥꠖꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠢꠇꠟ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠞꠣꠞ ꠛꠡꠔ ꠛꠣꠠꠤ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK2_40","072_2_40","LUK","2","40","40","ꠘꠣꠛꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠛꠄꠅꠡ ꠛꠣꠠꠤꠟ, ꠄꠞꠟꠉꠦ ꠔꠣꠁꠘ ꠡꠞꠤꠟꠞ ꠛꠟ ꠀꠞ ꠁꠟꠤꠝ-ꠀꠈꠟꠦꠅ ꠝꠎꠛꠥꠔ ꠅꠁꠟꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠔ ꠔꠣꠘ ꠟꠉꠦ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK2_41","072_2_41","LUK","2","41","41","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠡꠝꠄ ꠀꠁꠟꠦ ꠁꠍꠣꠞ ꠝꠣ-ꠛꠣꠚ ꠙꠞꠔꠤ ꠛꠍꠞꠃ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_42","072_2_42","LUK","2","42","42","ꠁꠍꠣꠞ ꠛꠄꠅꠡ ꠎꠦꠛꠟꠣ ꠛꠣꠞꠅ ꠛꠍꠞ, ꠅꠃ ꠡꠝꠄꠅ ꠢꠃ ꠞꠦꠅꠀꠎ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_43","072_2_43","LUK","2","43","43","ꠁꠖ ꠡꠦꠡ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠛꠣꠠꠤꠔ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠅꠁꠟꠦ ꠁꠍꠣ ꠅꠃ ꠡꠝꠄ ꠁ ꠖꠟꠞ ꠟꠉꠦ ꠘꠣ ꠉꠤꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠞꠁꠉꠦꠟꠣ। ꠔꠣꠘ ꠝꠣ-ꠛꠣꠚꠦ ꠁꠈꠣꠘ ꠐꠦꠞ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_44","072_2_44","LUK","2","44","44","ꠁꠍꠣꠅ ꠖꠟꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠂꠘ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠄꠇꠖꠤꠘꠞ ꠙꠕ ꠀꠉꠥꠀꠁ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠀꠞ ꠟꠉꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤꠀ ꠔꠣꠘꠞꠦ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_45","072_2_45","LUK","2","45","45","ꠘꠣ ꠙꠣꠁꠀ ꠔꠣꠘꠞꠦ ꠔꠥꠇꠣꠁ ꠔꠥꠇꠣꠁ ꠢꠤꠞꠛꠣꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_46","072_2_46","LUK","2","46","46","ꠔꠤꠘ ꠖꠤꠘ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤꠀ ꠔꠣꠘꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠙꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠖꠦꠈꠟꠣ, ꠔꠣꠁꠘ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠛꠁꠀ ꠔꠣꠞꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠞꠣ, ꠀꠞ ꠘꠣꠘꠣꠘ ꠝꠥꠍꠟꠣ ꠎꠤꠇꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_47","072_2_47","LUK","2","47","47","ꠀꠞ ꠎꠔ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠝꠣꠔ ꠢꠥꠘꠟꠣ, ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠔꠣꠘ ꠀꠈꠟꠖꠣꠞꠤ ꠛꠣꠔꠌꠤꠔ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_48","072_2_48","LUK","2","48","48","ꠔꠣꠘ ꠝꠣ-ꠛꠣꠚꠦꠅ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠄꠇ꠆ꠇꠦꠞꠦ ꠌꠝꠇꠤꠉꠦꠟꠣ। ꠝꠣʼꠄ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠙꠥꠔꠞꠦ, ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠁꠔꠣ ꠇꠞꠟꠣꠄ ꠇꠦꠘꠦ? ꠀꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠦ ꠇꠔ ꠙꠦꠞꠦꠡꠣꠘ ꠅꠁꠀ ꠔꠥꠝꠣꠞꠦ ꠔꠥꠇꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK2_49","072_2_49","LUK","2","49","49","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤꠔꠣꠁꠘ ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠔꠥꠇꠣꠁꠞꠣꠄ? ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠀꠝꠤ ꠔ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠊꠞꠅꠃ ꠞꠁꠔꠦ ꠅꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("LK2_50","072_2_50","LUK","2","50","50","ꠔꠣꠘ ꠝꠣ-ꠛꠣꠚꠦ ꠁ ꠝꠣꠔꠞ ꠇꠥꠘꠥ ꠜꠦꠖ ꠛꠥꠎꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_51","072_2_51","LUK","2","51","51","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠛꠣꠞ ꠅꠁꠀ ꠝꠣ-ꠛꠣꠚꠞ ꠟꠉꠦ ꠅꠁꠀ ꠘꠣꠍꠣꠞꠔꠅ ꠉꠦꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠇꠕꠣꠝꠔ ꠌꠟꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠘ ꠝꠣʼꠄ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠖꠤꠟꠅ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK2_52","072_2_52","LUK","2","52","52","ꠄꠞꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔ, ꠝꠣꠘꠡꠞ ꠝꠣꠄꠀ, ꠛꠄꠅꠡ ꠀꠞ ꠁꠟꠤꠝ-ꠀꠈꠟꠦ ꠔꠣꠁꠘ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠛꠠ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK3_1","072_3_1","LUK","3","1","1","ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣ ꠔꠤꠛꠤꠞꠤꠅ ꠇꠂꠍꠞꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠙꠘꠞ ꠛꠍꠞ ꠌꠟꠦꠞ। ꠅꠃ ꠡꠝꠄ ꠙꠘ꠆ꠔꠤꠅ ꠙꠤꠟꠣꠔ ꠀꠍꠟꠣ ꠔꠣꠘ ꠅꠗꠤꠘꠞ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠢꠣꠇꠤꠝ, ꠀꠞ ꠢꠦꠞꠥꠖ ꠀꠍꠟꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠞꠣꠎꠣ, ꠢꠦꠞꠥꠖꠞ ꠜꠣꠁ ꠚꠤꠟꠤꠚ ꠀꠍꠟꠣ ꠎꠤꠔꠥꠞꠤꠀ ꠀꠞ ꠔꠣꠈꠥꠘꠤꠔꠤ ꠎꠤꠟꠣꠞ ꠞꠣꠎꠣ, ꠀꠞ ꠟꠥꠍꠣꠘꠤꠀꠍ ꠀꠍꠟꠣ ꠀꠛꠤꠟꠤꠘꠤ ꠎꠤꠟꠣꠞ ꠞꠣꠎꠣ। ꠄꠞꠣ ꠢꠇꠟꠃ ꠀꠍꠟꠣ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠞ ꠅꠗꠤꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("LK3_2","072_3_2","LUK","3","2","2","ꠅꠃ ꠀꠝꠟꠞ ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠀꠍꠟꠣ, ꠁꠝꠣꠝ ꠢꠣꠘꠘ ꠀꠞ ꠇꠣꠄꠀꠚꠣ। ꠑꠤꠇ ꠅꠃ ꠡꠝꠄ ꠎꠣꠇꠣꠞꠤꠀꠞ ꠙꠥꠔ ꠄꠢꠤꠀꠞ ꠉꠦꠍꠦ ꠝꠞꠥꠜꠥꠝꠤ ꠄꠟꠣꠇꠣꠔ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠘꠣꠎꠤꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK3_3","072_3_3","LUK","3","3","3","ꠔꠦꠃ ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠢꠇꠟ ꠈꠣꠘꠅ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ꠇꠁꠟꠣ, ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠝꠣꠚꠤ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠃꠛꠣ ꠇꠞꠤꠀ ꠔꠞꠤꠇꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("LK3_4","072_3_4","LUK","3","4","4","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠇꠤꠔꠣꠛꠅ ꠎꠦꠟꠣ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠅꠃꠟꠣ ꠇꠞꠟꠣ। ꠟꠦꠈꠣ ꠀꠍꠦ, ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠄꠇꠎꠘꠦ ꠄꠟꠣꠘ ꠇꠞꠞꠣ, ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇꠞ ꠙꠕ ꠍꠢꠤ ꠇꠞꠅ, ꠔꠣꠘ ꠌꠟꠣꠞ ꠞꠣꠡ꠆ꠔꠣ ꠅꠇꠟ ꠡꠤꠗꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("LK3_5","072_3_5","LUK","3","5","5","ꠙꠣꠠꠤꠀ ꠢꠇ꠆ꠇꠟ ꠘꠤꠌꠣ ꠎꠣꠉꠣ ꠜꠞꠣꠐ ꠅꠁꠛ, ꠃꠌꠣ-ꠘꠤꠌꠣ ꠐꠤꠟ꠆ꠟꠣꠁꠘ ꠢꠝꠣꠘ ꠇꠞꠣ ꠅꠁꠛ। ꠔꠦꠠꠣ-ꠛꠦꠇꠣ ꠢꠇꠟ ꠙꠕ ꠡꠥꠎꠣ ꠅꠁꠛ, ꠉꠣꠔ-ꠉꠣꠠꠣ ꠢꠇꠟꠔꠣ ꠢꠝꠣꠘ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK3_6","072_3_6","LUK","3","6","6","ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠔꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠘꠣꠎꠣꠔꠞ ꠎꠦ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠞꠍꠂꠘ ꠔꠣꠝꠣꠝ ꠝꠣꠘꠡꠦꠃ ꠁꠔꠣ ꠖꠦꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK3_7","072_3_7","LUK","3","7","7","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠔꠛꠟꠤꠉ ꠢꠥꠘꠤꠀ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠎꠦꠞꠣ ꠀꠁꠟ, ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠢꠣꠚꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠁꠘ, ꠀꠍꠝꠣꠘꠤ ꠉꠎꠛ ꠀꠁꠅꠞ ꠖꠦꠈꠤꠀ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠙꠕ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠦꠉꠤꠄ ꠛꠣꠔꠣꠁ ꠖꠤꠟ? ");
INSERT INTO syls_vpl VALUES ("LK3_8","072_3_8","LUK","3","8","8","ꠢꠣꠍꠣꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠤꠀ ꠕꠣꠇꠅ, ꠔꠦ ꠄꠞ ꠚꠟꠅ ꠖꠦꠈꠣꠅ। ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠅ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠅꠟꠣꠖ। ꠢꠥꠘꠅ, ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠁꠟꠦ ꠔ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟ ꠕꠣꠇꠤꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠅꠟꠣꠖ ꠛꠣꠘꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK3_9","072_3_9","LUK","3","9","9","ꠉꠣꠍꠞ ꠉꠥꠠꠤꠔ ꠔ ꠇꠥꠠꠣꠟ ꠟꠣꠉꠣꠁꠟꠃ ꠀꠍꠦ। ꠎꠦ ꠉꠣꠍꠅ ꠜꠣꠟꠣ ꠚꠟ ꠗꠞꠦ ꠘꠣ, ꠁ ꠉꠣꠍ ꠇꠣꠐꠤꠀ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK3_10","072_3_10","LUK","3","10","10","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠄꠢꠤꠀꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠦ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("LK3_11","072_3_11","LUK","3","11","11","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠇꠦꠃꠞꠞ ꠎꠥꠖꠤ ꠖꠥꠁꠐꠣ ꠇꠥꠞ꠆ꠔꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠎꠣꠞ ꠘꠣꠁ ꠔꠣꠞꠦ ꠄꠇꠐꠣ ꠖꠦꠃꠇ। ꠎꠣꠞ ꠊꠞꠅ ꠗꠣꠘ-ꠌꠣꠃꠟ ꠀꠍꠦ, ꠢꠦ-ꠅ ꠅꠃꠟꠣ ꠛꠤꠟꠣꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("LK3_12","072_3_12","LUK","3","12","12","ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠇꠄꠎꠘ ꠔꠡꠤꠟꠖꠣꠞꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠔ ꠀꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠝꠥꠞꠡꠤꠖ, ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("LK3_13","072_3_13","LUK","3","13","13","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠘꠤꠅꠝ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠐꠦꠇꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK3_14","072_3_14","LUK","3","14","14","ꠇꠄꠎꠘ ꠍꠤꠙꠣꠁꠄꠅ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠔꠦ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠇꠦꠃꠞꠞꠦ ꠎꠥꠞ-ꠎꠥꠟꠥꠝ ꠇꠞꠤꠀ ꠛꠣ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠁꠀ ꠇꠥꠘ꠆ꠔꠣ ꠀꠖꠣꠄ ꠇꠞꠤꠅ ꠘꠣ। ꠎꠣꠞꠎꠤꠞ ꠛꠦꠔꠘꠦ ꠈꠥꠡꠤ ꠞꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK3_15","072_3_15","LUK","3","15","15","ꠝꠣꠘꠡꠦ ꠝꠘꠦ ꠝꠘꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠤꠟ, ꠄꠢꠤꠀꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠀꠡꠣ ꠇꠞꠟ, ꠄꠁꠘꠃ ꠝꠘꠅꠟꠄ ꠀꠟ-ꠝꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LK3_16","072_3_16","LUK","3","16","16","ꠅꠁꠟꠦ ꠄꠢꠤꠀꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠈꠣꠟꠤ ꠙꠣꠘꠤꠖꠤ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠀꠞ, ꠔꠦ ꠀꠝꠣꠞ ꠛꠣꠖꠦ ꠎꠦꠁꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠔꠣꠁꠘ ꠀꠝꠣ ꠕꠣꠇꠤꠅ ꠔꠣꠇ꠆ꠇꠔ ꠀꠟꠣ। ꠔꠣꠘ ꠙꠣꠅꠞ ꠎꠥꠔꠣꠞ ꠚꠤꠔꠣ ꠉꠦꠍꠣ ꠈꠥꠟꠣꠞ ꠎꠥꠇꠣꠅ ꠀꠝꠤ ꠘꠣꠄ। ꠔꠣꠁꠘ ꠀꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠞ ꠀꠉꠥꠁꠘ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK3_17","072_3_17","LUK","3","17","17","ꠔꠣꠘ ꠇꠥꠟꠣ ꠔ ꠔꠣꠘ ꠀꠔꠅꠃ ꠀꠍꠦ, ꠝꠣꠠꠣ ꠖꠦꠅꠀ ꠗꠣꠘ ꠅꠃ ꠇꠥꠟꠣꠖꠤ ꠃꠀꠁꠀ ꠢꠣꠞꠤ ꠗꠣꠘ ꠘꠤꠀ ꠃꠉꠣꠞꠅ ꠔꠥꠟꠛꠣ, ꠀꠞ ꠍꠥꠍꠣꠞꠦ ꠅꠝꠘ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁ ꠎꠣꠟꠣꠁꠛꠣ, ꠎꠦ ꠀꠉꠥꠁꠘ ꠇꠥꠘꠥꠖꠤꠘ ꠘꠤꠜꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK3_18","072_3_18","LUK","3","18","18","ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠞꠅ ꠛꠃꠔ ꠘꠍꠤꠅꠔ ꠇꠞꠤꠀ ꠄꠢꠤꠀꠄ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK3_19","072_3_19","LUK","3","19","19","ꠅꠁꠟꠦ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠦ ꠛꠃꠔ ꠘꠝꠥꠘꠣꠞ ꠈꠣꠞꠣꠙ ꠇꠣꠝ ꠇꠞꠣꠄ, ꠀꠞ ꠔꠣꠞ ꠜꠣꠁꠞ ꠛꠃ ꠢꠦꠞꠥꠖꠤꠀꠞꠦ ꠢꠣꠋꠉꠣ ꠇꠞꠣꠄ, ꠄꠢꠤꠀꠄ ꠔꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK3_20","072_3_20","LUK","3","20","20","ꠄꠞꠖꠣꠄ ꠢꠦ ꠔꠣꠞ ꠢꠇꠟ ꠇꠥ-ꠇꠣꠝꠞ ꠟꠉꠦ ꠄꠅꠈꠣꠘꠅ ꠛꠣꠠꠣꠁꠟ, ꠢꠦ ꠘꠛꠤ ꠄꠢꠤꠀꠞꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK3_21","072_3_21","LUK","3","21","21","ꠄꠢꠤꠀ ꠘꠛꠤ ꠎꠦꠟꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠀꠉꠦ, ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠀ ꠎꠦꠛꠟꠣ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠅ ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠉꠥꠍꠟ ꠇꠞꠟꠣ। ꠉꠥꠍꠟꠞ ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠖꠥꠀ ꠇꠞꠞꠣ, ꠀꠈꠔꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠀꠞꠡꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠉꠦꠟ, ");
INSERT INTO syls_vpl VALUES ("LK3_22","072_3_22","LUK","3","22","22","ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠞꠅꠞ ꠍꠥꠞꠔ ꠗꠞꠤꠀ ꠔꠣꠘ ꠃꠙꠞꠦ ꠘꠣꠎꠤꠟ ꠅꠁꠟꠣ। ꠟꠉꠦ ꠟꠉꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠅꠃ ꠀꠅꠀꠎꠅ ꠢꠥꠘꠣ ꠉꠦꠟ, “ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK3_23","072_3_23","LUK","3","23","23","ꠅꠘꠥꠝꠣꠘ ꠔꠤꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠞ ꠇꠣꠟꠅ ꠁꠍꠣꠄ ꠔꠛꠟꠤꠉ ꠇꠣꠝ ꠡꠥꠞꠥ ꠇꠞꠟꠣ। ꠝꠣꠘꠡꠦ ꠎꠣꠘꠔꠣ ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ। ꠁꠃꠍꠥꠚꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK3_24","072_3_24","LUK","3","24","24","ꠀꠟꠤ, ꠝꠣꠔ꠆ꠕꠣꠔ, ꠟꠦꠛꠤ, ꠝꠣꠟꠇꠤ, ꠁꠀꠘ꠆ꠘꠣꠁ, ꠁꠃꠍꠥꠚ, ");
INSERT INTO syls_vpl VALUES ("LK3_25","072_3_25","LUK","3","25","25","ꠝꠣꠔ꠆ꠕꠣꠔꠤꠀ, ꠀꠝꠥꠎ, ꠘꠣꠃꠝ, ꠁꠍꠟꠤ, ꠘꠣꠉ꠆ꠉꠣꠁ, ");
INSERT INTO syls_vpl VALUES ("LK3_26","072_3_26","LUK","3","26","26","ꠝꠣꠢꠣꠔ, ꠝꠣꠔ꠆ꠕꠣꠔꠤꠀ, ꠡꠤꠝꠤꠅ, ꠁꠃꠡꠦꠈ, ꠁꠅꠖꠣ, ");
INSERT INTO syls_vpl VALUES ("LK3_27","072_3_27","LUK","3","27","27","ꠁꠃꠢꠣꠘ꠆ꠘꠣꠘ, ꠞꠤꠡꠣ, ꠎꠦꠞꠛꠣꠛꠤꠟ, ꠍꠣꠟꠔꠤꠄꠟ, ꠘꠤꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("LK3_28","072_3_28","LUK","3","28","28","ꠝꠣꠟꠇꠤ, ꠀꠖ꠆ꠖꠤ, ꠇꠣꠍꠣꠝ, ꠁꠟꠝꠣꠖꠣꠝ, ꠁꠄꠞ, ");
INSERT INTO syls_vpl VALUES ("LK3_29","072_3_29","LUK","3","29","29","ꠁꠃꠍꠣ, ꠄꠟꠤꠄꠎꠦꠞ, ꠁꠃꠞꠤꠝ, ꠝꠣꠔ꠆ꠕꠣꠔ, ꠟꠦꠛꠤ, ");
INSERT INTO syls_vpl VALUES ("LK3_30","072_3_30","LUK","3","30","30","ꠡꠤꠝꠤꠅꠘ, ꠄꠢꠥꠖꠣ, ꠁꠃꠍꠥꠚ, ꠁꠃꠘꠣꠘ, ꠁꠟꠤꠀꠇꠤꠝ, ");
INSERT INTO syls_vpl VALUES ("LK3_31","072_3_31","LUK","3","31","31","ꠝꠣꠟꠤꠀ, ꠝꠣꠘ꠆ꠘꠣ, ꠝꠣꠔ꠆ꠕꠣꠔꠣ, ꠘꠣꠕꠣꠘ, ꠖꠣꠃꠖ ꠘꠛꠤ, ");
INSERT INTO syls_vpl VALUES ("LK3_32","072_3_32","LUK","3","32","32","ꠁꠀꠍ, ꠃꠛꠣꠄꠖ, ꠛꠥꠀꠎ, ꠍꠦꠟꠤꠝ, ꠘꠣꠢꠤꠡ, ");
INSERT INTO syls_vpl VALUES ("LK3_33","072_3_33","LUK","3","33","33","ꠀꠝꠤꠘꠣꠖꠣꠛ, ꠀꠖꠝꠤꠘ, ꠀꠞꠘꠤ, ꠢꠣꠍꠤꠞ, ꠚꠤꠞꠥꠎ, ꠄꠢꠥꠖꠣ, ");
INSERT INTO syls_vpl VALUES ("LK3_34","072_3_34","LUK","3","34","34","ꠁꠀꠇꠥꠛ ꠘꠛꠤ, ꠁꠍꠢꠣꠇ ꠘꠛꠤ, ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤ, ꠔꠣꠞꠦꠈ, ꠘꠣꠢꠥꠞ, ");
INSERT INTO syls_vpl VALUES ("LK3_35","072_3_35","LUK","3","35","35","ꠍꠣꠞꠥꠎ, ꠞꠣꠃ, ꠚꠣꠟꠦꠎ, ꠀꠛꠦꠞ, ꠡꠣꠟꠦꠈ, ");
INSERT INTO syls_vpl VALUES ("LK3_36","072_3_36","LUK","3","36","36","ꠇꠤꠘꠣꠘ, ꠀꠞ꠆ꠚꠣꠇꠍꠣꠖ, ꠡꠣꠝ, ꠘꠥꠢ ꠘꠛꠤ, ꠟꠣꠝꠣꠇ, ");
INSERT INTO syls_vpl VALUES ("LK3_37","072_3_37","LUK","3","37","37","ꠝꠣꠔꠥꠡꠣꠟꠣꠈ, ꠁꠖ꠆ꠞꠤꠍ ꠘꠛꠤ, ꠁꠀꠞꠦꠖ, ꠝꠣꠢꠟꠣꠁꠟ, ꠇꠦꠘꠣꠘ, ");
INSERT INTO syls_vpl VALUES ("LK3_38","072_3_38","LUK","3","38","38","ꠁꠘꠥꠡ, ꠡꠤꠡ ꠘꠛꠤ, ꠀꠖꠝ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ। ");
INSERT INTO syls_vpl VALUES ("LK4_1","072_4_1","LUK","4","1","1","ꠁꠍꠣ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ, ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠅ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠦꠟꠣꠉꠤ। ꠉꠤꠀ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠁꠡꠣꠞꠣꠄ ꠄꠇꠟꠣꠉꠣ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠊꠥꠞꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_2","072_4_2","LUK","4","2","2","ꠀꠞ ꠁꠛꠟꠤꠍ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠌꠣꠟꠣꠁꠟ। ꠅꠃ ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠄꠇꠟꠣꠉꠣꠞꠦ ꠞꠥꠎꠣ ꠀꠍꠟꠣ, ꠇꠥꠘꠥꠎꠣꠔ ꠈꠣꠘꠣ ꠈꠣꠁꠍꠂꠘ ꠘꠣ। ꠄꠞꠛꠣꠖꠦ ꠔꠣꠘ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("LK4_3","072_4_3","LUK","4","3","3","ꠔꠦꠃ ꠁꠛꠟꠤꠍꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠅꠅ, ꠔꠦ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠇꠅ ꠘꠣ ꠞꠥꠐꠤ ꠅꠁꠎꠤꠔ।” ");
INSERT INTO syls_vpl VALUES ("LK4_4","072_4_4","LUK","4","4","4","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ꠈꠣꠟꠤ ꠞꠥꠐꠤ ꠈꠣꠁꠟꠦꠃ ꠝꠣꠘꠥꠡ ꠛꠣꠌꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK4_5","072_4_5","LUK","4","5","5","ꠛꠣꠖꠦ ꠁꠛꠟꠤꠍꠦ ꠔꠣꠘꠞꠦ ꠈꠥꠛ ꠃꠌꠣ ꠄꠇ ꠎꠣꠉꠣꠔ ꠟꠁꠀ ꠉꠦꠟ, ꠘꠤꠀ ꠢꠣꠞꠤ ꠄꠇ ꠙꠟꠇꠦ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠝꠥꠟ꠆ꠟꠥꠇ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠣꠁꠟ ꠀꠞ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("LK4_6","072_4_6","LUK","4","6","6","“ꠁ ꠔꠣꠝꠣꠝ ꠝꠥꠟ꠆ꠟꠥꠇꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠞ ꠎꠣꠇ-ꠎꠝꠇ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠝꠥ। ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠀꠝꠤ ꠎꠣꠞꠦ ꠈꠥꠡꠤ ꠔꠣꠞꠦ ꠖꠤꠔꠣꠝ ꠙꠣꠞꠤ; ");
INSERT INTO syls_vpl VALUES ("LK4_7","072_4_7","LUK","4","7","7","ꠈꠣꠟꠤ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠟꠣꠅ, ꠔꠦꠃ ꠁ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠥꠝꠣꠞ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK4_8","072_4_8","LUK","4","8","8","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠀꠙꠘ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠛꠣꠄ, ꠈꠣꠟꠤ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK4_9","072_4_9","LUK","4","9","9","ꠔꠦꠃ ꠢꠦ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟ, ꠉꠤꠀ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠝꠤꠘꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠘꠦ ꠃꠛꠣ ꠇꠞꠤꠀ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠅꠅ, ꠔꠦ ꠖꠦꠈꠤ ꠌꠣꠁꠘ, ꠅꠘ ꠕꠣꠇꠤ ꠚꠣꠟ ꠖꠤꠀ ꠟꠣꠝꠣꠔ ꠙꠠꠅ। ");
INSERT INTO syls_vpl VALUES ("LK4_10","072_4_10","LUK","4","10","10","ꠇꠤꠔꠣꠛꠅ ꠔ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ, ꠀꠞ ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_11","072_4_11","LUK","4","11","11","ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠀꠔꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠗꠞꠤꠟꠤꠛꠣ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠔ ꠇꠥꠘꠥ ꠙꠣꠔ꠆ꠔꠞꠞ ꠌꠥꠐ ꠘꠣ ꠟꠣꠉꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK4_12","072_4_12","LUK","4","12","12","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK4_13","072_4_13","LUK","4","13","13","ꠁꠛꠟꠤꠍꠦ ꠔꠣꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠡꠦꠡ ꠇꠞꠤꠀ, ꠀꠙꠣꠔꠔ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK4_14","072_4_14","LUK","4","14","14","ꠛꠣꠖꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠥꠖꠞꠔꠦ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠄꠟꠣꠇꠣꠔ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘ ꠘꠣꠝ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠞꠐꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK4_15","072_4_15","LUK","4","15","15","ꠔꠣꠁꠘ ꠢꠘꠞ ꠝꠍꠤꠖꠅ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠛꠄꠀꠘ-ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ, ꠔꠦꠃ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK4_16","072_4_16","LUK","4","16","16","ꠀꠞ ꠁꠍꠣ ꠢꠃ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠔ ꠀꠁꠟꠣ, ꠎꠦ ꠉꠣꠃꠔ ꠔꠣꠁꠘ ꠢꠥꠞꠥ ꠕꠣꠇꠤ ꠛꠠ ꠅꠁꠍꠂꠘ। ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠈꠥꠔꠛꠣ ꠙꠠꠣꠔ ꠃꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_17","072_4_17","LUK","4","17","17","ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠔꠣꠘ ꠀꠔꠅ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠔꠣꠁꠘ ꠇꠤꠔꠣꠛ ꠈꠥꠟꠤꠀ ꠅꠃ ꠀꠄꠀꠔ ꠛꠣꠞ ꠇꠞꠟꠣ, ꠎꠦ ꠀꠄꠀꠔꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LK4_18","072_4_18","LUK","4","18","18","ꠀꠝꠣꠞ ꠖꠤꠟꠅ ꠝꠣꠛꠥꠖꠞ ꠞꠥꠢꠥ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠀ ꠛꠦꠎꠤꠍꠂꠘ, ꠉꠞꠤꠛ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ। ꠀꠞ ꠛꠘ꠆ꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠎꠣꠖꠤꠞ ꠇꠕꠣ, ꠀꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠌꠃꠈꠦ ꠖꠦꠈꠣꠞ ꠇꠕꠣ, ꠎꠦꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠅꠞ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠇꠕꠣ ꠄꠟꠣꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠦꠎꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK4_19","072_4_19","LUK","4","19","19","ꠀꠞ ꠅꠃ ꠇꠕꠣ ꠄꠟꠣꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠛꠦꠎꠤꠍꠂꠘ, ꠅꠈꠘ ꠝꠣꠛꠥꠖꠞ ꠞꠢꠝꠔ ꠖꠦꠈꠣꠘꠤꠞ ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK4_20","072_4_20","LUK","4","20","20","ꠈꠥꠔꠛꠣ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠁꠘ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠀꠐꠣꠁꠀ ꠝꠍꠤꠖꠞ ꠝꠔꠟ꠆ꠟꠤꠞ ꠀꠔꠅ ꠖꠤꠀ ꠛꠁꠟꠣ, ꠝꠍꠤꠖꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠛꠣꠄ ꠗꠤꠀꠘ ꠗꠞꠤ ꠌꠣꠁ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK4_21","072_4_21","LUK","4","21","21","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠞ ꠁ ꠀꠄꠀꠔ ꠈꠣꠘꠣꠁꠘ, ꠀꠁꠎ ꠀꠙꠘꠣꠞꠣ ꠢꠥꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠚꠟꠤꠉꠦꠟ।” ");
INSERT INTO syls_vpl VALUES ("LK4_22","072_4_22","LUK","4","22","22","ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠟ, ꠔꠣꠘ ꠝꠥꠈ ꠕꠣꠇꠤ ꠅꠔ ꠡꠥꠘ꠆ꠖꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟ। ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠄꠁꠘ ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠘꠣꠄ ꠘꠤ ꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("LK4_23","072_4_23","LUK","4","23","23","ꠄꠞꠝꠣꠎꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠘꠤꠌꠄ ꠀꠝꠣꠞꠦ ꠅꠃ ꠍꠤꠟ꠆ꠟꠦꠈ ꠢꠥꠘꠣꠁꠛꠣ, ‘ꠒꠣꠇ꠆ꠔꠞ ꠍꠣꠛ, ꠘꠤꠎꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠅ। ꠇꠚꠞꠘꠣꠃꠝꠅ ꠛꠥꠟꠦ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ-ꠝꠥꠎꠦꠎꠣ ꠖꠦꠈꠣꠁꠍ, ꠔꠦ ꠅꠈꠘ ꠘꠤꠎꠞ ꠉꠣꠃꠔꠅ ꠅꠔꠣ ꠖꠦꠈꠣꠅ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("LK4_24","072_4_24","LUK","4","24","24","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠇꠥꠘꠥ ꠘꠛꠤꠞꠦꠃ ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠣꠃꠞ ꠝꠣꠘꠡꠦ ꠝꠣꠘꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_25","072_4_25","LUK","4","25","25","ꠀꠞ ꠁꠈꠣꠘꠅ ꠢꠣꠍꠣ ꠇꠕꠣ, ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞ ꠎꠝꠣꠘꠣꠔ ꠄꠇꠟꠣꠉꠣ ꠡꠣꠠꠦ ꠔꠤꠘ ꠛꠍꠞ ꠇꠥꠘꠥ ꠝꠦꠊ ꠅꠁꠍꠤꠟ ꠘꠣ, ꠀꠡ꠆ꠔꠣ ꠖꠦꠡꠅ ꠛꠦꠎꠥꠁꠔꠣ ꠘꠤꠖꠣꠘ ꠀꠍꠤꠟ। ꠢꠃ ꠡꠝꠄ ꠔ ꠁꠍꠞꠣꠁꠟ ꠖꠦꠡꠅ ꠛꠃꠔ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ ꠀꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK4_26","072_4_26","LUK","4","26","26","ꠅꠁꠟꠦ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞꠦ ꠄꠞꠣ ꠇꠦꠃꠞꠞ ꠉꠦꠍꠦ ꠘꠣ ꠛꠦꠎꠤꠀ, ꠈꠣꠟꠤ ꠍꠤꠖꠘ ꠖꠦꠡꠞ ꠍꠣꠞꠤꠚꠔ ꠉꠣꠃꠞ ꠄꠇ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠞ ꠉꠦꠍꠦ ꠛꠦꠎꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK4_27","072_4_27","LUK","4","27","27","ꠀꠞ ꠀꠟꠤꠀꠡꠣ ꠘꠛꠤꠞ ꠀꠝꠟꠅ ꠁꠍꠞꠣꠁꠟ ꠖꠦꠡꠅ ꠛꠃꠔ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤ ꠀꠍꠟꠣ, ꠅꠁꠟꠦ ꠄꠞꠣ ꠇꠦꠃꠞꠞꠦ ꠜꠣꠟꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠈꠣꠟꠤ ꠡꠤꠞꠤꠀ ꠖꠦꠡꠞ ꠘꠣꠝꠣꠘꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("LK4_28","072_4_28","LUK","4","28","28","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠝꠍꠤꠖꠞ ꠡꠛ ꠝꠣꠘꠥꠡ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_29","072_4_29","LUK","4","29","29","ꠔꠣꠞꠣ ꠃꠑꠤꠀ ꠔꠣꠘꠞꠦ ꠑꠦꠟꠤꠀ ꠈꠦꠖꠣꠁꠀ ꠉꠣꠃꠞ ꠛꠣꠞꠦ ꠟꠁꠀ ꠉꠦꠟ, ꠉꠤꠀ ꠉꠣꠃꠞ ꠇꠥꠘꠣꠞ ꠈꠣꠠꠣ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠘꠤꠀ, ꠗꠣꠇ꠆ꠇꠣꠖꠤ ꠔꠟꠦ ꠚꠣꠟꠣꠁꠔ ꠌꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK4_30","072_4_30","LUK","4","30","30","ꠅꠁꠟꠦ ꠜꠤꠠꠞ ꠝꠣꠎ ꠕꠘꠦ ꠔꠣꠁꠘ ꠀꠐꠤꠀ ꠢꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK4_31","072_4_31","LUK","4","31","31","ꠛꠣꠖꠦ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠄꠟꠣꠇꠣꠞ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠝꠣꠘꠡꠞꠦ ꠅꠀꠎ-ꠘꠍꠤꠅꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_32","072_4_32","LUK","4","32","32","ꠔꠣꠘ ꠅꠀꠎ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ, ꠔꠣꠁꠘ ꠔ ꠙꠥꠞꠣ ꠢꠤꠝ꠆ꠝꠔ ꠀꠟꠣ ꠎꠘꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_33","072_4_33","LUK","4","33","33","ꠢꠃ ꠝꠍꠤꠖꠅ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠟꠣ ꠄꠇ ꠛꠦꠐꠣ ꠀꠍꠤꠟ। ꠢꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("LK4_34","072_4_34","LUK","4","34","34","“ꠅ ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣ, ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠦꠘꠦ ꠀꠁꠍꠂꠘ? ꠀꠝꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠔ ꠀꠁꠍꠂꠘ ꠘꠤ? ꠀꠝꠤ ꠎꠣꠘꠤ ꠀꠙꠘꠦ ꠇꠦ, ꠀꠙꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠢꠃ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK4_35","072_4_35","LUK","4","35","35","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠌꠥꠙ, ꠄꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁ ꠎꠣ।” ꠎꠤꠘꠦ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞꠦ ꠀꠍꠣꠠ ꠝꠣꠞꠤ ꠢꠇꠟꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠚꠣꠟꠣꠁꠀ, ꠇꠥꠘꠥꠎꠣꠔ ꠈꠦꠔꠤ ꠘꠣ ꠇꠞꠤꠀ ꠍꠣꠠꠤꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK4_36","072_4_36","LUK","4","36","36","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠀ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠟꠣꠉꠣꠁꠟꠣ, “ꠁꠔꠣ ꠇꠤꠔꠣ ꠖꠦꠈꠟꠣꠝ? ꠔꠣꠁꠘ ꠢꠤꠝ꠆ꠝꠔ ꠀꠞ ꠈꠦꠝꠔꠣ ꠈꠣꠐꠣꠁꠀ ꠎꠤꠘ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠁꠘ, ꠔꠣꠞꠣꠅ ꠖꠦꠈꠤ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠄꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK4_37","072_4_37","LUK","4","37","37","ꠛꠣꠖꠦ ꠢꠤꠘꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠉꠣꠔ ꠁꠍꠣꠞ ꠇꠦꠞꠣꠝꠔꠤꠞ ꠈꠛꠞ ꠞꠐꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK4_38","072_4_38","LUK","4","38","38","ꠝꠍꠤꠖ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠔꠣꠁꠘ ꠍꠣꠁꠝꠘꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ। ꠍꠣꠁꠝꠘꠞ ꠢꠠꠤꠞ ꠈꠥꠛ ꠛꠦꠡꠤ ꠔꠣꠙ ꠃꠑꠍꠤꠟ, ꠄꠞꠖꠣꠄ ꠢꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠈꠥꠛ ꠝꠤꠘꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_39","072_4_39","LUK","4","39","39","ꠔꠣꠁꠘ ꠍꠣꠁꠝꠘꠞ ꠢꠠꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠃꠛꠣꠁꠀ ꠔꠣꠙꠞꠦ ꠗꠝꠇ ꠖꠤꠟꠣ। ꠗꠝꠇꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠙꠦ ꠍꠣꠠꠤꠖꠤꠟ। ꠛꠦꠐꠤꠄ ꠃꠑꠤꠀ ꠔꠣꠞꠣꠞ ꠝꠦꠝꠣꠘꠖꠣꠞꠤꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_40","072_4_40","LUK","4","40","40","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠝꠣꠘꠡꠦ ꠛꠃꠔ ꠎꠣꠔꠞ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠟꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠁꠍꠣꠄ ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠉꠔꠞꠅ ꠀꠔꠣꠁ ꠖꠤꠀ ꠛꠦꠝꠣꠞ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK4_41","072_4_41","LUK","4","41","41","ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠟꠣꠅ ꠛꠃꠔ ꠛꠦꠝꠣꠞꠤ ꠀꠍꠟꠣ, ꠔꠣꠞꠣꠅ ꠜꠣꠟꠣ ꠅꠁꠟꠣ। ꠎꠤꠘ ꠅꠇꠟꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦꠃ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ।” ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠀ ꠝꠥꠈ ꠛꠘ꠆ꠖ ꠇꠞꠟꠣ। ꠔꠣꠞꠣꠞ ꠔ ꠎꠣꠘꠣ ꠀꠍꠤꠟ, ꠔꠣꠁꠘꠃ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LK4_42","072_4_42","LUK","4","42","42","ꠛꠤꠀꠘꠦ ꠃꠑꠤꠀ ꠢꠣꠞꠤ, ꠁꠍꠣ ꠢꠤ ꠉꠣꠃ ꠍꠣꠠꠤꠀ ꠄꠇ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠀꠁꠟꠣ। ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠔꠥꠇꠣꠁ ꠔꠥꠇꠣꠁ ꠔꠣꠘ ꠗꠣꠞꠅ ꠀꠁꠟ, ꠀꠁꠀ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠟ ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK4_43","072_4_43","LUK","4","43","43","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠀꠞꠅ ꠛꠃꠔ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠅꠃ ꠇꠣꠝꠞ ꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK4_44","072_4_44","LUK","4","44","44","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠡ꠆ꠔꠣ ꠁꠢꠥꠖꠤ ꠖꠦꠡꠞ ꠝꠍꠤꠖꠣꠁꠘ꠆ꠔꠅ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_1","072_5_1","LUK","5","1","1","ꠄꠇ ꠖꠤꠘ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠙꠣꠞꠅ ꠃꠛꠣ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠑꠦꠟꠣꠑꠦꠟꠤ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_2","072_5_2","LUK","5","2","2","ꠁꠍꠣꠄ ꠖꠦꠈꠟꠣ, ꠀꠅꠞꠞ ꠇꠤꠘꠣꠞꠅ ꠖꠥꠈꠣꠘ ꠎꠣꠟꠥꠀ ꠘꠣꠅ ꠟꠣꠉꠣꠁꠟ। ꠘꠣꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠎꠣꠟꠥꠀ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠎꠣꠟ ꠗꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_3","072_5_3","LUK","5","3","3","ꠁꠍꠣ ꠉꠤꠀ ꠍꠣꠁꠝꠘ ꠘꠣꠝꠞ ꠄꠇ ꠎꠣꠟꠥꠀꠞ ꠘꠣꠅꠅ ꠃꠑꠤꠀ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, ꠘꠣꠅꠈꠣꠘ ꠜꠣꠡꠣꠁꠀ ꠇꠤꠍꠥ ꠙꠣꠘꠤꠔ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ। ꠇꠁꠀ ꠔꠣꠁꠘ ꠘꠣꠅꠅ ꠛꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠅꠀꠎ-ꠘꠍꠤꠅꠔ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_4","072_5_4","LUK","5","4","4","ꠘꠍꠤꠅꠔ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠣꠟꠥꠀ ꠍꠣꠁꠝꠘꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣꠅꠈꠣꠘ ꠉꠁꠘ ꠙꠣꠘꠤꠔ ꠘꠦꠅ ꠀꠞ ꠎꠣꠟ ꠚꠣꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK5_5","072_5_5","LUK","5","5","5","ꠍꠣꠁꠝꠘꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠡ꠆ꠔꠣ ꠞꠣꠁꠔ ꠇꠡ꠆ꠐ ꠇꠞꠤꠀꠅ ꠇꠥꠘꠥ ꠝꠣꠍ ꠙꠣꠁꠍꠤ ꠘꠣ, ꠔꠣ-ꠅ ꠀꠙꠘꠣꠞ ꠇꠕꠣꠄ ꠎꠣꠟ ꠚꠣꠟꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK5_6","072_5_6","LUK","5","6","6","ꠎꠣꠟ ꠚꠣꠟꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠅꠔ ꠛꠦꠡꠤ ꠝꠣꠍ ꠎꠣꠟꠅ ꠢꠣꠝꠣꠁꠟꠣ, ꠝꠣꠍꠞ ꠑꠦꠟꠣꠄ ꠎꠣꠟ ꠚꠣꠞꠤꠎꠤꠛꠣꠞ ꠖꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_7","072_5_7","LUK","5","7","7","ꠅꠃ ꠔꠣꠞꠣ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ ꠟꠉꠞ ꠘꠣꠅꠞ ꠎꠣꠟꠥꠀꠞꠦ ꠒꠣꠇ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠀꠁꠀ ꠝꠣꠍ ꠗꠞꠤꠀ ꠘꠣꠅ ꠜꠞꠤꠟꠤꠟꠣ, ꠎꠣꠟꠅ ꠅꠔ ꠝꠣꠍ ꠢꠣꠝꠣꠁꠍꠤꠟ ꠎꠦꠘ, ꠝꠣꠍꠞ ꠜꠣꠞꠦ ꠖꠥꠁꠅ ꠘꠣꠅ ꠒꠥꠛꠥꠒꠥꠛꠥ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK5_8","072_5_8","LUK","5","8","8","ꠁꠔꠣ ꠖꠦꠈꠤꠀ, ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠁꠍꠣꠞ ꠙꠣꠅ-ꠅ ꠙꠠꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠔ ꠉꠥꠘꠣꠉꠣꠞ ꠝꠣꠘꠥꠡ, ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠡꠞꠤꠚ ꠈꠣꠘ ꠘꠦꠃꠇ꠆ꠇꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK5_9","072_5_9","LUK","5","9","9","ꠇꠣꠞꠘ, ꠅꠔ ꠝꠣꠍ ꠖꠦꠈꠤꠀ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇ꠆ꠇꠟꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_10","072_5_10","LUK","5","10","10","ꠍꠣꠁꠝꠘꠞ ꠟꠉꠞ ꠎꠣꠟꠥꠀ ꠎꠤꠛꠥꠖꠤꠀꠞ ꠖꠥꠁꠅ ꠙꠥꠀ ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠦꠅ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠟꠣ। ꠔꠦꠃ ꠁꠍꠣꠄ ꠍꠣꠁꠝꠘꠞꠦ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠀꠞ ꠝꠣꠍ ꠘꠣꠄ, ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠝꠣꠘꠥꠡ ꠗꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK5_11","072_5_11","LUK","5","11","11","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠘꠣꠅ ꠟꠁꠀ ꠇꠤꠘꠣꠞꠣꠔ ꠀꠁꠟꠣ, ꠀꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠕꠁꠀ ꠁꠍꠣꠞ ꠟꠉꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_12","072_5_12","LUK","5","12","12","ꠄꠇꠛꠣꠞ ꠁꠍꠣ ꠄꠇ ꠉꠣꠃꠔ ꠉꠦꠟꠣ। ꠢꠃ ꠉꠣꠃꠞ ꠄꠇ ꠛꠦꠐꠣꠞ ꠀꠡ꠆ꠔꠣ ꠉꠔꠞ ꠎꠥꠠꠤ ꠘꠣꠙꠣꠇ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞ ꠀꠍꠤꠟ। ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠢꠦ ꠔꠣꠘ ꠙꠣꠅ-ꠅ ꠙꠠꠤꠀ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠟꠣꠉꠣꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠝꠘꠦ ꠌꠣꠁꠟꠦ ꠔ ꠀꠝꠣꠞꠦ ꠅꠃ ꠘꠣꠙꠣꠇ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK5_13","072_5_13","LUK","5","13","13","ꠁꠍꠣꠄ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠔꠣꠞꠦ ꠍꠁꠀ ꠇꠁꠟꠣ, “ꠅꠄ, ꠀꠝꠤꠅ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠅ।” ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞ ꠛꠦꠝꠣꠞ ꠇꠝꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK5_14","072_5_14","LUK","5","14","14","ꠜꠣꠟꠣ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠁꠔꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ, ꠔꠥꠝꠤ ꠉꠤꠀ ꠈꠣꠟꠤ ꠁꠝꠣꠝ ꠍꠣꠛꠞꠦ ꠖꠦꠈꠣꠅ। ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠦꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠦꠃ ꠝꠣꠘꠡꠦ ꠎꠣꠘꠤꠟꠤꠛꠣ, ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠅꠁꠍ।” ");
INSERT INTO syls_vpl VALUES ("LK5_15","072_5_15","LUK","5","15","15","ꠅꠁꠟꠦ ꠁꠍꠣꠞ ꠈꠛꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠞꠐꠤꠉꠦꠟ। ꠄꠞꠖꠣꠄ ꠔꠣꠘ ꠝꠥꠈꠞ ꠛꠥꠟꠤ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟ ꠜꠣꠟꠣ ꠅꠀꠞ ꠘꠤꠅꠔꠦ, ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_16","072_5_16","LUK","5","16","16","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠘꠣ ꠇꠥꠘꠥ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠢꠣꠝꠦꠡꠣ ꠖꠥꠀ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_17","072_5_17","LUK","5","17","17","ꠄꠇꠖꠤꠘ ꠁꠍꠣ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ, ꠅꠃ ꠝꠎꠟꠤꠍꠅ ꠀꠟꠤꠝ ꠅꠇꠟ ꠀꠞ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠛꠃꠔ ꠝꠥꠟ꠆ꠟꠣꠁꠘ ꠛꠅꠀꠔ ꠀꠍꠟꠣ। ꠔꠣꠞꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ, ꠉꠣꠟꠤꠟ ꠀꠞ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠘꠣꠘꠣꠘ ꠉꠣꠃꠀꠁꠘ ꠕꠣꠇꠤ ꠀꠁꠍꠂꠘ। ꠁꠍꠣꠞ ꠝꠣꠎꠦ ꠝꠣꠛꠥꠖꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟ ꠀꠍꠤꠟ, ꠅꠃ ꠛꠟꠦꠃ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_18","072_5_18","LUK","5","18","18","ꠄꠞꠝꠣꠎꠦ ꠇꠄꠎꠘ ꠝꠣꠘꠡꠦ ꠄꠇꠎꠘ ꠅꠛꠡ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠙꠟꠅꠖꠤ ꠛꠁꠀ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠔꠣꠞꠣ ꠌꠣꠁꠟꠣ ꠔꠣꠞꠦ ꠘꠤꠀ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠁꠍꠣꠞ ꠍꠣꠝꠘꠦ ꠕꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_19","072_5_19","LUK","5","19","19","ꠅꠁꠟꠦ ꠜꠤꠠꠞ ꠟꠣꠉꠤ ꠊꠞꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠙꠕ ꠙꠣꠁꠟꠣ ꠘꠣ। ꠅꠃ ꠔꠣꠞꠣ ꠌꠣꠟꠞ ꠃꠙꠞꠦ ꠃꠑꠤꠀ, ꠌꠣꠟꠞ ꠍꠣꠘꠤ ꠈꠥꠟꠤꠀ ꠙꠟꠅ ꠡꠥꠖ꠆ꠖꠣ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠁꠍꠣꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠟꠣꠝꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_20","072_5_20","LUK","5","20","20","ꠔꠣꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠟ ꠖꠦꠈꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠜꠣꠁꠞꠦ, ꠔꠥꠝꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK5_21","072_5_21","LUK","5","21","21","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠀꠟꠤꠝ ꠅꠇꠟꠦ ꠀꠞ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠝꠥꠟ꠆ꠟꠣꠁꠘ꠆ꠔꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, “ꠁ ꠝꠣꠘꠥꠡꠉꠥ ꠇꠦꠉꠥ, ꠢꠦ ꠅꠟꠣ ꠡꠤꠞꠤꠇꠤ ꠇꠞꠦꠞ? ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK5_22","072_5_22","LUK","5","22","22","ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠌꠤꠘ꠆ꠔꠣ ꠁꠍꠣꠄ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠛꠥꠎꠤꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠇꠦꠘꠦ ꠁꠟꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠣ? ");
INSERT INTO syls_vpl VALUES ("LK5_23","072_5_23","LUK","5","23","23","ꠀꠝꠤ ꠇꠥꠘꠈꠣꠘ ꠇꠅꠀ ꠡꠥꠎꠣ, ꠔꠥꠝꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠝ? ꠛꠣ ꠔꠥꠝꠤ ꠃꠑꠤꠀ ꠀꠐꠤꠀ ꠔꠥꠝꠣꠞ ꠛꠤꠍꠘꠣ ꠟꠁꠀ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ? ꠇꠥꠘꠈꠣꠘ ꠡꠥꠎꠣ? ");
INSERT INTO syls_vpl VALUES ("LK5_24","072_5_24","LUK","5","24","24","ꠔꠦ ꠅꠈꠘ ꠀꠙꠘꠣꠞꠣ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁ ꠖꠥꠘꠤꠀꠔ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠈꠦꠝꠔꠣ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠀꠍꠦ।” ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠃꠑꠅ, ꠔꠥꠝꠣꠞ ꠈꠦꠔꠣ-ꠛꠣꠟꠤꠡ ꠟꠁꠀ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK5_25","072_5_25","LUK","5","25","25","ꠇꠁꠔꠦꠃ ꠢꠤ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠀ, ꠔꠣꠞ ꠈꠦꠔꠣ-ꠛꠣꠟꠤꠡ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤ ꠇꠞꠤ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK5_26","072_5_26","LUK","5","26","26","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤ ꠒꠞꠣꠁ ꠒꠞꠣꠁ ꠇꠁꠟꠣ, “ꠀꠁꠎ ꠁꠔꠣ ꠇꠤꠎꠣꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK5_27","072_5_27","LUK","5","27","27","ꠛꠣꠖꠦ ꠁꠍꠣ ꠛꠣꠞꠦ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠔꠡꠤꠟ ꠅꠚꠤꠡꠅ ꠟꠦꠛꠤ ꠘꠣꠝꠞ ꠄꠇ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣꠞꠦ ꠛꠅꠀꠔ ꠖꠦꠈꠟꠣ। ꠖꠦꠈꠤꠀ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK5_28","072_5_28","LUK","5","28","28","ꠖꠣꠅꠔ ꠢꠥꠘꠤꠀꠃ ꠟꠦꠛꠤꠄ ꠔꠣꠘ ꠢꠇꠟꠔꠣ ꠚꠣꠟꠣꠁꠀ ꠁꠍꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_29","072_5_29","LUK","5","29","29","ꠛꠣꠖꠦ ꠟꠦꠛꠤꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠁꠍꠣꠞ ꠟꠣꠉꠤ ꠛꠠ ꠄꠇ ꠈꠣꠅꠀ-ꠖꠣꠅꠀꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠟꠣ। ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠃꠔ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠀꠞ ꠀꠞꠅ ꠝꠣꠘꠥꠡ ꠈꠣꠅꠀꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK5_30","072_5_30","LUK","5","30","30","ꠔꠦꠃ ꠚꠞꠤꠡꠤ ꠀꠞ ꠔꠣꠞꠣꠞ ꠖꠟꠞ ꠀꠟꠤꠝ ꠅꠇꠟꠦ ꠘꠣ-ꠈꠥꠡ ꠅꠁꠀ ꠁꠍꠣꠞ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠐꠉꠛꠣꠎ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠛꠣꠠꠤꠔ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠅ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK5_31","072_5_31","LUK","5","31","31","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠜꠣꠟꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠔ ꠒꠣꠇ꠆ꠔꠞꠞ ꠎꠞꠥꠞ ꠘꠣꠁ, ꠅꠁꠟꠦ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠎꠞꠥꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK5_32","072_5_32","LUK","5","32","32","ꠔꠦ ꠀꠝꠤꠅ ꠙꠞꠦꠎꠉꠣꠞ ꠅꠇꠟꠞꠦ ꠖꠣꠅꠔ ꠖꠦꠅꠀꠔ ꠀꠁꠍꠤ ꠘꠣ, ꠈꠣꠟꠤ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞꠦ ꠖꠣꠅꠔ ꠖꠦꠅꠀꠔ ꠀꠁꠍꠤ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK5_33","072_5_33","LUK","5","33","33","ꠛꠣꠖꠦ ꠢꠃ ꠀꠟꠤꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠄꠢꠤꠀꠞ ꠡꠤꠡꠤꠅ ꠅꠇꠟꠦ ꠢꠣꠝꠦꠡꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠂꠘ, ꠖꠥꠀ ꠇꠞꠂꠘ, ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠡꠤꠡꠤꠅ ꠅꠇꠟꠦꠅ ꠅꠟꠣ ꠇꠞꠂꠘ, ꠔꠦ ꠀꠙꠘꠣꠞ ꠡꠤꠡꠤꠅ ꠅꠇꠟꠦ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠈꠣꠘꠤ ꠛꠣꠖ ꠖꠦꠁꠘ ꠘꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK5_34","072_5_34","LUK","5","34","34","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠘꠡꠣ ꠟꠉꠦ ꠕꠣꠇꠟꠦ ꠟꠉꠞ ꠛꠂꠞꠣꠔꠤꠞꠦ ꠇꠥꠘꠥ ꠃꠙꠣꠡ ꠞꠣꠈꠣ ꠎꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK5_35","072_5_35","LUK","5","35","35","ꠅꠁꠟꠦ ꠅꠝꠘ ꠄꠇ ꠖꠤꠘ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠘꠡꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠘꠦꠅꠀ ꠅꠁꠎꠤꠛ। ꠢꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK5_36","072_5_36","LUK","5","36","36","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠝꠤꠍꠣꠟ ꠢꠥꠘꠣꠁꠟꠣ, ꠇꠁꠟꠣ, “ꠘꠄꠀ ꠇꠥꠞ꠆ꠔꠣꠞ ꠐꠥꠇꠞꠣ ꠍꠤꠠꠤꠀ, ꠇꠦꠃ ꠙꠥꠞꠣꠘ ꠇꠥꠞ꠆ꠔꠣꠔ ꠔꠣꠟꠤ ꠖꠦꠄ ꠘꠣ। ꠁꠟꠣ ꠇꠞꠟꠦ ꠔ ꠘꠄꠀꠐꠣꠅ ꠘꠡ꠆ꠐ ꠅꠁꠛ, ꠀꠞ ꠘꠄꠀ ꠇꠣꠙꠠꠞ ꠔꠣꠟꠤ ꠔ ꠙꠥꠞꠣꠘ ꠇꠣꠙꠠꠞ ꠟꠉꠦ ꠝꠤꠟꠔ-ꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK5_37","072_5_37","LUK","5","37","37","ꠙꠥꠞꠣꠘ ꠌꠣꠝꠠꠣꠞ ꠕꠟꠤꠔ ꠇꠦꠃ ꠔꠣꠎꠣ ꠀꠋꠉꠥꠞꠞ ꠞꠡ ꠜꠞꠦ ꠘꠣ। ꠜꠞꠟꠦ ꠅꠃ ꠔꠣꠎꠣ ꠞꠡꠞ ꠚꠣꠚꠦ ꠕꠟꠤ ꠚꠣꠐꠤꠀ ꠞꠡ ꠀꠞ ꠕꠟꠤ ꠖꠥꠁꠅꠔꠣ ꠛꠞꠛꠣꠖ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LK5_38","072_5_38","LUK","5","38","38","ꠔꠣꠎꠣ ꠞꠡ ꠘꠄꠀ ꠕꠟꠤꠔ ꠕꠁꠔꠦ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LK5_39","072_5_39","LUK","5","39","39","ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠙꠥꠞꠣꠘ ꠞꠡ ꠈꠣꠁꠀ ꠢꠣꠞꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠘꠄꠀ ꠞꠡ ꠈꠣꠁꠔ ꠌꠣꠄ ꠘꠣ। ꠔꠣꠞꠣ ꠇꠂꠘ, ꠙꠥꠞꠣꠘꠔꠣꠃ ꠝꠎꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK6_1","072_6_1","LUK","6","1","1","ꠄꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠁꠍꠣ ꠉꠝ ꠈꠦꠔꠞ ꠀꠁꠟꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠉꠝꠞ ꠍꠠꠣ ꠍꠤꠠꠤꠀ ꠀꠔꠅ ꠊꠡꠤ ꠊꠡꠤ ꠈꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_2","072_6_2","LUK","6","2","2","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠇꠄꠎꠘꠦ ꠇꠁꠟꠣ, “ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠔ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠎꠦꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠣ ꠢꠣꠞꠣꠝ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠁ ꠍꠠꠣ ꠍꠤꠠꠤꠞꠣꠄ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK6_3","072_6_3","LUK","6","3","3","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠦ ꠖꠣꠃꠖ ꠘꠛꠤ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠞ ꠎꠦꠛꠟꠣ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠍꠤꠟ, ꠢꠤ ꠡꠝꠄ ꠔꠣꠞꠣ ꠇꠤꠔꠣ ꠇꠞꠍꠟꠣ, ꠁꠔꠣ ꠀꠙꠘꠣꠞꠣ ꠙꠠꠍꠂꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK6_4","072_6_4","LUK","6","4","4","ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ ꠈꠣꠁꠍꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠅꠇꠟꠞꠦꠅ ꠈꠣꠅꠀꠁꠍꠟꠣ। ꠀꠍꠟꠦ ꠈꠣꠟꠤ ꠁꠝꠣꠝ ꠅꠇꠟ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠁ ꠞꠥꠐꠤ ꠈꠣꠅꠀ ꠎꠣꠁꠎ ꠀꠍꠤꠟ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK6_5","072_6_5","LUK","6","5","5","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠃ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠝꠣꠟꠤꠇ।” ");
INSERT INTO syls_vpl VALUES ("LK6_6","072_6_6","LUK","6","6","6","ꠀꠞꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠁꠍꠣ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠅꠀꠎ-ꠘꠍꠤꠅꠔ ꠇꠞꠣꠔ ꠀꠍꠟꠣ। ꠢꠘꠅ ꠄꠇ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣ ꠀꠍꠤꠟ, ꠔꠣꠞ ꠒꠣꠁꠘꠞ ꠀꠔ ꠛꠦꠝꠣꠞꠦ ꠢꠥꠇꠣꠁ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK6_7","072_6_7","LUK","6","7","7","ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞꠦ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠁꠔꠣ ꠇꠞꠤ ꠜꠣꠘꠣ ꠔꠥꠇꠣꠘꠤꠔ ꠀꠍꠟꠣ। ꠔꠣꠞꠣ ꠖꠦꠈꠔꠣ ꠌꠣꠁꠟꠣ, ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠔꠣꠁꠘ ꠇꠦꠃꠞꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠂꠘ ꠘꠤ, ꠇꠞꠟꠦ ꠔꠣꠘꠞꠦ ꠖꠥꠡꠤ ꠛꠣꠘꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_8","072_6_8","LUK","6","8","8","ꠁꠍꠣꠄꠅ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠇꠥ-ꠝꠔꠟꠛ ꠛꠥꠎꠤꠟꠤꠟꠣ। ꠛꠥꠎꠤꠀ ꠔꠣꠁꠘ ꠢꠥꠇꠘꠣ ꠀꠔꠀꠟꠣ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠤ ꠀꠁꠀ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠅ ꠌꠣꠁꠘ।” ꠔꠦꠃ ꠛꠦꠐꠣ ꠀꠁꠀ ꠃꠛꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK6_9","072_6_9","LUK","6","9","9","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠄꠇꠈꠣꠘ ꠇꠕꠣ ꠎꠤꠇꠣꠁꠞꠣꠝ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠇꠥꠘ ꠇꠣꠝ ꠇꠞꠣ ꠎꠣꠁꠎ, ꠜꠣꠟꠣ ꠇꠣꠝ ꠘꠣ ꠛꠣꠖ ꠇꠣꠝ? ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤ, ꠘꠣ ꠎꠣꠘꠞ ꠛꠤꠘꠣꠡ ꠇꠞꠣ?” ");
INSERT INTO syls_vpl VALUES ("LK6_10","072_6_10","LUK","6","10","10","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠢꠇꠟꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠢꠃ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠔꠈꠣꠘ ꠛꠣꠠꠣꠅ।” ꠛꠦꠐꠣꠄ ꠔꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠁꠟ, ꠀꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK6_11","072_6_11","LUK","6","11","11","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠃ ꠝꠥꠟ꠆ꠟꠣ ꠅꠇꠟꠞ ꠈꠥꠛ ꠉꠥꠍꠣ ꠃꠑꠟ। ꠔꠣꠞꠣ ꠙꠞꠣꠝꠤꠡ ꠌꠣꠟꠣꠁꠟꠣ, ꠁꠍꠣꠞꠦ ꠇꠦꠝꠘꠦ ꠕꠣꠝꠣꠁꠟ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_12","072_6_12","LUK","6","12","12","ꠛꠣꠖꠦ ꠁꠍꠣ ꠖꠥꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇ ꠙꠣꠠꠅ ꠃꠑꠤꠟꠣ, ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠞꠣꠁꠔ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠖꠥꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_13","072_6_13","LUK","6","13","13","ꠛꠤꠀꠘꠤ ꠛꠣꠟꠣ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠘꠟꠣ, ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠣꠞꠅ ꠎꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ, ꠔꠣꠘ ꠈꠣꠍ ꠍꠣꠢꠣꠛꠤ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_14","072_6_14","LUK","6","14","14","ꠅꠃ ꠛꠣꠞꠅꠎꠘ ꠅꠁꠟꠣ, ꠍꠣꠁꠝꠘ—ꠁꠍꠣꠄ ꠄꠘ ꠘꠄꠀ ꠘꠣꠝ ꠖꠤꠟꠣ ꠙꠤꠔꠞ, ꠍꠣꠁꠝꠘꠞ ꠜꠣꠁ ꠀꠘ꠆ꠖꠞꠤꠀꠍ, ꠁꠀꠇꠥꠛ, ꠢꠣꠘ꠆ꠘꠣꠘ, ꠚꠤꠟꠤꠚ, ꠛꠞ꠆ꠕꠟꠝꠄ, ");
INSERT INTO syls_vpl VALUES ("LK6_15","072_6_15","LUK","6","15","15","ꠝꠕꠤ, ꠕꠥꠝꠣꠍ, ꠀꠟꠚꠤꠞ ꠙꠥꠀ ꠁꠀꠇꠥꠛ, ꠝꠥꠇ꠆ꠔꠤꠎꠥꠖ꠆ꠖꠣ ꠍꠣꠁꠝꠘ, ");
INSERT INTO syls_vpl VALUES ("LK6_16","072_6_16","LUK","6","16","16","ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠁꠢꠥꠖꠣ, ꠀꠞ ꠁꠢꠥꠖꠣ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔ—ꠅꠃ ꠁꠢꠥꠖꠣꠄ ꠛꠣꠖꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK6_17","072_6_17","LUK","6","17","17","ꠄꠞꠝꠣꠎꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠙꠣꠠꠞ ꠙꠦꠐꠅ ꠢꠝꠣꠘ ꠄꠇ ꠎꠣꠉꠣꠔ ꠀꠁꠀ ꠃꠛꠣꠁꠟꠣ। ꠢꠤꠘꠅ ꠔꠣꠘ ꠛꠃꠔ ꠃꠝ꠆ꠝꠔ ꠖꠟꠣ ꠅꠁꠍꠟꠣ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ ꠀꠞ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣ ꠕꠣꠇꠤ, ꠖꠞꠤꠀꠞ ꠙꠣꠞꠞ ꠡꠥꠞ ꠀꠞ ꠍꠤꠖꠘ ꠄꠟꠣꠇꠣ ꠕꠣꠇꠤꠅ ꠖꠟ ꠛꠣꠘ꠆ꠖꠤ ꠛꠣꠘ꠆ꠖꠤ ꠝꠣꠘꠥꠡ ꠀꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_18","072_6_18","LUK","6","18","18","ꠔꠣꠞꠣ ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠞ ꠈꠤꠀꠟꠦ ꠀꠞ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠡꠤꠚꠣ ꠅꠀꠞ ꠘꠤꠅꠔꠦ ꠀꠁꠟꠣ। ꠀꠞ ꠎꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠍꠤꠟ, ꠔꠣꠞꠣꠅ ꠜꠣꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_19","072_6_19","LUK","6","19","19","ꠢꠇꠟ ꠝꠣꠘꠡꠦꠃ ꠔꠣꠘꠞꠦ ꠀꠔ ꠖꠤꠀ ꠍꠁꠔ ꠌꠣꠁꠟ, ꠇꠣꠞꠘ ꠔꠣꠘ ꠜꠤꠔꠞ ꠕꠣꠇꠤ ꠇꠥꠖꠞꠔꠤ ꠡꠇ꠆ꠔꠤ ꠛꠣꠞꠘꠤꠄ, ꠄꠞꠣ ꠢꠇꠟꠞ ꠛꠦꠝꠣꠞ ꠇꠝꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK6_20","072_6_20","LUK","6","20","20","ꠔꠦꠃ ꠁꠍꠣꠄ ꠀꠙꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠉꠞꠤꠛ ꠔꠥꠝꠞꠣꠃ ꠇꠙꠣꠟꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠃ। ");
INSERT INTO syls_vpl VALUES ("LK6_21","072_6_21","LUK","6","21","21","ꠔꠥꠝꠞꠣ ꠎꠔ ꠎꠘꠞ ꠙꠦꠐꠅ ꠜꠥꠇ ꠀꠍꠦ, ꠔꠥꠝꠞꠣꠃ ꠇꠙꠣꠟꠤ, ꠔꠥꠝꠞꠣ ꠙꠦꠐ ꠜꠞꠤꠀ ꠈꠣꠁꠛꠣꠄ। ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠇꠣꠘ꠆ꠖꠤꠞꠣꠄ ꠔꠥꠝꠞꠣꠃ ꠇꠙꠣꠟꠤ, ꠛꠣꠖꠦ ꠔ ꠀꠡꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_22","072_6_22","LUK","6","22","22","“ꠔꠥꠝꠞꠣꠃ ꠇꠙꠣꠟꠤ, ꠎꠦꠛꠟꠣ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠖꠣꠄ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠉꠣꠃ ꠕꠣꠇꠤ ꠛꠣꠍꠤꠀ ꠄꠇꠊꠞꠤ ꠇꠞꠦ, ꠛꠖꠘꠣꠝ ꠉꠣꠄ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠝ ꠢꠥꠘꠟꠦ ꠝꠥꠈꠞ ꠕꠥ ꠚꠣꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_23","072_6_23","LUK","6","23","23","ꠁꠟꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠈꠥꠡꠤ ꠅꠁꠅ, ꠚꠥꠞ꠆ꠔꠤꠄ ꠘꠣꠌꠤꠅ, ꠇꠣꠞꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠥꠝꠞꠣ ꠛꠃꠔ ꠛꠠ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛꠣꠄ। ꠎꠣꠘ ꠘꠤ, ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠅꠟꠣ ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_24","072_6_24","LUK","6","24","24","“ꠢꠣꠄꠞꠦ ꠗꠘꠤ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠡꠥꠈ ꠔ ꠖꠥꠘꠤꠀꠔꠃ ꠇꠣꠝꠣꠁꠟꠤꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_25","072_6_25","LUK","6","25","25","ꠢꠣꠄꠞꠦ ꠙꠦꠐ ꠜꠞꠤꠀ ꠈꠣꠅꠞꠣ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠅ ꠜꠥꠇꠦ ꠍꠐꠚꠐ ꠇꠞꠛꠣꠄ। ꠢꠣꠄꠞꠦ ꠢꠣꠄ ꠎꠦꠞꠣ ꠅꠈꠘ ꠀꠡꠤꠞꠣꠄ, ꠔꠥꠝꠞꠣ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_26","072_6_26","LUK","6","26","26","ꠢꠣꠄꠞꠦ ꠢꠣꠄ, ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠡꠥꠘꠣꠝ ꠉꠣꠄ, ꠎꠣꠘ ꠘꠤ, ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠦꠅ ꠀꠉꠞ ꠀꠝꠟꠞ ꠜꠘ꠆ꠒ ꠘꠛꠤ ꠅꠇꠟꠞ ꠅꠟꠣ ꠡꠥꠘꠣꠝ ꠉꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("LK6_27","072_6_27","LUK","6","27","27","“ꠔꠥꠝꠞꠣ ꠎꠔꠎꠘ ꠀꠝꠣꠞ ꠔꠞꠤꠇꠣꠄ ꠌꠟꠔꠣꠄ ꠌꠣꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠖꠥꠡꠝꠘꠞꠦꠅ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ। ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LK6_28","072_6_28","LUK","6","28","28","ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠟꠣꠘ꠆ꠘꠔ ꠝꠣꠋꠉꠦ, ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠞꠢꠝꠔ ꠌꠣꠁꠅ। ꠀꠞ ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠛꠖꠘꠣꠝ ꠇꠞꠦ, ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LK6_29","072_6_29","LUK","6","29","29","ꠎꠦ ꠔꠥꠝꠣꠞ ꠄꠇ ꠉꠣꠟꠅ ꠌꠠ ꠝꠣꠞꠦ, ꠔꠣꠞꠦ ꠀꠞꠇ ꠉꠣꠟ ꠙꠣꠔꠤꠀ ꠖꠤꠅ। ꠎꠦ ꠔꠥꠝꠣꠞ ꠌꠣꠖ꠆ꠖꠞ ꠇꠣꠠꠤꠀ ꠘꠤꠔ ꠌꠣꠄ, ꠔꠣꠞꠦ ꠇꠥꠞ꠆ꠔꠣꠅ ꠈꠥꠟꠤꠀ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LK6_30","072_6_30","LUK","6","30","30","ꠎꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠌꠣꠄ, ꠔꠣꠞꠣꠞꠦ ꠖꠤꠅ। ꠇꠦꠃ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠌꠤꠎ ꠘꠤꠟꠦꠉꠤ, ꠔꠣꠞ ꠉꠦꠍꠦ ꠀꠞ ꠚꠤꠞꠔ ꠌꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_31","072_6_31","LUK","6","31","31","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦꠟꠣꠈꠣꠘ ꠛꠦꠛꠢꠣꠞ ꠙꠣꠁꠔꠣꠄ ꠌꠣꠅ, ꠔꠥꠝꠞꠣꠅ ꠢꠇꠟꠞ ꠟꠉꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("LK6_32","072_6_32","LUK","6","32","32","“ꠎꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦꠃ ꠝꠣꠄꠀ ꠇꠞ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠛꠣꠢꠛꠣ ꠙꠣꠁꠔꠣꠄ ꠇꠤꠟꠣ? ꠁꠟꠣ ꠔ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠦꠅ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK6_33","072_6_33","LUK","6","33","33","ꠀꠞ ꠎꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠦ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠇꠞ, ꠔꠦ ꠛꠣꠢꠛꠣ ꠙꠣꠁꠛꠣꠄ ꠇꠤꠟꠣ? ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠦꠅ ꠔ ꠁꠟꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK6_34","072_6_34","LUK","6","34","34","ꠎꠦ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠇꠞꠎ ꠙꠣꠁꠛꠣꠞ ꠀꠡꠣ ꠀꠍꠦ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠔꠣꠞꠦꠃ ꠇꠞꠎ ꠖꠦꠅ, ꠔꠦ ꠇꠤꠟꠣ ꠛꠣꠢꠛꠣ ꠙꠣꠁꠛꠣꠄ? ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠦꠅ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠁꠟꠣ ꠇꠞꠎ ꠖꠦꠄ, ꠢꠦ ꠀꠡꠣ ꠇꠞꠦ ꠛꠤꠙꠖꠅ ꠙꠠꠟꠦ ꠢꠦ-ꠅ ꠢꠘ ꠕꠣꠇꠤ ꠇꠞꠎ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK6_35","072_6_35","LUK","6","35","35","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠖꠥꠡꠝꠘꠞꠦꠅ ꠝꠣꠄꠀ ꠇꠞꠤꠅ, ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠤꠅ। ꠛꠖꠟꠣ ꠙꠣꠅꠀꠞ ꠀꠡꠣ ꠘꠣ ꠇꠞꠤꠀ ꠇꠞꠎ ꠖꠤꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠠ ꠛꠈꠡꠤꠡ ꠀꠍꠦ। ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠛꠣꠄ। ꠔꠣꠁꠘ ꠔ ꠘꠤꠝꠇ-ꠢꠣꠞꠣꠝ ꠀꠞ ꠈꠣꠞꠣꠙ ꠝꠣꠘꠡꠞꠦꠅ ꠖꠄꠀ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK6_36","072_6_36","LUK","6","36","36","ꠔꠥꠝꠞꠣꠞ ꠘꠤꠞꠣꠇꠣꠞ ꠛꠣꠚ ꠎꠦꠟꠣ ꠖꠄꠀꠟ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣꠘ ꠖꠄꠀꠟ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("LK6_37","072_6_37","LUK","6","37","37","“ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠅ ꠛꠤꠌꠣꠞꠞ ꠖꠣꠠꠅ ꠙꠠꠔꠣꠄ ꠘꠣꠄ। ꠇꠦꠃꠞꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠅ ꠖꠥꠡꠤ ꠅꠁꠔꠣꠄ ꠘꠣꠄ। ꠝꠣꠚ ꠇꠞꠤꠀ ꠖꠤꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠅ ꠝꠣꠚꠤ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_38","072_6_38","LUK","6","38","38","ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠦꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠝꠣꠘꠡꠦ ꠎꠣꠔꠣꠁ ꠎꠣꠔꠣꠁ ꠜꠞꠤꠀ ꠀꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠐꠤꠔ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠛꠣ। ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠝꠣꠙꠤꠀ ꠖꠤꠛꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠅꠟꠣ ꠝꠣꠙꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK6_39","072_6_39","LUK","6","39","39","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ, “ꠄꠇ ꠀꠘ꠆ꠖꠣꠄ ꠇꠥꠘꠥ ꠀꠞꠇ ꠀꠘ꠆ꠖꠣꠞꠦ ꠙꠕ ꠖꠦꠈꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠤ? ꠔꠦ ꠖꠥꠁꠅꠎꠘꠃ ꠉꠣꠔꠅ ꠙꠠꠔ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK6_40","072_6_40","LUK","6","40","40","ꠡꠣꠉꠞꠤꠖ ꠃꠡ꠆ꠔꠣꠖ ꠕꠣꠇꠤ ꠛꠠ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠎꠦ ꠡꠣꠉꠞꠤꠖꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠔꠣꠟꠤꠝ ꠟꠄ, ꠢꠦ-ꠅ ꠃꠡ꠆ꠔꠣꠖꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_41","072_6_41","LUK","6","41","41","ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞ ꠌꠈꠥꠔ ꠉꠥꠠꠣ ꠢꠣꠝꠣꠁꠍꠦ ꠅꠈꠣꠘꠃ ꠖꠦꠈꠞꠣꠄ, ꠅꠁꠟꠦ ꠘꠤꠎꠞ ꠌꠃꠈꠅ ꠉꠣꠍꠞ ꠌꠦꠟꠤ ꠀꠍꠦ ꠁꠔꠣ ꠖꠦꠈꠞꠣꠄ ꠘꠣ? ");
INSERT INTO syls_vpl VALUES ("LK6_42","072_6_42","LUK","6","42","42","ꠔꠥꠝꠣꠞ ꠌꠈꠥꠔ ꠌꠦꠟꠤ ꠢꠣꠝꠣꠁꠍꠦ ꠁꠈꠣꠘ ꠘꠣ ꠌꠣꠁꠀ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞꠦ ꠇꠤꠟꠣ ꠇꠁꠛꠣꠄ, ‘ꠜꠣꠁꠍꠣꠛ, ꠔꠥꠝꠣꠞ ꠌꠃꠈꠅ ꠎꠦ ꠉꠥꠠꠣ ꠙꠠꠍꠦ, ꠀꠅ, ꠅꠉꠥ ꠛꠣꠞ ꠇꠞꠤꠀ ꠖꠦꠁ।’ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠌꠈꠥꠞ ꠌꠦꠟꠤꠃ ꠔ ꠖꠦꠈꠞꠣꠄ ꠘꠣ। ꠅ ꠜꠘ꠆ꠒ, ꠙꠄꠟꠣ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠌꠃꠈ ꠕꠣꠇꠤ ꠌꠦꠟꠤ ꠢꠞꠣꠅ, ꠔꠦꠃ ꠜꠣꠁꠞ ꠌꠃꠈ ꠕꠣꠇꠤ ꠉꠥꠠꠣ ꠛꠣꠞ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠦ ꠜꠣꠟꠣ ꠇꠞꠤ ꠖꠦꠈꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_43","072_6_43","LUK","6","43","43","ꠜꠣꠟꠣ ꠉꠣꠍꠦ ꠔ ꠝꠘ꠆ꠖ ꠚꠟ ꠗꠞꠦ ꠘꠣ, ꠀꠞ ꠝꠘ꠆ꠖ ꠉꠣꠍꠦ ꠜꠣꠟꠣ ꠚꠟ ꠗꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_44","072_6_44","LUK","6","44","44","ꠚꠟ ꠖꠦꠈꠤꠀ ꠉꠣꠍ ꠌꠤꠘꠣ ꠎꠣꠄ। ꠝꠣꠘꠡꠦ ꠔ ꠞꠤꠚꠥꠎꠤ ꠟꠔ ꠕꠣꠇꠤ ꠛꠞꠁ ꠙꠣꠠꠦ ꠘꠣ, ꠛꠣ ꠍꠥꠔꠞꠣ ꠉꠣꠍ ꠕꠣꠇꠤ ꠀꠋꠉꠥꠞ ꠙꠣꠠꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK6_45","072_6_45","LUK","6","45","45","ꠜꠣꠟꠣ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠘꠦꠇ ꠜꠣꠘ꠆ꠒꠣꠞ ꠕꠣꠇꠤ ꠜꠣꠟꠣꠁ ꠛꠣꠞꠅꠄ, ꠀꠞ ꠛꠖ ꠝꠣꠘꠡꠞ ꠛꠖ ꠖꠤꠟ ꠕꠣꠇꠤ ꠛꠖꠃ ꠛꠣꠞꠅꠄ। ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠜꠣꠘ꠆ꠒꠣꠞꠅ ꠎꠦꠔꠣ ꠎꠝꠣ ꠀꠍꠦ, ꠅꠔꠣ ꠕꠣꠇꠤꠃ ꠔ ꠎꠛꠣꠘꠞ ꠛꠥꠟꠤ ꠛꠣꠞꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LK6_46","072_6_46","LUK","6","46","46","“ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠈꠣꠟꠤ ꠢꠥꠎꠥꠞ ꠢꠥꠎꠥꠞ ꠇꠁꠞꠣꠄ, ꠅꠕꠌ ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠁ, ꠁꠔꠣ ꠝꠣꠘꠅ ꠘꠣ? ");
INSERT INTO syls_vpl VALUES ("LK6_47","072_6_47","LUK","6","47","47","ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠀꠝꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠎꠦ ꠎꠘꠦ ꠀꠝꠟ ꠇꠞꠦ, ꠢꠦ ꠇꠣꠞ ꠟꠣꠈꠣꠘ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK6_48","072_6_48","LUK","6","48","48","ꠢꠦ ꠅꠃ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ, ꠎꠦ ꠊꠞ ꠛꠣꠘꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠉꠁꠘ ꠇꠞꠤ ꠝꠣꠐꠤ ꠈꠥꠖꠤꠀ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠊꠞꠞ ꠈꠥꠐꠤ ꠛꠣꠘꠣꠁꠟ, ꠛꠣꠖꠦ ꠛꠁꠘ꠆ꠘꠣ ꠀꠁꠟ ꠀꠞ ꠙꠣꠘꠤꠞ ꠚꠥꠔꠦ ꠅꠃ ꠊꠞꠞꠦ ꠑꠦꠟꠤꠟ, ꠅꠁꠟꠦ ꠁꠈꠣꠘ ꠟꠠꠣꠁꠔ ꠙꠣꠞꠟ ꠘꠣ, ꠁꠈꠣꠘ ꠔ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠛꠣꠘꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK6_49","072_6_49","LUK","6","49","49","ꠀꠞ ꠀꠝꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠎꠦ ꠎꠘꠦ ꠀꠝꠟ ꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠥꠡ, ꠎꠦꠉꠤꠄ ꠉꠣꠔ ꠘꠣ ꠈꠥꠖꠤꠀ ꠈꠣꠟꠤ ꠘꠞꠝ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠊꠞ ꠛꠣꠘꠣꠁꠟ, ꠛꠣꠖꠦ ꠛꠣꠘꠞ ꠚꠥꠔꠞ ꠗꠣꠇ꠆ꠇꠣꠄ ꠔꠣꠞ ꠊꠞ ꠙꠠꠤꠀ ꠜꠣꠋꠉꠤꠀ ꠌꠥꠞꠝꠣꠞ ꠅꠁꠉꠦꠟ।” ");
INSERT INTO syls_vpl VALUES ("LK7_1","072_7_1","LUK","7","1","1","ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠄꠀꠘ ꠡꠦꠡ ꠇꠞꠤꠀ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK7_2","072_7_2","LUK","7","2","2","ꠢꠤꠘꠅ ꠞꠥꠝꠣꠘ ꠍꠤꠙꠣꠁꠞ ꠄꠇ ꠍꠥꠛꠦꠖꠣꠞꠞ ꠉꠥꠟꠣꠝ ꠛꠦꠝꠣꠞ ꠙꠠꠤꠀ ꠝꠞꠣꠞ ꠙꠕꠤ ꠅꠁꠉꠦꠍꠤꠟ, ꠍꠥꠛꠦꠖꠣꠞ ꠍꠣꠛꠦ ꠁ ꠉꠥꠟꠣꠝꠞꠦ ꠈꠥꠛ ꠝꠣꠄꠀ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_3","072_7_3","LUK","7","3","3","ꠔꠣꠁꠘ ꠁꠍꠣꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠇꠄꠎꠘ ꠁꠢꠥꠖꠤ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠔꠣꠘ ꠉꠥꠟꠣꠝꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠔꠣ ꠡꠥꠙꠣꠞꠤꠡꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK7_4","072_7_4","LUK","7","4","4","ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠎꠦ ꠎꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠔꠣꠘ ꠉꠥꠟꠣꠝꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔ ꠇꠞꠔꠣꠝ, ꠄꠁꠘ ꠀꠍꠟꠦꠅ ꠖꠄꠀ ꠙꠣꠅꠀꠞ ꠟꠣꠈ। ");
INSERT INTO syls_vpl VALUES ("LK7_5","072_7_5","LUK","7","5","5","ꠔꠣꠁꠘ ꠛꠤꠖꠦꠡꠤ ꠅꠁꠟꠦꠅ ꠀꠝꠞꠣꠞ ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤꠞꠦ ꠈꠥꠛ ꠝꠣꠄꠀ ꠇꠞꠂꠘ। ꠀꠝꠞꠣꠞ ꠝꠍꠤꠖ ꠈꠣꠘꠅ ꠔꠣꠁꠘ ꠛꠣꠘꠣꠁ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK7_6","072_7_6","LUK","7","6","6","ꠁꠍꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠍꠥꠛꠦꠖꠣꠞꠞ ꠛꠣꠠꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠔꠦꠃ ꠍꠥꠛꠦꠖꠣꠞꠦ ꠘꠤꠎꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟꠞꠦ ꠙꠣꠑꠣꠁꠀ ꠎꠣꠘꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞꠦ ꠀꠞ ꠇꠡ꠆ꠐ ꠇꠞꠂꠘ ꠘꠣ ꠎꠣꠘꠥ, ꠀꠙꠘꠣꠞ ꠝꠔ ꠎꠘꠦ ꠀꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠀꠝꠤ ꠔ ꠁꠔꠣꠞ ꠟꠣꠈ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK7_7","072_7_7","LUK","7","7","7","ꠀꠙꠘꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠘꠤꠞ ꠎꠁꠉ꠆ꠉ-ꠅ ꠀꠝꠤ ꠘꠣꠄ, ꠄꠞꠖꠣꠄ ꠀꠝꠤ ꠀꠁꠞꠣꠝ ꠘꠣ। ꠔꠦ ꠀꠙꠘꠦ ꠈꠣꠟꠤ ꠎꠛꠣꠘꠖꠤ ꠇꠁꠟꠦꠃ, ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LK7_8","072_7_8","LUK","7","8","8","ꠀꠙꠘꠦ ꠔ ꠛꠥꠎꠞꠣ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞꠞ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠤ, ꠅꠃꠟꠣ ꠀꠝꠣꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠅ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠂꠘ। ꠀꠝꠤ ꠄꠞꠣ ꠄꠇꠎꠘꠞꠦ ꠀꠅ ꠇꠁꠟꠦ ꠀꠄ, ꠎꠣꠅ ꠇꠁꠟꠦ ꠎꠣꠄ, ꠀꠝꠣꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠅꠃ ꠇꠣꠝ ꠇꠞꠅ ꠇꠁꠟꠦ, ꠢꠦ ꠇꠞꠦ। ꠔꠦ ꠀꠙꠘꠦꠅ ꠅꠟꠣ ꠈꠣꠟꠤ ꠝꠥꠈꠖꠤ ꠇꠁꠟꠦꠃ, ꠢꠇ꠆ꠇꠟꠔꠣꠄ ꠝꠣꠘꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK7_9","072_7_9","LUK","7","9","9","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ, ꠖꠟꠦ ꠖꠟꠦ ꠎꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠈꠞꠦ ꠅꠁꠀ ꠀꠅꠀꠔ ꠀꠍꠤꠟ, ꠄꠞꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠁ ꠍꠥꠛꠦꠖꠣꠞ ꠔ ꠛꠤꠗꠞ꠆ꠝꠤ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠥꠡ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦꠅ ꠔ ꠅꠔ ꠝꠎꠛꠥꠔ ꠁꠝꠣꠘꠖꠣꠞ ꠀꠝꠤ ꠇꠥꠘꠥꠈꠣꠘꠅ ꠖꠦꠈꠍꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK7_10","072_7_10","LUK","7","10","10","ꠢꠣꠍꠣꠃ ꠍꠥꠛꠦꠖꠣꠞꠦ ꠎꠣꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠊꠞꠅ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠢꠤ ꠉꠥꠟꠣꠝꠞ ꠛꠦꠝꠣꠞ ꠇꠝꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK7_11","072_7_11","LUK","7","11","11","ꠕꠥꠠꠣ ꠇꠄ ꠖꠤꠘ ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟ ꠀꠞ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠟꠁꠀ ꠘꠣꠄꠁꠘ ꠘꠣꠝꠞ ꠄꠇ ꠉꠣꠃꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_12","072_7_12","LUK","7","12","12","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠢꠃ ꠉꠣꠃꠔ ꠀꠁꠀ ꠢꠣꠝꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠘꠡꠦ ꠈꠞꠣꠞꠅ ꠇꠞꠤ ꠄꠇ ꠝꠁꠅꠔ ꠟꠁꠀ ꠎꠣꠁꠞꠣ। ꠁ ꠝꠁꠅꠔ ꠀꠍꠤꠟ ꠄꠇ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠞ ꠄꠇꠝꠣꠔ꠆ꠞ ꠙꠥꠀ। ꠉꠣꠃꠞ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠅꠃ ꠈꠞꠣꠞꠞ ꠟꠉꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_13","072_7_13","LUK","7","13","13","ꠅꠃ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠞꠦ ꠖꠦꠈꠤꠀ ꠁꠍꠣꠞ ꠖꠤꠟꠅ ꠖꠄꠀ ꠢꠣꠝꠣꠁꠟ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠉ, ꠇꠣꠘ꠆ꠖꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK7_14","072_7_14","LUK","7","14","14","ꠇꠁꠀ ꠔꠣꠁꠘ ꠈꠞꠣꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠤꠀ ꠈꠞꠣꠞꠅ ꠍꠁꠟꠣ, ꠔꠦꠃ ꠝꠁꠅꠔ ꠛꠁꠀ ꠘꠦꠅꠞꠣ ꠛꠦꠐꠣꠁꠘ ꠃꠛꠣꠁ ꠉꠦꠟꠣ। ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠛꠦꠐꠣ, ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠃꠑꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK7_15","072_7_15","LUK","7","15","15","ꠔꠦꠃ ꠢꠤ ꠝꠥꠞ꠆ꠖꠣ ꠛꠦꠐꠣ ꠃꠑꠤꠀ ꠛꠁꠉꠦꠟ, ꠛꠁꠀ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠟ। ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠔꠣꠞ ꠝꠣʼꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_16","072_7_16","LUK","7","16","16","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟꠞ ꠜꠤꠔꠞꠦ ꠒꠞ ꠢꠣꠝꠣꠁꠉꠦꠟ। ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠍꠥꠛꠢꠣꠘ ꠀꠟ꠆ꠟꠣ, ꠄꠇꠎꠘ ꠝꠢꠣꠘ ꠘꠛꠤꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠛꠣꠄ ꠌꠃꠈ ꠚꠤꠞꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK7_17","072_7_17","LUK","7","17","17","ꠁꠍꠣꠞ ꠅꠃ ꠇꠦꠞꠣꠝꠔꠤꠞ ꠇꠕꠣ ꠀꠡ꠆ꠔꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠀꠞ ꠀꠡ-ꠙꠣꠡ ꠢꠇ꠆ꠇꠟ ꠎꠣꠉꠣꠔ ꠝꠣꠡꠥꠞ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK7_18","072_7_18","LUK","7","18","18","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟ ꠉꠤꠀ ꠅꠃ ꠢꠇ꠆ꠇꠟꠔꠣ ꠄꠢꠤꠀꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_19","072_7_19","LUK","7","19","19","ꠅꠃ ꠄꠢꠤꠀꠄ ꠔꠣꠘ ꠖꠥꠁꠎꠘ ꠡꠣꠉꠞꠤꠖꠞꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠔꠣ, “ꠢꠥꠎꠥꠞꠦ ꠇꠁꠍꠂꠘ ꠀꠝꠞꠣ ꠎꠣꠘꠤꠀ ꠎꠣꠁꠔꠣꠝ, ꠎꠦꠁꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠕꠣ, ꠀꠙꠘꠦꠃ ꠢꠦꠁꠘ ꠘꠤ? ꠘꠣ ꠀꠝꠞꠣ ꠀꠞ ꠇꠦꠃꠞꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("LK7_20","072_7_20","LUK","7","20","20","ꠔꠦꠃ ꠖꠥꠁꠅ ꠡꠣꠉꠞꠤꠖ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠀꠙꠘꠣꠞꠦ ꠎꠤꠇꠣꠁꠔꠣꠝ, ꠎꠦꠁꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠕꠣ, ꠀꠙꠘꠦꠃ ꠢꠦꠁꠘ ꠘꠤ? ꠘꠣ ꠀꠝꠞꠣ ꠀꠞ ꠇꠦꠃꠞꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("LK7_21","072_7_21","LUK","7","21","21","ꠑꠤꠇ ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞ ꠀꠞ ꠎꠤꠘ-ꠜꠥꠔꠞ ꠀꠍꠞ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ꠛꠃꠔ ꠀꠘ꠆ꠖꠣꠞꠦꠅ ꠖꠦꠈꠣꠞ ꠈꠦꠝꠔꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_22","072_7_22","LUK","7","22","22","ꠅꠔꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠄꠢꠤꠀꠞ ꠖꠥꠁꠅ ꠡꠣꠉꠞꠤꠖꠞꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠣꠅꠉꠤ, ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠀꠁꠀ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠎꠦꠔꠣ ꠖꠦꠈꠟꠣꠄ ꠀꠞ ꠢꠥꠘꠟꠣꠄ, ꠅꠔꠣ ꠉꠤꠀ ꠄꠢꠤꠀꠞꠦ ꠎꠣꠘꠣꠅ। ꠔꠣꠘꠞꠦ ꠇꠁꠅ, ꠀꠘ꠆ꠖꠣꠄꠅ ꠌꠃꠈꠦ ꠖꠦꠈꠞꠣ, ꠟꠦꠋꠠꠣ ꠅꠇꠟꠦ ꠀꠐꠤꠞꠣ, ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤ ꠜꠣꠟꠣ ꠅꠁꠞꠣ, ꠈꠣꠟꠥꠀꠄꠅ ꠢꠥꠘꠞꠣ, ꠝꠥꠞ꠆ꠖꠣ ꠝꠣꠘꠥꠡ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠞꠣ, ꠀꠞ ꠉꠞꠤꠛ ꠅꠇꠟꠞ ꠉꠦꠍꠦꠅ ꠀꠟ꠆ꠟꠣꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("LK7_23","072_7_23","LUK","7","23","23","ꠀꠞ ꠄꠞꠣꠃ ꠇꠙꠣꠟꠤ ꠝꠣꠘꠥꠡ, ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠦꠞꠣꠞ ꠖꠤꠟꠅ ꠇꠥꠘꠥ ꠛꠣꠗꠣ ꠘꠣ ꠙꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK7_24","072_7_24","LUK","7","24","24","ꠄꠢꠤꠀꠞ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟ ꠉꠤꠀ ꠢꠣꠞꠟꠦ, ꠄꠢꠤꠀꠞ ꠛꠦꠙꠣꠞꠦ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠇꠤꠔꠣ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ? ꠛꠣꠔꠣꠡꠦ ꠟꠠꠦ-ꠍꠠꠦ ꠅꠔꠣ ꠈꠣꠉꠠꠣ-ꠛꠘ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK7_25","072_7_25","LUK","7","25","25","ꠘꠣ, ꠇꠤꠔꠣ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ? ꠡꠥꠘ꠆ꠖꠞ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠘ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠘꠤ? ꠎꠦꠞꠣ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠎꠣꠇ-ꠎꠝꠇ ꠇꠞꠦ, ꠀꠞ ꠡꠥꠈꠤꠞ꠆ꠔꠣ ꠖꠤꠘ ꠇꠣꠐꠣꠄ, ꠔꠣꠞꠣ ꠔ ꠞꠣꠎꠛꠣꠠꠤꠔ ꠕꠣꠇꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK7_26","072_7_26","LUK","7","26","26","ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ? ꠇꠥꠘꠥ ꠘꠛꠤꠞꠦ ꠖꠦꠈꠣꠔ ꠉꠦꠍꠟꠣꠄ ꠘꠤ? ꠅꠄ, ꠢꠣꠍꠣꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠁ ꠄꠢꠤꠀ ꠔ ꠈꠣꠟꠤ ꠘꠛꠤ ꠘꠣꠄ, ꠘꠛꠤ ꠕꠣꠇꠤꠅ ꠛꠠ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("LK7_27","072_7_27","LUK","7","27","27","ꠄꠁꠘ ꠔ ꠢꠃ ꠎꠘ, ꠎꠦꠘ ꠇꠕꠣ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞ ꠀꠉꠦ ꠛꠦꠎꠤꠀꠞ ꠀꠝꠤ ꠀꠝꠣꠞ ꠙꠦꠉꠣꠝ꠆ꠛꠞ, ꠄꠁꠘ ꠉꠤꠀ ꠑꠤꠇ-ꠑꠣꠇ ꠇꠞꠛꠣ ꠔꠥꠝꠣꠞ ꠌꠟꠣꠞ ꠙꠕ। ");
INSERT INTO syls_vpl VALUES ("LK7_28","072_7_28","LUK","7","28","28","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠇꠥꠘꠥ ꠀꠖꠝꠃ ꠄꠢꠤꠀ ꠕꠣꠇꠤ ꠛꠠ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠢꠥꠞꠥ ꠎꠘꠅ, ꠄꠢꠤꠀ ꠕꠣꠇꠤ ꠝꠢꠣꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK7_29","072_7_29","LUK","7","29","29","ꠡꠝꠣꠎꠞ ꠢꠇꠟ ꠗꠞꠘꠞ ꠀꠝ ꠝꠣꠘꠡꠦ ꠀꠞ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠅꠇꠟꠦꠅ ꠄꠢꠤꠀꠞ ꠔꠛꠟꠤꠉ ꠢꠥꠘꠟꠣ, ꠔꠣꠞꠣ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠢꠇ-ꠁꠘꠍꠣꠚꠇꠣꠞꠤ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_30","072_7_30","LUK","7","30","30","ꠅꠁꠟꠦ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠝꠣꠘꠡꠦ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠄꠢꠤꠀꠞ ꠉꠦꠍꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠘꠣ ꠇꠞꠤꠀ, ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠎꠦ ꠈꠤꠀꠟ ꠀꠍꠤꠟ, ꠁꠐꠣꠞꠦ ꠇꠥꠘꠥ ꠖꠣꠝ ꠖꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_31","072_7_31","LUK","7","31","31","ꠔꠦꠃ ꠁꠍꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠅꠈꠘ ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠤ ꠇꠤꠔꠣꠞ ꠟꠉꠦ ꠔꠥꠟꠘꠣ ꠇꠞꠔꠣꠝ? ꠔꠣꠞꠣ ꠇꠣꠞ ꠟꠣꠈꠣꠘ? ");
INSERT INTO syls_vpl VALUES ("LK7_32","072_7_32","LUK","7","32","32","ꠔꠣꠞꠣ ꠔ ꠅꠝꠘ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ, ꠎꠦꠔꠣꠄ ꠛꠣꠎꠣꠞꠅ ꠛꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠄ, ꠛꠣꠡꠤ ꠔ ꠛꠣꠎꠣꠁꠟꠣꠝ ꠖꠥꠡ꠆ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠀ, ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠘꠣꠌꠤꠟꠣꠄ ꠘꠣ ꠛꠣꠡꠤ ꠢꠥꠘꠤꠀ। ꠝꠣꠔ꠆ꠔꠝꠞ ꠎꠣꠞꠤ-ꠉꠣꠘ ꠉꠣꠁꠟꠣꠝ ꠀꠝꠞꠣ ꠡꠛꠦ, ꠇꠣꠘ꠆ꠖꠤꠟꠣꠄ ꠘꠣ ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠝꠣꠔ꠆ꠔꠝꠞ ꠡꠥꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK7_33","072_7_33","LUK","7","33","33","ꠔꠦ ꠄꠢꠤꠀ ꠘꠛꠤ ꠀꠁꠀ ꠢꠣꠞꠤ ꠜꠣꠔ-ꠞꠥꠐꠤ ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠘꠣ ꠈꠣꠅꠀꠄ, ꠔꠥꠝꠞꠣ ꠇꠁꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠜꠥꠔꠦ ꠗꠞꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK7_34","072_7_34","LUK","7","34","34","ꠀꠞ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠁꠀ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠇꠞꠞꠣ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣ ꠇꠁꠞꠣꠄ, ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠁ ꠛꠦꠐꠣ ꠔ ꠙꠦꠐꠥꠀ ꠀꠞ ꠝꠖꠈꠥꠞ। ꠢꠦ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠖꠥꠡ꠆ꠔꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK7_35","072_7_35","LUK","7","35","35","ꠔꠣ-ꠅ ꠀꠈꠟ ꠈꠣꠐꠣꠁꠀ ꠎꠦꠞꠣ ꠌꠟꠦ, ꠔꠣꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠕꠣꠇꠤꠃ ꠙꠞꠝꠣꠘ ꠝꠤꠟꠦ, ꠀꠈꠟꠃ ꠅꠁꠟ ꠈꠣꠐꠤ-ꠘꠤꠈꠥꠔ ꠌꠤꠎ।” ");
INSERT INTO syls_vpl VALUES ("LK7_36","072_7_36","LUK","7","36","36","ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠈꠣꠘꠤꠞ ꠖꠣꠅꠔ ꠖꠤꠟꠣ, ꠁꠍꠣ ꠅꠃ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠈꠣꠘꠤꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK7_37","072_7_37","LUK","7","37","37","ꠅꠁꠟꠦ ꠅꠃ ꠉꠣꠃꠔ ꠄꠇ ꠈꠛꠤꠍ ꠛꠦꠐꠤ ꠀꠍꠤꠟ। ꠁꠍꠣ ꠅꠘꠅ ꠖꠣꠅꠔꠅ ꠀꠁꠍꠂꠘ ꠢꠥꠘꠤꠀ ꠢꠃ ꠈꠛꠤꠍ ꠛꠦꠐꠤꠄ ꠖꠣꠝꠤ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞꠞ ꠛꠂꠀꠝꠅ ꠇꠞꠤ ꠀꠔꠞ ꠟꠁꠀ ꠅꠘꠅ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK7_38","072_7_38","LUK","7","38","38","ꠀꠁꠀ ꠁꠍꠣꠞ ꠙꠤꠍꠘ ꠉꠣꠟꠣꠛꠣꠄ ꠔꠣꠘ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠃꠛꠣꠁꠀ, ꠇꠣꠘ꠆ꠖꠤꠀ ꠌꠃꠈꠞ ꠙꠣꠘꠤꠖꠤ ꠔꠣꠘ ꠙꠣꠅꠞ ꠙꠣꠔꠣ ꠜꠤꠎꠣꠁꠟꠤꠟ। ꠛꠣꠖꠦ ꠔꠣꠁꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟꠖꠤ ꠙꠣꠅ ꠚꠥꠍꠤꠀ ꠖꠤꠟ, ꠙꠣꠅꠞ ꠝꠣꠎꠦ ꠢꠥꠋꠉꠣ ꠖꠤꠔꠦ ꠖꠤꠔꠦ ꠀꠔꠞ ꠝꠣꠈꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK7_39","072_7_39","LUK","7","39","39","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠁꠍꠣꠞꠦ ꠎꠦꠁꠘ ꠖꠣꠅꠔ ꠖꠤꠍꠟꠣ, ꠄꠁꠘ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, “ꠁ ꠛꠦꠐꠣ ꠇꠥꠘꠥ ꠘꠛꠤ ꠅꠁꠟꠦ ꠔ ꠄꠝꠘꠦꠃ ꠛꠥꠎꠟ ꠅꠘꠦ ꠁ ꠛꠦꠐꠤ ꠇꠦꠉꠥ, ꠁꠉꠥ ꠇꠔ ꠛꠠ ꠈꠛꠤꠍ ꠉꠥꠘꠣꠉꠣꠞ ꠛꠦꠐꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK7_40","072_7_40","LUK","7","40","40","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠍꠣꠁꠝꠘ, ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠇꠤꠍꠥ ꠇꠕꠣ ꠀꠍꠦ।” ꠍꠣꠁꠝꠘꠦ ꠇꠁꠟꠣ, “ꠇꠃꠇ꠆ꠇꠣ ꠢꠥꠎꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK7_41","072_7_41","LUK","7","41","41","ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠝꠘꠦ ꠇꠞꠅ, ꠄꠇ ꠝꠣꠎꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠁꠎꠘ ꠝꠣꠘꠡꠦ ꠇꠤꠍꠥ ꠐꠦꠇꠣ ꠇꠞꠎ ꠘꠤꠍꠤꠟ, ꠄꠇꠎꠘꠦ ꠙꠣꠌ-ꠡ, ꠀꠞꠇ ꠎꠘꠦ ꠙꠁꠘ꠆ꠌꠣꠡ ꠖꠤꠘꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LK7_42","072_7_42","LUK","7","42","42","ꠔꠣꠞꠣꠞ ꠇꠦꠃꠞꠞꠃ ꠔꠣꠇ꠆ꠇꠔ ꠀꠍꠤꠟ ꠘꠣ ꠁ ꠐꠦꠇꠣ ꠚꠤꠞꠔ ꠖꠦꠅꠀ, ꠔꠦꠃ ꠝꠣꠎꠘꠦ ꠄꠞꠣ ꠖꠥꠁꠅꠎꠘꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠁꠟꠣ। ꠅꠈꠘ ꠇꠅ ꠌꠣꠁꠘ, ꠄꠞꠣ ꠇꠥꠘ ꠎꠘꠦ ꠝꠣꠎꠘꠞꠦ ꠛꠦꠡꠤ ꠜꠣꠟꠣ ꠙꠣꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("LK7_43","072_7_43","LUK","7","43","43","ꠍꠣꠁꠝꠘꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠝꠘꠦ ꠇꠄ, ꠎꠣꠞ ꠛꠦꠡꠤ ꠐꠦꠇꠣ ꠝꠣꠚ ꠖꠦꠅꠀ ꠅꠁꠍꠦ।” ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠑꠤꠇꠃ ꠇꠁꠍ।” ");
INSERT INTO syls_vpl VALUES ("LK7_44","072_7_44","LUK","7","44","44","ꠔꠦꠃ ꠁꠍꠣꠄ ꠅꠃ ꠛꠦꠐꠤꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠍꠣꠁꠝꠘ, ꠅꠃ ꠛꠦꠐꠤꠉꠥꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠅ ꠀꠞ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠊꠞꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞꠦ ꠙꠣꠅ ꠗꠅꠀꠞꠅ ꠙꠣꠘꠤ ꠖꠤꠍ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠣꠁꠞ ꠌꠃꠈꠞ ꠙꠣꠘꠤꠖꠤ ꠀꠝꠣꠞ ꠙꠣꠅ ꠜꠤꠎꠣꠁꠀ, ꠝꠣꠕꠣꠞ ꠌꠥꠟꠖꠤ ꠚꠥꠍꠤꠀ ꠖꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK7_45","072_7_45","LUK","7","45","45","ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠢꠥꠋꠉꠣ ꠖꠤꠍ ꠘꠣ, ꠅꠁꠟꠦ ꠖꠦꠈꠞꠣꠄ ꠘꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠘꠤꠞ ꠛꠣꠖ ꠅꠘꠦꠃ ꠔꠣꠁ ꠀꠝꠣꠞ ꠙꠣꠅꠔ ꠢꠥꠋꠉꠣ ꠖꠦꠅꠀꠔꠃ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK7_46","072_7_46","LUK","7","46","46","ꠔꠥꠝꠤ ꠇꠥꠘꠥꠎꠣꠔ ꠔꠣꠎꠤꠝ ꠇꠞꠤ ꠀꠝꠣꠞꠦ ꠀꠉꠥꠀꠁ ꠀꠘꠍ ꠘꠤ? ꠅꠁꠟꠦ ꠔꠣꠁ ꠀꠝꠣꠞ ꠙꠣꠅꠔ ꠀꠔꠞ ꠓꠣꠟꠤꠀ ꠔꠣꠎꠤꠝ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK7_47","072_7_47","LUK","7","47","47","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠣꠁ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠍꠦ ꠇꠞꠤ ꠛꠥꠎꠣ ꠎꠣꠞ, ꠔꠣꠁ ꠛꠠ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠁꠟꠦꠅ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠙꠣꠁꠍꠦ। ꠎꠣꠞ ꠕꠥꠠꠣ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠣ ꠅꠄ, ꠢꠦ ꠕꠥꠠꠣ ꠝꠣꠄꠀ ꠇꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK7_48","072_7_48","LUK","7","48","48","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠅꠉ, ꠔꠥꠝꠣꠞ ꠔꠣꠝꠣꠝ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK7_49","072_7_49","LUK","7","49","49","ꠎꠣꠞꠣ ꠁꠍꠣꠞ ꠟꠉꠦ ꠈꠣꠘꠤꠔ ꠛꠁꠍꠟꠣ ꠔꠣꠞꠣ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠇꠦ, ꠎꠦꠁꠘ ꠉꠥꠘꠣꠅ ꠝꠣꠚ ꠇꠞꠤꠟꠣꠁꠘ?” ");
INSERT INTO syls_vpl VALUES ("LK7_50","072_7_50","LUK","7","50","50","ꠁꠍꠣꠄ ꠢꠤ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠦꠐꠤ, ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠔꠥꠝꠤ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠟꠣꠄ, ꠅꠈꠘ ꠡꠣꠘ꠆ꠔꠤ ꠅꠁꠀ ꠛꠣꠠꠤꠔ ꠎꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK8_1","072_8_1","LUK","8","1","1","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠅꠃ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠟꠁꠀ ꠉꠣꠃꠄ ꠉꠣꠃꠄ, ꠐꠣꠃꠘꠦ ꠐꠣꠃꠘꠦ ꠊꠥꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_2","072_8_2","LUK","8","2","2","ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠇꠄꠎꠘ ꠛꠦꠐꠤꠘꠅ ꠀꠍꠟꠣ। ꠅꠃ ꠛꠦꠐꠤꠘ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠞ ꠛꠃꠔ ꠎꠣꠔꠞ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠅꠁꠀ ꠔꠣꠘ ꠟꠉ ꠗꠞꠍꠟꠣ। ꠄꠞꠣꠞ ꠘꠣꠝ ꠅꠁꠟ: ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ, ꠄꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠣꠔꠉꠥ ꠎꠤꠘ ꠍꠣꠠꠣꠁꠟ ꠅꠁꠍꠤꠟ; ");
INSERT INTO syls_vpl VALUES ("LK8_3","072_8_3","LUK","8","3","3","ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠃꠎꠤꠞ ꠇꠥꠎꠣꠁꠞ ꠛꠃ ꠍꠥꠢꠣꠘ꠆ꠘꠣ; ꠍꠥꠍꠣꠘ꠆ꠘꠣ; ꠀꠞ ꠀꠞꠅ ꠛꠃꠔ ꠛꠦꠐꠤꠘ ꠀꠍꠟꠣ। ꠅꠃ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠍꠣꠝꠣꠘꠣ ꠖꠤꠀ ꠁꠍꠣ ꠀꠞ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞ ꠈꠞꠌ-ꠙꠣꠔꠤ ꠌꠣꠟꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_4","072_8_4","LUK","8","4","4","ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠘꠣꠘꠣꠘ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠖꠟꠣ ꠅꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠄꠇ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_5","072_8_5","LUK","8","5","5","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠦ ꠗꠣꠘꠞ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠖꠦꠅꠀꠔ ꠉꠦꠟ। ꠉꠤꠀ ꠛꠣꠁꠘ ꠖꠦꠅꠀꠞ ꠛꠣꠟꠣ ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠀꠁꠟꠞ ꠝꠣꠎꠦ ꠙꠠꠤꠉꠦꠟ, ꠝꠣꠘꠡꠦ ꠙꠣꠅꠖꠤ ꠃꠠꠤꠀ ꠁ ꠎꠣꠟꠣ ꠘꠡ꠆ꠐ ꠇꠞꠤꠟ꠆ꠟ, ꠀꠞ ꠙꠣꠈꠤꠘ꠆ꠔꠦꠅ ꠀꠁꠀ ꠈꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK8_6","072_8_6","LUK","8","6","6","ꠉꠤꠞꠡ꠆ꠔꠞ ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠢꠥꠇꠘꠣ-ꠡꠇ꠆ꠔ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠙꠠꠟ, ꠁꠔꠣꠄ ꠀꠟꠤ ꠛꠣꠞ ꠅꠁꠟꠦꠅ ꠢꠦꠡꠦ ꠞꠡ ꠘꠣ ꠙꠣꠁꠀ ꠢꠥꠇꠣꠁꠀ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK8_7","072_8_7","LUK","8","7","7","ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠛꠘ-ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠙꠠꠟ, ꠁ ꠎꠣꠟꠣꠄ ꠀꠟꠤ ꠚꠥꠐꠟꠦꠅ ꠁꠔꠣꠞꠦ ꠛꠘ-ꠎꠋꠟꠣꠄ ꠎꠣꠔꠤꠀ ꠗꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK8_8","072_8_8","LUK","8","8","8","ꠅꠁꠟꠦ ꠇꠤꠍꠥ ꠎꠣꠟꠣ ꠜꠣꠟꠣ ꠎꠝꠤꠘꠅ ꠙꠠꠟ, ꠁ ꠎꠣꠟꠣꠄ ꠜꠣꠟꠣ ꠗꠣꠘ ꠅꠁꠟ, ꠀꠞ ꠄꠇ-ꠡ ꠉꠥꠘ ꠛꠦꠡꠤ ꠗꠣꠘ ꠗꠞꠟ।” ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ, ꠢꠦ ꠢꠥꠘꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("LK8_9","072_8_9","LUK","8","9","9","ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠦ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("LK8_10","072_8_10","LUK","8","10","10","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠉꠥꠙꠘ ꠞꠢꠁꠡ꠆ꠡ ꠎꠣꠘꠣꠞ ꠡꠥꠎꠥꠉ ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠁꠟꠦ ꠛꠣꠇꠤ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠔ ꠁꠔꠣ ꠇꠤꠌ꠆ꠍꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠁꠞꠣꠝ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠖꠦꠈꠤꠀꠅ ꠘꠣ ꠖꠦꠈꠦ, ꠢꠥꠘꠤꠀꠅ ꠘꠣ ꠛꠥꠎꠦ। ");
INSERT INTO syls_vpl VALUES ("LK8_11","072_8_11","LUK","8","11","11","“ꠔꠦ ꠁ ꠇꠤꠌ꠆ꠍꠣꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠁ ꠗꠣꠘꠞ ꠎꠣꠟꠣ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK8_12","072_8_12","LUK","8","12","12","ꠀꠁꠟꠞ ꠝꠣꠎꠦ ꠙꠠꠣ ꠎꠣꠟꠣꠖꠤ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ, ꠛꠣꠖꠦ ꠁꠛꠟꠤꠍꠦ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠁꠔꠣ ꠇꠣꠠꠤꠀ ꠘꠦꠄꠉꠤ। ꠁꠛꠟꠤꠍꠦ ꠌꠣꠄ ꠘꠣ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LK8_13","072_8_13","LUK","8","13","13","ꠀꠞ ꠢꠥꠇꠘꠣ-ꠡꠇ꠆ꠔ ꠝꠣꠐꠤꠞ ꠃꠙꠞꠦ ꠙꠠꠣ ꠎꠣꠟꠣꠖꠤ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠣꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠛꠦꠡ ꠈꠥꠡꠤ ꠅꠁꠀ ꠢꠥꠘꠦ, ꠅꠁꠟꠦ ꠇꠣꠟꠣꠝꠦ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠎꠠ ꠇꠞꠦ ꠘꠣ। ꠄꠞꠖꠣꠄ ꠁ ꠁꠝꠣꠘ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠐꠤꠇꠦ, ꠇꠥꠘꠥ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠙꠠꠟꠦꠃ ꠔꠣꠞꠣꠞ ꠁꠝꠣꠘ ꠈꠥꠀꠁꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK8_14","072_8_14","LUK","8","14","14","ꠛꠘ-ꠎꠋꠟꠣꠔ ꠙꠠꠣ ꠎꠣꠟꠣꠖꠤ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦꠞꠣ ꠁꠝꠣꠘꠞ ꠖꠣꠅꠔ ꠢꠥꠘꠦ, ꠅꠁꠟꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠗꠣꠘ꠆ꠖꠣꠔ ꠙꠠꠤꠀ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠟꠣꠟꠌ, ꠀꠞ ꠀꠞꠣꠝ-ꠀꠄꠄꠡꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠁꠔꠣ ꠚꠣꠃꠞꠤꠟꠣꠄ। ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠇꠥꠘꠥ ꠜꠣꠟꠣ ꠚꠟ ꠗꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_15","072_8_15","LUK","8","15","15","ꠜꠣꠟꠣ ꠎꠝꠤꠘꠅ ꠙꠠꠣ ꠎꠣꠟꠣꠖꠤ ꠛꠥꠎꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠦꠞꠣ ꠢꠇ ꠀꠞ ꠍꠢꠤ ꠖꠤꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ, ꠢꠥꠘꠤꠀ ꠘꠤꠎꠞ ꠖꠤꠟꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠦ, ꠀꠞ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠁꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠜꠣꠟꠣ ꠚꠟ ꠗꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK8_16","072_8_16","LUK","8","16","16","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠟꠦꠝ ꠎꠣꠟꠣꠁꠀ ꠢꠣꠞꠤ ꠌꠇꠤꠞ ꠔꠟꠦ ꠕꠄ ꠘꠤ ꠛꠣ ꠐꠥꠇꠞꠤꠖꠤ ꠉꠥꠞꠤꠟꠣꠄ ꠘꠤ? ꠘꠤꠌꠄ ꠘꠣ, ꠔꠣꠞꠣ ꠉꠣꠍꠣꠞ ꠃꠙꠞꠦ ꠕꠄ, ꠎꠣꠔꠦ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠚꠞ ꠖꠦꠈꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK8_17","072_8_17","LUK","8","17","17","ꠔꠦ ꠁꠟꠣ ꠉꠣꠁꠛꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ ꠎꠦꠔꠣ ꠎꠣꠁꠞ ꠅꠁꠔ ꠘꠣꠄ। ꠁꠟꠣ ꠟꠥꠇꠣꠁꠟꠅ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ ꠎꠦꠔꠣ ꠇꠦꠃ ꠢꠥꠘꠔ ꠘꠣꠄ ꠛꠣ ꠎꠣꠘꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK8_18","072_8_18","LUK","8","18","18","ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣ ꠢꠥꠘꠞꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠤꠅ, ꠎꠣꠞ ꠀꠍꠦ ꠔꠣꠞꠦ ꠀꠞꠅ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠀꠞ ꠎꠣꠞ ꠘꠣꠁ, ꠔꠣꠞ ꠎꠦꠔꠣ ꠀꠍꠦ ꠛꠟꠤꠀ ꠢꠦ ꠝꠘꠦ ꠇꠞꠦꠞ, ꠅꠔꠣꠅ ꠘꠦꠅꠀ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK8_19","072_8_19","LUK","8","19","19","ꠄꠞꠝꠣꠎꠦ ꠁꠍꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠀ ꠀꠎꠤꠟꠣ, ꠅꠁꠟꠦ ꠜꠤꠠꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠇꠣꠍꠣꠔ ꠀꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_20","072_8_20","LUK","8","20","20","ꠔꠦꠃ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞ ꠝꠣ ꠀꠞ ꠜꠣꠁꠀꠁꠘ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠀꠁꠀ ꠛꠣꠞꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK8_21","072_8_21","LUK","8","21","21","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠣꠞ ꠝꠣ-ꠜꠣꠁ ꠔ ꠄꠞꠣꠃ, ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠂꠘ ꠀꠞ ꠀꠝꠟ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK8_22","072_8_22","LUK","8","22","22","ꠄꠇꠖꠤꠘ ꠁꠍꠣ ꠀꠞ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠉꠤꠀ ꠘꠣꠅꠅ ꠃꠑꠟꠣ, ꠃꠑꠤꠀ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠝꠞꠣ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠎꠣꠁ।” ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠘꠣꠅ ꠜꠣꠡꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_23","072_8_23","LUK","8","23","23","ꠘꠣꠅ ꠌꠟꠔꠤꠞ ꠝꠣꠎꠦ ꠁꠍꠣ ꠊꠥꠝꠣꠁ ꠉꠦꠟꠣ। ꠀꠈꠔꠣꠃ ꠀꠅꠞꠞ ꠝꠣꠎꠦ ꠅꠝꠘ ꠔꠥꠚꠣꠘ ꠀꠁꠟ, ꠔꠥꠚꠣꠘꠦ ꠘꠣꠅꠔ ꠙꠣꠘꠤ ꠢꠣꠝꠣꠁꠀ ꠜꠞꠤꠎꠣꠞ, ꠔꠣꠞꠣ ꠖꠦꠈꠟꠣ ꠛꠠ ꠝꠍꠤꠛꠔ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK8_24","072_8_24","LUK","8","24","24","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠁꠍꠣꠞ ꠗꠣꠞꠅ ꠉꠤꠀ ꠔꠣꠘꠦ ꠢꠎꠣꠉ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠘꠥ ꠝꠞꠤꠎꠤꠞꠣꠝ।” ꠁꠍꠣ ꠃꠑꠤꠀ ꠙꠣꠘꠤꠞ ꠓꠦꠃ ꠀꠞ ꠛꠣꠔꠣꠡꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠟꠣ। ꠟꠉꠦ ꠟꠉꠦꠃ ꠓꠦꠃ ꠀꠞ ꠔꠥꠚꠣꠘ ꠕꠣꠝꠤꠀ ꠢꠇꠟꠔꠣ ꠕꠤꠞ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK8_25","072_8_25","LUK","8","25","25","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠅꠔꠣ ꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ?” ꠔꠣꠞꠣ ꠒꠞꠣꠁꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠀꠍꠟꠦ ꠇꠦ, ꠖꠦꠈꠞꠣꠄ ꠘꠤ ꠛꠣꠔꠣꠡꠦ ꠀꠞ ꠙꠣꠘꠤꠄꠅ ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK8_26","072_8_26","LUK","8","26","26","ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠟꠁꠀ ꠉꠣꠟꠤꠟ ꠀꠅꠞ ꠙꠣꠞ ꠅꠁꠀ ꠎꠦꠞꠣꠍꠤꠘꠤ ꠄꠟꠣꠇꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_27","072_8_27","LUK","8","27","27","ꠉꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠁꠘ ꠘꠣꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠉꠣꠃꠞ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠟꠣ ꠄꠇ ꠛꠦꠐꠣ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ। ꠎꠤꠘꠞ ꠙꠣꠟꠦ ꠀꠍꠞ ꠇꠞꠣꠄ ꠢꠦ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠟꠦꠝꠐꠣ ꠀꠞ ꠇꠥꠘꠥ ꠛꠣꠠꠤ-ꠊꠞꠅ ꠞꠁꠔ ꠘꠣ, ꠈꠣꠟꠤ ꠇꠛꠞꠡ꠆ꠕꠣꠘꠅ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("LK8_28","072_8_28","LUK","8","28","28","ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀꠃ ꠢꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠃꠑꠟ, ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠙꠠꠤꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟ, “ꠅ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠀꠙꠘꠦ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠁꠘꠅ ꠔꠡꠞꠤꠚ ꠀꠘꠟꠣ? ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠀꠝꠣꠞꠦ ꠍꠣꠔꠣꠁꠘ ꠘꠣ ꠎꠣꠘꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK8_29","072_8_29","LUK","8","29","29","ꠁꠈꠣꠘ ꠇꠅꠀꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠁꠍꠣꠄ ꠢꠤ ꠎꠤꠘꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ। ꠁ ꠎꠤꠘꠦ ꠔꠣꠞꠦ ꠛꠃꠔ ꠖꠤꠘ ꠕꠣꠇꠤ ꠀꠍꠞ ꠇꠞꠍꠤꠟ, ꠛꠦꠐꠣꠞꠦ ꠒꠣꠘ꠆ꠒꠣ-ꠛꠦꠠꠤ ꠀꠞ ꠡꠤꠇꠟꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠣꠈꠟꠦꠅ, ꠢꠦ ꠁꠔꠣ ꠍꠤꠠꠤꠟꠤꠔ, ꠢꠃ ꠎꠤꠘꠦ ꠔꠣꠞꠦ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠘꠤꠔꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK8_30","072_8_30","LUK","8","30","30","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠞ ꠘꠣꠝ ꠇꠤꠔꠣ?” ꠢꠦ ꠇꠁꠟ, “ꠚꠃꠎ ꠙꠣꠟ” ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠛꠃꠔ ꠎꠤꠘ ꠄꠇꠟꠉꠦ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK8_31","072_8_31","LUK","8","31","31","ꠔꠦꠃ ꠢꠤ ꠚꠃꠎ ꠙꠣꠟꠦ ꠁꠍꠣꠞꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠔꠣꠞꠣꠞꠦ ꠞꠡꠣꠔꠟꠦ ꠘꠣ ꠉꠣꠠꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK8_32","072_8_32","LUK","8","32","32","ꠢꠤꠘꠅ ꠙꠣꠠꠞ ꠄꠇ ꠉꠣꠟꠣꠔ ꠛꠠ ꠄꠇ ꠡꠥꠅꠞꠞ ꠙꠣꠟ ꠀꠍꠤꠟ। ꠚꠃꠎ ꠙꠣꠟꠦ ꠔꠣꠘꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠢꠃ ꠡꠥꠅꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠘꠤꠞ ꠁꠎꠣꠎꠔ ꠖꠤꠔꠣ। ꠔꠣꠁꠘ ꠁꠎꠣꠎꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_33","072_8_33","LUK","8","33","33","ꠅꠃ ꠔꠣꠞꠣ ꠢꠤ ꠛꠦꠐꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠡꠥꠅꠞꠞ ꠜꠤꠔꠞꠦ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟ, ꠄꠔꠦ ꠡꠥꠅꠞꠞ ꠙꠣꠟ ꠙꠣꠠꠞ ꠓꠣꠟꠦꠖꠤ ꠖꠃꠠꠤꠀ ꠉꠤꠀ ꠀꠅꠞꠞ ꠙꠣꠘꠤꠔ ꠛꠥꠠꠤꠀ ꠝꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_34","072_8_34","LUK","8","34","34","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠡꠥꠅꠞꠞ ꠞꠣꠈꠣꠟ ꠅꠇꠟ ꠖꠃꠠꠤꠀ ꠉꠤꠀ ꠐꠣꠃꠘꠅ ꠀꠞ ꠉꠣꠃꠄ ꠉꠣꠃꠄ ꠈꠛꠞ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK8_35","072_8_35","LUK","8","35","35","ꠈꠛꠞ ꠙꠣꠁꠀ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠘꠦ ꠝꠣꠘꠥꠡ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠎꠦ ꠛꠦꠐꠣꠞ ꠟꠉ ꠕꠣꠇꠤ ꠚꠃꠎ ꠙꠣꠟ ꠛꠣꠞ ꠅꠁꠀ ꠉꠦꠍꠂꠘ, ꠢꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠜꠣꠟꠣ ꠅꠁꠀ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠁꠍꠣꠞ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠁꠞꠁꠍꠦ। ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠌꠝꠇꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_36","072_8_36","LUK","8","36","36","ꠀꠞ ꠅꠃ ꠊꠐꠘꠣ ꠊꠐꠤꠔꠦ ꠎꠦꠞꠣ ꠖꠦꠈꠍꠤꠟ, ꠔꠣꠞꠣ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ, ꠁ ꠛꠦꠐꠣ ꠇꠤꠟꠣ ꠜꠣꠟꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK8_37","072_8_37","LUK","8","37","37","ꠢꠥꠘꠤꠀ ꠎꠦꠞꠣꠍꠤꠘꠤ ꠄꠟꠣꠇꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠒꠞꠣꠁꠉꠦꠟꠣ। ꠒꠞꠞ ꠌꠥꠐꠦ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠡꠞꠤꠚ ꠘꠤꠔꠣꠉꠤ। ꠔꠦꠃ ꠁꠍꠣ ꠘꠣꠅꠅ ꠃꠑꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠉꠣꠟꠤꠟꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_38","072_8_38","LUK","8","38","38","ꠅꠁꠟꠦ ꠎꠦ ꠛꠦꠐꠣꠞꠦ ꠎꠤꠘꠦ ꠗꠞꠍꠤꠟ, ꠢꠦ ꠀꠞꠎ ꠇꠞꠟ ꠔꠣꠘ ꠟꠉꠦ ꠞꠁꠛꠣꠞ ꠟꠣꠉꠤ। ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠅꠈꠣꠘ ꠇꠁꠀ ꠛꠣꠠꠤꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK8_39","072_8_39","LUK","8","39","39","ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠦ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠇꠞꠍꠂꠘ, ꠅꠔꠣ ꠉꠤꠀ ꠇꠅ।” ꠔꠦꠃ ꠢꠦ ꠉꠦꠟꠉꠤ, ꠉꠤꠀ ꠐꠣꠃꠘꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠣꠁꠟ, ꠁꠍꠣꠄ ꠔꠣꠞ ꠟꠣꠉꠤ ꠅꠔ ꠛꠠ ꠇꠣꠝ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK8_40","072_8_40","LUK","8","40","40","ꠁꠍꠣ ꠉꠣꠟꠤꠟꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠔꠣꠘ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK8_41","072_8_41","LUK","8","41","41","ꠅꠃ ꠡꠝꠄ ꠎꠣꠄꠁꠞ ꠘꠣꠝꠦ ꠝꠍꠤꠖ ꠇꠝꠤꠐꠤꠞ ꠄꠇ ꠝꠔꠟ꠆ꠟꠤ ꠀꠁꠀ ꠁꠍꠣꠞ ꠙꠣꠅ-ꠅ ꠙꠠꠤꠀ ꠝꠤꠘꠔ ꠟꠣꠉꠣꠁꠟꠣ, ꠢꠥꠎꠥꠞꠞꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK8_42","072_8_42","LUK","8","42","42","ꠇꠣꠞꠘ ꠔꠣꠘ ꠄꠇꠝꠣꠔ꠆ꠞ ꠙꠥꠠꠤ ꠍꠞꠈꠣꠔꠅ ꠀꠍꠤꠟ, ꠙꠥꠠꠤꠞ ꠛꠄꠅꠡ ꠛꠣꠞꠅ ꠛꠍꠞ। ꠁꠍꠣ ꠎꠦꠛꠟꠣ ꠅꠃ ꠛꠣꠠꠤꠔ ꠎꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠔꠣꠘ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠜꠤꠠ ꠇꠞꠤꠀ ꠑꠦꠟꠣꠑꠦꠟꠤ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_43","072_8_43","LUK","8","43","43","ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠄꠇ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡꠅ ꠀꠍꠟꠣ, ꠄꠁꠘ ꠛꠣꠞꠅ ꠛꠍꠞ ꠗꠞꠤꠀ ꠝꠣꠡꠤꠇ ꠛꠦꠝꠣꠞꠤ। ꠔꠣꠘ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠒꠣꠇ꠆ꠔꠞꠞ ꠔꠟꠦ ꠈꠥꠀꠁꠀꠅ ꠜꠣꠟꠣ ꠅꠁꠔꠣ ꠙꠣꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_44","072_8_44","LUK","8","44","44","ꠔꠣꠁꠘ ꠁꠍꠣꠞ ꠈꠞꠦꠖꠤ ꠀꠁꠀ ꠁꠍꠣꠞ ꠌꠣꠖ꠆ꠖꠞꠞ ꠇꠥꠘꠣꠔ ꠍꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠘ ꠛꠦꠝꠣꠞ ꠇꠝꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK8_45","072_8_45","LUK","8","45","45","ꠔꠦꠃ ꠁꠍꠣꠄ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠝꠣꠞꠦ ꠇꠦ ꠍꠁꠟ?” ꠇꠦꠃ ꠡ꠆ꠛꠤꠇꠣꠞ ꠘꠣ ꠇꠞꠣꠄ ꠙꠤꠔꠞ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠇꠔ ꠝꠣꠘꠡꠦ ꠑꠦꠟꠣꠑꠦꠟꠤ ꠇꠞꠤꠀ ꠀꠙꠘꠣꠞ ꠉꠣ’ꠔ ꠟꠣꠉꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK8_46","072_8_46","LUK","8","46","46","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠍꠁꠍꠦ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠛꠥꠎꠞꠣꠝ, ꠀꠝꠣꠞ ꠜꠤꠔꠞ ꠕꠣꠇꠤ ꠉꠣꠁꠛꠤ ꠛꠟ ꠛꠣꠞ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK8_47","072_8_47","LUK","8","47","47","ꠅꠃ ꠛꠦꠐꠤꠄ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟ ꠗꠞꠣ ꠙꠠꠤꠉꠦꠍꠦ, ꠔꠣꠁ ꠇꠣꠙꠤ ꠇꠣꠙꠤ ꠁꠍꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠔꠣꠘ ꠙꠣꠅ-ꠅ ꠙꠠꠤꠀ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦꠃ ꠇꠁꠟ, ꠇꠦꠘꠦ ꠔꠣꠁ ꠁꠍꠣꠞꠦ ꠍꠁꠍꠤꠟ ꠀꠞ ꠇꠤꠟꠣꠘ ꠟꠉꠦ ꠟꠉꠦꠃ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK8_48","072_8_48","LUK","8","48","48","ꠁꠍꠣꠄ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠁ ꠉ, ꠔꠥꠝꠤ ꠄꠇꠤꠘ ꠇꠞꠍ ꠇꠞꠤ ꠜꠣꠟꠣ ꠅꠁꠍ। ꠅꠈꠘ ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠣꠠꠤꠔ ꠎꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK8_49","072_8_49","LUK","8","49","49","ꠁꠍꠣꠄ ꠅꠔꠣ ꠝꠣꠔꠤꠞꠣ, ꠅꠝꠘ ꠡꠝꠄ ꠝꠍꠤꠖꠞ ꠝꠔꠟ꠆ꠟꠤꠞ ꠛꠣꠠꠤ ꠕꠣꠇꠤ ꠈꠛꠞꠤꠀ ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠇꠁꠟ, “ꠍꠣꠛ, ꠀꠙꠘꠣꠞ ꠙꠥꠠꠤ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠉꠦꠍꠂꠘꠉꠤ, ꠔꠦ ꠢꠥꠎꠥꠞꠞꠦ ꠀꠞ ꠇꠡ꠆ꠐ ꠖꠤꠛꠣꠞ ꠇꠣꠝ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK8_50","072_8_50","LUK","8","50","50","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ, ꠈꠣꠟꠤ ꠄꠇꠤꠘ ꠇꠞꠅ। ꠖꠦꠈꠛꠣꠄꠘꠦ, ꠔꠣꠁ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK8_51","072_8_51","LUK","8","51","51","ꠁꠍꠣ ꠢꠃ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠙꠤꠔꠞ, ꠢꠣꠘ꠆ꠘꠣꠘ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠙꠥꠠꠤꠞ ꠝꠣ-ꠛꠣꠚ ꠍꠣꠠꠣ ꠅꠁꠘ꠆ꠘ ꠇꠦꠃꠞꠞꠦ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠔꠦ ꠖꠤꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_52","072_8_52","LUK","8","52","52","ꠢꠇꠟꠦ ꠎꠦꠛꠟꠣ ꠙꠥꠠꠤꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠇꠣꠘ꠆ꠖꠤꠅ ꠘꠣ ꠞꠦ, ꠔꠣꠁ ꠔ ꠝꠞꠍꠦ ꠘꠣ, ꠊꠥꠝꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK8_53","072_8_53","LUK","8","53","53","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠍꠤꠠꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠎꠣꠘꠔ ꠙꠥꠠꠤ ꠝꠞꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK8_54","072_8_54","LUK","8","54","54","ꠔꠦꠃ ꠁꠍꠣꠄ ꠙꠥꠠꠤꠞ ꠀꠔꠅ ꠗꠞꠤꠀ ꠒꠣꠇ ꠖꠤꠟꠣ, “ꠝꠣꠁ ꠉ, ꠃꠑꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK8_55","072_8_55","LUK","8","55","55","ꠟꠉꠦ ꠟꠉꠦꠃ ꠙꠥꠠꠤꠞ ꠎꠣꠘ ꠚꠤꠞꠔ ꠀꠁꠟ। ꠔꠣꠁ ꠃꠑꠤꠀ ꠛꠁꠉꠦꠟ। ꠁꠍꠣꠄ ꠇꠁꠟꠣ, ꠙꠥꠠꠤꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠁꠛꠣꠞ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK8_56","072_8_56","LUK","8","56","56","ꠙꠥꠠꠤꠞ ꠝꠣ-ꠛꠣꠚ ꠄꠇ꠆ꠇꠦꠞꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ। ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠁꠔꠣ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK9_1","072_9_1","LUK","9","1","1","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠢꠃ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠤꠘ-ꠜꠥꠔ ꠍꠣꠠꠣꠘꠤ, ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠣꠞ ꠁꠎꠣꠎꠔ ꠀꠞ ꠈꠦꠝꠔꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_2","072_9_2","LUK","9","2","2","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠔꠛꠟꠤꠉ ꠀꠞ ꠛꠦꠝꠣꠞꠤꠘ꠆ꠔꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠣꠔ ꠄꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_3","072_9_3","LUK","9","3","3","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠙꠕꠞ ꠟꠣꠉꠤ ꠟꠣꠑꠤ, ꠉꠣꠁꠐ-ꠛꠥꠍꠇꠤ, ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤ, ꠐꠦꠇꠣ-ꠙꠄꠡꠣ, ꠛꠣ ꠖꠥꠁꠐꠣ ꠇꠥꠞ꠆ꠔꠣꠅ ꠟꠉꠦ ꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_4","072_9_4","LUK","9","4","4","ꠇꠥꠘꠥ ꠉꠣꠃꠔ ꠉꠦꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠦ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠛꠣꠄ, ꠅꠃ ꠛꠣꠠꠤꠔꠃ ꠞꠁꠅ, ꠀꠞ ꠅꠘ ꠕꠣꠇꠤ ꠢꠤꠞꠛꠣꠞ ꠛꠤꠖꠣꠄ ꠅꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LK9_5","072_9_5","LUK","9","5","5","ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠉꠣ ꠘꠣ ꠖꠦꠁꠘ, ꠔꠦ ꠢꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠛꠣꠞ ꠀꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅꠞ ꠗꠥꠁꠟ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠅ, ꠅꠃ ꠗꠥꠁꠟꠦꠃ ꠔꠣꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK9_6","072_9_6","LUK","9","6","6","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠉꠣꠃꠄ ꠉꠣꠃꠄ ꠉꠤꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠀꠞ ꠛꠦꠝꠣꠞꠤꠘ꠆ꠔꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_7","072_9_7","LUK","9","7","7","ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠦ ꠁꠍꠣꠞ ꠅꠃ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠈꠥꠛ ꠊꠣꠛꠠꠤ ꠉꠦꠟꠣ। ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, ꠄꠢꠤꠀ ꠘꠛꠤ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠤ ꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK9_8","072_9_8","LUK","9","8","8","ꠀꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠇꠁꠟꠣ, ꠁꠟꠤꠀꠍ ꠘꠛꠤꠄ ꠖꠞꠡꠘ ꠖꠤꠍꠂꠘ। ꠢꠤꠞꠛꠣꠞ ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, ꠙꠥꠞꠣꠘꠣ ꠎꠝꠣꠘꠣꠞ ꠇꠥꠘꠥ ꠘꠛꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠀꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK9_9","072_9_9","LUK","9","9","9","ꠔꠦꠃ ꠢꠦꠞꠥꠖꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠘꠤꠎꠦꠃ ꠔ ꠄꠢꠤꠀꠞ ꠝꠣꠕꠣ ꠇꠣꠐꠣꠁꠍꠤ, ꠔꠦ ꠅꠃ ꠎꠦꠔꠣ ꠢꠥꠘꠞꠣꠝ, ꠄꠁꠘ ꠀꠍꠟꠦ ꠇꠦ?” ꠄꠞꠖꠣꠄ ꠢꠦꠞꠥꠖꠦ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠈꠤꠀꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK9_10","072_9_10","LUK","9","10","10","ꠁꠍꠣꠄ ꠎꠦ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠔꠛꠟꠤꠉꠅ ꠙꠣꠑꠣꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ, ꠔꠛꠟꠤꠉꠤ ꠍꠚꠞꠅ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠟꠁꠀ ꠈꠥꠛ ꠘꠤꠞꠤꠛꠤꠟꠤ ꠢꠣꠟꠔꠦ ꠛꠣꠄꠔ-ꠍꠄꠖꠣ ꠘꠣꠝꠞ ꠄꠇ ꠉꠣꠃꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_11","072_9_11","LUK","9","11","11","ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠁ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠖꠟꠦ ꠖꠟꠦ ꠁꠍꠣꠞ ꠈꠞꠦ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠈꠥꠡꠤ ꠝꠘꠦ ꠇꠛꠥꠟ ꠇꠞꠟꠣ। ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠛꠄꠀꠘꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ꠀꠞ ꠎꠦꠔꠣ ꠛꠦꠝꠣꠞꠤꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠅꠀ ꠎꠞꠥꠞ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_12","072_9_12","LUK","9","12","12","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠢꠃ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠎꠦ ꠎꠣꠉꠣꠔ ꠀꠍꠤ, ꠁꠈꠣꠘ ꠈꠥꠛ ꠘꠤꠞꠤꠛꠤꠟꠤ ꠎꠣꠉꠣ। ꠔꠦ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ, ꠔꠣꠞꠣ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠉꠣꠃꠔ ꠉꠤꠀ ꠞꠣꠁꠔꠇꠥꠞ ꠕꠣꠇꠣ-ꠈꠣꠅꠀꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("LK9_13","072_9_13","LUK","9","13","13","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠈꠣꠘꠣ ꠈꠣꠅꠀꠅ।” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠈꠣꠟꠤ ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤ, ꠖꠥꠁꠐꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍ ꠀꠍꠦ, ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ। ꠔꠦ ꠀꠝꠞꠣ ꠛꠣꠎꠣꠞꠅ ꠉꠤꠀ ꠄꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠣ ꠟꠁꠀ ꠀꠘꠔꠣꠝ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK9_14","072_9_14","LUK","9","14","14","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠄꠞꠣꠞꠦ ꠙꠁꠘ꠆ꠌꠣꠡ-ꠎꠘ, ꠙꠁꠘ꠆ꠌꠣꠡ-ꠎꠘ ꠇꠞꠤ ꠛꠅꠀꠁ ꠖꠦꠅ।” ꠁꠘꠅ ꠈꠣꠟꠤ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡꠃ ꠀꠍꠟꠣ ꠙꠣꠌ ꠀꠎꠣꠞꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("LK9_15","072_9_15","LUK","9","15","15","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_16","072_9_16","LUK","9","16","16","ꠁꠍꠣꠄ ꠅꠃ ꠙꠣꠌꠅꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠞ ꠖꠥꠁꠅ ꠝꠣꠍ ꠟꠁꠀ ꠀꠍꠝꠣꠘꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ꠛꠣꠖꠦ ꠞꠥꠐꠤ ꠀꠞ ꠝꠣꠍ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤ ꠜꠣꠋꠉꠤꠀ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠀꠔꠅ ꠖꠤꠀ ꠇꠁꠟꠣ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_17","072_9_17","LUK","9","17","17","ꠅꠃ ꠈꠣꠘꠣꠄ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠙꠦꠐ ꠜꠞꠤꠀ ꠈꠣꠁꠟꠣ। ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠎꠦꠔꠣ ꠉꠥꠠꠣ-ꠉꠣꠠꠣ ꠞꠁꠍꠤꠟ ꠅꠔꠣ ꠖꠟꠣ ꠇꠞꠟꠦ ꠛꠣꠞꠅ ꠐꠥꠇꠞꠤ ꠜꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK9_18","072_9_18","LUK","9","18","18","ꠄꠇꠖꠤꠘ ꠁꠍꠣ ꠄꠇ ꠘꠤꠞꠣꠁ ꠎꠣꠉꠣꠔ ꠖꠥꠀ ꠇꠞꠣꠔ ꠛꠁꠞꠣ, ꠈꠣꠟꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠔꠣꠘ ꠟꠉꠦ ꠀꠍꠟꠣ। ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠝꠣꠘꠡꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠀꠝꠤ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK9_19","072_9_19","LUK","9","19","19","ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠇꠂꠘ, ꠀꠙꠘꠦ ꠄꠢꠤꠀ ꠘꠛꠤ। ꠇꠥꠘꠥ ꠎꠘꠦ ꠇꠂꠘ ꠁꠟꠤꠀꠍ ꠘꠛꠤ, ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠇꠄ ꠛꠃꠔ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠇꠥꠘꠥ ꠘꠛꠤ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK9_20","072_9_20","LUK","9","20","20","ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞ, ꠀꠝꠤ ꠇꠦ?” ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK9_21","072_9_21","LUK","9","21","21","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠈꠛꠞꠖꠣꠞ! ꠁꠔꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK9_22","072_9_22","LUK","9","22","22","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦ ꠛꠃꠔ ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠣ ꠟꠣꠉꠛ। ꠡꠝꠣꠎꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ, ꠛꠠ ꠁꠝꠣꠝ, ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠀꠝꠣꠞꠦ ꠄꠟꠣ ꠇꠞꠛꠣ। ꠀꠝꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠀꠝꠣꠞ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣ ꠎꠞꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK9_23","072_9_23","LUK","9","23","23","ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠔꠞꠤꠇꠣꠄ ꠇꠦꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔꠦ ꠌꠣꠁꠟꠦ, ꠢꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠌꠟꠣ ꠛꠣꠖ ꠖꠦꠃꠇ। ꠔꠣꠞ ꠀꠙꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠁꠀ ꠟꠁꠀ ꠀꠝꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠀꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LK9_24","072_9_24","LUK","9","24","24","ꠎꠦ ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ ꠌꠣꠄ, ꠢꠦ ꠔꠣꠞ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠥꠀꠁꠛ। ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠄ, ꠢꠦ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK9_25","072_9_25","LUK","9","25","25","ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠎꠥꠖꠤ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠟꠤꠇ ꠛꠘꠤꠀꠅ ꠔꠣꠞ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠝꠣꠘꠤ ꠀꠈꠦꠞ ꠈꠥꠀꠁꠟꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠟ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK9_26","072_9_26","LUK","9","26","26","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠛꠣ ꠀꠝꠣꠞ ꠔꠣꠟꠤꠝꠞ ꠟꠣꠉꠤꠀ ꠝꠥꠈ ꠟꠥꠇꠣꠄ, ꠔꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞ ꠘꠤꠎꠞ, ꠀꠞ ꠙꠛꠤꠔ꠆ꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ, ꠀꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤꠄ ꠖꠥꠘꠤꠀꠔ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤꠅ ꠄꠞꠣꠞꠦ ꠖꠦꠈꠟꠦ ꠝꠥꠈ ꠟꠥꠇꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LK9_27","072_9_27","LUK","9","27","27","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠅꠃ ꠝꠎꠟꠤꠍꠅ ꠅꠃꠟꠣ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠎꠤꠞ ꠀꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠘꠣ ꠖꠦꠈꠤꠀ ꠄꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK9_28","072_9_28","LUK","9","28","28","ꠅꠃ ꠔꠣꠟꠤꠝꠞ ꠄꠇꠖ ꠢꠣꠙ꠆ꠔꠣ ꠛꠣꠖꠦ, ꠁꠍꠣ ꠖꠥꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞ, ꠢꠣꠘ꠆ꠘꠣꠘ, ꠀꠞ ꠁꠀꠇꠥꠛꠞꠦ ꠟꠁꠀ ꠄꠇ ꠐꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_29","072_9_29","LUK","9","29","29","ꠔꠣꠁꠘ ꠖꠥꠀ ꠇꠞꠞꠣ, ꠅꠝꠘ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠔꠣꠘ ꠝꠥꠈꠞ ꠞꠋꠉ ꠛꠖꠟꠤꠉꠦꠟ, ꠔꠣꠘ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠟꠣ ꠌꠇꠌꠇꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK9_30","072_9_30","LUK","9","30","30","ꠅꠃ ꠡꠝꠄ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠖꠥꠁꠎꠘ ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠔꠣꠘ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠞꠣ, ꠄꠞꠣꠞ ꠄꠇꠎꠘ ꠅꠁꠟꠣ ꠝꠥꠍꠣ ꠘꠛꠤ, ꠖꠥꠍꠞꠣ ꠎꠘ ꠁꠟꠤꠀꠍ ꠘꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("LK9_31","072_9_31","LUK","9","31","31","ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠁ ꠎꠣꠟꠣꠟ ꠀꠞ ꠡꠣꠘꠦ ꠖꠦꠈꠣ ꠖꠤꠟꠣ। ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠍꠚꠞꠞ ꠇꠣꠟꠅ ꠁꠍꠣ ꠎꠦꠘ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠝꠃꠔꠞ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠅꠁꠞꠣ, ꠅꠃ ꠛꠦꠙꠣꠞꠦꠃ ꠔꠣꠞꠣ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_32","072_9_32","LUK","9","32","32","ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠅꠇꠟ ꠛꠦꠝꠣꠟꠥꠝ ꠊꠥꠝꠅ ꠀꠍꠟꠣ। ꠀꠈꠔꠣꠃ ꠊꠥꠝ ꠜꠣꠋꠉꠤ ꠎꠣꠅꠀꠄ ꠔꠣꠞꠣ ꠁꠍꠣꠞ ꠎꠣꠟꠣꠟ-ꠡꠣꠘ ꠖꠦꠈꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠃꠛꠣ ꠅꠃ ꠖꠥꠁꠅ ꠎꠘꠞꠦꠅ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_33","072_9_33","LUK","9","33","33","ꠢꠃ ꠖꠥꠁꠅꠎꠘ ꠎꠦꠛꠟꠣ ꠁꠍꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠅ ꠔ ꠅꠘꠅ ꠀꠍꠤ, ꠈꠥꠛ ꠜꠣꠟꠣ ꠅꠁꠍꠦ, ꠔꠦ ꠄꠇ ꠇꠣꠝ ꠇꠞꠤꠟꠣꠁ, ꠀꠝꠞꠣ ꠅꠘꠅ ꠔꠤꠘꠈꠣꠘ ꠒꠦꠞꠣ-ꠊꠞ ꠛꠣꠘꠣꠁꠟꠣꠁ, ꠄꠇꠈꠣꠘ ꠀꠙꠘꠣꠞ, ꠄꠇꠈꠣꠘ ꠁꠟꠤꠀꠍ ꠘꠛꠤ, ꠀꠞ ꠄꠇꠈꠣꠘ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠟꠣꠉꠤ।” ꠙꠤꠔꠞꠦ ꠎꠦꠘ ꠇꠤꠔꠣ ꠇꠁꠞꠣ, ꠁꠔꠣ ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠛꠥꠎꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_34","072_9_34","LUK","9","34","34","ꠙꠤꠔꠞꠦ ꠅꠔꠣ ꠝꠣꠔꠤꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠝꠦꠊꠞ ꠇꠣꠟꠘꠤ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠉꠥꠞꠤꠟꠤꠟ। ꠔꠣꠞꠣ ꠇꠣꠟꠘꠤꠞ ꠀꠅꠠꠦ ꠢꠣꠝꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠒꠞꠣꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_35","072_9_35","LUK","9","35","35","ꠀꠞ ꠇꠣꠟꠘꠤꠞ ꠜꠤꠔꠞ ꠕꠣꠇꠤ ꠅꠃ ꠀꠅꠀꠎ ꠀꠁꠟ, “ꠄꠁꠘꠃ ꠀꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠔꠥꠝꠞꠣ ꠄꠘ ꠇꠕꠣ ꠝꠣꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK9_36","072_9_36","LUK","9","36","36","ꠁ ꠀꠅꠀꠎꠞ ꠛꠣꠖꠦꠃ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠁꠍꠣ ꠢꠘꠅ ꠄꠇꠟꠣ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠘꠤꠞꠣꠁ ꠅꠁꠉꠦꠟꠣ, ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠖꠦꠈꠍꠤꠟꠣ ꠅꠃ ꠡꠝꠄ ꠁꠔꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_37","072_9_37","LUK","9","37","37","ꠛꠣꠖꠞ ꠖꠤꠘ ꠁꠍꠣ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠙꠣꠠꠞ ꠐꠤꠟ꠆ꠟꠣ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠦ, ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠀꠁꠀ ꠜꠤꠠ ꠛꠣꠘ꠆ꠖꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_38","072_9_38","LUK","9","38","38","ꠅꠃ ꠜꠤꠠꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠙꠥꠀꠉꠥꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠅꠉꠥ ꠀꠝꠣꠞ ꠄꠇꠝꠣꠔ꠆ꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("LK9_39","072_9_39","LUK","9","39","39","ꠔꠣꠞꠦ ꠄꠇꠐꠣ ꠎꠤꠘꠦ ꠗꠞꠦ, ꠁꠉꠤꠄ ꠔꠣꠞꠦ ꠍꠣꠠꠔ ꠌꠣꠄ ꠘꠣ, ꠢꠦ ꠀꠈꠔꠣꠃ ꠌꠤꠇ ꠖꠤꠀ ꠃꠑꠦ ꠀꠞ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀ ꠍꠣꠐꠤꠀꠄ। ꠔꠣꠞ ꠝꠥꠈꠦꠖꠤ ꠚꠦꠘꠣ ꠛꠣꠞꠅꠄ, ꠢꠦꠡꠦ ꠔꠣꠞꠦ ꠀꠍꠣꠠꠤꠀ ꠀꠗ-ꠝꠞꠣ ꠇꠞꠤ ꠚꠣꠟꠣꠁ ꠕꠁꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK9_40","072_9_40","LUK","9","40","40","ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠍꠟꠣꠝ ꠅꠉꠥꠔꠣꠞꠦ ꠈꠦꠖꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠙꠣꠞꠍꠂꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK9_41","072_9_41","LUK","9","41","41","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠛꠦꠁꠝꠣꠘ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠎꠣꠔ, ꠀꠝꠤ ꠀꠞ ꠇꠔꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠍꠣꠔꠣꠘꠤ ꠡꠁꠎ꠆ꠎ ꠇꠞꠝꠥ? ꠖꠦꠈꠤ ꠌꠣꠁꠘ, ꠔꠥꠝꠣꠞ ꠙꠥꠀꠞꠦ ꠅꠘꠅ ꠀꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK9_42","072_9_42","LUK","9","42","42","ꠛꠦꠐꠣꠄ ꠙꠥꠀꠞꠦ ꠟꠁꠀ ꠀꠉꠥꠀꠞ, ꠅꠃ ꠡꠝꠄ ꠎꠤꠘ꠆ꠘꠣꠔꠦ ꠔꠣꠞꠦ ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠔꠤꠀ ꠗꠞꠟ, ꠢꠦ ꠢꠥꠔꠤꠀ ꠍꠣꠐꠤꠀꠘꠤ ꠟꠣꠉꠣꠁꠟ। ꠔꠦꠃ ꠁꠍꠣꠄ ꠎꠤꠘ꠆ꠘꠣꠔꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠅꠃ ꠙꠥꠀꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠤꠀ ꠔꠣꠞ ꠛꠣꠚꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_43","072_9_43","LUK","9","43","43","ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ꠁꠍꠣꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ-ꠇꠣꠎ ꠖꠦꠈꠤꠀ ꠢꠇ꠆ꠇꠟꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠀ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK9_44","072_9_44","LUK","9","44","44","“ꠀꠝꠣꠞ ꠇꠕꠣ ꠈꠣꠘꠣꠁꠘ ꠔꠥꠝꠞꠣ ꠝꠘ ꠖꠤꠀ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠔ ꠝꠣꠘꠡꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK9_45","072_9_45","LUK","9","45","45","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠁ ꠝꠣꠔꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠤ ꠛꠥꠎꠟꠣ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠁꠈꠣꠘ ꠉꠣꠁꠛ ꠞꠣꠈꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠘꠣ ꠛꠥꠎꠂꠘ। ꠀꠞ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠁꠍꠣꠞꠦꠅ ꠇꠥꠘ꠆ꠔꠣ ꠎꠤꠇꠣꠁꠔꠦ ꠔꠣꠞꠣꠞ ꠡꠣꠅꠡ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_46","072_9_46","LUK","9","46","46","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠇꠦ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ, ꠅꠔꠣ ꠟꠁꠀ ꠔꠣꠞꠣ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠇꠞꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("LK9_47","072_9_47","LUK","9","47","47","ꠄꠞꠝꠣꠎꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠜꠣꠛ ꠛꠥꠎꠤꠟꠤꠟꠣ। ꠔꠣꠁꠘ ꠄꠇ ꠘꠣꠛꠣꠟꠤꠇ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠘꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK9_48","072_9_48","LUK","9","48","48","“ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠍꠣꠛꠣꠟꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠀꠝꠣꠞꠦꠃ ꠇꠛꠥꠟ ꠇꠞꠦ। ꠀꠞ ꠀꠝꠣꠞꠦ ꠎꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠈꠣꠟꠤ ꠀꠝꠣꠞꠦ ꠘꠣꠄ, ꠀꠝꠣꠞꠦ ꠎꠦꠁꠘ ꠛꠦꠎꠤꠍꠂꠘ ꠔꠣꠘꠞꠦꠅ ꠇꠛꠥꠟ ꠇꠞꠟ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦ ꠎꠘ ꠢꠇꠟ ꠕꠣꠇꠤ ꠢꠥꠞꠥ, ꠢꠦ-ꠃ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ।” ");
INSERT INTO syls_vpl VALUES ("LK9_49","072_9_49","LUK","9","49","49","ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠖꠦꠈꠟꠣꠝ ꠀꠙꠘꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠄꠇꠎꠘꠦ ꠜꠥꠔ ꠍꠣꠠꠣꠞ। ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠔꠣꠞꠦ ꠝꠣꠘꠣ ꠇꠞꠍꠤ, ꠢꠦ ꠔ ꠀꠝꠞꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK9_50","072_9_50","LUK","9","50","50","ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠞ ꠝꠣꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠘꠣꠄ, ꠢꠦ ꠔ ꠙꠇ꠆ꠇꠦꠃ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK9_51","072_9_51","LUK","9","51","51","ꠁꠍꠣꠄ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠡꠞꠤꠚ ꠘꠤꠛꠣꠞ ꠖꠤꠘ ꠊꠘꠣꠁꠀ ꠀꠁꠟ, ꠅꠃ ꠔꠣꠁꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠁꠔꠣ ꠇꠞꠤ ꠘꠤꠅꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_52","072_9_52","LUK","9","52","52","ꠔꠣꠘ ꠀꠉꠦ ꠅꠁꠀ ꠈꠛꠞꠤꠀ ꠅꠇꠟ ꠙꠣꠑꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠀꠉꠦ ꠉꠤꠀ ꠢꠇꠟꠔꠣ ꠎꠥꠁꠔ-ꠎꠣꠁꠔ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠡꠝꠞꠤꠀ ꠎꠣꠔꠤꠞ ꠄꠇ ꠉꠣꠃꠔ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_53","072_9_53","LUK","9","53","53","ꠅꠁꠟꠦ ꠢꠤ ꠉꠣꠃꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣ, ꠁꠍꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠎꠣꠁꠔꠣ, ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠀꠡꠞꠄ ꠖꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK9_54","072_9_54","LUK","9","54","54","ꠄꠞꠖꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠁꠀꠇꠥꠛ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣꠅ ꠅꠈꠘ ꠀꠞꠎ ꠇꠞꠔꠣꠝ ꠘꠤ, ꠀꠍꠝꠣꠘꠤ ꠀꠉꠥꠁꠘ ꠟꠣꠝꠤꠀ ꠅꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠃꠇ?” ");
INSERT INTO syls_vpl VALUES ("LK9_55","072_9_55","LUK","9","55","55","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠀ ꠗꠣꠝꠇꠤ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ ꠔꠥꠝꠞꠣ ꠇꠥꠘ ꠟꠣꠈꠣꠘ ꠞꠥꠢꠥꠞ ꠉꠠꠣ? ꠀꠝꠣꠞꠦ ꠇꠥꠘꠥ ꠛꠦꠎꠣ ꠅꠁꠍꠦ ꠘꠤ ꠝꠣꠘꠡꠞ ꠛꠤꠘꠣꠡ ꠇꠞꠔꠣꠝ? ꠀꠝꠣꠞꠦ ꠔ ꠛꠦꠎꠣ ꠅꠁꠍꠦ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK9_56","072_9_56","LUK","9","56","56","ꠅꠈꠣꠘ ꠇꠁꠀ ꠄꠞꠣ ꠀꠞꠇ ꠉꠣꠃꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK9_57","072_9_57","LUK","9","57","57","ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠙꠕꠦꠖꠤ ꠎꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠛꠦꠐꠣ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟ, “ꠍꠣꠛ, ꠀꠙꠘꠦ ꠎꠦꠈꠣꠘꠅ ꠎꠣꠁꠛꠣ, ꠀꠝꠤꠅ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠢꠘꠅ ꠎꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK9_58","072_9_58","LUK","9","58","58","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣꠞꠦ, ꠢꠤꠀꠟꠞ ꠉꠣꠔ ꠀꠍꠦ, ꠙꠣꠈꠤꠘ꠆ꠔꠞ ꠛꠣꠖꠣ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠝꠣꠕꠣ ꠉꠥꠎꠣꠞ ꠇꠥꠘꠥ ꠑꠣꠁ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK9_59","072_9_59","LUK","9","59","59","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠀꠞꠇ ꠎꠘꠞꠦ ꠖꠦꠈꠟꠣ, ꠖꠦꠈꠤꠀ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠌꠟꠅ।” ꠢꠦ ꠎꠥꠀꠙ ꠖꠤꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠔꠣꠘꠞꠦ ꠝꠣꠐꠤ ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠀꠝꠤ ꠀꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK9_60","072_9_60","LUK","9","60","60","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠞꠣ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠝꠞꠣꠞꠦ ꠝꠣꠐꠤ ꠖꠦꠃꠇ, ꠔꠥꠝꠤ ꠀꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠖꠣꠅꠔ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK9_61","072_9_61","LUK","9","61","61","ꠀꠞꠅ ꠄꠇꠎꠘꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠎꠣꠁꠝꠥ, ꠔꠦ ꠀꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠀꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK9_62","072_9_62","LUK","9","62","62","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠟꠣꠋꠉꠟꠞ ꠈꠥꠐꠤꠔ ꠗꠞꠤꠀ ꠎꠦꠉꠥꠄ ꠈꠞꠦꠖꠤ ꠚꠤꠞꠤꠀ ꠌꠣꠄ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠟꠣꠈ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK10_1","072_10_1","LUK","10","1","1","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠞꠅ ꠡꠔ꠆ꠔꠁꠞꠎꠘ ꠡꠣꠉꠞꠤꠖꠞꠦ ꠔꠛꠟꠤꠉꠅ ꠙꠣꠑꠣꠁꠔꠣ ꠇꠞꠤ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠎꠦꠔꠣ ꠐꠣꠃꠘ ꠛꠣ ꠉꠣꠃꠀꠁꠘ꠆ꠔꠅ ꠎꠣꠅꠀꠞ ꠁꠞꠣꠖꠣ ꠇꠞꠍꠤꠟꠣ, ꠢꠘꠅ ꠎꠣꠁꠛꠣꠞ ꠀꠉꠦ ꠄꠞꠣꠞꠦ ꠖꠥꠁꠎꠘ ꠖꠥꠁꠎꠘ ꠇꠞꠤꠀ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK10_2","072_10_2","LUK","10","2","2","ꠙꠣꠑꠣꠘꠤꠞ ꠛꠣꠟꠣ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠎꠝꠤꠘꠅ ꠔ ꠚꠡꠟ ꠛꠃꠔ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠇꠣꠝꠟꠣ ꠈꠥꠛ ꠇꠝ। ꠄꠞꠟꠣꠉꠤ ꠎꠝꠤꠘꠞ ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍꠦ ꠖꠥꠀ ꠇꠞꠅ, ꠔꠣꠘ ꠚꠡꠟ ꠔꠥꠟꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠇꠣꠝꠟꠣ ꠙꠣꠑꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK10_3","072_10_3","LUK","10","3","3","ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠞꠅꠀꠘꠣ ꠅꠁꠎꠣꠅ। ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠛꠣꠊꠞ ꠙꠣꠟꠞ ꠝꠣꠎꠦ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK10_4","072_10_4","LUK","10","4","4","ꠔꠥꠝꠞꠣ ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠐꠦꠇꠣꠞ ꠕꠟꠤ, ꠉꠣꠁꠐ-ꠛꠥꠍꠇꠤ, ꠙꠣꠅꠞ ꠎꠥꠔꠣ ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠟꠉꠦ ꠘꠤꠅ ꠘꠣ, ꠀꠞ ꠙꠕꠞ ꠝꠣꠎꠦ ꠇꠦꠃꠞꠞꠦ ꠍꠣꠟꠣꠝꠅ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK10_5","072_10_5","LUK","10","5","5","ꠎꠦ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠛꠣꠄ, ꠢꠣꠝꠣꠁꠀꠃ ꠇꠁꠅ, ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ। ");
INSERT INTO syls_vpl VALUES ("LK10_6","072_10_6","LUK","10","6","6","ꠍꠣꠟꠣꠝ ꠟꠅꠀꠞ ꠎꠥꠇꠣ ꠇꠦꠃ ꠢꠤꠘꠅ ꠕꠣꠇꠟꠦ, ꠔꠥꠝꠞꠣꠞ ꠍꠣꠟꠣꠝ ꠔꠣꠞ ꠃꠙꠞꠦ ꠛꠞ꠆ꠔꠤꠛ, ꠀꠞ ꠁꠟꠣ ꠇꠦꠃ ꠘꠣ ꠕꠣꠇꠟꠦ, ꠔꠥꠝꠞꠣꠞ ꠍꠣꠟꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦꠃ ꠚꠤꠞꠔ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK10_7","072_10_7","LUK","10","7","7","ꠙꠄꠟꠣ ꠎꠦ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠛꠣꠄ, ꠢꠃ ꠛꠣꠠꠤꠔꠃ ꠞꠁꠅ। ꠁ ꠛꠣꠠꠤ ꠍꠣꠠꠤꠀ ꠖꠥꠍꠞꠣ ꠛꠣꠠꠤꠔ ꠎꠣꠁꠅ ꠘꠣ। ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠖꠦꠁꠘ ꠅꠔꠣ ꠈꠣꠁꠅ, ꠇꠣꠞꠘ ꠇꠣꠝꠟꠣꠄ ꠔꠣꠞ ꠛꠦꠔꠘ ꠙꠣꠅꠀꠞ ꠎꠁꠉ꠆ꠉ। ");
INSERT INTO syls_vpl VALUES ("LK10_8","072_10_8","LUK","10","8","8","“ꠎꠦꠛꠟꠣ ꠇꠥꠘꠥ ꠉꠣꠃꠔ ꠎꠣꠁꠛꠣꠄ, ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠤꠀ, ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠈꠣꠁꠔꠦ ꠖꠦꠁꠘ, ꠅꠔꠣꠃ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LK10_9","072_10_9","LUK","10","9","9","ꠔꠣꠞꠣꠞ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞ ꠛꠦꠝꠣꠞ ꠜꠣꠟꠣ ꠇꠞꠤꠅ। ꠔꠣꠞꠣꠞꠦ ꠇꠁꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠔꠥꠝꠞꠣꠞ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK10_10","072_10_10","LUK","10","10","10","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠉꠣꠃꠔ ꠉꠦꠟꠦ ꠢꠘꠞ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠘꠣ ꠇꠞꠂꠘ, ꠔꠦ ꠉꠣꠃꠔ ꠀꠐꠤ ꠀꠐꠤ ꠅꠈꠣꠘ ꠇꠁꠅ, ");
INSERT INTO syls_vpl VALUES ("LK10_11","072_10_11","LUK","10","11","11","ꠢꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠉꠣꠃꠞ ꠎꠦ ꠗꠥꠁꠟ ꠀꠝꠞꠣꠞ ꠙꠣꠅꠔ ꠟꠣꠉꠍꠦ, ꠁꠔꠣ ꠀꠝꠞꠣ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠞꠣꠝ, ꠅꠃ ꠗꠥꠁꠟꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛ। ꠅꠁꠟꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK10_12","072_10_12","LUK","10","12","12","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠟꠣꠘ꠆ꠘꠔꠤ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘꠞ ꠖꠡꠣ ꠕꠣꠇꠤ, ꠢꠤ ꠉꠣꠃꠞ ꠖꠡꠣ ꠀꠞꠅ ꠇꠑꠤꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK10_13","072_10_13","LUK","10","13","13","“ꠢꠣꠄꠞꠦ ꠛꠣꠄꠔ-ꠍꠄꠖꠣ ꠀꠞ ꠈꠥꠞꠣꠍꠤꠘ ꠉꠣꠃ, ꠔꠥꠝꠞꠣ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠡꠥꠞ ꠀꠞ ꠍꠤꠖꠘ ꠄꠟꠣꠇꠣꠔ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠟꠦ, ꠔꠣꠞꠣ ꠇꠣꠔꠞ ꠅꠁꠀ ꠔꠃꠛꠣ ꠇꠞꠟ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("LK10_14","072_10_14","LUK","10","14","14","ꠀꠍꠟꠦ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠡꠥꠞ ꠀꠞ ꠍꠤꠖꠘ ꠄꠟꠣꠇꠣꠞ ꠖꠡꠣ ꠕꠣꠇꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠖꠡꠣ ꠛꠃꠔ ꠇꠑꠤꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK10_15","072_10_15","LUK","10","15","15","ꠀꠞ ꠅ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘ, ꠔꠥꠝꠤ ꠛꠥꠟꠦ ꠃꠌꠣ ꠅꠁꠀ ꠀꠍꠝꠣꠘꠅ ꠉꠤꠀ ꠟꠣꠉꠔꠣꠄ? ꠘꠣ, ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ! ꠔꠥꠝꠣꠞꠦ ꠙꠣꠔꠣꠟꠅ ꠟꠣꠝꠣꠁꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK10_16","072_10_16","LUK","10","16","16","“ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠦ, ꠔꠣꠞꠣ ꠀꠍꠟꠦ ꠀꠝꠣꠞ ꠇꠕꠣꠃ ꠝꠣꠘꠦ। ꠀꠞ ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠘꠦ ꠘꠣ, ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦꠅ ꠝꠣꠘꠦ ꠘꠣ। ꠎꠦꠞꠣ ꠀꠝꠣꠞꠦ ꠝꠣꠘꠦ ꠘꠣ, ꠔꠣꠞꠣ ꠀꠍꠟꠦ ꠢꠃ ꠀꠟ꠆ꠟꠣꠞꠦꠅ ꠝꠣꠘꠦ ꠘꠣ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK10_17","072_10_17","LUK","10","17","17","ꠛꠣꠖꠦ ꠢꠤ ꠡꠔ꠆ꠔꠁꠞꠎꠘ ꠡꠣꠉꠞꠤꠖꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠈꠥꠛ ꠈꠥꠡ ꠝꠤꠎꠣꠎꠦ ꠚꠤꠞꠔ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠘꠣꠝ ꠢꠥꠘꠟꠦ ꠎꠤꠘ-ꠜꠥꠔꠦꠅ ꠀꠝꠞꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK10_18","072_10_18","LUK","10","18","18","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠖꠦꠈꠍꠤ, ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘ ꠝꠦꠊꠞ ꠎꠤꠟꠇꠤꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠙꠠꠤꠎꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LK10_19","072_10_19","LUK","10","19","19","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠚ-ꠛꠤꠌ꠆ꠍꠥꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠣꠞ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠤ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ, ꠁꠛꠟꠤꠍꠞ ꠢꠇꠟ ꠡꠇ꠆ꠔꠤꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠤ। ꠇꠥꠘꠥꠎꠣꠔ ꠇꠥꠘ꠆ꠔꠣꠄꠃ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK10_20","072_10_20","LUK","10","20","20","ꠀꠞ ꠎꠤꠘ-ꠜꠥꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠦꠞ ꠖꠦꠈꠤꠀ ꠈꠥꠡꠤ ꠘꠣ ꠅꠁꠀ, ꠛꠞꠋ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠈꠣꠔꠣꠔ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠝ ꠟꠦꠈꠣ ꠅꠁꠍꠦ ꠇꠞꠤꠃ ꠈꠥꠡꠤ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK10_21","072_10_21","LUK","10","21","21","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠅ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠅ ꠉꠣꠁꠛꠤ ꠛꠣꠛꠣ, ꠔꠥꠝꠤꠃ ꠔ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠝꠣꠟꠤꠇ। ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠞꠣꠝ, ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠀꠈꠟꠖꠣꠞ-ꠛꠥꠖ꠆ꠖꠤꠝꠣꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠎꠣꠁꠞ ꠘꠣ ꠇꠞꠤꠀ, ꠛꠦꠛꠥꠎ-ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠍ। ꠛꠣꠛꠣ, ꠀꠍꠟꠦ ꠔ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ। ");
INSERT INTO syls_vpl VALUES ("LK10_22","072_10_22","LUK","10","22","22","ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠛꠣꠄ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠍꠂꠘ। ꠛꠣꠚ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠎꠣꠘꠦ ꠘꠣ ꠅꠃ ꠙꠥꠔ ꠇꠦ, ꠀꠞ ꠙꠥꠔ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠎꠣꠘꠦ ꠘꠣ ꠅꠃ ꠛꠣꠚ ꠇꠦ। ꠙꠥꠔꠦ ꠛꠣꠚꠞꠦ ꠎꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠅꠄ, ꠈꠣꠟꠤ ꠢꠦ-ꠃ ꠛꠣꠚꠞ ꠙꠞꠤꠌꠄ ꠙꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK10_23","072_10_23","LUK","10","23","23","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠀ ꠇꠣꠘꠦ ꠇꠣꠘꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠖꠦꠈꠍ, ꠁꠔꠣ ꠖꠦꠈꠣꠞ ꠡꠥꠎꠥꠉ ꠎꠣꠞ ꠅꠄ, ꠢꠦ-ꠃ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("LK10_24","072_10_24","LUK","10","24","24","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠖꠦꠈꠞꠣꠄ, ꠁꠔꠣ ꠛꠃꠔ ꠘꠛꠤꠄ ꠀꠞ ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣꠄ ꠖꠦꠈꠣꠞ ꠀꠡꠣ ꠇꠞꠟꠦꠅ, ꠖꠦꠈꠣꠞ ꠇꠙꠣꠟ ꠅꠁꠍꠦ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠢꠥꠘꠞꠣꠄ, ꠁꠔꠣ ꠔꠣꠞꠣ ꠢꠥꠘꠔꠦ ꠌꠣꠁꠟꠦꠅ ꠢꠥꠘꠣꠞ ꠇꠙꠣꠟ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK10_25","072_10_25","LUK","10","25","25","ꠄꠇꠛꠣꠞ ꠄꠇ ꠀꠟꠤꠝ ꠍꠣꠛ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠔꠣꠘꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠇꠤꠔꠣ ꠇꠣꠝ ꠇꠞꠟꠦ ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔ ꠙꠣꠁꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("LK10_26","072_10_26","LUK","10","26","26","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠇꠤꠔꠣꠛꠅ ꠇꠤꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠦ? ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠙꠣꠁꠍꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("LK10_27","072_10_27","LUK","10","27","27","ꠀꠟꠤꠝꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠖꠤꠟ ꠖꠤꠀ, ꠎꠣꠘ ꠖꠤꠀ, ꠢꠇꠟ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠖꠤꠀ, ꠔꠥꠝꠣꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠝꠘ ꠖꠤꠀ, ꠔꠥꠝꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠛꠣꠄ। ꠀꠞ, ꠔꠥꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK10_28","072_10_28","LUK","10","28","28","ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠑꠤꠇ ꠇꠕꠣ ꠇꠁꠍꠂꠘ। ꠔꠦ ꠀꠙꠘꠦꠅ ꠅꠃꠟꠣ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠔꠦꠃ ꠛꠦꠢꠦꠡ꠆ꠔ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK10_29","072_10_29","LUK","10","29","29","ꠅꠃ ꠀꠟꠤꠝꠦ ꠘꠤꠎꠞ ꠖꠣꠝ ꠛꠣꠠꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ, ꠔꠦ ꠀꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK10_30","072_10_30","LUK","10","30","30","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠅ ꠎꠣꠅꠀꠔ ꠀꠍꠤꠟ। ꠙꠕꠅ ꠒꠣꠇꠣꠁꠔꠦ ꠙꠣꠁꠀ ꠔꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠢꠇꠟꠔꠣ ꠇꠣꠠꠤꠀ ꠘꠤꠀ, ꠔꠣꠞꠦ ꠝꠣꠞꠤꠀ ꠀꠗ-ꠝꠞꠣ ꠇꠞꠤ ꠚꠣꠟꠣꠁ ꠕꠁꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK10_31","072_10_31","LUK","10","31","31","ꠛꠣꠖꠦ ꠄꠇ ꠁꠝꠣꠝ ꠍꠣꠛ ꠅꠃ ꠙꠕꠦꠖꠤ ꠎꠣꠁꠞꠣ, ꠔꠣꠁꠘ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠉꠣꠟꠣꠛꠣꠄ ꠢꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK10_32","072_10_32","LUK","10","32","32","ꠅꠃ ꠟꠣꠈꠣꠘ ꠟꠦꠛꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠇ ꠈꠣꠖꠤꠝ ꠍꠣꠛꠅ ꠅꠃ ꠙꠕꠦꠖꠤ ꠀꠁꠟꠣ, ꠔꠣꠁꠘꠅ ꠄꠞꠦ ꠖꠦꠈꠤꠀ ꠉꠣꠟꠣꠛꠣꠄ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK10_33","072_10_33","LUK","10","33","33","ꠢꠦꠡꠦ ꠡꠝꠞꠤꠀ ꠎꠣꠔꠤꠞ ꠄꠇ ꠛꠦꠐꠣ ꠅꠃ ꠙꠕꠦꠖꠤ ꠀꠁꠟ, ꠢꠦ ꠛꠤꠗꠞ꠆ꠝꠤ ꠎꠣꠔꠤꠞ ꠅꠁꠟꠦꠅ ꠄꠞ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠔꠣꠞ ꠖꠤꠟꠅ ꠖꠞꠖ ꠢꠣꠝꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK10_34","072_10_34","LUK","10","34","34","ꠅꠃ ꠢꠦ ꠄꠞ ꠎꠈꠝꠞ ꠃꠙꠞꠦ ꠔꠦꠟ ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠞꠡ ꠝꠣꠟꠤꠡ ꠇꠞꠤꠀ ꠙꠐ꠆ꠐꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠤꠟ। ꠛꠣꠖꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠉꠣꠗꠣꠞ ꠃꠙꠞꠦ ꠔꠥꠟꠤꠀ, ꠄꠇ ꠝꠥꠍꠣꠚꠤꠞ ꠈꠣꠘꠣꠔ ꠘꠤꠀ ꠔꠣꠞ ꠎꠔꠘ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK10_35","072_10_35","LUK","10","35","35","ꠛꠣꠖꠞ ꠖꠤꠘ ꠅꠃ ꠡꠝꠞꠤꠅ ꠛꠦꠐꠣꠄ ꠝꠥꠍꠣꠚꠤꠞ ꠈꠣꠘꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠀꠔꠅ ꠖꠥꠁꠐꠣ ꠖꠤꠘꠣꠞ ꠖꠤꠀ ꠇꠁꠟ, ꠅꠃ ꠝꠣꠘꠥꠡꠉꠥꠞ ꠎꠔꠘ ꠇꠞꠛꠣ। ꠄꠞ ꠛꠦꠡꠤ ꠈꠞꠌ ꠅꠁꠟꠦꠅ, ꠀꠝꠤ ꠀꠁꠀ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LK10_36","072_10_36","LUK","10","36","36","“ꠔꠦ ꠀꠟꠤꠝ ꠍꠣꠛ, ꠀꠙꠘꠣꠞ ꠇꠤꠔꠣ ꠝꠘꠅ ꠅꠄ, ꠅꠃ ꠔꠤꠘꠎꠘꠞ ꠝꠣꠎꠦ ꠇꠥꠘ ꠎꠘ, ꠒꠣꠇꠣꠁꠔꠞ ꠀꠔꠅ ꠙꠤꠐꠣ ꠈꠣꠅꠞꠣ ꠛꠦꠐꠣꠞ ꠀꠞꠤ-ꠚꠞꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK10_37","072_10_37","LUK","10","37","37","ꠀꠟꠤꠝꠦ ꠇꠁꠟꠣ, “ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠖꠞꠖ ꠇꠞꠟ ꠢꠦ-ꠃ ꠔ।” ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠙꠘꠦꠅ ꠉꠤꠀ ꠅꠃꠟꠣ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK10_38","072_10_38","LUK","10","38","38","ꠛꠣꠖꠦ ꠁꠍꠣ ꠀꠞ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠀꠐꠤ ꠀꠐꠤ ꠄꠇ ꠉꠣꠃꠔ ꠉꠦꠟꠣ। ꠢꠃ ꠉꠣꠃꠞ ꠄꠇ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠁꠍꠣꠞꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠘꠤꠀ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠟꠣ। ꠅꠃ ꠛꠦꠐꠤꠞ ꠘꠣꠝ ꠝꠣꠞꠕꠣ। ");
INSERT INTO syls_vpl VALUES ("LK10_39","072_10_39","LUK","10","39","39","ꠛꠦꠐꠤꠞ ꠄꠇ ꠛꠁꠘꠞ ꠘꠣꠝ ꠅꠁꠟ ꠝꠞꠤꠅꠝ, ꠄꠁꠘ ꠢꠥꠎꠥꠞꠞ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠁꠀ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK10_40","072_10_40","LUK","10","40","40","ꠀꠞ ꠝꠣꠞꠕꠣ ꠉꠤꠀ ꠞꠣꠘ꠆ꠖꠣ-ꠛꠣꠠꠣ ꠀꠞ ꠈꠣꠔꠤꠞ-ꠎꠔꠘ ꠇꠞꠣꠔ ꠙꠦꠞꠦꠡꠣꠘꠤꠔ ꠞꠁꠟꠣ। ꠄꠞꠝꠣꠎꠦ ꠝꠣꠞꠕꠣ ꠀꠁꠀ ꠢꠥꠎꠥꠞ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠖꠦꠈꠞꠣ ꠘꠤ ꠀꠝꠣꠞ ꠛꠁꠘꠦ ꠢꠇ꠆ꠇꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠄꠇꠟꠣ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠕꠁꠀ ꠅꠘꠅ ꠀꠁꠍꠦ? ꠔꠦ ꠀꠙꠘꠦ ꠇꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠔ।” ");
INSERT INTO syls_vpl VALUES ("LK10_41","072_10_41","LUK","10","41","41","ꠢꠥꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠞꠕꠣ, ꠔꠥꠝꠤ ꠛꠃꠔ ꠛꠦꠙꠣꠞꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠀ ꠙꠦꠞꠦꠡꠣꠘ ꠅꠁꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("LK10_42","072_10_42","LUK","10","42","42","ꠢꠥꠘꠅ, ꠀꠍꠟꠦ ꠄꠇꠐꠣ ꠛꠦꠙꠣꠞꠃ ꠈꠣꠟꠤ ꠎꠞꠥꠞ ꠀꠍꠦ। ꠔꠥꠝꠣꠞ ꠛꠁꠘ ꠝꠞꠤꠅꠝꠦ ꠢꠃ ꠎꠞꠥꠞꠤ ꠛꠦꠙꠣꠞꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠦ। ꠁꠔꠣ ꠔ ꠔꠣꠁꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK11_1","072_11_1","LUK","11","1","1","ꠄꠇꠖꠤꠘ ꠢꠥꠎꠥꠞ ꠁꠍꠣꠄ ꠇꠥꠘꠥ ꠄꠇ ꠎꠣꠉꠣꠔ ꠖꠥꠀ ꠇꠞꠣꠔ ꠀꠍꠟꠣ। ꠖꠥꠀ ꠡꠦꠡ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘ ꠄꠇ ꠍꠣꠢꠣꠛꠤꠄ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠔ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠖꠥꠀ ꠇꠞꠣ ꠢꠤꠇꠣꠁꠔꠣ, ꠔꠦ ꠀꠙꠘꠦꠅ ꠀꠝꠞꠣꠞꠦ ꠖꠥꠀ ꠇꠞꠣ ꠢꠤꠇꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK11_2","072_11_2","LUK","11","2","2","ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠖꠥꠀ ꠇꠞꠣꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠅꠃꠟꠣ ꠇꠁꠅ, ꠅ ꠀꠍꠝꠣꠘꠤ ꠛꠣꠛꠣ, ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠙꠛꠤꠔ꠆ꠞ ꠇꠁꠀ ꠝꠣꠘꠣ ꠅꠃꠇ, ꠖꠥꠘꠤꠀꠔ ꠔꠥꠝꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠇꠣꠁꠝ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LK11_3","072_11_3","LUK","11","3","3","ꠀꠝꠞꠣꠞ ꠙꠞꠔꠦꠇ ꠖꠤꠘꠞ ꠞꠤꠎꠦꠇ ꠙꠞꠔꠤꠖꠤꠘ ꠎꠥꠉꠣꠁ ꠖꠤꠅ; ");
INSERT INTO syls_vpl VALUES ("LK11_4","072_11_4","LUK","11","4","4","ꠛꠣꠛꠣ, ꠀꠝꠞꠣꠞ ꠔꠣꠝꠣꠝ ꠉꠥꠘꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤꠀ ꠖꠤꠟꠣꠅ, ꠎꠦꠟꠣ ꠀꠝꠞꠣꠅ ꠝꠣꠚꠤ ꠖꠤꠟꠣꠁꠍꠤ ꠀꠝꠞꠣꠞ ꠅꠙꠞꠣꠗꠤ ꠅꠇꠟꠞꠦ; ꠀꠞ ꠙꠞꠤꠇ꠆ꠇꠣ ꠕꠣꠇꠤ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠅ ꠀꠝꠞꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK11_5","072_11_5","LUK","11","5","5","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠗꠞꠤꠟꠣꠅ, ꠀꠗꠣ ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠖꠥꠡ꠆ꠔꠞ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠇꠁꠟꠣꠄ, ꠖꠥꠡ꠆ꠔ, ꠀꠝꠣꠞꠦ ꠔꠤꠘꠈꠣꠘ ꠞꠥꠐꠤ ꠇꠞꠎ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("LK11_6","072_11_6","LUK","11","6","6","ꠀꠝꠣꠞ ꠄꠇ ꠛꠘ꠆ꠖꠥ ꠙꠕꠦꠖꠤ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠀꠈꠔꠣꠃ ꠀꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠃꠑꠍꠂꠘ। ꠅꠈꠘ ꠔꠣꠘꠦ ꠇꠤꠔꠣ ꠈꠣꠅꠀꠁꠔꠣꠝ, ꠀꠝꠣꠞ ꠊꠞꠅ ꠔ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LK11_7","072_11_7","LUK","11","7","7","ꠔꠦꠃ ꠖꠥꠡ꠆ꠔꠦ ꠊꠞꠅ ꠕꠘꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, ꠀꠝꠤ ꠖꠞꠎꠣ ꠛꠘ꠆ꠖ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠟꠁꠀ ꠢꠥꠔꠤꠞꠁꠍꠤ, ꠀꠝꠣꠞꠦ ꠇꠡ꠆ꠐ ꠖꠤꠅ ꠘꠣ। ꠅꠈꠘ ꠃꠑꠤꠀ ꠇꠥꠘ꠆ꠔꠣ ꠖꠤꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK11_8","072_11_8","LUK","11","8","8","ꠅꠁꠟꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠅꠃ ꠖꠥꠡ꠆ꠔꠦ ꠃꠑꠤꠀ ꠛꠘ꠆ꠖꠥ ꠢꠤꠡꠣꠛꠦ ꠇꠥꠘ꠆ꠔꠣ ꠖꠤꠔꠦ ꠘꠣ ꠌꠣꠁꠟꠦꠅ, ꠔꠥꠝꠤ ꠛꠣꠞ ꠛꠣꠞ ꠝꠤꠘꠔ ꠇꠞꠟꠦ ꠢꠦ ꠃꠑꠛꠃ। ꠃꠑꠤꠀ ꠔꠥꠝꠤ ꠎꠦꠔꠣ ꠌꠣꠁꠞꠣꠄ, ꠁꠔꠣ ꠑꠤꠇꠃ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LK11_9","072_11_9","LUK","11","9","9","“ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠌꠣꠅ, ꠔꠦꠃ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠅ, ꠔꠦꠃ ꠙꠣꠁꠛꠣꠄ। ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣ ꠖꠦꠅ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀꠞ ꠈꠥꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK11_10","072_11_10","LUK","11","10","10","ꠎꠣꠞꠣ ꠌꠣꠄ, ꠔꠣꠞꠣꠃ ꠔ ꠙꠣꠄ। ꠎꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠦ ꠢꠦ ꠙꠣꠄ। ꠎꠦ ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣ ꠖꠦꠄ, ꠔꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀꠞ ꠈꠥꠟꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LK11_11","072_11_11","LUK","11","11","11","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠛꠣꠚ ꠀꠍꠦ ꠘꠤ, ꠎꠣꠞ ꠙꠥꠔꠦ ꠞꠥꠐꠤ ꠌꠣꠁꠟꠦ ꠔꠣꠞꠦ ꠝꠣꠐꠤ ꠖꠤꠛ, ꠝꠣꠍ ꠌꠣꠁꠟꠦ ꠢꠣꠚ ꠖꠤꠛ, ");
INSERT INTO syls_vpl VALUES ("LK11_12","072_11_12","LUK","11","12","12","ꠛꠣ ꠄꠘ꠆ꠒꠣ ꠌꠣꠁꠟꠦ ꠛꠤꠍꠣ ꠖꠤꠛ? ");
INSERT INTO syls_vpl VALUES ("LK11_13","072_11_13","LUK","11","13","13","ꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠁꠀꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠌꠤꠎ ꠖꠤꠔꠣꠄ ꠎꠣꠘ, ꠔꠦ ꠎꠣꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠌꠣꠁꠛ, ꠔꠣꠁꠘ ꠘꠤꠌꠄ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠛꠣꠃ।” ");
INSERT INTO syls_vpl VALUES ("LK11_14","072_11_14","LUK","11","14","14","ꠄꠇꠖꠤꠘ ꠄꠇ ꠛꠦꠐꠣꠞ ꠟꠉ ꠕꠣꠇꠤꠀ ꠁꠍꠣꠄ ꠄꠇ ꠛꠥꠛꠣ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁꠟꠣ। ꠎꠤꠘ꠆ꠘꠣꠔꠦ ꠍꠣꠠꠣꠞ ꠛꠣꠖꠦ ꠢꠤ ꠛꠦꠐꠣꠞ ꠎꠛꠣꠘ ꠈꠥꠟꠤꠉꠦꠟ, ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠟ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_15","072_11_15","LUK","11","15","15","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠇꠁꠟ, “ꠁ ꠛꠦꠐꠣꠄ ꠎꠤꠘꠞ ꠛꠣꠖꠡꠣ ꠛꠦꠟ-ꠍꠛꠥꠟꠞ ꠛꠟꠦ ꠎꠤꠘ ꠍꠣꠠꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK11_16","072_11_16","LUK","11","16","16","ꠀꠞꠅ ꠇꠁꠄꠇ ꠎꠘꠦ ꠔꠣꠘꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠔꠣꠘ ꠀꠔꠞ ꠇꠥꠘꠥ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠔ ꠌꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK11_17","072_11_17","LUK","11","17","17","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠜꠣꠛ ꠛꠥꠎꠤꠟꠤꠟꠣ। ꠛꠥꠎꠤꠀ ꠇꠁꠟꠣ, “ꠇꠥꠘꠥ ꠞꠣꠁꠎ꠆ꠎ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠜꠣꠉ ꠅꠁꠉꠦꠟꠦ, ꠁ ꠞꠣꠁꠎ꠆ꠎ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠣꠄ। ꠅꠃꠟꠣ ꠇꠥꠘꠥ ꠙꠞꠤꠛꠣꠞꠅ ꠎꠦꠛꠟꠣ ꠛꠤꠛꠣꠖ ꠟꠣꠉꠤꠎꠣꠄ, ꠁ ꠙꠞꠤꠛꠣꠞꠅ ꠀꠞ ꠐꠤꠇꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_18","072_11_18","LUK","11","18","18","ꠔꠦ ꠎꠤꠘ꠆ꠘꠣꠔ ꠎꠥꠖꠤ ꠔꠣꠞ ꠘꠤꠎꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠟꠣꠉꠤꠎꠣꠄ, ꠔꠣꠁꠟꠦ ꠔꠣꠞ ꠞꠣꠁꠎ꠆ꠎ ꠇꠦꠝꠘꠦ ꠐꠤꠇꠛ? ꠔꠥꠝꠞꠣ ꠔ ꠇꠁꠞꠣꠄ, ꠀꠝꠤ ꠛꠦꠟ-ꠍꠛꠥꠟꠞ ꠛꠟꠦ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LK11_19","072_11_19","LUK","11","19","19","ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠕꠣ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠛꠦꠟ-ꠍꠛꠥꠟꠞ ꠛꠟꠦ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠡꠦ ꠇꠤꠔꠣꠖꠤ ꠍꠣꠠꠣꠄ? ꠔꠥꠝꠞꠣꠞ ꠝꠣꠔꠞ ꠛꠤꠌꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠘꠡꠦꠃ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LK11_20","072_11_20","LUK","11","20","20","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠁ ꠇꠥꠖꠞꠔꠦ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁ, ꠔꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔꠥꠝꠞꠣꠞ ꠘꠎꠖꠤꠇ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK11_21","072_11_21","LUK","11","21","21","“ꠢꠥꠘꠅ, ꠇꠥꠘꠥ ꠛꠟꠀꠟꠣ ꠝꠣꠘꠡꠦ ꠅꠡꠔ꠆ꠞ-ꠡꠡꠔ꠆ꠞ ꠟꠁꠀ ꠔꠣꠞ ꠛꠣꠠꠤ ꠙꠣꠢꠣꠞꠣ ꠖꠤꠟꠦ, ꠔꠣꠞ ꠍꠣꠝꠣꠘꠣ ꠘꠤꠞꠣꠙꠖ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("LK11_22","072_11_22","LUK","11","22","22","ꠅꠁꠟꠦ ꠔꠣꠞ ꠕꠣꠇꠤ ꠎꠛꠞꠖꠡ꠆ꠔ ꠀꠞꠇ ꠎꠘ ꠀꠁꠀ ꠢꠣꠝꠟꠣ ꠇꠞꠤꠀ ꠔꠣꠞꠦ ꠀꠞꠣꠁꠟꠤꠟꠦ, ꠢꠦ ꠎꠦꠔꠣ ꠅꠡꠔ꠆ꠞ-ꠡꠡꠔ꠆ꠞꠞ ꠛꠠꠣꠁ ꠇꠞꠍꠤꠟ, ꠁ ꠅꠡꠔ꠆ꠞꠅ ꠇꠣꠠꠤꠀ ꠘꠤꠛꠉꠤ। ꠔꠣꠞ ꠢꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠅ ꠟꠥꠐꠤꠀ ꠘꠤꠀ ꠛꠣꠐꠤꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LK11_23","072_11_23","LUK","11","23","23","“ꠔꠦ ꠎꠦ ꠎꠘ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠘꠣꠄ, ꠢꠦ ꠔ ꠀꠝꠣꠞ ꠛꠤꠙꠇ꠆ꠇ। ꠎꠦ ꠀꠝꠣꠞ ꠅꠁꠀ ꠇꠣꠝ ꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠔ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠣꠝ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK11_24","072_11_24","LUK","11","24","24","“ꠇꠥꠘꠥ ꠎꠤꠘꠦ ꠎꠦꠛꠟꠣ ꠄꠇ ꠛꠦꠝꠣꠞꠤꠞ ꠟꠉ ꠍꠣꠠꠤꠀ ꠎꠣꠄꠉꠤ, ꠉꠤꠀ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠊꠥꠞꠣꠊꠥꠞꠤ ꠇꠞꠦ। ꠛꠣꠖꠦ ꠇꠥꠘꠥꠈꠣꠘꠅ ꠞꠁꠛꠣꠞ ꠎꠣꠉꠣ ꠘꠣ ꠙꠣꠁꠀ ꠝꠘꠦ ꠝꠘꠦ ꠇꠄ, ꠖꠥꠞ! ꠀꠝꠤ ꠎꠦꠘ ꠕꠣꠇꠤ ꠀꠁꠍꠤ ꠅꠘꠅꠃ ꠢꠤꠞꠛꠣꠞ ꠎꠣꠁꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK11_25","072_11_25","LUK","11","25","25","ꠚꠤꠞꠔ ꠀꠁꠀ ꠢꠣꠞꠤ ꠖꠦꠈꠦ, ꠢꠤ ꠎꠣꠉꠣ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠢꠣꠎꠣꠁ-ꠙꠣꠠꠣꠁ ꠕꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("LK11_26","072_11_26","LUK","11","26","26","ꠅꠃ ꠢꠦ ꠉꠤꠀ ꠔꠣꠞ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠖ ꠡꠣꠔꠉꠥ ꠎꠤꠘ ꠟꠉꠦ ꠇꠞꠤ ꠀꠘꠦ। ꠀꠘꠤꠀ ꠅꠘꠅ ꠢꠣꠝꠣꠁꠀ ꠛꠣꠡꠣ ꠛꠣꠘꠣꠄ। ꠄꠞꠖꠣꠄ ꠅꠃ ꠛꠦꠝꠣꠞꠤꠞ ꠖꠡꠣ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠢꠦꠡꠦ ꠀꠞꠅ ꠈꠣꠞꠣꠙ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK11_27","072_11_27","LUK","11","27","27","ꠁꠍꠣꠄ ꠅꠔꠣ ꠛꠄꠀꠘ ꠇꠞꠞꠣ, ꠀꠈꠔꠣꠃ ꠜꠤꠠꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠇ ꠛꠦꠐꠤꠄ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠎꠦ ꠝꠣʼꠄ ꠀꠙꠘꠣꠞꠦ ꠙꠦꠐꠅ ꠟꠁꠍꠂꠘ ꠀꠞ ꠖꠥꠗ ꠈꠣꠅꠀꠁꠍꠂꠘ, ꠄꠁꠘ ꠛꠠ ꠇꠙꠣꠟꠤ ꠝꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK11_28","072_11_28","LUK","11","28","28","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁꠈꠣꠘ ꠢꠣꠍꠣ ꠇꠕꠣ, ꠅꠁꠟꠦ ꠄꠞ ꠌꠣꠁꠔꠦꠅ ꠛꠠ ꠇꠙꠣꠟꠤ ꠔꠣꠞꠣ, ꠎꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ, ꠢꠥꠘꠤꠀ ꠅꠟꠣ ꠀꠝꠟ ꠇꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK11_29","072_11_29","LUK","11","29","29","ꠛꠣꠖꠦ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠥꠡ ꠔ ꠘꠣꠚꠞꠝꠣꠘ। ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠇꠦꠞꠣꠝꠔꠤ ꠔꠥꠇꠣꠄ, ꠅꠁꠟꠦ ꠁꠃꠘꠥꠍ ꠘꠛꠤꠞ ꠀꠟꠣꠝꠔ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠇꠦꠞꠣꠝꠔꠤ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK11_30","072_11_30","LUK","11","30","30","ꠁꠃꠘꠥꠍ ꠘꠛꠤ ꠘꠤꠎꠦ ꠘꠤꠎꠦꠃ ꠎꠦꠟꠣ ꠘꠤꠘꠜ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠄꠇ ꠀꠟꠣꠝꠔ ꠅꠁꠍꠟꠣ, ꠛꠤꠘ-ꠀꠖꠝꠅ ꠅꠃꠟꠣ ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠘꠤꠎꠦꠃ ꠀꠟꠣꠝꠔ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_31","072_11_31","LUK","11","31","31","ꠞꠥꠎ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠖꠃꠇꠘꠞ ꠖꠦꠡꠞ ꠞꠣꠘꠤ ꠃꠑꠤꠀ ꠅꠃ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠖꠥꠡ ꠎꠣꠁꠞ ꠇꠞꠛꠣ। ꠇꠣꠞꠘ ꠛꠣꠖꠡꠣ ꠍꠥꠟꠣꠁꠝꠣꠘꠞ ꠀꠈꠟꠞ ꠇꠕꠣ ꠢꠥꠘꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀꠞ ꠢꠦꠡ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠁꠍꠟꠣ। ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠍꠥꠟꠣꠁꠝꠣꠘ ꠕꠣꠇꠤꠅ ꠀꠞꠅ ꠝꠢꠣꠘ ꠄꠇꠎꠘ ꠅꠘꠅ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK11_32","072_11_32","LUK","11","32","32","ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠘꠤꠘꠜ ꠐꠣꠃꠘꠞ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠃꠑꠤꠀ ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠖꠥꠡ ꠎꠣꠁꠞ ꠇꠞꠛꠣ। ꠇꠣꠞꠘ ꠁꠃꠘꠥꠍ ꠘꠛꠤꠞ ꠔꠛꠟꠤꠉ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠍꠤꠟꠣ। ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠁꠃꠘꠥꠍ ꠕꠣꠇꠤꠅ ꠀꠞꠅ ꠝꠢꠣꠘ ꠄꠇꠎꠘ ꠁꠘꠅ ꠀꠍꠂꠘ, ꠔꠣ-ꠅ ꠝꠣꠘꠡꠦ ꠔꠃꠛꠣ ꠇꠞꠦꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_33","072_11_33","LUK","11","33","33","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔ ꠟꠦꠝ ꠎꠣꠟꠣꠁꠀ ꠢꠣꠞꠤ ꠌꠇꠤꠞ ꠔꠟꠦ ꠛꠣ ꠐꠥꠇꠞꠤꠞ ꠔꠟꠦ ꠕꠄ ꠘꠣ, ꠛꠞꠋ ꠉꠣꠍꠣꠞ ꠃꠙꠞꠦꠃ ꠕꠄ, ꠎꠣꠔꠦ ꠊꠞꠞ ꠝꠣꠘꠡꠦ ꠚꠞ ꠖꠦꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("LK11_34","072_11_34","LUK","11","34","34","ꠔꠥꠝꠣꠞ ꠌꠃꠈꠃ ꠅꠁꠟ ꠔꠥꠝꠣꠞ ꠇꠣꠄꠀꠞ ꠛꠣꠔ꠆ꠔꠤ। ꠌꠃꠈ ꠎꠥꠖꠤ ꠜꠣꠟꠣ ꠅꠄ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠅ ꠚꠞ ꠅꠁꠛ। ꠀꠞ ꠌꠃꠈ ꠈꠣꠞꠣꠙ ꠅꠁꠟꠦ, ꠔꠥꠝꠣꠞ ꠡꠞꠤꠟꠅ ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK11_35","072_11_35","LUK","11","35","35","ꠔꠦ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠣꠞ ꠖꠤꠟꠅ ꠎꠦ ꠘꠥꠞ ꠀꠍꠦ, ꠁꠔꠣ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠎꠣꠞ ꠇꠤ ꠘꠣ? ");
INSERT INTO syls_vpl VALUES ("LK11_36","072_11_36","LUK","11","36","36","ꠔꠥꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠅ ꠎꠥꠖꠤ ꠚꠞ ꠕꠣꠇꠦ, ꠇꠥꠘꠥ ꠅꠋꠉ ꠀꠘ꠆ꠖꠣꠁꠞ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠟꠦꠝꠦ ꠎꠦꠟꠣ ꠔꠣꠞ ꠘꠤꠎꠞ ꠔꠦꠎꠦ ꠔꠥꠝꠣꠞꠦ ꠚꠞ ꠖꠦꠄ, ꠅꠃꠟꠣ ꠁ ꠘꠥꠞꠦꠅ ꠔꠥꠝꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠞꠦ ꠚꠞ ꠇꠞꠤꠟꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK11_37","072_11_37","LUK","11","37","37","ꠁꠍꠣꠄ ꠛꠄꠀꠘ ꠇꠞꠞꠣ ꠅꠃ ꠡꠝꠄ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠄꠇꠎꠘꠦ ꠔꠣꠘꠞꠦ ꠈꠣꠁꠛꠣꠞ ꠖꠣꠅꠔ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠉꠤꠀ ꠄꠘ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠈꠣꠘꠤꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_38","072_11_38","LUK","11","38","38","ꠚꠞꠤꠡꠤꠄ ꠖꠦꠈꠟꠣ, ꠈꠣꠅꠀꠔ ꠛꠁꠛꠣꠞ ꠇꠣꠟꠅ ꠁꠍꠣꠄ ꠁꠢꠥꠖꠤ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠀꠔ ꠗꠁꠍꠁꠘ ꠘꠣ, ꠅꠃ ꠔꠣꠁꠘ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_39","072_11_39","LUK","11","39","39","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞꠣ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠔ ꠛꠣꠡꠘ-ꠛꠞ꠆ꠔꠘꠞ ꠛꠣꠁꠞ ꠉꠣꠟꠣ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠂꠘ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠔ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠟꠣꠟꠌꠦ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_40","072_11_40","LUK","11","40","40","ꠅ ꠛꠦꠀꠈꠟꠞ ꠖꠟ, ꠎꠦꠁꠘ ꠛꠣꠞꠉꠣꠟꠣ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠇꠤꠔꠣ ꠜꠤꠔꠞ ꠉꠣꠟꠣꠅ ꠛꠣꠘꠣꠁꠍꠂꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK11_41","072_11_41","LUK","11","41","41","ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠎꠦꠔꠣ ꠀꠍꠦ, ꠅꠔꠣ ꠀꠉꠦ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠡ꠆ꠔꠦ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠔꠦꠃ ꠖꠦꠈꠛꠣꠘꠦ, ꠀꠙꠘꠣꠞꠣꠞ ꠢꠇꠟꠔꠣꠃ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LK11_42","072_11_42","LUK","11","42","42","“ꠢꠣꠄꠞꠦ ꠚꠞꠤꠡꠤ ꠅꠇꠟ, ꠟꠣꠘ꠆ꠘꠔ ꠔꠥꠝꠞꠣꠞꠦ, ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠔꠦꠎꠙꠣꠔꠣ, ꠙꠖꠤꠘꠣ ꠙꠣꠔꠣ ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠢꠣꠉ-ꠔꠞꠇꠣꠞꠤꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠎꠇꠣꠔ ꠖꠦꠅ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔ ꠀꠞ ꠢꠇ ꠁꠘꠍꠣꠚꠞ ꠛꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠈꠤꠀꠟꠃ ꠘꠣꠁ। ꠀꠍꠟꠦ ꠅꠃ ꠙꠄꠟꠣꠔꠣ ꠝꠣꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠛꠣꠖꠞꠔꠣꠅ ꠀꠝꠟ ꠇꠞꠣ ꠚꠞꠎ। ");
INSERT INTO syls_vpl VALUES ("LK11_43","072_11_43","LUK","11","43","43","ꠅ ꠟꠣꠘ꠆ꠘꠔꠤ ꠚꠞꠤꠡꠤ ꠅꠇꠟ! ꠝꠍꠤꠖꠅ ꠢꠣꠝꠣꠁꠀ ꠍꠣꠝꠘꠞ ꠇꠣꠔꠣꠞꠅ ꠛꠅꠀ, ꠀꠞ ꠛꠣꠎꠣꠞ-ꠀꠐꠅ ꠉꠤꠀ ꠍꠣꠟꠣꠝ ꠙꠣꠁꠔꠦ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠙꠍꠘ꠆ꠖ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("LK11_44","072_11_44","LUK","11","44","44","ꠟꠣꠘ꠆ꠘꠔ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ, ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠅꠌꠤꠘꠣ ꠇꠄꠛꠞꠞ ꠟꠣꠈꠣꠘ। ꠝꠣꠘꠡꠦ ꠘꠣ ꠌꠤꠘꠤꠀ ꠄꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠣ-ꠚꠤꠞꠣ ꠇꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK11_45","072_11_45","LUK","11","45","45","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠄꠇꠎꠘ ꠀꠟꠤꠝꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠈꠣꠘ ꠇꠁꠀ ꠔ ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞꠦꠅ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK11_46","072_11_46","LUK","11","46","46","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠘꠤꠌꠄ, ꠀꠙꠘꠣꠞꠣꠅ ꠟꠣꠘ꠆ꠘꠔꠤ, ꠀꠙꠘꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠇꠣꠘ꠆ꠖꠅ ꠜꠣꠞ ꠛꠥꠏꠣꠁ ꠇꠞꠤꠀ ꠖꠦꠁꠘ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠀꠍꠣꠘꠞ ꠟꠣꠉꠤ ꠀꠋꠉꠥꠟꠐꠣꠅ ꠟꠣꠠꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_47","072_11_47","LUK","11","47","47","“ꠢꠣꠄꠞꠦ ꠟꠣꠘ꠆ꠘꠔꠤ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠘꠛꠤ ꠅꠇꠟꠞ ꠞꠅꠎꠣꠞꠦ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤꠀ ꠙꠣꠇ꠆ꠇꠣ ꠇꠞꠅ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠄꠃ ꠔ ꠄꠞꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK11_48","072_11_48","LUK","11","48","48","ꠅꠔꠣ ꠖꠦꠈꠤꠀꠃ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠔꠥꠝꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠇꠣꠝꠞ ꠡꠣꠇ꠆ꠇꠤ ꠅꠁꠞꠣꠄ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠅꠁꠞꠣꠄ। ꠔꠣꠞꠣ ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠍꠤꠟ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠢꠃ ꠘꠛꠤꠞ ꠞꠅꠎꠣꠞꠦ ꠙꠣꠇ꠆ꠇꠣ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK11_49","072_11_49","LUK","11","49","49","ꠄꠞꠖꠣꠄ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦꠅ ꠔꠣꠘ ꠘꠤꠎꠞ ꠝꠞ꠆ꠎꠤꠄ ꠇꠁꠟꠣ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠘꠛꠤ-ꠞꠍꠥꠟ ꠛꠦꠎꠤꠝꠥ, ꠄꠞꠣꠞ ꠇꠦꠃꠞꠞꠦ ꠔꠣꠞꠣ ꠎꠥꠟꠥꠝ ꠇꠞꠛ, ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LK11_50","072_11_50","LUK","11","50","50","ꠄꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠔ ꠘꠛꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠦ, ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠞ ꠖꠣꠄꠁ ꠅꠁꠛꠣ ꠅꠃ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("LK11_51","072_11_51","LUK","11","51","51","ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠇꠁꠞꠣꠝ, ꠙꠄꠟꠣ ꠀꠖꠝꠞ ꠙꠥꠔ ꠢꠣꠛꠤꠟꠞ ꠈꠥꠘ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠇꠞꠤꠀ, ꠘꠛꠤ ꠎꠣꠇꠣꠞꠤꠀꠞ ꠈꠥꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇꠟ ꠟꠃꠞ ꠡꠣꠎꠣ ꠅꠃ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠛ। ꠘꠛꠤ ꠎꠣꠇꠣꠞꠤꠀꠞꠦ ꠔ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠡꠞꠤꠚꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠈꠥꠘ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK11_52","072_11_52","LUK","11","52","52","ꠢꠣꠄꠞꠦ ꠟꠣꠘ꠆ꠘꠔꠤ ꠀꠟꠤꠝ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠝꠣꠘꠡꠞꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠙꠕ ꠌꠤꠘꠣꠁꠞꠣꠄ ꠘꠣ, ꠘꠤꠎꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠁꠞꠣꠄ ꠘꠣ, ꠀꠞ ꠎꠦꠞꠣ ꠢꠣꠝꠣꠁꠔ ꠌꠣꠞ, ꠔꠣꠞꠣꠞꠦꠅ ꠛꠣꠗꠣ ꠖꠤꠞꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK11_53","072_11_53","LUK","11","53","54","ꠛꠄꠀꠘ ꠛꠣꠖꠦ ꠁꠍꠣ ꠁꠈꠣꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟꠣ। ꠔꠦꠃ ꠀꠟꠤꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠝꠤꠎꠣꠎ ꠉꠞꠝ ꠇꠞꠤꠀ ꠁꠍꠣꠞꠦ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠁꠔꠣ ꠇꠞꠤ ꠈꠥꠌꠣꠁ-ꠚꠣꠠꠣꠁ ꠝꠣꠔꠤꠟꠣ। ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠍꠅꠀꠟ ꠇꠞꠤꠀ ꠔꠣꠘꠞꠦ ꠀꠐꠇꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠔꠥꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_1","072_12_1","LUK","12","1","1","ꠅꠃ ꠡꠝꠄ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠝꠣꠘꠥꠡ ꠖꠟꠣ ꠅꠁꠉꠦꠟꠣ, ꠔꠣꠞꠣ ꠑꠦꠟꠣꠑꠦꠟꠤ ꠇꠞꠤ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠃꠙꠞꠦ ꠙꠠꠟꠣ। ꠁꠍꠣꠄ ꠙꠄꠟꠣ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠈꠣꠝꠤꠞ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠅꠃ ꠈꠣꠝꠤꠞ ꠅꠁꠟ ꠔꠣꠞꠣꠞ ꠜꠘ꠆ꠒꠣꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("LK12_2","072_12_2","LUK","12","2","2","ꠑꠤꠇ ꠅꠃ ꠈꠣꠝꠤꠞꠞ ꠟꠣꠈꠣꠘ, ꠁꠟꠣ ꠟꠥꠇꠣꠁꠟ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ, ꠎꠦꠔꠣ ꠎꠣꠁꠞ ꠅꠁꠔ ꠘꠣꠄ। ꠁꠟꠣ ꠉꠥꠙꠘ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ, ꠎꠦꠔꠣ ꠎꠣꠘꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK12_3","072_12_3","LUK","12","3","3","ꠔꠥꠝꠞꠣ ꠀꠘ꠆ꠖꠣꠁꠞ ꠊꠞꠅ ꠎꠦꠔꠣ ꠝꠣꠔꠤꠍ, ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠚꠞꠞ ꠝꠣꠎꠦ ꠢꠥꠘꠛ। ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠇꠣꠘꠦ ꠇꠣꠘꠦ ꠎꠦꠔꠣ ꠇꠁꠍ, ꠁꠔꠣ ꠌꠣꠟꠞ ꠃꠙꠞꠦ ꠞꠐꠣꠁꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK12_4","072_12_4","LUK","12","4","4","“ꠅ ꠀꠝꠣꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠀꠞ, ꠎꠣꠞꠣ ꠈꠣꠟꠤ ꠡꠞꠤꠟꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_5","072_12_5","LUK","12","5","5","ꠔꠦ ꠇꠣꠞꠦ ꠒꠞꠣꠁꠔꠣꠄ ꠄꠅꠈꠣꠘꠅ ꠇꠁꠞꠣꠝ, ꠝꠣꠞꠣꠞ ꠛꠣꠖꠦ ꠖꠥꠎꠈꠅ ꠢꠣꠞꠣꠘꠤꠞ ꠈꠦꠝꠔꠣꠅ ꠎꠣꠘ ꠀꠍꠦ, ꠈꠣꠟꠤ ꠔꠣꠘꠞꠦꠃ ꠒꠞꠣꠁꠅ। ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠔꠣꠘꠦꠃ ꠒꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LK12_6","072_12_6","LUK","12","6","6","ꠝꠣꠔ꠆ꠞ ꠖꠥꠁ ꠀꠘꠣꠄ ꠙꠣꠌꠉꠥ ꠌꠠꠣ ꠙꠣꠈꠤ ꠝꠤꠟꠦ ꠘꠣ ꠘꠤ? ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠅꠃ ꠌꠠꠣꠞ ꠇꠕꠣꠅ ꠚꠣꠃꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_7","072_12_7","LUK","12","7","7","ꠀꠞ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟꠞ ꠢꠤꠡꠣꠛꠅ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠍꠦ। ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠛꠃꠔ ꠌꠠꠣ ꠙꠣꠈꠤ ꠕꠘꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠖꠣꠝ ꠔꠣꠘ ꠉꠦꠍꠦ ꠛꠦꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("LK12_8","072_12_8","LUK","12","8","8","“ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠡꠝꠣꠎꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LK12_9","072_12_9","LUK","12","9","9","ꠅꠁꠟꠦ ꠎꠦ ꠝꠣꠘꠡꠦ ꠡꠝꠣꠎꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠛ, ꠀꠝꠤꠅ ꠔꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LK12_10","072_12_10","LUK","12","10","10","ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠤꠟꠦꠅ ꠝꠣꠚꠤ ꠙꠣꠁꠛ। ꠅꠁꠟꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠥꠚꠥꠞꠤ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞ ꠇꠥꠘꠥ ꠝꠣꠚꠤ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LK12_11","072_12_11","LUK","12","11","11","“ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠍꠤꠖꠞ ꠙꠣꠁꠘ꠆ꠌꠣꠁꠔꠅ, ꠛꠤꠌꠣꠞꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ, ꠛꠣ ꠕꠣꠘꠣꠔ ꠘꠤꠛ, ꠅꠃ ꠡꠝꠄ ꠇꠤꠔꠣ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ ꠛꠣ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠄ, ꠁꠔꠣ ꠟꠁꠀ ꠇꠥꠘꠥ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_12","072_12_12","LUK","12","12","12","ꠇꠤꠔꠣ ꠝꠣꠔꠤꠔꠣꠄ ꠁꠔꠣ ꠙꠣꠇ ꠞꠥꠢꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠃ ꠡꠝꠄ ꠛꠣꠔꠣꠁ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK12_13","072_12_13","LUK","12","13","13","ꠜꠤꠠꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠇꠎꠘꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠜꠣꠁꠞꠦ ꠇꠃꠇ꠆ꠇꠣ, ꠀꠝꠣꠞ ꠛꠣꠛꠣꠄ ꠎꠦꠔꠣ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠕꠁꠀ ꠉꠦꠍꠂꠘ, ꠅꠔꠣ ꠛꠣꠐ-ꠛꠣꠐꠥꠞꠣ ꠇꠞꠤꠀ ꠖꠤꠔꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK12_14","072_12_14","LUK","12","14","14","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠔꠣꠝ ꠀꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠛꠣꠐꠤꠔꠣꠝ, ꠁꠔꠣ ꠄꠈꠔꠤꠀꠞ ꠀꠝꠣꠞꠦ ꠇꠦꠉꠥꠄ ꠖꠤꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK12_15","072_12_15","LUK","12","15","15","ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠈꠛꠞꠖꠣꠞ! ꠢꠇ꠆ꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠟꠥꠜ-ꠟꠣꠟꠌ ꠕꠘꠦ ꠘꠤꠎꠞꠦ ꠛꠣꠌꠣꠅ। ꠇꠣꠞꠘ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠛꠣꠁꠀ ꠉꠦꠟꠦꠅ ꠁꠔꠣꠄ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK12_16","072_12_16","LUK","12","16","16","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ, ꠇꠁꠟꠣ, “ꠄꠇ ꠗꠘꠤ ꠛꠦꠐꠣꠞ ꠎꠝꠤꠘꠅ ꠛꠃꠔ ꠗꠣꠘ ꠚꠟꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK12_17","072_12_17","LUK","12","17","17","ꠗꠣꠘ ꠖꠦꠈꠤꠀ ꠢꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟ, ꠅꠔ ꠗꠣꠘ ꠅꠈꠘ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ? ꠀꠝꠣꠞ ꠔ ꠕꠁꠛꠣꠞꠃ ꠎꠣꠉꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LK12_18","072_12_18","LUK","12","18","18","ꠔꠦ ꠀꠝꠤ ꠄꠇ ꠇꠣꠝ ꠇꠞꠤ, ꠀꠝꠣꠞ ꠃꠉꠣꠞ ꠜꠣꠋꠉꠤꠀ ꠛꠠ ꠇꠞꠤ ꠇꠄꠐꠣ ꠃꠉꠣꠞ ꠛꠣꠘꠣꠁꠟꠣꠁ। ꠔꠦꠃ ꠀꠝꠣꠞ ꠢꠇꠟ ꠗꠣꠘ ꠀꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠎꠣꠉꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK12_19","072_12_19","LUK","12","19","19","ꠢꠦꠡꠦ ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ ꠇꠁꠝꠥ, ꠅ ꠎꠣꠘ, ꠛꠃꠔ ꠛꠍꠞꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠀꠞ ꠈꠣꠘꠤ-ꠈꠥꠞꠣꠇꠤꠞ ꠟꠣꠉꠤ ꠘꠤꠌꠤꠘ꠆ꠔꠣ ꠅꠁꠉꠦꠍ। ꠅꠈꠘ ꠀꠞꠣꠝ-ꠀꠄꠄꠡꠦ ꠔꠥꠝꠤ ꠈꠣꠁꠀ ꠚꠤꠘ꠆ꠖꠤꠀ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("LK12_20","072_12_20","LUK","12","20","20","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, ꠅꠞꠦ ꠛꠦꠀꠈꠟ, ꠔꠞ ꠎꠣꠘ ꠔ ꠀꠁꠎ ꠞꠣꠁꠔꠃ ꠇꠛꠎ ꠇꠞꠣ ꠅꠁꠛ। ꠔꠦ ꠔꠥꠁ ꠎꠦꠔꠣ ꠎꠝꠣꠁꠍꠍ, ꠁꠔꠣ ꠇꠦꠉꠥꠄ ꠈꠣꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("LK12_21","072_12_21","LUK","12","21","21","ꠢꠦꠡꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠎꠦ ꠝꠣꠘꠡꠦ ꠈꠣꠟꠤ ꠖꠥꠘꠤꠀꠛꠤ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠖꠟꠣ ꠇꠞꠦ, ꠅꠁꠟꠦ ꠀꠈꠦꠞꠞ ꠗꠘ ꠘꠣ ꠎꠝꠣꠄ, ꠔꠣꠞ ꠢꠣꠟꠔ ꠅꠃꠟꠣꠃ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK12_22","072_12_22","LUK","12","22","22","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠄꠞꠖꠣꠄꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠇꠤꠔꠣ ꠈꠣꠁꠀ ꠛꠣꠌꠔꠣꠝ, ꠀꠞ ꠇꠤꠔꠣ ꠚꠤꠘ꠆ꠖꠤꠔꠣꠝ, ꠁꠔꠣ ꠟꠁꠀ ꠔꠥꠝꠞꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_23","072_12_23","LUK","12","23","23","ꠎꠣꠘ ꠕꠣꠇꠤ ꠔ ꠈꠣꠘꠤ ꠛꠠ ꠘꠣꠄ, ꠀꠞ ꠡꠞꠤꠟ ꠕꠣꠇꠤ ꠇꠣꠙꠠ ꠛꠠ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK12_24","072_12_24","LUK","12","24","24","ꠅꠃ ꠇꠣꠃꠀꠉꠥꠁꠘ꠆ꠔꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠅ, ꠔꠣꠞꠣ ꠔ ꠈꠦꠔꠅ ꠇꠞꠦ ꠘꠣ, ꠚꠡꠟꠅ ꠇꠣꠐꠦ ꠘꠣ। ꠔꠣꠞꠣꠞ ꠃꠉꠣꠞꠅ ꠘꠣꠁ, ꠜꠣꠘ꠆ꠒꠣꠞꠅ ꠘꠣꠁ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠞꠤꠎꠦꠇ ꠎꠥꠉꠣꠁꠀ ꠖꠦꠁꠘ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠔ ꠅꠃ ꠇꠣꠃꠀ ꠕꠣꠇꠤ ꠛꠃꠔ ꠖꠣꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("LK12_25","072_12_25","LUK","12","25","25","ꠇꠅ ꠌꠣꠁꠘ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠇꠞꠤꠀ ꠔꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠄꠇꠈꠣꠘ ꠊꠘ꠆ꠐꠣꠅ ꠛꠣꠠꠣꠁꠔ ꠙꠣꠞꠛ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK12_26","072_12_26","LUK","12","26","26","ꠀꠞ ꠅꠃ ꠢꠥꠞꠥ ꠇꠣꠝꠈꠣꠘꠃ ꠎꠦꠛꠟꠣ ꠙꠣꠞ ꠘꠣ, ꠔꠦ ꠇꠦꠘꠦ ꠛꠣꠠꠔꠤ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞ? ");
INSERT INTO syls_vpl VALUES ("LK12_27","072_12_27","LUK","12","27","27","“ꠔꠥꠝꠞꠣ ꠅꠃ ꠎꠋꠟꠤ ꠚꠥꠟꠞ ꠛꠣꠄ ꠌꠣꠅ, ꠁꠔꠣ ꠇꠔ ꠡꠥꠘ꠆ꠖꠞ! ꠁꠔꠣꠄ ꠔ ꠘꠤꠎꠞ ꠡꠥꠘ꠆ꠖꠞꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠦ ꠘꠣ, ꠇꠥꠘꠥ ꠞꠋ ꠡꠤꠟꠣꠁꠅ ꠇꠞꠦ ꠘꠣ, ꠛꠣꠁꠘꠅ ꠇꠞꠦ ꠘꠣ, ꠄꠝꠘꠦꠃ ꠅꠄ। ꠔꠦ ꠀꠝꠤ ꠇꠁꠀꠞ, ꠛꠣꠖꠡꠣ ꠍꠥꠟꠣꠁꠝꠣꠘ ꠅꠔ ꠎꠣꠇ-ꠎꠝꠇꠞ ꠝꠣꠎꠦ ꠞꠁꠟꠦꠅ ꠔꠣꠘ ꠟꠦꠛꠣꠍ ꠔ ꠅꠔꠣ ꠄꠉꠥ ꠎꠋꠟꠤ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘꠅ ꠡꠥꠘ꠆ꠖꠞ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_28","072_12_28","LUK","12","28","28","ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠎꠋꠉꠟꠞ ꠝꠣꠎꠦ ꠅꠃ ꠎꠔ ꠡꠥꠘ꠆ꠖꠞ ꠚꠥꠟ ꠅꠈꠘ ꠀꠍꠦ, ꠇꠣꠁꠟ ꠅꠁꠟꠦꠃ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠖꠣꠞꠥ ꠛꠣꠘꠣꠁꠀ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠛ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠥꠖꠤ ꠅꠃ ꠎꠋꠉꠟꠞꠦ ꠅꠟꠣ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠍꠂꠘ, ꠔꠦ ꠅ ꠇꠝꠎꠥꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞꠦꠅ ꠔꠣꠁꠘ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠔꠣ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK12_29","072_12_29","LUK","12","29","29","ꠔꠦ ꠇꠤꠟꠣ ꠈꠣꠁꠔꠣꠝ, ꠇꠤꠟꠣ ꠌꠟꠔꠣꠝ, ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠛꠣ ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_30","072_12_30","LUK","12","30","30","ꠁ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠈꠣꠟꠤ ꠅꠔꠣ ꠟꠁꠀꠃ ꠗꠣꠘ꠆ꠖꠣ ꠇꠞꠦ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚꠦ ꠔ ꠄꠝꠘꠦꠃ ꠎꠣꠘꠂꠘ, ꠔꠥꠝꠞꠣꠞ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("LK12_31","072_12_31","LUK","12","31","31","ꠄꠞꠖꠣꠄꠃ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠛꠣꠖ ꠖꠤꠀ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠗꠣꠘ꠆ꠖꠣꠔ ꠞꠅ, ꠔꠦꠃ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔꠣꠁꠘ ꠎꠥꠉꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_32","072_12_32","LUK","12","32","32","“ꠔꠥꠝꠞꠣꠃ ꠀꠝꠣꠞ ꠝꠦꠠꠣꠞ ꠙꠣꠟ, ꠔꠥꠝꠞꠣꠞ ꠖꠟ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠅꠁꠟꠦꠅ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚꠞ ꠝꠞ꠆ꠎꠤ ꠅꠁꠟ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠛꠣꠖꠡꠣꠁꠞ ꠜꠤꠔꠞꠅ ꠢꠣꠝꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("LK12_33","072_12_33","LUK","12","33","33","ꠔꠥꠝꠞꠣꠞ ꠎꠔꠔꠣ ꠀꠍꠦ, ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠦꠌꠤꠀ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅ, ꠀꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠈꠣꠟꠤ ꠅꠃꠟꠣ ꠄꠇ ꠇꠥꠕꠤ-ꠛꠦꠉ ꠔꠤꠀꠞ ꠇꠞꠅ, ꠎꠦ ꠇꠥꠕꠤ ꠇꠥꠘꠥꠖꠤꠘ ꠙꠥꠞꠣꠘ ꠅꠄ ꠘꠣ। ꠅꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠍꠣꠝꠣꠘꠣ ꠎꠝꠣ ꠇꠞꠅ, ꠎꠦꠈꠣꠘꠅ ꠍꠣꠝꠣꠘꠣ ꠇ꠆ꠇꠄ ꠅꠄ ꠘꠣ, ꠌꠥꠞꠦꠅ ꠘꠦꠄ ꠘꠣ, ꠙꠥꠇꠦꠅ ꠈꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_34","072_12_34","LUK","12","34","34","ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠗꠘ ꠎꠦꠘꠅ ꠞꠄ, ꠝꠘꠅ ꠢꠘꠅ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK12_35","072_12_35","LUK","12","35","35","“ꠔꠥꠝꠞꠣ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠀꠞ ꠛꠣꠔ꠆ꠔꠤ ꠎꠣꠟꠣꠁꠀ ꠔꠤꠀꠞ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LK12_36","072_12_36","LUK","12","36","36","ꠔꠥꠝꠞꠣ ꠅꠃ ꠎꠣꠔ ꠇꠣꠝꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠅ, ꠎꠣꠞꠣ ꠔꠣꠞꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠄ, ꠔꠣꠁꠘ ꠛꠤꠀꠞ ꠖꠣꠅꠔ ꠕꠣꠇꠤ ꠚꠤꠞꠔ ꠀꠁꠀ ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣ ꠖꠤꠟꠦꠃ, ꠟꠉꠦ ꠟꠉꠦ ꠖꠥꠀꠞ ꠈꠥꠟꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK12_37","072_12_37","LUK","12","37","37","ꠢꠃ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠃ ꠇꠙꠣꠟꠤ, ꠎꠦꠞꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠀꠁꠀ ꠢꠎꠣꠉ ꠙꠣꠁꠛꠣ। ꠀꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠝꠥꠘꠤꠛꠦ ꠀꠁꠀ ꠢꠣꠞꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠇꠝꠞꠅ ꠉꠣꠝꠍꠣ ꠛꠣꠘ꠆ꠖꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠈꠣꠘꠤꠔ ꠛꠅꠀꠁꠛꠣ, ꠀꠞ ꠘꠤꠎꠞ ꠀꠔꠦ ꠛꠣꠠꠤꠀ ꠈꠣꠅꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_38","072_12_38","LUK","12","38","38","ꠔꠣꠞꠣꠃ ꠛꠠ ꠇꠙꠣꠟꠤ, ꠎꠦꠞꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠀꠗꠣ ꠞꠣꠁꠔ ꠛꠣ ꠢꠦꠡ ꠞꠣꠁꠔꠦ ꠀꠁꠀ ꠒꠣꠇ ꠖꠤꠟꠦꠃ ꠢꠎꠣꠉ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_39","072_12_39","LUK","12","39","39","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠌꠥꠞ ꠇꠥꠘ ꠡꠝꠄ ꠀꠁꠛ, ꠉꠤꠞꠡ꠆ꠔꠦ ꠁꠈꠣꠘ ꠎꠣꠘꠟꠦ ꠔ ꠢꠦ ꠢꠎꠣꠉ ꠞꠁꠟ ꠅꠘꠦ, ꠔꠣꠞ ꠊꠞꠅ ꠢꠤꠋ ꠇꠣꠐꠔꠦ ꠖꠤꠟ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("LK12_40","072_12_40","LUK","12","40","40","ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠔꠤꠀꠞ ꠞꠁꠅ, ꠇꠣꠞꠘ ꠎꠦ ꠅꠇ꠆ꠔꠞ ꠇꠕꠣ ꠔꠥꠝꠞꠣ ꠌꠤꠘ꠆ꠔꠣꠃ ꠇꠞꠔꠣꠄ ꠘꠣꠄ, ꠢꠃ ꠡꠝꠄꠃ ꠛꠤꠘ-ꠀꠖꠝꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK12_41","072_12_41","LUK","12","41","41","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠘꠍꠤꠅꠔ ꠈꠣꠟꠤ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ, ꠘꠣ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK12_42","072_12_42","LUK","12","42","42","ꠢꠥꠎꠥꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠈꠟꠖꠣꠞ ꠀꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠅꠃ ꠎꠘ ꠇꠦ, ꠎꠣꠞ ꠀꠔꠅ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠖꠦꠈꠣ-ꠢꠥꠘꠣꠞ ꠜꠣꠞ ꠖꠤꠛꠣ, ꠢꠦ ꠅꠇ꠆ꠔꠞ ꠇꠣꠟꠅ ꠔꠣꠞꠣꠞ ꠈꠣꠘꠤ ꠛꠣꠐꠤꠀ ꠖꠤꠛ? ");
INSERT INTO syls_vpl VALUES ("LK12_43","072_12_43","LUK","12","43","43","ꠢꠃ ꠉꠥꠟꠣꠝꠃ ꠇꠙꠣꠟꠤ, ꠎꠣꠞꠦ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠀꠁꠀ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠣꠔ ꠖꠦꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_44","072_12_44","LUK","12","44","44","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠢꠃ ꠝꠥꠘꠤꠛꠦ ꠔꠣꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠔꠖꠣꠞꠇꠤꠞ ꠄꠈꠔꠤꠀꠞ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_45","072_12_45","LUK","12","45","45","ꠅꠁꠟꠦ ꠗꠞꠤꠟꠣꠅ, ꠢꠃ ꠉꠥꠟꠣꠝꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟ, ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛ ꠀꠁꠔꠦ ꠔ ꠛꠃꠔ ꠖꠦꠞꠤ ꠀꠍꠦ, ꠀꠞ ꠅꠃ ꠚꠣꠇꠦ ꠢꠦ ꠢꠇ꠆ꠇꠟ ꠛꠣꠘ꠆ꠖꠤ-ꠉꠥꠟꠣꠝꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠟ, ꠈꠣꠁꠀ-ꠖꠣꠁꠀ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠤꠀ, ꠝꠖ ꠈꠣꠁꠀ ꠐꠣꠟ ꠅꠁꠀ ꠙꠠꠤ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK12_46","072_12_46","LUK","12","46","46","ꠛꠣꠖꠦ ꠎꠦ ꠖꠤꠘ ꠀꠞ ꠎꠦ ꠅꠇ꠆ꠔꠞ ꠇꠕꠣ ꠢꠦ ꠌꠤꠘ꠆ꠔꠣꠃ ꠇꠞꠔ ꠘꠣꠄ, ꠢꠃ ꠖꠤꠘ ꠀꠞ ꠢꠃ ꠅꠇ꠆ꠔꠅ ꠔꠣꠞ ꠝꠥꠘꠤꠛ ꠀꠁꠀ ꠀꠎꠤꠞ ꠅꠁꠛꠣ। ꠔꠣꠁꠘ ꠔꠣꠞꠦ ꠄꠇ ꠍꠦꠖꠦ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠇꠞꠤꠀ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠇꠣꠔꠣꠞꠅ ꠝꠤꠡꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK12_47","072_12_47","LUK","12","47","47","“ꠀꠞ ꠎꠦ ꠉꠥꠟꠣꠝꠦ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠝꠞ꠆ꠎꠤꠞꠦ ꠛꠥꠎꠤꠀꠅ ꠔꠤꠀꠞ ꠅꠁꠍꠦ ꠘꠣ, ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠍꠦ ꠘꠣ, ꠔꠣꠞꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠝꠣꠁꠞ ꠝꠣꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK12_48","072_12_48","LUK","12","48","48","ꠅꠁꠟꠦ ꠘꠣ ꠎꠣꠘꠤꠀ ꠎꠥꠖꠤ ꠢꠦ ꠡꠣꠎꠣ ꠙꠣꠁꠛꠣꠞ ꠇꠣꠝ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠡꠣꠎꠣ ꠇꠝ ꠅꠁꠛ। ꠎꠣꠞꠦ ꠛꠦꠡꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠔꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠛꠦꠡꠤ ꠌꠣꠅꠀ ꠅꠁꠛ, ꠀꠞ ꠎꠣꠞ ꠉꠦꠍꠦ ꠛꠦꠡꠤ ꠙꠞꠤꠝꠣꠘꠦ ꠕꠅꠀ ꠅꠁꠍꠦ, ꠔꠣꠞ ꠉꠦꠍꠦꠃ ꠛꠦꠡꠤ ꠖꠣꠛꠤ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK12_49","072_12_49","LUK","12","49","49","“ꠀꠝꠤ ꠔ ꠖꠥꠘꠤꠀꠔ ꠀꠉꠥꠁꠘ ꠟꠣꠉꠣꠘꠤꠔ ꠀꠁꠍꠤ। ꠅꠈꠘ ꠎꠥꠖꠤ ꠁ ꠀꠉꠥꠁꠘꠈꠣꠘ ꠎꠟꠤꠎꠤꠔ, ꠔꠦ ꠛꠠ ꠜꠣꠟꠣ ꠅꠁꠟ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("LK12_50","072_12_50","LUK","12","50","50","ꠀꠝꠤ ꠔ ꠄꠇ ꠈꠣꠍ ꠉꠥꠍꠟ ꠇꠞꠣꠃ ꠟꠣꠉꠛ। ꠔꠦ ꠀꠝꠣꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠁ ꠉꠥꠍꠟ ꠎꠔꠖꠤꠘ ꠘꠣ ꠅꠁꠍꠦ, ꠅꠔ ꠖꠤꠘ ꠀꠝꠣꠞ ꠙꠦꠞꠦꠡꠣꠘꠤꠞ ꠇꠥꠘꠥ ꠡꠤꠝꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LK12_51","072_12_51","LUK","12","51","51","ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠇꠞꠞꠣꠄ ꠘꠤ, ꠀꠝꠤ ꠖꠥꠘꠤꠀꠔ ꠡꠣꠘ꠆ꠔꠤ ꠖꠤꠔꠣꠝ ꠀꠁꠍꠤ? ꠘꠣ, ꠝꠥꠐꠦꠃ ꠘꠣꠄ, ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠀꠝꠤ ꠔ ꠖꠥꠘꠤꠀꠔ ꠄꠇ ꠝꠔꠜꠦꠖ ꠟꠣꠉꠣꠘꠤꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LK12_52","072_12_52","LUK","12","52","52","ꠅꠈꠘ ꠕꠣꠇꠤ ꠄꠇ ꠊꠞꠞ ꠙꠣꠌꠎꠘ ꠎꠣꠞꠎꠤꠞ ꠀꠟꠉ ꠅꠁꠎꠤꠛ। ꠔꠤꠘꠎꠘ ꠖꠥꠁꠎꠘꠞ ꠛꠤꠙꠇ꠆ꠇꠦ, ꠀꠞ ꠖꠥꠁꠎꠘ ꠔꠤꠘꠎꠘꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("LK12_53","072_12_53","LUK","12","53","53","ꠛꠣꠚꠦ ꠙꠥꠀꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠀꠞ ꠙꠥꠀ ꠛꠣꠚꠞ ꠛꠤꠙꠇ꠆ꠇꠦ। ꠝꠣ ꠙꠥꠠꠤꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠀꠞ ꠙꠥꠠꠤꠄ ꠝꠣʼꠞ ꠛꠤꠙꠇ꠆ꠇꠦ। ꠢꠠꠤ ꠛꠃꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠀꠞ ꠛꠃꠄ ꠢꠠꠤꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK12_54","072_12_54","LUK","12","54","54","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠙꠁꠌꠝꠦꠖꠤ ꠇꠣꠟꠘꠤ ꠖꠦꠈꠟꠦꠃ ꠇꠅ, ꠝꠦꠊ ꠀꠁꠅꠞ। ꠀꠞ ꠢꠣꠍꠣꠃ ꠝꠦꠊ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("LK12_55","072_12_55","LUK","12","55","55","ꠢꠤꠞꠛꠣꠞ ꠖꠇ꠆ꠇꠤꠘꠣ ꠛꠣꠔꠣꠡ ꠌꠣꠟꠥ ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠅ, ꠈꠞꠣ ꠅꠁꠛ, ꠀꠞ ꠅꠟꠣꠃ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LK12_56","072_12_56","LUK","12","56","56","ꠅ ꠜꠘ꠆ꠒ ꠅꠇꠟ! ꠔꠥꠝꠞꠣ ꠀꠍꠝꠣꠘ ꠀꠞ ꠎꠝꠤꠘꠞ ꠍꠥꠞꠔ ꠛꠥꠎꠔꠣꠄ ꠙꠣꠞ, ꠔꠦ ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠇꠦꠘꠦ ꠛꠥꠎ ꠘꠣ? ");
INSERT INTO syls_vpl VALUES ("LK12_57","072_12_57","LUK","12","57","57","“ꠇꠥꠘꠈꠣꠘ ꠑꠤꠇ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠘꠤꠎꠦꠃ ꠛꠤꠌꠣꠞ ꠇꠞ ꠘꠣ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("LK12_58","072_12_58","LUK","12","58","58","ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠟꠁꠀ ꠢꠣꠇꠤꠝꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠁꠛꠣꠞ ꠀꠉꠦ, ꠛꠤꠙꠇ꠆ꠇꠞ ꠟꠉꠦ ꠙꠕꠅ ꠛꠁꠀꠃ ꠝꠤꠐ-ꠝꠣꠐ ꠇꠞꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤꠅ। ꠀꠞꠘꠣꠄ ꠢꠦ ꠔꠥꠝꠣꠞꠦ ꠗꠞꠤꠀ ꠢꠣꠇꠤꠝꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠛ, ꠢꠣꠇꠤꠝꠦ ꠙꠥꠟꠤꠡꠞ ꠀꠔꠅ ꠖꠤꠛ, ꠀꠞ ꠙꠥꠟꠤꠡꠦ ꠘꠤꠀ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK12_59","072_12_59","LUK","12","59","59","ꠢꠦꠡꠦ ꠡꠦꠡ ꠙꠄꠡꠣꠐꠣ ꠀꠖꠣꠄ ꠘꠣ ꠇꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠎꠦꠟ ꠕꠣꠇꠤ ꠍꠣꠠꠣ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ, ꠁꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK13_1","072_13_1","LUK","13","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠛꠄꠀꠘ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠢꠘꠞ ꠇꠄꠎꠘ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠢꠃ ꠙꠣꠇ ꠎꠣꠉꠣꠔ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠀ, ꠔꠣꠞꠣꠞ ꠟꠃ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ ꠄꠇꠟꠉꠦ ꠝꠤꠡꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK13_2","072_13_2","LUK","13","2","2","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠞꠣꠞ ꠝꠃꠔ ꠅꠟꠣ ꠅꠀꠄ, ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠇꠞꠞꠣꠄ ꠘꠤ, ꠉꠣꠟꠤꠟꠞ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ ꠄꠞꠣ ꠛꠦꠡꠤ ꠉꠥꠘꠣꠉꠣꠞ ꠀꠍꠤꠟ? ");
INSERT INTO syls_vpl VALUES ("LK13_3","072_13_3","LUK","13","3","3","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠘꠣ, ꠁꠟꠣ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠔꠃꠛꠣ ꠘꠣ ꠇꠞ, ꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK13_4","072_13_4","LUK","13","4","4","ꠢꠥꠘꠅ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠍꠤꠟꠥꠀ ꠄꠟꠣꠇꠣꠞ ꠢꠃ ꠃꠌꠣ ꠝꠤꠘꠣꠞꠣ ꠜꠣꠋꠉꠣꠄ ꠎꠦ ꠀꠑꠣꠞ ꠎꠘ ꠝꠣꠞꠣ ꠉꠦꠍꠤꠟ, ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞ? ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠛꠣꠇꠤ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ ꠄꠞꠣ ꠛꠦꠡꠤ ꠉꠥꠘꠣꠉꠣꠞ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK13_5","072_13_5","LUK","13","5","5","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠘꠣ, ꠁꠈꠣꠘ ꠑꠤꠇ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠔꠃꠛꠣ ꠘꠣ ꠇꠞ, ꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK13_6","072_13_6","LUK","13","6","6","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ, “ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠘ ꠛꠣꠉꠣꠘꠅ ꠒꠥꠝꠥꠞꠞ ꠄꠇꠐꠣ ꠉꠣꠍ ꠟꠣꠉꠣꠁꠟꠣ। ꠡꠝꠄ ꠀꠁꠟꠦ ꠄꠁꠘ ꠀꠁꠀ ꠉꠣꠍꠅ ꠚꠟ ꠔꠥꠇꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠚꠟ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK13_7","072_13_7","LUK","13","7","7","ꠘꠣ ꠙꠣꠁꠀ ꠛꠣꠉꠣꠘꠞ ꠝꠣꠟꠤꠞꠦ ꠇꠁꠟꠣ, ꠢꠥꠘꠅ, ꠀꠁꠎ ꠔꠤꠘ ꠛꠍꠞ ꠗꠞꠤ ꠅꠃ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠅ ꠚꠟ ꠔꠥꠇꠣꠁꠞꠣꠝ, ꠅꠁꠟꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠙꠣꠁꠞꠣꠝ ꠘꠣ। ꠔꠦ ꠔꠥꠝꠤ ꠉꠣꠍꠉꠥ ꠇꠣꠐꠤꠟꠣꠅ, ꠁꠉꠥꠄ ꠈꠣꠝꠈꠣ ꠎꠝꠤꠘꠞ ꠞꠡ ꠐꠣꠘꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("LK13_8","072_13_8","LUK","13","8","8","ꠝꠣꠟꠤꠄ ꠇꠁꠟ, ꠍꠣꠛ, ꠁ ꠛꠍꠞꠈꠣꠘꠅ ꠕꠣꠇꠃꠇ। ꠀꠝꠤ ꠅꠉꠥꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠞ ꠝꠣꠐꠤ ꠈꠥꠠꠤꠀ ꠡꠣꠞ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LK13_9","072_13_9","LUK","13","9","9","ꠍꠣꠝꠘꠞ ꠛꠍꠞ ꠎꠥꠖꠤ ꠚꠟ ꠗꠞꠤꠟꠣꠄ, ꠔꠦ ꠔ ꠜꠣꠟꠣ, ꠘꠣꠁꠟꠦ ꠇꠣꠐꠤꠟꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK13_10","072_13_10","LUK","13","10","10","ꠄꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠁꠍꠣ ꠝꠍꠤꠖꠞ ꠜꠤꠔꠞꠦ ꠘꠍꠤꠅꠔ ꠇꠞꠣꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK13_11","072_13_11","LUK","13","11","11","ꠢꠘꠅ ꠄꠇ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠀꠍꠤꠟ, ꠁ ꠛꠦꠐꠤꠞ ꠃꠙꠞꠦ ꠀꠑꠣꠞ ꠛꠍꠞ ꠗꠞꠤ ꠀꠔꠡꠤ-ꠖꠦꠅꠄ ꠀꠍꠞ ꠇꠞꠍꠤꠟ। ꠖꠦꠅꠄ ꠛꠦꠐꠤꠞꠦ ꠉꠥꠎꠣ ꠛꠣꠘꠣꠁꠟꠤꠍꠤꠟ, ꠛꠦꠐꠤ ꠡꠤꠗꠣ ꠅꠁꠀ ꠃꠛꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK13_12","072_13_12","LUK","13","12","12","ꠁꠍꠣꠄ ꠛꠦꠐꠤꠞꠦ ꠒꠣꠇꠖꠤ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠘꠤꠀ ꠇꠁꠟꠣ, “ꠝꠣꠁ ꠉ, ꠔꠥꠝꠤ ꠅꠈꠘ ꠁ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠍ।” ");
INSERT INTO syls_vpl VALUES ("LK13_13","072_13_13","LUK","13","13","13","ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠛꠦꠐꠤꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠟꠣ। ꠟꠉꠦ ꠟꠉꠦꠃ ꠛꠦꠐꠤ ꠡꠤꠗꠣ ꠅꠁꠀ ꠃꠛꠣꠁꠟ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK13_14","072_13_14","LUK","13","14","14","ꠅꠁꠟꠦ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠔꠣꠁꠘ ꠁ ꠛꠦꠐꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠣꠄ, ꠝꠍꠤꠖꠞ ꠝꠔꠟ꠆ꠟꠤꠄ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔ ꠛꠣꠇꠤ ꠍꠄꠖꠤꠘꠃ ꠀꠔꠅ ꠀꠍꠦ। ꠔꠥꠝꠞꠣ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠘꠣ ꠀꠁꠀ ꠅꠁꠘ꠆ꠘ ꠎꠦꠇꠥꠘꠥ ꠖꠤꠘ ꠀꠁꠀ ꠜꠣꠟꠣ ꠅꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK13_15","072_13_15","LUK","13","15","15","ꠔꠦꠃ ꠁꠍꠣꠄ ꠢꠤ ꠝꠔꠟ꠆ꠟꠤꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠜꠘ꠆ꠒ ꠅꠇꠟ! ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠀꠙꠘꠣꠞꠣꠞ ꠉꠞꠥ-ꠉꠣꠗꠣꠞꠦ ꠉꠥꠀꠟꠣꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠙꠣꠘꠤ ꠈꠣꠛꠣꠁꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK13_16","072_13_16","LUK","13","16","16","ꠀꠁꠎ ꠀꠑꠣꠞ ꠛꠍꠞ ꠗꠞꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠅꠃ ꠀꠅꠟꠣꠖꠞꠦ ꠡꠄꠔꠣꠘꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠣꠈꠍꠤꠟ। ꠅꠈꠘ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠁ ꠛꠦꠐꠤꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠣ ꠎꠣꠁꠎ ꠅꠁꠍꠦ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK13_17","072_13_17","LUK","13","17","17","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠎꠦꠞꠣ ꠔꠣꠘ ꠛꠤꠙꠇ꠆ꠇꠦ ꠀꠍꠤꠟ ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠟ। ꠅꠁꠟꠦ ꠛꠣꠇꠤ ꠝꠥꠍꠟ꠆ꠟꠤ ꠅꠇꠟꠦ ꠔꠣꠘ ꠢꠇꠟ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠤꠀ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK13_18","072_13_18","LUK","13","18","18","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞꠦ ꠀꠝꠤ ꠇꠤꠔꠣꠞ ꠟꠉꠦ ꠔꠥꠟꠘꠣ ꠇꠞꠔꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("LK13_19","072_13_19","LUK","13","19","19","ꠝꠘꠅ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟꠉꠤ ꠄꠉꠥ ꠒꠦꠋꠉꠣ ꠛꠤꠌꠤꠞ ꠟꠣꠈꠣꠘ, ꠇꠥꠘꠥ ꠉꠤꠞꠡ꠆ꠔꠦ ꠔꠣꠞ ꠎꠝꠤꠘꠅ ꠘꠤꠀ ꠅꠃ ꠛꠤꠌꠤ ꠛꠣꠁꠘ ꠖꠤꠟ, ꠛꠣꠖꠦ ꠁꠐꠣ ꠛꠠ ꠅꠁꠀ ꠉꠣꠍ ꠅꠁꠉꠦꠟ, ꠀꠞ ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠉꠣꠍꠞ ꠒꠣꠟꠅ ꠛꠣꠖꠣ ꠛꠣꠘꠣꠁꠟ।” ");
INSERT INTO syls_vpl VALUES ("LK13_20","072_13_20","LUK","13","20","20","ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠔꠥꠟꠘꠣ ꠀꠝꠤ ꠇꠤꠔꠣꠞ ꠟꠉꠦ ꠇꠞꠔꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("LK13_21","072_13_21","LUK","13","21","21","ꠗꠞꠃꠇ꠆ꠇꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠅꠁꠟꠉꠤ ꠈꠣꠝꠤꠞꠞ ꠟꠣꠈꠣꠘ, ꠇꠥꠘꠥ ꠄꠇ ꠛꠦꠐꠤꠄ ꠕꠥꠠꠣ ꠈꠣꠝꠤꠞ ꠘꠤꠀ ꠄꠇ ꠝꠘ ꠝꠄꠖꠣꠞ ꠟꠉꠦ ꠝꠣꠈꠤꠟ, ꠀꠞ ꠈꠣꠝꠤꠞꠞ ꠚꠣꠚꠦ ꠢꠇꠟ ꠝꠄꠖꠣ ꠚꠥꠟꠤꠀ ꠃꠑꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("LK13_22","072_13_22","LUK","13","22","22","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠐꠤ ꠀꠐꠤ ꠉꠣꠃꠄ ꠉꠣꠃꠄ ꠀꠞ ꠐꠣꠃꠘꠦ ꠐꠣꠃꠘꠦ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠛꠣꠄ ꠀꠉꠥꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK13_23","072_13_23","LUK","13","23","23","ꠄꠞꠝꠣꠎꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠦ ꠎꠤꠇꠣꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠎꠦꠞꠣ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠛꠣ, ꠄꠞꠣ ꠙꠞꠤꠝꠣꠘꠦ ꠈꠥꠛ ꠇꠝ ꠘꠤ?” ꠅꠃ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK13_24","072_13_24","LUK","13","24","24","“ꠌꠤꠙꠣ ꠖꠥꠀꠞꠦꠖꠤ ꠢꠣꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠚꠤꠇꠤꠞ ꠇꠞꠅ। ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠛꠃꠔ ꠎꠘ ꠁꠘꠅ ꠢꠣꠝꠣꠁꠔꠦ ꠌꠣꠁꠟꠦꠅ, ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK13_25","072_13_25","LUK","13","25","25","ꠊꠞꠞ ꠝꠣꠟꠤꠇꠦ ꠎꠦꠛꠟꠣ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟꠤꠛꠣ, ꠔꠥꠝꠞꠣ ꠛꠣꠞꠦ ꠃꠛꠣꠁꠀ ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣꠁꠔꠦ ꠑꠥꠇꠣꠁꠔꠦ ꠇꠁꠛꠣꠄ, ‘ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞꠦ ꠖꠥꠀꠞꠈꠣꠘ ꠈꠥꠟꠤꠀ ꠖꠦꠃꠇ꠆ꠇꠣ।’ ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠛꠣ, ‘ꠔꠥꠝꠞꠣ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍ, ꠀꠝꠤ ꠔ ꠌꠤꠘꠤꠃ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("LK13_26","072_13_26","LUK","13","26","26","ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠇꠁꠛꠣꠄ, ‘ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠈꠣꠁꠍꠤ-ꠛꠁꠍꠤ, ꠀꠙꠘꠦ ꠔ ꠀꠝꠞꠣꠞ ꠙꠕꠅ-ꠊꠣꠐꠅ ꠀꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠘꠍꠤꠅꠔ ꠇꠞꠔꠣ।’ ");
INSERT INTO syls_vpl VALUES ("LK13_27","072_13_27","LUK","13","27","27","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠁꠛꠣ, ‘ꠢꠣꠄꠞꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟ, ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠅ। ꠔꠥꠝꠞꠣ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍ, ꠀꠝꠤ ꠔ ꠌꠤꠘꠤꠃ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("LK13_28","072_13_28","LUK","13","28","28","“ꠔꠥꠝꠞꠣ ꠖꠦꠈꠛꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ, ꠁꠀꠇꠥꠛ ꠀꠞ ꠔꠣꠝꠣꠝ ꠘꠛꠤ ꠅꠇꠟ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠖꠣꠈꠤꠟ ꠅꠁꠍꠂꠘ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠞꠣꠁꠀ ꠚꠣꠟꠣꠘꠤ ꠅꠁꠍꠦ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠛꠣꠄ ꠀꠞ ꠇꠦꠃ ꠖꠣꠔ ꠇꠤꠠꠤꠝꠤꠠꠤ ꠈꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK13_29","072_13_29","LUK","13","29","29","ꠀꠞꠅ ꠖꠦꠈꠛꠣꠄ, ꠖꠥꠘꠤꠀꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠣꠇꠤ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠖꠣꠈꠤꠟ ꠅꠁꠀ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠈꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK13_30","072_13_30","LUK","13","30","30","ꠔꠦ ꠎꠦꠞꠣ ꠅꠈꠘ ꠈꠞꠞ ꠇꠣꠔꠣꠞꠅ ꠀꠍꠦ, ꠔꠣꠞꠣ ꠇꠦꠃ ꠇꠦꠃ ꠀꠉꠦ ꠀꠁꠛ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠎꠦꠞꠣ ꠀꠉꠞ ꠇꠣꠔꠣꠞꠅ ꠀꠍꠦ ꠔꠣꠞꠣ ꠇꠦꠃ ꠇꠦꠃ ꠈꠞꠦ ꠎꠣꠁꠛꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK13_31","072_13_31","LUK","13","31","31","ꠔꠣꠁꠘ ꠅꠔꠣ ꠝꠣꠔꠤꠞꠣ, ꠄꠞꠝꠣꠎꠦ ꠀꠈꠔꠣꠃ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠇꠄꠎꠘ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠁꠘ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠎꠣꠁꠘꠉꠤ, ꠇꠣꠞꠘ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠦ ꠀꠙꠘꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠌꠣꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK13_32","072_13_32","LUK","13","32","32","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠉꠤꠀ ꠢꠃ ꠢꠤꠀꠟꠞ ꠍꠣꠅꠞꠦ ꠇꠃꠇ꠆ꠇꠣ, ꠀꠁꠎ ꠀꠞ ꠇꠣꠁꠟ ꠀꠝꠤ ꠎꠤꠘ꠆ꠘꠣꠔ ꠍꠣꠠꠣꠁꠝꠥ, ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞ ꠡꠤꠚꠣ ꠇꠞꠝꠥ, ꠙꠞꠥ ꠖꠤꠘ ꠀꠝꠣꠞ ꠇꠣꠝ ꠡꠦꠡ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK13_33","072_13_33","LUK","13","33","33","ꠔꠦ ꠎꠦꠟꠣꠃ ꠅꠃꠇ, ꠀꠁꠎ, ꠇꠣꠁꠟ ꠀꠞ ꠙꠞꠥ, ꠅꠃ ꠔꠤꠘ ꠖꠤꠘ ꠀꠝꠣꠞ ꠌꠟꠣꠃ ꠟꠣꠉꠛ। ꠀꠝꠤ ꠔ ꠎꠣꠘꠤꠃ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠛꠣꠞꠦ ꠇꠥꠘꠥ ꠘꠛꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK13_34","072_13_34","LUK","13","34","34","“ꠎꠦꠞꠥꠎꠣꠟꠦꠝ! ꠢꠣꠄꠞꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ! ꠔꠥꠝꠤ ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞ। ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠞꠣꠞꠦ ꠛꠦꠎꠣ ꠅꠁꠍꠦ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠍ। ꠝꠥꠞꠉꠤꠄ ꠎꠦꠟꠣ ꠔꠣꠁꠞ ꠍꠣꠅꠞꠦ ꠒꠣꠈꠘꠣꠞ ꠔꠟꠦ ꠀꠡꠞꠄ ꠖꠦꠄ, ꠀꠝꠤ ꠅꠃꠟꠣ ꠔꠥꠝꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠡꠞꠄ ꠖꠤꠔꠣꠝ ꠌꠣꠁꠍꠤ, ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠞꠣꠎꠤ ꠅꠁꠟꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK13_35","072_13_35","LUK","13","35","35","ꠔꠦ ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤ ꠈꠣꠟꠤ-ꠛꠣꠠꠤ ꠅꠁꠛ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠎꠔꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠘꠣ ꠇꠁꠛꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠎꠦꠁꠘ ꠀꠁꠞꠣ ꠔꠣꠁꠘꠃ ꠝꠥꠛꠣꠞꠇ, ꠅꠔ ꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK14_1","072_14_1","LUK","14","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠄꠇ ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠛꠣꠠꠤꠔ ꠇꠥꠘꠥ ꠄꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠖꠣꠅꠔꠅ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠔꠣꠘ ꠛꠣꠄ ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠞꠤ ꠌꠃꠈ ꠞꠣꠈꠟ। ");
INSERT INTO syls_vpl VALUES ("LK14_2","072_14_2","LUK","14","2","2","ꠀꠈꠔꠣꠃ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠄꠇ ꠛꠦꠝꠣꠞꠤ ꠛꠦꠐꠣ ꠀꠁꠟ, ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟ ꠛꠦꠝꠣꠞꠦ ꠚꠥꠟꠤꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK14_3","072_14_3","LUK","14","3","3","ꠔꠦꠃ ꠁꠍꠣꠄ ꠢꠘꠞ ꠀꠟꠤꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK14_4","072_14_4","LUK","14","4","4","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠢꠇꠟ ꠘꠤꠞꠣꠁ ꠞꠁꠟꠣ, ꠀꠞ ꠁꠍꠣꠄ ꠢꠤ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠤꠀ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_5","072_14_5","LUK","14","5","5","ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠎꠘ ꠀꠍꠦ ꠘꠤ, ꠎꠣꠞ ꠇꠥꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠛꠣ ꠉꠞꠥ-ꠍꠣꠉꠟ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠙꠣꠘꠤꠔ ꠙꠠꠤꠉꠦꠟꠦ, ꠢꠦ ꠁꠉꠥꠞꠦ ꠙꠣꠘꠤ ꠕꠣꠇꠤ ꠔꠥꠟꠦ ꠘꠣ?” ");
INSERT INTO syls_vpl VALUES ("LK14_6","072_14_6","LUK","14","6","6","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_7","072_14_7","LUK","14","7","7","ꠀꠞ ꠎꠦ ꠝꠦꠝꠣꠘ ꠅꠇꠟ ꠖꠣꠅꠔꠅ ꠀꠁꠍꠂꠘ, ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠎꠣꠉꠣ ꠔꠥꠇꠣꠁ ꠛꠁꠞꠣ ꠖꠦꠈꠤꠀ, ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK14_8","072_14_8","LUK","14","8","8","“ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠛꠤꠀꠞ ꠖꠣꠅꠔ ꠖꠤꠟꠦ, ꠔꠥꠝꠤ ꠝꠎꠟꠤꠍꠅ ꠢꠣꠝꠣꠁꠀ ꠖꠣꠝꠤ ꠎꠣꠉꠣꠔ ꠛꠅꠀ ꠑꠤꠇ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠝꠣꠟꠤꠇꠦ ꠇꠤꠛꠣꠘ ꠔꠥꠝꠣꠞ ꠕꠣꠇꠤ ꠀꠞꠅ ꠁꠎ꠆ꠎꠔꠤ ꠇꠦꠃꠞꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK14_9","072_14_9","LUK","14","9","9","ꠔꠦ ꠅꠁꠟꠦ ꠎꠦꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ ꠔꠣꠁꠘ ꠀꠁꠀ ꠇꠁꠛꠣ, ꠅꠃ ꠍꠤꠐ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠀꠝꠣꠞ ꠖꠣꠝꠤ ꠝꠦꠝꠣꠘꠞꠦ ꠛꠁꠛꠣꠞ ꠖꠦꠁꠘ। ꠔꠦꠃ ꠔꠥꠝꠤ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠄꠝꠘꠦꠃ ꠢꠇꠟ ꠕꠣꠇꠤ ꠘꠤꠌꠣ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠛꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK14_10","072_14_10","LUK","14","10","10","ꠄꠞꠖꠣꠄ ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠖꠣꠅꠔꠅ ꠉꠦꠟꠦ ꠙꠄꠟꠣ ꠘꠤꠌꠣ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠛꠁꠅ। ꠔꠦꠃ ꠎꠣꠞ ꠛꠣꠠꠤꠔ ꠖꠣꠅꠔꠅ ꠉꠦꠍ ꠔꠣꠁꠘ ꠀꠁꠀ ꠇꠁꠛꠣ, ꠜꠣꠁꠍꠣꠛ, ꠁꠘꠅ ꠇꠦꠘꠦ ꠛꠁꠍꠂꠘ, ꠜꠣꠟꠣ ꠎꠣꠉꠣꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠃꠇ꠆ꠇꠣ। ꠄꠔꠦ ꠀꠞꠅ ꠝꠦꠝꠣꠘ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠣꠞ ꠁꠎ꠆ꠎꠔ ꠛꠣꠠꠛ। ");
INSERT INTO syls_vpl VALUES ("LK14_11","072_14_11","LUK","14","11","11","ꠀꠍꠟꠦ ꠎꠦ ꠘꠤꠎꠞꠦ ꠛꠠ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠣꠞꠦ ꠢꠥꠞꠥ ꠇꠞꠣ ꠅꠁꠛ। ꠀꠞ ꠎꠦ ꠘꠤꠎꠞꠦ ꠢꠥꠞꠥ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠣꠞꠦ ꠛꠠ ꠇꠞꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK14_12","072_14_12","LUK","14","12","12","ꠎꠦ ꠝꠃꠟꠣꠘꠣꠄ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠟꠣ, ꠁꠍꠣꠄ ꠄꠘꠞꠦ ꠇꠁꠟꠣ, “ꠖꠤꠘꠞ ꠛꠣ ꠞꠣꠁꠔꠇꠥꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠅꠘꠥꠡ꠆ꠑꠣꠘ ꠇꠞꠟꠦ, ꠔꠥꠝꠣꠞ ꠛꠘ꠆ꠖꠥ-ꠛꠣꠘ꠆ꠖꠛ, ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞ, ꠈꠦꠡ-ꠇꠥꠐꠥꠝ, ꠀꠞ ꠗꠣꠞꠅ ꠇꠣꠍꠞ ꠗꠘꠤ ꠝꠣꠘꠡꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠅ ꠘꠣ। ꠔꠣꠞꠣꠞꠦ ꠈꠣꠅꠀꠁꠟꠦ ꠛꠣꠖꠦ ꠔꠣꠞꠣꠅ ꠔꠥꠝꠣꠞꠦ ꠈꠣꠅꠀꠁꠀ ꠛꠖꠟꠣ ꠖꠤꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_13","072_14_13","LUK","14","13","13","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠔꠦ ꠌꠣꠁꠟꠦ, ꠈꠣꠟꠤ ꠉꠞꠤꠛ ꠝꠣꠘꠥꠡ, ꠀꠔꠥꠞ, ꠀꠘ꠆ꠖꠣ, ꠟꠥꠟꠣ-ꠟꠦꠋꠠꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LK14_14","072_14_14","LUK","14","14","14","ꠄꠞꠣ ꠔ ꠚꠤꠞꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠈꠣꠅꠀꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠄꠔꠦ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠔꠥꠝꠤ ꠙꠞꠦꠎꠉꠣꠞ ꠅꠇꠟꠞ ꠟꠉꠦ ꠁꠔꠣꠞ ꠛꠖꠟꠣ ꠙꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK14_15","072_14_15","LUK","14","15","15","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠃ ꠈꠣꠘꠤꠞ ꠝꠎꠟꠤꠍꠞ ꠄꠇꠎꠘꠦ ꠇꠁꠟꠣ, “ꠝꠥꠛꠣꠞꠇ ꠢꠃ ꠛꠘ꠆ꠖꠣ, ꠎꠦꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠛꠁꠀ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK14_16","072_14_16","LUK","14","16","16","ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠇꠥꠘꠥ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠈꠥꠛ ꠛꠠ ꠄꠇ ꠝꠦꠎꠛꠣꠘꠤ ꠇꠞꠤꠀ, ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_17","072_14_17","LUK","14","17","17","ꠈꠣꠅꠀꠞ ꠡꠝꠄ ꠅꠁꠟꠦ ꠔꠣꠘ ꠉꠥꠟꠣꠝꠞꠦꠖꠤ ꠇꠅꠀꠁꠟꠣ, ‘ꠀꠙꠘꠣꠞꠣ ꠀꠁꠃꠇ꠆ꠇꠣ, ꠈꠣꠘꠣ ꠔꠤꠀꠞ ꠅꠁꠉꠦꠍꠦ।’ ");
INSERT INTO syls_vpl VALUES ("LK14_18","072_14_18","LUK","14","18","18","ꠅꠁꠟꠦ ꠢꠇꠟ ꠖꠣꠅꠔꠤꠄ ꠄꠇ ꠄꠇꠐꠣ ꠃꠎꠞ ꠖꠦꠈꠣꠁꠟ। ꠙꠄꠟꠣ ꠎꠘꠦ ꠇꠁꠟ, ‘ꠀꠝꠤ ꠕꠥꠠꠣ ꠎꠝꠤꠘ ꠈꠞꠤꠖ ꠇꠞꠍꠤ, ꠅꠈꠘ ꠖꠦꠈꠣꠔ ꠎꠣꠁꠔꠣꠝ, ꠔꠦ ꠢꠘꠅ ꠘꠣ ꠉꠦꠟꠦ ꠅꠁꠔ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠃꠇ꠆ꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("LK14_19","072_14_19","LUK","14","19","19","ꠖꠥꠍꠞꠣ ꠎꠘꠦ ꠇꠁꠟ, ‘ꠀꠝꠤ ꠀꠟꠞ ꠟꠣꠉꠤ ꠙꠣꠌ ꠎꠥꠠꠣ ꠛꠤꠍꠣꠟ ꠟꠁꠍꠤ। ꠅꠈꠘ ꠉꠤꠀ ꠖꠦꠈꠔꠣꠝ, ꠁꠔꠣꠄ ꠀꠟ ꠛꠣꠁꠘ ꠇꠤ ꠘꠣ, ꠀꠝꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠃꠇ꠆ꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("LK14_20","072_14_20","LUK","14","20","20","ꠀꠞꠇ ꠎꠘꠦ ꠇꠁꠟ, ‘ꠀꠝꠤ ꠔ ꠘꠄꠀ ꠛꠤꠀ ꠇꠞꠍꠤ। ꠅꠈꠘ ꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("LK14_21","072_14_21","LUK","14","21","21","ꠢꠤ ꠉꠥꠟꠣꠝꠦ ꠀꠁꠀ ꠔꠣꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟ। ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠣꠟꠤꠇꠦ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ‘ꠔꠥꠁ ꠎꠟꠖꠤ ꠇꠞꠤ ꠐꠣꠃꠘꠞ ꠅꠟ꠆ꠟꠤꠄ-ꠉꠟ꠆ꠟꠤꠄ ꠎꠣ, ꠉꠤꠀ ꠉꠞꠤꠛ, ꠀꠔꠥꠞ, ꠀꠘ꠆ꠖꠣ, ꠟꠥꠟꠣ-ꠟꠦꠋꠠꠣꠞꠦ ꠀꠘꠉꠤ।’ ");
INSERT INTO syls_vpl VALUES ("LK14_22","072_14_22","LUK","14","22","22","ꠔꠦꠃ ꠢꠦ ꠅꠟꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠤ ꠛꠣꠖꠦ ꠀꠁꠀ ꠇꠁꠟ, ‘ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠢꠥꠇꠥꠝꠦ ꠢꠇꠟꠔꠣ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠅꠁꠟꠦ ꠅꠈꠘꠅ ꠎꠣꠉꠣ ꠈꠣꠟꠤ ꠞꠁꠍꠦ।’ ");
INSERT INTO syls_vpl VALUES ("LK14_23","072_14_23","LUK","14","23","23","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠔꠦ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠙꠕꠅ-ꠊꠣꠐꠅ, ꠀꠞ ꠌꠤꠙꠣꠄ-ꠌꠣꠙꠣꠄ ꠎꠣ, ꠉꠤꠀ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤ ꠝꠣꠘꠡꠞꠦ ꠀꠘ। ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠝꠎꠟꠤꠍ ꠜꠞꠤ ꠎꠣꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_24","072_14_24","LUK","14","24","24","ꠀꠞ ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟ ꠇꠞꠤ ꠢꠥꠘꠅ, ꠀꠉꠦ ꠎꠦꠔꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠟꠣꠝ, ꠁꠔꠣ ꠇꠥꠘꠥꠉꠤꠄ ꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠈꠣꠘꠤ ꠘꠣ ꠙꠣꠁꠘ।’ ” ");
INSERT INTO syls_vpl VALUES ("LK14_25","072_14_25","LUK","14","25","25","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠐꠣꠔ ꠀꠍꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK14_26","072_14_26","LUK","14","26","26","“ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠔꠞꠤꠇꠣꠔ ꠀꠁꠔ ꠌꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠝꠣ-ꠛꠣꠚ, ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣ, ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞ, ꠀꠞ ꠘꠤꠎꠞ ꠎꠣꠘꠞꠦꠅ ꠀꠝꠣꠞ ꠕꠣꠇꠤ ꠢꠥꠞꠥ ꠝꠘꠦ ꠇꠞꠔꠦ ꠅꠁꠛ। ꠀꠞꠘꠣꠄ ꠢꠦ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK14_27","072_14_27","LUK","14","27","27","ꠎꠦ ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛ ꠇꠣꠘ꠆ꠖꠅ ꠟꠁꠀ ꠀꠝꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠄ ꠘꠣ, ꠢꠦ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_28","072_14_28","LUK","14","28","28","“ꠔꠥꠝꠞꠣꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠃꠌꠣ ꠇꠥꠘꠥ ꠖꠟꠣꠘ ꠛꠣꠘꠣꠁꠔ ꠌꠣꠄ, ꠔꠦ ꠢꠦ ꠙꠄꠟꠣ ꠔꠣꠞ ꠈꠞꠌꠞ ꠢꠤꠡꠣꠛ ꠝꠤꠟꠣꠁꠀ ꠖꠦꠈꠦ, ꠖꠟꠣꠘꠞ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠐꠦꠇꠣ ꠀꠍꠦ ꠇꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_29","072_14_29","LUK","14","29","29","ꠘꠣ ꠅꠁꠟꠦ, ꠁꠀꠘ ꠖꠤꠀ ꠢꠣꠞꠤ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠔꠦ ꠘꠣ ꠙꠣꠞꠟꠦ, ꠝꠣꠘꠡꠦ ꠑꠣꠐ꠆ꠐꠣ ꠇꠞꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("LK14_30","072_14_30","LUK","14","30","30","ꠔꠣꠞꠣ ꠇꠁꠛꠣ, ꠛꠦꠐꠣꠄ ꠖꠟꠣꠘ ꠔꠥꠟꠤꠀ ꠅꠈꠘ ꠡꠦꠡ ꠇꠞꠔ ꠙꠣꠞꠦꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_31","072_14_31","LUK","14","31","31","“ꠀꠞ ꠎꠥꠖꠤ ꠄꠇ ꠞꠣꠎꠣ ꠀꠞꠇ ꠞꠣꠎꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠔ ꠟꠣꠉꠂꠘ, ꠔꠦ ꠙꠄꠟꠣ ꠛꠁꠀ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠛꠣ, ꠔꠣꠁꠘ ꠇꠁꠛꠣ, ꠛꠤꠡ ꠀꠎꠣꠞ ꠚꠃꠎ ꠟꠁꠀ ꠎꠦꠞꠣ ꠀꠝꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠀꠁꠞꠣ, ꠀꠝꠤ ꠖꠡ ꠀꠎꠣꠞ ꠚꠃꠎ ꠟꠁꠀ ꠄꠞ ꠝꠥꠇꠣꠛꠤꠟꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠝꠥ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK14_32","072_14_32","LUK","14","32","32","ꠎꠥꠖꠤ ꠘꠣ ꠙꠣꠞꠂꠘ, ꠔꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠞꠣ ꠞꠣꠎꠣ ꠖꠥꠞꠁ ꠕꠣꠇꠔꠦꠃ ꠀꠙꠥꠡꠞ ꠟꠣꠉꠤ ꠇꠄꠎꠘ ꠔꠤꠀꠁꠔ ꠙꠣꠑꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK14_33","072_14_33","LUK","14","33","33","ꠑꠤꠇ ꠅꠃꠟꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠣꠄꠀ ꠍꠣꠠꠔ ꠘꠣ ꠙꠣꠞꠦ, ꠔꠦ ꠢꠦ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK14_34","072_14_34","LUK","14","34","34","“ꠘꠥꠘ ꠔ ꠜꠣꠟꠣ ꠎꠤꠘꠤꠡ, ꠅꠁꠟꠦ ꠘꠥꠘꠞ ꠎꠥꠖꠤ ꠡ꠆ꠛꠣꠖ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠀꠞ ꠘꠥꠘꠔꠣ ꠇꠞꠣ ꠎꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK14_35","072_14_35","LUK","14","35","35","ꠁꠔꠣꠖꠤ ꠡꠣꠞꠅ ꠛꠣꠘꠣꠁꠟ ꠎꠣꠄ ꠘꠣ, ꠎꠝꠤꠘꠅ ꠖꠦꠅꠀ ꠎꠣꠄ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠛꠣꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠦꠁꠘ। ꠢꠥꠘꠣꠞ ꠝꠔ ꠇꠣꠘ ꠎꠣꠞ ꠀꠍꠦ, ꠢꠦ ꠢꠥꠘꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("LK15_1","072_15_1","LUK","15","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠀꠞ ꠛꠦ-ꠡꠞꠤꠅꠔꠤ ꠀꠝ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠖꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK15_2","072_15_2","LUK","15","2","2","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠝꠣꠘꠡꠦ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠁ ꠝꠣꠘꠥꠡꠉꠥ ꠈꠣꠟꠤ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠟꠉꠦ ꠃꠑꠣ-ꠛꠅꠀ ꠀꠞ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK15_3","072_15_3","LUK","15","3","3","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠇꠤꠌ꠆ꠍꠣꠁꠘ ꠢꠥꠘꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK15_4","072_15_4","LUK","15","4","4","“ꠝꠘꠅ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞꠣ ꠇꠥꠘꠥ ꠄꠇꠎꠘꠞ ꠄꠇ-ꠡꠐꠣ ꠝꠦꠠꠣ ꠀꠍꠦ। ꠄꠞꠝꠣꠎꠞ ꠄꠉꠥ ꠝꠦꠠꠣ ꠀꠞꠣꠁ ꠉꠦꠟꠦ, ꠢꠦ ꠛꠣꠇꠤ ꠘꠤꠞꠣꠘ꠆ꠘꠛ꠆ꠛꠁꠐꠣ ꠛꠘ꠆ꠖꠅ ꠕꠁꠀ ꠢꠃ ꠀꠞꠣꠁꠟ ꠅꠉꠥ ꠔꠥꠇꠣꠘꠤꠔ ꠎꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK15_5","072_15_5","LUK","15","5","5","ꠉꠤꠀ ꠅꠉꠥ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟꠦ, ꠈꠥꠡꠤꠄ ꠁꠐꠣꠞꠦ ꠇꠣꠘ꠆ꠖꠅ ꠇꠞꠤ ꠀꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("LK15_6","072_15_6","LUK","15","6","6","ꠛꠣꠖꠦ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠛꠘ꠆ꠖꠥ-ꠛꠣꠘ꠆ꠖꠛ ꠀꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠇꠄ, ‘ꠀꠅ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ। ꠀꠝꠣꠞ ꠀꠞꠣꠁꠟ ꠝꠦꠠꠣꠉꠥ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟꠤꠍꠤ।’ ");
INSERT INTO syls_vpl VALUES ("LK15_7","072_15_7","LUK","15","7","7","ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘꠃ, ꠎꠣꠞꠣ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠎꠞꠥꠞ ꠝꠘꠅ ꠇꠞꠦ ꠘꠣ, ꠁꠟꠣ ꠘꠤꠞꠣꠘ꠆ꠘꠛ꠆ꠛꠁ ꠎꠘ ꠙꠞꠦꠎꠉꠣꠞ ꠕꠣꠇꠤ ꠄꠇꠎꠘ ꠉꠥꠘꠣꠉꠣꠞꠦ ꠝꠘ ꠛꠖꠟꠣꠁꠀ ꠔꠃꠛꠣ ꠇꠞꠟꠦ, ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠀꠞꠅ ꠛꠦꠡꠤ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LK15_8","072_15_8","LUK","15","8","8","“ꠛꠣ ꠗꠞꠃꠇ꠆ꠇꠣ, ꠇꠥꠘꠥ ꠄꠇ ꠛꠦꠐꠤꠞ ꠉꠦꠍꠦ ꠞꠥꠙꠣꠞ ꠖꠡꠐꠣ ꠐꠦꠇꠣ ꠀꠍꠤꠟ। ꠄꠞ ꠕꠣꠇꠤ ꠄꠉꠥ ꠐꠦꠇꠣ ꠎꠥꠖꠤ ꠀꠞꠣꠁꠎꠣꠄ, ꠔꠦ ꠛꠦꠐꠤꠄ ꠢꠤ ꠐꠦꠇꠣꠞ ꠟꠣꠉꠤ ꠟꠦꠝ ꠎꠣꠟꠣꠁꠀ ꠢꠥꠞꠥꠁꠘꠖꠤ ꠢꠥꠞꠤꠀ ꠀꠡ꠆ꠔꠣ ꠊꠞ ꠔꠥꠇꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK15_9","072_15_9","LUK","15","9","9","ꠛꠣꠖꠦ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟꠤꠟꠦ ꠛꠘ꠆ꠖꠥ-ꠛꠣꠘ꠆ꠖꠛ ꠀꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠄ, ‘ꠀꠅ ꠘꠣ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠈꠥꠡꠤꠔ ꠡꠣꠝꠤꠟ ꠅꠅ। ꠀꠝꠣꠞ ꠀꠞꠣꠁꠟ ꠐꠦꠇꠣꠉꠥ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠟꠤꠍꠤ।’ ");
INSERT INTO syls_vpl VALUES ("LK15_10","072_15_10","LUK","15","10","10","ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘꠃ, ꠄꠇꠎꠘ ꠉꠥꠘꠣꠉꠣꠞ ꠝꠣꠘꠡꠦ ꠝꠘ ꠛꠖꠟꠣꠁꠀ ꠔꠃꠛꠣ ꠇꠞꠟꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠅꠃꠟꠣ ꠈꠥꠡꠤ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK15_11","072_15_11","LUK","15","11","11","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠞ ꠖꠥꠁ ꠙꠥꠀ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK15_12","072_15_12","LUK","15","12","12","ꠄꠇꠖꠤꠘ ꠢꠥꠞꠥ ꠙꠥꠀꠄ ꠔꠣꠞ ꠛꠣꠚꠞꠦ ꠇꠁꠟ, ꠛꠣꠛꠣ, ꠀꠝꠤ ꠛꠣꠛꠣꠁꠔꠤ ꠎꠝꠤ-ꠎꠝꠣ ꠀꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠎꠦꠔꠣ ꠙꠣꠁꠔꠣꠝ, ꠀꠝꠣꠞ ꠅꠃ ꠛꠣꠐꠈꠣꠘ ꠅꠈꠘꠃ ꠀꠟꠉꠣꠁꠀ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ। ꠅꠃ ꠛꠣꠚꠦ ꠔꠣꠘ ꠍꠣꠝꠣꠘꠣ ꠖꠥꠁꠅ ꠙꠥꠀꠞ ꠘꠣꠝꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK15_13","072_15_13","LUK","15","13","13","ꠄꠞ ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠢꠥꠞꠥ ꠙꠥꠀꠄ ꠔꠣꠞ ꠢꠇ꠆ꠇꠟ ꠍꠣꠝꠣꠘꠣ ꠛꠦꠌꠤꠀ ꠛꠤꠖꠦꠡ ꠉꠦꠟꠉꠤ। ꠛꠤꠖꠦꠡ ꠉꠤꠀ ꠛꠣꠖ ꠙꠕꠦ ꠌꠟꠤꠀ ꠔꠣꠞ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠈꠥꠀꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK15_14","072_15_14","LUK","15","14","14","ꠢꠇꠟꠔꠣ ꠈꠥꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠢꠃ ꠖꠦꠡꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠈꠥꠛ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠟ ꠄꠞꠖꠣꠄ ꠢꠦ ꠈꠥꠛ ꠇꠡ꠆ꠐꠔ ꠙꠠꠟ। ");
INSERT INTO syls_vpl VALUES ("LK15_15","072_15_15","LUK","15","15","15","ꠢꠦ ꠢꠃ ꠖꠦꠡꠞ ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠞ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠌꠣꠇꠞꠤ ꠌꠣꠁꠟ। ꠝꠣꠟꠤꠇꠦ ꠔꠣꠞꠦ ꠌꠣꠇꠞꠤ ꠖꠤꠀ ꠡꠥꠅꠞꠞ ꠙꠣꠟ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠛꠘ꠆ꠖꠅ ꠙꠣꠑꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK15_16","072_15_16","LUK","15","16","16","ꠛꠘ꠆ꠖꠅ ꠉꠤꠀ ꠡꠥꠅꠞꠦ ꠎꠦꠔꠣ ꠈꠣꠄ, ꠢꠦ-ꠅ ꠅꠔꠣ ꠈꠣꠁꠀ ꠙꠦꠐꠞ ꠜꠥꠇ ꠝꠤꠐꠣꠁꠔ ꠌꠣꠁꠟ, ꠅꠁꠟꠦ ꠅꠔꠣꠅ ꠇꠦꠃ ꠔꠣꠞꠦ ꠖꠤꠔ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK15_17","072_15_17","LUK","15","17","17","“ꠛꠣꠖꠦ ꠀꠈꠔꠣ ꠄꠇꠖꠤꠘ ꠔꠣꠞ ꠢꠥꠡ ꠅꠁꠟ। ꠢꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟ, ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞ ꠛꠣꠠꠤꠔ ꠔ ꠛꠃꠔ ꠌꠣꠇꠞ-ꠛꠣꠇꠞꠦ ꠙꠦꠐ ꠜꠞꠤ ꠜꠣꠔ ꠈꠣꠁꠞꠣ। ꠔꠦ ꠀꠝꠤ ꠅꠘꠅ ꠃꠙꠣꠡꠦ ꠝꠞꠞꠣꠝ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("LK15_18","072_15_18","LUK","15","18","18","ꠀꠝꠤ ꠉꠤꠀ ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞꠦ ꠇꠁꠝꠥ, ꠛꠣꠛꠣ, ꠀꠝꠤ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦꠅ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠘꠤꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LK15_19","072_15_19","LUK","15","19","19","ꠔꠥꠝꠣꠞ ꠙꠥꠀ ꠇꠁꠀ ꠀꠝꠤ ꠀꠞ ꠙꠞꠤꠌꠄ ꠖꠤꠛꠣꠞ ꠟꠣꠈ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠔꠥꠝꠣꠞ ꠌꠣꠇꠞꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠣꠞꠦ ꠄꠇꠎꠞꠣ ꠀꠡꠞꠄ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("LK15_20","072_15_20","LUK","15","20","20","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠦ ꠔꠣꠞ ꠛꠣꠠꠤꠔ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟ। ꠛꠣꠠꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠔꠦꠃ ꠔꠣꠞ ꠛꠣꠚꠦ ꠔꠣꠞꠦ ꠖꠦꠈꠤꠟꠤꠟꠣ। ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠖꠤꠟ ꠉꠟꠤ ꠉꠦꠟ। ꠔꠣꠁꠘ ꠖꠃꠠꠤꠀ ꠉꠤꠀ ꠔꠣꠞꠦ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠢꠥꠋꠉꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK15_21","072_15_21","LUK","15","21","21","ꠔꠦꠃ ꠙꠥꠀꠄ ꠇꠁꠟ, ‘ꠛꠣꠛꠣ, ꠀꠝꠤ ꠔ ꠔꠥꠝꠣꠞ ꠙꠥꠀ ꠇꠁꠀ ꠙꠞꠤꠌꠄ ꠖꠤꠛꠣꠞ ꠟꠣꠈ ꠞꠁꠍꠤ ꠘꠣ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦꠅ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠘꠤꠉꠦꠍꠤ।’ ");
INSERT INTO syls_vpl VALUES ("LK15_22","072_15_22","LUK","15","22","22","ꠅꠁꠟꠦ ꠛꠣꠚꠦ ꠟꠉꠦ ꠟꠉꠦ ꠇꠣꠝꠟꠣꠁꠘ꠆ꠔꠞꠦ ꠇꠁꠟꠣ, ‘ꠢꠂ, ꠎꠟꠖꠤ ꠇꠞꠤ ꠊꠞ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠎꠥꠛ꠆ꠛꠣꠐꠣ ꠀꠘꠤꠀ ꠀꠝꠣꠞ ꠙꠥꠀꠉꠥꠞꠦ ꠚꠤꠘ꠆ꠖꠣꠅ। ꠔꠣꠞ ꠀꠔꠅ ꠀꠋꠐꠤ ꠀꠞ ꠙꠣꠅꠔ ꠎꠥꠔꠣ ꠚꠤꠘ꠆ꠖꠣꠁ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("LK15_23","072_15_23","LUK","15","23","23","ꠀꠞ ꠢꠥꠘꠅ, ꠙꠣꠟꠅ ꠕꠣꠇꠤ ꠔꠣꠎꠣ ꠒꠦꠇꠣ-ꠛꠣꠍꠥꠞꠉꠥ ꠀꠘꠤꠀ ꠎꠛ ꠇꠞꠅ। ꠀꠅ, ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤ ꠈꠣꠘꠣ ꠈꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LK15_24","072_15_24","LUK","15","24","24","ꠀꠝꠣꠞ ꠁ ꠙꠥꠀꠉꠥ ꠔ ꠝꠞꠤꠉꠦꠍꠤꠟ, ꠅꠈꠘ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍꠦ। ꠅꠉꠥ ꠘꠣꠁ ꠅꠁꠉꠦꠍꠤꠟ, ꠅꠈꠘ ꠚꠤꠞꠔ ꠙꠣꠁꠍꠤ।’ ꠔꠦꠃ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK15_25","072_15_25","LUK","15","25","25","“ꠅꠃ ꠡꠝꠄ ꠛꠦꠐꠣꠞ ꠛꠠ ꠙꠥꠀ ꠛꠘ꠆ꠖꠅ ꠀꠍꠤꠟ। ꠢꠦ ꠛꠣꠠꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠘꠣꠌ-ꠉꠣꠘ ꠀꠞ ꠒꠥꠟ-ꠒꠙꠇꠤꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("LK15_26","072_15_26","LUK","15","26","26","ꠔꠣꠞꠣꠞ ꠄꠇ ꠌꠣꠇꠞꠞꠦ ꠎꠤꠇꠣꠁꠟ, ‘ꠇꠤꠔꠣꠞꠦ, ꠁꠔꠣ ꠇꠤꠔꠣ ꠅꠞ?’ ");
INSERT INTO syls_vpl VALUES ("LK15_27","072_15_27","LUK","15","27","27","ꠌꠣꠇꠞꠦ ꠇꠁꠟ, ‘ꠍꠣꠛ, ꠀꠙꠘꠣꠞ ꠢꠥꠞꠥ ꠜꠣꠁ ꠛꠣꠠꠤꠔ ꠀꠁꠍꠂꠘ। ꠀꠙꠘꠣꠞ ꠀꠛ꠆ꠛꠣꠄ ꠔꠣꠘꠞꠦ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠙꠣꠁꠀ, ꠔꠣꠎꠣ ꠅꠃ ꠒꠦꠇꠣ-ꠛꠣꠍꠥꠞ ꠎꠛ ꠇꠞꠍꠂꠘ।’ ");
INSERT INTO syls_vpl VALUES ("LK15_28","072_15_28","LUK","15","28","28","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠠ ꠙꠥꠀꠄ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠀꠁꠔ ꠌꠣꠁꠟ ꠘꠣ। ꠔꠦꠃ ꠔꠣꠞ ꠛꠣꠚ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠀ ꠔꠣꠞꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK15_29","072_15_29","LUK","15","29","29","ꠢꠦ ꠔꠣꠞ ꠛꠣꠚꠞꠦ ꠇꠁꠟ, ‘ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠅꠔ ꠖꠤꠘ ꠗꠞꠤꠀ ꠀꠙꠘꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣꠝ, ꠇꠥꠘꠥꠖꠤꠘꠃ ꠀꠙꠘꠣꠞ ꠢꠥꠇꠥꠝ ꠃꠟ꠆ꠐꠣꠁꠍꠤ ꠘꠣ। ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠥ-ꠛꠣꠘ꠆ꠖꠛ ꠟꠁꠀ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠉꠥ ꠛꠇꠞꠤꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠖꠤꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK15_30","072_15_30","LUK","15","30","30","ꠀꠞ ꠀꠙꠘꠣꠞ ꠎꠦ ꠙꠥꠀꠄ ꠘꠐꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠔꠟꠦ ꠢꠇꠟ ꠍꠣꠝꠣꠘꠣ ꠈꠥꠀꠁꠍꠦ, ꠢꠦ ꠀꠁꠔꠦꠃ ꠔꠣꠎꠣ ꠒꠦꠇꠣ-ꠛꠣꠍꠥꠞꠉꠥ ꠀꠘꠤꠀ ꠎꠛ ꠇꠞꠤꠟꠣꠁꠟꠣ!’ ");
INSERT INTO syls_vpl VALUES ("LK15_31","072_15_31","LUK","15","31","31","ꠛꠣꠚꠦ ꠇꠁꠟꠣ, ‘ꠙꠥꠔꠞꠦ, ꠔꠥꠝꠤ ꠔ ꠢꠣꠝꠦꠡꠣꠃ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠍ। ꠀꠝꠣꠞ ꠎꠦꠔꠣ ꠍꠣꠝꠣꠘꠣ ꠞꠁꠍꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔ ꠔꠥꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LK15_32","072_15_32","LUK","15","32","32","ꠅꠈꠘ ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠖꠤꠟ ꠍꠣꠚ ꠇꠞꠤꠀ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠣ ꠎꠞꠥꠞ। ꠔꠥꠝꠣꠞ ꠁ ꠜꠣꠁ ꠔ ꠝꠞꠤꠃ ꠉꠦꠍꠤꠟ, ꠅꠈꠘ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍꠦ। ꠅꠉꠥ ꠄꠇ꠆ꠇꠦꠞꠦ ꠘꠣꠁ ꠅꠁꠉꠦꠍꠤꠟ, ꠅꠈꠘ ꠚꠤꠞꠔ ꠙꠣꠁꠍꠤ।’ ” ");
INSERT INTO syls_vpl VALUES ("LK16_1","072_16_1","LUK","16","1","1","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠇꠥꠘꠥ ꠄꠇ ꠎꠝꠤꠖꠣꠞꠞ ꠄꠇ ꠝꠦꠘꠦꠎꠣꠞ ꠀꠍꠤꠟ। ꠅꠃ ꠝꠦꠘꠦꠎꠣꠞꠞ ꠛꠖꠘꠣꠝ ꠛꠣꠞ ꠅꠁꠟ, ꠢꠦ ꠛꠥꠟꠦ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LK16_2","072_16_2","LUK","16","2","2","ꠛꠖꠘꠣꠝ ꠢꠥꠘꠤꠀ ꠝꠥꠘꠤꠛꠦ ꠔꠣꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, ꠔꠥꠝꠣꠞ ꠘꠣꠝꠦ ꠁꠔꠣ ꠇꠤꠔꠣ ꠢꠥꠘꠞꠣꠝ? ꠔꠥꠝꠣꠞ ꠢꠤꠡꠣꠛ-ꠘꠤꠇꠣꠡ ꠢꠇꠟꠔꠣ ꠡꠝꠎꠣꠁ ꠖꠦꠅ। ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠌꠣꠇꠞꠤꠔ ꠞꠣꠈꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK16_3","072_16_3","LUK","16","3","3","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠦꠘꠦꠎꠣꠞꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟ, ꠅꠈꠘ ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ? ꠝꠥꠘꠤꠛꠦ ꠔ ꠀꠝꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠁꠞꠣ। ꠀꠝꠤ ꠔ ꠝꠣꠐꠤ ꠇꠣꠝꠅ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ, ꠜꠤꠇ ꠇꠞꠔꠦꠅ ꠡꠞꠝ ꠟꠣꠉꠦ। ꠅꠈꠘ ꠈꠣꠁꠝꠥ ꠇꠤꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("LK16_4","072_16_4","LUK","16","4","4","ꠀꠁꠌ꠆ꠍꠣ, ꠄꠇ ꠇꠣꠝ ꠇꠞꠤ, ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠝꠦꠘꠦꠎꠣꠞꠤ ꠉꠦꠟꠦꠉꠤꠅ ꠝꠣꠘꠡꠞ ꠊꠞꠅ ꠀꠡꠞꠄ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LK16_5","072_16_5","LUK","16","5","5","ꠅꠃ ꠢꠦ ꠇꠤꠔꠣ ꠇꠞꠟ, ꠎꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠙꠣꠅꠘꠣ ꠀꠍꠤꠟ, ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠄꠞꠣꠞꠦ ꠀꠘꠣꠁꠟ। ꠀꠘꠣꠁꠀ ꠙꠄꠟꠣ ꠎꠘꠞꠦ ꠇꠁꠟ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠇꠔ ꠙꠣꠅꠘꠣ ꠀꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("LK16_6","072_16_6","LUK","16","6","6","ꠢꠦꠁꠘ ꠇꠁꠟꠣ, ꠄꠇ-ꠡ ꠝꠘ ꠔꠦꠟ। ꠝꠦꠘꠦꠎꠣꠞꠦ ꠇꠁꠟ, ꠎꠟꠖꠤ ꠇꠞꠤ ꠔꠥꠝꠣꠞ ꠈꠣꠔꠣ ꠛꠣꠞ ꠇꠞꠅ, ꠀꠞ ꠄꠇ-ꠡꠞ ꠛꠖꠟꠣ ꠙꠁꠘ꠆ꠌꠣꠡ ꠝꠘ ꠟꠦꠈꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("LK16_7","072_16_7","LUK","16","7","7","ꠛꠣꠖꠦ ꠝꠦꠘꠦꠎꠣꠞꠦ ꠖꠥꠍꠞꠣ ꠎꠘꠞꠦ ꠎꠤꠇꠣꠁꠟ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠔ ꠙꠣꠁꠘ? ꠢꠦꠁꠘ ꠇꠁꠟꠣ, ꠄꠇ-ꠡ ꠚꠥꠞꠣꠞ ꠉꠝ। ꠝꠦꠘꠦꠎꠣꠞꠦ ꠇꠁꠟ, ꠔꠥꠝꠣꠞ ꠢꠤꠡꠣꠛꠅ ꠀꠡꠤ ꠚꠥꠞꠣꠞ ꠟꠦꠈꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("LK16_8","072_16_8","LUK","16","8","8","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠤ ꠎꠝꠤꠖꠣꠞꠦ ꠅꠃ ꠛꠦꠁꠝꠣꠘ ꠝꠦꠘꠦꠎꠣꠞꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ꠢꠦ ꠗꠣꠘ꠆ꠖꠣꠛꠣꠎ ꠅꠁꠟꠦꠅ ꠛꠃꠔ ꠛꠠ ꠛꠥꠖ꠆ꠖꠤꠝꠣꠘꠞ ꠇꠣꠝ ꠇꠞꠍꠦ। ꠔꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠅ, ꠁꠔꠣꠄ ꠛꠥꠎꠣ ꠎꠣꠄ ꠘꠣ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠝꠣꠘꠡꠞ ꠀꠈꠟ ꠕꠣꠇꠤꠅ, ꠁ ꠎꠝꠣꠘꠣꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠘꠡꠞ ꠙꠦꠌ-ꠙꠣꠁꠌ꠆ꠍꠣ ꠛꠦꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("LK16_9","072_16_9","LUK","16","9","9","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠅ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠃ ꠎꠉꠔꠞ ꠍꠣꠝꠣꠘꠣ ꠖꠤꠀ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠖꠥꠡ꠆ꠔꠤ ꠙꠣꠔꠣꠅ, ꠎꠣꠔꠦ ꠁ ꠍꠣꠝꠣꠘꠣ ꠚꠥꠠꠣꠁꠉꠦꠟꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠛꠣꠉꠣꠘꠅ ꠚꠥꠟꠞ ꠝꠣꠟꠣ ꠖꠦꠅꠀ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LK16_10","072_16_10","LUK","16","10","10","“ꠎꠦ ꠝꠣꠘꠥꠡ ꠡꠣꠝꠣꠁꠘ꠆ꠘ ꠛꠦꠙꠣꠞꠦ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠞꠄ, ꠢꠦ ꠛꠠ ꠛꠦꠙꠣꠞꠦꠅ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠞꠄ। ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠡꠣꠝꠣꠁꠘ꠆ꠘ ꠛꠦꠙꠣꠞꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠦ, ꠢꠦ ꠛꠠ ꠛꠦꠙꠣꠞꠦꠅ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK16_11","072_16_11","LUK","16","11","11","ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠖꠥꠘꠤꠀꠛꠤ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠇ ꠘꠣ ꠞꠅ, ꠔꠣꠁꠟꠦ ꠇꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠤꠡ꠆ꠛꠣꠡ ꠇꠞꠤꠀ ꠀꠍꠟ ꠗꠘ ꠖꠤꠛ? ");
INSERT INTO syls_vpl VALUES ("LK16_12","072_16_12","LUK","16","12","12","ꠙꠞꠞ ꠍꠣꠝꠣꠘꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠑꠤꠇ-ꠑꠣꠇ ꠝꠔ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠔꠣꠄ ꠘꠣ ꠙꠣꠞ, ꠔꠦ ꠇꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠍꠣꠝꠣꠘꠣ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠖꠤꠛ? ");
INSERT INTO syls_vpl VALUES ("LK16_13","072_16_13","LUK","16","13","13","ꠇꠥꠘꠥ ꠉꠥꠟꠣꠝꠦ ꠄꠇꠟꠉꠦ ꠖꠥꠁ ꠝꠥꠘꠤꠛꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ꠔꠦ ꠅꠁꠟꠦ ꠢꠦ ꠄꠇꠎꠘꠞꠦ ꠁꠋꠡꠣꠁꠛ, ꠀꠞꠇ ꠎꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠛ। ꠄꠇꠎꠘꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠤꠛ ꠀꠞ ꠀꠞꠇ ꠎꠘꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠛ। ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ, ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣ ꠀꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠖꠥꠁꠅꠔꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠄꠇꠟꠉꠦ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK16_14","072_16_14","LUK","16","14","14","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠓꠋ-ꠔꠣꠝꠣꠡꠣ ꠟꠣꠉꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠔ ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠞꠦ ꠈꠥꠛ ꠝꠣꠄꠀ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK16_15","072_16_15","LUK","16","15","15","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠃ ꠔ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠎꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠖꠦꠈꠣꠅ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠈꠛꠞ ꠎꠣꠘꠂꠘ। ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠈꠥꠛ ꠖꠣꠝꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LK16_16","072_16_16","LUK","16","16","16","ꠢꠥꠘꠅ, ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠡꠝꠄ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ, ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠍꠢꠤꠚꠣ ꠎꠣꠞꠤ ꠀꠍꠤꠟ। ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠞ, ꠀꠞ ꠝꠣꠘꠡꠦꠅ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠅꠘꠅ ꠖꠣꠈꠤꠟ ꠅꠁꠔꠣ ꠌꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK16_17","072_16_17","LUK","16","17","17","ꠁ ꠡꠞꠤꠅꠔꠞ ꠄꠇꠐꠣ ꠢꠞꠚ ꠛꠣꠔꠤꠟ ꠅꠀꠞ ꠌꠣꠁꠔꠦ, ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠛꠤꠘꠣꠡ ꠅꠀꠈꠣꠘ ꠛꠃꠔ ꠡꠥꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("LK16_18","072_16_18","LUK","16","18","18","ꠔꠦ ꠢꠥꠘꠅ, ꠎꠦ ꠛꠦꠐꠣꠄ ꠘꠤꠎꠞ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠤꠀ ꠀꠞꠇ ꠛꠦꠐꠤꠞꠦ ꠢꠣꠋꠉꠣ ꠇꠞꠦ, ꠢꠦ ꠎꠤꠘꠣꠇꠥꠞ। ꠅꠃꠟꠣ ꠔꠣꠟꠣꠇ ꠙꠣꠅꠀ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠞꠦ ꠎꠦꠉꠤꠄ ꠛꠤꠀ ꠇꠞꠦ, ꠢꠦ-ꠅ ꠎꠤꠘꠣꠇꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK16_19","072_16_19","LUK","16","19","19","“ꠄꠇ ꠗꠘꠤ ꠛꠦꠐꠣ ꠀꠍꠤꠟ, ꠢꠦ ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠤꠘꠔ, ꠀꠞ ꠢꠣꠝꠦꠡꠣ ꠎꠣꠇ-ꠎꠝꠇ ꠇꠞꠤꠀ ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("LK16_20","072_16_20","LUK","16","20","20","ꠝꠣꠘꠡꠦ ꠟꠣꠍꠣꠞ ꠘꠣꠝꠞ ꠄꠇ ꠢꠇꠤꠞ ꠛꠦꠐꠣꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠅꠃ ꠗꠘꠤꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠛꠅꠀꠁꠀ ꠕꠁꠔꠣ, ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠉꠔꠞꠅ ꠙꠌꠣ-ꠊꠣ ꠀꠍꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("LK16_21","072_16_21","LUK","16","21","21","ꠀꠞ ꠙꠕꠞ ꠇꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠦ ꠀꠁꠀ ꠔꠣꠞ ꠊꠣ ꠎꠤꠚꠞꠣꠖꠤ ꠟꠦꠁꠔꠣ। ꠅꠃ ꠗꠘꠤꠄ ꠜꠣꠔ ꠈꠣꠁꠀ ꠢꠣꠞꠤ ꠀꠒ꠆ꠒꠤ-ꠉꠥꠒ꠆ꠒꠤ ꠉꠥꠠꠣ-ꠉꠣꠠꠣ ꠎꠦꠔꠣ ꠔꠟꠦ ꠚꠣꠟꠣꠁꠔꠣ, ꠅꠔꠣ ꠈꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠈꠥꠛ ꠁꠌ꠆ꠍꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK16_22","072_16_22","LUK","16","22","22","ꠄꠇꠖꠤꠘ ꠅꠃ ꠢꠇꠤꠞ ꠛꠦꠐꠣ ꠝꠞꠤꠉꠦꠟ, ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠞꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠞ ꠇꠥꠟꠅ ꠘꠤꠀ ꠛꠅꠀꠁꠟꠣ। ꠄꠞꠝꠣꠎꠦ ꠢꠃ ꠗꠘꠤ ꠛꠦꠐꠣꠅ ꠝꠞꠤꠉꠦꠟ, ꠔꠣꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK16_23","072_16_23","LUK","16","23","23","ꠛꠣꠖꠦ ꠢꠦ ꠖꠥꠎꠈꠞ ꠀꠎꠣꠛ ꠕꠣꠇꠤ ꠀꠈꠔꠣ ꠃꠙꠞꠦꠖꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠟ, ꠖꠥꠞꠁ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤ ꠛꠁ ꠞꠁꠍꠂꠘ, ꠔꠣꠘ ꠇꠥꠟꠅ ꠢꠃ ꠟꠣꠍꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LK16_24","072_16_24","LUK","16","24","24","ꠖꠦꠈꠤꠀꠃ ꠢꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, ꠛꠣꠛꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝ! ꠀꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠟꠣꠍꠣꠞꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠃꠇ꠆ꠇꠣ, ꠢꠦ ꠔꠣꠞ ꠀꠋꠉꠥꠟꠤꠞ ꠀꠉꠣꠈꠣꠘ ꠙꠣꠘꠤꠔ ꠛꠥꠠꠣꠁꠀ ꠀꠝꠣꠞ ꠎꠤꠚꠞꠣꠞꠦ ꠑꠣꠘ꠆ꠒꠣ ꠇꠞꠃꠇ। ꠖꠥꠎꠈꠞ ꠁ ꠀꠉꠥꠘꠤꠔ ꠀꠝꠣꠞ ꠛꠠ ꠀꠎꠣꠛ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("LK16_25","072_16_25","LUK","16","25","25","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠁꠟꠣ, ꠛꠣꠛꠣꠞꠦ, ꠝꠘꠅ ꠇꠞꠤꠀ ꠖꠦꠈꠅ, ꠔꠥꠝꠣꠞ ꠡꠥꠈ ꠔꠥꠝꠤ ꠖꠥꠘꠤꠀꠔꠃ ꠇꠣꠝꠣꠁꠟꠤꠍ, ꠀꠞ ꠟꠣꠍꠣꠞꠦ ꠛꠃꠔ ꠇꠡ꠆ꠐ ꠇꠞꠍꠦ। ꠅꠈꠘ ꠁꠘꠅ ꠀꠁꠀ ꠢꠦ ꠀꠞꠣꠝꠦ ꠀꠍꠦ, ꠀꠞ ꠔꠥꠝꠤ ꠀꠎꠣꠛꠅ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("LK16_26","072_16_26","LUK","16","26","26","ꠢꠥꠘꠅ, ꠁꠔꠣ ꠍꠣꠠꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠈꠘ ꠛꠃꠔ ꠛꠠ ꠚꠣꠇ ꠞꠣꠈꠣ ꠅꠁꠍꠦ। ꠁꠘꠞ ꠇꠦꠃ ꠁꠌ꠆ꠍꠣ ꠇꠞꠟꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠀꠞ ꠔꠥꠝꠞꠣꠅ ꠇꠦꠃ ꠁꠌ꠆ꠍꠣ ꠇꠞꠟꠦ ꠁꠘꠅ ꠀꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK16_27","072_16_27","LUK","16","27","27","ꠅꠃ ꠢꠤ ꠗꠘꠤ ꠛꠦꠐꠣꠄ ꠇꠁꠟ, ꠛꠣꠛꠣ, ꠔꠦ ꠖꠄꠀ ꠇꠞꠤ ꠟꠣꠍꠣꠞꠞꠦ ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞ ꠛꠣꠠꠤꠈꠣꠘꠅ ꠙꠣꠑꠣꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("LK16_28","072_16_28","LUK","16","28","28","ꠢꠘꠅ ꠀꠝꠣꠞ ꠀꠞꠅ ꠙꠣꠌꠉꠥ ꠜꠣꠁ ꠞꠁꠍꠂꠘ। ꠢꠦ ꠉꠤꠀ ꠀꠝꠣꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠃꠇ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠁ ꠖꠥꠎꠈꠞ ꠀꠎꠣꠛ ꠕꠣꠇꠤ ꠛꠣꠌꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK16_29","072_16_29","LUK","16","29","29","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠛꠃꠔ ꠇꠤꠔꠣꠛ ꠛꠦꠎꠣ ꠅꠁꠍꠦ, ꠔꠣꠞꠣ ꠅꠃ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LK16_30","072_16_30","LUK","16","30","30","ꠢꠃ ꠗꠘꠤꠄ ꠇꠁꠟ, ꠘꠣ, ꠘꠣ, ꠛꠣꠛꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝ! ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠇꠦꠃ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠦꠃ, ꠔꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK16_31","072_16_31","LUK","16","31","31","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠇꠁꠟꠣ, ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠕꠣ ꠘꠣ ꠢꠥꠘꠦ, ꠔꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠉꠦꠟꠦꠅ ꠔꠣꠞꠣ ꠝꠣꠘꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK17_1","072_17_1","LUK","17","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠃꠍꠇꠣꠘꠤ ꠀꠁꠛꠃ ꠀꠁꠛ। ꠅꠁꠟꠦ ꠟꠣꠘ꠆ꠘꠔ ꠢꠃ ꠎꠘꠞ ꠃꠙꠞꠦ, ꠎꠦꠉꠤꠄ ꠉꠥꠘꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠃꠍꠇꠣꠘꠤ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("LK17_2","072_17_2","LUK","17","2","2","ꠅꠃ ꠛꠦꠛꠥꠎ ꠅꠇꠟꠞ ꠄꠇꠎꠘꠞꠦꠅ ꠎꠦꠉꠤꠄ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠤꠀ ꠘꠦꠄ, ꠅꠉꠥꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠜꠣꠟꠣ ꠅꠁꠟ ꠅꠘꠦ, ꠅꠉꠥꠞ ꠉꠟꠣꠔ ꠙꠣꠔ꠆ꠔꠞ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("LK17_3","072_17_3","LUK","17","3","3","ꠔꠥꠝꠞꠣꠅ ꠎꠣꠞꠎꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ। ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠜꠣꠁꠄ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠖꠥꠡ ꠇꠞꠟꠦ ꠔꠣꠞꠦ ꠛꠥꠎꠣꠁꠅ। ꠢꠦ ꠖꠤꠟ ꠛꠖꠟꠣꠁꠀ ꠝꠣꠚ ꠌꠣꠁꠟꠦ ꠔꠣꠞꠦ ꠝꠣꠚꠤ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("LK17_4","072_17_4","LUK","17","4","4","ꠢꠦ ꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠡꠣꠔꠛꠣꠞ ꠖꠥꠡ ꠇꠞꠤꠀ, ꠡꠣꠔꠛꠣꠞ ꠀꠁꠀ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠚ ꠌꠣꠁꠟꠦ, ꠔꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK17_5","072_17_5","LUK","17","5","5","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠛꠖꠣꠞ ꠇꠞꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣꠞ ꠁꠝꠣꠘꠤ ꠛꠟ ꠛꠣꠠꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK17_6","072_17_6","LUK","17","6","6","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠥꠖꠤ ꠄꠉꠥ ꠒꠦꠋꠉꠣꠞ ꠛꠤꠌꠤꠞ ꠙꠞꠤꠝꠣꠘ ꠁꠝꠣꠘ ꠕꠣꠇꠦ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠃ ꠢꠦꠅꠞꠣ ꠉꠣꠍꠞꠦ ꠇꠅ, ꠎꠠ ꠡꠥꠖ꠆ꠖꠣ ꠢꠥꠞꠤꠀ ꠉꠤꠀ ꠖꠞꠤꠀꠔ ꠉꠣꠠꠤꠎꠣꠅ, ꠔꠦ ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("LK17_7","072_17_7","LUK","17","7","7","“ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠇꠥꠘꠥ ꠉꠤꠞꠡ꠆ꠔ ꠀꠍꠦ ꠘꠤ, ꠎꠣꠞ ꠇꠣꠝꠟꠣꠄ ꠀꠟ ꠛꠣꠁꠀ ꠛꠣ ꠉꠞꠥ ꠞꠣꠈꠤꠀ ꠛꠘ꠆ꠖꠅ ꠕꠣꠇꠤ ꠛꠣꠠꠤꠔ ꠀꠁꠔꠦꠃ, ꠢꠦ ꠔꠣꠞ ꠇꠣꠝꠟꠣꠞꠦ ꠇꠄ, ꠔꠥꠝꠤ ꠎꠟꠖꠤ ꠀꠁꠀ ꠈꠣꠘꠣ ꠈꠣꠅ? ");
INSERT INTO syls_vpl VALUES ("LK17_8","072_17_8","LUK","17","8","8","ꠘꠣ, ꠇꠦꠃ ꠁꠟꠣ ꠇꠄ ꠘꠣ। ꠛꠞꠋ ꠅꠃꠟꠣ ꠇꠄ, ꠅꠛꠣ, ꠔꠥꠁ ꠀꠝꠣꠞ ꠈꠣꠘꠣ ꠎꠥꠁꠔ ꠇꠞ। ꠀꠝꠤ ꠎꠔ ꠡꠝꠄ ꠈꠣꠘꠣ ꠈꠣꠁ, ꠔꠥꠁ ꠅꠘꠅ ꠃꠛꠣꠁꠀ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠀꠝꠣꠞꠦ ꠛꠣꠔꠣꠡ ꠖꠦ। ꠛꠣꠖꠦ ꠔꠥꠁ ꠈꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("LK17_9","072_17_9","LUK","17","9","9","ꠀꠞ ꠢꠃ ꠉꠥꠟꠣꠝꠦ ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠍꠦ ꠇꠞꠤ ꠔꠣꠁꠘ ꠔꠣꠞꠦ ꠇꠥꠘꠥ ꠗꠁꠘ꠆ꠘꠛꠣꠖ ꠖꠦꠁꠘ ꠘꠤ? ꠘꠤꠌꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK17_10","072_17_10","LUK","17","10","10","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠅ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠖꠣꠄ ꠇꠞꠟꠦꠅ ꠇꠁꠅ, ꠝꠣꠟꠤꠇ, ꠀꠝꠞꠣ ꠔ ꠔꠥꠝꠣꠞ ꠘꠣ-ꠟꠣꠄꠇ ꠉꠥꠟꠣꠝ। ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠣ ꠎꠞꠥꠞ ꠀꠍꠤꠟ, ꠈꠣꠟꠤ ꠅꠔꠣꠃ ꠇꠥꠘꠥ ꠞꠇꠝꠦ ꠀꠖꠣꠄ ꠇꠞꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK17_11","072_17_11","LUK","17","11","11","ꠢꠎꠞꠔ ꠁꠍꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠡꠝꠞꠤꠀ ꠀꠞ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠝꠣꠎꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK17_12","072_17_12","LUK","17","12","12","ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠉꠣꠃꠔ ꠢꠣꠝꠣꠘꠤꠞ ꠙꠕꠞ ꠝꠥꠈꠅ ꠖꠡꠎꠘ ꠙꠌꠣ-ꠇꠥꠡ꠆ꠑ ꠛꠦꠝꠣꠞꠤꠄ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠣꠔ ꠀꠁꠟꠣ। ꠔꠣꠞꠣ ꠖꠥꠞꠁ ꠃꠛꠣꠁꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK17_13","072_17_13","LUK","17","13","13","“ꠅ ꠢꠥꠎꠥꠞ ꠁꠍꠣ, ꠀꠝꠞꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK17_14","072_17_14","LUK","17","14","14","ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠎꠣꠅ, ꠁꠝꠣꠝ ꠍꠣꠛ ꠅꠇꠟꠞꠦ ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠢꠣꠟꠔ ꠖꠦꠈꠣꠅ।” ꠙꠕꠦꠖꠤ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠛꠦꠝꠣꠞ ꠇꠝꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK17_15","072_17_15","LUK","17","15","15","ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠄꠇꠎꠘꠦ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟ, ꠢꠦ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍꠦ, ꠖꠦꠈꠤꠀꠃ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤ ꠇꠞꠤ ꠢꠦ ꠚꠤꠞꠤꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK17_16","072_17_16","LUK","17","16","16","ꠀꠁꠀ ꠁꠍꠣꠞ ꠙꠣꠅꠔ ꠙꠠꠤꠀ ꠔꠣꠘꠞꠦ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠟ। ꠢꠦ ꠅꠁꠟ ꠡꠝꠞꠤꠀ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("LK17_17","072_17_17","LUK","17","17","17","ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠖꠡꠅ ꠎꠘꠞꠦꠃ ꠇꠥꠘꠥ ꠜꠣꠟꠣ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ ꠘꠤ? ꠔꠦ ꠛꠣꠇꠤ ꠘꠄꠎꠘ ꠇꠥꠀꠁ? ");
INSERT INTO syls_vpl VALUES ("LK17_18","072_17_18","LUK","17","18","18","ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠛꠤꠖꠦꠡꠤ ꠛꠦꠐꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠚꠤꠞꠤꠀ ꠀꠁꠟ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK17_19","072_17_19","LUK","17","19","19","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁ, ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠅꠁꠍ। ꠅꠈꠘ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠎꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK17_20","072_17_20","LUK","17","20","20","ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠇꠄꠎꠘ ꠀꠁꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘ ꠡꠝꠄ ꠔꠣꠘ ꠛꠣꠖꠡꠣꠁ ꠌꠣꠟꠥ ꠇꠞꠛꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠇꠦꠃꠞꠞꠦ ꠎꠣꠘꠣꠁ-ꠢꠥꠘꠣꠁ ꠀꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK17_21","072_17_21","LUK","17","21","21","ꠇꠦꠃ ꠇꠅꠀꠞ ꠡꠣꠁꠖ꠆ꠖ ꠘꠣꠁ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠅꠘꠅ ꠛꠣ ꠢꠘꠅ ꠖꠦꠈꠍꠤ। ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠅꠈꠘꠃ ꠀꠙꠘꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠌꠣꠟꠥ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK17_22","072_17_22","LUK","17","22","22","ꠛꠣꠖꠦ ꠔꠣꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠅꠝꠘ ꠄꠇ ꠡꠝꠄ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠄꠇꠈꠣꠘ ꠖꠤꠘ ꠖꠦꠈꠔꠣꠄ ꠌꠣꠁꠛꠣꠄ, ꠅꠁꠟꠦ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK17_23","072_17_23","LUK","17","23","23","ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠛꠣ, ꠅꠘꠅ ꠖꠦꠈꠅ, ꠢꠘꠅ ꠖꠦꠈꠅ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠇꠕꠣꠄ ꠖꠃꠠꠤꠅ ꠘꠣ, ꠇꠥꠘꠥꠈꠣꠘꠅ ꠎꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK17_24","072_17_24","LUK","17","24","24","ꠢꠥꠘꠅ, ꠝꠦꠊꠞ ꠎꠤꠟꠇꠤꠞ ꠟꠉꠦ ꠀꠍꠝꠣꠘꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣ ꠎꠦꠛꠟꠣ ꠚꠞ ꠅꠄ, ꠅꠃ ꠡꠝꠄ ꠔ ꠢꠇꠟꠦ ꠖꠦꠈꠦ। ꠔꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠎꠦꠛꠟꠣ ꠀꠁꠝꠥ ꠢꠃ ꠡꠝꠄꠅ ꠅꠟꠣ ꠢꠇꠟꠦ ꠖꠦꠈꠛ। ");
INSERT INTO syls_vpl VALUES ("LK17_25","072_17_25","LUK","17","25","25","ꠅꠁꠟꠦꠅ ꠙꠄꠟꠣ ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠀꠔꠅ ꠀꠝꠤ ꠛꠃꠔ ꠇꠡ꠆ꠐ ꠙꠣꠁꠔꠣꠝ ꠅꠁꠛ, ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠖꠥꠞ ꠖꠥꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK17_26","072_17_26","LUK","17","26","26","“ꠎꠦꠟꠣ ꠘꠥꠢ ꠘꠛꠤꠞ ꠀꠝꠟꠅ ꠅꠁꠍꠤꠟ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠎꠝꠣꠘꠣꠔꠅ ꠅꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK17_27","072_17_27","LUK","17","27","27","ꠘꠥꠢ ꠘꠛꠤ ꠎꠣꠎꠅ ꠃꠑꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠝꠣꠘꠡꠦ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ, ꠛꠤꠀ-ꠡꠣꠖꠤ ꠀꠞ ꠊꠞ-ꠡꠋꠡꠣꠞ ꠇꠞꠔꠣ, ꠘꠥꠢ ꠘꠛꠤꠞ ꠛꠁꠘ꠆ꠘꠣ ꠀꠁꠀ ꠁꠔꠣꠞꠦ ꠘꠤꠙꠣꠔ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK17_28","072_17_28","LUK","17","28","28","ꠅꠃꠟꠣ ꠟꠥꠔ ꠘꠛꠤꠞ ꠀꠝꠟꠅ-ꠅ ꠝꠣꠘꠡꠦ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ, ꠈꠞꠤꠖ-ꠛꠤꠇꠤ, ꠈꠦꠔ-ꠉꠤꠞꠡ꠆ꠔꠤ ꠀꠞ ꠛꠣꠠꠤ-ꠊꠞ ꠛꠣꠘꠣꠘꠤꠔ ꠛꠦꠡ꠆ꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK17_29","072_17_29","LUK","17","29","29","ꠅꠁꠟꠦ ꠟꠥꠔ ꠘꠛꠤ ꠎꠦꠖꠤꠘ ꠍꠣꠖꠥꠝ ꠐꠣꠃꠘ ꠍꠣꠠꠤꠀ ꠛꠤꠖꠣꠄ ꠅꠁꠉꠦꠟꠣ, ꠢꠃ ꠖꠤꠘꠃ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠀꠉꠥꠁꠘ ꠀꠞ ꠉꠘ꠆ꠖꠇꠞ ꠉꠎꠛ ꠟꠣꠝꠤꠀ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞꠦ ꠘꠤꠙꠣꠔ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK17_30","072_17_30","LUK","17","30","30","ꠑꠤꠇ ꠅꠃꠟꠣ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠎꠦꠖꠤꠘ ꠎꠣꠁꠞꠣ ꠅꠁꠝꠥ, ꠢꠃ ꠖꠤꠘꠅ ꠅꠟꠣ ꠀꠈꠔꠣ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK17_31","072_17_31","LUK","17","31","31","“ꠢꠤꠖꠤꠘ ꠇꠦꠃ ꠎꠥꠖꠤ ꠊꠞꠞ ꠌꠣꠟꠞ ꠃꠙꠞꠦ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠣꠞ ꠊꠞꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠟꠣꠝꠣꠔ ꠟꠣꠝꠤꠀ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠘꠣ ꠢꠣꠝꠣꠃꠇ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠦꠃ ꠎꠥꠖꠤ ꠛꠘ꠆ꠖꠅ ꠕꠣꠇꠦ, ꠢꠦ-ꠅ ꠀꠞ ꠛꠣꠠꠤꠔ ꠘꠣ ꠀꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LK17_32","072_17_32","LUK","17","32","32","ꠟꠥꠔ ꠘꠛꠤꠞ ꠛꠤꠛꠤꠞ ꠊꠐꠘꠣ ꠁꠀꠖ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("LK17_33","072_17_33","LUK","17","33","33","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠎꠦ ꠎꠘꠦ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ ꠌꠣꠄ, ꠢꠦ ꠘꠤꠎꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠥꠀꠁꠛ, ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠎꠣꠘ ꠡꠙꠤꠀ ꠖꠦꠄ, ꠢꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK17_34","072_17_34","LUK","17","34","34","ꠢꠤ ꠞꠣꠁꠔ ꠄꠇꠁ ꠛꠤꠍꠘꠣꠔ ꠖꠥꠁꠎꠘ ꠢꠥꠔꠤꠟꠦꠅ, ꠄꠇꠎꠘꠞꠦ ꠘꠦꠅꠀ ꠅꠁꠛ, ꠖꠥꠍꠞꠣ ꠎꠘ ꠛꠣꠖ ꠙꠠꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LK17_35","072_17_35","LUK","17","35","36","ꠖꠥꠁ ꠛꠦꠐꠤꠄ ꠄꠇꠟꠉꠦ ꠛꠣꠞꠣ-ꠜꠣꠘꠣꠔ ꠕꠣꠇꠟꠦꠅ, ꠄꠞꠣꠞ ꠄꠇꠎꠘꠞꠦ ꠘꠦꠅꠀ ꠅꠁꠛ, ꠀꠞꠇ ꠎꠘ ꠛꠣꠖ ꠙꠠꠤꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK17_37","072_17_37","LUK","17","37","37","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁꠔꠣ ꠇꠥꠀꠁ ꠅꠁꠛ?” ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠝꠞꠣ ꠟꠣꠡ ꠎꠦꠈꠣꠘꠅ, ꠢꠇꠥꠘꠅ ꠢꠘꠅ ꠖꠟꠣ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK18_1","072_18_1","LUK","18","1","1","ꠝꠥꠘꠣꠎꠣꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟ ꠘꠤꠞꠣꠡ ꠘꠣ ꠅꠁꠀ ꠢꠣꠝꠦꠡꠣ ꠎꠣꠔꠦ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠂꠘ, ꠅꠈꠣꠘ ꠛꠥꠎꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠍꠣꠄ ꠄꠇ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK18_2","072_18_2","LUK","18","2","2","ꠇꠁꠟꠣ, “ꠇꠥꠘꠥ ꠄꠇ ꠐꠣꠃꠘꠅ ꠄꠇꠎꠘ ꠢꠣꠇꠤꠝ ꠀꠍꠟꠣ। ꠄꠁꠘ ꠀꠟ꠆ꠟꠣꠞꠦꠅ ꠒꠞꠣꠁꠔꠣ ꠘꠣ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦꠅ ꠔꠅꠀꠇ꠆ꠇꠣ ꠇꠞꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK18_3","072_18_3","LUK","18","3","3","ꠢꠃ ꠐꠣꠃꠘꠅ ꠄꠇ ꠠꠣꠠꠤ ꠛꠦꠐꠤ ꠀꠍꠤꠟ। ꠅꠃ ꠛꠦꠐꠤꠄ ꠀꠁꠀ ꠢꠣꠝꠦꠡꠣ ꠔꠣꠘꠞꠦ ꠇꠁꠔ, ꠢꠣꠇꠤꠝ ꠍꠣꠛ, ꠀꠝꠣꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ, ꠖꠄꠀ ꠇꠞꠤ ꠅꠃ ꠘꠤꠀꠎ꠆ꠎ ꠛꠤꠌꠣꠞꠈꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("LK18_4","072_18_4","LUK","18","4","4","ꠁ ꠢꠣꠇꠤꠝꠦ ꠇꠄꠖꠤꠘ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠟꠣ ꠘꠣ। ꠛꠣꠖꠦ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠟꠣ, ꠀꠝꠤ ꠔ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁ ꠘꠣ, ꠝꠣꠘꠡꠞꠦꠅ ꠔꠅꠀꠇ꠆ꠇꠣ ꠇꠞꠤ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("LK18_5","072_18_5","LUK","18","5","5","ꠅꠁꠟꠦ ꠁ ꠠꠣꠠꠤꠄ ꠀꠁꠀ ꠔ ꠢꠣꠝꠦꠡꠣ ꠍꠣꠔꠣꠄ, ꠅꠈꠘ ꠅꠉꠥꠞ ꠘꠤꠀꠎ꠆ꠎ ꠛꠤꠌꠣꠞꠈꠣꠘ ꠇꠞꠤꠟꠣꠁ। ꠘꠣꠁꠟꠦ ꠔꠣꠁ ꠀꠁꠀ ꠛꠣꠞ ꠛꠣꠞ ꠍꠣꠔꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK18_6","072_18_6","LUK","18","6","6","ꠛꠣꠖꠦ ꠢꠥꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠟꠣꠄ ꠘꠤ, ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠢꠣꠇꠤꠝꠦ ꠇꠤꠔꠣ ꠇꠞꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("LK18_7","072_18_7","LUK","18","7","7","ꠔꠦ ꠎꠦꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠖꠤꠘꠦ-ꠞꠣꠁꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠇꠣꠘ꠆ꠖꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠤꠔꠣ ꠔꠣꠘ ꠁ ꠝꠣꠄꠀꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠢꠇ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠔꠣ ꠘꠣꠄ ꠘꠤ? ꠔꠣꠁꠘ ꠢꠥꠘꠔꠦ ꠇꠥꠘꠥ ꠀꠞ ꠖꠦꠞꠤ ꠇꠞꠛꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK18_8","072_18_8","LUK","18","8","8","ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠔꠣꠁꠘ ꠎꠟꠖꠤ ꠇꠞꠤꠃ ꠄꠞꠣꠞ ꠢꠇ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠛꠣ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠎꠦꠛꠟꠣ ꠁ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠝꠥ, ꠢꠃ ꠡꠝꠄ ꠖꠥꠘꠤꠀꠔ ꠇꠥꠘꠥ ꠁꠝꠣꠘ ꠙꠣꠁꠝꠥ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK18_9","072_18_9","LUK","18","9","9","ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞꠦ ꠈꠥꠛ ꠙꠞꠦꠎꠉꠣꠞ, ꠀꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠢꠥꠞꠥ ꠝꠘꠅ ꠇꠞꠔ, ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK18_10","072_18_10","LUK","18","10","10","ꠇꠁꠟꠣ, “ꠖꠥꠁꠎꠘ ꠝꠣꠘꠥꠡ ꠖꠥꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠉꠦꠟ। ꠄꠞꠣꠞ ꠄꠇꠎꠘ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠀꠞ ꠖꠥꠍꠞꠣ ꠎꠘ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK18_11","072_18_11","LUK","18","11","11","ꠚꠞꠤꠡꠤ ꠛꠦꠐꠣꠄ ꠀꠟꠉꠣ ꠃꠛꠣꠁꠀ ꠅꠃꠟꠣ ꠖꠥꠀ ꠇꠞꠟ, ꠅ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠞꠣꠝ, ꠀꠝꠤ ꠔ ꠡꠝꠣꠎꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠚꠞꠝꠣꠘ, ꠎꠣꠟꠤꠝ, ꠀꠞ ꠎꠤꠘꠣꠇꠥꠞ ꠘꠣꠄ, ꠛꠣ ꠅꠃ ꠊꠥꠡꠈꠥꠞ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣꠞ ꠟꠣꠈꠣꠘꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK18_12","072_18_12","LUK","18","12","12","ꠀꠝꠤ ꠢꠣꠙ꠆ꠔꠣꠔ ꠖꠥꠁꠖꠤꠘ ꠞꠥꠎꠣ ꠞꠣꠈꠤ, ꠀꠞ ꠀꠝꠣꠞ ꠢꠇ꠆ꠇꠟ ꠞꠥꠎꠤꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠔꠥꠝꠣꠞ ꠘꠣꠝꠦ ꠎꠇꠣꠔ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("LK18_13","072_18_13","LUK","18","13","13","ꠅꠁꠟꠦ ꠅꠃ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠛꠦꠐꠣꠄ ꠖꠥꠞꠁ ꠃꠛꠣꠁ ꠞꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠀꠞꠡꠞ ꠛꠣꠄ ꠌꠃꠈ ꠔꠥꠟꠣꠞ ꠡꠣꠅꠡꠅ ꠔꠣꠞ ꠅꠁꠟ ꠘꠣ। ꠢꠦ ꠛꠥꠇꠥꠔ ꠝꠣꠞꠤ ꠝꠣꠞꠤ ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ ꠇꠁꠟ, ꠅ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠤ ꠛꠠ ꠉꠥꠘꠣꠉꠣꠞ, ꠀꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("LK18_14","072_18_14","LUK","18","14","14","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠅꠃ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠛꠦꠐꠣꠃ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘꠤꠀ ꠔꠣꠞ ꠊꠞꠅ ꠉꠦꠟ, ꠢꠤ ꠚꠞꠤꠡꠤ ꠘꠣꠄ। ꠀꠍꠟꠦ ꠎꠦ ꠘꠤꠎꠞꠦ ꠛꠠ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠣꠞꠦ ꠢꠥꠞꠥ ꠇꠞꠣ ꠅꠁꠛ। ꠀꠞ ꠎꠦ ꠘꠤꠎꠞꠦ ꠢꠥꠞꠥ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠣꠞꠦ ꠛꠠ ꠇꠞꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK18_15","072_18_15","LUK","18","15","15","ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠟꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟ, ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠀꠔꠣꠁ ꠖꠤꠀ ꠖꠥꠀ ꠇꠞꠂꠘ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠛꠤꠞꠇ꠆ꠔ ꠅꠁꠀ ꠘꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK18_16","072_18_16","LUK","18","16","16","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠘꠤꠟꠣ, ꠘꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠛꠣꠞ ꠖꠦꠅ, ꠔꠣꠞꠣꠞꠦ ꠛꠣꠗꠣ ꠖꠤꠅ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠅꠃ ꠘꠝꠥꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤꠃ। ");
INSERT INTO syls_vpl VALUES ("LK18_17","072_18_17","LUK","18","17","17","ꠀꠝꠤ ꠢꠇ ꠇꠕꠣ ꠇꠁꠀꠞ, ꠢꠥꠞꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠛꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠡꠘ ꠘꠣ ꠝꠣꠘꠟꠦ, ꠇꠥꠘꠥ ꠎꠘꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK18_18","072_18_18","LUK","18","18","18","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠁꠘ꠆ꠌꠣꠁꠔꠞ ꠄꠇ ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠅ ꠢꠇ ꠃꠡ꠆ꠔꠣꠖ, ꠀꠝꠣꠞꠦ ꠛꠣꠔꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠇꠤꠔꠣ ꠇꠞꠟꠦ ꠀꠝꠤ ꠀꠈꠦꠞ ꠙꠣꠁꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("LK18_19","072_18_19","LUK","18","19","19","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞꠦ ꠇꠦꠘꠦ ꠢꠇ ꠇꠁꠞꠣ? ꠈꠣꠟꠤ ꠄꠇ ꠀꠟ꠆ꠟꠣ ꠛꠣꠖꠦ ꠀꠞ ꠇꠦꠃ ꠢꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK18_20","072_18_20","LUK","18","20","20","ꠀꠙꠘꠦ ꠔ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠎꠣꠘꠂꠘ, ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠈꠥꠘ ꠇꠞꠤꠅ ꠘꠣ। ꠌꠥꠞꠤ ꠇꠞꠤꠅ ꠘꠣ। ꠝꠤꠍꠣ ꠇꠥꠘꠥ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠅ ꠘꠣ। ꠔꠥꠝꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK18_21","072_18_21","LUK","18","21","21","ꠢꠤ ꠝꠥꠞꠛ꠆ꠛꠤꠄ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔ ꠢꠥꠞꠥꠝꠣꠘ ꠕꠘꠦꠃ ꠀꠖꠣꠄ ꠇꠞꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK18_22","072_18_22","LUK","18","22","22","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠈꠣꠟꠤ ꠄꠇꠈꠣꠘ ꠇꠣꠝ ꠛꠣꠇꠤ ꠀꠍꠦ, ꠀꠙꠘꠣꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠛꠦꠌꠤꠀ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠟꠣꠃꠇ꠆ꠇꠣ। ꠔꠦꠃ ꠀꠙꠘꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠗꠘ ꠙꠣꠁꠛꠣ। ꠛꠣꠖꠦ ꠀꠁꠀ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK18_23","072_18_23","LUK","18","23","23","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠤ ꠝꠥꠞꠛ꠆ꠛꠤ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠉꠦꠟꠣ, ꠔꠣꠁꠘ ꠀꠍꠟꠦ ꠛꠃꠔ ꠛꠠ ꠗꠘꠤ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK18_24","072_18_24","LUK","18","24","24","ꠔꠣꠁꠘ ꠛꠦꠎꠣꠞ ꠅꠁꠉꠦꠍꠂꠘ ꠖꠦꠈꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠗꠘꠤ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠘꠤ ꠛꠠ ꠝꠡꠇꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK18_25","072_18_25","LUK","18","25","25","ꠗꠘꠤ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠘꠤꠞ ꠌꠣꠁꠔꠦ, ꠍꠥꠁꠞ ꠘꠣʼ ꠛꠣꠄꠖꠤ ꠃꠐ ꠢꠣꠝꠣꠘꠤ ꠀꠞꠅ ꠡꠥꠎꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK18_26","072_18_26","LUK","18","26","26","ꠁꠈꠣꠘ ꠎꠣꠞꠣ ꠢꠥꠘꠟꠣ, ꠔꠣꠞꠣ ꠀꠞꠎ ꠇꠞꠟꠣ, “ꠔꠦ ꠀꠞ ꠇꠦꠉꠤꠄ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("LK18_27","072_18_27","LUK","18","27","27","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠅꠡꠝ꠆ꠛꠛ, ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠔ ꠁꠔꠣ ꠡꠝ꠆ꠛꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK18_28","072_18_28","LUK","18","28","28","ꠅꠃ ꠡꠝꠄ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠔ ꠢꠇꠟꠔꠣ ꠚꠣꠟꠣꠁ ꠕꠁꠀ ꠀꠙꠘꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK18_29","072_18_29","LUK","18","29","29","ꠔꠦꠃ ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣ ꠘꠤꠎꠞ ꠛꠣꠠꠤ-ꠊꠞ, ꠝꠣ-ꠛꠣꠚ, ꠛꠃ, ꠙꠥꠀ-ꠙꠥꠠꠤ, ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞ ꠚꠣꠟꠣꠁꠀ ꠀꠁꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("LK18_30","072_18_30","LUK","18","30","30","ꠔꠣꠞꠣ ꠅꠃ ꠖꠥꠘꠤꠀꠔꠃ ꠄꠞ ꠛꠃꠔ ꠛꠦꠡꠤ ꠙꠣꠁꠛꠣ, ꠀꠞ ꠛꠣꠖꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠀꠈꠦꠞꠅ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK18_31","072_18_31","LUK","18","31","31","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠗꠣꠞꠅ ꠛꠅꠀꠁꠟꠣ। ꠛꠅꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠅꠈꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠁꠞꠣꠝ, ꠔꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠘꠛꠤ ꠅꠇꠟꠦ ꠎꠔꠔꠣ ꠟꠦꠈꠤꠀ ꠉꠦꠍꠂꠘ, ꠁꠔꠣ ꠅꠈꠘ ꠙꠥꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK18_32","072_18_32","LUK","18","32","32","ꠀꠝꠣꠞꠦ ꠛꠤꠗꠞ꠆ꠝꠤ ꠎꠣꠔꠤꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠝꠣꠘꠡꠦ ꠟꠁꠀ ꠓꠋ-ꠔꠣꠝꠣꠡꠣ ꠇꠞꠛꠣ, ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠛꠣ, ꠀꠞ ꠕꠥꠕꠥ ꠇꠞꠤ ꠝꠥꠈꠅ ꠍꠦꠚ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK18_33","072_18_33","LUK","18","33","33","ꠀꠝꠣꠞꠦ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠛꠣ ꠛꠣꠖꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠛꠣ। ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK18_34","072_18_34","LUK","18","34","34","ꠅꠁꠟꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠅꠃ ꠝꠣꠔꠞ ꠇꠥꠘꠥ ꠜꠦꠖ ꠛꠥꠎꠟꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠇꠤꠔꠣ ꠇꠁꠞꠣ ꠔꠣꠞꠣ ꠡꠝꠎꠤꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠉꠥꠙꠘ ꠞꠣꠈꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK18_35","072_18_35","LUK","18","35","35","ꠁꠍꠣ ꠎꠦꠛꠟꠣ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣꠄ ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠁꠀ ꠜꠤꠇ ꠇꠞꠣꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK18_36","072_18_36","LUK","18","36","36","ꠀꠈꠔꠣꠃ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠙꠣꠅꠞ ꠔꠣꠟꠤ ꠢꠥꠘꠤꠀ ꠛꠦꠐꠣꠄ ꠎꠤꠇꠣꠁꠟ, “ꠇꠤꠔꠣ ꠛꠣ, ꠇꠤꠔꠣ ꠅꠞ?” ");
INSERT INTO syls_vpl VALUES ("LK18_37","072_18_37","LUK","18","37","37","ꠝꠣꠘꠡꠦ ꠇꠁꠟꠣ, “ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣꠄ ꠅꠃ ꠙꠕꠦꠖꠤ ꠔꠡꠞꠤꠚ ꠘꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK18_38","072_18_38","LUK","18","38","38","ꠅꠃ ꠢꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠃꠑꠟ, “ꠅ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ ꠁꠍꠣ, ꠀꠝꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK18_39","072_18_39","LUK","18","39","39","ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠢꠥꠘꠤꠀ ꠜꠤꠠꠞ ꠍꠣꠝꠘꠞ ꠇꠣꠔꠣꠞꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠗꠝꠇ ꠖꠤꠟꠣ, “ꠌꠥꠙ ꠇꠞꠅ, ꠘꠤꠞꠣꠁ ꠞꠅ।” ꠅꠁꠟꠦ ꠢꠦ ꠀꠞꠅ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠅ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ, ꠀꠝꠣꠞꠦ ꠞꠢꠝ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK18_40","072_18_40","LUK","18","40","40","ꠔꠦꠃ ꠁꠍꠣ ꠃꠛꠣꠁ ꠉꠦꠟꠣ। ꠃꠛꠣꠁꠀ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣꠞꠦ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠘꠣꠁꠟꠣ। ꠛꠦꠐꠣ ꠗꠣꠞꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK18_41","072_18_41","LUK","18","41","41","“ꠇꠤꠔꠣ ꠛꠣ, ꠔꠥꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ꠛꠦꠐꠣꠄ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠈꠣꠟꠤ ꠌꠃꠈꠦ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK18_42","072_18_42","LUK","18","42","42","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ ꠔꠦ ꠖꠦꠈꠅ। ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠅꠁꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK18_43","072_18_43","LUK","18","43","43","ꠟꠉꠦ ꠟꠉꠦꠃ ꠛꠦꠐꠣꠞ ꠌꠃꠈ ꠈꠥꠟꠤꠉꠦꠟ, ꠖꠦꠈꠣꠞ ꠡꠇ꠆ꠔꠤ ꠙꠣꠁꠟ। ꠛꠦꠐꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ ꠇꠞꠤ ꠔꠣꠘ ꠈꠞꠦ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠁꠟ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_1","072_19_1","LUK","19","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("LK19_2","072_19_2","LUK","19","2","2","ꠢꠘꠅ ꠎꠣꠇꠤꠞ ꠘꠣꠝꠞ ꠛꠠ ꠄꠇ ꠗꠘꠤ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ। ꠄꠁꠘ ꠅꠁꠟꠣ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠞꠣ ꠅꠇꠟꠞ ꠙꠞꠗꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("LK19_3","072_19_3","LUK","19","3","3","ꠁꠍꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠈꠥꠛ ꠈꠣꠁꠡ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠛꠣꠐ꠆ꠐꠤ ꠝꠣꠘꠥꠡ, ꠄꠞꠖꠣꠄ ꠅꠔ ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠖꠦꠈꠣꠞ ꠃꠙꠣꠄ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_4","072_19_4","LUK","19","4","4","ꠅꠃ ꠖꠃꠠꠤꠀ ꠀꠉꠦꠖꠤ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠁꠍꠣ ꠎꠦ ꠙꠕꠦꠖꠤ ꠀꠁꠞꠣ ꠅꠃ ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠞ ꠄꠇ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠅ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_5","072_19_5","LUK","19","5","5","ꠁꠍꠣ ꠎꠦꠛꠟꠣ ꠢꠃ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠞ ꠔꠟꠦ ꠀꠁꠟꠣ, ꠔꠣꠁꠘ ꠃꠙꠞꠦꠖꠤ ꠌꠣꠁꠀ ꠎꠣꠇꠤꠞꠞꠦ ꠒꠣꠇ ꠖꠤꠟꠣ, “ꠎꠣꠇꠤꠞ, ꠎꠟꠖꠤ ꠟꠣꠝꠤꠀ ꠀꠅ। ꠀꠝꠤ ꠀꠁꠎ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠔ ꠞꠁꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK19_6","072_19_6","LUK","19","6","6","ꠎꠣꠇꠤꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ। ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠀ ꠁꠍꠣꠞꠦ ꠔꠣꠎꠤꠝ ꠇꠞꠤꠀ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_7","072_19_7","LUK","19","7","7","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟꠦ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠔꠣꠁꠘ ꠇꠦꠘꠦ ꠄꠇ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠦꠐꠣꠞ ꠛꠣꠠꠤꠔ ꠞꠣꠁꠔ ꠇꠣꠐꠣꠘꠤꠔ ꠉꠦꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("LK19_8","072_19_8","LUK","19","8","8","ꠎꠣꠇꠤꠞꠦ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠅꠈꠘꠃ ꠀꠝꠣꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠅꠞ꠆ꠗꠦꠇ ꠉꠞꠤꠛꠞꠦ ꠟꠤꠟ꠆ꠟꠣ ꠖꠤꠟꠣꠁꠞꠣꠝ। ꠀꠞ ꠎꠦꠞꠣꠞ ꠢꠇ ꠐꠉꠤꠀ ꠀꠘꠍꠤ, ꠔꠣꠞꠣꠞꠦ ꠌꠣꠁꠞ ꠅꠔꠈꠣꠘ ꠚꠤꠞꠔ ꠖꠤꠟꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK19_9","072_19_9","LUK","19","9","9","ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠁꠎ ꠕꠣꠇꠤ ꠁ ꠛꠣꠠꠤꠔ ꠘꠣꠎꠣꠔ ꠀꠁꠍꠦ। ꠄꠁꠘꠅ ꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠄꠇꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("LK19_10","072_19_10","LUK","19","10","10","ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠦ-ꠙꠕꠤ ꠅꠇꠟꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠛꠣꠞ ꠇꠞꠤꠀ, ꠔꠣꠞꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠔ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠁ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK19_11","072_19_11","LUK","19","11","11","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠅꠔꠣ ꠝꠣꠔꠤꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠖꠥꠞꠁ ꠞꠁꠍꠂꠘ। ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠟꠣ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠙꠃꠍꠤꠀꠃ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠎꠣꠁꠞ ꠇꠞꠤꠟꠤꠛꠣ। ꠄꠞꠟꠣꠉꠤ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK19_12","072_19_12","LUK","19","12","12","“ꠘꠛꠣꠛ ꠙꠞꠤꠛꠣꠞꠞ ꠄꠇꠎꠘ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡ ꠛꠃꠔ ꠖꠥꠞꠁ ꠄꠇ ꠖꠦꠡꠅ ꠍꠚꠞꠅ ꠉꠦꠟꠣ। ꠔꠣꠘ ꠈꠤꠀꠟ ꠀꠍꠤꠟ ꠢꠘꠅ ꠉꠤꠀ ꠞꠣꠎꠣ ꠅꠁꠀ ꠚꠤꠞꠔ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_13","072_19_13","LUK","19","13","13","ꠎꠣꠁꠛꠣꠞ ꠀꠉꠦ ꠔꠣꠘ ꠖꠡꠎꠘ ꠉꠥꠟꠣꠝꠞꠦ ꠀꠘꠤꠀ ꠙꠞꠔꠦꠇ ꠎꠘꠞꠦ ꠄꠇꠐꠣ ꠇꠞꠤ ꠡꠥꠘꠣꠞ ꠝꠢꠞ ꠖꠤꠀ ꠇꠁꠟꠣ, ‘ꠀꠝꠤ ꠀꠁꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠉꠥꠁꠘꠖꠤ ꠔꠥꠝꠞꠣ ꠇꠣꠄ-ꠇꠣꠞꠛꠣꠞ ꠇꠞꠅ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_14","072_19_14","LUK","19","14","14","“ꠅꠁꠟꠦ ꠔꠣꠘ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠔꠣ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠔꠣꠘ ꠈꠞꠦ ꠅꠁꠀ ꠉꠥꠁꠀ ꠙꠣꠑꠣꠁꠀ ꠢꠃ ꠛꠣꠖꠡꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ, ‘ꠀꠝꠞꠣ ꠌꠣꠁ ꠘꠣ, ꠄꠁꠘ ꠀꠝꠞꠣꠞ ꠞꠣꠎꠣ ꠅꠃꠇ꠆ꠇꠣ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_15","072_19_15","LUK","19","15","15","ꠅꠁꠟꠦꠅ ꠔꠣꠁꠘ ꠞꠣꠎꠣ ꠛꠘꠤꠀ ꠚꠤꠞꠔ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠢꠃ ꠎꠦ ꠖꠡꠎꠘ ꠉꠥꠟꠣꠝꠞꠦ ꠔꠣꠁꠘ ꠝꠢꠞ ꠖꠤꠍꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠀꠘꠣꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, ꠇꠣꠄ-ꠇꠣꠞꠛꠣꠞ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠇꠦ ꠇꠔ ꠟꠣꠜ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK19_16","072_19_16","LUK","19","16","16","ꠙꠄꠟꠣ ꠎꠘꠦ ꠀꠁꠀ ꠇꠁꠟ, ‘ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠄꠇ ꠝꠢꠞꠖꠤ ꠀꠝꠤ ꠖꠡ ꠝꠢꠞ ꠞꠥꠎꠤ ꠇꠞꠍꠤ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_17","072_19_17","LUK","19","17","17","ꠞꠣꠎꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, ‘ꠜꠣꠟꠣ ꠇꠞꠍ! ꠔꠥꠝꠤ ꠔ ꠜꠣꠟꠣ ꠉꠥꠟꠣꠝ, ꠔꠥꠝꠤ ꠈꠥꠛ ꠡꠣꠝꠣꠁꠘ꠆ꠘ ꠛꠦꠙꠣꠞꠦꠅ ꠢꠇ ꠀꠍ। ꠔꠦ ꠔꠥꠝꠤ ꠅꠃ ꠖꠡ ꠙꠞꠉꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠝꠤꠖꠣꠞꠤ ꠇꠞꠅ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_18","072_19_18","LUK","19","18","18","ꠖꠥꠍꠞꠣ ꠎꠘꠦ ꠇꠁꠟ, ‘ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠝꠢꠞꠖꠤ ꠀꠝꠤ ꠙꠣꠌ ꠝꠢꠞ ꠞꠥꠎꠤ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LK19_19","072_19_19","LUK","19","19","19","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠤꠅ ꠙꠣꠌ ꠙꠞꠉꠘꠣꠞ ꠃꠙꠞꠦ ꠎꠝꠤꠖꠣꠞꠤ ꠇꠞꠅ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_20","072_19_20","LUK","19","20","20","ꠛꠣꠖꠦ ꠀꠞꠇ ꠎꠘꠦ ꠇꠁꠟ, ‘ꠢꠥꠎꠥꠞ, ꠅꠃ ꠘꠦꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞ ꠢꠤ ꠝꠢꠞ। ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠒꠞꠣꠁꠀ ꠀꠙꠘꠣꠞ ꠝꠢꠞ ꠞꠥꠝꠣꠟꠅ ꠛꠣꠘ꠆ꠖꠤꠀ ꠕꠁ ꠖꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("LK19_21","072_19_21","LUK","19","21","21","ꠀꠙꠘꠦ ꠔ ꠇꠠꠣ ꠝꠤꠎꠣꠎꠞ ꠝꠣꠘꠥꠡ। ꠎꠝꠣ ꠘꠣ ꠇꠞꠤꠀꠅ ꠀꠖꠣꠄ ꠇꠞꠂꠘ, ꠈꠦꠔ ꠘꠣ ꠇꠞꠤꠀꠅ ꠚꠡꠟ ꠇꠣꠐꠂꠘ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_22","072_19_22","LUK","19","22","22","“ꠔꠦꠃ ꠞꠣꠎꠣꠄ ꠇꠁꠟꠣ, ‘ꠅ ꠈꠛꠤꠍ ꠉꠥꠟꠣꠝ! ꠔꠞ ꠝꠥꠈꠞ ꠇꠕꠣꠄ ꠀꠝꠤ ꠔꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠝꠥ। ꠔꠥꠁ ꠔ ꠎꠣꠘꠍꠃ ꠀꠝꠤ ꠇꠠꠣ ꠝꠤꠎꠣꠎꠞ ꠝꠣꠘꠥꠡ, ꠎꠝꠣ ꠘꠣ ꠇꠞꠤꠀꠅ ꠀꠖꠣꠄ ꠇꠞꠤ, ꠈꠦꠔ ꠘꠣ ꠇꠞꠤꠀꠅ ꠚꠡꠟ ꠇꠣꠐꠤ! ");
INSERT INTO syls_vpl VALUES ("LK19_23","072_19_23","LUK","19","23","23","ꠔꠦ ꠀꠝꠣꠞ ꠝꠢꠞ ꠔꠥꠁ ꠛꠦꠙꠣꠞꠤꠞ ꠉꠦꠍꠦ ꠕꠁꠟꠦ ꠘꠣ ꠇꠦꠘꠦ? ꠔꠦ ꠔ ꠀꠝꠤ ꠀꠁꠀ ꠝꠥꠟ ꠝꠢꠞꠞ ꠟꠉꠦ ꠇꠤꠍꠥ ꠟꠣꠜꠅ ꠙꠣꠁꠟꠣꠝ ꠅꠘꠦ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_24","072_19_24","LUK","19","24","24","ꠞꠣꠎꠣꠄ ꠔꠣꠘ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞꠦ ꠇꠁꠟꠣ, ‘ꠅꠉꠥꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠃ ꠝꠢꠞ ꠚꠤꠞꠔ ꠀꠘꠅ, ꠀꠞ ꠎꠣꠞ ꠖꠡ ꠝꠢꠞ ꠀꠍꠦ ꠔꠣꠞꠦ ꠖꠦꠅ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_25","072_19_25","LUK","19","25","25","ꠔꠦꠃ ꠢꠇꠟꠦ ꠇꠁꠟꠣ, ‘ꠢꠥꠎꠥꠞ, ꠔꠣꠞ ꠔ ꠄꠝꠘꠦꠃ ꠖꠡ ꠝꠢꠞ ꠀꠍꠦ।’ ");
INSERT INTO syls_vpl VALUES ("LK19_26","072_19_26","LUK","19","26","26","ꠞꠣꠎꠣꠄ ꠇꠁꠟꠣ, ‘ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠎꠣꠞ ꠀꠍꠦ ꠔꠣꠞꠦ ꠀꠞꠅ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠎꠣꠞ ꠘꠣꠁ, ꠔꠣꠞ ꠎꠦꠔꠣ ꠀꠍꠦ ꠅꠔꠣꠅ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK19_27","072_19_27","LUK","19","27","27","ꠀꠞ ꠀꠝꠣꠞ ꠎꠦꠔꠣ ꠖꠥꠡꠝꠘꠦ ꠌꠣꠁꠍꠂꠘ ꠘꠣ ꠀꠝꠤ ꠞꠣꠎꠣ ꠅꠁꠔꠣꠝ, ꠅꠔꠣꠞꠦ ꠅꠘꠅ ꠗꠞꠤꠀ ꠀꠘꠤꠀ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠞꠤꠟꠣꠅ।’ ” ");
INSERT INTO syls_vpl VALUES ("LK19_28","072_19_28","LUK","19","28","28","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠀꠉꠦ ꠅꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠛꠣꠄ ꠔꠡꠞꠤꠚ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_29","072_19_29","LUK","19","29","29","ꠔꠣꠁꠘ ꠎꠄꠔꠥꠘ ꠙꠣꠠꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠣꠄꠔ-ꠚꠣꠁꠎ꠆ꠎꠣ ꠀꠞ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠉꠣꠃꠞ ꠉꠣꠟꠣꠔ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠘ ꠖꠥꠁꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠅꠈꠣꠘ ꠇꠁꠀ ꠙꠣꠑꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠃ ꠍꠣꠝꠘꠞ ꠉꠣꠃꠔ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("LK19_30","072_19_30","LUK","19","30","30","ꠉꠣꠃꠔ ꠢꠣꠝꠣꠁꠀꠃ ꠖꠦꠈꠛꠣꠄ, ꠄꠉꠥ ꠉꠣꠗꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠛꠣꠘ꠆ꠖꠣ ꠀꠍꠦ। ꠅꠉꠥꠞ ꠃꠙꠞꠦ ꠇꠦꠃ ꠇꠥꠘꠥꠖꠤꠘ ꠌꠠꠍꠦ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠅꠉꠥꠞ ꠛꠣꠘ ꠈꠥꠟꠤꠀ ꠅꠘꠅ ꠟꠁꠀ ꠀꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("LK19_31","072_19_31","LUK","19","31","31","ꠇꠦꠃ ꠎꠥꠖꠤ ꠎꠤꠇꠣꠄ, ‘ꠁꠉꠥꠞ ꠛꠣꠘ ꠈꠥꠟ ꠇꠦꠘꠦ ꠛꠣ? ꠔꠦ ꠇꠁꠅ, ꠢꠥꠎꠥꠞꠞ ꠉꠞꠎ ꠀꠍꠦ।’ ” ");
INSERT INTO syls_vpl VALUES ("LK19_32","072_19_32","LUK","19","32","32","ꠎꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠙꠣꠑꠣꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠉꠤꠀ ꠔꠣꠘ ꠇꠕꠣꠝꠔ ꠢꠇꠟꠔꠣ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_33","072_19_33","LUK","19","33","33","ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠉꠣꠗꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠛꠣꠘ ꠈꠥꠟꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠟꠤꠇꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠛꠣ, ꠖꠠꠤ ꠈꠥꠟꠞꠣꠄ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK19_34","072_19_34","LUK","19","34","34","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞꠞ ꠉꠞꠎ ꠀꠍꠦ ꠇꠞꠤ ꠈꠥꠟꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK19_35","072_19_35","LUK","19","35","35","ꠛꠣꠖꠦ ꠉꠣꠗꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠟꠁꠀ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ, ꠄꠞꠣꠞ ꠉꠔꠞꠞ ꠌꠣꠖ꠆ꠖꠞꠖꠤ ꠉꠣꠗꠣꠞ ꠙꠤꠑꠤꠔ ꠉꠖꠤ ꠛꠣꠘꠣꠁꠀ ꠁꠍꠣꠞꠦ ꠛꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_36","072_19_36","LUK","19","36","36","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠉꠣꠗꠣ ꠌꠠꠤꠀ ꠙꠕꠦꠖꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠙꠕꠞ ꠝꠣꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠎꠣꠞꠎꠤꠞ ꠌꠣꠖ꠆ꠖꠞ ꠛꠤꠍꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_37","072_19_37","LUK","19","37","37","ꠁꠍꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠄꠔꠥꠘ ꠙꠣꠠ ꠕꠘꠦ ꠟꠣꠝꠣꠞ ꠙꠕꠅ ꠀꠁꠀ ꠀꠎꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠅ ꠟꠉꠦ ꠀꠍꠟꠣ, ꠄꠞꠣ ꠔꠣꠘ ꠎꠦꠔꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠍꠤꠟꠣ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠈꠥꠡꠤꠄ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK19_38","072_19_38","LUK","19","38","38","“ꠝꠥꠛꠣꠞꠇ ꠢꠃ ꠛꠣꠖꠡꠣ, ꠎꠦꠁꠘ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ। ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠡꠣꠘ꠆ꠔꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠀꠞꠡꠅ ꠉꠃꠞꠛ!” ");
INSERT INTO syls_vpl VALUES ("LK19_39","072_19_39","LUK","19","39","39","ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠇꠄꠎꠘꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦ ꠗꠝꠇ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK19_40","072_19_40","LUK","19","40","40","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠄꠞꠣꠞ ꠝꠥꠈ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟ꠆ꠟꠦꠅ, ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠃꠑꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK19_41","072_19_41","LUK","19","41","41","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ ꠖꠦꠈꠤꠀ ꠇꠣꠘ꠆ꠖꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_42","072_19_42","LUK","19","42","42","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠣꠄꠞꠦ ꠢꠣꠄ! ꠀꠁꠎ ꠎꠥꠖꠤ ꠔꠥꠝꠤ ꠛꠥꠎꠔꠣꠄ, ꠡꠣꠘ꠆ꠔꠤ ꠇꠤꠟꠣ ꠇꠣꠁꠝ ꠅꠄ! ꠅꠁꠟꠦ ꠅꠈꠘ ꠁꠔꠣ ꠔꠥꠝꠣꠞ ꠌꠈꠥꠞ ꠀꠅꠠꠦ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK19_43","072_19_43","LUK","19","43","43","ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠟꠣ ꠡꠝꠄ ꠀꠎꠤꠞ ꠅꠁꠛ, ꠎꠦꠛꠟꠣ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠦ ꠖꠦꠅꠀꠟꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠝꠣꠐꠤꠞ ꠐꠦꠇꠤ ꠛꠣꠘ꠆ꠖꠤꠛ। ꠔꠥꠝꠣꠞꠦ ꠛꠦꠞꠤꠟꠤꠛ, ꠀꠞ ꠢꠇ꠆ꠇꠟꠛꠣꠄ ꠀꠐꠇ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LK19_44","072_19_44","LUK","19","44","44","ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠦꠐꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ ꠝꠣꠐꠤꠞ ꠟꠉꠦ ꠝꠤꠡꠣꠁꠛ। ꠔꠥꠝꠣꠞ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠀꠞꠇ ꠙꠣꠔ꠆ꠔꠞ ꠞꠁꠔ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠔꠣ ꠇꠞꠤ ꠎꠦ ꠡꠥꠎꠥꠉ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠤ ꠁ ꠡꠝꠄ-ꠡꠥꠎꠥꠉꠞꠦ ꠌꠤꠘꠟꠣꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK19_45","072_19_45","LUK","19","45","45","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠁꠟꠣ। ꠢꠣꠝꠣꠁꠀ ꠢꠘꠅ ꠎꠦꠔꠣꠄ ꠛꠦꠛꠡꠣ ꠇꠞꠣꠔ ꠀꠍꠟꠣ, ꠅꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_46","072_19_46","LUK","19","46","46","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠙꠣꠇ ꠇꠣꠟꠣꠝꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠝꠣꠞ ꠊꠞ ꠅꠁꠛ ꠝꠥꠘꠣꠎꠣꠔꠞ ꠊꠞ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠁꠈꠣꠘꠞꠦ ꠒꠣꠇꠣꠁꠔꠞ ꠀꠒ꠆ꠒꠣꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠟꠤꠍ।” ");
INSERT INTO syls_vpl VALUES ("LK19_47","072_19_47","LUK","19","47","47","ꠢꠎꠞꠔ ꠁꠍꠣ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠉꠤꠀ ꠘꠍꠤꠅꠔ ꠇꠞꠔꠣ। ꠅꠃ ꠡꠝꠄ ꠛꠠ ꠁꠝꠣꠝ, ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠡꠝꠣꠎꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK19_48","072_19_48","LUK","19","48","48","ꠅꠁꠟꠦ ꠇꠤꠟꠣ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠣ ꠎꠣꠄ, ꠄꠞ ꠇꠥꠘꠥ ꠚꠘ꠆ꠖꠤ ꠔꠣꠞꠣ ꠙꠣꠁꠟ ꠘꠣ। ꠇꠣꠞꠘ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠀꠡꠤꠇ ꠅꠁꠀ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK20_1","072_20_1","LUK","20","1","1","ꠅꠃ ꠍꠚꠞꠞ ꠇꠣꠟꠅ ꠄꠇꠖꠤꠘ ꠢꠎꠞꠔ ꠁꠍꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠝꠣꠎꠦ, ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠀꠍꠟꠣ। ꠀꠈꠔꠣꠃ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠀꠟꠤꠝ ꠅꠇꠟ ꠔꠣꠞꠣꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠀꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK20_2","072_20_2","LUK","20","2","2","“ꠀꠁꠌ꠆ꠍꠣ ꠇꠅ ꠌꠣꠁꠘ, ꠔꠥꠝꠤ ꠇꠥꠘ ꠈꠦꠝꠔꠣꠄ ꠁꠔꠣ ꠇꠣꠝ ꠇꠞꠞꠣꠄ, ꠔꠥꠝꠣꠞꠦ ꠁꠔꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠇꠦꠉꠤꠄ ꠖꠤꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK20_3","072_20_3","LUK","20","3","3","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠦ ꠀꠝꠤꠅ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠎꠤꠇꠣꠁꠞꠣꠝ, ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ");
INSERT INTO syls_vpl VALUES ("LK20_4","072_20_4","LUK","20","4","4","ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠍꠟꠣ, ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠘꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK20_5","072_20_5","LUK","20","5","5","ꠅꠃ ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠎꠥꠇ꠆ꠔꠤ-ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟ, “ꠎꠥꠖꠤ ꠇꠁ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠔꠦ ꠢꠦ ꠇꠁꠛ, ꠔꠣꠁꠟꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣꠄ ꠘꠣ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("LK20_6","072_20_6","LUK","20","6","6","ꠀꠞ ꠎꠥꠖꠤ ꠇꠁ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠔꠦ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠝꠣꠞꠛꠣ। ꠄꠢꠤꠀꠞꠦ ꠔ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠛꠤ ꠇꠁꠀ ꠝꠣꠘꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK20_7","072_20_7","LUK","20","7","7","ꠅꠃ ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠁ ꠈꠦꠝꠔꠣ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠙꠣꠁꠍꠟꠣ, ꠀꠝꠞꠣ ꠎꠣꠘꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK20_8","072_20_8","LUK","20","8","8","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠤꠅ ꠇꠁꠔꠣꠝ ꠘꠣꠄ, ꠇꠥꠘ ꠈꠦꠝꠔꠣꠄ ꠁꠔꠣ ꠇꠞꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK20_9","072_20_9","LUK","20","9","9","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠅꠃ ꠇꠤꠌ꠆ꠍꠣ ꠢꠥꠘꠣꠁꠟꠣ, “ꠄꠇ ꠉꠤꠞꠡ꠆ꠔꠦ ꠀꠋꠉꠥꠞꠞ ꠛꠣꠉꠣꠘ ꠇꠞꠟꠣ, ꠛꠣꠖꠦ ꠔꠣꠘ ꠛꠣꠉꠣꠘꠞꠦ ꠈꠦꠔꠣꠟ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠛꠣꠉꠤ ꠖꠤꠀ ꠛꠃꠔ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠛꠤꠖꠦꠡ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK20_10","072_20_10","LUK","20","10","10","ꠀꠋꠉꠥꠞ ꠙꠣꠇꠣꠞ ꠡꠝꠄ ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠛꠣꠐ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠄꠇ ꠉꠥꠟꠣꠝꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ। ꠅꠁꠟꠦ ꠈꠦꠔꠣꠟ ꠅꠇꠟꠦ ꠔꠣꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠤꠀ ꠈꠣꠟꠤ ꠀꠔꠦ ꠚꠤꠞꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK20_11","072_20_11","LUK","20","11","11","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠞꠇ ꠉꠥꠟꠣꠝꠞꠦ ꠙꠣꠑꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠁ ꠉꠥꠟꠣꠝꠞꠦꠅ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠤ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠀ ꠈꠣꠟꠤ ꠀꠔꠦ ꠚꠤꠞꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK20_12","072_20_12","LUK","20","12","12","ꠛꠣꠖꠦ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠉꠥꠟꠣꠝꠞꠦ ꠙꠣꠑꠣꠁꠟꠦ, ꠔꠣꠞꠣ ꠄꠅ ꠉꠥꠟꠣꠝꠞꠦ ꠝꠣꠞꠤꠀ ꠎꠈꠝ ꠇꠞꠤꠀ ꠛꠣꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK20_13","072_20_13","LUK","20","13","13","ꠔꠦꠃ ꠛꠣꠉꠣꠘꠞ ꠝꠣꠟꠤꠇꠦ ꠇꠁꠟꠣ, ‘ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ? ꠅꠈꠘ ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠙꠥꠔꠞꠦ ꠙꠣꠑꠣꠁꠝꠥ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠝꠣꠘꠔ ꠙꠣꠞꠦ।’ ");
INSERT INTO syls_vpl VALUES ("LK20_14","072_20_14","LUK","20","14","14","ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇꠞ ꠙꠥꠀꠞꠦ ꠖꠦꠈꠤꠀ ꠈꠦꠔꠣꠟ ꠅꠇꠟꠦ ꠇꠁꠟ, ꠅꠃ ꠙꠥꠀꠃ ꠔ ꠔꠣꠞ ꠛꠣꠚꠞ ꠢꠇꠟꠔꠣꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠛ। ꠀꠅ, ꠄꠞꠦ ꠝꠣꠞꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠁ। ꠔꠦꠃ ꠝꠣꠟꠤꠇꠞ ꠢꠇꠟꠔꠣ ꠀꠝꠞꠣ ꠙꠣꠁꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LK20_15","072_20_15","LUK","20","15","15","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠔꠣꠞꠦ ꠛꠣꠉꠣꠘꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠈꠥꠘ ꠇꠞꠤꠟꠣꠁꠟ। “ꠅꠈꠘ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠛꠣꠉꠣꠘꠞ ꠝꠣꠟꠤꠇꠦ ꠁ ꠛꠣꠉꠤꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠛꠣ? ");
INSERT INTO syls_vpl VALUES ("LK20_16","072_20_16","LUK","20","16","16","ꠔꠣꠁꠘ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠘꠤꠙꠣꠔ ꠇꠞꠤꠟꠤꠛꠣ ꠘꠣ ꠘꠤ? ꠀꠞ ꠔꠣꠘ ꠛꠣꠉꠣꠘ ꠖꠥꠍꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠖꠤꠛꠣ ꠘꠣ ꠘꠤ?” ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ! ꠀꠟ꠆ꠟꠣꠄ ꠚꠣꠘꠣ ꠖꠦꠃꠇ!” ");
INSERT INTO syls_vpl VALUES ("LK20_17","072_20_17","LUK","20","17","17","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠇꠦꠘꠦ ꠁꠟꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠞꠣꠎ ꠝꠦꠡ꠆ꠔꠁꠞ ꠅꠇꠟꠦ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠛꠦꠇꠣꠝꠣ ꠇꠁꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠍꠤꠟ, ꠅꠇꠐꠣ ꠖꠤꠀꠃ ꠊꠞꠞ ꠁꠀꠘ ꠈꠥꠐꠤ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK20_18","072_20_18","LUK","20","18","18","ꠁ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠇꠦꠃ ꠙꠠꠟꠦ, ꠁ ꠎꠘ ꠜꠣꠋꠉꠤꠀ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠅꠁꠎꠤꠛ, ꠀꠞ ꠁ ꠙꠣꠔ꠆ꠔꠞꠅ ꠇꠦꠃꠞꠞ ꠃꠙꠞꠦ ꠙꠠꠟꠦ, ꠢꠦ-ꠅ ꠎꠘ ꠌꠥꠞꠝꠣꠞ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK20_19","072_20_19","LUK","20","19","19","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠟꠔꠣ ꠌꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠁꠍꠣꠄ ꠁ ꠇꠤꠌ꠆ꠍꠣ ꠔꠣꠞꠣꠞ ꠘꠤꠅꠔꠦꠃ ꠇꠁꠞꠣ। ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞꠦ ꠒꠞꠣꠁꠀ ꠔꠣꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK20_20","072_20_20","LUK","20","20","20","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠌꠃꠈꠦ ꠌꠃꠈꠦ ꠞꠣꠈꠟꠣ, ꠔꠣꠘ ꠈꠞꠦ ꠇꠄꠎꠘ ꠉꠥꠁꠀ ꠟꠣꠉꠣꠁꠟꠣ। ꠉꠥꠁꠀ ꠅꠇꠟꠦ ꠝꠥꠝꠤꠘꠤ ꠛꠦꠡ ꠗꠞꠤꠀ ꠌꠟꠟꠦꠅ, ꠔꠣꠞꠣꠞ ꠘꠤꠅꠔ ꠅꠁꠟ ꠁꠍꠣꠞꠦ ꠇꠕꠣꠞ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠁꠔꠣ, ꠎꠣꠔꠦ ꠔꠣꠘꠦ ꠖꠦꠡꠞ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝꠞ ꠀꠖꠣꠟꠔꠅ ꠌꠣꠟꠣꠘ ꠇꠞꠣꠁꠟ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK20_21","072_20_21","LUK","20","21","21","ꠅꠃ ꠉꠥꠁꠀ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠔ ꠢꠇꠟꠞꠦ ꠢꠝꠣꠘ ꠌꠃꠈꠦ ꠖꠦꠈꠂꠘ। ꠀꠙꠘꠦ ꠢꠇ ꠝꠣꠔ ꠝꠣꠔꠂꠘ, ꠢꠇ ꠔꠣꠟꠤꠝ ꠖꠦꠁꠘ। ꠇꠦꠃꠞꠞꠦ ꠔꠅꠀꠇ꠆ꠇꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇ ꠙꠕ ꠖꠦꠈꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LK20_22","072_20_22","LUK","20","22","22","ꠔꠦ ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞꠦ ꠈꠣꠎꠘꠣ ꠖꠦꠅꠀ ꠎꠣꠁꠎ ꠘꠤ, ꠘꠣ ꠘꠣꠎꠣꠁꠎ?” ");
INSERT INTO syls_vpl VALUES ("LK20_23","072_20_23","LUK","20","23","23","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠇꠥ-ꠝꠔꠟꠛ ꠛꠥꠎꠤꠟꠤꠟꠣ। ꠛꠥꠎꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK20_24","072_20_24","LUK","20","24","24","“ꠖꠦꠈꠤ, ꠀꠝꠣꠞꠦ ꠄꠇꠐꠣ ꠖꠤꠘꠣꠞ ꠖꠦꠈꠣꠅ।” ꠖꠤꠘꠣꠞ ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠁꠉꠥꠞ ꠃꠙꠞꠦ ꠇꠣꠞ ꠍꠛꠤ ꠀꠞ ꠘꠣꠝ ꠀꠍꠦ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK20_25","072_20_25","LUK","20","25","25","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠇꠂꠍꠞꠞꠔꠣ ꠇꠂꠍꠞꠞꠦ ꠖꠦꠅ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞꠔꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK20_26","072_20_26","LUK","20","26","26","ꠔꠣꠘ ꠎꠥꠀꠙ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠀ ꠘꠤꠞꠣꠁ ꠅꠁꠉꠦꠟꠣ। ꠉꠥꠁꠀ ꠅꠇꠟꠦ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠘꠞꠦ ꠇꠕꠣꠞ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠁꠔ ꠙꠣꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK20_27","072_20_27","LUK","20","27","27","ꠛꠣꠖꠦ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠝꠎꠛꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠅꠃ ꠝꠎꠛꠞ ꠝꠣꠘꠡꠦ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠇꠥꠘꠥ ꠎꠣꠘꠖꠣꠞꠃ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK20_28","072_20_28","LUK","20","28","28","ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠘꠤꠅꠝ ꠟꠦꠈꠤꠀ ꠉꠦꠍꠂꠘ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠛꠃ ꠕꠁꠀ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠢꠣꠟꠔꠦ ꠝꠞꠤꠉꠦꠟꠦ, ꠔꠣꠞ ꠜꠣꠁꠄ ꠅꠃ ꠛꠃꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠝꠞꠣ ꠜꠣꠁꠞ ꠅꠀꠞꠤꠡ ꠙꠄꠖꠣ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LK20_29","072_20_29","LUK","20","29","29","ꠅꠈꠘ ꠝꠘꠅ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠄꠇ ꠊꠞꠅ ꠡꠣꠔ ꠜꠣꠁ ꠀꠍꠤꠟ। ꠙꠄꠟꠣ ꠎꠘꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠢꠣꠟꠔꠦ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK20_30","072_20_30","LUK","20","30","31","ꠛꠣꠖꠦ ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠀꠞ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠜꠣꠁꠄ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠟ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠡꠣꠔꠅ ꠜꠣꠁꠄꠃ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠤꠀ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠢꠣꠟꠔꠦ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK20_32","072_20_32","LUK","20","32","32","ꠢꠦꠡꠦ ꠅꠃ ꠛꠦꠐꠤꠅ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK20_33","072_20_33","LUK","20","33","33","ꠔꠦ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠁ ꠛꠦꠐꠤ ꠇꠣꠞ ꠛꠃ ꠅꠁꠛ? ꠡꠣꠔꠅ ꠎꠘꠦꠃ ꠔ ꠁ ꠛꠦꠐꠤꠞꠦ ꠛꠤꠀ ꠇꠞꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("LK20_34","072_20_34","LUK","20","34","34","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠂꠘ, ꠀꠞ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LK20_35","072_20_35","LUK","20","35","35","ꠅꠁꠟꠦ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠎꠦꠞꠣ ꠀꠈꠦꠞꠣꠔꠅ ꠇꠣꠝꠤꠀꠛꠤꠞ ꠟꠣꠈ ꠅꠁꠎꠣꠄ, ꠔꠣꠞꠣ ꠀꠞ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠔꠣ ꠘꠣꠄ, ꠛꠣ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠛꠁꠔꠣꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK20_36","072_20_36","LUK","20","36","36","ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠝꠃꠔꠅ ꠅꠁꠔ ꠘꠣꠄ, ꠔꠣꠞꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠎꠤꠛꠣ। ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠀꠈꠦꠞ ꠙꠣꠅꠀꠄ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠤꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK20_37","072_20_37","LUK","20","37","37","ꠔꠥꠞ ꠙꠣꠠꠞ ꠎꠣꠟꠣꠁꠟ ꠎꠋꠟꠣꠞ ꠛꠄꠀꠘꠤꠞ ꠝꠣꠎꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠛꠥꠎꠣꠁꠍꠂꠘ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠔ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠂꠘ, ꠄꠞꠟꠣꠉꠤꠃ ꠛꠃꠔ ꠀꠉꠦ ꠎꠦ ꠘꠛꠤ ꠅꠇꠟ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ ꠝꠥꠍꠣꠄ ꠝꠣꠛꠥꠖꠞꠦ ꠢꠃ ꠘꠛꠤ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ ꠇꠁꠀ ꠒꠣꠇꠤꠟꠣ। ꠔꠣꠁꠘ ꠝꠣꠛꠥꠖꠞꠦ ꠇꠁꠟꠣ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠟ꠆ꠟꠣ, ꠁꠍꠢꠣꠇꠞ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK20_38","072_20_38","LUK","20","38","38","ꠔꠦ ꠀꠟ꠆ꠟꠣ ꠔ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ ꠘꠣꠄ, ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ। ꠔꠣꠘ ꠘꠎꠞꠅ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠥꠡꠃ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK20_39","072_20_39","LUK","20","39","39","ꠔꠦꠃ ꠇꠄꠎꠘ ꠀꠟꠤꠝꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠔ ꠈꠣꠐꠤ ꠝꠣꠔ ꠝꠣꠔꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK20_40","072_20_40","LUK","20","40","40","ꠢꠦꠡꠦ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠀꠞ ꠇꠥꠘꠥ ꠍꠅꠀꠟ ꠇꠞꠣꠞ ꠡꠣꠅꠡ ꠙꠣꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK20_41","072_20_41","LUK","20","41","41","ꠄꠞꠝꠣꠎꠦ ꠁꠍꠣꠄ ꠅꠃ ꠀꠟꠤꠝ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠝꠣꠘꠡꠦ ꠇꠦꠘꠦ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖ ꠇꠂꠘ? ");
INSERT INTO syls_vpl VALUES ("LK20_42","072_20_42","LUK","20","42","43","ꠎꠛꠥꠞ ꠡꠞꠤꠚꠞ ꠝꠣꠎꠦ ꠖꠣꠃꠖꠦ ꠘꠤꠎꠦꠃ ꠔ ꠅꠈꠣꠘ ꠇꠁꠞꠣ, ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠇꠁꠟꠣ, ꠎꠔꠖꠤꠘ ꠔꠥꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠦ ꠘꠣ ꠚꠣꠟꠣꠁ, ꠅꠔ ꠖꠤꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ ꠛꠁꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("LK20_44","072_20_44","LUK","20","44","44","ꠖꠣꠃꠖꠦ ꠔ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠣꠘ ꠝꠥꠘꠤꠛ ꠇꠁꠀ ꠒꠣꠇꠤꠟꠣ, ꠔꠦ ꠀꠟ-ꠝꠍꠤ ꠇꠦꠝꠘꠦ ꠖꠣꠃꠖꠞ ꠀꠅꠟꠣꠖ ꠅꠁꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("LK20_45","072_20_45","LUK","20","45","45","ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠡꠣꠉꠞꠤꠖ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK20_46","072_20_46","LUK","20","46","46","“ꠀꠟꠤꠝ ꠅꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠅꠅ। ꠔꠣꠞꠣ ꠟꠣꠝ꠆ꠛꠣ ꠟꠣꠝ꠆ꠛꠣ ꠎꠥꠛ꠆ꠛꠣ ꠚꠤꠘ꠆ꠖꠤꠀ ꠊꠥꠞꠤꠔꠦ ꠈꠥꠛ ꠜꠣꠟꠣ ꠙꠣꠁꠘ। ꠛꠣꠎꠣꠞ-ꠀꠐꠅ ꠉꠤꠀ ꠍꠣꠟꠣꠝ ꠙꠣꠁꠔꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ। ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠍꠣꠝꠘꠞ ꠇꠣꠔꠣꠞꠅ ꠛꠁꠔꠦ ꠀꠞ ꠝꠎꠟꠤꠍꠅ ꠉꠤꠀ ꠖꠣꠝꠤ ꠎꠣꠉꠣꠔ ꠛꠁꠔꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK20_47","072_20_47","LUK","20","47","47","ꠔꠣꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠟꠣꠝ꠆ꠛꠣ ꠟꠣꠝ꠆ꠛꠣ ꠖꠥꠀ ꠇꠞꠂꠘ। ꠢꠤꠞꠛꠣꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠊꠞ-ꠛꠣꠠꠤ ꠖꠈꠟ ꠇꠞꠂꠘ। ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠄꠞꠣꠞ ꠛꠠ ꠇꠑꠤꠘ ꠡꠣꠎꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK21_1","072_21_1","LUK","21","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠗꠘꠤ ꠅꠇꠟꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠟꠤꠟ꠆ꠟꠣꠞ ꠒꠦꠉꠞ ꠝꠣꠎꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK21_2","072_21_2","LUK","21","2","2","ꠄꠞꠝꠣꠎꠦ ꠖꠦꠈꠟꠣ, ꠈꠥꠛ ꠉꠞꠤꠛ ꠄꠇ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠄꠅ ꠀꠁꠀ ꠒꠦꠉꠞ ꠝꠣꠎꠦ ꠖꠥꠁꠐꠣ ꠙꠄꠡꠣ ꠖꠣꠘ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK21_3","072_21_3","LUK","21","3","3","ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠅꠃ ꠉꠞꠤꠛ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠄ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠖꠣꠘ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK21_4","072_21_4","LUK","21","4","4","ꠇꠣꠞꠘ ꠛꠣꠇꠤ ꠢꠇꠟꠦ ꠈꠞꠌ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠖꠦꠠꠤꠀ ꠞꠁꠍꠦ, ꠅꠘ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠅꠋꠡ ꠒꠦꠉꠞ ꠝꠣꠎꠦ ꠖꠣꠘ ꠇꠞꠍꠦ। ꠅꠁꠟꠦ ꠁ ꠛꠦꠐꠤꠄ ꠘꠤꠎꠞ ꠅꠜꠣꠛ-ꠅꠘꠐꠘ ꠕꠣꠇꠟꠦꠅ, ꠔꠣꠁꠞ ꠇꠣꠝꠣꠁꠟ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠖꠣꠘ ꠇꠞꠤꠟꠤꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK21_5","072_21_5","LUK","21","5","5","ꠇꠄꠎꠘ ꠍꠣꠢꠣꠛꠤꠄ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠇꠣꠛꠣ ꠡꠞꠤꠚꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠔꠤꠟꠣ, ꠇꠁꠟꠣ, “ꠖꠦꠈꠞꠣ ꠘꠤ, ꠅꠔ ꠡꠥꠘ꠆ꠖꠞ ꠡꠥꠘ꠆ꠖꠞ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠀꠞ ꠖꠣꠘ-ꠈꠄꠞꠣꠔꠖꠤ ꠊꠞꠈꠣꠘꠞꠦ ꠢꠣꠎꠣꠁꠟ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK21_6","072_21_6","LUK","21","6","6","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠃ ꠎꠔꠔꠣ ꠖꠦꠈꠞꠣꠄ, ꠅꠟꠣ ꠄꠇ ꠖꠤꠘ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠁꠔꠣ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠀꠞꠇ ꠙꠣꠔ꠆ꠔꠞ ꠞꠁꠔ ꠘꠣꠄ। ꠢꠇꠟꠔꠣ ꠝꠣꠐꠤꠞ ꠟꠉꠦ ꠝꠤꠡꠤꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK21_7","072_21_7","LUK","21","7","7","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁꠔꠣ ꠇꠥꠘ ꠎꠝꠣꠘꠣꠔ ꠅꠁꠛ? ꠇꠥꠘ ꠀꠟꠣꠝꠔ ꠖꠦꠈꠟꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ, ꠢꠤ ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK21_8","072_21_8","LUK","21","8","8","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦ-ꠙꠕꠦ ꠘꠣ ꠘꠦꠄ। ꠛꠃꠔ ꠎꠘꠦ ꠀꠝꠣꠞ ꠘꠣꠝ ꠗꠞꠤ ꠀꠁꠀ ꠇꠁꠛ, ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ, ꠀꠝꠤꠃ ꠀꠟ-ꠝꠍꠤ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞ ꠈꠞꠦ ꠎꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK21_9","072_21_9","LUK","21","9","9","ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠥꠖ꠆ꠖ ꠀꠞ ꠉꠘ꠆ꠒꠉꠥꠟꠞ ꠈꠛꠞ ꠢꠥꠘꠛꠣꠄ, ꠒꠞꠣꠁꠅ ꠘꠣ। ꠇꠣꠞꠘ ꠙꠄꠟꠣ ꠁꠔꠣ ꠅꠁꠛꠃ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠁꠔꠣ ꠔ ꠡꠦꠡ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK21_10","072_21_10","LUK","21","10","10","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠎꠣꠔꠤꠄ ꠎꠣꠔꠤꠞ ꠛꠤꠙꠇ꠆ꠇꠦ, ꠞꠣꠎꠣꠄ ꠞꠣꠎꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("LK21_11","072_21_11","LUK","21","11","11","ꠛꠠ ꠛꠠ ꠜꠂꠍꠣꠟ ꠅꠁꠛ, ꠎꠣꠉꠣꠄ ꠎꠣꠉꠣꠄ ꠘꠤꠖꠣꠘ ꠀꠞ ꠛꠦꠎꠥꠁꠔꠣ ꠛꠦꠝꠣꠞ-ꠀꠎꠣꠞꠦ ꠝꠣꠘꠥꠡ ꠝꠞꠛꠣ। ꠀꠍꠝꠣꠘꠅ-ꠅ ꠈꠥꠛ ꠒꠞ-ꠈꠚꠞ ꠘꠤꠡꠣꠘꠣ ꠀꠞ ꠀꠎꠛ ꠀꠎꠛ ꠇꠥꠖꠞꠔꠤ ꠟꠤꠟꠣ ꠎꠣꠁꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK21_12","072_21_12","LUK","21","12","12","“ꠅꠁꠟꠦ ꠁꠔꠣ ꠊꠐꠣꠞ ꠀꠉꠦ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠦꠖꠣꠁꠛ, ꠗꠞꠛ। ꠛꠤꠌꠣꠞꠞ ꠟꠣꠉꠤ ꠝꠎꠟꠤꠍꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠛ, ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠛ। ꠀꠝꠣꠞ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣ ꠀꠞ ꠢꠣꠇꠤꠝ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK21_13","072_21_13","LUK","21","13","13","ꠔꠦꠃ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK21_14","072_21_14","LUK","21","14","14","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠇꠤꠔꠣ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ, ꠁꠔꠣ ꠀꠉꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠣꠞ ꠇꠥꠘꠥ ꠎꠞꠥꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK21_15","072_21_15","LUK","21","15","15","ꠇꠣꠞꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃꠟꠣ ꠎꠛꠣꠘ ꠀꠞ ꠢꠦꠇꠝꠔ ꠎꠥꠉꠣꠁꠀ ꠖꠤꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇ ꠅꠇꠟꠦ ꠁꠔꠣ ꠚꠤꠞꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠄꠞ ꠎꠥꠀꠙ ꠖꠤꠛꠣꠞꠅ ꠔꠣꠇ꠆ꠇꠔ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK21_16","072_21_16","LUK","21","16","16","ꠔꠥꠝꠞꠣꠞ ꠝꠣ-ꠛꠣꠚ, ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞ, ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠀꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠤꠛꠣ। ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠁꠟꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK21_17","072_21_17","LUK","21","17","17","ꠀꠞ ꠀꠝꠣꠞ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ꠆ꠇꠟꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK21_18","072_21_18","LUK","21","18","18","ꠅꠁꠟꠦꠅ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠕꠣꠞ ꠄꠇꠍꠣ ꠌꠥꠟꠞꠅ ꠈꠦꠔꠤ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK21_19","072_21_19","LUK","21","19","19","ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠁꠟꠦ, ꠘꠤꠎꠞ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠢꠣꠍꠤꠟ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK21_20","072_21_20","LUK","21","20","20","“ꠔꠥꠝꠞꠣ ꠖꠦꠈꠛꠣꠄ, ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠀꠁꠀ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠕꠘꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞꠦ ꠊꠦꠞꠣꠅ ꠇꠞꠤꠟꠤꠞꠣ, ꠔꠦꠃ ꠛꠥꠎꠤꠟꠤꠅ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠛꠤꠘꠣꠡ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK21_21","072_21_21","LUK","21","21","21","ꠢꠤ ꠡꠝꠄ ꠎꠣꠞꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠕꠣꠇꠛꠣ, ꠔꠣꠞꠣ ꠙꠣꠠꠦꠖꠤ ꠉꠤꠀ ꠜꠣꠉꠃꠇ। ꠎꠣꠞꠣ ꠅꠃ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠕꠣꠇꠛꠣ, ꠔꠣꠞꠣ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠎꠣꠃꠇ। ꠎꠣꠞꠣ ꠉꠣꠃ-ꠉꠦꠞꠣꠝꠅ ꠕꠣꠇꠛꠣ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠐꠣꠃꠘꠅ ꠘꠣ ꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("LK21_22","072_21_22","LUK","21","22","22","ꠇꠣꠞꠘ ꠁ ꠅꠇ꠆ꠔ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠁ ꠉꠎꠛꠞ ꠅꠇ꠆ꠔ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠀꠄꠀꠔ ꠅꠇꠟ ꠙꠥꠞꠣ ꠅꠁꠛꠣꠞ ꠅꠇ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("LK21_23","072_21_23","LUK","21","23","23","ꠁꠡ! ꠁ ꠡꠝꠄ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠙꠦꠐꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠕꠣꠇꠛꠣ, ꠎꠦꠞꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠛꠥꠇꠥꠞ ꠖꠥꠗ ꠈꠣꠅꠀꠁꠛꠣ, ꠄꠞꠣꠞ ꠛꠃꠔ ꠇꠡ꠆ꠐ ꠅꠁꠛ! ꠖꠦꠡꠞ ꠃꠙꠞꠦ ꠛꠦꠎꠥꠁꠔꠣ ꠖꠥꠞ꠆ꠉꠔꠤ, ꠀꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠘꠣꠎꠤꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK21_24","072_21_24","LUK","21","24","24","ꠔꠟꠥꠀꠞꠞ ꠔꠟꠦ ꠔꠣꠞꠣ ꠎꠣꠘ ꠈꠥꠀꠁꠛꠣ, ꠛꠘ꠆ꠖꠤ ꠅꠁꠀ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠎꠣꠁꠛꠣ। ꠅꠃ ꠛꠤꠗꠞ꠆ꠝꠤ ꠎꠣꠔꠤꠞ ꠈꠦꠝꠔꠣꠞ ꠡꠝꠄ ꠙꠥꠞꠣ ꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠁ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK21_25","072_21_25","LUK","21","25","25","“ꠌꠣꠘ-ꠡꠥꠞꠥꠎ ꠀꠞ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣꠘꠣꠘ ꠀꠟꠣꠝꠔ ꠖꠦꠈꠣ ꠎꠣꠁꠛ। ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞ ꠇꠡ꠆ꠐ ꠅꠁꠛ। ꠖꠞꠤꠀꠄ ꠃꠔꠣꠟ-ꠙꠣꠔꠣꠟ ꠇꠞꠛ। ꠓꠦꠃꠞ ꠀꠅꠀꠎꠦ ꠝꠣꠘꠥꠡ ꠛꠦꠖꠤꠡꠣ ꠟꠣꠉꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK21_26","072_21_26","LUK","21","26","26","ꠖꠥꠘꠤꠀꠔ ꠇꠥꠘ ꠖꠡꠣ ꠊꠐꠤꠛ ꠅꠔꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠀ ꠒꠞꠞ ꠌꠥꠐꠦ ꠝꠣꠘꠥꠡ ꠛꠦꠃꠡ ꠅꠁꠎꠤꠛ, ꠀꠍꠝꠣꠘꠤ ꠌꠣꠘ-ꠡꠥꠞꠥꠎ, ꠔꠦꠞꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠀꠃꠟꠣ-ꠎꠣꠃꠟꠣ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LK21_27","072_21_27","LUK","21","27","27","ꠅꠃ ꠡꠝꠄ ꠖꠦꠈꠛꠣꠄ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠡꠇ꠆ꠔꠤ ꠀꠞ ꠘꠥꠞꠞ ꠝꠢꠤꠝꠣꠄ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠔ ꠅꠁꠀ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("LK21_28","072_21_28","LUK","21","28","28","ꠁꠔꠣ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠖꠦꠈꠟꠦ ꠔꠥꠝꠞꠣ ꠝꠎꠛꠥꠔ ꠅꠁꠅ, ꠝꠣꠕꠣ ꠃꠌꠣ ꠇꠞꠤꠅ, ꠛꠥꠎꠤꠟꠤꠅ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠎꠣꠔ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK21_29","072_21_29","LUK","21","29","29","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠝꠤꠍꠣꠟ ꠢꠥꠘꠣꠁꠟꠣ, ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠒꠥꠝꠥꠞ ꠉꠣꠍ ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠉꠣꠍꠣꠁꠘ꠆ꠔꠞ ꠛꠣꠄ ꠖꠦꠈꠅ, ");
INSERT INTO syls_vpl VALUES ("LK21_30","072_21_30","LUK","21","30","30","ꠁꠔꠣꠞ ꠘꠄꠀ ꠇꠥꠠꠤ-ꠙꠣꠔꠣ ꠛꠣꠞꠘꠤ ꠖꠦꠈꠟꠦꠃ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠤꠟꠣꠅ, ꠉꠞꠝꠞ ꠖꠤꠘ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK21_31","072_21_31","LUK","21","31","31","ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠛꠣꠄ, ꠁꠔꠣ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠊꠐꠦꠞ, ꠔꠦ ꠛꠥꠎꠤꠟꠤꠅ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠘꠎꠖꠤꠇ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK21_32","072_21_32","LUK","21","32","32","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠘꠣ ꠊꠐꠣꠞ ꠀꠉꠦ, ꠁ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠥꠡ ꠇ꠆ꠇꠄ ꠅꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK21_33","072_21_33","LUK","21","33","33","ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠇ꠆ꠇꠄ ꠅꠁꠎꠤꠛ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠇ꠆ꠇꠄ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK21_34","072_21_34","LUK","21","34","34","“ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠎꠣꠔꠦ ꠝꠎꠣꠞ ꠝꠎꠣꠞ ꠈꠣꠘꠤ, ꠝꠖ ꠈꠣꠁꠀ ꠐꠣꠟ ꠅꠀ ꠀꠞ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞꠞ ꠘꠦꠡꠣꠄ ꠀꠃꠟꠣ-ꠎꠣꠃꠟꠣ ꠘꠣ ꠅꠅ, ꠀꠞꠘꠣꠄ ꠢꠃ ꠖꠤꠘ ꠀꠁꠀ ꠀꠈꠔꠣꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠚꠣꠘ꠆ꠖꠅ ꠢꠣꠞꠣꠁꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("LK21_35","072_21_35","LUK","21","35","35","ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦꠃ ꠢꠤ ꠖꠤꠘ ꠀꠎꠤꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("LK21_36","072_21_36","LUK","21","36","36","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠢꠎꠣꠉ ꠞꠁꠅ, ꠀꠞ ꠖꠥꠀ ꠇꠞꠤꠅ, ꠎꠣꠔꠦ ꠅꠃ ꠎꠦꠔꠣ ꠎꠣꠁꠞ ꠅꠁꠛ ꠅꠔꠣ ꠙꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠤ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠘꠤꠞ ꠛꠟ ꠙꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK21_37","072_21_37","LUK","21","37","37","ꠁꠍꠣꠄ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠀꠁꠀ ꠘꠍꠤꠅꠔ ꠇꠞꠔꠣ। ꠛꠣꠖꠦ ꠞꠣꠁꠔ ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠛꠣꠞ ꠅꠁꠀ ꠎꠄꠔꠥꠘ ꠙꠣꠠꠅ ꠎꠣꠁꠔꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("LK21_38","072_21_38","LUK","21","38","38","ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠞ ꠘꠤꠅꠔꠦ ꠛꠤꠀꠘ-ꠍꠛꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠀꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_1","072_22_1","LUK","22","1","1","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖ ꠇꠣꠍꠣꠔ ꠀꠁꠟ, ꠅꠃ ꠁꠖꠞ ꠘꠣꠝ ꠀꠎꠣꠖꠤ ꠁꠖ। ");
INSERT INTO syls_vpl VALUES ("LK22_2","072_22_2","LUK","22","2","2","ꠁꠛꠣꠄ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ, ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠀꠝ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠟꠥꠇꠣꠁꠀ ꠇꠤꠟꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠔꠣ। ꠔꠣꠞꠣ ꠀꠝ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠛ ꠒꠞꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_3","072_22_3","LUK","22","3","3","ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ, ꠄꠘ ꠘꠣꠝ ꠁꠢꠥꠖꠣ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔ, ꠄꠘ ꠜꠤꠔꠞꠦ ꠡꠄꠔꠣꠘ ꠢꠣꠝꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK22_4","072_22_4","LUK","22","4","4","ꠄꠁꠘ ꠁꠍꠣꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠟꠥꠇꠣꠁꠀ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠢꠘꠞ ꠖꠣꠞꠉꠣ ꠀꠞ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠟꠉꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ, ꠇꠥꠘ ꠘꠝꠥꠘꠣꠄ ꠁꠍꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠦꠅꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK22_5","072_22_5","LUK","22","5","5","ꠔꠦꠃ ꠁꠝꠣꠝ ꠅꠇꠟ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀ ꠅꠀꠖꠣ ꠇꠞꠟꠣ, ꠔꠣꠘꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠤꠟꠦ ꠔꠣꠞꠦ ꠛꠈꠡꠤꠡ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_6","072_22_6","LUK","22","6","6","ꠄꠔꠦ ꠁꠢꠥꠖꠣꠅ ꠞꠣꠎꠤ ꠅꠁꠀ ꠝꠣꠘꠡꠞ ꠀꠚꠞꠈꠦ, ꠔꠣꠘꠞꠦ ꠗꠞꠣꠁ ꠖꠦꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠔꠥꠇꠣꠘꠤꠔ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK22_7","072_22_7","LUK","22","7","7","ꠛꠣꠖꠦ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠁꠟ, ꠅꠃ ꠁꠖꠞ ꠖꠤꠘ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("LK22_8","072_22_8","LUK","22","8","8","ꠔꠦꠃ ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠉꠤꠀ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠖꠞ ꠈꠣꠘꠤ ꠔꠤꠀꠞ ꠇꠞꠅ, ꠀꠝꠞꠣ ꠢꠇꠟ ꠀꠁꠀ ꠄꠇꠟꠉꠦ ꠈꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK22_9","072_22_9","LUK","22","9","9","ꠄꠞꠣ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠈꠤꠀꠟ ꠇꠤꠔꠣ, ꠀꠝꠞꠣ ꠇꠥꠘꠣꠘꠅ ꠉꠤꠀ ꠈꠣꠘꠣ ꠔꠤꠀꠞ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("LK22_10","072_22_10","LUK","22","10","10","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠖꠦꠈꠛꠣꠄ, ꠄꠇ ꠛꠦꠐꠣꠄ ꠙꠣꠘꠤꠞ ꠈꠂꠟꠣ ꠜꠞꠤꠀ ꠟꠁꠀ ꠎꠣꠁꠞꠣ। ꠔꠥꠝꠞꠣ ꠄꠘ ꠈꠞꠦ ꠈꠞꠦ ꠎꠣꠁꠅ, ꠉꠤꠀ ꠄꠁꠘ ꠎꠦ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("LK22_11","072_22_11","LUK","22","11","11","ꠢꠃ ꠊꠞꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠇꠁꠅ, ‘ꠢꠥꠎꠥꠞꠦ ꠎꠤꠇꠣꠁꠍꠂꠘ, ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠈꠣꠘꠤ ꠎꠦ ꠊꠞꠅ ꠈꠣꠁꠔꠣ, ꠁ ꠝꠥꠍꠣꠚꠤꠞ ꠈꠣꠘꠣ ꠇꠥꠀꠁ?’ ");
INSERT INTO syls_vpl VALUES ("LK22_12","072_22_12","LUK","22","12","12","ꠢꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠙꠞꠞ ꠔꠣꠟꠣꠔ ꠢꠣꠎꠣꠁꠟ-ꠙꠣꠠꠣꠁꠟ ꠛꠠ ꠄꠇ ꠇꠥꠑꠣ ꠖꠦꠈꠣꠁꠀ ꠖꠤꠛ। ꠢꠘꠅ ꠉꠤꠀ ꠔꠥꠝꠞꠣ ꠞꠣꠘ꠆ꠖꠣ-ꠛꠣꠠꠣ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK22_13","072_22_13","LUK","22","13","13","ꠢꠣꠍꠣꠃ ꠔꠣꠞꠣ ꠉꠤꠀ ꠔꠣꠘ ꠇꠕꠣ ꠝꠣꠚꠤꠇ ꠢꠇꠟꠔꠣ ꠙꠣꠁꠟꠣ, ꠙꠣꠁꠀ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠈꠣꠘꠤꠅ ꠔꠤꠀꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_14","072_22_14","LUK","22","14","14","ꠛꠣꠖꠦ ꠡꠝꠄ ꠀꠁꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠟꠁꠀ ꠈꠣꠘꠤꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_15","072_22_15","LUK","22","15","15","ꠛꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠠ ꠈꠤꠀꠟ ꠀꠍꠤꠟ ꠝꠍꠤꠛꠔꠞ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠅꠁꠛꠣꠞ ꠀꠉꠦ, ꠀꠈꠦꠞꠤ ꠁꠖꠞ ꠈꠣꠘꠤ ꠈꠣꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠈꠣꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK22_16","072_22_16","LUK","22","16","16","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠀꠍꠟ ꠝꠞ꠆ꠎꠤ-ꠝꠥꠘꠡꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠢꠣꠍꠤꠟ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠝꠤ ꠀꠞ ꠇꠥꠘꠥ ꠁꠖꠞ ꠈꠣꠘꠤ ꠈꠣꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK22_17","072_22_17","LUK","22","17","17","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠡꠞꠛꠔꠞ ꠙꠤꠀꠟꠣ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅꠃ ꠚꠥꠐꠣꠁꠘ ꠔꠥꠝꠞꠣ ꠛꠣꠐꠤꠀ ꠈꠣꠁꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("LK22_18","072_22_18","LUK","22","18","18","ꠀꠞ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠘꠣ ꠀꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠝꠤ ꠀꠞ ꠀꠋꠉꠥꠞꠞ ꠇꠥꠘꠥ ꠡꠞꠛꠔ ꠈꠣꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK22_19","072_22_19","LUK","22","19","19","ꠄꠞꠛꠣꠖꠦ ꠞꠥꠐꠤ ꠀꠔꠅ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠟꠣ। ꠞꠥꠐꠤ ꠐꠥꠇꠞꠣꠁꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠤꠟꠣ, ꠇꠁꠟꠣ, “ꠝꠘꠅ ꠇꠞꠤꠅ ꠁꠐꠣ ꠀꠝꠣꠞ ꠇꠣꠄꠀ, ꠅꠃ ꠇꠣꠄꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠙꠤ ꠖꠤꠝꠥ। ꠀꠝꠣꠞꠦ ꠝꠘꠅ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤꠔꠣꠁꠘꠅ ꠅꠟꠣ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK22_20","072_22_20","LUK","22","20","20","ꠈꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠡꠞꠛꠔꠞ ꠙꠤꠀꠟꠣ ꠀꠔꠅ ꠟꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠟꠃꠞ ꠎꠞꠤꠀꠄ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠣꠘꠡꠞ ꠝꠤꠟꠘꠞ ꠎꠦ ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣ ꠘꠣꠎꠤꠟ ꠅꠞ, ꠅꠃ ꠙꠤꠀꠟꠣ ꠅꠁꠟ ꠄꠞ ꠘꠤꠡꠣꠘꠣ। ꠀꠝꠣꠞ ꠅꠃ ꠟꠃ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠎꠣꠔꠞ ꠟꠣꠉꠤ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("LK22_21","072_22_21","LUK","22","21","21","ꠔꠦ ꠖꠦꠈꠞꠣꠄ ꠘꠤ! ꠀꠝꠣꠞꠦ ꠎꠦꠉꠤꠄ ꠗꠞꠣꠁꠀ ꠖꠤꠛ, ꠢꠦ ꠅꠈꠘ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠃ ꠖꠡ꠆ꠔꠣꠞꠈꠣꠘꠣꠔ ꠛꠁꠀ ꠈꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("LK22_22","072_22_22","LUK","22","22","22","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠂꠘ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠝꠃꠔ ꠔ ꠅꠟꠣꠃ ꠅꠁꠛ। ꠢꠣꠄꠞꠦ ꠢꠣꠄ! ꠟꠣꠘ꠆ꠘꠔꠤ ꠢꠃ ꠀꠖꠝ, ꠎꠦꠉꠤꠄ ꠀꠝꠣꠞꠦ ꠗꠞꠣꠁꠀ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK22_23","072_22_23","LUK","22","23","23","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘ ꠝꠣꠘꠡꠦ ꠁꠟꠣ ꠇꠣꠝ ꠇꠞꠛ?” ");
INSERT INTO syls_vpl VALUES ("LK22_24","072_22_24","LUK","22","24","24","ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠇꠥꠘ ꠎꠘ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ, ꠅꠔꠣ ꠟꠁꠀ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠟꠣꠉꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK22_25","072_22_25","LUK","22","25","25","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠛꠤꠗꠞ꠆ꠝꠤ ꠖꠦꠡꠞ ꠞꠣꠎꠣ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠙ꠆ꠞꠎꠣꠞ ꠃꠙꠞꠦ ꠝꠥꠘꠤꠛꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠘ। ꠔꠣꠞꠣꠞ ꠎꠝꠤꠖꠣꠞꠞꠦ ꠇꠅꠀ ꠅꠄ ꠎꠘꠉꠘꠞ ꠖꠥꠡ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("LK22_26","072_22_26","LUK","22","26","26","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠁꠟꠣꠘ ꠅꠁꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠁꠘ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ, ꠄꠁꠘ ꠢꠇꠟꠞ ꠢꠥꠞꠥ ꠅꠃꠇ। ꠀꠞ ꠎꠦꠁꠘ ꠘꠦꠔꠣ, ꠄꠁꠘ ꠈꠣꠖꠤꠝꠖꠣꠞꠞ ꠟꠣꠈꠣꠘ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LK22_27","072_22_27","LUK","22","27","27","ꠇꠅ ꠌꠣꠁꠘ ꠇꠥꠘ ꠎꠘ ꠛꠠ? ꠎꠦꠁꠘ ꠈꠣꠘꠣ ꠈꠣꠁꠘ, ꠘꠣ ꠎꠦ ꠈꠣꠖꠤꠝꠖꠣꠞꠤ ꠇꠞꠦ? ꠎꠦꠁꠘ ꠈꠣꠘꠣ ꠈꠣꠁꠘ ꠄꠁꠘꠃ ꠘꠣꠄ ꠘꠤ? ꠔꠦ ꠀꠝꠤ ꠘꠤꠎꠦꠃ ꠔ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠖꠤꠝꠖꠣꠞꠤ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("LK22_28","072_22_28","LUK","22","28","28","“ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠢꠇꠟ ꠛꠣꠟꠣ-ꠝꠍꠤꠛꠔꠅ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK22_29","072_22_29","LUK","22","29","29","ꠀꠞ ꠀꠝꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠉꠖꠤ ꠀꠞ ꠈꠦꠝꠔꠣ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠀꠝꠤꠅ ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠣꠘ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("LK22_30","072_22_30","LUK","22","30","30","ꠅꠃ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠀ, ꠔꠥꠝꠞꠣꠅ ꠀꠝꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠖꠣꠈꠤꠟ ꠅꠁꠀ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠁꠀ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁꠛꠣꠄ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠉꠖꠤꠔ ꠛꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠉꠥꠡ꠆ꠐꠤꠞ ꠛꠤꠌꠣꠞ-ꠀꠖꠣꠟꠔ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK22_31","072_22_31","LUK","22","31","31","“ꠍꠣꠁꠝꠘ, ꠍꠣꠁꠝꠘ, ꠢꠥꠘꠅ, ꠗꠣꠘ-ꠌꠣꠃꠟ ꠎꠦꠟꠣ ꠌꠣꠁꠘꠖꠤ ꠌꠣꠘꠤꠀꠁꠘ, ꠡꠄꠔꠣꠘꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠌꠣꠘꠤꠀꠁꠔ ꠌꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK22_32","072_22_32","LUK","22","32","32","ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠞꠎ ꠇꠞꠍꠤ, ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘ ꠎꠣꠘꠥ ꠇꠝꠎꠥꠞ ꠘꠣ ꠅꠄ। ꠔꠦ ꠔꠥꠝꠤ ꠄꠇꠛꠣꠞ ꠉꠦꠟꠦꠉꠤꠅ ꠔꠃꠛꠣ ꠇꠞꠤꠀ ꠎꠦꠛꠟꠣ ꠚꠤꠞꠔ ꠀꠁꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠅꠃ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠁꠝꠣꠘꠤ ꠛꠟꠅ ꠝꠎꠛꠥꠔ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK22_33","072_22_33","LUK","22","33","33","ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠔ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠦꠟꠅ ꠎꠣꠁꠔꠦ, ꠛꠣ ꠎꠣꠘ ꠖꠤꠔꠦꠅ ꠔꠤꠀꠞ ꠀꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("LK22_34","072_22_34","LUK","22","34","34","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠙꠤꠔꠞ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠁꠎ ꠙꠔꠣꠛꠣꠟꠣ ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠛꠣꠞ ꠀꠉꠦꠃ, ꠔꠥꠝꠤ ꠔꠤꠘ-ꠔꠤꠘꠛꠣꠞ ꠇꠁꠛꠣꠄ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK22_35","072_22_35","LUK","22","35","35","ꠛꠣꠖꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠐꠦꠇꠣꠞ ꠕꠟꠤ, ꠉꠣꠁꠐ-ꠛꠥꠍꠇꠤ ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠖꠤꠀ ꠈꠣꠟꠤ ꠙꠣꠅꠄ ꠙꠣꠑꠣꠁꠍꠟꠣꠝ, ꠢꠤ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘ꠆ꠔꠣꠞ ꠅꠜꠣꠛ ꠅꠁꠍꠤꠟ ꠘꠤ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤ ꠘꠣ, ꠇꠥꠘꠥ ꠅꠜꠣꠛ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK22_36","072_22_36","LUK","22","36","36","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠅꠈꠘ ꠀꠝꠤ ꠇꠁ, ꠅꠈꠘ ꠎꠣꠞ ꠐꠦꠇꠣꠞ ꠕꠟꠤ ꠛꠣ ꠉꠣꠁꠐ-ꠛꠥꠍꠇꠤ ꠀꠍꠦ, ꠢꠦ ꠅꠔꠣ ꠟꠉꠦ ꠞꠣꠈꠃꠇ। ꠎꠣꠞ ꠔꠟꠥꠀꠞ ꠘꠣꠁ, ꠢꠦ ꠔꠣꠞ ꠌꠣꠖ꠆ꠖꠞ ꠛꠦꠌꠤꠀ ꠔꠟꠥꠀꠞ ꠈꠞꠤꠖ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("LK22_37","072_22_37","LUK","22","37","37","ꠙꠣꠇ ꠇꠣꠟꠣꠝꠞ ꠀꠄꠀꠔꠅ ꠔ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠣꠘꠞꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠇꠣꠔꠣꠞꠅ ꠝꠤꠟꠣꠁꠟ ꠅꠁꠛ। ꠁ ꠀꠄꠀꠔ ꠔ ꠀꠝꠣꠞ ꠃꠙꠞ ꠖꠤꠀꠃ ꠚꠟꠤꠛ। ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠔꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠅꠈꠘ ꠚꠟꠤꠎꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK22_38","072_22_38","LUK","22","38","38","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠁꠘꠅ ꠖꠥꠈꠣꠘ ꠔꠟꠥꠀꠞ ꠀꠍꠦ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠔꠣꠃ ꠔ ꠛꠃꠔ।” ");
INSERT INTO syls_vpl VALUES ("LK22_39","072_22_39","LUK","22","39","39","ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠞ ꠛꠣꠖꠦ ꠁꠍꠣ ꠛꠣꠞ ꠅꠁꠀ ꠛꠞꠣꠛꠞꠇꠥꠞ ꠟꠣꠈꠣꠘ ꠢꠃ ꠎꠄꠔꠥꠘ ꠙꠣꠠꠅ ꠉꠦꠟꠣ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠅ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_40","072_22_40","LUK","22","40","40","ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠖꠥꠀ ꠇꠞꠅ, ꠎꠣꠔꠦ ꠇꠥꠘꠥ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠘꠣ ꠙꠠ।” ");
INSERT INTO syls_vpl VALUES ("LK22_41","072_22_41","LUK","22","41","41","ꠇꠁꠀ ꠢꠣꠞꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠌꠣꠁꠞ ꠘꠟ ꠙꠞꠤꠝꠣꠘ ꠖꠥꠞꠁ ꠉꠤꠀ, ꠎꠣꠘꠥ ꠙꠣꠔꠤꠀ ꠖꠥꠀ ꠇꠞꠣꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_42","072_22_42","LUK","22","42","42","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠛꠣ, ꠔꠥꠝꠣꠞ ꠁꠌ꠆ꠍꠣ ꠅꠁꠟꠦ ꠝꠍꠤꠛꠔꠞ ꠁ ꠙꠤꠀꠟꠣꠐꠣ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠢꠞꠣꠁꠟꠣꠅ। ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠁꠌ꠆ꠍꠣꠄ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠁꠌ꠆ꠍꠣꠄꠃ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("LK22_43","072_22_43","LUK","22","43","43","ꠔꠦꠃ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠀ ꠔꠣꠘ ꠛꠟ ꠛꠣꠠꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_44","072_22_44","LUK","22","44","44","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠝꠘꠞ ꠖꠥꠈꠦ ꠙꠦꠞꠦꠡꠣꠘ ꠛꠘꠤꠀ ꠀꠞꠅ ꠇꠣꠔꠞ ꠅꠁꠀ ꠖꠥꠀ ꠇꠞꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠉꠔꠞꠞ ꠊꠣꠝ ꠟꠃꠞ ꠚꠥꠐꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠐꠤꠔ ꠙꠠꠔ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("LK22_45","072_22_45","LUK","22","45","45","ꠖꠥꠀ ꠡꠦꠡ ꠇꠞꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠝꠘꠞ ꠖꠥꠈꠦ ꠇꠣꠔꠞ ꠅꠁꠀ ꠔꠣꠞꠣ ꠊꠥꠝꠣꠁ ꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK22_46","072_22_46","LUK","22","46","46","ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠊꠥꠝꠣꠁꠞꠣꠄ ꠇꠦꠘꠦ? ꠃꠑꠤꠀ ꠖꠥꠀ ꠇꠞꠅ, ꠎꠣꠔꠦ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠘꠣ ꠙꠠ।” ");
INSERT INTO syls_vpl VALUES ("LK22_47","072_22_47","LUK","22","47","47","ꠁꠍꠣ ꠝꠣꠔꠅ ꠞꠁꠍꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠢꠤꠈꠣꠘꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠟꠣ। ꠄꠞꠣꠞ ꠢꠇ꠆ꠇꠟꠞ ꠀꠉꠦ ꠀꠍꠤꠟ ꠁꠢꠥꠖꠣ, ꠢꠦ ꠁꠍꠣꠞ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ। ꠁꠢꠥꠖꠣꠄ ꠔꠣꠘꠞꠦ ꠢꠥꠋꠉꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK22_48","072_22_48","LUK","22","48","48","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁꠢꠥꠖꠣ, ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠢꠥꠋꠉꠣ ꠖꠤꠀ ꠗꠞꠣꠁ ꠖꠤꠞꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK22_49","072_22_49","LUK","22","49","49","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠦꠞꠣ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠛꠥꠎꠤꠟꠤꠟꠣ ꠇꠤꠔꠣ ꠅꠞ। ꠛꠥꠎꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠔꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠔꠟꠥꠀꠞꠖꠤ ꠝꠣꠞꠔꠣꠝ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK22_50","072_22_50","LUK","22","50","50","ꠇꠁꠀꠃ ꠄꠇ ꠍꠣꠢꠣꠛꠤꠄ ꠔꠟꠥꠀꠞꠖꠤ ꠍꠦꠖ ꠝꠣꠞꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠥꠟꠣꠝꠞ ꠒꠣꠁꠘꠞ ꠇꠣꠘ ꠇꠣꠐꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_51","072_22_51","LUK","22","51","51","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠛꠣꠖ ꠖꠦꠅ, ꠀꠞ ꠝꠣꠞꠤꠅ ꠘꠣ।” ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠢꠤ ꠉꠥꠟꠣꠝꠞ ꠇꠣꠘ ꠀꠔꠣꠁ ꠖꠤꠀ ꠔꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_52","072_22_52","LUK","22","52","52","ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠀꠐꠇ ꠇꠞꠣꠔ ꠎꠔ ꠛꠠ ꠁꠝꠣꠝ, ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠖꠣꠞꠉꠣ, ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠀꠁꠍꠟꠣ, ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠝꠣꠘꠡꠦ ꠌꠥꠞ-ꠒꠣꠇꠣꠁꠔ ꠗꠞꠔꠦ ꠎꠦꠟꠣ ꠟꠣꠑꠤ-ꠍꠥꠟꠚꠤ ꠟꠁꠀ ꠎꠣꠁꠘ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠗꠞꠣꠔ ꠅꠃꠟꠣ ꠀꠁꠍ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("LK22_53","072_22_53","LUK","22","53","53","ꠀꠝꠤ ꠔ ꠙꠞꠔꠦꠇ ꠖꠤꠘꠃ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠍꠟꠣꠝ, ꠢꠤ ꠡꠝꠄ ꠀꠝꠣꠞꠦ ꠗꠞꠟꠣꠄ ꠘꠣ ꠇꠦꠘꠦ? ꠅ, ꠅꠈꠘ ꠘꠤꠌꠄ ꠔꠥꠝꠞꠣꠞ ꠡꠝꠄ, ꠀꠘ꠆ꠖꠣꠁꠞꠞ ꠞꠣꠎꠔ꠆ꠔ ꠌꠣꠟꠥ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("LK22_54","072_22_54","LUK","22","54","54","ꠖꠥꠡꠝꠘꠞ ꠖꠟꠦ ꠁꠍꠣꠞꠦ ꠀꠐꠇ ꠇꠞꠤꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠛꠣꠠꠤꠔ ꠟꠁꠀ ꠉꠦꠟꠣꠉꠤ। ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞ ꠖꠥꠞꠁ ꠢꠞꠤ ꠢꠞꠤ ꠁꠍꠣꠞ ꠈꠞꠦ ꠅꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_55","072_22_55","LUK","22","55","55","ꠃꠑꠣꠘꠞ ꠝꠣꠎꠦ ꠛꠣꠇ꠆ꠇꠣ ꠝꠣꠘꠡꠦ ꠀꠉꠥꠁꠘ ꠗꠞꠣꠁꠀ ꠔꠣꠛꠣꠘꠤꠔ ꠟꠣꠉꠟꠣ, ꠙꠤꠔꠞꠅ ꠅꠘꠅ ꠀꠁꠀ ꠡꠞꠤꠇ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_56","072_22_56","LUK","22","56","56","ꠅꠃ ꠡꠝꠄ ꠄꠇ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤꠄ ꠀꠉꠥꠘꠤꠞ ꠚꠞꠞ ꠝꠣꠎꠦ ꠙꠤꠔꠞꠞꠦ ꠖꠦꠈꠤꠀ ꠜꠣꠟꠣ ꠇꠞꠤ ꠌꠣꠁꠀ ꠇꠁꠟ, “ꠅꠃ ꠛꠦꠐꠣꠅ ꠢꠉꠥꠞ ꠟꠉꠦ ꠀꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("LK22_57","072_22_57","LUK","22","57","57","ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣ ꠛꠦꠐꠤ, ꠀꠝꠤ ꠄꠞꠦ ꠌꠤꠘꠤꠃ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK22_58","072_22_58","LUK","22","58","58","ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠀꠞꠇ ꠎꠘꠦ ꠙꠤꠔꠞꠞꠦ ꠖꠦꠈꠤꠀ ꠇꠁꠟ, “ꠔꠥꠝꠤꠅ ꠅꠔꠣꠞ ꠟꠉꠞ ꠄꠇꠎꠘ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠘꠣ ꠛꠣ, ꠀꠝꠤ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK22_59","072_22_59","LUK","22","59","59","ꠀꠞꠅ ꠄꠇꠖ ꠊꠘ꠆ꠐꠣ ꠛꠣꠖꠦ ꠀꠞꠇ ꠎꠘꠦ ꠛꠠ ꠉꠟꠣꠄ ꠇꠁꠟ, “ꠅꠄ, ꠅꠄ, ꠅꠉꠥꠅ ꠄꠞ ꠟꠉꠦ ꠀꠍꠤꠟ, ꠄꠅ ꠔ ꠉꠣꠟꠤꠟꠞ ꠝꠣꠘꠥꠡ।” ");
INSERT INTO syls_vpl VALUES ("LK22_60","072_22_60","LUK","22","60","60","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠖꠥꠞ ꠛꠦꠐꠣ! ꠔꠥꠝꠤ ꠁꠔꠣ ꠇꠤꠔꠣ ꠝꠣꠔꠅ, ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠤ ꠘꠣ।” ꠙꠤꠔꠞꠦ ꠅꠔꠣ ꠇꠁꠞꠣ, ꠄꠞꠝꠣꠎꠦ ꠀꠈꠔꠣꠃ ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠟꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK22_61","072_22_61","LUK","22","61","61","ꠔꠦꠃ ꠁꠍꠣꠄ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠀ ꠙꠤꠔꠞꠞ ꠛꠣꠄ ꠌꠣꠁꠟꠣ। ꠌꠣꠁꠔꠦꠃ ꠙꠤꠔꠞꠞ ꠝꠘꠅ ꠅꠁꠉꠦꠟꠉꠤ, ꠢꠥꠎꠥꠞꠦ ꠔ ꠀꠉꠦꠃ ꠇꠁꠍꠟꠣ, “ꠀꠁꠎ ꠙꠔꠣꠛꠣꠟꠣ ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠛꠣꠞ ꠀꠉꠦꠃ, ꠔꠥꠝꠤ ꠔꠤꠘꠛꠣꠞ ꠇꠁꠛꠣꠄ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK22_62","072_22_62","LUK","22","62","62","ꠔꠦꠃ ꠙꠤꠔꠞ ꠛꠣꠞꠦ ꠉꠤꠀ ꠈꠥꠛ ꠇꠣꠘ꠆ꠖꠘ ꠇꠣꠘ꠆ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK22_63","072_22_63","LUK","22","63","63","ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠀ ꠀꠘꠤꠀ ꠙꠣꠞꠣꠖꠣꠞ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠀꠞ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK22_64","072_22_64","LUK","22","64","64","ꠔꠣꠘ ꠌꠃꠈ ꠛꠣꠘ꠆ꠖꠤꠀ ꠇꠁꠟ, “ꠢꠂ, ꠔꠥꠁ ꠛꠥꠟꠦ ꠘꠛꠤ, ꠔꠦ ꠅꠈꠘ ꠉꠣꠁꠛꠤ ꠇꠅ ꠌꠣꠁꠘ, ꠔꠞꠦ ꠇꠦꠉꠤꠄ ꠝꠣꠞꠟ?” ");
INSERT INTO syls_vpl VALUES ("LK22_65","072_22_65","LUK","22","65","65","ꠅꠃꠟꠣ ꠀꠞꠅ ꠛꠃꠔꠔꠣ ꠇꠁꠀ ꠔꠣꠘꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("LK22_66","072_22_66","LUK","22","66","66","ꠞꠣꠁꠔ ꠙꠥꠀꠘꠤꠞ ꠛꠣꠖꠦ ꠖꠦꠡꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠝꠥꠞꠛ꠆ꠛꠤꠀꠘ, ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠀꠟꠤꠝ ꠅꠇꠟ ꠖꠟꠣ ꠅꠁꠟꠣ, ꠀꠞ ꠁꠍꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK22_67","072_22_67","LUK","22","67","67","“ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ ꠅꠅ, ꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠇꠅ।” ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠇꠁꠟꠦꠅ ꠔ ꠔꠥꠝꠤꠔꠣꠁꠘ ꠄꠇꠤꠘ ꠇꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK22_68","072_22_68","LUK","22","68","68","ꠇꠥꠘ꠆ꠔꠣ ꠎꠤꠇꠣꠁꠟꠦꠅ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK22_69","072_22_69","LUK","22","69","69","ꠅꠁꠟꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠅꠈꠘ ꠕꠣꠇꠤꠃ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘꠞ ꠇꠥꠞꠍꠤꠔ ꠛꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK22_70","072_22_70","LUK","22","70","70","ꠔꠦꠃ ꠢꠇ꠆ꠇꠟꠦ ꠎꠤꠇꠣꠁꠟ, “ꠔꠦ ꠔꠥꠝꠤꠃ ꠇꠤꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠘꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠄ, ꠔꠥꠝꠤꠔꠣꠁꠘꠃ ꠔ ꠇꠁꠞꠣꠄ, ꠀꠝꠤꠃ ꠢꠦꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("LK22_71","072_22_71","LUK","22","71","71","ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠦ ꠇꠁꠟ, “ꠔꠦ ꠀꠞ ꠡꠣꠄ-ꠡꠣꠇ꠆ꠇꠤꠖꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠄ? ꠀꠝꠞꠣ ꠘꠤꠎꠞ ꠇꠣꠘꠦꠃ ꠔ ꠔꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠢꠥꠘꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK23_1","072_23_1","LUK","23","1","1","ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠄꠇꠟꠉꠦ ꠖꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠞꠥꠝꠣꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_2","072_23_2","LUK","23","2","2","ꠉꠤꠀ ꠁꠍꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠖꠦꠈꠍꠤ, ꠅꠃ ꠛꠦꠐꠣꠄ ꠀꠝꠞꠣꠞ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠉꠠꠣꠁ ꠖꠦꠞ, ꠢꠦ ꠝꠣꠘꠡꠞꠦ ꠘꠤꠡꠦꠗ ꠇꠞꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞꠦ ꠈꠣꠎꠘꠣ ꠖꠤꠔꠣ ꠘꠣ। ꠢꠦ ꠘꠤꠎꠦꠃ ꠛꠥꠟꠦ ꠀꠟ-ꠝꠍꠤ ꠘꠣꠝꠞ ꠄꠇ ꠛꠣꠖꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK23_3","072_23_3","LUK","23","3","3","ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠘꠤ?” ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠦ ꠎꠦꠟꠣ ꠇꠂꠘ, ꠅꠟꠣꠃ।” ");
INSERT INTO syls_vpl VALUES ("LK23_4","072_23_4","LUK","23","4","4","ꠔꠦꠃ ꠙꠤꠟꠣꠔꠦ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠁ ꠀꠡꠣꠝꠤꠞ ꠇꠥꠘꠥ ꠖꠥꠡꠃ ꠙꠣꠁꠞꠣꠝ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK23_5","072_23_5","LUK","23","5","5","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠎꠤꠖ ꠇꠞꠤꠀ ꠇꠁꠟ, “ꠁ ꠛꠦꠐꠣꠄ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣ ꠕꠣꠇꠤ ꠀꠞꠝ꠆ꠛ ꠇꠞꠤꠀ ꠀꠡ꠆ꠔꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠉꠠꠣꠁꠀ, ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠅꠘꠅ ꠀꠁꠀꠅ ꠢꠇ꠆ꠇꠟꠞꠦ ꠛꠤꠉꠠꠣꠁꠟꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("LK23_6","072_23_6","LUK","23","6","6","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠙꠤꠟꠣꠔꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠦ ꠇꠤꠔꠣ ꠉꠣꠟꠤꠟꠞ ꠝꠣꠘꠥꠡ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK23_7","072_23_7","LUK","23","7","7","ꠢꠣꠇꠤꠝꠦ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣ, ꠁꠍꠣꠞ ꠛꠣꠠꠤ ꠅꠁꠟ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠅꠗꠤꠘꠞ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ, ꠢꠥꠘꠤꠀ ꠔꠣꠁꠘ ꠁꠍꠣꠞꠦ ꠢꠦꠞꠥꠖꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ, ꠇꠣꠞꠘ ꠢꠦꠞꠥꠖꠅ ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_8","072_23_8","LUK","23","8","8","ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠢꠦꠞꠥꠖ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ꠔꠣꠁꠘ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠔꠣ ꠌꠣꠁꠞꠣ। ꠀꠉꠦ ꠔꠣꠁꠘ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠃꠔꠔꠣ ꠢꠥꠘꠍꠤꠟꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠝꠘꠞ ꠀꠡꠣ ꠀꠍꠤꠟ, ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠥꠘꠥ ꠇꠦꠞꠣꠝꠔꠤ-ꠝꠥꠎꠦꠎꠣ ꠖꠦꠈꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_9","072_23_9","LUK","23","9","9","ꠔꠣꠁꠘ ꠁꠍꠣꠞꠦ ꠛꠃꠔ ꠘꠝꠥꠘꠣꠞ ꠙ꠆ꠞꠡꠘ ꠇꠞꠟꠣ, ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_10","072_23_10","LUK","23","10","10","ꠀꠖꠣꠟꠔꠅ ꠃꠛꠣꠁꠀꠅ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟꠦ ꠈꠥꠛ ꠉꠞꠝ ꠅꠁꠀ ꠁꠍꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠘꠣꠟꠤꠡ ꠢꠥꠘꠣꠘꠤꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_11","072_23_11","LUK","23","11","11","ꠄꠞꠟꠉꠦ ꠢꠦꠞꠥꠖꠦ ꠀꠞ ꠔꠣꠘ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦꠅ ꠁꠍꠣꠞꠦ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ, ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠟꠣ, ꠢꠦꠡ-ꠝꠦꠡ ꠔꠣꠘꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠌꠇꠌꠇꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠣꠁꠀ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_12","072_23_12","LUK","23","12","12","ꠄꠞ ꠀꠉꠦ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖ ꠀꠞ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠝꠣꠎꠦ ꠖꠥꠡꠝꠘꠤ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠅꠃ ꠖꠤꠘ ꠕꠣꠇꠤꠃ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠖꠥꠡ꠆ꠔꠤ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK23_13","072_23_13","LUK","23","13","13","ꠛꠣꠖꠦ ꠙꠤꠟꠣꠔꠦ ꠛꠠ ꠁꠝꠣꠝ, ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ, ꠀꠞ ꠀꠝ ꠝꠣꠘꠡꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("LK23_14","072_23_14","LUK","23","14","14","ꠇꠁꠟꠣ, “ꠅꠃ ꠀꠡꠣꠝꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠗꠞꠤꠀ ꠀꠘꠤꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠟꠣꠄ, ꠢꠦ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠉꠠꠣꠁꠟꠣꠞ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦꠃ ꠔꠣꠞꠦ ꠎꠦꠞꠣ ꠇꠞꠟꠣꠝ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠘꠣꠟꠤꠡ ꠖꠤꠍ, ꠔꠣꠞ ꠝꠣꠎꠦ ꠔ ꠁꠟꠣ ꠇꠥꠘꠥ ꠖꠥꠡꠃ ꠙꠣꠁꠟꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_15","072_23_15","LUK","23","15","15","ꠀꠞ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠦꠅ ꠘꠤꠌꠄ ꠔꠣꠞ ꠇꠥꠘꠥ ꠖꠥꠡ ꠙꠣꠁꠍꠂꠘ ꠘꠣ, ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠁꠘ ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠔ ꠙꠣꠑꠣꠁꠍꠂꠘ। ꠀꠝꠤ ꠖꠦꠈꠞꠣꠝ, ꠝꠃꠔꠞ ꠡꠣꠎꠣꠞ ꠎꠥꠇꠣ ꠇꠥꠘꠥ ꠖꠥꠡꠃ ꠢꠦ ꠇꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_16","072_23_16","LUK","23","16","16","ꠔꠦ ꠀꠝꠤ ꠔꠣꠞꠦ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠤꠀ ꠍꠣꠠꠤ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK23_17","072_23_17","LUK","23","17","17","ꠀꠍꠟꠦ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠞꠦꠅꠀꠎꠅ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠅꠇ꠆ꠔꠅ ꠄꠇꠎꠘ ꠇꠄꠅꠖꠤꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_18","072_23_18","LUK","23","18","18","ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠄꠇꠟꠉꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠘꠣ, ꠘꠣ, ꠅꠉꠥꠞꠦ ꠝꠣꠞꠤꠟꠣꠅ। ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK23_19","072_23_19","LUK","23","19","19","ꠅꠃ ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞꠦ ꠀꠉꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠢꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠈꠥꠘ ꠀꠞ ꠡꠘꠔ꠆ꠞꠣꠡ ꠇꠞꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("LK23_20","072_23_20","LUK","23","20","20","ꠅꠁꠟꠦ ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅꠀꠞ ꠘꠤꠅꠔꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_21","072_23_21","LUK","23","21","21","ꠔꠣ-ꠅ ꠔꠣꠞꠣ ꠄꠇꠟꠉꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠃꠑꠟ, “ꠅꠉꠥꠞꠦ ꠍꠟꠤꠛꠅ ꠖꠦꠅ, ꠍꠟꠤꠛꠅ ꠖꠦꠅ।” (ꠍꠟꠤꠛ ꠅꠁꠟ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠝꠣꠘꠡꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣꠞ ꠄꠇ ꠎꠤꠘꠤꠡ।) ");
INSERT INTO syls_vpl VALUES ("LK23_22","072_23_22","LUK","23","22","22","ꠙꠤꠟꠣꠔꠦ ꠔꠤꠘ-ꠔꠤꠘꠛꠣꠞ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠦꠘꠦ? ꠁ ꠀꠡꠣꠝꠤꠄ ꠇꠤꠔꠣ ꠖꠥꠡ ꠇꠞꠍꠦ? ꠝꠃꠔꠞ ꠡꠣꠎꠣꠞ ꠎꠥꠇꠣ ꠔꠣꠞ ꠇꠥꠘꠥ ꠖꠥꠡꠃ ꠀꠝꠤ ꠙꠣꠁꠞꠣꠝ ꠘꠣ। ꠀꠝꠤ ꠈꠣꠟꠤ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠤꠀ ꠔꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK23_23","072_23_23","LUK","23","23","23","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠝꠣꠁꠞꠝꠥꠈꠤ ꠅꠁꠀ, ꠌꠤꠟ꠆ꠟꠣꠁꠀ, ꠝꠤꠍꠤꠟ ꠟꠣꠉꠣꠁꠟꠣ, “ꠅꠉꠥꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠅ, ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠅ।” ꠌꠤꠟ꠆ꠟꠣꠘꠤꠞ ꠌꠥꠐꠦ ꠔꠣꠞꠣꠞ ꠖꠣꠛꠤ ꠙꠥꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK23_24","072_23_24","LUK","23","24","24","ꠔꠣꠞꠣꠞ ꠖꠣꠛꠤ ꠝꠣꠚꠤꠇꠃ ꠙꠤꠟꠣꠔꠦ ꠞꠣꠄ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_25","072_23_25","LUK","23","25","25","ꠔꠣꠁꠘ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠛꠖ ꠈꠣꠁꠡ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠍꠣꠠꠤ ꠖꠤꠟꠣ ꠀꠞ ꠢꠃ ꠈꠥꠘꠤ-ꠡꠘꠔ꠆ꠞꠣꠡꠤꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_26","072_23_26","LUK","23","26","26","ꠢꠣꠇꠤꠝꠞ ꠞꠣꠄ ꠙꠣꠁꠀ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠇꠞꠤ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠎꠣꠁꠞꠣ। ꠅꠃ ꠡꠝꠄ ꠍꠣꠁꠝꠘ ꠘꠣꠝꠞ ꠇꠥꠞꠤꠘꠤ ꠄꠟꠣꠇꠣꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠉꠣꠃ ꠕꠣꠇꠤ ꠐꠣꠃꠘꠅ ꠀꠅꠀꠔ ꠀꠍꠤꠟ। ꠔꠣꠞꠣ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠗꠞꠤꠀ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠍꠟꠤꠛ ꠔꠣꠞ ꠇꠣꠘ꠆ꠖꠅ ꠔꠥꠟꠤꠀ ꠖꠤꠀ ꠇꠁꠟ, ꠢꠦ ꠅꠉꠥ ꠟꠁꠀ ꠁꠍꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠎꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("LK23_27","072_23_27","LUK","23","27","27","ꠁꠍꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠍꠤꠟ, ꠄꠞꠣꠞ ꠟꠉꠦ ꠛꠃꠔ ꠛꠦꠐꠤꠘꠅ ꠀꠍꠟꠣ। ꠔꠣꠞꠣ ꠔꠣꠘ ꠟꠣꠉꠤ ꠛꠤꠟꠣꠙ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠤꠀ ꠛꠥꠇꠥꠔ ꠕꠣꠛꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠘ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_28","072_23_28","LUK","23","28","28","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠝꠣꠁ ꠅꠇꠟ, ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠀꠞ ꠘꠤꠎꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠅ। ");
INSERT INTO syls_vpl VALUES ("LK23_29","072_23_29","LUK","23","29","29","ꠢꠥꠘꠅ, ꠅꠝꠘ ꠄꠇ ꠖꠤꠘ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠝꠣꠘꠡꠦ ꠇꠁꠛꠣ ꠀꠐꠇꠥꠞꠣ ꠛꠦꠐꠤꠘꠃ ꠛꠠ ꠇꠙꠣꠟꠤ। ꠎꠦꠞꠣꠞ ꠇꠥꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠃ ꠅꠁꠍꠦ ꠘꠣ, ꠛꠥꠇꠞ ꠖꠥꠗꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠈꠣꠅꠀꠁꠍꠦ ꠘꠣ, ꠔꠣꠞꠣꠃ ꠇꠙꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("LK23_30","072_23_30","LUK","23","30","30","ꠢꠤ ꠡꠝꠄ ꠝꠣꠘꠡꠦ ꠛꠠ ꠛꠠ ꠙꠣꠠꠞꠦ ꠇꠁꠛ, ꠔꠥꠝꠞꠣ ꠀꠁꠀ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠙꠠꠅ। ꠙꠣꠠꠞ ꠐꠤꠟ꠆ꠟꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠛ, ꠀꠝꠞꠣꠞꠦ ꠟꠥꠇꠣꠁꠀ ꠞꠣꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("LK23_31","072_23_31","LUK","23","31","31","ꠔꠥꠝꠞꠣ ꠖꠦꠈꠞꠣꠄ ꠘꠣ ꠘꠤ, ꠔꠣꠎꠣ ꠉꠣꠍꠞꠦꠃ ꠁꠔꠣꠄ ꠅꠃ ꠢꠣꠟꠔ ꠇꠞꠞꠣ, ꠔꠦ ꠢꠥꠇꠘꠣ ꠉꠣꠍꠞ ꠇꠥꠘ ꠖꠡꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK23_32","072_23_32","LUK","23","32","32","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠉꠦ ꠇꠞꠤ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠖꠥꠁꠎꠘ ꠖꠣꠉꠤ ꠀꠡꠣꠝꠤꠞꠦ ꠟꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK23_33","072_23_33","LUK","23","33","33","ꠛꠣꠖꠦ ꠝꠣꠕꠣꠞ-ꠈꠥꠟꠤ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠀꠘꠤꠀ, ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠀꠞ ꠢꠃ ꠖꠥꠁꠅ ꠖꠣꠉꠤ ꠀꠡꠣꠝꠤꠞꠦ ꠉꠣꠍꠞ ꠐꠥꠇꠞꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠟ, ꠄꠇꠎꠘꠞꠦ ꠔꠣꠘ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ, ꠀꠞꠇ ꠎꠘꠞꠦ ꠛꠣꠃ ꠉꠣꠟꠣꠔ ꠟꠐꠇꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK23_34","072_23_34","LUK","23","34","34","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ, ꠄꠞꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠅ। ꠔꠣꠞꠣ ꠔ ꠛꠥꠎꠦꠞ ꠘꠣ ꠔꠣꠞꠣ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠦꠞ।” ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠔꠣꠘ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠘꠤꠔꠣ ꠇꠞꠤ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠛꠣꠐꠣ-ꠛꠣꠐꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_35","072_23_35","LUK","23","35","35","ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠃꠛꠣꠁꠀ ꠁꠔꠣ ꠖꠦꠈꠟꠣ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠐꠤꠐꠇꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠇꠁꠟꠣ, “ꠢꠦ ꠔ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔ, ꠢꠦ ꠎꠥꠖꠤ ꠢꠣꠍꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ ꠅꠄ, ꠔꠦ ꠅꠈꠘ ꠔꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠘꠅ ꠛꠣꠌꠣꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("LK23_36","072_23_36","LUK","23","36","36","ꠞꠥꠝꠣꠘ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦꠅ ꠔꠣꠘꠞꠦ ꠟꠁꠀ ꠝꠡꠇꠣꠞꠤ ꠇꠞꠟ, ꠔꠣꠞꠣ ꠐꠦꠋꠉꠣ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠟꠁꠀ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK23_37","072_23_37","LUK","23","37","37","“ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠢꠣꠍꠣꠞꠞ ꠛꠣꠖꠡꠣ ꠅꠅ, ꠔꠦ ꠅꠈꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK23_38","072_23_38","LUK","23","38","38","ꠔꠣꠘ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠦ ꠄꠇꠈꠣꠘ ꠡꠣꠁꠘꠛꠞ꠆ꠒ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ, ꠢꠘꠅ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, “ꠢꠦ ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK23_39","072_23_39","LUK","23","39","39","ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠟꠉꠦ ꠀꠞꠅ ꠎꠦ ꠖꠥꠁꠎꠘ ꠀꠡꠣꠝꠤꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠅꠔꠣ ꠄꠇꠎꠘꠦ ꠔꠣꠘꠞꠦ ꠐꠤꠐꠇꠣꠞꠤ ꠝꠣꠞꠤꠀ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠛꠥꠟꠦ ꠢꠃ ꠀꠟ-ꠝꠍꠤ? ꠔꠦ ꠅꠈꠘ ꠀꠝꠞꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞꠦꠅ ꠛꠣꠌꠣꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK23_40","072_23_40","LUK","23","40","40","ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠖꠥꠍꠞꠣ ꠎꠘꠦ ꠄꠞꠦ ꠗꠣꠝꠇꠤ ꠖꠤꠀ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠀꠟ꠆ꠟꠣꠞꠦꠅ ꠒꠞꠣꠅ ꠘꠣ ꠘꠤ? ꠔꠥꠝꠤꠅ ꠔ ꠅꠃ ꠢꠝꠣꠘ ꠡꠣꠎꠣ ꠙꠣꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("LK23_41","072_23_41","LUK","23","41","41","ꠀꠞ ꠀꠝꠞꠣ ꠔ ꠙꠣꠁꠞꠣꠝ ꠀꠝꠞꠣꠞ ꠃꠌꠤꠔ ꠡꠣꠎꠣ, ꠀꠝꠞꠣ ꠎꠦꠟꠣꠘ ꠇꠣꠝ ꠇꠞꠍꠤ ꠅꠃꠟꠣꠘ ꠙꠣꠁꠞꠣꠝ। ꠅꠁꠟꠦ ꠄꠁꠘ ꠔ ꠇꠥꠘꠥ ꠖꠥꠡꠃ ꠇꠞꠍꠂꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK23_42","072_23_42","LUK","23","42","42","ꠛꠣꠖꠦ ꠢꠦ ꠇꠁꠟ, “ꠅ ꠁꠍꠣ, ꠀꠙꠘꠦ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠎꠦꠛꠟꠣ ꠘꠤꠎꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠈꠣꠘꠅ ꠀꠝꠣꠞꠦ ꠁꠀꠖ ꠞꠣꠈꠂꠘ ꠎꠣꠘꠥ।” ");
INSERT INTO syls_vpl VALUES ("LK23_43","072_23_43","LUK","23","43","43","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠀꠁꠎ ꠕꠣꠇꠤꠃ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠕꠣꠇꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("LK23_44","072_23_44","LUK","23","44","44","ꠅꠃ ꠡꠝꠄ ꠛꠦꠁꠟ ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁꠚꠞ, ꠄꠞꠛꠣꠖ ꠕꠣꠇꠤ ꠎꠥꠢꠞꠞ ꠛꠣꠖ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠤꠘ ꠊꠘ꠆ꠐꠣ ꠗꠞꠤ ꠀꠡ꠆ꠔꠣ ꠖꠦꠡ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK23_45","072_23_45","LUK","23","45","45","ꠡꠥꠞꠥꠎꠞ ꠚꠞ ꠘꠤꠜꠤꠉꠦꠟ। ꠄꠞꠝꠣꠎꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠇꠣꠛꠣ ꠊꠞꠞ ꠙꠛꠤꠔ꠆ꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠙꠞ꠆ꠖꠣꠈꠣꠘ, ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠔꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠍꠤꠠꠤꠀ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK23_46","072_23_46","LUK","23","46","46","ꠢꠦꠡꠦ ꠁꠍꠣꠄ ꠎꠥꠞꠦ ꠀꠅꠀꠎ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠛꠣꠛꠣ, ꠀꠝꠣꠞ ꠞꠥꠢꠥ ꠔꠥꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠤꠟꠣꠁꠟꠣꠝ।” ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠀꠈꠦꠞꠤ ꠖꠝ ꠚꠣꠟꠣꠁꠀ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_47","072_23_47","LUK","23","47","47","ꠞꠥꠝꠣꠘ ꠍꠤꠙꠣꠁꠞ ꠎꠦ ꠛꠠ ꠅꠚꠤꠡꠣꠞ ꠢꠘꠅ ꠙꠣꠞꠣ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ, ꠄꠁꠘ ꠁꠍꠣꠞ ꠝꠃꠔꠞ ꠁ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠘꠤꠌ꠆ꠌꠄ, ꠁ ꠛꠦꠌꠣꠠꠣ ꠈꠣꠐꠤ ꠖꠤꠘꠖꠣꠞ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("LK23_48","072_23_48","LUK","23","48","48","ꠀꠞ ꠁꠔꠣ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠎꠔ ꠝꠣꠘꠥꠡ ꠖꠟꠣ ꠅꠁꠍꠟꠣ, ꠔꠣꠞꠣꠅ ꠁ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠛꠥꠇꠥꠔ ꠝꠣꠞꠤ ꠝꠣꠞꠤ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠤꠀ ꠚꠤꠞꠤꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_49","072_23_49","LUK","23","49","49","ꠁꠍꠣꠞ ꠙꠞꠤꠌꠤꠔ ꠎꠘ ꠅꠇꠟꠦ, ꠀꠞ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ ꠔꠣꠘ ꠟꠉꠦ ꠅꠁꠀ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠦ ꠖꠥꠞꠁ ꠃꠛꠣꠁꠀ ꠁꠔꠣ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_50","072_23_50","LUK","23","50","51","ꠖꠦꠡꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠄꠇꠎꠘ ꠁꠎ꠆ꠎꠔꠤ ꠝꠦꠝ꠆ꠛꠣꠞ ꠀꠍꠟꠣ, ꠄꠘ ꠘꠣꠝ ꠁꠃꠍꠥꠚ, ꠄꠘ ꠛꠣꠠꠤ ꠀꠞꠤꠝꠣꠕꠤꠀ ꠉꠣꠃꠔ। ꠄꠁꠘ ꠔ ꠙꠞꠦꠎꠉꠣꠞ ꠀꠞ ꠢꠇ ꠝꠣꠘꠥꠡ, ꠁꠍꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠅꠃ ꠇꠥ-ꠗꠣꠘ꠆ꠖꠣꠔ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠣꠎꠤ ꠅꠁꠟꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_52","072_23_52","LUK","23","52","52","ꠅꠃ ꠁꠃꠍꠥꠚ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠁꠍꠣꠞ ꠟꠣꠡ ꠘꠤꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_53","072_23_53","LUK","23","53","53","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠣꠡ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠣꠁꠀ, ꠇꠣꠚꠘ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ, ꠀꠞ ꠙꠣꠔ꠆ꠔꠞ ꠈꠥꠖꠤꠀ ꠛꠣꠘꠣꠁꠟ ꠅꠃꠟꠣ ꠄꠇ ꠇꠄꠛꠞꠞ ꠝꠣꠎꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ, ꠁ ꠇꠄꠛꠞꠅ ꠇꠥꠘꠥꠖꠤꠘ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_54","072_23_54","LUK","23","54","54","ꠁ ꠖꠤꠘ ꠀꠍꠤꠟ ꠁꠢꠥꠖꠤꠞ ꠎꠥꠝ꠆ꠝꠣꠞ ꠀꠉꠞ ꠖꠤꠘ, ꠕꠥꠠꠣ ꠛꠣꠖꠦꠃ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ ꠡꠥꠞꠥ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("LK23_55","072_23_55","LUK","23","55","55","ꠀꠞ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ ꠉꠣꠟꠤꠟ ꠕꠣꠇꠤ ꠁꠍꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠁꠃꠍꠥꠚꠞ ꠈꠞꠦ ꠈꠞꠦ ꠉꠤꠀ ꠢꠃ ꠇꠄꠛꠞ ꠖꠦꠈꠟꠣ, ꠀꠞ ꠇꠤꠟꠣꠈꠣꠘ ꠔꠣꠘ ꠟꠣꠡ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠟ ꠄꠅꠔꠣ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK23_56","072_23_56","LUK","23","56","56","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠚꠤꠞꠤꠀ ꠉꠤꠀ ꠢꠣꠞꠤ ꠀꠔꠞ-ꠉꠥꠟꠣꠙ ꠀꠞ ꠌꠘ꠆ꠖꠘ-ꠝꠟꠝ ꠛꠣꠘꠣꠁꠟꠣ, ꠢꠦꠡꠦ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠎꠥꠝ꠆ꠝꠣꠞ ꠖꠤꠘ ꠎꠤꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_1","072_24_1","LUK","24","1","1","ꠅꠃ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠎꠦꠔꠣ ꠀꠔꠞ-ꠉꠥꠟꠣꠙ ꠔꠤꠀꠞ ꠇꠞꠍꠟꠣ, ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠈꠥꠛ ꠍꠛꠞꠦ ꠔꠣꠞꠣ ꠅꠔꠣ ꠟꠁꠀ, ꠁꠍꠣꠞ ꠇꠄꠛꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_2","072_24_2","LUK","24","2","2","ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠇꠄꠛꠞꠞ ꠝꠥꠈꠞ ꠙꠣꠔ꠆ꠔꠞꠈꠣꠘ ꠢꠞꠣꠁꠟ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK24_3","072_24_3","LUK","24","3","3","ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠇꠄꠛꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠖꠦꠈꠂꠘ, ꠁꠍꠣꠞ ꠟꠣꠡ ꠔ ꠇꠄꠛꠞꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("LK24_4","072_24_4","LUK","24","4","4","ꠔꠦꠃ ꠔꠣꠞꠣ ꠌꠤꠘ꠆ꠔꠣꠔ ꠙꠠꠤꠉꠦꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠗꠟꠣ ꠌꠇꠌꠇꠣ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠘ ꠖꠥꠁꠎꠘ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠃꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_5","072_24_5","LUK","24","5","5","ꠄꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠒꠞꠣꠁꠀ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠟꠤꠟꠣ। ꠅꠃ ꠖꠥꠁꠅꠎꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠉ, ꠔꠥꠝꠤꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣꠞꠦ ꠇꠦꠘꠦ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠀꠁꠀ ꠔꠥꠇꠣꠁꠞꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("LK24_6","072_24_6","LUK","24","6","6","ꠔꠣꠁꠘ ꠔ ꠅꠘꠅ ꠘꠣꠁ, ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠉꠦꠍꠂꠘ। ꠔꠣꠁꠘ ꠉꠣꠟꠤꠟꠅ ꠕꠣꠇꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠤꠔꠣ ꠇꠁꠍꠟꠣ, ꠝꠘꠅ ꠇꠞꠤꠀ ꠖꠦꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("LK24_7","072_24_7","LUK","24","7","7","ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ ꠘꠣ ꠘꠤ, ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠝꠣꠘꠡꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ। ꠔꠣꠘꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠛ, ꠅꠁꠟꠦ ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("LK24_8","072_24_8","LUK","24","8","8","ꠅꠈꠣꠘ ꠢꠥꠘꠔꠦꠃ ꠁꠍꠣꠞ ꠀꠉꠞ ꠇꠕꠣ ꠅꠇꠟ ꠔꠣꠞꠣꠞ ꠝꠘꠅ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("LK24_9","072_24_9","LUK","24","9","9","ꠔꠣꠞꠣ ꠇꠛꠞꠡ꠆ꠕꠣꠘ ꠕꠣꠇꠤ ꠚꠤꠞꠤꠀ ꠉꠤꠀ, ꠢꠃ ꠄꠉꠣꠞꠅ ꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_10","072_24_10","LUK","24","10","10","ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ, ꠁꠃꠢꠣꠘ꠆ꠘꠣ, ꠁꠀꠇꠥꠛꠞ ꠝꠣ ꠝꠞꠤꠅꠝ ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠦꠔꠣ ꠛꠦꠐꠤꠘ ꠀꠍꠟꠣ, ꠄꠞꠣ ꠢꠇꠟꠦ ꠉꠤꠀ ꠁ ꠈꠛꠞ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_11","072_24_11","LUK","24","11","11","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠁꠔꠣ ꠢꠥꠘꠟꠣ, ꠄꠞꠣ ꠝꠘꠅ ꠇꠞꠟꠣ ꠁꠔꠣ ꠘꠤꠌꠄ ꠛꠣꠎꠦ ꠝꠣꠔ, ꠁꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠔ ꠔꠣꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_12","072_24_12","LUK","24","12","12","ꠅꠁꠟꠦ ꠙꠤꠔꠞ ꠖꠃꠠꠣꠁꠀ ꠇꠄꠛꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠃꠘ꠆ꠖꠣ ꠅꠁꠀ ꠖꠦꠈꠟꠣ, ꠈꠣꠟꠤ ꠇꠣꠚꠘꠈꠣꠘ ꠙꠠꠤ ꠞꠁꠍꠦ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠀ ꠚꠤꠞꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_13","072_24_13","LUK","24","13","13","ꠅꠃ ꠖꠤꠘꠃ ꠖꠥꠁꠎꠘ ꠡꠣꠉꠞꠤꠖ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠡꠣꠔ ꠝꠣꠁꠟ ꠖꠥꠞꠁ ꠁꠝꠥꠀꠍ ꠘꠣꠝꠞ ꠄꠇ ꠉꠣꠃꠔ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_14","072_24_14","LUK","24","14","14","ꠙꠕꠅ ꠔꠣꠞꠣ ꠅꠔꠣ ꠛꠦꠙꠣꠞ ꠅꠇꠟ ꠟꠁꠀꠃ ꠝꠣꠔꠤ ꠝꠣꠔꠤ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_15","072_24_15","LUK","24","15","15","ꠔꠣꠞꠣ ꠝꠣꠔꠅ ꠞꠁꠍꠂꠘ ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠁꠍꠣ ꠘꠤꠎꠦ ꠔꠣꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠄꠇꠟꠉꠦ ꠀꠐꠣ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_16","072_24_16","LUK","24","16","16","ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠌꠈꠥꠔ ꠍꠣꠐꠣ ꠟꠣꠉꠤ ꠉꠦꠍꠤꠟ, ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀꠅ ꠌꠤꠘꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_17","072_24_17","LUK","24","17","17","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠐꠤ ꠀꠐꠤ ꠀꠙꠘꠣꠞꠣ ꠁꠔꠣ ꠇꠤꠔꠣꠞ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠞꠣ?” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠄꠞꠣ ꠝꠥꠈ ꠛꠦꠎꠣꠞ ꠇꠞꠤ ꠃꠛꠣꠁ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_18","072_24_18","LUK","24","18","18","ꠄꠞꠝꠣꠎꠦ ꠇꠤꠟꠤꠅꠚꠣꠍ ꠘꠣꠝꠦ ꠄꠇꠎꠘꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦꠃ ꠄꠇꠝꠣꠔ꠆ꠞ ꠎꠘ, ꠎꠦꠁꠘ ꠢꠥꠘꠍꠂꠘ ꠘꠣ ꠁ ꠇꠄꠖꠤꠘꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠇꠤꠔꠣ ꠊꠐꠤꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("LK24_19","072_24_19","LUK","24","19","19","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠊꠐꠤꠍꠦ ꠛꠣ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠎꠔꠔꠣ ꠊꠐꠤꠍꠦ। ꠔꠣꠁꠘ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠘꠛꠤ, ꠔꠣꠘ ꠝꠥꠈꠞ ꠎꠛꠣꠘ ꠀꠞ ꠇꠣꠝꠦ-ꠇꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠌꠈꠥꠔꠅ ꠈꠥꠛ ꠔꠣꠇ꠆ꠇꠔꠤ ꠀꠞ ꠝꠞꠔꠥꠛꠣꠀꠟꠣ ꠘꠛꠤ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_20","072_24_20","LUK","24","20","20","ꠀꠝꠞꠣꠞ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠞꠥꠝꠣꠘ ꠅꠇꠟꠞ ꠀꠔꠅ ꠗꠞꠣꠁꠀ ꠖꠤꠟꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠘꠤꠀ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK24_21","072_24_21","LUK","24","21","21","ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠀꠡꠣ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠛꠣ। ꠀꠁꠎ ꠔꠤꠘ ꠖꠤꠘ ꠅꠁꠟ ꠁ ꠊꠐꠘꠣ ꠊꠐꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK24_22","072_24_22","LUK","24","22","22","ꠀꠞ ꠀꠝꠞꠣꠞ ꠟꠉꠞ ꠇꠄꠎꠘ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠦ ꠀꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠣꠘꠣꠁꠟꠤꠍꠂꠘ। ꠔꠣꠞꠣ ꠈꠥꠛ ꠍꠛꠞꠦ ꠁꠍꠣꠞ ꠇꠄꠛꠞꠅ ꠉꠦꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("LK24_23","072_24_23","LUK","24","23","23","ꠉꠤꠀ ꠖꠦꠈꠍꠂꠘ, ꠔꠣꠘ ꠟꠣꠡ ꠘꠣꠁ। ꠔꠣꠞꠣ ꠚꠤꠞꠔ ꠀꠁꠀ ꠇꠁꠟꠣ, ꠔꠣꠞꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠖꠞꠡꠘ ꠙꠣꠁꠍꠂꠘ, ꠀꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠍꠂꠘ, ꠁꠍꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK24_24","072_24_24","LUK","24","24","24","ꠛꠣꠖꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠣꠞꠣ ꠀꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦꠅ ꠇꠦꠃ ꠇꠦꠃ ꠇꠄꠛꠞꠅ ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠇꠕꠣꠃ ꠢꠣꠍꠣ, ꠁꠍꠣꠞ ꠟꠣꠡ ꠇꠄꠛꠞꠅ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK24_25","072_24_25","LUK","24","25","25","ꠢꠇꠟꠔꠣ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠔ ꠇꠥꠘ꠆ꠔꠣꠃ ꠛꠥꠎꠂꠘ ꠘꠣ। ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠖꠤꠟ ꠅꠟꠣ ꠅꠡꠣꠠ ꠛꠘꠤꠉꠦꠍꠦ ꠘꠤ? ꠀꠟ꠆ꠟꠣꠞ ꠘꠛꠤ ꠅꠇꠟꠦ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠀ ꠉꠦꠍꠂꠘ, ꠅꠔꠣꠞꠦꠅ ꠀꠙꠘꠣꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠞꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_26","072_24_26","LUK","24","26","26","ꠘꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠍꠂꠘ ꠘꠣ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠘ ꠎꠣꠟꠣꠟ ꠀꠞ ꠉꠃꠞꠛ ꠢꠣꠍꠤꠟ ꠇꠞꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("LK24_27","072_24_27","LUK","24","27","27","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠇꠞꠤꠀ, ꠢꠇ꠆ꠇꠟ ꠘꠛꠤꠞ ꠇꠤꠔꠣꠛꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠎꠔꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠅꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠛꠥꠎꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_28","072_24_28","LUK","24","28","28","ꠀꠞ ꠎꠦ ꠉꠣꠃꠔ ꠎꠣꠁꠔꠣ ꠇꠞꠤ ꠔꠣꠞꠣ ꠞꠅꠀꠘꠣ ꠖꠤꠍꠟꠣ, ꠢꠃ ꠉꠣꠃꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠦ ꠁꠍꠣꠄ ꠀꠞꠅ ꠖꠥꠞꠁ ꠎꠣꠅꠀꠞ ꠜꠣꠛ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_29","072_24_29","LUK","24","29","29","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠈꠥꠛ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤꠀ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠔ ꠛꠦꠁꠟ ꠉꠦꠍꠦꠉꠤ, ꠢꠣꠁꠘ꠆ꠎꠣ ꠅꠁꠎꠣꠞ, ꠔꠦ ꠞꠣꠁꠔꠈꠣꠘ ꠀꠙꠘꠦ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠁ ꠎꠣꠃꠇ꠆ꠇꠣ।” ꠅꠃ ꠔꠣꠁꠘ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_30","072_24_30","LUK","24","30","30","ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠈꠣꠘꠤꠔ ꠛꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠞꠥꠐꠤ ꠟꠁꠀ ꠐꠥꠇꠞꠣꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_31","072_24_31","LUK","24","31","31","ꠔꠦꠃ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠈꠥꠟꠤꠉꠦꠟ, ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠌꠤꠘꠤꠟꠤꠟꠣ। ꠌꠤꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠃꠠꠤ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_32","072_24_32","LUK","24","32","32","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠇꠁꠟꠣ, “ꠙꠕꠅ ꠎꠦꠛꠟꠣ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠟꠣ, ꠀꠝꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠛꠥꠎꠣꠁꠀ ꠖꠤꠍꠟꠣ, ꠢꠃ ꠡꠝꠄ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠄꠇ ꠄꠡꠇꠤ ꠙꠄꠖꠣ ꠅꠁꠍꠤꠟ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK24_33","072_24_33","LUK","24","33","33","ꠟꠉꠦ ꠟꠉꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘ ꠛꠣꠞ ꠅꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠀꠁꠟꠣ। ꠀꠁꠀ ꠢꠃ ꠄꠉꠣꠞꠅ ꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇ꠆ꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠛꠅꠀꠔ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_34","072_24_34","LUK","24","34","34","ꠔꠣꠞꠣ ꠅꠘꠅ ꠛꠁꠀ ꠅꠔꠣ ꠝꠣꠔꠤꠞꠣ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠍꠟꠦꠃ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠉꠦꠍꠂꠘ, ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK24_35","072_24_35","LUK","24","35","35","ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠖꠥꠁꠅꠎꠘꠦꠅ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, ꠙꠕꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣ ꠇꠤꠟꠣ ꠁꠍꠣꠞ ꠖꠦꠈꠣ ꠙꠣꠁꠟꠣ, ꠞꠥꠐꠤ ꠐꠥꠇꠞꠣꠁꠛꠣꠞ ꠡꠝꠄ ꠇꠤꠟꠣ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠟꠣ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_36","072_24_36","LUK","24","36","36","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔ ꠅꠔꠣ ꠟꠁꠀ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠁꠍꠣ ꠘꠤꠎꠦ ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ।” ");
INSERT INTO syls_vpl VALUES ("LK24_37","072_24_37","LUK","24","37","37","ꠔꠣꠘꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠒꠞꠣꠁꠉꠦꠟꠣ, ꠝꠘꠅ ꠇꠞꠟꠣ ꠜꠥꠔ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("LK24_38","072_24_38","LUK","24","38","38","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠔ ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠉꠦꠟꠣꠄ ꠇꠦꠘꠦ? ꠇꠦꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠡꠘ꠆ꠖꠄ ꠢꠣꠝꠣꠁꠟ? ");
INSERT INTO syls_vpl VALUES ("LK24_39","072_24_39","LUK","24","39","39","ꠀꠝꠣꠞ ꠀꠔ-ꠙꠣꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠖꠦꠈꠅ, ꠖꠦꠈꠅ ꠘꠣ, ꠁ ꠔ ꠀꠝꠤ। ꠀꠝꠣꠞꠦ ꠀꠔꠣꠁꠀ ꠖꠦꠈꠅ, ꠜꠥꠔꠞ ꠔ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠒ꠆ꠒꠤ-ꠝꠣꠋꠡ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("LK24_40","072_24_40","LUK","24","40","40","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠀꠔ-ꠙꠣꠅ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_41","072_24_41","LUK","24","41","41","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠔꠣꠘꠦ ꠖꠦꠈꠤꠀ ꠅꠔ ꠛꠦꠡꠤ ꠈꠥꠡꠤ ꠅꠁꠟꠣ, ꠈꠥꠡꠤꠞ ꠌꠥꠐꠦ ꠛꠦꠖꠤꠡꠣ ꠛꠘꠤꠉꠦꠟꠣ, ꠇꠥꠘ꠆ꠔꠣ ꠛꠤꠡ꠆ꠛꠣꠡ ꠇꠞꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁꠘꠅ ꠈꠣꠁꠛꠣꠞ ꠇꠥꠘ꠆ꠔꠣ ꠀꠍꠦ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("LK24_42","072_24_42","LUK","24","42","42","ꠔꠣꠞꠣ ꠄꠇ ꠐꠥꠇꠞꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍ ꠔꠣꠘꠞꠦ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_43","072_24_43","LUK","24","43","43","ꠅꠃ ꠝꠣꠍ ꠔꠣꠁꠘ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_44","072_24_44","LUK","24","44","44","ꠈꠣꠁꠀ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣꠝ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠟꠣꠝ ꠘꠣ ꠘꠤ, ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚ, ꠘꠛꠤ ꠅꠇꠟꠞ ꠍꠢꠤꠚꠣ, ꠀꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠚꠟꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("LK24_45","072_24_45","LUK","24","45","45","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ, ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠖꠤꠟꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠤ ꠖꠤꠟꠣ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠝꠣꠘꠤ ꠄꠞꠣ ꠛꠥꠎꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("LK24_46","072_24_46","LUK","24","46","46","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠟ-ꠝꠍꠤꠄ ꠛꠃꠔ ꠇꠑꠤꠘ ꠖꠥꠈ-ꠔꠇꠟꠤꠚ ꠙꠣꠁꠛꠣ, ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠁꠘ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_47","072_24_47","LUK","24","47","47","ꠎꠦꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠘꠣꠝꠦ ꠔꠃꠛꠣ ꠇꠞꠟꠦ, ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠝꠣꠉꠤꠟꠦ ꠝꠣꠚꠤ ꠙꠣꠁꠛ, ꠅꠃ ꠛꠄꠀꠘꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠅꠁꠀ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠇꠣꠘꠅ ꠙꠃꠍꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("LK24_48","072_24_48","LUK","24","48","48","ꠔꠥꠝꠞꠣꠃ ꠁ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("LK24_49","072_24_49","LUK","24","49","49","ꠀꠞ ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚꠦ ꠎꠦꠔꠣ ꠖꠣꠘ ꠇꠞꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠝꠤ ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠛꠦꠎꠤꠝꠥ। ꠅꠁꠟꠦ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔ ꠘꠣ ꠙꠣꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠞꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("LK24_50","072_24_50","LUK","24","50","50","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠉꠣꠃꠞ ꠝꠥꠈꠅ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠔꠣꠁꠘ ꠀꠔ ꠔꠥꠟꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_51","072_24_51","LUK","24","51","51","ꠀꠞ ꠅꠃ ꠖꠥꠀꠞ ꠢꠣꠟꠔꠦꠃ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠀꠟꠉ ꠅꠁꠉꠦꠟꠣ, ꠔꠣꠘꠞꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("LK24_52","072_24_52","LUK","24","52","52","ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ, ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠚꠤꠞꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("LK24_53","072_24_53","LUK","24","53","53","ꠀꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠣꠝꠖ-ꠔꠣꠞꠤꠚ ꠇꠞꠣꠔ ꠞꠁꠟꠣ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("JN1_1","073_1_1","JHN","1","1","1","ꠙꠄꠟꠣꠃ ꠇꠣꠟꠣꠝ ꠀꠍꠟꠣ, ꠇꠣꠟꠣꠝ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ ꠀꠞ ꠅꠃ ꠇꠣꠟꠣꠝ ꠘꠤꠎꠦꠃ ꠀꠟ꠆ꠟꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_2","073_1_2","JHN","1","2","2","ꠢꠇꠟ ꠙꠄꠟꠣ ꠅꠃ ꠇꠣꠟꠣꠝ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_3","073_1_3","JHN","1","3","3","ꠅꠃ ꠇꠣꠟꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠎꠔꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠄꠞ ꠇꠥꠘꠥꠔꠣꠃ ꠔꠣꠘꠞꠦ ꠍꠣꠠꠣ ꠙꠄꠖꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_4","073_1_4","JHN","1","4","4","ꠔꠣꠘ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠍꠤꠟ, ꠢꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠃ ꠅꠁꠟ ꠝꠣꠘꠡꠞ ꠘꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("JN1_5","073_1_5","JHN","1","5","5","ꠅꠃ ꠘꠥꠞ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠎꠟꠦꠞ, ꠅꠁꠟꠦ ꠀꠘ꠆ꠖꠣꠁꠞꠦ ꠁ ꠘꠥꠞꠞꠦ ꠇꠛꠎꠣ ꠇꠞꠔ ꠙꠣꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_6","073_1_6","JHN","1","6","6","ꠀꠟ꠆ꠟꠣꠄ ꠄꠢꠤꠀ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠘꠤꠀꠔ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_7","073_1_7","JHN","1","7","7","ꠅꠃ ꠘꠥꠞꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠙꠣꠑꠣꠁꠟ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠘ ꠀꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("JN1_8","073_1_8","JHN","1","8","8","ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠢꠤ ꠘꠥꠞ ꠀꠍꠟꠣ ꠘꠣ, ꠅꠁꠟꠦ ꠘꠥꠞꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_9","073_1_9","JHN","1","9","9","ꠀꠍꠟ ꠘꠥꠞ ꠅꠁꠟꠣ ꠢꠃ ꠎꠘ, ꠎꠦꠁꠘ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠘꠥꠞ ꠖꠣꠘ ꠇꠞꠂꠘ, ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_10","073_1_10","JHN","1","10","10","ꠅꠃ ꠖꠥꠘꠤꠀꠔ ꠔꠣꠁꠘ ꠀꠍꠟꠣ, ꠖꠥꠘꠤꠀ ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠙꠄꠖꠣ ꠅꠁꠍꠦ, ꠔꠣ-ꠅ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_11","073_1_11","JHN","1","11","11","ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠎꠝꠤꠘꠅ ꠀꠁꠟꠣ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠝꠣꠘꠡꠦꠃ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_12","073_1_12","JHN","1","12","12","ꠅꠁꠟꠦ ꠎꠔ ꠎꠘꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠄꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠞꠦ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠀꠅꠟꠣꠖ, ꠝꠣꠘꠤ ꠝꠣꠄꠀꠞ ꠎꠘ ꠛꠘꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_13","073_1_13","JHN","1","13","13","ꠀꠍꠟꠦ ꠅꠃ ꠎꠘ ꠅꠇꠟꠞ ꠎꠘꠝ ꠔ ꠝꠣꠘꠡꠞ ꠟꠃ ꠕꠣꠇꠤ ꠅꠁꠍꠦ ꠘꠣ, ꠡꠞꠤꠟꠞ ꠈꠣꠁꠡ ꠛꠣ ꠝꠣꠘꠡꠞ ꠁꠌ꠆ꠍꠣꠄꠅ ꠅꠁꠍꠦ ꠘꠣ, ꠁꠐꠣ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣ ꠕꠣꠇꠤꠃ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN1_14","073_1_14","JHN","1","14","14","ꠅꠃ ꠇꠣꠟꠣꠝꠃ ꠝꠣꠘꠥꠡ ꠍꠥꠞꠔꠦ ꠎꠘꠝ ꠟꠁꠟꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔꠤ ꠇꠞꠟꠣ। ꠛꠣꠚꠞ ꠈꠣꠍ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠁꠘ ꠎꠦ ꠎꠣꠟꠣꠟ ꠀꠞ ꠝꠢꠤꠝꠣ ꠙꠣꠁꠍꠂꠘ, ꠢꠃ ꠎꠣꠟꠣꠟ ꠀꠞ ꠝꠢꠤꠝꠣ ꠀꠝꠞꠣ ꠖꠦꠈꠍꠤ। ꠔꠣꠁꠘ ꠔ ꠢꠇ ꠀꠞ ꠞꠢꠝꠔꠦ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠇꠣꠝꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN1_15","073_1_15","JHN","1","15","15","ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠛꠠ ꠉꠟꠣꠄ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠟꠣ, ꠇꠁꠟꠣ, “ꠄꠁꠘꠃ ꠔ ꠢꠃ ꠎꠘ, ꠎꠦꠘ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠀꠉꠦ ꠇꠁꠍꠟꠣꠝ, ꠀꠝꠣꠞ ꠛꠣꠖꠦ ꠄꠇꠎꠘꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠔꠣꠁꠘ ꠀꠝꠣ ꠕꠣꠇꠤꠅ ꠝꠢꠣꠘ, ꠀꠝꠣꠞ ꠛꠃꠔ ꠀꠉ ꠕꠣꠇꠤꠃ ꠔ ꠔꠣꠁꠘ ꠀꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN1_16","073_1_16","JHN","1","16","16","ꠔꠣꠁꠘ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠇꠣꠝꠤꠟ ꠅꠀꠄ ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠞꠢꠝꠔꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠞꠅ ꠞꠢꠝꠔ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN1_17","073_1_17","JHN","1","17","17","ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠞꠚꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠡꠞꠤꠅꠔ ꠖꠣꠘ ꠇꠞꠍꠤꠟꠣ, ꠅꠁꠟꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠞꠚꠔꠦ ꠢꠇ ꠀꠞ ꠞꠢꠝꠔ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN1_18","073_1_18","JHN","1","18","18","ꠀꠟ꠆ꠟꠣꠞꠦ ꠔ ꠇꠦꠃ ꠇꠥꠘꠥꠖꠤꠘ ꠖꠦꠈꠍꠦ ꠘꠣ। ꠔꠣꠘ ꠟꠉꠦ ꠞꠅꠞꠣ ꠢꠃ ꠄꠇꠝꠣꠔ꠆ꠞ ꠙꠥꠔ, ꠝꠣꠘꠤ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠎꠦꠁꠘ ꠡ꠆ꠛꠄꠅꠋ ꠝꠃꠟꠣ, ꠔꠣꠁꠘꠃ ꠀꠟ꠆ꠟꠣꠞꠦ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN1_19","073_1_19","JHN","1","19","19","ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠎꠦꠛꠟꠣ ꠇꠄꠎꠘ ꠁꠝꠣꠝ ꠀꠞ ꠟꠦꠛꠤ ꠡꠝꠣꠎꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠞꠦ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠄꠢꠤꠀꠄ ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠤꠇꠣꠁꠟꠣ, “ꠍꠣꠛ, ꠀꠙꠘꠦ ꠀꠍꠟꠦ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN1_20","073_1_20","JHN","1","20","20","ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠟꠥꠇꠣꠁꠀ ꠡ꠆ꠛꠤꠇꠣꠞ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠀꠟ-ꠝꠍꠤ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN1_21","073_1_21","JHN","1","21","21","ꠔꠦꠃ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠦ ꠀꠙꠘꠦ ꠇꠦ? ꠀꠙꠘꠦ ꠁꠟꠤꠀꠍ ꠘꠛꠤ ꠘꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠘꠣ, ꠀꠝꠤ ꠁꠟꠤꠀꠍ ꠘꠣꠄ।” ꠅꠃ ꠔꠣꠞꠣ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠦ ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠢꠃ ꠘꠛꠤ ꠘꠤ?” ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠎꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN1_22","073_1_22","JHN","1","22","22","ꠔꠣꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠣꠁꠟꠦ ꠀꠙꠘꠦ ꠇꠦ? ꠀꠝꠞꠣꠞꠦ ꠎꠦꠞꠣ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠀꠝꠞꠣ ꠚꠤꠞꠤꠀ ꠉꠤꠀ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠝ, ꠀꠙꠘꠣꠞ ꠘꠤꠎꠞ ꠙꠞꠤꠌꠄ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN1_23","073_1_23","JHN","1","23","23","ꠄꠢꠤꠀꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠅꠁꠟꠣꠝ ꠢꠃ ꠀꠅꠀꠎ, ꠎꠦꠘ ꠛꠦꠙꠣꠞꠦ ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠛꠣꠔꠣꠁ ꠉꠦꠍꠂꠘ, ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠄꠇꠎꠘꠦ ꠄꠟꠣꠘ ꠇꠞꠞꠣ, ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇꠞ ꠙꠕ ꠍꠢꠤ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN1_24","073_1_24","JHN","1","24","24","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠎꠦꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠄꠞꠣ ꠀꠍꠟꠣ ꠚꠞꠤꠡꠤ ꠡꠝꠣꠎꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("JN1_25","073_1_25","JHN","1","25","25","ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠦ ꠎꠦꠛꠟꠣ ꠀꠟ-ꠝꠍꠤꠅ ꠘꠣꠄ, ꠁꠟꠤꠀꠍ ꠘꠛꠤꠅ ꠘꠣꠄ ꠛꠣ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠢꠃ ꠘꠛꠤꠅ ꠘꠣꠄ, ꠔꠦ ꠀꠙꠘꠦ ꠇꠦꠘꠦ ꠝꠣꠘꠡꠞꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠖꠤꠞꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN1_26","073_1_26","JHN","1","26","26","ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠘꠤ ꠖꠤꠀ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠞꠣꠝ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠃꠟꠣ ꠄꠇ ꠛꠥꠎꠥꠞ꠆ꠉ ꠎꠘ ꠀꠍꠂꠘ, ꠎꠦꠘꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠌꠤꠘꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_27","073_1_27","JHN","1","27","27","ꠁ ꠛꠥꠎꠥꠞ꠆ꠉ ꠢꠃ ꠎꠘ, ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠛꠣꠖꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠕꠣ ꠀꠍꠤꠟ। ꠔꠣꠘ ꠙꠣꠅꠞ ꠎꠥꠔꠣꠞ ꠚꠤꠔꠣꠉꠦꠍꠣ ꠈꠥꠟꠣꠞ ꠟꠣꠈꠅ ꠀꠝꠤ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN1_28","073_1_28","JHN","1","28","28","ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠀꠞꠇ ꠙꠣꠞꠅ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠉꠣꠃꠔ, ꠄꠢꠤꠀ ꠘꠛꠤ ꠎꠦ ꠎꠣꠉꠣꠔ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠘꠤꠔ ꠀꠍꠟꠣ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠅꠃ ꠍꠅꠀꠟ-ꠎꠥꠀꠙ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN1_29","073_1_29","JHN","1","29","29","ꠛꠣꠖꠞ ꠖꠤꠘ ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠖꠦꠈꠟꠣ ꠢꠥꠎꠥꠞ ꠁꠍꠣ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠞꠣ, ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠅꠃ ꠖꠦꠈꠞꠣꠄ ꠘꠤ ꠀꠟ꠆ꠟꠣꠁ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ, ꠎꠦꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JN1_30","073_1_30","JHN","1","30","30","ꠄꠁꠘ ꠅꠁꠟꠣ ꠢꠃ ꠎꠘ, ꠎꠦꠘ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠀꠉꠦ ꠇꠁꠍꠟꠣꠝ, ꠀꠝꠣꠞ ꠛꠣꠖꠦ ꠄꠇꠎꠘꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠀꠍꠟꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠀꠉ ꠕꠣꠇꠤꠃ ꠀꠍꠂꠘ, ꠀꠞ ꠔꠣꠁꠘ ꠀꠝꠣ ꠕꠣꠇꠤꠅ ꠁꠎ꠆ꠎꠔꠤ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("JN1_31","073_1_31","JHN","1","31","31","ꠀꠉꠦ ꠔ ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠔꠣꠝ ꠘꠣ, ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠔꠣꠁꠘ ꠎꠣꠔꠦ ꠙꠞꠤꠌꠤꠔꠤ ꠙꠣꠁꠘ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠉꠦ ꠀꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠘꠤꠖꠤ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN1_32","073_1_32","JHN","1","32","32","ꠛꠣꠖꠦ ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠅꠃ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠟꠣ, ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ ꠇꠂꠔꠞꠞ ꠍꠥꠞꠔꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠄꠘ ꠃꠙꠞꠦ ꠀꠎꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_33","073_1_33","JHN","1","33","33","ꠀꠝꠤ ꠔ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠔꠣꠝ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠣꠔꠣꠁ ꠖꠤꠍꠂꠘ ꠎꠦꠘ, ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞꠦ ꠎꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠝꠤꠀ ꠀꠁꠔꠦ ꠖꠦꠈꠛꠣꠄ, ꠄꠁꠘꠃ ꠢꠃ ꠎꠘ, ꠎꠦꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠖꠤ ꠔꠞꠤꠇꠣꠛꠘ꠆ꠖꠤ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_34","073_1_34","JHN","1","34","34","ꠔꠦ ꠀꠝꠤ ꠁꠔꠣ ꠖꠦꠈꠟꠣꠝ, ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣꠝ, ꠄꠁꠘꠃ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN1_35","073_1_35","JHN","1","35","35","ꠛꠣꠖꠞ ꠖꠤꠘ ꠄꠢꠤꠀ ꠘꠛꠤ ꠀꠞ ꠔꠣꠘ ꠖꠥꠁꠎꠘ ꠃꠝ꠆ꠝꠔ ꠢꠤꠞꠛꠣꠞ ꠢꠃ ꠎꠣꠉꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_36","073_1_36","JHN","1","36","36","ꠅꠃ ꠡꠝꠄ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠐꠤꠀ ꠎꠣꠁꠞꠣ, ꠔꠣꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠄꠢꠤꠀꠄ ꠇꠁꠟꠣ, “ꠅꠃ ꠖꠦꠈꠞꠣꠄ ꠘꠤ ꠀꠟ꠆ꠟꠣꠁ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN1_37","073_1_37","JHN","1","37","37","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠅꠃ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠢꠃ ꠖꠥꠁꠅꠎꠘ ꠁꠍꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN1_38","073_1_38","JHN","1","38","38","ꠁꠍꠣꠄ ꠈꠞꠦꠖꠤ ꠚꠤꠞꠤꠀ ꠄꠞꠣꠞꠦ ꠖꠦꠈꠟꠣ, ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠌꠣꠅ?” ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠞꠛ꠆ꠛꠤ, (ꠝꠣꠘꠤ ꠃꠡ꠆ꠔꠣꠖ), ꠀꠙꠘꠦ ꠇꠥꠀꠁ ꠕꠣꠇꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("JN1_39","073_1_39","JHN","1","39","39","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ ꠘꠣ, ꠀꠁꠀ ꠖꠦꠈꠤꠀ ꠎꠣꠅ।” ꠔꠦꠃ ꠔꠣꠞꠣ ꠔꠣꠘ ꠟꠉꠦ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠖꠦꠈꠟꠣ ꠔꠣꠁꠘ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠕꠣꠇꠂꠘ, ꠀꠞ ꠔꠣꠞꠣꠅ ꠀꠡ꠆ꠔꠣ ꠖꠤꠘ ꠔꠣꠘ ꠟꠉꠦ ꠞꠁꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠀꠍꠞꠞ ꠅꠇ꠆ꠔ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN1_40","073_1_40","JHN","1","40","40","ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠎꠦ ꠖꠥꠁꠎꠘ ꠁꠍꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠍꠟꠣ, ꠄꠞꠣꠞ ꠄꠇꠎꠘꠞ ꠘꠣꠝ ꠅꠁꠟ ꠀꠘ꠆ꠖꠞꠤꠀꠍ, ꠄꠘ ꠜꠣꠁꠞ ꠘꠣꠝ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("JN1_41","073_1_41","JHN","1","41","41","ꠅꠃ ꠀꠘ꠆ꠖꠞꠤꠀꠍꠦ ꠙꠄꠟꠣ ꠔꠣꠘ ꠜꠣꠁ ꠍꠣꠁꠝꠘꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠛꠣꠞ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠜꠣꠁꠍꠣꠛ ꠢꠥꠘꠍ ꠘꠤ, ꠀꠝꠞꠣ ꠔ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠖꠦꠈꠍꠤ।” ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠘꠤ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠅꠀ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("JN1_42","073_1_42","JHN","1","42","42","ꠀꠘ꠆ꠖꠞꠤꠀꠍꠦ ꠍꠣꠁꠝꠘꠞꠦ ꠟꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠁꠍꠣꠄ ꠍꠣꠁꠝꠘꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔ ꠍꠣꠁꠝꠘ ꠛꠤꠘ ꠁꠃꠢꠣꠘ꠆ꠘꠣ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠂꠚꠣ ꠘꠣꠝꠦ ꠒꠣꠇꠣ ꠅꠁꠛ।” ꠇꠂꠚꠣ ꠝꠣꠘꠤ ꠙꠤꠔꠞ, ꠛꠣ ꠙꠣꠔ꠆ꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("JN1_43","073_1_43","JHN","1","43","43","ꠛꠣꠖꠞ ꠖꠤꠘ ꠁꠍꠣꠄ ꠘꠤꠅꠔ ꠇꠞꠟꠣ, ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠎꠣꠁꠔꠣꠉꠤ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠚꠤꠟꠤꠚꠞꠦ ꠖꠦꠈꠟꠣ, ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠚꠤꠟꠤꠚ ꠀꠅ, ꠀꠁꠀ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN1_44","073_1_44","JHN","1","44","44","ꠚꠤꠟꠤꠚ ꠀꠍꠟꠣ ꠛꠣꠄꠔ-ꠍꠄꠖꠣ ꠉꠣꠃꠞ ꠝꠣꠘꠥꠡ। ꠀꠘ꠆ꠖꠞꠤꠀꠍ ꠀꠞ ꠙꠤꠔꠞꠞ ꠛꠣꠠꠤꠅ ꠀꠍꠤꠟ ꠅꠃ ꠉꠣꠃꠔ। ");
INSERT INTO syls_vpl VALUES ("JN1_45","073_1_45","JHN","1","45","45","ꠚꠤꠟꠤꠚꠦ ꠘꠕꠘꠦꠟꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠛꠣꠞ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠅ ꠀꠞ ꠀꠍꠝꠣꠘꠤ ꠘꠛꠤ ꠅꠇꠟꠞ ꠍꠢꠤꠚꠣꠔ ꠎꠦꠘ ꠇꠕꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠝꠞꠣ ꠔ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠍꠤ। ꠔꠣꠁꠘ ꠔ ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠞ ꠁꠍꠣ, ꠔꠣꠘ ꠛꠣꠚꠞ ꠘꠣꠝ ꠁꠃꠍꠥꠚ।” ");
INSERT INTO syls_vpl VALUES ("JN1_46","073_1_46","JHN","1","46","46","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠘꠕꠘꠦꠟꠦ ꠚꠤꠟꠤꠚꠞꠦ ꠇꠁꠟꠣ, “ꠗꠥꠔ! ꠘꠣꠍꠣꠞꠔ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠞꠅꠄ ꠘꠤ?” ꠚꠤꠟꠤꠚꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠁꠀ ꠖꠦꠈꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN1_47","073_1_47","JHN","1","47","47","ꠁꠍꠣꠄ ꠖꠦꠈꠟꠣ, ꠘꠕꠘꠦꠟ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠞꠣ, ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠅꠃ ꠖꠦꠈꠞꠣꠄ ꠘꠤ ꠄꠇꠎꠘ ꠈꠣꠐꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠤ। ꠔꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠗꠥꠘ꠆ꠖꠥꠞ-ꠝꠥꠘ꠆ꠖꠥꠞ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN1_48","073_1_48","JHN","1","48","48","ꠔꠦꠃ ꠘꠕꠘꠦꠟꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠦꠝꠘꠦ ꠌꠤꠘꠟꠣ?” ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞꠦ ꠒꠣꠇꠤꠛꠣꠞ ꠀꠉꠦ ꠔꠥꠝꠤ ꠎꠦꠛꠟꠣ ꠢꠃ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠞ ꠔꠟꠦ ꠀꠍꠟꠣꠄ, ꠢꠃ ꠡꠝꠄ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN1_49","073_1_49","JHN","1","49","49","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠘꠕꠘꠦꠟꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦꠃ ꠔ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ। ꠀꠙꠘꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠖꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN1_50","073_1_50","JHN","1","50","50","ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞꠦ ꠢꠃ ꠒꠥꠝꠥꠞ ꠉꠣꠍꠞ ꠔꠟꠦ ꠖꠦꠈꠍꠤ ꠅꠈꠣꠘ ꠇꠅꠀꠄ ꠔꠥꠝꠤ ꠁꠝꠣꠘ ꠀꠘꠟꠣꠄ ꠘꠤ? ꠢꠥꠘꠅ, ꠄꠞ ꠕꠣꠇꠤꠅ ꠀꠞꠅ ꠛꠃꠔ ꠛꠠ ꠛꠠ ꠇꠦꠞꠣꠝꠔꠤ ꠔꠥꠝꠤ ꠖꠦꠈꠛꠣꠄꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN1_51","073_1_51","JHN","1","51","51","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠖꠦꠈꠛꠣꠄ ꠛꠦꠢꠦꠡ꠆ꠔ ꠈꠥꠟꠤꠉꠦꠍꠦ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠃꠙꠞꠦ ꠃꠑꠣ-ꠟꠣꠝꠣ ꠇꠞꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN2_1","073_2_1","JHN","2","1","1","ꠄꠞ ꠖꠥꠁꠖꠤꠘ ꠛꠣꠖꠦ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠇꠣꠘ꠆ꠘꠣ ꠉꠣꠃꠔ ꠄꠇ ꠛꠤꠀ ꠀꠍꠤꠟ। ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠝꠣ ꠅꠃ ꠛꠤꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN2_2","073_2_2","JHN","2","2","2","ꠅꠃ ꠛꠤꠀꠔ ꠁꠍꠣ ꠀꠞ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦꠅ ꠖꠣꠅꠔ ꠙꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN2_3","073_2_3","JHN","2","3","3","ꠛꠤꠀꠞ ꠅꠘꠥꠡ꠆ꠑꠣꠘꠅ ꠎꠦꠛꠟꠣ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠚꠥꠠꠣꠁ ꠉꠦꠟ, ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠞ ꠝꠣʼꠄ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠄꠞꠣꠞ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠡꠦꠡ ꠅꠁꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN2_4","073_2_4","JHN","2","4","4","ꠁꠍꠣꠄ ꠔꠣꠘ ꠝꠣʼꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠁ ꠉ, ꠁꠔꠣ ꠔ ꠀꠝꠣꠞ ꠛꠤꠡꠄ ꠘꠣꠄ। ꠅꠈꠘꠅ ꠀꠝꠣꠞ ꠡꠝꠄ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN2_5","073_2_5","JHN","2","5","5","ꠅꠁꠟꠦ ꠔꠣꠘ ꠝꠣʼꠄ ꠈꠣꠖꠤꠝꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠇꠂꠘ, ꠅꠔꠣꠃ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN2_6","073_2_6","JHN","2","6","6","ꠁꠢꠥꠖꠤꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠅꠎꠥ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠤꠘꠅ ꠙꠣꠔ꠆ꠔꠞꠞ ꠍꠄꠐꠣ ꠉꠣꠝꠟꠣ ꠀꠍꠤꠟ। ꠁꠔꠣ ꠄꠇꠅꠐꠣꠔ ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁ-ꠔꠤꠘ ꠝꠘ ꠙꠣꠘꠤ ꠗꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("JN2_7","073_2_7","JHN","2","7","7","ꠁꠍꠣꠄ ꠈꠣꠖꠤꠝꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠉꠣꠝꠟꠣꠁꠘ꠆ꠔꠅ ꠙꠣꠘꠤ ꠜꠞꠅ।” ꠔꠦꠃ ꠔꠣꠞꠣ ꠁꠉꠥꠁꠘ ꠐꠦꠙꠦ ꠐꠦꠙꠦ ꠜꠞꠤ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN2_8","073_2_8","JHN","2","8","8","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠘ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠙꠣꠘꠤ ꠘꠤꠀ ꠙꠞꠗꠣꠘ ꠛꠣꠛꠥꠞ꠆ꠌꠤꠞꠦ ꠖꠦꠅ।” ꠔꠦꠃ ꠔꠣꠞꠣ ꠅꠟꠣꠃ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("JN2_9","073_2_9","JHN","2","9","9","ꠛꠣꠛꠥꠞ꠆ꠌꠤꠄ ꠅꠃ ꠙꠣꠘꠤ ꠈꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠁꠔꠣ ꠔ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ। ꠅꠁꠟꠦ ꠁ ꠡꠞꠛꠔ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠟ, ꠁꠈꠣꠘ ꠔꠣꠁꠘ ꠎꠣꠘꠔꠣ ꠘꠣ। ꠈꠣꠟꠤ ꠈꠣꠖꠤꠝꠖꠣꠞ ꠅꠇꠟꠦ ꠎꠣꠘꠔ। ꠄꠞꠟꠣꠉꠤ ꠛꠣꠛꠥꠞ꠆ꠌꠤꠄ ꠛꠤꠀꠞ ꠘꠡꠣꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("JN2_10","073_2_10","JHN","2","10","10","“ꠙꠄꠟꠣ ꠢꠇꠟꠦꠃ ꠝꠣꠘꠡꠞꠦ ꠈꠣꠐꠤ ꠡꠞꠛꠔ ꠈꠣꠁꠔꠦ ꠖꠦꠄ। ꠝꠣꠘꠡꠦ ꠁꠌ꠆ꠍꠣꠝꠔ ꠈꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠡꠦꠡ ꠅꠁꠎꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠎꠦ ꠡꠞꠛꠔ ꠖꠦꠄ, ꠁꠔꠣ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠇꠤꠍꠥ ꠜꠦꠎꠣꠟ ꠕꠣꠇꠦ। ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠈꠣꠐꠤ ꠡꠞꠛꠔ ꠅꠈꠘꠅ ꠞꠣꠈꠍ।” ");
INSERT INTO syls_vpl VALUES ("JN2_11","073_2_11","JHN","2","11","11","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠇꠣꠘ꠆ꠘꠣ ꠉꠣꠃꠔ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠅꠃ ꠙꠄꠟꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠀ ꠘꠤꠎꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠟꠣ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN2_12","073_2_12","JHN","2","12","12","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠝꠣ, ꠜꠣꠁꠀꠁꠘ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠇꠄꠖꠤꠘ ꠢꠘꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN2_13","073_2_13","JHN","2","13","13","ꠁꠢꠥꠖꠤꠞ ꠀꠎꠣꠖꠤ ꠁꠖ ꠊꠘꠣꠁ ꠉꠦꠟꠦ ꠁꠍꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN2_14","073_2_14","JHN","2","14","14","ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠀ ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠇꠣꠛꠣ ꠊꠞꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠞꠥ, ꠝꠦꠠꠣ ꠀꠞ ꠙꠣꠞꠅ ꠛꠦꠌꠣ-ꠇꠤꠘꠣ ꠌꠟꠦꠞ, ꠀꠞ ꠐꠦꠇꠣꠞ ꠛꠣꠐ꠆ꠐꠣꠞ ꠇꠣꠞꠛꠣꠞꠤ ꠅꠇꠟꠅ ꠛꠁ ꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN2_15","073_2_15","JHN","2","15","15","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠖꠠꠤ ꠖꠤꠀ ꠄꠇꠐꠣ ꠌꠣꠛꠥꠇ ꠛꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠌꠣꠛꠥꠇ ꠖꠤꠀ ꠢꠇꠟ ꠉꠞꠥ-ꠝꠦꠠꠣ ꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠁꠘ ꠕꠘꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠟꠣ। ꠀꠞ ꠐꠦꠇꠣꠞ ꠛꠣꠐ꠆ꠐꠣꠞ ꠇꠣꠞꠛꠣꠞꠤ ꠅꠇꠟꠞ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠍꠤꠔ꠆ꠞꠣꠁꠀ, ꠔꠣꠞꠣꠞ ꠇꠦꠡ ꠛꠣꠇ꠆ꠡ ꠃꠟꠐꠣꠁꠀ ꠚꠣꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN2_16","073_2_16","JHN","2","16","16","ꠙꠣꠞꠅ ꠛꠦꠌꠞꠣ ꠅꠇꠟꠞꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁꠘ ꠕꠘꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠢꠞꠣꠅ। ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠊꠞꠞꠦ ꠛꠣꠎꠣꠞ ꠛꠣꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN2_17","073_2_17","JHN","2","17","17","ꠅꠃ ꠡꠝꠄ ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠅꠃ ꠇꠕꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠝꠘꠅ ꠅꠁꠉꠦꠟ, “ꠔꠥꠝꠣꠞ ꠊꠞꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠎꠦ ꠝꠢꠛ꠆ꠛꠔ, ꠅꠃ ꠝꠢꠛ꠆ꠛꠔꠦꠃ ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠎꠟꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN2_18","073_2_18","JHN","2","18","18","ꠁꠍꠣꠞ ꠁ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁꠔꠣ ꠇꠞꠣꠞ ꠅꠗꠤꠇꠣꠞ ꠎꠦ ꠔꠥꠝꠣꠞ ꠀꠍꠦ, ꠔꠣꠞ ꠙꠞꠝꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠤ ꠇꠥꠘ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠛꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("JN2_19","073_2_19","JHN","2","19","19","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠅꠃ ꠇꠣꠛꠣ ꠊꠞ ꠜꠣꠋꠉꠤꠟꠣꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠔꠤꠘ ꠖꠤꠘꠞ ꠜꠤꠔꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠟꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN2_20","073_2_20","JHN","2","20","20","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠁ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠁꠔꠦ ꠍꠄꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠟꠣꠉꠍꠤꠟ, ꠀꠞ ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠔꠤꠘ ꠖꠤꠘꠞ ꠜꠤꠔꠞꠦ ꠛꠣꠘꠣꠁꠟꠤꠛꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN2_21","073_2_21","JHN","2","21","21","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠁꠘꠅ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ ꠛꠟꠔꠦ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞ ꠇꠕꠣꠃ ꠇꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN2_22","073_2_22","JHN","2","22","22","ꠄꠞꠟꠣꠉꠤ ꠁꠍꠣ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠝꠘꠅ ꠅꠁꠍꠤꠟ, ꠔꠣꠁꠘ ꠅꠃ ꠇꠕꠣꠃ ꠇꠁꠍꠟꠣ। ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠇꠕꠣ ꠀꠞ ꠁꠍꠣꠄ ꠎꠦꠔꠣ ꠇꠁꠍꠟꠣ, ꠅꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN2_23","073_2_23","JHN","2","23","23","ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠡꠝꠄ ꠁꠍꠣꠄ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠞꠁꠀ ꠎꠦꠔꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠍꠤꠟꠣ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟ। ");
INSERT INTO syls_vpl VALUES ("JN2_24","073_2_24","JHN","2","24","24","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠘꠤꠎꠞꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠗꠞꠣ ꠖꠤꠟꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠌꠤꠘꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN2_25","073_2_25","JHN","2","25","25","ꠝꠣꠘꠡꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠘ ꠇꠥꠘꠥ ꠡꠣꠇ꠆ꠇꠤꠞ ꠎꠞꠥꠞ ꠀꠍꠤꠟ ꠘꠣ, ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠖꠤꠟꠞ ꠈꠛꠞ ꠎꠣꠘꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_1","073_3_1","JHN","3","1","1","ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠘꠤꠇꠖꠤꠝ ꠘꠣꠝꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠄꠇꠎꠘ ꠘꠦꠔꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_2","073_3_2","JHN","3","2","2","ꠄꠇꠖꠤꠘ ꠞꠣꠁꠔ ꠔꠣꠁꠘ ꠀꠁꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠙꠘꠦ ꠄꠇꠎꠘ ꠃꠡ꠆ꠔꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠂꠘ। ꠀꠙꠘꠦ ꠎꠦꠔꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠞꠣ, ꠀꠟ꠆ꠟꠣ ꠟꠉꠦ ꠘꠣ ꠕꠣꠇꠟꠦ ꠇꠦꠃ ꠁꠔꠣ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN3_3","073_3_3","JHN","3","3","3","ꠔꠣꠁꠘ ꠘꠤꠇꠖꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠘꠄꠀ ꠇꠞꠤ ꠎꠘꠝ ꠘꠣ ꠟꠁꠟꠦ ꠇꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠖꠦꠈꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN3_4","073_3_4","JHN","3","4","4","ꠔꠦꠃ ꠘꠤꠇꠖꠤꠝꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠘꠥꠡ ꠛꠥꠠꠣ ꠅꠁꠉꠦꠟꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠘꠝ ꠟꠄ ꠇꠤꠟꠣ? ꠖꠥꠍꠞꠣꠛꠣꠞ ꠝꠣʼꠞ ꠙꠦꠐꠅ ꠢꠣꠝꠣꠁꠀ ꠎꠘꠝ ꠟꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN3_5","073_3_5","JHN","3","5","5","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠙꠣꠘꠤ ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠥ ꠕꠣꠇꠤ ꠎꠘꠝ ꠘꠣ ꠅꠁꠟꠦ ꠇꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_6","073_3_6","JHN","3","6","6","ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡ ꠕꠣꠇꠤ ꠎꠦꠔꠣꠞ ꠎꠘꠝ ꠅꠄ, ꠁꠔꠣ ꠔ ꠈꠣꠟꠤ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡ। ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠥ ꠕꠣꠇꠤ ꠎꠦꠔꠣꠞ ꠎꠘꠝ, ꠁꠔꠣ ꠞꠥꠢꠥ। ");
INSERT INTO syls_vpl VALUES ("JN3_7","073_3_7","JHN","3","7","7","ꠀꠝꠤ ꠎꠦ ꠀꠙꠘꠣꠞꠦ ꠇꠁꠟꠣꠝ, ꠘꠄꠀ ꠇꠞꠤ ꠎꠘꠝ ꠟꠅꠀ ꠎꠞꠥꠞ, ꠄꠔꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠛꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_8","073_3_8","JHN","3","8","8","ꠛꠣꠔꠣꠡ ꠔꠣꠞ ꠎꠦꠛꠣꠄ ꠁꠌ꠆ꠍꠣ ꠅꠛꠣꠄ ꠎꠣꠄ, ꠀꠞ ꠀꠙꠘꠦ ꠔꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠂꠘ, ꠅꠁꠟꠦ ꠇꠁ ꠕꠣꠇꠤ ꠀꠄ ꠀꠞ ꠇꠁ ꠎꠣꠄ, ꠁꠈꠣꠘ ꠎꠣꠘꠂꠘ ꠘꠣ। ꠔꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠕꠣꠇꠤ ꠎꠦꠞꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠦ, ꠔꠣꠞꠣꠞ ꠛꠦꠟꠣꠄꠅ ꠅꠟꠣꠈꠣꠘ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN3_9","073_3_9","JHN","3","9","9","ꠘꠤꠇꠖꠤꠝꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁꠇꠐꠣ ꠇꠤꠟꠣ ꠅꠁꠔ ꠙꠣꠞꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN3_10","073_3_10","JHN","3","10","10","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠡ꠆ꠔꠣꠖ ꠅꠁꠀꠅ ꠁꠔꠣ ꠛꠥꠎꠂꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN3_11","073_3_11","JHN","3","11","11","ꠀꠙꠘꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠎꠣꠘꠤ ꠅꠈꠣꠘꠃ ꠇꠁ, ꠀꠞ ꠎꠦꠔꠣ ꠖꠦꠈꠍꠤ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠁ। ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠝꠣꠘꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_12","073_3_12","JHN","3","12","12","ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠟꠦ ꠎꠦꠛꠟꠣ ꠄꠇꠤꠘ ꠇꠞꠂꠘ ꠘꠣ, ꠔꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠦꠙꠣꠞ ꠇꠁꠟꠦ ꠇꠤꠟꠣ ꠄꠇꠤꠘ ꠇꠞꠛꠣ? ");
INSERT INTO syls_vpl VALUES ("JN3_13","073_3_13","JHN","3","13","13","ꠎꠦꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠕꠣꠇꠂꠘ ꠀꠞ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠀꠁꠍꠂꠘ, ꠢꠃ ꠛꠤꠘ-ꠀꠖꠝ ꠍꠣꠠꠣ ꠀꠞ ꠇꠦꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠃꠑꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_14","073_3_14","JHN","3","14","14","“ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠎꠦꠟꠣ ꠢꠣꠚꠞꠦ ꠃꠌꠣꠔ ꠔꠥꠟꠍꠤꠟꠣ, ꠅꠟꠣ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦꠅ ꠃꠌꠣꠔ ꠔꠥꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN3_15","073_3_15","JHN","3","15","15","ꠎꠣꠔꠦ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠢꠦ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠢꠣꠍꠤꠟ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("JN3_16","073_3_16","JHN","3","16","16","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠅꠔ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠟꠣ, ꠁ ꠝꠣꠄꠀꠞ ꠈꠣꠔꠤꠞꠦ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞꠦ ꠖꠣꠘ ꠇꠞꠟꠣ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠢꠦ ꠛꠤꠘꠣꠡ ꠅꠄ ꠘꠣ, ꠛꠞꠋ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠢꠣꠍꠤꠟ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("JN3_17","073_3_17","JHN","3","17","17","“ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠡꠤ ꠙꠞꠝꠣꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠝꠣꠄꠀꠞ ꠎꠘꠞꠦ ꠖꠥꠘꠤꠀꠔ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠘꠣ। ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠈꠣꠔꠤꠞꠦ ꠝꠣꠘꠡꠦ ꠎꠣꠔꠦ ꠘꠣꠎꠣꠔ ꠙꠣꠄ, ꠄꠞꠟꠣꠉꠤꠃ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN3_18","073_3_18","JHN","3","18","18","ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠔꠣꠞ ꠇꠥꠘꠥ ꠛꠤꠌꠣꠞ ꠅꠄ ꠘꠣ, ꠅꠁꠟꠦ ꠎꠦ ꠁꠝꠣꠘ ꠀꠘꠦ ꠘꠣ, ꠔꠣꠞꠦ ꠀꠉꠦꠃ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠉꠦꠍꠦ। ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠄꠇꠝꠣꠔ꠆ꠞ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠢꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_19","073_3_19","JHN","3","19","19","ꠔꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠇꠣꠞꠘ ꠖꠥꠘꠤꠀꠔ ꠘꠥꠞ ꠎꠣꠁꠞ ꠅꠁꠍꠦ। ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞ ꠛꠖ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠘꠥꠞ ꠕꠣꠇꠤ ꠀꠘ꠆ꠖꠣꠁꠞꠞꠦ ꠛꠦꠡꠤ ꠜꠣꠟꠣ ꠙꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN3_20","073_3_20","JHN","3","20","20","ꠎꠦ ꠝꠣꠘꠡꠦ ꠛꠖ ꠇꠣꠝ ꠇꠞꠦ, ꠢꠦ ꠘꠥꠞꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠔꠣꠞ ꠛꠖ ꠇꠣꠝ ꠅꠇꠟ ꠎꠣꠁꠞ ꠅꠁꠎꠤꠛ ꠇꠞꠤ ꠢꠦ ꠘꠥꠞꠞ ꠉꠦꠍꠦ ꠀꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_21","073_3_21","JHN","3","21","21","ꠅꠁꠟꠦ ꠎꠦ ꠎꠘ ꠢꠇ-ꠢꠣꠟꠣꠟꠤꠞ ꠙꠕꠦ ꠌꠟꠦ, ꠢꠦ ꠘꠥꠞꠞ ꠉꠦꠍꠦ ꠀꠄ, ꠎꠣꠔꠦ ꠔꠣꠞ ꠢꠇꠟ ꠇꠣꠝ ꠀꠟ꠆ꠟꠣꠞ ꠝꠥꠘꠡꠣ ꠝꠣꠚꠤꠇ ꠅꠁꠍꠦ ꠇꠞꠤ ꠙꠞꠝꠣꠘ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN3_22","073_3_22","JHN","3","22","22","ꠄꠞꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠄꠢꠥꠖꠤꠀ ꠄꠟꠣꠇꠣꠔ ꠀꠁꠟꠣ। ꠢꠤꠘꠅ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠇꠤꠍꠥ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠟꠣ ꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_23","073_3_23","JHN","3","23","23","ꠅꠃ ꠡꠝꠄ ꠍꠣꠟꠤꠝ ꠘꠣꠝꠞ ꠄꠇ ꠉꠣꠃꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠅꠂꠘꠥꠘ ꠘꠣꠝꠞ ꠄꠇ ꠎꠣꠉꠣꠔ ꠄꠢꠤꠀꠄꠅ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠘꠤꠔ ꠀꠍꠟꠣ। ꠢꠃ ꠎꠣꠉꠣꠔ ꠛꠃꠔ ꠙꠣꠘꠤ ꠕꠣꠇꠣꠄ ꠖꠟꠦ ꠖꠟꠦ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_24","073_3_24","JHN","3","24","24","ꠄꠢꠤꠀ ꠘꠛꠤꠞꠦ ꠅꠃ ꠡꠝꠄꠅ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_25","073_3_25","JHN","3","25","25","ꠅꠃ ꠡꠝꠄ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠛꠦꠙꠣꠞ ꠟꠁꠀ, ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠁꠢꠥꠖꠤꠞ ꠄꠇ ꠀꠟꠤꠝꠞ ꠟꠉꠦ ꠔꠞ꠆ꠇ ꠟꠣꠉꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_26","073_3_26","JHN","3","26","26","ꠛꠣꠖꠦ ꠔꠣꠁꠘ-ꠔꠣꠁꠘ ꠢꠎꠞꠔ ꠄꠢꠤꠀꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠎꠦꠁꠘ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠀꠙꠘꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ, ꠀꠞ ꠎꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠙꠘꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠟꠣ, ꠖꠦꠈꠞꠣ ꠘꠤ, ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠎꠣꠁꠞꠣꠉꠤ ꠀꠞ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠖꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN3_27","073_3_27","JHN","3","27","27","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠄꠢꠤꠀꠄ ꠇꠁꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠖꠦꠅꠀ ꠘꠣ ꠅꠁꠟꠦ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠙꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_28","073_3_28","JHN","3","28","28","ꠔꠥꠝꠞꠣꠃ ꠔ ꠢꠥꠘꠍ, ꠀꠝꠤ ꠇꠁꠍꠤ, ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠔꠣꠘ ꠀꠉꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠘꠤ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN3_29","073_3_29","JHN","3","29","29","ꠎꠣꠞ ꠉꠦꠍꠦ ꠇꠁꠘꠣꠞꠦ ꠛꠤꠀ ꠖꠦꠅꠀ ꠅꠄ, ꠄꠁꠘꠃ ꠘꠡꠣ। ꠘꠡꠣꠞ ꠖꠥꠡ꠆ꠔꠦ ꠈꠣꠟꠤ ꠃꠛꠣꠁꠀ ꠘꠡꠣꠞ ꠝꠣꠔ ꠢꠥꠘꠂꠘ ꠀꠞ ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠤꠀ ꠈꠥꠡꠤ ꠅꠁꠘ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠝꠣꠞ ꠈꠥꠡꠤꠅ ꠀꠁꠎ ꠙꠥꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN3_30","073_3_30","JHN","3","30","30","ꠔꠣꠘꠞꠦ ꠛꠠ ꠅꠁꠔꠦ ꠅꠁꠛ ꠀꠞ ꠀꠝꠤ ꠢꠞꠤ ꠎꠣꠁꠔꠣꠝ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN3_31","073_3_31","JHN","3","31","31","ꠎꠦꠁꠘ ꠃꠙꠞ ꠕꠣꠇꠤ ꠀꠁꠘ, ꠄꠁꠘ ꠢꠇꠟꠞ ꠃꠙꠞꠦ। ꠅꠁꠟꠦ ꠎꠦ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠀꠄ, ꠢꠦ ꠔ ꠖꠥꠘꠤꠀꠞ, ꠢꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠔꠃ ꠝꠣꠔꠦ। ꠎꠦꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠀꠁꠘ, ꠔꠣꠘ ꠀꠡꠘ ꠢꠇꠟꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("JN3_32","073_3_32","JHN","3","32","32","ꠔꠣꠁꠘ ꠢꠘꠅ ꠎꠦꠔꠣ ꠖꠦꠈꠍꠂꠘ ꠀꠞ ꠢꠥꠘꠍꠂꠘ, ꠅꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤꠃ ꠖꠦꠁꠘ। ꠇꠦꠃ ꠔꠣꠘ ꠡꠣꠇ꠆ꠇꠤ ꠝꠣꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_33","073_3_33","JHN","3","33","33","ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠔꠣꠘ ꠡꠣꠇ꠆ꠇꠤ ꠇꠛꠥꠟ ꠇꠞꠍꠦ, ꠢꠦ ꠅꠈꠣꠘ ꠖꠤꠀꠃ ꠙꠞꠝꠣꠘ ꠇꠞꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠃ ꠢꠣꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("JN3_34","073_3_34","JHN","3","34","34","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠘꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠃ ꠛꠣꠔꠣꠁꠘ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠞꠤꠀ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN3_35","073_3_35","JHN","3","35","35","ꠛꠣꠚꠦ ꠔꠣꠘ ꠙꠥꠔꠞꠦ, ꠝꠣꠘꠤ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠂꠘ ꠀꠞ ꠔꠣꠘ ꠀꠔꠅꠃ ꠢꠇꠟꠔꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN3_36","073_3_36","JHN","3","36","36","ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ, ꠢꠦ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠟꠤꠍꠦ। ꠅꠁꠟꠦ ꠎꠦ ꠔꠣꠘꠞꠦ ꠝꠣꠘꠦ ꠘꠣ, ꠢꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠈꠦꠞ ꠙꠣꠁꠔ ꠘꠣꠄ ꠛꠞꠋ ꠔꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛ ꠙꠠꠛ। ");
INSERT INTO syls_vpl VALUES ("JN4_1","073_4_1","JHN","4","1","1","ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠢꠥꠘꠟꠣ, ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠄꠢꠤꠀ ꠘꠛꠤ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠀꠞ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_2","073_4_2","JHN","4","2","2","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠘꠤꠎꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠞꠣ ꠘꠣ, ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦꠃ ꠇꠞꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_3","073_4_3","JHN","4","3","3","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠁ ꠈꠛꠞ ꠙꠣꠁꠀ, ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣ ꠍꠣꠠꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_4","073_4_4","JHN","4","4","4","ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠔꠣꠘꠞꠦ ꠡꠝꠞꠤꠀꠞ ꠝꠣꠎꠖꠤ ꠎꠣꠅꠀ ꠟꠣꠉꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN4_5","073_4_5","JHN","4","5","5","ꠙꠕꠅ ꠔꠣꠁꠘ ꠡꠝꠞꠤꠀꠞ ꠡꠥꠈꠣꠞ ꠘꠣꠝꠞ ꠄꠇ ꠉꠣꠃꠞ ꠗꠣꠞꠅ ꠀꠁꠟꠣ। ꠢꠎꠞꠔ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠙꠥꠀ ꠁꠃꠍꠥꠚꠞꠦ ꠎꠦ ꠎꠝꠤꠘ ꠖꠣꠘ ꠇꠞꠍꠟꠣ, ꠅꠃ ꠎꠝꠤꠘꠈꠣꠘ ꠀꠍꠤꠟ ꠢꠃ ꠉꠣꠃꠞ ꠗꠣꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN4_6","073_4_6","JHN","4","6","6","ꠁ ꠎꠝꠤꠘꠅ ꠢꠎꠞꠔ ꠁꠀꠇꠥꠛꠞ ꠇꠥꠀ ꠀꠍꠤꠟ। ꠁꠍꠣ ꠀꠐꠔꠦ ꠀꠐꠔꠦ ꠢꠦꠞꠣꠘ ꠅꠁꠀ ꠅꠃ ꠇꠥꠀꠞ ꠇꠣꠍꠣꠔ ꠎꠤꠞꠣꠁꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁꠚꠞ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN4_7","073_4_7","JHN","4","7","8","ꠄꠞꠝꠣꠎꠦ ꠡꠝꠞꠤꠀ ꠎꠣꠔꠤꠞ ꠄꠇ ꠛꠦꠐꠤꠄ ꠙꠣꠘꠤ ꠔꠥꠟꠣꠔ ꠀꠁꠟ, ꠀꠞ ꠇꠥꠀꠞ ꠇꠣꠍꠣꠔ ꠁꠍꠣ ꠄꠇꠟꠣ ꠀꠍꠟꠣ, ꠇꠣꠞꠘ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠈꠣꠘꠤ-ꠙꠣꠘꠤ ꠟꠅꠀꠞ ꠟꠣꠉꠤ ꠛꠣꠎꠣꠞꠅ ꠉꠦꠍꠟꠣꠉꠤ। ꠁꠍꠣꠄ ꠔꠣꠁꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠁ, ꠀꠝꠣꠞꠦ ꠕꠥꠠꠣ ꠙꠣꠘꠤ ꠈꠣꠅꠀꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN4_9","073_4_9","JHN","4","9","9","ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠀꠝꠤ ꠔ ꠡꠝꠞꠤꠀ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ। ꠀꠙꠘꠦ ꠄꠇꠎꠘ ꠁꠢꠥꠖꠤ ꠅꠁꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠘꠤ ꠌꠣꠁꠞꠣ ꠇꠤꠟꠣ?” ꠛꠦꠐꠤꠄ ꠁꠈꠣꠘ ꠇꠁꠟ, ꠇꠣꠞꠘ ꠡꠝꠞꠤꠀ ꠎꠣꠔꠤꠞ ꠟꠉꠦ ꠁꠢꠥꠖꠤ ꠝꠣꠘꠡꠞ ꠇꠥꠘꠥꠎꠣꠔ ꠝꠤꠟ-ꠝꠤꠡ ꠛꠣ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_10","073_4_10","JHN","4","10","10","ꠁꠍꠣꠄ ꠔꠣꠁꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠎꠣꠘꠔꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠖꠣꠘ ꠇꠤꠔꠣ, ꠀꠞ ꠇꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠘꠤ ꠌꠣꠁꠞꠣ, ꠔꠦ ꠔꠥꠝꠤ ꠘꠤꠎꠦꠃ ꠔꠣꠘ ꠉꠦꠍꠦ ꠙꠣꠘꠤ ꠌꠣꠁꠟꠣꠄ ꠅꠘꠦ, ꠀꠞ ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠙꠣꠘꠤ ꠖꠤꠟꠣ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN4_11","073_4_11","JHN","4","11","11","ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠍꠣꠛ, ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠔ ꠙꠣꠘꠤ ꠔꠥꠟꠣꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ, ꠀꠞ ꠁ ꠇꠥꠀꠅ ꠉꠁꠘ। ꠔꠦ ꠎꠤꠘ꠆ꠖꠣ ꠙꠣꠘꠤ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠙꠣꠁꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("JN4_12","073_4_12","JHN","4","12","12","ꠀꠙꠘꠦ ꠇꠥꠘꠥ ꠀꠝꠞꠣꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ ꠁꠀꠇꠥꠛ ꠘꠛꠤ ꠕꠣꠇꠤ ꠛꠠ ꠘꠤ? ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠁ ꠇꠥꠀ ꠈꠥꠖꠤꠍꠟꠣ। ꠔꠣꠁꠘ ꠀꠞ ꠔꠣꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠦꠅ ꠅꠃ ꠇꠥꠀꠞ ꠙꠣꠘꠤ ꠈꠣꠁꠔꠣ, ꠀꠞ ꠔꠣꠘ ꠙꠡꠥꠞ ꠙꠣꠟꠞꠦꠅ ꠈꠣꠅꠀꠁꠔꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN4_13","073_4_13","JHN","4","13","13","ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠎꠦ ꠎꠘꠦ ꠁ ꠇꠥꠀꠞ ꠙꠣꠘꠤ ꠈꠣꠁꠛ, ꠔꠣꠞ ꠢꠤꠞꠛꠣꠞ ꠙꠤꠀꠍ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("JN4_14","073_4_14","JHN","4","14","14","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠙꠣꠘꠤ ꠎꠦ ꠈꠣꠁꠛ, ꠔꠣꠞ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠙꠤꠀꠍ ꠟꠣꠉꠔ ꠘꠣꠄ। ꠛꠞꠋ ꠁ ꠙꠣꠘꠤ ꠔꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠏꠞꠘꠣꠞ ꠟꠣꠈꠣꠘ ꠃꠕꠟꠤꠀ ꠃꠑꠛ ꠀꠞ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN4_15","073_4_15","JHN","4","15","15","ꠔꠦꠃ ꠛꠦꠐꠤꠄ ꠁꠍꠣꠞꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠔꠦ ꠀꠝꠣꠞꠦꠅ ꠢꠃ ꠙꠣꠘꠤ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠙꠤꠀꠍ ꠘꠣ ꠟꠣꠉꠦ, ꠀꠞ ꠙꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠘꠅ ꠀꠅꠀ ꠘꠣ ꠟꠣꠉꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN4_16","073_4_16","JHN","4","16","16","ꠁꠍꠣꠄ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠎꠣꠅ, ꠔꠥꠝꠣꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠅꠘꠅ ꠟꠁꠀ ꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN4_17","073_4_17","JHN","4","17","17","ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠍꠣꠛ, ꠀꠝꠣꠞ ꠔ ꠇꠥꠘꠥ ꠎꠣꠝꠣꠁ ꠘꠣꠁ।” ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠑꠤꠇꠃ ꠇꠁꠍ, ꠔꠥꠝꠣꠞ ꠎꠣꠝꠣꠁ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN4_18","073_4_18","JHN","4","18","18","ꠇꠣꠞꠘ ꠄꠞ ꠀꠉꠦ ꠔ ꠔꠥꠝꠣꠞ ꠙꠣꠌ ꠎꠘ ꠎꠣꠝꠣꠁ ꠅꠁꠉꠦꠍꠂꠘ, ꠀꠞ ꠅꠈꠘ ꠎꠦ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠍꠦ, ꠢꠦ ꠔꠥꠝꠣꠞ ꠎꠣꠝꠣꠁ ꠘꠣꠄ। ꠔꠥꠝꠤ ꠢꠣꠍꠣ ꠇꠕꠣꠃ ꠇꠁꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN4_19","073_4_19","JHN","4","19","19","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠛꠦꠐꠤꠄ ꠁꠍꠣꠞꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠅꠈꠘ ꠀꠝꠤ ꠛꠥꠎꠟꠣꠝ, ꠀꠙꠘꠦ ꠄꠇꠎꠘ ꠘꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("JN4_20","073_4_20","JHN","4","20","20","ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠦ ꠅꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦꠃ ꠄꠛꠣꠖꠔ ꠇꠞꠔꠣ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠇꠂꠘ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅꠃ ꠝꠣꠘꠡꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠣ ꠃꠌꠤꠔ।” ");
INSERT INTO syls_vpl VALUES ("JN4_21","073_4_21","JHN","4","21","21","ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠝꠣꠔꠈꠣꠘ ꠄꠇꠤꠘ ꠇꠞꠅ। ꠖꠦꠈꠤꠅ, ꠅꠃꠟꠣ ꠡꠝꠄ ꠀꠁꠛ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣ ꠁ ꠙꠣꠠꠞ ꠃꠙꠞꠦ, ꠛꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠇꠥꠘꠥꠈꠣꠘꠅ, ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN4_22","073_4_22","JHN","4","22","22","ꠔꠥꠝꠞꠣ ꠎꠣꠞꠦ ꠌꠤꠘꠅ ꠘꠣ, ꠔꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠅ, ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠎꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠤ, ꠔꠣꠘꠞꠦ ꠀꠝꠞꠣ ꠌꠤꠘꠤ। ꠎꠣꠘ ꠘꠤ, ꠘꠣꠎꠣꠔꠞ ꠙꠕ ꠔ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤꠃ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN4_23","073_4_23","JHN","4","23","23","ꠢꠥꠘꠅ, ꠅꠟꠣ ꠡꠝꠄ ꠀꠁꠛ, ꠛꠞꠋ ꠅꠈꠘꠃ ꠀꠁꠌ꠆ꠍꠦ, ꠎꠦꠛꠟꠣ ꠀꠍꠟ ꠄꠛꠣꠖꠔꠇꠣꠞꠤ ꠅꠇꠟꠦ ꠢꠇ꠆ꠇꠣꠘꠤ ꠞꠥꠢꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠛꠣ। ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦꠅ ꠅꠟꠣꠈꠣꠘ ꠄꠛꠣꠖꠔꠇꠣꠞꠤꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN4_24","073_4_24","JHN","4","24","24","ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣ ꠅꠁꠟꠣꠉꠤ ꠞꠥꠢꠥ, ꠄꠞꠟꠣꠉꠤ ꠎꠣꠞꠣ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠛꠣ, ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠣꠘꠤ ꠞꠥꠢꠦ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN4_25","073_4_25","JHN","4","25","25","ꠛꠣꠖꠦ ꠅꠃ ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠀꠝꠤ ꠎꠣꠘꠤ, ꠀꠟ-ꠝꠍꠤ ꠀꠁꠞꠣ। ꠔꠣꠁꠘ ꠀꠁꠀ ꠢꠇꠟꠔꠣ ꠀꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN4_26","073_4_26","JHN","4","26","26","ꠁꠍꠣꠄ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠢꠦꠁꠘ, ꠎꠦꠁꠘ ꠅꠈꠘ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN4_27","073_4_27","JHN","4","27","27","ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠀꠁꠀ ꠖꠦꠈꠟꠣ, ꠁꠍꠣꠄ ꠄꠇ ꠛꠦꠐꠤꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠞꠣ, ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ꠔꠣ-ꠅ ꠔꠣꠞꠣ ꠇꠦꠃ ꠎꠤꠇꠣꠁꠟꠣ ꠘꠣ, ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠌꠣꠁꠞꠣ ꠛꠣ ꠄꠘ ꠟꠉꠦ ꠝꠣꠔꠤꠞꠣ ꠇꠦꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("JN4_28","073_4_28","JHN","4","28","28","ꠛꠣꠖꠦ ꠛꠦꠐꠤꠄ ꠔꠣꠁꠞ ꠙꠣꠘꠤꠞ ꠈꠂꠟꠣ ꠕꠁꠀ ꠉꠣꠃꠞ ꠝꠣꠘꠡꠞꠦ ꠉꠤꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("JN4_29","073_4_29","JHN","4","29","29","“ꠔꠥꠝꠞꠣ ꠀꠁꠀ ꠄꠇꠎꠘꠞꠦ ꠖꠦꠈꠤ ꠎꠣꠅ। ꠀꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠎꠦꠔꠣ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠤꠍꠂꠘ। ꠔꠦ ꠔꠣꠁꠘꠃ ꠇꠤꠔꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN4_30","073_4_30","JHN","4","30","30","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠉꠣꠃꠞ ꠝꠣꠘꠥꠡ ꠛꠣꠞ ꠅꠁꠀ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠅꠀ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_31","073_4_31","JHN","4","31","31","ꠛꠣꠖꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠅꠘꠥꠞꠥꠗ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN4_32","073_4_32","JHN","4","32","32","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠁꠟꠣ ꠈꠣꠘꠤ ꠀꠍꠦ, ꠎꠦ ꠈꠣꠘꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN4_33","073_4_33","JHN","4","33","33","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠦ ꠔꠣꠘꠞꠦ ꠇꠦꠃ ꠇꠥꠘꠥ ꠈꠣꠘꠤ ꠀꠘꠤꠀ ꠖꠤꠍꠦ ꠘꠣ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN4_34","073_4_34","JHN","4","34","34","ꠔꠦꠃ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ, ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠔꠣꠘ ꠇꠣꠝ ꠙꠥꠞꠣ ꠇꠞꠣꠃ ꠀꠝꠣꠞ ꠈꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("JN4_35","073_4_35","JHN","4","35","35","“ꠔꠥꠝꠞꠣ ꠇꠅ ꠘꠣ ꠘꠤ, ‘ꠀꠞ ꠌꠣꠁꠞ ꠝꠣꠡ ꠛꠣꠖꠦꠃ ꠚꠡꠟ ꠇꠣꠐꠣꠞ ꠡꠝꠄ ꠀꠁꠛ’? ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠜꠣꠟꠣ ꠇꠞꠤ ꠄꠇꠛꠣꠞ ꠈꠦꠔꠦꠖꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠅ, ꠚꠡꠟ ꠙꠣꠇꠤꠀ ꠇꠣꠐꠣꠞ ꠎꠥꠇꠣ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN4_36","073_4_36","JHN","4","36","36","ꠚꠡꠟ ꠇꠣꠐꠞꠣꠄ ꠅꠈꠘꠃ ꠛꠦꠔꠘ ꠙꠣꠁꠞꠣ ꠀꠞ ꠀꠈꠦꠞꠞ ꠟꠣꠉꠤ ꠚꠡꠟ ꠖꠟꠣ ꠇꠞꠞꠣ। ꠄꠞꠟꠣꠉꠤ ꠎꠦꠁꠘ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠖꠦꠁꠘ ꠀꠞ ꠎꠦꠁꠘ ꠚꠡꠟ ꠇꠣꠐꠂꠘ, ꠖꠥꠁꠅꠎꠘꠃ ꠢꠝꠣꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("JN4_37","073_4_37","JHN","4","37","37","ꠄꠔꠦ ꠅꠃ ꠍꠤꠟ꠆ꠟꠦꠈꠞ ꠙꠞꠝꠣꠘ ꠅꠄ, ‘ꠄꠇꠎꠘꠦ ꠛꠣꠁꠘ ꠖꠦꠁꠘ, ꠀꠞꠇ ꠎꠘꠦ ꠇꠣꠐꠂꠘ।’ ");
INSERT INTO syls_vpl VALUES ("JN4_38","073_4_38","JHN","4","38","38","ꠀꠝꠤꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠚꠡꠟ ꠇꠣꠐꠣꠔ ꠙꠣꠑꠣꠁꠍꠤ, ꠎꠦ ꠚꠡꠟꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠝꠦꠘꠔ ꠇꠞꠍ ꠘꠣ। ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠦ ꠝꠦꠘꠔ ꠇꠞꠍꠦ ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠃ ꠝꠦꠘꠔꠞ ꠚꠡꠟ ꠇꠣꠐꠤꠍ।” ");
INSERT INTO syls_vpl VALUES ("JN4_39","073_4_39","JHN","4","39","39","ꠎꠦ ꠛꠦꠐꠤꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠢꠇꠟꠔꠣ ꠁꠍꠣꠄ ꠇꠁꠟꠤꠍꠂꠘ, ꠅꠃ ꠛꠦꠐꠤꠞ ꠡꠣꠇ꠆ꠇꠤ ꠢꠥꠘꠤꠀ ꠢꠃ ꠉꠣꠃꠞ ꠛꠃꠔ ꠡꠝꠞꠤꠀ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_40","073_4_40","JHN","4","40","40","ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠉꠤꠀ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, ꠔꠣꠞꠣꠞ ꠅꠈꠣꠘꠅ ꠞꠁꠛꠣꠞ ꠟꠣꠉꠤ। ꠄꠞꠖꠣꠄ ꠔꠣꠁꠘ ꠖꠥꠁ ꠖꠤꠘ ꠢꠘꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_41","073_4_41","JHN","4","41","41","ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_42","073_4_42","JHN","4","42","42","ꠀꠞ ꠉꠣꠃꠞ ꠝꠣꠘꠡꠦ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠇꠕꠣꠄ ꠀꠝꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠤ ꠘꠣ, ꠀꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠔꠣꠘ ꠝꠣꠔ ꠢꠥꠘꠤꠀ ꠛꠥꠎꠔꠣꠝ ꠙꠣꠞꠍꠤ, ꠄꠁꠘꠃ ꠎꠉꠔꠞ ꠀꠍꠟ ꠔꠞꠣꠘꠦꠀꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN4_43","073_4_43","JHN","4","43","43","ꠡꠝꠞꠤꠀꠔ ꠖꠥꠁꠖꠤꠘ ꠞꠁꠀ ꠢꠣꠞꠤ ꠢꠎꠞꠔ ꠁꠍꠣ ꠘꠤꠎꠞ ꠛꠣꠠꠤ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN4_44","073_4_44","JHN","4","44","44","ꠎꠥꠖꠤꠅ ꠔꠣꠁꠘ ꠀꠉꠦ ꠇꠁꠍꠟꠣ, ꠇꠥꠘꠥ ꠘꠛꠤꠞꠦꠃ ꠘꠤꠎꠞ ꠖꠦꠡꠅ ꠖꠣꠝ ꠖꠦꠅꠀ ꠅꠄ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("JN4_45","073_4_45","JHN","4","45","45","ꠔꠦꠛꠃ ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠟꠣ। ꠇꠣꠞꠘ ꠁꠖꠞ ꠡꠝꠄ ꠁꠍꠣꠄ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠦꠔꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠍꠟꠣ, ꠉꠣꠟꠤꠟꠞ ꠝꠣꠘꠥꠡ ꠢꠘꠅ ꠕꠣꠇꠣꠄ ꠔꠣꠞꠣ ꠁꠔꠣ ꠖꠦꠈꠍꠟꠣ ꠇꠞꠤ ꠔꠣꠁꠘ ꠉꠣꠟꠤꠟꠅ ꠀꠁꠟꠦ ꠔꠣꠞꠣ ꠇꠛꠥꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_46","073_4_46","JHN","4","46","46","ꠛꠣꠖꠦ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠉꠣꠟꠤꠟꠞ ꠇꠣꠘ꠆ꠘꠣ ꠉꠣꠃꠔ ꠉꠦꠟꠣ। ꠅꠘꠅꠃ ꠔꠣꠁꠘ ꠙꠣꠘꠤꠞꠦ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠛꠣꠘꠣꠁꠍꠟꠣ। ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠄꠇ ꠡꠞꠇꠣꠞꠤ ꠅꠚꠤꠡꠣꠞꠞ ꠙꠥꠀ ꠈꠥꠛ ꠛꠦꠝꠣꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN4_47","073_4_47","JHN","4","47","47","ꠢꠎꠞꠔ ꠁꠍꠣ ꠄꠢꠥꠖꠤꠀ ꠕꠣꠇꠤ ꠉꠣꠟꠤꠟ ꠀꠁꠍꠂꠘ ꠢꠥꠘꠤꠀ, ꠅꠃ ꠅꠚꠤꠡꠣꠞ ꠔꠣꠘ ꠉꠦꠍꠦ ꠉꠤꠀ ꠝꠤꠘꠔ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠇꠚꠞꠘꠣꠃꠝ ꠉꠤꠀ ꠄꠘ ꠙꠥꠀꠉꠥꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠂꠘ। ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠙꠥꠀ ꠝꠞꠣꠞ ꠙꠕꠤ ꠅꠁꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN4_48","073_4_48","JHN","4","48","48","ꠁꠍꠣꠄ ꠅꠃ ꠅꠚꠤꠡꠣꠞꠞꠦ ꠇꠁꠟꠣ, “ꠇꠥꠘꠥ ꠘꠤꠡꠣꠘꠣ ꠛꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠘꠣ ꠖꠦꠈꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠁꠝꠣꠘ ꠀꠘꠔꠣ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN4_49","073_4_49","JHN","4","49","49","ꠔꠦꠃ ꠅꠚꠤꠡꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠖꠄꠀ ꠇꠞꠤ ꠎꠟꠖꠤ ꠀꠃꠇ꠆ꠇꠣ, ꠙꠥꠀꠉꠥꠞ ꠎꠣꠘ ꠕꠣꠇꠔꠦ ꠀꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN4_50","073_4_50","JHN","4","50","50","ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠎꠣꠃꠇ꠆ꠇꠣꠉꠤ, ꠀꠙꠘꠣꠞ ꠙꠥꠀ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍꠦ।” ꠁꠍꠣꠞ ꠇꠕꠣ ꠄꠇꠤꠘ ꠇꠞꠤꠀ ꠄꠁꠘ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN4_51","073_4_51","JHN","4","51","51","ꠢꠣꠍꠣꠃ, ꠢꠃ ꠅꠚꠤꠡꠣꠞ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠀꠞ ꠙꠕꠦ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠀꠁꠀ ꠈꠛꠞ ꠇꠁꠟ, “ꠍꠣꠛ, ꠀꠙꠘꠣꠞ ꠙꠥꠀꠞ ꠛꠦꠝꠣꠞ ꠇꠝꠤꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN4_52","073_4_52","JHN","4","52","52","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠦ ꠇꠥꠘ ꠡꠝꠄ ꠜꠣꠟꠣ ꠅꠁꠍꠦ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠇꠣꠁꠟ ꠖꠥꠁꠚꠞ ꠕꠣꠇꠤ ꠔꠣꠘ ꠔꠣꠙ ꠍꠣꠠꠤ ꠖꠤꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN4_53","073_4_53","JHN","4","53","53","ꠔꠦꠃ ꠅꠚꠤꠡꠣꠞꠞ ꠝꠘꠅ ꠅꠁꠟ, ꠑꠤꠇ ꠖꠥꠁꠚꠞꠤ ꠛꠣꠟꠣ ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠍꠟꠣ, “ꠀꠙꠘꠦ ꠎꠣꠃꠇ꠆ꠇꠣꠉꠤ, ꠀꠙꠘꠣꠞ ꠙꠥꠀ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍꠦ।” ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠅꠚꠤꠡꠣꠞ ꠀꠞ ꠔꠣꠘ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠦ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN4_54","073_4_54","JHN","4","54","54","ꠢꠎꠞꠔ ꠁꠍꠣ ꠄꠢꠥꠖꠤꠀ ꠕꠘꠦ ꠉꠣꠟꠤꠟꠅ ꠀꠅꠀꠞ ꠛꠣꠖꠦ ꠅꠃ ꠖꠥꠍꠞꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_1","073_5_1","JHN","5","1","1","ꠁꠔꠣꠞ ꠛꠣꠖꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠁꠖꠞ ꠡꠝꠄ ꠀꠁꠟꠦ ꠁꠍꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN5_2","073_5_2","JHN","5","2","2","ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠝꠦꠠꠣ-ꠖꠞꠎꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠄꠇꠐꠣ ꠙꠥꠞꠇꠤ ꠀꠍꠤꠟ, ꠅꠃ ꠙꠥꠞꠇꠤꠔ ꠍꠤꠠꠤ ꠛꠣꠘ꠆ꠖꠣ ꠙꠣꠌꠈꠣꠘ ꠊꠣꠐ ꠀꠍꠤꠟ, ꠙꠣꠌꠅ ꠊꠣꠐꠞ ꠃꠙꠞꠦ ꠙꠣꠌꠈꠣꠘ ꠍꠣꠃꠘꠤ। ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠁ ꠙꠥꠞꠇꠤꠞ ꠘꠣꠝ ꠛꠣꠄꠔ-ꠍꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_3","073_5_3","JHN","5","3","3","ꠅꠃ ꠊꠣꠐꠅ ꠛꠃꠔ ꠎꠣꠔꠞ ꠛꠦꠝꠣꠞꠤ ꠙꠠꠤ ꠞꠁꠔ। ꠟꠥꠟꠣ-ꠟꠦꠋꠠꠣ, ꠀꠘ꠆ꠖꠣ, ꠀꠞ ꠛꠦꠝꠣꠞꠦ ꠎꠦꠞꠣꠞ ꠡꠞꠤꠟ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠢꠥꠇꠣꠁ ꠉꠦꠍꠦ, ꠔꠣꠞꠣꠅ ꠅꠘꠅ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("JN5_4","073_5_4","JHN","5","4","4","ꠝꠣꠎꠦ ꠝꠣꠎꠦ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠁꠀ ꠅꠃ ꠙꠥꠞꠇꠤꠞ ꠙꠣꠘꠤ ꠟꠣꠠꠣꠁꠔꠣ, ꠟꠣꠠꠣꠘꠤꠞ ꠛꠣꠖꠦꠃ ꠙꠄꠟꠣ ꠎꠦ ꠎꠘ ꠙꠣꠘꠤꠔ ꠟꠣꠝꠔ, ꠔꠣꠞ ꠎꠔ ꠛꠠ ꠛꠦꠝꠣꠞ ꠅꠃꠇ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠔ। ꠄꠞꠖꠣꠄ ꠅꠃ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠦ ꠙꠣꠘꠤ ꠟꠣꠠꠣꠘꠤꠞ ꠀꠡꠣꠄ ꠅꠘꠅ ꠙꠠꠤ ꠞꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("JN5_5","073_5_5","JHN","5","5","5","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠟꠣ ꠄꠇꠎꠘ ꠛꠦꠝꠣꠞꠤ ꠀꠍꠤꠟ, ꠎꠦ ꠛꠦꠐꠣ ꠀꠐꠔꠤꠡ ꠛꠍꠞ ꠕꠣꠇꠤ ꠛꠦꠝꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("JN5_6","073_5_6","JHN","5","6","6","ꠛꠃꠔ ꠖꠤꠘ ꠕꠣꠇꠤ ꠢꠦ ꠅꠘꠅ ꠙꠠꠤ ꠞꠁꠍꠦ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠔꠥꠝꠣꠞ ꠁꠌ꠆ꠍꠣ ꠘꠤ ꠔꠥꠝꠤ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠔꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("JN5_7","073_5_7","JHN","5","7","7","ꠛꠦꠐꠣꠄ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠣꠞ ꠔ ꠁꠟꠣ ꠇꠦꠃ ꠘꠣꠁ, ꠎꠦꠁꠘ ꠙꠣꠘꠤ ꠟꠣꠠꠣꠘꠤꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠀꠝꠣꠞꠦ ꠙꠥꠞꠇꠤꠔ ꠟꠣꠝꠣꠁꠔ। ꠀꠝꠤ ꠟꠣꠝꠔꠦ ꠟꠣꠝꠔꠦ ꠀꠞꠇ ꠎꠘ ꠉꠤꠀ ꠟꠣꠝꠤ ꠎꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN5_8","073_5_8","JHN","5","8","8","ꠁꠍꠣꠄ ꠄꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠃꠑꠅ, ꠔꠥꠝꠣꠞ ꠛꠤꠍꠘꠣ ꠟꠁꠀ ꠀꠐꠣ-ꠌꠟꠣ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN5_9","073_5_9","JHN","5","9","9","ꠟꠉꠦ ꠟꠉꠦꠃ ꠅꠃ ꠛꠦꠝꠣꠞꠤ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ, ꠀꠞ ꠔꠣꠞ ꠛꠤꠍꠘꠣ ꠔꠥꠟꠤꠀ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠟ। ꠢꠤ ꠖꠤꠘ ꠀꠍꠤꠟ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ, ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ ꠇꠞꠣ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN5_10","073_5_10","JHN","5","10","10","ꠄꠞꠖꠣꠄ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠁꠎ ꠔ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ, ꠔꠦ ꠀꠁꠎ ꠔꠥꠝꠣꠞ ꠛꠤꠍꠘꠣ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀ ꠎꠣꠁꠎ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN5_11","073_5_11","JHN","5","11","11","ꠅꠁꠟꠦ ꠢꠦ ꠇꠁꠟ, “ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠃꠑꠅ, ꠔꠥꠝꠣꠞ ꠛꠤꠍꠘꠣ ꠟꠁꠀ ꠀꠐꠣ-ꠌꠟꠣ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN5_12","073_5_12","JHN","5","12","12","ꠔꠦꠃ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠛꠦꠐꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠃ ꠝꠣꠘꠥꠡꠉꠥ ꠇꠦꠉꠥ, ꠎꠦꠉꠤꠄ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠍꠦ, ꠛꠤꠍꠘꠣ ꠟꠁꠀ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠔꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("JN5_13","073_5_13","JHN","5","13","13","ꠅꠁꠟꠦ ꠅꠃ ꠛꠦꠐꠣꠄ ꠔ ꠎꠣꠘꠔ ꠘꠣ, ꠔꠣꠁꠘ ꠇꠦ, ꠢꠤ ꠎꠣꠉꠣꠔ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠜꠤꠠ ꠇꠞꠤꠟꠤꠍꠂꠘ ꠖꠦꠈꠤꠀ, ꠁꠍꠣ ꠢꠤꠘ ꠕꠘꠦ ꠉꠦꠍꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN5_14","073_5_14","JHN","5","14","14","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠙꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠔ ꠛꠦꠝꠣꠞ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠍ। ꠔꠦ ꠀꠞ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠘꠣ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN5_15","073_5_15","JHN","5","15","15","ꠔꠦꠃ ꠅꠃ ꠛꠦꠐꠣꠄ ꠉꠤꠀ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠟ, ꠔꠣꠞꠦ ꠎꠦꠁꠘ ꠜꠣꠟꠣ ꠇꠞꠍꠂꠘ ꠄꠘ ꠘꠣꠝ ꠁꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_16","073_5_16","JHN","5","16","16","ꠁꠍꠣꠄ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠣꠄ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_17","073_5_17","JHN","5","17","17","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠢꠣꠝꠦꠡꠣ ꠇꠣꠝ ꠇꠞꠞꠣ ꠀꠞ ꠀꠝꠤꠅ ꠇꠞꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN5_18","073_5_18","JHN","5","18","18","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠉꠞꠝ ꠅꠁꠀ ꠙꠕ ꠔꠥꠇꠣꠘꠤꠔ ꠞꠁꠟꠣ। ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠍꠤꠟ, ꠔꠣꠁꠘ ꠈꠣꠟꠤ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠘꠤꠅꠝ ꠜꠣꠋꠉꠤꠍꠂꠘ ꠘꠣ, ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠛꠣꠚ ꠒꠣꠇꠤꠀ ꠡꠤꠞꠤꠇꠤꠅ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN5_19","073_5_19","JHN","5","19","19","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠅꠃ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠘꠤꠌ꠆ꠌꠤꠔ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠙꠥꠔꠦ ꠔ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠣꠘ ꠛꠣꠚꠞꠦ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠣꠔ ꠖꠦꠈꠂꠘ, ꠔꠣꠁꠘ ꠈꠣꠟꠤ ꠅꠔꠣꠃ ꠇꠞꠂꠘ, ꠛꠣꠚꠦ ꠎꠦꠔꠣ ꠇꠞꠂꠘ, ꠙꠥꠔꠦꠅ ꠔ ꠅꠔꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN5_20","073_5_20","JHN","5","20","20","ꠛꠣꠚꠦ ꠔꠣꠘ ꠙꠥꠔꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠂꠘ ꠀꠞ ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠎꠦ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠙꠥꠔꠞꠦ ꠖꠦꠈꠣꠁꠘ। ꠀꠞ ꠁꠔꠣ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠠ ꠛꠠ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠙꠥꠔꠞꠦ ꠖꠦꠈꠣꠁꠛꠣ, ꠎꠦꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠙꠘꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_21","073_5_21","JHN","5","21","21","ꠛꠣꠚꠦ ꠎꠦꠟꠣ ꠝꠥꠞ꠆ꠖꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠂꠘ, ꠙꠥꠔꠦꠅ ꠅꠃꠟꠣ ꠎꠦꠞꠣꠞꠦ ꠁꠌ꠆ꠍꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN5_22","073_5_22","JHN","5","22","22","ꠛꠣꠚꠦ ꠇꠦꠃꠞꠞ ꠛꠤꠌꠣꠞꠅ ꠇꠞꠂꠘ ꠘꠣ, ꠔꠣꠘ ꠢꠇꠟ ꠛꠤꠌꠣꠞꠞ ꠜꠣꠞ ꠙꠥꠔꠞ ꠀꠔꠅ ꠖꠤꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("JN5_23","073_5_23","JHN","5","23","23","ꠎꠣꠔꠦ ꠛꠣꠚꠞꠦ ꠎꠦꠟꠣ ꠢꠇꠟꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠦ, ꠅꠃꠟꠣ ꠙꠥꠔꠞꠦꠅ ꠁꠎ꠆ꠎꠔ ꠇꠞꠦ। ꠙꠥꠔꠞꠦ ꠎꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠦ ꠘꠣ, ꠢꠦ ꠀꠍꠟꠦ ꠢꠃ ꠛꠣꠚꠞꠦꠅ ꠁꠎ꠆ꠎꠔ ꠇꠞꠦ ꠘꠣ, ꠎꠦꠁꠘ ꠁ ꠙꠥꠔꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN5_24","073_5_24","JHN","5","24","24","“ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ ꠀꠞ ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠢꠦ ꠔ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠟꠤꠍꠦ। ꠔꠣꠞꠦ ꠀꠞ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠔ ꠘꠣꠄ। ꠢꠦ ꠔ ꠝꠃꠔ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠙꠣꠠꠤ ꠖꠤꠟꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN5_25","073_5_25","JHN","5","25","25","ꠀꠞ ꠀꠝꠤ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠁꠟꠣ ꠄꠇ ꠎꠝꠣꠘꠣ ꠀꠁꠛ, ꠛꠞꠋ ꠅꠈꠘꠃ ꠀꠁꠌ꠆ꠍꠦ, ꠎꠦꠛꠟꠣ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠦ ꠀꠝꠤ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠛꠣ, ꠀꠞ ꠎꠣꠞꠣ ꠢꠥꠘꠛꠣ ꠔꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_26","073_5_26","JHN","5","26","26","ꠁꠔꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠛꠣꠚ ꠘꠤꠎꠦ ꠎꠦꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠝꠣꠟꠤꠇ, ꠔꠣꠘ ꠙꠥꠔꠞꠦꠅ ꠅꠃꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN5_27","073_5_27","JHN","5","27","27","ꠛꠣꠚꠦ ꠙꠥꠔꠞꠦ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠖꠤꠍꠂꠘ, ꠇꠣꠞꠘ ꠄꠁꠘꠃ ꠔ ꠛꠤꠘ-ꠀꠖꠝ। ");
INSERT INTO syls_vpl VALUES ("JN5_28","073_5_28","JHN","5","28","28","ꠔꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠀꠙꠘꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠛꠣ ꠘꠣ, ꠎꠣꠘꠂꠘ ꠘꠤ, ꠅꠃꠟꠣ ꠡꠝꠄ ꠀꠁꠅꠞ, ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠙꠥꠔꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠤꠀ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_29","073_5_29","JHN","5","29","29","ꠀꠞ ꠎꠦꠞꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠍꠂꠘ, ꠔꠣꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠃꠑꠛꠣ, ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠍꠦ, ꠔꠣꠞꠣ ꠃꠑꠛꠣ ꠡꠣꠎꠣ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN5_30","073_5_30","JHN","5","30","30","“ꠀꠝꠤ ꠔ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ, ꠀꠝꠤ ꠎꠦꠟꠣ ꠢꠥꠘꠤ ꠅꠟꠣ ꠛꠤꠌꠣꠞ ꠇꠞꠤ। ꠀꠝꠤ ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠤ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠁꠌ꠆ꠍꠣꠄ ꠇꠣꠝ ꠇꠞꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠈꠣꠟꠤ ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠙꠥꠞꠣ ꠇꠞꠔꠣꠝ ꠌꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN5_31","073_5_31","JHN","5","31","31","“ꠀꠝꠤ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠘꠤꠎꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠁ, ꠔꠦ ꠁ ꠡꠣꠇ꠆ꠇꠤ ꠡꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN5_32","073_5_32","JHN","5","32","32","ꠅꠁꠟꠦ ꠖꠥꠍꠞꠣ ꠎꠘꠦꠅ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ, ꠀꠞ ꠀꠝꠤ ꠎꠣꠘꠤ, ꠔꠣꠁꠘ ꠎꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ, ꠁꠔꠣ ꠢꠣꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_33","073_5_33","JHN","5","33","33","ꠀꠙꠘꠣꠞꠣ ꠔ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠀ ꠎꠤꠇꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘꠅ ꠢꠇꠞ ꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN5_34","073_5_34","JHN","5","34","34","ꠀꠞ ꠀꠝꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠡꠣꠇ꠆ꠇꠤꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠎꠣꠔꠦ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠀ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠄꠞꠖꠣꠄ ꠁꠔꠣ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN5_35","073_5_35","JHN","5","35","35","ꠢꠎꠞꠔ ꠄꠢꠤꠀꠃ ꠀꠍꠟꠣ ꠢꠃ ꠎꠣꠟꠣꠁꠟ ꠝꠥꠡꠣꠟ, ꠎꠦ ꠝꠥꠡꠣꠟꠦ ꠚꠞ ꠖꠤꠍꠤꠟ। ꠀꠙꠘꠣꠞꠣꠅ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠅꠃ ꠝꠥꠡꠣꠟꠞ ꠚꠞꠞ ꠝꠣꠎꠦ ꠈꠥꠡꠤ ꠇꠞꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_36","073_5_36","JHN","5","36","36","“ꠅꠁꠟꠦ ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠡꠣꠇ꠆ꠇꠤ ꠕꠘꠦꠅ ꠀꠞꠅ ꠛꠠ ꠡꠣꠇ꠆ꠇꠤ ꠀꠝꠣꠞ ꠀꠍꠦ, ꠇꠣꠞꠘ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠎꠦ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠀꠝꠤ ꠅꠔꠣꠃ ꠇꠞꠞꠣꠝ। ꠀꠞ ꠅꠃ ꠇꠣꠝꠞ ꠡꠣꠇ꠆ꠇꠤꠄꠃ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠝꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠛꠦꠎꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN5_37","073_5_37","JHN","5","37","37","ꠔꠣꠁꠘꠃ ꠔ ꠢꠃ ꠛꠣꠛꠣ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠘꠤꠎꠦꠅ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ। ꠀꠙꠘꠣꠞꠣ ꠇꠥꠘꠥ ꠡꠝꠄ ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠍꠂꠘ ꠘꠣ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠍꠂꠘꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_38","073_5_38","JHN","5","38","38","ꠄꠍꠣꠠꠣ ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠔ ꠀꠙꠘꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠞꠄ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠎꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠄꠘ ꠃꠙꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_39","073_5_39","JHN","5","39","39","“ꠀꠙꠘꠣꠞꠣ ꠔ ꠈꠥꠛ ꠝꠘ ꠖꠤꠀ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠂꠘ, ꠝꠘꠅ ꠇꠞꠂꠘ ꠁꠔꠣ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠟꠦ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛꠣ। ꠅꠁꠟꠦ ꠅꠃ ꠇꠤꠔꠣꠛꠦꠃ ꠔ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("JN5_40","073_5_40","JHN","5","40","40","ꠄꠞꠛꠣꠖꠦꠅ ꠀꠙꠘꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠣ ꠌꠣꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_41","073_5_41","JHN","5","41","41","“ꠀꠝꠤ ꠔ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠞꠤꠚ ꠙꠣꠅꠀꠞ ꠀꠡꠣꠄ ꠀꠁꠍꠤ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("JN5_42","073_5_42","JHN","5","42","42","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠀꠙꠘꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠝꠢꠛ꠆ꠛꠔ ꠘꠣꠁ, ꠀꠝꠤ ꠔ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠌꠤꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("JN5_43","073_5_43","JHN","5","43","43","ꠀꠝꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠘꠣꠝ ꠟꠁꠀ ꠀꠁꠍꠤ, ꠔꠣ-ꠅ ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠞꠣ ꠘꠣ। ꠅꠁꠟꠦ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠞ ꠘꠤꠎꠞ ꠘꠣꠝꠦ ꠀꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_44","073_5_44","JHN","5","44","44","ꠀꠙꠘꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠞꠤꠚ ꠙꠣꠁꠔꠣ ꠌꠣꠁꠘ, ꠅꠁꠟꠦ ꠎꠦ ꠔꠣꠞꠤꠚ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠙꠣꠅꠀ ꠎꠣꠄ, ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠂꠘ ꠘꠣ। ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠇꠦꠝꠘꠦ ꠄꠇꠤꠘ ꠇꠞꠛꠣ? ");
INSERT INTO syls_vpl VALUES ("JN5_45","073_5_45","JHN","5","45","45","ꠀꠙꠘꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠛꠣ ꠘꠣ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠛꠣꠞ ꠉꠦꠍꠦ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠖꠥꠡꠤ ꠛꠣꠘꠣꠁꠝꠥ। ꠅꠁꠟꠦ ꠎꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠃꠙꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠜꠞꠡꠣ ꠇꠞꠤ ꠀꠍꠂꠘ, ꠢꠃ ꠝꠥꠍꠣꠄꠃ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠖꠥꠡꠤ ꠇꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN5_46","073_5_46","JHN","5","46","46","ꠀꠙꠘꠣꠞꠣ ꠎꠥꠖꠤ ꠝꠥꠍꠣ ꠘꠛꠤꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠔꠣ, ꠔꠦ ꠀꠝꠣꠞꠦꠅ ꠄꠇꠤꠘ ꠇꠞꠟꠣ ꠅꠘꠦ, ꠁ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠔ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦꠃ ꠟꠦꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN5_47","073_5_47","JHN","5","47","47","ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠟꠦꠈꠣꠞꠦꠃ ꠄꠇꠤꠘ ꠇꠞꠂꠘ ꠘꠣ, ꠔꠦ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠇꠕꠣꠞꠦ ꠇꠤꠟꠣ ꠄꠇꠤꠘ ꠇꠞꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN6_1","073_6_1","JHN","6","1","1","ꠄꠞꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠉꠦꠟꠣꠉꠤ, ꠅꠃ ꠀꠅꠞꠞ ꠀꠞꠇ ꠘꠣꠝ ꠔꠤꠛꠤꠞꠤꠀ ꠀꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("JN6_2","073_6_2","JHN","6","2","2","ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠈꠞꠦ ꠅꠁꠀ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠔ ꠖꠦꠈꠍꠤꠟꠣ, ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠔꠣꠁꠘ ꠇꠤꠟꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN6_3","073_6_3","JHN","6","3","3","ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠄꠇ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_4","073_6_4","JHN","6","4","4","ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠀꠎꠣꠖꠤ ꠁꠖ ꠊꠘꠣꠁ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN6_5","073_6_5","JHN","6","5","5","ꠁꠍꠣꠄ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠃꠑꠤꠀ ꠀꠁꠞꠣ, ꠅꠃ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠚꠤꠟꠤꠚꠞꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠈꠣꠅꠀꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠞꠥꠐꠤ ꠙꠣꠁꠝꠥ ꠇꠥꠘ ꠎꠣꠉꠣꠔ?” ");
INSERT INTO syls_vpl VALUES ("JN6_6","073_6_6","JHN","6","6","6","ꠀꠍꠟꠦ ꠚꠤꠟꠤꠚꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠁꠈꠣꠘ ꠎꠤꠇꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠇꠤꠟꠣ ꠇꠤꠔꠣ ꠇꠞꠛꠣ, ꠁꠈꠣꠘ ꠔꠣꠁꠘ ꠀꠉꠦꠃ ꠎꠣꠘꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_7","073_6_7","JHN","6","7","7","ꠚꠤꠟꠤꠚꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠄꠞꠣꠞꠦ ꠕꠥꠠꠣ ꠕꠥꠠꠣ ꠈꠣꠘꠤ ꠖꠤꠟꠦꠅ ꠖꠥꠁ-ꠡ ꠖꠤꠘꠣꠞꠞ ꠞꠥꠐꠤꠄ ꠇꠥꠟꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN6_8","073_6_8","JHN","6","8","8","ꠢꠘꠅ ꠀꠘ꠆ꠖꠞꠤꠀꠍ ꠘꠣꠝꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠄꠇ ꠍꠣꠢꠣꠛꠤ ꠀꠍꠟꠣ। ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠞ ꠜꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN6_9","073_6_9","JHN","6","9","9","ꠔꠣꠁꠘ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠘꠅ ꠢꠥꠞꠥ ꠄꠇ ꠙꠥꠀꠞ ꠉꠦꠍꠦ ꠙꠣꠌꠈꠣꠘ ꠀꠐꠣꠞ ꠞꠥꠐꠤ ꠀꠞ ꠖꠥꠁꠐꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠅꠔ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠁꠔꠣꠄ ꠇꠤꠔꠣ ꠅꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("JN6_10","073_6_10","JHN","6","10","10","ꠁꠍꠣꠄ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠊꠣꠡꠞ ꠃꠙꠞꠦ ꠛꠅꠀꠁ ꠖꠦꠅ।” ꠔꠦꠃ ꠔꠣꠞꠣ ꠊꠣꠡꠞ ꠃꠙꠞꠦ ꠛꠁꠉꠦꠟꠣ। ꠁꠘꠅ ꠈꠣꠟꠤ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡꠃ ꠀꠍꠟꠣ ꠅꠘꠥꠝꠣꠘ ꠙꠣꠌ ꠀꠎꠣꠞ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("JN6_11","073_6_11","JHN","6","11","11","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠃ ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤ ꠀꠔꠅ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠄꠞꠣꠞꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣ। ꠅꠃꠟꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍꠅ ꠛꠣꠐꠤꠀ ꠖꠤꠟꠣ। ꠎꠦ ꠎꠔ ꠌꠣꠁꠟ, ꠢꠦ ꠅꠔꠈꠣꠘ ꠙꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN6_12","073_6_12","JHN","6","12","12","ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠙꠦꠐ ꠜꠞꠤ ꠈꠣꠁꠟ। ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠈꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠞꠁꠍꠦ, ꠔꠥꠝꠞꠣ ꠅꠔꠣ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠅ, ꠇꠥꠘ꠆ꠔꠣ ꠚꠣꠟꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN6_13","073_6_13","JHN","6","13","13","ꠄꠞꠣ ꠅꠃ ꠙꠣꠌꠈꠣꠘ ꠞꠥꠐꠤꠞ ꠛꠣꠠꠔꠤ ꠐꠥꠇꠞꠣꠁꠘ ꠖꠟꠣ ꠇꠞꠤꠀ ꠛꠣꠞꠅ ꠐꠥꠇꠞꠤ ꠜꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_14","073_6_14","JHN","6","14","14","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠁ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠡꠦ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠟꠣꠉꠣꠁꠟꠣ, “ꠘꠤꠌ꠆ꠌꠄ ꠄꠁꠘꠃ ꠢꠃ ꠘꠛꠤ, ꠎꠦꠁꠘ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠕꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN6_15","073_6_15","JHN","6","15","15","ꠔꠦꠃ ꠁꠍꠣꠄ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠝꠣꠘꠡꠦ ꠎꠥꠞ ꠇꠞꠤꠀ ꠔꠣꠘꠞꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠗꠞꠔ ꠌꠣꠞ। ꠅꠈꠣꠘ ꠛꠥꠎꠤꠀ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠄꠇꠟꠣꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN6_16","073_6_16","JHN","6","16","16","ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠁꠍꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠀꠅꠞꠞ ꠙꠣꠞꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_17","073_6_17","JHN","6","17","17","ꠀꠞ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠎꠣꠁꠔꠣ ꠇꠞꠤ ꠘꠣꠅ ꠟꠁꠀ ꠀꠅꠞ ꠙꠣꠠꠤ ꠖꠦꠅꠀꠔ ꠟꠣꠉꠟꠣ। ꠁ ꠡꠝꠄ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠍꠤꠟ ꠀꠞ ꠁꠍꠣꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_18","073_6_18","JHN","6","18","18","ꠀꠅꠞꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠎꠣꠁꠔꠦꠃ ꠈꠥꠛ ꠔꠥꠚꠣꠘꠤ ꠛꠣꠔꠣꠡ ꠀꠞ ꠛꠠ ꠛꠠ ꠓꠦꠃ ꠡꠥꠞꠥ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN6_19","073_6_19","JHN","6","19","19","ꠅꠘꠥꠝꠣꠘ ꠔꠤꠘ-ꠌꠣꠁꠞ ꠝꠣꠁꠟ ꠘꠣꠅ ꠛꠣꠁꠀ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠖꠦꠈꠟꠣ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦꠖꠤ ꠀꠐꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠞꠣ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠈꠥꠛ ꠒꠞꠣꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_20","073_6_20","JHN","6","20","20","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ, ꠁ ꠔ ꠀꠝꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN6_21","073_6_21","JHN","6","21","21","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠘꠣꠅꠅ ꠔꠥꠟꠔꠣ ꠌꠣꠁꠟꠣ, ꠀꠞ ꠔꠣꠞꠣ ꠎꠦ ꠎꠣꠉꠣꠔ ꠎꠣꠅꠀꠞ ꠇꠕꠣ, ꠟꠉꠦ ꠟꠉꠦ ꠘꠣꠅ ꠉꠤꠀ ꠢꠘꠅ ꠙꠃꠍꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("JN6_22","073_6_22","JHN","6","22","22","ꠀꠅꠞꠞ ꠢꠙꠣꠞꠅ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠃꠛꠣ ꠀꠍꠟꠣ, ꠛꠣꠖꠞ ꠖꠤꠘ ꠔꠣꠞꠣ ꠛꠥꠎꠟꠣ, ꠀꠉꠞ ꠖꠤꠘ ꠁꠘꠅ ꠄꠇꠈꠣꠘ ꠘꠣꠅ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠘꠣꠅ ꠀꠍꠤꠟ ꠘꠣ। ꠔꠣꠞꠣ ꠄꠅꠈꠣꠘꠅ ꠛꠥꠎꠟꠣ, ꠁꠍꠣ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠘꠣꠅꠅ ꠃꠑꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠔꠣꠞꠣ ꠄꠇꠟꠣꠃ ꠀꠅꠞ ꠙꠣꠞ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN6_23","073_6_23","JHN","6","23","23","ꠅꠁꠟꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠁꠍꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠢꠣꠞꠤ ꠝꠣꠘꠡꠞꠦ ꠞꠥꠐꠤ ꠈꠣꠅꠀꠁꠍꠟꠣ, ꠅꠃ ꠎꠣꠉꠣꠞ ꠉꠦꠍꠦ ꠔꠤꠛꠤꠞꠤꠀ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠇꠄꠈꠣꠘ ꠘꠣꠅ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN6_24","073_6_24","JHN","6","24","24","ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣ, ꠁꠍꠣ ꠛꠣ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠇꠦꠃ ꠁ ꠎꠣꠉꠣꠔ ꠘꠣꠁ, ꠅꠃ ꠔꠣꠞꠣ ꠅꠔꠣ ꠘꠣꠅꠀꠁꠘ꠆ꠔꠅ ꠃꠑꠤꠀ ꠁꠍꠣꠞ ꠔꠣꠟ꠆ꠟꠣꠡꠦ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN6_25","073_6_25","JHN","6","25","25","ꠢꠘꠅ ꠉꠤꠀ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠙꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠁꠘꠅ ꠇꠥꠘ ꠡꠝꠄ ꠀꠁꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN6_26","073_6_26","JHN","6","26","26","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠘꠤꠡꠣꠘꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠤꠀ ꠀꠝꠣꠞꠦ ꠔꠥꠇꠣꠁꠞꠣꠄ ꠘꠣ, ꠛꠞꠋ ꠙꠦꠐ ꠜꠞꠤ ꠞꠥꠐꠤ ꠈꠣꠁꠍ ꠇꠞꠤꠃ ꠔꠥꠇꠣꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN6_27","073_6_27","JHN","6","27","27","ꠅꠈꠘ ꠢꠥꠘꠅ, ꠖꠥꠘꠤꠀꠛꠤ ꠎꠦ ꠈꠣꠘꠤ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ, ꠔꠣꠞ ꠈꠞꠦ ꠊꠥꠞꠤꠀ ꠟꠣꠜ ꠇꠤꠔꠣ? ꠎꠦ ꠈꠣꠘꠤ ꠇꠥꠘꠥꠖꠤꠘ ꠘꠡ꠆ꠐ ꠅꠄ ꠘꠣ, ꠛꠞꠋ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠦ, ꠔꠣꠞ ꠈꠞꠦ ꠅꠁꠀ ꠊꠥꠞꠅ। ꠁ ꠈꠣꠘꠤ ꠔ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠝꠥ। ꠅꠃ ꠄꠈꠔꠤꠀꠞ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠀꠍꠦ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄꠃ ꠁꠔꠣꠞ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN6_28","073_6_28","JHN","6","28","28","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("JN6_29","073_6_29","JHN","6","29","29","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠃ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN6_30","073_6_30","JHN","6","30","30","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟ, “ꠔꠦ ꠀꠙꠘꠦ ꠅꠝꠘ ꠇꠤꠔꠣ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣꠁꠛꠣ, ꠎꠦꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠝꠥ? ꠀꠙꠘꠦ ꠇꠥꠘ ꠇꠣꠝ ꠇꠞꠛꠣ? ");
INSERT INTO syls_vpl VALUES ("JN6_31","073_6_31","JHN","6","31","31","ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠄ ꠔ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠣꠘ꠆ꠘꠣ ꠈꠣꠁꠍꠟꠣ। ꠙꠣꠇ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠈꠣꠘꠤ ꠈꠣꠅꠀꠁꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN6_32","073_6_32","JHN","6","32","32","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠎꠦ ꠞꠥꠐꠤ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠍꠟꠣꠄ, ꠁꠔꠣ ꠔ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠍꠟ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠞꠥꠐꠤ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN6_33","073_6_33","JHN","6","33","33","ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠢꠃ ꠞꠥꠐꠤ ꠅꠁꠟꠣ ꠅꠃ ꠎꠘ, ꠎꠦꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠀ ꠢꠣꠞꠣ ꠎꠉꠔꠞꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠦꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN6_34","073_6_34","JHN","6","34","34","ꠔꠦꠃ ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠔꠦ ꠅꠃ ꠞꠥꠐꠤꠃ ꠀꠝꠞꠣꠞꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN6_35","073_6_35","JHN","6","35","35","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠢꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠞꠥꠐꠤ। ꠎꠦ ꠎꠘ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠄ, ꠔꠣꠞ ꠇꠥꠘꠥ ꠡꠝꠄ ꠜꠥꠇ ꠟꠣꠉꠦ ꠘꠣ, ꠀꠞ ꠎꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠔꠣꠞ ꠇꠥꠘꠥ ꠡꠝꠄ ꠙꠤꠀꠍꠦꠅ ꠗꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_36","073_6_36","JHN","6","36","36","ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠥꠈꠖꠤ ꠇꠁꠍꠤꠅ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠤꠀꠅ ꠁꠝꠣꠘ ꠀꠘꠟꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_37","073_6_37","JHN","6","37","37","ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠎꠦꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠦꠁꠘ, ꠔꠣꠞꠣ ꠢꠇꠟꠃ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠛ। ꠎꠦ ꠎꠘ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠄ, ꠀꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠔꠣꠞꠦ ꠛꠣꠞꠦ ꠚꠣꠟꠣꠁꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN6_38","073_6_38","JHN","6","38","38","ꠀꠝꠤ ꠇꠥꠘꠥ ꠀꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠇꠣꠝ ꠇꠞꠣꠔ ꠀꠁꠍꠤ ꠘꠤ? ꠘꠣ, ꠛꠞꠋ ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN6_39","073_6_39","JHN","6","39","39","ꠢꠥꠘꠅ, ꠎꠦ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠘ ꠝꠥꠘꠡꠣ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠎꠦꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠤꠍꠂꠘ, ꠀꠝꠤ ꠎꠣꠘꠥ ꠄꠞꠣ ꠄꠇꠎꠘꠞꠦꠅ ꠘꠣ ꠀꠞꠣꠁ ꠛꠞꠋ ꠞꠥꠎ ꠢꠣꠡꠞꠅ ꠄꠞꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠔꠥꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("JN6_40","073_6_40","JHN","6","40","40","ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠝꠥꠘꠡꠣ ꠅꠁꠟ, ꠎꠣꠞꠣ ꠔꠣꠘ ꠙꠥꠔꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠀꠈꠦꠞ ꠙꠣꠄ। ꠀꠞ ꠀꠝꠤꠃ ꠔꠣꠞꠣꠞꠦ ꠞꠥꠎ ꠢꠣꠡꠞꠅ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN6_41","073_6_41","JHN","6","41","41","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠇꠣꠘꠣ-ꠊꠥꠡꠣ ꠟꠣꠉꠣꠁꠟꠣ। ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠀꠉꠦ ꠇꠁꠍꠟꠣ, “ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠎꠦ ꠞꠥꠐꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠦ, ꠀꠝꠤꠃ ꠢꠃ ꠞꠥꠐꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN6_42","073_6_42","JHN","6","42","42","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠇꠁꠟꠣ, “ꠅꠉꠥ ꠔ ꠁꠃꠍꠥꠚꠞ ꠙꠥꠀ ꠁꠍꠣ ꠘꠣꠄ ꠘꠤ ꠛꠣ? ꠀꠝꠞꠣ ꠔ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦꠅ ꠌꠤꠘꠤ। ꠔꠦ ꠢꠦ ꠇꠦꠝꠘꠦ ꠇꠄ, ꠢꠦ ꠛꠥꠟꠦ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN6_43","073_6_43","JHN","6","43","43","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠎꠦ ꠇꠣꠘꠣ-ꠊꠥꠡꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_44","073_6_44","JHN","6","44","44","ꠀꠝꠣꠞ ꠎꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠡꠤꠇ ꠘꠣ ꠛꠣꠘꠣꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡꠃ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ꠀꠞ ꠀꠝꠤꠃ ꠔꠣꠞꠦ ꠞꠥꠎ ꠢꠣꠡꠞꠅ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠔꠥꠟꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JN6_45","073_6_45","JHN","6","45","45","ꠎꠣꠘ ꠘꠤ, ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ‘ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠟꠤꠝ ꠟꠁꠛꠣ।’ ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍꠦ, ꠢꠃ ꠎꠘꠃ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("JN6_46","073_6_46","JHN","6","46","46","“ꠅꠃ ꠛꠣꠚꠞꠦ ꠔ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠖꠦꠈꠍꠦ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦꠁꠘ ꠀꠁꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠁ ꠛꠣꠚꠞꠦ ꠖꠦꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN6_47","073_6_47","JHN","6","47","47","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ, ꠢꠦ ꠟꠉꠦ ꠟꠉꠦꠃ ꠀꠈꠦꠞ ꠙꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN6_48","073_6_48","JHN","6","48","48","ꠀꠝꠤꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠞꠥꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("JN6_49","073_6_49","JHN","6","49","49","ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠦ ꠔ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠝꠣꠘ꠆ꠘꠣ ꠈꠣꠁꠍꠟꠣ, ꠔꠣ-ꠅ ꠔꠣꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN6_50","073_6_50","JHN","6","50","50","ꠅꠁꠟꠦ ꠁꠈꠣꠘ ꠅꠁꠟ ꠢꠃ ꠞꠥꠐꠤ, ꠎꠦ ꠞꠥꠐꠤ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠦ, ꠎꠣꠔꠦ ꠅꠃ ꠞꠥꠐꠤ ꠈꠣꠁꠀ ꠝꠣꠘꠥꠡ ꠝꠞꠘ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN6_51","073_6_51","JHN","6","51","51","ꠢꠥꠘꠅ, ꠀꠝꠤꠃ ꠅꠁꠟꠣꠝ ꠢꠃ ꠎꠤꠘ꠆ꠖꠣ ꠞꠥꠐꠤ, ꠎꠦ ꠞꠥꠐꠤ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠦ। ꠎꠦ ꠎꠘꠦ ꠁ ꠞꠥꠐꠤ ꠈꠣꠁꠛ, ꠢꠦ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ। ꠀꠝꠣꠞ ꠇꠣꠄꠀꠃ ꠅꠁꠟ ꠅꠃ ꠞꠥꠐꠤ। ꠝꠣꠘꠡꠞꠦ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠖꠦꠢ-ꠇꠣꠄꠀ ꠛꠤꠟꠣꠁ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN6_52","073_6_52","JHN","6","52","52","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠟꠣꠉꠤꠉꠦꠟ। ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟ, “ꠁ ꠛꠦꠐꠣꠄ ꠇꠦꠝꠘꠦ ꠔꠣꠞ ꠡꠞꠤꠟꠞ ꠉꠥꠡ꠆ꠔ ꠀꠝꠞꠣꠞꠦ ꠈꠣꠅꠀꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("JN6_53","073_6_53","JHN","6","53","53","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠘꠤꠌ꠆ꠌꠤꠔ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠟꠃ ꠀꠞ ꠉꠥꠡ꠆ꠔ ꠘꠣ ꠈꠣꠁꠟꠦ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN6_54","073_6_54","JHN","6","54","54","ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠟꠃ ꠀꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠄ, ꠔꠦ ꠢꠦ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠟꠤꠍꠦ, ꠀꠞ ꠞꠥꠎ ꠢꠣꠡꠞꠞ ꠖꠤꠘꠅ ꠀꠝꠤ ꠔꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JN6_55","073_6_55","JHN","6","55","55","ꠀꠝꠣꠞ ꠉꠥꠡ꠆ꠔꠃ ꠅꠁꠟ ꠀꠍꠟ ꠈꠣꠘꠤ ꠀꠞ ꠀꠝꠣꠞ ꠟꠃ-ꠃ ꠅꠁꠟ ꠀꠍꠟ ꠙꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("JN6_56","073_6_56","JHN","6","56","56","ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠟꠃ ꠀꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠄ, ꠢꠦ ꠀꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠦ ꠀꠞ ꠀꠝꠤꠅ ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("JN6_57","073_6_57","JHN","6","57","57","ꠎꠦꠟꠣ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠎꠤꠘ꠆ꠖꠣ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤꠅ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠤ। ꠅꠃꠟꠣ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠈꠣꠄ, ꠢꠦ-ꠅ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN6_58","073_6_58","JHN","6","58","58","ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠅꠃ ꠞꠥꠐꠤ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠦ। ꠎꠦ ꠞꠥꠐꠤ ꠈꠣꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ, ꠁ ꠞꠥꠐꠤ ꠔ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ। ꠀꠝꠣꠞ ꠅꠃ ꠞꠥꠐꠤ ꠎꠦ ꠎꠘꠦ ꠈꠣꠁꠛ, ꠢꠦ ꠌꠤꠞꠇꠣꠟ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN6_59","073_6_59","JHN","6","59","59","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠚꠞꠘꠣꠃꠝ ꠐꠣꠃꠘꠞ ꠝꠍꠤꠖꠅ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_60","073_6_60","JHN","6","60","60","ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔꠞ ꠝꠣꠎꠞ ꠛꠃꠔꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠔ ꠛꠠ ꠉꠞꠝ ꠔꠣꠟꠤꠝ। ꠁꠔꠣ ꠇꠦꠉꠤꠄ ꠝꠣꠘꠛ?” ");
INSERT INTO syls_vpl VALUES ("JN6_61","073_6_61","JHN","6","61","61","ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠟꠦ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠇꠤꠔꠣ ꠟꠁꠀ ꠄꠞꠣ ꠇꠣꠘꠣ-ꠊꠥꠡꠣ ꠇꠞꠞꠣ। ꠛꠥꠎꠤꠀ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠊꠣꠛꠠꠤ ꠉꠦꠟꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN6_62","073_6_62","JHN","6","62","62","ꠔꠦ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠉꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠀꠍꠟꠣꠝ, ꠀꠝꠣꠞꠦ ꠎꠦꠛꠟꠣ ꠢꠘꠅ ꠃꠑꠤ ꠎꠣꠅꠀꠔ ꠖꠦꠈꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠁꠛꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("JN6_63","073_6_63","JHN","6","63","63","ꠔꠥꠝꠞꠣ ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠝꠣꠘꠡꠞ ꠡꠞꠤꠟ ꠔ ꠛꠦꠇꠣꠝꠣ, ꠀꠍꠟꠦ ꠞꠥꠢꠥ ꠅꠁꠟꠉꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠛꠄꠀꠘꠤ ꠇꠁꠟꠣꠝ, ꠁꠔꠣ ꠅꠁꠟꠉꠤ ꠝꠣꠘꠡꠞ ꠞꠥꠢꠥ ꠀꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠛꠦꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("JN6_64","073_6_64","JHN","6","64","64","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠇꠦꠃ ꠅꠈꠘꠅ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ ꠘꠣ।” ꠇꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ ꠘꠣ, ꠀꠞ ꠇꠦ ꠔꠣꠘꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠛ, ꠁꠍꠣꠄ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠁꠔꠣ ꠎꠣꠘꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_65","073_6_65","JHN","6","65","65","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠃ ꠇꠣꠞꠘꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠤ, ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠛꠟ ꠘꠣ ꠖꠤꠟꠦ, ꠇꠥꠘꠥꠎꠘꠃ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔ ꠙꠣꠞꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN6_66","073_6_66","JHN","6","66","66","ꠁꠍꠣꠞ ꠁꠔꠣ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠔꠣꠘ ꠛꠃꠔ ꠃꠝ꠆ꠝꠔ ꠚꠤꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ, ꠔꠣꠞꠣ ꠔꠣꠘ ꠟꠉꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN6_67","073_6_67","JHN","6","67","67","ꠄꠞꠟꠣꠉꠤ ꠁꠍꠣꠄ ꠔꠣꠘ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠔꠥꠝꠤꠔꠣꠁꠘꠅ ꠎꠣꠁꠔꠣꠄꠉꠤ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN6_68","073_6_68","JHN","6","68","68","ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠞꠣ ꠀꠞ ꠇꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠣꠝ? ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠣꠘꠤꠞ ꠔꠣꠟꠤꠝ ꠔ ꠈꠣꠟꠤ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦꠃ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN6_69","073_6_69","JHN","6","69","69","ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠍꠤ ꠀꠞ ꠀꠙꠘꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘꠅ ꠀꠘꠍꠤ, ꠀꠙꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN6_70","073_6_70","JHN","6","70","70","ꠔꠦꠃ ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣ ꠛꠣꠞꠅ ꠎꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦꠃ ꠄꠇꠎꠘ ꠡꠄꠔꠣꠘ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN6_71","073_6_71","JHN","6","71","71","ꠁꠘꠅ ꠔꠣꠁꠘ ꠍꠣꠁꠝꠘ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔꠞ ꠙꠥꠀ ꠁꠢꠥꠖꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠟꠣ, ꠅꠃ ꠁꠢꠥꠖꠣꠄ ꠛꠣꠖꠦ ꠔꠣꠘꠦ ꠗꠞꠣꠁ ꠖꠤꠛ। ꠢꠦ ꠀꠍꠤꠟ ꠅꠃ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("JN7_1","073_7_1","JHN","7","1","1","ꠄꠞꠛꠣꠖ ꠕꠣꠇꠤ ꠢꠎꠞꠔ ꠁꠍꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠜꠤꠔꠞꠦꠃ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠟꠣ। ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔ ꠌꠣꠁꠍꠤꠟ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠀꠞ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠎꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_2","073_7_2","JHN","7","2","2","ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠒꠦꠞꠣ-ꠊꠞꠞ ꠁꠖꠞ ꠖꠤꠘ ꠊꠘꠣꠁ ꠀꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN7_3","073_7_3","JHN","7","3","3","ꠄꠞꠟꠣꠉꠤ ꠁꠍꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠁꠘ ꠕꠘꠦ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠎꠣꠅꠉꠤ, ꠔꠦꠃ ꠔꠥꠝꠤ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠍ, ꠅꠔꠣ ꠔꠥꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦꠅ ꠖꠦꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_4","073_7_4","JHN","7","4","4","ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠤꠎꠞꠦ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠔ ꠌꠣꠄ, ꠔꠦ ꠢꠦ ꠟꠥꠇꠣꠁꠀ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠦ ꠘꠣ। ꠔꠥꠝꠤꠅ ꠎꠦꠛꠟꠣ ꠅꠝꠘ ꠇꠣꠝ ꠇꠞꠞꠣꠄ, ꠔꠦ ꠘꠤꠎꠞꠦ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN7_5","073_7_5","JHN","7","5","5","ꠀꠍꠟꠦ ꠁꠍꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦꠅ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_6","073_7_6","JHN","7","6","6","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠡꠝꠄ ꠅꠈꠘꠅ ꠅꠁꠍꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠔ ꠡꠝꠄ ꠅꠡꠝꠄ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN7_7","073_7_7","JHN","7","7","7","ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠔ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠊꠤꠘ ꠇꠞꠦ। ꠀꠝꠤ ꠔ ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠀꠞ, ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠇꠣꠝꠃ ꠈꠣꠞꠣꠙ। ");
INSERT INTO syls_vpl VALUES ("JN7_8","073_7_8","JHN","7","8","8","ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠅꠉꠤ, ꠉꠤꠀ ꠁꠖ ꠇꠞꠅ। ꠀꠝꠣꠞ ꠡꠝꠄ ꠅꠈꠘꠅ ꠙꠥꠞꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠈꠘ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN7_9","073_7_9","JHN","7","9","9","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠔ ꠞꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_10","073_7_10","JHN","7","10","10","ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ ꠁꠖꠞ ꠝꠣꠢꠚꠤꠟꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘꠅ ꠉꠦꠟꠣ, ꠅꠁꠟꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠘꠣ ꠉꠤꠀ ꠟꠥꠇꠣꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_11","073_7_11","JHN","7","11","11","ꠁꠖꠞ ꠇꠣꠟꠅ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠣꠔ ꠞꠁꠟꠣ, ꠀꠞ ꠇꠁꠟꠣ, “ꠢꠃ ꠝꠣꠘꠥꠡꠐꠣ ꠇꠥꠀꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN7_12","073_7_12","JHN","7","12","12","ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠘꠡꠦ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠟꠣ। ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, “ꠄꠁꠘ ꠔ ꠛꠠ ꠜꠣꠟꠣ ꠝꠣꠘꠥꠡ।” ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, “ꠘꠣ, ꠘꠣ, ꠢꠦ ꠔ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠟꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN7_13","073_7_13","JHN","7","13","13","ꠅꠁꠟꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠒꠞꠣꠁꠀ, ꠝꠥꠈ ꠈꠥꠟꠤꠀ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_14","073_7_14","JHN","7","14","14","ꠅꠃ ꠁꠖꠞ ꠝꠣꠎꠣꠝꠣꠎꠤ ꠡꠝꠄ ꠢꠎꠞꠔ ꠁꠍꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠇꠣꠛꠣ ꠡꠞꠤꠚꠅ ꠉꠤꠀ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_15","073_7_15","JHN","7","15","15","ꠔꠣꠘ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠁ ꠝꠣꠘꠡꠦ ꠝꠣꠖ꠆ꠞꠣꠡꠣꠔ ꠘꠣ ꠙꠠꠤꠀ ꠅꠔ ꠁꠟꠤꠝ ꠙꠣꠁꠟ ꠇꠤꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN7_16","073_7_16","JHN","7","16","16","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠎꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠁ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠘꠣꠄ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ, ꠁꠔꠣ ꠔ ꠔꠣꠘꠃ ꠔꠣꠟꠤꠝ। ");
INSERT INTO syls_vpl VALUES ("JN7_17","073_7_17","JHN","7","17","17","ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠔ ꠌꠣꠄ, ꠔꠦ ꠢꠦ ꠛꠥꠎꠛ, ꠁ ꠔꠣꠟꠤꠝ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠦ, ꠘꠣ ꠀꠝꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠖꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN7_18","073_7_18","JHN","7","18","18","ꠎꠦ ꠎꠘꠦ ꠘꠤꠎꠞ ꠝꠘ ꠕꠣꠇꠤ ꠝꠣꠔꠦ, ꠢꠦ ꠈꠣꠟꠤ ꠘꠤꠎꠞ ꠔꠣꠞꠤꠚ ꠙꠣꠁꠔ ꠌꠣꠄ। ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠔꠣꠞ ꠙꠣꠑꠣꠘꠦꠀꠟꠣ ꠝꠣꠟꠤꠇꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠦ, ꠢꠦ ꠢꠣꠝꠦꠡꠣ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠕꠣꠇꠦ, ꠔꠣꠞ ꠝꠘꠅ ꠇꠥꠘꠥ ꠗꠥꠇꠣꠛꠣꠎꠤ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN7_19","073_7_19","JHN","7","19","19","“ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ ꠙꠣꠁꠍ ꠘꠣ ꠘꠤ? ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠄꠇꠎꠘꠦꠅ ꠔ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠞꠣꠄ ꠘꠣ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("JN7_20","073_7_20","JHN","7","20","20","ꠔꠦꠃ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞꠦ ꠜꠥꠔꠦ ꠙꠣꠁꠍꠦ, ꠔꠥꠝꠣꠞꠦ ꠇꠦ ꠝꠣꠞꠔ ꠌꠣꠞ?” ");
INSERT INTO syls_vpl VALUES ("JN7_21","073_7_21","JHN","7","21","21","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠈꠣꠟꠤ ꠄꠇꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠟꠣꠝ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN7_22","073_7_22","JHN","7","22","22","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠘꠤꠅꠝ ꠖꠤꠍꠟꠣ, ꠀꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦꠅ ꠔꠥꠝꠞꠣ ꠅꠃ ꠇꠣꠝ ꠇꠞꠣꠅ। ꠀꠍꠟꠦ, ꠁ ꠘꠤꠅꠝ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠀꠉꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN7_23","073_7_23","JHN","7","23","23","ꠑꠤꠇ ꠀꠍꠦ, ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠘꠤꠅꠝ ꠌꠣꠟꠥ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦꠅ ꠎꠥꠖꠤ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟ ꠎꠣꠄ, ꠔꠦ ꠀꠝꠤ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠄꠇꠎꠘ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠍꠤ ꠖꠦꠈꠤꠀ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠉꠥꠍꠣ ꠇꠞꠞꠣꠄ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("JN7_24","073_7_24","JHN","7","24","24","ꠢꠇ-ꠁꠘꠍꠣꠚ ꠇꠞꠅ, ꠈꠣꠟꠤ ꠛꠣꠞꠉꠣꠟꠣ ꠖꠦꠈꠤꠀ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN7_25","073_7_25","JHN","7","25","25","ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠦ ꠇꠁꠟ, “ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠎꠣꠞꠦ ꠝꠣꠞꠤꠟꠔꠣ ꠌꠣꠁꠞꠣ, ꠅꠉꠥ ꠇꠤꠔꠣ ꠢꠃ ꠝꠣꠘꠥꠡ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN7_26","073_7_26","JHN","7","26","26","ꠔꠦ ꠢꠦ ꠔ ꠖꠦꠈꠤ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠝꠣꠔꠦꠞ, ꠔꠣ-ꠅ ꠔꠣꠞꠣ ꠖꠦꠈꠤ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠞꠣ ꠘꠣ। ꠔꠣꠁꠟꠦ ꠔꠣꠞꠣ ꠇꠤꠔꠣ ꠢꠣꠍꠣ ꠇꠕꠣ ꠛꠥꠎꠤꠟꠤꠍꠂꠘ ꠘꠤ, ꠅꠃ ꠝꠣꠘꠥꠡꠃ ꠀꠟ-ꠝꠍꠤ? ");
INSERT INTO syls_vpl VALUES ("JN7_27","073_7_27","JHN","7","27","27","ꠀꠞ ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠅꠉꠥ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍꠦ। ꠅꠁꠟꠦ ꠀꠟ-ꠝꠍꠤ ꠎꠦꠛꠟꠣ ꠀꠁꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠇꠦꠃ ꠎꠣꠘꠔ ꠘꠣꠄ, ꠔꠣꠁꠘ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN7_28","073_7_28","JHN","7","28","28","ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠛꠄꠀꠘ ꠇꠞꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞꠦꠅ ꠌꠤꠘꠂꠘ, ꠀꠞ ꠀꠝꠤ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍꠤ ꠁꠈꠣꠘꠅ ꠎꠣꠘꠂꠘ। ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠘꠤꠎ ꠕꠣꠇꠤ ꠀꠁꠍꠤ ꠘꠣ, ꠢꠇ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN7_29","073_7_29","JHN","7","29","29","ꠀꠙꠘꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠌꠤꠘꠤ। ꠇꠣꠞꠘ ꠀꠝꠤ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠀꠁꠍꠤ ꠀꠞ ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN7_30","073_7_30","JHN","7","30","30","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠟꠤꠔ ꠌꠣꠁꠟ, ꠅꠁꠟꠦ ꠔꠣꠘ ꠡꠝꠄ ꠙꠥꠞꠣ ꠅꠁꠍꠦ ꠘꠣ ꠉꠔꠤꠇꠦ ꠇꠦꠃ ꠔꠣꠘ ꠉꠔꠞꠅ ꠀꠔ ꠔꠥꠟꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_31","073_7_31","JHN","7","31","31","ꠀꠞ ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠃꠔꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠇꠁꠟ, “ꠄꠁꠘ ꠔ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠀꠟ-ꠝꠍꠤ ꠀꠁꠀ ꠇꠥꠘꠥ ꠄꠞ ꠌꠣꠁꠔꠦ ꠛꠦꠡꠤ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠛꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN7_32","073_7_32","JHN","7","32","32","ꠁꠔꠣ ꠟꠁꠀ ꠝꠣꠘꠡꠦ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠞꠣ, ꠁꠈꠣꠘ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠢꠥꠘꠟꠣ। ꠢꠥꠘꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠗꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠄꠎꠘ ꠙꠣꠞꠣꠖꠣꠞ-ꠍꠤꠙꠣꠁ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_33","073_7_33","JHN","7","33","33","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠀꠞ ꠛꠦꠡꠤ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣꠄ। ꠀꠝꠤ ꠔ ꠔꠣꠘ ꠉꠦꠍꠦ ꠎꠣꠁꠝꠥꠉꠤ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN7_34","073_7_34","JHN","7","34","34","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ, ꠀꠞ ꠀꠝꠤ ꠎꠦ ꠎꠣꠉꠣꠔ ꠞꠁꠝꠥ, ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠢꠤꠘꠅ ꠀꠁꠔꠣꠄꠅ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN7_35","073_7_35","JHN","7","35","35","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠁꠔꠣ ꠝꠣꠔ ꠢꠥꠘꠤꠀ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠦ ꠇꠥꠀꠁ ꠎꠣꠁꠛꠉꠤ, ꠎꠦꠈꠣꠘꠅ ꠀꠝꠞꠣ ꠔꠣꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠔꠣꠝ ꠘꠣꠄ? ꠢꠦ ꠇꠤꠔꠣ ꠁꠃꠘꠣꠘꠤ ꠅꠇꠟꠞ ꠖꠦꠡꠅ ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤ ꠀꠍꠂꠘ, ꠢꠘꠅ ꠞꠁꠀ ꠁꠃꠘꠣꠘꠤ ꠅꠔꠣꠞꠦꠅ ꠔꠣꠟꠤꠝ ꠖꠤꠛ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN7_36","073_7_36","JHN","7","36","36","ꠢꠦ ꠔ ꠇꠁꠟ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ, ꠀꠞ ꠀꠝꠤ ꠎꠦꠈꠣꠘꠅ ꠎꠣꠁꠝꠥ, ꠔꠥꠝꠞꠣ ꠢꠤꠘꠅ ꠀꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ꠔꠣꠞ ꠁ ꠝꠣꠔꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN7_37","073_7_37","JHN","7","37","37","ꠁꠖꠞ ꠀꠈꠦꠞꠤ ꠖꠤꠘ ꠢꠎꠞꠔ ꠁꠍꠣ ꠃꠛꠣꠁꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠛꠄꠀꠘ ꠇꠞꠟꠣ, “ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠙꠤꠀꠍꠦ ꠗꠞꠟꠦ, ꠢꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠙꠣꠘꠤ ꠈꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("JN7_38","073_7_38","JHN","7","38","38","ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠀꠄꠀꠔ ꠝꠣꠚꠤꠇ ꠔꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠙꠣꠘꠤꠞ ꠉꠣꠋ ꠛꠣꠞ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN7_39","073_7_39","JHN","7","39","39","ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠎꠦꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥꠞꠦ ꠙꠣꠁꠛꠣ, ꠢꠃ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠅꠃ ꠇꠕꠣ ꠇꠁꠟꠣ। ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞꠦ ꠅꠈꠘꠅ ꠖꠦꠅꠀ ꠅꠁꠍꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠁꠍꠣꠄ ꠔꠣꠘ ꠝꠢꠤꠝꠣ ꠅꠈꠘꠅ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_40","073_7_40","JHN","7","40","40","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠦ ꠇꠁꠟ, “ꠀꠍꠟꠦ ꠄꠁꠘꠃ ꠢꠃ ꠅꠀꠖꠣ ꠇꠞꠣ ꠘꠛꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN7_41","073_7_41","JHN","7","41","41","ꠀꠞ ꠇꠄꠎꠘꠦ ꠇꠁꠟ, “ꠄꠁꠘꠃ ꠀꠟ-ꠝꠍꠤ।” ꠅꠁꠟꠦ ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, “ꠀꠟ-ꠝꠍꠤ ꠇꠥꠘꠥ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣ ꠕꠣꠇꠤ ꠀꠁꠛꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN7_42","073_7_42","JHN","7","42","42","ꠙꠣꠇ ꠇꠤꠔꠣꠛꠦ ꠔ ꠛꠣꠔꠣꠄ, ꠀꠟ-ꠝꠍꠤꠄ ꠎꠘꠝ ꠟꠁꠛꠣ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠛꠋꠡꠔ, ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠛꠦꠕꠦꠟꠢꠣꠝ ꠉꠣꠃꠔ।” ");
INSERT INTO syls_vpl VALUES ("JN7_43","073_7_43","JHN","7","43","43","ꠅꠃ ꠟꠣꠈꠣꠘ ꠁꠍꠣꠞꠦ ꠟꠁꠀ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("JN7_44","073_7_44","JHN","7","44","44","ꠄꠞꠝꠣꠎꠦ ꠇꠄꠎꠘꠦ ꠔꠣꠘꠞꠦ ꠗꠞꠤꠟꠤꠔ ꠌꠣꠁꠟ, ꠅꠁꠟꠦ ꠇꠦꠃ ꠔꠣꠘ ꠉꠔꠞꠅ ꠀꠔ ꠔꠥꠟꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_45","073_7_45","JHN","7","45","45","ꠁꠍꠣꠞꠦ ꠗꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦ ꠙꠣꠞꠣꠖꠣꠞ-ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠙꠣꠑꠣꠘꠤ ꠅꠁꠍꠤꠟ, ꠔꠣꠞꠣ ꠚꠤꠞꠔ ꠀꠁꠟꠦ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠣꠞꠦ ꠗꠞꠤꠀ ꠀꠘꠟꠣꠄ ꠘꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN7_46","073_7_46","JHN","7","46","46","ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠁ ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠝꠣꠔ ꠝꠣꠔꠦ, ꠁꠟꠣ ꠝꠣꠔ ꠇꠦꠃ ꠇꠥꠘꠥꠖꠤꠘ ꠝꠣꠔꠤꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN7_47","073_7_47","JHN","7","47","47","ꠔꠦꠃ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠢꠦ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠐꠉꠤꠟꠤꠟ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN7_48","073_7_48","JHN","7","48","48","ꠖꠦꠈꠍ ꠘꠤ, ꠘꠦꠔꠣ ꠛꠣ ꠚꠞꠤꠡꠤ ꠡꠝꠣꠎꠞ ꠇꠦꠃ ꠔꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN7_49","073_7_49","JHN","7","49","49","ꠈꠣꠟꠤ ꠅꠃ ꠎꠦꠔꠣꠄ ꠡꠞꠤꠅꠔꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠎꠣꠘꠂꠘ ꠘꠣ, ꠅꠔꠣꠃ ꠔ। ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN7_50","073_7_50","JHN","7","50","50","ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠄꠇꠎꠘꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠝꠃꠟꠣꠘꠣ ꠘꠤꠇꠖꠤꠝ, ꠄꠁꠘ ꠀꠉꠦ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠉꠦꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN7_51","073_7_51","JHN","7","51","51","ꠘꠤꠇꠖꠤꠝꠦ ꠇꠁꠟꠣ, “ꠇꠦꠃꠞꠞ ꠝꠥꠈꠞ ꠇꠕꠣ ꠘꠣ ꠢꠥꠘꠤꠀ ꠛꠣ ꠔꠣꠞ ꠅꠙꠞꠣꠗ ꠘꠣ ꠎꠣꠘꠤꠀ, ꠔꠣꠞꠦ ꠡꠣꠎꠣ ꠖꠦꠅꠀꠞ ꠘꠤꠅꠝ ꠇꠥꠘꠥ ꠀꠝꠞꠣꠞ ꠡꠞꠤꠅꠔꠅ ꠀꠍꠦ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN7_52","073_7_52","JHN","7","52","53","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠘꠤꠇꠖꠤꠝꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤꠅ ꠇꠤꠔꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠝꠣꠘꠥꠡ ꠘꠤ? ꠙꠣꠇ ꠇꠤꠔꠣꠛꠅ ꠌꠣꠁꠀ ꠖꠦꠈꠅ ꠘꠣ, ꠉꠣꠟꠤꠟꠅ ꠇꠥꠘꠥ ꠘꠛꠤꠞ ꠎꠘꠝ ꠅꠄ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN8_1","073_8_1","JHN","8","1","1","ꠛꠣꠖꠦ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠎꠣꠞꠎꠤꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣꠉꠤ, ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠄꠇꠟꠣ ꠎꠄꠔꠥꠘ ꠙꠣꠠꠅ ꠉꠤꠀ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_2","073_8_2","JHN","8","2","2","ꠛꠣꠖꠞ ꠖꠤꠘ ꠚꠎꠞ ꠅꠇ꠆ꠔꠅ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ। ꠔꠣꠁꠘ ꠅꠘꠅ ꠛꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_3","073_8_3","JHN","8","3","3","ꠅꠃ ꠡꠝꠄ ꠝꠃꠟꠣꠘꠣ ꠀꠞ ꠚꠞꠤꠡꠤ ꠡꠝꠣꠎꠞ ꠝꠣꠘꠡꠦ ꠄꠇ ꠎꠤꠘꠣꠇꠥꠞ ꠛꠦꠐꠤꠞꠦ ꠟꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ। ꠀꠁꠀ ꠛꠦꠐꠤꠞꠦ ꠝꠎꠟꠤꠍꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣ ꠇꠞꠣꠁꠀ ꠇꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("JN8_4","073_8_4","JHN","8","4","4","“ꠢꠥꠎꠥꠞ, ꠅꠃ ꠛꠦꠐꠤ ꠅꠉꠥ ꠎꠤꠘꠣꠞ ꠇꠣꠝꠅ ꠗꠞꠣ ꠈꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN8_5","073_8_5","JHN","8","5","5","ꠔꠦ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠞ ꠝꠣꠎꠦ ꠔ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠎꠤꠘꠣꠇꠥꠞ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ। ꠅꠈꠘ ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠇꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("JN8_6","073_8_6","JHN","8","6","6","ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦꠃ ꠁꠟꠣ ꠇꠁꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠘꠞꠦ ꠖꠥꠡꠤ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠈꠥꠔ ꠙꠣꠁꠘ। ꠔꠦꠃ ꠁꠍꠣꠄꠅ ꠝꠣꠕꠣ ꠘꠤꠌꠣ ꠇꠞꠤ ꠀꠋꠉꠥꠟ ꠖꠤꠀ ꠝꠣꠐꠤꠔ ꠟꠦꠈꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_7","073_8_7","JHN","8","7","7","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠛꠣꠞ ꠛꠣꠞ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠝꠣꠕꠣ ꠔꠥꠟꠤꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠎꠦ ꠎꠘꠦ ꠇꠥꠘꠥꠖꠤꠘ ꠉꠥꠘꠣ ꠇꠞꠍꠂꠘ ꠘꠣ, ꠄꠁꠘ ꠙꠄꠟꠣ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN8_8","073_8_8","JHN","8","8","8","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠝꠣꠕꠣ ꠘꠤꠌꠣ ꠇꠞꠤ ꠝꠣꠐꠤꠔ ꠟꠦꠈꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_9","073_8_9","JHN","8","9","9","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠛꠥꠠꠣ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠇꠞꠤꠀ ꠄꠇꠦ ꠄꠇꠦ ꠢꠇꠟꠃ ꠉꠦꠟꠣꠉꠤ। ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠞ ꠢꠃ ꠛꠦꠐꠤ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_10","073_8_10","JHN","8","10","10","ꠔꠦꠃ ꠁꠍꠣꠄ ꠝꠣꠕꠣ ꠔꠥꠟꠤꠀ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠉ ꠝꠣꠁ, ꠁꠔꠣ ꠝꠣꠘꠥꠡ ꠇꠥꠀꠁ? ꠇꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠡꠣꠎꠣꠞ ꠎꠥꠇꠣ ꠝꠘꠅ ꠇꠞꠟ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN8_11","073_8_11","JHN","8","11","11","ꠛꠦꠐꠤꠄ ꠇꠁꠟ, “ꠎꠤ ꠘꠣ ꠢꠥꠎꠥꠞ, ꠔꠣꠞꠣ ꠇꠦꠃ ꠔ ꠡꠣꠎꠣ ꠖꠤꠍꠂꠘ ꠘꠣ।” ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠤꠅ ꠔꠥꠝꠣꠞꠦ ꠇꠥꠘꠥ ꠡꠣꠎꠣ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ꠅꠈꠘ ꠎꠣꠅꠉꠤ, ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠀꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN8_12","073_8_12","JHN","8","12","12","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠖꠥꠘꠤꠀꠞ ꠘꠥꠞ। ꠎꠦ ꠎꠘ ꠀꠝꠣꠞ ꠙꠕꠦ ꠀꠄ, ꠢꠦ ꠇꠥꠘꠥ ꠡꠝꠄ ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠙꠣꠅ ꠚꠣꠟꠣꠁꠔ ꠘꠣꠄ, ꠛꠞꠋ ꠘꠥꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN8_13","073_8_13","JHN","8","13","13","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠟꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN8_14","073_8_14","JHN","8","14","14","ꠔꠦꠃ ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠟꠦꠅ ꠀꠝꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠔ ꠢꠣꠍꠣ। ꠇꠣꠞꠘ ꠀꠝꠤ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍꠤ ꠀꠞ ꠇꠥꠀꠁ ꠎꠣꠁꠞꠣꠝ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠝꠤꠃ ꠎꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("JN8_15","073_8_15","JHN","8","15","15","ꠔꠥꠝꠞꠣ ꠔ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠛꠤꠌꠣꠞ ꠇꠞ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠇꠦꠃꠞꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_16","073_8_16","JHN","8","16","16","ꠀꠝꠤ ꠇꠦꠃꠞꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠟꠦꠅ ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠝꠥ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠄꠇꠟꠣ ꠘꠣꠄ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠅ ꠀꠍꠂꠘ, ꠅꠃ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN8_17","073_8_17","JHN","8","17","17","ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠝꠣꠎꠦ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠖꠥꠁꠎꠘꠦ ꠎꠥꠖꠤ ꠄꠇ ꠢꠝꠣꠘ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠄ, ꠔꠦ ꠁ ꠡꠣꠇ꠆ꠇꠤ ꠢꠣꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_18","073_8_18","JHN","8","18","18","ꠅꠟꠣꠈꠣꠘ ꠀꠝꠤꠅ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠁ, ꠀꠞ ꠎꠦ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘꠅ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN8_19","073_8_19","JHN","8","19","19","ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠛꠣꠚ ꠇꠥꠀꠁ?” ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦꠅ ꠌꠤꠘ ꠘꠣ, ꠀꠞ ꠀꠝꠣꠞ ꠛꠣꠚꠞꠦꠅ ꠌꠤꠘ ꠘꠣ। ꠀꠝꠣꠞꠦ ꠌꠤꠘꠟꠦ ꠀꠝꠣꠞ ꠛꠣꠚꠞꠦꠅ ꠌꠤꠘꠟꠣꠄ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN8_20","073_8_20","JHN","8","20","20","ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠖꠣꠘ-ꠛꠣꠇ꠆ꠡꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠅꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠘ ꠡꠝꠄ ꠙꠥꠞꠣ ꠘꠣ ꠅꠀꠄ ꠇꠦꠃ ꠔꠣꠘꠞꠦ ꠗꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_21","073_8_21","JHN","8","21","21","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠎꠣꠁꠀꠞꠉꠤ। ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠔꠥꠇꠣꠁꠛꠣꠄ, ꠅꠁꠟꠦ ꠀꠞ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ, ꠀꠝꠤ ꠎꠦꠘꠅ ꠎꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠤꠘꠅ ꠀꠁꠔꠣꠄꠅ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠎꠦꠃ ꠝꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN8_22","073_8_22","JHN","8","22","22","ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠦ ꠇꠦꠘꠦ ꠇꠁꠟ, ꠀꠝꠤ ꠎꠦꠘꠅ ꠎꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠤꠘꠅ ꠀꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ? ꠢꠦ ꠇꠤꠔꠣ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠝꠞꠤꠎꠤꠔ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN8_23","073_8_23","JHN","8","23","23","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠁꠍꠤ ꠃꠙꠞꠦ ꠕꠣꠇꠤ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠟꠦ ꠕꠣꠇꠤ। ꠔꠥꠝꠞꠣ ꠁ ꠎꠉꠔꠞ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠔ ꠁ ꠎꠉꠔꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN8_24","073_8_24","JHN","8","24","24","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠎꠦꠃ ꠝꠞꠛꠣꠄ। ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠄꠇꠤꠘ ꠘꠣ ꠇꠞ, ꠀꠝꠤꠃ ꠢꠦꠁꠘ, ꠔꠦ ꠉꠥꠘꠣꠉꠣꠞ ꠢꠣꠟꠔꠦꠃ ꠝꠞꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN8_25","073_8_25","JHN","8","25","25","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠦ?” ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠀꠝꠤ ꠎꠦꠟꠣ ꠇꠁꠞꠣꠝ, ꠀꠝꠤꠃ ꠢꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("JN8_26","073_8_26","JHN","8","26","26","ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠔꠣꠞ ꠀꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠛꠃꠔꠔꠣ ꠀꠍꠦ। ꠢꠥꠘꠅ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠔꠣꠘ ꠝꠣꠎꠦ ꠔ ꠝꠤꠍꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ। ꠀꠝꠤ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠢꠥꠘꠤ, ꠅꠔꠣꠃ ꠁ ꠖꠥꠘꠤꠀꠞꠦ ꠎꠣꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN8_27","073_8_27","JHN","8","27","27","ꠁꠍꠣꠄ ꠎꠦꠘ ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠇꠕꠣ ꠇꠁꠞꠣ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠛꠥꠎꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_28","073_8_28","JHN","8","28","28","ꠄꠞꠖꠣꠄ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠃꠙꠞꠦ ꠔꠥꠟꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠛꠥꠎꠛꠣꠄ ꠀꠝꠤꠃ ꠢꠦꠁꠘ। ꠀꠞ ꠄꠅꠈꠣꠘ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠤ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠤ ꠘꠣ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠎꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠂꠘ, ꠅꠃ ꠔꠣꠟꠤꠝꠃ ꠀꠝꠤ ꠛꠣꠔꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN8_29","073_8_29","JHN","8","29","29","ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ। ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠟꠉ ꠍꠣꠠꠍꠂꠘ ꠘꠣ, ꠀꠝꠤ ꠔ ꠢꠣꠝꠦꠡꠣ ꠅꠃ ꠇꠣꠝꠃ ꠇꠞꠤ, ꠎꠦ ꠇꠣꠝ ꠇꠞꠟꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN8_30","073_8_30","JHN","8","30","30","ꠁꠍꠣꠞ ꠁ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_31","073_8_31","JHN","8","31","31","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟꠣ, ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠇꠕꠣꠝꠔ ꠌꠟ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠢꠣꠍꠣꠞꠞ ꠃꠝ꠆ꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("JN8_32","073_8_32","JHN","8","32","32","ꠔꠥꠝꠞꠣ ꠢꠇ ꠌꠤꠘꠛꠣꠄ ꠀꠞ ꠅꠃ ꠢꠇꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN8_33","073_8_33","JHN","8","33","33","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠛꠋꠡꠞ ꠝꠣꠘꠥꠡ, ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠡꠝꠄꠅ ꠇꠦꠃꠞꠞ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠝ ꠘꠣ। ꠔꠦ ꠔꠥꠝꠤ ꠇꠤꠟꠣ ꠇꠁꠞꠣꠄ, ꠀꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠣ ꠅꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("JN8_34","073_8_34","JHN","8","34","34","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠎꠦꠞꠣ ꠉꠥꠘꠣꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠄ, ꠔꠣꠞꠣ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN8_35","073_8_35","JHN","8","35","35","ꠇꠥꠘꠥ ꠉꠥꠟꠣꠝ ꠌꠤꠞꠇꠣꠟ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠛꠣꠠꠤꠔ ꠕꠣꠇꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠙꠥꠔ ꠔ ꠌꠤꠞꠇꠣꠟ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("JN8_36","073_8_36","JHN","8","36","36","ꠄꠞꠟꠣꠉꠤ ꠙꠥꠔꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠢꠣꠍꠣꠞꠞ ꠀꠎꠣꠖ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN8_37","073_8_37","JHN","8","37","37","ꠀꠝꠤ ꠎꠣꠘꠤ, ꠔꠥꠝꠞꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠞ ꠛꠋꠡꠞ ꠝꠣꠘꠥꠡ, ꠔꠦꠛꠃ ꠀꠝꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ, ꠇꠣꠞꠘ ꠀꠝꠣꠞ ꠘꠍꠤꠅꠔ ꠔꠥꠝꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_38","073_8_38","JHN","8","38","38","ꠀꠝꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠖꠦꠈꠍꠤ ꠅꠔꠣ ꠇꠁꠞꠣꠝ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠢꠤꠇꠍ ꠅꠔꠣꠃ ꠇꠞꠞꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN8_39","073_8_39","JHN","8","39","39","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠃ ꠀꠝꠞꠣꠞ ꠛꠣꠚ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖ ꠅꠁꠔꠣꠄ, ꠔꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠟꠣꠄ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("JN8_40","073_8_40","JHN","8","40","40","ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦ ꠢꠇ ꠇꠣꠟꠣꠝ ꠙꠣꠁꠍꠤ, ꠅꠔꠣꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ। ꠔꠦꠛꠃ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ, ꠅꠁꠟꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠔ ꠁꠟꠣ ꠇꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_41","073_8_41","JHN","8","41","41","ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠛꠣꠚꠦ ꠎꠦꠔꠣ ꠇꠞꠦ, ꠔꠥꠝꠞꠣꠅ ꠅꠔꠣ ꠇꠞꠞꠣꠄ।” ꠅꠃ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠚꠥꠋꠉꠣ ꠙꠥꠀ ꠘꠣꠄ। ꠀꠝꠞꠣꠞ ꠄꠇꠎꠘꠃ ꠛꠣꠚ ꠀꠍꠂꠘ, ꠄꠁꠘ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN8_42","073_8_42","JHN","8","42","42","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠍꠟꠦꠃ ꠀꠟ꠆ꠟꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠅꠁꠔꠣ, ꠔꠦ ꠀꠝꠣꠞ ꠛꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠄꠀ ꠕꠣꠇꠟ ꠅꠘꠦ। ꠇꠣꠞꠘ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠤ ꠀꠞ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠤ। ꠀꠝꠤ ꠘꠤꠎꠦ ꠀꠁꠍꠤ ꠘꠣ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN8_43","073_8_43","JHN","8","43","43","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠛꠥꠎꠞꠣꠄ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠔꠣꠄ ꠙꠣꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_44","073_8_44","JHN","8","44","44","ꠁꠛꠟꠤꠍꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠣꠞ ꠀꠅꠟꠣꠖ, ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣ ꠔꠣꠞ ꠈꠣꠁꠡ ꠙꠥꠞꠣ ꠇꠞꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ। ꠁꠛꠟꠤꠍ ꠔ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠈꠥꠘꠤ। ꠢꠦ ꠇꠥꠘꠥꠖꠤꠘ ꠢꠇꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠍꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠢꠇ ꠘꠣꠁ। ꠢꠦ ꠎꠦꠛꠟꠣ ꠝꠤꠍꠣ ꠝꠣꠔꠦ, ꠅꠃ ꠡꠝꠄ ꠢꠦ ꠘꠤꠎ ꠕꠣꠇꠤꠃ ꠝꠣꠔꠦ। ꠇꠣꠞꠘ ꠢꠦ ꠛꠦꠁꠝꠣꠘ, ꠀꠞ ꠢꠇꠟ ꠛꠦꠁꠝꠣꠘꠤ ꠔꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠃ ꠙꠄꠖꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN8_45","073_8_45","JHN","8","45","45","ꠀꠝꠤ ꠢꠇ ꠝꠣꠔ ꠝꠣꠔꠤꠀꠞ ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠞꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN8_46","073_8_46","JHN","8","46","46","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠉꠥꠘꠣꠉꠣꠞ ꠙꠞꠝꠣꠘ ꠇꠞꠔ ꠙꠣꠞꠛ ꠘꠤ? ꠀꠝꠤ ꠎꠥꠖꠤ ꠢꠇ ꠝꠣꠔ ꠝꠣꠔꠤ, ꠔꠦ ꠀꠝꠣꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠞꠣꠄ ꠘꠣ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("JN8_47","073_8_47","JHN","8","47","47","ꠎꠦ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠦ। ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠄ ꠉꠔꠤꠇꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN8_48","073_8_48","JHN","8","48","48","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠑꠤꠇ ꠇꠕꠣ ꠇꠁꠍꠤ, ꠔꠥꠁ ꠡꠝꠞꠤꠀ ꠎꠣꠔꠞ ꠝꠣꠘꠥꠡ, ꠔꠞꠦ ꠜꠥꠔꠦ ꠗꠞꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN8_49","073_8_49","JHN","8","49","49","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠘꠣ, ꠀꠝꠣꠞꠦ ꠜꠥꠔꠦ ꠗꠞꠍꠦ ꠘꠣ। ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠚꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN8_50","073_8_50","JHN","8","50","50","ꠀꠝꠤ ꠘꠤꠎꠦ ꠇꠥꠘꠥ ꠁꠎ꠆ꠎꠔ ꠙꠣꠁꠔꠣꠝ ꠇꠞꠤ ꠇꠣꠝ ꠇꠞꠤ ꠘꠣ। ꠅꠁꠟꠦ ꠄꠇꠎꠘ ꠀꠍꠂꠘ ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠁꠎ꠆ꠎꠔꠞ ꠟꠣꠉꠤ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞꠇ। ");
INSERT INTO syls_vpl VALUES ("JN8_51","073_8_51","JHN","8","51","51","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠦ, ꠢꠦ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠝꠞꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN8_52","073_8_52","JHN","8","52","52","ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠀꠝꠞꠣ ꠛꠥꠎꠟꠣꠝ, ꠔꠞꠦ ꠑꠤꠇꠃ ꠜꠥꠔꠦ ꠗꠞꠍꠦ। ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤ ꠛꠣ ꠀꠞꠅ ꠘꠛꠤ ꠅꠇꠟ ꠔ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ, ꠀꠞ ꠔꠥꠁ ꠇꠁꠞꠦ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠦ, ꠢꠦ ꠇꠥꠘꠥ ꠡꠝꠄꠅ ꠝꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN8_53","073_8_53","JHN","8","53","53","ꠔꠥꠁ ꠇꠥꠘꠥ ꠛꠣꠛꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠕꠣꠇꠤꠅ ꠛꠠ ꠘꠤ? ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠀꠞ ꠛꠣꠇꠤ ꠔꠣꠝꠣꠝ ꠘꠛꠤ ꠅꠇꠟꠃ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ। ꠔꠦ ꠔꠥꠁ ꠘꠤꠎꠞꠦ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠍ?” ");
INSERT INTO syls_vpl VALUES ("JN8_54","073_8_54","JHN","8","54","54","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠔꠣꠞꠤꠚ ꠘꠤꠎꠦꠃ ꠇꠞꠤ, ꠔꠦ ꠄꠞ ꠇꠥꠘꠥ ꠖꠣꠝ ꠘꠣꠁ। ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ, ꠎꠣꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠇꠁꠀ ꠖꠣꠛꠤ ꠇꠞꠅ, ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN8_55","073_8_55","JHN","8","55","55","ꠔꠥꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠍ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠤ। ꠀꠝꠤ ꠎꠥꠖꠤ ꠇꠁ ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠤ ꠘꠣ, ꠔꠦ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠤꠅ ꠛꠦꠁꠝꠣꠘ ꠅꠁꠝꠥ। ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠤ ꠀꠞ ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("JN8_56","073_8_56","JHN","8","56","56","ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠄ ꠀꠝꠣꠞ ꠖꠤꠘ ꠖꠦꠈꠣꠞ ꠀꠡꠣꠄ ꠈꠥꠡꠤ ꠇꠞꠍꠂꠘ। ꠔꠣꠁꠘ ꠁꠔꠣ ꠖꠦꠈꠍꠂꠘ ꠀꠞ ꠈꠥꠡꠤꠅ ꠅꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN8_57","073_8_57","JHN","8","57","57","ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠛꠄꠅꠡ ꠔ ꠅꠈꠘꠅ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠍꠞ ꠅꠁꠍꠦ ꠘꠣ, ꠔꠦ ꠔꠥꠝꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠞꠦ ꠖꠦꠈꠟꠣꠄ ꠇꠤꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN8_58","073_8_58","JHN","8","58","58","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠞ ꠎꠘꠝꠞ ꠀꠉ ꠕꠣꠇꠤꠃ ꠀꠝꠤ ꠀꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN8_59","073_8_59","JHN","8","59","59","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠔ꠆ꠔꠞ ꠔꠥꠇꠣꠁꠀ ꠟꠁꠟꠣ। ꠅꠁꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠃꠠꠤ ꠖꠤꠀ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN9_1","073_9_1","JHN","9","1","1","ꠢꠎꠞꠔ ꠁꠍꠣ ꠙꠕꠦꠖꠤ ꠀꠐꠤꠀ ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠄꠇ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣꠞꠦ ꠙꠣꠁꠟꠣ। ꠢꠦ ꠎꠘꠝ ꠕꠣꠇꠤꠃ ꠀꠘ꠆ꠖꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN9_2","073_9_2","JHN","9","2","2","ꠄꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠃ ꠝꠣꠘꠥꠡꠉꠥ ꠇꠣꠞ ꠉꠥꠘꠣꠄ ꠀꠘ꠆ꠖꠣ ꠅꠁꠀ ꠎꠘꠝꠤꠍꠦ? ꠔꠣꠞ ꠘꠤꠎꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ, ꠘꠣ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞ?” ");
INSERT INTO syls_vpl VALUES ("JN9_3","073_9_3","JHN","9","3","3","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠣꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤꠅ ꠘꠣꠄ, ꠀꠞ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤꠅ ꠘꠣꠄ। ꠔꠣꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠎꠣꠁꠞ ꠅꠀꠞ ꠟꠣꠉꠤꠃ ꠁꠟꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN9_4","073_9_4","JHN","9","4","4","ꠢꠥꠘꠅ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ, ꠡꠝꠄ ꠕꠣꠇꠔꠦ ꠕꠣꠇꠔꠦ ꠔꠣꠘ ꠇꠣꠝ ꠇꠞꠣ ꠀꠝꠞꠣꠞ ꠎꠞꠥꠞ। ꠞꠣꠁꠔ ꠊꠘꠣꠁꠀ ꠀꠞ, ꠢꠤ ꠡꠝꠄ ꠇꠦꠃ ꠇꠣꠝ ꠇꠞꠣꠞ ꠃꠙꠣꠄ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN9_5","073_9_5","JHN","9","5","5","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠝꠤ ꠎꠔꠖꠤꠘ ꠖꠥꠘꠤꠀꠔ ꠀꠍꠤ, ꠅꠔꠖꠤꠘ ꠀꠝꠤꠃ ꠖꠥꠘꠤꠀꠞ ꠘꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN9_6","073_9_6","JHN","9","6","6","ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠝꠣꠐꠤꠔ ꠍꠦꠚ ꠚꠣꠟꠣꠁꠀ ꠚꠦꠇ ꠛꠣꠘꠣꠁꠟꠣ, ꠛꠣꠖꠦ ꠅꠃ ꠚꠦꠇ ꠀꠘ꠆ꠖꠣ ꠛꠦꠐꠣꠞ ꠌꠈꠥꠔ ꠟꠣꠉꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("JN9_7","073_9_7","JHN","9","7","7","“ꠎꠣꠅ ꠛꠣ, ꠍꠤꠟꠥꠀꠞ ꠙꠥꠞꠇꠤꠔ ꠉꠤꠀ ꠗꠁꠟꠣꠅ।” ꠍꠤꠟꠥꠀ ꠝꠣꠘꠤ ꠙꠣꠑꠣꠘꠤ। ꠢꠦ ꠉꠤꠀ ꠌꠃꠈ ꠗꠁꠟ ꠀꠞ ꠜꠣꠟꠣ ꠅꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN9_8","073_9_8","JHN","9","8","8","ꠁꠈꠣꠘ ꠖꠦꠈꠤꠀ ꠀꠞꠤ-ꠚꠞꠤ ꠀꠞ ꠎꠔ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠀꠉꠦ ꠜꠤꠇ ꠇꠞꠣꠔ ꠖꠦꠈꠍꠤꠟꠣ ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠅꠉꠥ ꠇꠤꠔꠣ ꠢꠃ ꠛꠦꠐꠣ ꠘꠣꠄ ꠘꠤ, ꠎꠦꠉꠤꠄ ꠅꠘꠅ ꠛꠁꠀ ꠜꠤꠇ ꠇꠞꠔ?” ");
INSERT INTO syls_vpl VALUES ("JN9_9","073_9_9","JHN","9","9","9","ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, “ꠅꠄ, ꠢꠦ ꠔ ꠅꠃ ꠛꠦꠐꠣꠃ।” ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, “ꠖꠦꠈꠔꠦ ꠎꠥꠖꠤꠅ ꠔꠣꠞ ꠟꠣꠈꠣꠘ, ꠅꠁꠟꠦ ꠢꠦ ꠘꠣꠄ।” ꠔꠦꠃ ꠢꠦ ꠘꠤꠎꠦ ꠇꠁꠟ, “ꠎꠤꠅꠄ, ꠀꠝꠤꠃ ꠢꠃ ꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN9_10","073_9_10","JHN","9","10","10","ꠅꠃ ꠔꠣꠞꠣ ꠄꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠔꠥꠝꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠅꠁꠟ ꠇꠤꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN9_11","073_9_11","JHN","9","11","11","ꠢꠦ ꠇꠁꠟ, “ꠁꠍꠣ ꠘꠣꠝꠞ ꠅꠃ ꠝꠣꠘꠡꠦ ꠚꠦꠇ ꠛꠣꠘꠣꠁꠀ ꠀꠝꠣꠞ ꠌꠈꠥꠔ ꠟꠣꠉꠣꠁꠀ ꠇꠁꠟꠣ, ꠎꠣꠅ ꠛꠣ, ꠍꠤꠟꠥꠀꠞ ꠙꠥꠇꠞꠤꠞ ꠝꠣꠎꠦ ꠗꠁꠀ ꠀꠅꠉꠤ। ꠀꠝꠤ ꠉꠤꠀ ꠗꠁꠟꠣꠝ ꠀꠞ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN9_12","073_9_12","JHN","9","12","12","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠅꠃ ꠝꠣꠘꠥꠡꠉꠥ ꠇꠥꠀꠁ?” ꠢꠦ ꠇꠁꠟ, “ꠀꠝꠤ ꠎꠣꠘꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN9_13","073_9_13","JHN","9","13","13","ꠅꠃ ꠎꠦ ꠛꠦꠐꠣ ꠀꠘ꠆ꠖꠣ ꠀꠍꠤꠟ, ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠗꠞꠤꠀ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN9_14","073_9_14","JHN","9","14","14","ꠇꠣꠞꠘ ꠁꠍꠣꠄ ꠎꠦꠖꠤꠘ ꠚꠦꠇ ꠟꠣꠉꠣꠁꠀ ꠔꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠇꠞꠍꠟꠣ, ꠁ ꠖꠤꠘ ꠀꠍꠤꠟ ꠔꠣꠞꠣꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("JN9_15","073_9_15","JHN","9","15","15","ꠄꠞꠟꠣꠉꠤ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠅꠁꠟ ꠇꠤꠟꠣ?” ꠢꠦ ꠇꠁꠟ, “ꠢꠃ ꠎꠘꠦ ꠀꠝꠣꠞ ꠌꠈꠥꠔ ꠚꠦꠇ ꠟꠣꠉꠣꠁꠀ ꠖꠤꠟꠣ, ꠀꠞ ꠀꠝꠤ ꠉꠤꠀ ꠗꠁꠀꠃ ꠌꠃꠈꠦ ꠖꠦꠈꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN9_16","073_9_16","JHN","9","16","16","ꠅꠃ ꠡꠝꠄ ꠇꠄꠎꠘ ꠚꠞꠤꠡꠤꠄ ꠇꠁꠟꠣ, “ꠁ ꠝꠣꠘꠥꠡꠉꠥ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠦ ꠘꠣ। ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠢꠦ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠅ ꠝꠣꠘꠦ ꠘꠣ।” ꠅꠁꠟꠦ ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟꠣ, “ꠉꠥꠘꠣꠉꠣꠞ ꠝꠣꠘꠡꠦ ꠁꠟꠣꠈꠣꠘ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠛ ꠇꠤꠟꠣ?” ꠅꠔꠣ ꠟꠁꠀ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("JN9_17","073_9_17","JHN","9","17","17","ꠔꠣꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠅꠃ ꠝꠣꠘꠡꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠑꠤꠇ ꠀꠍꠦ, ꠢꠦ ꠔ ꠔꠥꠝꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠇꠞꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠔꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠅ।” ꠢꠦ ꠇꠁꠟ, “ꠔꠣꠁꠘ ꠄꠇꠎꠘ ꠘꠛꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN9_18","073_9_18","JHN","9","18","18","ꠅꠁꠟꠦ ꠅꠃ ꠛꠦꠐꠣ ꠎꠦꠘ ꠀꠉꠦ ꠀꠘ꠆ꠖꠣ ꠀꠍꠤꠟ ꠀꠞ ꠅꠈꠘ ꠌꠃꠈꠦ ꠖꠦꠈꠦꠞ, ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠘꠣ ꠎꠤꠇꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN9_19","073_9_19","JHN","9","19","19","ꠔꠣꠞꠣ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠖꠦꠈꠅ ꠌꠣꠁꠘ, ꠅꠉꠥ ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠀꠘ꠆ꠖꠣ ꠙꠥꠀ ꠘꠤ, ꠎꠦꠉꠥꠞꠦ ꠔꠥꠝꠞꠣ ꠎꠘꠝꠞ ꠀꠘ꠆ꠖꠣ ꠇꠅ? ꠔꠦ ꠢꠦ ꠅꠈꠘ ꠌꠃꠈꠦ ꠖꠦꠈꠦꠞ ꠇꠤꠟꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN9_20","073_9_20","JHN","9","20","20","ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠦ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠢꠦ ꠀꠝꠞꠣꠞꠃ ꠙꠥꠀ ꠀꠞ ꠢꠦ ꠀꠘ꠆ꠖꠣ ꠅꠁꠀ ꠎꠘꠝꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN9_21","073_9_21","JHN","9","21","21","ꠅꠁꠟꠦ ꠅꠈꠘ ꠇꠤꠟꠣ ꠌꠃꠈꠦ ꠖꠦꠈꠦꠞ, ꠁꠈꠣꠘ ꠀꠝꠞꠣ ꠎꠣꠘꠤ ꠘꠣ। ꠀꠞ ꠇꠦ ꠔꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠇꠞꠍꠂꠘ, ꠔꠣ-ꠅ ꠇꠁꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ। ꠢꠦ ꠔ ꠛꠠ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠞꠦꠃ ꠎꠤꠇꠣꠃꠇ꠆ꠇꠣ, ꠔꠣꠞ ꠛꠦꠙꠣꠞ ꠢꠦ ꠇꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("JN9_22","073_9_22","JHN","9","22","22","ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠒꠞꠦ ꠅꠟꠣ ꠝꠣꠔꠤꠟꠣ, ꠇꠣꠞꠘ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠀꠉ ꠕꠣꠇꠤꠃ ꠀꠁꠘ ꠇꠞꠍꠤꠟꠣ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠍꠣꠞꠦ ꠀꠟ-ꠝꠍꠤ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN9_23","073_9_23","JHN","9","23","23","ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠦ ꠇꠁꠟꠣ, “ꠢꠦ ꠛꠠ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠞꠦꠃ ꠎꠤꠇꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN9_24","073_9_24","JHN","9","24","24","ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠣꠞꠦ ꠀꠘꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠢꠣꠍꠣ ꠝꠣꠔ ꠝꠣꠔꠅ। ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ ꠁ ꠝꠣꠘꠥꠡꠐꠣ ꠉꠥꠘꠣꠉꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN9_25","073_9_25","JHN","9","25","25","ꠢꠦ ꠎꠥꠀꠙ ꠖꠤꠟ, “ꠔꠣꠁꠘ ꠉꠥꠘꠣꠉꠣꠞ ꠘꠣ ꠇꠤꠔꠣ, ꠁꠈꠣꠘ ꠀꠝꠤ ꠎꠣꠘꠤ ꠘꠣ। ꠈꠣꠟꠤ ꠅꠈꠣꠘ ꠎꠣꠘꠤ, ꠀꠝꠤ ꠀꠉꠦ ꠀꠘ꠆ꠖꠣ ꠀꠍꠟꠣꠝ, ꠅꠈꠘ ꠌꠃꠈꠦ ꠖꠦꠈꠤꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN9_26","073_9_26","JHN","9","26","26","ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠢꠦ ꠔꠥꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠞꠍꠦ? ꠔꠥꠝꠣꠞ ꠌꠃꠈ ꠇꠤꠟꠣ ꠜꠣꠟꠣ ꠇꠞꠟ?” ");
INSERT INTO syls_vpl VALUES ("JN9_27","073_9_27","JHN","9","27","27","ꠅꠃ ꠛꠦꠐꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟ, “ꠀꠝꠤ ꠔ ꠀꠉꠦꠃ ꠇꠁꠟꠣꠝ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠢꠥꠘꠟꠣ ꠘꠣ। ꠔꠦ ꠅꠈꠘ ꠇꠦꠘꠦ ꠀꠞ ꠢꠥꠘꠔꠣ ꠌꠣꠁꠞꠣ? ꠀꠙꠘꠣꠞꠣꠅ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠁꠔꠣ ꠌꠣꠁꠞꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN9_28","073_9_28","JHN","9","28","28","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠛꠦꠐꠣꠞꠦ ꠈꠥꠛ ꠉꠣꠟꠣ-ꠉꠣꠟꠤ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠢꠂ, ꠔꠥꠁ ꠉꠤꠀ ꠅꠉꠥꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠍꠔ, ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠅꠁꠟꠣꠝ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠃꠝ꠆ꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("JN9_29","073_9_29","JHN","9","29","29","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠂꠘ, ꠅꠁꠟꠦ ꠁ ꠛꠦꠐꠣ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍꠦ, ꠁꠔꠣ ꠔ ꠀꠝꠞꠣ ꠎꠣꠘꠤꠃ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN9_30","073_9_30","JHN","9","30","30","ꠔꠦꠃ ꠛꠦꠐꠣꠄ ꠇꠁꠟ, “ꠇꠤ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ! ꠀꠙꠘꠣꠞꠣ ꠎꠣꠘꠂꠘ ꠘꠣ ꠔꠣꠁꠘ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍꠂꠘ, ꠅꠕꠌ ꠔꠣꠁꠘꠃ ꠀꠝꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN9_31","073_9_31","JHN","9","31","31","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠇꠕꠣ ꠀꠟ꠆ꠟꠣꠄ ꠢꠥꠘꠂꠘ ꠘꠣ। ꠅꠁꠟꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠀꠡꠤꠇ ꠛꠘꠤꠀ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠦ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞ ꠚꠞꠤꠀꠖ ꠢꠥꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN9_32","073_9_32","JHN","9","32","32","ꠀꠞ ꠀꠁꠎ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠟꠣ ꠢꠥꠘꠣ ꠉꠦꠍꠦ ꠘꠣ ꠎꠦꠘ, ꠎꠘꠝ ꠕꠣꠇꠤ ꠀꠘ꠆ꠖꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠌꠃꠈ ꠇꠦꠃ ꠜꠣꠟꠣ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN9_33","073_9_33","JHN","9","33","33","ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠘꠣ ꠀꠁꠔꠣ, ꠔꠦ ꠁꠟꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN9_34","073_9_34","JHN","9","34","34","ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠞ ꠎꠘꠝ ꠅꠁꠍꠦ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠝꠣꠎꠦ, ꠀꠞ ꠔꠥꠁ ꠀꠝꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠦ ꠘꠤ?” ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠞꠣ ꠔꠣꠞꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠄꠇꠊꠞꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN9_35","073_9_35","JHN","9","35","35","ꠁꠍꠣꠄ ꠢꠥꠘꠟꠣ, ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠄꠇꠊꠞꠤ ꠇꠞꠍꠂꠘ। ꠔꠣꠁꠘ ꠅꠃ ꠛꠦꠐꠣꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠛꠣꠞ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN9_36","073_9_36","JHN","9","36","36","ꠢꠦ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠔꠣꠁꠘ ꠇꠦ? ꠀꠝꠣꠞꠦ ꠇꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠎꠣꠔꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠔꠣꠝ ꠙꠣꠞꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN9_37","073_9_37","JHN","9","37","37","ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠍ, ꠀꠞ ꠔꠣꠁꠘꠃ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN9_38","073_9_38","JHN","9","38","38","ꠅꠃ ꠛꠦꠐꠣꠄ ꠇꠁꠟ, “ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠁꠝꠣꠘ ꠀꠘꠟꠣꠝ।” ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠢꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("JN9_39","073_9_39","JHN","9","39","39","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠀꠁꠍꠤ ꠁ ꠖꠥꠘꠤꠀꠔ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠎꠦꠞꠣ ꠀꠘ꠆ꠖꠣ ꠀꠍꠂꠘ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠜꠣꠟꠣ ꠅꠁꠘ, ꠀꠞ ꠜꠣꠟꠣ ꠅꠇꠟ ꠀꠘ꠆ꠖꠣ ꠅꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN9_40","073_9_40","JHN","9","40","40","ꠅꠃ ꠡꠝꠄ ꠇꠄꠎꠘ ꠚꠞꠤꠡꠤꠅ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠍꠟꠣ। ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠇꠁꠔꠣ ꠌꠣꠁꠞꠣ, ꠀꠝꠞꠣ ꠀꠘ꠆ꠖꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN9_41","073_9_41","JHN","9","41","41","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠘ꠆ꠖꠣ ꠅꠁꠔꠣꠄ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠖꠥꠡꠤ ꠅꠁꠟꠣꠄ ꠘꠣ ꠅꠘꠦ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠃ ꠇꠁꠞꠣꠄ ꠀꠘ꠆ꠖꠣ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠖꠥꠡ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN10_1","073_10_1","JHN","10","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠝꠣꠘꠥꠡ ꠝꠦꠠꠣꠞ ꠉꠥꠀꠟ-ꠊꠞꠞ ꠖꠥꠀꠞꠦꠖꠤ ꠘꠣ ꠢꠣꠝꠣꠁꠀ, ꠅꠁꠘ꠆ꠘ ꠙꠕꠦ ꠢꠣꠝꠣꠄ, ꠢꠦ ꠔ ꠌꠥꠞ-ꠒꠣꠇꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("JN10_2","073_10_2","JHN","10","2","2","ꠅꠁꠟꠦ ꠎꠦ ꠎꠘ ꠖꠥꠀꠞꠦꠖꠤ ꠢꠣꠝꠣꠄ, ꠢꠦ-ꠃ ꠝꠦꠠꠣꠞ ꠞꠣꠈꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("JN10_3","073_10_3","JHN","10","3","3","ꠉꠥꠀꠟ-ꠊꠞꠞ ꠌꠇꠤꠖꠣꠞꠦ ꠞꠣꠈꠣꠟꠞꠦ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠀ ꠖꠦꠄ। ꠝꠦꠠꠣꠁꠘ꠆ꠔꠦꠅ ꠞꠣꠈꠣꠟꠞ ꠒꠣꠇ ꠢꠥꠘꠂꠘ ꠀꠞ ꠞꠣꠈꠣꠟꠦ ꠔꠣꠞꠣꠞ ꠘꠣꠝ ꠗꠞꠤ ꠒꠣꠇꠤ ꠒꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠘꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("JN10_4","073_10_4","JHN","10","4","4","ꠊꠞ ꠕꠣꠇꠤ ꠘꠤꠎꠞ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠞꠣꠈꠣꠟ ꠔꠣꠞꠣꠞ ꠀꠉꠦ ꠀꠉꠦ ꠎꠣꠄ, ꠀꠞ ꠔꠣꠞ ꠝꠦꠠꠣꠁꠘ ꠎꠣꠄ ꠈꠞꠦ ꠈꠞꠦ, ꠇꠣꠞꠘ ꠔꠣꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠔꠣꠞꠣ ꠌꠤꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("JN10_5","073_10_5","JHN","10","5","5","ꠔꠣꠞꠣ ꠇꠥꠘꠥꠛꠣꠟꠣ ꠅꠌꠤꠘꠣ ꠇꠥꠘꠥ ꠞꠣꠈꠣꠟꠞ ꠟꠉꠦ ꠎꠣꠁꠔ ꠘꠣꠄ ꠛꠞꠋ ꠔꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠛ, ꠇꠣꠞꠘ ꠅꠌꠤꠘꠣ ꠇꠥꠘꠥ ꠞꠣꠈꠣꠟꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠔꠣꠞꠣ ꠌꠤꠘꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN10_6","073_10_6","JHN","10","6","6","ꠁꠍꠣꠄ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞꠦ ꠢꠤꠇꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠅꠃ ꠃꠖꠣꠢꠞꠘ ꠖꠤꠟꠣ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠤꠔꠣ ꠛꠥꠎꠣꠁꠞꠣ, ꠔꠣꠞꠣ ꠡꠝꠎꠤꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN10_7","073_10_7","JHN","10","7","7","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠝꠦꠠꠣꠞ ꠙꠣꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠤꠃ ꠖꠥꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("JN10_8","073_10_8","JHN","10","8","8","ꠀꠝꠣꠞ ꠀꠉꠦ ꠞꠣꠈꠣꠟꠞ ꠜꠣꠛ ꠗꠞꠤꠀ ꠎꠦꠔꠣ ꠀꠁꠍꠟꠣ, ꠁꠉꠥꠁꠘ ꠔ ꠌꠥꠞ-ꠒꠣꠇꠣꠁꠔ ꠀꠍꠟꠣ, ꠝꠦꠠꠣꠁꠘ꠆ꠔꠦꠅ ꠔꠣꠞꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN10_9","073_10_9","JHN","10","9","9","ꠀꠝꠤꠃ ꠖꠥꠀꠞ। ꠀꠝꠣꠞ ꠝꠣꠎꠖꠤ ꠎꠦ ꠢꠣꠝꠣꠁꠛ, ꠢꠦ ꠔꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠛ। ꠢꠦ ꠜꠤꠔꠞꠦ ꠀꠅꠀ-ꠎꠣꠅꠀ ꠇꠞꠛ ꠀꠞ ꠀꠐꠤꠀ-ꠌꠞꠤꠀ ꠈꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN10_10","073_10_10","JHN","10","10","10","ꠌꠥꠞꠦ ꠔ ꠈꠣꠟꠤ ꠌꠥꠞꠤ, ꠈꠥꠘ-ꠈꠣꠞꠣꠙꠤ ꠀꠞ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦꠃ ꠀꠄ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠀꠁꠍꠤ ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠄ, ꠀꠞ ꠅꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠜꠥꠉ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("JN10_11","073_10_11","JHN","10","11","11","“ꠀꠝꠤꠃ ꠀꠍꠟ ꠞꠣꠈꠣꠟ। ꠀꠍꠟ ꠞꠣꠈꠣꠟꠦ ꠔꠣꠞ ꠝꠦꠠꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("JN10_12","073_10_12","JHN","10","12","12","ꠈꠣꠟꠤ ꠛꠦꠔꠘꠞ ꠟꠣꠉꠤ ꠎꠦ ꠎꠘꠦ ꠞꠣꠈꠣꠟꠤ ꠇꠞꠦ, ꠢꠦ ꠈꠣꠐꠤ ꠞꠣꠈꠣꠟ ꠘꠣꠄ ꠀꠞ ꠁ ꠝꠦꠠꠣꠁꠘꠅ ꠔꠣꠞ ꠘꠤꠎꠞ ꠘꠣꠄ। ꠛꠣꠊ ꠀꠅꠀꠔ ꠖꠦꠈꠟꠦꠃ ꠢꠦ ꠝꠦꠠꠣꠁꠘ ꠚꠣꠟꠣꠁꠀ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN10_13","073_10_13","JHN","10","13","13","ꠇꠣꠞꠘ ꠢꠦ ꠈꠣꠟꠤ ꠛꠦꠔꠘꠞ ꠀꠡꠣꠄ ꠞꠣꠈꠣꠟꠤ ꠇꠞꠦ, ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞ ꠇꠕꠣ ꠌꠤꠘ꠆ꠔꠣꠅ ꠇꠞꠦ ꠘꠣ। ꠜꠣꠉꠦ ꠀꠁꠀ ꠝꠦꠠꠣꠁꠘ ꠗꠞꠤꠀ ꠘꠦꠄꠉꠤ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠙꠣꠟ ꠜꠣꠋꠉꠤꠀ ꠍꠤꠔ꠆ꠞꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN10_14","073_10_14","JHN","10","14","15","ꠔꠦ ꠀꠝꠤꠃ ꠜꠣꠟꠣ ꠞꠣꠈꠣꠟ। ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠂꠘ, ꠀꠞ ꠀꠝꠤꠅ ꠀꠝꠣꠞ ꠛꠣꠚꠞꠦ ꠌꠤꠘꠤ। ꠑꠤꠇ ꠅꠃꠟꠣ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠞꠦꠅ ꠌꠤꠘꠤ, ꠀꠞ ꠀꠝꠣꠞ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠦꠅ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠂꠘ। ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠦꠠꠣ ꠙꠣꠟꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠎꠣꠘ ꠖꠤꠟꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN10_16","073_10_16","JHN","10","16","16","ꠀꠝꠣꠞ ꠔ ꠀꠞꠅ ꠝꠦꠠꠣꠁꠘ ꠀꠍꠂꠘ, ꠎꠦꠔꠣ ꠁ ꠉꠥꠀꠟ-ꠊꠞꠅ ꠘꠣꠁ, ꠔꠣꠞꠣꠞꠦꠅ ꠀꠝꠤ ꠀꠘꠔꠦ ꠅꠁꠛ। ꠔꠣꠞꠣ ꠘꠤꠌ꠆ꠌꠄ ꠀꠝꠣꠞ ꠒꠣꠇ ꠢꠥꠘꠛꠣ, ꠔꠦꠃ ꠈꠣꠟꠤ ꠄꠇꠎꠘ ꠞꠣꠈꠣꠟ ꠀꠞ ꠄꠇꠐꠣ ꠙꠣꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN10_17","073_10_17","JHN","10","17","17","“ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠂꠘ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠁꠝꠥ ꠎꠣꠔꠦ ꠢꠤꠞꠛꠣꠞ ꠚꠤꠞꠔ ꠘꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("JN10_18","073_10_18","JHN","10","18","18","ꠀꠝꠣꠞ ꠎꠣꠘ ꠇꠦꠃ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠣꠠꠤꠀ ꠘꠤꠔ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠘꠤꠎꠦꠃ ꠎꠣꠘ ꠛꠤꠟꠣꠁꠝꠥ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠎꠣꠘ ꠖꠦꠅꠀꠞ ꠈꠦꠝꠔꠣ ꠎꠦꠟꠣ ꠀꠝꠣꠞ ꠀꠍꠦ, ꠅꠃꠟꠣ ꠚꠤꠞꠔ ꠘꠦꠅꠀꠞ ꠈꠦꠝꠔꠣꠅ ꠀꠍꠦ। ꠁ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠝꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN10_19","073_10_19","JHN","10","19","19","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠁꠔꠣ ꠝꠣꠔ-ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("JN10_20","073_10_20","JHN","10","20","20","ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠃꠔꠦ ꠇꠁꠟ, “ꠅꠉꠥꠞꠦ ꠜꠥꠔꠦ ꠗꠞꠍꠦ, ꠢꠦ ꠙꠣꠉꠟ, ꠔꠥꠝꠞꠣ ꠅꠉꠥꠞ ꠝꠣꠔ ꠢꠥꠘꠞꠣꠄ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN10_21","073_10_21","JHN","10","21","21","ꠀꠞ ꠛꠃꠔꠦ ꠇꠁꠟ, “ꠜꠥꠔꠦ ꠗꠞꠣ ꠝꠣꠘꠡꠞ ꠝꠣꠔ ꠔ ꠁꠟꠣ ꠘꠣꠄ। ꠜꠥꠔꠦ ꠇꠥꠘꠥ ꠀꠘ꠆ꠖꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠇꠞꠦ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN10_22","073_10_22","JHN","10","22","22","ꠛꠣꠖꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠇꠣꠛꠣ ꠊꠞꠞ ꠖꠈꠟ ꠙꠣꠅꠀꠞ ꠁꠖꠞ ꠡꠝꠄ ꠀꠁꠀ ꠀꠎꠤꠟ। ꠅꠃ ꠡꠝꠄ ꠀꠍꠤꠟ ꠡꠤꠔꠞ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("JN10_23","073_10_23","JHN","10","23","23","ꠢꠎꠞꠔ ꠁꠍꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠛꠣꠖꠡꠣ ꠍꠥꠟꠣꠁꠝꠣꠘꠞ ꠛꠣꠞꠤꠘ꠆ꠖꠣꠔ ꠀꠐꠣ-ꠃꠐꠤ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN10_24","073_10_24","JHN","10","24","24","ꠄꠞꠝꠣꠎꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟ ꠁꠍꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠖꠟꠣ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠀꠞ ꠇꠔꠖꠤꠘ ꠔꠥꠝꠤ ꠀꠝꠞꠣꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠞꠣꠈꠔꠣꠄ? ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠢꠣꠍꠣꠞꠞ ꠀꠟ-ꠝꠍꠤ ꠅꠅ, ꠔꠦ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠞꠤ ꠀꠝꠞꠣꠞꠦ ꠇꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN10_25","073_10_25","JHN","10","25","25","ꠔꠦꠃ ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔ ꠇꠁꠟꠣꠝ, ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠞꠣ ꠘꠣ, ꠀꠞ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠎꠦ ꠇꠣꠝ ꠇꠞꠤ, ꠁꠔꠣꠄꠅ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠞ, ");
INSERT INTO syls_vpl VALUES ("JN10_26","073_10_26","JHN","10","26","26","ꠔꠣ-ꠅ ꠀꠙꠘꠣꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠞꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞ ꠙꠣꠟꠞ ꠝꠦꠠꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN10_27","073_10_27","JHN","10","27","27","ꠀꠝꠣꠞ ꠝꠦꠠꠣꠁꠘ꠆ꠔꠦ ꠀꠝꠣꠞ ꠒꠣꠇ ꠢꠥꠘꠂꠘ। ꠀꠝꠤ ꠔ ꠔꠣꠞꠣꠞꠦ ꠌꠤꠘꠤ ꠀꠞ ꠔꠣꠞꠣꠅ ꠀꠝꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN10_28","073_10_28","JHN","10","28","28","ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠤ, ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠡꠝꠄ ꠛꠤꠘꠣꠡ ꠅꠁꠔꠣ ꠘꠣꠄ। ꠇꠦꠃ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠣꠠꠤꠀ ꠘꠤꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN10_29","073_10_29","JHN","10","29","29","ꠀꠝꠣꠞ ꠎꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠔꠣꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠤꠍꠂꠘ, ꠔꠣꠁꠘ ꠢꠇꠟ ꠕꠣꠇꠤ ꠝꠢꠣꠘ। ꠔꠣꠘ ꠀꠔ ꠕꠣꠇꠤ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠇꠣꠠꠤꠀ ꠘꠤꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN10_30","073_10_30","JHN","10","30","30","ꠀꠝꠤ ꠀꠞ ꠛꠣꠛꠣ, ꠀꠝꠞꠣ ꠄꠇ।” ");
INSERT INTO syls_vpl VALUES ("JN10_31","073_10_31","JHN","10","31","31","ꠔꠦꠃ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠢꠤꠞꠛꠣꠞ ꠙꠣꠔ꠆ꠔꠞ ꠟꠁꠟꠣ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN10_32","073_10_32","JHN","10","32","32","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠛꠃꠔ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠇꠣꠝ ꠀꠝꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠖꠦꠈꠣꠁꠍꠤ। ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠔꠣ ꠌꠣꠁꠞꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN10_33","073_10_33","JHN","10","33","33","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠜꠣꠟꠣ ꠇꠥꠘꠥ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠔꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀꠞ ꠘꠣ, ꠔꠥꠁ ꠔ ꠡꠤꠞꠤꠇꠤ ꠇꠞꠞꠦ, ꠄꠞꠟꠣꠉꠤꠃ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠝꠥ। ꠝꠣꠘꠥꠡ ꠅꠁꠀ ꠔꠥꠁ ꠘꠤꠎꠞꠦ ꠀꠟ꠆ꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠖꠣꠛꠤ ꠇꠞꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN10_34","073_10_34","JHN","10","34","34","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣꠞ ꠡꠞꠤꠅꠔꠅ ꠟꠦꠈꠣ ꠀꠍꠦ ꠘꠣ ꠘꠤ, ‘ꠀꠝꠤ ꠇꠁꠟꠣꠝ, ꠔꠥꠝꠞꠣꠃ ꠄꠟꠣꠢꠤ’? ");
INSERT INTO syls_vpl VALUES ("JN10_35","073_10_35","JHN","10","35","35","ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠎꠦꠞꠣꠞ ꠉꠦꠍꠦ ꠘꠣꠎꠤꠟ ꠅꠁꠍꠤꠟ, ꠄꠞꠣꠞꠦ ꠔ ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠁꠀ ꠒꠣꠇꠤꠍꠂꠘ। ꠀꠞ ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠇꠕꠣ ꠔ ꠛꠣꠖ ꠖꠦꠅꠀ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN10_36","073_10_36","JHN","10","36","36","ꠔꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠎꠣꠘꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠛꠣꠍꠤꠀ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠣ ꠀꠞ ꠖꠥꠘꠤꠀꠔ ꠙꠣꠑꠣꠁꠟꠣ, ꠅꠃ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠇꠁꠟꠣꠝ, ꠀꠝꠤ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠇꠤꠟꠣ ꠇꠁꠞꠣ, ꠔꠥꠁ ꠡꠤꠞꠤꠇꠤ ꠇꠞꠞꠦ? ");
INSERT INTO syls_vpl VALUES ("JN10_37","073_10_37","JHN","10","37","37","ꠀꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠇꠣꠝ ꠘꠣ ꠇꠞꠤ, ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠛꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN10_38","073_10_38","JHN","10","38","38","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠢꠇꠟ ꠇꠣꠝ ꠇꠞꠤꠀ ꠕꠣꠇꠤ, ꠔꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠘꠣ ꠀꠘꠟꠦꠅ ꠁꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠔꠦꠃ ꠀꠙꠘꠣꠞꠣ ꠎꠣꠘꠛꠣ, ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠝꠣꠞ ꠝꠣꠎꠦꠃ ꠀꠍꠂꠘ, ꠀꠞ ꠀꠝꠤꠅ ꠔꠣꠘ ꠝꠣꠎꠦ ꠀꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN10_39","073_10_39","JHN","10","39","39","ꠅꠃ ꠡꠝꠄ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠗꠞꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠟꠣ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠁꠘ ꠕꠘꠦ ꠉꠣꠁꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN10_40","073_10_40","JHN","10","40","40","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠎꠞ꠆ꠖꠣꠘ ꠉꠣꠋꠉꠞ ꠢꠙꠣꠞꠅ ꠉꠤꠀ ꠞꠁꠟꠣ। ꠀꠉꠦ ꠅꠃ ꠎꠣꠉꠣꠔ ꠢꠎꠞꠔ ꠄꠢꠤꠀꠄ ꠝꠣꠘꠡꠞꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN10_41","073_10_41","JHN","10","41","41","ꠢꠘꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ ꠀꠞ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠟ, “ꠄꠢꠤꠀ ꠘꠛꠤꠄ ꠔ ꠇꠥꠘꠥ ꠇꠦꠞꠣꠝꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣꠁꠍꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠔꠔꠣ ꠇꠁꠍꠟꠣ, ꠁꠔꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠢꠣꠍꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN10_42","073_10_42","JHN","10","42","42","ꠅꠈꠣꠘ ꠛꠥꠎꠤꠀ ꠢꠘꠞ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_1","073_11_1","JHN","11","1","1","ꠟꠣꠍꠣꠞ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠛꠦꠝꠣꠞ ꠀꠍꠟꠣ। ꠔꠣꠘ ꠛꠣꠠꠤ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠉꠣꠃꠔ, ꠝꠞꠤꠅꠝ ꠀꠞ ꠝꠣꠞꠕꠣ ꠘꠣꠝꠞ ꠔꠣꠘ ꠖꠥꠁ ꠛꠁꠘꠅ ꠅꠃ ꠉꠣꠃꠔ ꠞꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_2","073_11_2","JHN","11","2","2","ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠅꠃ ꠝꠞꠤꠅꠝꠦꠃ ꠁꠍꠣꠞ ꠙꠣꠅ-ꠅ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠀꠔꠞ ꠝꠣꠈꠣꠁꠀ, ꠘꠤꠎꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟꠖꠤ ꠙꠣꠅ ꠚꠥꠍꠣꠁ ꠖꠤꠛꠣ। ꠅꠃ ꠝꠞꠤꠅꠝꠞ ꠜꠣꠁ ꠅꠁꠟꠣ ꠛꠦꠝꠣꠞꠤ ꠟꠣꠍꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("JN11_3","073_11_3","JHN","11","3","3","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠛꠁꠘꠣꠁꠘ꠆ꠔꠦ ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠈꠛꠞ ꠙꠣꠑꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ ꠈꠥꠛ ꠛꠦꠝꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN11_4","073_11_4","JHN","11","4","4","ꠈꠛꠞ ꠙꠣꠁꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁ ꠛꠦꠝꠣꠞ ꠔ ꠔꠣꠞ ꠝꠃꠔꠞ ꠟꠣꠉꠤ ꠅꠁꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞꠞ ꠟꠣꠉꠤꠃ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠄꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠤ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣꠅ ꠎꠣꠁꠞ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN11_5","073_11_5","JHN","11","5","5","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠛꠤꠛꠤ ꠝꠣꠞꠕꠣ, ꠔꠣꠘ ꠛꠁꠘ ꠀꠞ ꠟꠣꠍꠣꠞꠞꠦ ꠈꠥꠛ ꠝꠣꠄꠀ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_6","073_11_6","JHN","11","6","6","ꠟꠣꠍꠣꠞꠞ ꠛꠦꠝꠣꠞꠞ ꠇꠕꠣ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦꠅ ꠁꠍꠣ ꠎꠦ ꠎꠣꠉꠣꠔ ꠀꠍꠟꠣ, ꠢꠘꠅ ꠀꠞꠅ ꠖꠥꠁꠖꠤꠘ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_7","073_11_7","JHN","11","7","7","ꠛꠣꠖꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠎꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN11_8","073_11_8","JHN","11","8","8","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠃ ꠇꠄꠖꠤꠘ ꠀꠉꠦ ꠢꠘꠞ ꠝꠣꠘꠡꠦ ꠀꠙꠘꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠈꠘ ꠀꠙꠘꠦ ꠢꠤꠞꠛꠣꠞ ꠢꠘꠅ ꠎꠣꠁꠔꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN11_9","073_11_9","JHN","11","9","9","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠖꠤꠘꠞ ꠛꠦꠟꠣ ꠔ ꠛꠣꠞꠅ ꠊꠘ꠆ꠐꠣ ꠀꠍꠦ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠖꠤꠘꠞ ꠛꠦꠟꠣ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠦ, ꠢꠦ ꠃꠡ꠆ꠐꠣ ꠈꠣꠄ ꠘꠣ, ꠇꠣꠞꠘ ꠢꠦ ꠅꠃ ꠖꠥꠘꠤꠀꠞ ꠚꠞ ꠖꠦꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("JN11_10","073_11_10","JHN","11","10","10","ꠀꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠞꠣꠁꠔꠞ ꠛꠦꠟꠣ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠦ, ꠢꠦ ꠃꠡ꠆ꠐꠣ ꠈꠣꠄ, ꠇꠣꠞꠘ ꠔꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠚꠞ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN11_11","073_11_11","JHN","11","11","11","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠞꠣꠞ ꠖꠥꠡ꠆ꠔ ꠟꠣꠍꠣꠞ ꠊꠥꠝꠣꠁ ꠉꠦꠍꠦꠉꠤ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠣꠔ ꠎꠣꠁꠀꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN11_12","073_11_12","JHN","11","12","12","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠢꠦ ꠎꠥꠖꠤ ꠊꠥꠝꠅ ꠕꠣꠇꠦ, ꠔꠦ ꠔ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN11_13","073_11_13","JHN","11","13","13","ꠁꠍꠣꠄ ꠟꠣꠍꠣꠞꠞ ꠝꠃꠔꠞ ꠇꠕꠣ ꠇꠁꠍꠟꠣ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠄꠝꠘꠦ ꠊꠥꠝꠞ ꠇꠕꠣ ꠇꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN11_14","073_11_14","JHN","11","14","14","ꠔꠦꠃ ꠁꠍꠣꠄ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠟꠣꠍꠣꠞ ꠝꠣꠞꠣ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN11_15","073_11_15","JHN","11","15","15","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣ ꠝꠘꠅ ꠇꠞꠤꠀ ꠈꠥꠡꠤ ꠅꠁꠍꠤ, ꠀꠝꠤ ꠢꠤꠘꠅ ꠀꠍꠟꠣꠝ ꠘꠣ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠔꠣꠄ ꠙꠣꠞ। ꠅꠈꠘ ꠀꠅ, ꠀꠝꠞꠣ ꠟꠣꠍꠣꠞꠞ ꠉꠦꠍꠦ ꠎꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN11_16","073_11_16","JHN","11","16","16","ꠔꠦꠃ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠕꠥꠝꠣꠍꠦ ꠟꠉꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ ꠘꠣ, ꠀꠝꠞꠣꠅ ꠎꠣꠁ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠟꠉꠦ ꠝꠞꠔꠣꠝ ꠙꠣꠞꠤ।” ꠅꠃ ꠕꠥꠝꠣꠍꠞꠦ ꠎꠝꠎ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JN11_17","073_11_17","JHN","11","17","17","ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠢꠥꠘꠟꠣ, ꠔꠣꠁꠘ ꠎꠣꠅꠀꠞ ꠌꠣꠁꠞ ꠖꠤꠘ ꠀꠉꠦꠃ ꠟꠣꠍꠣꠞꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN11_18","073_11_18","JHN","11","18","18","ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠅꠃ ꠛꠣꠄꠔ-ꠀꠘꠤꠀ ꠉꠣꠃ ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁ ꠝꠣꠁꠟ ꠖꠥꠞꠁ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN11_19","073_11_19","JHN","11","19","19","ꠟꠣꠍꠣꠞꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠔꠣꠘ ꠛꠁꠘ ꠛꠤꠛꠤ ꠝꠣꠞꠕꠣ ꠀꠞ ꠝꠞꠤꠅꠝꠞꠦ ꠛꠥꠎ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠁꠢꠥꠖꠤ ꠡꠝꠣꠎꠞ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_20","073_11_20","JHN","11","20","20","ꠄꠞꠝꠣꠎꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ ꠢꠥꠘꠤꠀ ꠛꠤꠛꠤ ꠝꠣꠞꠕꠣ ꠔꠣꠘ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠔ ꠉꠦꠟꠣ, ꠅꠁꠟꠦ ꠝꠞꠤꠅꠝ ꠊꠞꠅ ꠛꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_21","073_11_21","JHN","11","21","21","ꠛꠤꠛꠤ ꠝꠣꠞꠕꠣꠄ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠎꠥꠖꠤ ꠅꠘꠅ ꠞꠁꠔꠣ, ꠔꠦ ꠀꠝꠣꠞ ꠜꠣꠁꠉꠥ ꠝꠞꠟ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("JN11_22","073_11_22","JHN","11","22","22","ꠅꠁꠟꠦ ꠄꠞꠛꠣꠖꠦꠅ ꠀꠝꠤ ꠎꠣꠘꠤ, ꠀꠙꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠌꠣꠁꠛꠣ, ꠔꠣꠁꠘ ꠀꠙꠘꠣꠞꠦ ꠅꠔꠣ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN11_23","073_11_23","JHN","11","23","23","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠔꠥꠝꠣꠞ ꠜꠣꠁ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN11_24","073_11_24","JHN","11","24","24","ꠔꠦꠃ ꠝꠣꠞꠕꠣꠄ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ, ꠀꠝꠤ ꠎꠣꠘꠤ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠎꠦꠛꠟꠣ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠢꠦ-ꠅ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN11_25","073_11_25","JHN","11","25","25","ꠁꠍꠣꠄ ꠝꠣꠞꠕꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠔ ꠇꠤꠀꠝꠔ ꠀꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ ꠢꠦ ꠝꠞꠟꠦꠅ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN11_26","073_11_26","JHN","11","26","26","ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠢꠦ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠝꠞꠔ ꠘꠣꠄ। ꠔꠥꠝꠤ ꠁꠈꠣꠘ ꠄꠇꠤꠘ ꠇꠞ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN11_27","073_11_27","JHN","11","27","27","ꠝꠣꠞꠕꠣꠄ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ ꠢꠥꠎꠥꠞ, ꠀꠝꠤ ꠁꠝꠣꠘ ꠀꠘꠍꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠎꠦ ꠎꠘꠦ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠕꠣ, ꠀꠙꠘꠦꠃ ꠢꠃ ꠀꠟ-ꠝꠍꠤ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN11_28","073_11_28","JHN","11","28","28","ꠅꠈꠣꠘ ꠇꠁꠀ ꠝꠣꠞꠕꠣꠄ ꠉꠤꠀ ꠔꠣꠘ ꠛꠁꠘ ꠝꠞꠤꠅꠝꠞꠦ ꠌꠥꠙꠔꠦ ꠒꠣꠇꠤꠀ ꠘꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠢꠥꠎꠥꠞ ꠅꠘꠅ ꠀꠍꠂꠘ, ꠔꠣꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠒꠣꠇꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN11_29","073_11_29","JHN","11","29","29","ꠔꠦꠃ ꠝꠞꠤꠅꠝ ꠎꠟꠖꠤ ꠇꠞꠤ ꠁꠍꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_30","073_11_30","JHN","11","30","30","ꠁꠍꠣ ꠅꠃ ꠡꠝꠄꠅ ꠉꠣꠃꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠍꠂꠘ ꠘꠣ, ꠝꠣꠞꠕꠣꠄ ꠔꠣꠘ ꠟꠉꠦ ꠎꠦꠘꠅ ꠖꠦꠈꠣ ꠇꠞꠍꠟꠣ, ꠔꠣꠁꠘ ꠢꠘꠅꠃ ꠃꠛꠣꠁ ꠞꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_31","073_11_31","JHN","11","31","31","ꠀꠞ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠝꠞꠤꠅꠝꠞꠦ ꠛꠥꠎ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ, ꠝꠞꠤꠅꠝꠦ ꠀꠈꠔꠣꠃ ꠛꠣꠞꠦ ꠎꠣꠅꠀꠔ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟꠣ। ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠟ, ꠝꠞꠤꠅꠝ ꠇꠄꠛꠞꠞ ꠉꠦꠍꠦ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_32","073_11_32","JHN","11","32","32","ꠁꠍꠣ ꠎꠦ ꠎꠣꠉꠣꠔ ꠀꠍꠟꠣ, ꠝꠞꠤꠅꠝꠅ ꠢꠘꠅ ꠉꠦꠟꠣ ꠀꠞ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠙꠣꠅ-ꠅ ꠙꠠꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠎꠥꠖꠤ ꠅꠘꠅ ꠕꠣꠇꠔꠣ, ꠔꠦ ꠀꠝꠣꠞ ꠜꠣꠁꠉꠥ ꠝꠞꠟ ꠘꠣ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN11_33","073_11_33","JHN","11","33","33","ꠝꠞꠤꠅꠝ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠇꠣꠘ꠆ꠖꠘ-ꠀꠢꠣꠎꠣꠞꠤ ꠖꠦꠈꠤꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠖꠤꠟꠞ ꠞꠥꠢꠥ ꠉꠞꠝ ꠅꠁꠉꠦꠟ, ꠔꠣꠁꠘ ꠇꠣꠔꠞ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_34","073_11_34","JHN","11","34","34","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠟꠣꠍꠣꠞꠞꠦ ꠇꠥꠀꠁ ꠖꠣꠚꠘ ꠇꠞꠍ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ ꠀꠃꠇ꠆ꠇꠣ, ꠖꠦꠈꠤ ꠎꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN11_35","073_11_35","JHN","11","35","35","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠇꠣꠘ꠆ꠖꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_36","073_11_36","JHN","11","36","36","ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠘ ꠖꠦꠈꠤꠀ ꠢꠘꠞ ꠄꠞꠣ ꠇꠁꠟꠣ, “ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠔꠣꠁꠘ ꠟꠣꠍꠣꠞꠞꠦ ꠇꠔ ꠝꠣꠄꠀ ꠇꠞꠔꠣ!” ");
INSERT INTO syls_vpl VALUES ("JN11_37","073_11_37","JHN","11","37","37","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠇꠁꠟꠣ, “ꠎꠦꠁꠘ ꠀꠘ꠆ꠖꠣꠞ ꠌꠃꠈ ꠜꠣꠟꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠟꠣ ꠅꠘꠦ ꠘꠣ ꠘꠤ, ꠎꠣꠔꠦ ꠟꠣꠍꠣꠞꠉꠥ ꠘꠣ ꠝꠞꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN11_38","073_11_38","JHN","11","38","38","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠖꠤꠟꠞ ꠞꠥꠢꠥ ꠢꠤꠞꠛꠣꠞ ꠉꠞꠝ ꠅꠁꠉꠦꠟ, ꠔꠣꠁꠘ ꠟꠣꠍꠣꠞꠞ ꠇꠄꠛꠞꠞ ꠗꠣꠞꠅ ꠉꠦꠟꠣ। ꠁ ꠇꠄꠛꠞ ꠀꠍꠤꠟ ꠉꠥꠢꠣꠞ ꠟꠣꠈꠣꠘ ꠄꠇ ꠉꠣꠔꠅ ꠀꠞ ꠇꠄꠛꠞꠞ ꠝꠥꠈꠅ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞ ꠖꠦꠅꠀ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN11_39","073_11_39","JHN","11","39","39","ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠙꠣꠔ꠆ꠔꠞꠐꠣ ꠢꠞꠣꠅ।” ꠟꠣꠍꠣꠞꠞ ꠛꠁꠘ ꠝꠣꠞꠕꠣꠄ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠈꠘ ꠔ ꠟꠣꠡ ꠙꠌꠤꠀ ꠉꠘ꠆ꠖ ꠛꠣꠞ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠁꠘ ꠌꠣꠁꠞ ꠖꠤꠘ ꠀꠉꠦ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN11_40","073_11_40","JHN","11","40","40","ꠁꠍꠣꠄ ꠄꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠍꠤ, ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠄꠇꠤꠘ ꠇꠞ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣ ꠖꠦꠈꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN11_41","073_11_41","JHN","11","41","41","ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠇꠄꠛꠞꠞ ꠝꠥꠈꠞ ꠙꠣꠔ꠆ꠔꠞꠐꠣ ꠢꠞꠣꠁꠟꠣ। ꠁꠍꠣꠄ ꠀꠍꠝꠣꠘꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠖꠥꠀ ꠇꠞꠟꠣ, “ꠅ ꠉꠣꠁꠛꠤ ꠛꠣꠛꠣ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠍ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("JN11_42","073_11_42","JHN","11","42","42","ꠀꠝꠤ ꠎꠣꠘꠤ, ꠔꠥꠝꠤ ꠢꠣꠝꠦꠡꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘ। ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠀꠍꠂꠘ, ꠔꠣꠞꠣ ꠎꠣꠔꠦ ꠄꠇꠤꠘ ꠇꠞꠂꠘ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍ, ꠄꠞꠖꠣꠄꠃ ꠅꠈꠣꠘ ꠇꠁꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN11_43","073_11_43","JHN","11","43","43","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠎꠥꠞꠦ ꠒꠣꠇ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠟꠣꠍꠣꠞ, ꠛꠣꠞ ꠅꠁꠀ ꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN11_44","073_11_44","JHN","11","44","44","ꠔꠦꠃ ꠝꠥꠞ꠆ꠖꠣ ꠟꠣꠍꠣꠞ ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ। ꠔꠣꠘ ꠀꠔ-ꠙꠣꠅ ꠇꠣꠚꠘꠖꠤ ꠙꠦꠌꠣꠁꠟ ꠀꠍꠤꠟ, ꠀꠞ ꠝꠥꠈ ꠀꠍꠤꠟ ꠞꠥꠝꠣꠟ ꠖꠤꠀ ꠛꠣꠘ꠆ꠖꠣ। ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠔꠣꠞ ꠛꠣꠘ꠆ꠖ ꠈꠥꠟꠅ ꠀꠞ ꠔꠣꠞꠦ ꠎꠣꠁꠔꠦ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN11_45","073_11_45","JHN","11","45","45","ꠛꠤꠛꠤ ꠝꠞꠤꠅꠝꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤ ꠝꠣꠘꠥꠡ ꠀꠁꠍꠟꠣ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠅꠃ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠤꠀ ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠃꠔꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_46","073_11_46","JHN","11","46","46","ꠅꠁꠟꠦ ꠇꠦꠃ ꠇꠦꠃ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠁꠍꠣꠞ ꠅꠃ ꠇꠣꠝꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN11_47","073_11_47","JHN","11","47","47","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠀꠞ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠝꠣꠘꠡꠦ ꠖꠦꠡꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞꠦ ꠟꠁꠀ ꠄꠇꠈꠣꠘꠅ ꠛꠁꠟꠣ, ꠛꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠅꠈꠘ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ? ꠁ ꠛꠦꠐꠣꠄ ꠔ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("JN11_48","073_11_48","JHN","11","48","48","ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠔꠣꠞꠦ ꠄꠝꠘꠦ ꠌꠟꠔꠦ ꠖꠦꠁ, ꠔꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠛ, ꠀꠞ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠞꠥꠝꠣꠘ ꠡꠞꠇꠣꠞꠞ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞ ꠑꠤꠇꠣꠘꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠎꠣꠔꠤꠞꠦꠅ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN11_49","073_11_49","JHN","11","49","49","ꠅꠃ ꠝꠎꠟꠤꠍꠞ ꠝꠣꠎꠦ ꠅꠃ ꠛꠍꠞꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ, ꠇꠣꠄꠀꠚꠣ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠀꠍꠟꠣ। ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔ ꠇꠥꠘ꠆ꠔꠣꠃ ꠎꠣꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_50","073_11_50","JHN","11","50","50","ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠀꠡ꠆ꠔꠣ ꠎꠣꠔꠤ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠌꠣꠁꠔꠦ, ꠢꠇꠟꠞ ꠛꠖꠟꠣ ꠄꠇꠎꠘꠞ ꠝꠞꠘ ꠀꠞꠅ ꠜꠣꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN11_51","073_11_51","JHN","11","51","51","ꠁꠝꠣꠝ ꠇꠣꠄꠀꠚꠣꠄ ꠀꠍꠟꠦ ꠘꠤꠎꠞ ꠝꠘ ꠕꠣꠇꠤ ꠅꠃ ꠇꠕꠣ ꠇꠁꠍꠂꠘ ꠘꠣ, ꠔꠣꠁꠘ ꠅꠃ ꠛꠍꠞꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠀꠄ ꠉꠣꠁꠛꠤ ꠛꠥꠟꠤ ꠔꠣꠘ ꠝꠥꠈ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠍꠦ ꠎꠦ, ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠍꠣꠞ ꠝꠞꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN11_52","073_11_52","JHN","11","52","52","ꠈꠣꠟꠤ ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤꠞ ꠟꠣꠉꠤ ꠘꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠎꠔ ꠛꠘ꠆ꠖꠣꠁꠘ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤꠀ ꠀꠍꠂꠘ, ꠔꠣꠞꠣꠞꠦ ꠖꠟꠣ ꠇꠞꠤꠀ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠔꠣꠁꠘ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_53","073_11_53","JHN","11","53","53","ꠢꠃ ꠖꠤꠘ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠝꠣꠞꠣꠞ ꠙꠣꠄꠔꠣꠞꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_54","073_11_54","JHN","11","54","54","ꠄꠞꠟꠣꠉꠤ ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠟꠣ, ꠀꠞ ꠅꠃ ꠎꠣꠉꠣ ꠍꠣꠠꠤꠀ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠚꠞꠣꠁꠝ ꠘꠣꠝꠞ ꠄꠇ ꠉꠣꠃꠔ ꠉꠤꠀ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_55","073_11_55","JHN","11","55","55","ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠀꠎꠣꠖꠤ ꠁꠖ ꠊꠘꠣꠁ ꠀꠁꠍꠤꠟ। ꠁꠖꠞ ꠀꠉꠦ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠉꠣꠃ ꠕꠣꠇꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN11_56","073_11_56","JHN","11","56","56","ꠢꠤꠘꠅ ꠉꠤꠀ ꠔꠣꠞꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠔꠥꠇꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠃꠛꠣꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠔꠣꠁꠘ ꠁ ꠁꠖꠅ ꠀꠁꠔꠣ ꠘꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN11_57","073_11_57","JHN","11","57","57","ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠍꠣꠞ ꠈꠥꠎ ꠙꠣꠄ, ꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠗꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN12_1","073_12_1","JHN","12","1","1","ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠍꠄꠖꠤꠘ ꠀꠉꠦ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠢꠃ ꠟꠣꠍꠣꠞꠞ ꠉꠣꠃ ꠛꠣꠄꠔ-ꠀꠘꠤꠀꠔ ꠀꠁꠟꠣ, ꠎꠦ ꠟꠣꠍꠣꠞꠞꠦ ꠔꠣꠁꠘ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_2","073_12_2","JHN","12","2","2","ꠁꠘꠅ ꠔꠣꠞꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠤꠞ ꠝꠦꠎꠛꠣꠘꠤ ꠎꠥꠁꠔ ꠇꠞꠟꠣ। ꠁꠍꠣꠞ ꠟꠉꠦ ꠈꠣꠅꠀꠔ ꠎꠦꠞꠣ ꠛꠁꠍꠤꠟ, ꠄꠞꠣꠞ ꠟꠉꠦ ꠟꠣꠍꠣꠞꠅ ꠀꠍꠟꠣ ꠀꠞ ꠛꠤꠛꠤ ꠝꠣꠞꠕꠣꠄ ꠈꠣꠖꠤꠝꠖꠣꠞꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_3","073_12_3","JHN","12","3","3","ꠅꠃ ꠡꠝꠄ ꠟꠣꠍꠣꠞꠞ ꠛꠁꠘ ꠝꠞꠤꠅꠝꠦ ꠀꠗꠣ ꠡꠦꠞ ꠈꠥꠛ ꠖꠣꠝꠤ ꠈꠣꠐꠤ ꠀꠔꠞ ꠟꠁꠀ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠅꠃ ꠀꠔꠞ ꠁꠍꠣꠞ ꠙꠣꠅ-ꠅ ꠓꠣꠟꠤꠀ ꠘꠤꠎꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟꠖꠤ ꠙꠣꠅ ꠚꠥꠍꠤꠀ ꠖꠤꠟꠣ। ꠀꠔꠞꠞ ꠈꠥꠡꠛꠄꠄ ꠀꠡ꠆ꠔꠣ ꠊꠞ ꠜꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("JN12_4","073_12_4","JHN","12","4","4","ꠁꠢꠥꠖꠣ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔ ꠘꠣꠝꠦ ꠁꠍꠣꠞ ꠄꠇ ꠍꠣꠢꠣꠛꠤ, ꠎꠦꠁꠘ ꠔꠣꠘꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠛꠣ, ꠄꠁꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("JN12_5","073_12_5","JHN","12","5","5","“ꠁꠡ, ꠁ ꠀꠔꠞ ꠚꠥꠐꠤꠘ ꠛꠦꠌꠤꠟꠦ ꠔ ꠔꠤꠘ-ꠡ ꠖꠤꠘꠣꠞ ꠙꠣꠁꠀ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀ ꠉꠦꠟ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN12_6","073_12_6","JHN","12","6","6","ꠀꠍꠟꠦ ꠁꠢꠥꠖꠣꠄ ꠉꠞꠤꠛ ꠅꠇꠟꠞ ꠇꠕꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠀ ꠁꠈꠣꠘ ꠇꠁꠍꠦ ꠘꠣ। ꠢꠦ ꠀꠍꠤꠟ ꠌꠥꠞ। ꠐꠦꠇꠣꠞ ꠕꠟꠤ ꠔꠣꠞ ꠉꠦꠍꠦ ꠕꠣꠇꠔ, ꠀꠞ ꠎꠝꠣ ꠐꠦꠇꠣ ꠕꠣꠇꠤ ꠢꠦ ꠌꠥꠞꠤ ꠇꠞꠔ, ꠄꠞꠟꠣꠉꠤ ꠅꠟꠣ ꠇꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN12_7","073_12_7","JHN","12","7","7","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁ ꠛꠦꠐꠤꠉꠥꠞ ꠝꠘꠅ ꠖꠥꠈ ꠖꠤꠅ ꠘꠣ। ꠀꠝꠣꠞ ꠖꠣꠚꠘ-ꠇꠣꠚꠘꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠁ ꠚꠥꠐꠣꠁꠘ ꠕꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_8","073_12_8","JHN","12","8","8","ꠉꠞꠤꠛ ꠅꠇꠟ ꠔ ꠢꠣꠝꠦꠡꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠂꠘ, ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN12_9","073_12_9","JHN","12","9","9","ꠢꠎꠞꠔ ꠁꠍꠣ ꠛꠣꠄꠔ-ꠀꠘꠤꠀꠔ ꠀꠁꠍꠂꠘ ꠢꠥꠘꠤꠀ, ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤꠞ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠅꠘꠅ ꠀꠁꠟꠣ। ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠁꠍꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠄ, ꠢꠃ ꠎꠦ ꠟꠣꠍꠣꠞꠞꠦ ꠁꠍꠣꠄ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠟꠣ, ꠔꠣꠞꠦꠅ ꠖꠦꠈꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_10","073_12_10","JHN","12","10","10","ꠅꠃ ꠡꠝꠄ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠘꠤꠅꠔ ꠇꠞꠟꠣ ꠟꠣꠍꠣꠞꠞꠦꠅ ꠝꠣꠞꠤꠟꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_11","073_12_11","JHN","12","11","11","ꠇꠣꠞꠘ ꠟꠣꠍꠣꠞꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠁꠢꠥꠖꠤ ꠝꠣꠘꠡꠦ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠟꠉ ꠍꠣꠠꠤꠀ, ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_12","073_12_12","JHN","12","12","12","ꠁꠖꠞ ꠘꠤꠅꠔꠦ ꠖꠟꠦ ꠖꠟꠦ ꠎꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠍꠂꠘ, ꠔꠣꠞꠣ ꠛꠣꠖꠞ ꠖꠤꠘ ꠢꠥꠘꠟꠣ, ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_13","073_12_13","JHN","12","13","13","ꠅꠃ ꠔꠣꠞꠣ ꠈꠦꠎꠥꠞꠞ ꠈꠦꠍꠝꠣ ꠒꠣꠟ ꠟꠁꠀ ꠔꠣꠘꠞꠦ ꠀꠉꠥꠀꠁꠀ ꠀꠘꠣꠔ ꠉꠦꠟꠣ ꠀꠞ ꠝꠤꠍꠤꠟ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠝꠣꠞꠢꠣꠛꠣ! ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠎꠦꠁꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ, ꠔꠣꠁꠘꠃ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠖꠡꠣ!” ");
INSERT INTO syls_vpl VALUES ("JN12_14","073_12_14","JHN","12","14","14","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠀꠄꠀꠔ ꠝꠣꠚꠤꠇ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠄꠇꠐꠣ ꠉꠣꠗꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞ ꠃꠙꠞꠦ ꠍꠅꠀꠞ ꠅꠁꠟꠣ। ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("JN12_15","073_12_15","JHN","12","15","15","“ꠅ ꠍꠤꠅꠘ-ꠇꠁꠘꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ, ꠒꠞꠣꠁꠅ ꠘꠣ। ꠌꠣꠁꠀ ꠖꠦꠈꠅ, ꠉꠣꠗꠣꠞ ꠛꠣꠁꠌ꠆ꠌꠣ ꠌꠠꠤꠀ ꠔꠥꠝꠣꠞ ꠛꠣꠖꠡꠣ ꠀꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN12_16","073_12_16","JHN","12","16","16","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠙꠄꠟꠣ ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠤ ꠛꠥꠎꠟꠣ ꠘꠣ। ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠁꠀ ꠢꠣꠞꠟꠦ, ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠇꠕꠣ ꠔꠣꠞꠣꠞ ꠝꠘꠅ ꠅꠁꠟ, ꠅꠃ ꠀꠄꠀꠔꠅ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦꠃ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, ꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠟꠣꠉꠤꠃ ꠅꠔꠔꠣ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN12_17","073_12_17","JHN","12","17","17","ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠟꠣꠍꠣꠞꠞꠦ ꠒꠣꠇꠤꠀ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠣꠞ ꠡꠝꠄ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ, ꠔꠣꠞꠣꠅ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_18","073_12_18","JHN","12","18","18","ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠅꠃ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠔꠣꠘꠞꠦ ꠀꠉꠥꠀꠁꠀ ꠀꠘꠣꠔ ꠉꠦꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_19","073_12_19","JHN","12","19","19","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟ, “ꠀꠝꠞꠣꠞ ꠔ ꠇꠥꠘꠥ ꠟꠣꠜ ꠅꠞ ꠘꠣ। ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠃ ꠔꠣꠞ ꠈꠞꠦ ꠉꠦꠍꠦꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN12_20","073_12_20","JHN","12","20","20","ꠀꠎꠣꠖꠤ ꠁꠖꠅ ꠎꠦꠞꠣ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠔ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠄꠎꠘ ꠁꠃꠘꠣꠘꠤ ꠝꠣꠘꠥꠡꠅ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_21","073_12_21","JHN","12","21","21","ꠔꠣꠞꠣ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠛꠣꠄꠔ-ꠍꠄꠖꠣ ꠉꠣꠃꠞ ꠚꠤꠟꠤꠚꠞꠦ ꠀꠁꠀ ꠝꠤꠘꠔ ꠇꠞꠟꠣ, “ꠍꠣꠛ, ꠀꠝꠞꠣ ꠢꠥꠎꠥꠞ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN12_22","073_12_22","JHN","12","22","22","ꠚꠤꠟꠤꠚꠦ ꠁꠈꠣꠘ ꠀꠘ꠆ꠖꠞꠤꠀꠍꠞꠦ ꠇꠁꠟꠣ। ꠛꠣꠖꠦ ꠀꠘ꠆ꠖꠞꠤꠀꠍ ꠀꠞ ꠚꠤꠟꠤꠚꠦ ꠉꠤꠀ ꠁꠍꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_23","073_12_23","JHN","12","23","23","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠀꠞ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN12_24","073_12_24","JHN","12","24","24","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠗꠣꠘꠞ ꠛꠤꠌ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀ ꠎꠥꠖꠤ ꠘꠣ ꠝꠞꠦ, ꠔꠦ ꠄꠇꠐꠣꠃ ꠕꠣꠇꠦ, ꠀꠞ ꠝꠣꠐꠤꠔ ꠝꠞꠟꠦ ꠛꠃꠔ ꠚꠡꠟ ꠚꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("JN12_25","073_12_25","JHN","12","25","25","ꠅꠟꠣ ꠎꠦ ꠎꠘꠦ ꠘꠤꠎꠞ ꠎꠣꠘꠞꠦ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠢꠦ ꠔꠣꠞ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠥꠀꠁꠟꠣꠄ, ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠁ ꠖꠥꠘꠤꠀꠔ ꠘꠤꠎꠞ ꠎꠣꠘꠞꠦ ꠔꠥꠌ꠆ꠍ ꠝꠘꠅ ꠇꠞꠦ, ꠢꠦ ꠔꠣꠞ ꠀꠍꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠝꠣꠘꠤ ꠀꠈꠦꠞꠣꠔꠞ ꠟꠣꠉꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN12_26","073_12_26","JHN","12","26","26","ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠔ ꠌꠣꠄ, ꠔꠦ ꠀꠝꠣꠞ ꠙꠕꠦ ꠌꠟꠃꠇ। ꠔꠦꠃ ꠀꠝꠤ ꠎꠦꠈꠣꠘꠅ ꠞꠁꠝꠥ ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔꠇꠣꠞꠤꠅ ꠅꠘꠅ ꠞꠁꠛ। ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠦ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠔꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_27","073_12_27","JHN","12","27","27","“ꠀꠝꠣꠞ ꠝꠘ ꠅꠈꠘ ꠙꠦꠞꠦꠡꠣꠘ ꠅꠁꠉꠦꠍꠦ। ꠔꠦ ꠀꠝꠤ ꠅꠈꠣꠘ ꠇꠁꠔꠣꠝ ꠘꠤ, ꠛꠣꠛꠣ, ꠎꠦ ꠡꠝꠄ ꠀꠁꠀ ꠀꠎꠤꠍꠦ, ꠅꠃ ꠡꠝꠄꠅꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠅ? ꠅꠁꠟꠦ ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠔ ꠀꠝꠤ ꠅꠃ ꠡꠝꠄ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN12_28","073_12_28","JHN","12","28","28","ꠛꠣꠛꠣ, ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠅ।” ꠅꠃ ꠡꠝꠄ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠉꠣꠁꠛꠤ ꠀꠅꠀꠎ ꠀꠁꠟ, “ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠍꠤ ꠀꠞ ꠢꠤꠞꠛꠣꠞ ꠎꠣꠁꠞ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN12_29","073_12_29","JHN","12","29","29","ꠁ ꠀꠅꠀꠎ ꠢꠥꠘꠤꠀ ꠢꠤꠘꠅ ꠎꠔ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ, ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠔ ꠝꠦꠊꠞ ꠒꠣꠇ।” ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, “ꠇꠥꠘꠥ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN12_30","073_12_30","JHN","12","30","30","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁ ꠀꠅꠀꠎ ꠔ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠀꠁꠍꠦ ꠘꠣ, ꠀꠙꠘꠣꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN12_31","073_12_31","JHN","12","31","31","ꠁ ꠎꠉꠔꠞ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞꠞ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ, ꠖꠥꠘꠤꠀꠞ ꠝꠥꠘꠤꠛ ꠁꠛꠟꠤꠍꠞ ꠀꠔ ꠕꠣꠇꠤ ꠅꠈꠘ ꠈꠦꠝꠔꠣ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN12_32","073_12_32","JHN","12","32","32","ꠀꠝꠣꠞꠦ ꠎꠦꠛꠟꠣ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠃꠙꠞꠦ ꠔꠥꠟꠣ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠢꠇꠟꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠐꠣꠘꠤꠀ ꠔꠥꠟꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN12_33","073_12_33","JHN","12","33","33","ꠔꠣꠘ ꠇꠤꠟꠣꠈꠣꠘ ꠝꠃꠔ ꠅꠁꠛ, ꠅꠈꠣꠘ ꠛꠥꠎꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠁꠔꠣ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_34","073_12_34","JHN","12","34","34","ꠅꠃ ꠡꠝꠄ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠙꠣꠇ ꠇꠤꠔꠣꠛ ꠕꠣꠇꠤ ꠢꠥꠘꠍꠤ ꠀꠟ-ꠝꠍꠤ ꠌꠤꠞꠇꠣꠟ ꠞꠁꠛꠣ। ꠔꠦ ꠀꠙꠘꠦ ꠇꠤꠟꠣ ꠇꠁꠞꠣ, ꠛꠤꠘ-ꠀꠖꠝꠞꠦ ꠃꠌꠣꠔ ꠔꠥꠟꠣ ꠅꠁꠛ? ꠔꠣꠁꠟꠦ ꠁ ꠛꠤꠘ-ꠀꠖꠝ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN12_35","073_12_35","JHN","12","35","35","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠞ ꠇꠤꠍꠥ ꠡꠝꠄ ꠘꠥꠞ ꠀꠙꠘꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠦ, ꠘꠥꠞ ꠕꠣꠇꠔꠦ ꠕꠣꠇꠔꠦꠃ ꠀꠐꠣ ꠗꠞꠃꠇ꠆ꠇꠣ, ꠎꠦꠟꠣ ꠀꠘ꠆ꠖꠣꠁꠞꠦ ꠀꠁꠀ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠘꠣ ꠛꠦꠞꠦ। ꠎꠦ ꠎꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠙꠕꠦ ꠀꠐꠦ, ꠢꠦ ꠎꠣꠘꠦ ꠘꠣ ꠢꠦ ꠇꠥꠀꠁ ꠎꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("JN12_36","073_12_36","JHN","12","36","36","ꠘꠥꠞ ꠀꠙꠘꠣꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠔꠦ ꠕꠣꠇꠔꠦꠃ ꠘꠥꠞꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠀꠙꠘꠣꠞꠣꠅ ꠅꠃ ꠘꠥꠞꠞ ꠝꠣꠘꠥꠡ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ।” ꠄꠞꠛꠣꠖꠦ ꠁꠍꠣ ꠁꠘ ꠕꠘꠦ ꠢꠞꠤꠀ ꠉꠤꠀ, ꠄꠞꠣꠞ ꠌꠃꠈ ꠕꠣꠇꠤ ꠘꠤꠎꠞꠦ ꠟꠥꠇꠣꠁꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_37","073_12_37","JHN","12","37","37","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠅꠔ ꠛꠦꠡꠤ ꠇꠦꠞꠣꠝꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣꠘꠤꠞ ꠛꠣꠖꠦꠅ ꠔꠣꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_38","073_12_38","JHN","12","38","38","ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠊꠐꠤꠍꠤꠟ ꠎꠣꠔꠦ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠘꠛꠤ ꠁꠡꠣꠄꠀꠞ ꠇꠕꠣ ꠙꠥꠞꠣ ꠅꠄ, ꠔꠣꠁꠘ ꠛꠣꠔꠣꠁꠍꠟꠣ, ꠝꠣꠛꠥꠖ ꠉ, ꠀꠝꠞꠣꠞ ꠔꠛꠟꠤꠉꠞ ꠃꠙꠞꠦ ꠇꠦ ꠄꠇꠤꠘ ꠇꠞꠍꠦ? ꠔꠥꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠔ ꠇꠣꠞ ꠉꠦꠍꠦꠃ ꠛꠣ ꠎꠣꠁꠞ ꠅꠁꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("JN12_39","073_12_39","JHN","12","39","39","ꠄꠞꠟꠣꠉꠤꠃ ꠔ ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠄꠅꠈꠣꠘ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("JN12_40","073_12_40","JHN","12","40","40","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠀꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠤꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠟꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠌꠃꠈꠖꠤ ꠘꠣ ꠖꠦꠈꠦ ꠀꠞ ꠖꠤꠟꠖꠤ ꠘꠣ ꠛꠥꠎꠦ। ꠀꠞꠘꠣꠄ ꠇꠤꠎꠣꠘꠥ ꠔꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠤꠟꠣꠁꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠎꠣꠁꠘ, ꠀꠞ ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠤꠟꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN12_41","073_12_41","JHN","12","41","41","ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠁꠍꠣꠞ ꠝꠢꠤꠝꠣ ꠖꠦꠈꠍꠟꠣ ꠉꠔꠤꠇꠦ, ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠅꠃ ꠇꠕꠣ ꠇꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_42","073_12_42","JHN","12","42","42","ꠔꠦꠛꠃ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠃꠔꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ, ꠅꠁꠟꠦ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠟꠣꠁꠛ, ꠅꠈꠣꠘ ꠒꠞꠣꠁꠀ ꠔꠣꠞꠣ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_43","073_12_43","JHN","12","43","43","ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠕꠣꠇꠤ ꠝꠣꠘꠡꠞ ꠔꠣꠞꠤꠚ ꠙꠣꠁꠔꠦ ꠛꠦꠡꠤ ꠙꠍꠘ꠆ꠖ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("JN12_44","073_12_44","JHN","12","44","44","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠢꠦ ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠘꠣꠄ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠔꠣꠘ ꠃꠙꠞꠦꠅ ꠁꠝꠣꠘ ꠀꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("JN12_45","073_12_45","JHN","12","45","45","ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠦ, ꠢꠦ ꠀꠍꠟꠦ ꠔꠣꠘꠞꠦꠃ ꠖꠦꠈꠦ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN12_46","073_12_46","JHN","12","46","46","ꠀꠝꠤ ꠁ ꠖꠥꠘꠤꠀꠔ ꠘꠥꠞ ꠢꠤꠡꠣꠛꠦ ꠀꠁꠍꠤ, ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠎꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠢꠦ ꠀꠞ ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠘꠣ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("JN12_47","073_12_47","JHN","12","47","47","ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ, ꠅꠃ ꠝꠣꠚꠤꠇ ꠀꠝꠟ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠤ ꠘꠣ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣꠔ ꠀꠁꠍꠤ ꠘꠣ, ꠛꠞꠋ ꠝꠣꠘꠡꠞꠦ ꠔꠞꠣꠘꠤꠔ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN12_48","073_12_48","JHN","12","48","48","ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠝꠣꠘꠦ ꠘꠣ ꠀꠞ ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠦ ꠘꠣ, ꠔꠣꠞ ꠛꠤꠌꠣꠞꠞ ꠟꠣꠉꠤ ꠔ ꠄꠇꠎꠘ ꠀꠍꠂꠘ। ꠀꠝꠤ ꠔꠣꠞꠦ ꠎꠦ ꠇꠕꠣ ꠇꠁꠍꠤ, ꠅꠃ ꠇꠕꠣꠄꠃ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠔꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("JN12_49","073_12_49","JHN","12","49","49","ꠀꠝꠤ ꠔ ꠘꠤꠎꠦ ꠕꠣꠇꠤ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠍꠤ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠎꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ, ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN12_50","073_12_50","JHN","12","50","50","ꠀꠝꠤ ꠎꠣꠘꠤ, ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠣꠃ ꠅꠁꠟ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠁ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠢꠥꠇꠥꠝꠦꠃ ꠇꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN13_1","073_13_1","JHN","13","1","1","ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠕꠥꠠꠣ ꠀꠉꠞ ꠊꠐꠘꠣ। ꠁꠍꠣꠄ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠔꠣꠁꠘ ꠁ ꠖꠥꠘꠤꠀ ꠍꠣꠠꠤꠀ ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠛꠣꠞ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ। ꠖꠥꠘꠤꠀꠔ ꠎꠦꠞꠣ ꠔꠣꠘ ꠀꠙꠘ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠈꠥꠛ ꠝꠣꠄꠀ ꠇꠞꠔꠣ ꠀꠞ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠟꠣ ꠝꠣꠄꠀ ꠇꠞꠤꠀꠃ ꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN13_2","073_13_2","JHN","13","2","2","ꠞꠣꠁꠔꠇꠥꠞ ꠈꠣꠘꠤꠔ ꠛꠁꠛꠣꠞ ꠀꠉꠞ ꠇꠕꠣ, ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠁꠛꠟꠤꠍꠦ ꠀꠁꠀ ꠍꠣꠁꠝꠘ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔꠞ ꠙꠥꠀ ꠁꠢꠥꠖꠣꠞ ꠝꠘꠅ ꠈꠣꠁꠡ ꠎꠣꠉꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN13_3","073_13_3","JHN","13","3","3","ꠁꠍꠣꠄ ꠎꠣꠘꠔꠣ, ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠀꠔꠅ ꠢꠇꠟꠔꠣ ꠡꠙꠤ ꠖꠤꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠂꠘ ꠀꠞ ꠔꠣꠘ ꠉꠦꠍꠦꠃ ꠚꠤꠞꠤꠀ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN13_4","073_13_4","JHN","13","4","4","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠈꠣꠅꠀ ꠕꠣꠇꠤ ꠃꠑꠟꠣ ꠀꠞ ꠚꠤꠘ꠆ꠘꠞ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ ꠈꠥꠟꠤꠀ ꠄꠇꠈꠣꠘ ꠉꠣꠝꠍꠣ ꠇꠝꠞꠅ ꠛꠣꠘ꠆ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN13_5","073_13_5","JHN","13","5","5","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠉꠣꠝꠟꠣꠞ ꠝꠣꠎꠦ ꠙꠣꠘꠤ ꠟꠁꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠙꠣꠅ ꠗꠅꠀꠁ ꠖꠤꠟꠣ, ꠀꠞ ꠇꠝꠞꠞ ꠉꠣꠝꠍꠣꠖꠤ ꠙꠣꠅ ꠚꠥꠍꠤꠀ ꠖꠦꠅꠀꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN13_6","073_13_6","JHN","13","6","6","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ, ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠂꠘ, ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠙꠣꠅ ꠗꠅꠀꠁꠀ ꠖꠤꠔꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN13_7","073_13_7","JHN","13","7","7","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠞꠤꠀꠞ, ꠅꠈꠘ ꠔꠥꠝꠤ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠔꠣꠄ ꠘꠣꠄ, ꠛꠣꠖꠦ ꠛꠥꠎꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN13_8","073_13_8","JHN","13","8","8","ꠅꠃ ꠙꠤꠔꠞꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠎꠤ ꠘꠣ, ꠀꠙꠘꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠝꠣꠞ ꠙꠣꠅ ꠗꠅꠀꠁ ꠖꠤꠛꠣ ꠘꠣ।” ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠙꠣꠅ ꠗꠁꠀ ꠘꠣ ꠖꠦꠁ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠇꠥꠘꠥ ꠈꠣꠔꠤꠞ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN13_9","073_13_9","JHN","13","9","9","ꠔꠦꠃ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠔꠦ ꠈꠣꠟꠤ ꠙꠣꠅ ꠘꠣꠄ, ꠀꠝꠣꠞ ꠝꠣꠕꠣ ꠀꠞ ꠀꠔꠅ ꠗꠅꠀꠁꠀ ꠖꠦꠃꠇ꠆ꠇꠣ”। ");
INSERT INTO syls_vpl VALUES ("JN13_10","073_13_10","JHN","13","10","10","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠎꠦ ꠝꠣꠘꠡꠦ ꠉꠥꠍꠟ ꠇꠞꠍꠦ, ꠔꠣꠞ ꠙꠣꠅ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠗꠅꠀꠞ ꠎꠞꠥꠞ ꠘꠣꠄ, ꠔꠣꠞ ꠔ ꠢꠇꠟꠔꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠀꠍꠦ। ꠔꠥꠝꠞꠣꠅ ꠘꠤꠌ꠆ꠌꠄ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠀꠍ, ꠅꠁꠟꠦ ꠢꠇꠟ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN13_11","073_13_11","JHN","13","11","11","ꠀꠍꠟꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠇꠦ ꠔꠣꠘꠞꠦ ꠗꠞꠣꠁ ꠖꠤꠛ, ꠁꠈꠣꠘ ꠔꠣꠁꠘ ꠎꠣꠘꠔꠣ। ꠄꠞꠖꠣꠄ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN13_12","073_13_12","JHN","13","12","12","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠙꠣꠅ ꠗꠅꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ ꠚꠤꠘ꠆ꠖꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠛꠁꠟꠣ ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠛꠥꠎꠍ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN13_13","073_13_13","JHN","13","13","13","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠃꠡ꠆ꠔꠣꠖ ꠀꠞ ꠝꠣꠟꠤꠇ ꠇꠁꠀ ꠒꠣꠇ, ꠁꠈꠣꠘ ꠑꠤꠇꠃ, ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞ ꠃꠡ꠆ꠔꠣꠖ ꠀꠞ ꠝꠣꠟꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("JN13_14","073_13_14","JHN","13","14","14","ꠀꠞ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠡ꠆ꠔꠣꠖ ꠀꠞ ꠝꠣꠟꠤꠇ ꠅꠁꠀꠅ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅ ꠗꠅꠀꠁꠀ ꠖꠤꠟꠣꠝ, ꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠙꠣꠅ ꠗꠅꠀꠁ ꠖꠦꠅꠀ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("JN13_15","073_13_15","JHN","13","15","15","ꠀꠝꠤ ꠁꠟꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠣꠁꠟꠣꠝ, ꠎꠣꠔꠦ ꠀꠝꠤ ꠎꠦꠟꠣ ꠇꠞꠟꠣꠝ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN13_16","073_13_16","JHN","13","16","16","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠉꠥꠟꠣꠝ ꠔꠣꠞ ꠝꠥꠘꠤꠛ ꠕꠣꠇꠤ ꠛꠠ ꠘꠣꠄ। ꠀꠞ ꠎꠣꠞꠦ ꠙꠣꠑꠣꠘꠤ ꠅꠁꠍꠦ, ꠢꠦ ꠔꠣꠞ ꠙꠣꠑꠣꠅꠞꠣ ꠕꠣꠇꠤ ꠛꠠ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN13_17","073_13_17","JHN","13","17","17","ꠁꠔꠣ ꠎꠣꠘꠤꠀ ꠎꠥꠖꠤ ꠀꠝꠟ ꠇꠞ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠗꠁꠘ꠆ꠘ। ");
INSERT INTO syls_vpl VALUES ("JN13_18","073_13_18","JHN","13","18","18","“ꠀꠝꠤ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠞꠣꠝ ꠘꠣ। ꠀꠝꠤ ꠎꠦꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ ꠔꠣꠞꠣꠞꠦ ꠔ ꠌꠤꠘꠤ। ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠀꠄꠀꠔ ꠔ ꠚꠟꠤꠔꠦ ꠅꠁꠛ, ꠟꠦꠈꠣ ꠀꠍꠦ, ‘ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠁꠀ ꠎꠦꠉꠥꠄ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠦ, ꠢꠉꠥꠄ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠙꠣꠅ ꠔꠥꠟꠍꠦ।’ ");
INSERT INTO syls_vpl VALUES ("JN13_19","073_13_19","JHN","13","19","19","ꠁꠔꠣ ꠊꠐꠣꠞ ꠀꠉꠦꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣꠝ, ꠔꠦꠃ ꠊꠐꠣꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠤꠃ ꠢꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("JN13_20","073_13_20","JHN","13","20","20","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠀꠝꠤ ꠎꠣꠞꠦ ꠙꠣꠑꠣꠁ, ꠔꠣꠞꠦ ꠎꠦ ꠎꠘꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠀꠍꠟꠦ ꠀꠝꠣꠞꠦꠃ ꠇꠛꠥꠟ ꠇꠞꠦ। ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠢꠦ ꠔꠣꠘꠞꠦꠃ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN13_21","073_13_21","JHN","13","21","21","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠖꠤꠟ ꠙꠦꠞꠦꠡꠣꠘ ꠅꠁꠉꠦꠟ। ꠔꠣꠁꠘ ꠈꠥꠟꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠦꠃ ꠀꠝꠣꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN13_22","073_13_22","JHN","13","22","22","ꠔꠣꠁꠘ ꠇꠣꠞ ꠇꠕꠣ ꠇꠁꠞꠣ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠁꠈꠣꠘ ꠘꠣ ꠛꠥꠎꠣꠄ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠛꠣꠄ ꠌꠣꠁ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN13_23","073_13_23","JHN","13","23","23","ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠎꠦ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠁꠍꠣꠄ ꠝꠣꠄꠀ ꠇꠞꠔꠣ, ꠄꠁꠘ ꠁꠍꠣꠞ ꠇꠥꠟꠅ ꠄꠟꠣꠁꠘ ꠖꠤꠀ ꠛꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN13_24","073_13_24","JHN","13","24","24","ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠄꠘꠞꠦ ꠁꠡꠣꠞꠣ ꠖꠤꠀ ꠇꠁꠟꠣ, ꠔꠥꠝꠤ ꠎꠤꠇꠣꠅ, ꠔꠣꠁꠘ ꠇꠣꠞ ꠇꠕꠣ ꠇꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN13_25","073_13_25","JHN","13","25","25","ꠔꠦꠃ ꠅꠃ ꠍꠣꠢꠣꠛꠤꠄ ꠁꠍꠣꠞ ꠛꠣꠄ ꠎꠥꠇꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠇꠦ ꠅꠃ ꠎꠘ?” ");
INSERT INTO syls_vpl VALUES ("JN13_26","073_13_26","JHN","13","26","26","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅꠃ ꠞꠥꠐꠤꠞ ꠐꠥꠇꠞꠣ ꠛꠃꠟꠅ ꠜꠤꠎꠣꠁꠀ ꠎꠣꠞꠦ ꠖꠤꠝꠥ, ꠢꠦ-ꠃ ꠅꠃ ꠎꠘ।” ꠀꠞ ꠅꠃ ꠞꠥꠐꠤ ꠔꠣꠁꠘ ꠍꠣꠁꠝꠘ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔꠞ ꠙꠥꠀ ꠁꠢꠥꠖꠣꠞꠦ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN13_27","073_13_27","JHN","13","27","27","ꠞꠥꠐꠤꠞ ꠐꠥꠇꠞꠣ ꠟꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠁꠛꠟꠤꠍ ꠁꠢꠥꠖꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟ। ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠎꠦꠔꠣ ꠇꠞꠔꠣꠄ ꠌꠣꠅ, ꠎꠟꠖꠤ ꠇꠞꠤꠟꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN13_28","073_13_28","JHN","13","28","28","ꠁꠍꠣꠞ ꠟꠉꠦ ꠎꠣꠞꠣ ꠈꠣꠅꠀꠔ ꠛꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠇꠦꠃ ꠛꠥꠎꠟꠣ ꠘꠣ, ꠔꠣꠁꠘ ꠁꠢꠥꠖꠣꠞꠦ ꠇꠦꠘꠦ ꠁꠈꠣꠘ ꠇꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN13_29","073_13_29","JHN","13","29","29","ꠇꠦꠃ ꠇꠦꠃ ꠝꠘꠅ ꠇꠞꠟ, ꠁꠖꠞ ꠛꠣꠎꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠍꠣꠄ ꠁꠢꠥꠖꠣꠞꠦ ꠅꠈꠣꠘ ꠇꠁꠍꠂꠘ ꠛꠣ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠖꠦꠅꠀꠞ ꠇꠕꠣ ꠇꠁꠍꠂꠘ, ꠇꠣꠞꠘ ꠐꠦꠇꠣꠞ ꠕꠟꠤ ꠔ ꠁꠢꠥꠖꠣꠞ ꠉꠦꠍꠦꠃ ꠕꠣꠇꠔ। ");
INSERT INTO syls_vpl VALUES ("JN13_30","073_13_30","JHN","13","30","30","ꠞꠥꠐꠤꠞ ꠐꠥꠇꠞꠣ ꠟꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦ ꠁꠢꠥꠖꠣ ꠛꠣꠞ ꠅꠁꠀ ꠉꠦꠟꠉꠤ। ꠁ ꠡꠝꠄ ꠞꠣꠁꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN13_31","073_13_31","JHN","13","31","31","ꠁꠢꠥꠖꠣ ꠛꠣꠞꠦ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠛꠤꠘ-ꠀꠖꠝꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠣꠞ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ, ꠔꠣꠘ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN13_32","073_13_32","JHN","13","32","32","ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠝꠣꠎꠖꠤ ꠎꠣꠁꠞ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠄꠅ ꠘꠤꠎꠞ ꠝꠣꠎꠦ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠛꠣ, ꠁꠔꠣ ꠔꠣꠁꠘ ꠈꠥꠛ ꠎꠟꠖꠤꠃ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN13_33","073_13_33","JHN","13","33","33","ꠅ ꠀꠅꠟꠣꠖ ꠅꠇꠟ, ꠀꠝꠤ ꠀꠞ ꠛꠦꠡꠤ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠁꠔꠣꠝ ꠘꠣꠄ। ꠔꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠀꠉꠦ ꠎꠦꠟꠣ ꠇꠁꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠦꠈꠣꠘꠅ ꠎꠣꠁꠝꠥ ꠔꠥꠝꠞꠣ ꠢꠤꠘꠅ ꠎꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ, ꠅꠈꠘ ꠅꠃ ꠇꠕꠣ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN13_34","073_13_34","JHN","13","34","34","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠄꠇꠈꠣꠘ ꠘꠄꠀ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠤꠅ। ꠀꠝꠤ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠍꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("JN13_35","073_13_35","JHN","13","35","35","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞ, ꠔꠦ ꠢꠇꠟꠦ ꠛꠥꠎꠛ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ।” ");
INSERT INTO syls_vpl VALUES ("JN13_36","073_13_36","JHN","13","36","36","ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠇꠥꠀꠁ ꠎꠣꠁꠞꠣ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦꠘꠅ ꠎꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠀꠝꠣꠞ ꠟꠉꠦ ꠢꠤꠘꠅ ꠀꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠛꠣꠖꠦ ꠀꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN13_37","073_13_37","JHN","13","37","37","ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠇꠦꠘꠦ ꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ? ꠀꠙꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠝꠣꠞ ꠎꠣꠘꠅ ꠛꠤꠟꠣꠁ ꠖꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN13_38","073_13_38","JHN","13","38","38","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠍꠣꠃ ꠔꠥꠝꠣꠞ ꠎꠣꠘ ꠖꠤꠛꠣꠄ ꠘꠤ? ꠔꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠛꠣꠞ ꠀꠉꠦꠃ, ꠔꠥꠝꠤ ꠔꠤꠘꠛꠣꠞ ꠇꠁꠛꠣꠄ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN14_1","073_14_1","JHN","14","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠀꠞ ꠙꠦꠞꠦꠡꠣꠘ ꠅꠁꠅ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠔ ꠔꠥꠝꠞꠣꠞ ꠄꠇꠤꠘ ꠀꠍꠦ, ꠔꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦꠅ ꠄꠇꠤꠘ ꠞꠣꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("JN14_2","073_14_2","JHN","14","2","2","ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠞꠅꠀꠞ ꠛꠃꠔ ꠎꠣꠉꠣ ꠀꠍꠦ, ꠘꠣ ꠕꠣꠇꠟꠦ ꠀꠝꠤ ꠇꠁꠟꠣꠝ ꠅꠘꠦ। ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠉꠣ ꠑꠤꠇ ꠇꠞꠣꠔ ꠎꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN14_3","073_14_3","JHN","14","3","3","ꠎꠣꠉꠣ ꠑꠤꠇ ꠇꠞꠤꠀ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠝꠥ, ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠘꠤꠝꠥ। ꠔꠦꠃ ꠀꠝꠤ ꠎꠦꠘꠅ ꠞꠁꠝꠥ, ꠔꠥꠝꠞꠣꠅ ꠢꠘꠅ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN14_4","073_14_4","JHN","14","4","4","ꠀꠞ ꠀꠝꠤ ꠇꠥꠀꠁ ꠎꠣꠁꠞꠣꠝ, ꠁ ꠙꠕ ꠔ ꠔꠥꠝꠞꠣꠞ ꠌꠤꠘꠣ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN14_5","073_14_5","JHN","14","5","5","ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠕꠥꠝꠣꠍꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠇꠥꠀꠁ ꠎꠣꠁꠞꠣ, ꠅꠈꠣꠘꠃ ꠀꠝꠞꠣ ꠎꠣꠘꠤ ꠘꠣ, ꠔꠦ ꠙꠕ ꠇꠤꠟꠣ ꠌꠤꠘꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("JN14_6","073_14_6","JHN","14","6","6","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠙꠕ, ꠀꠝꠤꠃ ꠢꠇ ꠀꠞ ꠀꠝꠤꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ꠀꠝꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡꠃ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN14_7","073_14_7","JHN","14","7","7","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠟꠦ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞꠦꠅ ꠌꠤꠘꠟꠣꠄ ꠅꠘꠦ। ꠔꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠔꠣꠘꠦ ꠌꠤꠘꠍ ꠀꠞ ꠖꠦꠈꠍ-ꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN14_8","073_14_8","JHN","14","8","8","ꠚꠤꠟꠤꠚꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠅꠃ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠝꠞꠣꠞꠦ ꠖꠦꠈꠣꠃꠇ꠆ꠇꠣ, ꠔꠦꠃ ꠀꠝꠞꠣ ꠡꠣꠘ꠆ꠔꠤ ꠅꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN14_9","073_14_9","JHN","14","9","9","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠚꠤꠟꠤꠚ, ꠅꠔ ꠖꠤꠘ ꠕꠣꠇꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠤ, ꠄꠞꠛꠣꠖꠦꠅ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠟꠣꠄ ꠘꠣ ꠘꠤ? ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠍꠦ, ꠢꠦ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞꠦꠅ ꠖꠦꠈꠍꠦ। ꠔꠦ ꠔꠥꠝꠤ ꠇꠤꠟꠣꠘ ꠇꠁꠟꠣꠄ, ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞꠦ ꠖꠦꠈꠣꠃꠇ꠆ꠇꠣ? ");
INSERT INTO syls_vpl VALUES ("JN14_10","073_14_10","JHN","14","10","10","ꠔꠥꠝꠤ ꠄꠇꠤꠘ ꠇꠞ ꠘꠣ ꠘꠤ, ꠀꠝꠤ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠝꠣꠎꠦ ꠀꠍꠤ, ꠀꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠅ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠂꠘ? ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠇꠁ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠝꠥꠈꠞ ꠛꠥꠟꠤ ꠘꠣꠄ, ꠎꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠔꠣꠘ ꠘꠤꠎꠞ ꠇꠣꠝ ꠌꠣꠟꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JN14_11","073_14_11","JHN","14","11","11","ꠀꠝꠣꠞ ꠇꠕꠣ ꠄꠇꠤꠘ ꠇꠞꠅ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠝꠣꠎꠦ ꠀꠍꠤ, ꠀꠞ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠂꠘ। ꠀꠞꠘꠣꠄ ꠅꠘ꠆ꠔꠔ ꠀꠝꠣꠞ ꠅꠔꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠤꠀ ꠀꠝꠣꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN14_12","073_14_12","JHN","14","12","12","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠔꠦ ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠤ, ꠢꠦ-ꠅ ꠅꠔꠣ ꠇꠞꠛ। ꠀꠞ ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠀꠞꠉꠤ ꠇꠞꠤ ꠢꠦ ꠀꠞꠅ ꠛꠠ ꠛꠠ ꠇꠣꠝ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("JN14_13","073_14_13","JHN","14","13","13","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠎꠦꠔꠣ ꠌꠣꠁꠛꠣꠄ, ꠀꠝꠤ ꠁꠔꠣ ꠙꠥꠞꠣ ꠇꠞꠝꠥ ꠎꠣꠔꠦ ꠛꠣꠚꠞ ꠝꠢꠤꠝꠣ ꠙꠥꠔꠞ ꠝꠣꠎꠖꠤ ꠎꠣꠁꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JN14_14","073_14_14","JHN","14","14","14","ꠀꠝꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘ꠆ꠔꠣ ꠌꠣꠁꠟꠦ, ꠀꠝꠤ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JN14_15","073_14_15","JHN","14","15","15","“ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞ, ꠔꠦ ꠀꠝꠣꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("JN14_16","073_14_16","JHN","14","16","16","ꠀꠝꠤ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠌꠣꠁꠝꠥ, ꠀꠞ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠇ ꠡꠣꠁꠎ꠆ꠎꠉꠤꠞ ꠙꠣꠑꠣꠁꠛꠣ, ꠄꠁꠘ ꠌꠤꠞꠇꠣꠟ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN14_17","073_14_17","JHN","14","17","17","ꠅꠃ ꠡꠣꠁꠎ꠆ꠎꠉꠤꠞ ꠅꠁꠟꠣ ꠢꠇ ꠞꠥꠢꠥ। ꠁ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠅꠃ ꠢꠇ ꠞꠥꠢꠥꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠄꠞꠦ ꠖꠦꠈꠦꠅ ꠘꠣ, ꠌꠤꠘꠦꠅ ꠘꠣ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠄꠘꠦ ꠌꠤꠘ, ꠄꠁꠘ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠂꠘ ꠀꠞ ꠍꠣꠝꠘꠦꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN14_18","073_14_18","JHN","14","18","18","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠄꠔꠤꠝ ꠢꠣꠟꠔꠦ ꠚꠣꠟꠣꠁꠀ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ, ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JN14_19","073_14_19","JHN","14","19","19","ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞꠦ ꠀꠞ ꠖꠦꠈꠔ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠖꠦꠈꠛꠣꠄ। ꠀꠝꠤ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠤ ꠉꠔꠤꠇꠦ ꠔꠥꠝꠞꠣꠅ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN14_20","073_14_20","JHN","14","20","20","ꠀꠝꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠝꠣꠎꠦ ꠀꠍꠤ ꠀꠞ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠀꠍ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN14_21","073_14_21","JHN","14","21","21","ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠌꠤꠘꠦ ꠀꠞ ꠀꠝꠟ ꠇꠞꠦ, ꠢꠦ-ꠃ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠦ। ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠛꠣ। ꠀꠝꠤꠅ ꠔꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠝꠥ, ꠀꠞ ꠀꠝꠣꠞ ꠘꠤꠎꠞꠦ ꠔꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN14_22","073_14_22","JHN","14","22","22","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠁꠢꠥꠖꠣ ꠁꠡ꠆ꠇꠣꠞꠤꠀꠔ ꠍꠣꠠꠣ ꠀꠞꠇ ꠍꠣꠢꠣꠛꠤꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠁꠢꠥꠖꠣ, ꠄꠁꠘ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠘꠣ ꠇꠞꠤꠀ, ꠈꠣꠟꠤ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦꠃ ꠀꠙꠘꠣꠞꠦ ꠇꠦꠘꠦ ꠎꠣꠁꠞ ꠇꠞꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN14_23","073_14_23","JHN","14","23","23","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠀꠝꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠛ। ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠔꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠛꠣ, ꠀꠝꠞꠣ ꠔꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ, ꠀꠁꠀ ꠔꠣꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JN14_24","073_14_24","JHN","14","24","24","ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠦ ꠘꠣ, ꠢꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠝꠣꠞ ꠇꠕꠣꠄ ꠌꠟꠦ ꠘꠣ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠇꠁꠟꠣꠝ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠇꠕꠣ ꠘꠣꠄ, ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ ꠢꠃ ꠛꠣꠚꠞ ꠇꠕꠣ। ");
INSERT INTO syls_vpl VALUES ("JN14_25","073_14_25","JHN","14","25","25","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠔꠦ ꠕꠣꠇꠔꠦꠃ ꠁꠔꠣ ꠇꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN14_26","073_14_26","JHN","14","26","26","ꠅꠃ ꠡꠣꠁꠎ꠆ꠎꠉꠤꠞ ꠙꠣꠇ ꠞꠥꠢꠥ, ꠎꠣꠘꠞꠦ ꠀꠝꠣꠞ ꠛꠣꠚꠦ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠙꠣꠑꠣꠁꠛꠣ, ꠔꠣꠁꠘꠃ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣ, ꠀꠞ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠤ ꠅꠔꠣ ꠁꠀꠖ ꠇꠞꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN14_27","073_14_27","JHN","14","27","27","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠣꠘ꠆ꠔꠤ ꠞꠣꠈꠤꠀ ꠎꠣꠁꠀꠞ, ꠀꠝꠣꠞ ꠡꠣꠘ꠆ꠔꠤꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠀ ꠎꠣꠁꠀꠞꠉꠤ। ꠁ ꠖꠥꠘꠤꠀꠄ ꠎꠦꠝꠘꠦ ꠡꠣꠘ꠆ꠔꠤ ꠖꠦꠄ, ꠀꠝꠤ ꠁꠟꠣ ꠖꠦꠁ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠣꠘꠥ ꠇꠥꠘꠥ ꠙꠦꠞꠦꠡꠣꠘꠤ ꠛꠣ ꠒꠞ-ꠈꠚ ꠘꠣ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("JN14_28","073_14_28","JHN","14","28","28","ꠀꠝꠤ ꠔ ꠀꠉꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠤ, ꠀꠝꠤ ꠎꠣꠁꠀꠞꠉꠤ, ꠀꠞ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ। ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠔꠣꠄ, ꠔꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠀꠞ ꠇꠞꠤ ꠈꠥꠡꠤ ꠅꠁꠟꠣꠄ ꠅꠘꠦ, ꠇꠣꠞꠘ ꠁ ꠛꠣꠚ ꠔ ꠀꠝꠣꠞ ꠕꠣꠇꠤꠅ ꠝꠢꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("JN14_29","073_14_29","JHN","14","29","29","ꠁꠔꠣ ꠊꠐꠣꠞ ꠀꠉꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣꠝ, ꠎꠣꠔꠦ ꠊꠐꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("JN14_30","073_14_30","JHN","14","30","30","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠞ ꠛꠦꠡꠤ ꠡꠝꠄ ꠝꠣꠔꠔꠣꠝ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠖꠥꠘꠤꠀꠞ ꠝꠥꠘꠤꠛ ꠁꠛꠟꠤꠍ ꠀꠁꠅꠞ। ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠝꠔꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN14_31","073_14_31","JHN","14","31","31","ꠅꠁꠟꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠞꠤ, ꠎꠣꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠂꠘ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠚꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠤ। ꠔꠦ ꠀꠅ, ꠀꠝꠞꠣ ꠅꠈꠘ ꠁ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠎꠣꠁꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN15_1","073_15_1","JHN","15","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠀꠍꠟ ꠀꠋꠉꠥꠞ ꠉꠣꠍ ꠀꠞ ꠀꠝꠣꠞ ꠛꠣꠛꠣ ꠉꠤꠞꠡ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("JN15_2","073_15_2","JHN","15","2","2","ꠀꠝꠣꠞ ꠎꠦꠔꠣ ꠒꠣꠟꠣꠁꠘ꠆ꠔꠅ ꠚꠟ ꠗꠞꠦ ꠘꠣ, ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠁꠘ। ꠀꠞ ꠎꠦꠔꠣ ꠒꠣꠟꠣꠁꠘ꠆ꠔꠅ ꠚꠟ ꠗꠞꠦ, ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠍꠣꠐꠤꠀ ꠍꠣꠚ-ꠍꠥꠔꠞꠣ ꠇꠞꠤ ꠞꠣꠈꠂꠘ, ꠎꠣꠔꠦ ꠀꠞꠅ ꠛꠦꠡꠤ ꠚꠟ ꠗꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("JN15_3","073_15_3","JHN","15","3","3","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠇꠣꠟꠣꠝ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠤ, ꠄꠞꠟꠣꠉꠤ ꠔ ꠔꠥꠝꠞꠣ ꠀꠉ ꠕꠣꠇꠤꠃ ꠍꠣꠐꠣ ꠅꠁꠀ ꠍꠣꠚ-ꠍꠥꠔꠞꠣ ꠅꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("JN15_4","073_15_4","JHN","15","4","4","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠞꠅ, ꠀꠝꠤꠅ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠞꠁꠝꠥ। ꠀꠋꠉꠥꠞ ꠉꠣꠍꠞ ꠟꠉꠦ ꠒꠣꠟ ꠎꠥꠖꠤ ꠟꠣꠉꠣꠁꠟ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠒꠣꠟꠦ ꠎꠦꠟꠣ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠚꠟ ꠗꠞꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣꠅ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠘꠣ ꠞꠁꠟꠦ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠚꠟꠀꠟꠣ ꠅꠁꠔꠣꠄ ꠙꠣꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN15_5","073_15_5","JHN","15","5","5","ꠀꠝꠤꠃ ꠀꠋꠉꠥꠞ ꠉꠣꠍ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠒꠣꠟ-ꠙꠣꠟꠣ। ꠎꠦ ꠎꠘ ꠀꠝꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠟ ꠕꠣꠇꠦ, ꠀꠝꠤꠅ ꠔꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠟ ꠞꠁ, ꠔꠦꠃ ꠔꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠛꠃꠔ ꠚꠟ ꠗꠞꠦ। ꠀꠞ, ꠀꠝꠣꠞꠦ ꠍꠣꠠꠣ ꠔ ꠔꠥꠝꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠔꠣꠄ ꠙꠣꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN15_6","073_15_6","JHN","15","6","6","“ꠀꠝꠣꠞ ꠟꠉꠦ ꠇꠦꠃ ꠟꠣꠉꠣꠁꠟ ꠘꠣ ꠞꠁꠟꠦ, ꠔꠣꠞꠦ ꠇꠣꠐꠣ ꠒꠣꠟꠞ ꠟꠣꠈꠣꠘ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠄ ꠀꠞ ꠞꠂꠖꠦ ꠢꠥꠇꠣꠁ ꠎꠣꠄ। ꠛꠣꠖꠦ ꠢꠥꠇꠘꠣ ꠒꠣꠟꠣꠁꠘ ꠔꠥꠛꠣꠁꠀ ꠀꠉꠥꠁꠘꠅ ꠖꠦꠁꠘ, ꠔꠦꠃ ꠁꠔꠣ ꠎꠟꠤ-ꠙꠥꠠꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN15_7","073_15_7","JHN","15","7","7","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠁꠟ ꠕꠣꠇ ꠀꠞ ꠀꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠈꠣꠘꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠁꠌ꠆ꠍꠣ ꠅꠔꠣꠃ ꠌꠣꠁꠅ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN15_8","073_15_8","JHN","15","8","8","ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠎꠥꠖꠤ ꠛꠃꠔ ꠚꠟ ꠗꠞꠦ, ꠀꠞ ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞꠦ ꠀꠝꠣꠞ ꠃꠝ꠆ꠝꠔ ꠢꠤꠡꠣꠛꠦ ꠙꠞꠝꠣꠘ ꠇꠞꠤꠟꠣꠅ, ꠔꠦ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠔꠣꠞꠤꠚ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JN15_9","073_15_9","JHN","15","9","9","ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠝꠣꠄꠀ ꠇꠞꠍꠂꠘ, ꠀꠝꠤꠅ ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠍꠤ। ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠣꠎꠦ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN15_10","073_15_10","JHN","15","10","10","ꠀꠝꠤ ꠀꠝꠣꠞ ꠛꠣꠚꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠎꠦꠟꠣ ꠔꠣꠘ ꠝꠣꠄꠀꠞ ꠝꠣꠎꠦ ꠞꠁꠍꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠟꠦ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠣꠎꠦ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN15_11","073_15_11","JHN","15","11","11","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠇꠁꠟꠣꠝ, ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠈꠥꠡꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠕꠣꠇꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠈꠥꠡꠤ ꠙꠥꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JN15_12","073_15_12","JHN","15","12","12","ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠅꠁꠟ, ꠀꠝꠤ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠍꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN15_13","073_15_13","JHN","15","13","13","ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠖꠥꠡ꠆ꠔꠞ ꠟꠣꠉꠤ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠦꠄ, ꠔꠦ ꠔꠣꠞ ꠕꠣꠇꠤ ꠀꠞ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠣꠞ ꠀꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("JN15_14","073_15_14","JHN","15","14","14","ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠢꠥꠇꠥꠝ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠀꠝꠟ ꠇꠞ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠖꠥꠡ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("JN15_15","073_15_15","JHN","15","15","15","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞ ꠉꠥꠟꠣꠝ ꠇꠁꠞꠣꠝ ꠘꠣ, ꠇꠣꠞꠘ ꠝꠥꠘꠤꠛꠦ ꠇꠤꠔꠣ ꠇꠞꠂꠘ ꠉꠥꠟꠣꠝꠦ ꠔ ꠁꠔꠣ ꠎꠣꠘꠦ ꠘꠣ, ꠛꠞꠋ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠡ꠆ꠔ ꠇꠁꠍꠤ, ꠇꠣꠞꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠝꠤ ꠎꠔꠔꠣ ꠢꠥꠘꠍꠤ, ꠢꠇꠟꠔꠣꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN15_16","073_15_16","JHN","15","16","16","“ꠀꠝꠣꠞꠦ ꠔ ꠔꠥꠝꠞꠣ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍ ꠘꠣ, ꠛꠞꠋ ꠀꠝꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ ꠀꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠍꠤ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠚꠟꠀꠟꠣ ꠅꠄ ꠀꠞ ꠅꠃ ꠚꠟ ꠐꠤꠇꠤꠀ ꠞꠄ। ꠔꠦꠃ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠌꠣꠁꠛꠣꠄ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN15_17","073_15_17","JHN","15","17","17","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN15_18","073_15_18","JHN","15","18","18","“ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠘ, ꠅꠁꠟꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠄꠞ ꠀꠉꠦ ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦꠃ ꠊꠤꠘ꠆ꠘꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN15_19","073_15_19","JHN","15","19","19","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠅꠃ ꠖꠥꠘꠤꠀꠞ ꠅꠁꠔꠣꠄ, ꠔꠦ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠎꠞ ꠢꠤꠡꠣꠛꠦ ꠜꠣꠟꠣ ꠙꠣꠁꠟ ꠅꠘꠦ। ꠔꠥꠝꠞꠣ ꠔ ꠁ ꠖꠥꠘꠤꠀꠞ ꠘꠣꠄ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ ꠉꠔꠤꠇꠦ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN15_20","073_15_20","JHN","15","20","20","ꠀꠝꠣꠞ ꠇꠕꠣꠈꠣꠘ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠉꠥꠟꠣꠝ ꠔꠣꠞ ꠝꠥꠘꠤꠛ ꠕꠣꠇꠤ ꠛꠠ ꠘꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠦ, ꠔꠦ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠅꠟꠣ ꠇꠞꠛ। ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠝꠣꠘꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣꠅ ꠝꠣꠘꠟ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("JN15_21","073_15_21","JHN","15","21","21","ꠀꠝꠣꠞ ꠇꠣꠞꠘꠦꠃ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠟꠣ ꠇꠞꠛ, ꠇꠣꠞꠘ ꠀꠝꠣꠞꠦ ꠎꠦꠁꠘ ꠛꠦꠎꠤꠍꠂꠘ, ꠄꠘꠞꠦ ꠔꠣꠞꠣ ꠌꠤꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN15_22","073_15_22","JHN","15","22","22","“ꠀꠝꠤ ꠎꠥꠖꠤ ꠘꠣ ꠀꠁꠔꠣꠝ ꠀꠞ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠘꠍꠤꠅꠔ ꠘꠣ ꠇꠞꠔꠣꠝ, ꠔꠦ ꠔꠣꠞꠣ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠁꠟ ꠘꠣ ꠅꠘꠦ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠅꠎꠥꠀꠔ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JN15_23","073_15_23","JHN","15","23","23","ꠎꠦ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠢꠦ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞꠦꠅ ꠊꠤꠘ꠆ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN15_24","073_15_24","JHN","15","24","24","ꠢꠥꠘꠅ, ꠎꠦꠔꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠦꠃ ꠇꠥꠘꠥꠖꠤꠘ ꠖꠦꠈꠣꠁꠍꠦ ꠘꠣ, ꠅꠔꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠎꠥꠖꠤ ꠀꠝꠤ ꠘꠣ ꠖꠦꠈꠣꠁꠔꠣꠝ, ꠔꠦ ꠔꠣꠞꠣ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠁꠟ ꠘꠣ ꠅꠘꠦ। ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠔ ꠀꠝꠣꠞꠦ ꠀꠞ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞꠦ ꠖꠦꠈꠍꠦ, ꠖꠦꠈꠤꠀꠅ ꠊꠤꠘ꠆ꠘꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN15_25","073_15_25","JHN","15","25","25","ꠁꠔꠣ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠇꠤꠔꠣꠛꠞ ꠅꠃ ꠇꠕꠣ ꠚꠟꠦ, ꠇꠤꠔꠣꠛꠅ ꠀꠍꠦ, ꠔꠣꠞꠣ ꠛꠤꠘꠣ ꠇꠣꠞꠘꠦ ꠀꠝꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN15_26","073_15_26","JHN","15","26","26","“ꠀꠝꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦ ꠡꠣꠁꠎ꠆ꠎꠉꠤꠞ ꠞꠥꠢꠥꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠝꠥ, ꠔꠣꠁꠘ ꠀꠁꠀ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛꠣ। ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠢꠇ ꠞꠥꠢꠥ, ꠔꠣꠁꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN15_27","073_15_27","JHN","15","27","27","ꠀꠞ ꠔꠥꠝꠞꠣꠅ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛꠣꠄ, ꠔꠥꠝꠞꠣ ꠔ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠀꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍ।” ");
INSERT INTO syls_vpl VALUES ("JN16_1","073_16_1","JHN","16","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠁꠔꠣ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣꠝ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠈꠞꠟꠣꠝꠤ ꠘꠣ ꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("JN16_2","073_16_2","JHN","16","2","2","ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠛꠣ। ꠅꠟꠣ ꠡꠝꠄ ꠀꠁꠛ, ꠎꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠛ, ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠛ ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("JN16_3","073_16_3","JHN","16","3","3","ꠔꠣꠞꠣ ꠁꠔꠣ ꠇꠞꠛ, ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞꠦꠅ ꠌꠤꠘꠍꠦ ꠘꠣ, ꠀꠝꠣꠞꠦꠅ ꠌꠤꠘꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN16_4","073_16_4","JHN","16","4","4","ꠀꠝꠤ ꠁꠔꠣ ꠀꠉꠦꠃ ꠇꠁꠀ ꠞꠣꠈꠟꠣꠝ, ꠎꠣꠔꠦ ꠡꠝꠄ ꠀꠁꠟꠦ ꠝꠘꠅ ꠅꠄ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠔꠣ ꠇꠁꠍꠟꠣꠝ। ꠀꠝꠤ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠁꠔꠣ ꠇꠁꠍꠤ ꠘꠣ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN16_5","073_16_5","JHN","16","5","5","“ꠢꠥꠘꠅ, ꠀꠝꠣꠞꠦ ꠎꠦꠁꠘ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠀꠝꠤ ꠅꠈꠘ ꠔꠣꠘ ꠉꠦꠍꠦ ꠎꠣꠁꠀꠞꠉꠤ, ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠎꠤꠇꠣꠁꠞꠣꠄ ꠘꠣ, ꠀꠝꠤ ꠇꠁ ꠎꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JN16_6","073_16_6","JHN","16","6","6","ꠛꠞꠋ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠇꠁꠍꠤ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠈꠥꠛ ꠖꠥꠈ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN16_7","073_16_7","JHN","16","7","7","ꠔꠦꠛꠃ ꠀꠝꠤ ꠢꠇ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠀꠝꠣꠞ ꠎꠣꠅꠀꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ, ꠀꠝꠤ ꠘꠣ ꠉꠦꠟꠦ ꠔ ꠢꠃ ꠡꠣꠁꠎ꠆ꠎꠉꠤꠞ ꠞꠥꠢꠥ ꠀꠁꠔꠣ ꠘꠣꠄ। ꠀꠝꠤ ꠉꠦꠟꠦꠉꠤ ꠔꠣꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JN16_8","073_16_8","JHN","16","8","8","ꠔꠣꠁꠘ ꠀꠁꠀ ꠉꠥꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠌꠣꠞꠞ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠘꠡꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN16_9","073_16_9","JHN","16","9","9","ꠔꠣꠁꠘ ꠉꠥꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠛꠣ, ꠇꠣꠞꠘ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN16_10","073_16_10","JHN","16","10","10","ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠛꠣ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠀꠞꠉꠤ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠀꠞ ꠖꠦꠈꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN16_11","073_16_11","JHN","16","11","11","ꠛꠤꠌꠣꠞꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠛꠣ, ꠇꠣꠞꠘ ꠖꠥꠘꠤꠀꠞ ꠝꠥꠘꠤꠛ ꠁꠛꠟꠤꠍꠞ ꠛꠤꠌꠣꠞ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN16_12","073_16_12","JHN","16","12","12","“ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞꠅ ꠛꠃꠔꠔꠣ ꠇꠅꠀꠞ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠁꠔꠣ ꠇꠁꠟꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN16_13","073_16_13","JHN","16","13","13","ꠢꠃ ꠢꠇ ꠞꠥꠢꠥ ꠀꠁꠀ ꠢꠣꠞꠤ ꠙꠕ ꠖꠦꠈꠣꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠢꠇꠈꠣꠘ ꠎꠣꠘꠣꠁꠛꠣ। ꠔꠣꠁꠘ ꠔ ꠘꠤꠎ ꠕꠣꠇꠤ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠔꠣ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠎꠦꠔꠣ ꠢꠥꠘꠂꠘ, ꠅꠔꠣꠃ ꠇꠁꠛꠣ। ꠀꠞ ꠎꠦꠔꠣ ꠊꠐꠛ, ꠅꠔꠣꠃ ꠎꠣꠘꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN16_14","073_16_14","JHN","16","14","14","ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠁ, ꠔꠣꠁꠘ ꠀꠁꠀ ꠅꠔꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠛꠣ। ꠅꠟꠣꠈꠣꠘ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN16_15","073_16_15","JHN","16","15","15","ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠎꠦꠔꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠣꠞ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠁ, ꠔꠣꠁꠘ ꠅꠔꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN16_16","073_16_16","JHN","16","16","16","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠔꠣꠄ ꠘꠣꠄ, ꠢꠤꠞꠛꠣꠞ ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠖꠦꠈꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN16_17","073_16_17","JHN","16","17","17","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠇꠄꠎꠘ ꠍꠣꠢꠣꠛꠤꠄ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠟꠣ, “ꠔꠣꠁꠘ ꠁꠔꠣ ꠇꠤꠔꠣ ꠝꠣꠔꠂꠘ, ‘ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠔꠣꠄ ꠘꠣꠄ, ꠢꠤꠞꠛꠣꠞ ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠖꠦꠈꠛꠣꠄ’, ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠞꠣ, ‘ꠀꠝꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞꠣꠝꠉꠤ।’ ");
INSERT INTO syls_vpl VALUES ("JN16_18","073_16_18","JHN","16","18","18","ꠔꠦ ꠔꠣꠁꠘ ꠎꠦ ꠕꠥꠠꠣ ꠡꠝꠄꠅꠞ ꠇꠕꠣ ꠇꠁꠞꠣ, ꠁꠈꠣꠘ ꠇꠤꠔꠣ? ꠔꠣꠁꠘ ꠇꠤꠔꠣ ꠝꠣꠔꠤꠞꠣ, ꠀꠝꠞꠣ ꠔ ꠛꠥꠎꠞꠣꠝ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN16_19","073_16_19","JHN","16","19","19","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠘꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠎꠤꠇꠣꠁꠔꠣ ꠌꠣꠁꠞꠣ, ꠛꠥꠎꠤꠀ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦ ꠇꠁꠍꠤ, ‘ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠀꠞ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠔꠣꠄ ꠘꠣꠄ, ꠢꠤꠞꠛꠣꠞ ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠖꠦꠈꠛꠣꠄ’ ꠅꠔꠣ ꠟꠁꠀ ꠔꠥꠝꠞꠣ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠞꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN16_20","073_16_20","JHN","16","20","20","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠇꠣꠘ꠆ꠖꠤꠛꠣꠄ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠁ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠈꠥꠡꠤ ꠇꠞꠛꠣ। ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠛꠣꠖꠦ ꠁ ꠖꠥꠈ ꠞꠁꠔ ꠘꠣꠄ, ꠄꠞ ꠛꠖꠟꠣ ꠈꠥꠡꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN16_21","073_16_21","JHN","16","21","21","ꠛꠣꠁꠌ꠆ꠌꠣ ꠅꠀꠞ ꠡꠝꠄ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠅꠄ, ꠅꠁꠟꠦ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠘꠄꠀ ꠀꠅꠟꠣꠖꠞ ꠚꠥꠞ꠆ꠔꠤꠄ ꠝꠘ ꠜꠞꠤ ꠎꠣꠄ, ꠢꠤ ꠇꠡ꠆ꠐꠞ ꠇꠕꠣ ꠀꠞ ꠝꠘꠅ ꠕꠣꠇꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN16_22","073_16_22","JHN","16","22","22","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠅ ꠅꠈꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠞꠞꠣꠄ, ꠅꠁꠟꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠖꠦꠈꠣ ꠅꠁꠛ, ꠢꠃ ꠡꠝꠄ ꠈꠥꠡꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠜꠞꠤꠎꠤꠛ, ꠁ ꠈꠥꠡꠤ ꠇꠦꠃ ꠇꠣꠠꠤꠀ ꠘꠤꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN16_23","073_16_23","JHN","16","23","23","“ꠢꠤ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘ꠆ꠔꠣ ꠌꠣꠁꠔꠣꠄ ꠘꠣꠄ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠍꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠌꠣꠁꠛꠣꠄ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JN16_24","073_16_24","JHN","16","24","24","ꠅꠈꠘꠅ ꠔ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠘ꠆ꠔꠣ ꠌꠣꠁꠍ ꠘꠣ। ꠌꠣꠅ, ꠔꠦꠃ ꠙꠣꠁꠛꠣꠄ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠈꠥꠡꠤ ꠙꠥꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JN16_25","073_16_25","JHN","16","25","25","“ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠖꠣꠢꠞꠘ ꠖꠤꠀ ꠅꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣꠝ। ꠅꠁꠟꠦ ꠅꠟꠣꠈꠣꠘ ꠡꠝꠄ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠀꠝꠤ ꠇꠥꠘꠥ ꠃꠖꠣꠢꠞꠘ ꠍꠣꠠꠣ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠛꠥꠎꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JN16_26","073_16_26","JHN","16","26","26","ꠢꠃ ꠖꠤꠘꠃ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠌꠣꠁꠛꠣꠄ। ꠀꠝꠤ ꠔ ꠁꠈꠣꠘ ꠇꠁꠞꠣꠝ ꠘꠣ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠅꠁꠀ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JN16_27","073_16_27","JHN","16","27","27","ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠂꠘ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠍ ꠀꠞ ꠄꠇꠤꠘ ꠇꠞꠍ ꠎꠦ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN16_28","073_16_28","JHN","16","28","28","ꠀꠍꠟꠦ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠃ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠍꠤ ꠀꠞ ꠖꠥꠘꠤꠀ ꠍꠣꠠꠤꠀ ꠔꠣꠘ ꠉꠦꠍꠦꠃ ꠎꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN16_29","073_16_29","JHN","16","29","29","ꠅꠃ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠅꠈꠘ ꠔ ꠀꠙꠘꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣꠃ ꠝꠣꠔꠤꠞꠣ, ꠇꠥꠘꠥ ꠃꠖꠣꠢꠞꠘ ꠖꠤꠞꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN16_30","073_16_30","JHN","16","30","30","ꠅꠈꠘ ꠀꠝꠞꠣ ꠛꠥꠎꠟꠣꠝ, ꠀꠙꠘꠣꠞ ꠅꠎꠣꠘꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ, ꠀꠞ ꠀꠙꠘꠣꠞꠦ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠎꠤꠇꠣꠘꠤꠞꠅ ꠘꠣꠁ। ꠉꠔꠤꠇꠦꠃ ꠀꠝꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠟꠣꠝ, ꠀꠙꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠀꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN16_31","073_16_31","JHN","16","31","31","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠄꠇꠤꠘ ꠅꠁꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JN16_32","073_16_32","JHN","16","32","32","ꠢꠥꠘꠅ, ꠅꠟꠣ ꠡꠝꠄ ꠀꠁꠅꠞ, ꠄꠝꠘꠇꠤ ꠀꠁꠌ꠆ꠍꠦ, ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣ ꠖꠟ ꠍꠣꠠꠤꠀ ꠀꠝꠣꠞꠦ ꠕꠁꠀ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠉꠣꠔ ꠜꠣꠉꠤꠛꠣꠄ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠔ ꠄꠇꠟꠣ ꠘꠣꠄ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN16_33","073_16_33","JHN","16","33","33","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠇꠁꠟꠣꠝ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠝꠤꠡꠤꠀ ꠀꠍ ꠉꠔꠤꠇꠦ ꠝꠘꠅ ꠡꠣꠘ꠆ꠔꠤ ꠙꠣꠅ। ꠁ ꠖꠥꠘꠤꠀꠔ ꠔꠥꠝꠞꠣ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠅ ꠀꠍ, ꠔꠣ-ꠅ ꠝꠘꠅꠛꠟ ꠞꠣꠈꠤꠅ, ꠀꠝꠤꠃ ꠖꠥꠘꠤꠀꠞꠦ ꠎꠄ ꠇꠞꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN17_1","073_17_1","JHN","17","1","1","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠍꠝꠣꠘꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠖꠥꠀ ꠇꠞꠟꠣ, “ꠛꠣꠛꠣ, ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ। ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠙꠥꠔꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠅ, ꠎꠣꠔꠦ ꠙꠥꠔꠦꠅ ꠔꠥꠝꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN17_2","073_17_2","JHN","17","2","2","ꠔꠥꠝꠤ ꠔꠣꠘꠞꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠤꠍ, ꠎꠣꠔꠦ ꠔꠥꠝꠤ ꠎꠦꠞꠣꠞꠦ ꠔꠣꠘ ꠀꠔꠅ ꠡꠙꠤꠍ, ꠄꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("JN17_3","073_17_3","JHN","17","3","3","ꠄꠇꠝꠣꠔ꠆ꠞ ꠢꠇ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠣꠘꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠤ ꠎꠦꠘꠞꠦ ꠙꠣꠑꠣꠁꠍ, ꠢꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠌꠤꠘꠣꠃ ꠅꠁꠟ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN17_4","073_17_4","JHN","17","4","4","ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠦ ꠇꠣꠝ ꠖꠤꠍ, ꠁ ꠇꠣꠝ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠖꠥꠘꠤꠀꠔ ꠔꠥꠝꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN17_5","073_17_5","JHN","17","5","5","ꠔꠦ ꠛꠣꠛꠣ, ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠀꠉꠦ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠣꠞ ꠎꠦ ꠝꠢꠤꠝꠣ ꠀꠍꠤꠟ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠞ ꠅꠃ ꠝꠢꠤꠝꠣ ꠅꠈꠘ ꠀꠝꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("JN17_6","073_17_6","JHN","17","6","6","“ꠁ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠎꠞ ꠎꠦꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠍ, ꠀꠝꠤ ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠣꠞꠦ ꠎꠣꠁꠞ ꠇꠞꠍꠤ। ꠔꠣꠞꠣ ꠔ ꠔꠥꠝꠣꠞꠃ ꠀꠍꠟꠣ, ꠔꠥꠝꠤꠃ ꠔꠣꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠍ। ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN17_7","073_17_7","JHN","17","7","7","ꠔꠣꠞꠣ ꠅꠈꠘ ꠛꠥꠎꠍꠦ, ꠔꠥꠝꠤ ꠎꠦꠔꠣ ꠀꠝꠣꠞꠦ ꠖꠤꠍ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN17_8","073_17_8","JHN","17","8","8","ꠇꠣꠞꠘ ꠅꠁꠟ, ꠔꠥꠝꠤ ꠎꠦꠔꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍ, ꠀꠝꠤ ꠅꠔꠣ ꠎꠣꠘꠣꠁꠍꠤ। ꠀꠞ ꠔꠣꠞꠣꠅ ꠁꠔꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠤꠀ ꠀꠍꠟꠈꠣꠘ ꠛꠥꠎꠤꠟꠤꠍꠦ ꠎꠦꠘ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠀꠁꠍꠤ। ꠔꠣꠞꠣ ꠄꠇꠤꠘꠅ ꠇꠞꠍꠦ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("JN17_9","073_17_9","JHN","17","9","9","ꠔꠦ ꠀꠝꠤ ꠔ ꠢꠇꠟꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ ꠘꠣ, ꠈꠣꠟꠤ ꠔꠥꠝꠤ ꠎꠣꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠤꠍ, ꠄꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠝꠤꠘꠔ ꠇꠞꠞꠣꠝ, ꠔꠣꠞꠣ ꠔ ꠔꠥꠝꠣꠞꠃ। ");
INSERT INTO syls_vpl VALUES ("JN17_10","073_17_10","JHN","17","10","10","ꠀꠝꠣꠞ ꠎꠔꠔꠣ ꠀꠍꠦ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔꠥꠝꠣꠞ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠀꠝꠣꠞ। ꠄꠞꠣꠞ ꠝꠣꠎꠖꠤꠃ ꠀꠝꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("JN17_11","073_17_11","JHN","17","11","11","“ꠅ ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠛꠣ, ꠁ ꠖꠥꠘꠤꠀꠔ ꠀꠝꠤ ꠀꠞ ꠛꠦꠡꠤ ꠡꠝꠄ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠁ ꠖꠥꠘꠤꠀꠔ ꠀꠍꠂꠘ, ꠀꠝꠤ ꠔ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠞꠣꠝ। ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠎꠦ ꠘꠣꠝ ꠖꠤꠍ, ꠅꠃ ꠘꠣꠝꠞ ꠛꠟꠦ ꠄꠞꠣꠞꠦ ꠛꠣꠌꠣꠅ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠄꠇ, ꠔꠣꠞꠣꠅ ꠅꠟꠣ ꠄꠇ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN17_12","073_17_12","JHN","17","12","12","ꠀꠝꠤ ꠎꠔꠖꠤꠘ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣꠝ, ꠅꠔꠖꠤꠘ ꠔꠥꠝꠣꠞ ꠖꠦꠅꠀ ꠅꠃ ꠘꠣꠝꠞ ꠉꠥꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠍꠤ। ꠔꠣꠞꠣꠞꠦ ꠙꠣꠞꠣ ꠖꠤꠀ ꠞꠣꠈꠍꠤ, ꠔꠣꠞꠣ ꠇꠦꠃ ꠛꠤꠘꠣꠡ ꠅꠁꠍꠦ ꠘꠣ। ꠈꠣꠟꠤ ꠎꠣꠞ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠇꠕꠣ, ꠢꠦ-ꠃ ꠛꠤꠘꠣꠡ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠇꠕꠣ ꠚꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("JN17_13","073_17_13","JHN","17","13","13","“ꠔꠦ ꠅꠈꠘ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠞꠣꠝ, ꠖꠥꠘꠤꠀꠔ ꠞꠁꠔꠦꠃ ꠁꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣꠝ, ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠈꠥꠡꠤꠄ ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠜꠞꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN17_14","073_17_14","JHN","17","14","14","ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠍ, ꠀꠝꠤꠅ ꠔꠣꠞꠣꠞꠦ ꠅꠔꠣ ꠎꠣꠘꠣꠁꠍꠤ। ꠀꠝꠤ ꠎꠦꠟꠣ ꠁ ꠖꠥꠘꠤꠀꠞ ꠘꠣꠄ, ꠔꠣꠞꠣꠅ ꠅꠟꠣ ꠁ ꠖꠥꠘꠤꠀꠞ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN17_15","073_17_15","JHN","17","15","15","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠛꠖꠣꠞ ꠇꠞꠞꠣꠝ ꠘꠣ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠘꠤꠔꠣꠄꠉꠤ, ꠛꠞꠋ ꠅꠃ ꠀꠛꠖꠣꠞ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠁꠛꠟꠤꠍꠞ ꠀꠔ ꠕꠣꠇꠤ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN17_16","073_17_16","JHN","17","16","16","ꠀꠝꠤ ꠎꠦꠟꠣ ꠅꠃ ꠖꠥꠘꠤꠀꠞ ꠘꠣꠄ, ꠅꠃꠟꠣ ꠔꠣꠞꠣꠅ ꠁ ꠖꠥꠘꠤꠀꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN17_17","073_17_17","JHN","17","17","17","ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠢꠇ ꠖꠤꠀ ꠈꠣꠍ ꠢꠤꠡꠣꠛꠦ ꠞꠣꠈꠅ। ꠔꠥꠝꠣꠞ ꠇꠣꠟꠣꠝꠃ ꠅꠁꠟ ꠅꠃ ꠢꠇ। ");
INSERT INTO syls_vpl VALUES ("JN17_18","073_17_18","JHN","17","18","18","ꠔꠥꠝꠤ ꠎꠦꠟꠣ ꠀꠝꠣꠞꠦ ꠖꠥꠘꠤꠀꠔ ꠙꠣꠑꠣꠁꠍ, ꠅꠃꠟꠣ ꠀꠝꠤꠅ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠎꠦ ꠙꠣꠑꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("JN17_19","073_17_19","JHN","17","19","19","ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞꠦ ꠈꠣꠍ ꠇꠞꠤ ꠞꠣꠈꠍꠤ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞꠦꠅ ꠢꠇ ꠖꠤꠀ ꠈꠣꠍ ꠢꠤꠡꠣꠛꠦ ꠞꠣꠈꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JN17_20","073_17_20","JHN","17","20","20","“ꠔꠦ ꠀꠝꠤ ꠈꠣꠟꠤ ꠄꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠝꠤꠘꠔ ꠇꠞꠞꠣꠝ, ꠎꠦꠞꠣ ꠄꠞꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("JN17_21","073_17_21","JHN","17","21","21","ꠀꠝꠤ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ ꠔꠣꠞꠣ ꠢꠇꠟ ꠎꠣꠘꠥ ꠄꠇ ꠅꠄ। ꠛꠣꠛꠣ, ꠔꠥꠝꠤ ꠎꠦꠟꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠍ ꠀꠞ ꠀꠝꠤꠅ ꠎꠦꠟꠣ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠀꠍꠤ, ꠅꠃꠟꠣ ꠔꠣꠞꠣꠅ ꠎꠣꠘꠥ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠞꠂꠘ। ꠔꠦꠃ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠄꠇꠤꠘ ꠇꠞꠛꠣ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("JN17_22","073_17_22","JHN","17","22","22","ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠦ ꠝꠢꠤꠝꠣ ꠖꠣꠘ ꠇꠞꠍ, ꠀꠝꠤ ꠁꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠍꠤ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠄꠇ, ꠅꠃꠟꠣ ꠔꠣꠞꠣꠅ ꠄꠇ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN17_23","073_17_23","JHN","17","23","23","ꠔꠥꠝꠤ ꠎꠦꠟꠣ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠀꠍ, ꠅꠟꠣ ꠀꠝꠤꠅ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠤ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠙꠥꠞꠣꠙꠥꠞ ꠄꠇ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ। ꠔꠦꠃ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠛ, ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍ, ꠀꠞ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠝꠣꠄꠀ ꠇꠞ, ꠅꠃꠟꠣ ꠔꠣꠞꠣꠞꠦꠅ ꠝꠣꠄꠀ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN17_24","073_17_24","JHN","17","24","24","ꠛꠣꠛꠣ, ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠎꠦꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠍ, ꠀꠝꠤ ꠎꠦꠈꠣꠘꠅ ꠀꠍꠤ, ꠔꠣꠞꠣꠅ ꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠟꠉꠦ ꠢꠘꠅ ꠞꠂꠘ ꠀꠞ ꠀꠝꠣꠞ ꠝꠢꠤꠝꠣ ꠖꠦꠈꠂꠘ। ꠁ ꠝꠢꠤꠝꠣ ꠔ ꠔꠥꠝꠤꠃ ꠀꠝꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠍ, ꠇꠣꠞꠘ ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠀꠉ ꠕꠣꠇꠤꠃ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("JN17_25","073_17_25","JHN","17","25","25","“ꠅ ꠢꠇ ꠁꠘꠍꠣꠚꠇꠣꠞꠤ ꠛꠣꠛꠣ, ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠌꠤꠘꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠔ ꠌꠤꠘꠤ। ꠀꠞ ꠔꠥꠝꠤꠃ ꠎꠦꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍ, ꠁꠈꠣꠘ ꠄꠞꠣ ꠛꠥꠎꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN17_26","073_17_26","JHN","17","26","26","ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠎꠣꠁꠞ ꠇꠞꠍꠤ, ꠀꠉꠦꠖꠤ ꠀꠞꠅ ꠇꠞꠝꠥ, ꠎꠣꠔꠦ ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠝꠣꠄꠀ ꠇꠞ, ꠅꠟꠣ ꠝꠣꠄꠀ ꠔꠣꠞꠣꠞ ꠜꠤꠔꠞꠦꠅ ꠕꠣꠇꠦ ꠀꠞ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠤꠡꠤꠀ ꠕꠣꠇꠤ।” ");
INSERT INTO syls_vpl VALUES ("JN18_1","073_18_1","JHN","18","1","1","ꠅꠃ ꠝꠥꠘꠣꠎꠣꠔꠞ ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠇꠤꠖ꠆ꠞꠥꠘ ꠘꠣꠝꠞ ꠄꠇ ꠙꠣꠠꠤꠀ ꠈꠣꠟ ꠙꠣꠞ ꠅꠁꠀ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠄꠇ ꠛꠣꠉꠣꠘꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_2","073_18_2","JHN","18","2","2","ꠛꠦꠁꠝꠣꠘ ꠁꠢꠥꠖꠣꠄ ꠁ ꠎꠣꠉꠣ ꠌꠤꠘꠔ, ꠇꠣꠞꠘ ꠁꠍꠣꠄ ꠀꠉꠦ ꠛꠃꠔ ꠛꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠟꠁꠀ ꠅꠘꠅ ꠛꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN18_3","073_18_3","JHN","18","3","3","ꠄꠞꠝꠣꠎꠦ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠅꠃ ꠁꠢꠥꠖꠣꠞ ꠟꠉꠦ ꠄꠇ ꠖꠟ ꠍꠤꠙꠣꠁ ꠀꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠇꠄꠎꠘ ꠙꠥꠟꠤꠡ ꠙꠣꠑꠣꠁꠟꠣ। ꠁꠢꠥꠖꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠟꠁꠀ ꠅꠘꠅ ꠀꠁꠟ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠟꠦꠝ, ꠝꠥꠡꠣꠟ, ꠀꠞ ꠅꠡꠔ꠆ꠞ-ꠡꠡꠔ꠆ꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN18_4","073_18_4","JHN","18","4","4","ꠁꠍꠣꠄ ꠀꠉ ꠕꠣꠇꠤꠃ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠔꠣ, ꠔꠣꠘ ꠃꠙꠞꠦ ꠇꠤꠔꠣ ꠊꠐꠛ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠀꠉꠥꠀꠁꠀ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠇꠣꠞꠦ ꠔꠥꠇꠣꠁꠞꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN18_5","073_18_5","JHN","18","5","5","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠞ ꠁꠍꠣꠞꠦ।” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠢꠦꠁꠘ।” ꠅꠃ ꠡꠝꠄ ꠛꠦꠁꠝꠣꠘ ꠁꠢꠥꠖꠣꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN18_6","073_18_6","JHN","18","6","6","ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠇꠁꠟꠣ, “ꠀꠝꠤꠃ ꠢꠦꠁꠘ,” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠔꠣꠞꠣ ꠈꠞꠦꠖꠤ ꠉꠤꠀ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_7","073_18_7","JHN","18","7","7","ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠇꠣꠞꠦ ꠌꠣꠁꠞꠣ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠞ ꠁꠍꠣꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN18_8","073_18_8","JHN","18","8","8","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠇꠁꠟꠣꠝ, ꠀꠝꠤꠃ ꠢꠦꠁꠘ। ꠀꠙꠘꠣꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦꠃ ꠔꠥꠇꠣꠘꠤꠔ ꠀꠁꠘ, ꠔꠦ ꠀꠝꠣꠞ ꠟꠉꠞ ꠄꠞꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN18_9","073_18_9","JHN","18","9","9","ꠀꠍꠟꠦ ꠁꠟꠣ ꠊꠐꠟ, ꠎꠣꠔꠦ ꠁꠍꠣꠄ ꠀꠉꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠟꠣ ꠅꠔꠣ ꠙꠥꠞꠣ ꠅꠄ। ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, “ꠛꠣꠛꠣ, ꠔꠥꠝꠤ ꠎꠦꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠍ, ꠄꠞꠣ ꠄꠇꠎꠘꠞꠦꠅ ꠀꠝꠤ ꠈꠥꠀꠁꠍꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN18_10","073_18_10","JHN","18","10","10","ꠅꠃ ꠡꠝꠄ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠞ ꠟꠉꠦ ꠄꠇꠈꠣꠘ ꠔꠟꠥꠀꠞ ꠀꠍꠤꠟ, ꠅꠈꠣꠘ ꠛꠣꠞ ꠇꠞꠤꠀ, ꠔꠣꠁꠘ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠥꠟꠣꠝꠞ ꠒꠣꠁꠘ ꠇꠣꠘ ꠇꠣꠐꠤꠟꠤꠟꠣ। ꠁ ꠉꠥꠟꠣꠝꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠝꠣꠟꠇꠥꠍ। ");
INSERT INTO syls_vpl VALUES ("JN18_11","073_18_11","JHN","18","11","11","ꠄꠞꠟꠣꠉꠤ ꠁꠍꠣꠄ ꠙꠤꠔꠞꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠔꠟꠥꠀꠞ ꠈꠣꠙꠅ ꠢꠣꠞꠣꠅ। ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠀꠝꠣꠞꠦ ꠎꠦ ꠝꠍꠤꠛꠔꠞ ꠙꠤꠀꠟꠣ ꠖꠤꠍꠂꠘ, ꠁꠇꠐꠣꠞ ꠡ꠆ꠛꠣꠖ ꠀꠝꠤ ꠟꠁꠔꠣꠝ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN18_12","073_18_12","JHN","18","12","12","ꠅꠃ ꠡꠝꠄ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ, ꠙꠞꠗꠣꠘ ꠍꠤꠙꠣꠁꠄ ꠀꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠙꠥꠟꠤꠡ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠗꠞꠤꠀ ꠛꠣꠘ꠆ꠖꠤꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN18_13","073_18_13","JHN","18","13","13","ꠛꠣꠘ꠆ꠖꠤꠀ ꠙꠄꠟꠣ ꠔꠣꠞꠣ ꠢꠣꠘꠘꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟ। ꠁ ꠢꠣꠘꠘ ꠀꠍꠟꠣ ꠢꠃ ꠛꠍꠞꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠇꠣꠄꠀꠚꠣꠞ ꠢꠃꠞ। ");
INSERT INTO syls_vpl VALUES ("JN18_14","073_18_14","JHN","18","14","14","ꠅꠃ ꠇꠣꠄꠀꠚꠣꠄ ꠀꠉꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠍꠟꠣ, “ꠀꠡ꠆ꠔꠣ ꠎꠣꠔꠤ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠌꠣꠁꠔꠦ, ꠢꠇꠟꠞ ꠛꠖꠟꠣ ꠄꠇꠎꠘꠞ ꠝꠞꠘ ꠀꠞꠅ ꠜꠣꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN18_15","073_18_15","JHN","18","15","15","ꠅꠃ ꠡꠝꠄ ꠙꠤꠔꠞ ꠀꠞ ꠀꠞꠇ ꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠁꠍꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟꠣ। ꠅꠃ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠌꠤꠘꠔꠣ। ꠄꠁꠘ ꠁꠍꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠛꠣꠠꠤꠞ ꠃꠑꠣꠘꠅ ꠢꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_16","073_18_16","JHN","18","16","16","ꠅꠁꠟꠦ ꠙꠤꠔꠞ ꠛꠣꠁꠞꠦ ꠉꠦꠁꠐꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁ ꠞꠁꠟꠣ। ꠔꠦꠃ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠙꠞꠤꠌꠤꠔ ꠁꠍꠣꠞ ꠅꠃ ꠍꠣꠢꠣꠛꠤ ꠛꠣꠞꠦ ꠉꠤꠀ ꠙꠣꠞꠣꠖꠣꠞ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠀ ꠙꠤꠔꠞꠞꠦ ꠜꠤꠔꠞꠦ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_17","073_18_17","JHN","18","17","17","ꠅꠃ ꠛꠦꠐꠤꠄ ꠙꠤꠔꠞꠞꠦ ꠇꠁꠟ, “ꠔꠥꠝꠤꠅ ꠄꠘ ꠝꠥꠞꠤꠖ ꠘꠤ?” ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠀꠝꠤ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN18_18","073_18_18","JHN","18","18","18","ꠅꠃ ꠡꠝꠄ ꠈꠥꠛ ꠡꠤꠔ ꠙꠠꠍꠤꠟ, ꠄꠞꠖꠣꠄ ꠍꠤꠙꠣꠁ ꠀꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠃꠑꠣꠘꠅ ꠀꠋꠞꠣꠖꠤ ꠀꠉꠥꠁꠘ ꠗꠞꠣꠁꠀ ꠀꠉꠥꠁꠘ ꠔꠣꠛꠣꠘꠤꠔ ꠟꠣꠉꠟꠣ। ꠙꠤꠔꠞꠦꠅ ꠔꠣꠞꠣꠞ ꠗꠣꠞꠅ ꠃꠛꠣꠁꠀ ꠀꠉꠥꠁꠘ ꠔꠣꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_19","073_18_19","JHN","18","19","19","ꠅꠃ ꠡꠝꠄ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠁꠍꠣꠞꠦ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠀꠞ ꠔꠣꠘ ꠔꠣꠟꠤꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_20","073_18_20","JHN","18","20","20","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠝꠣꠔꠤꠍꠤ। ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠎꠦꠈꠣꠘꠅ ꠎꠝꠣ ꠅꠁꠘ, ꠅꠔꠣ ꠝꠍꠤꠖꠅ ꠀꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠦꠡꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠤ। ꠀꠝꠤ ꠔ ꠟꠥꠇꠣꠁꠀ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_21","073_18_21","JHN","18","21","21","ꠔꠦ ꠀꠝꠣꠞꠦ ꠀꠞ ꠇꠦꠘꠦ ꠎꠤꠇꠣꠁꠞꠣ? ꠀꠝꠣꠞ ꠔꠣꠟꠤꠝ ꠎꠦꠞꠣ ꠢꠥꠘꠍꠦ, ꠔꠣꠞꠣꠞꠦꠃ ꠎꠤꠇꠣꠃꠇ꠆ꠇꠣ। ꠀꠝꠤ ꠎꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠤ, ꠁꠔꠣ ꠔꠣꠞꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN18_22","073_18_22","JHN","18","22","22","ꠁꠍꠣꠞ ꠁ ꠎꠥꠀꠙ ꠢꠥꠘꠤꠀ, ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠦ ꠍꠤꠙꠣꠁ ꠅꠇꠟ ꠃꠛꠣ ꠀꠍꠟꠣ, ꠄꠞꠣ ꠄꠇꠎꠘꠦ ꠔꠣꠘꠞꠦ ꠌꠠ ꠝꠣꠞꠤꠀ ꠇꠁꠟ, “ꠔꠥꠁ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞꠦ ꠅꠟꠣ ꠎꠥꠀꠙ ꠖꠤꠞꠦ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN18_23","073_18_23","JHN","18","23","23","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠥꠖꠤ ꠛꠣꠖ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠀ ꠕꠣꠇꠤ ꠔꠦ ꠇꠃꠇ꠆ꠇꠣ, ꠀꠞ ꠜꠣꠟꠣ ꠝꠣꠔ ꠝꠣꠔꠤꠟꠦ ꠀꠝꠣꠞꠦ ꠝꠣꠞꠞꠣ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN18_24","073_18_24","JHN","18","24","24","ꠅꠃ ꠡꠝꠄ ꠢꠣꠘꠘꠦ ꠛꠣꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠁꠍꠣꠞꠦ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠇꠣꠄꠀꠚꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_25","073_18_25","JHN","18","25","25","ꠍꠣꠢꠣꠛꠤ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠎꠦꠛꠟꠣ ꠀꠉꠥꠁꠘ ꠔꠣꠛꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟ, “ꠔꠥꠝꠤꠅ ꠔꠣꠞ ꠟꠉꠞ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠘꠤ?” ꠙꠤꠔꠞꠦ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠀꠝꠤ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN18_26","073_18_26","JHN","18","26","26","ꠙꠤꠔꠞꠦ ꠎꠣꠞ ꠇꠣꠘ ꠇꠣꠐꠤꠍꠟꠣ, ꠔꠣꠞ ꠄꠇ ꠇꠥꠐꠥꠝ ꠀꠍꠤꠟ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠥꠟꠣꠝ। ꠢꠦ ꠇꠁꠟ, “ꠀꠝꠤ ꠛꠣꠉꠣꠘꠞ ꠜꠤꠔꠞꠦ ꠅꠉꠥꠞ ꠟꠉꠦ ꠔꠥꠝꠣꠞꠦꠅ ꠖꠦꠈꠟꠣꠝ ꠘꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN18_27","073_18_27","JHN","18","27","27","ꠙꠤꠔꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠟꠣ, ꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠝꠥꠞꠉꠣꠄ ꠛꠣꠋ ꠖꠤꠟꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN18_28","073_18_28","JHN","18","28","28","ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠛꠤꠀꠘꠦ ꠁꠍꠣꠞꠦ ꠇꠣꠄꠀꠚꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠞ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠐꠋꠉꠤꠔ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠛꠣꠠꠤꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ ꠘꠣ, ꠎꠣꠔꠦ ꠛꠦ-ꠖꠤꠘ ꠢꠣꠇꠤꠝꠞ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠀ ꠘꠣꠙꠣꠇ ꠘꠣ ꠅꠁꠘ, ꠛꠞꠋ ꠙꠣꠇ-ꠍꠣꠚ ꠞꠁꠀ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠈꠣꠘꠤ ꠈꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN18_29","073_18_29","JHN","18","29","29","ꠄꠞꠟꠣꠉꠤ ꠞꠥꠝꠣꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔ ꠛꠣꠞꠦ ꠀꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁ ꠛꠦꠐꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠟꠤꠡ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN18_30","073_18_30","JHN","18","30","30","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠢꠦ ꠅꠙꠞꠣꠗ ꠘꠣ ꠇꠞꠟꠦ ꠔ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠟꠣꠝ ꠘꠣ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN18_31","073_18_31","JHN","18","31","31","ꠙꠤꠟꠣꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠔꠣꠞꠦ ꠟꠁꠀ ꠎꠣꠅꠉꠤ, ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠟꠣꠅ।” ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠙꠤꠟꠣꠔꠞꠦ ꠇꠁꠟꠣ, “ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠝꠔ ꠡꠣꠎꠣ ꠖꠦꠅꠀꠞ ꠈꠦꠝꠔꠣ ꠀꠝꠞꠣꠞ ꠀꠔꠅ ꠘꠣꠁ, ꠈꠣꠟꠤ ꠞꠥꠝꠣꠘ ꠅꠇꠟꠞ ꠀꠔꠅ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN18_32","073_18_32","JHN","18","32","32","ꠘꠤꠎꠞ ꠝꠃꠔ ꠇꠤꠟꠣꠘ ꠅꠁꠛ, ꠁꠍꠣꠄ ꠁꠈꠣꠘ ꠀꠉꠦꠃ ꠇꠁꠍꠂꠘ। ꠔꠦ ꠁꠔꠣ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠅꠃ ꠇꠕꠣ ꠚꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("JN18_33","073_18_33","JHN","18","33","33","ꠔꠦꠃ ꠙꠤꠟꠣꠔ ꠢꠤꠞꠛꠣꠞ ꠐꠋꠉꠤꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ ꠀꠞ ꠁꠍꠣꠞꠦ ꠒꠣꠇ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("JN18_34","073_18_34","JHN","18","34","34","ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠙꠘꠦ ꠘꠤꠎꠦ ꠅꠃ ꠇꠕꠣ ꠇꠁꠞꠣ, ꠘꠣ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠙꠘꠣꠞꠦ ꠇꠁꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN18_35","073_18_35","JHN","18","35","35","ꠙꠤꠟꠣꠔꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠇꠤꠔꠣ ꠁꠢꠥꠖꠤ ꠘꠤ? ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠦ ꠀꠞ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠔꠥꠝꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠤꠍꠦ। ꠇꠅ, ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠍ?” ");
INSERT INTO syls_vpl VALUES ("JN18_36","073_18_36","JHN","18","36","36","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠁ ꠖꠥꠘꠤꠀꠞ ꠘꠣꠄ। ꠀꠝꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠎꠥꠖꠤ ꠅꠃ ꠖꠥꠘꠤꠀꠞ ꠅꠁꠔ, ꠔꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠀꠔꠅ ꠀꠝꠤ ꠘꠣ ꠙꠠꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠝꠣꠘꠡꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠟ ꠅꠘꠦ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠁꠘꠞ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN18_37","073_18_37","JHN","18","37","37","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠣꠁꠟꠦ ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠛꠣꠖꠡꠣ ꠘꠤ?” ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦꠃ ꠔ ꠇꠁꠞꠣ, ꠀꠝꠤ ꠛꠣꠖꠡꠣ। ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠢꠇꠞ ꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠍꠤ। ꠎꠣꠞꠣ ꠢꠇꠞ ꠟꠉꠦ ꠀꠍꠦ, ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN18_38","073_18_38","JHN","18","38","38","ꠙꠤꠟꠣꠔꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠢꠇꠈꠣꠘ ꠇꠤꠔꠣ?” ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠞꠦ ꠉꠤꠀ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠄꠞ ꠇꠥꠘꠥ ꠖꠥꠡ ꠙꠣꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN18_39","073_18_39","JHN","18","39","39","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠔ ꠄꠇꠐꠣ ꠞꠦꠅꠀꠎ ꠀꠍꠦ, ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠡꠝꠄ ꠀꠝꠤ ꠄꠇꠎꠘ ꠇꠄꠅꠖꠤꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠦꠁ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠌꠣꠅ ꠘꠤ, ꠀꠝꠤ ꠁꠢꠥꠖꠤꠞ ꠅꠃ ꠛꠣꠖꠡꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("JN18_40","073_18_40","JHN","18","40","40","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠘꠣ, ꠘꠣ, ꠄꠞꠦ ꠘꠣ, ꠛꠣꠞꠣꠛ꠆ꠛꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠃꠇ꠆ꠇꠣ।” ꠅꠃ ꠛꠣꠞꠣꠛ꠆ꠛꠣ ꠀꠍꠤꠟ ꠄꠇ ꠒꠣꠇꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("JN19_1","073_19_1","JHN","19","1","1","ꠛꠣꠖꠦ ꠞꠥꠝꠣꠘ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞꠦ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_2","073_19_2","JHN","19","2","2","ꠀꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠉꠍꠣ-ꠇꠣꠐꠣ ꠖꠤꠀ ꠄꠇ ꠝꠥꠇꠥꠐ ꠛꠣꠘꠣꠁꠀ ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠖꠤꠟ, ꠀꠞ ꠛꠣꠁꠋꠉꠘꠤ ꠞꠋꠉꠞ ꠛꠣꠖꠡꠣꠁ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN19_3","073_19_3","JHN","19","3","3","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠇꠁꠟ, “ꠅ ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ, ꠝꠣꠞꠢꠣꠛꠣ!” ꠅꠈꠣꠘ ꠇꠁꠀ ꠇꠁꠀ ꠔꠣꠞꠣ ꠔꠣꠘ ꠉꠣꠟꠅ ꠌꠠꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN19_4","073_19_4","JHN","19","4","4","ꠔꠦꠃ ꠙꠤꠟꠣꠔ ꠢꠤꠞꠛꠣꠞ ꠛꠣꠞꠦ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠄꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠛꠣꠞ ꠇꠞꠤꠀ ꠀꠘꠤꠀꠞ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠤ ꠄꠞ ꠇꠥꠘꠥ ꠖꠥꠡꠃ ꠙꠣꠁꠞꠣꠝ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN19_5","073_19_5","JHN","19","5","5","ꠢꠃ ꠉꠍꠣ-ꠇꠣꠐꠣꠞ ꠝꠥꠇꠥꠐ ꠀꠞ ꠛꠣꠁꠋꠉꠘꠤ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠁꠍꠣ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ, ꠀꠞ ꠙꠤꠟꠣꠔꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠖꠦꠈꠅ, ꠢꠃ ꠝꠣꠘꠥꠡ।” ");
INSERT INTO syls_vpl VALUES ("JN19_6","073_19_6","JHN","19","6","6","ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠙꠥꠟꠤꠡ ꠅꠇꠟꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠣꠞꠦ ꠍꠟꠤꠛꠅ ꠖꠦꠅ, ꠍꠟꠤꠛꠅ ꠖꠦꠅ।” ꠙꠤꠟꠣꠔꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠔ ꠔꠣꠞ ꠇꠥꠘꠥ ꠖꠥꠡ ꠙꠣꠁꠍꠤ ꠘꠣ, ꠔꠦ ꠔꠥꠝꠞꠣꠃ ꠔꠣꠞꠦ ꠘꠤꠀ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠤꠟꠣꠅ।” (ꠁ ꠍꠟꠤꠛ ꠅꠁꠟ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ, ꠝꠣꠘꠡꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣꠞ ꠄꠇ ꠎꠤꠘꠤꠡ।) ");
INSERT INTO syls_vpl VALUES ("JN19_7","073_19_7","JHN","19","7","7","ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠙꠤꠟꠣꠔꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠔꠣꠞ ꠝꠞꠘ ꠅꠀ ꠃꠌꠤꠔ, ꠇꠣꠞꠘ ꠢꠦ ꠘꠤꠎꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠇꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN19_8","073_19_8","JHN","19","8","8","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠙꠤꠟꠣꠔꠦ ꠀꠞꠅ ꠛꠦꠡꠤ ꠒꠞꠣꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_9","073_19_9","JHN","19","9","9","ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠐꠋꠉꠤ-ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍ?” ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_10","073_19_10","JHN","19","10","10","ꠄꠞꠖꠣꠄ ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠝꠣꠔꠞ ꠇꠥꠘꠥ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ ꠘꠣ ꠘꠤ? ꠔꠥꠝꠤ ꠎꠣꠘ ꠘꠤ, ꠔꠥꠝꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠛꠣꠞ ꠛꠣ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠀꠝꠣꠞ ꠀꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN19_11","073_19_11","JHN","19","11","11","ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠃꠙꠞꠦ ꠕꠣꠇꠤ ꠀꠙꠘꠣꠞꠦ ꠈꠦꠝꠔꠣ ꠘꠣ ꠖꠦꠅꠀ ꠅꠁꠟꠦ, ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠙꠘꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠝꠔꠣꠃ ꠕꠣꠇꠔ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞꠦ ꠀꠙꠘꠣꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠤꠍꠦ, ꠢꠦ-ꠃ ꠛꠠ ꠉꠥꠘꠣꠉꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN19_12","073_19_12","JHN","19","12","12","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠟꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠦ ꠎꠥꠖꠤ ꠄꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠟꠣꠁꠘ, ꠔꠦ ꠀꠙꠘꠦ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠞ ꠖꠥꠡ꠆ꠔ ꠘꠣꠄ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞꠦ ꠛꠣꠖꠡꠣ ꠇꠁꠀ ꠖꠣꠛꠤ ꠇꠞꠦ, ꠢꠦ ꠔ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠞ ꠖꠥꠡꠝꠘ।” ");
INSERT INTO syls_vpl VALUES ("JN19_13","073_19_13","JHN","19","13","13","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠙꠤꠟꠣꠔꠦ ꠁꠍꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣ ꠀꠞ ꠙꠣꠔ꠆ꠔꠞꠖꠤ-ꠛꠣꠘ꠆ꠖꠣ ꠘꠣꠝꠞ ꠄꠇ ꠃꠑꠣꠘꠅ ꠛꠤꠌꠣꠞꠞ ꠀꠡꠘꠅ ꠛꠁꠟꠣ। ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠁ ꠃꠑꠣꠘꠞꠦ ꠉꠣꠛ꠆ꠛꠣꠕꠣ ꠇꠅꠀ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JN19_14","073_19_14","JHN","19","14","14","ꠁ ꠖꠤꠘ ꠀꠍꠤꠟ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠀꠄꠅꠎꠘꠞ ꠖꠤꠘ। ꠅꠃ ꠡꠝꠄ ꠛꠦꠁꠟ ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁꠚꠞ ꠅꠁꠉꠦꠍꠦ। ꠙꠤꠟꠣꠔꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠖꠦꠈꠅ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠖꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN19_15","073_19_15","JHN","19","15","15","ꠁꠍꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠅꠉꠥꠞꠦ ꠢꠞꠣꠅ, ꠢꠞꠣꠅ, ꠔꠣꠞꠦ ꠍꠟꠤꠛꠅ ꠖꠦꠅ।” ꠙꠤꠟꠣꠔꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣꠞ ꠛꠣꠖꠡꠣꠞꠦ ꠀꠝꠤ ꠍꠟꠤꠛꠅ ꠖꠤꠟꠣꠁꠔꠣꠝ ꠘꠤ?” ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠈꠣꠟꠤ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣ ꠍꠣꠠꠣ, ꠀꠝꠞꠣꠞ ꠀꠞ ꠇꠥꠘꠥ ꠛꠣꠖꠡꠣ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("JN19_16","073_19_16","JHN","19","16","16","ꠔꠦꠃ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠦ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠍꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ, ꠀꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_17","073_19_17","JHN","19","17","17","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠔꠣꠘ ꠍꠟꠤꠛ ꠘꠤꠎꠦ ꠛꠁꠀ ꠇꠟ꠆ꠟꠣꠞ ꠌꠣꠠ ꠘꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠉꠦꠟꠣ। ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠁ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠉꠟꠉꠣꠕꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_18","073_19_18","JHN","19","18","18","ꠢꠤꠘꠅ ꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠟ। ꠁꠍꠣꠞꠦ ꠝꠣꠎꠈꠣꠘꠅ, ꠀꠞ ꠔꠣꠘ ꠖꠥꠁ ꠉꠣꠟꠣꠞ ꠖꠥꠁꠅ ꠍꠟꠤꠛꠅ ꠅꠁꠘ꠆ꠘ ꠖꠥꠁꠎꠘꠞꠦ ꠟꠐꠇꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN19_19","073_19_19","JHN","19","19","19","ꠀꠞ ꠙꠤꠟꠣꠔꠦ ꠄꠇꠈꠣꠘ ꠅꠙꠞꠣꠗ-ꠘꠣꠝꠣ ꠟꠦꠈꠤꠀ ꠁꠍꠣꠞ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠟꠣꠉꠣꠁꠟꠣ। ꠁꠈꠣꠘꠅ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, “ꠘꠣꠍꠣꠞꠔ ꠉꠣꠃꠞ ꠁꠍꠣ, ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN19_20","073_19_20","JHN","19","20","20","ꠎꠦ ꠎꠣꠉꠣꠔ ꠔꠣꠘꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠅꠃ ꠎꠣꠉꠣ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠍꠤꠟ ꠉꠔꠤꠇꠦ ꠛꠃꠔ ꠁꠢꠥꠖꠤꠄ ꠅꠃ ꠅꠙꠞꠣꠗ-ꠘꠣꠝꠣ ꠙꠠꠟ। ꠁꠈꠣꠘ ꠁꠛꠞꠣꠘꠤ, ꠁꠃꠘꠣꠘꠤ ꠀꠞ ꠞꠥꠝꠣꠘ ꠜꠣꠡꠣꠄ ꠟꠦꠈꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN19_21","073_19_21","JHN","19","21","21","ꠁꠢꠥꠖꠤꠞ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞꠦ ꠇꠁꠟꠣ, “ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ ꠘꠣ ꠟꠦꠈꠤꠀ, ꠀꠙꠘꠦ ꠅꠟꠣ ꠟꠦꠈꠃꠇ꠆ꠇꠣ, ꠢꠦ ꠇꠁꠔ, ꠀꠝꠤ ꠁꠢꠥꠖꠤꠞ ꠛꠣꠖꠡꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN19_22","073_19_22","JHN","19","22","22","ꠙꠤꠟꠣꠔꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠦꠔꠣ ꠟꠦꠈꠍꠤ, ꠟꠦꠈꠍꠤꠃ।” ");
INSERT INTO syls_vpl VALUES ("JN19_23","073_19_23","JHN","19","23","23","ꠁꠍꠣꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠔꠣꠘ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠌꠣꠁꠞ ꠛꠣꠐ ꠇꠞꠤ ꠛꠣꠐꠤꠀ ꠘꠤꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠘ ꠇꠥꠞ꠆ꠔꠣꠐꠣꠅ ꠘꠤꠟꠣ। ꠁ ꠀꠡ꠆ꠔꠣ ꠇꠥꠞ꠆ꠔꠣꠞ ꠉꠟꠣ ꠕꠣꠇꠤ ꠛꠣꠁꠘ ꠇꠞꠣ, ꠇꠥꠘꠥ ꠡꠤꠟꠣꠁ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_24","073_19_24","JHN","19","24","24","ꠄꠞꠟꠣꠉꠤ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟ, “ꠁꠇꠐꠣ ꠘꠣ ꠍꠤꠠꠤꠀ ꠛꠞꠋ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠤ ꠖꠦꠈꠤ, ꠇꠣꠞ ꠜꠣꠁꠉ꠆ꠉꠔ ꠙꠠꠦ।” ꠁꠔꠣ ꠊꠐꠍꠤꠟ, ꠎꠣꠔꠦ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠞ ꠇꠕꠣ ꠚꠟꠦ, ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠎꠦ ꠀꠝꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠛꠣꠐꠣ-ꠛꠣꠐꠤ ꠇꠞꠍꠦ, ꠀꠝꠣꠞ ꠇꠥꠞ꠆ꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN19_25","073_19_25","JHN","19","25","25","ꠀꠞ ꠢꠣꠍꠣꠃ ꠔꠣꠞꠣ ꠅꠟꠣ ꠇꠞꠟ। ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠍꠟꠤꠛꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠔꠣꠘ ꠝꠣ, ꠈꠣꠟꠣ, ꠇꠥꠟꠥꠚꠣꠞ ꠛꠃ ꠝꠞꠤꠅꠝ ꠀꠞ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ ꠃꠛꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_26","073_19_26","JHN","19","26","26","ꠁꠍꠣꠄ ꠖꠦꠈꠟꠣ, ꠔꠣꠘ ꠝꠣ ꠀꠞ ꠝꠣꠄꠀꠞ ꠢꠃ ꠍꠣꠢꠣꠛꠤ ꠗꠣꠞꠅ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠖꠦꠈꠤꠀ ꠙꠄꠟꠣ ꠔꠣꠘ ꠝꠣʼꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠁ ꠉ, ꠅꠃꠘꠥ ꠔꠥꠝꠣꠞ ꠙꠥꠀ।” ");
INSERT INTO syls_vpl VALUES ("JN19_27","073_19_27","JHN","19","27","27","ꠀꠞ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁ, ꠅꠃꠘꠥ ꠔꠥꠝꠣꠞ ꠝꠣ।” ꠅꠃ ꠡꠝꠄ ꠕꠣꠇꠤ ꠁ ꠍꠣꠢꠣꠛꠤꠄ ꠁꠍꠣꠞ ꠝꠣʼꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠊꠞꠅ ꠟꠁꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JN19_28","073_19_28","JHN","19","28","28","ꠄꠞꠛꠣꠖꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠡꠦꠡ ꠅꠁꠉꠦꠍꠦ ꠎꠣꠘꠤꠀ, ꠀꠟ-ꠎꠛꠥꠞ ꠇꠤꠔꠣꠛꠞ ꠀꠄꠀꠔ ꠎꠣꠔꠦ ꠚꠟꠦ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠙꠤꠀꠍꠦ ꠗꠞꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN19_29","073_19_29","JHN","19","29","29","ꠅꠃ ꠡꠝꠄ ꠢꠤꠘꠅ ꠄꠇ ꠎꠉ ꠐꠦꠋꠉꠣ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔ ꠀꠍꠤꠟ। ꠔꠣꠞꠣ ꠄꠇꠈꠣꠘ ꠔꠦꠘꠣ ꠀꠘꠤꠀ ꠅꠃ ꠡꠞꠛꠔꠞ ꠝꠣꠎꠦ ꠜꠤꠎꠣꠁꠀ, ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠒꠦꠐꠣꠞ ꠝꠣꠕꠣꠔ ꠟꠣꠉꠣꠁꠀ ꠃꠌꠣ ꠇꠞꠤ ꠔꠣꠘ ꠝꠥꠈꠞ ꠉꠦꠍꠦ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN19_30","073_19_30","JHN","19","30","30","ꠁ ꠡꠞꠛꠔ ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠡꠦꠡ ꠅꠁꠉꠦꠍꠦ।” ꠅꠈꠣꠘ ꠇꠁꠀ, ꠔꠣꠁꠘ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠀ ꠀꠈꠦꠞꠤ ꠖꠝ ꠚꠣꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_31","073_19_31","JHN","19","31","31","ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠀꠉꠞ ꠖꠤꠘ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ। ꠛꠣꠖꠞ ꠖꠤꠘ ꠀꠍꠤꠟ ꠈꠣꠍ ꠙꠛꠤꠔ꠆ꠞ ꠄꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞ। ꠄꠞꠟꠣꠉꠤ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠌꠣꠁꠟꠣ, ꠁ ꠖꠤꠘ ꠎꠣꠘꠥ ꠇꠥꠘꠥ ꠟꠣꠡ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠘꠣ ꠕꠣꠇꠦ। ꠅꠃ ꠔꠣꠞꠣ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠌꠣꠁꠟꠣ, ꠎꠣꠔꠦ ꠍꠟꠤꠛꠅ ꠎꠦꠞꠣ ꠀꠍꠦ, ꠔꠣꠞꠣ ꠎꠟꠖꠤ ꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠙꠣꠅ ꠜꠣꠋꠉꠤꠀ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠣꠘꠤ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JN19_32","073_19_32","JHN","19","32","32","ꠔꠦꠃ ꠁꠍꠣꠞ ꠟꠉꠦ ꠎꠦꠞꠣꠞꠦ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠄꠞꠣ ꠖꠥꠁꠅꠎꠘꠞ ꠙꠣꠅ ꠜꠣꠋꠉꠤ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JN19_33","073_19_33","JHN","19","33","33","ꠔꠣꠞꠣ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠖꠦꠈꠟ, ꠔꠣꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠙꠣꠅ ꠜꠣꠋꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_34","073_19_34","JHN","19","34","34","ꠅꠁꠟꠦ ꠄꠇ ꠍꠤꠙꠣꠁꠄ ꠍꠥꠟꠚꠤ ꠖꠤꠀ ꠔꠣꠘ ꠙꠣꠔ꠆ꠔꠤ-ꠀꠠꠞ ꠝꠣꠎꠦꠖꠤ ꠚꠣꠠ ꠝꠣꠞꠟ, ꠚꠣꠠꠞ ꠟꠉꠦ ꠟꠃ ꠀꠞ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN19_35","073_19_35","JHN","19","35","35","ꠎꠦ ꠎꠘꠦ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠁ ꠊꠐꠘꠣ ꠖꠦꠈꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ ꠀꠞ ꠔꠣꠘ ꠡꠣꠇ꠆ꠇꠤ ꠢꠣꠍꠣ। ꠔꠣꠁꠘ ꠎꠣꠘꠂꠘ, ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠇꠁꠞꠣ ꠁꠔꠣ ꠢꠣꠍꠣ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠄꠇꠤꠘ ꠇꠞ। ");
INSERT INTO syls_vpl VALUES ("JN19_36","073_19_36","JHN","19","36","36","ꠁꠔꠣ ꠅꠁꠍꠤꠟ ꠎꠣꠔꠦ ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠅꠃ ꠇꠕꠣ ꠙꠥꠞꠣ ꠅꠄ, ꠇꠤꠔꠣꠛꠅ ꠀꠍꠦ, ‘ꠔꠣꠘ ꠄꠇꠐꠣ ꠀꠒ꠆ꠒꠤꠅ ꠜꠣꠋꠉꠣ ꠅꠁꠔ ꠘꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("JN19_37","073_19_37","JHN","19","37","37","ꠄꠅꠈꠣꠘ ꠀꠍꠦ, ‘ꠎꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠉꠣꠕꠤꠍꠦ, ꠔꠣꠞꠣ ꠔꠣꠘ ꠛꠣꠄ ꠌꠣꠁ ꠞꠁꠛ।’ ");
INSERT INTO syls_vpl VALUES ("JN19_38","073_19_38","JHN","19","38","38","ꠁꠔꠣ ꠊꠐꠘꠣꠞ ꠛꠣꠖꠦ ꠀꠞꠤꠝꠣꠕꠤꠀ ꠉꠣꠃꠞ ꠁꠃꠍꠥꠚꠦ ꠁꠍꠣꠞ ꠟꠣꠡ ꠘꠤꠔꠣ ꠇꠞꠤ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠅꠘꠥꠝꠔꠤ ꠌꠣꠁꠟꠣ। ꠁꠃꠍꠥꠚ ꠀꠍꠟꠣ ꠁꠍꠣꠞ ꠄꠇꠎꠘ ꠟꠥꠇꠣꠁꠟ ꠃꠝ꠆ꠝꠔ, ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞꠦ ꠒꠞꠣꠁꠔꠣ। ꠙꠤꠟꠣꠔꠞ ꠅꠘꠥꠝꠔꠤ ꠙꠣꠁꠀ ꠔꠣꠁꠘ ꠁꠍꠣꠞ ꠟꠣꠡ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_39","073_19_39","JHN","19","39","39","ꠀꠉꠦ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠎꠦꠁꠘ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠍꠟꠣ, ꠢꠃ ꠘꠤꠇꠖꠤꠝꠦꠅ ꠝꠥꠞꠣ-ꠀꠔꠞ ꠀꠞ ꠅꠉꠥꠞꠥ ꠝꠤꠡꠣꠁꠀ ꠅꠘꠥꠝꠣꠘ ꠄꠇ ꠝꠘ ꠈꠥꠡꠛꠄ ꠝꠡꠟꠣ ꠟꠁꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_40","073_19_40","JHN","19","40","40","ꠀꠞ ꠁꠍꠣꠞ ꠟꠣꠡ ꠘꠤꠀ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠅꠃ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠝꠡꠟꠣ ꠝꠣꠈꠣꠁꠀ ꠇꠣꠚꠘ ꠚꠤꠘ꠆ꠖꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_41","073_19_41","JHN","19","41","41","ꠁꠍꠣꠞꠦ ꠎꠦꠈꠣꠘꠅ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠣ ꠅꠁꠍꠤꠟ, ꠢꠘꠅ ꠄꠇ ꠛꠣꠉꠣꠘꠞ ꠜꠤꠔꠞꠦ ꠙꠣꠠꠞ ꠉꠥꠢꠣꠞ ꠝꠣꠎꠦ ꠘꠄꠀ ꠄꠇꠐꠣ ꠇꠄꠛꠞ ꠈꠥꠖꠤꠀ ꠞꠣꠈꠣ ꠀꠍꠤꠟ। ꠁ ꠇꠄꠛꠞꠅ ꠇꠦꠃꠞꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN19_42","073_19_42","JHN","19","42","42","ꠅꠃ ꠖꠤꠘ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠁꠖꠞ ꠀꠉꠞ ꠖꠤꠘ ꠅꠀꠄ ꠀꠞ ꠇꠄꠛꠞꠐꠣꠅ ꠇꠣꠘ꠆ꠖꠣꠔ ꠕꠣꠇꠣꠄ, ꠔꠣꠞꠣ ꠔꠣꠠꠣ-ꠃꠠꠣ ꠇꠞꠤ ꠁꠍꠣꠞꠦ ꠅꠘꠅꠃ ꠖꠣꠚꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_1","073_20_1","JHN","20","1","1","ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠚꠎꠞ ꠅꠇ꠆ꠔꠅ ꠀꠘ꠆ꠖꠣꠁꠞ ꠞꠁꠔꠦꠃ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠇꠄꠛꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠖꠦꠈꠟꠣ, ꠇꠄꠛꠞꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠙꠣꠔ꠆ꠔꠞꠐꠣ ꠢꠞꠣꠁꠟ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN20_2","073_20_2","JHN","20","2","2","ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞ ꠀꠞ ꠎꠦ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠁꠍꠣꠄ ꠈꠥꠛ ꠝꠣꠄꠀ ꠇꠞꠔꠣ, ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠍꠂꠘ ꠘꠤ, ꠢꠥꠎꠥꠞꠞ ꠟꠣꠡ ꠝꠣꠘꠡꠦ ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠔꠥꠟꠤꠀ ꠘꠤꠍꠂꠘꠉꠤ। ꠘꠤꠀ ꠇꠁ ꠞꠣꠈꠍꠂꠘ ꠀꠝꠞꠣ ꠎꠣꠘꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN20_3","073_20_3","JHN","20","3","3","ꠈꠛꠞ ꠙꠣꠁꠀ ꠙꠤꠔꠞ ꠀꠞ ꠅꠃ ꠍꠣꠢꠣꠛꠤ ꠇꠄꠛꠞꠞ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_4","073_20_4","JHN","20","4","4","ꠖꠥꠁꠅꠎꠘꠦ ꠄꠇꠟꠉꠦ ꠖꠃꠠꠣꠁꠞꠣ। ꠙꠤꠔꠞꠞꠦ ꠈꠞꠦ ꠚꠣꠟꠣꠁꠀ ꠢꠃ ꠍꠣꠢꠣꠛꠤ ꠀꠉꠦ ꠇꠄꠛꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_5","073_20_5","JHN","20","5","5","ꠉꠤꠀ ꠃꠘ꠆ꠖꠣ ꠅꠁꠀ ꠖꠦꠈꠟꠣ, ꠇꠄꠛꠞꠞ ꠜꠤꠔꠞꠦ ꠇꠣꠚꠘ ꠙꠠꠤ ꠞꠁꠍꠦ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠄꠛꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_6","073_20_6","JHN","20","6","6","ꠙꠤꠔꠞꠅ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠟꠣ, ꠀꠁꠀ ꠇꠄꠛꠞꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠈꠣꠟꠤ ꠇꠣꠚꠘꠈꠣꠘ ꠙꠠꠤ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN20_7","073_20_7","JHN","20","7","7","ꠎꠦ ꠇꠣꠚꠘꠞ ꠐꠥꠇꠞꠣ ꠖꠤꠀ ꠔꠣꠘ ꠝꠣꠕꠣ ꠛꠣꠘ꠆ꠖꠣ ꠅꠁꠍꠤꠟ, ꠁꠈꠣꠘ ꠅꠁꠘ꠆ꠘ ꠐꠥꠇꠞꠣꠞ ꠟꠉꠦ ꠘꠣꠄ, ꠀꠟꠉꠣ ꠙꠠꠤ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JN20_8","073_20_8","JHN","20","8","8","ꠎꠦ ꠍꠣꠢꠣꠛꠤ ꠙꠄꠟꠣ ꠇꠄꠛꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠍꠟꠣ, ꠛꠣꠖꠦ ꠔꠣꠁꠘꠅ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ, ꠢꠣꠝꠣꠁꠀ ꠢꠇꠟꠔꠣ ꠖꠦꠈꠤꠀ ꠄꠇꠤꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_9","073_20_9","JHN","20","9","9","ꠁꠍꠣꠞ ꠔ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀ ꠎꠞꠥꠞ, ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠅꠃ ꠔꠣꠟꠤꠝꠞ ꠝꠣꠘꠤ ꠀꠉꠦ ꠔ ꠄꠞꠣ ꠇꠦꠃ ꠛꠥꠎꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_10","073_20_10","JHN","20","10","10","ꠄꠞꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠎꠣꠞꠎꠤꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("JN20_11","073_20_11","JHN","20","11","11","ꠅꠁꠟꠦ ꠝꠞꠤꠅꠝꠦ ꠇꠄꠛꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠃꠛꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠘ ꠟꠣꠉꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ ꠃꠘ꠆ꠖꠣ ꠅꠁꠀ ꠇꠄꠛꠞꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("JN20_12","073_20_12","JHN","20","12","12","ꠁꠍꠣꠞ ꠟꠣꠡ ꠎꠦꠘꠅ ꠢꠥꠔꠣꠁꠀ ꠞꠣꠈꠣ ꠅꠁꠍꠤꠟ, ꠢꠘꠅ ꠗꠟꠣ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠘ ꠖꠥꠁꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠁ ꠞꠁꠍꠂꠘ, ꠄꠇꠎꠘ ꠢꠤꠔꠣꠘꠦꠖꠤ, ꠀꠞꠇ ꠎꠘ ꠙꠣꠅ ꠉꠣꠟꠣꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JN20_13","073_20_13","JHN","20","13","13","ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠝꠞꠤꠅꠝꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠣꠘ꠆ꠖꠤꠞꠣꠄ ꠇꠦꠘꠦ ꠉ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠟꠣꠡ ꠔꠥꠟꠤꠀ ꠘꠤꠍꠂꠘꠉꠤ, ꠘꠤꠀ ꠇꠁ ꠕꠁꠍꠂꠘ ꠎꠣꠘꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN20_14","073_20_14","JHN","20","14","14","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠈꠞꠦꠖꠤ ꠌꠣꠁꠔꠦꠃ ꠖꠦꠈꠟꠣ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠅꠁꠟꠦ ꠔꠣꠁꠘꠃ ꠎꠦ ꠁꠍꠣ, ꠝꠞꠤꠅꠝꠦ ꠁꠈꠣꠘ ꠛꠥꠎꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_15","073_20_15","JHN","20","15","15","ꠁꠍꠣꠄ ꠝꠞꠤꠅꠝꠞꠦ ꠇꠁꠟꠣ, “ꠅꠉ, ꠔꠥꠝꠤ ꠇꠣꠘ꠆ꠖꠅ ꠇꠦꠘꠦ? ꠇꠣꠞꠦ ꠔꠥꠇꠣꠁꠞꠣꠄ?” ꠁꠍꠣꠞꠦ ꠛꠣꠉꠣꠘꠞ ꠝꠣꠟꠤ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠦ ꠎꠥꠖꠤ ꠔꠣꠘ ꠟꠣꠡ ꠘꠤꠀ ꠕꠣꠇꠂꠘ, ꠔꠦ ꠇꠥꠀꠁ ꠘꠤꠍꠂꠘ, ꠇꠃꠇ꠆ꠇꠣ। ꠀꠝꠤ ꠔꠣꠘ ꠟꠣꠡ ꠘꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JN20_16","073_20_16","JHN","20","16","16","ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠝꠞꠤꠅꠝ।” ꠔꠦꠃ ꠝꠞꠤꠅꠝ ꠚꠤꠞꠤꠀ ꠃꠛꠣꠁꠀ ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠞꠣꠛ꠆ꠛꠥꠘꠤ” ꠝꠣꠘꠤ ꠃꠡ꠆ꠔꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("JN20_17","073_20_17","JHN","20","17","17","ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞꠦ ꠗꠞꠤꠀ ꠞꠣꠈꠤꠅ ꠘꠣ, ꠀꠝꠤ ꠔ ꠅꠈꠘꠅ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠉꠦꠍꠦ ꠃꠙꠞꠦ ꠉꠦꠍꠤ ꠘꠣ। ꠔꠥꠝꠤ ꠛꠞꠋ ꠀꠝꠣꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠉꠤꠀ ꠇꠅ, ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ, ꠀꠝꠣꠞ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠤ ꠃꠙꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦꠃ ꠎꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN20_18","073_20_18","JHN","20","18","18","ꠔꠦꠃ ꠝꠉꠖꠤꠟꠤꠘꠤ ꠝꠞꠤꠅꠝꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, ꠁꠍꠣꠞ ꠟꠉꠦ ꠔꠣꠘ ꠖꠦꠈꠣ ꠅꠁꠍꠦ ꠀꠞ ꠁꠍꠣꠄꠃ ꠔꠣꠘꠞꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JN20_19","073_20_19","JHN","20","19","19","ꠢꠃ ꠖꠤꠘ, ꠝꠣꠘꠤ ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠢꠣꠁꠘ꠆ꠎꠣ ꠛꠣꠟꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠟꠣ। ꠅꠁꠟꠦ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠒꠞꠦ ꠊꠞꠞ ꠖꠥꠀꠞ-ꠈꠤꠠꠇꠤ ꠢꠇꠟꠔꠣ ꠛꠘ꠆ꠖ ꠀꠍꠤꠟ। ꠄꠞꠝꠣꠎꠦ ꠀꠈꠔꠣꠃ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠁꠀ ꠄꠞꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN20_20","073_20_20","JHN","20","20","20","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠖꠥꠁꠅ ꠀꠔ ꠀꠞ ꠙꠣꠔ꠆ꠔꠤ-ꠀꠠꠞ ꠎꠈꠝꠞ ꠖꠣꠉ ꠄꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠟꠣ। ꠢꠥꠎꠥꠞꠞꠦ ꠖꠦꠈꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_21","073_20_21","JHN","20","21","21","ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ। ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠎꠦꠟꠣ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠀꠝꠤꠅ ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN20_22","073_20_22","JHN","20","22","22","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠚꠥ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN20_23","073_20_23","JHN","20","23","23","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠦꠃꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠦꠅ, ꠔꠦ ꠔꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠛ, ꠀꠞ ꠎꠥꠖꠤ ꠝꠣꠚ ꠘꠣ ꠇꠞ, ꠔꠦ ꠔꠣꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠝꠤꠟꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN20_24","073_20_24","JHN","20","24","24","ꠢꠎꠞꠔ ꠁꠍꠣ ꠎꠦꠛꠟꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠝꠣꠎꠞ ꠕꠥꠝꠣꠍ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠁꠘꠅ ꠀꠍꠟꠣ ꠘꠣ। ꠅꠃ ꠕꠥꠝꠣꠍꠞꠦ ꠎꠝꠎ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("JN20_25","073_20_25","JHN","20","25","25","ꠄꠞꠟꠣꠉꠤ ꠛꠣꠇꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠕꠥꠝꠣꠍꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠢꠥꠎꠥꠞꠞꠦ ꠖꠦꠈꠍꠤ।” ꠕꠥꠝꠣꠍꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠎꠥꠖꠤ ꠔꠣꠘ ꠖꠥꠁꠅ ꠀꠔꠞ ꠙꠦꠞꠦꠉꠞ ꠖꠣꠉ ꠘꠣ ꠖꠦꠈꠤ, ꠅꠃ ꠎꠈꠝꠅ ꠀꠋꠉꠥꠟ ꠘꠣ ꠟꠣꠉꠣꠁ, ꠀꠞ ꠔꠣꠘ ꠙꠣꠔ꠆ꠔꠤ-ꠀꠠꠞ ꠎꠈꠝꠅ ꠀꠔ ꠘꠣ ꠖꠦꠁ, ꠔꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠝꠤ ꠁꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("JN20_26","073_20_26","JHN","20","26","26","ꠄꠞ ꠄꠇ ꠢꠣꠙ꠆ꠔꠣ ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠅꠃ ꠊꠞꠅ ꠖꠟꠣ ꠅꠁꠟꠣ, ꠄꠞꠣꠞ ꠟꠉꠦ ꠕꠥꠝꠣꠍꠅ ꠀꠍꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠊꠞꠞ ꠢꠇꠟ ꠖꠥꠀꠞ-ꠈꠤꠠꠇꠤ ꠛꠘ꠆ꠖ ꠕꠣꠇꠟꠦꠅ ꠀꠈꠔꠣꠃ ꠁꠍꠣ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ।” ");
INSERT INTO syls_vpl VALUES ("JN20_27","073_20_27","JHN","20","27","27","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠕꠥꠝꠣꠍꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠀꠋꠉꠥꠟ ꠟꠣꠉꠣꠁꠀ ꠀꠝꠣꠞ ꠖꠥꠁꠅ ꠀꠔ ꠖꠦꠈꠅ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠀꠝꠣꠞ ꠙꠣꠔ꠆ꠔꠤ-ꠀꠠꠞ ꠎꠈꠝꠅ ꠢꠣꠞꠣꠅ, ꠄꠇꠤꠘ ꠇꠞꠅ, ꠡꠘ꠆ꠖꠄ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN20_28","073_20_28","JHN","20","28","28","ꠔꠦꠃ ꠕꠥꠝꠣꠍꠦ ꠇꠁꠟꠣ, “ꠝꠣꠟꠤꠇ ꠀꠝꠣꠞ, ꠀꠟ꠆ꠟꠣ ꠀꠝꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("JN20_29","073_20_29","JHN","20","29","29","ꠁꠍꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠕꠥꠝꠣꠍ, ꠀꠝꠣꠞꠦ ꠖꠦꠈꠍ ꠇꠞꠤ ꠔꠥꠝꠤ ꠁꠝꠣꠘ ꠀꠘꠟꠣꠄ ꠘꠤ? ꠢꠥꠘꠅ, ꠗꠁꠘ꠆ꠘ ꠔꠣꠞꠣ, ꠎꠦꠞꠣ ꠘꠣ ꠖꠦꠈꠤꠀꠅ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("JN20_30","073_20_30","JHN","20","30","30","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠀꠞꠅ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔ ꠅꠃ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN20_31","073_20_31","JHN","20","31","31","ꠈꠣꠟꠤ ꠅꠃ ꠊꠐꠘꠣ ꠅꠇꠟ ꠟꠦꠈꠣ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠅꠔꠣ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘ ꠀꠘ, ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ, ꠔꠣꠁꠘꠃ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠀꠞ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠎꠣꠔꠦ ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠢꠣꠍꠤꠟ ꠇꠞ। ");
INSERT INTO syls_vpl VALUES ("JN21_1","073_21_1","JHN","21","1","1","ꠄꠞꠛꠣꠖꠦ ꠔꠤꠛꠤꠞꠤꠀ ꠘꠣꠝꠞ ꠀꠅꠞꠞ ꠙꠣꠞꠅ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠣ ꠖꠤꠟꠣ। ꠊꠐꠘꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JN21_2","073_21_2","JHN","21","2","2","ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞ, ꠕꠥꠝꠣꠍ ꠎꠣꠞꠦ ꠎꠝꠎ ꠇꠅꠀ ꠅꠁꠔ, ꠀꠞ ꠉꠣꠟꠤꠟ ꠎꠤꠟꠣꠞ ꠇꠣꠘ꠆ꠘꠣ ꠉꠣꠃꠞ ꠘꠕꠘꠦꠟ, ꠎꠤꠛꠥꠖꠤꠀꠞ ꠙꠥꠀꠂꠘ ꠡꠢ ꠀꠞꠅ ꠖꠥꠁꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠄꠇꠟꠉꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_3","073_21_3","JHN","21","3","3","ꠍꠣꠢꠣꠛꠤ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠟꠉꠞ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠝꠣꠍ ꠝꠣꠞꠣꠔ ꠎꠣꠁꠀꠞꠉꠤ।” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠅ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠎꠣꠁꠝꠥ।” ꠔꠦꠃ ꠔꠣꠞꠣ ꠘꠣꠅ ꠟꠁꠀ ꠝꠣꠍ ꠝꠣꠞꠣꠔ ꠛꠣꠞ ꠅꠁꠟꠣ, ꠅꠁꠟꠦ ꠁ ꠞꠣꠁꠔ ꠇꠥꠘꠥ ꠝꠣꠍ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_4","073_21_4","JHN","21","4","4","ꠚꠎꠞ ꠅꠇ꠆ꠔꠅ ꠁꠍꠣ ꠀꠁꠀ ꠀꠅꠞꠞ ꠙꠣꠞꠅ ꠃꠛꠣꠁꠟꠣ। ꠅꠁꠟꠦ ꠔꠣꠁꠘꠃ ꠎꠦ ꠁꠍꠣ, ꠄꠞꠣ ꠁꠈꠣꠘ ꠛꠥꠎꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_5","073_21_5","JHN","21","5","5","ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠦꠐꠣꠁꠘ, ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠍ ꠙꠣꠁꠍ ꠘꠣ ꠘꠤ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠎꠤ ꠘꠣ, ꠙꠣꠁꠍꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("JN21_6","073_21_6","JHN","21","6","6","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠘꠣꠅꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠛꠣꠄ ꠎꠣꠟ ꠚꠣꠟꠣꠅ, ꠔꠦꠃ ꠙꠣꠁꠛꠣꠄꠘꠦ।” ꠔꠣꠘ ꠇꠕꠣꠝꠔ ꠔꠣꠞꠣ ꠎꠣꠟ ꠚꠣꠟꠣꠁꠟꠣ ꠀꠞ ꠎꠣꠟꠅ ꠅꠔ ꠝꠣꠍ ꠢꠣꠝꠣꠁꠟꠣ, ꠁꠈꠣꠘ ꠐꠣꠘꠤꠀ ꠔꠥꠟꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_7","073_21_7","JHN","21","7","7","ꠎꠦ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠁꠍꠣꠄ ꠝꠣꠄꠀ ꠇꠞꠔꠣ, ꠔꠣꠁꠘ ꠙꠤꠔꠞꠞꠦ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠔ ꠝꠣꠟꠤꠇ।” ꠁ ꠡꠝꠄ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠞ ꠉꠔꠞꠅ ꠇꠣꠙꠠ ꠀꠍꠤꠟ ꠘꠣ। “ꠄꠁꠘ ꠔ ꠝꠣꠟꠤꠇ” ꠅꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠔꠣꠁꠘ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠚꠣꠟꠖꠤ ꠙꠣꠘꠤꠔ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_8","073_21_8","JHN","21","8","8","ꠅꠁꠟꠦ ꠛꠣꠇꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠝꠣꠍꠦ ꠜꠞꠣ ꠎꠣꠟꠈꠣꠘ ꠐꠣꠘꠤ ꠐꠣꠘꠤ ꠘꠣꠅ ꠟꠁꠀ ꠙꠣꠞꠅ ꠀꠎꠤꠟꠣ। ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠙꠣꠞ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠖꠥꠞꠁ ꠘꠣꠄ, ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁ-ꠡ ꠀꠔ ꠖꠥꠞꠁ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_9","073_21_9","JHN","21","9","9","ꠔꠣꠞꠣ ꠙꠣꠞꠅ ꠃꠑꠤꠀ ꠖꠦꠈꠟꠣ ꠀꠋꠞꠣꠞ ꠀꠉꠥꠁꠘ, ꠅꠃ ꠀꠉꠥꠁꠘꠞ ꠃꠙꠞꠦ ꠝꠣꠍ ꠀꠞ ꠞꠥꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("JN21_10","073_21_10","JHN","21","10","10","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠎꠦꠔꠣ ꠝꠣꠍ ꠝꠣꠞꠍ, ꠅꠘ ꠕꠘꠦ ꠇꠄꠐꠣ ꠀꠘꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN21_11","073_21_11","JHN","21","11","11","ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠘꠣꠅ ꠕꠣꠇꠤ ꠎꠣꠟꠈꠣꠘ ꠙꠣꠞꠅ ꠐꠣꠘꠤꠀ ꠔꠥꠟꠟꠣ। ꠎꠣꠟꠞ ꠜꠤꠔꠞꠦ ꠄꠇ-ꠡ ꠔꠦꠙ꠆ꠙꠣꠘ꠆ꠘꠐꠣ ꠛꠠ ꠝꠣꠍ ꠀꠍꠤꠟ, ꠔꠦꠛꠃ ꠎꠣꠟ ꠚꠣꠠꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_12","073_21_12","JHN","21","12","12","ꠁꠍꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠈꠣꠅ ꠀꠁꠀ।” ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠍꠣꠢꠣꠛꠤꠄ ꠎꠤꠇꠣꠘꠤꠞ ꠡꠣꠅꠡ ꠅꠁꠟ ꠘꠣ “ꠀꠙꠘꠦ ꠇꠦ?” ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠎꠣꠘꠔꠣ, ꠔꠣꠁꠘꠃ ꠝꠣꠟꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("JN21_13","073_21_13","JHN","21","13","13","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠞꠥꠐꠤ ꠈꠣꠁꠔꠦ ꠖꠤꠟꠣ, ꠅꠃꠟꠣ ꠛꠤꠞꠣꠘ ꠝꠣꠍꠅ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_14","073_21_14","JHN","21","14","14","ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠛꠣꠖꠦ, ꠅꠃ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠛꠣꠞ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_15","073_21_15","JHN","21","15","15","ꠔꠣꠞꠣꠞ ꠈꠣꠅꠀ-ꠖꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠁꠍꠣꠄ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅ ꠍꠣꠁꠝꠘ ꠛꠤꠘ ꠁꠃꠢꠣꠘ꠆ꠘꠣ, ꠄꠞꠣ ꠎꠦꠟꠣ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠂꠘ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠄꠞ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠅ ꠘꠤ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ ꠝꠣꠟꠤꠇ, ꠀꠙꠘꠦ ꠔ ꠎꠣꠘꠂꠘ, ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠇꠔ ꠝꠣꠄꠀ ꠇꠞꠤ।” ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠣꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠞꠣꠈꠣꠟꠤ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN21_16","073_21_16","JHN","21","16","16","ꠁꠍꠣꠄ ꠢꠤꠞꠛꠣꠞ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠍꠣꠁꠝꠘ ꠛꠤꠘ ꠁꠃꠢꠣꠘ꠆ꠘꠣ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞ ꠘꠤ?” ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ ꠝꠣꠟꠤꠇ, ꠀꠙꠘꠦ ꠔ ꠎꠣꠘꠂꠘ, ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠇꠔ ꠝꠣꠄꠀ ꠇꠞꠤ।” ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠣꠞ ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN21_17","073_21_17","JHN","21","17","17","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠔꠤꠍꠞꠣ ꠛꠣꠞ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅ ꠍꠣꠁꠝꠘ ꠛꠤꠘ ꠁꠃꠢꠣꠘ꠆ꠘꠣ, ꠢꠣꠍꠣꠃ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ ꠘꠤ?” ꠁꠍꠣꠄ ꠔꠤꠍꠞꠣ ꠛꠣꠞ ꠎꠤꠇꠣꠘꠤꠄ ꠙꠤꠔꠞ ꠝꠘꠦ ꠝꠘꠦ ꠇꠤꠍꠥ ꠖꠥꠈꠤꠔ ꠅꠁꠀ ꠇꠁꠟꠣ, “ꠝꠣꠟꠤꠇ, ꠀꠙꠘꠦ ꠔ ꠢꠇꠟꠔꠣꠃ ꠎꠣꠘꠂꠘ, ꠀꠙꠘꠦ ꠎꠣꠘꠂꠘꠃ ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠈꠥꠛ ꠝꠣꠄꠀꠞ ꠎꠘ।” ꠔꠦꠃ ꠁꠍꠣꠄ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠣꠞ ꠝꠦꠠꠣ ꠙꠣꠟꠞ ꠞꠣꠈꠣꠟꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JN21_18","073_21_18","JHN","21","18","18","ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠢꠣꠍꠣꠃ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠣꠞ ꠎꠥꠀꠘꠇꠤꠞ ꠡꠝꠄ ꠔꠥꠝꠤ ꠘꠤꠎꠦꠃ ꠔꠥꠝꠣꠞ ꠇꠝꠞ ꠛꠣꠘ꠆ꠖꠤꠀ ꠎꠦꠘꠅ ꠈꠥꠡꠤ ꠅꠘꠅ ꠎꠣꠁꠔꠣꠄ। ꠅꠁꠟꠦ ꠛꠥꠠꠣꠇꠤꠞ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠀꠔ ꠛꠣꠠꠣꠁ ꠖꠤꠛꠣꠄ, ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠎꠘꠦ ꠔꠥꠝꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ, ꠔꠥꠝꠤ ꠎꠦꠘꠅ ꠎꠣꠁꠔꠣꠄ ꠌꠣꠅ ꠘꠣ, ꠢꠘꠅ ꠟꠁꠀ ꠎꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("JN21_19","073_21_19","JHN","21","19","19","ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ ꠎꠣꠁꠞ ꠅꠀꠞ ꠟꠣꠉꠤ ꠙꠤꠔꠞꠞ ꠝꠃꠔ ꠇꠤꠟꠣꠘ ꠅꠁꠛ, ꠅꠈꠣꠘ ꠛꠥꠎꠣꠘꠤꠔ ꠉꠤꠀ ꠁꠍꠣꠄ ꠅꠃ ꠇꠕꠣ ꠇꠁꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠙꠤꠔꠞꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN21_20","073_21_20","JHN","21","20","20","ꠅꠃ ꠡꠝꠄ ꠙꠤꠔꠞꠦ ꠈꠞꠦꠖꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠁꠍꠣꠞ ꠢꠃ ꠝꠣꠄꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠞꠣ। ꠅꠃ ꠍꠣꠢꠣꠛꠤꠄ ꠇꠄꠖꠤꠘ ꠀꠉꠦ ꠈꠣꠘꠤꠔ ꠛꠁꠀ ꠁꠍꠣꠞ ꠛꠣꠄ ꠎꠥꠇꠤꠀ ꠇꠁꠍꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠣꠞꠦ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠎꠦ ꠗꠞꠣꠁ ꠖꠤꠛ, ꠢꠦ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("JN21_21","073_21_21","JHN","21","21","21","ꠙꠤꠔꠞꠦ ꠄꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠁꠍꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠄꠘ ꠇꠤꠔꠣ ꠅꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("JN21_22","073_21_22","JHN","21","22","22","ꠁꠍꠣꠄ ꠙꠤꠔꠞꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠥꠖꠤ ꠌꠣꠁ, ꠀꠝꠤ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠖꠥꠘꠤꠀꠔ ꠘꠣ ꠀꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠅꠘꠅ ꠞꠃꠇ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠇꠤꠔꠣ? ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠅ।” ");
INSERT INTO syls_vpl VALUES ("JN21_23","073_21_23","JHN","21","23","23","ꠄꠞꠟꠣꠉꠤ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠈꠛꠞ ꠞꠐꠤ ꠉꠦꠟ, ꠅꠃ ꠍꠣꠢꠣꠛꠤ ꠝꠞꠔꠣ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠁꠍꠣꠄ ꠙꠤꠔꠞꠞꠦ ꠁꠈꠣꠘ ꠇꠁꠍꠂꠘ ꠘꠣ। ꠛꠞꠋ ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, “ꠀꠝꠤ ꠎꠥꠖꠤ ꠌꠣꠁ, ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠘꠣ ꠀꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠅꠘꠅ ꠕꠣꠇꠃꠇ, ꠔꠦ ꠔꠥꠝꠣꠞ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("JN21_24","073_21_24","JHN","21","24","24","ꠅꠃ ꠍꠣꠢꠣꠛꠤꠄ ꠁꠔꠣ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ ꠀꠞ ꠟꠦꠈꠍꠂꠘ। ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠔꠣꠘ ꠡꠣꠇ꠆ꠇꠤ ꠢꠣꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("JN21_25","073_21_25","JHN","21","25","25","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠀꠞꠅ ꠛꠃꠔ ꠇꠣꠝ ꠇꠞꠍꠂꠘ। ꠁꠔꠣ ꠎꠥꠖꠤ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠟꠦꠈꠣ ꠅꠁꠔ, ꠔꠦ ꠅꠔ ꠇꠤꠔꠣꠛ ꠅꠁꠔ, ꠁꠔꠣ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠄ ꠗꠞꠟ ꠘꠣ ꠅꠘꠦ॥");
INSERT INTO syls_vpl VALUES ("AC1_1","074_1_1","ACT","1","1","1","ꠝꠢꠣꠝꠣꠁꠘ꠆ꠘ ꠕꠤꠅꠚꠤꠟꠣꠍ, ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠂꠘ ꠀꠞ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠞꠍꠂꠘ ꠁ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠤ ꠀꠉꠞ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC1_2","074_1_2","ACT","1","2","2","ꠎꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠔꠣꠁꠘ ꠛꠣꠍꠤꠀ ꠟꠁꠍꠟꠣ, ꠔꠣꠘꠞꠦ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀꠞ ꠀꠉꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠀ ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠅꠍꠤꠅꠔ ꠇꠞꠣꠁ ꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC1_3","074_1_3","ACT","1","3","3","ꠔꠣꠘ ꠔꠇꠟꠤꠚ ꠇꠣꠁꠝꠞ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠦꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ ꠁꠐꠣꠞ ꠛꠃꠔ ꠇꠤꠍꠤꠝꠞ ꠀꠟꠣꠝꠔ ꠖꠦꠈꠣꠁꠍꠂꠘ। ꠌꠣꠟ꠆ꠟꠤꠡ ꠖꠤꠘ ꠗꠞꠤ ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠛꠤꠡꠄꠄ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC1_4","074_1_4","ACT","1","4","4","ꠁꠍꠣꠄ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠞ ꠟꠉꠦ ꠄꠇꠈꠣꠘꠅ ꠡꠞꠤꠇ ꠅꠁꠀ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠎꠣꠁꠅ ꠘꠣ, ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠎꠦ ꠖꠣꠘꠞ ꠇꠕꠣ ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠢꠥꠘꠍ, ꠄꠞꠟꠣꠉꠤ ꠅꠘꠅ ꠛꠣꠞ ꠌꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("AC1_5","074_1_5","ACT","1","5","5","ꠢꠎꠞꠔ ꠄꠢꠤꠀꠄ ꠔ ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠔꠣ, ꠅꠁꠟꠦ ꠛꠦꠡ ꠖꠦꠞꠤ ꠅꠁꠔ ꠘꠣꠄ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠀ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC1_6","074_1_6","ACT","1","6","6","ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠀ ꠁꠍꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠢꠥꠎꠥꠞ, ꠁ ꠡꠝꠄ ꠇꠤꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞ ꠀꠔꠅ ꠞꠣꠁꠎ꠆ꠎ ꠚꠤꠞꠔ ꠀꠘꠛꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC1_7","074_1_7","ACT","1","7","7","ꠁꠍꠣꠄ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠎꠦ ꠅꠇ꠆ꠔ ꠛꠣ ꠎꠝꠣꠘꠣ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠄꠈꠔꠤꠀꠞꠅ ꠞꠣꠈꠍꠂꠘ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠣꠞ ꠉꠞꠎ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("AC1_8","074_1_8","ACT","1","8","8","ꠅꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠇꠣꠁꠝ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠉꠣꠁꠛꠤ ꠛꠟ ꠙꠣꠁꠛꠣꠄ, ꠅꠃ ꠛꠟꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ, ꠀꠡ꠆ꠔꠣ ꠄꠢꠥꠖꠤꠀ ꠀꠞ ꠡꠝꠞꠤꠀ ꠄꠟꠣꠇꠣ, ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠢꠦꠡ ꠡꠤꠝꠣꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠅꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC1_9","074_1_9","ACT","1","9","9","ꠅꠃ ꠝꠣꠔꠞ ꠛꠣꠖꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ ꠁꠍꠣꠞꠦ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠟ, ꠀꠞ ꠔꠣꠁꠘ ꠝꠦꠊꠞ ꠐꠥꠇꠞꠣꠞ ꠀꠅꠠ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC1_10","074_1_10","ACT","1","10","10","ꠁꠍꠣ ꠎꠦꠛꠟꠣ ꠀꠍꠝꠣꠘꠅ ꠃꠑꠤꠞꠣ ꠁ ꠡꠝꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠌꠃꠈ ꠘꠣ ꠚꠤꠞꠣꠁꠀ ꠀꠍꠝꠣꠘꠞ ꠛꠣꠄ ꠌꠣꠁꠞꠂꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠗꠟꠣ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠣ ꠖꠥꠁꠎꠘ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡ ꠔꠣꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠃꠛꠣꠁꠀ ");
INSERT INTO syls_vpl VALUES ("AC1_11","074_1_11","ACT","1","11","11","ꠇꠁꠟꠣ, “ꠅ ꠉꠣꠟꠤꠟꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟ, ꠁꠈꠣꠘꠅ ꠃꠛꠣꠁꠀ ꠀꠍꠝꠣꠘꠞ ꠛꠣꠄ ꠌꠣꠁꠞꠤꠍ ꠇꠦꠘꠦ? ꠎꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠟ, ꠅꠃ ꠁꠍꠣꠞꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠎꠣꠁꠔꠦ ꠖꠦꠈꠟꠣꠄ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠁꠘ ꠚꠤꠞꠤꠀꠅ ꠀꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC1_12","074_1_12","ACT","1","12","12","ꠅꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠎꠄꠔꠥꠘ ꠘꠣꠝꠞ ꠙꠣꠠꠅ ꠕꠣꠇꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠚꠤꠞꠤꠀ ꠀꠁꠟꠣ। ꠁ ꠙꠣꠠ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ ꠕꠘꠦ ꠕꠥꠠꠣ ꠖꠥꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("AC1_13","074_1_13","ACT","1","13","13","ꠐꠣꠃꠘꠅ ꠚꠤꠞꠤꠀ ꠔꠣꠞꠣ ꠎꠦ ꠊꠞꠞ ꠃꠙꠞꠞ ꠔꠣꠟꠣꠔ ꠞꠁꠔꠣ ꠢꠃ ꠊꠞꠅ ꠉꠦꠟꠣ। ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠙꠤꠔꠞ, ꠢꠣꠘ꠆ꠘꠣꠘ, ꠁꠀꠇꠥꠛ, ꠀꠘ꠆ꠖꠞꠤꠀꠍ, ꠚꠤꠟꠤꠚ, ꠕꠥꠝꠣꠍ, ꠛꠞ꠆ꠕꠟꠝꠄ ꠀꠞ ꠝꠕꠤ, ꠀꠟꠚꠤꠞ ꠙꠥꠀ ꠁꠀꠇꠥꠛ, ꠝꠥꠇ꠆ꠔꠤꠎꠥꠖ꠆ꠖꠣ ꠍꠣꠁꠝꠘ, ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠙꠥꠀ ꠁꠢꠥꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("AC1_14","074_1_14","ACT","1","14","14","ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠈꠣꠍ ꠖꠤꠟꠦ ꠖꠥꠀ ꠇꠞꠣꠔ ꠞꠁꠟꠣ, ꠄꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ ꠁꠝꠣꠘꠖꠣꠞ ꠛꠦꠐꠤꠘ, ꠁꠍꠣꠞ ꠝꠣ ꠝꠞꠤꠅꠝ ꠀꠞ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("AC1_15","074_1_15","ACT","1","15","15","ꠢꠃ ꠡꠝꠄ ꠄꠇꠖꠤꠘ ꠙꠤꠔꠞꠦ ꠅꠘꠥꠝꠣꠘ ꠄꠇ-ꠡ ꠛꠤꠡꠎꠘ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC1_16","074_1_16","ACT","1","16","16","“ꠜꠣꠁ ꠅꠇꠟ, ꠁꠍꠣꠞꠦ ꠎꠦꠞꠣ ꠗꠞꠣꠔ ꠀꠁꠍꠤꠟ ꠔꠣꠞꠣꠞꠦ ꠙꠕ ꠌꠤꠘꠣꠁꠀ ꠘꠤꠍꠤꠟ ꠁꠢꠥꠖꠣ, ꠔꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠃꠔ ꠀꠉꠦ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠝꠥꠈꠅ ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠟꠣ, ꠙꠣꠇ ꠇꠣꠟꠣꠝꠞ ꠁ ꠇꠕꠣ ꠙꠥꠞꠣ ꠅꠀꠞ ꠖꠞꠇꠣꠞ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC1_17","074_1_17","ACT","1","17","17","ꠢꠦ ꠔ ꠀꠝꠞꠣꠞꠃ ꠄꠇꠎꠘ ꠀꠍꠤꠟ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠔꠞꠤꠇꠣꠞ ꠈꠦꠎꠝꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦꠅ ꠍꠣꠢꠣꠛꠤ ꠢꠤꠡꠣꠛꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠅꠁꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("AC1_18","074_1_18","ACT","1","18","18","ꠅꠃ ꠘꠣꠙꠣꠇꠤ ꠇꠣꠝꠞ ꠐꠦꠇꠣ ꠖꠤꠀ ꠢꠦ ꠄꠇꠎꠞꠣ ꠎꠝꠤ ꠟꠁꠍꠤꠟ, ꠀꠞ ꠅꠃ ꠎꠝꠤꠘꠅ ꠃꠚꠁꠔ ꠅꠁꠀ ꠙꠠꠤꠀ ꠔꠣꠞ ꠙꠦꠐ ꠚꠣꠐꠤꠀ ꠀꠔ-ꠜꠠ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC1_19","074_1_19","ACT","1","19","19","ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠢꠥꠘꠍꠤꠟ, ꠄꠞꠟꠣꠉꠤ ꠢꠇꠟꠦ ꠅꠃ ꠎꠝꠤꠘꠞꠦ ꠒꠣꠇꠂꠘ ꠀꠇꠦꠟꠖꠣꠝꠣ ꠛꠣ ꠟꠃꠞ ꠎꠝꠤꠘ। ꠙꠤꠔꠞꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC1_20","074_1_20","ACT","1","20","20","“ꠅꠃ ꠇꠕꠣ ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠍꠦ: ꠔꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠈꠣꠟꠤ ꠞꠃꠇ, ꠢꠘꠅ ꠞꠅꠀꠞ ꠇꠦꠃ ꠘꠣ ꠕꠣꠇꠃꠇ। ꠔꠣꠞ ꠉꠖꠤ ꠀꠞꠇ ꠎꠘꠦ ꠙꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("AC1_21","074_1_21","ACT","1","21","22","ꠄꠞꠟꠣꠉꠤ ꠄꠢꠤꠀꠄ ꠎꠦꠛꠟꠣ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠔꠣ ꠢꠃ ꠡꠝꠄ ꠕꠣꠇꠤ, ꠁꠍꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠎꠔꠖꠤꠘ ꠁꠍꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠍꠤꠟꠣ, ꠅꠔꠖꠤꠘ ꠎꠦꠞꠣ ꠀꠝꠞꠣꠞ ꠖꠟꠅ ꠀꠍꠤꠟ, ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠘꠦ ꠁꠍꠣ ꠎꠦꠘ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠍꠂꠘ, ꠄꠞ ꠡꠣꠇ꠆ꠇꠤ ꠢꠤꠡꠣꠛꠦ ꠅꠁꠘ꠆ꠘ ꠀꠞꠇ ꠎꠘꠞꠦ ꠀꠝꠞꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠖꠟꠅ ꠢꠣꠞꠣꠘꠤ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC1_23","074_1_23","ACT","1","23","23","ꠔꠦꠃ ꠔꠣꠞꠣ ꠅꠃ ꠖꠥꠁꠎꠘꠞꠦ ꠃꠛꠣ ꠇꠞꠣꠁꠟꠣ, ꠁꠃꠍꠥꠚ ꠛꠣꠞ꠆ꠡꠣꠛ꠆ꠛꠣ, ꠔꠣꠘ ꠀꠞꠇ ꠘꠣꠝ ꠁꠃꠍꠔꠥꠍ; ꠀꠞ ꠝꠣꠔꠤꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("AC1_24","074_1_24","ACT","1","24","25","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠖꠥꠀ ꠇꠞꠟꠣ, “ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠤ ꠢꠇꠟꠞ ꠖꠤꠟꠞ ꠈꠛꠞ ꠎꠣꠘ, ꠁꠢꠥꠖꠣꠄ ꠔ ꠔꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠉꠣꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠈꠦꠎꠝꠔ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠙꠖꠞ ꠇꠣꠝ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍꠦ, ꠁꠢꠥꠖꠣꠞ ꠛꠖꠟꠣ ꠁ ꠖꠥꠁꠎꠘꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠤ ꠇꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠅ ꠀꠝꠞꠣꠞꠦ ꠌꠤꠘꠣꠁꠀ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC1_26","074_1_26","ACT","1","26","26","ꠢꠦꠡꠦ ꠔꠣꠞꠣ ꠖꠥꠁꠎꠘꠞ ꠘꠣꠝꠦ ꠟꠐꠣꠞꠤ ꠝꠣꠞꠟꠦ ꠝꠣꠔꠤꠀꠍꠞ ꠘꠣꠝ ꠃꠑꠟ; ꠔꠦꠃ ꠝꠣꠔꠤꠀꠍ ꠅꠃ ꠄꠉꠣꠞꠅ ꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠟꠉꠦ ꠎꠥꠉ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_1","074_2_1","ACT","2","1","1","ꠙꠘ꠆ꠌꠣꠁꠡꠣ ꠁꠖꠞ ꠖꠤꠘ ꠔꠣꠞꠣ ꠢꠇꠟ ꠄꠇ ꠎꠣꠉꠣꠔ ꠖꠟꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_2","074_2_2","ACT","2","2","2","ꠅꠃ ꠡꠝꠄ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠔꠥꠚꠣꠘꠞ ꠟꠣꠈꠣꠘ ꠄꠇ ꠀꠅꠀꠎ ꠅꠁꠟ, ꠔꠣꠞꠣ ꠎꠦ ꠊꠞꠅ ꠛꠅꠀꠔ ꠀꠍꠟꠣ ꠁ ꠀꠅꠀꠎꠦ ꠀꠡ꠆ꠔꠣ ꠊꠞ ꠜꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC2_3","074_2_3","ACT","2","3","3","ꠔꠣꠞꠣ ꠖꠦꠈꠟꠣ, ꠀꠉꠥꠁꠘꠞ ꠟꠥꠇ꠆ꠇꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠤꠔꠣꠞ ꠐꠥꠇꠞꠣꠁꠘ ꠀꠁꠍꠦ, ꠀꠞ ꠁ ꠟꠥꠇ꠆ꠇꠣꠁꠘ ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠀꠁꠀ ꠛꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC2_4","074_2_4","ACT","2","4","4","ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠟꠣ, ꠀꠞ ꠞꠥꠢꠥꠞ ꠉꠣꠁꠛꠤ ꠛꠟꠦ ꠔꠣꠞꠣ ꠀꠟꠉ ꠀꠟꠉ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠔꠣ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_5","074_2_5","ACT","2","5","5","ꠁ ꠡꠝꠄ ꠖꠥꠘꠤꠀꠞ ꠢꠇ꠆ꠇꠟ ꠖꠦꠡꠞ ꠙꠞꠦꠎꠉꠣꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_6","074_2_6","ACT","2","6","6","ꠁ ꠀꠅꠀꠎꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞꠣ ꠀꠁꠀ ꠜꠤꠠ ꠇꠞꠤꠟ꠆ꠟꠣ ꠀꠞ ꠛꠦꠀꠈꠟ ꠅꠁꠉꠦꠟꠣ, ꠇꠣꠞꠘ ꠄꠞꠣꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠘꠤꠎꠞ ꠜꠣꠡꠣꠄ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠔꠦ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_7","074_2_7","ACT","2","7","7","ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠟꠣ, “ꠅꠃ ꠎꠦꠞꠣ ꠝꠣꠔꠞꠣ ꠄꠞꠣ ꠢꠇꠟꠃ ꠇꠤꠔꠣ ꠉꠣꠟꠤꠟꠞ ꠝꠣꠘꠥꠡ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("AC2_8","074_2_8","ACT","2","8","8","ꠎꠥꠖꠤ ꠅꠄ ꠔꠦ ꠀꠝꠞꠣ ꠇꠤꠟꠣ ꠎꠣꠞꠎꠤꠞ ꠘꠤꠎꠞ ꠜꠣꠡꠣꠞ ꠛꠥꠟꠤ ꠄꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠥꠘꠞꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("AC2_9","074_2_9","ACT","2","9","9","ꠀꠝꠞꠣ ꠔ ꠙꠣꠞ꠆ꠕꠤꠅ, ꠝꠣꠖꠤꠅ, ꠁꠟꠣꠝꠤꠅ, ꠀꠞ ꠝꠦꠡꠙꠔꠣꠝꠤꠀꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ, ꠄꠢꠥꠖꠤꠀ, ꠇꠣꠙ꠆ꠙꠣꠖꠇꠤꠀ, ꠙꠘ꠆ꠔ, ꠀꠍꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("AC2_10","074_2_10","ACT","2","10","10","ꠚꠞꠥꠉꠤꠀ, ꠙꠣꠝꠚꠥꠟꠤꠀ ꠀꠞ ꠝꠤꠡꠞ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠦꠅ; ꠟꠤꠛꠤꠀꠞ ꠇꠥꠞꠤꠘꠤ ꠄꠟꠣꠇꠣꠞ ꠝꠣꠘꠡꠦ, ꠁꠘꠅ ꠊꠥꠞꠣꠔ ꠀꠁꠍꠂꠘ ꠅꠃꠟꠣ ꠞꠥꠝꠣꠘ ꠅꠇꠟꠦ, ");
INSERT INTO syls_vpl VALUES ("AC2_11","074_2_11","ACT","2","11","11","ꠎꠦꠞꠣ ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤ ꠛꠣ ꠁꠢꠥꠖꠤ ꠗꠞ꠆ꠝꠞ ꠝꠣꠘꠥꠡ, ꠀꠞ ꠇ꠆ꠞꠤꠔꠤꠅ, ꠀꠞꠛꠤ, ꠀꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠔ ꠎꠣꠞꠎꠤꠞ ꠘꠤꠎꠞ ꠜꠣꠡꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝꠞ ꠇꠕꠣ ꠄꠞꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠢꠥꠘꠞꠣꠝ!” ");
INSERT INTO syls_vpl VALUES ("AC2_12","074_2_12","ACT","2","12","12","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠀꠞ ꠛꠦꠀꠈꠟ ꠛꠘꠤꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠄꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("AC2_13","074_2_13","ACT","2","13","13","ꠀꠞ ꠛꠣꠇꠤ ꠅꠇꠟꠦ ꠑꠣꠐ꠆ꠐꠣ ꠇꠞꠤꠀ ꠇꠁꠟ, “ꠄꠞꠣ ꠔ ꠝꠖ ꠈꠣꠁꠀ ꠝꠣꠔꠟꠣꠝꠤ ꠇꠞꠦꠞ!” ");
INSERT INTO syls_vpl VALUES ("AC2_14","074_2_14","ACT","2","14","14","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠙꠤꠔꠞꠦ ꠅꠃ ꠄꠉꠣꠞꠅ ꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠟꠉꠦ ꠃꠛꠣꠁꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠀꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠀꠙꠘꠣꠞꠣ ꠎꠣꠘꠤꠀ ꠞꠣꠈꠃꠇ꠆ꠇꠣ ꠀꠞ ꠝꠘ ꠖꠤꠀ ꠀꠝꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_15","074_2_15","ACT","2","15","15","ꠀꠙꠘꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠞꠣ ꠄꠞꠣ ꠝꠣꠔꠣꠟ ꠅꠁꠉꠦꠍꠦ, ꠘꠣ, ꠀꠍꠟꠦ ꠑꠤꠇ ꠘꠣꠄ, ꠅꠈꠘ ꠔ ꠈꠣꠟꠤ ꠡꠇꠣꠟ ꠘꠄꠐꠣ ꠛꠣꠎꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("AC2_16","074_2_16","ACT","2","16","16","ꠁꠐꠣ ꠔ ꠅꠃ ꠊꠐꠘꠣ ꠎꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠘꠛꠤ ꠎꠥꠄꠟꠦ ꠇꠁꠍꠟꠣ: ");
INSERT INTO syls_vpl VALUES ("AC2_17","074_2_17","ACT","2","17","17","ꠀꠟ꠆ꠟꠣꠄ ꠚꠞꠝꠣꠁꠞꠣ, ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠔ ꠅꠃꠟꠣ ꠊꠐꠛ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠞꠥꠢꠥ ꠢꠇ꠆ꠇꠟꠞ ꠝꠣꠎꠦ ꠛꠦꠎꠤꠝꠥ; ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠘꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠔꠥꠘꠤ ꠝꠣꠔ ꠝꠣꠔꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠎꠥꠀꠘ ꠅꠇꠟꠦ ꠉꠣꠁꠛꠤ ꠀꠟꠣꠝꠔꠞ ꠖꠦꠈꠣ ꠙꠣꠁꠛꠣ, ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠈꠥꠀꠛ ꠖꠦꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_18","074_2_18","ACT","2","18","18","ꠅꠃ ꠡꠝꠄ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ-ꠛꠣꠘ꠆ꠖꠤꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠞꠥꠢꠥ ꠛꠦꠎꠤꠝꠥ, ꠔꠣꠞꠣ ꠘꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠅꠢꠤ ꠇꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_19","074_2_19","ACT","2","19","19","ꠀꠝꠤ ꠃꠙꠞꠦ ꠀꠍꠝꠣꠘꠅ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠁꠝꠥ, ꠀꠞ ꠔꠟꠦ ꠖꠥꠘꠤꠀꠔ ꠛꠃꠔ ꠘꠤꠡꠣꠘꠣ ꠊꠐꠣꠁꠝꠥ, ꠟꠃ, ꠀꠉꠥꠁꠘ ꠀꠞ ꠇꠣꠟꠣ-ꠗꠥꠝꠣ ꠖꠦꠈꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("AC2_20","074_2_20","ACT","2","20","20","ꠝꠣꠛꠥꠖꠞ ꠁ ꠝꠢꠣꠘ ꠀꠞ ꠈꠣꠍ ꠖꠤꠘ ꠀꠁꠛꠣꠞ ꠀꠉꠦ, ꠡꠥꠞꠥꠎ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠎꠤꠛ, ꠌꠣꠘ꠆ꠖ ꠟꠃꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("AC2_21","074_2_21","ACT","2","21","21","ꠀꠞ ꠅꠃꠟꠣꠘ ꠅꠁꠛ, ꠎꠦꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠒꠣꠇꠤꠟꠦ, ꠢꠦ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("AC2_22","074_2_22","ACT","2","22","22","ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ, ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣꠞ ꠝꠣꠎꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠀꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠀ, ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠙꠞꠝꠣꠘ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠁꠍꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠟꠣ, ꠀꠞ ꠁꠔꠣ ꠔ ꠀꠙꠘꠣꠞꠣꠅ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC2_23","074_2_23","ACT","2","23","23","ꠀꠟ꠆ꠟꠣ, ꠎꠦꠁꠘ ꠀꠉꠦꠃ ꠎꠣꠘꠂꠘ ꠀꠞ ꠚꠄꠍꠣꠟꠣꠅ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠂꠘ, ꠁꠍꠣꠞꠦ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠀꠔꠅ ꠡꠙꠤꠛꠣ। ꠀꠞ ꠀꠙꠘꠣꠞꠣ ꠛꠦ-ꠖꠤꠘ ꠅꠇꠟꠞ ꠀꠔꠣꠘꠦ ꠔꠣꠘꠞꠦ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛꠅ ꠖꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC2_24","074_2_24","ACT","2","24","24","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠝꠃꠔꠞ ꠀꠎꠣꠛ ꠕꠣꠇꠤ ꠔꠣꠘꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤꠀ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠇꠣꠞꠘ ꠝꠃꠔꠞ ꠈꠦꠝꠔꠣ ꠀꠍꠤꠟ ꠘꠣ ꠔꠣꠘꠞꠦ ꠇꠛꠎꠣ ꠇꠞꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("AC2_25","074_2_25","ACT","2","25","25","ꠖꠣꠃꠖꠦꠅ ꠔꠣꠘ ꠇꠕꠣ ꠇꠁꠍꠂꠘ: ꠀꠝꠤ ꠢꠣꠝꠦꠡꠣ ꠝꠥꠘꠤꠛꠞꠦ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠖꠦꠈꠔꠣꠝ, ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ ꠀꠍꠂꠘ, ꠀꠝꠤ ꠎꠣꠘꠥ ꠅꠡ꠆ꠕꠤꠞ ꠘꠣ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("AC2_26","074_2_26","ACT","2","26","26","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠖꠤꠟ ꠈꠥꠡꠤ ꠅꠄ, ꠀꠝꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠚꠥꠞ꠆ꠔꠤ ꠛꠣꠞꠅꠄ, ꠀꠝꠣꠞ ꠇꠣꠄꠀ ꠅꠃ ꠀꠡꠣꠄ ꠎꠤꠔꠣ ꠞꠁꠛ, ");
INSERT INTO syls_vpl VALUES ("AC2_27","074_2_27","ACT","2","27","27","ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ ꠙꠣꠔꠣꠟꠅ ꠚꠣꠟꠣꠁꠀ ꠕꠁꠔꠣꠄ ꠘꠣꠄ, ꠔꠥꠝꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣꠞ ꠡꠞꠤꠟꠞꠦ ꠙꠌꠣ-ꠉꠟꠣ ꠅꠁꠔꠦ ꠖꠤꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC2_28","074_2_28","ACT","2","28","28","ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠙꠕ ꠎꠣꠘꠣꠁꠍ। ꠔꠥꠝꠣꠞ ꠖꠤꠖꠣꠞꠞ ꠝꠣꠎꠦ ꠀꠍꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠚꠥꠞ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("AC2_29","074_2_29","ACT","2","29","29","ꠜꠣꠁ ꠅꠇꠟ, ꠅꠃ ꠝꠢꠣꠘ-ꠛꠣꠚ ꠖꠣꠃꠖꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠈꠥꠟꠣ-ꠈꠥꠟꠤ ꠇꠁꠞꠣꠝ, ꠔꠣꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ, ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠀꠞ ꠔꠣꠘ ꠇꠄꠛꠞ ꠀꠁꠎꠅ ꠅꠈꠣꠘꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC2_30","074_2_30","ACT","2","30","30","ꠔꠣꠁꠘ ꠄꠇꠎꠘ ꠘꠛꠤ ꠀꠍꠟꠣ ꠀꠞ ꠔꠣꠁꠘ ꠎꠣꠘꠔꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠍꠝ ꠇꠞꠤꠀ ꠁ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ ꠎꠦꠘ, ꠔꠣꠘꠃ ꠅꠀꠞꠤꠡꠞ ꠄꠇꠎꠘꠞꠦ ꠔꠣꠘ ꠉꠖꠤꠔ ꠛꠅꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_31","074_2_31","ACT","2","31","31","ꠄꠞꠟꠣꠉꠤ ꠀꠉ ꠕꠘꠦ ꠖꠦꠈꠤꠀꠃ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠛꠣꠖꠡꠣ, ꠝꠣꠘꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠃ ꠇꠕꠣ ꠇꠁꠍꠟꠣ, ꠄꠘꠞꠦ ꠙꠣꠔꠣꠟꠅ ꠚꠣꠟꠣꠁꠀ ꠕꠅꠀ ꠅꠁꠔ ꠘꠣꠄ, ꠄꠘ ꠇꠣꠄꠀꠅ ꠙꠌꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC2_32","074_2_32","ACT","2","32","32","ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠁꠍꠣꠞꠦꠃ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠀ ꠔꠥꠟꠍꠤꠟꠣ, ꠀꠝꠞꠣ ꠢꠇ꠆ꠇꠟ ꠄꠞ ꠡꠣꠇ꠆ꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("AC2_33","074_2_33","ACT","2","33","33","ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠛꠁꠛꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠔꠣꠘꠞꠦꠃ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠔꠣꠁꠘꠃ ꠙꠣꠁꠍꠟꠣ, ꠀꠞ ꠅꠈꠘ ꠀꠙꠘꠣꠞꠣ ꠎꠦꠔꠣ ꠖꠦꠈꠞꠣ ꠀꠞ ꠢꠥꠘꠞꠣ ꠁꠔꠣ ꠔꠣꠁꠘꠃ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC2_34","074_2_34","ACT","2","34","34","ꠖꠣꠃꠖ ꠔ ꠘꠤꠎꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠢꠣꠝꠣꠁꠍꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠁꠍꠂꠘ: ꠝꠣꠛꠥꠖꠦ ꠀꠝꠣꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠇꠁꠟꠣ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ ꠛꠅ, ");
INSERT INTO syls_vpl VALUES ("AC2_35","074_2_35","ACT","2","35","35","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ ꠚꠣꠟꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠅ। ");
INSERT INTO syls_vpl VALUES ("AC2_36","074_2_36","ACT","2","36","36","ꠄꠞꠟꠣꠉꠤ ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠅꠃ ꠇꠕꠣ ꠜꠣꠟꠣ ꠇꠞꠤ ꠎꠣꠘꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞꠣ ꠎꠦꠘꠞꠦ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠤꠍꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠁꠍꠣꠞꠦꠃ ꠝꠣꠟꠤꠇ ꠀꠞ ꠀꠟ-ꠝꠍꠤ ꠖꠥꠁꠅ ꠔꠈ꠆ꠔ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC2_37","074_2_37","ACT","2","37","37","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠅ ꠍꠦꠟ ꠢꠣꠝꠣꠁꠟ, ꠔꠣꠞꠣ ꠙꠤꠔꠞ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠤꠇꠣꠁꠟ, “ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("AC2_38","074_2_38","ACT","2","38","38","ꠙꠤꠔꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠝꠘ ꠚꠤꠞꠣꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟꠦ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠔꠦꠃ ꠀꠙꠘꠣꠞꠣ ꠖꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_39","074_2_39","ACT","2","39","39","ꠁ ꠅꠀꠖꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠉꠤ, ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠀꠅꠟꠣꠖꠞ ꠟꠣꠉꠤ, ꠎꠦꠞꠣ ꠖꠥꠞꠁ ꠀꠍꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ, ꠎꠔ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠈꠣꠍ ꠛꠘ꠆ꠖꠣ ꠅꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠖꠣꠅꠔ ꠖꠤꠛꠣ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠞ ꠟꠣꠉꠤ।” ");
INSERT INTO syls_vpl VALUES ("AC2_40","074_2_40","ACT","2","40","40","ꠀꠞꠅ ꠛꠃꠔꠔꠣ ꠇꠁꠀ ꠙꠤꠔꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠀꠞ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠁ ꠎꠝꠣꠘꠣꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC2_41","074_2_41","ACT","2","41","41","ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠟꠣ ꠔꠣꠞꠣ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠟꠣ, ꠅꠘꠥꠝꠣꠘ ꠔꠤꠘ ꠀꠎꠣꠞ ꠝꠣꠘꠥꠡ ꠁ ꠖꠤꠘ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_42","074_2_42","ACT","2","42","42","ꠔꠣꠞꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠣ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠦꠎꠛꠣꠘꠤ ꠈꠣꠅꠀ, ꠀꠞ ꠖꠥꠀ ꠇꠞꠣꠔ ꠢꠣꠝꠦꠡꠣ ꠇꠣꠁꠝ ꠞꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_43","074_2_43","ACT","2","43","43","ꠔꠦꠃ ꠢꠇꠟꠦ ꠒꠞꠣꠁꠔ ꠇꠣꠞꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠀꠞ ꠝꠥꠎꠦꠎꠣ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_44","074_2_44","ACT","2","44","44","ꠢꠇ꠆ꠇꠟ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠞꠁꠔꠣ ꠀꠞ ꠎꠣꠞꠎꠤꠞ ꠖꠞꠇꠣꠞꠤ ꠍꠣꠝꠣꠘꠣ ꠅꠘ ꠕꠣꠇꠤ ꠘꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_45","074_2_45","ACT","2","45","45","ꠔꠣꠞꠣꠞ ꠎꠝꠤ-ꠎꠝꠣ ꠗꠘ-ꠖꠃꠟꠔ ꠛꠦꠌꠤꠀ ꠎꠣꠞ ꠎꠦꠟꠣ ꠖꠞꠇꠣꠞ ꠅꠃꠟꠣ ꠛꠣꠐꠤꠀ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_46","074_2_46","ACT","2","46","46","ꠔꠣꠞꠣ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠄꠇꠈꠣꠘꠅ ꠝꠤꠟꠔꠣ, ꠀꠞ ꠈꠥꠡꠤ ꠅꠁꠀ ꠄꠇꠟꠉꠦ ꠡꠞꠟ ꠝꠘꠦ ꠊꠞꠅ ꠊꠞꠅ ꠉꠤꠀ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC2_47","074_2_47","ACT","2","47","47","ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠣꠔ ꠞꠁꠔꠣ ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ। ꠎꠦꠞꠣ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠔꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦꠅ ꠀꠘꠤꠀ ꠖꠤꠘꠦ ꠖꠤꠘꠦ ꠄꠞꠣꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC3_1","074_3_1","ACT","3","1","1","ꠄꠇꠖꠤꠘ ꠀꠍꠞ ꠅꠇ꠆ꠔꠞ ꠘꠝꠣꠎꠞ ꠟꠣꠉꠤ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("AC3_2","074_3_2","ACT","3","2","2","ꠝꠣꠘꠡꠦ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠛꠁꠀ ꠀꠘꠤꠀ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ‘ꠡꠥꠘ꠆ꠖꠞ’ ꠘꠣꠝꠞ ꠉꠦꠁꠐꠞ ꠉꠦꠍꠦ ꠕꠁꠔꠣ, ꠢꠦ ꠎꠘꠝꠉꠔ ꠟꠦꠋꠠꠣ-ꠀꠔꠥꠞ ꠀꠍꠤꠟ, ꠎꠦꠞꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠎꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠜꠤꠇ ꠌꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠢꠤꠈꠣꠘꠅ ꠕꠅꠀ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("AC3_3","074_3_3","ACT","3","3","3","ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠘꠤꠔ ꠖꠦꠈꠤꠀ ꠢꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤ ꠜꠤꠇ ꠈꠥꠎꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC3_4","074_3_4","ACT","3","4","4","ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ ꠔꠣꠞ ꠛꠣꠄ ꠗꠤꠀꠘ ꠗꠞꠤ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC3_5","074_3_5","ACT","3","5","5","ꠔꠦꠃ ꠢꠦ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘ꠆ꠔꠣ ꠙꠣꠅꠀꠞ ꠟꠣꠟꠌꠦ ꠗꠤꠀꠘ ꠗꠞꠤ ꠌꠣꠁꠞꠂꠟ। ");
INSERT INTO syls_vpl VALUES ("AC3_6","074_3_6","ACT","3","6","6","ꠙꠤꠔꠞꠦ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ ꠞꠦꠛꠣ, ꠅꠁꠟꠦ ꠎꠦꠔꠣ ꠀꠍꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠞꠣꠝ। ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠀꠐꠤꠀ ꠎꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC3_7","074_3_7","ACT","3","7","7","ꠇꠁꠀ ꠢꠣꠞꠤ ꠔꠣꠁꠘ ꠄꠞ ꠒꠣꠁꠘ ꠀꠔꠅ ꠗꠞꠤꠀ ꠃꠌꠣ ꠇꠞꠟꠣ, ꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞ ꠙꠣꠅ ꠀꠞ ꠉꠥꠍꠤꠔ ꠛꠟ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC3_8","074_3_8","ACT","3","8","8","ꠢꠦ ꠚꠣꠟꠖꠤ ꠃꠑꠤꠀ ꠃꠛꠣꠁꠟ ꠀꠞ ꠀꠐꠣ ꠡꠥꠞꠥ ꠇꠞꠟ, ꠀꠐꠤ ꠀꠐꠤ ꠚꠣꠟꠣꠁ ꠚꠣꠟꠣꠁ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠔꠦ ꠇꠞꠔꠦ ꠄꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC3_9","074_3_9","ACT","3","9","9","ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠀꠐꠣꠔ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠣꠔ ꠖꠦꠈꠤꠀ ");
INSERT INTO syls_vpl VALUES ("AC3_10","074_3_10","ACT","3","10","10","ꠄꠞꠦ ꠌꠤꠘꠤꠟꠤꠟ, ꠁꠉꠥ ꠖꠦꠈꠤ ꠅꠃ ꠝꠣꠘꠥꠡ, ꠎꠦꠉꠥꠄ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠡꠥꠘ꠆ꠖꠞ ꠘꠣꠝꠞ ꠉꠦꠁꠐꠅ ꠛꠁꠀ ꠜꠤꠇ ꠇꠞꠔ! ꠔꠣꠞ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠥꠡ ꠀꠌꠣꠘꠇ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC3_11","074_3_11","ACT","3","11","11","ꠅꠁꠟꠦ ꠟꠦꠋꠠꠣ ꠢꠇꠤꠞꠦ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞ ꠈꠞꠦ ꠅꠁꠀ ꠊꠥꠞꠣꠄ, ꠝꠣꠘꠡꠦ ꠙꠤꠔꠞꠞ ꠁ ꠇꠣꠝꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠖꠃꠠꠤꠀ ꠍꠥꠟꠣꠁꠝꠣꠘ ꠘꠣꠝꠞ ꠛꠣꠞꠤꠘ꠆ꠖꠣꠔ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC3_12","074_3_12","ACT","3","12","12","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠙꠤꠔꠞꠦ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ, ꠄꠞꠦ ꠖꠦꠈꠤꠀ ꠀꠙꠘꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ ꠇꠦꠘꠦ? ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠙꠤꠞꠣꠇꠤ ꠛꠣ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠉꠥꠘꠦ ꠔꠣꠞꠦ ꠌꠟꠣꠞ ꠡꠇ꠆ꠔꠤ ꠖꠤꠍꠤ ꠝꠘꠦ ꠇꠞꠤꠀ, ꠇꠦꠘꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠄ ꠗꠤꠀꠘ ꠗꠞꠤ ꠌꠣꠁꠞꠂꠍ? ");
INSERT INTO syls_vpl VALUES ("AC3_13","074_3_13","ACT","3","13","13","ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠘ ꠀꠙꠘ ꠛꠘ꠆ꠖꠣ ꠁꠍꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ, ꠎꠦꠘꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠍꠟꠣ। ꠀꠞ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠘꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠔꠣ ꠇꠞꠤ ꠘꠤꠅꠔ ꠇꠞꠍꠟꠣ, ꠁ ꠡꠝꠄ ꠀꠙꠘꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠖꠥꠞꠁ ꠢꠞꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC3_14","074_3_14","ACT","3","14","14","ꠀꠙꠘꠣꠞꠣ ꠅꠃ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠢꠞꠣꠁ ꠖꠤꠀ ꠄꠇꠎꠘ ꠈꠥꠘꠤꠞꠦ ꠍꠣꠠꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠡꠥꠙꠣꠞꠤꠡ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC3_15","074_3_15","ACT","3","15","15","ꠎꠦꠁꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠂꠘ ꠔꠣꠘꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠍꠂꠘ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠝꠞꠣ ꠄꠞ ꠡꠣꠇ꠆ꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("AC3_16","074_3_16","ACT","3","16","16","ꠀꠞ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ, ꠅꠃ ꠎꠦ ꠛꠦꠐꠣꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠌꠤꠘꠞꠣ ꠀꠞ ꠖꠦꠈꠞꠣ, ꠢꠃ ꠁꠍꠣꠞ ꠘꠣꠝꠃ ꠔꠣꠞꠦ ꠛꠟꠀꠟꠣ ꠇꠞꠍꠦ। ꠁꠍꠣꠞ ꠝꠣꠎꠦꠖꠤ ꠎꠦꠔꠣ ꠁꠝꠣꠘ ꠙꠄꠖꠣ ꠅꠄ, ꠅꠃ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC3_17","074_3_17","ACT","3","17","17","“ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠅꠈꠘ ꠎꠣꠘꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ-ꠡꠣꠟꠤꠡ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠀꠙꠘꠣꠞꠣꠅ ꠘꠣ-ꠛꠥꠎꠤꠀ ꠁ ꠇꠣꠝ ꠇꠞꠤꠟꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC3_18","074_3_18","ACT","3","18","18","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠔꠣꠝꠣꠝ ꠘꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠇꠟꠤꠚꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠉꠦ ꠎꠔꠔꠣ ꠎꠣꠘꠣꠁꠍꠂꠘ, ꠁ ꠢꠇ꠆ꠇꠟꠔꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠙꠥꠞꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC3_19","074_3_19","ACT","3","19","19","ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠣ ꠝꠘ ꠚꠤꠞꠣꠃꠇ꠆ꠇꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠥꠈꠤ ꠅꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠥꠘꠣ ꠅꠇꠟ ꠚꠥꠍꠤꠀ ꠍꠣꠚ ꠇꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("AC3_20","074_3_20","ACT","3","20","20","ꠔꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠅꠇ꠆ꠔ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠢꠃ ꠁꠍꠣꠞꠦ ꠝꠣꠘꠤ ꠔꠣꠘ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠛꠦꠎꠤꠀ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠔꠞꠔꠣꠎꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC3_21","074_3_21","ACT","3","21","21","ꠀꠟ꠆ꠟꠣꠄ ꠢꠇꠟꠔꠣꠞꠦ ꠀꠉꠞ ꠢꠣꠟꠔꠅ ꠚꠤꠞꠣꠁꠛꠣ, ꠁꠔꠣ ꠛꠃꠔ ꠖꠤꠘ ꠀꠉꠦꠃ ꠙꠣꠇ ꠘꠛꠤ ꠅꠇꠟꠞ ꠎꠛꠣꠘ ꠖꠤꠀ ꠇꠁꠍꠂꠘ। ꠎꠔꠖꠤꠘ ꠔꠣꠘ ꠁ ꠅꠀꠖꠣ ꠙꠥꠞꠣ ꠘꠣ ꠇꠞꠛꠣ, ꠅꠔ ꠖꠤꠘ ꠁꠍꠣꠅ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC3_22","074_3_22","ACT","3","22","22","ꠝꠥꠍꠣꠄ ꠔ ꠇꠁꠍꠟꠣ, ‘ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠕꠣꠇꠤ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠄꠇ ꠘꠛꠤ ꠙꠄꠖꠣ ꠇꠞꠛꠣ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠇꠁꠛꠣ, ꠔꠥꠝꠞꠣ ꠁ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("AC3_23","074_3_23","ACT","3","23","23","ꠎꠦꠉꠥꠄ ꠔꠣꠘ ꠇꠕꠣ ꠢꠥꠘꠔ ꠘꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠄꠞꠦ ꠘꠤꠎꠞ ꠛꠘ꠆ꠖꠣꠞ ꠈꠣꠔꠣ ꠕꠣꠇꠤ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠛꠣ।’ ");
INSERT INTO syls_vpl VALUES ("AC3_24","074_3_24","ACT","3","24","24","ꠀꠞ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖꠞ ꠀꠝꠟꠞ ꠡꠣꠝꠥꠄꠟ ꠘꠛꠤ ꠕꠣꠇꠤ ꠡꠥꠞꠥ ꠇꠞꠤ ꠎꠔ ꠘꠛꠤ ꠅꠇꠟꠦ ꠇꠣꠟꠣꠝ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠄꠞꠣ ꠢꠇꠟꠦꠃ ꠁ ꠅꠇ꠆ꠔꠞ ꠇꠕꠣ ꠇꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC3_25","074_3_25","ACT","3","25","25","ꠀꠙꠘꠣꠞꠣ ꠔ ꠁ ꠘꠛꠤ ꠅꠇꠟꠞ ꠅꠀꠞꠤꠡ, ꠀꠞ ꠢꠃ ꠇꠣꠘꠥꠘꠞꠅ ꠅꠀꠞꠤꠡ ꠎꠦꠔꠣ ꠀꠟ꠆ꠟꠣꠄ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠇꠣꠁꠝ ꠇꠞꠍꠤꠟꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠇꠁꠍꠟꠣ, ‘ꠔꠥꠝꠣꠞ ꠅꠀꠞꠤꠡꠞ ꠝꠣꠎꠦꠖꠤ ꠖꠥꠘꠤꠀꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠄ ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣ।’ ");
INSERT INTO syls_vpl VALUES ("AC3_26","074_3_26","ACT","3","26","26","ꠢꠃ ꠅꠀꠞꠤꠡ, ꠝꠣꠘꠤ ꠔꠣꠘ ꠈꠣꠍ ꠉꠥꠟꠣꠝ ꠁꠍꠣꠞꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠙꠄꠟꠣꠃ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠛꠦꠎꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠛꠦ-ꠖꠤꠘꠤ ꠇꠣꠝ ꠅꠇꠟ ꠕꠣꠇꠤ ꠚꠤꠞꠣꠁꠀ ꠢꠣꠞꠤ ꠛꠞꠇꠔ ꠖꠦꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC4_1","074_4_1","ACT","4","1","1","ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠎꠦꠛꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠄꠀꠘ ꠇꠞꠞꠣ ꠅꠃ ꠡꠝꠄ ꠁꠝꠣꠝ ꠅꠇꠟ, ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠛꠠ ꠖꠣꠞꠉꠣ ꠀꠞ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠝꠎꠛꠞ ꠝꠣꠘꠥꠡ ꠀꠈꠔꠣꠃ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_2","074_4_2","ACT","4","2","2","ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠣ ꠀꠞ ꠁꠍꠣꠞ ꠝꠣꠎꠖꠤꠀꠃ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠘꠣꠞꠣꠎ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_3","074_4_3","ACT","4","3","3","ꠔꠣꠞꠣ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠀꠐꠇ ꠇꠞꠟꠣ ꠀꠞ ꠢꠣꠁꠘ꠆ꠎꠣ ꠅꠁꠉꠦꠍꠤꠟ ꠇꠞꠤ ꠄꠞꠣꠞꠦ ꠛꠣꠖꠞ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_4","074_4_4","ACT","4","4","4","ꠎꠦꠞꠣ ꠙꠤꠔꠞꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠍꠤꠟꠣ ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠃꠔꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ, ꠔꠦꠃ ꠁꠝꠣꠘꠖꠣꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠙꠞꠤꠝꠣꠘ ꠙꠣꠌ ꠀꠎꠣꠞꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC4_5","074_4_5","ACT","4","5","5","ꠛꠣꠖꠞ ꠖꠤꠘ ꠁꠢꠥꠖꠤꠞ ꠘꠦꠔꠣ ꠅꠇꠟ, ꠝꠥꠞꠛ꠆ꠛꠤ-ꠡꠣꠟꠤꠡ ꠀꠞ ꠝꠃꠟꠣꠘꠣ ꠅꠇꠟ ꠄꠇꠟꠉꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠖꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_6","074_4_6","ACT","4","6","6","ꠢꠤꠈꠣꠘꠅ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠢꠣꠘꠘ, ꠇꠣꠄꠀꠚꠣ, ꠁꠃꠢꠥꠘ꠆ꠘꠣ, ꠍꠤꠇꠘ꠆ꠖꠞ ꠀꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠅꠇꠟꠅ ꠀꠎꠤꠞ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_7","074_4_7","ACT","4","7","7","ꠔꠣꠞꠣ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣ ꠇꠞꠣꠁꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠇꠥꠘ ꠛꠟꠦ ꠀꠞ ꠇꠣꠞ ꠘꠣꠝꠦ ꠁ ꠇꠣꠝ ꠇꠞꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("AC4_8","074_4_8","ACT","4","8","8","ꠔꠦꠃ ꠙꠤꠔꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠝꠥꠞꠛ꠆ꠛꠤ ꠍꠣꠄꠛꠣꠁꠘ ꠀꠞ ꠖꠦꠡꠞ ꠛꠥꠎꠥꠞ꠆ꠉ ꠅꠇꠟ, ");
INSERT INTO syls_vpl VALUES ("AC4_9","074_4_9","ACT","4","9","9","ꠄꠇꠎꠘ ꠟꠦꠋꠠꠣ-ꠀꠔꠥꠞ ꠝꠣꠘꠡꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠍꠤ ꠇꠞꠤ ꠀꠙꠘꠣꠞꠣ ꠀꠁꠎ ꠀꠝꠞꠣꠞꠦ ꠎꠦꠞꠣ ꠇꠞꠞꠣ, ꠝꠣꠘꠥꠡꠉꠥ ꠇꠤꠟꠣ ꠜꠣꠟꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC4_10","074_4_10","ACT","4","10","10","ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟꠦ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠦꠅ ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ, ꠎꠦꠘꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠍꠟꠣ, ꠎꠦꠘꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠛꠟꠦꠃ ꠁ ꠝꠣꠘꠥꠡꠉꠥ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠍꠣꠝꠘꠦ ꠜꠣꠟꠣ ꠅꠁꠀ ꠃꠛꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC4_11","074_4_11","ACT","4","11","11","ꠔꠣꠁꠘ ꠢꠃ ꠙꠣꠔ꠆ꠔꠞ, ꠎꠦꠔꠣꠞꠦ ꠞꠣꠎ ꠝꠦꠡ꠆ꠔꠁꠞ ꠅꠇꠟꠦ, ꠝꠣꠘꠤ ꠀꠙꠘꠣꠞꠣ ꠄꠟꠣꠝꠤ ꠇꠞꠤ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍꠟꠣ, ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠇꠕꠣ ꠝꠣꠚꠤꠇ ꠢꠃ ꠙꠣꠔ꠆ꠔꠞꠃ ꠀꠁꠎ ꠁꠀꠘ ꠇꠥꠘꠣꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠎꠞꠥꠞꠤ ꠈꠥꠐꠤ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC4_12","074_4_12","ACT","4","12","12","ꠔꠞꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠀꠞ ꠇꠦꠃꠞꠞ ꠉꠦꠍꠦ ꠘꠣꠁ, ꠇꠣꠞꠘ ꠀꠍꠝꠣꠘꠞ ꠔꠟꠦ ꠀꠞ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠅꠃꠟꠣ ꠀꠞ ꠇꠥꠘꠥ ꠘꠣꠝ ꠖꠦꠅꠀ ꠅꠁꠍꠦ ꠘꠣ, ꠎꠦꠘ ꠘꠣꠝꠦ ꠀꠝꠞꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("AC4_13","074_4_13","ACT","4","13","13","ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞ ꠡꠣꠅꠡ ꠖꠦꠈꠤꠀ, ꠄꠞꠣ ꠎꠦꠘ ꠅꠡꠤꠇ꠆ꠇꠤꠔ ꠡꠣꠝꠣꠁꠘ꠆ꠘ ꠝꠣꠘꠥꠡ ꠁꠔꠣ ꠎꠣꠘꠤꠀ ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ, ꠀꠞ ꠄꠞꠣ ꠁꠍꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ ꠇꠞꠤꠅ ꠌꠤꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_14","074_4_14","ACT","4","14","14","ꠎꠦ ꠛꠦꠐꠣ ꠜꠣꠟꠣ ꠅꠁꠍꠤꠟ, ꠢꠦ ꠄꠞꠣꠞ ꠟꠉꠦ ꠃꠛꠣꠁꠞꠂꠍꠦ ꠖꠦꠈꠤꠀ ꠄꠞꠣꠞꠦ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠇꠅꠀꠞ ꠡꠣꠅꠡ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_15","074_4_15","ACT","4","15","15","ꠛꠣꠖꠦ ꠝꠎꠟꠤꠍ ꠕꠣꠇꠤ ꠄꠞꠣꠞꠦ ꠛꠣꠞꠦ ꠎꠣꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠀ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠣꠔ ꠛꠁꠀ ");
INSERT INTO syls_vpl VALUES ("AC4_16","074_4_16","ACT","4","16","16","ꠇꠁꠟꠣ, “ꠁ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ? ꠄꠞꠣ ꠔ ꠛꠃꠔ ꠛꠠ ꠄꠇ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠍꠦ ꠀꠞ ꠁꠔꠣ ꠔ ꠀꠡ꠆ꠔꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠢꠇꠟꠦ ꠎꠣꠘꠦ, ꠀꠞ ꠀꠝꠞꠣꠅ ꠁꠐꠣꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤꠀꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_17","074_4_17","ACT","4","17","17","ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠣꠘꠥ ꠁ ꠇꠕꠣ ꠀꠞ ꠎꠣꠘꠣ-ꠎꠣꠘꠤ ꠘꠣ ꠅꠄ, ꠄꠞꠟꠣꠉꠤ ꠄꠞꠣꠞꠦ ꠒꠞ ꠖꠦꠈꠣꠁꠟ ꠅꠃꠇ, ꠎꠣꠔꠦ ꠁ ꠎꠘꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣ ꠀꠞ ꠇꠦꠃꠞꠞ ꠉꠦꠍꠦ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠇꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC4_18","074_4_18","ACT","4","18","18","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠀꠘꠣꠁꠀ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠄꠇꠖꠝ ꠇꠤꠌ꠆ꠍꠥ ꠇꠁꠅ ꠘꠣ, ꠇꠥꠘꠥꠎꠣꠔ ꠘꠍꠤꠅꠔꠅ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC4_19","074_4_19","ACT","4","19","19","ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠞꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠔꠣꠝ, ꠘꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠔꠣꠝ? ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠇꠥꠘꠈꠣꠘ ꠑꠤꠇ, ꠁꠔꠣ ꠀꠙꠘꠣꠞꠣꠃ ꠛꠤꠌꠣꠞ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_20","074_4_20","ACT","4","20","20","ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠖꠦꠈꠍꠤ ꠀꠞ ꠢꠥꠘꠍꠤ, ꠁꠔꠣ ꠘꠣ ꠇꠁꠀ ꠔ ꠕꠣꠇꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC4_21","074_4_21","ACT","4","21","21","ꠔꠦꠃ ꠔꠣꠞꠣ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠀꠞꠅ ꠒꠞ ꠖꠦꠈꠣꠁꠀ ꠍꠣꠠꠤ ꠖꠤꠟꠣ। ꠝꠣꠘꠡꠞꠦ ꠒꠞꠣꠁꠀ ꠔꠣꠞꠣ ꠄꠞꠣꠞꠦ ꠇꠥꠘꠥ ꠡꠣꠎꠣ ꠖꠤꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠎꠦꠔꠣ ꠊꠐꠍꠤꠟ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙ꠆ꠞꠡꠋꠡꠣ ꠇꠞꠣꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC4_22","074_4_22","ACT","4","22","22","ꠎꠦ ꠝꠣꠘꠥꠡꠉꠥ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠜꠣꠟꠣ ꠅꠁꠍꠤꠟ ꠔꠣꠞ ꠛꠄꠅꠡ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞꠞ ꠛꠦꠡꠤ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC4_23","074_4_23","ACT","4","23","23","ꠁ ꠛꠤꠌꠣꠞ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠍꠣꠠꠣꠞ ꠛꠣꠖꠦ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ ꠔꠣꠞꠣꠞ ꠀꠙꠘ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣꠉꠤ, ꠉꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ-ꠡꠣꠟꠤꠡ ꠅꠇꠟꠦꠅ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠁꠍꠟꠣ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_24","074_4_24","ACT","4","24","24","ꠁꠔꠣ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠄꠇ ꠖꠤꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠖꠥꠀ ꠇꠞꠟꠣ, “ꠅ ꠝꠣꠟꠤꠇ, ꠔꠥꠝꠤ ꠀꠍꠝꠣꠘ, ꠎꠝꠤꠘ, ꠖꠞꠤꠀ ꠀꠞ ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠎꠔꠔꠣ ꠀꠍꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("AC4_25","074_4_25","ACT","4","25","25","ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝ, ꠀꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠣꠚ ꠖꠣꠃꠖꠞ ꠎꠛꠣꠘꠅ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤꠀ ꠅꠃꠟꠣ ꠇꠁꠍ, ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠄ ꠇꠦꠘꠦ ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠞꠣ? ꠇꠤꠅꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠛꠦꠢꠥꠖꠣ ꠚꠘ꠆ꠖꠤ ꠇꠞꠦꠞ? ");
INSERT INTO syls_vpl VALUES ("AC4_26","074_4_26","ACT","4","26","26","ꠎꠉꠔꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟ ꠛꠤꠉꠠꠤ ꠉꠦꠟ, ꠞꠣꠎꠣ ꠅꠇꠟ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠟ, ꠝꠣꠛꠥꠖꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠞ ꠔꠣꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ। ");
INSERT INTO syls_vpl VALUES ("AC4_27","074_4_27","ACT","4","27","27","ꠔꠥꠝꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠉꠥꠟꠣꠝ ꠁꠍꠣ, ꠎꠦꠘꠞꠦ ꠔꠥꠝꠤ ꠀꠟ-ꠝꠍꠤ ꠇꠞꠤꠀ ꠖꠥꠘꠤꠀꠔ ꠙꠣꠑꠣꠁꠍ, ꠔꠣꠘ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖ ꠀꠞ ꠙꠘ꠆ꠔꠤꠅ ꠙꠤꠟꠣꠔ, ꠅꠃ ꠡꠢꠞꠅ ꠅ-ꠁꠢꠥꠖꠤ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠄꠇꠈꠣꠘꠅ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC4_28","074_4_28","ACT","4","28","28","ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠇꠥꠖꠞꠔꠦ ꠎꠦꠔꠣ ꠊꠐꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠀꠉꠦꠃ ꠑꠤꠇ ꠇꠞꠤ ꠞꠣꠈꠤꠍꠟꠣꠄ, ꠔꠣꠞꠣ ꠅꠃꠔꠣꠃ ꠊꠐꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC4_29","074_4_29","ACT","4","29","29","ꠅꠈꠘ ꠅ ꠝꠣꠟꠤꠇ, ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞꠦ ꠇꠤꠟꠣ ꠒꠞ ꠖꠦꠈꠣꠁꠞꠣ, ꠔꠥꠝꠤ ꠈꠤꠀꠟ ꠇꠞꠅ, ꠔꠥꠝꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠅꠃꠟꠣ ꠔꠣꠇ꠆ꠇꠔ ꠖꠦꠅ ꠎꠣꠔꠦ, ꠙꠥꠞꠣꠙꠥꠞ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("AC4_30","074_4_30","ACT","4","30","30","ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞ ꠡꠤꠚꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠀꠔ ꠝꠥꠛꠣꠞꠇ ꠛꠣꠠꠣꠁ ꠖꠦꠅ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠣꠇ ꠉꠥꠟꠣꠝ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠝꠥꠎꠦꠎꠣ ꠀꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠘꠤꠞ ꠔꠚꠤꠇ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC4_31","074_4_31","ACT","4","31","31","ꠔꠣꠞꠣꠞ ꠖꠥꠀ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠔꠣꠞꠣ ꠖꠟꠣ ꠅꠁꠍꠟꠣ, ꠢꠤ ꠎꠣꠉꠣ ꠇꠣꠙꠤꠀ ꠃꠑꠟ। ꠀꠞ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_32","074_4_32","ACT","4","32","32","ꠎꠦꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟꠣ, ꠔꠣꠞꠣꠞ ꠄꠇ ꠝꠘ ꠀꠞ ꠄꠇ ꠖꠤꠟ ꠀꠍꠤꠟ। ꠔꠣꠞꠣ ꠄꠇꠎꠘꠦꠅ ꠘꠤꠎꠞ ꠗꠘ-ꠖꠃꠟꠔꠞꠦ ꠘꠤꠎꠞ ꠇꠁꠀ ꠖꠣꠛꠤ ꠇꠞꠔꠣ ꠘꠣ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠢꠇꠟꠞ ꠖꠞꠇꠣꠞ ꠝꠔ ꠈꠞꠌ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC4_33","074_4_33","ACT","4","33","33","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠈꠥꠛ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤꠀ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠞ ꠛꠤꠡꠄꠄ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣ, ꠀꠞ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠞꠢꠝꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC4_34","074_4_34","ACT","4","34","34","ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠅꠜꠣꠛꠤ ꠀꠍꠟꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠎꠦꠞꠣꠞ ꠎꠝꠤꠘ ꠛꠣ ꠛꠣꠠꠤ ꠀꠍꠤꠟ ꠔꠣꠞꠣ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠦꠌꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("AC4_35","074_4_35","ACT","4","35","35","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠘꠤꠀ ꠖꠣꠘ ꠇꠞꠤꠟꠤꠔꠣ, ꠛꠣꠖꠦ ꠎꠣꠞ ꠎꠦꠟꠣ ꠉꠞꠎ ꠔꠣꠞꠦ ꠅꠃꠟꠣ ꠖꠦꠅꠀ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("AC4_36","074_4_36","ACT","4","36","36","ꠀꠞ ꠁꠃꠍꠥꠚ ꠘꠣꠝꠦ ꠟꠦꠛꠤꠞ ꠛꠋꠡꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ, ꠔꠣꠘ ꠛꠣꠠꠤ ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠖꠤꠙ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠒꠣꠇꠤꠔꠣ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ, ꠝꠣꠘꠤ ꠃꠔꠡꠣꠢ ꠎꠥꠉꠣꠅꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("AC4_37","074_4_37","ACT","4","37","37","ꠔꠣꠘ ꠄꠇꠎꠞꠣ ꠎꠝꠤꠘ ꠀꠍꠤꠟ, ꠔꠣꠁꠘꠅ ꠔꠣꠘ ꠎꠝꠤꠘꠈꠣꠘ ꠛꠦꠌꠤꠀ ꠐꠦꠇꠣ ꠀꠘꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠇꠖꠝꠅ ꠖꠣꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_1","074_5_1","ACT","5","1","1","ꠅꠃ ꠡꠝꠄ ꠅꠘꠘꠤꠅ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠞ ꠔꠣꠞ ꠛꠃ ꠍꠣꠚꠤꠞꠣꠄ ꠔꠣꠞꠣꠞꠅ ꠄꠇꠎꠞꠣ ꠎꠝꠤꠘ ꠛꠦꠌꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC5_2","074_5_2","ACT","5","2","2","ꠛꠦꠌꠤꠀ ꠔꠣꠞ ꠛꠃꠞ ꠎꠣꠘꠣ ꠝꠘ꠆ꠔꠦꠃ ꠎꠝꠤꠘꠞ ꠇꠤꠍꠥ ꠐꠦꠇꠣ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠟꠥꠇꠣꠁꠀ, ꠛꠣꠇꠤ ꠐꠦꠇꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠙꠣꠅꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_3","074_5_3","ACT","5","3","3","ꠔꠦꠃ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠅꠘꠘꠤꠅ, ꠡꠄꠔꠣꠘꠦ ꠇꠦꠝꠘꠦ ꠔꠥꠝꠣꠞ ꠖꠤꠟꠞꠦ ꠖꠈꠟ ꠇꠞꠟ, ꠔꠥꠝꠤ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠉꠦꠍꠦ ꠇꠤꠟꠣ ꠝꠤꠍꠣ ꠝꠣꠔꠟꠣꠄ, ꠀꠞ ꠎꠝꠤꠘ ꠛꠦꠌꠣꠞ ꠐꠦꠇꠣ ꠇꠤꠍꠥ ꠟꠥꠇꠣꠁ ꠞꠣꠈꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("AC5_4","074_5_4","ACT","5","4","4","ꠛꠦꠌꠣꠞ ꠀꠉꠦ ꠎꠝꠤꠘꠈꠣꠘ ꠇꠤꠔꠣ ꠔꠥꠝꠣꠞ ꠀꠍꠤꠟ ꠘꠣ ꠘꠤ? ꠀꠞ ꠛꠦꠌꠣꠞ ꠛꠣꠖꠦꠅ ꠔ ꠁ ꠐꠦꠇꠣ ꠔꠥꠝꠣꠞ ꠄꠈꠔꠤꠀꠞꠅ ꠀꠍꠤꠟ, ꠔꠦ ꠇꠦꠘꠦ ꠔꠥꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠁꠔꠣ ꠢꠣꠝꠣꠁꠟ? ꠔꠥꠝꠤ ꠔ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠝꠤꠍꠣ ꠝꠣꠔꠍ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦꠃ ꠝꠤꠍꠣ ꠝꠣꠔꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC5_5","074_5_5","ACT","5","5","5","ꠁꠔꠣ ꠢꠥꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠅꠘꠘꠤꠅ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀ ꠝꠞꠤꠉꠦꠟ। ꠀꠞ ꠎꠦꠞꠣ ꠁ ꠊꠐꠘꠣ ꠢꠥꠘꠟ ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠈꠥꠛ ꠒꠞꠣꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC5_6","074_5_6","ACT","5","6","6","ꠛꠣꠖꠦ ꠎꠥꠀꠘ ꠅꠇꠟꠦ ꠀꠁꠀ ꠔꠣꠞꠦ ꠇꠣꠚꠘ ꠚꠤꠘ꠆ꠖꠣꠁꠀ ꠛꠣꠞꠦ ꠘꠤꠀ ꠝꠣꠐꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_7","074_5_7","ACT","5","7","7","ꠅꠘꠥꠝꠣꠘ ꠔꠤꠘ ꠊꠘ꠆ꠐꠣ ꠛꠣꠖꠦ ꠔꠣꠞ ꠛꠃꠅ ꠢꠘꠅ ꠀꠁꠟ, ꠅꠁꠟꠦ ꠀꠉꠦ ꠇꠤꠔꠣ ꠊꠐꠍꠦ ꠔꠣꠁ ꠎꠣꠘꠔ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_8","074_5_8","ACT","5","8","8","ꠔꠦꠃ ꠙꠤꠔꠞꠦ ꠔꠣꠁꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠝꠣꠞꠦ ꠇꠅ ꠌꠣꠁꠘ, ꠔꠥꠝꠞꠣ ꠁ ꠎꠝꠤꠘ ꠅꠔ ꠐꠦꠇꠣꠄ ꠛꠦꠌꠤꠍꠟꠣꠄ ꠘꠤ?” ꠔꠣꠁ ꠇꠁꠟ, “ꠎꠤꠅꠄ ꠅꠔ ꠐꠦꠇꠣꠄꠃ।” ");
INSERT INTO syls_vpl VALUES ("AC5_9","074_5_9","ACT","5","9","9","ꠅꠃ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠝꠣꠛꠥꠖꠞ ꠞꠥꠢꠥꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠄꠇꠝꠔ ꠅꠁꠟꠣꠄ? ꠖꠦꠈꠅ, ꠎꠦꠞꠣ ꠔꠥꠝꠣꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠍꠦ ꠔꠣꠞꠣ ꠅꠈꠘ ꠖꠞꠎꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠅꠞ, ꠔꠣꠞꠣ ꠔꠥꠝꠣꠞꠦꠅ ꠛꠣꠞꠦ ꠟꠁꠀ ꠎꠣꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC5_10","074_5_10","ACT","5","10","10","ꠟꠉꠦ ꠟꠉꠦꠃ ꠍꠣꠚꠤꠞꠣ ꠙꠤꠔꠞꠞ ꠙꠣꠅꠔ ꠙꠠꠤꠀ ꠝꠞꠤꠉꠦꠟ, ꠀꠞ ꠅꠃ ꠎꠥꠀꠘ ꠅꠇꠟꠦ ꠊꠞꠅ ꠀꠁꠀ ꠔꠣꠁꠞꠦ ꠝꠞꠣ ꠖꠦꠈꠤꠀ ꠛꠣꠞꠦ ꠘꠤꠀ ꠎꠣꠝꠣꠁꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠝꠣꠐꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_11","074_5_11","ACT","5","11","11","ꠔꠦꠃ ꠢꠇ꠆ꠇꠟ ꠎꠝꠣꠔ, ꠀꠞ ꠎꠔ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠢꠥꠘꠟ, ꠢꠇꠟꠦꠃ ꠈꠥꠛ ꠒꠞꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC5_12","074_5_12","ACT","5","12","12","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠀꠔꠣꠘꠦ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠝꠥꠎꠦꠎꠣ ꠀꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠎꠣꠁꠞ ꠅꠁꠔ, ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠄꠇ ꠖꠤꠟ ꠅꠁꠀ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠍꠥꠟꠣꠁꠝꠣꠘꠞ ꠛꠣꠞꠤꠘ꠆ꠖꠣꠔ ꠖꠟꠣ ꠅꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_13","074_5_13","ACT","5","13","13","ꠎꠥꠖꠤꠅ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠔꠣ, ꠔꠣ-ꠅ ꠀꠞ ꠇꠦꠃ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠤꠡꠔꠦ ꠡꠣꠅꠡ ꠇꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_14","074_5_14","ACT","5","14","14","ꠀꠞ ꠖꠤꠘꠦ ꠖꠤꠘꠦ ꠛꠃꠔ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠖꠟꠅ ꠢꠣꠝꠣꠘꠤꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_15","074_5_15","ACT","5","15","15","ꠀꠞ ꠝꠣꠘꠡꠦ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞꠦ ꠛꠣꠞꠦ ꠀꠘꠤꠀ ꠙꠕꠞ ꠇꠣꠘ꠆ꠖꠣꠄ ꠇꠣꠘ꠆ꠖꠣꠄ ꠢꠥꠔꠣꠁꠀ ꠀꠞ ꠛꠤꠍꠘꠣ ꠙꠣꠔꠤꠀ ꠛꠅꠀꠁꠀ ꠕꠁꠔꠣ, ꠎꠣꠔꠦ ꠙꠤꠔꠞꠦ ꠌꠟꠣ-ꠚꠤꠞꠣꠞ ꠡꠝꠄ ꠅꠘ꠆ꠔꠔ ꠔꠣꠘ ꠍꠦꠛꠣ ꠈꠣꠘꠅ ꠔꠣꠞꠣ ꠇꠦꠃꠞꠞ ꠃꠙꠞꠦ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("AC5_16","074_5_16","ACT","5","16","16","ꠀꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠉꠣꠃꠀꠁꠘ ꠕꠣꠇꠤ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞꠦ ꠀꠞ ꠎꠤꠘꠞ ꠀꠍꠞ ꠀꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠀꠁꠀ ꠜꠤꠠ ꠎꠝꠣꠁꠔ, ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠃ ꠜꠣꠟꠣ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("AC5_17","074_5_17","ACT","5","17","17","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠅꠇꠟ ꠁꠋꠡꠣꠄ ꠎꠟꠤ-ꠙꠥꠠꠤ ꠃꠑꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC5_18","074_5_18","ACT","5","18","18","ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠗꠞꠤꠀ ꠡꠞꠇꠣꠞꠤ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_19","074_5_19","ACT","5","19","19","ꠅꠁꠟꠦ ꠞꠣꠁꠔꠇꠥ ꠝꠣꠛꠥꠖꠞ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠎꠦꠟꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠞꠦ ꠀꠘꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC5_20","074_5_20","ACT","5","20","20","“ꠔꠥꠝꠞꠣ ꠎꠣꠅ, ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠃꠛꠣꠁꠀ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠘꠄꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠇꠕꠣ ꠇꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC5_21","074_5_21","ACT","5","21","21","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠡꠇꠣꠟꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠘꠍꠤꠅꠔ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ꠁꠛꠣꠄ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠦ ꠀꠁꠀ ꠖꠦꠡꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞꠦ ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠟꠣ, ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_22","074_5_22","ACT","5","22","22","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠉꠤꠀ ꠄꠞꠣꠞꠦ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠙꠣꠁꠟꠣ ꠘꠣ। ꠅꠃ ꠔꠣꠞꠣ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠈꠛꠞ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC5_23","074_5_23","ACT","5","23","23","“ꠀꠝꠞꠣ ꠖꠦꠈꠍꠤ, ꠎꠦꠟꠞ ꠖꠞꠎꠣ ꠡꠇ꠆ꠔ ꠇꠞꠤ ꠟꠣꠉꠣꠁꠟ, ꠀꠞ ꠖꠥꠀꠞꠅ ꠖꠥꠀꠞꠅ ꠙꠣꠞꠣꠖꠣꠞ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ, ꠅꠁꠟꠦ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠀ ꠜꠤꠔꠞꠦ ꠇꠦꠃꠞꠞꠦ ꠙꠣꠁꠟꠣꠝ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC5_24","074_5_24","ACT","5","24","24","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠛꠠ ꠖꠣꠞꠉꠣꠄ ꠀꠞ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠛꠦꠅꠇꠥꠚ ꠅꠁꠀ ꠌꠤꠘ꠆ꠔꠣꠔ ꠙꠠꠟꠣ, ꠄꠞ ꠚꠟ ꠇꠤꠔꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("AC5_25","074_5_25","ACT","5","25","25","ꠄꠞꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠄꠇꠎꠘꠦ ꠀꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠈꠛꠞ ꠖꠤꠟ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞꠣ ꠎꠦ ꠝꠣꠘꠡꠞꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠃꠛꠣꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠘꠍꠤꠅꠔ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC5_26","074_5_26","ACT","5","26","26","ꠔꠦꠃ ꠛꠠ ꠖꠣꠞꠉꠣꠄ ꠔꠣꠘ ꠍꠤꠙꠣꠁ ꠖꠟꠞꠦ ꠟꠁꠀ ꠢꠘꠅ ꠉꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠗꠞꠤꠀ ꠀꠘꠟꠣ, ꠅꠁꠟꠦ ꠎꠥꠞ-ꠎꠛꠞꠖꠡ꠆ꠔꠤ ꠇꠞꠟꠣ ꠘꠣ ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠒꠞꠣꠁꠉꠦꠟꠣ, ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠝꠣꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC5_27","074_5_27","ACT","5","27","27","ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠀꠘꠤꠀ ꠔꠣꠞꠣ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣ ꠇꠞꠣꠁꠟꠣ, ꠀꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠄꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC5_28","074_5_28","ACT","5","28","28","“ꠀꠝꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠠꠣꠁꠀ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣꠝ, ꠁ ꠘꠣꠝꠦ ꠇꠥꠘꠥ ꠘꠍꠤꠅꠔ ꠘꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣ-ꠅ ꠀꠡ꠆ꠔꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠎꠥꠠꠤ ꠔꠥꠝꠞꠣꠞ ꠔꠣꠟꠤꠝꠦ ꠜꠞꠤꠟꠤꠍ, ꠀꠞ ꠅꠃ ꠎꠘꠞ ꠈꠥꠘꠞ ꠜꠣꠞ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠚꠣꠟꠣꠁꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC5_29","074_5_29","ACT","5","29","29","ꠔꠦꠃ ꠙꠤꠔꠞ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠝꠣꠘꠡꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠣꠞ ꠌꠣꠁꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠣ ꠔ ꠚꠞꠎ। ");
INSERT INTO syls_vpl VALUES ("AC5_30","074_5_30","ACT","5","30","30","ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠀꠟ꠆ꠟꠣꠄ ꠢꠃ ꠁꠍꠣꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠎꠦꠘꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC5_31","074_5_31","ACT","5","31","31","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦꠃ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠀꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠘꠣꠁꠀ ꠘꠤꠎꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ ꠛꠁꠛꠣꠞ ꠁꠎ꠆ꠎꠔ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞꠦ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ, ꠀꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠖꠤꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC5_32","074_5_32","ACT","5","32","32","ꠀꠝꠞꠣ ꠁ ꠢꠇꠟꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠞꠣ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠎꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠍꠂꠘ, ꠢꠃ ꠙꠣꠇ ꠞꠥꠢꠥꠅ ꠄꠞ ꠡꠣꠇ꠆ꠇꠤ।” ");
INSERT INTO syls_vpl VALUES ("AC5_33","074_5_33","ACT","5","33","33","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ, ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠅꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_34","074_5_34","ACT","5","34","34","ꠅꠁꠟꠦ ꠅꠃ ꠝꠎꠟꠤꠍ ꠕꠣꠇꠤ ꠉꠝꠟꠤꠄꠟ ꠘꠣꠝꠦ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠃꠛꠣꠁꠟꠣ, ꠔꠣꠁꠘ ꠄꠇꠎꠘ ꠘꠣꠝꠇꠞꠣ ꠝꠃꠟꠣꠘꠣ ꠀꠍꠟꠣ, ꠢꠇ꠆ꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠔ, ꠔꠣꠁꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠕꠥꠠꠣ ꠛꠣꠞꠦ ꠘꠦꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_35","074_5_35","ACT","5","35","35","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ, ꠁ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠇꠞꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ ꠁ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("AC5_36","074_5_36","ACT","5","36","36","ꠢꠥꠘꠅ, ꠅꠃ ꠇꠄꠖꠤꠘ ꠀꠉꠦ ꠕꠥꠖꠣ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠈꠥꠛ ꠛꠠ-ꠝꠣꠘꠡꠤ ꠖꠦꠈꠣꠁꠍꠤꠟ, ꠀꠞ ꠅꠘꠥꠝꠣꠘ ꠌꠣꠁꠞ-ꠡ ꠝꠣꠘꠥꠡ ꠔꠣꠞ ꠖꠟꠅ ꠢꠣꠝꠣꠁꠍꠤꠟ। ꠔꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠣ ꠅꠁꠟ, ꠀꠞ ꠔꠣꠞ ꠖꠟꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤꠉꠦꠍꠦ, ꠇꠦꠃ ꠖꠟꠅ ꠞꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_37","074_5_37","ACT","5","37","37","ꠛꠣꠖꠦ ꠉꠣꠟꠤꠟꠞ ꠄꠢꠥꠖꠣ ꠀꠁꠀ ꠖꠦꠡꠞ ꠝꠣꠘꠥꠡ ꠉꠘꠘꠣꠞ ꠛꠍꠞ, ꠄꠇꠖꠟ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠞ ꠖꠟꠅ ꠢꠣꠞꠣꠁꠀ ꠚꠤꠔꠘꠣ ꠈꠣꠠꠣ ꠇꠞꠟ, ꠢꠦ-ꠅ ꠝꠞꠤꠉꠦꠟ, ꠀꠞ ꠔꠣꠞ ꠟꠉꠞ ꠢꠇ꠆ꠇꠟꠅ ꠍꠤꠔ꠆ꠞꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC5_38","074_5_38","ACT","5","38","38","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠁ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ, ꠔꠣꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠀꠞ ꠘꠤꠅꠔ ꠎꠥꠖꠤ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ ꠅꠄ, ꠔꠦ ꠁꠔꠣ ꠄꠝꠘꠦꠃ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("AC5_39","074_5_39","ACT","5","39","39","ꠀꠞ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣ ꠕꠣꠇꠤ ꠅꠄ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠕꠣꠝꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ, ꠇꠤ ꠎꠣꠘꠤ ꠢꠦꠡꠦ ꠖꠦꠈꠣ ꠎꠣꠁꠛ ꠎꠦꠘ, ꠔꠥꠝꠞꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠤꠢꠣꠖ ꠇꠞꠞꠣꠄ।” ꠉꠝꠟꠤꠄꠟꠞ ꠝꠣꠔꠦ ꠘꠦꠔꠣ ꠅꠇꠟ ꠞꠣꠎꠤ ꠅꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC5_40","074_5_40","ACT","5","40","40","ꠔꠣꠞꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠣꠍꠣꠔ ꠀꠘꠣꠁꠀ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠟꠣ ꠀꠞ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠤꠅ ꠘꠣ।” ꠢꠦꠡꠦ ꠔꠣꠞꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_41","074_5_41","ACT","5","41","41","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ, ꠁꠍꠣꠞ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠣꠝꠣꠘꠤꠞ ꠎꠥꠇꠣ ꠅꠁꠍꠂꠘ ꠉꠔꠤꠇꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠤ ꠇꠞꠤ ꠝꠎꠟꠤꠍ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC5_42","074_5_42","ACT","5","42","42","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠀꠞ ꠛꠣꠠꠤꠄ ꠛꠣꠠꠤꠄ ꠉꠤꠀ ꠘꠍꠤꠅꠔ ꠇꠞꠔꠣ, ꠀꠞ ꠁꠍꠣꠃ ꠎꠦꠘ ꠀꠟ-ꠝꠍꠤ ꠁꠈꠣꠘ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠛꠣꠖ ꠖꠤꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC6_1","074_6_1","ACT","6","1","1","ꠢꠤ ꠡꠝꠄ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠙꠞꠤꠝꠣꠘ ꠛꠣꠠꠔꠦꠃ ꠀꠍꠤꠟ, ꠀꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠁꠃꠘꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠔꠣ, ꠔꠣꠞꠣ ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠞꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠔꠣ ꠟꠣꠉꠟꠣ। ꠔꠣꠞꠣ ꠖꠥꠡ ꠖꠦꠈꠣꠁꠟꠣ, ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠈꠣꠘꠤ ꠛꠤꠟꠣꠘꠤꠞ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠇꠥꠘ꠆ꠔꠣ ꠙꠣꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC6_2","074_6_2","ACT","6","2","2","ꠔꠦꠃ ꠢꠃ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠄ ꠢꠇꠟ ꠃꠝ꠆ꠝꠔꠞꠦ ꠄꠇ ꠎꠣꠉꠣꠔ ꠖꠟꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠔꠛꠟꠤꠉ ꠛꠣꠖ ꠖꠤꠀ, ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠦꠡ꠆ꠔ ꠅꠀꠈꠣꠘ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC6_3","074_6_3","ACT","6","3","3","ꠅꠁꠟꠦ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠅꠃꠟꠣ ꠡꠣꠔꠎꠘ ꠡꠥꠘꠣꠝ ꠀꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠅ, ꠎꠦꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠦ ꠀꠞ ꠢꠦꠇꠝꠔꠦ ꠙꠥꠞꠣ ꠇꠣꠝꠤꠀꠛ ꠀꠍꠦ, ꠀꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠁ ꠇꠣꠝꠞ ꠎꠤꠝ꠆ꠝꠣ ꠖꠤꠟꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("AC6_4","074_6_4","ACT","6","4","4","ꠀꠞ ꠀꠝꠞꠣ ꠇꠣꠟꠣꠝꠞ ꠈꠦꠎꠝꠔ ꠀꠞ ꠖꠥꠀ ꠇꠞꠣꠞ ꠇꠣꠝꠅ ꠇꠣꠁꠝ ꠞꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("AC6_5","074_6_5","ACT","6","5","5","ꠔꠦꠃ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠥꠡ ꠡꠣꠘ꠆ꠔꠤ ꠅꠁꠟꠣ, ꠔꠣꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠞ ꠁꠝꠣꠘꠦ ꠇꠣꠝꠤꠟ ꠡ꠆ꠔꠤꠚꠣꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠣ, ꠔꠣꠘ ꠟꠉꠦ ꠚꠤꠟꠤꠚ, ꠚꠈꠞ, ꠘꠤꠇꠣꠘꠞ, ꠔꠤꠝꠥꠘ, ꠙꠣꠞ꠆ꠝꠤꠘꠣ ꠀꠞ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ ꠐꠣꠃꠘꠞ ꠘꠄꠀ ꠁꠢꠥꠖꠤ ꠘꠤꠇꠥꠟꠣꠄꠞꠦ ꠛꠣꠍꠤꠀ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC6_6","074_6_6","ACT","6","6","6","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠅꠃ ꠡꠣꠔ ꠎꠘꠞꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠟꠦ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠖꠥꠀ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠔ ꠞꠣꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC6_7","074_6_7","ACT","6","7","7","ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠍꠤꠔ꠆ꠞꠤꠀ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠙꠃꠍꠤꠉꠦꠟ, ꠔꠦꠃ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠃꠝ꠆ꠝꠔꠞ ꠙꠞꠤꠝꠣꠘ ꠈꠥꠛ ꠎꠟꠖꠤ ꠇꠞꠤ ꠛꠣꠠꠔ ꠟꠣꠉꠟ, ꠁꠢꠥꠖꠤ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠝꠣꠎꠦꠅ ꠛꠃꠔ ꠎꠘꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC6_8","074_6_8","ACT","6","8","8","ꠡ꠆ꠔꠤꠚꠣꠘ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠀꠞ ꠢꠤꠝ꠆ꠝꠔꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ, ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠀꠞ ꠝꠥꠎꠦꠎꠣ ꠇꠣꠝ ꠇꠞꠔꠣ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC6_9","074_6_9","ACT","6","9","9","ꠁꠢꠥꠖꠤꠞ ꠎꠦ ꠝꠍꠤꠖꠞꠦ ꠀꠎꠣꠖ-ꠅꠀ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠝꠍꠤꠖ ꠒꠣꠇꠣ ꠅꠁꠔ, ꠢꠃ ꠝꠍꠤꠖꠞ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ, ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠇꠥꠞꠤꠘꠤ, ꠀꠟꠦꠇꠎꠣꠘꠖ꠆ꠞꠤꠀ, ꠇꠤꠟꠤꠇꠤꠀ ꠀꠞ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠦ ꠡ꠆ꠔꠤꠚꠣꠘꠞ ꠟꠉꠦ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠔꠞ꠆ꠇ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC6_10","074_6_10","ACT","6","10","10","ꠅꠁꠟꠦ ꠡ꠆ꠔꠤꠚꠣꠘꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠈꠥꠛ ꠀꠈꠟꠖꠣꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠣꠄ, ꠔꠣꠞꠣ ꠔꠣꠘ ꠟꠉꠦ ꠝꠣꠔꠤꠀ ꠇꠥꠟꠣꠁꠔ ꠙꠣꠞꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC6_11","074_6_11","ACT","6","11","11","ꠔꠦꠃ ꠔꠣꠞꠣ ꠇꠄꠎꠘ ꠛꠣꠎꠦ ꠝꠣꠘꠡꠞꠦ ꠊꠥꠡ ꠖꠤꠀ ꠅꠈꠣꠘ ꠢꠤꠇꠣꠁ ꠖꠤꠟ, “ꠔꠥꠝꠞꠣ ꠇꠁꠅ, ꠀꠝꠞꠣ ꠢꠥꠘꠍꠤ ꠅꠃ ꠛꠦꠐꠣꠄ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC6_12","074_6_12","ACT","6","12","12","ꠅꠔꠣ ꠇꠞꠤ ꠔꠣꠞꠣ ꠝꠣꠘꠡꠞꠦ, ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ, ꠀꠞ ꠀꠟꠤꠝ ꠡꠝꠣꠎꠞꠦ ꠡ꠆ꠔꠤꠚꠣꠘꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠛꠤꠉꠠꠣꠁꠟ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠎꠛꠞꠖꠡ꠆ꠔꠤ ꠇꠞꠤ ꠗꠞꠤꠀ ꠖꠦꠡꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠍꠣꠝꠘꠦ ꠛꠤꠌꠣꠞꠅ ꠀꠘꠟ। ");
INSERT INTO syls_vpl VALUES ("AC6_13","074_6_13","ACT","6","13","13","ꠀꠞ ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠅꠇꠟꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠛꠦꠐꠣꠄ ꠢꠣꠝꠦꠡꠣ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠞ ꠅꠃ ꠙꠛꠤꠔ꠆ꠞ ꠝꠥꠇꠣꠝꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦꠅ ꠝꠣꠔꠦ। ");
INSERT INTO syls_vpl VALUES ("AC6_14","074_6_14","ACT","6","14","14","ꠀꠝꠞꠣ ꠢꠥꠘꠍꠤ ꠢꠦ ꠇꠞ, ꠢꠃ ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣꠄ ꠁ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠜꠣꠋꠉꠤꠟꠤꠛ ꠀꠞ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦ ꠡꠞꠤꠅꠔ ꠕꠁꠀ ꠉꠦꠍꠂꠘ, ꠁꠔꠣ ꠛꠖꠟꠣꠁꠟꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC6_15","074_6_15","ACT","6","15","15","ꠁ ꠡꠝꠄ ꠎꠦꠞꠣ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠔ ꠛꠅꠀꠔ ꠀꠍꠟꠣ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠗꠤꠀꠘ ꠗꠞꠤ ꠡ꠆ꠔꠤꠚꠣꠘꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣ, ꠔꠣꠘ ꠝꠥꠈ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠝꠥꠈꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC7_1","074_7_1","ACT","7","1","1","ꠔꠦꠃ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠡ꠆ꠔꠤꠚꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁꠔꠣ ꠇꠤꠔꠣ ꠢꠣꠍꠣꠃ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC7_2","074_7_2","ACT","7","2","2","ꠡ꠆ꠔꠤꠚꠣꠘꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠛꠣꠛꠣ ꠅꠇꠟ, ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣꠞ ꠝꠥꠟ ꠛꠣꠚ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠎꠦꠛꠟꠣ ꠢꠣꠞꠣꠘ ꠡꠢꠞꠅ ꠞꠅꠀꠞ ꠀꠉꠦ ꠝꠦꠡꠙꠔꠣꠝꠤꠀꠔ ꠀꠍꠟꠣ, ꠢꠃ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠖꠤꠖꠣꠞ ꠖꠤꠀ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC7_3","074_7_3","ACT","7","3","3","‘ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠖꠦꠡ ꠀꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠍꠣꠠꠤꠀ ꠞꠅꠀꠘꠣ ꠖꠦꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠦꠈꠣꠁꠝꠥ ꠢꠃ ꠖꠦꠡꠅ ꠎꠣꠅ।’ ");
INSERT INTO syls_vpl VALUES ("AC7_4","074_7_4","ACT","7","4","4","ꠅꠃ ꠔꠣꠁꠘ ꠇꠟꠖꠤꠅ ꠅꠇꠟꠞ ꠛꠣꠛꠤꠟ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ, ꠢꠣꠞꠣꠘ ꠡꠢꠞꠅ ꠛꠡꠔ ꠇꠞꠟꠣ; ꠀꠞ ꠔꠣꠘ ꠛꠣꠚꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠢꠘ ꠕꠣꠇꠤ ꠁ ꠖꠦꠡꠅ ꠀꠘꠍꠂꠘ, ꠎꠦꠈꠣꠘꠅ ꠀꠙꠘꠣꠞꠣ ꠅꠈꠘ ꠛꠡꠔ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_5","074_7_5","ACT","7","5","5","ꠔꠣ-ꠅ ꠀꠟ꠆ꠟꠣꠄ ꠁꠘꠅ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠟꠔꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠖꠤꠟꠣ ꠘꠣ, ꠙꠣꠅ ꠕꠁꠛꠣꠞ ꠎꠣꠉꠣ ꠈꠣꠘꠅ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠟꠉꠦ ꠅꠀꠖꠣ ꠇꠞꠟꠣ, ꠔꠣꠘꠞꠦ ꠀꠞ ꠔꠣꠘ ꠅꠀꠞꠤꠡ ꠅꠇꠟꠞꠦ ꠅꠃ ꠎꠝꠤꠘꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠛꠣ, ꠎꠥꠖꠤꠅ ꠁ ꠡꠝꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠇꠥꠘꠥ ꠀꠅꠟꠣꠖ ꠅꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_6","074_7_6","ACT","7","6","6","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠛꠤꠖꠦꠡꠅ ꠝꠥꠍꠣꠚꠤꠞ ꠞꠁꠛꠣ, ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞꠦꠖꠤ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠁꠛꠣ, ꠀꠞ ꠌꠣꠁꠞ-ꠡ ꠛꠞꠍ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠌꠟꠛ।’ ");
INSERT INTO syls_vpl VALUES ("AC7_7","074_7_7","ACT","7","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠄꠅꠈꠣꠘꠅ ꠇꠁꠟꠣ, ‘ꠎꠦ ꠎꠣꠔꠤꠄ ꠔꠣꠞꠣꠞꠦꠖꠤ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠁꠛꠣ, ꠀꠝꠤ ꠢꠤ ꠎꠣꠔꠤꠞ ꠛꠤꠌꠣꠞ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠝꠥ; ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠢꠤ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠀ, ꠅꠃ ꠎꠣꠉꠣꠔ ꠀꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠛꠣ।’ ");
INSERT INTO syls_vpl VALUES ("AC7_8","074_7_8","ACT","7","8","8","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ; ꠢꠦꠡꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠎꠘꠝ ꠅꠁꠟ, ꠀꠞ ꠔꠣꠁꠘ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟꠣ। ꠛꠣꠖꠦ ꠁꠍꠢꠣꠇꠦ ꠁꠀꠇꠥꠛꠞꠦ, ꠀꠞ ꠁꠀꠇꠥꠛꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠣꠞꠅꠎꠘ ꠛꠣꠚꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_9","074_7_9","ACT","7","9","9","“ꠢꠃ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠣꠚ ꠅꠇꠟꠦ ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠁꠃꠍꠥꠚꠞꠦ ꠛꠦꠌꠤꠟꠣꠁꠟꠦ, ꠔꠣꠘꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠘꠦꠅꠀ ꠅꠁꠟ। ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣ ꠁꠃꠍꠥꠚꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC7_10","074_7_10","ACT","7","10","10","ꠔꠣꠁꠘ ꠁꠃꠍꠥꠚꠞꠦ ꠢꠇꠟ ꠔꠇꠟꠤꠚ ꠕꠣꠇꠤ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠟꠣ, ꠝꠤꠡꠞꠞ ꠛꠣꠖꠡꠣ ꠚꠦꠞꠣꠃꠘꠞ ꠘꠎꠞꠅ ꠖꠄꠀ ꠀꠞ ꠇꠣꠝꠤꠀꠛꠤ ꠖꠣꠘ ꠇꠞꠟꠣ; ꠔꠦꠃ ꠚꠦꠞꠣꠃꠘꠦ ꠔꠣꠘꠞꠦ ꠝꠤꠡꠞꠞ ꠢꠣꠇꠤꠝ ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠞꠣꠎꠛꠣꠠꠤꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣꠞ ꠜꠣꠞ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_11","074_7_11","ACT","7","11","11","ꠛꠣꠖꠦ ꠙꠥꠞꠣ ꠝꠤꠡꠞ ꠀꠞ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠅ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠟ ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠞ ꠈꠥꠛ ꠖꠥꠞ꠆ꠉꠔꠤ ꠅꠁꠍꠤꠟ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠅ ꠈꠣꠘꠤꠞ ꠅꠜꠣꠛꠅ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_12","074_7_12","ACT","7","12","12","ꠅꠁꠟꠦ ꠝꠤꠡꠞꠅ ꠚꠡꠟ ꠀꠍꠦ ꠢꠥꠘꠤꠀ, ꠁꠀꠇꠥꠛꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞꠦ ꠙꠄꠟꠣ ꠛꠣꠞ ꠢꠤꠈꠣꠘꠅ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_13","074_7_13","ACT","7","13","13","ꠛꠣꠖꠦ ꠖꠥꠍꠞꠣꠛꠣꠞꠞ ꠛꠣꠟꠣ ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ ꠔꠣꠁꠘ ꠇꠦ, ꠀꠞ ꠚꠦꠞꠣꠃꠘꠦ ꠁꠃꠍꠥꠚꠞ ꠙꠞꠤꠛꠣꠞꠞꠦ ꠌꠤꠘ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_14","074_7_14","ACT","7","14","14","ꠁꠃꠍꠥꠚꠦ ꠔꠣꠘ ꠛꠣꠛꠣ ꠁꠀꠇꠥꠛ ꠀꠞ ꠘꠤꠎꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠝꠤꠟꠣꠁꠀ ꠢꠇ꠆ꠇꠟꠔꠣꠄ ꠙꠌꠔ꠆ꠔꠁꠞ ꠎꠘꠞꠦ ꠈꠛꠞꠖꠤ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_15","074_7_15","ACT","7","15","15","ꠁꠀꠇꠥꠛ ꠝꠤꠡꠞꠅ ꠀꠁꠟꠣ, ꠢꠦꠡꠦ ꠔꠣꠁꠘ ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠅ ꠝꠣꠞꠣ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_16","074_7_16","ACT","7","16","16","ꠔꠣꠞꠣꠞ ꠟꠣꠡ ꠡꠤꠈꠤꠝꠅ ꠀꠘꠤꠀ ꠇꠄꠛꠞ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠁ ꠇꠛꠞꠡ꠆ꠕꠣꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠡꠤꠈꠤꠝ ꠡꠢꠞꠞ ꠢꠝꠥꠞꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠞꠥꠙꠣꠞ ꠐꠦꠇꠣ ꠖꠤꠀ ꠈꠞꠤꠖ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_17","074_7_17","ACT","7","17","17","“ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠤꠟꠣ, ꠢꠤ ꠅꠀꠖꠣ ꠙꠥꠞꠘ ꠅꠀꠞ ꠡꠝꠄ ꠎꠦꠛꠟꠣ ꠇꠣꠍꠣꠁ ꠉꠦꠟ, ꠁ ꠡꠝꠄ ꠝꠤꠡꠞꠅ ꠀꠝꠞꠣꠞ ꠝꠣꠘꠡꠞ ꠙꠞꠤꠝꠣꠘ ꠛꠃꠔ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC7_18","074_7_18","ACT","7","18","18","ꠢꠦꠡꠦ ꠝꠤꠡꠞꠅ ꠄꠇ ꠘꠄꠀ ꠛꠣꠖꠡꠣ ꠅꠁꠟꠣ, ꠄꠁꠘ ꠁꠃꠍꠥꠚꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠎꠣꠘꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_19","074_7_19","ACT","7","19","19","ꠢꠤ ꠛꠣꠖꠡꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠐꠉꠣꠁꠔꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠈꠥꠛ ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣ, ꠔꠣꠘ ꠘꠤꠅꠔ ꠀꠍꠤꠟ ꠄꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠎꠘꠝꠞ ꠛꠣꠖꠦꠃ ꠎꠣꠔꠦ ꠛꠣꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠄ, ꠀꠞ ꠔꠣꠞꠣ ꠝꠞꠤ ꠎꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("AC7_20","074_7_20","ACT","7","20","20","ꠢꠃ ꠡꠝꠄ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠎꠘꠝ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠔꠣꠁꠘ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠀꠍꠟꠣ। ꠔꠤꠘ ꠝꠣꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠁꠘ ꠔꠣꠘ ꠝꠣ-ꠛꠣꠚꠞ ꠛꠣꠠꠤꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_21","074_7_21","ACT","7","21","21","ꠛꠣꠖꠦ ꠔꠣꠘꠞꠦ ꠛꠣꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠟꠦ, ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠠꠤꠄ ꠔꠣꠘꠞꠦ ꠘꠤꠀ ꠘꠤꠎꠞ ꠙꠥꠀ ꠛꠣꠘꠣꠁꠀ ꠙꠣꠟꠤꠀ ꠛꠠ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_22","074_7_22","ACT","7","22","22","ꠝꠥꠍꠣ ꠝꠤꠡꠞꠤꠅ ꠁꠟꠤꠝ ꠀꠞ ꠀꠖꠛ-ꠈꠣꠁꠍꠟꠔꠦ ꠛꠠ ꠅꠁꠟꠣ, ꠔꠣꠁꠘ ꠇꠕꠣꠄ ꠀꠞ ꠇꠣꠝꠦ ꠢꠤꠝ꠆ꠝꠔꠤ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_23","074_7_23","ACT","7","23","23","ꠛꠣꠖꠦ ꠝꠥꠍꠣꠞ ꠛꠄꠅꠡ ꠎꠦꠛꠟꠣ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠅꠁꠟ, ꠅꠃ ꠔꠣꠘ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠘꠤꠎꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠤ ꠜꠣꠁ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC7_24","074_7_24","ACT","7","24","24","ꠔꠣꠁꠘ ꠛꠣꠞ ꠅꠁꠀ ꠖꠦꠈꠟꠣ, ꠄꠇꠎꠘ ꠝꠤꠡꠞꠤꠄ ꠄꠇ ꠁꠍꠞꠣꠁꠟꠤꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠦꠞ, ꠔꠣꠁꠘ ꠢꠃ ꠁꠍꠞꠣꠁꠟꠤꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣꠔ ꠉꠦꠟꠣ, ꠀꠞ ꠝꠤꠡꠞꠤꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠀ ꠄꠞ ꠛꠖꠟꠣ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_25","074_7_25","ACT","7","25","25","ꠝꠥꠍꠣꠄ ꠝꠘꠦ ꠇꠞꠍꠤꠟꠣ ꠔꠣꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠛꠣ ꠎꠦꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠖꠤꠀꠃ ꠔꠣꠞꠣꠞꠦ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠛꠣ; ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠁꠔꠣ ꠛꠥꠎꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_26","074_7_26","ACT","7","26","26","ꠛꠣꠖꠞ ꠖꠤꠘ ꠝꠥꠍꠣꠄ ꠖꠥꠁꠎꠘ ꠁꠍꠞꠣꠁꠟꠤꠞꠦ ꠝꠣꠁꠞ ꠇꠞꠣꠔ ꠖꠦꠈꠤꠀ, ꠔꠣꠞꠣꠞꠦ ꠝꠤꠟ-ꠝꠤꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠇꠁꠟꠣ, ‘ꠅꠂ ꠔꠥꠝꠞꠣ ꠔ ꠜꠣꠁ ꠜꠣꠁ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞ ꠟꠉꠦ ꠝꠣꠞꠣ-ꠝꠣꠞꠤ ꠇꠞꠞꠣꠄ?’ ");
INSERT INTO syls_vpl VALUES ("AC7_27","074_7_27","ACT","7","27","27","ꠅꠁꠟꠦ ꠎꠦ ꠝꠣꠘꠡꠦ ꠛꠣꠖ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠣꠔ ꠀꠍꠤꠟ, ꠢꠦ ꠝꠥꠍꠣꠞꠦ ꠑꠦꠟꠣ ꠝꠣꠞꠤ ꠚꠣꠟꠣꠁꠀ ꠇꠁꠟ, ‘ꠅꠛꠣ, ꠔꠥꠝꠣꠞꠦ ꠇꠦꠉꠤꠄ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠡꠣꠟꠤꠡ ꠀꠞ ꠢꠣꠇꠤꠝ ꠛꠣꠘꠣꠁꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("AC7_28","074_7_28","ACT","7","28","28","ꠇꠣꠁꠟ ꠎꠦꠟꠣ ꠢꠃ ꠝꠤꠡꠞꠤꠞꠦ ꠈꠥꠘ ꠇꠞꠍ, ꠀꠝꠣꠞꠦꠅ ꠅꠟꠣ ꠇꠞꠔꠣꠄ ꠌꠣꠅ ꠘꠤ?’ ");
INSERT INTO syls_vpl VALUES ("AC7_29","074_7_29","ACT","7","29","29","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠝꠥꠍꠣꠄ ꠜꠣꠉꠤꠀ ꠝꠣꠖꠤꠀꠘ ꠖꠦꠡꠅ ꠉꠦꠟꠣꠉꠤ, ꠀꠞ ꠢꠤꠈꠣꠘꠅ ꠔꠣꠘ ꠖꠥꠁ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC7_30","074_7_30","ACT","7","30","30","“ꠛꠣꠖꠦ ꠀꠞꠅ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠉꠥꠎꠞꠤ ꠉꠦꠟꠦ, ꠔꠥꠞ ꠙꠣꠠꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠝꠞꠥꠜꠥꠝꠤꠔ, ꠀꠉꠥꠁꠘ ꠎꠣꠟꠣꠁꠟ ꠎꠋꠟꠣꠞ ꠝꠣꠎ ꠕꠘꠦ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠝꠥꠍꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_31","074_7_31","ACT","7","31","31","ꠝꠥꠍꠣꠄ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠄꠇ꠆ꠇꠦꠞꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠉꠦꠟꠣ, ꠀꠞ ꠜꠣꠟꠣ ꠇꠞꠤ ꠖꠦꠈꠣꠞ ꠘꠤꠅꠔꠦ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC7_32","074_7_32","ACT","7","32","32","‘ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠀꠟ꠆ꠟꠣ।’ ꠔꠦꠃ ꠝꠥꠍꠣꠄ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠣ ꠡꠥꠞꠥ ꠇꠞꠟꠣ, ꠀꠞ ꠜꠣꠟꠣ ꠇꠞꠤ ꠖꠦꠈꠣꠞ ꠡꠣꠅꠡ ꠙꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_33","074_7_33","ACT","7","33","33","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠣꠞ ꠙꠣꠅꠞ ꠎꠥꠔꠣ ꠈꠥꠟꠤꠟꠣꠅ, ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠎꠦꠘꠅ ꠃꠛꠣꠁꠍ ꠁꠈꠣꠘ ꠙꠣꠇ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_34","074_7_34","ACT","7","34","34","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠀꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠅꠇꠟꠞ ꠔꠇꠟꠤꠚ ꠖꠦꠈꠍꠤ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠢꠥꠘꠍꠤ, ꠔꠣꠞꠣꠞꠦ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠤ, ꠅꠈꠘ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠚꠤꠞꠔ ꠙꠣꠑꠣꠁꠝꠥ।’ ");
INSERT INTO syls_vpl VALUES ("AC7_35","074_7_35","ACT","7","35","35","“ꠄꠁꠘ ꠢꠃ ꠝꠥꠍꠣ, ꠎꠣꠞꠦ ꠁꠍꠞꠣꠁꠟꠤ ꠅꠇꠟꠦ ꠅꠃ ꠇꠕꠣ ꠇꠁꠀ ꠚꠤꠞꠔ ꠖꠤꠍꠤꠟ, ꠇꠦ ꠔꠥꠝꠣꠞꠦ ꠡꠣꠟꠤꠡ ꠀꠞ ꠢꠣꠇꠤꠝ ꠛꠣꠘꠣꠁꠍꠦ? ꠔꠣꠘꠞꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠎꠋꠟꠣꠞ ꠝꠣꠎꠦ ꠖꠦꠈꠣ ꠖꠤꠍꠟꠣ, ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠀꠔꠣꠘꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠡꠣꠟꠤꠡ ꠀꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠛꠣꠘꠣꠁꠀ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_36","074_7_36","ACT","7","36","36","ꠀꠞ ꠅꠃ ꠝꠥꠍꠣꠄꠃ ꠝꠤꠡꠞꠞ ꠘꠤꠟ ꠖꠞꠤꠀ ꠀꠞ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠀꠞ ꠝꠥꠎꠦꠎꠣ ꠇꠣꠝ ꠇꠞꠤꠀ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠁꠍꠞꠣꠁꠟꠤ ꠅꠇꠟꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_37","074_7_37","ACT","7","37","37","“ꠄꠁꠘ ꠢꠃ ꠝꠥꠍꠣ, ꠎꠦꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠇꠁꠍꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ, ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠎꠘ ꠘꠛꠤꠞꠦ ꠛꠦꠎꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_38","074_7_38","ACT","7","38","38","ꠅꠃ ꠝꠥꠍꠣꠃ ꠔ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠀꠍꠟꠣ। ꠀꠞ ꠎꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠥꠞ ꠙꠣꠠꠅ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠤꠟꠣ, ꠅꠃ ꠝꠥꠍꠣꠞ ꠟꠉꠦꠃ ꠔꠣꠁꠘ ꠝꠣꠔꠤꠍꠟꠣ। ꠀꠞ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠘ꠆ꠖꠣ-ꠇꠣꠟꠣꠝ ꠅꠃ ꠝꠥꠍꠣꠞ ꠉꠦꠍꠦꠃ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC7_39","074_7_39","ACT","7","39","39","“ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠦ ꠝꠥꠍꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠔꠣ ꠌꠣꠁꠟꠣ ꠘꠣ, ꠔꠣꠞꠣ ꠝꠥꠍꠣꠞꠦ ꠢꠞꠣꠁ ꠕꠁꠀ ꠝꠘꠦ ꠝꠘꠦ ꠢꠤꠞꠛꠣꠞ ꠝꠤꠡꠞꠞ ꠛꠣꠄ ꠘꠤꠅꠔ ꠇꠞꠤꠀ ꠢꠣꠞꠥꠘꠞꠦ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC7_40","074_7_40","ACT","7","40","40","‘ꠀꠝꠞꠣꠞꠦ ꠙꠕ ꠌꠤꠘꠣꠁꠀ ꠟꠁꠀ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠖꠦꠛꠔꠣ ꠛꠣꠘꠣꠁ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠇꠣꠞꠘ ꠎꠦ ꠝꠥꠍꠣꠄ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠔꠣꠘ ꠖꠡꠣ ꠇꠤꠔꠣ ꠅꠁꠍꠦ, ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ ꠘꠣ।’ ");
INSERT INTO syls_vpl VALUES ("AC7_41","074_7_41","ACT","7","41","41","ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠉꠞꠥꠞ ꠛꠣꠍꠥꠞꠞ ꠟꠣꠈꠣꠘ ꠄꠇ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠟꠣ, ꠀꠞ ꠅꠃ ꠝꠥꠞ꠆ꠔꠤꠞ ꠘꠣꠝꠦ ꠛꠟꠤ ꠖꠤꠟꠣ, ꠘꠤꠎꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠥꠞ꠆ꠔꠤꠞꠦ ꠟꠁꠀ ꠔꠣꠞꠣ ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_42","074_7_42","ACT","7","42","42","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠘꠣꠞꠣꠎ ꠅꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉ ꠍꠣꠠꠤ ꠖꠤꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠀꠍꠝꠣꠘꠞ ꠌꠣꠘ-ꠡꠥꠞꠥꠎ, ꠔꠦꠞꠣꠞ ꠙꠥꠎꠣꠔ ꠛꠥꠠꠣꠁ ꠕꠁꠟꠣ; ꠎꠦꠟꠣ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠍꠂꠘ: ꠅ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ, ꠝꠞꠥꠜꠥꠝꠤꠔ ꠢꠤ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠘꠥ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠟꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("AC7_43","074_7_43","ACT","7","43","43","ꠘꠣ, ꠔꠥꠝꠞꠣ ꠔ ꠝꠥꠟꠇ ꠖꠦꠛꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤ, ꠀꠞ ꠞꠤꠚꠘ ꠖꠦꠛꠔꠣꠞ ꠔꠦꠞꠣ ꠛꠣꠘꠣꠁ ꠇꠣꠘ꠆ꠖꠅ ꠟꠁꠀ ꠊꠥꠞꠍ। ꠢꠃ ꠖꠥꠁꠅ ꠙꠥꠔꠥꠟ ꠔ ꠙꠥꠎꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠛꠣꠘꠣꠁꠍꠟꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠛꠤꠟ ꠖꠦꠡꠞ ꠢꠙꠣꠞꠅ ꠛꠘꠛꠣꠡ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("AC7_44","074_7_44","ACT","7","44","44","ꠔꠦ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥꠞ ꠇꠣꠛꠣ ꠡꠞꠤꠚ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠀꠍꠤꠟ। ꠔꠣꠁꠘ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠔꠥꠝꠤ ꠎꠦꠟꠣꠈꠣꠘ ꠘꠇꠡꠣ ꠖꠦꠈꠟꠣꠄ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠁꠐꠣ ꠔꠤꠀꠞ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("AC7_45","074_7_45","ACT","7","45","45","ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠦ ꠢꠤ ꠇꠣꠛꠣ ꠡꠞꠤꠚ ꠙꠣꠁꠀ, ꠔꠣꠞꠣꠞ ꠀꠝꠤꠞ ꠁꠃꠍꠣꠞ ꠀꠔꠣꠘꠦ ꠘꠤꠎꠞ ꠟꠉꠦ ꠇꠞꠤ ꠀꠝꠞꠣꠞ ꠁ ꠖꠦꠡꠅ ꠀꠘꠍꠤꠟꠣ, ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠤ ꠖꠦꠡꠅ ꠢꠣꠝꠣꠁꠍꠤꠟ ꠁ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠢꠤꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠤꠍꠟꠣ। ꠢꠤ ꠔꠣꠝ꠆ꠛꠥ ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞ ꠀꠝꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠖꠦꠡꠅ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC7_46","074_7_46","ACT","7","46","46","“ꠖꠣꠃꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠤꠟꠣ, ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠄꠇꠈꠣꠘ ꠊꠞ ꠛꠣꠘꠣꠁꠛꠣꠞ ꠀꠞꠎꠤ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_47","074_7_47","ACT","7","47","47","ꠅꠁꠟꠦ ꠢꠎꠞꠔ ꠍꠥꠟꠣꠁꠝꠣꠘꠦ ꠔꠣꠘ ꠟꠣꠉꠤ ꠢꠤ ꠊꠞ ꠛꠣꠘꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_48","074_7_48","ACT","7","48","48","ꠔꠣ-ꠅ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣ ꠔ ꠝꠣꠘꠡꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠊꠞꠅ ꠛꠡꠔ ꠇꠞꠂꠘ ꠘꠣ; ꠎꠦꠟꠣ ꠘꠛꠤꠄ ꠇꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("AC7_49","074_7_49","ACT","7","49","49","ꠝꠣꠛꠥꠖꠦ ꠇꠂꠘ, ꠛꠦꠢꠦꠡ꠆ꠔ ꠀꠝꠣꠞ ꠔꠈ꠆ꠔ, ꠖꠥꠘꠤꠀ ꠀꠝꠣꠞ ꠙꠣꠅ ꠕꠁꠛꠣꠞ ꠎꠣꠉꠣ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠤꠎꠣꠔ ꠊꠞ ꠛꠣꠘꠣꠁꠛꠣꠄ? ꠀꠝꠣꠞ ꠎꠤꠞꠣꠘꠤꠞ ꠎꠣꠉꠣ ꠇꠥꠀꠁ? ");
INSERT INTO syls_vpl VALUES ("AC7_50","074_7_50","ACT","7","50","50","ꠁ ꠢꠇ꠆ꠇꠟꠔꠣ ꠇꠤꠔꠣ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠀꠔꠦ ꠛꠣꠘꠣꠁꠍꠤ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("AC7_51","074_7_51","ACT","7","51","51","“ꠅ ꠉꠣꠠꠔꠦꠠꠣꠞ ꠎꠣꠔ! ꠇꠣꠘ ꠀꠞ ꠖꠤꠟꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠣꠁꠟ ꠎꠣꠔ! ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠕꠅ। ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ ꠎꠦꠟꠣ ꠀꠍꠟꠣ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠅꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("AC7_52","074_7_52","ACT","7","52","52","ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠦ ꠇꠥꠘ ꠘꠛꠤꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠍꠂꠘ ꠘꠣ? ꠔꠣꠞꠣ ꠔ ꠢꠃ ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦꠅ ꠝꠣꠞꠍꠦ, ꠎꠦꠞꠣ ꠀꠉꠦ ꠁ ꠖꠤꠘꠖꠣꠞ ꠎꠘ ꠀꠁꠛꠣꠞ ꠇꠕꠣ ꠄꠟꠣꠘ ꠇꠞꠍꠂꠘ। ꠅꠃ ꠖꠤꠘꠖꠣꠞ ꠎꠘꠞꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠅ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("AC7_53","074_7_53","ACT","7","53","53","ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤ ꠘꠣꠎꠤꠟ ꠅꠀ ꠡꠞꠤꠅꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠅꠁꠟꠦ ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠍ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC7_54","074_7_54","ACT","7","54","54","ꠁꠔꠣ ꠢꠥꠘꠤꠀꠃ ꠔꠣꠞꠣ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠉꠦꠟꠣ, ꠀꠞ ꠖꠣꠔ ꠇꠤꠠꠤ-ꠝꠤꠠꠤ ꠇꠞꠣ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_55","074_7_55","ACT","7","55","55","ꠅꠁꠟꠦ ꠡ꠆ꠔꠤꠚꠣꠘꠦ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠛꠣꠄ ꠗꠤꠀꠘ ꠗꠞꠤ ꠌꠣꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤ ꠖꠦꠈꠟꠣ, ꠀꠞ ꠁꠍꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘ ꠛꠣꠎꠥꠔ ꠃꠛꠣ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_56","074_7_56","ACT","7","56","56","ꠔꠦꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠖꠦꠈꠞꠣꠝ ꠛꠦꠢꠦꠡ꠆ꠔ ꠈꠥꠟꠣ ꠀꠍꠦ, ꠀꠞ ꠁꠍꠣ ꠛꠤꠘ-ꠀꠖꠝ ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC7_57","074_7_57","ACT","7","57","57","ꠀꠞ ꠔꠣꠞꠣ ꠇꠣꠘꠅ ꠀꠋꠉꠥꠟ ꠖꠤꠀ ꠄꠇꠟꠉꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠡ꠆ꠔꠤꠚꠣꠘꠞ ꠃꠙꠞꠦ ꠃꠠꠤꠀ ꠉꠤꠀ ꠙꠠꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_58","074_7_58","ACT","7","58","58","ꠔꠣꠘꠞꠦ ꠐꠣꠘꠤꠀ ꠡꠢꠞꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠣꠔ ꠟꠣꠉꠟꠣ; ꠀꠞ ꠛꠣꠖꠤ ꠅꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠇꠣꠙꠠ ꠈꠥꠟꠤꠀ ꠡꠃꠟ ꠘꠣꠝꠞ ꠄꠇ ꠎꠥꠀꠘꠞ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC7_59","074_7_59","ACT","7","59","59","ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠡ꠆ꠔꠤꠚꠣꠘꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠖꠥꠀ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠅ ꠝꠣꠟꠤꠇ ꠁꠍꠣ, ꠀꠝꠣꠞ ꠞꠥꠢꠥꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC7_60","074_7_60","ACT","7","60","60","ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠀꠐꠥ ꠉꠣꠟꠣ ꠖꠤꠀ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠝꠣꠟꠤꠇ, ꠄꠞꠣꠞ ꠁ ꠉꠥꠘꠣꠞꠦ ꠀꠝꠟꠅ ꠗꠞꠤꠅ ꠘꠣ।” ꠅꠈꠣꠘ ꠇꠁꠀꠃ ꠔꠣꠁꠘ ꠀꠈꠦꠞꠤ ꠖꠝ ꠍꠣꠠꠤ ꠖꠤꠟꠣ। ꠀꠞ ꠡꠃꠟꠦ ꠢꠘꠅ ꠡ꠆ꠔꠤꠚꠣꠘꠞ ꠈꠥꠘꠞ ꠢꠥꠇꠥꠝꠞ ꠟꠉꠦ ꠡꠣꠄ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_1","074_8_1","ACT","8","1","1","ꠢꠤꠖꠤꠘ ꠕꠣꠇꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠎꠝꠣꠔꠞ ꠃꠙꠞꠦ ꠈꠥꠛ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠈꠣꠠꠣ ꠅꠁꠟ, ꠄꠞꠟꠣꠉꠤ ꠈꠣꠟꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠛꠣꠖꠦ ꠀꠞ ꠢꠇꠟꠦꠃ ꠄꠢꠥꠖꠤꠀ ꠀꠞ ꠡꠝꠞꠤꠀ ꠄꠟꠣꠇꠣꠞ ꠎꠣꠉꠣꠄ ꠎꠣꠉꠣꠄ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_2","074_8_2","ACT","8","2","2","ꠇꠄꠎꠘꠦ ꠝꠤꠟꠤꠀ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠝꠣꠘꠥꠡ ꠡ꠆ꠔꠤꠚꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠟꠣ ꠀꠞ ꠔꠣꠘ ꠟꠣꠉꠤ ꠛꠃꠔ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_3","074_8_3","ACT","8","3","3","ꠅꠁꠟꠦ ꠡꠃꠟꠦ ꠎꠝꠣꠔꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠊꠞꠅ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠁꠝꠣꠘꠖꠣꠞ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤ ꠐꠣꠘꠤꠀ ꠍꠦꠌꠠꠣꠁꠀ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠢꠣꠞꠣꠘꠤꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_4","074_8_4","ACT","8","4","4","ꠔꠦꠃ ꠎꠦꠞꠣ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠍꠤꠟ, ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟ ꠎꠣꠉꠣꠔ ꠊꠥꠞꠤ ꠊꠥꠞꠤ ꠁꠘ꠆ꠎꠤꠟꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_5","074_8_5","ACT","8","5","5","ꠀꠞ ꠚꠤꠟꠤꠚ ꠡꠝꠞꠤꠀꠞ ꠄꠇ ꠡꠢꠞꠅ ꠉꠤꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_6","074_8_6","ACT","8","6","6","ꠝꠣꠘꠡꠦ ꠚꠤꠟꠤꠚꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠀꠞ ꠔꠣꠘ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠅꠇꠟ ꠖꠦꠈꠤꠀ, ꠗꠤꠀꠘ ꠗꠞꠤ ꠄꠇ ꠖꠤꠟꠦ ꠔꠣꠘ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_7","074_8_7","ACT","8","7","7","ꠇꠣꠞꠘ ꠛꠃꠔꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠥꠔ ꠅꠇꠟ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠍꠣꠠꠤꠀ ꠉꠦꠟ, ꠀꠞ ꠛꠃꠔ ꠅꠞ꠆ꠖꠋ ꠛꠦꠝꠣꠞꠤ ꠀꠞ ꠟꠦꠋꠠꠣ ꠅꠇꠟ ꠜꠣꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_8","074_8_8","ACT","8","8","8","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠤ ꠡꠢꠞꠞ ꠝꠣꠘꠥꠡ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_9","074_8_9","ACT","8","9","9","ꠅꠁꠟꠦ ꠢꠤꠈꠣꠘꠅ ꠍꠣꠁꠝꠘ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠦ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠎꠣꠖꠥ-ꠐꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠔ, ꠡꠝꠞꠤꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠗꠣꠘ꠆ꠖꠣ ꠟꠣꠉꠣꠁꠀ ꠢꠦ ꠘꠤꠎꠞꠦ ꠄꠇꠎꠘ ꠇꠣꠝꠤꠟ ꠙꠤꠞ ꠇꠁꠀ ꠖꠣꠛꠤ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("AC8_10","074_8_10","ACT","8","10","10","ꠀꠞ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟꠦ ꠔꠣꠞ ꠇꠕꠣꠞ ꠖꠣꠝ ꠖꠤꠔ, ꠝꠣꠘꠡꠦ ꠇꠁꠔ, ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠇꠥꠖꠞꠔꠞꠦ ꠈꠣꠍ ꠇꠥꠖꠞꠔ ꠇꠂꠘ, ꠁ ꠛꠦꠐꠣ ꠅꠁꠟ ꠢꠃ ꠈꠣꠍ ꠇꠥꠖꠞꠔꠤ ꠛꠦꠐꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_11","074_8_11","ACT","8","11","11","ꠝꠣꠘꠡꠦꠅ ꠔꠣꠞ ꠇꠕꠣꠝꠔ ꠌꠟꠔ ꠇꠣꠞꠘ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠢꠦ ꠔꠣꠞ ꠎꠣꠖꠥ-ꠐꠥꠘꠣ ꠖꠦꠈꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠣꠘꠣꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC8_12","074_8_12","ACT","8","12","12","ꠅꠁꠟꠦ ꠚꠤꠟꠤꠚꠦ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠔꠛꠟꠤꠉꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ, ꠁ ꠡꠝꠄ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠀꠁꠀ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_13","074_8_13","ACT","8","13","13","ꠢꠃ ꠍꠣꠁꠝꠘꠅ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠤꠀ ꠚꠤꠟꠤꠚꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠁꠟꠣ, ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠀꠞ ꠛꠠ ꠛꠠ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠢꠣꠍꠤꠟ ꠅꠞ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_14","074_8_14","ACT","8","14","14","ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣ, ꠡꠝꠞꠤꠀꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_15","074_8_15","ACT","8","15","15","ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("AC8_16","074_8_16","ACT","8","16","16","ꠇꠣꠞꠘ ꠅꠈꠘꠅ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠘꠣꠎꠤꠟ ꠅꠁꠍꠦ ꠘꠣ, ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC8_17","074_8_17","ACT","8","17","17","ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠔ ꠞꠣꠈꠟꠣ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_18","074_8_18","ACT","8","18","18","ꠀꠞ ꠍꠣꠁꠝꠘꠦ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠀꠔ ꠞꠣꠈꠣꠞ ꠇꠣꠞꠘꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠝꠤꠟꠦꠞ, ꠅꠃ ꠔꠣꠁꠘ ꠐꠦꠇꠣ ꠀꠘꠤꠀ ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠖꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC8_19","074_8_19","ACT","8","19","19","“ꠀꠝꠣꠞꠦꠅ ꠅꠃ ꠈꠦꠝꠔꠣ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠀꠝꠤ ꠇꠦꠃꠞꠞ ꠃꠙꠞꠦ ꠀꠔ ꠞꠣꠈꠟꠦ ꠢꠦ-ꠅ ꠅꠃ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC8_20","074_8_20","ACT","8","20","20","ꠙꠤꠔꠞꠦ ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠞꠥꠙꠣ ꠔꠥꠝꠣꠞ ꠟꠉꠦꠃ ꠛꠤꠘꠣꠡ ꠅꠃꠇ, ꠔꠥꠝꠤ ꠝꠘꠅ ꠇꠞꠍ ꠀꠟ꠆ꠟꠣꠞ ꠖꠣꠘ ꠐꠦꠇꠣꠖꠤ ꠈꠞꠤꠖ ꠇꠞꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC8_21","074_8_21","ACT","8","21","21","ꠀꠝꠞꠣꠞ ꠁ ꠇꠣꠝꠅ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠜꠣꠉ ꠘꠣꠁ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠔꠥꠝꠣꠞ ꠖꠤꠟ ꠡꠞꠟ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC8_22","074_8_22","ACT","8","22","22","ꠄꠞꠟꠣꠉꠤ ꠁ ꠘꠣꠎꠣꠁꠎ ꠇꠣꠝ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞ ꠖꠤꠟ ꠚꠤꠞꠣꠅ। ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠅ, ꠇꠤꠛꠣ ꠔꠥꠝꠣꠞ ꠖꠤꠟꠞ ꠁ ꠘꠣꠎꠣꠁꠎ ꠈꠤꠀꠟ ꠔꠣꠁꠘ ꠝꠣꠚ ꠇꠞꠤꠟꠤꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC8_23","074_8_23","ACT","8","23","23","ꠀꠝꠤ ꠖꠦꠈꠞꠣꠝ, ꠔꠥꠝꠣꠞ ꠖꠤꠟ ꠟꠤꠙꠡꠣꠄ ꠜꠞꠣ ꠀꠞ ꠔꠥꠝꠤ ꠉꠥꠘꠣꠞ ꠝꠣꠎꠦ ꠛꠘ꠆ꠖꠤ ꠅꠁꠞꠂꠍ।” ");
INSERT INTO syls_vpl VALUES ("AC8_24","074_8_24","ACT","8","24","24","ꠔꠦꠃ ꠍꠣꠁꠝꠘꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠁꠍꠂꠘ ꠁꠔꠣ ꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠘꠣ ꠀꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC8_25","074_8_25","ACT","8","25","25","ꠛꠣꠖꠦ ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠚꠤꠞꠔ ꠎꠣꠅꠀꠞ ꠙꠕꠅ, ꠡꠝꠞꠤꠀꠞ ꠛꠃꠔ ꠉꠣꠃꠔ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤ ꠇꠞꠤ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_26","074_8_26","ACT","8","26","26","ꠄꠇꠖꠤꠘ ꠀꠟ꠆ꠟꠣꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠢꠎꠞꠔ ꠚꠤꠟꠤꠚꠞꠦ ꠇꠁꠟꠣ, “ꠃꠑꠅ, ꠖꠃꠇꠘꠞ ꠎꠦ ꠙꠕ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠉꠣꠎꠣ ꠐꠣꠃꠘꠞ ꠛꠣꠄ ꠉꠦꠍꠦ ꠢꠃ ꠙꠕꠦ ꠞꠅꠀꠘꠣ ꠖꠦꠅ।” ꠁ ꠙꠕ ꠀꠍꠤꠟ ꠝꠞꠥꠜꠥꠝꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("AC8_27","074_8_27","ACT","8","27","27","ꠔꠦꠃ ꠚꠤꠟꠤꠚ ꠃꠑꠤꠀ ꠢꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠙꠕꠅ ꠁꠕꠤꠅꠙꠤꠀ ꠖꠦꠡꠞ ꠇꠣꠘ꠆ꠖꠣꠇꠤ ꠞꠣꠘꠤꠞ ꠄꠇꠎꠘ ꠛꠠ ꠞꠣꠎ ꠈꠣꠎꠣꠘ꠆ꠌꠤꠞ ꠟꠉꠦ ꠔꠣꠘ ꠝꠥꠟꠣꠇꠣꠔ ꠅꠁꠟ, ꠢꠤ ꠈꠣꠎꠣꠘ꠆ꠌꠤ ꠀꠍꠟꠣ ꠘꠣ-ꠝꠞ꠆ꠖ, ꠀꠞ ꠞꠣꠘꠤꠞ ꠢꠇ꠆ꠇꠟ ꠗꠘ-ꠞꠔꠘꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞ। ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠁꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_28","074_8_28","ACT","8","28","28","ꠛꠣꠖꠦ ꠛꠣꠠꠤꠔ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠙꠕꠅ ꠔꠣꠘ ꠘꠤꠎꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤꠔ ꠛꠁꠀ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠇꠤꠔꠣꠛ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠣꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_29","074_8_29","ACT","8","29","29","ꠅꠃ ꠡꠝꠄ ꠙꠣꠇ ꠞꠥꠢꠦ ꠚꠤꠟꠤꠚꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠉꠣꠠꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠅ, ꠀꠞ ꠄꠘ ꠟꠉꠦ ꠟꠉ ꠗꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC8_30","074_8_30","ACT","8","30","30","ꠔꠦꠃ ꠚꠤꠟꠤꠚꠦ ꠖꠃꠠꠤꠀ ꠅꠃ ꠉꠣꠠꠤꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠤꠀ ꠢꠥꠘꠟꠣ, ꠄꠁꠘ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠇꠤꠔꠣꠛ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠞꠣ; ꠚꠤꠟꠤꠚꠦ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠦ ꠎꠦꠔꠣ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠞꠣ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠞꠣ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC8_31","074_8_31","ACT","8","31","31","ꠢꠦꠁꠘ ꠇꠁꠟꠣ, “ꠇꠦꠃ ꠛꠥꠎꠣꠁꠀ ꠘꠣ ꠖꠤꠟꠦ ꠀꠝꠤ ꠇꠦꠝꠘꠦ ꠛꠥꠎꠝꠥ?” ꠅꠃ ꠔꠣꠁꠘ ꠚꠤꠟꠤꠚꠞꠦ ꠉꠣꠠꠤꠔ ꠃꠑꠤꠀ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠅꠀꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_32","074_8_32","ACT","8","32","32","ꠢꠦꠁꠘ ꠇꠤꠔꠣꠛꠞ ꠎꠦ ꠀꠄꠀꠔ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠣꠔ ꠀꠍꠟꠣ, ꠁꠔꠣ ꠅꠁꠟ, ꠎꠛ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠦꠠꠣꠞꠦ ꠎꠦꠟꠣ ꠘꠦꠁꠘ, ꠝꠣꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠘꠞꠦ ꠅꠃꠟꠣ ꠘꠦꠅꠀ ꠅꠁꠟ, ꠞꠥꠝꠣ ꠇꠣꠐꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠎꠦꠟꠣ ꠘꠤꠞꠣꠁ ꠞꠄ, ꠅꠃꠟꠣ ꠔꠣꠁꠘꠅ ꠎꠛꠣꠘ ꠈꠥꠟꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_33","074_8_33","ACT","8","33","33","ꠔꠣꠁꠘ ꠛꠦꠁꠎ꠆ꠎꠔ ꠅꠁꠟꠣ, ꠔꠣꠘꠞꠦ ꠛꠦ-ꠁꠘꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠟ। ꠔꠣꠘ ꠅꠀꠞꠤꠡꠞ ꠇꠕꠣ ꠇꠦꠉꠤꠄ ꠇꠁꠔ ꠙꠣꠞꠛ? ꠔꠣꠘ ꠎꠣꠘꠞꠦ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠇꠣꠠꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC8_34","074_8_34","ACT","8","34","34","ꠢꠃ ꠈꠣꠎꠣꠘ꠆ꠌꠤꠄ ꠚꠤꠟꠤꠚꠞꠦ ꠇꠁꠟꠣ, “ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠘꠛꠤꠄ ꠇꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠁꠔꠣ ꠇꠁꠍꠂꠘ? ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠘꠣ ꠀꠞ ꠇꠦꠃꠞꠞ?” ");
INSERT INTO syls_vpl VALUES ("AC8_35","074_8_35","ACT","8","35","35","ꠚꠤꠟꠤꠚꠦ ꠎꠛꠣꠘ ꠈꠥꠟꠤꠀ ꠙꠣꠇ ꠇꠣꠟꠣꠝꠞ ꠅꠃ ꠀꠄꠀꠔ ꠕꠣꠇꠤ ꠟꠁꠀ ꠁꠍꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠘ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_36","074_8_36","ACT","8","36","37","ꠙꠕꠅ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠔꠣꠞꠣ ꠙꠣꠘꠤꠀꠟꠣ ꠄꠇ ꠎꠣꠉꠣꠔ ꠀꠁꠀ ꠙꠃꠍꠟꠣ, ꠔꠦꠃ ꠢꠤ ꠈꠣꠎꠣꠘ꠆ꠌꠤꠄ ꠇꠁꠟꠣ, “ꠅꠃ ꠖꠦꠈꠃꠇ꠆ꠇꠣ ꠅꠘꠅ ꠙꠣꠘꠤ ꠀꠍꠦ, ꠔꠦ ꠀꠝꠤ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠔꠦ ꠇꠥꠘꠥ ꠛꠣꠗꠣ ꠀꠍꠦ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC8_38","074_8_38","ACT","8","38","38","ꠇꠁꠀ ꠔꠣꠁꠘ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ ꠃꠛꠣ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠚꠤꠟꠤꠚ ꠀꠞ ꠢꠃ ꠘꠣ-ꠝꠞ꠆ꠖ ꠈꠣꠎꠣꠘ꠆ꠌꠤ ꠖꠥꠁꠅ ꠎꠘ ꠙꠣꠘꠤꠔ ꠟꠣꠝꠟꠣ, ꠀꠞ ꠚꠤꠟꠤꠚꠦ ꠔꠣꠘꠞꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC8_39","074_8_39","ACT","8","39","39","ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠙꠣꠘꠤ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠀꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠝꠣꠛꠥꠖꠞ ꠞꠥꠢꠦ ꠀꠈꠔꠣꠃ ꠚꠤꠟꠤꠚꠞꠦ ꠀꠅꠠꠦ ꠘꠤꠟꠣꠉꠤ। ꠢꠤ ꠘꠣ-ꠝꠞ꠆ꠖꠦ ꠀꠞ ꠚꠤꠟꠤꠚꠞꠦ ꠖꠦꠈꠟꠣ ꠘꠣ, ꠔꠦꠃ ꠔꠣꠁꠘ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠤ ꠇꠞꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠕꠦ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC8_40","074_8_40","ACT","8","40","40","ꠅꠁꠟꠦ ꠚꠤꠟꠤꠚꠞꠦ ꠀꠡꠖꠥꠖ ꠐꠣꠃꠘꠅ ꠖꠦꠈꠣ ꠝꠤꠟꠟ; ꠔꠣꠁꠘ ꠉꠣꠃꠄ ꠉꠣꠃꠄ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤ ꠇꠞꠤ ꠢꠦꠡꠦ ꠇꠂꠍꠞꠤꠀ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_1","074_9_1","ACT","9","1","2","ꠁ ꠡꠝꠄꠅ ꠡꠃꠟꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠔꠣ ꠇꠞꠤ ꠒꠞ ꠖꠦꠈꠣꠘꠤꠔ ꠞꠁꠍꠂꠘ। ꠀꠞ ꠖꠣꠝꠦꠡ꠆ꠇ ꠡꠢꠞꠞ ꠁꠢꠥꠖꠤꠞ ꠝꠍꠤꠖꠣꠁꠘ꠆ꠔꠅ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠌꠤꠑꠤ ꠌꠣꠁꠟꠣ, ꠎꠔ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ ꠁꠍꠣꠞ ꠙꠕꠦ ꠌꠟꠂꠘ, ꠔꠣꠞꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠘꠔꠣ ꠅꠃ ꠈꠦꠝꠔꠣ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠌꠤꠑꠤ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_3","074_9_3","ACT","9","3","3","ꠙꠕꠅ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠎꠦꠛꠟꠣ ꠖꠣꠝꠦꠡ꠆ꠇ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠣ, ꠔꠦꠃ ꠀꠈꠔꠣꠃ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠔꠣꠘ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠚꠞ ꠅꠁꠀ ꠌꠝꠇꠣꠁꠀ ꠃꠑꠟ। ");
INSERT INTO syls_vpl VALUES ("AC9_4","074_9_4","ACT","9","4","4","ꠅꠃ ꠔꠣꠁꠘ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠉꠦꠟꠣ ꠀꠞ ꠉꠣꠁꠛꠤ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣ, ꠇꠦ ꠎꠣꠘꠥ ꠔꠣꠘꠞꠦ ꠇꠞ, “ꠡꠃꠟ, ꠡꠃꠟ, ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("AC9_5","074_9_5","ACT","9","5","5","ꠡꠃꠟꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠝꠣꠟꠤꠇ, ꠀꠙꠘꠦ ꠇꠦ?” ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠁꠍꠣ, ꠎꠦꠘꠞꠦ ꠔꠥꠝꠤ ꠎꠥꠟꠥꠝ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC9_6","074_9_6","ACT","9","6","6","ꠔꠥꠝꠤ ꠅꠈꠘ ꠃꠑꠤꠀ ꠡꠢꠞꠅ ꠎꠣꠅ, ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC9_7","074_9_7","ACT","9","7","7","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠡꠃꠟꠞ ꠟꠉꠦ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ ꠔꠣꠞꠣ ꠌꠝꠇꠤ ꠉꠦꠟꠣ, ꠔꠣꠞꠣ ꠁ ꠀꠅꠀꠎ ꠑꠤꠇꠃ ꠢꠥꠘꠍꠤꠟꠣ, ꠅꠁꠟꠦ ꠇꠦꠃꠞꠞꠦ ꠖꠦꠈꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_8","074_9_8","ACT","9","8","8","ꠛꠣꠖꠦ ꠡꠃꠟ ꠝꠣꠐꠤ ꠕꠣꠇꠤ ꠃꠑꠟꠣ, ꠀꠞ ꠌꠃꠈ ꠝꠦꠟꠤꠀ ꠢꠣꠞꠟꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠖꠦꠈꠟꠣ ꠘꠣ; ꠔꠣꠘ ꠟꠉꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠀꠔꠅ ꠗꠞꠤꠀ ꠖꠣꠝꠦꠡ꠆ꠇꠅ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_9","074_9_9","ACT","9","9","9","ꠡꠃꠟꠦ ꠔꠤꠘ ꠖꠤꠘ ꠗꠞꠤ ꠌꠃꠈꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠖꠦꠈꠟꠣ ꠘꠣ ꠀꠞ ꠇꠥꠘꠥꠎꠣꠔ ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠅ ꠈꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_10","074_9_10","ACT","9","10","10","ꠖꠣꠝꠦꠡ꠆ꠇ ꠡꠢꠞꠅ ꠅꠘꠘꠤꠅ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠝꠥꠝꠤꠘ ꠀꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC9_11","074_9_11","ACT","9","11","11","ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠅꠘꠘꠤꠅ!” ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠝꠣꠟꠤꠇ, ꠅꠃꠘꠥ ꠀꠝꠤ।” ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠡꠥꠎꠣ ꠘꠣꠝꠞ ꠎꠦ ꠡꠠꠇ ꠀꠍꠦ, ꠔꠥꠝꠤ ꠢꠃ ꠡꠠꠇꠦ ꠎꠣꠅ, ꠉꠤꠀ ꠢꠘꠞ ꠄꠢꠥꠖꠣꠞ ꠛꠣꠠꠤꠔ ꠔꠣꠞ꠆ꠡ ꠡꠢꠞꠞ ꠡꠃꠟ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("AC9_12","074_9_12","ACT","9","12","12","ꠢꠘꠅ ꠢꠦ ꠖꠥꠀ ꠇꠞꠦꠞ, ꠀꠞ ꠢꠦ ꠖꠞꠡꠘ ꠙꠣꠁꠍꠦ, ꠅꠘꠘꠤꠅ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠔꠣꠞ ꠡꠞꠤꠟ ꠀꠔꠣꠁꠀ ꠖꠤꠛ, ꠔꠦꠃ ꠢꠦ ꠢꠤꠞꠛꠣꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC9_13","074_9_13","ACT","9","13","13","ꠅꠘꠘꠤꠅꠄ ꠇꠁꠟꠣ, “ꠝꠣꠟꠤꠇ, ꠀꠝꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠁ ꠝꠣꠘꠥꠡꠉꠥꠞ ꠈꠣꠁꠍꠟꠔ ꠢꠥꠘꠍꠤ, ꠢꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠔꠥꠝꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠛꠃꠔ ꠎꠥꠟꠥꠝ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC9_14","074_9_14","ACT","9","14","14","ꠀꠞ ꠅꠃ ꠎꠣꠉꠣꠔꠅ ꠎꠔ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞ ꠙꠕꠦ ꠌꠟꠦ, ꠄꠞꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠘꠦꠅꠀꠞ ꠈꠦꠝꠔꠣ ꠢꠦ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("AC9_15","074_9_15","ACT","9","15","15","ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠣꠅ, ꠇꠣꠞꠘ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟ, ꠔꠣꠞꠣꠞ ꠞꠣꠎꠣ ꠅꠇꠟ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠘꠣꠝ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC9_16","074_9_16","ACT","9","16","16","ꠀꠝꠤ ꠔꠣꠞꠦ ꠖꠦꠈꠣꠁꠝꠥ, ꠀꠝꠣꠞ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠇꠔ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC9_17","074_9_17","ACT","9","17","17","ꠔꠦꠃ ꠅꠘꠘꠤꠅ ꠛꠣꠞ ꠅꠁꠀ ꠢꠃ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟꠣ, ꠀꠞ ꠡꠃꠟꠞ ꠉꠔꠞꠅ ꠀꠔ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠜꠣꠁ ꠡꠃꠟ, ꠅꠘꠅ ꠀꠅꠀꠞ ꠙꠕꠅ ꠎꠦꠁꠘ ꠔꠥꠝꠣꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠍꠂꠘ ꠔꠣꠁꠘ ꠢꠎꠞꠔ ꠁꠍꠣ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠥꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠔꠣꠄ ꠙꠣꠅ ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC9_18","074_9_18","ACT","9","18","18","ꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠘ ꠌꠃꠈ ꠕꠣꠇꠤ ꠝꠣꠍꠞ-ꠚꠁꠞꠞ ꠟꠣꠈꠣꠘ ꠇꠤꠔꠣ ꠙꠠꠤꠉꠦꠟ, ꠔꠣꠁꠘ ꠖꠦꠈꠔꠣ ꠙꠣꠞꠟꠣ ꠀꠞ ꠃꠑꠤꠀ ꠙꠣꠘꠤꠔ ꠉꠤꠀ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("AC9_19","074_9_19","ACT","9","19","19","ꠈꠣꠅꠀ-ꠖꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠡꠞꠤꠟꠅ ꠢꠤꠞꠛꠣꠞ ꠛꠟ ꠙꠣꠁꠟꠣ। ꠀꠞ ꠔꠣꠁꠘ ꠇꠤꠍꠥꠖꠤꠘ ꠖꠣꠝꠦꠡ꠆ꠇꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠟꠉꠦ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_20","074_9_20","ACT","9","20","20","ꠡꠃꠟꠦ ꠀꠞ ꠖꠦꠞꠤ ꠇꠞꠟꠣ ꠘꠣ, ꠔꠣꠁꠘ ꠎꠣꠉꠣꠄ ꠎꠣꠉꠣꠄ ꠝꠍꠤꠖꠣꠁꠘ꠆ꠔꠅ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ, ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠢꠃ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠁꠛꠘꠥꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_21","074_9_21","ACT","9","21","21","ꠎꠦꠞꠣ ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠔ ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠇꠞꠔ, “ꠄꠁꠘ ꠢꠃ ꠝꠣꠘꠥꠡ ꠘꠣꠄ ꠘꠤ ꠎꠦꠁꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠁꠍꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣ? ꠀꠞ ꠅꠘꠅ-ꠅ ꠔ ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠁꠍꠂꠘ, ꠎꠦꠞꠣ ꠁꠍꠣꠞ ꠙꠕꠦ ꠌꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠎꠣꠁꠔꠣ?” ");
INSERT INTO syls_vpl VALUES ("AC9_22","074_9_22","ACT","9","22","22","ꠅꠁꠟꠦ ꠡꠃꠟ ꠖꠤꠘ ꠖꠤꠘ ꠀꠞꠅ ꠢꠤꠝ꠆ꠝꠔ ꠀꠟꠣ ꠅꠁꠟꠣ, ꠀꠞ ꠖꠣꠝꠦꠡ꠆ꠇꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠟꠣ-ꠎꠥꠀꠙ ꠛꠣꠘꠣꠁꠔꠣ ꠟꠣꠉꠟꠣ, ꠔꠣꠁꠘ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠟꠣ, ꠅꠃ ꠁꠍꠣꠃ ꠢꠤ ꠀꠟ-ꠝꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC9_23","074_9_23","ACT","9","23","23","ꠄꠞ ꠛꠃꠔ ꠛꠣꠖꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠟ꠆ꠟꠣ-ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC9_24","074_9_24","ACT","9","24","24","ꠀꠞ ꠡꠃꠟꠦ ꠁ ꠈꠛꠞ ꠙꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠢꠞꠅ ꠢꠣꠝꠣꠘꠤ ꠛꠣꠞꠘꠤꠞ ꠢꠇ꠆ꠇꠟ ꠖꠥꠀꠞꠅ ꠖꠤꠘꠦ-ꠞꠣꠁꠔꠦ ꠌꠇꠤꠖꠣꠞ ꠛꠅꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_25","074_9_25","ACT","9","25","25","ꠄꠇꠖꠤꠘ ꠞꠣꠁꠔ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠡꠃꠟꠞꠦ ꠄꠇ ꠐꠥꠇꠞꠤꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠞꠣꠁꠀ, ꠛꠣꠃꠘ꠆ꠒꠞꠤ ꠅꠀꠟꠞ ꠈꠤꠠꠇꠤꠛꠣꠄ ꠙꠣꠞ ꠇꠞꠤ ꠛꠣꠞꠦ ꠟꠣꠝꠣꠁꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_26","074_9_26","ACT","9","26","26","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠀ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠔꠣ ꠌꠣꠁꠟꠣ; ꠅꠁꠟꠦ ꠢꠇ꠆ꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠒꠞꠣꠁꠟ, ꠔꠣꠁꠘ ꠎꠦꠘ ꠢꠣꠍꠣꠃ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ ꠔꠣꠞꠣ ꠛꠤꠡ꠆ꠛꠣꠡ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_27","074_9_27","ACT","9","27","27","ꠔꠦꠃ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠔꠣꠘꠞꠦ ꠀꠔꠅ ꠗꠞꠤꠀ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟꠣ, ꠀꠞ ꠖꠣꠝꠦꠡ꠆ꠇ ꠎꠣꠅꠀꠞ ꠙꠕꠅ ꠇꠤꠟꠣ ꠔꠣꠁꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠟꠣ, ꠀꠞ ꠇꠤꠟꠣ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ, ꠖꠣꠝꠦꠡ꠆ꠇꠅ ꠇꠤꠟꠣ ꠔꠣꠁꠘ ꠡꠣꠅꠡ ꠇꠞꠤ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠂꠘ ꠢꠇꠟꠔꠣ ꠄꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_28","074_9_28","ACT","9","28","28","ꠛꠣꠖꠦ ꠡꠃꠟ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠄꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠔꠣ, ꠔꠣꠁꠘ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠊꠥꠞꠤꠀ ꠚꠤꠞꠤꠀ ꠡꠣꠅꠡ ꠇꠞꠤ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_29","074_9_29","ACT","9","29","29","ꠔꠣꠁꠘ ꠁꠃꠘꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠞꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠖꠤꠘꠤ ꠛꠣꠔꠌꠤꠔ ꠀꠞ ꠔꠞ꠆ꠇ ꠇꠞꠔꠣ; ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_30","074_9_30","ACT","9","30","30","ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠁ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠔꠣꠘꠞꠦ ꠇꠂꠍꠞꠤꠀ ꠡꠢꠞꠅ ꠟꠁꠀ ꠉꠦꠟꠣ, ꠢꠘ ꠕꠣꠇꠤ ꠔꠣꠘꠞꠦ ꠔꠣꠞ꠆ꠡ ꠡꠢꠞꠅ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_31","074_9_31","ACT","9","31","31","ꠢꠤ ꠡꠝꠄ ꠄꠢꠥꠖꠤꠀ, ꠉꠣꠟꠤꠟ ꠀꠞ ꠡꠝꠞꠤꠀ ꠄꠟꠣꠇꠣꠞ ꠎꠝꠣꠔ ꠅꠇꠟ ꠡꠣꠘ꠆ꠔꠤꠞ ꠝꠣꠎꠦ ꠔꠂꠀꠞ ꠅꠁꠟ, ꠁ ꠎꠝꠣꠔ ꠅꠇꠟ ꠝꠣꠛꠥꠖꠞ ꠒꠞꠦ ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠁꠡꠣꠞꠣꠄ ꠌꠟꠤ ꠌꠟꠤ ꠛꠃꠔ ꠙꠞꠤꠝꠣꠘꠦ ꠛꠣꠠꠟ। ");
INSERT INTO syls_vpl VALUES ("AC9_32","074_9_32","ACT","9","32","32","ꠙꠤꠔꠞꠦ ꠢꠇ꠆ꠇꠟ ꠎꠣꠉꠣꠔ ꠊꠥꠞꠔꠦ ꠊꠥꠞꠔꠦ ꠟꠥꠖ꠆ꠖꠣ ꠉꠣꠃꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠀꠎꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_33","074_9_33","ACT","9","33","33","ꠢꠃ ꠉꠣꠃꠔ ꠅꠂꠘꠤꠅ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠍꠤꠟ; ꠢꠦ ꠅꠞ꠆ꠖꠋ ꠛꠦꠝꠣꠞꠦ ꠀꠐ ꠛꠞꠍ ꠗꠞꠤ ꠛꠤꠍꠘꠣꠔ ꠙꠠꠘꠅ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC9_34","074_9_34","ACT","9","34","34","ꠙꠤꠔꠞꠦ ꠔꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠇꠁꠟꠣ, “ꠅꠂꠘꠤꠅ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠔꠥꠝꠣꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠟꠣ, ꠃꠑꠅ, ꠔꠥꠝꠣꠞ ꠛꠤꠍꠘꠣ ꠔꠥꠟꠤꠟꠣꠅ।” ꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠅꠂꠘꠤꠅ ꠃꠑꠤꠀ ꠃꠛꠣꠁ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC9_35","074_9_35","ACT","9","35","35","ꠔꠦꠃ ꠟꠥꠖ꠆ꠖꠣ ꠉꠣꠃ ꠀꠞ ꠡꠣꠞꠥꠘ ꠄꠟꠣꠇꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠅꠂꠘꠤꠅꠞ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_36","074_9_36","ACT","9","36","36","ꠎꠣꠚꠣ ꠡꠢꠞꠅ ꠐꠣꠛꠤꠕꠣ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠝꠥꠝꠤꠘ ꠛꠦꠐꠤ ꠀꠍꠟꠣ, ꠁꠃꠘꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠐꠣꠛꠤꠕꠣ ꠘꠣꠝꠞ ꠅꠞ꠆ꠕ ꠖꠞ꠆ꠇꠣ, ꠝꠣꠘꠤ ꠢꠞꠤꠘꠤ, ꠔꠣꠁꠘ ꠢꠇꠟ ꠡꠝꠄ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠔꠣ ꠀꠞ ꠉꠞꠤꠛꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_37","074_9_37","ACT","9","37","37","ꠔꠣꠁꠘ ꠛꠦꠝꠣꠞ ꠙꠠꠤꠀ ꠝꠣꠞꠣ ꠉꠦꠟꠣ, ꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠉꠥꠍꠟ ꠖꠦꠅꠀꠁꠀ ꠃꠙꠞꠞ ꠇꠥꠑꠣꠔ ꠘꠤꠀ ꠕꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_38","074_9_38","ACT","9","38","38","ꠎꠣꠚꠣ ꠡꠢꠞ ꠟꠥꠖ꠆ꠖꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠍꠤꠟ ꠉꠔꠤꠇꠦ, ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠦ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣ, ꠙꠤꠔꠞ ꠟꠥꠖ꠆ꠖꠣꠔ ꠀꠍꠂꠘ, ꠅꠃ ꠔꠣꠞꠣ ꠖꠥꠁꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠀ ꠝꠤꠘꠔ ꠇꠞꠟꠣ, “ꠀꠙꠘꠦ ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC9_39","074_9_39","ACT","9","39","39","ꠔꠦꠃ ꠙꠤꠔꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠢꠘꠅ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠃꠙꠞꠞ ꠇꠥꠑꠣꠔ ꠟꠁꠀ ꠉꠦꠟ, ꠢꠇꠟ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠙꠤꠔꠞꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠃꠛꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠘ ꠡꠥꠞꠥ ꠇꠞꠟꠣ ꠀꠞ ꠖꠞ꠆ꠇꠣ ꠎꠤꠔꠣ ꠕꠣꠇꠔꠦ ꠎꠦꠔꠣ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠛꠣꠘꠣꠁꠍꠟꠣ, ꠅꠔꠣ ꠙꠤꠔꠞꠞꠦ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_40","074_9_40","ACT","9","40","40","ꠙꠤꠔꠞꠦ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠞꠦ ꠇꠥꠑꠣ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠀ ꠎꠣꠘꠥ ꠙꠣꠠꠤꠀ ꠖꠥꠀ ꠇꠞꠟꠣ; ꠛꠣꠖꠦ ꠝꠞꠣ ꠛꠦꠐꠤꠞ ꠟꠣꠡꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠀ ꠇꠁꠟꠣ, “ꠐꠣꠛꠤꠕꠣ, ꠃꠑꠅ।” ꠟꠉꠦ ꠟꠉꠦ ꠖꠞ꠆ꠇꠣꠄ ꠌꠃꠈ ꠈꠥꠟꠟꠣ, ꠀꠞ ꠙꠤꠔꠞꠞꠦ ꠖꠦꠈꠤꠀ ꠃꠑꠤꠀ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_41","074_9_41","ACT","9","41","41","ꠙꠤꠔꠞꠦ ꠔꠣꠘ ꠀꠔꠅ ꠗꠞꠤꠀ ꠃꠛꠣ ꠇꠞꠟꠣ, ꠛꠣꠖꠦ ꠢꠤ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ ꠀꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠒꠣꠇꠤꠀ ꠖꠦꠈꠣꠁꠟꠣ, ꠖꠞ꠆ꠇꠣ ꠎꠤꠔꠣ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC9_42","074_9_42","ACT","9","42","42","ꠁ ꠈꠛꠞ ꠎꠣꠚꠣ ꠡꠢꠞꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠃꠠꠤꠉꠦꠟ ꠀꠞ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC9_43","074_9_43","ACT","9","43","43","ꠙꠤꠔꠞ ꠛꠃꠔ ꠖꠤꠘ ꠎꠣꠚꠣ ꠡꠢꠞꠅ ꠍꠣꠁꠝꠘ ꠘꠣꠝꠞ ꠄꠇ ꠌꠣꠝꠣꠞꠞ ꠛꠣꠠꠤꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_1","074_10_1","ACT","10","1","1","ꠇꠂꠍꠞꠤꠀ ꠡꠢꠞꠅ ꠇꠞꠘꠤꠟꠥꠍ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ, ꠁꠔꠣꠟꠤ ꠘꠣꠝꠞ ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠍꠥꠛꠦꠖꠣꠞ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_2","074_10_2","ACT","10","2","2","ꠔꠣꠁꠘ ꠄꠇꠎꠘ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠣꠘꠥꠡ, ꠔꠣꠘ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠦꠅ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠔꠣ। ꠔꠣꠁꠘ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠛꠃꠔ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠀꠞ ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠖꠥꠀ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_3","074_10_3","ACT","10","3","3","ꠄꠇꠖꠤꠘ ꠅꠘꠥꠝꠣꠘ ꠔꠤꠘꠐꠣꠞ ꠡꠝꠄ ꠔꠣꠁꠘ ꠄꠇ ꠍꠣꠚ ꠖꠞꠡꠘ ꠙꠣꠁꠟꠣ। ꠖꠦꠈꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠀ ꠒꠣꠇꠤꠞꠣ, “ꠇꠞꠘꠤꠟꠥꠍ!” ");
INSERT INTO syls_vpl VALUES ("AC10_4","074_10_4","ACT","10","4","4","ꠇꠞꠘꠤꠟꠥꠍꠦ ꠒꠞꠣꠁꠀ ꠢꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠝꠣꠟꠤꠇ, ꠇꠃꠇ꠆ꠇꠣ, ꠢꠥꠘꠞꠣꠝ।” ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠝꠥꠘꠣꠎꠣꠔ ꠀꠞ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠖꠣꠘꠞ ꠇꠕꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠙꠃꠍꠤꠍꠦ ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣ ꠇꠛꠥꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_5","074_10_5","ACT","10","5","5","ꠅꠈꠘ ꠔꠥꠝꠤ ꠎꠣꠚꠣ ꠡꠢꠞꠅ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠅ, ꠀꠞ ꠍꠣꠁꠝꠘ ꠃꠞꠚꠦ ꠙꠤꠔꠞꠞꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠣꠁ ꠀꠘꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("AC10_6","074_10_6","ACT","10","6","6","ꠄꠁꠘ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠅ ꠀꠞꠇ ꠍꠣꠁꠝꠘꠞ ꠛꠣꠠꠤꠔ ꠕꠣꠇꠂꠘ, ꠢꠤ ꠍꠣꠁꠝꠘꠦ ꠌꠣꠝꠠꠣꠞ ꠇꠣꠞꠛꠣꠞ ꠇꠞꠦ।” ");
INSERT INTO syls_vpl VALUES ("AC10_7","074_10_7","ACT","10","7","7","ꠎꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠞꠘꠤꠟꠥꠍꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠤꠟꠣ, ꠔꠣꠁꠘ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠇꠞꠘꠤꠟꠥꠍꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠖꠥꠁꠎꠘ ꠇꠣꠝꠟꠣ ꠀꠞ ꠔꠣꠘ ꠡꠣꠁꠎ꠆ꠎꠇꠣꠞꠤ ꠄꠇꠎꠘ ꠙꠞꠦꠎꠉꠣꠞ ꠍꠤꠙꠣꠁꠞꠦ ꠒꠣꠇ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_8","074_10_8","ACT","10","8","8","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠢꠇꠟꠔꠣ ꠛꠥꠎꠣꠁ ꠖꠤꠀ ꠎꠣꠚꠣ ꠡꠢꠞꠅ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_9","074_10_9","ACT","10","9","9","ꠛꠣꠖꠞ ꠖꠤꠘ ꠎꠦꠛꠟꠣ ꠢꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠎꠣꠚꠣ ꠡꠢꠞꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠟꠣ, ꠁ ꠡꠝꠄ ꠛꠦꠁꠟ ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁꠚꠞ, ꠙꠤꠔꠞꠦ ꠖꠥꠀ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠃ ꠡꠝꠄ ꠍꠣꠔꠅ ꠃꠑꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_10","074_10_10","ACT","10","10","10","ꠔꠣꠘ ꠈꠥꠛ ꠜꠥꠇ ꠟꠣꠉꠍꠤꠟ, ꠔꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ ꠀꠞ ꠝꠣꠘꠡꠦ ꠈꠣꠘꠤ ꠔꠤꠀꠞ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠊꠥꠝꠦ ꠔꠣꠘ ꠃꠋꠉꠣꠘꠤ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC10_11","074_10_11","ACT","10","11","11","ꠅꠃ ꠢꠣꠟꠔꠅ ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠀꠍꠝꠣꠘ ꠈꠥꠟꠤꠉꠦꠍꠦ ꠀꠞ ꠈꠥꠛ ꠛꠠ ꠌꠣꠖ꠆ꠖꠞꠞ ꠟꠣꠈꠣꠘ ꠄꠇ ꠌꠤꠎꠞ ꠌꠣꠁꠞ ꠇꠥꠘꠣꠔ ꠗꠞꠤꠀ ꠖꠥꠘꠤꠀꠔ ꠟꠣꠝꠣꠁ ꠖꠦꠅꠀ ꠅꠞ; ");
INSERT INTO syls_vpl VALUES ("AC10_12","074_10_12","ACT","10","12","12","ꠀꠞ ꠁ ꠌꠣꠖ꠆ꠖꠞꠞ ꠝꠣꠎꠦ ꠖꠥꠘꠤꠀꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠙꠡꠥ, ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠙꠣꠈꠤꠘ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC10_13","074_10_13","ACT","10","13","13","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠃ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣ, ꠇꠦ ꠎꠣꠘꠥ ꠔꠣꠘꠞꠦ ꠇꠞ, “ꠙꠤꠔꠞ, ꠃꠑꠅ, ꠝꠣꠞꠤꠀ ꠈꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC10_14","074_10_14","ACT","10","14","14","ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ, ꠝꠣꠟꠤꠇ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠘꠣ, ꠀꠝꠤ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠘꠣꠙꠣꠇ ꠀꠞ ꠢꠣꠞꠣꠝ ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠁ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC10_15","074_10_15","ACT","10","15","15","ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠅꠃ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣ, “ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠢꠣꠟꠣꠟ ꠇꠞꠍꠂꠘ, ꠁꠔꠣꠞꠦ ꠔꠥꠝꠤ ꠢꠣꠞꠣꠝ ꠇꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC10_16","074_10_16","ACT","10","16","16","ꠅꠃꠟꠣ ꠔꠤꠘꠛꠣꠞ ꠅꠀꠞ ꠛꠣꠖꠦ ꠢꠃ ꠌꠣꠖ꠆ꠖꠞꠈꠣꠘ ꠀꠍꠝꠣꠘꠅ ꠔꠥꠟꠤꠀ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC10_17","074_10_17","ACT","10","17","17","ꠙꠤꠔꠞꠦ ꠎꠦ ꠛꠣꠔꠥꠘꠤ ꠖꠞꠡꠘ ꠖꠦꠈꠟꠣ, ꠄꠞ ꠝꠣꠘꠤ ꠇꠤꠔꠣ ꠅꠁꠔ ꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠗꠤꠀꠘ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠇꠞꠘꠤꠟꠥꠍꠞ ꠙꠣꠑꠣꠁꠟ ꠢꠤ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠍꠣꠁꠝꠘꠞ ꠛꠣꠠꠤ ꠔꠥꠇꠣꠁꠀ ꠙꠣꠁꠀ, ꠛꠣꠠꠤꠞ ꠖꠥꠀꠞꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠃꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_18","074_10_18","ACT","10","18","18","ꠔꠣꠞꠣ ꠒꠣꠇꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠍꠣꠁꠝꠘ ꠎꠦꠘꠞꠦ ꠙꠤꠔꠞ ꠇꠁꠀ ꠒꠣꠇꠂꠘ, ꠔꠣꠁꠘ ꠁꠈꠣꠘꠅ ꠀꠍꠂꠘ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC10_19","074_10_19","ACT","10","19","19","ꠙꠤꠔꠞꠦ ꠢꠃ ꠖꠞꠡꠘꠞ ꠇꠕꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠙꠣꠇ ꠞꠥꠢꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠖꠦꠈꠅ, ꠔꠤꠘꠎꠘ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠣꠞꠦ ꠔꠥꠇꠣꠘꠤꠔ ꠀꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_20","074_10_20","ACT","10","20","20","ꠔꠥꠝꠤ ꠟꠣꠝꠣꠔ ꠟꠣꠝꠅ ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠅꠀꠘꠣ ꠖꠦꠅ, ꠇꠥꠘꠥ ꠡꠘ꠆ꠖꠄ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠀꠝꠤꠃ ꠙꠣꠑꠣꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("AC10_21","074_10_21","ACT","10","21","21","ꠔꠦꠃ ꠙꠤꠔꠞ ꠟꠣꠝꠤꠀ ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠎꠣꠞꠦ ꠔꠥꠇꠣꠁꠞꠣ ꠀꠝꠤꠃ ꠢꠦꠁꠘ; ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠇꠤꠔꠣꠟ꠆ꠟꠣꠉꠤ ꠀꠁꠍꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("AC10_22","074_10_22","ACT","10","22","22","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠡ-ꠍꠤꠙꠣꠁꠞ ꠍꠥꠛꠦꠖꠣꠞ ꠇꠞꠘꠤꠟꠥꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠄꠇꠎꠘ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠣꠘꠥꠡ, ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠌꠟꠂꠘ, ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠈꠥꠛ ꠔꠣꠎꠤꠝ ꠇꠞꠂꠘ। ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠀꠙꠘꠣꠞꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠘꠦꠅꠀꠁꠀ ꠀꠙꠘꠣꠞ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC10_23","074_10_23","ACT","10","23","23","ꠅꠃ ꠙꠤꠔꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠜꠤꠔꠞꠦ ꠒꠣꠇꠤꠀ ꠘꠤꠀ, ꠔꠣꠞꠣꠞ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠟꠣ। ꠛꠣꠖꠞ ꠖꠤꠘ ꠃꠑꠤꠀ ꠙꠤꠔꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ, ꠀꠞ ꠎꠣꠚꠣ ꠡꠢꠞꠞ ꠇꠄꠎꠘ ꠁꠝꠣꠘꠖꠣꠞꠅ ꠔꠣꠘ ꠟꠉꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_24","074_10_24","ACT","10","24","24","ꠄꠞ ꠛꠣꠖꠞ ꠖꠤꠘ ꠔꠣꠞꠣ ꠇꠂꠍꠞꠤꠀꠔ ꠙꠃꠍꠟꠣ; ꠅꠃ ꠡꠝꠄ ꠇꠞꠘꠤꠟꠥꠍꠦ ꠔꠣꠘ ꠈꠦꠡ-ꠇꠥꠐꠥꠝ ꠀꠞ ꠛꠘ꠆ꠖꠥ-ꠛꠣꠘ꠆ꠖꠛ ꠅꠇꠟꠞꠦ ꠖꠟꠣ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠛꠣꠞ ꠌꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_25","074_10_25","ACT","10","25","25","ꠀꠞ ꠙꠤꠔꠞ ꠉꠤꠀ ꠎꠦꠛꠟꠣ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠟꠣ, ꠁ ꠡꠝꠄ ꠇꠞꠘꠤꠟꠥꠍꠦ ꠔꠣꠘ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠙꠣꠅꠔ ꠙꠠꠤꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_26","074_10_26","ACT","10","26","26","ꠅꠁꠟꠦ ꠙꠤꠔꠞꠦ ꠔꠣꠘꠞꠦ ꠔꠥꠟꠤꠀ ꠇꠁꠟꠣ, “ꠃꠑꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠘꠤꠎꠦꠅ ꠔ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ।” ");
INSERT INTO syls_vpl VALUES ("AC10_27","074_10_27","ACT","10","27","27","ꠛꠣꠖꠦ ꠇꠞꠘꠤꠟꠥꠍꠞ ꠟꠉꠦ ꠝꠣꠔꠤ ꠝꠣꠔꠤ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠙꠤꠔꠞꠦ ꠖꠦꠈꠟꠣ, ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠖꠟꠣ ꠅꠁꠞꠂꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC10_28","074_10_28","ACT","10","28","28","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠔ ꠎꠣꠘꠂꠘ, ꠄꠇꠎꠘ ꠁꠢꠥꠖꠤ ꠝꠣꠘꠡꠦ ꠇꠥꠘꠥ ꠅ-ꠁꠢꠥꠖꠤꠞ ꠇꠣꠍꠣꠔ ꠎꠣꠅꠀ ꠛꠣ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠣ ꠀꠝꠞꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠘꠣꠎꠣꠁꠎ। ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠁꠍꠂꠘ ꠎꠦꠘ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣ ꠅꠙꠛꠤꠔ꠆ꠞ ꠇꠅꠀ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("AC10_29","074_10_29","ACT","10","29","29","ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠝꠣꠞꠦ ꠈꠛꠞ ꠖꠤꠍꠂꠘ, ꠔꠦ ꠀꠝꠤ ꠇꠥꠘꠥ ꠅꠝꠔ ꠘꠣ ꠇꠞꠤꠀꠃ ꠀꠁꠍꠤ। ꠅꠈꠘ ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠞꠣꠝ, ꠀꠝꠣꠞꠦ ꠇꠤꠔꠣꠟ꠆ꠟꠣꠉꠤ ꠀꠘꠣꠁꠍꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("AC10_30","074_10_30","ACT","10","30","30","ꠇꠞꠘꠤꠟꠥꠍꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠁꠎ ꠕꠣꠇꠤ ꠌꠣꠁꠞ ꠖꠤꠘ ꠀꠉꠦ ꠅꠝꠘ ꠛꠣꠟꠣ ꠝꠣꠘꠤ ꠔꠤꠘꠐꠣꠞ ꠡꠝꠄ ꠀꠝꠤ ꠀꠝꠣꠞ ꠊꠞꠅ ꠖꠥꠀ ꠇꠞꠣꠔ ꠀꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠌꠝꠇꠣꠁꠟ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠣ ꠄꠇ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠃꠛꠣꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC10_31","074_10_31","ACT","10","31","31","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠇꠞꠘꠤꠟꠥꠍ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞ ꠖꠥꠀ ꠇꠛꠥꠟ ꠇꠞꠍꠂꠘ। ꠀꠞ ꠔꠥꠝꠣꠞ ꠖꠣꠘ-ꠈꠄꠞꠣꠔꠅ ꠇꠛꠥꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_32","074_10_32","ACT","10","32","32","ꠅꠈꠘ ꠔꠥꠝꠤ ꠎꠣꠚꠣ ꠡꠢꠞꠅ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠅ ꠀꠞ ꠍꠣꠁꠝꠘ ꠃꠞꠚꠦ ꠙꠤꠔꠞꠞꠦ ꠀꠘꠣꠅ। ꠔꠣꠁꠘ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠅ ꠍꠣꠁꠝꠘ ꠘꠣꠝꠞ ꠄꠇ ꠌꠣꠝꠠꠣꠞ ꠇꠣꠞꠛꠣꠞꠤꠞ ꠛꠣꠠꠤꠔ ꠀꠍꠂꠘ।’ ");
INSERT INTO syls_vpl VALUES ("AC10_33","074_10_33","ACT","10","33","33","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠙꠘꠣꠞꠦ ꠀꠘꠣꠔ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠁꠟꠣꠝ। ꠀꠙꠘꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠍꠂꠘ ꠖꠦꠈꠤꠀ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠟꠣꠝ। ꠅꠈꠘ ꠀꠝꠞꠣ ꠢꠇꠟ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠀꠍꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠙꠘꠣꠞꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠂꠘ, ꠀꠝꠞꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠘꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("AC10_34","074_10_34","ACT","10","34","34","ꠔꠦꠃ ꠙꠤꠔꠞꠦ ꠎꠛꠣꠘ ꠈꠥꠟꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠅꠈꠘ ꠢꠣꠍꠣꠞꠞ ꠛꠥꠎꠟꠣꠝ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠢꠇꠟꠃ ꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_35","074_10_35","ACT","10","35","35","ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣ ꠔꠣꠘꠞꠦ ꠒꠞꠣꠄ ꠀꠞ ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠦ, ꠔꠣꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠛꠥꠟ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_36","074_10_36","ACT","10","36","36","ꠀꠙꠘꠣꠞꠣ ꠔ ꠎꠣꠘꠂꠘ, ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠈꠥꠡꠤꠞ ꠄꠇꠈꠣꠘ ꠈꠛꠞ ꠎꠣꠘꠣꠁꠍꠂꠘ। ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ, ꠎꠦꠁꠘ ꠢꠇꠟꠞ ꠝꠣꠟꠤꠇ, ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠡꠣꠘ꠆ꠔꠤ ꠙꠣꠅꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC10_37","074_10_37","ACT","10","37","37","ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠄꠢꠤꠀꠄ ꠁꠈꠣꠘ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠛꠣꠖꠦꠃ ꠉꠣꠟꠤꠟ ꠕꠣꠇꠤ ꠀꠡ꠆ꠔꠣ ꠄꠢꠥꠖꠤꠀ ꠎꠥꠠꠤ ꠎꠦꠔꠣ ꠊꠐꠍꠤꠟ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠀꠙꠘꠣꠞꠣ ꠢꠥꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_38","074_10_38","ACT","10","38","38","ꠀꠟ꠆ꠟꠣꠄ ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠞ ꠇꠥꠖꠞꠔꠦ ꠇꠤꠟꠣ ꠈꠣꠍ ꠈꠟꠤꠚꠣ ꠛꠣꠘꠣꠁꠍꠟꠣ; ꠔꠣꠁꠘ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠤ ꠇꠞꠤ ꠍꠚꠞ ꠇꠞꠔꠣ, ꠀꠞ ꠎꠤꠘꠦ ꠗꠞꠣ ꠛꠦꠝꠣꠞꠤ ꠅꠇꠟꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠔꠣ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠔꠣꠘ ꠟꠉꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_39","074_10_39","ACT","10","39","39","ꠔꠣꠁꠘ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠎꠝꠤꠘꠅ ꠀꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠦꠔꠣ ꠇꠞꠍꠤꠟꠣ, ꠀꠝꠞꠣ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤ; ꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("AC10_40","074_10_40","ACT","10","40","40","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠔꠤꠘ ꠖꠤꠘ ꠛꠣꠖꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠃꠑꠣꠁꠟꠣ, ꠀꠞ ꠝꠣꠘꠡꠦꠅ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_41","074_10_41","ACT","10","41","41","ꠔꠣ-ꠅ ꠢꠇ꠆ꠇꠟꠦ ꠔꠣꠘꠦ ꠖꠦꠈꠣꠞ ꠘꠍꠤꠛ ꠅꠁꠍꠦ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠞꠣꠞꠦ ꠀꠉꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤꠟꠣ, ꠢꠃ ꠡꠣꠇ꠆ꠇꠤ ꠅꠇꠟꠞꠦ, ꠝꠣꠘꠤ ꠀꠝꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠟꠣ, ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠞ ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠔꠣꠘ ꠟꠉꠦ ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠅ ꠈꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC10_42","074_10_42","ACT","10","42","42","ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠤ ꠀꠞ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠁ ꠎꠦꠘ, ꠔꠣꠘꠞꠦꠃ ꠀꠟ꠆ꠟꠣꠄ ꠎꠤꠘ꠆ꠖꠣ ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠢꠣꠇꠤꠝ ꠛꠣꠘꠣꠁ ꠙꠣꠑꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_43","074_10_43","ACT","10","43","43","ꠢꠇꠟ ꠘꠛꠤꠄꠅ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠅꠃꠟꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ ꠎꠦꠘ, ꠎꠦꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠔꠣꠘ ꠘꠣꠝꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠙꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC10_44","074_10_44","ACT","10","44","44","ꠙꠤꠔꠞꠦ ꠛꠄꠀꠘ ꠇꠞꠞꠣ, ꠁ ꠡꠝꠄ ꠎꠦꠞꠣ ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠔ ꠀꠍꠤꠟ, ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥ ꠘꠣꠎꠤꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC10_45","074_10_45","ACT","10","45","45","ꠀꠞ ꠙꠤꠔꠞꠞ ꠟꠉꠦ ꠅꠁꠀ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ ꠎꠦꠔꠣ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠌꠝꠇꠤꠀ ꠃꠑꠟꠣ, ꠇꠣꠞꠘ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠃꠙꠞꠦꠅ ꠙꠣꠇ ꠞꠥꠢꠥ ꠛꠞ꠆ꠡꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC10_46","074_10_46","ACT","10","46","46","ꠔꠣꠞꠣ ꠖꠦꠈꠟꠣ, ꠅꠃ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠘꠣꠘꠣꠘ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠤꠞꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC10_47","074_10_47","ACT","10","47","47","ꠔꠦꠃ ꠙꠤꠔꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠙꠣꠇ ꠞꠥꠢꠥ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠂꠘ, ꠄꠞꠣ ꠙꠣꠘꠤꠔ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠔꠦ ꠇꠤꠔꠣ ꠇꠦꠃ ꠛꠣꠗꠣ ꠖꠤꠔ ꠙꠣꠞꠛ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC10_48","074_10_48","ACT","10","48","48","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ꠀꠞ ꠔꠣꠞꠣ ꠙꠤꠔꠞꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠟꠣ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠄꠈꠣꠘ ꠖꠤꠘ ꠞꠅꠀꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC11_1","074_11_1","ACT","11","1","1","ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠀꠞ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠢꠇ꠆ꠇꠟ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠢꠥꠘꠟꠣ, ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC11_2","074_11_2","ACT","11","2","2","ꠄꠞꠟꠣꠉꠤ ꠙꠤꠔꠞ ꠎꠦꠛꠟꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠟꠣ, ꠁ ꠡꠝꠄ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟꠦ ꠔꠣꠘꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC11_3","074_11_3","ACT","11","3","3","“ꠀꠙꠘꠦ ꠔ ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠣꠁꠟ ꠝꠣꠘꠡꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠍꠂꠘ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠈꠣꠘꠣꠅ ꠈꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC11_4","074_11_4","ACT","11","4","4","ꠔꠦꠃ ꠙꠤꠔꠞꠦ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠊꠐꠍꠤꠟ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠛꠥꠎꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC11_5","074_11_5","ACT","11","5","5","“ꠀꠝꠤ ꠎꠣꠚꠣ ꠡꠢꠞꠅ ꠖꠥꠀ ꠇꠞꠣꠔ ꠀꠍꠟꠣꠝ, ꠅꠝꠘ ꠡꠝꠄ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠖꠞꠡꠘ ꠙꠣꠁꠟꠣꠝ, ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠛꠠ ꠌꠣꠖ꠆ꠖꠞꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠈꠣꠘ ꠌꠤꠎꠞ ꠌꠣꠁꠞ ꠇꠥꠘꠣꠔ ꠗꠞꠤꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠟꠣꠝꠣꠁꠀ ꠖꠦꠅꠀ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("AC11_6","074_11_6","ACT","11","6","6","ꠀꠝꠤ ꠗꠤꠀꠘ ꠗꠞꠤ ꠌꠣꠁꠀ ꠌꠤꠘ꠆ꠔꠣꠔ ꠙꠠꠤꠉꠦꠟꠣꠝ, ꠀꠞ ꠖꠦꠈꠟꠣꠝ, ꠄꠞ ꠝꠣꠎꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠙꠡꠥ, ꠙꠣꠈꠤ, ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞ ꠅꠇꠟ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC11_7","074_11_7","ACT","11","7","7","ꠛꠣꠖꠦ ꠄꠇ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ, ꠙꠤꠔꠞ, ꠃꠑꠅ, ꠝꠣꠞꠤꠀ ꠈꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("AC11_8","074_11_8","ACT","11","8","8","ꠀꠝꠤ ꠇꠁꠟꠣꠝ, ꠘꠣ, ꠘꠣ ꠝꠣꠟꠤꠇ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠘꠣ, ꠘꠣꠙꠣꠇ ꠛꠣ ꠢꠣꠞꠣꠝ ꠇꠥꠘ꠆ꠔꠣ ꠀꠝꠤ ꠇꠥꠘꠥꠖꠤꠘ ꠝꠥꠈꠅ ꠖꠤꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_9","074_11_9","ACT","11","9","9","ꠛꠣꠖꠦ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠅꠃ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠢꠣꠟꠣꠟ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠤ ꠁꠔꠣꠞꠦ ꠢꠣꠞꠣꠝ ꠇꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_10","074_11_10","ACT","11","10","10","ꠅꠃꠟꠣ ꠔꠤꠘꠛꠣꠞ ꠇꠅꠀꠞ ꠛꠣꠖꠦ ꠢꠇꠟꠔꠣ ꠀꠍꠝꠣꠘꠅ ꠔꠥꠟꠤ ꠘꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC11_11","074_11_11","ACT","11","11","11","ꠀꠞ ꠄꠞ ꠟꠉꠦ ꠟꠉꠦꠃ, ꠀꠝꠤ ꠎꠦ ꠛꠣꠠꠤꠔ ꠀꠍꠟꠣꠝ ꠅꠃ ꠛꠣꠠꠤꠔ ꠀꠁꠀ ꠔꠤꠘꠎꠘ ꠝꠣꠘꠥꠡ ꠢꠣꠝꠣꠁꠟ, ꠔꠣꠞꠣꠞꠦ ꠇꠂꠍꠞꠤꠀ ꠕꠣꠇꠤ ꠙꠣꠑꠣꠁꠟ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC11_12","074_11_12","ACT","11","12","12","ꠔꠦꠃ ꠙꠣꠇ ꠞꠥꠢꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ꠇꠥꠘꠥ ꠡꠘ꠆ꠖꠄ ꠘꠣ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ। ꠀꠞ ꠅꠃ ꠍꠄꠎꠘ ꠜꠣꠁꠅ ꠀꠝꠣꠞ ꠟꠉꠦ ꠉꠦꠍꠟꠣ। ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠅꠃ ꠅ-ꠁꠢꠥꠖꠤꠞ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC11_13","074_11_13","ACT","11","13","13","ꠔꠣꠁꠘ ꠇꠤꠟꠣ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠖꠞꠡꠘ ꠙꠣꠁꠍꠟꠣ ꠁꠔꠣ ꠀꠝꠞꠣꠞꠦ ꠢꠥꠘꠣꠁꠟꠣ। ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔ ꠔꠣꠘꠞꠦ ꠇꠁꠍꠟꠣ, ꠍꠣꠁꠝꠘ ꠃꠞꠚꠦ ꠙꠤꠔꠞꠞꠦ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠚꠣ ꠡꠢꠞꠅ ꠝꠣꠘꠥꠡ ꠙꠣꠑꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("AC11_14","074_11_14","ACT","11","14","14","ꠢꠦ ꠔꠥꠝꠣꠞꠦ ꠅꠃꠟꠣ ꠘꠍꠤꠅꠔ ꠇꠞꠛ, ꠎꠦꠔꠣ ꠝꠣꠘꠤꠀ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇꠟꠦ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC11_15","074_11_15","ACT","11","15","15","ꠀꠞ ꠀꠝꠤ ꠛꠄꠀꠘ ꠡꠥꠞꠥ ꠇꠞꠣꠞ ꠛꠣꠖꠦ, ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠄꠟꠣ ꠎꠦꠟꠣ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠁꠍꠟꠣ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃꠟꠣ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_16","074_11_16","ACT","11","16","16","ꠅꠃꠉꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠣꠟꠤꠝ ꠀꠝꠣꠞ ꠝꠘꠅ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, ꠄꠢꠤꠀꠄ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠍꠂꠘ ꠙꠣꠘꠤꠔ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠍꠟ ꠅꠁꠛ ꠙꠣꠇ ꠞꠥꠢꠦ। ");
INSERT INTO syls_vpl VALUES ("AC11_17","074_11_17","ACT","11","17","17","ꠔꠦ ꠜꠣꠁ ꠅꠇꠟ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠖꠣꠘ ꠖꠤꠍꠂꠘ, ꠢꠃ ꠄꠇꠁ ꠖꠣꠘ ꠎꠦꠛꠟꠣ ꠔꠣꠞꠣꠞꠦꠅ ꠖꠤꠟꠣ, ꠔꠦ ꠀꠝꠤ ꠀꠞꠇ ꠎꠘ ꠇꠦ, ꠀꠟ꠆ꠟꠣꠞꠦ ꠘꠣ ꠇꠞꠔꠣꠝ?” ");
INSERT INTO syls_vpl VALUES ("AC11_18","074_11_18","ACT","11","18","18","ꠁꠈꠣꠘ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦ ꠄꠢꠥꠖꠤꠀꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟꠦ ꠀꠞ ꠇꠥꠘꠥ ꠀꠙꠔ꠆ꠔꠤ ꠘꠣ ꠇꠞꠤꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠣ ꠗꠞꠟꠣ, ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦꠅ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠝꠘ ꠛꠖꠟꠣꠁꠀ, ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠅꠀꠞ ꠔꠚꠤꠇ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC11_19","074_11_19","ACT","11","19","19","ꠡ꠆ꠔꠤꠚꠣꠘꠞ ꠝꠃꠔꠞ ꠊꠐꠘꠣꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟ ꠎꠥꠟꠥꠝꠞ ꠟꠣꠉꠤ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠍꠟꠣ, ꠔꠣꠞꠣ ꠚꠂꠘꠤꠇꠤꠀ, ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠀꠞ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠉꠤꠀ ꠈꠣꠟꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_20","074_11_20","ACT","11","20","20","ꠅꠁꠟꠦ ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠄꠎꠘ ꠀꠍꠟꠣ ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠖꠤꠙ ꠀꠞ ꠇꠥꠞꠤꠘꠤ ꠄꠟꠣꠇꠣꠞ ꠝꠣꠘꠥꠡ, ꠄꠞꠣ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠉꠤꠀ ꠁꠃꠘꠣꠘꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦꠅ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_21","074_11_21","ACT","11","21","21","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠟꠣ, ꠔꠦꠃ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠔꠣꠘ ꠝꠥꠈꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_22","074_11_22","ACT","11","22","22","ꠁ ꠈꠛꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠎꠝꠣꠔꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠇꠣꠘꠅ ꠀꠁꠟ, ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞꠦ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_23","074_11_23","ACT","11","23","23","ꠔꠣꠁꠘ ꠢꠘꠅ ꠙꠃꠍꠤꠀ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠀꠟ꠆ꠟꠣꠞ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠖꠦꠈꠤꠀ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠟꠣ, ꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠡꠣ ꠖꠤꠔꠣ ꠕꠣꠇꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠣꠟꠤꠇꠞ ꠘꠣꠝꠦ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC11_24","074_11_24","ACT","11","24","24","ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠄꠇꠎꠘ ꠢꠇ ꠝꠣꠘꠥꠡ, ꠔꠣꠁꠘ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠞ ꠁꠝꠣꠘꠦ ꠇꠣꠝꠤꠟ ꠀꠍꠟꠣ। ꠀꠞ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠝꠣꠟꠤꠇꠞ ꠝꠥꠈꠤ ꠚꠤꠞꠤꠀ ꠀꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC11_25","074_11_25","ACT","11","25","25","ꠛꠣꠖꠦ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠡꠃꠟꠞ ꠔꠣꠟ꠆ꠟꠣꠡꠦ ꠔꠣꠞ꠆ꠡ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC11_26","074_11_26","ACT","11","26","26","ꠀꠞ ꠔꠣꠘꠞꠦ ꠙꠣꠁꠀ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠟꠁꠀ ꠀꠁꠟꠣ। ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠡꠃꠟ ꠙꠥꠞꠣ ꠄꠇ ꠛꠞꠍ ꠢꠘꠅ ꠎꠝꠣꠔꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ꠅꠃ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦ ꠙꠄꠟꠣ ꠁꠍꠣꠄꠁ ꠘꠣꠝꠦ ꠒꠣꠇꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC11_27","074_11_27","ACT","11","27","27","ꠅꠃ ꠡꠝꠄ ꠇꠄꠎꠘ ꠘꠛꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_28","074_11_28","ACT","11","28","28","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠉꠣꠛꠥꠍ ꠘꠣꠝꠞ ꠄꠇ ꠘꠛꠤꠄ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠎꠞꠤꠀꠄ ꠈꠣꠠꠣ ꠅꠁꠀ ꠇꠁꠟꠣ, ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁ ꠎꠥꠠꠤꠀ ꠄꠇ ꠛꠦꠎꠥꠁꠔꠣ ꠘꠤꠖꠣꠘ ꠖꠦꠈꠣ ꠖꠤꠛ; ꠛꠣꠖꠡꠣ ꠇꠦꠟꠣꠖꠥꠍꠞ ꠞꠣꠎꠔ꠆ꠔꠞ ꠇꠣꠟꠅ ꠁꠈꠣꠘ ꠙꠥꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC11_29","074_11_29","ACT","11","29","29","ꠄꠞꠟꠣꠉꠤ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠘꠤꠅꠔ ꠇꠞꠟꠣ, ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟꠞ ꠈꠦꠎꠝꠔꠞ ꠟꠣꠉꠤ, ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠈꠦꠝꠔꠣ ꠝꠣꠚꠤꠇ ꠡꠣꠁꠎ꠆ꠎ ꠙꠣꠑꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC11_30","074_11_30","ACT","11","30","30","ꠀꠞ ꠘꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠇꠣꠝꠅ ꠔꠣꠞꠣ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠡꠃꠟꠞ ꠀꠔꠣꠘꠦ ꠄꠢꠥꠖꠤꠀꠞ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠡꠣꠁꠎ꠆ꠎ ꠙꠣꠑꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_1","074_12_1","ACT","12","1","1","ꠢꠤ ꠡꠝꠄ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠦ ꠎꠝꠣꠔꠞ ꠇꠄꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠗꠞꠣꠁ ꠀꠘꠤꠀ ꠎꠥꠟꠥꠝ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_2","074_12_2","ACT","12","2","2","ꠔꠣꠁꠘ ꠢꠣꠘ꠆ꠘꠣꠘꠞ ꠜꠣꠁ ꠁꠀꠇꠥꠛꠞꠦ ꠔꠟꠥꠀꠞ ꠖꠤꠀ ꠇꠣꠐꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_3","074_12_3","ACT","12","3","3","ꠄꠞꠟꠣꠉꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠈꠥꠡꠤ ꠅꠁꠍꠂꠘ ꠖꠦꠈꠤꠀ, ꠔꠣꠁꠘ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖꠞ ꠅꠇ꠆ꠔꠅ ꠙꠤꠔꠞꠞꠦꠅ ꠀꠐꠇ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_4","074_12_4","ACT","12","4","4","ꠀꠞ ꠔꠣꠘꠞꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠟꠣ, ꠎꠦꠟꠅ-ꠅ ꠙꠣꠢꠣꠞꠣ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠌꠣꠁꠞ ꠎꠘ ꠇꠞꠤ, ꠌꠣꠁꠞ ꠖꠟ ꠍꠤꠙꠣꠁꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ꠢꠦꠞꠥꠖꠞ ꠘꠤꠅꠔ ꠀꠍꠤꠟ ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠛꠣꠖꠦ ꠙꠤꠔꠞꠞꠦ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠛꠣꠞ ꠇꠞꠤ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_5","074_12_5","ACT","12","5","5","ꠙꠤꠔꠞ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠛꠘ꠆ꠖꠤ ꠞꠁꠟꠣ, ꠅꠁꠟꠦ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠦ ꠙꠤꠔꠞꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠀ ꠇꠞꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_6","074_12_6","ACT","12","6","6","ꠛꠤꠌꠣꠞꠞ ꠟꠣꠉꠤ ꠎꠦꠖꠤꠘ ꠙꠤꠔꠞꠞꠦ ꠛꠣꠞꠦ ꠀꠘꠣꠁꠔꠣ, ꠄꠞ ꠀꠉꠞ ꠞꠣꠁꠔ ꠔꠣꠁꠘ ꠖꠥꠁꠎꠘ ꠍꠤꠙꠣꠁꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠖꠥꠁꠉꠦꠍꠣ ꠌꠦꠁꠘꠖꠤ ꠛꠣꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠊꠥꠝꠅ ꠀꠍꠟꠣ, ꠀꠞ ꠛꠣꠞꠦ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠖꠥꠀꠞꠅ ꠙꠣꠢꠣꠞꠣ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_7","074_12_7","ACT","12","7","7","ꠅꠝꠘ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠝꠣꠛꠥꠖꠞ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠢꠘꠅ ꠀꠁꠀ ꠃꠛꠣꠁꠟꠣ, ꠀꠞ ꠎꠦꠟꠞ ꠜꠤꠔꠞ ꠚꠞ ꠅꠁꠉꠦꠟ। ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠙꠤꠔꠞꠞ ꠉꠔꠞꠅ ꠑꠦꠟꠣ ꠖꠤꠀ ꠔꠣꠘꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠎꠟꠖꠤ ꠃꠑꠅ!” ꠔꠦꠃ ꠙꠤꠔꠞꠞ ꠖꠥꠁꠅ ꠀꠔ ꠕꠣꠇꠤ ꠌꠦꠁꠘ ꠈꠥꠟꠤꠀ ꠙꠠꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC12_8","074_12_8","ACT","12","8","8","ꠛꠣꠖꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠇꠝꠞꠅ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠅ ꠀꠞ ꠎꠥꠔꠣ ꠙꠣꠅꠔ ꠖꠦꠅ।” ꠔꠣꠁꠘ ꠅꠃꠟꠣ ꠇꠞꠟꠣ। ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠌꠣꠖ꠆ꠖꠞ ꠉꠔꠞꠅ ꠖꠤꠀ ꠀꠝꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC12_9","074_12_9","ACT","12","9","9","ꠙꠤꠔꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠎꠦꠟꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁ ꠀꠁꠟꠣ, ꠅꠁꠟꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠎꠦꠔꠣ ꠇꠞꠟꠣ, ꠁꠔꠣ ꠎꠦꠘ ꠢꠣꠍꠣꠞꠞꠃ ꠅꠞ, ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠙꠤꠔꠞꠦ ꠛꠥꠎꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ, ꠔꠣꠁꠘ ꠝꠘꠅ ꠇꠞꠟꠣ ꠁꠔꠣ ꠇꠥꠘꠥ ꠖꠞꠡꠘ ꠖꠦꠈꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_10","074_12_10","ACT","12","10","10","ꠔꠣꠞꠣ ꠙꠄꠟꠣ ꠀꠞ ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠙꠣꠞꠣꠖꠣꠞꠞ ꠖꠟꠞꠦ ꠙꠣꠞ ꠅꠁꠀ ꠎꠦꠛꠟꠣ ꠡꠢꠞꠅ ꠢꠣꠝꠣꠁꠛꠣꠞ ꠟꠥꠀꠞ ꠉꠦꠁꠐꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ, ꠉꠦꠁꠐ ꠘꠤꠎꠦ ꠘꠤꠎꠦꠃ ꠈꠥꠟꠤꠉꠦꠟ। ꠔꠣꠞꠣ ꠛꠣꠞ ꠅꠁꠀ ꠄꠇ ꠉꠟ꠆ꠟꠤꠞ ꠢꠦꠡ ꠉꠣꠟꠣꠔ ꠀꠁꠀ ꠀꠎꠤꠟꠣ, ꠀꠞ ꠅꠃ ꠡꠝꠄ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠙꠤꠔꠞꠞ ꠟꠉ ꠕꠣꠇꠤ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC12_11","074_12_11","ACT","12","11","11","ꠔꠦꠃ ꠙꠤꠔꠞꠞ ꠢꠥꠡ ꠅꠁꠟ ꠀꠞ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠈꠘ ꠀꠝꠤ ꠢꠣꠍꠣꠞꠞꠃ ꠛꠥꠎꠟꠣꠝ ꠎꠦꠘ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠙꠣꠑꠣꠁꠀ, ꠢꠦꠞꠥꠖꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠖ ꠈꠣꠁꠡ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC12_12","074_12_12","ACT","12","12","12","ꠔꠣꠁꠘ ꠝꠘꠦ ꠝꠘꠦ ꠁꠔꠣ ꠝꠣꠔꠤ ꠝꠣꠔꠤ ꠝꠞꠤꠅꠝꠞ ꠛꠣꠠꠤꠞ ꠝꠥꠈꠣ ꠉꠦꠟꠣ, ꠁ ꠝꠞꠤꠅꠝ ꠅꠁꠟꠣ ꠢꠣꠘ꠆ꠘꠣꠘ ꠃꠞꠚꠦ ꠝꠣꠞ꠆ꠇꠥꠍꠞ ꠝꠣ। ꠅꠘꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠖꠟꠣ ꠅꠁꠀ ꠖꠥꠀ ꠇꠞꠣꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_13","074_12_13","ACT","12","13","13","ꠙꠤꠔꠞꠦ ꠉꠦꠁꠐꠅ ꠑꠥꠇꠣ ꠝꠣꠞꠣꠞ ꠛꠣꠖꠦ ꠞꠥꠖꠣ ꠘꠣꠝꠞ ꠄꠇ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤꠄ ꠉꠦꠁꠐ ꠈꠥꠟꠣꠔ ꠀꠁꠟ; ");
INSERT INTO syls_vpl VALUES ("AC12_14","074_12_14","ACT","12","14","14","ꠀꠞ ꠙꠤꠔꠞꠞ ꠉꠟꠣꠞ ꠡꠥꠞ ꠢꠥꠘꠤꠀ ꠈꠥꠡꠤꠄ ꠔꠣꠁ ꠉꠦꠁꠐ ꠘꠣ ꠈꠥꠟꠤꠀ ꠖꠃꠠꠤꠀ ꠉꠤꠀ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠇꠁꠟ, “ꠙꠤꠔꠞ ꠀꠁꠀ ꠛꠣꠞꠦ ꠉꠦꠁꠐꠅ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC12_15","074_12_15","ACT","12","15","15","ꠔꠣꠞꠣ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠤ ꠛꠦꠐꠤꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠝꠣꠕꠣ ꠈꠣꠞꠣꠙ ꠅꠁꠍꠦ ꠘꠤ?” ꠛꠦꠐꠤꠄ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠘꠤꠀꠄ ꠇꠞꠤꠀ ꠇꠁꠟ, “ꠘꠣ, ꠢꠣꠍꠣꠃ ꠙꠤꠔꠞꠞ ꠉꠟꠣ ꠢꠥꠘꠍꠤ!” ꠔꠦꠃ ꠢꠇꠟꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠄꠁꠘ ꠝꠘꠦ ꠅꠄ ꠙꠤꠔꠞꠞ ꠍꠥꠞꠔꠦ ꠇꠥꠘꠥ ꠚꠤꠞꠤꠡ꠆ꠔꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC12_16","074_12_16","ACT","12","16","16","ꠁꠛꠣꠄ ꠙꠤꠔꠞꠦ ꠉꠦꠁꠐꠅ ꠑꠥꠇꠣꠘꠤꠔ ꠞꠁꠟꠣ। ꠅꠃ ꠔꠣꠞꠣ ꠈꠥꠟꠤꠀ ꠙꠤꠔꠞꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_17","074_12_17","ACT","12","17","17","ꠙꠤꠔꠞꠦ ꠀꠔꠖꠤ ꠁꠡꠣꠞꠣ ꠖꠤꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠘꠤꠞꠣꠁ ꠅꠀꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠎꠦꠟꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠤꠟꠣ ꠔꠣꠘꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠟꠣ, ꠅꠃꠔꠣ ꠢꠇꠟꠔꠣ ꠇꠁꠟꠣ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠁ ꠈꠛꠞꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠁꠀꠇꠥꠛ ꠀꠞ ꠛꠣꠇꠤ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦꠅ ꠎꠣꠘꠣꠁꠅ।” ꠢꠦꠡꠦ ꠔꠣꠁꠘ ꠅꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠞꠇ ꠎꠣꠉꠣꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC12_18","074_12_18","ACT","12","18","18","ꠞꠣꠁꠔ ꠙꠥꠀꠘꠤꠞ ꠛꠣꠖꠦ ꠙꠤꠔꠞ ꠇꠥꠀꠁ ꠉꠦꠟꠣ, ꠁ ꠝꠣꠔ ꠟꠁꠀ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠃꠟꠥꠡ꠆ꠕꠟ ꠙꠠꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC12_19","074_12_19","ACT","12","19","19","ꠢꠦꠞꠥꠖꠦ ꠔꠣꠘꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠘꠣ ꠙꠣꠅꠀꠄ ꠙꠣꠞꠣꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠎꠦꠞꠣ ꠇꠞꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠛꠣꠖꠦ ꠢꠦꠞꠥꠖ ꠘꠤꠎꠦꠅ ꠄꠢꠥꠖꠤꠀ ꠍꠣꠠꠤꠀ ꠇꠄꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠇꠂꠍꠞꠤꠀꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC12_20","074_12_20","ACT","12","20","20","ꠢꠤ ꠡꠝꠄ ꠢꠦꠞꠥꠖꠦ ꠡꠥꠞ ꠀꠞ ꠍꠤꠖꠘꠞ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠈꠥꠛ ꠉꠥꠍꠣ ꠀꠍꠟꠣ। ꠅꠁꠟꠦ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠖꠦꠡꠅ ꠈꠣꠘꠤꠞ ꠍꠣꠝꠣꠘꠣ ꠀꠁꠔ ꠇꠞꠤ, ꠢꠤꠘꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠄꠇꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠢꠦꠞꠥꠖꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ, ꠔꠣꠞꠣ ꠞꠣꠎꠣꠞ ꠢꠥꠔꠤꠛꠣꠞ ꠊꠞꠞ ꠛꠦꠟꠣꠡ꠆ꠔꠍ ꠘꠣꠝꠞ ꠄꠇ ꠛꠠ ꠉꠥꠟꠣꠝꠞꠦ ꠀꠔ ꠇꠞꠤꠀ ꠞꠣꠎꠣꠞ ꠟꠉꠦ ꠀꠙꠥꠡ ꠇꠞꠣꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_21","074_12_21","ACT","12","21","21","ꠀꠞ ꠢꠦꠞꠥꠖꠦ ꠄꠇ ꠖꠤꠘ ꠑꠤꠇ ꠇꠞꠤꠀ, ꠢꠤꠖꠤꠘ ꠔꠣꠘ ꠞꠣꠎ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠀ ꠡꠤꠋꠢꠣꠡꠘꠅ ꠛꠁꠀ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠜꠣꠡꠘ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_22","074_12_22","ACT","12","22","22","ꠔꠣꠘ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠔ ꠝꠣꠘꠡꠞ ꠛꠥꠟꠤ ꠘꠣꠄ, ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣꠞ ꠛꠥꠟꠤ!” ");
INSERT INTO syls_vpl VALUES ("AC12_23","074_12_23","ACT","12","23","23","ꠀꠞ ꠟꠉꠦ ꠟꠉꠦ ꠝꠣꠛꠥꠖꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠟꠣ, ꠇꠣꠞꠘ ꠢꠦꠞꠥꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠁꠎ꠆ꠎꠔ ꠞꠣꠈꠟꠣ ꠘꠣ। ꠔꠦꠃ ꠇꠤꠞꠝꠤꠞ ꠈꠥꠞꠣꠇ ꠛꠘꠤꠀ ꠔꠣꠘ ꠖꠝ ꠛꠣꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC12_24","074_12_24","ACT","12","24","24","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠇꠟꠛꠣꠄ ꠀꠞꠅ ꠛꠦꠡꠤ ꠍꠤꠔ꠆ꠞꠤꠟ, ꠀꠞ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC12_25","074_12_25","ACT","12","25","25","ꠁꠛꠣꠄ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠡꠃꠟꠞ ꠔꠛꠟꠤꠉ ꠇꠣꠝ ꠡꠦꠡ ꠅꠀꠄ ꠔꠣꠞꠣ ꠢꠣꠘ꠆ꠘꠣꠘ ꠃꠞꠚꠦ ꠝꠣꠞ꠆ꠇꠥꠍꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠚꠤꠞꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_1","074_13_1","ACT","13","1","1","ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ ꠎꠝꠣꠔꠅ ꠇꠄꠎꠘ ꠘꠛꠤ ꠀꠞ ꠃꠡ꠆ꠔꠣꠖ ꠀꠍꠟꠣ, ꠄꠞꠣꠞ ꠘꠣꠝ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ, ꠍꠣꠝꠣꠃꠘ ꠃꠞꠚꠦ ꠇꠣꠟꠣꠜꠣꠁ, ꠇꠥꠞꠤꠘꠤ ꠡꠢꠞꠞ ꠟꠥꠇꠤꠀꠍ, ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠈꠣꠔꠤꠞꠞ ꠝꠣꠘꠥꠡ ꠝꠘꠢꠦꠝ, ꠀꠞ ꠡꠃꠟ। ");
INSERT INTO syls_vpl VALUES ("AC13_2","074_13_2","ACT","13","2","2","ꠄꠞꠣ ꠎꠦꠛꠟꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠤꠀ ꠝꠣꠛꠥꠖꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠔ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠙꠣꠇ ꠞꠥꠢꠦ ꠄꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠡꠃꠟꠞꠦ ꠀꠝꠤ ꠎꠦ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ, ꠅꠃ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞꠦ ꠀꠟꠉ ꠇꠞꠤ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC13_3","074_13_3","ACT","13","3","3","ꠔꠦꠃ ꠄꠞꠣ ꠞꠥꠎꠣ ꠞꠣꠈꠤꠀ, ꠢꠃ ꠖꠥꠁꠅꠎꠘꠞ ꠃꠙꠞꠦ ꠀꠔ ꠕꠁꠀ ꠖꠥꠀ ꠇꠞꠤꠀ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_4","074_13_4","ACT","13","4","4","ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠙꠣꠇ ꠞꠥꠢꠦ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠡꠃꠟꠞꠦ ꠡꠤꠟꠥꠇꠤꠀꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ, ꠀꠞ ꠢꠤꠈꠣꠘ ꠕꠣꠇꠤ ꠎꠣꠎꠅ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠖꠤꠙꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_5","074_13_5","ACT","13","5","5","ꠀꠞ ꠍꠣꠟꠣꠝꠤꠍ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠍꠤꠖꠣꠁꠘ꠆ꠔꠅ ꠢꠣꠝꠣꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ꠔꠣꠞꠣꠞ ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠘ꠆ꠘꠣꠘ ꠃꠞꠚꠦ ꠝꠣꠞ꠆ꠇꠥꠍ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_6","074_13_6","ACT","13","6","6","ꠔꠣꠞꠣ ꠀꠡ꠆ꠔꠣ ꠖꠤꠙ ꠊꠥꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠙꠣꠚꠥꠍ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ, ꠀꠞ ꠢꠤꠘꠅ ꠛꠞ-ꠎꠤꠡꠥ ꠘꠣꠝꠞ ꠄꠇ ꠁꠢꠥꠖꠤ ꠎꠣꠖꠥꠉꠤꠞꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠅꠁꠟ, ꠢꠦ ꠀꠍꠤꠟ ꠜꠘ꠆ꠒ ꠘꠛꠤ। ");
INSERT INTO syls_vpl VALUES ("AC13_7","074_13_7","ACT","13","7","8","ꠔꠣꠞ ꠀꠞꠇ ꠘꠣꠝ ꠀꠍꠤꠟ ꠁꠟꠥꠝꠣ, ꠝꠣꠘꠤ ꠎꠣꠖꠥꠉꠤꠞ। ꠢꠦ ꠅꠁꠟ ꠢꠤ ꠖꠦꠡꠞ ꠢꠣꠇꠤꠝ ꠡꠦꠞ꠆ꠉꠤꠅ ꠙꠣꠃꠟꠥꠍꠞ ꠖꠥꠡ꠆ꠔ, ꠅꠁꠟꠦ ꠢꠤ ꠢꠣꠇꠤꠝ ꠀꠍꠟꠣ ꠄꠇꠎꠘ ꠀꠈꠟꠖꠣꠞ ꠝꠣꠘꠥꠡ, ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠡꠃꠟꠞꠦ ꠈꠛꠞꠖꠤ ꠀꠘꠣꠁꠟꠣ। ꠁꠟꠥꠝꠣꠄ ꠢꠣꠇꠤꠝꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠔꠦ ꠖꠤꠔ ꠘꠣ ꠇꠞꠤ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠡꠃꠟꠞꠦ ꠛꠣꠗꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC13_9","074_13_9","ACT","13","9","9","ꠀꠞ ꠡꠃꠟ, ꠎꠦꠘꠞꠦ ꠙꠣꠃꠟꠥꠍ ꠇꠁꠀꠅ ꠒꠣꠇꠂꠘ, ꠔꠣꠁꠘ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ ꠁꠟꠥꠝꠣꠞ ꠛꠣꠄ ꠗꠤꠀꠘ ꠗꠞꠤ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC13_10","074_13_10","ACT","13","10","10","“ꠅ ꠁꠛꠟꠤꠍꠞ ꠛꠣꠁꠌ꠆ꠌꠣ, ꠢꠇꠟ ꠝꠥꠝꠤꠘꠤ ꠇꠣꠝꠞ ꠖꠥꠡꠝꠘ, ꠔꠞ ꠜꠤꠔꠞꠦ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠍꠟ-ꠌꠔꠥꠞꠤ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠄ ꠜꠞꠣ, ꠔꠥꠁ ꠝꠣꠛꠥꠖꠞ ꠍꠢꠤ ꠙꠕꠞꠦ ꠔꠦꠠꠣ ꠇꠞꠣꠞ ꠚꠤꠇꠤꠞ ꠛꠣꠖ ꠖꠤꠔꠦ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("AC13_11","074_13_11","ACT","13","11","11","ꠢꠥꠘ, ꠝꠣꠛꠥꠖꠞ ꠀꠔ ꠔꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠟꠣꠉꠍꠦ। ꠔꠥꠁ ꠀꠘ꠆ꠖꠣ ꠅꠁꠎꠤꠛꠦ, ꠀꠞ ꠇꠄꠖꠤꠘ ꠡꠥꠞꠥꠎ ꠖꠦꠈꠔꠦ ꠘꠣꠄ।” ꠟꠉꠦ ꠟꠉꠦꠃ ꠈꠥꠀ ꠀꠞ ꠀꠘ꠆ꠖꠣꠁꠞꠦ ꠔꠣꠞꠦ ꠉꠥꠞꠤꠟꠤꠟ, ꠀꠞ ꠢꠦ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠒꠣꠁꠘꠦ-ꠛꠣꠃꠄ ꠇꠦꠃꠞꠞꠦ ꠔꠥꠇꠣꠁꠟ, ꠔꠣꠞꠦ ꠀꠔꠅ ꠗꠞꠤꠀ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC13_12","074_13_12","ACT","13","12","12","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠤ ꠢꠣꠇꠤꠝꠦ ꠝꠣꠟꠤꠇꠞ ꠛꠤꠡꠄꠄ ꠎꠦ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠟꠣ, ꠄꠔꠦ ꠔꠣꠁꠘ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠀ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_13","074_13_13","ACT","13","13","13","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠦ ꠙꠣꠚꠥꠍ ꠍꠣꠠꠤꠀ ꠎꠣꠎꠅ ꠇꠞꠤ ꠙꠣꠝꠚꠥꠟꠤꠀ ꠖꠦꠡꠞ ꠙꠞ꠆ꠉꠣ ꠡꠢꠞꠅ ꠙꠃꠍꠟꠣ। ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘ ꠃꠞꠚꠦ ꠝꠣꠞ꠆ꠇꠥꠍꠦ ꠔꠣꠞꠣꠞꠦ ꠕꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠚꠤꠞꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC13_14","074_13_14","ACT","13","14","14","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠙꠞ꠆ꠉꠣ ꠕꠣꠇꠤ ꠀꠉꠥꠀꠁꠀ ꠙꠤꠡꠤꠖꠤꠀ ꠖꠦꠡꠞ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ ꠡꠢꠞꠅ ꠙꠃꠍꠟꠣ ꠀꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠁꠢꠥꠖꠤꠞ ꠝꠍꠤꠖꠅ ꠢꠣꠝꠣꠁꠀ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_15","074_13_15","ACT","13","15","15","ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠤꠔꠣꠛ ꠕꠣꠇꠤ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠣ ꠡꠦꠡ ꠅꠁꠟꠦ, ꠝꠎꠟꠤꠍꠞ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠜꠣꠁꠍꠣꠛ ꠅꠇꠟ, ꠝꠣꠘꠡꠞꠦ ꠘꠍꠤꠅꠔꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣ ꠛꠄꠀꠘ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠅꠁꠟꠦ, ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC13_16","074_13_16","ACT","13","16","16","ꠅꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠃꠛꠣꠁꠀ ꠀꠔꠖꠤ ꠁꠡꠣꠞꠣ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠅꠞꠣ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠀꠙꠘꠣꠞꠣ ꠢꠥꠘꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_17","074_13_17","ACT","13","17","17","ꠅꠃ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠟꠣ, ꠎꠦꠛꠟꠣ ꠔꠣꠞꠣ ꠝꠤꠡꠞ ꠖꠦꠡꠅ ꠝꠥꠍꠣꠚꠤꠞꠤꠔ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞꠦ ꠝꠢꠣꠘ ꠇꠞꠍꠤꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠝꠢꠣ ꠇꠥꠖꠞꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠢꠤꠈꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_18","074_13_18","ACT","13","18","18","ꠅꠘꠥꠝꠣꠘ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠞꠍ ꠗꠞꠤ ꠔꠣꠁꠘ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠝꠣ-ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞ ꠛꠦꠀꠖꠛꠤ ꠍꠛꠞ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_19","074_13_19","ACT","13","19","19","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠡꠣꠔꠐꠣ ꠎꠣꠔꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠀ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠢꠃ ꠖꠦꠡꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠣꠘ ꠇꠞꠟꠣ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠅꠘꠥꠝꠣꠘ ꠌꠣꠁꠞ-ꠡ ꠙꠁꠘ꠆ꠌꠣꠡ ꠛꠞꠍ ꠉꠥꠎꠞꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC13_20","074_13_20","ACT","13","20","20","ꠢꠦꠡꠦ ꠡꠣꠝꠥꠄꠟ ꠘꠛꠤꠞ ꠀꠝꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠟ꠆ꠟꠣꠄ ꠇꠄꠎꠘ ꠀꠝꠤꠞ ꠛꠦꠎꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_21","074_13_21","ACT","13","21","21","ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠄꠇꠎꠘ ꠛꠣꠖꠡꠣ ꠌꠣꠁꠟ। ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞꠞ ꠟꠣꠉꠤ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠛꠋꠡꠞ ꠇꠤꠡꠞ ꠙꠥꠀ ꠔꠣꠟꠥꠔꠞꠦ ꠛꠣꠖꠡꠣ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_22","074_13_22","ACT","13","22","22","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠟꠥꠔꠞꠦ ꠢꠞꠣꠁꠀ ꠢꠎꠞꠔ ꠖꠣꠃꠖꠞꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠖꠡꠣ ꠛꠣꠘꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠖꠣꠃꠖꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠟꠣ, ‘ꠀꠝꠤ ꠁꠀꠍꠞ ꠙꠥꠀ ꠖꠣꠃꠖꠞꠦ ꠙꠣꠁꠍꠤ, ꠢꠦ ꠀꠝꠣꠞ ꠝꠘꠞ ꠝꠔ ꠝꠣꠘꠥꠡ। ꠀꠝꠣꠞ ꠢꠇꠟ ꠝꠞ꠆ꠎꠤ ꠀꠝꠟ ꠇꠞꠛ।’ ");
INSERT INTO syls_vpl VALUES ("AC13_23","074_13_23","ACT","13","23","23","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠅꠃ ꠝꠣꠘꠡꠞ ꠅꠀꠞꠤꠡ ꠕꠣꠇꠤ ꠄꠇꠎꠘ ꠔꠞꠣꠘꠦꠀꠟꠣ, ꠝꠣꠘꠤ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠎꠤꠞ ꠇꠞꠍꠤꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("AC13_24","074_13_24","ACT","13","24","24","ꠅꠃ ꠁꠍꠣ ꠀꠅꠀꠞ ꠀꠉꠦ ꠢꠇ꠆ꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠢꠎꠞꠔ ꠄꠢꠤꠀꠄ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤꠟꠣ, ‘ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠖꠤꠟ ꠚꠤꠞꠣꠁꠀ ꠢꠣꠞꠤ ꠝꠣꠘꠡꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣ ꠖꠞꠇꠣꠞ।’ ");
INSERT INTO syls_vpl VALUES ("AC13_25","074_13_25","ACT","13","25","25","ꠀꠞ ꠄꠢꠤꠀꠄ ꠔꠣꠘ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠞ ꠀꠈꠦꠞ ꠇꠣꠟꠅ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠅ, ꠀꠝꠤ ꠇꠦ? ꠀꠝꠤ ꠔ ꠢꠤ ꠅꠀꠖꠣ ꠇꠞꠣ ꠀꠟ-ꠝꠍꠤ ꠘꠣꠄ; ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠛꠣꠖꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ। ꠔꠣꠘ ꠙꠣꠅꠞ ꠎꠥꠔꠣꠞ ꠚꠤꠔꠣ ꠈꠥꠟꠣꠞ ꠟꠣꠈꠅ ꠀꠝꠤ ꠘꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("AC13_26","074_13_26","ACT","13","26","26","“ꠔꠦ ꠅ ꠜꠣꠁꠀꠁꠘ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠅꠞꠣ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟ, ꠀꠝꠞꠣ ꠢꠇ꠆ꠇꠟꠞ ꠉꠦꠍꠦꠃ ꠘꠣꠎꠣꠔꠞ ꠁ ꠇꠣꠟꠣꠝ ꠘꠣꠎꠤꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC13_27","074_13_27","ACT","13","27","27","ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠝꠣꠘꠡꠦ ꠀꠞ ꠔꠣꠞꠣꠞ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠁꠍꠣꠞꠦ ꠘꠣ ꠌꠤꠘꠣꠄ, ꠀꠞ ꠙꠞꠔꠦꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠘꠛꠤ ꠅꠇꠟꠞ ꠎꠦ ꠛꠄꠀꠘ ꠔꠤꠟꠣꠅꠔ ꠅꠄ ꠄꠅꠔꠣ ꠘꠣ ꠛꠥꠎꠣꠄ, ꠔꠣꠞꠣ ꠁꠍꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠤꠀ ꠢꠃ ꠇꠕꠣ ꠅꠇꠟ ꠙꠥꠞꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_28","074_13_28","ACT","13","28","28","ꠀꠞ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠈ ꠇꠥꠘꠥ ꠖꠥꠡ ꠘꠣ ꠙꠣꠁꠟꠦꠅ ꠔꠣꠞꠣ ꠢꠣꠇꠤꠝ ꠙꠤꠟꠣꠔꠞ ꠉꠦꠍꠦ ꠖꠣꠛꠤ ꠎꠣꠘꠣꠁꠟꠣ, ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC13_29","074_13_29","ACT","13","29","29","ꠔꠣꠘ ꠛꠤꠡꠄꠄ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛ ꠅꠇꠟꠅ ꠎꠦꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠙꠥꠞꠣ ꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠟ ꠢꠣꠟꠔ ꠕꠣꠇꠤ, ꠝꠣꠘꠤ ꠍꠟꠤꠛ ꠕꠣꠇꠤ ꠟꠣꠝꠣꠁꠀ ꠖꠣꠚꠘ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("AC13_30","074_13_30","ACT","13","30","30","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_31","074_13_31","ACT","13","31","31","ꠀꠞ ꠉꠣꠟꠤꠟ ꠕꠣꠇꠤ ꠎꠦꠞꠣ ꠔꠣꠘ ꠟꠉꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠁꠘ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠖꠦꠈꠣ ꠖꠤꠟꠣ; ꠄꠞꠣꠃ ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_32","074_13_32","ACT","13","32","32","ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠤꠟꠣ, ꠀꠝꠞꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠢꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠎꠣꠘꠣꠁꠞꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("AC13_33","074_13_33","ACT","13","33","33","ꠀꠟ꠆ꠟꠣꠄ ꠁꠍꠣꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠅꠀꠞꠤꠡ ꠅꠇꠟ, ꠝꠣꠘꠤ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠘ ꠅꠀꠖꠣ ꠙꠥꠞꠣ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠁ ꠛꠦꠙꠣꠞꠦ ꠎꠛꠥꠞ ꠇꠤꠔꠣꠛꠞ ꠖꠥꠍꠞꠣ ꠞꠥꠇꠥꠔ ꠅꠃꠟꠣ ꠟꠦꠈꠣ ꠀꠍꠦ: ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠙꠥꠔ, ꠀꠁꠎ ꠕꠣꠇꠤ ꠀꠝꠤ ꠅꠁꠟꠣꠝ ꠔꠥꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("AC13_34","074_13_34","ACT","13","34","34","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠘ ꠔꠣꠘꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠔꠣꠁꠘ ꠎꠦꠘ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠇ꠆ꠇꠄ ꠅꠁꠔꠣ ꠘꠣꠄ, ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠍꠂꠘ: ꠀꠝꠤ ꠖꠣꠃꠖꠞ ꠉꠦꠍꠦ ꠎꠦ ꠙꠣꠇ ꠅꠀꠖꠣ ꠅꠇꠟ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("AC13_35","074_13_35","ACT","13","35","35","ꠔꠣꠁꠘ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠞ ꠀꠞꠇ ꠀꠄꠀꠔꠅ ꠇꠁꠍꠂꠘ: ꠔꠥꠝꠤ ꠘꠤꠎꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣꠞꠦ ꠇ꠆ꠇꠄ ꠅꠁꠔꠦ ꠖꠤꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC13_36","074_13_36","ACT","13","36","36","ꠖꠣꠃꠖ ꠔ ꠢꠤ ꠀꠝꠟꠞ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠤꠀꠟ-ꠈꠥꠡꠤ ꠙꠥꠞꠣ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠁꠘ꠆ꠔꠦꠇꠣꠟ ꠇꠞꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠇ꠆ꠇꠄ ꠅꠁꠉꠦꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC13_37","074_13_37","ACT","13","37","37","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠘꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠄꠁꠘ ꠔ ꠇ꠆ꠇꠄ ꠅꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_38","074_13_38","ACT","13","38","38","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠙꠘꠣꠞꠣꠅ ꠎꠣꠘꠤꠀ ꠞꠣꠈꠃꠇ꠆ꠇꠣ, ꠅꠃ ꠁꠍꠣꠞ ꠝꠣꠎꠖꠤꠀꠃ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠝꠣꠚꠤ ꠙꠣꠅꠀꠞ ꠇꠕꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("AC13_39","074_13_39","ACT","13","39","39","ꠀꠙꠘꠣꠞꠣ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠍꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠎꠦꠇꠥꠘꠥ ꠎꠘꠦ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠦ, ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠢꠦ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC13_40","074_13_40","ACT","13","40","40","ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠣꠅ ꠢꠥꠡꠤꠀꠞ ꠅꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠤꠔꠣꠛꠅ ꠎꠦꠔꠣ ꠛꠄꠀꠘ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠎꠣꠘꠥ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠘꠣ ꠊꠐꠦ: ");
INSERT INTO syls_vpl VALUES ("AC13_41","074_13_41","ACT","13","41","41","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠟꠁꠀ ꠑꠣꠐ꠆ꠐꠣ ꠇꠞ, ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟ ꠇꠞꠅ, ꠔꠥꠝꠞꠣ ꠌꠝꠇꠣꠁꠀ ꠃꠑꠅ ꠀꠞ ꠛꠤꠘꠣꠡ ꠅꠅ; ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠀꠝꠟꠅꠃ ꠀꠝꠤ ꠅꠃꠟꠣ ꠄꠇ ꠇꠣꠝ ꠇꠞꠝꠥ, ꠎꠦ ꠇꠣꠝꠞ ꠇꠕꠣ ꠇꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠁꠟꠦꠅ, ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠛꠤꠡ꠆ꠛꠣꠡ ꠇꠞꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC13_42","074_13_42","ACT","13","42","42","ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠝꠍꠤꠖ ꠕꠣꠇꠤ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, ꠛꠣꠖꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦꠅ ꠔꠣꠞꠣ ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠞꠅ ꠛꠄꠀꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC13_43","074_13_43","ACT","13","43","43","ꠝꠍꠤꠖ ꠕꠣꠇꠤ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ, ꠛꠃꠔ ꠁꠢꠥꠖꠤ ꠀꠞ ꠁꠢꠥꠖꠤ ꠗꠞ꠆ꠝ ꠝꠣꠘꠞꠣ ꠙꠞꠦꠎꠉꠣꠞ ꠅꠇꠟꠦ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟꠣ। ꠄꠞꠣ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠄꠞꠣꠞꠦ ꠃꠔꠡꠣꠢ ꠖꠤꠟꠣ, ꠄꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠃꠙꠞꠦ ꠇꠣꠁꠝ ꠞꠁꠔꠣ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("AC13_44","074_13_44","ACT","13","44","44","ꠛꠣꠖꠞ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠥꠡ ꠖꠟꠦ ꠖꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_45","074_13_45","ACT","13","45","45","ꠅꠁꠟꠦ ꠅꠔ ꠝꠣꠘꠡꠞ ꠜꠤꠠ ꠖꠦꠈꠤꠀ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠁꠋꠡꠣꠄ ꠜꠞꠤ ꠉꠦꠟꠣ, ꠀꠞ ꠙꠣꠃꠟꠥꠍꠦ ꠎꠦꠔꠣ ꠛꠄꠀꠘ ꠇꠞꠟꠣ ꠔꠣꠞꠣ ꠄꠞ ꠘꠤꠘ꠆ꠖꠣ ꠉꠣꠁꠀ ꠔꠣꠘ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_46","074_13_46","ACT","13","46","46","ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠙꠄꠟꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠖꠞꠇꠣꠞ ꠀꠍꠤꠟ; ꠅꠁꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠁꠔꠣ ꠑꠦꠟꠤꠀ ꠢꠞꠣꠁ ꠖꠤꠞꠣ, ꠀꠞ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠝꠣꠁ ꠇꠞꠣ ꠖꠞꠇꠣꠞ ꠝꠘꠅ ꠇꠞꠞꠣ ꠘꠣ, ꠔꠦ ꠀꠝꠞꠣꠅ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠣꠄ ꠘꠎꠞ ꠚꠤꠞꠣꠁꠟ꠆ꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC13_47","074_13_47","ACT","13","47","47","ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠦ ꠀꠝꠞꠣꠞꠦ ꠅꠃꠟꠣ ꠢꠥꠇꠥꠝ ꠇꠞꠍꠂꠘ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠘꠥꠞ ꠢꠤꠡꠣꠛꠦ ꠛꠦꠎꠤꠍꠤ, ꠎꠣꠔꠦ ꠔꠥꠝꠤ ꠖꠥꠘꠤꠀꠞ ꠢꠦꠡ ꠡꠤꠝꠣꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠘꠣꠎꠣꠔꠞ ꠃꠍꠤꠟ꠆ꠟꠣ ꠅꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC13_48","074_13_48","ACT","13","48","48","ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠈꠥꠡꠤ ꠅꠁꠟꠣ ꠀꠞ ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠟꠣ; ꠀꠞ ꠎꠔ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠢꠣꠍꠤꠟꠞ ꠟꠣꠉꠤ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠞꠣꠈꠍꠤꠟꠣ, ꠔꠣꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC13_49","074_13_49","ACT","13","49","49","ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝ ꠢꠤ ꠖꠦꠡꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠙꠃꠍꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC13_50","074_13_50","ACT","13","50","50","ꠅꠁꠟꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠙꠞꠦꠎꠉꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠀꠞ ꠐꠣꠃꠘꠞ ꠛꠠ ꠛꠠ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠃꠍꠇꠣꠁꠀ ꠖꠤꠟ ꠔꠣꠞꠣ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠣꠁꠀ, ꠔꠣꠞꠣꠞ ꠡꠤꠝꠣꠘꠣ ꠕꠣꠇꠤ ꠈꠦꠖꠣꠁꠀ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC13_51","074_13_51","ACT","13","51","51","ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠢꠤ ꠝꠣꠘꠡꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠞ ꠗꠥꠁꠟ ꠏꠣꠠꠤꠀ ꠚꠣꠟꠣꠁꠀ ꠁꠇꠘꠤꠅ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC13_52","074_13_52","ACT","13","52","52","ꠀꠞ ꠢꠤꠘꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟ ꠈꠥꠡꠤꠄ ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠟ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_1","074_14_1","ACT","14","1","1","ꠁꠇꠘꠤꠅ ꠐꠣꠃꠘꠅ ꠀꠁꠀꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠁꠢꠥꠖꠤꠞ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠢꠣꠝꠣꠁꠟꠣ, ꠢꠣꠝꠣꠁꠀ ꠔꠣꠞꠣ ꠅꠝꠘ ꠟꠣꠈꠣꠘ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠛꠃꠔ ꠁꠢꠥꠖꠤ ꠀꠞ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_2","074_14_2","ACT","14","2","2","ꠅꠁꠟꠦ ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤꠄ ꠁꠝꠣꠘ ꠀꠘꠟꠣ ꠘꠣ, ꠔꠣꠞꠣ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠃꠍꠇꠣꠁ ꠖꠤꠀ, ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠛꠣꠄ ꠛꠤꠉꠠꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_3","074_14_3","ACT","14","3","3","ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠢꠤ ꠐꠣꠃꠘꠅ ꠛꠃꠔ ꠖꠤꠘ ꠞꠁꠟꠣ, ꠔꠣꠞꠣ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠝꠣꠟꠤꠇꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ꠀꠞ ꠝꠣꠟꠤꠇꠦꠅ ꠔꠣꠘ ꠞꠢꠝꠔꠞ ꠇꠣꠟꠣꠝꠞ ꠙꠇ꠆ꠇꠦ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠝꠣꠎꠖꠤ, ꠛꠃꠔ ꠝꠥꠎꠦꠎꠣ ꠀꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠅꠇꠟ ꠎꠣꠁꠞ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_4","074_14_4","ACT","14","4","4","ꠛꠣꠖꠦ ꠀꠡ꠆ꠔꠣ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠥꠡ ꠖꠥꠁ ꠖꠟ ꠅꠁꠉꠦꠟ, ꠄꠇ ꠖꠟ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠙꠇ꠆ꠇꠦ, ꠀꠞꠇ ꠖꠟ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠙꠇ꠆ꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("AC14_5","074_14_5","ACT","14","5","5","ꠅꠁꠟꠦ ꠁꠢꠥꠖꠤ ꠀꠞ ꠅ-ꠁꠢꠥꠖꠤ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ, ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠀꠞ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠣꠞ ꠚꠘ꠆ꠖꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_6","074_14_6","ACT","14","6","6","ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠁꠔꠣ ꠐꠦꠞ ꠙꠣꠁꠀ ꠟꠥꠇꠣꠄꠘꠤꠀ ꠖꠦꠡꠞ ꠟꠥꠡ꠆ꠞꠣ ꠀꠞ ꠖꠞ꠆ꠛꠤ ꠡꠢꠞꠅ, ꠀꠞ ꠄꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠔ ꠜꠣꠉꠤꠀ ꠞꠁꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("AC14_7","074_14_7","ACT","14","7","7","ꠔꠣꠞꠣ ꠢꠘꠅ ꠁꠘ꠆ꠎꠤꠟꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_8","074_14_8","ACT","14","8","8","ꠟꠥꠡ꠆ꠞꠣ ꠐꠣꠃꠘꠅ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠛꠅꠀꠔ ꠕꠣꠇꠔ, ꠔꠣꠞ ꠙꠣꠅꠔ ꠇꠥꠘꠥ ꠛꠟ ꠀꠍꠤꠟ ꠘꠣ, ꠢꠦ ꠝꠣʼꠞ ꠙꠦꠐ ꠕꠣꠇꠤꠃ ꠟꠦꠋꠠꠣ, ꠇꠥꠘꠥꠖꠤꠘꠅ ꠀꠐꠔ ꠙꠣꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_9","074_14_9","ACT","14","9","9","ꠢꠦ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠔ ꠀꠍꠤꠟ; ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠞ ꠛꠣꠄ ꠗꠤꠀꠘ ꠇꠞꠤ ꠌꠣꠁꠟꠣ, ꠀꠞ ꠜꠣꠟꠣ ꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠁꠝꠣꠘ ꠀꠍꠦ ꠛꠥꠎꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("AC14_10","074_14_10","ACT","14","10","10","ꠔꠣꠞꠦ ꠎꠥꠞꠦ ꠒꠣꠇꠖꠤ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠙꠣꠅꠔ ꠜꠞꠖꠤ ꠡꠤꠗꠣ ꠅꠁꠀ ꠃꠛꠣꠅ!” ꠔꠦꠃ ꠟꠉꠦ ꠟꠉꠦꠃ ꠝꠣꠘꠥꠡꠉꠥ ꠚꠣꠟꠖꠤ ꠃꠑꠤꠀ ꠀꠐꠔ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("AC14_11","074_14_11","ACT","14","11","11","ꠙꠣꠃꠟꠥꠍꠞ ꠁ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠡꠦ ꠟꠥꠇꠣꠄꠘꠤꠀ ꠜꠣꠡꠣꠄ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠖꠦꠛꠔꠣ ꠅꠇꠟꠦ ꠝꠣꠘꠡꠞ ꠍꠥꠞꠔ ꠗꠞꠤꠀ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠣꠝꠤꠀ ꠀꠁꠍꠂꠘ!” ");
INSERT INTO syls_vpl VALUES ("AC14_12","074_14_12","ACT","14","12","12","ꠀꠞ ꠝꠣꠘꠡꠦ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠘꠣꠝ ꠖꠤꠟ ‘ꠎꠤꠃꠍ ꠖꠦꠛ’ ꠀꠞ ꠙꠣꠃꠟꠥꠍ ꠛꠠ ꠛꠄꠀꠘ ꠇꠞꠞꠣ ꠉꠔꠤꠇꠦ, ꠔꠣꠘ ꠘꠣꠝ ꠖꠤꠟ ‘ꠢꠣꠞ꠆ꠝꠤꠍ ꠖꠦꠛ’। ");
INSERT INTO syls_vpl VALUES ("AC14_13","074_14_13","ACT","14","13","13","ꠡꠢꠞꠞ ꠛꠣꠁꠞꠣ ꠝꠥꠟ ꠉꠦꠁꠐꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠤꠃꠍ ꠖꠦꠛꠔꠣꠞ ꠝꠘ꠆ꠖꠤꠞꠞ ꠛꠣꠛꠘ ꠑꠣꠇꠥꠞꠦ ꠛꠤꠍꠣꠟ ꠀꠞ ꠝꠣꠟꠣ ꠟꠁꠀ ꠀꠁꠟ, ꠇꠣꠞꠘ ꠢꠤ ꠑꠣꠇꠥꠞꠦ ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠦ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠘꠤꠅꠔꠦ ꠙꠡꠥ ꠛꠟꠤ ꠖꠤꠔ ꠌꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC14_14","074_14_14","ACT","14","14","14","ꠅꠁꠟꠦ ꠍꠣꠢꠣꠛꠤ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠙꠣꠃꠟꠥꠍꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠛꠦꠇꠞꠣꠞ ꠛꠘꠤꠀ ꠎꠣꠞꠎꠤꠞ ꠚꠤꠘ꠆ꠘꠞ ꠇꠣꠙꠠ ꠍꠤꠠꠤꠀ ꠖꠃꠠꠤꠀ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠉꠦꠟꠣ, ꠀꠞ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC14_15","074_14_15","ACT","14","15","15","“ꠅ ꠍꠣꠛ ꠅꠇꠟ, ꠀꠙꠘꠣꠞꠣ ꠇꠦꠘꠦ ꠁꠔꠣ ꠇꠞꠞꠣ? ꠀꠝꠞꠣ ꠔ ꠈꠣꠟꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠈꠣꠘꠃ ꠖꠥꠈꠤ-ꠡꠥꠈꠤ ꠝꠣꠘꠥꠡ, ꠀꠝꠞꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ, ꠎꠣꠔꠦ ꠁ ꠅꠡꠣꠞ ꠢꠇꠟꠔꠣ ꠛꠣꠖ ꠖꠤꠀ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠂꠘ, ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ, ꠖꠞꠤꠀ ꠀꠞ ꠄꠞꠝꠣꠎꠦ ꠎꠔꠔꠣ ꠀꠍꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC14_16","074_14_16","ACT","14","16","16","ꠀꠉꠞ ꠀꠝꠟꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠔꠣꠁꠘ ꠎꠣꠞꠎꠤꠞ ꠁꠌ꠆ꠍꠣꠝꠔ ꠙꠕꠦ ꠌꠟꠔꠦ ꠖꠤꠍꠂꠘ; ");
INSERT INTO syls_vpl VALUES ("AC14_17","074_14_17","ACT","14","17","17","ꠔꠣ-ꠅ ꠔꠣꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠘꠤꠎꠞꠦ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠝꠦꠊ ꠖꠤꠀ, ꠡꠝꠄ ꠝꠔ ꠚꠡꠟ ꠖꠣꠘ ꠇꠞꠤꠀ ꠔꠣꠘ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠙꠦꠐ ꠜꠞꠣ ꠈꠣꠘꠤ ꠀꠞ ꠖꠤꠟꠞ ꠀꠞꠣꠝ ꠎꠥꠉꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC14_18","074_14_18","ACT","14","18","18","ꠁ ꠝꠣꠔ ꠅꠇꠟ ꠝꠣꠔꠣꠞ ꠛꠣꠖꠦꠅ ꠛꠃꠔ ꠇꠡ꠆ꠐ ꠇꠞꠤꠀ ꠄꠞꠣꠞ ꠙꠡꠥ ꠛꠟꠤ ꠖꠦꠅꠀ ꠛꠘ꠆ꠖ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_19","074_14_19","ACT","14","19","19","ꠛꠣꠖꠦ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ ꠀꠞ ꠁꠇꠘꠤꠅ ꠕꠣꠇꠤ ꠇꠄꠎꠘ ꠁꠢꠥꠖꠤ ꠀꠁꠀ, ꠙꠣꠃꠟꠥꠍꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠣꠘꠡꠞꠦ ꠃꠍꠇꠣꠁꠀ ꠖꠤꠀ ꠔꠣꠘꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠟ, ꠀꠞ ꠔꠣꠁꠘ ꠝꠞꠤꠉꠦꠍꠂꠘ ꠝꠘꠦ ꠇꠞꠤꠀ, ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠍꠦꠌꠠꠣꠁꠀ ꠟꠁꠀ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC14_20","074_14_20","ACT","14","20","20","ꠅꠁꠟꠦ ꠝꠥꠝꠤꠘ ꠅꠇꠟ ꠔꠣꠘ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠄꠇꠟꠉꠦ ꠖꠟꠣ ꠅꠀꠞ ꠛꠣꠖꠦ, ꠔꠣꠁꠘ ꠃꠑꠤꠀ ꠐꠣꠃꠘꠅ ꠚꠤꠞꠤꠀ ꠉꠦꠟꠣ। ꠛꠣꠖꠞ ꠖꠤꠘ ꠔꠣꠁꠘ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠟꠉꠦ ꠅꠁꠀ ꠖꠞ꠆ꠛꠤ ꠡꠢꠞꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC14_21","074_14_21","ACT","14","21","21","ꠖꠞ꠆ꠛꠤꠔ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠢꠘꠅ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠁꠝꠣꠘꠖꠣꠞ ꠛꠣꠘꠣꠁꠟꠣ, ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠟꠥꠡ꠆ꠞꠣ, ꠁꠇꠘꠤꠅ ꠀꠞ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠚꠤꠞꠔ ꠉꠦꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("AC14_22","074_14_22","ACT","14","22","22","ꠢꠘꠅ ꠉꠤꠀ ꠔꠣꠞꠣ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠁꠝꠣꠘꠤ ꠛꠟ ꠛꠣꠠꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠉꠤꠖ ꠖꠤꠟꠣ, ꠔꠣꠞꠣ ꠇꠁꠟꠣ, ꠛꠃꠔ ꠖꠥꠈ-ꠔꠇꠟꠤꠚꠞ ꠙꠕ ꠙꠣꠞ ꠅꠁꠀ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠢꠣꠝꠣꠘꠤ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("AC14_23","074_14_23","ACT","14","23","23","ꠔꠣꠞꠣ ꠎꠝꠣꠔꠞꠦ ꠌꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠙꠞꠔꠦꠇ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ-ꠇꠝꠤꠐꠤ ꠛꠣꠘꠣꠁꠟꠣ। ꠀꠞ ꠎꠦ ꠝꠣꠟꠤꠇꠞ ꠃꠙꠞꠦ ꠔꠣꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ, ꠄꠘ ꠘꠣꠝꠦ ꠞꠥꠎꠣ ꠞꠣꠈꠤꠀ ꠖꠥꠀ ꠇꠞꠤꠀ ꠅꠃ ꠁꠍꠣꠞ ꠀꠔꠅ ꠄꠞꠣꠞꠦ ꠡꠙꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_24","074_14_24","ACT","14","24","24","ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠙꠤꠡꠤꠖꠤꠀ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠙꠣꠝꠚꠥꠟꠤꠀ ꠖꠦꠡꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_25","074_14_25","ACT","14","25","25","ꠔꠣꠞꠣ ꠙꠞ꠆ꠉꠣ ꠡꠢꠞꠅ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠀꠘ꠆ꠔꠥꠟꠤꠀ ꠎꠣꠎ ꠊꠣꠐꠅ ꠉꠦꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("AC14_26","074_14_26","ACT","14","26","26","ꠀꠘ꠆ꠔꠥꠟꠤꠀ ꠕꠣꠇꠤ ꠎꠣꠎꠅ ꠃꠑꠤꠀ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠚꠤꠞꠔ ꠀꠁꠟꠣ। ꠔꠣꠞꠣ ꠁ ꠍꠚꠞꠅ ꠎꠦꠔꠣ ꠇꠣꠝ ꠅꠇꠟ ꠁꠘ꠆ꠎꠣꠝ ꠇꠞꠍꠤꠟꠣ, ꠁ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ ꠕꠣꠇꠤꠃ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠢꠦꠚꠣꠎꠔꠅ ꠡꠙꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC14_27","074_14_27","ACT","14","27","27","ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠙꠃꠍꠤꠀ ꠎꠝꠣꠔꠞ ꠢꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠟꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠁ ꠐꠣꠃꠘꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠀ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠣꠝ ꠅꠇꠟ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠔꠣꠁꠘ ꠇꠤꠟꠣ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠀ ꠖꠤꠍꠂꠘ, ꠁ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC14_28","074_14_28","ACT","14","28","28","ꠢꠦꠡꠦ ꠔꠣꠞꠣ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠟꠉꠦ ꠢꠤꠈꠣꠘꠅ ꠛꠃꠔ ꠖꠤꠘ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_1","074_15_1","ACT","15","1","1","ꠄꠢꠥꠖꠤꠀ ꠕꠣꠇꠤ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠀꠁꠟꠣ ꠀꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠅꠃ ꠔꠣꠟꠤꠝ ꠢꠤꠇꠣꠘꠤꠔ ꠟꠣꠉꠟꠣ, “ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ ꠘꠣ ꠅꠁꠟꠦ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC15_2","074_15_2","ACT","15","2","2","ꠁꠔꠣ ꠟꠁꠀ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠟꠉꠦ ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞ ꠈꠥꠛ ꠇꠕꠣ ꠇꠣꠐꠣꠇꠣꠐꠤ ꠅꠁꠟ। ꠛꠣꠖꠦ ꠑꠤꠇ ꠅꠁꠟ, ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠞ ꠇꠄꠎꠘ ꠁꠝꠣꠘꠖꠣꠞꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠁꠛꠣ, ꠉꠤꠀ ꠔꠣꠞꠣ ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠁ ꠛꠤꠡꠄꠄ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_3","074_15_3","ACT","15","3","3","ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠞ ꠎꠝꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠎꠣꠅꠀꠞ ꠛꠘ꠆ꠖꠛꠡ꠆ꠔ ꠇꠞꠤ ꠖꠤꠟꠣ, ꠚꠂꠘꠤꠇꠤꠀ ꠀꠞ ꠡꠝꠞꠤꠀ ꠄꠟꠣꠇꠣꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠇꠤꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠦꠞ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_4","074_15_4","ACT","15","4","4","ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠀ ꠙꠃꠍꠣꠞ ꠛꠣꠖꠦ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠦ, ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦꠅ ꠔꠣꠞꠣꠞꠦ ꠝꠣꠄꠀꠞ ꠘꠎꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠟꠣ। ꠀꠞ ꠔꠣꠞꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_5","074_15_5","ACT","15","5","5","ꠅꠃ ꠡꠝꠄ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠇꠄꠎꠘ ꠁꠝꠣꠘꠖꠣꠞꠦ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤ ꠎꠞꠥꠞ, ꠀꠞ ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠅ ꠀꠝꠟ ꠇꠞꠦ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠅꠀ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("AC15_6","074_15_6","ACT","15","6","6","ꠔꠦꠃ ꠁ ꠛꠤꠡꠄꠅꠞ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠀꠞ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠄꠇ ꠎꠣꠉꠣꠔ ꠖꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_7","074_15_7","ACT","15","7","7","ꠛꠃꠔ ꠛꠣꠔꠌꠤꠔꠞ ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠙꠤꠔꠞꠦ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠜꠣꠁꠀꠁꠘ ꠅꠇꠟ, ꠀꠙꠘꠣꠞꠣ ꠔ ꠎꠣꠘꠂꠘ, ꠛꠃꠔ ꠖꠤꠘ ꠀꠉꠦ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠘꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦꠅ ꠀꠝꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠢꠥꠘꠤꠀ ꠁꠝꠣꠘ ꠀꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC15_8","074_15_8","ACT","15","8","8","ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠢꠇꠟꠞ ꠖꠤꠟꠞ ꠈꠛꠞ ꠎꠣꠘꠂꠘ, ꠔꠦ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦꠅ ꠅꠃꠟꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠤꠀ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠔꠣꠞꠣꠅ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC15_9","074_15_9","ACT","15","9","9","ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠀꠞ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠟꠣꠖꠣ ꠇꠥꠘ꠆ꠔꠣ ꠞꠣꠈꠍꠂꠘ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ ꠇꠞꠤ, ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠍꠣꠚ ꠇꠞꠤꠟꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC15_10","074_15_10","ACT","15","10","10","ꠔꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠦ ꠛꠣ ꠀꠝꠞꠣꠅ ꠎꠦ ꠜꠣꠞ ꠛꠁꠔꠣꠝ ꠙꠣꠞꠍꠤ ꠘꠣ, ꠢꠤ ꠜꠣꠞ ꠅ-ꠁꠢꠥꠖꠤ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠇꠣꠘ꠆ꠖꠅ ꠔꠥꠟꠤꠀ ꠖꠤꠀ, ꠇꠦꠘꠦ ꠀꠙꠘꠣꠞꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠞꠣ? ");
INSERT INTO syls_vpl VALUES ("AC15_11","074_15_11","ACT","15","11","11","ꠀꠝꠞꠣ ꠔ ꠝꠘꠅ ꠇꠞꠤ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠝꠦꠢꠦꠞꠛꠣꠘꠤꠄ ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠝꠣꠚꠤ ꠙꠣꠁꠍꠤ, ꠔꠣꠞꠣꠅ ꠅꠃꠟꠣ ꠝꠣꠚꠤ ꠙꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC15_12","074_15_12","ACT","15","12","12","ꠔꠦꠃ ꠢꠇ꠆ꠇꠟ ꠘꠤꠞꠣꠁ ꠅꠁꠉꠦꠟꠣ; ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠎꠞꠤꠀꠄ ꠀꠟ꠆ꠟꠣꠄ ꠅ-ꠁꠢꠥꠖꠤꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠝꠥꠎꠦꠎꠣ ꠀꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠅꠇꠟ ꠇꠞꠣꠁꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠅꠔꠣ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_13","074_15_13","ACT","15","13","13","ꠔꠣꠞꠣꠞ ꠛꠄꠀꠘ ꠡꠦꠡ ꠅꠀꠞ ꠛꠣꠖꠦ ꠁꠀꠇꠥꠛꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁꠍꠣꠛ ꠅꠇꠟ, ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ");
INSERT INTO syls_vpl VALUES ("AC15_14","074_15_14","ACT","15","14","14","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠘ꠆ꠖꠣ ꠅꠀꠞ ꠟꠣꠉꠤ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠕꠣꠇꠤ ꠄꠇꠖꠟ ꠝꠣꠘꠡꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠘꠤꠀ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠣꠄꠅ ꠔꠣꠘ ꠈꠤꠀꠟ ꠀꠍꠦ, ꠀꠞ ꠅꠃ ꠇꠕꠣꠃ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞꠦ ꠅꠈꠘ ꠛꠄꠀꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC15_15","074_15_15","ACT","15","15","15","ꠁ ꠛꠄꠀꠘꠞ ꠟꠉꠦ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠣꠟꠣꠝꠞꠅ ꠝꠤꠟ ꠀꠍꠦ; ꠎꠦꠟꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("AC15_16","074_15_16","ACT","15","16","16","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠀꠁꠀ ꠖꠣꠃꠖꠞ ꠙꠠꠤ ꠎꠣꠅꠀ ꠊꠞ ꠢꠤꠞꠛꠣꠞ ꠔꠤꠀꠞ ꠇꠞꠝꠥ, ꠎꠦꠔꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠍꠦ ꠁꠔꠣ ꠢꠤꠞꠛꠣꠞ ꠉꠣꠕꠤꠝꠥ, ꠢꠤꠞꠛꠣꠞ ꠘꠄꠀ ꠇꠞꠤꠀ ꠛꠣꠘꠣꠁꠝꠥ, ");
INSERT INTO syls_vpl VALUES ("AC15_17","074_15_17","ACT","15","17","17","ꠎꠣꠔꠦ ꠛꠣꠇꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠂꠘ, ꠀꠞ ꠎꠔ ꠅ-ꠁꠢꠥꠖꠤꠞ ꠘꠣꠝ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣꠞ ꠈꠣꠔꠣꠔ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠣꠞꠣꠅ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠂꠘ। ꠝꠣꠛꠥꠖꠦꠃ ꠅꠃ ꠇꠣꠟꠣꠝ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("AC15_18","074_15_18","ACT","15","18","18","ꠁꠔꠣ ꠛꠃꠔ ꠖꠤꠘ ꠀꠉ ꠕꠣꠇꠤꠃ ꠔꠣꠘ ꠝꠣꠟꠥꠝ ꠀꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("AC15_19","074_15_19","ACT","15","19","19","ꠁꠀꠇꠥꠛꠦ ꠀꠞꠅ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠝꠣꠞ ꠚꠄꠍꠣꠟꠣ ꠅꠁꠟ, ꠅ-ꠁꠢꠥꠖꠤ ꠕꠣꠇꠤ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠙꠕꠤ ꠅꠞ, ꠔꠣꠞꠣꠞꠦ ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠖꠥꠈ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC15_20","074_15_20","ACT","15","20","20","ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠈꠣꠟꠤ ꠅꠃ ꠢꠥꠇꠥꠝꠈꠣꠘ ꠟꠦꠈꠤꠀ ꠎꠣꠘꠣꠁ ꠖꠦꠁ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠞ ꠢꠇ꠆ꠇꠟ ꠇꠣꠝ ꠕꠣꠇꠤ, ꠎꠤꠘꠣꠞ ꠇꠣꠝ ꠕꠣꠇꠤ, ꠀꠞ ꠉꠟꠣ ꠐꠤꠙꠤꠀ ꠝꠣꠞꠣ ꠎꠣꠘꠖꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠅꠀ ꠀꠞ ꠟꠃ ꠈꠣꠅꠀ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC15_21","074_15_21","ACT","15","21","21","ꠁ ꠢꠥꠇꠥꠝ ꠅꠇꠟ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠘꠤꠈꠣꠘ ꠜꠣꠟꠣ, ꠇꠣꠞꠘ ꠝꠥꠍꠣꠄ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠛꠃꠔ ꠎꠝꠣꠘꠣ ꠕꠣꠇꠤ ꠙꠞꠔꠦꠇ ꠐꠣꠃꠘꠅ ꠝꠣꠘꠡꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣ, ꠀꠞ ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠟꠦꠈꠤꠀ ꠕꠁꠀ ꠉꠦꠍꠂꠘ, ꠁꠔꠣ ꠔ ꠙꠞꠔꠦꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠝꠍꠤꠖꠣꠁꠘ꠆ꠔꠅ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠣ ꠅꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC15_22","074_15_22","ACT","15","22","22","ꠔꠦꠃ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ, ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ, ꠀꠞ ꠎꠝꠣꠔꠞ ꠢꠇꠟ ꠀꠝ ꠝꠣꠘꠡꠦ ꠄꠇꠝꠔ ꠅꠁꠟꠣ, ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠇꠄꠎꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠟꠉꠦ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠛꠣ। ꠅꠃ ꠔꠣꠞꠣ ꠍꠤꠟꠣꠍ ꠀꠞ ꠄꠢꠥꠖꠣ ꠃꠞꠚꠦ ꠛꠣꠞ꠆ꠡꠣꠛ꠆ꠛꠣ ꠘꠣꠝꠞ ꠅꠃ ꠖꠥꠁ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_23","074_15_23","ACT","15","23","23","ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠅꠃ ꠌꠤꠑꠤ ꠟꠦꠈꠤꠀ ꠙꠣꠑꠣꠁꠟꠣ: “ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ, ꠡꠤꠞꠤꠀ ꠀꠞ ꠇꠤꠟꠤꠇꠤꠀꠞ ꠅ-ꠁꠢꠥꠖꠤ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ, ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ, ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ, ꠀꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠁ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC15_24","074_15_24","ACT","15","24","24","ꠀꠝꠞꠣ ꠢꠥꠘꠟꠣꠝ ꠎꠦꠘ, ꠀꠝꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠎꠛꠣꠘꠖꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠅꠡ꠆ꠕꠤꠞ ꠛꠣꠘꠣꠁꠀ ꠙꠦꠞꠦꠡꠣꠘꠤ ꠇꠞꠣꠞ; ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠔ ꠔꠣꠞꠣꠞꠦ ꠁꠟꠣ ꠇꠣꠝꠞ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_25","074_15_25","ACT","15","25","25","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠄꠇꠝꠔ ꠅꠁꠀ ꠇꠄꠎꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ, ꠀꠝꠞꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠙꠣꠃꠟꠥꠍꠞ ꠟꠉꠦ ꠇꠞꠤ ꠔꠣꠞꠣꠞꠦ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("AC15_26","074_15_26","ACT","15","26","26","ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠞ ꠙꠣꠃꠟꠥꠍ ꠔ ꠀꠝꠞꠣꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠝꠞꠣꠞ ꠎꠥꠇꠣ ꠅꠁꠉꠦꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_27","074_15_27","ACT","15","27","27","ꠀꠝꠞꠣ ꠄꠢꠥꠖꠣ ꠀꠞ ꠍꠤꠟꠣꠍꠞꠦꠅ ꠙꠣꠑꠣꠁꠟꠣꠝ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠝꠥꠈꠦ ꠝꠥꠈꠦꠅ ꠎꠣꠘꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_28","074_15_28","ACT","15","28","28","ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠞ ꠀꠝꠞꠣ ꠝꠤꠟꠤꠀ ꠅꠐꠣꠃ ꠜꠣꠟꠣ ꠝꠘꠅ ꠇꠞꠟꠣꠝ ꠎꠦꠘ, ꠅꠃ ꠎꠞꠥꠞꠤ ꠔꠣꠟꠤꠝ ꠅꠇꠟ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥ ꠜꠣꠞ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠘꠣ ꠉꠍꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("AC15_29","074_15_29","ACT","15","29","29","ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠞ ꠝꠣꠘꠣ ꠇꠥꠘꠥ ꠈꠣꠘꠤ, ꠟꠃ, ꠀꠞ ꠉꠟꠣ ꠐꠤꠙꠤꠀ ꠝꠣꠞꠣ ꠎꠣꠘꠖꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛꠣ ꠘꠣ, ꠀꠞ ꠎꠤꠘꠣꠞ ꠇꠣꠝ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠞꠁꠛꠣ; ꠁꠔꠣ ꠕꠣꠇꠤ ꠢꠦꠚꠣꠎꠔ ꠞꠁꠟꠦ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ। ꠁꠔꠤ, ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ।” ");
INSERT INTO syls_vpl VALUES ("AC15_30","074_15_30","ACT","15","30","30","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠀꠁꠟꠣ, ꠢꠤꠘꠅ ꠔꠣꠞꠣ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠤ ꠌꠤꠑꠤꠈꠣꠘ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_31","074_15_31","ACT","15","31","31","ꠝꠣꠘꠡꠦ ꠌꠤꠑꠤꠈꠣꠘ ꠙꠠꠤꠀ ꠁ ꠡꠣꠘ꠆ꠔꠤꠞ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠤꠀ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_32","074_15_32","ACT","15","32","32","ꠄꠢꠥꠖꠣ ꠀꠞ ꠍꠤꠟꠣꠍ, ꠄꠞꠣ ꠖꠥꠁꠅꠎꠘ ꠘꠛꠤ ꠀꠍꠟꠣ, ꠄꠞꠣ ꠢꠤꠘꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠛꠃꠔ ꠟꠣꠈꠣꠘ ꠅꠀꠎ-ꠘꠍꠤꠅꠔ ꠇꠞꠤꠀ ꠃꠔꠡꠣꠢ ꠖꠤꠟꠣ ꠀꠞ ꠔꠣꠞꠣꠞ ꠁꠝꠣꠘꠤ ꠛꠟ ꠝꠎꠛꠥꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_33","074_15_33","ACT","15","33","34","ꠢꠘꠅ ꠛꠣꠇ꠆ꠇꠣ ꠇꠄꠖꠤꠘ ꠞꠅꠀꠞ ꠛꠣꠖꠦ, ꠎꠦꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠟꠣ ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠢꠤꠞꠛꠣꠞ ꠚꠤꠞꠔ ꠀꠁꠔꠣ ꠇꠞꠤ, ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠀ ꠛꠤꠖꠣꠄ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_35","074_15_35","ACT","15","35","35","ꠅꠁꠟꠦ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠞꠁꠉꠦꠟꠣ, ꠔꠣꠞꠣ ꠢꠤꠘꠅ ꠀꠞꠅ ꠛꠃꠔꠞ ꠟꠉꠦ ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝꠞ ꠔꠣꠟꠤꠝ ꠀꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_36","074_15_36","ACT","15","36","36","ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠎꠣꠉꠣꠁꠘ꠆ꠔꠅ ꠀꠉꠦ ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠟꠣꠝ, ꠀꠅ, ꠢꠃ ꠎꠣꠉꠣꠁꠘ꠆ꠔꠅ ꠢꠤꠞꠛꠣꠞ ꠉꠤꠀ ꠖꠦꠈꠣ ꠇꠞꠤ। ꠖꠦꠈꠤꠀ ꠀꠁ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠇꠤꠔꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC15_37","074_15_37","ACT","15","37","37","ꠔꠦꠃ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠈꠤꠀꠟ ꠅꠁꠟ, ꠢꠣꠘ꠆ꠘꠣꠘ ꠃꠞꠚꠦ ꠝꠣꠞ꠆ꠇꠥꠍꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠎꠣꠁꠔꠣ; ");
INSERT INTO syls_vpl VALUES ("AC15_38","074_15_38","ACT","15","38","38","ꠅꠁꠟꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠄꠘꠞꠦ ꠟꠉꠦ ꠘꠦꠅꠀ ꠜꠣꠟꠣ ꠝꠘꠅ ꠇꠞꠟꠣ ꠘꠣ, ꠇꠣꠞꠘ ꠝꠣꠞ꠆ꠇꠥꠍꠦ ꠀꠉꠦ ꠙꠣꠝꠚꠥꠟꠤꠀꠔ ꠔꠣꠞꠣꠞꠦ ꠚꠣꠟꠣꠁꠀ ꠉꠦꠍꠟꠣꠉꠤ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠇꠣꠝ ꠇꠞꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_39","074_15_39","ACT","15","39","39","ꠄꠞꠟꠣꠉꠤ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠝꠣꠎꠦ ꠝꠔꠞ ꠅꠝꠤꠟ ꠅꠁꠉꠦꠟ ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠙꠕꠦ ꠀꠟꠉ ꠅꠁꠉꠦꠟꠣ। ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠝꠣꠞ꠆ꠇꠥꠍꠞꠦ ꠟꠁꠀ ꠎꠣꠎꠅ ꠇꠞꠤ ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠖꠤꠙꠅ ꠉꠦꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("AC15_40","074_15_40","ACT","15","40","40","ꠀꠞ ꠙꠣꠃꠟꠥꠍꠦ ꠍꠤꠟꠣꠍꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ, ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠎꠞꠤꠀꠄ ꠝꠣꠛꠥꠖꠞ ꠞꠢꠝꠔꠞ ꠀꠔꠅ ꠡꠙꠣ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC15_41","074_15_41","ACT","15","41","41","ꠔꠣꠁꠘ ꠡꠤꠞꠤꠀ ꠀꠞ ꠇꠤꠟꠤꠇꠤꠀꠞ ꠝꠣꠎꠦꠖꠤ ꠞꠅꠀꠘꠣ ꠇꠞꠤꠀ ꠙꠕꠦ ꠙꠕꠦ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠀꠞꠅ ꠝꠎꠛꠥꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_1","074_16_1","ACT","16","1","1","ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠙꠄꠟꠣ ꠖꠞ꠆ꠛꠤ ꠀꠞ ꠛꠣꠖꠦ ꠟꠥꠡ꠆ꠞꠣ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠀꠎꠤꠟꠣ। ꠟꠥꠡ꠆ꠞꠣꠔ ꠔꠤꠝꠕꠤ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠃꠝ꠆ꠝꠔ ꠀꠍꠟꠣ, ꠔꠣꠘ ꠝꠣ ꠁꠝꠣꠘꠖꠣꠞ, ꠝꠣ ꠔ ꠁꠢꠥꠖꠤ ꠎꠣꠔꠞ, ꠅꠁꠟꠦ ꠛꠣꠚ ꠁꠃꠘꠣꠘꠤ ꠎꠣꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("AC16_2","074_16_2","ACT","16","2","2","ꠟꠥꠡ꠆ꠞꠣ ꠀꠞ ꠁꠇꠘꠤꠅ ꠐꠣꠃꠘꠞ ꠢꠇꠟ ꠁꠝꠣꠘꠖꠣꠞꠦ ꠔꠤꠝꠕꠤꠞ ꠛꠃꠔ ꠔꠣꠞꠤꠚ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_3","074_16_3","ACT","16","3","3","ꠙꠣꠃꠟꠥꠍꠦ ꠔꠤꠝꠕꠤꠞꠦ ꠟꠉꠦ ꠘꠤꠔꠣ ꠇꠞꠤ ꠈꠤꠀꠟ ꠇꠞꠟꠣ; ꠔꠣꠁꠘ ꠔꠤꠝꠕꠤꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟꠣ, ꠇꠣꠞꠘ ꠢꠤ ꠎꠣꠉꠣꠁꠘ꠆ꠔꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠎꠣꠘꠔꠣ ꠔꠤꠝꠕꠤꠞ ꠛꠣꠚ ꠅꠁꠟꠣ ꠁꠃꠘꠣꠘꠤ ꠎꠣꠔꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("AC16_4","074_16_4","ACT","16","4","4","ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠎꠝꠣꠔꠞ ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ, ꠔꠣꠞꠣ ꠐꠣꠃꠘꠦ ꠐꠣꠃꠘꠦ ꠍꠚꠞ ꠇꠞꠤ ꠇꠞꠤ ꠁꠔꠣ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁꠟꠣ ꠀꠞ ꠝꠣꠘꠣꠞ ꠔꠣꠉꠤꠖ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_5","074_16_5","ACT","16","5","5","ꠅꠃꠟꠣ ꠎꠝꠣꠔꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠁꠝꠣꠘ ꠝꠎꠛꠥꠔ ꠅꠁꠟ, ꠀꠞ ꠖꠤꠘꠦ ꠖꠤꠘꠦ ꠔꠣꠞꠣꠞ ꠙꠞꠤꠝꠣꠘ ꠀꠞꠅ ꠛꠣꠠꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC16_6","074_16_6","ACT","16","6","6","ꠙꠣꠇ ꠞꠥꠢꠦ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇꠟꠞꠦ ꠀꠍꠤꠀ ꠖꠦꠡꠅ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠦ ꠝꠣꠘꠣ ꠇꠞꠟꠣ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠚꠞꠥꠉꠤꠀ ꠀꠞ ꠉꠣꠟꠣꠔꠤꠀ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠙꠣꠞ ꠅꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_7","074_16_7","ACT","16","7","7","ꠉꠤꠀ ꠝꠥꠡꠤꠀꠞ ꠡꠤꠝꠣꠘꠣꠔ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠛꠤꠕꠥꠘꠤꠀ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠁꠍꠣꠞ ꠞꠥꠢꠦ ꠔꠣꠞꠣꠞꠦ ꠢꠤꠈꠣꠘꠅ ꠎꠣꠁꠔꠦ ꠖꠤꠟꠣ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("AC16_8","074_16_8","ACT","16","8","8","ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠝꠥꠡꠤꠀ ꠖꠦꠡ ꠚꠣꠟꠣꠁꠀ ꠔꠞꠥꠀꠍ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC16_9","074_16_9","ACT","16","9","9","ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠙꠣꠃꠟꠥꠍꠦ ꠉꠣꠁꠛꠤ ꠄꠇ ꠖꠞꠡꠘ ꠙꠣꠁꠟꠣ; ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ, ꠝꠣꠇꠤꠖꠘꠤꠀ ꠖꠦꠡꠞ ꠄꠇ ꠛꠦꠐꠣꠄ ꠃꠛꠣꠁꠀ ꠔꠣꠘꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠞꠣ, “ꠝꠣꠇꠤꠖꠘꠤꠀꠔ ꠙꠣꠞ ꠅꠁꠀ ꠀꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC16_10","074_16_10","ACT","16","10","10","ꠔꠣꠁꠘ ꠁ ꠀꠟꠣꠝꠔ ꠖꠦꠈꠣꠞ ꠛꠣꠖꠦꠃ ꠀꠝꠞꠣ ꠝꠣꠇꠤꠖꠘꠤꠀꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠤꠀꠞ ꠅꠁꠟꠣꠝ, ꠀꠝꠞꠣ ꠛꠥꠎꠟꠣꠝ, ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_11","074_16_11","ACT","16","11","11","ꠅꠃ ꠀꠝꠞꠣ ꠔꠞꠥꠀꠍ ꠍꠣꠠꠤꠀ ꠎꠣꠎꠅ ꠇꠞꠤ ꠡꠥꠎꠣ ꠍꠣꠝꠕ꠆ꠞꠣꠇꠤ ꠖꠤꠙꠅ ꠉꠦꠟꠣꠝ, ꠢꠤꠘ ꠕꠣꠇꠤ ꠛꠣꠖꠞ ꠖꠤꠘ ꠘꠤꠀꠙꠟꠤ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠀꠎꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC16_12","074_16_12","ACT","16","12","12","ꠘꠤꠀꠙꠟꠤ ꠕꠣꠇꠤ ꠀꠝꠞꠣ ꠚꠤꠟꠤꠙꠤ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣꠝ। ꠁꠐꠣ ꠅꠁꠟ ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ ꠐꠣꠃꠘ, ꠁꠘꠅ ꠞꠥꠝꠣꠘ ꠞꠣꠎꠣꠞ ꠝꠣꠘꠥꠡ ꠛꠡꠔ ꠇꠞꠔꠣ। ꠀꠝꠞꠣ ꠇꠄꠖꠤꠘ ꠅꠘꠅ ꠞꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC16_13","074_16_13","ACT","16","13","13","ꠄꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠀꠝꠞꠣ ꠐꠣꠃꠘꠞ ꠛꠣꠁꠞꠣ ꠉꠣꠋꠉꠞ ꠙꠣꠞꠅ ꠉꠦꠟꠣꠝ, ꠝꠘꠅ ꠇꠞꠟꠣꠝ, ꠢꠤꠈꠣꠘꠅ ꠁꠢꠥꠖꠤ ꠗꠞ꠆ꠝꠞ ꠖꠥꠀ ꠇꠞꠣꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣ ꠀꠍꠦ। ꠢꠤꠘꠅ ꠉꠤꠀ ꠀꠝꠞꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠄꠇ ꠖꠟ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠅ ꠛꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC16_14","074_16_14","ACT","16","14","14","ꠀꠞ ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠕꠥꠀꠔꠤꠞꠣ ꠐꠣꠃꠘꠞ ꠟꠥꠖꠤꠀ ꠘꠣꠝꠞ ꠅ-ꠁꠢꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠄꠇ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ, ꠄꠁꠘ ꠛꠣꠁꠋꠉꠘꠤ ꠞꠋꠉꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠇꠣꠙꠠꠞ ꠇꠣꠞꠛꠣꠞ ꠇꠞꠔꠣ। ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠔ ꠀꠍꠟꠣ, ꠀꠞ ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠖꠤꠟꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠀ ꠖꠤꠟꠣꠁꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠄꠀꠘ ꠖꠤꠟ ꠖꠤꠀ ꠢꠥꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC16_15","074_16_15","ACT","16","15","15","ꠔꠣꠁꠘ ꠀꠞ ꠔꠣꠘ ꠊꠞꠞ ꠢꠇꠟꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠟꠤꠇꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘꠖꠣꠞ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠔꠦ ꠀꠝꠣꠞ ꠛꠣꠠꠤ ꠈꠣꠘꠅ ꠀꠁꠀ ꠞꠃꠇ꠆ꠇꠣ।” ꠇꠁꠀ ꠔꠣꠁꠘ ꠎꠥꠞꠦ ꠎꠣꠔꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC16_16","074_16_16","ACT","16","16","16","ꠄꠇꠖꠤꠘ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠢꠃ ꠖꠥꠀ ꠇꠞꠣꠞ ꠎꠣꠉꠣꠔ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠎꠤꠘ꠆ꠘꠣꠔ ꠡꠣꠗꠇꠤ ꠄꠇ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤ ꠀꠈꠔꠣꠃ ꠀꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠟ। ꠔꠣꠁ ꠜꠣꠁꠉ꠆ꠉ ꠉꠘꠤꠀ ꠔꠣꠁꠞ ꠉꠤꠞꠡ꠆ꠔ ꠅꠇꠟꠞꠦ ꠛꠃꠔ ꠟꠣꠜ ꠇꠞꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("AC16_17","074_16_17","ACT","16","17","17","ꠔꠣꠁ ꠀꠝꠞꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟ, “ꠁ ꠝꠣꠘꠥꠡ ꠉꠥꠁꠘ ꠃꠙꠞꠀꠟꠣꠞ ꠡꠦꠛꠇ, ꠄꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠞꠣꠘꠤꠞ ꠙꠕ ꠖꠦꠈꠣꠁ ꠖꠤꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC16_18","074_16_18","ACT","16","18","18","ꠔꠣꠁ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠁꠔꠣ ꠇꠞꠍꠤꠟ, ꠄꠇꠖꠤꠘ ꠙꠣꠃꠟꠥꠍꠦ ꠛꠤꠞꠇ꠆ꠔ ꠅꠁꠀ ꠔꠣꠁꠞ ꠛꠣꠄ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠀ ꠢꠃ ꠎꠤꠘꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠣꠞꠦ ꠁ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠤ ꠁ ꠛꠦꠐꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠅꠉꠤ!” ꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠢꠤ ꠎꠤꠘ ꠛꠣꠞ ꠅꠁꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC16_19","074_16_19","ACT","16","19","19","ꠅꠁꠟꠦ ꠔꠣꠁꠞ ꠝꠥꠘꠤꠛ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠜ ꠚꠥꠠꠣꠁꠉꠦꠟ ꠖꠦꠈꠤꠀ, ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞꠦ ꠗꠞꠤꠀ ꠐꠣꠘꠤꠀ ꠡꠖꠞꠅ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_20","074_16_20","ACT","16","20","20","ꠛꠣꠖꠦ ꠢꠣꠇꠤꠝ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠡꠝꠎꠣꠁ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠁ ꠝꠣꠘꠥꠡꠉꠥꠁꠘ꠆ꠔꠦ ꠀꠝꠞꠣꠞ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠛꠦꠕꠣꠄꠀ ꠉꠘ꠆ꠒꠉꠥꠟ ꠛꠣꠠꠣꠁ ꠖꠤꠍꠦ। ꠄꠞꠣ ꠔ ꠁꠢꠥꠖꠤ ꠀꠞ ꠀꠝꠞꠣ ꠅꠁꠟꠣꠝ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("AC16_21","074_16_21","ACT","16","21","21","ꠄꠞꠣ ꠅꠃ ꠎꠣꠔꠞ ꠇꠣꠄꠖꠣ-ꠇꠣꠘꠥꠘꠞ ꠇꠕꠣ ꠝꠣꠘꠡꠞꠦ ꠢꠤꠇꠣꠁꠞꠣ, ꠎꠦꠔꠣ ꠇꠞꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠦ-ꠀꠁꠘꠤ।” ");
INSERT INTO syls_vpl VALUES ("AC16_22","074_16_22","ACT","16","22","22","ꠀꠞ ꠢꠤꠘꠞ ꠀꠞꠅ ꠝꠣꠘꠥꠡ ꠄꠇꠟꠉꠦ ꠖꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠟ, ꠔꠦꠃ ꠢꠣꠇꠤꠝ ꠅꠇꠟꠦ ꠄꠞꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠈꠥꠟꠤꠀ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_23","074_16_23","ACT","16","23","23","ꠀꠞ ꠈꠥꠛ ꠜꠣꠟꠣꠐꠤꠇꠦ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁ ꠕꠁꠀ, ꠎꠦꠟꠞ ꠅꠚꠤꠡꠣꠞꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ ꠇꠠꠣꠇꠠꠤ ꠙꠣꠢꠣꠞꠣ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC16_24","074_16_24","ACT","16","24","24","ꠎꠦꠟꠞ ꠅꠚꠤꠡꠣꠞꠦ ꠁ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀ ꠢꠣꠞꠤ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠟꠞ ꠜꠤꠔꠞꠞ ꠇꠥꠑꠣꠔ ꠢꠣꠞꠣꠁ ꠕꠁꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠔ ꠒꠣꠘ꠆ꠒꠣ-ꠛꠦꠠꠤ ꠟꠣꠉꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_25","074_16_25","ACT","16","25","25","ꠀꠗꠣ ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠢꠣꠝꠖ-ꠉꠎꠟ ꠉꠣꠁꠔꠦ ꠉꠣꠁꠔꠦ ꠖꠥꠀ ꠇꠞꠣꠔ ꠀꠍꠟꠣ, ꠎꠦꠟꠞ ꠇꠄꠖꠤ ꠅꠇꠟꠦ ꠇꠣꠘ ꠙꠣꠔꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠎꠟ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_26","074_16_26","ACT","16","26","26","ꠅꠃ ꠡꠝꠄ ꠀꠈꠔꠣꠃ ꠛꠠ ꠄꠇ ꠜꠂꠍꠣꠟ ꠅꠁꠟ, ꠀꠡ꠆ꠔꠣ ꠎꠦꠟꠈꠣꠘꠣꠞ ꠜꠤꠔ ꠇꠣꠙꠤꠀ ꠃꠑꠟ। ꠎꠦꠟꠞ ꠢꠇꠟ ꠖꠥꠀꠞ ꠀꠞ ꠇꠄꠖꠤ ꠅꠇꠟꠞ ꠡꠤꠇꠟ ꠈꠥꠟꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC16_27","074_16_27","ACT","16","27","27","ꠔꠦꠃ ꠎꠦꠟꠞ ꠅꠚꠤꠡꠣꠞꠞ ꠊꠥꠝ ꠜꠣꠋꠟ ꠀꠞ ꠎꠦꠟꠞ ꠢꠇꠟ ꠖꠥꠀꠞ ꠈꠥꠟꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠔꠟꠥꠀꠞ ꠛꠣꠞ ꠇꠞꠤꠀ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠈꠥꠘ ꠅꠁꠎꠤꠔꠣ ꠌꠣꠁꠟꠣ, ꠔꠣꠁꠘ ꠝꠘꠅ ꠇꠞꠟꠣ, ꠢꠇꠟ ꠇꠄꠖꠤ ꠜꠣꠉꠤꠀ ꠉꠦꠍꠂꠘꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC16_28","074_16_28","ACT","16","28","28","ꠅꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠖꠦꠈꠤꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠖꠝ ꠟꠅ, ꠖꠝ ꠟꠅ, ꠘꠤꠎꠞ ꠈꠦꠔꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠝꠞꠣ ꠢꠇꠟꠃ ꠁꠈꠣꠘꠅ ꠞꠁꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("AC16_29","074_16_29","ACT","16","29","29","ꠔꠦꠃ ꠅꠚꠤꠡꠣꠞꠦ ꠄꠇꠎꠘꠞꠦ ꠛꠣꠔ꠆ꠔꠤ ꠀꠘꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠀ, ꠔꠣꠁꠘ ꠖꠃꠠꠣꠁꠀ ꠉꠤꠀ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟꠣ, ꠀꠞ ꠒꠞꠞ ꠌꠥꠐꠦ ꠇꠣꠙꠤ ꠇꠣꠙꠤ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞ ꠙꠣꠅꠔ ꠙꠠꠟꠣ; ");
INSERT INTO syls_vpl VALUES ("AC16_30","074_16_30","ACT","16","30","30","ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞꠦ ꠛꠣꠞꠦ ꠀꠘꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠍꠣꠛ ꠅꠇꠟ, ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠟꠦ ꠎꠣꠘꠦ ꠛꠣꠌꠔꠣꠝ ꠙꠣꠞꠝꠥ?” ");
INSERT INTO syls_vpl VALUES ("AC16_31","074_16_31","ACT","16","31","31","ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠃꠇ꠆ꠇꠣ, ꠔꠦꠃ ꠀꠙꠘꠦ ꠀꠞ ꠀꠙꠘꠣꠞ ꠛꠣꠠꠤꠞ ꠢꠇꠟ ꠎꠣꠘꠦ ꠛꠣꠌꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC16_32","074_16_32","ACT","16","32","32","ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠦ ꠎꠦꠟꠞ ꠅꠚꠤꠡꠣꠞ ꠀꠞ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠢꠇꠟꠞꠦ ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_33","074_16_33","ACT","16","33","33","ꠀꠞ ꠢꠃ ꠞꠣꠁꠔꠃ ꠔꠣꠁꠘ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞꠦ ꠟꠁꠀ ꠉꠤꠀ ꠔꠣꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠇꠣꠐꠣ-ꠌꠤꠞꠣ ꠗꠁꠀ ꠖꠤꠟꠣ, ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠞ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠢꠇꠟꠦ ꠟꠉꠦ ꠟꠉꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_34","074_16_34","ACT","16","34","34","ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠊꠞꠅ ꠘꠤꠀ ꠈꠣꠘꠣ ꠈꠣꠁꠔꠦ ꠖꠤꠟꠣ। ꠛꠣꠠꠤꠞ ꠢꠇꠟꠦ ꠝꠤꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠛꠃꠔ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_35","074_16_35","ACT","16","35","35","ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠤꠀꠘꠦ ꠢꠣꠇꠤꠝ ꠅꠇꠟꠦ ꠙꠥꠟꠤꠡ ꠙꠣꠑꠣꠁꠀ ꠎꠣꠘꠣꠁꠟꠣ, “ꠁ ꠇꠄꠖꠤ ꠅꠇꠟꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC16_36","074_16_36","ACT","16","36","36","ꠔꠦꠃ ꠎꠦꠟꠞ ꠅꠚꠤꠡꠣꠞ ꠍꠣꠛꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ, “ꠢꠣꠇꠤꠝ ꠅꠇꠟꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠛꠣꠞ ꠅꠁꠀ ꠀꠃꠇ꠆ꠇꠣ ꠀꠞ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠔꠡꠞꠤꠚ ꠘꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC16_37","074_16_37","ACT","16","37","37","ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠥꠡ, ꠀꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠛꠤꠌꠣꠞ ꠘꠣ ꠇꠞꠤꠀ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠍꠂꠘ ꠀꠞ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠍꠂꠘ। ꠅꠈꠘ ꠢꠣꠇꠤꠝ ꠅꠇꠟꠦ ꠀꠝꠞꠣꠞꠦ ꠟꠥꠇꠣꠁꠀ ꠍꠣꠠꠤ ꠖꠤꠔꠣ ꠌꠣꠁꠞꠣ? ꠁꠔꠣ ꠅꠁꠔ ꠘꠣꠄ, ꠔꠣꠞꠣ ꠘꠤꠎꠦ ꠀꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠘꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC16_38","074_16_38","ACT","16","38","38","ꠙꠥꠟꠤꠡꠦ ꠉꠤꠀ ꠢꠣꠇꠤꠝ ꠅꠇꠟꠞꠦ ꠅꠃ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠟꠣ, ꠢꠣꠇꠤꠝ ꠅꠇꠟꠦ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞꠦ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠥꠡ ꠢꠥꠘꠤꠀ ꠒꠞꠣꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_39","074_16_39","ACT","16","39","39","ꠔꠣꠞꠣ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠝꠣꠚ ꠌꠣꠁꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠞꠦ ꠘꠤꠀ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠢꠞꠤ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC16_40","074_16_40","ACT","16","40","40","ꠔꠦꠃ ꠔꠣꠞꠣ ꠎꠦꠟꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠀ ꠛꠤꠛꠤ ꠟꠥꠖꠤꠀꠞ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠣꠁꠟꠣ। ꠢꠤꠈꠣꠘꠅ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠟꠉꠦ ꠖꠦꠈꠣ-ꠡꠣꠇ꠆ꠇꠣꠔ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠃꠔꠡꠣꠢ ꠖꠤꠟꠣ, ꠛꠣꠖꠦ ꠢꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_1","074_17_1","ACT","17","1","1","ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍ ꠀꠝꠚꠤꠙꠥꠟꠤ ꠀꠞ ꠀꠙꠟ꠆ꠟꠥꠘꠤꠀ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦꠖꠤ ꠉꠤꠀ ꠕꠤꠡꠟꠘꠤꠇꠤꠔ ꠀꠁꠟꠣ। ꠢꠤꠘꠅ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠄꠇꠈꠣꠘ ꠝꠍꠤꠖ ꠀꠍꠤꠟ; ");
INSERT INTO syls_vpl VALUES ("AC17_2","074_17_2","ACT","17","2","2","ꠙꠣꠃꠟꠥꠍ ꠔꠣꠘ ꠘꠤꠅꠝ ꠝꠔꠃ ꠢꠤ ꠝꠍꠤꠖꠅ ꠉꠦꠟꠣ, ꠀꠞ ꠟꠣꠉꠣ ꠟꠣꠉꠣ ꠔꠤꠘ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠇ ꠇꠣꠟꠣꠝ ꠕꠣꠇꠤ ꠛꠥꠎꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_3","074_17_3","ACT","17","3","3","ꠔꠣꠁꠘ ꠛꠥꠎꠣꠁꠟꠣ ꠀꠞ ꠙꠞꠝꠣꠘꠅ ꠖꠦꠈꠣꠁꠟꠣ, ꠔꠇꠟꠤꠚ ꠡꠁꠎ꠆ꠎ ꠇꠞꠣ ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠎꠞꠥꠞ ꠀꠍꠤꠟ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅꠃ ꠎꠦ ꠁꠍꠣꠞ ꠇꠕꠣ ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠛꠥꠎꠣꠁꠞꠣꠝ, ꠄꠁꠘꠃ ꠀꠟ-ꠝꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("AC17_4","074_17_4","ACT","17","4","4","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠄꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠇꠄꠎꠘꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠟꠣ। ꠛꠃꠔ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠁꠃꠘꠣꠘꠤ ꠛꠦꠐꠣꠁꠘ ꠀꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠛꠦꠐꠤꠘꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_5","074_17_5","ACT","17","5","5","ꠅꠁꠟꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠛꠣꠎꠣꠞꠤ ꠉꠥꠘ꠆ꠒꠣꠁꠘ ꠀꠘꠤꠀ ꠖꠟ ꠛꠣꠘꠣꠁꠟ ꠀꠞ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦ ꠉꠥꠟꠝꠣꠟ ꠟꠣꠉꠣꠁ ꠖꠤꠟ। ꠔꠣꠞꠣ ꠎꠣꠍꠥꠘꠞ ꠛꠣꠠꠤꠔ ꠢꠣꠝꠟꠣ ꠇꠞꠤꠀ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠀꠘꠔ ꠌꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC17_6","074_17_6","ACT","17","6","6","ꠅꠁꠟꠦ ꠄꠞꠣꠞꠦ ꠘꠣ ꠙꠣꠁꠀ ꠔꠣꠞꠣ ꠎꠣꠍꠥꠘ ꠀꠞ ꠀꠞꠅ ꠇꠄꠎꠘ ꠝꠥꠝꠤꠘꠞꠦ ꠐꠣꠘꠤꠀ ꠍꠦꠌꠠꠣꠁꠀ ꠐꠣꠃꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠉꠦꠟ, ꠀꠞ ꠌꠤꠟ꠆ꠟꠣꠁ ꠌꠤꠟ꠆ꠟꠣꠁ ꠇꠁꠟ, “ꠅꠃ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞꠦ ꠟꠘ꠆ꠒꠜꠘ꠆ꠒ ꠇꠞꠤꠀ ꠅꠈꠘ ꠅꠘꠅ-ꠅ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC17_7","074_17_7","ACT","17","7","7","ꠀꠞ ꠅꠃ ꠎꠣꠍꠥꠘꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠄꠞꠣꠞꠦ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠍꠦ; ꠄꠞꠣ ꠢꠇꠟꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞ ꠢꠥꠇꠥꠝ ꠘꠣ ꠝꠣꠘꠤꠀ ꠇꠁꠞꠣ, ꠔꠣꠁꠘ ꠍꠣꠠꠣ ꠁꠍꠣ ꠘꠣꠝꠦ ꠀꠞꠇ ꠎꠘ ꠛꠣꠖꠡꠣ ꠀꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC17_8","074_17_8","ACT","17","8","8","ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠔ ꠝꠣꠔꠤꠀ ꠔꠣꠞꠣ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠀꠞ ꠀꠝ ꠝꠣꠘꠡꠞꠦꠅ ꠃꠍꠟꠣꠁꠀ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC17_9","074_17_9","ACT","17","9","9","ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠦ ꠎꠣꠍꠥꠘ ꠀꠞ ꠔꠣꠘ ꠟꠉꠞ ꠢꠇ꠆ꠇꠟꠞ ꠎꠣꠝꠣꠘꠔ ꠟꠁꠀ ꠎꠣꠝꠤꠘꠦ ꠍꠣꠠꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_10","074_17_10","ACT","17","10","10","ꠞꠣꠁꠔ ꠅꠀꠞ ꠛꠣꠖꠦ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠎꠟꠖꠤ ꠇꠞꠤ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠍꠤꠟꠣꠍꠞꠦ ꠛꠤꠞꠄꠀꠔ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ। ꠢꠤꠈꠣꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠁꠢꠥꠖꠤꠞ ꠝꠍꠤꠖꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_11","074_17_11","ACT","17","11","11","ꠕꠤꠡꠟꠘꠤꠇꠤꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠕꠣꠇꠤ ꠛꠤꠞꠄꠀ ꠐꠣꠃꠘꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠛꠃꠔ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠀꠍꠟꠣ। ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠤꠀ ꠈꠥꠛ ꠉꠞꠎꠤ ꠅꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠀꠞ ꠙꠣꠃꠟꠥꠍꠦ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠣ ꠁꠔꠣ ꠢꠣꠍꠣ ꠇꠤ ꠘꠣ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛ ꠈꠥꠟꠤꠀ ꠝꠤꠟꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_12","074_17_12","ACT","17","12","12","ꠔꠣꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠃꠔ ꠁꠢꠥꠖꠤꠄ, ꠀꠞ ꠁꠃꠘꠣꠘꠤ ꠕꠣꠇꠤꠅ ꠛꠃꠔ ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_13","074_17_13","ACT","17","13","13","ꠅꠁꠟꠦ ꠕꠤꠡꠟꠘꠤꠇꠤꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟ, ꠙꠣꠃꠟꠥꠍꠦ ꠛꠤꠞꠄꠀꠔ ꠀꠁꠀꠅ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣ, ꠅꠃ ꠔꠣꠞꠣꠅ ꠛꠤꠞꠄꠀꠔ ꠀꠁꠀ ꠢꠤꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠃꠍꠟꠣꠁꠀ ꠉꠥꠟꠝꠣꠟ ꠟꠣꠉꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC17_14","074_17_14","ACT","17","14","14","ꠁꠔꠣ ꠢꠥꠘꠤꠀꠃ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠅ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ, ꠅꠁꠟꠦ ꠍꠤꠟꠣꠍ ꠀꠞ ꠔꠤꠝꠕꠤ ꠛꠤꠞꠄꠀꠔꠃ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_15","074_17_15","ACT","17","15","15","ꠙꠣꠃꠟꠥꠍꠞꠦ ꠟꠁꠀ ꠎꠦꠞꠣ ꠞꠅꠀꠘꠣ ꠅꠁꠍꠤꠟ, ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠟꠁꠀ ꠀꠕꠤꠘꠤꠀꠔ ꠉꠦꠟꠣ। ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, ꠍꠤꠟꠣꠍ ꠀꠞ ꠔꠤꠝꠕꠤꠞꠦ ꠈꠥꠛ ꠎꠟꠖꠤ ꠇꠞꠤ ꠔꠣꠘ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠇꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_16","074_17_16","ACT","17","16","16","ꠀꠕꠤꠘꠤꠀꠔ ꠀꠁꠀ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍꠦ ꠎꠦꠛꠟꠣ ꠍꠤꠟꠣꠍ ꠀꠞ ꠔꠤꠝꠕꠤꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠖꠦꠈꠟꠣ ꠢꠤ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦ ꠝꠥꠞ꠆ꠔꠤꠄ ꠜꠞꠣ, ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠝꠘꠞ ꠝꠣꠎꠦ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_17","074_17_17","ACT","17","17","17","ꠅꠃ ꠔꠣꠁꠘ ꠁꠢꠥꠖꠤ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠁꠢꠥꠖꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠁꠃꠘꠣꠘꠤ ꠅꠇꠟꠞꠦ, ꠀꠞ ꠙꠞꠔꠤꠖꠤꠘ ꠛꠣꠎꠣꠞꠅ ꠉꠤꠀꠅ ꠎꠦꠞꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠅꠁꠔ, ꠔꠣꠞꠣꠞ ꠟꠉꠦꠅ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_18","074_17_18","ACT","17","18","18","ꠔꠦꠃ ꠁꠚꠤꠇꠥꠞꠤ ꠀꠞ ꠡ꠆ꠔꠥꠁꠇꠤ ꠝꠔꠛꠣꠖꠞ ꠇꠄꠎꠘ ꠙꠘ꠆ꠒꠤꠔꠦ ꠔꠣꠘ ꠟꠉꠦ ꠔꠞ꠆ꠇ ꠟꠣꠉꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠇꠄꠎꠘꠦ ꠇꠁꠟꠣ, “ꠁ ꠛꠇ-ꠛꠇ ꠇꠞꠞꠣꠄ ꠇꠤꠔꠣ ꠢꠤꠇꠣꠁꠔ ꠌꠣꠄ?” ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, “ꠝꠘꠦ ꠇꠄ ꠢꠦ ꠇꠥꠘꠥ ꠛꠤꠖꠦꠡꠤ ꠖꠦꠛꠔꠣꠁꠘ꠆ꠔꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠔ ꠌꠣꠞ।” ꠇꠣꠞꠘ ꠙꠣꠃꠟꠥꠍꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_19","074_17_19","ACT","17","19","19","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠀꠘꠤꠀ ꠀꠞꠦꠅ-ꠙꠣꠉꠞ ꠝꠎꠟꠤꠍꠅ ꠘꠤꠀ ꠀꠎꠤꠞ ꠇꠞꠟꠣ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠃ ꠎꠦꠔꠣ ꠘꠄꠀ ꠡꠤꠇ꠆ꠇꠣ ꠀꠙꠘꠦ ꠇꠁꠞꠣ, ꠁꠔꠣ ꠇꠤꠔꠣ ꠀꠝꠞꠣꠞꠦꠅ ꠢꠥꠘꠣꠁꠛꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("AC17_20","074_17_20","ACT","17","20","20","ꠀꠙꠘꠦ ꠔ ꠇꠤꠍꠥ ꠀꠎꠉꠥꠛꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠞꠣ, ꠔꠦ ꠀꠝꠞꠣ ꠎꠣꠘꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ ꠄꠞ ꠀꠍꠟ ꠝꠣꠘꠤꠈꠣꠘ ꠇꠤꠔꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC17_21","074_17_21","ACT","17","21","21","ꠀꠕꠤꠘꠤꠀ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠡꠦ ꠀꠞ ꠢꠤꠘꠅ ꠞꠅꠞꠣ ꠝꠥꠍꠣꠚꠤꠞ ꠅꠇꠟꠦꠅ ꠈꠣꠟꠤ ꠘꠄꠀ ꠘꠄꠀ ꠛꠦꠙꠣꠞꠞ ꠝꠣꠔ ꠝꠣꠔꠤꠀ ꠛꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_22","074_17_22","ACT","17","22","22","ꠔꠦꠃ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍꠦ ꠀꠞꠦꠅ-ꠙꠣꠉꠞ ꠝꠎꠟꠤꠍꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅ ꠀꠕꠤꠘꠤꠀꠞ ꠝꠣꠘꠥꠡ ꠅꠇꠟ, ꠀꠝꠤ ꠖꠦꠈꠞꠣꠝ, ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟ ꠇꠣꠝꠅꠃ ꠈꠥꠛ ꠖꠦꠛꠔꠣ ꠜꠎꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC17_23","074_17_23","ACT","17","23","23","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠙꠣꠈꠣꠘꠤꠔ ꠉꠦꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠙꠥꠎꠣꠞ ꠢꠇꠟꠔꠣ ꠊꠥꠞꠤꠀ ꠖꠦꠈꠟꠣꠝ, ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠟꠦꠈꠣ ꠀꠍꠦ, ‘ꠅꠌꠤꠘꠣ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ।’ ꠔꠦ ꠢꠥꠘꠃꠇ꠆ꠇꠣ, ꠀꠙꠘꠣꠞꠣ ꠘꠣ-ꠌꠤꠘꠤꠀ ꠎꠦꠘ ꠙꠥꠎꠣ ꠇꠞꠞꠣ, ꠀꠝꠤ ꠔꠣꠘ ꠇꠕꠣꠃ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC17_24","074_17_24","ACT","17","24","24","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ, ꠎꠦꠁꠘ ꠁ ꠖꠥꠘꠤꠀ ꠀꠞ ꠄꠞ ꠝꠣꠎꠞ ꠢꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔ ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠟꠤꠇ, ꠔꠣꠁꠘ ꠔ ꠝꠣꠘꠡꠞ ꠛꠣꠘꠣꠁꠟ ꠇꠥꠘꠥ ꠝꠘ꠆ꠖꠤꠞꠅ ꠛꠡꠔ ꠇꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_25","074_17_25","ACT","17","25","25","ꠔꠣꠘ ꠇꠥꠘꠥ ꠅꠜꠣꠛ ꠘꠣꠁ ꠉꠔꠤꠇꠦ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘꠥꠔꠣ ꠘꠦꠅꠀꠞꠅ ꠉꠞꠎ ꠘꠣꠁ, ꠔꠣꠁꠘꠃ ꠔ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞ ꠎꠣꠘ, ꠖꠝ, ꠀꠞ ꠢꠇꠟꠔꠣ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC17_26","074_17_26","ACT","17","26","26","ꠔꠣꠁꠘ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠕꠣꠇꠤ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠝꠣꠘꠥꠡ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁ ꠎꠥꠠꠤ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ꠔꠣꠞꠣ ꠇꠥꠘ ꠀꠝꠟꠅ ꠇꠥꠘꠣꠘꠅ ꠛꠡꠔ ꠇꠞꠛꠣ ꠁꠐꠣꠅ ꠔꠣꠁꠘ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC17_27","074_17_27","ACT","17","27","27","ꠀꠟ꠆ꠟꠣꠄ ꠁ ꠇꠣꠝ ꠇꠞꠍꠂꠘ ꠎꠣꠔꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠂꠘ, ꠀꠞ ꠔꠥꠇꠣꠁ ꠔꠥꠇꠣꠁ ꠔꠣꠘ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠘ। ꠅꠕꠌ ꠔꠣꠁꠘ ꠀꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC17_28","074_17_28","ACT","17","28","28","ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠇꠄꠎꠘ ꠇꠛꠤꠄꠅ ꠇꠁꠍꠂꠘ, ‘ꠔꠣꠘ ꠇꠥꠖꠞꠔꠦꠃ ꠀꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠉꠔꠤ ꠀꠞ ꠑꠣꠁ।’ ꠀꠞ, ‘ꠀꠝꠞꠣꠅ ꠔꠣꠘ ꠅꠀꠞꠤꠡ।’ ");
INSERT INTO syls_vpl VALUES ("AC17_29","074_17_29","ACT","17","29","29","“ꠀꠞ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠞꠤꠡ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠍꠥꠞꠔꠞꠦ ꠝꠣꠘꠡꠞ ꠈꠤꠀꠟ-ꠝꠞ꠆ꠎꠤꠄ ꠛꠣꠘꠣꠁꠟ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠛꠣ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠥꠞ꠆ꠔꠤ ꠝꠘꠅ ꠇꠞꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠃꠌꠤꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC17_30","074_17_30","ACT","17","30","30","ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠎꠣꠘꠔꠣ ꠘꠣ ꠉꠔꠤꠇꠦ ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣꠞꠦ ꠇꠍꠥꠞ ꠝꠘꠅ ꠇꠞꠍꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠔꠣꠁꠘ ꠢꠇꠟ ꠎꠣꠉꠣꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠝꠘ ꠛꠖꠟꠣꠁꠀ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC17_31","074_17_31","ACT","17","31","31","ꠔꠣꠁꠘ ꠔ ꠅꠃꠟꠣ ꠄꠇ ꠖꠤꠘꠅ ꠑꠤꠇ ꠇꠞꠍꠂꠘ, ꠎꠦꠖꠤꠘ ꠔꠣꠘ ꠙꠍꠘ꠆ꠖꠞ ꠢꠇ꠆ꠇꠣꠘꠤ ꠝꠣꠘꠡꠞ ꠀꠔꠣꠘꠦ ꠖꠤꠘ-ꠖꠥꠘꠤꠀꠞ ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠁꠛꠣ। ꠁꠐꠣꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠢꠃ ꠝꠣꠘꠡꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠀ ꠄꠞ ꠙꠞꠝꠣꠘꠅ ꠖꠦꠈꠣꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC17_32","074_17_32","ACT","17","32","32","ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠇꠦꠃ ꠇꠦꠃ ꠀꠡꠣ-ꠀꠡꠤ ꠇꠞꠟ, ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠇꠁꠟ, “ꠀꠙꠘꠣꠞ ꠁ ꠛꠦꠙꠣꠞꠈꠣꠘ ꠀꠝꠞꠣ ꠀꠞꠇꠛꠣꠞ ꠢꠥꠘꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("AC17_33","074_17_33","ACT","17","33","33","ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠢꠤ ꠝꠎꠟꠤꠍ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC17_34","074_17_34","ACT","17","34","34","ꠅꠁꠟꠦ ꠇꠦꠃ ꠇꠦꠃ ꠔꠣꠘ ꠟꠉꠦ ꠄꠇꠝꠔ ꠅꠁꠟꠣ ꠀꠞ ꠁꠝꠣꠘꠅ ꠀꠘꠟꠣ। ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠖꠤꠅꠘꠥꠍꠤꠅ ꠘꠣꠝꠦ ꠀꠞꠦꠅ-ꠙꠣꠉꠞ ꠄꠇꠎꠘ ꠝꠦꠝ꠆ꠛꠣꠞ, ꠖꠣꠝꠣꠞꠤꠍ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠀꠞ ꠀꠞꠅ ꠇꠄꠎꠘꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_1","074_18_1","ACT","18","1","1","ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠀꠕꠤꠘꠤꠀ ꠍꠣꠠꠤꠀ ꠇꠞꠤꠘ꠆ꠔ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_2","074_18_2","ACT","18","2","2","ꠢꠤꠘꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠀꠇꠤꠟ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠁꠢꠥꠖꠤꠞ ꠟꠉꠦ ꠔꠣꠘ ꠖꠦꠈꠣ ꠅꠁꠟ। ꠄꠘ ꠛꠣꠠꠤ ꠙꠘ꠆ꠔ ꠖꠦꠡꠅ, ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣ ꠇꠦꠟꠣꠖꠥꠍꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠞꠥꠝ ꠕꠣꠇꠤ ꠢꠞꠤ ꠎꠣꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ ꠉꠔꠤꠇꠦ, ꠀꠇꠤꠟꠦ ꠔꠣꠘ ꠛꠃ ꠚꠤꠍꠇꠤꠟꠣꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠀꠉꠦ ꠁꠔꠣꠟꠤ ꠕꠣꠇꠤ ꠇꠞꠤꠘ꠆ꠔꠔ ꠀꠁꠍꠟꠣ। ꠙꠣꠃꠟꠥꠍ ꠔꠣꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_3","074_18_3","ACT","18","3","3","ꠔꠣꠁꠘꠅ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠝ꠆ꠛꠥ ꠛꠣꠘꠣꠘꠤꠞ ꠇꠣꠝ ꠇꠞꠔꠣ ꠉꠔꠤꠇꠦ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠀ ꠅꠃ ꠇꠣꠝꠅ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_4","074_18_4","ACT","18","4","4","ꠙꠞꠔꠦꠇ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠦ ꠙꠣꠃꠟꠥꠍ ꠁꠢꠥꠖꠤ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣ, ꠔꠣꠁꠘ ꠁꠃꠘꠣꠘꠤ ꠀꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠉꠤꠖ ꠖꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_5","074_18_5","ACT","18","5","5","ꠢꠎꠞꠔ ꠍꠤꠟꠣꠍ ꠀꠞ ꠔꠤꠝꠕꠤ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠕꠣꠇꠤ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠙꠣꠃꠟꠥꠍꠦ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣ। ꠔꠣꠁꠘ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠛꠥꠎꠣꠁꠔꠣ, ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠅꠁꠟꠣ ꠀꠟ-ꠝꠍꠤ ꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("AC18_6","074_18_6","ACT","18","6","6","ꠅꠁꠟꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠎꠦꠛꠟꠣ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠀꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠅꠀꠔ ꠟꠣꠉꠟꠣ, ꠁ ꠡꠝꠄ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠟꠦꠛꠣꠍꠞ ꠗꠥꠁꠟ ꠏꠣꠠꠤꠀ ꠚꠣꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠟꠃꠞ ꠖꠣꠄ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠕꠣꠔꠃ ꠞꠃꠇ। ꠀꠝꠤ ꠀꠝꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠟꠣꠝ। ꠅꠈꠘ ꠕꠣꠇꠤ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠥꠈꠣ ꠙꠕ ꠗꠞꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("AC18_7","074_18_7","ACT","18","7","7","ꠇꠁꠀ ꠢꠣꠞꠤ ꠢꠘ ꠕꠣꠇꠤ ꠔꠤꠔꠤꠅ-ꠁꠃꠍꠔꠥꠍ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠝꠣꠘꠡꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣ। ꠄꠘ ꠛꠣꠠꠤ ꠀꠍꠤꠟ ꠝꠍꠤꠖꠞ ꠟꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("AC18_8","074_18_8","ACT","18","8","8","ꠝꠍꠤꠖꠞ ꠝꠥꠔꠟ꠆ꠟꠤ ꠇꠤꠞꠤꠡꠙꠅ ꠍꠣꠛ ꠀꠞ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠢꠇꠟꠦ ꠝꠣꠟꠤꠇꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ꠀꠞ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠇꠞꠤꠘ꠆ꠔꠤꠅ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠛꠃꠔꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_9","074_18_9","ACT","18","9","9","ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠖꠞꠡꠘ ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ, ꠔꠛꠟꠤꠉ ꠌꠣꠟꠣꠁꠀ ꠎꠣꠅ, ꠝꠥꠈ ꠛꠘ꠆ꠖ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_10","074_18_10","ACT","18","10","10","ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠀꠍꠤ, ꠇꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠢꠣꠝꠟꠣ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠔ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠁ ꠐꠣꠃꠘꠅ ꠀꠝꠣꠞ ꠛꠃꠔ ꠙ꠆ꠞꠎꠣ ꠀꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC18_11","074_18_11","ACT","18","11","11","ꠅꠃ ꠙꠣꠃꠟꠥꠍ ꠖꠦꠠ ꠛꠞꠍ ꠗꠞꠤ ꠢꠘꠅ ꠞꠁꠀ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_12","074_18_12","ACT","18","12","12","ꠛꠣꠖꠦ ꠉꠣꠟꠤꠅꠘ ꠎꠦꠛꠟꠣ ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠞ ꠢꠣꠇꠤꠝ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠄꠇꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠗꠞꠤꠀ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠞꠣꠎ ꠖꠞꠛꠣꠞꠅ ꠘꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC18_13","074_18_13","ACT","18","13","13","“ꠅꠃ ꠛꠦꠐꠣꠄ ꠀꠝꠞꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠇꠞ, ꠀꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠔꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("AC18_14","074_18_14","ACT","18","14","14","ꠅꠁꠟꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠎꠦꠛꠟꠣ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠉꠣꠟꠤꠅꠘꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠁꠢꠥꠖꠤ ꠅꠇꠟ, ꠁꠐꠣ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠅꠁꠘ꠆ꠘꠣꠄ ꠛꠣ ꠖꠥꠡꠞ ꠇꠣꠝ ꠅꠁꠔ ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠟꠤꠡ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("AC18_15","074_18_15","ACT","18","15","15","ꠅꠁꠟꠦ ꠁꠐꠣ ꠎꠦꠛꠟꠣ ꠇꠥꠘꠥ ꠈꠣꠍ ꠛꠥꠟꠤ ꠛꠣ ꠘꠣꠝ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠚꠤꠞꠇꠣ, ꠔꠦ ꠁꠔꠣ ꠛꠤꠡꠄ-ꠀꠡꠄ ꠔꠥꠝꠞꠣꠃ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠤꠟꠣꠅ, ꠁꠔꠣ ꠝꠣꠔꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠛꠤꠌꠣꠞ ꠇꠞꠔꠣꠝ ꠌꠣꠁ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC18_16","074_18_16","ACT","18","16","16","ꠇꠁꠀ ꠢꠣꠞꠤ ꠔꠣꠁꠘ ꠀꠖꠣꠟꠔ ꠕꠣꠇꠤ ꠁꠔꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_17","074_18_17","ACT","18","17","17","ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠁꠢꠥꠖꠤ ꠝꠍꠤꠖꠞ ꠈꠣꠖꠤꠝ ꠍꠥꠍꠤꠘꠞꠦ ꠗꠞꠤꠀ ꠀꠖꠣꠟꠔꠞ ꠍꠣꠝꠘꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠟꠣ। ꠅꠁꠟꠦ ꠉꠣꠟꠤꠅꠘꠦ ꠁꠝꠥꠈꠣ ꠚꠤꠞꠤꠀꠃ ꠌꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_18","074_18_18","ACT","18","18","18","ꠙꠣꠃꠟꠥꠍ ꠀꠞꠅ ꠛꠃꠔ ꠖꠤꠘ ꠇꠞꠤꠘ꠆ꠔꠔ ꠞꠅꠀꠞ ꠛꠣꠖꠦ, ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠡꠤꠞꠤꠀ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠣ ꠇꠞꠤ ꠇꠤꠋꠇ꠆ꠞꠤꠀ ꠘꠣꠝꠞ ꠎꠣꠎ ꠊꠣꠐꠅ ꠀꠁꠟꠣ, ꠀꠇꠤꠟ ꠀꠞ ꠚꠤꠍꠇꠤꠟꠣꠅ ꠔꠣꠘ ꠟꠉꠦ ꠀꠁꠟꠣ। ꠙꠣꠃꠟꠥꠍꠞ ꠄꠇ ꠝꠣꠘ꠆ꠘꠔ ꠀꠍꠤꠟ ꠇꠞꠤ ꠅꠘꠅ ꠀꠁꠀ ꠔꠣꠘ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠁꠀ ꠎꠣꠎꠅ ꠃꠑꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_19","074_18_19","ACT","18","19","19","ꠛꠣꠖꠦ ꠁꠚꠤꠍ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠙꠣꠃꠟꠥꠍꠦ ꠢꠤ ꠖꠥꠁꠅꠎꠘꠞꠦ ꠅꠘꠅ ꠕꠁꠀ, ꠔꠣꠁꠘ ꠝꠍꠤꠖꠅ ꠢꠣꠝꠣꠁꠀ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_20","074_18_20","ACT","18","20","20","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠇꠄꠖꠤꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔ ꠇꠞꠟꠦꠅ, ꠔꠣꠁꠘ ꠞꠣꠎꠤ ꠅꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_21","074_18_21","ACT","18","21","21","ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠇꠁꠟꠣ, “ꠁꠘꠡꠣꠟ꠆ꠟꠣ, ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠝꠥ।” ꠇꠁꠀ ꠔꠣꠁꠘ ꠁꠚꠤꠍ ꠕꠣꠇꠤ ꠎꠣꠎꠅ ꠇꠞꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_22","074_18_22","ACT","18","22","22","ꠀꠞ ꠇꠂꠍꠞꠤꠀꠔ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠎꠣꠎ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠤꠀ ꠢꠘ ꠕꠣꠇꠤ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_23","074_18_23","ACT","18","23","23","ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠔ ꠇꠄꠖꠤꠘ ꠇꠣꠐꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠢꠤꠈꠣꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠀ, ꠉꠣꠟꠣꠔꠤꠀ ꠀꠞ ꠚꠞꠥꠉꠤꠀ ꠖꠦꠡꠞ ꠎꠣꠉꠣꠄ ꠎꠣꠉꠣꠄ ꠊꠥꠞꠤꠀ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠁꠝꠣꠘꠤ ꠛꠟ ꠝꠎꠛꠥꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_24","074_18_24","ACT","18","24","24","ꠄꠞ ꠝꠣꠎꠦ ꠀꠙꠟ꠆ꠟꠍ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠁꠢꠥꠖꠤ ꠁꠚꠤꠍ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ꠔꠣꠘ ꠛꠣꠠꠤ ꠀꠟꠦꠇꠎꠣꠘꠖ꠆ꠞꠤꠀ ꠐꠣꠃꠘꠅ, ꠔꠣꠁꠘ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠅꠀꠎ ꠇꠞꠂꠘ, ꠀꠞ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠈꠥꠛ ꠜꠣꠟꠣ ꠛꠥꠎꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC18_25","074_18_25","ACT","18","25","25","ꠝꠣꠟꠤꠇꠞ ꠔꠞꠤꠇꠣꠞ ꠁꠟꠤꠝꠅ ꠔꠣꠘ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠞꠥꠢꠦ ꠉꠞꠝ ꠅꠁꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠍꠢꠤ-ꠡꠥꠖ꠆ꠖ ꠅꠀꠎ-ꠘꠍꠤꠅꠔ ꠇꠞꠔꠣ ꠀꠞ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣ। ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠈꠣꠟꠤ ꠢꠎꠞꠔ ꠄꠢꠤꠀꠞ ꠔꠞꠤꠇꠣꠞ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟꠞ ꠇꠕꠣ ꠎꠣꠘꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_26","074_18_26","ACT","18","26","26","ꠔꠣꠁꠘ ꠈꠥꠛ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤꠀ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠅꠀꠎ ꠇꠞꠔꠣ। ꠚꠤꠍꠇꠤꠟꠣ ꠀꠞ ꠀꠇꠤꠟꠦ ꠔꠣꠘ ꠅꠀꠎ ꠢꠥꠘꠤꠀ ꠔꠣꠘꠞꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠠꠤꠔ ꠖꠣꠅꠔ ꠖꠤꠟꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠣꠡ꠆ꠔꠣ ꠀꠞꠅ ꠜꠣꠟꠣ ꠇꠞꠤ ꠛꠥꠎꠣꠁꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC18_27","074_18_27","ACT","18","27","27","ꠛꠣꠖꠦ ꠀꠙꠟ꠆ꠟꠍ ꠎꠦꠛꠟꠣ ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ, ꠁ ꠡꠝꠄ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠃꠔꠡꠣꠢ ꠖꠤꠟꠣ, ꠀꠞ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠔꠣ ꠇꠞꠤ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠌꠤꠑꠤꠅ ꠖꠤꠟꠣ। ꠔꠦꠃ ꠔꠣꠁꠘ ꠉꠤꠀ ꠉ꠆ꠞꠤꠍꠅ ꠀꠎꠤꠞ ꠅꠁꠟꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟꠣ ꠔꠣꠞꠣꠞ ꠛꠃꠔ ꠚꠣꠄꠖꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC18_28","074_18_28","ACT","18","28","28","ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠎꠦꠘ ꠀꠟ-ꠝꠍꠤ, ꠅꠃ ꠇꠕꠣ ꠔ ꠔꠣꠁꠘ ꠙꠣꠇ ꠇꠤꠔꠣꠛ ꠕꠣꠇꠤ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠀ, ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠄꠇ꠆ꠇꠦꠞꠦ ꠟꠣ-ꠎꠥꠀꠙ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_1","074_19_1","ACT","19","1","1","ꠀꠙꠟ꠆ꠟꠍ ꠎꠦꠛꠟꠣ ꠇꠞꠤꠘ꠆ꠔꠔ ꠀꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠝꠣꠎꠦꠖꠤ ꠁꠚꠤꠍ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ꠢꠤꠈꠣꠘꠅ ꠇꠄꠎꠘ ꠃꠝ꠆ꠝꠔꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠅꠀꠄ, ");
INSERT INTO syls_vpl VALUES ("AC19_2","074_19_2","ACT","19","2","2","ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠣꠞ ꠡꠝꠄ ꠇꠤꠔꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠟꠣ ꠘꠤ?” ꠔꠣꠞꠣ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠞꠇꠔꠣ ꠇꠤꠔꠣ, ꠁꠔꠣ ꠔ ꠀꠝꠞꠣ ꠢꠥꠘꠍꠤꠃ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC19_3","074_19_3","ACT","19","3","3","ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠦ ꠀꠙꠘꠣꠞꠣ ꠇꠥꠘ ꠔꠞꠤꠇꠣꠄ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠍꠟꠣ?” ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠄꠢꠤꠀ ꠘꠛꠤꠞ ꠔꠞꠤꠇꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC19_4","074_19_4","ACT","19","4","4","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠝꠘ ꠛꠖꠟꠣꠁꠟꠦ ꠎꠦ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠟ ꠅꠄ, ꠅꠐꠣꠃ ꠅꠁꠟ ꠢꠎꠞꠔ ꠄꠢꠤꠀꠞ ꠔꠞꠤꠇꠣꠞ ꠉꠥꠍꠟ, ꠅꠁꠟꠦ ꠄꠢꠤꠀꠄ ꠔ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠟꠣ, ꠔꠣꠘ ꠛꠣꠖꠦ ꠎꠦꠁꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠝꠣꠘꠤ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠃꠙꠞꠦꠅ ꠁꠝꠣꠘ ꠀꠘꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC19_5","074_19_5","ACT","19","5","5","ꠁ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_6","074_19_6","ACT","19","6","6","ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠔ ꠞꠣꠈꠟꠦ ꠔꠣꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠁꠟꠣ, ꠔꠦꠃ ꠄꠞꠣ ꠘꠣꠘꠣꠘ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠤꠟꠣ ꠀꠞ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔ ꠝꠣꠔꠣ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_7","074_19_7","ACT","19","7","7","ꠄꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠅꠘꠥꠝꠣꠘ ꠛꠣꠞꠅ ꠎꠘ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_8","074_19_8","ACT","19","8","8","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠁꠢꠥꠖꠤꠞ ꠝꠍꠤꠖꠅ ꠉꠤꠀ ꠄꠇꠟꠣꠉꠣꠞꠦ ꠔꠤꠘ ꠝꠣꠡ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠥꠇ꠆ꠔꠤ-ꠔꠞ꠆ꠇ ꠖꠦꠈꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠛꠥꠎꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_9","074_19_9","ACT","19","9","9","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠄꠎꠘꠞ ꠖꠤꠟ ꠘꠣ-ꠢꠥꠝꠣꠞ ꠅꠀꠄ ꠔꠣꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠟꠣ ꠘꠣ, ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠉꠤꠛꠔ ꠉꠣꠁꠔꠣ। ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠄꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦ ꠀꠟꠉꠣꠁꠀ ꠔꠣꠘ ꠟꠉꠦ ꠞꠣꠈꠟꠣ, ꠀꠞ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠔꠥꠞꠣꠘ꠆ꠘ ꠘꠣꠝꠞ ꠄꠇ ꠃꠡ꠆ꠔꠣꠖꠞ ꠐꠋꠉꠤꠔ ꠉꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_10","074_19_10","ACT","19","10","10","ꠅꠃꠟꠣ ꠖꠥꠁ ꠛꠍꠞ ꠉꠥꠎꠞꠣꠞ ꠛꠣꠖꠦ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠁꠢꠥꠖꠤ ꠀꠞ ꠁꠃꠘꠣꠘꠤ, ꠢꠇ꠆ꠇꠟꠞ ꠇꠣꠘꠅꠃ ꠝꠣꠛꠥꠖꠞ ꠇꠣꠟꠣꠝ ꠙꠃꠍꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("AC19_11","074_19_11","ACT","19","11","11","ꠀꠟ꠆ꠟꠣꠄ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍꠞ ꠀꠔꠣꠘꠦ ꠀꠌꠣꠘꠇ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠎꠣꠁꠞ ꠇꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_12","074_19_12","ACT","19","12","12","ꠢꠦꠡꠦ ꠅꠃꠟꠣꠅ ꠅꠁꠟ ꠎꠦꠘ, ꠔꠣꠘ ꠉꠔꠞꠞ ꠇꠣꠙꠠ ꠛꠣ ꠉꠣꠝꠍꠣ ꠈꠣꠘꠅ ꠇꠥꠘꠥ ꠛꠦꠝꠣꠞꠤ ꠝꠣꠘꠡꠞ ꠇꠣꠍꠣꠔ ꠘꠤꠟꠦꠃ ꠛꠦꠝꠣꠞ ꠜꠣꠟꠣ ꠅꠁꠎꠤꠔ, ꠀꠞ ꠎꠤꠘ-ꠜꠥꠔꠦꠅ ꠛꠦꠝꠣꠞꠤ ꠍꠣꠠꠤꠀ ꠜꠣꠉꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_13","074_19_13","ACT","19","13","13","ꠄꠞꠝꠣꠎꠦ ꠇꠄꠎꠘ ꠊꠥꠞꠤꠀ ꠙꠣꠈꠣꠁꠀ ꠈꠣꠅꠞꠣ ꠁꠢꠥꠖꠤ ꠔꠣꠛꠎꠣꠔꠤ ꠝꠥꠟ꠆ꠟꠣꠄꠅ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠎꠤꠘ-ꠜꠥꠔ ꠍꠣꠠꠣꠁꠔ ꠌꠣꠁꠟ, ꠔꠣꠞꠣ ꠅꠃꠟꠣ ꠇꠁꠔ, “ꠙꠣꠃꠟꠥꠍꠦ ꠎꠦꠘ ꠘꠣꠝꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠂꠘ, ꠢꠃ ꠁꠍꠣꠞ ꠖꠥꠀꠁ ꠖꠤꠀ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("AC19_14","074_19_14","ACT","19","14","14","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠡ꠆ꠇꠤꠛꠣ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠁꠢꠥꠖꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠡꠣꠔ ꠙꠥꠀꠄꠅ ꠅꠃꠟꠣ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("AC19_15","074_19_15","ACT","19","15","15","ꠔꠦꠃ ꠄꠇꠖꠤꠘ ꠜꠥꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠥꠀꠙ ꠖꠤꠟ, “ꠀꠝꠤ ꠁꠍꠣꠞꠦꠅ ꠌꠤꠘꠤ, ꠙꠣꠃꠟꠥꠍꠞꠦꠅ ꠌꠤꠘꠤ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠦ?” ");
INSERT INTO syls_vpl VALUES ("AC19_16","074_19_16","ACT","19","16","16","ꠇꠁꠀꠃ ꠎꠦ ꠛꠦꠐꠣꠞꠦ ꠜꠥꠔꠦ ꠗꠞꠍꠤꠟ ꠢꠤ ꠛꠦꠐꠣꠄ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠚꠣꠟ ꠖꠤꠀ ꠙꠠꠤꠀ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠤꠀ ꠔꠣꠞꠣ ꠡꠣꠔꠅ ꠎꠘꠞꠦ ꠀꠞꠣꠁꠟ। ꠝꠣꠁꠞꠦ ꠔꠣꠞꠣꠞ ꠡꠞꠤꠟ ꠍꠤꠠꠤꠀ-ꠛꠤꠠꠤꠀ ꠎꠈꠝ ꠅꠁꠉꠦꠟ, ꠔꠣꠞꠣ ꠟꠦꠝꠐꠣ ꠅꠁꠀ ꠁ ꠛꠣꠠꠤ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_17","074_19_17","ACT","19","17","17","ꠁ ꠈꠛꠞ ꠎꠦꠛꠟꠣ ꠁꠚꠤꠍꠞ ꠁꠢꠥꠖꠤ ꠀꠞ ꠁꠃꠘꠣꠘꠤ ꠅꠇꠟꠦ ꠎꠣꠘꠟꠣ, ꠔꠦ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠦ ꠒꠞꠣꠁꠉꠦꠟꠣ, ꠀꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠘꠣꠝꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC19_18","074_19_18","ACT","19","18","18","ꠎꠦꠞꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟ, ꠄꠞꠣ ꠛꠃꠔꠦ ꠀꠁꠀ ꠢꠣꠞꠤ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠇꠞꠤ ꠔꠣꠞꠣꠞ ꠛꠣꠖ ꠇꠣꠝꠞ ꠇꠕꠣ ꠡ꠆ꠛꠤꠇꠣꠞ ꠀꠞ ꠎꠣꠁꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_19","074_19_19","ACT","19","19","19","ꠀꠞ ꠎꠦꠞꠣ ꠎꠣꠖꠥ-ꠐꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠔ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦꠅ ꠛꠃꠔꠦ ꠔꠣꠞꠣꠞ ꠎꠣꠖꠥ-ꠐꠥꠘꠣꠞ ꠛꠁꠀꠁꠘ ꠀꠘꠤꠀ ꠖꠟꠣ ꠇꠞꠤ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠟꠣꠁꠟꠤꠟꠣ। ꠁ ꠛꠁꠀꠁꠘ꠆ꠔꠞ ꠖꠣꠝ ꠢꠤꠡꠣꠛ ꠇꠞꠤꠀ ꠖꠦꠈꠣ ꠉꠦꠟ ꠙꠁꠘ꠆ꠌꠣꠡ ꠀꠎꠣꠞ ꠞꠥꠙꠣꠞ ꠖꠤꠘꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("AC19_20","074_19_20","ACT","19","20","20","ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝ ꠛꠃꠔ ꠛꠣꠠꠤꠟ ꠀꠞ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠈꠥꠛ ꠇꠣꠝ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("AC19_21","074_19_21","ACT","19","21","21","ꠁꠔꠣ ꠊꠐꠣꠞ ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠝꠘꠦ ꠝꠘꠦ ꠘꠤꠅꠔ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠀꠞ ꠉ꠆ꠞꠤꠍ ꠅꠁꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠁꠔꠣꠉꠤ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠀꠝꠤ ꠞꠥꠝ ꠐꠣꠃꠘꠅ-ꠅ ꠎꠣꠅꠀ ꠎꠞꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC19_22","074_19_22","ACT","19","22","22","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠔꠤꠝꠕꠤ ꠀꠞ ꠁꠞꠣꠡ꠆ꠔꠣꠍ ꠘꠣꠝꠞ ꠔꠣꠘ ꠖꠥꠁꠅ ꠈꠣꠖꠤꠝꠞꠦ ꠝꠣꠇꠤꠖꠘꠤꠀꠔ ꠙꠣꠑꠣꠁꠀ, ꠘꠤꠎꠦ ꠀꠞꠅ ꠇꠄꠖꠤꠘ ꠀꠍꠤꠀ ꠖꠦꠡꠅ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_23","074_19_23","ACT","19","23","23","ꠅꠃ ꠡꠝꠄ ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠛꠤꠡꠄ ꠟꠁꠀ ꠛꠃꠔ ꠉꠘ꠆ꠒꠉꠥꠟ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("AC19_24","074_19_24","ACT","19","24","24","ꠇꠣꠞꠘ ꠖꠤꠝꠤꠔ꠆ꠞꠤ ꠘꠣꠝꠦ ꠄꠇꠎꠘ ꠛꠣꠘꠤꠀꠄ ꠀꠞ꠆ꠔꠦꠝꠤꠍ ꠖꠦꠛꠤꠞ ꠝꠘ꠆ꠖꠤꠞꠞ ꠘꠝꠥꠘꠣꠄ ꠞꠥꠙꠣꠖꠤ ꠢꠥꠞꠥ ꠢꠥꠞꠥ ꠝꠘ꠆ꠖꠤꠞ ꠛꠣꠘꠣꠁꠔ, ꠀꠞꠅ ꠛꠃꠔ ꠛꠣꠘꠤꠀꠄꠅ ꠅꠃ ꠇꠣꠝ ꠇꠞꠤꠀ ꠛꠃꠔ ꠟꠣꠜ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("AC19_25","074_19_25","ACT","19","25","25","ꠢꠦ ꠅꠃ ꠛꠣꠘꠤꠀ ꠅꠇꠟꠞꠦ ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠤ ꠅꠇꠟꠞꠦꠅ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠤꠀ ꠇꠁꠟ, “ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘꠞꠣꠄ, ꠁ ꠇꠣꠞꠛꠣꠞ ꠕꠣꠇꠤ ꠀꠝꠞꠣ ꠜꠣꠟꠣ ꠟꠣꠜ ꠙꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC19_26","074_19_26","ACT","19","26","26","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠖꠦꠈꠞꠣꠄ ꠀꠞ ꠢꠥꠘꠞꠣꠄꠅ, ꠙꠣꠃꠟꠥꠍ ꠘꠣꠝꠞ ꠅꠃ ꠛꠦꠐꠣꠄ ꠈꠣꠟꠤ ꠀꠝꠞꠣꠞ ꠁꠚꠤꠍꠅꠃ ꠘꠣꠄ, ꠇꠁꠔꠦ ꠉꠦꠟꠦ ꠀꠡ꠆ꠔꠣ ꠀꠍꠤꠀ ꠎꠥꠠꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠍꠦ ꠀꠞ ꠄꠇꠤꠘ ꠇꠞꠣꠁꠍꠦ, ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠖꠦꠛ-ꠖꠦꠛꠤ ꠅꠇꠟ ꠛꠥꠟꠦ ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣꠃ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC19_27","074_19_27","ACT","19","27","27","ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘ ꠒꠞ ꠇꠞꠦꠞ, ꠈꠣꠟꠤ ꠀꠝꠞꠣꠞ ꠇꠣꠞꠛꠣꠞꠞꠃ ꠛꠖꠘꠣꠝ ꠅꠁꠛ ꠁꠟꠣ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠝꠢꠣꠖꠦꠛꠤ ꠀꠞ꠆ꠔꠦꠝꠤꠍꠞ ꠝꠘ꠆ꠖꠤꠞꠅ ꠛꠦꠇꠣꠝꠣ ꠅꠁꠎꠤꠛ, ꠀꠞ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠦ ꠀꠞ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠄ ꠝꠤꠟꠤꠀ ꠎꠦꠘ ꠙꠥꠎꠣ ꠇꠞꠦ, ꠔꠣꠁꠘꠅ ꠘꠤꠎꠞ ꠁꠎ꠆ꠎꠔ ꠀꠞꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC19_28","074_19_28","ACT","19","28","28","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣ ꠉꠥꠍꠣꠄ ꠀꠉꠥꠁꠘ ꠅꠁꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁꠚꠤꠍꠤꠀꠞ ꠀꠞ꠆ꠔꠦꠝꠤꠍ ꠖꠦꠛꠤ, ꠎꠤꠘ꠆ꠖꠣꠛꠣꠖ!” ");
INSERT INTO syls_vpl VALUES ("AC19_29","074_19_29","ACT","19","29","29","ꠟꠉꠦ ꠟꠉꠦ ꠀꠡ꠆ꠔꠣ ꠐꠣꠃꠘꠅ ꠉꠘ꠆ꠒꠉꠥꠟ ꠟꠣꠉꠤꠉꠦꠟ; ꠝꠣꠘꠡꠦ ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠉꠃꠍ ꠀꠞ ꠀꠞꠤꠡ꠆ꠔꠣꠇꠥꠍ ꠘꠣꠝꠞ ꠙꠣꠃꠟꠥꠍꠞ ꠟꠉꠞ ꠖꠥꠁꠎꠘꠞꠦ ꠗꠞꠤꠀ, ꠄꠇꠟꠉꠦ ꠙꠣꠟ ꠛꠣꠘ꠆ꠖꠤꠀ ꠖꠃꠠꠣꠁꠀ ꠡ꠆ꠐꠦꠒꠤꠀꠝꠅ ꠟꠁꠀ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_30","074_19_30","ACT","19","30","30","ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠅꠃ ꠜꠤꠠꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠀꠐꠇꠣꠁꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_31","074_19_31","ACT","19","31","31","ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠡꠞꠇꠣꠞꠤ ꠅꠚꠤꠡꠣꠞꠞ ꠝꠣꠎꠦ ꠇꠄꠎꠘ ꠀꠍꠟꠣ ꠙꠣꠃꠟꠥꠍꠞ ꠖꠥꠡ꠆ꠔ, ꠄꠞꠣ ꠈꠛꠞꠤꠀꠖꠤ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ, ꠔꠣꠁꠘ ꠢꠤ ꠜꠤꠠꠞ ꠍꠣꠝꠘꠦ ꠉꠤꠀ ꠘꠤꠎꠞ ꠝꠍꠤꠛꠔ ꠒꠣꠇꠤꠀ ꠀꠘꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_32","074_19_32","ACT","19","32","32","ꠜꠤꠠꠞ ꠝꠣꠎꠦ ꠝꠣꠘꠡꠦ ꠈꠥꠛ ꠌꠤꠟ꠆ꠟꠣ-ꠌꠤꠟ꠆ꠟꠤ ꠀꠞ ꠉꠦꠁꠘꠎꠣꠝ ꠟꠣꠉꠣꠁꠟꠣ। ꠛꠦꠡꠤꠞ ꠜꠣꠉ ꠝꠣꠘꠡꠦ ꠎꠣꠘꠔꠣꠃ ꠘꠣ ꠁꠘꠅ ꠇꠤꠔꠣ ꠅꠁꠍꠦ, ꠔꠣꠞꠣ ꠄꠇꠎꠘꠦ ꠄꠇꠟꠣꠈꠣꠘ, ꠀꠞꠇ ꠎꠘꠦ ꠀꠞꠇ ꠟꠣꠈꠣꠘ ꠝꠣꠔꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC19_33","074_19_33","ACT","19","33","33","ꠔꠦꠃ ꠇꠄꠎꠘ ꠁꠢꠥꠖꠤꠄ ꠍꠤꠇꠘ꠆ꠖꠞ ꠘꠣꠝꠞ ꠄꠇꠎꠘꠞꠦ ꠍꠣꠝꠘꠦ ꠑꠦꠟꠤꠀ ꠖꠤꠟ ꠜꠣꠡꠘ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ꠔꠣꠁꠘ ꠀꠔꠖꠤ ꠁꠡꠣꠞꠣ ꠖꠤꠟꠣ, ꠎꠣꠔꠦ ꠝꠣꠘꠥꠡ ꠘꠤꠞꠣꠁ ꠅꠁꠀ ꠔꠣꠘ ꠛꠇ꠆ꠔꠤꠔꠣ ꠢꠥꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC19_34","074_19_34","ACT","19","34","34","ꠅꠁꠟꠦ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠛꠥꠎꠟꠣ, ꠄꠁꠘꠅ ꠁꠢꠥꠖꠤ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠀꠞꠅ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁ ꠊꠘ꠆ꠐꠣ ꠗꠞꠤ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁꠚꠤꠍꠤꠀꠞ ꠀꠞ꠆ꠔꠦꠝꠤꠍ ꠖꠦꠛꠤ, ꠎꠤꠘ꠆ꠖꠣꠛꠣꠖ!” ");
INSERT INTO syls_vpl VALUES ("AC19_35","074_19_35","ACT","19","35","35","ꠢꠦꠡꠦ ꠐꠣꠃꠘꠞ ꠌꠦꠀꠞꠝꠣꠘꠦ ꠝꠣꠘꠡꠞꠦ ꠘꠤꠞꠣꠁ ꠇꠞꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅ ꠁꠚꠤꠍꠤꠀ ꠅꠇꠟ, ꠇꠃꠇ꠆ꠇꠣ ꠌꠣꠁꠘ, ꠇꠥꠘ ꠝꠣꠘꠥꠡꠉꠥꠄ ꠘꠣ ꠎꠣꠘꠦ ꠎꠦꠘ, ꠁ ꠁꠚꠤꠍ ꠐꠣꠃꠘ ꠅꠁꠟ ꠝꠢꠣꠘ ꠀꠞ꠆ꠔꠦꠝꠤꠍ ꠖꠦꠛꠤꠞ ꠝꠘ꠆ꠖꠤꠞ ꠀꠞ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠔꠣꠘ ꠎꠦꠔꠣ ꠝꠥꠞ꠆ꠔꠤ ꠟꠣꠝꠣꠔ ꠙꠠꠍꠦ ꠄꠞ ꠞꠁꠇ꠆ꠇꠣ ꠇꠞꠘꠦꠀꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("AC19_36","074_19_36","ACT","19","36","36","ꠀꠞ ꠁ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠦꠃ ꠎꠦꠛꠟꠣ ꠈꠘ꠆ꠒꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠔꠦ ꠛꠦꠛꠥꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠇꠣꠝ ꠘꠣ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠘꠤꠞꠣꠁ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("AC19_37","074_19_37","ACT","19","37","37","ꠅꠃ ꠝꠣꠘꠡꠦ ꠔ ꠀꠝꠞꠣꠞ ꠝꠘ꠆ꠖꠤꠞꠅ ꠌꠥꠞꠤꠅ ꠇꠞꠍꠦ ꠘꠣ, ꠀꠝꠞꠣꠞ ꠖꠦꠛꠤꠞ ꠇꠥꠘꠥ ꠛꠖꠘꠣꠝꠅ ꠇꠞꠦꠞ ꠘꠣ, ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣ ꠄꠞꠣꠞꠦ ꠗꠞꠤꠀ ꠀꠘꠍ। ");
INSERT INTO syls_vpl VALUES ("AC19_38","074_19_38","ACT","19","38","38","ꠔꠦ ꠢꠥꠘꠅ, ꠖꠤꠝꠤꠔ꠆ꠞꠤ ꠀꠞ ꠔꠣꠞ ꠟꠉꠞ ꠛꠣꠘꠤꠀ ꠅꠇꠟꠞ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠕꠣꠇꠦ, ꠔꠦ ꠀꠖꠣꠟꠔ ꠔ ꠈꠥꠟꠣ ꠀꠍꠦ, ꠢꠣꠇꠤꠝ ꠅꠇꠟꠅ ꠀꠍꠂꠘ, ꠔꠣꠞꠣ ꠢꠘꠅ ꠉꠤꠀ ꠎꠣꠞꠎꠤꠞ ꠝꠣꠝꠟꠣ-ꠝꠇꠖ꠆ꠖꠝꠣ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("AC19_39","074_19_39","ACT","19","39","39","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠞ ꠇꠥꠘꠥ ꠖꠣꠛꠤ-ꠖꠣꠅꠀ ꠕꠣꠇꠟꠦ ꠁꠔꠣ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠝꠎꠟꠤꠍꠅ ꠛꠁꠀ ꠝꠤꠐ-ꠝꠣꠐ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("AC19_40","074_19_40","ACT","19","40","40","ꠀꠍꠟꠦ ꠀꠁꠎꠇꠥꠞ ꠁ ꠉꠦꠁꠘꠎꠣꠝ ꠟꠣꠉꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦꠃ ꠖꠥꠡ ꠙꠠꠔ ꠙꠣꠞꠦ, ꠁ ꠉꠘ꠆ꠒꠉꠥꠟ ꠟꠣꠉꠣꠘꠤꠞ ꠇꠥꠘꠥ ꠇꠣꠞꠘ ꠖꠦꠈꠣꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC19_41","074_19_41","ACT","19","41","41","ꠅꠈꠣꠘ ꠇꠁꠀ ꠔꠣꠁꠘ ꠝꠎꠟꠤꠍ ꠜꠣꠋꠉꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_1","074_20_1","ACT","20","1","1","ꠉꠦꠁꠘꠎꠣꠝ ꠡꠦꠡ ꠅꠀꠞ ꠛꠣꠖꠦ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍꠦ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠈꠛꠞꠖꠤ ꠀꠘꠣꠁꠟꠣ, ꠔꠣꠞꠣ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞꠦ ꠃꠔꠡꠣꠢ ꠖꠤꠀ, ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠝꠣꠇꠤꠖꠘꠤꠀꠔ ꠎꠣꠁꠔꠣ ꠇꠞꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_2","074_20_2","ACT","20","2","2","ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠝꠣꠎꠦꠖꠤ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠛꠃꠔ ꠃꠔꠡꠣꠢ ꠖꠤꠀ, ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠅ ꠀꠁꠀ ꠀꠎꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_3","074_20_3","ACT","20","3","3","ꠅꠘꠅ ꠀꠁꠀ ꠔꠤꠘ ꠝꠣꠡ ꠞꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠎꠣꠎꠅ ꠇꠞꠤ ꠡꠤꠞꠤꠀ ꠖꠦꠡꠅ ꠎꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠔꠣꠘ ꠛꠤꠙꠇ꠆ꠇꠦ ꠇꠥ-ꠝꠔꠟꠛ ꠇꠞꠦꠞ ꠢꠥꠘꠤꠀ, ꠔꠣꠁꠘ ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠝꠣꠎꠦꠖꠤ ꠎꠣꠁꠔꠣ ꠇꠞꠤ ꠘꠤꠅꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_4","074_20_4","ACT","20","4","4","ꠀꠞ ꠛꠤꠞꠄꠀ ꠐꠣꠃꠘꠞ ꠙꠥꠞꠍꠞ ꠙꠥꠀ ꠍꠥꠙꠣꠔꠍ, ꠕꠤꠡꠟꠘꠤꠇꠤꠞ ꠀꠞꠤꠡ꠆ꠔꠣꠇꠥꠍ ꠀꠞ ꠍꠤꠇꠥꠘ꠆ꠖꠍ, ꠖꠞ꠆ꠛꠤ ꠡꠢꠞꠞ ꠉꠃꠍ, ꠔꠤꠝꠕꠤ, ꠀꠞ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠔꠥꠈꠤꠇ ꠀꠞ ꠔꠚꠤꠝ, ꠄꠞꠣ ꠢꠇ꠆ꠇꠟ ꠙꠣꠃꠟꠥꠍꠞ ꠟꠉꠦ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_5","074_20_5","ACT","20","5","5","ꠄꠞꠣ ꠀꠉꠦ ꠅꠁꠀ ꠔꠞꠥꠀꠍ ꠐꠣꠃꠘꠅ ꠉꠤꠀ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_6","074_20_6","ACT","20","6","6","ꠛꠣꠖꠦ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤꠞ ꠁꠖ ꠡꠦꠡ ꠅꠁꠉꠦꠟꠦ ꠀꠝꠞꠣ ꠎꠣꠎꠅ ꠇꠞꠤ ꠚꠤꠟꠤꠙꠤ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠀ, ꠙꠣꠌ ꠖꠤꠘ ꠛꠣꠖꠦ ꠔꠞꠥꠀꠍ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠟꠣꠝ, ꠅꠘꠅ ꠡꠣꠔꠖꠤꠘ ꠞꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC20_7","074_20_7","ACT","20","7","7","ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠁꠍꠣꠞ ꠝꠦꠎꠛꠣꠘꠤ ꠈꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠟꠦ, ꠙꠣꠃꠟꠥꠍ ꠛꠣꠖꠞ ꠖꠤꠘ ꠎꠣꠁꠔꠣꠉꠤ ꠇꠞꠤ ꠝꠣꠎ ꠞꠣꠁꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠅꠀꠎ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_8","074_20_8","ACT","20","8","8","ꠀꠝꠞꠣ ꠃꠙꠞꠞ ꠔꠣꠟꠣꠞ ꠎꠦ ꠊꠞꠅ ꠛꠁꠍꠟꠣꠝ ꠢꠤꠈꠣꠘꠅ ꠛꠃꠔ ꠛꠣꠔ꠆ꠔꠤ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC20_9","074_20_9","ACT","20","9","9","ꠀꠞ ꠃꠔꠥꠈ ꠘꠣꠝꠞ ꠄꠇ ꠎꠥꠀꠘ ꠙꠥꠀ ꠈꠤꠠꠇꠤꠞ ꠃꠙꠞꠦ ꠛꠅꠀꠔ ꠀꠍꠤꠟ, ꠙꠣꠃꠟꠥꠍꠦ ꠛꠃꠔ ꠡꠝꠄ ꠗꠞꠤ ꠅꠀꠎ ꠇꠞꠣꠄ ꠢꠦ ꠢꠥꠘꠤ ꠢꠥꠘꠤ ꠊꠥꠝꠣꠁ ꠉꠦꠍꠤꠟ, ꠀꠈꠔꠣꠃ ꠢꠦ ꠔꠤꠘ ꠔꠣꠟꠣ ꠕꠣꠇꠤ ꠟꠣꠝꠣꠔ ꠙꠠꠤꠉꠦꠟ। ꠔꠦꠃ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠝꠞꠣ ꠢꠣꠟꠔꠦ ꠔꠥꠟꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_10","074_20_10","ACT","20","10","10","ꠙꠣꠃꠟꠥꠍ ꠟꠣꠝꠣꠔ ꠟꠣꠝꠤꠀ ꠙꠥꠀꠞ ꠃꠙꠞꠦ ꠇꠣꠁꠔ ꠅꠁꠀ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠃꠟꠁꠡ꠆ꠔꠟ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠔ ꠎꠣꠘ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("AC20_11","074_20_11","ACT","20","11","11","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠃꠙꠞꠞ ꠔꠣꠟꠣꠔ ꠉꠤꠀ ꠝꠦꠎꠛꠣꠘꠤ ꠈꠣꠁꠟꠣ, ꠈꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠚꠎꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠤꠀ ꠛꠤꠖꠣꠄ ꠟꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_12","074_20_12","ACT","20","12","12","ꠄꠞ ꠝꠣꠎꠦ ꠅꠃ ꠙꠥꠀꠞꠦ ꠝꠣꠘꠡꠦ ꠎꠤꠔꠣ ꠢꠣꠟꠔꠦ ꠛꠣꠠꠤꠔ ꠘꠤꠀ ꠎꠣꠞ ꠙꠞ ꠘꠣꠁ ꠈꠥꠡꠤ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_13","074_20_13","ACT","20","13","13","ꠀꠝꠞꠣ ꠀꠉꠦ ꠉꠤꠀ ꠎꠣꠎꠅ ꠇꠞꠤ ꠀꠍꠥꠍ ꠊꠣꠐꠞ ꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣꠝ, ꠝꠘꠅ ꠇꠞꠟꠣꠝ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠢꠘ ꠕꠣꠇꠤ ꠔꠥꠟꠝꠥ। ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠈꠤꠀꠟ ꠇꠞꠍꠟꠣ ꠀꠐꠤꠀ ꠢꠤꠈꠣꠘꠅ ꠉꠤꠀ ꠃꠑꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_14","074_20_14","ACT","20","14","14","ꠀꠍꠥꠍ ꠀꠁꠀ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠞ ꠛꠣꠖꠦ, ꠀꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠎꠣꠎꠅ ꠔꠥꠟꠤꠀ ꠝꠤꠔꠥꠟꠤꠘꠤꠔ ꠀꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC20_15","074_20_15","ACT","20","15","15","ꠛꠣꠖꠞ ꠖꠤꠘ ꠀꠝꠞꠣ ꠎꠣꠎ ꠈꠥꠟꠤꠀ ꠢꠤꠈꠣꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠈꠤꠅꠍ ꠖꠤꠙꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠣꠝ; ꠄꠞ ꠛꠣꠖꠞ ꠖꠤꠘ ꠀꠝꠞꠣ ꠍꠣꠝꠥꠍ ꠖꠤꠙꠅ ꠞꠁꠟꠣꠝ, ꠔꠣꠞ ꠛꠣꠖꠞ ꠖꠤꠘ ꠉꠤꠀ ꠀꠝꠞꠣ ꠝꠤꠟꠤꠔꠣ ꠊꠣꠐꠅ ꠜꠤꠠꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC20_16","074_20_16","ACT","20","16","16","ꠀꠍꠤꠀ ꠖꠦꠡꠅ ꠙꠣꠃꠟꠥꠍꠦ ꠖꠦꠞꠤ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠘꠣ ꠅꠀꠄ ꠔꠣꠁꠘ ꠝꠘꠦ ꠝꠘꠦ ꠑꠤꠇ ꠇꠞꠍꠟꠣ, ꠁꠚꠤꠍꠅ ꠘꠣ ꠢꠣꠝꠣꠁꠀ ꠄꠞ ꠉꠣꠟꠣꠛꠣꠄ ꠎꠣꠁꠛꠣꠉꠤ, ꠔꠣꠁꠘ ꠎꠟꠖꠤ ꠇꠞꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠤꠀ ꠢꠣꠞꠤ ꠙꠘ꠆ꠌꠣꠁꠡꠣ ꠁꠖ ꠢꠘꠅ ꠀꠖꠣꠄ ꠇꠞꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_17","074_20_17","ACT","20","17","17","ꠝꠤꠟꠤꠔꠣ ꠕꠣꠇꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠈꠛꠞꠤꠀ ꠙꠣꠑꠣꠁꠀ ꠁꠚꠤꠍꠞ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_18","074_20_18","ACT","20","18","18","ꠔꠣꠞꠣ ꠀꠁꠀ ꠙꠃꠍꠣꠞ ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠇꠁꠟꠣ, “ꠀꠙꠘꠣꠞꠣ ꠔ ꠎꠣꠘꠂꠘ, ꠀꠍꠤꠀ ꠖꠦꠡꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠀꠝꠤ ꠙꠄꠟꠣ ꠖꠤꠘ ꠕꠣꠇꠤꠃ ꠇꠤꠟꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠡꠝꠄ ꠇꠣꠐꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC20_19","074_20_19","ACT","20","19","19","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠃꠔ ꠎꠣꠔꠞ ꠇꠥ-ꠙꠞꠣꠝꠤꠡ ꠕꠣꠇꠤ, ꠔꠣꠞꠣꠞ ꠙꠣꠔꠣꠁꠟ ꠚꠘ꠆ꠖꠤꠞ ꠝꠣꠎꠦꠅ ꠀꠝꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠞꠝ ꠖꠤꠟꠦ, ꠌꠃꠈꠞ ꠙꠣꠘꠤ ꠚꠣꠟꠣꠁꠀ ꠝꠣꠛꠥꠖꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC20_20","074_20_20","ACT","20","20","20","ꠀꠙꠘꠣꠞꠣꠞ ꠚꠣꠄꠖꠣ ꠅꠁꠛ ꠁꠟꠣ ꠇꠥꠘꠥ ꠔꠣꠟꠤꠝꠃ ꠘꠣ ꠟꠥꠇꠣꠁꠀ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠣꠘꠣꠁꠍꠤ, ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠝꠎꠟꠤꠍꠅ ꠀꠞ ꠊꠞꠅ ꠊꠞꠅ ꠉꠤꠀ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠦꠅ ꠘꠣ ꠇꠞꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_21","074_20_21","ACT","20","21","21","ꠁꠢꠥꠖꠤ ꠀꠞ ꠁꠃꠘꠣꠘꠤꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠛꠥꠎꠣꠁꠍꠤ, ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠝꠘ ꠛꠖꠟꠣꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠙꠕꠤ ꠅꠁꠔꠣ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_22","074_20_22","ACT","20","22","22","ꠀꠞ ꠅꠈꠘ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠢꠥꠇꠥꠝꠛꠘ꠆ꠖꠤ ꠅꠁꠀ ꠀꠝꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠁꠞꠣꠝ, ꠢꠤꠈꠣꠘꠅ ꠀꠝꠣꠞ ꠇꠥꠘ ꠖꠡꠣ ꠅꠁꠛ, ꠎꠣꠘꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_23","074_20_23","ACT","20","23","23","ꠈꠣꠟꠤ ꠅꠃ ꠈꠛꠞꠈꠣꠘ ꠎꠣꠘꠤ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠢꠇ꠆ꠇꠟ ꠐꠣꠃꠘꠅ ꠀꠝꠣꠞꠦ ꠅꠃ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠞꠣ, ꠔꠇꠟꠤꠚ ꠀꠞ ꠎꠦꠟ ꠈꠣꠐꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("AC20_24","074_20_24","ACT","20","24","24","ꠅꠁꠟꠦꠅ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠘꠞ ꠙꠞꠥꠀ ꠇꠞꠤ ꠘꠣ, ꠀꠝꠣꠞ ꠎꠣꠘꠞꠦ ꠅꠔ ꠝꠥꠟ꠆ꠟꠛꠣꠘ ꠝꠘꠅ ꠇꠞꠤ ꠘꠣ। ꠀꠝꠤ ꠁꠞꠣꠖꠣ ꠇꠞꠣ ꠙꠕꠞ ꠢꠦꠡ ꠑꠤꠇꠣꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠃꠠꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ। ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠔꠛꠟꠤꠉ ꠀꠞ ꠈꠦꠎꠝꠔꠞ ꠅꠃ ꠎꠦ ꠜꠣꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍꠤ, ꠄꠞ ꠁꠘ꠆ꠎꠣꠝ ꠖꠤꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC20_25","074_20_25","ACT","20","25","25","ꠅꠈꠘ ꠀꠝꠤ ꠄꠅꠈꠣꠘꠅ ꠎꠣꠘꠤ, ꠀꠙꠘꠣꠞꠣ ꠎꠦꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ, ꠅꠃ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠟꠉꠦꠅ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠖꠦꠈꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC20_26","074_20_26","ACT","20","26","26","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠁꠎ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠅꠃ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠞꠣꠝ, ꠢꠇ꠆ꠇꠟꠞ ꠟꠃꠞ ꠖꠣꠄ ꠕꠣꠇꠤ ꠀꠝꠤ ꠈꠣꠟꠣꠍ। ");
INSERT INTO syls_vpl VALUES ("AC20_27","074_20_27","ACT","20","27","27","ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠝꠞ꠆ꠎꠤꠞ ꠇꠕꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠛꠄꠀꠘ ꠇꠞꠔꠦ ꠈꠞꠦꠖꠤ ꠉꠦꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_28","074_20_28","ACT","20","28","28","ꠀꠙꠘꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠅꠃꠇ꠆ꠇꠣ। ꠙꠣꠇ ꠞꠥꠢꠦ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠎꠦꠞꠣꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠅꠃꠇ꠆ꠇꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠘꠞꠦꠖꠤ ꠎꠦꠞꠣꠞꠦ ꠈꠞꠤꠖ ꠇꠞꠍꠂꠘ, ꠢꠤ ꠎꠝꠣꠔꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠎꠦꠟꠣ ꠞꠣꠈꠣꠟꠦ ꠔꠣꠞ ꠝꠦꠠꠣꠞ ꠙꠣꠟꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠦ, ꠁꠝꠣꠝ ꠅꠁꠀ ꠀꠙꠘꠣꠞꠣꠅ ꠅꠃꠟꠣ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_29","074_20_29","ACT","20","29","29","ꠀꠝꠤ ꠎꠣꠘꠤ, ꠀꠝꠤ ꠎꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠙꠣꠉꠟꠣ ꠛꠣꠊꠞ ꠍꠥꠞꠔꠞ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠢꠣꠝꠣꠁꠛꠣ, ꠔꠣꠞꠣ ꠘꠤꠞ꠆ꠖꠄ ꠅꠁꠀ ꠙꠣꠟꠞ ꠛꠃꠔ ꠈꠦꠔꠤ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_30","074_20_30","ACT","20","30","30","ꠀꠞ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠘꠤꠎꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠅ ꠇꠦꠃ ꠇꠦꠃ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠔꠣꠞ ꠈꠞꠦ ꠘꠦꠅꠀꠞ ꠟꠣꠉꠤ, ꠢꠣꠍꠣ ꠔꠣꠟꠤꠝꠞꠦ ꠝꠤꠍꠣ ꠇꠁꠀ ꠘꠄꠀ ꠔꠣꠟꠤꠝ ꠛꠣꠞ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("AC20_31","074_20_31","ACT","20","31","31","ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠣ ꠢꠎꠣꠉ ꠞꠃꠇ꠆ꠇꠣ, ꠀꠞ ꠝꠘꠅ ꠞꠣꠈꠛꠣ, ꠀꠝꠤ ꠔꠤꠘ ꠛꠞꠍ ꠗꠞꠤꠀ ꠞꠣꠁꠔ-ꠖꠤꠘ ꠌꠃꠈꠞ ꠙꠣꠘꠤ ꠚꠣꠟꠣꠁꠀ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠔꠦ ꠖꠝ ꠟꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_32","074_20_32","ACT","20","32","32","ꠅꠈꠘ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠔꠣꠘ ꠞꠢꠝꠔꠞ ꠇꠣꠟꠣꠝꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠡꠙꠤꠟꠣꠝ। ꠀꠟ꠆ꠟꠣꠞ ꠁ ꠇꠣꠟꠣꠝꠦ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠛ ꠀꠞ ꠔꠣꠘ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠅꠀꠖꠣ ꠇꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠝꠘ꠆ꠎꠤꠟꠅ ꠙꠃꠍꠣꠁ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("AC20_33","074_20_33","ACT","20","33","33","ꠀꠝꠤ ꠔ ꠇꠦꠃꠞꠞ ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠛꠣ ꠇꠣꠙꠠ-ꠌꠥꠙꠠꠞ ꠛꠣꠄ ꠟꠣꠟꠌ ꠇꠞꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_34","074_20_34","ACT","20","34","34","ꠀꠙꠘꠣꠞꠣ ꠘꠤꠎꠦꠃ ꠔ ꠎꠣꠘꠂꠘ, ꠀꠝꠣꠞ ꠀꠞ ꠀꠝꠣꠞ ꠟꠉꠤ ꠅꠇꠟꠞ ꠅꠜꠣꠛ ꠝꠤꠐꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠖꠥꠁꠅ ꠀꠔꠦ ꠇꠣꠝ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC20_35","074_20_35","ACT","20","35","35","ꠀꠝꠤ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠇꠣꠝꠞ ꠝꠣꠎꠦ ꠘꠝꠥꠘꠣ ꠖꠦꠈꠣꠁꠍꠤ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠤꠀ ꠖꠥꠞ꠆ꠛꠟ ꠅꠇꠟꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣ ꠎꠞꠥꠞ। ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠔꠣꠟꠤꠝꠞꠦ ꠝꠘꠅ ꠞꠣꠈꠅ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠘꠦꠅꠀꠞ ꠌꠣꠁꠔꠦ ꠖꠦꠅꠀ ꠗꠁꠘ꠆ꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC20_36","074_20_36","ACT","20","36","36","ꠅꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠟꠦ, ꠙꠣꠃꠟꠥꠍꠦ ꠀꠐꠥ ꠉꠣꠠꠤꠀ ꠢꠇꠟꠞ ꠟꠉꠦ ꠖꠥꠀ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_37","074_20_37","ACT","20","37","37","ꠛꠣꠖꠦ ꠎꠝꠣꠔꠞ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠈꠥꠛ ꠇꠣꠘ꠆ꠖꠘ ꠇꠣꠘ꠆ꠖꠤꠟꠣ, ꠀꠞ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠀꠁꠘ꠆ꠎꠣ ꠇꠞꠤ ꠗꠞꠤꠀ ꠢꠥꠋꠉꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC20_38","074_20_38","ACT","20","38","38","ꠈꠣꠍ ꠇꠞꠤ ꠙꠣꠃꠟꠥꠍꠞ ꠅꠃ ꠇꠕꠣꠞ ꠟꠣꠉꠤ ꠛꠦꠡꠤ ꠇꠣꠘ꠆ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, ꠔꠣꠘ ꠝꠥꠈ ꠔꠣꠞꠣ ꠀꠞ ꠖꠦꠈꠔꠣ ꠘꠣꠄ। ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠔꠣꠘ ꠟꠉꠦ ꠅꠁꠀ ꠉꠤꠀ ꠎꠣꠎꠅ ꠔꠥꠟꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_1","074_21_1","ACT","21","1","1","ꠁꠚꠤꠍꠞ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠟꠁꠀ, ꠎꠣꠎ ꠈꠥꠟꠤꠀ ꠢꠣꠞꠤ ꠀꠝꠞꠣ ꠡꠥꠎꠣ ꠙꠕꠦ ꠇꠥꠍ ꠘꠣꠝꠞ ꠖꠤꠙꠅ ꠀꠁꠟꠣꠝ, ꠛꠣꠖꠞ ꠖꠤꠘ ꠀꠝꠞꠣ ꠞꠥꠖꠍ ꠖꠤꠙꠅ ꠀꠁꠟꠣꠝ, ꠢꠘ ꠕꠣꠇꠤ ꠙꠣꠔꠣꠞꠣ ꠘꠣꠝꠞ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC21_2","074_21_2","ACT","21","2","2","ꠢꠘꠅ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠚꠂꠘꠤꠇꠤꠀꠔ ꠎꠣꠅꠞꠣ ꠄꠇꠈꠣꠘ ꠎꠣꠎ ꠙꠣꠁꠟꠣꠝ, ꠀꠝꠞꠣ ꠢꠃ ꠎꠣꠎꠦ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC21_3","074_21_3","ACT","21","3","3","ꠀꠞ ꠎꠦꠛꠟꠣ ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠖꠤꠙ ꠖꠦꠈꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠖꠤꠙꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠛꠣꠄ ꠉꠤꠀ ꠀꠝꠞꠣ ꠡꠤꠞꠤꠀ ꠖꠦꠡꠞ ꠡꠥꠞ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠟꠣꠝꠟꠣꠝ। ꠢꠤꠈꠣꠘꠅ ꠎꠣꠎꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠟꠣꠝꠣꠁ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC21_4","074_21_4","ACT","21","4","4","ꠢꠘꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠢꠣꠞꠤ ꠀꠝꠞꠣ ꠡꠣꠔ ꠖꠤꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠁꠟꠣꠝ; ꠔꠣꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠞꠚꠔꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠘꠣ ꠎꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("AC21_5","074_21_5","ACT","21","5","5","ꠁꠘꠅ ꠇꠄꠖꠤꠘ ꠇꠣꠐꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣꠝ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠇ꠆ꠇꠟꠦ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠟꠁꠀ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠀꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠀꠉꠥꠀꠁ ꠖꠤꠟꠣ। ꠛꠣꠖꠦ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠅ ꠀꠝꠞꠣ ꠀꠐꠥ ꠉꠣꠠꠤꠀ ꠖꠥꠀ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC21_6","074_21_6","ACT","21","6","6","ꠖꠥꠀ ꠛꠣꠖꠦ ꠎꠣꠞꠎꠤꠞ ꠙꠕꠦ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠀꠝꠞꠣ ꠎꠣꠎꠅ ꠃꠑꠟꠣꠝ, ꠀꠞ ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC21_7","074_21_7","ACT","21","7","7","ꠡꠥꠞ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠀ ꠀꠝꠞꠣ ꠎꠣꠎꠞ ꠍꠚꠞ ꠡꠦꠡ ꠇꠞꠤꠀ ꠔꠟꠤꠝꠣꠄꠁꠔ ꠀꠎꠤꠟꠣꠝ, ꠢꠘꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠎꠤꠇꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠄꠇꠖꠤꠘ ꠞꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC21_8","074_21_8","ACT","21","8","8","ꠛꠣꠖꠞ ꠖꠤꠘ ꠀꠝꠞꠣ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠇꠂꠍꠞꠤꠀꠔ ꠀꠁꠟꠣꠝ, ꠀꠞ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠞ ꠛꠥꠎꠥꠞ꠆ꠉ ꠚꠤꠟꠤꠚꠞ ꠛꠣꠠꠤꠔ ꠉꠦꠟꠣꠝ। ꠄꠁꠘ ꠔ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠢꠃ ꠡꠣꠔ ꠈꠣꠖꠤꠝꠖꠣꠞꠞ ꠄꠇꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("AC21_9","074_21_9","ACT","21","9","9","ꠔꠣꠘ ꠌꠣꠁꠞꠎꠘ ꠀꠛꠤꠀꠔꠤ ꠙꠥꠠꠤꠘ ꠀꠍꠟꠣ, ꠄꠞꠣ ꠘꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠅꠢꠤ ꠇꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_10","074_21_10","ACT","21","10","10","ꠛꠣꠇ꠆ꠇꠣ ꠇꠄꠖꠤꠘ ꠢꠘꠅ ꠞꠅꠀꠞ ꠛꠣꠖꠦ ꠀꠉꠣꠛꠥꠍ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠘꠛꠤꠄ ꠄꠢꠥꠖꠤꠀ ꠕꠣꠇꠤ ꠔꠡꠞꠤꠚ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_11","074_21_11","ACT","21","11","11","ꠔꠣꠁꠘ ꠀꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠃꠟꠥꠍꠞ ꠇꠝꠞꠞ ꠔꠣꠉꠣ ꠈꠥꠟꠤꠟꠤꠟꠣ, ꠀꠞ ꠁꠐꠣꠖꠤ ꠘꠤꠎꠞ ꠀꠔ-ꠙꠣꠅ ꠛꠣꠘ꠆ꠖꠤꠀ ꠇꠁꠟꠣ, “ꠙꠣꠇ ꠞꠥꠢꠦ ꠅꠃꠟꠣ ꠇꠁꠞꠣ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠅꠃ ꠇꠝꠞꠞ ꠔꠣꠉꠣ ꠀꠟꠣꠞꠦ ꠅꠃꠟꠣ ꠛꠣꠘꠛꠣ, ꠀꠞ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC21_12","074_21_12","ACT","21","12","12","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠀꠞ ꠀꠝꠞꠣꠅ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠛꠃꠔ ꠝꠤꠘꠔ ꠇꠞꠟꠣꠝ, ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠣꠅꠀ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("AC21_13","074_21_13","ACT","21","13","13","ꠙꠣꠃꠟꠥꠍꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠇꠤꠔꠣ ꠟꠣꠉꠣꠁꠟꠣꠄ? ꠇꠣꠘ꠆ꠖꠤꠀ ꠀꠝꠣꠞ ꠝꠘ ꠜꠣꠋꠉꠤ ꠖꠤꠞꠣꠄ ꠇꠦꠘꠦ? ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠈꠣꠟꠤ ꠛꠘ꠆ꠖꠤ ꠅꠀꠃ ꠘꠣꠄ, ꠝꠞꠔꠦꠅ ꠔꠤꠀꠞ ꠀꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("AC21_14","074_21_14","ACT","21","14","14","ꠔꠣꠘꠞꠦ ꠇꠕꠣ ꠢꠥꠘꠣꠁꠔꠣꠝ ꠘꠣ ꠙꠣꠞꠤꠀ ꠀꠝꠞꠣ ꠘꠤꠞꠣꠁ ꠅꠁꠉꠦꠟꠣꠝ, ꠀꠞ ꠇꠁꠟꠣꠝ, “ꠝꠣꠛꠥꠖꠞ ꠝꠞ꠆ꠎꠤ ꠇꠣꠁꠝ ꠅꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("AC21_15","074_21_15","ACT","21","15","15","ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠉꠣꠁꠐ ꠛꠣꠘ꠆ꠖꠤꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC21_16","074_21_16","ACT","21","16","16","ꠇꠂꠍꠞꠤꠀ ꠐꠣꠃꠘꠞ ꠇꠄꠎꠘ ꠝꠥꠝꠤꠘꠅ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠁꠟꠣ, ꠀꠞ ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠖꠤꠙꠞ ꠝꠦꠘꠣꠍꠘ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠙꠥꠞꠣꠘꠣ ꠁꠝꠣꠘꠖꠣꠞꠞ ꠛꠣꠠꠤꠔ ꠀꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠄꠘ ꠛꠣꠠꠤꠔꠃ ꠀꠝꠞꠣ ꠞꠅꠀꠞ ꠇꠕꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC21_17","074_21_17","ACT","21","17","17","ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠅꠀꠞ ꠛꠣꠖꠦ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠈꠥꠡꠤ ꠅꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_18","074_21_18","ACT","21","18","18","ꠛꠣꠖꠞ ꠖꠤꠘ ꠙꠣꠃꠟꠥꠍꠦ ꠀꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠜꠣꠁ ꠁꠀꠇꠥꠛꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠟꠣ। ꠢꠤꠈꠣꠘꠅ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠅ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_19","074_21_19","ACT","21","19","19","ꠙꠣꠃꠟꠥꠍꠦ ꠄꠞꠣꠞꠦ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠎꠤꠇꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠘ ꠔꠛꠟꠤꠉꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠄ ꠇꠤꠟꠣꠘ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠖꠤꠘꠤ ꠇꠣꠝ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠛꠄꠀꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_20","074_21_20","ACT","21","20","20","ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠟꠣ ꠀꠞ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁ, ꠔꠥꠝꠤ ꠔ ꠖꠦꠈꠞꠣꠄ, ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠁꠢꠥꠖꠤꠄ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ, ꠀꠞ ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞꠦ ꠀꠝꠟ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC21_21","074_21_21","ACT","21","21","21","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠅꠃ ꠈꠛꠞꠅ ꠙꠣꠁꠍꠂꠘ, ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠕꠣꠇꠂꠘ, ꠔꠣꠞꠣꠞꠦ ꠔꠥꠝꠤ ꠔꠣꠟꠤꠝ ꠖꠤꠍ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠔꠣ ꠇꠞꠤ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠘ ꠀꠞ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠞꠦꠅꠀꠎꠅ ꠘꠣ ꠝꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC21_22","074_21_22","ACT","21","22","22","ꠔꠦ ꠇꠤꠔꠣ ꠇꠞꠣ ꠎꠣꠄ? ꠔꠣꠞꠣ ꠔ ꠘꠤꠌꠄ ꠢꠥꠘꠛꠣ ꠔꠥꠝꠤ ꠀꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("AC21_23","074_21_23","ACT","21","23","23","ꠅꠈꠘ ꠀꠝꠞꠣ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠁ, ꠔꠥꠝꠤ ꠅꠃꠟꠣ ꠇꠞꠤꠟꠣꠅ। ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠌꠣꠁꠞꠎꠘ ꠛꠦꠐꠣꠁꠘ ꠀꠍꠂꠘ, ꠔꠣꠞꠣ ꠄꠇꠈꠣꠘ ꠝꠣꠘ꠆ꠘꠔ ꠇꠞꠍꠂꠘ; ");
INSERT INTO syls_vpl VALUES ("AC21_24","074_21_24","ACT","21","24","24","ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠎꠣꠅ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠉꠤꠀ ꠔꠥꠝꠤ ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠈꠞꠌ ꠀꠞ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠘꠤꠞ ꠙꠄꠡꠣꠅ ꠖꠤꠟꠣꠅ। ꠔꠦꠃ ꠢꠇꠟꠦ ꠎꠣꠘꠛꠣ, ꠔꠥꠝꠣꠞ ꠘꠣꠝꠦ ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠈꠛꠞ ꠙꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠄ, ꠀꠍꠟꠦ ꠔꠥꠝꠤ ꠘꠤꠎꠦꠅ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠀꠞ ꠞꠦꠅꠀꠎ ꠝꠣꠘꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC21_25","074_21_25","ACT","21","25","25","ꠅꠁꠟꠦ ꠎꠦꠔꠣ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ, ꠔꠣꠞꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠅꠃ ꠚꠄꠍꠣꠟꠣ ꠟꠦꠈꠤꠀ ꠎꠣꠘꠣꠁ ꠖꠤꠍꠤ, ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠘꠤꠅꠔ ꠇꠞꠣ ꠈꠣꠘꠤ ꠈꠣꠁꠔꠣ ꠘꠣ, ꠟꠃ ꠈꠣꠁꠔꠣ ꠘꠣ ꠀꠞ ꠉꠟꠣ ꠐꠤꠙꠤꠀ ꠝꠣꠞꠣ ꠇꠥꠘꠥ ꠎꠣꠘꠖꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠣ ꠘꠣ, ꠇꠥꠘꠥ ꠎꠣꠔꠞ ꠎꠤꠘꠣꠞ ꠇꠣꠝꠅ ꠎꠣꠁꠔꠣ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC21_26","074_21_26","ACT","21","26","26","ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠢꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠉꠤꠀ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠘꠤꠎꠞꠦꠅ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠟꠣ। ꠛꠣꠖꠞ ꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠁꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠟꠣꠉꠤ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠥꠘꠖꠤꠘ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠄꠅ ꠔꠣꠞꠤꠈ ꠎꠣꠘꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_27","074_21_27","ACT","21","27","27","ꠙꠣꠇ-ꠍꠣꠚ ꠅꠀꠞ ꠘꠤꠅꠝꠞ ꠢꠤ ꠡꠣꠔ ꠖꠤꠘ ꠡꠦꠡ ꠘꠣ ꠅꠁꠔꠦꠃ, ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠇꠄꠎꠘ ꠁꠢꠥꠖꠤꠄ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠖꠦꠈꠤꠀ, ꠝꠣꠘꠡꠞꠦ ꠃꠍꠇꠣꠁ ꠖꠤꠀ ꠔꠣꠘꠦ ꠗꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_28","074_21_28","ACT","21","28","28","ꠔꠣꠞꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ, ꠀꠉꠥꠀꠅ! ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠦꠉꠥꠄ ꠀꠝꠞꠣꠞ ꠎꠣꠔꠤꠞ, ꠀꠝꠞꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠀꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠊꠥꠞꠦ, ꠅꠉꠥ ꠢꠃ ꠛꠦꠐꠣ! ꠢꠦ ꠁꠃꠘꠣꠘꠤ ꠅꠇꠟꠞꠦ ꠅꠘꠅ ꠢꠣꠞꠣꠁꠀ ꠁ ꠙꠣꠇ ꠎꠣꠉꠣꠈꠣꠘꠞꠦꠅ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("AC21_29","074_21_29","ACT","21","29","29","ꠄꠞ ꠀꠉꠦ ꠔ ꠁꠚꠤꠍꠞ ꠔꠚꠤꠝꠞꠦ ꠙꠣꠃꠟꠥꠍꠞ ꠟꠉꠦ ꠐꠣꠃꠘꠅ ꠌꠇ꠆ꠇꠞꠅ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠝꠘꠦ ꠝꠘꠦ ꠡꠘ꠆ꠖꠄ ꠇꠞꠍꠂꠘ, ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠘꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ-ꠅ ꠢꠣꠞꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC21_30","074_21_30","ACT","21","30","30","ꠔꠦꠃ ꠀꠡ꠆ꠔꠣ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠥꠡ ꠉꠞꠝ ꠅꠁꠉꠦꠟꠣ, ꠀꠞ ꠄꠇꠟꠉꠦ ꠖꠃꠠꠤꠀ ꠀꠁꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠗꠞꠤꠀ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠕꠣꠇꠤ ꠐꠣꠘꠤꠀ ꠛꠣꠞꠦ ꠀꠘꠟꠣ, ꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠄꠞ ꠖꠥꠀꠞ ꠅꠇꠟ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_31","074_21_31","ACT","21","31","31","ꠔꠣꠞꠣ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠌꠣꠁꠟꠣ, ꠅꠁꠟꠦ ꠅꠃ ꠡꠝꠄ ꠞꠥꠝꠣꠘ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞ ꠙꠞꠗꠣꠘꠞ ꠉꠦꠍꠦ ꠈꠛꠞ ꠉꠦꠟ, ꠀꠡ꠆ꠔꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠝꠣꠎꠦ ꠃꠟꠁꠡ꠆ꠔꠟ ꠟꠣꠉꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC21_32","074_21_32","ACT","21","32","32","ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠁꠘ ꠍꠥꠛꠦꠖꠣꠞ ꠅꠇꠟ ꠀꠞ ꠍꠤꠙꠣꠁ ꠖꠟ ꠟꠁꠀ ꠖꠃꠠꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠣ। ꠝꠣꠘꠡꠦ ꠍꠤꠙꠣꠁ ꠀꠞ ꠍꠤꠙꠣꠁꠞ ꠙꠞꠗꠣꠘꠞꠦ ꠖꠦꠈꠤꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠣ ꠛꠘ꠆ꠖ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_33","074_21_33","ACT","21","33","33","ꠔꠦꠃ ꠢꠤ ꠅꠚꠤꠡꠣꠞꠦ ꠀꠁꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠀꠐꠇ ꠇꠞꠤꠀ ꠖꠥꠁꠉꠦꠍꠣ ꠡꠤꠇꠟꠖꠤ ꠛꠣꠘ꠆ꠖꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠛꠣꠖꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠁ ꠝꠣꠘꠥꠡꠉꠥ ꠇꠦ, ꠢꠦ ꠇꠤꠔꠣ ꠖꠥꠡ ꠇꠞꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("AC21_34","074_21_34","ACT","21","34","34","ꠉꠘ꠆ꠒꠉꠥꠟꠞ ꠝꠣꠎꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠦꠃ ꠄꠇꠟꠣꠈꠣꠘ, ꠇꠦꠃ ꠇꠦꠃ ꠀꠞꠇ ꠟꠣꠈꠣꠘ ꠇꠁꠟ। ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠇꠥꠘ꠆ꠔꠣ ꠡꠝꠎꠤꠔꠣ ꠘꠣ ꠙꠣꠞꠤꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠘꠤꠀ ꠇꠦꠘ꠆ꠐꠘꠝꠦꠘ꠆ꠐꠅ ꠢꠣꠞꠣꠁꠀ ꠕꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC21_35","074_21_35","ACT","21","35","35","ꠙꠣꠃꠟꠥꠍ ꠍꠤꠠꠤꠞ ꠝꠥꠈꠅ ꠎꠣꠁꠔꠦꠃ ꠝꠣꠘꠡꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠃꠌꠣ ꠇꠞꠤꠀ ꠛꠁꠀ ꠘꠤꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC21_36","074_21_36","ACT","21","36","36","ꠝꠣꠘꠡꠦ ꠈꠞꠦ ꠅꠁꠀ ꠝꠤꠍꠤꠟ ꠖꠤꠔꠣ ꠟꠣꠉꠟꠣ, “ꠅꠉꠥꠞꠦ ꠝꠣꠞꠤꠟꠣꠅ!” ");
INSERT INTO syls_vpl VALUES ("AC21_37","074_21_37","ACT","21","37","37","ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠇꠦꠘ꠆ꠐꠘꠝꠦꠘ꠆ꠐꠅ ꠢꠣꠞꠣꠁ ꠖꠤꠔꠣ ꠌꠣꠁꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠞꠦ ꠁꠃꠘꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠍꠅꠀꠟ ꠇꠞꠟꠣ, “ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠔꠣꠝ ꠙꠣꠞꠝꠥ ꠘꠤ?” ꠅꠚꠤꠡꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠁꠃꠘꠣꠘꠤ ꠜꠣꠡꠣ ꠎꠣꠘ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("AC21_38","074_21_38","ACT","21","38","38","ꠔꠦ ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠢꠃ ꠝꠤꠡꠞꠤ ꠛꠦꠐꠣ ꠘꠤ, ꠎꠦꠉꠥꠄ ꠇꠄꠖꠤꠘ ꠀꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠤꠀ, ꠌꠣꠁꠞ ꠀꠎꠣꠞ ꠡꠘꠔ꠆ꠞꠣꠡꠤꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠉꠦꠍꠤꠟ?” ");
INSERT INTO syls_vpl VALUES ("AC21_39","074_21_39","ACT","21","39","39","ꠙꠣꠃꠟꠥꠍꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠍꠣꠛ, ꠀꠝꠤ ꠄꠇꠎꠘ ꠁꠢꠥꠖꠤ, ꠇꠤꠟꠤꠇꠤꠀꠞ ꠔꠣꠞ꠆ꠡ ꠡꠢꠞꠞ ꠝꠣꠘꠥꠡ, ꠀꠝꠤ ꠎꠦꠔꠣ ꠝꠘꠦ ꠇꠄ ꠁꠔꠣ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠥꠡ ꠘꠣꠄ। ꠀꠝꠤ ꠀꠙꠘꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠞꠣꠝ, ꠖꠄꠀ ꠇꠞꠤ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞꠦ ꠝꠣꠔꠣꠞ ꠡꠥꠎꠥꠉ ꠈꠣꠘ ꠖꠦꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC21_40","074_21_40","ACT","21","40","40","ꠔꠣꠁꠘ ꠡꠥꠎꠥꠉ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠍꠤꠠꠤꠞ ꠃꠙꠞꠦ ꠃꠛꠣꠁꠀ, ꠝꠣꠘꠡꠞꠦ ꠘꠤꠞꠣꠁ ꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠔꠖꠤ ꠁꠡꠣꠞꠣ ꠖꠤꠟꠣ, ꠔꠣꠞꠣ ꠘꠤꠞꠣꠁ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠇꠅꠀꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC22_1","074_22_1","ACT","22","1","1","ꠙꠣꠃꠟꠥꠍꠦ ꠇꠁꠟꠣ, “ꠅ ꠛꠣꠛꠣ ꠅꠇꠟ, ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠅꠈꠘ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠞꠣꠝ, ꠀꠙꠘꠣꠞꠣ ꠢꠥꠘꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC22_2","074_22_2","ACT","22","2","2","ꠔꠣꠁꠘ ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠞꠣ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠥꠡ ꠄꠇ꠆ꠇꠦꠞꠦ ꠘꠤꠞꠣꠁ ꠅꠁꠉꠦꠟꠣ। ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC22_3","074_22_3","ACT","22","3","3","“ꠀꠝꠤ ꠄꠇꠎꠘ ꠁꠢꠥꠖꠤ। ꠇꠤꠟꠤꠇꠤꠀꠞ ꠔꠣꠞ꠆ꠡ ꠡꠢꠞꠅ ꠀꠝꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠦ; ꠅꠁꠟꠦ ꠅꠃ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠀꠝꠤ ꠝꠣꠘꠥꠡ ꠅꠁꠍꠤ, ꠀꠟ꠆ꠟꠣꠝꠣ ꠉꠝꠟꠤꠄꠟꠞ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠁꠀ ꠀꠝꠤ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠡꠞꠤꠅꠔ ꠀꠞ ꠇꠣꠄꠖꠣ-ꠇꠣꠘꠥꠘꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍꠤ। ꠀꠞ ꠀꠁꠎ ꠀꠙꠘꠣꠞꠣ ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠅꠀꠟꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠞꠣ, ꠀꠝꠤ ꠘꠤꠎꠦꠅ ꠀꠉꠦ ꠅꠃꠟꠣ ꠀꠟ꠆ꠟꠣꠅꠀꠟꠣ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC22_4","074_22_4","ACT","22","4","4","ꠀꠝꠤ ꠁꠍꠣꠞ ꠙꠕꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘ-ꠙꠞꠣꠘ ꠡꠙꠤꠀ ꠎꠥꠟꠥꠝ ꠀꠞ ꠎꠣꠘꠦ ꠝꠣꠞꠔꠣꠝ, ꠛꠦꠐꠣꠁꠘ-ꠛꠦꠐꠤꠘꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠘꠤꠀ ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠢꠣꠞꠣꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC22_5","074_22_5","ACT","22","5","5","ꠁꠔꠣ ꠔ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠍꠣꠛ ꠀꠞ ꠖꠦꠡꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠢꠇ꠆ꠇꠟ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦꠅ ꠜꠣꠟꠣ ꠇꠞꠤ ꠎꠣꠘꠂꠘ। ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠌꠤꠑꠤ ꠟꠁꠀ, ꠖꠣꠝꠦꠡ꠆ꠇ ꠡꠢꠞꠞ ꠀꠝꠞꠣꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠍꠟꠣꠝ। ꠢꠘꠅ ꠎꠦꠞꠣ ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠔ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠤꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠘꠤꠀ ꠡꠣꠎꠣ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠢꠘꠅ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC22_6","074_22_6","ACT","22","6","6","ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ ꠖꠣꠝꠦꠡ꠆ꠇꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠛꠦꠁꠟ ꠖꠥꠁꠚꠞ ꠅꠁꠉꠦꠟ, ꠀꠈꠔꠣꠃ ꠀꠝꠣꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠀꠍꠝꠣꠘꠤ ꠚꠞ ꠌꠝꠇꠣꠁꠀ ꠃꠑꠟ। ");
INSERT INTO syls_vpl VALUES ("AC22_7","074_22_7","ACT","22","7","7","ꠀꠝꠤ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠉꠦꠟꠣꠝ ꠀꠞ ꠢꠥꠘꠟꠣꠝ, ꠀꠝꠣꠞꠦ ꠇꠦꠃ ꠒꠣꠇꠤꠀ ꠇꠁꠞꠣ, ‘ꠡꠃꠟ, ꠡꠃꠟ, ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠇꠦꠘꠦ ꠔꠇꠟꠤꠚ ꠖꠤꠞꠣꠄ?’ ");
INSERT INTO syls_vpl VALUES ("AC22_8","074_22_8","ACT","22","8","8","ꠀꠝꠤ ꠎꠤꠇꠣꠁꠟꠣꠝ, ‘ꠢꠥꠎꠥꠞ, ꠀꠙꠘꠦ ꠇꠦ?’ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠀꠝꠤ ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣ, ꠎꠦꠘꠞꠦ ꠔꠥꠝꠤ ꠔꠇꠟꠤꠚ ꠖꠤꠞꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("AC22_9","074_22_9","ACT","22","9","9","ꠎꠦꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠍꠤꠟ ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠁ ꠚꠞ ꠅꠁꠍꠦ ꠇꠞꠤ ꠖꠦꠈꠟꠣ, ꠅꠁꠟꠦ ꠎꠦꠁꠘ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠤꠟꠣ, ꠔꠣꠘ ꠛꠥꠟꠤ ꠔꠣꠞꠣ ꠢꠥꠘꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC22_10","074_22_10","ACT","22","10","10","ꠛꠣꠖꠦ ꠀꠝꠤ ꠇꠁꠟꠣꠝ, ‘ꠝꠣꠟꠤꠇ, ꠔꠦ ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ?’ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠃꠑꠅ, ꠖꠣꠝꠦꠡ꠆ꠇꠅ ꠞꠅꠀꠘꠣ ꠖꠦꠅ, ꠔꠥꠝꠣꠞ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠇꠞꠣꠞ ꠉꠞꠎ ꠀꠍꠦ, ꠁꠔꠣ ꠔꠥꠝꠣꠞꠦ ꠢꠘꠅ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠛ।’ ");
INSERT INTO syls_vpl VALUES ("AC22_11","074_22_11","ACT","22","11","11","ꠀꠞ ꠢꠤ ꠌꠝꠇꠣꠘꠤꠄ ꠀꠝꠣꠞ ꠌꠃꠈ ꠀꠘ꠆ꠖꠣ ꠅꠁꠉꠦꠍꠤꠟ ꠉꠔꠤꠇꠦ, ꠀꠝꠣꠞ ꠟꠉꠤ ꠅꠇꠟꠦ ꠀꠝꠣꠞ ꠀꠔꠅ ꠗꠞꠤꠀ ꠖꠣꠝꠦꠡ꠆ꠇꠞ ꠛꠣꠄ ꠟꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC22_12","074_22_12","ACT","22","12","12","“ꠢꠘꠅ ꠅꠘꠘꠤꠅ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ, ꠔꠣꠁꠘ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠈꠥꠛ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠣꠘꠥꠡ। ꠢꠤꠈꠣꠘꠞ ꠢꠇꠟ ꠁꠢꠥꠖꠤꠞ ꠉꠦꠍꠦ ꠔꠣꠁꠘ ꠈꠥꠛ ꠁꠎ꠆ꠎꠔꠤ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("AC22_13","074_22_13","ACT","22","13","13","ꠔꠣꠁꠘ ꠀꠁꠀ ꠀꠝꠣꠞ ꠇꠣꠍꠣꠔ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, ‘ꠜꠣꠁ ꠡꠃꠟ, ꠔꠥꠝꠣꠞ ꠖꠦꠈꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠚꠤꠞꠔ ꠀꠃꠇ।’ ꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC22_14","074_22_14","ACT","22","14","14","ꠅꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ‘ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠤ ꠎꠣꠘꠥ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠎꠣꠘꠔꠣꠄ ꠙꠣꠞ, ꠀꠞ ꠢꠃ ꠝꠣꠍꠥꠝ ꠛꠘ꠆ꠖꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦꠅ ꠖꠦꠈꠔꠣꠄ ꠙꠣꠞ, ꠀꠞ ꠔꠣꠘ ꠎꠛꠣꠘꠞ ꠛꠥꠟꠤꠅ ꠢꠥꠘꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("AC22_15","074_22_15","ACT","22","15","15","ꠔꠥꠝꠤ ꠔꠣꠘ ꠡꠣꠇ꠆ꠇꠤ ꠅꠁꠛꠣꠄ, ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠖꠦꠈꠍ ꠀꠞ ꠢꠥꠘꠍ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠣꠝꠣꠝ ꠖꠥꠘꠤꠀꠞꠦ ꠎꠣꠘꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC22_16","074_22_16","ACT","22","16","16","ꠅꠈꠘ ꠀꠞ ꠖꠦꠞꠤ ꠇꠞꠞꠣꠄ ꠇꠦꠘꠦ? ꠃꠑꠅ, ꠔꠣꠘꠦ ꠒꠣꠇꠅ, ꠀꠞ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠉꠥꠘꠣ ꠗꠁꠀ ꠚꠣꠟꠣꠅ।’ ");
INSERT INTO syls_vpl VALUES ("AC22_17","074_22_17","ACT","22","17","17","“ꠛꠣꠖꠦ ꠀꠝꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠚꠤꠞꠔ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠄꠇꠖꠤꠘ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞ ꠜꠤꠔꠞꠦ ꠖꠥꠀ ꠇꠞꠣꠔ ꠀꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠃꠋꠉꠣꠘꠤꠞ ꠢꠣꠟꠔꠅ ꠀꠈꠔꠣꠃ ꠔꠣꠘ ꠖꠞꠡꠘ ꠙꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC22_18","074_22_18","ACT","22","18","18","ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠇꠁꠞꠣ, ‘ꠎꠟꠖꠤ ꠇꠞꠤ ꠃꠑꠅ, ꠅꠈꠘꠃ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠍꠣꠠꠤꠀ ꠛꠣꠞꠅ, ꠇꠣꠞꠘ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠣꠞ ꠝꠥꠈꠞ ꠇꠥꠘꠥ ꠡꠣꠇ꠆ꠇꠤ ꠁꠘꠞ ꠝꠣꠘꠡꠦ ꠢꠥꠘꠔ ꠘꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("AC22_19","074_22_19","ACT","22","19","19","ꠀꠝꠤ ꠇꠁꠟꠣꠝ, ‘ꠝꠣꠟꠤꠇ, ꠁ ꠢꠇꠟ ꠝꠣꠘꠡꠦꠃ ꠔ ꠎꠣꠘꠂꠘ, ꠎꠦꠞꠣ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠔꠣ, ꠄꠞꠣꠞꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠘꠤ ꠀꠞ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠀꠝꠤ ꠢꠇ꠆ꠇꠟ ꠝꠍꠤꠖꠣꠁꠘ꠆ꠔꠅ ꠎꠣꠁꠔꠣꠝ; ");
INSERT INTO syls_vpl VALUES ("AC22_20","074_22_20","ACT","22","20","20","ꠔꠥꠝꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠡ꠆ꠔꠤꠚꠣꠘꠞꠦ ꠎꠦꠛꠟꠣ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ, ꠢꠤ ꠡꠝꠄ ꠀꠝꠤ ꠘꠤꠎꠦ ꠢꠤꠈꠣꠘꠅ ꠃꠛꠣꠁꠀ ꠡꠣꠄ ꠖꠦꠅꠀꠔ ꠀꠍꠟꠣꠝ, ꠀꠞ ꠎꠦꠞꠣ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠍꠤꠟ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠙꠣꠞꠣ ꠖꠤꠍꠟꠣꠝ।’ ");
INSERT INTO syls_vpl VALUES ("AC22_21","074_22_21","ACT","22","21","21","ꠔꠦꠃ ꠝꠣꠟꠤꠇꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, ‘ꠔꠥꠝꠤ ꠞꠅꠀꠘꠣ ꠖꠦꠅ, ꠀꠝꠤ ꠖꠥꠞꠁꠞ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠣꠞꠦ ꠛꠦꠎꠤꠝꠥ।’ ” ");
INSERT INTO syls_vpl VALUES ("AC22_22","074_22_22","ACT","22","22","22","ꠝꠣꠘꠡꠦ ꠅꠔ ꠡꠝꠄ ꠗꠞꠤ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠣꠔ ꠀꠍꠟꠣ, ꠛꠣꠖꠦ ꠅ-ꠁꠢꠥꠖꠤꠞ ꠘꠣꠝ ꠢꠥꠘꠤꠀꠃ ꠔꠣꠞꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅꠉꠥꠞꠦ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠢꠞꠣꠁ ꠖꠦꠅ, ꠁꠉꠥ ꠛꠣꠌꠤꠀ ꠞꠅꠀꠞ ꠎꠥꠇꠣ ꠘꠣꠄ!” ");
INSERT INTO syls_vpl VALUES ("AC22_23","074_22_23","ACT","22","23","23","ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠌꠤꠟ꠆ꠟꠣꠘꠤ ꠗꠞꠟꠣ ꠀꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠣꠟꠣꠁꠀ, ꠀꠍꠝꠣꠘꠅ ꠗꠥꠁꠟ ꠃꠠꠣꠘꠤꠔ ꠟꠣꠉꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC22_24","074_22_24","ACT","22","24","24","ꠅꠃ ꠡꠝꠄ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠇꠦꠘ꠆ꠐꠘꠝꠦꠘ꠆ꠐꠅ ꠟꠁꠀ ꠎꠣꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠀꠞ ꠇꠁꠟꠣ, “ꠄꠞꠦ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠤꠀ ꠎꠦꠞꠣ ꠇꠞꠅ, ꠇꠦꠘꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠁꠟꠣ ꠌꠤꠟ꠆ꠟꠣ-ꠌꠤꠟ꠆ꠟꠤ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC22_25","074_22_25","ACT","22","25","25","ꠙꠣꠃꠟꠥꠍꠞꠦ ꠎꠦꠛꠟꠣ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠣꠘ꠆ꠖꠤꠟꠣ, ꠁ ꠡꠝꠄ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠄꠇ ꠍꠥꠛꠦꠖꠣꠞ ꠢꠤꠈꠣꠘꠅ ꠃꠛꠣꠔ ꠀꠍꠟꠣ, ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅꠈꠘꠅ ꠎꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠁꠟꠣ ꠄꠇꠎꠘ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠌꠣꠛꠥꠇ ꠝꠣꠞꠣ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠅꠞ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC22_26","074_22_26","ACT","22","26","26","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠢꠤ ꠍꠥꠛꠦꠖꠣꠞꠦ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠞꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠍꠣꠞ, ꠀꠙꠘꠦ ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠍꠂꠘ? ꠁ ꠛꠦꠐꠣ ꠔ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠥꠡ।” ");
INSERT INTO syls_vpl VALUES ("AC22_27","074_22_27","ACT","22","27","27","ꠔꠦꠃ ꠔꠣꠁꠘ ꠙꠣꠃꠟꠥꠍꠞ ꠗꠣꠞꠅ ꠉꠤꠀ ꠎꠤꠇꠣꠁꠟꠣ, “ꠇꠅ ꠌꠣꠁꠘ, ꠔꠥꠝꠤ ꠞꠥꠝꠣꠘ ꠘꠤ?” ꠙꠣꠃꠟꠥꠍꠦ ꠇꠁꠟꠣ, “ꠎꠤꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC22_28","074_22_28","ACT","22","28","28","ꠅꠚꠤꠡꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠛꠃꠔ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠈꠞꠌ ꠇꠞꠤꠀ ꠞꠥꠝꠣꠘ ꠍꠤꠐꠤꠎꠦꠘ ꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠟꠁꠍꠤ।” ꠙꠣꠃꠟꠥꠍꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠎꠘꠝ ꠡꠥꠔ꠆ꠞꠦꠃ ꠞꠥꠝꠣꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC22_29","074_22_29","ACT","22","29","29","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀꠃ ꠎꠦ ꠍꠤꠙꠣꠁꠄ ꠔꠣꠘꠞꠦ ꠎꠦꠞꠣ ꠇꠞꠣꠔ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣ, ꠟꠉꠦ ꠟꠉꠦꠃ ꠔꠣꠞꠣ ꠢꠘ ꠕꠘꠦ ꠢꠞꠤꠀ ꠉꠦꠟꠣꠉꠤ। ꠀꠞ ꠔꠣꠁꠘ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠦꠅ ꠔꠣꠘꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠍꠟꠣ ꠇꠞꠤ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠦꠅ ꠒꠞꠣꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC22_30","074_22_30","ACT","22","30","30","ꠅꠁꠟꠦ ꠛꠣꠖꠞ ꠖꠤꠘ ꠢꠤꠞꠛꠣꠞ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠎꠤꠇꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ, ꠇꠤꠔꠣꠞ ꠟꠣꠉꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠔꠣꠘꠞꠦ ꠖꠥꠡ ꠖꠤꠞꠣ, ꠔꠦꠃ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠦ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠣꠘ꠆ꠖ ꠈꠥꠟꠤ ꠖꠤꠟꠣ, ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟ ꠀꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠢꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠟꠣꠝꠣꠁꠀ ꠔꠣꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_1","074_23_1","ACT","23","1","1","ꠙꠣꠃꠟꠥꠍꠦ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠝꠣꠘꠡꠞ ꠛꠣꠄ ꠗꠤꠀꠘ ꠗꠞꠤ ꠌꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅ ꠜꠣꠁꠍꠣꠛ ꠅꠇꠟ, ꠀꠝꠤ ꠔ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠣꠞ ꠛꠤꠛꠦꠇ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠞꠣꠈꠤꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠢꠤꠡꠣꠛꠦ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠇꠞꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("AC23_2","074_23_2","ACT","23","2","2","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠘꠘꠤꠅꠄ, ꠙꠣꠃꠟꠥꠍꠞ ꠉꠣꠟꠣꠔ ꠎꠦꠞꠣ ꠃꠛꠣꠔ ꠀꠍꠤꠟ, ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠉꠥꠞ ꠝꠥꠈꠅ ꠌꠠ ꠝꠣꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("AC23_3","074_23_3","ACT","23","3","3","ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠜꠘ꠆ꠒ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦꠅ ꠌꠠ ꠝꠣꠞꠛꠣ। ꠔꠥꠝꠤ ꠡꠞꠤꠅꠔꠞ ꠀꠁꠘꠦ ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠔ ꠛꠁꠀ, ꠡꠞꠤꠅꠔꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠌꠠ ꠝꠣꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("AC23_4","074_23_4","ACT","23","4","4","ꠎꠦꠞꠣ ꠙꠣꠃꠟꠥꠍꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠃꠛꠣꠁꠍꠤꠟ, ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠇꠁꠟ, “ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠍꠣꠛꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠞꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC23_5","074_23_5","ACT","23","5","5","ꠙꠣꠃꠟꠥꠍꠦ ꠇꠁꠟꠣ, “ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ ꠘꠣ ꠄꠁꠘ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠇꠞꠤ। ꠀꠞꠘꠣꠄ ꠁꠟꠣ ꠇꠁꠟꠣꠝ ꠘꠣ ꠅꠘꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠔ ꠟꠦꠈꠣ ꠀꠍꠦ, ‘ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠇꠥꠘꠥ ꠉꠣꠟꠤ ꠖꠤꠅ ꠘꠣ।’ ” ");
INSERT INTO syls_vpl VALUES ("AC23_6","074_23_6","ACT","23","6","6","ꠙꠣꠃꠟꠥꠍꠦ ꠎꠦꠛꠟꠣ ꠛꠥꠎꠟꠣ ꠢꠤ ꠝꠎꠟꠤꠍꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠝꠎꠛꠞ ꠀꠞ ꠇꠤꠍꠥ ꠅꠁꠟꠣ ꠚꠞꠤꠡꠤ ꠝꠎꠛꠞ, ꠅꠃ ꠔꠣꠁꠘ ꠝꠎꠟꠤꠍꠞ ꠝꠣꠎꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠄꠇꠎꠘ ꠚꠞꠤꠡꠤ ꠀꠞ ꠚꠞꠤꠡꠤꠞ ꠀꠅꠟꠣꠖ। ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ, ꠅꠃ ꠝꠣꠔꠞ ꠟꠣꠉꠤ ꠅꠈꠘ ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣ ꠅꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC23_7","074_23_7","ACT","23","7","7","ꠔꠣꠁꠘ ꠁꠈꠣꠘ ꠇꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠚꠞꠤꠡꠤ ꠀꠞ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠇꠣꠁꠎ꠆ꠎꠣ ꠟꠣꠉꠤꠉꠦꠟ, ꠝꠎꠟꠤꠍꠞ ꠝꠣꠎꠦ ꠖꠥꠁ ꠖꠟ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_8","074_23_8","ACT","23","8","8","ꠇꠣꠞꠘ ꠍꠤꠖ꠆ꠖꠦꠇꠤꠀ ꠅꠇꠟꠞ ꠄꠇꠤꠘ ꠅꠁꠟ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠔꠣ ꠘꠣꠄ, ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠣ ꠞꠥꠢꠥ ꠁꠔꠣ ꠇꠥꠘꠥꠔꠣ ꠘꠣꠁ। ꠅꠁꠟꠦ ꠚꠞꠤꠡꠤ ꠅꠇꠟꠦ ꠄꠇꠤꠘ ꠇꠞꠂꠘ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC23_9","074_23_9","ACT","23","9","9","ꠁ ꠉꠘ꠆ꠒꠉꠥꠟ ꠛꠃꠔ ꠛꠠ ꠅꠁꠉꠦꠟ, ꠔꠦꠃ ꠚꠞꠤꠡꠤ ꠖꠟꠞ ꠇꠄꠎꠘ ꠝꠃꠟꠣꠘꠣꠄ ꠃꠛꠣꠁꠀ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠁ ꠝꠣꠘꠡꠞ ꠇꠥꠘꠥ ꠖꠥꠡ ꠖꠦꠈꠞꠣꠝ ꠘꠣ। ꠇꠥꠘꠥ ꠞꠥꠢꠥ ꠛꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔ ꠔꠣꠞ ꠟꠉꠦ ꠁꠟꠣ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC23_10","074_23_10","ACT","23","10","10","ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠛꠦꠕꠣꠄꠀ ꠉꠘ꠆ꠒꠉꠥꠟ ꠟꠣꠉꠟ, ꠄꠞꠖꠣꠄ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠦ ꠒꠞꠣꠁꠉꠦꠟꠣ, ꠝꠣꠘꠡꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤ ꠍꠤꠠꠤꠟꠣꠁꠛꠣ, ꠅꠃ ꠔꠣꠁꠘ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠔꠣꠞꠣ ꠟꠣꠝꠤꠀ ꠉꠤꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠘꠤꠀ ꠇꠦꠘ꠆ꠐꠘꠝꠦꠘ꠆ꠐꠅ ꠢꠣꠞꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_11","074_23_11","ACT","23","11","11","ꠛꠣꠖꠦ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠙꠣꠃꠟꠥꠍꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠅ, ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠎꠦꠟꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍ, ꠞꠥꠝ ꠐꠣꠃꠘꠅ-ꠅ ꠅꠃꠟꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC23_12","074_23_12","ACT","23","12","12","ꠛꠣꠖꠞ ꠖꠤꠘ ꠚꠎꠞꠞ ꠅꠇ꠆ꠔꠅ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠄꠇ ꠖꠣꠉꠣꠛꠣꠎꠤ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠟꠣ, ꠙꠣꠃꠟꠥꠍꠞꠦ ꠝꠣꠞꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠣ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ ꠇꠥꠘ꠆ꠔꠣ ꠝꠥꠈꠅ ꠖꠤꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC23_13","074_23_13","ACT","23","13","13","ꠌꠣꠟ꠆ꠟꠤꠡ ꠎꠘꠞꠅ ꠛꠦꠡꠤ ꠝꠣꠘꠥꠡ ꠄꠇꠈꠣꠘꠅ ꠅꠁꠀ ꠁ ꠖꠣꠉꠣꠛꠣꠎꠤꠞ ꠇꠍꠝ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_14","074_23_14","ACT","23","14","14","ꠔꠣꠞꠣ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠇꠠꠣꠇꠠꠤ ꠇꠍꠝ ꠈꠣꠁꠍꠤ, ꠙꠣꠃꠟꠥꠍꠞꠦ ꠘꠣ ꠝꠣꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ ꠇꠥꠘ꠆ꠔꠣ ꠝꠥꠈꠅ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC23_15","074_23_15","ACT","23","15","15","ꠅꠈꠘ ꠀꠙꠘꠣꠞꠣ ꠀꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠢꠇꠟꠦ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠞ ꠉꠦꠍꠦ ꠅꠃ ꠀꠛꠖꠣꠞ ꠇꠞꠃꠇ꠆ꠇꠣ ꠎꠦꠘ, ꠀꠙꠘꠣꠞꠣ ꠀꠞꠅ ꠜꠣꠟꠣꠐꠤꠇꠦ ꠁ ꠛꠤꠌꠣꠞꠞ ꠔꠖꠘ꠆ꠔ ꠇꠞꠔꠣ ꠌꠣꠁꠞꠣ, ꠅꠃ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠢꠦ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠀꠅꠀꠞ ꠀꠉꠦꠃ, ꠙꠕꠞ ꠝꠣꠎꠦ ꠀꠝꠞꠣ ꠔꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("AC23_16","074_23_16","ACT","23","16","16","ꠅꠁꠟꠦ ꠙꠣꠃꠟꠥꠍꠞ ꠜꠣꠉꠘꠣꠄ ꠔꠣꠞꠣꠞ ꠁ ꠖꠣꠉꠣꠛꠣꠎꠤꠞ ꠈꠛꠞ ꠢꠥꠘꠤꠀ, ꠇꠦꠘ꠆ꠐꠘꠝꠦꠘ꠆ꠐꠅ ꠉꠤꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠁꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_17","074_23_17","ACT","23","17","17","ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠄꠇꠎꠘ ꠍꠥꠛꠦꠖꠣꠞꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠅꠃ ꠙꠥꠀꠉꠥꠞꠦ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞ ꠍꠣꠛꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠎꠣꠃꠇ꠆ꠇꠣ, ꠢꠦ ꠔꠣꠘꠞꠦ ꠇꠤꠔꠣ ꠇꠁꠔ ꠀꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("AC23_18","074_23_18","ACT","23","18","18","ꠅꠃ ꠢꠤ ꠍꠥꠛꠦꠖꠣꠞꠦ ꠔꠣꠞꠦ ꠟꠁꠀ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠛꠘ꠆ꠖꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠀꠝꠣꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, ꠅꠃ ꠙꠥꠀꠉꠥꠞꠦ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠀꠁꠔꠣꠝ, ꠢꠦ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠇꠤꠔꠣ ꠇꠁꠔ ꠌꠣꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC23_19","074_23_19","ACT","23","19","19","ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠦ ꠔꠣꠞ ꠀꠔꠅ ꠗꠞꠤꠀ ꠄꠇ ꠉꠣꠟꠣꠛꠣꠄ ꠟꠁꠀ ꠉꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("AC23_20","074_23_20","ACT","23","20","20","ꠢꠦ ꠇꠁꠟ, “ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠘꠤꠅꠔ ꠇꠞꠍꠂꠘ, ꠔꠣꠞꠣ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠀꠛꠖꠣꠞ ꠇꠞꠛꠣ, ꠙꠣꠃꠟꠥꠍꠞ ꠛꠤꠌꠣꠞ ꠀꠞꠅ ꠜꠣꠟꠣꠐꠤꠇꠦ ꠔꠖꠘ꠆ꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠙꠘꠦ ꠎꠣꠘꠥ ꠍꠣꠝꠘꠞ ꠇꠣꠁꠟ ꠔꠣꠘꠞꠦ ꠖꠦꠡꠞ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("AC23_21","074_23_21","ACT","23","21","21","ꠀꠙꠘꠦ ꠔꠣꠞꠣꠞ ꠇꠕꠣꠄ ꠞꠣꠎꠤ ꠅꠁꠘ ꠘꠣ ꠎꠣꠘꠥ, ꠄꠞꠣ ꠌꠣꠟ꠆ꠟꠤꠡ ꠎꠘꠞꠅ ꠛꠦꠡꠤ ꠝꠣꠘꠡꠦ ꠟꠥꠇꠣꠁꠀ ꠙꠣꠃꠟꠥꠍꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠞꠣ, ꠔꠣꠞꠣ ꠇꠍꠝ ꠈꠣꠁꠍꠦ, ꠔꠣꠘꠞꠦ ꠘꠣ ꠝꠣꠞꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ ꠇꠥꠘ꠆ꠔꠣ ꠝꠥꠈꠅ ꠖꠤꠔ ꠘꠣꠄ। ꠔꠣꠞꠣ ꠅꠈꠘ ꠔꠤꠀꠞ ꠅꠁꠀ ꠙꠕꠅ ꠛꠁꠍꠦ, ꠈꠣꠟꠤ ꠀꠙꠘꠣꠞ ꠞꠣꠎꠤ ꠅꠀꠞ ꠛꠣꠞ ꠌꠣꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC23_22","074_23_22","ACT","23","22","22","ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠦ ꠔꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠀ ꠛꠤꠖꠣꠄ ꠖꠤꠟꠣ, “ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠁ ꠈꠛꠞ ꠇꠁꠍ ꠇꠞꠤ ꠇꠦꠃꠞꠞꠦ ꠢꠥꠘꠣꠁꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC23_23","074_23_23","ACT","23","23","23","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠖꠥꠁꠎꠘ ꠍꠥꠛꠦꠖꠣꠞꠞꠦ ꠀꠘꠣꠁꠀ ꠇꠁꠟꠣ, “ꠖꠥꠁ-ꠡ ꠎꠘ ꠍꠤꠙꠣꠁ, ꠡꠔ꠆ꠔꠁꠞ ꠎꠘ ꠊꠥꠠꠣꠀꠟꠣ ꠍꠤꠙꠣꠁ, ꠀꠞ ꠖꠥꠁ-ꠡ ꠎꠘ ꠍꠥꠟꠚꠤ ꠀꠟꠣ ꠍꠤꠙꠣꠁ ꠀꠁꠎ ꠞꠣꠁꠔ ꠘꠄꠐꠣꠔ ꠇꠂꠍꠞꠤꠀꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠤꠀꠞ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("AC23_24","074_23_24","ACT","23","24","24","ꠀꠞ ꠙꠣꠃꠟꠥꠍꠞ ꠟꠣꠉꠤꠅ ꠊꠥꠠꠣꠞ ꠛꠘ꠆ꠖꠛꠡ꠆ꠔ ꠇꠞꠅ, ꠔꠣꠞꠦ ꠎꠣꠘꠥ ꠘꠤꠞꠣꠙꠖꠦ ꠖꠦꠡꠞ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ ꠚꠤꠟꠤꠇ꠆ꠡꠞ ꠉꠦꠍꠦ ꠙꠃꠍꠣꠁꠟ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC23_25","074_23_25","ACT","23","25","25","ꠇꠁꠀ, ꠔꠣꠁꠘ ꠅꠃ ꠌꠤꠑꠤ ꠟꠦꠈꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC23_26","074_23_26","ACT","23","26","26","“ꠝꠣꠘꠘꠤꠅ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ ꠍꠣꠛ, ꠀꠝꠤ ꠇꠦꠟꠣꠖꠥꠍ ꠟꠥꠍꠤꠀꠍ, ꠀꠙꠘꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC23_27","074_23_27","ACT","23","27","27","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠅꠃ ꠝꠣꠘꠥꠡꠉꠥꠞꠦ ꠗꠞꠤꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠌꠣꠁꠍꠟꠣ, ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ ꠢꠦ ꠄꠇꠎꠘ ꠞꠥꠝꠣꠘ ꠝꠣꠘꠥꠡ, ꠢꠥꠘꠤꠀ ꠀꠝꠣꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟ ꠟꠁꠀ ꠉꠤꠀ ꠔꠣꠞꠦ ꠛꠣꠌꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC23_28","074_23_28","ACT","23","28","28","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠥꠘꠔꠣꠝ ꠌꠣꠁꠟꠣꠝ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠇꠤꠔꠣ ꠖꠥꠡ ꠙꠣꠁꠍꠂꠘ, ꠄꠞꠖꠣꠄ ꠔꠣꠞꠦ ꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠝꠎꠟꠤꠍꠅ ꠀꠎꠤꠞ ꠇꠞꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC23_29","074_23_29","ACT","23","29","29","ꠔꠦꠃ ꠀꠝꠤ ꠛꠥꠎꠟꠣꠝ, ꠔꠣꠞꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠇꠥꠘꠥ ꠚꠔꠥꠀꠞ ꠟꠣꠉꠤ ꠄꠞ ꠃꠙꠞꠦ ꠖꠥꠡ ꠖꠤꠞꠣ, ꠅꠁꠟꠦ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠘꠤ ꠛꠣ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠎꠥꠇꠣ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠙꠣꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_30","074_23_30","ACT","23","30","30","ꠀꠞ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠔꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠖꠣꠉꠣꠛꠣꠎꠤ ꠇꠞꠣ ꠅꠞ, ꠔꠦꠃ ꠎꠟꠖꠤ ꠇꠞꠤ ꠔꠣꠞꠦ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣꠝ। ꠔꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠦꠞꠣ ꠘꠣꠟꠤꠡ ꠖꠤꠍꠦ, ꠔꠣꠞꠣꠞꠦꠅ ꠇꠁꠍꠤ, ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠕꠣꠇꠟꠦ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠢꠥꠘꠣꠁꠔꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC23_31","074_23_31","ACT","23","31","31","ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠟꠁꠀ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣ ꠀꠘ꠆ꠔꠤꠙꠣꠔ꠆ꠞꠤ ꠐꠣꠃꠘꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_32","074_23_32","ACT","23","32","32","ꠛꠣꠖꠞ ꠖꠤꠘ ꠊꠥꠠꠣꠀꠟꠣ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞ ꠟꠉꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠛꠤꠖꠣꠄ ꠖꠤꠀ ꠛꠣꠇꠤ ꠍꠤꠙꠣꠁ ꠅꠇꠟ ꠇꠦꠘ꠆ꠐꠘꠝꠦꠘ꠆ꠐꠅ ꠊꠥꠞꠤꠀ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_33","074_23_33","ACT","23","33","33","ꠊꠥꠠꠣꠀꠟꠣ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠌꠤꠑꠤ ꠀꠞ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠟꠁꠀ ꠇꠂꠍꠞꠤꠀꠔ ꠙꠃꠍꠤꠀ ꠢꠣꠞꠟꠦ ꠖꠦꠡꠞ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC23_34","074_23_34","ACT","23","34","34","ꠔꠣꠁꠘ ꠁ ꠌꠤꠑꠤ ꠙꠠꠤꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠥꠘ ꠖꠦꠡꠞ ꠝꠣꠘꠥꠡ?” ꠙꠣꠃꠟꠥꠍ ꠇꠤꠟꠤꠇꠤꠀꠞ ꠝꠣꠘꠥꠡ ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC23_35","074_23_35","ACT","23","35","35","“ꠔꠥꠝꠣꠞꠦ ꠎꠦꠞꠣ ꠖꠥꠡꠦꠞ ꠔꠣꠞꠣ ꠁꠈꠣꠘꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠢꠥꠘꠝꠥ।” ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠙꠣꠃꠟꠥꠍꠞꠦ ꠘꠤꠀ ꠞꠣꠎꠣ ꠢꠦꠞꠥꠖꠞ ꠛꠣꠠꠤꠞ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC24_1","074_24_1","ACT","24","1","1","ꠙꠣꠌ ꠖꠤꠘ ꠛꠣꠖꠦ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠘꠘꠤꠅꠄ ꠇꠄꠎꠘ ꠁꠢꠥꠖꠤ ꠝꠥꠞꠛ꠆ꠛꠤ ꠀꠞ ꠔꠞ꠆ꠔꠥꠟ꠆ꠟ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠃꠇꠤꠟꠞꠦ ꠟꠁꠀ ꠇꠂꠍꠞꠤꠀꠔ ꠉꠦꠟꠣ, ꠉꠤꠀ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝꠞ ꠀꠖꠣꠟꠔꠅ ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠘꠣꠟꠤꠡ ꠖꠣꠈꠤꠟ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC24_2","074_24_2","ACT","24","2","2","ꠙꠣꠃꠟꠥꠍꠞꠦ ꠀꠘꠤꠀ ꠀꠖꠣꠟꠔꠅ ꠀꠎꠤꠞ ꠇꠞꠣ ꠅꠁꠟ। ꠛꠣꠖꠦ ꠃꠇꠤꠟ ꠔꠞ꠆ꠔꠥꠟ꠆ꠟꠄ ꠅꠃ ꠘꠣꠟꠤꠡ ꠉꠣꠁꠟꠣ, “ꠝꠣꠘꠘꠤꠅ ꠢꠣꠇꠤꠝ ꠍꠣꠛ, ꠀꠙꠘꠣꠞ ꠡꠣꠡꠘꠅ ꠞꠁꠀ ꠀꠝꠞꠣ ꠛꠃꠔ ꠖꠤꠘ ꠕꠣꠇꠤ ꠛꠠ ꠡꠣꠘ꠆ꠔꠤꠄ ꠀꠍꠤ। ꠀꠙꠘꠦ ꠀꠙꠘꠣꠞ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠖꠤꠀ ꠁ ꠎꠣꠔꠤꠞ ꠛꠃꠔ ꠜꠣꠟꠣꠁ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC24_3","074_24_3","ACT","24","3","3","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠀꠙꠘꠣꠞ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("AC24_4","074_24_4","ACT","24","4","4","ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠝꠥꠟ꠆ꠟꠛꠣꠘ ꠡꠝꠄ ꠘꠡ꠆ꠐ ꠇꠞꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ ꠘꠣ, ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠢꠥꠘꠟꠦ, ꠀꠝꠞꠣꠞ ꠘꠣꠟꠤꠡ ꠈꠣꠘ ꠖꠥꠁ-ꠌꠣꠁꠞ ꠇꠕꠣꠄ ꠇꠁꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("AC24_5","074_24_5","ACT","24","5","5","ꠍꠣꠛ, ꠀꠝꠞꠣ ꠖꠦꠈꠍꠤ, ꠅꠃ ꠝꠣꠘꠥꠡꠉꠥ ꠛꠠ ꠄꠇ ꠀꠙꠖ ꠅꠁꠀ ꠀꠎꠤꠍꠦ। ꠢꠦ ꠘꠣꠍꠣꠞꠣ ꠘꠣꠝꠞ ꠄꠇ ꠛꠤꠗꠞ꠆ꠝꠤ ꠖꠟꠞ ꠃꠡ꠆ꠔꠣꠖ। ꠢꠣꠝꠦꠡꠣ ꠈꠣꠟꠤ ꠢꠣꠋꠉꠣꠝꠣ ꠟꠣꠉꠣꠄ, ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠁꠢꠥꠖꠤꠞ ꠝꠣꠎꠦ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠣꠘꠤꠃ ꠔꠣꠞ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC24_6","074_24_6","ACT","24","6","7","ꠢꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠞꠦꠅ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠔ ꠌꠣꠁꠍꠤꠟ, ꠄꠞꠖꠣꠄ ꠀꠝꠞꠣ ꠔꠣꠞꠦ ꠀꠐꠇ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC24_8","074_24_8","ACT","24","8","8","ꠀꠞ ꠅꠃ ꠎꠦꠔꠣ ꠘꠣꠟꠤꠡ ꠖꠤꠟꠣꠝ, ꠀꠙꠘꠦ ꠘꠤꠎꠦ ꠔꠣꠞꠦ ꠎꠦꠞꠣ ꠇꠞꠟꠦꠃ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠣꠞ ꠅꠁꠎꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC24_9","074_24_9","ACT","24","9","9","ꠃꠇꠤꠟꠞ ꠟꠉꠦ ꠅꠁꠀ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦꠅ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠢꠣꠍꠣ ꠇꠁꠀ ꠡꠣꠄ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC24_10","074_24_10","ACT","24","10","10","ꠔꠦꠃ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ ꠍꠣꠛꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠁꠡꠣꠞꠣ ꠖꠤꠟꠣ, ꠙꠣꠃꠟꠥꠍꠦ ꠇꠁꠟꠣ, “ꠍꠣꠛ, ꠀꠙꠘꠦ ꠛꠃꠔ ꠛꠞꠍ ꠗꠞꠤ ꠁ ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠀ ꠀꠁꠞꠣ, ꠁꠐꠣ ꠢꠥꠘꠤꠀ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀ ꠀꠝꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC24_11","074_24_11","ACT","24","11","11","ꠀꠙꠘꠦ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠟꠦꠃ ꠎꠣꠘꠤꠟꠤꠛꠣ, ꠅꠈꠘꠅ ꠛꠣꠞꠅ ꠖꠤꠘ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠝꠤ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠦꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC24_12","074_24_12","ACT","24","12","12","ꠅꠃ ꠎꠦꠞꠣ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠞꠣ, ꠔꠣꠞꠣ ꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠢꠣꠋꠉꠣꠝꠣ ꠇꠞꠣꠔ ꠖꠦꠈꠍꠂꠘ ꠘꠣ। ꠐꠣꠃꠘꠞ ꠇꠥꠘꠥꠈꠣꠘꠅ ꠛꠣ ꠇꠥꠘꠥ ꠝꠍꠤꠖꠅ-ꠅ ꠝꠣꠘꠡꠞꠦ ꠃꠍꠇꠣꠁꠀ ꠖꠦꠅꠀꠔ ꠀꠝꠣꠞꠦ ꠙꠣꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC24_13","074_24_13","ACT","24","13","13","ꠅꠈꠘ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠎꠦꠔꠣ ꠖꠥꠡ ꠖꠦꠈꠣꠁꠞꠣ, ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠙꠞꠝꠣꠘꠅ ꠔꠣꠞꠣ ꠖꠤꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC24_14","074_24_14","ACT","24","14","14","ꠅꠁꠟꠦ ꠀꠝꠤ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠞꠣꠝ, ꠄꠞꠣ ꠎꠦꠇꠐꠣꠞꠦ ꠛꠤꠗꠞ꠆ꠝꠤ ꠖꠟ ꠇꠁꠞꠣ, ꠢꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠄ ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠤ। ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠔꠣꠝꠣꠝ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠤꠔꠣꠛꠞꠦ ꠀꠝꠤ ꠄꠇꠤꠘ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("AC24_15","074_24_15","ACT","24","15","15","ꠀꠞ ꠄꠞꠣ ꠎꠦꠟꠣꠘ ꠄꠇꠤꠘ ꠇꠞꠂꠘ, ꠀꠝꠤꠅ ꠅꠃꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠤ, ꠙꠞꠦꠎꠉꠣꠞ ꠛꠣ ꠉꠥꠘꠣꠉꠣꠞ ꠢꠇꠟꠞꠦꠃ ꠝꠞꠣꠞ ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("AC24_16","074_24_16","ACT","24","16","16","ꠄꠞꠖꠣꠄ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠀꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦꠅ ꠢꠣꠝꠦꠡꠣ ꠀꠝꠣꠞ ꠛꠤꠛꠦꠇ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠞꠣꠈꠔꠣꠝ ꠌꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("AC24_17","074_24_17","ACT","24","17","17","ꠛꠃꠔ ꠛꠞꠍ ꠛꠣꠖꠦ ꠀꠝꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠦꠍꠟꠣꠝ, ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠣꠝ ꠀꠞ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠛꠤꠟꠣꠁꠔꠣꠝ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("AC24_18","074_24_18","ACT","24","18","18","ꠔꠦ ꠀꠝꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠀ ꠎꠦꠛꠟꠣ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠢꠣꠝꠣꠁꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠍꠂꠘ। ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘꠥ ꠜꠤꠠꠅ ꠅꠁꠍꠦ ꠘꠣ, ꠛꠣ ꠇꠥꠘꠥ ꠉꠘ꠆ꠒꠉꠥꠟꠅ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC24_19","074_24_19","ACT","24","19","19","ꠈꠣꠟꠤ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠇꠄꠎꠘ ꠁꠢꠥꠖꠤ ꠢꠘꠅ ꠀꠍꠟꠣ। ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠕꠣꠇꠟꠦ ꠢꠃ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠘꠣꠟꠤꠡ ꠖꠤꠔꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC24_20","074_24_20","ACT","24","20","20","ꠀꠞꠘꠣꠄ ꠅꠘꠅ ꠎꠦꠞꠣ ꠀꠁꠍꠂꠘ ꠄꠞꠣꠃ ꠇꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠚꠔꠥꠀ ꠇꠝꠤꠐꠤꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠇꠤꠔꠣ ꠖꠥꠡ ꠙꠣꠁꠍꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("AC24_21","074_24_21","ACT","24","21","21","ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣ, ꠈꠣꠟꠤ ꠄꠇꠈꠣꠘ ꠝꠣꠔ ꠀꠝꠤ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠝꠣꠔꠤꠍꠟꠣꠝ ꠎꠦꠘ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠞ ꠝꠥꠍꠟꠣ ꠟꠁꠀ ꠀꠁꠎ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣ ꠅꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC24_22","074_24_22","ACT","24","22","22","ꠢꠣꠇꠤꠝ ꠚꠤꠟꠤꠇ꠆ꠡꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠞꠤ ꠎꠣꠘꠔꠣ, ꠄꠞꠖꠣꠄ ꠔꠣꠁꠘ ꠛꠤꠌꠣꠞ ꠛꠘ꠆ꠖ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠍꠤꠙꠣꠁꠞ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞ ꠟꠥꠍꠤꠀꠍ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠌꠣꠞꠞ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("AC24_23","074_24_23","ACT","24","23","23","ꠔꠣꠁꠘ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠍꠥꠛꠦꠖꠣꠞꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, “ꠙꠣꠃꠟꠥꠍꠞꠦ ꠀꠐꠇ ꠞꠣꠈꠅ, ꠅꠁꠟꠦ ꠔꠣꠞꠦ ꠝꠣꠄꠀꠞ ꠘꠎꠞꠦ ꠞꠣꠈꠤꠅ, ꠔꠣꠞ ꠈꠦꠡ-ꠇꠥꠐꠥꠝꠦ ꠔꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠣꠔ ꠀꠁꠟꠦ ꠛꠣꠗꠣ ꠖꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC24_24","074_24_24","ACT","24","24","24","ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠚꠤꠟꠤꠇ꠆ꠡꠦ ꠔꠣꠘ ꠁꠢꠥꠖꠤ ꠛꠃ ꠖ꠆ꠞꠥꠡꠤꠟ꠆ꠟꠣꠞꠦ ꠟꠉꠦ ꠟꠁꠀ ꠀꠁꠀ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠈꠛꠞꠖꠤ ꠀꠘꠣꠁꠟꠣ, ꠀꠞ ꠙꠣꠃꠟꠥꠍꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠞ ꠛꠄꠀꠘꠤ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC24_25","074_24_25","ACT","24","25","25","ꠙꠣꠃꠟꠥꠍꠦ ꠎꠦꠛꠟꠣ ꠢꠇ ꠙꠕꠦ ꠌꠟꠣ, ꠘꠤꠎꠞꠦ ꠖꠝꠣꠁꠀ ꠞꠣꠈꠣ, ꠀꠞ ꠢꠣꠡꠞꠞ ꠛꠤꠌꠣꠞꠞ ꠇꠕꠣ ꠛꠄꠀꠘ ꠇꠞꠟꠣ, ꠚꠤꠟꠤꠇ꠆ꠡꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠒꠞꠣꠁꠉꠦꠟꠣ। ꠒꠞꠣꠁꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠅꠈꠘ ꠎꠣꠅꠉꠤ, ꠡꠝꠄ ꠡꠥꠎꠥꠉ ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠈꠛꠞꠖꠤ ꠀꠘꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("AC24_26","074_24_26","ACT","24","26","26","ꠔꠣꠘ ꠝꠘꠦ ꠝꠘꠦ ꠀꠍꠤꠟ, ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠘꠞꠦ ꠇꠤꠍꠥ ꠊꠥꠡ ꠖꠤꠛꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠀꠘꠣꠁꠀ ꠉꠚ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC24_27","074_24_27","ACT","24","27","27","ꠖꠥꠁ ꠛꠞꠍ ꠙꠣꠞꠘꠤꠞ ꠛꠣꠖꠦ ꠙꠞ꠆ꠇꠤꠅ ꠚꠤꠡ꠆ꠔꠍ ꠀꠁꠀ ꠚꠤꠟꠤꠇ꠆ꠡꠞ ꠉꠖꠤꠔ ꠛꠁꠟꠣ। ꠚꠤꠟꠤꠇ꠆ꠡꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠔꠣ ꠇꠞꠤ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠎꠦꠟꠅ ꠕꠁꠀ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC25_1","074_25_1","ACT","25","1","1","ꠁ ꠖꠦꠡꠅ ꠀꠅꠀꠞ ꠔꠤꠘ ꠖꠤꠘ ꠛꠣꠖꠦ ꠚꠤꠡ꠆ꠔꠍ ꠇꠂꠍꠞꠤꠀ ꠕꠣꠇꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC25_2","074_25_2","ACT","25","2","2","ꠅꠃ ꠡꠝꠄ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠁꠢꠥꠖꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠀ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠦꠙꠣꠞꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠚꠤꠡ꠆ꠔꠍꠞ ꠉꠦꠍꠦ ꠈꠥꠛ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠤ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC25_3","074_25_3","ACT","25","3","3","ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠘꠣꠁꠘ। ꠔꠣꠞꠣꠞ ꠝꠔꠟꠛ ꠀꠍꠤꠟ, ꠙꠣꠃꠟꠥꠍꠞꠦ ꠀꠘꠣꠞ ꠡꠝꠄ ꠙꠕꠞ ꠝꠣꠎꠦ ꠟꠥꠇꠣꠁꠀ ꠞꠁꠀ ꠝꠣꠞꠤꠟꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC25_4","074_25_4","ACT","25","4","4","ꠢꠣꠇꠤꠝ ꠚꠤꠡ꠆ꠔꠍꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠙꠣꠃꠟꠥꠍꠞꠦ ꠔ ꠇꠂꠍꠞꠤꠀꠔ ꠀꠐꠇ ꠞꠣꠈꠣ ꠅꠁꠍꠦ, ꠀꠞ ꠀꠝꠤꠅ ꠈꠥꠛ ꠔꠣꠉꠖꠣ ꠇꠞꠤ ꠢꠤꠈꠣꠘꠅ ꠎꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC25_5","074_25_5","ACT","25","5","5","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠥꠎꠖꠣꠞ ꠇꠄꠎꠘ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠁꠅ, ꠢꠦ ꠇꠥꠘꠥ ꠖꠥꠡ ꠇꠞꠟꠦ ꠄꠞ ꠘꠣꠟꠤꠡ ꠖꠤꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC25_6","074_25_6","ACT","25","6","6","ꠚꠤꠡ꠆ꠔꠍ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠐ-ꠖꠡ ꠖꠤꠘ ꠞꠁꠀ ꠢꠣꠞꠟꠦ ꠇꠂꠍꠞꠤꠀꠔ ꠉꠦꠟꠣꠉꠤ। ꠉꠤꠀ ꠛꠣꠖꠞ ꠖꠤꠘ ꠔꠣꠁꠘ ꠀꠖꠣꠟꠔꠅ ꠛꠁꠀ, ꠙꠣꠃꠟꠥꠍꠞꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC25_7","074_25_7","ACT","25","7","7","ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤ ꠅꠇꠟ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠀꠁꠍꠟꠣ, ꠙꠣꠃꠟꠥꠍ ꠢꠤꠘꠅ ꠀꠎꠤꠞ ꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠔꠣꠘꠞꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠛꠦꠞꠤꠀ ꠃꠛꠣꠁꠀ ꠈꠥꠛ ꠖꠥꠡꠣ-ꠖꠥꠡꠤ ꠇꠞꠟꠣ, ꠅꠁꠟꠦ ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠙꠞꠝꠣꠘ ꠖꠤꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC25_8","074_25_8","ACT","25","8","8","ꠅꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠘꠤꠎꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠡꠞꠤꠅꠔ, ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ, ꠛꠣ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠥꠘꠥ ꠖꠥꠡ ꠇꠞꠍꠤ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC25_9","074_25_9","ACT","25","9","9","ꠅꠁꠟꠦ ꠚꠤꠡ꠆ꠔꠍꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠅꠀꠄ ꠔꠣꠁꠘ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠎꠤꠇꠣꠁꠟꠣ, “ꠅꠃ ꠝꠣꠝꠟꠣꠞ ꠛꠤꠌꠣꠞ ꠀꠝꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠇꠞꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠢꠤꠈꠣꠘꠅ ꠎꠣꠁꠔꠦ ꠞꠣꠎꠤ ꠀꠍ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC25_10","074_25_10","ACT","25","10","10","ꠙꠣꠃꠟꠥꠍꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠤ ꠔ ꠞꠥꠝꠣꠘ ꠀꠖꠣꠟꠔꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠍꠤ, ꠀꠞ ꠅꠃ ꠀꠖꠣꠟꠔꠅꠃ ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠅꠀꠈꠣꠘ ꠎꠞꠥꠞ। ꠀꠙꠘꠦ ꠘꠤꠎꠦꠅ ꠜꠣꠟꠣ ꠇꠞꠤ ꠎꠣꠘꠂꠘ, ꠀꠝꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC25_11","074_25_11","ACT","25","11","11","ꠔꠣ-ꠅ ꠀꠝꠣꠞ ꠇꠥꠘꠥ ꠇꠍꠥꠞ ꠅꠁꠟꠦ, ꠝꠃꠔꠞ ꠡꠣꠎꠣ ꠙꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠇꠥꠘꠥ ꠖꠥꠡ ꠙꠣꠁꠟꠦ, ꠀꠝꠤ ꠝꠞꠔꠦ ꠞꠣꠎꠤ ꠀꠍꠤ। ꠅꠁꠟꠦ ꠄꠞꠣ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠦꠔꠣ ꠖꠥꠡ ꠖꠤꠞꠣ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠢꠣꠍꠣ ꠘꠣ ꠅꠄ, ꠔꠦ ꠀꠝꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠍꠣꠠꠤ ꠖꠦꠅꠀꠞ ꠄꠈꠔꠤꠀꠞ ꠇꠦꠃꠞꠞ ꠘꠣꠁ। ꠄꠞꠖꠣꠄ ꠀꠝꠤ ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞ ꠉꠦꠍꠦ ꠀꠙꠤꠟ ꠇꠞꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("AC25_12","074_25_12","ACT","25","12","12","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠚꠤꠡ꠆ꠔꠍꠦ ꠔꠣꠘ ꠃꠎꠤꠞ-ꠘꠣꠎꠤꠞꠞ ꠟꠉꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠦꠛꠟꠣ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦ ꠀꠙꠤꠟ ꠇꠞꠟꠣꠄ, ꠔꠦ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦꠃ ꠎꠣꠁꠛꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC25_13","074_25_13","ACT","25","13","13","ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠞꠣꠎꠣ ꠀꠉ꠆ꠞꠤꠙ꠆ꠙ ꠀꠞ ꠔꠣꠘ ꠛꠁꠘ ꠞꠣꠘꠤ ꠛꠞ꠆ꠘꠤꠇꠤꠄ, ꠘꠄꠀ ꠢꠣꠇꠤꠝ ꠚꠤꠡ꠆ꠔꠍꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠂꠍꠞꠤꠀꠔ ꠀꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC25_14","074_25_14","ACT","25","14","14","ꠔꠣꠞꠣ ꠁꠈꠣꠘꠅ ꠇꠄꠖꠤꠘ ꠞꠁꠛꠣ ꠉꠔꠤꠇꠦ, ꠚꠤꠡ꠆ꠔꠍꠦ ꠙꠣꠃꠟꠥꠍꠞ ꠝꠣꠝꠟꠣꠞ ꠇꠕꠣ ꠞꠣꠎꠣꠞꠦ ꠎꠣꠘꠣꠁꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠚꠤꠟꠤꠇ꠆ꠡꠦ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞꠦ ꠎꠦꠟꠅ ꠕꠁꠀ ꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC25_15","074_25_15","ACT","25","15","15","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠦꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠢꠘꠞ ꠛꠠ ꠁꠝꠣꠝ ꠀꠞ ꠁꠢꠥꠖꠤ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠅꠃ ꠛꠦꠐꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠀ ꠔꠣꠞ ꠡꠣꠎꠣ ꠌꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC25_16","074_25_16","ACT","25","16","16","ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠍꠟꠣꠝ, ꠎꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠘꠣꠟꠤꠡ ꠖꠦꠅꠀ ꠅꠄ, ꠀꠞ ꠎꠦꠞꠣ ꠁ ꠘꠣꠟꠤꠡ ꠖꠦꠁꠘ, ꠢꠤ ꠛꠣꠖꠤ-ꠛꠤꠛꠣꠖꠤꠞ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠀꠞ ꠎꠦꠞꠣ ꠘꠣ ꠅꠁꠟꠦ, ꠀꠡꠣꠝꠤꠞꠦ ꠇꠥꠘꠥ ꠡꠣꠎꠣ ꠖꠦꠅꠀꠞ ꠄꠈꠔꠤꠀꠞ ꠞꠥꠝꠣꠘ ꠀꠁꠘꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("AC25_17","074_25_17","ACT","25","17","17","ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠇꠟ ꠅꠘꠅ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠀꠝꠤ ꠛꠣꠖꠞ ꠖꠤꠘꠃ ꠀꠖꠣꠟꠔꠅ ꠛꠁꠀ ꠢꠃ ꠀꠡꠣꠝꠤꠞꠦ ꠍꠣꠝꠘꠦ ꠀꠘꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC25_18","074_25_18","ACT","25","18","18","ꠎꠦꠞꠣ ꠔꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠍꠟꠣ ꠔꠣꠞꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠢꠥꠘꠟꠣꠝ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠦꠟꠣ ꠅꠘꠥꠝꠣꠘ ꠇꠞꠍꠟꠣꠝ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠔꠣꠞꠣ ꠖꠤꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC25_19","074_25_19","ACT","25","19","19","ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠗꠞ꠆ꠝꠞ ꠇꠕꠣ, ꠀꠞ ꠁꠍꠣ ꠘꠣꠝꠞ ꠇꠥꠘꠥ ꠄꠇꠎꠘ ꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠇꠕꠣ, ꠙꠣꠃꠟꠥꠍꠦ ꠄꠘꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠁꠀ ꠖꠣꠛꠤ ꠇꠞꠦꠞ, ꠅꠔꠣ ꠟꠁꠀ ꠔꠣꠞꠣ ꠀꠖꠣꠟꠔꠅ ꠘꠣꠟꠤꠡ ꠖꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC25_20","074_25_20","ACT","25","20","20","ꠀꠞ ꠁꠔꠣ ꠇꠤꠟꠣ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠔꠣꠝ, ꠁꠈꠣꠘ ꠝꠣꠟꠥꠝ ꠘꠣ ꠅꠀꠄ ꠀꠝꠤ ꠔꠣꠞꠦ ꠎꠤꠇꠣꠁꠟꠣꠝ, ꠢꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠉꠤꠀ ꠁ ꠝꠣꠝꠟꠣꠞ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠔꠦ ꠞꠣꠎꠤ ꠀꠍꠦ ꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("AC25_21","074_25_21","ACT","25","21","21","ꠢꠦ ꠞꠣꠎꠤ ꠘꠣ ꠅꠁꠀ, ꠀꠙꠤꠟ ꠇꠞꠤꠀ ꠛꠣꠖꠡꠣꠞ ꠞꠣꠄꠅꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅꠀꠄ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠘꠤꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠐꠇ ꠞꠣꠈꠣꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("AC25_22","074_25_22","ACT","25","22","22","ꠅꠃ ꠞꠣꠎꠣ ꠀꠉ꠆ꠞꠤꠙ꠆ꠙꠦ ꠚꠤꠡ꠆ꠔꠍꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠢꠥꠘꠔꠣꠝ ꠌꠣꠁ।” ꠚꠤꠡ꠆ꠔꠍꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠔꠦ ꠇꠣꠁꠟ ꠢꠥꠘꠛꠣꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("AC25_23","074_25_23","ACT","25","23","23","ꠛꠣꠖꠞ ꠖꠤꠘ ꠞꠣꠎꠣ ꠀꠉ꠆ꠞꠤꠙ꠆ꠙ ꠀꠞ ꠞꠣꠘꠤ ꠛꠞ꠆ꠘꠤꠇꠤ ꠛꠃꠔ ꠗꠥꠝꠗꠣꠝ ꠇꠞꠤ ꠀꠁꠟꠣ, ꠔꠣꠁꠘ ꠍꠤꠙꠣꠁꠞ ꠙꠞꠗꠣꠘ ꠅꠚꠤꠡꠣꠞ ꠅꠇꠟ, ꠐꠣꠃꠘꠞ ꠉꠁꠘ꠆ꠘ-ꠝꠣꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠀꠖꠣꠟꠔꠅ ꠢꠣꠝꠣꠁꠟꠣ। ꠚꠤꠡ꠆ꠔꠍꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠀ ꠙꠣꠃꠟꠥꠍꠞꠦꠅ ꠅꠘꠅ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC25_24","074_25_24","ACT","25","24","24","ꠛꠣꠖꠦ ꠚꠤꠡ꠆ꠔꠍꠦ ꠇꠁꠟꠣ, “ꠝꠢꠣꠘ ꠞꠣꠎꠣ ꠀꠉ꠆ꠞꠤꠙ꠆ꠙ, ꠀꠞ ꠀꠖꠣꠟꠔꠅ ꠀꠎꠤꠞ ꠉꠁꠘ꠆ꠘ-ꠝꠣꠁꠘ꠆ꠘ ꠍꠣꠛ ꠅꠇꠟ, ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟꠦ ꠅꠃ ꠛꠦꠌꠣꠠꠣꠞꠦ ꠖꠦꠈꠞꠣ। ꠢꠇꠟ ꠁꠢꠥꠖꠤꠄ ꠝꠤꠟꠤꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠀꠞ ꠇꠂꠍꠞꠤꠀꠔ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠞ ꠛꠤꠌꠣꠞ ꠌꠣꠁꠀ ꠝꠤꠍꠤꠟ ꠖꠤꠀ ꠇꠁꠍꠂꠘ, ꠔꠣꠞꠦ ꠈꠔꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("AC25_25","074_25_25","ACT","25","25","25","ꠅꠁꠟꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠝꠃꠔꠞ ꠡꠣꠎꠣ ꠖꠦꠅꠀꠞ ꠎꠥꠇꠣ ꠇꠥꠘꠥ ꠖꠥꠡ ꠔꠣꠞ ꠘꠣꠁ। ꠔꠣ-ꠅ ꠢꠦ ꠘꠤꠎꠦ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦ ꠀꠙꠤꠟ ꠇꠞꠣꠄ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠔꠣꠘ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠘꠤꠞ ꠈꠤꠀꠟ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("AC25_26","074_25_26","ACT","25","26","26","ꠅꠁꠟꠦ ꠝꠢꠣꠘ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠔꠣꠝ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠖꠥꠡ ꠙꠣꠁꠞꠣꠝ ꠘꠣ ꠉꠔꠤꠇꠦ, ꠀꠝꠤ ꠡ꠆ꠞꠖ꠆ꠖꠦꠅ ꠞꠣꠎꠣ ꠀꠉ꠆ꠞꠤꠙ꠆ꠙ ꠀꠞ ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠦ ꠀꠎꠤꠞ ꠇꠞꠍꠤ। ꠀꠙꠘꠣꠞꠣ ꠎꠦꠞꠣ ꠇꠞꠟꠦ ꠟꠦꠈꠣꠞ ꠎꠥꠇꠣ ꠇꠥꠘ꠆ꠔꠣ ꠙꠣꠁꠝꠥ ꠇꠞꠤ ꠝꠘꠅ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC25_27","074_25_27","ACT","25","27","27","ꠇꠣꠞꠘ ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠤ, ꠇꠥꠘꠥ ꠛꠘ꠆ꠖꠤꠞꠦ ꠌꠣꠟꠣꠘ ꠖꠦꠅꠀꠞ ꠛꠣꠟꠣ ꠔꠣꠞ ꠖꠥꠡ ꠅꠇꠟ ꠎꠣꠘꠣꠘꠤꠈꠣꠘ ꠎꠞꠥꠞ।” ");
INSERT INTO syls_vpl VALUES ("AC26_1","074_26_1","ACT","26","1","1","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠞꠣꠎꠣ ꠀꠉ꠆ꠞꠤꠙ꠆ꠙꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠇꠅꠀꠞ ꠟꠣꠉꠤ ꠅꠘꠥꠝꠔꠤ ꠖꠤꠟꠣꠝ।” ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠀꠔ ꠎꠥꠠ ꠇꠞꠤꠀ ꠘꠤꠎꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC26_2","074_26_2","ACT","26","2","2","“ꠝꠣꠘꠘꠤꠅ ꠞꠣꠎꠣ ꠘꠣꠝꠖꠣꠞ, ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠦꠔꠣ ꠘꠣꠟꠤꠡ ꠖꠤꠍꠂꠘ, ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠀꠁꠎ ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠢꠥꠘꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠀ, ꠀꠝꠤ ꠘꠤꠎꠞꠦ ꠜꠣꠁꠉ꠆ꠉꠝꠣꠘ ꠝꠘꠅ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC26_3","074_26_3","ACT","26","3","3","ꠈꠣꠍ ꠇꠞꠤ, ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠌꠣꠟ-ꠌꠟꠘ ꠀꠞ ꠔꠣꠞꠣꠞ ꠚꠤꠔꠘꠣ ꠅꠇꠟ ꠀꠙꠘꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ। ꠄꠞꠖꠣꠄ ꠀꠞꠎ ꠇꠞꠞꠣꠝ, ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤ ꠀꠙꠘꠦ ꠀꠝꠣꠞ ꠝꠣꠔ ꠈꠣꠘꠣꠁꠘ ꠢꠥꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("AC26_4","074_26_4","ACT","26","4","4","“ꠢꠥꠞꠥꠝꠣꠘ ꠕꠘꠦꠃ ꠘꠤꠎꠞ ꠄꠟꠣꠇꠣꠔ ꠀꠝꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠇꠤꠟꠣ ꠀꠍꠤꠟ, ꠛꠣꠖꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠁꠀ ꠇꠤꠟꠣꠈꠣꠘ ꠌꠟꠍꠤ, ꠁꠔꠣ ꠔ ꠔꠣꠝꠣꠝ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC26_5","074_26_5","ACT","26","5","5","ꠔꠣꠞꠣ ꠔ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠂꠘ ꠉꠔꠤꠇꠦ, ꠔꠣꠞꠣ ꠈꠤꠀꠟ ꠇꠞꠟꠦ ꠁ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠔꠣ ꠙꠣꠞꠛꠣ, ꠀꠝꠞꠣꠞ ꠗꠞ꠆ꠝꠞ ꠝꠣꠎꠦ ꠚꠞꠤꠡꠤ ꠘꠣꠝꠞ ꠎꠦ ꠝꠃꠟꠛꠣꠖꠤ ꠖꠟ ꠀꠍꠦ, ꠀꠝꠤ ꠅꠃ ꠚꠞꠤꠡꠤ ꠔꠞꠤꠇꠣꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC26_6","074_26_6","ACT","26","6","6","ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠤꠟꠣ, ꠢꠃ ꠅꠀꠖꠣꠄ ꠀꠝꠤ ꠜꠞꠡꠣ ꠇꠞꠤ, ꠄꠞꠟꠣꠉꠤ ꠀꠁꠎ ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("AC26_7","074_26_7","ACT","26","7","7","ꠀꠝꠞꠣꠞ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠡꠦ ꠞꠣꠁꠔ-ꠖꠤꠘ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠄꠛꠣꠖꠔꠤ ꠇꠞꠤꠀ, ꠢꠃ ꠅꠀꠖꠣꠞ ꠚꠟ ꠖꠦꠈꠣꠞ ꠀꠡꠣꠔ ꠀꠍꠂꠘ। ꠞꠣꠎꠣ ꠘꠣꠝꠖꠣꠞ, ꠢꠃ ꠀꠡꠣꠞ ꠟꠣꠉꠤꠃ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠀꠝꠣꠞꠦ ꠖꠥꠡꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("AC26_8","074_26_8","ACT","26","8","8","ꠀꠟ꠆ꠟꠣꠄ ꠝꠥꠞ꠆ꠖꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠀ ꠔꠥꠟꠂꠘ, ꠁꠈꠣꠘ ꠇꠦꠘꠦ ꠀꠙꠘꠣꠞꠣ ꠛꠤꠡ꠆ꠛꠣꠡ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ ꠘꠣ? ");
INSERT INTO syls_vpl VALUES ("AC26_9","074_26_9","ACT","26","9","9","“ꠀꠝꠤ ꠔ ꠝꠘꠅ ꠇꠞꠔꠣꠝ, ꠘꠣꠍꠣꠞꠔꠞ ꠁꠍꠣ ꠘꠣꠝꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠚꠞꠎ। ");
INSERT INTO syls_vpl VALUES ("AC26_10","074_26_10","ACT","26","10","10","ꠀꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠀꠝꠤ ꠅꠟꠣ ꠇꠞꠍꠤꠅ। ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠅꠘꠥꠝꠔꠤ ꠟꠁꠀ ꠁꠍꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦ ꠀꠝꠤ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠁꠔꠣꠝ। ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠇꠣꠟꠅ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠜꠥꠐ ꠖꠤꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC26_11","074_26_11","ACT","26","11","11","ꠀꠝꠤ ꠢꠇꠟ ꠝꠍꠤꠖꠣꠁꠘ꠆ꠔꠅ ꠉꠤꠀ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠔꠣꠝ। ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞꠦ ꠚꠤꠞꠣꠁꠀ, ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠟꠣꠘ꠆ꠘꠔ ꠖꠤꠔꠣ ꠇꠞꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠞ-ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣꠝ। ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠅꠔ ꠉꠥꠍꠣ ꠀꠍꠤꠟ ꠎꠦꠘ, ꠄꠞꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠛꠣꠞꠣ ꠖꠦꠡꠞ ꠐꠣꠃꠘꠅ-ꠅ ꠎꠣꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC26_12","074_26_12","ACT","26","12","12","“ꠅꠃꠟꠣ ꠄꠇꠛꠣꠞ ꠛꠠ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠈꠦꠝꠔꠣ ꠀꠞ ꠢꠥꠇꠥꠝꠎꠣꠞꠤ ꠟꠁꠀ ꠀꠝꠤ ꠖꠣꠝꠦꠡ꠆ꠇꠅ ꠎꠣꠅꠀꠔ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC26_13","074_26_13","ACT","26","13","13","ꠀꠞ ꠞꠣꠎꠣ ꠘꠣꠝꠖꠣꠞ, ꠅꠃ ꠡꠝꠄ ꠛꠦꠁꠟ ꠖꠥꠁꠚꠞ ꠅꠁꠉꠦꠍꠦ। ꠀꠈꠔꠣꠃ ꠖꠦꠈꠟꠣꠝ, ꠀꠝꠣꠞ ꠀꠞ ꠀꠝꠣꠞ ꠟꠉꠞ ꠢꠇꠟꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠡꠥꠞꠥꠎ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠦꠡꠤ ꠚꠞꠀꠟꠣ ꠄꠇ ꠞꠥꠡꠘꠤ, ꠀꠍꠝꠣꠘ ꠕꠘꠦ ꠎꠟꠤ ꠃꠑꠟ। ");
INSERT INTO syls_vpl VALUES ("AC26_14","074_26_14","ACT","26","14","14","ꠅꠃ ꠀꠝꠞꠣ ꠢꠇꠟ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠉꠦꠟꠣꠝ ꠀꠞ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠇꠁꠞꠣ, ꠡꠃꠟ, ꠡꠃꠟ, ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠞꠣꠄ? ꠌꠥꠈꠣ ꠚꠣꠁꠎꠘꠅ ꠟꠣꠕ ꠝꠣꠞꠤꠀ ꠘꠤꠎꠞ ꠈꠦꠔꠤ ꠇꠞꠞꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("AC26_15","074_26_15","ACT","26","15","15","ꠔꠦꠃ ꠀꠝꠤ ꠎꠤꠇꠣꠁꠟꠣꠝ, ꠝꠥꠘꠤꠛ, ꠀꠙꠘꠦ ꠇꠦ? ꠝꠥꠘꠤꠛꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, ꠀꠝꠤ ꠁꠍꠣ, ꠎꠦꠘꠞꠦ ꠔꠥꠝꠤ ꠎꠥꠟꠥꠝ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC26_16","074_26_16","ACT","26","16","16","ꠅꠈꠘ ꠃꠑꠅ, ꠙꠣꠅꠔ ꠜꠞꠖꠤ ꠃꠛꠣꠅ। ꠔꠥꠝꠤ ꠅꠈꠘ ꠎꠦꠔꠣ ꠖꠦꠈꠍ ꠀꠞ ꠎꠦꠔꠣ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠣꠁꠝꠥ, ꠁꠔꠣ ꠢꠇꠟꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤ ꠀꠞ ꠈꠦꠎꠝꠔꠉꠣꠞ ꠛꠣꠘꠣꠘꠤꠞ ꠈꠤꠀꠟꠦ, ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC26_17","074_26_17","ACT","26","17","17","ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠀꠞ, ꠔꠣꠞꠣꠞ ꠀꠞ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("AC26_18","074_26_18","ACT","26","18","18","ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠈꠥꠟꠤꠀ ꠖꠤꠛꠣꠄ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠀꠘ꠆ꠖꠣꠁꠞ ꠕꠣꠇꠤ ꠘꠥꠞꠞ ꠛꠣꠄ, ꠡꠄꠔꠣꠘꠞ ꠖꠈꠟ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠀ ꠀꠁꠘ, ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠙꠣꠁꠀ, ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠔꠣꠞꠣꠅ ꠖꠣꠈꠤꠟ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("AC26_19","074_26_19","ACT","26","19","19","“ꠝꠣꠘꠘꠤꠅ ꠞꠣꠎꠣ ꠘꠣꠝꠖꠣꠞ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠁ ꠖꠞꠡꠘꠞꠦ ꠀꠝꠤ ꠚꠣꠟꠣꠁꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC26_20","074_26_20","ACT","26","20","20","ꠄꠞꠖꠣꠄ ꠙꠄꠟꠣ ꠖꠣꠝꠦꠡ꠆ꠇꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ, ꠛꠣꠖꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ, ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠀꠞ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦꠅ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠣꠝ। ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣꠝ, ꠔꠃꠛꠣ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠅ, ꠀꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠝꠟ ꠇꠞꠅ, ꠎꠦꠔꠣ ꠖꠦꠈꠤꠀ ꠙꠞꠝꠣꠘ ꠝꠤꠟꠦ ꠔꠥꠝꠞꠣ ꠢꠣꠍꠣꠞꠞ ꠔꠃꠛꠣ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("AC26_21","074_26_21","ACT","26","21","21","ꠅꠃ ꠇꠣꠞꠘꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠗꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ ꠌꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC26_22","074_26_22","ACT","26","22","22","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠁꠎ꠆ꠎꠄ ꠀꠝꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠐꠤꠇꠤꠀ ꠀꠍꠤ, ꠀꠞ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠀ ꠡꠣꠇ꠆ꠇꠤꠅ ꠖꠤꠞꠣꠝ। ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠀꠞ ꠔꠣꠝꠣꠝ ꠘꠛꠤ ꠅꠇꠟꠦ ꠎꠦꠔꠣ ꠊꠐꠤꠛ ꠇꠞꠤ ꠛꠣꠔꠣꠁꠀ ꠉꠦꠍꠂꠘ, ꠁꠔꠣꠞ ꠛꠣꠞꠣ ꠀꠝꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠁꠞꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC26_23","074_26_23","ACT","26","23","23","ꠄꠞꠣ ꠇꠁꠍꠂꠘ, ꠀꠟ-ꠝꠍꠤꠄ ꠔꠇꠟꠤꠚ ꠡꠁꠎ꠆ꠎ ꠇꠞꠛꠣ, ꠔꠣꠁꠘꠃ ꠙꠄꠟꠣ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠔꠤ, ꠀꠞ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦꠅ ꠘꠥꠞꠞ ꠔꠞꠤꠇꠣꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC26_24","074_26_24","ACT","26","24","24","ꠙꠣꠃꠟꠥꠍꠦ ꠎꠦꠛꠟꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠞꠣ, ꠀꠈꠔꠣꠃ ꠚꠤꠡ꠆ꠔꠍꠦ ꠔꠣꠘꠞꠦ ꠎꠥꠞꠦ ꠗꠣꠝꠇꠤ ꠝꠣꠞꠤ ꠇꠁꠟꠣ, “ꠙꠣꠃꠟꠥꠍ, ꠔꠥꠝꠤ ꠔ ꠙꠣꠉꠟ ꠅꠁꠉꠦꠍ। ꠔꠥꠝꠤ ꠛꠃꠔ ꠟꠦꠈꠣ-ꠙꠠꠣ ꠇꠞꠍ, ꠅꠃ ꠟꠦꠈꠣ-ꠙꠠꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠙꠣꠉꠟ ꠛꠣꠘꠣꠁꠟꠤꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("AC26_25","074_26_25","ACT","26","25","25","ꠙꠣꠃꠟꠥꠍꠦ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠎꠤ ꠘꠣ, ꠢꠣꠇꠤꠝ ꠍꠣꠛ, ꠀꠝꠤ ꠙꠣꠉꠟ ꠘꠣꠄ। ꠀꠝꠤ ꠔ ꠢꠇ ꠀꠞ ꠎꠥꠇ꠆ꠔꠤꠞ ꠝꠣꠔ ꠝꠣꠔꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC26_26","074_26_26","ACT","26","26","26","ꠞꠣꠎꠣ ꠘꠣꠝꠖꠣꠞꠦ ꠔ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠎꠣꠘꠂꠘ, ꠀꠞ ꠀꠝꠤ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤꠀ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠝꠣꠔꠤꠞꠣꠝ। ꠀꠝꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠣꠘꠤ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠞꠣꠎꠣ ꠘꠣꠝꠖꠣꠞꠞ ꠝꠣꠟꠥꠝ ꠀꠍꠦ, ꠁꠔꠣ ꠔ ꠇꠥꠘꠥ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠟꠥꠇꠣꠁꠀ ꠊꠐꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC26_27","074_26_27","ACT","26","27","27","“ꠔꠦ ꠝꠣꠘꠘꠤꠅ ꠞꠣꠎꠣ ꠘꠣꠝꠖꠣꠞ, ꠀꠙꠘꠦ ꠇꠤꠔꠣ ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠂꠘ ꠘꠤ? ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ, ꠀꠙꠘꠦꠅ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC26_28","074_26_28","ACT","26","28","28","ꠅꠃ ꠀꠉ꠆ꠞꠤꠙ꠆ꠙꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠅꠔ ꠎꠟꠖꠤ ꠀꠝꠣꠞꠦꠅ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠔ ꠘꠤꠔꠣꠄꠉꠤ ꠌꠣꠁꠞꠣꠄ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("AC26_29","074_26_29","ACT","26","29","29","ꠙꠣꠃꠟꠥꠍꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠖꠥꠀ ꠇꠞꠞꠣꠝ, ꠎꠟꠖꠤ ꠅꠃꠇ ꠛꠣ ꠖꠦꠞꠤꠄ ꠅꠃꠇ, ꠈꠣꠟꠤ ꠀꠙꠘꠦ ꠘꠣꠄ, ꠎꠔ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠀꠁꠎꠇꠥꠞ ꠁ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠢꠥꠘꠞꠣ, ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠃ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠤꠎꠣꠃꠇ꠆ꠇꠣ। ꠈꠣꠟꠤ ꠅꠃ ꠡꠤꠇꠟ ꠛꠣꠖ ꠖꠤꠀ।” ");
INSERT INTO syls_vpl VALUES ("AC26_30","074_26_30","ACT","26","30","30","ꠔꠦꠃ ꠞꠣꠎꠣ, ꠖꠦꠡꠞ ꠙꠞꠗꠣꠘ ꠢꠣꠇꠤꠝ, ꠞꠣꠘꠤ ꠛꠞ꠆ꠘꠤꠇꠤ ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠖꠣꠟꠔꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠃꠛꠣꠁ ꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC26_31","074_26_31","ACT","26","31","31","ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠛꠣꠞꠘꠤꠞ ꠙꠕꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠁꠟꠣ, “ꠁ ꠛꠦꠌꠣꠠꠣꠄ ꠔ ꠝꠃꠔꠞ ꠡꠣꠎꠣ ꠛꠣ ꠎꠦꠟ ꠈꠣꠐꠣꠞ ꠎꠥꠇꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC26_32","074_26_32","ACT","26","32","32","ꠞꠣꠎꠣ ꠀꠉ꠆ꠞꠤꠙ꠆ꠙꠦ ꠚꠤꠡ꠆ꠔꠍꠞꠦ ꠇꠁꠟꠣ, “ꠢꠦ ꠎꠥꠖꠤ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦ ꠀꠙꠤꠟ ꠘꠣ ꠇꠞꠔ, ꠔꠦ ꠔꠣꠞꠦ ꠅꠈꠘ ꠈꠣꠟꠣꠍ ꠖꠦꠅꠀ ꠉꠦꠟ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("AC27_1","074_27_1","ACT","27","1","1","ꠢꠣꠇꠤꠝꠞ ꠚꠄꠍꠣꠟꠣ ꠝꠣꠚꠤꠇ ꠎꠣꠎꠅ ꠇꠞꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠁꠔꠣꠟꠤ ꠖꠦꠡꠅ ꠙꠣꠑꠣꠘꠤꠞ ꠡꠝꠄ ꠀꠁꠟꠦ, ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠀꠞꠅ ꠇꠄꠎꠘ ꠇꠄꠅꠖꠤꠞꠦ ꠎꠥꠟꠤꠅ ꠘꠣꠝꠞ ꠄꠇꠎꠘ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠍꠥꠛꠦꠖꠣꠞꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠟꠣ। ꠎꠥꠟꠤꠅ ꠀꠍꠟꠣ ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞ ꠀꠙꠘ ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠄꠇꠎꠘ ꠍꠥꠛꠦꠖꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("AC27_2","074_27_2","ACT","27","2","2","ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠀꠖ꠆ꠞꠣꠝꠥꠔ꠆ꠔꠤꠅ ꠊꠣꠐꠞ ꠅꠃꠟꠣ ꠄꠇ ꠎꠣꠎꠅ ꠅꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠝ, ꠎꠦꠈꠣꠘ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠛꠃꠔ ꠎꠣꠎ ꠊꠣꠐꠅ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠇꠞꠣ ꠅꠁꠍꠦ। ꠀꠞ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠖꠦꠡꠞ ꠕꠤꠡꠟꠘꠤꠇꠤ ꠐꠣꠃꠘꠞ ꠀꠞꠤꠡ꠆ꠔꠣꠇꠥꠍ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_3","074_27_3","ACT","27","3","3","ꠛꠣꠖꠞ ꠖꠤꠘ ꠀꠝꠞꠣꠞ ꠎꠣꠎ ꠉꠤꠀ ꠍꠤꠖꠘꠅ ꠜꠤꠠꠟ। ꠍꠥꠛꠦꠖꠣꠞ ꠎꠥꠟꠤꠅꠄ ꠙꠣꠃꠟꠥꠍꠞ ꠟꠉꠦ ꠈꠥꠛ ꠜꠣꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠟꠣ। ꠔꠣꠁꠘ ꠔꠣꠘ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠉꠤꠀ, ꠘꠤꠎꠞ ꠎꠞꠥꠞꠤ ꠉꠞꠎ ꠇꠥꠟꠣꠘꠤꠞ ꠁꠎꠣꠎꠔ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_4","074_27_4","ACT","27","4","4","ꠛꠣꠖꠦ ꠢꠤ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠢꠤꠞꠛꠣꠞ ꠎꠣꠎ ꠍꠣꠠꠟ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠃꠟꠐꠣꠝꠥꠈꠣ ꠛꠣꠔꠣꠡ ꠖꠦꠅꠀꠄ, ꠀꠝꠞꠣ ꠍꠣꠁꠙ꠆ꠞꠣꠍ ꠖꠤꠙꠞ ꠎꠦꠛꠣꠄ ꠛꠣꠔꠣꠡ ꠀꠍꠤꠟ ꠘꠣ ꠢꠛꠣꠄꠖꠤ ꠉꠦꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_5","074_27_5","ACT","27","5","5","ꠉꠤꠀ ꠇꠤꠟꠤꠇꠤꠀ ꠀꠞ ꠙꠣꠝꠚꠥꠟꠤꠀꠞ ꠍꠣꠝꠘꠞ ꠡꠣꠉꠞ ꠙꠣꠞ ꠅꠁꠀ ꠟꠥꠇꠤꠀ ꠖꠦꠡꠞ ꠝꠥꠞꠣ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠀꠎꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_6","074_27_6","ACT","27","6","6","ꠍꠥꠛꠦꠖꠣꠞꠦ ꠢꠤꠈꠣꠘꠅ ꠁꠔꠣꠟꠤ ꠖꠦꠡꠅ ꠎꠣꠅꠞꠣ, ꠀꠟꠦꠇꠎꠣꠘꠖ꠆ꠞꠤꠀꠞ ꠄꠇꠈꠣꠘ ꠎꠣꠎ ꠙꠣꠁꠀ, ꠢꠃ ꠎꠣꠎꠅ ꠇꠞꠤ ꠀꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_7","074_27_7","ACT","27","7","7","ꠀꠝꠞꠣꠞ ꠎꠣꠎꠈꠣꠘ ꠈꠥꠛ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠌꠟꠤꠀ ꠛꠃꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠇꠡ꠆ꠐ ꠇꠞꠤ ꠇ꠆ꠟꠤꠖ ꠐꠣꠃꠘꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠀꠎꠤꠟ, ꠅꠁꠟꠦ ꠛꠣꠔꠣꠡꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠀꠞ ꠡꠢꠎꠦ ꠀꠉꠥꠀꠁꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠘꠣ। ꠔꠦꠃ ꠀꠝꠞꠣ ꠇꠝ ꠛꠣꠔꠣꠡꠦꠖꠤ ꠍꠣꠟꠝꠥꠘꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠛꠣꠄ ꠉꠤꠀ ꠇ꠆ꠞꠤꠔꠤ ꠖꠤꠙꠞ ꠀꠅꠠꠦꠖꠤ ꠎꠣꠅꠀꠔ ꠟꠣꠉꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_8","074_27_8","ACT","27","8","8","ꠀꠞ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠛꠣꠄ ꠇꠡ꠆ꠐ ꠇꠞꠤꠀ ꠎꠣꠁꠔꠦ ꠎꠣꠁꠔꠦ, ‘ꠡꠥꠘ꠆ꠖꠞ ꠟꠋꠉꠞꠈꠣꠘꠣ’ ꠘꠣꠝꠞ ꠄꠇ ꠢꠥꠞꠥ ꠎꠣꠎ ꠊꠣꠐꠅ ꠀꠁꠟꠣꠝ, ꠄꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠍꠤꠟ ꠟꠣꠍꠦꠀ ꠐꠣꠃꠘ। ");
INSERT INTO syls_vpl VALUES ("AC27_9","074_27_9","ACT","27","9","9","ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠃꠔ ꠖꠤꠘ ꠉꠥꠎꠞꠤ ꠉꠦꠟ, ꠞꠥꠎꠣꠞ ꠁꠖꠞ ꠖꠤꠘ ꠡꠦꠡ ꠅꠁꠀ ꠕꠥꠠꠣ ꠕꠥꠠꠣ ꠡꠤꠔ ꠀꠁꠍꠦ। ꠁ ꠡꠝꠄ ꠎꠣꠎꠦ ꠍꠚꠞ ꠇꠞꠣ ꠈꠥꠛ ꠛꠤꠙꠖ। ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠎꠣꠎꠞ ꠝꠣꠘꠡꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_10","074_27_10","ACT","27","10","10","ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠍꠣꠛ ꠅꠇꠟ, ꠀꠝꠤ ꠖꠦꠈꠞꠣꠝ, ꠁ ꠍꠚꠞꠅ ꠀꠝꠞꠣꠞ ꠛꠃꠔ ꠝꠍꠤꠛꠔ ꠀꠞ ꠈꠦꠔꠤ ꠅꠁꠛ। ꠁꠔꠣ ꠈꠣꠟꠤ ꠎꠣꠎ ꠛꠣ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞ ꠘꠣꠄ, ꠀꠝꠞꠣꠞ ꠎꠣꠘꠞꠅ ꠈꠦꠔꠤ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("AC27_11","074_27_11","ACT","27","11","11","ꠅꠁꠟꠦ ꠍꠥꠛꠦꠖꠣꠞꠦ ꠙꠣꠃꠟꠥꠍꠞ ꠇꠕꠣ ꠘꠣ ꠝꠣꠘꠤꠀ, ꠎꠣꠎꠞ ꠝꠣꠟꠤꠇ ꠀꠞ ꠇꠦꠙꠐꠤꠘꠞ ꠇꠕꠣ ꠢꠥꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_12","074_27_12","ACT","27","12","12","ꠀꠞ ꠁ ꠟꠋꠉꠞꠈꠣꠘꠣꠔ ꠡꠤꠔꠞ ꠖꠤꠘꠅ ꠞꠁꠔꠦ ꠡꠥꠛꠤꠗꠣ ꠅꠁꠔ ꠘꠣꠄ ꠉꠔꠤꠇꠦ, ꠛꠦꠡꠤꠞ ꠜꠣꠉ ꠝꠣꠘꠡꠦ ꠢꠤꠘ ꠕꠣꠇꠤ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠟꠣ। ꠔꠣꠞꠣ ꠌꠣꠁꠟꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦ ꠚꠤꠘꠤꠇ꠆ꠡ ꠊꠣꠐꠅ ꠙꠃꠍꠤꠀ ꠡꠤꠔꠞ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠔꠣ। ꠁ ꠊꠣꠐ ꠀꠍꠤꠟ ꠇ꠆ꠞꠤꠔꠤ ꠖꠤꠙꠅ, ꠄꠞ ꠃꠔ꠆ꠔꠞ-ꠙꠌ꠆ꠌꠤꠝ ꠀꠞ ꠖꠇ꠆ꠇꠤꠘ-ꠙꠌ꠆ꠌꠤꠝ ꠖꠤꠇ ꠈꠥꠟꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC27_13","074_27_13","ACT","27","13","13","ꠛꠣꠖꠦ ꠎꠦꠛꠟꠣ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠖꠃꠇꠘꠞ ꠛꠣꠔꠣꠡ ꠌꠣꠟꠥ ꠅꠁꠟ, ꠅꠃ ꠔꠣꠞꠣ ꠝꠘꠅ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠎꠦꠟꠣ ꠀꠡꠣ ꠇꠞꠍꠟꠣ ꠅꠟꠣꠃ ꠅꠁꠍꠦ। ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠎꠣꠎꠞ ꠟꠋꠉꠞ ꠈꠥꠟꠤꠀ ꠇ꠆ꠞꠤꠔꠤ ꠖꠤꠙꠞ ꠉꠣꠟꠣꠛꠣꠄ ꠞꠅꠀꠘꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC27_14","074_27_14","ACT","27","14","14","ꠅꠁꠟꠦ ꠕꠥꠠꠣ ꠛꠣꠖꠦꠃ ꠢꠤ ꠙꠣꠞꠅ ꠕꠣꠇꠤ ꠁꠀꠘ-ꠇꠥꠘꠤ ꠘꠣꠝꠞ ꠈꠥꠛ ꠛꠦꠎꠥꠁꠔꠣ ꠄꠇ ꠔꠥꠚꠣꠘ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("AC27_15","074_27_15","ACT","27","15","15","ꠀꠝꠞꠣꠞ ꠎꠣꠎ ꠔꠥꠚꠣꠘꠞ ꠝꠣꠎꠦ ꠙꠠꠟ, ꠔꠥꠚꠣꠘꠞ ꠑꠦꠟꠣ ꠝꠥꠇꠣꠛꠤꠟꠣ ꠇꠞꠔꠣꠝ ꠘꠣ ꠙꠣꠞꠤꠀ, ꠎꠣꠎꠞꠦ ꠛꠣꠔꠣꠡꠞ ꠔꠣꠟꠦ ꠔꠣꠟꠦ ꠜꠣꠐꠤꠅꠟ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_16","074_27_16","ACT","27","16","16","ꠛꠣꠖꠦ ꠇꠃꠖꠣ ꠘꠣꠝꠞ ꠄꠇ ꠢꠥꠞꠥ ꠖꠤꠙꠞ ꠀꠅꠠꠦꠖꠤ ꠉꠤꠀ, ꠎꠣꠎꠞ ꠟꠉꠞ ꠛꠣꠞꠇꠤ ꠘꠣꠅꠈꠣꠘꠞꠦ ꠀꠝꠞꠣ ꠛꠃꠔ ꠇꠡ꠆ꠐ ꠇꠞꠤ ꠜꠣꠋꠉꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_17","074_27_17","ACT","27","17","17","ꠝꠣꠘꠡꠦ ꠘꠣꠅꠞꠦ ꠐꠣꠘꠤꠀ ꠘꠤꠀ ꠎꠣꠎꠞ ꠃꠙꠞꠦ ꠔꠥꠟꠟꠣ, ꠀꠞ ꠎꠣꠎꠞ ꠔꠇ꠆ꠔꠣꠁꠘꠞꠦ ꠖꠠꠤ ꠖꠤꠀ ꠖꠠ ꠇꠞꠤ ꠛꠣꠘ꠆ꠖꠤꠟꠣ, ꠎꠣꠔꠦ ꠔꠥꠚꠣꠘꠦ ꠘꠣ ꠜꠣꠋꠉꠦ। ꠛꠣꠖꠦ ꠍꠥꠞ꠆ꠔꠤ ꠘꠣꠝꠞ ꠡꠣꠉꠞꠞ ꠌꠞꠅ ꠎꠣꠎ ꠟꠣꠉꠤꠎꠤꠛꠣꠞ ꠒꠞꠦ, ꠙꠣꠟ ꠟꠣꠝꠣꠁꠀ ꠎꠣꠎꠞꠦ ꠄꠝꠘꠦ ꠛꠣꠔꠣꠡ ꠜꠣꠐꠤꠅꠟꠦ ꠍꠣꠠꠤ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_18","074_27_18","ACT","27","18","18","ꠔꠥꠚꠣꠘꠦ ꠎꠣꠎꠞꠦ ꠅꠝꠘ ꠟꠣꠈꠣꠘ ꠉꠠꠣꠉꠠꠤ ꠡꠥꠞꠥ ꠇꠞꠟ, ꠄꠞꠖꠣꠄ ꠔꠣꠞꠣ ꠛꠣꠖꠞ ꠖꠤꠘ ꠎꠣꠎꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠙꠣꠘꠤꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_19","074_27_19","ACT","27","19","19","ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠀꠔꠦ ꠎꠣꠎꠞ ꠡꠣꠎ-ꠡꠞꠘ꠆ꠎꠣꠝꠅ ꠙꠣꠘꠤꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_20","074_27_20","ACT","27","20","20","ꠛꠃꠔ ꠖꠤꠘ ꠕꠣꠇꠤ ꠌꠣꠘ-ꠡꠥꠞꠥꠎ ꠇꠥꠘ ꠎꠤꠘꠤꠡ ꠁꠔꠣ ꠘꠣ ꠖꠦꠈꠣꠄ, ꠀꠞ ꠔꠥꠚꠣꠘꠞ ꠎꠥꠞ ꠈꠥꠛ ꠛꠦꠡꠤ ꠅꠀꠄ, ꠀꠝꠞꠣ ꠎꠣꠘꠦ ꠛꠣꠌꠣꠞ ꠀꠡꠣ ꠍꠣꠠꠤ ꠖꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_21","074_27_21","ACT","27","21","21","ꠎꠣꠎꠞ ꠝꠣꠘꠥꠡ ꠛꠃꠔ ꠖꠤꠘ ꠗꠞꠤ ꠃꠙꠣꠡ ꠞꠅꠀꠄ ꠙꠣꠃꠟꠥꠍꠦ ꠃꠛꠣꠁꠀ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠜꠣꠁꠍꠣꠛ ꠅꠇꠟ, ꠀꠝꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠇ꠆ꠞꠤꠔꠤ ꠖꠤꠙ ꠕꠣꠇꠤ ꠎꠣꠎꠈꠣꠘꠞꠦ ꠘꠣ ꠍꠣꠠꠟꠦ, ꠁ ꠝꠍꠤꠛꠔ ꠀꠞ ꠈꠦꠔꠤ ꠕꠣꠇꠤ ꠀꠙꠘꠣꠞꠣ ꠛꠣꠌꠟꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("AC27_22","074_27_22","ACT","27","22","22","ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠅꠃ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠞꠣꠝ, ꠀꠙꠘꠣꠞꠣ ꠝꠘꠞ ꠝꠣꠎꠦ ꠛꠟ ꠞꠣꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣ ꠇꠦꠃ ꠎꠣꠘꠦ ꠝꠞꠔꠣꠝ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠎꠣꠎꠈꠣꠘ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("AC27_23","074_27_23","ACT","27","23","23","ꠀꠝꠤ ꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠤ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠞ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠉꠔ ꠞꠣꠁꠔ ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠃꠛꠣꠁꠀ ꠇꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("AC27_24","074_27_24","ACT","27","24","24","ꠙꠣꠃꠟꠥꠍ, ꠒꠞꠣꠁꠅ ꠘꠣ, ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠣꠞ ꠃꠛꠣꠘꠤ ꠟꠣꠉꠛ। ꠀꠞ ꠁ ꠎꠣꠎꠅ ꠇꠞꠤ ꠎꠦꠞꠣ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠁꠞꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞ ꠈꠣꠔꠤꠞꠦ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC27_25","074_27_25","ACT","27","25","25","ꠔꠦ ꠍꠣꠛ ꠅꠇꠟ, ꠀꠙꠘꠣꠞꠣ ꠝꠘꠞ ꠝꠣꠎꠦ ꠛꠟ ꠞꠣꠈꠃꠇ꠆ꠇꠣ। ꠀꠝꠤ ꠄꠇꠤꠘ ꠇꠞꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠁꠍꠂꠘ, ꠅꠟꠣꠃ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("AC27_26","074_27_26","ACT","27","26","26","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠖꠤꠙꠞ ꠃꠙꠞꠦ ꠉꠤꠀ ꠙꠠꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("AC27_27","074_27_27","ACT","27","27","27","ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠀꠝꠞꠣ ꠀꠖ꠆ꠞꠤꠀ ꠡꠣꠉꠞꠞ ꠃꠙꠞꠦꠖꠤ ꠎꠣꠅꠀꠔ ꠞꠁꠟꠣꠝ, ꠛꠣꠖꠦ ꠔꠥꠚꠣꠘꠞ ꠌꠃꠖ꠆ꠖ ꠖꠤꠘꠞ ꠖꠤꠘ ꠀꠗꠣ ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠘꠣꠁꠀ ꠅꠇꠟꠦ ꠀꠘ꠆ꠖꠣꠎ ꠇꠞꠟꠣ, ꠔꠣꠞꠣ ꠙꠣꠞꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("AC27_28","074_27_28","ACT","27","28","28","ꠔꠣꠞꠣ ꠙꠣꠘꠤ ꠝꠣꠙꠤꠀ ꠖꠦꠈꠟꠣ ꠈꠣꠟꠤ ꠀꠡꠤ ꠀꠔ ꠉꠁꠘ ꠀꠍꠦ, ꠕꠥꠠꠣ ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠝꠣꠙꠤꠀ ꠖꠦꠈꠟꠣ, ꠡꠣꠁꠐ ꠀꠔ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC27_29","074_27_29","ACT","27","29","29","ꠄꠞꠖꠣꠄ ꠌꠞꠞ ꠙꠣꠔ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠉꠤꠀ ꠎꠣꠎ ꠗꠣꠇ꠆ꠇꠣ ꠟꠣꠉꠣꠞ ꠒꠞꠦ, ꠔꠣꠞꠣ ꠎꠣꠎꠞ ꠈꠞꠦꠖꠤ ꠌꠣꠁꠞꠉꠦꠍꠣ ꠟꠋꠉꠞ ꠚꠣꠟꠣꠁꠀ, ꠡꠥꠞꠥꠎꠞ ꠚꠞ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠣꠔ ꠛꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_30","074_27_30","ACT","27","30","30","ꠘꠣꠁꠀ ꠅꠇꠟꠦ ꠎꠣꠎ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠀ ꠎꠣꠅꠀꠞ ꠝꠔꠟꠛ ꠇꠞꠤ, ꠍꠣꠝꠘꠞ ꠉꠟꠁꠞ ꠕꠥꠠꠣ ꠀꠉꠦ ꠟꠋꠉꠞ ꠚꠣꠟꠣꠘꠤꠞ ꠇꠕꠣ ꠇꠁꠀ, ꠎꠣꠎꠞ ꠛꠣꠞꠇꠤ ꠘꠣꠅꠞꠦ ꠖꠞꠤꠀꠔ ꠟꠣꠝꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_31","074_27_31","ACT","27","31","31","ꠔꠦꠃ ꠙꠣꠃꠟꠥꠍꠦ ꠍꠥꠛꠦꠖꠣꠞꠞꠦ ꠀꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣꠁꠀ ꠅꠇꠟ ꠎꠣꠎ ꠕꠣꠇꠤ ꠜꠣꠉꠤ ꠉꠦꠟꠦ ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟ ꠝꠣꠞꠣ ꠎꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC27_32","074_27_32","ACT","27","32","32","ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠘꠣꠅꠞ ꠖꠠꠤ ꠇꠣꠐꠤ ꠖꠤꠟꠣ, ꠔꠦꠃ ꠘꠣꠅ ꠙꠣꠘꠤꠔ ꠜꠣꠡꠤꠀ ꠉꠦꠟꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("AC27_33","074_27_33","ACT","27","33","33","ꠙꠔꠣꠛꠣꠟꠣ ꠙꠣꠃꠟꠥꠍꠦ ꠢꠇꠟꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠅꠀꠞ ꠟꠣꠉꠤ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠁꠎ ꠌꠃꠖ꠆ꠖꠖꠤꠘ ꠗꠞꠤ ꠇꠤꠔꠣ ꠅꠁꠛ ꠘꠣ ꠅꠁꠛ ꠅꠃ ꠌꠤꠘ꠆ꠔꠣꠄ ꠀꠙꠘꠣꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_34","074_27_34","ACT","27","34","34","ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠞꠣꠝ, ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠃꠇ꠆ꠇꠣ। ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔꠦ ꠅꠁꠟꠦ ꠔ ꠀꠙꠘꠣꠞꠣ ꠈꠣꠁꠔꠦ ꠅꠁꠛ। ꠖꠦꠈꠛꠣꠘꠦ, ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠕꠣꠞ ꠄꠇꠍꠣ ꠌꠥꠟꠞꠅ ꠈꠦꠔꠤ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("AC27_35","074_27_35","ACT","27","35","35","ꠁꠈꠣꠘ ꠇꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠞꠥꠐꠤ ꠀꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠀ, ꠞꠥꠐꠤ ꠍꠤꠠꠤꠀ ꠈꠣꠅꠀꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_36","074_27_36","ACT","27","36","36","ꠔꠦꠃ ꠢꠇꠟꠦ ꠝꠘꠞ ꠝꠣꠎꠦ ꠛꠟ ꠙꠣꠁꠀ ꠈꠣꠘꠤ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_37","074_27_37","ACT","27","37","37","ꠁ ꠎꠣꠎꠞ ꠝꠣꠎꠦ ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠖꠥꠁ-ꠡ ꠍꠤꠅꠔ꠆ꠔꠁꠞ ꠎꠘ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_38","074_27_38","ACT","27","38","38","ꠢꠇꠟꠦ ꠙꠦꠐ ꠜꠞꠤꠀ ꠈꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠣꠎꠞ ꠜꠣꠞ ꠇꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠇ꠆ꠇꠟ ꠉꠝ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_39","074_27_39","ACT","27","39","39","ꠛꠤꠀꠘ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠌꠤꠘꠟꠣ ꠘꠣ, ꠁ ꠎꠣꠉꠣ ꠀꠍꠟꠦ ꠇꠥꠘ ꠎꠣꠉꠣ। ꠅꠁꠟꠦ ꠅꠃꠟꠣ ꠄꠇ ꠛꠣꠈ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠁ ꠛꠣꠈꠞ ꠌꠞ ꠛꠣꠟꠥꠄ ꠜꠞꠣ। ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ, ꠙꠣꠞꠟꠦ ꠎꠣꠎꠞꠦ ꠘꠤꠀ ꠢꠃ ꠌꠞꠅ ꠔꠥꠟꠤꠟꠤꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("AC27_40","074_27_40","ACT","27","40","40","ꠔꠦꠃ ꠔꠣꠞꠣ ꠟꠋꠉꠞꠣꠁꠘ ꠇꠣꠐꠤꠀ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ, ꠀꠞ ꠇꠣꠘ꠆ꠒꠣꠞꠤꠞ ꠛꠂꠑꠣꠞ ꠖꠠꠤꠘꠅ ꠇꠣꠐꠤ ꠖꠤꠟꠣ। ꠛꠣꠖꠦ ꠛꠣꠔꠣꠡ ꠜꠣꠐꠤꠅꠟꠦ ꠍꠣꠝꠘꠞ ꠙꠣꠟ ꠐꠣꠋꠉꠣꠁꠀ ꠢꠃ ꠛꠣꠟꠥꠞ ꠌꠞꠞ ꠝꠥꠈꠣ ꠉꠦꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC27_41","074_27_41","ACT","27","41","41","ꠅꠁꠟꠦ ꠎꠣꠎ ꠔꠟꠦ ꠟꠥꠇꠣꠁꠟ ꠇꠥꠘ꠆ꠔꠣꠔ ꠀꠐꠇꠤ ꠉꠦꠟ। ꠀꠞ ꠍꠣꠝꠘ ꠉꠣꠟꠣ ꠀꠐꠇꠤ ꠎꠣꠅꠀꠄ, ꠈꠞꠞ ꠉꠟꠁꠔ ꠓꠦꠃꠞ ꠛꠣꠠꠤ ꠟꠣꠉꠤꠀ ꠜꠣꠋꠉꠣ ꠗꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("AC27_42","074_27_42","ACT","27","42","42","ꠔꠦꠃ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠟꠣ ꠛꠘ꠆ꠖꠤ ꠅꠇꠟꠞꠦ ꠝꠣꠞꠤꠟꠤꠔꠣ, ꠀꠞꠘꠣꠄ ꠇꠦꠃ ꠇꠦꠃ ꠢꠣꠔꠞꠣꠁꠀ ꠜꠣꠉꠤꠎꠤꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("AC27_43","074_27_43","ACT","27","43","43","ꠅꠁꠟꠦ ꠡ-ꠍꠤꠙꠣꠁꠞ ꠍꠥꠛꠦꠖꠣꠞꠦ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠈꠤꠀꠟꠦ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞ ꠁ ꠙꠞꠣꠝꠤꠡ ꠝꠣꠘꠟꠣ ꠘꠣ। ꠔꠣꠁꠘ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠎꠦꠞꠣ ꠢꠣꠔꠣꠞ ꠎꠣꠘꠦ, ꠔꠣꠞꠣ ꠀꠉꠦ ꠎꠣꠎ ꠕꠣꠇꠤ ꠚꠣꠟꠣꠁꠀ ꠙꠠꠤꠀ ꠢꠥꠇꠘꠣꠔ ꠃꠑꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("AC27_44","074_27_44","ACT","27","44","44","ꠀꠞ ꠢꠣꠔꠣꠞ ꠘꠣ ꠎꠣꠘꠞꠣ ꠅꠇꠟꠦ ꠎꠣꠎꠞ ꠔꠇ꠆ꠔꠣ ꠛꠣ ꠀꠞꠅ ꠇꠥꠘ꠆ꠔꠣꠔ ꠗꠞꠤꠀ ꠢꠥꠇꠘꠣꠔ ꠙꠣꠞꠃꠇ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠇꠟꠦ ꠢꠥꠇꠘꠣꠔ ꠃꠑꠤꠀ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_1","074_28_1","ACT","28","1","1","ꠀꠝꠞꠣ ꠢꠦꠚꠣꠎꠔꠦ ꠙꠣꠞꠅ ꠃꠑꠤꠀ ꠢꠣꠞꠟꠦ ꠎꠣꠘꠟꠣꠝ, ꠁ ꠖꠤꠙꠞ ꠘꠣꠝ ꠅꠁꠟ ꠝꠣꠟꠐꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_2","074_28_2","ACT","28","2","2","ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠈꠥꠛ ꠜꠣꠟꠣ-ꠝꠣꠘꠡꠤ ꠇꠞꠟꠣ, ꠝꠦꠊ ꠀꠞ ꠡꠤꠔ ꠀꠍꠤꠟ ꠇꠞꠤ ꠔꠣꠞꠣ ꠀꠉꠥꠁꠘ ꠎꠣꠟꠣꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠒꠣꠇꠤꠀ ꠘꠤꠀ ꠈꠣꠔꠤꠞ-ꠎꠔꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_3","074_28_3","ACT","28","3","3","ꠄꠞꠝꠣꠎꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠄꠇ ꠀꠐꠣ ꠢꠥꠇꠘꠣ ꠟꠣꠇꠠꠤ ꠔꠥꠇꠣꠁꠀ ꠖꠟꠣ ꠇꠞꠤ ꠀꠘꠤꠀ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎꠦ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ, ꠀꠉꠥꠘꠤꠞ ꠔꠦꠎꠦ ꠄꠇ ꠇꠣꠟꠘꠣꠉ ꠛꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠤ ꠙꠣꠃꠟꠥꠍꠞ ꠀꠔꠅ ꠇꠣꠝꠠ ꠝꠣꠞꠤ ꠗꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("AC28_4","074_28_4","ACT","28","4","4","ꠇꠣꠟꠘꠣꠉꠦ ꠙꠣꠃꠟꠥꠍꠞ ꠀꠔꠅ ꠇꠣꠝꠠꠖꠤ ꠟꠐꠇꠤ ꠞꠁꠍꠦ ꠖꠦꠈꠤꠀ, ꠢꠤꠘꠞ ꠝꠣꠘꠡꠦ ꠝꠣꠔꠣ-ꠝꠣꠔꠤ ꠟꠣꠉꠣꠁꠟꠣ, “ꠁ ꠝꠣꠘꠥꠡꠉꠥ ꠘꠤꠌꠄ ꠇꠥꠘꠥ ꠈꠥꠘꠤ, ꠖꠞꠤꠀꠞ ꠀꠔ ꠕꠣꠇꠤ ꠢꠦ ꠛꠣꠌꠤꠉꠦꠟꠦꠅ ꠘꠤꠀꠄ-ꠖꠦꠛꠔꠣꠄ ꠔꠣꠞꠦ ꠛꠣꠌꠔꠦ ꠖꠤꠟꠣ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC28_5","074_28_5","ACT","28","5","5","ꠅꠁꠟꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠀꠔ ꠏꠣꠠꠣ ꠖꠤꠀ ꠇꠣꠟꠘꠣꠉꠞꠦ ꠀꠉꠥꠁꠘꠅ ꠚꠣꠟꠣꠁ ꠖꠤꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_6","074_28_6","ACT","28","6","6","ꠝꠣꠘꠡꠦ ꠝꠘꠦ ꠝꠘꠦ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠤꠟ, ꠙꠣꠃꠟꠥꠍꠞ ꠉꠔꠞ ꠚꠥꠟꠤꠎꠤꠛ, ꠛꠣ ꠔꠣꠁꠘ ꠀꠈꠔꠣꠃ ꠝꠣꠐꠤꠔ ꠙꠠꠤꠀ ꠝꠞꠤꠎꠤꠛꠣ। ꠛꠃꠔ ꠡꠝꠄ ꠛꠣꠞ ꠌꠣꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘ ꠇꠥꠘꠥ ꠛꠤꠙꠖ ꠅꠁꠍꠦ ꠘꠣ ꠖꠦꠈꠤꠀ, ꠔꠣꠞꠣꠞ ꠝꠔ ꠛꠖꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠄꠁꠘ ꠔ ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC28_7","074_28_7","ACT","28","7","7","ꠁ ꠎꠣꠉꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠢꠃ ꠖꠤꠙꠞ ꠙꠥꠛꠟꠤꠅ ꠘꠣꠝꠞ ꠄꠇ ꠈꠣꠘ꠆ꠖꠣꠘꠤ ꠝꠣꠘꠡꠞ ꠎꠝꠤꠖꠣꠞꠤ ꠀꠍꠤꠟ। ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠛꠣꠠꠤꠔ ꠖꠣꠅꠔ ꠖꠤꠟꠣ ꠀꠞ ꠔꠤꠘꠖꠤꠘ ꠗꠞꠤ ꠀꠝꠞꠣꠞꠦ ꠈꠥꠛ ꠈꠣꠔꠤꠞ-ꠎꠔꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_8","074_28_8","ACT","28","8","8","ꠅꠃ ꠡꠝꠄ ꠙꠥꠛꠟꠤꠅꠞ ꠛꠣꠚ ꠔꠣꠙ ꠀꠞ ꠇꠣꠝꠠꠤ ꠛꠦꠝꠣꠞꠦ ꠛꠤꠍꠘꠣꠔ ꠚꠣꠟꠣꠁꠟ ꠀꠍꠟꠣ। ꠙꠣꠃꠟꠥꠍꠦ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠁꠀ ꠖꠥꠀ ꠇꠞꠟꠣ, ꠔꠣꠘ ꠉꠔꠞꠅ ꠀꠔꠣꠁ ꠖꠤꠀ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_9","074_28_9","ACT","28","9","9","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠢꠤ ꠖꠤꠙꠞ ꠎꠔ ꠛꠦꠝꠣꠞꠤ ꠀꠍꠟꠣ, ꠔꠣꠞꠣꠅ ꠀꠁꠀ ꠜꠣꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_10","074_28_10","ACT","28","10","10","ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞꠦ ꠛꠃꠔ ꠟꠣꠈꠣꠘ ꠁꠎ꠆ꠎꠔ ꠇꠞꠟꠣ, ꠛꠤꠖꠣꠄ ꠛꠣꠟꠣ ꠎꠣꠎ ꠍꠣꠠꠣꠞ ꠀꠉꠦ ꠀꠝꠞꠣꠞ ꠖꠞꠇꠣꠞꠤ ꠢꠇꠟ ꠌꠤꠎ ꠎꠥꠉꠣꠁꠀ ꠎꠣꠎꠅ ꠀꠘꠤꠀ ꠜꠞꠤꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_11","074_28_11","ACT","28","11","11","ꠔꠤꠘ ꠝꠣꠡ ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠀꠟꠦꠇꠎꠣꠘꠖ꠆ꠞꠤꠀꠞ ꠄꠇ ꠎꠣꠎꠅ ꠇꠞꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣꠝ। ꠁ ꠎꠣꠎꠈꠣꠘ ꠅꠃ ꠖꠤꠙꠅ ꠞꠁꠀ ꠡꠤꠔꠞ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠍꠤꠟ, ꠄꠞ ꠍꠣꠝꠘꠞ ꠉꠟꠁ ꠈꠥꠖꠤꠀ ꠎꠥꠠ ꠖꠦꠛꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤ ꠟꠣꠉꠣꠁꠟ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("AC28_12","074_28_12","ACT","28","12","12","ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠍꠥꠞꠣꠇꠥꠡꠅ ꠀꠁꠀ ꠔꠤꠘ ꠖꠤꠘ ꠞꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC28_13","074_28_13","ACT","28","13","13","ꠢꠤꠈꠣꠘ ꠕꠣꠇꠤ ꠞꠅꠀꠘꠣ ꠖꠤꠀ ꠊꠥꠞꠤ ꠊꠥꠞꠤ ꠁꠔꠣꠟꠤꠞ ꠞꠤꠎꠤꠅꠔ ꠀꠁꠟꠣꠝ। ꠛꠣꠖꠞ ꠖꠤꠘ ꠖꠃꠇꠘꠞ ꠛꠣꠔꠣꠡ ꠍꠣꠠꠟ, ꠔꠦꠃ ꠖꠥꠍꠞꠣ ꠖꠤꠘ ꠀꠝꠞꠣ ꠙꠥꠔꠤꠅꠟꠤ ꠎꠣꠎ ꠊꠣꠐꠅ ꠀꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC28_14","074_28_14","ACT","28","14","14","ꠢꠤꠘꠅ ꠇꠄꠎꠘ ꠝꠥꠝꠤꠘꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠅꠁꠟ, ꠔꠣꠞꠣ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠣꠄ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠄꠇ ꠢꠣꠙ꠆ꠔꠣ ꠞꠁꠟꠣꠝ। ꠅꠔꠣ ꠇꠞꠤ ꠇꠞꠤ ꠀꠝꠞꠣ ꠞꠥꠝ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠀꠎꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("AC28_15","074_28_15","ACT","28","15","15","ꠞꠥꠝꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠀꠝꠞꠣ ꠀꠅꠀꠞ ꠈꠛꠞ ꠢꠥꠘꠍꠟꠣ, ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠔꠣ ꠇꠞꠤ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠀꠙ꠆ꠙꠤꠅꠞ ꠛꠣꠎꠣꠞ, ꠇꠦꠃ ꠇꠦꠃ ꠔꠤꠘ-ꠡꠞꠣꠁꠈꠣꠘꠣꠞ ꠉꠣꠃ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠉꠥꠀꠁ ꠀꠁꠟꠣ। ꠄꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠙꠣꠃꠟꠥꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ, ꠀꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠛꠟ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_16","074_28_16","ACT","28","16","16","ꠀꠝꠞꠣ ꠞꠥꠝꠅ ꠀꠅꠀꠞ ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠍꠘ꠆ꠖ ꠝꠣꠚꠤꠇ ꠞꠁꠛꠣꠞ ꠅꠘꠥꠝꠔꠤ ꠙꠣꠁꠟꠣ। ꠈꠣꠟꠤ ꠄꠇꠎꠘ ꠍꠤꠙꠣꠁꠄ ꠔꠣꠘꠦ ꠙꠣꠞꠣ ꠖꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("AC28_17","074_28_17","ACT","28","17","17","ꠔꠤꠘꠖꠤꠘ ꠛꠣꠖꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠠ ꠛꠠ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠖꠟꠣ ꠇꠞꠤꠀ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠖꠟꠣ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠅ ꠜꠣꠁꠍꠣꠛ ꠅꠇꠟ, ꠎꠥꠖꠤꠅ ꠀꠝꠤ ꠘꠤꠎꠞ ꠎꠣꠔꠞ ꠛꠣ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠛꠣꠔꠣꠁꠟ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘꠞ ꠃꠟꠐꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠇꠞꠍꠤ ꠘꠣ, ꠔꠣ-ꠅ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠀꠐꠇ ꠇꠞꠤꠀ, ꠞꠥꠝꠣꠘ ꠅꠇꠟꠞ ꠀꠔꠅ ꠡꠝꠎꠣꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("AC28_18","074_28_18","ACT","28","18","18","ꠞꠥꠝꠣꠘ ꠅꠇꠟꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠞꠣ ꠇꠞꠤꠀ ꠝꠃꠔꠞ ꠡꠣꠎꠣ ꠖꠦꠅꠀꠞ ꠎꠥꠇꠣ ꠇꠥꠘꠥ ꠖꠥꠡ ꠘꠣ ꠙꠣꠅꠀꠄ, ꠀꠝꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠖꠤꠟꠣꠁꠔꠣ ꠌꠣꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_19","074_28_19","ACT","28","19","19","ꠅꠁꠟꠦ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠛꠣꠗꠣ ꠖꠦꠅꠀꠄ ꠘꠤꠞꠥꠙꠣꠄ ꠅꠁꠀ ꠀꠝꠤ ꠛꠣꠖꠡꠣꠞ ꠉꠦꠍꠦ ꠀꠙꠤꠟ ꠇꠞꠍꠤ। ꠔꠣ-ꠅ ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠖꠥꠡ ꠖꠤꠔꠣꠝ ꠌꠣꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_20","074_28_20","ACT","28","20","20","ꠔꠦ ꠍꠣꠛ ꠅꠇꠟ, ꠔꠣꠝꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠎꠦ ꠀꠡꠣ ꠀꠍꠦ, ꠢꠃ ꠀꠡꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠣꠞꠦ ꠁ ꠡꠤꠇꠟ ꠚꠤꠘ꠆ꠖꠣꠁꠟ ꠅꠁꠍꠦ, ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠀꠞ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("AC28_21","074_28_21","ACT","28","21","21","ꠔꠣꠞꠣ ꠇꠁꠟꠣ, “ꠀꠝꠞꠣ ꠔ ꠀꠙꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠄꠢꠥꠖꠤꠀ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠌꠤꠑꠤ ꠙꠣꠁꠍꠤ ꠘꠣ। ꠀꠞ ꠎꠦꠔꠣ ꠁꠢꠥꠖꠤ ꠜꠣꠁꠀꠁꠘ ꠢꠘ ꠕꠣꠇꠤ ꠀꠁꠍꠂꠘ, ꠔꠣꠞꠣꠅ ꠀꠙꠘꠣꠞ ꠘꠣꠝꠦ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠛꠣ ꠛꠥꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠍꠂꠘꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_22","074_28_22","ACT","28","22","22","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠀꠙꠘꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠝꠔꠣꠝꠔ ꠢꠥꠘꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ। ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠢꠇꠟ ꠎꠣꠉꠣꠞ ꠝꠣꠘꠡꠦꠃ ꠁ ꠔꠞꠤꠇꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠝꠣꠔꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("AC28_23","074_28_23","ACT","28","23","23","ꠙꠣꠃꠟꠥꠍꠞ ꠟꠉꠦ ꠢꠤꠞꠛꠣꠞ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇ ꠔꠣꠞꠤꠈ ꠑꠤꠇ ꠇꠞꠟꠣ। ꠢꠃ ꠖꠤꠘ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠙꠣꠃꠟꠥꠍꠞ ꠊꠞꠅ ꠀꠁꠟꠣ। ꠙꠣꠃꠟꠥꠍꠦ ꠚꠎꠞ ꠕꠣꠇꠤ ꠢꠣꠁꠘ꠆ꠎꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠣꠞꠣꠖꠤꠘ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠇꠕꠣ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠜꠣꠋꠉꠤꠀ ꠛꠄꠀꠘ ꠇꠞꠟꠣ। ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠤꠔꠣꠛꠞ ꠀꠄꠀꠔ ꠖꠦꠈꠣꠁꠀ, ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠄꠇꠤꠘ ꠎꠘꠝꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_24","074_28_24","ACT","28","24","24","ꠔꠣꠘ ꠛꠄꠀꠘ ꠢꠥꠘꠤꠀ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ, ꠀꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠁꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("AC28_25","074_28_25","ACT","28","25","25","ꠛꠄꠀꠘ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠝꠔꠞ ꠅꠝꠤꠟ ꠅꠁꠉꠦꠟ, ꠔꠣꠞꠣ ꠢꠤꠈꠣꠘ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠅꠁꠔꠣ ꠌꠣꠁꠟꠣ। ꠎꠣꠅꠀꠞ ꠀꠉꠦ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠣꠞꠣꠞꠦ ꠈꠣꠟꠤ ꠅꠃ ꠘꠍꠤꠅꠔꠈꠣꠘ ꠇꠞꠟꠣ, “ꠙꠣꠇ ꠞꠥꠢꠦ ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠞ ꠎꠞꠤꠀꠄ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠅꠇꠟꠞꠦ ꠅꠃ ꠇꠕꠣꠈꠣꠘ ꠑꠤꠇꠃ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("AC28_26","074_28_26","ACT","28","26","26","ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟꠞ ꠇꠣꠍꠣꠔ ꠉꠤꠀ ꠇꠅ, ꠔꠥꠝꠞꠣ ꠇꠣꠘꠦ ꠢꠥꠘꠟꠦꠅ ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠔꠣꠄ ꠘꠣꠄ, ꠌꠃꠈꠦ ꠖꠦꠈꠟꠦꠅ ꠇꠥꠘ꠆ꠔꠣ ꠌꠤꠘꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("AC28_27","074_28_27","ACT","28","27","27","ꠇꠣꠞꠘ ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠖꠤꠟ ꠅꠡꠣꠠ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠞꠣꠞ ꠇꠣꠘꠅ ꠔꠣꠟꠣ ꠟꠣꠉꠤꠉꠦꠍꠦ, ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠌꠃꠈ ꠝꠥꠎꠤ ꠛꠁꠞꠁꠍꠦ। ꠎꠣꠔꠦ ꠌꠃꠈꠦ ꠘꠣ ꠖꠦꠈꠦ, ꠇꠣꠘꠦ ꠘꠣ ꠢꠥꠘꠦ, ꠖꠤꠟ ꠖꠤꠀ ꠘꠣ ꠛꠥꠎꠦ, ꠇꠤꠎꠣꠘꠥ ꠔꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠤꠀ, ꠀꠝꠣꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠎꠣꠁꠘ, ꠀꠞ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠤꠟꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("AC28_28","074_28_28","ACT","28","28","29","ꠄꠞꠟꠣꠉꠤ ꠀꠙꠘꠣꠞꠣꠅ ꠎꠣꠘꠤꠀ ꠞꠣꠈꠃꠇ꠆ꠇꠣ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠁ ꠘꠣꠎꠣꠔꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠛ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠈꠥꠡ ꠅꠁꠀ ꠢꠥꠘꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("AC28_30","074_28_30","ACT","28","30","30","ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍ ꠙꠥꠞꠣ ꠖꠥꠁ ꠛꠞꠍ ꠗꠞꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠜꠣꠠꠣ ꠇꠞꠣ ꠛꠣꠡꠣꠔ ꠞꠁꠟꠣ। ꠀꠞ ꠎꠔ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠤꠀ, ");
INSERT INTO syls_vpl VALUES ("AC28_31","074_28_31","ACT","28","31","31","ꠙꠥꠞꠣꠙꠥꠞ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣ। ꠀꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠤꠘꠣ ꠛꠣꠗꠣꠄ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠔꠣ॥");
INSERT INTO syls_vpl VALUES ("RM1_1","075_1_1","ROM","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ ꠔ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠥꠟꠣꠝ। ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠁꠞ ꠞꠣꠎꠗꠣꠘꠤ ꠞꠥꠝ ꠐꠣꠃꠘꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠅꠃ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠝꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠞ ꠔꠣꠘ ꠛꠣꠔꠣꠁꠟ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RM1_2","075_1_2","ROM","1","2","2","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤ ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠝꠣꠎꠦ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠇꠕꠣ ꠀꠉꠦꠃ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM1_3","075_1_3","ROM","1","3","4","ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠅꠁꠟ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ। ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ। ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠍꠤꠟꠍꠤꠟꠣꠄ ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠢꠎꠞꠔ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠀꠅꠟꠣꠖ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠥꠖꠞꠔꠤꠄ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠎꠣꠁꠞ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM1_5","075_1_5","ROM","1","5","5","ꠔꠣꠘ ꠘꠣꠝ ꠃꠎꠤꠟꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠘ ꠝꠣꠎꠖꠤꠃ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠤꠀꠝꠔ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠙꠖ ꠙꠣꠁꠍꠤ, ꠎꠣꠔꠦ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠁꠖ꠆ꠖ ꠅꠁꠀ ꠌꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("RM1_6","075_1_6","ROM","1","6","6","ꠅꠃ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠅ ꠀꠍ। ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠙꠘ ꠎꠘ ꠅꠀꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RM1_7","075_1_7","ROM","1","7","7","ꠔꠦ ꠅꠃ ꠞꠥꠝ ꠐꠣꠃꠘꠅ ꠀꠟ꠆ꠟꠣꠞ ꠎꠔ ꠝꠣꠄꠀꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠀꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠅꠃ ꠌꠤꠑꠤꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("RM1_8","075_1_8","ROM","1","8","8","ꠀꠝꠤ ꠙꠄꠟꠣꠃ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠎꠛꠥꠔ ꠁꠝꠣꠘꠞ ꠇꠕꠣ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠁꠞ ꠝꠣꠎꠦ ꠞꠐꠤꠉꠦꠍꠦ ꠇꠞꠤ, ꠀꠝꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM1_9","075_1_9","ROM","1","9","9","ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ, ꠀꠝꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠞꠣꠝ। ꠄꠇ ꠀꠟ꠆ꠟꠣꠃ ꠡꠣꠇ꠆ꠇꠤ ꠀꠍꠂꠘ, ꠀꠝꠤ ꠙꠞꠔꠦꠇ ꠛꠣꠞ ꠝꠥꠘꠣꠎꠣꠔꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM1_10","075_1_10","ROM","1","10","10","ꠀꠝꠤ ꠢꠣꠝꠦꠡꠣ ꠅꠃ ꠇꠕꠣ ꠝꠣꠉꠤꠞꠣꠝ, ꠅꠔꠖꠤꠘ ꠛꠣꠖꠦ ꠅꠁꠟꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤꠄ ꠎꠦꠇꠥꠘꠥ ꠝꠘ꠆ꠔꠦ ꠀꠝꠤ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM1_11","075_1_11","ROM","1","11","11","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠎꠣꠔꠦ ꠞꠥꠢꠣꠘꠤ ꠇꠥꠘꠥ ꠘꠤꠀꠝꠔ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠟꠛꠣꠘ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM1_12","075_1_12","ROM","1","12","12","ꠝꠣꠘꠤ, ꠀꠝꠣꠞ ꠁꠝꠣꠘ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠘꠤꠎꠦꠅ ꠃꠔꠡꠣꠢ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM1_13","075_1_13","ROM","1","13","13","ꠅ ꠜꠣꠁꠀꠁꠘ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠛꠃꠔ ꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠣꠝ ꠌꠣꠁꠍꠤ, ꠅꠁꠟꠦ ꠛꠣꠞ ꠛꠣꠞ ꠛꠣꠗꠣ ꠀꠁꠍꠦ। ꠘꠣꠘꠣꠘ ꠎꠣꠉꠣꠔ ꠉꠤꠀ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠎꠦꠟꠣ ꠚꠟ ꠙꠣꠁꠍꠤ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦꠅ ꠅꠟꠣ ꠚꠟ ꠖꠦꠈꠣꠞ ꠀꠡꠣꠄ ꠀꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM1_14","075_1_14","ROM","1","14","14","ꠜꠖ꠆ꠞ ꠁꠃꠘꠣꠘꠤ ꠎꠣꠔꠤ ꠛꠣ ꠅꠜꠖ꠆ꠞ ꠛꠞꠛꠞ ꠎꠣꠔꠤ, ꠡꠤꠇ꠆ꠇꠤꠔ ꠛꠣ ꠅꠡꠤꠇ꠆ꠇꠤꠔ, ꠢꠇꠟꠞ ꠟꠣꠉꠤꠃ ꠔ ꠀꠝꠣꠞ ꠄꠇ ꠢꠝꠣꠘ ꠖꠣꠄ-ꠜꠣꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM1_15","075_1_15","ROM","1","15","15","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠞꠥꠝ ꠐꠣꠃꠘꠅ ꠛꠡꠔ ꠇꠞꠞꠣꠄ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦꠅ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("RM1_16","075_1_16","ROM","1","16","16","ꠇꠣꠞꠘ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠦ ꠀꠝꠤ ꠇꠥꠘꠥ ꠡꠞꠝ ꠝꠘꠅ ꠇꠞꠤ ꠘꠣ, ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠢꠥꠘꠤꠀ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠔꠣꠞꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠐꠣ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠁ ꠛꠟ। ꠙꠄꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣ ꠄꠇ ꠀꠟ꠆ꠟꠣ ꠝꠣꠘꠂꠘ, ꠛꠣꠖꠦ ꠛꠦ-ꠖꠤꠘ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RM1_17","075_1_17","ROM","1","17","17","ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠝꠣꠎꠦꠃ ꠔ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠤꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠂꠘ। ꠈꠣꠟꠤ ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤꠃ ꠝꠣꠘꠡꠞꠦ ꠀꠃꠀꠟ ꠕꠣꠇꠤ ꠀꠈꠦꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠄ। ꠎꠦꠟꠣ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠅꠀ ꠎꠘꠞ ꠎꠣꠘ ꠛꠣꠌꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("RM1_18","075_1_18","ROM","1","18","18","ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞꠦ ꠟꠥꠇꠣꠁꠀ ꠞꠣꠈꠦ। ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠒꠞ-ꠈꠚ ꠘꠣ ꠕꠣꠇꠣꠄ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠘꠣꠎꠤꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("RM1_19","075_1_19","ROM","1","19","19","ꠀꠟ꠆ꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠔꠈꠣꠘ ꠛꠥꠎꠣꠞ ꠔꠣꠇ꠆ꠇꠔ ꠀꠍꠦ ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠙꠞꠤꠡ꠆ꠇꠣꠞ, ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦꠃ ꠔ ꠁꠔꠣ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM1_20","075_1_20","ROM","1","20","20","ꠔꠣꠘ ꠎꠦꠔꠣ ꠉꠥꠘꠣꠉꠥꠘ ꠝꠣꠘꠡꠞ ꠀ-ꠖꠦꠈꠣ, ꠝꠣꠘꠤ ꠔꠣꠘ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠈꠦꠝꠔꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠡ꠆ꠛꠜꠣꠛ, ꠁꠔꠣ ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠅꠀꠞ ꠀꠉ ꠕꠣꠇꠤꠃ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠚꠥꠐꠤꠀ ꠃꠑꠍꠦ। ꠔꠣꠘ ꠙꠄꠖꠣ ꠇꠞꠣ ꠎꠤꠘꠤꠡ ꠖꠦꠈꠟꠦꠃ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠛꠥꠎꠔ ꠙꠣꠞꠦ। ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠤ ꠘꠣ ꠇꠁꠀ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠜꠣꠘꠣ ꠖꠦꠈꠣꠘꠤꠞ ꠃꠙꠣꠄ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM1_21","075_1_21","ROM","1","21","21","ꠀꠟ꠆ꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠔꠔꠣ ꠎꠣꠘꠣꠞ ꠛꠣꠖꠦꠅ ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠀꠟ꠆ꠟꠣ ꠜꠣꠛꠤꠀ ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠀꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞꠤ ꠘꠣ ꠇꠞꠣꠄ, ꠔꠣꠞꠣꠞ ꠛꠤꠌꠣꠞ-ꠛꠤꠛꠦꠇ ꠅꠡꠣꠞ ꠅꠁꠉꠦꠍꠦ ꠀꠞ ꠛꠦꠀꠈꠟ ꠝꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM1_22","075_1_22","ROM","1","22","22","ꠎꠥꠖꠤꠅ ꠔꠣꠞꠣ ꠘꠤꠎꠞꠦ ꠀꠈꠟꠖꠣꠞ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠀꠍꠟꠦ ꠔꠣꠞꠣ ꠛꠦꠀꠈꠟ। ");
INSERT INTO syls_vpl VALUES ("RM1_23","075_1_23","ROM","1","23","23","ꠔꠣꠞꠣ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠛꠣꠖ ꠖꠤꠀ ꠅꠡ꠆ꠕꠣꠄꠁ ꠝꠣꠘꠥꠡ, ꠙꠡꠥ-ꠙꠣꠈꠤ, ꠀꠞ ꠛꠥꠇꠦ ꠌꠟꠞꠣ ꠎꠣꠘꠖꠣꠞꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠁꠀ ꠅꠔꠣꠞ ꠙꠥꠎꠣ ꠇꠞꠍꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠅꠘꠣ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣ ꠅꠔꠣꠞꠦ ꠖꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM1_24","075_1_24","ROM","1","24","24","ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦꠅ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡ ꠝꠣꠚꠤꠇ, ꠔꠣꠞꠣꠞꠦ ꠘꠚꠞꠔꠤ ꠇꠣꠝꠞ ꠀꠔꠅ ꠍꠣꠠꠤ ꠖꠤꠍꠂꠘ, ꠅꠔꠣꠞ ꠖꠣꠄ ꠔꠣꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠟꠉꠦ ꠛꠖꠝꠣꠁꠡꠤ-ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("RM1_25","075_1_25","ROM","1","25","25","ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠞꠦ ꠛꠣꠖ ꠖꠤꠀ ꠝꠤꠍꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠦ। ꠙꠄꠖꠣ ꠇꠞꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠛꠣꠖ ꠖꠤꠀ, ꠔꠣꠘ ꠙꠄꠖꠣ ꠇꠞꠣ ꠎꠤꠘꠤꠡꠞ ꠙꠥꠎꠣ ꠇꠞꠍꠦ। ꠅꠁꠟꠦ ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠌꠤꠞꠇꠣꠟ ꠢꠇꠟ ꠔꠣꠞꠤꠚ ꠄꠇꠝꠣꠔ꠆ꠞ ꠙꠄꠖꠣ ꠇꠞꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠃ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("RM1_26","075_1_26","ROM","1","26","26","ꠝꠣꠘꠡꠦ ꠅꠟꠣꠈꠣꠘ ꠘꠚꠞꠔꠤ ꠇꠣꠝ ꠇꠞꠦꠞ ꠖꠦꠈꠤꠀ, ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠣꠞꠣꠞꠦ ꠅꠃ ꠛꠖ ꠈꠣꠁꠡꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠍꠂꠘ। ꠅꠔꠣꠞ ꠛꠦꠐꠤꠘ꠆ꠔꠦꠅ ꠎꠣꠝꠣꠁꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠛꠣꠖ ꠖꠤꠀ ꠅꠁꠘ꠆ꠘ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠈꠛꠤꠍꠤ ꠇꠣꠝ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM1_27","075_1_27","ROM","1","27","27","ꠅꠃꠟꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦꠅ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠛꠣꠖ ꠖꠤꠀ ꠅꠁꠘ꠆ꠘ ꠛꠦꠐꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣꠞ ꠟꠣꠉꠤ ꠙꠣꠉꠟ ꠅꠁꠉꠦꠍꠦ, ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠈꠛꠤꠍꠤ ꠇꠣꠝ ꠇꠞꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠙꠞꠔꠦꠇꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠎꠣꠞꠎꠤꠞ ꠛꠖ ꠇꠣꠝꠞ ꠡꠣꠎꠣ ꠙꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM1_28","075_1_28","ROM","1","28","28","ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠝꠣꠘꠦꠞ ꠘꠣ ꠖꠦꠈꠤꠀ, ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠣꠞꠣꠞꠦ ꠅꠟꠣ ꠛꠖ ꠈꠣꠁꠡꠞ ꠈꠛꠤꠍꠤ ꠖꠤꠟꠞ ꠀꠔꠅ ꠍꠣꠠꠤ ꠖꠤꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠅꠔꠣ ꠇꠞꠣꠔ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("RM1_29","075_1_29","ROM","1","29","29","ꠔꠣꠞꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ, ꠛꠖ ꠇꠣꠝ, ꠟꠥꠜ-ꠟꠣꠟꠌ, ꠁꠋꠡꠣ-ꠘꠤꠘ꠆ꠖꠣ, ꠈꠥꠘ-ꠈꠣꠞꠣꠙꠤ, ꠝꠣꠞꠣ-ꠝꠣꠞꠤ, ꠍꠟ-ꠌꠔꠥꠞꠤ ꠀꠞ ꠇꠣꠘꠣ-ꠇꠣꠘꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠃꠡ꠆ꠔꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("RM1_30","075_1_30","ROM","1","30","30","ꠔꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠤꠛꠔ ꠉꠣꠄ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ। ꠔꠣꠞꠣ ꠛꠖ-ꠝꠤꠎꠣꠎꠤ, ꠅꠢꠋꠇꠣꠞꠤ, ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠀꠞ ꠘꠄꠀ ꠘꠄꠀ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠗꠣꠘ꠆ꠖꠣꠄ ꠕꠣꠇꠦ। ꠔꠣꠞꠣ ꠝꠣ-ꠛꠣꠚꠞꠅ ꠅꠛꠣꠁꠖ꠆ꠖ। ");
INSERT INTO syls_vpl VALUES ("RM1_31","075_1_31","ROM","1","31","31","ꠘꠦꠇꠤ-ꠛꠖꠤ ꠛꠥꠎꠣꠞ ꠀꠈꠟ ꠘꠣꠁ, ꠅꠀꠖꠣ ꠈꠦꠟꠣꠚꠇꠣꠞꠤ, ꠙꠣꠡꠣꠘ, ꠁꠔꠣꠞ ꠖꠤꠟꠅ ꠇꠥꠘꠥ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM1_32","075_1_32","ROM","1","32","32","ꠔꠣꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠁ ꠛꠤꠌꠣꠞꠞ ꠇꠕꠣ ꠜꠣꠟꠣ ꠇꠞꠤꠃ ꠎꠣꠘꠦ, ꠎꠦꠞꠣ ꠁꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠡꠣꠎꠣ ꠅꠁꠛ ꠝꠃꠔ। ꠁꠈꠣꠘ ꠎꠣꠘꠤꠀꠅ, ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠘꠤꠎꠦ ꠁꠔꠣ ꠇꠞꠦ ꠘꠣ, ꠛꠣꠇꠤ ꠎꠦꠞꠣ ꠁꠟꠣ ꠇꠣꠝ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠙꠇ꠆ꠇꠦꠅ ꠡꠣꠄ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("RM2_1","075_2_1","ROM","2","1","1","ꠄꠞꠟꠣꠉꠤꠃ ꠇꠁꠞꠣꠝ, ꠅ ꠝꠣꠘꠥꠡ ꠎꠣꠔꠤ, ꠔꠥꠝꠤ ꠔ ꠅꠁꠘ꠆ꠘ ꠎꠘꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠞꠣꠄ, ꠁꠔꠣ ꠛꠤꠌꠣꠞ ꠔꠥꠝꠤ ꠢꠤꠇꠟꠣꠄ ꠇꠤꠟꠣ? ꠔꠥꠝꠣꠞ ꠎꠥꠀꠙ ꠖꠤꠛꠣꠞ ꠇꠥꠘꠥ ꠙꠕ ꠀꠍꠦ ꠘꠤ? ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠘꠤꠎꠦ ꠎꠦ ꠅꠙꠞꠣꠗ ꠇꠞꠞꠣꠄ, ꠅꠃ ꠄꠇꠁ ꠅꠙꠞꠣꠗꠦ ꠔꠥꠝꠤ ꠀꠞꠇ ꠎꠘꠞꠦ ꠖꠥꠡꠤ ꠇꠁꠞꠣꠄ। ꠔꠦ ꠁ ꠖꠥꠡ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦꠅ ꠙꠠꠦꠞ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM2_2","075_2_2","ROM","2","2","2","ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠎꠦꠞꠣ ꠁꠟꠣꠈꠣꠘ ꠅꠙꠞꠣꠗ ꠇꠞꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠢꠇ ꠁꠘꠍꠣꠚ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM2_3","075_2_3","ROM","2","3","3","ꠅ ꠝꠣꠘꠥꠡ ꠎꠣꠔꠤ, ꠎꠦ ꠇꠣꠝ ꠔꠥꠝꠤ ꠘꠤꠎꠦꠅ ꠇꠞ, ꠅꠃ ꠄꠇꠁ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠀꠞꠇ ꠎꠘꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠅ, ꠔꠦ ꠇꠦꠝꠘꠦ ꠛꠥꠎꠟꠣꠄ, ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠎꠣ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠟꠤꠛꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("RM2_4","075_2_4","ROM","2","4","4","ꠔꠥꠝꠤ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠅꠡꠦꠡ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ, ꠔꠣꠘ ꠗꠂꠞ꠆ꠎ-ꠡꠇ꠆ꠔꠤ ꠀꠞ ꠍꠛꠞꠉꠣꠞꠤꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠞꠣꠄ। ꠔꠣꠘ ꠝꠦꠢꠦꠞꠛꠣꠘꠤꠄ ꠔꠥꠝꠣꠞꠦ ꠈꠣꠟꠤ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠤꠀ ꠘꠦꠄ, ꠁꠈꠣꠘ ꠚꠣꠃꠞꠤꠟꠤꠍ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM2_5","075_2_5","ROM","2","5","5","ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠙꠣꠡꠣꠘ ꠖꠤꠟ ꠀꠞ ꠔꠃꠛꠣ ꠘꠣ ꠇꠞꠣꠞ ꠝꠘꠜꠣꠛꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛ ꠖꠟꠣ ꠇꠞꠤ ꠕꠁꠞꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠖꠤꠘ ꠉꠎꠛ ꠎꠣꠁꠞ ꠇꠞꠛꠣ, ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ, ꠢꠃ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠡꠣꠎꠣ ꠖꠟꠣ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM2_6","075_2_6","ROM","2","6","6","ꠔꠣꠁꠘ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠇꠣꠝꠞ ꠚꠟ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM2_7","075_2_7","ROM","2","7","7","ꠎꠦꠞꠣ ꠗꠂꠎ꠆ꠎ ꠗꠞꠤꠀ ꠘꠦꠇ ꠇꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠁ ꠔꠣꠞꠤꠚ, ꠁꠎ꠆ꠎꠔ, ꠀꠞ ꠇ꠆ꠇꠄꠢꠤꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦꠃ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM2_8","075_2_8","ROM","2","8","8","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠘꠤꠎꠞ ꠈꠣꠁꠡꠞ ꠛꠡꠦ ꠌꠟꠦ, ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠞꠄ, ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠙꠇ꠆ꠇꠦ ꠕꠣꠇꠦ, ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠁ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ, ꠉꠎꠛ ꠀꠞ ꠟꠣꠘ꠆ꠘꠔ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM2_9","075_2_9","ROM","2","9","9","ꠙꠞꠔꠦꠇ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠃꠙꠞꠦ ꠁꠔꠣ ꠀꠁꠛ, ꠙꠄꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠃꠙꠞꠦ, ꠛꠣꠖꠦ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("RM2_10","075_2_10","ROM","2","10","10","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠦ, ꠔꠣꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠔꠣꠞꠤꠚ, ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠙꠣꠁꠛ। ꠙꠄꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ, ꠛꠣꠖꠦ ꠜꠤꠘ ꠎꠣꠔꠤꠄ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM2_11","075_2_11","ROM","2","11","11","ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔ ꠙꠇ꠆ꠇꠙꠣꠔꠤꠞ ꠇꠥꠘꠥ ꠇꠣꠞꠛꠣꠞ ꠘꠣꠁ, ꠢꠇꠟꠃ ꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RM2_12","075_2_12","ROM","2","12","12","ꠡꠞꠤꠅꠔꠞ ꠛꠣꠁꠞꠦ ꠞꠁꠀ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠉꠥꠘꠣ ꠇꠞꠍꠦ, ꠔꠣꠞꠣ ꠛꠤꠘꠣꠡꠅ ꠅꠁꠛꠣ ꠡꠞꠤꠅꠔ ꠍꠣꠠꠣ, ꠀꠞ ꠡꠞꠤꠅꠔꠞ ꠜꠤꠔꠞꠦ ꠞꠁꠀ ꠎꠦꠞꠣ ꠉꠥꠘꠣ ꠇꠞꠦ, ꠅꠃ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇꠃ ꠔꠣꠞꠣꠞ ꠛꠤꠌꠣꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM2_13","075_2_13","ROM","2","13","13","ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠡꠞꠤꠅꠔꠞ ꠛꠄꠀꠘ ꠈꠣꠟꠤ ꠢꠥꠘꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠔ ꠔꠣꠞꠣ ꠛꠦ-ꠇꠍꠥꠞ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠦ, ꠔꠣꠞꠣꠃ ꠈꠣꠟꠤ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM2_14","075_2_14","ROM","2","14","14","ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠦ ꠀꠟ꠆ꠟꠣꠁ ꠇꠥꠘꠥ ꠡꠞꠤꠅꠔ ꠘꠣ ꠙꠣꠁꠟꠦꠅ, ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠄꠝꠘꠦꠃ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠌꠟꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠛꠤꠛꠦꠇꠃ ꠡꠞꠤꠅꠔ ꠛꠘꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM2_15","075_2_15","ROM","2","15","15","ꠄꠔꠦ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠎꠦꠔꠣ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠁꠔꠣ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠛꠤꠛꠦꠇꠞ ꠝꠣꠎꠦ ꠟꠦꠈꠣ ꠀꠍꠦ। ꠔꠣꠞꠣꠞ ꠛꠤꠛꠦꠇꠦ ꠔꠣꠞꠣꠞ ꠇꠣꠝꠞ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠄ, ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠛꠤꠛꠦꠇꠦ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠦ, ꠀꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠡꠝꠄ ꠔꠣꠞꠣꠞ ꠙꠇ꠆ꠇꠦꠅ ꠡꠣꠄ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("RM2_16","075_2_16","ROM","2","16","16","ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠖꠤꠘ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠟꠥꠇꠣꠁꠟ ꠀꠝꠟꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ, ꠢꠃ ꠖꠤꠘꠃ ꠁꠔꠣ ꠎꠣꠁꠞ ꠅꠁꠛ। ꠀꠞ ꠀꠝꠤ ꠅꠈꠘ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀꠞ, ꠅꠃ ꠝꠣꠚꠤꠇꠃ ꠛꠤꠌꠣꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM2_17","075_2_17","ROM","2","17","17","ꠔꠥꠝꠤ ꠎꠦꠛꠟꠣ ꠘꠤꠎꠞ ꠙꠞꠤꠌꠄ ꠖꠤꠞꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠇꠁꠀ, ꠔꠥꠝꠤ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠞꠣꠄ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠄꠀꠞ ꠛꠘ꠆ꠖꠣ ꠇꠁꠀ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM2_18","075_2_18","ROM","2","18","18","ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠤꠔꠣ ꠀꠡꠣ ꠇꠞꠂꠘ, ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠄ, ꠁꠈꠣꠘ ꠔ ꠔꠥꠝꠤ ꠎꠣꠘꠃ, ꠡꠞꠤꠅꠔ ꠕꠣꠇꠤ ꠔꠥꠝꠤ ꠁꠔꠣꠞ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("RM2_19","075_2_19","ROM","2","19","19","ꠔꠥꠝꠤ ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠞꠣꠄ, ꠀꠝꠤ ꠔ ꠀꠘ꠆ꠖꠣꠞꠦ ꠙꠕ ꠖꠦꠈꠣꠁꠀꠞ, ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠎꠦꠔꠣ ꠀꠍꠂꠘ, ꠁꠔꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠘꠥꠞꠞ ꠞꠥꠡꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("RM2_20","075_2_20","ROM","2","20","20","ꠛꠦꠀꠈꠟꠞꠦ ꠢꠦꠖꠣꠄꠅꠔ ꠇꠞꠤꠀꠞ, ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠀꠞ। ꠔꠥꠝꠤ ꠛꠥꠎꠞꠣꠄ, ꠡꠞꠤꠅꠔꠞ ꠜꠤꠔꠞꠦ ꠢꠇ ꠀꠞ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM2_21","075_2_21","ROM","2","21","21","ꠁꠔꠣ ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠕꠣ, ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠎꠦꠛꠟꠣ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞꠦ ꠢꠤꠇꠣꠁꠞꠣꠄ, ꠔꠦ ꠘꠤꠎꠦꠅ ꠁꠔꠣ ꠢꠤꠇ ꠘꠣ ꠇꠦꠘꠦ? ꠔꠥꠝꠤ ꠝꠣꠘꠡꠞꠦ ꠇꠁꠞꠣꠄ, ꠌꠥꠞꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠘꠤꠎꠦꠃ ꠌꠥꠞꠤ ꠇꠞꠞꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM2_22","075_2_22","ROM","2","22","22","ꠝꠣꠘꠡꠞꠦ ꠇꠁꠞꠣꠄ, ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠘꠤꠎꠦ ꠇꠥꠘꠥ ꠎꠤꠘꠣ ꠇꠞꠞꠣꠄ ꠘꠣ ꠘꠤ? ꠔꠥꠝꠤ ꠔ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠝꠥꠞ꠆ꠔꠤꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠞꠣꠄ, ꠢꠤꠞꠛꠣꠞ ꠘꠤꠎꠦꠃ ꠝꠥꠞ꠆ꠔꠤꠞ ꠝꠘ꠆ꠖꠤꠞꠞꠦ ꠟꠥꠐ-ꠔꠞꠣꠎ ꠇꠞꠞꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM2_23","075_2_23","ROM","2","23","23","ꠎꠦ ꠡꠞꠤꠅꠔ ꠟꠁꠀ ꠔꠥꠝꠤ ꠛꠠꠣꠁ ꠇꠞꠞꠣꠄ, ꠁ ꠡꠞꠤꠅꠔꠞ ꠃꠟꠐꠣ ꠌꠟꠤꠀ ꠔꠥꠝꠤ ꠘꠤꠎꠦꠃ ꠀꠟ꠆ꠟꠣꠞꠦ ꠅꠡꠝ꠆ꠝꠣꠘ ꠇꠞꠞꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM2_24","075_2_24","ROM","2","24","24","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, “ꠔꠥꠝꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠖꠦꠈꠤꠀ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠞꠦ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("RM2_25","075_2_25","ROM","2","25","25","ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠤꠀ ꠌꠟꠅ, ꠔꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠖꠣꠝ ꠀꠍꠦ, ꠀꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠘꠣ ꠌꠟꠟꠦ, ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟꠦꠅ ꠎꠦꠔꠣ, ꠘꠣ ꠇꠞꠣꠁꠟꠦꠅ ꠅꠔꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠔꠥꠝꠤ ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠣꠁꠟ ꠛꠦ-ꠖꠤꠘꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RM2_26","075_2_26","ROM","2","26","26","ꠅꠈꠘ ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠣꠁꠀꠅ ꠎꠥꠖꠤ ꠇꠦꠃ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠤꠀ ꠌꠟꠦ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ ꠇꠁꠀ ꠡꠝꠎꠤꠔꠣ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM2_27","075_2_27","ROM","2","27","27","ꠀꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠣꠁꠟ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠤꠀ ꠌꠟꠦ, ꠔꠦ ꠟꠤꠈꠤꠔ ꠡꠞꠤꠅꠔ ꠙꠣꠁꠀ ꠀꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠀꠅ ꠎꠥꠖꠤ ꠔꠥꠝꠤ ꠄꠞ ꠃꠟꠐꠣ ꠌꠟꠅ, ꠔꠣꠁꠟꠦ ꠢꠃ ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠣꠁꠟ ꠛꠦꠐꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠖꠥꠡꠤꠔ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM2_28","075_2_28","ROM","2","28","28","ꠛꠤꠡꠄꠐꠣ ꠛꠥꠎꠞꠣꠄ ꠘꠤ? ꠈꠣꠟꠤ ꠘꠣꠝꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠁꠟꠦꠃ ꠇꠦꠃ ꠀꠍꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠘꠣꠄ। ꠡꠞꠤꠟꠞ ꠅꠋꠉ ꠇꠣꠐꠤꠀ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟꠦꠅ ꠔ, ꠀꠍꠟ ꠝꠍꠟꠝꠣꠘꠤ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM2_29","075_2_29","ROM","2","29","29","ꠅꠁꠟꠦ ꠝꠘ ꠕꠣꠇꠤ ꠎꠦꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ, ꠔꠣꠞꠣꠃ ꠀꠍꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ। ꠁꠔꠣ ꠇꠥꠘꠥ ꠟꠤꠈꠤꠔ ꠀꠁꠘ-ꠇꠣꠘꠥꠘꠞ ꠛꠦꠙꠣꠞ ꠘꠣꠄ, ꠖꠤꠟꠞ ꠜꠤꠔꠞꠞ ꠞꠥꠢꠣꠘꠤ ꠛꠦꠙꠣꠞ। ꠖꠤꠟꠞ ꠝꠍꠟꠝꠣꠘꠤꠃ ꠅꠁꠟ ꠀꠍꠟ ꠝꠍꠟꠝꠣꠘꠤ। ꠎꠉꠔꠞ ꠝꠣꠘꠡꠦ ꠄꠞꠣꠞ ꠔꠣꠞꠤꠚ ꠘꠣ ꠇꠞꠟꠦꠅ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠤꠚ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM3_1","075_3_1","ROM","3","1","1","ꠔꠦ ꠁꠟꠣꠈꠣꠘ ꠛꠦꠙꠣꠞ ꠅꠁꠟꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠀꠄ ꠛꠣꠠꠔꠤ ꠇꠥꠘꠥ ꠟꠣꠜ ꠀꠍꠦ ꠘꠤ? ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠔ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠀꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM3_2","075_3_2","ROM","3","2","2","ꠘꠤꠌ꠆ꠌꠄ ꠀꠍꠦ। ꠛꠃꠔ ꠘꠝꠥꠘꠣꠞ ꠚꠣꠄꠖꠣ ꠀꠍꠦ। ꠙꠄꠟꠣ ꠚꠣꠄꠖꠣ: ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠣꠘ ꠢꠇ꠆ꠇꠟ ꠇꠣꠟꠣꠝ ꠘꠣꠎꠤꠟ ꠇꠞꠍꠂꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM3_3","075_3_3","ROM","3","3","3","ꠅꠛꠁꠡ꠆ꠡ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠍꠦ, ꠄꠔꠦ ꠇꠤꠔꠣ ꠅꠁꠍꠦ? ꠔꠣꠞꠣ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠟꠦꠅ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠇꠥꠘꠥ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠁꠝꠣꠘꠤ ꠇꠞꠛꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM3_4","075_3_4","ROM","3","4","4","ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ! ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠝꠤꠍꠣ ꠝꠣꠔꠟꠦꠅ ꠀꠟ꠆ꠟꠣ ꠔ ꠢꠣꠝꠦꠡꠣ ꠢꠇ ꠕꠣꠇꠂꠘ। ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠍꠦ: ꠄꠞꠛꠣꠖꠦꠅ ꠙꠞꠝꠣꠘ ꠝꠤꠟꠛ ꠔꠥꠝꠣꠞ ꠎꠛꠣꠘ ꠡꠑꠤꠇ, ꠔꠥꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠞꠣꠄ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM3_5","075_3_5","ROM","3","5","5","ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠘꠡꠦ ꠇꠁꠔ ꠙꠣꠞꠦ, ꠀꠝꠞꠣꠞ ꠘꠣ-ꠢꠇ ꠇꠣꠝꠦ ꠎꠦꠛꠟꠣ ꠀꠞꠅ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠛꠥꠎꠣ ꠎꠣꠄ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠇꠔ ꠢꠇ, ꠔꠦ ꠀꠝꠞꠣꠞ ꠘꠣ-ꠢꠇꠦ ꠔꠣꠘ ꠉꠃꠞꠛ ꠅꠀꠞ ꠛꠣꠖꠦꠅ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠟꠦ ꠁꠔꠣ ꠔꠣꠘ ꠅꠁꠘ꠆ꠘꠣꠄ? ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM3_6","075_3_6","ROM","3","6","6","ꠀꠟ꠆ꠟꠣꠄ ꠎꠥꠖꠤ ꠢꠇ ꠁꠘꠍꠣꠚ ꠘꠣ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠣꠁꠘ ꠇꠤꠟꠣ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ? ");
INSERT INTO syls_vpl VALUES ("RM3_7","075_3_7","ROM","3","7","7","ꠔꠣꠞꠣ ꠇꠂꠘ, “ꠀꠝꠣꠞ ꠝꠤꠍꠣ ꠝꠣꠔꠞ ꠝꠣꠎꠖꠤꠃ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠢꠇ-ꠁꠘꠍꠣꠚꠇꠣꠞꠤ। ꠀꠞ ꠀꠝꠣꠞ ꠝꠤꠍꠣ ꠝꠣꠔꠦ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ-ꠔꠣꠞꠤꠚ ꠅꠄ, ꠔꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠉꠥꠘꠣꠉꠣꠞ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠂꠘ ꠇꠦꠘꠦ?” ");
INSERT INTO syls_vpl VALUES ("RM3_8","075_3_8","ROM","3","8","8","ꠁꠈꠣꠘ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠎꠥꠇ꠆ꠔꠤ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠇꠁꠔꠣꠝ ꠘꠤ, “ꠀꠅ, ꠀꠝꠞꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠣꠔ ꠞꠁ, ꠎꠣꠔꠦ ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠝꠣꠎꠖꠤ ꠜꠣꠟꠣ ꠚꠟ ꠝꠤꠟꠦ?” ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠀ ꠇꠂꠘ, ꠀꠝꠞꠣꠅ ꠛꠥꠟꠦ ꠅꠟꠣ ꠔꠣꠟꠤꠝ ꠖꠦꠁ। ꠁꠔꠣꠄ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM3_9","075_3_9","ROM","3","9","9","ꠅꠈꠘ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠝ? ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣꠞ ꠢꠣꠟꠔ ꠇꠤꠔꠣ ꠜꠤꠘ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠜꠣꠟꠣ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ ꠘꠣ। ꠀꠉꠦꠃ ꠀꠝꠞꠣ ꠇꠁꠍꠤ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠞ ꠜꠤꠘ ꠎꠣꠔꠤ ꠢꠇꠟꠃ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM3_10","075_3_10","ROM","3","10","10","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ꠛꠦ-ꠇꠍꠥꠞ ꠛꠟꠔꠦ ꠇꠦꠃ ꠘꠣꠁ, ꠄꠇꠎꠘꠅ ꠘꠣꠁ; ");
INSERT INTO syls_vpl VALUES ("RM3_11","075_3_11","ROM","3","11","11","ꠀꠈꠟꠖꠣꠞ ꠄꠇꠎꠘꠅ ꠘꠣꠁ, ꠇꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM3_12","075_3_12","ROM","3","12","12","ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠛꠦ-ꠙꠕꠤ ꠅꠁꠉꠦꠍꠦ, ꠢꠇꠟ ꠄꠇꠟꠉꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠁꠉꠦꠍꠦ, ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠦ ꠁꠟꠣ ꠇꠦꠃ ꠘꠣꠁ, ꠄꠇꠎꠘꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM3_13","075_3_13","ROM","3","13","13","ꠔꠣꠞꠣꠞ ꠝꠥꠈ ꠔ ꠙꠌꠣ ꠟꠣꠡꠞ ꠈꠥꠟꠣ ꠇꠄꠛꠞꠞ ꠟꠣꠈꠣꠘ, ꠔꠣꠞꠣꠞ ꠎꠤꠜꠦ ꠍꠟ-ꠌꠔꠥꠞꠤ ꠝꠣꠔꠦ, ꠀꠞ ꠑꠥꠐꠞ ꠔꠟꠦ ꠀꠍꠦ, ꠢꠣꠚꠞ ꠛꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("RM3_14","075_3_14","ROM","3","14","14","ꠔꠣꠞꠣꠞ ꠉꠟꠣꠞ ꠝꠣꠎꠦ ꠛꠖ꠆ꠖꠥꠀ ꠀꠞ ꠔꠤꠔ꠆ꠔꠣ ꠝꠣꠔ-ꠇꠕꠣꠄ ꠜꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RM3_15","075_3_15","ROM","3","15","15","ꠈꠥꠘ-ꠈꠣꠞꠣꠙꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠙꠣꠅ ꠀꠉꠥꠀꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("RM3_16","075_3_16","ROM","3","16","16","ꠔꠣꠞꠣꠞ ꠙꠕꠅ ꠈꠣꠟꠤ ꠛꠤꠘꠣꠡ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM3_17","075_3_17","ROM","3","17","17","ꠡꠣꠘ꠆ꠔꠤꠞ ꠙꠕ ꠔꠣꠞꠣ ꠌꠤꠘꠦ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("RM3_18","075_3_18","ROM","3","18","18","ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚ ꠢꠞꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM3_19","075_3_19","ROM","3","19","19","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠃ, ꠎꠦꠞꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠡꠞꠤꠅꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠎꠣꠔꠦ ꠈꠣꠟꠤ ꠜꠤꠘ ꠎꠣꠔꠤ ꠘꠣꠄ, ꠡꠞꠤꠅꠔ ꠙꠣꠅꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠅ, ꠝꠣꠘꠤ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠤꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠘꠣꠁ, ꠡꠛꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠌꠣꠞꠞ ꠖꠣꠠꠅ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("RM3_20","075_3_20","ROM","3","20","20","ꠇꠣꠞꠘ ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠟꠦꠃ, ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠤꠟꠤꠛꠣ, ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠡꠞꠤꠅꠔꠞ ꠝꠣꠎꠖꠤꠃ ꠝꠣꠘꠥꠡ ꠉꠥꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("RM3_21","075_3_21","ROM","3","21","21","ꠅꠈꠘ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠙꠕ ꠛꠣꠔꠣꠁ ꠖꠤꠍꠂꠘ, ꠡꠞꠤꠅꠔ ꠍꠣꠠꠣꠅ ꠔꠣꠁꠘ ꠇꠤꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠇꠞꠂꠘ। ꠀꠉꠦ ꠔꠣꠁꠘ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠤꠔꠣꠛꠅ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠁꠡꠣꠞꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM3_22","075_3_22","ROM","3","22","22","ꠅꠃ ꠙꠕ ꠅꠁꠟ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠅꠃ ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠂꠘ। ꠁ ꠛꠦꠙꠣꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠃꠇ ꠛꠣ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠃꠇ ꠢꠇꠟꠃ ꠄꠇ ꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RM3_23","075_3_23","ROM","3","23","23","ꠇꠣꠞꠘ, ꠢꠇꠟꠦꠃ ꠉꠥꠘꠣ ꠇꠞꠍꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤꠔ ꠢꠣꠝꠣꠘꠤꠞ ꠡꠣꠝꠞ꠆ꠕ ꠇꠦꠃꠞꠞ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM3_24","075_3_24","ROM","3","24","24","ꠅꠁꠟꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠝꠣꠘꠡꠞꠦ ꠉꠥꠘꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠘꠤꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠖꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣꠞ ꠙꠕ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM3_25","075_3_25","ROM","3","25","25","ꠎꠦꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠀꠟ-ꠝꠍꠤꠄ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠟꠃꠞꠦ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠍꠂꠘ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠀꠟ꠆ꠟꠣꠄ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠎꠥꠖꠤꠅ ꠔꠣꠘ ꠘꠤꠎꠞ ꠍꠛꠞꠉꠣꠞꠤꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠞ ꠙꠥꠞꠣꠘꠣ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠖꠤꠔꠦ ꠖꠦꠞꠤ ꠇꠞꠞꠣ, ꠔꠦꠛꠃ ꠔꠣꠁꠘ ꠢꠇ-ꠁꠘꠍꠣꠚꠇꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM3_26","075_3_26","ROM","3","26","26","ꠀꠞ ꠅꠈꠘ ꠔꠣꠁꠘ ꠁꠔꠣ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠙꠞꠝꠣꠘ ꠅꠄ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠢꠇ-ꠁꠘꠍꠣꠚꠇꠣꠞꠤ ꠀꠞ ꠎꠦꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠂꠘ, ꠔꠣꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM3_27","075_3_27","ROM","3","27","27","ꠄꠞꠛꠣꠖꠦꠅ ꠝꠣꠘꠡꠦ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠘꠤꠞ ꠇꠥꠘ꠆ꠔꠣ ꠀꠍꠦ ꠘꠤ? ꠘꠣ, ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ। ꠇꠦꠘꠦ ꠘꠣꠁ? ꠝꠣꠘꠡꠦ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠦ ꠇꠞꠤ ꠔꠣꠞ ꠛꠠꠣꠁ ꠇꠞꠣꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ ꠘꠤ? ꠘꠣ, ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠁꠝꠣꠘꠞ ꠝꠣꠎꠦ ꠛꠠꠣꠁ ꠇꠞꠣꠞ ꠎꠣꠉꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM3_28","075_3_28","ROM","3","28","28","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠞ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤꠃ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠂꠘ, ꠡꠞꠤꠅꠔ ꠝꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM3_29","075_3_29","ROM","3","29","29","ꠔꠦ ꠀꠟ꠆ꠟꠣ ꠈꠣꠟꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠘꠤ, ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠟꠣꠉꠤꠅ ꠘꠣꠄ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ, ꠔꠣꠁꠘ ꠜꠤꠘ ꠎꠣꠔꠤꠞꠅ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM3_30","075_3_30","ROM","3","30","30","ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣ ꠔ ꠄꠇꠎꠘꠃ। ꠔꠣꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠦꠟꠣ ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠂꠘ, ꠅꠟꠣ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦꠅ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM3_31","075_3_31","ROM","3","31","31","ꠅꠈꠘ ꠇꠅ ꠌꠣꠁꠘ, ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠡꠞꠤꠅꠔ ꠛꠣꠔꠤꠟ ꠇꠞꠞꠣꠝ ꠘꠤ? ꠘꠣ, ꠝꠥꠐꠦꠃ ꠘꠣ! ꠛꠞꠋ ꠀꠝꠞꠣ ꠡꠞꠤꠅꠔꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("RM4_1","075_4_1","ROM","4","1","1","ꠔꠦ ꠀꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠥꠟ ꠛꠣꠚ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠝ? ꠔꠣꠁꠘ ꠇꠤꠔꠣ ꠙꠣꠁꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("RM4_2","075_4_2","ROM","4","2","2","ꠡꠞꠤꠅꠔ ꠝꠣꠘꠣꠞ ꠟꠣꠉꠤꠃ ꠎꠥꠖꠤ ꠔꠣꠘꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠘꠣ ꠅꠄ, ꠔꠦ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM4_3","075_4_3","ROM","4","3","3","ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, “ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("RM4_4","075_4_4","ROM","4","4","4","ꠇꠣꠝꠟꠣꠄ ꠇꠣꠝ ꠇꠞꠤꠀ ꠎꠦ ꠛꠦꠔꠘ ꠙꠣꠄ, ꠁꠇꠐꠣ ꠇꠥꠘꠥ ꠖꠣꠘ ꠘꠣꠄ, ꠁꠇꠐꠣ ꠔꠣꠞ ꠙꠣꠅꠘꠣ ꠝꠎꠥꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM4_5","075_4_5","ROM","4","5","5","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠀꠝꠟꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠈꠣꠟꠤ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠎꠦꠁꠘ ꠉꠥꠘꠣꠉꠣꠞꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠣꠞ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠢꠦ ꠈꠣꠟꠣꠍ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM4_6","075_4_6","ROM","4","6","6","ꠀꠞ ꠘꠤꠎ ꠀꠝꠟ ꠍꠣꠠꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠎꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠍꠂꠘ, ꠢꠎꠞꠔ ꠖꠣꠃꠖꠦꠅ ꠔꠣꠞꠦ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠇꠁꠍꠂꠘ। ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠔꠣꠁꠘ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RM4_7","075_4_7","ROM","4","7","7","ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠔꠣꠞꠣꠃ, ꠎꠦꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣꠄ ꠎꠦꠞꠣꠞ ꠉꠥꠘꠣꠞꠦ ꠀꠞ ꠢꠤꠡꠣꠛꠅ ꠗꠞꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM4_8","075_4_8","ROM","4","8","8","ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠢꠃ ꠎꠘ, ꠎꠣꠞ ꠉꠥꠘꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞ ꠀꠝꠟ-ꠘꠣꠝꠣ ꠕꠣꠇꠤ ꠇꠣꠐꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM4_9","075_4_9","ROM","4","9","9","ꠔꠦ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞꠦꠃ ꠇꠅꠀ ꠅꠁꠍꠦ ꠘꠤ, ꠎꠦꠞꠣꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟ ꠅꠁꠍꠦ? ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠣꠁꠟ ꠝꠣꠘꠡꠞꠦꠅ ꠇꠅꠀ ꠅꠁꠍꠦ ꠘꠣ ꠘꠤ? ꠅꠄ, ꠔꠣꠞꠣꠞꠦꠅ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠇꠅꠀ ꠅꠁꠍꠦ। ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠙꠣꠁꠍꠤ, ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤꠃ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM4_10","075_4_10","ROM","4","10","10","ꠇꠥꠘ ꠡꠝꠄ ꠇꠞꠟꠣ? ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤꠞ ꠀꠉꠦ, ꠘꠣ ꠛꠣꠖꠦ? ꠘꠤꠌ꠆ꠌꠄ, ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤꠞ ꠀꠉꠦꠃ ꠅꠁꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM4_11","075_4_11","ROM","4","11","11","ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠀꠉꠦꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠍꠟꠣ, ꠀꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤ ꠀꠍꠤꠟ ꠄꠞ ꠙꠞꠝꠣꠘ ꠛꠣ ꠘꠤꠡꠣꠘꠣ। ꠄ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠖꠤꠟꠦꠅ, ꠈꠣꠟꠤ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠗꠞꠣ ꠅꠄ, ꠔꠣꠞꠣꠞ ꠝꠥꠟ ꠛꠣꠚ ꠅꠁꠟꠣ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝ। ");
INSERT INTO syls_vpl VALUES ("RM4_12","075_4_12","ROM","4","12","12","ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠘꠤꠞ ꠀꠉꠦ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠁꠝꠣꠘ ꠎꠦꠟꠣꠈꠣꠘ ꠀꠍꠤꠟ, ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠀ ꠎꠔ ꠝꠣꠘꠡꠦ ꠅꠃ ꠁꠝꠣꠘꠦ ꠌꠟꠦ, ꠔꠣꠞꠣꠞꠅ ꠝꠥꠟ ꠛꠣꠚ ꠅꠁꠟꠣ ꠅꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝ। ");
INSERT INTO syls_vpl VALUES ("RM4_13","075_4_13","ROM","4","13","13","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠀꠞ ꠔꠣꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠁ ꠖꠥꠘꠤꠀꠞ ꠖꠈꠟꠖꠣꠞꠤ ꠖꠤꠛꠣ। ꠡꠞꠤꠅꠔ ꠝꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠁ ꠅꠀꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤꠃ ꠔꠣꠘꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠤꠀ ꠅꠃ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM4_14","075_4_14","ROM","4","14","14","ꠡꠞꠤꠅꠔ ꠝꠣꠘꠤꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠖꠈꠟꠖꠣꠞꠤ ꠙꠣꠁꠟꠣꠄ, ꠔꠦ ꠔ ꠁꠝꠣꠘ ꠛꠦꠇꠣꠝꠣ ꠛꠘꠤꠎꠣꠄ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣꠞꠅ ꠇꠥꠘꠥ ꠖꠣꠝ ꠞꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM4_15","075_4_15","ROM","4","15","15","ꠡꠞꠤꠅꠔꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛ ꠟꠣꠝꠣꠄ। ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠎꠦꠈꠣꠘꠅ ꠡꠞꠤꠅꠔ ꠘꠣꠁ, ꠁꠘꠅ ꠡꠞꠤꠅꠔ ꠜꠋꠉꠞ ꠇꠕꠣꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM4_16","075_4_16","ROM","4","16","16","ꠄꠞꠟꠣꠉꠤ ꠁ ꠅꠀꠖꠣ ꠈꠣꠟꠤ ꠝꠣꠘꠡꠞ ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ ꠙꠥꠞꠣ ꠇꠞꠣ ꠅꠄ, ꠎꠣꠔꠦ ꠁꠐꠣ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠖꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠞꠄ। ꠔꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠉꠦꠍꠦ ꠎꠦ ꠅꠀꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠁꠈꠣꠘ ꠘꠤꠌ꠆ꠌꠄ ꠙꠥꠞꠣ ꠇꠞꠣ ꠅꠁꠛ। ꠈꠣꠟꠤ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠞꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤꠃ ꠙꠥꠞꠘ ꠇꠞꠣ ꠅꠁꠔ ꠘꠣꠄ, ꠎꠦꠞꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠁꠝꠣꠘꠞ ꠟꠉꠦ ꠡꠞꠤꠇ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠁ ꠅꠀꠖꠣ ꠙꠥꠞꠣ ꠇꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("RM4_17","075_4_17","ROM","4","17","17","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠎꠦꠟꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠃꠔ ꠎꠣꠔꠤꠞ ꠝꠥꠟ ꠛꠣꠚ ꠛꠣꠘꠣꠁꠟꠣꠝ।” ꠅꠃ ꠢꠤꠡꠣꠛꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠅꠁꠟꠣ ꠀꠝꠞꠣ ꠢꠇꠟꠞ ꠝꠥꠟ ꠛꠣꠚ। ꠎꠦꠁꠘ ꠝꠞꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠦꠁꠘ ꠀꠞ ꠎꠦꠔꠣ ꠅꠀꠞ ꠘꠣꠄ, ꠅꠔꠣ ꠅꠀꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠁꠘ ꠁꠝꠣꠘ ꠀꠘꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM4_18","075_4_18","ROM","4","18","18","ꠅꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠎꠦꠛꠟꠣ ꠀꠅꠟꠣꠖ ꠙꠣꠅꠀꠞ ꠇꠥꠘꠥ ꠀꠡꠣ ꠇꠞꠣꠞ ꠇꠕꠣ ꠘꠣꠄ, ꠢꠃ ꠡꠝꠄꠅ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤꠀ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠁꠍꠂꠘ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠁꠍꠟꠣ, “ꠔꠥꠝꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦ ꠀꠝꠤ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠤꠡꠣꠛ ꠇꠞꠝꠥ।” ꠀꠞ ꠅꠃ ꠇꠕꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠁꠘ ꠁꠝꠣꠘ ꠀꠘꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM4_19","075_4_19","ROM","4","19","19","ꠄꠇ-ꠡ ꠛꠍꠞ ꠛꠄꠅꠡꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠎꠥꠖꠤꠅ ꠛꠥꠎꠍꠤꠟꠣ, ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠎꠘꠝ ꠖꠦꠅꠀꠞ ꠈꠦꠝꠔꠣ ꠀꠞ ꠔꠣꠘ ꠘꠣꠁ, ꠔꠣꠘ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠀꠞ ꠛꠄꠅꠡ ꠡꠦꠡ ꠅꠁꠉꠦꠍꠦ, ꠔꠦꠛꠃ ꠔꠣꠘ ꠁꠝꠣꠘ ꠝꠎꠛꠥꠔ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RM4_20","075_4_20","ROM","4","20","20","ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠘ ꠝꠘꠅ ꠇꠥꠘꠥ ꠡꠘ꠆ꠖꠄ ꠀꠁꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠔꠣꠁꠘ ꠁꠝꠣꠘꠦ ꠀꠞꠅ ꠝꠎꠛꠥꠔ ꠅꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM4_21","075_4_21","ROM","4","21","21","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠄꠇꠤꠘ ꠇꠞꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠙꠥꠞꠣ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣꠅ ꠔꠣꠘ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM4_22","075_4_22","ROM","4","22","22","ꠅꠃ ꠇꠣꠞꠘꠦꠃ ꠔꠣꠘ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RM4_23","075_4_23","ROM","4","23","23","“ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠁꠍꠤꠟ,” ꠁꠈꠣꠘ ꠈꠣꠟꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠣꠉꠤ ꠟꠦꠈꠣ ꠅꠁꠍꠦ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("RM4_24","075_4_24","ROM","4","24","24","ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠟꠦꠈꠣ ꠅꠁꠍꠦ। ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠛꠣ, ꠇꠣꠞꠘ ꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠟꠣ, ꠀꠝꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦꠃ ꠁꠝꠣꠘ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("RM4_25","075_4_25","ROM","4","25","25","ꠀꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠢꠤꠡꠣꠛꠦ ꠅꠃ ꠁꠍꠣꠞꠦ ꠝꠃꠔꠞ ꠀꠔꠅ ꠔꠥꠟꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠀꠞ ꠀꠝꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RM5_1","075_5_1","ROM","5","1","1","ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠉꠔꠤꠇꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠡꠥ-ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠛꠅꠀꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM5_2","075_5_2","ROM","5","2","2","ꠅꠃ ꠎꠦ ꠞꠢꠝꠔꠞ ꠔꠟꠦ ꠀꠝꠞꠣ ꠀꠍꠤ, ꠀꠟ-ꠝꠍꠤꠄ ꠀꠝꠞꠣꠞꠦ ꠁ ꠎꠣꠉꠣꠔ ꠀꠘꠤꠀ ꠙꠃꠍꠣꠁꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ ꠙꠣꠅꠀꠞ ꠀꠡꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠘ ꠅꠈꠘ ꠘꠤꠌ꠆ꠌꠤꠔ ꠈꠥꠡꠤꠄ ꠜꠞꠤ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM5_3","075_5_3","ROM","5","3","3","ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠀꠝꠞꠣ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠝꠣꠎꠦꠅ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠞꠣꠝ। ꠇꠣꠞꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠄ ꠍꠛꠞ ꠀꠘꠦ, ");
INSERT INTO syls_vpl VALUES ("RM5_4","075_5_4","ROM","5","4","4","ꠍꠛꠞꠦ ꠝꠦꠅꠀ ꠚꠟꠦ, ꠅꠃ ꠝꠦꠅꠀꠄ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠀꠘꠦ, ");
INSERT INTO syls_vpl VALUES ("RM5_5","075_5_5","ROM","5","5","5","ꠀꠞ ꠅꠃ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠛꠦꠇꠣꠝꠣ ꠎꠣꠄ ꠘꠣ। ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠍꠂꠘ, ꠁ ꠙꠣꠇ ꠞꠥꠢꠦ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠁ ꠝꠢꠛ꠆ꠛꠔ ꠎꠘꠝꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM5_6","075_5_6","ROM","5","6","6","ꠀꠝꠞꠣ ꠔ ꠇꠝꠎꠥꠞ-ꠟꠣꠌꠣꠞ ꠀꠍꠟꠣꠝ, ꠡꠑꠤꠇ ꠡꠝꠄꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠉꠥꠘꠣꠉꠣꠞꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠀꠟ-ꠝꠍꠤꠄ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM5_7","075_5_7","ROM","5","7","7","ꠇꠥꠘꠥ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠡꠣꠗꠣꠞꠘꠔ ꠇꠦꠃ ꠎꠣꠘ ꠖꠤꠟꠣꠁꠔ ꠌꠣꠄ ꠘꠣ, ꠔꠣ-ꠅ ꠈꠥꠛ ꠜꠣꠟꠣ ꠎꠘꠞ ꠟꠣꠉꠤ ꠀꠈꠔꠣ ꠇꠦꠃ ꠖꠤꠟꠦꠅ ꠖꠤꠟꠣꠁꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("RM5_8","075_5_8","ROM","5","8","8","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠉꠥꠘꠣꠉꠣꠞ ꠢꠣꠟꠔꠦꠃ ꠀꠟ-ꠝꠍꠤꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠂꠘ। ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠙꠞꠝꠣꠘ ꠝꠤꠟꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠇꠔ ꠝꠣꠄꠀ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM5_9","075_5_9","ROM","5","9","9","ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠅꠁꠍꠤ, ꠔꠦ ꠅꠈꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠎꠣ ꠕꠣꠇꠤꠅ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠝꠥ, ꠁꠐꠣ ꠔ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠘꠤꠌ꠆ꠌꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("RM5_10","075_5_10","ROM","5","10","10","ꠀꠝꠞꠣ ꠀꠉꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠥꠡꠝꠘ ꠀꠍꠟꠣꠝ, ꠢꠃ ꠡꠝꠄ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠝꠃꠔꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ, ꠔꠣꠘ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠝꠤꠟꠘ ꠅꠁꠍꠦ। ꠔꠦ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠞ ꠝꠣꠎꠖꠤ ꠅꠈꠘ ꠀꠞꠅ ꠛꠦꠡꠤ ꠘꠤꠌ꠆ꠌꠤꠔ, ꠀꠝꠞꠣ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM5_11","075_5_11","ROM","5","11","11","ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠎꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠅꠃ ꠝꠤꠟꠘ ꠅꠁꠍꠦ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠅꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠅꠈꠘ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠅ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM5_12","075_5_12","ROM","5","12","12","ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠖꠤ ꠖꠥꠘꠤꠀꠁꠔ ꠉꠥꠘꠣ ꠀꠁꠀ ꠢꠣꠝꠣꠁꠍꠤꠟ, ꠀꠞ ꠅꠃ ꠉꠥꠘꠣꠞ ꠝꠣꠎꠖꠤ ꠝꠃꠔꠅ ꠀꠁꠍꠤꠟ। ꠛꠣꠖꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠦꠃ ꠉꠥꠘꠣ ꠇꠞꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠢꠇꠟꠞ ꠟꠣꠉꠤꠃ ꠝꠃꠔ ꠀꠁꠀ ꠀꠎꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM5_13","075_5_13","ROM","5","13","13","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠘꠣꠎꠤꠟꠞ ꠀꠉꠦꠅ ꠖꠥꠘꠤꠀꠁꠔ ꠉꠥꠘꠣ ꠀꠍꠤꠟ। ꠅꠁꠟꠦ ꠡꠞꠤꠅꠔ ꠀꠍꠤꠟ ꠘꠣ ꠉꠔꠤꠇꠦ ꠉꠥꠘꠣꠞꠦ ꠢꠤꠡꠣꠛꠅ ꠗꠞꠣ ꠅꠁꠔ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM5_14","075_5_14","ROM","5","14","14","ꠔꠣ-ꠅ ꠛꠣꠛꠣ ꠀꠖꠝ ꠕꠣꠇꠤ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠀꠝꠟ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠦꠞꠣ ꠀꠖꠝꠞ ꠟꠣꠈꠣꠘ ꠡꠞꠣꠡꠞꠤ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠞꠦ ꠜꠣꠋꠉꠤꠍꠦ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦꠅ ꠝꠃꠔꠦ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠍꠦ। ꠔꠦ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠛꠣꠛꠣ ꠀꠖꠝꠞ ꠟꠉꠦ, ꠛꠣꠖꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠣ ꠅꠃ ꠀꠟ-ꠝꠍꠤꠞꠅ ꠝꠤꠟ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RM5_15","075_5_15","ROM","5","15","15","ꠅꠁꠟꠦ ꠛꠣꠛꠣ ꠀꠖꠝꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠔꠚꠣꠔ ꠀꠍꠦ। ꠢꠃ ꠄꠇꠎꠘꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠖꠣꠄ ꠛꠃꠔꠞ ꠟꠣꠉꠤ ꠝꠃꠔ ꠀꠁꠟ ꠀꠞ ꠀꠞꠇ ꠎꠘ, ꠝꠣꠘꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠦꠢꠦꠞꠛꠣꠘꠤꠞ ꠝꠣꠎꠖꠤ ꠎꠦ ꠞꠢꠝꠔꠤ ꠖꠣꠘ ꠀꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠁ ꠞꠢꠝꠔ ꠀꠞꠅ ꠛꠃꠔ ꠛꠦꠡꠤ ꠛꠣꠠꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RM5_16","075_5_16","ROM","5","16","16","ꠀꠞ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠄ ꠎꠦꠟꠣ ꠚꠟ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠖꠣꠘ ꠔ ꠁꠟꠣꠈꠣꠘ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠍꠦ। ꠅꠁꠟꠦ ꠛꠃꠔ ꠛꠦꠡꠤ ꠙꠞꠤꠝꠣꠘꠦ ꠉꠥꠘꠣ ꠇꠞꠣꠞ ꠛꠣꠖꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠞꠢꠝꠔꠦ ꠛꠃꠔ ꠎꠘꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM5_17","075_5_17","ROM","5","17","17","ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠛꠟꠣ ꠝꠃꠔꠦ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠍꠦ, ꠔꠦ ꠖꠥꠍꠞꠣ ꠀꠞꠇ ꠎꠘ, ꠝꠣꠘꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠞꠣ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠅꠁꠍꠤ, ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠇꠔ ꠛꠦꠡꠤ ꠘꠤꠌ꠆ꠌꠤꠔ ꠅꠁꠀ ꠀꠟ꠆ꠟꠣꠁ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠀ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞꠦ ꠞꠣꠎꠔ꠆ꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM5_18","075_5_18","ROM","5","18","18","ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠟꠣ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠅꠃꠟꠣ ꠄꠇꠐꠣ ꠘꠦꠇ ꠇꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠅꠃ ꠡꠥꠎꠥꠉꠞ ꠚꠟ ꠅꠁꠟ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RM5_19","075_5_19","ROM","5","19","19","ꠎꠦꠝꠘ ꠗꠞꠅ, ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠅꠛꠣꠁꠖ꠆ꠖꠔꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠁꠍꠂꠘ। ꠅꠃꠟꠣ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠛꠣꠁꠖ꠆ꠖꠔꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM5_20","075_5_20","ROM","5","20","20","ꠄꠞꠝꠣꠎꠦ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠅ ꠘꠣꠎꠤꠟ ꠅꠁꠉꠦꠟ, ꠎꠣꠔꠦ ꠁ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠢꠤꠡꠣꠛꠞ ꠙꠞꠤꠝꠣꠘ ꠀꠞꠅ ꠛꠣꠠꠤ ꠎꠣꠄ। ꠅꠁꠟꠦ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠎꠦꠘꠅ ꠛꠣꠠꠤꠟ, ꠁꠘꠅ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠀꠞꠅ ꠛꠃꠔ ꠛꠣꠠꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RM5_21","075_5_21","ROM","5","21","21","ꠁ ꠞꠢꠝꠔ ꠛꠣꠠꠤꠟ, ꠎꠣꠔꠦ ꠝꠃꠔꠞ ꠝꠣꠎꠖꠤ ꠀꠉꠦ ꠉꠥꠘꠣꠄ ꠎꠦꠟꠣ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠍꠤꠟ, ꠅꠈꠘ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠅꠀꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠅꠃꠟꠣ ꠞꠣꠎꠔ꠆ꠔ ꠇꠞꠦ। ꠀꠞ ꠅꠔꠣꠞ ꠚꠟ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM6_1","075_6_1","ROM","6","1","1","ꠔꠦ ꠅꠈꠘ ꠀꠝꠞꠣ ꠅꠟꠣ ꠇꠁꠔꠣꠝ ꠘꠤ, ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠀꠞꠅ ꠛꠣꠠꠦ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠀꠞꠅ ꠉꠥꠘꠣ ꠇꠞꠣꠔ ꠞꠁ? ");
INSERT INTO syls_vpl VALUES ("RM6_2","075_6_2","ROM","6","2","2","ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ, ꠝꠥꠐꠦꠃ ꠘꠣ! ꠉꠥꠘꠣꠞ ꠛꠣꠛꠔꠦ ꠀꠝꠞꠣ ꠔ ꠝꠞꠤꠉꠦꠍꠤ, ꠔꠦ ꠁ ꠝꠥꠞ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠅꠈꠘ ꠀꠞ ꠇꠦꠝꠘꠦ ꠉꠥꠘꠣꠞ ꠇꠣꠝꠅ ꠞꠁꠔꠣꠝ? ");
INSERT INTO syls_vpl VALUES ("RM6_3","075_6_3","ROM","6","3","3","ꠀꠁꠌ꠆ꠍꠣ, ꠀꠝꠞꠣ ꠎꠔ ꠎꠘꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠍꠤ, ꠀꠝꠞꠣ ꠔ ꠔꠣꠘ ꠝꠃꠔꠞ ꠟꠉꠦꠅ ꠡꠞꠤꠇ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("RM6_4","075_6_4","ROM","6","4","4","ꠅꠃ ꠉꠥꠍꠟꠞ ꠇꠣꠟꠅ ꠀꠝꠞꠣꠞꠦ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠇꠄꠛꠞ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠀꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠝꠢꠣ ꠇꠥꠖꠞꠔꠦ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠎꠦꠟꠣ ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠍꠂꠘ, ꠑꠤꠇ ꠅꠃꠟꠣ ꠀꠝꠞꠣꠅ ꠎꠣꠘꠥ ꠘꠄꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠄ ꠖꠤꠘ ꠇꠣꠐꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM6_5","075_6_5","ROM","6","5","5","ꠀꠞ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠃꠔꠅ ꠡꠞꠤꠇ ꠅꠁꠍꠤ, ꠔꠦ ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠍꠂꠘ, ꠅꠟꠣ ꠀꠝꠞꠣꠅ ꠔꠣꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM6_6","075_6_6","ROM","6","6","6","ꠀꠝꠞꠣ ꠁꠈꠣꠘ ꠎꠣꠘꠤ, ꠀꠝꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞꠦ ꠛꠦꠇꠣꠝꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠝꠞꠣꠞ ꠙꠥꠞꠣꠘ ‘ꠀꠝꠤ’ꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠝꠣꠞꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠀꠞ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠘꠣ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("RM6_7","075_6_7","ROM","6","7","7","ꠇꠣꠞꠘ ꠎꠣꠞ ꠝꠃꠔ ꠅꠁꠎꠣꠄ, ꠢꠦ ꠔ ꠉꠥꠘꠣꠞ ꠇꠛꠎꠣ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM6_8","075_6_8","ROM","6","8","8","ꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣꠞ ꠝꠞꠘ ꠅꠁꠍꠦ, ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠅꠁꠟ, ꠔꠣꠘ ꠟꠉꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠅ ꠙꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM6_9","075_6_9","ROM","6","9","9","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠟ-ꠝꠍꠤ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠤꠍꠂꠘ ꠇꠞꠤ ꠔꠣꠘ ꠀꠞ ꠝꠃꠔ ꠅꠁꠔ ꠘꠣꠄ। ꠝꠃꠔꠞ ꠇꠥꠘꠥ ꠈꠦꠝꠔꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM6_10","075_6_10","ROM","6","10","10","ꠀꠍꠟꠦ ꠔꠣꠘ ꠎꠦ ꠝꠃꠔ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠔ ꠉꠥꠘꠣꠞ ꠈꠦꠝꠔꠣ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠣꠟꠤ ꠄꠇꠛꠣꠞꠃ ꠅꠁꠍꠦ। ꠀꠞ ꠅꠈꠘ ꠔꠣꠘ ꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠍꠦ, ꠁꠐꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM6_11","075_6_11","ROM","6","11","11","ꠑꠤꠇ ꠅꠃꠟꠣ, ꠔꠥꠝꠞꠣꠅ ꠝꠘꠅ ꠇꠞꠤꠅ, ꠉꠥꠘꠣꠞ ꠈꠦꠝꠔꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠞꠘ ꠅꠁꠉꠦꠍꠦ, ꠅꠈꠘ ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("RM6_12","075_6_12","ROM","6","12","12","ꠄꠞꠟꠣꠉꠤ ꠝꠃꠔꠞ ꠎꠥꠇꠣ ꠔꠥꠝꠞꠣꠞ ꠁ ꠡꠞꠤꠟꠞ ꠃꠙꠞꠦ ꠉꠥꠘꠣꠞꠦ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠔꠦ ꠖꠤꠅ ꠘꠣ, ꠡꠞꠤꠟꠞꠦ ꠛꠖ ꠈꠣꠁꠡꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM6_13","075_6_13","ROM","6","13","13","ꠡꠞꠤꠟꠞ ꠇꠥꠘꠥ ꠅꠋꠉꠞꠦ ꠛꠖ ꠇꠣꠝꠞ ꠀꠔꠤꠀꠞ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ꠛꠞꠋ ꠘꠤꠎꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀ ꠎꠘ ꠝꠘꠅ ꠇꠞꠤꠀ ꠙꠥꠞꠣꠙꠥꠞꠤ ꠀꠟ꠆ꠟꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠦꠅ, ꠡꠞꠤꠟꠞ ꠢꠇꠟ ꠅꠋꠉꠞꠦ ꠘꠦꠇ ꠇꠣꠝꠞ ꠀꠔꠤꠀꠞ ꠢꠤꠡꠣꠛꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("RM6_14","075_6_14","ROM","6","14","14","ꠔꠥꠝꠞꠣ ꠔ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠘꠣꠄ, ꠡꠞꠤꠅꠔꠞ ꠀꠅꠔꠣꠄꠅ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠔꠟꠦ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("RM6_15","075_6_15","ROM","6","15","15","ꠔꠦ ꠅꠈꠘ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ? ꠡꠞꠤꠅꠔꠞ ꠀꠅꠔꠣ ꠕꠣꠇꠤ ꠍꠣꠠꠣ ꠙꠣꠁꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠀꠅꠔꠣꠄ ꠀꠍꠤ ꠇꠞꠤ, ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠉꠥꠘꠣ ꠇꠞꠔꠣꠝ ꠘꠤ? ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ, ꠝꠥꠐꠦꠃ ꠘꠣ! ");
INSERT INTO syls_vpl VALUES ("RM6_16","075_6_16","ROM","6","16","16","ꠔꠥꠝꠞꠣ ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠘꠤꠎꠞꠦ ꠇꠦꠃꠞꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠀ ꠔꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠌꠟ, ꠔꠦ ꠄꠝꠘꠦꠃ ꠔ ꠔꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠤꠎꠣꠅ। ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠢꠄꠔ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠤꠀ ꠝꠞꠛꠣꠄ, ꠀꠞꠘꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠤꠀ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM6_17","075_6_17","ROM","6","17","17","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠡꠥꠇꠥꠞ, ꠀꠉꠦ ꠎꠥꠖꠤꠅ ꠔꠥꠝꠞꠣ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠄ, ꠔꠣ-ꠅ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣꠞ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠀ ꠢꠣꠞꠤ, ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠁꠔꠣꠞ ꠀꠡꠤꠇ ꠅꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("RM6_18","075_6_18","ROM","6","18","18","ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠍꠣꠠꠣ ꠙꠣꠁꠀ, ꠘꠦꠇ ꠇꠣꠝꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("RM6_19","075_6_19","ROM","6","19","19","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠀꠈꠟꠞ ꠇꠝꠎꠥꠞꠤ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠘꠥꠡ ꠛꠥꠟꠤꠄ ꠝꠣꠔꠤꠞꠣꠝ, ꠀꠉꠦ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠅꠋꠉꠞꠦ ꠘꠣꠙꠣꠇꠤ ꠀꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠁꠍꠟꠣꠄ, ꠅꠈꠘꠅ ꠑꠤꠇ ꠅꠃꠟꠣ, ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠎꠣꠞꠎꠤꠞ ꠅꠋꠉꠞꠦ ꠘꠦꠇ ꠇꠣꠝꠞ ꠉꠥꠟꠣꠝꠤꠔ ꠡꠙꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("RM6_20","075_6_20","ROM","6","20","20","ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠄ, ꠁ ꠡꠝꠄ ꠔ ꠘꠦꠇ ꠇꠣꠝꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠀꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM6_21","075_6_21","ROM","6","21","21","ꠀꠉꠞ ꠛꠖ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠇꠕꠣ ꠝꠘꠅ ꠅꠁꠟꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠝ ꠟꠣꠉꠦ, ꠔꠦ ꠇꠅ ꠌꠣꠁꠘ, ꠁꠔꠣ ꠇꠣꠝꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠤꠔꠣ ꠟꠣꠜ ꠅꠁꠔ? ꠁꠔꠣꠞ ꠢꠦꠡ ꠚꠟ ꠔ ꠝꠞꠘ। ");
INSERT INTO syls_vpl VALUES ("RM6_22","075_6_22","ROM","6","22","22","ꠅꠁꠟꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠕꠣꠇꠤ ꠀꠎꠣꠖ ꠅꠁꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠕꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠤꠀ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠞꠣꠄ, ꠄꠞ ꠢꠦꠡ ꠚꠟ ꠔ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RM6_23","075_6_23","ROM","6","23","23","ꠀꠍꠟꠦ ꠉꠥꠘꠣꠞ ꠝꠎꠥꠞꠤ ꠅꠁꠟ ꠝꠃꠔ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠖꠣꠘ ꠅꠁꠟꠉꠤ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RM7_1","075_7_1","ROM","7","1","1","ꠔꠦ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠛꠤꠡꠄ ꠔ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠣꠃ ꠀꠍꠦ। ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣ ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠡꠞꠤꠅꠔꠞ ꠖꠣꠛꠤ-ꠖꠣꠅꠀ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠛꠅꠀꠁꠟ ꠕꠣꠇꠦ, ꠈꠣꠟꠤ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("RM7_2","075_7_2","ROM","7","2","2","ꠎꠦꠟꠣ, ꠎꠣꠝꠣꠁ ꠎꠔꠖꠤꠘ ꠎꠤꠔꠣ ꠀꠍꠦ, ꠅꠔꠖꠤꠘ ꠔꠣꠞ ꠛꠃ ꠔꠣꠞ ꠀꠅꠔꠣꠄ ꠛꠣꠘ꠆ꠖꠣ ꠞꠄ, ꠀꠞ ꠎꠣꠝꠣꠁꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠔꠣꠞ ꠛꠃ ꠁ ꠛꠣꠘ꠆ꠖꠘ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM7_3","075_7_3","ROM","7","3","3","ꠀꠞ ꠎꠣꠝꠣꠁ ꠎꠤꠔꠣ ꠕꠣꠇꠔꠦ ꠛꠃ ꠎꠥꠖꠤ ꠖꠥꠍꠞꠣ ꠛꠦꠐꠣꠞ ꠉꠦꠍꠦ ꠢꠣꠋꠉꠣ ꠛꠄ, ꠔꠣꠁꠞꠦ ꠔ ꠎꠤꠘꠣꠇꠥꠞ ꠢꠤꠡꠣꠛꠦ ꠉꠘꠣ ꠅꠄ। ꠅꠁꠟꠦ ꠎꠣꠝꠣꠁꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠔꠣꠁ ꠎꠣꠝꠣꠁꠞ ꠛꠣꠘ꠆ꠖꠘ ꠕꠣꠇꠤ ꠀꠁꠘ ꠝꠣꠚꠤꠇ ꠈꠣꠟꠣꠍ ꠙꠣꠄ, ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁ ꠅꠁꠘ꠆ꠘ ꠎꠘꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠛꠁꠟꠦ ꠎꠤꠘꠣꠇꠥꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM7_4","075_7_4","ROM","7","4","4","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘꠃ, ꠀꠟ-ꠝꠍꠤꠞ ꠡꠞꠤꠟꠞ ꠝꠃꠔꠞ ꠝꠣꠎꠖꠤ ꠡꠞꠤꠅꠔꠞ ꠛꠣꠘ꠆ꠖꠘ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠉꠦꠍꠦ ꠇꠞꠤ, ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠅꠁꠘ꠆ꠘ ꠎꠘꠞ ꠛꠣꠘ꠆ꠖꠘꠅ ꠎꠣꠁꠔꠣꠄ ꠙꠣꠞ, ꠀꠞ ꠅꠃ ꠅꠁꠘ꠆ꠘ ꠎꠘ ꠅꠁꠟꠣ, ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀ ꠢꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ, ꠎꠣꠔꠦ ꠀꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠘꠦꠇ ꠙꠕꠞ ꠚꠟ ꠗꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("RM7_5","075_7_5","ROM","7","5","5","ꠀꠉꠦ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣ ꠡꠞꠤꠟꠞ ꠝꠞ꠆ꠎꠤꠄ ꠌꠟꠔꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠡꠞꠤꠅꠔꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠉꠥꠘꠣꠞ ꠛꠖ ꠈꠣꠁꠡꠞꠦ ꠈꠥꠌꠣꠁꠀ ꠢꠎꠣꠉ ꠇꠞꠔ, ꠅꠃ ꠇꠣꠞꠘꠦ ꠀꠝꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠅꠋꠉ ꠅꠇꠟꠦ ꠝꠃꠔꠞ ꠙꠕꠤ ꠉꠥꠘꠣꠞ ꠚꠟ ꠗꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("RM7_6","075_7_6","ROM","7","6","6","ꠔꠦ ꠀꠉꠦ ꠀꠝꠞꠣ ꠎꠦ ꠡꠞꠤꠅꠔꠞ ꠛꠣꠘ꠆ꠖꠘꠅ ꠀꠍꠟꠣꠝ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠉꠦꠍꠦ, ꠅꠈꠘ ꠀꠝꠞꠣ ꠁ ꠡꠞꠤꠅꠔꠞ ꠛꠣꠘ꠆ꠖꠘ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠍꠤ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠀꠞ ꠢꠤ ꠟꠤꠈꠤꠔ ꠡꠞꠤꠅꠔꠞ ꠉꠥꠟꠣꠝ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠦ ꠘꠄꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM7_7","075_7_7","ROM","7","7","7","ꠅꠈꠘ ꠀꠝꠞꠣ ꠅꠟꠣ ꠇꠁꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠤ, ꠡꠞꠤꠅꠔꠦꠃ ꠉꠥꠘꠣ ꠇꠞꠣꠄ? ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ, ꠝꠥꠐꠦꠃ ꠘꠣ! ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠡꠞꠤꠅꠔ ꠘꠣ ꠕꠣꠇꠟꠦ ꠔ ꠀꠝꠤ ꠛꠥꠎꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠘꠣ ꠅꠘꠦ, ꠉꠥꠘꠣ ꠇꠤ ꠎꠤꠘꠤꠡ। ꠡꠞꠤꠅꠔꠦ ꠎꠥꠖꠤ ꠘꠣ ꠇꠁꠔ, ꠟꠥꠜ-ꠟꠣꠟꠌ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠦ ꠟꠣꠟꠌ ꠇꠞꠟꠦ ꠇꠤꠔꠣ ꠅꠄ, ꠁꠔꠣ ꠀꠝꠞꠣ ꠛꠥꠎꠟꠣꠝ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("RM7_8","075_7_8","ROM","7","8","8","ꠀꠞ ꠅꠃ ꠢꠥꠇꠥꠝꠞ ꠡꠥꠎꠥꠉ ꠛꠥꠎꠤꠀ ꠀꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠉꠥꠘꠣ ꠢꠣꠝꠣꠁꠀ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠟꠥꠜ-ꠟꠣꠟꠌ ꠎꠘꠝ ꠖꠤꠍꠦ। ꠡꠞꠤꠅꠔ ꠘꠣ ꠕꠣꠇꠟꠦ ꠔ ꠉꠥꠘꠣꠅ ꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠌꠥꠙꠌꠣꠙ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("RM7_9","075_7_9","ROM","7","9","9","ꠀꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠡꠞꠤꠅꠔꠞꠦ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠌꠤꠘꠣꠞ ꠀꠉꠦ ꠀꠝꠤ ꠔ ꠎꠤꠔꠣ ꠀꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠎꠣꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠉꠥꠘꠣ ꠢꠎꠣꠉ ꠅꠁꠟ, ꠀꠞ ꠀꠝꠣꠞ ꠝꠃꠔ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RM7_10","075_7_10","ROM","7","10","10","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠎꠦ ꠡꠞꠤꠅꠔꠦ ꠀꠝꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠅꠀꠞ ꠇꠕꠣ, ꠢꠃ ꠡꠞꠤꠅꠔꠦ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠝꠞꠘ ꠟꠁꠀ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RM7_11","075_7_11","ROM","7","11","11","ꠡꠞꠤꠅꠔꠞ ꠅꠃ ꠢꠥꠇꠥꠝꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠀ ꠉꠥꠘꠣꠄ ꠀꠝꠣꠞꠦ ꠐꠉꠤꠟ, ꠅꠃ ꠢꠥꠇꠥꠝꠞ ꠛꠟꠦꠃ ꠉꠥꠘꠣꠄ ꠀꠝꠣꠞ ꠎꠣꠘ ꠇꠣꠠꠤꠀ ꠘꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RM7_12","075_7_12","ROM","7","12","12","ꠅꠁꠟꠦ ꠁꠈꠣꠘ ꠔ ꠢꠣꠍꠣ, ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠖꠦꠅꠀ ꠡꠞꠤꠅꠔ ꠙꠛꠤꠔ꠆ꠞ, ꠄꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠅ ꠙꠛꠤꠔ꠆ꠞ, ꠁꠔꠣ ꠡꠑꠤꠇ ꠀꠞ ꠜꠣꠟꠣ ꠎꠤꠘꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("RM7_13","075_7_13","ROM","7","13","13","ꠔꠦ ꠅꠃ ꠜꠣꠟꠣ ꠎꠤꠘꠤꠡꠦꠃ ꠇꠤꠔꠣ ꠀꠝꠣꠞ ꠝꠞꠘ ꠀꠘꠟ ꠘꠤ? ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ, ꠝꠥꠐꠦꠃ ꠘꠣꠄ! ꠛꠞꠋ ꠉꠥꠘꠣꠄꠃ ꠁꠔꠣ ꠇꠞꠍꠦ, ꠢꠦ ꠜꠣꠟꠣ ꠎꠤꠘꠤꠡ ꠖꠤꠀ ꠀꠝꠣꠞꠦ ꠝꠣꠞꠤꠀ ꠢꠣꠞꠤ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠟ, ꠉꠥꠘꠣ ꠔ ꠉꠥꠘꠣ। ꠀꠞ ꠅꠃ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠦꠃ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠉꠥꠘꠣ ꠅꠁꠟ ꠝꠡ꠆ꠔ ꠛꠠ ꠎꠊꠁꠘ꠆ꠘ। ");
INSERT INTO syls_vpl VALUES ("RM7_14","075_7_14","ROM","7","14","14","ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠡꠞꠤꠅꠔ ꠅꠁꠟꠉꠤ ꠞꠥꠢꠣꠘꠤ ꠎꠉꠔꠞ, ꠅꠁꠟꠦ ꠀꠝꠤ ꠅꠁꠟꠣꠝ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠎꠉꠔꠞ, ꠀꠝꠤ ꠡꠞꠤꠟꠞ ꠝꠞ꠆ꠎꠤꠞ ꠛꠣꠘ꠆ꠖꠘꠅ ꠕꠣꠇꠣꠄ ꠉꠥꠘꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("RM7_15","075_7_15","ROM","7","15","15","ꠀꠝꠤ ꠘꠤꠎꠦꠃ ꠔ ꠛꠥꠎꠤ ꠘꠣ, ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠣꠝ ꠇꠞꠤ। ꠀꠍꠟꠦ ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠞꠔꠣꠝ ꠌꠣꠁ, ꠁꠔꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠎꠦꠔꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁ ꠅꠔꠣꠃ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM7_16","075_7_16","ROM","7","16","16","ꠀꠞ ꠎꠦꠔꠣ ꠇꠞꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠅꠟꠣ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠎꠦꠛꠟꠣ ꠇꠞꠤ, ꠔꠦ ꠀꠝꠤ ꠄꠝꠘꠦꠃ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤꠀꠞ, ꠡꠞꠤꠅꠔ ꠀꠍꠟꠦꠅ ꠜꠣꠟꠣ ꠎꠤꠘꠤꠡ। ");
INSERT INTO syls_vpl VALUES ("RM7_17","075_7_17","ROM","7","17","17","ꠁꠔꠣ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠝꠤ ꠘꠤꠎꠦ ꠁꠟꠣ ꠇꠞꠤꠀꠞ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠎꠦ ꠉꠥꠘꠣꠄ ꠛꠡꠔ ꠇꠞꠦ, ꠢꠦ-ꠃ ꠀꠝꠣꠞꠦ ꠖꠤꠀ ꠁꠔꠣ ꠇꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM7_18","075_7_18","ROM","7","18","18","ꠀꠞ ꠀꠝꠤ ꠔ ꠛꠥꠎꠤꠀꠞ, ꠀꠝꠣꠞ ꠟꠃꠞ ꠝꠣꠎꠦ, ꠝꠣꠘꠤ ꠡꠞꠤꠟꠞ ꠈꠣꠁꠡꠞ ꠝꠣꠎꠦ ꠜꠣꠟꠣ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠃ ꠘꠣꠁ। ꠀꠝꠤ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠞ ꠈꠤꠀꠟ ꠕꠣꠇꠟꠦꠅ, ꠀꠝꠣꠞ ꠡꠣꠝꠞ꠆ꠕꠄ ꠇꠥꠟꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM7_19","075_7_19","ROM","7","19","19","ꠇꠣꠞꠘ ꠀꠝꠤ ꠎꠦꠔꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠔꠣꠝ ꠌꠣꠁ, ꠁꠔꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ, ꠅꠁꠟꠦ ꠎꠦ ꠛꠖ ꠇꠣꠝ ꠇꠞꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠅꠔꠣꠃ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM7_20","075_7_20","ROM","7","20","20","ꠔꠦ ꠎꠦꠔꠣ ꠇꠞꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠅꠔꠣꠃ ꠎꠦꠛꠟꠣ ꠇꠞꠤ, ꠄꠞ ꠝꠣꠘꠤ ꠅꠁꠟ ꠁꠔꠣ ꠀꠝꠤ ꠇꠞꠤ ꠘꠣ, ꠛꠞꠋ ꠎꠦ ꠉꠥꠘꠣꠄ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠦ, ꠢꠦ-ꠃ ꠁꠔꠣ ꠇꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM7_21","075_7_21","ROM","7","21","21","ꠅꠈꠘ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠜꠤꠔꠞꠦꠃ ꠖꠦꠈꠤꠀꠞ, ꠄꠇꠐꠣ ꠛꠖ ꠞꠤꠙꠥꠄ ꠇꠣꠝ ꠇꠞꠦꠞ, ꠀꠝꠤ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠦ, ꠛꠖ ꠇꠣꠝ ꠄꠝꠘꠦꠃ ꠀꠁꠀ ꠀꠎꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM7_22","075_7_22","ROM","7","22","22","ꠀꠍꠟꠦ ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠈꠣꠁꠍꠟꠔ ꠝꠣꠚꠤꠇ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠁ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠦ ꠈꠥꠡꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("RM7_23","075_7_23","ROM","7","23","23","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠡꠞꠤꠟꠞ ꠅꠋꠉꠞ ꠝꠣꠎꠦ ꠖꠥꠍꠞꠣ ꠀꠞꠇ ꠈꠣꠁꠍꠟꠔꠦ ꠇꠣꠝ ꠇꠞꠦꠞ, ꠀꠝꠣꠞ ꠖꠤꠟꠦ ꠘꠦꠇ ꠇꠣꠝꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠦꠅ, ꠅꠃ ꠛꠖ ꠈꠣꠁꠍꠟꠔꠦ ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠤꠀ, ꠀꠝꠣꠞꠦ ꠔꠣꠞ ꠉꠥꠟꠣꠝꠤꠔ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠣꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("RM7_24","075_7_24","ROM","7","24","24","ꠀꠝꠣꠞ ꠛꠠ ꠛꠖ ꠘꠍꠤꠛ! ꠀꠝꠣꠞ ꠡꠞꠤꠟꠞ ꠅꠃ ꠛꠖ ꠈꠣꠁꠍꠟꠔ, ꠎꠦꠉꠤꠄ ꠀꠝꠣꠞꠦ ꠝꠃꠔꠞ ꠙꠕꠦ ꠐꠣꠘꠦ, ꠔꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠇꠦ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠛ? ");
INSERT INTO syls_vpl VALUES ("RM7_25","075_7_25","ROM","7","25","25","ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠥꠞ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠍꠂꠘ! ꠅꠈꠘ ꠘꠤꠌ꠆ꠌꠤꠔ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠖꠤꠟꠞ ꠖꠤꠇ ꠕꠣꠇꠤ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠁ ꠡꠞꠤꠅꠔꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠤ, ꠅꠁꠟꠦ ꠡꠞꠤꠟꠞ ꠝꠞ꠆ꠎꠤꠞ ꠖꠤꠇ ꠕꠣꠇꠤ ꠀꠝꠤ ꠉꠥꠘꠣꠞ ꠈꠣꠁꠍꠟꠔꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM8_1","075_8_1","ROM","8","1","1","ꠔꠦ ꠅꠃ ꠔꠣꠟꠤꠝ ꠕꠣꠇꠤ ꠀꠝꠞꠣ ꠛꠥꠎꠤ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠦꠞꠣ ꠀꠙꠘ ꠎꠘ ꠛꠘꠤ ꠉꠦꠍꠂꠘ, ꠅꠈꠘ ꠔꠣꠞꠣꠞꠦ ꠀꠞ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM8_2","075_8_2","ROM","8","2","2","ꠉꠥꠘꠣ ꠀꠞ ꠝꠃꠔꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠝꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠦꠅꠞꠣ ꠞꠥꠢꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠈꠣꠟꠣꠍ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM8_3","075_8_3","ROM","8","3","3","ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠟꠣꠉꠤ ꠡꠞꠤꠅꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠔ ꠙꠣꠞꠍꠦ ꠘꠣ, ꠀꠞ ꠡꠞꠤꠅꠔꠦ ꠎꠦꠔꠣ ꠇꠞꠔ ꠙꠣꠞꠍꠦ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠘꠤꠎꠦꠃ ꠁꠔꠣ ꠇꠞꠍꠂꠘ। ꠔꠣꠁꠘ ꠔꠣꠘ ꠘꠤꠎꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠉꠥꠘꠣꠉꠣꠞ ꠝꠣꠘꠡꠞ ꠍꠥꠞꠔꠦ ꠙꠣꠑꠣꠁꠟꠣ, ꠉꠥꠘꠣꠞ ꠈꠦꠝꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ꠀꠞ ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠣꠎꠖꠤ ꠉꠥꠘꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠀ ꠔꠣꠞ ꠈꠦꠝꠔꠣꠞꠦ ꠛꠣꠔꠤꠟ ꠇꠞꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_4","075_8_4","ROM","8","4","4","ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠁꠔꠣ ꠇꠞꠟꠣ, ꠀꠝꠞꠣ ꠎꠦꠞꠣ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠡꠞꠤꠟꠞ ꠈꠣꠁꠡꠦ ꠘꠣ ꠌꠟꠤꠀ ꠞꠥꠢꠥꠞ ꠛꠡꠦ ꠌꠟꠤ, ꠅꠃ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠞꠤꠅꠔꠞ ꠖꠣꠛꠤ-ꠖꠣꠅꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_5","075_8_5","ROM","8","5","5","ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠀꠅꠔꠣꠄ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠌꠟꠂꠘ, ꠔꠣꠞꠣꠞ ꠝꠘꠅ ꠛꠖ ꠈꠣꠁꠡꠞ ꠛꠣꠄ ꠈꠤꠀꠟꠤ ꠕꠣꠇꠦ, ꠀꠞ ꠎꠦꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠀꠅꠔꠣꠄ, ꠔꠣꠞꠣꠞ ꠝꠘ ꠔ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠔꠦ ꠈꠤꠀꠟꠤ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("RM8_6","075_8_6","ROM","8","6","6","ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡ ꠎꠦ ꠇꠣꠝꠞ ꠈꠤꠀꠟꠤ, ꠁꠔꠣꠞ ꠚꠟ ꠅꠁꠟ ꠝꠞꠘ, ꠅꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠈꠤꠀꠟꠦ ꠌꠟꠣꠞ ꠚꠟ ꠅꠁꠟ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("RM8_7","075_8_7","ROM","8","7","7","ꠎꠦ ꠎꠘꠞ ꠝꠘ ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠛꠣꠄ ꠈꠤꠀꠟꠤ, ꠁ ꠝꠘ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠖꠥꠡꠝꠘ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠁ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠔꠦ ꠞꠣꠎꠤ ꠘꠣꠄ, ꠝꠣꠘꠔ ꠙꠣꠞꠦꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_8","075_8_8","ROM","8","8","8","ꠄꠞꠟꠣꠉꠤꠃ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠀꠅꠔꠣꠄ ꠌꠟꠂꠘ, ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_9","075_8_9","ROM","8","9","9","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠔ ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠀꠅꠔꠣꠄ ꠘꠣꠄ, ꠛꠞꠋ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠀꠅꠔꠣꠄ। ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠀꠟ-ꠝꠍꠤꠞ ꠞꠥꠢꠥ ꠎꠣꠞ ꠝꠣꠎꠦ ꠘꠣꠁ, ꠢꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM8_10","075_8_10","ROM","8","10","10","ꠀꠞ ꠢꠣꠍꠣꠃ ꠎꠥꠖꠤ ꠀꠟ-ꠝꠍꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠕꠣꠇꠂꠘ, ꠔꠦ ꠉꠥꠘꠣꠞ ꠚꠟ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟ ꠝꠞꠣꠞ ꠙꠕꠤ ꠅꠁꠟꠦꠅ, ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠚꠟ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣ ꠔ ꠎꠤꠘ꠆ꠖꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM8_11","075_8_11","ROM","8","11","11","ꠀꠞ ꠢꠃ ꠁꠍꠣꠞꠦ ꠎꠦꠁꠘ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠣꠘ ꠅꠃ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠝꠃꠔꠞ ꠀꠅꠔꠣꠄ ꠕꠣꠇꠣ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟꠞꠦꠅ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_12","075_8_12","ROM","8","12","12","ꠄꠞꠟꠣꠉꠤ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠀꠞ ꠑꠦꠇꠣꠔ ꠘꠣꠄ, ꠅꠃ ꠛꠖ ꠈꠣꠁꠡꠞ ꠅꠗꠤꠘꠦ ꠌꠟꠣꠞꠅ ꠎꠞꠥꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM8_13","075_8_13","ROM","8","13","13","ꠅꠈꠘ ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠀꠅꠔꠣꠄ ꠌꠟꠟꠦ ꠔ ꠔꠥꠝꠞꠣ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠝꠞꠛꠣꠄ, ꠅꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠡꠞꠤꠟꠞ ꠢꠇꠟ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟ꠆ꠟꠦ ꠌꠤꠞꠇꠣꠟ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM8_14","075_8_14","ROM","8","14","14","ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠎꠦꠞꠣ ꠌꠟꠦ, ꠔꠣꠞꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("RM8_15","075_8_15","ROM","8","15","15","ꠔꠥꠝꠞꠣ ꠔ ꠉꠥꠟꠣꠝꠤꠞ ꠞꠥꠢꠥ ꠙꠣꠁꠍ ꠘꠣ, ꠔꠦ ꠀꠞ ꠒꠞꠣꠁꠔꠣꠄ ꠇꠦꠘꠦ? ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠢꠃ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥ ꠙꠣꠁꠍ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠅꠟꠣꠖ ꠅꠀꠞ ꠄꠈꠔꠤꠀꠞ ꠖꠤꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠀꠝꠞꠣ ꠞꠥꠢꠣꠘꠤ ꠀꠛ꠆ꠛꠣ, ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠛꠣ ꠇꠁꠀ ꠒꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("RM8_16","075_8_16","ROM","8","16","16","ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠞ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠦꠅ ꠅꠟꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠀ ꠇꠁꠞꠣ, ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("RM8_17","075_8_17","ROM","8","17","17","ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠅꠟꠣꠖ, ꠔꠦ ꠀꠝꠞꠣ ꠝꠃꠞꠡꠤ ꠛꠣꠐ ꠙꠣꠁꠝꠥ। ꠀꠟ-ꠝꠍꠤꠄ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠝꠃꠞꠡꠤ ꠛꠣꠐ ꠙꠣꠁꠛꠣ, ꠀꠞ ꠔꠣꠘ ꠟꠉꠦ ꠀꠝꠞꠣꠅ ꠙꠣꠁꠝꠥ। ꠈꠣꠟꠤ ꠀꠝꠞꠣ ꠔꠣꠘ ꠟꠉꠦ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠟꠦ, ꠔꠣꠘ ꠟꠉꠦ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣꠞꠅ ꠜꠣꠉ ꠙꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM8_18","075_8_18","ROM","8","18","18","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠞꠣ ꠛꠣꠖꠦ ꠎꠦ ꠝꠢꠤꠝꠣ ꠙꠣꠁꠝꠥ, ꠁꠔꠣꠞ ꠔꠥꠟꠘꠣꠄ ꠅꠈꠘꠇꠥꠞ ꠁ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠄ, ꠁꠔꠣ ꠔ ꠀꠝꠤ ꠎꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("RM8_19","075_8_19","ROM","8","19","19","ꠢꠃ ꠡꠝꠄ ꠀꠁꠟꠦ ꠖꠦꠈꠣ ꠎꠣꠁꠛ ꠇꠦ ꠇꠦ ꠔꠣꠘ ꠀꠍꠟ ꠀꠅꠟꠣꠖ, ꠄꠞꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠣ ꠢꠇꠟꠔꠣꠄ ꠎꠣꠘꠦ-ꠙꠞꠣꠘꠦ ꠛꠣꠞ ꠌꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_20","075_8_20","ROM","8","20","20","ꠇꠣꠞꠘ ꠔꠣꠘ ꠙꠄꠖꠣ ꠇꠞꠣ ꠢꠇꠟꠔꠣꠃ ꠅꠈꠘ ꠅꠡꠣꠞ ꠅꠁꠉꠦꠍꠦ। ꠁꠔꠣ ꠇꠥꠘꠥ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠅꠡꠣꠞ ꠅꠁꠉꠦꠍꠦ ꠘꠤ? ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠣꠞꠣꠞꠦ ꠢꠃ ꠙꠕꠦ ꠍꠣꠠꠤ ꠖꠤꠍꠂꠘ। ꠅꠁꠟꠦ ꠄꠞꠟꠉꠦ ꠔꠣꠁꠘ ꠅꠃ ꠀꠡꠣꠅ ꠖꠤꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("RM8_21","075_8_21","ROM","8","21","21","ꠄꠇꠖꠤꠘ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠤꠘꠣꠡꠞ ꠀꠔ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠅꠁꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠡ꠆ꠛꠣꠗꠤꠘꠔꠣ ꠀꠞ ꠉꠃꠞꠛꠞ ꠜꠣꠉꠤ ꠅꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("RM8_22","075_8_22","ROM","8","22","22","ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠦꠈꠤꠀꠞ, ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣꠞ ꠇꠣꠟꠅ ꠝꠣʼꠄ ꠎꠦꠟꠣ ꠛꠥꠇ ꠚꠣꠐꠣꠁꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠘ, ꠔꠣꠘ ꠙꠄꠖꠣ ꠇꠞꠣ ꠢꠇꠟꠔꠣꠄꠃ ꠅꠟꠣ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠤ ꠌꠤꠟ꠆ꠟꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_23","075_8_23","ROM","8","23","23","ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠀꠝꠞꠣꠅ ꠢꠃ ꠎꠦ ꠝꠢꠤꠝꠣ ꠛꠣꠖꠦ ꠙꠣꠁꠝꠥ, ꠄꠞ ꠙꠄꠟꠣ ꠇꠤꠡ꠆ꠔꠤ ꠢꠤꠡꠣꠛꠦ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞꠦ ꠅꠈꠘ ꠙꠣꠁꠍꠤ, ꠙꠣꠁꠀ ꠛꠣꠇꠤ ꠇꠤꠡ꠆ꠔꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠀꠞ। ꠀꠞ ꠢꠃ ꠇꠤꠡ꠆ꠔꠤ ꠙꠣꠅꠀꠞ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠀꠞ, ꠎꠦ ꠖꠤꠘ ꠀꠝꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠎꠣꠁꠞ ꠇꠞꠣ ꠅꠁꠛ, ꠝꠣꠘꠤ ꠎꠦ ꠖꠤꠘ ꠀꠝꠞꠣꠞ ꠡꠞꠤꠟꠞꠦ ꠛꠤꠘꠣꠡꠞ ꠀꠔ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM8_24","075_8_24","ROM","8","24","24","ꠀꠝꠞꠣ ꠈꠣꠟꠣꠍ ꠅꠀꠞ ꠅꠃ ꠀꠡꠣ ꠙꠣꠁꠍꠤ, ꠁꠝꠣꠘ ꠀꠘꠣꠞ ꠇꠣꠟꠅ। ꠔꠦ ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡ ꠝꠣꠘꠡꠦ ꠖꠦꠈꠤꠟꠣꠄ, ꠁꠔꠣ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠢꠦ ꠀꠞ ꠀꠡꠣ ꠇꠞꠦ ꠘꠣ, ꠎꠦꠔꠣ ꠖꠦꠈꠣ ꠅꠁꠉꠦꠍꠦ, ꠁꠔꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠀꠡꠣ ꠀꠞ ꠇꠦꠘꠦ ꠇꠞꠔ? ");
INSERT INTO syls_vpl VALUES ("RM8_25","075_8_25","ROM","8","25","25","ꠅꠁꠟꠦ ꠘꠣ ꠖꠦꠈꠣ ꠎꠤꠘꠤꠡꠞꠦ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠗꠂꠎ꠆ꠎ ꠗꠞꠤꠀ ꠛꠣꠞ ꠌꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM8_26","075_8_26","ROM","8","26","26","ꠁꠔꠣ ꠍꠣꠠꠣ ꠀꠝꠞꠣꠞ ꠇꠝꠎꠥꠞꠤꠞ ꠡꠝꠄ ꠔ ꠙꠣꠇ ꠞꠥꠢꠦ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠂꠘ। ꠖꠥꠀ ꠇꠞꠣꠞ ꠇꠣꠟꠅ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠌꠣꠁꠔꠣꠝ, ꠁꠔꠣ ꠔ ꠀꠝꠞꠣ ꠎꠣꠘꠤ ꠘꠣ। ꠅꠁꠟꠦ ꠝꠥꠈꠖꠤ ꠎꠦꠔꠣ ꠇꠅꠀꠞ ꠡꠣꠁꠖ꠆ꠖ ꠘꠣꠁ, ꠖꠤꠟꠞ ꠇꠣꠘ꠆ꠖꠘꠞ ꠟꠉꠦ ꠙꠣꠇ ꠞꠥꠢꠦ ꠘꠤꠎꠦꠃ ꠀꠝꠞꠣꠞ ꠙꠇ꠆ꠇ ꠅꠁꠀ, ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔꠤ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM8_27","075_8_27","ROM","8","27","27","ꠇꠣꠞꠘ ꠎꠦꠁꠘ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠂꠘ, ꠔꠣꠁꠘ ꠔ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠕꠣꠅ ꠛꠥꠎꠂꠘ। ꠙꠣꠇ ꠞꠥꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠔꠣꠘ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔꠤ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM8_28","075_8_28","ROM","8","28","28","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞꠦ ꠎꠦꠞꠣ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠎꠦꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠢꠇꠟꠔꠣꠄ ꠄꠇꠟꠉꠦ ꠇꠣꠝ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("RM8_29","075_8_29","ROM","8","29","29","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠞꠣꠞꠦ ꠀꠉ ꠕꠣꠇꠤꠃ ꠔꠣꠘ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠞꠣꠈꠍꠤꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠍꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠀꠞ ꠟꠣꠉꠤꠃ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤꠟꠣ, ꠎꠣꠔꠦ ꠅꠃ ꠁꠍꠣ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠃ, ꠄꠞꠣ ꠢꠇꠟꠞ ꠛꠠ ꠜꠣꠁ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM8_30","075_8_30","ROM","8","30","30","ꠔꠣꠁꠘ ꠀꠉꠦ ꠎꠦꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤꠟꠣ, ꠔꠣꠞꠣꠞꠦꠃ ꠖꠣꠅꠔ ꠖꠤꠟꠣ। ꠀꠞ ꠎꠦꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠟꠣ, ꠀꠞ ꠎꠦꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠉꠁꠘ꠆ꠘ ꠇꠞꠟꠣ, ꠔꠣꠞꠣꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣꠅ ꠖꠣꠘ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_31","075_8_31","ROM","8","31","31","ꠅꠈꠘ ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠝ? ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣꠞ ꠙꠇ꠆ꠇꠦ, ꠔꠦ ꠀꠝꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠇꠦꠉꠥ ꠟꠣꠉꠔ? ");
INSERT INTO syls_vpl VALUES ("RM8_32","075_8_32","ROM","8","32","32","ꠀꠝꠞꠣ ꠢꠇꠟꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠤꠔꠦꠅ ꠘꠣꠞꠣꠎ ꠅꠁꠟꠣ ꠘꠣ, ꠔꠣꠘꠞꠦ ꠝꠃꠔꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠟꠣ, ꠔꠦ ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠟꠉꠦ ꠢꠇꠟꠔꠣꠃ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠔꠣ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM8_33","075_8_33","ROM","8","33","33","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠄꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠛꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠇꠣꠞ? ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦꠃ ꠔꠣꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM8_34","075_8_34","ROM","8","34","34","ꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠦꠉꠥꠄ ꠖꠥꠡꠤꠔ? ꠎꠦꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠃꠔ ꠅꠁꠍꠦ, ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠅ ꠔꠥꠟꠣ ꠅꠁꠍꠦ, ꠔꠣꠁꠘ ꠅꠈꠘ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠞ ꠔꠈ꠆ꠔꠅ ꠛꠁꠀ, ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠤꠘꠔ-ꠇꠣꠎ꠆ꠎꠤ ꠇꠞꠣꠔ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM8_35","075_8_35","ROM","8","35","35","ꠄꠞꠟꠣꠉꠤ ꠁꠟꠣ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠀꠍꠦ ꠘꠤ, ꠎꠦꠔꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠢꠛ꠆ꠛꠔ ꠕꠣꠇꠤ ꠀꠟꠉ ꠇꠞꠔ? ꠎꠥꠟꠥꠝ-ꠘꠤꠞ꠆ꠎꠣꠔꠘ, ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ, ꠝꠘꠞ ꠇꠡ꠆ꠐ, ꠈꠣꠅꠀ-ꠚꠤꠘ꠆ꠖꠣꠞ ꠅꠜꠣꠛ, ꠛꠤꠙꠖ-ꠀꠙꠖ ꠛꠣ ꠖꠥꠡꠝꠘꠞ ꠔꠟꠥꠀꠞ? ");
INSERT INTO syls_vpl VALUES ("RM8_36","075_8_36","ROM","8","36","36","ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, ꠔꠥꠝꠣꠞ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠈꠥꠘ ꠇꠞꠣ ꠅꠞ। ꠝꠣꠘꠡꠞ ꠌꠈꠥꠔ ꠀꠝꠞꠣ ꠅꠁꠟꠣꠝ ꠛꠟꠤꠞ ꠙꠣꠑꠣ। ");
INSERT INTO syls_vpl VALUES ("RM8_37","075_8_37","ROM","8","37","37","ꠘꠣ, ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ। ꠇꠣꠞꠘ ꠎꠦ ꠁꠍꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠅꠔ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠛꠟꠦ ꠀꠝꠞꠣ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠔꠃ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠄꠁ ꠅꠁꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("RM8_38","075_8_38","ROM","8","38","38","ꠔꠦ ꠀꠝꠤ ꠁꠈꠣꠘ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦꠃ ꠎꠣꠘꠤ, ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠛꠣ ꠝꠃꠔ, ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠣ ꠁꠛꠟꠤꠍꠞ ꠇꠥꠘꠥ ꠌꠦꠟꠣ, ꠅꠈꠘ ꠛꠣ ꠜꠛꠤꠡꠔꠞ ꠇꠥꠘꠥꠔꠣꠄꠃ, ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠡꠇ꠆ꠔꠤꠄꠃ, ");
INSERT INTO syls_vpl VALUES ("RM8_39","075_8_39","ROM","8","39","39","ꠀꠍꠝꠣꠘꠞ ꠛꠣ ꠙꠣꠔꠣꠟꠞ ꠛꠣ ꠙꠄꠖꠣ ꠅꠀ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠦꠃ ꠀꠝꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔ ꠕꠣꠇꠤ ꠀꠟꠉ ꠇꠞꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠔꠣꠘ ꠅꠃ ꠝꠢꠛ꠆ꠛꠔ ꠔ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("RM9_1","075_9_1","ROM","9","1","1","ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠤꠀ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠢꠣꠍꠣ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠀꠝꠣꠞ ꠛꠤꠛꠦꠇꠦꠅ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠟꠉꠦ ꠅꠁꠀ ꠅꠃ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("RM9_2","075_9_2","ROM","9","2","2","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠠ ꠀꠚꠍꠥꠍ ꠀꠞ ꠡꠤꠝꠣꠢꠤꠘ ꠇꠡ꠆ꠐ ꠟꠣꠉꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("RM9_3","075_9_3","ROM","9","3","3","ꠢꠣꠄꠞꠦ ꠢꠣꠄ, ꠀꠝꠤ ꠟꠣꠘ꠆ꠘꠔꠤꠞ ꠇꠣꠔꠣꠞꠅ ꠉꠤꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟ ꠅꠁꠀꠅ ꠎꠥꠖꠤ, ꠀꠝꠣꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁꠀꠁꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠛꠣꠌꠣꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM9_4","075_9_4","ROM","9","4","4","ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠅꠟꠣꠖꠞ ꠄꠈꠔꠤꠀꠞ ꠖꠤꠍꠂꠘ, ꠔꠣꠘ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠔꠣꠘ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠃꠍꠤꠟ꠆ꠟꠣ ꠅꠇꠟ ꠇꠣꠁꠝ ꠇꠞꠍꠂꠘ, ꠡꠞꠤꠅꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤꠞ ꠡꠥꠎꠥꠉ ꠇꠞꠤ ꠖꠤꠍꠂꠘ ꠀꠞ ꠛꠃꠔ ꠟꠣꠈꠣꠘ ꠅꠀꠖꠣꠅ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM9_5","075_9_5","ROM","9","5","5","ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝ, ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛ ꠘꠛꠤ ꠀꠍꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ। ꠛꠣꠖꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠅ ꠔ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠛꠣꠄ ꠕꠣꠇꠤ ꠄꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠅꠃ ꠎꠘꠝ ꠟꠁꠍꠂꠘ, ꠄꠁꠘ ꠢꠇꠟꠔꠣꠞ ꠃꠙꠞꠀꠟꠣ, ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠌꠤꠞꠇꠣꠟ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("RM9_6","075_9_6","ROM","9","6","6","ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠅꠇꠟ ꠅꠈꠘ ꠎꠦꠘ ꠛꠦꠇꠣꠝꠣ ꠅꠁꠉꠦꠍꠦ, ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠎꠘꠝ ꠅꠁꠟ ꠇꠞꠤꠃ, ꠄꠞꠣ ꠢꠇꠟ ꠔ ꠀꠍꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM9_7","075_9_7","ROM","9","7","7","ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠇꠞꠤꠃ ꠔꠣꠞꠣ ꠎꠦꠘ ꠔꠣꠘ ꠀꠍꠟ ꠀꠅꠟꠣꠖ, ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ꠛꠞꠋ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠔꠥꠝꠣꠞ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦꠃ ꠔꠥꠝꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠇꠁꠀ ꠉꠘꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("RM9_8","075_9_8","ROM","9","8","8","ꠝꠣꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠎꠘꠝ ꠅꠁꠍꠦ ꠉꠔꠤꠇꠦꠃ ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠤꠉꠦꠍ। ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠝꠣꠚꠤꠇ ꠎꠦꠞꠣ ꠀꠅꠟꠣꠖ ꠛꠘꠍꠦ, ꠔꠣꠞꠣꠞꠦꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM9_9","075_9_9","ROM","9","9","9","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠦꠍꠦ ꠅꠃ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, “ꠍꠣꠝꠘꠞ ꠛꠍꠞ ꠅꠃ ꠌꠣꠘ꠆ꠖꠅ ꠀꠝꠤ ꠚꠤꠞꠤꠀ ꠀꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠇꠥꠟꠅ ꠄꠇ ꠙꠥꠀ ꠕꠣꠇꠛ।” ");
INSERT INTO syls_vpl VALUES ("RM9_10","075_9_10","ROM","9","10","10","ꠀꠞ ꠅꠃ ꠙꠥꠀ ꠅꠁꠟꠣ, ꠀꠝꠞꠣꠞ ꠙꠥꠞ꠆ꠛꠙꠥꠞꠥꠡ ꠢꠎꠞꠔ ꠁꠍꠢꠣꠇ। ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠅꠃ ꠁꠍꠢꠣꠇꠞ ꠛꠤꠛꠤ ꠞꠦꠛꠦꠇꠣꠞ ꠙꠦꠐꠞ ꠎꠥꠠꠞ ꠙꠥꠀꠂꠘ ꠄꠇꠁ ꠛꠣꠚꠞ ꠀꠅꠟꠣꠖ ꠅꠁꠟꠦꠅ, ");
INSERT INTO syls_vpl VALUES ("RM9_11","075_9_11","ROM","9","11","12","ꠄꠞꠣ ꠝꠣʼꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠣ ꠢꠣꠟꠔꠦ ꠎꠦꠛꠟꠣ ꠜꠣꠟꠣ-ꠛꠥꠞꠣ ꠇꠤꠌ꠆ꠍꠥ ꠇꠞꠍꠂꠘ ꠘꠣ, ꠢꠃ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠄ ꠞꠦꠛꠦꠇꠣꠞꠦ ꠇꠁꠍꠟꠣ, “ꠔꠥꠝꠣꠞ ꠛꠠ ꠙꠥꠀ ꠔ ꠢꠥꠞꠥ ꠙꠥꠀꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠛ।” ꠅꠘ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠝꠥꠘꠡꠣ ꠙꠥꠞꠣ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠦ ꠝꠣꠘꠡꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ, ꠇꠦꠃꠞꠞ ꠀꠝꠟꠞ ꠛꠣꠄ ꠘꠣ ꠌꠣꠁꠀ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠍꠘ꠆ꠖ ꠝꠣꠚꠤꠇ ꠛꠣꠍꠤꠀ ꠘꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM9_13","075_9_13","ROM","9","13","13","ꠄꠞꠟꠣꠉꠤꠃ ꠙꠣꠇ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠀꠝꠤ ꠔ ꠁꠀꠇꠥꠛꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠍꠤ, ꠅꠁꠟꠦ ꠔꠣꠞ ꠜꠣꠁ ꠁꠡʼꠞꠦ ꠢꠞꠣꠁꠀ ꠞꠣꠈꠍꠤ।” ");
INSERT INTO syls_vpl VALUES ("RM9_14","075_9_14","ROM","9","14","14","ꠔꠦ ꠅꠈꠘ ꠀꠝꠞꠣ ꠇꠁꠔꠣꠝ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠄꠅ ꠅꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ? ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ, ꠝꠥꠐꠦꠃ ꠘꠣ! ");
INSERT INTO syls_vpl VALUES ("RM9_15","075_9_15","ROM","9","15","15","ꠀꠟ꠆ꠟꠣꠄ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞꠦ ꠇꠁꠍꠟꠣ, “ꠀꠝꠤ ꠎꠣꠞꠦ ꠈꠥꠡꠤ ꠖꠄꠀ ꠇꠞꠝꠥ, ꠀꠞ ꠎꠣꠞꠦ ꠈꠥꠡꠤ ꠞꠢꠝ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("RM9_16","075_9_16","ROM","9","16","16","ꠅꠘ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠞꠢꠝꠔ ꠔ ꠇꠦꠃꠞꠞ ꠌꠦꠡ꠆ꠐꠣꠄ ꠛꠣ ꠁꠌ꠆ꠍꠣꠄ ꠝꠤꠟꠦ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠕꠣꠇꠤꠃ ꠝꠤꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("RM9_17","075_9_17","ROM","9","17","17","ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠞ ꠀꠄꠀꠔꠅ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠚꠦꠞꠣꠃꠘꠞꠦ ꠇꠁꠍꠟꠣ, “ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠛꠣꠖꠡꠣ ꠛꠣꠘꠣꠁꠍꠤ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞ ꠝꠣꠎꠖꠤ ꠢꠇꠟꠦ ꠀꠝꠣꠞ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠤꠀ, ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠀꠝꠣꠞ ꠘꠣꠝ ꠎꠣꠁꠞ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("RM9_18","075_9_18","ROM","9","18","18","ꠔꠦ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠇꠦꠃꠞꠞꠦ ꠖꠄꠀ ꠇꠞꠂꠘ, ꠀꠞ ꠇꠦꠃꠞꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM9_19","075_9_19","ROM","9","19","19","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠎꠤꠇꠣꠁꠔꠣꠄ ꠙꠣꠞ, “ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤꠞ ꠛꠣꠁꠞꠣ ꠎꠦꠛꠟꠣ ꠇꠦꠃ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠦꠘꠦ ꠝꠣꠘꠡꠞ ꠖꠥꠡ-ꠔꠤꠞꠥꠐꠤ ꠉꠘꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("RM9_20","075_9_20","ROM","9","20","20","ꠁ ꠍꠅꠀꠟꠞ ꠡꠥꠎꠣ ꠎꠥꠀꠙ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠝꠣꠔꠣꠞ ꠔꠥꠝꠤ ꠇꠦ? ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠛꠣꠘꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠎꠤꠘꠤꠡꠦ ꠎꠤꠇꠣꠁꠔ ꠙꠣꠞꠛ ꠘꠤ, ꠀꠝꠣꠞꠦ ꠇꠦꠘꠦ ꠁꠟꠣ ꠛꠣꠘꠣꠁꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("RM9_21","075_9_21","ROM","9","21","21","ꠄꠇ ꠝꠣꠐꠤ ꠕꠣꠇꠤ ꠇꠥꠝꠣꠞꠦ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠞ ꠎꠤꠘꠤꠡ ꠛꠣꠘꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ ꠘꠤ? ꠁꠔꠣꠞ ꠇꠥꠘꠥꠐꠣ ꠁꠎ꠆ꠎꠔꠤ ꠇꠣꠝꠅ ꠀꠞ ꠇꠥꠘꠥꠐꠣ ꠡꠣꠗꠣꠞꠘ ꠇꠣꠝꠅ ꠟꠣꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("RM9_22","075_9_22","ROM","9","22","22","ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠟꠣꠘ꠆ꠘꠔ ꠀꠞ ꠇꠥꠖꠞꠔꠤ ꠈꠦꠝꠔꠣ ꠖꠦꠈꠣꠁꠔꠣ ꠌꠣꠁꠍꠟꠣ, ꠀꠞ ꠎꠦꠞꠣꠞ ꠃꠙꠞꠦ ꠁ ꠟꠣꠘ꠆ꠘꠔ ꠓꠣꠟꠤꠔꠣ ꠌꠣꠁꠍꠟꠣ, ꠄꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠀꠍꠤꠟ ꠈꠣꠟꠤ ꠛꠤꠘꠣꠡꠤ ꠉꠎꠛ, ꠔꠣ-ꠅ ꠔꠣꠁꠘ ꠛꠃꠔ ꠛꠠ ꠍꠛꠞ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠁꠔꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM9_23","075_9_23","ROM","9","23","23","ꠔꠣꠁꠘ ꠁꠔꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠟꠣ, ꠇꠣꠞꠘ ꠀꠞꠇꠛꠣꠞ ꠘꠤꠎꠞ ꠇꠥꠖꠞꠔꠤ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ। ꠀꠞ ꠎꠦꠞꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠍꠂꠘ, ꠄꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠀꠉꠦ ꠕꠣꠇꠤꠃ ꠎꠥꠁꠔ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠤꠟꠣ, ꠔꠣꠘ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤ ꠖꠦꠈꠣꠘꠤꠞ ꠈꠤꠀꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("RM9_24","075_9_24","ROM","9","24","24","ꠀꠍꠟꠦ ꠀꠝꠞꠣꠃ ꠅꠁꠟꠣꠝ ꠢꠃ ꠖꠄꠀꠞ ꠎꠘ। ꠀꠝꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠈꠣꠟꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠃ ꠖꠣꠅꠔ ꠖꠤꠀ ꠀꠘꠍꠂꠘ ꠘꠣ, ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠅ ꠔ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM9_25","075_9_25","ROM","9","25","25","ꠢꠎꠞꠔ ꠢꠥꠍꠤꠀ ꠘꠛꠤꠞ ꠍꠢꠤꠚꠣꠔ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠍꠂꠘ, ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠀꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠘꠣꠄ, ꠔꠣꠞꠣꠞꠦꠅ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠙ꠆ꠞꠎꠣ ꠛꠣꠘꠣꠁꠝꠥ। ꠀꠞ ꠎꠦꠞꠣ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ ꠀꠍꠤꠟ ꠘꠣ, ꠔꠣꠞꠣꠞꠦꠅ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ ꠇꠁꠀ ꠒꠣꠇꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM9_26","075_9_26","ROM","9","26","26","ꠎꠦ ꠎꠝꠤꠘꠅ ꠇꠅꠀ ꠅꠁꠍꠤꠟ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠙ꠆ꠞꠎꠣ ꠘꠣꠄ, ꠢꠃ ꠎꠝꠤꠘꠅꠃ ꠔꠣꠞꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠇꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM9_27","075_9_27","ROM","9","27","27","ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠇꠁꠍꠟꠣ, ꠉꠘꠣꠞ ꠛꠣꠟꠣ ꠎꠥꠖꠤꠅ ꠔꠣꠞꠣ ꠖꠞꠤꠀꠞ ꠌꠞꠞ ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠤꠡꠣꠛ, ꠔꠦꠛꠃ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠈꠥꠛ ꠢꠥꠞꠥ ꠄꠇ ꠅꠋꠡꠄ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM9_28","075_9_28","ROM","9","28","28","ꠝꠣꠛꠥꠖ ꠝꠃꠟꠣꠄ ꠎꠉꠔꠞ ꠙꠣꠅꠘꠣ ꠎꠦ ꠡꠣꠎꠣ ꠎꠥꠁꠔ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠡꠣꠎꠣ ꠈꠥꠛ ꠎꠟꠖꠤꠃ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM9_29","075_9_29","ROM","9","29","29","ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠀꠞꠅ ꠛꠣꠔꠣꠁꠍꠂꠘ, “ꠀꠟ꠆ꠟꠣ ꠞꠣꠛ꠆ꠛꠥꠟ ꠀꠟꠣꠝꠤꠘꠦ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠘꠣ ꠞꠣꠈꠔꠣ, ꠔꠦ ꠀꠝꠞꠣꠞ ꠖꠡꠣ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ ꠍꠣꠖꠥꠝ ꠀꠞ ꠀꠝꠥꠞꠣ ꠐꠣꠃꠘꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠟ ꠅꠘꠦ।” ");
INSERT INTO syls_vpl VALUES ("RM9_30","075_9_30","ROM","9","30","30","ꠔꠦ ꠀꠝꠞꠣ ꠅꠃ ꠇꠕꠣꠃ ꠇꠁꠝꠥ, ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠦ ꠎꠥꠖꠤꠅ ꠀꠟ꠆ꠟꠣꠞ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠀꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠍꠦ ꠘꠣ, ꠔꠦꠛꠃ ꠁꠝꠣꠘ ꠀꠘꠣꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM9_31","075_9_31","ROM","9","31","31","ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠈꠣꠟꠤ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠤꠀ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘꠔ ꠌꠣꠁꠍꠤꠟ, ꠅꠁꠟꠦ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠔ ꠙꠣꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM9_32","075_9_32","ROM","9","32","32","ꠀꠁꠌ꠆ꠍꠣ, ꠔꠣꠞꠣ ꠇꠦꠘꠦ ꠙꠣꠞꠍꠦ ꠘꠣ? ꠔꠣꠞꠣ ꠁꠝꠣꠘꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠈꠣꠟꠤ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠀꠝꠟꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠙꠣꠞꠍꠦ ꠘꠣ। ꠝꠣꠘꠡꠦ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠅ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠘ, ꠔꠣꠞꠣꠅ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠅ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM9_33","075_9_33","ROM","9","33","33","ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠢꠥꠘꠅ, ꠀꠝꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠅꠟꠣ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞ ꠛꠅꠀꠁꠍꠤ, ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠅ ꠝꠣꠘꠡꠦ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠀ ꠙꠠꠛ। ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠛ, ꠢꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM10_1","075_10_1","ROM","10","1","1","ꠔꠦ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠖꠤꠟꠞ ꠅꠃ ꠚꠞꠤꠀꠖ ꠀꠍꠦ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠀ ꠇꠞꠤꠀꠞ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM10_2","075_10_2","ROM","10","2","2","ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠅꠈꠣꠘꠃ ꠇꠁꠞꠣꠝ, ꠔꠣꠞꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠄꠡꠇꠤ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠎꠣꠘꠦ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠦꠝꠘꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM10_3","075_10_3","ROM","10","3","3","ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠅꠀꠞ ꠙꠕ ꠘꠣ ꠎꠣꠘꠣꠄ, ꠔꠣꠞꠣ ꠁ ꠙꠕꠞꠦ ꠝꠣꠘꠍꠦꠅ ꠘꠣ, ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠤꠀ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘꠔ ꠌꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM10_4","075_10_4","ROM","10","4","4","ꠅꠃ ꠡꠞꠤꠅꠔꠞ ꠢꠇꠟ ꠖꠣꠛꠤ-ꠖꠣꠅꠀ ꠀꠟ-ꠝꠍꠤꠄ ꠔ ꠀꠖꠣꠄ ꠇꠞꠤꠟꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠃꠙꠞꠦ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("RM10_5","075_10_5","ROM","10","5","5","ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠙꠞꠦꠎꠉꠣꠞ ꠅꠀꠞ ꠛꠦꠙꠣꠞꠦ, ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠍꠂꠘ, “ꠎꠦꠞꠣ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠔ ꠌꠣꠄ, ꠔꠣꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠣꠘꠟꠦ ꠛꠣꠌꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("RM10_6","075_10_6","ROM","10","6","6","ꠀꠞ ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠝꠣꠘꠥꠡ ꠇꠤꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘꠦ ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠝꠘꠦ ꠝꠘꠦ ꠇꠁꠅ ꠘꠣ, ꠇꠦ ꠉꠤꠀ ꠀꠍꠝꠣꠘꠅ ꠃꠑꠤꠔ?” ꠄꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠢꠘꠅ ꠃꠑꠤꠀ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠟꠣꠝꠣꠁꠀ ꠀꠘꠔ। ");
INSERT INTO syls_vpl VALUES ("RM10_7","075_10_7","ROM","10","7","7","ꠛꠣ ꠁꠈꠣꠘꠅ ꠇꠁꠅ ꠘꠣ, “ꠇꠦ ꠉꠤꠀ ꠙꠣꠔꠣꠟꠅ ꠟꠣꠝꠔ?” ꠄꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠢꠘꠅ ꠟꠣꠝꠤꠀ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠇꠄꠛꠞ ꠕꠣꠇꠤ ꠔꠥꠟꠤꠀ ꠀꠘꠔ। ");
INSERT INTO syls_vpl VALUES ("RM10_8","075_10_8","ROM","10","8","8","ꠘꠣ ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔ ꠔꠥꠝꠣꠞ ꠈꠥꠛ ꠗꠣꠞꠅ ꠀꠍꠦ, ꠁꠔꠣ ꠔꠥꠝꠣꠞ ꠝꠥꠈꠅ ꠀꠞ ꠔꠥꠝꠣꠞ ꠖꠤꠟꠅ ꠀꠍꠦ।” ꠀꠞ ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ, ꠁꠔꠣꠃ ꠔ ꠢꠃ ꠇꠣꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM10_9","075_10_9","ROM","10","9","9","ꠅꠈꠘ ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠝꠥꠈꠦ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠝꠣꠟꠤꠇ, ꠀꠞ ꠖꠤꠟꠦ ꠄꠇꠤꠘ ꠇꠞ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠦ ꠔꠥꠝꠤ ꠀꠈꠦꠞ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM10_10","075_10_10","ROM","10","10","10","ꠇꠣꠞꠘ ꠖꠤꠟꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠂꠘ, ꠀꠞ ꠝꠥꠈꠦ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠘꠣꠎꠣꠔ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM10_11","075_10_11","ROM","10","11","11","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠦ ꠛꠣꠔꠣꠄ, “ꠎꠦ ꠎꠘꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠛ, ꠢꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("RM10_12","075_10_12","ROM","10","12","12","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠃꠇ ꠛꠣ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠃꠇ, ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠔꠚꠣꠔ ꠘꠣꠁ, ꠇꠣꠞꠘ ꠢꠇꠟꠞ ꠝꠣꠟꠤꠇ ꠔ ꠄꠇꠎꠘ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠟꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠦ ꠛꠃꠔ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM10_13","075_10_13","ROM","10","13","13","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠦ ꠔ ꠇꠄ, “ꠎꠦꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠒꠣꠇꠤꠟꠦ, ꠢꠦ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛ।” ");
INSERT INTO syls_vpl VALUES ("RM10_14","075_10_14","ROM","10","14","14","ꠅꠁꠟꠦ ꠎꠣꠘ ꠃꠙꠞꠦ ꠔꠣꠞꠣ ꠁꠝꠣꠘꠃ ꠀꠘꠍꠦ ꠘꠣ, ꠔꠣꠘꠞꠦ ꠇꠤꠟꠣ ꠒꠣꠇꠤꠛ? ꠀꠞ ꠎꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞꠣ ꠢꠥꠘꠍꠦꠃ ꠘꠣ, ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠛ ꠇꠤꠟꠣ? ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣ ꠘꠣ ꠕꠣꠇꠟꠦ, ꠔꠣꠞꠣ ꠢꠥꠘꠛ ꠇꠤꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("RM10_15","075_10_15","ROM","10","15","15","ꠀꠞ ꠔꠛꠟꠤꠉꠅ ꠇꠦꠃ ꠘꠣ ꠙꠣꠑꠣꠁꠟꠦ, ꠔꠣꠞꠣ ꠇꠤꠟꠣ ꠔꠛꠟꠤꠉꠅ ꠎꠣꠁꠛ? ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, “ꠗꠁꠘ꠆ꠘ ꠔꠣꠞꠣꠞ ꠙꠣꠅ ꠈꠣꠘꠣꠁꠘ, ꠎꠦꠞꠣ ꠀꠐꠤ ꠀꠐꠤ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("RM10_16","075_10_16","ROM","10","16","16","ꠅꠁꠟꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔ ꠁ ꠈꠥꠡ-ꠈꠛꠞꠤꠞꠦ ꠇꠣꠘꠅ ꠑꠣꠁ ꠖꠦꠄ ꠘꠣ। ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠇꠁꠍꠂꠘ, “ꠅ ꠝꠣꠛꠥꠖ, ꠀꠝꠞꠣꠞ ꠔꠛꠟꠤꠉ ꠢꠥꠘꠤꠀ ꠇꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("RM10_17","075_10_17","ROM","10","17","17","ꠔꠦ ꠖꠦꠈꠣ ꠎꠣꠞ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠟꠦ ꠁꠝꠣꠘ ꠀꠄ, ꠅꠃ ꠇꠣꠟꠣꠝ ꠅꠁꠟ, ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠛꠟꠤꠉ। ");
INSERT INTO syls_vpl VALUES ("RM10_18","075_10_18","ROM","10","18","18","ꠅꠁꠟꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠦ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠍꠦ ꠘꠣ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ ꠢꠥꠘꠍꠦ। ꠙꠣꠇ ꠇꠣꠟꠣꠝꠦ ꠇꠄ, ꠔꠣꠞꠣꠞ ꠀꠅꠀꠎ ꠔ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠁꠔ ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠍꠦ, ꠍꠤꠔ꠆ꠞꠤ ꠉꠦꠍꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠔ-ꠇꠕꠣ, ꠖꠥꠘꠤꠀꠞ ꠄꠇ ꠝꠣꠕꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠝꠣꠕꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("RM10_19","075_10_19","ROM","10","19","19","ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠞꠣꠝ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠢꠃ ꠇꠣꠟꠣꠝ ꠛꠥꠎꠍꠂꠘ ꠘꠣ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ ꠛꠥꠎꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠞꠣꠞꠦ ꠇꠁꠍꠂꠘ, ꠎꠦꠐꠣ ꠎꠣꠔꠤ ꠘꠣꠁ ꠁꠟꠣ ꠎꠣꠔꠤ ꠖꠤꠀ ꠁꠋꠡꠣ ꠇꠞꠣꠁꠝꠥ, ꠀꠝ꠆ꠝꠇ ꠎꠣꠔꠤ ꠖꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠥꠍꠣ ꠔꠥꠟꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM10_20","075_10_20","ROM","10","20","20","ꠛꠣꠖꠦ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠈꠥꠛ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠁ ꠀꠄꠀꠔꠅ ꠇꠁꠍꠂꠘ, ꠀꠝꠣꠞꠦ ꠎꠦꠞꠣ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠍꠦ ꠘꠣ, ꠔꠣꠞꠣꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠁꠍꠦ। ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠌꠣꠁꠍꠦ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠀꠝꠤ ꠖꠤꠖꠣꠞ ꠖꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("RM10_21","075_10_21","ROM","10","21","21","ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠁꠞꠣ, ꠀꠝꠤ ꠀꠔ ꠛꠣꠠꠣꠁꠀ ꠒꠣꠇꠤꠞꠣꠝ, ꠢꠣꠞꠣ ꠖꠤꠘ ꠗꠞꠤ ꠖꠥꠁꠅ ꠀꠔꠦ ꠒꠣꠇꠤꠞꠣꠝ, ꠘꠣꠚꠞꠝꠣꠘ ꠀꠞ ꠙꠣꠡꠣꠘ ꠄꠇ ꠎꠣꠔꠤꠞꠦ ꠒꠣꠇꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM11_1","075_11_1","ROM","11","1","1","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠈꠘ ꠎꠤꠇꠣꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥ ꠔꠣꠘ ꠀꠙꠘ ꠛꠘ꠆ꠖꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉ ꠍꠣꠠꠤ ꠖꠤꠍꠂꠘ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ ꠘꠣ! ꠇꠣꠞꠘ ꠀꠝꠤ ꠘꠤꠎꠦꠅ ꠔ ꠄꠇꠎꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠞ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠛꠋꠡꠗꠞ, ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("RM11_2","075_11_2","ROM","11","2","2","ꠀꠟ꠆ꠟꠣꠄ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠔꠣꠘ ꠎꠦ ꠙ꠆ꠞꠎꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠀꠟꠉ ꠇꠞꠍꠤꠟꠣ, ꠔꠣꠁꠘ ꠔ ꠄꠞꠣꠞ ꠟꠉ ꠍꠣꠠꠍꠂꠘ ꠘꠣ। ꠢꠎꠞꠔ ꠁꠟꠤꠀꠍ ꠘꠛꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠇꠤꠔꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ? ꠔꠣꠁꠘ ꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠅꠃ ꠘꠣꠟꠤꠡ ꠖꠤꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RM11_3","075_11_3","ROM","11","3","3","“ꠅ ꠝꠣꠛꠥꠖ, ꠁꠔꠣꠄ ꠔꠥꠝꠣꠞ ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠍꠦ, ꠔꠥꠝꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠁꠘꠅ ꠜꠣꠋꠉꠤꠟꠤꠍꠦ। ꠈꠣꠟꠤ ꠀꠝꠤꠃ ꠛꠣꠌꠤꠀ ꠞꠁꠍꠤ, ꠅꠈꠘ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠎꠣꠘꠈꠣꠘꠅ ꠘꠤꠔꠣꠉꠤ ꠌꠣꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("RM11_4","075_11_4","ROM","11","4","4","ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠇꠤꠔꠣ ꠎꠥꠀꠙ ꠖꠤꠍꠟꠣ ꠝꠘꠅ ꠀꠍꠦ ꠘꠤ? ꠔꠣꠁꠘ ꠇꠁꠍꠟꠣ, “ꠅ ꠁꠟꠤꠀꠍ, ꠀꠝꠤ ꠔ ꠡꠣꠔ ꠀꠎꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠀꠟꠉ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠤ, ꠄꠞꠣ ꠔ ꠁ ꠛꠣꠀꠟ ꠖꠦꠛꠔꠣꠞꠦ ꠙꠞꠘꠣꠝ ꠇꠞꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("RM11_5","075_11_5","ROM","11","5","5","ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠞꠢꠝ ꠇꠞꠤꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠄꠇꠐꠣ ꠅꠋꠡꠞꠦ ꠅꠈꠘꠅ ꠀꠟꠉ ꠇꠞꠤ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM11_6","075_11_6","ROM","11","6","6","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠞꠢꠝ ꠇꠞꠤꠀ ꠄꠞꠣꠞꠦ ꠀꠟꠉ ꠇꠞꠍꠂꠘ, ꠔꠦ ꠁꠐꠣ ꠇꠥꠘꠥ ꠘꠦꠇ ꠀꠝꠟꠞ ꠚꠟ ꠘꠣꠄ। ꠀꠝꠟꠞ ꠚꠟ ꠅꠁꠟꠦ ꠔ ꠀꠞ ꠞꠢꠝꠔ ꠇꠅꠀ ꠅꠁꠟ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("RM11_7","075_11_7","ROM","11","7","7","ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠤꠀ ꠎꠦꠔꠣ ꠙꠣꠁꠔꠣ ꠌꠣꠁꠍꠟꠣ, ꠁꠔꠣ ꠔꠣꠞꠣ ꠙꠣꠁꠍꠂꠘ ꠘꠣ। ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠘꠦ ꠙꠣꠁꠍꠂꠘ। ꠅꠁꠟꠦ ꠛꠣꠇꠤ ꠢꠇꠟꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠛꠘꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM11_8","075_11_8","ROM","11","8","8","ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠦ ꠇꠁꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠛꠦꠃꠡꠤ ꠊꠥꠝꠅ ꠚꠣꠟꠣꠁꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠕꠣꠇꠔꠦꠅ ꠖꠦꠈꠦ ꠘꠣ, ꠇꠣꠘ ꠕꠣꠇꠟꠦꠅ ꠢꠥꠘꠦ ꠘꠣ। ꠀꠁꠎ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠢꠣꠟꠔꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM11_9","075_11_9","ROM","11","9","9","ꠅꠟꠣ ꠢꠎꠞꠔ ꠖꠣꠃꠖ ꠘꠛꠤꠄꠅ ꠇꠁꠞꠣ, ꠔꠣꠞꠣꠞ ꠗꠥꠝꠗꠣꠝ ꠇꠞꠤ ꠈꠣꠅꠀ-ꠖꠣꠅꠀꠃ ꠡꠤꠇꠣꠞꠞ ꠎꠣꠟ ꠀꠞ ꠚꠣꠘ꠆ꠖ ꠛꠘꠤꠎꠣꠃꠇ। ꠁꠔꠣ ꠔꠣꠞꠣꠞ ꠛꠤꠙꠖꠞ ꠇꠣꠞꠘ ꠅꠃꠇ, ꠛꠖ ꠇꠣꠝꠞ ꠡꠣꠎꠣ ꠛꠘꠤꠎꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("RM11_10","075_11_10","ROM","11","10","10","ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠀꠘ꠆ꠖꠣ ꠅꠁꠎꠣꠃꠇ ꠎꠣꠔꠦ ꠘꠣ ꠖꠦꠈꠦ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠇꠝꠞꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠉꠥꠎꠣ ꠇꠞꠤ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("RM11_11","075_11_11","ROM","11","11","11","ꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠅꠃ ꠛꠤꠙꠖꠞ ꠚꠣꠘ꠆ꠖꠅ ꠞꠁꠛ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ ꠘꠣ। ꠛꠞꠋ ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠄ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠘꠣꠎꠣꠔꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠉꠦꠟ। ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠁꠟꠣ, ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠣꠘꠥ ꠎꠣꠟꠣ ꠙꠄꠖꠣ ꠅꠄ, ꠇꠣꠞꠘ ꠜꠤꠘ ꠎꠣꠔꠤꠄ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠟꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM11_12","075_11_12","ROM","11","12","12","ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠉꠔꠞ ꠝꠣꠘꠡꠞ ꠛꠃꠔ ꠚꠣꠄꠖꠣ ꠅꠁꠍꠦ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠈꠦꠔꠤꠄ ꠎꠦꠛꠟꠣ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠟꠣꠜ ꠅꠁꠟ, ꠔꠦ ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠎꠣꠔꠞ ꠖꠣꠅꠔ ꠇꠛꠥꠟ ꠇꠞꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠦ ꠀꠞꠅ ꠇꠔ ꠛꠦꠡꠤ ꠞꠢꠝ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM11_13","075_11_13","ROM","11","13","13","ꠅ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦꠃ ꠀꠝꠣꠞꠦ ꠍꠣꠢꠣꠛꠤ ꠢꠤꠡꠣꠛꠦ ꠙꠣꠑꠣꠁꠟ ꠅꠁꠍꠦ ꠇꠞꠤ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠇꠣꠝꠞꠦ ꠈꠥꠛ ꠖꠣꠝ ꠖꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM11_14","075_11_14","ROM","11","14","14","ꠇꠣꠞꠘ, ꠅꠃ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠀ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠤꠟꠅ ꠇꠥꠘꠥ ꠎꠣꠟꠣ ꠙꠄꠖꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ, ꠀꠞ ꠅꠃ ꠎꠣꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM11_15","075_11_15","ROM","11","15","15","ꠔꠣꠞꠣ ꠖꠥꠞꠁ ꠢꠞꠤ ꠎꠣꠅꠀꠄ ꠎꠦꠛꠟꠣ ꠎꠉꠔꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠤꠟꠘ ꠅꠁꠟ, ꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠎꠦꠛꠟꠣ ꠢꠤꠞꠛꠣꠞ ꠑꠣꠁ ꠖꠤꠛꠣ ꠢꠃ ꠡꠝꠄ ꠇꠥꠘ ꠢꠣꠟꠔ ꠅꠁꠛ? ꠁꠔꠣ ꠝꠞꠣ ꠝꠣꠘꠥꠡ ꠎꠤꠔꠣ ꠅꠀꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM11_16","075_11_16","ROM","11","16","16","ꠗꠞꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠛꠤꠟꠣꠘꠤꠞ ꠞꠥꠐꠤꠞ ꠝꠥꠟ ꠈꠣꠁ ꠎꠥꠖꠤ ꠙꠛꠤꠔ꠆ꠞ ꠅꠄ, ꠔꠦ ꠔ ꠛꠣꠘꠣꠁꠟ ꠞꠥꠐꠤꠅ ꠙꠛꠤꠔ꠆ꠞ। ꠉꠣꠍꠞ ꠝꠥꠟ ꠎꠠ ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠟꠦ, ꠄꠞ ꠒꠣꠟ-ꠙꠣꠟꠣꠅ ꠘꠤꠌ꠆ꠌꠄ ꠙꠛꠤꠔ꠆ꠞ। ꠑꠤꠇ ꠅꠟꠣ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠟ ꠛꠣꠚ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠎꠦꠛꠟꠣ ꠙꠛꠤꠔ꠆ꠞ, ꠔꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠅ ꠙꠛꠤꠔ꠆ꠞ। ");
INSERT INTO syls_vpl VALUES ("RM11_17","075_11_17","ROM","11","17","17","ꠀꠞ ꠝꠘꠦ ꠇꠞꠅ, ꠉꠣꠍꠞ ꠇꠤꠍꠥ ꠒꠣꠟ-ꠙꠣꠟꠣ ꠇꠣꠐꠣ ꠅꠁꠟ, ꠛꠣꠖꠦ ꠅꠃ ꠇꠣꠐꠣ ꠎꠣꠉꠣꠔ ꠔꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠎꠋꠟꠤ ꠎꠄꠔꠥꠘ ꠉꠣꠍꠞ ꠇꠤꠍꠥ ꠒꠣꠟ ꠇꠟꠝ ꠖꠤꠀ ꠎꠥꠠꠣ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠔꠦ ꠔꠥꠝꠤ ꠘꠤꠌ꠆ꠌꠄ ꠝꠥꠟ ꠉꠣꠍ ꠕꠣꠇꠤꠃ ꠞꠡ ꠙꠣꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM11_18","075_11_18","ROM","11","18","18","ꠅꠈꠘ ꠔꠥꠝꠤꠅ ꠘꠤꠎꠞꠦ ꠢꠃ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠒꠣꠟ ꠕꠣꠇꠤ ꠛꠠ ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ, ꠁꠀꠖ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠤ ꠝꠥꠟ ꠉꠣꠍꠞꠦ ꠐꠤꠇꠣꠁ ꠞꠣꠈꠍ ꠘꠣ, ꠛꠞꠋ ꠝꠥꠟ ꠉꠣꠍꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠐꠤꠇꠣꠁꠀ ꠞꠣꠈꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM11_19","075_11_19","ROM","11","19","19","ꠔꠥꠝꠤ ꠁꠈꠣꠘ ꠇꠁꠔꠣꠄ ꠙꠣꠞ, “ꠀꠝꠣꠞꠦ ꠎꠥꠠꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤꠃ ꠔ ꠀꠉꠞ ꠒꠣꠟ-ꠙꠣꠟꠣꠁꠘ ꠇꠣꠐꠣ ꠅꠁꠍꠤꠟ।” ");
INSERT INTO syls_vpl VALUES ("RM11_20","075_11_20","ROM","11","20","20","ꠁꠈꠣꠘ ꠑꠤꠇ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠁꠝꠣꠘ ꠘꠣ ꠀꠘꠣꠞ ꠇꠣꠞꠘꠦꠃ ꠔ ꠔꠣꠞꠣꠞꠦ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠍꠦ, ꠀꠞ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠢꠘꠅ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠍꠦ। ꠔꠦ ꠔꠥꠝꠤꠅ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠘꠣ ꠖꠦꠈꠣꠁꠀ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("RM11_21","075_11_21","ROM","11","21","21","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠝꠥꠟ ꠒꠣꠟ-ꠙꠣꠟꠣꠞꠦꠃ ꠞꠦꠢꠣꠁ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠔꠦ ꠔꠥꠝꠤ ꠇꠟꠝꠞ ꠒꠣꠟꠞꠦ ꠇꠥꠘꠥ ꠞꠦꠢꠣꠁ ꠖꠤꠛꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("RM11_22","075_11_22","ROM","11","22","22","ꠄꠞꠟꠣꠉꠤꠃ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠅ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠇꠔ ꠖꠄꠀꠟ ꠀꠞ ꠇꠔ ꠙꠣꠡꠣꠘ। ꠎꠦꠞꠣ ꠛꠦ-ꠙꠕꠦ ꠚꠣꠐꠤ ꠉꠦꠍꠂꠘ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠙꠣꠡꠣꠘ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠣꠄ ꠔꠣꠁꠘ ꠖꠄꠀꠟꠥ, ꠎꠥꠖꠤ ꠔꠥꠝꠤ ꠔꠣꠘ ꠖꠄꠀꠞ ꠝꠣꠎꠦ ꠞꠅ, ꠘꠣ ꠞꠁꠟꠦ ꠔꠥꠝꠣꠞꠦꠅ ꠅꠟꠣ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM11_23","075_11_23","ROM","11","23","23","ꠀꠞ ꠢꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦꠅ ꠎꠥꠖꠤ ꠢꠤꠞꠛꠣꠞ ꠁꠝꠣꠘ ꠀꠘꠂꠘ, ꠔꠦ ꠔꠣꠞꠣꠞꠦꠅ ꠔꠣꠁꠘ ꠝꠥꠟ ꠉꠣꠍꠞ ꠟꠉꠦ ꠎꠥꠠꠣ ꠖꠤꠛꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠁꠟꠣ ꠎꠥꠠꠣ ꠖꠤꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM11_24","075_11_24","ROM","11","24","24","ꠀꠍꠟꠦ ꠔ ꠔꠥꠝꠤ ꠀꠍꠟꠣꠄ ꠎꠋꠟꠤ ꠎꠄꠔꠥꠘ ꠉꠣꠍꠞ ꠒꠣꠟ, ꠔꠥꠝꠣꠞꠦ ꠎꠦꠛꠟꠣ ꠢꠘ ꠕꠣꠇꠤ ꠇꠣꠐꠤꠀ ꠀꠘꠤꠀ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠛꠣꠉꠣꠘꠞ ꠎꠄꠔꠥꠘ ꠉꠣꠍꠞ ꠟꠉꠦ ꠀꠌꠣꠘꠇ ꠢꠣꠟꠔꠦ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠍꠦ। ꠔꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠅ, ꠎꠦꠞꠣ ꠅꠃ ꠉꠣꠍꠞ ꠀꠍꠟ ꠒꠣꠟ, ꠔꠣꠞꠣꠞꠦ ꠝꠥꠟ ꠉꠣꠍꠞ ꠟꠉꠦ ꠟꠣꠉꠣꠘꠤ ꠇꠔ ꠡꠥꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("RM11_25","075_11_25","ROM","11","25","25","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠣꠔꠦ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠀꠈꠟꠖꠣꠞ ꠘꠣ ꠛꠘ, ꠄꠞꠟꠣꠉꠤ ꠄꠇꠐꠣ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠤꠇꠣꠁ ꠖꠦꠁ। ꠢꠥꠘꠅ, ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠘꠣꠎꠣꠔ ꠙꠣꠅꠀꠞ ꠡꠋꠈꠣ ꠙꠥꠞꠣ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠃꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠢꠣꠟꠔꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM11_26","075_11_26","ROM","11","26","26","ꠢꠦꠡꠦ ꠅꠟꠣꠃ ꠢꠇꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛꠣ, ꠎꠦꠟꠣ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠀꠍꠦ, ꠔꠞꠣꠘꠦꠀꠟꠣꠄ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠍꠤꠅꠘ ꠙꠣꠠ ꠕꠣꠇꠤ, ꠔꠣꠁꠘ ꠁꠀꠇꠥꠛ ꠘꠛꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠈꠦꠖꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM11_27","075_11_27","ROM","11","27","27","ꠀꠝꠤ ꠅꠟꠣꠃ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞꠦ ꠢꠞꠣꠁꠟꠤꠝꠥ ꠁꠐꠣ ꠔ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠅꠀꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("RM11_28","075_11_28","ROM","11","28","28","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞꠣ ꠔ ꠅꠈꠘ ꠀꠟ꠆ꠟꠣꠞ ꠖꠥꠡꠝꠘ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠁ ꠙꠍꠘ꠆ꠖꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠍꠤꠟꠍꠤꠟꠣꠄ ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("RM11_29","075_11_29","ROM","11","29","29","ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠞꠢꠝꠔꠞ ꠖꠣꠘ-ꠖꠇ꠆ꠇꠤꠘꠣ ꠀꠞ ꠔꠣꠘ ꠖꠣꠅꠔꠞ ꠇꠕꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠝꠔ ꠛꠖꠟꠣꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM11_30","075_11_30","ROM","11","30","30","ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠅ ꠄꠇ ꠡꠝꠄ ꠘꠣꠚꠞꠝꠣꠘ ꠀꠍꠟꠣꠄ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠣꠄ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠙꠣꠁꠍ, ");
INSERT INTO syls_vpl VALUES ("RM11_31","075_11_31","ROM","11","31","31","ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠔꠥꠝꠞꠣ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠙꠣꠅꠀꠄ ꠔꠣꠞꠣ ꠅꠈꠘ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠦꠞ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠅ ꠅꠟꠣ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM11_32","075_11_32","ROM","11","32","32","ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠥꠘꠡꠣ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠎꠣꠔꠦ ꠢꠇꠟꠞ ꠛꠣꠄ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠖꠦꠈꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠢꠇꠟꠞꠦꠃ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM11_33","075_11_33","ROM","11","33","33","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠇꠔ ꠛꠠ! ꠔꠣꠘ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠇꠔ ꠉꠁꠘ! ꠔꠣꠘ ꠛꠤꠛꠦꠇ-ꠛꠤꠌꠣꠞ ꠛꠥꠎꠣꠞ ꠅꠡꠣꠁꠖ꠆ꠖ, ꠔꠣꠘ ꠇꠣꠝ-ꠇꠣꠎ ꠅꠇꠟ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤ ꠛꠥꠎꠣ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM11_34","075_11_34","ROM","11","34","34","ꠎꠦꠟꠣ ꠇꠤꠔꠣꠛꠅ ꠀꠍꠦ, ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠞ ꠝꠘ ꠌꠤꠘꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠇꠣꠞ ꠀꠍꠦ? ꠔꠣꠘꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠛꠣꠞ ꠟꠣꠈ ꠇꠦ ꠀꠍꠦ? ");
INSERT INTO syls_vpl VALUES ("RM11_35","075_11_35","ROM","11","35","35","ꠇꠦ ꠀꠉꠦ ꠀꠟ꠆ꠟꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠖꠤꠟꠣꠁꠔ ꠙꠣꠞꠍꠦ, ꠎꠦ ꠇꠣꠞꠘꠦ ꠔꠣꠁꠘ ꠔꠣꠞ ꠉꠦꠍꠦ ꠖꠦꠘꠣꠖꠣꠞ ꠀꠍꠂꠘ? ");
INSERT INTO syls_vpl VALUES ("RM11_36","075_11_36","ROM","11","36","36","ꠀꠍꠟꠦ ꠢꠇꠟꠔꠣꠃ ꠔ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ, ꠔꠣꠘ ꠝꠣꠎꠖꠤꠃ ꠀꠄ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ। ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠌꠤꠞꠇꠣꠟ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("RM12_1","075_12_1","ROM","12","1","1","ꠄꠞꠟꠣꠉꠤ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠣꠄ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠣꠍ ꠝꠤꠘꠔꠤ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠡꠞꠤꠟꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠦꠅ, ꠁꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠛꠥꠟ ꠅꠄ, ꠅꠇꠐꠣꠃ ꠅꠁꠛ ꠔꠥꠝꠞꠣꠞ ꠍꠢꠤ-ꠡꠥꠖ꠆ꠖ ꠄꠛꠣꠖꠔ। ");
INSERT INTO syls_vpl VALUES ("RM12_2","075_12_2","ROM","12","2","2","ꠀꠞ ꠅꠃ ꠈꠣꠞꠣꠙ ꠎꠝꠣꠘꠣꠞ ꠔꠣꠟꠅ ꠙꠠꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠘꠤꠎꠞ ꠖꠤꠟꠞ ꠜꠣꠛ ꠛꠖꠟꠣꠁꠀ ꠘꠄꠀ ꠝꠣꠘꠥꠡ ꠅꠅ। ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠛꠥꠎꠛꠣꠄ। ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠔ ꠜꠣꠟꠣ ꠀꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ, ꠅꠟꠣ ꠇꠞꠟꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM12_3","075_12_3","ROM","12","3","3","ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠎꠦ ꠈꠣꠍ ꠘꠤꠀꠝꠔ ꠖꠤꠍꠂꠘ, ꠅꠃ ꠘꠤꠀꠝꠔꠞ ꠛꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠞꠦ ꠇꠁꠞꠣꠝ, ꠘꠤꠎꠞꠦ ꠎꠔꠈꠣꠘ ꠛꠠ ꠝꠘꠅ ꠇꠞꠣ ꠃꠌꠤꠔ, ꠄꠞ ꠌꠣꠁꠔꠦ ꠛꠦꠡꠤ ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠦ ꠎꠔꠈꠣꠘ ꠁꠝꠣꠘꠤ ꠛꠟ ꠖꠤꠍꠂꠘ, ꠢꠦ ꠎꠣꠘꠥ ꠘꠤꠎꠞꠦ ꠄꠞ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠇꠥꠘ꠆ꠔꠣ ꠝꠘꠅ ꠘꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("RM12_4","075_12_4","ROM","12","4","4","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠀꠝꠞꠣ ꠢꠇꠟꠞ ꠡꠞꠤꠟꠅ ꠛꠃꠔ ꠅꠋꠉ ꠀꠍꠦ, ꠢꠇꠟ ꠅꠋꠉꠄ ꠔ ꠄꠇꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM12_5","075_12_5","ROM","12","5","5","ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠝꠥꠝꠤꠘ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣ ꠛꠃꠔ ꠎꠘ ꠅꠁꠟꠦꠅ, ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠀ ꠈꠣꠟꠤ ꠄꠇ ꠡꠞꠤꠟ ꠅꠁꠍꠤ। ꠄꠇꠁ ꠡꠞꠤꠟꠞ ꠅꠋꠉ ꠉꠔꠤꠇꠦ ꠀꠝꠞꠣꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠤꠟ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM12_6","075_12_6","ROM","12","6","6","ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠀꠝꠞꠣ ꠘꠣꠘꠣꠘ ꠎꠘꠦ ꠘꠣꠘꠣꠘ ꠟꠣꠈꠣꠘ ꠘꠤꠀꠝꠔ ꠙꠣꠁꠍꠤ, ꠅꠃ ꠘꠤꠀꠝꠔ ꠎꠥꠖꠤ ꠉꠣꠁꠛꠤ ꠅꠢꠤ ꠎꠣꠘꠣꠘꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠄ, ꠔꠦ ꠀꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠅꠟꠤ-ꠀꠃꠟꠤꠀꠞ ꠟꠣꠈꠣꠘ ꠅꠢꠤ ꠇꠁꠔꠦ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("RM12_7","075_12_7","ROM","12","7","7","ꠇꠦꠃ ꠎꠥꠖꠤ ꠈꠦꠎꠝꠔ ꠇꠞꠣꠞ ꠘꠤꠀꠝꠔ ꠙꠣꠄ, ꠔꠦ ꠈꠦꠎꠝꠔ ꠇꠞꠃꠇ। ꠀꠞ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣꠞ ꠘꠤꠀꠝꠔ ꠎꠦ ꠙꠣꠁꠍꠦ, ꠢꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("RM12_8","075_12_8","ROM","12","8","8","ꠃꠔꠡꠣꠢ ꠖꠤꠛꠣꠞ ꠘꠤꠀꠝꠔ ꠎꠦ ꠙꠣꠁꠍꠦ, ꠢꠦ ꠝꠣꠘꠡꠞꠦ ꠃꠔꠡꠣꠢ ꠖꠦꠃꠇ। ꠖꠣꠘ ꠇꠞꠣꠞ ꠘꠤꠀꠝꠔ ꠎꠦ ꠙꠣꠁꠍꠦ, ꠢꠦ ꠈꠣꠟꠤꠍ ꠘꠤꠅꠔꠦ ꠖꠣꠘ ꠇꠞꠃꠇ। ꠝꠥꠞꠛ꠆ꠛꠤꠀꠘꠣ ꠇꠞꠣꠞ ꠘꠤꠀꠝꠔ ꠎꠦ ꠙꠣꠁꠍꠦ, ꠢꠦ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠢꠇꠟꠔꠣ ꠌꠣꠟꠣꠃꠇ। ꠝꠣꠘꠡꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣꠞ ꠘꠤꠀꠝꠔ ꠎꠦ ꠙꠣꠁꠍꠦ, ꠢꠦ ꠈꠥꠡꠤ ꠝꠘꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("RM12_9","075_12_9","ROM","12","9","9","ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠈꠣꠖ ꠝꠤꠡꠣꠁꠅ ꠘꠣ। ꠈꠣꠞꠣꠙꠤꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠅ, ꠜꠣꠟꠣꠁꠞ ꠀꠡꠤꠇ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("RM12_10","075_12_10","ROM","12","10","10","ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠀꠙꠘ ꠜꠣꠁꠞ ꠟꠣꠈꠣꠘ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠣꠄꠀ ꠇꠞꠅ, ꠘꠤꠎ ꠕꠣꠇꠤ ꠅꠁꠘ꠆ꠘꠞꠦ ꠛꠦꠡꠤ ꠖꠣꠝ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("RM12_11","075_12_11","ROM","12","11","11","ꠈꠦꠎꠝꠔ ꠇꠣꠝꠅ ꠖꠥꠞ꠆ꠛꠟ ꠅꠁꠅ ꠘꠣ, ꠞꠥꠢꠥꠞꠦ ꠉꠞꠝ ꠞꠣꠈꠅ, ꠝꠣꠟꠤꠇꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠔ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("RM12_12","075_12_12","ROM","12","12","12","ꠍꠣꠝꠘꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞꠞ ꠀꠡꠣꠄ ꠢꠣꠝꠦꠡꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠅ, ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠅ ꠍꠛꠞ ꠇꠞꠅ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠣꠔ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("RM12_13","075_12_13","ROM","12","13","13","ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠅꠜꠣꠛꠅ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠅ। ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠔꠦ ꠈꠤꠀꠟꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("RM12_14","075_12_14","ROM","12","14","14","ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠞꠣ ꠎꠥꠟꠥꠝ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠦꠇ ꠖꠥꠀ ꠇꠞꠤꠅ, ꠛꠖ꠆ꠖꠥꠀ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM12_15","075_12_15","ROM","12","15","15","ꠎꠦꠞꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠦꠞ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠈꠥꠡꠤ ꠇꠞꠅ, ꠎꠦꠞꠣ ꠇꠣꠘ꠆ꠖꠦꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠇꠣꠘ꠆ꠖꠅ। ");
INSERT INTO syls_vpl VALUES ("RM12_16","075_12_16","ROM","12","16","16","ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠜꠣꠁ ꠜꠣꠁ ꠅꠁꠀ ꠞꠅ। ꠛꠠꠟꠥꠇꠤ ꠜꠣꠛ ꠘꠣ ꠖꠦꠈꠣꠁꠀ, ꠡꠣꠗꠣꠞꠘ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠤꠟꠤ-ꠝꠤꠡꠤ ꠌꠟꠅ। ꠘꠤꠎꠞ ꠙꠘ꠆ꠒꠤꠔꠤ ꠖꠦꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM12_17","075_12_17","ROM","12","17","17","ꠈꠣꠞꠣꠙꠤꠞ ꠛꠖꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠇꠦꠃꠞꠞ ꠈꠣꠞꠣꠙꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣꠞꠦ ꠜꠣꠟꠣ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠇꠞꠤꠀ ꠅꠔꠣꠃ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("RM12_18","075_12_18","ROM","12","18","18","ꠔꠥꠝꠞꠣꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠎꠔꠈꠣꠘ ꠡꠝ꠆ꠛꠛ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠡꠔ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("RM12_19","075_12_19","ROM","12","19","19","ꠅ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠛꠖꠟꠣ ꠟꠁꠅ ꠘꠣ, ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠔꠅ ꠍꠣꠠꠤ ꠖꠦꠅ, ꠛꠖꠟꠣ ꠖꠦꠅꠀ ꠔꠣꠘ ꠇꠣꠝ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, “ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠡꠣꠎꠣ ꠖꠤꠛꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠈꠣꠟꠤ ꠀꠝꠣꠞꠃ ꠀꠍꠦ, ꠎꠣꠞ ꠎꠦꠟꠣ ꠙꠣꠅꠘꠣ ꠀꠝꠤ ꠔꠣꠞꠦ ꠅꠟꠣ ꠛꠖꠟꠣ ꠖꠤꠝꠥ, ꠁꠈꠣꠘ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("RM12_20","075_12_20","ROM","12","20","20","ꠛꠞꠋ ꠇꠤꠔꠣꠛꠦ ꠇꠄ, “ꠔꠥꠝꠣꠞ ꠖꠥꠡꠝꠘꠞ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠟꠦ, ꠔꠣꠞꠦ ꠈꠣꠘꠤ ꠖꠦꠅ। ꠙꠤꠀꠍꠦ ꠗꠞꠟꠦ ꠔꠣꠞꠦ ꠙꠣꠘꠤ ꠖꠦꠅ। ꠅꠟꠣ ꠇꠞꠟꠦ ꠔ ꠔꠥꠝꠤ ꠔꠣꠞ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠁꠟ ꠀꠋꠞꠣꠞ ꠐꠥꠇꠞꠤ ꠕꠁꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("RM12_21","075_12_21","ROM","12","21","21","ꠈꠣꠞꠣꠙꠤꠞ ꠉꠦꠍꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠞꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠜꠣꠟꠣꠞꠦ ꠖꠤꠀ ꠈꠣꠞꠣꠙꠤꠞꠦ ꠀꠞꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("RM13_1","075_13_1","ROM","13","1","1","ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠦ ꠖꠦꠡꠞ ꠞꠣꠎꠣꠞꠦ ꠝꠣꠘꠤꠀ ꠌꠟꠃꠇ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠍꠣꠠꠣ ꠇꠦꠃ ꠞꠣꠎꠔ꠆ꠔ ꠙꠣꠄ ꠘꠣ, ꠞꠣꠎꠣ ꠅꠇꠟꠞꠦ ꠔ ꠀꠟ꠆ꠟꠣꠄꠃ ꠉꠖꠤꠔ ꠛꠅꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM13_2","075_13_2","ROM","13","2","2","ꠄꠞꠟꠣꠉꠤ ꠎꠦ ꠝꠣꠘꠡꠦ ꠖꠦꠡꠞ ꠞꠣꠎꠣꠞ ꠖꠥꠡꠝꠘꠤ ꠇꠞꠦ, ꠢꠦ ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠁ ꠢꠥꠇꠥꠝꠞ ꠖꠥꠡꠝꠘꠤ ꠇꠞꠦ। ꠁꠟꠣ ꠇꠣꠝ ꠎꠦꠔꠣꠄ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠔ ꠘꠤꠎꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠒꠣꠇꠤꠀ ꠀꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM13_3","075_13_3","ROM","13","3","3","ꠀꠞ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠞꠣ ꠎꠘꠦ ꠔ ꠞꠣꠎꠣꠞꠦ ꠒꠞꠣꠘꠤꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ, ꠅꠁꠟꠦ ꠇꠥ-ꠇꠣꠝ ꠇꠞꠞꠣ ꠎꠘꠞ ꠟꠣꠉꠤ ꠇꠑꠤꠘ ꠛꠤꠙꠖ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠘꠤꠞꠜꠄꠄ ꠞꠁꠔꠣꠄ ꠌꠣꠅ ꠘꠤ? ꠔꠣꠁꠟꠦ ꠜꠣꠟꠣ ꠙꠕꠦ ꠀꠐꠅ, ꠔꠦꠃ ꠞꠣꠎꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM13_4","075_13_4","ROM","13","4","4","ꠞꠣꠎꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠖꠤꠝ ꠢꠤꠡꠣꠛꠦ ꠇꠣꠝ ꠇꠞꠂꠘ। ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠇꠥ-ꠇꠣꠝ ꠇꠞ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠤꠙꠖ ꠀꠍꠦ। ꠔꠣꠁꠘ ꠈꠣꠝꠈꠣ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠞꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠇꠥ-ꠇꠣꠝ ꠇꠞꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠖꠤꠝ ꠢꠤꠡꠣꠛꠦ ꠑꠤꠇꠃ ꠡꠣꠎꠣ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM13_5","075_13_5","ROM","13","5","5","ꠔꠦ ꠈꠣꠟꠤ ꠡꠣꠎꠣꠞ ꠒꠞꠦ ꠘꠣꠄ, ꠛꠞꠋ ꠎꠣꠞꠎꠤꠞ ꠛꠤꠛꠦꠇꠞ ꠛꠤꠌꠣꠞꠦꠅ ꠞꠣꠎꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("RM13_6","075_13_6","ROM","13","6","6","ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠔ ꠔꠥꠝꠞꠣ ꠈꠣꠎꠘꠣ ꠖꠦꠅ, ꠇꠣꠞꠘ ꠈꠣꠎꠘꠣ ꠔꠥꠟꠤꠀ ꠈꠞꠌ ꠇꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM13_7","075_13_7","ROM","13","7","7","ꠅꠈꠘ ꠎꠣꠞ ꠎꠦꠟꠣ ꠙꠣꠅꠘꠣ, ꠔꠣꠞꠦ ꠅꠟꠣ ꠖꠦꠅ। ꠎꠦꠘꠞꠦ ꠈꠣꠎꠘꠣ ꠖꠤꠛꠣꠞ ꠇꠕꠣ, ꠄꠘꠞꠦ ꠈꠣꠎꠘꠣ ꠖꠦꠅ; ꠎꠦꠘꠞꠦ ꠝꠣꠡꠥꠟ ꠖꠤꠛꠣꠞ ꠇꠕꠣ, ꠄꠘꠞꠦ ꠝꠣꠡꠥꠟ ꠖꠦꠅ; ꠎꠦꠘꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠣꠞ ꠇꠕꠣ, ꠄꠘꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠅ; ꠎꠦꠘꠞꠦ ꠔꠣꠎꠤꠝ ꠇꠞꠣꠞ ꠇꠕꠣ, ꠄꠘꠦ ꠔꠣꠎꠤꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("RM13_8","075_13_8","ROM","13","8","8","ꠈꠣꠟꠤ ꠝꠣꠄꠀꠞ ꠞꠤꠘ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠛꠦꠙꠣꠞꠦ ꠇꠦꠃꠞꠞ ꠉꠦꠍꠦ ꠞꠤꠘꠤ ꠅꠁꠅ ꠘꠣ। ꠎꠣꠘ ꠘꠤ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠅꠁꠘ꠆ꠘ ꠎꠘꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠢꠦ ꠔ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠀꠖꠣꠄ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM13_9","075_13_9","ROM","13","9","9","ꠎꠦꠟꠣ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠀꠍꠦ, “ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠈꠥꠘ ꠇꠞꠤꠅ ꠘꠣ, ꠌꠥꠞꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠟꠥꠜ-ꠟꠣꠟꠌ ꠇꠞꠤꠅ ꠘꠣ,” ꠛꠣ ꠁ ꠟꠣꠈꠣꠘ ꠀꠞꠅ ꠎꠔ ꠢꠥꠇꠥꠝ ꠀꠍꠦ, ꠁ ꠢꠇꠟ ꠢꠥꠇꠥꠝꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠤ ꠇꠅꠀ ꠅꠁꠍꠦ, “ꠔꠥꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("RM13_10","075_13_10","ROM","13","10","10","ꠀꠞ ꠝꠣꠄꠀ ꠕꠣꠇꠟꠦ ꠇꠦꠃ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠈꠦꠔꠤ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠝꠣꠄꠀ ꠇꠞꠟꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠡꠞꠤꠅꠔꠃ ꠝꠣꠘꠣ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM13_11","075_13_11","ROM","13","11","11","ꠔꠦ ꠜꠣꠁ ꠅꠇꠟ, ꠅꠈꠘꠇꠥꠞ ꠎꠝꠣꠘꠣꠞ ꠢꠣꠟꠔ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠃ, ꠄꠞꠟꠣꠉꠤ ꠛꠥꠎꠤ-ꠢꠥꠘꠤ ꠌꠟꠅ। ꠔꠥꠝꠞꠣ ꠊꠥꠝ ꠕꠣꠇꠤ ꠢꠎꠣꠉ ꠅꠀꠞ ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ, ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠎꠦ ꠡꠝꠄ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟꠣꠝ, ꠢꠃ ꠢꠣꠟꠔ ꠕꠣꠇꠤꠅ ꠀꠝꠞꠣꠞ ꠘꠣꠎꠣꠔ ꠅꠈꠘ ꠀꠞꠅ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM13_12","075_13_12","ROM","13","12","12","ꠞꠣꠁꠔ ꠙꠥꠀꠁꠀ ꠢꠣꠞꠤ ꠛꠤꠀꠘ ꠅꠁꠎꠣꠞ; ꠅꠈꠘ ꠎꠟꠖꠤ ꠀꠅ, ꠀꠝꠞꠣ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠛꠖ ꠇꠣꠝ ꠍꠣꠠꠤꠀ ꠘꠥꠞꠞ ꠟꠦꠛꠣꠍ ꠟꠣꠉꠣꠁ, ꠀꠟ꠆ꠟꠣꠁ ꠀꠔꠤꠀꠞ ꠚꠤꠘ꠆ꠖꠤꠟꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM13_13","075_13_13","ROM","13","13","13","ꠢꠂ-ꠢꠥꠟ꠆ꠟꠣ ꠇꠞꠤ ꠝꠖ ꠈꠣꠁꠀ ꠐꠣꠟ ꠅꠀ, ꠎꠤꠘꠣ-ꠛꠖꠝꠣꠁꠡꠤ ꠛꠣ ꠝꠘꠉꠠꠣ ꠌꠟꠣ, ꠁꠋꠡꠣ ꠀꠞ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠛꠣꠖ ꠖꠤꠀ, ꠀꠅ, ꠀꠝꠞꠣ ꠖꠤꠘꠞ ꠚꠞꠦ ꠌꠟꠞꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠌꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("RM13_14","075_13_14","ROM","13","14","14","ꠚꠤꠘ꠆ꠘꠞ ꠟꠦꠛꠣꠍꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠚꠤꠘ꠆ꠖꠤꠟꠣꠅ। ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡ ꠝꠤꠐꠣꠘꠤꠞ ꠌꠤꠘ꠆ꠔꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠛꠣꠖ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("RM14_1","075_14_1","ROM","14","1","1","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠎꠦ ꠜꠣꠁ ꠁꠝꠣꠘꠦ ꠇꠝꠎꠥꠞ, ꠔꠣꠞꠦꠅ ꠀꠙꠘ ꠢꠤꠡꠣꠛꠦ ꠡꠝꠎꠅ, ꠔꠣꠞ ꠙꠍꠘ꠆ꠖ-ꠅꠙꠍꠘ꠆ꠖ ꠟꠁꠀ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM14_2","075_14_2","ROM","14","2","2","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠄꠇꠎꠘꠦ ꠝꠘꠅ ꠇꠞꠦ, ꠢꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠈꠣꠘꠤ ꠈꠣꠁꠔ ꠙꠣꠞꠛ, ꠅꠁꠟꠦ ꠇꠝꠎꠥꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠎꠘꠦ ꠈꠣꠟꠤ ꠘꠤꠞꠣꠝꠤꠡ ꠈꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM14_3","075_14_3","ROM","14","3","3","ꠔꠦ ꠝꠣꠍ-ꠝꠣꠋꠡ ꠈꠣꠅꠞꠣ ꠎꠘꠦ ꠅꠃ ꠘꠤꠞꠣꠝꠤꠡ ꠈꠣꠅꠞꠣ ꠎꠘꠞꠦ ꠎꠣꠘꠥ ꠘꠣ ꠍꠤꠠꠣꠄ। ꠀꠞ ꠘꠤꠞꠣꠝꠤꠡ ꠈꠣꠅꠞꠣꠄꠅ ꠎꠣꠘꠥ ꠝꠣꠍ-ꠝꠣꠋꠡ ꠈꠣꠅꠞꠣꠞꠦ ꠘꠣ ꠖꠥꠡꠦ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠖꠥꠁꠅꠎꠘꠞꠦꠃ ꠘꠤꠎꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM14_4","075_14_4","ROM","14","4","4","ꠀꠞ ꠔꠥꠝꠣꠞꠦ ꠇꠦꠉꠤꠄ ꠈꠦꠝꠔꠣ ꠖꠤꠟ, ꠀꠞꠇ ꠛꠦꠐꠣꠞ ꠉꠥꠟꠣꠝꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠔꠣꠄ? ꠢꠦ ꠑꠤꠇ ꠙꠕꠦ ꠀꠍꠦ, ꠘꠣ ꠜꠥꠟ ꠙꠕꠦ ꠀꠍꠦ ꠁꠈꠣꠘ ꠔ ꠔꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠛꠥꠎꠛꠣ। ꠀꠍꠟꠦ ꠔ ꠢꠦ ꠑꠤꠇ ꠙꠕꠦꠃ ꠞꠁꠛ, ꠝꠣꠟꠤꠇꠦꠃ ꠔꠣꠞꠦ ꠑꠤꠇ ꠙꠕꠦ ꠞꠣꠈꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM14_5","075_14_5","ROM","14","5","5","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠡꠣꠗꠣꠞꠘ ꠖꠤꠘ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠈꠣꠍ ꠖꠤꠘꠞ ꠚꠎꠤꠟꠔ ꠛꠦꠡꠤ। ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠢꠇꠟ ꠖꠤꠘꠞꠦꠃ ꠄꠇꠟꠣꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠦ। ꠔꠦ ꠁ ꠛꠦꠙꠣꠞꠦ ꠇꠦ ꠇꠤꠔꠣ ꠇꠞꠔ ꠘꠣ ꠇꠞꠔ, ꠁꠔꠣ ꠎꠣꠘꠥ ꠔꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠡꠣꠄ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("RM14_6","075_14_6","ROM","14","6","6","ꠎꠦ ꠝꠣꠘꠡꠦ ꠇꠥꠘꠥ ꠈꠣꠍ ꠖꠤꠘꠞꠦ ꠝꠣꠘꠦ, ꠢꠦ ꠔ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦꠃ ꠁꠔꠣ ꠝꠣꠘꠦ। ꠎꠦ ꠎꠘꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠈꠣꠘꠤ ꠈꠣꠄ, ꠢꠦ-ꠅ ꠔ ꠝꠣꠟꠤꠇꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦꠃ ꠈꠣꠄ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠈꠣꠄ, ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠢꠇꠟꠔꠣ ꠈꠣꠄ ꠘꠣ, ꠢꠦ-ꠅ ꠝꠣꠟꠤꠇꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠈꠣꠄ ꠘꠣ, ꠢꠦ-ꠅ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("RM14_7","075_14_7","ROM","14","7","7","ꠀꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠛꠘ꠆ꠖꠣꠃ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠦ ꠎꠤꠘ꠆ꠖꠣ ꠞꠄ ꠘꠣ, ꠀꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠝꠞꠦꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM14_8","075_14_8","ROM","14","8","8","ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁ, ꠈꠣꠟꠤ ꠝꠣꠟꠤꠇꠞ ꠟꠣꠉꠤꠃ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁ, ꠀꠞ ꠎꠦꠛꠟꠣ ꠝꠞꠘ ꠅꠄ, ꠈꠣꠟꠤ ꠝꠣꠟꠤꠇꠞ ꠟꠣꠉꠤꠃ ꠝꠞꠘ ꠅꠄ। ꠔꠦ ꠀꠝꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠟꠦꠅ ꠎꠦꠔꠣ, ꠝꠞꠟꠦꠅ ꠅꠔꠣ, ꠀꠝꠞꠣ ꠔ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠃ। ");
INSERT INTO syls_vpl VALUES ("RM14_9","075_14_9","ROM","14","9","9","ꠝꠣꠟꠤꠇ ꠀꠟ-ꠝꠍꠤꠅ ꠔ ꠝꠣꠞꠣ ꠉꠦꠍꠟꠣ ꠀꠞ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠖꠥꠁꠅ ꠖꠟꠞꠃ ꠝꠣꠟꠤꠇ ꠛꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM14_10","075_14_10","ROM","14","10","10","ꠔꠦ ꠔꠥꠝꠤ ꠇꠦꠘꠦ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠞ ꠈꠥꠔ ꠔꠥꠇꠣꠁꠞꠣꠄ? ꠔꠣꠞꠦ ꠇꠦꠘꠦ ꠍꠤꠠꠣꠁꠞꠣꠄ? ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠌꠣꠞꠞ ꠍꠣꠝꠘꠦ ꠔ ꠀꠝꠞꠣ ꠢꠇꠟꠃ ꠃꠛꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM14_11","075_14_11","ROM","14","11","11","ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ꠝꠣꠛꠥꠖꠦ ꠇꠁꠞꠣ, ꠀꠝꠣꠞ ꠘꠣꠝꠞ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠀꠞ, ꠢꠇꠟꠦꠃ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠛ, ꠙꠞꠔꠦꠇ ꠝꠥꠈꠦꠃ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠛ, ꠀꠝꠤꠃ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM14_12","075_14_12","ROM","14","12","12","ꠅꠘꠅ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣ ꠙꠞꠔꠦꠇꠦꠃ ꠎꠣꠞꠎꠤꠞ ꠇꠣꠝꠞ ꠢꠤꠡꠣꠛ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RM14_13","075_14_13","ROM","14","13","13","ꠔꠦ ꠀꠅ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠀꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠈꠥꠔ ꠗꠞꠣ ꠛꠘ꠆ꠖ ꠇꠞꠤ, ꠀꠞ ꠘꠤꠅꠔ ꠇꠞꠤ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠔꠣꠝ ꠘꠣꠄ, ꠎꠦ ꠇꠣꠝꠦ ꠀꠞꠇ ꠜꠣꠁꠞ ꠁꠝꠣꠘꠞ ꠈꠦꠔꠤ ꠅꠁꠛ, ꠛꠣ ꠔꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠘꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("RM14_14","075_14_14","ROM","14","14","14","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠀꠄ ꠀꠝꠤ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦꠃ ꠎꠣꠘꠤ ꠀꠞ ꠛꠥꠎꠤ, ꠄꠝꠘꠦ ꠔ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡꠃ ꠘꠣꠎꠣꠁꠎ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠔꠣꠞꠦ ꠘꠣꠎꠣꠁꠎ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠁꠔꠣ ꠘꠣꠎꠣꠁꠎ। ");
INSERT INTO syls_vpl VALUES ("RM14_15","075_14_15","ROM","14","15","15","ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠞꠇ ꠜꠣꠁꠄ ꠝꠘꠅ ꠖꠥꠈ ꠙꠣꠄ, ꠔꠦ ꠔ ꠔꠥꠝꠤ ꠔꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠞꠣꠄ ꠘꠣ। ꠎꠦ ꠜꠣꠁꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤꠄ ꠝꠃꠔ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠇꠥꠘꠥ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁ ꠜꠣꠁꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM14_16","075_14_16","ROM","14","16","16","ꠔꠥꠝꠤ ꠎꠦꠔꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠅ, ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠍꠞꠣ ꠎꠘꠦ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞꠦ ꠘꠣ ꠘꠤꠘ꠆ꠖꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM14_17","075_14_17","ROM","14","17","17","ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠈꠣꠟꠤ ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠄ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠦ ꠖꠦꠅꠀ ꠙꠞꠦꠎꠉꠣꠞꠤ, ꠡꠣꠘ꠆ꠔꠤ ꠀꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠞ ꠛꠦꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("RM14_18","075_14_18","ROM","14","18","18","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠎꠦꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠦ, ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣ ꠈꠥꠡꠤ ꠕꠣꠇꠂꠘ, ꠀꠞ ꠝꠣꠘꠡꠦꠅ ꠜꠣꠟꠣ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM14_19","075_14_19","ROM","14","19","19","ꠄꠞꠟꠣꠉꠤ ꠀꠅ, ꠀꠝꠞꠣ ꠅꠟꠣ ꠇꠣꠝ ꠇꠞꠤ, ꠎꠦ ꠇꠣꠝꠦ ꠡꠣꠘ꠆ꠔꠤ ꠇꠣꠁꠝ ꠅꠄ, ꠎꠦ ꠇꠣꠝꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM14_20","075_14_20","ROM","14","20","20","ꠀꠞ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠝꠞꠦ ꠛꠤꠘꠣꠡ ꠘꠣ ꠇꠞꠤ, ꠈꠣꠘꠤꠞ ꠎꠥꠇꠣ ꠢꠇꠟꠔꠣꠃ ꠔ ꠢꠣꠟꠣꠟ। ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠇꠥꠘꠥ ꠄꠇ ꠛꠤꠡꠦꠡ ꠈꠣꠘꠤ ꠈꠣꠅꠀꠄ ꠎꠥꠖꠤ ꠖꠥꠍꠞꠣ ꠝꠣꠘꠡꠞ ꠁꠝꠣꠘꠅ ꠇꠡ꠆ꠐ ꠟꠣꠉꠦ, ꠔꠦ ꠁꠔꠣ ꠈꠣꠅꠀ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠁꠎ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM14_21","075_14_21","ROM","14","21","21","ꠛꠤꠡꠦꠡ ꠇꠥꠘꠥ ꠉꠥꠡ꠆ꠔ ꠛꠣ ꠡꠞꠣꠛ ꠈꠣꠅꠀ, ꠎꠦ ꠇꠣꠝꠦ ꠔꠥꠝꠣꠞ ꠜꠣꠁꠄ ꠝꠘꠅ ꠖꠥꠈ ꠙꠣꠄ, ꠁꠝꠣꠘꠦ ꠛꠣꠗꠣ ꠙꠣꠄ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠣ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM14_22","075_14_22","ROM","14","22","22","ꠔꠥꠝꠣꠞ ꠖꠤꠟꠞ ꠄꠇꠤꠘꠞꠦ, ꠈꠣꠟꠤ ꠔꠥꠝꠤ ꠀꠞ ꠔꠥꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠎꠦ ꠞꠣꠈꠅ। ꠘꠦꠇ-ꠇꠙꠣꠟꠤ ꠔ ꠢꠃ ꠎꠘ, ꠎꠦ ꠎꠘꠦ ꠜꠣꠟꠣ ꠝꠘꠅ ꠇꠞꠤꠀ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠞ ꠝꠘꠅ ꠈꠥꠔꠈꠥꠔꠤ ꠀꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM14_23","075_14_23","ROM","14","23","23","ꠅꠁꠟꠦ ꠝꠘꠅ ꠈꠥꠔꠈꠥꠔꠤ ꠟꠁꠀ ꠎꠥꠖꠤ ꠢꠦ ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠄ, ꠔꠦ ꠔ ꠢꠦ ꠖꠥꠡꠤ। ꠇꠣꠞꠘ ꠢꠦ ꠎꠦꠔꠣ ꠈꠣꠁꠍꠦ, ꠁꠔꠣ ꠔꠣꠞ ꠛꠤꠛꠦꠇꠞ ꠅꠙꠍꠘ꠆ꠖ, ꠀꠞ ꠛꠤꠛꠦꠇꠞ ꠃꠟꠐꠣ ꠇꠣꠝꠃ ꠅꠁꠟ ꠉꠥꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RM15_1","075_15_1","ROM","15","1","1","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠎꠦꠞꠣꠞ ꠁꠝꠣꠘ ꠝꠎꠛꠥꠔ ꠀꠍꠦ, ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠞ ꠛꠣꠄ ꠘꠣ ꠌꠣꠁꠀ, ꠀꠝꠞꠣꠞ ꠇꠝꠎꠥꠞ ꠝꠔꠡꠇ꠆ꠇꠤ ꠝꠘꠣ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁꠀꠂꠘꠞꠦꠅ ꠎꠣꠘꠥ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RM15_2","075_15_2","ROM","15","2","2","ꠅꠔꠣ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣꠞ ꠘꠤꠅꠔꠦ, ꠙꠞꠔꠦꠇꠦꠃ ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠝꠘꠞ ꠙꠍꠘ꠆ꠖꠞꠦ ꠎꠣꠘꠥ ꠈꠥꠡ ꠞꠣꠈꠤ। ");
INSERT INTO syls_vpl VALUES ("RM15_3","075_15_3","ROM","15","3","3","ꠀꠟ-ꠝꠍꠤꠄꠅ ꠔ ꠔꠣꠘ ꠘꠤꠎꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, “ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞꠦ ꠎꠦꠞꠣ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠍꠦ, ꠔꠣꠞꠣꠞ ꠅꠃ ꠢꠇꠟ ꠛꠦꠁꠎ꠆ꠎꠔꠤ ꠀꠝꠣꠞ ꠃꠙꠞꠦꠃ ꠀꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RM15_4","075_15_4","ROM","15","4","4","ꠔꠦ ꠀꠉꠞ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠎꠔꠔꠣ ꠟꠦꠈꠣ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠔ ꠀꠝꠞꠣꠞꠦꠃ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠟꠦꠈꠣ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣꠞ ꠍꠛꠞ ꠀꠞ ꠡꠣꠘ꠆ꠔꠘꠣ ꠀꠄ, ꠀꠞ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RM15_5","075_15_5","ROM","15","5","5","ꠅꠈꠘ ꠍꠛꠞ ꠀꠞ ꠡꠣꠘ꠆ꠔꠘꠣ ꠖꠦꠅꠞꠣ ꠀꠟ꠆ꠟꠣꠄ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠙꠕꠦ ꠌꠟꠣꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠝꠘ ꠄꠇ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("RM15_6","075_15_6","ROM","15","6","6","ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠄꠇ ꠝꠘꠦ ꠀꠞ ꠄꠇ ꠝꠥꠈꠦ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM15_7","075_15_7","ROM","15","7","7","ꠄꠞꠟꠣꠉꠤꠃ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠟ-ꠝꠍꠤꠄ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠙꠘ ꠇꠞꠍꠤꠟꠣ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠀꠙꠘ ꠇꠞꠤꠟꠣꠅ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("RM15_8","075_15_8","ROM","15","8","8","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠟ꠆ꠟꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠥꠟ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠟꠉꠦ ꠎꠔ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠅꠔꠣꠞ ꠢꠇꠤꠇꠔꠤ ꠙꠞꠝꠣꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤ ꠀꠁꠀ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠈꠦꠎꠝꠔꠉꠣꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM15_9","075_15_9","ROM","15","9","9","ꠀꠞ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦꠅ ꠀꠁꠟꠣ, ꠎꠣꠔꠦ ꠄꠞꠣꠅ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠖꠦꠈꠤꠀ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠦ। ꠁ ꠛꠦꠙꠣꠞꠦ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠉꠦꠃ ꠇꠅꠀ ꠅꠁꠍꠦ, ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠝꠥ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠣꠞ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM15_10","075_15_10","ROM","15","10","10","ꠀꠞ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠅ ꠇꠅꠀ ꠅꠁꠍꠦ, ꠅ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ, ꠀꠟ꠆ꠟꠣꠞ ꠀꠙꠘ ꠙ꠆ꠞꠎꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ, ꠔꠥꠝꠞꠣꠅ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("RM15_11","075_15_11","ROM","15","11","11","ꠢꠤꠞꠛꠣꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠇꠅꠀ ꠅꠁꠍꠦ, ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠖꠦꠡ ꠀꠞ ꠉꠥꠡ꠆ꠐꠤꠄ ꠔꠣꠘ ꠘꠣꠝ ꠎꠚꠅ। ");
INSERT INTO syls_vpl VALUES ("RM15_12","075_15_12","ROM","15","12","12","ꠀꠞ ꠢꠎꠞꠔ ꠁꠡꠣꠄꠀ ꠘꠛꠤꠄ ꠟꠦꠈꠍꠂꠘ, ꠎꠦꠁꠘ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖ ꠛꠤꠘ ꠁꠀꠍꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠥꠟ ꠈꠥꠐꠤ, ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠁꠘ ꠀꠁꠛꠣ, ꠔꠣꠘ ꠃꠙꠞꠦꠃ ꠕꠣꠇꠛ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠀꠡꠣ-ꠜꠞꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("RM15_13","075_15_13","ROM","15","13","13","ꠔꠦ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠀꠡꠣ ꠖꠦꠅꠞꠣ ꠀꠟ꠆ꠟꠣꠄ ꠁꠝꠣꠘꠞ ꠛꠟꠦ, ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤꠞ ꠝꠣꠎꠦ ꠢꠣꠛꠥꠒꠥꠛꠥ ꠈꠣꠅꠀꠃꠇ꠆ꠇꠣ। ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠥꠖꠞꠔꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠛꠣꠁꠀ ꠙꠠꠛ। ");
INSERT INTO syls_vpl VALUES ("RM15_14","075_15_14","ROM","15","14","14","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠥꠎꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠈꠣꠘ ꠘꠦꠇ ꠘꠤꠅꠔꠦ ꠜꠞꠣ ꠀꠞ ꠍꠢꠤ-ꠡꠥꠖ꠆ꠖ ꠁꠝꠣꠘꠤ ꠀꠈꠟ ꠀꠍꠦ, ꠎꠣꠔꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("RM15_15","075_15_15","ROM","15","15","15","ꠔꠣ-ꠅ ꠇꠁꠄꠇꠐꠣ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠘꠅ ꠇꠞꠣꠁ ꠖꠤꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠅꠃ ꠘꠤꠀꠝꠔ ꠖꠤꠍꠂꠘ ꠇꠞꠤ, ꠀꠝꠤ ꠡꠣꠅꠡ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠤꠀꠞ, ");
INSERT INTO syls_vpl VALUES ("RM15_16","075_15_16","ROM","15","16","16","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠖꠤꠝ ꠢꠤꠡꠣꠛꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠘ ꠖꠦꠅꠀ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠤ ꠁꠝꠣꠝꠔꠤꠞ ꠇꠣꠝ ꠇꠞꠤꠀꠞ, ꠎꠣꠔꠦ ꠅꠃ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠦ ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠀ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠇꠛꠥꠟ ꠅꠀꠞ ꠎꠥꠇꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RM15_17","075_15_17","ROM","15","17","17","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦ ꠈꠦꠎꠝꠔ ꠇꠞꠤꠀꠞ, ꠅꠃ ꠇꠣꠝꠞ ꠇꠣꠞꠘꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠣꠞ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠘꠤꠞ ꠄꠈꠔꠤꠀꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RM15_18","075_15_18","ROM","15","18","18","ꠀꠟ-ꠝꠍꠤꠄ ꠀꠝꠣꠞ ꠝꠣꠎꠖꠤ ꠎꠦ ꠇꠣꠝ ꠢꠣꠍꠤꠟ ꠇꠞꠞꠣ, ꠄꠞ ꠛꠣꠁꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠤꠛꠣꠞ ꠡꠣꠅꠡ ꠀꠝꠣꠞ ꠘꠣꠁ। ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠇꠕꠣ, ꠀꠝꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ, ");
INSERT INTO syls_vpl VALUES ("RM15_19","075_15_19","ROM","15","19","19","ꠇꠦꠞꠣꠝꠔꠤ-ꠝꠥꠎꠦꠎꠣ ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞꠦꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣꠁꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠕꠣꠇꠤ ꠁꠟꠥꠞꠤꠇꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇꠟ ꠎꠣꠉꠣꠞ ꠝꠣꠎꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("RM15_20","075_15_20","ROM","15","20","20","ꠔꠦ ꠎꠦ ꠎꠣꠉꠣꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠢꠃ ꠎꠣꠉꠣꠔ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠃ ꠀꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠝꠥꠟ ꠇꠣꠝ ꠝꠘꠅ ꠇꠞꠤ। ꠀꠝꠤ ꠌꠣꠁ ꠘꠣ ꠀꠞꠇ ꠎꠘꠞ ꠉꠣꠠꠣ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠜꠞ ꠇꠞꠤꠀ ꠊꠞ ꠛꠣꠘꠣꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM15_21","075_15_21","ROM","15","21","21","ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ꠔꠣꠘ ꠇꠕꠣ ꠎꠦꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ ꠘꠣ ꠅꠈꠘ ꠔꠣꠞꠣ ꠁꠔꠣ ꠖꠦꠈꠛꠣ, ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠀꠉꠦ ꠎꠦꠞꠣ ꠢꠥꠘꠍꠂꠘ ꠘꠣ ꠔꠣꠞꠣ ꠅꠈꠘ ꠛꠥꠎꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RM15_22","075_15_22","ROM","15","22","22","ꠔꠦ ꠅꠃ ꠇꠣꠞꠘꠦ ꠀꠝꠤ ꠛꠃꠔ ꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀꠞ ꠙꠕꠦ ꠛꠣꠗꠣ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("RM15_23","075_15_23","ROM","15","23","23","ꠅꠁꠘ꠆ꠘ ꠎꠣꠉꠣꠔ ꠀꠝꠣꠞ ꠇꠣꠝ ꠡꠦꠡ ꠘꠣ ꠅꠀꠄ ꠎꠣꠅꠀ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠍꠦ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠁꠔꠣ ꠎꠣꠉꠣꠔ ꠀꠝꠣꠞ ꠔꠛꠟꠤꠉ ꠇꠣꠝ ꠡꠦꠡ, ꠇꠥꠘꠥ ꠎꠣꠉꠣꠃ ꠛꠣꠖ ꠞꠁꠍꠦ ꠘꠣ। ꠀꠍꠟꠦ ꠛꠃꠔ ꠛꠍꠞ ꠗꠞꠤꠃ ꠀꠝꠣꠞ ꠈꠤꠀꠟ ꠀꠍꠤꠟ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("RM15_24","075_15_24","ROM","15","24","24","ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘ ꠡ꠆ꠙꠦꠘ ꠖꠦꠡꠅ ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ। ꠀꠝꠤ ꠀꠡꠣ ꠇꠞꠞꠣꠝ, ꠢꠘꠅ ꠎꠣꠅꠀꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠅꠁꠛ, ꠀꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠀ ꠇꠄꠈꠣꠘ ꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠇꠣꠐꠣꠁꠝꠥ। ꠛꠣꠖꠦ ꠡ꠆ꠙꠦꠘꠅ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠃ ꠀꠝꠣꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠤꠀ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM15_25","075_15_25","ROM","15","25","25","ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠞꠤꠟꠤꠚ ꠛꠣꠐꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠎꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM15_26","075_15_26","ROM","15","26","26","ꠢꠤꠘꠅ ꠅꠜꠣꠛ-ꠅꠘꠐꠘꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠀꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠛꠣꠐꠤꠀ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠀꠞ ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠞ ꠎꠝꠣꠔ ꠅꠇꠟꠦ ꠇꠤꠍꠥ ꠡꠣꠁꠎ꠆ꠎ ꠔꠥꠟꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM15_27","075_15_27","ROM","15","27","27","ꠔꠣꠞꠣ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀ ꠁꠔꠣ ꠔꠥꠟꠍꠂꠘ। ꠎꠣꠘ ꠘꠤ, ꠁ ꠎꠝꠣꠔꠞ ꠜꠣꠁ-ꠛꠁꠘ ꠅꠇꠟ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠞ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠞꠤꠘꠤ ꠀꠍꠂꠘ। ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠁ ꠛꠣꠔꠥꠘꠤ ꠘꠤꠀꠝꠔꠞ ꠛꠣꠐ ꠎꠦꠛꠟꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠖꠤ ꠜꠤꠘ ꠎꠣꠔꠤꠄ ꠙꠣꠁꠍꠂꠘ, ꠔꠦ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠟꠣꠉꠤꠅ ꠎꠞꠥꠞ ꠅꠁꠟ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠄ-ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM15_28","075_15_28","ROM","15","28","28","ꠀꠝꠣꠞ ꠅꠃ ꠞꠤꠟꠤꠚ ꠛꠣꠐꠣꠔ ꠉꠤꠀ ꠢꠣꠞꠤ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠅꠁꠝꠥ, ꠁꠔꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠔꠣꠞꠣꠞ ꠀꠔꠅ ꠙꠃꠍꠤ ꠉꠦꠍꠦ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠡ꠆ꠙꠦꠘ ꠖꠦꠡꠅ ꠎꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM15_29","075_15_29","ROM","15","29","29","ꠀꠝꠤ ꠛꠥꠎꠤꠀꠞ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠀꠟ-ꠝꠍꠤꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠞꠢꠝ-ꠘꠤꠀꠝꠔ ꠟꠁꠀ ꠀꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RM15_30","075_15_30","ROM","15","30","30","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠢꠛ꠆ꠛꠔꠦ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠣꠍ ꠝꠤꠘꠔꠤ ꠇꠞꠤꠀꠞ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠅ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔꠞ ꠎꠤꠢꠣꠖ ꠌꠣꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("RM15_31","075_15_31","ROM","15","31","31","ꠖꠥꠀ ꠇꠞꠤꠅ, ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣꠞ ꠛꠤꠞꠥꠗꠤ ꠝꠣꠘꠡꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠝꠤ ꠎꠣꠘꠥ ꠞꠦꠢꠣꠁ ꠙꠣꠁ, ꠀꠞ ꠀꠝꠣꠞ ꠀꠘꠣ ꠁ ꠞꠤꠟꠤꠚ ꠈꠣꠘꠣꠁꠘ ꠎꠣꠘꠥ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠅ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠦ ꠡꠝꠎꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM15_32","075_15_32","ROM","15","32","32","ꠔꠦꠃ ꠀꠝꠤ ꠈꠥꠡꠤ ꠝꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠞꠣꠝ-ꠀꠄꠄꠡ ꠇꠞꠝꠥ, ꠁꠘꠡꠣꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RM15_33","075_15_33","ROM","15","33","33","ꠡꠣꠘ꠆ꠔꠤ ꠖꠦꠅꠞꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠃꠇ꠆ꠇꠣ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("RM16_1","075_16_1","ROM","16","1","1","ꠔꠦ ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠛꠁꠘ ꠚꠂꠛꠤ ꠛꠤꠛꠤꠞꠦ ꠙꠣꠑꠣꠁꠞꠣꠝ, ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠇꠤꠋꠇ꠆ꠞꠤꠀ ꠐꠣꠃꠘꠞ ꠁꠍꠣꠄꠁ ꠎꠝꠣꠔꠞ ꠈꠣꠖꠤꠝ, ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠀꠞ, ");
INSERT INTO syls_vpl VALUES ("RM16_2","075_16_2","ROM","16","2","2","ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠎꠦꠟꠣ ꠀꠙꠘ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠄꠘꠞꠦꠅ ꠅꠟꠣ ꠀꠙꠘ ꠝꠘꠅ ꠇꠞꠤꠅ। ꠔꠣꠁꠘ ꠔ ꠀꠝꠣꠞꠦ ꠀꠞ ꠀꠞꠅ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠎꠦꠇꠥꠘꠥ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠌꠣꠁꠟꠦ, ꠔꠥꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_3","075_16_3","ROM","16","3","3","ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣ ꠇꠣꠝ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠚꠤꠍꠇꠤꠟꠣ ꠀꠞ ꠀꠇꠤꠟꠞꠦ ꠀꠝꠣꠞ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_4","075_16_4","ROM","16","4","4","ꠀꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠔꠣꠞꠣ ꠘꠤꠎꠞꠦ ꠝꠃꠔꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠍꠟꠣ। ꠈꠣꠟꠤ ꠀꠝꠤ ꠘꠣꠄ, ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠞ ꠢꠇꠟ ꠎꠝꠣꠔꠃ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠤꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("RM16_5","075_16_5","ROM","16","5","5","ꠅꠈꠘ ꠔꠣꠞꠣꠞ ꠛꠣꠠꠤꠞ ꠎꠝꠣꠔꠅ ꠀꠁꠀ ꠎꠦꠞꠣ ꠡꠞꠤꠇ ꠅꠁꠘ, ꠄꠞꠣ ꠢꠇꠟꠞꠦꠃ ꠀꠝꠣꠞ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ꠔꠥꠞꠡ꠆ꠇꠞ ꠀꠍꠤꠀ ꠄꠟꠣꠇꠣꠔ ꠢꠇꠟ ꠙꠄꠟꠣ ꠎꠦꠁꠘ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠍꠟꠣ, ꠢꠃ ꠀꠙꠤꠘꠤꠔꠥꠍ ꠜꠣꠁꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ, ꠄꠁꠘ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("RM16_6","075_16_6","ROM","16","6","6","ꠀꠞ ꠢꠃ ꠝꠞꠤꠅꠝ ꠛꠤꠛꠤꠞꠦꠅ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠝꠦꠘꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM16_7","075_16_7","ROM","16","7","7","ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ ꠀꠘꠖ꠆ꠞꠘꠤꠇꠥꠍ ꠀꠞ ꠎꠥꠘꠤꠀꠞꠦꠅ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ, ꠄꠞꠣ ꠔ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠦꠟ ꠈꠣꠐꠤꠍꠂꠘ। ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠄꠞꠣ ꠈꠥꠛ ꠁꠎ꠆ꠎꠔꠤ ꠎꠘ, ꠄꠞꠣ ꠀꠝꠣꠞ ꠀꠉꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM16_8","075_16_8","ROM","16","8","8","ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠀꠝꠚꠤꠟꠥꠍꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_9","075_16_9","ROM","16","9","9","ꠀꠝꠞꠣꠞ ꠟꠉꠞ ꠔꠛꠟꠤꠉꠇꠣꠞꠤ ꠃꠞꠛꠣꠘ ꠜꠣꠁꠞꠦ, ꠀꠞ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ ꠡ꠆ꠔꠣꠈꠤꠍꠞꠦꠅ ꠍꠣꠟꠣꠝ ꠇꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_10","075_16_10","ROM","16","10","10","ꠀꠟ-ꠝꠍꠤꠞ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠙꠣꠡ ꠇꠞꠣ ꠍꠤꠙꠣꠁ ꠀꠚꠤꠟꠤꠍ ꠜꠣꠁꠞꠦꠅ ꠍꠣꠟꠣꠝ ꠖꠤꠅ। ꠜꠣꠁ ꠀꠞꠤꠡ꠆ꠔꠣꠛꠥꠟꠞ ꠛꠣꠠꠤꠞ ꠢꠇ꠆ꠇꠟꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_11","075_16_11","ROM","16","11","11","ꠀꠝꠣꠞ ꠎꠣꠔꠤꠞ ꠜꠣꠁ ꠢꠦꠞꠥꠖꠥꠘꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠅ। ꠝꠞꠢꠥꠝ ꠘꠣꠇꠤꠍꠥꠍꠞ ꠛꠣꠠꠤꠞ ꠎꠦꠞꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠍꠂꠘ, ꠔꠣꠞꠣꠞꠦꠅ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_12","075_16_12","ROM","16","12","12","ꠔꠥꠞꠚꠣꠘꠣ ꠀꠞ ꠔꠥꠞꠚꠣꠍꠣ ꠛꠤꠛꠤꠞꠦꠅ ꠍꠣꠟꠣꠝ ꠖꠤꠅ। ꠅꠃ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠟꠣꠉꠤ ꠛꠠ ꠝꠦꠘꠔ ꠇꠞꠞꠣ। ꠝꠣꠄꠀꠞ ꠛꠁꠘ ꠚꠣꠞ꠆ꠍꠤꠀꠞꠦꠅ ꠍꠣꠟꠣꠝ ꠇꠁꠅ, ꠝꠣꠟꠤꠇꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘꠅ ꠛꠃꠔ ꠝꠦꠘꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RM16_13","075_16_13","ROM","16","13","13","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠙꠍꠘ꠆ꠖꠞ ꠝꠣꠘꠥꠡ ꠞꠃꠚ ꠜꠣꠁꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠅ, ꠔꠣꠘ ꠀꠝ꠆ꠝꠣꠞꠦꠅ ꠍꠣꠟꠣꠝ ꠇꠁꠅ, ꠁ ꠛꠦꠐꠤ ꠔ ꠀꠝꠣꠞꠅ ꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("RM16_14","075_16_14","ROM","16","14","14","ꠍꠤꠋꠇꠤꠞꠣꠔ, ꠚꠤꠟꠤꠉꠥꠘ, ꠢꠣꠞ꠆ꠝꠤꠍ, ꠚꠣꠔꠞꠥꠛ, ꠢꠦꠞ꠆ꠝꠣꠍ ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠔ ꠁꠝꠣꠘꠖꠣꠞ ꠛꠘ꠆ꠖꠣ ꠀꠍꠂꠘ, ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_15","075_16_15","ROM","16","15","15","ꠜꠣꠁ ꠚꠤꠟꠣꠉꠤ, ꠎꠥꠟꠤꠀ ꠛꠤꠛꠤ, ꠘꠤꠞꠤꠀꠍ ꠀꠞ ꠔꠣꠘ ꠛꠁꠘꠞꠦ, ꠀꠞ ꠅꠟꠤꠝ꠆ꠙꠣꠍꠞꠦ ꠍꠣꠟꠣꠝ ꠇꠁꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠎꠔ ꠛꠘ꠆ꠖꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠂꠘ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_16","075_16_16","ROM","16","16","16","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠙꠛꠤꠔ꠆ꠞ ꠉꠟꠣꠉꠟꠤ ꠇꠞꠤꠅ। ꠀꠟ-ꠝꠍꠤꠞ ꠢꠇꠟ ꠎꠝꠣꠔꠞ ꠜꠣꠁ-ꠛꠘꠤꠘ꠆ꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM16_17","075_16_17","ROM","16","17","17","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠞꠣꠝ, ꠀꠉꠦ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍ, ꠅꠃ ꠔꠣꠟꠤꠝꠞ ꠃꠟꠐꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠎꠦꠉꠥꠁꠘ꠆ꠔꠦ ꠖꠟꠣꠖꠟꠤ ꠀꠞ ꠛꠣꠗꠣ-ꠛꠤꠊꠘꠞ ꠎꠘꠝ ꠖꠦꠁꠘ, ꠅꠔꠣꠞ ꠛꠣꠄ ꠘꠎꠞ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_18","075_16_18","ROM","16","18","18","ꠇꠣꠞꠘ ꠁꠔꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠥꠟꠣꠝꠤ ꠘꠣ ꠇꠞꠤꠀ, ꠔꠣꠞꠣꠞ ꠙꠦꠐꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠦ। ꠝꠤꠑꠣ ꠝꠤꠑꠣ ꠝꠣꠔ ꠝꠣꠔꠤꠀ ꠀꠞ ꠔꠦꠟ ꠝꠣꠟꠤꠡ ꠇꠞꠤꠀ ꠡꠞꠟ-ꠡꠥꠎꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RM16_19","075_16_19","ROM","16","19","19","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠘ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠌꠟꠞꠣꠄ, ꠁꠔꠣ ꠔ ꠢꠇꠟꠦꠃ ꠎꠣꠘꠦ, ꠁ ꠈꠛꠞ ꠢꠥꠘꠤꠀ ꠀꠝꠤꠅ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠍꠤ। ꠔꠦ ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠘꠦꠇ ꠙꠕꠦ ꠇꠣꠝꠤꠟ ꠅꠅ, ꠛꠖ ꠙꠕ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("RM16_20","075_16_20","ROM","16","20","20","ꠡꠣꠘ꠆ꠔꠤ ꠖꠦꠅꠞꠣ ꠀꠟ꠆ꠟꠣꠄ ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘꠞꠦ ꠈꠥꠛ ꠎꠟꠖꠤ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠦ ꠚꠣꠟꠣꠁ ꠙꠤꠡꠣꠁꠛꠣ। ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝ-ꠘꠤꠀꠝꠔ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠞꠤ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("RM16_21","075_16_21","ROM","16","21","21","ꠀꠝꠣꠞ ꠟꠉꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠂꠘ ꠎꠦ ꠔꠤꠝꠕꠤ ꠜꠣꠁ, ꠄꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ꠀꠝꠣꠞ ꠎꠣꠔꠤ ꠜꠣꠁ ꠟꠥꠇꠤꠀꠍ, ꠎꠣꠍꠥꠘ ꠀꠞ ꠍꠥꠙꠣꠔꠍꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠇꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM16_22","075_16_22","ROM","16","22","22","ꠢꠎꠞꠔ ꠙꠣꠃꠟꠥꠍꠞ ꠛꠥꠟꠤ ꠢꠥꠘꠤꠀ ꠀꠝꠤ ꠔꠞ꠆ꠔꠤꠃꠍ ꠝꠢꠞꠤꠞꠦ ꠟꠦꠈꠞꠣꠝ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠀꠝꠤꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RM16_23","075_16_23","ROM","16","23","24","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠎꠝꠣꠔꠞ ꠢꠇꠟꠞꠦ ꠎꠦꠁꠘ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠂꠘ, ꠢꠃ ꠉꠃꠍ ꠜꠣꠁꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ꠅꠃ ꠐꠣꠃꠘꠞ ꠡꠞꠇꠣꠞꠤ ꠇꠦꠡꠤꠀꠞ ꠁꠞꠣꠡ꠆ꠔꠣꠍ ꠜꠣꠁꠄ ꠀꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠇꠥꠀꠔꠥꠍꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RM16_25","075_16_25","ROM","16","25","25","ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ, ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠈꠦꠝꠔꠣ ꠀꠍꠦ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠝꠣꠘꠦ ꠕꠤꠞ ꠞꠣꠈꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠛꠃꠔ ꠎꠝꠣꠘꠣ ꠗꠞꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠁ ꠛꠣꠔꠥꠘꠤ ꠝꠥꠘꠡꠣꠞ ꠇꠕꠣ ꠟꠥꠇꠣꠁ ꠞꠣꠈꠍꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RM16_26","075_16_26","ROM","16","26","26","ꠅꠁꠟꠦ ꠅꠈꠘ ꠁꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠅꠞ। ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠦ, ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠘꠛꠤ ꠅꠇꠟꠦ ꠎꠦꠔꠣ ꠟꠦꠈꠤꠀ ꠞꠣꠈꠍꠤꠟꠣ, ꠅꠔꠣ ꠎꠣꠁꠞ ꠅꠞ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠛꠣꠁꠖ꠆ꠖ ꠅꠁꠘ। ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠅꠈꠘ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("RM16_27","075_16_27","ROM","16","27","27","ꠔꠣꠁꠘꠃ ꠄꠇꠝꠣꠔ꠆ꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠁꠘꠃ ꠀꠈꠟꠖꠣꠞ, ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠌꠤꠞꠇꠣꠟ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("C11_1","076_1_1","1CO","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠞ꠆ꠎꠤꠄ ꠀꠟ꠆ꠟꠣꠁ ꠖꠣꠅꠔ ꠙꠣꠁꠀ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠁꠍꠤ। ꠀꠝꠤ ꠀꠞ ꠀꠝꠣꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠍꠥꠍꠤꠘꠦ, ");
INSERT INTO syls_vpl VALUES ("C11_2","076_1_2","1CO","1","2","2","ꠇꠞꠤꠘ꠆ꠔ ꠐꠣꠃꠘꠞ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ, ꠝꠣꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣ ꠇꠛꠥꠟ ꠇꠞꠣꠄ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠍꠂꠘ ꠀꠞ ꠔꠣꠘ ꠀꠙꠘ ꠛꠘ꠆ꠖꠣ ꠅꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ। ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠞ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠉꠣꠞ ꠎꠔ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠣꠟꠤꠇ ꠇꠁꠀ ꠝꠣꠘꠂꠘ, ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠅꠃ ꠌꠤꠑꠤꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ꠔꠣꠁꠘ ꠔꠣꠞꠣꠞꠅ ꠝꠣꠟꠤꠇ, ꠀꠝꠞꠣꠞꠅ ꠝꠣꠟꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("C11_3","076_1_3","1CO","1","3","3","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("C11_4","076_1_4","1CO","1","4","4","ꠀꠝꠤ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ, ꠇꠣꠞꠘ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣ ꠇꠛꠥꠟ ꠇꠞꠣꠄ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠔꠟꠦ ꠀꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("C11_5","076_1_5","1CO","1","5","5","ꠅꠃ ꠞꠢꠝꠔ ꠅꠁꠟ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠀ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠄ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠣ ꠀꠞ ꠀꠈꠟ-ꠁꠟꠤꠝꠦ ꠗꠘꠤ ꠅꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("C11_6","076_1_6","1CO","1","6","6","ꠅꠈꠘ ꠖꠦꠈꠣ ꠎꠣꠞ, ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠟꠣꠝ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠉꠣꠕꠤꠀ ꠞꠣꠈꠍ। ");
INSERT INTO syls_vpl VALUES ("C11_7","076_1_7","1CO","1","7","7","ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠛꠣꠞ ꠌꠣꠁꠞꠣꠄ, ꠄꠞꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠛꠣꠔꠥꠘꠤ ꠈꠦꠝꠔꠣꠞ ꠎꠦꠇꠥꠘꠥ ꠘꠤꠀꠝꠔ ꠙꠣꠁꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠅꠜꠣꠛ ꠅꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C11_8","076_1_8","1CO","1","8","8","ꠀꠝꠤ ꠎꠣꠘꠤ, ꠀꠝꠞꠣꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠈꠦꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠣꠈꠛꠣ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠀꠁꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C11_9","076_1_9","1CO","1","9","9","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠢꠇ ꠀꠞ ꠈꠣꠐꠤ, ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠇꠂꠘ ꠅꠟꠣ ꠅꠄ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠎꠣꠘꠥ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠍꠣ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠈꠣꠔꠤꠞ-ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠞꠣꠈꠅ, ꠄꠁꠘꠃ ꠀꠟ-ꠝꠍꠤ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("C11_10","076_1_10","1CO","1","10","10","ꠔꠦ ꠜꠣꠁ ꠅꠇꠟ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠅꠁꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠥꠠ ꠀꠔꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠄꠇ ꠅꠅ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠖꠟꠣꠖꠟꠤ ꠘꠣ ꠞꠃꠇ, ꠄꠇ ꠝꠘ ꠀꠞ ꠄꠇ ꠝꠔ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("C11_11","076_1_11","1CO","1","11","11","ꠢꠥꠘꠅ, ꠇꠥꠟꠥꠀ ꠛꠤꠛꠤꠞ ꠛꠣꠠꠤꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠣꠘꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠌꠟꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("C11_12","076_1_12","1CO","1","12","12","ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠇꠄ, “ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠞ ꠖꠟꠞ,” ꠇꠦꠃ ꠇꠄ, “ꠀꠝꠤ ꠀꠙꠟ꠆ꠟꠍꠞ ꠖꠟꠞ,” ꠇꠦꠃ ꠇꠄ, “ꠀꠝꠤ ꠙꠤꠔꠞꠞ ꠖꠟꠞ,” ꠀꠞ ꠇꠦꠃ ꠇꠄ, “ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠖꠟꠞ।” ");
INSERT INTO syls_vpl VALUES ("C11_13","076_1_13","1CO","1","13","13","ꠔꠦ ꠇꠅ ꠌꠣꠁꠘ, ꠀꠟ-ꠝꠍꠤꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠐꠣ-ꠛꠣꠐꠤ ꠇꠞꠣ ꠅꠁꠉꠦꠍꠦ ꠘꠤ? ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠍꠟꠤꠛꠅ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣ ꠅꠁꠍꠦ ꠘꠤ? ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠍ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C11_14","076_1_14","1CO","1","14","14","ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁ, ꠈꠣꠟꠤ ꠇꠤꠞꠤꠡꠙꠅ ꠀꠞ ꠉꠃꠍ ꠍꠣꠠꠣ, ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠤ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C11_15","076_1_15","1CO","1","15","15","ꠎꠣꠔꠦ ꠇꠦꠃ ꠇꠁꠔ ꠘꠣ ꠙꠣꠞꠦ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠘꠣꠝꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("C11_16","076_1_16","1CO","1","16","16","ꠀꠡ꠆ꠔꠤꠚꠣꠘ ꠜꠣꠁꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠘꠡꠞꠦꠅ ꠀꠝꠤ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠍꠤ, ꠄꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠍꠤ ꠇꠞꠤꠀ ꠀꠝꠣꠞ ꠝꠘꠅ ꠅꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C11_17","076_1_17","1CO","1","17","17","ꠀꠟ-ꠝꠍꠤꠄ ꠔ ꠀꠝꠣꠞꠦ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤꠃ ꠙꠣꠑꠣꠁꠍꠂꠘ। ꠀꠞ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤꠅ ꠇꠥꠘꠥ ꠀꠈꠟꠖꠣꠞꠤ ꠙꠘ꠆ꠒꠤꠔꠤ ꠜꠣꠛ-ꠜꠋꠉꠤꠄ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠙꠣꠑꠣꠁꠍꠂꠘ ꠘꠣ, ꠎꠣꠔꠦ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠀ ꠛꠦꠇꠣꠝꠣ ꠘꠣ ꠛꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("C11_18","076_1_18","1CO","1","18","18","ꠎꠣꠞꠣ ꠉꠎꠛꠤ ꠙꠕꠦꠖꠤ ꠖꠃꠠꠣꠞ, ꠀꠟ-ꠝꠍꠤꠞ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠈꠣꠟꠤ ꠛꠦꠀꠈꠟꠤ ꠝꠘꠅ ꠅꠄ, ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠎꠣꠞꠣ ꠘꠣꠎꠣꠔꠞ ꠙꠕꠦ ꠖꠃꠠꠣꠁꠞꠣꠝ, ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠁ ꠛꠟ। ");
INSERT INTO syls_vpl VALUES ("C11_19","076_1_19","1CO","1","19","19","ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠀꠝꠤ ꠀꠈꠟꠖꠣꠞ ꠅꠇꠟꠞ ꠀꠈꠟꠞꠦ ꠛꠦꠇꠣꠝꠣ ꠇꠞꠝꠥ, ꠀꠞ ꠛꠥꠖ꠆ꠖꠤꠝꠣꠘ ꠅꠇꠟꠞ ꠛꠥꠖ꠆ꠖꠤꠞꠦ ꠛꠤꠚꠟ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("C11_20","076_1_20","1CO","1","20","20","ꠔꠦ ꠅꠃ ꠀꠈꠟꠖꠣꠞ ꠅꠇꠟ ꠇꠥꠀꠁ? ꠀꠟꠤꠝ ꠅꠇꠟꠃ ꠛꠣ ꠇꠥꠀꠁ? ꠀꠞ ꠅꠃ ꠎꠝꠣꠘꠣꠔ ꠔꠞ꠆ꠇ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠎꠣꠞ ꠀꠍꠦ, ꠢꠦ ꠅꠈꠘ ꠇꠥꠀꠁ? ꠖꠥꠘꠤꠀꠛꠤ ꠀꠈꠟ ꠔ ꠈꠣꠟꠤ ꠛꠦꠀꠈꠟꠤ, ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠄꠃ ꠖꠦꠈꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C11_21","076_1_21","1CO","1","21","21","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠈꠟ ꠖꠤꠀ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠖꠥꠘꠤꠀꠄ ꠎꠣꠘꠥ ꠔꠣꠞ ꠀꠈꠟ ꠖꠤꠀ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠔ ꠘꠣ ꠙꠣꠞꠦ। ꠄꠞꠟꠣꠉꠤ ꠛꠦꠀꠈꠟꠤꠞ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠄ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠔꠣ ꠌꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C11_22","076_1_22","1CO","1","22","22","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠈꠣꠟꠤ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠔꠣ ꠌꠣꠁꠘ, ꠁꠃꠘꠣꠘꠤ ꠅꠇꠟꠦ ꠀꠈꠟꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("C11_23","076_1_23","1CO","1","23","23","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠤ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠕꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠄꠇꠐꠣ ꠛꠦ-ꠖꠤꠘꠤ ꠇꠣꠝ ꠀꠞ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠦ ꠝꠘꠅ ꠇꠞꠂꠘ ꠛꠦꠀꠈꠟꠤ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C11_24","076_1_24","1CO","1","24","24","ꠅꠁꠟꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠃꠇ꠆ꠇꠣ ꠛꠣ ꠁꠃꠘꠣꠘꠤ ꠅꠃꠇ꠆ꠇꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠣꠅꠔꠤ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠅꠃ ꠀꠟ-ꠝꠍꠤꠃ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠁ ꠀꠈꠟ ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠛꠟ। ");
INSERT INTO syls_vpl VALUES ("C11_25","076_1_25","1CO","1","25","25","ꠀꠟ꠆ꠟꠣꠁ ꠛꠦꠀꠈꠟꠤ ꠝꠣꠘꠡꠞ ꠀꠈꠟ ꠕꠣꠇꠤ ꠛꠃꠔ ꠛꠠ ꠀꠈꠟꠖꠣꠞ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠇꠝꠎꠥꠞꠤ ꠝꠣꠘꠡꠞ ꠡꠇ꠆ꠔꠤ ꠕꠣꠇꠤ ꠛꠃꠔ ꠡꠛꠟ। ");
INSERT INTO syls_vpl VALUES ("C11_26","076_1_26","1CO","1","26","26","ꠜꠣꠁ ꠅꠇꠟ, ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ ꠖꠦꠈꠅ, ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠛꠟꠣ ꠖꠣꠅꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠢꠤ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣꠈꠣꠘ ꠀꠍꠟꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠃꠔ ꠎꠘꠃ ꠝꠣꠘꠡꠞ ꠌꠈꠥꠔ ꠀꠈꠟꠖꠣꠞ, ꠈꠦꠝꠔꠣꠛꠣꠘ ꠛꠣ ꠘꠣꠝꠤ-ꠖꠣꠝꠤ ꠛꠋꠡꠞ ꠀꠍꠟꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C11_27","076_1_27","1CO","1","27","27","ꠅꠁꠟꠦ ꠖꠥꠘꠤꠀꠄ ꠎꠦꠔꠣꠞꠦ ꠛꠦꠀꠈꠟꠤ ꠇꠁꠀ ꠝꠘꠅ ꠇꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠅꠔꠣꠞꠦꠃ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠀꠈꠟꠖꠣꠞ ꠅꠇꠟꠦ ꠡꠞꠝ ꠙꠣꠁꠘ। ꠀꠞ ꠖꠥꠘꠤꠀꠄ ꠎꠦꠔꠣꠞꠦ ꠇꠝꠎꠥꠞ ꠝꠘꠅ ꠇꠞꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠅꠔꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠛꠟꠛꠣꠘ ꠢꠇꠟꠔꠣ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C11_28","076_1_28","1CO","1","28","28","ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣꠞꠦ ꠈꠥꠛ ꠔꠥꠌ꠆ꠍ ꠝꠘꠅ ꠇꠞꠦ, ꠖꠥꠘꠤꠀꠞ ꠛꠥꠇꠥꠔ ꠎꠦꠔꠣꠞ ꠇꠥꠘꠥ ꠖꠣꠝ ꠘꠣꠁ, ꠀꠟ꠆ꠟꠣꠄ ꠅꠔꠣꠞꠦꠃ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠌꠈꠥꠔ ꠎꠦꠔꠣ ꠘꠣꠝꠤ-ꠖꠣꠝꠤ, ꠁꠔꠣ ꠛꠦ-ꠖꠣꠝꠤ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C11_29","076_1_29","1CO","1","29","29","ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠘꠣ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C11_30","076_1_30","1CO","1","30","30","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠙꠘ ꠎꠘ ꠛꠘꠍ, ꠁꠔꠣ ꠔ ꠀꠟ꠆ꠟꠣ ꠕꠣꠇꠤꠃ ꠅꠁꠍꠦ। ꠀꠟ-ꠝꠍꠤꠃ ꠅꠁꠟꠣ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠀꠈꠟ, ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤ, ꠙꠛꠤꠔ꠆ꠞꠔꠣ ꠀꠞ ꠀꠎꠣꠖꠤꠞ ꠈꠥꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("C11_31","076_1_31","1CO","1","31","31","ꠄꠞꠟꠣꠉꠤ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠎꠦ ꠝꠣꠘꠡꠦ ꠛꠠꠣꠁ ꠇꠞꠦ, ꠢꠦ ꠝꠣꠛꠥꠖꠞꠦ ꠟꠁꠀꠃ ꠛꠠꠣꠁ ꠇꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("C12_1","076_2_1","1CO","2","1","1","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠉꠤꠀ ꠀꠝꠤ ꠔ ꠡꠥꠘ꠆ꠖꠞ ꠡꠥꠘ꠆ꠖꠞ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠤꠍꠤ ꠘꠣ, ꠛꠣ ꠛꠠ ꠇꠥꠘꠥ ꠀꠟꠤꠝ-ꠃꠟꠣꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠄꠀꠘ ꠇꠞꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C12_2","076_2_2","1CO","2","2","2","ꠀꠝꠤ ꠝꠘꠦ ꠝꠘꠦ ꠑꠤꠇ ꠇꠞꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠣꠞ ꠇꠣꠟꠅ ꠀꠝꠤ ꠈꠣꠟꠤ ꠅꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠤꠡꠄꠄ ꠝꠣꠔꠤꠝꠥ, ꠎꠦ ꠁꠍꠣꠞꠦ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠣ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C12_3","076_2_3","1CO","2","3","3","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠔꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠘꠤꠎꠞꠦ ꠇꠝꠎꠥꠞ ꠝꠘꠅ ꠇꠞꠔꠣꠝ ꠀꠞ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠤꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C12_4","076_2_4","1CO","2","4","4","ꠀꠝꠣꠞ ꠔꠛꠟꠤꠉ ꠀꠞ ꠀꠝꠣꠞ ꠛꠄꠀꠘꠞ ꠝꠣꠎꠦ ꠝꠣꠘꠡꠞ ꠝꠘ ꠎꠄ ꠇꠞꠣꠞ ꠝꠔ ꠇꠥꠘꠥ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠀꠞ ꠎꠥꠇ꠆ꠔꠤ ꠀꠍꠤꠟ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟ ꠖꠦꠈꠣ ꠉꠦꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("C12_5","076_2_5","1CO","2","5","5","ꠀꠝꠤ ꠌꠣꠁꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠝꠣꠘꠡꠞ ꠀꠈꠟ-ꠁꠟꠤꠝꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠁ ꠛꠟꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C12_6","076_2_6","1CO","2","6","6","ꠔꠣ-ꠅ ꠎꠦꠞꠣ ꠁꠝꠣꠘꠦ ꠇꠣꠝꠤꠟ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠀꠈꠟꠞ ꠝꠣꠔ ꠝꠣꠔꠤ। ꠅꠁꠟꠦ ꠅꠃ ꠀꠈꠟ ꠔ ꠁ ꠎꠉꠔꠞ ꠘꠣꠄ ꠛꠣ ꠎꠉꠔꠞ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘꠅ ꠘꠣꠄ, ꠔꠣꠞꠣ ꠔ ꠛꠞꠛꠣꠖ ꠅꠀꠞ ꠙꠕꠤ। ");
INSERT INTO syls_vpl VALUES ("C12_7","076_2_7","1CO","2","7","7","ꠀꠍꠟꠦ ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠁ ꠀꠈꠟ-ꠢꠦꠇꠝꠔꠞ ꠛꠣꠔꠥꠘꠤ ꠉꠥꠙꠘ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠔꠤ। ꠅꠃ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞ ꠔ ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠀꠉꠦꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠝꠞ꠆ꠎꠤꠄ ꠑꠤꠇ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠂꠘ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠔꠣꠘ ꠉꠃꠞꠛꠞ ꠜꠣꠉꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("C12_8","076_2_8","1CO","2","8","8","ꠅꠁꠟꠦ ꠅꠃ ꠎꠉꠔꠞ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠁꠔꠣ ꠛꠥꠎꠞꠣ ꠘꠣ। ꠁꠔꠣ ꠛꠥꠎꠟꠦ ꠔꠣꠞꠣ, ꠢꠃ ꠉꠃꠞꠛꠞ ꠗꠘ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠝꠣꠞꠟ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("C12_9","076_2_9","1CO","2","9","9","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠦ ꠇꠄ, ꠎꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠞꠣꠈꠍꠂꠘ, ꠁꠔꠣ ꠇꠦꠃ ꠌꠃꠈꠦ ꠖꠦꠈꠍꠦ ꠘꠣ, ꠇꠣꠘꠦꠅ ꠢꠥꠘꠍꠦ ꠘꠣ, ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥꠖꠤꠘ ꠌꠤꠘ꠆ꠔꠣꠅ ꠇꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C12_10","076_2_10","1CO","2","10","10","ꠁꠔꠣ ꠅꠈꠘ ꠔꠣꠘ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ। ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠅꠎꠣꠘꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ, ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠟ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞꠅ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C12_11","076_2_11","1CO","2","11","11","ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠅꠟꠣ ꠇꠦꠃ ꠀꠍꠦ ꠘꠤ, ꠎꠦꠞꠣ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞ ꠝꠘꠞ ꠈꠛꠞ ꠎꠣꠘꠂꠘ? ꠈꠣꠟꠤ ꠘꠤꠎꠞ ꠞꠥꠢꠦꠃ ꠔꠣꠞ ꠝꠘꠞ ꠈꠛꠞ ꠎꠣꠘꠦ। ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠥ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠦꠙꠣꠞ ꠎꠣꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C12_12","076_2_12","1CO","2","12","12","ꠀꠞ ꠀꠝꠞꠣ ꠔ ꠖꠥꠘꠤꠀꠛꠤ ꠞꠥꠢꠥ ꠙꠣꠁꠍꠤ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠔꠣꠘ ꠞꠥꠢꠥ ꠙꠣꠁꠍꠤ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠖꠦꠅꠀ ꠘꠤꠀꠝꠔ ꠅꠇꠟ ꠀꠝꠞꠣ ꠌꠤꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("C12_13","076_2_13","1CO","2","13","13","ꠀꠞ ꠅꠃ ꠘꠤꠀꠝꠔꠞ ꠛꠦꠙꠣꠞꠦꠃ ꠀꠝꠞꠣ ꠇꠁ, ꠁꠔꠣ ꠇꠅꠀꠞ ꠡꠝꠄ ꠀꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠀꠈꠟ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤ ꠘꠣ, ꠈꠣꠟꠤ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠀ ꠇꠁ। ꠞꠥꠢꠣꠘꠤ ꠢꠇꠤꠇꠔꠞꠦ ꠎꠣꠁꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠀꠝꠞꠣ ꠞꠥꠢꠣꠘꠤ ꠝꠣꠔ ꠝꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("C12_14","076_2_14","1CO","2","14","14","ꠎꠦ ꠝꠣꠘꠥꠡ ꠞꠥꠢꠣꠘꠤ ꠝꠘꠜꠣꠛꠞ ꠘꠣꠄ, ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠝꠤꠟꠦ ꠢꠦ ꠁꠔꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠛꠦꠇꠣꠝꠣ। ꠁꠔꠣ ꠛꠦꠙꠣꠞ ꠢꠦ ꠛꠥꠎꠦꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠁꠔꠣ ꠞꠥꠢꠣꠘꠤ ꠎꠉꠔꠞ ꠛꠦꠙꠣꠞ, ꠈꠣꠟꠤ ꠞꠥꠢꠥꠖꠤ ꠎꠣꠌꠣꠁ ꠇꠞꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C12_15","076_2_15","1CO","2","15","15","ꠎꠦ ꠎꠘꠞ ꠝꠣꠎꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠍꠦ, ꠢꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠌꠣꠁ ꠇꠞꠤꠀ ꠖꠦꠈꠦ, ꠔꠣꠞꠦ ꠇꠦꠃ ꠎꠣꠌꠣꠁ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C12_16","076_2_16","1CO","2","16","16","ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ꠝꠣꠛꠥꠖꠞ ꠝꠘ ꠇꠦꠉꠤꠄ ꠛꠥꠎꠔ ꠙꠣꠞꠍꠦ, ꠔꠣꠘꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠛꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠇꠣꠞ? ꠅꠁꠟꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠘ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠕꠣꠇꠣꠄ, ꠀꠝꠞꠣ ꠁꠔꠣ ꠛꠥꠎꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C13_1","076_3_1","1CO","3","1","1","ꠜꠣꠁ ꠅꠇꠟ, ꠞꠥꠢꠣꠘꠤꠇ ꠎꠘꠞ ꠟꠉꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠝꠣꠔꠣ ꠃꠌꠤꠔ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠁꠟꠣ ꠝꠣꠔꠔꠣꠝ ꠙꠣꠞꠍꠤ ꠘꠣ। ꠛꠞꠋ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠎꠦꠟꠣ ꠝꠣꠔꠣ ꠃꠌꠤꠔ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠟꠣꠃ ꠝꠣꠔꠤꠍꠤ। ꠔꠥꠝꠞꠣ ꠔ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣꠔ ꠄꠇ꠆ꠇꠦꠞꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠈꠣꠘ, ꠄꠞꠟꠣꠉꠤꠃ ꠅꠃꠟꠣ ꠝꠣꠔꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C13_2","076_3_2","1CO","3","2","2","ꠙꠄꠟꠣ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠇ꠆ꠔ ꠈꠣꠘꠤ ꠘꠣ ꠖꠤꠀ ꠈꠣꠟꠤ ꠖꠥꠗ ꠈꠣꠛꠣꠁꠍꠟꠣꠝ, ꠢꠤ ꠡꠝꠄ ꠡꠇ꠆ꠔ ꠈꠣꠘꠤ ꠈꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠀꠍꠟꠣꠄ ꠘꠣ, ꠀꠞ ꠅꠔ ꠖꠤꠘ ꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠁ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠞꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("C13_3","076_3_3","1CO","3","3","3","ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠅꠈꠘꠅ ꠖꠥꠘꠤꠀꠛꠤ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠦ ꠌꠟꠞꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠈꠘꠅ ꠁꠋꠡꠣ, ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠟꠣꠉꠣꠁꠟꠃ ꠀꠍꠦ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠛꠡꠦ ꠞꠁꠍ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C13_4","076_3_4","1CO","3","4","4","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠎꠦꠛꠟꠣ ꠇꠄ, ꠢꠦ ꠙꠣꠃꠟꠥꠍꠞ ꠖꠟꠞ, ꠇꠦꠃ ꠇꠄ ꠀꠙꠟ꠆ꠟꠍꠞ ꠖꠟꠞ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C13_5","076_3_5","1CO","3","5","5","ꠀꠙꠟ꠆ꠟꠍ ꠇꠦ? ꠀꠞ ꠙꠣꠃꠟꠥꠍꠃ ꠛꠣ ꠇꠦ? ꠀꠝꠞꠣ ꠔ ꠡꠣꠝꠣꠁꠘ꠆ꠘ ꠈꠦꠎꠝꠔꠇꠣꠞꠤ, ꠀꠝꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘꠞ ꠙꠕꠦ ꠀꠁꠍ। ꠀꠟ꠆ꠟꠣꠄꠃ ꠀꠝꠞꠣꠞꠦ ꠎꠣꠞꠎꠤꠞ ꠁ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C13_6","076_3_6","1CO","3","6","6","ꠀꠝꠤ ꠛꠤꠌ ꠟꠣꠉꠣꠁꠍꠤ, ꠀꠙꠟ꠆ꠟꠍꠦ ꠙꠣꠘꠤ ꠖꠤꠍꠂꠘ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣꠞꠦ ꠛꠠ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C13_7","076_3_7","1CO","3","7","7","ꠄꠞꠟꠣꠉꠤ ꠎꠦꠁꠘ ꠛꠤꠌ ꠟꠣꠉꠣꠁꠘ ꠀꠞ ꠎꠦꠁꠘ ꠙꠣꠘꠤ ꠖꠦꠁꠘ, ꠄꠞꠣ ꠀꠍꠟꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠎꠦꠁꠘ ꠁꠔꠣꠞꠦ ꠛꠠ ꠇꠞꠤ ꠔꠥꠟꠂꠘ, ꠔꠣꠁꠘꠃ ꠢꠇ꠆ꠇꠟꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("C13_8","076_3_8","1CO","3","8","8","ꠛꠤꠌ ꠟꠣꠉꠣꠅꠞꠣ ꠀꠞ ꠙꠣꠘꠤ ꠖꠦꠅꠞꠣꠞ ꠄꠇꠁ ꠃꠖ꠆ꠖꠦꠡ꠆ꠡ। ꠄꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠎꠣꠞꠎꠤꠞ ꠝꠦꠘꠔ ꠝꠣꠚꠤꠇ ꠇꠣꠝꠞ ꠚꠟ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C13_9","076_3_9","1CO","3","9","9","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠖꠥꠁꠅꠎꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠝ ꠇꠞꠤꠀꠞ। ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠃ ꠈꠦꠔ, ꠔꠣꠘ ꠛꠣꠘꠣꠁꠟ ꠛꠤꠟꠒꠤꠋ। ");
INSERT INTO syls_vpl VALUES ("C13_10","076_3_10","1CO","3","10","10","ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦ ꠈꠣꠍ ꠞꠢꠝꠔ ꠀꠝꠤ ꠙꠣꠁꠍꠤ, ꠅꠃ ꠞꠢꠝꠔꠞ ꠛꠟꠦꠃ ꠀꠝꠤ ꠀꠈꠟꠖꠣꠞ ꠞꠣꠎ ꠝꠦꠡ꠆ꠔꠞꠤꠞ ꠟꠣꠈꠣꠘ ꠁꠀꠘ ꠈꠥꠐꠤ ꠉꠣꠠꠍꠤ। ꠀꠞ ꠅꠃ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠅꠁꠘ꠆ꠘ ꠎꠘꠦ ꠛꠤꠟꠒꠤꠋ ꠛꠣꠘꠣꠁꠞꠣ। ꠅꠁꠟꠦ ꠇꠦ ꠇꠤꠟꠣ ꠛꠣꠘꠣꠁꠞꠣ, ꠁ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C13_11","076_3_11","1CO","3","11","11","ꠎꠦ ꠁꠀꠘ ꠈꠥꠐꠤ ꠀꠉꠦꠃ ꠉꠣꠠꠣ ꠅꠁꠉꠦꠍꠦ, ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠃ ꠅꠁꠟꠣ ꠢꠃ ꠈꠥꠐꠤ, ꠁꠇꠐꠣ ꠛꠣꠖ ꠖꠤꠀ ꠀꠞ ꠇꠥꠘꠥ ꠘꠄꠀ ꠈꠥꠐꠤ ꠇꠦꠃ ꠉꠣꠠꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C13_12","076_3_12","1CO","3","12","12","ꠅꠈꠘ ꠁ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ, ꠟꠣꠇꠠꠤ ꠀꠞ ꠍꠘ ꠖꠤꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠊꠞ ꠛꠣꠘꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("C13_13","076_3_13","1CO","3","13","13","ꠔꠦ ꠇꠦ ꠇꠤꠟꠣ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠜꠣꠟꠣ ꠇꠞꠤ ꠖꠦꠈꠣ ꠎꠣꠁꠛ। ꠞꠥꠎ ꠢꠣꠡꠞꠞ ꠖꠤꠘ ꠁꠔꠣ ꠎꠣꠁꠞ ꠅꠁꠛ, ꠢꠃ ꠖꠤꠘ ꠅꠉ꠆ꠘꠤ-ꠙꠞꠤꠇ꠆ꠇꠣꠞ ꠝꠣꠎꠖꠤ ꠁꠔꠣ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C13_14","076_3_14","1CO","3","14","14","ꠎꠦꠁꠘ ꠎꠦꠔꠣ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠐꠤꠇꠤꠀ ꠞꠄ, ꠔꠦ ꠄꠁꠘ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C13_15","076_3_15","1CO","3","15","15","ꠅꠁꠟꠦ ꠁꠔꠣ ꠎꠟꠤ ꠉꠦꠟꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠕꠣꠇꠤ ꠛꠣꠖ ꠙꠠꠛ, ꠔꠣ-ꠅ ꠔꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠣꠌꠤꠛ। ꠔꠣꠞꠦ ꠖꠦꠈꠟꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ, ꠢꠦ ꠀꠉꠥꠁꠘꠞ ꠝꠣꠎꠖꠤ ꠙꠣꠠꠤ ꠖꠤꠀ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C13_16","076_3_16","1CO","3","16","16","ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠛꠣ ꠊꠞ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠙꠣꠇ ꠞꠥꠢꠥ ꠛꠡꠔ ꠇꠞꠂꠘ? ");
INSERT INTO syls_vpl VALUES ("C13_17","076_3_17","1CO","3","17","17","ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠛꠣ ꠊꠞ ꠛꠤꠘꠣꠡ ꠇꠞꠦ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ। ꠇꠣꠞꠘ ꠔꠣꠘ ꠕꠣꠇꠣꠞ ꠊꠞ ꠅꠁꠟ ꠙꠛꠤꠔ꠆ꠞ, ꠀꠞ ꠔꠥꠝꠞꠣꠃ ꠅꠁꠟꠣꠄ ꠢꠃ ꠊꠞ। ");
INSERT INTO syls_vpl VALUES ("C13_18","076_3_18","1CO","3","18","18","ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠘꠤꠎꠞꠦ ꠚꠣꠇꠤ ꠖꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠖꠥꠘꠤꠀꠞ ꠀꠈꠟ-ꠁꠟꠤꠝꠦ ꠘꠤꠎꠞꠦ ꠀꠈꠟꠖꠣꠞ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠛꠦꠀꠈꠟ ꠛꠘꠃꠇ ꠎꠣꠔꠦ ꠀꠍꠟ ꠀꠈꠟꠖꠣꠞ ꠅꠁꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C13_19","076_3_19","1CO","3","19","19","ꠇꠣꠞꠘ ꠁ ꠎꠉꠔꠞ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠈꠣꠟꠤ ꠛꠦꠀꠈꠟꠤ। ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠀꠍꠦ, “ꠀꠟ꠆ꠟꠣꠄ ꠀꠈꠟꠖꠣꠞ ꠅꠇꠟꠞꠦ ꠔꠣꠞꠣꠞ ꠌꠣꠟꠣꠇꠤꠔ ꠗꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("C13_20","076_3_20","1CO","3","20","20","ꠀꠞꠇ ꠀꠄꠀꠔꠅ ꠀꠍꠦ, “ꠀꠈꠟꠖꠣꠞ ꠅꠇꠟꠞ ꠢꠇꠟ ꠌꠤꠘ꠆ꠔꠣꠃ ꠛꠦꠇꠣꠝꠣ, ꠁꠔꠣ ꠔ ꠝꠣꠛꠥꠖꠦ ꠎꠣꠘꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("C13_21","076_3_21","1CO","3","21","21","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠇꠕꠣ ꠅꠁꠟ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔ ꠔꠥꠝꠞꠣꠞ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠛꠠꠣꠁ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C13_22","076_3_22","1CO","3","22","22","ꠙꠣꠃꠟꠥꠍ, ꠀꠙꠟ꠆ꠟꠍ, ꠙꠤꠔꠞ, ꠁ ꠖꠥꠘꠤꠀ, ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠝꠃꠔ, ꠛꠞ꠆ꠔꠝꠣꠘ, ꠜꠛꠤꠡꠔ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔꠥꠝꠞꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C13_23","076_3_23","1CO","3","23","23","ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠀꠟ-ꠝꠍꠤꠞ, ꠀꠞ ꠀꠟ-ꠝꠍꠤ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C14_1","076_4_1","1CO","4","1","1","ꠀꠝꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠃꠇ, ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠖꠤꠝ, ꠀꠟ꠆ꠟꠣꠁ ꠛꠣꠔꠥꠘꠤ ꠜꠣꠘ꠆ꠒꠣꠞꠞ ꠈꠣꠎꠣꠘ꠆ꠌꠤ। ");
INSERT INTO syls_vpl VALUES ("C14_2","076_4_2","1CO","4","2","2","ꠀꠞ ꠎꠦꠞꠣꠞ ꠃꠙꠞꠦ ꠜꠣꠘ꠆ꠒꠣꠞꠞ ꠈꠣꠎꠣꠘ꠆ꠌꠤꠞ ꠜꠣꠞ ꠖꠦꠅꠀ ꠅꠄ, ꠔꠣꠞꠣ ꠔ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠘꠤ ꠟꠣꠉꠛ, ꠔꠣꠞꠣ ꠢꠇ-ꠢꠣꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("C14_3","076_4_3","1CO","4","3","3","ꠔꠦ ꠀꠝꠤ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠇꠤ ꠘꠣ ꠁ ꠛꠤꠌꠣꠞ ꠔꠥꠝꠞꠣ ꠇꠞꠅ ꠛꠣ ꠀꠖꠣꠟꠔꠦꠃ ꠇꠞꠃꠇ, ꠄꠔꠦ ꠀꠝꠣꠞ ꠇꠥꠘ꠆ꠔꠣ ꠎꠣꠄ ꠀꠄ ꠘꠣ। ꠀꠝꠤ ꠔ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠤꠌꠣꠞꠃ ꠇꠞꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C14_4","076_4_4","1CO","4","4","4","ꠀꠝꠣꠞ ꠝꠘ ꠡꠣꠖꠣ ꠅꠁꠟꠦꠅ ꠙꠞꠝꠣꠘ ꠇꠞꠣ ꠎꠣꠞ ꠘꠣ ꠀꠝꠤ ꠘꠤꠞ꠆ꠖꠥꠡ। ꠔꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄꠃ ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C14_5","076_4_5","1CO","4","5","5","ꠄꠞꠟꠣꠉꠤ ꠡꠑꠤꠇ ꠡꠝꠄꠅꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠝꠣꠘꠤ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠘꠣ ꠀꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠘ꠆ꠖꠣꠁꠞꠅ ꠎꠦꠔꠣ ꠟꠥꠇꠣꠁꠟ ꠀꠍꠦ, ꠔꠣꠁꠘ ꠀꠁꠀ ꠁꠔꠣꠞꠦ ꠚꠞꠅ ꠀꠘꠛꠣ ꠀꠞ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠉꠥꠙꠘ ꠘꠤꠅꠔ ꠅꠇꠟ ꠎꠣꠁꠞ ꠇꠞꠛꠣ। ꠢꠃ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠙꠣꠅꠘꠣ ꠔꠣꠞꠤꠚ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C14_6","076_4_6","1CO","4","6","6","ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠀꠞ ꠀꠙꠟ꠆ꠟꠍꠞ ꠃꠖꠣꠢꠞꠘ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠟꠣꠝ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠃ ꠔꠣꠟꠤꠝ ꠘꠦꠅ, ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠎꠦꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠁꠔꠣꠞ ꠛꠣꠞꠦ ꠎꠣꠅꠀ ꠑꠤꠇ ꠘꠣꠄ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠄꠇꠎꠘꠞꠦ ꠕꠁꠀ ꠀꠞꠦꠇꠎꠘꠞꠦ ꠟꠁꠀ ꠛꠠꠣꠁ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C14_7","076_4_7","1CO","4","7","7","ꠇꠦꠃ ꠎꠣꠘꠥ ꠝꠘꠅ ꠘꠣ ꠇꠞꠦ ꠔꠥꠝꠤ ꠀꠟꠣꠖꠣ ꠇꠥꠘ꠆ꠔꠣ ꠛꠘꠤꠉꠦꠍ। ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠄꠝꠘ ꠇꠥꠘ ꠗꠘ ꠀꠍꠦ, ꠎꠦꠔꠣ ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠟꠤꠟ꠆ꠟꠣ ꠙꠣꠁꠍ ꠘꠣ? ꠀꠞ ꠁꠔꠣ ꠎꠥꠖꠤ ꠟꠤꠟ꠆ꠟꠣ ꠙꠣꠁꠀ ꠕꠣꠇꠅ, ꠔꠦ ꠟꠤꠟ꠆ꠟꠣ ꠙꠣꠁꠍ ꠘꠣ ꠇꠁꠀ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠞꠣꠄ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("C14_8","076_4_8","1CO","4","8","8","ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠔ ꠝꠘꠅ ꠅꠞ, ꠔꠥꠝꠞꠣ ꠀꠉꠦꠃ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠣꠁꠀ ꠗꠘꠤ ꠅꠁꠉꠦꠍ, ꠀꠝꠞꠣꠞꠦ ꠛꠣꠖ ꠖꠤꠀꠃ ꠔꠥꠝꠞꠣ ꠛꠣꠖꠡꠣ ꠛꠘꠤꠉꠦꠍ! ꠔꠥꠝꠞꠣ ꠢꠣꠍꠣꠞꠞ ꠛꠣꠖꠡꠣ ꠅꠁꠟꠦ ꠜꠣꠟꠣꠃ ꠅꠁꠔ, ꠀꠝꠞꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠣꠖꠡꠣ ꠅꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C14_9","076_4_9","1CO","4","9","9","ꠎꠥꠖ꠆ꠖ-ꠛꠘ꠆ꠖꠤ ꠅꠇꠟꠞꠦ ꠝꠣꠞꠤꠟꠤꠛꠣꠞ ꠘꠤꠅꠔꠦ, ꠎꠥꠖ꠆ꠖꠞ ꠛꠤꠎꠄ ꠝꠤꠍꠤꠟꠞ ꠈꠞꠞ ꠇꠣꠔꠣꠞꠅ ꠎꠣꠞꠣꠞꠦ ꠞꠣꠈꠣ ꠅꠄ, ꠀꠝꠣꠞ ꠝꠘꠅ ꠅꠄ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞꠦꠅ ꠅꠟꠣ ꠢꠇꠟꠞ ꠈꠞꠦ ꠞꠣꠈꠍꠂꠘ। ꠀꠝꠞꠣ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠉꠦꠍꠦ, ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ, ꠀꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦꠅ ꠔꠣꠝꠡꠣꠞ ꠘꠣꠄꠅꠇ ꠛꠘꠤꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C14_10","076_4_10","1CO","4","10","10","ꠀꠝꠞꠣ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠛꠦꠀꠈꠟ ꠅꠁꠍꠤ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠛꠥꠟꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠀꠈꠟꠖꠣꠞ ꠛꠘꠤꠉꠦꠍ। ꠀꠝꠞꠣ ꠇꠝꠎꠥꠞ, ꠔꠥꠝꠞꠣ ꠛꠟꠛꠣꠘ, ꠔꠥꠝꠞꠣ ꠛꠥꠟꠦ ꠁꠎ꠆ꠎꠔꠤ ꠛꠘꠤꠉꠦꠍ, ꠀꠝꠞꠣꠞ ꠔ ꠇꠥꠘꠥ ꠁꠎ꠆ꠎꠔ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C14_11","076_4_11","1CO","4","11","11","ꠀꠝꠞꠣ ꠅꠈꠘꠅ ꠙꠦꠐꠞ ꠜꠥꠇꠦ, ꠙꠣꠘꠤꠞ ꠙꠤꠀꠍꠦ, ꠇꠣꠙꠠ-ꠌꠥꠙꠠꠞ ꠅꠜꠣꠛꠦ ꠇꠡ꠆ꠐ ꠇꠞꠤꠀꠞ, ꠛꠣꠠꠤ-ꠊꠞ ꠘꠣꠁ ꠇꠞꠤ ꠛꠂꠔꠟꠞ ꠟꠣꠈꠣꠘ ꠞꠁꠀꠞ ꠀꠞ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠈꠣꠁꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C14_12","076_4_12","1CO","4","12","12","ꠢꠣꠝꠦꠡꠣ ꠘꠤꠎꠞ ꠀꠔꠦ ꠝꠦꠘꠔ ꠇꠞꠤ ꠈꠣꠁꠀꠞ। ꠝꠣꠘꠡꠞ ꠉꠣꠁꠟ-ꠝꠘ꠆ꠖ ꠢꠥꠘꠤꠀꠅ, ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠌꠣꠁꠀꠞ, ꠎꠥꠟꠥꠝ-ꠘꠤꠞ꠆ꠎꠣꠔꠘ, ꠢꠥꠝꠇꠤ-ꠗꠣꠝꠇꠤꠞꠦ ꠍꠛꠞ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C14_13","076_4_13","1CO","4","13","13","ꠛꠖꠘꠣꠝ-ꠉꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤ ꠇꠞꠤ, ꠘꠞꠝ ꠡꠥꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠥꠎꠣꠁꠀꠞ। ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠞꠣ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠈꠣꠍꠞꠣꠞ ꠟꠣꠈꠣꠘ, ꠢꠇꠟꠔꠣꠞ ꠉꠦꠍꠦꠃ ꠎꠁꠘ꠆ꠎꠣꠟ ꠛꠘꠤꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C14_14","076_4_14","1CO","4","14","14","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞꠦ ꠡꠞꠝ ꠖꠦꠅꠀꠞ ꠘꠤꠅꠔꠦ ꠁꠔꠣ ꠟꠦꠈꠞꠣꠝ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C14_15","076_4_15","1CO","4","15","15","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠃꠡ꠆ꠔꠣꠖ ꠕꠣꠇꠔꠣ ꠙꠣꠞꠂꠘ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ ꠔ ꠅꠔ ꠎꠘ ꠘꠣꠄ। ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠝꠣꠎꠖꠤ ꠁꠍꠣꠄꠁ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠄꠇꠝꠣꠔ꠆ꠞ ꠀꠝꠤꠃ ꠅꠁꠟꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ। ");
INSERT INTO syls_vpl VALUES ("C14_16","076_4_16","1CO","4","16","16","ꠅꠈꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀ ꠇꠁꠀꠞ, ꠀꠝꠤ ꠎꠦꠟꠣ ꠌꠟꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("C14_17","076_4_17","1CO","4","17","17","ꠅꠃ ꠘꠤꠅꠔꠦ ꠀꠝꠤ ꠔꠤꠝꠕꠤꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣꠝ, ꠝꠣꠟꠤꠇꠞ ꠘꠣꠝꠦ ꠄꠁꠘ ꠔ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠙꠥꠔ। ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠀꠝꠤ ꠇꠤꠟꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠤꠀꠞ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠞ ꠢꠇꠟ ꠎꠝꠣꠔꠅ ꠇꠤꠟꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠀꠞ, ꠁꠔꠣ ꠔꠣꠁꠘ ꠝꠘꠅ ꠇꠞꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C14_18","076_4_18","1CO","4","18","18","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠇꠦꠃ ꠝꠘꠅ ꠇꠞꠦꠞ, ꠀꠝꠤ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠣꠝ ꠘꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C14_19","076_4_19","1CO","4","19","19","ꠁꠘꠡꠣꠟ꠆ꠟꠣ ꠀꠝꠤ ꠈꠥꠛ ꠎꠟꠖꠤꠃ ꠀꠁꠝꠥ। ꠎꠦꠔꠣꠄ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠞꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠔ ꠢꠥꠘꠣꠔ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠔꠣꠞꠣꠞ ꠝꠥꠟ ꠈꠦꠝꠔꠣ ꠖꠦꠈꠣꠔ ꠀꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C14_20","076_4_20","1CO","4","20","20","ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠔ ꠝꠣꠔ-ꠇꠕꠣꠞ ꠛꠦꠙꠣꠞ ꠘꠣꠄ, ꠁꠔꠣ ꠅꠁꠟ ꠇꠥꠖꠞꠔꠤ ꠈꠦꠝꠔꠣꠞ ꠛꠦꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C14_21","076_4_21","1CO","4","21","21","ꠔꠥꠝꠞꠣꠞ ꠁꠌ꠆ꠍꠣ ꠇꠤꠔꠣ? ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠤꠔꠣ ꠟꠁꠀ ꠀꠁꠔꠣꠝ? ꠍꠤꠋꠟꠣ ꠟꠁꠀ ꠘꠤ, ꠘꠣ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ ꠀꠞ ꠘꠞꠝ ꠝꠤꠎꠣꠎ? ");
INSERT INTO syls_vpl VALUES ("C15_1","076_5_1","1CO","5","1","1","ꠀꠝꠤ ꠢꠥꠘꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠎꠊꠁꠘ꠆ꠘ ꠎꠤꠘꠣꠞ ꠇꠣꠝ ꠌꠟꠦꠞ, ꠁꠟꠣ ꠇꠣꠝ ꠛꠤꠗꠞ꠆ꠝꠤ ꠅꠇꠟꠦꠅ ꠇꠞꠦ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇ ꠎꠘꠦ ꠘꠤꠎꠞ ꠢꠣꠔꠘ ꠝꠣʼꠞꠦꠅ ꠛꠃꠞ ꠟꠣꠈꠣꠘ ꠞꠣꠈꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C15_2","076_5_2","1CO","5","2","2","ꠄꠞꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠛꠠꠣꠁ ꠇꠞꠅ ꠇꠤꠟꠣ? ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠚꠣꠘꠣ ꠝꠣꠋꠉꠣ ꠎꠞꠥꠞ ꠘꠣꠄ ꠘꠤ? ꠀꠞ ꠎꠦꠉꠤꠄ ꠁꠔꠣ ꠇꠞꠍꠦ, ꠔꠣꠞꠦ ꠎꠝꠣꠔ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠦꠅꠀ ꠃꠌꠤꠔ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C15_3","076_5_3","1CO","5","3","3","ꠀꠝꠤ ꠡ-ꠡꠞꠤꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣ ꠕꠣꠇꠟꠦꠅ ꠞꠥꠢꠦ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠤ, ꠄꠞꠟꠣꠉꠤ ꠎꠦꠉꠤꠄ ꠁꠔꠣ ꠇꠞꠍꠦ, ꠍꠣꠝꠘꠦ ꠕꠣꠇꠣ ꠛꠤꠌꠣꠞꠤꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠤꠅ ꠀꠉꠦꠃ ꠔꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C15_4","076_5_4","1CO","5","4","4","ꠀꠝꠣꠞ ꠛꠤꠌꠣꠞ ꠅꠁꠟ, ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠄꠇ ꠎꠣꠉꠣꠔ ꠖꠟꠣ ꠅꠅ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤꠅ ꠞꠥꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠝꠥ ꠀꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤꠅ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("C15_5","076_5_5","1CO","5","5","5","ꠀꠞ ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠡꠞꠤꠟꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠡꠄꠔꠣꠘꠞ ꠀꠔꠅ ꠖꠤꠟꠣꠁꠔꠦ ꠅꠁꠛ, ꠎꠣꠔꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠁꠛꠣꠞ ꠇꠣꠟꠅ ꠔꠣꠞ ꠞꠥꠢꠦ ꠘꠣꠎꠣꠔ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C15_6","076_5_6","1CO","5","6","6","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠛꠠꠣꠁ ꠇꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠘꠣꠄ। ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠝꠄꠖꠣꠞ ꠈꠣꠁꠞ ꠛꠠ ꠉꠣꠝꠟꠣꠞꠦꠅ ꠕꠥꠠꠣ ꠈꠣꠝꠤꠞꠦ ꠚꠥꠟꠣꠁꠟꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("C15_7","076_5_7","1CO","5","7","7","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤꠅ ꠢꠃ ꠙꠥꠞꠣꠘ ꠈꠣꠝꠤꠞꠞ ꠜꠣꠛ ꠚꠣꠟꠣꠁ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠝꠄꠖꠣꠞ ꠈꠣꠁ ꠛꠘ, ꠀꠞ ꠀꠍꠟꠦꠃ ꠔ ꠔꠥꠝꠞꠣ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠎꠘ। ꠀꠎꠣꠖꠤ ꠁꠖꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤꠞꠦꠅ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠎꠣꠘ ꠔ, ꠢꠃ ꠁꠖꠅ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠈꠣꠝꠤꠞ ꠞꠣꠈꠣ ꠢꠣꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C15_8","076_5_8","1CO","5","8","8","ꠄꠞꠟꠣꠉꠤ ꠀꠅ, ꠀꠝꠞꠣꠅ ꠢꠃ ꠙꠥꠞꠣꠘ ꠈꠣꠝꠤꠞ, ꠝꠣꠘꠤ ꠁꠋꠡꠣ ꠀꠞ ꠈꠣꠞꠣꠙꠤꠞꠦ ꠛꠣꠖ ꠖꠤꠟꠣꠁ, ꠄꠞ ꠛꠖꠟꠣ ꠈꠣꠝꠤꠞ ꠍꠣꠠꠣ ꠞꠥꠐꠤ, ꠝꠣꠘꠤ ꠢꠇ ꠀꠞ ꠡꠣꠖꠣ ꠖꠤꠟꠦ ꠁꠖ ꠀꠖꠣꠄ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C15_9","076_5_9","1CO","5","9","9","ꠀꠝꠤ ꠀꠉꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠦꠈꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠘꠣꠚꠞꠝꠣꠘ ꠈꠛꠤꠍ ꠅꠇꠟꠞ ꠟꠉꠦ ꠡꠋ ꠗꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C15_10","076_5_10","1CO","5","10","10","ꠀꠝꠤ ꠇꠁꠞꠣꠝ ꠘꠣ, ꠁ ꠎꠉꠔꠞ ꠈꠛꠤꠍ ꠝꠣꠘꠥꠡ, ꠟꠥꠜꠤ, ꠖꠈꠟꠛꠣꠎ ꠀꠞ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠞꠣꠞ ꠡꠋꠉꠅ ꠄꠇ꠆ꠇꠦꠞꠦ ꠍꠣꠠꠤ ꠖꠤꠔꠣꠄ। ꠁꠟꠣ ꠅꠁꠟꠦ ꠔ ꠔꠥꠝꠞꠣ ꠎꠉꠔꠞ ꠛꠣꠞꠦ ꠀꠞꠅ ꠇꠥꠘꠥꠈꠣꠘꠅ ꠎꠣꠁꠔꠦꠉꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C15_11","076_5_11","1CO","5","11","11","ꠅꠁꠟꠦ ꠀꠝꠤ ꠈꠣꠟꠤ ꠅꠈꠣꠘ ꠇꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠤꠎꠞꠦ ꠝꠥꠝꠤꠘ ꠇꠁꠀ ꠖꠣꠛꠤ ꠇꠞꠦ, ꠀꠞ ꠢꠦ ꠎꠤꠘꠣꠇꠥꠞ, ꠟꠥꠜꠤ, ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣꠞꠤ, ꠉꠤꠛꠔ ꠉꠣꠅꠞꠣ, ꠝꠖꠈꠥꠞ, ꠛꠣ ꠌꠥꠞ-ꠒꠣꠇꠣꠁꠔ ꠅꠄ, ꠔꠦ ꠔꠣꠞ ꠡꠋ ꠗꠞꠤꠅ ꠘꠣ, ꠔꠣꠞ ꠟꠉꠦ ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠅ ꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C15_12","076_5_12","1CO","5","12","13","ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠅꠟꠣ ꠑꠦꠇꠣ ꠙꠠꠍꠦ ꠘꠤ, ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠛꠣꠁꠞꠞ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠔꠣꠝ? ꠁꠔꠣꠞ ꠛꠤꠌꠣꠞ ꠀꠟ꠆ꠟꠣꠄꠃ ꠇꠞꠛꠣ। ꠅꠁꠟꠦ ꠔꠞꠤꠇꠣꠞ ꠜꠤꠔꠞꠞ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ ꠘꠣ ꠘꠤ? ꠔꠃꠞꠣꠔ ꠇꠤꠔꠣꠛꠅ ꠀꠍꠦ, “ꠢꠃ ꠘꠣꠚꠞꠝꠣꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠡꠝꠣꠎ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("C16_1","076_6_1","1CO","6","1","1","ꠔꠥꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠘꠣꠟꠤꠡ ꠕꠣꠇꠦ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠘꠣ ꠉꠤꠀ, ꠢꠦ ꠇꠥꠘ ꠡꠣꠅꠡꠦ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠛꠤꠌꠣꠞ ꠌꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("C16_2","076_6_2","1CO","6","2","2","ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠅꠃ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠦꠃ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ? ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠔꠦ ꠙꠣꠞꠟꠦ ꠅꠃ ꠝꠣꠝꠥꠟꠤ ꠛꠦꠙꠣꠞꠞ ꠚꠄꠍꠣꠟꠣ ꠇꠞꠔꠣꠄ ꠙꠣꠞ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C16_3","076_6_3","1CO","6","3","3","ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠀꠝꠞꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠅ ꠛꠤꠌꠣꠞ ꠇꠞꠝꠥ? ꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠛꠦꠙꠣꠞ ꠔ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠄ! ");
INSERT INTO syls_vpl VALUES ("C16_4","076_6_4","1CO","6","4","4","ꠔꠥꠝꠞꠣꠞ ꠎꠦꠛꠟꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠤꠌꠣꠞ-ꠀꠌꠣꠞꠞ ꠎꠞꠥꠞ ꠅꠄ, ꠅꠃ ꠡꠝꠄ ꠎꠝꠣꠔꠞ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠇꠦꠘꠦ ꠛꠤꠌꠣꠞꠞ ꠡꠣꠟꠤꠡ ꠛꠣꠘꠣꠅ? ");
INSERT INTO syls_vpl VALUES ("C16_5","076_6_5","1CO","6","5","5","ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠞꠝ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤꠃ ꠟꠦꠈꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠀꠈꠟꠖꠣꠞ ꠡꠣꠟꠤꠡ ꠄꠇꠎꠘꠅ ꠘꠣꠁ ꠘꠤ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠝꠣꠎꠞ ꠉꠘ꠆ꠒꠉꠥꠟ ꠝꠤꠐ-ꠝꠣꠐ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ? ");
INSERT INTO syls_vpl VALUES ("C16_6","076_6_6","1CO","6","6","6","ꠀꠝꠤ ꠖꠦꠈꠞꠣꠝ, ꠛꠤꠌꠣꠞꠞ ꠝꠎꠟꠤꠍꠅ ꠛꠁꠀꠅ ꠔꠥꠝꠞꠣ ꠜꠣꠁꠄ ꠜꠣꠁꠄ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠞꠣꠄ। ꠔꠣ-ꠅ ꠀꠛꠣꠞ ꠅ-ꠁꠝꠣꠘꠖꠣꠞꠞ ꠍꠣꠝꠘꠦ! ");
INSERT INTO syls_vpl VALUES ("C16_7","076_6_7","1CO","6","7","7","ꠀꠍꠟꠦ ꠔꠥꠝꠞꠣ ꠜꠣꠁꠄ ꠜꠣꠁꠄ ꠅꠃ ꠎꠦꠟꠣ ꠛꠤꠌꠣꠞ ꠡꠣꠟꠤꠡ ꠌꠣꠟꠣꠁꠞꠣꠄ, ꠁꠔꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞꠃ ꠈꠦꠔꠤ ꠅꠞ। ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠅ ꠘꠣ ꠇꠦꠘꠦ ꠛꠣ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠐꠉꠣ ꠈꠣꠅ ꠘꠣ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("C16_8","076_6_8","1CO","6","8","8","ꠛꠞꠋ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠔ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠞꠣꠄ, ꠝꠣꠘꠡꠞꠦ ꠐꠉꠤꠞꠣꠄ, ꠀꠞ ꠁꠔꠣ ꠘꠤꠎꠞ ꠜꠣꠁꠞ ꠟꠉꠦꠃ ꠇꠞꠞꠣꠄ! ");
INSERT INTO syls_vpl VALUES ("C16_9","076_6_9","1CO","6","9","9","ꠀꠍꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠘꠣꠚꠞꠝꠣꠘ ꠈꠛꠤꠍ ꠅꠇꠟꠞ ꠇꠥꠘꠥ ꠑꠣꠁ ꠘꠣꠁ। ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠜꠥꠟ ꠌꠤꠘ꠆ꠔꠣ ꠖꠥꠞ ꠅꠃꠇ, ꠎꠦꠔꠣ ꠝꠣꠘꠡꠞ ꠡ꠆ꠛꠜꠣꠛ ꠈꠣꠞꠣꠙ, ꠎꠦꠔꠣꠄ ꠎꠤꠘꠣ ꠇꠞꠂꠘ, ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠇꠞꠂꠘ, ꠉꠣꠐꠥꠀ ꠘꠣꠌꠣꠁꠘ, ꠡꠝꠇꠣꠝꠤ, ");
INSERT INTO syls_vpl VALUES ("C16_10","076_6_10","1CO","6","10","10","ꠌꠥꠞꠤ, ꠟꠥꠜ-ꠟꠣꠟꠌꠤ, ꠝꠖꠈꠥꠞ, ꠉꠤꠛꠔ ꠉꠣꠅꠞꠣ ꠀꠞ ꠖꠈꠟꠛꠣꠎ, ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠑꠣꠁ ꠙꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C16_11","076_6_11","1CO","6","11","11","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠅ ꠀꠉꠦ ꠅꠟꠣ ꠀꠍꠟꠣꠄ, ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠞ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠗꠁꠀ ꠍꠣꠚ ꠇꠞꠍꠦ, ꠔꠥꠝꠞꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠣ ꠅꠁꠍꠦ ꠀꠞ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C16_12","076_6_12","1CO","6","12","12","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠇꠂꠘ, “ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠢꠣꠞꠣꠝ ꠘꠣꠄ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠎꠣꠁꠎ।” ꠅꠁꠟꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠦꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠃꠙꠇꠣꠞꠤ, ꠁꠟꠣ ꠌꠤꠘ꠆ꠔꠣ ꠑꠤꠇ ꠘꠣꠄ। ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠁꠎ ꠅꠁꠟꠦꠅ, ꠀꠝꠤ ꠇꠥꠘ꠆ꠔꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C16_13","076_6_13","1CO","6","13","13","ꠇꠦꠃ ꠇꠦꠃ ꠇꠂꠘ, “ꠙꠦꠐꠞ ꠟꠣꠉꠤ ꠈꠣꠘꠤ ꠀꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠙꠦꠐ ꠖꠦꠅꠀ ꠅꠁꠍꠦ।” ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ ꠇꠕꠣ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠁ ꠖꠥꠁꠅꠔꠣꠃ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠛꠣ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠡꠞꠤꠟ ꠔ ꠎꠤꠘꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠄ ꠛꠞꠋ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠟꠣꠉꠤꠃ, ꠀꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠡꠞꠤꠟꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("C16_14","076_6_14","1CO","6","14","14","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠅꠃ ꠛꠟꠦ ꠀꠝꠞꠣꠞꠦꠅ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C16_15","076_6_15","1CO","6","15","15","ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟ ꠅꠁꠟ ꠀꠟ-ꠝꠍꠤꠞ ꠡꠞꠤꠟꠞ ꠅꠋꠉ? ꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠡꠞꠤꠟꠞꠦ ꠀꠝꠤ ꠛꠖꠝꠣꠁꠡ ꠛꠦꠐꠤꠞ ꠡꠞꠤꠟꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠁꠔꠣꠝ ꠘꠤ? ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠘꠣ! ");
INSERT INTO syls_vpl VALUES ("C16_16","076_6_16","1CO","6","16","16","ꠔꠥꠝꠞꠣ ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠎꠦ ꠛꠦꠐꠣꠄ ꠛꠖꠝꠣꠁꠡ ꠛꠦꠐꠤꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠦ, ꠔꠣꠞ ꠡꠞꠤꠟ ꠔ ꠅꠃ ꠛꠦꠐꠤꠞ ꠟꠉꠦ ꠄꠇꠈꠣꠘꠅ ꠝꠤꠟꠤꠎꠣꠄ। ꠎꠦꠟꠣ ꠙꠛꠤꠔ꠆ꠞ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘ ꠄꠇ ꠡꠞꠤꠟ ꠅꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("C16_17","076_6_17","1CO","6","17","17","ꠅꠁꠟꠦ ꠎꠦ ꠎꠘ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠎꠣꠄ, ꠢꠦ ꠔꠣꠘ ꠟꠉꠦ ꠞꠥꠢꠦꠅ ꠄꠇ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C16_18","076_6_18","1CO","6","18","18","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠎꠣꠔꠞ ꠎꠤꠘꠣ ꠕꠣꠇꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠅ। ꠝꠣꠘꠡꠦ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠎꠔ ꠉꠥꠘꠣ ꠇꠞꠦ, ꠁꠔꠣ ꠡꠞꠤꠟꠞ ꠛꠣꠞꠦ ꠇꠞꠦ, ꠅꠁꠟꠦ ꠎꠦꠉꠤꠄ ꠎꠤꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠉꠥꠘꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C16_19","076_6_19","1CO","6","19","19","ꠔꠥꠝꠞꠣ ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠣꠛꠣ ꠊꠞ, ꠅꠃ ꠞꠥꠢꠥꠞꠦ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍ, ꠄꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠛꠡꠔ ꠇꠞꠂꠘ। ꠔꠥꠝꠣꠞ ꠡꠞꠤꠟ ꠔ ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠡꠝ꠆ꠙꠖ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C16_20","076_6_20","1CO","6","20","20","ꠛꠃꠔ ꠖꠣꠝ ꠖꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠈꠞꠤꠖ ꠇꠞꠣ ꠅꠁꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠡꠞꠤꠟꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("C17_1","076_7_1","1CO","7","1","1","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠚꠔꠥꠀ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠍ, ꠅꠈꠘ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠞꠣꠝ। ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣ ꠑꠤꠇ ꠀꠍꠦ, ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ ꠇꠣꠝ ꠅꠁꠟ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠘꠣ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C17_2","076_7_2","1CO","7","2","2","ꠅꠁꠟꠦ ꠡꠝꠣꠎꠞ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠎꠤꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠙꠞꠔꠦꠇ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠛꠃ ꠕꠣꠇꠟꠦ ꠜꠣꠟꠣ, ꠀꠞ ꠙꠞꠔꠦꠇ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠅ ꠎꠣꠝꠣꠁ ꠕꠣꠇꠟꠦ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C17_3","076_7_3","1CO","7","3","3","ꠢꠇꠟ ꠎꠣꠝꠣꠁꠄ ꠔꠣꠞ ꠛꠃꠞ ꠙꠣꠅꠘꠣ ꠢꠇ ꠀꠖꠣꠄ ꠇꠞꠃꠇ, ꠀꠞ ꠛꠃꠄꠅ ꠅꠟꠣ ꠎꠣꠝꠣꠁꠞ ꠙꠣꠅꠘꠣ ꠀꠖꠣꠄ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C17_4","076_7_4","1CO","7","4","4","ꠛꠃꠞ ꠡꠞꠤꠟ ꠔ ꠔꠣꠁꠞ ꠘꠤꠎꠞ ꠘꠣꠄ, ꠔꠣꠁꠞ ꠎꠣꠝꠣꠁꠞ। ꠅꠟꠣꠈꠣꠘ ꠎꠣꠝꠣꠁꠞ ꠡꠞꠤꠟꠅ ꠔꠣꠞ ꠘꠤꠎꠞ ꠘꠣꠄ, ꠔꠣꠞ ꠛꠃꠞ। ");
INSERT INTO syls_vpl VALUES ("C17_5","076_7_5","1CO","7","5","5","ꠎꠣꠝꠣꠁ-ꠛꠃꠄ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠘꠤꠞꠣꠡ ꠇꠞꠤꠅ ꠘꠣ, ꠈꠣꠟꠤ ꠈꠣꠍ ꠇꠥꠘꠥ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔꠞ ꠟꠣꠉꠤ ꠖꠥꠁꠅꠎꠘꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠤꠀ ꠇꠤꠍꠥ ꠡꠝꠄ ꠀꠟꠣꠖꠣ ꠞꠁꠔꠣꠄ ꠙꠣꠞ। ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠝꠤꠟꠤꠎꠤꠅ, ꠎꠣꠔꠦ ꠡꠞꠤꠟꠞ ꠈꠣꠁꠡꠞ ꠟꠣꠉꠤ ꠡꠄꠔꠣꠘꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠣꠞ ꠡꠥꠎꠥꠉ ꠘꠣ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C17_6","076_7_6","1CO","7","6","6","ꠔꠦ ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ ꠘꠣ, ꠈꠣꠟꠤ ꠁꠎꠣꠎꠔ ꠖꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C17_7","076_7_7","1CO","7","7","7","ꠔꠣ-ꠅ ꠀꠝꠣꠞ ꠝꠘꠞ ꠀꠡꠣ ꠅꠁꠟ, ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠛꠤꠀꠔꠤ ꠞꠃꠇ! ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔ ꠄꠇꠅ ꠝꠣꠘꠡꠦ ꠄꠇꠅ ꠘꠝꠥꠘꠣꠞ ꠞꠢꠝ-ꠘꠤꠀꠝꠔ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C17_8","076_7_8","1CO","7","8","8","ꠔꠦ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠀꠞ ꠛꠃ ꠝꠞꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞꠦ ꠀꠝꠤ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠞꠣꠝ, ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠞꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠔꠦ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C17_9","076_7_9","1CO","7","9","9","ꠅꠁꠟꠦ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠔꠦ ꠘꠣ ꠙꠣꠞꠟꠦ ꠔꠣꠞꠣ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠃꠇ। ꠇꠣꠞꠘ ꠡꠞꠤꠟꠞ ꠈꠣꠁꠡꠦ ꠎꠟꠤꠀ-ꠙꠥꠠꠤꠀ ꠝꠞꠣ ꠕꠣꠇꠤ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠣꠃ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C17_10","076_7_10","1CO","7","10","10","ꠀꠞ ꠎꠣꠝꠣꠁ-ꠛꠃꠞꠦ ꠀꠝꠤ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠛꠃꠄ ꠎꠣꠘꠥ ꠔꠣꠁꠞ ꠎꠣꠝꠣꠁ ꠍꠣꠠꠤꠀ ꠘꠣ ꠎꠣꠄ। ꠁ ꠢꠥꠇꠥꠝ ꠈꠣꠟꠤ ꠀꠝꠤ ꠖꠤꠞꠣꠝ ꠘꠣ, ꠡ꠆ꠛꠄꠅꠋ ꠝꠣꠟꠤꠇꠦꠃ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C17_11","076_7_11","1CO","7","11","11","ꠀꠞ ꠎꠥꠖꠤ ꠔꠣꠁ ꠢꠞꠤꠀ ꠎꠣꠄꠉꠤ, ꠔꠦ ꠖꠥꠍꠞꠣ ꠛꠤꠀ ꠘꠣ ꠛꠃꠇ, ꠛꠞꠋ ꠎꠣꠝꠣꠁꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠤꠀ ꠀꠃꠇ। ꠅꠟꠣ ꠇꠥꠘꠥ ꠎꠣꠝꠣꠁꠄꠅ ꠔꠣꠞ ꠛꠃꠞꠦ ꠔꠣꠟꠣꠇ ꠘꠣ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C17_12","076_7_12","1CO","7","12","12","ꠅꠈꠘ ꠎꠦꠔꠣ ꠇꠁꠞꠣꠝ, ꠁꠔꠣ ꠔ ꠡꠞꠣꠡꠞꠤ ꠝꠣꠟꠤꠇꠞ ꠢꠥꠇꠥꠝ ꠘꠣꠄ, ꠔꠣꠘ ꠙꠇ꠆ꠇꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠇꠥꠘꠥ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠞ ꠛꠃ ꠎꠥꠖꠤ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣꠞ ꠘꠣ ꠅꠁꠘ ꠀꠞ ꠔꠣꠁꠘ ꠎꠣꠝꠣꠁꠞ ꠟꠉꠦ ꠡꠋꠡꠣꠞ ꠇꠞꠔꠣ ꠌꠣꠁꠘ, ꠔꠦ ꠎꠣꠝꠣꠁꠄ ꠔꠣꠘꠞꠦ ꠔꠣꠟꠣꠇ ꠘꠣ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C17_13","076_7_13","1CO","7","13","13","ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞ ꠎꠣꠝꠣꠁꠅ ꠎꠥꠖꠤ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣꠞ ꠘꠣ ꠅꠁꠘ, ꠀꠞ ꠎꠣꠝꠣꠁ ꠔꠣꠘ ꠟꠉꠦ ꠞꠁꠔꠣ ꠌꠣꠁꠘ, ꠔꠦ ꠛꠃꠄ ꠁ ꠎꠣꠝꠣꠁꠞꠦ ꠔꠣꠟꠣꠇ ꠘꠣ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C17_14","076_7_14","1CO","7","14","14","ꠇꠣꠞꠘ ꠅꠃ ꠛꠃꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠁꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠍꠂꠘ ꠀꠞ ꠅꠃ ꠎꠣꠝꠣꠁꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠞ ꠛꠃꠞꠦꠅ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠍꠂꠘ। ꠁꠟꠣ ꠘꠣ ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠔ ꠘꠣꠙꠣꠇ ꠅꠁꠟ ꠅꠘꠦ। ꠀꠍꠟꠦ ꠔ ꠀꠟ꠆ꠟꠣꠄ ꠅꠈꠘ ꠔꠣꠞꠣꠞꠦꠅ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠝꠘꠅ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C17_15","076_7_15","1CO","7","15","15","ꠅꠁꠟꠦ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣꠞ ꠛꠣꠁꠞꠣ ꠢꠃ ꠛꠃ ꠛꠣ ꠎꠣꠝꠣꠁ ꠎꠥꠖꠤ ꠄꠝꠘꠦꠃ ꠀꠟꠉ ꠅꠁꠎꠤꠔꠣ ꠌꠣꠁꠘ, ꠔꠦ ꠅꠁꠔꠣ ꠙꠣꠞꠛꠣ। ꠁꠟꠣ ꠢꠣꠟꠔꠦ ꠢꠃ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠛꠣ ꠛꠁꠘ ꠛꠤꠀꠞ ꠇꠥꠘꠥ ꠛꠣꠘ꠆ꠖꠘꠞ ꠝꠣꠎꠦ ꠕꠣꠇꠂꠘ ꠘꠣ। ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠝꠞꠣ ꠡꠣꠘ꠆ꠔꠤꠄ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄꠃ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C17_16","076_7_16","1CO","7","16","16","ꠅ ꠛꠃ ꠅꠇꠟ, ꠔꠥꠝꠤ ꠇꠤꠟꠣ ꠛꠥꠎꠟꠣꠄ, ꠔꠥꠝꠣꠞ ꠎꠣꠝꠣꠁꠞ ꠎꠣꠘ ꠔꠥꠝꠤ ꠛꠣꠌꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ? ꠅ ꠎꠣꠝꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠤꠃ ꠛꠣ ꠇꠤꠟꠣ ꠛꠥꠎꠟꠣꠄ, ꠔꠥꠝꠣꠞ ꠛꠃꠞ ꠎꠣꠘ ꠔꠥꠝꠤ ꠛꠣꠌꠣꠁꠔꠣꠄ ꠙꠣꠞꠔꠣꠄ ꠘꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("C17_17","076_7_17","1CO","7","17","17","ꠎꠣꠁ ꠅꠃꠇ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠎꠣꠞꠦ ꠎꠦꠟꠣ ꠞꠣꠈꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠦ ꠎꠦꠟꠣ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠢꠦ ꠅꠟꠣ ꠌꠟꠃꠇ। ꠢꠇꠟ ꠁꠍꠣꠄꠁ ꠎꠝꠣꠔꠞꠦ ꠀꠝꠤ ꠅꠃ ꠄꠇꠁ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C17_18","076_7_18","1CO","7","18","18","ꠎꠦꠟꠣ, ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣ ꠇꠛꠥꠟ ꠇꠞꠟꠦ ꠢꠦ ꠔꠣꠞ ꠅꠃ ꠝꠍꠟꠝꠣꠘꠤꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠘꠣ ꠇꠞꠃꠇ, ꠀꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠣꠁꠟ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣ ꠇꠛꠥꠟ ꠇꠞꠟꠦ, ꠢꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠘꠣ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C17_19","076_7_19","1CO","7","19","19","ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤ ꠛꠣ ꠘꠣ ꠇꠞꠣꠘꠤ ꠁꠐꠣ ꠇꠥꠘꠥ ꠛꠠ ꠛꠦꠙꠣꠞ ꠘꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠣꠃ ꠅꠁꠟ ꠀꠍꠟ ꠇꠕꠣ। ");
INSERT INTO syls_vpl VALUES ("C17_20","076_7_20","1CO","7","20","20","ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠦ ꠎꠦ ꠢꠣꠟꠔꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠢꠦ ꠅꠃ ꠢꠣꠟꠔꠦꠃ ꠕꠣꠇꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C17_21","076_7_21","1CO","7","21","21","ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣꠔ ꠀꠁꠛꠣꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠤ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠄ ꠘꠤ? ꠔꠦ ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠛꠦꠎꠣꠞ ꠅꠁꠅ ꠘꠣ, ꠀꠞ ꠡ꠆ꠛꠣꠗꠤꠘ ꠅꠁꠔꠦ ꠙꠣꠞꠟꠦ ꠡ꠆ꠛꠣꠗꠤꠘ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("C17_22","076_7_22","1CO","7","22","22","ꠉꠥꠟꠣꠝꠤ ꠇꠞꠣ ꠢꠣꠟꠔꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠎꠣꠞꠦ ꠖꠣꠅꠔ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠢꠦ ꠔ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠡ꠆ꠛꠣꠗꠤꠘ ꠅꠁꠉꠦꠍꠦ। ꠀꠞ ꠡ꠆ꠛꠣꠗꠤꠘ ꠢꠣꠟꠔ ꠕꠣꠇꠤ ꠎꠣꠞꠦ ꠖꠣꠅꠔ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠢꠦ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C17_23","076_7_23","1CO","7","23","23","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣꠞꠦ ꠛꠃꠔ ꠖꠣꠝꠖꠤ ꠈꠞꠤꠖ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C17_24","076_7_24","1CO","7","24","24","ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠦ ꠎꠦ ꠢꠣꠟꠔꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠢꠦ ꠅꠟꠣꠃ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C17_25","076_7_25","1CO","7","25","25","ꠅꠈꠘ ꠀꠝꠤ ꠀꠛꠤꠀꠔꠤ ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠝꠥꠍꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠞꠣꠝ। ꠁ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠝꠤ ꠡꠞꠣꠡꠞꠤ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠍꠤ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠞꠁꠀ ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠔꠣꠝꠔ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C17_26","076_7_26","1CO","7","26","26","ꠅꠃ ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠔ ꠎꠦꠟꠣ ꠝꠍꠤꠛꠔ ꠀꠁꠀ ꠀꠎꠤꠍꠦ, ꠀꠝꠣꠞ ꠝꠘꠦ ꠅꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠁꠘ ꠎꠦꠟꠣ ꠀꠍ, ꠅꠟꠣꠃ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("C17_27","076_7_27","1CO","7","27","27","ꠔꠥꠝꠣꠞ ꠎꠥꠖꠤ ꠛꠃ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠣꠁꠞꠦ ꠔꠣꠟꠣꠇ ꠖꠤꠅ ꠘꠣ, ꠀꠞ ꠛꠃ ꠘꠣ ꠕꠣꠇꠟꠦ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠣꠔꠅ ꠟꠣꠉꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C17_28","076_7_28","1CO","7","28","28","ꠅꠁꠟꠦ ꠛꠤꠀ ꠇꠞꠟꠦ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠅꠁꠔ ꠘꠣꠄ, ꠀꠞ ꠇꠥꠘꠥ ꠀꠛꠤꠀꠔꠤ ꠙꠥꠠꠤ ꠛꠤꠀ ꠛꠁꠟꠦ ꠔꠣꠁꠞꠅ ꠉꠥꠘꠣ ꠅꠁꠔ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠎꠉꠔꠅ ꠔꠣꠞꠣꠞ ꠇꠡ꠆ꠐ ꠛꠣꠠꠤꠛ, ꠅꠃ ꠇꠡ꠆ꠐ ꠕꠣꠇꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C17_29","076_7_29","1CO","7","29","29","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠇꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠈꠥꠛ ꠎꠟꠖꠤ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠛꠦꠡꠤ ꠖꠦꠞꠤ ꠘꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘ ꠕꠣꠇꠤ ꠅꠃꠟꠣ ꠝꠘꠅ ꠇꠞꠤꠅ, ꠎꠦꠞꠣꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠍꠦ, ꠝꠘꠅ ꠇꠞꠤꠅ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C17_30","076_7_30","1CO","7","30","30","ꠎꠦꠞꠣ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠅ ꠀꠍꠂꠘ, ꠔꠣꠞꠣ ꠝꠘꠦ ꠇꠞꠃꠇ꠆ꠇꠣ ꠇꠥꠘꠥ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠘꠣꠁ, ꠎꠦꠞꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠞꠣ, ꠔꠣꠞꠣ ꠝꠘꠦ ꠇꠞꠃꠇ꠆ꠇꠣ ꠇꠥꠘꠥ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠘꠣꠁ, ꠀꠞ ꠎꠣꠞꠣ ꠈꠞꠤꠖ-ꠛꠤꠇꠤ ꠇꠞꠦꠞ, ꠔꠣꠞꠣꠅ ꠝꠘꠦ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠁꠔꠣ ꠝꠣꠟꠞ ꠃꠙꠞꠦ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠖꠣꠛꠤ-ꠖꠣꠅꠀ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C17_31","076_7_31","1CO","7","31","31","ꠎꠦꠞꠣ ꠎꠉꠔ-ꠡꠋꠡꠣꠞ ꠟꠁꠀ ꠛꠦꠡ꠆ꠔ, ꠔꠣꠞꠣꠞ ꠜꠣꠛ ꠎꠣꠘꠥ ꠙꠥꠞꠣꠙꠥꠞ ꠡꠋꠡꠣꠞꠤ ꠘꠣ ꠅꠄ, ꠇꠣꠞꠘ ꠜꠛꠞ ꠛꠣꠎꠣꠞ ꠔ ꠡꠣꠋꠉ ꠅꠁꠎꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C17_32","076_7_32","1CO","7","32","32","ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠕꠣꠇꠤ ꠢꠞꠣꠁ ꠞꠣꠈꠔꠣꠝ। ꠇꠣꠞꠘ ꠀꠛꠤꠀꠔꠤ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠂꠘ ꠝꠣꠟꠤꠇꠞ ꠛꠦꠙꠣꠞꠦ, ꠇꠤꠟꠣ ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠞꠦ ꠈꠥꠡꠤ ꠞꠣꠈꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C17_33","076_7_33","1CO","7","33","33","ꠅꠁꠟꠦ ꠛꠤꠀꠔꠤ ꠝꠣꠘꠡꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠂꠘ ꠡꠋꠡꠣꠞꠞ ꠛꠦꠙꠣꠞꠦ, ꠇꠤꠟꠣ ꠊꠞꠞ ꠛꠃ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠈꠥꠡꠤ ꠞꠣꠈꠣ ꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("C17_34","076_7_34","1CO","7","34","34","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠝꠘ ꠖꠥ-ꠐꠣꠘꠣꠔ ꠙꠠꠤ ꠎꠣꠄ। ꠅꠃꠟꠣ ꠀꠛꠤꠀꠔꠤ ꠛꠦꠐꠤ ꠀꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠂꠘ ꠝꠣꠟꠤꠇꠞ ꠛꠦꠙꠣꠞꠦ, ꠇꠤꠟꠣ ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠞꠦ ꠈꠥꠡꠤ ꠞꠣꠈꠣ ꠎꠣꠄ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠡꠞꠤꠟ ꠀꠞ ꠝꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠕꠣꠇꠦ। ꠅꠁꠟꠦ ꠛꠤꠀꠔꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠂꠘ ꠡꠋꠡꠣꠞꠞ ꠛꠦꠙꠣꠞꠦ, ꠇꠤꠟꠣ ꠎꠣꠝꠣꠁꠞꠦ ꠈꠥꠡꠤ ꠞꠣꠈꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C17_35","076_7_35","1CO","7","35","35","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠅꠃ ꠔꠣꠟꠤꠝ ꠅꠇꠟ ꠔ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠇꠁꠞꠣꠝ। ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠟꠣꠔ ꠇꠥꠘꠥ ꠚꠣꠡ ꠟꠣꠉꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ ꠘꠣ, ꠈꠣꠟꠤ ꠇꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠘꠦꠇ ꠙꠕꠦ ꠌꠟꠅ ꠀꠞ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠞ ꠀꠡꠤꠇ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("C17_36","076_7_36","1CO","7","36","36","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠘꠅ ꠇꠞꠦ, ꠢꠦ ꠔꠣꠞ ꠀꠛꠤꠀꠔꠤ ꠙꠥꠠꠤꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠇꠞꠦꠞ ꠘꠣ, ꠙꠥꠠꠤꠞ ꠛꠤꠀꠞ ꠛꠄꠅꠡ ꠙꠣꠞ ꠅꠁꠎꠣꠞ ꠇꠞꠤ, ꠢꠦ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠖꠦꠅꠀ ꠎꠞꠥꠞ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ ꠖꠦꠃꠇ। ꠄꠔꠦ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C17_37","076_7_37","1CO","7","37","37","ꠅꠁꠟꠦ ꠎꠦ ꠝꠣꠘꠡꠞ ꠝꠘ ꠕꠤꠞ ꠀꠍꠦ, ꠎꠣꠞ ꠝꠘꠅ ꠇꠥꠘꠥ ꠅꠡꠣꠘ꠆ꠔꠤ ꠘꠣꠁ, ꠢꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠝꠘꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠇꠣꠝ ꠇꠞꠦ, ꠁ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠘꠦ ꠇꠞꠦ ꠔꠣꠞ ꠙꠥꠠꠤꠞ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠎꠞꠥꠞ ꠘꠣꠄ, ꠔꠦ ꠢꠦ ꠑꠤꠇ ꠇꠣꠝꠃ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("C17_38","076_7_38","1CO","7","38","38","ꠅꠈꠘ ꠛꠥꠎꠣ ꠎꠣꠞ, ꠎꠦ ꠎꠘꠦ ꠔꠣꠞ ꠙꠥꠠꠤꠞꠦ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠖꠦꠄ, ꠢꠦ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠦ ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠔꠣꠞ ꠙꠥꠠꠤꠞꠦ ꠀꠛꠤꠀꠔꠤ ꠢꠣꠟꠔꠦ ꠞꠣꠈꠦ, ꠢꠦ ꠀꠞꠅ ꠛꠦꠡꠤ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C17_39","076_7_39","1CO","7","39","39","ꠎꠣꠝꠣꠁ ꠎꠔꠖꠤꠘ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠂꠘ, ꠅꠔꠖꠤꠘ ꠛꠃ ꠎꠣꠝꠣꠁꠞ ꠛꠣꠘ꠆ꠖꠘꠅ ꠕꠣꠇꠂꠘ। ꠅꠁꠟꠦ ꠎꠣꠝꠣꠁ ꠝꠣꠞꠣ ꠉꠦꠟꠦ ꠛꠃꠄ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠘ, ꠀꠞ ꠘꠤꠎꠞ ꠙꠍꠘ꠆ꠖ ꠝꠣꠚꠤꠇ ꠁꠍꠣꠄꠁ ꠔꠞꠤꠇꠣꠞ ꠎꠦꠇꠥꠘꠥ ꠎꠘꠞ ꠉꠦꠍꠦ ꠛꠤꠀ ꠛꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C17_40","076_7_40","1CO","7","40","40","ꠔꠣ-ꠅ ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠤ, ꠔꠣꠁꠘ ꠠꠣꠠꠤ ꠢꠣꠟꠔꠦ ꠞꠁꠟꠦꠃ ꠀꠞꠅ ꠜꠣꠟꠣ। ꠀꠝꠤ ꠛꠥꠎꠞꠣꠝ, ꠀꠝꠤ ꠅꠃ ꠢꠇ꠆ꠇꠟꠔꠣ ꠀꠟ꠆ꠟꠣꠁ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C18_1","076_8_1","1CO","8","1","1","ꠢꠥꠘꠅ, ꠅꠈꠘ ꠀꠝꠤ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀ ꠙꠡꠣꠖꠞ ꠝꠥꠍꠟꠣꠞ ꠇꠕꠣ ꠇꠁꠞꠣꠝ। ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠀꠝꠞꠣ ꠢꠇꠟꠞꠃ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠀꠍꠦ। ꠅꠁꠟꠦ ꠀꠈꠟꠦ ꠛꠠꠣꠁ ꠛꠣꠠꠦ, ꠀꠞ ꠝꠢꠛ꠆ꠛꠔꠦ ꠝꠣꠘꠥꠡ ꠉꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("C18_2","076_8_2","1CO","8","2","2","ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠤꠎꠞꠦ ꠡꠤꠀꠘ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠦ ꠎꠔꠈꠣꠘ ꠡꠤꠀꠘ ꠅꠀ ꠎꠞꠥꠞ, ꠅꠔꠈꠣꠘ ꠔ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C18_3","076_8_3","1CO","8","3","3","ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔ ꠔꠣꠞꠦ ꠌꠤꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C18_4","076_8_4","1CO","8","4","4","ꠔꠦ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀ ꠙꠡꠣꠖꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠖꠦꠛꠔꠣ ꠛꠟꠔꠦ ꠁ ꠎꠉꠔꠅ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ, ꠄꠇ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C18_5","076_8_5","1CO","8","5","5","ꠀꠍꠝꠣꠘꠅ ꠛꠣ ꠎꠝꠤꠘꠅ ꠎꠦꠇꠥꠘꠥ ꠎꠣꠉꠣꠔ, ꠖꠦꠛ-ꠖꠦꠛꠤ ꠘꠣꠝꠦ ꠎꠥꠖꠤ ꠇꠥꠘ꠆ꠔꠣ ꠕꠣꠇꠤꠀ ꠕꠣꠇꠦ, ꠔꠦ ꠛꠃꠔ ꠖꠦꠛꠔꠣ ꠀꠞ ꠛꠃꠔ ꠝꠥꠘꠤꠛ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C18_6","076_8_6","1CO","8","6","6","ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠎꠣꠘꠣ ꠝꠔꠦ ꠈꠣꠟꠤ ꠄꠇ ꠀꠟ꠆ꠟꠣ ꠀꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ। ꠔꠣꠘ ꠀꠔꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠅꠁꠍꠦ, ꠔꠣꠘ ꠟꠣꠉꠤꠃ ꠀꠝꠞꠣ ꠛꠣꠌꠤꠀ ꠀꠍꠤ। ꠑꠤꠇ ꠅꠃꠟꠣ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠅ ꠈꠣꠟꠤ ꠄꠇꠎꠘ, ꠔꠣꠘ ꠘꠣꠝ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ। ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠅꠁꠍꠦ, ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠔꠣꠘ ꠟꠣꠉꠤꠃ ꠐꠤꠇꠤꠀ ꠀꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C18_7","076_8_7","1CO","8","7","7","ꠁꠔꠣ ꠛꠥꠎꠣꠞ ꠀꠈꠟ ꠔ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠘꠣꠁ। ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠀꠉꠦ ꠖꠦꠛꠔꠣꠞꠦ ꠜꠎꠘꠣ ꠇꠞꠔ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠅꠈꠘ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀ ꠙꠡꠣꠖ ꠈꠣꠁꠟꠦ, ꠔꠣꠞꠣꠞ ꠛꠤꠛꠦꠇꠞ ꠇꠝꠎꠥꠞꠤꠄ ꠔꠣꠞꠦ ꠇꠟꠋꠇꠤ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C18_8","076_8_8","1CO","8","8","8","ꠀꠍꠟꠦ ꠇꠥꠘꠥ ꠘꠝꠥꠘꠣꠞ ꠈꠣꠘꠤꠞ ꠛꠟꠦꠃ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠛꠥꠟ ꠅꠁ ꠘꠣ। ꠈꠣꠘꠤ ꠘꠣ ꠈꠣꠁꠟꠦꠅ ꠀꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠈꠦꠔꠤ ꠅꠄ ꠘꠣ, ꠀꠞ ꠈꠣꠁꠟꠦꠅ ꠇꠥꠘꠥ ꠟꠣꠜ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C18_9","076_8_9","1CO","8","9","9","ꠅꠁꠟꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠔꠥꠝꠞꠣꠞ ꠅꠃ ꠡ꠆ꠛꠣꠗꠤꠘꠔꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠎꠣꠘꠥ ꠇꠝꠎꠥꠞ ꠁꠝꠣꠘꠖꠣꠞꠞ ꠟꠣꠉꠤ ꠉꠥꠘꠣꠞ ꠇꠣꠞꠘ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C18_10","076_8_10","1CO","8","10","10","ꠔꠥꠝꠣꠞ ꠔ ꠀꠈꠟ-ꠛꠤꠛꠦꠇ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠎꠣꠞ ꠛꠤꠛꠦꠇ ꠇꠝꠎꠥꠞ, ꠢꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠛꠔꠣꠞ ꠝꠘ꠆ꠖꠤꠞꠅ ꠛꠁꠀ ꠙꠡꠣꠖ ꠈꠣꠅꠀꠔ ꠖꠦꠈꠦ, ꠔꠦ ꠢꠦ-ꠅ ꠅꠃ ꠙꠡꠣꠖ ꠈꠣꠁꠔ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C18_11","076_8_11","1CO","8","11","11","ꠀꠞ ꠅꠃ ꠇꠝꠎꠥꠞ ꠜꠣꠁꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠔ ꠀꠟ-ꠝꠍꠤꠄ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠟꠣ, ꠅꠈꠘ ꠔꠥꠝꠣꠞ ꠅꠃ ꠀꠈꠟꠦ ꠔꠣꠞ ꠁꠝꠣꠘꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("C18_12","076_8_12","1CO","8","12","12","ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞ, ꠔꠣꠞꠣꠞ ꠇꠝꠎꠥꠞ ꠛꠤꠛꠦꠇꠞꠦ ꠖꠥꠈ ꠖꠦꠅ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦꠃ ꠉꠥꠘꠣ ꠇꠞ। ");
INSERT INTO syls_vpl VALUES ("C18_13","076_8_13","1CO","8","13","13","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠞ ꠇꠣꠞꠘꠦ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠜꠣꠁꠞ ꠁꠝꠣꠘꠞ ꠈꠦꠔꠤ ꠅꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠉꠥꠡ꠆ꠔ ꠈꠣꠅꠀꠅ ꠄꠇ꠆ꠇꠦꠞꠦ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C19_1","076_9_1","1CO","9","1","1","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠤ ꠇꠤꠔꠣ ꠡ꠆ꠛꠣꠗꠤꠘ ꠘꠣꠄ ꠘꠤ? ꠀꠝꠤ ꠇꠥꠘꠥ ꠍꠣꠢꠣꠛꠤ ꠘꠣꠄ ꠘꠤ? ꠀꠝꠤ ꠇꠥꠘꠥ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠍꠤ ꠘꠣ ꠘꠤ? ꠝꠣꠟꠤꠇꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦ ꠔꠛꠟꠤꠉ ꠇꠣꠝ ꠇꠞꠍꠤ, ꠁꠔꠣꠞ ꠚꠟ ꠔꠥꠝꠞꠣ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C19_2","076_9_2","1CO","9","2","2","ꠅꠁꠘ꠆ꠘ ꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠍꠣꠢꠣꠛꠤ ꠇꠁꠀ ꠘꠣ ꠝꠣꠘꠟꠦꠅ ꠔꠥꠝꠞꠣ ꠔ ꠝꠣꠘꠛꠣꠄ, ꠀꠝꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠇꠣꠝꠞ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠔꠥꠝꠞꠣꠃ, ꠇꠣꠞꠘ ꠀꠝꠣꠞ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("C19_3","076_9_3","1CO","9","3","3","ꠔꠦ ꠀꠝꠣꠞ ꠍꠣꠢꠣꠛꠤ ꠙꠖ ꠟꠁꠀ ꠎꠦꠞꠣ ꠡꠘ꠆ꠖꠄ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠅꠃ ꠎꠥꠀꠙ ꠢꠥꠘꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("C19_4","076_9_4","1CO","9","4","4","ꠀꠝꠤ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦ ꠇꠤꠔꠣ ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠞ ꠛꠦꠔꠘ ꠙꠣꠁꠛꠣꠞ ꠅꠗꠤꠇꠣꠞ ꠘꠣꠁ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C19_5","076_9_5","1CO","9","5","5","ꠝꠥꠝꠤꠘ ꠇꠥꠘꠥ ꠛꠁꠘꠞꠦ ꠡꠣꠖꠤ ꠇꠞꠣꠞ ꠅꠗꠤꠇꠣꠞ ꠀꠝꠞꠣꠞ ꠘꠣꠁ ꠘꠤ? ꠅꠁꠘ꠆ꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠎꠦꠟꠣ ꠎꠣꠞꠎꠤꠞ ꠛꠤꠛꠤꠞꠦ ꠟꠁꠀ ꠍꠚꠞꠅ ꠎꠣꠁꠘ, ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠙꠣꠞꠤ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C19_6","076_9_6","1CO","9","6","6","ꠈꠣꠟꠤ ꠀꠝꠤ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠦꠃ ꠘꠤꠎꠞ ꠀꠔꠦ ꠇꠣꠝꠣꠁ ꠇꠞꠤꠀ ꠈꠣꠁꠔꠣꠝ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C19_7","076_9_7","1CO","9","7","7","ꠘꠤꠎꠞ ꠉꠣꠐ꠆ꠐꠤꠞ ꠐꠦꠇꠣ ꠜꠣꠋꠉꠤꠀ ꠇꠦꠃ ꠍꠤꠙꠣꠁꠞ ꠌꠣꠇꠞꠤ ꠇꠞꠦ ꠘꠤ? ꠎꠦ ꠉꠤꠞꠡ꠆ꠔꠦ ꠚꠟꠞ ꠛꠣꠉꠣꠘ ꠇꠞꠦ, ꠢꠦ ꠁꠔꠣꠞ ꠚꠟ ꠈꠣꠄ ꠘꠣ ꠘꠤ? ꠎꠦ ꠞꠣꠈꠣꠟꠦ ꠙꠡꠥꠙꠣꠟ ꠞꠣꠈꠦ, ꠢꠦ ꠁꠔꠣꠞ ꠖꠥꠗ ꠈꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C19_8","076_9_8","1CO","9","8","8","ꠀꠝꠤ ꠔ ꠈꠣꠟꠤ ꠝꠣꠘꠥꠡ ꠀꠈꠟꠦ ꠝꠣꠔꠤꠀꠞ ꠘꠣ, ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔꠦꠅ ꠅꠟꠣ ꠇꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C19_9","076_9_9","1CO","9","9","9","ꠡꠞꠤꠅꠔꠅ ꠀꠍꠦ, “ꠗꠣꠘ ꠝꠣꠠꠣ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠉꠞꠥꠞ ꠝꠥꠈꠅ ꠢꠥꠚꠤ ꠟꠣꠉꠣꠁꠅ ꠘꠣ।” ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠈꠣꠟꠤ ꠉꠞꠥꠞ ꠇꠕꠣꠃ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠂꠘ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C19_10","076_9_10","1CO","9","10","10","ꠔꠣꠁꠘ ꠀꠍꠟꠦ ꠀꠝꠞꠣꠞ ꠇꠕꠣꠃ ꠇꠁꠍꠂꠘ, ꠁꠈꠣꠘ ꠢꠣꠍꠣ ꠘꠣꠄ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ, ꠁꠔꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠟꠦꠈꠣ ꠅꠁꠍꠤꠟ, ꠇꠣꠞꠘ ꠎꠦꠁꠘ ꠈꠦꠔ ꠇꠞꠂꠘ ꠀꠞ ꠎꠦꠁꠘ ꠗꠣꠘ ꠝꠣꠠꠣ ꠖꠦꠁꠘ, ꠚꠡꠟꠞ ꠛꠣꠐ ꠙꠣꠅꠀꠞ ꠀꠡꠣꠄꠃ ꠔꠣꠞꠣꠞ ꠁꠔꠣ ꠇꠞꠣ ꠃꠌꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("C19_11","076_9_11","1CO","9","11","11","ꠔꠦ ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠞꠥꠢꠣꠘꠤꠇ ꠛꠤꠌꠤ ꠞꠥꠁꠍꠤ, ꠅꠃꠟꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠘꠤꠀꠛꠤ ꠈꠣꠘꠤ-ꠙꠣꠘꠤ ꠎꠥꠉꠣꠁ, ꠔꠦ ꠛꠦꠡꠤ ꠇꠥꠘ꠆ꠔꠣ ꠘꠤꠞꠣꠝ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C19_12","076_9_12","1CO","9","12","12","ꠀꠞ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠖꠣꠛꠤ ꠈꠣꠐꠦ, ꠔꠦ ꠀꠝꠞꠣ ꠀꠞꠅ ꠛꠦꠡꠤ ꠖꠣꠛꠤ ꠈꠣꠐꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ ꠘꠤ? ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠁꠟꠣ ꠖꠣꠛꠤ ꠘꠣ ꠈꠣꠐꠣꠁꠀ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀꠞ, ꠎꠣꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠅ ꠀꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠙꠕꠞ ꠇꠣꠐꠣ ꠘꠣ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("C19_13","076_9_13","1CO","9","13","13","ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍꠅ ꠎꠦꠞꠣ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠅꠈꠣꠘ ꠕꠣꠇꠤꠃ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠙꠣꠁꠘ, ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠔ ꠎꠦꠞꠣ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠣꠟ ꠕꠣꠇꠤ ꠛꠣꠐ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C19_14","076_9_14","1CO","9","14","14","ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠢꠥꠇꠥꠝ ꠀꠍꠦ, ꠎꠣꠞꠣ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠅꠃ ꠇꠣꠝꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠈꠣꠅꠀ-ꠚꠤꠘ꠆ꠖꠣ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C19_15","076_9_15","1CO","9","15","15","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔ ꠄꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠤꠍꠤ ꠘꠣ। ꠀꠞ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠁꠔꠣ ꠟꠦꠈꠤꠀꠞ ꠘꠣ, ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠅꠔꠣꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠔꠣꠄ ꠇꠞꠤ। ꠅꠈꠘ ꠀꠝꠣꠞ ꠅꠃ ꠛꠠꠣꠁꠞꠦ ꠎꠥꠖꠤ ꠇꠦꠃ ꠛꠦꠇꠣꠝꠣ ꠛꠣꠘꠣꠁꠟꠣꠄ, ꠔꠦ ꠀꠝꠣꠞ ꠝꠞꠤ ꠎꠣꠅꠀꠃ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C19_16","076_9_16","1CO","9","16","16","ꠀꠝꠤ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀꠞ, ꠄꠔꠦ ꠀꠝꠣꠞ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠘꠤꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠚꠞꠎ। ꠔꠛꠟꠤꠉ ꠘꠣ ꠇꠞꠟꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠃꠇ! ");
INSERT INTO syls_vpl VALUES ("C19_17","076_9_17","1CO","9","17","17","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠥꠖꠤ ꠈꠥꠡꠤ ꠝꠘꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠤ, ꠔꠦ ꠔ ꠀꠝꠣꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠀꠍꠦ, ꠀꠞ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠘꠣ-ꠅ ꠇꠞꠤ, ꠔꠦ ꠝꠣꠟꠤꠇꠞ ꠖꠦꠅꠀ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠔ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C19_18","076_9_18","1CO","9","18","18","ꠅꠈꠘ ꠀꠝꠣꠞ ꠁ ꠇꠣꠝꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠇꠤꠔꠣ? ꠁ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠅꠁꠟ, ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠢꠣꠞꠤ ꠙꠣꠅꠘꠣ ꠛꠦꠔꠘ ꠘꠦꠁ ꠘꠣ, ꠛꠤꠘꠣ ꠙꠄꠡꠣꠄ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠃ ꠀꠝꠣꠞ ꠛꠦꠔꠘ। ");
INSERT INTO syls_vpl VALUES ("C19_19","076_9_19","1CO","9","19","19","ꠀꠝꠤ ꠎꠥꠖꠤꠅ ꠇꠥꠘꠥ ꠛꠦꠐꠣꠞ ꠉꠥꠟꠣꠝ ꠘꠣꠄ, ꠔꠦꠛꠃ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞꠦ ꠢꠇꠟꠞ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠁꠀ ꠞꠣꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C19_20","076_9_20","1CO","9","20","20","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠘ ꠎꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠢꠥꠖꠤ ꠡꠝꠣꠎꠅ ꠀꠝꠤ ꠁꠢꠥꠖꠤꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠍꠤ। ꠀꠝꠤ ꠔ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔꠞ ꠅꠗꠤꠘꠦ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠎꠣꠞꠣ ꠔꠣꠘ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠦ, ꠔꠣꠞꠣꠞꠦ ꠎꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C19_21","076_9_21","1CO","9","21","21","ꠀꠞ ꠎꠣꠞꠣ ꠡꠞꠤꠅꠔꠞ ꠛꠣꠁꠞꠣ, ꠔꠣꠞꠣꠞꠦ ꠎꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠡꠞꠤꠅꠔꠞ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠍꠤ। ꠀꠍꠟꠦ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠡꠞꠤꠅꠔꠞ ꠛꠣꠞꠦ ꠘꠣꠄ, ꠀꠟ-ꠝꠍꠤꠞ ꠡꠞꠤꠅꠔꠞ ꠅꠗꠤꠘꠦ ꠀꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C19_22","076_9_22","1CO","9","22","22","ꠎꠦꠞꠣ ꠇꠝꠎꠥꠞ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠇꠝꠎꠥꠞꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠍꠤ, ꠔꠣꠞꠣꠞꠦꠅ ꠎꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ꠛꠦꠙꠣꠞ ꠅꠁꠟ, ꠎꠦꠇꠥꠘꠥ ꠝꠘ꠆ꠔꠦ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠢꠇꠟ ꠡꠝꠣꠎꠞ ꠝꠘ ꠎꠥꠉꠣꠁ ꠌꠟꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C19_23","076_9_23","1CO","9","23","23","ꠈꠣꠟꠤ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠁꠔꠣ ꠇꠞꠤꠀꠞ, ꠎꠣꠔꠦ ꠄꠞ ꠞꠢꠝꠔꠞ ꠜꠣꠉꠤ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("C19_24","076_9_24","1CO","9","24","24","ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠖꠃꠠꠞ ꠈꠦꠟꠣꠔ ꠃꠑꠤꠀ ꠢꠇꠟꠦꠃ ꠖꠃꠠꠣꠄ, ꠅꠁꠟꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠈꠣꠟꠤ ꠄꠇꠎꠘꠦꠃ ꠙꠣꠄ। ꠅꠈꠘ ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠖꠃꠠꠣꠅ ꠎꠣꠔꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("C19_25","076_9_25","1CO","9","25","25","ꠖꠃꠠꠞ ꠈꠦꠟꠣꠔ ꠖꠃꠠꠣꠁꠀ ꠢꠣꠞꠤ ꠝꠣꠘꠡꠦ ꠅꠟꠣ ꠄꠇ ꠝꠣꠟꠣ ꠙꠣꠄ, ꠎꠦ ꠝꠣꠟꠣ ꠛꠣꠖꠦ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ, ꠀꠞ ꠅꠃ ꠝꠣꠟꠣ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠄꠞꠣ ꠛꠃꠔ ꠇꠑꠤꠘ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘꠅ ꠝꠣꠘꠦ। ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠔ ꠀꠍꠟ ꠅꠇ꠆ꠇꠄ ꠝꠣꠟꠣ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C19_26","076_9_26","1CO","9","26","26","ꠄꠞꠟꠣꠉꠤ ꠃꠖ꠆ꠖꠦꠡ꠆ꠡ ꠍꠣꠠꠣ ꠀꠝꠤ ꠖꠃꠠꠣꠁꠞꠣꠝ ꠘꠣ। ꠎꠦꠔꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠛꠣꠔꠣꠡꠞ ꠟꠉꠦ ꠇꠤꠟꠣꠇꠤꠟꠤ ꠇꠞꠂꠘ, ꠀꠝꠤ ꠔ ꠁꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C19_27","076_9_27","1CO","9","27","27","ꠛꠞꠋ ꠀꠝꠤ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞꠦ ꠇꠡ꠆ꠐ ꠖꠤꠀ ꠉꠥꠟꠣꠝꠞ ꠟꠣꠈꠣꠘ ꠞꠣꠈꠍꠤ, ꠎꠣꠔꠦ ꠅꠁꠘ꠆ꠘꠞ ꠉꠦꠍꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠢꠣꠞꠤ, ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠕꠣꠇꠤ ꠘꠤꠎꠦ ꠛꠣꠖ ꠘꠣ ꠙꠠꠤ। ");
INSERT INTO syls_vpl VALUES ("C110_1","076_10_1","1CO","10","1","1","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠊꠐꠘꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠞꠃꠇ। ꠄꠞꠣ ꠢꠇꠟ ꠔ ꠉꠣꠁꠛꠤ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠞ ꠔꠟꠦ ꠞꠁꠔꠣ, ꠢꠇꠟꠦ ꠙꠣꠅꠄ ꠀꠐꠤꠀ ꠘꠤꠟ ꠖꠞꠤꠀ ꠙꠣꠞꠅꠁꠀ ꠉꠦꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C110_2","076_10_2","1CO","10","2","2","ꠢꠇꠟꠦꠃ ꠢꠃ ꠝꠦꠊꠞ ꠈꠥꠐꠤ ꠀꠞ ꠘꠤꠟ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠦ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠔꠞꠤꠇꠣꠄ ꠙꠣꠇ ꠉꠥꠍꠟ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C110_3","076_10_3","1CO","10","3","3","ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠉꠣꠁꠛꠤ ꠈꠣꠘꠤ ꠈꠣꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("C110_4","076_10_4","1CO","10","4","4","ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠉꠣꠁꠛꠤ ꠙꠣꠘꠤꠅ ꠈꠣꠁꠍꠂꠘ, ꠢꠇꠟꠦ ꠅꠟꠣ ꠄꠇ ꠇꠥꠖꠞꠔꠤ ꠙꠣꠔ꠆ꠔꠞ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠈꠣꠁꠔꠣ, ꠎꠦ ꠙꠣꠔ꠆ꠔꠞ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠔ, ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠃ ꠅꠁꠟꠣ ꠀꠟ-ꠝꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C110_5","076_10_5","1CO","10","5","5","ꠔꠣ-ꠅ ꠄꠞꠣ ꠛꠦꠡꠤꠞ ꠜꠣꠉ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠈꠥꠡꠤ ꠀꠍꠟꠣ ꠘꠣ। ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠞꠣꠞ ꠟꠣꠡ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠙꠠꠤ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("C110_6","076_10_6","1CO","10","6","6","ꠁꠔꠣ ꠊꠐꠘꠣ ꠅꠁꠟ ꠀꠝꠞꠣꠞ ꠔꠣꠟꠤꠝꠞ ꠟꠣꠉꠤ ꠄꠇ ꠁꠔꠤꠢꠣꠡ, ꠎꠣꠔꠦ ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠅꠁ ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠥ-ꠙꠕꠞ ꠀꠡꠤꠇ ꠘꠣ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("C110_7","076_10_7","1CO","10","7","7","ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠇꠦꠃ ꠎꠦꠟꠣ ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠇꠞꠍꠤꠟ, ꠔꠥꠝꠞꠣ ꠁꠟꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, “ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠈꠣꠘꠤꠔ ꠛꠁꠟꠣ, ꠛꠣꠖꠦ ꠔꠣꠞꠣ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ ꠇꠞꠤꠀ ꠢꠣꠞꠤ, ꠢꠂ-ꠢꠥꠟ꠆ꠟꠣ ꠇꠞꠤ ꠘꠣꠌ-ꠉꠣꠘ, ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("C110_8","076_10_8","1CO","10","8","8","ꠀꠞꠇꠛꠣꠞ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠃꠔ ꠎꠘꠦ ꠎꠤꠘꠣ ꠇꠞꠣꠄ, ꠄꠇꠁ ꠖꠤꠘꠦ ꠔꠦꠁꠡ ꠀꠎꠣꠞ ꠝꠣꠘꠥꠡ ꠝꠣꠞꠣ ꠉꠦꠍꠟꠣ। ꠔꠦ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠅꠟꠣꠈꠣꠘ ꠎꠤꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("C110_9","076_10_9","1CO","10","9","9","ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠃꠔꠦ ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠀ ꠢꠣꠚꠞ ꠇꠣꠝꠠ ꠈꠣꠁꠀ ꠝꠞꠍꠂꠘ। ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠔꠣꠘꠞꠦ ꠁꠟꠣ ꠙꠞꠤꠇ꠆ꠇꠣ ꠘꠣ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C110_10","076_10_10","1CO","10","10","10","ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠃꠔꠦ ꠘꠣ-ꠈꠥꠡ ꠅꠁꠀ ꠛꠇꠣ-ꠎꠇꠣ ꠇꠞꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠁꠟꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C110_11","076_10_11","1CO","10","11","11","ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠁꠔꠣ ꠊꠐꠤꠍꠤꠟ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ, ꠎꠣꠔꠦ ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠅꠁ। ꠀꠝꠞꠣ ꠎꠦꠞꠣ ꠅꠃ ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠥꠡ, ꠅꠃ ꠟꠦꠈꠣ ꠙꠠꠤꠀ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠡꠣꠛꠗꠣꠘꠦ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("C110_12","076_10_12","1CO","10","12","12","ꠄꠞꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠝꠘꠅ ꠇꠞꠦ, ꠢꠦ ꠝꠎꠛꠥꠔ ꠀꠍꠦ, ꠔꠦ ꠢꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠃꠇ ꠎꠣꠔꠦ ꠔꠣꠞ ꠁꠝꠣꠘ ꠘꠣ ꠀꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("C110_13","076_10_13","1CO","10","13","13","ꠝꠣꠘꠡꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠎꠦꠟꠣꠈꠣꠘ ꠙꠞꠤꠇ꠆ꠇꠣ ꠀꠄ, ꠅꠔꠣꠞ ꠛꠣꠁꠞꠣ ꠘꠄꠀ ꠇꠥꠘꠥ ꠙꠞꠤꠇ꠆ꠇꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠅꠞ ꠘꠣ। ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠢꠇ-ꠢꠣꠟꠣꠟ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠁꠎ꠆ꠎꠞ ꠅꠔꠤꠞꠤꠇ꠆ꠔ ꠇꠥꠘꠥ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠚꠣꠟꠣꠁꠔꠣ ꠘꠣꠄ, ꠛꠞꠋ ꠙꠞꠤꠇ꠆ꠇꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠛꠣꠞ ꠙꠕꠅ ꠛꠣꠔꠣꠁ ꠖꠤꠛꠣ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C110_14","076_10_14","1CO","10","14","14","ꠅ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠙꠥꠎꠣ ꠕꠣꠇꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("C110_15","076_10_15","1CO","10","15","15","ꠔꠥꠝꠞꠣꠞꠦ ꠀꠈꠟꠖꠣꠞ ꠎꠣꠘꠤꠀꠃ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠁꠞꠣꠝ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠎꠣꠌꠣꠁ-ꠛꠣꠌꠣꠁ ꠇꠞꠤꠀ ꠖꠦꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("C110_16","076_10_16","1CO","10","16","16","ꠀꠟ-ꠝꠍꠤꠞ ꠝꠦꠎꠛꠣꠘꠤꠞ ꠡꠝꠄ, ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠙꠤꠀꠟꠣ ꠕꠣꠇꠤ ꠀꠝꠞꠣ ꠎꠦ ꠡꠞꠛꠔ ꠈꠣꠁ, ꠁꠔꠣꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠃꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁ ꠘꠣ ꠘꠤ? ꠀꠞ ꠎꠦ ꠞꠥꠐꠤ ꠍꠤꠠꠤꠀ ꠈꠣꠁ, ꠁ ꠈꠣꠘꠤꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠘ ꠡꠞꠤꠟꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C110_17","076_10_17","1CO","10","17","17","ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠎꠦꠛꠟꠣ ꠄꠇ ꠞꠥꠐꠤ ꠛꠣꠐꠤꠀ ꠈꠣꠁ, ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠝꠞꠣ ꠛꠃꠔ ꠎꠘ ꠅꠁꠟꠦꠅ ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠄꠇ ꠡꠞꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("C110_18","076_10_18","1CO","10","18","18","ꠢꠥꠘꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠣꠟꠔ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠅ, ꠔꠣꠞꠣꠞ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠘ, ꠔꠣꠞꠣ ꠢꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠢꠇꠟ ꠇꠣꠝꠅ-ꠅ ꠡꠞꠤꠇ ꠅꠁꠎꠣꠁꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C110_19","076_10_19","1CO","10","19","19","ꠀꠞ ꠀꠝꠤ ꠇꠥꠘꠥ ꠇꠁꠞꠣꠝ ꠘꠤ, ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠞ ꠙꠡꠣꠖꠞꠦ ꠢꠤꠡꠣꠛꠅ ꠗꠞꠣ ꠎꠣꠄ, ꠛꠣ ꠅꠃ ꠖꠦꠛꠔꠣꠞꠦ ꠢꠤꠡꠣꠛꠅ ꠗꠞꠣ ꠎꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("C110_20","076_10_20","1CO","10","20","20","ꠘꠣ, ꠝꠥꠐꠦꠃ ꠘꠣ। ꠔꠣ-ꠅ ꠛꠤꠗꠞ꠆ꠝꠤ ꠅꠇꠟꠦ ꠎꠔ ꠘꠝꠥꠘꠣꠞ ꠛꠟꠤ ꠖꠦꠁꠘ, ꠁꠔꠣ ꠖꠦꠅ-ꠖꠣꠘꠛ, ꠜꠥꠔ-ꠙꠦꠞꠔꠞ ꠘꠣꠝꠦꠃ ꠖꠦꠁꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠘꠣꠄ। ꠔꠦ ꠀꠝꠤ ꠌꠣꠁ ꠘꠣ, ꠅꠃ ꠜꠥꠔ-ꠙꠦꠞꠔꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠈꠣꠔꠤꠞ-ꠖꠥꠡ꠆ꠔꠤ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C110_21","076_10_21","1CO","10","21","21","ꠢꠥꠘꠅ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠝꠦꠎꠛꠣꠘꠤ ꠀꠞ ꠜꠥꠔ-ꠙꠦꠞꠔꠞ ꠝꠦꠎꠛꠣꠘꠤ, ꠁ ꠖꠥꠁꠅ ꠇꠣꠝꠅ ꠡꠞꠤꠇ ꠅꠀ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠘꠣꠄ। ꠝꠣꠟꠤꠇꠞ ꠙꠤꠀꠟꠣ ꠀꠞ ꠜꠥꠔꠞ ꠙꠤꠀꠟꠣ, ꠖꠥꠁꠅꠔꠣ ꠕꠣꠇꠤ ꠄꠇꠟꠉꠦ ꠈꠣꠅꠀ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C110_22","076_10_22","1CO","10","22","22","ꠔꠦ ꠀꠝꠞꠣ ꠇꠤꠔꠣ ꠇꠞꠤꠀꠞ, ꠀꠝꠞꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠖꠤꠟꠅ ꠀꠉꠥꠁꠘ ꠟꠣꠉꠣꠁꠔꠣꠝ ꠘꠤ? ꠔꠣꠘ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠤꠀ ꠎꠤꠔꠔꠣꠝ ꠙꠣꠞꠝꠥ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C110_23","076_10_23","1CO","10","23","23","ꠝꠘꠅ ꠅꠞ ꠘꠤ, ꠀꠝꠤ ꠔ ꠀꠉꠦ ꠇꠁꠍꠤ, ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠇꠂꠘ, “ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠢꠣꠞꠣꠝ ꠘꠣꠄ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠎꠣꠁꠎ।” ꠅꠁꠟꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠦꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠃꠙꠇꠣꠞꠤ, ꠁꠟꠣ ꠌꠤꠘ꠆ꠔꠣ ꠔ ꠑꠤꠇ ꠘꠣꠄ। ꠎꠥꠖꠤꠅ ꠄꠞꠣ ꠇꠂꠘ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠢꠣꠟꠣꠟ, ꠅꠁꠟꠦ ꠢꠇꠟꠔꠣꠄ ꠔ ꠝꠣꠘꠡꠞ ꠁꠝꠣꠘ ꠛꠣꠠꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C110_24","076_10_24","1CO","10","24","24","ꠔꠦ ꠇꠥꠘꠥ ꠎꠘꠦꠃ ꠘꠤꠎꠞ ꠡ꠆ꠛꠣꠞꠕ ꠟꠁꠀ ꠙꠣꠉꠟ ꠅꠁꠅ ꠘꠣ, ꠛꠞꠋ ꠅꠁꠘ꠆ꠘꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("C110_25","076_10_25","1CO","10","25","25","ꠛꠣꠎꠣꠞ-ꠀꠐꠅ ꠎꠦꠇꠥꠘꠥ ꠉꠥꠡ꠆ꠔ ꠛꠤꠇꠤ ꠅꠁꠟꠦ ꠁꠔꠣ ꠈꠣꠁꠅ, ꠘꠤꠎꠞ ꠛꠤꠛꠦꠇꠞꠦ ꠡꠣꠘ꠆ꠔꠤ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠡꠘ꠆ꠖꠄ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C110_26","076_10_26","1CO","10","26","26","ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠦ ꠔ ꠇꠄ, “ꠁ ꠎꠉꠔ ꠀꠞ ꠎꠉꠔꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠝꠣꠛꠥꠖꠞ।” ");
INSERT INTO syls_vpl VALUES ("C110_27","076_10_27","1CO","10","27","27","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠛꠣꠁꠞꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠦꠁꠘ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠣꠁꠔꠣꠄ ꠌꠣꠅ, ꠔꠦ ꠛꠤꠛꠦꠇꠞꠦ ꠑꠣꠘ꠆ꠒꠣ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠡꠘ꠆ꠖꠄ ꠘꠣ ꠇꠞꠤꠀ ꠎꠦꠔꠣ ꠍꠣꠝꠘꠦ ꠖꠦꠁꠘ ꠅꠔꠣꠃ ꠈꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("C110_28","076_10_28","1CO","10","28","28","ꠅꠁꠟꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠦꠄ, ꠁ ꠈꠣꠘꠤ ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣꠞ ꠘꠣꠝꠞ ꠙꠡꠣꠖ, ꠔꠦ ꠎꠦ ꠎꠘꠦ ꠁꠈꠣꠘ ꠇꠁꠍꠦ, ꠔꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠀꠞ ꠛꠤꠛꠦꠇꠞ ꠀꠞꠣꠝꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠈꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C110_29","076_10_29","1CO","10","29","29","ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠛꠦꠇꠞ ꠇꠕꠣ ꠇꠁꠞꠣꠝ ꠘꠣ, ꠢꠃ ꠖꠥꠍꠞꠣ ꠝꠣꠘꠡꠞ ꠛꠤꠛꠦꠇꠞ ꠇꠕꠣ ꠇꠁꠞꠣꠝ। ꠇꠣꠞꠘ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠛꠤꠛꠦꠇ-ꠛꠤꠌꠣꠞꠦ, ꠀꠝꠣꠞ ꠁꠌ꠆ꠍꠣ-ꠅꠘꠤꠌ꠆ꠍꠣꠞ ꠡ꠆ꠛꠣꠗꠤꠘꠔꠣꠔ ꠇꠦꠘꠦ ꠘꠣꠇ ꠉꠟꠣꠁꠔ? ");
INSERT INTO syls_vpl VALUES ("C110_30","076_10_30","1CO","10","30","30","ꠀꠝꠤ ꠎꠥꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁ, ꠔꠦ ꠎꠦ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣꠝ, ꠅꠃ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠞ ꠛꠖꠘꠣꠝ ꠅꠁꠔ ꠇꠦꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("C110_31","076_10_31","1CO","10","31","31","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠇꠞ ꠛꠣ ꠎꠦꠔꠣꠃ ꠇꠞ ꠘꠣ ꠇꠦꠘꠦ, ꠢꠇꠟꠔꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛꠞ ꠘꠤꠅꠔꠦ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("C110_32","076_10_32","1CO","10","32","32","ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠛꠣ ꠜꠤꠘ ꠎꠣꠔꠤ, ꠛꠣ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠙꠕꠞ ꠇꠣꠐꠣ ꠛꠘꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C110_33","076_10_33","1CO","10","33","33","ꠀꠝꠤ ꠎꠦꠟꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ ꠞꠣꠈꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠇꠞꠤꠅ। ꠀꠝꠤ ꠔ ꠘꠤꠎꠞ ꠡ꠆ꠛꠣꠞꠕꠞ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ ꠘꠣ, ꠡꠛ ꠝꠣꠘꠡꠞ ꠜꠣꠟꠣꠁꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C111_1","076_11_1","1CO","11","1","1","ꠔꠦ ꠀꠝꠤ ꠎꠦꠟꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠈꠣꠘ ꠌꠟꠤꠀꠞ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("C111_2","076_11_2","1CO","11","2","2","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠔꠣꠟꠤꠝ ꠝꠘꠅ ꠞꠣꠈꠤꠀ ꠌꠟꠞꠣꠄ, ꠀꠞ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦꠃ ꠀꠝꠣꠞꠦ ꠁꠀꠖ ꠞꠣꠈꠞꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C111_3","076_11_3","1CO","11","3","3","ꠔꠦ ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠅꠈꠣꠘ ꠛꠥꠎ, ꠀꠟ-ꠝꠍꠤꠃ ꠅꠁꠟꠣ ꠢꠇꠟ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠕꠣ, ꠛꠦꠐꠣꠁꠘ ꠅꠁꠟꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠕꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠅꠁꠟꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠕꠣ। ");
INSERT INTO syls_vpl VALUES ("C111_4","076_11_4","1CO","11","4","4","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤꠞ ꠡꠝꠄ ꠎꠦ ꠛꠦꠐꠣꠄ ꠝꠣꠕꠣ ꠉꠥꠞꠤꠀ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠦ, ꠛꠣ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠦ, ꠢꠦ ꠔ ꠔꠣꠞ ꠝꠣꠕꠣꠞꠦ ꠅꠡꠝ꠆ꠝꠣꠘ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C111_5","076_11_5","1CO","11","5","5","ꠅꠟꠣꠈꠣꠘ ꠎꠦ ꠛꠦꠐꠤꠄ ꠝꠣꠕꠣ ꠘꠣ ꠉꠥꠞꠤꠀ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠦ, ꠛꠣ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠦ, ꠅꠃ ꠛꠦꠐꠤꠄꠅ ꠔꠣꠁꠞ ꠝꠣꠕꠣꠞ ꠅꠡꠝ꠆ꠝꠣꠘ ꠇꠞꠦ, ꠔꠣꠁ ꠝꠣꠕꠣ ꠇꠣꠝꠣꠁꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C111_6","076_11_6","1CO","11","6","6","ꠇꠥꠘꠥ ꠛꠦꠐꠤꠄ ꠎꠥꠖꠤ ꠝꠣꠕꠣ ꠘꠣ ꠉꠥꠞꠦ, ꠔꠦ ꠔꠣꠁꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠁꠟꠣꠃꠇ। ꠅꠁꠟꠦ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠌꠥꠟ ꠇꠣꠝꠣꠘꠤ ꠡꠞꠝꠞ ꠛꠤꠡꠄ ꠝꠘꠅ ꠅꠁꠟꠦ, ꠔꠣꠁꠞ ꠝꠣꠕꠣ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C111_7","076_11_7","1CO","11","7","7","ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤꠞ ꠡꠝꠄ ꠝꠣꠕꠣ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠣ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠘꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠍꠥꠞꠔꠦ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ ꠀꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠖꠤꠃ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠄ, ꠅꠁꠟꠦ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠝꠣꠎꠖꠤ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C111_8","076_11_8","1CO","11","8","8","ꠙꠄꠟꠣ ꠛꠦꠐꠣ ꠝꠣꠘꠥꠡ ꠛꠣꠛꠣ ꠀꠖꠝ ꠔ ꠛꠦꠐꠤ ꠕꠣꠇꠤ ꠙꠄꠖꠣ ꠅꠁꠍꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠙꠄꠟꠣ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠝꠣꠁ ꠢꠣꠅꠀ ꠘꠤꠌ꠆ꠌꠄ ꠛꠦꠐꠣ ꠕꠣꠇꠤꠃ ꠙꠄꠖꠣ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C111_9","076_11_9","1CO","11","9","9","ꠀꠞ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠣꠉꠤ ꠛꠦꠐꠣꠁꠘ ꠙꠄꠖꠣ ꠅꠁꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠉꠤꠃ ꠛꠦꠐꠤꠘ ꠙꠄꠖꠣ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C111_10","076_11_10","1CO","11","10","10","ꠅꠃ ꠔꠣꠟꠤꠝ ꠝꠣꠚꠤꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠇꠕꠣ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠀ, ꠔꠣꠛꠦꠖꠣꠞꠤ ꠝꠣꠘꠣꠞ ꠘꠤꠡꠣꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠢꠇꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠝꠣꠕꠣ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("C111_11","076_11_11","1CO","11","11","11","ꠔꠣ-ꠅ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠦ ꠊꠞꠞ ꠛꠦꠐꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠂꠘ, ꠀꠞ ꠛꠦꠐꠣꠄꠅ ꠅꠟꠣ ꠛꠦꠐꠤꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C111_12","076_11_12","1CO","11","12","12","ꠇꠣꠞꠘ, ꠙꠄꠟꠣ ꠛꠦꠐꠣ ꠀꠖꠝ ꠕꠣꠇꠤ ꠎꠥꠖꠤꠅ ꠙꠄꠟꠣ ꠛꠦꠐꠤ ꠝꠣꠁ ꠢꠣꠅꠀ ꠙꠄꠖꠣ, ꠔꠣ-ꠅ ꠛꠦꠐꠤꠘ ꠕꠣꠇꠤꠃ ꠢꠤꠞꠛꠣꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠎꠘꠝ ꠅꠄ। ꠀꠍꠟꠦ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠙꠄꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("C111_13","076_11_13","1CO","11","13","13","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠛꠤꠌꠣꠞ ꠇꠞꠤ ꠖꠦꠈꠅ, ꠝꠣꠕꠣꠔ ꠇꠣꠙꠠ ꠘꠣ ꠖꠤꠀ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠄ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠣ ꠑꠤꠇ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C111_14","076_11_14","1CO","11","14","14","ꠀꠞ ꠡꠝꠣꠎꠞ ꠢꠣꠟ-ꠌꠣꠟ ꠕꠣꠇꠤꠃ ꠔ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠕꠣꠔ ꠟꠣꠝ꠆ꠛꠣ ꠌꠥꠟ ꠞꠣꠈꠣ ꠡꠞꠝꠞ ꠛꠦꠙꠣꠞ, ");
INSERT INTO syls_vpl VALUES ("C111_15","076_11_15","1CO","11","15","15","ꠅꠁꠟꠦ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠟꠣꠝ꠆ꠛꠣ ꠌꠥꠟ ꠞꠣꠈꠟꠦ ꠔꠣꠞꠣꠞ ꠡꠥꠘꠣꠝ ꠛꠣꠠꠦ ꠘꠣ ꠘꠤ? ꠘꠤꠎꠞꠦ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤꠃ ꠔ ꠔꠣꠞꠣ ꠁ ꠟꠣꠝ꠆ꠛꠣ ꠌꠥꠟ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C111_16","076_11_16","1CO","11","16","16","ꠔꠦ ꠁꠔꠣ ꠟꠁꠀ ꠇꠦꠃ ꠔꠞ꠆ꠇ-ꠛꠤꠔꠞ꠆ꠇ ꠇꠞꠟꠦ, ꠀꠝꠣꠞ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠎꠥꠀꠙ ꠅꠁꠟ, ꠁꠔꠣ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠘꠤꠅꠝ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣꠁ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔꠞ ꠝꠣꠎꠦꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C111_17","076_11_17","1CO","11","17","17","ꠅꠈꠘ ꠀꠝꠤ ꠎꠦ ꠛꠦꠙꠣꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠁ ꠛꠦꠙꠣꠞꠦ ꠔ ꠔꠥꠝꠞꠣ ꠝꠥꠐꠦꠃ ꠔꠣꠞꠤꠚ ꠙꠣꠅꠀꠞ ꠎꠥꠇꠣ ꠘꠣꠄ। ꠔꠥꠝꠞꠣ ꠎꠝꠣꠔꠅ ꠎꠦꠟꠣ ꠡꠞꠤꠇ ꠅꠅ, ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠄ ꠘꠣ, ꠛꠞꠋ ꠈꠦꠔꠤ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C111_18","076_11_18","1CO","11","18","18","ꠀꠝꠤ ꠢꠥꠘꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠝꠣꠔꠅ ꠡꠞꠤꠇ ꠅꠅ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠖꠟꠣꠖꠟꠤ ꠕꠣꠇꠦ, ꠀꠞ ꠁꠔꠣ ꠇꠤꠍꠥ ꠀꠝꠤ ꠛꠤꠡ꠆ꠛꠣꠡꠅ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C111_19","076_11_19","1CO","11","19","19","ꠀꠍꠟꠦ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠝꠔꠞ ꠅꠝꠤꠟ ꠕꠣꠇꠛꠃ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠈꠣꠐꠤ ꠘꠤꠈꠥꠔ ꠝꠣꠘꠡꠞ ꠙꠞꠤꠌꠄ ꠝꠤꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("C111_20","076_11_20","1CO","11","20","20","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠄꠇꠈꠣꠘꠅ ꠝꠤꠟꠤꠀ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞ, ꠅꠃ ꠡꠝꠄ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠦꠎꠛꠣꠘꠤꠞ ꠘꠤꠅꠔꠦ ꠈꠣꠘꠤ ꠛꠤꠟꠣꠘꠤ ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C111_21","076_11_21","1CO","11","21","21","ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠘꠣ ꠇꠞꠤꠀꠃ ꠈꠣꠘꠤ ꠈꠣꠁꠟꠣꠅ। ꠔꠥꠝꠞꠣꠞ ꠄꠇꠎꠘꠞ ꠙꠦꠐꠅ ꠜꠥꠇ ꠕꠣꠇꠦ, ꠀꠞ ꠀꠞꠇ ꠎꠘ ꠈꠣꠁꠀ ꠐꠣꠟ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C111_22","076_11_22","1CO","11","22","22","ꠈꠣꠘꠣ-ꠙꠤꠘꠣ ꠈꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠊꠞ-ꠛꠣꠠꠤ ꠘꠣꠁ ꠘꠤ? ꠔꠥꠝꠞꠣ ꠁꠌ꠆ꠍꠣ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠞꠣꠄ ꠘꠤ? ꠀꠞ ꠎꠦꠞꠣꠞ ꠈꠣꠘꠤꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ, ꠔꠣꠞꠣꠞꠦ ꠡꠞꠝ ꠖꠤꠞꠣꠄ ꠘꠤ? ꠅꠈꠘ ꠀꠝꠤ ꠀꠞ ꠇꠤꠔꠣ ꠇꠁꠔꠣꠝ? ꠔꠥꠝꠞꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠔꠣꠝ ꠘꠤ? ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("C111_23","076_11_23","1CO","11","23","23","ꠀꠍꠟꠦ ꠀꠝꠤ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍꠤ, ꠅꠃ ꠔꠣꠟꠤꠝꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠍꠤ। ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠎꠦ ꠞꠣꠁꠔ ꠖꠥꠡꠝꠘꠞ ꠀꠔꠅ ꠗꠞꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠢꠃ ꠞꠣꠁꠔ ꠔꠣꠁꠘ ꠈꠣꠘꠤꠞ ꠞꠥꠐꠤ ꠀꠔꠅ ꠟꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("C111_24","076_11_24","1CO","11","24","24","ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠟꠣ, ꠛꠣꠖꠦ ꠅꠃ ꠞꠥꠐꠤ ꠐꠥꠇꠞꠣꠁꠀ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠔ ꠀꠝꠣꠞ ꠡꠞꠤꠟ, ꠅꠃ ꠡꠞꠤꠟ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠞ, ꠔꠦ ꠀꠝꠣꠞꠦ ꠝꠘꠅ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠅꠃꠟꠣ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("C111_25","076_11_25","1CO","11","25","25","ꠅꠟꠣ ꠈꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠡꠞꠛꠔꠞ ꠙꠤꠀꠟꠣ ꠟꠁꠀ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠟꠃꠞ ꠎꠞꠤꠀꠄ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠎꠦ ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠣꠁꠝ ꠅꠁꠛ, ꠅꠃ ꠙꠤꠀꠟꠣ ꠅꠁꠟ ꠄꠞ ꠘꠤꠡꠣꠘꠣ। ꠔꠥꠝꠞꠣ ꠅꠃ ꠙꠤꠀꠟꠣ ꠕꠣꠇꠤ ꠈꠣꠅꠀꠞ ꠡꠝꠄ ꠀꠝꠣꠞꠦ ꠁꠀꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠝꠦꠡꠣ ꠅꠟꠣ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("C111_26","076_11_26","1CO","11","26","26","ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠔꠛꠣꠞ ꠅꠃ ꠞꠥꠐꠤ ꠈꠣꠁꠛꠣꠄ ꠀꠞ ꠅꠃ ꠙꠤꠀꠟꠣꠞ ꠡꠞꠛꠔ ꠈꠣꠁꠛꠣꠄ, ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠢꠤꠞꠛꠣꠞ ꠘꠣ ꠀꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠔꠛꠣꠞꠃ ꠔꠣꠘ ꠝꠃꠔꠞ ꠇꠕꠣ ꠄꠟꠣꠘ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C111_27","076_11_27","1CO","11","27","27","ꠄꠞꠟꠣꠉꠤ ꠈꠣꠝ-ꠈꠦꠀꠟꠤ ꠇꠞꠤꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠁ ꠞꠥꠐꠤ ꠈꠣꠄ ꠀꠞ ꠙꠤꠀꠟꠣꠞ ꠡꠞꠛꠔ ꠈꠣꠄ, ꠔꠦ ꠢꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠡꠞꠤꠟ ꠀꠞ ꠟꠃꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠉꠥꠘꠣ ꠇꠞꠤꠀ ꠖꠥꠡꠤ ꠛꠘꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C111_28","076_11_28","1CO","11","28","28","ꠅꠃ ꠞꠥꠐꠤ ꠈꠣꠁꠛꠣꠞ ꠀꠉꠦ ꠀꠞ ꠙꠤꠀꠟꠣꠞ ꠡꠞꠛꠔ ꠈꠣꠁꠛꠣꠞ ꠀꠉꠦ, ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞꠦ ꠎꠣꠌꠣꠁ ꠇꠞꠤ ꠖꠦꠈꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C111_29","076_11_29","1CO","11","29","29","ꠇꠣꠞꠘ ꠁꠔꠣ ꠈꠣꠅꠀꠞ ꠡꠝꠄ ꠢꠦ ꠎꠥꠖꠤ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠡꠞꠤꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠘꠣ ꠛꠥꠎꠦ, ꠔꠦ ꠁꠔꠣ ꠈꠣꠁꠀ ꠢꠦ ꠘꠤꠎꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠒꠣꠇꠤꠀ ꠀꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("C111_30","076_11_30","1CO","11","30","30","ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠇꠝꠎꠥꠞ ꠀꠞ ꠛꠦꠝꠣꠞꠤ ꠀꠍꠂꠘ, ꠄꠝꠘꠇꠤ ꠇꠦꠃ ꠇꠦꠃ ꠝꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C111_31","076_11_31","1CO","11","31","31","ꠀꠝꠞꠣ ꠘꠤꠎꠞ ꠛꠤꠌꠣꠞ ꠘꠤꠎꠦ ꠇꠞꠤꠟ꠆ꠟꠦ, ꠝꠣꠟꠤꠇꠞ ꠀꠔꠞ ꠛꠤꠌꠣꠞ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C111_32","076_11_32","1CO","11","32","32","ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇꠦ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠡꠘ ꠇꠞꠂꠘ, ꠎꠣꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟꠞ ꠟꠉꠦ ꠀꠈꠦꠞꠣꠔꠞ ꠖꠤꠘ ꠀꠝꠞꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C111_33","076_11_33","1CO","11","33","33","ꠄꠞꠟꠣꠉꠤ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠝꠦꠎꠛꠣꠘꠤ ꠈꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠅ, ꠅꠃ ꠡꠝꠄ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("C111_34","076_11_34","1CO","11","34","34","ꠄꠇꠎꠘꠞ ꠎꠥꠖꠤ ꠙꠦꠐꠅ ꠜꠥꠇ ꠟꠣꠉꠤꠎꠣꠄ, ꠔꠦ ꠢꠦ ꠛꠣꠠꠤ ꠕꠣꠇꠤ ꠈꠣꠁꠀ ꠀꠃꠇ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠄꠇꠈꠣꠘꠅ ꠅꠀꠄ ꠇꠥꠘꠥ ꠡꠣꠎꠣ ꠘꠣ ꠙꠣꠅ। ꠔꠦ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠛꠦꠙꠣꠞꠦ ꠘꠍꠤꠅꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C112_1","076_12_1","1CO","12","1","1","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠖꠣꠘ-ꠘꠤꠀꠝꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠅꠎꠣꠘꠣ ꠘꠣ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C112_2","076_12_2","1CO","12","2","2","ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠀꠉꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠔꠣꠄ ꠘꠣ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠟꠣꠈꠣꠘ ꠖꠦꠛ-ꠖꠦꠛꠤꠞ ꠛꠣꠄ ꠐꠣꠘꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠔ, ꠎꠦꠔꠣꠄ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠤꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C112_3","076_12_3","1CO","12","3","3","ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠝꠣꠔꠤꠟꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠁꠈꠣꠘ ꠇꠄ ꠘꠣ, “ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠃꠇ।” ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟ ꠍꠣꠠꠣ ꠇꠦꠃ ꠇꠁꠔ-ꠅ ꠙꠣꠞꠦ ꠘꠣ, “ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠝꠣꠟꠤꠇ।” ");
INSERT INTO syls_vpl VALUES ("C112_4","076_12_4","1CO","12","4","4","ꠅꠃ ꠄꠇꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠖꠣꠘ-ꠘꠤꠀꠝꠔ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C112_5","076_12_5","1CO","12","5","5","ꠀꠝꠞꠣ ꠘꠣꠘꠣꠘ ꠘꠤꠅꠝꠦ ꠄꠇꠁ ꠝꠣꠟꠤꠇꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C112_6","076_12_6","1CO","12","6","6","ꠀꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠞꠦ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠄꠇꠎꠘꠃ, ꠔꠣꠁꠘ ꠘꠣꠘꠣꠘ ꠃꠙꠣꠄꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠣꠝ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C112_7","076_12_7","1CO","12","7","7","ꠢꠇꠟꠞ ꠚꠣꠄꠖꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠙꠣꠇ ꠞꠥꠢꠥ ꠄꠇꠅ ꠎꠘꠞ ꠝꠣꠎꠦ ꠄꠇꠅ ꠘꠝꠥꠘꠣꠄ ꠎꠣꠁꠞ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C112_8","076_12_8","1CO","12","8","8","ꠅꠃ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠞꠦ ꠉꠤꠀꠘ-ꠛꠥꠖ꠆ꠖꠤꠞ ꠝꠣꠔ ꠝꠣꠔꠣ, ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠀꠈꠟꠖꠣꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠣꠞ ꠘꠤꠀꠝꠔ ꠖꠦꠅꠀ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C112_9","076_12_9","1CO","12","9","9","ꠄꠇꠎꠘꠦ ꠅꠃ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠉꠣꠁꠛꠤ ꠜꠞꠡꠣ ꠙꠣꠁꠘ, ꠀꠞ ꠅꠃ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠖꠥꠍꠞꠣ ꠎꠘꠦ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠘ, ");
INSERT INTO syls_vpl VALUES ("C112_10","076_12_10","1CO","12","10","10","ꠇꠦꠃ ꠇꠦꠃ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ, ꠇꠦꠃ ꠇꠦꠃ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠣꠞ ꠈꠦꠝꠔꠣ, ꠇꠦꠃ ꠇꠦꠃ ꠛꠣꠖ-ꠜꠣꠟꠣ ꠞꠥꠢꠥ ꠅꠇꠟ ꠀꠞ ꠎꠤꠘ-ꠜꠥꠔꠞꠦ ꠌꠤꠘꠣꠞ ꠈꠦꠝꠔꠣ, ꠇꠦꠃ ꠇꠦꠃ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠣꠞ ꠈꠦꠝꠔꠣ ꠀꠞ ꠇꠦꠃ ꠇꠦꠃ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠣꠁꠀ ꠖꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C112_11","076_12_11","1CO","12","11","11","ꠁꠔꠣ ꠢꠇꠟ ꠇꠣꠝ ꠔ ꠅꠃ ꠄꠇꠁ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠞꠂꠘ। ꠅꠃ ꠖꠣꠘ-ꠘꠤꠀꠝꠔ ꠅꠇꠟ ꠔꠣꠘ ꠘꠤꠎꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠙꠞꠔꠦꠇ ꠝꠥꠝꠤꠘꠞꠦ ꠛꠣꠐꠤꠀ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C112_12","076_12_12","1CO","12","12","12","ꠅ ꠜꠣꠁꠀꠁꠘ ꠅꠇꠟ, ꠄꠇ ꠡꠞꠤꠟꠞ ꠎꠦꠟꠣ ꠛꠃꠔ ꠅꠋꠉ ꠕꠣꠇꠦ, ꠅꠟꠣ ꠛꠃꠔ ꠅꠋꠉ ꠝꠤꠟꠤꠀ ꠄꠇ ꠡꠞꠤꠟ ꠅꠄ, ꠀꠟ-ꠝꠍꠤꠅ ꠔ ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("C112_13","076_12_13","1CO","12","13","13","ꠀꠝꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠁ ꠛꠣ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠁ, ꠀꠎꠣꠖ ꠛꠣ ꠉꠥꠟꠣꠝ ꠅꠁ, ꠅꠃ ꠄꠇꠁ ꠙꠣꠇ ꠞꠥꠢꠦ ꠢꠇꠟꠞ ꠔꠞꠤꠇꠣꠛꠘ꠆ꠖꠤ ꠅꠁꠍꠦ ꠄꠇ ꠡꠞꠤꠟ ꠅꠀꠞ ꠟꠣꠉꠤ। ꠢꠇꠟꠦꠃ ꠔ ꠅꠃ ꠄꠇꠁ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C112_14","076_12_14","1CO","12","14","14","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠡꠞꠤꠟꠞꠦ ꠈꠣꠟꠤ ꠄꠇ ꠅꠋꠉ ꠖꠤꠀ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠛꠃꠔ ꠅꠋꠉ ꠎꠥꠠꠣ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C112_15","076_12_15","1CO","12","15","15","ꠅꠈꠘ ꠙꠣꠅꠄ ꠎꠥꠖꠤ ꠇꠄ, “ꠀꠝꠣꠞ ꠘꠣꠝ ꠔ ꠀꠔ ꠘꠣꠄ, ꠔꠦ ꠀꠝꠤ ꠡꠞꠤꠟꠞ ꠅꠋꠉ-ꠅ ꠘꠣꠄ,” ꠄꠞꠟꠣꠉꠤ ꠙꠣꠅ ꠎꠦꠘ ꠡꠞꠤꠟꠞ ꠅꠋꠉ ꠘꠣꠄ, ꠁꠈꠣꠘ ꠔ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C112_16","076_12_16","1CO","12","16","16","ꠅꠃꠟꠣ ꠇꠣꠘꠦ ꠎꠥꠖꠤ ꠇꠄ, “ꠀꠝꠣꠞ ꠘꠣꠝ ꠔ ꠌꠃꠈ ꠘꠣꠄ, ꠔꠦ ꠀꠝꠤ ꠡꠞꠤꠟꠞ ꠅꠋꠉ-ꠅ ꠘꠣꠄ,” ꠄꠞꠟꠣꠉꠤ ꠇꠣꠘ ꠎꠦꠘ ꠡꠞꠤꠟꠞ ꠅꠋꠉ ꠘꠣꠄ, ꠁꠈꠣꠘ ꠔ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C112_17","076_12_17","1CO","12","17","17","ꠝꠣꠘꠡꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠃ ꠎꠥꠖꠤ ꠌꠃꠈ ꠅꠁꠎꠤꠔ, ꠔꠦ ꠢꠥꠘꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠇꠁ ꠙꠣꠁꠟ ꠅꠘꠦ? ꠀꠞ ꠎꠥꠖꠤ ꠡꠣꠞꠣ ꠡꠞꠤꠟꠃ ꠇꠣꠘ ꠅꠁꠎꠤꠔ, ꠔꠦ ꠊꠦꠞꠣꠘ ꠢꠥꠋꠉꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠇꠁ ꠞꠁꠟ ꠅꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("C112_18","076_12_18","1CO","12","18","18","ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠈꠤꠀꠟ-ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠡꠞꠤꠟꠞ ꠘꠣꠘꠣꠘ ꠅꠋꠉꠞꠦ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C112_19","076_12_19","1CO","12","19","19","ꠢꠇꠟ ꠅꠋꠉ ꠎꠥꠖꠤ ꠄꠇꠟꠣꠈꠣꠘ ꠅꠁꠎꠤꠔ, ꠔꠣꠁꠟꠦ ꠡꠞꠤꠟꠞ ꠇꠥꠘ ꠢꠣꠟꠔ ꠅꠁꠟ ꠅꠘꠦ? ");
INSERT INTO syls_vpl VALUES ("C112_20","076_12_20","1CO","12","20","20","ꠡꠞꠤꠟꠅ ꠛꠃꠔ ꠅꠋꠉ ꠀꠍꠦ, ꠔꠣ-ꠅ ꠡꠞꠤꠟ ꠔ ꠄꠇꠐꠣꠃ। ");
INSERT INTO syls_vpl VALUES ("C112_21","076_12_21","1CO","12","21","21","ꠌꠃꠈꠦ ꠀꠔꠞꠦ ꠇꠁꠔ ꠙꠣꠞꠦ ꠘꠣ, “ꠔꠥꠝꠣꠞꠦ ꠀꠝꠣꠞ ꠖꠞꠇꠣꠞ ꠘꠣꠁ,” ꠀꠞ ꠝꠣꠕꠣꠄ ꠖꠥꠁꠅ ꠙꠣꠅꠞꠦ ꠇꠁꠔ ꠙꠣꠞꠦ ꠘꠣ, “ꠔꠥꠝꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠖꠞꠇꠣꠞ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("C112_22","076_12_22","1CO","12","22","22","ꠀꠍꠟꠦ ꠡꠞꠤꠟꠞ ꠎꠦ ꠅꠋꠉꠞꠦ ꠇꠝꠎꠥꠞ ꠝꠘꠅ ꠅꠄ, ꠅꠉꠥꠁꠘꠃ ꠛꠦꠡꠤ ꠖꠞꠇꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C112_23","076_12_23","1CO","12","23","23","ꠡꠞꠤꠟꠞ ꠎꠦ ꠡꠞꠝꠞ ꠅꠋꠉꠞꠦ ꠀꠝꠞꠣ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠝꠘꠅ ꠇꠞꠤ, ꠁꠐꠣꠞꠦ ꠀꠝꠞꠣ ꠛꠦꠡꠤ ꠖꠣꠝ ꠖꠦꠁ, ꠝꠣꠘꠤ ꠎꠦ ꠅꠋꠉꠞꠦ ꠛꠣꠞꠦ ꠖꠦꠈꠣꠘꠤ ꠎꠣꠄ ꠘꠣ, ꠁꠔꠣꠞꠦ ꠀꠝꠞꠣ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠀ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠤ। ");
INSERT INTO syls_vpl VALUES ("C112_24","076_12_24","1CO","12","24","24","ꠅꠁꠟꠦ ꠎꠦ ꠅꠋꠉꠞꠦ ꠛꠣꠞꠦ ꠖꠦꠈꠣꠘꠤ ꠎꠣꠄ, ꠁꠔꠣꠞꠦ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠣꠞ ꠖꠞꠇꠣꠞ ꠅꠄ ꠘꠣ। ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠀꠞ ꠇꠝꠎꠥꠞ ꠅꠋꠉꠞꠦ ꠛꠦꠡꠤ ꠁꠎ꠆ꠎꠔ ꠖꠤꠀ, ꠢꠇꠟ ꠅꠋꠉꠞꠦ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠁꠀ ꠄꠇ ꠡꠞꠤꠟ ꠛꠣꠘꠣꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("C112_25","076_12_25","1CO","12","25","25","ꠎꠣꠔꠦ ꠡꠞꠤꠟ ꠜꠣꠉꠣꠜꠣꠉꠤ ꠘꠣ ꠅꠄ, ꠛꠞꠋ ꠄꠇ ꠅꠋꠉꠄ ꠀꠞꠇ ꠅꠋꠉꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C112_26","076_12_26","1CO","12","26","26","ꠡꠞꠤꠟꠞ ꠄꠇ ꠅꠋꠉꠞ ꠎꠥꠖꠤ ꠇꠡ꠆ꠐ ꠅꠄ, ꠔꠦ ꠡꠣꠞꠣ ꠡꠞꠤꠟꠦ ꠇꠡ꠆ꠐ ꠙꠣꠄ, ꠀꠞ ꠄꠇ ꠅꠋꠉꠦ ꠁꠎ꠆ꠎꠔ ꠙꠣꠁꠟꠦ, ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C112_27","076_12_27","1CO","12","27","27","ꠔꠦ ꠔꠥꠝꠞꠣꠃ ꠅꠁꠟꠣꠄ ꠀꠟ-ꠝꠍꠤꠞ ꠡꠞꠤꠟ, ꠔꠥꠝꠞꠣ ꠄꠇꠅ ꠎꠘ ꠅꠃ ꠡꠞꠤꠟꠞ ꠄꠇꠅ ꠅꠋꠉ। ");
INSERT INTO syls_vpl VALUES ("C112_28","076_12_28","1CO","12","28","28","ꠎꠣꠘ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠎꠝꠣꠔꠞ ꠜꠤꠔꠞꠦ ꠙꠄꠟꠣ ꠍꠣꠢꠣꠛꠤ, ꠛꠣꠖꠦ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔ ꠝꠣꠔꠞꠣ, ꠛꠣꠖꠦ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ। ꠄꠞꠛꠣꠖꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ ꠎꠦꠞꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠞꠣ, ꠛꠦꠝꠣꠞ ꠜꠣꠟꠣ ꠇꠞꠞꠣ, ꠡꠣꠁꠎ꠆ꠎ-ꠡꠢꠣꠄꠅꠔꠣ ꠇꠞꠞꠣ, ꠁꠍꠣꠄꠁ ꠎꠝꠣꠔꠞꠦ ꠌꠣꠟꠣꠅꠞꠣ ꠀꠞ ꠘꠣꠘꠣꠘ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠞꠣ ꠎꠘ। ");
INSERT INTO syls_vpl VALUES ("C112_29","076_12_29","1CO","12","29","29","ꠔꠦ ꠄꠞꠣ ꠢꠇꠟꠦꠃ ꠇꠥꠘꠥ ꠍꠣꠢꠣꠛꠤ ꠙꠖ ꠙꠣꠁꠍꠂꠘ ꠘꠤ? ꠢꠇꠟꠦꠃ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠂꠘ ꠘꠤ? ꠢꠇꠟꠃ ꠃꠡ꠆ꠔꠣꠖ ꠘꠤ? ꠀꠞ ꠢꠇꠟꠦ ꠇꠥꠘꠥ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠍꠂꠘ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C112_30","076_12_30","1CO","12","30","30","ꠢꠇꠟꠦ ꠇꠥꠘꠥ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ ꠘꠤ? ꠢꠇꠟꠦꠃ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠂꠘ ꠘꠤ? ꠢꠇꠟꠦꠃ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠣꠁꠀ ꠖꠤꠔꠣ ꠙꠣꠞꠂꠘ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C112_31","076_12_31","1CO","12","31","31","ꠔꠣ-ꠅ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠕꠣꠇꠤ ꠖꠣꠝꠤ ꠘꠤꠀꠝꠔ ꠅꠇꠟ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠡꠤꠇ ꠅꠅ। ꠀꠞ ꠈꠤꠀꠟ ꠇꠞꠅ, ꠅꠈꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞꠅ ꠜꠣꠟꠣ ꠄꠇꠈꠣꠘ ꠙꠕ ꠖꠦꠈꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C113_1","076_13_1","1CO","13","1","1","ꠀꠝꠤ ꠎꠥꠖꠤ ꠎꠉꠔꠞ ꠝꠣꠘꠥꠡ ꠛꠣ ꠀꠍꠝꠣꠘꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠤ, ꠀꠞ ꠀꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠇꠥꠘꠥ ꠝꠢꠛ꠆ꠛꠔ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠔ ꠀꠝꠤ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠛꠣꠎꠣꠁꠟ ꠙꠤꠔꠟꠞ ꠊꠘ꠆ꠐꠤ ꠛꠣ ꠏꠘꠏꠘ ꠇꠞꠣ ꠇꠞꠔꠣꠟꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C113_2","076_13_2","1CO","13","2","2","ꠀꠝꠣꠞ ꠎꠥꠖꠤ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠕꠣꠇꠦ, ꠢꠇꠟ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞ ꠛꠥꠎꠤ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤꠄ ꠇꠣꠝꠤꠟ ꠅꠁ, ꠀꠞ ꠀꠝꠣꠞ ꠁꠝꠣꠘꠤ ꠛꠟꠖꠤ ꠃꠌꠣ ꠙꠣꠠꠅꠞꠦꠅ ꠄꠇ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠎꠣꠉꠣꠔ ꠢꠞꠣꠁꠟꠤꠔꠣꠝ ꠙꠣꠞꠤ, ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠖꠤꠟꠅ ꠇꠥꠘꠥ ꠝꠢꠛ꠆ꠛꠔ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠀꠝꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C113_3","076_13_3","1CO","13","3","3","ꠀꠝꠣꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠎꠥꠖꠤ ꠉꠞꠤꠛ-ꠖꠥꠈꠤꠞꠦ ꠛꠤꠟꠣꠁ ꠖꠦꠁ, ꠄꠝꠘꠇꠤ ꠀꠝꠣꠞ ꠡꠞꠤꠟꠞꠦꠅ ꠎꠥꠖꠤ ꠎꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠣꠘ ꠇꠞꠤꠟꠣꠁ, ꠀꠞ ꠀꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠎꠥꠖꠤ ꠝꠢꠛ꠆ꠛꠔ ꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C113_4","076_13_4","1CO","13","4","4","ꠝꠢꠛ꠆ꠛꠔ ꠢꠇꠟ ꠡꠝꠄ ꠍꠛꠞ ꠇꠞꠦ, ꠖꠄꠀ-ꠝꠣꠄꠀ ꠇꠞꠦ, ꠁꠋꠡꠣ ꠇꠞꠦ ꠘꠣ, ꠛꠠꠣꠁ ꠇꠞꠦ ꠘꠣ, ꠅꠢꠋꠇꠣꠞ ꠇꠞꠦ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("C113_5","076_13_5","1CO","13","5","5","ꠛꠣꠖ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠦ ꠘꠣ, ꠘꠤꠎꠞ ꠡ꠆ꠛꠣꠞꠕꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠦ ꠘꠣ, ꠞꠣꠉ-ꠉꠥꠍꠣ ꠇꠞꠦ ꠘꠣ, ꠇꠦꠃ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠇꠞꠟꠦ ꠝꠘꠅ ꠞꠣꠈꠦ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("C113_6","076_13_6","1CO","13","6","6","ꠘꠣꠚꠞꠝꠣꠘꠤꠔ ꠈꠥꠡꠤ ꠅꠄ ꠘꠣ, ꠛꠞꠋ ꠢꠇꠤꠇꠔꠤꠄ ꠈꠥꠡꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C113_7","076_13_7","1CO","13","7","7","ꠝꠢꠛ꠆ꠛꠔꠦ ꠢꠇ꠆ꠇꠟꠔꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠦ, ꠢꠇꠟꠔꠣ ꠛꠤꠡ꠆ꠛꠣꠡ ꠇꠞꠦ, ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠝꠘꠞ ꠝꠣꠎꠦ ꠀꠡꠣ ꠎꠥꠉꠣꠄ ꠀꠞ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠍꠛꠞ ꠇꠞꠤꠀ ꠗꠂꠎ꠆ꠎ ꠗꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C113_8","076_13_8","1CO","13","8","8","ꠢꠥꠘꠅ, ꠢꠇꠟ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔ ꠄꠇꠖꠤꠘ ꠚꠥꠠꠣꠁꠎꠤꠛ, ꠘꠣꠘꠣꠘ ꠜꠣꠡꠣꠅ ꠡꠦꠡ ꠅꠁꠎꠤꠛ ꠀꠞ ꠀꠈꠟꠖꠣꠞꠞ ꠀꠈꠟꠅ ꠚꠥꠠꠣꠁꠎꠤꠛ, ꠅꠁꠟꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠥꠘꠥ ꠡꠝꠄ ꠚꠥꠠꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C113_9","076_13_9","1CO","13","9","9","ꠔꠦ ꠅꠈꠘ ꠀꠝꠞꠣ ꠔ ꠇꠥꠘꠥꠔꠣꠃ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠎꠣꠘꠤ ꠘꠣ, ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠅ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠇꠁꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C113_10","076_13_10","1CO","13","10","10","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠅꠀꠞ ꠡꠝꠄ ꠎꠦꠛꠟꠣ ꠀꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠜꠣꠋꠉꠣ-ꠌꠥꠞꠣ ꠢꠇꠟꠔꠣ ꠚꠥꠠꠣꠁꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("C113_11","076_13_11","1CO","13","11","11","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠢꠥꠞꠥ ꠀꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠔꠤꠔꠣꠝ, ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠇꠞꠔꠣꠝ, ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠛꠤꠌꠣꠞ-ꠛꠤꠛꠦꠌꠘꠣ ꠇꠞꠔꠣꠝ। ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠛꠠ ꠅꠁꠉꠦꠍꠤ, ꠄꠞꠟꠣꠉꠤ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠌꠣꠞ-ꠛꠦꠛꠢꠣꠞ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C113_12","076_13_12","1CO","13","12","12","ꠅꠈꠘ ꠔ ꠀꠝꠞꠣ ꠏꠣꠙꠡꠣ ꠀꠄꠘꠣꠞ ꠝꠣꠎꠦ ꠢꠇꠟꠔꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠖꠦꠈꠞꠣꠝ ꠘꠣ, ꠛꠣꠖꠦ ꠢꠃ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠅꠀꠞ ꠡꠝꠄ ꠀꠁꠟꠦ ꠀꠝꠞꠣ ꠢꠇꠟꠔꠣ ꠍꠣꠝꠘꠣ-ꠍꠣꠝꠘꠤ ꠖꠦꠈꠝꠥ। ꠅꠈꠘ ꠀꠝꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠣꠘꠤ ꠘꠣ, ꠢꠃ ꠡꠝꠄ ꠀꠁꠟꠦ ꠀꠝꠤ ꠢꠇꠟꠔꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠣꠘꠝꠥ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠘꠂꠘ, ꠅꠟꠣ ꠀꠝꠤꠅ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C113_13","076_13_13","1CO","13","13","13","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠁꠝꠣꠘ, ꠀꠡꠣ, ꠀꠞ ꠝꠢꠛ꠆ꠛꠔ, ꠅꠃ ꠔꠤꠘꠅ ꠗꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠞꠁꠛ, ꠁꠔꠣꠞ ꠝꠣꠎꠦ ꠝꠢꠛ꠆ꠛꠔꠃ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ। ");
INSERT INTO syls_vpl VALUES ("C114_1","076_14_1","1CO","14","1","1","ꠄꠞꠟꠣꠉꠤ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠅ ꠝꠢꠛ꠆ꠛꠔꠞ ꠟꠣꠉꠤ ꠀꠡꠤꠇ ꠅꠅ, ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠖꠦꠅꠀ ꠖꠣꠘ-ꠘꠤꠀꠝꠔꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟꠤ ꠅꠅ, ꠈꠣꠍ ꠇꠞꠤ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠔꠦ ꠈꠤꠀꠟꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("C114_2","076_14_2","1CO","14","2","2","ꠇꠣꠞꠘ ꠎꠦ ꠝꠣꠘꠡꠦ ꠉꠣꠁꠛꠤ ꠇꠥꠘꠥ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠦ, ꠢꠦ ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠣꠔꠦꠞ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦꠃ ꠝꠣꠔꠦꠞ। ꠔꠣꠞ ꠝꠣꠔꠞ ꠜꠣꠡꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠦ ꠘꠣ, ꠢꠦ ꠈꠣꠟꠤ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠛꠣꠔꠥꠘꠤ ꠛꠥꠟꠤ ꠇꠄ। ");
INSERT INTO syls_vpl VALUES ("C114_3","076_14_3","1CO","14","3","3","ꠅꠁꠟꠦ ꠎꠦꠁꠘ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠂꠘ, ꠄꠁꠘ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦꠃ ꠝꠣꠔꠂꠘ, ꠄꠘ ꠝꠣꠔꠦ ꠝꠣꠘꠡꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠦ, ꠝꠣꠘꠡꠞ ꠖꠤꠟꠅ ꠀꠡꠣ ꠀꠞ ꠡꠣꠘ꠆ꠔꠘꠣ ꠎꠥꠉꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C114_4","076_14_4","1CO","14","4","4","ꠔꠦ ꠎꠦ ꠎꠘꠦ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠦ, ꠢꠦ ꠈꠣꠟꠤ ꠘꠤꠎꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠦ, ꠅꠁꠟꠦ ꠎꠦꠁꠘ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠂꠘ, ꠄꠁꠘ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C114_5","076_14_5","1CO","14","5","5","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠅ, ꠅꠁꠟꠦ ꠀꠞꠅ ꠛꠦꠡꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔ ꠝꠣꠔꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠦ, ꠀꠞ ꠝꠣꠔꠞ ꠛꠣꠖꠦ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠣꠁꠀ ꠘꠣ ꠖꠦꠄ, ꠔꠦ ꠢꠃ ꠎꠦꠁꠘ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠂꠘ ꠄꠁꠘꠃ ꠛꠠ। ");
INSERT INTO syls_vpl VALUES ("C114_6","076_14_6","1CO","14","6","6","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠈꠣꠟꠤ ꠉꠣꠁꠛꠤ ꠇꠥꠘꠥ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠤ, ꠅꠁꠟꠦ ꠄꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠝꠥꠘꠡꠣꠞ ꠇꠕꠣ, ꠀꠈꠟ-ꠢꠦꠇꠝꠔꠞ ꠇꠕꠣ, ꠙꠤꠞꠣꠇꠤ ꠇꠥꠘꠥ ꠝꠣꠔ ꠛꠣ ꠇꠤꠔꠣꠛꠤ ꠘꠍꠤꠅꠔ ꠘꠣ ꠎꠣꠘꠣꠁ, ꠔꠦ ꠀꠝꠣꠞꠦꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠛ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C114_7","076_14_7","1CO","14","7","7","ꠝꠘꠦ ꠇꠞꠅ, ꠛꠣꠡꠤ, ꠡꠣꠞꠤꠘ꠆ꠖꠣ, ꠀꠞ ꠎꠦꠔꠣ ꠛꠣꠁꠖ꠆ꠖ-ꠛꠣꠎꠘꠣꠞ ꠜꠤꠔꠞꠦ ꠇꠥꠘꠥ ꠎꠣꠘ ꠘꠣꠁ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠉꠣꠘꠞ ꠡꠑꠤꠇ ꠡꠥꠞ-ꠔꠣꠟ ꠘꠣ ꠝꠣꠘꠤꠀ ꠛꠣꠎꠦ, ꠔꠦ ꠅꠃ ꠛꠣꠎꠘꠣꠔ ꠇꠤꠔꠣ ꠛꠣꠎꠦꠞ, ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠇꠦꠝꠘꠦ ꠛꠥꠎꠛ? ");
INSERT INTO syls_vpl VALUES ("C114_8","076_14_8","1CO","14","8","8","ꠎꠥꠖ꠆ꠖꠔ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠚꠃꠎꠤ ꠡꠤꠋꠉꠣꠄ ꠎꠥꠖꠤ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠀꠅꠀꠎ ꠘꠣ ꠖꠦꠄ, ꠔꠦ ꠇꠥꠘꠥ ꠍꠤꠙꠣꠁ ꠞꠦꠒꠤ ꠅꠁꠛ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C114_9","076_14_9","1CO","14","9","9","ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠤ ꠎꠦꠛꠟꠣ ꠅꠎꠣꠘꠣ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠅ, ꠔꠦ ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠇꠁꠞꠣꠄ, ꠔꠣꠞꠣ ꠇꠦꠝꠘꠦ ꠛꠥꠎꠛ? ꠔꠥꠝꠣꠞ ꠁ ꠝꠣꠔ ꠈꠣꠟꠤ ꠛꠣꠔꠣꠡꠞ ꠟꠉꠦ ꠝꠣꠔꠞꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C114_10","076_14_10","1CO","14","10","10","ꠁ ꠖꠥꠘꠤꠀꠔ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠞ ꠛꠥꠟꠤ ꠀꠍꠦ, ꠁꠔꠣ ꠇꠥꠘꠥꠐꠣꠃ ꠝꠣꠘꠤ ꠍꠣꠠꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C114_11","076_14_11","1CO","14","11","11","ꠀꠞ ꠀꠝꠤ ꠎꠥꠖꠤ ꠅꠃ ꠛꠥꠟꠤ ꠘꠣ ꠛꠥꠎꠤ, ꠔꠦ ꠎꠦ ꠎꠘꠦ ꠝꠣꠔꠤꠞꠣ, ꠔꠣꠘ ꠉꠦꠍꠦ ꠔ ꠀꠝꠤ ꠛꠤꠖꠦꠡꠤ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ, ꠀꠞ ꠔꠣꠁꠘꠅ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠛꠤꠖꠦꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("C114_12","076_14_12","1CO","14","12","12","ꠁꠈꠣꠘ ꠔ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠟꠣꠄꠅ ꠑꠤꠇ। ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠖꠦꠅꠀ ꠖꠣꠘ-ꠘꠤꠀꠝꠔꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟꠤ ꠅꠁꠞꠣꠄ, ꠔꠦ ꠎꠦ ꠘꠤꠀꠝꠔ ꠖꠤꠀ ꠎꠝꠣꠔꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣ ꠎꠣꠄ, ꠅꠃ ꠘꠤꠀꠝꠔ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤꠃ ꠛꠦꠡꠤ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("C114_13","076_14_13","1CO","14","13","13","ꠄꠞꠟꠣꠉꠤ ꠎꠦ ꠝꠣꠘꠡꠦ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠦ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠋꠉꠃꠇ, ꠎꠣꠔꠦ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠣꠁꠀ ꠖꠤꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C114_14","076_14_14","1CO","14","14","14","ꠀꠝꠤ ꠎꠥꠖꠤ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠖꠥꠀ ꠇꠞꠤ, ꠔꠦ ꠀꠍꠟꠦ ꠀꠝꠣꠞ ꠞꠥꠢꠦ ꠖꠥꠀ ꠇꠞꠦꠞ, ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠝꠘꠦ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠦꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C114_15","076_14_15","1CO","14","15","15","ꠅꠈꠘ ꠀꠝꠤ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ? ꠀꠝꠤ ꠞꠥꠢꠥ ꠖꠤꠀ ꠖꠥꠀ ꠇꠞꠔꠣꠝ, ꠀꠞ ꠛꠥꠖ꠆ꠖꠤ ꠖꠤꠀꠅ ꠇꠞꠔꠣꠝ। ꠀꠝꠤ ꠞꠥꠢꠥ ꠖꠤꠀ ꠉꠤꠔ-ꠉꠎꠟ ꠉꠣꠁꠝꠥ, ꠛꠥꠖ꠆ꠖꠤ ꠖꠤꠀꠅ ꠉꠤꠔ-ꠉꠎꠟ ꠉꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C114_16","076_14_16","1CO","14","16","16","ꠀꠞ ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠞꠥꠢꠥ ꠖꠤꠀ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞ, ꠔꠦ ꠝꠎꠟꠤꠍꠞ ꠝꠣꠘꠡꠦ ꠇꠤꠟꠣ ꠀꠝꠤꠘ ꠇꠁꠔ? ꠔꠣꠞꠣ ꠔ ꠛꠥꠎꠦꠞꠃ ꠘꠣ ꠔꠥꠝꠤ ꠇꠤꠔꠣ ꠇꠁꠞꠣꠄ, ꠔꠣꠞꠣ ꠔ ꠅꠌꠤꠘꠣ ꠎꠘꠞ ꠟꠣꠈꠣꠘ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C114_17","076_14_17","1CO","14","17","17","ꠔꠥꠝꠤ ꠢꠄꠔ ꠑꠤꠇ ꠜꠣꠛꠦꠃ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠞꠣꠄ, ꠅꠁꠟꠦ ꠅꠃ ꠝꠣꠘꠡꠞꠦ ꠔ ꠉꠠꠤꠀ ꠔꠥꠟꠣ ꠅꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C114_18","076_14_18","1CO","14","18","18","ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ, ꠇꠣꠞꠘ ꠀꠝꠤ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠌꠣꠁꠔꠦ ꠛꠃꠔ ꠛꠦꠡꠤ ꠝꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("C114_19","076_14_19","1CO","14","19","19","ꠔꠣ-ꠅ ꠎꠝꠣꠔꠞ ꠝꠣꠢꠚꠤꠟꠞ ꠝꠣꠎꠦ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠇꠕꠣꠞ ꠛꠖꠟꠣ, ꠝꠣꠘꠡꠞ ꠔꠣꠟꠤꠝꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠈꠟ ꠈꠣꠐꠣꠁꠀ ꠈꠣꠟꠤ ꠙꠣꠌꠈꠣꠘ ꠇꠕꠣ ꠇꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C114_20","076_14_20","1CO","14","20","20","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠘꠣ ꠅꠁꠀ ꠛꠄꠅꠡ꠆ꠇ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠅꠃꠇ। ꠅꠁꠟꠦ ꠁꠋꠡꠣ-ꠘꠤꠘ꠆ꠖꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠘ ꠝꠣꠍꠥꠝ ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C114_21","076_14_21","1CO","14","21","21","ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠀꠍꠦ, ꠅꠌꠤꠘꠣ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠞꠣ ꠝꠣꠘꠥꠡꠖꠤ, ꠛꠤꠖꠦꠡꠤ ꠝꠣꠘꠡꠞ ꠝꠥꠈꠖꠤ, ꠀꠝꠤ ꠅꠃ ꠎꠣꠔꠤꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠝꠥ। ꠔꠣ-ꠅ ꠀꠝꠣꠞ ꠝꠣꠔ ꠔꠣꠞꠣ ꠢꠥꠘꠔ ꠘꠣꠄ, ꠁꠈꠣꠘ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C114_22","076_14_22","1CO","14","22","22","ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠣ ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠘꠤꠡꠣꠘꠣ ꠘꠣꠄ, ꠛꠞꠋ ꠅ-ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠄꠇꠐꠣ ꠘꠤꠡꠣꠘꠣ। ꠀꠞ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔ ꠝꠣꠔꠣ ꠅ-ꠁꠝꠣꠘꠖꠣꠞꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠘꠤꠡꠣꠘꠣ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠁꠝꠣꠘꠖꠣꠞꠞ ꠟꠣꠉꠤ ꠔ ꠁꠔꠣ ꠄꠇꠐꠣ ꠘꠤꠡꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C114_23","076_14_23","1CO","14","23","23","ꠎꠝꠣꠔꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠄꠇ ꠎꠣꠉꠣꠔ ꠝꠤꠟꠣꠞ ꠛꠣꠖꠦ, ꠢꠇꠟꠦ ꠎꠥꠖꠤ ꠄꠇꠟꠉꠦ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠦ, ꠀꠞ ꠅꠃ ꠡꠝꠄ ꠎꠝꠣꠔꠞ ꠛꠣꠁꠞꠞ ꠛꠣ ꠅ-ꠁꠝꠣꠘꠖꠣꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠁꠘꠅ ꠀꠄ, ꠔꠦ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠉꠟ ꠇꠁꠛꠣ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C114_24","076_14_24","1CO","14","24","24","ꠀꠞ ꠢꠇꠟꠦ ꠎꠥꠖꠤ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠂꠘ, ꠅꠝꠘ ꠡꠝꠄ ꠇꠥꠘꠥ ꠅ-ꠁꠝꠣꠘꠖꠣꠞ ꠀꠁꠀ ꠁꠘꠅ ꠢꠣꠝꠣꠄ, ꠔꠦ ꠅꠃ ꠢꠇꠟꠞ ꠝꠣꠔꠞ ꠝꠣꠎꠖꠤ ꠢꠦ ꠘꠤꠎꠞ ꠉꠥꠘꠣꠞ ꠢꠣꠟꠔ ꠛꠥꠎꠤꠟꠤꠛ, ꠅꠃ ꠝꠣꠔ ꠢꠥꠘꠣꠄ ꠔꠣꠞ ꠘꠤꠎꠞ ꠛꠤꠌꠣꠞ ꠘꠤꠎꠦ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("C114_25","076_14_25","1CO","14","25","25","ꠔꠣꠞ ꠝꠘꠞ ꠟꠥꠇꠣꠁꠟ ꠛꠤꠡꠄ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠅꠁꠛ, ꠔꠦꠃ ꠢꠦ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ-ꠔꠣꠞꠤꠚ ꠇꠞꠤꠀ ꠇꠁꠛ, “ꠀꠙꠘꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠤꠌ꠆ꠌꠄ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠎꠤꠞ ꠀꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("C114_26","076_14_26","1CO","14","26","26","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠇꠤꠔꠣ ꠅꠁꠔ? ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠄꠇ ꠎꠣꠉꠣꠔ ꠎꠝꠣꠔꠅ ꠖꠟꠣ ꠅꠅ, ꠅꠃ ꠡꠝꠄ ꠇꠦꠃ ꠉꠤꠔ-ꠉꠎꠟ ꠉꠣꠁꠘ, ꠇꠦꠃ ꠘꠍꠤꠅꠔ ꠇꠞꠂꠘ, ꠇꠦꠃ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞꠦ ꠇꠂꠘ, ꠇꠦꠃ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠂꠘ, ꠀꠞ ꠇꠦꠃ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠣꠁꠀ ꠖꠦꠁꠘ। ꠔꠦ ꠎꠦꠁꠘ ꠎꠦꠔꠣꠃ ꠇꠞꠂꠘ ꠘꠣ ꠇꠦꠘꠦ, ꠁꠔꠣ ꠎꠣꠘꠥ ꠎꠝꠣꠔꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣꠞ ꠘꠤꠅꠔꠦ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C114_27","076_14_27","1CO","14","27","27","ꠇꠦꠃ ꠎꠥꠖꠤ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠦ, ꠔꠦ ꠄꠇꠅꠎꠘ ꠇꠞꠤ ꠖꠥꠁ-ꠔꠤꠘꠎꠘꠦ ꠝꠣꠔꠃꠇ ꠀꠞ ꠄꠇꠎꠘꠦ ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠣꠁꠀ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C114_28","076_14_28","1CO","14","28","28","ꠝꠣꠘꠤ ꠛꠥꠎꠣꠁ ꠖꠤꠛꠣꠞ ꠇꠦꠃ ꠘꠣ ꠕꠣꠇꠟꠦ, ꠔꠣꠞꠣ ꠎꠝꠣꠔꠅ ꠌꠥꠙꠌꠣꠙ ꠕꠣꠇꠃꠇ, ꠈꠣꠟꠤ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C114_29","076_14_29","1CO","14","29","29","ꠀꠞ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠞꠣ ꠅꠇꠟꠦ ꠅꠟꠣ ꠖꠥꠁ-ꠔꠤꠘꠎꠘꠦ ꠝꠣꠔꠃꠇ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟꠦ ꠎꠣꠌꠣꠁ-ꠛꠣꠌꠣꠁ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C114_30","076_14_30","1CO","14","30","30","ꠅꠁꠟꠦ ꠎꠝꠣꠔꠅ ꠎꠦꠞꠣ ꠛꠅꠀꠔ ꠀꠍꠂꠘ, ꠔꠣꠞꠣ ꠇꠦꠃꠞꠞ ꠉꠦꠍꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠅꠢꠤ ꠛꠣ ꠛꠣꠔꠥꠘꠤ ꠈꠛꠞ ꠘꠣꠎꠤꠟ ꠅꠄ, ꠔꠦ ꠎꠦꠁꠘ ꠛꠄꠀꠘ ꠇꠞꠞꠣ, ꠔꠣꠁꠘ ꠘꠤꠞꠣꠁ ꠅꠁꠎꠣꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("C114_31","076_14_31","1CO","14","31","31","ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠄꠇ ꠄꠇ ꠇꠞꠤ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠤꠅ, ꠎꠣꠔꠦ ꠢꠥꠘꠞꠣ ꠅꠇꠟꠦ ꠔꠣꠟꠤꠝ ꠀꠞ ꠃꠔꠡꠣꠢ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C114_32","076_14_32","1CO","14","32","32","ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔꠞꠣꠞ ꠞꠥꠢꠥ ꠔ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠛꠡꠦ ꠕꠣꠇꠦ, ");
INSERT INTO syls_vpl VALUES ("C114_33","076_14_33","1CO","14","33","33","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠘꠤꠌ꠆ꠌꠄ ꠉꠥꠟꠝꠣꠟ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠡꠣꠘ꠆ꠔꠤ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C114_34","076_14_34","1CO","14","34","34","ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠢꠇꠟ ꠎꠝꠣꠔꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠅꠁꠟ, ꠎꠝꠣꠔꠞ ꠝꠣꠎꠦ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠘꠤꠞꠣꠁ ꠞꠅꠀ ꠃꠌꠤꠔ, ꠉꠚ-ꠡꠚ ꠇꠞꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠘꠣꠄ। ꠡꠞꠤꠅꠔꠞ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣ ꠅꠗꠤꠘꠔꠣ ꠝꠣꠘꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C114_35","076_14_35","1CO","14","35","35","ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠔꠣꠟꠤꠝ ꠎꠣꠘꠣꠞ ꠈꠤꠀꠟꠤ ꠅꠁꠟꠦ ꠛꠣꠠꠤꠔ ꠉꠤꠀ ꠘꠤꠎꠞ ꠎꠣꠝꠣꠁꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠣꠘꠃꠇ। ꠇꠣꠞꠘ ꠎꠝꠣꠔꠞ ꠝꠣꠎꠦ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠉꠚ-ꠡꠚ ꠇꠞꠣ ꠡꠞꠝ। ");
INSERT INTO syls_vpl VALUES ("C114_36","076_14_36","1CO","14","36","36","ꠀꠁꠌ꠆ꠍꠣ ꠇꠅ ꠌꠣꠁꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠇꠥꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠍꠦ ꠘꠤ? ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦꠃ ꠀꠁꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C114_37","076_14_37","1CO","14","37","37","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠘꠤꠎꠞꠦ ꠙꠤꠞ-ꠖꠞꠛꠦꠡ ꠛꠣ ꠛꠣꠔꠥꠘꠤ ꠈꠦꠝꠔꠣꠀꠟꠣ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠁꠈꠣꠘ ꠛꠥꠎꠤꠟꠣꠃꠇ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠔꠣ ꠟꠦꠈꠟꠣꠝ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠢꠥꠇꠥꠝ। ");
INSERT INTO syls_vpl VALUES ("C114_38","076_14_38","1CO","14","38","38","ꠀꠞ ꠇꠦꠃ ꠁꠔꠣ ꠘꠣ ꠝꠣꠘꠟꠦ, ꠔꠣꠞꠦꠅ ꠝꠣꠁꠘ꠆ꠘ ꠇꠞꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C114_39","076_14_39","1CO","14","39","39","ꠄꠞꠟꠣꠉꠤ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠙꠤꠞꠣꠇꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟꠤ ꠅꠅ, ꠀꠞ ꠉꠣꠁꠛꠤ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠤꠔꠦꠅ ꠛꠣꠗꠣ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C114_40","076_14_40","1CO","14","40","40","ꠔꠣ-ꠅ ꠎꠝꠣꠔꠞ ꠢꠇꠟ ꠇꠣꠝꠃ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠖꠛ-ꠇꠣꠄꠖꠣ ꠀꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠝꠣꠘꠤꠀ ꠇꠞꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("C115_1","076_15_1","1CO","15","1","1","ꠅ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠀꠉꠦ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤꠟꠣꠝ, ꠢꠃ ꠇꠕꠣ ꠅꠈꠘ ꠁꠀꠖ ꠇꠞꠣꠁ ꠖꠤꠞꠣꠝ। ꠔꠥꠝꠞꠣ ꠔ ꠁꠔꠣ ꠇꠛꠥꠟ ꠇꠞꠍꠟꠣꠄ ꠀꠞ ꠁꠝꠣꠘꠦ ꠐꠤꠇꠤꠀꠅ ꠞꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("C115_2","076_15_2","1CO","15","2","2","ꠀꠝꠤ ꠎꠦ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠗꠞꠤꠀ ꠞꠣꠈꠅ, ꠔꠦ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠝꠣꠎꠖꠤ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠞꠣꠄ, ꠀꠞ ꠘꠣ ꠙꠣꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠀꠘꠣꠃ ꠛꠦꠇꠣꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_3","076_15_3","1CO","15","3","3","ꠀꠍꠟꠦ ꠀꠝꠤ ꠘꠤꠎꠦ ꠎꠦ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍꠤ, ꠅꠃ ꠔꠣꠟꠤꠝꠞꠦ ꠈꠥꠛ ꠎꠞꠥꠞꠤ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠎꠣꠘꠣꠁꠍꠤ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠝꠣꠚꠤꠇ ꠀꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤꠄ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_4","076_15_4","1CO","15","4","4","ꠔꠣꠘꠞꠦ ꠖꠣꠚꠘ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠝꠣꠚꠤꠇ ꠝꠃꠔꠞ ꠔꠤꠘ ꠖꠤꠘꠞ ꠖꠤꠘ ꠔꠣꠁꠘ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_5","076_15_5","1CO","15","5","5","ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠙꠄꠟꠣ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠞꠦ, ꠛꠣꠖꠦ ꠔꠣꠘ ꠢꠃ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_6","076_15_6","1CO","15","6","6","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠄꠇꠟꠉꠦ ꠙꠣꠌ-ꠡꠞꠅ ꠛꠦꠡꠤ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠍꠂꠘ। ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠇꠦꠃ ꠝꠣꠞꠣ ꠉꠦꠟꠦꠅ, ꠅꠈꠘꠅ ꠛꠦꠡꠤꠞ ꠜꠣꠉ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_7","076_15_7","1CO","15","7","7","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠘ ꠜꠣꠁ ꠁꠀꠇꠥꠛꠞꠦ, ꠛꠣꠖꠦ ꠢꠇꠟ ꠍꠣꠢꠣꠛꠤꠞꠦ ꠖꠦꠈꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_8","076_15_8","1CO","15","8","8","ꠀꠞ ꠀꠝꠤ ꠔ ꠢꠇꠟꠞ ꠢꠦꠡꠞ ꠏꠥꠟꠤ-ꠏꠣꠠꠣ ꠙꠥꠔ, ꠅꠃ ꠀꠝꠣꠞꠦꠅ ꠔꠣꠁꠘ ꠖꠦꠈꠣ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_9","076_15_9","1CO","15","9","9","ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠀꠝꠤꠃ ꠢꠇꠟ ꠕꠣꠇꠤ ꠘꠉꠁꠘ꠆ꠘ, ꠀꠝꠤ ꠔ ꠍꠣꠢꠣꠛꠤ ꠇꠁꠀ ꠙꠞꠤꠌꠄ ꠖꠤꠛꠣꠞ ꠟꠣꠈ ꠘꠣꠄ, ꠀꠉꠦ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C115_10","076_15_10","1CO","15","10","10","ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠤ ꠎꠦꠟꠣ ꠅꠁꠍꠤ, ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦꠃ ꠅꠁꠍꠤ। ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠁ ꠞꠢꠝꠔ ꠛꠦꠇꠣꠝꠣ ꠉꠦꠍꠦ ꠘꠣ, ꠀꠝꠤ ꠅꠁꠘ꠆ꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠝꠦꠘꠔ ꠇꠞꠍꠤ। ꠁ ꠝꠦꠘꠔ ꠔ ꠀꠝꠤ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠍꠤ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦꠃ ꠁꠔꠣ ꠇꠞꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C115_11","076_15_11","1CO","15","11","11","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠛꠣ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠍꠣꠢꠣꠛꠤꠄ ꠎꠦꠁꠘꠃ ꠔꠛꠟꠤꠉ ꠇꠞꠤ ꠘꠣ ꠇꠦꠘꠦ, ꠀꠝꠞꠣ ꠅꠃ ꠄꠇꠁ ꠛꠦꠙꠣꠞꠦꠃ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀꠞ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣꠅ ꠁꠝꠣꠘ ꠀꠘꠍ। ");
INSERT INTO syls_vpl VALUES ("C115_12","076_15_12","1CO","15","12","12","ꠔꠦ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ ꠇꠁꠀ ꠎꠦꠛꠟꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠄ, ꠔꠣꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠇꠦꠃ ꠇꠦꠝꠘꠦ ꠇꠄ, ꠝꠣꠘꠥꠡ ꠝꠞꠤꠉꠦꠟꠦ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠔꠣ ꠘꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("C115_13","076_15_13","1CO","15","13","13","ꠝꠞꠘ ꠛꠣꠖꠦ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠔꠦ ꠘꠣ ꠙꠣꠞꠟꠦ ꠔ, ꠀꠟ-ꠝꠍꠤꠅ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_14","076_15_14","1CO","15","14","14","ꠀꠞ ꠀꠟ-ꠝꠍꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠘꠣ ꠃꠑꠟꠦ ꠔ ꠀꠝꠞꠣꠞ ꠔꠛꠟꠤꠉꠅ ꠛꠦꠇꠣꠝꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠀꠘꠣꠅ ꠛꠦꠇꠣꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_15","076_15_15","1CO","15","15","15","ꠄꠝꠘꠇꠤ ꠅꠈꠣꠘꠅ ꠛꠥꠎꠣ ꠎꠣꠞ ꠎꠦꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀꠞ ꠁꠔꠣ ꠝꠤꠍꠣ, ꠇꠣꠞꠘ ꠀꠝꠞꠣꠞ ꠔꠛꠟꠤꠉ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ। ꠅꠁꠟꠦ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠎꠥꠖꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠘꠣ ꠅꠄ, ꠔꠦ ꠔ ꠔꠣꠁꠘ ꠀꠟ-ꠝꠍꠤꠞꠦꠅ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_16","076_15_16","1CO","15","16","16","ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠎꠥꠖꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠘꠣ ꠃꠑꠂꠘ, ꠔꠦ ꠔ ꠀꠟ-ꠝꠍꠤꠅ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_17","076_15_17","1CO","15","17","17","ꠀꠟ-ꠝꠍꠤꠞꠦ ꠎꠥꠖꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠘꠣ ꠅꠁꠀꠃ ꠕꠣꠇꠦ, ꠔꠦ ꠔ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠛꠦꠇꠣꠝꠣ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠈꠘꠅ ꠉꠥꠘꠣꠞ ꠝꠣꠎꠦ ꠢꠣꠛꠥꠒꠥꠛꠥ ꠈꠣꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C115_18","076_15_18","1CO","15","18","18","ꠔꠣꠁꠟꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠞ ꠎꠦꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠞꠣꠅ ꠔ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_19","076_15_19","1CO","15","19","19","ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠀꠝꠞꠣꠞ ꠎꠦ ꠀꠡꠣ, ꠁ ꠀꠡꠣ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠅꠃ ꠖꠥꠘꠤꠀꠛꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠟꠣꠉꠤ ꠅꠄ, ꠔꠦ ꠔ ꠢꠇꠟ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠃ ꠛꠦꠡꠤ ꠛꠖ ꠘꠍꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("C115_20","076_15_20","1CO","15","20","20","ꠅꠁꠟꠦ ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔ ꠢꠣꠍꠣꠃ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ। ꠔꠣꠁꠘꠃ ꠙꠄꠟꠣ ꠚꠡꠟ, ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠔ ꠎꠘꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠛ, ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠔꠣꠘꠞꠦꠃ ꠙꠄꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C115_21","076_15_21","1CO","15","21","21","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠟꠣ ꠝꠃꠔ ꠀꠁꠍꠦ, ꠅꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠅ ꠄꠇꠎꠘ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠖꠤ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C115_22","076_15_22","1CO","15","22","22","ꠛꠣꠛꠣ ꠀꠖꠝꠞ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠎꠦꠟꠣ ꠝꠞꠘ ꠅꠄ, ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠢꠤꠡꠣꠛꠦ ꠅꠃꠟꠣ ꠢꠇꠟꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C115_23","076_15_23","1CO","15","23","23","ꠅꠁꠟꠦ ꠄꠞ ꠝꠣꠎꠦ ꠇꠕꠣ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠗꠣꠙꠦ ꠗꠣꠙꠦ ꠢꠇꠟꠔꠣ ꠇꠞꠣꠁꠛꠣ। ꠈꠦꠔꠅ ꠕꠣꠇꠤ ꠙꠄꠟꠣ ꠔꠥꠟꠣ ꠚꠡꠟꠞ ꠟꠣꠈꠣꠘ ꠙꠄꠟꠣ ꠗꠣꠙꠅ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠣꠟꠅ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞꠦꠅ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C115_24","076_15_24","1CO","15","24","24","ꠄꠞꠛꠣꠖꠦ ꠇꠤꠀꠝꠔꠞ ꠇꠣꠟꠅ ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠘꠤꠀꠛꠤ ꠢꠇꠟ ꠡꠣꠡꠘ, ꠅꠗꠤꠇꠣꠞ ꠀꠞ ꠈꠦꠝꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠀ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠀꠔꠅ ꠛꠣꠖꠡꠣꠁ ꠡꠝꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_25","076_15_25","1CO","15","25","25","ꠇꠣꠞꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠔ ꠡꠝꠄ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠢꠇꠟ ꠖꠥꠡꠝꠘꠞꠦ ꠔꠣꠘ ꠙꠣꠅꠞ ꠔꠟꠣꠔ ꠘꠣ ꠚꠣꠟꠣꠁꠘ, ꠅꠔ ꠡꠝꠄ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠁꠘ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C115_26","076_15_26","1CO","15","26","26","ꠀꠞ ꠡꠦꠡ ꠖꠥꠡꠝꠘ ꠝꠃꠔꠞꠦꠅ ꠔꠣꠁꠘ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_27","076_15_27","1CO","15","27","27","ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, “ꠔꠣꠁꠘ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ ꠞꠣꠈꠍꠂꠘ।” ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠅꠗꠤꠘꠦ ꠞꠣꠈꠣꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞꠦ ꠛꠣꠖ ꠞꠣꠈꠤꠀ ꠅꠁꠘ꠆ꠘ ꠢꠇꠟꠔꠣꠞꠦꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠟꠦ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_28","076_15_28","1CO","15","28","28","ꠀꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠣꠘ ꠅꠗꠤꠘꠦ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠟꠁꠀ ꠅꠃ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠅ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠅꠗꠤꠘ ꠅꠁꠛꠣ। ꠎꠣꠔꠦ ꠎꠦꠁꠘ ꠢꠇꠟꠔꠣ ꠔꠣꠘ ꠅꠗꠤꠘꠦ ꠞꠣꠈꠍꠤꠟꠣ, ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠃ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠃꠙꠞꠀꠟꠣ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_29","076_15_29","1CO","15","29","29","ꠀꠁꠌ꠆ꠍꠣ ꠗꠞꠅ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣ ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠦꠞ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠘꠣ ꠅꠄ, ꠔꠦ ꠄꠞꠣꠞ ꠚꠣꠄꠖꠣ ꠇꠤꠔꠣ? ");
INSERT INTO syls_vpl VALUES ("C115_30","076_15_30","1CO","15","30","30","ꠀꠞ ꠀꠝꠞꠣ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠅ ꠇꠦꠘꠦ ꠊꠘ꠆ꠐꠣꠄ ꠊꠘ꠆ꠐꠣꠄ ꠛꠤꠙꠖꠞ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠅꠁꠀꠞ? ");
INSERT INTO syls_vpl VALUES ("C115_31","076_15_31","1CO","15","31","31","ꠅꠄ, ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠔ ꠙꠞꠔꠦꠇ ꠖꠤꠘꠃ ꠝꠃꠔꠞ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠅꠁꠀꠞ! ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠎꠦ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠁ, ꠅꠃ ꠛꠠꠣꠁꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C115_32","076_15_32","1CO","15","32","32","ꠁꠚꠤꠍ ꠐꠣꠃꠘꠅ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞ ꠙꠣꠟꠞ ꠟꠉꠦ ꠀꠝꠤ ꠎꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠈꠣꠟꠤ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠔꠦ ꠇꠞꠤꠀ ꠕꠣꠇꠤ, ꠔꠦ ꠀꠝꠣꠞ ꠇꠥꠘꠥ ꠟꠣꠜ ꠅꠁꠍꠦ ꠘꠤ? ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠎꠥꠖꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠘꠣ ꠅꠄ, ꠔꠦ ꠀꠅ, ꠅꠟꠣ ꠇꠁ, “ꠀꠅ, ꠈꠣꠅ-ꠖꠣꠅ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ, ꠇꠣꠁꠟ ꠔ ꠘꠤꠌ꠆ꠌꠤꠔ ꠝꠞꠘ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("C115_33","076_15_33","1CO","15","33","33","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣ ꠜꠥꠟ ꠇꠞꠤꠅ ꠘꠣ, ꠅꠟꠣ ꠄꠇ ꠍꠤꠟ꠆ꠟꠦꠈ ꠀꠍꠦ, “ꠇꠥ-ꠡꠋꠉꠤꠄ ꠜꠣꠟꠣ ꠝꠣꠘꠡꠞꠦꠅ ꠘꠣꠐꠣꠁꠟꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("C115_34","076_15_34","1CO","15","34","34","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠛꠖ ꠘꠤꠡꠣ ꠕꠣꠇꠤ ꠢꠎꠣꠉ ꠅꠅ, ꠀꠞ ꠉꠥꠘꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠇꠦꠃ ꠔ ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣꠞꠦꠃ ꠌꠤꠘꠦ ꠘꠣ, ꠁꠔꠣ ꠛꠠ ꠡꠞꠝꠞ ꠛꠦꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C115_35","076_15_35","1CO","15","35","35","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠤꠇꠣꠁꠔ ꠙꠣꠞꠦ, “ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠇꠦꠝꠘꠦ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠛꠣ? ꠔꠣꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠉꠑꠘ ꠇꠤꠟꠣꠈꠣꠘ ꠅꠁꠛ?” ");
INSERT INTO syls_vpl VALUES ("C115_36","076_15_36","1CO","15","36","36","ꠢꠣꠄꠞꠦ ꠛꠦꠀꠈꠟ! ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠈꠦꠔꠞ ꠝꠣꠎꠦ ꠎꠦ ꠛꠤꠌꠤ ꠛꠣꠁꠘ ꠇꠞꠅ, ꠁ ꠛꠤꠌꠤ ꠘꠣ ꠝꠞꠟꠦ ꠔ ꠌꠦꠞꠣ ꠃꠑꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_37","076_15_37","1CO","15","37","37","ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠣꠁꠘ ꠇꠞꠣ ꠛꠤꠌꠤ ꠕꠣꠇꠤ ꠎꠦ ꠌꠦꠞꠣ ꠛꠣꠞꠅꠄ, ꠔꠥꠝꠤ ꠔ ꠁ ꠌꠦꠞꠣ ꠛꠣꠁꠘ ꠇꠞ ꠘꠣ, ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠛꠤꠌꠤ ꠛꠣꠁꠘ ꠇꠞ ꠗꠣꠘ ꠛꠣ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠚꠡꠟꠞ, ꠅꠉꠥ ꠝꠞꠤꠀꠃ ꠌꠦꠞꠣ ꠛꠣꠞꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C115_38","076_15_38","1CO","15","38","38","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠁꠔꠣꠞ ꠍꠥꠞꠔ-ꠀꠇꠣꠞ ꠉꠑꠘ ꠇꠞꠂꠘ। ꠔꠣꠁꠘ ꠙꠞꠔꠦꠇ ꠛꠤꠌꠞꠦꠃ ꠔꠣꠞ ꠎꠣꠔ ꠝꠣꠚꠤꠇ ꠌꠦꠞꠣꠞ ꠍꠥꠞꠔ-ꠀꠇꠣꠞ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_39","076_15_39","1CO","15","39","39","ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞ ꠉꠥꠡ꠆ꠔ ꠔ ꠄꠇ ꠡꠝꠣꠘ ꠘꠣꠄ। ꠝꠣꠘꠡꠞ ꠉꠥꠡ꠆ꠔ ꠄꠇꠟꠣꠈꠣꠘ, ꠙꠡꠥꠞ ꠄꠇꠟꠣꠈꠣꠘ, ꠙꠣꠈꠤꠞ ꠄꠇꠟꠣꠈꠣꠘ ꠀꠞ ꠝꠣꠍꠞ ꠀꠞꠇ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_40","076_15_40","1CO","15","40","40","ꠅꠃꠟꠣ ꠀꠍꠝꠣꠘꠅ-ꠅ ꠛꠃꠔ ꠘꠝꠥꠘꠣꠞ ꠡꠞꠤꠟ ꠀꠍꠦ, ꠖꠥꠘꠤꠀꠔꠅ ꠛꠃꠔ ꠡꠞꠤꠟ ꠀꠍꠦ, ꠔꠣ-ꠅ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠡꠞꠤꠟꠞ ꠔꠦꠎ ꠄꠇꠟꠣꠈꠣꠘ, ꠀꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠡꠞꠤꠟꠞ ꠔꠦꠎ ꠀꠞꠇ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_41","076_15_41","1CO","15","41","41","ꠡꠥꠞꠥꠎꠞ ꠔꠦꠎ ꠄꠇꠟꠣꠈꠣꠘ, ꠌꠣꠘ꠆ꠖꠞ ꠔꠦꠎ ꠀꠞꠇ ꠟꠣꠈꠣꠘ ꠀꠞ ꠔꠦꠞꠣꠞ ꠔꠦꠎ ꠖꠥꠍꠞꠣ ꠟꠣꠈꠣꠘ। ꠄꠝꠘꠇꠤ ꠄꠇ ꠔꠦꠞꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠔꠦꠞꠣꠞ ꠔꠦꠎꠅ ꠀꠟꠣꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_42","076_15_42","1CO","15","42","42","ꠝꠞꠘ ꠛꠣꠖꠦ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠅ ꠅꠃ ꠟꠣꠈꠣꠘ। ꠟꠣꠡ ꠝꠣꠐꠤ ꠖꠤꠀ ꠢꠣꠞꠟꠦ ꠙꠌꠤꠎꠣꠄ, ꠅꠁꠟꠦ ꠅꠃ ꠟꠣꠡꠞꠦ ꠎꠦꠛꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠛ, ꠁꠐꠣ ꠀꠞ ꠙꠌꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C115_43","076_15_43","1CO","15","43","43","ꠅꠡꠝ꠆ꠝꠣꠘꠤ ꠢꠣꠟꠔꠦ ꠝꠣꠐꠤ ꠖꠦꠅꠀ ꠅꠄ, ꠡꠝ꠆ꠝꠣꠘꠤ ꠢꠣꠟꠔꠦ ꠔꠥꠟꠣ ꠅꠁꠛ। ꠝꠣꠐꠤ ꠖꠦꠅꠀ ꠅꠄ ꠖꠥꠞ꠆ꠛꠟ ꠢꠣꠟꠔꠦ, ꠀꠞ ꠔꠥꠟꠣ ꠅꠁꠛ ꠛꠟꠛꠣꠘ ꠢꠣꠟꠔꠦ। ");
INSERT INTO syls_vpl VALUES ("C115_44","076_15_44","1CO","15","44","44","ꠝꠣꠐꠤ ꠖꠦꠅꠀ ꠅꠄ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠡꠞꠤꠟ, ꠅꠁꠟꠦ ꠔꠥꠟꠣ ꠅꠁꠛ ꠞꠥꠢꠣꠘꠤꠇ ꠡꠞꠤꠟ। ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠡꠞꠤꠟ ꠎꠦꠛꠟꠣ ꠀꠍꠦ, ꠔꠦ ꠔ ꠞꠥꠢꠣꠘꠤꠇ ꠡꠞꠤꠟꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C115_45","076_15_45","1CO","15","45","45","ꠎꠦꠟꠣ ꠛꠣꠛꠣ ꠀꠖꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, “ꠅꠃ ꠙꠄꠟꠣ ꠀꠖꠝ ꠎꠤꠘ꠆ꠖꠣ ꠎꠣꠘꠖꠣꠞ ꠅꠁꠟꠣ।” ꠔꠦ ꠡꠦꠡ ꠀꠖꠝ, ꠎꠦꠁꠘ ꠀꠟ-ꠝꠍꠤ, ꠔꠣꠁꠘ ꠇꠤꠔꠣ ꠅꠁꠟꠣ? ꠔꠣꠁꠘ ꠔ ꠅꠁꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠦꠅꠞꠣ ꠞꠥꠢꠥ। ");
INSERT INTO syls_vpl VALUES ("C115_46","076_15_46","1CO","15","46","46","ꠅꠁꠟꠦ ꠞꠥꠢꠣꠘꠤꠇ ꠎꠦ ꠡꠞꠤꠟ, ꠁꠈꠣꠘ ꠔ ꠙꠄꠟꠣ ꠅꠄ ꠘꠣ, ꠙꠄꠟꠣ ꠅꠄ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠡꠞꠤꠟ, ꠛꠣꠖꠦ ꠅꠄ ꠞꠥꠢꠣꠘꠤꠇ ꠡꠞꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("C115_47","076_15_47","1CO","15","47","47","ꠎꠦꠟꠣ ꠙꠄꠟꠣ ꠀꠖꠝ ꠝꠣꠐꠤ ꠕꠣꠇꠤ ꠀꠁꠟꠣ, ꠛꠣꠖꠦ ꠖꠥꠍꠞꠣ ꠀꠖꠝ, ꠀꠟ-ꠝꠍꠤ ꠀꠁꠟꠣ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("C115_48","076_15_48","1CO","15","48","48","ꠎꠉꠔꠞ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ ꠅꠃ ꠝꠣꠐꠤꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ, ꠀꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ ꠢꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠎꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_49","076_15_49","1CO","15","49","49","ꠔꠦ ꠛꠣꠛꠣ ꠀꠖꠝꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠝꠣꠐꠤꠞ ꠇꠣꠄꠀꠞ ꠍꠥꠞꠔ ꠙꠣꠁꠍꠤ, ꠑꠤꠇ ꠅꠃꠟꠣ ꠢꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠎꠘꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠍꠥꠞꠔꠅ ꠙꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C115_50","076_15_50","1CO","15","50","50","ꠜꠣꠁꠀꠁꠘꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠇꠥꠘꠥ ꠡꠞꠤꠟ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠅꠗꠤꠇꠣꠞ ꠙꠣꠄ ꠘꠣ। ꠎꠦꠔꠣꠞ ꠛꠤꠘꠣꠡ ꠀꠍꠦ, ꠁꠔꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠌꠤꠞꠡ꠆ꠕꠣꠄꠁ ꠛꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C115_51","076_15_51","1CO","15","51","51","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠄꠇꠐꠣ ꠛꠣꠔꠥꠘꠤ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠎꠣꠘ ꠘꠤ, ꠀꠝꠞꠣ ꠢꠇꠟꠞ ꠔ ꠝꠃꠔ ꠅꠁꠔ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠢꠇꠟꠞꠃ ꠍꠥꠞꠔ ꠛꠖꠟꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("C115_52","076_15_52","1CO","15","52","52","ꠇꠤꠀꠝꠔꠞ ꠇꠣꠟꠅ ꠄꠇ ꠝꠥꠢꠥꠞ꠆ꠔꠞ ꠝꠣꠎꠦ, ꠌꠈꠥꠞ ꠙꠟꠇꠦ, ꠡꠤꠋꠉꠣꠔ ꠚꠥ ꠖꠦꠅꠀꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠀꠝꠞꠣ ꠛꠖꠟꠤꠎꠤꠝꠥ। ꠅꠃ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠤꠀ ꠢꠣꠞꠟꠦ, ꠢꠇꠟ ꠝꠥꠞ꠆ꠖꠣ ꠅꠟꠣ ꠍꠥꠞꠔꠦ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠛꠣ, ꠎꠦꠔꠣ ꠇꠥꠘꠥꠖꠤꠘ ꠛꠤꠘꠣꠡ ꠅꠁꠔ ꠘꠣꠄ, ꠀꠞ ꠀꠝꠞꠣꠅ ꠢꠃ ꠍꠥꠞꠔꠦ ꠛꠖꠟꠤꠎꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C115_53","076_15_53","1CO","15","53","53","ꠄꠞꠟꠣꠉꠤ ꠎꠦ ꠡꠞꠤꠟ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠣꠄ, ꠁꠔꠣꠄ ꠅꠟꠣ ꠍꠥꠞꠔ ꠙꠣꠁꠔꠦ ꠅꠁꠛ, ꠎꠦꠔꠣ ꠇꠥꠘꠥꠖꠤꠘ ꠙꠌꠤꠔ ꠘꠣꠄ, ꠀꠞ ꠎꠦꠔꠣ ꠝꠞꠤꠎꠤꠛ, ꠁꠔꠣꠄ ꠅꠟꠣ ꠍꠥꠞꠔ ꠙꠣꠁꠔꠦ ꠅꠁꠛ, ꠎꠦꠔꠣ ꠇꠥꠘꠥꠖꠤꠘ ꠝꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C115_54","076_15_54","1CO","15","54","54","ꠀꠞ ꠎꠦ ꠡꠞꠤꠟ ꠙꠌꠤꠎꠣꠄ, ꠁ ꠡꠞꠤꠟꠦ ꠎꠦꠛꠟꠣ ꠌꠤꠞꠡ꠆ꠕꠣꠄꠁ ꠍꠥꠞꠔ ꠙꠣꠁꠛ, ꠎꠦ ꠡꠞꠤꠟꠞ ꠝꠃꠔ ꠅꠄ, ꠁꠔꠣꠄ ꠎꠦꠛꠟꠣ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ, ꠢꠃ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠅꠃ ꠟꠦꠈꠣ ꠚꠟꠤꠛ, ꠝꠃꠔꠞ ꠛꠤꠘꠣꠡ ꠅꠁꠀ ꠎꠄ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C115_55","076_15_55","1CO","15","55","55","ꠅ ꠝꠃꠔ, ꠔꠞ ꠎꠄ ꠇꠥꠀꠁ? ꠝꠃꠔꠞꠦ, ꠔꠞ ꠛꠤꠡ-ꠖꠣꠔ ꠇꠥꠀꠁ? ");
INSERT INTO syls_vpl VALUES ("C115_56","076_15_56","1CO","15","56","56","ꠝꠃꠔꠞ ꠛꠤꠡ-ꠖꠣꠔ ꠅꠁꠟ ꠉꠥꠘꠣ, ꠀꠞ ꠉꠥꠘꠣꠞꠦ ꠈꠦꠝꠔꠣ ꠎꠥꠉꠣꠄ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔ। ");
INSERT INTO syls_vpl VALUES ("C115_57","076_15_57","1CO","15","57","57","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠎꠄ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C115_58","076_15_58","1CO","15","58","58","ꠔꠦ, ꠅ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁꠀꠁꠘ, ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠅꠅ, ꠎꠣꠔꠦ ꠇꠥꠘ꠆ꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟꠣꠁꠔ ꠘꠣ ꠙꠣꠞꠦ। ꠝꠣꠟꠤꠇꠞ ꠈꠦꠎꠝꠔꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠤꠟꠣꠁ ꠖꠦꠅ, ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠔꠣꠘ ꠟꠣꠉꠤ ꠝꠦꠘꠔ ꠇꠞꠟꠦ ꠁ ꠝꠦꠘꠔ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠛꠦꠇꠣꠝꠣ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C116_1","076_16_1","1CO","16","1","1","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ ꠌꠣꠘ꠆ꠖꠣ ꠔꠥꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠅꠈꠘ ꠇꠁꠞꠣꠝ। ꠉꠣꠟꠣꠔꠤꠀ ꠖꠦꠡꠞ ꠁꠍꠣꠄꠁ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠀꠝꠤ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("C116_2","076_16_2","1CO","16","2","2","ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠦ ꠎꠣꠞꠎꠤꠞ ꠔꠚꠤꠇ ꠅꠘꠥꠎꠣꠄꠁ ꠢꠣꠙ꠆ꠔꠣꠞ ꠙꠄꠟꠣ ꠖꠤꠘ ꠇꠤꠍꠥ ꠐꠦꠇꠣ-ꠙꠄꠡꠣ ꠖꠟꠣ ꠇꠞꠅ, ꠎꠣꠔꠦ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠀꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠇꠥꠘꠥ ꠌꠣꠘ꠆ꠖꠣ ꠔꠥꠟꠣ ꠘꠣ ꠟꠣꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("C116_3","076_16_3","1CO","16","3","3","ꠀꠝꠤ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠟꠣ ꠇꠞꠣ ꠅꠃ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠟꠁꠀ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠛꠣꠄ, ꠀꠝꠤ ꠌꠤꠑꠤ ꠖꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C116_4","076_16_4","1CO","16","4","4","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠝꠘꠅ ꠇꠞꠅ ꠀꠝꠤꠅ ꠎꠣꠅꠀ ꠎꠞꠥꠞ, ꠔꠦ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠎꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C116_5","076_16_5","1CO","16","5","5","ꠀꠝꠣꠞ ꠈꠤꠀꠟ ꠅꠁꠟ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠅꠁꠀ ꠀꠁꠔꠣꠝ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C116_6","076_16_6","1CO","16","6","6","ꠀꠁꠀ ꠢꠄꠔ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠁꠝꠥ ꠛꠣ ꠀꠡ꠆ꠔꠣ ꠡꠤꠔꠇꠣꠟ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦꠃ ꠇꠣꠐꠣꠁꠝꠥ, ꠎꠣꠔꠦ ꠀꠝꠤ ꠎꠦꠘꠅꠃ ꠎꠣꠁ ꠘꠣ ꠇꠦꠘꠦ ꠔꠥꠝꠞꠣꠃ ꠀꠝꠣꠞꠦ ꠅꠃ ꠍꠚꠞꠞ ꠟꠣꠉꠤ ꠢꠇꠟꠔꠣ ꠎꠥꠁꠔ-ꠎꠣꠁꠔ ꠇꠞꠤꠀ ꠖꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C116_7","076_16_7","1CO","16","7","7","ꠙꠕꠞ ꠇꠥꠐꠝꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠤ ꠈꠣꠟꠤ ꠙꠕꠦꠖꠤ ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠅꠁꠟꠦ ꠛꠣꠇ꠆ꠇꠣ ꠇꠄꠖꠤꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C116_8","076_16_8","1CO","16","8","8","ꠅꠁꠟꠦ ꠙꠘ꠆ꠌꠣꠁꠡꠣ ꠁꠖ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠤ ꠅꠃ ꠁꠚꠤꠍ ꠐꠣꠃꠘꠅꠃ ꠞꠁꠝꠥ, ");
INSERT INTO syls_vpl VALUES ("C116_9","076_16_9","1CO","16","9","9","ꠇꠣꠞꠘ ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠅꠃꠟꠣ ꠛꠠ ꠄꠇꠐꠣ ꠡꠥꠎꠥꠉ ꠀꠍꠦ, ꠁ ꠡꠥꠎꠥꠉꠦ ꠛꠠ ꠜꠣꠟꠣ ꠚꠟ ꠝꠤꠟꠦ। ꠔꠣ-ꠅ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠁꠔꠣꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C116_10","076_16_10","1CO","16","10","10","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠔꠤꠝꠕꠤ ꠜꠣꠁ ꠔꠥꠝꠞꠣꠞ ꠅꠘꠅ ꠀꠁꠟꠦ ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠡꠣꠘ꠆ꠔꠤꠄ-ꠘꠤꠞꠜꠄꠄ ꠞꠁꠔꠣ ꠙꠣꠞꠂꠘ। ꠎꠣꠘ ꠔ, ꠀꠝꠤ ꠎꠦꠟꠣ ꠝꠣꠟꠤꠇꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠤꠀꠞ, ꠔꠣꠁꠘꠅ ꠑꠤꠇ ꠅꠃꠟꠣ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C116_11","076_16_11","1CO","16","11","11","ꠄꠞꠟꠣꠉꠤ ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠣꠘꠞꠦ ꠄꠟꠣꠝꠤ ꠘꠣ ꠇꠞꠦ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠅꠃꠟꠣ ꠡꠣꠘ꠆ꠔꠤ ꠝꠔ ꠔꠣꠘꠞꠦ ꠀꠉꠥꠀꠁꠀ ꠖꠤꠅ। ꠀꠝꠤ ꠔ ꠔꠣꠘ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠀꠞ, ꠀꠡꠣ ꠇꠞꠤ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠔꠣꠁꠘꠅ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C116_12","076_16_12","1CO","16","12","12","ꠀꠞ ꠀꠙꠟ꠆ꠟꠍ ꠜꠣꠁꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠣꠘꠞꠦ ꠛꠃꠔ ꠝꠤꠘꠔ ꠇꠞꠍꠟꠣꠝ, ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠅꠁꠀ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠣ, ꠔꠣ-ꠅ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠞꠣꠎꠤ ꠅꠁꠟꠣ ꠘꠣ। ꠔꠦ ꠡꠝꠄ-ꠡꠥꠎꠥꠉ ꠅꠁꠟꠦ ꠛꠣꠖꠦ ꠎꠣꠁꠛꠣꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("C116_13","076_16_13","1CO","16","13","13","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠢꠥꠡꠤꠀꠞ ꠅꠅ, ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠅꠅ, ꠡꠣꠅꠡꠤ ꠜꠣꠛ ꠖꠦꠈꠣꠅ ꠀꠞ ꠛꠟꠛꠣꠘ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("C116_14","076_16_14","1CO","16","14","14","ꠔꠥꠝꠞꠣ ꠎꠔꠔꠣꠃ ꠇꠞ, ꠝꠢꠛ꠆ꠛꠔꠞ ꠡꠢꠤꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("C116_15","076_16_15","1CO","16","15","15","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠔ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠀꠡ꠆ꠔꠣ ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠀꠡ꠆ꠔꠤꠚꠣꠘ ꠜꠣꠁꠞ ꠙꠞꠤꠛꠣꠞꠃ ꠅꠁꠟꠣ ꠙꠄꠟꠣ ꠁꠝꠣꠘꠖꠣꠞ। ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠈꠦꠎꠝꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠘꠤꠎꠞꠦ ꠡꠙꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C116_16","076_16_16","1CO","16","16","16","ꠄꠞꠟꠣꠉꠤ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠁꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠔꠥꠝꠞꠣ ꠁꠎ꠆ꠎꠔꠞ ꠡꠢꠤꠔ ꠜꠎꠤꠅ, ꠀꠞꠅ ꠎꠔ ꠎꠘꠦ ꠅꠟꠣ ꠈꠦꠎꠝꠔ ꠇꠞꠂꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠝꠦꠘꠔ ꠇꠞꠂꠘ, ꠔꠣꠞꠣꠞꠦꠅ ꠅꠟꠣ ꠜꠎꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("C116_17","076_16_17","1CO","16","17","17","ꠅꠃ ꠀꠡ꠆ꠔꠤꠚꠣꠘ ꠜꠣꠁ, ꠚꠣꠔꠥꠘꠣꠔ ꠜꠣꠁ ꠀꠞ ꠀꠇꠤꠇ ꠜꠣꠁ ꠀꠁꠍꠂꠘ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠍꠤ, ꠄꠞꠣ ꠀꠅꠀꠄ ꠔꠥꠝꠞꠣꠞ ꠅꠜꠣꠛ ꠙꠥꠞꠘ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C116_18","076_16_18","1CO","16","18","18","ꠄꠞꠣ ꠀꠝꠣꠞ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠀꠞꠣꠝ ꠖꠤꠍꠂꠘ। ꠔꠥꠝꠞꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠈꠣꠍ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("C116_19","076_16_19","1CO","16","19","19","ꠔꠥꠞꠡ꠆ꠇꠞ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ꠀꠇꠤꠟ ꠀꠞ ꠚꠤꠍꠇꠤꠟꠣ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠊꠞꠞ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠦ ꠝꠣꠟꠤꠇꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠡꠢꠤꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C116_20","076_16_20","1CO","16","20","20","ꠢꠇꠟ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠙꠛꠤꠔ꠆ꠞ ꠉꠟꠣꠉꠟꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("C116_21","076_16_21","1CO","16","21","21","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠘꠤꠎꠞ ꠀꠔꠦ ꠅꠃ ꠍꠣꠟꠣꠝꠞ ꠇꠕꠣ ꠟꠦꠈꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C116_22","076_16_22","1CO","16","22","22","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠎꠥꠖꠤ ꠇꠦꠃ ꠝꠢꠛ꠆ꠛꠔ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠃꠇ। ꠝꠣꠞꠣꠘꠣ ꠕꠣ! ꠝꠣꠘꠤ, ꠅ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ, ꠔꠡꠞꠤꠚ ꠀꠘꠃꠇ꠆ꠇꠣ! ");
INSERT INTO syls_vpl VALUES ("C116_23","076_16_23","1CO","16","23","23","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠞꠢꠝꠔ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠣꠞꠤ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C116_24","076_16_24","1CO","16","24","24","ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠁꠍꠣꠄꠁ ꠝꠢꠛ꠆ꠛꠔ ꠞꠁꠟ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("C21_1","077_1_1","2CO","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤ। ꠇꠞꠤꠘ꠆ꠔ ꠐꠣꠃꠘꠞ ꠁꠍꠣꠄꠁ ꠎꠝꠣꠔ ꠀꠞ ꠀꠡ꠆ꠔꠣ ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠔ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠔꠤꠝꠕꠤꠄ ꠅꠃ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C21_2","077_1_2","2CO","1","2","2","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠘꠣꠎꠤꠟ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("C21_3","077_1_3","2CO","1","3","3","ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ꠔꠣꠁꠘꠃ ꠞꠢꠝꠣꠘꠥꠞ ꠞꠢꠤꠝ ꠀꠟ꠆ꠟꠣ, ꠢꠇ꠆ꠇꠟꠞ ꠖꠤꠟꠞ ꠛꠥꠎ ꠖꠦꠅꠞꠣ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C21_4","077_1_4","2CO","1","4","4","ꠢꠇꠟ ꠎꠣꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠡꠝꠄ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠛꠥꠎ ꠖꠦꠁꠘ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠥꠎ ꠙꠣꠁꠀ, ꠅꠁꠘ꠆ꠘꠞ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠡꠝꠄ ꠀꠝꠞꠣꠅ ꠔꠣꠞꠣꠞꠦ ꠛꠥꠎ ꠖꠤꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C21_5","077_1_5","2CO","1","5","5","ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠛꠃꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀꠞ, ꠅꠃꠟꠣ ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠛꠃꠔ ꠛꠥꠎ-ꠡꠣꠘ꠆ꠔꠤꠅ ꠙꠣꠁꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C21_6","077_1_6","2CO","1","6","6","ꠀꠝꠞꠣ ꠎꠦ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠡꠣꠘ꠆ꠔꠘꠣ ꠀꠞ ꠘꠣꠎꠣꠔꠞ ꠟꠣꠉꠤꠃ ꠇꠞꠤ। ꠔꠥꠝꠞꠣꠞꠦ ꠛꠥꠎ ꠖꠦꠅꠀꠞ ꠘꠤꠅꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠛꠥꠎ ꠖꠦꠁꠘ। ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠅ ꠙꠠꠛꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠞꠣꠞ ꠖꠦꠅꠀ ꠛꠥꠎ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠇꠡ꠆ꠐꠞꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞꠔꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("C21_7","077_1_7","2CO","1","7","7","ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠞꠣꠞ ꠝꠎꠛꠥꠔ ꠄꠇꠤꠘ ꠀꠍꠦ, ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠀꠝꠞꠣꠞ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠅ ꠡꠞꠤꠇ ꠀꠍ, ꠅꠃꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠛꠥꠎ-ꠡꠣꠘ꠆ꠔꠘꠣꠞ ꠝꠣꠎꠦꠅ ꠡꠞꠤꠇ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("C21_8","077_1_8","2CO","1","8","8","ꠔꠥꠞꠡ꠆ꠇꠞ ꠀꠍꠤꠀ ꠖꠦꠡꠅ ꠀꠝꠞꠣ ꠎꠦ ꠝꠍꠤꠛꠔꠅ ꠙꠠꠍꠟꠣꠝ, ꠅꠔꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠔꠣꠝ ꠌꠣꠁ। ꠢꠤꠘꠅ ꠕꠣꠇꠔꠦ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠦ ꠀꠎꠣꠛ ꠀꠁꠍꠤꠟ, ꠅꠃ ꠀꠎꠣꠛ ꠅꠟꠣ ꠝꠣꠞꠣꠔ꠆ꠔꠇ ꠀꠍꠤꠟ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠎꠣꠘꠞ ꠝꠣꠄꠀ ꠍꠣꠠꠤ ꠖꠤꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C21_9","077_1_9","2CO","1","9","9","ꠝꠘꠅ ꠇꠞꠍꠟꠣꠝ, ꠀꠝꠞꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠝꠣꠞꠣ ꠎꠣꠁꠝꠥ। ꠔꠦ ꠀꠝꠞꠣꠞ ꠁ ꠢꠣꠟꠔ ꠅꠁꠍꠤꠟ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠘꠤꠎꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠝꠥꠞ꠆ꠖꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠂꠘ, ꠅꠃ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C21_10","077_1_10","2CO","1","10","10","ꠄꠇ ꠛꠦꠎꠥꠁꠔꠣ ꠝꠃꠔꠞ ꠀꠔ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠍꠂꠘ, ꠀꠞ ꠅꠈꠘꠅ ꠛꠣꠌꠣꠁꠞꠣ। ꠀꠝꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ, ꠔꠣꠁꠘ ꠢꠣꠝꠦꠡꠣꠃ ꠀꠝꠞꠣꠞꠦ ꠅꠟꠣꠈꠣꠘ ꠛꠣꠌꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C21_11","077_1_11","2CO","1","11","11","ꠔꠥꠝꠞꠣꠅ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠞꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠛꠃꠔ ꠎꠘꠞ ꠖꠥꠀꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠝꠞꠣ ꠎꠦ ꠞꠢꠝ ꠙꠣꠁꠍꠤ, ꠅꠔꠣꠞ ꠚꠟ ꠖꠦꠈꠤꠀ ꠛꠃꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C21_12","077_1_12","2CO","1","12","12","ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠟꠁꠀ ꠉꠃꠞꠛ ꠇꠞꠤꠀꠞ, ꠀꠝꠞꠣꠞ ꠛꠤꠛꠦꠇꠦꠅ ꠅꠟꠣ ꠇꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠙꠛꠤꠔ꠆ꠞ ꠀꠞ ꠡꠞꠟ ꠝꠘ ꠟꠁꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠍꠤ, ꠈꠣꠍ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦꠃ ꠇꠣꠐꠣꠁꠍꠤ। ꠁ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠀꠈꠟ-ꠢꠦꠇꠝꠔꠦ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠛꠟꠦ ꠇꠣꠐꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C21_13","077_1_13","2CO","1","13","13","ꠀꠝꠞꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠥꠇꠣꠁ-ꠌꠣꠙꠣꠁ ꠇꠥꠘꠥꠔꠣ ꠟꠦꠈꠤꠀꠞ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠎꠦ ꠟꠦꠈꠣ ꠙꠠꠞꠣꠄ ꠀꠞ ꠛꠥꠎꠞꠣꠄ, ꠈꠣꠟꠤ ꠅꠃ ꠛꠦꠙꠣꠞꠦꠃ ꠟꠦꠈꠤꠀꠞ। ꠀꠞ ꠀꠡꠣ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣꠃ ꠅꠟꠣ ꠛꠥꠎꠣꠔ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C21_14","077_1_14","2CO","1","14","14","ꠀꠍꠟꠦ ꠀꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠕꠥꠠꠣ ꠇꠤꠍꠥ ꠎꠣꠘꠤꠀꠃ, ꠀꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠎꠦꠟꠣ ꠛꠠꠣꠁ ꠇꠞꠞꠣꠄ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠛꠠꠣꠁ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C21_15","077_1_15","2CO","1","15","15","ꠀꠞ ꠅꠃ ꠇꠕꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤꠀ ꠀꠝꠤ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠍꠟꠣꠝ, ꠀꠝꠤ ꠀꠅꠀ-ꠎꠣꠅꠀꠞ ꠙꠕꠅ ꠖꠥꠁꠅꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠝꠥ, ꠉꠦꠟꠦ ꠔꠥꠝꠞꠣ ꠖꠥꠁꠅꠛꠣꠞꠃ ꠞꠢꠝ-ꠘꠤꠀꠝꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C21_16","077_1_16","2CO","1","16","16","ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠍꠟꠣꠝ, ꠝꠣꠇꠤꠖꠘꠤꠀꠔ ꠎꠣꠅꠀꠞ ꠙꠕꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠝꠥ ꠀꠞ ꠢꠘ ꠕꠣꠇꠤ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ, ꠎꠣꠔꠦ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠀꠉꠥꠀꠁꠀ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("C21_17","077_1_17","2CO","1","17","17","ꠅꠁꠟꠦ ꠀꠝꠤ ꠘꠣ ꠀꠅꠀꠄ ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠇꠞꠞꠣꠄ ꠘꠤ, ꠀꠝꠤ ꠁꠔꠣ ꠓꠋ ꠇꠞꠍꠟꠣꠝ? ꠎꠉꠔꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠄꠇꠛꠣꠞ ꠇꠄ “ꠅꠄ, ꠅꠄ” ꠀꠞꠇꠛꠣꠞ ꠇꠄ “ꠘꠣ, ꠘꠣ”, ꠀꠝꠤꠅ ꠅꠟꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C21_18","077_1_18","2CO","1","18","18","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠢꠇ ꠀꠞ ꠈꠣꠐꠤ, ꠁꠈꠣꠘ ꠎꠦꠟꠣ ꠢꠣꠍꠣ, ꠅꠃꠟꠣ ꠄꠅꠈꠣꠘꠅ ꠢꠣꠍꠣ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣꠞ ꠎꠛꠣꠘ ꠄꠇꠛꠣꠞ “ꠅꠄ” ꠀꠞ ꠀꠞꠇꠛꠣꠞ “ꠘꠣ” ꠅꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C21_19","077_1_19","2CO","1","19","19","ꠀꠝꠤ, ꠍꠤꠟꠣꠍ, ꠀꠞ ꠜꠣꠁ ꠔꠤꠝꠕꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤ, ꠢꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠃ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠔꠣꠁꠘ ꠄꠇꠛꠣꠞ “ꠅꠄ” ꠀꠞ ꠄꠇꠛꠣꠞ “ꠘꠣ” ꠘꠣꠄ, ꠔꠣꠁꠘ ꠔ ꠢꠇꠟ ꠡꠝꠄꠃ “ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("C21_20","077_1_20","2CO","1","20","20","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠢꠇꠟ ꠅꠀꠖꠣꠃ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠙꠥꠞꠣ ꠅꠄ। ꠄꠞꠟꠣꠉꠤ ꠝꠥꠘꠣꠎꠣꠔꠞ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛꠞ ꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣ “ꠀꠝꠤꠘ” ꠝꠣꠘꠤ “ꠅꠄ” ꠇꠁ। ");
INSERT INTO syls_vpl VALUES ("C21_21","077_1_21","2CO","1","21","21","ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠁꠘ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠐꠤꠇꠣꠁ ꠞꠣꠈꠍꠂꠘ, ꠔꠣꠘ ꠘꠣꠝ ꠀꠟ꠆ꠟꠣ। ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C21_22","077_1_22","2CO","1","22","22","ꠔꠣꠘ ꠘꠤꠎꠞ ꠗꠘ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣꠞꠦ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠤꠀ ꠞꠣꠈꠍꠂꠘ, ꠀꠞ ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠁꠔꠣꠞ ꠙꠄꠟꠣ ꠇꠤꠡ꠆ꠔꠤ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C21_23","077_1_23","2CO","1","23","23","ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠤꠀ ꠀꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠖꠄꠀ-ꠝꠣꠄꠀ ꠕꠣꠇꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠈꠤꠀꠟꠦ ꠀꠝꠤ ꠇꠞꠤꠘ꠆ꠔ ꠐꠣꠃꠘꠅ ꠎꠣꠅꠀ ꠛꠘ꠆ꠖ ꠞꠣꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C21_24","077_1_24","2CO","1","24","24","ꠀꠝꠞꠣ ꠘꠤꠎꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠝꠣꠟꠤꠇ ꠝꠘꠅ ꠇꠞꠞꠣꠝ ꠘꠣ, ꠛꠞꠋ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠄ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠀ ꠇꠣꠝ ꠇꠞꠞꠣꠝ। ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("C22_1","077_2_1","2CO","2","1","1","ꠄꠞꠟꠣꠉꠤ ꠝꠘꠦ ꠝꠘꠦ ꠑꠤꠇ ꠇꠞꠟꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠖꠥꠈ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C22_2","077_2_2","2CO","2","2","2","ꠇꠣꠞꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠈ ꠖꠤꠟꠦ ꠀꠝꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠛ ꠇꠦ? ꠀꠞ ꠀꠝꠤ ꠎꠣꠞꠣꠞꠦ ꠖꠥꠈ ꠖꠤꠝꠥ, ꠅꠃ ꠔꠥꠝꠞꠣ ꠍꠣꠠꠣ ꠀꠝꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠀꠞ ꠔ ꠇꠦꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C22_3","077_2_3","2CO","2","3","3","ꠀꠝꠣꠞ ꠁꠟꠣ ꠟꠦꠈꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠎꠣꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠣ ꠀꠝꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠇꠕꠣ, ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠣꠘꠥ ꠇꠥꠘꠥ ꠖꠥꠈ ꠘꠣ ꠙꠣꠁ। ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠁ ꠛꠤꠡ꠆ꠛꠣꠡ ꠀꠍꠦ, ꠀꠝꠤ ꠎꠦꠔꠣꠔ ꠈꠥꠡꠤ ꠅꠁꠝꠥ, ꠔꠥꠝꠞꠣꠅ ꠁꠔꠣꠔ ꠈꠥꠡꠤ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C22_4","077_2_4","2CO","2","4","4","ꠀꠝꠣꠞ ꠝꠘꠅ ꠛꠠ ꠖꠥꠈ ꠟꠁꠀ, ꠌꠈꠥꠞ ꠙꠣꠘꠤ ꠚꠣꠟꠣꠁꠀ ꠀꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠍꠟꠣꠝ। ꠀꠍꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠈ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠟꠦꠈꠍꠤ ꠘꠣ, ꠛꠞꠋ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠎꠦ ꠇꠔ ꠝꠢꠛ꠆ꠛꠔ, ꠅꠈꠣꠘ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠟꠦꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C22_5","077_2_5","2CO","2","5","5","ꠀꠝꠣꠞꠦ ꠎꠥꠖꠤ ꠇꠦꠃ ꠖꠥꠈ ꠖꠤꠀ ꠕꠣꠇꠦ, ꠔꠦ ꠢꠦ ꠈꠣꠟꠤ ꠀꠝꠣꠞꠦ ꠘꠣꠄ, ꠕꠥꠠꠣ ꠅꠁꠟꠦꠅ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞꠦꠃ ꠖꠥꠈ ꠖꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C22_6","077_2_6","2CO","2","6","6","ꠔꠥꠝꠞꠣ ꠛꠦꠡꠤꠞ ꠜꠣꠉ ꠎꠘꠦ ꠝꠤꠟꠤꠀ ꠔꠣꠞꠦ ꠎꠦ ꠡꠣꠎꠣ ꠖꠤꠍ, ꠅꠔꠣꠃ ꠔꠣꠞ ꠟꠣꠉꠤ ꠎꠕꠦꠡ꠆ꠐ। ");
INSERT INTO syls_vpl VALUES ("C22_7","077_2_7","2CO","2","7","7","ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠅ, ꠔꠣꠞꠦ ꠛꠥꠎ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠛꠦꠡꠤ ꠖꠥꠈꠦ ꠢꠦ ꠇꠣꠔꠞ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C22_8","077_2_8","2CO","2","8","8","ꠄꠞꠟꠣꠉꠤ ꠈꠣꠍ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠦꠘ ꠔꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞ, ꠁꠔꠣ ꠙꠞꠝꠣꠘ ꠇꠞꠤ ꠖꠦꠈꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("C22_9","077_2_9","2CO","2","9","9","ꠀꠝꠤ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁꠍꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠁꠖ꠆ꠖ ꠀꠍ ꠇꠤ ꠘꠣ, ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C22_10","077_2_10","2CO","2","10","10","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠛꠦꠙꠣꠞꠦ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠤꠟꠣꠅ, ꠔꠦ ꠀꠝꠤꠅ ꠔꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠦꠁ। ꠀꠞ ꠢꠣꠍꠣꠃ ꠎꠥꠖꠤ ꠀꠝꠤ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠚ ꠇꠞꠤꠀ ꠕꠣꠇꠤ, ꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠇꠞꠤꠀꠞ, ");
INSERT INTO syls_vpl VALUES ("C22_11","077_2_11","2CO","2","11","11","ꠎꠣꠔꠦ ꠡꠄꠔꠣꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠗꠥꠇꠣ ꠖꠤꠔ ꠘꠣ ꠙꠣꠞꠦ। ꠔꠣꠞ ꠇꠥ-ꠝꠔꠟꠛꠞ ꠇꠕꠣ ꠔ ꠀꠝꠞꠣꠞ ꠅꠎꠣꠘꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C22_12","077_2_12","2CO","2","12","12","ꠀꠝꠤ ꠔꠞꠥꠀꠍ ꠐꠣꠃꠘꠅ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠉꠤꠀ ꠖꠦꠈꠟꠣꠝ, ꠢꠘꠅ ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠟꠤꠇꠦ ꠀꠝꠣꠞꠦ ꠄꠇꠐꠣ ꠡꠥꠎꠥꠉ ꠇꠞꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C22_13","077_2_13","2CO","2","13","13","ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠔꠤꠔꠣꠍꠞꠦ ꠢꠘꠅ ꠘꠣ ꠙꠣꠅꠀꠄ ꠀꠝꠣꠞ ꠝꠘꠅ ꠈꠥꠛ ꠅꠡꠣꠘ꠆ꠔꠤ ꠀꠍꠤꠟ। ꠄꠞꠟꠣꠉꠤ ꠔꠞꠥꠀꠍ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠛꠤꠖꠣꠄ ꠟꠁꠀ ꠝꠣꠇꠤꠖꠘꠤꠀꠔ ꠉꠦꠟꠣꠝꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("C22_14","077_2_14","2CO","2","14","14","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁ, ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠤꠎꠄꠅꠞ ꠝꠢꠣ ꠚꠥꠞ꠆ꠔꠤꠞ ꠝꠤꠍꠤꠟꠞ ꠟꠉꠦ ꠌꠣꠟꠣꠁꠞꠣ। ꠀꠟ-ꠝꠍꠤꠞꠦ ꠌꠤꠘꠣ ꠔ ꠄꠇ ꠊꠦꠞꠣꠘꠞ ꠟꠣꠈꠣꠘ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠎꠄ-ꠎꠣꠔ꠆ꠞꠣꠄ ꠅꠃ ꠊꠦꠞꠣꠘ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠍꠤꠔ꠆ꠞꠣꠁ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C22_15","077_2_15","2CO","2","15","15","ꠎꠦꠞꠣ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠞꠣ ꠀꠞ ꠎꠦꠞꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠞꠣ, ꠅꠃ ꠖꠥꠁꠅ ꠖꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠅꠁꠟꠣꠝ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇ ꠊꠦꠞꠣꠘ, ꠅꠃ ꠊꠦꠞꠣꠘꠞꠦ ꠀꠟ-ꠝꠍꠤꠄ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠡꠙꠤꠀ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C22_16","077_2_16","2CO","2","16","16","ꠎꠦꠞꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠣꠞ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣꠞ ꠊꠦꠞꠣꠘ ꠅꠁꠟ ꠝꠞꠣꠞ ꠉꠘ꠆ꠖ, ꠎꠣꠞ ꠚꠟ ꠅꠁꠟ ꠘꠤꠌ꠆ꠌꠤꠔ ꠝꠞꠘ। ꠀꠞ ꠎꠦꠞꠣ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠞꠣ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠅꠁꠟꠣꠝ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠊꠦꠞꠣꠘ, ꠄꠞ ꠚꠟ ꠅꠁꠟ ꠀꠈꠦꠞꠣꠔꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ꠁ ꠅꠔ ꠛꠠ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠈ ꠇꠥꠘ ꠎꠘ? ");
INSERT INTO syls_vpl VALUES ("C22_17","077_2_17","2CO","2","17","17","ꠘꠤꠎꠞ ꠟꠣꠜꠞ ꠟꠣꠉꠤ ꠎꠦꠟꠣ ꠛꠃꠔ ꠎꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠟꠁꠀ ꠛꠦꠛꠡꠣ ꠇꠞꠦ, ꠀꠝꠞꠣ ꠔ ꠁꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ। ꠀꠝꠞꠣ ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠑꠣꠁꠟ ꠎꠘ ꠢꠤꠡꠣꠛꠦ ꠡꠞꠟ ꠝꠘꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠀꠟ꠆ꠟꠣꠞꠦ ꠀꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠞꠣꠈꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C23_1","077_3_1","2CO","3","1","1","ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠝꠘꠅ ꠇꠞꠅ, ꠀꠝꠞꠣ ꠁꠔꠣ ꠇꠁꠀ ꠢꠤꠞꠛꠣꠞ ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠡꠥꠘꠣꠝ ꠉꠣꠅꠀꠔ ꠟꠣꠉꠍꠤ ꠘꠤ? ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠎꠦꠟꠣ ꠅꠁꠘ꠆ꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠍꠘꠖ ꠘꠦꠅꠀ ꠟꠣꠉꠦ, ꠀꠝꠞꠣꠅ ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠛꠣ ꠔꠥꠝꠞꠣ ꠕꠣꠇꠤ ꠍꠘꠖ ꠙꠣꠅꠀ ꠟꠣꠉꠛ ꠘꠤ? ꠘꠣ, ꠝꠥꠐꠦꠃ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C23_2","077_3_2","2CO","3","2","2","ꠔꠥꠝꠞꠣꠞ ꠘꠣꠝ ꠔ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠥꠝꠞꠣꠃ ꠅꠁꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠍꠘꠖ। ꠀꠞ ꠅꠃ ꠍꠘꠖꠞ ꠇꠕꠣ ꠔ ꠢꠇꠟꠦꠃ ꠎꠣꠘꠦ ꠀꠞ ꠢꠇꠟꠦꠃ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("C23_3","077_3_3","2CO","3","3","3","ꠁꠈꠣꠘ ꠔ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠟ-ꠝꠍꠤꠞ ꠟꠦꠈꠣ ꠍꠘꠖ ꠅꠁꠟꠣꠄ ꠔꠥꠝꠞꠣꠃ, ꠔꠥꠝꠞꠣꠃ ꠀꠝꠞꠣꠞ ꠝꠦꠘꠔꠞ ꠚꠟ। ꠁ ꠍꠘꠖ ꠔ ꠇꠥꠘꠥ ꠇꠣꠟꠤ-ꠇꠟꠝ ꠖꠤꠀ ꠟꠦꠈꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠀ ꠟꠦꠈꠣ ꠅꠁꠍꠦ। ꠁꠈꠣꠘ ꠔ ꠔꠥꠞ ꠙꠣꠠꠅ ꠙꠣꠅꠀ ꠡꠞꠤꠅꠔꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠟꠦꠈꠣ ꠘꠣꠄ, ꠛꠞꠋ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦꠃ ꠟꠦꠈꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C23_4","077_3_4","2CO","3","4","4","ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠌ꠆ꠌꠄꠅꠔꠣ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("C23_5","077_3_5","2CO","3","5","5","ꠔꠣ-ꠅ ꠀꠝꠞꠣ ꠎꠦ ꠘꠤꠎꠞ ꠉꠥꠘꠦ ꠢꠇꠟꠔꠣ ꠇꠞꠤꠟꠔꠣꠝ ꠙꠣꠞꠝꠥ, ꠁꠟꠣ ꠇꠥꠘꠥ ꠇꠕꠣ ꠘꠣꠄ। ꠁ ꠈꠦꠎꠝꠔꠤ ꠉꠥꠘ ꠔ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C23_6","077_3_6","2CO","3","6","6","ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞꠦ ꠁ ꠈꠦꠎꠝꠔꠤ ꠉꠥꠘ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ꠁ ꠃꠍꠤꠟ꠆ꠟꠣ ꠔ ꠅꠇ꠆ꠇꠞꠦ ꠅꠇ꠆ꠇꠞꠦ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠣꠞ ꠛꠦꠙꠣꠞ ꠘꠣꠄ, ꠛꠞꠋ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠙꠞꠤꠌꠣꠟꠘꠣꠄ ꠖꠤꠟꠞ ꠁꠝꠣꠘ-ꠀꠇꠤꠖꠣꠞ ꠛꠦꠙꠣꠞ। ꠇꠣꠞꠘ ꠅꠇ꠆ꠇꠞꠦ ꠝꠃꠔ, ꠀꠞ ꠞꠥꠢꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("C23_7","077_3_7","2CO","3","7","7","ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠟꠦꠈꠣ ꠡꠞꠤꠅꠔꠤ ꠎꠦ ꠈꠦꠎꠝꠔꠦ ꠝꠞꠘ ꠀꠄ, ꠅꠃ ꠡꠞꠤꠅꠔ ꠘꠣꠎꠤꠟꠞ ꠡꠝꠄ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠁꠍꠤꠟ। ꠅꠃ ꠡꠝꠄ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠌꠦꠢꠣꠞꠣꠅ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣꠄ ꠘꠥꠞꠣꠘꠤ ꠅꠁꠉꠦꠍꠤꠟ। ꠔꠣꠘ ꠝꠥꠈꠞ ꠘꠥꠞꠣꠘꠤ ꠍꠥꠞꠔ ꠎꠥꠖꠤꠅ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠇꠝꠤ ꠎꠣꠅꠀ ꠗꠞꠍꠤꠟ, ꠔꠦꠛꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠦ ꠔꠣꠘ ꠌꠦꠢꠣꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠅꠀꠞ ꠔꠣꠇ꠆ꠇꠔ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C23_8","077_3_8","2CO","3","8","8","ꠅꠃ ꠡꠞꠤꠅꠔꠞ ꠈꠦꠎꠝꠔꠤ ꠚꠟ ꠎꠥꠖꠤ ꠅꠔ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ ꠅꠄ, ꠔꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠈꠦꠎꠝꠔꠤ ꠚꠟ ꠇꠔ ꠛꠦꠡꠤ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("C23_9","077_3_9","2CO","3","9","9","ꠅꠃ ꠎꠦ ꠅꠇ꠆ꠇꠞꠤ ꠡꠞꠤꠅꠔꠦ ꠝꠣꠘꠡꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠦ, ꠔꠣꠞ ꠈꠦꠎꠝꠔꠤ ꠇꠣꠝ ꠎꠥꠖꠤ ꠅꠔ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ ꠅꠄ, ꠔꠦ ꠎꠦ ꠈꠦꠎꠝꠔꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠇꠁꠀ ꠉꠁꠘ꠆ꠘ ꠇꠞꠦ, ꠁ ꠈꠦꠎꠝꠔ ꠔ ꠀꠞꠅ ꠇꠔ ꠛꠦꠡꠤ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("C23_10","077_3_10","2CO","3","10","10","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠉꠦ ꠎꠦꠔꠣ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ ꠀꠍꠤꠟ, ꠅꠈꠘ ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠝꠢꠤꠝꠣ ꠘꠣꠁ ꠇꠁꠟꠦꠃ ꠌꠟꠦ, ꠔꠣꠞ ꠔꠥꠟꠘꠣꠄ ꠅꠈꠘꠇꠥꠞ ꠘꠄꠀ ꠈꠦꠎꠝꠔꠞ ꠝꠢꠤꠝꠣ ꠛꠃꠔ ꠛꠦꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("C23_11","077_3_11","2CO","3","11","11","ꠎꠦ ꠘꠥꠞꠣꠘꠤꠞ ꠔꠦꠎ ꠇꠝꠣ ꠗꠞꠍꠤꠟ, ꠁꠔꠣ ꠎꠦꠛꠟꠣ ꠅꠔ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ, ꠔꠦ ꠎꠦꠔꠣ ꠌꠤꠞꠇꠣꠟ ꠞꠁꠛ, ꠁꠔꠣ ꠔ ꠀꠞꠅ ꠇꠔ ꠛꠦꠡꠤ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ! ");
INSERT INTO syls_vpl VALUES ("C23_12","077_3_12","2CO","3","12","12","ꠀꠝꠞꠣꠞ ꠝꠘꠅ ꠅꠟꠣꠈꠣꠘ ꠀꠡꠣ ꠀꠍꠦ ꠉꠔꠤꠇꠦꠃ ꠀꠝꠞꠣ ꠈꠥꠟꠣ-ꠈꠥꠟꠤ ꠝꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("C23_13","077_3_13","2CO","3","13","13","ꠀꠝꠞꠣ ꠔ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ, ꠔꠣꠁꠘ ꠙꠞ꠆ꠖꠣ ꠖꠤꠀ ꠔꠣꠘ ꠝꠥꠈ ꠉꠥꠞꠤꠀ ꠕꠁꠍꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠝꠥꠈꠞ ꠇꠝꠤ ꠎꠣꠅꠀ ꠘꠥꠞꠣꠘꠤ ꠍꠥꠞꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠘꠣ ꠖꠦꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C23_14","077_3_14","2CO","3","14","14","ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠙꠣꠡꠣꠘ ꠅꠁꠉꠦꠍꠤꠟ। ꠀꠞ ꠅꠈꠘꠅ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠅ ꠟꠦꠈꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠢꠃ ꠙꠥꠞꠣꠘꠣ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠇꠕꠣ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠟꠦ, ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠙꠞ꠆ꠖꠣ ꠕꠣꠇꠦ। ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠦ ꠅꠃ ꠙꠞ꠆ꠖꠣ ꠢꠞꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C23_15","077_3_15","2CO","3","15","15","ꠀꠞ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠣꠞ ꠡꠝꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟꠞ ꠖꠤꠟ ꠙꠞ꠆ꠖꠣ ꠖꠤꠀ ꠉꠥꠞꠣ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("C23_16","077_3_16","2CO","3","16","16","ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠎꠦꠛꠟꠣ ꠝꠣꠟꠤꠇꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠙꠞ꠆ꠖꠣ ꠢꠞꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C23_17","077_3_17","2CO","3","17","17","ꠅꠃ ꠝꠣꠟꠤꠇ ꠅꠁꠟꠣ ꠙꠣꠇ ꠞꠥꠢꠥ, ꠀꠞ ꠝꠣꠟꠤꠇꠞ ꠞꠥꠢꠥ ꠎꠦꠘꠅ ꠀꠍꠦ, ꠅꠘꠅꠃ ꠡ꠆ꠛꠣꠗꠤꠘꠔꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C23_18","077_3_18","2CO","3","18","18","ꠀꠄꠘꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠦꠟꠣ ꠙꠞ꠆ꠖꠣ ꠍꠣꠠꠣ ꠝꠥꠈ ꠡꠞꠣꠡꠞꠤ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠅꠃꠟꠣ ꠀꠝꠞꠣ ꠢꠇꠟꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠥꠞꠣꠘꠤ ꠝꠢꠤꠝꠣ ꠖꠦꠈꠤ ꠖꠦꠈꠤ ꠀꠞꠅ ꠛꠦꠡꠤ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ ꠛꠘꠤꠀ ꠔꠣꠘ ꠟꠣꠈꠣꠘ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ ꠅꠁꠞꠣꠝ। ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ, ꠝꠣꠘꠤ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦꠃ ꠁꠟꠣ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("C24_1","077_4_1","2CO","4","1","1","ꠅꠃ ꠇꠣꠞꠘꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠤꠀ ꠅꠃ ꠘꠄꠀ ꠈꠦꠎꠝꠔꠤ ꠇꠣꠝꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠝꠞꠣꠞ ꠀꠔꠅ ꠖꠤꠍꠂꠘ ꠇꠞꠤ, ꠀꠝꠞꠣ ꠘꠤꠞꠣꠡ ꠅꠁ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C24_2","077_4_2","2CO","4","2","2","ꠔꠛꠟꠤꠉ ꠇꠣꠝꠅ ꠝꠣꠘꠡꠦ ꠟꠥꠇꠣꠁꠀ ꠎꠦꠔꠣ ꠛꠦꠢꠣꠄꠀꠝꠤ ꠇꠞꠂꠘ, ꠁꠔꠣ ꠀꠝꠞꠣ ꠝꠥꠐꠦꠃ ꠇꠞꠤ ꠘꠣ। ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠇꠣꠝꠅ ꠍꠟ-ꠌꠔꠥꠞꠤ ꠇꠞꠤ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠜꠦꠎꠣꠟ ꠝꠤꠡꠣꠁ ꠘꠣ। ꠛꠞꠋ ꠢꠇ ꠇꠕꠣꠞꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠇꠁꠀ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣꠞꠦ ꠎꠁꠉ꠆ꠉ ꠢꠤꠡꠣꠛꠦ ꠙꠞꠝꠣꠘ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C24_3","077_4_3","2CO","4","3","3","ꠀꠝꠞꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠎꠥꠖꠤ ꠟꠥꠇꠣꠁꠟ ꠕꠣꠇꠦ, ꠔꠦ ꠟꠣꠘ꠆ꠘꠔꠤ ꠙꠕꠦ ꠎꠦꠞꠣ ꠎꠣꠁꠞꠣ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦꠃ ꠟꠥꠇꠣꠁꠟ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("C24_4","077_4_4","2CO","4","4","4","ꠅꠃ ꠎꠉꠔꠞ ꠖꠦꠛꠔꠣ ꠁꠛꠟꠤꠍꠦ ꠅ-ꠁꠝꠣꠘꠖꠣꠞ ꠅꠇꠟꠞ ꠖꠤꠟꠞꠦ ꠀꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠤꠍꠦ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠘꠥꠞ ꠘꠣ ꠖꠦꠈꠦ। ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠝꠣꠎꠖꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠃꠞꠛ ꠎꠣꠁꠞ ꠅꠁꠍꠦ, ꠀꠞ ꠅꠃ ꠀꠟ-ꠝꠍꠤꠃ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠅꠛꠤꠇꠟ ꠍꠥꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("C24_5","077_4_5","2CO","4","5","5","ꠀꠝꠞꠣ ꠔ ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ ꠘꠣ, ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ, ꠔꠣꠁꠘꠃ ꠝꠣꠟꠤꠇ, ꠔꠣꠘ ꠟꠣꠉꠤꠃ ꠀꠝꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C24_6","077_4_6","2CO","4","6","6","ꠀꠝꠞꠣ ꠁꠔꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ, ꠇꠣꠞꠘ ꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠍꠂꠘ, “ꠀꠘ꠆ꠖꠣꠁꠞ ꠕꠣꠇꠤ ꠚꠞ ꠅꠃꠇ,” ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠣꠘ ꠘꠥꠞ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠣꠟꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠌꠦꠢꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠞ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C24_7","077_4_7","2CO","4","7","7","ꠀꠟ꠆ꠟꠣꠁ ꠅꠃ ꠘꠥꠞꠞ ꠗꠘ ꠔ ꠝꠣꠐꠤꠞ ꠛꠣꠡꠘꠅ ꠞꠣꠈꠣ ꠅꠁꠍꠦ, ꠅꠃ ꠛꠣꠡꠘ ꠅꠁꠟꠣꠝ ꠀꠝꠞꠣꠃ। ꠝꠣꠐꠤꠞ ꠛꠣꠡꠘꠅ ꠞꠣꠈꠣ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠔ ꠙꠣꠞꠦ ꠅꠃ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠣꠡꠇ꠆ꠔꠤ ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C24_8","077_4_8","2CO","4","8","8","ꠢꠇꠟꠛꠣꠄ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠃꠔ ꠟꠣꠈꠣꠘ ꠌꠣꠙ ꠀꠁꠟꠦꠅ, ꠀꠝꠞꠣ ꠌꠥꠞꠝꠣꠞ ꠅꠁꠍꠤ ꠘꠣ। ꠀꠝꠞꠣ ꠛꠦꠖꠤꠡꠣ ꠟꠣꠉꠟꠦꠅ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠞꠣꠡ ꠅꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C24_9","077_4_9","2CO","4","9","9","ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠣ ꠅꠁꠟꠦꠅ ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠀꠝꠞꠣꠞ ꠟꠉ ꠍꠣꠠꠍꠂꠘ ꠘꠣ। ꠝꠣꠐꠤꠔ ꠚꠣꠟꠣꠁꠀ ꠀꠍꠣꠠꠟꠦꠅ ꠀꠝꠞꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C24_10","077_4_10","2CO","4","10","10","ꠢꠣꠝꠦꠡꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠝꠃꠔꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠘꠤꠡꠣꠘꠣ ꠀꠝꠞꠣꠞ ꠡꠞꠤꠟꠅ ꠟꠁꠀ ꠊꠥꠞꠤꠀꠞ, ꠎꠣꠔꠦ ꠀꠝꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠅ ꠖꠦꠈꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C24_11","077_4_11","2CO","4","11","11","ꠀꠞ ꠀꠝꠞꠣ ꠎꠔ ꠡꠝꠄ ꠛꠣꠌꠤꠀ ꠀꠍꠤ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞꠦ ꠔ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠃ ꠝꠃꠔꠞ ꠀꠔꠅ ꠔꠥꠟꠤ ꠖꠦꠅꠀ ꠅꠞ, ꠎꠣꠔꠦ ꠅꠃ ꠝꠃꠔꠞ ꠅꠗꠤꠘ ꠡꠞꠤꠟꠅ ꠔꠣꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠎꠣꠁꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C24_12","077_4_12","2CO","4","12","12","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠣꠝ ꠇꠞꠦꠞ ꠝꠃꠔꠦ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠣꠝ ꠇꠞꠦꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠄ। ");
INSERT INTO syls_vpl VALUES ("C24_13","077_4_13","2CO","4","13","13","ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, “ꠀꠝꠤ ꠁꠝꠣꠘ ꠀꠘꠍꠤ ꠉꠔꠤꠇꠦꠃ ꠇꠁꠟꠣꠝ।” ꠅꠃ ꠄꠇꠁ ꠁꠝꠣꠘꠞ ꠜꠣꠉꠤ ꠅꠁꠀ ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠇꠁ। ");
INSERT INTO syls_vpl VALUES ("C24_14","077_4_14","2CO","4","14","14","ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠟꠣ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠟꠉꠦ ꠀꠝꠞꠣꠞꠦꠅ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠛꠣ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C24_15","077_4_15","2CO","4","15","15","ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤꠃ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠞꠢꠝꠔ ꠘꠣꠎꠤꠟ ꠅꠁꠍꠦ, ꠢꠃ ꠞꠢꠝꠔꠞ ꠈꠣꠔꠤꠞꠦ ꠛꠃꠔꠦ ꠀꠞꠅ ꠛꠦꠡꠤ ꠇꠞꠤ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠦ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C24_16","077_4_16","2CO","4","16","16","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠘꠤꠞꠣꠡ ꠅꠁ ꠘꠣ। ꠎꠥꠖꠤꠅ ꠀꠝꠞꠣꠞ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠡꠞꠤꠟ ꠇ꠆ꠇꠄ ꠅꠁꠎꠣꠞ, ꠔꠦꠛꠃ ꠀꠝꠞꠣꠞ ꠞꠥꠢꠥ ꠖꠤꠘ ꠖꠤꠘ ꠔꠣꠎꠣ ꠅꠁꠀ ꠃꠑꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("C24_17","077_4_17","2CO","4","17","17","ꠅꠈꠘ ꠀꠝꠞꠣ ꠎꠦ ꠇꠄꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠡꠣꠝꠣꠁꠘ꠆ꠘ ꠇꠡ꠆ꠐ ꠇꠞꠤꠀꠞ, ꠁ ꠇꠡ꠆ꠐꠞ ꠛꠖꠟꠣ ꠀꠝꠞꠣ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠅꠚꠥꠞꠘ꠆ꠔ ꠡꠣꠘ-ꠝꠢꠤꠝꠣ ꠟꠣꠜ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C24_18","077_4_18","2CO","4","18","18","ꠌꠃꠈꠖꠤ ꠎꠦꠔꠣ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠀꠝꠞꠣ ꠔ ꠁꠔꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠞꠣꠝ ꠘꠣ, ꠛꠞꠋ ꠎꠦꠔꠣ ꠖꠦꠈꠣ ꠎꠣꠄ ꠘꠣ, ꠅꠔꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠞꠣꠝ। ꠌꠃꠈꠦ ꠎꠦꠔꠣ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠁꠔꠣ ꠔ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘꠞ, ꠅꠁꠟꠦ ꠎꠦꠔꠣ ꠖꠦꠈꠣ ꠎꠣꠄ ꠘꠣ, ꠁꠔꠣ ꠌꠤꠞꠇꠣꠟꠞ। ");
INSERT INTO syls_vpl VALUES ("C25_1","077_5_1","2CO","5","1","1","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠝꠞꠣ ꠁ ꠖꠥꠘꠤꠀꠛꠤ ꠎꠦ ꠒꠦꠞꠣ-ꠊꠞꠅ ꠛꠡꠔ ꠇꠞꠤ, ꠝꠣꠘꠤ ꠎꠦ ꠇꠝꠎꠥꠞ ꠡꠞꠤꠟ ꠟꠁꠀ ꠀꠍꠤ, ꠁꠈꠣꠘ ꠎꠥꠖꠤ ꠛꠤꠘꠣꠡꠅ ꠅꠁꠎꠣꠄ, ꠔꠦꠛꠃ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠄꠇꠈꠣꠘ ꠊꠞ ꠀꠝꠞꠣꠞ ꠀꠍꠦ। ꠁ ꠊꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠘꠣꠄ, ꠁꠈꠣꠘ ꠔ ꠢꠣꠝꠦꠡꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C25_2","077_5_2","2CO","5","2","2","ꠅꠃ ꠒꠦꠞꠣ-ꠊꠞꠅ ꠛꠡꠔ ꠇꠞꠣ ꠢꠣꠟꠔꠦ ꠀꠝꠞꠣ ꠟꠣꠝ꠆ꠛꠣ ꠇꠞꠤ ꠖꠝ ꠚꠣꠟꠣꠁꠀꠞ ꠀꠞ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠡꠣ ꠇꠞꠤꠀꠞ, ꠎꠣꠔꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠢꠃ ꠘꠄꠀ ꠊꠞꠞ ꠝꠣꠎꠦ ꠀꠝꠞꠣꠞꠦ ꠉꠥꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C25_3","077_5_3","2CO","5","3","3","ꠔꠣ-ꠅ ꠇꠕꠣ ꠅꠁꠟ, ꠅꠃ ꠒꠦꠞꠣ-ꠊꠞ ꠜꠣꠋꠉꠣꠞ ꠛꠣꠖꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠣꠘꠥ ꠟꠦꠝꠐꠣ ꠖꠦꠈꠣ ꠘꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C25_4","077_5_4","2CO","5","4","4","ꠅꠃ ꠒꠦꠞꠣ-ꠊꠞꠅ ꠞꠁꠀ ꠜꠣꠞ-ꠛꠥꠏꠣ ꠛꠁꠔꠦ ꠛꠁꠔꠦ ꠀꠝꠞꠣ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠤꠀꠞ। ꠄꠞꠛꠣꠖꠦꠅ ꠀꠝꠞꠣ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠁ ꠒꠦꠞꠣ-ꠊꠞ ꠍꠣꠠꠔꠣꠝ ꠌꠣꠁ ꠘꠣ, ꠔꠣ-ꠅ ꠜꠣꠟꠣ ꠊꠞꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠞꠣꠝ, ꠎꠣꠔꠦ ꠅꠈꠘꠇꠥꠞ ꠅꠃ ꠝꠃꠔꠞ ꠅꠗꠤꠘ ꠒꠦꠞꠣ-ꠊꠞ ꠚꠣꠟꠣꠁꠀ, ꠌꠤꠞꠇꠣꠟ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠣꠞ ꠎꠥꠇꠣ ꠊꠞ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C25_5","077_5_5","2CO","5","5","5","ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠎꠥꠁꠔ ꠇꠞꠍꠂꠘ ꠀꠞ ꠁꠔꠣꠞ ꠛꠣꠄꠘꠣꠝꠣ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C25_6","077_5_6","2CO","5","6","6","ꠄꠞꠖꠣꠄ ꠀꠝꠞꠣꠞ ꠡꠣꠅꠡꠞ ꠇꠥꠘꠥ ꠇꠝꠔꠤ ꠘꠣꠁ। ꠀꠝꠞꠣ ꠔ ꠛꠥꠎꠤꠟꠤꠍꠤ, ꠎꠔꠖꠤꠘ ꠅꠃ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠡꠞꠤꠟ ꠟꠁꠀ ꠛꠡꠔ ꠇꠞꠝꠥ, ꠅꠔꠖꠤꠘ ꠀꠝꠞꠣ ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C25_7","077_5_7","2CO","5","7","7","ꠀꠝꠞꠣ ꠔ ꠌꠈꠥꠞ ꠖꠦꠈꠣ ꠇꠥꠘ꠆ꠔꠣꠞ ꠜꠞꠡꠣꠄ ꠌꠟꠤ ꠘꠣ, ꠈꠣꠟꠤ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠌꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("C25_8","077_5_8","2CO","5","8","8","ꠀꠍꠟꠦ ꠀꠝꠞꠣꠞ ꠜꠤꠔꠞ ꠜꠞꠣ ꠡꠣꠅꠡ ꠀꠍꠦ, ꠀꠞ ꠀꠝꠞꠣ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠡꠞꠤꠟꠅ ꠞꠅꠀ ꠕꠣꠇꠤ ꠝꠣꠟꠤꠇꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠣꠈꠣꠘꠃ ꠜꠣꠟꠣ ꠝꠘꠅ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C25_9","077_5_9","2CO","5","9","9","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠡꠞꠤꠟꠞ ꠝꠣꠎꠦ ꠕꠣꠇꠤ ꠛꠣ ꠘꠣ ꠕꠣꠇꠤ, ꠀꠝꠞꠣꠞ ꠘꠤꠅꠔ ꠅꠁꠟ ꠝꠣꠟꠤꠇꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C25_10","077_5_10","2CO","5","10","10","ꠇꠣꠞꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠖꠣꠟꠔꠅ ꠀꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠃꠛꠣꠘꠤ ꠟꠣꠉꠛ, ꠎꠣꠔꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠅꠃ ꠡꠞꠤꠟꠦ ꠀꠝꠞꠣ ꠎꠔ ꠘꠝꠥꠘꠣꠞ ꠛꠣꠖ-ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠍꠤ, ꠅꠃ ꠇꠣꠝꠞ ꠛꠖꠟꠣ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C25_11","077_5_11","2CO","5","11","11","ꠀꠝꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠒꠞꠣꠁꠀ ꠌꠟꠤ, ꠄꠞꠟꠣꠉꠤ ꠝꠣꠘꠡꠞꠦ ꠛꠥꠎꠣꠘꠤꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠞꠣꠝ। ꠀꠝꠞꠣꠞ ꠛꠦꠙꠣꠞ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠙꠞꠤꠡ꠆ꠇꠣꠞ, ꠀꠡꠣ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦꠅ ꠅꠟꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠀꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C25_12","077_5_12","2CO","5","12","12","ꠁꠈꠣꠘ ꠇꠁꠀ ꠀꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠘꠤꠎꠞ ꠔꠣꠞꠤꠚ ꠉꠣꠁꠞꠣꠝ ꠘꠣ, ꠛꠞꠋ ꠀꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠠꠣꠁꠞ ꠇꠣꠞꠘ ꠎꠣꠘꠣꠁꠞꠣꠝ। ꠔꠦ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠜꠤꠔꠞ ꠘꠣ ꠖꠦꠈꠤꠀ, ꠈꠣꠟꠤ ꠝꠣꠘꠡꠞ ꠛꠣꠞꠉꠣꠟꠣ ꠟꠁꠀ ꠛꠠꠣꠁ ꠇꠞꠦ, ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠄꠇꠐꠣ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C25_13","077_5_13","2CO","5","13","13","ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠙꠣꠉꠟ ꠅꠁ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠉꠟ ꠅꠁꠍꠤ, ꠀꠞ ꠎꠥꠖꠤ ꠝꠣꠕꠣ ꠜꠣꠟꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠜꠣꠟꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C25_14","077_5_14","2CO","5","14","14","ꠀꠟ-ꠝꠍꠤꠞ ꠝꠢꠛ꠆ꠛꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠙꠥꠡ ꠝꠣꠘꠣꠁꠀ ꠌꠣꠟꠣꠄ। ꠀꠝꠞꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠛꠥꠎꠍꠤ, ꠢꠇꠟꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠄꠇꠎꠘꠞ ꠝꠃꠔ ꠅꠁꠍꠤꠟ, ꠄꠞꠟꠣꠉꠤ ꠢꠇꠟꠞꠃ ꠝꠃꠔ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C25_15","077_5_15","2CO","5","15","15","ꠔꠣꠁꠘ ꠢꠇꠟꠞ ꠟꠣꠉꠤ ꠝꠣꠞꠣ ꠉꠦꠍꠟꠣ, ꠎꠣꠔꠦ ꠎꠦꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠀꠞ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠘꠣ ꠛꠣꠌꠂꠘ। ꠛꠞꠋ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠍꠟꠣ ꠀꠞ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍꠟꠣ, ꠔꠣꠘ ꠟꠣꠉꠤꠃ ꠔꠣꠞꠣ ꠛꠣꠌꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C25_16","077_5_16","2CO","5","16","16","ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘ ꠕꠣꠇꠤ ꠀꠝꠞꠣ ꠀꠞ ꠝꠣꠘꠡꠞ ꠛꠣꠁꠞꠞ ꠍꠥꠞꠔ ꠖꠦꠈꠤꠀ ꠛꠤꠌꠣꠞ ꠇꠞꠤ ꠘꠣ। ꠀꠝꠞꠣ ꠔ ꠀꠉꠦ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠅꠟꠣꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠞ ꠁꠟꠣ ꠇꠞꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C25_17","077_5_17","2CO","5","17","17","ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣ ꠇꠛꠥꠟ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠘꠄꠀ ꠙꠄꠖꠣ ꠅꠁꠟ। ꠔꠣꠞ ꠙꠥꠞꠣꠘ ꠢꠇꠟꠔꠣ ꠚꠥꠍꠤꠀ ꠢꠣꠞꠤ ꠄꠇ꠆ꠇꠦꠞꠦ ꠘꠄꠀ ꠛꠘꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("C25_18","077_5_18","2CO","5","18","18","ꠁꠔꠣ ꠔ ꠀꠟ꠆ꠟꠣ ꠕꠣꠇꠤꠃ ꠅꠄ। ꠔꠣꠁꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠝꠤꠟꠘ ꠊꠐꠣꠁꠍꠂꠘ, ꠀꠞ ꠀꠝꠞꠣꠞꠦ ꠅꠃ ꠈꠦꠎꠝꠔꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠤꠍꠂꠘ, ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠘ ꠟꠉꠦ ꠝꠤꠟꠣꠁ ꠖꠤꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C25_19","077_5_19","2CO","5","19","19","ꠄꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠛꠣꠄ ꠘꠣ ꠌꠣꠁꠀ, ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠟꠉꠦ ꠝꠣꠘꠡꠞ ꠝꠤꠟꠘ ꠊꠐꠣꠁꠍꠂꠘ। ꠀꠞ ꠅꠃ ꠝꠤꠟꠘꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C25_20","077_5_20","2CO","5","20","20","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠁꠛ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠘ ꠙꠇ꠆ꠇꠦ ꠝꠣꠔꠤꠞꠣꠝ। ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠄꠃ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠝꠣꠘꠡꠞꠦ ꠝꠤꠘꠔꠤ ꠇꠞꠞꠣ। ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠙꠇ꠆ꠇꠦ ꠀꠝꠞꠣꠅ ꠝꠤꠘꠔ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠔ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("C25_21","077_5_21","2CO","5","21","21","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔ ꠇꠥꠘꠥ ꠉꠥꠘꠣ-ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠍꠂꠘ ꠘꠣ। ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠢꠇꠟꠞ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠅ ꠔꠥꠟꠤ ꠖꠤꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠁ ꠙꠛꠤꠔ꠆ꠞꠔꠣꠄ ꠀꠝꠞꠣ ꠙꠞꠦꠎꠉꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("C26_1","077_6_1","2CO","6","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠖꠤꠝ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣ ꠅꠃ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠙꠣꠁꠍ, ꠔꠦ ꠁꠇꠐꠣꠞꠦ ꠛꠤꠚꠟ ꠅꠁꠔꠦ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C26_2","077_6_2","2CO","6","2","2","ꠙꠣꠇ ꠇꠣꠟꠣꠝꠅ ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠀꠝꠤ ꠡꠑꠤꠇ ꠡꠝꠄꠄ ꠔꠥꠝꠣꠞ ꠀꠞꠎꠤ ꠢꠥꠘꠍꠤ, ꠘꠣꠎꠣꠔ ꠙꠣꠅꠀꠞ ꠖꠤꠘ ꠔꠥꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠍꠤ। ꠢꠥꠘꠅ, ꠅꠈꠘꠃ ꠡꠑꠤꠇ ꠡꠝꠄ, ꠅꠈꠘꠃ ꠘꠣꠎꠣꠔ ꠙꠣꠅꠀꠞ ꠖꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("C26_3","077_6_3","2CO","6","3","3","ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠀꠝꠞꠣ ꠎꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠤ, ꠅꠃ ꠔꠛꠟꠤꠉꠞ ꠛꠖꠘꠣꠝ ꠘꠣ ꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠁꠟꠣ ꠇꠥꠘꠥ ꠇꠣꠝ ꠇꠞꠤ ꠘꠣ, ꠎꠦ ꠇꠣꠝꠦ ꠝꠣꠘꠡꠞ ꠝꠘꠅ ꠛꠣꠗꠣ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("C26_4","077_6_4","2CO","6","4","4","ꠛꠞꠋ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠞꠣꠝ, ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠦꠎꠝꠔꠇꠣꠞꠤ। ꠛꠃꠔ ꠖꠥꠈ-ꠇꠡ꠆ꠐ, ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ, ꠀꠞ ꠛꠤꠙꠖ-ꠀꠙꠖ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀ ꠁꠔꠣꠞ ꠙꠞꠝꠣꠘ ꠖꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C26_5","077_6_5","2CO","6","5","5","ꠀꠝꠞꠣꠞꠦ ꠛꠃꠔ ꠛꠣꠞ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠛꠃꠔ ꠛꠣꠞ ꠎꠦꠟꠅ ꠢꠣꠞꠣꠘꠤ ꠅꠁꠍꠦ, ꠛꠃꠔ ꠖꠣꠋꠉꠣ-ꠢꠣꠋꠉꠣꠝꠣ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦꠖꠤ ꠉꠦꠍꠦ, ꠛꠃꠔ ꠝꠦꠘꠔ ꠇꠞꠍꠤ, ꠘꠣ ꠊꠥꠝꠣꠁꠀ ꠞꠣꠁꠔ ꠇꠣꠐꠣꠁꠍꠤ ꠀꠞ ꠃꠙꠣꠡ-ꠈꠣꠙꠣꠡ ꠞꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C26_6","077_6_6","2CO","6","6","6","ꠁꠔꠣ ꠍꠣꠠꠣ ꠀꠝꠞꠣꠞ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ, ꠍꠛꠞꠉꠣꠞꠤ, ꠖꠄꠀ-ꠝꠣꠄꠀ, ꠖꠤꠟꠞ ꠙꠣꠇ ꠞꠥꠢꠥ, ꠈꠣꠐꠤ ꠝꠢꠛ꠆ꠛꠔ, ");
INSERT INTO syls_vpl VALUES ("C26_7","077_6_7","2CO","6","7","7","ꠢꠇ ꠇꠕꠣ ꠇꠅꠀ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟ, ꠖꠥꠁꠅ ꠀꠔꠦ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠀꠔꠤꠀꠞ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C26_8","077_6_8","2CO","6","8","8","ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠝ ꠖꠦꠃꠇ ꠛꠣ ꠘꠣ ꠖꠦꠃꠇ, ꠀꠝꠞꠣꠞ ꠡꠥꠘꠣꠝ ꠉꠣꠃꠇ ꠛꠣ ꠛꠖꠘꠣꠝ ꠉꠣꠃꠇ, ꠁꠔꠣꠄ ꠀꠝꠞꠣꠞ ꠎꠣꠄ ꠀꠄ ꠘꠣ। ꠝꠣꠘꠡꠦ ꠇꠁꠞꠣ, ꠀꠝꠞꠣ ꠛꠥꠟꠦ ꠐꠉ, ꠀꠍꠟꠦ ꠔ ꠀꠝꠞꠣ ꠢꠇ ꠙꠕꠦ ꠌꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("C26_9","077_6_9","2CO","6","9","9","ꠝꠣꠘꠡꠦ ꠇꠂꠘ, ꠀꠝꠞꠣꠞꠦ ꠌꠤꠘꠂꠘ ꠘꠣ, ꠔꠦꠛꠃ ꠢꠇꠟꠦ ꠀꠝꠞꠣꠞꠦ ꠌꠤꠘꠦ। ꠀꠝꠞꠣ ꠝꠞꠣꠞ ꠟꠣꠈ ꠅꠁꠉꠦꠟꠦꠅ ꠛꠣꠌꠤꠀ ꠀꠍꠤ। ꠀꠝꠞꠣꠞꠦ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠇꠞꠣ ꠅꠞ, ꠅꠁꠟꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C26_10","077_6_10","2CO","6","10","10","ꠛꠃꠔ ꠖꠥꠈꠞ ꠝꠣꠎꠦꠅ ꠀꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠀꠍꠤ। ꠀꠝꠞꠣ ꠘꠤꠎꠦ ꠉꠞꠤꠛ ꠅꠁꠀꠅ ꠛꠃꠔꠞꠦ ꠗꠘꠤ ꠛꠣꠘꠣꠁꠍꠤ। ꠀꠝꠞꠣꠞ ꠔ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ, ꠔꠦꠛꠃ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠣꠟꠤꠇ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣ ꠙꠞꠝꠣꠘ ꠇꠞꠍꠤ, ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠦꠎꠝꠔꠇꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C26_11","077_6_11","2CO","6","11","11","ꠅ ꠇꠞꠤꠘ꠆ꠔ ꠎꠝꠣꠔꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠈꠥꠟꠣ-ꠝꠦꠟꠣꠃ ꠝꠣꠔꠤꠍꠤ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠝꠘ ꠃꠎꠣꠠ ꠇꠞꠤ ꠖꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C26_12","077_6_12","2CO","6","12","12","ꠀꠝꠞꠣꠞ ꠖꠤꠟ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠟꠤꠀ ꠞꠣꠈꠍꠤ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠕꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("C26_13","077_6_13","2CO","6","13","13","ꠔꠦ ꠀꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠤꠟ ꠈꠥꠟꠤꠀ ꠞꠣꠈꠍꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠈꠣꠘ ꠈꠥꠟꠤꠀ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("C26_14","077_6_14","2CO","6","14","14","ꠔꠥꠝꠞꠣ ꠛꠤꠗꠞ꠆ꠝꠤ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠈꠦꠡꠤ-ꠇꠥꠐꠥꠝꠤꠔꠣ ꠇꠞꠤꠅ ꠘꠣ। ꠙꠞꠦꠎꠉꠣꠞꠞ ꠟꠉꠦ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠝꠤꠟ ꠇꠥꠀꠁ? ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠞ ꠟꠉꠦ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠇꠥꠘꠥ ꠈꠣꠔꠤꠞ ꠀꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C26_15","077_6_15","2CO","6","15","15","ꠁꠛꠟꠤꠍꠞ ꠟꠉꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠥꠘꠥ ꠈꠣꠔꠤꠞ ꠀꠍꠦ ꠘꠤ? ꠝꠥꠝꠤꠘꠞ ꠟꠉꠦ ꠛꠤꠗꠞ꠆ꠝꠤ ꠡꠞꠤꠇ ꠅꠁꠛ ꠇꠤꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("C26_16","077_6_16","2CO","6","16","16","ꠎꠣꠘ ꠔ, ꠙꠣꠇ ꠇꠣꠟꠣꠝꠅ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠞꠣ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠛꠡꠔ ꠇꠞꠝꠥ, ꠔꠣꠞꠣꠞ ꠟꠉꠦꠃ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠝꠥ। ꠀꠝꠤ ꠅꠁꠝꠥ ꠔꠣꠞꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠞꠣ ꠅꠁꠛꠣ ꠀꠝꠣꠞ ꠙ꠆ꠞꠎꠣ। ꠔꠦ ꠀꠝꠞꠣꠃ ꠅꠁꠟꠣꠝ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠛꠣ ꠊꠞꠞ ꠜꠤꠔꠞꠦ ꠝꠥꠞ꠆ꠔꠤꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣ ꠀꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C26_17","077_6_17","2CO","6","17","17","ꠙꠣꠇ ꠇꠣꠟꠣꠝꠅ ꠀꠞꠅ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠛꠤꠗꠞ꠆ꠝꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠅ, ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠟꠉ ꠞꠅ, ꠘꠣꠙꠣꠇ ꠇꠥꠘꠥ ꠎꠤꠘꠤꠡ ꠍꠁꠅ ꠘꠣ, ꠔꠦꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C26_18","077_6_18","2CO","6","18","18","ꠀꠝꠤ ꠅꠁꠝꠥ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ, ꠔꠥꠝꠞꠣ ꠅꠁꠛꠣꠄ ꠀꠝꠣꠞ ꠀꠅꠟꠣꠖ, ꠁꠈꠣꠘ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠞꠣꠛ꠆ꠛꠥꠟ ꠀꠟꠣꠝꠤꠘꠦ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C27_1","077_7_1","2CO","7","1","1","ꠅ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠅꠃ ꠅꠀꠖꠣ ꠅꠇꠟ ꠔ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠔꠦ ꠀꠅ ꠀꠝꠞꠣ ꠡꠞꠤꠟꠞ ꠀꠞ ꠖꠤꠟꠞ ꠘꠣꠙꠣꠇꠤ ꠖꠥꠞ ꠇꠞꠤꠀ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠙꠕꠦ ꠌꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("C27_2","077_7_2","2CO","7","2","2","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠞꠣ ꠔ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠍꠤ ꠘꠣ, ꠇꠦꠃꠞꠞ ꠈꠦꠔꠤꠅ ꠇꠞꠍꠤ ꠘꠣ ꠀꠞ ꠇꠦꠃꠞꠞꠦ ꠐꠉꠣꠁꠍꠤꠅ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠑꠣꠁ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("C27_3","077_7_3","2CO","7","3","3","ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠡꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠁꠈꠣꠘ ꠇꠁꠞꠣꠝ ꠘꠣ। ꠀꠝꠤ ꠀꠉꠦꠃ ꠇꠁꠍꠤ, ꠔꠥꠝꠞꠣ ꠔ ꠀꠝꠞꠣꠞ ꠎꠣꠘꠞ ꠎꠣꠘ ꠇꠁꠟꠎꠣꠞ ꠐꠥꠇꠞꠣ, ꠀꠝꠞꠣ ꠝꠞꠟꠦꠅ ꠄꠇꠟꠉꠦ ꠝꠞꠝꠥ, ꠛꠣꠌꠟꠦꠅ ꠄꠇꠟꠉꠦ ꠛꠣꠌꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C27_4","077_7_4","2CO","7","4","4","ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠜꠞꠡꠣ ꠇꠞꠤ, ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠛꠠꠣꠁ ꠇꠞꠤ। ꠄꠞꠟꠣꠉꠤ ꠅꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦ ꠞꠁꠀꠅ ꠀꠝꠣꠞ ꠎꠣꠘꠅ ꠡꠣꠘ꠆ꠔꠤ ꠀꠍꠤꠟ, ꠀꠝꠣꠞ ꠝꠘ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠄ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C27_5","077_7_5","2CO","7","5","5","ꠢꠥꠘꠅ, ꠅꠃ ꠝꠣꠇꠤꠖꠘꠤꠀꠔ ꠀꠁꠀꠅ ꠀꠝꠞꠣꠞ ꠡꠞꠤꠟꠅ ꠇꠥꠘꠥ ꠡꠥꠈ ꠙꠣꠁꠍꠤ ꠘꠣ, ꠢꠇꠟꠛꠣꠄ ꠕꠣꠇꠤꠃ ꠀꠝꠞꠣ ꠇꠡ꠆ꠐ ꠙꠣꠁꠍꠤ, ꠛꠣꠁꠞꠦ ꠀꠍꠤꠟ ꠉꠘ꠆ꠒꠉꠥꠟ ꠀꠞ ꠎꠣꠘꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠤꠟ ꠒꠞ-ꠈꠚ। ");
INSERT INTO syls_vpl VALUES ("C27_6","077_7_6","2CO","7","6","6","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ, ꠎꠦꠁꠘ ꠖꠥꠈꠤ ꠎꠘꠞꠦ ꠛꠥꠎ ꠖꠦꠁꠘ, ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠛꠥꠎ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠤꠔꠣꠍ ꠜꠣꠁꠞꠦ ꠅꠘꠅ ꠀꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C27_7","077_7_7","2CO","7","7","7","ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠔꠤꠔꠣꠍ ꠜꠣꠁꠄ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦ ꠛꠥꠎ ꠙꠣꠁꠍꠟꠣ, ꠅꠃ ꠛꠥꠎꠦ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦꠅ ꠛꠥꠎ ꠖꠤꠟꠣ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠄꠡꠇꠤ, ꠔꠥꠝꠞꠣꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠟꠣ, ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠛꠥꠟꠦ ꠈꠥꠛ ꠀꠉ꠆ꠞꠢꠤ। ꠅꠃ ꠢꠇꠟꠔꠣ ꠢꠥꠘꠤꠀ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C27_8","077_7_8","2CO","7","8","8","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠣꠞ ꠀꠉꠞ ꠌꠤꠑꠤꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠈ ꠖꠤꠍꠟꠣꠝ, ꠔꠦꠛꠃ ꠀꠝꠣꠞ ꠝꠘꠅ ꠇꠥꠘꠥ ꠇꠡ꠆ꠐ ꠘꠣꠁ। ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠛꠥꠎꠟꠣꠝ, ꠅꠃ ꠌꠤꠑꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠖꠥꠈ ꠖꠤꠍꠦ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤꠅ ꠇꠤꠍꠥ ꠖꠥꠈ ꠙꠣꠁꠍꠟꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("C27_9","077_7_9","2CO","7","9","9","ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠤ ꠈꠥꠡꠤ। ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠈ ꠖꠦꠅꠀꠄ ꠈꠥꠡꠤ ꠅꠁꠍꠤ ꠘꠣ, ꠛꠞꠋ ꠖꠥꠈ ꠙꠣꠁꠀ ꠔꠥꠝꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠍ ꠖꠦꠈꠤꠀ ꠈꠥꠡꠤ ꠅꠁꠍꠤ। ꠅꠃ ꠖꠥꠈ ꠙꠣꠁꠍꠟꠣꠄ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤꠄ, ꠎꠣꠔꠦ ꠀꠝꠞꠣꠞ ꠖꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C27_10","077_7_10","2CO","7","10","10","ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠝꠘꠞ ꠇꠡ꠆ꠐꠄ ꠝꠣꠘꠡꠦ ꠔꠃꠛꠣ ꠇꠞꠂꠘ, ꠀꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠘ। ꠔꠦ ꠅꠃ ꠇꠡ꠆ꠐꠄ ꠔ ꠖꠥꠈ ꠘꠣꠁ। ꠅꠁꠟꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠘꠞ ꠇꠡ꠆ꠐꠄ ꠝꠣꠘꠡꠞ ꠝꠞꠘ ꠀꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("C27_11","077_7_11","2CO","7","11","11","ꠔꠥꠝꠞꠣ ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠝꠘꠞ ꠇꠡ꠆ꠐꠄ ꠔꠥꠝꠞꠣꠞ ꠇꠔ ꠜꠣꠟꠣꠁ ꠇꠞꠍꠦ, ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠍꠦ, ꠉꠥꠘꠣꠞ ꠛꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠊꠤꠘ꠆ꠘꠣ ꠎꠘꠝꠣꠁꠍꠦ, ꠝꠘꠦ ꠝꠘꠦ ꠇꠔ ꠒꠞ ꠒꠞꠣꠁꠍ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠇꠔ ꠀꠉꠥꠀꠁꠍ, ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠣꠝꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠍ। ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠝꠘ꠆ꠔꠦꠃ ꠙꠞꠝꠣꠘ ꠖꠤꠍ, ꠔꠥꠝꠞꠣ ꠘꠤꠈꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("C27_12","077_7_12","2CO","7","12","12","ꠀꠝꠤ ꠎꠥꠖꠤꠅ ꠅꠃ ꠌꠤꠑꠤ ꠟꠦꠈꠍꠤꠟꠣꠝ, ꠅꠁꠟꠦ ꠎꠦ ꠝꠣꠘꠡꠦ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠍꠦ ꠛꠣ ꠎꠣꠞ ꠃꠙꠞꠦ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠣ ꠅꠁꠍꠦ ꠔꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠄ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠅꠃ ꠢꠣꠟꠔꠈꠣꠘ ꠎꠣꠁꠞ ꠅꠄ ꠎꠦꠘ, ꠔꠥꠝꠞꠣ ꠢꠣꠍꠣꠃ ꠀꠝꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ, ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠟꠦꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C27_13","077_7_13","2CO","7","13","13","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠛꠥꠎꠅ ꠙꠣꠁꠍꠤ। ꠅꠃ ꠛꠥꠎ ꠙꠣꠁꠀ ꠀꠞ ꠜꠣꠁ ꠔꠤꠔꠣꠍꠞ ꠈꠥꠡꠤ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠀꠞꠅ ꠛꠦꠡꠤ ꠈꠥꠡꠤ ꠅꠁꠍꠤ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠈꠥꠛ ꠀꠞꠣꠝ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C27_14","077_7_14","2CO","7","14","14","ꠀꠍꠟꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠛꠠꠣꠁ ꠇꠞꠍꠟꠣꠝ, ꠄꠔꠦ ꠇꠥꠘꠥ ꠡꠞꠝꠤꠘ꠆ꠖꠣꠅ ꠅꠁꠍꠤ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣꠞ ꠛꠣꠔꠣꠁꠟ ꠢꠇꠟ ꠇꠕꠣ ꠎꠦꠟꠣ ꠢꠣꠍꠣ ꠀꠍꠤꠟ, ꠅꠃꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠀꠝꠞꠣꠞ ꠛꠠꠣꠁ ꠇꠞꠣꠈꠣꠘꠅ ꠔꠣꠘ ꠉꠦꠍꠦ ꠢꠣꠍꠣ ꠙꠞꠝꠣꠘ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C27_15","077_7_15","2CO","7","15","15","ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦ ꠎꠦꠟꠣ ꠔꠣꠘ ꠘꠍꠤꠅꠔ ꠝꠣꠘꠍ, ꠝꠘꠞ ꠒꠞ-ꠈꠚꠦ ꠇꠣꠙꠤ ꠇꠣꠙꠤ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠍ, ꠅꠈꠣꠘ ꠝꠘꠅ ꠅꠀꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠔꠣꠘ ꠝꠣꠄꠀ ꠈꠥꠛ ꠛꠦꠡꠤ ꠛꠣꠠꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C27_16","077_7_16","2CO","7","16","16","ꠀꠞ ꠀꠝꠤꠅ ꠈꠥꠛ ꠈꠥꠡꠤ, ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠅꠈꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠜꠞꠡꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C28_1","077_8_1","2CO","8","1","1","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠞꠣꠝ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠖꠦꠡꠞ ꠎꠝꠣꠔ ꠅꠇꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠔ ꠘꠤꠀꠝꠔ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C28_2","077_8_2","2CO","8","2","2","ꠎꠥꠖꠤꠅ ꠛꠃꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠖꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠔꠣꠞꠣ ꠈꠥꠛ ꠉꠞꠤꠛ ꠢꠣꠟꠔꠦ ꠀꠍꠟꠣ, ꠔꠦꠛꠃ ꠔꠣꠞꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠚꠥꠞ꠆ꠔꠤ ꠀꠍꠤꠟ, ꠔꠣꠞꠣ ꠈꠥꠟꠣ ꠀꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C28_3","077_8_3","2CO","8","3","3","ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠙꠇ꠆ꠇꠦ ꠇꠁꠞꠣꠝ, ꠔꠣꠞꠣ ꠈꠥꠡꠤ ꠅꠁꠀ ꠘꠤꠎꠞ ꠔꠚꠤꠇ ꠝꠣꠚꠤꠇ, ꠄꠝꠘꠇꠤ ꠔꠚꠤꠇ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠦꠡꠤꠅ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C28_4","077_8_4","2CO","8","4","4","ꠀꠞ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠍꠤꠟꠣ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠅꠜꠣꠛꠞ ꠝꠣꠎꠦ ꠀꠍꠂꠘ, ꠄꠞꠣꠞꠦ ꠅꠜꠣꠛ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠡꠞꠤꠇ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C28_5","077_8_5","2CO","8","5","5","ꠀꠝꠞꠣ ꠎꠔꠈꠣꠘ ꠀꠡꠣ ꠇꠞꠍꠟꠣꠝ, ꠔꠣꠞꠣ ꠄꠞ ꠌꠣꠁꠔꠦꠅ ꠛꠦꠡꠤ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠔꠣꠞꠣ ꠙꠄꠟꠣ ꠘꠤꠎꠞꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠍꠂꠘ, ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤꠄ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦꠅ ꠡꠙꠣ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C28_6","077_8_6","2CO","8","6","6","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠔꠤꠔꠣꠍ ꠜꠣꠁꠞꠦ ꠈꠥꠛ ꠝꠤꠘꠔ ꠇꠞꠍꠟꠣꠝ, ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠇꠞꠣꠞ ꠎꠦ ꠇꠣꠝ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠌꠣꠟꠥ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠎꠣꠘꠥ ꠡꠦꠡꠅ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C28_7","077_8_7","2CO","8","7","7","ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦꠃ ꠀꠉꠥꠀꠁꠟ ꠀꠍ, ꠔꠥꠝꠞꠣꠞ ꠡꠛꠟ ꠁꠝꠣꠘ, ꠇꠕꠣ-ꠛꠣꠞ꠆ꠔꠣ, ꠀꠈꠟ-ꠢꠦꠇꠝꠔ, ꠝꠘꠞ ꠄꠡꠇꠤ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠣꠄ ꠎꠦꠟꠣ ꠈꠥꠛ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠀꠍꠦ, ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠇꠞꠣꠞ ꠘꠦꠇ ꠀꠝꠟꠅ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠣꠁꠀ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("C28_8","077_8_8","2CO","8","8","8","ꠁꠔꠣ ꠟꠦꠈꠤꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ ꠘꠣ, ꠈꠣꠟꠤ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤ ꠖꠦꠈꠞꠣꠝ, ꠄꠞꠟꠣꠉꠤ ꠅꠁꠘ꠆ꠘ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠄꠡꠇꠤꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠁꠞꠣꠝ। ꠖꠦꠈꠤ, ꠔꠥꠝꠞꠣꠞ ꠝꠢꠛ꠆ꠛꠔ ꠇꠔꠈꠣꠘ ꠘꠤꠈꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("C28_9","077_8_9","2CO","8","9","9","ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝ-ꠘꠤꠀꠝꠔꠞ ꠇꠕꠣ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠃ, ꠔꠣꠁꠘ ꠔ ꠀꠟ꠆ꠟꠣꠁ ꠗꠘꠦ ꠗꠘꠤ ꠀꠍꠟꠣ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠉꠞꠤꠛ ꠛꠘꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠉꠞꠤꠛ ꠛꠘꠣꠞ ꠇꠣꠞꠘꠦ ꠔꠥꠝꠞꠣ ꠗꠘꠤ ꠅꠁꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C28_10","077_8_10","2CO","8","10","10","ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠞꠣꠝ, ꠁꠔꠣ ꠝꠣꠘꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ, ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀ ꠉꠔ ꠛꠍꠞ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠔꠥꠟꠣꠔ ꠟꠣꠉꠍꠤꠟꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("C28_11","077_8_11","2CO","8","11","11","ꠅꠈꠘ ꠅꠃ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠅ। ꠝꠘꠞ ꠎꠦ ꠄꠡꠇꠤ ꠟꠁꠀ ꠔꠥꠝꠞꠣ ꠁ ꠇꠣꠝ ꠡꠥꠞꠥ ꠇꠞꠍꠤꠟꠣꠄ, ꠅꠃꠟꠣ ꠄꠡꠇꠤꠄ ꠎꠣꠞꠎꠤꠞ ꠔꠚꠤꠇ ꠝꠣꠚꠤꠇ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠤꠀ ꠁꠔꠣ ꠡꠦꠡ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("C28_12","077_8_12","2CO","8","12","12","ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠤꠛꠣꠞ ꠘꠤꠅꠔ ꠇꠞꠟꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠘꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠇꠛꠥꠟ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠚꠤꠇ ꠕꠣꠇꠟꠦ ꠖꠦꠅ, ꠘꠣ ꠕꠣꠇꠟꠦ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C28_13","077_8_13","2CO","8","13","13","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ ꠘꠣ, ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠦ ꠀꠞꠣꠝ ꠇꠞꠃꠇ ꠀꠞ ꠔꠥꠝꠞꠣ ꠇꠡ꠆ꠐ ꠇꠞ, ꠛꠞꠋ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠢꠣꠟꠔ ꠄꠇꠟꠣꠈꠣꠘ ꠅꠃꠇ, ꠅꠈꠣꠘꠃ ꠀꠡꠣ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C28_14","077_8_14","2CO","8","14","14","ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠗꠘ-ꠖꠃꠟꠔ ꠅꠈꠘ ꠛꠣꠠꠔꠤ ꠀꠍꠦ, ꠅꠔꠣꠄ ꠔꠣꠞꠣꠞ ꠅꠜꠣꠛ ꠝꠤꠐꠣꠃꠇ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠎꠦꠛꠟꠣ ꠛꠦꠡꠤ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠅꠜꠣꠛ ꠝꠤꠐꠣꠁꠛꠣ। ꠅꠟꠣꠈꠣꠘ ꠢꠇꠟꠞ ꠢꠣꠟꠔ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C28_15","077_8_15","2CO","8","15","15","ꠎꠦꠟꠣ ꠔꠃꠞꠣꠔ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, “ꠎꠦꠁꠘ ꠛꠦꠡꠤ ꠔꠥꠇꠣꠁꠍꠟꠣ ꠔꠣꠘꠅ ꠛꠦꠡꠤ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠞ ꠎꠦꠁꠘ ꠕꠥꠠꠣ ꠔꠥꠇꠣꠁꠍꠟꠣ ꠔꠣꠘꠅ ꠇꠝ ꠅꠁꠍꠦ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("C28_16","077_8_16","2CO","8","16","16","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ, ꠀꠝꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠎꠦꠟꠣ ꠈꠤꠀꠟ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠅꠃ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠈꠤꠀꠟ ꠖꠣꠘ ꠇꠞꠍꠂꠘ ꠜꠣꠁ ꠔꠤꠔꠣꠍꠞ ꠝꠣꠎꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("C28_17","077_8_17","2CO","8","17","17","ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠅꠘꠥꠞꠥꠗ ꠝꠣꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞꠣ, ꠀꠞ ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠈꠥꠡꠤ ꠅꠁꠀ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C28_18","077_8_18","2CO","8","18","18","ꠔꠣꠘ ꠟꠉꠦ ꠇꠞꠤ ꠀꠝꠞꠣ ꠢꠃ ꠜꠣꠁꠞꠦꠅ ꠙꠣꠑꠣꠁꠀꠞ, ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤ ꠢꠇꠟ ꠎꠝꠣꠔꠦꠃ ꠁ ꠜꠣꠁꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C28_19","077_8_19","2CO","8","19","19","ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠦ ꠈꠣꠟꠤ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠍꠦ ꠘꠣ, ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠟꠁꠀ ꠎꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠃ ꠔꠣꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠦ। ꠔꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠉꠃꠞꠛꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠀꠝꠞꠣ ꠅꠃ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠘꠤꠛꠣꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C28_20","077_8_20","2CO","8","20","20","ꠀꠝꠞꠣ ꠈꠥꠛ ꠢꠥꠡꠤꠀꠞ ꠅꠁꠀ ꠌꠟꠤꠀꠞ, ꠎꠣꠔꠦ ꠛꠠ ꠀꠇꠣꠞꠞ ꠅꠃ ꠞꠤꠟꠤꠚ ꠛꠤꠟꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠇꠦꠃ ꠀꠝꠞꠣꠞ ꠛꠖꠘꠣꠝ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠘꠣ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C28_21","077_8_21","2CO","8","21","21","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠘꠣꠄ, ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦꠅ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠞꠅꠀꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C28_22","077_8_22","2CO","8","22","22","ꠀꠞ ꠄꠞꠣꠞ ꠟꠉꠦ ꠇꠞꠤ ꠀꠝꠞꠣ ꠀꠞꠇ ꠜꠣꠁꠞꠦ ꠙꠣꠑꠣꠁꠞꠣꠝ, ꠄꠘꠞꠦ ꠀꠝꠞꠣ ꠛꠃꠔ ꠛꠣꠞ ꠛꠃꠔ ꠟꠣꠈꠣꠘ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠍꠤ, ꠔꠣꠘ ꠈꠥꠛ ꠄꠡꠇꠤ ꠀꠍꠦ। ꠅꠈꠘ ꠖꠦꠈꠞꠣꠝ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠥꠛ ꠛꠤꠡ꠆ꠛꠣꠡ ꠇꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠔꠣꠘ ꠄꠡꠇꠤ ꠀꠞꠅ ꠛꠣꠠꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C28_23","077_8_23","2CO","8","23","23","ꠅꠈꠘ ꠔꠤꠔꠣꠍ ꠜꠣꠁꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠄꠁꠘ ꠔ ꠀꠝꠣꠞ ꠟꠉꠦ ꠞꠂꠘ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠝ ꠇꠞꠂꠘ। ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠢꠇꠟ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠞꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠃꠞꠛ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C28_24","077_8_24","2CO","8","24","24","ꠄꠞꠟꠣꠉꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠜꠤꠔꠞꠞ ꠝꠢꠛ꠆ꠛꠔ, ꠀꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠀꠝꠞꠣ ꠎꠦ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁ, ꠁꠔꠣꠞ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠅ। ꠔꠦꠃ ꠢꠇꠟ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠦ ꠛꠥꠎꠛꠣ, ꠔꠥꠝꠞꠣ ꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("C29_1","077_9_1","2CO","9","1","1","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠡꠣꠁꠎ꠆ꠎꠞ ꠟꠣꠉꠤ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠔꠥꠟꠣꠞ ꠎꠦ ꠇꠣꠝ ꠌꠟꠦꠞ, ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠟꠦꠈꠣꠞ ꠎꠞꠥꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C29_2","077_9_2","2CO","9","2","2","ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠈꠤꠀꠟ ꠔ ꠀꠝꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ। ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠡꠥꠘꠣꠝ ꠉꠣꠁꠀ ꠇꠁꠞꠣꠝ, ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠞ ꠝꠣꠘꠥꠡ ꠝꠣꠘꠤ ꠔꠥꠝꠞꠣ, ꠉꠔ ꠛꠍꠞ ꠕꠣꠇꠤꠃ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠟꠁꠀ ꠎꠥꠁꠔ ꠀꠍ। ꠔꠥꠝꠞꠣꠞ ꠁ ꠄꠡꠇꠤ ꠖꠦꠈꠤꠀ, ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠢꠎꠣꠉ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C29_3","077_9_3","2CO","9","3","3","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠃ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠙꠣꠑꠣꠁꠞꠣꠝ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠀꠝꠞꠣ ꠎꠦ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠁ, ꠔꠣꠞꠣ ꠉꠤꠀ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠙꠞꠝꠣꠘ ꠙꠣꠁꠘ। ꠔꠦ ꠀꠝꠤ ꠎꠦꠟꠣ ꠛꠠꠣꠁ ꠇꠞꠍꠤ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣꠈꠣꠘ ꠎꠥꠁꠔ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("C29_4","077_9_4","2CO","9","4","4","ꠀꠞꠘꠣꠄ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠇꠥꠘꠥ ꠜꠣꠁꠀꠁꠘ ꠉꠤꠀ ꠎꠥꠖꠤ ꠖꠦꠈꠂꠘ ꠔꠥꠝꠞꠣ ꠎꠥꠁꠔ ꠘꠣꠄ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠅꠔ ꠛꠠ ꠜꠞꠡꠣ ꠇꠞꠣꠄ, ꠀꠝꠞꠣ ꠡꠞꠝ ꠙꠣꠁꠝꠥ ꠀꠞ ꠔꠥꠝꠞꠣꠅ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C29_5","077_9_5","2CO","9","5","5","ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠅꠘꠥꠞꠥꠗ ꠇꠞꠟꠣꠝ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠀꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠘ। ꠞꠤꠟꠤꠚ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠤꠛꠣꠞ ꠎꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠤꠟꠣꠄ, ꠔꠣꠞꠣ ꠉꠤꠀ ꠅꠉꠥꠁꠘ ꠎꠥꠁꠔ ꠇꠞꠣꠔ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠛꠣ। ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠥꠞ-ꠎꠛꠞꠖꠡ꠆ꠔꠤ ꠇꠞꠤꠀ ꠇꠥꠘ꠆ꠔꠣ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠔ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠝꠘꠞ ꠈꠥꠡꠤꠄ ꠖꠦꠅꠀ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠘꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C29_6","077_9_6","2CO","9","6","6","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠎꠦ ꠉꠤꠞꠡ꠆ꠔꠦ ꠕꠥꠠꠣ ꠇꠞꠤ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠖꠦꠄ, ꠢꠦ ꠕꠥꠠꠣ ꠚꠡꠟ ꠖꠣꠁꠛ, ꠀꠞ ꠎꠦ ꠉꠤꠞꠡ꠆ꠔꠦ ꠛꠦꠡ ꠇꠞꠤ ꠎꠣꠟꠣ ꠛꠣꠁꠘ ꠖꠦꠄ, ꠢꠦ ꠛꠦꠡ ꠇꠞꠤ ꠚꠡꠟ ꠖꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C29_7","077_9_7","2CO","9","7","7","ꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠙꠞꠔꠦꠇꠦ ꠎꠣꠞꠎꠤꠞ ꠘꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠦꠅ। ꠝꠘꠞ ꠝꠣꠎꠦ ꠇꠡ꠆ꠐ ꠟꠁꠀ ꠛꠣ ꠖꠦꠅꠀ ꠟꠣꠉꠛ ꠇꠞꠤ ꠖꠤꠅ ꠘꠣ। ꠇꠣꠞꠘ ꠖꠤꠟꠞ ꠈꠥꠡꠤꠄ ꠖꠣꠘ ꠇꠞꠟꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠄꠀ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C29_8","077_9_8","2CO","9","8","8","ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠤꠔꠣ ꠙꠣꠞꠂꠘ। ꠁ ꠈꠦꠝꠔꠣ ꠔꠣꠘ ꠀꠍꠦ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠞꠇꠣꠞꠤ ꠢꠇꠟꠔꠣ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠕꠣꠇꠦ, ꠀꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠈꠥꠟꠣ ꠀꠔꠦ ꠁꠔꠣ ꠛꠤꠟꠣꠁꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("C29_9","077_9_9","2CO","9","9","9","ꠎꠦꠟꠣ ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, ꠢꠦ ꠔ ꠈꠥꠟꠣ ꠀꠔꠦ ꠛꠤꠟꠣꠁ ꠖꠤꠍꠦ, ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠖꠣꠘ ꠇꠞꠍꠦ, ꠔꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠌꠤꠞꠇꠣꠟ ꠡ꠆ꠕꠣꠄꠁ। ");
INSERT INTO syls_vpl VALUES ("C29_10","077_9_10","2CO","9","10","10","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠉꠤꠞꠡ꠆ꠔꠞ ꠟꠣꠉꠤ ꠎꠦꠁꠘ ꠛꠤꠌ ꠎꠥꠉꠣꠁꠀ ꠖꠦꠁꠘ, ꠀꠞ ꠈꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠁꠘ ꠖꠣꠘꠣ-ꠙꠣꠘꠤ ꠎꠥꠉꠣꠁꠀ ꠖꠦꠁꠘ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠛꠤꠌ ꠎꠥꠉꠣꠁ ꠖꠤꠛꠣ, ꠁꠔꠣꠔ ꠛꠞꠇꠔ ꠖꠤꠛꠣ, ꠔꠥꠝꠞꠣꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠚꠡꠟ ꠛꠃꠔ ꠛꠣꠠꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C29_11","077_9_11","2CO","9","11","11","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠝꠘ꠆ꠔꠦ ꠗꠘꠤ ꠅꠁꠛꠣꠄ, ꠀꠞ ꠈꠥꠟꠣ ꠀꠔꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠛꠤꠟꠣꠁꠛꠣꠄ, ꠔꠦꠃ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠀꠖꠣꠄ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C29_12","077_9_12","2CO","9","12","12","ꠅꠃ ꠞꠤꠟꠤꠚ ꠇꠣꠝꠦ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠅꠜꠣꠛꠅ ꠡꠣꠁꠎ꠆ꠎ ꠅꠁꠔ ꠘꠣꠄ, ꠛꠞꠋ ꠛꠃꠔ ꠎꠘꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞꠅ ꠛꠣꠁꠀ ꠙꠠꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("C29_13","077_9_13","2CO","9","13","13","ꠔꠥꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠃꠙꠎꠥꠇ꠆ꠔ ꠅꠃ ꠈꠦꠎꠝꠔ ꠇꠞꠍ ꠖꠦꠈꠤꠀ, ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠀꠖꠣꠄ ꠇꠞꠛꠣ। ꠔꠥꠝꠞꠣ ꠖꠥꠁꠅ ꠀꠔꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠛꠤꠟꠣꠘꠤꠄ, ꠝꠣꠇꠤꠖꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠀꠞ ꠛꠣꠇꠤ ꠢꠇꠟꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C29_14","077_9_14","2CO","9","14","14","ꠔꠥꠝꠞꠣ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠖꠦꠅꠀꠄ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠃ ꠎꠦ ꠀꠌꠣꠘꠇ ꠘꠤꠀꠝꠔ ꠙꠣꠁꠍ, ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠖꠥꠀ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C29_15","077_9_15","2CO","9","15","15","ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠖꠣꠘꠞ ꠇꠕꠣ ꠝꠥꠈꠖꠤ ꠇꠁꠀ ꠚꠥꠠꠣꠘꠤꠞ ꠡꠣꠁꠖ꠆ꠖ ꠘꠣꠁ, ꠢꠃ ꠖꠣꠘꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("C210_1","077_10_1","2CO","10","1","1","ꠅ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠀꠁꠘ, ꠀꠟ-ꠝꠍꠤꠞ ꠘꠞꠝ ꠀꠞ ꠖꠄꠀꠟꠥ ꠜꠣꠛꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠤꠀ, ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠝꠣꠘꠡꠦ ꠇꠂꠘ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠛꠥꠟꠦ ꠒꠞꠣꠁ ꠒꠞꠣꠁ ꠕꠣꠇꠤ, ꠀꠞ ꠢꠞꠤꠀ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠡꠣꠅꠡꠤ ꠅꠁꠎꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C210_2","077_10_2","2CO","10","2","2","ꠔꠦ ꠎꠦꠞꠣ ꠝꠘꠅ ꠇꠞꠦ, ꠀꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠀꠞ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠔꠈꠣꠘ ꠡꠣꠅꠡ ꠖꠦꠈꠣꠘꠤ ꠖꠞꠇꠣꠞ, ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠀꠝꠤ ꠀꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠣꠘꠥ ꠅꠔꠈꠣꠘ ꠡꠣꠅꠡ ꠖꠦꠈꠣꠘꠤ ꠘꠣ ꠟꠣꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("C210_3","077_10_3","2CO","10","3","3","ꠀꠝꠞꠣ ꠎꠥꠖꠤꠅ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠝꠣꠘꠥꠡ, ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠎꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠞꠣꠝ, ꠁꠔꠣ ꠔ ꠇꠥꠘꠥ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠟꠣꠠꠣꠁ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C210_4","077_10_4","2CO","10","4","4","ꠖꠥꠘꠤꠀꠛꠤ ꠍꠤꠙꠣꠁꠄ ꠎꠦꠔꠣ ꠅꠡꠔ꠆ꠞ-ꠡꠡꠔ꠆ꠞ ꠖꠤꠀ ꠟꠣꠠꠣꠁ ꠇꠞꠂꠘ, ꠀꠝꠞꠣ ꠔ ꠁꠔꠣ ꠖꠤꠀ ꠟꠣꠠꠣꠁ ꠇꠞꠤ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠁ ꠛꠟꠦ ꠀꠝꠞꠣꠞ ꠅꠡꠔ꠆ꠞ-ꠡꠡꠔ꠆ꠞꠄ ꠙꠣꠠꠞ ꠃꠙꠞꠞ ꠛꠣꠋꠇꠣꠞꠅ ꠜꠣꠋꠉꠤꠟꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C210_5","077_10_5","2CO","10","5","5","ꠀꠝꠞꠣꠞ ꠅꠡꠔ꠆ꠞꠖꠤ ꠝꠣꠘꠡꠞ ꠛꠣꠘꠥꠀꠐ ꠎꠥꠇ꠆ꠔꠤ ꠛꠤꠘꠣꠡ ꠇꠞꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞꠦ ꠌꠤꠘꠣꠞ ꠙꠕꠦ ꠎꠔ ꠟꠣꠈꠣꠘ ꠛꠣꠗꠣ-ꠛꠤꠊꠘꠄ ꠖꠤꠟꠞꠦ ꠀꠐꠇꠣꠁꠀ ꠞꠣꠈꠦ, ꠁꠔꠣꠞꠦꠅ ꠛꠤꠘꠣꠡ ꠇꠞꠤ। ꠝꠣꠘꠡꠞ ꠝꠘꠞ ꠢꠇꠟ ꠇꠥ-ꠌꠤꠘ꠆ꠔꠣꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠢꠣꠞꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠟꠦ ꠀꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("C210_6","077_10_6","2CO","10","6","6","ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠛꠣꠁꠖ꠆ꠖ ꠅꠁꠀ ꠔꠣꠘ ꠔꠟꠦ ꠀꠁꠛꠣꠄ, ꠢꠃ ꠡꠝꠄ ꠎꠦꠔꠣ ꠅꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠛꠣ, ꠁꠔꠣꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠎꠥꠁꠔ ꠅꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C210_7","077_10_7","2CO","10","7","7","ꠔꠥꠝꠞꠣ ꠔ ꠈꠣꠟꠤ ꠀꠝꠞꠣꠞ ꠛꠣꠁꠞꠞ ꠍꠥꠞꠔ ꠖꠦꠈꠍ। ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠘꠤꠎꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠝꠘꠅ ꠇꠞꠦ, ꠔꠦ ꠔꠣꠞ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠢꠦ ꠎꠣꠘ ꠃꠝ꠆ꠝꠔ, ꠀꠝꠞꠣꠅ ꠔ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("C210_8","077_10_8","2CO","10","8","8","ꠀꠍꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠅꠗꠤꠇꠣꠞ ꠖꠤꠍꠂꠘ, ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠇꠤꠍꠥ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠁꠟꠦꠅ ꠔ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠔꠣꠝ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠁ ꠅꠗꠤꠇꠣꠞꠞ ꠃꠖ꠆ꠖꠦꠡ꠆ꠡ ꠅꠁꠟ, ꠔꠥꠝꠞꠣꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣ, ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠇꠞꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C210_9","077_10_9","2CO","10","9","9","ꠀꠝꠣꠞ ꠁ ꠟꠦꠈꠣ ꠙꠠꠤꠀ ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠝꠤ ꠌꠤꠑꠤ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠒꠞ ꠖꠦꠈꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C210_10","077_10_10","2CO","10","10","10","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠝꠣꠔꠂꠘ, “ꠔꠣꠘ ꠟꠦꠈꠣ ꠌꠤꠑꠤꠘ꠆ꠔꠦ ꠖꠤꠟꠅ ꠒꠦꠇ꠆ꠇꠣ ꠝꠣꠞꠦ, ꠁꠔꠣ ꠡꠇ꠆ꠔꠤꠡꠣꠟꠤ ꠌꠤꠑꠤ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠟꠦ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠔꠣꠁꠘ ꠇꠝꠎꠥꠞ ꠀꠞ ꠅꠀꠎ-ꠘꠍꠤꠅꠔꠅ ꠝꠥꠐꠦꠃ ꠉꠞꠝ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("C210_11","077_10_11","2CO","10","11","11","ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠁꠞꠣꠝ, ꠀꠝꠞꠣ ꠖꠥꠞꠁ ꠕꠣꠇꠤ ꠌꠤꠑꠤꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠟꠦꠈꠞꠣꠝ, ꠍꠣꠝꠘꠦ ꠀꠁꠟꠦ ꠑꠤꠇ ꠅꠟꠣꠃ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C210_12","077_10_12","2CO","10","12","12","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠔꠣꠞꠤꠚ ꠉꠣꠄ। ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠔ ꠀꠝꠞꠣꠞ ꠔꠥꠟꠘꠣ ꠌꠟꠦ ꠘꠣ, ꠛꠣ ꠔꠣꠞꠣꠞ ꠖꠟꠞ ꠡꠖꠁꠡ꠆ꠡ ꠅꠁꠔꠦꠅ ꠡꠣꠅꠡ ꠇꠞꠤ ꠘꠣ। ꠔꠣꠞꠣ ꠔ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠎꠦꠔꠣ ꠜꠣꠟꠣ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠅꠔꠣꠞ ꠟꠉꠦꠃ ꠔꠣꠞꠣꠞ ꠔꠥꠟꠘꠣ ꠇꠞꠂꠘ, ꠅꠔꠣꠖꠤꠃ ꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ, ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠁꠔꠣ ꠇꠔ ꠛꠠ ꠀꠝ꠆ꠝꠇ! ");
INSERT INTO syls_vpl VALUES ("C210_13","077_10_13","2CO","10","13","13","ꠢꠥꠘꠅ, ꠀꠝꠞꠣꠞ ꠎꠔꠈꠣꠘ ꠛꠠꠣꠁ ꠇꠞꠣ ꠃꠌꠤꠔ, ꠄꠞ ꠛꠦꠡꠤ ꠇꠞꠔꠣꠝ ꠘꠣꠄ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠇꠣꠝꠞ ꠎꠦ ꠡꠤꠝꠣꠘꠣ ꠑꠤꠇ ꠇꠞꠤ ꠖꠤꠍꠂꠘ, ꠀꠝꠞꠣ ꠄꠞ ꠜꠤꠔꠞꠦ ꠞꠁꠀꠃ ꠛꠠꠣꠁ ꠇꠞꠝꠥ, ꠁ ꠡꠤꠝꠣꠘꠣꠞ ꠜꠤꠔꠞꠦ ꠔꠥꠝꠞꠣꠅ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("C210_14","077_10_14","2CO","10","14","14","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠉꠦꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠡꠤꠝꠣꠞ ꠛꠣꠞꠣ ꠔ ꠉꠦꠍꠤ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠢꠇꠟ ꠙꠄꠟꠣ ꠀꠝꠞꠣꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠉꠦꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C210_15","077_10_15","2CO","10","15","15","ꠄꠍꠣꠠꠣ ꠙꠞꠞ ꠇꠣꠝ ꠟꠁꠀ ꠀꠝꠞꠣ ꠉꠃꠞꠛ ꠇꠞꠤꠀꠞ ꠘꠣ, ꠁꠔꠣ ꠇꠞꠟꠦ ꠡꠤꠝꠣꠞ ꠛꠣꠞꠣ ꠅꠁꠟ ꠅꠘꠦ। ꠀꠝꠞꠣ ꠀꠡꠣ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠤ ꠛꠟ ꠛꠣꠠꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠞꠅ ꠛꠃꠔ ꠇꠣꠝ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C210_16","077_10_16","2CO","10","16","16","ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠞꠅ ꠖꠥꠞꠞ ꠖꠦꠡꠣꠁꠘ꠆ꠔꠅ ꠉꠤꠀ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠝꠥ। ꠔꠦꠃ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠇꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠙꠞꠞ ꠇꠣꠝ ꠟꠁꠀ ꠀꠝꠞꠣ ꠛꠠꠣꠁ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("C210_17","077_10_17","2CO","10","17","17","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, “ꠎꠦ ꠝꠣꠘꠡꠦ ꠛꠠꠣꠁ ꠇꠞꠦ, ꠢꠦ ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠞꠦ ꠟꠁꠀ ꠛꠠꠣꠁ ꠇꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("C210_18","077_10_18","2CO","10","18","18","ꠇꠣꠞꠘ ꠘꠤꠎꠞ ꠡꠥꠘꠣꠝ ꠘꠤꠎꠦ ꠉꠣꠁꠟꠦꠃ ꠙꠞꠝꠣꠘ ꠅꠄ ꠘꠣ ꠢꠦ ꠜꠣꠟꠣ ꠝꠣꠘꠥꠡ, ꠛꠞꠋ ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠄ ꠎꠣꠞ ꠡꠥꠘꠣꠝ ꠉꠣꠁꠘ, ꠢꠦ-ꠃ ꠜꠣꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠙꠞꠝꠣꠘ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("C211_1","077_11_1","2CO","11","1","1","ꠅ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠀꠝꠣꠞ ꠕꠥꠠꠣ ꠛꠦꠀꠈꠟꠤ ꠔꠥꠝꠞꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞ, ꠀꠞ ꠢꠣꠍꠣꠃ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞꠞꠣꠄꠅ। ");
INSERT INTO syls_vpl VALUES ("C211_2","077_11_2","2CO","11","2","2","ꠀꠟ꠆ꠟꠣꠁ ꠄꠡꠇꠤꠞ ꠎꠣꠟꠣꠄ ꠀꠝꠣꠞ ꠖꠤꠟꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇ ꠎꠣꠟꠣ ꠙꠄꠖꠣ ꠅꠁꠍꠦ। ꠔꠦ ꠀꠝꠤ ꠄꠇꠎꠘ ꠘꠡꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠀꠞ ꠝꠣꠔ-ꠇꠕꠣ ꠑꠤꠇ ꠇꠞꠤ ꠞꠣꠈꠍꠤ, ꠄꠘ ꠘꠣꠝ ꠀꠟ-ꠝꠍꠤ। ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠡꠔꠤ ꠇꠁꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠀꠔꠅ ꠡꠝꠎꠣꠁ ꠖꠤꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C211_3","077_11_3","2CO","11","3","3","ꠅꠁꠟꠦ ꠀꠝꠤ ꠒꠞꠣꠁꠀꠞ, ꠢꠃ ꠢꠣꠚꠦ ꠎꠦꠟꠣ ꠇꠥ-ꠛꠥꠖ꠆ꠖꠤ ꠖꠤꠀ ꠛꠤꠛꠤ ꠢꠣꠅꠀꠞꠦ ꠛꠦ-ꠙꠕꠦ ꠘꠤꠍꠤꠟꠉꠤ, ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟꠤꠔ ꠙꠣꠞꠦ, ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠈꠣꠐꠤ ꠜꠣꠛ ꠀꠞ ꠝꠘꠞ ꠘꠤꠡꠣꠘꠣ ꠀꠟꠣꠁꠟꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("C211_4","077_11_4","2CO","11","4","4","ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠎꠦ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤ, ꠅꠁꠘ꠆ꠘ ꠎꠘꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠘꠞꠦ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠁꠍꠣꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠦ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠝꠣꠘꠞꠣꠄ। ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠁꠍ, ꠅꠃ ꠙꠣꠇ ꠞꠥꠢꠥ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠞꠥꠢꠥ ꠙꠣꠁꠟꠦ, ꠛꠣ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠞꠣꠄ, ꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠢꠥꠘꠟꠦ, ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀꠃ ꠝꠣꠘꠤꠟꠤꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C211_5","077_11_5","2CO","11","5","5","ꠅꠁꠟꠦ ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠤ ꠘꠣ, ꠢꠃ ꠘꠣꠝ-ꠒꠣꠇꠤ ꠍꠣꠢꠣꠛꠤ ꠖꠟ ꠕꠣꠇꠤ ꠀꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠢꠥꠞꠥ। ");
INSERT INTO syls_vpl VALUES ("C211_6","077_11_6","2CO","11","6","6","ꠀꠝꠤ ꠎꠥꠖꠤꠅ ꠈꠥꠛ ꠝꠤꠑꠣ ꠝꠤꠑꠣ ꠡꠥꠞꠦ ꠅꠀꠎ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ ꠘꠣ, ꠔꠦꠛꠃ ꠀꠝꠣꠞ ꠔ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤꠞ ꠇꠝꠔꠤ ꠘꠣꠄ, ꠁꠔꠣ ꠔ ꠀꠝꠤ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠄ ꠢꠇꠟ ꠢꠣꠟꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C211_7","077_11_7","2CO","11","7","7","ꠔꠥꠝꠞꠣꠞ ꠃꠘ꠆ꠘꠔꠤ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠛꠤꠘꠣ ꠛꠦꠔꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ ꠘꠤꠎꠞꠦ ꠘꠤꠌꠣ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠇꠥꠘꠥ ꠙꠣꠙ ꠇꠞꠍꠤ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C211_8","077_11_8","2CO","11","8","8","ꠔꠥꠝꠞꠣꠞ ꠈꠦꠎꠝꠔꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠁꠘ꠆ꠘ ꠎꠝꠣꠔ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠣꠁꠎ꠆ꠎ ꠀꠘꠍꠤ, ꠇꠁꠔꠦ ꠉꠦꠟꠦ ꠔꠣꠞꠣꠞꠦ ꠟꠥꠐꠤꠀ ꠀꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C211_9","077_11_9","2CO","11","9","9","ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠅꠀꠞ ꠇꠣꠟꠅ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠅꠜꠣꠛꠅ ꠙꠠꠟꠣꠝ, ꠢꠃ ꠡꠝꠄꠅ ꠀꠝꠤ ꠇꠦꠃꠞꠞ ꠛꠥꠏꠣ ꠅꠁꠍꠤ ꠘꠣ। ꠇꠣꠞꠘ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠕꠣꠇꠤ ꠎꠦꠔꠣ ꠜꠣꠁꠀꠁꠘ ꠀꠁꠍꠟꠣ, ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠍꠂꠘ। ꠔꠦ ꠇꠥꠘꠥ ꠢꠣꠟꠔꠦꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠥꠏꠣ ꠅꠁꠍꠤ ꠘꠣ, ꠅꠁꠔꠣꠝꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C211_10","077_11_10","2CO","11","10","10","ꠀꠟ-ꠝꠍꠤꠞ ꠎꠦ ꠢꠇꠤꠇꠔꠤ ꠀꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠦ ꠅꠃ ꠢꠇꠞ ꠛꠟꠦꠃ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠀꠡ꠆ꠔꠣ ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠞ ꠇꠥꠘꠥ ꠎꠣꠉꠣꠔꠃ ꠀꠝꠣꠞ ꠁ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠦꠃ ꠛꠘ꠆ꠖ ꠇꠞꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C211_11","077_11_11","2CO","11","11","11","ꠀꠝꠤ ꠁꠟꠣ ꠝꠣꠔꠣꠞ ꠇꠣꠞꠘ ꠇꠤꠔꠣ? ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠤ ꠘꠣ ꠘꠤ? ꠄꠇ ꠀꠟ꠆ꠟꠣꠄꠃ ꠎꠣꠘꠂꠘ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠔ ꠝꠣꠄꠀ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C211_12","077_11_12","2CO","11","12","12","ꠘꠤꠎꠞ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠀ ꠎꠦꠉꠥꠁꠘ ꠀꠝꠞꠣꠞ ꠢꠝꠣꠘꠤ ꠅꠁꠔꠣ ꠌꠣꠁꠘ, ꠁꠔꠣꠄ ꠎꠣꠘꠥ ꠁ ꠡꠥꠎꠥꠉ ꠘꠣ ꠙꠣꠁꠘ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦꠈꠣꠘ ꠇꠞꠣꠔ ꠀꠍꠤ, ꠁꠈꠣꠘ ꠇꠞꠣꠔ ꠞꠁꠝꠥꠃ। ");
INSERT INTO syls_vpl VALUES ("C211_13","077_11_13","2CO","11","13","13","ꠀꠍꠟꠦ ꠔ ꠁꠔꠣ ꠅꠁꠟꠣ ꠜꠘ꠆ꠒ ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠐꠉ ꠇꠣꠝꠟꠣꠁꠘ। ꠔꠣꠞꠣ ꠘꠤꠎꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠢꠣꠛꠤ ꠖꠦꠈꠣꠁꠔ ꠇꠞꠤ ꠘꠤꠎꠞ ꠍꠥꠞꠔ ꠛꠖꠟꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C211_14","077_11_14","2CO","11","14","14","ꠄꠔꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ, ꠁꠛꠟꠤꠍꠦꠅ ꠔ ꠘꠤꠎꠞꠦ ꠘꠥꠞꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠞ ꠍꠥꠞꠔ ꠛꠖꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C211_15","077_11_15","2CO","11","15","15","ꠄꠞꠟꠣꠉꠤ ꠎꠦꠉꠥꠁꠘ꠆ꠔꠦ ꠁꠛꠟꠤꠍꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠂꠘ, ꠔꠣꠞꠣꠅ ꠎꠥꠖꠤ ꠘꠤꠎꠞ ꠍꠥꠞꠔ ꠛꠖꠟꠣꠁꠀ ꠖꠦꠈꠣꠁꠘ ꠔꠣꠞꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠞꠣ, ꠔꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠀꠞ ꠇꠤꠔꠣ ꠀꠍꠦ? ꠔꠣꠞꠣꠞ ꠇꠣꠝꠞ ꠚꠟ ꠔꠣꠞꠣ ꠀꠈꠦꠞꠣꠔꠅ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("C211_16","077_11_16","2CO","11","16","16","ꠀꠝꠤ ꠀꠞꠇꠛꠣꠞ ꠇꠁꠞꠣꠝ, ꠀꠝꠣꠞꠦ ꠎꠣꠘꠥ ꠇꠦꠃ ꠙꠣꠉꠟ ꠝꠘꠅ ꠘꠣ ꠇꠞꠦ। ꠀꠞ ꠎꠥꠖꠤ ꠁꠟꠣ ꠝꠘꠅ ꠇꠞꠤꠟꠣꠅ, ꠔꠦ ꠀꠝꠣꠞꠦ ꠄꠇ ꠙꠣꠉꠟ ꠢꠤꠡꠣꠛꠦꠃ ꠡꠝꠎꠤꠟꠣꠅ, ꠎꠣꠔꠦ ꠀꠝꠤꠅ ꠕꠥꠠꠣ ꠛꠠꠣꠁ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C211_17","077_11_17","2CO","11","17","17","ꠀꠝꠤ ꠅꠈꠘ ꠎꠦꠔꠣ ꠇꠁꠞꠣꠝ, ꠁꠔꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠢꠥꠇꠥꠝꠦ ꠇꠁꠞꠣꠝ ꠘꠣ, ꠈꠣꠟꠤ ꠘꠤꠎꠞ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠘꠤꠔ ꠉꠤꠀ ꠙꠣꠉꠟꠣꠝꠤ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C211_18","077_11_18","2CO","11","18","18","ꠛꠃꠔ ꠎꠘꠦ ꠎꠦꠛꠟꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠛꠤꠡꠄ ꠟꠁꠀ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠁꠞꠣ, ꠔꠦ ꠀꠝꠤ ꠇꠦꠘꠦ ꠖꠦꠈꠣꠁꠔꠣꠝ ꠘꠣ? ");
INSERT INTO syls_vpl VALUES ("C211_19","077_11_19","2CO","11","19","19","ꠔꠥꠝꠞꠣ ꠔ ꠛꠦꠡꠤ ꠀꠈꠟꠖꠣꠞ, ꠄꠞꠟꠣꠉꠤ ꠛꠦꠀꠈꠟ ꠅꠇꠟꠞꠦ ꠈꠥꠡ ꠖꠤꠟꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞ। ");
INSERT INTO syls_vpl VALUES ("C211_20","077_11_20","2CO","11","20","20","ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠎꠞ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠁꠀ ꠞꠣꠈꠦ, ꠔꠥꠝꠞꠣꠞꠦ ꠔꠣꠞ ꠡꠤꠇꠣꠞ ꠛꠣꠘꠣꠁꠟꠣꠄ, ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠃꠡ꠆ꠔꠣꠖꠤ ꠇꠞꠦ ꠛꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠣꠟꠅ ꠌꠠ ꠝꠣꠞꠦ, ꠔꠣ-ꠅ ꠔ ꠔꠥꠝꠞꠣ ꠈꠥꠡꠤ ꠅꠁꠀ ꠡꠁꠎ꠆ꠎ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C211_21","077_11_21","2CO","11","21","21","ꠅꠁꠟꠦ ꠀꠝꠤ ꠈꠥꠛ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤꠀꠞ, ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠛꠠ ꠇꠝꠎꠥꠞ ꠀꠍꠟꠣꠝ, ꠁꠟꠣ ꠘꠦꠔꠣꠉꠤꠞꠤ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠍꠤ ꠘꠣ। ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠟꠁꠀ ꠛꠠꠣꠁ ꠇꠞꠣꠞ ꠡꠣꠅꠡ ꠙꠣꠄ, ꠀꠝꠣꠞꠅ ꠡꠣꠅꠡ ꠀꠍꠦ ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠘꠤꠞ, ꠀꠝꠤ ꠈꠣꠟꠤ ꠙꠣꠉꠟꠞ ꠟꠣꠈꠣꠘ ꠁꠔꠣ ꠝꠣꠔꠤꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C211_22","077_11_22","2CO","11","22","22","ꠎꠦꠔꠣꠄ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠘ, ꠔꠣꠞꠣ ꠇꠤꠔꠣ ꠁꠛꠞꠣꠘꠤ ꠎꠣꠔꠤꠞ ꠘꠤ? ꠀꠝꠤꠅ ꠔ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ। ꠔꠣꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤꠞ ꠘꠤ? ꠀꠝꠤꠅ ꠅꠟꠣ। ꠔꠣꠞꠣ ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠅꠟꠣꠖ ꠘꠤ? ꠀꠝꠤꠅ ꠔ। ");
INSERT INTO syls_vpl VALUES ("C211_23","077_11_23","2CO","11","23","23","ꠔꠣꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠦꠎꠝꠔꠇꠣꠞꠤ ꠘꠤ? ꠀꠝꠤ ꠀꠞꠅ ꠛꠠ ꠈꠦꠎꠝꠔꠇꠣꠞꠤ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠙꠣꠉꠟꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠔꠤꠞꠣꠝ। ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠦꠎꠝꠔꠅ ꠟꠣꠉꠤꠀ ꠔꠣꠞꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠛꠦꠡꠤ ꠝꠦꠘꠔ ꠇꠞꠍꠤ। ꠛꠃꠔ ꠛꠣꠞ ꠎꠦꠟ ꠈꠣꠐꠍꠤ, ꠛꠃꠔ ꠛꠣꠞ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠈꠣꠁꠍꠤ, ꠀꠞ ꠛꠃꠔ ꠛꠣꠞ ꠝꠃꠔꠞ ꠝꠥꠇꠣꠛꠤꠟꠣ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C211_24","077_11_24","2CO","11","24","24","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠀꠝꠣꠞꠦ ꠙꠣꠌꠛꠣꠞ ꠖꠥꠞꠞꠣ ꠝꠣꠞꠍꠂꠘ, ꠙꠞꠔꠦꠇ ꠛꠣꠞ ꠃꠘꠥꠌꠣꠟ꠆ꠟꠤꠡꠐꠣ ꠇꠞꠤ ꠖꠥꠞꠞꠣ ꠈꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C211_25","077_11_25","2CO","11","25","25","ꠔꠤꠘꠛꠣꠞ ꠀꠝꠣꠞꠦ ꠍꠤꠋꠟꠣꠖꠤ ꠝꠣꠞꠣ ꠅꠁꠍꠦ। ꠄꠇꠛꠣꠞ ꠀꠝꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠣ ꠅꠁꠍꠦ। ꠔꠤꠘꠛꠣꠞ ꠀꠝꠣꠞ ꠎꠣꠎ ꠒꠥꠛꠤ ꠉꠦꠍꠤꠟ, ꠀꠞ ꠄꠇ ꠖꠤꠘ ꠄꠇ ꠞꠣꠁꠔ ꠖꠞꠤꠀꠞ ꠙꠣꠘꠤꠔ ꠜꠣꠡꠣꠁꠟ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C211_26","077_11_26","2CO","11","26","26","ꠀꠝꠤ ꠛꠃꠔ ꠖꠦꠡ ꠍꠚꠞ ꠇꠞꠍꠤ। ꠛꠣꠘ-ꠙꠣꠘꠤꠞ ꠀꠔꠅ, ꠌꠥꠞ-ꠒꠣꠇꠣꠁꠔꠞ ꠀꠔꠅ, ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠀꠔꠅ ꠀꠞ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠀꠔꠅ ꠀꠝꠤ ꠝꠍꠤꠛꠔꠅ ꠙꠠꠍꠤ। ꠄꠍꠣꠠꠣ ꠐꠣꠃꠘꠅ, ꠝꠞꠥꠜꠥꠝꠤꠔ, ꠖꠞꠤꠀꠔ, ꠀꠞ ꠜꠘ꠆ꠒ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠀꠔꠅꠃ ꠀꠝꠤ ꠝꠍꠤꠛꠔꠅ ꠙꠠꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C211_27","077_11_27","2CO","11","27","27","ꠅꠃ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦꠅ ꠎꠣꠘꠦ-ꠙꠞꠣꠘꠦ ꠝꠦꠘꠔ ꠇꠞꠍꠤ, ꠛꠃꠔ ꠞꠣꠁꠔ ꠃꠎꠣꠉꠞꠤ ꠇꠞꠍꠤ, ꠈꠣꠘꠤ-ꠙꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠡ꠆ꠐ ꠙꠣꠁꠍꠤ, ꠛꠃꠔ ꠃꠙꠣꠡ-ꠈꠣꠙꠣꠡ ꠞꠁꠍꠤ, ꠡꠤꠔ ꠀꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠꠞ ꠅꠜꠣꠛꠦꠅ ꠇꠡ꠆ꠐ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C211_28","077_11_28","2CO","11","28","28","ꠁꠔꠣ ꠍꠣꠠꠣꠅ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠝꠣꠔ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C211_29","077_11_29","2CO","11","29","29","ꠇꠦꠃ ꠇꠝꠎꠥꠞ ꠅꠁꠟꠦ ꠀꠝꠤ ꠘꠤꠎꠦꠅ ꠔꠣꠞ ꠇꠝꠎꠥꠞꠤꠞ ꠜꠣꠉꠤ ꠅꠁ ꠘꠣ ꠘꠤ? ꠇꠥꠘꠥ ꠇꠥ-ꠡꠋꠉꠤꠞ ꠔꠣꠟꠅ ꠙꠠꠤꠀ ꠇꠦꠃ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠉꠦꠟꠦꠉꠤ, ꠀꠝꠤ ꠅꠡꠣꠘ꠆ꠔꠤ ꠇꠞꠤ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C211_30","077_11_30","2CO","11","30","30","ꠀꠝꠤ ꠎꠥꠖꠤ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠁꠔꠣꠝ ꠌꠣꠁ, ꠔꠦ ꠅꠃ ꠇꠝꠎꠥꠞꠤ ꠟꠁꠀꠃ ꠛꠠꠣꠁ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C211_31","077_11_31","2CO","11","31","31","ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ, ꠎꠦꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠉꠃꠞꠛ ꠙꠣꠅꠀꠞ ꠟꠣꠈ, ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠎꠣꠘꠂꠘ, ꠀꠝꠤ ꠇꠥꠘ꠆ꠔꠣꠃ ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("C211_32","077_11_32","2CO","11","32","32","ꠖꠣꠝꠦꠡ꠆ꠇꠞ ꠛꠣꠖꠡꠣ ꠀꠞꠤꠔꠣꠞ ꠢꠣꠇꠤꠝ ꠍꠣꠛꠦ ꠀꠝꠣꠞꠦ ꠗꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠣꠝꠦꠡ꠆ꠇ ꠐꠣꠃꠘꠅ ꠙꠣꠞꠣ ꠖꠦꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C211_33","077_11_33","2CO","11","33","33","ꠅꠁꠟꠦ ꠐꠣꠃꠘꠞ ꠛꠣꠃꠘ꠆ꠒꠞꠤꠞ ꠅꠀꠟꠞ ꠝꠣꠎꠦ ꠎꠦ ꠈꠤꠠꠇꠤ ꠀꠍꠤꠟ, ꠝꠥꠝꠤꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠄꠇ ꠐꠥꠇꠞꠤꠔ ꠇꠞꠤ ꠅꠃ ꠈꠤꠠꠇꠤ ꠛꠣꠄꠖꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠐꠤꠔ ꠟꠣꠝꠣꠁ ꠖꠤꠍꠟꠣ, ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠀꠝꠤ ꠔꠣꠘ ꠀꠔ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C212_1","077_12_1","2CO","12","1","1","ꠔꠦ ꠀꠝꠣꠞ ꠀꠞꠅ ꠇꠤꠍꠥ ꠛꠠꠣꠁ ꠇꠞꠣ ꠖꠞꠇꠣꠞ, ꠁ ꠛꠠꠣꠁꠄ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠘꠣꠁ, ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠎꠦ ꠖꠞꠡꠘ ꠖꠦꠈꠣꠁꠍꠂꠘ ꠀꠞ ꠎꠦꠔꠣ ꠎꠣꠘꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠅꠈꠘ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C212_2","077_12_2","2CO","12","2","2","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠄꠇꠎꠘ ꠈꠣꠖꠤꠝꠞꠦ ꠀꠝꠤ ꠌꠤꠘꠤ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠌꠃꠖ꠆ꠖ ꠛꠍꠞ ꠀꠉꠦ ꠝꠦꠞꠣꠎ ꠡꠞꠤꠚꠞ ꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠍꠤꠟ। ꠔꠣꠁꠘ ꠎꠣꠘ꠆ꠘꠣꠔꠥꠟ-ꠚꠦꠞꠖꠃꠍꠅ ꠉꠦꠟꠣ, ꠁ ꠡꠝꠄ ꠔꠣꠁꠘ ꠡ-ꠡꠞꠤꠟꠦ ꠉꠦꠍꠂꠘ ꠇꠤ ꠘꠣ ꠎꠣꠘꠤ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠄꠃ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C212_3","077_12_3","2CO","12","3","3","ꠔꠦ ꠄꠘꠞꠦ ꠀꠝꠤ ꠌꠤꠘꠤ, ꠅꠁꠟꠦ ꠔꠣꠘꠦ ꠡ-ꠡꠞꠤꠟꠦ ꠘꠦꠅꠀ ꠅꠁꠍꠦ ꠇꠤ ꠘꠣ ꠀꠝꠤ ꠎꠣꠘꠤ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("C212_4","077_12_4","2CO","12","4","4","ꠝꠦꠞꠣꠎ ꠡꠞꠤꠚꠅ ꠘꠤꠀ ꠢꠣꠞꠟꠦ ꠔꠣꠘ ꠟꠉꠦ ꠛꠃꠔ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠛꠣꠔꠌꠤꠔ ꠝꠣꠘꠡꠞꠦ ꠢꠥꠘꠣꠘꠤ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C212_5","077_12_5","2CO","12","5","5","ꠅꠃꠟꠣ ꠝꠣꠘꠡꠞꠦ ꠟꠁꠀ ꠀꠝꠤ ꠛꠠꠣꠁ ꠇꠞꠝꠥ। ꠀꠝꠣꠞ ꠘꠤꠎꠞꠦ ꠟꠁꠀ ꠇꠥꠘꠥ ꠛꠠꠣꠁ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠀꠝꠣꠞ ꠇꠝꠎꠥꠞꠤꠞ ꠟꠣꠉꠤ ꠛꠠꠣꠁ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C212_6","077_12_6","2CO","12","6","6","ꠅꠃ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠁꠔꠦ ꠌꠣꠁꠟꠦꠅ, ꠀꠝꠤ ꠇꠥꠘꠥ ꠛꠦꠀꠈꠟꠤ ꠇꠞꠔꠣꠝ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠢꠣꠍꠣ ꠝꠣꠔ ꠝꠣꠔꠤꠝꠥ। ꠔꠣ-ꠅ ꠀꠝꠤ ꠛꠠꠣꠁ ꠖꠦꠈꠣꠘꠤ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠟꠣꠝ, ꠇꠤꠎꠣꠘꠥ ꠀꠝꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠖꠦꠈꠤꠀ ꠛꠣ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠢꠥꠘꠤꠀ, ꠝꠣꠘꠡꠦ ꠅꠈꠘ ꠀꠝꠣꠞꠦ ꠎꠔꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠄꠞ ꠌꠣꠁꠔꠦ ꠛꠦꠡꠤ ꠝꠘꠅ ꠇꠞꠤꠟꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("C212_7","077_12_7","2CO","12","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠅꠔ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞ ꠎꠣꠘꠣꠘꠤꠄ ꠀꠝꠣꠞ ꠖꠤꠟꠅ ꠎꠣꠘꠥ ꠅꠢꠋꠇꠣꠞ ꠘꠣ ꠀꠄ, ꠅꠃ ꠘꠤꠅꠔꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠡꠞꠤꠟꠅ ꠄꠇꠐꠣ ꠞꠤꠙꠥ ꠖꠤꠟꠣ, ꠀꠝꠣꠞꠦ ꠇꠡ꠆ꠐ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ, ꠅꠃ ꠞꠤꠙꠥ ꠅꠁꠟ ꠁꠛꠟꠤꠍꠞ ꠌꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("C212_8","077_12_8","2CO","12","8","8","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠤ ꠔꠤꠘꠛꠣꠞ ꠀꠞꠎ ꠇꠞꠍꠟꠣꠝ, ꠅꠃ ꠞꠤꠙꠥꠉꠥ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠀ ꠘꠤꠔꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("C212_9","077_12_9","2CO","12","9","9","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠎꠥꠀꠙ ꠖꠤꠟꠣ, “ꠀꠝꠣꠞ ꠞꠢꠝꠔꠃ ꠔꠥꠝꠣꠞ ꠛꠃꠔꠔꠣ, ꠀꠝꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠝꠤꠟꠦ ꠈꠣꠟꠤ ꠇꠝꠎꠥꠞ ꠢꠣꠟꠔꠦ।” ꠄꠞꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠇꠝꠎꠥꠞꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠈꠥꠡꠤ ꠝꠘꠦꠃ ꠛꠠꠣꠁ ꠇꠞꠝꠥ, ꠎꠣꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠅꠃ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("C212_10","077_12_10","2CO","12","10","10","ꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠘꠣꠘꠣꠘ ꠟꠣꠈꠣꠘ ꠇꠝꠎꠥꠞꠤ, ꠛꠦꠁꠎ꠆ꠎꠔꠤ, ꠅꠜꠣꠛ-ꠅꠘꠐꠘ, ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ, ꠀꠞ ꠛꠦꠚꠣꠘꠣꠔ ꠙꠠꠟꠦꠅ ꠀꠝꠤ ꠈꠥꠡꠤ ꠅꠁ। ꠇꠣꠞꠘ ꠇꠝꠎꠥꠞ ꠢꠣꠟꠔꠦꠃ ꠀꠝꠤ ꠛꠟꠛꠣꠘ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("C212_11","077_12_11","2CO","12","11","11","ꠀꠝꠤ ꠙꠣꠉꠟ ꠅꠁꠍꠤ ꠑꠤꠇꠃ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠃ ꠀꠝꠣꠞꠦ ꠙꠣꠉꠟ ꠅꠁꠔꠦ ꠛꠣꠁꠖ꠆ꠖ ꠇꠞꠍ। ꠔꠥꠝꠞꠣꠞ ꠃꠌꠤꠔ ꠀꠍꠤꠟ ꠀꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠣ। ꠀꠝꠤ ꠎꠥꠖꠤꠅ ꠈꠥꠛ ꠡꠣꠗꠣꠞꠘ ꠝꠣꠘꠥꠡ, ꠔꠦꠛꠃ ꠔꠥꠝꠞꠣꠞ ꠢꠃ ꠘꠣꠝ-ꠒꠣꠇꠤ ꠍꠣꠢꠣꠛꠤ ꠖꠟ ꠕꠣꠇꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠢꠥꠞꠥ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C212_12","077_12_12","2CO","12","12","12","ꠀꠝꠤ ꠘꠤꠎꠞꠦ ꠄꠇꠎꠘ ꠢꠇ ꠍꠣꠢꠣꠛꠤ ꠢꠤꠡꠣꠛꠦ ꠙꠞꠝꠣꠘ ꠇꠞꠍꠤ, ꠛꠃꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ, ꠇꠥꠖꠞꠔꠤ ꠘꠤꠡꠣꠘꠣ ꠀꠞ ꠝꠥꠎꠦꠎꠣ ꠖꠦꠈꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C212_13","077_12_13","2CO","12","13","13","ꠀꠁꠌ꠆ꠍꠣ ꠇꠅ ꠌꠣꠁꠘ, ꠅꠁꠘ꠆ꠘ ꠎꠝꠣꠔ ꠅꠇꠟ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦ ꠢꠥꠞꠥ ꠘꠤ? ꠅꠄ, ꠈꠣꠟꠤ ꠄꠇꠐꠣ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠞꠥ ꠀꠍ, ꠁꠔꠣ ꠅꠁꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠛꠥꠏꠣ ꠅꠁꠍꠤ ꠘꠣ। ꠁ ꠜꠥꠟꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞꠦ ꠝꠣꠚꠤ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("C212_14","077_12_14","2CO","12","14","14","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠅꠃ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠛꠣꠞ ꠎꠥꠁꠔ ꠅꠁꠟꠣꠝ, ꠔꠦ ꠀꠝꠤ ꠇꠥꠘꠥ ꠛꠥꠏꠣ ꠅꠁꠔꠣꠝ ꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘꠥ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠌꠣꠁꠞꠣꠝ ꠘꠣ, ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠌꠣꠁꠞꠣꠝ। ꠝꠣ-ꠛꠣꠚꠞ ꠟꠣꠉꠤ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠎꠝꠣꠘꠤ ꠔ ꠀꠅꠟꠣꠖꠞ ꠚꠞꠎ ꠘꠣꠄ, ꠛꠞꠋ ꠝꠣ-ꠛꠣꠚꠞ ꠃꠌꠤꠔ ꠅꠁꠟ ꠀꠅꠟꠣꠖꠞ ꠟꠣꠉꠤ ꠗꠘ ꠎꠝꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("C212_15","077_12_15","2CO","12","15","15","ꠔꠦ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠀꠃ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠢꠇꠟꠔꠣ ꠈꠞꠌ ꠇꠞꠝꠥ, ꠀꠝꠣꠞ ꠘꠤꠎꠞꠦꠅ ꠛꠤꠟꠣꠁ ꠖꠤꠝꠥ। ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦꠡ ꠇꠞꠤ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠀꠞ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠦꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠝ ꠝꠣꠄꠀ ꠇꠞꠞꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("C212_16","077_12_16","2CO","12","16","16","ꠎꠣꠁ ꠅꠃꠇ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠥꠏꠣ ꠅꠁꠍꠤ ꠘꠣ, ꠀꠞꠘꠣꠄ ꠇꠦꠃ ꠇꠁꠟꠤꠔ ꠙꠣꠞꠦ, ꠀꠝꠤ ꠌꠣꠟꠣꠇꠤ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠗꠥꠇꠣ ꠖꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C212_17","077_12_17","2CO","12","17","17","ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠎꠦꠞꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠟꠣꠝ, ꠄꠞꠣꠞꠦꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠐꠉꠣꠁꠍꠤ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("C212_18","077_12_18","2CO","12","18","18","ꠔꠤꠔꠣꠍ ꠜꠣꠁꠞꠦ ꠀꠝꠤ ꠝꠤꠘꠔ ꠇꠞꠟꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ, ꠔꠣꠘ ꠟꠉꠦ ꠢꠃ ꠜꠣꠁꠞꠦꠅ ꠙꠣꠑꠣꠁꠟꠣꠝ। ꠔꠦ ꠅꠃ ꠔꠤꠔꠣꠍꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠐꠉꠤꠍꠂꠘ ꠘꠤ? ꠀꠝꠤ ꠀꠞ ꠔꠤꠔꠣꠍ, ꠀꠝꠞꠣ ꠖꠥꠁꠅꠎꠘꠦ ꠔ ꠄꠇꠁ ꠞꠥꠢꠦ ꠀꠞ ꠄꠇꠁ ꠘꠤꠅꠔꠦ ꠇꠣꠝ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("C212_19","077_12_19","2CO","12","19","19","ꠀꠁꠌ꠆ꠍꠣ, ꠔꠥꠝꠞꠣ ꠝꠘꠅ ꠇꠞꠞꠣꠄ ꠘꠤ, ꠅꠃ ꠌꠤꠑꠤ ꠟꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠘꠤꠎꠞ ꠖꠥꠡ ꠇꠣꠐꠣꠁꠞꠣꠝ? ꠘꠣ, ꠁꠈꠣꠘ ꠑꠤꠇ ꠘꠣꠄ, ꠅ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟ, ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠖꠤꠝ ꠢꠤꠡꠣꠛꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠀꠎꠤꠞ-ꠘꠣꠎꠤꠞ ꠞꠣꠈꠤꠀ ꠟꠦꠈꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣꠞ ꠘꠤꠅꠔꠦꠃ ꠁꠔꠣ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("C212_20","077_12_20","2CO","12","20","20","ꠀꠍꠟꠦ ꠀꠝꠣꠞ ꠈꠥꠛ ꠒꠞ ꠇꠞꠦꠞ, ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ, ꠀꠁꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠟꠣ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠁꠟꠣꠈꠣꠘ ꠎꠥꠁꠔ ꠘꠣ ꠅꠅ, ꠀꠞ ꠔꠥꠝꠞꠣꠅ ꠀꠝꠣꠞ ꠎꠦ ꠞꠥꠙ ꠖꠦꠈꠔꠣꠄ ꠌꠣꠅ ꠘꠣ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠢꠃ ꠞꠥꠙ ꠖꠦꠈꠣꠘꠤ ꠟꠣꠉꠦ। ꠛꠣ ꠀꠁꠀ ꠖꠦꠈꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ, ꠁꠋꠡꠣ-ꠘꠤꠘ꠆ꠖꠣ, ꠞꠣꠉ-ꠉꠥꠍꠣ, ꠖꠟꠣꠖꠟꠤ, ꠙꠞꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠅꠀ, ꠉꠤꠛꠔ ꠉꠣꠅꠀ, ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠀꠞ ꠉꠥꠟꠝꠣꠟ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C212_21","077_12_21","2CO","12","21","21","ꠀꠝꠣꠞ ꠜꠤꠔꠞꠦ ꠒꠞ ꠇꠞꠦꠞ, ꠀꠝꠤ ꠀꠞꠇꠛꠣꠞ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞꠦ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠣꠁꠘ, ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠉꠥꠘꠣ ꠇꠞꠍꠂꠘ, ꠎꠦꠔꠣꠄ ꠘꠣꠙꠣꠇꠤ ꠇꠣꠝ, ꠎꠤꠘꠣ, ꠀꠞ ꠛꠖꠝꠣꠁꠡꠤ ꠇꠞꠤꠀ ꠔꠃꠛꠣ ꠇꠞꠍꠦ ꠘꠣ, ꠅꠔꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠘꠤ ꠀꠝꠤ ꠝꠘꠞ ꠝꠣꠎꠦ ꠇꠡ꠆ꠐ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C213_1","077_13_1","2CO","13","1","1","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠝꠤ ꠅꠃ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠞꠣꠝ। ꠎꠣꠘ ꠔ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, “ꠖꠥꠁ ꠛꠣ ꠔꠤꠘ ꠎꠘ ꠝꠣꠘꠡꠦ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠟꠦ ꠅꠃ ꠛꠦꠙꠣꠞ ꠢꠣꠍꠣ ꠙꠞꠝꠣꠘ ꠅꠄ।” ");
INSERT INTO syls_vpl VALUES ("C213_2","077_13_2","2CO","13","2","2","ꠔꠦ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠉꠦꠍꠟꠣꠝ, ꠢꠃ ꠍꠚꠞꠞ ꠀꠉꠦ ꠎꠦꠞꠣ ꠉꠥꠘꠣ-ꠇꠍꠥꠞꠤ ꠇꠞꠍꠤꠟ, ꠀꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠀꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤ ꠖꠤꠍꠟꠣꠝ। ꠀꠞ ꠅꠈꠘ ꠀꠝꠤ ꠘꠤꠎꠦ ꠀꠎꠤꠞ ꠘꠣ ꠅꠁꠟꠦꠅ ꠔꠣꠞꠣꠞꠦ ꠅꠟꠣ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤ ꠖꠤꠞꠣꠝ, ꠀꠝꠤ ꠀꠞꠇꠛꠣꠞ ꠀꠁꠟꠦ ꠔꠣꠞꠣ ꠇꠦꠃ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C213_3","077_13_3","2CO","13","3","3","ꠔꠥꠝꠞꠣ ꠛꠥꠟꠦ ꠙꠞꠝꠣꠘ ꠌꠣꠁꠞꠣꠄ, ꠀꠝꠣꠞ ꠝꠥꠈ ꠖꠤꠀ ꠀꠟ-ꠝꠍꠤꠄ ꠝꠣꠔꠤꠞꠣ ꠘꠤ। ꠀꠍꠟꠦ ꠀꠟ-ꠝꠍꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠇꠝꠎꠥꠞ ꠘꠣꠄ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠎꠤꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("C213_4","077_13_4","2CO","13","4","4","ꠎꠥꠖꠤꠅ ꠔꠣꠘꠞꠦ ꠇꠝꠎꠥꠞ ꠢꠣꠟꠔꠦ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ, ꠔꠣ-ꠅ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠔꠣꠁꠘ ꠅꠈꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ। ꠀꠞ ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠔꠣꠘ ꠟꠣꠈꠣꠘ ꠇꠝꠎꠥꠞ ꠀꠍꠤ, ꠅꠁꠟꠦ ꠔꠣꠘ ꠟꠉꠦ ꠎꠤꠘ꠆ꠖꠣ ꠞꠅꠀꠄ ꠀꠟ꠆ꠟꠣꠁ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠝꠥꠇꠣꠛꠤꠟꠣ ꠅꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("C213_5","077_13_5","2CO","13","5","5","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞꠦ ꠎꠣꠌꠣꠁ ꠇꠞꠤ ꠖꠦꠈꠅ, ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠢꠣꠍꠣꠞꠞ ꠁꠝꠣꠘ ꠀꠍꠦ ꠘꠤ? ꠔꠥꠝꠞꠣ ꠛꠥꠎ ꠘꠣ ꠘꠤ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠀꠍꠂꠘ। ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠎꠣꠌꠣꠁ ꠇꠞꠣꠔ ꠉꠤꠀ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠜꠦꠎꠣꠟ ꠘꠣ ꠝꠤꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("C213_6","077_13_6","2CO","13","6","6","ꠀꠞ ꠀꠝꠤ ꠀꠡꠣ ꠇꠞꠤ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠛꠣꠄ, ꠀꠝꠞꠣ ꠔ ꠈꠣꠐꠤ ꠢꠤꠡꠣꠛꠦ ꠙꠞꠝꠣꠘ ꠅꠁꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("C213_7","077_13_7","2CO","13","7","7","ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠛꠖ ꠇꠣꠝ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠞꠅ। ꠀꠝꠞꠣ ꠘꠤꠎꠞ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠈꠣꠘ ꠇꠁꠞꠣꠝ ꠘꠣ। ꠀꠞ ꠝꠣꠘꠡꠦ ꠀꠝꠞꠣꠞꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠘꠅ ꠘꠣ ꠇꠞꠟꠦꠅ, ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠔ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("C213_8","077_13_8","2CO","13","8","8","ꠀꠝꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠅꠁꠟ ꠢꠇꠞ ꠙꠇ꠆ꠇꠦ, ꠘꠣ-ꠢꠇꠞ ꠙꠇ꠆ꠇꠦ ꠀꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠛꠟ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("C213_9","077_13_9","2CO","13","9","9","ꠔꠦ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠇꠝꠎꠥꠞ ꠀꠞ ꠔꠥꠝꠞꠣ ꠛꠟꠛꠣꠘ, ꠁꠔꠣ ꠖꠦꠈꠟꠦ ꠀꠝꠞꠣ ꠈꠥꠡꠤ। ꠀꠝꠞꠣ ꠖꠥꠀ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠤꠀ ꠢꠣꠞꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠈꠣꠐꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("C213_10","077_13_10","2CO","13","10","10","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠞꠁꠀ ꠁꠔꠣ ꠟꠦꠈꠞꠣꠝ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠖꠦꠅꠀ ꠈꠦꠝꠔꠣ ꠈꠣꠐꠣꠁꠀ ꠇꠐꠥ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠣ ꠘꠣ ꠟꠣꠉꠦ। ꠝꠣꠟꠤꠇꠦ ꠀꠝꠣꠞꠦ ꠁ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠂꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣꠞ ꠟꠣꠉꠤ, ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("C213_11","077_13_11","2CO","13","11","11","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠢꠦꠡ-ꠝꠦꠡ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠅ, ꠘꠤꠎꠞꠦ ꠇꠣꠝꠤꠟ ꠛꠣꠘꠣꠅ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠘꠍꠤꠅꠔ ꠇꠞꠅ, ꠄꠇꠁ ꠝꠘꠜꠣꠛꠦ ꠞꠅ, ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠡꠔ ꠇꠞꠅ। ꠔꠦꠃ ꠡꠣꠘ꠆ꠔꠤꠞ ꠀꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠀꠟ꠆ꠟꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("C213_12","077_13_12","2CO","13","12","12","ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠙꠛꠤꠔ꠆ꠞ ꠉꠟꠣꠉꠟꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("C213_13","077_13_13","2CO","13","13","13","ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠟ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("C213_14","077_13_14","2CO","13","14","14","ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠢꠛ꠆ꠛꠔ, ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠈꠣꠔꠤꠞ-ꠎꠔꠘ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠖꠤꠟꠅ ꠞꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("GL1_1","078_1_1","GAL","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤ। ꠀꠝꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠢꠥꠇꠥꠝ-ꠙꠞꠣꠝꠤꠡꠦ ꠛꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠍꠣꠢꠣꠛꠤ ꠅꠁꠍꠤ ꠘꠣ। ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠀꠞ ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ, ꠎꠦꠁꠘ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠍꠂꠘ, ꠄꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GL1_2","078_1_2","GAL","1","2","2","ꠀꠝꠤ ꠀꠞ ꠀꠝꠣꠞ ꠟꠉꠞ ꠢꠇꠟ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠝꠤꠟꠤꠀ, ꠉꠣꠟꠣꠔꠤꠀ ꠖꠦꠡꠞ ꠁꠍꠣꠄꠁ ꠎꠝꠣꠔ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠅꠃ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL1_3","078_1_3","GAL","1","3","3","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GL1_4","078_1_4","GAL","1","4","4","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠥꠘꠡꠣꠄ, ꠢꠃ ꠁꠍꠣꠄ ꠀꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠅꠃ ꠈꠣꠞꠣꠙ ꠎꠝꠣꠘꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GL1_5","078_1_5","GAL","1","5","5","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠔꠣꠞꠤꠚ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠣꠞꠤ ꠞꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("GL1_6","078_1_6","GAL","1","6","6","ꠀꠝꠤ ꠛꠠ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠍꠤ, ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠦ ꠎꠦꠁꠘ ꠒꠣꠇꠤꠀ ꠀꠘꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠎꠞ ꠛꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠔꠣꠘꠦ ꠍꠣꠠꠤꠀ ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣ ꠅꠔ ꠎꠟꠖꠤ ꠀꠞꠇ ꠘꠝꠥꠘꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠉꠦꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL1_7","078_1_7","GAL","1","7","7","ꠀꠍꠟꠦ ꠔ ꠁꠐꠣ ꠇꠥꠘꠥ ꠈꠥꠡ-ꠈꠛꠞꠤꠃ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠍꠦ, ꠎꠦꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠟꠁꠀ ꠈꠦꠁꠠ ꠈꠦꠟꠣꠁꠞꠣ, ꠔꠣꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞꠦ ꠃꠟ꠆ꠐꠣ-ꠙꠣꠟ꠆ꠐꠣ ꠇꠞꠤꠟꠔꠣ ꠌꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GL1_8","078_1_8","GAL","1","8","8","ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤ, ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠄ, ꠁꠔꠣ ꠎꠥꠖꠤ ꠀꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠇꠞꠤ, ꠛꠣ ꠀꠍꠝꠣꠘꠤ ꠇꠥꠘꠥ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠁꠀ ꠇꠞꠂꠘ, ꠔꠦ ꠅꠉꠥꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GL1_9","078_1_9","GAL","1","9","9","ꠀꠝꠤ ꠀꠉꠦ ꠎꠦꠝꠘꠦ ꠇꠁꠍꠤ, ꠅꠈꠘ ꠢꠤꠞꠛꠣꠞ ꠅꠃꠟꠣ ꠇꠁꠞꠣꠝ, ꠀꠉꠞ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠍ, ꠁꠔꠣ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠇꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠟꠦ, ꠅꠉꠥꠞ ꠃꠙꠞꠦ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GL1_10","078_1_10","GAL","1","10","10","ꠁꠔꠣ ꠇꠞꠤꠀ ꠀꠝꠤ ꠇꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠞꠤꠚ ꠙꠣꠁꠔꠣꠝ ꠌꠣꠁꠀꠞ, ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠘꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ? ꠀꠝꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤꠀꠞ ꠘꠤ? ꠀꠝꠤ ꠎꠥꠖꠤ ꠅꠈꠘꠅ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠔꠣꠝ, ꠔꠦ ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠖꠤꠝ ꠅꠁꠟꠣꠝ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("GL1_11","078_1_11","GAL","1","11","11","ꠅ ꠜꠣꠁꠍꠣꠛ ꠅꠇꠟ, ꠀꠙꠘꠣꠞꠣ ꠎꠣꠘꠤꠀ ꠞꠣꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠔ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠔꠛꠣꠖ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL1_12","078_1_12","GAL","1","12","12","ꠀꠝꠤ ꠁꠔꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍꠤ ꠘꠣ, ꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠁꠔꠣ ꠢꠤꠇꠣꠁꠍꠦꠅ ꠘꠣ। ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠘꠤꠎꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GL1_13","078_1_13","GAL","1","13","13","ꠀꠝꠤ ꠀꠉꠦ ꠎꠦꠛꠟꠣ ꠁꠢꠥꠖꠤ ꠗꠞ꠆ꠝ ꠝꠣꠘꠔꠣꠝ, ꠢꠃ ꠡꠝꠄ ꠀꠝꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠇꠤꠟꠣ ꠀꠍꠤꠟ ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣ ꠢꠥꠘꠍ। ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠇꠔ ꠛꠦꠡꠤ ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣꠝ, ꠀꠞ ꠁꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠌꠦꠡ꠆ꠐꠣꠔ ꠀꠍꠟꠣꠝ, ꠄꠅꠔꠣ ꠔꠥꠝꠞꠣ ꠎꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GL1_14","078_1_14","GAL","1","14","14","ꠀꠝꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠡꠞꠣ-ꠞꠍꠥꠝꠔ ꠝꠣꠘꠣꠔꠅ ꠀꠝꠤ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠀꠍꠟꠣꠝ। ꠄꠞꠖꠣꠄ ꠀꠝꠣꠞ ꠛꠄꠅꠡꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣ-ꠛꠤꠟ꠆ꠟꠣ ꠇꠞꠣꠔ ꠀꠝꠤ ꠛꠃꠔ ꠀꠉꠥꠀꠁꠟ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL1_15","078_1_15","GAL","1","15","15","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠀꠝꠣꠞ ꠝꠣʼꠞ ꠙꠦꠐꠅ ꠕꠣꠇꠔꠦꠃ ꠀꠝꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠘꠤꠎꠞ ꠞꠢꠝꠔꠦ ꠀꠝꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ। ꠔꠣꠘ ꠝꠥꠘꠡꠣ ꠀꠍꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("GL1_16","078_1_16","GAL","1","16","16","ꠀꠝꠤ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠀ, ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤ। ꠔꠦ ꠅꠃ ꠖꠤꠖꠣꠞ ꠙꠣꠁꠀꠅ ꠀꠝꠤ ꠇꠥꠘꠥ ꠀꠖꠝ ꠎꠣꠔꠞ ꠟꠉꠦ ꠙꠞꠣꠝꠤꠡ ꠇꠞꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL1_17","078_1_17","GAL","1","17","17","ꠀꠞ ꠀꠝꠣꠞ ꠀꠉꠞ ꠇꠥꠘꠥ ꠍꠣꠢꠣꠛꠤꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ ꠈꠣꠘꠅ-ꠅ ꠉꠦꠍꠤ ꠘꠣ। ꠛꠞꠋ ꠀꠝꠤ ꠀꠞꠛ ꠖꠦꠡꠅ ꠉꠦꠍꠟꠣꠝꠉꠤ, ꠉꠤꠀ ꠊꠥꠞꠤ-ꠚꠤꠞꠤ ꠢꠤꠞꠛꠣꠞ ꠖꠣꠝꠦꠡ꠆ꠇ ꠐꠣꠃꠘꠅ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GL1_18","078_1_18","GAL","1","18","18","ꠄꠞ ꠔꠤꠘ ꠛꠞꠍ ꠛꠣꠖꠦ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠉꠦꠍꠟꠣꠝ, ꠉꠤꠀ ꠔꠣꠘ ꠅꠘꠅ ꠙꠘꠞ ꠖꠤꠘ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL1_19","078_1_19","GAL","1","19","19","ꠅꠃ ꠡꠝꠄ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠜꠣꠁ ꠍꠣꠢꠣꠛꠤ ꠁꠀꠇꠥꠛ ꠍꠣꠠꠣ, ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠍꠣꠢꠣꠛꠤꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠖꠦꠈꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL1_20","078_1_20","GAL","1","20","20","ꠄꠇ ꠀꠟ꠆ꠟꠣ ꠡꠣꠇ꠆ꠇꠤ ꠀꠍꠂꠘ, ꠀꠝꠤ ꠅꠃ ꠎꠦꠔꠣ ꠟꠦꠈꠟꠣꠝ, ꠄꠞ ꠄꠇꠐꠣ ꠢꠞꠚꠅ ꠝꠤꠍꠣ ꠘꠣꠄ। ꠝꠘꠅ ꠞꠣꠈꠛꠣ, ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍꠤ ꠘꠣ, ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠘꠤꠎꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GL1_21","078_1_21","GAL","1","21","21","ꠛꠣꠖꠦ ꠀꠝꠤ ꠡꠤꠞꠤꠀ ꠀꠞ ꠇꠤꠟꠤꠇꠤꠀ ꠖꠦꠡꠞ ꠛꠃꠔ ꠎꠣꠉꠣꠔ ꠉꠦꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL1_22","078_1_22","GAL","1","22","22","ꠅꠃ ꠡꠝꠄ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠞ ꠁꠍꠣꠄꠁ ꠎꠝꠣꠔ ꠅꠇꠟꠦꠅ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠔꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL1_23","078_1_23","GAL","1","23","23","ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠅꠃ ꠈꠛꠞ ꠢꠥꠘꠍꠤꠟꠣ, “ꠀꠉꠦ ꠎꠦ ꠛꠦꠐꠣꠄ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠔ, ꠀꠞ ꠁꠍꠣꠞ ꠘꠣꠝꠞꠦ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠔꠥꠠꠤꠟꠤꠔ ꠌꠣꠁꠍꠤꠟ, ꠅꠈꠘ ꠢꠃ ꠛꠦꠐꠣꠄ ꠀꠟ-ꠝꠍꠤꠞ ꠁꠝꠣꠘꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("GL1_24","078_1_24","GAL","1","24","24","ꠀꠝꠤ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠛꠖꠟꠤ ꠎꠣꠅꠀꠄ, ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠥꠞ-ꠔꠣꠞꠤꠚ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GL2_1","078_2_1","GAL","2","1","1","ꠌꠃꠖ꠆ꠖ ꠛꠞꠍ ꠛꠣꠖꠦ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠟꠉꠦ ꠅꠁꠀ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠉꠦꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠔꠤꠔꠣꠍꠞꠦꠅ ꠟꠉꠦ ꠘꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL2_2","078_2_2","GAL","2","2","2","ꠀꠟ꠆ꠟꠣꠁ ꠢꠥꠇꠥꠝꠦ ꠀꠝꠤ ꠢꠘꠅ ꠉꠦꠟꠣꠝ। ꠉꠤꠀ ꠢꠘꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠇꠁꠟꠣꠝ, ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠇꠥꠘ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠤ। ꠅꠁꠟꠦ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠁꠔꠣ ꠘꠤꠞꠣꠟꠣꠄ ꠇꠁꠟꠣꠝ, ꠀꠝꠣꠞ ꠌꠤꠘ꠆ꠔꠣ ꠀꠍꠤꠟ, ꠀꠝꠣꠞ ꠅꠔ ꠖꠃꠠꠞ ꠇꠣꠝ ꠎꠣꠔꠦ ꠛꠦꠇꠣꠝꠣ ꠘꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL2_3","078_2_3","GAL","2","3","3","ꠀꠝꠣꠞ ꠟꠉꠞ ꠜꠣꠁ ꠔꠤꠔꠣꠍ ꠅ-ꠁꠢꠥꠖꠤ ꠅꠁꠟꠦꠅ, ꠔꠣꠘ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠞꠣ ꠇꠥꠘꠥ ꠌꠣꠙ ꠖꠤꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL2_4","078_2_4","GAL","2","4","4","ꠀꠍꠟꠦ ꠁꠝꠣꠘꠖꠣꠞ ꠖꠟꠞ ꠜꠤꠔꠞꠦ ꠇꠄꠎꠘ ꠝꠥꠘꠣꠚꠤꠇ ꠢꠣꠝꠣꠘꠤꠄ ꠅꠟꠣ ꠅꠁꠟ। ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠛꠘꠣꠄ ꠀꠝꠞꠣ ꠎꠦ ꠡ꠆ꠛꠣꠗꠤꠘꠔꠣ ꠙꠣꠁꠍꠤ, ꠅꠔꠣꠞ ꠈꠥꠔ ꠗꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠄꠞꠣ ꠢꠣꠝꠣꠁꠍꠤꠟ, ꠎꠣꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠉꠥꠟꠣꠝꠤꠔ ꠞꠣꠈꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("GL2_5","078_2_5","GAL","2","5","5","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠄꠇ ꠙꠟꠇꠞ ꠟꠣꠉꠤꠅ ꠔꠣꠞꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠝꠣꠘꠟꠣꠝ ꠘꠣ, ꠎꠣꠔꠦ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠢꠇꠤꠇꠔꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠇꠣꠁꠝ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("GL2_6","078_2_6","GAL","2","6","6","ꠀꠞ ꠎꠝꠣꠔꠞ ꠘꠣꠝ-ꠒꠣꠇꠤ ꠎꠘ ꠅꠇꠟꠞ ꠟꠉꠦ ꠀꠝꠤ ꠝꠣꠔꠤꠟꠣꠝ, ꠄꠞꠣ ꠎꠦꠁꠘꠃ ꠅꠁꠘ ꠘꠣ ꠇꠦꠘꠦ, ꠁꠔꠣꠄ ꠀꠝꠣꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠎꠣꠄ ꠀꠄ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠝꠥꠈ ꠌꠣꠁꠀ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠂꠘ ꠘꠣ। ꠄꠞꠣ ꠔ ꠀꠝꠣꠞꠦ ꠘꠄꠀ ꠇꠥꠘ꠆ꠔꠣ ꠖꠤꠍꠂꠘ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("GL2_7","078_2_7","GAL","2","7","7","ꠛꠞꠋ ꠔꠣꠞꠣ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠁꠢꠥꠖꠤ ꠡꠝꠣꠎꠞ ꠉꠦꠍꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠅ ꠙꠤꠔꠞꠞꠦ ꠎꠦꠟꠣ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠝꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GL2_8","078_2_8","GAL","2","8","8","ꠔꠣꠞꠣ ꠅꠈꠣꠘ ꠖꠦꠈꠟꠣ, ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠍꠣꠢꠣꠛꠤ ꠇꠣꠝꠅ ꠙꠤꠔꠞꠞꠦ ꠎꠦꠁꠘ ꠌꠣꠟꠣꠁꠍꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠄꠃ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠍꠣꠢꠣꠛꠤ ꠇꠣꠝꠅ ꠀꠝꠣꠞꠦ ꠌꠣꠟꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GL2_9","078_2_9","GAL","2","9","9","ꠅꠈꠣꠘ ꠖꠦꠈꠤꠀ ꠎꠝꠣꠔꠞ ꠉꠁꠘ꠆ꠘ-ꠝꠣꠁꠘ꠆ꠘ ꠝꠥꠞꠛ꠆ꠛꠤ, ꠝꠣꠘꠤ ꠁꠀꠇꠥꠛ, ꠙꠤꠔꠞ ꠀꠞ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠛꠥꠎꠤꠟꠤꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠔꠞꠚ ꠕꠘꠦ ꠀꠝꠤ ꠈꠣꠍ ꠞꠢꠝꠔ ꠙꠣꠁꠍꠤ। ꠔꠦꠃ ꠔꠣꠞꠣꠅ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠄꠇꠝꠔ ꠀꠍꠂꠘ ꠅꠈꠣꠘ ꠖꠦꠈꠣꠁꠔꠣ ꠇꠞꠤ, ꠀꠝꠣꠞ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠀꠔ ꠝꠤꠟꠣꠁꠟꠣ। ꠀꠞ ꠅꠃ ꠝꠣꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠟꠣ, ꠀꠝꠞꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠝꠥ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠛꠣ ꠁꠢꠥꠖꠤ ꠡꠝꠣꠎꠞ ꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GL2_10","078_2_10","GAL","2","10","10","ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠄꠇꠈꠣꠘ ꠀꠛꠖꠣꠞ ꠇꠞꠟꠣ, ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠎꠝꠣꠔꠞ ꠉꠞꠤꠛ ꠅꠇꠟꠞ ꠛꠣꠄ ꠈꠤꠀꠟ ꠞꠣꠈꠤ। ꠀꠍꠟꠦ ꠀꠝꠣꠞꠅ ꠅꠟꠣ ꠇꠞꠣꠞ ꠈꠥꠛ ꠁꠌ꠆ꠍꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GL2_11","078_2_11","GAL","2","11","11","ꠛꠣꠖꠦ ꠙꠤꠔꠞ ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ ꠐꠣꠃꠘꠅ ꠀꠁꠟꠣ। ꠄꠞꠝꠣꠎꠦ ꠔꠣꠁꠘ ꠄꠇ ꠛꠠ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠣꠄ ꠀꠝꠤ ꠔꠣꠘ ꠝꠥꠈꠞ ꠍꠣꠝꠘꠦꠃ ꠀꠙꠔ꠆ꠔꠤ ꠎꠣꠘꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL2_12","078_2_12","GAL","2","12","12","ꠅꠃ ꠡꠝꠄ ꠁꠢꠥꠖꠤ ꠕꠣꠇꠤ ꠝꠥꠝꠤꠘ ꠅꠀ ꠄꠇꠖꠟ ꠝꠣꠘꠡꠦ ꠚꠔꠥꠀ ꠖꠤꠔꠣ, ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠔꠤ ꠕꠣꠇꠤ ꠎꠦꠞꠣ ꠁꠍꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠄ, ꠔꠣꠞꠣꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤ ꠎꠞꠥꠞ। ꠅꠃ ꠚꠔꠥꠀ ꠖꠟꠞ ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠍꠣꠢꠣꠛꠤ ꠁꠀꠇꠥꠛꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠛꠣꠞ ꠀꠉꠦ ꠙꠤꠔꠞꠦ ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠟꠉꠦ ꠝꠤꠟꠣ-ꠝꠤꠡꠣ ꠇꠞꠤ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠈꠣꠁꠔꠣ। ꠁꠐꠣ ꠔ ꠈꠥꠛ ꠜꠣꠟꠣ। ꠅꠁꠟꠦ ꠄꠞꠣ ꠀꠅꠀꠄ ꠄꠞꠣꠞ ꠒꠞꠦ ꠔꠣꠁꠘ ꠅꠃ ꠜꠣꠟꠣ ꠇꠣꠝ ꠛꠘ꠆ꠖ ꠇꠞꠤꠟ꠆ꠟꠣ। ꠅꠇꠐꠣꠃ ꠛꠠ ꠅꠁꠘ꠆ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL2_13","078_2_13","GAL","2","13","13","ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀꠞ ꠀꠞꠅ ꠛꠃꠔ ꠁꠢꠥꠖꠤ ꠝꠥꠝꠤꠘꠦꠅ ꠙꠤꠔꠞꠞ ꠟꠉꠦ ꠅꠃ ꠜꠘ꠆ꠒꠣꠝꠤꠔ ꠡꠣꠝꠤꠟ ꠅꠁꠟꠣ। ꠢꠦꠡ-ꠝꠦꠡ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠜꠥꠟ ꠙꠕꠦ ꠙꠣꠅ ꠖꠤꠟꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GL2_14","078_2_14","GAL","2","14","14","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟꠣꠝ, ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠢꠇꠤꠇꠔꠞ ꠟꠉꠦ ꠔꠣꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠝꠤꠟꠦꠞ ꠘꠣ, ꠅꠃ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠙꠤꠔꠞꠞꠦ ꠇꠁꠟꠣꠝ, “ꠀꠙꠘꠦ ꠁꠢꠥꠖꠤ ꠅꠁꠀꠅ ꠎꠥꠖꠤ ꠁꠢꠥꠖꠤ ꠘꠤꠅꠝ ꠛꠣꠖ ꠖꠤꠀ ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞ ꠟꠣꠈꠣꠘ ꠌꠟꠂꠘ, ꠔꠦ ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞꠦ ꠇꠦꠘꠦ ꠅꠈꠘ ꠁꠢꠥꠖꠤ ꠘꠤꠅꠝ ꠝꠣꠘꠣꠞ ꠔꠣꠉꠤꠖ ꠖꠤꠞꠣ? ");
INSERT INTO syls_vpl VALUES ("GL2_15","078_2_15","GAL","2","15","15","ꠀꠙꠘꠦ-ꠀꠝꠤ ꠖꠥꠁꠅꠎꠘꠃ ꠔ ꠁꠢꠥꠖꠤ, ꠘꠣꠚꠞꠝꠣꠘ ꠅ-ꠁꠢꠥꠖꠤ ꠇꠥꠟꠅ ꠎꠘꠝꠤꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL2_16","078_2_16","GAL","2","16","16","ꠄꠞꠛꠣꠖꠦꠅ ꠔ ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠟꠦꠅ ꠀꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠂꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠦꠃ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠂꠘ। ꠄꠞꠖꠣꠄꠃ ꠀꠝꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠤ, ꠎꠣꠔꠦ ꠡꠞꠤꠅꠔꠞ ꠀꠝꠟꠦ ꠘꠣꠄ, ꠅꠁꠟꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠂꠘ। ꠇꠣꠞꠘ ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠟꠦꠅ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠉꠘꠣ ꠅꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GL2_17","078_2_17","GAL","2","17","17","ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠄ ꠖꠤꠘꠖꠣꠞ ꠛꠘꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ ꠇꠞꠤ, ꠁꠢꠥꠖꠤ ꠡꠞꠣꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍꠤ। ꠄꠔꠦ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠇꠂꠘ, ꠔꠦ ꠇꠤꠔꠣ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠟ-ꠝꠍꠤꠄ ꠇꠥꠘꠥ ꠉꠥꠘꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠂꠘ ꠘꠤ? ꠘꠣꠃꠎꠥꠛꠤꠟ꠆ꠟꠣ, ꠘꠤꠌꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL2_18","078_2_18","GAL","2","18","18","ꠀꠝꠤ ꠘꠤꠎꠦ ꠎꠦꠔꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍꠤ, ꠅꠔꠣ ꠎꠥꠖꠤ ꠢꠤꠞꠛꠣꠞ ꠇꠞꠤ, ꠔꠦ ꠔ ꠘꠤꠎꠦꠃ ꠘꠤꠎꠞꠦ ꠖꠥꠡꠤ ꠙꠞꠝꠣꠘ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("GL2_19","078_2_19","GAL","2","19","19","ꠡꠞꠤꠅꠔꠞ ꠘꠤꠅꠝꠦ ꠡꠞꠤꠅꠔꠞ ꠀꠔꠅꠃ ꠀꠝꠣꠞ ꠝꠃꠔ ꠅꠁꠉꠦꠍꠦ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("GL2_20","078_2_20","GAL","2","20","20","ꠔꠦ ꠗꠞꠤꠟꠣꠅ, ꠀꠝꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠦ। ꠀꠝꠤ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠘꠣꠄ, ꠀꠝꠣꠞ ꠇꠣꠄꠀꠞ ꠝꠣꠎꠦ ꠀꠟ-ꠝꠍꠤꠃ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ। ꠅꠃ ꠇꠣꠄꠀꠄ ꠅꠈꠘ ꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠞꠣꠝ, ꠁꠐꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠇꠣꠐꠣꠁꠞꠣꠝ। ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠀ, ꠀꠝꠣꠞꠦ ꠔꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GL2_21","078_2_21","GAL","2","21","21","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠁ ꠞꠢꠝꠔ ꠀꠝꠤ ꠛꠤꠚꠟ ꠅꠁꠔꠦ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠤꠀ ꠎꠥꠖꠤ ꠝꠣꠘꠥꠡ ꠖꠤꠘꠖꠣꠞ ꠛꠘꠤꠎꠤꠔ, ꠔꠦ ꠀꠟ-ꠝꠍꠤ ꠈꠣꠝꠈꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠁꠟꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GL3_1","078_3_1","GAL","3","1","1","ꠅ ꠛꠦꠀꠈꠟ ꠉꠣꠟꠣꠔꠤ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞꠦ ꠇꠦꠉꠤꠄ ꠎꠣꠖꠥ ꠇꠞꠍꠦ? ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠀꠞ ꠍꠣꠚ-ꠍꠚꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GL3_2","078_3_2","GAL","3","2","2","ꠔꠦ ꠅꠈꠘ ꠀꠝꠤ ꠈꠣꠟꠤ ꠅꠃ ꠇꠕꠣꠈꠣꠘ ꠎꠣꠘꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠁꠍ, ꠁꠐꠣ ꠇꠤꠔꠣ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠤꠀ ꠙꠣꠁꠍ ꠘꠤ? ꠘꠣ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠢꠥꠘꠤꠀ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠙꠣꠁꠍ? ");
INSERT INTO syls_vpl VALUES ("GL3_3","078_3_3","GAL","3","3","3","ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠅꠟꠣ ꠛꠦꠀꠈꠟ ꠘꠤ? ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠘꠄꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠡꠥꠞꠥ ꠇꠞꠤꠀ, ꠅꠈꠘ ꠘꠤꠎꠞ ꠛꠟꠦ ꠇꠣꠝꠤꠀꠛ ꠅꠁꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("GL3_4","078_3_4","GAL","3","4","4","ꠔꠦ ꠈꠣꠝꠈꠣ ꠅꠔ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠞꠟꠣꠄ ꠘꠤ? ꠀꠝꠤ ꠀꠡꠣ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠁ ꠇꠡ꠆ꠐ ꠝꠥꠐꠦꠃ ꠛꠦꠢꠥꠖꠣ ꠉꠦꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL3_5","078_3_5","GAL","3","5","5","ꠀꠁꠌ꠆ꠍꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝꠅ ꠇꠞꠍꠂꠘ। ꠔꠦ ꠇꠅ ꠌꠣꠁꠘ, ꠔꠣꠘ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠣꠄ ꠔꠣꠁꠘ ꠁꠔꠣ ꠇꠞꠟꠣ ꠘꠤ? ꠘꠣ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠁꠔꠣ ꠇꠞꠍꠂꠘ? ");
INSERT INTO syls_vpl VALUES ("GL3_6","078_3_6","GAL","3","6","6","ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠞ ꠛꠦꠙꠣꠞꠈꠣꠘ ꠖꠦꠈꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, “ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣꠄ ꠁꠝꠣꠘ ꠀꠘꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("GL3_7","078_3_7","GAL","3","7","7","ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣꠅ ꠡꠝꠎꠤꠟꠣꠅ, ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠔꠣꠞꠣꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠍꠟ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GL3_8","078_3_8","GAL","3","8","8","ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠅ ꠀꠉꠦꠃ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠦꠃ ꠔ ꠔꠣꠁꠘ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠎꠣꠔꠤꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠂꠘ। ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠦꠍꠦ ꠅꠃ ꠀꠄꠀꠔꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠀꠉꠦꠃ ꠎꠣꠘꠣꠁꠟ ꠅꠁꠍꠤꠟ, “ꠔꠥꠝꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠄ ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GL3_9","078_3_9","GAL","3","9","9","ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣꠄ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠎꠦꠟꠣ ꠛꠞꠇꠔ ꠙꠣꠁꠍꠂꠘ, ꠔꠣꠘ ꠛꠣꠖꠦ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠛꠣ ꠔꠣꠞꠣꠅ ꠅꠟꠣ ꠛꠞꠇꠔ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("GL3_10","078_3_10","GAL","3","10","10","ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠦ ꠇꠄ, “ꠎꠦ ꠝꠣꠘꠡꠦ ꠡꠞꠤꠅꠔꠞ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠔꠣꠝꠣꠝ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠝꠟ ꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠟꠣꠘ꠆ꠘꠔꠤ।” ꠅꠘ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠎꠦꠞꠣ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠦ, ꠔꠣꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦꠃ ꠁ ꠟꠣꠘ꠆ꠘꠔ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GL3_11","078_3_11","GAL","3","11","11","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠦ ꠛꠣꠔꠣꠄ, “ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠎꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠣ ꠅꠄ, ꠢꠦ ꠔꠣꠞ ꠁꠝꠣꠘꠞ ꠎꠞꠤꠀꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ।” ꠄꠞꠖꠣꠄ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠟꠦꠅ ꠀꠟ꠆ꠟꠣꠄ ꠇꠦꠃꠞꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL3_12","078_3_12","GAL","3","12","12","ꠅꠁꠟꠦ ꠡꠞꠤꠅꠔꠦ ꠇꠄ, “ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠚꠤꠇ ꠎꠦ ꠝꠣꠘꠥꠡ ꠌꠟꠦ, ꠢꠦ ꠡꠞꠤꠅꠔꠞ ꠝꠣꠎꠖꠤꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠛ।” ꠔꠦ ꠔ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠡꠞꠤꠅꠔꠦ ꠁꠝꠣꠘꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL3_13","078_3_13","GAL","3","13","13","ꠡꠞꠤꠅꠔꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠣꠄ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠦ ꠟꠣꠘ꠆ꠘꠔ ꠀꠍꠤꠟ, ꠅꠃ ꠟꠣꠘ꠆ꠘꠔ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠇꠣꠘ꠆ꠖꠅ ꠘꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠍꠂꠘ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠔ ꠀꠍꠦ, “ꠉꠣꠍꠅ ꠟꠐꠇꠣꠁꠀ ꠎꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠄ, ꠢꠦ ꠟꠣꠘ꠆ꠘꠔꠤ।” ");
INSERT INTO syls_vpl VALUES ("GL3_14","078_3_14","GAL","3","14","14","ꠀꠟ꠆ꠟꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠞꠦ ꠎꠦ ꠛꠞꠇꠔ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠞꠤꠀꠄ ꠅꠃ ꠛꠞꠇꠔ ꠎꠣꠔꠦ ꠅꠁꠘ꠆ꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠦꠅ ꠙꠣꠁꠘ, ꠀꠞ ꠀꠝꠞꠣꠅ ꠎꠣꠔꠦ ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠙꠣꠇ ꠞꠥꠢꠥ ꠙꠣꠁ, ꠅꠔꠣꠞ ꠖꠣꠄꠃ ꠀꠟ-ꠝꠍꠤꠄ ꠁ ꠟꠣꠘ꠆ꠘꠔ ꠘꠤꠎꠞ ꠇꠣꠘ꠆ꠖꠅ ꠘꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GL3_15","078_3_15","GAL","3","15","15","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠖꠥꠘꠤꠀꠛꠤ ꠇꠕꠣꠖꠤ ꠛꠥꠎꠣꠁ ꠖꠤꠞꠣꠝ। ꠖꠥꠁ ꠙꠇ꠆ꠇ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠎꠦꠛꠟꠣ ꠇꠥꠘꠥ ꠌꠥꠇ꠆ꠔꠤ ꠙꠣꠇꠣ-ꠙꠥꠇ꠆ꠔ ꠅꠁꠎꠣꠄ, ꠅꠃ ꠌꠥꠇ꠆ꠔꠤ ꠄꠇ ꠙꠇ꠆ꠇꠄ ꠀꠞ ꠛꠣꠔꠤꠟ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠛꠣ ꠄꠞ ꠝꠣꠎꠦ ꠘꠄꠀ ꠇꠥꠘ꠆ꠔꠣ ꠟꠣꠉꠣꠁꠔ-ꠅ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL3_16","078_3_16","GAL","3","16","16","ꠔꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤ ꠀꠞ ꠔꠣꠘ ꠀꠅꠟꠣꠖꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠔ ꠇꠅꠀ ꠅꠁꠍꠦ ꠘꠣ, “ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠟꠉꠦ” ꠝꠣꠘꠤ ꠛꠃꠔ ꠀꠅꠟꠣꠖꠞ ꠟꠉꠦ। ꠛꠞꠋ ꠇꠅꠀ ꠅꠁꠍꠦ ꠈꠣꠟꠤ “ꠔꠥꠝꠣꠞ ꠀꠅꠟꠣꠖꠞ ꠟꠉꠦ” ꠝꠣꠘꠤ ꠄꠇ ꠀꠅꠟꠣꠖꠞ ꠟꠉꠦ, ꠀꠞ ꠅꠃ ꠀꠅꠟꠣꠖꠃ ꠅꠁꠟꠣ ꠀꠟ-ꠝꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GL3_17","078_3_17","GAL","3","17","17","ꠀꠝꠤ ꠇꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠝꠟꠅ ꠅꠀꠖꠣꠞ ꠝꠣꠎꠖꠤ ꠎꠦ ꠘꠤꠅꠝ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠟꠣ, ꠄꠞ ꠌꠣꠁꠞ-ꠡ ꠔꠤꠡ ꠛꠞꠍ ꠛꠣꠖꠦ ꠡꠞꠤꠅꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ। ꠅꠃ ꠡꠞꠤꠅꠔ ꠀꠅꠀꠄ ꠀꠉꠞ ꠢꠃ ꠅꠀꠖꠣꠞ ꠘꠤꠅꠝ ꠔ ꠛꠣꠔꠤꠟ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ꠔꠦ ꠔ ꠔꠣꠘ ꠅꠀꠖꠣ ꠎꠣꠞꠤ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("GL3_18","078_3_18","GAL","3","18","18","ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠛꠞꠇꠔ ꠙꠣꠅꠀ ꠎꠥꠖꠤ ꠡꠞꠤꠅꠔ ꠀꠝꠟꠞ ꠃꠙꠞꠦ ꠘꠤꠞꠜꠞ ꠇꠞꠔ, ꠔꠦ ꠅꠀꠖꠣꠞ ꠃꠙꠞꠦ ꠘꠤꠞꠜꠞ ꠞꠁꠟ ꠘꠣ ꠅꠘꠦ। ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠅꠀꠖꠣꠞ ꠝꠣꠎꠖꠤꠃ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠛꠞꠇꠔ ꠖꠣꠘ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GL3_19","078_3_19","GAL","3","19","19","ꠔꠦ ꠇꠁꠛꠣ, ꠡꠞꠤꠅꠔ ꠇꠦꠘꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ? ꠝꠣꠘꠡꠦ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠘꠣ ꠍꠣꠠꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠅꠀꠖꠣꠞ ꠟꠉꠦ ꠡꠞꠤꠅꠔꠅ ꠡꠣꠝꠤꠟ ꠇꠞꠍꠟꠣ। ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠎꠦ ꠀꠅꠟꠣꠖꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠅꠃ ꠎꠘꠦ ꠔꠡꠞꠤꠚ ꠘꠣ ꠀꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁ ꠡꠞꠤꠅꠔ ꠛꠅꠀꠁꠟ ꠀꠍꠤꠟ। ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠎꠞꠤꠀꠄ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠁ ꠡꠞꠤꠅꠔ ꠘꠣꠎꠤꠟ ꠅꠁꠍꠤꠟ। ꠅꠃ ꠝꠥꠍꠣꠃ ꠀꠍꠟꠣ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠡꠣꠚꠣꠄꠀꠔꠇꠣꠞꠤ, ꠝꠣꠘꠤ ꠝꠣꠎꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("GL3_20","078_3_20","GAL","3","20","20","ꠅꠁꠟꠦ ꠈꠣꠟꠤ ꠄꠇꠙꠇ꠆ꠇ ꠕꠣꠇꠟꠦ ꠔ ꠝꠣꠎꠞ ꠝꠣꠘꠡꠞ ꠎꠞꠥꠞ ꠀꠍꠤꠟ ꠘꠣ; ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠔ ꠄꠇꠎꠘꠃ। ꠔꠣꠁꠘ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠉꠦ ꠅꠀꠖꠣꠞ ꠇꠣꠟꠅ ꠇꠥꠘꠥ ꠝꠣꠎꠞ ꠎꠘ ꠟꠣꠉꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL3_21","078_3_21","GAL","3","21","21","ꠔꠦ ꠡꠞꠤꠅꠔ ꠇꠥꠘꠥ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠅꠇꠟꠞ ꠃꠟꠐꠣ ꠘꠤ? ꠘꠤꠌꠄ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠥꠖꠤ ꠅꠃ ꠟꠣꠈꠣꠘ ꠡꠞꠤꠅꠔ ꠖꠣꠘ ꠇꠞꠔꠣ, ꠎꠦꠔꠣꠄ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠝꠤꠟꠦ, ꠔꠦ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠤꠀꠃ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠛꠥꠟ ꠅꠁꠉꠦꠟꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("GL3_22","078_3_22","GAL","3","22","22","ꠅꠁꠟꠦ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠦ ꠛꠣꠔꠣꠄ, ꠔꠣꠝꠣꠝ ꠝꠣꠘꠥꠡꠃ ꠉꠥꠘꠣꠞ ꠇꠛꠎꠣꠄ ꠛꠘ꠆ꠖꠤ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ, ꠁꠝꠣꠘꠞ ꠎꠞꠤꠀꠄ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠛꠞꠇꠔ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("GL3_23","078_3_23","GAL","3","23","23","ꠁꠝꠣꠘ ꠀꠅꠀꠞ ꠀꠉꠦ ꠡꠞꠤꠅꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠞꠣ ꠖꠤꠍꠤꠟ। ꠁꠝꠣꠘ ꠎꠣꠁꠞ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠡꠞꠤꠅꠔꠦꠃ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠣꠈꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("GL3_24","078_3_24","GAL","3","24","24","ꠄꠞꠖꠣꠄ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠟ-ꠝꠍꠤꠞ ꠉꠦꠍꠦ ꠙꠃꠍꠣꠘꠤꠞ ꠀꠉꠦ ꠅꠃ ꠡꠞꠤꠅꠔꠦꠃ ꠅꠔꠖꠤꠘ ꠀꠝꠞꠣꠞꠦ ꠌꠣꠟꠣꠁꠍꠦ, ꠎꠣꠔꠦ ꠁꠝꠣꠘꠞ ꠎꠞꠤꠀꠄ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("GL3_25","078_3_25","GAL","3","25","25","ꠅꠁꠟꠦ ꠅꠈꠘ ꠁꠝꠣꠘ ꠇꠣꠁꠝ ꠅꠀꠄ, ꠀꠝꠞꠣ ꠀꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠔꠟꠥꠀ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL3_26","078_3_26","GAL","3","26","26","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠔꠥꠝꠞꠣ ꠢꠇ꠆ꠇꠟ ꠅꠈꠘ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠤꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("GL3_27","078_3_27","GAL","3","27","27","ꠔꠥꠝꠞꠣ ꠎꠣꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣ ꠇꠛꠥꠟ ꠇꠞꠍ, ꠔꠥꠝꠞꠣ ꠔ ꠚꠤꠘ꠆ꠘꠞ ꠘꠄꠀ ꠇꠣꠙꠠꠞ ꠟꠣꠈꠣꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("GL3_28","078_3_28","GAL","3","28","28","ꠁꠢꠥꠖꠤ ꠀꠞ ꠅ-ꠁꠢꠥꠖꠤ, ꠉꠥꠟꠣꠝ ꠀꠞ ꠀꠎꠣꠖ, ꠛꠦꠐꠤꠘ ꠀꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠝꠣꠎꠦ ꠅꠈꠘ ꠇꠥꠘꠥ ꠔꠚꠣꠔ ꠘꠣꠁ। ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠝꠤꠡꠤ ꠎꠣꠅꠀꠄ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠃ ꠔ ꠄꠇ ꠅꠁꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("GL3_29","078_3_29","GAL","3","29","29","ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠘ ꠅꠁꠉꠦꠍ, ꠔꠦ ꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠅꠟꠣꠖꠅ ꠅꠁꠍ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠎꠦꠔꠣ ꠖꠤꠛꠣ ꠇꠞꠤ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠔꠥꠝꠞꠣꠅ ꠅꠔꠣꠞ ꠜꠣꠉꠤ ꠛꠘꠤꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("GL4_1","078_4_1","GAL","4","1","1","ꠀꠍꠟꠦ ꠀꠝꠤ ꠛꠥꠎꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠛꠣꠚꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠔ ꠀꠅꠟꠣꠖꠞ ꠄꠈꠔꠤꠀꠞ ꠕꠣꠇꠟꠦꠅ, ꠢꠦ ꠎꠔꠖꠤꠘ ꠘꠣꠛꠣꠟꠤꠇ ꠞꠄ ꠅꠔꠖꠤꠘ ꠀꠅꠟꠣꠖ ꠀꠞ ꠉꠥꠟꠣꠝꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠔꠚꠣꠔ ꠝꠤꠟꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_2","078_4_2","GAL","4","2","2","ꠔꠣꠞ ꠛꠣꠚꠦ ꠎꠦ ꠡꠝꠄꠅꠞ ꠇꠕꠣ ꠅꠍꠤꠅꠔ ꠇꠞꠤ ꠎꠣꠁꠘ, ꠅꠔꠖꠤꠘ ꠢꠦ ꠔꠣꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠣ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠞ ꠀꠅꠔꠣꠄ ꠞꠁꠔꠦ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("GL4_3","078_4_3","GAL","4","3","3","ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣꠅ ꠎꠦꠛꠟꠣ ꠘꠣꠛꠣꠟꠤꠇ ꠀꠍꠟꠣꠝ, ꠢꠃ ꠡꠝꠄ ꠖꠥꠘꠤꠀꠞ ꠘꠣꠘꠣꠘ ꠌꠣꠟ-ꠌꠟꠘꠞ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL4_4","078_4_4","GAL","4","4","4","ꠅꠁꠟꠦ ꠡꠝꠄ ꠙꠥꠞꠣ ꠅꠁꠀ ꠢꠣꠞꠟꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞꠦ ꠛꠦꠎꠤꠟꠣ। ꠔꠣꠁꠘ ꠄꠇꠎꠘ ꠘꠦꠇ ꠀꠅꠞꠔꠞ ꠙꠦꠐꠅ ꠎꠘꠝ ꠟꠁꠀ, ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠚꠤꠇ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_5","078_4_5","GAL","4","5","5","ꠎꠣꠔꠦ ꠡꠞꠤꠅꠔꠞ ꠀꠅꠔꠣꠄ ꠕꠣꠇꠣ ꠝꠣꠘꠡꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ, ꠀꠞ ꠀꠝꠞꠣꠞꠦꠅ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("GL4_6","078_4_6","GAL","4","6","6","ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠤꠎꠣꠅꠀꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠞꠥꠢꠥꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ। ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠅꠃ ꠞꠥꠢꠦ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠀꠛ꠆ꠛꠣ ꠇꠁꠀ ꠒꠣꠇꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("GL4_7","078_4_7","GAL","4","7","7","ꠉꠔꠤꠇꠦꠃ ꠔꠥꠝꠞꠣ ꠉꠥꠟꠣꠝ ꠞꠁꠍ ꠘꠣ, ꠀꠅꠟꠣꠖ ꠛꠘꠤꠉꠦꠍ; ꠀꠞ ꠀꠅꠟꠣꠖꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠔꠣ ꠖꠦꠅꠀꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠤꠟꠣ, ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠄꠅꠔꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣꠅ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("GL4_8","078_4_8","GAL","4","8","8","ꠀꠉꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠌꠤꠘꠔꠣꠄ ꠘꠣ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠔꠣꠄ, ꠁꠉꠥꠁꠘ ꠔ ꠀꠍꠟꠦ ꠇꠥꠘꠥ ꠖꠦꠛꠔꠣꠃ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL4_9","078_4_9","GAL","4","9","9","ꠅꠁꠟꠦ ꠅꠈꠘ ꠔ ꠀꠟ꠆ꠟꠣꠞꠦ ꠌꠤꠘꠍ; ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠞꠤꠌꠄ ꠖꠤꠍꠂꠘ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣ ꠢꠤꠞꠛꠣꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠢꠃ ꠇꠝꠎꠥꠞ ꠀꠞ ꠛꠣꠔꠤꠟ ꠌꠣꠟ-ꠌꠟꠘꠞ ꠛꠣꠄ ꠚꠤꠞꠤꠎꠤꠞꠣꠄ? ꠀꠞꠇꠛꠣꠞ ꠅꠔꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GL4_10","078_4_10","GAL","4","10","10","ꠔꠥꠝꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠅꠝꠥꠇ ꠀꠞ ꠔꠝꠥꠇ ꠖꠤꠘ, ꠝꠣꠡ, ꠞꠤꠔꠥ ꠀꠞ ꠛꠍꠞꠞꠦ ꠝꠣꠘꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL4_11","078_4_11","GAL","4","11","11","ꠄꠞꠖꠣꠄ ꠀꠝꠣꠞ ꠒꠞ ꠇꠞꠦꠞ, ꠔꠥꠝꠞꠣꠞ ꠔꠟꠦ ꠀꠝꠣꠞ ꠅꠔ ꠝꠦꠘꠔ ꠘꠤ ꠝꠣꠐꠤ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL4_12","078_4_12","GAL","4","12","12","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠀꠝꠤ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠉꠦꠍꠤ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠅ। ꠔꠥꠝꠞꠣ ꠔ ꠅꠔꠖꠤꠘ ꠀꠝꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠇꠞꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_13","078_4_13","GAL","4","13","13","ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠀꠝꠣꠞ ꠡꠞꠤꠟꠅ ꠛꠦꠝꠣꠞ ꠅꠀꠄ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠄꠟꠣ ꠛꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL4_14","078_4_14","GAL","4","14","14","ꠀꠝꠣꠞ ꠛꠦꠝꠣꠞꠞ ꠖꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠇꠡ꠆ꠐ ꠅꠁꠟꠦꠅ, ꠔꠥꠝꠞꠣ ꠔ ꠊꠤꠘ ꠛꠣ ꠄꠟꠣ ꠇꠞꠤꠀ ꠀꠝꠣꠞꠦ ꠚꠣꠟꠣꠁꠍ ꠘꠣ। ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠘꠥ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠇꠛꠥꠟ ꠇꠞꠔꠣꠄ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠝꠣꠞꠦꠅ ꠇꠛꠥꠟ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("GL4_15","078_4_15","GAL","4","15","15","ꠅꠁꠟꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠢꠤ ꠄꠡꠇꠤ ꠉꠦꠟ ꠇꠥꠀꠁ? ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠈꠣꠘꠃ ꠇꠁꠔꠣꠝ ꠙꠣꠞꠤ, ꠢꠃ ꠡꠝꠄ ꠙꠣꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠇꠁꠟꠎꠣ ꠈꠥꠟꠤꠀ ꠀꠝꠣꠞꠦ ꠖꠤꠟꠣꠁꠟꠣꠄ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("GL4_16","078_4_16","GAL","4","16","16","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠢꠇ ꠇꠕꠣ ꠝꠣꠔꠣꠄ, ꠀꠝꠤ ꠅꠈꠘ ꠖꠥꠡꠝꠘ ꠅꠁꠉꠦꠟꠣꠝ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GL4_17","078_4_17","GAL","4","17","17","ꠢꠥꠘꠅ, ꠅꠃ ꠎꠦꠉꠥꠁꠘ꠆ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠈꠥꠎ-ꠈꠛꠞ ꠟꠁꠞꠣ, ꠅꠉꠥꠁꠘ ꠔ ꠛꠖ ꠘꠤꠅꠔꠦ ꠀꠁꠞꠣ। ꠔꠣꠞꠣ ꠌꠣꠁꠘ, ꠔꠥꠝꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠛꠣꠄ ꠕꠘꠦ ꠚꠤꠞꠣꠁꠀ, ꠔꠣꠞꠣꠞ ꠀꠡꠤꠇ ꠛꠣꠘꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_18","078_4_18","GAL","4","18","18","ꠜꠣꠟꠣ ꠘꠤꠅꠔꠦ ꠅꠟꠣ ꠇꠞꠟꠦ ꠚꠣꠄꠖꠣ ꠅꠁꠟ ꠅꠘꠦ। ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁ, ꠈꠣꠟꠤ ꠅꠃ ꠡꠝꠄ ꠘꠣꠄ, ꠘꠦꠇ ꠘꠤꠅꠔꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠈꠥꠎ-ꠈꠛꠞ ꠟꠅꠀ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_19","078_4_19","GAL","4","19","19","ꠅ ꠀꠝꠣꠞ ꠙꠤꠀꠞꠣ ꠀꠅꠟꠣꠖ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠔꠖꠤꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠈꠣꠘ ꠘꠣ ꠛꠘꠍ, ꠅꠔꠖꠤꠘ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣꠞ ꠛꠤꠡꠞ ꠟꠣꠈꠣꠘ ꠍꠐꠚꠐ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL4_20","078_4_20","GAL","4","20","20","ꠀꠝꠣꠞ ꠝꠘꠦ ꠌꠣꠞ, ꠅꠃ ꠙꠄꠉꠣꠝ ꠟꠦꠈꠣ ꠛꠣꠖ ꠖꠤꠀ ꠅꠈꠘꠃ ꠀꠝꠤ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ, ꠑꠣꠘ꠆ꠒꠣ ꠝꠣꠕꠣꠄ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠔꠣꠝ। ꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠇꠤꠔꠣ ꠇꠞꠔꠣꠝ ꠇꠥꠘ꠆ꠔꠣ ꠛꠥꠎꠞꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_21","078_4_21","GAL","4","21","21","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠔꠣꠄ ꠌꠣꠅ, ꠔꠥꠝꠞꠣ ꠇꠅ ꠌꠣꠁꠘ, ꠡꠞꠤꠅꠔꠦ ꠎꠦꠔꠣ ꠇꠄ ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠘꠅ ꠢꠣꠝꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("GL4_22","078_4_22","GAL","4","22","22","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠦ ꠛꠣꠔꠣꠄ, ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠞ ꠖꠥꠁ ꠙꠥꠀ ꠀꠍꠟꠣ, ꠙꠄꠟꠣ ꠙꠥꠀ ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤ ꠢꠣꠎꠦꠞꠣꠞ ꠔꠞꠚꠣ ꠀꠞ ꠖꠥꠍꠞꠣ ꠙꠥꠀ ꠀꠍꠟ ꠡ꠆ꠛꠣꠗꠤꠘ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠔꠞꠚꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_23","078_4_23","GAL","4","23","23","ꠛꠣꠘ꠆ꠖꠤ ꠛꠦꠐꠤꠞ ꠔꠞꠚꠣ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ ꠖꠥꠘꠤꠀꠞ ꠘꠤꠅꠝꠦ, ꠅꠁꠟꠦ ꠀꠍꠟ ꠡ꠆ꠛꠣꠗꠤꠘ ꠛꠤꠛꠤꠞ ꠙꠥꠀꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠅꠀꠖꠣꠄ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("GL4_24","078_4_24","GAL","4","24","24","ꠁ ꠝꠣꠔꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠅꠃ ꠖꠥꠁ ꠛꠦꠐꠤ ꠅꠁꠟꠣ ꠖꠥꠁꠐꠣ ꠘꠤꠅꠝ। ꠄꠇ ꠘꠤꠅꠝ ꠔꠥꠞ ꠙꠣꠠ ꠕꠘꠦ ꠀꠁꠍꠦ, ꠁꠐꠣꠄ ꠔꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠉꠥꠟꠣꠝꠤꠞ ꠙꠕꠦ ꠐꠣꠘꠦ; ꠄꠁꠘ ꠅꠁꠟꠣ ꠛꠣꠘ꠆ꠖꠤ ꠢꠣꠎꠦꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_25","078_4_25","GAL","4","25","25","ꠅꠃ ꠢꠣꠎꠦꠞꠣ ꠝꠣꠘꠤ ꠀꠞꠛ ꠖꠦꠡꠞ ꠔꠥꠞ ꠙꠣꠠ। ꠀꠞ ꠢꠣꠎꠦꠞꠣ ꠅꠁꠟꠣ ꠅꠃ ꠎꠉꠔꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠞ ꠄꠇ ꠘꠝꠥꠘꠣ, ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠦ ꠔ ꠔꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦ ꠟꠁꠀ ꠛꠣꠘ꠆ꠖꠤ ꠛꠘꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GL4_26","078_4_26","GAL","4","26","26","ꠅꠁꠟꠦ ꠀꠍꠝꠣꠘꠤ ꠎꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ, ꠄꠁꠘ ꠔ ꠡ꠆ꠛꠣꠗꠤꠘ; ꠄꠁꠘꠃ ꠀꠝꠞꠣꠞ ꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("GL4_27","078_4_27","GAL","4","27","27","ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠦ ꠇꠄ, “ꠅ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠛꠦꠐꠤ, ꠎꠣꠞ ꠇꠥꠘꠥ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠔꠥꠝꠤ ꠈꠥꠡꠤꠞ ꠉꠎꠟ ꠉꠣꠅ। ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣꠞ ꠛꠤꠡꠦ ꠎꠣꠞꠦ ꠗꠞꠍꠦ ꠘꠣ, ꠔꠥꠝꠤ ꠉꠟꠣ ꠚꠣꠐꠣꠁꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠉꠎꠟ ꠉꠣꠅ। ꠎꠣꠝꠣꠁꠞ ꠊꠞꠞ ꠛꠃꠞ ꠌꠣꠁꠔꠦꠅ, ꠎꠣꠞ ꠇꠦꠃ ꠘꠣꠁ ꠔꠣꠁꠞ ꠛꠃꠔ ꠛꠦꠡꠤ ꠀꠅꠟꠣꠖ ꠅꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("GL4_28","078_4_28","GAL","4","28","28","ꠜꠣꠁ ꠅꠇꠟ, ꠄꠞꠖꠣꠄꠃ ꠔꠥꠝꠞꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣꠞ ꠁꠍꠢꠣꠇꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("GL4_29","078_4_29","GAL","4","29","29","ꠅꠁꠟꠦ ꠢꠃ ꠡꠝꠄ ꠖꠥꠘꠤꠀꠞ ꠘꠤꠅꠝꠦ ꠎꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠤꠟ, ꠢꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠔ ꠅꠃ ꠎꠘꠞꠦ, ꠎꠦꠁꠘ ꠎꠘꠝ ꠟꠁꠍꠂꠘ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ; ꠀꠞ ꠅꠈꠘꠅ ꠅꠃꠟꠣ ꠎꠥꠟꠥꠝ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("GL4_30","078_4_30","GAL","4","30","30","ꠄꠞꠖꠣꠄ ꠖꠦꠈꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠦ ꠇꠄ, “ꠛꠣꠘ꠆ꠖꠤꠞꠦ ꠀꠞ ꠔꠣꠁꠞ ꠙꠥꠀꠞꠦ ꠛꠣꠠꠤ ꠕꠘꠦ ꠈꠦꠖꠣꠁ ꠖꠦꠅ; ꠛꠣꠘ꠆ꠖꠤꠞ ꠔꠞꠚꠣ ꠙꠥꠀꠄ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠀꠍꠟ ꠛꠤꠛꠤꠞ ꠙꠥꠀꠞ ꠟꠉꠦ, ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠛꠣꠐ ꠙꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("GL4_31","078_4_31","GAL","4","31","31","ꠔꠦ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠅꠃ ꠀꠄꠀꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠝꠞꠣ ꠛꠣꠘ꠆ꠖꠤꠞ ꠀꠅꠟꠣꠖ ꠘꠣꠄ, ꠀꠝꠞꠣ ꠔ ꠀꠍꠟ ꠡ꠆ꠛꠣꠗꠤꠘ ꠛꠤꠛꠤꠞ ꠊꠞꠞ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("GL5_1","078_5_1","GAL","5","1","1","ꠅ ꠝꠥꠝꠤꠘ ꠅꠇꠟ, ꠀꠟ-ꠝꠍꠤꠄ ꠀꠝꠞꠣꠞꠦ ꠡ꠆ꠛꠣꠗꠤꠘ ꠇꠞꠍꠂꠘ, ꠡ꠆ꠛꠣꠗꠤꠘ ꠢꠣꠟꠔꠦ ꠞꠅꠀꠞ ꠟꠣꠉꠤ। ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠡ꠆ꠛꠣꠗꠤꠘꠔꠣꠞꠦ ꠗꠞꠤꠀ ꠞꠣꠈꠅ, ꠉꠥꠟꠣꠝꠤꠞ ꠟꠣꠉꠣꠝ ꠀꠞ ꠚꠤꠘ꠆ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL5_2","078_5_2","GAL","5","2","2","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠅꠈꠘꠅ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠅ, ꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠥꠘꠥ ꠖꠣꠝꠃ ꠔ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("GL5_3","078_5_3","GAL","5","3","3","ꠀꠝꠤ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠢꠤꠞꠛꠣꠞ ꠅꠈꠣꠘ ꠇꠁꠞꠣꠝ, ꠎꠦ ꠎꠘꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ ꠅꠄ, ꠔꠣꠞ ꠃꠙꠞꠦ ꠚꠞꠎ ꠅꠁꠎꠣꠄ ꠡꠞꠤꠅꠔꠞ ꠔꠣꠝꠣꠝ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL5_4","078_5_4","GAL","5","4","4","ꠔꠥꠝꠞꠣ ꠎꠣꠞꠣ ꠡꠞꠤꠅꠔ ꠀꠝꠟ ꠇꠞꠤꠀ ꠖꠤꠘꠖꠣꠞ ꠛꠘꠔꠣꠄ ꠌꠣꠁꠞꠣꠄ, ꠔꠥꠝꠞꠣ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠦꠍ ꠕꠘꠦ ꠀꠟꠉ ꠅꠁꠉꠦꠍ, ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠕꠘꠦ ꠢꠞꠤꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("GL5_5","078_5_5","GAL","5","5","5","ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠣ ꠅꠁꠛ, ꠁꠝꠣꠘꠦ ꠅꠃ ꠘꠤꠌꠄꠅꠔꠣ ꠙꠣꠁꠀ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠀꠝꠞꠣ ꠛꠣꠞ ꠌꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("GL5_6","078_5_6","GAL","5","6","6","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠛꠘꠤꠀ ꠢꠣꠞꠟꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟꠦꠅ ꠎꠦꠔꠣ, ꠘꠣ ꠇꠞꠣꠁꠟꠦꠅ ꠅꠔꠣ। ꠛꠞꠋ ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠎꠖꠤ ꠎꠦ ꠁꠝꠣꠘ ꠎꠣꠁꠞ ꠅꠄ, ꠅꠃ ꠁꠝꠣꠘꠃ ꠅꠁꠟ ꠀꠍꠟ। ");
INSERT INTO syls_vpl VALUES ("GL5_7","078_5_7","GAL","5","7","7","ꠔꠥꠝꠞꠣ ꠔ ꠜꠣꠟꠣ ꠙꠕꠦ ꠌꠟꠣꠔ ꠀꠍꠟꠣꠄ; ꠔꠦ ꠅꠃ ꠢꠇ ꠙꠕꠦ ꠌꠟꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠦꠉꠤꠄ ꠛꠣꠗꠣ ꠖꠤꠟ? ");
INSERT INTO syls_vpl VALUES ("GL5_8","078_5_8","GAL","5","8","8","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠎꠦ ꠝꠔꠛꠣꠖ ꠝꠣꠘꠞꠣꠄ, ꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠁ ꠝꠔꠛꠣꠖ ꠔ ꠔꠣꠘ ꠛꠣꠔꠣꠁꠟ ꠙꠕ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL5_9","078_5_9","GAL","5","9","9","ꠎꠣꠘ ꠘꠤ, ꠄꠇ ꠚꠥꠐꠣ ꠌꠦꠘꠣꠄ ꠄꠇ ꠛꠣꠟꠔꠤ ꠖꠥꠗꠞꠦ ꠛꠞꠛꠣꠖ ꠇꠞꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL5_10","078_5_10","GAL","5","10","10","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠝꠣꠟꠤꠇꠞ ꠖꠞꠛꠣꠞꠅ ꠅꠃ ꠜꠞꠡꠣ ꠇꠞꠤ, ꠔꠥꠝꠞꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠝꠔꠛꠣꠖꠅ ꠎꠣꠁꠔꠣꠄ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠎꠦꠉꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠔꠣꠞ, ꠢꠦ ꠎꠦ-ꠃ ꠅꠄ ꠘꠣ ꠇꠦꠘꠦ, ꠔꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠢꠦ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GL5_11","078_5_11","GAL","5","11","11","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠎꠥꠖꠤ ꠅꠈꠘꠅ ꠅꠈꠣꠘ ꠇꠁ, ꠝꠣꠘꠡꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤ ꠎꠞꠥꠞ, ꠔꠦ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠇꠦꠘꠦ ꠅꠈꠘꠅ ꠎꠥꠟꠥꠝ ꠅꠞ? ꠔꠦ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠃꠔꠞ ꠇꠕꠣ ꠢꠥꠘꠟꠦ ꠎꠦꠔꠣꠄ ꠝꠥꠈ ꠟꠥꠇꠣꠁꠘ, ꠔꠣꠞꠣꠞ ꠝꠥꠈ ꠟꠥꠇꠣꠘꠤ ꠔ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("GL5_12","078_5_12","GAL","5","12","12","ꠄꠞꠖꠣꠄ ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠦꠔꠣꠄ ꠉꠘ꠆ꠒꠉꠥꠟ ꠟꠣꠉꠣꠁꠍꠂꠘ, ꠅꠉꠥꠁꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠘꠚꠍ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GL5_13","078_5_13","GAL","5","13","13","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠀꠘꠍꠂꠘ ꠀꠎꠣꠖ ꠅꠀꠞ ꠟꠣꠉꠤ। ꠅꠁꠟꠦ ꠀꠎꠣꠖ ꠛꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠉꠥꠘꠣꠞ ꠈꠣꠁꠡ ꠙꠥꠞꠣꠘꠤꠔ ꠟꠣꠉꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠖꠤꠟꠞ ꠝꠢꠛ꠆ꠛꠔꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("GL5_14","078_5_14","GAL","5","14","14","ꠇꠣꠞꠘ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠅꠔꠞꠦꠃ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠤꠀ ꠇꠅꠀ ꠅꠁꠍꠦ, “ꠔꠥꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠤꠅ।” ");
INSERT INTO syls_vpl VALUES ("GL5_15","078_5_15","GAL","5","15","15","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠀꠞ ꠞꠦꠡꠣ-ꠞꠦꠡꠤ ꠇꠞ, ꠔꠦ ꠢꠥꠡꠤꠀꠞ ꠅꠁꠎꠣꠅ! ꠁꠔꠣ ꠇꠞꠟꠦ ꠔ ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠤꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL5_16","078_5_16","GAL","5","16","16","ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠅ, ꠔꠦꠃ ꠖꠤꠟꠞ ꠅꠃ ꠈꠣꠁꠡ ꠝꠤꠐꠣꠘꠤꠞ ꠈꠤꠀꠟ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL5_17","078_5_17","GAL","5","17","17","ꠅꠃ ꠈꠣꠁꠡꠦ ꠎꠦꠔꠣ ꠇꠄ, ꠁꠔꠣ ꠔ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠤꠙꠇ꠆ꠇꠦ, ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠦꠔꠣ ꠇꠂꠘ ꠁꠔꠣ ꠛꠖ ꠈꠣꠁꠡꠞ ꠛꠤꠙꠇ꠆ꠇꠦ। ꠛꠖ ꠈꠣꠁꠡ ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠥ ꠄꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠛꠤꠞꠥꠗꠤ, ꠄꠞꠖꠣꠄ ꠘꠦꠇ ꠇꠣꠝꠞ ꠘꠤꠅꠔ ꠇꠞꠤꠀꠅ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠙꠥꠞꠣ ꠇꠞ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL5_18","078_5_18","GAL","5","18","18","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠅ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠡꠞꠤꠅꠔꠞ ꠉꠥꠟꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL5_19","078_5_19","GAL","5","19","19","ꠖꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠔ ꠈꠥꠟꠣ-ꠝꠦꠟꠣꠃ ꠌꠤꠘꠣ ꠎꠣꠄ, ꠁꠔꠣ ꠅꠁꠟꠉꠤ ꠎꠤꠘꠣ, ꠘꠣꠙꠣꠇꠤ, ꠛꠖꠝꠣꠁꠡꠤ, ");
INSERT INTO syls_vpl VALUES ("GL5_20","078_5_20","GAL","5","20","20","ꠖꠦꠛꠔꠣ ꠙꠥꠎꠣ, ꠎꠣꠖꠥ-ꠐꠥꠘꠣ, ꠖꠥꠡꠝꠘꠤ, ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ, ꠟꠥꠜ-ꠟꠣꠟꠌ, ꠉꠥꠍꠣ, ꠘꠤꠎ-ꠝꠔꠟꠛꠤ, ꠅꠝꠤꠟ, ꠖꠟꠣꠖꠟꠤ, ");
INSERT INTO syls_vpl VALUES ("GL5_21","078_5_21","GAL","5","21","21","ꠁꠋꠡꠣ, ꠝꠣꠔꠟꠣꠝꠤ, ꠢꠂ-ꠢꠥꠟ꠆ꠟꠣ ꠇꠞꠤ ꠛꠎ꠆ꠎꠣꠔꠤ ꠇꠞꠣ, ꠀꠞ ꠅꠃ ꠘꠝꠥꠘꠣꠞ ꠀꠞꠅ ꠛꠃꠔ ꠇꠣꠝ। ꠔꠦ ꠀꠝꠤ ꠀꠉꠦ ꠎꠦꠟꠣ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠍꠟꠣꠝ, ꠅꠈꠘ ꠢꠤꠞꠛꠣꠞ ꠅꠃꠟꠣ ꠇꠁꠞꠣꠝ, ꠖꠤꠟꠞ ꠅꠃ ꠛꠖ ꠈꠣꠁꠡꠞ ꠉꠥꠟꠣꠝꠤ ꠎꠦꠞꠣ ꠇꠞꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠑꠣꠁ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("GL5_22","078_5_22","GAL","5","22","22","ꠅꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠦ ꠌꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠚꠟ ꠅꠁꠟ ꠝꠢꠛ꠆ꠛꠔ, ꠈꠥꠡꠤ-ꠛꠣꠡꠤ, ꠡꠣꠘ꠆ꠔꠤ, ꠍꠛꠞ ꠇꠞꠣ, ꠖꠄꠀꠟꠥ ꠜꠣꠛ, ꠜꠣꠟꠣ-ꠝꠣꠘꠡꠤ ꠇꠞꠣ, ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠞꠅꠀ, ");
INSERT INTO syls_vpl VALUES ("GL5_23","078_5_23","GAL","5","23","23","ꠘꠞꠝ ꠅꠀ ꠀꠞ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠣ। ꠅꠃ ꠘꠦꠇ ꠇꠣꠝꠞ ꠛꠤꠞꠥꠗꠤ ꠇꠥꠘꠥꠎꠣꠔ ꠀꠁꠘ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("GL5_24","078_5_24","GAL","5","24","24","ꠀꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠙꠘ ꠃꠝ꠆ꠝꠔꠦ ꠔ, ꠎꠣꠞꠎꠤꠞ ꠞꠤꠙꠥꠞꠦ, ꠖꠤꠟꠞ ꠢꠇꠟ ꠛꠖ ꠈꠣꠁꠡ ꠡꠥꠖ꠆ꠖꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠟꠤꠛꠅ ꠇꠄꠛꠞ ꠖꠤꠟꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("GL5_25","078_5_25","GAL","5","25","25","ꠅꠈꠘ ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠄꠇꠤꠘ ꠇꠞꠤ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠎꠞꠤꠀꠄ ꠘꠄꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠍꠤ, ꠔꠦ ꠀꠅ, ꠀꠝꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("GL5_26","078_5_26","GAL","5","26","26","ꠀꠝꠞꠣ ꠛꠦꠢꠥꠖꠣ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠛꠣꠖ ꠖꠦꠁ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠍꠣꠔꠣꠘꠤ ꠀꠞ ꠁꠋꠡꠣ-ꠁꠋꠡꠤ ꠄꠇ꠆ꠇꠦꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("GL6_1","078_6_1","GAL","6","1","1","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠎꠝꠣꠔꠞ ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠈꠔꠣ ꠇꠥꠘꠥ ꠉꠥꠘꠣꠞ ꠚꠣꠘ꠆ꠖꠅ ꠙꠠꠤꠎꠣꠄ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠞꠣꠄ, ꠔꠥꠝꠞꠣ ꠔꠣꠞꠦ ꠔꠥꠟꠤꠀ ꠀꠘꠤꠅ। ꠀꠞ ꠈꠥꠛ ꠘꠞꠝ ꠖꠤꠟꠦ ꠁ ꠇꠣꠝ ꠇꠞꠤꠅ, ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦꠅ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠎꠣꠔꠦ ꠘꠤꠎꠦꠅ ꠚꠣꠘ꠆ꠖꠅ ꠘꠣ ꠙꠠ। ");
INSERT INTO syls_vpl VALUES ("GL6_2","078_6_2","GAL","6","2","2","ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠜꠣꠞ ꠛꠅ, ꠔꠦꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠤꠅꠝ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠣꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("GL6_3","078_6_3","GAL","6","3","3","ꠇꠥꠘ꠆ꠔꠣ ꠘꠣ ꠛꠘꠤꠀꠅ ꠎꠦ ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞ ꠛꠠꠣꠁ-ꠛꠣꠢꠣꠖꠥꠞꠤ ꠖꠦꠈꠣꠄ, ꠢꠦ ꠔ ꠘꠤꠎꠦꠃ ꠘꠤꠎꠞꠦ ꠐꠉꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL6_4","078_6_4","GAL","6","4","4","ꠔꠦ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠦ ꠎꠣꠞꠎꠤꠞ ꠀꠝꠟ-ꠈꠣꠁꠍꠟꠔ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠃꠇ। ꠔꠦꠃ ꠅꠁꠘ꠆ꠘꠞ ꠟꠉꠦ ꠘꠤꠎꠞ ꠔꠥꠟꠘꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠔꠣꠞ ꠘꠤꠎꠞ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠛꠠꠣꠁ ꠇꠞꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("GL6_5","078_6_5","GAL","6","5","5","ꠙꠞꠔꠦꠇ ꠎꠘꠦꠃ ꠘꠤꠎꠞ ꠉꠣꠁꠐ ꠘꠤꠎꠦ ꠛꠅ। ");
INSERT INTO syls_vpl VALUES ("GL6_6","078_6_6","GAL","6","6","6","ꠢꠥꠘꠅ, ꠎꠦ ꠎꠘꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠤꠇꠣꠁꠟ ꠅꠄ, ꠢꠦ ꠔꠣꠞ ꠃꠡ꠆ꠔꠣꠖꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠈꠦꠎꠝꠔ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("GL6_7","078_6_7","GAL","6","7","7","ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠛꠦ-ꠙꠕꠤ ꠛꠘꠤꠅ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠔ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠌꠟꠦ ꠘꠣ। ꠎꠦꠁꠘ ꠎꠦꠟꠣ ꠈꠦꠔ ꠇꠞꠛꠣꠄ, ꠄꠁꠘ ꠅꠟꠣ ꠚꠡꠟ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("GL6_8","078_6_8","GAL","6","8","8","ꠖꠤꠟꠞ ꠅꠃ ꠛꠖ ꠈꠣꠁꠡꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠦꠔ ꠇꠞꠟꠦ, ꠁ ꠈꠦꠔ ꠕꠣꠇꠤ ꠉꠎꠛ ꠝꠤꠟꠛ। ꠅꠁꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞꠦ ꠈꠥꠡ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠈꠦꠔ ꠇꠞꠟꠦ, ꠁ ꠙꠣꠇ ꠞꠥꠢꠥ ꠕꠣꠇꠤ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠝꠤꠟꠛ। ");
INSERT INTO syls_vpl VALUES ("GL6_9","078_6_9","GAL","6","9","9","ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠔ ꠟꠣꠉꠤꠀ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠘꠤꠞꠣꠡ ꠘꠣ ꠅꠁ। ꠢꠣꠝꠦꠡꠣ ꠟꠣꠉꠤꠀ ꠞꠁꠟꠦ ꠑꠤꠇ ꠡꠝꠄꠄ ꠄꠞ ꠚꠡꠟ ꠙꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("GL6_10","078_6_10","GAL","6","10","10","ꠡꠥꠎꠥꠉ ꠙꠣꠁꠟꠦꠃ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠢꠇꠟ ꠝꠣꠘꠡꠞ, ꠈꠣꠍ ꠇꠞꠤ ꠀꠟ꠆ꠟꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠘꠡꠞ ꠀꠍꠣꠘ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("GL6_11","078_6_11","GAL","6","11","11","ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠇꠔ ꠝꠥꠐꠣ ꠝꠥꠐꠣ ꠢꠞꠚꠦ ꠀꠝꠤ ꠘꠤꠎꠞ ꠀꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠍꠤ! ");
INSERT INTO syls_vpl VALUES ("GL6_12","078_6_12","GAL","6","12","12","ꠎꠦꠉꠥꠁꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠜꠣꠟꠣ-ꠝꠣꠘꠡꠤ ꠎꠣꠁꠞ ꠇꠞꠔ ꠌꠣꠄ, ꠅꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠉꠤꠖ ꠖꠦꠞ। ꠀꠟ-ꠝꠍꠤꠞ ꠍꠟꠤꠛꠞ ꠟꠣꠉꠤ ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠇꠥꠘꠥ ꠎꠥꠟꠥꠝ ꠘꠣ ꠅꠄ, ꠎꠥꠟꠥꠝ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠁꠔꠣ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("GL6_13","078_6_13","GAL","6","13","13","ꠢꠥꠘꠅ, ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠎꠦꠔꠣꠄ ꠇꠞꠣꠁꠍꠂꠘ, ꠅꠔꠣꠄꠅ ꠔ ꠡꠞꠤꠅꠔꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠂꠘ। ꠅꠁꠟꠦ ꠄꠞꠛꠣꠖꠦꠅ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠔ ꠌꠣꠄ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠛꠠꠣꠁ ꠇꠞꠤꠀ ꠇꠁꠔ ꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠅ ꠔꠣꠞꠣꠞ ꠖꠟꠅ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("GL6_14","078_6_14","GAL","6","14","14","ꠅꠁꠟꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠈꠣꠟꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠟꠤꠛ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠛꠦꠙꠣꠞꠦꠃ ꠀꠝꠤ ꠛꠠꠣꠁ ꠇꠞꠤ ꠘꠣ। ꠅꠃ ꠍꠟꠤꠛꠞ ꠝꠣꠎꠖꠤꠃ ꠁ ꠖꠥꠘꠤꠀ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠝꠞꠤꠉꠦꠍꠦ, ꠀꠞ ꠀꠝꠤꠅ ꠖꠥꠘꠤꠀꠞ ꠌꠈꠥꠔ ꠝꠞꠤꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("GL6_15","078_6_15","GAL","6","15","15","ꠄꠞꠖꠣꠄ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟꠦꠅ ꠎꠦꠔꠣ, ꠘꠣ ꠇꠞꠣꠁꠟꠦꠅ ꠅꠔꠣ। ꠀꠟ-ꠝꠍꠤꠞ ꠎꠞꠤꠀꠄ ꠢꠤꠞꠛꠣꠞ ꠘꠄꠀ ꠙꠄꠖꠣ ꠅꠀꠃ ꠅꠁꠟ ꠀꠍꠟ ꠛꠦꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("GL6_16","078_6_16","GAL","6","16","16","ꠀꠞ ꠅꠃ ꠁꠝꠣꠘꠦ ꠎꠦꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠄ, ꠝꠣꠘꠤ ꠈꠣꠐꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣꠞꠦ, ꠔꠣꠁꠘ ꠞꠢꠝ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("GL6_17","078_6_17","GAL","6","17","17","ꠢꠦꠡ-ꠝꠦꠡ ꠇꠁꠞꠣꠝ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠁꠞ ꠈꠣꠁꠀ ꠇꠔ ꠘꠝꠥꠘꠣꠞ ꠎꠈꠝ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠅ ꠟꠁꠀ ꠌꠇ꠆ꠇꠞ ꠖꠤꠀꠞ। ꠔꠦ ꠀꠝꠣꠞꠦ ꠇꠦꠃ ꠖꠥꠈ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("GL6_18","078_6_18","GAL","6","18","18","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠞꠣꠞ ꠝꠥꠘꠤꠛ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠇꠣꠁꠝ ꠞꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("EP1_1","079_1_1","EPH","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤ। ꠁꠚꠤꠍ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠀꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠅꠃ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EP1_2","079_1_2","EPH","1","2","2","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠀꠙꠘꠣꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠘꠣꠎꠤꠟ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("EP1_3","079_1_3","EPH","1","3","3","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠔꠣꠞꠤꠚ ꠅꠃꠇ, ꠔꠣꠁꠘꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚ, ꠀꠞ ꠅꠃ ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ। ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠍꠝꠣꠘꠞ ꠙꠞꠔꠦꠇ ꠘꠝꠥꠘꠣꠞ ꠞꠥꠢꠣꠘꠤ ꠞꠢꠝꠔ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP1_4","079_1_4","EPH","1","4","4","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣ ꠎꠣꠔꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠀꠞ ꠘꠤꠈꠥꠔ ꠅꠁꠔꠣꠝ ꠙꠣꠞꠤ, ꠅꠃ ꠈꠤꠀꠟꠦ ꠔꠣꠁꠘ ꠁ ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣꠞ ꠀꠉꠦꠃ, ꠘꠤꠎꠞ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP1_5","079_1_5","EPH","1","5","5","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠝꠞ꠆ꠎꠤ ꠀꠞ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠀꠉꠦꠃ ꠑꠤꠇ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠂꠘ, ꠎꠣꠔꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠀꠙꠘ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EP1_6","079_1_6","EPH","1","6","6","ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠍꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠎꠔ ꠙꠞꠤꠝꠣꠘꠦ ꠞꠢꠝꠔ ꠀꠞ ꠝꠢꠤꠝꠣ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠅꠔꠣꠄ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EP1_7","079_1_7","EPH","1","7","7","ꠀꠟ-ꠝꠍꠤꠞ ꠙꠛꠤꠔ꠆ꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠟꠃꠞ ꠛꠖꠟꠣ ꠀꠝꠞꠣ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠍꠤ, ꠀꠝꠞꠣ ꠅꠃ ꠝꠣꠚꠤ ꠙꠣꠁꠍꠤ, ꠁꠔꠣ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠈꠣꠍ ꠞꠢꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("EP1_8","079_1_8","EPH","1","8","8","ꠅꠃ ꠞꠢꠝꠔ ꠔ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠈꠣꠍ ꠀꠈꠟ-ꠢꠦꠇꠝꠔꠦ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠓꠣꠟꠤꠀ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP1_9","079_1_9","EPH","1","9","9","ꠔꠣꠁꠘ ꠀꠉꠦ ꠕꠣꠇꠤ ꠎꠦꠟꠣꠈꠣꠘ ꠈꠤꠀꠟ ꠇꠞꠍꠟꠣ, ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠎꠦꠔꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔ ꠇꠞꠍꠤꠟꠣ, ꠅꠃ ꠈꠤꠀꠟ-ꠈꠥꠡꠤꠞ ꠢꠇ꠆ꠇꠟ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP1_10","079_1_10","EPH","1","10","10","ꠔꠣꠁꠘ ꠔ ꠀꠉꠦꠃ ꠅꠈꠣꠘ ꠑꠤꠇ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠤꠟꠣ, ꠎꠣꠔꠦ ꠡꠝꠄ ꠙꠥꠞꠣ ꠅꠁꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠘ ꠀꠙꠘ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠤꠀ, ꠀꠟ-ꠝꠍꠤꠞ ꠀꠅꠔꠣꠄ ꠀꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EP1_11","079_1_11","EPH","1","11","11","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠀꠈꠟ-ꠁꠘꠍꠣꠚ ꠖꠤꠀ ꠘꠤꠎꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠢꠇꠟ ꠇꠣꠝ ꠇꠞꠂꠘ। ꠔꠣꠘ ꠝꠥꠘꠡꠣ ꠝꠣꠚꠤꠇ ꠔꠣꠁꠘ ꠀꠉꠦꠃ ꠎꠦꠔꠣ ꠑꠤꠇ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠤꠟꠣ, ꠢꠃ ꠝꠥꠘꠡꠣ ꠝꠣꠚꠤꠇ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦꠅ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠈꠣꠍ ꠛꠘ꠆ꠖꠣ ꠅꠀꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("EP1_12","079_1_12","EPH","1","12","12","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠎꠦꠞꠣ ꠀꠉ ꠕꠣꠇꠤꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠔꠣꠝ, ꠅꠃ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠖꠤꠃ ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠅꠄ, ꠅꠃ ꠈꠤꠀꠟꠦꠃ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP1_13","079_1_13","EPH","1","13","13","ꠀꠞ ꠀꠙꠘꠣꠞꠣꠅ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇ ꠇꠣꠟꠣꠝ, ꠝꠣꠘꠤ ꠘꠣꠎꠣꠔꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠙꠣꠁꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ। ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠅꠀꠄ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠣꠘ ꠅꠀꠖꠣ ꠇꠞꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠀ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP1_14","079_1_14","EPH","1","14","14","ꠔꠦ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠡꠝ꠆ꠙꠖ ꠇꠁꠀ ꠒꠣꠇꠤꠍꠂꠘ, ꠄꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠄꠇꠐꠣ ꠅꠗꠤꠇꠣꠞ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠎꠔꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠄꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠈꠣꠟꠣꠍ ꠘꠣ ꠅꠁꠍꠂꠘ, ꠅꠔꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠅꠗꠤꠇꠣꠞꠞ ꠙꠄꠟꠣ ꠇꠤꠡ꠆ꠔꠤ ꠢꠤꠡꠣꠛꠦ ꠄꠞꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ꠀꠞ ꠅꠃ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣꠞ ꠔꠣꠞꠤꠚ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EP1_15","079_1_15","EPH","1","15","15","ꠔꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠀꠙꠘꠣꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠟ ꠛꠘ꠆ꠖꠣꠞꠦꠃ ꠀꠙꠘꠣꠞꠣ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠞꠣ, ꠅꠃ ꠈꠛꠞ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠢꠥꠘꠟꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("EP1_16","079_1_16","EPH","1","16","16","ꠢꠥꠘꠣꠞ ꠛꠣꠖ ꠕꠣꠇꠤꠃ, ꠀꠝꠤ ꠀꠙꠘꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠣ ꠇꠥꠘꠥ ꠡꠝꠄꠅ ꠛꠘ꠆ꠖ ꠇꠞꠍꠤ ꠘꠣ। ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠤ, ꠁ ꠡꠝꠄ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠇꠕꠣ ꠚꠣꠃꠞꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EP1_17","079_1_17","EPH","1","17","17","ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠞꠎ ꠇꠞꠤ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠟ꠆ꠟꠣꠄ, ꠎꠣꠟꠣꠟ ꠀꠞ ꠡꠣꠘ ꠀꠟꠣ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠞꠥꠢꠣꠘꠤ ꠀꠈꠟ ꠀꠞ ꠛꠥꠎꠣꠞ ꠈꠦꠝꠔꠣ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠔꠦꠃ ꠀꠙꠘꠣꠞꠣ ꠀꠞꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EP1_18","079_1_18","EPH","1","18","18","ꠀꠝꠤ ꠀꠞꠅ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠤꠀꠞ, ꠀꠙꠘꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠌꠃꠈ ꠈꠥꠟꠤ ꠎꠣꠃꠇ, ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠁ ꠖꠣꠅꠔ ꠙꠣꠁꠀ ꠀꠙꠘꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠎꠦ ꠄꠡꠇꠤ ꠙꠄꠖꠣ ꠅꠁꠍꠦ ꠅꠔꠣ ꠀꠞꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠛꠥꠎꠛꠣ। ꠄꠞꠟꠉꠦ ꠄꠅꠈꠣꠘꠅ ꠛꠥꠎꠔꠣ ꠙꠣꠞꠛꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠘ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠇꠔ ꠛꠠ ꠡꠝ꠆ꠙꠔ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("EP1_19","079_1_19","EPH","1","19","19","ꠀꠞ ꠀꠝꠞꠣ ꠎꠦꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠤ, ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠇꠔ ꠛꠠ ꠡꠇ꠆ꠔꠤꠄ ꠇꠣꠝ ꠇꠞꠦꠞ। ꠁ ꠡꠇ꠆ꠔꠤ ꠅꠁꠟ, ꠔꠣꠘ ꠇꠥꠖꠞꠔꠞ ꠝꠢꠣꠡꠇ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("EP1_20","079_1_20","EPH","1","20","20","ꠅꠃ ꠡꠇ꠆ꠔꠤꠞ ꠛꠟꠦꠃ ꠔꠣꠁꠘ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠔꠣꠘ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠘꠤꠀ ꠛꠅꠀꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP1_21","079_1_21","EPH","1","21","21","ꠀꠍꠝꠣꠘꠞ ꠢꠇ꠆ꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠈꠦꠝꠔꠣ, ꠡꠣꠡꠘ, ꠡꠇ꠆ꠔꠤ, ꠀꠞ ꠛꠣꠢꠣꠖꠥꠞꠤ ꠎꠣꠞꠣꠞ ꠀꠔꠅ ꠀꠍꠦ, ꠄꠞꠣ ꠢꠇꠟꠞꠦꠃ ꠔꠣꠁꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠟꠦ ꠞꠣꠈꠍꠂꠘ। ꠀꠞ ꠎꠣꠞꠦ ꠎꠦ ꠘꠣꠝꠦꠃ ꠒꠣꠇꠣ ꠅꠄ ꠘꠣ ꠇꠦꠘꠦ, ꠁꠔꠣ ꠁ ꠎꠉꠔꠞ ꠅꠃꠇ ꠛꠣ ꠀꠈꠦꠞꠤ ꠎꠉꠔꠞ ꠅꠃꠇ, ꠢꠇ꠆ꠇꠟ ꠘꠣꠝꠞ ꠃꠙꠞꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EP1_22","079_1_22","EPH","1","22","22","ꠀꠟ꠆ꠟꠣꠄ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠅꠔꠣꠄ ꠞꠣꠈꠍꠂꠘ। ꠝꠣꠘꠡꠞ ꠝꠣꠕꠣ ꠎꠦꠟꠣ ꠔꠣꠞ ꠡꠞꠤꠟꠞ ꠛꠣꠖꠡꠣ, ꠀꠟ-ꠝꠍꠤꠞꠦ ꠅꠟꠣ ꠎꠝꠣꠔꠞ ꠝꠣꠕꠣ, ꠝꠣꠘꠤ ꠛꠣꠖꠡꠣ ꠢꠤꠡꠣꠛꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP1_23","079_1_23","EPH","1","23","23","ꠀꠞ ꠁ ꠎꠝꠣꠔ ꠅꠁꠟꠉꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠡꠞꠤꠟ। ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠀꠟ-ꠝꠍꠤꠄ ꠎꠝꠣꠔꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP2_1","079_2_1","EPH","2","1","1","ꠔꠥꠝꠞꠣ ꠔ ꠉꠥꠘꠣ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠝꠞꠣ ꠀꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EP2_2","079_2_2","EPH","2","2","2","ꠎꠉꠔꠞ ꠜꠣꠛꠞ ꠝꠣꠎꠦ ꠙꠠꠤꠀ ꠔꠥꠝꠞꠣꠅ ꠄꠇ ꠡꠝꠄ ꠢꠃ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠔꠣꠄ। ꠎꠦ ꠛꠖ ꠞꠥꠢꠥ ꠀꠍꠝꠣꠘꠞ ꠢꠇꠟ ꠕꠣꠇꠤ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠞꠣꠎꠣ, ꠢꠃ ꠛꠖ ꠞꠥꠢꠦ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠜꠤꠔꠞꠦ ꠇꠣꠝ ꠇꠞꠦ, ꠀꠞ ꠔꠥꠝꠞꠣꠅ ꠢꠃ ꠛꠖ ꠞꠥꠢꠥꠞ ꠝꠥꠞꠤꠖ ꠀꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EP2_3","079_2_3","EPH","2","3","3","ꠀꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠄꠇ ꠡꠝꠄ ꠉꠥꠘꠣꠞ ꠡ꠆ꠛꠜꠣꠛꠞ ꠉꠥꠟꠣꠝ ꠛꠘꠤꠀ, ꠅꠔꠣ ꠘꠣꠚꠞꠝꠣꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔꠣꠝ। ꠅꠃ ꠛꠖ ꠡ꠆ꠛꠜꠣꠛ ꠕꠣꠇꠤ ꠎꠦ ꠛꠖ ꠈꠣꠁꠡ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠀꠁꠔ, ꠀꠝꠞꠣ ꠅꠟꠣ ꠇꠣꠝ ꠇꠞꠔꠣꠝ। ꠀꠞ ꠅꠃ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠟꠣꠉꠤ ꠢꠔꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣꠅ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛꠞ ꠟꠣꠈ ꠀꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EP2_4","079_2_4","EPH","2","4","4","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠞꠢꠝꠔꠞ ꠜꠣꠘ꠆ꠒꠣꠞ; ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠈꠥꠛ ꠛꠦꠡꠤ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP2_5","079_2_5","EPH","2","5","5","ꠄꠞꠟꠣꠉꠤꠃ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠤꠀ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠝꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠝꠣꠎꠦ ꠢꠣꠛꠥꠒꠥꠛꠥ ꠈꠣꠁꠍꠟꠣꠝ, ꠢꠃ ꠡꠝꠄ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠟꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠔꠥꠝꠞꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("EP2_6","079_2_6","EPH","2","6","6","ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠀꠍꠤ, ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠀ, ꠔꠣꠘ ꠟꠉꠦ ꠇꠞꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠜꠤꠔꠞꠦ ꠛꠅꠀꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP2_7","079_2_7","EPH","2","7","7","ꠔꠣꠁꠘ ꠁꠔꠣ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠝꠢꠣ-ꠝꠥꠟ꠆ꠟꠛꠣꠘ ꠞꠢꠝꠔ ꠅꠇꠟ ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠌꠤꠞꠇꠣꠟ ꠖꠦꠈꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ। ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠖꠄꠀ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠖꠄꠀꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠘ ꠁ ꠞꠢꠝꠔꠞ ꠇꠕꠣ ꠎꠣꠁꠞ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EP2_8","079_2_8","EPH","2","8","8","ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠔꠥꠝꠞꠣ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠍ। ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠇꠥꠘꠥ ꠀꠝꠟꠞ ꠚꠟ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠖꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("EP2_9","079_2_9","EPH","2","9","9","ꠁꠔꠣ ꠔ ꠇꠥꠘꠥ ꠘꠦꠇ ꠇꠣꠝꠞ ꠛꠖꠟꠣ ꠘꠣꠄ, ꠎꠣꠔꠦ ꠇꠦꠃ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠛꠠꠣꠁ ꠇꠞꠔ ꠘꠣ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("EP2_10","079_2_10","EPH","2","10","10","ꠀꠝꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠀꠔꠞ ꠙꠄꠖꠣ। ꠔꠣꠁꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠘꠄꠀ ꠇꠞꠤ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠤ। ꠅꠃ ꠘꠦꠇ ꠇꠣꠝ ꠔꠣꠁꠘ ꠀꠉꠦ ꠕꠣꠇꠤꠃ ꠑꠤꠇ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠤꠟꠣ ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠅꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("EP2_11","079_2_11","EPH","2","11","11","ꠎꠘꠝꠉꠔ ꠜꠣꠛꠦ ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠛꠤꠗꠞ꠆ꠝꠤ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ। ꠝꠣꠘꠡꠞ ꠀꠔ ꠖꠤꠀ ꠎꠣꠞꠣꠞꠦ ꠡꠞꠤꠟꠅ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ ꠅꠁꠍꠦ, ꠄꠞꠣ ꠇꠁꠞꠣ, ꠔꠥꠝꠞꠣ ꠛꠥꠟꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EP2_12","079_2_12","EPH","2","12","12","ꠔꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠉꠦ ꠔ ꠔꠥꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟ ꠀꠍꠟꠣꠄ; ꠔꠥꠝꠞꠣ ꠀꠍꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠁꠞꠞ ꠝꠣꠘꠥꠡ। ꠀꠟ꠆ꠟꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠎꠔ ꠟꠣꠈꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠁꠔꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞ ꠔ ꠇꠥꠘꠥ ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠀꠍꠤꠟ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠀꠡꠣꠅ ꠀꠍꠤꠟ ꠘꠣ; ꠔꠥꠝꠞꠣ ꠀꠍꠟꠣꠄ ꠁ ꠖꠥꠘꠤꠀꠔ ꠀꠟ꠆ꠟꠣ ꠍꠣꠠꠣ ꠎꠣꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("EP2_13","079_2_13","EPH","2","13","13","ꠄꠇ ꠇꠕꠣꠄ, ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠀꠍꠟꠣꠄ। ꠅꠁꠟꠦ ꠅꠈꠘ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠅꠀꠄ, ꠔꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠗꠣꠞꠅ ꠀꠘꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EP2_14","079_2_14","EPH","2","14","14","ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞ ꠡꠣꠘ꠆ꠔꠤ। ꠁꠍꠞꠣꠁꠟ ꠎꠣꠔꠤ ꠀꠞ ꠜꠤꠘ ꠎꠣꠔꠤ, ꠢꠇ꠆ꠇꠟꠞꠦ ꠔꠣꠁꠘ ꠄꠇ ꠇꠞꠍꠂꠘ। ꠁ ꠖꠥꠁꠅ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠦ ꠖꠥꠡꠝꠘꠤꠞ ꠎꠦ ꠅꠀꠟ ꠀꠍꠤꠟ, ꠁ ꠅꠀꠟꠞꠦ ꠔꠣꠁꠘ ꠜꠣꠋꠉꠤꠀ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP2_15","079_2_15","EPH","2","15","15","ꠀꠞ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠘꠤꠎꠞ ꠇꠣꠄꠀꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ, ꠔꠣꠁꠘ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔꠞ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠀꠞ ꠀꠁꠘ-ꠇꠣꠘꠥꠘꠞ ꠈꠦꠝꠔꠣꠞꠦ ꠛꠣꠔꠤꠟ ꠇꠞꠍꠂꠘ। ꠔꠣꠘ ꠁꠟꠣ ꠇꠞꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠌꠣꠁꠟꠣ, ꠅꠃ ꠖꠥꠁꠅꠔꠣ ꠖꠤꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠘꠄꠀ ꠄꠇ ꠎꠣꠔꠤ ꠙꠄꠖꠣ ꠇꠞꠔꠣ, ꠎꠣꠔꠦ ꠅꠃ ꠎꠣꠔꠤꠞ ꠝꠣꠎꠖꠤ ꠁ ꠖꠥꠁꠅ ꠖꠟꠞ ꠝꠣꠎꠦ ꠡꠣꠘ꠆ꠔꠤ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EP2_16","079_2_16","EPH","2","16","16","ꠀꠞ ꠔꠣꠁꠘ ꠌꠣꠁꠟꠣ, ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ, ꠅꠃ ꠖꠥꠁꠅ ꠖꠟꠞꠦ ꠔꠣꠁꠘ ꠄꠇꠈꠣꠘꠅ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘ ꠊꠐꠣꠁꠔꠣ। ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠖꠥꠁꠅ ꠖꠟꠞ ꠝꠣꠎꠦ ꠖꠥꠡꠝꠘꠤꠞ ꠎꠦ ꠜꠣꠛ ꠀꠍꠤꠟ, ꠁ ꠖꠥꠡꠝꠘꠤꠞꠦ ꠔꠣꠁꠘ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠝꠤꠐꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP2_17","079_2_17","EPH","2","17","17","ꠔꠥꠝꠞꠣ ꠄꠇ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠀꠍꠟꠣꠄ, ꠀꠞ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠅꠇꠟ ꠇꠣꠍꠣꠔ ꠀꠍꠟꠣ, ꠅꠈꠘ ꠔꠣꠁꠘ ꠀꠁꠀ ꠅꠃ ꠖꠥꠁꠅ ꠖꠟꠞ ꠉꠦꠍꠦꠃ ꠡꠣꠘ꠆ꠔꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP2_18","079_2_18","EPH","2","18","18","ꠄꠞ ꠚꠟꠦ ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣ ꠖꠥꠁꠅ ꠖꠟ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤ, ꠀꠝꠞꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠅꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("EP2_19","079_2_19","EPH","2","19","19","ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠛꠣꠁꠞꠞ ꠝꠣꠘꠥꠡ ꠘꠣꠄ, ꠜꠤꠘ ꠎꠣꠔꠤꠅ ꠘꠣꠄ। ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠅ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠞ ꠔꠣꠘ ꠙꠞꠤꠛꠣꠞꠞ ꠡꠖꠁꠡ꠆ꠡ ꠛꠘꠤꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("EP2_20","079_2_20","EPH","2","20","20","ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟ ꠅꠁꠟꠣ ꠔꠣꠘ ꠊꠞꠞ ꠈꠥꠐꠤ, ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠅꠁꠟꠣ ꠝꠥꠟ ꠁꠀꠘ ꠈꠥꠐꠤ। ꠅꠃ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠉꠠꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EP2_21","079_2_21","EPH","2","21","21","ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠄ, ꠀꠡ꠆ꠔꠣ ꠊꠞꠞ ꠢꠇꠟ ꠅꠋꠡ ꠄꠇꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠄꠇꠈꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠊꠞ ꠔꠤꠀꠞ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EP2_22","079_2_22","EPH","2","22","22","ꠔꠥꠝꠞꠣꠅ ꠀꠁꠀ ꠔꠣꠘ ꠟꠉꠦ ꠎꠥꠠꠣ ꠟꠣꠉꠍ, ꠝꠣꠘꠤ ꠔꠣꠘ ꠃꠝ꠆ꠝꠔ ꠅꠁꠍ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠄꠇꠟꠉꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣ ꠅꠞ, ꠎꠣꠔꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤ ꠁ ꠊꠞꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EP3_1","079_3_1","EPH","3","1","1","ꠅꠃ ꠇꠣꠞꠘꠦ ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠀ ꠇꠞꠤꠀꠞ। ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠣꠞꠣ ꠜꠤꠘ ꠎꠣꠔꠤ, ꠔꠥꠝꠞꠣꠞꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠞ ꠖꠣꠅꠔ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠅꠈꠘ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EP3_2","079_3_2","EPH","3","2","2","ꠔꠥꠝꠞꠣ ꠘꠤꠌꠄ ꠢꠥꠘꠍ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠅꠃ ꠈꠣꠍ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠤꠍꠂꠘ, ꠔꠣꠘ ꠞꠢꠝꠔꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠙꠃꠍꠣꠁ ꠖꠤꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EP3_3","079_3_3","EPH","3","3","3","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠣꠔꠥꠘꠤ ꠝꠥꠘꠡꠣ ꠅꠢꠤꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠣꠞꠦ ꠎꠣꠘꠣꠁꠍꠂꠘ, ꠀꠞ ꠅꠃ ꠛꠦꠙꠣꠞꠈꠣꠘ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠡꠋꠇ꠆ꠇꠦꠙꠦ ꠟꠦꠈꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EP3_4","079_3_4","EPH","3","4","4","ꠁꠈꠣꠘ ꠙꠠꠟꠦ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠛꠣꠄ, ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠃ ꠛꠣꠔꠥꠘꠤ ꠛꠤꠡꠄ ꠛꠥꠎꠣꠞ ꠈꠦꠝꠔꠣ ꠀꠝꠣꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EP3_5","079_3_5","EPH","3","5","5","ꠁ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞꠈꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠦꠟꠣ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤ ꠅꠈꠘ ꠎꠣꠁꠞ ꠅꠞ, ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦꠃ ꠁꠟꠣ ꠎꠣꠁꠞ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EP3_6","079_3_6","EPH","3","6","6","ꠀꠞ ꠁ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞ ꠅꠁꠟ, ꠁꠘ꠆ꠎꠤꠟꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠝꠣꠎꠖꠤ ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠅ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠄꠇ ꠅꠁꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠁ ꠅꠗꠤꠇꠣꠞꠅ ꠡꠞꠤꠇ ꠅꠄ, ꠢꠇꠟ ꠄꠇ ꠡꠞꠤꠟꠞ ꠅꠋꠡ ꠅꠄ, ꠄꠇꠁ ꠅꠀꠖꠣꠞ ꠖꠥꠀꠞ ꠜꠣꠉꠤ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EP3_7","079_3_7","EPH","3","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠝꠢꠣ ꠇꠥꠖꠞꠔꠞ ꠛꠟꠦ ꠀꠝꠣꠞꠦ ꠞꠢꠝꠔ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠎꠦꠟꠣ ꠞꠢꠝꠔ ꠙꠣꠁꠍꠤ, ꠅꠟꠣ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EP3_8","079_3_8","EPH","3","8","8","ꠀꠟ꠆ꠟꠣꠞ ꠢꠇ꠆ꠇꠟ ꠛꠘ꠆ꠖꠣꠞ ꠝꠣꠎꠦ ꠀꠝꠣ ꠕꠣꠇꠤ ꠢꠥꠞꠥ ꠀꠞ ꠇꠦꠃ ꠘꠣꠁ, ꠔꠣ-ꠅ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠦ ꠗꠘꠞ ꠇꠕꠣ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠛꠥꠎꠣ ꠎꠣꠄ ꠘꠣ, ꠅꠃ ꠝꠥꠟ꠆ꠟꠛꠣꠘ ꠗꠘꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠖꠤꠍꠂꠘ, ꠁꠐꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("EP3_9","079_3_9","EPH","3","9","9","ꠀꠞ ꠔꠣꠘ ꠛꠣꠔꠥꠘꠤ ꠝꠥꠘꠡꠣ ꠇꠤꠟꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠟ ꠎꠣꠄ, ꠁꠈꠣꠘ ꠎꠣꠁꠞ ꠇꠞꠣꠞ ꠜꠣꠞꠅ ꠔꠣꠁꠘ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠖꠤꠍꠂꠘ। ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠄ ꠅꠔꠖꠤꠘ ꠗꠞꠤꠀ ꠁꠔꠣ ꠛꠣꠔꠥꠘꠤ ꠞꠣꠈꠍꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EP3_10","079_3_10","EPH","3","10","10","ꠔꠣꠁꠘ ꠁꠔꠣ ꠛꠣꠔꠥꠘꠤ ꠞꠣꠈꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠀꠍꠝꠣꠘꠞ ꠢꠇꠟ ꠞꠣꠎꠣ ꠀꠞ ꠈꠦꠝꠔꠣꠀꠟꠣ ꠢꠇꠟꠞ ꠉꠦꠍꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠝꠣꠔꠞ ꠝꠣꠎꠖꠤ ꠅꠈꠘ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EP3_11","079_3_11","EPH","3","11","11","ꠔꠣꠘ ꠘꠤꠎꠞ ꠌꠤꠞꠇꠣꠟꠞ ꠝꠥꠘꠡꠣ ꠝꠣꠚꠤꠇ ꠁꠔꠣ ꠅꠁꠍꠦ, ꠀꠞ ꠅꠃ ꠝꠥꠘꠡꠣ-ꠝꠞ꠆ꠎꠤ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠙꠥꠞꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP3_12","079_3_12","EPH","3","12","12","ꠔꠣꠘ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠀ ꠁꠝꠣꠘꠞ ꠛꠟꠦ, ꠛꠥꠇꠥꠔ ꠡꠣꠅꠡ ꠞꠣꠈꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠞꠣ ꠀꠎꠤꠞ ꠅꠀꠞ ꠄꠈꠔꠤꠀꠞ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EP3_13","079_3_13","EPH","3","13","13","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠀꠝꠤ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀꠞ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣ ꠘꠤꠞꠣꠡ ꠅꠁꠅ ꠘꠣ। ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀꠞ, ꠄꠞꠟꠣꠉꠤ ꠉꠃꠞꠛ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP3_14","079_3_14","EPH","3","14","15","ꠔꠦ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞꠞꠦ ꠎꠦꠁꠘ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠝꠤ ꠀꠐꠥ ꠉꠣꠠꠤꠀ ꠢꠃ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠚꠞ ꠍꠣꠝꠘꠦ ꠝꠥꠘꠣꠎꠣꠔꠅ ꠛꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EP3_16","079_3_16","EPH","3","16","16","ꠀꠝꠤ ꠖꠥꠀ ꠇꠞꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠘꠥ ꠔꠣꠘ ꠅꠡꠦꠡ ꠇꠥꠖꠞꠔꠞ ꠛꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠝꠘ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠖꠦꠁꠘ, ꠎꠣꠔꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠝꠎꠛꠥꠔ ꠅꠄ, ");
INSERT INTO syls_vpl VALUES ("EP3_17","079_3_17","EPH","3","17","17","ꠀꠞ ꠁꠝꠣꠘꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠈꠟ ꠇꠞꠂꠘ। ꠀꠝꠤ ꠖꠥꠀ ꠇꠞꠤ, ꠔꠥꠝꠞꠣ ꠎꠣꠘꠥ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠎꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠒꠥꠛ ꠖꠤꠀ ꠕꠤꠞ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP3_18","079_3_18","EPH","3","18","18","ꠔꠦꠃ ꠢꠇꠟ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠅ ꠛꠥꠎꠛꠣꠄ, ꠀꠟ-ꠝꠍꠤꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠇꠥꠘꠥ ꠇꠥꠟ-ꠇꠤꠘꠣꠞ ꠘꠣꠁ, ꠇꠥꠘꠥ ꠡꠦꠡ ꠡꠤꠝꠣ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("EP3_19","079_3_19","EPH","3","19","19","ꠅꠃ ꠎꠦ ꠝꠢꠛ꠆ꠛꠔ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠥꠎꠣꠞ ꠅꠡꠣꠁꠖ꠆ꠖ, ꠀꠝꠤ ꠖꠥꠀ ꠇꠞꠤꠀꠞ, ꠁ ꠝꠢꠛ꠆ꠛꠔꠞꠦ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣ ꠌꠤꠘꠅ, ꠌꠤꠘꠤꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣꠅ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠉꠥꠘꠣꠉꠥꠘ ꠢꠣꠍꠤꠟ ꠇꠞꠤꠀ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠟ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("EP3_20","079_3_20","EPH","3","20","20","ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠇꠣꠝ ꠇꠞꠦ, ꠢꠃ ꠛꠟꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠛꠣ ꠌꠣꠅꠀ-ꠙꠣꠅꠀ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠃꠔ ꠛꠦꠡꠤ ꠇꠣꠝ ꠔꠣꠁꠘ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP3_21","079_3_21","EPH","3","21","21","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤꠀ ꠀꠞ ꠎꠝꠣꠔꠞ ꠝꠣꠎꠖꠤꠀꠅ ꠎꠥꠉ ꠎꠥꠉ ꠗꠞꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("EP4_1","079_4_1","EPH","4","1","1","ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠀꠍꠤ। ꠅꠃ ꠛꠘ꠆ꠖꠤ ꠢꠣꠟꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ, ꠎꠦ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠄꠞ ꠃꠙꠎꠥꠇ꠆ꠔ ꠅꠁꠀ ꠌꠟ। ");
INSERT INTO syls_vpl VALUES ("EP4_2","079_4_2","EPH","4","2","2","ꠔꠥꠝꠞꠣꠞ ꠀꠌꠣꠞ-ꠛꠦꠛꠢꠣꠞ ꠎꠣꠘꠥ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠤꠑꠣ ꠀꠞ ꠘꠞꠝ ꠅꠄ। ꠙꠞꠔꠦꠇꠦ ꠍꠛꠞ ꠇꠞꠅ ꠀꠞ ꠖꠤꠟꠅ ꠝꠢꠛ꠆ꠛꠔ ꠞꠣꠈꠤꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP4_3","079_4_3","EPH","4","3","3","ꠀꠟ-ꠝꠍꠤꠞ ꠎꠦ ꠡꠣꠘ꠆ꠔꠤꠄ ꠀꠝꠞꠣꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠁꠍꠦ, ꠢꠃ ꠡꠣꠘ꠆ꠔꠤꠞ ꠛꠟꠦ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠖꠦꠅꠀ ꠄꠇꠔꠣ ꠞꠇ꠆ꠇꠣꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP4_4","079_4_4","EPH","4","4","4","ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠙꠕꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠈꠣꠟꠤ ꠄꠇꠈꠣꠘ ꠀꠡꠣ ꠀꠍꠦ, ꠈꠣꠟꠤ ꠄꠇ ꠡꠞꠤꠟ ꠀꠞ ꠄꠇꠎꠘ ꠙꠣꠇ ꠞꠥꠢꠥ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP4_5","079_4_5","EPH","4","5","5","ꠄꠇ ꠁꠝꠣꠘ, ꠄꠇ ꠔꠞꠤꠇꠣꠛꠘ꠆ꠖꠤ ꠀꠞ ꠄꠇꠎꠘ ꠝꠣꠟꠤꠇ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP4_6","079_4_6","EPH","4","6","6","ꠢꠇꠟꠞ ꠀꠟ꠆ꠟꠣ ꠈꠣꠟꠤ ꠄꠇꠎꠘ, ꠝꠣꠘꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠄꠇꠎꠘꠃ ꠀꠍꠂꠘ। ꠔꠣꠁꠘꠃ ꠢꠇꠟꠞ ꠃꠙꠞꠦ, ꠢꠇꠟꠞ ꠝꠣꠎꠦ, ꠢꠇꠟꠞ ꠖꠤꠟꠅ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP4_7","079_4_7","EPH","4","7","7","ꠅꠁꠟꠦ ꠀꠟ-ꠝꠍꠤꠄ ꠎꠦꠟꠣ ꠑꠤꠇ ꠇꠞꠤꠀ ꠞꠣꠈꠍꠂꠘ, ꠢꠃ ꠝꠣꠚꠤꠇ ꠀꠝꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠈꠣꠍ ꠞꠢꠝꠔ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EP4_8","079_4_8","EPH","4","8","8","ꠄꠞꠟꠣꠉꠤ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠣꠁꠘ ꠉꠤꠀ ꠎꠦꠛꠟꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠃꠑꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠛꠘ꠆ꠖꠤ ꠅꠇꠟꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠐꠣꠘꠤꠀ ꠘꠤꠟꠣ, ꠀꠞ ꠔꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠛꠃꠔ ꠖꠣꠘ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EP4_9","079_4_9","EPH","4","9","9","ꠔꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠉꠤꠀ ꠃꠑꠤꠟꠣ, ꠁ ꠀꠄꠀꠔ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ ꠘꠣ ꠘꠤ, ꠀꠉꠦ ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀꠞ ꠔꠟꠦ ꠟꠣꠝꠍꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EP4_10","079_4_10","EPH","4","10","10","ꠀꠞ ꠎꠦꠁꠘ ꠟꠣꠝꠍꠤꠟꠣ, ꠔꠣꠁꠘ ꠢꠇꠟꠔꠣ ꠙꠥꠞꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠀꠞꠅ ꠃꠙꠞꠦ ꠉꠤꠀ ꠃꠑꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP4_11","079_4_11","EPH","4","11","11","ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠅꠃ ꠖꠣꠘ ꠖꠤꠍꠂꠘ, ꠇꠄꠎꠘꠞꠦ ꠍꠣꠢꠣꠛꠤ, ꠇꠄꠎꠘꠞꠦ ꠘꠛꠤ, ꠇꠄꠎꠘꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠔꠛꠟꠤꠉ, ꠇꠄꠎꠘꠞꠦ ꠎꠝꠣꠔꠞ ꠁꠝꠣꠝ ꠀꠞ ꠃꠡ꠆ꠔꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP4_12","079_4_12","EPH","4","12","12","ꠔꠣꠁꠘ ꠁꠟꠣ ꠇꠞꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠦ ꠎꠣꠘꠥ ꠔꠣꠘ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠅꠄ, ꠀꠞ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠀꠟ-ꠝꠍꠤꠞ ꠡꠞꠤꠟ, ꠎꠝꠣꠔ ꠢꠤꠡꠣꠛꠦ ꠉꠠꠤꠀ ꠃꠑꠦ। ");
INSERT INTO syls_vpl VALUES ("EP4_13","079_4_13","EPH","4","13","13","ꠔꠣꠘ ꠈꠤꠀꠟ ꠅꠁꠟ, ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠎꠣꠘꠥ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ, ꠔꠣꠘꠞꠦ ꠜꠣꠟꠣ ꠇꠞꠤ ꠌꠤꠘꠤꠀ ꠄꠇꠈꠣꠘꠅ ꠅꠁ। ꠀꠞ ꠀꠟ-ꠝꠍꠤ ꠎꠦꠟꠣ ꠢꠇꠟ ꠟꠣꠈꠣꠘ ꠉꠥꠘꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠜꠞꠣ, ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠢꠇꠟ ꠉꠥꠘꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠅꠁꠀ ꠇꠣꠝꠤꠟ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("EP4_14","079_4_14","EPH","4","14","14","ꠔꠦꠃ ꠀꠝꠞꠣ ꠀꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠞꠁꠔꠣꠝ ꠘꠣꠄ। ꠝꠣꠘꠡꠦ ꠡꠄꠔꠣꠘꠤ ꠀꠈꠟ ꠈꠣꠐꠣꠁꠀ ꠛꠦ-ꠙꠕꠦ ꠘꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠞꠦ ꠎꠦ ꠜꠥꠟ ꠔꠣꠟꠤꠝ ꠖꠦꠄ, ꠅꠃ ꠜꠥꠟ ꠔꠣꠟꠤꠝꠦ ꠎꠣꠘꠥ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠘꠤꠞ ꠀꠃꠟꠣ-ꠎꠣꠃꠟꠣ ꠓꠦꠃꠞ ꠟꠣꠈꠣꠘ ꠖꠥ-ꠖꠤꠟꠣ ꠘꠣ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EP4_15","079_4_15","EPH","4","15","15","ꠛꠞꠋ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠢꠛ꠆ꠛꠔꠦ ꠢꠇ ꠝꠣꠔ ꠝꠣꠔꠤꠝꠥ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠄ ꠛꠠ ꠅꠁꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠝꠥ। ꠔꠣꠁꠘꠃ ꠔ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠞ ꠝꠣꠕꠣ। ");
INSERT INTO syls_vpl VALUES ("EP4_16","079_4_16","EPH","4","16","16","ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟ ꠅꠝꠟꠣ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠡꠞꠤꠟꠞ ꠢꠇꠟ ꠅꠋꠉ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠉꠣꠔ ꠞꠁꠀ ꠝꠥꠟ ꠇꠣꠄꠀꠞ ꠟꠉꠦ ꠎꠥꠠꠣ ꠟꠣꠉꠣꠁꠟ ꠞꠄ। ꠙꠞꠔꠦꠇ ꠅꠋꠉ ꠎꠦꠛꠟꠣ ꠑꠤꠇ-ꠑꠣꠇ ꠇꠣꠝ ꠇꠞꠦ, ꠅꠃ ꠡꠝꠄ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠃ ꠝꠣꠕꠣꠞ ꠛꠟꠦ ꠛꠣꠠꠤꠀ ꠃꠑꠦ, ꠀꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠎꠖꠤ ꠘꠤꠎꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("EP4_17","079_4_17","EPH","4","17","17","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤ ꠖꠤꠀꠞ, ꠜꠤꠘ ꠗꠞ꠆ꠝꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠛꠣꠎꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠘ, ꠔꠥꠝꠞꠣ ꠀꠞ ꠁꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EP4_18","079_4_18","EPH","4","18","18","ꠔꠣꠞꠣꠞ ꠖꠤꠟ ꠔ ꠀꠘ꠆ꠖꠣꠁꠞꠞ ꠝꠣꠎꠦ ꠙꠠꠤ ꠞꠁꠍꠦ। ꠁꠔꠣꠞ ꠖꠤꠟ ꠉꠥꠝꠞꠣ, ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠌꠤꠘꠦ ꠘꠣ, ꠇꠥꠘ꠆ꠔꠣ ꠌꠤꠘꠔ ꠌꠣꠄꠅ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠛꠃꠔ ꠖꠥꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("EP4_19","079_4_19","EPH","4","19","19","ꠔꠣꠞꠣꠞ ꠛꠤꠛꠦꠇ ꠅꠡꠣꠠ ꠅꠁꠉꠦꠍꠦ, ꠅꠔꠣꠞ ꠖꠣꠄ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠘꠣꠙꠣꠇꠤ ꠇꠣꠝꠞ ꠗꠣꠘ꠆ꠖꠣ ꠇꠞꠦ, ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠟꠣꠉꠣꠝ ꠍꠣꠠꠣ ꠛꠖ ꠈꠣꠁꠡꠞ ꠀꠔꠅ ꠍꠣꠠꠤ ꠖꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EP4_20","079_4_20","EPH","4","20","20","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠁꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EP4_21","079_4_21","EPH","4","21","21","ꠔꠥꠝꠞꠣ ꠘꠤꠌ꠆ꠌꠄ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠘꠍ, ꠢꠥꠘꠤꠀ ꠔꠣꠘ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠀ, ꠔꠣꠘ ꠝꠣꠎꠦ ꠎꠦ ꠢꠇ ꠀꠍꠦ, ꠅꠃ ꠢꠇꠞ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("EP4_22","079_4_22","EPH","4","22","22","ꠔꠣꠘ ꠔꠣꠟꠤꠝ ꠅꠁꠟ, ꠚꠤꠘ꠆ꠘꠞ ꠙꠥꠞꠣꠘ ꠇꠣꠙꠠ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠦꠄ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠜꠤꠔꠞꠞ ꠙꠥꠞꠣꠘ ‘ꠀꠝꠤ’ꠞꠦ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠦꠅ, ꠇꠣꠞꠘ ꠅꠃ ‘ꠀꠝꠤ’ꠞ ꠛꠖ ꠈꠣꠁꠡꠦ ꠝꠣꠘꠡꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠛꠞꠛꠣꠖ ꠇꠞꠤꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EP4_23","079_4_23","EPH","4","23","23","ꠄꠞ ꠛꠖꠟꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠡꠥꠎꠥꠉ ꠖꠦꠅ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠘꠄꠀ ꠢꠣꠟꠔꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠃꠇ꠆ꠇꠣ, ");
INSERT INTO syls_vpl VALUES ("EP4_24","079_4_24","EPH","4","24","24","ꠔꠣꠘ ꠖꠦꠅꠀ ꠘꠄꠀ ‘ꠀꠝꠤ’ꠞꠦ ꠘꠄꠀ ꠇꠣꠙꠠꠞ ꠟꠣꠈꠣꠘ ꠚꠤꠘ꠆ꠖꠅ। ꠅꠃ ꠘꠄꠀ ‘ꠀꠝꠤ’ꠞꠦ ꠀꠍꠟ ꠢꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤ ꠀꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠍꠥꠞꠔꠦ ꠉꠠꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("EP4_25","079_4_25","EPH","4","25","25","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠝꠤꠍꠣ ꠝꠣꠔꠣ ꠛꠣꠖ ꠖꠦꠅ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠢꠣꠍꠣ ꠝꠣꠔꠅ, ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠢꠇꠟꠃ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠤꠡꠤꠀ ꠀꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("EP4_26","079_4_26","EPH","4","26","26","ꠞꠣꠉ-ꠉꠥꠍꠣ ꠇꠞꠟꠦꠅ ꠁ ꠞꠣꠉꠞ ꠟꠣꠉꠤ ꠉꠥꠘꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠡꠥꠞꠥꠎ ꠒꠥꠛꠣꠞ ꠀꠉꠦꠃ ꠉꠥꠍꠣꠞ ꠇꠕꠣ ꠚꠣꠃꠞꠤꠟꠣꠅ, ");
INSERT INTO syls_vpl VALUES ("EP4_27","079_4_27","EPH","4","27","27","ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘꠞꠦ ꠇꠥꠘꠥ ꠡꠥꠎꠥꠉ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("EP4_28","079_4_28","EPH","4","28","28","ꠌꠥꠞꠦ ꠔꠣꠞ ꠌꠥꠞꠤ ꠇꠞꠣ ꠛꠣꠖ ꠖꠦꠃꠇ, ꠘꠤꠎꠞ ꠀꠔꠦ ꠢꠣꠟꠣꠟ ꠙꠕꠦ ꠝꠦꠘꠔ ꠇꠞꠤꠀ ꠈꠣꠘꠣ ꠈꠣꠃꠇ, ꠎꠣꠔꠦ ꠔꠣꠞ ꠈꠣꠅꠀ-ꠚꠤꠘ꠆ꠖꠣꠞ ꠛꠣꠖꠦꠅ ꠉꠞꠤꠛ-ꠖꠥꠈꠤꠞꠦ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠇꠤꠍꠥ ꠎꠝꠣ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("EP4_29","079_4_29","EPH","4","29","29","ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈꠖꠤ ꠎꠣꠘꠥ ꠛꠣꠖ ꠇꠕꠣ ꠘꠣ ꠛꠣꠞꠅꠄ, ꠛꠞꠋ ꠀꠞꠇ ꠎꠘꠞ ꠃꠙꠇꠣꠞꠤ ꠔꠣꠟꠤꠝꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ ꠝꠣꠔ ꠝꠣꠔꠤꠅ, ꠎꠣꠔꠦ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠥꠘꠞꠣ ꠎꠘꠞ ꠜꠣꠟꠣꠁ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("EP4_30","079_4_30","EPH","4","30","30","ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞꠦ ꠖꠥꠈ ꠖꠤꠅ ꠘꠣ, ꠀꠈꠦꠞꠤ ꠘꠣꠎꠣꠔꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠃ ꠞꠥꠢꠥ ꠖꠤꠀꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠤꠀ ꠕꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP4_31","079_4_31","EPH","4","31","31","ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠤꠞꠇ꠆ꠔꠤ ꠜꠣꠛ, ꠝꠤꠎꠣꠎ ꠖꠦꠈꠣꠘꠤ, ꠞꠣꠉ-ꠉꠥꠍꠣ, ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞꠣ, ꠉꠣꠟꠣ-ꠉꠣꠟꠤ, ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠁꠋꠡꠣ-ꠘꠤꠘ꠆ꠖꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EP4_32","079_4_32","EPH","4","32","32","ꠛꠞꠋ ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠖꠄꠀ ꠇꠞꠅ, ꠅꠁꠘ꠆ꠘꠞ ꠖꠥꠈꠦ ꠖꠥꠈꠤ ꠅꠅ, ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠣꠚ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_1","079_5_1","EPH","5","1","1","ꠔꠥꠝꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠄꠀꠞ ꠀꠅꠟꠣꠖ, ꠔꠦ ꠙꠥꠔ ꠎꠦꠟꠣ ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠅꠄ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_2","079_5_2","EPH","5","2","2","ꠀꠟ-ꠝꠍꠤꠄ ꠎꠦꠟꠣ ꠀꠝꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠞ ꠙꠕꠦ ꠌꠟꠅ। ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠔꠣ ꠇꠞꠤ ꠘꠤꠎꠞ ꠎꠣꠘꠞꠦ ꠈꠥꠡꠛꠄꠖꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠛꠤꠟꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP5_3","079_5_3","EPH","5","3","3","ꠇꠥꠘꠥ ꠘꠝꠥꠘꠣꠞ ꠎꠤꠘꠣ, ꠘꠣꠙꠣꠇꠤ ꠀꠞ ꠟꠥꠜ-ꠟꠣꠟꠌꠞ ꠇꠕꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠣꠘꠥ ꠘꠣ ꠢꠥꠘꠣ ꠎꠣꠄ, ꠇꠣꠞꠘ ꠁꠔꠣ ꠇꠣꠝ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EP5_4","079_5_4","EPH","5","4","4","ꠀꠞ ꠛꠦꠢꠣꠄꠀ-ꠛꠦꠁꠎ꠆ꠎꠔꠤꠞ ꠎꠦꠇꠥꠘꠥ ꠝꠣꠔ-ꠇꠕꠣ, ꠀꠌꠣꠞ-ꠛꠦꠛꠢꠣꠞ ꠛꠣ ꠈꠛꠤꠍꠤ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣ ꠅꠄ, ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠘꠣꠄ ꠘꠣ। ꠁꠔꠣꠞ ꠛꠖꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_5","079_5_5","EPH","5","5","5","ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘꠃ, ꠎꠤꠘꠣꠇꠥꠞ, ꠘꠣꠙꠣꠇ ꠀꠞ ꠟꠣꠟꠌꠤ ꠝꠣꠘꠡꠦ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠎꠣꠉꠣ ꠙꠣꠁꠔ ꠘꠣꠄ। ꠁꠔꠣꠄ ꠔ ꠄꠇꠟꠣꠈꠣꠘ ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("EP5_6","079_5_6","EPH","5","6","6","ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠝꠤꠍꠣ ꠝꠣꠔ ꠝꠣꠔꠤꠀ ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦ-ꠙꠕꠦ ꠘꠣ ꠘꠦꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠘꠤꠀ ꠎꠦꠞꠣ ꠁꠔꠣ ꠛꠖ ꠇꠣꠝ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛ ꠟꠣꠝꠦ। ");
INSERT INTO syls_vpl VALUES ("EP5_7","079_5_7","EPH","5","7","7","ꠔꠥꠝꠞꠣ ꠁꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠝꠤꠡꠤꠅ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("EP5_8","079_5_8","EPH","5","8","8","ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠕꠣꠇꠟꠦꠅ ꠅꠈꠘ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠛꠘꠤꠀ ꠘꠥꠞꠞ ꠙꠕꠅ ꠀꠁꠍ। ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠦ ꠇꠣꠝꠤꠟ ꠎꠘꠦ ꠎꠦꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠘꠤ ꠃꠌꠤꠔ, ꠔꠥꠝꠞꠣ ꠅꠃꠟꠣ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_9","079_5_9","EPH","5","9","9","ꠀꠞ ꠘꠥꠞꠦ ꠌꠟꠣꠞ ꠚꠟ ꠅꠁꠟ, ꠙꠞꠦꠎꠉꠣꠞꠤ, ꠡꠔꠔꠣ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠦꠇ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EP5_10","079_5_10","EPH","5","10","10","ꠄꠞꠟꠣꠉꠤ ꠎꠦ ꠇꠣꠝꠦ ꠝꠣꠟꠤꠇ ꠈꠥꠡꠤ ꠅꠁꠘ, ꠔꠥꠝꠞꠣ ꠎꠣꠌꠣꠁ ꠇꠞꠤꠀ ꠅꠃ ꠇꠣꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_11","079_5_11","EPH","5","11","11","ꠀꠘ꠆ꠖꠣꠁꠞ ꠎꠉꠔꠞ ꠛꠦꠚꠣꠄꠖꠣ ꠇꠣꠝꠞ ꠟꠉꠦ ꠇꠥꠘꠥ ꠘꠝꠥꠘꠣꠞ ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠞꠣꠈꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠔꠥꠝꠞꠣ ꠅꠔꠣꠞ ꠖꠥꠡ ꠖꠦꠈꠣꠁ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_12","079_5_12","EPH","5","12","12","ꠝꠣꠘꠡꠦ ꠟꠥꠇꠣꠁꠀ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠣꠅ ꠡꠞꠝ। ");
INSERT INTO syls_vpl VALUES ("EP5_13","079_5_13","EPH","5","13","13","ꠘꠥꠞꠞ ꠝꠣꠎꠖꠤ ꠖꠥꠡ ꠖꠦꠈꠣꠁꠀ ꠖꠤꠟꠣꠁꠟꠦ ꠁꠔꠣ ꠎꠣꠁꠞꠣ ꠅꠁꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("EP5_14","079_5_14","EPH","5","14","14","ꠇꠣꠞꠘ ꠅꠃ ꠘꠥꠞꠦꠃ ꠢꠇꠟꠔꠣ ꠎꠣꠁꠞ ꠇꠞꠦ। ꠄꠞꠟꠣꠉꠤ ꠍꠤꠟ꠆ꠟꠦꠈ ꠀꠍꠦ, ꠅ ꠊꠥꠝꠞ ꠝꠣꠘꠥꠡ, ꠢꠎꠣꠉ ꠅꠅ, ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠔꠣ ꠅꠅ, ꠔꠦꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠥꠞꠦ, ꠘꠥꠞꠣꠘꠤ ꠇꠞꠤꠛꠣ ꠔꠥꠝꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("EP5_15","079_5_15","EPH","5","15","15","ꠔꠥꠝꠞꠣ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣ ꠇꠞꠤ ꠖꠦꠈꠅ, ꠔꠥꠝꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠇꠤꠟꠣꠈꠣꠘ। ꠛꠦꠀꠈꠟꠞ ꠟꠣꠈꠣꠘ ꠘꠣ ꠌꠟꠤꠀ, ꠀꠈꠟꠖꠣꠞꠞ ꠟꠣꠈꠣꠘ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_16","079_5_16","EPH","5","16","16","ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠞ ꠎꠦ ꠡꠥꠎꠥꠉ ꠔꠥꠝꠞꠣꠞ ꠀꠔꠅ ꠀꠍꠦ, ꠁꠔꠣ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠅ, ꠎꠣꠘ ꠔ ꠅꠈꠘꠇꠥꠞ ꠎꠝꠣꠘꠣ ꠈꠣꠞꠣꠙ। ");
INSERT INTO syls_vpl VALUES ("EP5_17","079_5_17","EPH","5","17","17","ꠄꠞꠟꠣꠉꠤꠃ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠛꠦꠀꠈꠟ ꠛꠘꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠝꠣꠟꠤꠇꠞ ꠝꠞ꠆ꠎꠤꠞꠦ ꠛꠥꠎꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_18","079_5_18","EPH","5","18","18","ꠝꠖꠞ ꠘꠤꠡꠣꠄ ꠐꠣꠟ ꠅꠁꠅ ꠘꠣ, ꠁꠔꠣꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠘꠡ꠆ꠐ ꠇꠞꠤꠟꠣꠄ। ꠛꠞꠋ ꠙꠥꠞꠣꠙꠥꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠡꠦ ꠞꠅ, ");
INSERT INTO syls_vpl VALUES ("EP5_19","079_5_19","EPH","5","19","19","ꠔꠥꠝꠞꠣ ꠢꠣꠝꠖ, ꠇꠣꠅꠀꠟꠤ ꠀꠞ ꠙꠛꠤꠔ꠆ꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠞ ꠉꠎꠟ ꠉꠣꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠅ; ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠦ ꠝꠣꠟꠤꠇꠞ ꠘꠣꠝꠦ ꠉꠎꠟ ꠉꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_20","079_5_20","EPH","5","20","20","ꠢꠣꠝꠦꠡꠣ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_21","079_5_21","EPH","5","21","21","ꠀꠟ-ꠝꠍꠤꠞ ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠒꠞꠦ ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠖꠤꠟ ꠕꠣꠇꠤ ꠝꠣꠁꠘ꠆ꠘ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_22","079_5_22","EPH","5","22","22","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠛꠃ ꠅꠁꠍ, ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞꠦ ꠝꠣꠁꠘ꠆ꠘ ꠇꠞꠅ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠝꠣꠁꠘ꠆ꠘ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP5_23","079_5_23","EPH","5","23","23","ꠇꠣꠞꠘ ꠀꠟ-ꠝꠍꠤ ꠎꠦꠟꠣ ꠎꠝꠣꠔꠞ, ꠝꠣꠘꠤ ꠔꠣꠘ ꠡꠞꠤꠟꠞ ꠝꠣꠕꠣ, ꠎꠣꠝꠣꠁꠅ ꠅꠟꠣ ꠛꠃꠞ ꠝꠣꠕꠣ। ꠀꠍꠟꠦ ꠀꠟ-ꠝꠍꠤꠃ ꠅꠃ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("EP5_24","079_5_24","EPH","5","24","24","ꠀꠞ ꠎꠝꠣꠔ ꠎꠦꠟꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠀꠍꠦ, ꠅꠃꠟꠣ ꠛꠃ ꠅꠇꠟꠅ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠎꠣꠝꠣꠁꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠞꠅꠀ ꠃꠌꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("EP5_25","079_5_25","EPH","5","25","25","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠎꠣꠝꠣꠁ ꠅꠁꠍ, ꠢꠥꠘꠅ, ꠀꠟ-ꠝꠍꠤꠄ ꠎꠦꠟꠣ ꠎꠝꠣꠔꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠍꠂꠘ, ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠅ ꠎꠣꠞꠎꠤꠞ ꠛꠃꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ। ꠔꠣꠁꠘ ꠔ ꠎꠝꠣꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("EP5_26","079_5_26","EPH","5","26","26","ꠔꠣꠘ ꠈꠤꠀꠟ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠎꠝꠣꠔꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠘ ꠇꠣꠟꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠝꠣꠘꠡꠞꠦ ꠔꠞꠤꠇꠣꠞ ꠉꠥꠍꠟ ꠇꠞꠣꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("EP5_27","079_5_27","EPH","5","27","27","ꠘꠥꠞꠞ ꠝꠢꠤꠝꠣꠄ ꠘꠤꠎꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠣ। ꠅꠃ ꠡꠝꠄ ꠎꠝꠣꠔꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠇꠟꠋꠇꠞ ꠖꠣꠉ, ꠈꠥꠔ ꠛꠣ ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠞꠁꠔ ꠘꠣꠄ, ꠁꠔꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠀꠞ ꠘꠤꠈꠥꠔ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("EP5_28","079_5_28","EPH","5","28","28","ꠄꠞꠟꠣꠉꠤ ꠎꠣꠝꠣꠁꠄ ꠔꠣꠞ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞꠦ ꠎꠦꠟꠣ ꠝꠣꠄꠀ ꠇꠞꠦ, ꠑꠤꠇ ꠔꠣꠞ ꠛꠃꠞꠦꠅ ꠅꠃꠟꠣ ꠝꠣꠄꠀ ꠇꠞꠣ ꠚꠞꠎ। ꠘꠤꠎꠞ ꠛꠃꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠣꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("EP5_29","079_5_29","EPH","5","29","29","ꠇꠦꠃ ꠔ ꠇꠥꠘꠥ ꠡꠝꠄ ꠔꠣꠞ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ ꠘꠣ, ꠢꠇꠟꠦꠃ ꠎꠣꠞꠎꠤꠞ ꠡꠞꠤꠟꠞ ꠜꠞꠘ-ꠙꠥꠡꠘ ꠇꠞꠦ। ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠀꠟ-ꠝꠍꠤꠄꠅ ꠔꠣꠘ ꠎꠝꠣꠔꠞ ꠜꠞꠘ-ꠙꠥꠡꠘ ꠎꠥꠉꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("EP5_30","079_5_30","EPH","5","30","30","ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠔꠣꠘ ꠡꠞꠤꠟꠞ ꠅꠋꠉ। ");
INSERT INTO syls_vpl VALUES ("EP5_31","079_5_31","EPH","5","31","31","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠄꠞꠟꠣꠉꠤꠃ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠍꠣꠠꠤꠀ ꠛꠃꠞ ꠟꠉꠦ ꠕꠣꠇꠛꠣ, ꠔꠣꠞꠣ ꠖꠥꠁꠅꠎꠘ ꠄꠇ ꠡꠞꠤꠟ ꠅꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("EP5_32","079_5_32","EPH","5","32","32","ꠁꠈꠣꠘ ꠅꠁꠟ ꠛꠃꠔ ꠛꠠ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞ, ꠀꠍꠟꠦ ꠀꠝꠤ ꠔ ꠀꠟ-ꠝꠍꠤ ꠀꠞ ꠔꠣꠘ ꠎꠝꠣꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("EP5_33","079_5_33","EPH","5","33","33","ꠎꠣꠁ ꠅꠃꠇ, ꠔꠥꠝꠞꠣ ꠢꠇꠟꠦꠃ ꠎꠣꠞꠎꠤꠞ ꠛꠃꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠤꠅ, ꠀꠞ ꠛꠃ ꠅꠇꠟꠦꠅ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠝꠣꠁꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("EP6_1","079_6_1","EPH","6","1","1","ꠅ ꠀꠅꠟꠣꠖ ꠅꠇꠟ, ꠝꠣꠟꠤꠇꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞ ꠝꠣ-ꠛꠣꠚꠞ ꠇꠕꠣꠝꠔ ꠌꠟꠤꠅ, ꠀꠞ ꠅꠟꠣ ꠌꠟꠣꠐꠣꠃ ꠔ ꠃꠌꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("EP6_2","079_6_2","EPH","6","2","2","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠙꠄꠟꠣ ꠢꠥꠇꠥꠝ, ꠎꠦ ꠢꠥꠇꠥꠝꠞ ꠟꠉꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞꠞ ꠅꠀꠖꠣ ꠀꠍꠦ, ꠁꠐꠣ ꠅꠁꠟ, “ꠔꠥꠝꠣꠞ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("EP6_3","079_6_3","EPH","6","3","3","ꠔꠦꠃ ꠔꠥꠝꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠛ, ꠀꠞ ꠁ ꠖꠥꠘꠤꠀꠔ ꠔꠥꠝꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠛꠣꠠꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("EP6_4","079_6_4","EPH","6","4","4","ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠛꠣꠚ ꠅꠁꠍ, ꠔꠥꠝꠞꠣꠅ ꠘꠤꠎꠞ ꠀꠅꠟꠣꠖꠞꠦ ꠍꠣꠔꠣꠁꠅ ꠘꠣ, ꠛꠞꠋ ꠝꠣꠟꠤꠇꠞ ꠔꠣꠟꠤꠝ ꠀꠞ ꠡ꠆ꠞꠤꠋꠈꠟꠣꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠞꠣꠞꠦ ꠝꠣꠘꠥꠡ ꠛꠣꠘꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("EP6_5","079_6_5","EPH","6","5","5","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠉꠥꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠦꠟꠣ ꠛꠣꠁꠖ꠆ꠖ, ꠅꠃꠟꠣ ꠒꠞ ꠀꠞ ꠔꠣꠎꠤꠝꠦ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠉꠔꠞ ꠝꠥꠘꠤꠛ ꠅꠇꠟꠞ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EP6_6","079_6_6","EPH","6","6","6","ꠈꠣꠟꠤ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠝꠥꠘꠤꠛꠞ ꠍꠣꠝꠘꠦ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠅ ꠘꠣ, ꠛꠞꠋ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠥꠟꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠞꠣꠄ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠘꠤꠛꠞ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EP6_7","079_6_7","EPH","6","7","7","ꠔꠥꠝꠞꠣ ꠁꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ ꠎꠦ, ꠔꠥꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣꠄ, ꠛꠞꠋ ꠀꠍꠝꠣꠘꠤ ꠝꠣꠟꠤꠇꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣꠄ ꠝꠘꠅ ꠇꠞꠤꠀ, ꠎꠉꠔꠞ ꠝꠥꠘꠤꠛꠞ ꠈꠦꠎꠝꠔꠅ ꠈꠤꠀꠟꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("EP6_8","079_6_8","EPH","6","8","8","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠦ ꠎꠣꠞꠎꠤꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛ, ꠢꠦ ꠉꠥꠟꠣꠝ ꠅꠃꠇ ꠛꠣ ꠀꠎꠣꠖ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("EP6_9","079_6_9","EPH","6","9","9","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠝꠥꠘꠤꠛ, ꠔꠥꠝꠞꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠟꠉꠦ ꠅꠃꠟꠣ ꠜꠣꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠅ। ꠔꠣꠞꠣꠞꠦ ꠒꠞ ꠖꠦꠈꠣꠘꠤ ꠛꠣꠖ ꠖꠦꠅ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠔꠣꠞꠣ ꠛꠣ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞꠃ ꠝꠣꠟꠤꠇ ꠄꠇꠎꠘ, ꠔꠣꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠀꠍꠂꠘ; ꠔꠣꠘ ꠘꠎꠞꠅ ꠢꠇꠟꠃ ꠡꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("EP6_10","079_6_10","EPH","6","10","10","ꠢꠦꠡ-ꠝꠦꠡ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠀꠍꠝꠣꠘꠤ ꠝꠣꠟꠤꠇꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠞꠁꠀ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠛꠟꠀꠟꠣ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("EP6_11","079_6_11","EPH","6","11","11","ꠎꠥꠖ꠆ꠖꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠀꠔꠤꠀꠞ ꠟꠣꠉꠣꠅ, ꠔꠦꠃ ꠁꠛꠟꠤꠍꠞ ꠢꠇꠟ ꠍꠟ-ꠌꠔꠥꠞꠤꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠝꠎꠛꠥꠔ ꠅꠁꠀ ꠃꠛꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EP6_12","079_6_12","EPH","6","12","12","ꠀꠝꠞꠣꠞ ꠅꠃ ꠎꠥꠖ꠆ꠖ ꠔ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠘꠣꠄ, ꠁꠔꠣ ꠅꠁꠟ ꠀꠘ꠆ꠖꠣꠁꠞ ꠎꠉꠔꠞ ꠢꠇꠟ ꠞꠣꠎꠣ ꠀꠞ ꠔꠣꠞ ꠈꠦꠝꠔꠣꠀꠟꠣ ꠅꠇꠟꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ, ꠀꠘ꠆ꠖꠣꠁꠞ ꠎꠉꠔꠞ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠛꠖ ꠞꠥꠢꠥ ꠅꠇꠟꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ, ꠀꠞ ꠀꠍꠝꠣꠘꠞ ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘ ꠖꠟꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ। ");
INSERT INTO syls_vpl VALUES ("EP6_13","079_6_13","EPH","6","13","13","ꠔꠦ ꠅꠃ ꠎꠥꠖ꠆ꠖꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠀꠔꠤꠀꠞ ꠚꠤꠘ꠆ꠖꠤꠟꠣꠅ, ꠎꠣꠔꠦ ꠁꠛꠟꠤꠍꠦ ꠎꠦꠛꠟꠣ ꠢꠣꠝꠟꠣ ꠇꠞꠛ ꠅꠃ ꠡꠝꠄ ꠝꠎꠛꠥꠔ ꠅꠁꠀ ꠃꠛꠣꠁꠔꠣꠄ ꠙꠣꠞ, ꠀꠞ ꠢꠦꠡ-ꠝꠦꠡ ꠕꠤꠞ ꠞꠁꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("EP6_14","079_6_14","EPH","6","14","14","ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠤꠇꠔꠤꠞ ꠛꠦꠟꠐ ꠇꠝꠞꠅ ꠛꠣꠘ꠆ꠖꠅ, ꠀꠞ ꠛꠥꠇ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠀꠝꠟ ꠖꠤꠀ ꠛꠥꠇ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠅ, ");
INSERT INTO syls_vpl VALUES ("EP6_15","079_6_15","EPH","6","15","15","ꠍꠤꠙꠣꠁ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠖꠥꠁꠅ ꠙꠣꠅ-ꠅ ꠎꠥꠔꠣ ꠟꠣꠉꠣꠅ, ꠎꠣꠔꠦ ꠡꠣꠘ꠆ꠔꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠕꠣꠇꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("EP6_16","079_6_16","EPH","6","16","16","ꠀꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠘꠤꠎꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠦ ꠓꠣꠟꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠦ, ꠅꠃꠟꠣ ꠢꠇꠟ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘꠞ ꠓꠣꠟꠣ ꠀꠔꠅ ꠟꠅ, ꠅꠃ ꠓꠣꠟꠣ ꠖꠤꠀ ꠁꠛꠟꠤꠍꠞ ꠢꠇꠟ ꠎꠣꠟꠣꠁꠟ ꠔꠤꠞ ꠘꠤꠜꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("EP6_17","079_6_17","EPH","6","17","17","ꠝꠣꠕꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠘꠣꠎꠣꠔ ꠍꠤꠙꠣꠁꠞ ꠇꠦꠙꠞ ꠟꠣꠈꠣꠘ ꠚꠤꠘ꠆ꠖꠤꠟꠣꠅ। ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠔꠟꠥꠀꠞ ꠝꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠗꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("EP6_18","079_6_18","EPH","6","18","18","ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠅ। ꠄꠞꠟꠣꠉꠤ ꠢꠎꠣꠉ ꠞꠁꠀ ꠢꠇꠟ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠡꠛ ꠡꠝꠄ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠣꠔ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("EP6_19","079_6_19","EPH","6","19","19","ꠀꠝꠣꠞ ꠟꠣꠉꠤꠅ ꠖꠥꠀ ꠇꠞꠤꠅ, ꠀꠝꠤ ꠇꠕꠣ ꠝꠣꠔꠣꠞ ꠛꠣꠟꠣ ꠎꠣꠘꠥ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠛꠥꠟꠤ ꠎꠥꠉꠣꠁ ꠖꠦꠁꠘ, ꠎꠣꠔꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠡꠝꠄ ꠀꠝꠤ ꠡꠣꠅꠡ ꠈꠣꠐꠣꠁꠀ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠀꠍꠟ ꠛꠣꠔꠥꠘꠤ ꠜꠦꠖ ꠝꠣꠘꠡꠞꠦ ꠛꠥꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("EP6_20","079_6_20","EPH","6","20","20","ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤ ꠟꠥꠀꠞ ꠌꠦꠁꠘꠖꠤ ꠛꠣꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦꠅ ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠁꠛ ꠢꠤꠡꠣꠛꠦ ꠇꠣꠝ ꠇꠞꠞꠣꠝ। ꠔꠦ ꠎꠦꠟꠞ ꠝꠣꠎꠦ ꠞꠁꠀ ꠎꠦꠟꠣꠈꠣꠘ ꠡꠣꠅꠡ ꠈꠣꠐꠣꠁꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠖꠥꠀ ꠇꠞꠤꠅ, ꠀꠝꠤ ꠎꠣꠔꠦ ꠅꠟꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("EP6_21","079_6_21","EPH","6","21","21","ꠀꠝꠣꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠇꠤꠟꠣꠈꠣꠘ ꠀꠞ ꠀꠝꠣꠞ ꠖꠤꠘ-ꠇꠣꠟ ꠇꠤꠟꠣ ꠎꠣꠞ, ꠁꠔꠣ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ ꠔꠥꠈꠤꠇ ꠜꠣꠁꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠥꠘꠛꠣꠄ। ꠄꠁꠘ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠈꠦꠎꠝꠔꠇꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("EP6_22","079_6_22","EPH","6","22","22","ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠝꠥꠈ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞ ꠈꠛꠞꠣ-ꠈꠛꠞ ꠢꠥꠘꠛꠣꠄ, ꠔꠣꠁꠘ ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠔꠡꠣꠢ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("EP6_23","079_6_23","EPH","6","23","23","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ, ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠅꠇꠟꠞꠦ ꠡꠣꠘ꠆ꠔꠤ ꠀꠞ ꠁꠝꠣꠘꠤ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠦ ꠞꠣꠈꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("EP6_24","079_6_24","EPH","6","24","24","ꠀꠝꠞꠣꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠎꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠈꠣꠐꠤ ꠝꠢꠛ꠆ꠛꠔ ꠀꠍꠦ, ꠄꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠘꠣꠎꠤꠟ ꠅꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("PP1_1","080_1_1","PHP","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ ꠀꠞ ꠔꠤꠝꠕꠤ ꠅꠁꠟꠣꠝ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠥꠟꠣꠝ। ꠅꠃ ꠚꠤꠟꠤꠙꠤ ꠐꠣꠃꠘꠅ ꠛꠡꠔ ꠇꠞꠞꠣ, ꠎꠦ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠂꠘ ꠄꠞꠣꠞꠦ, ꠄꠞꠣꠞ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟꠞꠦ ꠀꠞ ꠈꠣꠖꠤꠝꠖꠣꠞ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PP1_2","080_1_2","PHP","1","2","2","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠘꠣꠎꠤꠟ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PP1_3","080_1_3","PHP","1","3","3","ꠔꠥꠝꠞꠣꠞ ꠇꠕꠣ ꠎꠔꠛꠣꠞꠃ ꠀꠝꠣꠞ ꠁꠀꠖ ꠅꠄ, ꠅꠔꠛꠣꠞꠃ ꠀꠝꠤ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PP1_4","080_1_4","PHP","1","4","4","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤ, ꠀꠝꠣꠞ ꠝꠘꠅ ꠈꠥꠛ ꠈꠥꠡꠤ ꠟꠁꠀ ꠖꠥꠀ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PP1_5","080_1_5","PHP","1","5","5","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔ ꠔꠥꠝꠞꠣ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PP1_6","080_1_6","PHP","1","6","6","ꠀꠝꠤ ꠄꠇꠤꠘ ꠇꠞꠤ, ꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠅꠃ ꠘꠦꠇ ꠇꠣꠝ ꠡꠥꠞꠥ ꠇꠞꠍꠂꠘ, ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠅꠃ ꠀꠟ꠆ꠟꠣꠄ ꠁ ꠇꠣꠝ ꠙꠥꠞꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PP1_7","080_1_7","PHP","1","7","7","ꠔꠥꠝꠞꠣ ꠔ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠣꠞ ꠝꠘꠞ ꠜꠣꠛ ꠅꠟꠣ ꠅꠀ ꠃꠌꠤꠔ। ꠀꠝꠤ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠢꠣꠟꠔꠦ ꠛꠣ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠢꠇ ꠇꠕꠣ ꠎꠦꠘꠅꠃ ꠔꠛꠟꠤꠉ ꠇꠞꠤ ꠘꠣ ꠇꠦꠘꠦ, ꠔꠥꠝꠞꠣꠅ ꠀꠝꠣꠞ ꠟꠉꠞ ꠞꠢꠝꠔꠞ ꠜꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("PP1_8","080_1_8","PHP","1","8","8","ꠄꠇ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠘꠂꠘ, ꠀꠟ-ꠝꠍꠤꠞ ꠝꠢꠛ꠆ꠛꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠔ ꠀꠡꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("PP1_9","080_1_9","PHP","1","9","9","ꠀꠝꠤ ꠖꠥꠀ ꠇꠞꠤ, ꠔꠥꠝꠞꠣꠞ ꠝꠢꠛ꠆ꠛꠔ ꠎꠣꠘꠥ ꠇꠣꠝꠤꠟ ꠛꠤꠛꠦꠇ ꠀꠞ ꠀꠈꠟꠦ ꠖꠤꠘ ꠖꠤꠘ ꠛꠣꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("PP1_10","080_1_10","PHP","1","10","10","ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠈꠟ ꠇꠣꠐꠣꠁꠀ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠛꠦꠙꠣꠞ ꠅꠇꠟ ꠌꠤꠘꠛꠣꠄ, ꠀꠞ ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ");
INSERT INTO syls_vpl VALUES ("PP1_11","080_1_11","PHP","1","11","11","ꠔꠣꠘ ꠛꠟꠦ ꠔꠥꠝꠞꠣ ꠘꠦꠇ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠤꠀ ꠈꠣꠐꠤ ꠙꠕꠦ ꠘꠤꠈꠥꠔ ꠅꠁꠀ ꠞꠁꠛꠣꠄ। ꠔꠦꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠃꠞꠛ ꠀꠞ ꠔꠣꠞꠤꠚ ꠎꠣꠁꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PP1_12","080_1_12","PHP","1","12","12","ꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ ꠔꠥꠝꠞꠣꠅ ꠎꠣꠘ, ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠊꠐꠤꠍꠦ, ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠀꠍꠟꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠇꠣꠝ ꠀꠞꠅ ꠛꠣꠠꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PP1_13","080_1_13","PHP","1","13","13","ꠄꠞꠟꠣꠉꠤ ꠅꠘꠞ ꠞꠣꠎꠛꠣꠠꠤꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠀꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠝꠣꠘꠡꠦꠅ ꠎꠣꠘꠤꠟꠤꠍꠂꠘ, ꠀꠝꠤ ꠔ ꠈꠣꠟꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤꠃ ꠎꠦꠟ ꠈꠣꠐꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("PP1_14","080_1_14","PHP","1","14","14","ꠀꠞ ꠀꠝꠤ ꠎꠦꠟꠅ ꠢꠣꠝꠣꠘꠤꠄ ꠀꠝꠞꠣꠞ ꠛꠃꠔ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠝꠣꠟꠤꠇꠞ ꠃꠙꠞꠦ ꠀꠞꠅ ꠛꠦꠡ ꠇꠞꠤ ꠜꠞꠡꠣ ꠇꠞꠣ ꠢꠤꠇꠍꠂꠘ, ꠔꠣꠞꠣ ꠒꠞ-ꠜꠄ ꠚꠣꠃꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠡꠣꠅꠡꠤ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PP1_15","080_1_15","PHP","1","15","15","ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠇꠦꠃ ꠁꠋꠡꠣ ꠀꠞ ꠖꠟꠣꠖꠟꠤꠞ ꠘꠤꠅꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠦꠞ, ꠅꠁꠟꠦ ꠇꠦꠃ ꠇꠦꠃ ꠜꠣꠟꠣ ꠘꠤꠅꠔꠦ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("PP1_16","080_1_16","PHP","1","16","16","ꠄꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠢꠛ꠆ꠛꠔꠦꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠦꠞ। ꠔꠣꠞꠣ ꠎꠣꠘꠂꠘ, ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠙꠇ꠆ꠇꠦ ꠝꠣꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠣꠞꠦ ꠀꠐꠇ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PP1_17","080_1_17","PHP","1","17","17","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠘꠤꠎꠞ ꠚꠣꠄꠖꠣ ꠇꠣꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠦ, ꠄꠞꠣ ꠔ ꠜꠣꠟꠣ ꠘꠤꠅꠔꠦ ꠇꠣꠝ ꠇꠞꠦ ꠘꠣ। ꠔꠣꠞꠣ ꠌꠣꠄ, ꠀꠝꠤ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠞꠁ ꠀꠞ ꠀꠝꠣꠞ ꠇꠡ꠆ꠐ ꠛꠣꠠꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("PP1_18","080_1_18","PHP","1","18","18","ꠅꠁꠟꠦ ꠁꠔꠣꠄ ꠇꠤꠔꠣ ꠀꠄ ꠎꠣꠄ? ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠎꠦꠝꠘꠦꠃ ꠅꠄ ꠘꠣ ꠇꠦꠘꠦ, ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝ ꠔ ꠔꠛꠟꠤꠉ ꠅꠞ। ꠁꠔꠣ ꠗꠥꠇꠣꠛꠣꠎꠤꠞ ꠘꠤꠅꠔꠦ ꠅꠃꠇ ꠛꠣ ꠍꠢꠤ ꠘꠤꠅꠔꠦꠃ ꠅꠃꠇ। ꠀꠞ ꠅꠔꠣ ꠖꠦꠈꠤꠀꠃ ꠀꠝꠤ ꠈꠥꠡꠤ। ꠀꠝꠣꠞ ꠁ ꠈꠥꠡꠤ ꠇꠥꠘꠥꠖꠤꠘ ꠚꠥꠠꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PP1_19","080_1_19","PHP","1","19","19","ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ, ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠔꠣ ꠊꠐꠤꠍꠦ, ꠁꠔꠣꠞ ꠢꠦꠡ ꠚꠟ ꠅꠁꠟ, ꠀꠝꠤ ꠘꠤꠡ꠆ꠔꠣꠞ ꠙꠣꠁꠝꠥ। ꠔꠥꠝꠞꠣꠞ ꠖꠥꠀ ꠀꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠁꠔꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PP1_20","080_1_20","PHP","1","20","20","ꠀꠝꠣꠞ ꠈꠥꠛ ꠝꠎꠛꠥꠔ ꠄꠇꠤꠘ ꠀꠍꠦ, ꠀꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠡꠞꠝ ꠙꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠀꠝꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠀꠉꠦ ꠎꠦꠟꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠃꠞꠛ ꠎꠣꠁꠞ ꠇꠞꠍꠤ, ꠀꠝꠤ ꠝꠞꠤ ꠛꠣ ꠛꠣꠌꠤ ꠅꠈꠘꠅ ꠅꠟꠣ ꠎꠣꠁꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PP1_21","080_1_21","PHP","1","21","21","ꠇꠣꠞꠘ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠅꠁꠟꠣ ꠀꠟ-ꠝꠍꠤ ꠀꠞ ꠝꠞꠘ ꠅꠁꠟ ꠟꠣꠜ। ");
INSERT INTO syls_vpl VALUES ("PP1_22","080_1_22","PHP","1","22","22","ꠅꠁꠟꠦ ꠀꠝꠤ ꠎꠥꠖꠤ ꠛꠣꠌꠤꠀ ꠞꠁ, ꠔꠦ ꠀꠝꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠅꠁꠛ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠛꠥꠎꠞꠣꠝ ꠘꠣ, ꠀꠝꠤ ꠇꠥꠘ ꠙꠕ ꠟꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PP1_23","080_1_23","PHP","1","23","23","ꠖꠥꠁꠅ ꠙꠕꠦꠃ ꠀꠝꠣꠞꠦ ꠐꠣꠘꠦꠞ। ꠀꠝꠣꠞ ꠁꠌ꠆ꠍꠣ ꠅꠁꠟ, ꠀꠝꠤ ꠝꠞꠤꠀ ꠢꠣꠞꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠞꠁꠔꠣꠝ, ꠅꠈꠣꠘꠃ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PP1_24","080_1_24","PHP","1","24","24","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠛꠣꠌꠤꠀ ꠞꠅꠀꠈꠣꠘ ꠀꠞꠅ ꠎꠞꠥꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PP1_25","080_1_25","PHP","1","25","25","ꠀꠞ ꠅꠃ ꠝꠘꠅꠛꠟꠦ ꠀꠝꠤ ꠜꠣꠟꠣ ꠇꠞꠤ ꠎꠣꠘꠤ, ꠀꠝꠤ ꠛꠣꠌꠝꠥ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠝꠥ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠀꠞꠅ ꠝꠎꠛꠥꠔ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠈꠥꠡꠤ ꠛꠣꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("PP1_26","080_1_26","PHP","1","26","26","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠀ ꠢꠣꠞꠟꠦ, ꠀꠝꠣꠞꠦ ꠟꠁꠀ ꠔꠥꠝꠞꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠈꠥꠛ ꠈꠥꠡꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PP1_27","080_1_27","PHP","1","27","27","ꠀꠍꠟ ꠛꠦꠙꠣꠞ ꠅꠁꠟ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠇꠣꠐꠣꠅ, ꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠟꠣꠈ। ꠔꠦꠃ ꠀꠝꠤ ꠘꠤꠎꠦ ꠀꠁꠀ ꠖꠦꠈꠤ ꠛꠣ ꠖꠥꠞꠁ ꠕꠣꠇꠤ ꠢꠥꠘꠤ, ꠀꠝꠤ ꠛꠥꠎꠝꠥ, ꠔꠥꠝꠞꠣ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠤꠟꠤꠀ ꠝꠎꠛꠥꠔ ꠀꠍ। ꠀꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠝꠣꠎꠖꠤ ꠎꠦ ꠁꠝꠣꠘ ꠙꠄꠖꠣ ꠅꠄ, ꠅꠃ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠢꠇꠟꠦ ꠝꠤꠟꠤꠀ ꠄꠇ ꠖꠤꠟꠦ ꠝꠦꠘꠔ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PP1_28","080_1_28","PHP","1","28","28","ꠎꠦꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠂꠘ, ꠇꠥꠘꠥ ꠛꠦꠙꠣꠞꠦꠃ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠔꠦꠃ ꠙꠞꠝꠣꠘ ꠅꠁꠎꠤꠛ, ꠔꠣꠞꠣ ꠛꠤꠘꠣꠡꠞ ꠙꠕꠦ ꠎꠣꠁꠞꠣꠉꠤ ꠀꠞ ꠔꠥꠝꠞꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠞꠣꠄ। ꠁ ꠞꠦꠢꠣꠁ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠝꠤꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("PP1_29","080_1_29","PHP","1","29","29","ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍ ꠁꠐꠣ ꠎꠦꠟꠣ ꠞꠢꠝꠔ, ꠔꠣꠘ ꠟꠣꠉꠤ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠍ ꠁꠐꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠞꠢꠝꠔ। ");
INSERT INTO syls_vpl VALUES ("PP1_30","080_1_30","PHP","1","30","30","ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠡ꠆ꠐ ꠇꠞꠣꠔ ꠖꠦꠈꠍ ꠀꠞ ꠅꠈꠘꠅ ꠎꠦꠔꠣ ꠇꠡ꠆ꠐꠞ ꠇꠕꠣ ꠢꠥꠘꠞꠣꠄ, ꠔꠥꠝꠞꠣꠅ ꠔ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠡ꠆ꠐꠞ ꠝꠣꠎꠦ ꠙꠠꠤꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("PP2_1","080_2_1","PHP","2","1","1","ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠦ ꠎꠦꠛꠟꠣ ꠜꠞꠡꠣ ꠝꠤꠟꠦ, ꠔꠣꠘ ꠝꠢꠛ꠆ꠛꠔꠦ ꠎꠦꠛꠟꠣ ꠡꠣꠘ꠆ꠔꠤ ꠝꠤꠟꠦ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠦꠛꠟꠣ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠜꠣꠟꠣ ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠀꠍꠦ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠦꠛꠟꠣ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("PP2_2","080_2_2","PHP","2","2","2","ꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠜꠤꠔꠞꠞ ꠈꠥꠡꠤꠈꠣꠘ ꠙꠥꠞꠣꠁꠟꠣꠅ। ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠄꠇ ꠝꠘꠦ ꠌꠟꠅ, ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠄꠇ ꠅꠅ, ꠀꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PP2_3","080_2_3","PHP","2","3","3","ꠘꠤꠎꠞ ꠟꠣꠜꠞ ꠀꠡꠣ ꠛꠣ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠘꠔ ꠅꠁꠀ ꠘꠤꠎꠞ ꠌꠣꠁꠔꠦ ꠅꠁꠘ꠆ꠘꠞꠦ ꠛꠦꠡꠤ ꠖꠣꠝ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("PP2_4","080_2_4","PHP","2","4","4","ꠈꠣꠟꠤ ꠘꠤꠎꠞ ꠡ꠆ꠛꠣꠞꠕꠞ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠙꠞꠞ ꠇꠕꠣꠅ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("PP2_5","080_2_5","PHP","2","5","5","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠘ ꠎꠦꠟꠣꠈꠣꠘ ꠀꠍꠤꠟ, ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠅꠟꠣꠈꠣꠘ ꠛꠣꠘꠣꠁꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PP2_6","080_2_6","PHP","2","6","6","ꠔꠣꠁꠘ ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠁ ꠍꠥꠞꠔꠦ ꠞꠁꠟꠦꠅ, ꠀꠟ꠆ꠟꠣꠁ ꠡꠤꠋꠢꠣꠡꠘ ꠗꠞꠤꠀ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠟꠣꠟꠌꠤ ꠀꠍꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PP2_7","080_2_7","PHP","2","7","7","ꠛꠞꠋ ꠉꠥꠟꠣꠝ ꠛꠘꠤꠀ ꠝꠣꠘꠥꠡ ꠢꠤꠡꠣꠛꠦ ꠎꠘꠝ ꠟꠁꠀ ꠘꠤꠎꠞꠦ ꠢꠥꠞꠥ ꠛꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PP2_8","080_2_8","PHP","2","8","8","ꠔꠣꠁꠘ ꠝꠣꠘꠥꠡ ꠍꠥꠞꠔꠦ ꠞꠁꠀ ꠝꠃꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠞ ꠝꠃꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠀ ꠘꠤꠎꠞꠦ ꠘꠔ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PP2_9","080_2_9","PHP","2","9","9","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠃꠑꠣꠁꠟꠣ ꠀꠞ ꠅꠟꠣ ꠁꠎ꠆ꠎꠔꠤ ꠄꠇ ꠘꠣꠝ ꠖꠤꠟꠣ, ꠎꠦ ꠘꠣꠝ ꠢꠇꠟ ꠕꠣꠇꠤ ꠡꠦꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PP2_10","080_2_10","PHP","2","10","10","ꠎꠣꠔꠦ ꠅꠃ ꠘꠣꠝꠞ ꠉꠥꠘꠦ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠀꠞ ꠙꠣꠔꠣꠟꠞ ꠔꠣꠝꠣꠝ ꠎꠣꠘꠖꠣꠞ ꠁꠍꠣꠞ ꠍꠣꠝꠘꠦ ꠘꠔ ꠅꠁꠘ, ");
INSERT INTO syls_vpl VALUES ("PP2_11","080_2_11","PHP","2","11","11","ꠀꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠃꠞꠛꠞ ꠟꠣꠉꠤ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠂꠘ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠃ ꠝꠣꠟꠤꠇ। ");
INSERT INTO syls_vpl VALUES ("PP2_12","080_2_12","PHP","2","12","12","ꠅ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠔ ꠢꠣꠝꠦꠡꠣꠃ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠀꠁꠞꠣꠄ। ꠔꠦ ꠀꠝꠤ ꠍꠣꠝꠘꠦ ꠕꠣꠇꠟꠦ ꠎꠦꠟꠣ ꠝꠣꠘꠅ, ꠅꠈꠘ ꠀꠝꠣꠞ ꠀꠚꠞꠈꠦꠅ ꠅꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠒꠞ-ꠈꠚꠦ ꠘꠦꠇ ꠀꠝꠟ ꠇꠞꠅ। ꠅꠃ ꠀꠝꠟꠞ ꠝꠣꠎꠖꠤ ꠖꠦꠈꠣꠅ, ꠔꠥꠝꠞꠣ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠟꠤꠍ। ");
INSERT INTO syls_vpl VALUES ("PP2_13","080_2_13","PHP","2","13","13","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠅꠟꠣ ꠄꠇ ꠜꠣꠛ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠀꠝꠟ ꠇꠞꠟꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ, ꠅꠃ ꠀꠝꠟ ꠇꠞꠣꠞ ꠘꠤꠅꠔ ꠀꠞ ꠔꠣꠇ꠆ꠇꠔꠅ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PP2_14","080_2_14","PHP","2","14","14","ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠛꠣ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠘꠣ ꠇꠞꠤꠀ ꠢꠇꠟ ꠇꠣꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PP2_15","080_2_15","PHP","2","15","16","ꠎꠣꠔꠦ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠙꠞꠦꠎꠉꠣꠞ ꠀꠞ ꠘꠤꠈꠥꠔ ꠛꠘ, ꠀꠞ ꠁ ꠎꠝꠣꠘꠣꠞ ꠈꠛꠤꠍ ꠘꠣꠚꠞꠝꠣꠘ ꠡꠝꠣꠎꠞ ꠝꠣꠎꠦꠅ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠞꠅ। ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀ, ꠅꠃ ꠖꠥꠘꠤꠀꠔꠃ ꠔꠥꠝꠞꠣ ꠀꠍꠝꠣꠘꠞ ꠌꠣꠘ-ꠡꠥꠞꠥꠎꠞ ꠟꠣꠈꠣꠘ ꠌꠇꠌꠇꠣ ꠛꠘꠤꠎꠣꠅ। ꠔꠦꠃ ꠀꠟ-ꠝꠍꠤ ꠎꠦꠛꠟꠣ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ, ꠢꠃ ꠖꠤꠘ ꠀꠝꠤ ꠛꠥꠇ ꠚꠥꠟꠣꠁꠀ ꠇꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ, ꠀꠝꠣꠞ ꠅꠃ ꠝꠦꠘꠔ ꠀꠞ ꠀꠐꠘꠤ-ꠈꠣꠐꠘꠤ ꠛꠦꠇꠣꠝꠣ ꠉꠦꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PP2_17","080_2_17","PHP","2","17","17","ꠢꠥꠘꠅ, ꠎꠦ ꠁꠝꠣꠘꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠞꠣꠄ, ꠄꠞ ꠃꠙꠞꠦ ꠎꠥꠖꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠟꠃꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠓꠣꠟꠤ ꠖꠦꠅꠀ ꠅꠄ, ꠔꠣ-ꠅ ꠀꠝꠤ ꠈꠥꠡ ꠀꠍꠤ, ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠈꠥꠡꠤ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PP2_18","080_2_18","PHP","2","18","18","ꠑꠤꠇ ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠈꠥꠡꠤ ꠅꠅ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠈꠥꠡꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PP2_19","080_2_19","PHP","2","19","19","ꠀꠝꠤ ꠀꠡꠣ ꠇꠞꠤ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠝꠞ꠆ꠎꠤ ꠅꠁꠟꠦ ꠀꠝꠤ ꠔꠤꠝꠕꠤꠞꠦ ꠈꠥꠛ ꠎꠟꠖꠤ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠝꠥ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠢꠣꠟꠔ ꠎꠣꠘꠤꠀ ꠀꠝꠤ ꠡꠣꠘ꠆ꠔꠤ ꠅꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PP2_20","080_2_20","PHP","2","20","20","ꠔꠤꠝꠕꠤꠞ ꠟꠣꠈꠣꠘ ꠁꠟꠣ ꠀꠞ ꠇꠦꠃ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠘꠣꠁ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PP2_21","080_2_21","PHP","2","21","21","ꠛꠣꠇꠤ ꠢꠇꠟꠦꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠌꠤꠘ꠆ꠔꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠗꠣꠘ꠆ꠖꠣꠄ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PP2_22","080_2_22","PHP","2","22","22","ꠅꠁꠟꠦ ꠔꠤꠝꠕꠤꠞ ꠛꠦꠙꠣꠞ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘ, ꠙꠥꠔꠦ ꠎꠦꠟꠣ ꠘꠤꠎꠞ ꠛꠣꠚꠞ ꠟꠉꠦ ꠇꠣꠝ ꠇꠞꠦ, ꠔꠣꠁꠘꠅ ꠅꠟꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠝꠦꠘꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PP2_23","080_2_23","PHP","2","23","23","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠀꠡꠣ ꠇꠞꠤꠀꠞ, ꠀꠝꠣꠞ ꠖꠡꠣ ꠇꠤꠔꠣ ꠅꠁꠛ, ꠅꠈꠣꠘ ꠎꠣꠘꠣꠞ ꠛꠣꠖꠦꠃ ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠙꠣꠑꠣꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PP2_24","080_2_24","PHP","2","24","24","ꠅꠁꠟꠦ ꠀꠝꠤ ꠝꠣꠟꠤꠇꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤ ꠇꠁꠀꠞ, ꠀꠝꠤ ꠘꠤꠎꠦꠅ ꠈꠥꠛ ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("PP2_25","080_2_25","PHP","2","25","25","ꠀꠞ ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠤꠀꠞ, ꠃꠍꠣꠁꠖꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠘꠤꠈꠣꠘ ꠈꠥꠛ ꠎꠞꠥꠞ। ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠍꠟꠣꠄ। ꠀꠝꠞꠣ ꠄꠇꠟꠉꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠤ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠎꠤꠢꠣꠖ ꠇꠞꠤ। ꠄꠁꠘ ꠀꠝꠣꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PP2_26","080_2_26","PHP","2","26","26","ꠔꠣꠁꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠔꠣ ꠌꠣꠁꠞꠣ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠛꠦꠝꠣꠞꠞ ꠈꠛꠞ ꠢꠥꠘꠣꠄ, ꠔꠣꠁꠘ ꠙꠦꠞꠦꠡꠣꠘꠤꠔ ꠙꠠꠤꠉꠦꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠙꠣꠑꠣꠁꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("PP2_27","080_2_27","PHP","2","27","27","ꠀꠍꠟꠦ ꠔꠣꠁꠘ ꠈꠥꠛ ꠛꠦꠝꠣꠞ ꠀꠍꠟꠣ, ꠛꠦꠝꠣꠞꠦ ꠔꠣꠘ ꠘꠣ-ꠛꠣꠌꠣꠞ ꠢꠣꠟꠔ ꠅꠁꠉꠦꠍꠤꠟ। ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠞꠢꠝ ꠇꠞꠍꠂꠘ। ꠈꠣꠟꠤ ꠔꠣꠘꠞꠦ ꠘꠣꠄ, ꠔꠣꠁꠘ ꠛꠣꠌꠤ ꠎꠣꠅꠀꠄ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦꠅ ꠛꠃꠔ ꠛꠠ ꠞꠢꠝ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠀꠝꠤ ꠄꠇ ꠇꠡ꠆ꠐꠞ ꠃꠙꠞꠦ ꠀꠞ ꠇꠥꠘꠥ ꠇꠡ꠆ꠐ ꠘꠣ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PP2_28","080_2_28","PHP","2","28","28","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠔꠣꠘꠞꠦ ꠙꠣꠑꠣꠁꠀꠞ, ꠎꠣꠔꠦ ꠔꠣꠘꠞꠦ ꠙꠣꠁꠀ ꠔꠥꠝꠞꠣꠅ ꠈꠥꠡꠤ ꠅꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠝꠘꠞ ꠌꠤꠘ꠆ꠔꠣꠅ ꠢꠞꠤ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PP2_29","080_2_29","PHP","2","29","29","ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠢꠤꠡꠣꠛꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠈꠥꠡꠤ ꠅꠁꠀ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠤꠅ, ꠀꠞ ꠄꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("PP2_30","080_2_30","PHP","2","30","30","ꠀꠟ-ꠝꠍꠤꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠉꠤꠀ ꠔꠣꠁꠘ ꠝꠞꠣꠞ ꠙꠕꠤ ꠅꠁꠉꠦꠍꠟꠣ। ꠀꠝꠣꠞ ꠍꠣꠝꠘꠦ ꠘꠣ ꠕꠣꠇꠣꠄ ꠔꠥꠝꠞꠣ ꠎꠦ ꠇꠣꠝ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠍ ꠘꠣ, ꠅꠃ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠖꠤꠔꠦꠅ ꠞꠣꠎꠤ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("PP3_1","080_3_1","PHP","3","1","1","ꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠢꠦꠡ-ꠝꠦꠡ ꠇꠁꠞꠣꠝ, ꠝꠣꠟꠤꠇꠞ ꠘꠣꠝꠦ ꠈꠥꠡꠤ ꠇꠞꠅ। ꠄꠇ ꠛꠦꠙꠣꠞ ꠟꠁꠀ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠟꠦꠈꠔꠦ ꠀꠝꠣꠞ ꠇꠥꠘꠥ ꠇꠡ꠆ꠐ ꠅꠞ ꠘꠣ, ꠔꠥꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠁꠔꠣ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PP3_2","080_3_2","PHP","3","2","2","ꠢꠥꠘꠅ, ꠢꠃ ꠇꠥꠇꠞꠞ ꠙꠣꠟ ꠕꠣꠇꠤ, ꠝꠣꠘꠤ ꠘꠣꠚꠞꠝꠣꠘ ꠖꠟꠞ ꠖꠣꠖꠤꠞ ꠝꠥꠍꠟꠣ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ। ꠁꠔꠣꠄ ꠔ ꠔꠣꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠇꠣꠐꠣ-ꠌꠤꠞꠣꠞ ꠃꠙꠞꠦꠃ ꠜꠞꠡꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PP3_3","080_3_3","PHP","3","3","3","ꠀꠍꠟꠦ ꠀꠝꠞꠣꠃ ꠅꠁꠟꠣꠝ ꠈꠣꠐꠤ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠞꠣꠁꠟ ꠝꠣꠘꠥꠡ, ꠀꠝꠞꠣ ꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠉꠃꠞꠛ ꠇꠞꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠤ, ꠡꠞꠤꠟꠤ ꠇꠥꠘꠥ ꠄꠛꠣꠖꠔꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PP3_4","080_3_4","PHP","3","4","4","ꠀꠍꠟꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠝꠘꠅ ꠇꠞꠦ, ꠘꠤꠎꠞ ꠡꠞꠤꠟꠤ ꠄꠛꠣꠖꠔꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠣꠞ ꠎꠥꠇ꠆ꠔꠤ ꠀꠍꠦ, ꠔꠦ ꠢꠦ ꠛꠥꠎꠤꠟꠣꠃꠇ, ꠔꠣꠞ ꠌꠣꠁꠔꠦ ꠀꠝꠣꠞ ꠀꠞꠅ ꠛꠦꠡꠤ ꠎꠥꠇ꠆ꠔꠤ ꠀꠍꠦ। ꠀꠝꠤꠅ ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("PP3_5","080_3_5","PHP","3","5","5","ꠎꠘꠝꠞ ꠀꠐ ꠖꠤꠘꠞ ꠖꠤꠘꠃ ꠀꠝꠣꠞ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟ ꠅꠁꠍꠤꠟ। ꠀꠝꠤ ꠄꠇꠎꠘ ꠈꠣꠐꠤ ꠁꠛꠞꠣꠘꠤ, ꠀꠝꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠦ ꠔ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠉꠥꠡ꠆ꠐꠤꠔ। ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠡꠞꠤꠅꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠔ ꠚꠞꠤꠡꠤ ꠎꠝꠣꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("PP3_6","080_3_6","PHP","3","6","6","ꠡꠞꠤꠅꠔ ꠝꠣꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠈꠥꠔ ꠛꠣꠞ ꠇꠞꠔ ꠙꠣꠞꠍꠦ ꠘꠣ। ꠗꠞ꠆ꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠇꠠꠣ, ꠀꠟ-ꠝꠍꠤꠞ ꠎꠝꠣꠔꠞ ꠃꠙꠞꠦꠅ ꠀꠝꠤ ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PP3_7","080_3_7","PHP","3","7","7","ꠅꠁꠟꠦ ꠅꠃ ꠀꠝꠟ ꠇꠞꠣꠄ ꠀꠝꠣꠞ ꠎꠔ ꠚꠣꠄꠖꠣ ꠅꠁꠍꠤꠟ, ꠅꠈꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠈꠦꠔꠤ ꠝꠘꠅ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PP3_8","080_3_8","PHP","3","8","8","ꠀꠍꠟꠦ ꠀꠝꠤ ꠎꠣꠞ ꠟꠣꠉꠤ ꠁ ꠈꠦꠔꠤ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤꠀꠞ, ꠄꠁꠘꠃ ꠀꠝꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ। ꠔꠣꠘꠞꠦ ꠎꠣꠘꠣꠞ ꠝꠣꠎꠦꠃ ꠢꠇꠟ ꠕꠣꠇꠤ ꠛꠠ ꠚꠣꠄꠖꠣ, ꠔꠣꠘ ꠔꠥꠟꠘꠣꠄ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦꠃ ꠀꠝꠤ ꠈꠦꠔꠤ ꠝꠘꠅ ꠇꠞꠤ। ꠀꠝꠤ ꠎꠣꠔꠦ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠙꠣꠁ, ꠀꠞ ꠀꠝꠣꠞꠦ ꠎꠣꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠄꠇꠈꠣꠘꠅ ꠝꠤꠟꠣꠁꠟ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠅꠃ ꠘꠤꠅꠔꠦꠃ ꠀꠝꠤ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠝꠄꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠢꠞꠣꠁꠀ ꠚꠣꠟꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("PP3_9","080_3_9","PHP","3","9","9","ꠔꠦ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠣꠄ ꠀꠝꠤ ꠎꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘꠤꠉꠦꠍꠤ, ꠁꠈꠣꠘ ꠘꠣꠄ, ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠍꠂꠘ। ꠁ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣ ꠕꠣꠇꠤꠃ ꠝꠤꠟꠦ, ꠁꠐꠣ ꠔ ꠁꠝꠣꠘꠞ ꠃꠙꠞꠦ ꠘꠤꠞꠜꠞ ꠇꠞꠦ। ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠝꠤꠟꠣꠞ ꠛꠣꠖꠦꠃ ꠀꠝꠣꠞ ꠅꠃ ꠢꠣꠟꠔ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PP3_10","080_3_10","PHP","3","10","10","ꠔꠦ ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠌꠤꠘꠔꠣꠝ ꠌꠣꠁ, ꠎꠦ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠔꠣꠘꠞꠦ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠅꠃ ꠛꠟꠞꠦꠅ ꠌꠤꠘꠔꠣꠝ ꠌꠣꠁ। ꠀꠝꠤ ꠔꠣꠘ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠜꠣꠉꠤ ꠅꠁꠔꠣꠝ ꠌꠣꠁ, ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠟꠣ, ꠀꠝꠤꠅ ꠅꠃ ꠝꠃꠔꠅ ꠡꠞꠤꠇ ꠅꠁꠔꠣꠝ ꠌꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("PP3_11","080_3_11","PHP","3","11","11","ꠀꠞ ꠎꠦꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠝꠞꠘ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠀꠔꠅ ꠡꠞꠤꠇ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("PP3_12","080_3_12","PHP","3","12","12","ꠔꠦ ꠀꠝꠤ ꠎꠦꠔꠣ ꠙꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠁꠔꠣ ꠎꠦ ꠅꠈꠘꠃ ꠙꠣꠁꠟꠤꠍꠤ, ꠛꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠀꠛ ꠅꠁꠉꠦꠍꠤ ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠎꠦ ꠘꠤꠅꠔꠦ ꠀꠝꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠘꠤꠅꠔ ꠙꠥꠞꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠖꠃꠠꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PP3_13","080_3_13","PHP","3","13","13","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠞꠣꠝ ꠘꠣ, ꠀꠝꠤ ꠁꠔꠣꠞ ꠟꠣꠉꠣꠟ ꠙꠣꠁꠟꠤꠍꠤ। ꠅꠁꠟꠦ ꠈꠞꠞ ꠢꠇꠟꠔꠣ ꠚꠣꠟꠣꠁꠀ ꠀꠝꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠍꠣꠝꠘꠦꠖꠤ ꠖꠃꠠꠣꠁꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("PP3_14","080_3_14","PHP","3","14","14","ꠖꠃꠠꠣꠁ ꠖꠃꠠꠣꠁ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤꠀꠞ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠞꠤꠀꠄ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠎꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠖꠣꠅꠔ ꠀꠍꠦ, ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠅꠃ ꠖꠣꠅꠔꠅ ꠢꠣꠝꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PP3_15","080_3_15","PHP","3","15","15","ꠄꠞꠟꠣꠉꠤ ꠇꠁꠞꠣꠝ, ꠀꠝꠞꠣ ꠎꠣꠞꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠙꠕꠦ ꠛꠃꠔ ꠀꠉꠥꠀꠁ ꠉꠦꠍꠤ, ꠀꠝꠞꠣꠞ ꠘꠤꠅꠔꠅ ꠅꠟꠣꠈꠣꠘ ꠅꠀ ꠎꠞꠥꠞ। ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠎꠥꠖꠤ ꠅꠁꠘ꠆ꠘ ꠇꠥꠘꠥ ꠘꠤꠅꠔ ꠕꠣꠇꠦ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄꠃ ꠙꠕ ꠛꠣꠔꠣꠁ ꠖꠤꠛꠣꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("PP3_16","080_3_16","PHP","3","16","16","ꠎꠣꠁ ꠅꠃꠇ, ꠀꠝꠞꠣ ꠎꠔꠈꠣꠘ ꠀꠉꠥꠀꠁꠍꠤ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠅ ꠇꠣꠐꠣꠘꠤ ꠃꠌꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("PP3_17","080_3_17","PHP","3","17","17","ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔꠣꠄ, ꠁꠔꠣ ꠔ ꠀꠝꠤ ꠢꠤꠇꠣꠁꠍꠤ। ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠌꠟꠅ, ꠀꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠎꠣꠞꠣ ꠌꠟꠦ, ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠢꠤꠇꠅ। ");
INSERT INTO syls_vpl VALUES ("PP3_18","080_3_18","PHP","3","18","18","ꠀꠝꠤ ꠔ ꠛꠃꠔ ꠛꠣꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠤ, ꠀꠞ ꠌꠈꠥꠞ ꠙꠣꠘꠤ ꠚꠣꠟꠣꠁꠀ ꠅꠈꠘꠅ ꠇꠁꠞꠣꠝ, ꠁꠟꠣꠅ ꠛꠃꠔ ꠎꠘ ꠀꠍꠦ, ꠎꠦꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛꠞ ꠖꠥꠡꠝꠘꠞ ꠟꠣꠈꠣꠘ ꠌꠟꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("PP3_19","080_3_19","PHP","3","19","19","ꠔꠣꠞꠣꠞ ꠇꠙꠣꠟꠅ ꠀꠍꠦ ꠛꠤꠘꠣꠡ। ꠔꠣꠞꠣꠞ ꠙꠦꠐꠃ ꠔꠣꠞꠣꠞ ꠀꠟ꠆ꠟꠣ। ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠣꠝ ꠟꠁꠀ ꠔꠣꠞꠣ ꠛꠠꠣꠁ ꠇꠞꠦ, ꠈꠣꠟꠤ ꠖꠥꠘꠤꠀꠞ ꠗꠣꠘ꠆ꠖꠣꠄ ꠙꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("PP3_20","080_3_20","PHP","3","20","20","ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠀꠍꠟ ꠛꠣꠠꠤ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠅ। ꠀꠝꠞꠣꠞ ꠔꠞꠣꠅꠞꠣ ꠝꠣꠟꠤꠇ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠢꠘ ꠕꠣꠇꠤ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ। ꠀꠝꠞꠣ ꠔꠣꠘ ꠟꠣꠉꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠛꠣꠞ ꠌꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PP3_21","080_3_21","PHP","3","21","21","ꠔꠣꠁꠘ ꠀꠁꠀ ꠀꠝꠞꠣꠞ ꠅꠃ ꠇꠝꠎꠥꠞ ꠇꠣꠄꠀ ꠛꠖꠟꠣꠁꠀ, ꠔꠣꠘ ꠇꠣꠄꠀꠞ ꠟꠣꠈꠣꠘ ꠈꠦꠝꠔꠣꠀꠟꠣ ꠘꠥꠞꠞ ꠇꠣꠄꠀ ꠖꠤꠛꠣ। ꠎꠦ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠔꠣꠁꠘ ꠢꠇ꠆ꠇꠟꠔꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ, ꠢꠃ ꠛꠟꠦꠃ ꠔꠣꠁꠘ ꠁꠔꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PP4_1","080_4_1","PHP","4","1","1","ꠅ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁ। ꠔꠥꠝꠞꠣꠃ ꠀꠝꠣꠞ ꠈꠥꠡꠤ, ꠀꠝꠣꠞ ꠎꠄꠅꠞ ꠝꠣꠟꠣ। ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣ ꠝꠎꠛꠥꠔ ꠅꠁꠀ ꠟꠣꠉꠤꠀ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PP4_2","080_4_2","PHP","4","2","2","ꠅ ꠀꠝꠣꠞ ꠛꠁꠘ ꠍꠣꠟꠤꠝꠣ ꠀꠞ ꠍꠣꠁꠖꠣ, ꠀꠝꠤ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠞꠣꠝ, ꠄꠇ ꠝꠣꠟꠤꠇꠞ ꠈꠦꠎꠝꠔꠅ ꠟꠣꠉꠣꠁꠟ ꠀꠍ ꠇꠞꠤ, ꠔꠥꠝꠞꠣ ꠝꠤꠟꠤ-ꠝꠤꠡꠤ ꠄꠇ ꠝꠘꠦ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("PP4_3","080_4_3","PHP","4","3","3","ꠅ ꠀꠝꠣꠞ ꠟꠉꠞ ꠀꠍꠟ ꠡꠋꠉꠤ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦꠅ ꠝꠤꠘꠔ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠤ ꠅꠃ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠤꠅ। ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠅ ꠄꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠦ ꠛꠃꠔ ꠇꠡ꠆ꠐ ꠇꠞꠍꠂꠘ। ꠇꠤꠟꠤꠝꠣꠘ ꠀꠞ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠉꠦꠅ ꠇꠡ꠆ꠐ ꠇꠞꠍꠂꠘ। ꠔꠣꠞꠣꠞ ꠘꠣꠝ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠣꠔꠣꠔ ꠟꠦꠈꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PP4_4","080_4_4","PHP","4","4","4","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠅ। ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠞꠣꠝ, ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("PP4_5","080_4_5","PHP","4","5","5","ꠔꠥꠝꠞꠣꠞ ꠘꠞꠝ ꠛꠦꠛꠢꠣꠞ ꠎꠣꠘꠥ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠌꠈꠥꠔ ꠙꠠꠦ। ꠎꠣꠘ ꠔ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠈꠥꠛ ꠎꠟꠖꠤꠃ ꠀꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PP4_6","080_4_6","PHP","4","6","6","ꠇꠥꠘꠥ ꠛꠦꠙꠣꠞꠦꠃ ꠔꠥꠝꠞꠣ ꠙꠦꠞꠦꠡꠣꠘ ꠅꠁꠅ ꠘꠣ, ꠛꠞꠋ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠅ। ꠔꠥꠝꠞꠣꠞ ꠎꠔꠔꠣ ꠌꠣꠁꠛꠣꠞ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠌꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PP4_7","080_4_7","PHP","4","7","7","ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠎꠦ ꠡꠣꠘ꠆ꠔꠤꠞ ꠇꠕꠣ ꠝꠣꠘꠡꠦ ꠌꠤꠘ꠆ꠔꠣꠅ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠅꠃ ꠡꠣꠘ꠆ꠔꠤ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠀꠞ ꠝꠘꠞꠦ ꠞꠁꠇ꠆ꠇꠣ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("PP4_8","080_4_8","PHP","4","8","8","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠤ ꠢꠦꠡ-ꠝꠦꠡ ꠇꠁꠞꠣꠝ, ꠎꠦꠔꠣ ꠢꠣꠍꠣ, ꠎꠦꠔꠣ ꠃꠙꠎꠥꠇ꠆ꠔ, ꠢꠇ, ꠈꠣꠐꠤ, ꠡꠥꠘ꠆ꠖꠞ, ꠀꠞ ꠁꠎ꠆ꠎꠔ ꠙꠣꠅꠀꠞ ꠎꠥꠇꠣ, ꠝꠣꠘꠤ ꠎꠦꠔꠣ ꠜꠣꠟꠣ ꠀꠞ ꠎꠦꠔꠣꠄ ꠔꠣꠞꠤꠚ ꠅꠄ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠈꠤꠀꠟꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("PP4_9","080_4_9","PHP","4","9","9","ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍ, ꠎꠦꠔꠣ ꠢꠥꠘꠍ, ꠎꠦꠔꠣ ꠖꠦꠈꠍ, ꠀꠞ ꠎꠦꠔꠣ ꠇꠛꠥꠟ ꠇꠞꠍ ꠅꠔꠣ ꠅꠈꠘ ꠀꠝꠟ ꠇꠞꠅ। ꠔꠦꠃ ꠡꠣꠘ꠆ꠔꠤ ꠖꠦꠅꠞꠣ ꠀꠟ꠆ꠟꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PP4_10","080_4_10","PHP","4","10","10","ꠝꠣꠟꠤꠇꠦ ꠀꠝꠣꠞ ꠈꠥꠡꠤ ꠀꠞꠅ ꠛꠣꠠꠣꠁ ꠖꠤꠟꠣ, ꠛꠃꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞꠦ ꠝꠘꠅ ꠇꠞꠞꠣꠄ। ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠔ ꠢꠣꠝꠦꠡꠣꠃ ꠔꠥꠝꠞꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠍ, ꠅꠁꠟꠦ ꠁꠔꠣ ꠖꠦꠈꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PP4_11","080_4_11","PHP","4","11","11","ꠇꠥꠘꠥ ꠅꠜꠣꠛꠅ ꠙꠠꠤꠀ ꠀꠝꠤ ꠁꠈꠣꠘ ꠇꠁꠞꠣꠝ ꠘꠣ, ꠎꠦꠇꠥꠘꠥ ꠢꠣꠟꠔꠦꠃ ꠡꠘ꠆ꠔꠥꠡ꠆ꠐ ꠞꠅꠀꠈꠣꠘ ꠀꠝꠤ ꠎꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("PP4_12","080_4_12","PHP","4","12","12","ꠅꠜꠣꠛꠤ ꠛꠣ ꠘꠛꠣꠛꠤ ꠢꠣꠟꠔꠦ, ꠃꠙꠣꠡꠤ ꠙꠦꠐꠦ ꠛꠣ ꠜꠞꠣ ꠙꠦꠐꠦ, ꠗꠘꠤ ꠛꠣ ꠉꠞꠤꠛꠤꠞ ꠝꠣꠎꠦ ꠇꠤꠟꠣ ꠡꠘ꠆ꠔꠥꠡ꠆ꠐ ꠞꠅꠀ ꠎꠣꠄ, ꠁꠔꠣ ꠔꠣꠟꠤꠝ ꠀꠝꠤ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("PP4_13","080_4_13","PHP","4","13","13","ꠀꠍꠟꠦ ꠎꠦꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠎꠥꠉꠣꠁꠀ ꠖꠦꠁꠘ, ꠔꠣꠘ ꠛꠟꠦꠃ ꠀꠝꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PP4_14","080_4_14","PHP","4","14","14","ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠇꠡ꠆ꠐꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠀ, ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("PP4_15","080_4_15","PHP","4","15","15","ꠅ ꠚꠤꠟꠤꠙꠤ ꠎꠝꠣꠔꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠔꠥꠝꠞꠣ ꠙꠄꠟꠣ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠙꠣꠅꠀꠞ ꠛꠣꠖꠦ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠖꠦꠡ ꠕꠣꠇꠤ ꠉꠦꠍꠟꠣꠝꠉꠤ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠍꠣꠠꠣ ꠀꠞ ꠇꠥꠘꠥ ꠎꠝꠣꠔꠦꠃ ꠀꠝꠣꠞ ꠟꠉꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠟꠦꠘ-ꠖꠦꠘ ꠇꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("PP4_16","080_4_16","PHP","4","16","16","ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠕꠤꠡꠟꠘꠤꠇꠤ ꠐꠣꠃꠘꠅ ꠀꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠣꠞ ꠅꠜꠣꠛꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠞꠣ ꠇꠄꠛꠣꠞ ꠡꠣꠁꠎ꠆ꠎ ꠙꠣꠑꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("PP4_17","080_4_17","PHP","4","17","17","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠖꠣꠘ-ꠖꠇ꠆ꠇꠤꠘꠣ ꠌꠣꠁꠞꠣꠝ ꠘꠣ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠟꠣ ꠄꠇ ꠚꠟ ꠀꠡꠣ ꠇꠞꠞꠣꠝ, ꠎꠦꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠀꠝꠟ-ꠘꠣꠝꠣꠔ ꠎꠝꠣ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PP4_18","080_4_18","PHP","4","18","18","ꠀꠝꠣꠞ ꠢꠇꠟ ꠙꠣꠅꠘꠣꠃ ꠀꠝꠤ ꠙꠣꠁꠟꠤꠍꠤ। ꠀꠍꠟꠦ ꠀꠝꠣꠞ ꠎꠔꠈꠣꠘ ꠎꠞꠥꠞ, ꠄꠞ ꠌꠣꠁꠔꠦꠅ ꠛꠦꠡꠤ ꠀꠍꠦ। ꠃꠍꠣꠁꠖ ꠜꠣꠁꠞ ꠀꠔ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠢꠣꠞ ꠙꠣꠁꠀ ꠅꠈꠘ ꠀꠝꠣꠞ ꠛꠃꠔ ꠅꠁꠍꠦ। ꠅꠃ ꠃꠙꠢꠣꠞ ꠔ ꠀꠟ꠆ꠟꠣꠁ ꠈꠥꠡꠛꠄ ꠀꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠛꠥꠟ ꠅꠀꠞ ꠎꠥꠇꠣ ꠇꠥꠞꠛꠣꠘꠤ। ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠁꠔꠣꠄ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("PP4_19","080_4_19","PHP","4","19","19","ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠃꠞꠛꠞ ꠗꠘ ꠢꠤꠡꠣꠛꠦ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠅꠜꠣꠛ ꠖꠥꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("PP4_20","080_4_20","PHP","4","20","20","ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠔꠣꠞꠤꠚ ꠎꠣꠞꠤ ꠞꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("PP4_21","080_4_21","PHP","4","21","21","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠟ ꠛꠘ꠆ꠖꠣꠞꠦ ꠀꠝꠣꠞ ꠍꠣꠟꠣꠝ ꠖꠤꠅ। ꠀꠝꠣꠞ ꠟꠉꠞ ꠢꠇꠟ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PP4_22","080_4_22","PHP","4","22","22","ꠀꠟ꠆ꠟꠣꠞ ꠎꠔ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠁ ꠎꠣꠉꠣꠔ ꠀꠍꠂꠘ, ꠈꠣꠍ ꠇꠞꠤ ꠛꠣꠖꠡꠣ ꠇꠂꠍꠞꠞ ꠛꠣꠠꠤꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PP4_23","080_4_23","PHP","4","23","23","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠕꠣꠇꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("CL1_1","081_1_1","COL","1","1","2","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠞ꠆ꠎꠤꠄ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤ। ꠇꠟ꠆ꠟꠍꠤ ꠐꠣꠃꠘꠞ ꠝꠣꠎꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠀꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠀꠞ ꠜꠣꠁ ꠔꠤꠝꠕꠤꠄ ꠅꠃ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠘꠣꠎꠤꠟ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("CL1_3","081_1_3","COL","1","3","4","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠣꠞ ꠇꠕꠣ ꠀꠝꠞꠣ ꠢꠥꠘꠍꠤ। ꠄꠞꠟꠣꠉꠤ ꠎꠦꠛꠟꠣꠃ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("CL1_5","081_1_5","COL","1","5","5","ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇ ꠇꠣꠟꠣꠝ ꠙꠣꠁꠍ, ꠅꠃ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠤꠀꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠄꠇ ꠀꠡꠣ ꠎꠘꠝꠤꠍꠦ। ꠅꠃ ꠀꠡꠣ ꠕꠣꠇꠤꠃ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠀꠞ ꠝꠣꠄꠀ ꠙꠄꠖꠣ ꠅꠁꠍꠦ। ꠀꠞ ꠔꠥꠝꠞꠣ ꠀꠡꠣ ꠇꠞꠞꠣꠄ ꠎꠦ ꠍꠣꠝꠣꠘ ꠙꠣꠁꠔꠣꠄ, ꠁꠔꠣ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠞꠣꠈꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL1_6","081_1_6","COL","1","6","6","ꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠤꠀ ꠜꠣꠟꠣ ꠚꠟꠀꠟꠣ ꠅꠁꠀ ꠖꠤꠘ ꠖꠤꠘ ꠛꠣꠠꠦꠞ। ꠎꠦ ꠖꠤꠘ ꠕꠘꠦ ꠔꠥꠝꠞꠣ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠢꠥꠘꠍ, ꠅꠃ ꠖꠤꠘ ꠕꠘꠦꠃ ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠜꠤꠔꠞꠦꠅ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("CL1_7","081_1_7","COL","1","7","7","ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠇꠕꠣ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠉꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠀꠛꠥ-ꠚꠣꠞꠣꠍꠞ ꠉꠦꠍꠦ ꠢꠥꠘꠍ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠢꠇ ꠈꠦꠎꠝꠔꠇꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("CL1_8","081_1_8","COL","1","8","8","ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠎꠦ ꠝꠣꠄꠀ ꠙꠄꠖꠣ ꠅꠁꠍꠦ, ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠀꠛꠥ-ꠚꠣꠞꠣꠍꠦ ꠀꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL1_9","081_1_9","COL","1","9","9","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠘꠣꠞ ꠛꠣꠖ ꠕꠣꠇꠤꠃ ꠀꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤ। ꠞꠥꠢꠣꠘꠤ ꠁꠟꠤꠝ ꠀꠞ ꠛꠥꠖ꠆ꠖꠤ ꠖꠤꠀ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠥ ꠀꠟ꠆ꠟꠣꠞ ꠝꠥꠘꠡꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠥꠎꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("CL1_10","081_1_10","COL","1","10","10","ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠅꠃ ꠖꠥꠀꠃ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠣꠔꠦ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟ ꠀꠞ ꠔꠣꠘ ꠃꠙꠎꠥꠇ꠆ꠔ ꠃꠝ꠆ꠝꠔꠞ ꠟꠣꠈꠣꠘ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠅ। ꠢꠇ ꠇꠣꠝ ꠇꠞꠤ ꠇꠞꠤ ꠚꠟꠛꠣꠘ ꠅꠅ, ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠀꠞꠅ ꠜꠣꠟꠣ ꠇꠞꠤ ꠌꠤꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("CL1_11","081_1_11","COL","1","11","11","ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠝꠢꠣ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠟ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠟꠛꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠛꠣꠟꠣ-ꠝꠍꠤꠛꠔꠅ ꠙꠠꠟꠦꠅ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠞꠁꠀ ꠍꠛꠞ ꠇꠞꠣꠞ ꠔꠚꠤꠇ ꠖꠦꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("CL1_12","081_1_12","COL","1","12","12","ꠀꠞ ꠢꠇꠟ ꠡꠝꠄ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠅ। ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠦ ꠘꠥꠞꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠎꠦ ꠅꠗꠤꠇꠣꠞ ꠙꠣꠁꠛꠣ, ꠁꠔꠣꠞ ꠜꠣꠉꠤ ꠅꠀꠞ ꠟꠣꠉꠤ ꠔ ꠔꠣꠁꠘꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠙꠎꠥꠇ꠆ꠔ ꠛꠣꠘꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL1_13","081_1_13","COL","1","13","13","ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞꠦ ꠀꠘ꠆ꠖꠣꠁꠞꠞ ꠛꠣꠖꠡꠣꠁ ꠕꠣꠇꠤ ꠃꠖ꠆ꠖꠣꠞ ꠇꠞꠤꠀ, ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠀꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL1_14","081_1_14","COL","1","14","14","ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠀꠝꠞꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠍꠤ, ꠝꠣꠘꠤ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠝꠣꠚꠤ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("CL1_15","081_1_15","COL","1","15","15","ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠃ ꠅꠁꠟꠣ, ꠛꠣꠔꠥꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠎꠣꠁꠞꠤ ꠍꠥꠞꠔ; ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠀꠉꠦ ꠔꠣꠁꠘ ꠀꠍꠟꠣ, ꠀꠞ ꠙꠄꠖꠣ ꠅꠀ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠣꠎꠦ ꠔꠣꠁꠘꠃ ꠙꠞꠗꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("CL1_16","081_1_16","COL","1","16","16","ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠝꠣꠎꠦ ꠖꠦꠈꠣ ꠀꠞ ꠀ-ꠖꠦꠈꠣ ꠎꠔꠔꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠛꠣꠖꠡꠣꠁ ꠅꠃꠇ ꠛꠣ ꠛꠣꠢꠣꠖꠥꠞꠤ, ꠡꠣꠡꠘ ꠇꠤꠛꠣ ꠈꠦꠝꠔꠣ ꠅꠃꠇ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔꠣꠘ ꠀꠔꠞ ꠙꠄꠖꠣ। ꠁꠔꠣ ꠔ ꠈꠣꠟꠤ ꠔꠣꠘ ꠟꠣꠉꠤꠃ ꠙꠄꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL1_17","081_1_17","COL","1","17","17","ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠙꠄꠟꠣ ꠔꠣꠁꠘ ꠀꠍꠟꠣ ꠀꠞ ꠔꠣꠘ ꠝꠣꠎꠖꠤꠀꠃ ꠢꠇꠟꠔꠣ ꠐꠤꠇꠤꠀ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL1_18","081_1_18","COL","1","18","18","ꠔꠣꠁꠘꠃ ꠔꠣꠘ ꠡꠞꠤꠟꠞ ꠝꠣꠕꠣ, ꠝꠣꠘꠤ ꠎꠝꠣꠔꠞ ꠝꠣꠕꠣ। ꠔꠣꠁꠘꠃ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠙꠄꠟꠣ, ꠀꠞ ꠔꠣꠁꠘꠃ ꠙꠄꠟꠣ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘꠃ ꠙꠞꠗꠣꠘ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL1_19","081_1_19","COL","1","19","19","ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠁꠟꠣ, ꠔꠣꠘ ꠀꠟ꠆ꠟꠣꠁ ꠉꠥꠘꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠘꠥ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠦ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("CL1_20","081_1_20","COL","1","20","20","ꠀꠞ ꠖꠥꠘꠤꠀꠔ ꠛꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠎꠦꠘꠅꠃ ꠅꠄ ꠘꠣ ꠇꠦꠘꠦ, ꠅꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤꠀ ꠎꠣꠘꠥ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠟꠉꠦ ꠔꠣꠘ ꠝꠤꠟꠘ ꠅꠄ। ꠔꠣꠁꠘ ꠌꠣꠁꠟꠣ, ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃꠞ ꠛꠖꠟꠣ ꠡꠣꠘ꠆ꠔꠤ ꠇꠣꠁꠝꠞ ꠝꠣꠎꠖꠤ ꠅꠃ ꠝꠤꠟꠘ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("CL1_21","081_1_21","COL","1","21","21","ꠔꠥꠝꠞꠣ ꠔ ꠄꠇ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠀꠍꠟꠣꠄ, ꠀꠞ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠖꠥꠡꠝꠘꠤ ꠜꠣꠛ ꠀꠍꠤꠟ। ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠛꠖ ꠇꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠎꠣꠁꠞ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL1_22","081_1_22","COL","1","22","22","ꠅꠁꠟꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠣꠎꠖꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠔꠣꠘ ꠟꠉꠦ ꠝꠤꠟꠘ ꠊꠐꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠘꠤꠈꠥꠔ ꠀꠞ ꠘꠤ-ꠅꠙꠞꠣꠗꠤ ꠢꠣꠟꠔꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL1_23","081_1_23","COL","1","23","23","ꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠕꠣꠇꠤ ꠎꠦ ꠘꠤꠌ꠆ꠌꠤꠔ ꠀꠡꠣ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠍ, ꠈꠣꠟꠤ ꠅꠃ ꠀꠡꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘꠦ ꠕꠤꠞ ꠞꠁꠅ, ꠁꠘ ꠕꠣꠇꠤ ꠟꠠꠤꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠔ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠅ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠈꠣꠖꠤꠝ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("CL1_24","081_1_24","COL","1","24","24","ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠣꠄ ꠈꠥꠛ ꠀꠘꠘ꠆ꠖ ꠙꠣꠁꠞꠣꠝ। ꠎꠣꠘ ꠔ, ꠀꠟ-ꠝꠍꠤꠞ ꠡꠞꠤꠟ ꠝꠣꠘꠤ ꠎꠝꠣꠔꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠎꠦ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠅꠈꠘꠅ ꠛꠣꠇꠤ ꠀꠍꠦ, ꠁꠔꠣ ꠅꠈꠘ ꠀꠝꠣꠞ ꠡꠞꠤꠟ ꠖꠤꠀ ꠙꠥꠞꠣ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("CL1_25","081_1_25","COL","1","25","25","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠟꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠜꠣꠞ ꠀꠝꠣꠞꠦ ꠖꠤꠍꠂꠘ, ꠉꠔꠤꠇꠦꠃ ꠀꠝꠤ ꠎꠝꠣꠔꠞ ꠄꠇꠎꠘ ꠈꠦꠎꠝꠔꠇꠣꠞꠤ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("CL1_26","081_1_26","COL","1","26","26","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠎꠦ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠎꠥꠉ ꠎꠥꠉ ꠗꠞꠤ ꠟꠥꠇꠣꠁꠟ ꠀꠍꠤꠟ, ꠁꠔꠣ ꠅꠈꠘ ꠔꠣꠘ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠞ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL1_27","081_1_27","COL","1","27","27","ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠁꠍꠂꠘ, ꠜꠤꠘ ꠎꠣꠔꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦꠅ ꠔꠣꠘ ꠛꠣꠔꠥꠘꠤ ꠝꠥꠘꠡꠣꠞ ꠉꠃꠞꠛ ꠎꠦ ꠇꠤꠔꠣ, ꠁꠔꠣ ꠎꠦꠘꠥ ꠔꠣꠘ ꠢꠇꠟ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠦ ꠎꠣꠘꠔꠣ ꠙꠣꠞꠂꠘ। ꠀꠍꠟꠦ ꠀꠟ-ꠝꠍꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠀꠍꠂꠘ, ꠉꠔꠤꠇꠦ ꠔꠥꠝꠞꠣ ꠉꠃꠞꠛ ꠙꠣꠅꠀꠞ ꠀꠡꠣ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("CL1_28","081_1_28","COL","1","28","28","ꠀꠞ ꠅꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠤꠀꠞ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠖꠤꠀ ꠝꠣꠘꠡꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤꠀꠞ ꠀꠞ ꠔꠣꠟꠤꠝ ꠖꠤꠀꠞ ꠎꠣꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠔ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠟ ꠢꠣꠟꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("CL1_29","081_1_29","COL","1","29","29","ꠅꠃ ꠘꠤꠅꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠇꠥꠖꠞꠔꠤ ꠛꠟ ꠀꠝꠣꠞ ꠝꠣꠎꠦ ꠇꠣꠝ ꠇꠞꠦꠞ, ꠅꠃ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦꠃ ꠀꠝꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠦꠘꠔ ꠇꠞꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("CL2_1","081_2_1","COL","2","1","1","ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ, ꠟꠣꠅꠖꠤꠇꠦꠀ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠎꠦꠞꠣ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠍꠦ ꠘꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠇꠔ ꠝꠦꠘꠔ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("CL2_2","081_2_2","COL","2","2","2","ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠜꠞꠡꠣ ꠙꠣꠁꠀ ꠝꠢꠛ꠆ꠛꠔꠦ ꠄꠇ ꠅꠃꠇ। ꠀꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠈꠟꠦ ꠀꠈꠟꠖꠣꠞ ꠛꠘꠤꠀ ꠘꠤꠌ꠆ꠌꠤꠔ ꠅꠃꠇ। ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠟꠥꠇꠣꠁꠟ ꠛꠣꠔꠥꠘꠤ ꠜꠦꠖ ꠛꠥꠎꠛ, ꠝꠣꠘꠤ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠣꠞꠣ ꠌꠤꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("CL2_3","081_2_3","COL","2","3","3","ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠦꠃ ꠢꠇꠟ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠟꠥꠇꠣꠁꠟ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL2_4","081_2_4","COL","2","4","4","ꠀꠝꠤ ꠁꠔꠣ ꠇꠁꠟꠣꠝ, ꠎꠣꠔꠦ ꠇꠦꠃ ꠛꠣꠘꠥꠀꠐ ꠝꠣꠔ-ꠇꠕꠣ ꠝꠣꠔꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦ-ꠙꠕꠦ ꠘꠤꠔ ꠘꠣ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("CL2_5","081_2_5","COL","2","5","5","ꠀꠝꠤ ꠡ-ꠡꠞꠤꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠘꠣ ꠕꠣꠇꠟꠦꠅ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠑꠤꠇꠃ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠎꠤꠞ ꠀꠍꠤ। ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣ ꠌꠣꠟ-ꠌꠟꠘ ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠝꠎꠛꠥꠔ ꠁꠝꠣꠘ ꠖꠦꠈꠤꠀ ꠀꠝꠣꠞ ꠈꠥꠛ ꠜꠣꠟꠣ ꠟꠣꠉꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("CL2_6","081_2_6","COL","2","6","6","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇ ꠢꠤꠡꠣꠛꠦ ꠎꠦꠟꠣ ꠇꠛꠥꠟ ꠇꠞꠍ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠘ ꠟꠉꠦ ꠞꠁꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠅ ꠇꠣꠐꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("CL2_7","081_2_7","COL","2","7","7","ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠦ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠒꠥꠛ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠅ। ꠔꠥꠝꠞꠣ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠀ ꠎꠦ ꠁꠝꠣꠘ ꠀꠘꠍ, ꠅꠃ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠅ ꠀꠞ ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("CL2_8","081_2_8","COL","2","8","8","ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠘꠡꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠘꠉꠠꠣ ꠔꠣꠟꠤꠝꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠛꠦ-ꠙꠕꠦ ꠐꠣꠘꠤꠀ ꠘꠤꠔ ꠘꠣ ꠙꠣꠞꠦ। ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠁ ꠔꠣꠟꠤꠝꠞ ꠇꠥꠘꠥ ꠝꠤꠟ ꠘꠣꠁ, ꠁꠔꠣ ꠔ ꠝꠣꠘꠡꠞ ꠝꠘꠉꠠꠣ ꠞꠍꠥꠝꠔ ꠀꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠣꠘꠣꠘ ꠀꠌꠣꠞ-ꠛꠦꠛꠢꠣꠞꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("CL2_9","081_2_9","COL","2","9","9","ꠀꠟ꠆ꠟꠣꠞ ꠢꠇ꠆ꠇꠟ ꠟꠣꠈꠣꠘ ꠉꠥꠘꠣꠉꠥꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠣꠄꠀꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL2_10","081_2_10","COL","2","10","10","ꠄꠞꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠅ ꠢꠇꠟ ꠉꠥꠘꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠍ, ꠔꠣꠘ ꠀꠡꠘ ꠔ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠡꠣꠡꠘꠇꠣꠞꠤ ꠀꠞ ꠈꠦꠝꠔꠣꠀꠟꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠃꠙꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("CL2_11","081_2_11","COL","2","11","11","ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟ ꠅꠁꠍꠦ। ꠅꠃ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠀꠔꠦ ꠇꠞꠣꠁꠟ ꠅꠁꠍꠦ ꠘꠣ, ꠀꠟ-ꠝꠍꠤꠄ ꠘꠤꠎꠦꠃ ꠁꠔꠣ ꠇꠞꠍꠂꠘ, ꠝꠣꠘꠤ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠎꠦ ꠛꠖ ꠈꠣꠁꠡ ꠀꠍꠤꠟ, ꠅꠃ ꠛꠖ ꠈꠣꠁꠡꠞꠦ ꠖꠤꠟ ꠕꠣꠇꠤ ꠇꠣꠐꠤꠀ ꠚꠣꠟꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL2_12","081_2_12","COL","2","12","12","ꠔꠃꠛꠣꠞ ꠉꠥꠍꠟꠞ ꠝꠣꠎꠖꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠝꠣꠐꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠀꠞ ꠎꠦꠁꠘ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟꠦ ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL2_13","081_2_13","COL","2","13","13","ꠔꠥꠝꠞꠣꠞ ꠉꠥꠘꠣ ꠀꠞ ꠖꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡ ꠘꠣ ꠢꠞꠣꠘꠤꠄ ꠝꠥꠞ꠆ꠖꠣ ꠀꠍꠟꠣꠄ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠍꠂꠘ। ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠢꠇꠟ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL2_14","081_2_14","COL","2","14","14","ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠖ ꠀꠝꠟ-ꠘꠣꠝꠣꠞ ꠎꠦ ꠖꠟꠤꠟ ꠀꠍꠤꠟ, ꠅꠃ ꠖꠟꠤꠟꠞꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠖꠣꠛꠤ-ꠖꠣꠅꠀ ꠡꠥꠖ꠆ꠖꠣ ꠚꠥꠍꠤꠀ ꠚꠣꠟꠣꠁꠍꠂꠘ। ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠎꠦ ꠍꠟꠤꠛꠅ ꠁꠍꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠦ, ꠅꠃ ꠍꠟꠤꠛꠅ ꠁ ꠖꠟꠤꠟꠞꠦ ꠙꠦꠞꠦꠉ ꠝꠣꠞꠤꠀ ꠛꠣꠔꠤꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL2_15","081_2_15","COL","2","15","15","ꠀꠟ-ꠝꠍꠤꠄ ꠛꠖ ꠡꠣꠡꠘꠇꠣꠞꠤ ꠀꠞ ꠈꠦꠝꠔꠣꠀꠟꠣ ꠢꠇ꠆ꠇꠟꠞ ꠈꠦꠝꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠂꠘ। ꠍꠟꠤꠛꠅ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠄꠁ ꠅꠁꠍꠂꠘ ꠀꠞ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠣꠞ ꠝꠥꠈ ꠘꠤꠌꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL2_16","081_2_16","COL","2","16","16","ꠄꠞꠟꠣꠉꠤꠃ ꠡꠤꠘ꠆ꠘꠤ-ꠍꠈꠣꠔ, ꠙꠥꠎꠣ-ꠙꠡꠣꠖ ꠅꠝꠣꠛꠁꠡ꠆ꠡꠣ-ꠙꠥꠘ꠆ꠘꠤꠝꠣ, ꠁꠖ ꠛꠣ ꠎꠥꠝ꠆ꠝꠣꠛꠣꠞꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠟꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠡꠤ ꠇꠞꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠇꠦꠃꠞꠞ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("CL2_17","081_2_17","COL","2","17","17","ꠁꠔꠣ ꠔ ꠀꠍꠤꠟ, ꠜꠛꠤꠡꠔꠦ ꠎꠦꠔꠣ ꠀꠁꠛ ꠅꠔꠣꠞ ꠄꠇꠐꠣ ꠘꠝꠥꠘꠣ ꠝꠣꠔ꠆ꠞ, ꠅꠁꠟꠦ ꠀꠍꠟꠔꠣ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠦꠃ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL2_18","081_2_18","COL","2","18","18","ꠎꠦꠞꠣ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞꠦ ꠇꠡ꠆ꠐ ꠖꠦꠅꠀ ꠀꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠞꠦ ꠎꠞꠥꠞꠤ ꠝꠘꠅ ꠇꠞꠦ, ꠄꠞꠣ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞꠞ ꠙꠕ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠔ ꠘꠣ ꠙꠣꠞꠦ। ꠅꠃ ꠘꠝꠥꠘꠣꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠖꠦꠈꠍꠦ ꠇꠁꠀ ꠈꠣꠝꠈꠣ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠇꠞꠦ, ꠀꠞ ꠅꠔꠣ ꠟꠁꠀ ꠛꠠ ꠛꠠ ꠉꠚ ꠝꠣꠞꠦ, ꠀꠍꠟꠦ ꠄꠞꠣꠞ ꠅꠘ꠆ꠔꠞ ꠔ ꠈꠣꠟꠤ ꠖꠥꠘꠤꠀꠛꠤ ꠌꠤꠘ꠆ꠔꠣꠄ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("CL2_19","081_2_19","COL","2","19","19","ꠔꠣꠞꠣ ꠔ ꠝꠣꠕꠣꠞꠦ, ꠝꠣꠘꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠗꠞꠤꠀ ꠞꠣꠈꠦ ꠘꠣ, ꠅꠃ ꠝꠣꠕꠣꠞ ꠈꠦꠝꠔꠣꠄ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠞ ꠀꠒ꠆ꠒꠤ-ꠝꠣꠋꠡ ꠛꠟ-ꠡꠇ꠆ꠔꠤ ꠙꠣꠁꠀ ꠄꠇꠈꠣꠘꠅ ꠞꠄ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠛꠟꠦ ꠛꠣꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("CL2_20","081_2_20","COL","2","20","20","ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠝꠣꠞꠣ ꠉꠤꠀ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠢꠇꠟ ꠌꠣꠟ-ꠌꠟꠘ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠀꠁꠍ, ꠔꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠦꠘꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠝ-ꠘꠤꠔꠤꠞ ꠉꠥꠟꠣꠝ ꠅꠁꠞꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("CL2_21","081_2_21","COL","2","21","22","ꠢꠥꠘꠅ, ꠎꠦ ꠎꠤꠘꠤꠡ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠔꠦ ꠇꠞꠔꠦ ꠛꠞꠛꠣꠖ ꠅꠁꠎꠣꠄ, ꠅꠃ ꠎꠤꠘꠤꠡꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠟꠣ ꠘꠤꠅꠝ ꠀꠍꠦ, ꠁꠔꠣ ꠗꠞꠤꠅ ꠘꠣ, ꠍꠁꠅ ꠘꠣ, ꠈꠣꠁꠅ ꠘꠣ। ꠁꠔꠣ ꠔ ꠈꠣꠟꠤ ꠝꠣꠘꠡꠞ ꠝꠘꠉꠠꠣ ꠢꠥꠇꠥꠝ ꠀꠞ ꠔꠣꠟꠤꠝ। ");
INSERT INTO syls_vpl VALUES ("CL2_23","081_2_23","COL","2","23","23","ꠇꠦꠝꠘꠦ ꠄꠛꠣꠖꠔ ꠇꠞꠣ, ꠘꠤꠎꠞꠦ ꠘꠤꠌꠣ ꠇꠞꠣ, ꠇꠦꠝꠘꠦ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠞꠦ ꠇꠡ꠆ꠐ ꠖꠦꠅꠀ, ꠅꠃ ꠘꠤꠅꠝ-ꠘꠤꠔꠤꠄ ꠅꠔꠣ ꠢꠤꠇꠣꠄ। ꠁ ꠘꠤꠅꠝ-ꠘꠤꠔꠤ ꠖꠦꠈꠟꠦ ꠝꠘꠅ ꠅꠄ, ꠁꠔꠣ ꠈꠥꠛ ꠀꠈꠟꠞ ꠇꠣꠝ, ꠅꠁꠟꠦ ꠖꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡꠞꠦ ꠖꠝꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠔꠣꠞ ꠇꠥꠘꠥ ꠖꠣꠝꠃ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("CL3_1","081_3_1","COL","3","1","1","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍ, ꠀꠞ ꠀꠟ-ꠝꠍꠤ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠦꠙꠣꠞ ꠟꠁꠀ ꠀꠡꠤꠇ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_2","081_3_2","COL","3","2","2","ꠖꠥꠘꠤꠀꠛꠤ ꠛꠦꠙꠣꠞꠦ ꠀꠡꠤꠇ ꠘꠣ ꠛꠘꠤꠀ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠦꠙꠣꠞꠦ ꠀꠡꠤꠇ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_3","081_3_3","COL","3","3","3","ꠔꠥꠝꠞꠣ ꠔ ꠝꠣꠞꠣ ꠉꠦꠍ, ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠟꠥꠇꠣꠁꠟ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL3_4","081_3_4","COL","3","4","4","ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠢꠃ ꠀꠟ-ꠝꠍꠤ ꠎꠦꠛꠟꠣ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠁꠞ ꠅꠁꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠅ ꠔꠣꠘ ꠝꠢꠤꠝꠣꠞ ꠜꠣꠉꠤ ꠅꠁꠀ ꠔꠣꠘ ꠟꠉꠦ ꠎꠣꠁꠞ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("CL3_5","081_3_5","COL","3","5","5","ꠄꠞꠟꠣꠉꠤ ꠉꠥꠘꠣꠞ ꠎꠦꠔꠣ ꠞꠤꠙꠥ ꠅꠇꠟ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠀꠍꠦ, ꠁꠔꠣꠞꠦ ꠄꠇꠖꠝ ꠛꠤꠘꠣꠡ ꠇꠞꠤꠟꠣꠅ। ꠁꠔꠣ ꠅꠁꠟ ꠢꠇ꠆ꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠎꠤꠘꠣ, ꠘꠣꠙꠣꠇꠤ, ꠛꠖ ꠈꠣꠁꠡ, ꠇꠥ-ꠌꠤꠘ꠆ꠔꠣ, ꠀꠞ ꠟꠥꠜ-ꠟꠣꠟꠌ, ꠁ ꠟꠥꠜ-ꠟꠣꠟꠌ ꠅꠁꠟ ꠄꠇꠟꠣꠈꠣꠘ ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("CL3_6","081_3_6","COL","3","6","6","ꠎꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠦ, ꠅꠔꠣꠞ ꠇꠣꠞꠘꠦꠃ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛ ꠟꠣꠝꠤꠀ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("CL3_7","081_3_7","COL","3","7","7","ꠔꠥꠝꠞꠣꠅ ꠀꠉꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("CL3_8","081_3_8","COL","3","8","8","ꠅꠁꠟꠦ ꠅꠈꠘ ꠞꠣꠉ-ꠉꠥꠍꠣ, ꠜꠤꠔꠞꠤ ꠖꠥꠡꠝꠘꠤ, ꠁꠋꠡꠣ-ꠘꠤꠘ꠆ꠖꠣ, ꠉꠣꠟꠣ-ꠉꠣꠟꠤ ꠀꠞ ꠈꠛꠤꠍꠤ ꠝꠣꠔ-ꠇꠕꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_9","081_3_9","COL","3","9","9","ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠤꠍꠣ ꠝꠣꠔꠤꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠙꠥꠞꠣꠘ ‘ꠀꠝꠤ’ꠞꠦ ꠔꠣꠞ ꠢꠇꠟ ꠀꠝꠟ ꠡꠥꠖ꠆ꠖꠣ ꠙꠥꠞꠣꠘ ꠇꠣꠙꠠꠞ ꠟꠣꠈꠣꠘ ꠚꠣꠟꠣꠁ ꠖꠤꠍ, ");
INSERT INTO syls_vpl VALUES ("CL3_10","081_3_10","COL","3","10","10","ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠘꠄꠀ ‘ꠀꠝꠤ’ꠞꠦ ꠘꠄꠀ ꠇꠣꠙꠠꠞ ꠟꠣꠈꠣꠘ ꠚꠤꠘ꠆ꠖꠤꠍ। ꠅꠃ ꠘꠄꠀ ‘ꠀꠝꠤ’ ꠀꠞꠅ ꠘꠄꠀ ꠅꠁꠀ ꠔꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠞꠣ ꠝꠣꠟꠤꠇꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠦꠞ, ꠎꠣꠔꠦ ꠅꠃ ꠙꠄꠖꠣ ꠇꠞꠞꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("CL3_11","081_3_11","COL","3","11","11","ꠅꠃ ꠢꠣꠟꠔꠦ ꠁꠢꠥꠖꠤ ꠇꠤꠛꠣ ꠜꠤꠘ ꠎꠣꠔꠤ, ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠁꠟ ꠛꠣ ꠘꠣ ꠇꠞꠣꠁꠟ, ꠅꠡꠤꠇ꠆ꠇꠤꠔ ꠛꠞꠛꠞ, ꠘꠤꠌꠣ ꠎꠣꠔꠤ, ꠉꠥꠟꠣꠝ ꠛꠣ ꠀꠎꠣꠖ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠔꠚꠣꠔ ꠘꠣꠁ। ꠁꠔꠣ ꠢꠇꠟꠔꠣꠞ ꠝꠣꠎꠦ ꠀꠟ-ꠝꠍꠤꠃ ꠙꠞꠗꠣꠘ, ꠢꠇꠟꠞ ꠝꠣꠎꠦꠃ ꠔꠣꠁꠘ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL3_12","081_3_12","COL","3","12","12","ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠀꠟꠉ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠢꠃ ꠝꠣꠄꠀꠞ ꠛꠘ꠆ꠖꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ, ꠖꠄꠀ, ꠘꠞꠝ ꠛꠦꠛꠢꠣꠞ, ꠘꠞꠝ ꠡ꠆ꠛꠜꠣꠛ ꠀꠞ ꠍꠛꠞ ꠖꠤꠀ ꠘꠤꠎꠞꠦ ꠢꠣꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_13","081_3_13","COL","3","13","13","ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞꠅ, ꠇꠦꠃꠞꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠕꠣꠇꠟꠦ ꠔꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠤ ꠖꠦꠅ। ꠝꠣꠟꠤꠇꠦ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠣꠚ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠣꠚ ꠇꠞꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("CL3_14","081_3_14","COL","3","14","14","ꠀꠞ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠟꠉꠦ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠖꠤ ꠘꠤꠎꠞꠦ ꠢꠣꠎꠣꠅ। ꠝꠢꠛ꠆ꠛꠔꠦ ꠔ ꠢꠇꠟꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠄꠇꠟꠉꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠣꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("CL3_15","081_3_15","COL","3","15","15","ꠀꠟ-ꠝꠍꠤꠄ ꠎꠦ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠂꠘ, ꠅꠃ ꠡꠣꠘ꠆ꠔꠤ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠞꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠌꠣꠟꠣꠃꠇ। ꠄꠇ ꠡꠞꠤꠟ ꠅꠁꠀ ꠡꠣꠘ꠆ꠔꠤꠞ ꠝꠣꠎꠦ ꠞꠁꠔꠣꠄ ꠇꠞꠤꠃ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠔꠥꠝꠞꠣ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠣꠔ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_16","081_3_16","COL","3","16","16","ꠀꠟ-ꠝꠍꠤꠞ ꠇꠣꠟꠣꠝꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠡꠔ ꠇꠞꠔꠦ ꠖꠦꠅ। ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠀꠈꠟ ꠈꠣꠐꠣꠁꠀ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠔꠣꠟꠤꠝ ꠀꠞ ꠙꠞꠣꠝꠤꠡ ꠖꠦꠅ। ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠘ ꠘꠣꠝꠦ ꠢꠣꠝꠖ, ꠇꠣꠅꠀꠟꠤ ꠀꠞ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠞ ꠉꠎꠟ ꠉꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_17","081_3_17","COL","3","17","17","ꠔꠥꠝꠞꠣ ꠝꠥꠈꠖꠤ ꠎꠦꠔꠣ ꠝꠣꠔ ꠀꠞ ꠡꠞꠤꠟ ꠖꠤꠀ ꠎꠔꠔꠣ ꠇꠞ, ꠁꠔꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠘꠣꠝꠦ ꠇꠞꠅ, ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣ ꠟꠁꠀ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_18","081_3_18","COL","3","18","18","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠛꠃ ꠅꠁꠍ, ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠝꠣꠁꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠅ, ꠝꠣꠟꠤꠇꠞ ꠛꠘ꠆ꠖꠣ ꠢꠤꠡꠣꠛꠦ ꠔ ꠅꠟꠣ ꠌꠟꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("CL3_19","081_3_19","COL","3","19","19","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠎꠣꠝꠣꠁ ꠅꠁꠍ, ꠔꠥꠝꠞꠣꠅ ꠎꠣꠞꠎꠤꠞ ꠛꠃꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠅ, ꠛꠃꠞ ꠟꠉꠦ ꠇꠐꠥ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("CL3_20","081_3_20","COL","3","20","20","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠙꠥꠀ-ꠙꠥꠠꠤ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠝꠣ-ꠛꠣꠚꠞ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠅ, ꠁꠟꠣ ꠌꠟꠟꠦ ꠝꠣꠟꠤꠇ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("CL3_21","081_3_21","COL","3","21","21","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠛꠣꠚ ꠅꠁꠍ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ꠆ꠔꠞ ꠝꠘꠞꠦ ꠔꠤꠔ꠆ꠔꠣ ꠇꠞꠤꠅ ꠘꠣ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠝꠘ ꠘꠣ ꠜꠣꠋꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("CL3_22","081_3_22","COL","3","22","22","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠉꠥꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠉꠔꠞ ꠝꠥꠘꠤꠛ ꠅꠇꠟꠞ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠅ। ꠔꠣꠞꠣ ꠍꠣꠝꠘꠦ ꠞꠁꠀ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠖꠦꠈꠂꠘ, ꠈꠣꠟꠤ ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞꠦ ꠈꠥꠡꠤ ꠞꠣꠈꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠛꠞꠋ ꠝꠣꠟꠤꠇꠞ ꠒꠞ-ꠈꠚ ꠜꠤꠔꠞꠦ ꠞꠣꠈꠤꠀ ꠈꠣꠐꠤ ꠖꠤꠟꠦ ꠔꠣꠞꠣꠞ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_23","081_3_23","COL","3","23","23","ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣꠃ ꠇꠞꠅ ꠘꠣ ꠇꠦꠘꠦ, ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠘꠣꠄ, ꠛꠞꠋ ꠝꠣꠟꠤꠇꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("CL3_24","081_3_24","COL","3","24","24","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠞꠣꠈꠍꠂꠘ, ꠁꠔꠣ ꠔ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠛꠣꠄ। ꠔꠥꠝꠞꠣ ꠔ ꠈꠣꠟꠤ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("CL3_25","081_3_25","COL","3","25","25","ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠦ, ꠢꠦ ꠔ ꠔꠣꠞ ꠇꠣꠝꠞ ꠚꠟ ꠙꠣꠁꠛ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠣꠟꠤꠇꠦ ꠇꠦꠃꠞꠞ ꠝꠥꠈ ꠌꠣꠁꠀ ꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("CL4_1","081_4_1","COL","4","1","1","ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠝꠥꠘꠤꠛ, ꠔꠥꠝꠞꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠟꠉꠦ ꠘꠤꠀꠄ ꠀꠞ ꠢꠇ ꠁꠘꠍꠣꠚ ꠇꠞꠤꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠞꠅ ꠄꠇꠎꠘ ꠝꠥꠘꠤꠛ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL4_2","081_4_2","COL","4","2","2","ꠔꠥꠝꠞꠣ ꠝꠘ ꠖꠤꠀ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠖꠥꠀ ꠇꠞꠣꠔ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("CL4_3","081_4_3","COL","4","3","3","ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠖꠥꠀ ꠇꠞꠤꠅ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠔꠥꠘꠤ ꠢꠇ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠔꠚꠤꠇ ꠖꠦꠁꠘ। ꠅꠃ ꠛꠣꠔꠥꠘꠤ ꠢꠇ ꠇꠣꠟꠣꠝꠞ ꠟꠣꠉꠤꠃ ꠔ ꠀꠝꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("CL4_4","081_4_4","COL","4","4","4","ꠖꠥꠀ ꠇꠞꠤꠅ, ꠝꠣꠘꠡꠞꠦ ꠎꠦꠟꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠞꠤ ꠛꠥꠎꠣꠘꠤ ꠎꠞꠥꠞ, ꠀꠝꠤ ꠎꠣꠘꠥ ꠑꠤꠇ ꠅꠃꠟꠣ ꠛꠥꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("CL4_5","081_4_5","COL","4","5","5","ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠞ ꠛꠣꠁꠞꠞ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠀꠈꠟ ꠈꠣꠐꠣꠁꠀ ꠌꠟꠤꠅ, ꠀꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠡꠥꠎꠥꠉ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("CL4_6","081_4_6","COL","4","6","6","ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈꠞ ꠎꠛꠣꠘ ꠢꠣꠝꠦꠡꠣ ꠝꠤꠑꠣ ꠀꠞ ꠞꠡꠣꠁꠟ ꠅꠃꠇ, ꠎꠣꠔꠦ ꠇꠣꠞꠦ ꠇꠤꠟꠣ ꠎꠥꠀꠙ ꠖꠤꠔꠣꠄ, ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠛꠥꠎ। ");
INSERT INTO syls_vpl VALUES ("CL4_7","081_4_7","COL","4","7","7","ꠀꠝꠞꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ, ꠛꠤꠡ꠆ꠛꠣꠡꠤ ꠈꠣꠖꠤꠝ ꠀꠞ ꠝꠣꠟꠤꠇꠞ ꠈꠦꠎꠝꠔꠅ ꠀꠝꠞꠣꠞ ꠟꠉꠞ ꠔꠛꠟꠤꠉꠇꠣꠞꠤ ꠔꠥꠈꠤꠇ ꠜꠣꠁꠄ, ꠀꠝꠣꠞ ꠛꠤꠡ꠆ꠔꠣꠞꠤꠔ ꠈꠛꠞꠣ-ꠈꠛꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("CL4_8","081_4_8","COL","4","8","8","ꠔꠣꠘ ꠝꠣꠞꠚꠔꠦ ꠀꠝꠞꠣꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠎꠣꠘꠛꠣꠄ, ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠡꠣꠅꠡ ꠖꠤꠛꠣ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("CL4_9","081_4_9","COL","4","9","9","ꠔꠥꠈꠤꠇꠞ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠄꠀꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠅꠘꠤꠍꠤꠝꠞꠦꠅ ꠙꠣꠑꠣꠁꠟꠣꠝ। ꠄꠁꠘ ꠔ ꠔꠥꠝꠞꠣꠞꠃ ꠄꠇꠎꠘ। ꠔꠣꠞꠣ ꠁꠘꠞ ꠢꠇꠟ ꠈꠛꠞ-ꠀꠘ꠆ꠔꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("CL4_10","081_4_10","COL","4","10","10","ꠀꠝꠣꠞ ꠟꠉꠞ ꠛꠘ꠆ꠖꠤ ꠜꠣꠁ ꠀꠞꠤꠡ꠆ꠔꠣꠇꠥꠍ ꠀꠞ ꠛꠣꠞ꠆ꠘꠣꠛꠣꠍꠞ ꠇꠥꠐꠥꠝ ꠝꠣꠞ꠆ꠇꠥꠍꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠍꠂꠘ। ꠅꠃ ꠝꠣꠞ꠆ꠇꠥꠍꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠔ ꠀꠉ ꠕꠣꠇꠤꠃ ꠈꠛꠞ ꠙꠣꠁꠍ, ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠁꠘ, ꠔꠦ ꠈꠥꠡꠤ ꠝꠘꠦ ꠔꠣꠘꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("CL4_11","081_4_11","COL","4","11","11","ꠀꠞ ꠁꠍꠣ ꠃꠞꠚꠦ ꠁꠃꠍꠔꠥꠍꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠍꠂꠘ। ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠟꠣꠉꠤ ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠈꠣꠟꠤ ꠅꠃ ꠔꠤꠘ ꠎꠘꠦꠃ ꠀꠝꠣꠞ ꠟꠉꠦ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠀꠝꠣꠞꠦ ꠛꠃꠔ ꠡꠣꠅꠡ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL4_12","081_4_12","COL","4","12","12","ꠀꠛꠥ-ꠚꠣꠞꠣꠍꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠍꠂꠘ, ꠔꠣꠁꠘ ꠔ ꠔꠥꠝꠞꠣꠞ ꠀꠙꠘ ꠝꠣꠘꠥꠡ ꠀꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠥꠟꠣꠝ। ꠄꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠞꠣ, ꠔꠥꠝꠞꠣ ꠎꠣꠔꠦ ꠇꠣꠝꠤꠟ ꠅꠅ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ-ꠝꠥꠘꠡꠣ ꠛꠥꠎꠤꠀ ꠝꠎꠛꠥꠔ ꠅꠁꠀ ꠃꠛꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("CL4_13","081_4_13","COL","4","13","13","ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠅꠃ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠔꠣꠝ ꠙꠣꠞꠤ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞ ꠟꠣꠅꠖꠤꠇꠦꠀ, ꠢꠤꠅꠞꠣꠙꠟꠤ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤꠅ ꠀꠛꠥ-ꠚꠣꠞꠣꠍꠦ ꠈꠥꠛ ꠝꠦꠘꠔ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL4_14","081_4_14","COL","4","14","14","ꠀꠝꠞꠣꠞ ꠝꠣꠄꠀꠞ ꠇꠛꠤꠞꠣꠎ ꠟꠥꠇ ꠀꠞ ꠜꠣꠁ ꠖꠤꠝꠣꠍꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("CL4_15","081_4_15","COL","4","15","15","ꠟꠣꠅꠖꠤꠇꠦꠀꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠅꠇꠟꠞꠦ, ꠀꠞ ꠘꠤꠝꠥꠚꠣ ꠀꠞ ꠔꠣꠘ ꠛꠣꠠꠤꠞ ꠎꠝꠣꠔꠞ ꠢꠇꠟꠞ ꠉꠦꠍꠦꠅ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("CL4_16","081_4_16","COL","4","16","16","ꠔꠥꠝꠞꠣ ꠅꠃ ꠌꠤꠑꠤꠈꠣꠘ ꠙꠠꠤꠀ ꠢꠣꠞꠟꠦ ꠟꠣꠅꠖꠤꠇꠦꠀꠞ ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠞꠦ ꠙꠠꠣꠞ ꠟꠣꠉꠤ ꠖꠤꠅ ꠀꠞ ꠟꠣꠅꠖꠤꠇꠦꠀ ꠎꠝꠣꠔꠞꠦ ꠖꠥꠍꠞꠣ ꠎꠦ ꠌꠤꠑꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠃ ꠌꠤꠑꠤꠅ ꠔꠥꠝꠞꠣ ꠙꠠꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("CL4_17","081_4_17","COL","4","17","17","ꠀꠞ꠆ꠈꠤꠙꠣꠍꠞꠦ ꠅꠈꠣꠘ ꠇꠁꠅ, “ꠝꠣꠟꠤꠇꠞ ꠈꠦꠎꠝꠔꠅ ꠔꠥꠝꠣꠞꠦ ꠎꠦ ꠇꠣꠝ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠅꠃ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠝꠘ ꠖꠤꠀ ꠇꠣꠝ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("CL4_18","081_4_18","COL","4","18","18","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠘꠤꠎꠞ ꠀꠔꠦ ꠅꠃ ꠍꠣꠟꠣꠝꠞ ꠇꠕꠣ ꠟꠦꠈꠟꠣꠝ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠤ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠀꠍꠤ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠞꠢꠝꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("H11_1","082_1_1","1TH","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ, ꠜꠣꠁ ꠍꠤꠟꠣꠍ ꠀꠞ ꠔꠤꠝꠕꠤꠄ ꠕꠤꠡꠟꠘꠤꠇꠤ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ꠔꠥꠝꠞꠣ ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠙꠘ ꠎꠘ ꠅꠁꠍ। ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠘꠣꠎꠤꠟ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("H11_2","082_1_2","1TH","1","2","2","ꠀꠝꠞꠣ ꠖꠥꠀ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠎꠝꠣꠔꠞ ꠢꠇꠟꠞ ꠘꠣꠝ ꠝꠘꠅ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("H11_3","082_1_3","1TH","1","3","3","ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠦ ꠇꠣꠝ ꠇꠞꠞꠣꠄ, ꠝꠢꠛ꠆ꠛꠔꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠦ ꠝꠦꠘꠔ ꠇꠞꠞꠣꠄ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠎꠦ ꠍꠛꠞ ꠇꠞꠞꠣꠄ, ꠁꠔꠣ ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠖꠥꠀ ꠇꠞꠣꠞ ꠡꠝꠄ ꠢꠣꠝꠦꠡꠣ ꠝꠘꠅ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("H11_4","082_1_4","1TH","1","4","4","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠄꠀꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("H11_5","082_1_5","1TH","1","5","5","ꠀꠝꠞꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠔꠛꠟꠤꠉ ꠇꠣꠝ ꠔ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠈꠣꠟꠤ ꠝꠥꠈꠞ ꠇꠕꠣꠃ ꠞꠁꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠁ ꠛꠟ, ꠙꠣꠇ ꠞꠥꠢꠥ, ꠀꠞ ꠘꠤꠌ꠆ꠌꠤꠔ ꠜꠞꠡꠣꠞ ꠃꠙꠞꠦ ꠌꠣꠟꠥ ꠅꠁꠍꠦ। ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠔꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠇꠤꠟꠣꠘ ꠌꠟꠍꠤ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠃ। ");
INSERT INTO syls_vpl VALUES ("H11_6","082_1_6","1TH","1","6","6","ꠔꠥꠝꠞꠣ ꠛꠃꠔ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦꠅ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠖꠦꠅꠀ ꠈꠥꠡꠤꠄ ꠀꠝꠞꠣꠞ ꠔꠛꠟꠤꠉ ꠇꠛꠥꠟ ꠇꠞꠤꠀ, ꠀꠝꠞꠣꠞ ꠀꠞ ꠝꠣꠟꠤꠇꠞ ꠙꠕꠦ ꠌꠟꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H11_7","082_1_7","1TH","1","7","7","ꠅꠃꠟꠣ ꠌꠟꠤꠀ ꠔꠥꠝꠞꠣ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠀꠞ ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠄꠇ ꠘꠤꠡꠣꠘꠣ ꠅꠁꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("H11_8","082_1_8","1TH","1","8","8","ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠈꠣꠟꠤ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠀꠞ ꠉ꠆ꠞꠤꠍ ꠖꠦꠡꠅꠃ ꠍꠤꠔ꠆ꠞꠤꠍꠦ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠇꠕꠣ ꠢꠇꠟ ꠎꠣꠉꠣꠔꠃ ꠍꠤꠔ꠆ꠞꠤꠉꠦꠍꠦ। ꠁ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠔꠣꠞ ꠎꠞꠥꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H11_9","082_1_9","1TH","1","9","9","ꠢꠇꠟ ꠝꠣꠘꠡꠦꠃ ꠔ ꠀꠝꠞꠣꠞꠦ ꠇꠁꠞꠣ, ꠔꠥꠝꠞꠣ ꠇꠔ ꠀꠖꠞ ꠇꠞꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠇꠛꠥꠟ ꠇꠞꠍꠤꠟꠣꠄ, ꠔꠣꠞꠣ ꠄꠅꠈꠣꠘ ꠇꠁꠞꠣ, ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣ ꠖꠦꠛ-ꠖꠦꠛꠤꠘ꠆ꠔꠞ ꠙꠥꠎꠣ ꠛꠣꠖ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠙꠕꠤ ꠅꠁꠀ, ꠎꠤꠘ꠆ꠖꠣ ꠢꠇ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠔ ꠀꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("H11_10","082_1_10","1TH","1","10","10","ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠎꠦꠘꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠣ ꠅꠁꠍꠦ, ꠢꠃ ꠁꠍꠣ ꠖꠥꠘꠤꠀꠔ ꠀꠅꠀꠞ ꠛꠣꠞ ꠌꠣꠁꠔꠣꠄ ꠙꠣꠞ। ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠞꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠉꠎꠛ ꠀꠁꠀ ꠟꠣꠝꠦꠞ, ꠁ ꠉꠎꠛ ꠕꠣꠇꠤ ꠅꠃ ꠁꠍꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H12_1","082_2_1","1TH","2","1","1","ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠔ ꠘꠤꠎꠦꠃ ꠎꠣꠘ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣꠞ ꠎꠣꠅꠀꠈꠣꠘ ꠛꠦꠇꠣꠝꠣ ꠉꠦꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("H12_2","082_2_2","1TH","2","2","2","ꠔꠥꠝꠞꠣ ꠄꠅꠈꠣꠘꠅ ꠎꠣꠘ, ꠄꠞ ꠀꠉꠦ ꠀꠝꠞꠣ ꠚꠤꠟꠤꠙꠤ ꠐꠣꠃꠘꠅ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔꠅ ꠙꠠꠍꠟꠣꠝ ꠀꠞ ꠛꠦꠁꠎ꠆ꠎꠔ ꠅꠁꠍꠟꠣꠝ। ꠛꠣꠖꠦ ꠔꠥꠝꠞꠣꠞ ꠅꠘꠅ-ꠅ ꠛꠃꠔ ꠛꠣꠗꠣ-ꠘꠤꠡꠦꠗ ꠇꠣꠐꠣꠁꠀ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠁ ꠡꠣꠅꠡꠦ ꠡꠣꠅꠡꠤ ꠅꠁꠀ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠔꠣꠘ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("H12_3","082_2_3","1TH","2","3","3","ꠀꠝꠞꠣꠞ ꠖꠣꠅꠔ ꠔ ꠇꠥꠘꠥ ꠜꠥꠟ ꠔꠣꠟꠤꠝ ꠕꠣꠇꠤ ꠘꠣꠄ, ꠇꠥꠘꠥ ꠛꠖ ꠘꠤꠅꠔꠦꠅ ꠘꠣꠄ ꠛꠣ ꠇꠥꠘꠥ ꠐꠉꠣ-ꠐꠉꠤꠞ ꠘꠤꠅꠔꠦꠅ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H12_4","082_2_4","1TH","2","4","4","ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠎꠁꠉ꠆ꠉ ꠝꠘꠅ ꠇꠞꠤꠀ ꠎꠦꠟꠣ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠤꠍꠂꠘ, ꠀꠝꠞꠣ ꠅꠟꠣꠃ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ। ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠀꠝꠞꠣ ꠁꠔꠣ ꠇꠁꠞꠣꠝ ꠘꠣ, ꠈꠣꠟꠤ ꠎꠦꠁꠘ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠎꠣꠌꠣꠁ ꠇꠞꠤꠀ ꠖꠦꠈꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠞꠦ ꠈꠥꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("H12_5","082_2_5","1TH","2","5","5","ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠇꠦꠃꠞꠞ ꠉꠦꠍꠦ ꠔꠦꠟ-ꠝꠣꠟꠤꠡ ꠇꠞꠤꠀ ꠇꠕꠣ ꠝꠣꠔꠍꠤ ꠘꠣ, ꠀꠞ ꠇꠥꠘꠥ ꠟꠥꠜ-ꠟꠣꠟꠌꠅ ꠙꠠꠤꠀ ꠗꠣꠘ꠆ꠖꠣꠛꠣꠎꠤꠞ ꠇꠣꠝꠅ ꠇꠞꠍꠤ ꠘꠣ, ꠄꠇ ꠀꠟ꠆ꠟꠣꠃ ꠁꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("H12_6","082_2_6","1TH","2","6","6","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠁꠎ꠆ꠎꠔ ꠙꠣꠁꠔꠦ ꠀꠡꠣ ꠇꠞꠍꠤ ꠘꠣ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠅ ꠘꠣ, ꠛꠣ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("H12_7","082_2_7","1TH","2","7","7","ꠀꠝꠞꠣ ꠁꠌ꠆ꠍꠣ ꠇꠞꠟꠦ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠢꠣꠛꠤ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠖꠣꠛꠤ ꠈꠣꠐꠣꠁꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠅꠘꠦ। ꠅꠁꠟꠦ ꠄꠞ ꠛꠖꠟꠣ, ꠝꠣʼꠄ ꠎꠦꠟꠣ ꠘꠤꠎꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘꠞꠦ ꠎꠄ-ꠎꠔꠘ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠣꠞ ꠡꠝꠄ ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠘꠞꠝ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("H12_8","082_2_8","1TH","2","8","8","ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠥꠛ ꠛꠦꠡꠤ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠅꠀꠄ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠘꠣꠄ, ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠘ ꠖꠤꠔꠦꠅ ꠞꠣꠎꠤ ꠀꠍꠟꠣꠝ। ꠎꠣꠘ ꠔ, ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠈꠥꠛ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("H12_9","082_2_9","1TH","2","9","9","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠀꠍꠟꠦ ꠔ ꠀꠝꠞꠣꠞ ꠝꠦꠘꠔ ꠀꠞ ꠀꠐꠘꠤ-ꠈꠣꠐꠘꠤꠞ ꠇꠕꠣ, ꠘꠤꠌ꠆ꠌꠄ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠀꠍꠦ। ꠀꠟ꠆ꠟꠣꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠚꠣꠇꠦ ꠚꠣꠇꠦ ꠀꠝꠞꠣ ꠖꠤꠘꠦ-ꠞꠣꠁꠔꠦ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞ ꠇꠞꠍꠤ, ꠎꠣꠔꠦ ꠀꠝꠞꠣꠞ ꠈꠞꠌꠣ-ꠙꠣꠔꠤ ꠔꠥꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠟꠣꠉꠤ ꠛꠥꠏꠣ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("H12_10","082_2_10","1TH","2","10","10","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍ, ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠔ ꠀꠝꠞꠣꠞ ꠀꠌꠣꠞ-ꠛꠦꠛꠢꠣꠞ ꠀꠍꠤꠟ ꠙꠛꠤꠔ꠆ꠞ, ꠢꠇ ꠀꠞ ꠘꠤꠈꠥꠔ। ꠔꠥꠝꠞꠣꠃ ꠁꠔꠣꠞ ꠡꠣꠇ꠆ꠇꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠅ ꠡꠣꠇ꠆ꠇꠤ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("H12_11","082_2_11","1TH","2","11","11","ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠛꠣꠚꠦ ꠎꠦꠟꠣ ꠘꠤꠎꠞ ꠙꠞꠔꠦꠇ ꠀꠅꠟꠣꠖꠞꠦ ꠃꠔꠡꠣꠢ, ꠡꠣꠘ꠆ꠔꠘꠣ ꠀꠞ ꠝꠎꠛꠥꠔ ꠙꠞꠣꠝꠤꠡ ꠖꠦꠁꠘ, ꠀꠝꠞꠣꠅ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞꠦ ꠅꠃꠟꠣ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠔꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("H12_12","082_2_12","1TH","2","12","12","ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣ ꠃꠙꠎꠥꠇ꠆ꠔ ꠅꠁꠀ ꠌꠟ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠞꠣ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠞ ꠉꠃꠞꠛꠞ ꠜꠣꠉꠤ ꠅꠀꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("H12_13","082_2_13","1TH","2","13","13","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠞꠣꠝ, ꠇꠣꠞꠘ ꠀꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟꠣꠄ, ꠢꠃ ꠡꠝꠄ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠝꠥꠈꠞ ꠇꠕꠣ ꠘꠣꠄ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠢꠤꠡꠣꠛꠦꠃ ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠇꠛꠥꠟ ꠇꠞꠍꠤꠟꠣꠄ, ꠀꠞ ꠢꠣꠍꠣꠃ ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ। ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍ, ꠢꠃ ꠇꠣꠟꠣꠝꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠇꠣꠝ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("H12_14","082_2_14","1TH","2","14","14","ꠜꠣꠁ ꠅꠇꠟ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠄ ꠌꠟꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠎꠔ ꠎꠝꠣꠔ ꠅꠇꠟ ꠄꠢꠥꠖꠤꠀ ꠎꠤꠟꠣꠔ ꠀꠍꠦ, ꠔꠥꠝꠞꠣꠞ ꠢꠣꠟ-ꠢꠇꠤꠇꠔ ꠔ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘꠃ। ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠎꠦꠟꠣ ꠘꠤꠎꠞ ꠁꠢꠥꠖꠤ ꠎꠣꠔꠤꠞ ꠀꠔꠅ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠙꠣꠁꠍꠂꠘ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠘꠤꠎꠞ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("H12_15","082_2_15","1TH","2","15","15","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠁꠢꠥꠖꠤ ꠅꠇꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠍꠤꠟ, ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦꠅ ꠎꠥꠟꠥꠝ ꠇꠞꠍꠦ। ꠔꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠡꠤ ꠘꠣꠄ, ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠟꠉꠦꠅ ꠔꠣꠞꠣꠞ ꠖꠥꠡꠝꠘꠤ ꠜꠣꠛ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("H12_16","082_2_16","1TH","2","16","16","ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞꠦ ꠘꠤꠡꠦꠗ ꠖꠤꠞꠣ, ꠎꠣꠔꠦ ꠜꠤꠘ-ꠗꠞ꠆ꠝꠤ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠁ ꠘꠣꠎꠣꠔꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠘꠣ ꠇꠞꠤ। ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠘꠣꠞ ꠛꠥꠏꠣ ꠛꠠ ꠇꠞꠞꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠠꠣ ꠉꠎꠛ ꠟꠣꠝꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("H12_17","082_2_17","1TH","2","17","17","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠝꠘꠞ ꠖꠤꠇ ꠕꠣꠇꠤ ꠘꠣ ꠅꠁꠟꠦꠅ, ꠡꠞꠤꠟꠞ ꠖꠤꠇ ꠕꠣꠇꠤ ꠔ ꠀꠝꠞꠣ ꠕꠥꠠꠣ ꠖꠤꠘꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟ ꠀꠍꠤ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠈꠥꠛ ꠈꠤꠀꠟ ꠀꠍꠦ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈꠈꠣꠘ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("H12_18","082_2_18","1TH","2","18","18","ꠀꠝꠞꠣ ꠢꠇꠟꠃ, ꠈꠣꠍ ꠇꠞꠤ ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠛꠣꠞ ꠛꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠍꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠣꠝ। ꠅꠁꠟꠦ ꠡꠄꠔꠣꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠀꠐꠇꠣꠁꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("H12_19","082_2_19","1TH","2","19","19","ꠢꠣꠍꠣꠃ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠝꠞꠣꠞ ꠀꠡꠣ, ꠀꠘꠘ꠆ꠖ ꠀꠞ ꠉꠃꠞꠛꠞ ꠎꠄꠅꠞ ꠝꠣꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠇꠤꠔꠣ ꠙꠣꠁꠝꠥ? ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠃ ꠘꠣꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("H12_20","082_2_20","1TH","2","20","20","ꠀꠍꠟꠦ ꠔꠥꠝꠞꠣꠃ ꠀꠝꠞꠣꠞ ꠉꠃꠞꠛ, ꠔꠥꠝꠞꠣꠃ ꠀꠝꠞꠣꠞ ꠀꠘꠘ꠆ꠖ। ");
INSERT INTO syls_vpl VALUES ("H13_1","082_3_1","1TH","3","1","1","ꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠞ ꠡꠁꠎ꠆ꠎ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠘꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠞꠣ ꠘꠤꠅꠔ ꠇꠞꠟꠣꠝ, ꠀꠝꠞꠣ ꠄꠇꠟꠣꠃ ꠀꠕꠤꠘꠤꠀ ꠐꠣꠃꠘꠅ ꠞꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("H13_2","082_3_2","1TH","3","2","2","ꠀꠝꠞꠣꠞ ꠜꠣꠁ ꠔꠤꠝꠕꠤꠞꠦ ꠙꠣꠑꠣꠁꠝꠥ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠉꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠝꠎꠛꠥꠔ ꠇꠞꠂꠘ ꠀꠞ ꠝꠘꠞ ꠡꠣꠅꠡ ꠎꠥꠉꠣꠁꠘ। ꠔꠣꠁꠘ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠅ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠖꠤꠝ, ꠀꠝꠞꠣꠞ ꠟꠉꠞ ꠜꠣꠁ, ꠔꠣꠘꠞꠦ ꠙꠣꠑꠣꠁꠟꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("H13_3","082_3_3","1TH","3","3","3","ꠎꠣꠔꠦ ꠅꠃ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦꠅ ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠈꠞꠦꠖꠤ ꠘꠣ ꠎꠣꠅ। ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠑꠤꠇꠃ ꠀꠁꠛ, ꠀꠞ ꠁꠔꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠣ ꠟꠣꠉꠛ। ");
INSERT INTO syls_vpl VALUES ("H13_4","082_3_4","1TH","3","4","4","ꠀꠝꠤ ꠀꠉꠦ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠍꠟꠣꠝ, ꠢꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠤ, ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠁꠛꠃ, ꠀꠞ ꠑꠤꠇꠃ ꠅꠟꠣꠈꠣꠘ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("H13_5","082_3_5","1TH","3","5","5","ꠔꠦ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠀꠞ ꠡꠁꠎ꠆ꠎ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠘꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠢꠣꠟꠔ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠤꠝꠕꠤ ꠜꠣꠁꠞꠦ ꠙꠣꠑꠣꠁꠟꠣꠝ। ꠀꠝꠣꠞ ꠝꠘꠅ ꠒꠞ ꠀꠍꠤꠟ, ꠇꠤꠎꠣꠘꠥ ꠡꠄꠔꠣꠘꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠣꠟꠌ ꠖꠦꠈꠣꠁꠍꠦ ꠀꠞ ꠀꠝꠞꠣꠞ ꠢꠇꠟ ꠝꠦꠘꠔ ꠛꠦꠇꠣꠝꠣ ꠉꠦꠍꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("H13_6","082_3_6","1TH","3","6","6","ꠅꠁꠟꠦ ꠔꠤꠝꠕꠤ ꠜꠣꠁ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠚꠤꠞꠤꠀ ꠀꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠍꠂꠘ, ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠀꠞ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠞ ꠢꠣꠟꠔ ꠛꠃꠔ ꠜꠣꠟꠣ। ꠔꠣꠁꠘ ꠇꠁꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠝꠘꠅ ꠇꠞꠅ, ꠀꠞ ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠦꠈꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠀꠝꠞꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠀꠡꠣ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H13_7","082_3_7","1TH","3","7","7","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠝꠎꠛꠥꠔꠤꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ, ꠀꠝꠞꠣꠞ ꠅꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦꠅ ꠖꠤꠟꠅ ꠡꠣꠘ꠆ꠔꠤ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("H13_8","082_3_8","1TH","3","8","8","ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠁꠟꠦꠃ, ꠀꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠈꠣꠘ ꠗꠁꠘ꠆ꠘ। ");
INSERT INTO syls_vpl VALUES ("H13_9","082_3_9","1TH","3","9","9","ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣ ꠎꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠤꠀꠞ, ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠇꠤꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠔꠣꠝ, ꠎꠣꠘꠞꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("H13_10","082_3_10","1TH","3","10","10","ꠀꠝꠞꠣ ꠝꠘ ꠖꠤꠀ ꠖꠤꠘꠦ-ꠞꠣꠁꠔꠦ ꠢꠣꠝꠦꠡꠣ ꠖꠥꠀ ꠇꠞꠞꠣꠝ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠈꠈꠣꠘ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟꠔꠣ ꠙꠥꠞꠣ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("H13_11","082_3_11","1TH","3","11","11","ꠔꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞꠦ ꠡꠥꠎꠥꠉ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("H13_12","082_3_12","1TH","3","12","12","ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠎꠦ ꠒꠥꠛꠤ ꠉꠦꠍꠤ, ꠑꠤꠇ ꠅꠃꠟꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ, ꠀꠞ ꠢꠇꠟꠞ ꠛꠣꠄ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠦ ꠢꠣꠛꠥꠒꠥꠛꠥ ꠈꠣꠅꠀꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("H13_13","082_3_13","1TH","3","13","13","ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠎꠛꠥꠔ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠀꠝꠞꠣꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠟꠁꠀ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠔꠥꠝꠞꠣ ꠙꠛꠤꠔ꠆ꠞ ꠀꠞ ꠘꠤꠈꠥꠔ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("H14_1","082_4_1","1TH","4","1","1","ꠅ ꠜꠣꠁꠀꠁꠘ ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠦꠝꠘꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠘꠤ ꠟꠣꠉꠦ, ꠁ ꠔꠣꠟꠤꠝ ꠔ ꠔꠥꠝꠞꠣ ꠀꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠉꠦꠃ ꠙꠣꠁꠍ ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠟꠣ ꠌꠟꠞꠣꠄꠅ। ꠄꠞꠛꠣꠖꠦꠅ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ ꠀꠞ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤꠀꠞ, ꠔꠥꠝꠞꠣ ꠎꠦꠟꠣ ꠌꠟꠞꠣꠄ, ꠅꠃꠟꠣ ꠀꠞꠅ ꠛꠦꠡ ꠇꠞꠤ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("H14_2","082_4_2","1TH","4","2","2","ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠖꠦꠅꠀ ꠄꠈꠔꠤꠀꠞꠦ ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("H14_3","082_4_3","1TH","4","3","3","ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠁꠞꠣ, ꠔꠥꠝꠞꠣ ꠎꠣꠘꠥ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠅ, ꠝꠣꠘꠤ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠎꠤꠘꠣ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("H14_4","082_4_4","1TH","4","4","5","ꠀꠞ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞꠦ ꠌꠤꠘꠂꠘ ꠘꠣ, ꠢꠃ ꠜꠤꠘ-ꠗꠞ꠆ꠝꠤꠞ ꠟꠣꠈꠣꠘ ꠡꠞꠤꠟꠞ ꠈꠣꠁꠡꠞ ꠛꠡꠦ ꠘꠣ ꠌꠟꠤꠀ, ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠦ ꠎꠣꠞꠎꠤꠞ ꠡꠞꠤꠟꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠞꠣꠈꠤꠀ ꠝꠣꠘ-ꠡꠝ꠆ꠝꠣꠘꠦ ꠎꠤꠘꠣ ꠕꠣꠇꠤ ꠢꠥꠡꠤꠀꠞ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("H14_6","082_4_6","1TH","4","6","6","ꠁ ꠛꠦꠙꠣꠞꠦ ꠇꠦꠃ ꠎꠣꠘꠥ ꠘꠤꠎꠞ ꠜꠣꠁꠞ ꠟꠉꠦ ꠉꠣꠖ꠆ꠖꠣꠞꠤ ꠘꠣ ꠇꠞꠦ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠞꠣ ꠀꠉꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠍꠤ ꠀꠞ ꠢꠥꠡꠤꠀꠞꠅ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠡꠣꠎꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H14_7","082_4_7","1TH","4","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ ꠘꠤ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠙꠕꠦ ꠌꠟꠣꠞ ꠟꠣꠉꠤ? ꠔꠣꠁꠘ ꠔ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠀ ꠌꠟꠣꠞ ꠟꠣꠉꠤ ꠇꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("H14_8","082_4_8","1TH","4","8","8","ꠄꠞꠟꠣꠉꠤ ꠎꠦꠉꠤꠄ ꠁ ꠔꠣꠟꠤꠝ ꠝꠣꠘꠦ ꠘꠣ, ꠢꠦ ꠈꠣꠟꠤ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠝꠣꠘꠦ ꠘꠣ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠢꠦ ꠀꠍꠟꠦ ꠢꠃ ꠀꠟ꠆ꠟꠣꠞꠦꠃ ꠝꠣꠘꠦꠞ ꠘꠣ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("H14_9","082_4_9","1TH","4","9","9","ꠔꠦ ꠜꠣꠁꠄ ꠜꠣꠁꠄ ꠇꠤꠟꠣ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠕꠣꠇꠣ ꠎꠞꠥꠞ, ꠁ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠟꠦꠈꠣꠞ ꠉꠞꠎ ꠘꠣꠁ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠤꠇꠣꠁꠍꠂꠘ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠔꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H14_10","082_4_10","1TH","4","10","10","ꠀꠞ ꠢꠣꠍꠣꠃ ꠔꠥꠝꠞꠣ ꠀꠡ꠆ꠔꠣ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠖꠦꠡꠞ ꠜꠣꠁ-ꠛꠁꠘꠞꠦ ꠅꠃꠟꠣ ꠝꠣꠄꠀ ꠇꠞꠞꠣꠄ। ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠈꠣꠍ ꠅꠘꠥꠞꠥꠗ ꠅꠁꠟ, ꠔꠥꠝꠞꠣꠞ ꠁ ꠝꠢꠛ꠆ꠛꠔ ꠎꠣꠘꠥ ꠖꠤꠘꠦ ꠖꠤꠘꠦ ꠀꠞꠅ ꠛꠣꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("H14_11","082_4_11","1TH","4","11","11","ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠀꠉꠦ ꠎꠦꠟꠣ ꠇꠁꠍꠤ, ꠅꠃ ꠇꠕꠣ ꠝꠣꠚꠤꠇ ꠡꠣꠘ꠆ꠔꠤꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠅ, ꠙꠞꠞ ꠇꠣꠝꠅ ꠘꠣꠇ ꠘꠣ ꠉꠟꠣꠁꠀ ꠘꠤꠎꠦ ꠇꠣꠝ ꠇꠞꠤꠀ ꠈꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("H14_12","082_4_12","1TH","4","12","12","ꠔꠦꠃ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞ ꠌꠈꠥꠔ ꠔꠥꠝꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠜꠖ꠆ꠞ ꠅꠁꠛ, ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠎꠘꠞ ꠞꠥꠎꠤꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠜꠞꠡꠣ ꠇꠞꠣ ꠟꠣꠉꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H14_13","082_4_13","1TH","4","13","13","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠢꠥꠘꠅ, ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠇꠥꠘ ꠢꠣꠟꠔ ꠅꠁꠛ, ꠀꠝꠞꠣ ꠌꠣꠁꠞꠣꠝ ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠎꠣꠘ, ꠎꠣꠔꠦ ꠝꠞꠘ ꠛꠣꠖꠦ ꠇꠤꠔꠣ ꠅꠁꠛ ꠁꠈꠣꠘ ꠘꠣ ꠎꠣꠘꠣꠄ ꠎꠦꠞꠣ ꠘꠤꠞꠣꠡ ꠅꠁꠎꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠝꠘ ꠎꠣꠘꠥ ꠁꠟꠣꠈꠣꠘ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("H14_14","082_4_14","1TH","4","14","14","ꠢꠥꠘꠅ, ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠄꠇꠤꠘ ꠇꠞꠤ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠝꠃꠔ ꠅꠁꠍꠤꠟ ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠍꠂꠘ, ꠔꠦ ꠄꠅꠈꠣꠘꠅ ꠄꠇꠤꠘ ꠇꠞꠤ, ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠟꠦ ꠁꠍꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠎꠦꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦꠅ ꠁꠍꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘ ꠇꠞꠤꠀ ꠔꠣꠘ ꠟꠉꠦ ꠘꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H14_15","082_4_15","1TH","4","15","15","ꠄꠞꠟꠣꠉꠤ ꠝꠣꠟꠤꠇꠞ ꠇꠣꠟꠣꠝ ꠝꠣꠚꠤꠇ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠝꠞꠣ ꠎꠦꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠤ ꠀꠞ ꠝꠣꠟꠤꠇꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁꠝꠥ, ꠀꠝꠞꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠢꠤ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠀꠉꠦ ꠎꠣꠁꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H14_16","082_4_16","1TH","4","16","16","ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠁ ꠡꠤꠋꠉꠣꠞ ꠀꠅꠀꠎꠞ ꠟꠉꠦ ꠟꠉꠦ, ꠙꠞꠗꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠒꠣꠇꠞ ꠟꠉꠦ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠎꠥꠞꠦ ꠢꠣꠃꠇꠖꠤ ꠢꠥꠇꠥꠝ ꠖꠤꠛꠣ, ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠛꠣ। ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠛꠘꠤꠀ ꠎꠦꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠞꠣꠃ ꠙꠄꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H14_17","082_4_17","1TH","4","17","17","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠞꠣ ꠎꠦꠞꠣ ꠖꠥꠘꠤꠀꠔ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠝꠥ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣꠞꠦꠅ ꠝꠦꠊꠞ ꠈꠥꠐꠤꠔ ꠇꠞꠤ ꠀꠍꠝꠣꠘꠅ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠛ। ꠅꠟꠣꠈꠣꠘ ꠀꠝꠞꠣ ꠌꠤꠞꠇꠣꠟ ꠝꠣꠟꠤꠇꠞ ꠟꠉꠦ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("H14_18","082_4_18","1TH","4","18","18","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠅꠔꠣ ꠎꠣꠘꠣꠁꠀ ꠄꠇ ꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞꠦ ꠃꠔꠡꠣꠢ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_1","082_5_1","1TH","5","1","1","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠇꠥꠘ ꠎꠝꠣꠘꠣꠔ ꠇꠥꠘ ꠡꠝꠄ ꠇꠤꠔꠣ ꠊꠐꠤꠛ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠣꠞ ꠎꠞꠥꠞ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("H15_2","082_5_2","1TH","5","2","2","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦꠃ ꠔ ꠜꠣꠟꠣ ꠇꠞꠤ ꠎꠣꠘ, ꠞꠣꠁꠔꠇꠥꠞ ꠛꠣꠟꠣ ꠎꠦꠟꠣ ꠀꠈꠔꠣꠃ ꠌꠥꠞ ꠀꠄ, ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠁꠛꠣꠞ ꠖꠤꠘꠅ ꠑꠤꠇ ꠅꠟꠣꠃ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("H15_3","082_5_3","1TH","5","3","3","ꠁ ꠎꠉꠔꠞ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠇꠁꠛꠣ, “ꠢꠇꠟꠔꠣ ꠡꠣꠘ꠆ꠔꠤ ꠅꠁꠉꠦꠍꠦ, ꠇꠥꠘꠥ ꠒꠞ-ꠜꠄ ꠘꠣꠁ,” ꠅꠃ ꠡꠝꠄ, ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠀꠞ ꠛꠦꠖꠘꠣ ꠎꠦꠟꠣ ꠀꠈꠔꠣꠃ ꠗꠞꠦ, ꠅꠃꠟꠣ ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠀꠈꠔꠣꠃ ꠅꠁꠛ। ꠔꠣꠞꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H15_4","082_5_4","1TH","5","4","4","ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠞꠣꠄ ꠘꠤ ꠎꠦꠘ, ꠢꠃ ꠖꠤꠘ ꠀꠈꠔꠣꠃ ꠌꠥꠞꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠁꠔ? ");
INSERT INTO syls_vpl VALUES ("H15_5","082_5_5","1TH","5","5","5","ꠔꠥꠝꠞꠣ ꠢꠇꠟꠃ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠞ ꠀꠞ ꠖꠤꠘꠞ ꠚꠞꠞ ꠝꠣꠘꠥꠡ। ꠀꠝꠞꠣ ꠔ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠛꠣ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣꠞ ꠝꠣꠘꠥꠡ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H15_6","082_5_6","1TH","5","6","6","ꠄꠞꠟꠣꠉꠤ ꠀꠅ, ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠞꠣ ꠘꠣ ꠊꠥꠝꠣꠁꠀ ꠛꠞꠋ ꠢꠎꠣꠉ ꠞꠁ ꠀꠞ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠤ। ");
INSERT INTO syls_vpl VALUES ("H15_7","082_5_7","1TH","5","7","7","ꠎꠣꠘ ꠔ, ꠎꠦꠞꠣ ꠊꠥꠝꠣꠄ, ꠔꠣꠞꠣ ꠞꠣꠁꠔꠞ ꠛꠣꠟꠣꠄꠃ ꠊꠥꠝꠣꠄ ꠀꠞ ꠎꠦꠞꠣ ꠝꠖꠈꠥꠞ, ꠞꠣꠁꠔ ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠝꠖ ꠈꠣꠁꠀ ꠐꠣꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("H15_8","082_5_8","1TH","5","8","8","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠔ ꠖꠤꠘꠞ ꠚꠞꠞ ꠝꠣꠘꠥꠡ, ꠄꠞꠟꠣꠉꠤ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠤ। ꠀꠝꠞꠣꠞ ꠛꠥꠇ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠝꠣꠘ ꠀꠞ ꠝꠢꠛ꠆ꠛꠔ ꠖꠤꠀ ꠛꠥꠇ ꠉꠥꠞꠤ, ꠀꠞ ꠝꠣꠕꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠁ ꠘꠣꠎꠣꠔꠞ ꠀꠡꠣꠞꠦ ꠍꠤꠙꠣꠁꠞ ꠇꠦꠙꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠕꠣꠔ ꠟꠣꠉꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("H15_9","082_5_9","1TH","5","9","9","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠒꠣꠇꠤꠀ ꠀꠘꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠘꠣꠎꠣꠔ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤꠃ ꠒꠣꠇꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("H15_10","082_5_10","1TH","5","10","10","ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠃꠔ ꠅꠁꠍꠦ ꠔ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤꠃ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠛꠣꠌꠤ ꠛꠣ ꠝꠞꠤ, ꠔꠣꠘ ꠟꠉꠦꠃ ꠢꠣꠝꠦꠡꠣ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("H15_11","082_5_11","1TH","5","11","11","ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠎꠦꠟꠣ ꠇꠞꠞꠣꠄ, ꠢꠣꠝꠦꠡꠣ ꠅꠟꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠡꠣꠅꠡ ꠖꠦꠅ ꠀꠞ ꠉꠠꠤꠀ ꠔꠥꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_12","082_5_12","1TH","5","12","12","ꠔꠦ ꠜꠣꠁꠀꠁꠘ, ꠀꠝꠞꠣ ꠝꠤꠘꠔ ꠇꠞꠤꠀ ꠇꠁꠀꠞ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠞꠣ ꠀꠐꠘꠤ-ꠈꠣꠐꠘꠤ ꠈꠣꠐꠂꠘ, ꠝꠣꠟꠤꠇꠞ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠌꠣꠟꠣꠁꠘ ꠀꠞ ꠘꠍꠤꠅꠔ ꠇꠞꠂꠘ, ꠔꠥꠝꠞꠣ ꠄꠞꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_13","082_5_13","1TH","5","13","13","ꠔꠣꠞꠣ ꠎꠦꠟꠣ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣ, ꠅꠔꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠖꠤꠟꠞ ꠝꠢꠛ꠆ꠛꠔꠦ ꠔꠣꠞꠣꠞꠦ ꠈꠣꠍ ꠁꠎ꠆ꠎꠔ ꠖꠤꠅ। ꠀꠞ ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠤꠟꠤ-ꠝꠤꠡꠤ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_14","082_5_14","1TH","5","14","14","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠘꠍꠤꠅꠔꠈꠣꠘ ꠇꠞꠤꠀꠞ, ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠇꠥꠠꠤꠀ, ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤ ꠖꠦꠅ, ꠒꠞꠣꠟꠥꠇ ꠎꠘꠞꠦ ꠡꠣꠅꠡ ꠖꠦꠅ, ꠇꠝꠎꠥꠞ ꠅꠇꠟꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠅ, ꠀꠞ ꠗꠂꠎ꠆ꠎ ꠗꠞꠤꠀ ꠢꠇ꠆ꠇꠟꠞꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_15","082_5_15","1TH","5","15","15","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠅꠁꠘ꠆ꠘꠣꠄꠞ ꠛꠖꠟꠣ ꠇꠦꠃ ꠎꠣꠘꠥ ꠅꠁꠘ꠆ꠘꠣꠄ ꠘꠣ ꠇꠞꠦ। ꠔꠥꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ, ꠀꠞ ꠢꠇꠟꠞꠃ ꠜꠣꠟꠣꠁ ꠇꠞꠣꠞ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_16","082_5_16","1TH","5","16","16","ꠢꠇꠟ ꠡꠝꠄ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠣꠔ ꠞꠁꠅ, ");
INSERT INTO syls_vpl VALUES ("H15_17","082_5_17","1TH","5","17","17","ꠢꠣꠝꠦꠡꠣ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠤꠅ ");
INSERT INTO syls_vpl VALUES ("H15_18","082_5_18","1TH","5","18","18","ꠀꠞ ꠢꠇꠟ ꠢꠣꠟꠔꠅ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠅ। ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠈꠤꠀꠟ ꠅꠁꠟ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠁꠝꠣꠘꠦ ꠔꠥꠝꠞꠣ ꠅꠟꠣꠈꠣꠘ ꠌꠟ। ");
INSERT INTO syls_vpl VALUES ("H15_19","082_5_19","1TH","5","19","19","ꠙꠣꠇ ꠞꠥꠢꠥꠞꠦ ꠖꠤꠟꠞ ꠜꠤꠔꠞ ꠕꠣꠇꠤ ꠘꠤꠜꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("H15_20","082_5_20","1TH","5","20","20","ꠀꠞ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠅꠟꠤ ꠢꠤꠡꠣꠛꠦ ꠛꠣꠔꠥꠘꠤ ꠇꠂꠘ, ꠔꠣꠞꠣꠞ ꠇꠕꠣꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠤꠅ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("H15_21","082_5_21","1TH","5","21","21","ꠛꠞꠋ ꠢꠇꠟꠔꠣ ꠎꠣꠌꠣꠁ ꠇꠞꠤ ꠖꠦꠈꠤꠀ, ꠜꠣꠟꠣꠈꠣꠘ ꠜꠤꠔꠞꠦ ꠢꠣꠞꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_22","082_5_22","1TH","5","22","22","ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_23","082_5_23","1TH","5","23","23","ꠡꠣꠘ꠆ꠔꠤ ꠖꠦꠅꠞꠣ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠣꠟꠅ ꠔꠥꠝꠞꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟ, ꠞꠥꠢꠥ ꠀꠞ ꠖꠤꠟꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠞꠣꠈꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("H15_24","082_5_24","1TH","5","24","24","ꠀꠞ ꠔꠣꠁꠘ ꠘꠤꠌ꠆ꠌꠤꠔ ꠅꠟꠣꠃ ꠇꠞꠛꠣ। ꠎꠣꠘ ꠔ, ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠔꠣꠘ ꠃꠙꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠜꠞꠡꠣ ꠇꠞꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H15_25","082_5_25","1TH","5","25","25","ꠅ ꠜꠣꠁꠀꠁꠘ, ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_26","082_5_26","1TH","5","26","26","ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠙꠛꠤꠔ꠆ꠞ ꠉꠟꠣꠉꠟꠤ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("H15_27","082_5_27","1TH","5","27","27","ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠘꠣꠝꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠅꠃ ꠌꠤꠑꠤꠈꠣꠘ ꠙꠠꠤꠀ ꠎꠣꠘꠥ ꠢꠇꠟ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠢꠥꠘꠣꠁꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("H15_28","082_5_28","1TH","5","28","28","ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("H21_1","083_1_1","2TH","1","1","1","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠡꠞꠤꠇ, ꠕꠤꠡꠟꠘꠤꠇꠤ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ, ꠜꠣꠁ ꠍꠤꠟꠣꠍ ꠀꠞ ꠔꠤꠝꠕꠤꠄ ꠅꠃ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("H21_2","083_1_2","2TH","1","2","2","ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("H21_3","083_1_3","2TH","1","3","3","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠣ ꠎꠞꠥꠞ। ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠤ ꠛꠟ ꠛꠃꠔ ꠛꠣꠠꠦꠞ ꠀꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠅ ꠛꠣꠁꠀ ꠙꠠꠦꠞ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠣ ꠖꠞꠇꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("H21_4","083_1_4","2TH","1","4","4","ꠀꠝꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠛꠠꠣꠁ ꠇꠞꠤꠀꠞ, ꠇꠣꠞꠘ ꠅꠔ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠀꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠙꠣꠁꠀꠅ ꠔꠥꠝꠞꠣ ꠍꠛꠞ ꠇꠞꠍ ꠀꠞ ꠁꠝꠣꠘꠦ ꠐꠤꠇꠤꠀ ꠞꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("H21_5","083_1_5","2TH","1","5","5","ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠎꠁꠉ꠆ꠉ ꠇꠁꠀ ꠉꠘꠣ ꠅꠄ, ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣ ꠅꠔ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠞꠣꠄ, ꠁꠔꠣ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇ-ꠁꠘꠍꠣꠚꠞ ꠙꠞꠝꠣꠘ, ");
INSERT INTO syls_vpl VALUES ("H21_6","083_1_6","2TH","1","6","6","ꠔꠣꠘ ꠢꠇ-ꠁꠘꠍꠣꠚ ꠅꠁꠟ, ꠎꠦꠔꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠡ꠆ꠐ ꠖꠦꠁꠘ, ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠇꠡ꠆ꠐ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H21_7","083_1_7","2TH","1","7","8","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠅꠈꠘ ꠇꠡ꠆ꠐ ꠙꠣꠁꠞꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠁ ꠇꠡ꠆ꠐ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠖꠤꠛꠣ। ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠡꠇ꠆ꠔꠤꠡꠣꠟꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠟꠁꠀ, ꠎꠣꠟꠣꠁꠟ ꠀꠉꠥꠘꠤꠞ ꠇꠥꠘ꠆ꠒꠟꠤꠔ ꠅꠁꠀ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠅꠃꠟꠣ ꠅꠁꠛ। ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞꠦ ꠌꠤꠘꠦ ꠘꠣ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠇꠕꠣ ꠝꠣꠘꠦ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠁꠔꠣꠞꠦ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H21_9","083_1_9","2TH","1","9","9","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣꠞꠦ ꠅꠝꠘ ꠡꠣꠎꠣ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠔꠣꠘ ꠖꠤꠖꠣꠞꠞ ꠀꠞ ꠝꠢꠣ ꠇꠥꠖꠞꠔꠤꠞ ꠛꠣꠞꠦ ꠙꠠꠤꠀ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠟꠣꠘ꠆ꠘꠔꠤ ꠡꠣꠎꠣ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("H21_10","083_1_10","2TH","1","10","10","ꠢꠃ ꠖꠤꠘ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠎꠦꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍꠦ ꠔꠣꠞꠣꠞ ꠝꠣꠎꠖꠤ, ꠔꠣꠘ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠁꠛ। ꠄꠞꠣꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠅ ꠀꠍ, ꠇꠣꠞꠘ ꠀꠝꠞꠣꠞ ꠔꠛꠟꠤꠉ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍ। ");
INSERT INTO syls_vpl VALUES ("H21_11","083_1_11","2TH","1","11","11","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤ, ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠖꠣꠅꠔꠞ ꠎꠥꠇꠣ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠔꠣꠘ ꠈꠦꠝꠔꠣꠞ ꠛꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠘꠦꠇ ꠇꠣꠝꠞ ꠀꠡꠣ ꠙꠥꠞꠘ ꠇꠞꠂꠘ, ꠀꠞ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠢꠣꠞꠤ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠞꠣꠄ, ꠁ ꠇꠣꠝꠅ ꠎꠣꠘꠥ ꠔꠣꠁꠘ ꠙꠥꠞꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("H21_12","083_1_12","2TH","1","12","12","ꠔꠦꠃ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔꠞ ꠟꠣꠉꠤ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠉꠃꠞꠛ ꠎꠣꠁꠞ ꠅꠁꠛ, ꠀꠞ ꠔꠣꠘ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣꠅ ꠉꠃꠞꠛꠞ ꠜꠣꠉꠤ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H22_1","083_2_1","2TH","2","1","1","ꠅ ꠜꠣꠁ ꠅꠇꠟ ꠢꠥꠘꠅ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠔ ꠢꠤꠞꠛꠣꠞ ꠀꠁꠛꠣ, ꠀꠁꠀ ꠀꠝꠞꠣ ꠢꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠤꠀ ꠔꠣꠘ ꠉꠦꠍꠦ ꠘꠤꠛꠣ। ꠔꠦ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠞꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("H22_2","083_2_2","2TH","2","2","2","ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠁꠀ ꠇꠄ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠖꠤꠘ ꠀꠁꠀ ꠢꠣꠞꠍꠦ, ꠢꠦ ꠇꠥꠘꠥ ꠉꠣꠁꠛꠤ ꠖꠞꠡꠘ ꠖꠦꠈꠍꠦ, ꠛꠣ ꠅꠢꠤ ꠘꠣꠎꠤꠟ ꠅꠁꠍꠦ, ꠛꠣ ꠀꠝꠞꠣꠞ ꠟꠦꠈꠣ ꠌꠤꠑꠤ ꠝꠘꠅ ꠇꠞꠤꠀꠅ ꠔꠥꠝꠞꠣ ꠒꠞꠣꠁꠀ ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("H22_3","083_2_3","2TH","2","3","3","ꠇꠦꠃ ꠎꠣꠘꠥ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠐꠉꠤꠀ ꠁꠝꠣꠘ ꠟꠥꠐꠤꠔ ꠘꠣ ꠙꠣꠞꠦ। ꠇꠣꠞꠘ ꠢꠃ ꠖꠤꠘ ꠀꠅꠀꠞ ꠀꠉꠦ ꠛꠦꠡꠤꠞ ꠜꠣꠉ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠣꠁꠛ, ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠢꠞꠤꠎꠤꠛ, ꠀꠞ ꠖꠥꠎꠈꠤ ꠎꠘ, ꠢꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠈꠣꠘꠦ-ꠖꠞ꠆ꠎꠣꠟ ꠛꠣꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("H22_4","083_2_4","2TH","2","4","4","ꠛꠣꠞ ꠅꠁꠀ “ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ” ꠎꠔꠔꠣ ꠀꠍꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠀꠞ ꠄꠛꠣꠖꠔꠤ ꠇꠞꠣꠞ ꠎꠥꠇꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠉꠤꠀ, ꠢꠦ ꠘꠤꠎꠞꠦ ꠛꠠ ꠝꠘꠅ ꠇꠞꠛ। ꠢꠦ ꠅꠟꠣꠅ ꠇꠞꠛ, ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠔ ꠛꠁꠀ ꠘꠤꠎꠞꠦ ꠀꠟ꠆ꠟꠣ ꠇꠁꠀ ꠖꠣꠛꠤ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("H22_5","083_2_5","2TH","2","5","5","ꠔꠦ ꠀꠝꠤ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠞꠁꠔꠣꠝ, ꠢꠃ ꠡꠝꠄ ꠀꠝꠤ ꠁ ꠛꠦꠙꠣꠞꠦ ꠝꠣꠔꠔꠣꠝ, ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠅ ꠅꠞ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("H22_6","083_2_6","2TH","2","6","6","ꠢꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠎꠣꠔꠦ ꠡꠝꠄ ꠙꠥꠞꠣ ꠅꠀꠞ ꠀꠉꠦ ꠛꠣꠞ ꠅꠁꠔ ꠘꠣ ꠙꠣꠞꠦ, ꠄꠞꠟꠣꠉꠤ ꠇꠤꠔꠣꠄ ꠔꠣꠞꠦ ꠀꠐꠇꠣꠁꠀ ꠞꠣꠈꠍꠦ, ꠁꠈꠣꠘ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠃ। ");
INSERT INTO syls_vpl VALUES ("H22_7","083_2_7","2TH","2","7","7","ꠔꠥꠝꠞꠣ ꠄꠅꠈꠣꠘꠅ ꠎꠣꠘ, ꠢꠃ ꠘꠣꠚꠞꠝꠣꠘꠞ ꠟꠥꠇꠣꠁꠟ ꠇꠣꠝ-ꠇꠣꠎ ꠅꠈꠘꠅ ꠌꠟꠦꠞ। ꠅꠁꠟꠦ ꠎꠦꠁꠘ ꠔꠣꠞꠦ ꠀꠐꠇꠣꠁꠀ ꠞꠣꠈꠞꠣ, ꠔꠣꠁꠘ ꠢꠞꠤꠀ ꠎꠣꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠦ ꠀꠐꠇꠣꠘꠤꠔ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H22_8","083_2_8","2TH","2","8","8","ꠔꠣꠁꠘ ꠢꠞꠤ ꠉꠦꠟꠦ ꠢꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠈꠣꠘꠦ-ꠖꠞ꠆ꠎꠣꠟ ꠛꠣꠞ ꠅꠁꠛ। ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠝꠥꠈꠖꠤ ꠚꠥ ꠖꠤꠀ ꠔꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠛꠣ, ꠀꠞ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣꠄ ꠀꠎꠤꠞ ꠅꠁꠀ ꠔꠣꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤꠞꠦ ꠈꠔꠝ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H22_9","083_2_9","2TH","2","9","9","ꠢꠤ ꠈꠣꠘꠦ-ꠖꠞ꠆ꠎꠣꠟ ꠎꠦꠛꠟꠣ ꠀꠁꠛ, ꠔꠣꠞ ꠟꠉꠦ ꠞꠁꠛ ꠡꠄꠔꠣꠘꠤ ꠈꠦꠝꠔꠣ। ꠅꠃ ꠡꠄꠔꠣꠘꠤ ꠈꠦꠝꠔꠣꠄ ꠢꠦ ꠢꠇꠟ ꠝꠤꠍꠣ ꠇꠦꠞꠣꠝꠔꠤ ꠀꠞ ꠝꠥꠎꠦꠎꠣ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("H22_10","083_2_10","2TH","2","10","10","ꠔꠣꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠦꠁꠝꠣꠘꠤ ꠈꠣꠐꠣꠁꠀ ꠛꠦꠁꠝꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠐꠉꠤꠛ। ꠁꠔꠣ ꠝꠣꠘꠥꠡ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛꠣ, ꠇꠣꠞꠘ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠦ ꠘꠣ, ꠀꠞ ꠇꠛꠥꠟꠅ ꠇꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("H22_11","083_2_11","2TH","2","11","11","ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠡꠇ꠆ꠔꠤꠡꠣꠟꠤ ꠄꠇ ꠇꠥ-ꠗꠣꠘ꠆ꠖꠣꠔ ꠚꠣꠟꠣꠁꠛꠣ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠝꠤꠍꠣ ꠛꠦꠙꠣꠞꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("H22_12","083_2_12","2TH","2","12","12","ꠄꠔꠦ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠘꠣ ꠀꠘꠤꠀ ꠎꠦꠔꠣꠄ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠔꠣꠞꠣꠞꠦ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("H22_13","083_2_13","2TH","2","13","13","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠅ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠝꠣꠄꠀꠞ ꠎꠘ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠣ ꠖꠞꠇꠣꠞ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠛꠣꠍꠤꠀ ꠀꠟꠉ ꠇꠞꠍꠂꠘ ꠘꠣꠎꠣꠔ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ। ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠣꠞ ꠝꠣꠎꠖꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠢꠇꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠔꠥꠝꠞꠣ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("H22_14","083_2_14","2TH","2","14","14","ꠀꠝꠞꠣ ꠎꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠤ, ꠄꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠘꠣꠎꠣꠔ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠢꠤꠝꠣꠔ ꠡꠞꠤꠇ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("H22_15","083_2_15","2TH","2","15","15","ꠔꠦ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘꠦ ꠕꠤꠞ ꠞꠅ ꠀꠞ ꠝꠥꠈꠦ ꠝꠥꠈꠦ ꠛꠣ ꠌꠤꠑꠤꠞ ꠝꠣꠞꠚꠔꠦ ꠀꠝꠞꠣ ꠎꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠤ, ꠁꠔꠣ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("H22_16","083_2_16","2TH","2","16","17","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠞ ꠡ꠆ꠛꠄꠅꠋ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠘꠦꠇ ꠃꠔꠡꠣꠢ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠦꠇ ꠇꠣꠝ ꠀꠞ ꠝꠣꠔ-ꠇꠕꠣꠞ ꠝꠣꠎꠦ ꠕꠤꠞ ꠞꠣꠈꠃꠇ꠆ꠇꠣ। ꠔꠣꠁꠘꠃ ꠀꠝꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠞꠢꠝ ꠇꠞꠤꠀ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠃꠔꠡꠣꠢ ꠀꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠞ ꠀꠡꠣ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("H23_1","083_3_1","2TH","3","1","1","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠢꠦꠡ-ꠝꠦꠡ ꠇꠁꠞꠣꠝ, ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤꠅ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠟꠣ ꠎꠟꠖꠤ ꠎꠟꠖꠤ ꠍꠤꠔ꠆ꠞꠤꠍꠤꠟ, ꠅꠃꠟꠣ ꠎꠣꠘꠥ ꠖꠤꠘ ꠖꠤꠘ ꠍꠤꠔ꠆ꠞꠣꠔ ꠞꠄ ꠀꠞ ꠉꠃꠞꠛ ꠙꠣꠅꠀꠔ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("H23_2","083_3_2","2TH","3","2","2","ꠀꠞ ꠅꠃ ꠖꠥꠀꠈꠣꠘꠅ ꠇꠞꠤꠅ, ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠛꠤꠛꠦꠇ ꠍꠣꠠꠣ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠀꠔ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁ। ꠡꠛ ꠝꠣꠘꠥꠡ ꠔ ꠀꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H23_3","083_3_3","2TH","3","3","3","ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠔ ꠢꠇ ꠀꠞ ꠈꠣꠐꠤ, ꠔꠣꠁꠘꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠝꠣꠘꠦ ꠕꠤꠞ ꠞꠣꠈꠛꠣ ꠀꠞ ꠡꠄꠔꠣꠘꠞ ꠀꠔ ꠕꠣꠇꠤ ꠢꠣꠝꠦꠡꠣ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("H23_4","083_3_4","2TH","3","4","4","ꠝꠣꠟꠤꠇꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠞꠣꠞ ꠁ ꠄꠇꠤꠘ ꠀꠍꠦ, ꠀꠝꠞꠣ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠤ, ꠔꠥꠝꠞꠣ ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠞꠣꠄ ꠀꠞ ꠇꠞꠣꠔ ꠞꠁꠛꠣꠄꠅ। ");
INSERT INTO syls_vpl VALUES ("H23_5","083_3_5","2TH","3","5","5","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠙꠕꠦ ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠛꠞꠞ ꠙꠕꠦ ꠌꠣꠟꠥ ꠞꠣꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("H23_6","083_3_6","2TH","3","6","6","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠞꠣꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠎꠝꠣꠔꠞ ꠇꠥꠘꠥ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁꠄ ꠎꠥꠖꠤ ꠇꠥꠠꠤꠀꠝꠤ ꠇꠞꠦ ꠀꠞ ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠤ, ꠁꠔꠣ ꠘꠣ ꠝꠣꠘꠦ, ꠔꠦ ꠔꠣꠞ ꠟꠉꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("H23_7","083_3_7","2TH","3","7","7","ꠢꠥꠘꠅ, ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠦꠝꠘꠦ ꠌꠟꠔꠣꠄ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘꠃ। ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠔꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠔ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠥꠠꠤꠀꠝꠤ ꠇꠞꠍꠤ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("H23_8","083_3_8","2TH","3","8","8","ꠝꠣꠉꠘꠣ ꠇꠥꠘꠥ ꠈꠣꠘꠤ ꠈꠣꠁꠍꠤ ꠘꠣ। ꠀꠝꠞꠣ ꠖꠤꠘꠦ-ꠞꠣꠁꠔꠦ ꠝꠦꠘꠔ ꠇꠞꠤꠀ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞ ꠇꠞꠍꠤ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠦꠃꠞꠞ ꠛꠥꠏꠣ ꠘꠣ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("H23_9","083_3_9","2TH","3","9","9","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠎꠦꠘ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠡꠣꠁꠎ꠆ꠎ ꠘꠤꠛꠣꠞ ꠅꠗꠤꠇꠣꠞ ꠘꠣꠁ, ꠁꠟꠣ ꠔ ꠘꠣꠄ, ꠔꠣ-ꠅ ꠀꠝꠞꠣ ꠅꠟꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠣꠁꠍꠤ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠌꠟ। ");
INSERT INTO syls_vpl VALUES ("H23_10","083_3_10","2TH","3","10","10","ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠕꠣꠇꠣꠞ ꠇꠣꠟꠅ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠟꠣꠝ, ꠇꠥꠘꠥ ꠎꠘꠦ ꠎꠥꠖꠤ ꠇꠣꠝ ꠇꠞꠔ ꠘꠣ ꠌꠣꠄ, ꠔꠦ ꠢꠦ ꠈꠣꠘꠤꠅ ꠛꠣꠖ ꠖꠤꠟꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("H23_11","083_3_11","2TH","3","11","11","ꠀꠝꠞꠣ ꠅꠈꠘꠅ ꠢꠥꠘꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠇꠦꠃ ꠇꠥꠠꠤꠀꠝꠤ ꠇꠞꠦꠞ ꠀꠞ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠦꠞ ꠘꠣ, ꠛꠞꠋ ꠢꠣꠝꠦꠡꠣ ꠙꠞꠞ ꠇꠤꠌ꠆ꠍꠣ ꠉꠣꠁꠀ ꠖꠤꠘ ꠇꠣꠐꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H23_12","083_3_12","2TH","3","12","12","ꠔꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠅꠁꠀ ꠁꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠘꠍꠤꠅꠔ ꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠡꠣꠘ꠆ꠔꠤ ꠅꠁꠀ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞ ꠇꠞꠤꠀ ꠈꠣꠄ, ꠀꠞ ꠘꠤꠎꠞ ꠈꠣꠘꠤ ꠘꠤꠎꠦ ꠎꠥꠉꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("H23_13","083_3_13","2TH","3","13","13","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠘꠦꠇ ꠇꠣꠝꠅ ꠢꠦꠞꠣꠘ ꠅꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("H23_14","083_3_14","2TH","3","14","14","ꠅꠃ ꠌꠤꠑꠤꠞ ꠜꠣꠡꠣꠄ ꠟꠦꠈꠣ ꠀꠝꠞꠣꠞ ꠙꠞꠣꠝꠤꠡ ꠎꠥꠖꠤ ꠇꠦꠃ ꠘꠣ ꠝꠣꠘꠦ, ꠔꠦ ꠔꠣꠞꠦ ꠌꠤꠘꠤꠀ ꠞꠣꠈꠅ, ꠔꠣꠞ ꠟꠉꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠅ, ꠔꠦꠃ ꠢꠦ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("H23_15","083_3_15","2TH","3","15","15","ꠅꠁꠟꠦ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠔꠣꠞꠦ ꠖꠥꠡꠝꠘ ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠜꠣꠁ ꠢꠤꠡꠣꠛꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("H23_16","083_3_16","2TH","3","16","16","ꠡꠣꠘ꠆ꠔꠤ ꠖꠦꠅꠞꠣ ꠝꠣꠟꠤꠇꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠣꠝꠦꠡꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("H23_17","083_3_17","2TH","3","17","17","ꠢꠥꠘꠅ, ꠁ ꠍꠣꠟꠣꠝꠞ ꠇꠕꠣ ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠘꠤꠎꠞ ꠀꠔꠦ ꠟꠦꠈꠍꠤ। ꠅꠇꠐꠣꠃ ꠀꠝꠣꠞ ꠙꠞꠔꠦꠇ ꠌꠤꠑꠤꠞ ꠀꠟꠣꠝꠔ, ꠀꠝꠤ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠌꠤꠑꠤ ꠟꠦꠈꠤ। ");
INSERT INTO syls_vpl VALUES ("H23_18","083_3_18","2TH","3","18","18","ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔ ꠎꠣꠞꠤ ꠞꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("T11_1","084_1_1","1TI","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ ꠔ ꠀꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠀꠝꠞꠣꠞ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠢꠥꠇꠥꠝꠦ ꠔꠣꠘ ꠍꠣꠢꠣꠛꠤ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("T11_2","084_1_2","1TI","1","2","2","ꠝꠥꠝꠤꠘ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠣꠞ ꠈꠣꠍ ꠀꠅꠟꠣꠖ, ꠔꠤꠝꠕꠤꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠣꠞꠦ ꠞꠢꠝꠔ, ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("T11_3","084_1_3","1TI","1","3","3","ꠅ ꠔꠤꠝꠕꠤ, ꠀꠝꠤ ꠝꠣꠇꠤꠖꠘꠤꠀ ꠖꠦꠡꠅ ꠎꠣꠅꠀꠞ ꠛꠣꠟꠣ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠍꠟꠣꠝ, ꠅꠈꠘ ꠢꠤꠞꠛꠣꠞ ꠝꠤꠘꠔꠤ ꠇꠞꠤ ꠇꠁꠞꠣꠝ, ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠁꠚꠤꠍ ꠐꠣꠃꠘꠅꠃ ꠞꠅ, ꠞꠁꠀ ꠅꠘꠞ ꠅꠟꠣ ꠇꠤꠍꠥ ꠝꠥꠟ꠆ꠟꠣꠁꠘ꠆ꠔꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠀꠞ ꠜꠥꠟ ꠔꠣꠟꠤꠝ ꠘꠣ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("T11_4","084_1_4","1TI","1","4","4","ꠔꠣꠞꠣꠞꠦ ꠇꠁꠅ, ꠔꠣꠞꠣ ꠎꠣꠔꠦ ꠛꠣꠘꠥꠀꠐ ꠇꠤꠌ꠆ꠍꠣ ꠀꠞ ꠟꠣꠝ꠆ꠛꠣ ꠟꠣꠝ꠆ꠛꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠟꠤꠡ꠆ꠐꠞ ꠛꠣꠄ ꠈꠤꠀꠟꠤ ꠘꠣ ꠅꠁꠘ। ꠁꠔꠣꠄ ꠔ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠖꠟꠣꠖꠟꠤꠞ ꠎꠘꠝ ꠖꠦꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠝꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠄ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠁ ꠚꠣꠄꠖꠣ ꠝꠤꠟꠦ ꠈꠣꠟꠤ ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ। ");
INSERT INTO syls_vpl VALUES ("T11_5","084_1_5","1TI","1","5","5","ꠛꠞꠋ ꠡꠑꠤꠇ ꠔꠣꠟꠤꠝꠞ ꠚꠟ ꠅꠁꠟ, ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ, ꠁꠔꠣ ꠔ ꠈꠣꠐꠤ ꠖꠤꠟ, ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠛꠤꠛꠦꠇ ꠀꠞ ꠢꠣꠍꠣꠞꠞ ꠁꠝꠣꠘ ꠕꠣꠇꠤ ꠙꠄꠖꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("T11_6","084_1_6","1TI","1","6","6","ꠅꠁꠟꠦ ꠇꠤꠍꠥ ꠝꠣꠘꠡꠦ ꠁꠔꠣ ꠛꠣꠖ ꠖꠤꠀ ꠛꠣꠘꠥꠀꠐ ꠝꠣꠔ-ꠇꠕꠣꠞ ꠛꠣꠄ ꠝꠘ ꠖꠤꠟꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T11_7","084_1_7","1TI","1","7","7","ꠔꠣꠞꠣ ꠎꠥꠖꠤꠅ ꠘꠤꠎꠦꠃ ꠘꠤꠎꠞ ꠝꠣꠔꠞ ꠝꠣꠘꠤ ꠛꠥꠎꠦ ꠘꠣ, ꠀꠞ ꠎꠦ ꠛꠦꠙꠣꠞ ꠟꠁꠀ ꠛꠠ ꠉꠟꠣꠄ ꠝꠣꠔꠦꠞ, ꠁ ꠛꠦꠙꠣꠞꠦꠅ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠎꠣꠘꠦ ꠘꠣ, ꠔꠦꠛꠃ ꠔꠣꠞꠣ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠛꠣꠔꠣꠁꠟ ꠡꠞꠤꠅꠔꠞ ꠃꠡ꠆ꠔꠣꠖ ꠅꠁꠔ ꠌꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T11_8","084_1_8","1TI","1","8","8","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠡꠞꠤꠅꠔ ꠜꠣꠟꠣ ꠎꠤꠘꠤꠡ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠑꠤꠇ ꠝꠔ ꠁꠔꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T11_9","084_1_9","1TI","1","9","9","ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠁ ꠡꠞꠤꠅꠔ ꠇꠥꠘꠥ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ ꠘꠣ। ꠁꠈꠣꠘ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠎꠦꠔꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠀꠁꠘ ꠝꠣꠘꠂꠘ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠁꠘ ꠘꠣ, ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠂꠘ, ꠉꠥꠘꠣꠉꠣꠞ, ꠈꠥꠘꠤ, ꠘꠣꠙꠣꠇ ꠀꠞ ꠛꠦ-ꠖꠤꠘ, ꠝꠣ-ꠛꠣꠚꠞ ꠈꠥꠘꠤ, ");
INSERT INTO syls_vpl VALUES ("T11_10","084_1_10","1TI","1","10","11","ꠎꠤꠘꠣꠇꠥꠞ, ꠡꠝꠇꠣꠝꠤ, ꠛꠣꠘ꠆ꠖꠤ-ꠉꠥꠟꠣꠝꠞ ꠇꠣꠞꠛꠣꠞꠤ, ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣ, ꠝꠤꠍꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠅꠞꠣ, ꠄꠇ ꠇꠕꠣꠄ ꠉꠥꠘꠉꠣꠘꠦ ꠗꠘꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠢꠣꠘ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠔꠣꠟꠤꠝꠞ ꠛꠤꠞꠥꠗꠤ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ, ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠁ ꠡꠞꠤꠅꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠀꠞ ꠅꠃ ꠝꠢꠣꠘ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠜꠣꠞ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T11_12","084_1_12","1TI","1","12","12","ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ, ꠎꠦꠁꠘ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠟ ꠎꠥꠉꠣꠁꠍꠂꠘ, ꠀꠝꠣꠞꠦ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠣꠘ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("T11_13","084_1_13","1TI","1","13","13","ꠎꠥꠖꠤꠅ ꠀꠝꠤ ꠀꠉꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠔꠣꠝ, ꠔꠣꠘ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠔꠣꠝ, ꠛꠖ-ꠝꠤꠎꠣꠎ ꠖꠦꠈꠣꠁꠔꠣꠝ। ꠔꠣ-ꠅ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠞꠢꠝꠔ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠇꠣꠞꠘ ꠢꠃ ꠡꠝꠄ ꠀꠝꠤ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T11_14","084_1_14","1TI","1","14","14","ꠀꠝꠞꠣꠞ ꠝꠥꠘꠤꠛꠦ ꠀꠝꠣꠞꠦ ꠇꠔ ꠛꠠ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠇꠞꠍꠂꠘ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣ ꠇꠛꠥꠟ ꠇꠞꠟꠦ ꠎꠦ ꠁꠝꠣꠘ ꠀꠞ ꠝꠢꠛ꠆ꠛꠔ ꠙꠄꠖꠣ ꠅꠄ, ꠁꠔꠣ ꠔ ꠀꠝꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T11_15","084_1_15","1TI","1","15","15","ꠀꠍꠟꠦ ꠁ ꠇꠕꠣ ꠔ ꠢꠇ-ꠈꠣꠐꠤ ꠀꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠝꠣꠘꠣꠞ ꠟꠣꠈ, ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠁ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠍꠤꠟꠣ। ꠅꠃ ꠉꠥꠘꠣꠉꠣꠞꠞ ꠝꠣꠎꠦ ꠀꠝꠤꠃ ꠙꠞꠗꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("T11_16","084_1_16","1TI","1","16","16","ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠀꠝꠣꠞ ꠝꠔ ꠙꠞꠗꠣꠘ ꠉꠥꠘꠣꠉꠣꠞꠞ ꠝꠣꠎꠖꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠣꠘ ꠡꠤꠝꠣ ꠍꠣꠠꠣ ꠍꠛꠞꠉꠣꠞꠤ ꠖꠦꠈꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ, ꠀꠞ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠎꠦꠞꠣ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛꠣ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠤꠀ ꠀꠟ꠆ꠟꠣꠁ ꠙꠕ ꠛꠥꠎꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T11_17","084_1_17","1TI","1","17","17","ꠎꠦꠁꠘ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠛꠣꠖꠡꠣ, ꠎꠦꠁꠘ ꠘꠤꠞꠣꠇꠣꠞ, ꠄꠇꠝꠣꠔ꠆ꠞ ꠀꠟ꠆ꠟꠣ, ꠎꠣꠘ ꠇꠥꠘꠥ ꠇ꠆ꠇꠄ ꠘꠣꠁ, ꠔꠣꠘ ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠉꠃꠞꠛ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠣꠞꠤ ꠞꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("T11_18","084_1_18","1TI","1","18","18","ꠅ ꠝꠣꠄꠀꠞ ꠙꠥꠔ ꠔꠤꠝꠕꠤ, ꠔꠥꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠉꠦ ꠎꠦꠔꠣ ꠛꠣꠔꠥꠘꠤ ꠝꠣꠔ ꠝꠣꠔꠣ ꠅꠁꠍꠤꠟ, ꠅꠃ ꠝꠣꠚꠤꠇ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠁꠔꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠔ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("T11_19","084_1_19","1TI","1","19","19","ꠄꠞꠟꠉꠦ ꠘꠤꠎꠞ ꠁꠝꠣꠘ ꠀꠞ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠛꠤꠛꠦꠇꠞꠦ ꠛꠣꠌꠣꠁꠅ। ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠛꠤꠛꠦꠇꠞ ꠛꠥꠟꠤ ꠘꠣ ꠝꠣꠘꠤꠀ, ꠘꠤꠎꠞ ꠁꠝꠣꠘꠞꠦ ꠘꠡ꠆ꠐ ꠇꠞꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T11_20","084_1_20","1TI","1","20","20","ꠁ ꠖꠟꠅ ꠀꠍꠂꠘ, ꠢꠥꠝꠤꠘꠣꠍ ꠀꠞ ꠍꠤꠇꠘ꠆ꠖꠞ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠁꠔꠣꠞꠦ ꠁꠛꠟꠤꠍꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠤꠍꠤ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠛꠥꠎꠔꠣ ꠙꠣꠞꠂꠘ, ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠣ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T12_1","084_2_1","1TI","2","1","1","ꠀꠝꠤ ꠙꠄꠟꠣꠃ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠣꠇꠥꠔꠤ-ꠝꠤꠘꠔꠤ, ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔ, ꠚꠞꠤꠀꠖ ꠎꠣꠘꠣꠅ ꠀꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("T12_2","084_2_2","1TI","2","2","2","ꠅꠟꠣꠈꠣꠘ ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣ ꠅꠇꠟ ꠀꠞ ꠃꠌꠣ ꠙꠖꠞ ꠢꠇꠟ ꠅꠚꠤꠡꠣꠞꠞ ꠟꠣꠉꠤ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚ ꠝꠘꠅ ꠞꠣꠈꠤꠀ, ꠢꠇ-ꠢꠣꠟꠣꠟ ꠙꠕꠦ ꠞꠁꠀ, ꠘꠤꠞꠣꠙꠖꠦ ꠡꠣꠘ꠆ꠔꠤꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("T12_3","084_2_3","1TI","2","3","3","ꠁꠔꠣ ꠔ ꠀꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠘꠦꠇ ꠇꠣꠝ, ꠁꠔꠣꠄ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T12_4","084_2_4","1TI","2","4","4","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠈꠤꠀꠟ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠘ, ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠞꠤꠇꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠛꠥꠎꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T12_5","084_2_5","1TI","2","5","5","ꠁ ꠢꠇꠤꠇꠔꠤ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣ ꠈꠣꠟꠤ ꠄꠇꠎꠘ, ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠡꠣꠚꠣꠄꠀꠔꠇꠣꠞꠤ ꠝꠣꠎꠞ ꠝꠣꠘꠥꠡꠅ ꠈꠣꠟꠤ ꠄꠇꠎꠘꠃ ꠀꠍꠂꠘ, ꠄꠘ ꠘꠣꠝ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ, ꠄꠁꠘꠅ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("T12_6","084_2_6","1TI","2","6","6","ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠎꠣꠘꠞ ꠛꠖꠟꠣ ꠢꠤꠡꠣꠛꠦ, ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠂꠘ। ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠑꠤꠇ ꠇꠞꠣ ꠡꠝꠄꠄ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T12_7","084_2_7","1TI","2","7","7","ꠀꠞ ꠅꠃ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠅ, ꠍꠣꠢꠣꠛꠤ ꠙꠖꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠖꠣꠄꠁꠔ꠆ꠔ ꠖꠤꠍꠂꠘ, ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠁꠝꠣꠘ ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠃꠡ꠆ꠔꠣꠖ ꠢꠤꠡꠣꠛꠦ। ꠀꠝꠤ ꠁꠔꠣ ꠢꠇ ꠝꠣꠔ ꠝꠣꠔꠤꠀꠞ, ꠝꠤꠍꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T12_8","084_2_8","1TI","2","8","8","ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠢꠇꠟ ꠎꠣꠉꠣꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠦ ꠈꠣꠟꠤꠍ ꠘꠤꠅꠔꠦ ꠖꠥꠁꠅ ꠀꠔ ꠔꠥꠟꠤꠀ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠃꠇ। ꠔꠣꠞꠣꠞ ꠝꠘꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠞꠣꠉ-ꠉꠥꠍꠣ ꠛꠣ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖꠞ ꠜꠣꠛ ꠘꠣ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("T12_9","084_2_9","1TI","2","9","9","ꠀꠝꠤ ꠄꠅꠈꠣꠘꠅ ꠌꠣꠁꠞꠣꠝ, ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠢꠣꠄꠀ-ꠡꠞꠝ ꠞꠣꠈꠤꠀ ꠡꠝꠣꠎꠞ ꠃꠙꠎꠥꠇ꠆ꠔ ꠛꠦꠡꠦ ꠜꠖ꠆ꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠤꠘ꠆ꠖꠃꠇ। ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠄ ꠌꠥꠟꠞ ꠛꠦꠘꠤ ꠛꠟꠤꠀ, ꠡꠥꠘꠣ-ꠞꠥꠙꠣ ꠀꠞ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣꠞ ꠉꠄꠘꠣ ꠟꠣꠉꠣꠁꠀ ꠀꠞ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠘꠤꠎꠞꠦ ꠘꠣ ꠢꠣꠎꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T12_10","084_2_10","1TI","2","10","10","ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠣꠘ꠆ꠖꠤꠄ ꠎꠦꠟꠣ ꠘꠦꠇ ꠇꠣꠝꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠘꠤ ꠃꠌꠤꠔ, ꠔꠣꠞꠣꠅ ꠅꠟꠣ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T12_11","084_2_11","1TI","2","11","11","ꠇꠞ꠆ꠔꠣꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠀ, ꠀꠞ ꠘꠤꠞꠣꠁ-ꠎꠤꠞꠣꠁ ꠞꠁꠀ ꠁꠟꠤꠝ ꠇꠣꠝꠣꠁ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("T12_12","084_2_12","1TI","2","12","12","ꠃꠡ꠆ꠔꠣꠖꠤ ꠇꠞꠣ ꠀꠞ ꠛꠦꠐꠣꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠝꠥꠍꠖ꠆ꠖꠞꠤ ꠇꠞꠣꠞ ꠅꠗꠤꠇꠣꠞ ꠀꠝꠤ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠞꠦ ꠖꠦꠁ ꠘꠣ। ꠔꠣꠞꠣ ꠘꠤꠞꠣꠁ-ꠎꠤꠞꠣꠁ ꠞꠅꠀ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("T12_13","084_2_13","1TI","2","13","13","ꠎꠣꠘ ꠔ, ꠢꠇꠟ ꠙꠄꠟꠣ ꠀꠖꠝꠞꠦ ꠀꠞ ꠛꠣꠖꠦ ꠛꠤꠛꠤ ꠢꠣꠅꠀꠞꠦ ꠙꠄꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("T12_14","084_2_14","1TI","2","14","14","ꠀꠖꠝ ꠔ ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘꠞ ꠗꠥꠇꠣꠔ ꠙꠠꠍꠂꠘ ꠘꠣ, ꠅꠁꠟꠦ ꠢꠣꠅꠀ ꠁꠛꠟꠤꠍꠞ ꠗꠥꠇꠣꠔ ꠙꠠꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T12_15","084_2_15","1TI","2","15","15","ꠅꠈꠘ ꠎꠥꠖꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣꠞ ꠢꠣꠄꠀ-ꠡꠞꠝ ꠞꠣꠈꠤꠀ ꠁꠝꠣꠘ, ꠝꠢꠛ꠆ꠛꠔ ꠀꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠀ ꠌꠟꠂꠘ, ꠔꠦ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠎꠘꠝ ꠖꠦꠅꠀꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠞꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T13_1","084_3_1","1TI","3","1","1","ꠢꠥꠘꠅ, ꠀꠍꠟ ꠢꠇ ꠇꠕꠣ ꠅꠁꠟ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠎꠝꠣꠔꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠅꠁꠔꠣ ꠌꠣꠁꠘ, ꠔꠦ ꠔꠣꠁꠘ ꠔ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠤ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T13_2","084_3_2","1TI","3","2","2","ꠎꠝꠣꠔꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠝꠣꠘꠡꠞ ꠌꠈꠥꠔ ꠘꠤꠈꠥꠔ ꠅꠁꠔꠦ ꠅꠁꠛ। ꠔꠣꠘ ꠈꠣꠟꠤ ꠄꠇ ꠛꠃ ꠅꠁꠛ। ꠔꠣꠁꠘ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠛꠣ, ꠔꠣꠘ ꠜꠣꠟꠣ ꠀꠈꠟ-ꠛꠥꠖ꠆ꠖꠤ ꠞꠁꠛ, ꠡ꠆ꠛꠜꠣꠛ ꠅꠁꠛ ꠜꠖ꠆ꠞ, ꠀꠞ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠔꠦ ꠜꠣꠟꠣ ꠙꠣꠁꠛꠣ। ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠈꠦꠝꠔꠣ ꠕꠣꠇꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T13_3","084_3_3","1TI","3","3","3","ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠝꠖꠈꠥꠞ ꠀꠞ ꠛꠖ-ꠝꠤꠎꠣꠎꠤ ꠘꠣ ꠅꠁꠘ, ꠛꠞꠋ ꠔꠣꠘ ꠡ꠆ꠛꠜꠣꠛ ꠅꠁꠛ ꠘꠞꠝ, ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠝꠣꠁꠞ-ꠖꠣꠋꠉꠣ ꠇꠞꠞꠣ ꠛꠣ ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠞ ꠟꠣꠟꠌꠤ ꠘꠣ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T13_4","084_3_4","1TI","3","4","4","ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠡꠑꠤꠇ ꠜꠣꠛꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠌꠣꠟꠣꠁꠘ, ꠔꠣꠘ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ ꠅꠁꠛꠣ ꠛꠣꠁꠖ꠆ꠖ ꠀꠞ ꠀꠖꠛ-ꠇꠣꠄꠖꠣ ꠝꠣꠘꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("T13_5","084_3_5","1TI","3","5","5","ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠊꠞ ꠡꠣꠝꠟꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔꠞꠦ ꠇꠤꠟꠣ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠛ? ");
INSERT INTO syls_vpl VALUES ("T13_6","084_3_6","1TI","3","6","6","ꠇꠥꠘꠥ ꠘꠄꠀ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠎꠝꠣꠔꠞ ꠌꠣꠟꠇꠖꠣꠞ ꠅꠀ ꠑꠤꠇ ꠘꠣꠄ, ꠁꠟꠣ ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠢꠄꠔ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤꠄ ꠛꠣꠢꠣꠖꠥꠞꠤ ꠇꠞꠛꠣ, ꠀꠞ ꠁꠛꠟꠤꠍꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠇꠞꠣ ꠡꠣꠎꠣꠞ ꠜꠣꠉꠤ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T13_7","084_3_7","1TI","3","7","7","ꠎꠝꠣꠔꠞ ꠛꠣꠁꠞꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠔꠣꠘ ꠡꠥꠘꠣꠝ ꠕꠣꠇꠣ ꠖꠞꠇꠣꠞ, ꠎꠣꠔꠦ ꠀꠈꠔꠣ ꠇꠥꠘꠥ ꠛꠖꠘꠣꠝꠞ ꠜꠣꠉꠤ ꠘꠣ ꠅꠁꠘ ꠀꠞ ꠁꠛꠟꠤꠍꠞ ꠚꠣꠘ꠆ꠖꠅ ꠘꠣ ꠙꠠꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T13_8","084_3_8","1TI","3","8","8","ꠅꠃꠟꠣ ꠎꠝꠣꠔꠞ ꠈꠣꠖꠤꠝ ꠅꠇꠟꠅ ꠁꠎ꠆ꠎꠔꠤ ꠀꠞ ꠄꠇ ꠇꠕꠣꠞ ꠝꠣꠘꠥꠡ ꠅꠀ ꠎꠞꠥꠞꠤ। ꠄꠞꠣ ꠎꠣꠔꠦ ꠝꠖꠈꠥꠞ ꠀꠞ ꠢꠣꠞꠣꠝ ꠟꠥꠜ-ꠟꠣꠟꠌꠤ ꠘꠣ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T13_9","084_3_9","1TI","3","9","9","ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠢꠇ ꠛꠤꠛꠦꠇꠦ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠞ ꠛꠣꠔꠥꠘꠤ ꠛꠦꠙꠣꠞꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠖꠤꠟꠅ ꠞꠣꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T13_10","084_3_10","1TI","3","10","10","ꠄꠞꠟꠣꠉꠤ ꠙꠄꠟꠣ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠌꠣꠁ ꠇꠞꠤ ꠖꠦꠈꠣ ꠎꠞꠥꠞ, ꠎꠣꠌꠣꠁꠔ ꠎꠥꠖꠤ ꠔꠣꠞꠣ ꠘꠤꠈꠥꠔ ꠅꠁꠘ, ꠔꠦ ꠎꠝꠣꠔꠞ ꠈꠣꠖꠤꠝ ꠅꠁꠔꠣ ꠙꠣꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T13_11","084_3_11","1TI","3","11","11","ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡꠅ ꠎꠣꠘꠥ ꠁꠎ꠆ꠎꠔꠤ ꠅꠁꠘ। ꠄꠞꠣ ꠝꠣꠘꠡꠞ ꠛꠖꠘꠣꠝ ꠘꠣ ꠉꠣꠁꠘ, ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠂꠘ, ꠀꠞ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠛꠤꠡ꠆ꠛꠣꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T13_12","084_3_12","1TI","3","12","12","ꠈꠣꠖꠤꠝ ꠍꠣꠛ ꠈꠣꠟꠤ ꠄꠇ ꠛꠃꠀꠟꠣ ꠝꠣꠘꠥꠡ ꠅꠁꠛꠣ। ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠔꠣꠘ ꠛꠃ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠀꠞ ꠡꠋꠡꠣꠞꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T13_13","084_3_13","1TI","3","13","13","ꠎꠦ ꠈꠣꠖꠤꠝꠦ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠈꠦꠎꠝꠔ ꠇꠞꠂꠘ, ꠄꠁꠘ ꠡꠥꠘꠣꠝ ꠙꠣꠁꠘ, ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠕꠣꠇꠣꠄ ꠔꠣꠘ ꠖꠤꠟ ꠡꠣꠅꠡꠦ ꠜꠞꠣ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("T13_14","084_3_14","1TI","3","14","14","ꠅ ꠔꠤꠝꠕꠤ, ꠀꠝꠤ ꠀꠡꠣ ꠇꠞꠞꠣꠝ ꠈꠥꠛ ꠎꠟꠖꠤꠃ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠔꠣꠝ। ꠅꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠁꠔꠣ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("T13_15","084_3_15","1TI","3","15","15","ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠇꠣꠞꠘꠦ ꠀꠝꠣꠞ ꠀꠁꠔꠦ ꠖꠦꠞꠤ ꠅꠁꠎꠣꠄ, ꠔꠦ ꠁ ꠟꠦꠈꠣ ꠙꠠꠟꠦ ꠔꠥꠝꠤ ꠛꠥꠎꠛꠣꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠘꠡꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠇꠤꠟꠣ ꠅꠁꠔ। ꠁ ꠙꠞꠤꠛꠣꠞ ꠔ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠎꠝꠣꠔ, ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠤꠇꠔꠞ ꠜꠤꠔ ꠀꠞ ꠁꠀꠘ ꠈꠥꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("T13_16","084_3_16","1TI","3","16","16","ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠞ ꠝꠣꠞꠤꠚꠔꠤ ꠇꠔ ꠝꠢꠣꠘ, ꠁꠔꠣ ꠔ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠣ ꠎꠣꠄ ꠘꠣ। ꠅꠃ ꠝꠣꠞꠤꠚꠔꠤ ꠅꠃꠟꠣ ꠎꠣꠁꠞ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠝꠣꠘꠥꠡ ꠍꠥꠞꠔꠦ ꠎꠣꠁꠞ ꠅꠁꠟꠣ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠙꠞꠝꠣꠘ ꠅꠁꠟꠣ ꠛꠦ-ꠇꠍꠥꠞ, ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠔꠣꠘ ꠖꠞꠡꠘ ꠙꠣꠁꠟꠣ। ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠟ, ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠟꠣ, ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣꠄ ꠔꠣꠘꠞꠦ ꠃꠙꠞꠦ ꠔꠥꠟꠤ ꠘꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("T14_1","084_4_1","1TI","4","1","1","ꠅ ꠔꠤꠝꠕꠤ, ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠦ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠞꠤ ꠇꠁꠞꠣ, ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠔ ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘ ꠕꠣꠇꠤ ꠢꠞꠤꠎꠤꠛ, ꠔꠣꠞꠣ ꠘꠣ-ꠢꠇ ꠞꠥꠢꠥ ꠀꠞ ꠎꠤꠘ-ꠜꠥꠔꠞ ꠔꠣꠟꠤꠝꠞ ꠀꠡꠤꠇ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T14_2","084_4_2","1TI","4","2","2","ꠎꠦꠔꠣ ꠛꠦꠁꠝꠣꠘ ꠅꠇꠟꠞ ꠛꠤꠛꠦꠇ-ꠛꠥꠖ꠆ꠖꠤ ꠅꠡꠣꠠ ꠅꠁꠉꠦꠍꠦ, ꠅꠔꠣꠞ ꠜꠘ꠆ꠒꠣꠝꠤꠞ ꠖꠣꠄ ꠅꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T14_3","084_4_3","1TI","4","3","3","ꠁꠔꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠇꠠꠣꠇꠠꠤ ꠢꠥꠇꠥꠝ ꠖꠦꠁꠘ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠘꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠈꠣꠘꠤ ꠈꠣꠁꠔꠦꠅ ꠘꠤꠡꠦꠗ ꠇꠞꠂꠘ। ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠁ ꠈꠣꠘꠤ ꠙꠄꠖꠣꠃ ꠇꠞꠍꠂꠘ, ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠦ, ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠞꠦ ꠎꠣꠘꠤꠟꠤꠍꠦ, ꠔꠣꠞꠣ ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠁꠔꠣ ꠈꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T14_4","084_4_4","1TI","4","4","4","ꠀꠟ꠆ꠟꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠣ ꠢꠇꠟ ꠎꠤꠘꠤꠡꠃ ꠜꠣꠟꠣ। ꠢꠣꠞꠣꠝ ꠝꠘꠅ ꠇꠞꠤꠀ ꠇꠥꠘꠥꠔꠣ ꠛꠣꠖ ꠖꠦꠅꠀ ꠑꠤꠇ ꠘꠣꠄ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤꠀ ꠈꠣꠅꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T14_5","084_4_5","1TI","4","5","5","ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠀꠞ ꠁ ꠝꠥꠘꠣꠎꠣꠔꠞ ꠝꠣꠎꠖꠤ ꠁꠔꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T14_6","084_4_6","1TI","4","6","6","ꠅ ꠔꠤꠝꠕꠤ, ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠅꠃ ꠔꠣꠟꠤꠝ ꠅꠇꠟ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠛꠥꠎꠣꠁꠀ ꠖꠦꠅ, ꠔꠦ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠞ ꠎꠦ ꠢꠇ ꠀꠞ ꠘꠤꠞꠜꠥꠟ ꠔꠣꠟꠤꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠞꠣꠄ, ꠁ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠤ ꠙꠣꠇꠣ-ꠙꠥꠇ꠆ꠔ ꠅꠁꠀ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠃꠙꠎꠥꠇ꠆ꠔ ꠈꠣꠖꠤꠝ ꠅꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T14_7","084_4_7","1TI","4","7","7","ꠔꠥꠝꠤ ꠀꠎꠦ-ꠛꠣꠎꠦ ꠇꠤꠌ꠆ꠍꠣ-ꠇꠣꠢꠤꠘꠤ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠁꠅ, ꠁꠔꠣ ꠔ ꠖꠣꠖꠤ-ꠘꠣꠘꠤꠞ ꠇꠅꠀ ꠛꠣꠘꠣꠁꠟ ꠇꠤꠌ꠆ꠍꠣꠞ ꠟꠣꠈꠣꠘ। ꠄꠞꠟꠣꠉꠤ ꠁꠔꠣ ꠛꠣꠖ ꠖꠤꠀ ꠖꠤꠟꠞ ꠁꠝꠣꠘꠤ ꠛꠦꠀꠝ ꠇꠞꠣꠔ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("T14_8","084_4_8","1TI","4","8","8","ꠡꠞꠤꠟꠞ ꠛꠦꠀꠝ ꠇꠞꠟꠦ ꠇꠤꠍꠥ ꠚꠣꠄꠖꠣ ꠅꠄ, ꠅꠁꠟꠦ ꠖꠤꠟꠞ ꠁꠝꠣꠘꠤ ꠛꠦꠀꠝꠦ ꠢꠇ꠆ꠇꠟ ꠛꠣꠄ ꠕꠣꠇꠤ ꠚꠣꠄꠖꠣ ꠅꠄ। ꠄꠞꠝꠣꠎꠦ ꠔ ꠈꠣꠟꠤ ꠁ ꠖꠥꠘꠤꠀ ꠘꠣꠄ, ꠀꠈꠦꠞꠣꠔꠞ ꠀꠡꠣꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T14_9","084_4_9","1TI","4","9","9","ꠁꠔꠣ ꠔ ꠙꠥꠞꠣꠙꠥꠞ ꠢꠇ ꠀꠞ ꠈꠣꠐꠤ, ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠇꠛꠥꠟ ꠇꠞꠣꠞ ꠟꠣꠈ। ");
INSERT INTO syls_vpl VALUES ("T14_10","084_4_10","1TI","4","10","10","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠞꠣ ꠎꠣꠘꠦ-ꠙꠞꠣꠘꠦ ꠁꠝꠣꠘꠞ ꠝꠦꠘꠔ ꠇꠞꠤꠀꠞ ꠀꠞ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠇꠣꠝ ꠇꠞꠤꠀꠞ। ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠔ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤ। ꠔꠣꠁꠘꠃ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ, ꠈꠣꠍ ꠇꠞꠤ ꠎꠦꠞꠣ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("T14_11","084_4_11","1TI","4","11","11","ꠔꠦ ꠔꠥꠝꠤꠅ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠀꠞ ꠔꠣꠟꠤꠝ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("T14_12","084_4_12","1TI","4","12","12","ꠔꠥꠝꠤ ꠎꠥꠀꠘ ꠛꠦꠐꠣ ꠝꠘꠅ ꠇꠞꠤꠀ ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞꠦ ꠄꠟꠣ ꠘꠣ ꠇꠞꠦ, ꠄꠞꠟꠣꠉꠤ ꠝꠣꠔ-ꠇꠕꠣꠄ, ꠌꠣꠟ-ꠌꠟꠘꠦ, ꠝꠢꠛ꠆ꠛꠔꠦ, ꠁꠝꠣꠘꠦ ꠀꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞꠔꠣꠄ ꠔꠥꠝꠤ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠄꠇꠐꠣ ꠘꠤꠡꠣꠘꠣ ꠛꠘꠤꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("T14_13","084_4_13","1TI","4","13","13","ꠀꠞ ꠀꠝꠤ ꠀꠁꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠤ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠙꠣꠇ ꠇꠣꠟꠣꠝ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠣ, ꠡꠥ-ꠙꠞꠣꠝꠤꠡ ꠖꠦꠅꠀ, ꠀꠞ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠔ ꠟꠣꠉꠣꠁꠟ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("T14_14","084_4_14","1TI","4","14","14","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠀꠔ ꠞꠣꠈꠤꠀ, ꠘꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠥꠟꠤ ꠝꠣꠔꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠍꠂꠘ, ꠔꠦ ꠔꠥꠝꠤ ꠁ ꠘꠤꠀꠝꠔꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T14_15","084_4_15","1TI","4","15","15","ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠈꠤꠀꠟꠤ ꠅꠅ, ꠘꠤꠎꠞꠦ ꠅꠔꠣꠞ ꠝꠣꠎꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠒꠥꠛꠣꠁꠀ ꠞꠣꠈꠅ, ꠔꠦꠃ ꠢꠇꠟꠞ ꠌꠈꠥꠔ ꠙꠠꠛ ꠔꠥꠝꠤ ꠀꠉꠦꠖꠤ ꠀꠉꠥꠀꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T14_16","084_4_16","1TI","4","16","16","ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠞ ꠔꠥꠝꠣꠞ ꠔꠣꠟꠤꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ। ꠔꠦꠃ ꠔꠥꠝꠤ ꠘꠤꠎꠞꠦ ꠛꠣꠌꠣꠁꠛꠣꠄ, ꠀꠞ ꠎꠦꠞꠣ ꠔꠥꠝꠣꠞ ꠛꠄꠀꠘ ꠢꠥꠘꠛ, ꠔꠣꠞꠣꠞꠦꠅ ꠛꠣꠌꠣꠁꠔꠣꠄ ꠙꠣꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T15_1","084_5_1","1TI","5","1","1","ꠅ ꠔꠤꠝꠕꠤ, ꠢꠥꠘꠅ, ꠇꠥꠘꠥ ꠝꠥꠞꠛ꠆ꠛꠤ ꠝꠣꠘꠡꠞ ꠖꠥꠡ ꠖꠦꠈꠣꠘꠤꠔ ꠉꠤꠀ ꠇꠠꠣ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠤꠅ ꠘꠣ। ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠘꠤꠎꠞ ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤꠅ। ꠀꠞ ꠎꠥꠀꠘ ꠅꠇꠟꠞꠦ ꠘꠤꠎꠞ ꠜꠣꠁ ꠝꠘꠅ ꠇꠞꠤꠀ ꠢꠦꠖꠣꠄꠅꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("T15_2","084_5_2","1TI","5","2","2","ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠦꠐꠤꠘꠞꠦ ꠘꠤꠎꠞ ꠝꠣ ꠀꠞ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠛꠁꠘ ꠝꠘꠅ ꠇꠞꠤꠀ, ꠝꠘꠞ ꠜꠣꠛ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠞꠣꠈꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠢꠦꠖꠣꠄꠅꠔ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("T15_3","084_5_3","1TI","5","3","3","ꠎꠦꠔꠣ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠇꠦꠃ ꠘꠣꠁ, ꠔꠣꠞꠣꠞꠦ ꠈꠥꠛ ꠎꠔꠘ ꠇꠞꠤ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("T15_4","084_5_4","1TI","5","4","4","ꠅꠁꠟꠦ ꠇꠥꠘꠥ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠎꠥꠖꠤ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠛꠣ ꠘꠣꠔꠤ-ꠘꠣꠔꠘꠤ ꠕꠣꠇꠂꠘ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞꠦ ꠄꠞꠣꠃ ꠎꠣꠘꠥ ꠙꠄꠟꠣ ꠎꠣꠞꠎꠤꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠦ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠝꠣꠄꠀ-ꠝꠝꠔꠣꠞ ꠞꠤꠘ ꠡꠥꠗ ꠇꠞꠔꠣ ꠙꠣꠞꠛꠣ, ꠀꠞ ꠁꠔꠣ ꠇꠣꠝꠦ ꠔ ꠀꠟ꠆ꠟꠣ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T15_5","084_5_5","1TI","5","5","5","ꠎꠦ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠇꠦꠃ ꠘꠣꠁ, ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠞꠣꠈꠤꠀ, ꠖꠤꠘꠦ-ꠞꠣꠁꠔꠦ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠝꠥꠘꠣꠎꠣꠔ ꠀꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠐꠤ ꠇꠞꠣꠔ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T15_6","084_5_6","1TI","5","6","6","ꠅꠁꠟꠦ ꠎꠦꠔꠣ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠎꠦꠝꠘꠦ ꠝꠘꠦ ꠌꠣꠄ ꠄꠝꠘꠦ ꠌꠟꠂꠘ, ꠁꠔꠣ ꠔ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦꠃ ꠝꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("T15_7","084_5_7","1TI","5","7","7","ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠇꠦꠃ ꠔꠣꠞꠣꠞꠦ ꠖꠥꠡꠤ ꠇꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠘꠣ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T15_8","084_5_8","1TI","5","8","8","ꠎꠦ ꠎꠘꠦ ꠀꠙꠘ ꠎꠘꠞꠦ, ꠈꠣꠍ ꠇꠞꠤ ꠘꠤꠎꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠝꠣꠘꠡꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠦ ꠘꠣ, ꠢꠦ ꠀꠍꠟꠦ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠞꠦꠃ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠟ। ꠁꠉꠥ ꠔ ꠛꠤꠗꠞ꠆ꠝꠤ ꠕꠣꠇꠤꠅ ꠛꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("T15_9","084_5_9","1TI","5","9","9","ꠄꠞꠟꠣꠉꠤ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠘꠣꠝꠞ ꠟꠤꠡ꠆ꠐ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠀꠉꠦ ꠖꠦꠈꠔꠦ ꠅꠁꠛ, ꠁ ꠛꠦꠐꠤꠞ ꠛꠄꠅꠡ ꠡꠣꠁꠐ ꠛꠍꠞ ꠅꠁꠍꠦ ꠘꠤ, ꠀꠞ ꠎꠣꠝꠣꠁꠞ ꠛꠣꠄ ꠔꠣꠁꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠀꠍꠟꠣ ꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("T15_10","084_5_10","1TI","5","10","10","ꠄꠍꠣꠠꠣ ꠘꠦꠇ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠡꠥꠘꠣꠝ ꠕꠣꠇꠔꠦ ꠅꠁꠛ, ꠅꠃ ꠘꠦꠇ ꠇꠣꠝ ꠅꠁꠟ, ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠝꠣꠘꠥꠡ ꠛꠣꠘꠣꠘꠤ, ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠙꠣꠅ ꠗꠅꠀꠘꠤ, ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠤ ꠝꠣꠘꠡꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣ, ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠦꠇ ꠇꠣꠝꠅ ꠡꠞꠤꠇ ꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("T15_11","084_5_11","1TI","5","11","11","ꠇꠥꠘꠥ ꠎꠥꠀꠘ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠞ ꠘꠣꠝ ꠁ ꠟꠤꠡ꠆ꠐꠅ ꠔꠥꠟꠤꠅ ꠘꠣ। ꠇꠣꠞꠘ ꠔꠣꠞꠣꠞ ꠎꠃꠛꠘꠞ ꠟꠣꠉꠤ ꠡꠞꠤꠟꠞ ꠉꠞꠝꠦ ꠎꠦꠛꠟꠣ ꠃꠔꠣꠟ-ꠙꠣꠔꠣꠟ ꠇꠞꠂꠘ, ꠅꠃ ꠡꠝꠄ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠣꠄ ꠔꠣꠞꠣꠞ ꠒꠞ-ꠜꠄ ꠇꠝꠤ ꠎꠣꠄ, ꠔꠦꠃ ꠔꠣꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠛꠤꠀ ꠛꠁꠔꠣ ꠌꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T15_12","084_5_12","1TI","5","12","12","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠞ ꠀꠉꠞ ꠅꠀꠖꠣ ꠜꠋꠉ ꠇꠞꠂꠘ, ꠘꠤꠎꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠒꠣꠇꠤꠀ ꠀꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T15_13","084_5_13","1TI","5","13","13","ꠀꠞ ꠔꠣꠞꠣ ꠛꠣꠠꠤꠄ ꠛꠣꠠꠤꠄ ꠀꠒ꠆ꠒꠣ ꠝꠣꠞꠤꠀ ꠇꠥꠠꠤꠀ ꠛꠘꠤꠎꠣꠁꠘ। ꠈꠣꠟꠤ ꠇꠥꠠꠤꠀ ꠘꠣꠄ, ꠎꠦꠔꠣ ꠝꠣꠔ-ꠇꠕꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠣꠁꠎ ꠘꠣꠄ, ꠅꠔꠣ ꠛꠣꠎꠦ ꠝꠣꠔ-ꠇꠕꠣꠅ ꠝꠣꠔꠂꠘ ꠀꠞ ꠙꠞꠞ ꠉꠤꠛꠔ ꠉꠣꠅꠀꠔ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T15_14","084_5_14","1TI","5","14","14","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠅꠃ ꠘꠍꠤꠅꠔ ꠇꠞꠤꠀꠞ, ꠎꠥꠀꠘ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠛꠤꠀ-ꠡꠣꠖꠤ ꠇꠞꠣꠃ ꠜꠣꠟꠣ, ꠔꠣꠞꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠝꠣ ꠅꠃꠇ, ꠘꠤꠎꠞ ꠡꠋꠡꠣꠞꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠃꠇ, ꠀꠞ ꠖꠥꠡꠝꠘꠞꠦ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘ ꠛꠖꠘꠣꠝ ꠉꠣꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠘꠣ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("T15_15","084_5_15","1TI","5","15","15","ꠇꠄꠎꠘ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ ꠄꠞꠝꠣꠎꠦꠃ ꠔ ꠛꠦ-ꠙꠕꠤ ꠛꠘꠤꠀ ꠡꠄꠔꠣꠘꠞ ꠙꠕꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("T15_16","084_5_16","1TI","5","16","16","ꠇꠥꠘꠥ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠖꠣꠞ ꠛꠦꠐꠤ ꠝꠣꠘꠡꠞ ꠊꠞꠅ ꠎꠥꠖꠤ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ ꠕꠣꠇꠂꠘ, ꠔꠦ ꠅꠃ ꠛꠦꠐꠤꠄ ꠎꠣꠘꠥ ꠄꠞꠣꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠂꠘ। ꠄꠞꠣꠞꠦ ꠖꠦꠈꠣ-ꠢꠥꠘꠣꠞ ꠜꠣꠞ ꠎꠝꠣꠔꠞ ꠃꠙꠞꠦ ꠘꠣ ꠖꠦꠅꠀ ꠜꠣꠟꠣ। ꠔꠦꠃ ꠎꠦꠔꠣ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ ꠄꠇꠖꠝ ꠟꠣꠍꠣꠞ, ꠎꠝꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠔꠦ ꠡꠥꠛꠤꠗꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T15_17","084_5_17","1TI","5","17","17","ꠎꠝꠣꠔꠞ ꠎꠦ ꠙꠞꠗꠣꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠎꠝꠣꠔꠞꠦ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠌꠣꠟꠣꠁꠘ, ꠈꠣꠍ ꠇꠞꠤ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠀꠞ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠝꠦꠘꠔ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠒꠣꠛꠥꠟ ꠁꠎ꠆ꠎꠔ ꠙꠣꠅꠀ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("T15_18","084_5_18","1TI","5","18","18","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠔ ꠀꠍꠦ, “ꠗꠣꠘ ꠝꠣꠠꠣ ꠖꠦꠅꠀꠞ ꠡꠝꠄ ꠉꠞꠥꠞ ꠝꠥꠈꠅ ꠢꠥꠚꠤ ꠟꠣꠉꠣꠁꠅ ꠘꠣ।” ꠀꠞꠇ ꠀꠄꠀꠔꠅ ꠀꠍꠦ, “ꠇꠣꠝꠟꠣꠄ ꠔꠣꠞ ꠛꠦꠔꠘ ꠙꠣꠅꠀꠞ ꠎꠁꠉ꠆ꠉ।” ");
INSERT INTO syls_vpl VALUES ("T15_19","084_5_19","1TI","5","19","19","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠖꠥꠁ ꠛꠣ ꠔꠤꠘ ꠎꠘ ꠡꠣꠇ꠆ꠇꠤꠞ ꠇꠕꠣ ꠍꠣꠠꠣ, ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠡꠝꠎꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T15_20","084_5_20","1TI","5","20","20","ꠅꠁꠟꠦ ꠎꠦ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠉꠥꠘꠣ ꠇꠞꠣꠔꠃ ꠕꠣꠇꠂꠘ, ꠎꠝꠣꠔꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍꠦ ꠔꠣꠞꠣꠞ ꠖꠥꠡ ꠎꠣꠁꠞ ꠇꠞꠤꠅ, ꠎꠣꠔꠦ ꠅꠁꠘ꠆ꠘ ꠢꠇꠟꠦ ꠒꠞꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T15_21","084_5_21","1TI","5","21","21","ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ, ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠄꠀꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠅꠃ ꠢꠥꠇꠥꠝ ꠖꠤꠞꠣꠝ, ꠔꠥꠝꠤ ꠘꠤꠞꠙꠇ꠆ꠇ ꠞꠁꠀ ꠁꠔꠣ ꠇꠣꠝ ꠇꠞꠤꠅ, ꠇꠦꠃꠞꠞꠦ ꠙꠞ ꠛꠣ ꠀꠙꠘ ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T15_22","084_5_22","1TI","5","22","22","ꠌꠐ ꠇꠞꠤ ꠇꠦꠃꠞꠞꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠀ, ꠇꠥꠘꠥ ꠙꠖꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠤꠅ ꠘꠣ। ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠞꠦ, ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠅ ꠘꠣ, ꠘꠤꠎꠞꠦ ꠘꠤꠈꠥꠔ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("T15_23","084_5_23","1TI","5","23","23","ꠀꠞ ꠇꠄꠖꠤꠘ ꠛꠣꠖꠦ ꠛꠣꠖꠦꠃ ꠔꠥꠝꠣꠞ ꠛꠦꠝꠣꠞ ꠅꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠈꠣꠟꠤ ꠙꠣꠘꠤ ꠈꠣꠁꠅ ꠘꠣ, ꠕꠥꠠꠣ ꠕꠥꠠꠣ ꠀꠋꠉꠥꠞꠞ ꠡꠞꠛꠔꠅ ꠈꠣꠁꠅ, ꠔꠦꠃ ꠅꠎꠝ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T15_24","084_5_24","1TI","5","24","24","ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣ ꠅꠟꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞ ꠛꠤꠌꠣꠞ ꠀꠉꠦꠃ ꠅꠁꠎꠣꠄ। ꠀꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣ ꠛꠣꠖꠦ ꠗꠞꠣ ꠙꠠꠦ। ");
INSERT INTO syls_vpl VALUES ("T15_25","084_5_25","1TI","5","25","25","ꠅꠟꠣꠈꠣꠘ ꠘꠦꠇ ꠇꠣꠝ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠖꠦꠈꠣ ꠎꠣꠄ, ꠀꠞ ꠇꠥꠘꠥ ꠘꠦꠇ ꠇꠣꠝ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠖꠦꠈꠣ ꠘꠣ ꠉꠦꠟꠦꠅ, ꠁꠔꠣ ꠟꠥꠇꠣꠁꠟ ꠞꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T16_1","084_6_1","1TI","6","1","1","ꠢꠥꠘꠅ, ꠎꠦ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤꠄ ꠝꠥꠘꠤꠛꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠎꠣꠞꠎꠤꠞ ꠝꠥꠘꠤꠛꠞꠦ ꠁꠎ꠆ꠎꠔꠤ ꠎꠘ ꠝꠘꠅ ꠇꠞꠃꠇ, ꠎꠣꠔꠦ ꠇꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠞꠦ ꠛꠣ ꠀꠝꠞꠣꠞ ꠔꠣꠟꠤꠝꠞꠦ ꠈꠣꠞꠣꠙ ꠇꠅꠀꠞ ꠡꠥꠎꠥꠉ ꠘꠣ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T16_2","084_6_2","1TI","6","2","2","ꠎꠦ ꠎꠘꠦ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠖꠣꠞ ꠇꠥꠘꠥ ꠝꠥꠘꠤꠛꠞ ꠉꠥꠟꠣꠝꠤ ꠇꠞꠂꠘ, ꠄꠁꠘ ꠎꠣꠘꠥ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠘ ꠝꠥꠘꠤꠛꠞꠦ ꠄꠟꠣꠝꠤ ꠘꠣ ꠇꠞꠂꠘ ꠛꠞꠋ ꠀꠞꠅ ꠜꠣꠟꠣ ꠇꠞꠤ ꠔꠣꠘ ꠈꠦꠎꠝꠔ ꠇꠞꠂꠘ। ꠇꠣꠞꠘ ꠉꠥꠟꠣꠝꠞ ꠈꠦꠎꠝꠔꠦ ꠎꠦ ꠝꠥꠘꠤꠛꠦ ꠃꠙꠇꠣꠞ ꠙꠣꠁꠞꠣ, ꠔꠣꠁꠘ ꠔ ꠝꠣꠄꠀꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ। ꠔꠦ ꠅꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠤ ꠔꠣꠟꠤꠝ ꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("T16_3","084_6_3","1TI","6","3","3","ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠔꠣ ꠛꠣꠖ ꠖꠤꠀ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠔꠣꠟꠤꠝ ꠖꠦꠄ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠐꠤ ꠔꠣꠟꠤꠝ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚꠞ ꠔꠣꠟꠤꠝꠞꠦ ꠘꠣ ꠝꠣꠘꠦ, ");
INSERT INTO syls_vpl VALUES ("T16_4","084_6_4","1TI","6","4","4","ꠢꠦ ꠔ ꠝꠤꠍꠣ ꠅꠢꠋꠇꠣꠞꠤ, ꠢꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠛꠥꠎꠦ ꠘꠣ, ꠝꠔꠜꠦꠖ ꠇꠞꠣ, ꠛꠦꠢꠥꠖꠣ ꠃꠚꠔꠣꠝꠤ ꠇꠞꠣ ꠔꠣꠞ ꠄꠇꠐꠣ ꠛꠦꠝꠣꠞ। ꠅꠔꠣꠞ ꠇꠣꠞꠘꠦ ꠁꠋꠡꠣ-ꠘꠤꠘ꠆ꠖꠣ, ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ, ꠇꠥ-ꠡꠘ꠆ꠖꠄ ꠙꠄꠖꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("T16_5","084_6_5","1TI","6","5","5","ꠀꠞ ꠅꠡꠣꠠ ꠛꠤꠛꠦꠇꠀꠟꠣ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠦꠡꠣ ꠉꠥꠟꠝꠣꠟ ꠟꠣꠉꠣꠁꠟꠃ ꠕꠣꠇꠦ। ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇ ꠘꠣꠁ। ꠔꠣꠞꠣ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠞꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠟꠣꠜꠞ ꠃꠙꠣꠄ ꠝꠘꠅ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("T16_6","084_6_6","1TI","6","6","6","ꠀꠍꠟꠦ ꠝꠘꠞ ꠔꠥꠡ꠆ꠐꠤꠄ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘ ꠝꠣꠚꠤꠇ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠟꠦ ꠈꠥꠛ ꠛꠦꠡꠤ ꠟꠣꠜ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("T16_7","084_6_7","1TI","6","7","7","ꠀꠝꠞꠣ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠛꠣꠞ ꠇꠣꠟꠅ ꠔ ꠇꠥꠘ꠆ꠔꠣꠃ ꠟꠉꠦ ꠟꠁꠀ ꠀꠁꠍꠤ ꠘꠣ, ꠀꠞ ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ-ꠅ ꠇꠥꠘ꠆ꠔꠣ ꠘꠤꠔꠣꠝ ꠙꠣꠞꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T16_8","084_6_8","1TI","6","8","8","ꠄꠞꠟꠣꠉꠤ ꠈꠣꠟꠤ ꠈꠣꠘꠤ-ꠇꠣꠙꠠ ꠙꠣꠁꠟꠦꠃ ꠀꠝꠞꠣ ꠈꠥꠡꠤ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("T16_9","084_6_9","1TI","6","9","9","ꠅꠁꠟꠦ ꠖꠥꠘꠤꠀꠔ ꠎꠦꠞꠣ ꠗꠘꠤ ꠅꠁꠔ ꠌꠣꠄ, ꠔꠣꠞꠣ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠀꠞ ꠚꠣꠘ꠆ꠖꠅ ꠙꠠꠦ, ꠔꠣꠞꠣꠞ ꠝꠘꠅ ꠈꠥꠛ ꠛꠖ ꠈꠣꠁꠡ ꠙꠄꠖꠣ ꠅꠄ, ꠎꠦꠔꠣꠄ ꠔꠣꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠡꠞ꠆ꠛꠘꠣꠡꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T16_10","084_6_10","1TI","6","10","10","ꠇꠣꠞꠘ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠖ ꠇꠣꠝꠞ ꠎꠘꠝ ꠅꠁꠟ ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠞ ꠝꠣꠄꠀ। ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘ ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠞ ꠟꠣꠟꠌꠦ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠉꠤꠀ, ꠘꠤꠎꠞ ꠃꠙꠞꠦ ꠛꠠ ꠖꠥꠈ-ꠝꠍꠤꠛꠔ ꠒꠣꠇꠤꠀ ꠀꠘꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T16_11","084_6_11","1TI","6","11","11","ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ, ꠔꠥꠝꠤ ꠁꠔꠣ ꠛꠖ ꠇꠣꠝ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠅ। ꠔꠥꠝꠤ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚ, ꠁꠝꠣꠘ, ꠝꠢꠛ꠆ꠛꠔ, ꠍꠛꠞ, ꠀꠞ ꠘꠞꠝ ꠡ꠆ꠛꠜꠣꠛꠞ ꠛꠣꠄ ꠈꠤꠀꠟꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("T16_12","084_6_12","1TI","6","12","12","ꠁꠝꠣꠘꠤ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠔ ꠞꠅ। ꠀꠈꠦꠞꠣꠔꠞ ꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠥꠝꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠢꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠔꠥꠝꠤ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠗꠞꠅ। ꠔꠥꠝꠤ ꠔ ꠁꠝꠣꠘꠤ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠟꠣꠄ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠍꠣꠝꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("T16_13","084_6_13","1TI","6","13","13","ꠅꠈꠘ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠘꠣꠝꠦ, ꠎꠦꠁꠘ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠎꠣꠘ ꠖꠦꠁꠘ, ꠀꠞ ꠎꠦꠁꠘ ꠢꠣꠇꠤꠝ ꠙꠘ꠆ꠔꠤꠅ ꠙꠤꠟꠣꠔꠞ ꠍꠣꠝꠘꠦ ꠘꠤꠎꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠇ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠟꠣ, ꠢꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦꠅ ꠔꠥꠝꠣꠞꠦ ꠅꠃ ꠝꠤꠘꠔꠤ ꠇꠞꠞꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("T16_14","084_6_14","1TI","6","14","14","ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠎꠣꠁꠞ ꠅꠀꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠈꠥꠔ ꠀꠞ ꠛꠖꠘꠣꠝ ꠍꠣꠠꠣ ꠞꠁꠀ ꠢꠥꠇꠥꠝ ꠀꠖꠣꠄ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("T16_15","084_6_15","1TI","6","15","15","ꠀꠞ ꠉꠥꠘꠉꠣꠘꠦ ꠗꠘꠤ ꠢꠃ ꠀꠟ꠆ꠟꠣ, ꠎꠦꠁꠘ ꠄꠇꠝꠣꠔ꠆ꠞ ꠡꠝ꠆ꠞꠣꠐ, ꠛꠣꠖꠡꠣ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ ꠀꠞ ꠝꠣꠟꠤꠇ ꠅꠇꠟꠞ ꠝꠣꠟꠤꠇ, ꠔꠣꠁꠘꠃ ꠔꠣꠘ ꠃꠙꠎꠥꠇ꠆ꠔ ꠡꠝꠄꠄ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠎꠣꠁꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T16_16","084_6_16","1TI","6","16","16","ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦꠃ ꠝꠃꠔꠦ ꠇꠛꠎꠣ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ꠔꠣꠁꠘ ꠅꠟꠣ ꠄꠇ ꠘꠥꠞꠞ ꠚꠞꠅ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠢꠤꠘꠅ ꠇꠥꠘꠥ ꠀꠖꠝ ꠎꠣꠔ ꠎꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ꠇꠥꠘꠥ ꠀꠖꠝꠦ ꠇꠥꠘꠥꠖꠤꠘ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠍꠦꠅ ꠘꠣ, ꠖꠦꠈꠣꠞ ꠔꠣꠇ꠆ꠇꠔꠅ ꠘꠣꠁ। ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠈꠦꠝꠔꠣ ꠌꠤꠞꠇꠣꠟ ꠈꠣꠟꠤ ꠔꠣꠘꠃ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("T16_17","084_6_17","1TI","6","17","17","ꠢꠥꠘꠅ, ꠅꠃ ꠖꠥꠘꠤꠀꠞ ꠗꠘꠤ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠛꠠꠣꠁ ꠘꠣ ꠇꠞꠂꠘ, ꠀꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠅꠡ꠆ꠕꠣꠄꠁ ꠗꠘꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠘꠣ ꠇꠞꠤꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠂꠘ। ꠀꠝꠞꠣꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘꠃ ꠢꠇꠟꠔꠣ ꠈꠥꠟꠣ ꠀꠔꠦ ꠖꠣꠘ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T16_18","084_6_18","1TI","6","18","18","ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠅꠁꠘ꠆ꠘꠞ ꠜꠣꠟꠣꠁ ꠇꠞꠦ, ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠔ ꠞꠄ, ꠝꠘ ꠈꠥꠟꠤꠀ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠇꠞꠦ, ꠀꠞ ꠔꠣꠞꠣꠞ ꠗꠘ-ꠖꠃꠟꠔꠞ ꠛꠣꠐ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞꠦ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("T16_19","084_6_19","1TI","6","19","19","ꠔꠦꠃ ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠟꠣꠉꠤ ꠄꠝꠘ ꠗꠘ ꠎꠝꠣ ꠇꠞꠛ, ꠎꠦꠔꠣ ꠜꠛꠤꠡꠔꠦ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘ ꠝꠎꠛꠥꠔ ꠜꠤꠔꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠛ। ꠄꠔꠦ ꠢꠣꠍꠣꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠔꠣꠞꠣ ꠡꠇ꠆ꠔ ꠇꠞꠤ ꠗꠞꠤꠀ ꠞꠣꠈꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("T16_20","084_6_20","1TI","6","20","20","ꠅ ꠔꠤꠝꠕꠤ, ꠔꠥꠝꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠎꠦ ꠡꠝ꠆ꠙꠖ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠁ ꠡꠝ꠆ꠙꠖ ꠔꠥꠝꠤ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠅ। ꠀꠎꠦ-ꠛꠣꠎꠦ ꠀꠈꠟꠞ ꠛꠦꠇꠣꠝꠣ ꠛꠤꠖ꠆ꠖꠣꠞ ꠛꠥꠟꠤꠞ ꠖꠥ-ꠘꠍꠟꠣ ꠔꠣꠟꠤꠝ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("T16_21","084_6_21","1TI","6","21","21","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘ ꠅꠔꠣ ꠛꠦꠇꠣꠝꠣ ꠀꠈꠟ ꠖꠦꠈꠣꠘꠤꠔ ꠉꠤꠀ, ꠀꠍꠟ ꠁꠝꠣꠘ ꠕꠣꠇꠤ ꠛꠦ-ꠙꠕꠦ ꠉꠦꠍꠦꠉꠤ। ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝꠔ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("T21_1","085_1_1","2TI","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠞ꠆ꠎꠤꠄ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠢꠣꠛꠤ। ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤ ꠍꠣꠢꠣꠛꠤ ꠙꠖ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("T21_2","085_1_2","2TI","1","2","2","ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠀꠅꠟꠣꠖ ꠔꠤꠝꠕꠤꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠣꠞꠦ ꠞꠢꠝꠔ, ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("T21_3","085_1_3","2TI","1","3","3","ꠅ ꠔꠤꠝꠕꠤ, ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠄ ꠎꠦꠟꠣ ꠄꠇ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠔꠣ, ꠀꠝꠤꠅ ꠅꠃꠟꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠛꠤꠛꠦꠇꠦ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠤ। ꠀꠝꠤ ꠖꠥꠀ ꠇꠞꠣꠞ ꠛꠣꠟꠣ ꠖꠤꠘꠦ-ꠞꠣꠁꠔꠦ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("T21_4","085_1_4","2TI","1","4","4","ꠔꠥꠝꠣꠞ ꠢꠃ ꠇꠣꠘ꠆ꠖꠘꠞ ꠇꠕꠣ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠣꠞ ꠟꠣꠉꠤ ꠝꠘꠦ ꠈꠥꠛ ꠐꠣꠘꠦꠞ, ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠟꠦ ꠀꠝꠣꠞ ꠜꠤꠔꠞ ꠈꠥꠡꠤꠄ ꠜꠞꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("T21_5","085_1_5","2TI","1","5","5","ꠀꠝꠣꠞ ꠝꠘꠅ ꠀꠍꠦ, ꠔꠥꠝꠣꠞ ꠖꠤꠟꠈꠣꠘ ꠢꠇ ꠁꠝꠣꠘꠦ ꠜꠞꠣ, ꠔꠥꠝꠣꠞ ꠘꠣꠘꠤ ꠟꠥꠁꠍ ꠀꠞ ꠔꠥꠝꠣꠞ ꠀꠝ꠆ꠝꠣ ꠃꠘꠤꠇꠤꠞ ꠜꠤꠔꠞꠦꠅ ꠅꠟꠣ ꠢꠇ ꠁꠝꠣꠘ ꠀꠍꠤꠟ। ꠀꠝꠤ ꠘꠤꠌ꠆ꠌꠤꠔ ꠎꠣꠘꠤ, ꠔꠥꠝꠣꠞ ꠜꠤꠔꠞꠦꠅ ꠅꠟꠣ ꠁꠝꠣꠘ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T21_6","085_1_6","2TI","1","6","6","ꠄꠞꠟꠣꠉꠤ ꠅꠈꠘ ꠔꠥꠝꠣꠞꠦ ꠝꠘꠅ ꠇꠞꠣꠁ ꠖꠤꠞꠣꠝ, ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠡꠞꠤꠟꠅ ꠀꠔ ꠞꠣꠈꠤꠀ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠦꠅꠀꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠎꠦ ꠈꠣꠍ ꠘꠤꠀꠝꠔ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠁ ꠀꠉꠥꠁꠘ ꠎꠣꠟꠣꠁꠀ ꠔꠥꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("T21_7","085_1_7","2TI","1","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠀꠝꠞꠣꠞꠦ ꠜꠤꠔꠥ-ꠒꠞꠣꠟꠥꠇꠞ ꠝꠘꠜꠣꠛ ꠖꠤꠍꠂꠘ ꠘꠣ। ꠛꠞꠋ ꠛꠟ-ꠡꠇ꠆ꠔꠤ, ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠀꠞ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T21_8","085_1_8","2TI","1","8","8","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠔꠦ ꠡꠞꠝꠣꠁꠅ ꠘꠣ, ꠀꠞ ꠔꠣꠘ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦꠘ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠀꠍꠤ, ꠀꠝꠣꠞꠦ ꠟꠁꠀꠅ ꠡꠞꠝꠣꠁꠅ ꠘꠣ। ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠛꠟꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠇꠣꠝꠅ ꠀꠝꠣꠞ ꠟꠉꠦ ꠞꠁꠀ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("T21_9","085_1_9","2TI","1","9","9","ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠍꠂꠘ, ꠀꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠅꠁꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ। ꠁꠔꠣ ꠔ ꠀꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠘꠦꠇ ꠇꠣꠝꠞ ꠉꠥꠘꠦ ꠘꠣꠄ, ꠛꠞꠋ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠀꠞ ꠞꠢꠝꠔꠞ ꠉꠥꠘꠦꠃ ꠇꠞꠍꠂꠘ। ꠀꠝꠞꠣꠞꠦ ꠁ ꠞꠢꠝꠔ ꠖꠣꠘ ꠇꠞꠍꠂꠘ ꠔ, ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠀꠉꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T21_10","085_1_10","2TI","1","10","10","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠅꠈꠘ ꠅꠃ ꠞꠢꠝꠔ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ, ꠀꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠝꠣꠎꠖꠤ। ꠀꠟ-ꠝꠍꠤꠄ ꠔ ꠝꠃꠔꠞ ꠈꠦꠝꠔꠣꠞꠦ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠝꠣꠎꠖꠤ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠘꠥꠞꠣꠘꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠙꠕ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T21_11","085_1_11","2TI","1","11","11","ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉꠞ ꠟꠣꠉꠤꠃ ꠔ ꠀꠝꠣꠞꠦ ꠔꠛꠟꠤꠉꠇꠣꠞꠤ, ꠍꠣꠢꠣꠛꠤ ꠀꠞ ꠃꠡ꠆ꠔꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T21_12","085_1_12","2TI","1","12","12","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠤ ꠅꠟꠣ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠙꠣꠁꠀꠞ, ꠔꠣ-ꠅ ꠀꠝꠤ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠀꠝꠤ ꠎꠣꠘꠤ, ꠀꠝꠤ ꠇꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠍꠤ। ꠀꠝꠣꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠄꠇꠤꠘ ꠀꠍꠦ, ꠀꠝꠤ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠎꠦꠔꠣ ꠎꠝꠣ ꠇꠞꠍꠤ, ꠁꠔꠣꠞꠦ ꠢꠦꠚꠣꠎꠔꠦ ꠞꠣꠈꠣꠞ ꠈꠦꠝꠔꠣ ꠔꠣꠘ ꠀꠍꠦ, ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T21_13","085_1_13","2TI","1","13","13","ꠔꠦ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠎꠔ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠍ, ꠅꠃ ꠢꠇ ꠔꠣꠟꠤꠝꠞꠦ ꠎꠣꠘꠞ ꠇꠛꠎ ꠝꠘꠅ ꠇꠞꠤꠀ, ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠞ ꠁꠝꠣꠘ ꠀꠞ ꠝꠢꠛ꠆ꠛꠔꠦ ꠗꠞꠤꠀ ꠞꠣꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("T21_14","085_1_14","2TI","1","14","14","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠍꠣꠝꠣꠘꠣ ꠢꠦꠚꠣꠎꠔꠦ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠖꠤꠍꠂꠘ, ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠞ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠔꠥꠝꠤ ꠁꠔꠣꠞ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("T21_15","085_1_15","2TI","1","15","15","ꠔꠥꠝꠤ ꠔ ꠎꠣꠘ, ꠔꠥꠞꠡ꠆ꠇꠞ ꠀꠍꠤꠀ ꠄꠟꠣꠇꠣꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠟꠉꠤ ꠉꠦꠍꠂꠘ, ꠚꠥꠉꠤꠟꠣꠍ ꠀꠞ ꠢꠣꠝꠣꠉꠤꠘꠣꠍꠅ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠉꠦꠍꠂꠘꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("T21_16","085_1_16","2TI","1","16","16","ꠜꠣꠁ ꠀꠘꠤꠍꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠃꠙꠞꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠞꠢꠝ-ꠛꠞꠇꠔ ꠖꠦꠃꠇ꠆ꠇꠣ। ꠄꠁꠘ ꠛꠃꠔ ꠛꠣꠞ ꠀꠝꠣꠞ ꠎꠣꠘꠅ ꠀꠞꠣꠝ ꠖꠤꠍꠂꠘ, ꠀꠝꠤ ꠎꠦꠟꠅ ꠢꠣꠝꠣꠁꠟꠦꠅ ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠡꠞꠝ ꠝꠘꠅ ꠇꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T21_17","085_1_17","2TI","1","17","17","ꠔꠣꠁꠘ ꠅꠃ ꠞꠥꠝ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠛꠃꠔ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠤ ꠀꠝꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T21_18","085_1_18","2TI","1","18","18","ꠀꠝꠤ ꠁꠚꠤꠍ ꠐꠣꠃꠘꠅ ꠕꠣꠇꠔꠦ ꠔꠣꠁꠘ ꠇꠤꠟꠣ ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠍꠟꠣ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠤ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦꠃ ꠎꠣꠘ। ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠅꠟꠣ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠖꠤꠘ ꠄꠁꠘ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T22_1","085_2_1","2TI","2","1","1","ꠅ ꠀꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠔꠤꠝꠕꠤ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠙꠣꠅꠀ ꠞꠢꠝꠔꠦ ꠔꠥꠝꠤ ꠛꠟꠛꠣꠘ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("T22_2","085_2_2","2TI","2","2","2","ꠀꠞ ꠛꠃꠔ ꠡꠣꠇ꠆ꠇꠤꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠍ, ꠅꠃ ꠔꠣꠟꠤꠝꠞꠦ ꠅꠟꠣꠈꠣꠘ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠝꠣꠘꠡꠞ ꠀꠔꠅ ꠖꠦꠅ, ꠎꠦꠞꠣ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞꠦꠅ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠃꠙꠎꠥꠇ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("T22_3","085_2_3","2TI","2","3","3","ꠔꠥꠝꠤ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠐꠤ ꠍꠤꠙꠣꠁ ꠅꠁꠀ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠔ ꠡꠞꠤꠇ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("T22_4","085_2_4","2TI","2","4","4","ꠇꠣꠝꠣꠘ꠆ꠒꠣꠞꠞꠦ ꠈꠥꠡꠤ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠖ꠆ꠖꠞ ꠇꠣꠟꠅ ꠇꠥꠘꠥ ꠍꠤꠙꠣꠁ ꠡꠋꠡꠣꠞꠞ ꠝꠣꠄꠀ-ꠎꠣꠟꠅ ꠢꠣꠝꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T22_5","085_2_5","2TI","2","5","5","ꠅꠃ ꠟꠣꠈꠣꠘ ꠈꠦꠟꠣꠔ ꠟꠣꠉꠤꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠤꠅꠝ ꠝꠔ ꠘꠣ ꠈꠦꠟꠣꠄ, ꠔꠦ ꠎꠄꠅꠞ ꠝꠣꠟꠣ ꠢꠦ ꠙꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T22_6","085_2_6","2TI","2","6","6","ꠀꠞ ꠎꠦ ꠉꠤꠞꠡ꠆ꠔꠦ ꠝꠦꠘꠔ ꠇꠞꠦ, ꠚꠡꠟꠞ ꠙꠄꠟꠣ ꠛꠣꠐ ꠔ ꠢꠦ-ꠃ ꠙꠣꠄ, ꠁꠐꠣꠃ ꠘꠤꠅꠝ। ");
INSERT INTO syls_vpl VALUES ("T22_7","085_2_7","2TI","2","7","7","ꠔꠦ ꠀꠝꠤ ꠎꠦꠔꠣ ꠛꠥꠎꠣꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ, ꠁꠔꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ ꠖꠦꠈꠅ, ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠥꠎꠣꠞ ꠀꠈꠟ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T22_8","085_2_8","2TI","2","8","8","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠤ ꠅꠈꠣꠘ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠣꠘꠞꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠛꠋꠡꠗꠞ, ꠀꠝꠣꠞ ꠇꠅꠀ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠝꠣꠎꠦꠅ ꠁꠈꠣꠘ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T22_9","085_2_9","2TI","2","9","9","ꠀꠞ ꠅꠃ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠄꠃ ꠀꠝꠤ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠙꠣꠁꠀꠞ। ꠖꠣꠉꠤ ꠀꠡꠣꠝꠤꠞ ꠟꠣꠈꠣꠘ ꠀꠝꠣꠞꠦ ꠛꠘ꠆ꠖꠤ ꠞꠣꠈꠣ ꠅꠁꠍꠦ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔ ꠛꠘ꠆ꠖꠤ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T22_10","085_2_10","2TI","2","10","10","ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤꠀ ꠀꠟꠉ ꠇꠞꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠢꠇ꠆ꠇꠟꠔꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀꠞ, ꠎꠣꠔꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣ ꠘꠣꠎꠣꠔ ꠙꠣꠁꠘ, ꠟꠉꠦ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠉꠃꠞꠛ-ꠝꠢꠤꠝꠣꠅ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T22_11","085_2_11","2TI","2","11","11","ꠅꠃ ꠇꠕꠣ ꠔ ꠄꠇꠤꠘ ꠇꠞꠣꠞ ꠎꠁꠉ꠆ꠉ, ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣꠞ ꠝꠞꠘ ꠅꠁꠍꠦ, ꠔꠦ ꠀꠝꠞꠣ ꠎꠤꠘ꠆ꠖꠣꠅ ꠅꠁꠝꠥ ꠔꠣꠘ ꠟꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("T22_12","085_2_12","2TI","2","12","12","ꠀꠝꠞꠣ ꠍꠛꠞ ꠇꠞꠤꠀ ꠡꠁꠎ꠆ꠎ ꠇꠞꠟꠦ, ꠔꠣꠘ ꠟꠉꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠝꠥ। ꠀꠞ ꠔꠣꠘꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠟꠦ ꠔ, ꠔꠣꠁꠘꠅ ꠀꠝꠞꠣꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T22_13","085_2_13","2TI","2","13","13","ꠀꠝꠞꠣ ꠛꠦꠁꠝꠣꠘ ꠅꠁꠉꠦꠟꠦꠅ, ꠔꠣꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠞꠂꠘ। ꠔꠣꠁꠘ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠘꠤꠎꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T22_14","085_2_14","2TI","2","14","14","ꠅ ꠔꠤꠝꠕꠤ, ꠔꠥꠝꠤ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠀꠝꠣꠞ ꠅꠃ ꠔꠣꠟꠤꠝꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠣꠁ ꠖꠦꠅ। ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠣꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠅ, ꠎꠣꠔꠦ ꠀꠎꠦ-ꠛꠣꠎꠦ ꠝꠣꠔ ꠟꠁꠀ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠘꠣ ꠇꠞꠂꠘ, ꠁꠔꠣ ꠝꠣꠔꠞ ꠔ ꠇꠥꠘꠥ ꠖꠣꠝ ꠘꠣꠁ, ꠁꠔꠣ ꠎꠦꠞꠣ ꠢꠥꠘꠦ, ꠔꠣꠞꠣꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("T22_15","085_2_15","2TI","2","15","15","ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠘꠤꠎꠞꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠢꠣꠟꠔꠦ ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠅ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝꠟꠣ ꠛꠘꠅ, ꠎꠦ ꠇꠣꠝꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠡꠞꠝ ꠙꠣꠅꠀꠞ ꠇꠥꠘꠥ ꠇꠣꠞꠘ ꠘꠣꠁ। ꠎꠦ ꠇꠣꠝꠟꠣꠄ ꠡꠑꠤꠇ ꠜꠣꠛꠦ ꠢꠇ ꠇꠣꠟꠣꠝ ꠔꠣꠟꠤꠝ ꠖꠦꠁꠘ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("T22_16","085_2_16","2TI","2","16","16","ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠗꠤ ꠀꠎꠦ-ꠛꠣꠎꠦ ꠝꠣꠔ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠞꠅ। ꠁꠟꠣ ꠝꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠝꠣꠘꠡꠞ ꠒꠞ-ꠈꠚ ꠇꠝꠣ ꠗꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("T22_17","085_2_17","2TI","2","17","17","ꠁꠟꠣ ꠀꠎꠦ-ꠛꠣꠎꠦ ꠔꠣꠟꠤꠝ ꠔ ꠙꠌꠣ-ꠊꠣꠞ ꠟꠣꠈꠣꠘ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠍꠤꠔ꠆ꠞꠦ। ꠁ ꠖꠟꠅ ꠀꠍꠦ, ꠢꠥꠝꠤꠘꠣꠍ ꠀꠞ ꠚꠤꠟꠤꠔꠣꠍ। ");
INSERT INTO syls_vpl VALUES ("T22_18","085_2_18","2TI","2","18","18","ꠁꠉꠥꠁꠘ ꠔ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇ ꠕꠣꠇꠤ ꠇꠥ-ꠙꠕꠦ ꠉꠦꠍꠂꠘꠉꠤ। ꠁꠔꠣꠄ ꠇꠂꠘ, ꠝꠥꠝꠤꠘ ꠅꠇꠟ ꠛꠥꠟꠦ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠢꠣꠞꠍꠂꠘ। ꠅꠟꠣ ꠀꠎꠦ-ꠛꠣꠎꠦ ꠝꠣꠔꠤꠀ ꠔꠣꠞꠣ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠞ ꠁꠝꠣꠘ ꠘꠡ꠆ꠐ ꠇꠞꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("T22_19","085_2_19","2TI","2","19","19","ꠔꠦꠛꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠎꠛꠥꠔ ꠜꠤꠔ ꠃꠛꠣ ꠞꠁꠍꠦ, ꠄꠞ ꠃꠙꠞꠦ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠꠞ ꠟꠣꠈꠣꠘ ꠅꠃ ꠇꠕꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠝꠣꠟꠤꠇꠦ ꠎꠣꠘꠂꠘ, ꠇꠦ ꠇꠦ ꠔꠣꠘ,” ꠀꠞ “ꠎꠦ ꠎꠘꠦ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠣꠟꠤꠇ ꠇꠁꠀ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠦ, ꠢꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟ ꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("T22_20","085_2_20","2TI","2","20","20","ꠅ ꠔꠤꠝꠕꠤ, ꠎꠝꠤꠖꠣꠞ ꠛꠣꠠꠤꠔ ꠔ ꠈꠣꠟꠤ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠞ ꠎꠤꠘꠤꠡ ꠕꠣꠇꠦ ꠘꠣ, ꠟꠣꠇꠠꠤꠞ ꠎꠤꠘꠤꠡ ꠀꠞ ꠝꠣꠐꠤꠞ ꠕꠣꠟ-ꠛꠣꠡꠘꠅ ꠕꠣꠇꠦ। ꠄꠞꠝꠣꠎꠦ ꠇꠥꠘꠥꠐꠣ ꠡꠝ꠆ꠝꠣꠘꠤ ꠇꠣꠝꠅ ꠀꠞ ꠇꠥꠘꠥꠐꠣ ꠘꠤꠌꠣ ꠇꠣꠝꠅ ꠛꠦꠛꠢꠣꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("T22_21","085_2_21","2TI","2","21","21","ꠔꠦ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠅꠃ ꠘꠤꠌꠣ ꠇꠣꠝꠞ ꠀꠡꠛꠣꠛꠞ ꠟꠣꠈꠣꠘ, ꠁꠔꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠀꠁꠀ ꠇꠦꠃ ꠎꠥꠖꠤ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠢꠦ ꠡꠝ꠆ꠝꠣꠘꠤ ꠎꠤꠘꠤꠡ ꠛꠘꠤꠎꠣꠄ। ꠔꠣꠞꠦ ꠙꠛꠤꠔ꠆ꠞ ꠢꠤꠡꠣꠛꠦ ꠀꠟꠣꠖꠣ ꠇꠞꠤ ꠞꠣꠈꠣ ꠅꠁꠛ। ꠢꠦ ꠔꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠇꠣꠝꠅ ꠟꠣꠉꠛ ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T22_22","085_2_22","2TI","2","22","22","ꠔꠤꠝꠕꠤ ꠢꠥꠡꠤꠀꠞ ꠅꠅ, ꠎꠃꠛꠘꠞ ꠛꠖ ꠈꠣꠁꠡ ꠕꠣꠇꠤ ꠔꠥꠝꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅ, ꠀꠞ ꠎꠦꠞꠣ ꠈꠣꠍ ꠖꠤꠟꠦ ꠝꠣꠟꠤꠇꠞ ꠘꠣꠝ ꠟꠄ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠀ ꠙꠞꠦꠎꠉꠣꠞꠤ, ꠁꠝꠣꠘ, ꠝꠢꠛ꠆ꠛꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("T22_23","085_2_23","2TI","2","23","23","ꠀꠎꠦ-ꠛꠣꠎꠦ ꠛꠦꠀꠈꠟꠤ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤꠔ ꠡꠣꠝꠤꠟ ꠅꠁꠅ ꠘꠣ, ꠔꠥꠝꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠁꠔꠣꠄ ꠈꠣꠟꠤ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠛꠣꠠꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("T22_24","085_2_24","2TI","2","24","24","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠉꠥꠟꠣꠝꠦ ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠇꠞꠣ ꠑꠤꠇ ꠘꠣꠄ, ꠄꠁꠘ ꠛꠞꠋ ꠢꠇꠟꠞ ꠛꠣꠄ ꠖꠄꠀꠟ ꠅꠁꠔꠦ ꠅꠁꠛ, ꠄꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀꠞ ꠈꠦꠝꠔꠣ ꠀꠞ ꠍꠛꠞ-ꠡꠇ꠆ꠔꠤ ꠕꠣꠇꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T22_25","085_2_25","2TI","2","25","25","ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠛꠤꠞꠥꠗꠤ ꠝꠣꠘꠡꠞꠦꠅ ꠘꠞꠝ ꠝꠘꠦ ꠛꠥꠎ ꠖꠤꠛꠣ। ꠅꠃ ꠀꠡꠣꠄ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣ, ꠢꠄꠔꠛꠣ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠛꠣ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞꠦ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠌꠤꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T22_26","085_2_26","2TI","2","26","26","ꠔꠦꠃ ꠔꠣꠞꠣ ꠌꠦꠔꠘ ꠙꠣꠁꠀ ꠁꠛꠟꠤꠍꠞ ꠚꠣꠘ꠆ꠖꠅ ꠕꠣꠇꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠛꠣ, ꠅꠃ ꠁꠛꠟꠤꠍꠦ ꠔꠣꠞ ꠉꠥꠟꠣꠝ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠞꠣꠞꠦ ꠗꠞꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("T23_1","085_3_1","2TI","3","1","1","ꠅ ꠔꠤꠝꠕꠤ, ꠅꠃ ꠢꠥꠡꠤꠀꠞꠤ ꠈꠣꠘꠣꠁꠘ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠔ ꠈꠥꠛ ꠝꠍꠤꠛꠔꠞ ꠖꠤꠘ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T23_2","085_3_2","2TI","3","2","2","ꠝꠣꠘꠥꠡ ꠡ꠆ꠛꠣꠞꠕꠙꠞ ꠅꠁꠎꠤꠛ, ꠐꠦꠇꠣ-ꠙꠄꠡꠣꠞ ꠟꠣꠟꠌꠤ, ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠘꠤ, ꠝꠣꠘꠡꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠣ, ꠖꠥꠞꠘꠣꠝ ꠉꠣꠅꠀ, ꠝꠣ-ꠛꠣꠚꠞ ꠅꠛꠣꠁꠖ꠆ꠖ, ꠘꠤꠝꠇ-ꠢꠣꠞꠣꠝꠤ ꠇꠞꠛ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("T23_3","085_3_3","2TI","3","3","3","ꠝꠣꠄꠀ-ꠝꠝꠔꠣ ꠇꠝꠤꠎꠤꠛ, ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠇꠞꠟꠦ ꠀꠙꠥꠡ ꠇꠞꠔ ꠘꠣꠄ। ꠙꠞꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠛ, ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠝꠣꠘꠥꠡ ꠅꠝꠣꠘꠥꠡ ꠅꠁꠎꠤꠛ ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠖꠥꠡꠝꠘꠤ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("T23_4","085_3_4","2TI","3","4","4","ꠝꠣꠘꠡꠦ ꠛꠦꠁꠝꠣꠘꠤ, ꠚꠥꠐꠣꠘꠤ ꠀꠞ ꠛꠦꠙꠞꠥꠀ ꠜꠣꠛ ꠖꠦꠈꠣꠁꠛ, ꠀꠟ꠆ꠟꠣꠞ ꠀꠡꠤꠇ ꠘꠣ ꠅꠁꠀ ꠖꠥꠘꠤꠀꠛꠤ ꠀꠞꠣꠝ-ꠀꠄꠄꠡꠞ ꠀꠡꠤꠇ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T23_5","085_3_5","2TI","3","5","5","ꠛꠣꠁꠞꠞ ꠜꠣꠛ-ꠍꠥꠞꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ ꠈꠥꠛ ꠀꠟ꠆ꠟꠣꠅꠀꠟꠣ ꠙꠣꠇ-ꠝꠥꠍꠟ꠆ꠟꠤ, ꠅꠁꠟꠦ ꠝꠥꠟꠔ ꠟꠦꠛꠣꠍꠗꠣꠞꠤ ꠜꠘ꠆ꠒ। ꠔꠦ ꠔꠥꠝꠤ ꠁꠔꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("T23_6","085_3_6","2TI","3","6","6","ꠅꠔꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠇꠦꠃ ꠗꠥꠇꠣ ꠖꠤꠀ ꠝꠣꠘꠡꠞ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠀ ꠇꠝ ꠁꠝꠣꠘꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠇꠥ-ꠙꠕꠦ ꠐꠣꠘꠦ। ꠁꠔꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠝꠉꠎ ꠅꠁꠟ ꠉꠥꠘꠣꠞ ꠜꠣꠘ꠆ꠒꠣꠞ। ꠔꠣꠞꠣ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖꠞ ꠛꠡꠦ ꠌꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("T23_7","085_3_7","2TI","3","7","7","ꠔꠣꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣꠁ ꠙꠕꠞ ꠔꠣꠟꠤꠝ ꠢꠥꠘꠦ, ꠅꠁꠟꠦ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠤꠇꠔ ꠔꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("T23_8","085_3_8","2TI","3","8","8","ꠝꠤꠡꠞꠞ ꠚꠦꠞꠣꠃꠘꠞ ꠎꠣꠖꠥꠉꠤꠞ-ꠉꠥꠘꠤꠘ ꠎꠣꠘ꠆ꠘꠤ ꠀꠞ ꠎꠣꠝ꠆ꠛꠞꠤꠄ ꠎꠦꠟꠣ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠍꠤꠟꠣ, ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠅꠉꠥꠁꠘ꠆ꠔꠦꠅ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠦ। ꠁꠔꠣꠞ ꠛꠤꠛꠦꠇ ꠙꠌꠤ ꠉꠦꠍꠦ, ꠔꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠁꠝꠣꠘꠞ ꠜꠣꠟꠣꠁ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("T23_9","085_3_9","2TI","3","9","9","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠀꠞ ꠀꠉꠥꠀꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ, ꠢꠃ ꠎꠣꠖꠥꠉꠤꠞ ꠎꠣꠘ꠆ꠘꠤ ꠀꠞ ꠎꠣꠝ꠆ꠛꠞꠤꠞ ꠛꠦꠀꠈꠟꠤ ꠎꠦꠟꠣ ꠢꠇꠟꠞ ꠉꠦꠍꠦ ꠗꠞꠣ ꠙꠠꠍꠤꠟ, ꠁꠔꠣꠞ ꠛꠦꠀꠈꠟꠤꠅ ꠅꠟꠣ ꠗꠞꠣ ꠙꠠꠛ। ");
INSERT INTO syls_vpl VALUES ("T23_10","085_3_10","2TI","3","10","10","ꠅ ꠔꠤꠝꠕꠤ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠔꠣꠟꠤꠝ, ꠀꠝꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ, ꠀꠝꠣꠞ ꠃꠖ꠆ꠖꠦꠡ꠆ꠡ, ꠁꠝꠣꠘ, ꠍꠛꠞꠉꠣꠞꠤ, ꠝꠢꠛ꠆ꠛꠔ, ꠀꠞ ꠀꠝꠣꠞ ꠗꠂꠎ꠆ꠎꠞ ꠇꠕꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠈꠤꠀꠟ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("T23_11","085_3_11","2TI","3","11","11","ꠀꠘ꠆ꠔꠤꠅꠈꠤꠀ, ꠁꠇꠘꠤꠅ ꠀꠞ ꠟꠥꠡ꠆ꠞꠣ ꠐꠣꠃꠘꠅ ꠀꠝꠤ ꠇꠔ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠡꠁꠎ꠆ꠎ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠤ ꠎꠣꠘ। ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇꠦ ꠀꠝꠣꠞꠦ ꠞꠇ꠆ꠇꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T23_12","085_3_12","2TI","3","12","12","ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚ ꠜꠤꠔꠞꠦ ꠞꠣꠈꠤꠀ, ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠖꠣꠞ ꠛꠘꠤꠀ ꠎꠦꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔ ꠌꠣꠄ, ꠔꠣꠞꠣ ꠔ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔꠅ ꠙꠠꠛꠃ। ");
INSERT INTO syls_vpl VALUES ("T23_13","085_3_13","2TI","3","13","13","ꠅꠁꠟꠦ ꠜꠘ꠆ꠒ ꠀꠞ ꠈꠛꠤꠍ ꠅꠇꠟ ꠖꠤꠘ ꠖꠤꠘ ꠀꠞꠅ ꠈꠣꠞꠣꠙ ꠅꠁꠛ। ꠔꠣꠞꠣ ꠘꠤꠎꠦꠅ ꠛꠦ-ꠙꠕꠦ ꠌꠟꠛ, ꠀꠞ ꠀꠞꠇ ꠎꠘꠞꠦꠅ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("T23_14","085_3_14","2TI","3","14","14","ꠔꠦ ꠔꠥꠝꠤ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍ, ꠙꠣꠁꠀ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠄꠇꠤꠘ ꠇꠞꠍ, ꠄꠞ ꠃꠙꠞꠦ ꠕꠤꠞ ꠕꠣꠇꠅ, ꠇꠣꠞꠘ ꠔꠥꠝꠤ ꠘꠤꠎꠦ ꠎꠣꠘ, ꠁ ꠔꠣꠟꠤꠝ ꠇꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("T23_15","085_3_15","2TI","3","15","15","ꠔꠥꠝꠤ ꠔ ꠢꠥꠞꠥꠝꠣꠘ ꠕꠘꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍ, ꠀꠞ ꠅꠃ ꠇꠣꠟꠣꠝꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ, ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟꠞ ꠙꠕ ꠛꠣꠔꠣꠁ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("T23_16","085_3_16","2TI","3","16","16","ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠙꠞꠔꠦꠇꠐꠣ ꠢꠞꠚ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤꠃ ꠀꠁꠍꠦ। ꠁꠔꠣ ꠔ ꠔꠣꠟꠤꠝ, ꠢꠥꠡꠤꠀꠞꠤ, ꠢꠦꠖꠣꠄꠅꠔ, ꠀꠞ ꠢꠇ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠉꠠꠤꠛꠣꠞ ꠈꠥꠞꠣꠇ, ");
INSERT INTO syls_vpl VALUES ("T23_17","085_3_17","2TI","3","17","17","ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠃꠙꠎꠥꠇ꠆ꠔ ꠛꠘꠤꠀ ꠢꠇꠟ ꠘꠦꠇ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("T24_1","085_4_1","2TI","4","1","1","ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠤꠀ, ꠀꠞ ꠎꠦꠁꠘ ꠔꠣꠝꠣꠝ ꠎꠤꠘ꠆ꠖꠣ-ꠝꠥꠞ꠆ꠖꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ, ꠢꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠞꠣꠈꠤꠀ, ꠖꠥꠘꠤꠀꠔ ꠔꠣꠘ ꠖꠥꠍꠞꠣꠛꠣꠞꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠣ ꠀꠞ ꠔꠣꠘ ꠛꠣꠖꠡꠣꠁꠞ ꠖꠥꠀꠁ ꠖꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠅꠃ ꠇꠠꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("T24_2","085_4_2","2TI","4","2","2","ꠔꠥꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠅ, ꠡꠝꠄ-ꠅꠡꠝꠄ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ, ꠢꠣꠝꠦꠡꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠅ, ꠈꠥꠛ ꠛꠦꠡꠤ ꠗꠂꠎ꠆ꠎ ꠗꠞꠤꠀ ꠔꠣꠟꠤꠝ ꠖꠦꠅ ꠀꠞ ꠝꠣꠘꠡꠞ ꠅꠙꠞꠣꠗ ꠖꠦꠈꠣꠁ ꠖꠦꠅ, ꠔꠣꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠅ ꠀꠞ ꠛꠥꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("T24_3","085_4_3","2TI","4","3","3","ꠀꠉꠦꠖꠤ ꠅꠟꠣ ꠡꠝꠄ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠢꠣꠍꠣ ꠔꠣꠟꠤꠝ ꠝꠣꠘꠡꠞ ꠡꠁꠎ꠆ꠎ ꠅꠁꠔ ꠘꠣꠄ, ꠛꠞꠋ ꠘꠤꠎꠞ ꠝꠘꠞ ꠈꠣꠁꠡ ꠙꠥꠞꠣꠁꠔꠣ ꠇꠞꠤ ꠔꠣꠞꠣ ꠅꠟꠣꠈꠣꠘ ꠃꠡ꠆ꠔꠣꠖ ꠗꠞꠛꠣ, ꠎꠦꠔꠣꠄ ꠔꠣꠞꠣꠞ ꠝꠘ ꠎꠥꠉꠣꠁꠀ ꠝꠘꠉꠠꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T24_4","085_4_4","2TI","4","4","4","ꠔꠣꠞꠣ ꠢꠇ ꠔꠣꠟꠤꠝ ꠕꠣꠇꠤ ꠝꠥꠈ ꠚꠤꠞꠣꠁꠀ, ꠝꠘꠉꠠꠣ ꠇꠤꠌ꠆ꠍꠣ-ꠇꠣꠢꠤꠘꠤꠞ ꠈꠞꠦ ꠖꠃꠠꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T24_5","085_4_5","2TI","4","5","5","ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠅ, ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠅ, ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠔ ꠞꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("T24_6","085_4_6","2TI","4","6","6","ꠀꠝꠣꠞ ꠝꠃꠔꠞ ꠖꠤꠘ ꠀꠁꠀ ꠀꠎꠤ ꠉꠦꠍꠦ, ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠟꠃꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠢꠤꠡꠣꠛꠦ ꠓꠣꠟꠤ ꠖꠦꠅꠀ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("T24_7","085_4_7","2TI","4","7","7","ꠀꠝꠤ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠎꠣꠘꠦ-ꠙꠞꠣꠘꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠍꠤ, ꠀꠝꠣꠞꠦ ꠛꠣꠔꠣꠁ ꠖꠦꠅꠀ ꠙꠕꠞ ꠢꠦꠡ ꠝꠣꠕꠣ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠃꠠꠣꠁꠍꠤ, ꠀꠝꠣꠞ ꠁꠝꠣꠘ ꠐꠤꠇꠣꠁꠀ ꠞꠣꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("T24_8","085_4_8","2TI","4","8","8","ꠔꠦ ꠀꠝꠣꠞ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠔ ꠎꠝꠣ ꠀꠍꠦ, ꠢꠃ ꠢꠇ-ꠁꠘꠍꠣꠚꠇꠣꠞꠤ ꠝꠣꠟꠤꠇꠦ ꠞꠥꠎ ꠢꠣꠡꠞꠞ ꠖꠤꠘ ꠀꠝꠣꠞꠦ ꠎꠄꠅꠞ ꠝꠣꠟꠣ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠖꠤꠛꠣ। ꠁꠔꠣ ꠈꠣꠟꠤ ꠀꠝꠣꠞꠦ ꠘꠣꠄ, ꠎꠔ ꠝꠣꠘꠥꠡ ꠀꠡꠤꠇ ꠅꠁꠀ ꠔꠣꠘ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁꠞꠣ, ꠔꠣꠞꠣ ꠢꠇꠟꠞꠦꠃ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T24_9","085_4_9","2TI","4","9","9","ꠅ ꠔꠤꠝꠕꠤ, ꠔꠥꠝꠤ ꠌꠦꠡ꠆ꠐꠣ ꠌꠣꠟꠣꠁꠀ ꠎꠔ ꠎꠟꠖꠤ ꠙꠣꠞ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠅ। ");
INSERT INTO syls_vpl VALUES ("T24_10","085_4_10","2TI","4","10","10","ꠇꠣꠞꠘ ꠇꠤꠞꠤꠍꠇꠦꠘ ꠜꠣꠁ ꠉꠣꠟꠣꠔꠤꠀ ꠖꠦꠡꠅ, ꠔꠤꠔꠣꠍ ꠜꠣꠁ ꠖꠣꠟꠝꠣꠔꠤꠀ ꠖꠦꠡꠅ ꠉꠦꠍꠂꠘ। ꠀꠞ ꠖꠤꠝꠣꠍ ꠜꠣꠁ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠄꠀꠞ ꠗꠣꠘ꠆ꠖꠣꠔ ꠙꠠꠤꠀ, ꠀꠝꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠕꠤꠡꠟꠘꠤꠇꠤ ꠐꠣꠃꠘꠅ ꠉꠦꠍꠂꠘꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("T24_11","085_4_11","2TI","4","11","11","ꠈꠣꠟꠤ ꠟꠥꠇ ꠜꠣꠁ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠀꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠝꠣꠞ꠆ꠇꠥꠍ ꠜꠣꠁꠞꠦ ꠟꠁꠀ ꠔꠥꠝꠤ ꠎꠟꠖꠤ ꠀꠅ, ꠀꠝꠣꠞ ꠇꠣꠝ-ꠇꠣꠎꠅ ꠔꠣꠁꠘ ꠛꠃꠔ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T24_12","085_4_12","2TI","4","12","12","ꠔꠥꠈꠤꠇ ꠜꠣꠁꠞꠦ ꠀꠝꠤ ꠁꠚꠤꠍꠅ ꠙꠣꠑꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("T24_13","085_4_13","2TI","4","13","13","ꠀꠝꠤ ꠀꠁꠛꠣꠞ ꠡꠝꠄ ꠔꠞꠥꠀꠍ ꠐꠣꠃꠘꠞ ꠇꠣꠞꠚꠥꠍ ꠜꠣꠁꠞ ꠉꠦꠍꠦ, ꠀꠝꠣꠞ ꠄꠇꠈꠣꠘ ꠌꠣꠖ꠆ꠖꠞ ꠕꠁꠀ ꠀꠁꠍꠤ, ꠔꠥꠝꠤ ꠀꠁꠛꠣꠞ ꠙꠕꠦ ꠅꠈꠣꠘꠔꠣ ꠀꠘꠤꠅ, ꠀꠞ ꠀꠝꠣꠞ ꠇꠤꠔꠣꠛ ꠈꠣꠘꠣꠁꠘ, ꠈꠣꠍ ꠇꠞꠤ ꠌꠣꠝꠠꠣꠞ ꠃꠙꠞꠦ ꠟꠦꠈꠣ ꠇꠤꠔꠣꠛ ꠈꠣꠘꠣꠁꠘꠅ ꠀꠘꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("T24_14","085_4_14","2TI","4","14","14","ꠢꠥꠘꠅ, ꠔꠣꠝꠣ-ꠙꠤꠔꠟꠞ ꠇꠣꠝ ꠇꠞꠦ ꠎꠦ ꠍꠤꠇꠘ꠆ꠖꠞ, ꠅꠉꠤꠄ ꠀꠝꠣꠞ ꠛꠃꠔ ꠈꠦꠔꠤ ꠇꠞꠍꠦ, ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠔꠣꠞꠦ ꠃꠙꠎꠥꠇ꠆ꠔ ꠛꠖꠟꠣ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("T24_15","085_4_15","2TI","4","15","15","ꠔꠦ ꠔꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠤ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠢꠦ ꠇꠝꠞ ꠛꠣꠘ꠆ꠖꠤꠀ ꠀꠝꠞꠣꠞ ꠔꠛꠟꠤꠉ ꠇꠣꠝꠞ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("T24_16","085_4_16","2TI","4","16","16","ꠎꠣꠘ ꠘꠤ, ꠀꠝꠣꠞꠦ ꠙꠄꠟꠣ ꠛꠣꠞ ꠎꠦꠛꠟꠣ ꠀꠖꠣꠟꠔꠅ ꠘꠦꠅꠀ ꠅꠁꠟ, ꠅꠃ ꠡꠝꠄ ꠇꠦꠃ ꠀꠝꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠍꠦ ꠘꠣ, ꠢꠇꠟꠦꠃ ꠀꠝꠣꠞꠦ ꠍꠣꠠꠤꠀ ꠜꠣꠉꠤꠍꠦ। ꠔꠣ-ꠅ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠘꠥ ꠔꠣꠞꠣꠞ ꠁ ꠛꠤꠡꠄꠈꠣꠘ ꠢꠤꠡꠣꠛꠅ ꠘꠣ ꠗꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T24_17","085_4_17","2TI","4","17","17","ꠈꠣꠟꠤ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠝꠣꠞ ꠙꠇ꠆ꠇꠦ ꠃꠛꠣꠁꠟꠣ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠛꠟ ꠎꠥꠉꠣꠁꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠜꠤꠘ ꠎꠣꠔꠤꠞ ꠍꠣꠝꠘꠦ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠍꠤ, ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠁꠔꠣ ꠢꠥꠘꠍꠦ। ꠅꠃ ꠛꠤꠌꠣꠞꠅ ꠔꠣꠞꠣꠞ ꠡꠤꠋꠢꠞ ꠝꠥꠈꠞ ꠈꠥꠞꠣꠇ ꠅꠀ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠛꠣꠌꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T24_18","085_4_18","2TI","4","18","18","ꠅꠃ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠛꠖ ꠇꠣꠝ ꠕꠣꠇꠤꠅ ꠀꠝꠣꠞꠦ ꠢꠦꠚꠣꠎꠔꠦ ꠞꠣꠈꠛꠣ ꠀꠞ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠖꠡꠣꠁꠔ ꠙꠣꠞ ꠇꠞꠛꠣ। ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠌꠤꠞꠇꠣꠟ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠅꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("T24_19","085_4_19","2TI","4","19","19","ꠀꠝꠞꠣꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠀꠇꠤꠟꠞꠦ, ꠔꠣꠘ ꠛꠤꠛꠤ ꠚꠤꠍꠇꠤꠟꠣ ꠀꠞ ꠀꠘꠤꠍ ꠜꠣꠁꠞ ꠙꠞꠤꠛꠣꠞꠞꠦ ꠀꠝꠣꠞ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("T24_20","085_4_20","2TI","4","20","20","ꠁꠞꠣꠡ꠆ꠔꠣꠍ ꠜꠣꠁ ꠇꠞꠤꠘ꠆ꠔ ꠐꠣꠃꠘꠅ ꠞꠁꠍꠂꠘ, ꠀꠞ ꠔꠚꠤꠝꠞꠦ ꠛꠦꠝꠣꠞ ꠢꠣꠟꠔꠦ ꠀꠝꠤ ꠝꠤꠟꠤꠔꠣ ꠛꠘ꠆ꠖꠞꠅ ꠕꠁꠀ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("T24_21","085_4_21","2TI","4","21","21","ꠔꠦ ꠔꠥꠝꠤ ꠈꠥꠛ ꠌꠦꠡ꠆ꠐꠣ ꠌꠣꠟꠣꠅ, ꠡꠤꠔꠞ ꠀꠉꠦ ꠀꠁꠛꠣꠞ ꠟꠣꠉꠤ। ꠜꠣꠁ ꠀꠛꠥꠟ, ꠛꠖꠤꠍ, ꠅꠟꠤꠘꠤꠍ, ꠛꠁꠘ ꠇꠥꠟꠥꠖꠤꠀ ꠡꠢ ꠀꠞꠅ ꠢꠇꠟ ꠜꠣꠁ-ꠛꠁꠘꠦ ꠔꠥꠝꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("T24_22","085_4_22","2TI","4","22","22","ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠃꠇ꠆ꠇꠣ। ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠕꠣꠇꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("TT1_1","086_1_1","TIT","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠥꠟꠣꠝ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠍꠣꠢꠣꠛꠤ। ꠀꠝꠣꠞ ꠖꠣꠄꠁꠔ꠆ꠔ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠁꠝꠣꠘꠞ ꠙꠕꠦ ꠀꠘꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠣꠘꠤꠀ ꠌꠟꠣꠞ ꠝꠣꠎꠦ ꠎꠦ ꠢꠇꠤꠇꠔ ꠀꠍꠦ, ꠅꠃ ꠢꠇꠤꠇꠔꠞꠦ ꠌꠤꠘꠣꠁ ꠖꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("TT1_2","086_1_2","TIT","1","2","2","ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠤꠀꠞ, ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠅꠀꠞ ꠀꠡꠣꠄ। ꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥ ꠝꠤꠍꠣ ꠝꠣꠔꠂꠘ ꠘꠣ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠄ ꠁ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠦꠅꠀꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠅꠀꠞ ꠀꠉꠦꠃ। ");
INSERT INTO syls_vpl VALUES ("TT1_3","086_1_3","TIT","1","3","3","ꠔꠣꠁꠘ ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠡꠑꠤꠇ ꠡꠝꠄꠄ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠁꠔꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠞ ꠜꠣꠞ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("TT1_4","086_1_4","TIT","1","4","4","ꠀꠝꠣꠞ ꠢꠃ ꠈꠣꠍ ꠀꠅꠟꠣꠖ ꠔꠤꠔꠣꠍꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ, ꠀꠝꠞꠣ ꠖꠥꠁꠅꠎꠘꠃ ꠄꠇꠁ ꠁꠝꠣꠘꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠝ꠆ꠝꠔ ꠅꠁꠍꠤ। ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠀꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("TT1_5","086_1_5","TIT","1","5","5","ꠔꠤꠔꠣꠍ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠅꠃ ꠇ꠆ꠞꠤꠔꠤ ꠖꠤꠙꠅ ꠕꠁꠀ ꠀꠁꠍꠤ, ꠎꠣꠔꠦ ꠎꠦꠔꠣ ꠇꠣꠝ ꠅꠈꠘꠅ ꠛꠣꠇꠤ ꠞꠁꠍꠦ, ꠔꠥꠝꠤ ꠅꠔꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠖꠣꠄ ꠇꠞ। ꠀꠞ ꠀꠝꠤ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣꠝ, ꠑꠤꠇ ꠅꠃꠟꠣ ꠔꠥꠝꠤ ꠙꠞꠔꠦꠇ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠣꠝꠅ ꠛꠅꠀꠁꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("TT1_6","086_1_6","TIT","1","6","6","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠎꠦ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟ ꠛꠖꠘꠣꠝ ꠍꠣꠠꠣ ꠘꠤꠈꠥꠔ, ꠎꠦꠞꠣꠞ ꠈꠣꠟꠤ ꠄꠇꠎꠘ ꠛꠃ ꠀꠍꠂꠘ, ꠎꠦꠞꠣꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠖꠣꠞ, ꠎꠦꠞꠣ ꠛꠦꠙꠞꠥꠀ ꠜꠣꠛꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠄ ꠘꠣ, ꠛꠞꠋ ꠝꠣ-ꠛꠣꠚꠞ ꠛꠣꠁꠖ꠆ꠖ ꠀꠍꠦ, ꠅꠃ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠔꠥꠝꠤ ꠛꠅꠀꠁꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("TT1_7","086_1_7","TIT","1","7","7","ꠀꠟ꠆ꠟꠣꠁ ꠇꠣꠝꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞꠤ ꠙꠣꠅꠀꠄ ꠎꠦꠇꠥꠘꠥ ꠌꠣꠟꠇꠖꠣꠞ ꠎꠣꠘꠥ ꠛꠖꠘꠣꠝ ꠍꠣꠠꠣ ꠘꠤꠈꠥꠔ ꠅꠁꠘ। ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠡ꠆ꠛꠂꠞꠣꠌꠣꠞ, ꠛꠖꠞꠣꠉꠤ, ꠘꠤꠡꠣꠈꠥꠞ, ꠝꠣꠞꠣ-ꠝꠣꠞꠤ ꠇꠞꠞꠣ ꠛꠣ ꠢꠣꠞꠣꠝ ꠞꠥꠎꠤ-ꠞꠥꠎꠉꠣꠞꠞ ꠟꠣꠟꠌꠤ ꠘꠣ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("TT1_8","086_1_8","TIT","1","8","8","ꠄꠞ ꠛꠖꠟꠣ ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠞꠣ, ꠘꠦꠇ ꠜꠣꠛꠞ ꠀꠡꠤꠇ, ꠢꠇ-ꠢꠣꠟꠣꠟꠤ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠁꠖ꠆ꠖ ꠎꠘ ꠅꠁꠘ। ꠔꠣꠘ ꠜꠣꠟꠣ ꠛꠤꠌꠣꠞ-ꠛꠥꠖ꠆ꠖꠤ ꠕꠣꠇꠦ, ꠀꠞ ꠘꠤꠎꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("TT1_9","086_1_9","TIT","1","9","9","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠎꠦ ꠢꠇ ꠇꠣꠟꠣꠝ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠗꠞꠤꠀ ꠞꠣꠈꠂꠘ, ꠀꠞ ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠈꠣꠐꠤ ꠔꠣꠟꠤꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ꠄꠞꠟꠉꠦ ꠎꠦꠞꠣ ꠔꠣꠘ ꠛꠤꠙꠇ꠆ꠇꠦ ꠀꠍꠦ, ꠔꠣꠞꠣꠞ ꠜꠥꠟ-ꠛꠦꠀꠈꠟꠤꠅ ꠗꠞꠣꠁ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("TT1_10","086_1_10","TIT","1","10","10","ꠇꠣꠞꠘ ꠛꠃꠔ ꠛꠦꠡꠣꠝꠣꠟ ꠝꠣꠘꠥꠡ ꠀꠍꠂꠘ, ꠎꠦꠔꠣꠄ ꠇꠦꠃꠞꠞꠦ ꠝꠣꠘꠂꠘ ꠘꠣ, ꠛꠦꠇꠣꠝꠣ ꠝꠣꠔ ꠝꠣꠔꠂꠘ, ꠍꠟ-ꠌꠔꠥꠞꠤ ꠇꠞꠂꠘ। ꠎꠦꠔꠣꠄ ꠝꠍꠟꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠥꠞꠣ-ꠎꠥꠞꠤ ꠇꠞꠂꠘ, ꠀꠝꠤ ꠈꠣꠍ ꠇꠞꠤ ꠅꠔꠣꠞ ꠇꠕꠣꠃ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("TT1_11","086_1_11","TIT","1","11","11","ꠁꠔꠣꠞ ꠝꠥꠈ ꠛꠘ꠆ꠖ ꠇꠞꠣ ꠎꠞꠥꠞ। ꠁꠔꠣꠄ ꠇꠥ-ꠙꠕꠦ ꠐꠦꠇꠣ ꠇꠣꠝꠣꠘꠤꠞ ꠀꠡꠣꠄ ꠅꠟꠣ ꠔꠣꠟꠤꠝ ꠖꠦꠁꠘ, ꠎꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠘꠣꠄ। ꠁ ꠔꠣꠟꠤꠝ ꠖꠤꠀ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠙꠞꠤꠛꠣꠞꠞꠦ ꠛꠤꠉꠠꠣꠁꠟꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("TT1_12","086_1_12","TIT","1","12","12","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠖꠦꠡꠞ ꠄꠇꠎꠘ ꠙꠘ꠆ꠒꠤꠔꠦ ꠇꠁꠍꠂꠘ, “ꠇ꠆ꠞꠤꠔꠤ ꠖꠤꠙꠞ ꠝꠣꠘꠡꠦ ꠢꠣꠝꠦꠡꠣ ꠝꠤꠍꠣ ꠝꠣꠔꠂꠘ, ꠁꠉꠥꠁꠘ ꠔ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠞ ꠟꠣꠈꠣꠘ, ꠇꠥꠠꠤꠀ ꠀꠞ ꠙꠦꠐꠥꠀ।” ");
INSERT INTO syls_vpl VALUES ("TT1_13","086_1_13","TIT","1","13","13","ꠁꠔꠣ ꠔ ꠄꠇꠖꠝ ꠢꠣꠍꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠤ ꠈꠥꠛ ꠉꠞꠝ ꠅꠁꠀ ꠔꠣꠞꠣꠞ ꠀꠁꠛ ꠖꠦꠈꠣꠁꠀ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠘꠤꠈꠥꠔ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("TT1_14","086_1_14","TIT","1","14","14","ꠁꠢꠥꠖꠤ ꠅꠇꠟꠞ ꠛꠣꠘꠣꠁꠟ ꠇꠤꠌ꠆ꠍꠣ-ꠇꠣꠢꠤꠘꠤ, ꠀꠞ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠤꠇꠔ ꠕꠣꠇꠤ ꠛꠦ-ꠙꠕꠦ ꠉꠦꠍꠦꠉꠤ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠁꠔꠣꠞ ꠢꠥꠇꠥꠝ-ꠃꠙꠖꠦꠡ ꠇꠣꠘꠅ ꠘꠣ ꠟꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("TT1_15","086_1_15","TIT","1","15","15","ꠎꠦꠞꠣꠞ ꠖꠤꠟ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠢꠇꠟꠔꠣꠃ ꠙꠛꠤꠔ꠆ꠞ। ꠅꠁꠟꠦ ꠎꠦꠞꠣꠞ ꠖꠤꠟ ꠘꠣꠙꠣꠇꠤꠄ ꠜꠞꠣ, ꠀꠞ ꠎꠦꠔꠣ ꠛꠦꠁꠝꠣꠘ, ꠁꠔꠣꠞ ꠉꠦꠍꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠙꠛꠤꠔ꠆ꠞ ꠘꠣꠄ। ꠁꠔꠣꠞ ꠝꠘ ꠀꠞ ꠛꠤꠛꠦꠇ ꠢꠇꠟꠔꠣꠃ ꠛꠞꠛꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("TT1_16","086_1_16","TIT","1","16","16","ꠔꠣꠞꠣ ꠝꠥꠈꠖꠤ ꠖꠣꠛꠤ ꠇꠞꠂꠘ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠣꠘꠂꠘ, ꠅꠁꠟꠦ ꠔꠣꠞꠣꠞ ꠇꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠘꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠂꠘ। ꠁꠉꠥꠁꠘ ꠔ ꠘꠚꠞꠔꠤ ꠀꠞ ꠅꠛꠣꠁꠖ꠆ꠖ। ꠁꠔꠣꠞꠦ ꠇꠥꠘꠥ ꠜꠣꠟꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠟ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("TT2_1","086_2_1","TIT","2","1","1","ꠔꠤꠔꠣꠍ ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠝꠣꠘꠡꠞꠦ ꠅꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠔꠥꠝꠣꠞ ꠝꠣꠔꠞ ꠝꠣꠎꠦ ꠘꠤꠈꠥꠔ ꠢꠇ ꠔꠣꠟꠤꠝ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("TT2_2","086_2_2","TIT","2","2","2","ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠦꠐꠣꠁꠘꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠢꠣꠝꠦꠡꠣ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠂꠘ, ꠁꠎ꠆ꠎꠔꠤ ꠛꠘꠂꠘ, ꠜꠣꠟꠣ ꠛꠤꠌꠣꠞ-ꠛꠤꠛꠦꠇ ꠈꠣꠐꠣꠁꠘ। ꠔꠣꠞꠣꠞ ꠎꠣꠘꠥ ꠈꠣꠐꠤ ꠁꠝꠣꠘ, ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠀꠞ ꠍꠛꠞ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("TT2_3","086_2_3","TIT","2","3","3","ꠅꠟꠣꠈꠣꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦꠅ ꠇꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠀꠖꠛ-ꠇꠣꠄꠖꠣ ꠝꠣꠘꠤꠀ ꠌꠟꠂꠘ ꠀꠞ ꠘꠦꠇꠤꠞ ꠜꠣꠛ ꠢꠤꠇꠣꠁꠘ। ꠅꠁꠘ꠆ꠘꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠅꠀ, ꠛꠣ ꠘꠤꠡꠣꠈꠥꠞ ꠛꠘꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("TT2_4","086_2_4","TIT","2","4","4","ꠔꠦꠃ ꠔꠣꠞꠣ ꠎꠥꠀꠘ ꠙꠥꠠꠤꠘ꠆ꠔꠞꠦ ꠢꠤꠇꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠎꠣꠝꠣꠁ ꠀꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("TT2_5","086_2_5","TIT","2","5","5","ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠂꠘ, ꠡꠔꠤ ꠞꠂꠘ, ꠜꠣꠟꠣ ꠡꠋꠡꠣꠞꠤ ꠅꠁꠘ, ꠖꠄꠀꠟꠥ ꠅꠁꠘ, ꠀꠞ ꠎꠣꠝꠣꠁꠞ ꠛꠣꠁꠖ꠆ꠖ ꠕꠣꠇꠂꠘ। ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠛꠖꠘꠣꠝ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠇꠦꠃ ꠙꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("TT2_6","086_2_6","TIT","2","6","6","ꠅꠟꠣꠈꠣꠘ ꠎꠥꠀꠘ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦꠅ ꠃꠙꠖꠦꠡ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("TT2_7","086_2_7","TIT","2","7","7","ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠘꠤꠡꠣꠘꠣ ꠅꠅ। ꠢꠇ ꠘꠤꠅꠔꠦ ꠀꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠟꠁꠀ ꠔꠣꠟꠤꠝ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("TT2_8","086_2_8","TIT","2","8","8","ꠇꠦꠃ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞ ꠎꠛꠣꠘꠞ ꠇꠥꠘꠥ ꠖꠥꠡ ꠘꠣ ꠙꠣꠄ। ꠔꠥꠝꠣꠞ ꠅꠃꠟꠣ ꠌꠣꠟ-ꠌꠟꠘ ꠖꠦꠈꠤꠀ ꠖꠥꠡꠝꠘ ꠅꠇꠟ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠛꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠛꠖꠘꠣꠝ ꠇꠞꠣꠞ ꠇꠥꠘꠥ ꠈꠥꠔ ꠙꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("TT2_9","086_2_9","TIT","2","9","9","ꠔꠥꠝꠤ ꠌꠣꠇꠞ ꠅꠇꠟꠞꠦ ꠇꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠢꠇ꠆ꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠝꠥꠘꠤꠛꠞ ꠛꠣꠁꠖ꠆ꠖ ꠞꠂꠘ, ꠝꠥꠘꠤꠛꠞ ꠝꠘ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠂꠘ, ꠔꠣꠞꠣꠞ ꠝꠥꠈꠞ ꠃꠙꠞꠦ ꠛꠦꠀꠖꠛꠤ ꠝꠣꠔ ꠘꠣ ꠝꠣꠔꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("TT2_10","086_2_10","TIT","2","10","10","ꠝꠥꠘꠤꠛꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠌꠥꠞꠤ ꠘꠣ ꠇꠞꠂꠘ, ꠛꠞꠋ ꠘꠤꠎꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤꠞ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠀ ꠢꠣꠞꠤ, ꠀꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠦ ꠔꠣꠟꠤꠝ ꠀꠍꠦ, ꠅꠃ ꠔꠣꠟꠤꠝꠞꠦ ꠢꠇ꠆ꠇꠟ ꠘꠝꠥꠘꠣꠄ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("TT2_11","086_2_11","TIT","2","11","11","ꠎꠣꠘ ꠔ, ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠞꠢꠝꠔꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠢꠇꠟꠞ ꠘꠣꠎꠣꠔ ꠝꠤꠟꠦ, ꠁꠔꠣ ꠅꠈꠘ ꠖꠥꠘꠤꠀꠔ ꠎꠣꠁꠞ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("TT2_12","086_2_12","TIT","2","12","12","ꠅꠃ ꠞꠢꠝꠔꠦꠃ ꠀꠝꠞꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠤꠞꠣ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠛꠦ-ꠖꠤꠘꠤ ꠇꠣꠝ-ꠇꠣꠎ ꠕꠣꠇꠤ ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠛꠖ ꠈꠣꠁꠡ ꠕꠣꠇꠤ ꠖꠥꠞꠁ ꠞꠁꠀ, ꠁ ꠎꠉꠔꠅ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠤ, ꠀꠞ ꠘꠦꠇ ꠙꠕꠦ ꠞꠁꠀ ꠙꠞꠦꠎꠉꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("TT2_13","086_2_13","TIT","2","13","13","ꠄꠞꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠙꠞꠝ ꠀꠡꠣ ꠙꠥꠞꠘꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁ, ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣ ꠀꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠡꠣꠘ-ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠀꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠙꠥꠞꠘꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("TT2_14","086_2_14","TIT","2","14","14","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠢꠇꠟ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠦ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠀꠘꠔꠣ ꠙꠣꠞꠂꠘ, ꠀꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠄꠇꠖꠟ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠂꠘ, ꠎꠦꠞꠣ ꠈꠣꠟꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠅꠁꠛꠣ, ꠎꠦꠞꠣ ꠘꠦꠇ ꠇꠣꠝꠞ ꠀꠡꠤꠇ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("TT2_15","086_2_15","TIT","2","15","15","ꠔꠥꠝꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠛꠟ ꠈꠣꠐꠣꠁꠀ ꠅꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠟꠤꠝ ꠖꠦꠅ, ꠝꠣꠘꠡꠞꠦ ꠘꠍꠤꠅꠔ ꠇꠞꠅ ꠀꠞ ꠔꠣꠞꠣꠞ ꠖꠥꠡ-ꠇꠍꠥꠞꠤ ꠖꠦꠈꠣꠁꠀ ꠖꠦꠅ। ꠔꠥꠝꠣꠞꠦ ꠢꠦꠄ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠇꠦꠃꠞꠞꠦ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("TT3_1","086_3_1","TIT","3","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠝꠘꠅ ꠇꠞꠣꠁ ꠖꠦꠅ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠖꠦꠡꠞ ꠞꠣꠎꠣ ꠀꠞ ꠡꠞꠇꠣꠞꠤ ꠘꠤꠅꠝꠞ ꠅꠗꠤꠘꠦ ꠞꠂꠘ, ꠔꠣꠞꠣ ꠅꠛꠣꠁꠖ꠆ꠖ ꠘꠣ ꠅꠁꠘ, ꠝꠣꠘꠡꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠃꠙꠇꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠕꠣꠇꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("TT3_2","086_3_2","TIT","3","2","2","ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠇꠦꠃꠞꠞ ꠛꠖꠘꠣꠝ ꠘꠣ ꠉꠣꠁꠘ, ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ ꠘꠣ ꠇꠞꠂꠘ, ꠛꠞꠋ ꠡꠣꠘ꠆ꠔ-ꠡꠤꠡ꠆ꠐ ꠞꠁꠀ ꠢꠇꠟꠞ ꠟꠉꠦ ꠘꠞꠝ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("TT3_3","086_3_3","TIT","3","3","3","ꠀꠝꠞꠣꠅ ꠀꠉꠦ ꠛꠦꠀꠈꠟ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠀꠍꠟꠣꠝ, ꠛꠦ-ꠙꠕꠦ ꠌꠟꠔꠣꠝ, ꠖꠥꠘꠤꠀꠛꠤ ꠀꠞꠣꠝ-ꠀꠄꠄꠡ ꠀꠞ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠉꠥꠟꠣꠝ ꠀꠍꠟꠣꠝ। ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞꠦ ꠁꠋꠡꠣ ꠇꠞꠔꠣꠝ, ꠔꠣꠞꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠗꠣꠘ꠆ꠖꠣꠄ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠔꠣꠝ। ꠀꠞ ꠘꠤꠎꠦ ꠊꠤꠘ꠆ꠘꠣꠞ ꠎꠁꠉ꠆ꠉ ꠅꠁꠟꠦꠅ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠔꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("TT3_4","086_3_4","TIT","3","4","4","ꠅꠁꠟꠦ ꠀꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠀꠞ ꠝꠢꠛ꠆ꠛꠔ ꠎꠦꠛꠟꠣ ꠎꠣꠁꠞ ꠅꠁꠟ, ");
INSERT INTO syls_vpl VALUES ("TT3_5","086_3_5","TIT","3","5","5","ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠞꠦꠢꠣꠁ ꠖꠤꠟꠣ। ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠇꠥꠘꠥ ꠘꠦꠇ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠞꠦꠢꠣꠁ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠔꠣꠘ ꠖꠄꠀ-ꠝꠣꠄꠀꠄ ꠖꠤꠍꠂꠘ। ꠙꠣꠇ ꠞꠥꠢꠦ ꠘꠄꠀ ꠎꠘꠝ ꠖꠤꠀ, ꠘꠄꠀ ꠜꠣꠛꠦ ꠙꠄꠖꠣ ꠇꠞꠤꠀ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠞꠍꠂꠘ। ꠀꠞ ꠅꠟꠣꠈꠣꠘꠃ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠞꠦꠢꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("TT3_6","086_3_6","TIT","3","6","6","ꠀꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠁꠘ ꠈꠥꠟꠣ ꠀꠔꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠃ ꠙꠣꠇ ꠞꠥꠢꠥ ꠓꠣꠟꠤꠀ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("TT3_7","086_3_7","TIT","3","7","7","ꠎꠣꠔꠦ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠙꠣꠁꠀ, ꠀꠟ꠆ꠟꠣꠁ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠅꠗꠤꠇꠣꠞꠤ ꠅꠁ। ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠛꠦ-ꠇꠍꠥꠞ ꠈꠣꠟꠣꠍ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠣꠄꠃ ꠔ ꠀꠝꠞꠣ ꠁꠔꠣ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("TT3_8","086_3_8","TIT","3","8","8","ꠁꠈꠣꠘ ꠔ ꠙꠥꠞꠣꠙꠥꠞ ꠢꠣꠍꠣ। ꠀꠝꠤ ꠌꠣꠁꠀꠞ, ꠔꠥꠝꠤ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠎꠥꠞ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠦ, ꠔꠣꠞꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠤ ꠅꠄ। ꠁꠟꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣ ꠔ ꠢꠇꠟꠞ ꠟꠣꠉꠤ ꠜꠣꠟꠣ ꠀꠞ ꠃꠙꠇꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("TT3_9","086_3_9","TIT","3","9","9","ꠔꠣ-ꠅ ꠛꠦꠅꠇꠥꠚꠞ ꠟꠣꠈꠣꠘ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ, ꠎꠣꠔ-ꠛꠋꠡ ꠟꠁꠀ ꠝꠣꠔꠣ, ꠇꠣꠁꠎ꠆ꠎꠣ-ꠚꠍꠣꠖ, ꠀꠞ ꠡꠞꠤꠅꠔ ꠟꠁꠀ ꠇꠕꠣ ꠇꠣꠐꠣꠇꠣꠐꠤ ꠇꠞꠤꠅ ꠘꠣ। ꠁꠔꠣꠄ ꠔ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠄ ꠘꠣ, ꠁꠔꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠛꠦꠇꠣꠝꠣ। ");
INSERT INTO syls_vpl VALUES ("TT3_10","086_3_10","TIT","3","10","10","ꠎꠦ ꠝꠣꠘꠡꠦ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠣꠄ, ꠔꠣꠞꠦ ꠙꠄꠟꠣ ꠄꠇꠛꠣꠞ, ꠛꠣꠖꠦ ꠖꠥꠍꠞꠣꠛꠣꠞꠅ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤꠅ, ꠁꠔꠣꠄ ꠎꠥꠖꠤ ꠢꠦ ꠘꠣ ꠛꠖꠟꠦ, ꠔꠦ ꠔꠣꠞ ꠟꠉꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠄꠇ꠆ꠇꠦꠞꠦ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("TT3_11","086_3_11","TIT","3","11","11","ꠔꠥꠝꠤ ꠔ ꠎꠣꠘꠃ, ꠁꠔꠣ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠌꠤꠘ꠆ꠔꠣ ꠈꠥꠛ ꠈꠣꠞꠣꠙ, ꠢꠦ ꠉꠥꠘꠣꠉꠣꠞ। ꠢꠦ ꠄꠝꠘꠦꠃ ꠘꠤꠎꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠙꠞꠝꠣꠘ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("TT3_12","086_3_12","TIT","3","12","12","ꠔꠤꠔꠣꠍ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠀꠞ꠆ꠔꠤꠝꠣꠍ ꠛꠣ ꠔꠥꠈꠤꠇ ꠜꠣꠁꠞꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠁꠝꠥ, ꠄꠞꠣ ꠇꠦꠃ ꠉꠦꠟꠦ ꠔꠥꠝꠤ ꠈꠣꠍ ꠇꠞꠤ ꠌꠦꠡ꠆ꠐꠣ ꠇꠞꠤꠅ ꠘꠤꠇꠣꠙꠟꠤ ꠐꠣꠃꠘꠅ ꠀꠁꠀ ꠀꠝꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ꠀꠝꠤ ꠘꠤꠅꠔ ꠇꠞꠍꠤ, ꠡꠤꠔꠞ ꠇꠄꠝꠣꠡ ꠅꠃ ꠘꠤꠇꠣꠙꠟꠤꠔ ꠞꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("TT3_13","086_3_13","TIT","3","13","13","ꠃꠇꠤꠟ ꠎꠁꠘ ꠍꠣꠛ ꠀꠞ ꠀꠙꠟ꠆ꠟꠍ ꠜꠣꠁꠞ ꠍꠚꠞꠞ ꠟꠣꠉꠤ ꠎꠔꠈꠣꠘ ꠙꠣꠞ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠤꠅ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠅꠜꠣꠛ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("TT3_14","086_3_14","TIT","3","14","14","ꠀꠝꠞꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠔ ꠢꠤꠇꠣꠘꠤ ꠎꠞꠥꠞ, ꠡꠝꠣꠎꠞ ꠜꠣꠟꠣꠁꠞ ꠟꠣꠉꠤ ꠇꠤꠟꠣ ꠘꠤꠎꠞꠦ ꠈꠣꠐꠣꠁꠟ ꠎꠣꠄ। ꠔꠦꠃ ꠔꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠎꠞꠥꠞꠤ ꠅꠜꠣꠛ ꠝꠤꠐꠣꠁꠔ ꠙꠣꠞꠛ, ꠅꠟꠣ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠅ ꠚꠟꠀꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("TT3_15","086_3_15","TIT","3","15","15","ꠀꠝꠣꠞ ꠟꠉꠞ ꠢꠇꠟꠦ ꠔꠥꠝꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣꠄ ꠎꠦꠞꠣ ꠀꠝꠞꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠂꠘ, ꠔꠣꠞꠣꠞꠦ ꠀꠝꠣꠞ ꠍꠣꠟꠣꠝ ꠖꠤꠅ। ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠇꠣꠁꠝ ꠞꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("PM1_1","087_1_1","PHM","1","1","1","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠛꠘ꠆ꠖꠤ ꠀꠍꠤ। ꠀꠝꠤ ꠀꠞ ꠀꠝꠞꠣꠞ ꠜꠣꠁ ꠔꠤꠝꠕꠤꠄ, ꠀꠝꠞꠣꠞ ꠟꠉꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ ꠚꠤꠟꠤꠝꠘꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PM1_2","087_1_2","PHM","1","2","2","ꠛꠁꠘ ꠀꠚꠤꠀ, ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠁꠝꠣꠘꠞ ꠎꠥꠖ꠆ꠖꠣ ꠀꠞ꠆ꠈꠤꠙꠣꠍ ꠀꠞ ꠔꠥꠝꠣꠞ ꠛꠣꠠꠤꠞ ꠎꠝꠣꠔꠞ ꠢꠇꠟꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PM1_3","087_1_3","PHM","1","3","3","ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠘꠣꠎꠤꠟ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("PM1_4","087_1_4","PHM","1","4","4","ꠀꠝꠤ ꠢꠣꠝꠦꠡꠣ ꠝꠥꠘꠣꠎꠣꠔꠞ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠡꠥꠇꠞꠤꠀ ꠀꠖꠣꠄ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("PM1_5","087_1_5","PHM","1","5","5","ꠇꠣꠞꠘ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘ ꠀꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠛꠣꠄ ꠔꠥꠝꠣꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠇꠕꠣ ꠀꠝꠤ ꠢꠥꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("PM1_6","087_1_6","PHM","1","6","6","ꠀꠝꠤ ꠖꠥꠀ ꠇꠞꠤ, ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞ ꠟꠉꠦ ꠔꠥꠝꠣꠞ ꠈꠣꠔꠤꠞ-ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠀꠞꠅ ꠛꠣꠠꠃꠇ। ꠔꠥꠝꠤ ꠔ ꠎꠣꠘ, ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠇꠔ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠘꠤꠀꠝꠔ ꠛꠤꠟꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PM1_7","087_1_7","PHM","1","7","7","ꠜꠣꠁ, ꠔꠥꠝꠣꠞ ꠝꠢꠛ꠆ꠛꠔ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠍꠤ ꠀꠞ ꠃꠔꠡꠣꠢ ꠙꠣꠁꠍꠤ, ꠔꠥꠝꠤ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠖꠤꠟꠅ ꠀꠞꠣꠝ ꠖꠤꠍ। ");
INSERT INTO syls_vpl VALUES ("PM1_8","087_1_8","PHM","1","8","8","ꠔꠥꠝꠣꠞ ꠁ ꠜꠣꠛ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠄꠇꠈꠣꠘ ꠇꠕꠣ ꠇꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ। ꠀꠝꠤ ꠔ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠔꠥꠝꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠔꠣꠝ ꠙꠣꠞꠟꠣꠝ ꠅꠘꠦ, ꠔꠥꠝꠣꠞ ꠇꠣꠝ ꠙꠥꠞꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("PM1_9","087_1_9","PHM","1","9","9","ꠅꠁꠟꠦ ꠝꠢꠛ꠆ꠛꠔꠞ ꠈꠣꠔꠤꠞꠦ ꠢꠥꠇꠥꠝ ꠘꠣ ꠖꠤꠀ ꠔꠥꠝꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤꠀꠞ। ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍ ꠅꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠛꠄꠅꠡꠅ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠛꠘ꠆ꠖꠤ ꠢꠣꠟꠔꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠁ ꠝꠤꠘꠔꠤ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PM1_10","087_1_10","PHM","1","10","10","ꠀꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠘꠤꠍꠤꠝꠞ ꠟꠣꠉꠤ ꠀꠞꠎꠤ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠀꠝꠤ ꠎꠦꠟꠅ ꠛꠘ꠆ꠖꠤ ꠕꠣꠇꠣ ꠢꠣꠟꠔꠦ ꠢꠦ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠀꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PM1_11","087_1_11","PHM","1","11","11","ꠄꠇ ꠡꠝꠄ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠢꠦ ꠛꠦꠇꠣꠝꠣ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠣꠞ ꠀꠞ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠢꠦ ꠛꠃꠔ ꠇꠣꠝꠣꠅꠞꠣ ꠛꠘꠤꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("PM1_12","087_1_12","PHM","1","12","12","ꠎꠣꠁ ꠅꠃꠇ, ꠀꠝꠣꠞ ꠎꠣꠘꠞ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠝꠣꠄꠀꠞ ꠅꠃ ꠝꠣꠘꠡꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠔ ꠙꠣꠑꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("PM1_13","087_1_13","PHM","1","13","13","ꠀꠝꠤ ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠞꠣꠈꠔꠣꠝ ꠌꠣꠁꠍꠟꠣꠝ, ꠎꠣꠔꠦ ꠈꠥꠡ-ꠈꠛꠞꠤꠞ ꠖꠣꠄ ꠛꠘ꠆ꠖꠤ ꠢꠣꠟꠔꠦ ꠔꠥꠝꠣꠞ ꠅꠁꠀ ꠢꠦ ꠀꠝꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("PM1_14","087_1_14","PHM","1","14","14","ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠁꠎꠣꠎꠔ ꠍꠣꠠꠣ ꠀꠝꠤ ꠇꠥꠘ꠆ꠔꠣ ꠇꠞꠟꠣꠝ ꠘꠣ, ꠎꠣꠔꠦ ꠎꠥꠞ ꠇꠞꠤꠀ ꠔꠥꠝꠣꠞ ꠜꠣꠟꠣ ꠇꠣꠝ ꠀꠖꠣꠄ ꠇꠞꠣ ꠘꠣ ꠟꠣꠉꠦ। ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠘꠤꠎ ꠕꠣꠇꠤꠃ ꠅꠃ ꠇꠣꠝ ꠇꠞ। ");
INSERT INTO syls_vpl VALUES ("PM1_15","087_1_15","PHM","1","15","15","ꠔꠥꠝꠤ ꠎꠣꠔꠦ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠦ ꠚꠤꠞꠤꠀ ꠙꠣꠅ, ꠅꠁꠔ ꠙꠣꠞꠦ ꠅꠃ ꠇꠣꠞꠘꠦꠃ ꠢꠦ ꠔꠥꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠢꠞꠤꠀ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("PM1_16","087_1_16","PHM","1","16","16","ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠅꠈꠘ ꠔꠣꠞꠦ ꠀꠞ ꠉꠥꠟꠣꠝ ꠢꠤꠡꠣꠛꠦ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ ꠛꠞꠋ ꠉꠥꠟꠣꠝ ꠕꠣꠇꠤ ꠛꠠ, ꠝꠣꠘꠤ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠢꠤꠡꠣꠛꠦ ꠙꠣꠁꠛꠣꠄ। ꠈꠣꠍ ꠇꠞꠤ ꠢꠦ ꠀꠝꠣꠞ ꠈꠥꠛ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ, ꠅꠈꠘ ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦꠅ ꠢꠦ ꠀꠞꠅ ꠝꠣꠄꠀꠞ, ꠈꠣꠟꠤ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠦ ꠘꠣꠄ, ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠢꠤꠡꠣꠛꠦ ꠝꠣꠄꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("PM1_17","087_1_17","PHM","1","17","17","ꠄꠞꠖꠣꠄ ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠀꠝꠣꠞꠦ ꠄꠇꠁ ꠁꠝꠣꠘꠞ ꠜꠣꠉꠤ ꠎꠣꠘ, ꠔꠦ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠇꠛꠥꠟ ꠇꠞꠣꠞ ꠇꠕꠣ, ꠔꠣꠞꠦꠅ ꠅꠟꠣ ꠇꠛꠥꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("PM1_18","087_1_18","PHM","1","18","18","ꠢꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠔꠤ ꠇꠞꠤꠀ ꠕꠣꠇꠦ ꠀꠞ ꠔꠣꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠣꠞ ꠇꠥꠘꠥ ꠙꠣꠅꠘꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠝꠘꠅ ꠇꠞꠤꠅ, ꠁ ꠙꠣꠅꠘꠣ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠙꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("PM1_19","087_1_19","PHM","1","19","19","ꠀꠝꠤ ꠙꠣꠃꠟꠥꠍꠦ ꠘꠤꠎꠞ ꠀꠔꠦ ꠟꠦꠈꠤꠀ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠔꠥꠝꠣꠞ ꠙꠣꠅꠘꠣ ꠀꠝꠤ ꠖꠤꠟꠣꠁꠝꠥ। ꠀꠍꠟꠦ ꠀꠝꠤ ꠇꠁꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ ꠘꠣ ꠎꠦ, ꠔꠥꠝꠣꠞ ꠘꠤꠎꠞ ꠎꠣꠘꠞ ꠟꠣꠉꠤꠃ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠉꠦꠍꠦ ꠞꠤꠘꠤ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("PM1_20","087_1_20","PHM","1","20","20","ꠜꠣꠁ ꠚꠤꠟꠤꠝꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠡ꠆ꠔꠦ ꠄꠇꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠅ, ꠄꠇꠎꠘ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠣꠞ ꠎꠣꠘꠅ ꠀꠞꠣꠝ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("PM1_21","087_1_21","PHM","1","21","21","ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠇꠕꠣ ꠞꠣꠈꠛꠣꠄ ꠎꠣꠘꠤꠀꠃ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠌꠤꠑꠤꠈꠣꠘ ꠟꠦꠈꠟꠣꠝ। ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠤ, ꠀꠝꠤ ꠎꠦꠔꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠁꠞꠣꠝ, ꠄꠞ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠔꠥꠝꠤ ꠇꠞꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("PM1_22","087_1_22","PHM","1","22","22","ꠢꠥꠘꠅ, ꠀꠞꠅ ꠄꠇꠈꠣꠘ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠝꠦꠝꠣꠘꠞ ꠇꠥꠑꠣ ꠑꠤꠇ ꠇꠞꠤꠀ ꠞꠣꠈꠤꠅ। ꠇꠣꠞꠘ ꠀꠝꠤ ꠀꠡꠣ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠞꠣꠞ ꠖꠥꠀꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠚꠤꠞꠔ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("PM1_23","087_1_23","PHM","1","23","23","ꠀꠛꠥ-ꠚꠣꠞꠣꠍꠦ ꠔꠥꠝꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠖꠤꠍꠂꠘ, ꠔꠣꠁꠘ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠛꠘ꠆ꠖꠤ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("PM1_24","087_1_24","PHM","1","24","24","ꠀꠞ ꠀꠝꠣꠞ ꠟꠉꠞ ꠔꠛꠟꠤꠉꠇꠣꠞꠤ ꠝꠣꠞ꠆ꠇꠥꠍ, ꠀꠞꠤꠡ꠆ꠔꠣꠇꠥꠍ, ꠖꠤꠝꠣꠍ ꠀꠞ ꠟꠥꠇꠦꠅ ꠔꠥꠝꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("PM1_25","087_1_25","PHM","1","25","25","ꠀꠝꠞꠣꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠇꠣꠁꠝ ꠞꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("HB1_1","088_1_1","HEB","1","1","1","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠔ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠄ ꠘꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤꠀ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠐꠥꠇꠞꠣ ꠐꠥꠇꠞꠣ ꠇꠞꠤ ꠅꠢꠤ ꠛꠦꠎꠤꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("HB1_2","088_1_2","HEB","1","2","2","ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠔ ꠀꠁꠀ ꠔꠣꠁꠘ ꠅꠢꠤꠞꠦ ꠝꠣꠘꠥꠡ ꠍꠥꠞꠔꠦ ꠡꠞꠣꠡꠞꠤ ꠛꠦꠎꠤꠍꠂꠘ। ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠙꠥꠔꠞ ꠟꠣꠈꠣꠘ, ꠄꠘ ꠘꠣꠝꠃ ꠇꠟꠤꠝꠣꠔꠥꠟ꠆ꠟꠣ, ꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠅꠢꠤ। ꠅꠃ ꠝꠣꠄꠀꠞ ꠙꠥꠔ ꠇꠟꠤꠝꠣꠔꠥꠟ꠆ꠟꠣꠞ ꠀꠔꠅꠃ ꠔꠣꠁꠘ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠖꠤꠟꠣꠁꠍꠂꠘ, ꠄꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠀꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB1_3","088_1_3","HEB","1","3","3","ꠄꠁꠘꠃ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤꠞ ꠘꠥꠞ, ꠔꠣꠘ ꠝꠣꠎꠖꠤꠀꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠘꠤꠎꠞꠦ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ। ꠅꠃ ꠝꠣꠄꠀꠞ ꠙꠥꠔ ꠇꠟꠤꠝꠣꠔꠥꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠟꠦ, ꠔꠣꠝꠣꠝ ꠎꠉꠔꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠌꠟꠦ। ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞꠦ ꠗꠁꠀ ꠍꠣꠚ ꠇꠞꠤꠀ, ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠔꠡꠞꠤꠚ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB1_4","088_1_4","HEB","1","4","4","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠛꠥꠎꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠦꠡꠤ ꠝꠞꠔꠥꠛꠣ ꠀꠟꠣ ꠘꠣꠝ ꠖꠤꠍꠂꠘ, ꠀꠞ ꠎꠦꠟꠣ ꠘꠣꠝ ꠅꠃꠟꠣ ꠁꠎ꠆ꠎꠔꠅ ꠖꠣꠘ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB1_5","088_1_5","HEB","1","5","5","ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠇꠥꠘꠥ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠁꠟꠣ ꠇꠕꠣ ꠇꠁꠍꠂꠘ ꠘꠣ, ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞ ꠙꠥꠔ, ꠀꠁꠎꠃ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠟꠣꠝ। ꠛꠣ, ꠀꠝꠤꠃ ꠔꠣꠞ ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠝꠥ ꠀꠞ ꠢꠦ ꠅꠁꠛ ꠀꠝꠣꠞ ꠙꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("HB1_6","088_1_6","HEB","1","6","6","ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠈꠣꠍ ꠙꠞꠗꠣꠘ ꠙꠥꠔꠞꠦ ꠖꠥꠘꠤꠀꠔ ꠛꠦꠎꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ, ꠅ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠄꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("HB1_7","088_1_7","HEB","1","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠞꠣ, ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠔꠣꠁꠘ ꠢꠣꠅꠀꠞ ꠘꠝꠥꠘꠣꠄ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠘꠤꠎꠞ ꠈꠣꠖꠤꠝ ꠅꠇꠟꠞꠦ ꠀꠉꠥꠘꠤꠞ ꠚꠥꠟꠇꠤꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠘꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB1_8","088_1_8","HEB","1","8","8","ꠅꠁꠟꠦ ꠅꠃ ꠙꠥꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠇꠁꠞꠣ, ꠁꠀ ꠄꠟꠣꠢꠤ, ꠔꠥꠝꠣꠞ ꠔꠈ꠆ꠔ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠛꠅꠀꠁꠟ ꠞꠁꠛ, ꠔꠥꠝꠣꠞ ꠁꠘꠍꠣꠚꠃ ꠅꠁꠟ ꠢꠇ ꠁꠘꠍꠣꠚ, ");
INSERT INTO syls_vpl VALUES ("HB1_9","088_1_9","HEB","1","9","9","ꠔꠥꠝꠤ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠅ ꠀꠞ ꠖꠤꠘꠖꠣꠞꠤꠞꠦ ꠜꠣꠟꠣ ꠙꠣꠅ, ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄꠅ, ꠔꠥꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠣꠞꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠣꠞꠦ ꠁꠎ꠆ꠎꠔꠤ ꠉꠖꠤ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠣꠞ ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞ ꠕꠣꠇꠤꠅ ꠔꠥꠝꠣꠞꠦ ꠛꠃꠔ ꠛꠦꠡꠤ ꠈꠥꠡꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB1_10","088_1_10","HEB","1","10","10","ꠀꠟ꠆ꠟꠣꠄ ꠀꠞꠅ ꠇꠁꠞꠣ, ꠅ ꠝꠣꠟꠤꠇ, ꠔꠥꠝꠤꠃ ꠙꠄꠟꠣ ꠖꠥꠘꠤꠀꠞ ꠁꠀꠘ ꠈꠥꠐꠤ ꠉꠣꠠꠤꠍ, ꠀꠍꠝꠣꠘ ꠅꠇꠟꠅ ꠔꠥꠝꠣꠞ ꠀꠔꠦ ꠙꠄꠖꠣ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB1_11","088_1_11","HEB","1","11","11","ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠎꠤꠛ, ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠔ ꠢꠣꠝꠦꠡꠣ ꠛꠅꠀꠁꠟ ꠞꠁꠛꠣꠄ। ꠁꠔꠣ ꠇꠣꠙꠠꠞ ꠟꠣꠈꠣꠘ ꠙꠥꠞꠣꠘ ꠅꠁꠎꠤꠛ, ");
INSERT INTO syls_vpl VALUES ("HB1_12","088_1_12","HEB","1","12","12","ꠔꠥꠝꠤ ꠁꠔꠣꠞꠦ ꠌꠣꠖ꠆ꠖꠞꠞ ꠟꠣꠈꠣꠘ ꠜꠣꠁꠘ꠆ꠎ ꠇꠞꠤꠀ ꠕꠁꠛꠣꠄ, ꠚꠤꠘ꠆ꠖꠤꠛꠣꠞ ꠇꠣꠙꠠꠞ ꠟꠣꠈꠣꠘ ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠖꠟꠣꠁꠛꠣꠄ। ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠎꠦꠟꠣ ꠀꠍ, ꠅꠃꠟꠣꠃ ꠞꠁꠛꠣꠄ, ꠔꠥꠝꠣꠞ ꠢꠣꠄꠀꠔꠤ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠚꠥꠠꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB1_13","088_1_13","HEB","1","13","13","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥꠖꠤꠘ ꠇꠥꠘꠥ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠁꠟꠣ ꠇꠕꠣ ꠇꠁꠍꠂꠘ ꠘꠣ, ꠔꠥꠝꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠎꠔꠖꠤꠘ ꠔꠥꠝꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ ꠘꠣ ꠚꠣꠟꠣꠁ, ꠅꠔꠖꠤꠘ ꠔꠥꠝꠤ ꠀꠝꠣꠞ ꠘꠤꠎꠞ ꠔꠈ꠆ꠔꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠔ ꠛꠅ। ");
INSERT INTO syls_vpl VALUES ("HB1_14","088_1_14","HEB","1","14","14","ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠔ ꠈꠣꠟꠤ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣ ꠞꠥꠢꠥ ꠘꠣꠄ ꠘꠤ? ꠎꠦꠞꠣ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠛꠣ, ꠔꠣꠞꠣꠞ ꠃꠙꠇꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠄꠞꠣꠞꠦ ꠛꠦꠎꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB2_1","088_2_1","HEB","2","1","1","ꠔꠦ ꠅꠃ ꠙꠥꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣ ꠎꠔꠔꠣ ꠢꠥꠘꠍꠤ, ꠁꠔꠣ ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤꠀ ꠡꠝꠎꠣ ꠖꠞꠇꠣꠞ, ꠀꠞꠘꠣꠄ ꠀꠡ꠆ꠔꠦ ꠀꠡ꠆ꠔꠦ ꠁ ꠔꠣꠟꠤꠝ ꠕꠣꠇꠤ ꠛꠦ-ꠙꠕꠦ ꠎꠣꠁꠔꠣꠝꠉꠤ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("HB2_2","088_2_2","HEB","2","2","2","ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠝꠣꠞꠚꠔꠦ ꠛꠣꠔꠣꠁꠟ ꠇꠣꠟꠣꠝ ꠎꠦꠛꠟꠣ ꠇꠣꠁꠝ ꠞꠁꠍꠦ, ꠀꠞ ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝꠞ ꠃꠟꠐꠣ ꠌꠟꠍꠤꠟ, ꠄꠞꠣꠅ ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠙꠣꠁꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("HB2_3","088_2_3","HEB","2","3","3","ꠔꠣꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠈꠣꠍ ꠝꠦꠢꠦꠞꠛꠣꠘꠤꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠈꠘ ꠎꠦ ꠘꠣꠎꠣꠔꠞ ꠙꠕ ꠔꠤꠀꠞ ꠇꠞꠍꠂꠘ, ꠁ ꠙꠕꠞ ꠃꠟꠐꠣ ꠌꠟꠟꠦ ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠛꠣꠌꠝꠥ ꠘꠤ? ꠅꠃ ꠘꠣꠎꠣꠔꠞ ꠇꠕꠣ ꠔ ꠢꠇ꠆ꠇꠟ ꠙꠄꠟꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠄ ꠘꠤꠎꠦꠃ ꠇꠁꠍꠂꠘ, ꠀꠞ ꠎꠦꠞꠣ ꠁꠔꠣ ꠢꠥꠘꠍꠤꠟ ꠔꠣꠞꠣꠅ ꠙꠥꠞꠣꠙꠥꠞ ꠍꠣꠚ ꠇꠞꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠇꠁꠍꠂꠘ, ꠁꠔꠣ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠢꠣꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("HB2_4","088_2_4","HEB","2","4","4","ꠄꠞꠣꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦꠅ ꠘꠣꠘꠣꠘ ꠇꠤꠍꠤꠝꠞ ꠇꠥꠖꠞꠔꠤ ꠀꠟꠣꠝꠔ, ꠇꠦꠞꠣꠝꠔꠤꠞ ꠛꠟ-ꠔꠣꠇ꠆ꠇꠔꠖꠤ ꠅꠃ ꠘꠣꠎꠣꠔꠞ ꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ। ꠀꠞ ꠘꠤꠎꠞ ꠝꠞ꠆ꠎꠤꠄ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠖꠦꠅꠀ ꠘꠣꠘꠣꠘ ꠘꠤꠀꠝꠔ ꠛꠤꠟꠣꠁ ꠖꠤꠀꠅ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB2_5","088_2_5","HEB","2","5","5","ꠔꠦ ꠀꠝꠞꠣ ꠎꠦ ꠛꠣꠔꠥꠘꠤ ꠛꠣꠖꠡꠣꠁꠞ ꠇꠕꠣ ꠇꠁꠀꠞ, ꠁ ꠛꠣꠖꠡꠣꠁ ꠔ ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠞꠣꠈꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB2_6","088_2_6","HEB","2","6","6","ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠝꠣꠎꠦ ꠄꠇꠎꠘꠦ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠝꠣꠘꠥꠡ ꠀꠞꠇꠔꠣ ꠇꠤꠔꠣ ꠎꠦꠘ ꠔꠥꠝꠤ ꠔꠣꠞꠣꠞꠦ ꠁꠀꠖ ꠇꠞ? ꠝꠣꠘꠡꠞ ꠀꠅꠟꠣꠖꠃ ꠛꠣ ꠇꠤꠔꠣ ꠎꠦꠘ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞ? ");
INSERT INTO syls_vpl VALUES ("HB2_7","088_2_7","HEB","2","7","7","ꠔꠥꠝꠤ ꠔ ꠝꠣꠘꠡꠞꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠕꠣꠇꠤ ꠈꠣꠟꠤ ꠕꠥꠠꠣ ꠟꠣꠝꠣꠔ ꠟꠣꠝꠣꠁꠍ, ꠉꠃꠞꠛ ꠀꠞ ꠁꠎ꠆ꠎꠔꠞ ꠝꠣꠟꠣ ꠔ ꠝꠣꠘꠡꠞꠦꠃ ꠖꠣꠘ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("HB2_8","088_2_8","HEB","2","8","8","ꠔꠥꠝꠣꠞ ꠙꠄꠖꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠃꠙꠞꠦ ꠄꠞꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠤꠍ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠄꠞꠣꠞ ꠙꠣꠅꠞ ꠔꠟꠣꠔ, ꠄꠞꠣꠞ ꠀꠅꠔꠣꠄ ꠞꠣꠈꠍ। ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠄꠞꠣꠞ ꠀꠅꠔꠣꠄ ꠀꠘꠣꠄ, ꠄꠞꠣꠞ ꠈꠦꠝꠔꠣꠞ ꠛꠣꠞꠦ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣꠃ ꠞꠁꠍꠦ ꠘꠣ। ꠅꠁꠟꠦ ꠅꠈꠘꠅ ꠔ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠀꠅꠔꠣꠄ ꠖꠦꠈꠞꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB2_9","088_2_9","HEB","2","9","9","ꠈꠣꠟꠤ ꠢꠃ ꠁꠍꠣꠞꠦ ꠖꠦꠈꠞꠣꠝ, ꠔꠣꠘꠞꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠟꠣꠝꠣꠔ ꠟꠣꠝꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠦ ꠖꠥꠘꠤꠀꠞ ꠔꠣꠝꠣꠝ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠦꠁꠘ। ꠢꠣꠍꠣꠃ ꠔꠣꠁꠘ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠙꠣꠁꠀ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠤꠀ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤꠃ ꠖꠦꠈꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠅꠃ ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠉꠃꠞꠛꠞ ꠝꠣꠟꠣ ꠚꠤꠘ꠆ꠖꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB2_10","088_2_10","HEB","2","10","10","ꠀꠍꠟꠦ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠁꠘꠃ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠔꠣꠘ ꠈꠤꠀꠟ ꠅꠁꠟ ꠔꠣꠘ ꠛꠃꠔ ꠀꠅꠟꠣꠖꠅ ꠔꠣꠘ ꠡꠣꠘ-ꠝꠢꠤꠝꠣꠞ ꠜꠣꠉꠤ ꠅꠁꠘ। ꠄꠞꠟꠣꠉꠤꠃ ꠔꠣꠞꠣꠞ ꠘꠣꠎꠣꠔꠞ ꠇꠣꠘ꠆ꠒꠣꠞꠤ ꠅꠃ ꠁꠍꠣꠞꠦ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠖꠤꠀ ꠇꠣꠝꠤꠟ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠄꠘ ꠟꠉ ꠗꠞꠤꠀ ꠄꠞꠣ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB2_11","088_2_11","HEB","2","11","11","ꠔꠦ ꠎꠦ ꠁꠍꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠂꠘ ꠀꠞ ꠎꠦꠞꠣ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠘꠂꠘ, ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠃ ꠔ ꠄꠇ ꠀꠟ꠆ꠟꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ। ꠅꠔꠣꠞ ꠖꠣꠄ ꠁꠍꠣꠄ ꠄꠞꠣꠞꠦ ꠜꠣꠁ ꠇꠁꠀ ꠒꠣꠇꠔꠦ ꠇꠥꠘꠥ ꠡꠞꠝ ꠙꠣꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB2_12","088_2_12","HEB","2","12","12","ꠔꠣꠁꠘ ꠇꠁꠍꠂꠘ, ꠀꠝꠤ ꠀꠝꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦ ꠔꠥꠝꠣꠞ ꠘꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠝꠥ, ꠡꠝꠣꠎꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠣꠞ ꠔꠣꠞꠤꠚ-ꠉꠎꠟ ꠉꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB2_13","088_2_13","HEB","2","13","13","ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠍꠂꠘ, ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠝꠥ। ꠀꠞ ꠀꠞꠇꠛꠣꠞ ꠇꠁꠍꠂꠘ, ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤꠅ ꠀꠍꠤ ꠀꠞ ꠢꠃ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠅ ꠅꠘꠅ ꠀꠍꠂꠘ, ꠎꠦꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞ ꠀꠔꠅ ꠡꠙꠤꠀ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB2_14","088_2_14","HEB","2","14","14","ꠀꠁꠌ꠆ꠍꠣ, ꠔꠦ ꠁ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠔ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠝꠣꠘꠥꠡ, ꠉꠔꠤꠇꠦ ꠁꠍꠣ ꠘꠤꠎꠦꠅ ꠅꠃꠟꠣ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠇꠣꠄꠀꠄ ꠎꠘꠝ ꠟꠁꠟꠣ। ꠈꠣꠟꠤ ꠅꠃ ꠇꠣꠄꠀꠞ ꠝꠃꠔꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ, ꠝꠃꠔꠞ ꠈꠦꠝꠔꠣꠞ ꠝꠣꠟꠤꠇ ꠢꠃ ꠁꠛꠟꠤꠍꠞꠦ ꠊꠣꠄꠄꠟ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("HB2_15","088_2_15","HEB","2","15","15","ꠀꠞ ꠝꠞꠘꠞ ꠒꠞꠦ ꠎꠦꠞꠣ ꠢꠣꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠝꠃꠔꠞ ꠉꠥꠟꠣꠝꠞ ꠟꠣꠈꠣꠘ ꠇꠣꠐꠣꠁꠞꠣ, ꠔꠣꠞꠣꠞꠦꠅ ꠀꠎꠣꠖ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB2_16","088_2_16","HEB","2","16","16","ꠔꠣꠁꠘ ꠔ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠂꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦꠃ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("HB2_17","088_2_17","HEB","2","17","17","ꠁ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠁꠍꠣꠞꠅ ꠎꠞꠥꠞ ꠀꠍꠤꠟ, ꠔꠣꠁꠘ ꠘꠤꠎꠦꠅ ꠅꠃ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞ ꠟꠉꠦ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠢꠝꠣꠘꠤ ꠅꠀ। ꠢꠝꠣꠘꠤ ꠅꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠘꠤꠞꠜꠞ ꠇꠞꠣꠞ ꠎꠥꠇꠣ, ꠖꠤꠟ-ꠖꠞꠖꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ। ꠁꠝꠣꠝ ꠛꠘꠤꠀ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB2_18","088_2_18","HEB","2","18","18","ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠙꠠꠤꠀ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤꠃ ꠎꠦꠞꠣ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠙꠠꠂꠘ ꠔꠣꠞꠣꠞꠦꠅ ꠔꠣꠁꠘ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB3_1","088_3_1","HEB","3","1","1","ꠄꠞꠟꠣꠉꠤ ꠅ ꠀꠝꠣꠞ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠖꠣꠅꠔꠅ ꠡꠞꠤꠇ ꠅꠁꠍ, ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇꠦꠃ ꠁꠍꠣꠞ ꠛꠣꠄ ꠌꠃꠈ ꠞꠣꠈꠅ। ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠣꠘ ꠁ ꠈꠣꠍ ꠈꠟꠤꠚꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠔ ꠢꠃ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ, ꠁꠈꠣꠘ ꠀꠝꠞꠣ ꠝꠣꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("HB3_2","088_3_2","HEB","3","2","2","ꠢꠎꠞꠔ ꠝꠥꠍꠣ ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ-ꠡꠋꠡꠣꠞꠅ ꠘꠤꠞꠜꠞ ꠇꠞꠣꠞ ꠎꠥꠇꠣ ꠀꠍꠟꠣ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠁꠍꠣꠞꠦꠅ ꠎꠦꠁꠘ ꠛꠦꠎꠤꠍꠂꠘ, ꠅꠃ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠁꠘ ꠀꠍꠟꠣ ꠘꠤꠞꠜꠞ ꠇꠞꠣꠞ ꠎꠥꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("HB3_3","088_3_3","HEB","3","3","3","ꠔꠦ ꠊꠞ ꠛꠣꠘꠣꠅꠞꠣ ꠝꠣꠟꠤꠇꠦ ꠎꠦꠟꠣ ꠊꠞ ꠕꠣꠇꠤꠅ ꠛꠦꠡꠤ ꠁꠎ꠆ꠎꠔ ꠙꠣꠁꠘ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ-ꠡꠋꠡꠣꠞꠅ ꠢꠎꠞꠔ ꠁꠍꠣꠄꠅ ꠝꠥꠍꠣ ꠘꠛꠤ ꠕꠣꠇꠤ ꠛꠦꠡꠤ ꠁꠎ꠆ꠎꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB3_4","088_3_4","HEB","3","4","4","ꠢꠇ꠆ꠇꠟ ꠊꠞꠣꠁꠘꠃ ꠔ ꠇꠥꠘꠥ ꠘꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠅꠁꠟꠦ ꠎꠦꠁꠘ ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠣꠘꠣꠁꠍꠂꠘ ꠔꠣꠁꠘꠃ ꠀꠟ꠆ꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB3_5","088_3_5","HEB","3","5","5","ꠀꠍꠟꠦ ꠍꠣꠝꠘꠞ ꠎꠝꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠛ, ꠅꠔꠣ ꠛꠦꠙꠣꠞ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠝꠥꠍꠣ ꠀꠍꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ-ꠡꠋꠡꠣꠞꠞ ꠇꠣꠝ-ꠇꠣꠎꠅ ꠘꠤꠞꠜꠞ ꠇꠞꠣꠞ ꠎꠥꠇꠣ ꠇꠣꠝꠟꠣꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("HB3_6","088_3_6","HEB","3","6","6","ꠅꠁꠟꠦ ꠀꠟ-ꠝꠍꠤ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ-ꠡꠋꠡꠣꠞꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠘꠤꠞꠜꠞ ꠇꠞꠣꠞ ꠎꠥꠇꠣ ꠙꠥꠔꠞ ꠟꠣꠈꠣꠘ ꠀꠍꠟꠣ। ꠅꠈꠘ ꠀꠝꠞꠣꠅ ꠎꠥꠖꠤ ꠎꠣꠞꠎꠤꠞ ꠖꠤꠟꠞ ꠀꠡꠣ ꠀꠞ ꠢꠤꠝ꠆ꠝꠔ ꠞꠣꠈꠤꠀ ꠝꠃꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠣꠁꠝ ꠞꠁ, ꠔꠦ ꠖꠦꠈꠣ ꠎꠣꠁꠛ ꠎꠦꠘ, ꠀꠝꠞꠣꠅ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞ-ꠡꠋꠡꠣꠞꠞ ꠜꠣꠉꠤ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("HB3_7","088_3_7","HEB","3","7","7","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠦ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠀꠁꠎ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠀꠅꠀꠎ ꠢꠥꠘ, ");
INSERT INTO syls_vpl VALUES ("HB3_8","088_3_8","HEB","3","8","8","ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠟꠣꠈꠣꠘ, ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠞꠣ, ꠔꠣꠞꠣ ꠎꠦꠟꠣ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ, ꠀꠝꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠉꠤꠀ ꠀꠝꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠍꠟꠣ, ꠔꠥꠝꠞꠣ ꠁꠟꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB3_9","088_3_9","HEB","3","9","9","ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠁꠘ꠆ꠔꠦ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠗꠞꠤ ꠀꠝꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠞ ꠛꠣꠖꠦꠅ, ꠢꠘꠅ ꠀꠝꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB3_10","088_3_10","HEB","3","10","10","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠃꠙꠞꠦ ꠈꠥꠛ ꠛꠦꠎꠣꠞ ꠅꠁꠀ ꠇꠁꠟꠣꠝ, ꠄꠞꠣꠞ ꠖꠤꠟ ꠔ ꠢꠣꠝꠦꠡꠣ ꠛꠦ-ꠙꠕꠦ ꠌꠇ꠆ꠇꠞ ꠖꠦꠞ, ꠔꠣꠞꠣ ꠔ ꠀꠝꠣꠞ ꠙꠕ ꠌꠤꠘꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB3_11","088_3_11","HEB","3","11","11","ꠔꠦꠃ ꠀꠝꠤ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠍꠟꠣꠝ, ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠢꠃ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣꠔ, ꠄꠞꠣ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB3_12","088_3_12","HEB","3","12","12","ꠜꠣꠁꠀꠁꠘ ꠅꠇꠟ, ꠢꠥꠡꠤꠀꠞ ꠅꠅ! ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠎꠣꠘꠥ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠛꠦꠁꠝꠣꠘꠤ ꠘꠣ ꠢꠣꠝꠣꠄ, ꠁꠔꠣ ꠢꠣꠝꠣꠁ ꠉꠦꠟꠦ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠘꠤꠎꠞꠦ ꠖꠥꠞꠁ ꠢꠞꠣꠁꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB3_13","088_3_13","HEB","3","13","13","ꠁꠔꠣꠞ ꠛꠖꠟꠣ ꠎꠔꠖꠤꠘꠞꠦ ꠀꠁꠎ ꠇꠁꠀ ꠒꠣꠇꠣ ꠅꠄ, ꠅꠔꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠡꠣꠅꠡ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠇꠦꠃ ꠉꠥꠘꠣꠞ ꠚꠣꠘ꠆ꠖꠅ ꠙꠠꠤꠀ ꠘꠤꠎꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠘꠣ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB3_14","088_3_14","HEB","3","14","14","ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠙꠄꠟꠣꠇꠥꠞ ꠟꠣꠈꠣꠘ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠁꠀ ꠌꠟꠤ, ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠡꠞꠤꠇ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("HB3_15","088_3_15","HEB","3","15","15","ꠕꠥꠠꠣ ꠀꠉꠦ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ, ꠀꠁꠎ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠀꠅꠀꠎ ꠢꠥꠘ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤꠞ ꠟꠣꠈꠣꠘ, ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB3_16","088_3_16","HEB","3","16","16","ꠀꠁꠌ꠆ꠍꠣ ꠇꠅ ꠌꠣꠁꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠤꠎꠞ ꠎꠛꠣꠘꠞ ꠛꠥꠟꠤ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦꠅ ꠇꠦꠉꠤꠄ ꠔꠣꠘ ꠛꠤꠞꠥꠗꠤꠔꠣ ꠇꠞꠍꠤꠟ? ꠄꠞꠣꠃ ꠘꠣꠄ ꠘꠤ, ꠎꠦꠞꠣꠞꠦ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠀꠘꠍꠤꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("HB3_17","088_3_17","HEB","3","17","17","ꠇꠅ ꠌꠣꠁꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠌꠣꠟ꠆ꠟꠤꠡ ꠛꠍꠞ ꠗꠞꠤ ꠇꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠎꠣꠞ ꠀꠍꠟꠣ? ꠄꠞꠣꠞ ꠃꠙꠞꠦꠃ ꠘꠣꠄ ꠘꠤ, ꠎꠦꠞꠣ ꠉꠥꠘꠣ ꠇꠞꠍꠟꠣ ꠀꠞ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠟꠣꠡ ꠅꠁꠀ ꠙꠠꠍꠟꠣ? ");
INSERT INTO syls_vpl VALUES ("HB3_18","088_3_18","HEB","3","18","18","ꠀꠟ꠆ꠟꠣꠄ ꠇꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠎꠣꠞ ꠅꠁꠀ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠍꠟꠣ, “ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠢꠃ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠄꠞꠣ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ”? ꠅꠃ ꠄꠞꠣꠞ ꠃꠙꠞꠦꠃ ꠘꠣꠄ ꠘꠤ, ꠎꠦꠞꠣ ꠔꠣꠘ ꠎꠛꠣꠘꠞ ꠛꠥꠟꠤ ꠢꠥꠘꠤꠀꠅ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠍꠤꠟ? ");
INSERT INTO syls_vpl VALUES ("HB3_19","088_3_19","HEB","3","19","19","ꠅꠔꠣ ꠕꠣꠇꠤꠃ ꠔ ꠀꠝꠞꠣ ꠛꠥꠎꠞꠣꠝ, ꠁꠝꠣꠘ ꠘꠣ ꠀꠘꠣꠄ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠢꠃ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB4_1","088_4_1","HEB","4","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠢꠣꠝꠣꠘꠤꠞ ꠅꠀꠖꠣ ꠅꠈꠘꠅ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠌꠣꠟꠥ ꠀꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠀꠅ, ꠀꠝꠞꠣ ꠀꠞꠅ ꠢꠥꠡꠤꠀꠞ ꠅꠁꠀ ꠌꠟꠤ, ꠘꠣꠁꠟꠦ ꠖꠦꠈꠣ ꠎꠣꠁꠛ ꠢꠦꠡꠦ ꠔꠥꠝꠞꠣ ꠇꠦꠃ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠛꠣꠖ ꠙꠠꠤꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("HB4_2","088_4_2","HEB","4","2","2","ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠦꠟꠣ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦꠅ ꠅꠃꠟꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠁ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠢꠥꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠁꠔꠣ ꠢꠥꠘꠟꠦꠅ ꠁꠝꠣꠘ ꠀꠘꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB4_3","088_4_3","HEB","4","3","3","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠔ ꠁꠝꠣꠘ ꠀꠘꠍꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣꠔ ꠢꠣꠝꠣꠁꠔꠣꠝ ꠙꠣꠞꠤꠀꠞ। ꠅꠃ ꠀꠞꠣꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠍꠂꠘ, ꠔꠦꠃ ꠀꠝꠤ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠍꠟꠣꠝ, ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠢꠃ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣꠔ, ꠄꠞꠣ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠎꠥꠖꠤꠅ ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠛꠣꠖ ꠕꠣꠇꠤꠃ, ꠀꠟ꠆ꠟꠣꠞ ꠁ ꠀꠞꠣꠝ ꠔꠤꠀꠞ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠔꠣ-ꠅ ꠔꠣꠁꠘ ꠅꠟꠣ ꠇꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB4_4","088_4_4","HEB","4","4","4","ꠅꠃ ꠀꠞꠣꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠞꠇ ꠀꠄꠀꠔꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠀꠟ꠆ꠟꠣꠄ ꠁ ꠢꠇꠟ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠤꠀ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠖꠤꠘ ꠀꠞꠣꠝ ꠇꠞꠟꠣ, ꠔꠣꠁꠘ ꠁꠖꠤꠘ ꠀꠞ ꠇꠥꠘ꠆ꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠟꠣ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("HB4_5","088_4_5","HEB","4","5","5","ꠅꠁꠟꠦ ꠔꠣꠁꠘꠃ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠍꠂꠘ, ꠀꠝꠣꠞ ꠖꠦꠅꠀ ꠢꠃ ꠀꠞꠣꠝꠞ ꠎꠣꠉꠣꠔ, ꠄꠞꠣ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB4_6","088_4_6","HEB","4","6","6","ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠇꠕꠣꠃ ꠚꠄꠍꠣꠟꠣ ꠅꠁꠟ ꠎꠦꠘ, ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠢꠤ ꠀꠞꠣꠝꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ, ꠅꠁꠟꠦ ꠙꠄꠟꠣ ꠎꠦꠞꠣꠞ ꠉꠦꠍꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠇꠣꠞꠘꠦꠃ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠤ ꠀꠞꠣꠝꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB4_7","088_4_7","HEB","4","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠛꠃꠔ ꠖꠤꠘ ꠀꠉꠦ ꠁꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍꠦ ꠛꠣꠔꠣꠁꠍꠟꠣ, ꠛꠣꠖꠦ ꠔꠣꠘ ꠀꠞꠣꠝꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠤꠞꠛꠣꠞ ꠘꠄꠀ ꠖꠤꠘ ꠑꠤꠇ ꠇꠞꠤꠀ ꠅꠃ ꠖꠤꠘꠞ ꠘꠣꠝ ꠖꠤꠟꠣ, ꠀꠁꠎ। ꠢꠤꠞꠛꠣꠞ ꠛꠃꠔ ꠖꠤꠘ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠉꠦꠍꠦ ꠇꠁꠍꠂꠘ, ꠎꠦꠟꠣ ꠃꠙꠞꠦ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠀꠁꠎ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠀꠅꠀꠎ ꠢꠥꠘꠅ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠡꠣꠘ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB4_8","088_4_8","HEB","4","8","8","ꠅꠈꠣꠘ ꠇꠅꠀꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠁꠃꠍꠣ ꠘꠛꠤꠄ ꠎꠥꠖꠤ ꠔꠣꠞꠣꠞꠦ ꠢꠤ ꠀꠞꠣꠝꠅ ꠢꠣꠞꠣꠁꠟꠤꠔꠣ ꠙꠣꠞꠔꠣ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠖꠦ ꠀꠞꠇ ꠖꠤꠘꠞ ꠇꠕꠣ ꠇꠁꠟꠣ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("HB4_9","088_4_9","HEB","4","9","9","ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠞꠣꠝꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠙꠕ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠅꠈꠘꠅ ꠈꠥꠟꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB4_10","088_4_10","HEB","4","10","10","ꠝꠥꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠟꠣ ꠔꠣꠘ ꠢꠇ꠆ꠇꠟ ꠇꠣꠝ ꠡꠦꠡ ꠇꠞꠤꠀ ꠛꠣꠖꠦ ꠀꠞꠣꠝ ꠇꠞꠍꠟꠣ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠛꠘ꠆ꠖꠣꠅ ꠔꠣꠘ ꠀꠞꠣꠝꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠁꠀ ꠢꠣꠞꠟꠦ, ꠢꠦ-ꠅ ꠔꠣꠞ ꠇꠣꠝ ꠕꠣꠇꠤ ꠀꠞꠣꠝ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB4_11","088_4_11","HEB","4","11","11","ꠔꠦ ꠀꠅ, ꠀꠝꠞꠣꠅ ꠢꠤ ꠀꠞꠣꠝꠞ ꠝꠣꠎꠦ ꠢꠣꠝꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠈꠣꠍ ꠖꠤꠟꠦ ꠀꠉꠥꠀꠁ, ꠎꠣꠔꠦ ꠢꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠣꠈꠣꠘ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠉꠤꠀ, ꠁ ꠀꠞꠣꠝ ꠕꠣꠇꠤ ꠛꠣꠖ ꠘꠣ ꠙꠠꠤ। ");
INSERT INTO syls_vpl VALUES ("HB4_12","088_4_12","HEB","4","12","12","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔ ꠎꠤꠘ꠆ꠖꠣ ꠀꠞ ꠛꠟꠀꠟꠣ ꠇꠣꠝꠟꠣ, ꠖꠥꠁꠅ ꠉꠣꠟꠣ ꠗꠣꠞꠣꠁꠟ ꠔꠟꠥꠀꠞꠞ ꠌꠣꠁꠔꠦꠅ ꠛꠦꠡꠤ ꠗꠣꠞꠀꠟꠣ। ꠁ ꠇꠣꠟꠣꠝꠦ ꠚꠥꠠ ꠇꠞꠤꠀ ꠝꠣꠘꠡꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠀ ꠖꠤꠟ-ꠞꠥꠢꠥ, ꠀꠒ꠆ꠒꠤ-ꠉꠥꠡ꠆ꠔꠞꠦ ꠀꠟꠉꠣꠄ, ꠀꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠞ ꠘꠤꠅꠔ-ꠌꠤꠘ꠆ꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("HB4_13","088_4_13","HEB","4","13","13","ꠀꠟ꠆ꠟꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠣ ꠇꠥꠘꠥ ꠝꠈꠟꠥꠇꠣꠔꠃ ꠔꠣꠘ ꠉꠦꠍꠦ ꠟꠥꠇꠣꠁꠟ ꠘꠣꠄ। ꠔꠣꠘ ꠌꠃꠈꠞ ꠍꠣꠝꠘꠦ ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠎꠣꠁꠞ ꠀꠍꠦ, ꠔꠣꠘ ꠉꠦꠍꠦꠃ ꠀꠝꠞꠣꠞ ꠢꠤꠡꠣꠛ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("HB4_14","088_4_14","HEB","4","14","14","ꠀꠝꠞꠣ ꠔ ꠅꠟꠣ ꠄꠇ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠙꠣꠁꠍꠤ, ꠎꠦꠁꠘ ꠔꠣꠝꠣꠝ ꠀꠍꠝꠣꠘ ꠙꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠤ ꠀꠟ꠆ꠟꠣꠞ ꠀꠞꠡꠅ ꠔꠡꠞꠤꠚ ꠘꠤꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ, ꠁꠍꠣ ꠁꠛꠘꠥꠟ꠆ꠟꠣ। ꠔꠦ ꠀꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣ ꠔꠣꠘ ꠇꠟꠤꠝꠣꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠝꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("HB4_15","088_4_15","HEB","4","15","15","ꠇꠣꠞꠘ ꠀꠝꠞꠣꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠁ ꠟꠣꠈꠣꠘ ꠘꠣꠄ ꠎꠦꠘ, ꠀꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠇꠝꠎꠥꠞꠤꠞ ꠖꠥꠈꠦ ꠔꠣꠁꠘ ꠖꠥꠈꠤ ꠅꠁꠔꠣ ꠘꠣꠄ, ꠔꠣꠁꠘꠅ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠉꠥꠘꠣꠞ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠙꠠꠍꠂꠘ, ꠅꠁꠟꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠉꠥꠘꠣ ꠇꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB4_16","088_4_16","HEB","4","16","16","ꠄꠞꠟꠣꠉꠤ ꠀꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠔꠈ꠆ꠔꠞ ꠇꠤꠘꠣꠞꠅ ꠎꠣꠁ, ꠎꠣꠔꠦ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠢꠣꠍꠤꠟ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ, ꠀꠞ ꠎꠦꠟꠣꠈꠣꠘ ꠞꠢꠝꠔꠞ ꠉꠞꠎ ꠀꠍꠦ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠞꠢꠝꠔꠅ ꠙꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("HB5_1","088_5_1","HEB","5","1","1","ꠝꠣꠘꠡꠞ ꠙꠇ꠆ꠇꠦ ꠞꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔꠤꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠞ ꠝꠣꠎ ꠕꠘꠦꠃ ꠙꠞꠔꠦꠇ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠤ ꠘꠦꠅꠀ ꠅꠄ। ꠔꠣꠘ ꠇꠣꠝ ꠅꠁꠟ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠛꠈꠡꠤꠀ ꠖꠦꠅꠀ। ");
INSERT INTO syls_vpl VALUES ("HB5_2","088_5_2","HEB","5","2","2","ꠎꠦꠞꠣ ꠘꠣ ꠛꠥꠎꠤꠀ ꠉꠥꠘꠣ ꠇꠞꠦ ꠀꠞ ꠛꠦ-ꠙꠕꠤ ꠅꠄ ꠄꠞꠣꠞ ꠟꠉꠦ ꠔꠣꠁꠘ ꠘꠞꠝ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ, ꠇꠣꠞꠘ ꠔꠣꠘ ꠝꠣꠎꠦꠅ ꠇꠝꠎꠥꠞꠤ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB5_3","088_5_3","HEB","5","3","3","ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠁꠘ, ꠅꠃꠟꠣ ꠔꠣꠘ ꠘꠤꠎꠞ ꠇꠝꠎꠥꠞꠤ ꠀꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤꠅ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠣ ꠚꠞꠎ। ");
INSERT INTO syls_vpl VALUES ("HB5_4","088_5_4","HEB","5","4","4","ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠀꠞ ꠁꠎ꠆ꠎꠔ ꠇꠦꠃ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠇꠣꠝꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠘꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ ꠔꠣꠁꠘꠃ ꠁ ꠁꠎ꠆ꠎꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠂꠘ, ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠄ ꠢꠣꠞꠥꠘ ꠘꠛꠤꠞꠦ ꠁ ꠁꠎ꠆ꠎꠔ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB5_5","088_5_5","HEB","5","5","5","ꠁꠍꠣꠄꠅ ꠅꠃꠟꠣ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠀꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠦ ꠘꠤꠎꠞꠦ ꠛꠠ ꠛꠣꠘꠣꠁꠟꠣ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠄꠃ ꠔꠣꠘꠞꠦ ꠅꠃ ꠉꠃꠞꠛ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠔꠥꠝꠤ ꠔ ꠀꠝꠣꠞ ꠙꠥꠔ, ꠀꠁꠎꠃ ꠀꠝꠤ ꠔꠥꠝꠣꠞ ꠛꠣꠚꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("HB5_6","088_5_6","HEB","5","6","6","ꠔꠣꠁꠘ ꠅꠃꠟꠣ ꠀꠞꠇ ꠀꠄꠀꠔꠅ ꠇꠁꠍꠂꠘ, ꠛꠣꠖꠡꠣ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠍꠤꠟꠍꠤꠟꠣꠄ, ꠔꠥꠝꠤꠃ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠁꠝꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("HB5_7","088_5_7","HEB","5","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠁꠍꠣꠞꠦ ꠝꠃꠔꠞ ꠀꠔ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠔꠣ ꠙꠣꠞꠟꠣ ꠅꠘꠦ, ꠁꠍꠣ ꠖꠥꠘꠤꠀꠔ ꠕꠣꠇꠣꠞ ꠡꠝꠄ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠤ ꠇꠣꠘ꠆ꠖꠤꠀ ꠖꠥꠀ-ꠝꠤꠘꠔꠤ ꠇꠞꠤ ꠜꠤꠇ ꠝꠣꠉꠤꠍꠂꠘ, ꠔꠣꠘ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚ ꠀꠞ ꠛꠣꠁꠖ꠆ꠖꠔꠣ ꠕꠣꠇꠣꠄ ꠁꠔꠣꠞ ꠎꠥꠀꠙꠅ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB5_8","088_5_8","HEB","5","8","8","ꠔꠣꠁꠘ ꠙꠥꠔ ꠅꠁꠟꠦꠅ ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠁꠖ꠆ꠖ ꠅꠁꠀ ꠞꠅꠀ ꠢꠤꠇꠤꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("HB5_9","088_5_9","HEB","5","9","10","ꠀꠞ ꠅꠃ ꠟꠣꠈꠣꠘ ꠞꠁꠀ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠟ ꠛꠘꠤꠉꠦꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠘꠝꠥꠘꠣꠄ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠈꠦꠔꠣꠛ ꠖꠤꠟꠣ, ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠘ ꠛꠣꠁꠖ꠆ꠖ ꠃꠝ꠆ꠝꠔ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠁ ꠘꠣꠎꠣꠔꠞ ꠙꠕ ꠈꠥꠟꠤꠀ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB5_11","088_5_11","HEB","5","11","11","ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣꠞ ꠀꠞꠅ ꠛꠃꠔ ꠛꠄꠀꠘ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠘꠅ ꠔꠣꠟꠣ ꠟꠣꠉꠣꠁ ꠖꠤꠍ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠁꠔꠣ ꠛꠥꠎꠣꠘꠤ ꠈꠥꠛ ꠇꠡ꠆ꠐ। ");
INSERT INTO syls_vpl VALUES ("HB5_12","088_5_12","HEB","5","12","12","ꠅꠔꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠅ ꠃꠡ꠆ꠔꠣꠖ ꠅꠁꠎꠤꠔꠣꠄ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠅꠈꠘꠅ ꠖꠦꠈꠣ ꠎꠣꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠙꠄꠟꠣ ꠍꠛꠇ ꠢꠤꠇꠣꠘꠤ ꠟꠣꠉꠛ। ꠔꠥꠝꠞꠣꠞꠦ ꠅꠈꠘꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠖꠥꠗ ꠈꠣꠅꠀꠘꠤ ꠟꠣꠉꠦꠞ, ꠡꠇ꠆ꠔ ꠈꠣꠘꠣ ꠢꠎꠝ ꠇꠞꠔꠣꠄ ꠙꠣꠞꠞꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB5_13","088_5_13","HEB","5","13","13","ꠀꠞ ꠎꠦꠞꠣ ꠖꠥꠗ ꠈꠣꠄ ꠔꠣꠞꠣ ꠔ ꠉꠦꠖꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣ, ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠛꠥꠎꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB5_14","088_5_14","HEB","5","14","14","ꠡꠇ꠆ꠔ ꠈꠣꠘꠣ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠎꠦꠞꠣꠞ ꠛꠄꠅꠡ ꠅꠁꠍꠦ, ꠔꠣꠞꠣ ꠜꠣꠟꠣ-ꠛꠥꠞꠣꠞ ꠔꠚꠣꠔ ꠛꠥꠎꠤꠀ ꠀꠈꠟ ꠈꠣꠐꠣꠁꠀ ꠌꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("HB6_1","088_6_1","HEB","6","1","1","ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠞꠣ ꠙꠄꠟꠣ ꠎꠦꠔꠣ ꠔꠣꠟꠤꠝ ꠙꠣꠁꠍꠤ, ꠀꠃꠇ꠆ꠇꠣ ꠁꠔꠣꠞꠦ ꠙꠣꠞ ꠅꠁꠀ ꠀꠝꠞꠣ ꠀꠞꠅ ꠀꠉꠦꠖꠤ ꠀꠉꠥꠀꠁꠀ ꠇꠣꠝꠤꠟ ꠅꠁ। ꠢꠃ ꠙꠄꠟꠣꠇꠥꠞ ꠔꠣꠟꠤꠝ ꠢꠤꠞꠛꠣꠞ ꠢꠤꠇꠣꠞ ꠀꠞ ꠉꠞꠎ ꠘꠣꠁ, ꠎꠦꠝꠘ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠣꠝ ꠕꠣꠇꠤ ꠖꠤꠟꠞꠦ ꠛꠖꠟꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("HB6_2","088_6_2","HEB","6","2","2","ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠉꠥꠍꠟ, ꠖꠥꠀ ꠘꠤꠛꠣꠞ ꠡꠝꠄ ꠀꠔꠣꠁ ꠖꠦꠅꠀ, ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣ, ꠀꠞ ꠀꠈꠦꠞꠣꠔꠞ ꠛꠤꠌꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("HB6_3","088_6_3","HEB","6","3","3","ꠁꠘꠡꠣꠟ꠆ꠟꠣ, ꠀꠝꠞꠣ ꠅꠟꠣꠃ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB6_4","088_6_4","HEB","6","4","4","ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠄꠇꠛꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠙꠕ ꠖꠦꠈꠤꠟꠣꠁꠍꠦ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠖꠣꠘꠞ ꠝꠎꠣ ꠙꠣꠁꠍꠦ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠡꠞꠤꠇ ꠅꠁꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("HB6_5","088_6_5","HEB","6","5","5","ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠇꠣꠟꠣꠝꠞ ꠝꠎꠣ ꠛꠥꠎꠍꠦ, ꠀꠞ ꠍꠣꠝꠘꠞ ꠎꠝꠣꠘꠣꠞ ꠘꠣꠘꠣꠘ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("HB6_6","088_6_6","HEB","6","6","6","ꠖꠦꠈꠣꠞ ꠛꠣꠖꠦꠅ ꠇꠣꠚꠤꠞꠤ ꠇꠣꠝ ꠇꠞꠍꠦ, ꠄꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠀꠞ ꠛꠖꠟꠣꠁꠟ ꠎꠣꠁꠔ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠘꠤꠎꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛꠅ ꠎꠣꠘꠦ ꠝꠣꠞꠦꠞ, ꠀꠞ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠈꠥꠟꠣ-ꠝꠦꠟꠣ ꠔꠣꠘ ꠉꠤꠛꠔ ꠉꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("HB6_7","088_6_7","HEB","6","7","7","ꠎꠦ ꠝꠣꠐꠤꠄ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠝꠦꠊꠞ ꠙꠣꠘꠤ ꠅꠎꠝ ꠇꠞꠤꠀ ꠉꠤꠞꠡ꠆ꠔ ꠅꠇꠟꠞꠦ ꠢꠣꠉ-ꠔꠞꠇꠣꠞꠤ ꠎꠥꠉꠣꠁꠀ ꠖꠦꠄ, ꠁ ꠝꠣꠐꠤꠔ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠘꠣꠎꠤꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("HB6_8","088_6_8","HEB","6","8","8","ꠅꠁꠟꠦ ꠎꠦ ꠝꠣꠐꠤꠔ ꠈꠣꠟꠤ ꠛꠘ-ꠎꠋꠉꠟ ꠀꠞ ꠇꠣꠐꠣ-ꠉꠍꠣ ꠚꠟꠦ, ꠁꠔꠣ ꠛꠦꠇꠣꠝꠣ ꠝꠣꠐꠤ, ꠁ ꠝꠣꠐꠤꠔ ꠟꠣꠘ꠆ꠘꠔ ꠙꠠꠦ। ꠝꠣꠘꠡꠦ ꠁꠔꠣꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB6_9","088_6_9","HEB","6","9","9","ꠅ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟ, ꠎꠥꠖꠤꠅ ꠀꠝꠞꠣ ꠁꠟꠣꠈꠣꠘ ꠇꠁꠞꠣꠝ, ꠅꠁꠟꠦ ꠀꠍꠟꠦ ꠀꠝꠞꠣ ꠈꠣꠍ ꠖꠤꠟꠦ ꠝꠘꠅ ꠇꠞꠤ, ꠔꠥꠝꠞꠣꠞ ꠢꠣꠟꠔ ꠄ ꠕꠣꠇꠤ ꠛꠃꠔ ꠜꠣꠟꠣ ꠀꠍꠦ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠘꠣꠎꠣꠔꠞ ꠚꠟꠅ ꠖꠦꠈꠣ ꠎꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("HB6_10","088_6_10","HEB","6","10","10","ꠀꠟ꠆ꠟꠣ ꠔ ꠢꠇ-ꠁꠘꠍꠣꠚꠇꠣꠞꠤ, ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠟꠣꠉꠤ ꠎꠦ ꠝꠢꠛ꠆ꠛꠔ ꠖꠦꠈꠣꠁꠞꠣꠄ, ꠔꠣꠘ ꠟꠣꠉꠤ ꠎꠦꠔꠣ ꠇꠣꠝ-ꠇꠣꠎ ꠇꠞꠞꠣꠄ, ꠔꠣꠘ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠤꠀ ꠀꠁꠞꠣꠄ, ꠁꠔꠣ ꠔ ꠔꠣꠁꠘ ꠚꠣꠃꠞꠤꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB6_11","088_6_11","HEB","6","11","11","ꠀꠝꠞꠣꠞ ꠈꠥꠛ ꠁꠌ꠆ꠍꠣ ꠅꠁꠟ, ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠦꠃ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠇꠣꠝ ꠇꠞꠣꠔ ꠀꠉꠥꠀꠁ ꠀꠁꠛꠣꠄ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠡꠣ ꠙꠥꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("HB6_12","088_6_12","HEB","6","12","12","ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠣꠝꠅ ꠀꠉꠥꠀꠁꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠀꠟꠡꠤ ꠘꠣ ꠀꠄ; ꠛꠞꠋ ꠁꠝꠣꠘꠦ ꠀꠞ ꠍꠛꠞꠦ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠛꠞꠇꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣꠅ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠎꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("HB6_13","088_6_13","HEB","6","13","13","ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠁ ꠡꠝꠄ ꠖꠥꠍꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠞ ꠘꠣꠝꠦ ꠔꠣꠁꠘ ꠇꠍꠝ ꠈꠣꠁꠍꠂꠘ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠘ ꠕꠣꠇꠤ ꠛꠠ ꠖꠥꠍꠞꠣ ꠇꠥꠘ꠆ꠔꠣꠃ ꠘꠣꠁ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠇꠞꠤꠀ ꠇꠁꠍꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("HB6_14","088_6_14","HEB","6","14","14","ꠀꠝꠤ ꠘꠤꠌꠄ ꠔꠥꠝꠣꠞꠦ ꠛꠞꠇꠔ ꠘꠣꠎꠤꠟ ꠇꠞꠝꠥ, ꠔꠥꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠃꠔ ꠙꠞꠤꠝꠣꠘꠦ ꠛꠣꠠꠣꠁ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB6_15","088_6_15","HEB","6","15","15","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠅꠃꠟꠣ ꠛꠃꠔ ꠟꠣꠝ꠆ꠛꠣ ꠡꠝꠄ ꠍꠛꠞ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣꠞ ꠚꠟ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB6_16","088_6_16","HEB","6","16","16","ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠇꠥꠘꠥ ꠇꠍꠝ ꠈꠣꠄ, ꠢꠦ ꠔꠣꠞ ꠌꠣꠁꠔꠦ ꠖꠣꠝꠤ ꠇꠦꠃꠞꠞ ꠘꠣꠝꠦ ꠇꠍꠝ ꠈꠣꠄ, ꠔꠦꠃ ꠛꠥꠎꠣ ꠎꠣꠄ ꠔꠣꠞ ꠇꠍꠝ ꠢꠣꠍꠣ, ꠀꠞ ꠅꠃ ꠇꠍꠝꠞ ꠟꠣꠉꠤ ꠢꠇꠟꠔꠣ ꠝꠤꠐ-ꠝꠣꠐ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB6_17","088_6_17","HEB","6","17","17","ꠅꠃꠟꠣ ꠀꠟ꠆ꠟꠣꠄꠅ ꠎꠦꠞꠣꠞ ꠟꠉꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠅꠀꠖꠣꠞ ꠘꠤꠌ꠆ꠌꠄꠅꠔꠣꠞ ꠟꠣꠉꠤꠀ ꠔꠣꠁꠘꠅ ꠇꠍꠝ ꠈꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠅꠀꠖꠣ ꠞꠖ-ꠛꠖꠟ ꠅꠀꠞ ꠡꠘ꠆ꠖꠄ ꠘꠣ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("HB6_18","088_6_18","HEB","6","18","18","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠇꠥꠘꠥ ꠝꠤꠍꠣ ꠝꠣꠔꠣ ꠔ ꠛꠃꠔ ꠖꠥꠞꠞ ꠇꠕꠣ। ꠔꠦ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠅꠀꠖꠣꠞ ꠟꠉꠦ ꠇꠍꠝꠅ ꠇꠞꠍꠂꠘ, ꠅꠈꠘ ꠀꠝꠞꠣ ꠀꠞꠅ ꠇꠔ ꠛꠦꠡꠤ ꠜꠞꠡꠣ ꠞꠣꠈꠔꠣꠝ ꠙꠣꠞꠤ। ꠄꠞꠟꠣꠉꠤ ꠀꠅ, ꠀꠝꠞꠣ ꠎꠦꠞꠣ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠉꠤꠀ ꠀꠡꠞꠄ ꠙꠣꠁꠍꠤ, ꠙꠣꠁꠀ ꠎꠦ ꠀꠡꠣ ꠙꠄꠖꠣ ꠀꠍꠦ, ꠀꠝꠞꠣꠞ ꠍꠣꠝꠘꠞ ꠢꠃ ꠀꠡꠣꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠗꠞꠤꠀ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("HB6_19","088_6_19","HEB","6","19","19","ꠅꠃ ꠀꠡꠣ ꠀꠝꠞꠣꠞ ꠎꠣꠘꠞ ꠟꠋꠉꠞꠞ ꠟꠣꠈꠣꠘ, ꠇꠣꠁꠝ ꠀꠞ ꠝꠎꠛꠥꠔ। ꠁꠐꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠙꠞ꠆ꠖꠣ ꠙꠣꠞ ꠅꠁꠀ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠜꠤꠔꠞꠦ ꠀꠝꠞꠣꠞꠦ ꠘꠤꠀ ꠙꠃꠍꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB6_20","088_6_20","HEB","6","20","20","ꠀꠞ ꠀꠝꠞꠣꠞ ꠙꠇ꠆ꠇ ꠅꠁꠀ ꠁꠍꠣ ꠉꠤꠀ ꠀꠝꠞꠣꠞ ꠀꠉꠦ ꠢꠤ ꠎꠣꠉꠣꠔ ꠙꠃꠍꠤ ꠉꠦꠍꠂꠘ। ꠔꠣꠁꠘ ꠔ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠍꠤꠟꠍꠤꠟꠣꠞ ꠞꠦꠅꠀꠎ ꠝꠣꠚꠤꠇ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠟꠣꠉꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠁꠍꠂꠘ, ꠔꠦ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠅꠈꠘ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("HB7_1","088_7_1","HEB","7","1","1","ꠁ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠔꠣꠟꠣꠞ ꠁꠝꠣꠝ, ꠡꠣꠟꠦꠝꠞ ꠛꠣꠖꠡꠣ। ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠞꠦ ꠎꠥꠖ꠆ꠖꠔ ꠀꠞꠣꠁꠀ ꠢꠣꠞꠤ ꠚꠤꠞꠤꠀ ꠀꠅꠀꠞ ꠛꠣꠟꠣ ꠅꠃ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠟꠉꠦ ꠔꠣꠘ ꠝꠥꠟꠣꠇꠣꠔ ꠅꠁꠟꠦ, ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠖꠥꠀ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB7_2","088_7_2","HEB","7","2","2","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠔꠣꠘ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠄꠘꠞꠦ ꠖꠤꠟꠣꠁꠟꠣ। ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇ ꠘꠣꠝꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠙꠞꠦꠎꠉꠣꠞꠞ ꠛꠣꠖꠡꠣ। ꠔꠣꠁꠘ ꠡꠣꠟꠦꠝ ꠐꠣꠃꠘꠞꠅ ꠛꠣꠖꠡꠣ, ꠝꠣꠘꠤ ꠡꠣꠘ꠆ꠔꠤꠞ ꠛꠣꠖꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("HB7_3","088_7_3","HEB","7","3","3","ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠝꠣ ꠘꠣꠁ, ꠛꠣꠚꠅ ꠘꠣꠁ, ꠔꠣꠘ ꠇꠥꠘꠥ ꠈꠣꠘ꠆ꠖꠣꠘ-ꠘꠣꠝꠣꠅ ꠘꠣꠁ, ꠔꠣꠘ ꠢꠣꠄꠀꠔꠤꠞ ꠡꠥꠞꠥ ꠛꠣ ꠡꠦꠡ ꠘꠣꠁ। ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠙꠥꠔꠞ ꠟꠣꠈꠣꠘ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠁꠝꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("HB7_4","088_7_4","HEB","7","4","4","ꠔꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠄꠁꠘ ꠇꠔ ꠝꠢꠣꠘ, ꠎꠦꠘꠞꠦ ꠀꠝꠞꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠥꠟ ꠛꠣꠛꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦꠅ ꠔꠣꠘ ꠉꠘꠤꠝꠔꠞ ꠝꠣꠟꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠖꠣꠘ ꠇꠞꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_5","088_7_5","HEB","7","5","5","ꠀꠞ ꠟꠦꠛꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠔꠣꠞꠣ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞ ꠜꠣꠁꠀꠁꠘ, ꠝꠣꠘꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠖꠣꠄ ꠇꠞꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠙꠣꠁꠍꠂꠘ। ꠅꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠅ ꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠘꠝꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_6","088_7_6","HEB","7","6","6","ꠅꠁꠟꠦ ꠢꠃ ꠎꠦ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣ ꠅꠁꠟꠦꠅ, ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠘꠤꠍꠟꠣ, ꠀꠞ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞꠦ ꠖꠥꠀꠅ ꠖꠤꠍꠟꠣ, ꠎꠦꠘ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_7","088_7_7","HEB","7","7","7","ꠢꠥꠞꠥ ꠅꠇꠟꠦ ꠛꠠ ꠅꠇꠟꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠖꠥꠀ ꠙꠣꠁꠀ ꠕꠣꠇꠂꠘ, ꠄꠞ ꠝꠣꠎꠦ ꠔ ꠡꠘ꠆ꠖꠄ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("HB7_8","088_7_8","HEB","7","8","8","ꠄꠇꠛꠣꠄꠖꠤ ꠎꠦ ꠁꠝꠣꠝꠞ ꠝꠃꠔ ꠅꠄ, ꠅꠃ ꠟꠦꠛꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠖꠣꠄ ꠇꠞꠂꠘ, ꠀꠞ ꠀꠞꠇꠛꠣꠄ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇ, ꠇꠤꠔꠣꠛꠦ ꠇꠄ ꠔꠣꠁꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ, ꠔꠣꠁꠘꠅ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠖꠣꠄ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_9","088_7_9","HEB","7","9","9","ꠢꠤꠞꠛꠣꠞ ꠁꠈꠣꠘꠅ ꠇꠅꠀ ꠎꠣꠄ, ꠟꠦꠛꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠎꠦ ꠁꠝꠣꠝꠦ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠖꠣꠄ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘꠅ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠝꠣꠎꠖꠤ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞꠦ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠖꠤꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("HB7_10","088_7_10","HEB","7","10","10","ꠇꠣꠞꠘ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠦ ꠎꠦꠛꠟꠣ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠟꠣ, ꠟꠦꠛꠤ ꠔ ꠅꠃ ꠡꠝꠄ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠘꠣꠠꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB7_11","088_7_11","HEB","7","11","11","ꠟꠦꠛꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠁꠝꠣꠝ ꠍꠣꠛ ꠅꠇꠟꠞ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠃꠙꠞꠦ ꠘꠤꠞꠜꠞ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠡꠞꠤꠅꠔ ꠖꠤꠍꠟꠣ, ꠁ ꠁꠝꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠎꠥꠖꠤ ꠇꠣꠝꠤꠟ ꠅꠀ ꠎꠣꠁꠔ, ꠔꠦ ꠟꠦꠛꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠙꠄꠟꠣ ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠛꠖꠟꠣ ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠘꠝꠥꠘꠣꠞ ꠀꠞꠇ ꠁꠝꠣꠝ ꠀꠅꠀꠞ ꠇꠥꠘꠥ ꠉꠞꠎ ꠀꠍꠤꠟ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("HB7_12","088_7_12","HEB","7","12","12","ꠁꠝꠣꠝꠞ ꠍꠤꠟꠍꠤꠟꠣ ꠛꠖꠟꠣꠁꠟ ꠅꠁꠟꠦ ꠔ ꠡꠞꠤꠅꠔꠞꠦꠅ ꠛꠖꠟꠣꠘꠤ ꠟꠣꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("HB7_13","088_7_13","HEB","7","13","13","ꠁ ꠢꠇꠟ ꠛꠄꠀꠘ ꠎꠣꠘ ꠘꠤꠅꠔꠦ ꠇꠞꠞꠣꠝ, ꠄꠁꠘ ꠔ ꠟꠦꠛꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠘꠣꠄ, ꠀꠞꠇ ꠉꠥꠡ꠆ꠐꠤꠞ, ꠢꠤ ꠉꠥꠡ꠆ꠐꠤꠞ ꠇꠦꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠈꠣꠖꠤꠝ ꠀꠍꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB7_14","088_7_14","HEB","7","14","14","ꠀꠝꠞꠣꠞ ꠝꠥꠘꠤꠛ ꠔ ꠄꠢꠥꠖꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠣꠎꠦ ꠙꠄꠖꠣ ꠅꠁꠍꠂꠘ, ꠁ ꠉꠥꠡ꠆ꠐꠤꠞ ꠇꠦꠃ ꠁꠝꠣꠝ ꠅꠁꠛꠣ ꠇꠞꠤꠀ ꠝꠥꠍꠣꠄ ꠇꠥꠘ꠆ꠔꠣ ꠇꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB7_15","088_7_15","HEB","7","15","15","ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠘꠝꠥꠘꠣꠄ ꠎꠦꠛꠟꠣ ꠀꠞꠇ ꠎꠘ ꠁꠝꠣꠝꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠂꠘ, ꠁ ꠡꠝꠄ ꠔ ꠀꠝꠞꠣꠞ ꠛꠄꠀꠘ ꠀꠞꠅ ꠍꠣꠚ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB7_16","088_7_16","HEB","7","16","16","ꠁꠍꠣ ꠔ ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠇꠥꠘꠥ ꠘꠤꠅꠝꠦ ꠁꠝꠣꠝ ꠅꠁꠍꠂꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠔꠣꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠇꠥꠖꠞꠔꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠛꠟꠦꠃ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_17","088_7_17","HEB","7","17","17","ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠙꠣꠇ ꠇꠣꠟꠣꠝꠦ ꠇꠄ, ꠝꠣꠟꠇꠤ-ꠍꠤꠖ꠆ꠖꠤꠇꠞ ꠍꠤꠟꠍꠤꠟꠣꠄ, ꠔꠥꠝꠤꠃ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠁꠝꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("HB7_18","088_7_18","HEB","7","18","18","ꠔꠦ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠄꠇꠛꠣꠄ ꠀꠉꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠅꠇꠟ ꠇꠝꠎꠥꠞ ꠀꠞ ꠛꠦꠇꠣꠝꠣ ꠅꠁꠎꠣꠅꠀꠄ ꠁꠔꠣꠞꠦ ꠢꠞꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("HB7_19","088_7_19","HEB","7","19","19","ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠦ ꠔ ꠇꠥꠘ꠆ꠔꠣꠞꠦꠃ ꠇꠣꠝꠤꠟ ꠛꠣꠘꠣꠁꠔ ꠙꠣꠞꠍꠦ ꠘꠣ। ꠀꠞ ꠀꠞꠇꠛꠣꠄ ꠅꠃꠟꠣ ꠄꠇ ꠝꠢꠣꠘ ꠘꠄꠀ ꠅꠀꠖꠣ ꠎꠣꠞꠤ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠁ ꠅꠀꠖꠣꠞ ꠎꠞꠤꠀꠄ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠞꠅ ꠇꠣꠍꠣꠔ ꠀꠁꠔꠣꠝ ꠙꠣꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB7_20","088_7_20","HEB","7","20","20","ꠀꠞ ꠀꠉꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠔ ꠇꠥꠘꠥ ꠇꠍꠝ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠁꠍꠣꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠍꠝ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_21","088_7_21","HEB","7","21","21","ꠔꠣꠁꠘ ꠇꠍꠝ ꠇꠞꠤꠀ ꠄꠘꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠂꠘ, ꠀꠞ ꠇꠁꠍꠂꠘ, ꠝꠣꠛꠥꠖꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠞꠣ, ꠔꠥꠝꠤꠃ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠁꠝꠣꠝ, ꠔꠥꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠘ ꠝꠥꠘꠡꠣ ꠛꠖꠟꠣꠁꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB7_22","088_7_22","HEB","7","22","22","ꠔꠦ ꠀꠝꠞꠣ ꠛꠥꠎꠞꠣꠝ ꠎꠦꠘ, ꠁꠍꠣ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠣꠘꠡꠞ ꠝꠤꠟꠘꠞ ꠀꠞꠅ ꠝꠢꠣꠘ ꠄꠇ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠎꠣꠝꠤꠘꠖꠣꠞ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_23","088_7_23","HEB","7","23","23","ꠀꠞ ꠟꠦꠛꠤꠞ ꠉꠥꠡ꠆ꠐꠤ ꠕꠣꠇꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠦ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠍꠂꠘ, ꠝꠃꠔ ꠅꠁꠎꠣꠄ ꠇꠞꠤ ꠄꠞꠣ ꠇꠥꠘꠥ ꠎꠘꠃ ꠢꠣꠝꠦꠡꠣ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠔꠣ ꠙꠣꠞꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB7_24","088_7_24","HEB","7","24","24","ꠅꠁꠟꠦ ꠁꠍꠣ ꠔ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘ ꠁꠝꠣꠝꠔꠤ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠚꠥꠠꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB7_25","088_7_25","HEB","7","25","25","ꠄꠞꠟꠣꠉꠤꠃ ꠎꠦꠞꠣ ꠔꠣꠘ ꠃꠍꠤꠟ꠆ꠟꠣ ꠟꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠣꠎꠣꠔ ꠖꠣꠘ ꠇꠞꠂꠘ, ꠇꠣꠞꠘ ꠔꠣꠞꠣꠞ ꠙꠇ꠆ꠇꠦ ꠡꠥꠙꠣꠞꠤꠡ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_26","088_7_26","HEB","7","26","26","ꠀꠍꠟꠦ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃꠟꠣ ꠄꠇꠎꠘ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠎꠞꠥꠞꠅ ꠀꠍꠤꠟ, ꠎꠦꠁꠘ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ, ꠛꠦ-ꠉꠥꠘꠣ, ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟ ꠕꠘꠦ ꠀꠟꠉ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠘꠞꠦ ꠀꠍꠝꠣꠘ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠔꠥꠟꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_27","088_7_27","HEB","7","27","27","ꠛꠣꠇꠤ ꠢꠇ꠆ꠇꠟ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠙꠄꠟꠣ ꠔꠣꠘ ꠘꠤꠎꠞ ꠟꠣꠉꠤ, ꠛꠣꠖꠦ ꠔꠣꠘ ꠇꠃꠝꠞ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠙꠞꠔꠦꠇ ꠖꠤꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠣ ꠟꠣꠉꠔ। ꠅꠁꠟꠦ ꠅꠃ ꠁꠝꠣꠝꠞ ꠟꠣꠉꠤ ꠁꠔꠣꠞ ꠎꠞꠥꠞ ꠀꠍꠤꠟ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠔꠣꠘ ꠘꠤꠎꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ ꠄꠇꠁ ꠛꠣꠞꠦ ꠁ ꠇꠣꠝ ꠀꠖꠣꠄ ꠇꠞꠤꠟꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB7_28","088_7_28","HEB","7","28","28","ꠡꠞꠤꠅꠔꠦ ꠎꠔ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠇꠟꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠍꠦ ꠄꠞꠣ ꠢꠇꠟꠃ ꠇꠝꠎꠥꠞ, ꠅꠁꠟꠦ ꠡꠞꠤꠅꠔꠞ ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠍꠝ ꠝꠣꠚꠤꠇ ꠎꠦꠘꠞꠦ ꠛꠅꠀꠁꠟ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠄꠁꠘꠃ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠙꠥꠔ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠁꠝꠣꠝꠔꠤꠞ ꠟꠣꠉꠤ ꠄꠘꠞꠦ ꠇꠣꠝꠤꠟ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB8_1","088_8_1","HEB","8","1","1","ꠀꠝꠞꠣꠞ ꠛꠄꠀꠘꠞ ꠝꠥꠟ ꠛꠦꠙꠣꠞ ꠅꠁꠟ, ꠀꠝꠞꠣꠞ ꠅꠃꠟꠣ ꠄꠇꠎꠘ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠀꠍꠂꠘ, ꠎꠦꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠔꠡꠞꠤꠚ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB8_2","088_8_2","HEB","8","2","2","ꠔꠣꠁꠘ ꠢꠃ ꠀꠍꠟ ꠙꠣꠇ ꠎꠣꠉꠣ, ꠝꠣꠘꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠔ ꠄꠛꠣꠖꠔꠤ ꠇꠞꠞꠣ, ꠁ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠔ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠝꠣꠛꠥꠖꠦ ꠘꠤꠎꠦ ꠛꠣꠘꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB8_3","088_8_3","HEB","8","3","3","ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠟ ꠙꠞꠔꠦꠇ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠖꠣꠄꠁꠔ꠆ꠔ, ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠞ ꠉꠦꠍꠦꠅ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠤꠘꠤꠡ ꠕꠣꠇꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("HB8_4","088_8_4","HEB","8","4","4","ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠅꠈꠘ ꠖꠥꠘꠤꠀꠔ ꠕꠣꠇꠔꠣ ꠔꠦ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠔꠣ ꠙꠣꠞꠟꠣ ꠘꠣ ꠅꠘꠦ, ꠇꠣꠞꠘ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠛꠣꠞ ꠁꠝꠣꠝ ꠔ ꠀꠍꠂꠘꠃ। ");
INSERT INTO syls_vpl VALUES ("HB8_5","088_8_5","HEB","8","5","5","ꠢꠤ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠇꠣꠝ ꠅꠁꠟ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠇꠣꠝꠞ ꠘꠝꠥꠘꠣ ꠛꠣ ꠍꠣꠄꠀ, ꠎꠦꠟꠣ ꠝꠥꠍꠣꠄ ꠢꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠛꠣꠘꠣꠘꠤꠞ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠄ ꠝꠥꠍꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠤ ꠇꠁꠟꠣ, “ꠖꠦꠈꠤꠅ, ꠅꠃ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠘꠇꠡꠣ ꠖꠦꠈꠣꠁꠟꠣꠝ, ꠄꠇ꠆ꠇꠦꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠤ ꠢꠇꠟꠔꠣ ꠛꠣꠘꠣꠁꠅ।” ");
INSERT INTO syls_vpl VALUES ("HB8_6","088_8_6","HEB","8","6","6","ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠞꠣ ꠖꠦꠈꠞꠣꠝ, ꠁꠍꠣꠄ ꠁꠝꠣꠝꠔꠤꠞ ꠎꠦ ꠖꠣꠄꠁꠔ꠆ꠔ ꠙꠣꠁꠍꠂꠘ, ꠁꠐꠣ ꠢꠤ ꠁꠝꠣꠝ ꠅꠇꠟ ꠕꠣꠇꠤ ꠛꠃꠔ ꠜꠣꠟꠣ, ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠣꠘꠡꠞ ꠝꠤꠟꠘꠞ ꠀꠞꠅ ꠜꠣꠟꠣ ꠄꠇ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞ ꠅꠁꠍꠂꠘ। ꠁ ꠃꠍꠤꠟ꠆ꠟꠣ ꠀꠉꠞ ꠃꠍꠤꠟ꠆ꠟꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠜꠣꠟꠣ; ꠁ ꠃꠍꠤꠟ꠆ꠟꠣ ꠔ ꠛꠃꠔ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠅꠀꠖꠣꠞ ꠃꠙꠞꠦ ꠇꠣꠁꠝ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB8_7","088_8_7","HEB","8","7","7","ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠝꠤꠟꠘꠞ ꠙꠄꠟꠣ ꠃꠍꠤꠟ꠆ꠟꠣ ꠎꠥꠖꠤ ꠘꠤꠈꠥꠔ ꠅꠁꠔ, ꠔꠦ ꠖꠥꠍꠞꠣ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠣꠁꠝꠞ ꠇꠥꠘꠥ ꠎꠞꠥꠞ ꠀꠍꠤꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB8_8","088_8_8","HEB","8","8","8","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠖꠥꠡ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠎꠦꠟꠣ ꠀꠍꠝꠣꠘꠤ ꠇꠤꠔꠣꠛꠦ ꠇꠄ, ꠝꠣꠛꠥꠖꠦ ꠇꠁꠞꠣ, ꠢꠥꠘꠅ, ꠅꠟꠣ ꠄꠇ ꠅꠇ꠆ꠔ ꠀꠁꠛ, ꠎꠦꠛꠟꠣ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠀꠞ ꠄꠢꠥꠖꠣ ꠉꠥꠡ꠆ꠐꠤꠞ ꠟꠣꠉꠤ, ꠀꠝꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠄꠇ ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠣꠁꠝ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB8_9","088_8_9","HEB","8","9","9","ꠅꠃ ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣ ꠀꠉꠞ ꠢꠤ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠄ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠔꠣꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ, ꠀꠎꠣꠖ ꠇꠞꠤ ꠀꠘꠣꠞ ꠛꠣꠟꠣ ꠎꠦ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠞꠍꠟꠣꠝ। ꠇꠣꠞꠘ ꠔꠣꠞꠣ ꠀꠝꠣꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠑꠤꠇ ꠞꠁꠍꠦ ꠘꠣ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤꠅ ꠔꠣꠞꠣꠞ ꠟꠉ ꠍꠣꠠꠤ ꠖꠤꠍꠤ, ꠁꠈꠣꠘ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("HB8_10","088_8_10","HEB","8","10","10","ꠅꠁꠟꠦ ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠄꠅꠈꠣꠘꠅ ꠇꠁꠞꠣꠝ, ꠁ ꠎꠝꠣꠘꠣꠞ ꠛꠣꠖꠦ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ, ꠀꠝꠣꠞ ꠘꠄꠀ ꠅꠃ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠣꠁꠝ ꠇꠞꠝꠥ, ꠀꠝꠣꠞ ꠡꠞꠤꠅꠔ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠖꠤꠝꠥ, ꠔꠣꠞꠣꠞ ꠅꠘ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠟꠦꠈꠤꠀ ꠖꠤꠝꠥ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠅꠁꠝꠥ, ꠔꠣꠞꠣ ꠅꠁꠛꠣ ꠀꠝꠣꠞ ꠙ꠆ꠞꠎꠣ। ");
INSERT INTO syls_vpl VALUES ("HB8_11","088_8_11","HEB","8","11","11","ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠔꠣꠞꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ, ꠎꠣꠞꠎꠤꠞ ꠜꠣꠁ-ꠛꠤꠞꠣꠖꠞꠞꠦ ꠁꠟꠣ ꠔꠣꠟꠤꠝ ꠖꠦꠅꠀ ꠟꠣꠉꠔ ꠘꠣꠄ ꠛꠥꠟꠦ, ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠌꠤꠘꠅ। ꠔꠣꠞꠣ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇ꠆ꠇꠟꠦ ꠄꠝꠘꠦꠃ ꠔ ꠀꠝꠣꠞꠦ ꠌꠤꠘꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("HB8_12","088_8_12","HEB","8","12","12","ꠇꠣꠞꠘ ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠢꠇ꠆ꠇꠟ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠝꠣꠚ ꠇꠞꠝꠥ, ꠔꠣꠞꠣꠞ ꠉꠥꠘꠣꠞꠦ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠝꠘꠅ ꠞꠣꠈꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB8_13","088_8_13","HEB","8","13","13","ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ‘ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣ’ ꠇꠕꠣ ꠇꠁꠀ ꠔꠣꠁꠘ ꠙꠄꠟꠣ ꠃꠍꠤꠟ꠆ꠟꠣꠞꠦ ꠙꠥꠞꠣꠘ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠀꠞ ꠎꠦꠔꠣ ꠅꠌꠟ-ꠙꠥꠞꠣꠘ ꠅꠁꠎꠣꠄ, ꠁꠔꠣ ꠔ ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠞꠣꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB9_1","088_9_1","HEB","9","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠣꠘꠡꠞ ꠝꠤꠟꠘꠞ ꠙꠄꠟꠣ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠝꠣꠎꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔꠤꠞ ꠟꠣꠉꠤ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠘꠤꠅꠝ-ꠇꠣꠘꠥꠘ ꠀꠍꠤꠟ, ꠀꠞ ꠖꠥꠘꠤꠀꠔ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠇꠕꠣꠅ ꠟꠦꠈꠣ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("HB9_2","088_9_2","HEB","9","2","2","ꠢꠃ ꠘꠤꠅꠝ ꠝꠣꠚꠤꠇ ꠄꠇꠈꠣꠘ ꠄꠛꠣꠖꠔ-ꠔꠣꠝ꠆ꠛꠥ ꠛꠣꠘꠣꠁꠟ ꠅꠁꠍꠤꠟ, ꠢꠤ ꠄꠛꠣꠖꠔ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠙꠄꠟꠣ ꠇꠥꠑꠣꠔ ꠀꠍꠤꠟ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤ, ꠙꠛꠤꠔ꠆ꠞ ꠞꠥꠐꠤ ꠀꠞ ꠁꠔꠣ ꠞꠣꠈꠣꠞ ꠐꠦꠛꠥꠟ। ꠁ ꠙꠄꠟꠣ ꠇꠥꠑꠣꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠙꠣꠇ ꠎꠣꠉꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_3","088_9_3","HEB","9","3","3","ꠖꠥꠍꠞꠣ ꠙꠞ꠆ꠖꠣꠞ ꠜꠤꠔꠞꠦ ꠀꠞꠇ ꠇꠥꠑꠣ ꠀꠍꠤꠟ, ꠢꠤ ꠖꠥꠍꠞꠣ ꠇꠥꠑꠣꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠈꠣꠍ ꠙꠣꠇ ꠎꠣꠉꠣ ꠛꠣ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚ। ");
INSERT INTO syls_vpl VALUES ("HB9_4","088_9_4","HEB","9","4","4","ꠁ ꠇꠥꠑꠣꠞ ꠝꠣꠎꠦ ꠀꠍꠤꠟ, ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠎꠣꠟꠣꠘꠤ ꠐꠦꠛꠥꠟ, ꠡꠥꠘꠣꠖꠤ ꠟꠦꠙꠣ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ, ꠡꠘ꠆ꠖꠥꠇꠞ ꠜꠤꠔꠞꠦ ꠀꠍꠤꠟ ꠡꠥꠘꠣꠞ ꠛꠂꠀꠝꠅ ꠜꠞꠣ ꠇꠥꠖꠞꠔꠤ ꠈꠣꠘꠤ ꠝꠣꠘ꠆ꠘꠣ, ꠁꠝꠣꠝ ꠢꠣꠞꠥꠘꠞ ꠟꠣꠑꠤ, ꠅꠃ ꠟꠣꠑꠤꠔ ꠇꠥꠖꠞꠔꠤ ꠚꠥꠟ ꠚꠥꠐꠤꠍꠤꠟ। ꠀꠞꠅ ꠀꠍꠤꠟ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠃꠍꠤꠟ꠆ꠟꠣ ꠟꠦꠈꠣ ꠢꠃ ꠖꠥꠁꠅ ꠡꠣꠢꠣꠖꠔ ꠙꠣꠔ꠆ꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("HB9_5","088_9_5","HEB","9","5","5","ꠢꠤ ꠡꠘ꠆ꠖꠥꠇꠞ ꠃꠙꠞꠦ ꠀꠍꠤꠟ ꠀꠟ꠆ꠟꠣꠞ ꠎꠣꠟꠣꠟꠤ ꠡꠥꠘꠣꠞ ꠖꠥꠁ ꠇꠣꠞꠥꠛꠤ, ꠅꠔꠣꠞ ꠒꠣꠈꠘꠣꠉꠥꠁꠘ ꠢꠃ ꠡꠘ꠆ꠖꠥꠇꠞ ꠓꠣꠇꠘꠤꠞ ꠃꠙꠞꠦ ꠝꠤꠟꠤꠀ ꠖꠦꠅꠀ ꠀꠍꠤꠟ, ꠀꠞ ꠅꠘꠅꠃ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠔ। ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠈꠥꠐꠤꠘꠣꠐꠤ ꠛꠄꠀꠘ ꠇꠞꠣ ꠅꠈꠘ ꠎꠞꠥꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB9_6","088_9_6","HEB","9","6","6","ꠁ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠥꠁꠔ ꠇꠞꠣꠞ ꠛꠣꠖꠦ ꠁꠝꠣꠝ ꠅꠇꠟꠦ ꠁꠝꠣꠝꠔꠤ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠢꠣꠝꠦꠡꠣ ꠙꠄꠟꠣ ꠇꠥꠑꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_7","088_9_7","HEB","9","7","7","ꠅꠁꠟꠦ ꠖꠥꠍꠞꠣ ꠇꠥꠑꠣꠔ, ꠝꠣꠘꠤ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠈꠣꠟꠤ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠛꠍꠞꠅ ꠄꠇꠛꠣꠞꠃ ꠢꠣꠝꠣꠁꠔꠣ ꠙꠣꠞꠔꠣ, ꠔꠣꠁꠘꠅ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ ꠛꠤꠘꠣ ꠢꠤꠘꠅ ꠢꠣꠝꠣꠁꠔꠣ ꠙꠣꠞꠔꠣ ꠘꠣ। ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠥꠘꠣ ꠀꠞ ꠔꠣꠘ ꠇꠃꠝꠞ ꠘꠣ-ꠎꠣꠘꠣ ꠢꠇꠟ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ ꠟꠁꠀ ꠢꠘꠅ ꠢꠣꠝꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_8","088_9_8","HEB","9","8","8","ꠔꠦ ꠙꠣꠇ ꠞꠥꠢꠦ ꠖꠦꠈꠣꠁꠀ ꠖꠤꠞꠣ, ꠁ ꠖꠥꠘꠤꠀꠞ ꠙꠄꠟꠣ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠎꠔꠖꠤꠘ ꠇꠣꠁꠝ ꠀꠍꠦ, ꠅꠔꠖꠤꠘ ꠢꠤ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠙꠕ ꠈꠥꠟꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB9_9","088_9_9","HEB","9","9","9","ꠢꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠅꠁꠟ ꠁ ꠎꠝꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠄꠇ ꠘꠤꠡꠣꠘꠣ, ꠁ ꠘꠤꠡꠣꠘꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠔꠣꠁ ꠖꠦꠄ, ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠞ ꠟꠤꠟ꠆ꠟꠣ-ꠍꠖꠉꠣꠄ ꠄꠛꠣꠖꠔꠇꠣꠞꠤꠞ ꠛꠤꠛꠦꠇꠞ ꠈꠥꠔꠈꠥꠔꠤ ꠜꠣꠛ ꠖꠥꠞ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_10","088_9_10","HEB","9","10","10","ꠁꠔꠣ ꠔ ꠈꠣꠟꠤ ꠈꠣꠅꠀ-ꠖꠣꠅꠀ, ꠅꠎꠥ-ꠉꠥꠍꠟꠞ ꠛꠦꠙꠣꠞ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠈꠣꠟꠤ ꠎꠣꠁꠞꠣ ꠡꠞꠤꠅꠔ, ꠖꠤꠟꠞ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ꠁ ꠡꠞꠤꠅꠔ ꠇꠣꠁꠝ ꠀꠍꠤꠟ, ꠀꠞꠅ ꠜꠣꠟꠣ ꠇꠥꠘꠥ ꠃꠍꠤꠟ꠆ꠟꠣ ꠀꠁꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("HB9_11","088_9_11","HEB","9","11","11","ꠅꠁꠟꠦ ꠅꠈꠘ ꠎꠔ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠛꠦꠙꠣꠞ ꠀꠁꠍꠦ, ꠀꠟ-ꠝꠍꠤ ꠔ ꠅꠃ ꠘꠄꠀ ꠔꠞꠤꠇꠣꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠁꠍꠂꠘ। ꠔꠣꠁꠘ ꠀꠞꠅ ꠁꠎ꠆ꠎꠔꠤ ꠀꠞꠅ ꠛꠦꠡꠤ ꠇꠣꠝꠤꠟ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠅꠁꠀ ꠀꠁꠍꠂꠘ। ꠁ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠘꠣꠄ, ꠁꠈꠣꠘ ꠁ ꠖꠥꠘꠤꠀꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB9_12","088_9_12","HEB","9","12","12","ꠇꠥꠘꠥ ꠉꠞꠥ ꠛꠣ ꠍꠣꠉꠟꠞ ꠟꠃ ꠀꠔꠅ ꠟꠁꠀ ꠔꠣꠁꠘ ꠢꠤꠘꠅ ꠢꠣꠝꠣꠁꠍꠂꠘ ꠘꠣ। ꠈꠣꠟꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ ꠖꠤꠀ ꠄꠇꠛꠣꠞꠃ ꠢꠤ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠈꠣꠘꠅ ꠢꠣꠝꠣꠁꠍꠂꠘ, ꠢꠣꠝꠣꠁꠀ ꠀꠝꠞꠣꠞꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠟꠣꠉꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB9_13","088_9_13","HEB","9","13","13","ꠀꠉꠦ ꠎꠦꠞꠣ ꠘꠣꠙꠣꠇ ꠛꠘꠤꠎꠤꠔ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠉꠞꠥ ꠛꠣ ꠍꠣꠉꠟꠞ ꠟꠃ ꠀꠞ ꠒꠦꠇꠤ-ꠉꠞꠥꠞ ꠎꠣꠟꠣꠁꠟ ꠍꠣꠟꠤ ꠍꠤꠐꠣꠁꠀ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠔ, ꠅꠁꠟꠦ ꠁꠔꠣꠄ ꠔ ꠄꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠛꠣꠁꠞꠉꠣꠟꠣ ꠈꠣꠟꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("HB9_14","088_9_14","HEB","9","14","14","ꠔꠦ ꠎꠦꠁꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠎꠤꠘ꠆ꠖꠣ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤꠀ, ꠛꠦ-ꠉꠥꠘꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠁꠀ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠡꠙꠤꠀ ꠖꠤꠟꠣꠁꠍꠂꠘ, ꠢꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠃꠄ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠘꠣꠙꠣꠇꠤ ꠇꠣꠝ-ꠇꠣꠎ ꠕꠣꠇꠤ ꠀꠞꠅ ꠇꠔ ꠛꠦꠡꠤ ꠙꠞꠤꠝꠣꠘꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠛ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("HB9_15","088_9_15","HEB","9","15","15","ꠀꠞ ꠙꠄꠟꠣ ꠃꠍꠤꠟ꠆ꠟꠣ ꠌꠣꠟꠥ ꠕꠣꠇꠔꠦ ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣ ꠉꠥꠘꠣ ꠇꠞꠍꠟꠣ, ꠅꠃ ꠉꠥꠘꠣꠞ ꠀꠔ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠇꠚꠞꠣ ꠢꠤꠡꠣꠛꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠃꠔ ꠅꠁꠍꠦ। ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠞꠣꠞꠦ ꠖꠣꠅꠔꠖꠤ ꠀꠘꠤꠀ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠝꠃꠞꠡꠤ ꠡꠝ꠆ꠙꠖ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠀꠟ-ꠝꠍꠤ ꠔ ꠄꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞ ꠅꠁꠍꠂꠘ। ꠅꠃ ꠝꠃꠞꠡꠤ ꠡꠝ꠆ꠙꠖ ꠅꠈꠘ ꠝꠣꠘꠡꠦ ꠙꠣꠁꠛꠣꠞ ꠡꠥꠎꠥꠉ ꠅꠁꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("HB9_16","088_9_16","HEB","9","16","16","ꠇꠣꠞꠘ ꠖꠥꠘꠤꠀꠛꠤ ꠘꠤꠅꠝꠦ ꠝꠃꠞꠡꠤ ꠡꠝ꠆ꠙꠖꠞ ꠇꠥꠘꠥ ꠅꠍꠤꠅꠔ-ꠘꠣꠝꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠔꠦ ꠅꠁꠟꠦ, ꠙꠄꠟꠣ ꠅꠃ ꠅꠍꠤꠅꠔ ꠇꠞꠞꠣꠞ ꠝꠃꠔ ꠅꠁꠍꠦ ꠇꠞꠤ ꠙꠞꠝꠣꠘ ꠖꠞꠇꠣꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("HB9_17","088_9_17","HEB","9","17","17","ꠝꠣꠘꠡꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ ꠔꠣꠞ ꠅꠍꠤꠅꠔ-ꠘꠣꠝꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠦ, ꠅꠍꠤꠅꠔ ꠇꠞꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠕꠣꠇꠔꠦ ꠁꠔꠣ ꠇꠥꠘꠥ ꠇꠣꠝꠅ ꠟꠣꠉꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_18","088_9_18","HEB","9","18","18","ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘꠃ, ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠙꠄꠟꠣ ꠃꠍꠤꠟ꠆ꠟꠣꠅ, ꠝꠃꠔꠞ ꠟꠃ ꠍꠣꠠꠣ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_19","088_9_19","HEB","9","19","19","ꠢꠎꠞꠔ ꠝꠥꠍꠣꠄ ꠡꠞꠤꠅꠔꠞ ꠔꠣꠝꠣꠝ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠎꠣꠘꠣꠘꠤꠞ ꠛꠣꠖꠦ, ꠔꠣꠁꠘ ꠛꠤꠍꠣꠟ ꠀꠞ ꠍꠣꠉꠟꠞ ꠟꠃꠞ ꠟꠉꠦ ꠙꠣꠘꠤ ꠝꠤꠡꠣꠁꠟꠣ, ꠛꠣꠖꠦ ꠟꠣꠟ ꠞꠋ ꠇꠞꠣ ꠝꠦꠠꠣꠞ ꠞꠥꠝꠣ ꠀꠞ ꠄꠍꠥꠛ ꠉꠣꠍꠞ ꠒꠦꠐꠣꠖꠤ ꠀꠟ꠆ꠟꠣꠁ ꠡꠞꠤꠅꠔ ꠇꠤꠔꠣꠛꠞ ꠃꠙꠞꠦ, ꠀꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠔꠞꠅ ꠍꠤꠐꠣꠁꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_20","088_9_20","HEB","9","20","20","ꠝꠥꠍꠣꠄ ꠇꠁꠟꠣ, “ꠁ ꠟꠃ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠁ ꠝꠤꠟꠘꠞ ꠢꠃ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠟꠃ, ꠎꠦ ꠃꠍꠤꠟ꠆ꠟꠣ ꠝꠣꠚꠤꠇ ꠌꠟꠣꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("HB9_21","088_9_21","HEB","9","21","21","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠁꠘ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠀꠞ ꠄꠛꠣꠖꠔꠤ ꠇꠣꠝꠞ ꠢꠇ꠆ꠇꠟ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣꠞ ꠃꠙꠞꠦꠅ ꠟꠃ ꠍꠤꠐꠣꠁꠀ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_22","088_9_22","HEB","9","22","22","ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔ ꠝꠣꠚꠤꠇ ꠛꠦꠡꠤꠞ ꠜꠣꠉ ꠎꠤꠘꠤꠡꠃ ꠟꠃ ꠖꠤꠀ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠔꠦ ꠅꠄ, ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃ ꠍꠣꠠꠣ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠙꠣꠅꠀ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_23","088_9_23","HEB","9","23","23","ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡ ꠅꠇꠟ ꠈꠣꠟꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠎꠤꠘꠤꠡꠞ ꠘꠤꠡꠣꠘꠣ, ꠅꠔꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠟꠃꠖꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠎꠞꠥꠞ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡ ꠀꠍꠟ ꠛꠦꠢꠦꠡ꠆ꠔꠤ, ꠁꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔ ꠀꠞꠅ ꠝꠢꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("HB9_24","088_9_24","HEB","9","24","24","ꠀꠞ ꠀꠟ-ꠝꠍꠤ ꠔ ꠢꠃ ꠘꠤꠡꠣꠘꠣꠞ ꠎꠤꠘꠤꠡꠞ ꠟꠣꠈꠣꠘ, ꠝꠣꠘꠡꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠇꠥꠘꠥ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠁꠍꠂꠘ ꠘꠣ, ꠔꠣꠁꠘ ꠈꠣꠟꠤ ꠀꠍꠟ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠢꠣꠝꠣꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠀꠝꠞꠣꠞ ꠘꠣꠎꠣꠔꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠅꠈꠘ ꠀꠎꠤꠞ ꠅꠁꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB9_25","088_9_25","HEB","9","25","25","ꠢꠇꠟ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠦ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠙꠡꠥꠞ ꠟꠃ ꠟꠁꠀ ꠎꠦꠟꠣ ꠙꠞꠔꠦꠇ ꠛꠍꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠘꠤ ꠟꠣꠉꠦ, ꠀꠟ-ꠝꠍꠤ ꠔ ꠁ ꠟꠣꠈꠣꠘ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠀꠞ ꠟꠣꠉꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠡꠞꠤꠚ ꠘꠤꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB9_26","088_9_26","HEB","9","26","26","ꠁ ꠟꠣꠈꠣꠘ ꠅꠁꠟꠦ ꠔ ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠁꠘ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠇꠡ꠆ꠐ ꠙꠣꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠁꠔꠦ ꠅꠁꠟ ꠅꠘꠦ। ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠔ ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠔ ꠀꠁꠀ ꠈꠣꠟꠤ ꠄꠇꠛꠣꠞꠃ ꠎꠣꠁꠞ ꠅꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠘꠤꠎꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ ꠔꠣꠝꠣꠝ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB9_27","088_9_27","HEB","9","27","27","ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠑꠤꠇ ꠇꠞꠤꠀ ꠖꠤꠟꠣꠁꠍꠂꠘ, ꠢꠇ꠆ꠇꠟ ꠝꠣꠘꠡꠞ ꠈꠣꠟꠤ ꠄꠇꠛꠣꠞ ꠝꠞꠘ ꠅꠁꠛ, ꠀꠞ ꠝꠞꠘ ꠛꠣꠖꠦ ꠛꠤꠌꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("HB9_28","088_9_28","HEB","9","28","28","ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ, ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠛꠥꠏꠣ ꠛꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤꠞꠦꠅ ꠈꠣꠟꠤ ꠄꠇꠛꠣꠞꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠔꠣꠁꠘ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ, ꠅꠁꠟꠦ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠛꠘꠣꠞ ꠟꠣꠉꠤ ꠀꠁꠔꠣ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠎꠦꠞꠣ ꠀꠡꠤꠇ ꠅꠁꠀ ꠔꠣꠘ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠞ, ꠔꠣꠞꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠣꠎꠣꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_1","088_10_1","HEB","10","1","1","ꠡꠞꠤꠅꠔ ꠅꠁꠟꠉꠤ ꠈꠣꠟꠤ ꠄꠇ ꠘꠤꠡꠣꠘꠣ, ꠁꠔꠣꠄ ꠜꠛꠤꠡꠔꠞ ꠘꠤꠀꠝꠔꠞ ꠇꠕꠣ ꠛꠣꠔꠣꠁ ꠖꠦꠄ, ꠁꠐꠣ ꠔ ꠀꠍꠟ ꠇꠥꠘꠥ ꠛꠦꠙꠣꠞ ꠘꠣꠄ। ꠄꠞꠟꠣꠉꠤꠃ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠣꠞ ꠈꠤꠀꠟꠤ ꠅꠄ, ꠡꠞꠤꠅꠔꠞ ꠘꠤꠅꠝꠦ ꠔꠣꠞꠣ ꠛꠍꠞ ꠛꠍꠞ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ ꠔ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠇꠣꠝꠤꠟ ꠅꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_2","088_10_2","HEB","10","2","2","ꠡꠞꠤꠅꠔꠦ ꠎꠥꠖꠤ ꠔꠣꠞꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠟ ꠛꠣꠘꠣꠁꠟꠤꠔ, ꠔꠦ ꠔ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠄꠇꠛꠣꠞꠦꠃ ꠛꠘ꠆ꠖ ꠅꠁꠉꠦꠟ ꠅꠘꠦ। ꠄꠛꠣꠖꠔ ꠇꠞꠞꠣ ꠅꠇꠟ ꠎꠥꠖꠤ ꠄꠇꠛꠣꠞꠦꠃ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠘꠤꠎꠤꠔ, ꠔꠦ ꠄꠞꠣ ꠘꠤꠎꠞꠦ ꠀꠞ ꠉꠥꠘꠣꠉꠣꠞ ꠝꠘꠅ ꠇꠞꠟ ꠘꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("HB10_3","088_10_3","HEB","10","3","3","ꠅꠁꠟꠦ ꠅꠃ ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤꠄ ꠔꠣꠞꠣꠞꠦ ꠙꠞꠔꠦꠇ ꠛꠍꠞ ꠁꠀꠖ ꠇꠞꠣꠁꠀ ꠖꠦꠄ ꠎꠦꠘ, ꠔꠣꠞꠣ ꠀꠍꠟꠦ ꠉꠥꠘꠣꠉꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("HB10_4","088_10_4","HEB","10","4","4","ꠝꠥꠟꠔ, ꠍꠣꠉꠟ ꠛꠣ ꠛꠤꠍꠣꠟꠞ ꠟꠃꠄ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞꠦ ꠇꠥꠘꠥ ꠟꠣꠈꠣꠘꠃ ꠍꠣꠚ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_5","088_10_5","HEB","10","5","5","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠣꠟꠅ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠁꠍꠂꠘ, ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠛꠣ ꠖꠣꠘ-ꠍꠖꠉꠣ ꠔ ꠀꠍꠟꠦ ꠔꠥꠝꠤ ꠌꠣꠅ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠝꠣꠞꠦ ꠄꠇꠈꠣꠘ ꠇꠣꠄꠀ ꠖꠤꠍ ꠛꠤꠟꠣꠁ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("HB10_6","088_10_6","HEB","10","6","6","ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠛꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠄ ꠔꠥꠝꠤ ꠔ ꠈꠥꠡꠤ ꠅꠁꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_7","088_10_7","HEB","10","7","7","ꠔꠦꠃ ꠀꠝꠤ ꠇꠁꠟꠣꠝ, ꠅ ꠀꠟ꠆ꠟꠣ, ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠔ ꠅꠘꠅ ꠀꠁꠍꠤ; ꠔꠥꠝꠣꠞ ꠇꠣꠟꠣꠝ ꠡꠞꠤꠚꠅ ꠎꠦꠟꠣ ꠀꠍꠦ, ꠀꠝꠣꠞ ꠎꠘꠝ ꠅꠁꠛ ꠅꠃ ꠎꠉꠔꠅ, ꠔꠥꠝꠣꠞ ꠝꠥꠘꠡꠣꠞꠦ ꠇꠣꠁꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠀꠞ ꠢꠣꠍꠣꠃ ꠀꠝꠤ ꠀꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("HB10_8","088_10_8","HEB","10","8","8","ꠃꠙꠞꠞ ꠀꠄꠀꠔ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠀꠟ-ꠝꠍꠤꠄ ꠙꠄꠟꠣ ꠇꠁꠞꠣ, “ꠙꠡꠥ ꠇꠥꠞꠛꠣꠘꠤ ꠛꠣ ꠖꠣꠘ-ꠍꠖꠉꠣ ꠔ ꠀꠍꠟꠦ ꠔꠥꠝꠤ ꠌꠣꠅ ꠘꠣ, ꠎꠣꠟꠣꠁꠟ ꠇꠥꠞꠛꠣꠘꠤ ꠛꠣ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠇꠥꠞꠛꠣꠘꠤꠄ ꠔꠥꠝꠤ ꠔ ꠈꠥꠡꠤ ꠅꠁꠍ ꠘꠣ।” ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠇꠟ ꠀꠖꠣꠄ ꠇꠞꠣ ꠅꠁꠟꠦꠅ, ꠀꠟ-ꠝꠍꠤꠄ ꠅꠟꠣ ꠇꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_9","088_10_9","HEB","10","9","9","ꠛꠣꠖꠞ ꠀꠄꠀꠔꠅ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠀꠝꠤ ꠔ ꠅꠘꠅ ꠀꠁꠍꠤ, ꠔꠥꠝꠣꠞ ꠝꠥꠘꠡꠣꠞꠦ ꠇꠣꠁꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ।” ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠖꠥꠍꠞꠣ ꠃꠍꠤꠟ꠆ꠟꠣꠞꠦ ꠇꠣꠁꠝ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠔꠣꠁꠘ ꠙꠄꠟꠣ ꠃꠍꠤꠟ꠆ꠟꠣꠞꠦ ꠛꠣꠔꠤꠟ ꠇꠞꠤꠟꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_10","088_10_10","HEB","10","10","10","ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠢꠃ ꠝꠥꠘꠡꠣ ꠝꠣꠚꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠣꠄꠀꠞꠦ ꠈꠣꠟꠤ ꠄꠇꠛꠣꠞꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠅꠃ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠛꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB10_11","088_10_11","HEB","10","11","11","ꠙꠞꠔꠦꠇ ꠁꠝꠣꠝ ꠍꠣꠛꠦ ꠙꠞꠔꠤꠖꠤꠘ ꠀꠎꠤꠞ ꠅꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔꠤ ꠇꠞꠂꠘ ꠀꠞ ꠛꠣꠞꠦ ꠛꠣꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠂꠘ, ꠔꠣ-ꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠄ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠉꠥꠘꠣꠞꠦ ꠗꠁꠀ ꠍꠣꠚ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_12","088_10_12","HEB","10","12","12","ꠅꠁꠟꠦ ꠀꠟ-ꠝꠍꠤꠄ ꠔ ꠌꠤꠞꠇꠣꠟꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠈꠣꠟꠤ ꠄꠇꠛꠣꠞꠃ ꠇꠥꠞꠛꠣꠘꠤ ꠅꠁꠀ, ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠔꠡꠞꠤꠚ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB10_13","088_10_13","HEB","10","13","13","ꠀꠞ ꠢꠃ ꠡꠝꠄ ꠕꠣꠇꠤ ꠔꠣꠁꠘ ꠛꠣꠞ ꠌꠣꠁꠞꠣ, ꠎꠔꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠔꠣꠘ ꠙꠣꠅꠞ ꠔꠟꠣꠔ ꠚꠣꠟꠣꠁꠀ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠣ ꠘꠣ ꠅꠄ, ꠅꠔꠖꠤꠘ ꠛꠣꠞ ꠌꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_14","088_10_14","HEB","10","14","14","ꠇꠣꠞꠘ ꠔꠣꠘ ꠅꠃ ꠄꠇꠛꠣꠞꠞ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠎꠦꠞꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠄꠞꠣꠞꠦ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤꠃ ꠔꠣꠁꠘ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB10_15","088_10_15","HEB","10","15","15","ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠞꠥꠢꠦꠅ ꠀꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ, ꠔꠣꠁꠘ ꠙꠄꠟꠣ ꠇꠁꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("HB10_16","088_10_16","HEB","10","16","16","ꠀꠝꠤ ꠝꠣꠛꠥꠖꠦ ꠇꠁꠞꠣꠝ, ꠁ ꠎꠝꠣꠘꠣꠞ ꠛꠣꠖꠦ ꠀꠝꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠟꠉꠦ, ꠀꠝꠣꠞ ꠘꠄꠀ ꠅꠃ ꠃꠍꠤꠟ꠆ꠟꠣ ꠇꠣꠁꠝ ꠇꠞꠝꠥ, ꠀꠝꠣꠞ ꠡꠞꠤꠅꠔ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠖꠤꠝꠥ, ꠔꠣꠞꠣꠞ ꠅꠘ꠆ꠔꠞꠞ ꠝꠣꠎꠦ ꠀꠝꠤ ꠟꠦꠈꠤꠀ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB10_17","088_10_17","HEB","10","17","17","ꠛꠣꠖꠦ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠞꠣ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠀꠞ ꠉꠥꠘꠣꠞꠦ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠝꠘꠅ ꠞꠣꠈꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB10_18","088_10_18","HEB","10","18","18","ꠔꠦ ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠛꠟꠣ ꠉꠥꠘꠣ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠝꠣꠚꠤ ꠖꠤꠟꠣꠁꠘ, ꠄꠞꠛꠣꠖꠦ ꠔ ꠉꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠥꠞꠛꠣꠘꠤꠞꠃ ꠎꠞꠥꠞ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("HB10_19","088_10_19","HEB","10","19","19","ꠄꠞꠟꠣꠉꠤꠃ ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠃꠞ ꠎꠞꠤꠀꠄ, ꠀꠝꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠡꠣꠅꠡ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("HB10_20","088_10_20","HEB","10","20","20","ꠀꠟ-ꠝꠍꠤꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠘꠄꠀ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠄꠇ ꠔꠞꠤꠇꠣ ꠈꠥꠟꠍꠂꠘ, ꠔꠣꠘ ꠡꠞꠤꠟ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠅꠃ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠞ ꠖꠥꠀꠞꠞ ꠙꠞ꠆ꠖꠣ ꠙꠣꠞ ꠅꠁꠀ, ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠅꠁꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("HB10_21","088_10_21","HEB","10","21","21","ꠔꠦ ꠀꠝꠞꠣꠞ ꠄꠇꠎꠘ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝꠅ ꠀꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠞꠤꠛꠣꠞꠞ ꠔꠣꠝꠣꠝ ꠝꠣꠘꠡꠞ ꠎꠤꠝ꠆ꠝꠣ ꠔ ꠔꠣꠘ ꠀꠔꠅ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB10_22","088_10_22","HEB","10","22","22","ꠄꠞꠟꠣꠉꠤ ꠀꠅ, ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠤꠌ꠆ꠌꠤꠔ ꠛꠘꠤꠀ ꠈꠣꠐꠤ ꠖꠤꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞ ꠅꠁ; ꠇꠣꠞꠘ ꠖꠥꠡꠤ ꠛꠤꠛꠦꠇꠞ ꠀꠔ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠃꠄ ꠙꠣꠇ-ꠍꠣꠚ ꠛꠣꠘꠣꠁꠍꠦ, ꠀꠞ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠙꠣꠘꠤ ꠖꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠘꠣꠅꠀꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB10_23","088_10_23","HEB","10","23","23","ꠝꠥꠝꠤꠘ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠦ ꠜꠞꠡꠣ ꠀꠍꠦ ꠇꠁꠀ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠤ, ꠀꠅ, ꠅꠃ ꠜꠞꠡꠣꠄ ꠙꠥꠞꠣꠙꠥꠞ ꠝꠎꠛꠥꠔ ꠞꠁꠀ ꠔꠣꠘ ꠔꠞꠤꠇꠣꠄ ꠌꠟꠤ, ꠇꠣꠞꠘ ꠎꠦꠁꠘ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ ꠄꠁꠘ ꠔ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("HB10_24","088_10_24","HEB","10","24","24","ꠀꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟ ꠇꠞꠤ, ꠝꠢꠛ꠆ꠛꠔ ꠀꠞ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠡꠣꠅꠡ-ꠙꠞꠣꠝꠤꠡ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("HB10_25","088_10_25","HEB","10","25","25","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠞ ꠡ꠆ꠛꠜꠣꠛ ꠅꠁꠟ, ꠔꠣꠞꠣ ꠎꠝꠣꠔꠅ ꠀꠁꠀ ꠡꠞꠤꠇ ꠅꠄ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠅꠃ ꠟꠣꠈꠣꠘ ꠘꠣ ꠅꠁ। ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠅꠇ꠆ꠔ ꠎꠔ ꠊꠘꠣꠁꠀ ꠀꠁꠅꠞ, ꠀꠝꠞꠣ ꠅꠔ ꠛꠦꠡꠤ ꠇꠞꠤ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠡꠣꠅꠡ-ꠙꠞꠣꠝꠤꠡ ꠖꠦꠅꠀꠔ ꠞꠁ। ");
INSERT INTO syls_vpl VALUES ("HB10_26","088_10_26","HEB","10","26","26","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠢꠇ ꠔꠞꠤꠇꠣ ꠎꠣꠘꠣꠞ ꠛꠣꠖꠦꠅ ꠎꠥꠖꠤ ꠀꠝꠞꠣ ꠎꠣꠘꠤꠀ-ꠢꠥꠘꠤꠀ ꠉꠥꠘꠣ ꠇꠞꠣꠔ ꠞꠁ, ꠔꠦ ꠁ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("HB10_27","088_10_27","HEB","10","27","27","ꠀꠍꠦ ꠈꠣꠟꠤ ꠢꠣꠡꠞꠞ ꠝꠄꠖꠣꠘꠅ ꠇꠑꠤꠘ ꠛꠤꠌꠣꠞꠞ ꠟꠣꠉꠤ ꠒꠞꠣꠁ ꠒꠞꠣꠁ ꠛꠣꠞ ꠌꠣꠅꠀ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠎꠣꠟꠣꠁꠀ ꠍꠣꠟꠤ ꠇꠞꠣꠞ ꠉꠎꠛꠞ ꠒꠞ। ");
INSERT INTO syls_vpl VALUES ("HB10_28","088_10_28","HEB","10","28","28","ꠇꠥꠘꠥ ꠎꠘꠦ ꠝꠥꠍꠣꠞ ꠡꠞꠤꠅꠔꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠟꠦ, ꠄꠞꠦ ꠇꠥꠘꠥ ꠝꠣꠄꠀ-ꠝꠝꠔꠣ ꠘꠣ ꠇꠞꠤꠀ ꠖꠥꠁ ꠛꠣ ꠔꠤꠘꠎꠘꠞ ꠡꠣꠇ꠆ꠇꠤ ꠟꠁꠀ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("HB10_29","088_10_29","HEB","10","29","29","ꠔꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ ꠖꠦꠈꠃꠇ꠆ꠇꠣ, ꠎꠦ ꠎꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞꠦ ꠊꠤꠘ ꠇꠞꠦ, ꠢꠦ ꠀꠞꠅ ꠇꠔ ꠛꠠ ꠀꠎꠣꠛꠞ ꠜꠣꠉꠤ ꠅꠁꠍꠦ! ꠎꠦ ꠟꠃꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠢꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠅꠁꠍꠦ, ꠀꠟ꠆ꠟꠣꠁ ꠢꠃ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠟꠃꠞꠦ ꠢꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠍꠦ, ꠀꠞ ꠎꠦ ꠙꠣꠇ ꠞꠥꠢꠦ ꠞꠢꠝꠔ ꠛꠈꠡꠤꠀ ꠖꠦꠁꠘ, ꠢꠃ ꠞꠥꠢꠥꠞꠦꠅ ꠛꠦꠁꠎ꠆ꠎꠔ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB10_30","088_10_30","HEB","10","30","30","ꠀꠍꠟꠦ ꠀꠝꠞꠣ ꠔ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠤꠃ, ꠎꠦꠁꠘ ꠚꠞꠝꠣꠁꠍꠂꠘ, ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠡꠣꠎꠣ ꠖꠦꠅꠀ ꠀꠝꠣꠞꠃ ꠇꠣꠝ, ꠀꠝꠟ ꠝꠣꠚꠤꠇ ꠛꠖꠟꠣ ꠖꠤꠝꠥ ꠔꠣꠝꠣꠝ ꠁꠘꠍꠣꠘ। ꠀꠞꠇ ꠀꠄꠀꠔꠅ ꠔꠣꠁꠘ ꠇꠁꠍꠂꠘ, ꠝꠣꠛꠥꠖꠦ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("HB10_31","088_10_31","HEB","10","31","31","ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞꠣ ꠖꠦꠅꠀ ꠇꠔ ꠛꠠ ꠝꠍꠤꠛꠔꠞ ꠛꠦꠙꠣꠞ! ");
INSERT INTO syls_vpl VALUES ("HB10_32","088_10_32","HEB","10","32","32","ꠔꠥꠝꠞꠣ ꠢꠃ ꠖꠤꠘꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠅ, ꠎꠦꠛꠟꠣ ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠘꠥꠞꠞ ꠙꠕ ꠙꠣꠁꠀ ꠢꠣꠞꠤ, ꠛꠃꠔ ꠘꠝꠥꠘꠣꠞ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦꠅ ꠝꠎꠛꠥꠔ ꠞꠁꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB10_33","088_10_33","HEB","10","33","33","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠡꠝꠄ ꠡꠝꠣꠎꠞ ꠍꠣꠝꠘꠦ ꠛꠦꠁꠎ꠆ꠎꠔꠤ, ꠎꠥꠟꠥꠝ-ꠐꠤꠐꠇꠣꠞꠤ, ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠢꠥꠘꠤꠀꠅ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠦ ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠍꠟꠣꠄ। ꠀꠞ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠡꠝꠄ ꠅꠁꠘ꠆ꠘꠞ ꠃꠙꠞꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠡ꠆ꠐ ꠀꠁꠍꠦ ꠢꠥꠘꠤꠀ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠅ ꠖꠥꠈꠤꠔ ꠅꠁꠍꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB10_34","088_10_34","HEB","10","34","34","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠎꠦꠞꠣ ꠎꠦꠟ ꠈꠣꠐꠤꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠖꠥꠈꠦ ꠔꠥꠝꠞꠣꠅ ꠖꠥꠈꠤ ꠅꠁꠍꠟꠣꠄ। ꠔꠥꠝꠞꠣꠞ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ ꠟꠥꠐ-ꠙꠣꠐ ꠇꠞꠣ ꠅꠁꠟꠦꠅ ꠈꠥꠡꠤ ꠀꠍꠟꠣꠄ, ꠀꠍꠟꠦ ꠛꠥꠎꠔꠣꠄ ꠙꠣꠞꠍꠟꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠛꠃꠔ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠍꠣꠝꠣꠘꠣ ꠎꠝꠣ ꠀꠍꠦ, ꠎꠦ ꠍꠣꠝꠣꠘꠣ ꠌꠤꠞꠇꠣꠟ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("HB10_35","088_10_35","HEB","10","35","35","ꠔꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠢꠤ ꠝꠘꠅꠛꠟ ꠈꠥꠀꠁꠅ ꠘꠣ, ꠄꠞ ꠝꠣꠎꠦ ꠔ ꠛꠃꠔ ꠖꠣꠝꠤ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB10_36","088_10_36","HEB","10","36","36","ꠔꠥꠝꠞꠣ ꠝꠎꠛꠥꠔ ꠞꠅꠀ ꠖꠞꠇꠣꠞ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠖꠤꠛꠣ ꠇꠞꠤ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠤꠀ ꠔꠥꠝꠞꠣꠅ ꠢꠃ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("HB10_37","088_10_37","HEB","10","37","37","ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠇꠁꠍꠂꠘ, ꠀꠞ ꠕꠥꠠꠣ ꠇꠄꠈꠣꠘ ꠖꠤꠘ ꠛꠣꠇꠤ ꠀꠍꠦ, ꠎꠦꠁꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠕꠣ, ꠔꠣꠁꠘ ꠔꠡꠞꠤꠚ ꠀꠘꠤꠟꠤꠛꠣ, ꠛꠦꠡꠤ ꠖꠦꠞꠤ ꠇꠞꠔꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB10_38","088_10_38","HEB","10","38","38","ꠀꠝꠣꠞ ꠖꠤꠘꠖꠣꠞ ꠛꠘ꠆ꠖꠣꠄ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠀꠈꠦꠞ ꠙꠣꠁꠛ, ꠅꠁꠟꠦ ꠇꠦꠃ ꠈꠞꠦꠖꠤ ꠙꠤꠍꠟꠤ ꠉꠦꠟꠦ ꠔꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠈꠥꠡꠤ ꠞꠁꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB10_39","088_10_39","HEB","10","39","39","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠔ ꠈꠞꠦꠖꠤ ꠙꠤꠍꠟꠤꠀ ꠛꠤꠘꠣꠡ ꠅꠀꠞ ꠝꠣꠘꠥꠡ ꠘꠣꠄ। ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠤꠀ ꠘꠣꠎꠣꠔ ꠢꠣꠍꠤꠟ ꠇꠞꠦ, ꠀꠝꠞꠣ ꠅꠁꠟꠣꠝ ꠢꠃ ꠖꠟꠞ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("HB11_1","088_11_1","HEB","11","1","1","ꠁꠝꠣꠘ ꠇꠤꠔꠣ? ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠙꠣꠁꠝꠥ ꠇꠞꠤ ꠀꠡꠣ ꠇꠞꠍꠤ, ꠁꠔꠣ ꠅꠈꠘ ꠘꠣ ꠙꠣꠁꠟꠦꠅ ꠛꠣꠖꠦ ꠙꠣꠁꠝꠥꠃ ꠙꠣꠁꠝꠥ, ꠅꠃ ꠄꠇꠤꠘꠞ ꠘꠣꠝꠃ ꠁꠝꠣꠘ। ꠅꠃ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠀꠝꠞꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠅꠁꠀ ꠛꠥꠎꠤ, ꠅꠈꠘ ꠎꠦꠔꠣ ꠀꠝꠞꠣꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠞꠣꠝ ꠘꠣ, ꠁꠔꠣ ꠀꠍꠟꠦꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB11_2","088_11_2","HEB","11","2","2","ꠅꠃ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠀꠝꠞꠣꠞ ꠝꠄ-ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠞꠤꠚ ꠇꠣꠝꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_3","088_11_3","HEB","11","3","3","ꠁꠝꠣꠘꠦꠃ ꠀꠝꠞꠣ ꠛꠥꠎꠞꠣꠝ ꠎꠦꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠇꠣꠟꠣꠝꠞ ꠛꠟꠦꠃ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠀꠝꠞꠣꠞ ꠌꠈꠥꠞ ꠖꠦꠈꠣ ꠇꠥꠘꠥ ꠌꠤꠎ ꠕꠣꠇꠤ ꠄꠝꠘꠦ ꠙꠄꠖꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_4","088_11_4","HEB","11","4","4","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠢꠣꠛꠤꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝꠦ ꠇꠣꠛꠤꠟꠞ ꠌꠣꠁꠔꠦ ꠜꠣꠟꠣ ꠇꠥꠞꠛꠣꠘꠤ ꠀꠖꠣꠄ ꠇꠞꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠄ ꠢꠣꠛꠤꠟꠞ ꠛꠦꠙꠣꠞꠦ ꠛꠣꠔꠣꠁꠟꠣ, ꠄꠁꠘ ꠄꠇꠎꠘ ꠇꠣꠝꠤꠟ ꠝꠣꠘꠥꠡ। ꠔꠦ ꠛꠃꠔ ꠎꠝꠣꠘꠣ ꠀꠉꠦ ꠢꠣꠛꠤꠟꠞ ꠝꠃꠔ ꠅꠁꠟꠦꠅ, ꠁꠝꠣꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠅꠈꠘꠅ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠣꠔꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_5","088_11_5","HEB","11","5","5","ꠁꠝꠣꠘꠞ ꠛꠟꠞ ꠟꠣꠉꠤꠃ ꠁꠖ꠆ꠞꠤꠍ ꠘꠛꠤꠞ ꠝꠃꠔ ꠅꠁꠟ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠥꠟꠤꠀ ꠘꠤꠟꠣꠉꠤ, ꠖꠥꠘꠤꠀꠔ ꠔꠣꠘꠞꠦ ꠔꠥꠇꠣꠁꠀ ꠝꠤꠟꠟ ꠘꠣ। ꠁꠖ꠆ꠞꠤꠍꠞꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀꠞ ꠀꠉꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠣꠘꠣꠁꠍꠟꠣ, ꠁꠖ꠆ꠞꠤꠍ ꠀꠝꠣꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠌꠟꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_6","088_11_6","HEB","11","6","6","ꠅꠁꠟꠦ ꠁꠝꠣꠘ ꠍꠣꠠꠣ ꠔ ꠇꠦꠃ ꠀꠟ꠆ꠟꠣꠞꠦ ꠈꠥꠡꠤ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ꠎꠦꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ ꠀꠟ꠆ꠟꠣꠞ ꠗꠣꠞꠅ ꠎꠣꠁꠔꠦ ꠌꠣꠁꠟꠦ, ꠢꠦ ꠄꠇꠤꠘ ꠇꠞꠣ ꠟꠣꠉꠛ ꠎꠦꠘ, ꠀꠟ꠆ꠟꠣ ꠀꠍꠂꠘ, ꠀꠞ ꠎꠦꠞꠣ ꠔꠣꠘ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠦ, ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_7","088_11_7","HEB","11","7","7","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠘꠥꠢ ꠘꠛꠤꠞ ꠎꠝꠣꠘꠣꠔ ꠎꠦꠔꠣ ꠊꠐꠘꠣ ꠖꠦꠈꠣ ꠉꠦꠍꠤꠟ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠡꠤꠀꠞꠤ ꠙꠣꠁꠀ ꠔꠣꠁꠘ ꠅꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠟꠣ, ꠄꠇꠤꠘ ꠇꠞꠤꠀ ꠘꠤꠎꠞ ꠙꠞꠤꠛꠣꠞꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘ ꠎꠣꠎ ꠛꠣꠘꠣꠁꠟꠣ। ꠔꠣꠘ ꠅꠃ ꠁꠝꠣꠘꠤ ꠇꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠎꠉꠔꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠙꠞꠝꠣꠘ ꠖꠦꠈꠣꠁꠟꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠙꠞꠦꠎꠉꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠉꠁꠘ꠆ꠘ ꠅꠁꠉꠦꠟꠣ, ꠈꠣꠟꠤ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠁꠟꠣ ꠅꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB11_8","088_11_8","HEB","11","8","8","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤꠄ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠀꠃ ꠘꠤꠎꠞ ꠜꠤꠐꠣ-ꠝꠣꠐꠤ ꠍꠣꠠꠤꠀ ꠞꠅꠀꠘꠣ ꠖꠤꠟꠣ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠎꠦ ꠖꠦꠡ ꠖꠤꠔꠣ ꠇꠞꠤ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠢꠤ ꠖꠦꠡꠈꠣꠘ ꠇꠥꠘ ꠎꠣꠉꠣꠔ, ꠁꠈꠣꠘ ꠘꠣ ꠎꠣꠘꠤꠀꠅ ꠔꠣꠁꠘ ꠞꠅꠀꠘꠣ ꠅꠁꠉꠦꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_9","088_11_9","HEB","11","9","9","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠔꠣꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠇꠦꠘꠣꠘ ꠖꠦꠡꠞ ꠜꠤꠔꠞꠦꠅ ꠝꠥꠍꠣꠚꠤꠞꠞ ꠟꠣꠈꠣꠘ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠟꠣ। ꠔꠣꠘ ꠟꠉꠦ ꠀꠞꠅ ꠎꠦꠞꠣ ꠢꠤ ꠅꠀꠖꠣꠞ ꠜꠣꠉꠤ ꠀꠍꠟꠣ, ꠢꠃ ꠁꠍꠢꠣꠇ ꠀꠞ ꠁꠀꠇꠥꠛꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠁꠘꠅ ꠔꠣꠝ꠆ꠛꠥꠄ ꠔꠣꠝ꠆ꠛꠥꠄ ꠞꠁꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_10","088_11_10","HEB","11","10","10","ꠀꠍꠟꠦ ꠎꠦ ꠐꠣꠃꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠇꠣꠁꠝ ꠞꠁꠛ, ꠢꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠐꠣꠃꠘꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍꠟꠣ, ꠁ ꠐꠣꠃꠘꠞ ꠘꠇꠡꠣ-ꠘꠝꠥꠘꠣ ꠡꠢ ꠢꠇ꠆ꠇꠟ ꠇꠣꠞꠤꠉꠞꠤ ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("HB11_11","088_11_11","HEB","11","11","11","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠘꠤꠀꠅꠟꠣꠖꠤ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠄ ꠀꠅꠟꠣꠖ ꠎꠘꠝ ꠖꠦꠅꠀꠞ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠟꠣ, ꠔꠣꠞꠣꠞ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠙꠄꠖꠣꠞ ꠛꠄꠅꠡ ꠙꠣꠞ ꠅꠁꠉꠦꠟꠦꠅ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠄꠇꠤꠘ ꠇꠞꠍꠟꠣ, ꠎꠦꠁꠘ ꠁ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠄꠁꠘ ꠔ ꠢꠇ, ꠄꠁꠘ ꠘꠤꠎꠞ ꠅꠀꠖꠣ ꠙꠥꠞꠣꠁꠛꠣꠃ ꠙꠥꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_12","088_11_12","HEB","11","12","12","ꠄꠞꠟꠣꠉꠤ ꠛꠄꠅꠡꠞ ꠜꠣꠞꠦ ꠝꠞꠣꠞ ꠙꠕꠤ ꠅꠃ ꠄꠇ ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠕꠣꠇꠤ ꠅꠔ ꠝꠣꠘꠥꠡ ꠎꠘꠝ ꠟꠁꠟꠣ, ꠎꠦꠞꠣ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣ ꠀꠞ ꠖꠞꠤꠀꠞ ꠌꠞꠞ ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ, ꠉꠘꠤꠀ ꠚꠥꠠꠣꠁꠟ ꠎꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_13","088_11_13","HEB","11","13","13","ꠝꠎꠛꠥꠔ ꠁꠝꠣꠘꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠀ ꠄꠞꠣ ꠢꠇꠟꠞ ꠝꠃꠔ ꠅꠁꠍꠦ, ꠄꠞꠣ ꠇꠦꠃ ꠢꠤ ꠅꠀꠖꠣꠞ ꠚꠟ ꠜꠥꠉ ꠇꠞꠔꠣ ꠙꠣꠞꠍꠂꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠖꠥꠞꠁ ꠕꠣꠇꠤ ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠈꠥꠡꠤ ꠅꠁꠍꠂꠘ। ꠁ ꠖꠥꠘꠤꠀꠔ ꠔꠣꠞꠣ ꠝꠥꠍꠣꠚꠤꠞꠤꠔ ꠀꠁꠍꠂꠘ, ꠁꠈꠣꠘ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠘꠣꠄ, ꠁꠔꠣ ꠔ ꠔꠣꠞꠣ ꠝꠣꠘꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_14","088_11_14","HEB","11","14","14","ꠀꠞ ꠎꠦꠞꠣ ꠁꠈꠣꠘ ꠝꠣꠘꠍꠂꠘ, ꠔꠣꠞꠣ ꠢꠇꠟꠦꠃ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠛꠥꠎꠣꠁꠍꠂꠘ ꠎꠦꠘ, ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠀꠙꠘ ꠖꠦꠡꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_15","088_11_15","HEB","11","15","15","ꠎꠦ ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠟꠣ, ꠢꠤ ꠎꠝꠤꠘꠞ ꠇꠕꠣ ꠈꠤꠀꠟ ꠇꠞꠟꠦ ꠔ ꠔꠣꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠢꠘꠅ ꠢꠣꠝꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠟꠣ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("HB11_16","088_11_16","HEB","11","16","16","ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠔ ꠀꠞꠅ ꠜꠣꠟꠣ ꠄꠇ ꠖꠦꠡ, ꠝꠣꠘꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠍꠟꠣ। ꠄꠞꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠘꠤꠎꠞꠦ ꠔꠣꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠇꠁꠀ ꠙꠞꠤꠌꠄ ꠖꠤꠔꠦ ꠇꠥꠘꠥ ꠡꠞꠝ ꠙꠣꠁꠘ ꠘꠣ, ꠔꠣꠁꠘꠃ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠀ ꠀꠞꠣꠝꠞ ꠄꠇ ꠐꠣꠃꠘ ꠔꠤꠀꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_17","088_11_17","HEB","11","17","17","ꠁꠛ꠆ꠞꠣꠢꠤꠝ ꠘꠛꠤ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠙꠠꠤꠀ ꠢꠣꠞꠤ ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠟꠣ। ꠎꠦ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠎꠘꠦ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠙꠥꠔꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠟꠣꠁꠔꠣ ꠌꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_18","088_11_18","HEB","11","18","18","ꠎꠦ ꠙꠥꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠔꠣꠁꠍꠟꠣ, “ꠔꠥꠝꠣꠞ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞꠦꠃ ꠔꠥꠝꠣꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠇꠁꠀ ꠉꠘꠣ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("HB11_19","088_11_19","HEB","11","19","19","ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠖꠤꠟꠞ ꠅꠃ ꠄꠇꠤꠘꠦ ꠔꠣꠁꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠍꠟꠣ ꠎꠦꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠝꠥꠞ꠆ꠖꠣꠞꠦꠅ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ꠀꠞ ꠢꠣꠍꠣꠃ ꠝꠃꠔꠞ ꠔꠟ ꠕꠣꠇꠤ ꠁꠍꠢꠣꠇꠞꠦ ꠚꠤꠞꠔ ꠙꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_20","088_11_20","HEB","11","20","20","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠁꠍꠢꠣꠇꠦ ꠔꠣꠘ ꠙꠥꠀꠂꠘ ꠁꠀꠇꠥꠛ ꠀꠞ ꠁꠡʼꠞ ꠜꠛꠤꠡꠔ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠖꠤꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_21","088_11_21","HEB","11","21","21","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠁꠀꠇꠥꠛꠦ ꠝꠃꠔꠞ ꠅꠇ꠆ꠔꠅ ꠁꠃꠍꠥꠚꠞ ꠖꠥꠁꠅ ꠙꠥꠀꠞꠦ ꠖꠥꠀ ꠖꠤꠟꠣ, ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠟꠣꠑꠤꠞ ꠃꠙꠞꠦ ꠜꠞꠖꠤ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔꠤ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_22","088_11_22","HEB","11","22","22","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠁꠃꠍꠥꠚꠦ ꠝꠃꠔꠞ ꠅꠇ꠆ꠔꠅ ꠇꠁꠍꠟꠣ, ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠔꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟ ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠛꠣ, ꠔꠣꠞꠣ ꠎꠣꠅꠀꠞ ꠇꠣꠟꠅ ꠔꠣꠘ ꠀꠒ꠆ꠒꠤ-ꠉꠥꠒ꠆ꠒꠤꠞꠦ ꠛꠁꠀ ꠘꠦꠅꠀꠞ ꠢꠥꠇꠥꠝ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_23","088_11_23","HEB","11","23","23","ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠝꠥꠍꠣꠞ ꠝꠣ-ꠛꠣꠚꠦ ꠝꠥꠍꠣꠞ ꠎꠘꠝꠞ ꠛꠣꠖꠦ ꠔꠤꠘ ꠝꠣꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠟꠥꠇꠣꠁꠀ ꠕꠁꠟꠣ, ꠔꠣꠞꠣ ꠖꠦꠈꠍꠟꠣ, ꠙꠥꠀꠉꠥ ꠈꠥꠛ ꠡꠥꠘ꠆ꠖꠞ, ꠛꠣꠖꠡꠣꠞ ꠢꠥꠇꠥꠝꠦꠅ ꠔꠣꠞꠣ ꠒꠞꠣꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_24","088_11_24","HEB","11","24","24","ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠝꠥꠍꠣꠄ, ꠔꠣꠘ ꠛꠥꠎꠖꠣꠞ ꠅꠀꠞ ꠛꠣꠖꠦ ꠚꠦꠞꠣꠃꠘꠞ ꠙꠥꠠꠤꠞ ꠊꠞꠞ ꠘꠣꠔꠤ ꠇꠁꠀ ꠙꠞꠤꠌꠄ ꠖꠤꠔꠦ ꠞꠣꠎꠤ ꠅꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_25","088_11_25","HEB","11","25","25","ꠔꠣꠁꠘ ꠉꠥꠘꠣꠞ ꠝꠣꠎꠦ ꠞꠁꠀ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠡꠥꠈ ꠇꠣꠝꠣꠘꠤꠞ ꠌꠣꠁꠔꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠉꠦ ꠝꠤꠟꠤꠀ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦ ꠞꠅꠀꠃ ꠙꠍꠘ꠆ꠖ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_26","088_11_26","HEB","11","26","26","ꠔꠣꠁꠘ ꠝꠤꠡꠞꠞ ꠢꠇ꠆ꠇꠟ ꠎꠣꠇ-ꠎꠝꠇꠞ ꠌꠣꠁꠔꠦ, ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠖꠥꠞꠘꠣꠝ ꠢꠣꠍꠤꠟꠞꠦꠃ ꠛꠦꠡꠤ ꠝꠥꠟ꠆ꠟꠛꠣꠘ ꠝꠘꠅ ꠇꠞꠟꠣ, ꠇꠣꠞꠘ ꠔꠣꠘ ꠘꠎꠞ ꠀꠍꠤꠟ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞꠞ ꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB11_27","088_11_27","HEB","11","27","27","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠔꠣꠁꠘ ꠝꠤꠡꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠉꠦꠟꠣ, ꠛꠣꠖꠡꠣꠞ ꠉꠥꠍꠣꠞꠦꠅ ꠒꠞꠣꠁꠟꠣ ꠘꠣ। ꠘꠤꠞꠣꠇꠣꠞ ꠀꠟ꠆ꠟꠣꠞꠦ ꠖꠦꠈꠤꠟꠣꠁꠍꠂꠘ, ꠅꠃꠟꠣ ꠝꠘꠅ ꠇꠞꠤꠀꠃ ꠔꠣꠁꠘ ꠍꠛꠞ ꠇꠞꠤ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_28","088_11_28","HEB","11","28","28","ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠔꠣꠁꠘ ꠀꠎꠣꠖꠤ ꠁꠖ ꠀꠞ ꠟꠃ ꠍꠤꠐꠣꠁꠀ ꠖꠦꠅꠀꠞ ꠘꠤꠅꠝ ꠝꠣꠘꠟꠣ, ꠎꠣꠔꠦ ꠀꠎꠞꠣꠁꠟ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠄꠟꠣ ꠙꠥꠀꠂꠘ꠆ꠔꠞꠦ ꠘꠣ ꠍꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_29","088_11_29","HEB","11","29","29","ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠝꠣꠘꠡꠦ ꠘꠤꠟ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠦꠖꠤ ꠢꠥꠇꠘꠣ ꠝꠣꠐꠤꠞ ꠙꠕꠞ ꠟꠣꠈꠣꠘ ꠀꠐꠤꠀ ꠉꠦꠟꠣ, ꠅꠁꠟꠦ ꠝꠤꠡꠞꠤ ꠅꠇꠟꠦ ꠁꠟꠣ ꠎꠣꠅꠀꠔ ꠟꠣꠉꠤꠀ ꠛꠥꠠꠤꠀ ꠝꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_30","088_11_30","HEB","11","30","30","ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠦ ꠎꠤꠞꠤꠢꠅ ꠐꠣꠃꠘꠞ ꠛꠣꠃꠘ꠆ꠒꠞꠤꠞ ꠅꠀꠟ ꠡꠣꠔꠖꠤꠘ ꠌꠇ꠆ꠇꠞ ꠖꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠄꠝꠘꠦꠃ ꠙꠠꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("HB11_31","088_11_31","HEB","11","31","31","ꠁꠝꠣꠘꠞ ꠛꠟꠦꠃ ꠅꠃ ꠐꠣꠃꠘꠞ ꠞꠣꠢꠛꠣ ꠘꠣꠝꠞ ꠛꠖꠝꠣꠁꠡ ꠛꠦꠐꠤꠄ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠉꠥꠁꠀ ꠅꠇꠟꠞꠦ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠣꠄ, ꠢꠤꠘꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠟꠉꠦ ꠁ ꠛꠦꠐꠤ ꠛꠤꠘꠣꠡ ꠅꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_32","088_11_32","HEB","11","32","32","ꠀꠞ ꠇꠔ ꠎꠘꠞ ꠛꠄꠀꠘ ꠇꠁꠔꠣꠝ? ꠎꠤꠖꠣꠃꠘ, ꠛꠣꠞꠣꠇ, ꠡꠤꠝꠡꠥꠘ, ꠁꠚꠔꠣ, ꠖꠣꠃꠖ, ꠡꠣꠝꠥꠄꠟ ꠀꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠁꠝꠣꠘꠤ ꠛꠟꠞ ꠛꠄꠀꠘ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠦ ꠡꠝꠄꠄ ꠇꠥꠟꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB11_33","088_11_33","HEB","11","33","33","ꠁꠝꠣꠘꠞ ꠛꠟꠦ ꠄꠞꠣ ꠛꠃꠔ ꠖꠦꠡ ꠖꠈꠟ ꠇꠞꠍꠂꠘ, ꠢꠇ ꠁꠘꠍꠣꠚ ꠇꠣꠁꠝ ꠇꠞꠍꠂꠘ, ꠀꠟ꠆ꠟꠣꠁ ꠅꠀꠖꠣꠞ ꠚꠣꠄꠖꠣ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠂꠘ, ꠡꠤꠋꠢꠞ ꠝꠥꠈ ꠛꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("HB11_34","088_11_34","HEB","11","34","34","ꠀꠉꠥꠘꠤꠞ ꠇꠥꠘ꠆ꠒꠟꠤꠞ ꠔꠦꠎ ꠇꠝꠣꠁꠟꠤꠍꠂꠘ, ꠔꠟꠥꠀꠞꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠍꠂꠘ, ꠇꠝꠎꠥꠞ ꠕꠣꠇꠤꠅ ꠛꠟ ꠢꠣꠍꠤꠟ ꠇꠞꠍꠂꠘ, ꠎꠤꠢꠣꠖꠞ ꠝꠣꠎꠦ ꠛꠟ-ꠈꠦꠝꠔꠣ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠜꠤꠘ-ꠖꠦꠡꠤ ꠅꠇꠟꠞ ꠚꠃꠎꠞꠦ ꠈꠦꠖꠣꠁꠀ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_35","088_11_35","HEB","11","35","35","ꠛꠦꠐꠤꠘ꠆ꠔꠦ ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ ꠙꠣꠁꠟꠣ। ꠀꠞꠅ ꠛꠃꠔꠦ ꠎꠣꠘꠞ ꠝꠣꠄꠀ ꠍꠣꠠꠤꠀ ꠎꠥꠟꠥꠝ-ꠘꠤꠞ꠆ꠎꠣꠔꠘ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀ ꠝꠞꠟꠣ, ꠎꠣꠔꠦ ꠇꠤꠀꠝꠔꠞ ꠛꠣꠖꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠡꠥꠈ ꠙꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_36","088_11_36","HEB","11","36","36","ꠛꠃꠔꠦ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠀꠞ ꠝꠣꠁꠞ-ꠗꠁꠞ ꠡꠁꠎ꠆ꠎ ꠇꠞꠍꠂꠘ, ꠛꠃꠔꠦ ꠒꠣꠘ꠆ꠒꠣ-ꠛꠦꠠꠤ ꠡꠢ ꠎꠦꠟ ꠈꠣꠐꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_37","088_11_37","HEB","11","37","37","ꠝꠣꠘꠡꠦ ꠔꠣꠞꠣꠞꠦ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠁꠐꠣꠁꠍꠂꠘ, ꠇꠞꠣꠔꠖꠤ ꠌꠤꠞꠤꠀ ꠖꠥꠁ ꠐꠥꠇꠞꠣ ꠇꠞꠍꠂꠘ, ꠔꠟꠥꠀꠞꠖꠤ ꠎꠣꠘꠦ ꠝꠣꠞꠍꠂꠘ। ꠔꠣꠞꠣ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ, ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ ꠙꠣꠁꠍꠂꠘ, ꠅꠜꠣꠛꠞ ꠑꠦꠟꠣꠄ ꠙꠡꠥꠞ ꠌꠣꠝꠠꠣ ꠚꠤꠘ꠆ꠖꠤꠀ ꠡꠞꠝ ꠟꠥꠇꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_38","088_11_38","HEB","11","38","38","ꠁ ꠖꠥꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠎꠥꠇꠣ ꠀꠍꠤꠟ ꠘꠣ, ꠔꠣꠞꠣ ꠙꠣꠠ-ꠎꠋꠉꠟ, ꠝꠞꠥꠜꠥꠝꠤ, ꠀꠞ ꠉꠣꠔ-ꠉꠣꠠꠣꠞ ꠝꠣꠎꠦ ꠞꠁꠀ ꠖꠥꠘꠤꠀꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB11_39","088_11_39","HEB","11","39","39","ꠁꠝꠣꠘꠞ ꠛꠟꠞ ꠟꠣꠉꠤ ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠦ ꠔꠣꠞꠤꠚ ꠇꠣꠝꠣꠁꠍꠂꠘ, ꠔꠣ-ꠅ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣꠞ ꠚꠟ ꠁ ꠖꠥꠘꠤꠀꠔ ꠙꠣꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB11_40","088_11_40","HEB","11","40","40","ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠃ ꠎꠝꠣꠘꠣ ꠕꠣꠇꠤ ꠀꠞꠅ ꠜꠣꠟꠣ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠕꠁꠍꠂꠘ, ꠎꠣꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠛꠣꠖ ꠖꠤꠀ ꠔꠣꠞꠣ ꠇꠣꠝꠤꠟ ꠘꠣ ꠛꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB12_1","088_12_1","HEB","12","1","1","ꠔꠦ ꠀꠝꠞꠣ ꠖꠦꠈꠞꠣꠝ, ꠁꠝꠣꠘꠤ ꠔꠦꠎꠞ ꠛꠃꠔ ꠡꠣꠇ꠆ꠇꠤ ꠀꠝꠞꠣꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠀꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠀꠅ, ꠀꠝꠞꠣꠅ ꠢꠇꠟ ꠎꠣꠄ-ꠎꠣꠝꠦꠟꠣ ꠢꠞꠣꠁ, ꠎꠦ ꠉꠥꠘꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠙꠦꠌꠣꠁꠀ ꠞꠣꠈꠦ, ꠅꠔꠣꠞꠦ ꠢꠞꠣꠁꠀ ꠚꠣꠟꠣꠁ, ꠀꠞ ꠖꠃꠠꠣꠅꠞꠣ ꠖꠟꠞ ꠟꠉꠦ ꠅꠁꠀ ꠗꠂꠎ꠆ꠎ ꠗꠞꠤ ꠢꠦꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠖꠃꠠꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("HB12_2","088_12_2","HEB","12","2","2","ꠀꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣꠞ ꠘꠎꠞ ꠞꠣꠈꠤ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠛꠣꠄ, ꠀꠃꠀꠟ ꠕꠣꠇꠤ ꠀꠈꠦꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠀꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠝꠥꠟ ꠈꠥꠐꠤ। ꠔꠣꠘ ꠟꠣꠉꠤ ꠎꠦ ꠈꠥꠡꠤ ꠞꠣꠈꠣ ꠅꠁꠍꠦ, ꠅꠃ ꠈꠥꠡꠤꠞ ꠛꠣꠄꠖꠤ ꠌꠣꠁꠀ, ꠖꠥꠈ-ꠇꠡ꠆ꠐꠞ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠞ ꠝꠃꠔꠞꠦꠅ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠁ ꠛꠦꠁꠎ꠆ꠎꠔꠤꠞꠦ ꠇꠥꠘꠥ ꠖꠣꠝ ꠖꠤꠟꠣ ꠘꠣ। ꠀꠞ ꠅꠈꠘ ꠀꠞꠡꠦ-ꠀꠎꠤꠝꠅ ꠀꠟ꠆ꠟꠣꠞ ꠒꠣꠁꠘꠞ ꠔꠈ꠆ꠔꠅ ꠔꠣꠁꠘ ꠔꠡꠞꠤꠚ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB12_3","088_12_3","HEB","12","3","3","ꠔꠦ ꠎꠦꠁꠘ ꠉꠥꠘꠣꠉꠣꠞ ꠝꠣꠘꠡꠞ ꠅꠔ ꠛꠠ ꠖꠥꠡꠝꠘꠤꠞꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞꠟꠣ, ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠅ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠇꠥꠘꠥ ꠇꠝꠎꠥꠞꠤ ꠛꠣ ꠘꠤꠞꠣꠡꠣ ꠘꠣ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("HB12_4","088_12_4","HEB","12","4","4","ꠉꠥꠘꠣꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁꠔ ꠟꠣꠉꠤꠀ ꠔ ꠟꠃ ꠛꠣꠞꠘꠤꠞ ꠖꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠅꠈꠘꠅ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB12_5","088_12_5","HEB","12","5","5","ꠔꠥꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ, ꠔꠣꠘ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦ ꠘꠍꠤꠅꠔ ꠇꠞꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠁꠔꠣ ꠚꠣꠃꠞꠤꠟꠤꠍ ꠘꠤ? ꠇꠤꠔꠣꠛꠅ ꠀꠍꠦ, ꠅ ꠀꠝꠣꠞ ꠙꠥꠔ, ꠝꠣꠛꠥꠖꠞ ꠡꠣꠡꠘꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠗꠣꠝꠇꠤ ꠖꠤꠟꠦ, ꠛꠦꠎꠣꠞ ꠅꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB12_6","088_12_6","HEB","12","6","6","ꠇꠣꠞꠘ ꠝꠣꠛꠥꠖꠦ ꠎꠦꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠔꠣꠞꠣꠞꠦꠃ ꠡꠣꠡꠘ ꠇꠞꠂꠘ, ꠎꠦꠞꠣꠞꠦ ꠔꠣꠁꠘ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠤꠟꠣꠁꠘ, ꠄꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠞꠦ ꠡꠣꠎꠣ ꠖꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB12_7","088_12_7","HEB","12","7","7","ꠡꠣꠡꠘ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣ ꠇꠡ꠆ꠐ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠅ। ꠛꠣꠚꠦ-ꠙꠥꠔꠦ ꠎꠦꠟꠣꠈꠣꠘ ꠡꠝ꠆ꠙꠞ꠆ꠇ, ꠀꠟ꠆ꠟꠣꠄꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠅꠃꠟꠣ ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠞꠣꠈꠍꠂꠘ। ꠁꠟꠣ ꠇꠥꠘꠥ ꠙꠥꠔ ꠀꠍꠦ ꠘꠤ, ꠎꠣꠞꠦ ꠔꠣꠞ ꠛꠣꠚꠦ ꠡꠣꠡꠘ ꠇꠞꠂꠘ ꠘꠣ? ");
INSERT INTO syls_vpl VALUES ("HB12_8","088_12_8","HEB","12","8","8","ꠢꠇ꠆ꠇꠟ ꠙꠥꠔꠞꠦꠃ ꠡꠣꠡꠘ ꠇꠞꠣ ꠅꠄ। ꠔꠥꠝꠞꠣꠞꠦ ꠎꠥꠖꠤ ꠡꠣꠡꠘ ꠇꠞꠣ ꠘꠣ ꠅꠄ, ꠔꠦ ꠔ ꠔꠥꠝꠞꠣ ꠚꠥꠋꠉꠣ, ꠀꠍꠟ ꠙꠥꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB12_9","088_12_9","HEB","12","9","9","ꠎꠣꠘ ꠔ, ꠀꠝꠞꠣꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠛꠣꠚ ꠅꠇꠟꠦ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠡꠘ ꠇꠞꠂꠘ, ꠀꠞ ꠀꠝꠞꠣ ꠔꠣꠞꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤ। ꠔꠦ ꠎꠦꠁꠘ ꠀꠝꠞꠣꠞ ꠀꠍꠝꠣꠘꠤ ꠛꠣꠚ, ꠔꠣꠘ ꠉꠦꠍꠦ ꠉꠞ꠆ꠖꠘꠣ ꠘꠥꠀꠁꠀ ꠌꠟꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠞꠥꠞ ꠘꠣꠄ ꠘꠤ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁ? ");
INSERT INTO syls_vpl VALUES ("HB12_10","088_12_10","HEB","12","10","10","ꠀꠝꠞꠣꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠛꠣꠚ ꠅꠇꠟꠦ ꠎꠦꠟꠣ ꠜꠣꠟꠣ ꠝꠘꠅ ꠇꠞꠔꠣ, ꠅꠟꠣ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠡꠘ ꠇꠞꠔꠣ, ꠀꠞ ꠁꠔꠣ ꠔ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘꠞ ꠟꠣꠉꠤ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠀꠝꠞꠣꠞꠦ ꠡꠣꠡꠘ ꠇꠞꠞꠣ ꠎꠣꠔꠦ ꠀꠝꠞꠣꠅ ꠔꠣꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞꠔꠣ ꠢꠣꠍꠤꠟ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("HB12_11","088_12_11","HEB","12","11","11","ꠇꠥꠘꠥ ꠡꠣꠡꠘꠞꠦꠃ ꠈꠥꠡꠤꠞ ꠛꠦꠙꠣꠞ ꠝꠘꠅ ꠇꠞꠣ ꠅꠄ ꠘꠣ, ꠖꠥꠈꠞ ꠛꠦꠙꠣꠞꠃ ꠝꠘꠅ ꠅꠄ, ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠡꠣꠡꠘ ꠝꠣꠘꠤꠀ ꠌꠟꠦ, ꠔꠣꠞꠣ ꠛꠣꠖꠦ ꠖꠤꠘꠖꠣꠞꠤꠞ ꠡꠣꠘ꠆ꠔꠤꠀꠟꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB12_12","088_12_12","HEB","12","12","12","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠝꠎꠥꠞ ꠀꠔꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠅ, ꠖꠥꠞ꠆ꠛꠟ ꠀꠐꠥꠞꠦ ꠡꠛꠟ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("HB12_13","088_12_13","HEB","12","13","13","ꠔꠥꠝꠞꠣ ꠡꠤꠗꠣ ꠙꠕꠦ ꠀꠐꠅ, ꠎꠣꠔꠦ ꠟꠦꠋꠠꠣ ꠙꠣꠅ ꠀꠞ ꠘꠣ ꠇꠌꠇꠦ, ꠛꠞꠋ ꠜꠣꠟꠣ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB12_14","088_12_14","HEB","12","14","14","ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠡꠣꠘ꠆ꠔꠤꠄ ꠛꠡꠔ ꠇꠞꠣ ꠀꠞ ꠙꠣꠇ-ꠙꠣꠇꠤꠎꠣ ꠅꠁꠀ ꠌꠟꠣꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟꠤ ꠅꠅ, ꠁꠟꠣ ꠘꠣ ꠌꠟꠟꠦ ꠇꠦꠃ ꠝꠣꠟꠤꠇꠞ ꠖꠞꠡꠘ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB12_15","088_12_15","HEB","12","15","15","ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠎꠣꠔꠦ ꠇꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠕꠣꠇꠤ ꠛꠣꠖ ꠘꠣ ꠙꠠꠅ। ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠎꠣꠘꠥ ꠛꠤꠡꠣꠇ꠆ꠔ ꠔꠤꠔ꠆ꠔꠣ ꠉꠣꠍꠞ ꠎꠠꠞ ꠟꠣꠈꠣꠘ ꠛꠣꠞ ꠅꠁꠀ ꠘꠣ ꠍꠣꠔꠣꠄ, ꠀꠞ ꠛꠃꠔ ꠝꠣꠘꠡꠞꠦ ꠘꠣꠙꠣꠇ ꠘꠣ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB12_16","088_12_16","HEB","12","16","16","ꠢꠎꠞꠔ ꠁꠀꠇꠥꠛꠞ ꠜꠣꠁ ꠁꠡʼꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥ ꠛꠦ-ꠙꠕꠤ ꠘꠣꠚꠞꠝꠣꠘ ꠙꠄꠖꠣ ꠘꠣ ꠅꠄ। ꠁꠡꠦ ꠔ ꠈꠣꠟꠤ ꠄꠇ ꠅꠇ꠆ꠔꠞ ꠈꠣꠘꠤꠞ ꠟꠣꠉꠤ, ꠔꠣꠞ ꠘꠤꠎꠞ ꠝꠃꠞꠡꠤ ꠝꠣꠟꠤꠇꠣꠘꠣ ꠛꠦꠌꠤꠟꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("HB12_17","088_12_17","HEB","12","17","17","ꠔꠥꠝꠞꠣꠞ ꠔ ꠎꠣꠘꠣꠃ ꠀꠍꠦ, ꠎꠥꠖꠤꠅ ꠛꠣꠖꠦ ꠢꠦ ꠌꠈꠥꠞ ꠙꠣꠘꠤ ꠚꠣꠟꠣꠁꠀ ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ ꠖꠥꠀ ꠝꠣꠋꠉꠤꠍꠤꠟ, ꠅꠁꠟꠦ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠀꠞ ꠢꠦ ꠙꠣꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB12_18","088_12_18","HEB","12","18","18","ꠔꠥꠝꠞꠣ ꠘꠤꠌ꠆ꠌꠄ ꠁꠟꠣ ꠇꠥꠘꠥ ꠙꠣꠠꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠍ ꠘꠣ, ꠎꠦ ꠙꠣꠠꠅ ꠀꠔꠖꠤ ꠍꠅꠀ ꠎꠣꠄ। ꠢꠃ ꠔꠥꠞ ꠙꠣꠠꠞ ꠎꠣꠟꠣꠁꠟ ꠀꠉꠥꠁꠘ, ꠉꠁꠘ ꠀꠘ꠆ꠖꠣꠁꠞ, ꠢꠤꠟ-ꠔꠥꠚꠣꠘ, ");
INSERT INTO syls_vpl VALUES ("HB12_19","088_12_19","HEB","12","19","19","ꠡꠤꠋꠉꠣꠞ ꠀꠅꠀꠎ, ꠛꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠝꠣꠔ-ꠇꠕꠣꠞ ꠇꠥꠘꠥ ꠀꠅꠀꠎꠞ ꠉꠦꠍꠦꠅ ꠀꠁꠍ ꠘꠣ। ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠝꠣꠔꠞ ꠅꠃ ꠀꠅꠀꠎ ꠎꠦꠞꠣ ꠢꠥꠘꠍꠤꠟ, ꠔꠣꠞꠣ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠍꠤꠟ, ꠎꠣꠔꠦ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠀꠞ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠣ ꠘꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("HB12_20","088_12_20","HEB","12","20","20","ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠡꠁꠔ ꠙꠣꠞꠍꠤꠟ ꠘꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠍꠟꠣ, “ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠙꠡꠥꠄꠅ ꠁ ꠙꠣꠠꠅ ꠍꠄ, ꠔꠦ ꠔꠣꠞꠦꠅ ꠙꠣꠔ꠆ꠔꠞ ꠝꠣꠞꠤꠀ ꠝꠣꠞꠤꠟꠤꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("HB12_21","088_12_21","HEB","12","21","21","ꠅꠃ ꠡꠝꠄ ꠎꠦꠞꠣ ꠝꠣꠛꠥꠖꠞ ꠖꠤꠖꠣꠞ ꠖꠦꠈꠍꠤꠟ, ꠔꠣꠞꠣ ꠅꠔ ꠒꠞ ꠒꠞꠣꠁꠍꠤꠟ ꠎꠦꠘ, ꠡ꠆ꠛꠄꠅꠋ ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠇꠁꠟꠣ, “ꠒꠞꠞ ꠌꠥꠐꠦ ꠀꠝꠤ ꠇꠣꠙꠤꠞꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("HB12_22","088_12_22","HEB","12","22","22","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠙꠛꠤꠔ꠆ꠞ ꠍꠤꠅꠘ ꠙꠣꠠ ꠀꠞ ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠐꠣꠃꠘꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠍ, ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠎꠦꠈꠣꠘꠅ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠞ ꠝꠣꠢꠚꠤꠟ ꠇꠞꠞꠣ, ꠢꠘꠅ ꠀꠁꠍ। ꠁ ꠐꠣꠃꠘ ꠅꠁꠟꠉꠤ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ। ");
INSERT INTO syls_vpl VALUES ("HB12_23","088_12_23","HEB","12","23","23","ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠈꠣꠔꠣꠔ ꠎꠦꠞꠣꠞ ꠘꠣꠝ ꠟꠦꠈꠣ ꠅꠁꠉꠦꠍꠦ, ꠛꠠ ꠙꠥꠀꠞ ꠟꠣꠈꠣꠘ ꠎꠦꠞꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠄꠞꠣꠞ ꠛꠣꠘꠣꠁꠟ ꠎꠝꠣꠔꠞ ꠗꠣꠞꠅ ꠀꠁꠍ। ꠎꠦꠁꠘ ꠔꠣꠝꠣꠝ ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠍ। ꠎꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠅꠇꠟ ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠝꠤꠟ ꠅꠁꠉꠦꠍꠂꠘ, ꠄꠞꠣꠞ ꠞꠥꠢꠥꠞ ꠝꠎꠟꠤꠍꠅ ꠀꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("HB12_24","088_12_24","HEB","12","24","24","ꠎꠦ ꠁꠍꠣ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠝꠤꠟꠘꠞ ꠘꠄꠀ ꠃꠍꠤꠟ꠆ꠟꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠖꠣꠞ, ꠢꠃ ꠁꠍꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠍ। ꠢꠣꠛꠤꠟꠞ ꠟꠃ ꠕꠣꠇꠤ ꠀꠞꠅ ꠝꠞꠔꠥꠛꠣꠀꠟꠣ ꠎꠦ ꠟꠃ, ꠔꠥꠝꠞꠣ ꠍꠤꠐꠣꠁꠟ ꠢꠃ ꠟꠃꠞ ꠇꠣꠍꠣꠔ ꠀꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("HB12_25","088_12_25","HEB","12","25","25","ꠝꠥꠍꠣ ꠘꠛꠤꠄ ꠀꠟ꠆ꠟꠣꠁ ꠢꠥꠡꠤꠀꠞꠤꠞ ꠇꠕꠣ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠣꠘꠤꠞ ꠛꠣꠖꠦ ꠎꠦꠞꠣ ꠔꠣꠘ ꠢꠥꠡꠤꠀꠞꠤꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠍꠤꠟ, ꠄꠞꠣ ꠎꠦꠛꠟꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠍꠂꠘ ꠘꠣ, ꠔꠦ ꠎꠦꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠕꠣꠇꠤꠀ ꠀꠝꠞꠣꠞꠦ ꠢꠥꠡꠤꠀꠞ ꠇꠞꠞꠣ, ꠔꠣꠘ ꠢꠥꠡꠤꠀꠞꠤꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠟꠦ ꠔ ꠄꠇ꠆ꠇꠦꠛꠣꠞꠦ ꠘꠤꠌ꠆ꠌꠤꠔꠃ ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠈꠤꠀꠟ ꠞꠣꠈꠤꠅ, ꠎꠦꠁꠘ ꠢꠃ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠢꠥꠇꠥꠝꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB12_26","088_12_26","HEB","12","26","26","ꠢꠤ ꠀꠝꠟꠅ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠥꠈꠞ ꠀꠅꠀꠎꠦ ꠢꠣꠞꠣ ꠖꠥꠘꠤꠀꠞꠦ ꠇꠣꠙꠣꠁꠍꠤꠟ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠔꠣꠁꠘ ꠅꠃ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, “ꠀꠝꠤ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠈꠣꠟꠤ ꠁ ꠖꠥꠘꠤꠀꠞꠦ ꠘꠣꠄ, ꠀꠍꠝꠣꠘꠞꠦꠅ ꠇꠣꠙꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("HB12_27","088_12_27","HEB","12","27","27","ꠔꠦ “ꠖꠥꠍꠞꠣꠛꠣꠞ” ꠅꠃ ꠡꠛ꠆ꠖ ꠕꠣꠇꠤ ꠛꠥꠎꠣ ꠎꠣꠄ ꠎꠦꠘ, ꠎꠦꠔꠣ ꠎꠤꠘꠤꠡ ꠅꠇꠟ ꠟꠣꠠꠣ-ꠌꠣꠠꠣ ꠇꠞꠣꠁꠟ ꠎꠣꠄ, ꠝꠣꠘꠤ ꠎꠦꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠁꠔꠣꠞꠦ ꠛꠣꠖ ꠖꠦꠅꠀ ꠅꠁꠎꠤꠛ, ꠀꠞ ꠎꠦꠔꠣꠞꠦ ꠟꠣꠠꠣ-ꠌꠣꠠꠣ ꠇꠞꠣ ꠎꠣꠄ ꠘꠣ, ꠅꠔꠣ ꠇꠣꠁꠝ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("HB12_28","088_12_28","HEB","12","28","28","ꠛꠥꠎꠞꠣ ꠘꠤ, ꠎꠦ ꠛꠣꠖꠡꠣꠁꠞꠦ ꠟꠣꠠꠣ-ꠌꠣꠠꠣ ꠇꠞꠣ ꠎꠣꠄ ꠘꠣ, ꠀꠝꠞꠣ ꠔ ꠢꠃ ꠛꠣꠖꠡꠣꠁ ꠙꠣꠁꠞꠣꠝ, ꠄꠞꠟꠣꠉꠤ ꠀꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁ। ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠎꠦ ꠘꠝꠥꠘꠣꠄ ꠈꠥꠡꠤ ꠅꠁꠘ, ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠀꠝꠞꠣ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠝꠥ, ꠔꠣꠘꠞꠦ ꠒꠞꠣꠁꠀ, ꠔꠣꠎꠤꠝ ꠇꠞꠤꠀ ꠄꠛꠣꠖꠔ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB12_29","088_12_29","HEB","12","29","29","ꠇꠣꠞꠘ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠔ ꠛꠤꠘꠣꠡ ꠇꠞꠞꠣ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("HB13_1","088_13_1","HEB","13","1","1","ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠀꠙꠘ ꠜꠣꠁꠞ ꠟꠣꠈꠣꠘ ꠢꠣꠝꠦꠡꠣ ꠝꠣꠄꠀ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("HB13_2","088_13_2","HEB","13","2","2","ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠣ ꠚꠣꠃꠞꠤꠅ ꠘꠣ। ꠎꠣꠘ ꠘꠤ, ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠘꠦ ꠘꠣ ꠌꠤꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠅ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB13_3","088_13_3","HEB","13","3","3","ꠎꠦꠟ ꠈꠣꠘꠣꠔ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠛꠘ꠆ꠖꠤ ꠀꠍꠂꠘ, ꠘꠤꠎꠞꠦꠅ ꠅꠟꠣ ꠛꠘ꠆ꠖꠤ ꠝꠘꠅ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠤꠅ, ꠀꠞ ꠎꠦꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠥꠟꠥꠝ-ꠝꠍꠤꠛꠔ ꠇꠞꠣ ꠅꠞ, ꠘꠤꠎꠦ ꠅꠃ ꠝꠍꠤꠛꠔꠅ ꠙꠠꠍ ꠝꠘꠅ ꠇꠞꠤꠀ, ꠔꠣꠞꠣꠞꠦ ꠈꠤꠀꠟ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("HB13_4","088_13_4","HEB","13","4","4","ꠢꠇꠟꠦꠃ ꠛꠤꠀ-ꠡꠣꠖꠤꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠤꠅ। ꠎꠣꠝꠣꠁ-ꠛꠃꠞ ꠡꠝ꠆ꠙꠞ꠆ꠇꠞꠦ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠞꠣꠈꠤꠅ। ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠟ꠆ꠟꠣꠄ ꠇꠥ-ꠘꠎꠞꠤ, ꠎꠤꠘꠣꠇꠥꠞ ꠀꠞ ꠟꠥꠌ꠆ꠌꠣ ꠅꠇꠟꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("HB13_5","088_13_5","HEB","13","5","5","ꠖꠥꠘꠤꠀꠛꠤ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠟꠣꠟꠌ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠞꠁꠅ। ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠀꠍꠦ, ꠅꠔꠣ ꠟꠁꠀꠃ ꠈꠥꠡꠤ ꠞꠁꠅ। ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠀꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠍꠣꠠꠔꠣꠝ ꠘꠣꠄ, ꠇꠥꠘꠥ ꠢꠣꠟꠔꠦꠃ ꠔꠥꠝꠣꠞꠦ ꠚꠣꠟꠣꠁꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB13_6","088_13_6","HEB","13","6","6","ꠄꠞꠟꠣꠉꠤꠃ ꠀꠝꠞꠣ ꠢꠤꠝ꠆ꠝꠔ ꠇꠞꠤꠀ ꠇꠁꠔꠣꠝ ꠙꠣꠞꠤꠀꠞ, ꠝꠣꠛꠥꠖ ꠀꠝꠣꠞ ꠡꠢꠣꠄ ꠀꠍꠂꠘ, ꠀꠝꠤ ꠒꠞꠣꠁꠔꠣꠝ ꠘꠣꠄ। ꠝꠣꠘꠡꠦ ꠀꠝꠣꠞ ꠇꠤꠔꠣ ꠇꠞꠔ? ");
INSERT INTO syls_vpl VALUES ("HB13_7","088_13_7","HEB","13","7","7","ꠢꠥꠘꠅ, ꠎꠦ ꠛꠥꠎꠥꠞ꠆ꠉ ꠅꠇꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠂꠘ, ꠔꠣꠞꠣꠞ ꠇꠕꠣ ꠁꠀꠖ ꠇꠞꠤꠅ। ꠔꠣꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠢꠣꠟꠔꠞ ꠇꠕꠣ ꠜꠣꠟꠣꠝꠘ꠆ꠔꠦ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤꠀ, ꠔꠥꠝꠞꠣꠅ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("HB13_8","088_13_8","HEB","13","8","8","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠉꠔꠇꠣꠁꠟ ꠎꠦꠟꠣ ꠀꠍꠟꠣ, ꠀꠁꠎꠅ ꠅꠟꠣ ꠀꠍꠂꠘ, ꠀꠞ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠃ ꠅꠟꠣ ꠞꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("HB13_9","088_13_9","HEB","13","9","9","ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠘꠄꠀ ꠘꠄꠀ ꠔꠣꠟꠤꠝꠦ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦ-ꠙꠕꠦ ꠘꠣ ꠘꠦꠄ, ꠈꠣꠘꠣ-ꠙꠤꠘꠣꠞ ꠈꠥꠐꠤꠘꠣꠐꠤ ꠛꠤꠡꠄ ꠘꠣ ꠔꠥꠇꠣꠁꠀ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠃꠙꠞꠦ ꠇꠣꠁꠝ ꠞꠅ। ꠁꠟꠣ ꠈꠥꠐꠤꠘꠣꠐꠤ ꠘꠤꠅꠝꠞ ꠃꠙꠞꠦ ꠎꠦꠞꠣ ꠜꠞꠡꠣ ꠇꠞꠔ, ꠁꠔꠣꠄ ꠔ ꠔꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠟꠣꠜ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("HB13_10","088_13_10","HEB","13","10","10","ꠀꠝꠞꠣꠞ ꠔ ꠄꠇꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠀꠍꠦ, ꠁꠈꠣꠘꠞ ꠇꠥꠘ꠆ꠔꠣ ꠈꠣꠁꠛꠣꠞ ꠄꠈꠔꠤꠀꠞ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠄꠛꠣꠖꠔ-ꠔꠣꠝ꠆ꠛꠥꠞ ꠁꠝꠣꠝ ꠅꠇꠟꠞ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("HB13_11","088_13_11","HEB","13","11","11","ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠎꠛ ꠇꠞꠣ ꠙꠡꠥꠞ ꠟꠃ ꠟꠁꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠙꠞꠗꠣꠘ ꠁꠝꠣꠝ ꠅꠇꠟ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠢꠦꠞꠦꠝ ꠡꠞꠤꠚꠅ ꠢꠣꠝꠣꠁꠘ, ꠅꠁꠟꠦ ꠅꠃ ꠙꠡꠥꠞ ꠀꠒ꠆ꠒꠤ-ꠝꠣꠋꠡ ꠢꠇꠟꠔꠣ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠘꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("HB13_12","088_13_12","HEB","13","12","12","ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠎꠞꠔ ꠁꠍꠣꠅ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠉꠤꠀ ꠎꠥꠟꠥꠝ-ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀ ꠝꠃꠔ ꠇꠛꠥꠟ ꠇꠞꠟꠣ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠟꠃꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠝꠣꠘꠡꠞꠦ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB13_13","088_13_13","HEB","13","13","13","ꠅꠈꠘ ꠀꠃꠇ꠆ꠇꠣ, ꠀꠝꠞꠣꠅ ꠔꠣꠘ ꠛꠖꠘꠣꠝꠞꠦ ꠘꠤꠎꠞ ꠇꠣꠘ꠆ꠖꠅ ꠟꠁꠀ ꠇꠦꠝ꠆ꠙꠞ ꠛꠣꠞꠦ ꠔꠣꠘ ꠇꠣꠘ꠆ꠖꠣꠔ ꠎꠣꠁꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("HB13_14","088_13_14","HEB","13","14","14","ꠇꠣꠞꠘ ꠁ ꠖꠥꠘꠤꠀꠔ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠡ꠆ꠕꠣꠄꠁ ꠇꠥꠘꠥ ꠐꠣꠃꠘ ꠘꠣꠁ, ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠢꠃ ꠐꠣꠃꠘꠞ ꠔꠣꠟ꠆ꠟꠣꠡ ꠇꠞꠞꠣꠝ, ꠎꠦ ꠐꠣꠃꠘꠞ ꠖꠤꠖꠣꠞ ꠛꠣꠖꠦ ꠙꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB13_15","088_13_15","HEB","13","15","15","ꠔꠦ ꠅꠈꠘ ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠞꠤꠀꠄ ꠢꠣꠝꠦꠡꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠎꠤꠇꠤꠞ-ꠀꠎꠇꠣꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠇꠞꠤ, ꠝꠣꠘꠤ ꠖꠥꠁꠅ ꠑꠥꠐꠦ ꠔꠣꠘ ꠘꠣꠝꠞ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("HB13_16","088_13_16","HEB","13","16","16","ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠣ ꠀꠞ ꠅꠜꠣꠛꠤ ꠝꠣꠘꠡꠞꠦ ꠖꠣꠘ-ꠈꠄꠞꠣꠔ ꠛꠤꠟꠣꠘꠤ ꠚꠣꠃꠞꠤꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠄ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠈꠥꠡꠤ ꠅꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("HB13_17","088_13_17","HEB","13","17","17","ꠔꠥꠝꠞꠣꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠕꠣ ꠘꠥꠀꠁꠀ ꠞꠁꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠢꠤꠡꠣꠛ ꠖꠦꠅꠀ ꠟꠣꠉꠛ ꠇꠞꠤ ꠔꠣꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠞ ꠙꠣꠞꠣꠖꠣꠞ ꠅꠁꠀ ꠇꠣꠝ ꠇꠞꠞꠣ। ꠅꠈꠘ ꠔꠣꠞꠣ ꠎꠣꠔꠦ ꠈꠥꠡꠤ ꠝꠘꠦ ꠁꠔꠣ ꠇꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠅ। ꠔꠣꠞꠣ ꠎꠥꠖꠤ ꠝꠘꠅ ꠖꠥꠈ ꠙꠣꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("HB13_18","088_13_18","HEB","13","18","18","ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠤꠅ। ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠀꠝꠞꠣꠞ ꠛꠤꠛꠦꠇ ꠍꠣꠚ-ꠍꠚꠣ ꠀꠍꠦ, ꠢꠇ꠆ꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠢꠇ ꠙꠕꠦ ꠌꠟꠔꠣꠝ ꠌꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("HB13_19","088_13_19","HEB","13","19","19","ꠀꠝꠤ ꠈꠣꠍ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠖꠥꠀ ꠌꠣꠁꠞꠣꠝ, ꠎꠣꠔꠦ ꠎꠟꠖꠤ ꠇꠞꠤ ꠀꠝꠤ ꠢꠤꠞꠛꠣꠞ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠥꠟꠣꠇꠣꠔ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("HB13_20","088_13_20","HEB","13","20","20","ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠝꠤꠟꠘ, ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠃꠍꠤꠟ꠆ꠟꠣ, ꠙꠥꠞꠣꠙꠥꠞ ꠇꠣꠁꠝ ꠇꠞꠣꠞ ꠟꠣꠉꠤꠀ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠢꠎꠞꠔ ꠁꠍꠣ, ꠘꠤꠎꠞ ꠟꠃ ꠛꠤꠟꠣꠁ ꠖꠤꠀ, ꠝꠦꠠꠣ ꠙꠣꠟꠞ ꠝꠢꠣꠘ ꠞꠣꠈꠣꠟ ꠛꠘꠤꠍꠂꠘ। ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦ, ꠡꠣꠘ꠆ꠔꠤ ꠖꠦꠃꠞꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ, ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠔꠣꠘꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("HB13_21","088_13_21","HEB","13","21","21","ꠢꠇꠟ ꠘꠦꠇ ꠇꠣꠝꠞ ꠔꠚꠤꠇ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁꠀ ꠌꠟꠣꠞ, ꠀꠞ ꠔꠣꠁꠘ ꠎꠦꠔꠣ ꠙꠍꠘ꠆ꠖ ꠇꠞꠂꠘ, ꠖꠤꠟꠅ ꠅꠔꠣꠞ ꠄꠡꠇꠤ ꠖꠦꠃꠇ꠆ꠇꠣ, ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠞꠤꠀꠄ, ꠄꠘ ꠝꠢꠤꠝꠣ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠞꠃꠇ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("HB13_22","088_13_22","HEB","13","22","22","ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠝꠤꠘꠔ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠛꠤꠞꠇ꠆ꠔ ꠘꠣ ꠅꠁꠀ ꠁ ꠘꠍꠤꠅꠔ ꠢꠥꠘꠅ, ꠀꠝꠤ ꠈꠥꠛ ꠡꠐꠇꠣꠐꠦ ꠟꠦꠈꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("HB13_23","088_13_23","HEB","13","23","23","ꠢꠥꠘꠅ, ꠀꠝꠞꠣꠞ ꠜꠣꠁ ꠔꠤꠝꠕꠤꠄ ꠈꠣꠟꠣꠍ ꠙꠣꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠎꠥꠖꠤ ꠡꠝꠄ ꠝꠔ ꠀꠝꠣꠞ ꠅꠘꠅ ꠀꠁꠘ, ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠅꠀꠞ ꠡꠝꠄ ꠔꠣꠘꠦ ꠟꠉꠦ ꠟꠁꠀ ꠀꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("HB13_24","088_13_24","HEB","13","24","24","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ, ꠀꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠀꠝꠣꠞ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ꠁꠔꠣꠟꠤ ꠖꠦꠡꠞ ꠝꠣꠘꠡꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("HB13_25","088_13_25","HEB","13","25","25","ꠔꠥꠝꠞꠣ ꠢꠇꠟꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠇꠣꠁꠝ ꠞꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("JM1_1","089_1_1","JAS","1","1","1","ꠀꠝꠤ ꠁꠀꠇꠥꠛ, ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠥꠟꠣꠝ, ꠖꠥꠘꠤꠀꠞ ꠘꠣꠘꠣꠘ ꠖꠦꠡꠅ ꠍꠤꠔ꠆ꠞꠣꠁꠟ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠉꠥꠡ꠆ꠐꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JM1_2","089_1_2","JAS","1","2","2","ꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠞ ꠙꠞꠤꠇ꠆ꠇꠣꠞ ꠝꠣꠎꠦ ꠙꠠꠅ, ꠁ ꠡꠝꠄ ꠁꠔꠣ ꠈꠥꠛ ꠈꠥꠡꠤꠞ ꠛꠦꠙꠣꠞ ꠝꠘꠅ ꠇꠞꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("JM1_3","089_1_3","JAS","1","3","3","ꠎꠣꠘ ꠔ, ꠁꠝꠣꠘꠞ ꠙꠞꠤꠇ꠆ꠇꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠕꠤꠞ ꠕꠣꠇꠣꠞ ꠈꠦꠝꠔꠣ ꠛꠣꠠꠣꠁ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("JM1_4","089_1_4","JAS","1","4","4","ꠀꠞ ꠁ ꠕꠤꠞ ꠕꠣꠇꠣꠞ ꠈꠦꠝꠔꠣꠞꠦ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠅ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠇꠣꠝꠤꠟ ꠀꠞ ꠈꠣꠐꠤ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠇꠝꠔꠤ ꠘꠣ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("JM1_5","089_1_5","JAS","1","5","5","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃꠞꠞ ꠎꠥꠖꠤ ꠀꠈꠟꠞ ꠇꠝꠔꠤ ꠕꠣꠇꠦ, ꠔꠦ ꠢꠦ ꠎꠣꠘꠥ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠌꠣꠄ, ꠔꠦꠃ ꠙꠣꠁꠛ। ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠛꠦꠎꠣꠞꠤ ꠜꠣꠛ ꠘꠣ ꠀꠘꠤꠀ ꠢꠇ꠆ꠇꠟꠞꠦꠃ ꠛꠦꠢꠤꠡꠣꠛ ꠖꠣꠘ ꠇꠞꠂꠘ, ꠈꠣꠟꠤ ꠀꠔꠦ ꠚꠤꠞꠣꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM1_6","089_1_6","JAS","1","6","6","ꠅꠁꠟꠦ ꠢꠦ ꠝꠘꠅ ꠇꠥꠘꠥ ꠡꠘ꠆ꠖꠄ ꠘꠣ ꠞꠣꠈꠤꠀ ꠄꠇꠤꠘ ꠇꠞꠤꠀ ꠌꠣꠁꠔꠦ ꠅꠁꠛ। ꠎꠦ ꠡꠘ꠆ꠖꠄ ꠇꠞꠦ ꠢꠦ ꠔ ꠖꠞꠤꠀꠞ ꠓꠦꠃꠞ ꠟꠣꠈꠣꠘ, ꠔꠣꠞꠦ ꠀꠃꠟꠣ-ꠎꠣꠃꠟꠣ ꠛꠣꠔꠣꠡꠦ ꠃꠠꠣꠁꠀ ꠟꠁꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM1_7","089_1_7","JAS","1","7","7","ꠁꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠦ ꠎꠣꠘꠥ ꠝꠣꠛꠥꠖꠞ ꠉꠦꠍ ꠕꠘꠦ ꠇꠥꠘ꠆ꠔꠣ ꠙꠣꠅꠀꠞ ꠀꠡꠣ ꠘꠣ ꠇꠞꠦ, ");
INSERT INTO syls_vpl VALUES ("JM1_8","089_1_8","JAS","1","8","8","ꠢꠦ ꠔ ꠖꠥ-ꠖꠤꠟꠣ ꠝꠣꠘꠥꠡ, ꠔꠣꠞ ꠢꠇꠟ ꠇꠣꠝꠅꠃ ꠅꠡꠣꠘ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("JM1_9","089_1_9","JAS","1","9","9","ꠎꠦ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠉꠞꠤꠛ, ꠔꠣꠞꠦ ꠛꠠ ꠛꠣꠘꠣꠁꠍꠂꠘ ꠇꠞꠤꠀ ꠢꠦ ꠘꠤꠎꠞꠦ ꠝꠥꠛꠣꠞꠇ ꠝꠘꠅ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("JM1_10","089_1_10","JAS","1","10","10","ꠀꠞ ꠎꠦ ꠗꠘꠤ, ꠔꠣꠞꠦ ꠢꠥꠞꠥ ꠛꠣꠘꠣꠁꠍꠂꠘ ꠇꠞꠤꠀ ꠢꠦ-ꠅ ꠘꠤꠎꠞꠦ ꠝꠥꠛꠣꠞꠇ ꠝꠘꠅ ꠇꠞꠃꠇ, ꠇꠣꠞꠘ ꠢꠦ ꠊꠣꠡ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠏꠞꠤꠀ ꠙꠠꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("JM1_11","089_1_11","JAS","1","11","11","ꠡꠥꠞꠥꠎ ꠎꠦꠛꠟꠣ ꠃꠑꠦ, ꠁ ꠡꠝꠄ ꠔꠣꠞ ꠔꠦꠎꠦ ꠊꠣꠡ ꠢꠥꠇꠣꠁ ꠎꠣꠄ, ꠚꠥꠟ ꠏꠞꠤꠀ ꠙꠠꠤꠎꠣꠄ, ꠀꠞ ꠔꠣꠞ ꠡꠥꠘ꠆ꠖꠞ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ। ꠗꠘꠤ ꠝꠣꠘꠥꠡꠅ ꠅꠟꠣꠈꠣꠘ ꠔꠣꠞ ꠛꠦꠡ꠆ꠔꠔꠣꠞ ꠝꠣꠎꠦ ꠏꠞꠤꠀ ꠙꠠꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("JM1_12","089_1_12","JAS","1","12","12","ꠝꠥꠛꠣꠞꠇ ꠢꠃ ꠎꠘ, ꠎꠦ ꠎꠘ ꠙꠞꠤꠇ꠆ꠇꠣꠞ ꠡꠝꠄ ꠝꠎꠛꠥꠔ ꠞꠄ। ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠇꠣꠝꠤꠀꠛ ꠅꠁꠟꠦ ꠎꠄꠅꠞ ꠝꠣꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠢꠦ ꠀꠈꠦꠞ ꠙꠣꠁꠛ। ꠅꠃ ꠝꠣꠟꠣ ꠔꠣꠘ ꠀꠡꠤꠇ ꠅꠇꠟꠞꠦ ꠖꠤꠛꠣ ꠇꠞꠤ ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JM1_13","089_1_13","JAS","1","13","13","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠉꠥꠘꠣꠞ ꠛꠣꠄ ꠄꠡꠇꠤ ꠅꠁꠀ ꠎꠣꠘꠥ ꠘꠣ ꠇꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠀꠝꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠐꠣꠘꠤꠞꠣ। ꠇꠥꠘꠥ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠙꠕꠦꠃ ꠀꠟ꠆ꠟꠣꠞꠦ ꠐꠣꠘꠣ ꠎꠣꠄ ꠘꠣ, ꠔꠣꠁꠘꠅ ꠇꠦꠃꠞꠞꠦ ꠁ ꠙꠕꠦ ꠘꠦꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM1_14","089_1_14","JAS","1","14","14","ꠅꠁꠟꠦ ꠝꠣꠘꠡꠞ ꠘꠤꠎꠞ ꠖꠤꠟꠦꠃ ꠐꠣꠘꠤꠀ ꠘꠤꠀ ꠔꠣꠞꠦ ꠚꠣꠘ꠆ꠖꠅ ꠚꠣꠟꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM1_15","089_1_15","JAS","1","15","15","ꠛꠣꠖꠦ ꠖꠤꠟꠞ ꠛꠖ ꠘꠤꠅꠔ ꠙꠥꠞꠣ ꠅꠁꠟꠦ ꠉꠥꠘꠣꠞ ꠛꠤꠌ ꠙꠦꠐꠅ ꠟꠄ, ꠀꠞ ꠉꠥꠘꠣ ꠛꠠ ꠅꠁꠀ ꠝꠃꠔꠞ ꠎꠘꠝ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("JM1_16","089_1_16","JAS","1","16","16","ꠅ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠅꠃ ꠟꠣꠈꠣꠘ ꠜꠥꠟ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM1_17","089_1_17","JAS","1","17","17","ꠢꠇ꠆ꠇꠟ ꠜꠣꠟꠣ ꠀꠞ ꠘꠤꠈꠥꠔ ꠖꠣꠘ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠘꠦ ꠟꠣꠝꠤꠀ ꠀꠄ, ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘꠤ ꠘꠥꠞ ꠅꠇꠟ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠀꠄ। ꠅꠃ ꠘꠥꠞ ꠅꠇꠟ ꠍꠦꠛꠣꠞ ꠟꠣꠈꠣꠘ ꠒꠥꠟꠣꠒꠥꠟꠤ ꠇꠞꠟꠦꠅ, ꠔꠣꠁꠘ ꠁꠟꠣ ꠇꠞꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM1_18","089_1_18","JAS","1","18","18","ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠀꠝꠞꠣꠞꠦ ꠢꠇ ꠇꠣꠟꠣꠝ ꠖꠤꠀ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠍꠂꠘ, ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠀꠡꠞꠣꠚꠥꠟ ꠝꠈꠟꠥꠇꠣꠔ, ꠡ꠆ꠞꠤꠡ꠆ꠐꠤꠞ ꠡꠦꠞꠣ ꠝꠣꠘꠥꠡ ꠅꠁ। ");
INSERT INTO syls_vpl VALUES ("JM1_19","089_1_19","JAS","1","19","19","ꠅ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠢꠥꠘꠅ ꠛꠣꠖꠦ ꠝꠣꠔꠅ, ꠎꠟꠖꠤ ꠉꠥꠍꠣ ꠇꠞꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM1_20","089_1_20","JAS","1","20","20","ꠝꠣꠘꠡꠦ ꠉꠥꠍꠣ ꠇꠞꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠇꠥꠘꠥ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM1_21","089_1_21","JAS","1","21","21","ꠉꠔꠤꠇꠦ ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠎꠣꠔꠞ ꠢꠣꠞꠣꠝ ꠀꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠣꠝ ꠛꠣꠖ ꠖꠤꠟꠣꠅ। ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠎꠦ ꠇꠣꠟꠣꠝ ꠞꠥꠀ ꠅꠁꠍꠦ, ꠘꠞꠝ ꠖꠤꠟꠦ ꠅꠃ ꠇꠣꠟꠣꠝ ꠇꠛꠥꠟ ꠇꠞꠅ। ꠔꠥꠝꠞꠣꠞꠦ ꠔꠞꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠁ ꠇꠣꠟꠣꠝꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JM1_22","089_1_22","JAS","1","22","22","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠈꠣꠟꠤ ꠢꠥꠘꠟꠦꠃ ꠅꠁꠔ ꠘꠣꠄ, ꠅꠟꠣꠈꠣꠘ ꠀꠝꠟꠅ ꠇꠞꠅ। ꠇꠣꠟꠣꠝ ꠢꠥꠘꠤꠀ ꠎꠥꠖꠤ ꠀꠝꠟ ꠘꠣ ꠇꠞ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞꠦ ꠐꠉꠤꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM1_23","089_1_23","JAS","1","23","23","ꠇꠦꠃ ꠎꠥꠖꠤ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠤꠀ ꠀꠝꠟ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠅꠃ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ, ꠎꠦ ꠀꠄꠘꠣꠔ ꠘꠤꠎꠞ ꠌꠦꠞꠣ ꠖꠦꠈꠤꠀ ꠎꠣꠄꠉꠤ, ");
INSERT INTO syls_vpl VALUES ("JM1_24","089_1_24","JAS","1","24","24","ꠛꠣꠖꠦ ꠢꠞꠤꠀ ꠉꠤꠀ ꠚꠣꠃꠞꠤꠟꠣꠄ ꠔꠣꠞ ꠌꠦꠞꠣ ꠇꠤꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("JM1_25","089_1_25","JAS","1","25","25","ꠅꠁꠟꠦ ꠎꠦ ꠈꠣꠐꠤ ꠀꠁꠘ ꠝꠣꠘꠡꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠦ, ꠀꠞ ꠅꠃ ꠀꠁꠘꠞ ꠛꠣꠄ ꠘꠎꠞ ꠞꠣꠈꠤꠀ ꠎꠦꠞꠣ ꠢꠣꠝꠦꠡꠣ ꠎꠤꠀꠁꠟ ꠞꠄ, ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠣꠞꠤ ꠚꠣꠃꠞꠦ ꠘꠣ, ꠀꠝꠟ ꠇꠞꠦ, ꠔꠣꠞꠣ ꠢꠇꠟ ꠇꠣꠝꠅ ꠝꠥꠛꠣꠞꠇ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JM1_26","089_1_26","JAS","1","26","26","ꠎꠦ ꠝꠣꠘꠡꠦ ꠘꠤꠎꠞꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠘꠅ ꠇꠞꠦ, ꠅꠁꠟꠦ ꠘꠤꠎꠞ ꠎꠤꠚꠞꠣꠞꠦ ꠡꠣꠝꠟꠣꠄ ꠘꠣ, ꠢꠦ ꠔ ꠔꠣꠞ ꠘꠤꠎꠞꠦ ꠐꠉꠦ, ꠔꠣꠞ ꠢꠇ꠆ꠇꠟ ꠄꠛꠣꠖꠔꠤꠃ ꠝꠤꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("JM1_27","089_1_27","JAS","1","27","27","ꠄꠔꠤꠝ ꠅꠇꠟꠞꠦ ꠀꠞ ꠠꠣꠠꠤ ꠛꠦꠐꠤꠘ꠆ꠔꠞꠦ ꠛꠤꠙꠖꠞ ꠡꠝꠄ ꠡꠣꠄ-ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣ, ꠄꠞꠟꠉꠦ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠕꠣꠇꠤ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠞꠣꠈꠣꠃ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠈꠣꠐꠤ ꠀꠞ ꠍꠢꠤ ꠄꠛꠣꠖꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("JM2_1","089_2_1","JAS","2","1","1","ꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠝꠣꠟꠤꠇ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍ, ꠔꠦ ꠢꠇꠟꠞꠦ ꠄꠇ ꠘꠎꠞꠦ ꠖꠦꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("JM2_2","089_2_2","JAS","2","2","2","ꠗꠞꠅ, ꠄꠇꠎꠘ ꠝꠣꠘꠥꠡ ꠔꠥꠝꠞꠣꠞ ꠝꠎꠟꠤꠍ ꠈꠣꠘꠣꠔ ꠡꠥꠘ꠆ꠖꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠀꠔꠅ ꠡꠥꠘꠣꠞ ꠀꠋꠐꠤ ꠟꠣꠉꠣꠁꠀ ꠀꠁꠟ, ꠀꠞ ꠝꠄꠟꠣ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠄꠇꠎꠘ ꠉꠞꠤꠛ ꠝꠣꠘꠥꠡꠅ ꠀꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JM2_3","089_2_3","JAS","2","3","3","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠡꠥꠘ꠆ꠖꠞ ꠇꠣꠙꠠ ꠀꠟꠣ ꠝꠣꠘꠡꠞ ꠝꠥꠈꠦꠖꠤ ꠌꠣꠁꠀ ꠇꠅ, “ꠀꠙꠘꠦ ꠅꠃ ꠜꠣꠟꠣ ꠎꠣꠉꠣꠈꠣꠘꠅ ꠛꠃꠇ꠆ꠇꠣ,” ꠀꠞ ꠉꠞꠤꠛ ꠛꠦꠐꠣꠞꠦ ꠇꠅ, “ꠅꠛꠣ, ꠔꠥꠁ ꠢꠘꠅ ꠃꠛꠣ, ꠀꠞꠘꠣꠄ ꠀꠝꠣꠞ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠛꠅ,” ");
INSERT INTO syls_vpl VALUES ("JM2_4","089_2_4","JAS","2","4","4","ꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠎꠦ ꠢꠣꠞ-ꠙꠞ ꠇꠞꠞꠣꠄ ꠘꠣ ꠘꠤ, ꠀꠞ ꠡꠄꠔꠣꠘꠤ ꠘꠤꠅꠔꠦ ꠛꠤꠌꠣꠞ ꠇꠞꠞꠣꠄ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JM2_5","089_2_5","JAS","2","5","5","ꠅ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠢꠥꠘꠅ। ꠁ ꠖꠥꠘꠤꠀꠞ ꠉꠞꠤꠛ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ ꠘꠣ ꠘꠤ ꠁꠝꠣꠘꠦ ꠗꠘꠤ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ? ꠀꠟ꠆ꠟꠣꠞ ꠀꠡꠤꠇ ꠝꠣꠘꠡꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠎꠦ ꠛꠣꠖꠡꠣꠁ ꠖꠦꠅꠀꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠟꠣ, ꠁ ꠛꠣꠖꠡꠣꠁꠞ ꠝꠣꠟꠤꠇ ꠅꠀꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JM2_6","089_2_6","JAS","2","6","6","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠁ ꠉꠞꠤꠛ ꠅꠇꠟꠞꠦ ꠄꠟꠣꠝꠤ ꠇꠞꠍ। ꠗꠘꠤ ꠅꠇꠟꠦ ꠇꠤꠔꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠥꠟꠥꠝ ꠇꠞꠦ ꠘꠣ ꠘꠤ? ꠔꠣꠞꠣꠃ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠐꠣꠘꠤꠀ-ꠍꠦꠌꠠꠣꠁꠀ ꠛꠤꠌꠣꠞꠅ ꠟꠁꠀ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM2_7","089_2_7","JAS","2","7","7","ꠎꠦ ꠝꠢꠣꠘ ꠘꠣꠝꠞ ꠈꠣꠔꠤꠞꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠒꠣꠇꠣ ꠅꠄ, ꠔꠣꠞꠣ ꠇꠤꠔꠣ ꠁ ꠘꠣꠝꠞꠦ ꠟꠁꠀ ꠇꠥꠚꠥꠞꠤ ꠇꠞꠦꠞ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JM2_8","089_2_8","JAS","2","8","8","ꠙꠣꠇ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠔꠥꠝꠣꠞ ꠀꠞꠤ-ꠚꠞꠤꠞꠦ ꠘꠤꠎꠞ ꠟꠣꠈꠣꠘ ꠝꠣꠄꠀ ꠇꠞꠤꠅ,” ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠢꠣꠍꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠖꠡꠣꠁꠞ ꠅꠃ ꠢꠥꠇꠥꠝ ꠀꠝꠟ ꠇꠞ, ꠔꠦ ꠔ ꠜꠣꠟꠣꠃ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM2_9","089_2_9","JAS","2","9","9","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠢꠇꠟꠞꠦ ꠄꠇ ꠘꠎꠞꠦ ꠘꠣ ꠖꠦꠈ, ꠔꠦ ꠔ ꠉꠥꠘꠣ ꠇꠞꠞꠣꠄ, ꠀꠞ ꠡꠞꠤꠅꠔꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠤꠀ ꠖꠥꠡꠤ ꠅꠁꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM2_10","089_2_10","JAS","2","10","10","ꠇꠦꠃ ꠎꠥꠖꠤ ꠡꠞꠤꠅꠔꠞ ꠢꠇ꠆ꠇꠟ ꠢꠥꠇꠥꠝ ꠀꠝꠟ ꠇꠞꠤꠀꠅ ꠈꠣꠟꠤ ꠄꠇ ꠢꠥꠇꠥꠝ ꠜꠣꠋꠉꠦ, ꠔꠦ ꠗꠞꠣ ꠅꠁꠛ ꠢꠦ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠅꠔꠃ ꠅꠝꠣꠁꠘ꠆ꠘ ꠇꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JM2_11","089_2_11","JAS","2","11","11","ꠇꠣꠞꠘ ꠎꠦꠁꠘ ꠇꠁꠍꠂꠘ, “ꠎꠤꠘꠣ ꠇꠞꠤꠅ ꠘꠣ,” ꠔꠣꠁꠘꠃ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠍꠂꠘ, “ꠈꠥꠘ ꠇꠞꠤꠅ ꠘꠣ।” ꠔꠦ ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠎꠤꠘꠣ ꠘꠣ ꠇꠞꠤꠀ ꠈꠥꠘ ꠇꠞ, ꠔꠦꠛꠃ ꠔ ꠡꠞꠤꠅꠔꠞ ꠛꠞꠈꠦꠟꠣꠚ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("JM2_12","089_2_12","JAS","2","12","12","ꠎꠦ ꠀꠁꠘꠦ ꠝꠣꠘꠡꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠦ, ꠅꠃ ꠀꠁꠘ ꠖꠤꠀꠃ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠌꠣꠞ ꠅꠁꠛ। ꠉꠔꠤꠇꠦ ꠛꠥꠎꠤ-ꠢꠥꠘꠤ ꠝꠣꠔ ꠝꠣꠔꠅ ꠀꠞ ꠇꠣꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JM2_13","089_2_13","JAS","2","13","13","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠖꠄꠀ ꠇꠞꠍꠦ ꠘꠣ, ꠛꠤꠌꠣꠞꠞ ꠡꠝꠄ ꠔꠣꠞꠦꠅ ꠖꠄꠀ ꠇꠞꠣ ꠅꠁꠔ ꠘꠣꠄ। ꠢꠣꠡꠞꠞ ꠝꠄꠖꠣꠘꠅ ꠖꠄꠀꠉꠤꠞ ꠅꠇꠟꠦꠃ ꠖꠄꠀ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JM2_14","089_2_14","JAS","2","14","14","ꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠄ ꠀꠝꠣꠞ ꠁꠝꠣꠘ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠀꠝꠟ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠚꠣꠄꠖꠣ ꠇꠤꠔꠣ ꠅꠁꠛ? ꠁ ꠁꠝꠣꠘꠦ ꠔꠣꠞꠦ ꠛꠣꠌꠣꠁꠔ ꠙꠣꠞꠛ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JM2_15","089_2_15","JAS","2","15","15","ꠝꠘꠅ ꠇꠞꠅ, ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘꠥ ꠜꠣꠁ ꠛꠣ ꠛꠁꠘꠞ ꠊꠞꠅ ꠈꠣꠘꠤ ꠘꠣꠁ, ꠚꠤꠘ꠆ꠖꠣꠞ ꠇꠣꠙꠠꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JM2_16","089_2_16","JAS","2","16","16","ꠁ ꠢꠣꠟꠔꠦ ꠎꠥꠖꠤ ꠔꠣꠞꠦ ꠇꠅ, “ꠔꠥꠝꠣꠞ ꠜꠣꠟꠣꠁ ꠅꠃꠇ, ꠈꠣꠁꠀ-ꠚꠤꠘ꠆ꠖꠤꠀ ꠡꠥꠈꠦ ꠞꠅ,” ꠅꠁꠟꠦ ꠔꠣꠞ ꠘꠤꠖꠣꠘ ꠢꠞꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠃꠙꠣꠄ ꠘꠣ ꠇꠞ, ꠔꠦ ꠔꠣꠞ ꠇꠥꠘꠥ ꠚꠣꠄꠖꠣ ꠅꠁꠟ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JM2_17","089_2_17","JAS","2","17","17","ꠅꠟꠣꠈꠣꠘ ꠎꠦ ꠁꠝꠣꠘꠞ ꠟꠉꠦ ꠀꠝꠟ ꠘꠣꠁ, ꠁ ꠁꠝꠣꠘ ꠔ ꠝꠥꠞ꠆ꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("JM2_18","089_2_18","JAS","2","18","18","ꠝꠘꠅ ꠇꠞꠅ ꠇꠦꠃ ꠇꠁꠟ, “ꠔꠥꠝꠣꠞ ꠁꠝꠣꠘ ꠀꠍꠦ ꠀꠞ ꠀꠝꠣꠞ ꠀꠝꠟ ꠀꠍꠦ।” ꠑꠤꠇ ꠀꠍꠦ, ꠔꠥꠝꠣꠞ ꠀꠝꠟ ꠍꠣꠠꠣ ꠁꠝꠣꠘ ꠀꠝꠣꠞꠦ ꠖꠦꠈꠣꠅ, ꠀꠞ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠀꠝꠣꠞ ꠀꠝꠟꠞ ꠝꠣꠎ ꠖꠤꠀ ꠁꠝꠣꠘ ꠖꠦꠈꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JM2_19","089_2_19","JAS","2","19","19","ꠔꠥꠝꠤ ꠄꠇꠤꠘ ꠇꠞꠍ ꠀꠟ꠆ꠟꠣ ꠄꠇ, ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠕꠣ। ꠜꠥꠔꠦꠅ ꠔ ꠅꠟꠣ ꠄꠇꠤꠘ ꠇꠞꠦ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞꠦ ꠇꠣꠙꠦ। ");
INSERT INTO syls_vpl VALUES ("JM2_20","089_2_20","JAS","2","20","20","ꠅ ꠛꠦꠀꠈꠟ, ꠔꠥꠝꠣꠞꠦ ꠀꠝꠤ ꠇꠤꠟꠣ ꠛꠥꠎꠣꠁꠔꠣꠝ, ꠀꠝꠟ ꠍꠣꠠꠣ ꠁꠝꠣꠘ ꠔ ꠇꠥꠘꠥ ꠇꠣꠝꠞ ꠘꠣꠄ? ");
INSERT INTO syls_vpl VALUES ("JM2_21","089_2_21","JAS","2","21","21","ꠀꠝꠞꠣꠞ ꠛꠣꠚ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠙꠥꠀ ꠁꠍꠢꠣꠇꠞꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠎꠣꠉꠣꠔ ꠘꠤꠍꠟꠣ, ꠁ ꠡꠝꠄ ꠇꠤꠔꠣ ꠔꠣꠘ ꠁ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JM2_22","089_2_22","JAS","2","22","22","ꠔꠥꠝꠤ ꠔ ꠖꠦꠈꠍ, ꠔꠣꠘ ꠁꠝꠣꠘ ꠀꠞ ꠀꠝꠟ ꠄꠇꠟꠉꠦ ꠇꠣꠝ ꠇꠞꠍꠤꠟ, ꠀꠞ ꠀꠝꠟꠞ ꠟꠣꠉꠤꠃ ꠁꠝꠣꠘ ꠇꠣꠝꠤꠀꠛ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("JM2_23","089_2_23","JAS","2","23","23","ꠅꠟꠣꠈꠣꠘ ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠀꠄꠀꠔ ꠙꠥꠞꠣ ꠅꠁꠟ, “ꠁꠛ꠆ꠞꠣꠢꠤꠝꠦ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣꠄ ꠁꠝꠣꠘ ꠀꠘꠣꠄ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠖꠤꠘꠖꠣꠞ ꠇꠁꠀ ꠇꠛꠥꠟ ꠇꠞꠟꠣ।” ꠔꠣꠘ ꠃꠙꠣꠗꠤ ꠖꠤꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠥꠡ꠆ꠔ। ");
INSERT INTO syls_vpl VALUES ("JM2_24","089_2_24","JAS","2","24","24","ꠔꠥꠝꠞꠣ ꠔ ꠖꠦꠈꠟꠣꠄ, ꠀꠝꠟꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠞꠦ ꠙꠞꠦꠎꠉꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠣ ꠅꠄ, ꠈꠣꠟꠤ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM2_25","089_2_25","JAS","2","25","25","ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠃ ꠍꠤꠟꠣꠘ ꠛꠦꠐꠤ ꠞꠣꠢꠛꠣꠞꠦꠅ ꠔꠣꠁꠞ ꠀꠝꠟꠞ ꠟꠣꠉꠤ ꠙꠞꠦꠎꠉꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠣ ꠅꠁꠍꠤꠟ ꠘꠣ ꠘꠤ? ꠔꠣꠁ ꠔ ꠢꠃ ꠖꠥꠁꠅ ꠉꠥꠁꠀꠞꠦ ꠟꠥꠇꠣꠁꠀ ꠞꠣꠈꠤꠀ, ꠖꠥꠍꠞꠣ ꠙꠕꠦꠖꠤ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JM2_26","089_2_26","JAS","2","26","26","ꠅꠃ ꠢꠣꠟꠔꠦ ꠀꠝꠞꠣ ꠛꠥꠎꠔꠣꠝ ꠙꠣꠞꠤ, ꠞꠥꠢꠥ ꠍꠣꠠꠣ ꠇꠣꠄꠀ ꠝꠥꠞ꠆ꠖꠣ, ꠀꠝꠟ ꠍꠣꠠꠣ ꠁꠝꠣꠘꠅ ꠝꠥꠞ꠆ꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("JM3_1","089_3_1","JAS","3","1","1","ꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠃꠡ꠆ꠔꠣꠖ ꠅꠁꠅ ꠘꠣ। ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠀꠝꠞꠣ ꠃꠡ꠆ꠔꠣꠖ ꠉꠔꠤꠇꠦ ꠀꠝꠞꠣꠞ ꠛꠤꠌꠣꠞ ꠀꠞꠅ ꠇꠑꠤꠘ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JM3_2","089_3_2","JAS","3","2","2","ꠀꠝꠞꠣ ꠢꠇꠟꠃ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠄ ꠛꠦ-ꠙꠕꠤ ꠅꠁ। ꠇꠦꠃ ꠎꠥꠖꠤ ꠎꠛꠣꠘ ꠖꠤꠀ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠇꠣꠝꠤꠟ ꠝꠣꠘꠥꠡ, ꠔꠣꠞ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠃ ꠡꠣꠝꠟꠣꠁꠔ ꠙꠣꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("JM3_3","089_3_3","JAS","3","3","3","ꠊꠥꠠꠣꠞꠦ ꠡꠣꠝꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠝꠥꠈꠅ ꠟꠣꠉꠣꠝ ꠟꠣꠉꠣꠁꠀ ꠀꠝꠞꠣ ꠎꠦꠛꠣꠄ ꠁꠌ꠆ꠍꠣ ꠅꠛꠣꠄ ꠘꠤꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("JM3_4","089_3_4","JAS","3","4","4","ꠀꠞ ꠇꠣꠠꠣꠟꠤꠄꠅ ꠢꠥꠞꠥ ꠄꠇ ꠇꠣꠠꠣꠟ ꠗꠞꠤꠀ ꠛꠠ ꠛꠠ ꠎꠣꠎꠞꠦ ꠔꠥꠚꠣꠘꠤ ꠛꠣꠔꠣꠡ ꠑꠦꠟꠤꠀ, ꠎꠦꠛꠣꠄ ꠈꠥꠡꠤ ꠅꠛꠣꠄ ꠘꠤꠔ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("JM3_5","089_3_5","JAS","3","5","5","ꠅꠃꠟꠣ ꠎꠤꠚꠞꠣ ꠈꠥꠛ ꠢꠥꠞꠥ ꠅꠁꠟꠦꠅ ꠛꠃꠔ ꠛꠠ ꠛꠠ ꠝꠣꠔ ꠝꠣꠔꠦ। ꠀꠞ ꠡꠣꠝꠣꠁꠘ꠆ꠘ ꠀꠉꠥꠁꠘꠦ ꠇꠤꠟꠣ ꠛꠠ ꠎꠋꠉꠟ ꠎꠣꠟꠣꠁꠔ ꠙꠣꠞꠦ! ");
INSERT INTO syls_vpl VALUES ("JM3_6","089_3_6","JAS","3","6","6","ꠎꠤꠚꠞꠣꠅ ꠅꠟꠣ ꠄꠇ ꠀꠉꠥꠁꠘ। ꠀꠝꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠝꠣꠎꠦ ꠎꠤꠚꠞꠣ ꠄꠇꠐꠣ ꠈꠣꠞꠣꠙꠤꠞ ꠜꠣꠘ꠆ꠒꠣꠞ, ꠎꠣꠢꠣꠘ꠆ꠘꠣꠝꠞ ꠀꠉꠥꠁꠘꠦ ꠎꠤꠚꠞꠣꠞꠦ ꠎꠣꠟꠣꠄ ꠀꠞ ꠎꠤꠚꠞꠣꠄ ꠀꠡ꠆ꠔꠣ ꠡꠞꠤꠟꠞꠦ ꠎꠣꠟꠣꠁꠀ ꠇꠟꠋꠇꠤ ꠛꠣꠘꠣꠁꠀ, ꠀꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠀꠉꠥꠁꠘ ꠗꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM3_7","089_3_7","JAS","3","7","7","ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤꠅ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠙꠡꠥ-ꠙꠣꠈꠤ, ꠢꠣꠚ-ꠛꠤꠌ꠆ꠍꠥ ꠀꠞ ꠖꠞꠤꠀꠞ ꠛꠠ ꠛꠠ ꠝꠣꠍꠞꠦ ꠡꠣꠝꠟꠣꠁꠍꠦ ꠀꠞ ꠅꠈꠘꠅ ꠡꠣꠝꠟꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("JM3_8","089_3_8","JAS","3","8","8","ꠅꠁꠟꠦꠅ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠎꠤꠚꠞꠣꠞꠦ ꠇꠦꠃ ꠡꠣꠝꠟꠣꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ꠁꠈꠣꠘ ꠈꠥꠛ ꠌꠘ꠆ꠌꠟ ꠀꠞ ꠈꠣꠞꠣꠙ, ꠛꠦꠎꠥꠁꠔꠣ ꠛꠤꠡꠦ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JM3_9","089_3_9","JAS","3","9","9","ꠄꠇ ꠎꠤꠚꠞꠣ ꠖꠤꠀꠃ ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠤ, ꠢꠤꠞꠛꠣꠞ ꠅꠃ ꠎꠤꠚꠞꠣ ꠖꠤꠀꠃ ꠀꠟ꠆ꠟꠣꠞ ꠍꠥꠞꠔꠦ ꠙꠄꠖꠣ ꠇꠞꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠖ꠆ꠖꠥꠀ ꠖꠦꠁ। ");
INSERT INTO syls_vpl VALUES ("JM3_10","089_3_10","JAS","3","10","10","ꠄꠇ ꠝꠥꠈ ꠕꠣꠇꠤꠃ ꠔꠣꠞꠤꠚ ꠀꠞ ꠛꠖ꠆ꠖꠥꠀ ꠛꠣꠞ ꠅꠁꠀ ꠀꠄ। ꠜꠣꠁ ꠅꠇꠟ, ꠁꠔꠣ ꠔ ꠑꠤꠇ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM3_11","089_3_11","JAS","3","11","11","ꠏꠞꠘꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠄꠇꠟꠉꠦ ꠝꠤꠑꠣ ꠀꠞ ꠔꠤꠔ꠆ꠔꠣ ꠙꠣꠘꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JM3_12","089_3_12","JAS","3","12","12","ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝ ꠉꠣꠍꠅ ꠇꠤꠔꠣ ꠎꠣꠝ ꠗꠞꠦ ꠘꠤ? ꠀꠞ ꠀꠋꠉꠥꠞ ꠉꠣꠍꠅ ꠀꠝ ꠗꠞꠦ ꠘꠤ? ꠅꠃꠟꠣ ꠔꠤꠔ꠆ꠔꠣ ꠙꠣꠘꠤꠞ ꠝꠣꠎꠦ ꠝꠤꠑꠣ ꠙꠣꠘꠤ ꠝꠤꠟꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM3_13","089_3_13","JAS","3","13","13","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠈꠟ-ꠢꠦꠇꠝꠔ ꠀꠟꠣ ꠇꠦꠃ ꠀꠍꠦ ꠘꠤ? ꠕꠣꠇꠟꠦ ꠢꠦ ꠜꠣꠟꠣ ꠀꠝꠟ-ꠈꠣꠁꠍꠟꠔꠦ ꠘꠞꠝ ꠅꠁꠀ ꠅꠔꠣ ꠖꠦꠈꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("JM3_14","089_3_14","JAS","3","14","14","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠎꠥꠖꠤ ꠁꠋꠡꠣꠄ ꠔꠤꠔ꠆ꠔꠣ ꠅꠁꠀ ꠡ꠆ꠛꠣꠞꠕꠄ ꠜꠞꠣ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠛꠠꠣꠁ ꠇꠞꠤꠀ ꠢꠣꠍꠣꠞꠦ ꠝꠤꠍꠣ ꠛꠣꠘꠣꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM3_15","089_3_15","JAS","3","15","15","ꠁꠟꠣꠈꠣꠘ ꠢꠦꠇꠝꠔ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠘꠦ ꠀꠄ ꠘꠣ, ꠁꠔꠣ ꠖꠥꠘꠤꠀ, ꠈꠣꠞꠣꠙ ꠘꠚꠍ, ꠀꠞ ꠁꠛꠟꠤꠍ ꠕꠣꠇꠤꠃ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("JM3_16","089_3_16","JAS","3","16","16","ꠇꠣꠞꠘ ꠎꠦ ꠎꠣꠉꠣꠔ ꠁꠋꠡꠣ ꠀꠞ ꠡ꠆ꠛꠣꠞꠕꠙꠞꠤ ꠕꠣꠇꠦ, ꠁ ꠎꠣꠉꠣꠔ ꠚꠤꠔꠘꠣ-ꠚꠍꠣꠖ ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("JM3_17","089_3_17","JAS","3","17","17","ꠅꠁꠟꠦ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠎꠦ ꠢꠦꠇꠝꠔ ꠀꠄ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠈꠣꠐꠤ। ꠁꠇꠐꠣ ꠡꠣꠘ꠆ꠔꠤꠄ ꠜꠞꠣ, ꠍꠛꠞꠀꠟꠣ ꠀꠞ ꠘꠞꠝ ꠝꠤꠎꠣꠎꠤ, ꠖꠄꠀ ꠀꠞ ꠢꠇ ꠇꠣꠝꠦ ꠜꠞꠣ, ꠔꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠢꠣꠞ-ꠙꠞ ꠛꠣ ꠜꠘ꠆ꠒꠣꠝꠤ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JM3_18","089_3_18","JAS","3","18","18","ꠎꠣꠞꠣ ꠡꠝꠣꠎꠅ ꠡꠣꠘ꠆ꠔꠤꠞ ꠛꠤꠌ ꠍꠤꠐꠣꠄ, ꠔꠣꠞꠣꠞ ꠚꠟ ꠅꠁꠟ ꠙꠞꠦꠎꠉꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JM4_1","089_4_1","JAS","4","1","1","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠀꠁ ꠕꠘꠦ ꠝꠣꠁꠞ-ꠖꠞꠛꠣꠞ ꠀꠞ ꠇꠣꠁꠎ꠆ꠎꠣ ꠙꠄꠖꠣ ꠅꠄ? ꠔꠥꠝꠞꠣꠞ ꠡꠥꠈꠞ ꠈꠣꠁꠡꠦ ꠡꠞꠤꠟꠞ ꠎꠦ ꠞꠤꠙꠥꠄ ꠟꠣꠠꠣꠁ ꠇꠞꠦ, ꠅꠉꠥ ꠕꠣꠇꠤꠃ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("JM4_2","089_4_2","JAS","4","2","2","ꠎꠦꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠘꠣꠄ, ꠅꠔꠣ ꠔꠥꠝꠞꠣ ꠝꠘꠦ ꠝꠘꠦ ꠌꠣꠅ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠈꠥꠘ ꠇꠞ। ꠀꠞ ꠟꠣꠟꠌ ꠇꠞ ꠅꠁꠟꠦ ꠙꠣꠅ ꠘꠣ, ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣ ꠝꠣꠁꠞ-ꠖꠞꠛꠣꠞ ꠀꠞ ꠇꠣꠁꠎ꠆ꠎꠣ ꠇꠞ। ꠔꠥꠝꠞꠣ ꠔ ꠌꠣꠅ ꠘꠣ, ꠄꠞꠖꠣꠄ ꠙꠣꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM4_3","089_4_3","JAS","4","3","3","ꠀꠞ ꠌꠣꠁꠟꠦꠅ ꠙꠣꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣ ꠔ ꠛꠖ ꠘꠤꠅꠔꠦ ꠌꠣꠅ, ꠎꠦꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞ ꠈꠣꠁꠡ ꠙꠥꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("JM4_4","089_4_4","JAS","4","4","4","ꠅ ꠛꠦꠁꠝꠣꠘ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠇꠤꠔꠣ ꠎꠣꠘ ꠘꠣ ꠘꠤ, ꠖꠥꠘꠤꠀꠞ ꠟꠉꠦ ꠖꠥꠡ꠆ꠔꠤꠞ ꠝꠣꠘꠤ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠖꠥꠡꠝꠘꠤ? ꠎꠦ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠄꠀꠄ ꠛꠥꠠꠤ ꠎꠣꠄ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠥꠡꠝꠘ ꠅꠁꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM4_5","089_4_5","JAS","4","5","5","“ꠀꠝꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠎꠦ ꠞꠥꠢꠥ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠁꠇꠐꠣꠄ ꠀꠝꠞꠣꠞꠦ ꠁꠋꠡꠣꠞ ꠛꠣꠄ ꠐꠣꠘꠦ।” ꠙꠣꠇ ꠇꠤꠔꠣꠛꠞ ꠅꠃ ꠔꠣꠟꠤꠝ ꠇꠥꠘꠥ ꠄꠝꠘꠦ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠍꠦ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("JM4_6","089_4_6","JAS","4","6","6","ꠅꠁꠟꠦ ꠁꠔꠣ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔ ꠀꠞꠅ ꠛꠦꠡꠤ। ꠄꠞꠟꠣꠉꠤ ꠇꠤꠔꠣꠛꠞ ꠝꠣꠎꠦ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠛꠠꠣꠁ ꠇꠞꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠀꠔ ꠔꠥꠟꠂꠘ, ꠅꠁꠟꠦ ꠘꠞꠝ ꠝꠣꠘꠡꠞꠦ ꠞꠢꠝ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JM4_7","089_4_7","JAS","4","7","7","ꠉꠔꠤꠇꠦ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠎꠤꠝ꠆ꠝꠣꠄ ꠞꠁꠀ ꠡꠄꠔꠣꠘꠞ ꠝꠥꠇꠣꠛꠤꠟꠣ ꠇꠞꠅ, ꠔꠦꠃ ꠢꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍ ꠕꠘꠦ ꠜꠣꠉꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("JM4_8","089_4_8","JAS","4","8","8","ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠄ ꠌꠣꠅ, ꠔꠦꠃ ꠔꠣꠁꠘꠅ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠌꠣꠁꠛꠣ। ꠅ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠅ, ꠅ ꠖꠥ-ꠖꠤꠟꠣ ꠝꠣꠘꠥꠡ, ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠈꠣꠐꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JM4_9","089_4_9","JAS","4","9","9","ꠖꠥꠈꠦ ꠇꠣꠔꠞ ꠅꠁꠀ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠅ, ꠀꠡꠤꠞ ꠛꠖꠟꠣ ꠇꠣꠘ꠆ꠖꠅ, ꠈꠥꠡꠤꠞ ꠛꠖꠟꠣ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JM4_10","089_4_10","JAS","4","10","10","ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠘꠔ ꠅꠅ, ꠔꠦꠃ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠌꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("JM4_11","089_4_11","JAS","4","11","11","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞ ꠉꠤꠛꠔ ꠉꠣꠁꠅ ꠘꠣ। ꠇꠦꠃ ꠎꠥꠖꠤ ꠜꠣꠁꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠄ ꠛꠣ ꠔꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠦ, ꠄꠞ ꠝꠣꠘꠤ ꠢꠦ ꠡꠞꠤꠅꠔꠞ ꠛꠖꠘꠣꠝ ꠇꠞꠟ ꠀꠞ ꠡꠞꠤꠅꠔꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠟ। ꠔꠥꠝꠤ ꠎꠥꠖꠤ ꠡꠞꠤꠅꠔꠞ ꠛꠤꠌꠣꠞ ꠇꠞ, ꠔꠦ ꠔ ꠡꠞꠤꠅꠔ ꠝꠣꠘꠞꠣꠄ ꠘꠣ, ꠃꠟꠐꠣ ꠔꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠔ ꠈꠣꠠꠣ ꠅꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("JM4_12","089_4_12","JAS","4","12","12","ꠡꠞꠤꠅꠔ ꠀꠞ ꠛꠤꠌꠣꠞꠞ ꠈꠦꠝꠔꠣ ꠈꠣꠟꠤ ꠄꠇꠎꠘꠞ ꠀꠔꠅꠃ ꠀꠍꠦ। ꠔꠣꠁꠘꠃ ꠛꠣꠌꠣꠁꠘ, ꠔꠣꠁꠘꠃ ꠝꠣꠞꠂꠘ। ꠔꠦ ꠀꠞꠤ-ꠚꠞꠤꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠞꠣ ꠔꠥꠝꠤ ꠀꠞꠇ ꠎꠘ ꠇꠦ? ");
INSERT INTO syls_vpl VALUES ("JM4_13","089_4_13","JAS","4","13","13","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠣ ꠇꠅ, ꠀꠁꠎ ꠛꠣ ꠇꠣꠁꠟ ꠀꠝꠞꠣ ꠅꠝꠥꠇ ꠐꠣꠃꠘꠅ ꠎꠣꠁꠝꠥꠉꠤ, ꠉꠤꠀ ꠢꠘꠅ ꠄꠇ ꠛꠞꠍ ꠞꠁꠀ ꠇꠣꠄ-ꠇꠣꠞꠛꠣꠞ ꠇꠞꠤꠀ ꠟꠣꠜ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("JM4_14","089_4_14","JAS","4","14","14","ꠅꠁꠟꠦ ꠇꠣꠁꠟꠇꠥꠞ ꠈꠛꠞ ꠔ ꠔꠥꠝꠞꠣ ꠎꠣꠘ ꠘꠣ। ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠃ ꠛꠣ ꠇꠤꠔꠣ? ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠔ ꠇꠍꠥ ꠙꠣꠔꠣꠞ ꠙꠣꠘꠤ, ꠕꠥꠠꠣ ꠡꠝꠄ ꠕꠣꠇꠦ, ꠛꠣꠖꠦ ꠙꠠꠤꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM4_15","089_4_15","JAS","4","15","15","ꠄꠞꠖꠣꠄ ꠁꠟꠣ ꠘꠣ ꠇꠁꠀ ꠅꠟꠣ ꠇꠅ, “ꠁꠘꠡꠣꠟ꠆ꠟꠣ, ꠀꠝꠞꠣ ꠢꠣꠄꠀꠔꠤ ꠙꠣꠁꠝꠥ, ꠀꠞ ꠅꠔꠣ-ꠢꠔꠣ ꠇꠞꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("JM4_16","089_4_16","JAS","4","16","16","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠛꠠꠣꠁ ꠇꠞꠤꠀ ꠚꠥꠐꠣꠘꠤ ꠖꠦꠈꠣꠁꠞꠣꠄ। ꠁꠟꠣꠈꠣꠘ ꠚꠥꠐꠣꠘꠤ ꠜꠣꠟꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JM4_17","089_4_17","JAS","4","17","17","ꠇꠦꠃ ꠎꠥꠖꠤ ꠎꠣꠘꠤꠀꠅ ꠜꠣꠟꠣ ꠇꠣꠝ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠉꠥꠘꠣꠞ ꠜꠣꠉꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JM5_1","089_5_1","JAS","5","1","1","ꠅ ꠗꠘꠤ ꠅꠇꠟ, ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠎꠦ ꠝꠍꠤꠛꠔ ꠀꠞ, ꠁꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠇꠣꠘ꠆ꠖꠅ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JM5_2","089_5_2","JAS","5","2","2","ꠔꠥꠝꠞꠣꠞ ꠗꠘ-ꠡꠝ꠆ꠙꠖ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠍꠦ, ꠔꠥꠝꠞꠣꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠃꠘ꠆ꠖꠥꠞꠦ ꠇꠣꠐꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JM5_3","089_5_3","JAS","5","3","3","ꠔꠥꠝꠞꠣꠞ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠔ ꠎꠋꠉꠣꠞꠦ ꠗꠞꠤꠟꠤꠍꠦ, ꠁ ꠎꠋꠉꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠛ, ꠀꠞ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛ। ꠁꠔꠣ ꠔ ꠇꠤꠀꠝꠔꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠖꠟꠣ ꠇꠞꠤ ꠕꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("JM5_4","089_5_4","JAS","5","4","4","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞ ꠗꠣꠘ ꠖꠣꠅꠞꠣ ꠇꠣꠝꠟꠣꠞ ꠎꠦ ꠛꠦꠔꠘ ꠀꠐꠇꠣꠁꠍ, ꠅꠃ ꠛꠦꠔꠘꠦ ꠅꠈꠘ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠦꠞ। ꠁ ꠇꠣꠝꠟꠣꠁꠘ꠆ꠔꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠀꠟ꠆ꠟꠣ ꠞꠣꠛ꠆ꠛꠥꠟ ꠀꠟꠣꠝꠤꠘꠞ ꠇꠣꠘꠅ ꠉꠤꠀ ꠀꠎꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JM5_5","089_5_5","JAS","5","5","5","ꠖꠥꠘꠤꠀꠞ ꠛꠥꠇꠥꠔ ꠛꠤꠟꠣꠡꠤꠔꠣ ꠀꠞ ꠞꠋ-ꠔꠣꠝꠡꠣꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠍ, ꠖꠥꠎꠈꠞ ꠈꠥꠞꠣꠇ ꠛꠘꠣꠞ ꠟꠣꠉꠤ ꠘꠤꠎꠞꠦ ꠈꠥꠛ ꠚꠥꠟꠚꠥꠟꠣ ꠛꠣꠘꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("JM5_6","089_5_6","JAS","5","6","6","ꠔꠥꠝꠞꠣ ꠘꠤ-ꠅꠙꠞꠣꠗꠤꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠤꠀ ꠈꠥꠘ ꠇꠞꠍ, ꠅꠁꠟꠦ ꠄꠞꠣ ꠇꠥꠘꠥ ꠙ꠆ꠞꠔꠤꠛꠣꠖ ꠇꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM5_7","089_5_7","JAS","5","7","7","ꠉꠔꠤꠇꠦ ꠅ ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠥꠝꠞꠣ ꠇꠡ꠆ꠐ ꠇꠞꠤꠀ ꠕꠥꠠꠣ ꠍꠛꠞ ꠇꠞꠅ। ꠔꠥꠝꠞꠣ ꠔ ꠖꠦꠈꠍ, ꠉꠤꠞꠡ꠆ꠔꠦ ꠜꠣꠟꠣ ꠚꠡꠟ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠝꠦꠊꠞ ꠀꠡꠣꠄ ꠇꠤꠟꠣ ꠍꠛꠞ ꠇꠞꠤ ꠛꠁ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("JM5_8","089_5_8","JAS","5","8","8","ꠔꠥꠝꠞꠣꠅ ꠅꠟꠣ ꠍꠛꠞ ꠇꠞꠅ, ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠝꠣꠟꠤꠇꠦ ꠈꠥꠛ ꠎꠟꠖꠤꠃ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JM5_9","089_5_9","JAS","5","9","9","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠖꠥꠡꠤ ꠘꠣ ꠛꠘ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠈꠣꠟꠤ ꠄꠇꠎꠘꠦ ꠀꠞꠇꠎꠘꠞ ꠈꠥꠔ ꠔꠥꠇꠣꠘꠤꠔ ꠞꠁꠅ ꠘꠣ। ꠢꠥꠘꠅ, ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠁꠀ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JM5_10","089_5_10","JAS","5","10","10","ꠅ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠎꠦ ꠘꠛꠤ-ꠞꠍꠥꠟ ꠅꠇꠟꠦ ꠝꠣꠛꠥꠖꠞ ꠘꠣꠝꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠟꠣ, ꠔꠣꠞꠣꠞ ꠇꠡ꠆ꠐ ꠀꠞ ꠍꠛꠞꠞ ꠇꠕꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ ꠖꠦꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("JM5_11","089_5_11","JAS","5","11","11","ꠔꠣꠞꠣ ꠔ ꠇꠡ꠆ꠐ ꠙꠣꠁꠀꠅ ꠕꠤꠞ ꠞꠁꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠉꠥꠘꠉꠣꠘ ꠉꠣꠁ। ꠔꠥꠝꠞꠣ ꠔ ꠀꠁꠃꠛ ꠘꠛꠤꠞ ꠍꠛꠞꠞ ꠇꠕꠣ ꠜꠣꠟꠣ ꠇꠞꠤ ꠎꠣꠘ, ꠀꠞ ꠄꠅꠈꠣꠘ ꠎꠣꠘ, ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠖꠦ ꠔꠣꠘꠞꠦ ꠇꠤꠟꠣ ꠞꠢꠝ ꠇꠞꠍꠟꠣ। ꠀꠟ꠆ꠟꠣ ꠔ ꠖꠄꠀ-ꠝꠣꠄꠀꠞ ꠡꠣꠉꠞ। ");
INSERT INTO syls_vpl VALUES ("JM5_12","089_5_12","JAS","5","12","12","ꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠀꠝꠣꠞ ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠇꠍꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠀꠍꠝꠣꠘꠞ ꠘꠣꠝꠦꠅ ꠘꠣ, ꠎꠝꠤꠘꠞ ꠘꠣꠝꠦꠅ ꠘꠣ, ꠅꠟꠣ ꠇꠥꠘꠥ ꠘꠣꠝꠦꠃ ꠇꠍꠝ ꠇꠞꠤꠅ ꠘꠣ। ꠄꠞ ꠛꠖꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠅꠄ ꠈꠣꠘ ꠅꠄ, ꠀꠞ ꠘꠣ ꠈꠣꠘ ꠘꠣ ꠅꠃꠇ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠛꠤꠌꠣꠞꠞ ꠖꠣꠠꠅ ꠘꠣ ꠙꠠ। ");
INSERT INTO syls_vpl VALUES ("JM5_13","089_5_13","JAS","5","13","13","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠝꠍꠤꠛꠔꠅ ꠕꠣꠇꠟꠦ ꠢꠦ ꠖꠥꠀ ꠇꠞꠃꠇ। ꠇꠦꠃ ꠡꠥꠈꠦ ꠕꠣꠇꠟꠦ ꠢꠣꠝꠖ-ꠇꠣꠅꠀꠟꠤ ꠉꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("JM5_14","089_5_14","JAS","5","14","14","ꠇꠦꠃꠞꠞ ꠛꠦꠝꠣꠞ ꠅꠁꠟꠦ ꠢꠦ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠖꠣꠅꠔ ꠖꠦꠃꠇ, ꠔꠣꠞꠣ ꠀꠁꠀ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠟꠁꠀ ꠔꠣꠞ ꠝꠣꠕꠣꠔ ꠔꠦꠟ ꠖꠤꠀ ꠖꠥꠀ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("JM5_15","089_5_15","JAS","5","15","15","ꠔꠦꠃ ꠁꠝꠣꠘꠞ ꠍꠣꠔꠦ ꠖꠥꠀ ꠇꠞꠣꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠁ ꠛꠦꠝꠣꠞꠤꠞꠦ ꠡꠤꠚꠣ ꠇꠞꠛꠣ। ꠢꠦ ꠎꠥꠖꠤ ꠉꠥꠘꠣꠅ ꠇꠞꠤꠀ ꠕꠣꠇꠦ, ꠔꠦ ꠔꠣꠞ ꠉꠥꠘꠣ ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("JM5_16","089_5_16","JAS","5","16","16","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠄꠇꠎꠘꠦ ꠀꠞꠇ ꠎꠘꠞ ꠉꠦꠍꠦ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠘꠣ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠅ, ꠀꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠅ, ꠎꠣꠔꠦ ꠜꠣꠟꠣ ꠅꠁꠔꠣꠄ ꠙꠣꠞ। ꠙꠞꠦꠎꠉꠣꠞ ꠅꠇꠟꠞ ꠝꠥꠘꠣꠎꠣꠔ ꠀꠌꠣꠘꠇ ꠛꠟꠀꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JM5_17","089_5_17","JAS","5","17","17","ꠁꠟꠤꠀꠍ ꠘꠛꠤ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘꠃ ꠞꠇ꠆ꠔꠄ-ꠝꠣꠋꠡꠄ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ। ꠔꠣꠁꠘ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠖꠥꠀ ꠇꠞꠟꠣ ꠝꠦꠊ ꠘꠣ ꠅꠀꠞ ꠟꠣꠉꠤ, ꠢꠣꠍꠣꠃ ꠡꠣꠠꠦ ꠔꠤꠘ ꠛꠞꠍ ꠇꠥꠘꠥ ꠝꠦꠊ ꠅꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JM5_18","089_5_18","JAS","5","18","18","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠝꠦꠊꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠇꠞꠟꠣ, ꠔꠦꠃ ꠝꠦꠊ ꠅꠁꠟ, ꠀꠞ ꠎꠝꠤꠘꠅ ꠚꠡꠟ ꠚꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("JM5_19","089_5_19","JAS","5","19","19","ꠅ ꠀꠝꠣꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠛꠦ-ꠙꠕꠤ ꠅꠁꠎꠣꠄ, ꠀꠞ ꠇꠦꠃ ꠔꠣꠞꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠦ, ");
INSERT INTO syls_vpl VALUES ("JM5_20","089_5_20","JAS","5","20","20","ꠔꠦ ꠎꠣꠘꠤꠅ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠇꠥꠘꠥ ꠉꠥꠘꠣꠉꠣꠞꠞꠦ ꠛꠦ-ꠙꠕ ꠕꠘꠦ ꠚꠤꠞꠣꠁꠀ ꠀꠘꠦ, ꠢꠦ ꠅꠃ ꠉꠥꠘꠣꠉꠣꠞꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠄ ꠀꠞ ꠔꠣꠞ ꠉꠥꠘꠣ ꠛꠦꠡꠤ ꠅꠁꠟꠦꠅ ꠝꠣꠚꠤ ꠙꠣꠄ॥");
INSERT INTO syls_vpl VALUES ("P11_1","090_1_1","1PE","1","1","1","ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠎꠔ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ ꠙꠘ꠆ꠔ, ꠉꠣꠟꠣꠔꠤꠀ, ꠇꠣꠙ꠆ꠙꠣꠖꠇꠤꠀ, ꠀꠍꠤꠀ ꠀꠞ ꠛꠤꠕꠥꠘꠤꠀ ꠖꠦꠡꠅ ꠍꠤꠔ꠆ꠞꠤꠀ ꠜꠤꠘ-ꠖꠦꠡꠤ ꠢꠤꠡꠣꠛꠦ ꠛꠡꠔ ꠇꠞꠞꠣ, ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠢꠣꠛꠤ ꠙꠤꠔꠞꠦ ꠅꠃ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("P11_2","090_1_2","1PE","1","2","2","ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠝꠥꠘꠡꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠦ ꠙꠛꠤꠔ꠆ꠞ ꠇꠞꠍꠂꠘ। ꠄꠞ ꠃꠖ꠆ꠖꠦꠡ꠆ꠡ ꠅꠁꠟ, ꠔꠥꠝꠞꠣ ꠎꠣꠔꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠣꠁꠖ꠆ꠖ ꠅꠅ ꠀꠞ ꠔꠣꠘ ꠟꠃ ꠍꠤꠐꠣꠁꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠄ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠛꠦꠡ ꠇꠞꠤ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("P11_3","090_1_3","1PE","1","3","3","ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠔꠣꠞꠤꠚ ꠅꠃꠇ, ꠎꠦꠁꠘ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠛꠥꠖ ꠀꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ। ꠔꠣꠁꠘ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤꠀ, ꠔꠣꠘ ꠝꠢꠣ ꠖꠄꠀꠄ ꠀꠝꠞꠣꠞꠦ ꠘꠄꠀ ꠎꠘꠝ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠄꠔꠦ ꠀꠝꠞꠣ ꠄꠇ ꠎꠤꠘ꠆ꠖꠣ ꠀꠡꠣ ꠙꠣꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("P11_4","090_1_4","1PE","1","4","4","ꠝꠣꠘꠤ ꠀꠝꠞꠣ ꠅꠟꠣ ꠄꠇ ꠗꠘꠞ ꠀꠡꠣ ꠙꠣꠁꠍꠤ, ꠎꠦ ꠗꠘ ꠇꠥꠘꠥꠖꠤꠘ ꠘꠡ꠆ꠐ ꠅꠁꠔ ꠘꠣꠄ, ꠢꠣꠞꠣ ꠎꠤꠛꠘ ꠘꠄꠀ ꠕꠣꠇꠛ, ꠄꠞ ꠝꠣꠎꠦ ꠈꠣꠞꠣꠙ ꠇꠥꠘ꠆ꠔꠣ ꠕꠣꠇꠔ ꠘꠣꠄ। ꠘꠣꠎꠣꠔꠞ ꠁ ꠗꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠞꠣꠈꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P11_5","090_1_5","1PE","1","5","5","ꠔꠥꠝꠞꠣ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠣꠎꠣꠔ ꠘꠣ ꠙꠣꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠟ꠆ꠟꠣꠁ ꠡꠇ꠆ꠔꠤꠄ ꠁꠝꠣꠘꠞ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠦꠚꠣꠎꠔꠦ ꠞꠣꠈꠣ ꠅꠁꠍꠦ। ꠅꠃ ꠘꠣꠎꠣꠔ ꠑꠤꠇ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠀꠈꠦꠞꠣꠔꠞ ꠡꠝꠄ ꠎꠣꠁꠞ ꠅꠀꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("P11_6","090_1_6","1PE","1","6","6","ꠎꠥꠖꠤꠅ ꠇꠄ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠘꠣꠘꠣꠘ ꠎꠣꠔ ꠙꠞꠤꠇ꠆ꠇꠣꠞ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠞꠞꠣꠄ, ꠔꠣ-ꠅ ꠅꠃ ꠘꠣꠎꠣꠔꠞ ꠀꠡꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞ ꠝꠘ ꠈꠥꠡꠤꠄ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("P11_7","090_1_7","1PE","1","7","7","ꠅꠃ ꠙꠞꠤꠇ꠆ꠇꠣ ꠅꠇꠟ ꠌꠟꠦꠞ, ꠔꠥꠝꠞꠣ ꠎꠦꠘ ꠁꠝꠣꠘꠦ ꠈꠣꠐꠤ ꠅꠈꠣꠘ ꠙꠞꠝꠣꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ꠀꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠎꠣꠁꠞ ꠅꠀꠞ ꠡꠝꠄ, ꠔꠥꠝꠞꠣ ꠎꠣꠘꠥ ꠔꠣꠞꠤꠚ, ꠉꠃꠞꠛ ꠀꠞ ꠡꠝ꠆ꠝꠣꠘ ꠙꠣꠅ। ꠎꠦ ꠡꠥꠘꠣ ꠇ꠆ꠇꠄ ꠅꠁꠎꠣꠄ, ꠅꠃ ꠡꠥꠘꠣꠞꠦꠅ ꠀꠉꠥꠘꠤꠔ ꠙꠥꠠꠤꠀ ꠎꠣꠌꠣꠁ ꠇꠞꠣ ꠅꠄ। ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠖꠣꠝ ꠔ ꠅꠃ ꠡꠥꠘꠣꠞ ꠌꠣꠁꠔꠦꠅ ꠛꠃꠔ ꠛꠦꠡꠤ, ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠙꠞꠤꠇ꠆ꠇꠣ ꠌꠟꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("P11_8","090_1_8","1PE","1","8","8","ꠎꠥꠖꠤꠅ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠔꠥꠝꠞꠣ ꠖꠦꠈꠍ ꠘꠣ, ꠔꠦꠛꠃ ꠔꠥꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠞꠣꠄ। ꠀꠞ ꠅꠈꠘꠅ ꠔꠣꠘꠞꠦ ꠌꠃꠈꠦ ꠘꠣ ꠖꠦꠈꠟꠦꠅ, ꠈꠥꠡꠤ ꠅꠁꠀ ꠔꠣꠘꠞꠦ ꠄꠇꠤꠘ ꠇꠞꠞꠣꠄ, ꠁ ꠈꠥꠡꠤ ꠔ ꠜꠣꠡꠣꠄ ꠇꠅꠀ ꠎꠣꠄ ꠘꠣ, ꠁꠔꠣ ꠈꠣꠟꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠈꠥꠡꠤ। ");
INSERT INTO syls_vpl VALUES ("P11_9","090_1_9","1PE","1","9","9","ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞ ꠀꠈꠦꠞꠤ ꠚꠟ ꠙꠣꠁꠞꠣꠄ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠘꠣꠎꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("P11_10","090_1_10","1PE","1","10","10","ꠎꠦ ꠖꠥꠀ ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅꠀꠞ ꠇꠕꠣ, ꠁ ꠛꠦꠙꠣꠞꠦ ꠛꠃꠔ ꠀꠉꠦ ꠘꠛꠤ ꠅꠇꠟꠦ ꠛꠣꠔꠣꠁꠍꠂꠘ। ꠔꠣꠞꠣ ꠅꠃ ꠘꠣꠎꠣꠔꠞ ꠛꠦꠙꠣꠞ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠈꠥꠎ-ꠈꠛꠞ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P11_11","090_1_11","1PE","1","11","11","ꠔꠣꠞꠣꠞ ꠖꠤꠟꠅ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠥꠢꠦ ꠀꠉꠦꠃ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠀ ꠇꠁꠍꠂꠘ, ꠔꠣꠘꠞꠦ ꠇꠡ꠆ꠐ ꠇꠞꠔꠦ ꠅꠁꠛ ꠀꠞ ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠝꠢꠤꠝꠣ ꠙꠣꠁꠛꠣ। ꠘꠛꠤ ꠅꠇꠟꠦ ꠎꠣꠘꠔꠣ ꠌꠣꠁꠍꠟꠣ, ꠀꠟ-ꠝꠍꠤꠞ ꠅꠃ ꠞꠥꠢꠦ ꠇꠥꠘ ꠡꠝꠄꠇꠥꠞ ꠀꠞ ꠇꠥꠘ ꠢꠣꠟꠔꠞ ꠇꠕꠣ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("P11_12","090_1_12","1PE","1","12","12","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠈꠣꠁꠀ ꠖꠤꠍꠂꠘ, ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ ꠁꠔꠣ ꠖꠤꠀ ꠔꠣꠞꠣꠞ ꠘꠤꠎꠞ ꠈꠦꠎꠝꠔ ꠘꠣ ꠇꠞꠤꠀ, ꠔꠥꠝꠞꠣꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠞꠣ। ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠙꠣꠑꠣꠁꠟ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠤꠀ, ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠂꠘ, ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠕꠣꠃ ꠎꠣꠘꠣꠁꠍꠂꠘ। ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦꠅ ꠁꠔꠣ ꠛꠦꠙꠣꠞ ꠎꠣꠘꠣꠞ ꠟꠣꠉꠤ ꠈꠤꠀꠟꠤ। ");
INSERT INTO syls_vpl VALUES ("P11_13","090_1_13","1PE","1","13","13","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠅ ꠀꠞ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠅ। ꠀꠟ-ꠝꠍꠤ ꠎꠣꠁꠞ ꠅꠀꠞ ꠛꠣꠖꠦ ꠎꠦ ꠞꠢꠝꠔ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠛꠣꠄ, ꠅꠃ ꠞꠢꠝꠔꠤ ꠘꠣꠎꠣꠔ ꠙꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠀꠡꠣ ꠟꠁꠀ ꠔꠥꠝꠞꠣ ꠛꠣꠞ ꠌꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("P11_14","090_1_14","1PE","1","14","14","ꠔꠥꠝꠞꠣꠞ ꠀꠉꠞ ꠅꠛꠥꠎ ꠢꠣꠟꠔꠞ ꠈꠣꠞꠣꠙ ꠇꠣꠝ-ꠇꠣꠎ ꠝꠣꠚꠤꠇ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠅ ꠘꠣ, ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠞꠣ ꠀꠅꠟꠣꠖ ꠢꠤꠡꠣꠛꠦ ꠖꠤꠘ ꠇꠣꠐꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("P11_15","090_1_15","1PE","1","15","15","ꠎꠦꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠙꠛꠤꠔ꠆ꠞ, ꠔꠥꠝꠞꠣꠅ ꠅꠃꠟꠣ ꠢꠇꠟ ꠌꠟꠣ-ꠚꠤꠞꠣꠔ ꠙꠛꠤꠔ꠆ꠞ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("P11_16","090_1_16","1PE","1","16","16","ꠙꠣꠇ ꠇꠤꠔꠣꠛꠅ ꠀꠟ꠆ꠟꠣꠄ ꠇꠁꠍꠂꠘ, “ꠀꠝꠤ ꠙꠛꠤꠔ꠆ꠞ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠅ ꠙꠛꠤꠔ꠆ꠞ ꠅꠅ।” ");
INSERT INTO syls_vpl VALUES ("P11_17","090_1_17","1PE","1","17","17","ꠀꠟ꠆ꠟꠣꠄ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠞ ꠀꠝꠟ-ꠘꠣꠝꠣ ꠖꠦꠈꠤꠀ ꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ, ꠇꠦꠃꠞ ꠝꠥꠈꠞ ꠛꠣꠄ ꠌꠣꠁꠀ ꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ ꠘꠣ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠘꠞꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠒꠣꠇ, ꠔꠦ ꠎꠔꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠅꠃ ꠖꠥꠘꠤꠀꠔ ꠝꠥꠍꠣꠚꠤꠞ ꠢꠣꠟꠔꠦ ꠕꠣꠇꠛꠣꠄ, ꠅꠔꠖꠤꠘ ꠔꠥꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠒꠞꠣꠁꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("P11_18","090_1_18","1PE","1","18","18","ꠔꠥꠝꠞꠣ ꠎꠣꠘ, ꠔꠥꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣ ꠕꠣꠇꠤ ꠙꠣꠅꠀ ꠛꠦꠇꠣꠝꠣ ꠌꠣꠟ-ꠌꠟꠘꠞ ꠙꠕ ꠕꠣꠇꠤ, ꠇ꠆ꠇꠄ ꠅꠀꠞ ꠎꠥꠇꠣ ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠞ ꠟꠣꠈꠣꠘ ꠇꠥꠘꠥꠔꠣ ꠖꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠣ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("P11_19","090_1_19","1PE","1","19","19","ꠛꠞꠋ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠀꠟ-ꠝꠍꠤꠞ ꠝꠢꠣ ꠖꠣꠝꠤ ꠟꠃ ꠖꠤꠀ, ꠘꠤꠈꠥꠔ-ꠘꠤꠡ꠆ꠇꠟꠋꠇ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠃ ꠖꠤꠀ। ");
INSERT INTO syls_vpl VALUES ("P11_20","090_1_20","1PE","1","20","20","ꠖꠥꠘꠤꠀ ꠙꠄꠖꠣ ꠅꠀꠞ ꠀꠉꠦꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘꠞꠦ ꠑꠤꠇ ꠇꠞꠤ ꠞꠣꠈꠍꠂꠘ, ꠅꠁꠟꠦ ꠅꠃ ꠢꠦꠡ-ꠝꠦꠡ ꠡꠝꠄ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠎꠣꠁꠞ ꠅꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P11_21","090_1_21","1PE","1","21","21","ꠀꠟ꠆ꠟꠣꠄ ꠄꠘꠞꠦ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠤ ꠔꠥꠟꠤꠀ ꠝꠢꠤꠝꠣ ꠖꠣꠘ ꠇꠞꠍꠂꠘ ꠀꠞ ꠔꠣꠘ ꠝꠣꠎꠖꠤ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍ। ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘ ꠀꠞ ꠀꠡꠣ ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦꠃ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P11_22","090_1_22","1PE","1","22","22","ꠅꠈꠘ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠝꠣꠘꠤꠀ, ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠍ ꠀꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠅꠇꠟ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠝꠣꠄꠀꠞ ꠝꠣꠘꠥꠡ ꠅꠁꠍꠂꠘ, ꠔꠦ ꠀꠝꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠝꠣꠄꠀ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("P11_23","090_1_23","1PE","1","23","23","ꠎꠦ ꠛꠤꠌ ꠘꠡ꠆ꠐ ꠅꠁꠎꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠎꠘꠝ ꠔ ꠁꠟꠣ ꠛꠤꠌꠞ ꠘꠣꠄ। ꠛꠞꠋ ꠎꠦꠔꠣ ꠘꠡ꠆ꠐ ꠅꠄ ꠘꠣ, ꠅꠔꠣ ꠕꠣꠇꠤꠃ ꠔꠥꠝꠞꠣꠞ ꠘꠄꠀ ꠎꠘꠝ ꠅꠁꠍꠦ। ꠅꠃ ꠛꠤꠌ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠣ ꠇꠣꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("P11_24","090_1_24","1PE","1","24","24","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠢꠇꠟ ꠝꠣꠘꠥꠡꠃ ꠊꠣꠡꠞ ꠟꠣꠈꠣꠘ, ꠊꠣꠡ ꠚꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣ ꠡꠥꠘ꠆ꠖꠞ; ꠊꠣꠡ ꠢꠥꠇꠣꠁ ꠎꠣꠄ, ꠚꠥꠟꠅ ꠏꠞꠤ ꠎꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("P11_25","090_1_25","1PE","1","25","25","ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠞꠄ ꠌꠤꠞꠇꠣꠟ। ꠀꠞ ꠅꠃ ꠇꠣꠟꠣꠝꠃ ꠅꠁꠟ ꠈꠥꠡ-ꠈꠛꠞꠤ, ꠎꠦꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P12_1","090_2_1","1PE","2","1","1","ꠄꠞꠟꠣꠉꠤ ꠅꠁꠘ꠆ꠘ ꠝꠣꠘꠡꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠢꠇꠟ ꠎꠣꠔ ꠇꠥ-ꠝꠔꠟꠛ, ꠍꠟ-ꠌꠔꠥꠞꠤ, ꠜꠘ꠆ꠒꠣꠝꠤ, ꠁꠋꠡꠣ, ꠀꠞ ꠢꠇꠟ ꠎꠣꠔ ꠘꠤꠘ꠆ꠖꠣꠞ ꠝꠣꠔ-ꠇꠕꠣ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠕꠣꠇꠤ ꠢꠞꠣꠁ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("P12_2","090_2_2","1PE","2","2","2","ꠉꠦꠖꠣ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠁꠘ꠆ꠔꠞ ꠖꠥꠗꠞ ꠙꠤꠀꠍꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣ ꠈꠣꠐꠤ ꠞꠥꠢꠣꠘꠤ ꠖꠥꠗꠞ ꠈꠤꠀꠟꠤ ꠅꠅ, ꠀꠞ ꠅꠃ ꠖꠥꠗ ꠈꠣꠁꠀ ꠈꠣꠁꠀ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣ ꠛꠠ ꠅꠁꠀ ꠘꠣꠎꠣꠔ ꠙꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("P12_3","090_2_3","1PE","2","3","3","ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠝꠦꠢꠦꠞꠛꠣꠘꠤꠞ ꠝꠎꠣ ꠔ ꠔꠥꠝꠞꠣ ꠙꠣꠁꠍꠃ। ");
INSERT INTO syls_vpl VALUES ("P12_4","090_2_4","1PE","2","4","4","ꠔꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠅ। ꠔꠣꠁꠘꠃ ꠅꠁꠟꠣ ꠀꠉꠞ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠅꠀ ꠢꠃ “ꠎꠤꠘ꠆ꠖꠣ ꠙꠣꠔ꠆ꠔꠞ”, ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠝꠣꠘꠡꠦ ꠖꠣꠝ ꠖꠤꠍꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠁꠇꠐꠣ ꠝꠢꠣ ꠖꠣꠝꠤ ꠀꠞ ꠙꠍꠘ꠆ꠖꠞ ꠙꠣꠔ꠆ꠔꠞ। ");
INSERT INTO syls_vpl VALUES ("P12_5","090_2_5","1PE","2","5","5","ꠀꠞ ꠔꠥꠝꠞꠣ ꠔꠣꠘ ꠔꠞꠤꠇꠣ ꠇꠛꠥꠟ ꠇꠞꠣꠄ, ꠔꠥꠝꠞꠣꠞꠦꠅ ꠎꠤꠘ꠆ꠖꠣ ꠙꠣꠔ꠆ꠔꠞꠞ ꠟꠣꠈꠣꠘ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠞꠁꠛꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞ ꠛꠣꠘꠣꠘꠤ ꠅꠞ। ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠁ ꠁꠝꠣꠝ ꠍꠣꠛ ꠢꠤꠡꠣꠛꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠟꠣꠖꠣ ꠇꠞꠤ ꠞꠣꠈꠣ ꠅꠁꠍꠦ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠅꠃꠟꠣ ꠞꠥꠢꠣꠘꠤ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠦꠅ, ꠎꠦꠔꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠇꠛꠥꠟ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P12_6","090_2_6","1PE","2","6","6","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ: ꠢꠥꠘꠅ, ꠀꠝꠤ ꠄꠇꠐꠣ ꠝꠢꠣ ꠖꠣꠝꠤ ꠙꠣꠔ꠆ꠔꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠤ; ꠁꠇꠐꠣꠞꠦ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠅ ꠁꠀꠘ ꠈꠥꠐꠤ ꠢꠤꠡꠣꠛꠦ ꠉꠣꠠꠤꠍꠤ। ꠎꠦ ꠎꠘꠦ ꠔꠣꠘ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠢꠦ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P12_7","090_2_7","1PE","2","7","7","ꠀꠞ ꠔꠥꠝꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠣꠄ, ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠢꠃ ꠙꠣꠔ꠆ꠔꠞ ꠝꠢꠣ ꠖꠣꠝꠤ ꠅꠁꠉꠦꠍꠦ। ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠍꠦ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠛꠦꠟꠣꠄ ꠇꠤꠔꠣꠛꠞ ꠅꠃ ꠇꠕꠣꠃ ꠈꠣꠐꠦ: ꠞꠣꠎ ꠝꠦꠡ꠆ꠔꠁꠞ ꠅꠇꠟꠦ ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠞꠦ ꠛꠦꠇꠣꠝꠣ ꠇꠁꠀ ꠚꠣꠟꠣꠁ ꠖꠤꠍꠤꠟ, ꠅꠇꠐꠣ ꠖꠤꠀꠃ ꠊꠞꠞ ꠁꠀꠘ ꠈꠥꠐꠤ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("P12_8","090_2_8","1PE","2","8","8","ꠀꠞ, ꠁꠇꠐꠣ ꠅꠃꠟꠣ ꠙꠣꠔ꠆ꠔꠞ, ꠎꠦ ꠙꠣꠔ꠆ꠔꠞꠅ ꠝꠣꠘꠡꠦ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠛ, ꠔꠣꠞꠣꠞ ꠀꠍꠣꠠ ꠈꠣꠁꠀ ꠙꠠꠣꠞ ꠇꠣꠞꠘ ꠅꠁꠛ। ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠝꠣꠘꠦ ꠘꠣ, ꠉꠔꠤꠇꠦꠃ ꠃꠡ꠆ꠐꠣ ꠈꠣꠄ। ꠁꠔꠣ ꠔ ꠔꠣꠞꠣꠞ ꠇꠙꠣꠟꠤ ꠖꠡꠣ। ");
INSERT INTO syls_vpl VALUES ("P12_9","090_2_9","1PE","2","9","9","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠁꠟꠣ ꠘꠣꠄ, ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠛꠣꠖꠡꠣꠁ ꠁꠝꠣꠝꠞ ꠖꠟ, ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠔꠤ, ꠔꠣꠘ ꠀꠙꠘ ꠙ꠆ꠞꠎꠣ। ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠘ꠆ꠖꠣꠁꠞ ꠕꠣꠇꠤ ꠘꠤꠎꠞ ꠘꠥꠞꠞ ꠚꠞꠅ ꠖꠣꠅꠔ ꠇꠞꠤ ꠀꠘꠍꠂꠘ, ꠔꠣꠘ ꠉꠥꠘꠉꠣꠘ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("P12_10","090_2_10","1PE","2","10","10","ꠀꠉꠦ ꠔ ꠔꠥꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠙ꠆ꠞꠎꠣ ꠀꠍꠟꠣꠄ ꠘꠣ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠅꠁꠍ। ꠀꠉꠦ ꠔꠣꠘ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠅ ꠙꠣꠁꠍ ꠘꠣ, ꠅꠈꠘ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("P12_11","090_2_11","1PE","2","11","11","ꠜꠣꠁ ꠅꠇꠟ, ꠁ ꠖꠥꠘꠤꠀꠔ ꠔꠥꠝꠞꠣ ꠝꠥꠍꠣꠚꠤꠞ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠡꠞꠤꠟꠞ ꠛꠖ ꠈꠣꠁꠡ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠞꠅ, ꠁꠔꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞ ꠞꠥꠢꠥꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("P12_12","090_2_12","1PE","2","12","12","ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠌꠤꠘꠦ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣ ꠢꠇ ꠙꠕꠦ ꠌꠟꠅ। ꠔꠦꠃ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠡꠤ ꠇꠁꠀ ꠘꠤꠘ꠆ꠖꠣ ꠇꠞꠟꠦꠅ, ꠔꠥꠝꠞꠣꠞ ꠢꠇꠟ ꠜꠣꠟꠣ ꠇꠣꠝ ꠖꠦꠈꠤꠀ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠀꠟ꠆ꠟꠣꠞ ꠉꠃꠞꠛ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("P12_13","090_2_13","1PE","2","13","13","ꠔꠥꠝꠞꠣ ꠝꠣꠟꠤꠇ ꠁꠍꠣꠞ ꠈꠣꠔꠤꠞꠦ ꠝꠣꠘꠡꠞ ꠛꠣꠘꠣꠁꠟ ꠡꠣꠡꠘ-ꠛꠦꠛꠡ꠆ꠔꠣ ꠝꠣꠘꠤꠅ। ꠖꠦꠡꠞ ꠞꠣꠎꠣꠞꠦ ꠝꠣꠘꠤꠅ, ꠄꠁꠘ ꠔ ꠖꠦꠡꠞ ꠙꠞꠗꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("P12_14","090_2_14","1PE","2","14","14","ꠔꠣꠘ ꠝꠘꠔ꠆ꠞꠤ ꠀꠞ ꠢꠣꠇꠤꠝꠞꠦ ꠝꠣꠘꠤꠅ, ꠅꠙꠞꠣꠗꠤꠞ ꠡꠣꠎꠣ ꠀꠞ ꠜꠣꠟꠣ ꠎꠘꠞꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P12_15","090_2_15","1PE","2","15","15","ꠀꠟ꠆ꠟꠣꠞ ꠝꠥꠘꠡꠣ ꠅꠁꠟ, ꠔꠥꠝꠞꠣ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠤꠀ ꠛꠥꠠꠛꠇ ꠝꠣꠘꠡꠞ ꠛꠦꠇꠣꠝꠣ ꠝꠣꠔ-ꠇꠕꠣ ꠛꠘ꠆ꠖ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("P12_16","090_2_16","1PE","2","16","16","ꠔꠥꠝꠞꠣ ꠘꠤꠌ꠆ꠌꠄ ꠡ꠆ꠛꠣꠗꠤꠘ, ꠔꠣ-ꠅ ꠘꠣꠚꠞꠝꠣꠘꠤꠞꠦ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠣꠞ ꠟꠣꠉꠤ ꠁ ꠡ꠆ꠛꠣꠗꠤꠘꠔꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠤꠅ ꠘꠣ। ꠛꠞꠋ ꠘꠤꠎꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠉꠥꠟꠣꠝ ꠝꠘꠅ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("P12_17","090_2_17","1PE","2","17","17","ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠁꠎ꠆ꠎꠔ ꠇꠞꠅ, ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁ ꠅꠇꠟꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ, ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠅ ꠀꠞ ꠖꠦꠡꠞ ꠞꠣꠎꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠦꠅ। ");
INSERT INTO syls_vpl VALUES ("P12_18","090_2_18","1PE","2","18","18","ꠀꠞ ꠛꠣꠠꠤꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠝꠥꠘꠤꠛꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠦꠅ ꠀꠞ ꠔꠣꠞꠣꠞ ꠇꠕꠣꠔ ꠞꠅ। ꠎꠦ ꠝꠥꠘꠤꠛ ꠜꠣꠟꠣ ꠀꠞ ꠖꠄꠀꠟꠥ, ꠈꠣꠟꠤ ꠎꠦꠘ ꠔꠣꠞꠣꠞ ꠇꠕꠣꠔ ꠕꠣꠇꠔꠣꠄ, ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠇꠐꠥ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠇꠕꠣꠔꠅ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("P12_19","090_2_19","1PE","2","19","19","ꠅꠟꠣ ꠇꠦꠃ ꠎꠥꠖꠤ ꠈꠣꠝꠈꠣ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠙꠣꠄ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠀ ꠁꠔꠣ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("P12_20","090_2_20","1PE","2","20","20","ꠅꠛꠁꠡ꠆ꠡ ꠅꠙꠞꠣꠗꠞ ꠟꠣꠉꠤ ꠝꠣꠁꠞ ꠈꠣꠁꠀ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠡꠁꠎ꠆ꠎ ꠇꠞ, ꠔꠦ ꠔꠣꠞꠤꠚ ꠇꠞꠣꠞ ꠇꠥꠘ꠆ꠔꠣ ꠀꠍꠦ ꠘꠤ? ꠅꠁꠟꠦ ꠜꠣꠟꠣ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠡ꠆ꠐ ꠙꠣꠁꠀꠅ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠟꠣꠅ, ꠔꠦ ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠣꠞꠤꠚꠞ ꠟꠣꠈ, ");
INSERT INTO syls_vpl VALUES ("P12_21","090_2_21","1PE","2","21","21","ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠔꠣꠞ ꠟꠣꠉꠤꠃ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ। ꠀꠟ-ꠝꠍꠤꠄꠅ ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠤꠀ ꠘꠝꠥꠘꠣ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠔꠦ ꠔꠥꠝꠞꠣꠅ ꠔꠣꠘ ꠙꠣꠅꠞ ꠔꠣꠟꠦ ꠔꠣꠟꠦ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("P12_22","090_2_22","1PE","2","22","22","ꠔꠣꠁꠘ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠇꠞꠍꠂꠘ ꠘꠣ, ꠔꠣꠘ ꠝꠥꠈꠅ ꠀꠍꠤꠟ ꠘꠣ ꠇꠥꠘꠥ ꠍꠟ-ꠌꠔꠥꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("P12_23","090_2_23","1PE","2","23","23","ꠝꠣꠘꠡꠦ ꠔꠣꠘꠞꠦ ꠉꠣꠟꠤ ꠖꠤꠟꠦꠅ, ꠔꠣꠁꠘ ꠚꠤꠞꠤꠀ ꠉꠣꠟꠤ ꠖꠤꠍꠂꠘ ꠘꠣ। ꠇꠡ꠆ꠐꠞ ꠡꠝꠄ ꠄꠞ ꠛꠖꠟꠣ ꠟꠁꠛꠣ ꠇꠁꠀ ꠒꠞ-ꠜꠄꠅ ꠖꠦꠈꠣꠁꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠎꠦꠁꠘ ꠢꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠂꠘ ꠔꠣꠘ ꠀꠔꠅ ꠘꠤꠎꠞꠦ ꠡꠙꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P12_24","090_2_24","1PE","2","24","24","ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠡꠞꠤꠟ ꠖꠤꠀ ꠀꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠛꠥꠏꠣ ꠛꠁꠍꠂꠘ ꠉꠣꠍꠞ ꠐꠥꠇꠞꠣꠞ ꠍꠟꠤꠛꠅ, ꠎꠣꠔꠦ ꠉꠥꠘꠣꠞ ꠛꠣꠛꠔꠦ ꠀꠝꠞꠣ ꠝꠞꠤꠀ ꠢꠣꠞꠤ, ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤꠄ ꠎꠤꠘ꠆ꠖꠣ ꠞꠁ। ꠔꠣꠘ ꠡꠞꠤꠟꠞ ꠇꠣꠐꠣ-ꠌꠤꠞꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠡꠤꠚꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P12_25","090_2_25","1PE","2","25","25","ꠀꠉꠦ ꠔ ꠔꠥꠝꠞꠣ ꠛꠦ-ꠙꠕꠦ ꠎꠣꠅꠀ ꠝꠦꠠꠣꠞ ꠟꠣꠈꠣꠘ ꠀꠍꠟꠣꠄ, ꠅꠁꠟꠦ ꠎꠦ ꠞꠣꠈꠣꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠖꠦꠈꠣ-ꠢꠥꠘꠣ ꠇꠞꠂꠘ, ꠅꠈꠘ ꠔꠣꠘ ꠉꠦꠍꠦꠃ ꠚꠤꠞꠤꠀ ꠀꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("P13_1","090_3_1","1PE","3","1","1","ꠅꠟꠣꠈꠣꠘ, ꠎꠣꠝꠣꠁꠞ ꠊꠞꠞ ꠢꠇꠟ ꠛꠃꠀꠁꠘ꠆ꠔꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠝꠣꠁꠞ ꠇꠕꠣꠄ ꠌꠟꠅ। ꠎꠥꠖꠤꠅ ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠎꠣꠝꠣꠁꠄ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞꠦ ꠖꠣꠝ ꠖꠦꠄ ꠘꠣ, ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘꠦ ꠎꠣꠘꠥ ꠔꠣꠞꠣꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠛꠣꠄ ꠐꠣꠘꠤꠀ ꠀꠘꠦ। ꠔꠦꠃ ꠁ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣꠞ ꠄꠇꠈꠣꠘ ꠇꠕꠣꠅ ꠝꠣꠔꠣ ꠟꠣꠉꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P13_2","090_3_2","1PE","3","2","2","ꠔꠥꠝꠞꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞ ꠢꠣꠟꠔ ꠖꠦꠈꠤꠀ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠒꠞ-ꠈꠚꠦ ꠌꠟꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠘꠤꠎꠦꠃ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("P13_3","090_3_3","1PE","3","3","3","ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠄ ꠢꠣꠎꠤ-ꠙꠣꠠꠤ ꠌꠥꠟꠞ ꠈꠥꠙꠣ ꠛꠣꠘ꠆ꠖꠤꠀ, ꠡꠥꠘꠣ-ꠞꠥꠙꠣꠞ ꠉꠄꠘꠣ ꠟꠣꠉꠣꠁꠀ, ꠀꠞ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠀ ꠘꠤꠎꠞꠦ ꠢꠣꠎꠣꠘꠤꠔ ꠞꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("P13_4","090_3_4","1PE","3","4","4","ꠛꠞꠋ ꠎꠦ ꠡꠥꠘ꠆ꠖꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠘꠡ꠆ꠐ ꠅꠁꠔ ꠘꠣꠄ, ꠢꠃ ꠘꠝꠥꠘꠣꠄ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤꠞ ꠈꠣꠁꠍꠟꠔ ꠖꠤꠀ ꠘꠤꠎꠞ ꠖꠤꠟꠞꠦ ꠢꠣꠎꠣꠅ। ꠀꠟ꠆ꠟꠣꠞ ꠘꠎꠞꠅ ꠅꠔꠣꠃ ꠔ ꠝꠢꠣ ꠖꠣꠝꠤ। ");
INSERT INTO syls_vpl VALUES ("P13_5","090_3_5","1PE","3","5","5","ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ ꠀꠉꠞ ꠎꠝꠣꠘꠣꠞ ꠀꠟ꠆ꠟꠣꠅꠀꠟꠣ ꠛꠦꠐꠤꠘ꠆ꠔꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠜꠞꠡꠣ ꠇꠞꠤꠀ ꠎꠣꠝꠣꠁꠞ ꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠀ ꠘꠤꠎꠞꠦ ꠢꠣꠎꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("P13_6","090_3_6","1PE","3","6","6","ꠢꠎꠞꠔ ꠁꠛ꠆ꠞꠣꠢꠤꠝꠞ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠅ ꠔꠣꠘ ꠎꠣꠝꠣꠁꠞ ꠛꠣꠁꠖ꠆ꠖ ꠀꠍꠟꠣ ꠀꠞ ꠔꠣꠘꠞꠦ ꠝꠥꠘꠤꠛ ꠇꠁꠀ ꠒꠣꠇꠤꠔꠣ। ꠔꠥꠝꠞꠣꠅ ꠝꠣꠘꠡꠞꠦ ꠘꠣ ꠒꠞꠣꠁꠀ ꠎꠥꠖꠤ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞ, ꠔꠦ ꠅꠇꠐꠣꠃ ꠙꠞꠝꠣꠘ ꠅꠁꠛ, ꠔꠥꠝꠞꠣ ꠛꠤꠛꠤ ꠍꠣꠄꠞꠣꠞ ꠎꠁꠉ꠆ꠉ ꠀꠅꠟꠣꠖ। ");
INSERT INTO syls_vpl VALUES ("P13_7","090_3_7","1PE","3","7","7","ꠀꠞ ꠎꠣꠝꠣꠁ ꠅꠇꠟꠞꠦꠅ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠛꠤꠛꠦꠇ-ꠛꠥꠖ꠆ꠖꠤ ꠈꠣꠐꠣꠁꠀ ꠛꠃꠞ ꠟꠉꠦ ꠌꠟꠅ। ꠔꠣꠞꠣꠅ ꠔ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠞ ꠇꠝꠎꠥꠞ ꠝꠣꠘꠥꠡ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞ ꠖꠣꠘ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠞꠣꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣꠞꠦ ꠁꠎ꠆ꠎꠔ ꠖꠦꠅ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠘꠣꠎꠣꠔ ꠛꠦꠇꠣꠝꠣ ꠘꠣ ꠎꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P13_8","090_3_8","1PE","3","8","8","ꠢꠦꠡꠦ ꠢꠇꠟꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠢꠇꠟ ꠄꠇ-ꠖꠤꠟꠣ ꠅꠅ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠖꠥꠈꠦ ꠖꠥꠈꠤ ꠅꠅ, ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠅ, ꠖꠄꠀꠟꠥ ꠀꠞ ꠘꠞꠝ ꠖꠤꠟꠞ ꠝꠣꠘꠥꠡ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("P13_9","090_3_9","1PE","3","9","9","ꠅꠁꠘ꠆ꠘꠣꠄꠞ ꠛꠖꠟꠣ ꠅꠁꠘ꠆ꠘꠣꠄ ꠇꠞꠤꠅ ꠘꠣ, ꠇꠦꠃ ꠉꠣꠟꠤ ꠖꠤꠟꠦ ꠚꠤꠞꠤꠀ ꠉꠣꠟꠤ ꠖꠤꠅ ꠘꠣ। ꠛꠞꠋ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠥꠀ ꠌꠣꠁꠅ, ꠅꠟꠣ ꠌꠟꠣꠞ ꠟꠣꠉꠤꠃ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠁꠟꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠞꠢꠝꠔ ꠙꠣꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P13_10","090_3_10","1PE","3","10","10","ꠎꠦꠟꠣ ꠎꠛꠥꠞ ꠡꠞꠤꠚꠅ ꠀꠍꠦ, ꠎꠦ ꠎꠘꠦ ꠡꠥꠈꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠔ ꠌꠣꠄ ꠀꠞ ꠡꠥꠖꠤꠘ ꠖꠦꠈꠣꠞ ꠀꠡꠣ ꠇꠞꠦ, ꠢꠦ ꠛꠣꠖ ꠇꠕꠣ ꠕꠣꠇꠤ ꠔꠣꠞ ꠎꠤꠚꠞꠣꠞꠦ, ꠍꠟ-ꠌꠔꠥꠞꠤ ꠕꠣꠇꠤ ꠑꠥꠐꠞꠦ ꠡꠣꠝꠟꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("P13_11","090_3_11","1PE","3","11","11","ꠛꠣꠖ ꠇꠣꠝ ꠕꠣꠇꠤ ꠚꠤꠞꠤꠀ ꠜꠣꠟꠣ ꠇꠣꠝ ꠇꠞꠃꠇ, ꠡꠣꠘ꠆ꠔꠤꠞ ꠀꠡꠤꠇ ꠅꠁꠀ ꠄꠞ ꠈꠞꠦ ꠈꠞꠦ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("P13_12","090_3_12","1PE","3","12","12","ꠙꠞꠦꠎꠉꠣꠞꠞ ꠃꠙꠞꠦ ꠔ ꠝꠣꠛꠥꠖꠞ ꠘꠎꠞ, ꠔꠣꠞꠣꠞ ꠖꠥꠀ ꠢꠥꠘꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠇꠣꠘ ꠈꠣꠠꠣ, ꠅꠁꠟꠦ ꠛꠣꠖ ꠇꠣꠝ ꠇꠞꠞꠣꠞ ꠃꠙꠞꠦ, ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠞ ꠛꠖ ꠘꠎꠞ। ");
INSERT INTO syls_vpl VALUES ("P13_13","090_3_13","1PE","3","13","13","ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠜꠣꠟꠣ ꠜꠣꠟꠣ ꠇꠣꠝꠞ ꠀꠡꠤꠇ ꠅꠅ, ꠔꠦ ꠇꠦ ꠔꠥꠝꠞꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠛ? ");
INSERT INTO syls_vpl VALUES ("P13_14","090_3_14","1PE","3","14","14","ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠙꠕꠦ ꠌꠟꠣꠞ ꠟꠣꠉꠤ ꠎꠥꠖꠤꠅ ꠔꠥꠝꠞꠣꠞ ꠇꠡ꠆ꠐ ꠅꠄ, ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣ ꠝꠥꠛꠣꠞꠇ। ꠀꠞ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠔꠣꠄ ꠒꠞ ꠖꠦꠈꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠒꠞꠣꠁꠅ ꠘꠣ, ꠅꠡ꠆ꠕꠤꠞ ꠅꠁꠅ ꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("P13_15","090_3_15","1PE","3","15","15","ꠛꠞꠋ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠘꠤꠎꠞ ꠖꠤꠟꠅ ꠝꠣꠟꠤꠇ ꠢꠤꠡꠣꠛꠦ ꠇꠛꠥꠟ ꠇꠞꠅ। ꠔꠥꠝꠞꠣꠞ ꠀꠡꠣ-ꠜꠞꠡꠣ ꠎꠥꠖꠤ ꠇꠦꠃ ꠎꠣꠘꠔ ꠌꠣꠄ, ꠔꠦ ꠔꠣꠞ ꠎꠥꠀꠙ ꠖꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠢꠣꠝꠦꠡꠣ ꠎꠥꠁꠔ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("P13_16","090_3_16","1PE","3","16","16","ꠅꠁꠟꠦ ꠁ ꠎꠥꠀꠙ ꠘꠞꠝ ꠡꠥꠞꠦ ꠖꠤꠅ। ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟ ꠍꠣꠚ ꠞꠣꠈꠤꠅ, ꠁꠍꠣꠄꠁ ꠃꠝ꠆ꠝꠔ ꠢꠤꠡꠣꠛꠦ ꠎꠦꠞꠣ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣ ꠌꠣꠟ-ꠌꠟꠘꠞ ꠘꠤꠘ꠆ꠖꠣ ꠇꠞꠦ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("P13_17","090_3_17","1PE","3","17","17","ꠛꠖ ꠇꠣꠝ ꠇꠞꠤꠀ ꠇꠡ꠆ꠐ ꠙꠣꠅꠀ ꠕꠣꠇꠤ ꠔ, ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠅꠁꠟꠦ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠤꠀ ꠇꠡ꠆ꠐ ꠙꠣꠅꠀ ꠛꠃꠔ ꠜꠣꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("P13_18","090_3_18","1PE","3","18","18","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠀꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤꠞ ꠟꠣꠉꠤ ꠀꠟ-ꠝꠍꠤꠄꠅ ꠄꠇꠛꠣꠞ ꠇꠡ꠆ꠐ ꠇꠞꠍꠂꠘ, ꠘꠣꠚꠞꠝꠣꠘꠞꠦ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠢꠃ ꠙꠞꠦꠎꠉꠣꠞ ꠎꠘꠦ ꠎꠣꠘ ꠖꠤꠍꠂꠘ, ꠀꠝꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠙꠃꠍꠣꠘꠤꠞ ꠟꠣꠉꠤ। ꠡꠞꠤꠟꠦ ꠔꠣꠘꠞꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ, ꠅꠁꠟꠦ ꠞꠥꠢꠦ ꠎꠤꠘ꠆ꠖꠣ ꠇꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P13_19","090_3_19","1PE","3","19","19","ꠀꠞ ꠞꠥꠢꠦ ꠔꠣꠁꠘ ꠛꠘ꠆ꠖꠤ ꠞꠥꠢꠥ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠉꠤꠀ ꠔꠛꠟꠤꠉ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P13_20","090_3_20","1PE","3","20","20","ꠅꠃ ꠞꠥꠢꠥ ꠅꠇꠟ ꠔ ꠘꠥꠢ ꠘꠛꠤꠞ ꠎꠝꠣꠘꠣꠞ ꠅꠛꠣꠁꠖ꠆ꠖ ꠝꠣꠘꠡꠞ ꠞꠥꠢꠥ। ꠔꠣꠘ ꠎꠣꠎ ꠛꠣꠘꠣꠘꠤꠞ ꠡꠝꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠝ꠆ꠛꠣ ꠍꠛꠞꠉꠣꠞꠤꠞ ꠇꠣꠟꠅ ꠄꠞꠣ ꠅꠛꠣꠁꠖ꠆ꠖ ꠞꠁꠍꠂꠘ, ꠅꠃ ꠎꠣꠎꠅ ꠃꠑꠤꠀ ꠈꠣꠟꠤ ꠀꠐꠎꠘ ꠝꠣꠘꠡꠦ ꠉꠎꠛꠤ ꠙꠣꠘꠤ ꠕꠣꠇꠤ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("P13_21","090_3_21","1PE","3","21","21","ꠁ ꠙꠣꠘꠤ ꠅꠁꠟ ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠦ ꠔꠞꠤꠇꠣꠛꠘ꠆ꠖꠤꠞ ꠄꠇꠐꠣ ꠘꠤꠡꠣꠘꠣ, ꠎꠦꠔꠣꠄ ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠦ। ꠔꠞꠤꠇꠣꠛꠘ꠆ꠖꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠡꠞꠤꠟꠞ ꠝꠄꠟꠣ ꠍꠣꠚ ꠅꠄ ꠘꠣ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠍꠣꠚ ꠖꠤꠟꠞ ꠡꠣꠄ ꠖꠦꠄ। ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠝꠞꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠦ, ");
INSERT INTO syls_vpl VALUES ("P13_22","090_3_22","1PE","3","22","22","ꠔꠣꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠉꠦꠍꠂꠘ ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠒꠣꠁꠘ ꠉꠣꠟꠣꠞ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠂꠘ। ꠀꠍꠝꠣꠘꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ, ꠈꠦꠝꠔꠣꠞ ꠝꠣꠟꠤꠇ ꠅꠇꠟ ꠀꠞ ꠞꠣꠎꠣ ꠅꠇꠟ ꠔꠣꠘ ꠅꠗꠤꠘꠦ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P14_1","090_4_1","1PE","4","1","1","ꠀꠟ-ꠝꠍꠤꠄ ꠘꠤꠎꠞ ꠡꠞꠤꠟꠅ ꠇꠡ꠆ꠐ ꠡꠁꠎ꠆ꠎ ꠇꠞꠍꠂꠘ ꠇꠞꠤ, ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠜꠣꠛꠞꠦꠅ ꠅꠟꠣꠈꠣꠘ ꠇꠞꠅ। ꠡꠞꠤꠟꠅ ꠎꠣꠞ ꠇꠡ꠆ꠐ ꠅꠁꠍꠦ, ꠢꠦ ꠔ ꠉꠥꠘꠣꠞ ꠎꠣꠟꠅ ꠛꠘ꠆ꠖꠤ ꠞꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("P14_2","090_4_2","1PE","4","2","2","ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠎꠔꠖꠤꠘ ꠖꠥꠘꠤꠀꠔ ꠀꠍꠦ, ꠅꠔꠖꠤꠘ ꠛꠖ ꠈꠣꠁꠡꠦ ꠘꠣ ꠌꠟꠤꠀ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠁ ꠝꠥꠘꠡꠣꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P14_3","090_4_3","1PE","4","3","3","ꠀꠟ꠆ꠟꠣꠞꠦ ꠎꠦꠞꠣ ꠌꠤꠘꠦ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠅ ꠀꠉꠦ ꠎꠤꠘꠣ-ꠛꠖꠝꠣꠁꠡꠤ, ꠝꠃꠎ-ꠚꠥꠞ꠆ꠔꠤ, ꠝꠣꠔꠟꠣꠝꠤ, ꠢꠂ-ꠢꠥꠟ꠆ꠟꠣ ꠀꠞ ꠎꠊꠁꠘ꠆ꠘ ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠇꠞꠤꠀ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠔꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P14_4","090_4_4","1PE","4","4","4","ꠅꠁꠟꠦ ꠅꠈꠘ ꠔꠥꠝꠞꠣ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠅꠁꠀ ꠅꠟꠣꠈꠣꠘ ꠛꠦꠡꠣꠝꠣꠟ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠞꠣꠄ ꠘꠣ ꠖꠦꠈꠤꠀ, ꠔꠣꠞꠣ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠘꠤꠘ꠆ꠖꠣ ꠉꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("P14_5","090_4_5","1PE","4","5","5","ꠔꠣ-ꠅ ꠎꠦꠁꠘ ꠎꠤꠘ꠆ꠖꠣ ꠀꠞ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠛꠤꠌꠣꠞꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠀꠍꠂꠘ, ꠔꠣꠞꠣ ꠔꠣꠘ ꠉꠦꠍꠦꠃ ꠢꠤꠡꠣꠛ-ꠘꠤꠇꠣꠡ ꠖꠤꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("P14_6","090_4_6","1PE","4","6","6","ꠄꠞꠟꠣꠉꠤꠃ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠉꠦꠍꠦꠅ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠎꠣꠔꠦ ꠝꠣꠘꠥꠡ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠞꠣꠞ ꠡꠞꠤꠟꠤ ꠛꠤꠌꠣꠞ ꠅꠁꠟꠦꠅ, ꠞꠥꠢꠣꠘꠤ ꠎꠉꠔꠅ ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠈꠣꠘ ꠎꠤꠘ꠆ꠖꠣ ꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P14_7","090_4_7","1PE","4","7","7","ꠅꠈꠘ ꠔ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠢꠦꠡ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠝꠘꠞꠦ ꠑꠤꠇ ꠇꠞꠅ, ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠅ, ꠎꠣꠔꠦ ꠝꠥꠘꠣꠎꠣꠔꠅ ꠇꠣꠝꠤꠀꠛ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("P14_8","090_4_8","1PE","4","8","8","ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠖꠤꠟ ꠕꠣꠇꠤ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠅ, ꠇꠣꠞꠘ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠦ ꠛꠃꠔ ꠉꠥꠘꠣ ꠉꠥꠞꠤꠀ ꠞꠣꠈꠦ। ");
INSERT INTO syls_vpl VALUES ("P14_9","090_4_9","1PE","4","9","9","ꠇꠥꠘꠥꠎꠣꠔ ꠛꠤꠔꠤꠡꠘꠣ ꠘꠣ ꠖꠦꠈꠣꠁꠀ, ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠝꠦꠝꠣꠘꠖꠣꠞꠤ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("P14_10","090_4_10","1PE","4","10","10","ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠎꠦꠁꠘ ꠎꠦꠟꠣꠈꠣꠘ ꠘꠤꠀꠝꠔ ꠙꠣꠁꠍ, ꠅꠃ ꠗꠘꠞ ꠈꠣꠐꠤ ꠈꠣꠎꠣꠘ꠆ꠌꠤ ꠢꠤꠡꠣꠛꠦ ꠁꠔꠣꠞꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠈꠦꠎꠝꠔꠅ ꠟꠣꠉꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("P14_11","090_4_11","1PE","4","11","11","ꠇꠦꠃ ꠎꠥꠖꠤ ꠔꠛꠟꠤꠉ ꠇꠞꠂꠘ, ꠔꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ ꠎꠣꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠁꠔꠣ ꠀꠟ꠆ꠟꠣꠁ ꠛꠥꠟꠤ। ꠀꠞ ꠎꠦꠁꠘ ꠈꠦꠎꠝꠔ ꠇꠞꠂꠘ, ꠄꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠛꠟ-ꠡꠇ꠆ꠔꠤꠄ ꠈꠦꠎꠝꠔ ꠇꠞꠃꠇ꠆ꠇꠣ, ꠎꠣꠔꠦ ꠢꠇ꠆ꠇꠟꠔꠣꠔꠃ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠅꠄ। ꠔꠣꠞꠤꠚ ꠀꠞ ꠇꠥꠖꠞꠔꠤ ꠈꠦꠝꠔꠣ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠔꠣꠘꠃ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("P14_12","090_4_12","1PE","4","12","12","ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠅꠈꠘ ꠎꠤꠛꠘ-ꠝꠞꠘ ꠙꠞꠤꠇ꠆ꠇꠣꠔ ꠙꠠꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠅ ꠘꠣ, ꠝꠘꠅ ꠇꠞꠤꠅ ꠘꠣ ꠁꠔꠣ ꠀꠌꠣꠘꠇ ꠇꠥꠘ꠆ꠔꠣ ꠊꠐꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("P14_13","090_4_13","1PE","4","13","13","ꠛꠞꠋ ꠔꠥꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠡ꠆ꠐꠞ ꠜꠣꠉꠤ ꠅꠁꠞꠣꠄ ꠇꠞꠤ ꠈꠥꠡꠤ ꠇꠞꠅ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠀꠞ ꠡꠝꠄꠅ ꠔꠥꠝꠞꠣ ꠀꠝꠥꠖ-ꠚꠥꠞ꠆ꠔꠤꠄ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠇꠞꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("P14_14","090_4_14","1PE","4","14","14","ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠛꠦꠁꠎ꠆ꠎꠔ ꠅꠅ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ। ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣ-ꠀꠟꠣ ꠙꠣꠇ ꠞꠥꠢꠥ ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P14_15","090_4_15","1PE","4","15","15","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠦꠃ ꠎꠣꠘꠥ ꠌꠥꠞꠤ, ꠈꠥꠘ ꠛꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠅꠙꠞꠣꠗꠤ ꠢꠤꠡꠣꠛꠦ, ꠄꠝꠘꠇꠤ ꠙꠞꠞ ꠇꠣꠝꠦ ꠘꠣꠇ ꠉꠟꠣꠁꠀ ꠇꠡ꠆ꠐ ꠘꠣ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("P14_16","090_4_16","1PE","4","16","16","ꠅꠁꠟꠦ ꠇꠦꠃ ꠎꠥꠖꠤ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠖꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠞꠦ, ꠔꠦ ꠢꠦ ꠡꠞꠝꠤꠘ꠆ꠖꠣ ꠘꠣ ꠅꠃꠇ, ꠛꠞꠋ ꠁꠍꠣꠄꠁ ꠙꠞꠤꠌꠄꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("P14_17","090_4_17","1PE","4","17","17","ꠛꠤꠌꠣꠞꠞ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠣ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦꠖꠤꠃ ꠛꠤꠌꠣꠞ ꠡꠥꠞꠥ ꠅꠁꠛ। ꠁꠔꠣ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠃ ꠡꠥꠞꠥ ꠅꠄ, ꠔꠦ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠥꠡ-ꠈꠛꠞꠤ ꠝꠣꠘꠍꠦ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠖꠡꠣ ꠇꠤꠟꠣꠘ ꠅꠁꠛ? ");
INSERT INTO syls_vpl VALUES ("P14_18","090_4_18","1PE","4","18","18","ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠞꠣꠁꠀ ꠝꠣꠘꠡꠞ ꠎꠣꠘꠞ ꠍꠖꠝꠣ ꠅꠁꠟꠦ, ꠉꠥꠘꠣꠉꠣꠞ ꠀꠞ ꠛꠦ-ꠖꠤꠘꠦ ꠝꠥꠈ ꠟꠥꠇꠣꠁꠛ ꠇꠥꠀꠁ? ");
INSERT INTO syls_vpl VALUES ("P14_19","090_4_19","1PE","4","19","19","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤꠄ ꠎꠦꠞꠣ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠞꠦꠞ, ꠔꠣꠞꠣ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠤ ꠇꠞꠤ ꠘꠤꠎꠞ ꠎꠣꠘꠞꠦ ꠢꠃ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠙꠄꠖꠣ ꠇꠞꠞꠣꠞ ꠀꠔꠅ ꠡꠙꠤ ꠖꠦꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("P15_1","090_5_1","1PE","5","1","1","ꠅꠈꠘ ꠎꠝꠣꠔꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠅꠇꠟꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠝꠤꠅ ꠔ ꠄꠇꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ, ꠀꠝꠤ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠖꠦꠈꠍꠤ, ꠀꠞ ꠔꠣꠘ ꠎꠦ ꠝꠢꠤꠝꠣ ꠎꠣꠁꠞ ꠅꠁꠛ, ꠅꠃ ꠝꠢꠤꠝꠣꠔꠅ ꠡꠞꠤꠇ ꠅꠁꠝꠥ। ꠀꠝꠤ ꠝꠤꠘꠔ ꠇꠞꠤ ꠇꠁꠞꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("P15_2","090_5_2","1PE","5","2","2","ꠀꠟ꠆ꠟꠣꠁ ꠎꠦ ꠝꠦꠠꠣꠞ ꠙꠣꠟ ꠔꠥꠝꠞꠣꠞ ꠀꠅꠔꠣꠄ ꠀꠍꠂꠘ, ꠄꠞꠣꠞ ꠞꠣꠈꠣꠟꠤ ꠇꠞꠅ। ꠔꠣꠞꠣꠞ ꠁꠝꠣꠝꠔꠤ ꠇꠞꠅ, ꠇꠞꠣ ꠟꠣꠉꠛ ꠇꠞꠤ ꠘꠣ ꠇꠞꠤꠀ ꠛꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠟꠣꠜꠞ ꠀꠡꠣꠄ ꠘꠣ ꠇꠞꠤꠀ, ꠈꠥꠡ ꠖꠤꠟꠦ ꠇꠞꠅ। ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠅꠟꠣ ꠁꠝꠣꠝꠔꠤꠃ ꠀꠡꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P15_3","090_5_3","1PE","5","3","3","ꠔꠥꠝꠞꠣꠞ ꠀꠅꠔꠣꠄ ꠎꠦꠞꠣ ꠀꠍꠦ, ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠝꠥꠍꠖ꠆ꠖꠞꠤ ꠇꠞꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠙꠣꠟꠞ ꠞꠣꠈꠣꠟꠤ ꠇꠞꠤꠀ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠘꠝꠥꠘꠣ ꠛꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("P15_4","090_5_4","1PE","5","4","4","ꠔꠦꠃ ꠢꠃ ꠙꠞꠗꠣꠘ ꠞꠣꠈꠣꠟ ꠁꠍꠣꠄ ꠎꠦꠛꠟꠣ ꠖꠥꠘꠤꠀꠔ ꠢꠤꠞꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠢꠤꠡꠣꠛꠦ ꠅꠟꠣ ꠄꠇ ꠎꠄꠅꠞ ꠝꠣꠟꠣ ꠙꠣꠁꠛꠣꠄ ꠎꠦꠔꠣ ꠇꠥꠘꠥꠖꠤꠘ ꠛꠤꠘꠣꠡ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P15_5","090_5_5","1PE","5","5","5","ꠅꠃ ꠟꠣꠈꠣꠘ ꠎꠥꠀꠘ ꠅꠇꠟꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠝꠥꠞꠛ꠆ꠛꠤꠞꠦ ꠝꠣꠘꠤꠀ ꠌꠟꠅ। ꠉꠥꠟꠣꠝꠤꠞ ꠛꠦꠡꠦ ꠢꠇꠟꠦꠃ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞ ꠈꠦꠎꠝꠔ ꠇꠞꠅ, ꠎꠦꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠅ ꠀꠍꠦ, ꠀꠟ꠆ꠟꠣꠄ ꠅꠢꠋꠇꠣꠞꠤꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠕꠣꠇꠂꠘ, ꠘꠞꠝ ꠖꠤꠟꠞ ꠝꠣꠘꠡꠞꠦ ꠞꠢꠝ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P15_6","090_5_6","1PE","5","6","6","ꠄꠞꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣꠞ ꠈꠦꠝꠔꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣ ꠘꠔ ꠅꠅ, ꠔꠦꠃ ꠡꠝꠄ ꠝꠔ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠌꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("P15_7","090_5_7","1PE","5","7","7","ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠁꠀꠃ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠢꠇꠟ ꠌꠤꠘ꠆ꠔꠣ-ꠜꠣꠛꠘꠣꠞ ꠜꠣꠞ ꠔꠣꠘ ꠃꠙꠞꠦ ꠖꠤꠟꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("P15_8","090_5_8","1PE","5","8","8","ꠔꠥꠝꠞꠣ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠁꠀ ꠞꠣꠈꠅ ꠀꠞ ꠢꠥꠡꠤꠀꠞ ꠅꠅ। ꠇꠣꠞꠘ ꠔꠥꠝꠞꠣꠞ ꠖꠥꠡꠝꠘ ꠁꠛꠟꠤꠍꠦ ꠉꠞ꠆ꠎꠘ ꠇꠞꠞꠣ ꠛꠣꠊꠞ ꠟꠣꠈꠣꠘ, ꠔꠥꠝꠞꠣꠞꠦ ꠈꠣꠁꠟꠤꠔ ꠇꠞꠤ ꠈꠣꠙ ꠗꠞꠤꠀ ꠊꠥꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("P15_9","090_5_9","1PE","5","9","9","ꠄꠞꠟꠣꠉꠤ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠁꠀ ꠔꠣꠞ ꠝꠥꠇꠣꠛꠤꠟꠣ ꠇꠞꠅ। ꠔꠥꠝꠞꠣ ꠔ ꠎꠣꠘ, ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠉꠣꠔ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠖꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠦ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠞꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("P15_10","090_5_10","1PE","5","10","10","ꠞꠢꠝꠣꠘꠥꠞ ꠞꠢꠤꠝ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠅꠁꠀ ꠔꠣꠘ ꠌꠤꠞꠡ꠆ꠕꠣꠄꠁ ꠝꠢꠤꠝꠣꠞ ꠜꠣꠉꠤ ꠅꠀꠞ ꠟꠣꠉꠤ। ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠖꠥꠈ-ꠇꠡ꠆ꠐ ꠇꠞꠤꠀ ꠢꠣꠞꠟꠦ, ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠑꠤꠇ-ꠑꠣꠇ ꠇꠞꠛꠣ ꠀꠞ ꠕꠤꠞ ꠞꠣꠈꠛꠣ, ꠔꠥꠝꠞꠣꠞꠦ ꠛꠟꠛꠣꠘ ꠇꠞꠤꠀ ꠝꠎꠛꠥꠔ ꠈꠥꠐꠤꠞ ꠃꠙꠞꠦ ꠈꠣꠠꠣ ꠇꠞꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("P15_11","090_5_11","1PE","5","11","11","ꠔꠣꠘ ꠞꠣꠎ-ꠈꠦꠝꠔꠣ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠣꠞꠤ ꠞꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("P15_12","090_5_12","1PE","5","12","12","ꠅꠃ ꠌꠤꠑꠤꠈꠣꠘ ꠀꠝꠤ ꠍꠤꠟꠣꠍ ꠝꠢꠞꠤꠞ ꠍꠣꠛꠞꠦꠖꠤ ꠈꠥꠛ ꠇꠝ ꠇꠕꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠣꠁꠍꠤ, ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠜꠣꠁ ꠝꠘꠅ ꠇꠞꠤ। ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠞꠢꠝꠔꠞ ꠅꠃ ꠡꠣꠇ꠆ꠇꠤ ꠢꠥꠘꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠡꠣꠅꠡ ꠛꠣꠠꠃꠇ, ꠀꠞ ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠕꠤꠞ ꠅꠁꠀ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("P15_13","090_5_13","1PE","5","13","13","ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠎꠦꠞꠣꠞꠦ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠢꠃ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘꠞ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ, ꠀꠞ ꠀꠝꠣꠞ ꠗꠞ꠆ꠝꠞ ꠙꠥꠀ ꠝꠣꠞ꠆ꠇꠥꠍꠦꠅ ꠔꠥꠝꠞꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("P15_14","090_5_14","1PE","5","14","14","ꠔꠥꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠢꠛ꠆ꠛꠔꠦ ꠉꠟꠣꠉꠟꠤ ꠇꠞꠤꠅ। ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠀꠙꠘ ꠎꠘ ꠅꠁꠍ, ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠡꠣꠘ꠆ꠔꠤ ꠘꠣꠎꠤꠟ ꠅꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("P21_1","091_1_1","2PE","1","1","1","ꠀꠝꠤ ꠍꠣꠁꠝꠘ-ꠙꠤꠔꠞ, ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠄꠇꠎꠘ ꠉꠥꠟꠣꠝ ꠀꠞ ꠍꠣꠢꠣꠛꠤ। ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠀꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ, ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤꠄ ꠄꠇꠁ ꠟꠣꠈꠣꠘ ꠝꠢꠣ ꠖꠣꠝꠤ ꠁꠝꠣꠘ ꠢꠣꠍꠤꠟ ꠇꠞꠍ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("P21_2","091_1_2","2PE","1","2","2","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠢꠎꠞꠔ ꠁꠍꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠘꠣꠞ ꠝꠣꠎꠖꠤ, ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠡ ꠇꠞꠤ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠘꠣꠎꠤꠟ ꠅꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("P21_3","091_1_3","2PE","1","3","3","ꠎꠦꠁꠘ ꠔꠣꠘ ꠘꠤꠎꠞ ꠝꠢꠤꠝꠣ ꠀꠞ ꠉꠥꠘꠦ ꠀꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ, ꠔꠣꠘꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠘꠣꠞ ꠝꠣꠎꠖꠤ ꠔꠣꠘ ꠇꠥꠖꠞꠔꠦ ꠀꠝꠞꠣ ꠅꠟꠣ ꠘꠤꠀꠝꠔ ꠙꠣꠁꠍꠤ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘꠤꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("P21_4","091_1_4","2PE","1","4","4","ꠔꠣꠘ ꠝꠢꠤꠝꠣ ꠀꠞ ꠉꠥꠘꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠝꠢꠣ ꠖꠣꠝꠤ ꠀꠞ ꠛꠃꠔ ꠛꠠ ꠛꠠ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠛꠤ ꠢꠇꠟ ꠛꠖ ꠈꠣꠁꠡ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠀꠟ꠆ꠟꠣꠁ ꠉꠥꠘꠞ ꠜꠣꠉꠤ ꠅꠅ। ");
INSERT INTO syls_vpl VALUES ("P21_5","091_1_5","2PE","1","5","5","ꠄꠞꠖꠣꠄ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ, ꠁꠝꠣꠘꠞ ꠟꠉꠦ ꠘꠦꠇ ꠈꠣꠁꠍꠟꠔ, ꠘꠦꠇ ꠈꠣꠁꠍꠟꠔꠞ ꠟꠉꠦ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠌꠤꠘꠣꠞ ꠀꠈꠟ, ");
INSERT INTO syls_vpl VALUES ("P21_6","091_1_6","2PE","1","6","6","ꠁ ꠀꠈꠟꠞ ꠟꠉꠦ ꠘꠤꠎꠞꠦ ꠡꠣꠝꠟꠣꠘꠤ, ꠡꠣꠝꠟꠣꠘꠤꠞ ꠟꠉꠦ ꠗꠂꠎ꠆ꠎ ꠀꠞ ꠗꠂꠎ꠆ꠎꠞ ꠟꠉꠦ ꠙꠞꠦꠎꠉꠣꠞꠤ, ");
INSERT INTO syls_vpl VALUES ("P21_7","091_1_7","2PE","1","7","7","ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠟꠉꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠣꠄꠀ, ꠀꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠣꠄꠀꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠁ ꠝꠢꠛ꠆ꠛꠔꠦ ꠛꠣꠠꠅ। ");
INSERT INTO syls_vpl VALUES ("P21_8","091_1_8","2PE","1","8","8","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠥꠖꠤ ꠁꠔꠣ ꠉꠥꠘꠣꠉꠥꠘ ꠕꠣꠇꠦ, ꠀꠞ ꠁꠔꠣ ꠜꠞꠤꠀ ꠙꠠꠣꠔ ꠞꠄ, ꠔꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠌꠤꠘꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠦꠇꠣꠝꠣ-ꠛꠦꠢꠥꠖꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P21_9","091_1_9","2PE","1","9","9","ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠞ ꠝꠣꠎꠦ ꠁꠔꠣ ꠉꠥꠘꠣꠉꠥꠘ ꠘꠣꠁ, ꠢꠦ ꠔ ꠀꠘ꠆ꠖꠣ, ꠢꠦ ꠇꠥꠘ꠆ꠔꠣꠃ ꠛꠥꠎꠦ ꠘꠣ। ꠇꠣꠞꠘ ꠀꠉꠞ ꠎꠦ ꠉꠥꠘꠣ ꠕꠣꠇꠤ ꠔꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠁꠈꠣꠘ ꠢꠦ ꠚꠣꠃꠞꠤꠟꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P21_10","091_1_10","2PE","1","10","10","ꠄꠞꠟꠣꠉꠤ ꠜꠣꠁ ꠅꠇꠟ ꠢꠥꠘꠅ, ꠀꠟ꠆ꠟꠣꠄ ꠎꠦꠘ ꠢꠣꠍꠣꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠤꠍꠂꠘ ꠀꠞ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠁꠔꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠛꠦꠡꠤ ꠈꠤꠀꠟꠤ ꠅꠅ। ꠁꠟꠣ ꠇꠞꠟꠦ ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥ ꠡꠝꠄ ꠃꠡ꠆ꠐꠣ ꠈꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P21_11","091_1_11","2PE","1","11","11","ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠛꠣꠖꠡꠣꠁꠔ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠖꠞ ꠇꠞꠤ ꠢꠣꠞꠣꠁꠟ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("P21_12","091_1_12","2PE","1","12","12","ꠄꠞꠟꠣꠉꠤ, ꠀꠝꠤ ꠢꠣꠝꠦꠡꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠝꠘꠅ ꠇꠞꠣꠁ ꠖꠤꠞꠣꠝ, ꠎꠥꠖꠤꠅ ꠁꠔꠣ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠎꠦ ꠢꠇꠤꠇꠔ ꠀꠁꠍꠦ, ꠁꠔꠣꠔ ꠕꠤꠞꠅ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("P21_13","091_1_13","2PE","1","13","13","ꠀꠍꠟꠦ ꠀꠝꠤ ꠝꠘꠅ ꠇꠞꠞꠣꠝ, ꠀꠝꠤ ꠎꠔꠖꠤꠘ ꠔꠣꠝ꠆ꠛꠥꠞ ꠟꠣꠈꠣꠘ ꠅꠃ ꠡꠞꠤꠟꠦ ꠛꠣꠌꠤꠀ ꠞꠁꠝꠥ, ꠅꠔꠖꠤꠘ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠔꠣ ꠝꠘꠅ ꠇꠞꠣꠁ ꠖꠤꠀ ꠢꠎꠣꠉ ꠞꠣꠈꠣ ꠃꠌꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("P21_14","091_1_14","2PE","1","14","14","ꠇꠣꠞꠘ ꠀꠝꠤ ꠔ ꠀꠞ ꠛꠦꠡꠤ ꠖꠤꠘ ꠅꠃ ꠡꠞꠤꠟꠦ ꠞꠁꠔꠣꠝ ꠘꠣꠄ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠁꠈꠣꠘ ꠀꠝꠣꠞꠦ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠎꠣꠘꠣꠁ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P21_15","091_1_15","2PE","1","15","15","ꠔꠦ ꠀꠝꠣꠞ ꠝꠃꠔꠞ ꠛꠣꠖꠦꠅ ꠢꠣꠝꠦꠡꠣ ꠎꠣꠔꠦ ꠅꠔꠣ ꠝꠘꠅ ꠞꠣꠈꠔꠣꠄ ꠙꠣꠞ, ꠀꠝꠤ ꠅꠃ ꠝꠦꠘꠔꠅ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("P21_16","091_1_16","2PE","1","16","16","ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠇꠥꠖꠞꠔꠤ ꠡꠇ꠆ꠔꠤ ꠀꠞ ꠔꠣꠘ ꠢꠤꠞꠛꠣꠞ ꠔꠡꠞꠤꠚ ꠀꠘꠣꠞ ꠇꠕꠣ ꠎꠣꠘꠣꠘꠤꠔ ꠉꠤꠀ, ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠛꠣꠘꠣꠁꠟ ꠇꠤꠌ꠆ꠍꠣ ꠇꠁꠍꠤ ꠘꠣ। ꠀꠝꠞꠣ ꠔ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠔꠣꠘ ꠝꠢꠤꠝꠣ ꠖꠦꠈꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("P21_17","091_1_17","2PE","1","17","17","ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠎꠣꠟꠣꠟ ꠀꠞ ꠡꠣꠘꠞ ꠎꠦ ꠀꠅꠀꠎ ꠀꠁꠟ, “ꠄꠁꠘꠃ ꠀꠝꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠄꠘ ꠃꠙꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ,” ꠅꠃ ꠀꠅꠀꠎꠞ ꠝꠣꠎꠖꠤ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠉꠃꠞꠛ ꠙꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P21_18","091_1_18","2PE","1","18","18","ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠣꠘ ꠟꠉꠦ ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠙꠣꠠꠅ ꠀꠍꠟꠣꠝ, ꠅꠃ ꠡꠝꠄ ꠘꠤꠎꠞ ꠇꠣꠘꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠅꠃ ꠉꠣꠁꠛꠤ ꠀꠅꠀꠎ ꠢꠥꠘꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("P21_19","091_1_19","2PE","1","19","19","ꠀꠞ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠞꠅ ꠛꠠ ꠙꠞꠝꠣꠘ ꠅꠁꠟ, ꠙꠣꠇ ꠇꠤꠔꠣꠛꠅ ꠘꠛꠤ ꠅꠇꠟꠦ ꠎꠔꠔꠣ ꠛꠣꠔꠣꠁ ꠉꠦꠍꠂꠘ। ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠞꠣꠞ ꠌꠃꠈ ꠎꠦꠟꠣꠈꠣꠘ ꠞꠥꠡꠘꠤꠞ ꠛꠣꠄ ꠕꠣꠇꠦ, ꠑꠤꠇ ꠅꠟꠣꠈꠣꠘ ꠎꠔ ꠡꠝꠄ ꠛꠤꠀꠘ ꠅꠁꠍꠦ ꠘꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠚꠎꠞꠞ ꠡꠥꠇ-ꠔꠦꠞꠣ ꠃꠑꠍꠦ ꠘꠣ, ꠅꠔ ꠡꠝꠄ ꠔꠥꠝꠞꠣ ꠘꠛꠤ ꠅꠇꠟꠞ ꠇꠕꠣꠄ ꠈꠤꠀꠟꠤ ꠅꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("P21_20","091_1_20","2PE","1","20","20","ꠀꠞ ꠈꠣꠍ ꠇꠞꠤ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠇꠤꠔꠣꠛꠞ ꠝꠣꠎꠞ ꠇꠥꠘꠥ ꠇꠕꠣ ꠘꠛꠤ ꠅꠇꠟꠞ ꠝꠘꠉꠠꠣ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P21_21","091_1_21","2PE","1","21","21","ꠇꠣꠞꠘ ꠘꠛꠤ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠁꠌ꠆ꠍꠣꠝꠔ ꠇꠥꠘꠥ ꠇꠕꠣ ꠇꠁꠍꠂꠘ ꠘꠣ, ꠈꠣꠟꠤ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠛꠥꠟꠤ ꠛꠣꠔꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P22_1","091_2_1","2PE","2","1","1","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠝꠣꠎꠦ ꠎꠦꠟꠣ ꠜꠘ꠆ꠒ ꠘꠛꠤ ꠅꠇꠟ ꠀꠍꠟꠣ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦꠅ ꠅꠃꠟꠣ ꠜꠘ꠆ꠒ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟ ꠕꠣꠇꠛꠣ। ꠔꠣꠞꠣ ꠟꠥꠇꠣꠁ ꠟꠥꠇꠣꠁ ꠅꠝꠘ ꠜꠥꠟ ꠔꠣꠟꠤꠝ ꠖꠤꠛ, ꠎꠦ ꠔꠣꠟꠤꠝꠦ ꠝꠣꠘꠡꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠦ ꠀꠞ ꠎꠦ ꠝꠣꠟꠤꠇꠦ ꠔꠣꠞꠣꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠞꠤꠖ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠝꠣꠟꠤꠇꠞꠦ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠔꠣꠞꠣ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠛ। ꠅꠟꠣꠈꠣꠘ ꠈꠥꠛ ꠎꠟꠖꠤ ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠃꠙꠞꠦ ꠛꠤꠘꠣꠡ ꠒꠣꠇꠤꠀ ꠀꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("P22_2","091_2_2","2PE","2","2","2","ꠔꠣꠞꠣꠞ ꠖꠦꠈꠣ-ꠖꠦꠈꠤ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠈꠛꠤꠍꠤ ꠙꠕꠦ ꠎꠣꠁꠛ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠃ ꠁꠍꠣꠄꠁ ꠢꠇ ꠔꠞꠤꠇꠣꠞ ꠛꠖꠘꠣꠝ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("P22_3","091_2_3","2PE","2","3","3","ꠟꠥꠜ-ꠟꠣꠟꠌ ꠇꠞꠤꠀ ꠍꠟ-ꠌꠔꠥꠞꠤꠞ ꠝꠣꠔ ꠝꠣꠔꠤꠀ, ꠘꠤꠎꠞ ꠟꠣꠜꠞ ꠀꠡꠣꠄ ꠔꠣꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠣꠝꠅ ꠟꠣꠉꠣꠁꠛ। ꠔꠣꠞꠣꠞ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ ꠔ ꠛꠃꠔ ꠖꠤꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠌꠣꠞ, ꠔꠣꠞꠣꠞ ꠛꠤꠘꠣꠡꠅ ꠛꠦꠡꠤ ꠖꠦꠞꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P22_4","091_2_4","2PE","2","4","4","ꠄꠝꠘꠇꠤ ꠀꠉꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠎꠦꠛꠟꠣ ꠉꠥꠘꠣ ꠇꠞꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠞꠦꠢꠣꠁ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠖꠥꠎꠈꠞ ꠀꠘ꠆ꠖꠣꠁꠞꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁꠀ ꠔꠣꠞꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠞꠣꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P22_5","091_2_5","2PE","2","5","5","ꠀꠞ ꠔꠣꠁꠘ ꠢꠃ ꠀꠉꠞ ꠖꠥꠘꠤꠀꠞꠦꠅ ꠞꠦꠢꠣꠁ ꠖꠤꠍꠂꠘ ꠘꠣ, ꠛꠞꠋ ꠅꠃ ꠛꠦ-ꠖꠤꠘ ꠅꠇꠟꠞꠦ ꠛꠁꠘ꠆ꠘꠣꠞ ꠙꠣꠘꠤꠖꠤ ꠝꠣꠞꠍꠂꠘ। ꠅꠁꠟꠦ ꠘꠥꠢ ꠘꠛꠤ ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠡꠣꠔ ꠎꠘꠞꠦ ꠔꠣꠁꠘ ꠛꠣꠌꠣꠁꠍꠂꠘ। ꠇꠣꠞꠘ ꠘꠥꠢ ꠘꠛꠤꠄ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("P22_6","091_2_6","2PE","2","6","6","ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠍꠣꠖꠥꠝ ꠀꠞ ꠀꠝꠥꠞꠣ ꠐꠣꠃꠘꠞꠦ ꠀꠉꠥꠁꠘ ꠖꠤꠀ ꠎꠣꠟꠣꠁꠀ ꠍꠣꠟꠤ ꠇꠞꠤꠀ, ꠅꠘꠞ ꠝꠣꠘꠡꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠍꠟꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠔꠣꠁꠘ ꠖꠦꠈꠣꠁꠍꠟꠣ, ꠛꠦ-ꠖꠤꠘ ꠅꠇꠟꠞ ꠖꠡꠣ ꠇꠤꠟꠣꠈꠣꠘ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("P22_7","091_2_7","2PE","2","7","7","ꠔꠣ-ꠅ ꠟꠥꠔ ꠘꠛꠤꠞꠦ ꠔꠣꠁꠘ ꠛꠣꠌꠣꠁꠍꠂꠘ। ꠄꠁꠘ ꠔ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠣꠘꠥꠡ ꠀꠍꠟꠣ, ꠢꠤꠘꠞ ꠘꠣꠚꠞꠝꠣꠘ ꠅꠇꠟꠞ ꠛꠦꠡꠣꠝꠣꠟ ꠜꠣꠛ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠘ ꠈꠥꠛ ꠇꠡ꠆ꠐ ꠙꠣꠁꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("P22_8","091_2_8","2PE","2","8","8","ꠖꠤꠘ ꠖꠤꠘ ꠔꠣꠞꠣꠞ ꠀꠇꠣꠝ-ꠇꠥꠇꠣꠝ ꠀꠞ ꠇꠕꠣꠛꠣꠞ꠆ꠔꠣ ꠢꠥꠘꠔꠣ। ꠡꠞꠤꠅꠔꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠔꠣꠞꠣꠞ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠖꠦꠈꠤꠀ, ꠅꠃ ꠙꠞꠦꠎꠉꠣꠞ ꠎꠘꠞ ꠝꠘꠅ ꠈꠥꠛ ꠖꠥꠈ ꠟꠣꠉꠔ। ");
INSERT INTO syls_vpl VALUES ("P22_9","091_2_9","2PE","2","9","10","ꠅꠔꠣ ꠕꠣꠇꠤ ꠖꠦꠈꠣ ꠎꠣꠞ, ꠀꠟ꠆ꠟꠣꠄ ꠔ ꠙꠞꠦꠎꠉꠣꠞ ꠝꠣꠘꠡꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠅ ꠛꠣꠌꠣꠁꠔꠣ ꠙꠣꠞꠂꠘ। ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠛꠦ-ꠖꠤꠘꠤ ꠇꠣꠝ ꠇꠞꠦ, ꠈꠣꠍ ꠇꠞꠤ ꠎꠦꠞꠣ ꠈꠛꠤꠍꠤ ꠇꠞꠦ, ꠇꠥꠘꠥ ꠡꠣꠡꠘ ꠝꠣꠘꠦ ꠘꠣ, ꠔꠣꠞꠣꠞꠦ ꠡꠣꠎꠣ ꠖꠦꠅꠀꠐꠣ ꠇꠤꠀꠝꠔ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠞꠣꠈꠔꠣꠅ ꠙꠣꠞꠂꠘ। ꠁ ꠜꠘ꠆ꠒ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟ ꠈꠥꠛ ꠛꠖ-ꠡꠣꠅꠡꠤ। ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠁꠌ꠆ꠍꠣꠝꠔ ꠌꠟꠦ ꠀꠞ ꠛꠣꠔꠥꠘꠤ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠔꠦ ꠒꠞꠣꠄ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("P22_11","091_2_11","2PE","2","11","11","ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠡꠇ꠆ꠔꠤ ꠀꠞ ꠈꠦꠝꠔꠣꠄ ꠄꠞꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠛꠠ ꠅꠁꠟꠦꠅ, ꠅꠃ ꠛꠣꠔꠥꠘꠤ ꠡꠞ꠆ꠖꠣꠞꠞ ꠛꠤꠙꠇ꠆ꠇꠦ ꠝꠣꠛꠥꠖꠞ ꠖꠞꠛꠣꠞꠅ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠀ ꠇꠥꠘꠥ ꠘꠣꠟꠤꠡ ꠖꠦꠁꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("P22_12","091_2_12","2PE","2","12","12","ꠛꠦꠀꠈꠟ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞ ꠅꠇꠟꠦ ꠘꠣ ꠛꠥꠎꠤꠀ ꠎꠦꠟꠣ ꠘꠤꠎꠞ ꠈꠥꠡꠤꠄ ꠌꠟꠦ ꠀꠞ ꠗꠞꠣ ꠈꠣꠁꠀ ꠝꠞꠦ, ꠅꠃ ꠜꠘ꠆ꠒ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟꠅ ꠅꠔꠣꠞ ꠟꠣꠈꠣꠘ। ꠔꠣꠞꠣ ꠎꠦꠔꠣ ꠛꠥꠎꠦ ꠘꠣ, ꠅꠔꠣꠞꠅ ꠛꠖꠘꠣꠝ ꠉꠣꠄ। ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞ ꠛꠤꠘꠣꠡ ꠀꠍꠦ, ");
INSERT INTO syls_vpl VALUES ("P22_13","091_2_13","2PE","2","13","13","ꠈꠣꠞꠣꠙꠤꠞ ꠛꠖꠟꠣ ꠛꠣꠛꠔ ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠈꠣꠞꠣꠙꠤ ꠀꠍꠦ। ꠖꠤꠘꠞ ꠛꠦꠟꠣꠄꠅ ꠝꠃꠎ-ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠤꠀ ꠝꠖ ꠈꠣꠁꠔꠦ ꠔꠣꠞꠣꠞ ꠜꠣꠟꠣ ꠟꠣꠉꠦ। ꠔꠣꠞꠣ ꠔ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤꠞ ꠕꠣꠟꠞ ꠕꠥ ꠀꠞ ꠉꠥ। ꠔꠣꠞꠣ ꠎꠦꠛꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠁꠀ ꠝꠦꠎꠛꠣꠘꠤ ꠈꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠞꠣ ꠜꠘ꠆ꠒꠣꠝꠤ ꠇꠞꠔꠦ ꠈꠥꠛ ꠀꠞꠣꠝ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P22_14","091_2_14","2PE","2","14","14","ꠔꠣꠞꠣꠞ ꠌꠃꠈ ꠎꠤꠘꠣꠄ ꠜꠞꠣ, ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠇꠥꠘꠥ ꠡꠝꠄ ꠛꠘ꠆ꠖ ꠇꠞꠦ ꠘꠣ। ꠅꠡ꠆ꠕꠤꠞ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠙꠕꠦ ꠐꠣꠘꠤꠀ ꠘꠦꠄ। ꠔꠣꠞꠣꠞ ꠝꠘ ꠟꠥꠜ-ꠟꠣꠟꠌꠞ ꠃꠡ꠆ꠔꠣꠖ। ꠁꠉꠥꠁꠘ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ! ");
INSERT INTO syls_vpl VALUES ("P22_15","091_2_15","2PE","2","15","15","ꠔꠣꠞꠣ ꠛꠣꠟꠣꠝ ꠛꠤꠘ ꠛꠣꠃꠞꠞ ꠟꠣꠈꠣꠘ ꠍꠢꠤ ꠙꠕ ꠍꠣꠠꠤꠀ ꠛꠦ-ꠙꠕꠦ ꠉꠦꠍꠦꠉꠤ। ꠅꠃ ꠜꠘ꠆ꠒ ꠙꠤꠞ ꠛꠣꠟꠣꠝ ꠔ ꠢꠣꠞꠣꠝ ꠇꠣꠝꠣꠁ-ꠞꠥꠎꠉꠣꠞꠞ ꠙꠣꠉꠟ ꠀꠍꠤꠟ, ");
INSERT INTO syls_vpl VALUES ("P22_16","091_2_16","2PE","2","16","16","ꠅꠁꠟꠦ ꠅꠟꠣ ꠛꠖ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠢꠦ ꠛꠥꠛꠣ ꠉꠣꠗꠣꠞ ꠗꠝꠇ ꠈꠣꠁꠍꠦ। ꠅꠃ ꠉꠣꠗꠣꠄ ꠝꠣꠘꠥꠡ ꠛꠥꠟꠤꠄ ꠝꠣꠔꠤꠀ ꠔꠣꠞ ꠙꠣꠉꠟꠣꠝꠤꠔ ꠛꠣꠗꠣ ꠖꠤꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P22_17","091_2_17","2PE","2","17","17","ꠁꠔꠣ ꠝꠣꠘꠥꠡ ꠔ ꠙꠣꠘꠤꠞ ꠢꠥꠇꠘꠣ ꠇꠥꠀꠞ ꠟꠣꠈꠣꠘ ꠀꠞ ꠛꠣꠔꠣꠡꠞ ꠇꠥꠠꠥꠟ꠆ꠟꠣꠞ ꠟꠣꠈꠣꠘ। ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠉꠁꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠎꠝꠣ ꠞꠣꠈꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("P22_18","091_2_18","2PE","2","18","18","ꠔꠣꠞꠣ ꠛꠠ ꠛꠠ ꠛꠦꠇꠣꠝꠣ ꠝꠣꠔ ꠝꠣꠔꠦ। ꠀꠞ ꠎꠦꠞꠣ ꠕꠥꠠꠣ ꠀꠉꠦ ꠇꠥ-ꠙꠕ ꠍꠣꠠꠤꠀ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠜꠣꠉꠤꠍꠂꠘ, ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠡꠞꠤꠟꠞ ꠈꠣꠁꠡꠦ ꠌꠟꠤꠀ ꠛꠖꠝꠣꠁꠡꠤ ꠇꠞꠣꠞ ꠁꠘ꠆ꠗꠘ ꠖꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("P22_19","091_2_19","2PE","2","19","19","ꠢꠃ ꠜꠘ꠆ꠒ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠄ ꠝꠣꠘꠡꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠔ, ꠅꠁꠟꠦ ꠔꠣꠞꠣ ꠘꠤꠎꠦꠃ ꠘꠚꠞꠔꠤ ꠇꠣꠝꠞ ꠉꠥꠟꠣꠝ। ꠎꠣꠘ ꠔ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘ꠆ꠔꠣꠞ ꠉꠦꠍꠦ ꠀꠞꠤꠎꠣꠄ, ꠔꠦ ꠢꠦ ꠁꠔꠣꠞ ꠉꠥꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("P22_20","091_2_20","2PE","2","20","20","ꠔꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠀꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠌꠤꠘꠤꠀ ꠢꠣꠞꠤ ꠎꠉꠔꠞ ꠈꠣꠞꠣꠙꠤ ꠕꠣꠇꠤ ꠢꠞꠤꠀ ꠀꠁꠀꠅ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠢꠤꠞꠛꠣꠞ ꠉꠤꠀ ꠅꠃ ꠈꠣꠞꠣꠙꠤꠞ ꠎꠣꠟꠅ ꠀꠐꠇꠣꠄ, ꠔꠦ ꠔꠣꠞꠣꠞ ꠙꠄꠟꠣ ꠖꠡꠣ ꠕꠣꠇꠤ ꠢꠦꠡ ꠖꠡꠣ ꠀꠞꠅ ꠝꠘ꠆ꠖ। ");
INSERT INTO syls_vpl VALUES ("P22_21","091_2_21","2PE","2","21","21","ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠙꠕ ꠌꠤꠘꠣꠞ ꠛꠣꠖꠦꠅ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠡꠝꠎꠣꠁꠟ ꠅꠃ ꠙꠛꠤꠔ꠆ꠞ ꠢꠥꠇꠥꠝꠞ ꠃꠟꠐꠣ ꠉꠦꠍꠦ, ꠄꠞ ꠕꠣꠇꠤ ꠀꠞꠅ ꠜꠣꠟꠣ ꠀꠍꠤꠟ ꠁ ꠙꠕ ꠘꠣ ꠌꠤꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("P22_22","091_2_22","2PE","2","22","22","ꠔꠣꠞꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠅꠃ ꠍꠤꠟ꠆ꠟꠦꠈꠃ ꠡꠑꠤꠇ, “ꠇꠥꠇꠞꠦ ꠘꠤꠎꠞ ꠛꠝꠤ ꠚꠤꠞꠤꠀ ꠈꠣꠄ,” ꠀꠞ “ꠡꠥꠅꠞꠞꠦ ꠘꠣꠅꠀꠁꠟꠦꠅ ꠚꠦꠇꠅ ꠙꠠꠤꠀ ꠉꠠꠤꠀꠄ।” ");
INSERT INTO syls_vpl VALUES ("P23_1","091_3_1","2PE","3","1","1","ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠅꠇꠟ, ꠁꠈꠣꠘ ꠅꠁꠟ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠣ ꠀꠝꠣꠞ ꠖꠥꠁ ꠘꠝ꠆ꠛꠞ ꠌꠤꠑꠤ, ꠁ ꠖꠥꠁꠅ ꠌꠤꠑꠤꠔꠃ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠤꠀꠟ ꠇꠞꠣꠁ ꠖꠤꠞꠣꠝ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠞꠦ ꠢꠎꠣꠉ ꠇꠞꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("P23_2","091_3_2","2PE","3","2","2","ꠀꠝꠤ ꠌꠣꠁꠞꠣꠝ, ꠙꠛꠤꠔ꠆ꠞ ꠘꠛꠤ ꠅꠇꠟꠦ ꠀꠉꠦ ꠎꠔꠔꠣ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠝꠣꠟꠤꠇꠦ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤ ꠎꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠅꠔꠣ ꠝꠘꠅ ꠞꠣꠈꠅ। ");
INSERT INTO syls_vpl VALUES ("P23_3","091_3_3","2PE","3","3","3","ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤ ꠛꠥꠎꠤꠅ, ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠔ ꠞꠋ-ꠔꠣꠝꠡꠣ ꠇꠞꠞꠣ ꠅꠇꠟꠦ ꠞꠋ-ꠔꠣꠝꠡꠣ ꠟꠁꠀ ꠀꠎꠤꠛꠣ, ꠔꠣꠞꠣ ꠎꠣꠞꠎꠤꠞ ꠈꠣꠁꠡꠦ ꠌꠟꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("P23_4","091_3_4","2PE","3","4","4","ꠔꠣꠞꠣ ꠇꠁꠛꠣ, “ꠇꠤꠔꠣ ꠛꠣ, ꠢꠦꠁꠘ ꠀꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠎꠦ ꠅꠀꠖꠣ ꠀꠍꠤꠟ, ꠁꠔꠣꠞ ꠇꠤꠔꠣ ꠅꠁꠟ? ꠖꠥꠘꠤꠀꠞ ꠡꠥꠞꠥ ꠕꠣꠇꠤ ꠎꠦꠟꠣꠈꠣꠘ ꠌꠟꠍꠤꠟ, ꠀꠝꠞꠣꠞ ꠛꠣꠚ-ꠖꠣꠖꠣꠞ ꠝꠞꠘꠞ ꠛꠣꠖ ꠕꠣꠇꠤ ꠅꠈꠘꠅ ꠔ ꠅꠟꠣꠈꠣꠘꠃ ꠌꠟꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("P23_5","091_3_5","2PE","3","5","5","ꠀꠍꠟꠦ ꠁꠔꠣꠄ ꠔ ꠁꠌ꠆ꠍꠣ ꠇꠞꠤꠃ ꠚꠣꠃꠞꠤꠟꠣꠄ, ꠛꠃꠔ ꠖꠤꠘ ꠀꠉꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠛꠟꠦ ꠀꠍꠝꠣꠘ ꠙꠄꠖꠣ ꠅꠁꠍꠦ ꠀꠞ ꠙꠣꠘꠤꠞꠦ ꠢꠞꠣꠁ ꠖꠤꠀ ꠎꠝꠤꠘ ꠛꠣꠞ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠙꠣꠘꠤꠞꠦ ꠎꠝꠤꠘꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠖꠟꠣ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("P23_6","091_3_6","2PE","3","6","6","ꠛꠣꠖꠦ ꠢꠃ ꠙꠣꠘꠤꠄ ꠛꠁꠘ꠆ꠘꠣ ꠅꠁꠀ ꠢꠤ ꠎꠝꠣꠘꠣꠞ ꠖꠥꠘꠤꠀꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("P23_7","091_3_7","2PE","3","7","7","ꠀꠞ ꠢꠃ ꠇꠣꠟꠣꠝꠞ ꠛꠟꠦ, ꠅꠈꠘꠇꠥꠞ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠛꠣꠞ ꠟꠣꠉꠤ ꠞꠣꠈꠣ ꠅꠞ। ꠀꠈꠦꠞꠤ ꠛꠤꠌꠣꠞ ꠖꠤꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠁꠔꠣꠞꠦ ꠅꠟꠣ ꠞꠇ꠆ꠇꠣ ꠇꠞꠣ ꠅꠞ, ꠢꠃ ꠖꠤꠘ ꠛꠦ-ꠖꠤꠘ ꠅꠇꠟꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("P23_8","091_3_8","2PE","3","8","8","ꠔꠣ-ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠁꠈꠣꠘ ꠚꠣꠃꠞꠤꠅ ꠘꠣ, ꠝꠣꠟꠤꠇꠞ ꠉꠦꠍꠦ ꠄꠇ ꠖꠤꠘ ꠄꠇ ꠀꠎꠣꠞ ꠛꠍꠞꠞ ꠢꠝꠣꠘ ꠀꠞ ꠄꠇ ꠀꠎꠣꠞ ꠛꠍꠞ ꠄꠇ ꠖꠤꠘꠞ ꠢꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("P23_9","091_3_9","2PE","3","9","9","ꠇꠥꠘꠥ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠝꠘꠅ ꠇꠞꠂꠘ, ꠝꠣꠟꠤꠇꠦ ꠔꠣꠘ ꠅꠀꠖꠣ ꠙꠥꠞꠘ ꠇꠞꠔꠦ ꠖꠦꠞꠤ ꠇꠞꠞꠣ, ꠁꠈꠣꠘ ꠑꠤꠇ ꠘꠣꠄ। ꠀꠍꠟꠦ ꠔꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠄ ꠍꠛꠞ ꠇꠞꠤꠀ ꠞꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠌꠣꠁꠞꠣ ꠘꠣ ꠇꠦꠃ ꠛꠤꠘꠣꠡ ꠅꠃꠇ, ꠛꠞꠋ ꠢꠇꠟꠞꠦ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠡꠥꠎꠥꠉ ꠖꠤꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("P23_10","091_3_10","2PE","3","10","10","ꠅꠁꠟꠦ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠁꠛꠣꠞ ꠖꠤꠘ ꠔ ꠌꠥꠞꠞ ꠟꠣꠈꠣꠘ ꠀꠈꠔꠣꠃ ꠀꠁꠛ। ꠢꠃ ꠖꠤꠘ ꠀꠍꠝꠣꠘꠦ ꠢꠥ ꠢꠥ ꠀꠅꠀꠎ ꠇꠞꠤꠀ ꠛꠤꠘꠣꠡ ꠅꠁꠛ ꠀꠞ ꠙꠄꠖꠣ ꠇꠞꠣ ꠢꠇꠟꠔꠣ ꠀꠉꠥꠁꠘꠦ ꠉꠟꠤꠀ ꠝꠤꠟꠣꠁ ꠎꠤꠛ। ꠖꠥꠘꠤꠀ ꠀꠞ ꠄꠞ ꠝꠣꠎꠦ ꠎꠔꠔꠣ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠁꠞ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("P23_11","091_3_11","2PE","3","11","11","ꠅꠟꠣꠈꠣꠘ ꠢꠇ꠆ꠇꠟꠔꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠛ ꠎꠣꠘꠤꠀ, ꠔꠥꠝꠞꠣ ꠇꠤꠟꠣꠈꠣꠘ ꠞꠅꠀ ꠎꠞꠥꠞ? ꠔꠥꠝꠞꠣ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠞꠁꠀ ꠙꠞꠦꠎꠉꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("P23_12","091_3_12","2PE","3","12","12","ꠀꠟ꠆ꠟꠣꠞ ꠑꠤꠇ ꠇꠞꠣ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠀꠡꠤꠇ ꠅꠁꠀ ꠛꠣꠞ ꠌꠣꠅ। ꠢꠃ ꠖꠤꠘ ꠔ ꠀꠍꠝꠣꠘ ꠎꠟꠤ ꠎꠟꠤ ꠛꠤꠘꠣꠡ ꠅꠁꠛ ꠀꠞ ꠙꠄꠖꠣ ꠇꠞꠣ ꠢꠇꠟꠔꠣ ꠀꠉꠥꠁꠘꠦ ꠉꠟꠤꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("P23_13","091_3_13","2PE","3","13","13","ꠅꠁꠟꠦ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠘꠄꠀ ꠀꠍꠝꠣꠘ, ꠘꠄꠀ ꠎꠝꠤꠘꠞ ꠛꠣꠞ ꠌꠣꠁꠞꠣꠝ, ꠎꠦꠈꠣꠘꠅ ꠈꠣꠟꠤ ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠑꠤꠇꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("P23_14","091_3_14","2PE","3","14","14","ꠄꠞꠟꠣꠉꠤ ꠜꠣꠁ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠅꠃ ꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅꠀꠔ ꠀꠍ, ꠔꠦ ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠅ, ꠅꠃ ꠖꠤꠘ ꠔꠣꠁꠘ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠤꠈꠥꠔ-ꠘꠤꠡ꠆ꠇꠟꠋꠇ ꠢꠣꠟꠔꠦ ꠡꠣꠘ꠆ꠔꠤꠞ ꠝꠣꠎꠦ ꠖꠦꠈꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P23_15","091_3_15","2PE","3","15","15","ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇꠞ ꠟꠣꠝ꠆ꠛꠣ ꠍꠛꠞꠉꠣꠞꠤꠞꠦ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠘꠤꠞ ꠡꠥꠎꠥꠉ ꠝꠘꠅ ꠇꠞꠤꠅ। ꠅꠃ ꠄꠇꠁ ꠇꠕꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠀꠈꠟꠦ ꠀꠝꠞꠣꠞ ꠝꠣꠄꠀꠞ ꠜꠣꠁ ꠙꠣꠃꠟꠥꠍꠦꠅ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("P23_16","091_3_16","2PE","3","16","16","ꠔꠣꠘ ꠢꠇ꠆ꠇꠟ ꠌꠤꠑꠤꠔꠃ ꠅꠃ ꠛꠦꠙꠣꠞꠦ ꠟꠦꠈꠂꠘ। ꠄꠞ ꠝꠣꠎꠦ ꠇꠤꠍꠥ ꠛꠦꠙꠣꠞ ꠀꠍꠦ ꠎꠦꠔꠣ ꠛꠥꠎꠣ ꠇꠑꠤꠘ, ꠈꠣꠟꠤ ꠛꠦꠀꠈꠟ ꠀꠞ ꠛꠦꠖꠤꠡꠣ ꠎꠘꠦ ꠅꠁꠘ꠆ꠘꠣꠁꠘ꠆ꠘ ꠇꠤꠔꠣꠛꠞ ꠟꠣꠈꠣꠘ ꠁꠔꠣꠞ ꠝꠣꠘꠤꠅ ꠛꠖꠟꠣꠁꠀ, ꠘꠤꠎꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠒꠣꠇꠤꠀ ꠀꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("P23_17","091_3_17","2PE","3","17","17","ꠜꠣꠁ ꠅꠇꠟ, ꠅꠃ ꠇꠕꠣ ꠅꠇꠟ ꠔꠥꠝꠞꠣ ꠀꠉꠦꠃ ꠎꠣꠘꠍ, ꠄꠞꠟꠣꠉꠤ ꠢꠥꠡꠤꠀꠞ ꠅꠅ ꠎꠣꠔꠦ ꠅꠃ ꠘꠣꠚꠞꠝꠣꠘ ꠝꠣꠘꠡꠞ ꠜꠥꠟꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠜꠥꠟ ꠙꠕꠦ ꠘꠣ ꠘꠦꠄ, ꠀꠞ ꠁꠝꠣꠘꠤ ꠜꠤꠔ ꠕꠣꠇꠤ ꠘꠣ ꠢꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("P23_18","091_3_18","2PE","3","18","18","ꠔꠥꠝꠞꠣ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠀꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠞꠢꠝꠔꠦ ꠀꠞ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠣꠞ ꠔꠣꠇ꠆ꠇꠔꠦ ꠛꠣꠠꠤꠀ ꠃꠑꠅ। ꠅꠈꠘ ꠀꠞ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠔꠣꠘ ꠝꠢꠤꠝꠣ ꠎꠣꠞꠤ ꠞꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("J11_1","092_1_1","1JN","1","1","1","ꠢꠇꠟ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠎꠦꠁꠘ ꠀꠍꠟꠣ, ꠎꠣꠘꠞꠦ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠍꠤ, ꠎꠣꠘ ꠝꠥꠈꠞ ꠀꠅꠀꠎ ꠀꠝꠞꠣ ꠢꠥꠘꠍꠤ, ꠈꠥꠛ ꠈꠤꠀꠟ ꠇꠞꠤ ꠀꠎꠝꠣꠁꠀ ꠌꠣꠁꠍꠤ ꠀꠞ ꠘꠤꠎꠞ ꠀꠔꠦ ꠗꠞꠣ-ꠍꠀ ꠇꠞꠍꠤ, ꠢꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠟꠣꠝꠞ ꠛꠄꠀꠘꠤ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("J11_2","092_1_2","1JN","1","2","2","ꠅꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠔ ꠁ ꠖꠥꠘꠤꠀꠔ ꠎꠣꠁꠞ ꠅꠁꠍꠟꠣ, ꠀꠝꠞꠣꠞ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠁ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠞꠦ ꠖꠦꠈꠍꠤ, ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣꠝ। ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠦꠍꠦ ꠎꠦꠁꠘ ꠀꠍꠟꠣ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠣꠁꠞ ꠅꠁꠍꠟꠣ, ꠀꠈꠦꠞꠤ ꠅꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠣꠘꠤꠞ ꠇꠕꠣꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠁꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("J11_3","092_1_3","1JN","1","3","3","ꠅꠃ ꠎꠦ ꠎꠘꠞꠦ ꠀꠝꠞꠣ ꠖꠦꠈꠍꠤ, ꠎꠣꠘ ꠝꠥꠈꠞ ꠛꠥꠟꠤ ꠢꠥꠘꠍꠤ, ꠔꠣꠘ ꠛꠦꠙꠣꠞꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ। ꠎꠣꠔꠦ ꠅꠔꠣ ꠢꠥꠘꠣꠞ ꠛꠣꠖꠦ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠞꠅ ꠈꠣꠔꠤꠞ-ꠖꠥꠡ꠆ꠔꠤ ꠅꠄ। ꠀꠝꠞꠣꠞ ꠅꠃ ꠈꠣꠔꠤꠞ ꠅꠁꠟꠉꠤ, ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ। ");
INSERT INTO syls_vpl VALUES ("J11_4","092_1_4","1JN","1","4","4","ꠔꠦ ꠀꠝꠞꠣ ꠁꠔꠣ ꠟꠦꠈꠞꠣꠝ, ꠎꠣꠔꠦ ꠀꠝꠞꠣ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠈꠥꠡꠤ-ꠛꠣꠡꠤ ꠙꠥꠞꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("J11_5","092_1_5","1JN","1","5","5","ꠀꠝꠞꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠁꠔꠣ ꠢꠥꠘꠤꠀ ꠢꠣꠞꠤ, ꠅꠈꠘ ꠔꠥꠝꠞꠣꠞꠦꠅ ꠎꠣꠘꠣꠁꠞꠣꠝ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠘꠥꠞ। ꠔꠣꠘ ꠝꠣꠎꠦ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠇꠥꠘꠥ ꠍꠤꠐꠣ-ꠚꠥꠐꠣꠅ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("J11_6","092_1_6","1JN","1","6","6","ꠀꠞ ꠀꠝꠞꠣ ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠌꠟꠤꠀ ꠎꠥꠖꠤ ꠇꠁ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠈꠣꠔꠤꠞ-ꠖꠥꠡ꠆ꠔꠤ ꠀꠍꠦ, ꠔꠦ ꠔ ꠀꠝꠞꠣ ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣꠝ, ꠡꠑꠤꠇ ꠇꠣꠝ ꠇꠞꠞꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J11_7","092_1_7","1JN","1","7","7","ꠅꠁꠟꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠎꠦꠟꠣ ꠘꠥꠞꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠅꠃꠟꠣ ꠀꠝꠞꠣꠅ ꠎꠥꠖꠤ ꠘꠥꠞꠞ ꠚꠞꠦ ꠌꠟꠤ, ꠔꠦ ꠀꠝꠞꠣ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠈꠣꠔꠤꠞ-ꠖꠥꠡ꠆ꠔꠤ ꠀꠍꠦ, ꠀꠞ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠍꠣ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠟꠃꠄ ꠀꠝꠞꠣꠞ ꠔꠣꠝꠣꠝ ꠉꠥꠘꠣ-ꠇꠍꠥꠞꠤ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("J11_8","092_1_8","1JN","1","8","8","ꠅꠈꠘ ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠁ, ꠀꠝꠞꠣ ꠝꠥꠐꠦꠃ ꠉꠥꠘꠣꠉꠣꠞ ꠘꠣꠄ, ꠔꠦ ꠀꠝꠞꠣ ꠘꠤꠎꠦ ꠘꠤꠎꠞꠦ ꠐꠉꠤꠀꠞ, ꠄꠔꠦ ꠙꠞꠝꠣꠘ ꠅꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠤꠇꠔꠤ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("J11_9","092_1_9","1JN","1","9","9","ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠎꠣꠞꠎꠤꠞ ꠉꠥꠘꠣꠞ ꠡ꠆ꠛꠤꠇꠣꠞꠥꠇ꠆ꠔꠤ ꠖꠤꠟꠣꠁ, ꠔꠦ ꠔꠣꠘ ꠀꠙꠘ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ ꠀꠞ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤꠞ ꠉꠥꠘꠦ, ꠟꠉꠦ ꠟꠉꠦ ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠖꠤꠟꠣꠁꠘ, ꠔꠣꠝꠣꠝ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠦ ꠙꠣꠇ-ꠍꠣꠚ ꠇꠞꠤꠟꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("J11_10","092_1_10","1JN","1","10","10","ꠅꠈꠘ ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠇꠁ, ꠀꠝꠞꠣ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠇꠞꠍꠤ ꠘꠣ, ꠔꠦ ꠀꠝꠞꠣ ꠔꠣꠘꠞꠦꠃ ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣ ꠛꠣꠘꠣꠁꠟꠣꠝ, ꠄꠔꠦ ꠙꠞꠝꠣꠘ ꠝꠤꠟꠦ, ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("J12_1","092_2_1","1JN","2","1","1","ꠅ ꠀꠝꠣꠞ ꠍꠣꠛꠣꠟ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠁꠔꠣ ꠟꠦꠈꠞꠣꠝ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠉꠥꠘꠣꠞ ꠇꠣꠝ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠞꠅ। ꠄꠞꠛꠣꠖꠦꠅ ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠉꠥꠘꠣ ꠇꠞꠤꠟꠣꠄ, ꠔꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠛꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣꠞ ꠄꠇꠎꠘ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ ꠡꠣꠚꠣꠄꠀꠔꠇꠣꠞꠤ ꠀꠍꠂꠘ, ꠔꠣꠘ ꠘꠣꠝ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("J12_2","092_2_2","1JN","2","2","2","ꠎꠣꠘ ꠘꠤ ꠔꠣꠁꠘ ꠇꠤꠔꠣ ꠇꠞꠍꠂꠘ? ꠀꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠍꠂꠘ। ꠈꠣꠟꠤ ꠀꠝꠞꠣꠞ ꠘꠣꠄ, ꠛꠞꠋ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣꠞ ꠟꠣꠉꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J12_3","092_2_3","1JN","2","3","3","ꠅꠈꠘ ꠀꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠤ ꠘꠤ? ꠘꠤꠌ꠆ꠌꠄ ꠌꠤꠘꠤ, ꠀꠝꠞꠣ ꠔꠣꠘ ꠢꠇꠟ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠟꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ, ꠀꠝꠞꠣ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("J12_4","092_2_4","1JN","2","4","4","ꠀꠞ ꠎꠦ ꠝꠣꠘꠡꠦ ꠇꠄ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠦ, ꠌꠤꠘꠤꠀꠅ ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠦ ꠘꠣ, ꠢꠦ ꠝꠤꠍꠣ ꠝꠣꠔꠦ, ꠔꠣꠞ ꠖꠤꠟꠅ ꠢꠇꠤꠇꠔꠤ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("J12_5","092_2_5","1JN","2","5","5","ꠅꠁꠟꠦ ꠎꠦ ꠎꠘꠦ ꠔꠣꠘ ꠇꠣꠟꠣꠝ ꠝꠣꠚꠤꠇ ꠌꠟꠦ, ꠔꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠘꠤꠌ꠆ꠌꠄ ꠀꠟ꠆ꠟꠣꠁ ꠝꠢꠛ꠆ꠛꠔ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠚꠟꠤꠍꠦ। ꠔꠦ ꠀꠝꠞꠣ ꠔꠣꠘ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠤ ꠘꠤ? ꠅꠄ, ꠅꠃ ꠝꠘ꠆ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠄ ꠀꠝꠞꠣ ꠔꠣꠘ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠤ: ");
INSERT INTO syls_vpl VALUES ("J12_6","092_2_6","1JN","2","6","6","ꠀꠞ ꠔꠣꠘ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠤ ꠇꠁꠟꠦ, ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠞꠥꠞ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠌꠟꠍꠂꠘ, ꠀꠝꠞꠣꠅ ꠅꠟꠣ ꠌꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("J12_7","092_2_7","1JN","2","7","7","ꠅ ꠡꠥꠘꠣ ꠅꠇꠟ, ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠘꠄꠀ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝꠞ ꠇꠕꠣ ꠟꠦꠈꠞꠣꠝ ꠘꠣ, ꠛꠞꠋ ꠅꠟꠣ ꠄꠇ ꠢꠥꠇꠥꠝꠞ ꠇꠕꠣ ꠟꠦꠈꠞꠣꠝ, ꠎꠦꠐꠣ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠀꠍꠤꠟ। ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠕꠣꠇꠤ ꠎꠦ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠍ, ꠅꠐꠣꠃ ꠅꠁꠟ ꠢꠃ ꠙꠥꠞꠣꠘꠣ ꠢꠥꠇꠥꠝ। ");
INSERT INTO syls_vpl VALUES ("J12_8","092_2_8","1JN","2","8","8","ꠁꠐꠣꠞꠦ ꠙꠥꠞꠣꠘꠣ ꠇꠁꠟꠦꠅ ꠀꠍꠟꠦ ꠁꠐꠣ ꠘꠄꠀ। ꠅꠃ ꠢꠥꠇꠥꠝꠞ ꠢꠇꠤꠇꠔꠤꠄ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠌꠟꠔꠣ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔꠅ ꠁꠔꠣ ꠀꠍꠦ। ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠀꠘ꠆ꠖꠣꠁꠞ ꠇꠣꠐꠤ ꠎꠣꠞ, ꠀꠍꠟ ꠘꠥꠞ ꠅꠈꠘ ꠎꠣꠁꠞ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("J12_9","092_2_9","1JN","2","9","9","ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠦꠛꠟꠣ ꠇꠄ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠁ ꠘꠥꠞꠞ ꠚꠞꠅ ꠀꠍꠦ, ꠅꠕꠌ ꠔꠣꠞ ꠜꠣꠁꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠢꠦ ꠀꠍꠟꠦ ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J12_10","092_2_10","1JN","2","10","10","ꠀꠞ ꠎꠦ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠜꠣꠁꠞꠦ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ, ꠢꠦ ꠘꠥꠞꠞ ꠚꠞꠅ ꠛꠡꠔ ꠇꠞꠦ, ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠀꠍꠣꠠ ꠈꠣꠅꠀꠞ ꠒꠞ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("J12_11","092_2_11","1JN","2","11","11","ꠅꠁꠟꠦ ꠎꠦꠉꠤꠄ ꠔꠣꠞ ꠜꠣꠁꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠢꠦ ꠔ ꠀꠘ꠆ꠖꠣꠞꠤꠔ ꠙꠠꠤ ꠞꠁꠍꠦ, ꠀꠘ꠆ꠖꠣꠞꠤꠞ ꠝꠣꠎꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠦ। ꠀꠍꠟꠦ ꠀꠘ꠆ꠖꠣꠁꠞꠦ ꠔꠣꠞꠦ ꠀꠘ꠆ꠖꠣ ꠛꠣꠘꠣꠁꠟꠤꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠎꠣꠘꠦꠃ ꠘꠣ, ꠢꠦ ꠇꠥꠘ ꠙꠕꠦꠖꠤ ꠎꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("J12_12","092_2_12","1JN","2","12","12","ꠅ ꠍꠣꠛꠣꠟ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ, ꠎꠣꠘ ꠘꠤ, ꠀꠟ-ꠝꠍꠤꠞ ꠘꠣꠝꠞ ꠈꠣꠔꠤꠞꠦ, ꠔꠥꠝꠞꠣꠞ ꠔꠣꠝꠣꠝ ꠉꠥꠘꠣ-ꠇꠍꠥꠞꠤ ꠝꠣꠚ ꠇꠞꠣ ꠅꠁꠉꠦꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J12_13","092_2_13","1JN","2","13","13","ꠅ ꠛꠣꠚ ꠅꠇꠟ, ꠀꠝꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞ ꠉꠦꠍꠦꠅ ꠟꠦꠈꠞꠣꠝ, ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠎꠦꠁꠘ ꠀꠍꠂꠘ, ꠀꠙꠘꠣꠞꠣ ꠔ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠂꠘ। ꠅ ꠎꠥꠀꠘ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠦꠈꠞꠣꠝ, ꠁꠛꠟꠤꠍꠞ ꠟꠉꠞ ꠝꠢꠣ-ꠟꠣꠠꠣꠁꠔ ꠔ, ꠔꠥꠝꠤꠔꠣꠁꠘ ꠎꠤꠔꠤ ꠉꠦꠍ। ");
INSERT INTO syls_vpl VALUES ("J12_14","092_2_14","1JN","2","14","14","ꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠦꠈꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚꠞꠦ ꠌꠤꠘꠤꠟꠤꠍ। ꠅ ꠛꠣꠚ ꠅꠇꠟ, ꠀꠝꠤ ꠀꠙꠘꠣꠁꠘ꠆ꠔꠞꠦ ꠟꠦꠈꠟꠣꠝ, ꠀꠙꠘꠣꠞꠣ ꠔ ꠔꠣꠘꠞꠦ ꠌꠤꠘꠤꠟꠤꠍꠂꠘ, ꠎꠦꠁꠘ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠀꠍꠂꠘ। ꠅ ꠘꠃꠎꠥꠀꠘ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠦꠈꠟꠣꠝ, ꠔꠥꠝꠞꠣꠃ ꠛꠟꠛꠣꠘ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠉꠣꠕꠣ, ꠁꠛꠟꠤꠍꠞ ꠟꠉꠞ ꠝꠢꠣ-ꠟꠣꠠꠣꠁꠔ ꠔꠥꠝꠞꠣ ꠎꠤꠔꠍ। ");
INSERT INTO syls_vpl VALUES ("J12_15","092_2_15","1JN","2","15","15","ꠅꠈꠘ ꠈꠤꠀꠟ ꠇꠞꠤ ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣ ꠁ ꠖꠥꠘꠤꠀ ꠀꠞ ꠎꠉꠔ-ꠡꠋꠡꠣꠞꠞ ꠇꠥꠘꠥꠔꠣꠞ ꠝꠣꠄꠀꠔ ꠙꠠꠤꠅ ꠘꠣ। ꠎꠦ ꠝꠣꠘꠥꠡ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠄꠀꠔ ꠙꠠꠤꠎꠣꠄ, ꠢꠦ ꠔ ꠘꠤꠎꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J12_16","092_2_16","1JN","2","16","16","ꠎꠣꠘ ꠔ, ꠖꠥꠘꠤꠀꠔ ꠎꠦꠔꠣ ꠝꠤꠟꠦ, ꠁꠔꠣ ꠅꠁꠟ, ꠞꠇ꠆ꠔ-ꠝꠣꠋꠡꠞ ꠈꠣꠁꠡ, ꠌꠃꠈꠞ ꠟꠥꠜ-ꠟꠣꠟꠌ ꠀꠞ ꠡꠋꠡꠣꠞꠞ ꠛꠣꠢꠣꠖꠥꠞꠤ, ꠁꠔꠣ ꠇꠥꠘꠥꠐꠣꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠄ ꠘꠣ, ꠈꠣꠟꠤ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠀꠄ। ");
INSERT INTO syls_vpl VALUES ("J12_17","092_2_17","1JN","2","17","17","ꠔꠦ ꠖꠥꠘꠤꠀꠛꠤ ꠎꠉꠔ-ꠡꠋꠡꠣꠞꠞ ꠢꠇ꠆ꠇꠟ ꠛꠣꠢꠣꠖꠥꠞꠤꠞ ꠖꠤꠘ ꠚꠥꠠꠣꠁ ꠎꠣꠞ, ꠅꠁꠟꠦ ꠎꠦ ꠛꠘ꠆ꠖꠣꠄ ꠀꠟ꠆ꠟꠣꠞ ꠝꠞ꠆ꠎꠤ ꠎꠥꠉꠣꠁ ꠌꠟꠦ, ꠢꠦ ꠔ ꠌꠤꠞꠇꠣꠟ ꠐꠤꠇꠤꠀ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("J12_18","092_2_18","1JN","2","18","18","ꠛꠣꠛꠣ ꠅꠇꠟꠞꠦ, ꠇꠤꠀꠝꠔ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ। ꠔꠦ ꠔꠥꠝꠞꠣ ꠘꠤꠌ꠆ꠌꠄ ꠢꠥꠘꠍ, ꠈꠣꠘꠦ-ꠖꠞ꠆ꠎꠣꠟ ꠀꠅꠀꠞ ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ। ꠀꠞ ꠀꠍꠟ ꠇꠕꠣ ꠅꠁꠟ, ꠄꠞꠝꠣꠎꠦ ꠛꠃꠔ ꠖꠞ꠆ꠎꠣꠟ ꠀꠁꠀ ꠢꠣꠞꠍꠂꠘ। ꠅꠔꠣ ꠖꠦꠈꠤꠀ ꠀꠝꠞꠣ ꠛꠥꠎꠤꠀꠞ, ꠢꠣꠍꠣꠃ ꠇꠤꠀꠝꠔ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J12_19","092_2_19","1JN","2","19","19","ꠅꠃ ꠖꠞ꠆ꠎꠣꠟ ꠅꠇꠟ ꠔ ꠀꠝꠞꠣꠞ ꠝꠣꠎ ꠕꠣꠇꠤꠃ ꠛꠣꠞ ꠅꠁꠍꠂꠘ। ꠔꠣ-ꠅ ꠄꠞꠣ ꠀꠍꠟꠦ ꠀꠝꠞꠣꠞ ꠔꠞꠤꠇꠣꠔ ꠀꠍꠤꠟ ꠘꠣ, ꠀꠝꠞꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠅꠁꠟꠦ ꠔ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠟ ꠅꠘꠦ। ꠔꠣꠞꠣ ꠛꠣꠞ ꠅꠁꠀ ꠉꠦꠍꠦꠉꠤ ꠇꠞꠤꠃ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠔꠣꠞꠣ ꠇꠦꠃ ꠀꠝꠞꠣꠞ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("J12_20","092_2_20","1JN","2","20","20","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠎꠘꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠁꠍ ꠀꠞ ꠢꠇꠟꠦꠃ ꠢꠇ ꠀꠈꠟ ꠙꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("J12_21","092_2_21","1JN","2","21","21","ꠔꠥꠝꠞꠣ ꠢꠇꠤꠇꠔꠤ ꠌꠤꠘ ꠘꠣ ꠝꠘꠅ ꠇꠞꠤꠀ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ ꠘꠤ? ꠘꠣ, ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ। ꠀꠍꠟꠦ ꠔꠥꠝꠞꠣ ꠢꠇꠤꠇꠔꠤ ꠌꠤꠘꠅ, ꠀꠞ ꠢꠇ ꠕꠣꠇꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠘꠣ-ꠢꠇ ꠛꠣꠞꠅꠄ ꠘꠣ, ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠟꠦꠈꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("J12_22","092_2_22","1JN","2","22","22","ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠀꠟ-ꠝꠍꠤ, ꠁꠈꠣꠘ ꠎꠦꠉꠤꠄ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠦ ꠘꠣ, ꠢꠦ ꠔ ꠘꠤꠌ꠆ꠌꠤꠔ ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣ। ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠞ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞꠦ ꠎꠦꠉꠤꠄ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠦ, ꠢꠦ-ꠃ ꠅꠁꠟ ꠖꠞ꠆ꠎꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("J12_23","092_2_23","1JN","2","23","23","ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞꠦ ꠎꠦꠉꠤꠄ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠦ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚꠞ ꠟꠉꠦ ꠔꠣꠞ ꠇꠥꠘꠥ ꠈꠣꠔꠤꠞ-ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠘꠣꠁ, ꠀꠞ ꠎꠦ ꠝꠣꠘꠡꠦ ꠝꠣꠄꠀꠞ ꠎꠘꠞꠦ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠦ, ꠔꠣꠞ ꠟꠉꠦ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚꠞꠅ ꠈꠣꠔꠤꠞ-ꠡꠝ꠆ꠙꠞ꠆ꠇ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J12_24","092_2_24","1JN","2","24","24","ꠔꠦ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠢꠥꠘꠤꠀ ꠀꠁꠞꠣꠄ, ꠁꠔꠣ ꠎꠣꠘꠥ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠉꠣꠕꠣ ꠞꠄ। ꠁꠔꠣ ꠖꠤꠟꠅ ꠞꠁꠟꠦ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚ ꠀꠞ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠟꠉꠦ ꠔꠥꠝꠞꠣꠅ ꠉꠣꠕꠣ ꠞꠁꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("J12_25","092_2_25","1JN","2","25","25","ꠀꠞ ꠁꠐꠣꠃ ꠅꠁꠟ ꠢꠃ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ, ꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠀꠟ-ꠝꠍꠤꠄ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠛꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J12_26","092_2_26","1JN","2","26","26","ꠢꠥꠘꠅ, ꠔꠥꠝꠞꠣꠞꠦ ꠎꠦꠉꠥꠁꠘ꠆ꠔꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠔ ꠌꠣꠄ, ꠅꠔꠣꠞ ꠙꠞꠤꠌꠄ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠁꠔꠣ ꠟꠦꠈꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("J12_27","092_2_27","1JN","2","27","27","ꠀꠍꠟꠦ ꠀꠟ-ꠝꠍꠤ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠎꠦ ꠈꠦꠟꠣꠚꠔꠤ ꠙꠣꠁꠍ, ꠅꠃ ꠈꠦꠟꠣꠚꠔꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠛꠡꠔ ꠇꠞꠦ। ꠄꠞꠟꠣꠉꠤ ꠖꠥꠍꠞꠣ ꠇꠦꠃꠞꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠔꠣꠟꠤꠝ ꠘꠤꠛꠣꠞ ꠇꠥꠘꠥ ꠎꠞꠥꠞ ꠘꠣꠄ, ꠅꠃ ꠈꠦꠟꠣꠚꠔꠤꠞ ꠞꠥꠢꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠞꠇꠣꠞꠤ ꠢꠇꠟꠔꠣ ꠢꠤꠇꠣꠁꠛꠣ। ꠔꠣꠁꠘ ꠔ ꠢꠇ, ꠔꠣꠘ ꠝꠣꠎꠦ ꠘꠣ-ꠢꠇ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠁ। ꠅꠈꠘ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠁꠘ ꠎꠦꠟꠣ ꠔꠣꠟꠤꠝ ꠖꠤꠍꠂꠘ, ꠔꠥꠝꠞꠣ ꠑꠤꠇ ꠅꠃꠟꠣ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("J12_28","092_2_28","1JN","2","28","28","ꠅ ꠍꠣꠛꠣꠟ ꠅꠇꠟ, ꠀꠝꠣꠞ ꠙꠞꠣꠝꠤꠡ ꠅꠁꠟ, ꠔꠣꠘ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠣꠔ ꠞꠅ, ꠔꠦꠃ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠢꠤꠞꠛꠣꠞ ꠎꠣꠁꠞꠣ ꠅꠁꠛꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠞꠣ ꠡꠣꠅꠡ ꠙꠣꠁꠝꠥ, ꠔꠣꠘ ꠍꠣꠝꠘꠦ ꠀꠁꠔꠦ ꠡꠞꠝ ꠇꠞꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("J12_29","092_2_29","1JN","2","29","29","ꠀꠞ ꠔꠥꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠄꠇꠤꠘ ꠇꠞꠅ ꠔꠣꠁꠘ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ, ꠔꠦ ꠄꠅꠈꠣꠘꠅ ꠄꠇꠤꠘ ꠇꠞꠤꠅ, ꠎꠦ ꠛꠘ꠆ꠖꠣ ꠘꠦꠇ ꠇꠣꠝꠞ ꠀꠡꠤꠇ, ꠔꠣꠞ ꠎꠘꠝ ꠔ ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("J13_1","092_3_1","1JN","3","1","1","ꠢꠥꠘꠅ, ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠛꠣꠚꠦ ꠀꠝꠞꠣꠞꠦ ꠇꠔ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠇꠞꠂꠘ! ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠀꠅꠟꠣꠖ ꠇꠁꠀ ꠒꠣꠇꠂꠘ, ꠀꠞ ꠀꠍꠟꠦꠅ ꠀꠝꠞꠣ ꠔꠣꠘ ꠀꠅꠟꠣꠖ। ꠔꠣ-ꠅ ꠁ ꠎꠉꠔꠦ ꠀꠝꠞꠣꠞꠦ ꠌꠤꠘꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠎꠉꠔꠦ ꠅꠃ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞꠦꠅ ꠌꠤꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_2","092_3_2","1JN","3","2","2","ꠅ ꠡꠥꠘꠣ ꠅꠇꠟ, ꠅꠈꠘ ꠔ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ ꠛꠘꠍꠤ, ꠄꠞꠛꠣꠖꠦ ꠇꠤꠔꠣ ꠛꠘꠝꠥ, ꠁꠈꠣꠘ ꠅꠈꠘꠅ ꠎꠣꠘꠤ ꠘꠣ। ꠈꠣꠟꠤ ꠎꠣꠘꠤ, ꠀꠟ-ꠝꠍꠤ ꠎꠦꠛꠟꠣ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠎꠣꠁꠞ ꠅꠁꠛꠣ, ꠢꠃ ꠡꠝꠄ ꠀꠝꠞꠣꠅ ꠔꠣꠘ ꠟꠣꠈꠣꠘ ꠅꠁꠝꠥ। ꠀꠝꠞꠣ ꠔ ꠔꠣꠘꠞꠦ ꠔꠣꠘ ꠀꠍꠟ ꠍꠥꠞꠔꠦ ꠖꠦꠈꠣꠞ ꠡꠥꠎꠥꠉ ꠙꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("J13_3","092_3_3","1JN","3","3","3","ꠀꠞ ꠎꠔ ꠝꠣꠘꠡꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠟꠣ ꠀꠡꠣ ꠇꠞꠦ, ꠔꠣꠞꠣ ꠘꠤꠎꠞꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠣꠈꠣꠘ ꠈꠣꠐꠤ ꠛꠣꠘꠣꠘꠤꠔ ꠞꠄ। ");
INSERT INTO syls_vpl VALUES ("J13_4","092_3_4","1JN","3","4","4","ꠎꠦ ꠝꠣꠘꠡꠦ ꠉꠥꠘꠣ ꠇꠞꠦ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠜꠣꠋꠉꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠜꠣꠋꠉꠣꠃ ꠔ ꠉꠥꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_5","092_3_5","1JN","3","5","5","ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠀꠟ-ꠝꠍꠤ ꠅꠁꠟꠣ ꠛꠦ-ꠉꠥꠘꠣ ꠝꠣꠍꠥꠝ, ꠔꠣꠁꠘ ꠉꠥꠘꠣꠞꠦ ꠈꠦꠖꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠘꠤꠀꠔ ꠎꠣꠁꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_6","092_3_6","1JN","3","6","6","ꠄꠞꠟꠣꠉꠤ ꠎꠦꠞꠣ ꠔꠣꠘ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠦ, ꠔꠣꠞꠣ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠌꠟꠦ ꠘꠣ। ꠉꠥꠘꠣꠞ ꠉꠣꠔꠅ ꠎꠦꠉꠥꠁꠘ ꠙꠠꠤ ꠞꠂꠘ, ꠁꠉꠥꠁꠘ꠆ꠔꠦ ꠔꠣꠘꠞꠦ ꠖꠦꠈꠍꠦꠅ ꠘꠣ, ꠌꠤꠘꠍꠦꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_7","092_3_7","1JN","3","7","7","ꠅ ꠍꠣꠛꠣꠟ ꠅꠇꠟ, ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠥ ꠇꠦꠃ ꠛꠦ-ꠙꠕꠦ ꠘꠤꠔ ꠘꠣ ꠙꠣꠞꠦ। ꠀꠟ-ꠝꠍꠤ ꠔ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞ, ꠀꠞ ꠘꠦꠇ ꠇꠣꠝꠞ ꠀꠡꠤꠇ ꠅꠇꠟꠅ ꠔꠣꠘ ꠟꠣꠈꠣꠘ ꠙꠞꠦꠎꠉꠣꠞ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("J13_8","092_3_8","1JN","3","8","8","ꠅꠁꠟꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠞ ꠀꠡꠤꠇ ꠎꠦꠞꠣ, ꠔꠣꠞꠣ ꠡꠄꠔꠣꠘꠞ ꠝꠥꠞꠤꠖ, ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘꠦ ꠔ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠉꠥꠘꠣ ꠇꠞꠦꠞ। ꠔꠣꠞ ꠇꠣꠝꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ, ꠅꠈꠘ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠁ ꠖꠥꠘꠤꠀꠔ ꠎꠣꠁꠞ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_9","092_3_9","1JN","3","9","9","ꠔꠦ ꠎꠦ ꠛꠘ꠆ꠖꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞ ꠕꠣꠇꠤ, ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠞ ꠛꠤꠌ ꠛꠡꠔ ꠇꠞꠦ, ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠉꠥꠘꠣꠞ ꠉꠣꠔꠅ ꠙꠠꠤ ꠞꠄ ꠘꠣ। ꠀꠟ꠆ꠟꠣꠁ ꠘꠥꠞ ꠕꠣꠇꠤ ꠎꠘꠝ ꠅꠁꠍꠦ ꠇꠞꠤ, ꠢꠦ ꠉꠥꠘꠣꠞ ꠇꠣꠝꠅ ꠙꠠꠤ ꠞꠁꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_10","092_3_10","1JN","3","10","10","ꠀꠞ ꠎꠣꠞꠎꠤꠞ ꠀꠝꠟ ꠖꠦꠈꠟꠦꠃ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠇꠦ ꠀꠟ꠆ꠟꠣꠞ ꠀꠅꠟꠣꠖ, ꠇꠦ ꠡꠄꠔꠣꠘꠞ ꠙꠥꠔ: ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠘꠦꠇ ꠙꠕꠦ ꠌꠟꠦ ꠘꠣ, ꠔꠣꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ ꠘꠣ, ꠢꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠘꠥꠡ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("J13_11","092_3_11","1JN","3","11","11","ꠔꠥꠝꠞꠣ ꠝꠥꠟꠅ ꠕꠣꠇꠤꠃ ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠀꠁꠞꠣꠄ, ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠚꠞꠎ ꠅꠁꠟ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_12","092_3_12","1JN","3","12","12","ꠔꠦ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠛꠣꠛꠣ ꠀꠖꠝꠞ ꠙꠥꠔ ꠇꠣꠛꠤꠟꠞ ꠟꠣꠈꠣꠘ ꠘꠣ ꠅꠁ। ꠢꠦ ꠀꠍꠤꠟ ꠁꠛꠟꠤꠍꠞ ꠝꠥꠞꠤꠖ, ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠔꠣꠞ ꠀꠙꠘ ꠜꠣꠁꠞꠦ ꠈꠥꠘ ꠇꠞꠍꠤꠟ। ꠎꠣꠘ ꠘꠤ ꠇꠦꠘꠦ ꠈꠥꠘ ꠇꠞꠍꠤꠟ? ꠢꠦ ꠢꠣꠝꠦꠡꠣ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠣꠝ ꠇꠞꠔ, ꠅꠁꠟꠦ ꠔꠣꠞ ꠜꠣꠁꠄ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠔ। ");
INSERT INTO syls_vpl VALUES ("J13_13","092_3_13","1JN","3","13","13","ꠅ ꠜꠣꠁ ꠅꠇꠟ, ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠔꠦ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_14","092_3_14","1JN","3","14","14","ꠀꠝꠞꠣ ꠔ ꠀꠝꠞꠣꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ, ꠄꠞꠟꠣꠉꠤ ꠛꠥꠎꠞꠣꠝ, ꠀꠝꠞꠣ ꠝꠞꠘ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠀꠁꠍꠤ। ꠎꠦꠞꠣ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ ꠘꠣ, ꠔꠣꠞꠣ ꠔ ꠝꠞꠘꠞ ꠉꠣꠔꠅ ꠙꠠꠤ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J13_15","092_3_15","1JN","3","15","15","ꠘꠤꠎꠞ ꠜꠣꠁꠞꠦ ꠎꠦꠉꠤꠄ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠢꠦ ꠔ ꠈꠥꠘꠤ। ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠎꠣꠘꠣ ꠀꠍꠦ, ꠇꠥꠘꠥ ꠈꠥꠘꠤꠞ ꠖꠤꠟꠅ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠛꠡꠔ ꠇꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J13_16","092_3_16","1JN","3","16","16","ꠀꠟ-ꠝꠍꠤꠄ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠘꠤꠎꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠤꠍꠟꠣ, ꠅꠈꠣꠘ ꠕꠣꠇꠤꠃ ꠀꠝꠞꠣ ꠛꠥꠎꠍꠤ, ꠝꠢꠛ꠆ꠛꠔ ꠇꠣꠞꠦ ꠇꠄ। ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠜꠣꠁꠞ ꠟꠣꠉꠤꠅ ꠀꠝꠞꠣꠞ ꠎꠣꠘ ꠛꠤꠟꠣꠁ ꠖꠦꠅꠀ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("J13_17","092_3_17","1JN","3","17","17","ꠡꠋꠡꠣꠞꠅ ꠈꠣꠁꠀ-ꠚꠤꠘ꠆ꠖꠤꠀ ꠛꠣꠌꠣꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠎꠣꠞ ꠀꠍꠦ, ꠢꠦ ꠔꠣꠞ ꠜꠣꠁꠞ ꠅꠜꠣꠛ ꠖꠦꠈꠤꠀꠅ ꠎꠥꠖꠤ ꠌꠃꠈ ꠝꠥꠎꠤꠀ ꠛꠁꠞꠄ, ꠔꠦ ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠇꠤꠟꠣ ꠀꠟ꠆ꠟꠣꠁ ꠝꠢꠛ꠆ꠛꠔ ꠛꠡꠔ ꠇꠞꠦ? ");
INSERT INTO syls_vpl VALUES ("J13_18","092_3_18","1JN","3","18","18","ꠛꠣꠛꠣ ꠅꠇꠟꠞꠦ, ꠀꠝꠞꠣ ꠈꠣꠟꠤ ꠝꠥꠈꠞ ꠝꠣꠄꠀ ꠘꠣ ꠖꠦꠈꠣꠁꠀ, ꠇꠣꠝꠞ ꠝꠣꠎꠖꠤ ꠎꠣꠘꠥ ꠀꠍꠟ ꠝꠢꠛ꠆ꠛꠔ ꠖꠦꠈꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("J13_19","092_3_19","1JN","3","19","19","ꠔꠦꠃ ꠀꠝꠞꠣ ꠛꠥꠎꠝꠥ, ꠀꠝꠞꠣ ꠢꠇꠞ ꠟꠉꠦ ꠀꠍꠤ। ꠀꠞ ꠢꠇ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠔꠍꠟ꠆ꠟꠤ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("J13_20","092_3_20","1JN","3","20","20","ꠇꠣꠞꠘ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠦꠃ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞꠦ ꠖꠥꠡꠤ ꠇꠁꠀ ꠞꠣꠄ ꠖꠦꠄ, ꠔꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠔ ꠁ ꠖꠤꠟ ꠕꠣꠇꠤ ꠛꠃꠔ ꠝꠢꠣꠘ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠎꠣꠘꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J13_21","092_3_21","1JN","3","21","21","ꠄꠞꠟꠣꠉꠤ ꠇꠁꠞꠣꠝ, ꠅ ꠡꠥꠘꠣ ꠅꠇꠟ, ꠀꠝꠞꠣꠞ ꠀꠙꠘ ꠖꠤꠟꠦ ꠎꠥꠖꠤ ꠀꠝꠞꠣꠞꠦ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠘꠣ ꠇꠞꠦ, ꠔꠦ ꠡꠣꠅꠡ ꠇꠞꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠀꠎꠤꠞꠣ ꠖꠤꠔꠣꠝ ꠙꠣꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("J13_22","092_3_22","1JN","3","22","22","ꠀꠞ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠝꠣꠋꠉꠤꠝꠥ, ꠁꠔꠣ ꠔꠣꠁꠘ ꠖꠤꠛꠣ। ꠇꠣꠞꠘ ꠀꠝꠞꠣ ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠤ, ꠀꠞ ꠎꠦ ꠇꠣꠝ ꠇꠞꠟꠦ ꠔꠣꠁꠘ ꠈꠥꠡꠤ ꠅꠁꠘ, ꠈꠣꠟꠤ ꠅꠃ ꠇꠣꠝ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("J13_23","092_3_23","1JN","3","23","23","ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠅꠁꠟ, ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠤ, ꠀꠞ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ। ꠅꠃ ꠢꠥꠇꠥꠝꠃ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J13_24","092_3_24","1JN","3","24","24","ꠀꠞ ꠎꠦ ꠛꠘ꠆ꠖꠣꠄ ꠔꠣꠘ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠦ, ꠢꠦ ꠔꠣꠘ ꠝꠣꠎꠦꠃ ꠛꠡꠔ ꠇꠞꠦ, ꠅꠟꠣ ꠔꠣꠁꠘꠅ ꠔꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠂꠘ। ꠅꠈꠘ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠎꠦ ꠙꠣꠇ ꠞꠥꠢꠥ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠖꠤ ꠀꠝꠞꠣ ꠛꠥꠎꠤꠀꠞ, ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠛꠡꠔ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J14_1","092_4_1","1JN","4","1","1","ꠅ ꠡꠥꠘꠣ ꠅꠇꠟ, ꠖꠥꠘꠤꠀꠔ ꠛꠃꠔ ꠜꠘ꠆ꠒ ꠘꠛꠤ ꠛꠣꠞ ꠅꠁꠍꠂꠘ। ꠄꠞꠟꠣꠉꠤ ꠇꠦꠃ ꠎꠥꠖꠤ ꠀꠁꠀ ꠇꠄ, ꠀꠝꠤ ꠞꠥꠢꠥꠞ ꠛꠟꠦ ꠝꠣꠔꠤꠞꠣꠝ, ꠔꠦ ꠔꠥꠝꠞꠣ ꠎꠟꠖꠤ ꠛꠤꠡ꠆ꠛꠣꠡ ꠇꠞꠤꠅ ꠘꠣ, ꠛꠞꠋ ꠎꠣꠌꠣꠁ ꠇꠞꠤꠀ ꠖꠦꠈꠅ, ꠁ ꠞꠥꠢꠥ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠦ ꠇꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J14_2","092_4_2","1JN","4","2","2","ꠀꠟ꠆ꠟꠣꠁ ꠞꠥꠢꠥꠞꠦ ꠌꠤꠘꠣꠞ ꠘꠤꠅꠝ ꠅꠁꠟ, ꠎꠦ ꠞꠥꠢꠦ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠦ ꠝꠣꠘꠥꠡ ꠍꠥꠞꠔꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠖꠥꠘꠤꠀꠔ ꠔꠡꠞꠤꠚ ꠀꠘꠍꠂꠘ, ꠅꠃ ꠞꠥꠢꠥ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J14_3","092_4_3","1JN","4","3","3","ꠅꠁꠟꠦ ꠎꠦ ꠞꠥꠢꠦ ꠅꠃ ꠁꠍꠣꠞꠦ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠦ ꠘꠣ, ꠁ ꠞꠥꠢꠥ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠁꠍꠦ ꠘꠣ। ꠁꠔꠣ ꠅꠁꠟ ꠈꠣꠘꠦ-ꠖꠞ꠆ꠎꠣꠟꠞ ꠞꠥꠢꠥ, ꠅꠃ ꠖꠞ꠆ꠎꠣꠟꠞ ꠞꠥꠢꠥ ꠀꠁꠛꠣꠞ ꠇꠕꠣ ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠢꠥꠘꠍ, ꠀꠞ ꠅꠈꠘꠅ ꠢꠦ ꠅꠃ ꠎꠉꠔꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J14_4","092_4_4","1JN","4","4","4","ꠅꠁꠟꠦ ꠅ ꠍꠣꠛꠣꠟ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠘꠥꠡ, ꠢꠃ ꠜꠘ꠆ꠒ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠔꠥꠝꠞꠣ ꠎꠤꠔꠤꠍ। ꠔꠥꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠎꠦ ꠞꠥꠢꠥ ꠀꠍꠂꠘ, ꠄꠁꠘ ꠔ ꠁ ꠎꠉꠔꠞ ꠞꠥꠢꠥ ꠕꠣꠇꠤ ꠛꠃꠔ ꠝꠢꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("J14_5","092_4_5","1JN","4","5","5","ꠀꠍꠟꠦ ꠅꠃ ꠜꠘ꠆ꠒ ꠅꠇꠟ ꠔ ꠅꠃ ꠎꠉꠔꠞ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠎꠉꠔꠞ ꠛꠥꠟꠤ ꠛꠥꠟꠦ, ꠀꠞ ꠎꠉꠔꠦꠅ ꠔꠣꠞꠣꠞ ꠛꠥꠟꠤ ꠝꠣꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("J14_6","092_4_6","1JN","4","6","6","ꠀꠞ ꠀꠝꠞꠣ ꠅꠁꠟꠣꠝ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠘꠥꠡ। ꠀꠟ꠆ꠟꠣꠞꠦ ꠎꠦꠞꠣ ꠌꠤꠘꠦ, ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠛꠥꠟꠤ ꠝꠣꠘꠦ। ꠅꠁꠟꠦ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠄ, ꠔꠣꠞꠣ ꠀꠝꠞꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠦ ꠘꠣ। ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠀꠝꠞꠣ ꠗꠥꠇꠣꠛꠣꠎ ꠞꠥꠢꠥ ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇ ꠞꠥꠢꠥꠞꠦ ꠌꠤꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("J14_7","092_4_7","1JN","4","7","7","ꠅ ꠡꠥꠘꠣ ꠅꠇꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠖꠣꠘ ꠅꠁꠟ ꠝꠢꠛ꠆ꠛꠔ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ। ꠎꠦ ꠛꠘ꠆ꠖꠣꠞ ꠖꠤꠟꠅ ꠝꠢꠛ꠆ꠛꠔ ꠀꠍꠦ, ꠔꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞ ꠕꠣꠇꠤ, ꠢꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠌꠤꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("J14_8","092_4_8","1JN","4","8","8","ꠀꠞ ꠎꠦꠉꠥꠞ ꠜꠤꠔꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠘꠣꠁ, ꠢꠦ ꠔ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠌꠤꠘꠦ ꠘꠣ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣ ꠘꠤꠎꠦꠃ ꠔ ꠝꠢꠛ꠆ꠛꠔ। ");
INSERT INTO syls_vpl VALUES ("J14_9","092_4_9","1JN","4","9","9","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠢꠛ꠆ꠛꠔ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠎꠣꠁꠞ ꠅꠁꠍꠦ, ꠔꠣꠁꠘ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞꠦ ꠅꠃ ꠖꠥꠘꠤꠀꠔ ꠛꠦꠎꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠄꠘ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠀꠝꠞꠣ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠢꠣꠍꠤꠟ ꠇꠞꠔꠣꠝ ꠙꠣꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("J14_10","092_4_10","1JN","4","10","10","ꠀꠞ ꠀꠝꠞꠣ ꠎꠦꠘ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠍꠟꠣꠝ ꠁꠟꠣ ꠇꠥꠘ꠆ꠔꠣ ꠘꠣꠄ, ꠛꠞꠋ ꠔꠣꠁꠘ ꠘꠤꠎꠦꠃ ꠀꠝꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠀ, ꠀꠝꠞꠣꠞ ꠉꠥꠘꠣꠞ ꠇꠚꠞꠣ ꠅꠁꠛꠣꠞ ꠟꠣꠉꠤ, ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞꠦ ꠎꠉꠔꠅ ꠙꠣꠑꠣꠁ ꠖꠤꠟꠣ, ꠅꠇꠐꠣꠞꠦꠃ ꠇꠄ ꠝꠢꠛ꠆ꠛꠔ। ");
INSERT INTO syls_vpl VALUES ("J14_11","092_4_11","1JN","4","11","11","ꠅ ꠡꠥꠘꠣ ꠅꠇꠟ, ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣꠞꠦ ꠅꠟꠣ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠟꠣ, ꠔꠦ ꠀꠝꠞꠣꠞ ꠟꠣꠉꠤꠅ ꠎꠞꠥꠞ ꠅꠁꠟ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("J14_12","092_4_12","1JN","4","12","12","ꠀꠟ꠆ꠟꠣꠞꠦ ꠔ ꠇꠦꠃ ꠇꠥꠘꠥꠖꠤꠘ ꠖꠦꠈꠍꠦ ꠘꠣ। ꠅꠈꠘ ꠀꠝꠞꠣ ꠎꠥꠖꠤ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ, ꠔꠦ ꠛꠥꠎꠣ ꠎꠣꠁꠛ, ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠔꠣꠘ ꠝꠢꠛ꠆ꠛꠔꠦ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠅ ꠙꠥꠞꠣꠙꠥꠞ ꠚꠟ ꠗꠞꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J14_13","092_4_13","1JN","4","13","13","ꠀꠝꠞꠣꠞꠦ ꠔꠣꠘ ꠞꠥꠢꠥ ꠝꠥꠛꠣꠞꠇ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠛꠥꠎꠞꠣꠝ, ꠀꠝꠞꠣ ꠔꠣꠘ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠤ, ꠀꠞ ꠔꠣꠁꠘꠅ ꠀꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J14_14","092_4_14","1JN","4","14","14","ꠀꠝꠞꠣ ꠘꠤꠎꠦ ꠖꠦꠈꠍꠤ, ꠖꠦꠈꠤꠀ ꠢꠣꠞꠤ ꠅꠃ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣꠝ, ꠎꠉꠔꠞ ꠔꠞꠣꠘꠦꠀꠟꠣ ꠇꠣꠘ꠆ꠒꠣꠞꠤ ꠢꠤꠡꠣꠛꠦ, ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞꠦ ꠛꠦꠎꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J14_15","092_4_15","1JN","4","15","15","ꠄꠞꠟꠣꠉꠤ ꠎꠦ ꠎꠘꠦ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠦ, ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠔꠣꠞ ꠖꠤꠟꠅ ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠛꠡꠔ ꠇꠞꠂꠘ, ꠀꠞ ꠢꠦ-ꠅ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("J14_16","092_4_16","1JN","4","16","16","ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠝꠢꠛ꠆ꠛꠔ ꠀꠍꠦ, ꠁꠈꠣꠘ ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠎꠣꠘꠤꠀ ꠄꠇꠤꠘꠅ ꠇꠞꠤ। ꠀꠍꠟꠦ ꠀꠟ꠆ꠟꠣ ꠘꠤꠎꠦꠃ ꠝꠢꠛ꠆ꠛꠔ। ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠎꠦ ꠎꠦ ꠛꠘ꠆ꠖꠣ ꠛꠡꠔ ꠇꠞꠦ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠎꠦꠃ ꠛꠡꠔ ꠇꠞꠦ, ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠅ ꠔꠣꠞ ꠝꠣꠎꠦ ꠛꠡꠔ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J14_17","092_4_17","1JN","4","17","17","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠝꠢꠛ꠆ꠛꠔ ꠀꠝꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠚꠟꠀꠟꠣ ꠅꠄ। ꠔꠦꠃ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠀꠝꠞꠣ ꠡꠣꠅꠡꠤ ꠛꠘꠤ, ꠇꠣꠞꠘ ꠅꠃ ꠎꠉꠔꠅ ꠀꠝꠞꠣ ꠔꠣꠘ ꠞꠋꠉꠦ ꠞꠋꠉꠤ ꠉꠦꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("J14_18","092_4_18","1JN","4","18","18","ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥ ꠒꠞ-ꠜꠄ ꠘꠣꠁ, ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠝꠢꠛ꠆ꠛꠔꠦ ꠛꠞꠋ ꠒꠞ-ꠜꠄꠞꠦ ꠈꠦꠖꠣꠁ ꠖꠦꠄ। ꠒꠞ-ꠜꠄꠞ ꠝꠣꠎꠦ ꠔ ꠡꠣꠎꠣ ꠙꠣꠅꠀꠞ ꠜꠣꠛ-ꠡꠣꠛ ꠀꠍꠦ, ꠄꠞꠟꠣꠉꠤ ꠒꠞ-ꠜꠄ ꠎꠣꠞ ꠜꠤꠔꠞꠦ, ꠢꠦ ꠝꠢꠛ꠆ꠛꠔꠞ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠚꠟ ꠗꠞꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J14_19","092_4_19","1JN","4","19","19","ꠔꠦ ꠀꠝꠞꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ, ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠙꠄꠟꠣ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J14_20","092_4_20","1JN","4","20","20","ꠀꠞ ꠎꠦ ꠝꠣꠘꠡꠦ ꠇꠄ, ꠢꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ, ꠇꠁꠀ ꠔꠣꠞ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠞꠦ ꠊꠤꠘ꠆ꠘꠣꠄ, ꠢꠦ ꠔ ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣ। ꠇꠣꠞꠘ ꠘꠤꠎꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠣ ꠜꠣꠁꠞꠦ ꠎꠦꠉꠤꠄ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ ꠘꠣ, ꠀ-ꠖꠦꠈꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠇꠤꠟꠣ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠛ? ");
INSERT INTO syls_vpl VALUES ("J14_21","092_4_21","1JN","4","21","21","ꠀꠝꠞꠣ ꠔ ꠔꠣꠘ ꠉꠦꠍ ꠕꠣꠇꠤ ꠅꠃ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠍꠤ, ꠎꠦ ꠛꠘ꠆ꠖꠣꠄ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ, ꠢꠦ ꠎꠣꠘꠥ ꠔꠣꠞ ꠜꠣꠁꠞꠦꠅ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("J15_1","092_5_1","1JN","5","1","1","ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠅꠀꠖꠣ ꠇꠞꠣ ꠢꠃ ꠀꠟ-ꠝꠍꠤ, ꠁꠈꠣꠘ ꠎꠦꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠦ, ꠔꠣꠞꠣꠞ ꠎꠘꠝ ꠅꠁꠍꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞ ꠕꠣꠇꠤ। ꠎꠣꠘ ꠘꠤ, ꠎꠦ ꠝꠣꠘꠡꠦ ꠇꠥꠘꠥ ꠝꠣ-ꠛꠣꠚꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠦ, ꠢꠦ ꠄꠞꠣꠞ ꠀꠅꠟꠣꠖꠞꠦꠅ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("J15_2","092_5_2","1JN","5","2","2","ꠔꠦ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠀꠅꠟꠣꠖꠞꠦ ꠝꠢꠛ꠆ꠛꠔꠞ ꠛꠦꠙꠣꠞ ꠇꠤꠟꠣ ꠛꠥꠎꠣꠁꠔꠣꠝ? ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤꠀ ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠟꠦꠃ ꠛꠥꠎꠣ ꠎꠣꠄ, ꠀꠝꠞꠣ ꠢꠣꠍꠣꠃ ꠔꠣꠘ ꠀꠅꠟꠣꠖꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("J15_3","092_5_3","1JN","5","3","3","ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠤꠀ ꠌꠟꠣꠃ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠣ। ꠀꠞ ꠔꠣꠘ ꠢꠥꠇꠥꠝ-ꠀꠢꠇꠣꠝ ꠝꠣꠘꠣ ꠔ ꠈꠥꠛ ꠇꠑꠤꠘ ꠇꠥꠘꠥ ꠇꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("J15_4","092_5_4","1JN","5","4","4","ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠁ ꠎꠉꠔꠞ ꠃꠙꠞꠦ ꠎꠄꠁ ꠅꠁꠘ, ꠀꠞ ꠎꠉꠔꠞ ꠟꠣꠠꠣꠁꠔ ꠎꠦ ꠎꠤꠘꠤꠡꠞ ꠛꠟꠦ ꠎꠄꠁ ꠅꠁꠍꠤ, ꠁꠇꠐꠣ ꠅꠁꠟ ꠀꠝꠞꠣꠞ ꠁꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("J15_5","092_5_5","1JN","5","5","5","ꠢꠎꠞꠔ ꠁꠍꠣꠃ ꠅꠁꠟꠣ ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠁꠈꠣꠘ ꠎꠦꠞꠣ ꠄꠇꠤꠘ ꠇꠞꠦ, ꠁ ꠎꠉꠔꠞ ꠟꠣꠠꠣꠁꠔ ꠔꠣꠞꠣꠃ ꠈꠣꠟꠤ ꠎꠄꠁ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("J15_6","092_5_6","1JN","5","6","6","ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠅꠁꠟꠣ ꠢꠃ ꠎꠘ, ꠎꠦꠁꠘ ꠙꠣꠘꠤ ꠀꠞ ꠟꠃꠞ ꠛꠟꠦ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠍꠂꠘ। ꠔꠣꠁꠘ ꠈꠣꠟꠤ ꠙꠣꠘꠤꠞ ꠎꠞꠤꠀꠄ ꠘꠣꠄ, ꠛꠞꠋ ꠢꠃ ꠙꠣꠇ ꠉꠥꠍꠟꠞ ꠙꠣꠘꠤ ꠀꠞ ꠍꠟꠤꠛꠅ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤꠞ ꠟꠃꠞ ꠛꠟꠦ ꠀꠁꠍꠂꠘ। ꠁꠔꠣ ꠛꠦꠙꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ, ꠀꠞ ꠅꠃ ꠞꠥꠢꠥ ꠔ ꠢꠇ। ");
INSERT INTO syls_vpl VALUES ("J15_7","092_5_7","1JN","5","7","7","ꠀꠍꠟꠦ ꠔꠤꠘꠅ ꠡꠣꠇ꠆ꠇꠤꠄ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ: ");
INSERT INTO syls_vpl VALUES ("J15_8","092_5_8","1JN","5","8","8","ꠞꠥꠢꠥ, ꠙꠣꠘꠤ ꠀꠞ ꠟꠃ, ꠅꠃ ꠔꠤꠘ ꠡꠣꠇ꠆ꠇꠤꠞ ꠡꠣꠇ꠆ꠇꠤ ꠄꠇ ꠡꠝꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("J15_9","092_5_9","1JN","5","9","9","ꠝꠣꠘꠡꠞ ꠝꠥꠈꠞ ꠡꠣꠇ꠆ꠇꠤ ꠎꠦꠛꠟꠣ ꠀꠝꠞꠣ ꠝꠣꠘꠤ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠡꠣꠇ꠆ꠇꠤ ꠔ ꠀꠞꠅ ꠝꠎꠛꠥꠔ, ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠣꠁꠘ ꠅꠟꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J15_10","092_5_10","1JN","5","10","10","ꠀꠞ ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠃꠙꠞꠦ ꠎꠦꠞꠣ ꠁꠝꠣꠘ ꠀꠘꠦ, ꠔꠣꠞꠣꠞ ꠖꠤꠟꠦꠅ ꠅꠃꠟꠣ ꠡꠣꠇ꠆ꠇꠤ ꠖꠦꠄ। ꠅꠈꠘ ꠀꠟ꠆ꠟꠣꠁ ꠡꠣꠇ꠆ꠇꠤꠞꠦ ꠎꠦꠞꠣ ꠝꠣꠘꠍꠦ ꠘꠣ, ꠔꠣꠞꠣ ꠔ ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣꠞꠦꠃ ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣ ꠛꠣꠘꠣꠁꠟꠤꠍꠦ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣꠄ ꠘꠤꠎꠦ ꠔꠣꠘ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠦ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠍꠂꠘ, ꠔꠣꠞꠣ ꠁꠔꠣ ꠝꠣꠘꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J15_11","092_5_11","1JN","5","11","11","ꠔꠣꠘ ꠡꠣꠇ꠆ꠇꠤ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠀꠝꠞꠣꠞꠦ ꠀꠈꠦꠞꠣꠔꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠣꠘ ꠇꠞꠍꠂꠘ, ꠅꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠞ ꠉꠦꠍꠦ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("J15_12","092_5_12","1JN","5","12","12","ꠎꠦ ꠝꠣꠘꠡꠦ ꠅꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞꠦ ꠙꠣꠁꠍꠦ, ꠢꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠅ ꠙꠣꠁꠍꠦ। ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠢꠃ ꠝꠣꠄꠀꠞ ꠎꠘꠞꠦ ꠎꠦꠞꠣ ꠙꠣꠁꠍꠦ ꠘꠣ, ꠔꠣꠞꠣ ꠁ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠅ ꠙꠣꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J15_13","092_5_13","1JN","5","13","13","ꠜꠣꠁꠀꠁꠘꠞꠦ, ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠁꠍꠣ ꠁꠛꠘꠥꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠁꠝꠣꠘ ꠀꠘꠍ, ꠔꠥꠝꠞꠣꠞꠦ ꠎꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠁꠔꠣ ꠟꠦꠈꠟꠣꠝ, ꠔꠥꠝꠞꠣ ꠀꠈꠦꠞꠣꠔꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠟꠤꠍ। ");
INSERT INTO syls_vpl VALUES ("J15_14","092_5_14","1JN","5","14","14","ꠅꠈꠘ ꠀꠝꠞꠣ ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠅꠃ ꠡꠣꠅꠡ ꠙꠣꠁꠍꠤ, ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠝꠣꠚꠤꠇ ꠀꠝꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠝꠣꠉꠤꠟꠦ, ꠁꠔꠣ ꠔꠣꠁꠘ ꠢꠥꠘꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("J15_15","092_5_15","1JN","5","15","15","ꠀꠝꠞꠣ ꠎꠦꠛꠟꠣ ꠎꠣꠘꠤ, ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠝꠣꠉꠤ ꠁꠔꠣ ꠔꠣꠁꠘ ꠢꠥꠘꠂꠘ, ꠔꠦ ꠄꠅꠈꠣꠘꠅ ꠎꠣꠘꠤ, ꠔꠣꠘ ꠖꠞꠛꠣꠞꠅ ꠀꠝꠞꠣ ꠎꠦꠔꠣ ꠝꠣꠉꠤꠍꠤ, ꠁꠔꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠙꠣꠁꠟꠤꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("J15_16","092_5_16","1JN","5","16","16","ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘꠥ ꠝꠥꠝꠤꠘ ꠜꠣꠁꠞꠦ ꠅꠟꠣ ꠄꠇ ꠉꠥꠘꠣ ꠇꠞꠣꠔ ꠖꠦꠈꠦ, ꠎꠦ ꠉꠥꠘꠣ ꠝꠃꠔꠞ ꠙꠕꠤ ꠘꠣꠄ, ꠔꠦ ꠢꠦ ꠀꠞꠎ ꠇꠞꠟꠦ ꠀꠟ꠆ꠟꠣꠄ ꠢꠃ ꠜꠣꠁꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠛꠣ। ꠀꠝꠤ ꠁꠘꠅ ꠅꠃ ꠟꠣꠈꠣꠘ ꠉꠥꠘꠣꠞ ꠇꠕꠣ ꠇꠁꠞꠣꠝ, ꠎꠦꠞꠣꠞ ꠉꠥꠘꠣ ꠝꠃꠔꠞ ꠙꠕꠤ ꠘꠣꠄ। ꠅꠁꠟꠦ ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠝꠃꠔꠞ ꠙꠕꠤ ꠉꠥꠘꠣꠅ ꠀꠍꠦ, ꠁꠟꠣ ꠉꠥꠘꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠞꠎ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠇꠁꠞꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J15_17","092_5_17","1JN","5","17","17","ꠀꠍꠟꠦ ꠢꠇꠟ ꠎꠣꠔꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠃ ꠉꠥꠘꠣ, ꠅꠁꠟꠦ ꠢꠇꠟ ꠉꠥꠘꠣ ꠔ ꠝꠃꠔꠞ ꠙꠕꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("J15_18","092_5_18","1JN","5","18","18","ꠀꠝꠞꠣ ꠎꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞ ꠕꠣꠇꠤ ꠎꠦ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠎꠘꠝ ꠅꠁꠍꠦ, ꠄꠞꠣ ꠉꠥꠘꠣꠞ ꠇꠣꠝꠅ ꠛꠘ꠆ꠖꠤ ꠞꠄ ꠘꠣ। ꠛꠞꠋ ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠦ ꠎꠘꠝ ꠟꠅꠀ ꠢꠃ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘꠦ ꠔꠣꠞꠣꠞ ꠎꠣꠘꠞ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠂꠘ, ꠁꠛꠟꠤꠍꠦ ꠔꠣꠞꠣꠞꠦ ꠇꠛꠎꠣ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J15_19","092_5_19","1JN","5","19","19","ꠀꠞ ꠀꠝꠞꠣ ꠔ ꠎꠣꠘꠤ, ꠈꠣꠟꠤ ꠀꠝꠞꠣꠃ ꠅꠁꠟꠣꠝ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠘꠥꠡ, ꠛꠣꠖ-ꠛꠣꠇꠤ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠃ ꠁꠛꠟꠤꠍꠞ ꠙꠣꠅꠞ ꠔꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("J15_20","092_5_20","1JN","5","20","20","ꠀꠝꠞꠣ ꠄꠅꠈꠣꠘꠅ ꠎꠣꠘꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠀꠁꠀ ꠢꠣꠞꠤ ꠀꠝꠞꠣꠞꠦ ꠅꠃ ꠀꠈꠟ ꠖꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠢꠇ ꠀꠟ꠆ꠟꠣꠞꠦ ꠀꠝꠞꠣ ꠌꠤꠘꠤ। ꠔꠦ ꠢꠇ ꠀꠟ꠆ꠟꠣꠞ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠝꠤꠟꠘ ꠅꠁꠍꠦ, ꠝꠣꠘꠤ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠀꠝꠞꠣꠞ ꠝꠤꠟꠘ ꠅꠁꠍꠦ। ꠔꠣꠁꠘꠃ ꠔ ꠢꠇ ꠀꠟ꠆ꠟꠣ, ꠔꠣꠁꠘꠃ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("J15_21","092_5_21","1JN","5","21","21","ꠅ ꠍꠣꠛꠣꠟ ꠅꠇꠟ, ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠤꠀ ꠞꠅ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("J21_1","093_1_1","2JN","1","1","1","ꠀꠝꠤ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤꠄ ꠁꠔꠣ ꠟꠦꠈꠞꠣꠝ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠍꠘ꠆ꠖꠞ ꠢꠃ ꠛꠦꠉꠝ ꠍꠣꠄꠛꠣꠘꠤ ꠀꠞ ꠔꠣꠘ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞ ꠉꠦꠍꠦ। ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠝꠤ ꠎꠣꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ, ꠈꠣꠟꠤ ꠀꠝꠤ ꠘꠣꠄ, ꠀꠞꠅ ꠎꠔ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇ ꠎꠣꠘꠍꠂꠘ ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠎꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠅꠃ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("J21_2","093_1_2","2JN","1","2","2","ꠅꠃ ꠢꠇ ꠔ ꠅꠈꠘ ꠀꠝꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠛꠡꠔ ꠇꠞꠦ ꠀꠞ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("J21_3","093_1_3","2JN","1","3","3","ꠢꠇ ꠀꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠈꠣꠔꠤꠞꠦ, ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠅꠃ ꠛꠣꠚꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠄꠁꠘꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ, ꠄꠞꠣꠞ ꠔꠞꠚ ꠕꠣꠇꠤ ꠞꠢꠝꠔ, ꠝꠦꠢꠦꠞꠛꠣꠘꠤ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠀꠝꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("J21_4","093_1_4","2JN","1","4","4","ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠎꠦꠟꠣ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠂꠘ, ꠢꠃ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠀꠙꠘꠣꠞ ꠇꠄꠎꠘ ꠙꠥꠀ-ꠙꠥꠠꠤꠘ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠙꠕꠦ ꠌꠟꠦꠞ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("J21_5","093_1_5","2JN","1","5","5","ꠅ ꠝꠣꠄꠀꠞ ꠍꠣꠄꠛꠣꠘꠤ, ꠀꠙꠘꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠣꠞ ꠄꠇꠐꠣ ꠅꠘꠥꠞꠥꠗ ꠀꠍꠦ, ꠀꠝꠞꠣ ꠎꠣꠘꠥ ꠙꠞꠔꠦꠇꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ। ꠀꠞ ꠅꠃ ꠎꠦ ꠅꠘꠥꠞꠥꠗ ꠀꠝꠤ ꠇꠞꠤꠀꠞ, ꠁꠐꠣ ꠔ ꠘꠄꠀ ꠇꠥꠘꠥ ꠢꠥꠇꠥꠝ ꠘꠣꠄ, ꠛꠞꠋ ꠝꠥꠟꠅ ꠕꠣꠇꠤꠃ ꠀꠝꠞꠣ ꠅꠃ ꠢꠥꠇꠥꠝ ꠙꠣꠁꠍꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("J21_6","093_1_6","2JN","1","6","6","ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠚꠤꠇ ꠌꠟꠣꠃ ꠅꠁꠟ ꠝꠢꠛ꠆ꠛꠔ। ꠔꠥꠝꠞꠣ ꠙꠄꠟꠣ ꠕꠣꠇꠤ ꠎꠦ ꠢꠥꠇꠥꠝꠞ ꠇꠕꠣ ꠢꠥꠘꠤꠀ ꠀꠁꠞꠣꠄ, ꠅꠟꠣꠈꠣꠘ ꠝꠢꠛ꠆ꠛꠔꠞ ꠙꠕꠦ ꠌꠟꠅ। ");
INSERT INTO syls_vpl VALUES ("J21_7","093_1_7","2JN","1","7","7","ꠖꠥꠘꠤꠀꠔ ꠅꠈꠘ ꠛꠃꠔ ꠟꠣꠈꠣꠘ ꠗꠥꠇꠣꠛꠣꠎ ꠛꠣꠞ ꠅꠁꠍꠂꠘ। ꠎꠦꠔꠣꠄ ꠇꠂꠘ, ꠝꠣꠘꠥꠡ ꠍꠥꠞꠔꠦ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠍꠂꠘ ꠘꠣ, ꠁꠟꠣ ꠝꠣꠔ ꠎꠦꠞꠣ ꠝꠣꠔꠦ ꠄꠞꠣ ꠅꠁꠟ ꠢꠃ ꠗꠥꠇꠣꠛꠣꠎ ꠀꠞ ꠈꠣꠘꠦ-ꠖꠞ꠆ꠎꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("J21_8","093_1_8","2JN","1","8","8","ꠔꠦ ꠔꠥꠝꠞꠣ ꠢꠥꠡꠤꠀꠞ ꠞꠁꠅ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠦꠘꠔꠞ ꠚꠟ ꠘꠣ ꠀꠞꠣꠁꠀ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠇꠣꠝꠣꠁꠔꠣꠄ ꠙꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("J21_9","093_1_9","2JN","1","9","9","ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠀꠟ-ꠝꠍꠤꠞ ꠖꠦꠅꠀ ꠔꠣꠟꠤꠝꠞ ꠡꠤꠝꠣ ꠙꠣꠞ ꠅꠁ ꠎꠣꠁꠘ, ꠔꠣꠘ ꠔꠣꠟꠤꠝꠞ ꠜꠤꠔꠞꠦ ꠞꠂꠘ ꠘꠣ, ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠜꠤꠔꠞꠦ ꠀꠟ꠆ꠟꠣ ꠘꠣꠁ। ꠅꠁꠟꠦ ꠎꠦ ꠝꠣꠘꠥꠡ ꠔꠣꠘ ꠔꠣꠟꠤꠝꠞ ꠃꠙꠞꠦ ꠕꠤꠞ ꠞꠄ, ꠔꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠞ ꠔꠣꠘ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠁ ꠖꠥꠁꠅꠎꠘꠃ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("J21_10","093_1_10","2JN","1","10","10","ꠇꠥꠘꠥ ꠃꠡ꠆ꠔꠣꠖ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠟꠦ ꠢꠦ ꠎꠥꠖꠤ ꠅꠃ ꠟꠣꠈꠣꠘ ꠔꠣꠟꠤꠝ ꠘꠣ ꠖꠦꠄ, ꠔꠦ ꠔꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠇꠞꠤꠅ ꠘꠣ, ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠛꠣꠠꠤꠔ ꠀꠡꠞꠄꠅ ꠖꠤꠅ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J21_11","093_1_11","2JN","1","11","11","ꠔꠣꠞꠦ ꠎꠦꠉꠤꠄ ꠍꠣꠟꠣꠝ ꠇꠞꠛ, ꠢꠦ ꠔ ꠅꠉꠥꠞ ꠛꠖ ꠇꠣꠝꠞ ꠜꠣꠉꠤ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("J21_12","093_1_12","2JN","1","12","12","ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠔ ꠀꠝꠣꠞ ꠀꠞꠅ ꠛꠃꠔ ꠇꠕꠣ ꠟꠦꠈꠣꠞ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠇꠣꠉꠎ-ꠇꠟꠝꠦ ꠢꠇꠟꠔꠣ ꠟꠦꠈꠔꠣꠝ ꠌꠣꠁꠞꠣꠝ ꠘꠣ। ꠛꠞꠋ ꠀꠝꠣꠞ ꠈꠤꠀꠟ ꠅꠁꠟ, ꠀꠝꠤ ꠘꠤꠎꠦ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠟꠉꠦ ꠛꠁꠀ ꠍꠣꠝꠘꠣ-ꠍꠣꠝꠘꠤ ꠉꠚ ꠇꠞꠝꠥ, ꠔꠦꠃ ꠢꠇꠟꠞ ꠜꠤꠔꠞꠞ ꠈꠥꠡꠤ ꠝꠤꠐꠛ। ");
INSERT INTO syls_vpl VALUES ("J21_13","093_1_13","2JN","1","13","13","ꠀꠙꠘꠣꠞ ꠎꠦ ꠛꠁꠘꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠙꠍꠘ꠆ꠖ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠦ ꠀꠙꠘꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠞꠣ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("J31_1","094_1_1","3JN","1","1","1","ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠈꠣꠔꠤꠞꠦ ꠀꠝꠤ ꠎꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ, ꠀꠝꠣꠞ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ ꠉꠃꠍꠞ ꠉꠦꠍꠦ, ꠀꠝꠤ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤꠄ ꠁꠔꠣ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("J31_2","094_1_2","3JN","1","2","2","ꠅ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ, ꠀꠝꠤ ꠖꠥꠀ ꠇꠞꠤꠀꠞ ꠔꠥꠝꠣꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠎꠣꠘꠥ ꠡꠑꠤꠇ ꠜꠣꠛꠦ ꠌꠟꠦ, ꠀꠞꠅ ꠌꠣꠁꠀꠞ ꠔꠥꠝꠣꠞ ꠖꠤꠟ ꠎꠦꠟꠣ ꠜꠣꠟꠣ ꠔꠥꠝꠣꠞ ꠡꠞꠤꠟ-ꠉꠔꠞꠅ ꠎꠣꠘꠥ ꠅꠟꠣ ꠜꠣꠟꠣ ꠕꠣꠇꠦ। ");
INSERT INTO syls_vpl VALUES ("J31_3","094_1_3","3JN","1","3","3","ꠔꠥꠝꠣꠞ ꠅꠈꠣꠘ ꠕꠣꠇꠤ ꠇꠄꠎꠘ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠀꠁꠀ ꠇꠁꠟꠣ, ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠤ ꠛꠥꠟꠦ ꠝꠎꠛꠥꠔ ꠀꠍ, ꠁꠈꠣꠘ ꠢꠥꠘꠤꠀ ꠀꠝꠤ ꠈꠥꠛ ꠈꠥꠡꠤ ꠅꠁꠍꠤ। ");
INSERT INTO syls_vpl VALUES ("J31_4","094_1_4","3JN","1","4","4","ꠀꠝꠣꠞ ꠀꠅꠟꠣꠖ ꠅꠇꠟ ꠀꠟ꠆ꠟꠣꠁ ꠢꠇꠞ ꠙꠕꠦ ꠌꠟꠞꠣ ꠢꠥꠘꠤꠀ ꠈꠥꠡꠤ ꠟꠣꠉꠦꠞ, ꠁꠈꠣꠘ ꠕꠣꠇꠤ ꠛꠠ ꠀꠞ ꠇꠥꠘꠥ ꠈꠥꠡꠤꠞ ꠈꠛꠞ ꠅꠄ ꠘꠤ? ");
INSERT INTO syls_vpl VALUES ("J31_5","094_1_5","3JN","1","5","5","ꠅ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ, ꠔꠥꠝꠣꠞ ꠅꠌꠤꠘꠣ ꠢꠃ ꠝꠥꠍꠣꠚꠤꠞ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠎꠦꠟꠣ ꠈꠦꠎꠝꠔ ꠇꠞꠍ, ꠁꠔꠣ ꠔ ꠈꠣꠐꠤ ꠝꠥꠝꠤꠘꠞ ꠇꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("J31_6","094_1_6","3JN","1","6","6","ꠔꠥꠝꠣꠞ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔꠞ ꠇꠕꠣ ꠔꠣꠞꠣ ꠎꠝꠣꠔꠞ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠇꠁꠍꠦ। ꠅꠈꠘ ꠀꠟ꠆ꠟꠣꠞ ꠈꠥꠡꠤ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞꠦ ꠍꠢꠤ-ꠍꠣꠟꠣꠝꠔꠦ ꠙꠣꠑꠣꠘꠤꠞ ꠛꠦꠛꠡ꠆ꠔꠣ ꠇꠞꠤ ꠖꠦꠅ, ꠔꠦ ꠀꠞꠅ ꠜꠣꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("J31_7","094_1_7","3JN","1","7","7","ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠔꠛꠟꠤꠉꠅ ꠛꠣꠞ ꠅꠁꠍꠂꠘ, ꠔꠞꠤꠇꠣꠞ ꠛꠣꠁꠞꠣ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠇꠥꠘꠥ ꠡꠣꠁꠎ꠆ꠎ ꠟꠁꠍꠂꠘ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J31_8","094_1_8","3JN","1","8","8","ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠣ ꠎꠞꠥꠞ, ꠎꠣꠔꠦ ꠢꠇ ꠇꠣꠝꠅ ꠀꠝꠞꠣꠅ ꠡꠞꠤꠇ ꠕꠣꠇꠤ। ");
INSERT INTO syls_vpl VALUES ("J31_9","094_1_9","3JN","1","9","9","ꠀꠝꠤ ꠀꠉꠦ ꠎꠝꠣꠔꠞ ꠉꠦꠍꠦ ꠄꠇꠈꠣꠘ ꠌꠤꠑꠤ ꠟꠦꠈꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠈꠛꠤꠍ ꠖꠤꠔ꠆ꠞꠤꠚꠦ ꠎꠝꠣꠔꠞ ꠘꠦꠔꠣꠉꠤꠞꠤ ꠇꠞꠔ ꠌꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠀꠝꠞꠣꠞ ꠇꠕꠣ ꠢꠥꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J31_10","094_1_10","3JN","1","10","10","ꠅꠈꠘ ꠢꠦ ꠎꠦꠔꠣ ꠇꠞꠦꠞ, ꠀꠝꠤ ꠀꠁꠀ ꠢꠣꠞꠤ ꠁꠔꠣ ꠢꠇꠟꠞꠦ ꠎꠣꠘꠣꠁꠝꠥ। ꠢꠦ ꠀꠝꠞꠣꠞꠦ ꠁꠋꠡꠣ ꠇꠞꠤꠀ ꠛꠃꠔ ꠝꠤꠍꠣ ꠛꠖꠘꠣꠝ ꠞꠐꠣꠁꠍꠦ। ꠈꠣꠟꠤ ꠁꠈꠣꠘ ꠘꠣꠄ, ꠝꠥꠝꠤꠘ ꠇꠥꠘꠥ ꠜꠣꠁꠞꠦ ꠢꠦ ꠝꠣꠘꠦꠞ ꠘꠣ, ꠀꠞ ꠅꠁꠘ꠆ꠘ ꠎꠦꠞꠣ ꠝꠣꠘꠔ ꠌꠣꠄ, ꠔꠣꠞꠣꠞꠦꠅ ꠛꠣꠗꠣ ꠖꠦꠞ, ꠄꠝꠘꠇꠤ ꠎꠝꠣꠔ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("J31_11","094_1_11","3JN","1","11","11","ꠅ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ, ꠔꠥꠝꠤ ꠛꠖ ꠇꠣꠝꠞ ꠈꠞꠦꠖꠤ ꠘꠣ ꠖꠃꠠꠣꠁꠀ ꠛꠞꠋ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠅ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠘꠦꠇ ꠇꠣꠝ ꠇꠞꠦ ꠢꠦ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ, ꠀꠞ ꠎꠦꠉꠤꠄ ꠛꠖ ꠇꠣꠝ ꠇꠞꠦ, ꠢꠦ ꠔ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠡꠘ ꠙꠣꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J31_12","094_1_12","3JN","1","12","12","ꠎꠣꠘ ꠘꠤ, ꠢꠇꠟꠦꠃ ꠖꠤꠝꠤꠔ꠆ꠞꠤ ꠜꠣꠁꠞ ꠡꠥꠘꠣꠝ ꠉꠣꠁꠞꠣ, ꠄꠝꠘꠇꠤ ꠡ꠆ꠛꠄꠅꠋ ꠀꠟ꠆ꠟꠣꠞ ꠢꠇꠦꠅ ꠄꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠞꠣ। ꠀꠝꠞꠣꠅ ꠄꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠞꠣꠝ, ꠀꠞ ꠔꠥꠝꠤ ꠔ ꠎꠣꠘ ꠀꠝꠞꠣꠞ ꠝꠥꠈꠞ ꠇꠕꠣ ꠢꠣꠍꠣ। ");
INSERT INTO syls_vpl VALUES ("J31_13","094_1_13","3JN","1","13","13","ꠜꠣꠁꠞꠦ, ꠔꠥꠝꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠣꠞ ꠛꠃꠔꠔꠣ ꠀꠍꠤꠟ, ꠅꠁꠟꠦ ꠇꠟꠝꠦ-ꠇꠣꠟꠤꠄ ꠢꠇꠟꠔꠣ ꠟꠦꠈꠞꠣꠝ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("J31_14","094_1_14","3JN","1","14","14","ꠀꠡꠣ ꠀꠍꠦ, ꠈꠥꠛ ꠎꠟꠖꠤ ꠔꠥꠝꠣꠞ ꠟꠉꠦ ꠖꠦꠈꠣ-ꠡꠣꠇ꠆ꠇꠣꠔ ꠅꠁꠛ, ꠅꠃ ꠡꠝꠄ ꠝꠥꠈꠣꠝꠥꠈꠤ ꠢꠇꠟꠔꠣ ꠉꠚ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("J31_15","094_1_15","3JN","1","15","15","ꠔꠥꠝꠣꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟꠦꠅ ꠔꠥꠝꠣꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠍꠂꠘ। ꠀꠝꠞꠣꠞ ꠢꠇꠟ ꠛꠘ꠆ꠖꠥ-ꠛꠣꠘ꠆ꠖꠛꠞꠦ ꠍꠣꠟꠣꠝ ꠎꠣꠘꠣꠁꠅ। ꠀꠍꠍꠣꠟꠣꠝꠥ ꠀꠟꠣꠁꠇꠥꠝ॥");
INSERT INTO syls_vpl VALUES ("JD1_1","095_1_1","JUD","1","1","1","ꠀꠝꠤ ꠄꠢꠥꠖꠣ ꠔ ꠍꠣꠢꠣꠛꠤ ꠁꠀꠇꠥꠛꠞ ꠜꠣꠁ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠉꠥꠟꠣꠝ। ꠀꠝꠞꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠎꠦꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠁ ꠖꠣꠅꠔ ꠙꠣꠁꠍꠂꠘ, ꠀꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠎꠦꠞꠣꠞ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠂꠘ, ꠅꠃ ꠍꠢꠤꠚꠣꠈꠣꠘ ꠀꠝꠤ ꠄꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠞꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("JD1_2","095_1_2","JUD","1","2","2","ꠔꠥꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠛꠦꠡ ꠇꠞꠤ ꠝꠦꠢꠦꠞꠛꠣꠘꠤ, ꠡꠣꠘ꠆ꠔꠤ ꠀꠞ ꠝꠢꠛ꠆ꠛꠔ ꠎꠣꠞꠤ ꠞꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("JD1_3","095_1_3","JUD","1","3","3","ꠅ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟ, ꠀꠝꠞꠣ ꠢꠇꠟꠦ ꠝꠤꠟꠤ ꠎꠦ ꠘꠣꠎꠣꠔꠞ ꠜꠣꠉꠤ ꠅꠁꠍꠤ, ꠅꠃ ꠘꠣꠎꠣꠔꠞ ꠛꠦꠙꠣꠞꠦ ꠀꠝꠤ ꠈꠥꠛ ꠈꠤꠀꠟꠤ ꠅꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠔꠣꠝ ꠌꠣꠁꠍꠤ। ꠄꠞꠝꠣꠎꠦ ꠛꠥꠎꠟꠣꠝ, ꠀꠞꠅ ꠖꠞꠇꠣꠞ ꠀꠍꠦ ꠁꠝꠣꠘꠞ ꠟꠣꠉꠤ ꠟꠣꠠꠣꠁꠞ ꠛꠦꠙꠣꠞꠦ ꠟꠦꠈꠤꠀ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠔꠡꠣꠢ ꠖꠦꠅꠀ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠎꠦ ꠁꠝꠣꠘꠤ ꠗꠘ ꠖꠤꠍꠂꠘ, ꠅꠃ ꠁꠍꠣꠄꠁ ꠁꠝꠣꠘꠞ ꠙꠇ꠆ꠇꠦ ꠖꠤꠟꠦ-ꠎꠣꠘꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣ ꠔ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("JD1_4","095_1_4","JUD","1","4","4","ꠁꠔꠣꠞ ꠎꠞꠥꠞ ꠅꠁꠍꠦ, ꠇꠣꠞꠘ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠛꠦ-ꠖꠤꠘꠤ ꠇꠣꠝꠞ ꠡꠣꠎꠣ ꠙꠣꠁꠛꠣꠞ ꠇꠕꠣ ꠀꠉ ꠕꠣꠇꠤꠃ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, ꠔꠟꠦ ꠔꠟꠦ ꠅꠔꠣ ꠝꠣꠘꠥꠡ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠖꠟꠅ ꠢꠣꠝꠣꠁ ꠉꠦꠍꠦ। ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠞꠢꠝꠔꠞꠦ ꠔꠣꠞꠣꠞ ꠛꠖ ꠈꠣꠁꠡ ꠝꠤꠐꠣꠘꠤꠞ ꠀꠔꠤꠀꠞ ꠛꠣꠘꠣꠁꠍꠦ, ꠀꠞ ꠀꠝꠞꠣꠞ ꠄꠇꠝꠣꠔ꠆ꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠟꠐꠣ ꠌꠟꠦ। ");
INSERT INTO syls_vpl VALUES ("JD1_5","095_1_5","JUD","1","5","5","ꠔꠦ ꠅꠃ ꠛꠦꠙꠣꠞ ꠔ ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠞꠤꠃ ꠎꠣꠘ, ꠔꠣ-ꠅ ꠀꠝꠤ ꠈꠣꠟꠤ ꠅꠈꠣꠘ ꠝꠘꠅ ꠇꠞꠣꠁ ꠖꠤꠞꠣꠝ, ꠝꠤꠡꠞ ꠖꠦꠡ ꠕꠣꠇꠤ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠀꠎꠣꠖ ꠇꠞꠤꠀ ꠀꠘꠣꠞ ꠛꠣꠖꠦ, ꠔꠣꠞꠣꠞ ꠝꠣꠎꠞ ꠎꠦꠔꠣꠄ ꠁꠝꠣꠘ ꠀꠘꠍꠤꠟ ꠘꠣ, ꠝꠣꠟꠤꠇꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("JD1_6","095_1_6","JUD","1","6","6","ꠀꠞ ꠎꠦꠔꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠘꠤꠎꠞ ꠖꠣꠄ-ꠖꠣꠄꠁꠔ꠆ꠔ ꠀꠖꠣꠄ ꠘꠣ ꠇꠞꠤꠀ, ꠘꠤꠎꠞ ꠀꠡꠘ ꠕꠣꠇꠤ ꠢꠞꠤ ꠉꠦꠍꠟꠣ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠌꠤꠞꠇꠣꠟ ꠗꠞꠤ ꠡꠤꠇꠟꠖꠤ ꠛꠣꠘ꠆ꠖꠤꠀ ꠉꠁꠘ ꠀꠘ꠆ꠖꠣꠁꠞ ꠊꠞꠅ ꠞꠣꠈꠍꠂꠘ ꠢꠣꠡꠞꠞ ꠖꠤꠘꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("JD1_7","095_1_7","JUD","1","7","7","ꠅꠃ ꠟꠣꠈꠣꠘ ꠢꠎꠞꠔ ꠟꠥꠔ ꠘꠛꠤꠞ ꠎꠝꠣꠘꠣꠞ ꠍꠣꠖꠥꠝ, ꠀꠝꠥꠞꠣ ꠀꠞ ꠇꠣꠘ꠆ꠖꠣ-ꠇꠣꠍꠣꠞ ꠢꠇꠟ ꠐꠣꠃꠘꠞ ꠝꠣꠘꠡꠦ ꠅꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠎꠤꠘꠣ ꠇꠞꠍꠤꠟ, ꠈꠣꠟꠤ ꠎꠤꠘꠣ ꠘꠣꠄ, ꠔꠣꠞꠣ ꠈꠥꠛ ꠈꠛꠤꠍꠤ ꠎꠤꠘꠣ ꠇꠞꠣꠄ ꠌꠤꠞꠇꠣꠟ ꠗꠞꠤ ꠖꠥꠎꠈꠅ ꠎꠟꠛ, ꠁꠔꠣ ꠅꠁꠟ ꠄꠇꠐꠣ ꠘꠤꠡꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("JD1_8","095_1_8","JUD","1","8","8","ꠄꠞꠛꠣꠖꠦꠅ ꠅꠃ ꠜꠘ꠆ꠒ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟ, ꠎꠦꠔꠣꠄ ꠛꠣꠎꠦ ꠈꠥꠀꠛ ꠖꠦꠈꠤ ꠖꠦꠈꠤ ꠔꠣꠟꠤꠝ ꠖꠦꠁꠘ, ꠔꠣꠞꠣ ꠈꠛꠤꠍꠤ ꠇꠣꠝ ꠇꠞꠂꠘ, ꠇꠥꠘꠥꠎꠣꠔ ꠡꠣꠡꠘ ꠝꠣꠘꠂꠘ ꠘꠣ, ꠀꠞ ꠛꠣꠔꠥꠘꠤ ꠡꠞ꠆ꠖꠣꠞ ꠅꠇꠟꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("JD1_9","095_1_9","JUD","1","9","9","ꠄꠝꠘꠇꠤ ꠀꠍꠝꠣꠘꠞ ꠡꠞ꠆ꠖꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠝꠤꠇꠣꠁꠟꠦ ꠎꠦꠛꠟꠣ ꠢꠎꠞꠔ ꠝꠥꠍꠣꠞ ꠟꠣꠡ ꠟꠁꠀ ꠁꠛꠟꠤꠍꠞ ꠟꠉꠦ ꠔꠞ꠆ꠇꠣ-ꠔꠞ꠆ꠇꠤ ꠇꠞꠍꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠔꠣꠁꠘ ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠁꠀ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣꠞ ꠡꠣꠅꠡ ꠇꠞꠟꠣ ꠘꠣ, ꠛꠞꠋ ꠇꠁꠟꠣ, “ꠝꠣꠟꠤꠇꠦ ꠎꠣꠘꠥ ꠔꠥꠝꠣꠞꠦ ꠛꠘ꠆ꠖ ꠇꠞꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("JD1_10","095_1_10","JUD","1","10","10","ꠅꠁꠟꠦ ꠅꠃ ꠜꠘ꠆ꠒ ꠃꠡ꠆ꠔꠣꠖ ꠅꠇꠟꠦ ꠎꠦꠔꠣ ꠛꠥꠎꠦ ꠘꠣ ꠅꠔꠣꠞ ꠛꠖꠘꠣꠝ ꠉꠣꠄ, ꠀꠞ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞꠞ ꠟꠣꠈꠣꠘ ꠘꠤꠎꠞ ꠀꠈꠟꠦ ꠘꠤꠎꠞ ꠡꠞ꠆ꠛꠘꠣꠡ ꠊꠐꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("JD1_11","095_1_11","JUD","1","11","11","ꠁꠔꠣ ꠔ ꠟꠣꠘ꠆ꠘꠔꠤ! ꠁꠉꠥꠁꠘ ꠛꠣꠛꠣ ꠀꠖꠝꠞ ꠟꠣꠘ꠆ꠘꠔꠤ ꠙꠥꠔ ꠇꠣꠛꠤꠟꠞ ꠟꠣꠈꠣꠘ ꠛꠘꠍꠂꠘ। ꠖꠥꠘꠤꠀꠛꠤ ꠟꠣꠜꠞ ꠀꠡꠣꠄ ꠔꠣꠞꠣ ꠢꠃ ꠜꠘ꠆ꠒ ꠘꠛꠤ ꠛꠣꠟꠣꠝꠞ ꠈꠣꠁꠡꠞ ꠀꠔꠅ ꠘꠤꠎꠞꠦ ꠡꠙꠤ ꠖꠤꠍꠦ। ꠀꠞ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠛꠣꠄ ꠛꠤꠉꠠꠤ ꠎꠣꠅꠞꠣ ꠢꠃ ꠘꠦꠔꠣ ꠇꠥꠞꠣꠢꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞꠣꠞ ꠛꠤꠘꠣꠡ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JD1_12","095_1_12","JUD","1","12","12","ꠔꠦ ꠅꠃ ꠟꠣꠘ꠆ꠘꠔꠤ ꠅꠔꠣ ꠀꠁꠀ ꠎꠦꠛꠟꠣ ꠛꠦ-ꠡꠞꠝꠞ ꠟꠣꠈꠣꠘ ꠔꠥꠝꠞꠣꠞ ꠝꠦꠎꠛꠣꠘꠤ ꠈꠣꠄ, ꠅꠃ ꠡꠝꠄ ꠁꠔꠣ ꠅꠁꠎꠣꠁꠘ ꠔꠥꠝꠞꠣꠞ ꠈꠣꠘꠤꠞ ꠕꠣꠟꠞ ꠝꠄꠟꠣ। ꠔꠣꠞꠣ ꠈꠣꠟꠤ ꠘꠤꠎꠞ ꠡ꠆ꠛꠣꠞꠕꠞ ꠗꠣꠘ꠆ꠖꠣ ꠇꠞꠦ। ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠀꠍꠝꠣꠘꠅ ꠃꠠꠞꠣ ꠢꠥꠖꠣ ꠝꠦꠊꠞ ꠈꠥꠐꠤ, ꠛꠣ ꠛꠣꠉꠣꠘꠅ ꠖꠥꠁꠛꠣꠞ ꠝꠞꠣ-ꠢꠥꠇꠘꠣ ꠚꠟ ꠉꠣꠍ, ꠎꠦꠉꠤꠄ ꠚꠟ ꠘꠣ ꠗꠞꠣꠄ, ꠎꠠꠦ-ꠚꠠꠦ ꠢꠥꠞꠤꠀ ꠔꠥꠟꠤꠀ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("JD1_13","095_1_13","JUD","1","13","13","ꠀꠞ ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠔꠥꠚꠣꠘꠞ ꠇꠣꠟꠞ ꠖꠞꠤꠀꠞ ꠓꠦꠃꠞ ꠟꠣꠈꠣꠘ, ꠖꠞꠤꠀꠞ ꠓꠦꠃꠄ ꠎꠦꠟꠣ ꠚꠦꠘꠣꠞꠦ ꠜꠣꠡꠣꠁꠀ ꠔꠥꠟꠦ, ꠔꠣꠞꠣꠞ ꠛꠖ ꠇꠣꠝꠞ ꠡꠞꠝꠅ ꠅꠟꠣ ꠜꠣꠡꠤꠀ ꠃꠑꠦ। ꠔꠣꠞꠣ ꠅꠁꠟꠣ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠌꠇ꠆ꠇꠞ ꠖꠦꠅꠞꠣ ꠔꠦꠞꠣꠞ ꠟꠣꠈꠣꠘ, ꠁꠔꠣꠞ ꠢꠦꠡ ꠖꠡꠣ ꠅꠁꠟ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠇꠥꠞ ꠟꠣꠉꠤ ꠎꠝꠣ ꠞꠣꠈꠣ ꠉꠁꠘ ꠀꠘ꠆ꠖꠣꠁꠞ। ");
INSERT INTO syls_vpl VALUES ("JD1_14","095_1_14","JUD","1","14","14","ꠛꠣꠛꠣ ꠀꠖꠝꠞ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠎꠘ ꠢꠎꠞꠔ ꠁꠖ꠆ꠞꠤꠍꠦꠅ ꠅꠔꠣ ꠝꠣꠘꠡꠞ ꠛꠦꠙꠣꠞꠦ ꠇꠁꠀ ꠉꠦꠍꠂꠘ, “ꠢꠥꠘꠅ, ꠝꠣꠘꠡꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ, ꠝꠣꠟꠤꠇ ꠝꠃꠟꠣꠄ ꠔꠣꠘ ꠀꠎꠣꠞ ꠀꠎꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠟꠁꠀ ꠀꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("JD1_15","095_1_15","JUD","1","15","15","ꠎꠦꠔꠣꠄ ꠛꠦ-ꠖꠤꠘꠤ ꠇꠣꠝ ꠇꠞꠍꠂꠘ ꠀꠞ ꠔꠣꠘ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠟꠣꠘ꠆ꠘꠔꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠍꠂꠘ, ꠅꠈꠘ ꠅꠃ ꠛꠦ-ꠖꠤꠘ ꠉꠥꠘꠣꠉꠣꠞ ꠅꠇꠟꠞ ꠙꠣꠅꠘꠣ ꠢꠤꠡꠣꠛꠦ ꠔꠣꠁꠘ ꠁꠔꠣꠞꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠖꠥꠡꠤ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣꠔ ꠀꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("JD1_16","095_1_16","JUD","1","16","16","ꠁꠔꠣꠄ ꠔ ꠢꠣꠝꠦꠡꠣꠃ ꠘꠣ-ꠍꠛꠞꠤ ꠇꠞꠂꠘ, ꠘꠤꠎꠞ ꠇꠙꠣꠟꠞꠦ ꠖꠥꠡꠂꠘ ꠀꠞ ꠔꠣꠞꠣꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠛꠡꠦ ꠌꠟꠂꠘ। ꠔꠣꠞꠣꠞ ꠢꠇꠟ ꠝꠣꠔꠅ ꠘꠤꠎꠞ ꠛꠠꠣꠁ-ꠛꠦꠐꠣꠉꠤꠞꠤ ꠖꠦꠈꠣꠁꠘ, ꠡ꠆ꠛꠣꠞꠕ ꠢꠣꠍꠤꠟꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠞ ꠜꠎꠘꠣ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("JD1_17","095_1_17","JUD","1","17","17","ꠅꠁꠟꠦ ꠅ ꠝꠣꠄꠀꠞ ꠖꠥꠡ꠆ꠔ ꠅꠇꠟ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠇꠁꠞꠣꠝ, ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟꠦ ꠀꠉꠦ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠍꠂꠘ, ꠁꠔꠣ ꠝꠘꠅ ꠞꠣꠈꠤꠅ। ");
INSERT INTO syls_vpl VALUES ("JD1_18","095_1_18","JUD","1","18","18","ꠄꠞꠣ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠢꠥꠡꠤꠀꠞꠤ ꠖꠤꠔꠣ ꠘꠣ ꠘꠤ, “ꠀꠈꠦꠞꠤ ꠎꠝꠣꠘꠣꠔ ꠙꠞꠦꠎꠉꠣꠞꠞꠦ ꠑꠣꠐ꠆ꠐꠣ-ꠝꠡꠇꠞꠣ ꠇꠞꠞꠣ ꠄꠇꠎꠣꠔ ꠝꠣꠘꠥꠡ ꠀꠁꠛꠣ, ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠛꠦ-ꠖꠤꠘꠤ ꠛꠖ ꠈꠣꠁꠡ ꠝꠣꠚꠤꠇ ꠌꠟꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("JD1_19","095_1_19","JUD","1","19","19","ꠖꠥꠘꠤꠀꠛꠤ ꠜꠣꠛꠞ ꠁꠔꠣ ꠝꠣꠘꠡꠦ ꠈꠣꠟꠤ ꠖꠟꠣꠖꠟꠤ ꠟꠣꠉꠣꠁꠘ, ꠔꠣꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("JD1_20","095_1_20","JUD","1","20","20","ꠔꠣ-ꠅ ꠝꠣꠄꠀꠞ ꠜꠣꠁꠀꠁꠘ, ꠔꠥꠝꠞꠣꠞ ꠅꠃ ꠘꠤꠈꠥꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠁꠝꠣꠘꠞ ꠃꠙꠞꠦ ꠜꠞ ꠇꠞꠤꠀ ꠘꠤꠎꠞꠦ ꠉꠠꠤꠀ ꠔꠥꠟꠣꠔ ꠞꠅ, ꠀꠞ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠀ ꠝꠥꠘꠣꠎꠣꠔ ꠇꠞꠣꠔ ꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JD1_21","095_1_21","JUD","1","21","21","ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠛ꠆ꠛꠔꠞ ꠝꠣꠎꠦ ꠘꠤꠎꠞꠦ ꠛꠣꠘ꠆ꠖꠤꠀ ꠞꠣꠈꠅ, ꠀꠞ ꠀꠈꠦꠞꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠙꠣꠁꠛꠣꠞ ꠀꠡꠣꠄ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠝꠦꠢꠦꠞꠛꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠣꠞ ꠌꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("JD1_22","095_1_22","JUD","1","22","22","ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠁꠝꠣꠘꠦ ꠟꠠꠣ-ꠌꠠꠣ ꠇꠞꠦ, ꠔꠣꠞꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JD1_23","095_1_23","JUD","1","23","23","ꠀꠉꠥꠁꠘ ꠕꠣꠇꠤ ꠔꠥꠟꠤꠀ ꠀꠘꠤꠀ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠅ। ꠀꠞ ꠉꠥꠘꠣꠞ ꠛꠖ ꠈꠣꠁꠡꠞ ꠎꠣꠟꠣꠄ ꠎꠦꠔꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠛꠞꠛꠣꠖ ꠅꠁꠉꠦꠍꠦ, ꠁꠔꠣꠞ ꠚꠤꠘ꠆ꠘꠞ ꠘꠣꠙꠣꠇ ꠇꠣꠙꠠ ꠈꠣꠘꠞꠦꠅ ꠊꠤꠘ꠆ꠘꠣ ꠇꠞꠅ, ꠀꠞ ꠘꠤꠎꠞꠦ ꠢꠦꠚꠣꠎꠔꠦ ꠞꠣꠈꠤꠀ ꠔꠣꠞꠣꠞꠦ ꠖꠄꠀ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("JD1_24","095_1_24","JUD","1","24","24","ꠀꠞ ꠎꠦ ꠀꠟ꠆ꠟꠣꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠃꠡ꠆ꠐꠣ ꠈꠣꠅꠀ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠘ, ꠎꠦꠁꠘ ꠘꠤꠈꠥꠔ ꠢꠣꠟꠔꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠈꠥꠡꠤ-ꠛꠣꠡꠤꠄ ꠔꠣꠘ ꠡꠣꠘ-ꠔꠎꠟ꠆ꠟꠤꠞ ꠍꠣꠝꠘꠦ ꠀꠎꠤꠞ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("JD1_25","095_1_25","JUD","1","25","25","ꠢꠃ ꠄꠇꠝꠣꠔ꠆ꠞ ꠀꠟ꠆ꠟꠣ ꠎꠦꠁꠘ ꠀꠝꠞꠣꠞ ꠎꠣꠘ ꠛꠣꠌꠣꠁꠘ, ꠔꠣꠘ ꠎꠣꠟꠣꠟ-ꠡꠣꠘ, ꠝꠢꠤꠝꠣ, ꠇꠥꠖꠞꠔꠤ ꠛꠟ-ꠡꠇ꠆ꠔꠤ, ꠀꠞ ꠞꠣꠎ-ꠈꠦꠝꠔꠣ ꠀꠝꠞꠣꠞ ꠝꠣꠟꠤꠇ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠃꠍꠤꠟ꠆ꠟꠣꠄ ꠎꠣꠁꠞ ꠅꠃꠇ, ꠢꠇ꠆ꠇꠟ ꠎꠥꠉꠞ ꠀꠉ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠞ ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣꠃ ꠅꠟꠣ ꠅꠃꠇ। ꠀꠝꠤꠘ॥");
INSERT INTO syls_vpl VALUES ("RV1_1","096_1_1","REV","1","1","1","ꠅꠃ ꠇꠤꠔꠣꠛꠅ ꠎꠔꠔꠣ ꠟꠦꠈꠣ ꠅꠁꠍꠦ, ꠁꠔꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞꠦ ꠎꠣꠘꠣꠁꠍꠂꠘ, ꠀꠞ ꠀꠟ-ꠝꠍꠤꠄ ꠁꠔꠣ ꠎꠣꠁꠞ ꠇꠞꠍꠂꠘ। ꠕꠥꠠꠣ ꠖꠤꠘꠞ ꠜꠤꠔꠞꠦ ꠎꠦꠔꠣ ꠎꠦꠔꠣ ꠛꠦꠙꠣꠞ ꠘꠤꠌ꠆ꠌꠤꠔ ꠊꠐꠤꠛ, ꠁꠔꠣ ꠎꠣꠔꠦ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠎꠣꠘꠂꠘ। ꠀꠟ-ꠝꠍꠤꠄ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠙꠣꠑꠣꠁꠀ ꠘꠤꠎꠞ ꠉꠥꠟꠣꠝ ꠍꠣꠢꠣꠛꠤ ꠢꠣꠘ꠆ꠘꠣꠘꠞꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠎꠣꠘꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV1_2","096_1_2","REV","1","2","2","ꠍꠣꠢꠣꠛꠤ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠀꠞ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠡꠣꠇ꠆ꠇꠤꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠔ ꠖꠞꠡꠘ ꠖꠦꠈꠟꠣ, ꠅꠃ ꠖꠞꠡꠘꠞ ꠛꠦꠙꠣꠞꠦꠃ ꠔꠣꠁꠘ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV1_3","096_1_3","REV","1","3","3","ꠀꠞ ꠢꠃ ꠎꠘꠃ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ, ꠎꠦꠁꠘ ꠁ ꠇꠣꠟꠣꠝꠞ ꠀꠉꠣꠝ ꠈꠛꠞ ꠅꠇꠟ ꠔꠤꠟꠣꠅꠔ ꠇꠞꠂꠘ, ꠀꠞ ꠔꠣꠞꠣꠅ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ, ꠎꠦꠞꠣ ꠁ ꠇꠣꠟꠣꠝ ꠢꠥꠘꠂꠘ, ꠢꠥꠘꠤꠀ ꠢꠣꠞꠤ ꠀꠝꠟ ꠇꠞꠂꠘ; ꠇꠣꠞꠘ ꠡꠝꠄ ꠔ ꠗꠣꠞꠅ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV1_4","096_1_4","REV","1","4","5","ꠔꠦ ꠀꠝꠤ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠞꠥꠝꠣꠘ ꠛꠣꠖꠡꠣꠁꠞ ꠀꠍꠤꠀ ꠖꠦꠡꠞ ꠡꠣꠔꠅ ꠎꠝꠣꠔꠞ ꠉꠦꠍꠦ ꠅꠃ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠟꠦꠈꠞꠣꠝ। ꠎꠦꠁꠘ ꠀꠍꠟꠣ, ꠎꠦꠁꠘ ꠀꠍꠂꠘ ꠀꠞ ꠎꠦꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠞꠁꠛꠣ ꠢꠃ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ, ꠀꠞ ꠔꠣꠘ ꠔꠈ꠆ꠔꠞ ꠍꠣꠝꠘꠦ ꠎꠦ ꠡꠣꠔ ꠘꠝꠥꠘꠣꠞ ꠞꠥꠢꠥ ꠕꠣꠇꠂꠘ, ꠄꠞꠣ ꠀꠞ ꠎꠦꠁꠘ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠡꠣꠇ꠆ꠇꠤ ꠢꠃ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠄ ꠔꠥꠝꠞꠣꠞꠦ ꠞꠢꠝꠔ ꠀꠞ ꠡꠣꠘ꠆ꠔꠤ ꠖꠣꠘ ꠇꠞꠃꠇ꠆ꠇꠣ। ꠔꠣꠁꠘ ꠔ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠙꠄꠟꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠤꠍꠂꠘ, ꠔꠣꠁꠘꠃ ꠖꠥꠘꠤꠀꠞ ꠞꠣꠎꠣ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ। ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠂꠘ, ꠄꠞꠟꠣꠉꠤ ꠘꠤꠎꠞ ꠎꠣꠘ ꠇꠥꠞꠛꠣꠘꠤ ꠖꠤꠀ, ꠀꠝꠞꠣꠞꠦ ꠉꠥꠘꠣꠞ ꠡꠣꠎꠣ ꠕꠣꠇꠤ ꠛꠣꠌꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV1_6","096_1_6","REV","1","6","6","ꠔꠣꠁꠘ ꠀꠝꠞꠣꠞꠦ ꠟꠁꠀ ꠄꠇ ꠛꠣꠖꠡꠣꠁ ꠔꠤꠀꠞ ꠇꠞꠤꠀ, ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔꠤꠞ ꠟꠣꠉꠤ ꠁꠝꠣꠝ ꠛꠣꠘꠣꠁꠍꠂꠘ। ꠔꠣꠘ ꠝꠢꠤꠝꠣ ꠀꠞ ꠇꠥꠖꠞꠔꠤ ꠛꠟ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠛꠅꠀꠁꠟ ꠞꠃꠇ। ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("RV1_7","096_1_7","REV","1","7","7","ꠢꠥꠘꠅ, ꠔꠣꠁꠘ ꠝꠦꠊꠞ ꠌꠣꠇꠣꠔ ꠅꠁꠀ ꠔꠡꠞꠤꠚ ꠀꠘꠞꠣ, ꠙꠞꠔꠦꠇꠦ ꠔꠣꠘꠞꠦ ꠌꠃꠈꠖꠤ ꠖꠦꠈꠛ, ꠎꠣꠞꠣ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠍꠟꠤꠛꠅ ꠉꠣꠕꠤꠀ ꠔꠣꠘꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠤꠟꠤꠍꠤꠟ ꠔꠣꠞꠣꠅ ꠖꠦꠈꠛ, ꠀꠞ ꠔꠣꠘ ꠟꠣꠉꠤ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠄ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠣꠘ꠆ꠖꠤꠛꠣ। ꠅꠃꠟꠣꠃ ꠅꠃꠇ, ꠀꠝꠤꠘ। ");
INSERT INTO syls_vpl VALUES ("RV1_8","096_1_8","REV","1","8","8","ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠦ ꠛꠣꠔꠣꠁꠞꠣ, “ꠀꠝꠤꠃ ꠀꠟꠤꠚ ꠀꠞ ꠁꠀ, ꠎꠦꠁꠘ ꠀꠍꠂꠘ, ꠎꠦꠁꠘ ꠀꠍꠟꠣ ꠀꠞ ꠎꠦꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠞꠁꠛꠣ। ꠀꠝꠤꠃ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ।” ");
INSERT INTO syls_vpl VALUES ("RV1_9","096_1_9","REV","1","9","9","ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠜꠣꠁ ꠢꠣꠘ꠆ꠘꠣꠘ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠃꠝ꠆ꠝꠔ ꠅꠀꠄ ꠀꠝꠤꠅ ꠔꠥꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠁ ꠇꠡ꠆ꠐ, ꠄꠇꠁ ꠛꠣꠖꠡꠣꠁ ꠀꠞ ꠄꠇꠁ ꠍꠛꠞꠞ ꠜꠣꠉꠤ ꠅꠁꠍꠤ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠔꠛꠟꠤꠉ ꠇꠞꠣꠄ ꠀꠞ ꠁꠍꠣꠞ ꠙꠇ꠆ꠇꠦ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠦꠅꠀꠄ ꠀꠝꠣꠞꠦ ꠙꠣꠔꠝꠥꠍ ꠘꠣꠝꠞ ꠖꠤꠙꠅ ꠘꠤꠀ ꠛꠘꠛꠣꠡ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV1_10","096_1_10","REV","1","10","10","ꠄꠞꠝꠣꠎꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠙꠛꠤꠔ꠆ꠞ ꠖꠤꠘ, ꠄꠇ ꠞꠛꠤꠛꠣꠞꠦ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣꠁ ꠙꠣꠇ ꠞꠥꠢꠥꠞ ꠝꠣꠎꠦ ꠙꠥꠞꠣꠙꠥꠞ ꠒꠥꠛꠤ ꠉꠦꠟꠣꠝ, ꠅꠝꠘ ꠡꠝꠄ ꠀꠝꠣꠞ ꠈꠞꠦꠖꠤ ꠡꠤꠋꠉꠣꠞ ꠀꠅꠀꠎꠞ ꠟꠣꠈꠣꠘ ꠄꠇ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RV1_11","096_1_11","REV","1","11","11","ꠢꠥꠘꠟꠣꠝ, ꠇꠥꠘꠥ ꠄꠇ ꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠞꠣ, “ꠢꠥꠘꠅ, ꠔꠥꠝꠤ ꠅꠈꠘ ꠎꠦꠔꠣ ꠖꠦꠈꠞꠣꠄ, ꠁꠔꠣ ꠄꠇ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠅ, ꠟꠦꠈꠤꠀ ꠁꠚꠤꠍ, ꠁꠎꠝꠤꠞ, ꠚꠞꠉꠣꠝ, ꠕꠥꠀꠔꠤꠞꠣ, ꠍꠣꠞ꠆ꠖꠤ, ꠚꠤꠟꠣꠖꠤꠟꠚꠤꠀ ꠀꠞ ꠟꠣꠅꠖꠤꠇꠦꠀ ꠐꠣꠃꠘꠞ ꠡꠣꠔꠅ ꠎꠝꠣꠔꠞ ꠉꠦꠍꠦ ꠙꠣꠑꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV1_12","096_1_12","REV","1","12","12","ꠀꠝꠣꠞ ꠟꠉꠦ ꠎꠦꠁꠘ ꠝꠣꠔꠤꠞꠣ, ꠔꠣꠘꠞꠦ ꠖꠦꠈꠣꠞ ꠈꠤꠀꠟꠦ ꠀꠝꠤ ꠈꠞꠦꠖꠤ ꠊꠥꠞꠟꠣꠝ, ꠊꠥꠞꠤꠀ ꠖꠦꠈꠤ, ꠡꠥꠘꠣꠞ ꠡꠣꠔꠐꠣ ꠌꠦꠞꠣꠉꠖꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("RV1_13","096_1_13","REV","1","13","13","ꠅꠃ ꠌꠦꠞꠣꠉꠖꠣꠘꠤꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠎꠘꠞꠦ ꠖꠦꠈꠟꠣꠝ। ꠔꠣꠘ ꠚꠤꠘ꠆ꠘ ꠙꠣꠅ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠟꠣꠝ꠆ꠛꠣ ꠙꠣꠁꠘ꠆ꠎꠣꠛꠤ, ꠀꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠦ ꠡꠥꠘꠣꠟꠤ ꠄꠇ ꠙꠐ꠆ꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("RV1_14","096_1_14","REV","1","14","14","ꠔꠣꠘ ꠝꠣꠕꠣꠞ ꠌꠥꠟ ꠖꠥꠗꠞ ꠟꠣꠈꠣꠘ ꠗꠟꠣ ꠌꠇꠌꠇꠣ। ꠔꠣꠘ ꠌꠃꠈ ꠀꠉꠥꠘꠤꠞ ꠟꠥꠇ꠆ꠇꠣꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV1_15","096_1_15","REV","1","15","15","ꠙꠣꠅ ꠅꠁꠟꠉꠤ, ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠀ ꠝꠣꠘ꠆ꠎꠤꠀ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠞꠣ ꠌꠇꠌꠇꠣ ꠙꠤꠔꠟꠞ ꠟꠣꠈꠣꠘ, ꠀꠞ ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠅꠁꠟ, ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠟ-ꠇꠟꠣꠁꠀ ꠎꠣꠅꠀ ꠙꠣꠘꠤꠞ ꠚꠥꠔꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV1_16","096_1_16","REV","1","16","16","ꠔꠣꠘ ꠝꠥꠈꠞ ꠍꠥꠞꠔ ꠀꠍꠤꠟ ꠙꠥꠞꠣ ꠏꠟꠝꠟ ꠇꠞꠞꠣ ꠡꠥꠞꠥꠎꠞ ꠟꠣꠈꠣꠘ। ꠔꠣꠘ ꠝꠥꠈ ꠕꠣꠇꠤ ꠗꠣꠞꠣꠁꠟ ꠄꠇꠈꠣꠘ ꠔꠟꠥꠀꠞ ꠛꠣꠞ ꠅꠁꠟ, ꠁ ꠔꠟꠥꠀꠞꠞ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠗꠣꠞ ꠀꠍꠤꠟ, ꠀꠞ ꠔꠣꠘ ꠒꠣꠁꠘ ꠀꠔꠅ ꠀꠍꠤꠟ ꠀꠍꠝꠣꠘꠞ ꠡꠣꠔꠐꠣ ꠔꠦꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV1_17","096_1_17","REV","1","17","17","ꠔꠣꠘꠦ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠝꠞꠣꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠘ ꠙꠣꠅꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠙꠠꠤ ꠞꠁꠟꠣꠝ। ꠔꠦꠃ ꠔꠣꠘ ꠘꠤꠎꠞ ꠒꠣꠁꠘꠞ ꠀꠔ ꠀꠝꠣꠞ ꠃꠙꠞꠦ ꠕꠁꠀ ꠇꠁꠟꠣ, “ꠒꠞꠣꠁꠅ ꠘꠣ। ꠀꠝꠤꠃ ꠀꠃꠀꠟ ꠀꠞ ꠀꠝꠤꠃ ꠀꠈꠦꠞ, ");
INSERT INTO syls_vpl VALUES ("RV1_18","096_1_18","REV","1","18","18","ꠀꠝꠤꠃ ꠢꠣꠁꠃꠟ-ꠇꠣꠁꠃꠝ, ꠎꠦꠁꠘ ꠘꠤꠎꠦ ꠘꠤꠎꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠀꠍꠤ। ꠀꠝꠣꠞ ꠝꠃꠔ ꠅꠁꠍꠤꠟ, ꠅꠁꠟꠦ ꠅꠈꠘ ꠀꠝꠤ ꠎꠥꠉ ꠎꠥꠉ ꠗꠞꠤ ꠌꠤꠞꠇꠣꠟ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠤ। ꠝꠃꠔ ꠀꠞ ꠇꠄꠛꠞꠞ ꠌꠣꠛꠤ ꠀꠝꠣꠞ ꠀꠔꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV1_19","096_1_19","REV","1","19","19","ꠄꠞꠟꠣꠉꠤꠃ ꠔꠥꠝꠤ ꠅꠈꠘ ꠎꠦꠔꠣ ꠖꠦꠈꠞꠣꠄ, ꠄꠞ ꠀꠉꠦ ꠎꠦꠔꠣ ꠊꠐꠤꠍꠦ ꠀꠞ ꠛꠣꠖꠦ ꠎꠦꠔꠣ ꠊꠐꠤꠛ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣ ꠔꠥꠝꠤ ꠟꠦꠈꠤꠀ ꠕꠅ। ");
INSERT INTO syls_vpl VALUES ("RV1_20","096_1_20","REV","1","20","20","ꠔꠥꠝꠤ ꠡꠥꠘꠣꠞ ꠎꠦ ꠡꠣꠔꠐꠣ ꠌꠦꠞꠣꠉꠖꠣꠘꠤ ꠖꠦꠈꠍ ꠀꠞ ꠀꠝꠣꠞ ꠒꠣꠁꠘ ꠀꠔꠅ ꠡꠣꠔꠐꠣ ꠔꠦꠞꠣ ꠖꠦꠈꠍ, ꠁꠔꠣꠞ ꠝꠣꠘꠤ ꠅꠁꠟ, ꠡꠣꠔꠅ ꠔꠦꠞꠣ ꠅꠁꠟ ꠡꠣꠔ ꠎꠝꠣꠔꠞ ꠡꠣꠔꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ, ꠡꠣꠔꠐꠣ ꠌꠦꠞꠣꠉꠖꠣꠘꠤ ꠅꠁꠟ ꠢꠃ ꠡꠣꠔꠅ ꠎꠝꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("RV2_1","096_2_1","REV","2","1","1","“ꠁꠚꠤꠍ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠅ: ꠎꠦꠁꠘ ꠘꠤꠎꠞ ꠒꠣꠁꠘ ꠀꠔꠅ ꠀꠍꠝꠣꠘꠞ ꠡꠣꠔꠐꠣ ꠔꠦꠞꠣ ꠗꠞꠤꠀ, ꠡꠥꠘꠣꠞ ꠡꠣꠔꠐꠣ ꠌꠦꠞꠣꠉꠖꠣꠘꠤꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠂꠘ, ꠔꠣꠁꠘ ꠅꠃ ꠇꠕꠣ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RV2_2","096_2_2","REV","2","2","2","“ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ, ꠔꠥꠝꠞꠣꠞ ꠝꠦꠘꠔ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠍꠛꠞꠞ ꠇꠕꠣꠅ ꠎꠣꠘꠤ। ꠀꠝꠤ ꠎꠣꠘꠤ, ꠔꠥꠝꠞꠣ ꠇꠥꠘꠥꠎꠣꠔ ꠛꠖ ꠝꠣꠘꠡꠞꠦ ꠡꠁꠎ꠆ꠎ ꠇꠞꠔꠣꠄ ꠙꠣꠞ ꠘꠣ, ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠘꠣ ꠅꠁꠀꠅ ꠎꠦꠉꠥꠁꠘ꠆ꠔꠦ ꠘꠤꠎꠞꠦ ꠍꠣꠢꠣꠛꠤ ꠇꠁꠀ ꠙꠞꠤꠌꠄ ꠖꠦꠁꠘ, ꠔꠣꠞꠣꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠤꠀ ꠖꠦꠈꠍ, ꠀꠞ ꠙꠞꠝꠣꠘꠅ ꠙꠣꠁꠍ ꠔꠣꠞꠣ ꠎꠦꠘ ꠛꠦꠁꠝꠣꠘꠤ ꠝꠣꠔꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("RV2_3","096_2_3","REV","2","3","3","ꠔꠥꠝꠞꠣꠞ ꠛꠃꠔ ꠍꠛꠞ ꠀꠍꠦ, ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠇꠡ꠆ꠐ ꠇꠞꠞꠣꠄ, ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦ ꠢꠦꠞꠣꠘ ꠅꠁꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV2_4","096_2_4","REV","2","4","4","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔ ꠀꠝꠣꠞ ꠘꠣꠟꠤꠡ ꠀꠍꠦ, ꠔꠥꠝꠞꠣ ꠙꠄꠟꠣ ꠀꠝꠣꠞꠦ ꠎꠦꠟꠣ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠔꠣꠄ, ꠅꠈꠘ ꠁꠔꠣ ꠛꠣꠖ ꠖꠤꠟꠣꠁꠍ। ");
INSERT INTO syls_vpl VALUES ("RV2_5","096_2_5","REV","2","5","5","ꠕꠥꠠꠣ ꠌꠤꠘ꠆ꠔꠣ ꠇꠞꠤ ꠖꠦꠈꠅ, ꠔꠥꠝꠞꠣ ꠇꠔ ꠃꠌꠣ ꠕꠣꠇꠤ ꠇꠔ ꠟꠣꠝꠣꠔ ꠟꠣꠝꠤ ꠉꠦꠍ। ꠁ ꠢꠣꠟꠔ ꠕꠣꠇꠤ ꠖꠤꠟ ꠛꠖꠟꠣꠁꠀ, ꠀꠉꠦ ꠎꠦꠔꠣ ꠇꠞꠔꠣꠄ ꠅꠈꠘ ꠢꠤꠞꠛꠣꠞ ꠅꠟꠣ ꠇꠞꠅ। ꠀꠞ ꠎꠥꠖꠤ ꠖꠤꠟ ꠘꠣ ꠚꠤꠞꠣꠅ, ꠔꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠀ ꠔꠥꠝꠞꠣꠞ ꠌꠦꠞꠣꠉ ꠖꠣꠘꠤꠈꠣꠘ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠢꠞꠣꠁꠟꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV2_6","096_2_6","REV","2","6","6","ꠔꠥꠝꠞꠣꠞ ꠔ ꠄꠇꠐꠣ ꠉꠥꠘ ꠀꠍꠦ, ꠘꠤꠇꠥꠟꠣꠄꠔꠤ ꠅꠇꠟꠦ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠂꠘ ꠔꠥꠝꠞꠣ ꠁꠔꠣꠞꠦ ꠊꠤꠘ꠆ꠘꠣ ꠇꠞ, ꠀꠞ ꠀꠝꠤꠅ ꠁꠔꠣꠞꠦ ꠊꠤꠘ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RV2_7","096_2_7","REV","2","7","7","“ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ ꠢꠦ ꠢꠥꠘꠃꠇ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ। ꠎꠦ ꠎꠘ ꠎꠄꠁ ꠅꠁꠛ ꠔꠣꠞꠦ ꠀꠝꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠎꠣꠘ꠆ꠘꠣꠔꠥꠟ-ꠚꠦꠞꠖꠃꠍꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠁꠔꠦ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV2_8","096_2_8","REV","2","8","8","“ꠁꠎꠝꠤꠞ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠇꠕꠣ ꠟꠦꠈꠅ: ꠎꠦꠁꠘ ꠀꠃꠀꠟ ꠀꠞ ꠀꠈꠦꠞ, ꠎꠦꠁꠘ ꠝꠣꠞꠣ ꠉꠦꠍꠟꠣ, ꠛꠣꠖꠦ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠍꠂꠘ, ꠔꠣꠁꠘ ꠅꠈꠣꠘ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RV2_9","096_2_9","REV","2","9","9","“ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠅꠜꠣꠛ-ꠅꠘꠐꠘ ꠀꠞ ꠇꠡ꠆ꠐꠞ ꠇꠕꠣ ꠎꠣꠘꠤ, ꠅꠁꠟꠦ ꠄꠞꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠗꠘꠤ। ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠈꠣꠐꠤ ꠁꠢꠥꠖꠤ ꠘꠣꠝꠦ ꠘꠤꠎꠞ ꠙꠞꠤꠌꠄ ꠖꠦꠄ, ꠅꠕꠌ ꠁꠢꠥꠖꠤꠞ ꠀꠝꠟ ꠘꠣꠁ, ꠛꠞꠋ ꠁꠛꠟꠤꠍꠞ ꠖꠟꠞ ꠝꠣꠘꠥꠡ, ꠁꠔꠣꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠤꠔꠣ ꠝꠣꠔꠤꠞꠣ ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("RV2_10","096_2_10","REV","2","10","10","ꠔꠥꠝꠞꠣ ꠎꠦ ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎꠦ ꠙꠠꠛꠣꠄ, ꠁ ꠝꠍꠤꠛꠔꠞꠦ ꠄꠇꠖꠝ ꠒꠞꠣꠁꠅ ꠘꠣ। ꠎꠣꠘ ꠘꠤ, ꠁꠛꠟꠤꠍꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠝꠣꠎꠞ ꠇꠄꠎꠘꠞꠦ ꠎꠦꠟꠅ ꠖꠤꠛ, ꠢꠘꠅ ꠔꠥꠝꠞꠣ ꠖꠡ ꠖꠤꠘ ꠇꠡ꠆ꠐ ꠙꠣꠁꠛꠣꠄ। ꠢꠥꠘꠅ, ꠁꠝꠣꠘꠞ ꠙꠕꠦ ꠔꠥꠝꠞꠣ ꠝꠞꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠞꠁꠅ, ꠔꠦꠃ ꠎꠄꠅꠞ ꠝꠣꠟꠣ ꠢꠤꠡꠣꠛꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠈꠦꠞꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV2_11","096_2_11","REV","2","11","11","“ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ ꠢꠦ ꠢꠥꠘꠃꠇ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ। ꠎꠦ ꠎꠘ ꠎꠄꠁ ꠅꠁꠛ, ꠖꠥꠍꠞꠣꠛꠣꠞꠞ ꠝꠃꠔꠦ, ꠝꠣꠘꠤ ꠖꠥꠎꠈꠦ ꠔꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠇꠥꠘꠥ ꠡꠣꠁꠖ꠆ꠖ ꠘꠣꠁ। ");
INSERT INTO syls_vpl VALUES ("RV2_12","096_2_12","REV","2","12","12","“ꠚꠞꠉꠣꠝ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠇꠕꠣ ꠟꠦꠈꠅ: ꠗꠣꠞꠀꠟꠣ ꠎꠦ ꠔꠟꠥꠀꠞꠞ ꠖꠥꠁꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠗꠣꠞ ꠀꠍꠦ, ꠅꠃ ꠔꠟꠥꠀꠞꠞ ꠝꠣꠟꠤꠇꠦ ꠅꠈꠣꠘ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RV2_13","096_2_13","REV","2","13","13","“ꠔꠥꠝꠞꠣ ꠇꠥꠘ ꠎꠣꠉꠣꠔ ꠛꠡꠔ ꠇꠞꠞꠣꠄ ꠁꠔꠣ ꠔ ꠀꠝꠤ ꠎꠣꠘꠤ, ꠁꠈꠣꠘꠅ ꠁꠛꠟꠤꠍꠞ ꠡꠤꠋꠢꠣꠡꠘ ꠀꠍꠦ। ꠅꠁꠟꠦ ꠀꠝꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠔꠥꠝꠞꠣ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠀꠍ, ꠀꠝꠣꠞ ꠃꠙꠞꠞ ꠁꠝꠣꠘꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠍ ꠘꠣ। ꠀꠝꠣꠞ ꠔꠛꠟꠤꠉ ꠇꠞꠞꠣ ꠢꠃ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠎꠘ ꠀꠘ꠆ꠔꠤꠙꠣꠍꠞꠦ ꠎꠦꠛꠟꠣ ꠡꠢꠤꠖ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠁꠛꠟꠤꠍꠞ ꠀꠈꠠꠣꠞ ꠝꠣꠎꠦ, ꠔꠥꠝꠞꠣꠞ ꠐꠣꠃꠘꠅ ꠔꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠢꠃ ꠡꠝꠄꠅ ꠔꠥꠝꠞꠣꠞ ꠁꠝꠣꠘꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV2_14","096_2_14","REV","2","14","14","“ꠔꠣ-ꠅ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠝꠣꠞ ꠇꠤꠍꠥ ꠝꠣꠔ ꠀꠍꠦ। ꠔꠥꠝꠞꠣꠞ ꠅꠘꠅ ꠅꠟꠣ ꠇꠤꠍꠥ ꠝꠣꠘꠥꠡ ꠀꠍꠂꠘ, ꠎꠦꠔꠣꠄ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠀꠝꠟꠞ ꠜꠘ꠆ꠒ ꠘꠛꠤ ꠛꠣꠟꠣꠝꠞ ꠔꠣꠟꠤꠝꠦ ꠌꠟꠂꠘ। ꠅꠃ ꠛꠣꠟꠣꠝꠦ ꠛꠣꠖꠡꠣ ꠛꠣꠟꠣꠇꠞꠦ ꠢꠤꠇꠣꠁꠍꠤꠟ, ꠎꠣꠔꠦ ꠢꠦ ꠖꠦꠛꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤꠞ ꠍꠣꠝꠘꠞ ꠙꠡꠣꠖ ꠈꠣꠅꠀꠁꠀ ꠀꠞ ꠎꠤꠘꠣ ꠇꠞꠣꠁꠀ, ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞꠦ ꠉꠥꠘꠣꠞ ꠙꠕꠦ ꠘꠦꠄ। ");
INSERT INTO syls_vpl VALUES ("RV2_15","096_2_15","REV","2","15","15","ꠁꠔꠣ ꠍꠣꠠꠣꠅ ꠘꠤꠇꠥꠟꠣꠄꠔꠤ ꠅꠇꠟꠞ ꠔꠣꠟꠤꠝꠦ ꠎꠦꠔꠣ ꠌꠟꠂꠘ, ꠅꠔꠣ ꠇꠄꠉꠥꠅ ꠔꠥꠝꠞꠣꠞ ꠅꠘꠅ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV2_16","096_2_16","REV","2","16","16","ꠄꠞꠟꠣꠉꠤ ꠁ ꠢꠣꠟꠔ ꠕꠣꠇꠤ ꠔꠥꠝꠞꠣ ꠖꠤꠟ ꠛꠖꠟꠣꠅ, ꠀꠞ ꠘꠣ ꠛꠖꠟꠤꠟꠦ ꠀꠝꠤ ꠈꠥꠛ ꠎꠟꠖꠤ ꠔꠥꠝꠞꠣꠞ ꠗꠣꠞꠅ ꠀꠁꠝꠥ, ꠀꠁꠀ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠔꠟꠥꠀꠞꠖꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠤꠢꠣꠖ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV2_17","096_2_17","REV","2","17","17","“ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ ꠢꠦ ꠢꠥꠘꠃꠇ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ। ꠎꠦ ꠎꠘ ꠎꠄꠁ ꠅꠁꠛ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠟꠥꠇꠣꠁꠟ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠝꠣꠘ꠆ꠘꠣ ꠕꠣꠇꠤ ꠕꠥꠠꠣ ꠝꠣꠘ꠆ꠘꠣ ꠀꠞ ꠄꠇꠐꠣ ꠗꠟꠣ ꠙꠣꠔ꠆ꠔꠞ ꠖꠤꠝꠥ। ꠅꠃ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠙꠞꠦ ꠅꠝꠘ ꠄꠇ ꠘꠣꠝ ꠟꠦꠈꠣ ꠕꠣꠇꠛ, ꠁ ꠘꠣꠝ ꠇꠦꠃ ꠌꠤꠘꠦ ꠘꠣ; ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠙꠣꠔ꠆ꠔꠞ ꠙꠣꠁꠛ, ꠈꠣꠟꠤ ꠢꠦ-ꠃ ꠁ ꠘꠣꠝ ꠌꠤꠘꠛ। ");
INSERT INTO syls_vpl VALUES ("RV2_18","096_2_18","REV","2","18","18","“ꠕꠥꠀꠔꠤꠞꠣ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠉꠦꠍꠦ ꠅꠃ ꠇꠕꠣ ꠟꠦꠈꠅ: ꠀꠟ꠆ꠟꠣꠞ ꠈꠣꠍ ꠝꠣꠄꠀꠞ ꠎꠘ ꠁꠛꠘꠥꠟ꠆ꠟꠣ, ꠔꠣꠘ ꠌꠃꠈ ꠅꠁꠟ ꠀꠉꠥꠘꠤꠞ ꠟꠥꠇ꠆ꠇꠣꠞ ꠟꠣꠈꠣꠘ, ꠙꠣꠅ ꠖꠥꠁꠅꠈꠣꠘ ꠝꠣꠘ꠆ꠎꠤꠀ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠞꠣ ꠌꠇꠌꠇꠣ ꠙꠤꠔꠟꠞ ꠟꠣꠈꠣꠘ, ꠔꠣꠁꠘ ꠅꠈꠣꠘ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RV2_19","096_2_19","REV","2","19","19","“ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ, ꠔꠥꠝꠞꠣꠞ ꠝꠣꠄꠀ-ꠝꠢꠛ꠆ꠛꠔ, ꠁꠝꠣꠘ, ꠈꠦꠎꠝꠔ ꠀꠞ ꠔꠥꠝꠞꠣꠞ ꠍꠛꠞꠞ ꠇꠕꠣ ꠎꠣꠘꠤ। ꠀꠞ ꠄꠅꠈꠣꠘꠅ ꠎꠣꠘꠤ, ꠔꠥꠝꠞꠣ ꠀꠉꠦ ꠎꠦꠔꠣ ꠇꠣꠝ ꠇꠞꠍ, ꠅꠈꠘ ꠄꠞ ꠕꠣꠇꠤ ꠀꠞꠅ ꠛꠦꠡꠤ ꠇꠣꠝ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV2_20","096_2_20","REV","2","20","20","“ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠁꠎꠣꠛꠦꠟ ꠘꠣꠝꠞ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠀꠡꠞꠄ ꠖꠤꠞꠣꠄ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠀꠝꠣꠞ ꠄꠇꠈꠣꠘ ꠇꠕꠣ ꠀꠍꠦ, ꠔꠣꠁ ꠘꠤꠎꠞꠦ ꠘꠛꠤ ꠇꠁꠀ ꠙꠞꠤꠌꠄ ꠖꠦꠄ। ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ ꠔꠣꠁ ꠎꠤꠘꠣ ꠇꠞꠣ ꠀꠞ ꠖꠦꠛꠔꠣꠞ ꠍꠣꠝꠘꠞ ꠙꠡꠣꠖ ꠈꠣꠅꠀ ꠢꠤꠇꠣꠁꠀ ꠛꠦ-ꠙꠕꠦ ꠘꠦꠞꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RV2_21","096_2_21","REV","2","21","21","ꠅꠃ ꠎꠤꠘꠣ ꠕꠣꠇꠤ ꠔꠃꠛꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠁꠞꠦ ꠡꠝꠄ ꠖꠤꠍꠟꠣꠝ, ꠅꠁꠟꠦ ꠔꠣꠁ ꠔꠃꠛꠣ ꠇꠞꠔꠦ ꠞꠣꠎꠤ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV2_22","096_2_22","REV","2","22","22","ꠢꠥꠘꠅ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠣꠁꠞꠦ ꠄꠇ ꠛꠤꠍꠘꠣꠔ ꠚꠣꠟꠣꠁꠀ ꠕꠁꠝꠥ, ꠔꠣꠁꠞ ꠟꠉꠦ ꠎꠦꠔꠣꠄ ꠎꠤꠘꠣ ꠇꠞꠂꠘ, ꠁꠔꠣꠄ ꠎꠥꠖꠤ ꠔꠃꠛꠣ ꠘꠣ ꠇꠞꠂꠘ, ꠔꠦ ꠔꠣꠞꠣꠞꠦꠅ ꠛꠠ ꠝꠍꠤꠛꠔꠅ ꠚꠣꠟꠣꠁꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV2_23","096_2_23","REV","2","23","23","ꠔꠣꠁꠞ ꠙꠥꠀ-ꠙꠥꠠꠤꠘꠞꠦꠅ ꠀꠝꠤ ꠝꠣꠞꠤꠟꠤꠝꠥ। ꠔꠦꠃ ꠢꠇꠟ ꠎꠝꠣꠔꠦ ꠎꠣꠘꠤꠟꠤꠛꠣ, ꠀꠝꠤ ꠔ ꠝꠣꠘꠡꠞ ꠖꠤꠟꠞ ꠀꠞ ꠝꠘꠞ ꠈꠛꠞ ꠞꠣꠈꠤ। ꠀꠝꠤ ꠀꠝꠟ-ꠘꠣꠝꠣ ꠖꠦꠈꠤꠀ ꠔꠥꠝꠞꠣ ꠙꠞꠔꠦꠇ ꠎꠘꠞ ꠚꠟ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV2_24","096_2_24","REV","2","24","24","ꠕꠥꠀꠔꠤꠞꠣ ꠎꠝꠣꠔꠞ ꠛꠣꠇꠤ ꠝꠥꠝꠤꠘ ꠅꠇꠟꠞꠦ ꠇꠁꠞꠣꠝ, ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠅꠃ ꠛꠦꠐꠤꠞ ꠇꠕꠣꠄ ꠌꠟ ꠘꠣ, ꠝꠣꠘꠡꠦ ꠎꠦꠔꠣꠞꠦ ꠁꠛꠟꠤꠍꠞ ꠉꠁꠘ ꠔꠣꠟꠤꠝ ꠇꠂꠘ, ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠢꠃ ꠙꠕ ꠌꠤꠘ ꠘꠣ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠖꠥꠍꠞꠣ ꠇꠥꠘꠥ ꠜꠣꠞ ꠖꠤꠔꠣꠝ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV2_25","096_2_25","REV","2","25","25","ꠈꠣꠟꠤ ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠀꠍꠦ, ꠀꠝꠤ ꠘꠣ ꠀꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠅꠈꠘꠣꠁꠘꠞꠦ ꠔꠥꠝꠞꠣ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠗꠞꠤꠀ ꠞꠁꠅ। ");
INSERT INTO syls_vpl VALUES ("RV2_26","096_2_26","REV","2","26","26","“ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠦ ꠎꠦꠟꠣ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠂꠘ, ꠎꠦꠞꠣ ꠎꠄꠁ ꠅꠁꠛ, ꠔꠣꠞꠣꠞꠦꠅ ꠀꠝꠤ ꠅꠃ ꠈꠦꠝꠔꠣ ꠖꠤꠝꠥ। ꠀꠝꠤ ꠎꠦ ꠇꠣꠝꠦ ꠈꠥꠡꠤ ꠅꠁ ꠅꠃ ꠇꠣꠝ ꠎꠦꠞꠣ ꠀꠈꠦꠞ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠞꠛ, ꠔꠣꠞꠣ ꠁ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV2_27","096_2_27","REV","2","27","27","ꠔꠣꠞꠣ ꠟꠥꠀꠞ ꠟꠣꠑꠤ ꠖꠤꠀ ꠁꠔꠣꠞ ꠡꠣꠡꠘ ꠇꠞꠛꠣ, ꠀꠞ ꠝꠣꠐꠤꠞ ꠙꠣꠔꠤꠟꠞ ꠟꠣꠈꠣꠘ ꠁꠔꠣꠞꠦ ꠌꠥꠞꠝꠣꠞ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV2_28","096_2_28","REV","2","28","28","ꠎꠦꠞꠣ ꠎꠄꠁ ꠅꠁꠛ, ꠀꠝꠤ ꠔꠣꠞꠦ ꠚꠎꠞꠞ ꠡꠥꠇ-ꠔꠦꠞꠣꠅ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV2_29","096_2_29","REV","2","29","29","“ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ ꠢꠦ ꠢꠥꠘꠃꠇ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV3_1","096_3_1","REV","3","1","1","“ꠍꠣꠞ꠆ꠖꠤ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠅ: ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠔ ꠘꠝꠥꠘꠣꠞ ꠞꠥꠢꠥ ꠀꠞ ꠡꠣꠔꠐꠣ ꠔꠦꠞꠣ ꠎꠦꠁꠘ ꠗꠞꠤꠀ ꠞꠣꠈꠍꠂꠘ, ꠔꠣꠁꠘ ꠅꠈꠣꠘ ꠇꠁꠞꠣ, “ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠔ ꠀꠝꠤ ꠎꠣꠘꠤ। ꠔꠥꠝꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍ ꠇꠞꠤꠀ ꠔꠥꠝꠞꠣꠞ ꠛꠃꠔ ꠡꠥꠘꠣꠝ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠀꠍꠟꠦ ꠔ ꠔꠥꠝꠞꠣ ꠝꠥꠞ꠆ꠖꠣ। ");
INSERT INTO syls_vpl VALUES ("RV3_2","096_3_2","REV","3","2","2","ꠔꠥꠝꠞꠣ ꠢꠎꠣꠉ ꠅꠁꠀ ꠃꠑꠅ, ꠀꠞ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠎꠔꠔꠣ ꠝꠞꠣꠞ ꠙꠕꠤ ꠅꠁꠉꠦꠍꠦ, ꠁꠔꠣꠞꠦ ꠛꠟ ꠎꠥꠉꠣꠅ। ꠢꠥꠘꠅ, ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠔꠥꠝꠞꠣꠞ ꠄꠇꠈꠣꠘ ꠇꠣꠝꠅ ꠀꠝꠤ ꠡꠑꠤꠇ ꠖꠦꠈꠍꠤ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV3_3","096_3_3","REV","3","3","3","ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠎꠦꠔꠣ ꠙꠣꠁꠍ ꠀꠞ ꠎꠦꠔꠣ ꠢꠥꠘꠍ, ꠅꠔꠣ ꠁꠀꠖ ꠞꠣꠈꠅ ꠀꠞ ꠀꠝꠟ ꠇꠞꠅ। ꠔꠥꠝꠞꠣꠞ ꠅꠈꠘꠇꠥꠞ ꠢꠣꠟꠔ ꠕꠣꠇꠤ ꠖꠤꠟ ꠛꠖꠟꠣꠅ। ꠔꠥꠝꠞꠣ ꠎꠥꠖꠤ ꠢꠎꠣꠉ ꠘꠣ ꠅꠅ, ꠔꠦ ꠀꠝꠤ ꠌꠥꠞꠞ ꠟꠣꠈꠣꠘ ꠟꠥꠇꠣꠁꠀ ꠀꠁꠝꠥ, ꠇꠥꠘ ꠛꠣꠟꠣ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠁꠝꠥ, ꠔꠥꠝꠞꠣ ꠐꠦꠞꠃ ꠙꠣꠁꠔꠣꠄ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV3_4","096_3_4","REV","3","4","4","ꠔꠦ ꠅꠃ ꠍꠣꠞ꠆ꠖꠤ ꠎꠝꠣꠔꠅ ꠔꠥꠝꠞꠣꠞ ꠅꠟꠣ ꠇꠄꠎꠘ ꠝꠣꠘꠥꠡ ꠀꠍꠂꠘ ꠎꠦꠞꠣꠞ ꠟꠦꠛꠣꠍꠅ ꠇꠥꠘꠥ ꠈꠥꠔ ꠘꠣꠁ, ꠝꠣꠘꠤ ꠔꠣꠞꠣꠞ ꠌꠣꠟ-ꠌꠟꠘ ꠈꠣꠞꠣꠙꠤꠞ ꠛꠣꠄ ꠉꠦꠍꠦ ꠘꠣ। ꠔꠣꠞꠣ ꠙꠞꠦꠎꠉꠣꠞ ꠛꠘ꠆ꠖꠣ, ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠗꠟꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠀ ꠀꠝꠣꠞ ꠟꠉꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV3_5","096_3_5","REV","3","5","5","ꠎꠦ ꠎꠘ ꠎꠄꠁ ꠅꠁꠛ, ꠢꠦ ꠅꠟꠣ ꠗꠟꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘꠛ। ꠀꠈꠦꠞꠣꠔꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠣꠔꠣ ꠕꠣꠇꠤ ꠔꠣꠞ ꠘꠣꠝ ꠀꠝꠤ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠚꠥꠍꠔꠣꠝ ꠘꠣꠄ। ꠛꠞꠋ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚ ꠀꠞ ꠔꠣꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠀꠝꠤ ꠔꠣꠞꠦ ꠀꠝꠣꠞ ꠇꠁꠀ ꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV3_6","096_3_6","REV","3","6","6","“ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ ꠢꠦ ꠢꠥꠘꠃꠇ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV3_7","096_3_7","REV","3","7","7","“ꠚꠤꠟꠣꠖꠤꠟꠚꠤꠀ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠅ: ꠎꠦꠁꠘ ꠢꠇ ꠀꠞ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠎꠦꠘ ꠀꠔꠅ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠌꠣꠛꠤ ꠀꠍꠦ, ꠎꠦꠁꠘ ꠈꠥꠟꠟꠦ ꠀꠞ ꠇꠦꠃ ꠛꠘ꠆ꠖ ꠇꠞꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠟꠦ ꠇꠦꠃ ꠈꠥꠟꠔ ꠙꠣꠞꠦ ꠘꠣ, ꠔꠣꠁꠘ ꠅꠈꠣꠘ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RV3_8","096_3_8","REV","3","8","8","“ꠀꠝꠤ ꠔ ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠎꠣꠘꠤ। ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠍꠣꠝꠘꠦ ꠄꠇꠈꠣꠘ ꠖꠥꠀꠞ ꠈꠥꠟꠣ ꠞꠣꠈꠟꠣꠝ, ꠁꠈꠣꠘ ꠛꠘ꠆ꠖ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠇꠦꠃꠞꠞ ꠘꠣꠁ। ꠀꠝꠤ ꠔ ꠎꠣꠘꠤ, ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠇꠝꠎꠥꠞ, ꠄꠞꠛꠣꠖꠦꠅ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠢꠥꠇꠥꠝ ꠀꠝꠟ ꠇꠞꠍ ꠀꠞ ꠀꠝꠣꠞꠦ ꠅꠡ꠆ꠛꠤꠇꠣꠞ ꠇꠞꠍ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV3_9","096_3_9","REV","3","9","9","ꠎꠦꠞꠣ ꠁꠢꠥꠖꠤ ꠇꠁꠀ ꠘꠤꠎꠞ ꠙꠞꠤꠌꠄ ꠖꠦꠄ ꠅꠕꠌ ꠀꠍꠟ ꠁꠢꠥꠖꠤ ꠘꠣꠄ, ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘꠞ ꠖꠟꠞ ꠢꠃ ꠛꠦꠁꠝꠣꠘ ꠅꠇꠟꠞꠦ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠀꠘꠣꠁꠝꠥ, ꠔꠥꠝꠞꠣꠞ ꠙꠣꠅ-ꠅ ꠗꠞꠣꠁ ꠇꠖꠝꠛꠥꠍꠤ ꠇꠞꠣꠁꠝꠥ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠣꠁ ꠖꠤꠝꠥ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠝꠢꠛ꠆ꠛꠔ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RV3_10","096_3_10","REV","3","10","10","ꠔꠥꠝꠞꠣꠞꠦ ꠍꠛꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠀꠝꠤ ꠎꠦ ꠢꠥꠇꠥꠝ ꠖꠤꠍꠟꠣꠝ ꠁꠔꠣ ꠔꠥꠝꠞꠣ ꠝꠣꠘꠍ; ꠄꠞꠟꠣꠉꠤ ꠁ ꠖꠥꠘꠤꠀꠞ ꠃꠙꠞꠦ ꠝꠍꠤꠛꠔꠞ ꠎꠦ ꠡꠝꠄ ꠀꠁꠀ ꠀꠎꠦꠞ, ꠢꠃ ꠡꠝꠄ ꠕꠣꠇꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠢꠦꠚꠣꠎꠔ ꠇꠞꠝꠥ। ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠙꠞꠤꠇ꠆ꠇꠣ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠝꠍꠤꠛꠔꠞ ꠡꠝꠄ ꠀꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV3_11","096_3_11","REV","3","11","11","“ꠢꠥꠘꠅ, ꠀꠝꠤ ꠈꠥꠛ ꠎꠟꠖꠤ ꠀꠁꠞꠣꠝ। ꠔꠥꠝꠞꠣꠞ ꠎꠦꠔꠣ ꠀꠍꠦ ꠅꠔꠣꠞꠦ ꠝꠎꠛꠥꠔ ꠇꠞꠤ ꠗꠞꠤꠀ ꠞꠣꠈꠅ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣꠞ ꠎꠄꠅꠞ ꠝꠣꠟꠣ ꠇꠦꠃ ꠇꠣꠠꠤꠀ ꠘꠤꠔ ꠘꠣ ꠙꠣꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("RV3_12","096_3_12","REV","3","12","12","ꠎꠦ ꠎꠘ ꠎꠄꠁ ꠅꠁꠛ, ꠔꠣꠞꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠊꠞꠞ ꠄꠇꠐꠣ ꠈꠥꠐꠤ ꠛꠣꠘꠣꠁꠝꠥ, ꠢꠦ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠛꠣꠞ ꠅꠁꠀ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠀꠝꠤ ꠔꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠐꠣꠃꠘꠞ ꠘꠣꠝꠅ ꠟꠦꠈꠝꠥ। ꠢꠃ ꠐꠣꠃꠘ ꠅꠁꠟꠉꠤ ꠘꠄꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ। ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎ ꠕꠣꠇꠤ, ꠀꠝꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠗꠣꠞꠅ ꠕꠣꠇꠤ ꠢꠃ ꠐꠣꠃꠘ ꠟꠣꠝꠤꠀ ꠀꠁꠛ। ꠀꠞ ꠎꠦ ꠎꠘ ꠎꠄꠁ ꠅꠁꠛ, ꠔꠣꠞ ꠃꠙꠞꠦ ꠀꠝꠤ ꠀꠝꠣꠞ ꠘꠄꠀ ꠘꠣꠝꠈꠣꠘꠅ ꠟꠦꠈꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV3_13","096_3_13","REV","3","13","13","“ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ ꠢꠦ ꠢꠥꠘꠃꠇ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV3_14","096_3_14","REV","3","14","14","“ꠟꠣꠅꠖꠤꠇꠦꠀ ꠐꠣꠃꠘꠞ ꠎꠝꠣꠔꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠉꠦꠍꠦ ꠟꠦꠈꠅ: ꠎꠦꠘ ꠘꠣꠝ ꠀꠝꠤꠘ, ꠎꠦꠁꠘ ꠢꠇ-ꠢꠣꠟꠣꠟ ꠡꠣꠇ꠆ꠇꠤ, ꠎꠦꠁꠘ ꠀꠟ꠆ꠟꠣꠞ ꠙꠄꠖꠣ ꠇꠞꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠝꠥꠟ ꠈꠥꠐꠤ, ꠔꠣꠁꠘ ꠅꠈꠣꠘ ꠇꠁꠞꠣ, ");
INSERT INTO syls_vpl VALUES ("RV3_15","096_3_15","REV","3","15","15","“ꠔꠥꠝꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎꠞ ꠇꠕꠣ ꠔ ꠀꠝꠤ ꠎꠣꠘꠤ। ꠔꠥꠝꠞꠣ ꠅꠁꠟꠣꠄ ꠘꠣ ꠑꠣꠘ꠆ꠒꠣ, ꠘꠣ ꠉꠞꠝ। ꠔꠥꠝꠞꠣ ꠢꠄ ꠑꠣꠘ꠆ꠒꠣ ꠘꠣ ꠅꠄ ꠉꠞꠝ ꠅꠁꠟꠦ ꠜꠣꠟꠣ ꠅꠁꠟ ꠅꠘꠦ। ");
INSERT INTO syls_vpl VALUES ("RV3_16","096_3_16","REV","3","16","16","ꠅꠁꠟꠦ ꠔꠥꠝꠞꠣ ꠔ ꠃꠝꠟꠤ ꠉꠞꠝ, ꠘꠣ ꠑꠣꠘ꠆ꠒꠣ, ꠘꠣ ꠉꠞꠝ, ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠀꠝꠣꠞ ꠝꠥꠈꠞ ꠍꠦꠚꠞ ꠟꠣꠈꠣꠘ ꠕꠥ ꠇꠞꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠚꠣꠟꠣꠁ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV3_17","096_3_17","REV","3","17","17","ꠔꠥꠝꠞꠣ ꠔ ꠇꠁꠞꠣꠄ, ꠔꠥꠝꠞꠣ ꠛꠃꠔ ꠗꠘꠤ, ꠔꠥꠝꠞꠣ ꠛꠠꠟꠥꠇ ꠅꠁꠉꠦꠍ, ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠇꠥꠘ꠆ꠔꠣꠞ ꠅꠜꠣꠛ ꠘꠣꠁ। ꠁꠔꠣ ꠈꠥꠛ ꠜꠣꠟꠣ ꠇꠕꠣ, ꠅꠁꠟꠦ ꠀꠍꠟꠦ ꠔ ꠔꠥꠝꠞꠣ ꠛꠥꠎꠞꠣꠄ ꠘꠣ, ꠔꠥꠝꠞꠣ ꠈꠥꠛ ꠖꠥꠈꠤ, ꠇꠣꠋꠉꠣꠟ, ꠉꠞꠤꠛ, ꠀꠘ꠆ꠖꠣ ꠀꠞ ꠟꠦꠝꠐꠣ ꠀꠍ। ");
INSERT INTO syls_vpl VALUES ("RV3_18","096_3_18","REV","3","18","18","ꠄꠞꠟꠣꠉꠤ ꠀꠝꠤ ꠔꠥꠝꠞꠣꠞꠦ ꠅꠃ ꠃꠙꠖꠦꠡ ꠖꠤꠞꠣꠝ, ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟ ꠈꠣꠐꠤ ꠡꠥꠘꠣ ꠔꠥꠝꠞꠣ ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠟꠁꠀ ꠘꠦꠅ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠢꠣꠍꠣꠞꠞ ꠗꠘꠤ ꠅꠁꠔꠣꠄ ꠙꠣꠞ। ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠗꠟꠣ ꠟꠦꠛꠣꠍ ꠟꠁꠀ ꠘꠤꠀ ꠚꠤꠘ꠆ꠖꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣꠞꠦ ꠀꠞ ꠟꠦꠝꠐꠣ ꠖꠦꠈꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠀꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠌꠈꠥꠔ ꠟꠣꠉꠣꠘꠤꠞ ꠡꠥꠞꠝꠣ ꠟꠁꠀ ꠘꠦꠅ, ꠔꠦꠃ ꠔꠥꠝꠞꠣ ꠢꠣꠍꠣꠞꠞ ꠌꠃꠈꠦ ꠖꠦꠈꠛꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV3_19","096_3_19","REV","3","19","19","“ꠢꠥꠘꠅ, ꠀꠝꠤ ꠎꠦꠞꠣꠞꠦ ꠝꠣꠄꠀ ꠇꠞꠤ, ꠔꠣꠞꠣꠞ ꠖꠥꠡ-ꠔꠤꠞꠥꠐꠤ ꠖꠦꠈꠣꠁ ꠖꠦꠁ ꠀꠞ ꠡꠣꠡꠘꠅ ꠇꠞꠤ। ꠄꠞꠟꠣꠉꠤ ꠔꠥꠝꠞꠣ ꠃꠝꠟꠤ ꠉꠞꠝ ꠕꠣꠇꠤ ꠙꠥꠞꠣ ꠉꠞꠝ ꠅꠁꠀ ꠔꠃꠛꠣ ꠇꠞꠅ। ");
INSERT INTO syls_vpl VALUES ("RV3_20","096_3_20","REV","3","20","20","ꠎꠣꠘ ꠘꠤ, ꠀꠝꠤ ꠖꠥꠀꠞꠞ ꠉꠦꠍꠦ ꠃꠛꠣꠁꠀ ꠖꠥꠀꠞꠅ ꠑꠥꠇꠣꠁꠞꠣꠝ। ꠀꠝꠣꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠤꠀ ꠎꠥꠖꠤ ꠇꠦꠃ ꠔꠣꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠤꠀ ꠖꠦꠄ, ꠔꠦ ꠀꠝꠤ ꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠝꠥ, ꠔꠣꠞ ꠟꠉꠦ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠈꠣꠁꠝꠥ ꠀꠞ ꠢꠦ-ꠅ ꠀꠝꠣꠞ ꠟꠉꠦ ꠈꠣꠘꠣ-ꠖꠣꠘꠣ ꠈꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV3_21","096_3_21","REV","3","21","21","ꠀꠝꠤ ꠎꠦꠟꠣ ꠎꠄꠁ ꠅꠁꠀ ꠀꠝꠣꠞ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠟꠉꠦ ꠔꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠀꠞꠡꠞ ꠇꠥꠞꠍꠤꠔ ꠛꠁꠍꠤ, ꠑꠤꠇ ꠅꠃ ꠟꠣꠈꠣꠘ ꠎꠦ ꠎꠘ ꠎꠄꠁ ꠅꠁꠛ, ꠔꠣꠞꠦꠅ ꠀꠝꠤ ꠀꠝꠣꠞ ꠟꠉꠦ ꠀꠝꠣꠞ ꠇꠥꠞꠍꠤꠔ ꠛꠅꠀꠞ ꠅꠗꠤꠇꠣꠞ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV3_22","096_3_22","REV","3","22","22","“ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ ꠢꠦ ꠢꠥꠘꠃꠇ, ꠙꠣꠇ ꠞꠥꠢꠦ ꠎꠝꠣꠔ ꠅꠇꠟꠞꠦ ꠇꠤꠔꠣ ꠛꠣꠔꠣꠁꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV4_1","096_4_1","REV","4","1","1","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠞꠡꠘ ꠖꠦꠈꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠄꠇꠈꠣꠘ ꠖꠥꠀꠞ ꠈꠥꠟꠣ ꠀꠍꠦ। ꠀꠞ ꠀꠝꠤ ꠔꠣꠘ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ, ꠡꠤꠋꠉꠣꠞ ꠀꠅꠀꠎꠞ ꠟꠣꠈꠣꠘ ꠎꠦꠁꠘ ꠀꠉꠦ ꠝꠣꠔꠤꠍꠟꠣ, ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠒꠣꠇ ꠖꠤꠟꠣ, ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠅꠘꠅ ꠃꠑꠤꠀ ꠀꠅ। ꠀꠝꠤ ꠅꠈꠘ ꠔꠥꠝꠣꠞꠦ ꠖꠦꠈꠣꠁꠝꠥ, ꠄꠞꠛꠣꠖꠦ ꠇꠤꠔꠣ ꠇꠤꠔꠣ ꠘꠤꠌ꠆ꠌꠤꠔ ꠊꠐꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("RV4_2","096_4_2","REV","4","2","2","ꠒꠣꠇ ꠢꠥꠘꠣꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠀꠝꠤ ꠙꠣꠇ ꠞꠥꠢꠦ ꠇꠣꠝꠤꠟ ꠅꠁꠟꠣꠝ, ꠀꠞ ꠖꠦꠈꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠄꠇꠈꠣꠘ ꠔꠈ꠆ꠔ ꠀꠍꠦ, ꠅꠃ ꠔꠈ꠆ꠔꠞ ꠃꠙꠞꠦ ꠄꠇꠎꠘ ꠛꠅꠀꠔ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV4_3","096_4_3","REV","4","3","3","ꠄꠘ ꠍꠥꠞꠔ ꠅꠁꠟ, ꠖꠣꠝꠤ ꠢꠤꠞꠣ ꠀꠞ ꠟꠣꠟ ꠝꠘꠤꠞ ꠟꠣꠈꠣꠘ। ꠁ ꠔꠈ꠆ꠔꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠛꠣꠄ ꠀꠍꠤꠟ ꠞꠋꠗꠦꠘꠥ, ꠁꠔꠣ ꠖꠦꠈꠔꠦ ꠄꠇ꠆ꠇꠦꠞꠦ ꠇꠌꠥꠀ ꠙꠣꠘ꠆ꠘꠣ ꠝꠘꠤꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV4_4","096_4_4","REV","4","4","4","ꠅꠃ ꠔꠈ꠆ꠔꠞ ꠌꠣꠁꠞꠅ ꠇꠣꠘ꠆ꠖꠣꠛꠣꠄ ꠀꠞꠅ ꠌꠛ꠆ꠛꠤꠡꠈꠣꠘ ꠔꠈ꠆ꠔ ꠀꠍꠤꠟ, ꠢꠃ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠟꠣ ꠌꠛ꠆ꠛꠤꠡꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ। ꠄꠞꠣꠞ ꠟꠦꠛꠣꠍ ꠀꠍꠤꠟ ꠗꠟꠣ ꠌꠇꠌꠇꠣ ꠀꠞ ꠝꠣꠕꠣꠔ ꠀꠍꠤꠟ ꠡꠥꠘꠣꠞ ꠔꠣꠎ। ");
INSERT INTO syls_vpl VALUES ("RV4_5","096_4_5","REV","4","5","5","ꠝꠣꠎꠈꠣꠘꠞ ꠔꠈ꠆ꠔ ꠕꠣꠇꠤ ꠝꠦꠊꠞ ꠎꠤꠟꠇꠣꠘꠤ, ꠉꠥꠠ-ꠉꠥꠠꠤ ꠒꠣꠇ ꠀꠞ ꠛꠦꠎꠥꠁꠔꠣ ꠑꠣꠐꠣꠞꠤ ꠡꠛ꠆ꠖ ꠛꠣꠞꠘꠤꠔ ꠀꠍꠤꠟ। ꠄꠞ ꠍꠣꠝꠘꠦ ꠡꠣꠔꠐꠣ ꠝꠥꠡꠣꠟ ꠎꠣꠟꠣꠁꠟ ꠀꠍꠤꠟ, ꠁ ꠝꠥꠡꠣꠟ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠡꠣꠔ ꠘꠝꠥꠘꠣꠞ ꠞꠥꠢꠥ। ");
INSERT INTO syls_vpl VALUES ("RV4_6","096_4_6","REV","4","6","6","ꠔꠈ꠆ꠔꠞ ꠍꠣꠝꠘꠦ ꠚꠐꠤꠇꠞ ꠉ꠆ꠟꠣꠡꠞ ꠟꠣꠈꠣꠘ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠣꠌꠞ ꠄꠇ ꠖꠞꠤꠀ ꠀꠍꠤꠟ। ꠀꠞ ꠅꠃ ꠝꠣꠎꠞ ꠔꠈ꠆ꠔꠞ ꠌꠣꠁꠞꠅ ꠉꠣꠟꠣꠔ ꠌꠣꠁꠞꠎꠘ ꠎꠣꠘꠖꠣꠞ ꠀꠍꠤꠟ, ꠄꠞꠣꠞ ꠍꠣꠝꠘꠦ-ꠙꠤꠍꠦ ꠖꠥꠁꠅꠛꠣꠄ ꠌꠃꠈ ꠅꠇꠟꠦ ꠜꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV4_7","096_4_7","REV","4","7","7","ꠙꠄꠟꠣ ꠎꠣꠘꠖꠣꠞꠐꠣ ꠖꠦꠈꠔꠦ ꠡꠤꠋꠢꠞ ꠟꠣꠈꠣꠘ, ꠖꠥꠍꠞꠣꠐꠣ ꠛꠤꠍꠣꠟꠞ ꠟꠣꠈꠣꠘ, ꠔꠤꠘ ꠘꠝ꠆ꠛꠞꠐꠣ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ ꠀꠞ ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞꠐꠣ ꠃꠠꠣꠟ ꠖꠦꠅꠞꠣ ꠌꠤꠟꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV4_8","096_4_8","REV","4","8","8","ꠅꠃ ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞꠞ ꠙꠞꠔꠦꠇꠞ ꠍꠄꠐꠣ ꠇꠞꠤ ꠒꠣꠈꠘꠣ ꠀꠍꠤꠟ, ꠀꠞ ꠛꠣꠞꠦ-ꠜꠤꠔꠞꠦ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠌꠃꠈ ꠀꠍꠤꠟ। ꠔꠣꠞꠣ ꠖꠤꠘ-ꠞꠣꠁꠔ ꠢꠣꠝꠦꠡꠣ ꠅꠃ ꠎꠤꠇꠤꠞ ꠇꠞꠞꠣ, “ꠇꠥꠖ꠆ꠖꠥꠍꠥꠘ, ꠇꠥꠖ꠆ꠖꠥꠍꠥꠘ, ꠇꠥꠖ꠆ꠖꠥꠍꠥꠘ, ꠞꠣꠛ꠆ꠛꠥ ꠁꠟꠣꠢꠥꠟ ꠇꠣꠖꠤꠞ, ꠇꠣꠘꠣ ꠅꠀ-ꠢꠥꠀ ꠇꠣꠁꠘꠥꠍ ꠍꠣꠁꠀꠔꠤꠘ। ꠙꠛꠤꠔ꠆ꠞ, ꠙꠛꠤꠔ꠆ꠞ, ꠙꠛꠤꠔ꠆ꠞ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ, ꠎꠦꠁꠘ ꠀꠍꠟꠣ, ꠎꠦꠁꠘ ꠀꠍꠂꠘ, ꠀꠞ ꠎꠦꠁꠘ ꠢꠣꠝꠦꠡꠣ ꠞꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV4_9","096_4_9","REV","4","9","9","ꠎꠦꠁꠘ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠣ, ꠎꠦꠁꠘ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠂꠘ, ꠅꠃ ꠎꠣꠘꠖꠣꠞ ꠅꠇꠟꠦ ꠎꠦꠛꠟꠣꠃ ꠔꠣꠘ ꠔꠣꠞꠤꠚ, ꠡꠝ꠆ꠝꠣꠘ ꠀꠞ ꠡꠥꠇꠞꠤꠀ ꠎꠣꠘꠣꠁꠘ, ");
INSERT INTO syls_vpl VALUES ("RV4_10","096_4_10","REV","4","10","10","ꠅꠃ ꠡꠝꠄ ꠎꠦꠁꠘ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠂꠘ, ꠎꠦꠁꠘ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠎꠤꠘ꠆ꠖꠣ, ꠄꠘ ꠍꠣꠝꠘꠦ ꠢꠃ ꠌꠛ꠆ꠛꠤꠡꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠘꠔ ꠅꠁꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠂꠘ। ꠁ ꠘꠦꠔꠣ ꠅꠇꠟꠦ ꠎꠣꠞꠎꠤꠞ ꠝꠣꠕꠣꠞ ꠔꠣꠎ ꠡꠤꠋꠢꠣꠡꠘꠞ ꠍꠣꠝꠘꠦ ꠈꠥꠟꠤꠀ ꠕꠁꠀ ꠇꠂꠘ, ");
INSERT INTO syls_vpl VALUES ("RV4_11","096_4_11","REV","4","11","11","“ꠅ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠤ ꠔ ꠁꠎ꠆ꠎꠔ, ꠔꠣꠞꠤꠚ ꠀꠞ ꠇꠥꠖꠞꠔꠤ ꠈꠦꠝꠔꠣꠞ ꠎꠁꠉ꠆ꠉ। ꠔꠥꠝꠤꠃ ꠔ ꠢꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍ, ꠔꠥꠝꠣꠞ ꠝꠞ꠆ꠎꠤꠄ ꠢꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠅꠁꠍꠦ ꠀꠞ ꠐꠤꠇꠤꠀ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV5_1","096_5_1","REV","5","1","1","ꠅꠃ ꠔꠈ꠆ꠔꠞ ꠝꠣꠎꠦ ꠎꠦꠁꠘ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠔꠣꠘ ꠒꠣꠁꠘꠞ ꠀꠔꠅ ꠀꠝꠤ ꠄꠇꠈꠣꠘ ꠇꠤꠔꠣꠛ ꠖꠦꠈꠟꠣꠝ। ꠇꠤꠔꠣꠛꠞ ꠛꠣꠞꠦ-ꠜꠤꠔꠞꠦ ꠇꠥꠘ꠆ꠔꠣ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠁꠈꠣꠘ ꠡꠣꠔꠐꠣ ꠡꠤꠟ ꠖꠤꠀ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV5_2","096_5_2","REV","5","2","2","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠈꠥꠛ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠞꠣ, “ꠁꠟꠣ ꠎꠁꠉ꠆ꠉ ꠇꠦꠃ ꠀꠍꠂꠘ ꠘꠤ, ꠎꠦꠁꠘ ꠅꠃ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠜꠣꠋꠉꠤꠀ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠈꠥꠟꠔꠣ ꠙꠣꠞꠛꠣ?” ");
INSERT INTO syls_vpl VALUES ("RV5_3","096_5_3","REV","5","3","3","ꠅꠁꠟꠦ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ ꠛꠣ ꠙꠣꠔꠣꠟꠞ ꠝꠣꠎꠦ ꠁꠟꠣ ꠇꠦꠃ ꠝꠤꠟꠟ ꠘꠣ, ꠎꠦꠁꠘ ꠁꠈꠣꠘ ꠈꠥꠟꠣ ꠛꠣ ꠄꠞ ꠜꠤꠔꠞ ꠖꠦꠈꠣꠞ ꠎꠁꠉ꠆ꠉ। ");
INSERT INTO syls_vpl VALUES ("RV5_4","096_5_4","REV","5","4","4","ꠔꠦꠃ ꠀꠝꠤ ꠢꠣꠘ꠆ꠘꠣꠘꠞ ꠈꠥꠛ ꠇꠣꠘ꠆ꠖꠘ ꠀꠁꠟ, ꠇꠣꠞꠘ ꠁ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠈꠥꠟꠣꠞ ꠛꠣ ꠄꠞ ꠜꠤꠔꠞ ꠖꠦꠈꠣꠞ ꠎꠁꠉ꠆ꠉ ꠄꠇꠎꠘꠅ ꠙꠣꠅꠀ ꠉꠦꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV5_5","096_5_5","REV","5","5","5","ꠛꠣꠖꠦ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠛꠣ, ꠇꠣꠘ꠆ꠖꠤꠅ ꠘꠣ। ꠢꠥꠘꠅ, ꠎꠦꠁꠘ ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠡꠤꠋꠢ, ꠖꠣꠃꠖ ꠘꠛꠤꠞ ꠛꠋꠡꠗꠞ, ꠔꠣꠁꠘ ꠎꠤꠔꠤꠍꠂꠘ। ꠔꠣꠁꠘ ꠅꠃ ꠡꠣꠔꠅ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠜꠣꠋꠉꠤꠀ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠈꠥꠟꠔꠣ ꠙꠣꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV5_6","096_5_6","REV","5","6","6","ꠀꠝꠤ ꠀꠞꠅ ꠖꠦꠈꠟꠣꠝ, ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ, ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞꠞ, ꠀꠞ ꠅꠃ ꠔꠈ꠆ꠔꠞ ꠝꠣꠎꠈꠣꠘꠅ ꠄꠇ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠃꠛꠣꠁ ꠞꠁꠍꠦ। ꠖꠦꠈꠔꠦ ꠝꠘꠅ ꠅꠁꠟ, ꠁ ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠎꠛ ꠇꠞꠣ ꠅꠁꠍꠦ। ꠁ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠡꠣꠔꠐꠣ ꠢꠤꠋ ꠀꠞ ꠡꠣꠔꠐꠣ ꠌꠃꠈ। ꠀꠟ꠆ꠟꠣꠞ ꠎꠦ ꠡꠣꠔ ꠘꠝꠥꠘꠣꠞ ꠞꠥꠢꠥꠞꠦ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠎꠦ ꠙꠣꠑꠣꠁꠟ ꠅꠄ, ꠅꠃ ꠡꠣꠔꠅ ꠌꠃꠈ ꠅꠁꠟ ꠢꠃ ꠡꠣꠔꠅ ꠞꠥꠢꠥ। ");
INSERT INTO syls_vpl VALUES ("RV5_7","096_5_7","REV","5","7","7","ꠛꠣꠖꠦ ꠅꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠁꠀ, ꠔꠈ꠆ꠔꠅ ꠎꠦꠁꠘ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠄꠘ ꠒꠣꠁꠘ ꠀꠔ ꠕꠣꠇꠤ ꠅꠃ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠘꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV5_8","096_5_8","REV","5","8","8","ꠇꠤꠔꠣꠛ ꠘꠦꠅꠀꠞ ꠛꠣꠖꠦ ꠢꠃ ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞꠦ ꠀꠞ ꠌꠛ꠆ꠛꠤꠡꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣꠄ ꠅꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ। ꠄꠞꠣ ꠙꠞꠔꠦꠇꠞ ꠀꠔꠅ ꠄꠉꠥ ꠇꠞꠤ ꠡꠣꠞꠤꠘ꠆ꠖꠣ, ꠀꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠄ ꠜꠞꠣ ꠄꠉꠥ ꠡꠥꠘꠣꠞ ꠛꠣꠐꠤ ꠀꠍꠤꠟ। ꠁ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("RV5_9","096_5_9","REV","5","9","9","ꠀꠞ ꠔꠣꠞꠣ ꠘꠄꠀ ꠅꠃ ꠉꠎꠟ ꠉꠣꠁꠟꠣ, “ꠈꠣꠟꠤ ꠔꠥꠝꠤꠃ ꠡꠑꠤꠇ ꠎꠘ ꠅꠃ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠘꠤꠛꠣꠞ, ꠘꠤꠀ ꠄꠞ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠈꠥꠟꠛꠣꠞ। ꠔꠥꠝꠣꠞꠦ ꠔ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ। ꠔꠥꠝꠤ ꠔꠥꠝꠣꠞ ꠟꠃ ꠖꠤꠀ ꠢꠇ꠆ꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ, ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠥꠡ ꠈꠞꠤꠖ ꠇꠞꠍ। ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠞ ꠛꠥꠟꠤꠄ ꠝꠣꠔꠞꠣ ꠝꠣꠘꠥꠡ, ꠢꠇꠟ ꠖꠦꠡ ꠀꠞ ꠎꠣꠔꠤ ꠕꠣꠇꠤꠅ ꠈꠣꠟꠣꠍ ꠇꠞꠍ। ");
INSERT INTO syls_vpl VALUES ("RV5_10","096_5_10","REV","5","10","10","ꠄꠞꠣꠞꠦ ꠟꠁꠀ ꠔꠥꠝꠤ ꠄꠇ ꠛꠣꠖꠡꠣꠁ ꠇꠣꠁꠝ ꠇꠞꠍ, ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠄꠛꠣꠖꠔꠤꠞ ꠟꠣꠉꠤ ꠁꠝꠣꠝ ꠛꠣꠘꠣꠁꠍ, ꠄꠞꠣꠃ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠅ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV5_11","096_5_11","REV","5","11","11","ꠛꠣꠖꠦ ꠀꠝꠤ ꠌꠣꠁꠟꠣꠝ, ꠀꠞ ꠢꠃ ꠔꠈ꠆ꠔ, ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠌꠣꠁꠞꠅꠛꠣꠄ ꠛꠃꠔ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ। ꠁꠘꠅ ꠢꠣꠎꠣꠞꠦ ꠢꠣꠎꠣꠞ, ꠇꠥꠐꠤ ꠇꠥꠐꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV5_12","096_5_12","REV","5","12","12","ꠄꠞꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠅꠃ ꠉꠎꠟ ꠇꠁꠟꠣ, “ꠎꠦ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠎꠛ ꠇꠞꠣ ꠅꠁꠍꠤꠟ, ꠄꠁꠘꠃ ꠈꠦꠝꠔꠣ, ꠗꠘ-ꠖꠃꠟꠔ, ꠀꠈꠟ, ꠛꠟ-ꠡꠇ꠆ꠔꠤ, ꠁꠎ꠆ꠎꠔ, ꠉꠃꠞꠛ ꠀꠞ ꠔꠣꠞꠤꠚ ꠙꠣꠅꠀꠞ ꠎꠁꠉ꠆ꠉ।” ");
INSERT INTO syls_vpl VALUES ("RV5_13","096_5_13","REV","5","13","13","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠀꠍꠝꠣꠘꠅ, ꠎꠝꠤꠘꠅ, ꠙꠣꠔꠣꠟꠅ ꠀꠞ ꠖꠞꠤꠀꠞ ꠝꠣꠎꠦ ꠎꠔ ꠎꠣꠘꠖꠣꠞ ꠀꠍꠦ, ꠛꠣ ꠁꠔꠣꠞ ꠜꠤꠔꠞꠦ ꠀꠞꠅ ꠎꠔꠔꠣ ꠀꠍꠦ, ꠄꠞꠣ ꠢꠇ꠆ꠇꠟꠦ ꠅꠈꠣꠘ ꠇꠁꠞꠣ, “ꠔꠈ꠆ꠔꠞ ꠝꠣꠎꠦ ꠎꠦꠁꠘ ꠛꠅꠀꠔ ꠀꠍꠂꠘ, ꠔꠣꠁꠘ ꠀꠞ ꠅꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ, ꠔꠣꠞꠤꠚ, ꠁꠎ꠆ꠎꠔ, ꠉꠃꠞꠛ ꠀꠞ ꠈꠦꠝꠔꠣ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠣꠞꠤ ꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("RV5_14","096_5_14","REV","5","14","14","ꠔꠦꠃ ꠢꠃ ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠝꠤꠘ।” ꠀꠞ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟ ꠘꠔ ꠅꠁꠀ ꠍꠁꠎꠖꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV6_1","096_6_1","REV","6","1","1","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠢꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠄ ꠎꠦꠛꠟꠣ ꠡꠣꠔꠅ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠙꠄꠟꠣ ꠡꠤꠟ ꠜꠣꠋꠉꠤꠞꠣ, ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠦ ꠑꠣꠐꠣ ꠙꠠꠣꠞ ꠀꠅꠀꠎꠞ ꠟꠣꠈꠣꠘ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV6_2","096_6_2","REV","6","2","2","ꠔꠦꠃ ꠀꠝꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣꠝ, ꠗꠟꠣ ꠄꠇꠐꠣ ꠊꠥꠠꠣ, ꠄꠞ ꠃꠙꠞꠦ ꠎꠦꠁꠘ ꠍꠅꠀꠞ ꠅꠁꠍꠂꠘ ꠔꠣꠘ ꠀꠔꠅ ꠔꠤꠞ-ꠗꠘꠥꠇ ꠀꠍꠦ। ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠔꠣꠎ ꠟꠣꠉꠣꠁꠟ ꠅꠁꠟ, ꠔꠣꠁꠘ ꠎꠄ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠎꠄ ꠇꠞꠤ ꠇꠞꠤ ꠞꠅꠀꠘꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV6_3","096_6_3","REV","6","3","3","ꠀꠞ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠖꠥꠍꠞꠣ ꠡꠤꠟ ꠜꠣꠋꠉꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠖꠥꠍꠞꠣ ꠎꠣꠘꠖꠣꠞꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ, ꠄꠁꠘ ꠇꠁꠟꠣ, “ꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV6_4","096_6_4","REV","6","4","4","ꠔꠦꠃ ꠟꠣꠟ ꠌꠥꠞꠥꠇ ꠀꠞꠇꠐꠣ ꠊꠥꠠꠣ ꠛꠣꠞ ꠅꠁꠟ, ꠀꠞ ꠄꠞ ꠃꠙꠞꠦ ꠎꠦꠁꠘ ꠍꠅꠀꠞ ꠅꠁꠍꠂꠘ, ꠄꠘꠞꠦ ꠅꠃ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠢꠇꠟ ꠡꠣꠘ꠆ꠔꠤ ꠇꠣꠠꠤꠀ ꠘꠦꠁꠘꠉꠤ, ꠝꠣꠘꠡꠦ ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠈꠥꠘ ꠇꠞꠂꠘ, ꠄꠘꠞꠦ ꠛꠠ ꠄꠇꠈꠣꠘ ꠔꠟꠥꠀꠞꠅ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV6_5","096_6_5","REV","6","5","5","ꠛꠣꠖꠦ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠄ ꠎꠦꠛꠟꠣ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠡꠤꠟ ꠜꠣꠋꠉꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠎꠣꠘꠖꠣꠞꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ, ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠅ।” ꠔꠦꠃ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠄꠇꠐꠣ ꠇꠣꠟꠣ ꠊꠥꠠꠣ। ꠄꠞ ꠃꠙꠞꠦ ꠎꠦꠁꠘ ꠍꠅꠀꠞ ꠅꠁꠍꠂꠘ, ꠔꠣꠘ ꠀꠔꠅ ꠄꠇꠈꠣꠘ ꠙꠣꠟ꠆ꠟꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV6_6","096_6_6","REV","6","6","6","ꠀꠞ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠢꠃ ꠌꠣꠁꠞꠎꠘ ꠎꠣꠘꠖꠣꠞꠞ ꠝꠣꠎꠈꠣꠘ ꠕꠣꠇꠤ ꠇꠦꠃ ꠎꠣꠘꠥ ꠇꠁꠞꠣ, “ꠄꠇ ꠖꠤꠘꠣꠞꠦ ꠈꠣꠟꠤ ꠄꠇ ꠡꠦꠞ ꠉꠝ ꠛꠣ ꠄꠇ ꠖꠤꠘꠣꠞꠦ ꠔꠤꠘ ꠡꠦꠞ ꠛꠣꠞ꠆ꠟꠤ ꠝꠤꠟꠦ। ꠅꠁꠟꠦ ꠔꠥꠝꠤ ꠎꠄꠔꠥꠘ ꠀꠞ ꠀꠋꠉꠥꠞ ꠉꠣꠍꠞ ꠈꠦꠔꠤ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV6_7","096_6_7","REV","6","7","7","ꠅꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠄ ꠎꠦꠛꠟꠣ ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠡꠤꠟ ꠜꠣꠋꠉꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠎꠣꠘꠖꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV6_8","096_6_8","REV","6","8","8","ꠔꠦꠃ ꠀꠝꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣꠝ, ꠍꠣꠟꠤ ꠞꠋꠉꠞ ꠄꠇ ꠊꠥꠠꠣ, ꠅꠃ ꠊꠥꠠꠣꠞ ꠎꠦꠁꠘ ꠍꠅꠀꠞ, ꠄꠘ ꠘꠣꠝ ꠅꠁꠟ ꠝꠃꠔ ꠀꠞ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠇꠄꠛꠞꠦ ꠀꠐꠦꠞ। ꠄꠞꠣꠞꠦ ꠖꠥꠘꠤꠀꠞ ꠌꠣꠁꠞ ꠛꠣꠐꠞ ꠝꠣꠎꠞ ꠄꠇ ꠛꠣꠐꠞ ꠃꠙꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠔꠣꠞꠣ ꠔꠟꠥꠀꠞ ꠖꠤꠀ, ꠘꠤꠖꠣꠘ ꠖꠤꠀ, ꠉꠎꠛꠤ ꠝꠃꠔ ꠀꠞ ꠎꠋꠟꠤ ꠎꠣꠘꠥꠀꠞ ꠖꠤꠀ ꠝꠣꠘꠡꠞ ꠎꠣꠘ ꠘꠦꠁꠘ। ");
INSERT INTO syls_vpl VALUES ("RV6_9","096_6_9","REV","6","9","9","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠎꠦꠛꠟꠣ ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠡꠤꠟ ꠜꠣꠋꠉꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠔꠟꠦ ꠅꠃ ꠟꠣꠈꠣꠘ ꠝꠣꠘꠡꠞ ꠞꠥꠢꠥ ꠅꠇꠟ ꠀꠍꠦ, ꠎꠦꠞꠣꠞꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝꠞ ꠟꠣꠉꠤ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠙꠇ꠆ꠇꠦ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ ꠎꠣꠘꠦ ꠝꠣꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV6_10","096_6_10","REV","6","10","10","ꠄꠞꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠅ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠢꠇ꠆ꠇꠣꠘꠤ ꠝꠃꠟꠣ, ꠀꠝꠞꠣꠞꠦ ꠈꠥꠘ ꠇꠞꠣꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠔꠦ ꠀꠞ ꠛꠖꠟꠣ ꠟꠁꠔꠦ, ꠔꠥꠝꠤ ꠖꠥꠘꠤꠀꠞ ꠝꠣꠘꠡꠞꠦ ꠀꠞ ꠇꠔꠖꠤꠘ ꠡꠝꠄ ꠖꠤꠔꠣꠄ?” ");
INSERT INTO syls_vpl VALUES ("RV6_11","096_6_11","REV","6","11","11","ꠔꠦꠃ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠗꠟꠣ ꠟꠦꠛꠣꠍ ꠖꠣꠘ ꠇꠞꠣ ꠅꠁꠟ, ꠀꠞ ꠇꠅꠀ ꠅꠁꠟ, ꠔꠣꠞꠣꠞ ꠟꠉꠞ ꠈꠦꠎꠝꠔꠉꠣꠞ ꠀꠞ ꠔꠣꠞꠣꠞ ꠎꠔ ꠜꠣꠁꠀꠁꠘꠞꠦ ꠔꠣꠞꠣꠞ ꠘꠝꠥꠘꠣꠄ ꠡꠢꠤꠖ ꠇꠞꠣ ꠅꠁꠛ, ꠄꠞꠣꠞ ꠡꠋꠈꠣ ꠙꠥꠞꠣ ꠘꠣ ꠅꠀ ꠙꠞ꠆ꠎꠘ꠆ꠔ, ꠀꠞꠅ ꠇꠤꠍꠥ ꠖꠤꠘ ꠛꠣꠞ ꠌꠣꠁꠔꠦ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV6_12","096_6_12","REV","6","12","12","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠄ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠡꠤꠟ ꠜꠣꠋꠉꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠈꠥꠛ ꠛꠠ ꠜꠂꠍꠣꠟ ꠅꠁꠟ। ꠡꠥꠞꠥꠎꠞ ꠞꠋ ꠅꠁꠉꠦꠟ ꠇꠣꠟꠣ ꠍꠤꠀꠁ ꠀꠞ ꠜꠞꠣ ꠌꠣꠘ꠆ꠖꠞ ꠞꠋ ꠅꠁꠟ ꠟꠃꠞ ꠟꠣꠈꠣꠘ ꠟꠣꠟ। ");
INSERT INTO syls_vpl VALUES ("RV6_13","096_6_13","REV","6","13","13","ꠔꠥꠚꠣꠘ ꠀꠁꠟꠦ ꠎꠦꠟꠣ ꠒꠥꠝꠥꠞ ꠉꠣꠍ ꠕꠣꠇꠤ ꠇꠣꠌꠣ ꠚꠟꠅ ꠔꠥꠚꠣꠘꠦ ꠚꠣꠟꠣꠁ ꠖꠦꠄ, ꠑꠤꠇ ꠅꠃꠟꠣ ꠀꠍꠝꠣꠘꠞ ꠔꠦꠞꠣ ꠅꠇꠟ ꠈꠥꠟꠤꠀ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠙꠠꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV6_14","096_6_14","REV","6","14","14","ꠀꠡ꠆ꠔꠣ ꠀꠍꠝꠣꠘ ꠖꠟꠣ ꠅꠁꠀ ꠇꠣꠉꠎꠞ ꠙꠥꠐꠟꠣ ꠟꠣꠈꠣꠘ ꠛꠘꠤꠀ ꠉꠣꠁꠛ ꠅꠁꠉꠦꠟ। ꠙꠣꠠ-ꠙꠞꠛꠔ ꠀꠞ ꠖꠤꠙ ꠅꠇꠟꠅ ꠎꠣꠞꠎꠤꠞ ꠎꠣꠉꠣ ꠕꠣꠇꠤ ꠢꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV6_15","096_6_15","REV","6","15","15","ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠞꠣꠎꠣ-ꠛꠣꠖꠡꠣꠁꠘ, ꠘꠣꠝꠇꠞꠣ ꠎꠘ, ꠍꠤꠙꠣꠁꠞ ꠙꠞꠗꠣꠘ, ꠎꠝꠤꠖꠣꠞ, ꠙꠄꠟꠥꠀꠘ, ꠉꠥꠟꠣꠝ ꠛꠣ ꠀꠎꠣꠖ ꠙꠞꠔꠦꠇ ꠎꠘꠃ ꠙꠣꠠꠞ ꠉꠣꠔꠦ ꠉꠣꠔꠦ, ꠙꠣꠔ꠆ꠔꠞꠞ ꠀꠅꠠꠦ ꠟꠥꠇꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV6_16","096_6_16","REV","6","16","16","ꠔꠣꠞꠣ ꠅꠃ ꠙꠣꠠ ꠀꠞ ꠙꠣꠔ꠆ꠔꠞ ꠅꠇꠟꠞꠦ ꠇꠁꠟ, “ꠀꠝꠞꠣꠞ ꠃꠙꠞꠦ ꠀꠁꠀ ꠙꠠꠅ, ꠎꠦꠁꠘ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠂꠘ ꠔꠣꠘ ꠌꠃꠈꠞ ꠍꠣꠝꠘ ꠕꠣꠇꠤ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠉꠎꠛ ꠕꠣꠇꠤ ꠀꠝꠞꠣꠞꠦ ꠟꠥꠇꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("RV6_17","096_6_17","REV","6","17","17","ꠔꠣꠞꠣꠞ ꠉꠎꠛꠤ ꠢꠃ ꠇꠤꠀꠝꠔꠞ ꠖꠤꠘ ꠔ ꠀꠁꠌ꠆ꠍꠦ, ꠅꠈꠘ ꠀꠞ ꠐꠤꠇꠤꠀ ꠕꠣꠇꠣꠞ ꠡꠣꠁꠖ꠆ꠖ ꠇꠣꠞ ꠀꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("RV7_1","096_7_1","REV","7","1","1","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠖꠥꠘꠤꠀꠞ ꠌꠣꠁꠞ ꠇꠥꠘꠣꠔ ꠌꠣꠁꠞꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠔꠣꠞꠣ ꠖꠥꠘꠤꠀꠔ, ꠖꠞꠤꠀꠔ ꠀꠞ ꠢꠇꠟ ꠉꠣꠍ-ꠙꠣꠟꠣꠔ ꠛꠣꠔꠣꠡ ꠢꠣꠝꠣꠘꠤꠞ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠃꠛꠣꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV7_2","096_7_2","REV","7","2","2","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠙꠥꠛꠦ ꠕꠣꠇꠤ ꠀꠞꠇ ꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠃꠑꠤꠀ ꠀꠁꠞꠣ, ꠎꠤꠘ꠆ꠖꠣ ꠀꠟ꠆ꠟꠣꠞ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠍꠦ। ꠔꠣꠁꠘ ꠀꠁꠀ ꠎꠦ ꠌꠣꠁꠞꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠖꠥꠘꠤꠀ ꠀꠞ ꠖꠞꠤꠀꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠢꠃ ꠌꠣꠁꠞꠅ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RV7_3","096_7_3","REV","7","3","3","“ꠀꠝꠞꠣ ꠎꠔꠛꠁꠟ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠇꠙꠣꠟꠅ ꠡꠤꠟ ꠘꠣ ꠝꠣꠞꠍꠤ, ꠅꠔꠛꠁꠟ ꠔꠥꠝꠞꠣ ꠖꠥꠘꠤꠀꠞ, ꠖꠞꠤꠀꠞ ꠛꠣ ꠉꠣꠍ-ꠙꠣꠟꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV7_4","096_7_4","REV","7","4","4","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠃ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠙꠞꠤꠝꠣꠘ ꠢꠥꠘꠟꠣꠝ। ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠄꠇ ꠟꠣꠈ ꠌꠃꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠎꠘꠞꠦ ꠡꠤꠟ ꠝꠣꠞꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV7_5","096_7_5","REV","7","5","5","ꠄꠢꠥꠖꠣ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠛꠣꠞꠅ ꠀꠎꠣꠞ ꠎꠘ ꠡꠤꠟ ꠝꠣꠞꠣ; ꠞꠥꠛꠦꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ꠍꠣꠖꠥ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ");
INSERT INTO syls_vpl VALUES ("RV7_6","096_7_6","REV","7","6","6","ꠀꠡꠤꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ꠘꠙ꠆ꠔꠣꠟꠤ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ꠝꠣꠘꠡꠣ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ");
INSERT INTO syls_vpl VALUES ("RV7_7","096_7_7","REV","7","7","7","ꠡꠤꠝꠤꠅꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ꠟꠦꠛꠤ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ꠁꠍꠣꠈꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ");
INSERT INTO syls_vpl VALUES ("RV7_8","096_7_8","REV","7","8","8","ꠍꠛꠥꠟꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ꠁꠃꠍꠥꠚ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ; ꠛꠤꠘ-ꠁꠀꠝꠤꠘ ꠈꠣꠘ꠆ꠖꠣꠘ ꠕꠣꠇꠤ ꠛꠣꠞꠅ ꠀꠎꠣꠞ ꠎꠘ ꠡꠤꠟ ꠝꠣꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV7_9","096_7_9","REV","7","9","9","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠙꠞꠔꠦꠇ ꠖꠦꠡ, ꠢꠇꠟ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠢꠇꠟ ꠎꠣꠔꠤ ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠥꠟꠤꠄ ꠝꠣꠔꠞꠣ ꠛꠃꠔ ꠝꠣꠘꠥꠡ ꠖꠟꠣ ꠅꠁꠍꠂꠘ, ꠄꠞꠣꠞꠦ ꠉꠘꠤꠀ ꠚꠥꠠꠣꠘꠤꠞ ꠡꠣꠁꠖ꠆ꠖ ꠇꠦꠃꠞꠞ ꠘꠣꠁ। ꠄꠞꠣ ꠗꠟꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠀ ꠈꠦꠎꠥꠞ ꠙꠣꠔꠣ ꠀꠔꠅ ꠟꠁꠀ, ꠢꠃ ꠔꠈ꠆ꠔ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV7_10","096_7_10","REV","7","10","10","ꠔꠣꠞꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠞꠣ, “ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠎꠦꠁꠘ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠂꠘ, ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠀꠔꠅꠃ, ꠉꠥꠘꠣꠞ ꠝꠣꠚꠤ ꠀꠞ ꠘꠣꠎꠣꠔ ꠀꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV7_11","096_7_11","REV","7","11","11","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠝꠣꠝ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ, ꠢꠃ ꠔꠈ꠆ꠔꠞ, ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠀꠞ ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞꠞ ꠌꠣꠁꠞꠅ ꠇꠣꠘ꠆ꠖꠣꠛꠣꠄ ꠃꠛꠣꠁꠟꠣ। ꠔꠣꠞꠣ ꠔꠈ꠆ꠔꠞ ꠍꠣꠝꠘꠦ ꠍꠁꠎꠖꠣꠔ ꠙꠠꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RV7_12","096_7_12","REV","7","12","12","“ꠀꠝꠤꠘ। ꠔꠣꠞꠤꠚ, ꠉꠃꠞꠛ, ꠀꠈꠟ ꠀꠞ ꠡꠥꠇꠞꠤꠀ, ꠁꠎ꠆ꠎꠔ, ꠈꠦꠝꠔꠣ ꠀꠞ ꠛꠟ-ꠡꠇ꠆ꠔꠤ, ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞꠃ ꠅꠃꠇ। ꠀꠝꠤꠘ।” ");
INSERT INTO syls_vpl VALUES ("RV7_13","096_7_13","REV","7","13","13","ꠛꠣꠖꠦ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠦ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠛꠥꠎꠞꠣꠄ ꠘꠤ, ꠗꠟꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠣ ꠅꠃ ꠝꠣꠘꠥꠡ ꠅꠇꠟ ꠇꠦ, ꠄꠞꠣ ꠇꠥꠀꠁ ꠕꠣꠇꠤ ꠀꠁꠍꠂꠘ?” ");
INSERT INTO syls_vpl VALUES ("RV7_14","096_7_14","REV","7","14","14","ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠇꠁꠟꠣꠝ, “ꠅ ꠝꠣꠟꠤꠇ, ꠁꠔꠣ ꠔ ꠀꠙꠘꠦꠃ ꠎꠣꠘꠂꠘ।” ꠔꠦꠃ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠄꠞꠣ ꠅꠁꠟꠣ ꠢꠃ ꠎꠘ ꠅꠇꠟ, ꠎꠦꠞꠣ ꠢꠃ ꠝꠢꠣ ꠝꠍꠤꠛꠔꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠀꠁꠍꠦ। ꠔꠣꠞꠣꠞ ꠟꠦꠛꠣꠍꠞꠦ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠃꠖꠤ ꠗꠁꠀ ꠗꠟꠣ ꠛꠣꠘꠣꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV7_15","096_7_15","REV","7","15","15","ꠄꠞꠟꠣꠉꠤ ꠄꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠔꠈ꠆ꠔꠞ ꠍꠣꠝꠘꠦ ꠀꠍꠦ; ꠔꠣꠞꠣ ꠖꠤꠘ-ꠞꠣꠁꠔ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠝꠣꠎꠦ ꠄꠛꠣꠖꠔ-ꠛꠘ꠆ꠖꠦꠉꠤ ꠇꠞꠞꠣ। ꠀꠞ ꠔꠈ꠆ꠔꠅ ꠎꠦꠁꠘ ꠛꠅꠀꠔ ꠀꠍꠂꠘ, ꠔꠣꠁꠘ ꠘꠤꠎꠦ ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠔꠣꠝ꠆ꠛꠥ ꠐꠣꠘꠣꠁ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV7_16","096_7_16","REV","7","16","16","ꠄꠞꠣꠞ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠜꠥꠇ ꠟꠣꠉꠔ ꠘꠣꠄ, ꠙꠣꠘꠤꠞ ꠙꠤꠀꠍꠦ ꠗꠞꠔ ꠘꠣꠄ; ꠡꠥꠞꠥꠎꠞ ꠔꠦꠎ ꠄꠞꠣꠞ ꠉꠔꠞꠅ ꠟꠣꠉꠔ ꠘꠣꠄ, ꠇꠥꠘꠥ ꠉꠞꠝꠅ ꠟꠣꠉꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV7_17","096_7_17","REV","7","17","17","ꠔꠈ꠆ꠔꠞ ꠝꠣꠎꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠄꠃ ꠄꠞꠣꠞ ꠞꠣꠈꠣꠟꠤ ꠇꠞꠛꠣ। ꠔꠣꠁꠘ ꠄꠞꠣꠞꠦ ꠀꠛꠦ-ꠢꠣꠄꠀꠔꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠙꠣꠘꠤꠞ ꠏꠞꠘꠣꠞ ꠉꠦꠍꠦ ꠟꠁꠀ ꠎꠣꠁꠛꠣ, ꠀꠞ ꠀꠟ꠆ꠟꠣꠄ ꠄꠞꠣꠞ ꠌꠃꠈꠞ ꠙꠣꠘꠤ ꠚꠥꠍꠤꠀ ꠖꠤꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV8_1","096_8_1","REV","8","1","1","ꠛꠣꠖꠦ ꠅꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠄ ꠎꠦꠛꠟꠣ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠜꠣꠋꠉꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠅꠘꠥꠝꠣꠘ ꠀꠗꠣ ꠊꠘ꠆ꠐꠣ ꠡꠝꠄ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠇꠥꠘꠥ ꠀꠅꠀꠎ ꠢꠥꠘꠣ ꠉꠦꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV8_2","096_8_2","REV","8","2","2","ꠀꠞ ꠎꠦ ꠡꠣꠔꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠔ ꠕꠣꠇꠂꠘ, ꠀꠝꠤ ꠄꠞꠣꠞꠦ ꠖꠦꠈꠟꠣꠝ, ꠄꠞꠣꠞ ꠀꠔꠅ ꠡꠣꠔꠐꠣ ꠡꠤꠋꠉꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV8_3","096_8_3","REV","8","3","3","ꠄꠞꠛꠣꠖꠦ ꠀꠞꠇ ꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠁꠀ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁꠟꠣ। ꠔꠣꠘ ꠀꠔꠅ ꠡꠥꠘꠣꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠖꠣꠘꠤ। ꠔꠈ꠆ꠔꠞ ꠍꠣꠝꠘꠞ ꠀꠉꠞ ꠎꠣꠟꠣꠘꠤꠞ ꠡꠥꠘꠣꠞ ꠐꠦꠛꠥꠟꠞ ꠃꠙꠞꠦ ꠎꠣꠟꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠀꠉꠞ-ꠈꠥꠡꠛꠄ ꠔꠣꠘꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠝꠣꠝ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔꠞ ꠟꠉꠦ ꠝꠤꠡꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠁꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV8_4","096_8_4","REV","8","4","4","ꠄꠞꠟꠣꠉꠤ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠀꠔꠞ ꠀꠉꠞ-ꠈꠥꠡꠛꠄꠞ ꠗꠥꠝꠣꠞ ꠟꠉꠦ, ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠖꠥꠀ-ꠝꠥꠘꠣꠎꠣꠔꠅ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠃꠑꠟ। ");
INSERT INTO syls_vpl VALUES ("RV8_5","096_8_5","REV","8","5","5","ꠛꠣꠖꠦ ꠅꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠀꠉꠥꠁꠘ ꠘꠤꠀ ꠀꠉꠞ ꠖꠣꠘꠤꠔ ꠜꠞꠟꠣ, ꠜꠞꠤꠀ ꠁꠔꠣ ꠖꠥꠘꠤꠀꠔ ꠚꠣꠟꠣꠁꠟꠣ। ꠔꠦꠃ ꠑꠣꠐꠣꠞꠤ ꠀꠅꠀꠎ, ꠝꠦꠊꠞ ꠒꠣꠇ, ꠎꠤꠟꠇꠣꠘꠤ, ꠀꠞ ꠜꠂꠍꠣꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV8_6","096_8_6","REV","8","6","6","ꠀꠞ ꠢꠃ ꠎꠦ ꠡꠣꠔꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠀꠔꠅ ꠡꠣꠔꠐꠣ ꠡꠤꠋꠉꠣ ꠀꠍꠤꠟ, ꠄꠞꠣ ꠅꠃ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV8_7","096_8_7","REV","8","7","7","ꠙꠄꠟꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠘꠤꠞ ꠟꠉꠦ ꠟꠉꠦ ꠟꠃ ꠝꠣꠈꠣꠁꠟ ꠢꠤꠟ ꠀꠞ ꠀꠉꠥꠁꠘ ꠎꠝꠤꠘꠅ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠟ। ꠔꠦꠃ ꠎꠝꠤꠘꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ, ꠉꠣꠍ-ꠉꠣꠍꠣꠟꠤꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ, ꠀꠞ ꠢꠇꠟ ꠊꠣꠡ-ꠙꠣꠔꠣ ꠎꠟꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV8_8","096_8_8","REV","8","8","8","ꠄꠞꠛꠣꠖꠦ ꠖꠥꠍꠞꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠎꠣꠟꠣꠁꠟ ꠙꠣꠠꠞ ꠟꠣꠈꠣꠘ ꠝꠥꠐꠣ ꠄꠇ ꠌꠤꠎ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠟ। ꠁꠔꠣꠄ ꠖꠞꠤꠀꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠙꠣꠘꠤ ꠟꠃ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV8_9","096_8_9","REV","8","9","9","ꠖꠞꠤꠀꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠎꠣꠘꠖꠣꠞ ꠝꠞꠤꠉꠦꠟ, ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠎꠣꠎ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV8_10","096_8_10","REV","8","10","10","ꠛꠣꠖꠦ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠟꠣ। ꠔꠦꠃ ꠀꠍꠝꠣꠘꠞ ꠌꠇꠌꠇꠣ ꠛꠤꠞꠣꠐ ꠄꠇ ꠔꠦꠞꠣ ꠛꠠ ꠝꠥꠡꠣꠟꠞ ꠟꠣꠈꠣꠘ ꠎꠟꠤ ꠎꠟꠤ ꠔꠟꠦ ꠙꠠꠟ, ꠁꠐꠣ ꠀꠁꠀ ꠢꠇꠟ ꠉꠣꠋ, ꠈꠣꠟ-ꠛꠤꠟꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐꠞ ꠃꠙꠞꠦ ꠙꠠꠟ। ");
INSERT INTO syls_vpl VALUES ("RV8_11","096_8_11","REV","8","11","11","ꠅꠃ ꠔꠦꠞꠣꠞ ꠘꠣꠝ ꠀꠍꠤꠟ ꠘꠣꠉꠖꠣꠘꠣ। ꠁꠐꠣ ꠙꠠꠤꠀ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠙꠣꠘꠤ ꠔꠤꠔ꠆ꠔꠣ-ꠎꠢꠞ ꠅꠁꠉꠦꠟ, ꠁ ꠙꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠛꠃꠔ ꠎꠘ ꠝꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV8_12","096_8_12","REV","8","12","12","ꠀꠞ ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠎꠦꠛꠟꠣ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠟꠣ, ꠅꠃ ꠡꠝꠄ ꠌꠣꠘ꠆ꠖ, ꠡꠥꠞꠥꠎ ꠀꠞ ꠔꠦꠞꠣ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠔꠣꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠅꠋꠡ ꠎꠈꠝ ꠅꠁꠉꠦꠟ, ꠔꠦꠃ ꠢꠇꠟꠔꠣꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠟ, ꠄꠞꠟꠣꠉꠤ ꠖꠤꠘꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐꠅ ꠀꠞ ꠞꠣꠁꠔꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐꠅ ꠇꠥꠘꠥꠎꠣꠔ ꠞꠥꠡꠘꠤ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV8_13","096_8_13","REV","8","13","13","ꠛꠣꠖꠦ ꠀꠝꠤ ꠌꠣꠁꠟꠣꠝ, ꠌꠣꠁꠀ ꠖꠦꠈꠤ, ꠄꠇꠐꠣ ꠌꠤꠟ ꠙꠣꠈꠤ ꠛꠃꠔ ꠃꠌꠣꠔ ꠀꠍꠝꠣꠘꠞ ꠝꠣꠎꠦꠖꠤ ꠃꠠꠦꠞ, ꠀꠞ ꠢꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠝꠣꠔꠦꠞ, “ꠛꠣꠇꠤ ꠎꠦ ꠔꠤꠘꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠛꠣ, ꠔꠣꠞꠣꠞ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠟꠦ ꠖꠥꠘꠤꠀꠞ ꠛꠣꠡꠤꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠉꠎꠛ, ꠉꠎꠛ, ꠉꠎꠛ ꠟꠣꠝꠛ।” ");
INSERT INTO syls_vpl VALUES ("RV9_1","096_9_1","REV","9","1","1","ꠛꠣꠖꠦ ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠟꠣ, ꠔꠦꠃ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠀꠍꠝꠣꠘꠞ ꠄꠇꠐꠣ ꠔꠦꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠖꠥꠘꠤꠀꠔ ꠙꠠꠟ। ꠅꠃ ꠔꠦꠞꠣꠞꠦ ꠢꠣꠛꠤꠀ ꠖꠥꠎꠈꠞ ꠌꠣꠛꠤ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV9_2","096_9_2","REV","9","2","2","ꠔꠦꠃ ꠢꠦ ꠢꠣꠛꠤꠀ ꠖꠥꠎꠈꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠟ, ꠛꠃꠔ ꠛꠠ ꠒꠝꠇꠣ ꠕꠣꠇꠤ ꠎꠦꠟꠣ ꠗꠥꠝꠣ ꠛꠣꠞꠅꠄ, ꠁ ꠖꠥꠎꠈ ꠕꠣꠇꠤ ꠅꠟꠣ ꠗꠥꠝꠣ ꠛꠣꠞ ꠅꠁꠟ। ꠅꠃ ꠖꠥꠎꠈꠤ ꠗꠥꠝꠣꠄ ꠀꠍꠝꠣꠘ ꠀꠞ ꠡꠥꠞꠥꠎ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV9_3","096_9_3","REV","9","3","3","ꠢꠃ ꠗꠥꠝꠣ ꠕꠣꠇꠤ ꠛꠃꠔ ꠙꠋꠉꠙꠣꠟ ꠛꠣꠞ ꠅꠁꠀ ꠖꠥꠘꠤꠀꠔ ꠀꠁꠟꠣ। ꠁꠔꠣꠞꠦ ꠖꠥꠘꠤꠀꠞ ꠇꠣꠇꠠꠣ-ꠛꠤꠍꠣꠞ ꠟꠣꠈꠣꠘ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV9_4","096_9_4","REV","9","4","4","ꠔꠣꠞꠣꠞꠦ ꠢꠥꠇꠥꠝ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠔꠣꠞꠣ ꠎꠣꠘꠥ ꠖꠥꠘꠤꠀꠞ ꠇꠥꠘꠥ ꠊꠣꠡ-ꠙꠣꠔꠣ, ꠉꠣꠍ-ꠙꠣꠟꠣ ꠛꠣ ꠢꠣꠉ-ꠔꠞꠇꠣꠞꠤꠞ ꠈꠦꠔꠤ ꠘꠣ ꠇꠞꠦ। ꠈꠣꠟꠤ ꠎꠦꠔꠣ ꠝꠣꠘꠡꠞ ꠇꠙꠣꠟꠅ ꠀꠟ꠆ꠟꠣꠞ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠣ ꠘꠣꠁ, ꠅꠔꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV9_5","096_9_5","REV","9","5","5","ꠁꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠇꠥꠘꠥ ꠈꠦꠝꠔꠣ ꠔꠣꠞꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠟ ꠘꠣ, ꠅꠁꠟꠦ ꠙꠣꠌ ꠝꠣꠡ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ ꠖꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠇꠣꠇꠠꠣ-ꠛꠤꠍꠣꠄ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞꠦ ꠇꠣꠝꠠ ꠖꠤꠟꠦ ꠎꠦꠟꠣ ꠛꠤꠡ-ꠛꠦꠖꠘꠣ ꠅꠄ, ꠅꠃ ꠙꠋꠉꠙꠣꠟꠦ ꠇꠣꠝꠠꠣꠁꠟꠦꠅ ꠅꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV9_6","096_9_6","REV","9","6","6","ꠢꠃ ꠡꠝꠄ ꠝꠣꠘꠡꠦ ꠝꠃꠔ ꠝꠣꠋꠉꠤꠛꠣ, ꠔꠣ-ꠅ ꠝꠃꠔ ꠅꠁꠔ ꠘꠣꠄ। ꠔꠣꠞꠣ ꠝꠞꠔꠣ ꠌꠣꠁꠛꠣ ꠅꠁꠟꠦ ꠝꠞꠘ ꠔꠣꠞꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠜꠣꠉꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("RV9_7","096_9_7","REV","9","7","7","ꠁ ꠙꠋꠉꠙꠣꠟ ꠅꠇꠟ ꠖꠦꠈꠔꠦ ꠎꠥꠖ꠆ꠖꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠇꠞꠣ ꠊꠥꠠꠣꠞ ꠟꠣꠈꠣꠘ। ꠔꠣꠞꠣꠞ ꠝꠣꠕꠣꠔ ꠡꠥꠘꠣꠞ ꠔꠣꠎꠞ ꠟꠣꠈꠣꠘ ꠌꠤꠎ ꠀꠍꠤꠟ, ꠀꠞ ꠝꠥꠈꠞ ꠉꠑꠘ ꠅꠁꠟ ꠝꠣꠘꠡꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV9_8","096_9_8","REV","9","8","8","ꠔꠣꠞꠣꠞ ꠌꠥꠟ ꠅꠁꠟ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠌꠥꠟꠞ ꠟꠣꠈꠣꠘ ꠀꠞ ꠖꠣꠔ ꠅꠁꠟ ꠡꠤꠋꠢꠞ ꠖꠣꠔꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV9_9","096_9_9","REV","9","9","9","ꠔꠣꠞꠣꠞ ꠛꠥꠇꠥꠞ ꠝꠣꠎꠦ ꠀꠍꠤꠟ ꠟꠥꠀꠞ ꠙꠣꠔꠞ ꠟꠣꠈꠣꠘ ꠈꠡꠈꠡꠣ ꠍꠣꠟ। ꠎꠥꠖ꠆ꠖꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ ꠐꠣꠘꠤꠀ ꠊꠥꠠꠣꠞ ꠙꠣꠟ ꠄꠇꠟꠉꠦ ꠉꠦꠟꠦ ꠎꠦꠟꠣ ꠀꠅꠀꠎ ꠅꠄ, ꠔꠣꠞꠣꠞ ꠒꠣꠈꠘꠣꠞ ꠀꠅꠀꠎꠅ ꠀꠍꠤꠟ ꠅꠃ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV9_10","096_9_10","REV","9","10","10","ꠔꠣꠞꠣꠞ ꠟꠦꠁꠘ꠆ꠎ ꠀꠞ ꠟꠦꠁꠘ꠆ꠎꠞ ꠝꠥꠈꠞ ꠛꠤꠡ-ꠖꠣꠔ ꠀꠍꠤꠟ ꠇꠣꠇꠠꠣ-ꠛꠤꠍꠣꠞ ꠟꠣꠈꠣꠘ। ꠙꠣꠌ ꠝꠣꠡ ꠗꠞꠤ ꠝꠣꠘꠡꠞꠦ ꠇꠡ꠆ꠐ ꠖꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠁ ꠟꠦꠁꠘ꠆ꠎꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV9_11","096_9_11","REV","9","11","11","ꠢꠣꠛꠤꠀ ꠖꠥꠎꠈꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠍꠟꠣ ꠅꠃ ꠙꠋꠉꠙꠣꠟꠞ ꠞꠣꠎꠣ। ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠁ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠘꠣꠝ ꠅꠁꠟ ꠀꠛꠣꠖ꠆ꠖꠘ, ꠀꠞ ꠁꠃꠘꠣꠘꠤ ꠛꠣ ꠉ꠆ꠞꠤꠇ ꠜꠣꠡꠣꠄ ꠄꠞ ꠘꠣꠝ ꠅꠁꠟ ꠀꠙꠟ꠆ꠟꠤꠅꠘ, ꠝꠣꠘꠤ ꠉꠎꠛꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣ। ");
INSERT INTO syls_vpl VALUES ("RV9_12","096_9_12","REV","9","12","12","ꠙꠄꠟꠣ ꠉꠎꠛ ꠢꠞꠟ, ꠅꠁꠟꠦ ꠢꠥꠘꠅ, ꠀꠞꠅ ꠖꠥꠁꠐꠣ ꠉꠎꠛ ꠀꠁꠀ ꠀꠎꠦꠞ। ");
INSERT INTO syls_vpl VALUES ("RV9_13","096_9_13","REV","9","13","13","ꠛꠣꠖꠦ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠟꠣ। ꠔꠦꠃ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠞ ꠀꠉꠞ ꠎꠣꠟꠣꠘꠤꠞ ꠡꠥꠘꠣꠞ ꠐꠦꠛꠥꠟꠞ ꠌꠣꠁꠞꠐꠣ ꠢꠤꠋꠉꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠀꠝꠤ ꠄꠇꠎꠘꠞꠦ ꠅꠈꠣꠘ ꠇꠁꠔꠦ ꠢꠥꠘꠟꠣꠝ, ");
INSERT INTO syls_vpl VALUES ("RV9_14","096_9_14","REV","9","14","14","ꠄꠁꠘ ꠢꠃ ꠡꠤꠋꠉꠣ ꠀꠟꠣ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠇꠁꠟꠣ, “ꠝꠢꠣ ꠉꠣꠋ ꠚꠥꠞꠣꠔꠞ ꠝꠣꠎꠦ ꠎꠦ ꠌꠣꠁꠞꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠐꠇ ꠀꠍꠂꠘ, ꠔꠣꠞꠣꠞꠦ ꠈꠥꠟꠤꠀ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV9_15","096_9_15","REV","9","15","15","ꠄꠞꠟꠣꠉꠤ ꠢꠃ ꠌꠣꠁꠞꠅ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠍꠣꠠꠤ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠖꠥꠘꠤꠀꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠝꠣꠘꠡꠞꠦ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠅꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠞꠦ ꠡꠑꠤꠇ ꠡꠝꠄ, ꠡꠑꠤꠇ ꠖꠤꠘ, ꠝꠣꠡ ꠀꠞ ꠛꠍꠞꠞ ꠟꠣꠉꠤ ꠎꠥꠁꠔ ꠇꠞꠤ ꠞꠣꠈꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV9_16","096_9_16","REV","9","16","16","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠊꠥꠠꠣꠔ ꠌꠠꠤꠀ ꠎꠣꠅꠀ ꠅꠃ ꠍꠤꠙꠣꠁꠞ ꠙꠞꠤꠝꠣꠘ ꠀꠍꠤꠟ ꠛꠤꠡ ꠇꠥꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("RV9_17","096_9_17","REV","9","17","17","ꠅꠃ ꠖꠞꠡꠘꠅ ꠀꠝꠤ ꠎꠔ ꠊꠥꠠꠣꠁꠘ ꠀꠞ ꠊꠥꠠ-ꠍꠅꠀꠞ ꠅꠇꠟ ꠖꠦꠈꠟꠣꠝ, ꠁ ꠍꠅꠀꠞꠞꠦ ꠖꠦꠈꠔꠦ ꠅꠟꠣ ꠟꠣꠉꠟ, ꠄꠞꠣꠞ ꠛꠥꠇꠥꠞ ꠃꠙꠞꠞ ꠚꠃꠎꠤ ꠟꠦꠛꠣꠍ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠟꠣꠟ, ꠀꠇꠣꠡꠞ ꠟꠣꠈꠣꠘ ꠟꠤꠟ ꠀꠞ ꠉꠘ꠆ꠖꠇꠞ ꠟꠣꠈꠣꠘ ꠅꠟꠖꠤꠀ। ꠊꠥꠠꠣꠁꠘ꠆ꠔꠞ ꠇꠟ꠆ꠟꠣ ꠀꠍꠤꠟ ꠡꠤꠋꠢꠞ ꠇꠟ꠆ꠟꠣꠞ ꠟꠣꠈꠣꠘ, ꠁꠔꠣꠞ ꠝꠥꠈꠅ ꠕꠣꠇꠤ ꠀꠉꠥꠁꠘ, ꠗꠥꠝꠣ ꠀꠞ ꠉꠘ꠆ꠖꠇ ꠛꠣꠞ ꠅꠞ। ");
INSERT INTO syls_vpl VALUES ("RV9_18","096_9_18","REV","9","18","18","ꠄꠞꠣꠞ ꠝꠥꠈꠞ ꠅꠃ ꠀꠉꠥꠁꠘ, ꠗꠥꠝꠣ ꠀꠞ ꠉꠘ꠆ꠖꠇꠞ ꠉꠎꠛꠖꠤ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠝꠣꠘꠥꠡ ꠝꠣꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV9_19","096_9_19","REV","9","19","19","ꠁ ꠊꠥꠠꠣꠁꠘ꠆ꠔꠞ ꠟꠦꠁꠘ꠆ꠎ ꠀꠞ ꠝꠥꠈꠞ ꠝꠣꠎꠦꠃ ꠀꠍꠤꠟ ꠔꠣꠞꠣꠞ ꠛꠟ, ꠁ ꠟꠦꠁꠘ꠆ꠎ ꠀꠍꠤꠟ ꠖꠥ-ꠝꠥꠈꠤ ꠢꠣꠚꠞ ꠟꠣꠈꠣꠘ। ꠅꠃ ꠟꠦꠁꠘ꠆ꠎꠖꠤ ꠔꠣꠞꠣ ꠝꠣꠘꠡꠞ ꠈꠦꠔꠤ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("RV9_20","096_9_20","REV","9","20","20","ꠅꠁꠟꠦ ꠅꠃ ꠉꠎꠛꠞ ꠛꠣꠖꠦꠅ ꠎꠦꠔꠣ ꠝꠣꠘꠥꠡ ꠎꠤꠔꠣ ꠞꠁꠟꠣ, ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠀꠔꠞ ꠛꠣꠘꠣꠁꠟ ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠕꠣꠇꠤ ꠔꠃꠛꠣ ꠇꠞꠟ ꠘꠣ। ꠔꠣꠞꠣ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠜꠥꠔꠞ ꠙꠥꠎꠣ, ꠀꠞ ꠎꠦꠔꠣꠄ ꠖꠦꠈꠂꠘ ꠘꠣ, ꠢꠥꠘꠂꠘ ꠘꠣ ꠛꠣ ꠀꠐꠣ-ꠌꠟꠣ ꠇꠞꠔꠣ ꠙꠣꠞꠂꠘ ꠘꠣ ꠅꠔꠣ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠣꠔ ꠞꠁꠟꠣ। ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠙꠤꠔꠟ, ꠙꠣꠔ꠆ꠔꠞ ꠀꠞ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣꠔ ꠞꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV9_21","096_9_21","REV","9","21","21","ꠄꠞꠟꠉꠦ ꠈꠥꠘ-ꠈꠣꠞꠣꠙꠤ, ꠎꠣꠖꠥ-ꠐꠥꠘꠣ, ꠎꠤꠘꠣ ꠀꠞ ꠌꠥꠞꠤ ꠕꠣꠇꠤꠅ ꠔꠃꠛꠣ ꠇꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV10_1","096_10_1","REV","10","1","1","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠈꠥꠛ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠀꠞꠇ ꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠟꠣꠝꠤꠀ ꠀꠁꠞꠣ। ꠝꠦꠊꠞ ꠌꠣꠇꠣ ꠀꠍꠤꠟ ꠔꠣꠘ ꠟꠦꠛꠣꠍ, ꠔꠣꠘ ꠝꠥꠈ ꠡꠥꠞꠥꠎꠞ ꠟꠣꠈꠣꠘ ꠌꠇꠌꠇꠣ, ꠔꠣꠘ ꠙꠣꠅ ꠀꠍꠤꠟ ꠀꠉꠥꠘꠤꠞ ꠈꠥꠐꠤꠞ ꠟꠣꠈꠣꠘ। ꠔꠣꠘ ꠝꠣꠕꠣꠞ ꠃꠙꠞꠦ ꠀꠍꠤꠟ ꠞꠋꠗꠦꠘꠥ। ");
INSERT INTO syls_vpl VALUES ("RV10_2","096_10_2","REV","10","2","2","ꠔꠣꠘ ꠀꠔꠅ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠄꠇꠈꠣꠘ ꠇꠤꠔꠣꠛ ꠈꠥꠟꠣ ꠀꠍꠤꠟ। ꠔꠣꠘ ꠒꠣꠁꠘꠞ ꠙꠣꠅ ꠖꠞꠤꠀꠔ ꠀꠞ ꠛꠣꠃꠅꠞ ꠙꠣꠅ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠕꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("RV10_3","096_10_3","REV","10","3","3","ꠡꠤꠋꠢꠞ ꠟꠣꠈꠣꠘ ꠈꠥꠛ ꠎꠥꠞꠦ ꠉꠞ꠆ꠎꠤꠀ ꠃꠑꠤꠟꠣ। ꠅꠃ ꠉꠞ꠆ꠎꠘꠞ ꠟꠉꠦ ꠟꠉꠦꠃ ꠑꠣꠐꠣ ꠙꠠꠣꠞ ꠝꠔ ꠡꠣꠔꠐꠣ ꠀꠅꠀꠎ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV10_4","096_10_4","REV","10","4","4","ꠅꠃ ꠡꠣꠔꠅ ꠀꠅꠀꠎ ꠢꠥꠘꠤꠀ ꠀꠝꠤ ꠟꠦꠈꠣꠔ ꠟꠣꠉꠟꠣꠝ; ꠄꠞꠝꠣꠎꠦ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠅꠃ ꠡꠛ꠆ꠖ ꠀꠁꠟ, “ꠢꠥꠘꠅ, ꠅꠃ ꠡꠣꠔꠅ ꠑꠣꠐꠣꠞꠤ ꠀꠅꠀꠎꠦ ꠎꠦꠔꠣ ꠇꠁꠍꠂꠘ, ꠁꠔꠣ ꠛꠣꠔꠥꠘꠤ ꠞꠣꠈꠅ, ꠟꠦꠈꠤꠅ ꠘꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV10_5","096_10_5","REV","10","5","5","ꠛꠣꠖꠦ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣ, ꠎꠦꠘꠞꠦ ꠀꠝꠤ ꠖꠞꠤꠀ ꠀꠞ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠃꠛꠣꠔ ꠖꠦꠈꠍꠟꠣꠝ, ꠔꠣꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠛꠣꠄ ꠘꠤꠎꠞ ꠒꠣꠁꠘ ꠀꠔ ꠔꠥꠟꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV10_6","096_10_6","REV","10","6","6","ꠔꠥꠟꠤꠀ ꠎꠦꠁꠘ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠌꠤꠞꠇꠣꠟ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ, ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘ, ꠎꠝꠤꠘ, ꠖꠞꠤꠀ ꠀꠞ ꠁꠔꠣꠞ ꠝꠣꠎꠞ ꠢꠇ꠆ꠇꠟꠔꠣ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠘꠣꠝꠦ ꠇꠍꠝ ꠈꠣꠁꠀ ꠇꠁꠟꠣ, “ꠀꠞ ꠔ ꠖꠦꠞꠤ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV10_7","096_10_7","REV","10","7","7","ꠅꠁꠟꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠛꠣꠞ ꠖꠤꠘ ꠀꠟ꠆ꠟꠣꠞ ꠛꠣꠔꠥꠘꠤ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠙꠥꠞꠣ ꠅꠁꠛ। ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠥꠟꠣꠝ, ꠘꠛꠤ ꠅꠇꠟꠞ ꠉꠦꠍꠦ ꠎꠦꠟꠣ ꠛꠣꠔꠣꠁꠍꠟꠣ, ꠅꠃꠟꠣꠃ ꠚꠟꠤꠛ।” ");
INSERT INTO syls_vpl VALUES ("RV10_8","096_10_8","REV","10","8","8","ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠀꠉꠦ ꠎꠦ ꠡꠛ꠆ꠖ ꠢꠥꠘꠍꠤꠟꠣꠝ, ꠄꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠖꠞꠤꠀ ꠀꠞ ꠎꠝꠤꠘꠞ ꠃꠙꠞꠦ ꠎꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠃꠛꠣꠔ ꠀꠍꠂꠘ, ꠔꠣꠘ ꠉꠦꠍꠦ ꠎꠣꠅ, ꠉꠤꠀ ꠔꠣꠘ ꠀꠔ ꠕꠣꠇꠤ ꠈꠥꠟꠣ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠘꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV10_9","096_10_9","REV","10","9","9","ꠔꠦꠃ ꠀꠝꠤ ꠄꠘ ꠉꠦꠍꠦ ꠉꠤꠀ ꠇꠁꠟꠣꠝ, ꠅꠃ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠦꠅꠀꠞ ꠟꠣꠉꠤ। ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠀꠁꠌ꠆ꠍꠣ ꠘꠦꠅꠉꠤ, ꠘꠤꠀ ꠈꠣꠁꠟꠣꠅ। ꠁꠈꠣꠘꠦ ꠔꠥꠝꠣꠞ ꠙꠦꠐꠞꠦ ꠔꠤꠔ꠆ꠔꠣ ꠇꠞꠤꠟꠤꠛ, ꠅꠁꠟꠦ ꠔꠥꠝꠣꠞ ꠝꠥꠈꠅ ꠝꠃ ꠟꠣꠈꠣꠘ ꠝꠤꠑꠣ ꠟꠣꠉꠛ।” ");
INSERT INTO syls_vpl VALUES ("RV10_10","096_10_10","REV","10","10","10","ꠅꠃ ꠀꠝꠤ ꠢꠤ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠀꠔꠞ ꠢꠥꠞꠥ-ꠝꠥꠞꠥ ꠇꠤꠔꠣꠛꠈꠣꠘ ꠘꠤꠀ ꠈꠣꠁꠟꠤꠟꠣꠝ। ꠈꠣꠁꠔꠦ ꠡꠝꠄ ꠢꠣꠍꠣꠃ ꠀꠝꠣꠞ ꠝꠥꠈꠅ ꠝꠃ ꠟꠣꠈꠣꠘ ꠝꠤꠑꠣ ꠟꠣꠉꠟ, ꠀꠞ ꠉꠤꠟꠤꠀ ꠢꠣꠞꠟꠦ ꠀꠡ꠆ꠔꠣ ꠙꠦꠐ ꠔꠤꠔ꠆ꠔꠣ ꠅꠁꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV10_11","096_10_11","REV","10","11","11","ꠛꠣꠖꠦ ꠀꠝꠣꠞꠦ ꠇꠅꠀ ꠅꠁꠟ, “ꠔꠥꠝꠤ ꠛꠃꠔ ꠖꠦꠡ, ꠛꠃꠔ ꠎꠣꠔꠤ, ꠘꠣꠘꠣꠘ ꠛꠥꠟꠤꠄ ꠝꠣꠔꠞꠣ ꠝꠣꠘꠥꠡ, ꠀꠞ ꠛꠣꠖꠡꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠢꠤꠞꠛꠣꠞ ꠅꠢꠤ ꠎꠣꠘꠣꠁꠔꠦ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("RV11_1","096_11_1","REV","11","1","1","ꠛꠣꠖꠦ ꠝꠣꠙꠤꠛꠣꠞ ꠟꠣꠉꠤ ꠟꠣꠑꠤꠞ ꠟꠣꠈꠣꠘ ꠄꠇꠐꠣ ꠘꠟ ꠀꠝꠣꠞ ꠀꠔꠅ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠀꠞ ꠄꠇꠎꠘꠦ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠙꠛꠤꠔ꠆ꠞ ꠛꠣꠄꠔꠥꠟ-ꠝꠥꠇꠣꠖ꠆ꠖꠍ ꠇꠣꠛꠣ ꠡꠞꠤꠚ ꠀꠞ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞꠦ ꠝꠣꠙꠅ। ꠝꠣꠙꠤꠀ ꠢꠘꠅ ꠎꠦꠞꠣ ꠄꠛꠣꠖꠔ ꠇꠞꠦ ꠔꠣꠞꠣꠞ ꠙꠞꠤꠝꠣꠘ ꠉꠘꠅ। ");
INSERT INTO syls_vpl VALUES ("RV11_2","096_11_2","REV","11","2","2","ꠅꠁꠟꠦ ꠅꠃ ꠇꠣꠛꠣ ꠊꠞꠞ ꠃꠑꠣꠘꠞꠦ ꠝꠣꠙꠤꠅ ꠘꠣ, ꠁꠈꠣꠘ ꠛꠣꠖ ꠖꠦꠅ, ꠁꠈꠣꠘ ꠔ ꠛꠤꠗꠞ꠆ꠝꠤ ꠅꠇꠟꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠔꠣꠞꠣ ꠛꠦꠀꠟ꠆ꠟꠤꠡ ꠝꠣꠡ ꠗꠞꠤ ꠁ ꠙꠛꠤꠔ꠆ꠞ ꠎꠣꠉꠣꠈꠣꠘꠞꠦ ꠙꠣꠅꠖꠤ ꠇꠌꠟꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV11_3","096_11_3","REV","11","3","3","ꠀꠞ ꠀꠝꠤ ꠀꠝꠣꠞ ꠖꠥꠁꠎꠘ ꠡꠣꠇ꠆ꠇꠤꠞꠦ ꠅꠟꠣ ꠈꠦꠝꠔꠣ ꠖꠤꠝꠥ, ꠁ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠀ ꠄꠞꠣ ꠇꠣꠔꠞ ꠅꠁꠀ ꠍꠟꠣꠞ ꠌꠐ ꠚꠤꠘ꠆ꠖꠤꠀ, ꠄꠇ ꠀꠎꠣꠞ ꠖꠥꠁ-ꠡ ꠡꠣꠁꠐ ꠖꠤꠘ ꠘꠛꠤꠞ ꠟꠣꠈꠣꠘ ꠅꠢꠤ ꠛꠣꠔꠣꠁꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV11_4","096_11_4","REV","11","4","4","ꠄꠞꠣ ꠅꠁꠟꠣ ꠢꠃ ꠎꠄꠔꠥꠘ ꠉꠣꠍ ꠎꠥꠠꠣ, ꠀꠞ ꠢꠃ ꠌꠦꠞꠣꠉꠖꠣꠘꠤ ꠎꠥꠠꠣ, ꠔꠣꠞꠣ ꠔ ꠖꠤꠘ-ꠖꠥꠘꠤꠀꠞ ꠝꠣꠟꠤꠇꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠔ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV11_5","096_11_5","REV","11","5","5","ꠇꠦꠃ ꠔꠣꠞꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠔꠦ ꠌꠣꠁꠟꠦ, ꠔꠣꠞꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠀꠉꠥꠁꠘ ꠛꠣꠞ ꠅꠁꠀ ꠢꠤ ꠖꠥꠡꠝꠘ ꠅꠇꠟꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠛ। ꠎꠦꠇꠥꠘꠥ ꠎꠘꠦ ꠔꠣꠞꠣꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠦ ꠅꠃ ꠖꠡꠣꠄ ꠝꠃꠔ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV11_6","096_11_6","REV","11","6","6","ꠄꠞꠣ ꠎꠔꠖꠤꠘ ꠘꠛꠤ ꠢꠣꠟꠔꠦ ꠅꠢꠤ ꠛꠣꠔꠣꠁꠛꠣ, ꠅꠔ ꠖꠤꠘ ꠎꠣꠔꠦ ꠇꠥꠘꠥ ꠝꠦꠊ ꠘꠣ ꠅꠄ ꠄꠞꠟꠣꠉꠤ ꠀꠍꠝꠣꠘꠞ ꠖꠥꠀꠞ ꠛꠘ꠆ꠖ ꠇꠞꠤ ꠖꠤꠛꠣꠞ ꠈꠦꠝꠔꠣ ꠔꠣꠞꠣꠞ ꠀꠍꠦ। ꠙꠣꠘꠤꠞꠦ ꠟꠃ ꠛꠣꠘꠣꠘꠤ, ꠀꠞ ꠎꠔꠛꠣꠞ ꠈꠥꠡꠤ ꠅꠔꠛꠣꠞ ꠎꠦꠇꠥꠘꠥ ꠉꠎꠛ ꠓꠣꠟꠤꠀ ꠎꠉꠔꠞ ꠈꠦꠔꠤ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣꠅ ꠔꠣꠞꠣꠞ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV11_7","096_11_7","REV","11","7","7","ꠔꠣꠞꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠦꠅꠀ ꠡꠦꠡ ꠅꠁꠉꠦꠟꠦ ꠢꠣꠛꠤꠀ ꠖꠥꠎꠈ ꠕꠣꠇꠤ ꠢꠃ ꠎꠣꠘꠥꠀꠞ ꠃꠑꠤꠀ ꠀꠁꠀ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠤꠀ, ꠔꠣꠞꠣꠞꠦ ꠀꠞꠣꠁꠀ ꠈꠥꠘ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("RV11_8","096_11_8","REV","11","8","8","ꠀꠞ ꠔꠣꠞꠣꠞ ꠟꠣꠡ ꠢꠃ ꠝꠢꠣꠘ ꠐꠣꠃꠘꠞ ꠞꠣꠡ꠆ꠔꠣꠞ ꠝꠣꠎꠦ ꠙꠠꠤ ꠞꠁꠛ, ꠎꠦ ꠐꠣꠃꠘꠅ ꠔꠣꠞꠣꠞ ꠝꠣꠟꠤꠇꠞꠦ ꠍꠟꠤꠛꠞ ꠃꠙꠞꠦ ꠟꠐꠇꠣꠁꠀ ꠈꠥꠘ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ꠁ ꠐꠣꠃꠘꠞ ꠘꠣꠝ ꠑꠤꠇ ꠍꠣꠖꠥꠝ ꠛꠣ ꠝꠤꠡꠞ ꠘꠣ ꠅꠁꠟꠦꠅ ꠄꠇꠁ ꠟꠣꠈꠣꠘꠃ ꠈꠣꠞꠣꠙ। ");
INSERT INTO syls_vpl VALUES ("RV11_9","096_11_9","REV","11","9","10","ꠢꠃ ꠡꠝꠄ ꠢꠇꠟ ꠖꠦꠡ, ꠈꠣꠘ꠆ꠖꠣꠘ, ꠢꠇꠟ ꠎꠣꠔꠞ ꠛꠥꠟꠤꠄ ꠝꠣꠔꠞꠣ ꠝꠣꠘꠡꠦ ꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠦ ꠡꠣꠠꠦ ꠔꠤꠘ ꠖꠤꠘ ꠗꠞꠤ ꠅꠃ ꠟꠣꠡꠉꠥꠁꠘ ꠖꠦꠈꠛꠣ। ꠀꠞ ꠄꠞꠣ ꠝꠣꠞꠣ ꠉꠦꠍꠂꠘ ꠇꠞꠤ ꠎꠉꠔꠞ ꠖꠥꠘꠤꠀꠛꠤ ꠝꠣꠘꠡꠦ ꠈꠥꠡꠤꠄ ꠚꠥꠞ꠆ꠔꠤ-ꠀꠝꠥꠖ ꠇꠞꠛꠣ, ꠄꠇꠦ-ꠅꠁꠘ꠆ꠘꠞꠦ ꠃꠙꠢꠣꠞ ꠖꠤꠛꠣ। ꠀꠞ ꠁ ꠟꠣꠡ ꠖꠣꠚꠘ ꠇꠞꠣꠞ ꠙꠣꠞꠝꠤꠡꠘ ꠖꠤꠔꠣ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠅꠃ ꠖꠥꠁꠅ ꠘꠛꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠘꠤꠀꠖꠣꠞꠤ ꠝꠣꠘꠡꠞ ꠇꠡ꠆ꠐ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV11_11","096_11_11","REV","11","11","11","ꠛꠣꠖꠦ ꠢꠃ ꠡꠣꠠꠦ ꠔꠤꠘ ꠖꠤꠘ ꠙꠣꠞ ꠅꠁꠀ ꠢꠣꠞꠟꠦ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠎꠣꠘ ꠄꠞꠣꠞ ꠜꠤꠔꠞꠦ ꠢꠣꠝꠣꠁꠟ, ꠔꠦꠃ ꠄꠞꠣ ꠙꠣꠅ-ꠅ ꠜꠞꠖꠤ ꠃꠛꠣꠁꠟꠣ। ꠀꠞ ꠎꠔ ꠎꠘꠦ ꠄꠞꠣꠞꠦ ꠖꠦꠈꠟꠣ, ꠢꠇꠟꠦꠃ ꠒꠞꠣꠁꠀ ꠇꠣꠙꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV11_12","096_11_12","REV","11","12","12","ꠛꠣꠖꠦ ꠄꠞꠣ ꠢꠥꠘꠟꠣ, ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠒꠣꠇꠤꠀ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠅꠀ ꠅꠞ, “ꠔꠥꠝꠞꠣ ꠅꠘꠅ ꠃꠑꠤꠀ ꠀꠁꠅ।” ꠔꠦꠃ ꠄꠞꠣ ꠘꠤꠎꠞ ꠖꠥꠡꠝꠘꠞ ꠍꠣꠝꠘꠦ ꠄꠇ ꠝꠦꠊꠞ ꠌꠣꠇꠣꠔ ꠅꠁꠀ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠉꠦꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RV11_13","096_11_13","REV","11","13","13","ꠅꠃ ꠡꠝꠄ ꠈꠥꠛ ꠛꠠ ꠜꠂꠍꠣꠟ ꠅꠁꠟ, ꠀꠞ ꠢꠤ ꠐꠣꠃꠘꠞ ꠖꠡ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠜꠣꠋꠉꠤ ꠉꠦꠟ। ꠜꠂꠍꠣꠟꠦ ꠡꠣꠔ ꠀꠎꠣꠞ ꠝꠣꠘꠥꠡ ꠝꠞꠟꠣ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠢꠇꠟꠦ ꠒꠞꠣꠁꠀ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠣꠔ ꠟꠣꠉꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV11_14","096_11_14","REV","11","14","14","ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠖꠥꠍꠞꠣ ꠉꠎꠛ ꠙꠣꠞ ꠅꠁꠟ, ꠅꠁꠟꠦ ꠢꠥꠘꠅ, ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠉꠎꠛ ꠈꠥꠛ ꠎꠟꠖꠤ ꠀꠁꠀ ꠀꠎꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("RV11_15","096_11_15","REV","11","15","15","ꠛꠣꠖꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠡꠤꠋꠉꠣ ꠚꠥꠇꠤꠟꠣ। ꠔꠦꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠄꠟꠣꠘ ꠇꠞꠣ ꠅꠁꠟ, “ꠅꠈꠘ ꠔ ꠖꠥꠘꠤꠀꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠝꠞꠣꠞ ꠝꠣꠛꠥꠖ ꠀꠞ ꠔꠣꠘ ꠝꠍꠤꠞ ꠢꠥꠇꠥꠝꠅ ꠀꠁꠍꠦ। ꠔꠣꠁꠘ ꠎꠥꠉ ꠎꠥꠉ ꠗꠞꠤ ꠌꠤꠞꠇꠣꠟ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠛꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV11_16","096_11_16","REV","11","16","16","ꠛꠣꠖꠦ ꠢꠃ ꠌꠛ꠆ꠛꠤꠡꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ, ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠍꠣꠝꠘꠦ ꠎꠣꠞꠎꠤꠞ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠄꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RV11_17","096_11_17","REV","11","17","17","“ꠅ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠤ ꠀꠉꠦꠅ ꠀꠍꠟꠣꠄ ꠀꠞ ꠅꠈꠘꠅ ꠀꠍ। ꠀꠝꠞꠣ ꠔꠥꠝꠣꠞ ꠡꠥꠇꠥꠞ-ꠉꠥꠎꠣꠞ ꠇꠞꠞꠣꠝ, ꠔꠥꠝꠤ ꠔ ꠔꠥꠝꠣꠞ ꠝꠢꠣ ꠈꠦꠝꠔꠣ ꠀꠔꠅ ꠟꠁꠀ ꠅꠈꠘ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV11_18","096_11_18","REV","11","18","18","ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠄ ꠉꠥꠍꠣ ꠇꠞꠤꠀ ꠌꠤꠟ꠆ꠟꠣꠁꠍꠦ, ꠔꠦ ꠅꠈꠘ ꠔꠥꠝꠣꠞ ꠉꠎꠛ ꠓꠣꠟꠤꠛꠣꠞ ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ। ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠛꠤꠌꠣꠞꠞ ꠡꠝꠄ ꠀꠁꠍꠦ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠀꠙꠘ ꠉꠥꠟꠣꠝ ꠘꠛꠤ ꠅꠇꠟꠞ, ꠔꠥꠝꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ, ꠢꠥꠞꠥ-ꠛꠠ ꠎꠔꠎꠘꠦ ꠔꠥꠝꠣꠞꠦ ꠒꠞꠣꠁꠘ, ꠔꠣꠞꠣꠞꠦ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠖꠤꠛꠣꠞ ꠡꠝꠄ ꠀꠁꠍꠦ। ꠀꠞ ꠎꠦꠞꠣ ꠖꠥꠘꠤꠀꠞ ꠈꠦꠔꠤ ꠇꠞꠍꠦ, ꠔꠣꠞꠣꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠞ ꠡꠝꠄꠅ ꠀꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV11_19","096_11_19","REV","11","19","19","ꠛꠣꠖꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠣ ꠅꠁꠟ, ꠀꠞ ꠄꠞ ꠜꠤꠔꠞꠦ ꠀꠟ꠆ꠟꠣꠁ ꠡꠣꠢꠣꠖꠔ ꠡꠘ꠆ꠖꠥꠇ ꠖꠦꠈꠣ ꠉꠦꠟ। ꠅꠃ ꠡꠝꠄ ꠝꠦꠊꠞ ꠎꠤꠟꠇꠣꠘꠤ, ꠉꠥꠠ-ꠉꠥꠠꠤ ꠒꠣꠇ, ꠑꠣꠐꠣ ꠙꠠꠣ, ꠜꠂꠍꠣꠟ ꠀꠞ ꠈꠥꠛ ꠛꠦꠡꠤ ꠢꠤꠟ-ꠝꠦꠊ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV12_1","096_12_1","REV","12","1","1","ꠛꠣꠖꠦ ꠀꠍꠝꠣꠘꠞ ꠝꠣꠎꠦ ꠄꠇ ꠇꠥꠖꠞꠔꠤ ꠇꠣꠞꠛꠣꠞ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠄꠇꠎꠘ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠀꠍꠂꠘ, ꠔꠣꠘ ꠚꠤꠘ꠆ꠘ ꠀꠍꠤꠟ ꠡꠥꠞꠥꠎ ꠀꠞ ꠙꠣꠅꠞ ꠔꠟꠦ ꠌꠣꠘ꠆ꠖ, ꠄꠘ ꠝꠣꠕꠣꠔ ꠀꠍꠦ ꠛꠣꠞꠅꠐꠣ ꠔꠦꠞꠣ ꠖꠤꠀ ꠉꠣꠕꠣ ꠄꠇꠐꠣ ꠔꠣꠎ। ");
INSERT INTO syls_vpl VALUES ("RV12_2","096_12_2","REV","12","2","2","ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠔꠣ, ꠄꠞꠟꠣꠉꠤ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠀꠞ ꠛꠦꠖꠘꠣꠄ ꠛꠦꠐꠤꠄ ꠈꠣꠟꠤ ꠌꠤꠟ꠆ꠟꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV12_3","096_12_3","REV","12","3","3","ꠄꠞꠛꠣꠖꠦ ꠀꠍꠝꠣꠘꠅ ꠀꠞꠇ ꠇꠣꠞꠛꠣꠞ ꠖꠦꠈꠣ ꠉꠦꠟ, ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ ꠟꠣꠟ ꠄꠇ ꠛꠤꠞꠣꠐ ꠖꠣꠘꠛ। ꠔꠣꠞ ꠡꠣꠔꠐꠣ ꠝꠣꠕꠣ ꠀꠞ ꠖꠡꠐꠣ ꠢꠤꠋ, ꠡꠣꠔꠅ ꠝꠣꠕꠣꠔ ꠡꠣꠔꠐꠣ ꠔꠣꠎ ꠟꠣꠉꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV12_4","096_12_4","REV","12","4","4","ꠔꠣꠞ ꠟꠦꠁꠘ꠆ꠎꠥꠠꠖꠤ ꠛꠣꠠꠤꠀꠁꠀ ꠀꠍꠝꠣꠘꠞ ꠔꠤꠘ ꠛꠣꠐꠞ ꠄꠇ ꠛꠣꠐ ꠔꠦꠞꠣꠞꠦ ꠖꠥꠘꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠤꠟ। ꠀꠞ ꠎꠦ ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠔꠣ, ꠅꠃ ꠖꠣꠘꠛ ꠀꠁꠀ ꠛꠦꠐꠤꠞ ꠍꠣꠝꠘꠦ ꠅꠃ ꠘꠝꠥꠘꠣꠄ ꠃꠛꠣꠔ ꠀꠍꠤꠟ ꠎꠦꠘ, ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠢꠥꠞꠥꠔ꠆ꠔꠣ ꠅꠁꠔꠦꠃ ꠢꠦ ꠈꠣꠁꠟꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("RV12_5","096_12_5","REV","12","5","5","ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠄꠇ ꠙꠥꠀ ꠙꠄꠖꠣ ꠅꠁꠟ, ꠅꠃ ꠙꠥꠀꠄ ꠢꠇ꠆ꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠟꠥꠀꠞ ꠟꠣꠑꠤ ꠖꠤꠀ ꠡꠣꠡꠘ ꠇꠞꠛꠣ। ꠅꠃ ꠢꠥꠞꠥꠔ꠆ꠔꠣꠞꠦ ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠔꠣꠘ ꠔꠈ꠆ꠔꠞ ꠉꠦꠍꠦ ꠌꠥ ꠝꠣꠞꠤ ꠔꠥꠟꠤꠀ ꠘꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV12_6","096_12_6","REV","12","6","6","ꠀꠞ ꠅꠃ ꠛꠦꠐꠤ ꠝꠣꠘꠥꠡ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠛꠣꠄ ꠜꠣꠉꠤꠀ ꠉꠦꠟꠣꠉꠤ। ꠀꠟ꠆ꠟꠣꠄ ꠢꠤ ꠝꠞꠥꠜꠥꠝꠤꠞ ꠝꠣꠎꠦ ꠛꠦꠐꠤꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘ ꠎꠣꠉꠣ ꠎꠥꠁꠔ ꠇꠞꠍꠤꠟꠣ, ꠄꠁꠘ ꠢꠘꠅ ꠄꠇ ꠀꠎꠣꠞ ꠖꠥꠁ-ꠡ ꠡꠣꠁꠐ ꠖꠤꠘ ꠟꠣꠟꠘ-ꠙꠣꠟꠘ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV12_7","096_12_7","REV","12","7","7","ꠛꠣꠖꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠅ ꠎꠥꠖ꠆ꠖ ꠟꠣꠉꠤꠉꠦꠟ। ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠝꠤꠇꠣꠁꠟ ꠀꠞ ꠔꠣꠘ ꠅꠗꠤꠘꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟꠦ ꠢꠃ ꠖꠣꠘꠛꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠟꠣ, ꠀꠞ ꠢꠃ ꠖꠣꠘꠛꠦꠅ ꠔꠣꠞ ꠌꠦꠟꠣ-ꠌꠣꠝꠌꠣꠞꠦ ꠟꠁꠀ ꠄꠞꠣꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("RV12_8","096_12_8","REV","12","8","8","ꠟꠣꠠꠣꠁꠔ ꠢꠤ ꠖꠣꠘꠛ ꠀꠞꠤꠉꠦꠟ, ꠀꠞ ꠔꠣꠞꠣꠞꠦ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠛꠣꠞ ꠇꠞꠤ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV12_9","096_12_9","REV","12","9","9","ꠢꠃ ꠖꠣꠘꠛꠞꠦ ꠀꠞ ꠔꠣꠞ ꠌꠦꠟꠣ-ꠌꠣꠝꠌꠣ ꠅꠇꠟꠞꠦ ꠖꠥꠘꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠅꠃ ꠖꠣꠘꠛ ꠅꠁꠟ ꠢꠃ ꠙꠥꠞꠣꠘꠣ ꠢꠣꠚ, ꠎꠦꠉꠥꠞ ꠘꠣꠝ ꠁꠛꠟꠤꠍ-ꠡꠄꠔꠣꠘ, ꠢꠦ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV12_10","096_12_10","REV","12","10","10","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠄꠇꠎꠘꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠞꠣ, “ꠅꠈꠘ ꠔ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠎꠣꠔ, ꠔꠣꠘ ꠛꠟ-ꠡꠇ꠆ꠔꠤ, ꠔꠣꠘ ꠛꠣꠖꠡꠣꠁ ꠀꠞ ꠔꠣꠘ ꠝꠍꠤꠞ ꠈꠦꠝꠔꠣ ꠀꠎꠤꠞ ꠅꠁꠉꠦꠍꠦ। ꠇꠣꠞꠘ ꠎꠦꠉꠤꠄ ꠀꠝꠞꠣꠞ ꠜꠣꠁꠀꠁꠘ꠆ꠔꠞꠦ ꠖꠥꠡꠤ ꠛꠣꠘꠣꠁꠔ, ꠔꠣꠞꠦ ꠔ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠢꠦ ꠖꠤꠘ-ꠞꠣꠁꠔ ꠢꠣꠝꠦꠡꠣ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠉꠦꠍꠦ ꠔꠣꠞꠣꠞ ꠘꠣꠝꠦ ꠘꠣꠟꠤꠡ ꠖꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("RV12_11","096_12_11","REV","12","11","11","ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠃ ꠀꠞ ꠎꠣꠞꠎꠤꠞ ꠔꠛꠟꠤꠉꠤ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤꠞ ꠛꠟꠦ ꠔꠣꠞꠣ ꠁꠛꠟꠤꠍꠞꠦ ꠀꠞꠣꠁꠍꠂꠘ। ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠇꠣꠄꠀꠞꠦ ꠛꠦꠡꠤ ꠝꠣꠄꠀ ꠘꠣ ꠇꠞꠤꠀ, ꠎꠣꠘ ꠖꠤꠔꠦꠅ ꠎꠥꠁꠔ ꠀꠍꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV12_12","096_12_12","REV","12","12","12","“ꠄꠞꠟꠣꠉꠤꠃ ꠅ ꠛꠦꠢꠦꠡ꠆ꠔ, ꠔꠥꠝꠤ ꠈꠥꠡꠤ ꠇꠞꠅ। ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔ ꠛꠣꠡꠤ, ꠔꠥꠝꠞꠣꠅ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ। ꠅꠁꠟꠦ ꠀꠚꠍꠥꠍ ꠖꠥꠘꠤꠀ ꠀꠞ ꠖꠞꠤꠀꠞ ꠟꠣꠉꠤ, ꠁꠛꠟꠤꠍ ꠔ ꠔꠣꠞꠣꠞ ꠉꠦꠍꠦ ꠟꠣꠝꠤꠉꠦꠍꠦ। ꠢꠦ ꠉꠥꠍꠣꠄ ꠚꠥꠡ-ꠚꠣꠡ ꠇꠞꠦꠞ, ꠢꠦ ꠔ ꠎꠣꠘꠦꠃ, ꠔꠣꠞ ꠡꠝꠄ ꠀꠞ ꠛꠦꠡꠤ ꠘꠣꠁ।” ");
INSERT INTO syls_vpl VALUES ("RV12_13","096_12_13","REV","12","13","13","ꠢꠃ ꠖꠣꠘꠛꠦ ꠎꠦꠛꠟꠣ ꠖꠦꠈꠟ ꠔꠣꠞꠦ ꠖꠥꠘꠤꠀꠔ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠖꠦꠈꠤꠀ ꠢꠃ ꠎꠦ ꠛꠦꠐꠤꠞ ꠊꠞꠅ ꠙꠥꠀ ꠙꠄꠖꠣ ꠅꠁꠍꠤꠟ, ꠢꠦ ꠅꠃ ꠛꠦꠐꠤꠞ ꠈꠞꠦ ꠟꠣꠉꠟ। ");
INSERT INTO syls_vpl VALUES ("RV12_14","096_12_14","REV","12","14","14","ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠛꠦꠐꠤꠞꠦ ꠈꠥꠛ ꠛꠠ ꠄꠇ ꠌꠤꠟ ꠙꠣꠈꠤꠞ ꠖꠥꠈꠣꠘ ꠒꠣꠈꠘꠣ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠛꠦꠐꠤꠄ ꠅꠃ ꠒꠣꠈꠘꠣꠖꠤ ꠃꠠꠣꠟ ꠖꠤꠀ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠘꠤꠎꠞ ꠎꠣꠉꠣꠔ ꠎꠣꠁꠔꠣ ꠙꠣꠞꠛꠣ। ꠢꠘꠅ ꠢꠃ ꠖꠣꠘꠛ-ꠢꠣꠚꠞ ꠌꠃꠈꠞ ꠀꠅꠠꠦ ꠡꠣꠠꠦ ꠔꠤꠘ ꠛꠍꠞ ꠔꠣꠘꠞꠦ ꠟꠣꠟꠘ-ꠙꠣꠟꠘ ꠇꠞꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV12_15","096_12_15","REV","12","15","15","ꠔꠦꠃ ꠢꠤ ꠢꠣꠚꠦ ꠔꠣꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠙꠣꠘꠤ ꠛꠣꠞ ꠇꠞꠤꠀ ꠄꠇ ꠉꠣꠋ ꠛꠣꠘꠣꠁꠟꠤꠟ, ꠉꠣꠋꠉꠞ ꠚꠥꠔꠦ ꠛꠦꠐꠤꠞꠦ ꠜꠣꠡꠣꠁ ꠘꠤꠔꠉꠤ ꠇꠞꠤ। ");
INSERT INTO syls_vpl VALUES ("RV12_16","096_12_16","REV","12","16","16","ꠅꠁꠟꠦ ꠖꠥꠘꠤꠀꠄ ꠛꠦꠐꠤꠞꠦ ꠡꠣꠁꠎ꠆ꠎ ꠇꠞꠟ, ꠁ ꠢꠣꠚꠦ ꠎꠦ ꠙꠣꠘꠤ ꠛꠣꠞ ꠇꠞꠟ, ꠖꠥꠘꠤꠀꠞ ꠝꠣꠐꠤꠄ ꠀ ꠇꠞꠤꠀ ꠁ ꠙꠣꠘꠤꠞꠦ ꠈꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV12_17","096_12_17","REV","12","17","17","ꠄꠞꠟꠣꠉꠤ ꠁ ꠖꠣꠘꠛ-ꠢꠣꠚꠦ ꠛꠦꠐꠤꠞ ꠛꠣꠄ ꠀꠞꠅ ꠛꠦꠡꠤ ꠉꠥꠍꠣ ꠇꠞꠟ, ꠢꠦ ꠛꠦꠐꠤꠞ ꠅꠁꠘ꠆ꠘ ꠀꠅꠟꠣꠖ ꠅꠇꠟꠞꠦ, ꠝꠣꠘꠤ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝꠦ ꠌꠟꠦ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠙꠇ꠆ꠇꠦ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠦꠄ, ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠔ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV12_18","096_12_18","REV","12","18","18","ꠉꠤꠀ ꠢꠦ ꠖꠞꠤꠀꠞ ꠌꠞꠞ ꠛꠣꠟꠥꠞ ꠃꠙꠞꠦ ꠃꠛꠣꠁ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV13_1","096_13_1","REV","13","1","1","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠖꠞꠤꠀ ꠕꠣꠇꠤ ꠄꠇ ꠎꠣꠘꠥꠀꠞ ꠃꠑꠦꠞ, ꠔꠣꠞ ꠖꠡꠉꠥ ꠢꠤꠋ, ꠡꠣꠔꠉꠥ ꠇꠟ꠆ꠟꠣ, ꠙꠞꠔꠦꠇ ꠢꠤꠋꠉꠞ ꠝꠣꠕꠣꠔ ꠄꠇꠐꠣ ꠇꠞꠤ ꠔꠣꠎ, ꠀꠞ ꠙꠞꠔꠦꠇ ꠇꠟ꠆ꠟꠣꠞ ꠃꠙꠞꠦ ꠘꠣꠘꠣꠘ ꠇꠥꠚꠥꠞꠤ ꠘꠣꠝ ꠟꠦꠈꠣ। ");
INSERT INTO syls_vpl VALUES ("RV13_2","096_13_2","REV","13","2","2","ꠁ ꠎꠣꠘꠥꠀꠞꠉꠥ ꠖꠦꠈꠔꠦ ꠌꠤꠔꠣꠛꠣꠊꠞ ꠟꠣꠈꠣꠘ, ꠔꠣꠞ ꠙꠣꠅ ꠅꠁꠟ ꠜꠣꠟ꠆ꠟꠥꠇꠞ ꠙꠣꠅꠞ ꠟꠣꠈꠣꠘ, ꠀꠞ ꠝꠥꠈ ꠅꠁꠟ ꠡꠤꠋꠢꠞ ꠝꠥꠈꠞ ꠟꠣꠈꠣꠘ। ꠢꠃ ꠖꠣꠘꠛꠦ ꠔꠣꠞ ꠡꠇ꠆ꠔꠤ, ꠔꠣꠞ ꠉꠖꠤ ꠀꠞ ꠝꠢꠣ ꠈꠦꠝꠔꠣ ꠅꠃ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠖꠤꠟꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV13_3","096_13_3","REV","13","3","3","ꠁ ꠎꠣꠘꠥꠀꠞꠞ ꠄꠇꠐꠣ ꠇꠟ꠆ꠟꠣꠞ ꠝꠣꠎꠦ ꠅꠝꠘ ꠄꠇ ꠎꠈꠝ ꠀꠍꠤꠟ, ꠅꠃ ꠎꠈꠝꠦ ꠢꠦ ꠝꠞꠣꠞ ꠟꠣꠈ ꠅꠁꠉꠦꠍꠤꠟ, ꠅꠁꠟꠦ ꠎꠈꠝꠐꠣ ꠜꠣꠟꠣ ꠅꠁꠉꠦꠟ। ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠥꠡ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠛꠘꠤꠀ ꠔꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV13_4","096_13_4","REV","13","4","4","ꠀꠞ ꠢꠃ ꠖꠣꠘꠛꠦ ꠔꠣꠞꠦ ꠁ ꠈꠦꠝꠔꠣ ꠖꠤꠍꠤꠟ ꠇꠞꠤ ꠝꠣꠘꠡꠦ ꠢꠃ ꠖꠣꠘꠛꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠟ, ꠄꠞꠟꠉꠦ ꠅꠃ ꠎꠣꠘꠥꠀꠞꠞꠦꠅ ꠍꠁꠎꠖꠣ ꠇꠞꠟ। ꠔꠣꠞꠣ ꠇꠁꠟ, “ꠁ ꠎꠣꠘꠥꠀꠞꠞ ꠟꠣꠈꠣꠘ ꠀꠞ ꠇꠦ ꠀꠍꠦ? ꠔꠣꠞ ꠟꠉꠦ ꠟꠣꠠꠣꠁ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠇꠣꠞ ꠀꠍꠦ?” ");
INSERT INTO syls_vpl VALUES ("RV13_5","096_13_5","REV","13","5","5","ꠁ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠇꠥꠚꠥꠞꠤ ꠛꠥꠟꠤ ꠀꠞ ꠛꠦꠐꠣꠉꠤꠞꠤ ꠝꠣꠔꠞ ꠝꠥꠈ ꠖꠦꠅꠀ ꠅꠁꠟ। ꠛꠦꠀꠟ꠆ꠟꠤꠡ ꠝꠣꠡ ꠗꠞꠤ ꠔꠣꠞ ꠇꠣꠝ ꠌꠣꠟꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV13_6","096_13_6","REV","13","6","6","ꠄꠞꠟꠣꠉꠤ ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠟ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠘꠣꠝ, ꠔꠣꠘ ꠛꠡꠔ ꠈꠣꠘꠣ ꠀꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠛꠣꠡꠤ ꠅꠇꠟꠞ ꠛꠖꠘꠣꠝ ꠇꠞꠣꠔ ꠞꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV13_7","096_13_7","REV","13","7","7","ꠔꠣꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠢꠦ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠤꠀ ꠎꠤꠔꠤꠔ ꠙꠣꠞꠛ। ꠀꠞ ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠙꠞꠔꠦꠇ ꠖꠦꠡ, ꠙꠞꠔꠦꠇ ꠎꠣꠔꠤ, ꠙꠞꠔꠦꠇ ꠘꠝꠥꠘꠣꠞ ꠛꠥꠟꠤꠄ ꠝꠣꠔꠞꠣ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦꠅ ꠔꠣꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV13_8","096_13_8","REV","13","8","8","ꠁꠔꠣ ꠖꠦꠈꠤꠀ ꠖꠥꠘꠤꠀꠛꠤ ꠢꠇꠟ ꠝꠣꠘꠡꠦ ꠔꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠛ। ꠎꠉꠔ ꠙꠄꠖꠣ ꠇꠞꠣꠞ ꠀꠉꠦ ꠎꠦ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞꠦ ꠎꠛ ꠇꠞꠣꠞ ꠇꠕꠣ ꠡꠣꠁꠛꠡ꠆ꠔ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠢꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠣꠔꠣꠔ ꠎꠦꠞꠣꠞ ꠘꠣꠝ ꠘꠣꠁ, ꠄꠞꠣ ꠙꠞꠔꠦꠇꠦ ꠔꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠛ। ");
INSERT INTO syls_vpl VALUES ("RV13_9","096_13_9","REV","13","9","9","ꠎꠣꠞ ꠇꠣꠘ ꠀꠍꠦ, ꠢꠦ ꠢꠥꠘꠃꠇ: ");
INSERT INTO syls_vpl VALUES ("RV13_10","096_13_10","REV","13","10","10","ꠎꠦ ꠎꠘ ꠛꠘ꠆ꠖꠤ ꠅꠀꠞ ꠇꠕꠣ, ꠢꠦ ꠔ ꠛꠘ꠆ꠖꠤ ꠅꠁꠛꠃ। ꠔꠟꠥꠀꠞꠞ ꠔꠟꠦ ꠎꠣꠞ ꠈꠥꠘ ꠅꠀꠞ ꠇꠕꠣ, ꠢꠦ ꠅꠟꠣ ꠈꠥꠘ ꠅꠁꠛ। ꠄꠞꠟꠣꠉꠤ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠦ ꠝꠎꠛꠥꠔ ꠁꠝꠣꠘ ꠀꠞ ꠍꠛꠞ ꠇꠞꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("RV13_11","096_13_11","REV","13","11","11","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠎꠝꠤꠘ ꠕꠣꠇꠤ ꠀꠞꠇꠐꠣ ꠎꠣꠘꠥꠀꠞ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟ। ꠝꠦꠠꠣꠞ ꠢꠤꠋꠉꠞ ꠟꠣꠈꠣꠘ ꠔꠣꠞ ꠖꠥꠁ ꠢꠤꠋ ꠀꠍꠦ, ꠅꠁꠟꠦ ꠢꠦ ꠝꠣꠔꠤꠔ ꠢꠃ ꠖꠣꠘꠛꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV13_12","096_13_12","REV","13","12","12","ꠅꠃ ꠝꠦꠠꠣꠞ ꠢꠤꠋ ꠀꠟꠣ ꠎꠣꠘꠥꠀꠞꠦ ꠢꠃ ꠙꠄꠟꠣ ꠎꠣꠘꠥꠀꠞꠞ ꠢꠇꠟ ꠈꠦꠝꠔꠣ ꠛꠦꠛꠢꠣꠞ ꠇꠞꠔ। ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠝꠣꠘꠡꠞꠦ ꠢꠦ ꠎꠥꠞ ꠇꠞꠤꠀ ꠢꠃ ꠎꠈꠝ ꠜꠣꠟꠣ ꠅꠀ ꠙꠄꠟꠣ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("RV13_13","096_13_13","REV","13","13","13","ꠢꠦ ꠢꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠛꠠ ꠛꠠ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠇꠞꠔ, ꠄꠝꠘꠇꠤ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠎꠝꠤꠘꠅ ꠀꠉꠥꠁꠘ ꠟꠣꠝꠣꠁꠀ ꠖꠦꠈꠣꠁꠔ। ");
INSERT INTO syls_vpl VALUES ("RV13_14","096_13_14","REV","13","14","14","ꠢꠃ ꠙꠄꠟꠣ ꠎꠣꠘꠥꠀꠞꠞ ꠟꠣꠉꠤ ꠎꠔ ꠟꠣꠈꠣꠘ ꠇꠦꠞꠣꠝꠔꠤ ꠖꠦꠈꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠔꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠍꠤꠟ, ꠅꠔꠣ ꠖꠦꠈꠣꠁꠀ ꠢꠦ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠟ। ꠙꠄꠟꠣ ꠎꠦ ꠎꠣꠘꠥꠀꠞ ꠔꠟꠥꠀꠞꠞ ꠍꠦꠖ ꠈꠣꠁꠀꠅ ꠛꠣꠌꠤ ꠉꠦꠍꠤꠟ, ꠔꠣꠞ ꠄꠇꠐꠣ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣꠘꠣꠘꠤꠞ ꠟꠣꠉꠤ ꠖꠥꠍꠞꠣ ꠎꠣꠘꠥꠀꠞꠦ ꠝꠣꠘꠡꠞꠦ ꠙꠞꠣꠝꠤꠡ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV13_15","096_13_15","REV","13","15","15","ꠀꠞ ꠝꠥꠞ꠆ꠔꠤꠞ ꠜꠤꠔꠞꠦ ꠎꠣꠘ ꠢꠣꠞꠣꠘꠤꠞ ꠈꠦꠝꠔꠣ ꠔꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠎꠣꠔꠦ ꠁ ꠝꠥꠞ꠆ꠔꠤꠄ ꠝꠣꠔꠤꠔ ꠙꠣꠞꠦ, ꠀꠞ ꠎꠦꠞꠣ ꠁ ꠝꠥꠞ꠆ꠔꠤꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠔ ꠘꠣꠄ, ꠔꠣꠞꠣꠞꠦ ꠎꠣꠘꠦ ꠝꠣꠞꠣꠞ ꠈꠦꠝꠔꠣꠅ ꠔꠣꠞꠦ ꠖꠦꠅꠀ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV13_16","096_13_16","REV","13","16","16","ꠢꠦ ꠢꠥꠞꠥ-ꠛꠠ, ꠗꠘꠤ-ꠉꠞꠤꠛ, ꠝꠥꠘꠤꠛ ꠛꠣ ꠉꠥꠟꠣꠝ ꠢꠇꠟꠞꠦ ꠛꠣꠁꠖ꠆ꠖ ꠇꠞꠟ, ꠎꠣꠞꠎꠤꠞ ꠒꠣꠁꠘ ꠀꠔꠅ ꠛꠣ ꠇꠙꠣꠟꠞ ꠃꠙꠞꠦ ꠄꠇꠐꠣ ꠡꠤꠟ ꠝꠣꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RV13_17","096_13_17","REV","13","17","17","ꠄꠞꠟꠣꠉꠤ ꠅꠃ ꠡꠤꠟ ꠍꠣꠠꠣ ꠇꠦꠃ ꠇꠥꠘꠥ ꠌꠤꠎ ꠈꠞꠤꠖ-ꠛꠤꠇꠤꠞ ꠃꠙꠣꠄ ꠞꠁꠟ ꠘꠣ। ꠁ ꠡꠤꠟ ꠀꠍꠤꠟ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞ ꠘꠣꠝ ꠛꠣ ꠘꠣꠝꠞ ꠝꠣꠞ꠆ꠇꠣ ꠘꠝ꠆ꠛꠞ। ");
INSERT INTO syls_vpl VALUES ("RV13_18","096_13_18","REV","13","18","18","ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠛꠥꠎꠔꠦ ꠛꠃꠔ ꠀꠈꠟꠞ ꠖꠞꠇꠣꠞ। ꠎꠣꠞ ꠀꠈꠟ ꠀꠍꠦ ꠢꠦ ꠅꠃ ꠎꠣꠘꠥꠀꠞꠞ ꠘꠣꠝꠞ ꠢꠞꠚꠞ ꠘꠝ꠆ꠛꠞ ꠉꠘꠃꠇ, ꠁꠔꠣ ꠔ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠞ ꠘꠣꠝꠞ ꠘꠝ꠆ꠛꠞ। ꠄꠞ ꠙꠞꠤꠝꠣꠘ ꠅꠁꠟ, ৬৬৬; ꠍꠄ-ꠡ ꠍꠄꠡꠐ꠆ꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("RV14_1","096_14_1","REV","14","1","1","ꠛꠣꠖꠦ ꠀꠝꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠤ, ꠢꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠎꠦꠞꠥꠎꠣꠟꠦꠝꠞ ꠙꠛꠤꠔ꠆ꠞ ꠍꠤꠅꠘ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠔꠣꠘ ꠟꠉꠦ ꠀꠍꠂꠘ ꠄꠇ ꠟꠣꠈ ꠌꠃꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠝꠣꠘꠥꠡ। ꠔꠣꠞꠣꠞ ꠇꠙꠣꠟꠞ ꠃꠙꠞꠦ ꠅꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠀꠞ ꠔꠣꠘ ꠉꠣꠁꠛꠤ ꠛꠣꠚꠞ ꠘꠣꠝ ꠟꠦꠈꠣ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV14_2","096_14_2","REV","14","2","2","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠟ-ꠇꠟꠣꠁꠀ ꠎꠣꠅꠀ ꠙꠣꠘꠤꠞ ꠚꠥꠔꠞ ꠀꠅꠀꠎ ꠀꠞ ꠎꠥꠞꠦ ꠑꠣꠐꠣ ꠙꠠꠣꠞ ꠡꠛ꠆ꠖꠞ ꠟꠣꠈꠣꠘ ꠄꠇ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ। ꠀꠝꠣꠞ ꠝꠘꠅ ꠅꠁꠟ, ꠇꠥꠘꠥ ꠡꠣꠞꠤꠘ꠆ꠖꠣ ꠛꠣꠎꠣꠅꠞꠣ ꠖꠟꠦ ꠡꠣꠞꠤꠘ꠆ꠖꠣ ꠛꠣꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV14_3","096_14_3","REV","14","3","3","ꠄꠞꠣ ꠢꠃ ꠔꠈ꠆ꠔ, ꠢꠃ ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞ ꠀꠞ ꠢꠃ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣ ꠅꠇꠟꠞ ꠍꠣꠝꠘꠦ ꠄꠇ ꠘꠄꠀ ꠉꠎꠟ ꠉꠣꠁꠞꠣ। ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠁ ꠉꠎꠟ ꠢꠤꠇꠔ ꠙꠣꠞꠟ ꠘꠣ, ꠈꠣꠟꠤ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠤ ꠘꠦꠅꠀ ꠅꠃ ꠄꠇ ꠟꠣꠈ ꠌꠃꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠎꠣꠞ ꠎꠘ ꠍꠣꠠꠣ। ");
INSERT INTO syls_vpl VALUES ("RV14_4","096_14_4","REV","14","4","4","ꠄꠞꠣ ꠔ ꠢꠃ ꠝꠣꠘꠥꠡ, ꠎꠦꠞꠣ ꠇꠥꠘꠥ ꠛꠦꠐꠤꠘ꠆ꠔꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠤꠀ ꠘꠤꠎꠞ ꠇꠣꠄꠀꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠍꠦ ꠘꠣ। ꠅꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣ ꠎꠦ ꠎꠣꠉꠣꠔ ꠎꠣꠁꠘ, ꠔꠣꠞꠣꠅ ꠄꠘ ꠈꠞꠦ ꠈꠞꠦ ꠞꠂꠘ। ꠀꠟ꠆ꠟꠣ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠘꠣꠝꠦ ꠈꠦꠔꠞ ꠙꠄꠟꠣ ꠚꠡꠟ ꠢꠤꠡꠣꠛꠦ ꠄꠞꠣꠞꠦ ꠎꠉꠔꠞ ꠝꠣꠘꠡꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠇꠞꠣ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV14_5","096_14_5","REV","14","5","5","ꠄꠞꠣ ꠇꠥꠘꠥꠖꠤꠘꠅ ꠝꠤꠍꠣ ꠝꠣꠔ ꠝꠣꠔꠤꠍꠂꠘ ꠘꠣ, ꠄꠞꠣ ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠘꠤꠈꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("RV14_6","096_14_6","REV","14","6","6","ꠛꠣꠖꠦ ꠀꠝꠤ ꠀꠞꠇ ꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠖꠦꠈꠟꠣꠝ, ꠄꠁꠘ ꠀꠍꠝꠣꠘꠞ ꠝꠣꠎꠦꠖꠤ ꠃꠠꠤꠞꠣ। ꠖꠥꠘꠤꠀꠔ ꠛꠡꠔ ꠇꠞꠞꠣ ꠙꠞꠔꠦꠇ ꠖꠦꠡ, ꠙꠞꠔꠦꠇ ꠈꠣꠘ꠆ꠖꠣꠘ, ꠙꠞꠔꠦꠇ ꠜꠣꠡꠣꠄ ꠝꠣꠔꠞꠣ ꠀꠞ ꠙꠞꠔꠦꠇ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞ ꠟꠣꠉꠤ ꠌꠤꠞꠇꠣꠟꠤꠘ ꠈꠥꠡꠤꠞ ꠈꠛꠞ ꠔꠣꠘ ꠉꠦꠍꠦ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV14_7","096_14_7","REV","14","7","7","ꠔꠣꠁꠘ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠄꠟꠣꠘ ꠇꠞꠟꠣ, “ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠒꠞꠣꠅ, ꠔꠣꠘ ꠁꠎ꠆ꠎꠔ-ꠔꠣꠞꠤꠚ ꠇꠞꠅ, ꠔꠣꠘ ꠛꠤꠌꠣꠞꠞ ꠡꠝꠄ ꠀꠁꠌ꠆ꠍꠦ। ꠎꠦꠁꠘ ꠀꠍꠝꠣꠘ-ꠎꠝꠤꠘ, ꠖꠞꠤꠀ ꠀꠞ ꠈꠣꠟ-ꠛꠤꠟ, ꠉꠣꠋ ꠅꠇꠟ ꠙꠄꠖꠣ ꠇꠞꠍꠂꠘ, ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV14_8","096_14_8","REV","14","8","8","ꠛꠣꠖꠦ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠖꠥꠍꠞꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ, ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ, ꠢꠃ ꠘꠣꠝꠇꠞꠣ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ। ꠎꠦ ꠐꠣꠃꠘꠦ ꠔꠣꠁꠞ ꠎꠤꠘꠣꠞ ꠇꠣꠝꠞ ꠇꠠꠣ ꠘꠤꠡꠣ-ꠙꠣꠘꠤ ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠈꠣꠅꠀꠁꠍꠦ, ꠔꠣꠁ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ।” ");
INSERT INTO syls_vpl VALUES ("RV14_9","096_14_9","REV","14","9","9","ꠛꠣꠖꠦ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠄꠞꠣꠞ ꠈꠞꠦ ꠈꠞꠦ ꠀꠁꠀ ꠎꠥꠞ ꠉꠟꠣꠄ ꠇꠁꠟꠣ, “ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠎꠥꠖꠤ ꠅꠃ ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠅꠉꠥꠞ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠦ, ꠅꠉꠥꠞ ꠡꠤꠟ ꠔꠣꠞ ꠀꠔꠅ ꠛꠣ ꠇꠙꠣꠟꠅ ꠟꠣꠉꠣꠄ, ");
INSERT INTO syls_vpl VALUES ("RV14_10","096_14_10","REV","14","10","10","ꠔꠦ ꠢꠦ-ꠅ ꠀꠟ꠆ꠟꠣꠁ ꠉꠎꠛꠤ ꠘꠤꠡꠣ-ꠙꠣꠘꠤ ꠈꠣꠁꠔꠦ ꠅꠁꠛ। ꠅꠃ ꠘꠤꠡꠣꠞ ꠟꠉꠦ ꠇꠥꠘꠥꠎꠣꠔ ꠙꠣꠘꠤ ꠘꠣ ꠝꠤꠡꠣꠁꠀ ꠀꠟ꠆ꠟꠣꠁ ꠉꠎꠛꠤ ꠛꠣꠐꠤꠔ ꠜꠞꠣ ꠅꠁꠍꠦ। ꠙꠛꠤꠔ꠆ꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠅꠇꠟ ꠀꠞ ꠀꠟ꠆ꠟꠣꠁ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠍꠣꠝꠘꠦ, ꠀꠉꠥꠁꠘ ꠀꠞ ꠉꠘ꠆ꠖꠇ ꠖꠤꠀ ꠁ ꠝꠣꠘꠡꠞꠦ ꠡꠣꠎꠣ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV14_11","096_14_11","REV","14","11","11","ꠎꠦ ꠀꠉꠥꠘꠤꠔ ꠁꠔꠣꠞꠦ ꠎꠣꠟꠣꠁꠟ ꠅꠁꠛ, ꠁ ꠀꠉꠥꠘꠤꠞ ꠗꠥꠝꠣ ꠇꠥꠘꠥꠖꠤꠘ ꠛꠘ꠆ꠖ ꠅꠁꠔ ꠘꠣꠄ। ꠎꠦ ꠝꠣꠘꠡꠦ ꠅꠃ ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠛ, ꠅꠉꠥꠞ ꠘꠣꠝꠞ ꠢꠃ ꠡꠤꠟ ꠟꠣꠉꠣꠁꠛ, ꠢꠦ ꠖꠤꠘ-ꠞꠣꠁꠔ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠀꠎꠣꠛ ꠕꠣꠇꠤ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("RV14_12","096_14_12","REV","14","12","12","ꠄꠞꠟꠣꠉꠤ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠢꠥꠇꠥꠝ ꠝꠣꠘꠦ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠔꠞꠤꠇꠣꠞ ꠁꠝꠣꠘꠦ ꠝꠎꠛꠥꠔ ꠞꠄ, ꠀꠟ꠆ꠟꠣꠞ ꠅꠃ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠦ ꠁ ꠢꠣꠟꠔꠞ ꠝꠣꠎꠦ ꠍꠛꠞ ꠕꠣꠇꠣ ꠎꠞꠥꠞ। ");
INSERT INTO syls_vpl VALUES ("RV14_13","096_14_13","REV","14","13","13","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠄꠇꠎꠘꠦ ꠇꠁꠞꠣ, “ꠅꠃ ꠀꠄꠀꠔ ꠟꠦꠈꠅ, ꠅꠈꠘ ꠕꠣꠇꠤ ꠝꠣꠟꠤꠇꠞ ꠔꠞꠤꠇꠣꠔ ꠞꠁꠀ ꠎꠔ ꠎꠘꠞ ꠎꠣꠘ ꠎꠣꠁꠛ, ꠄꠞꠣꠃ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ।” ꠙꠣꠇ ꠞꠥꠢꠦ ꠅꠃ ꠡꠣꠇ꠆ꠇꠤ ꠖꠤꠞꠣ, “ꠘꠤꠌ꠆ꠌꠄ ꠄꠞꠣꠃ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ। ꠔꠣꠞꠣꠞ ꠇꠣꠝ-ꠇꠣꠎ ꠕꠣꠇꠤ ꠔꠣꠞꠣ ꠞꠦꠢꠣꠁ ꠙꠣꠁꠛꠣ, ꠇꠣꠞꠘ ꠔꠣꠞꠣꠞ ꠇꠣꠝꠞ ꠚꠟ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠟꠉꠦ ꠞꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("RV14_14","096_14_14","REV","14","14","14","ꠛꠣꠖꠦ ꠀꠝꠤ ꠌꠣꠁꠀ ꠖꠦꠈꠟꠣꠝ, ꠗꠟꠣ ꠄꠇ ꠝꠦꠊꠞ ꠌꠣꠇꠣ, ꠅꠃ ꠌꠣꠇꠣꠞ ꠃꠙꠞꠦ ꠛꠤꠘ-ꠀꠖꠝꠞ ꠟꠣꠈꠣꠘ ꠇꠦꠃ ꠄꠇꠎꠘ ꠛꠅꠀꠔ ꠀꠍꠂꠘ। ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠡꠥꠘꠣꠞ ꠔꠣꠎ ꠀꠞ ꠀꠔꠅ ꠀꠍꠤꠟ ꠗꠣꠞꠣꠁꠟ ꠇꠣꠌꠤ। ");
INSERT INTO syls_vpl VALUES ("RV14_15","096_14_15","REV","14","15","15","ꠛꠣꠖꠦ ꠀꠞꠇ ꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ, ꠀꠞ ꠎꠦꠁꠘ ꠝꠦꠊꠞ ꠃꠙꠞꠦ ꠛꠅꠀꠔ ꠀꠍꠟꠣ ꠔꠣꠘꠞꠦ ꠎꠥꠞꠦ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠖꠥꠘꠤꠀꠞ ꠚꠡꠟ ꠇꠣꠐꠤꠛꠣꠞ ꠡꠝꠄ ꠅꠁꠍꠦ, ꠚꠡꠟ ꠙꠥꠞꠣꠙꠥꠞ ꠙꠣꠇꠤ ꠉꠦꠍꠦ, ꠀꠙꠘꠣꠞ ꠇꠣꠌꠤ ꠟꠣꠉꠣꠃꠇ꠆ꠇꠣ ꠀꠞ ꠚꠡꠟ ꠇꠣꠐꠃꠇ꠆ꠇꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV14_16","096_14_16","REV","14","16","16","ꠔꠦꠃ ꠅꠃ ꠝꠦꠊꠞ ꠌꠣꠇꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠁꠘ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠄꠁꠘ ꠖꠥꠘꠤꠀꠔ ꠔꠣꠘ ꠇꠣꠌꠤ ꠟꠣꠉꠣꠁꠟꠣ ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠚꠡꠟ ꠇꠣꠐꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV14_17","096_14_17","REV","14","17","17","ꠛꠣꠖꠦ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠀꠞꠇ ꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ, ꠔꠣꠘ ꠉꠦꠍꠦꠅ ꠄꠇꠈꠣꠘ ꠗꠣꠞꠣꠁꠟ ꠇꠣꠌꠤ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV14_18","096_14_18","REV","14","18","18","ꠄꠞꠛꠣꠖꠦ ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ, ꠔꠣꠘ ꠈꠦꠝꠔꠣ ꠀꠍꠤꠟ ꠀꠉꠥꠘꠤꠞ ꠃꠙꠞꠦ। ꠀꠁꠀ ꠔꠣꠁꠘ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠢꠃ ꠇꠣꠌꠤꠀꠟꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, “ꠔꠥꠝꠣꠞ ꠗꠣꠞꠣꠁꠟ ꠇꠣꠌꠤꠈꠣꠘ ꠟꠣꠉꠣꠅ ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠀꠋꠉꠥꠞ ꠉꠣꠍ ꠕꠣꠇꠤ ꠀꠋꠉꠥꠞꠞ ꠍꠠꠤꠘ ꠇꠣꠐꠤꠀ ꠖꠟꠣ ꠇꠞꠅ, ꠁꠔꠣ ꠔ ꠙꠣꠇꠤ ꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV14_19","096_14_19","REV","14","19","19","ꠔꠦꠃ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠖꠥꠘꠤꠀꠔ ꠔꠣꠘ ꠇꠣꠌꠤ ꠟꠣꠉꠣꠁꠟꠣ ꠀꠞ ꠖꠥꠘꠤꠀꠞ ꠀꠋꠉꠥꠞ ꠉꠣꠍꠞ ꠢꠇꠟ ꠀꠋꠉꠥꠞ ꠖꠟꠣ ꠇꠞꠤꠀ, ꠀꠋꠉꠥꠞ ꠝꠣꠠꠣꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁꠟꠣ। ꠅꠃ ꠉꠣꠔ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛꠞ ꠝꠢꠣ ꠉꠣꠔ। ");
INSERT INTO syls_vpl VALUES ("RV14_20","096_14_20","REV","14","20","20","ꠐꠣꠃꠘꠞ ꠛꠣꠞꠦ ꠀꠋꠉꠥꠞ ꠝꠣꠠꠣꠞ ꠉꠣꠔꠅ ꠁ ꠀꠋꠉꠥꠞ ꠝꠣꠠꠤꠀ ꠢꠣꠞꠟꠦ, ꠁꠔꠣ ꠕꠣꠇꠤ ꠟꠃ ꠛꠣꠞ ꠅꠁꠟ, ꠁ ꠟꠃꠞ ꠛꠁꠘ꠆ꠘꠣꠄ ꠊꠥꠠꠣꠁꠘ꠆ꠔꠞ ꠟꠣꠉꠣꠝ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠀꠁꠀ ꠍꠁꠟ। ꠟꠃꠄ ꠄꠇ ꠀꠎꠣꠞ ꠍꠄ-ꠡ ꠡ꠆ꠔꠣꠖꠤꠀ (ꠅꠘꠥꠝꠣꠘ ꠖꠥꠁ-ꠡ ꠝꠣꠁꠟ) ꠎꠣꠉꠣ ꠒꠥꠛꠤ ꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV15_1","096_15_1","REV","15","1","1","ꠛꠣꠖꠦ ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠀꠞꠇꠐꠣ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠖꠦꠈꠟꠣꠝ, ꠁꠐꠣ ꠛꠠ ꠝꠢꠣꠘ ꠔꠣꠁꠎ꠆ꠎꠥꠛꠤ। ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠡꠣꠔꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠍꠂꠘ, ꠄꠞꠣꠞ ꠀꠔꠅ ꠀꠈꠦꠞꠤ ꠡꠣꠔꠐꠣ ꠉꠎꠛ। ꠁꠔꠣꠞꠦ ꠀꠈꠦꠞꠤ ꠉꠎꠛ ꠇꠅꠀꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠅꠉꠥꠁꠘ ꠖꠤꠀ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠥꠍꠣꠞ ꠡꠦꠡ ꠚꠄꠍꠣꠟꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV15_2","096_15_2","REV","15","2","2","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠀꠉꠥꠁꠘ ꠀꠟꠣ ꠄꠇ ꠇꠣꠌꠞ ꠖꠞꠤꠀ, ꠀꠞ ꠎꠔ ꠝꠣꠘꠡꠦ ꠢꠃ ꠎꠣꠘꠥꠀꠞ, ꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤ ꠛꠣ ꠔꠣꠞ ꠘꠣꠝꠞ ꠘꠝ꠆ꠛꠞꠞ ꠃꠙꠞꠦ ꠎꠤꠔꠍꠂꠘ, ꠔꠣꠞꠣꠞꠦꠅ ꠖꠦꠈꠟꠣꠝ। ꠖꠦꠈꠟꠣꠝ, ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠖꠦꠅꠀ ꠡꠣꠞꠤꠘ꠆ꠖꠣ ꠀꠔꠅ ꠟꠁꠀ ꠇꠣꠌꠞ ꠖꠞꠤꠀꠞ ꠙꠣꠞꠅ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV15_3","096_15_3","REV","15","3","3","ꠔꠣꠞꠣ ꠀꠟ꠆ꠟꠣꠞ ꠛꠘ꠆ꠖꠣ ꠝꠥꠍꠣ ꠘꠛꠤꠞ ꠀꠞ ꠢꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠅꠃ ꠇꠣꠅꠀꠟꠤ ꠉꠣꠁꠞꠣ, “ꠅ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠟꠤꠟꠣ-ꠈꠦꠟꠣ ꠇꠔ ꠝꠢꠣꠘ ꠀꠞ ꠀꠌꠣꠘꠇ! ꠅ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠛꠣꠖꠡꠣ, ꠇꠔ ꠢꠇ ꠀꠞ ꠡꠑꠤꠇ ꠔꠥꠝꠣꠞ ꠙꠕ! ");
INSERT INTO syls_vpl VALUES ("RV15_4","096_15_4","REV","15","4","4","ꠅ ꠝꠣꠛꠥꠖ, ꠔꠥꠝꠣꠞꠦ ꠒꠞꠣꠁꠔ ꠘꠣꠄ ꠇꠥꠘ ꠎꠘꠦ? ꠇꠥꠘ ꠎꠘꠦ ꠔꠥꠝꠣꠞ ꠘꠣꠝꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠔ ꠘꠣꠄ? ꠈꠣꠟꠤ ꠔꠥꠝꠤꠃ ꠔ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ, ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠃ ꠀꠁꠛ ꠔꠥꠝꠣꠞ ꠖꠞꠛꠣꠞꠅ, ꠢꠇ꠆ꠇꠟꠦꠃ ꠔꠥꠝꠣꠞ ꠄꠛꠣꠖꠔ ꠇꠞꠛ, ꠔꠥꠝꠣꠞ ꠢꠇ ꠛꠤꠌꠣꠞ ꠔ ꠎꠣꠁꠞ ꠅꠁꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV15_5","096_15_5","REV","15","5","5","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠢꠃ ꠡꠣꠢꠣꠖꠔ ꠔꠣꠝ꠆ꠛꠥꠞ ꠜꠤꠔꠞꠞ ꠙꠛꠤꠔ꠆ꠞ ꠇꠣꠛꠣ ꠊꠞꠈꠣꠘ ꠈꠥꠟꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV15_6","096_15_6","REV","15","6","6","ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠡꠣꠔꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠡꠣꠔꠐꠣ ꠉꠎꠛ ꠟꠁꠀ ꠇꠣꠛꠣ ꠊꠞ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟꠣ। ꠔꠣꠞꠣꠞ ꠚꠤꠘ꠆ꠘꠞ ꠟꠦꠛꠣꠍ ꠀꠍꠤꠟ ꠌꠇꠌꠇꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠀꠞ ꠛꠥꠇꠥꠔ ꠀꠍꠤꠟ ꠡꠥꠘꠣꠟꠤ ꠙꠐ꠆ꠐꠤ। ");
INSERT INTO syls_vpl VALUES ("RV15_7","096_15_7","REV","15","7","7","ꠢꠃ ꠌꠣꠁꠞꠎꠘ ꠎꠣꠘꠖꠣꠞꠞ ꠄꠇꠎꠘꠦ ꠅꠃ ꠡꠣꠔꠅ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠡꠣꠔꠐꠣ ꠡꠥꠘꠣꠞ ꠛꠣꠐꠤ ꠖꠤꠟꠣ। ꠁ ꠡꠣꠔꠅ ꠛꠣꠐꠤ ꠜꠞꠣ ꠀꠍꠤꠟ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠉꠥꠍꠣ, ꠎꠦꠁꠘ ꠎꠥꠉꠦ ꠎꠥꠉꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠎꠤꠘ꠆ꠖꠣ ꠀꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV15_8","096_15_8","REV","15","8","8","ꠀꠟ꠆ꠟꠣꠞ ꠇꠥꠖꠞꠔꠤ ꠝꠢꠤꠝꠣ ꠕꠣꠇꠤ ꠎꠦ ꠗꠥꠝꠣ ꠛꠣꠞꠘꠤꠔ ꠀꠍꠤꠟ, ꠅꠃ ꠗꠥꠝꠣꠄ ꠀꠡ꠆ꠔꠣ ꠊꠞ ꠜꠞꠤ ꠉꠦꠟ। ꠀꠞ ꠅꠃ ꠡꠣꠔꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠡꠣꠔꠐꠣ ꠉꠎꠛ ꠘꠣ ꠚꠥꠠꠣꠘꠤ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠦꠃ ꠉꠤꠀ ꠇꠣꠛꠣ ꠊꠞꠅ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV16_1","096_16_1","REV","16","1","1","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠢꠃ ꠇꠣꠛꠣ ꠊꠞ ꠕꠣꠇꠤ ꠄꠇꠎꠘꠦ ꠅꠃ ꠡꠣꠔꠅ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠞꠣ, “ꠔꠥꠝꠞꠣ ꠎꠣꠅ, ꠉꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠉꠎꠛꠦ ꠜꠞꠣ ꠅꠃ ꠡꠣꠔꠅ ꠛꠣꠐꠤ ꠖꠥꠘꠤꠀꠞ ꠃꠙꠞꠦ ꠃꠚꠁꠔ ꠇꠞꠤ ꠓꠣꠟꠤ ꠖꠦꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV16_2","096_16_2","REV","16","2","2","ꠔꠦꠃ ꠙꠄꠟꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠉꠤꠀ ꠔꠣꠘ ꠛꠣꠐꠤ ꠖꠥꠘꠤꠀꠞ ꠃꠙꠞꠦ ꠃꠚꠁꠔ ꠇꠞꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠎꠣꠞꠣꠞ ꠉꠔꠞꠅ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞ ꠡꠤꠟ ꠀꠍꠤꠟ, ꠎꠦꠞꠣ ꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠔ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤꠞ ꠉꠔꠞꠅ ꠄꠇ ꠎꠣꠔꠞ ꠈꠥꠛ ꠛꠣꠖ ꠛꠤꠡ ꠚꠥꠠꠣ ꠖꠦꠈꠣ ꠖꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV16_3","096_16_3","REV","16","3","3","ꠖꠥꠍꠞꠣ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠛꠣꠐꠤ ꠖꠞꠤꠀꠞ ꠃꠙꠞꠦ ꠃꠚꠁꠔ ꠇꠞꠟꠣ। ꠔꠦꠃ ꠖꠞꠤꠀꠞ ꠢꠇꠟ ꠙꠣꠘꠤ ꠝꠞꠣ ꠝꠣꠘꠡꠞ ꠟꠃꠞ ꠟꠣꠈꠣꠘ ꠅꠁꠉꠦꠟ, ꠖꠞꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠘꠖꠣꠞ ꠝꠞꠤꠉꠦꠟ। ");
INSERT INTO syls_vpl VALUES ("RV16_4","096_16_4","REV","16","4","4","ꠀꠞ ꠔꠤꠘ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠛꠣꠐꠤ ꠉꠣꠋ ꠀꠞ ꠢꠇꠟ ꠈꠣꠟ-ꠛꠤꠟꠞ ꠃꠙꠞꠦ ꠃꠚꠁꠔ ꠇꠞꠟꠣ। ꠄꠞꠟꠣꠉꠤ ꠁꠔꠣ ꠅꠁꠉꠦꠟ ꠟꠃꠞ ꠉꠣꠋ ꠀꠞ ꠈꠣꠟ-ꠛꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV16_5","096_16_5","REV","16","5","5","ꠀꠞ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠎꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠈꠦꠝꠔꠣ ꠀꠍꠤꠟ, ꠄꠁꠘ ꠇꠁꠞꠣ, “ꠅ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠤ ꠀꠉꠦꠅ ꠀꠍꠟꠣꠄ, ꠅꠈꠘꠅ ꠀꠍ। ꠔꠥꠝꠤ ꠢꠇ-ꠁꠘꠍꠣꠚꠇꠣꠞꠤ, ꠔꠥꠝꠤꠃ ꠔ ꠁ ꠉꠎꠛꠤ ꠡꠣꠎꠣ ꠖꠤꠞꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV16_6","096_16_6","REV","16","6","6","ꠁꠉꠥꠁꠘ꠆ꠔꠦ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠃ ꠏꠞꠣꠁꠍꠦ, ꠘꠛꠤ ꠅꠇꠟꠞꠅ ꠟꠃ ꠏꠞꠣꠁꠍꠦ। ꠄꠞꠖꠣꠄꠃ ꠔꠥꠝꠤ ꠁꠔꠣꠞꠦ ꠅꠃ ꠟꠃ ꠈꠣꠛꠣꠁꠞꠣꠄ, ꠁꠔꠣꠃ ꠔꠣꠞꠣꠞ ꠡꠑꠤꠇ ꠙꠣꠅꠘꠣ ꠡꠣꠎꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV16_7","096_16_7","REV","16","7","7","ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠇꠥꠞꠛꠣꠘꠤ ꠈꠣꠘꠣꠄ ꠡꠣꠄ ꠖꠤꠟꠣ, “ꠅ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣ, ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠛꠤꠌꠣꠞꠃ ꠢꠇ ꠀꠞ ꠡꠑꠤꠇ।” ");
INSERT INTO syls_vpl VALUES ("RV16_8","096_16_8","REV","16","8","8","ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠛꠣꠐꠤ ꠡꠥꠞꠥꠎꠞ ꠃꠙꠞꠦ ꠃꠚꠁꠔ ꠇꠞꠟꠣ। ꠔꠦꠃ ꠡꠥꠞꠥꠎꠞꠦ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠟ, ꠝꠣꠘꠡꠞꠦ ꠀꠉꠥꠘꠤꠔ ꠎꠣꠟꠣꠁꠀ ꠇꠥꠟꠡ ꠔꠥꠟꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RV16_9","096_16_9","REV","16","9","9","ꠅꠃ ꠡꠝꠄ ꠈꠥꠛ ꠉꠞꠝꠦ ꠝꠣꠘꠡꠞ ꠡꠞꠤꠟ ꠎꠟꠤ ꠉꠦꠟ, ꠀꠞ ꠅꠃ ꠉꠎꠛ ꠅꠇꠟꠞ ꠃꠙꠞꠦ ꠎꠣꠘ ꠈꠦꠝꠔꠣ ꠀꠍꠦ, ꠢꠃ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠔꠣꠞꠣ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠟ। ꠅꠔꠔꠣꠞ ꠛꠣꠖꠦꠅ ꠔꠣꠞꠣ ꠔꠃꠛꠣ ꠇꠞꠟ ꠘꠣ, ꠛꠣ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚꠅ ꠇꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV16_10","096_16_10","REV","16","10","10","ꠛꠣꠖꠦ ꠙꠣꠌ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞ ꠉꠖꠤꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠛꠣꠐꠤ ꠃꠚꠁꠔ ꠇꠞꠟꠣ। ꠔꠦꠃ ꠁ ꠎꠣꠘꠥꠀꠞꠞ ꠛꠣꠖꠡꠣꠁ ꠀꠘ꠆ꠖꠣꠁꠞ ꠅꠁꠉꠦꠟ। ꠝꠣꠘꠡꠦ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠄ ꠎꠣꠞꠎꠤꠞ ꠎꠤꠜꠅ ꠇꠣꠝꠠꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV16_11","096_16_11","REV","16","11","11","ꠅꠃ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣ ꠀꠞ ꠡꠞꠤꠟꠞ ꠛꠤꠡ ꠚꠥꠠꠣꠞ ꠇꠣꠞꠘꠦ ꠔꠣꠞꠣ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔꠅ ꠞꠁꠟ, ꠅꠔꠣꠞ ꠛꠣꠖꠦꠅ ꠔꠣꠞꠣꠞ ꠛꠖ ꠇꠣꠝꠞ ꠟꠣꠉꠤ ꠔꠃꠛꠣ ꠇꠞꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV16_12","096_16_12","REV","16","12","12","ꠀꠞ ꠍꠄ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠢꠃ ꠝꠢꠣ ꠉꠣꠋ ꠚꠥꠞꠣꠔꠞ ꠃꠙꠞꠦ ꠔꠣꠘ ꠉꠎꠛꠤ ꠛꠣꠐꠤ ꠃꠚꠁꠔ ꠇꠞꠟꠣ। ꠔꠦꠃ ꠉꠣꠋꠉꠞ ꠙꠣꠘꠤ ꠢꠥꠇꠣꠁꠀ ꠙꠥꠛꠞ ꠖꠦꠡꠞ ꠞꠣꠎꠣ ꠅꠇꠟꠞ ꠎꠣꠁꠛꠣꠞ ꠙꠕ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV16_13","096_16_13","REV","16","13","13","ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠛꠦꠋꠉꠞ ꠟꠣꠈꠣꠘ ꠔꠤꠘꠐꠣ ꠜꠥꠔ। ꠁ ꠔꠤꠘꠅꠐꠣ ꠢꠃ ꠖꠣꠘꠛ, ꠢꠃ ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠢꠃ ꠜꠘ꠆ꠒ ꠘꠛꠤꠞ ꠝꠥꠈ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV16_14","096_16_14","REV","16","14","14","ꠅꠃ ꠜꠥꠔ ꠅꠇꠟꠦ ꠇꠦꠞꠣꠝꠔꠤ ꠇꠣꠝ ꠖꠦꠈꠣꠘꠤꠔ ꠀꠍꠤꠟ। ꠔꠣꠞꠣ ꠢꠣꠞꠣ ꠎꠉꠔꠞ ꠞꠣꠎꠣ ꠅꠇꠟꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠟ, ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣꠞ ꠢꠃ ꠝꠢꠣꠘ ꠖꠤꠘꠅ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ। ");
INSERT INTO syls_vpl VALUES ("RV16_15","096_16_15","REV","16","15","15","ꠝꠘꠅ ꠞꠣꠈꠤꠅ, ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠞꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠔ ꠌꠥꠞꠞ ꠟꠣꠈꠣꠘ ꠘꠤꠞꠣꠟꠣꠄ ꠀꠁꠝꠥ। ꠔꠦ ꠗꠁꠘ꠆ꠘ ꠢꠃ ꠎꠘ, ꠎꠦ ꠎꠘ ꠢꠎꠣꠉ ꠞꠁꠛ ꠀꠞ ꠘꠤꠎꠞ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠀ ꠞꠁꠛ, ꠎꠣꠔꠦ ꠢꠦ ꠟꠦꠝꠐꠣ ꠅꠁꠀ ꠊꠥꠞꠣ ꠘꠣ ꠟꠣꠉꠦ, ꠀꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠞ ꠡꠞꠝ ꠘꠣ ꠖꠦꠈꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV16_16","096_16_16","REV","16","16","16","ꠁꠛꠞꠣꠘꠤ ꠜꠣꠡꠣꠄ ꠎꠦ ꠎꠣꠉꠣꠞ ꠘꠣꠝ ꠀꠞ-ꠝꠣꠎꠣꠖ꠆ꠖꠥꠘ, ꠜꠥꠔ ꠅꠇꠟꠦ ꠢꠃ ꠞꠣꠎꠣꠁꠘ꠆ꠔꠞꠦ ꠀꠘꠤꠀ ꠅꠘꠅ ꠖꠟꠣ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV16_17","096_16_17","REV","16","17","17","ꠛꠣꠖꠦ ꠡꠣꠔ ꠘꠝ꠆ꠛꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠔꠣꠘ ꠛꠣꠐꠤ ꠛꠣꠔꠣꠡꠞ ꠃꠙꠞꠦ ꠃꠚꠁꠔ ꠇꠞꠟꠣ। ꠅꠃ ꠡꠝꠄ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣꠞ ꠔꠈ꠆ꠔ ꠕꠣꠇꠤ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠅꠃ ꠀꠅꠀꠎ ꠅꠁꠟ, “ꠅꠈꠘ ꠅꠁꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV16_18","096_16_18","REV","16","18","18","ꠔꠦꠃ ꠝꠦꠊꠞ ꠎꠤꠟꠇꠣꠘꠤ, ꠉꠥꠠ-ꠉꠥꠠꠤ ꠒꠣꠇ ꠀꠞ ꠑꠣꠐꠣ ꠙꠠꠔ ꠟꠣꠉꠟ, ꠄꠞꠟꠉꠦ ꠅꠟꠣ ꠛꠦꠎꠥꠁꠔꠣ ꠜꠂꠍꠣꠟ ꠅꠁꠟ, ꠁꠟꠣ ꠜꠂꠍꠣꠟ ꠖꠥꠘꠤꠀꠔ ꠝꠣꠘꠥꠡ ꠙꠄꠖꠣ ꠕꠣꠇꠤ ꠅꠈꠘ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠇꠥꠘꠥꠖꠤꠘ ꠅꠁꠍꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV16_19","096_16_19","REV","16","19","19","ꠢꠃ ꠝꠢꠣꠘ ꠐꠣꠃꠘ ꠔꠤꠘ ꠐꠥꠇꠞꠣ ꠅꠁꠉꠦꠟ, ꠖꠥꠘꠤꠀꠞ ꠘꠣꠘꠣꠘ ꠎꠣꠔꠤꠞ ꠐꠣꠃꠘ ꠅꠇꠟ ꠌꠥꠞꠝꠣꠞ ꠅꠁꠉꠦꠟ। ꠀꠞ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠝꠘꠅ ꠅꠁꠟ, ꠢꠃ ꠘꠣꠝꠇꠞꠣ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘꠞ ꠇꠕꠣ, ꠔꠣꠁꠘ ꠔꠣꠘ ꠘꠤꠎꠞ ꠉꠎꠛꠤ ꠘꠤꠡꠣ-ꠙꠣꠘꠤꠞ ꠙꠤꠀꠟꠣ ꠜꠞꠤꠀ ꠅꠃ ꠛꠣꠛꠤꠟꠞꠦ ꠈꠣꠛꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV16_20","096_16_20","REV","16","20","20","ꠅꠃ ꠡꠝꠄ ꠔꠣꠝꠣꠝ ꠖꠤꠙ ꠅꠇꠟ ꠜꠣꠉꠤꠀ ꠉꠦꠟꠉꠤ, ꠙꠣꠠ ꠅꠇꠟꠞꠦ ꠀꠞ ꠖꠦꠈꠣ ꠉꠦꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV16_21","096_16_21","REV","16","21","21","ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠛꠠ ꠛꠠ ꠙꠣꠔ꠆ꠔꠞꠞ ꠟꠣꠈꠣꠘ ꠢꠤꠟ ꠅꠇꠟ ꠝꠣꠘꠡꠞ ꠃꠙꠞꠦ ꠙꠠꠣꠔ ꠞꠁꠟ। ꠁꠔꠣ ꠄꠇꠅ ꠙꠣꠔ꠆ꠔꠞꠞ ꠃꠎꠘ ꠅꠁꠟ, ꠅꠘꠥꠝꠣꠘ ꠄꠇ ꠝꠘ। ꠅꠃ ꠢꠤꠟꠞ ꠉꠎꠛꠞ ꠟꠣꠉꠤ ꠝꠣꠘꠡꠦ ꠀꠟ꠆ꠟꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠇꠥꠚꠥꠞꠤ ꠝꠣꠔ ꠝꠣꠔꠤꠟ, ꠁꠔꠣ ꠀꠍꠤꠟ ꠈꠥꠛ ꠝꠣꠞꠣꠔ꠆ꠔꠇ ꠉꠎꠛ। ");
INSERT INTO syls_vpl VALUES ("RV17_1","096_17_1","REV","17","1","1","ꠎꠦ ꠡꠣꠔꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠀꠔꠅ ꠡꠣꠔꠐꠣ ꠛꠣꠐꠤ ꠀꠍꠤꠟ, ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠦ ꠀꠁꠀ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠁꠀ ꠖꠦꠈꠅ, ꠛꠃꠔ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠎꠦ ꠝꠢꠣ ꠛꠖꠝꠣꠁꠡꠘꠤ ꠛꠁꠍꠦ, ꠔꠣꠁꠞ ꠇꠤꠔꠣ ꠡꠣꠎꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV17_2","096_17_2","REV","17","2","2","ꠎꠉꠔꠞ ꠞꠣꠎꠣ ꠅꠇꠟꠦ ꠔꠣꠁꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠍꠟꠣ, ꠢꠘꠞ ꠝꠣꠘꠡꠦ ꠔꠣꠁꠞ ꠎꠤꠘꠣꠞ ꠘꠤꠡꠣ-ꠙꠣꠘꠤ ꠈꠣꠁꠀ ꠐꠣꠟ ꠅꠁꠍꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV17_3","096_17_3","REV","17","3","3","ꠛꠣꠖꠦ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠞꠥꠢꠣꠘꠤ ꠢꠣꠟꠔꠦ ꠀꠝꠣꠞꠦ ꠝꠞꠥꠜꠥꠝꠤꠔ ꠘꠤꠟꠣ। ꠢꠘꠅ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠟꠣꠟ ꠞꠋꠉꠞ ꠄꠇ ꠎꠣꠘꠥꠀꠞꠞ ꠃꠙꠞꠦ ꠄꠇ ꠛꠦꠐꠤ ꠛꠁꠞꠁꠍꠦ। ꠅꠃ ꠎꠣꠘꠥꠀꠞꠞ ꠉꠔꠞꠅ ꠛꠃꠔ ꠇꠥꠚꠥꠞꠤ ꠘꠣꠝ ꠟꠦꠈꠣ ꠀꠍꠦ। ꠅꠉꠥꠞ ꠡꠣꠔꠉꠥ ꠇꠟ꠆ꠟꠣ ꠀꠞ ꠖꠡꠉꠥ ꠢꠤꠋ ꠖꠦꠈꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RV17_4","096_17_4","REV","17","4","4","ꠅꠃ ꠛꠦꠐꠤꠄ ꠟꠣꠟ ꠀꠞ ꠛꠣꠁꠋꠉꠘꠤ ꠞꠋꠉꠞ ꠈꠥꠛ ꠖꠣꠝꠤ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠤꠍꠦ, ꠔꠣꠁ ꠡꠥꠘꠣ ꠀꠞ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣꠞ ꠉꠄꠘꠣꠖꠤ ꠢꠣꠎꠤꠍꠦ। ꠔꠣꠁꠞ ꠀꠔꠅ ꠎꠤꠘꠣꠞ ꠝꠄꠟꠣ ꠀꠞ ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠘꠚꠞꠔꠤ ꠎꠤꠘꠤꠡꠦ ꠜꠞꠣ ꠡꠥꠘꠣꠞ ꠄꠇ ꠙꠤꠀꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV17_5","096_17_5","REV","17","5","5","ꠔꠣꠁꠞ ꠇꠙꠣꠟꠅ ꠅꠟꠣ ꠄꠇ ꠘꠣꠝ ꠟꠦꠈꠣ ꠀꠍꠤꠟ, ꠁ ꠟꠦꠈꠣꠞ ꠄꠇ ꠉꠥꠙꠘ ꠝꠣꠘꠤ ꠀꠍꠤꠟ। ꠁ ꠘꠣꠝ ꠅꠁꠟ, “ꠘꠣꠝꠇꠞꠣ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘ, ꠛꠖꠝꠣꠁꠡ ꠛꠦꠐꠤꠘ ꠀꠞ ꠎꠉꠔꠞ ꠢꠇꠟ ꠘꠚꠞꠔꠤ ꠎꠤꠘꠤꠡꠞ ꠝꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV17_6","096_17_6","REV","17","6","6","ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠅꠃ ꠛꠦꠐꠤꠄ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠟꠃ ꠀꠞ ꠎꠦꠞꠣ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠇꠕꠣ ꠔꠛꠟꠤꠉ ꠇꠞꠦ, ꠄꠞꠣꠞ ꠟꠃ ꠈꠣꠁꠀ ꠐꠣꠟ ꠅꠁꠉꠦꠍꠦ। ꠔꠣꠁꠞꠦ ꠖꠦꠈꠤꠀ ꠀꠝꠤ ꠀꠌꠣꠘꠇ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RV17_7","096_17_7","REV","17","7","7","ꠔꠦꠃ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠉꠦꠟꠣꠄ ꠇꠦꠘꠦ? ꠅꠃ ꠛꠦꠐꠤꠞ ꠛꠦꠙꠣꠞꠦ, ꠀꠞ ꠎꠦ ꠎꠣꠘꠥꠀꠞꠦ ꠔꠣꠁꠞꠦ ꠛꠁꠀ ꠘꠦꠞ, ꠎꠦꠉꠥꠞ ꠡꠣꠔꠉꠥ ꠇꠟ꠆ꠟꠣ ꠀꠞ ꠖꠡꠉꠥ ꠢꠤꠋ, ꠁꠔꠣꠞ ꠉꠥꠙꠘ ꠜꠦꠖ ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠎꠣꠘꠣꠁꠀꠞ। ");
INSERT INTO syls_vpl VALUES ("RV17_8","096_17_8","REV","17","8","8","ꠔꠥꠝꠤ ꠎꠦ ꠎꠣꠘꠥꠀꠞ ꠖꠦꠈꠍꠤꠟꠣꠄ, ꠁꠉꠥ ꠀꠉꠦ ꠀꠍꠤꠟ, ꠅꠈꠘ ꠘꠣꠁ, ꠛꠣꠖꠦ ꠢꠦ ꠢꠣꠛꠤꠀ ꠖꠥꠎꠈ ꠕꠣꠇꠤ ꠃꠑꠤꠀ ꠀꠁꠀ ꠌꠤꠞꠇꠣꠟꠞ ꠟꠣꠉꠤ ꠡꠣꠎꠣ ꠙꠣꠁꠛ। ꠢꠃ ꠎꠦꠞꠣ ꠅꠃ ꠎꠉꠔꠞ ꠝꠣꠘꠥꠡ, ꠎꠦꠔꠣꠞ ꠘꠣꠝ ꠖꠥꠘꠤꠀꠞ ꠙꠄꠟꠣ ꠕꠣꠇꠤꠃ ꠀꠟ꠆ꠟꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠣꠔꠣꠔ ꠟꠦꠈꠣ ꠘꠣꠁ, ꠔꠣꠞꠣ ꠅꠃ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠖꠦꠈꠤꠀ ꠔꠣꠁꠎ꠆ꠎꠥꠛ ꠅꠁꠎꠤꠛꠣ, ꠇꠣꠞꠘ ꠁꠉꠥ ꠀꠉꠦ ꠀꠍꠤꠟ, ꠅꠈꠘ ꠘꠣꠁ, ꠅꠕꠌ ꠢꠤꠞꠛꠣꠞ ꠖꠦꠈꠣ ꠖꠤꠛ। ");
INSERT INTO syls_vpl VALUES ("RV17_9","096_17_9","REV","17","9","9","“ꠢꠥꠘꠅ, ꠅꠈꠘ ꠎꠦꠔꠣ ꠛꠣꠔꠣꠁꠟ ꠅꠁꠛ, ꠁꠔꠣ ꠛꠥꠎꠣꠞ ꠟꠣꠉꠤ ꠀꠈꠟꠞ ꠖꠞꠇꠣꠞ। ꠅꠃ ꠡꠣꠔꠅ ꠇꠟ꠆ꠟꠣ ꠅꠁꠟꠉꠤ, ꠡꠣꠔꠐꠣ ꠙꠣꠠ, ꠎꠦ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠅꠃ ꠛꠦꠐꠤ ꠛꠁꠍꠦ। ꠅꠃ ꠡꠣꠔꠅ ꠇꠟ꠆ꠟꠣꠞꠦ ꠡꠣꠔꠎꠘ ꠞꠣꠎꠣꠅ ꠛꠥꠎꠣ ꠎꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV17_10","096_17_10","REV","17","10","10","ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠙꠣꠌ ꠞꠣꠎꠣ ꠀꠉꠦꠃ ꠡꠦꠡ ꠅꠁꠉꠦꠍꠦ। ꠄꠇꠎꠘ ꠅꠈꠘ ꠀꠍꠦ ꠀꠞ ꠄꠇꠎꠘ ꠅꠈꠘꠅ ꠀꠁꠍꠦ ꠘꠣ। ꠅꠃ ꠞꠣꠎꠣ ꠀꠁꠀ ꠢꠣꠞꠟꠦ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘ ꠞꠁꠔꠦꠃ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV17_11","096_17_11","REV","17","11","11","ꠢꠃ ꠎꠦ ꠎꠣꠘꠥꠀꠞ ꠀꠉꠦ ꠀꠍꠤꠟ ꠅꠈꠘ ꠘꠣꠁ, ꠢꠦ ꠡꠣꠔꠎꠘꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘ ꠅꠁꠟꠦꠅ, ꠢꠦ ꠀꠍꠟꠦ ꠀꠐ ꠘꠝ꠆ꠛꠞ ꠞꠣꠎꠣ। ꠛꠣꠖꠦ ꠢꠦ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠌꠤꠞꠇꠣꠟ ꠡꠣꠎꠣ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV17_12","096_17_12","REV","17","12","12","“ꠀꠞ ꠔꠥꠝꠤ ꠎꠦ ꠖꠡꠉꠥ ꠢꠤꠋ ꠖꠦꠈꠍ, ꠁꠔꠣ ꠅꠁꠟꠉꠤ ꠖꠡꠎꠘ ꠞꠣꠎꠣ। ꠔꠣꠞꠣ ꠅꠈꠘꠅ ꠞꠣꠎꠔ꠆ꠔ ꠇꠞꠣ ꠡꠥꠞꠥ ꠇꠞꠍꠦ ꠘꠣ, ꠅꠁꠟꠦ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞ ꠟꠉꠦ ꠞꠣꠎꠣ ꠛꠘꠤꠀ ꠔꠣꠞꠣ ꠈꠥꠛ ꠇꠝ ꠡꠝꠄ ꠞꠣꠎꠔ꠆ꠔ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠙꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV17_13","096_17_13","REV","17","13","13","ꠁ ꠞꠣꠎꠣ ꠅꠇꠟꠞ ꠝꠘ ꠅꠁꠛ ꠄꠇꠁ ꠟꠣꠈꠣꠘ, ꠔꠣꠞꠣ ꠢꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠀꠞ ꠄꠈꠔꠤꠀꠞ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠖꠤꠟꠣꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV17_14","096_17_14","REV","17","14","14","ꠔꠣꠞꠣ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠛ, ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠄ ꠔꠣꠞꠣꠞꠦ ꠀꠞꠣꠁꠛꠣ। ꠇꠣꠞꠘ ꠔꠣꠁꠘ ꠅꠁꠟꠣ ꠝꠣꠟꠤꠇ ꠅꠇꠟꠞ ꠝꠣꠟꠤꠇ, ꠛꠣꠖꠡꠣ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ। ꠀꠞ ꠔꠣꠘ ꠟꠉꠦ ꠎꠦꠞꠣ ꠞꠁꠛꠣ ꠔꠣꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠀꠞ ꠛꠣꠍꠤꠀ ꠀꠟꠉꠣꠁꠟ ꠅꠁꠍꠦ, ꠔꠣꠞꠣ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ।” ");
INSERT INTO syls_vpl VALUES ("RV17_15","096_17_15","REV","17","15","15","ꠛꠣꠖꠦ ꠅꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠎꠦ ꠙꠣꠘꠤ ꠖꠦꠈꠍ, ꠎꠦ ꠙꠣꠘꠤꠞ ꠃꠙꠞꠦ ꠅꠃ ꠝꠢꠣ ꠛꠖꠝꠣꠁꠡꠘꠤ ꠛꠁꠍꠦ, ꠁꠔꠣ ꠅꠁꠟꠉꠤ ꠛꠃꠔ ꠖꠦꠡ, ꠛꠃꠔ ꠝꠣꠘꠥꠡ, ꠛꠃꠔ ꠎꠣꠔꠤ ꠀꠞ ꠛꠃꠔ ꠎꠣꠔꠞ ꠛꠥꠟꠤꠄ ꠝꠣꠔꠞꠣ ꠝꠣꠘꠥꠡ। ");
INSERT INTO syls_vpl VALUES ("RV17_16","096_17_16","REV","17","16","16","ꠀꠞ ꠎꠦ ꠖꠡꠉꠥ ꠢꠤꠋ ꠖꠦꠈꠍ, ꠁꠔꠣꠄ ꠀꠞ ꠅꠃ ꠎꠣꠘꠥꠀꠞꠦ ꠁ ꠛꠖꠝꠣꠁꠡꠘꠤꠞꠦ ꠛꠣꠖꠦ ꠊꠤꠘ꠆ꠘꠣꠁꠛꠣ, ꠔꠣꠞꠣ ꠔꠣꠁꠞꠦ ꠙꠕꠞ ꠢꠇꠤꠞ ꠛꠣꠘꠣꠁꠀ ꠟꠦꠝꠐꠣ ꠇꠞꠛꠣ, ꠀꠞ ꠔꠣꠁꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠛꠣ, ꠢꠦꠡꠦ ꠔꠣꠁꠞꠦ ꠀꠉꠥꠘꠤꠔ ꠚꠣꠟꠣꠁ ꠎꠣꠟꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV17_17","096_17_17","REV","17","17","17","ꠄꠞ ꠇꠣꠞꠘ ꠅꠁꠟ, ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠞꠣꠞ ꠖꠤꠟꠞ ꠝꠣꠎꠦ ꠅꠟꠣ ꠄꠇ ꠘꠤꠅꠔ ꠖꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠔꠣꠘ ꠝꠞ꠆ꠎꠤ ꠙꠥꠞꠣꠙꠥꠞ ꠚꠟꠦ। ꠄꠞꠟꠣꠉꠤ ꠔꠣꠞꠣ ꠄꠇꠝꠔ ꠅꠁꠀ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠢꠇ꠆ꠇꠟ ꠈꠦꠝꠔꠣ ꠖꠤꠟꠣꠁꠛꠣ, ꠎꠣꠔꠦ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠙꠥꠞꠣꠙꠥꠞ ꠚꠟꠤꠛꠣꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠢꠦ ꠞꠣꠎꠔ꠆ꠔ ꠇꠞꠦ। ");
INSERT INTO syls_vpl VALUES ("RV17_18","096_17_18","REV","17","18","18","ꠔꠥꠝꠤ ꠎꠦ ꠛꠦꠐꠤꠞꠦ ꠖꠦꠈꠍ, ꠁꠉꠥ ꠅꠁꠟꠉꠤ ꠢꠃ ꠘꠣꠝꠇꠞꠣ ꠐꠣꠃꠘ, ꠁ ꠐꠣꠃꠘꠦ ꠎꠉꠔꠞ ꠢꠇꠟ ꠞꠣꠎꠣꠁꠘ꠆ꠔꠞ ꠃꠙꠞꠦ ꠞꠣꠎꠔ꠆ꠔ ꠇꠞꠦꠞ।” ");
INSERT INTO syls_vpl VALUES ("RV18_1","096_18_1","REV","18","1","1","ꠁꠔꠣꠞ ꠛꠣꠖꠦ ꠀꠝꠤ ꠀꠞꠇ ꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠖꠦꠈꠟꠣꠝ, ꠔꠣꠁꠘ ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠁꠞꠣ। ꠔꠣꠘ ꠛꠃꠔ ꠛꠠ ꠈꠦꠝꠔꠣ ꠀꠍꠦ, ꠔꠣꠘ ꠝꠢꠤꠝꠣꠞ ꠛꠟꠦ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠄ ꠏꠟꠝꠟ ꠇꠞꠟ। ");
INSERT INTO syls_vpl VALUES ("RV18_2","096_18_2","REV","18","2","2","ꠔꠣꠁꠘ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠟꠣ, “ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠍꠦ, ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠍꠦ, ꠢꠃ ꠘꠣꠝꠇꠞꠣ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘ। ꠁꠈꠣꠘ ꠅꠈꠘ ꠜꠥꠔꠞ ꠀꠈꠠꠣ ꠅꠁꠍꠦ, ꠢꠇ꠆ꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠜꠥꠔ-ꠙꠦꠞꠔꠞ ꠀꠈꠠꠣ, ꠘꠣꠙꠣꠇ ꠀꠞ ꠎꠊꠁꠘ꠆ꠘ ꠙꠣꠈꠤꠘ꠆ꠔꠞ ꠛꠡꠔ ꠈꠣꠘꠣ ꠅꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV18_3","096_18_3","REV","18","3","3","ꠇꠣꠞꠘ ꠁꠈꠣꠘꠦ ꠔꠣꠁꠞ ꠎꠤꠘꠣꠞ ꠇꠣꠝꠞ ꠛꠦꠎꠥꠁꠔꠣ ꠘꠤꠡꠣ-ꠙꠣꠘꠤ ꠖꠥꠘꠤꠀꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠈꠣꠛꠣꠁꠍꠦ। ꠎꠉꠔꠞ ꠞꠣꠎꠣ ꠅꠇꠟꠦ ꠔꠣꠁꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠍꠦ, ꠎꠉꠔꠞ ꠛꠦꠙꠣꠞꠤ ꠡꠖꠣꠉꠞ ꠅꠇꠟꠦ ꠅꠈꠣꠘꠞ ꠔꠣꠟꠦ ꠔꠣꠟꠦ ꠟꠣꠉꠣꠝ ꠍꠣꠠꠣ ꠘꠤꠡꠣꠄ ꠗꠘꠤ ꠛꠘꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV18_4","096_18_4","REV","18","4","4","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠀꠞꠇ ꠎꠘꠦ ꠇꠁꠞꠣ, “ꠅ ꠀꠝꠣꠞ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ ꠀꠅ, ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠔꠣꠁꠞ ꠉꠥꠘꠣꠞ ꠜꠣꠉꠤ ꠘꠣ ꠅꠅ। ꠀꠞ ꠔꠣꠁꠞ ꠃꠙꠞꠦ ꠎꠦꠔꠣ ꠉꠎꠛ ꠘꠣꠎꠤꠟ ꠅꠁꠛ, ꠁꠔꠣ ꠉꠎꠛꠦ ꠔꠥꠝꠞꠣꠞꠦ ꠘꠣ ꠙꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV18_5","096_18_5","REV","18","5","5","ꠔꠣꠁꠞ ꠉꠥꠘꠣ ꠉꠤꠀ ꠔ ꠀꠍꠝꠣꠘꠅ ꠟꠣꠉꠤꠉꠦꠍꠦ, ꠔꠣꠁꠞ ꠘꠣꠚꠞꠝꠣꠘꠤꠞ ꠛꠣꠄ ꠀꠟ꠆ꠟꠣꠄ ꠈꠤꠀꠟ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV18_6","096_18_6","REV","18","6","6","ꠅꠁꠘ꠆ꠘ ꠎꠘꠞ ꠟꠉꠦ ꠔꠣꠁ ꠎꠦꠟꠣ ꠇꠞꠍꠦ, ꠔꠥꠝꠞꠣꠅ ꠔꠣꠁꠞ ꠟꠉꠦ ꠅꠟꠣ ꠇꠞꠅ, ꠔꠣꠁꠞ ꠇꠣꠝꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠙꠣꠅꠘꠣ ꠔꠣꠁꠞꠦ ꠖꠦꠅ। ꠎꠦ ꠙꠤꠀꠟꠣꠞ ꠝꠣꠎꠦ ꠔꠣꠁ ꠅꠁꠘ꠆ꠘꠞ ꠟꠣꠉꠤ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠉꠥꠟꠣꠁꠔ, ꠅꠃ ꠙꠤꠀꠟꠣꠔ ꠔꠣꠁꠞ ꠙꠥꠞꠣꠙꠥꠞ ꠡꠣꠎꠣ, ꠡꠥꠟ꠆ꠟꠀꠘꠣ ꠡꠣꠎꠣ ꠉꠥꠟꠤꠀ ꠔꠣꠁꠞꠦ ꠈꠣꠛꠣꠅ। ");
INSERT INTO syls_vpl VALUES ("RV18_7","096_18_7","REV","18","7","7","ꠔꠣꠁ ꠘꠤꠎꠞꠦ ꠟꠁꠀ ꠎꠔꠈꠣꠘ ꠛꠠꠣꠁ ꠇꠞꠍꠦ, ꠎꠔ ꠛꠦꠡꠤ ꠛꠤꠟꠣꠡꠤꠔꠣꠞ ꠝꠣꠎꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠇꠣꠐꠣꠁꠍꠦ, ꠑꠤꠇ ꠅꠔꠈꠣꠘ ꠎꠘꠔ꠆ꠞꠘꠣ ꠀꠞ ꠖꠥꠈ ꠔꠣꠁꠞꠦ ꠖꠦꠅ। ꠔꠣꠁ ꠔ ꠝꠘꠦ ꠝꠘꠦ ꠇꠄ, ‘ꠀꠝꠤ ꠇꠥꠘꠥ ꠠꠣꠠꠤ ꠛꠦꠐꠤ ꠘꠤ? ꠀꠝꠤ ꠔ ꠞꠣꠘꠤꠞ ꠀꠡꠘꠅ ꠛꠁꠍꠤ, ꠀꠝꠤ ꠇꠥꠘꠥꠝꠘ꠆ꠔꠦꠃ ꠖꠥꠈ-ꠝꠍꠤꠛꠔꠅ ꠙꠠꠔꠣꠝ ꠘꠣꠄ।’ ");
INSERT INTO syls_vpl VALUES ("RV18_8","096_18_8","REV","18","8","8","ꠄꠞꠟꠣꠉꠤ ꠔꠣꠁꠞ ꠃꠙꠞꠦ ꠄꠇꠖꠤꠘꠦꠃ ꠢꠇꠟ ꠉꠎꠛ ꠙꠠꠛ। ꠁ ꠉꠎꠛ ꠅꠁꠟ ꠝꠃꠔ, ꠛꠤꠟꠣꠙ-ꠀꠢꠣꠎꠣꠞꠤ ꠀꠞ ꠘꠤꠖꠣꠘ। ꠔꠣꠁꠞꠦ ꠀꠉꠥꠁꠘꠖꠤ ꠎꠣꠟꠣꠁꠟ ꠅꠁꠛ, ꠇꠣꠞꠘ ꠎꠦꠁꠘ ꠔꠣꠁꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠛꠣ, ꠁ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖ ꠈꠥꠛ ꠛꠟꠛꠣꠘ।” ");
INSERT INTO syls_vpl VALUES ("RV18_9","096_18_9","REV","18","9","9","ꠎꠉꠔꠞ ꠎꠔ ꠞꠣꠎꠣ ꠅꠇꠟꠦ ꠅꠉꠥꠞ ꠟꠉꠦ ꠎꠤꠘꠣ ꠇꠞꠍꠦ, ꠔꠣꠁꠞ ꠟꠉꠦ ꠢꠂ-ꠢꠥꠟ꠆ꠟꠣ ꠇꠞꠤ ꠛꠤꠟꠣꠡꠤ ꠖꠤꠘ ꠇꠣꠐꠣꠁꠍꠦ, ꠔꠣꠁꠞꠦ ꠎꠣꠟꠣꠘꠤꠞ ꠛꠣꠟꠣ ꠔꠣꠁꠞ ꠗꠥꠝꠣ ꠖꠦꠈꠤꠀ ꠅꠔꠣꠄ ꠇꠣꠘ꠆ꠖꠤꠛꠣ, ꠔꠣꠁꠞ ꠟꠣꠉꠤ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV18_10","096_18_10","REV","18","10","10","ꠔꠣꠁꠞ ꠎꠘꠔ꠆ꠞꠘꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠒꠞꠣꠁꠀ ꠖꠥꠞꠁ ꠃꠛꠣꠁꠀ ꠇꠁꠛꠣ, “ꠢꠣꠄꠞꠦ ꠛꠣꠛꠤꠟ, ꠢꠣꠄꠞꠦ ꠢꠣꠄ! ꠅꠔ ꠘꠣꠝꠇꠞꠣ ꠐꠣꠃꠘ, ꠅꠔ ꠈꠦꠝꠔꠣꠀꠟꠣ ꠐꠣꠃꠘ! ꠅꠟꠣ ꠎꠟꠖꠤ ꠔꠥꠝꠣꠞ ꠃꠙꠞꠦ ꠉꠎꠛ ꠀꠁꠟ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("RV18_11","096_18_11","REV","18","11","11","ꠎꠉꠔꠞ ꠛꠦꠙꠣꠞꠤ ꠡꠖꠣꠉꠞ ꠅꠇꠟꠦꠅ ꠔꠣꠁꠞ ꠟꠣꠉꠤ ꠇꠣꠘ꠆ꠖꠤꠛꠣ ꠀꠞ ꠀꠢꠣꠎꠣꠞꠤ ꠇꠞꠛꠣ, ꠇꠣꠞꠘ ꠔꠣꠞꠣꠞ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠅꠈꠘ ꠇꠥꠘꠥ ꠝꠣꠘꠡꠦ ꠟꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV18_12","096_18_12","REV","18","12","12","ꠔꠣꠞꠣꠞ ꠁꠔꠣ ꠝꠣꠟ-ꠍꠣꠝꠣꠘꠣ ꠅꠁꠟ, ꠡꠥꠘꠣ, ꠞꠥꠙꠣ, ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣ, ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠇꠣꠙꠠ, ꠛꠣꠁꠋꠉꠘꠤ ꠞꠋꠉꠞ ꠛꠣꠖꠡꠣꠁ ꠇꠣꠙꠠ, ꠞꠦꠡꠝꠤ ꠀꠞ ꠟꠣꠟ ꠇꠣꠙꠠ, ꠘꠣꠘꠣꠘ ꠘꠝꠥꠘꠣꠞ ꠈꠥꠡꠛꠄ ꠀꠟꠣ ꠟꠣꠇꠠꠤ, ꠀꠔ꠆ꠔꠤꠞ ꠖꠣꠔꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠘꠣꠘꠣꠘ ꠌꠤꠎ, ꠖꠣꠝꠤ ꠟꠣꠇꠠꠤꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠌꠤꠎ, ꠙꠤꠔꠟ, ꠟꠥꠀ ꠀꠞ ꠝꠣꠞꠛꠦꠟ ꠙꠣꠔ꠆ꠔꠞꠖꠤ ꠛꠣꠘꠣꠁꠟ ꠘꠣꠘꠣꠘ ꠍꠣꠝꠣꠘꠣ, ");
INSERT INTO syls_vpl VALUES ("RV18_13","096_18_13","REV","18","13","13","ꠒꠣꠁꠟꠌꠤꠘꠤ, ꠄꠟꠣꠁꠌ, ꠀꠉꠞ-ꠈꠥꠡꠛꠄ, ꠝꠥꠞꠣ-ꠀꠔꠞ, ꠟꠥꠛꠣꠘ-ꠀꠉꠞ, ꠀꠋꠉꠥꠞꠞ ꠞꠡ, ꠎꠄꠔꠥꠘꠞ ꠔꠦꠟ, ꠝꠄꠖꠣ-ꠉꠝ, ꠉꠞꠥ-ꠝꠦꠠꠣ, ꠊꠥꠠꠣ ꠀꠞ ꠊꠥꠠꠣꠞ ꠉꠣꠠꠤ, ꠄꠞꠟꠉꠦ ꠈꠞꠤꠖꠣ ꠉꠥꠟꠣꠝ-ꠛꠣꠘ꠆ꠖꠤ ꠅꠇꠟ। ");
INSERT INTO syls_vpl VALUES ("RV18_14","096_18_14","REV","18","14","14","ꠢꠃ ꠡꠖꠣꠉꠞ ꠅꠇꠟꠦ ꠇꠁꠛꠣ, “ꠅ ꠛꠣꠛꠤꠟ, ꠔꠥꠝꠤ ꠎꠦ ꠀꠞꠣꠝ-ꠀꠄꠄꠡ ꠙꠣꠁꠔꠣꠄ ꠌꠣꠁꠍꠟꠣꠄ, ꠁꠔꠣ ꠔ ꠔꠥꠝꠣꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠢꠞꠤꠉꠦꠍꠦ। ꠔꠥꠝꠣꠞ ꠢꠇꠟ ꠗꠘ-ꠍꠣꠝꠣꠘꠣ, ꠎꠣꠇ-ꠎꠝꠇ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠍꠦ। ꠁꠔꠣ ꠔ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠚꠤꠞꠔ ꠙꠣꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ।” ");
INSERT INTO syls_vpl VALUES ("RV18_15","096_18_15","REV","18","15","15","ꠎꠦꠔꠣ ꠡꠖꠣꠉꠞ ꠅꠇꠟꠦ ꠅꠔꠣ ꠝꠣꠟꠞ ꠛꠦꠛꠡꠣ ꠇꠞꠤꠀ ꠗꠘꠤ ꠅꠁꠍꠟꠣ, ꠔꠣꠁꠞ ꠎꠘꠔ꠆ꠞꠘꠣ ꠖꠦꠈꠤꠀ ꠢꠃ ꠛꠦꠙꠣꠞꠤ ꠅꠇꠟꠦ ꠒꠞꠣꠁꠀ ꠖꠥꠞꠁ ꠃꠛꠣꠁ ꠞꠁꠛꠣ। ꠔꠣꠞꠣ ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠤꠀ ꠇꠁꠛꠣ, ");
INSERT INTO syls_vpl VALUES ("RV18_16","096_18_16","REV","18","16","16","“ꠁꠡ, ꠢꠣꠄꠞꠦ ꠢꠣꠄ, ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠝꠍꠟꠤꠘ ꠇꠣꠙꠠ, ꠛꠣꠁꠋꠉꠘꠤ ꠀꠞ ꠟꠣꠟ ꠞꠋꠉꠞ ꠛꠣꠖꠡꠣꠁ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠣ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘ, ꠡꠥꠘꠣ ꠀꠞ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣ ꠖꠤꠀ ꠢꠣꠎꠣꠁꠟ-ꠙꠣꠠꠣꠁꠟ ꠅꠔ ꠘꠣꠝꠇꠞꠣ ꠐꠣꠃꠘ! ");
INSERT INTO syls_vpl VALUES ("RV18_17","096_18_17","REV","18","17","17","ꠅꠔ ꠎꠟꠖꠤ ꠔꠥꠝꠣꠞ ꠅꠔ ꠗꠘ-ꠍꠣꠝꠣꠘꠣꠞ ꠜꠣꠘ꠆ꠒꠣꠞ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ ꠘꠤ?” ꠡꠖꠣꠉꠞꠤ ꠎꠣꠎꠞ ꠡꠣꠞꠋ ꠀꠞ ꠇꠣꠙ꠆ꠔꠣꠘ ꠅꠇꠟꠦ, ꠘꠣꠁꠀ ꠅꠇꠟꠦ, ꠎꠣꠎ ꠀꠞ ꠙꠣꠟꠞ ꠘꠣꠁꠀ ꠇꠣꠞꠛꠣꠞꠤ ꠅꠇꠟꠦ ꠖꠥꠞꠁ ꠃꠛꠣꠁꠀ ꠁꠔꠣ ꠖꠦꠈꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV18_18","096_18_18","REV","18","18","18","ꠔꠣꠁꠞꠦ ꠎꠣꠟꠣꠘꠤꠞ ꠡꠝꠄ ꠔꠣꠁꠞ ꠗꠥꠝꠣ ꠖꠦꠈꠤꠀ ꠔꠣꠞꠣ ꠌꠤꠟ꠆ꠟꠣꠁꠀ ꠇꠁꠛꠣ, “ꠁ ꠐꠣꠃꠘꠞ ꠟꠣꠈꠣꠘ ꠘꠣꠝꠇꠞꠣ, ꠎꠉꠔꠞ ꠀꠞ ꠇꠥꠘꠥ ꠐꠣꠃꠘ ꠀꠍꠤꠟ ꠘꠤ?” ");
INSERT INTO syls_vpl VALUES ("RV18_19","096_18_19","REV","18","19","19","ꠔꠣꠞꠣ ꠘꠤꠎꠞ ꠝꠣꠕꠣꠔ ꠗꠥꠁꠟ ꠝꠣꠈꠣꠁꠀ ꠌꠤꠟ꠆ꠟꠣ-ꠌꠤꠟ꠆ꠟꠤ ꠇꠞꠛꠣ ꠀꠞ ꠇꠣꠘ꠆ꠖꠤ ꠇꠣꠘ꠆ꠖꠤ ꠝꠣꠔ꠆ꠔꠝ ꠇꠞꠤꠀ ꠇꠁꠛꠣ, “ꠢꠣꠄꠞꠦ ꠢꠣꠄ, ꠢꠃ ꠘꠣꠝꠇꠞꠣ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘ, ꠢꠣꠄꠞꠦ ꠢꠣꠄ! ꠖꠞꠤꠀꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠎꠣꠎ ꠌꠟꠣꠌꠟ ꠇꠞꠦ, ꠔꠣꠞꠣ ꠔ ꠎꠣꠎꠞ ꠇꠣꠝꠣꠁ ꠖꠤꠀ ꠛꠠꠟꠥꠇ ꠅꠁꠍꠟꠣ, ꠅꠈꠘ ꠖꠦꠈꠞꠣꠄ ꠘꠤ, ꠅꠔ ꠎꠟꠖꠤ ꠇꠤꠟꠣ ꠢꠇꠟꠔꠣ ꠛꠤꠘꠣꠡ ꠅꠁꠉꠦꠟ!” ");
INSERT INTO syls_vpl VALUES ("RV18_20","096_18_20","REV","18","20","20","ꠅꠃ ꠡꠝꠄ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠇꠁꠟꠣ, “ꠅ ꠛꠦꠢꠦꠡ꠆ꠔ, ꠔꠥꠝꠤ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ, ꠅꠃ ꠐꠣꠃꠘꠞꠦ ꠛꠤꠘꠣꠡ ꠇꠞꠣꠄ ꠈꠥꠡꠤ ꠇꠞꠅ। ꠅ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟ, ꠘꠛꠤ-ꠞꠍꠥꠟ ꠅꠇꠟ ꠀꠞ ꠍꠣꠢꠣꠛꠤ ꠅꠇꠟ, ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠅ। ꠅꠉꠤꠄ ꠔꠥꠝꠞꠣꠞ ꠛꠤꠞꠥꠖ꠆ꠖꠦ ꠎꠔꠔꠣ ꠇꠞꠍꠤꠟ, ꠅꠈꠘ ꠀꠟ꠆ꠟꠣꠄ ꠔꠣꠁꠞ ꠛꠤꠌꠣꠞ ꠇꠞꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("RV18_21","096_18_21","REV","18","21","21","ꠛꠣꠖꠦ ꠈꠥꠛ ꠡꠇ꠆ꠔꠤꠀꠟꠣ ꠄꠇ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠛꠤꠞꠣꠐ ꠄꠇ ꠙꠣꠔ꠆ꠔꠞ ꠀꠘꠤꠀ ꠖꠞꠤꠀꠔ ꠚꠣꠟꠣꠁꠀ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠅꠃ ꠘꠣꠝꠇꠞꠣ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘꠞꠦꠅ ꠅꠟꠣ ꠒꠦꠇ꠆ꠇꠣ ꠝꠣꠞꠤ ꠚꠣꠟꠣꠁ ꠖꠦꠅꠀ ꠅꠁꠛ, ꠔꠣꠁꠞꠦ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠙꠣꠅꠀ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV18_22","096_18_22","REV","18","22","22","ꠎꠦꠞꠣ ꠡꠣꠞꠤꠘ꠆ꠖꠣ ꠛꠣꠎꠣꠄ, ꠉꠣꠘ ꠉꠣꠄ ꠀꠞ ꠛꠣꠡꠤ ꠛꠣ ꠡꠤꠋꠉꠣ ꠛꠣꠎꠣꠄ, ꠔꠣꠞꠣꠞ ꠀꠅꠀꠎ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠢꠥꠘꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘꠃ ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥꠎꠣꠔꠞ ꠝꠦꠡ꠆ꠔꠞꠤ ꠝꠤꠟꠔ ꠘꠣꠄ। ꠇꠥꠘꠥ ꠝꠡꠟꠣ ꠙꠤꠡꠣꠞ ꠙꠣꠐꠣꠞ ꠀꠅꠀꠎ ꠇꠥꠘꠥꠖꠤꠘ ꠢꠥꠘꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV18_23","096_18_23","REV","18","23","23","ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠇꠥꠘꠥꠖꠤꠘ ꠇꠥꠘꠥ ꠛꠣꠔ꠆ꠔꠤꠞ ꠚꠞ ꠎꠟꠔ ꠘꠣꠄ। ꠖꠣꠝꠣꠘ꠆ꠖ-ꠇꠁꠘꠣꠞ ꠉꠟꠣꠞ ꠀꠅꠀꠎ ꠀꠞ ꠇꠥꠘꠥꠖꠤꠘ ꠔꠥꠝꠣꠞ ꠝꠣꠎꠦ ꠢꠥꠘꠣ ꠎꠣꠁꠔ ꠘꠣꠄ। ꠇꠣꠞꠘ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠝꠣꠎꠦ ꠔꠥꠝꠣꠞ ꠡꠖꠣꠉꠞ ꠅꠇꠟ ꠘꠣꠝꠇꠞꠣ ꠀꠍꠤꠟ, ꠎꠉꠔꠞ ꠢꠇꠟ ꠎꠣꠔꠤ ꠔꠥꠝꠣꠞ ꠍꠟ-ꠌꠔꠥꠞꠤꠞ ꠎꠣꠖꠥꠄ ꠙꠣꠉꠟ ꠅꠁꠎꠤꠔ। ");
INSERT INTO syls_vpl VALUES ("RV18_24","096_18_24","REV","18","24","24","ꠀꠞ ꠘꠛꠤ-ꠞꠍꠥꠟ ꠅꠇꠟꠞꠦ, ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞꠦ, ꠀꠞ ꠎꠔ ꠝꠣꠘꠡꠞꠦ ꠁ ꠎꠉꠔꠅ ꠈꠥꠘ ꠇꠞꠣ ꠅꠁꠍꠦ, ꠔꠣꠞꠣꠞ ꠟꠃ ꠔ ꠔꠥꠝꠣꠞ ꠅꠃ ꠛꠣꠛꠤꠟ ꠐꠣꠃꠘꠅ ꠝꠤꠟꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV19_1","096_19_1","REV","19","1","1","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎꠦ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠜꠤꠠꠞ ꠀꠅꠀꠎ ꠢꠥꠘꠟꠣꠝ। ꠔꠣꠞꠣ ꠇꠁꠞꠣ, “ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ! ꠝꠢꠤꠝꠣ ꠀꠞ ꠈꠦꠝꠔꠣ, ꠀꠈꠦꠞꠣꠔꠞ ꠘꠣꠎꠣꠔ, ꠢꠇ꠆ꠇꠟꠔꠣꠃ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ। ");
INSERT INTO syls_vpl VALUES ("RV19_2","096_19_2","REV","19","2","2","ꠔꠣꠘ ꠛꠤꠌꠣꠞ ꠔ ꠢꠇ ꠀꠞ ꠡꠑꠤꠇ। ꠎꠦ ꠐꠣꠃꠘꠦ ꠘꠤꠎꠞ ꠎꠤꠘꠣꠞ ꠇꠣꠝ ꠖꠤꠀ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞꠦ ꠘꠣꠙꠣꠇ ꠛꠣꠘꠣꠁꠍꠤꠟ, ꠢꠃ ꠝꠢꠣ-ꠛꠖꠝꠣꠁꠡꠘꠤꠞꠦ ꠀꠟ꠆ꠟꠣꠄ ꠡꠣꠎꠣ ꠖꠤꠍꠂꠘ। ꠔꠣꠘ ꠝꠣꠄꠀꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞ ꠟꠃꠞ ꠛꠖꠟꠣ, ꠔꠣꠁꠘ ꠅꠉꠥꠞ ꠉꠦꠍ ꠕꠣꠇꠤ ꠟꠁꠍꠂꠘ।” ");
INSERT INTO syls_vpl VALUES ("RV19_3","096_19_3","REV","19","3","3","ꠄꠞꠣ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ! ꠅꠉꠥꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠗꠥꠝꠣ ꠛꠣꠞ ꠅꠁꠛ।” ");
INSERT INTO syls_vpl VALUES ("RV19_4","096_19_4","REV","19","4","4","ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠎꠦꠁꠘ ꠔꠈ꠆ꠔꠅ ꠛꠅꠀꠔ ꠀꠍꠂꠘ, ꠢꠃ ꠌꠛ꠆ꠛꠤꠡꠎꠘ ꠝꠥꠞꠛ꠆ꠛꠤ ꠘꠦꠔꠣꠄ ꠀꠞ ꠢꠃ ꠌꠣꠁꠞꠅ ꠎꠣꠘꠖꠣꠞꠦ ꠔꠣꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠤꠀ ꠇꠁꠟꠣ, “ꠀꠝꠤꠘ! ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV19_5","096_19_5","REV","19","5","5","ꠅꠃ ꠡꠝꠄ ꠛꠦꠢꠦꠡ꠆ꠔꠤ ꠔꠈ꠆ꠔꠅ ꠕꠣꠇꠤ ꠄꠇꠎꠘꠦ ꠇꠁꠟꠣ, “ꠅ ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠄꠀꠞ ꠉꠥꠟꠣꠝ ꠅꠇꠟ, ꠔꠥꠝꠞꠣ ꠎꠦꠞꠣ ꠀꠟ꠆ꠟꠣꠞꠦ ꠒꠞꠣꠅ, ꠔꠥꠝꠞꠣ ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇ꠆ꠇꠟꠦ ꠀꠝꠞꠣꠞ ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠞꠤꠚ ꠇꠞꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV19_6","096_19_6","REV","19","6","6","ꠛꠣꠖꠦ ꠀꠝꠤ ꠛꠃꠔ ꠝꠣꠘꠡꠞ ꠜꠤꠠꠞ ꠀꠅꠀꠎ ꠛꠣ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠟ-ꠇꠟꠣꠁꠀ ꠙꠣꠘꠤ ꠙꠠꠣꠞ ꠀꠅꠀꠎ ꠛꠣ ꠎꠥꠞꠦ ꠑꠣꠐꠣ ꠙꠠꠣꠞ ꠀꠅꠀꠎꠞ ꠟꠣꠈꠣꠘ ꠅꠃ ꠇꠕꠣꠈꠣꠘꠣꠁꠘ ꠢꠥꠘꠟꠣꠝ, “ꠀꠟꠢꠣꠝꠖꠥꠟꠤꠟ꠆ꠟꠣ! ꠀꠝꠞꠣꠞ ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠝꠣꠛꠥꠖ ꠀꠟ꠆ꠟꠣꠄ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠣ ꠡꠥꠞꠥ ꠇꠞꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV19_7","096_19_7","REV","19","7","7","ꠀꠅ, ꠀꠝꠞꠣ ꠝꠘꠞ ꠈꠥꠡꠤꠄ ꠚꠥꠞ꠆ꠔꠤ ꠇꠞꠤ, ꠀꠞ ꠔꠣꠘ ꠔꠣꠞꠤꠚ ꠇꠞꠤ, ꠇꠣꠞꠘ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠄ ꠡꠣꠖꠤ ꠇꠞꠣꠞ ꠡꠝꠄ ꠅꠁꠉꠦꠍꠦ, ꠔꠣꠘ ꠇꠁꠘꠣ ꠎꠥꠁꠔ ꠅꠁꠀ ꠢꠣꠎꠤꠉꠦꠍꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV19_8","096_19_8","REV","19","8","8","ꠔꠣꠘꠞꠦ ꠌꠇꠌꠇꠣ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠖꠣꠝꠤ ꠇꠣꠙꠠ ꠚꠤꠘ꠆ꠖꠣꠁꠟ ꠅꠁꠍꠦ।” ꠁ ꠇꠣꠙꠠ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠌꠣꠟ-ꠌꠟꠘ। ");
INSERT INTO syls_vpl VALUES ("RV19_9","096_19_9","REV","19","9","9","ꠛꠣꠖꠦ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠔꠥꠝꠤ ꠅꠈꠣꠘ ꠟꠦꠈꠅ, ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠡꠣꠖꠤꠞ ꠝꠎꠟꠤꠍꠅ ꠎꠦꠞꠣꠞꠦ ꠖꠣꠅꠔ ꠖꠦꠅꠀ ꠅꠁꠍꠦ, ꠔꠣꠞꠣ ꠝꠥꠛꠣꠞꠇ।” ꠔꠣꠁꠘ ꠄꠅꠈꠣꠘ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠅꠁꠟ ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ, ꠁꠔꠣ ꠈꠣꠐꠤ ꠢꠣꠍꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV19_10","096_19_10","REV","19","10","10","ꠔꠦꠃ ꠀꠝꠤ ꠅꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠘ ꠙꠣꠅ-ꠅ ꠙꠠꠟꠣꠝ, ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠢꠣꠄ, ꠢꠣꠄ! ꠁꠔꠣ ꠇꠤꠔꠣ ꠇꠞꠞꠣꠄ, ꠀꠝꠤꠅ ꠔ ꠔꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠉꠥꠟꠣꠝ, ꠀꠞ ꠔꠥꠝꠣꠞ ꠎꠦ ꠝꠥꠝꠤꠘ ꠜꠣꠁ ꠅꠇꠟꠦ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠙꠇ꠆ꠇꠦ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠦꠅꠀꠔ ꠞꠄ, ꠀꠝꠤ ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘꠅ ꠉꠥꠟꠣꠝ। ꠔꠦ ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠅ। ꠅꠃ ꠁꠍꠣꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤꠃ ꠅꠁꠟ, ꠘꠛꠤ-ꠞꠍꠥꠟ ꠅꠇꠟꠞ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤꠞ ꠝꠥꠟ ꠈꠥꠐꠤ।” ");
INSERT INTO syls_vpl VALUES ("RV19_11","096_19_11","REV","19","11","11","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠖꠥꠀꠞ ꠈꠥꠟꠣ, ꠀꠞ ꠢꠘꠅ ꠗꠟꠣ ꠄꠇꠐꠣ ꠊꠥꠠꠣ ꠀꠍꠦ। ꠢꠃ ꠊꠥꠠꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠁꠘ ꠔꠡꠞꠤꠚ ꠞꠣꠈꠍꠂꠘ, ꠔꠣꠘ ꠘꠣꠝ ꠅꠁꠟ, ꠢꠇ ꠀꠞ ꠢꠇ-ꠢꠣꠟꠣꠟꠤ। ꠔꠣꠁꠘ ꠙꠣꠇ-ꠙꠞꠦꠎꠉꠣꠞꠤꠄ ꠛꠤꠌꠣꠞ-ꠁꠘꠍꠣꠚ ꠀꠞ ꠎꠥꠖ꠆ꠖ ꠇꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV19_12","096_19_12","REV","19","12","12","ꠔꠣꠘ ꠌꠃꠈ ꠅꠁꠟ ꠎꠣꠟꠣꠁꠟ ꠌꠇꠌꠇꠣ ꠀꠉꠥꠘꠤꠞ ꠟꠣꠈꠣꠘ, ꠔꠣꠘ ꠝꠣꠕꠣꠔ ꠛꠃꠔ ꠔꠣꠎ ꠀꠍꠦ। ꠔꠣꠘ ꠡꠞꠤꠟꠅ ꠅꠝꠘ ꠄꠇ ꠘꠣꠝ ꠟꠦꠈꠣ, ꠎꠦ ꠘꠣꠝꠞ ꠝꠣꠘꠤ ꠔꠣꠁꠘ ꠍꠣꠠꠣ ꠖꠥꠍꠞꠣ ꠇꠦꠃ ꠎꠣꠘꠦ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV19_13","096_19_13","REV","19","13","13","ꠔꠣꠘ ꠚꠤꠘ꠆ꠘ ꠀꠍꠦ ꠟꠃꠞ ꠝꠣꠎꠦ ꠒꠥꠛꠣꠁꠟ ꠟꠦꠛꠣꠍ, ꠀꠞ ꠔꠣꠘ ꠘꠣꠝ ꠅꠁꠟ, “ꠇꠣꠟꠤꠝꠣꠔꠥꠟ꠆ꠟꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("RV19_14","096_19_14","REV","19","14","14","ꠀꠞ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠍꠤꠙꠣꠁ ꠅꠇꠟꠦ ꠖꠣꠝꠤ ꠍꠣꠚ-ꠍꠥꠔꠞꠣ ꠗꠟꠣ ꠟꠦꠛꠣꠍ ꠚꠤꠘ꠆ꠖꠤꠀ, ꠗꠟꠣ ꠊꠥꠠꠣꠞ ꠃꠙꠞꠦ ꠍꠅꠀꠞ ꠅꠁꠀ ꠔꠣꠘ ꠈꠞꠦ ꠈꠞꠦ ꠎꠣꠁꠞꠣ। ");
INSERT INTO syls_vpl VALUES ("RV19_15","096_19_15","REV","19","15","15","ꠔꠣꠁꠘ ꠎꠣꠔꠦ ꠎꠉꠔꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ ꠡꠣꠎꠣ ꠖꠤꠔꠣ ꠙꠣꠞꠂꠘ, ꠅꠔꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠘ ꠝꠥꠈ ꠕꠣꠇꠤ ꠄꠇꠈꠣꠘ ꠗꠣꠞꠣꠁꠟ ꠔꠟꠥꠀꠞ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠟ। ꠔꠣꠁꠘ ꠟꠥꠀꠞ ꠟꠣꠑꠤ ꠖꠤꠀ ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞꠦ ꠡꠣꠡꠘ ꠇꠞꠛꠣ, ꠀꠞ ꠀꠋꠉꠥꠞ ꠝꠣꠠꠣꠞ ꠉꠣꠔꠅ ꠝꠣꠘꠡꠦ ꠎꠦꠟꠣ ꠙꠣꠅꠖꠤ ꠀꠋꠉꠥꠞ ꠝꠣꠠꠂꠘ, ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣꠞ ꠟꠣꠘ꠆ꠘꠔꠤ ꠉꠎꠛꠖꠤ ꠔꠣꠁꠘ ꠅꠟꠣ ꠝꠣꠠꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV19_16","096_19_16","REV","19","16","16","ꠔꠣꠘ ꠃꠞꠣꠔꠞ ꠝꠣꠎꠦ ꠀꠞ ꠔꠣꠘ ꠟꠦꠛꠣꠍꠅ ꠅꠃ ꠘꠣꠝ ꠟꠦꠈꠣ ꠀꠍꠦ, “ꠛꠣꠖꠡꠣ ꠅꠇꠟꠞ ꠛꠣꠖꠡꠣ, ꠝꠣꠟꠤꠇ ꠅꠇꠟꠞ ꠝꠣꠟꠤꠇ।” ");
INSERT INTO syls_vpl VALUES ("RV19_17","096_19_17","REV","19","17","17","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠡꠥꠞꠥꠎꠞ ꠝꠣꠎꠦ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠀꠍꠝꠣꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠃꠠꠤꠞꠣ, ꠔꠣꠁꠘ ꠄꠞꠣ ꠢꠇꠟꠞꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠒꠣꠇꠤꠀ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠝꠢꠣ-ꠖꠣꠅꠔ ꠈꠣꠅꠀꠞ ꠟꠣꠉꠤ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠅ, ");
INSERT INTO syls_vpl VALUES ("RV19_18","096_19_18","REV","19","18","18","ꠎꠣꠔꠦ ꠔꠥꠝꠞꠣ ꠀꠁꠀ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠔꠣꠄ ꠙꠣꠞ, ꠛꠣꠖꠡꠣ, ꠙꠞꠗꠣꠘ ꠍꠤꠙꠣꠁ, ꠙꠄꠟꠥꠀꠘ ꠅꠇꠟ, ꠊꠥꠠꠣꠁꠘ ꠀꠞ ꠊꠥꠠꠣꠁꠘ꠆ꠔꠞ ꠍꠅꠀꠞ ꠅꠇꠟ, ꠀꠎꠣꠖ ꠀꠞ ꠉꠥꠟꠣꠝ, ꠢꠥꠞꠥ-ꠛꠠ ꠢꠇꠟ ꠝꠣꠘꠡꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠅ।” ");
INSERT INTO syls_vpl VALUES ("RV19_19","096_19_19","REV","19","19","19","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠅꠃ ꠊꠥꠠꠣꠔ ꠎꠦꠁꠘ ꠍꠅꠀꠞ ꠅꠁꠍꠂꠘ, ꠄꠘ ꠟꠉꠦ ꠀꠞ ꠄꠘ ꠍꠤꠙꠣꠁ ꠖꠟꠞ ꠟꠉꠦ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠢꠃ ꠎꠣꠘꠥꠀꠞ, ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀꠞ ꠞꠣꠎꠣ ꠅꠇꠟ, ꠔꠣꠞꠣꠞ ꠡꠂꠘ꠆ꠘ-ꠍꠤꠙꠣꠁ ꠖꠟ ꠟꠁꠀ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠅꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV19_20","096_19_20","REV","19","20","20","ꠔꠦꠃ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠗꠞꠤꠀ ꠀꠐꠇ ꠇꠞꠣ ꠅꠁꠟ, ꠀꠞ ꠎꠦ ꠜꠘ꠆ꠒ ꠘꠛꠤꠄ ꠔꠣꠞ ꠙꠇ꠆ꠇ ꠟꠁꠀ ꠀꠌꠣꠘꠇ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠔ, ꠔꠣꠞꠦꠅ ꠗꠞꠣ ꠅꠁꠟ। ꠎꠦꠔꠣ ꠝꠣꠘꠡꠦ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞ ꠡꠤꠟ ꠟꠣꠉꠣꠁꠍꠦ, ꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤꠞ ꠙꠥꠎꠣ ꠇꠞꠍꠦ, ꠅꠃ ꠜꠘ꠆ꠒ ꠘꠛꠤꠄ ꠔꠣꠞ ꠀꠌꠣꠘꠇ ꠇꠣꠝ ꠖꠦꠈꠣꠁꠀ ꠅꠔꠣ ꠝꠣꠘꠡꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠍꠦ। ꠁ ꠖꠥꠁꠅꠐꠣꠞꠦ ꠎꠤꠘ꠆ꠖꠣ ꠢꠣꠟꠔꠦ, ꠎꠣꠟꠣꠁꠟ ꠉꠘ꠆ꠖꠇꠞ ꠀꠉꠥꠘꠤꠞ ꠝꠣꠎꠦ ꠚꠣꠟꠣꠘꠤ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV19_21","096_19_21","REV","19","21","21","ꠢꠃ ꠗꠟꠣ ꠊꠥꠠꠣꠞ ꠃꠙꠞꠦ ꠎꠦꠁꠘ ꠛꠅꠀꠔ ꠀꠍꠟꠣ, ꠔꠣꠘ ꠝꠥꠈ ꠕꠣꠇꠤ ꠎꠦ ꠗꠣꠞꠣꠁꠟ ꠔꠟꠥꠀꠞ ꠛꠣꠞ ꠅꠁꠀ ꠀꠁꠍꠤꠟ, ꠅꠈꠣꠘꠖꠤ ꠔꠣꠞꠣꠞ ꠟꠉꠞ ꠡꠣꠋꠉ-ꠙꠣꠋꠉ ꠅꠇꠟꠞꠦ ꠈꠥꠘ ꠇꠞꠣ ꠅꠁꠟ। ꠄꠞꠟꠣꠉꠤ ꠢꠇꠟ ꠙꠣꠈꠤꠘ꠆ꠔꠦ ꠙꠦꠐ ꠜꠞꠤꠀ ꠅꠔꠣꠞ ꠉꠥꠡ꠆ꠔ ꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV20_1","096_20_1","REV","20","1","1","ꠄꠞꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠛꠦꠢꠦꠡ꠆ꠔ ꠕꠣꠇꠤ ꠄꠇꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠟꠣꠝꠤꠀ ꠀꠁꠞꠣ। ꠔꠣꠘ ꠀꠔꠅ ꠀꠍꠤꠟ ꠢꠣꠛꠤꠀ ꠖꠥꠎꠈꠞ ꠌꠣꠛꠤ, ꠀꠞ ꠈꠥꠛ ꠛꠠ ꠄꠇꠍꠣ ꠟꠋꠉꠞ। ");
INSERT INTO syls_vpl VALUES ("RV20_2","096_20_2","REV","20","2","2","ꠔꠣꠁꠘ ꠢꠃ ꠖꠣꠘꠛꠞꠦ ꠗꠞꠟꠣ, ꠁꠉꠥ ꠅꠁꠟ ꠢꠃ ꠙꠥꠞꠣꠘꠣ ꠢꠣꠚ, ꠄꠞ ꠘꠣꠝ ꠅꠁꠟ ꠁꠛꠟꠤꠍ ꠛꠣ ꠡꠄꠔꠣꠘ। ꠔꠣꠞꠦ ꠗꠞꠤꠀ ꠄꠇ ꠀꠎꠣꠞ ꠛꠍꠞꠞ ꠟꠣꠉꠤ ꠛꠣꠘ꠆ꠖꠤꠟꠣ, ");
INSERT INTO syls_vpl VALUES ("RV20_3","096_20_3","REV","20","3","3","ꠛꠣꠘ꠆ꠖꠤꠀ ꠢꠣꠛꠤꠀ ꠖꠥꠎꠈꠅ ꠚꠣꠟꠣꠁꠟꠣ। ꠛꠣꠖꠦ ꠅꠃ ꠖꠥꠎꠈꠞ ꠖꠥꠀꠞꠅ ꠔꠣꠟꠣ ꠟꠣꠉꠣꠁꠀ ꠄꠞ ꠃꠙꠞꠦ ꠡꠤꠟ-ꠌꠣꠙ꠆ꠙꠠ ꠝꠣꠞꠟꠣ, ꠎꠣꠔꠦ ꠢꠦ ꠅꠃ ꠄꠇ ꠀꠎꠣꠞ ꠛꠞꠍꠞ ꠝꠣꠎꠦ ꠛꠣꠞ ꠅꠁꠀ, ꠖꠥꠘꠤꠀꠞ ꠇꠥꠘꠥ ꠎꠣꠔꠤꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠔ ꠘꠣ ꠙꠣꠞꠦ। ꠢꠦꠡꠦ ꠔꠣꠞꠦ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘꠞ ꠟꠣꠉꠤ ꠍꠣꠠꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV20_4","096_20_4","REV","20","4","4","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠛꠃꠔ ꠔꠈ꠆ꠔ ꠀꠍꠦ। ꠎꠦꠞꠣ ꠅꠃ ꠔꠈ꠆ꠔꠞ ꠃꠙꠞꠦ ꠛꠁꠍꠂꠘ, ꠄꠞꠣꠞꠦ ꠛꠤꠌꠣꠞ ꠇꠞꠣꠞ ꠈꠦꠝꠔꠣ ꠖꠦꠅꠀ ꠅꠁꠍꠦ। ꠀꠟ꠆ꠟꠣꠞ ꠇꠣꠟꠣꠝ ꠀꠞ ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠛꠦꠙꠣꠞꠦ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠦꠅꠀꠄ ꠎꠦꠞꠣꠞꠦ ꠉꠞ꠆ꠖꠣꠘ ꠝꠣꠞꠣ ꠅꠁꠍꠤꠟ, ꠄꠞꠣꠞ ꠞꠥꠢꠥ ꠅꠇꠟꠞꠦꠅ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ। ꠄꠞꠣ ꠢꠃ ꠎꠣꠘꠥꠀꠞꠞꠦ ꠛꠣ ꠔꠣꠞ ꠝꠥꠞ꠆ꠔꠤꠞꠦ ꠙꠥꠎꠣ ꠇꠞꠍꠦ ꠘꠣ, ꠀꠞ ꠀꠔꠅ ꠛꠣ ꠇꠙꠣꠟꠞ ꠃꠙꠞꠦ ꠔꠣꠞ ꠡꠤꠟꠅ ꠟꠣꠉꠣꠁꠍꠦ ꠘꠣ। ꠄꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠟꠣ, ꠃꠑꠤꠀ ꠄꠇ ꠀꠎꠣꠞ ꠛꠍꠞ ꠗꠞꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV20_5","096_20_5","REV","20","5","6","ꠁꠐꠣ ꠅꠁꠟ ꠙꠄꠟꠣ ꠛꠣꠞ ꠝꠥꠞ꠆ꠖꠣ ꠕꠣꠇꠤ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠣ, ꠀꠞ ꠅꠃ ꠎꠦꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠟꠣ ꠔꠣꠞꠣꠃ ꠗꠁꠘ꠆ꠘ ꠀꠞ ꠙꠛꠤꠔ꠆ꠞ। ꠙꠄꠟꠣ ꠛꠣꠞ ꠎꠦꠞꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠀ ꠃꠑꠟꠣ, ꠄꠞꠣꠞ ꠃꠙꠞꠦ ꠔ ꠝꠃꠔꠞ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠇꠥꠘꠥ ꠛꠟ ꠈꠣꠐꠣꠘꠤ ꠌꠟꠔ ꠘꠣꠄ। ꠔꠣꠞꠣ ꠅꠁꠛꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠀꠟ-ꠝꠍꠤꠞ ꠁꠝꠣꠝ। ꠔꠣꠞꠣ ꠢꠃ ꠄꠇ ꠀꠎꠣꠞ ꠛꠍꠞ ꠗꠞꠤ ꠀꠟ-ꠝꠍꠤꠞ ꠟꠉꠦ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠛꠣ। ꠅꠁꠟꠦ ꠅꠃ ꠀꠎꠣꠞ ꠛꠍꠞ ꠚꠥꠠꠣꠘꠤꠞ ꠀꠉ ꠙꠞ꠆ꠎꠘ꠆ꠔ ꠛꠣꠖ-ꠛꠣꠇꠤ ꠇꠥꠘꠥ ꠝꠥꠞ꠆ꠖꠣ ꠎꠤꠘ꠆ꠖꠣ ꠅꠁꠟꠣ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV20_7","096_20_7","REV","20","7","7","ꠅꠃ ꠄꠇ ꠀꠎꠣꠞ ꠛꠍꠞ ꠉꠤꠀ ꠢꠣꠞꠟꠦ ꠡꠄꠔꠣꠘꠞꠦ ꠔꠣꠞ ꠎꠦꠟ ꠈꠣꠘꠣ ꠕꠣꠇꠤ ꠈꠣꠟꠣꠍ ꠖꠦꠅꠀ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV20_8","096_20_8","REV","20","8","8","ꠔꠦꠃ ꠢꠦ ꠉꠤꠀ ꠀꠡ꠆ꠔꠣ ꠎꠉꠔꠞ ꠢꠇꠟ ꠎꠣꠔꠤꠞꠦ, ꠝꠣꠘꠤ ꠁꠀꠎꠥꠎ-ꠝꠣꠎꠥꠎꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠛ, ꠀꠞ ꠎꠥꠖ꠆ꠖ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠔꠣꠞꠣꠞꠦ ꠄꠇꠈꠣꠘꠅ ꠖꠟꠣ ꠇꠞꠛ। ꠔꠣꠞ ꠝꠣꠘꠥꠡ ꠅꠁꠛꠣ, ꠖꠞꠤꠀꠞ ꠌꠞꠞ ꠛꠣꠟꠥꠞ ꠟꠣꠈꠣꠘ, ꠁꠔꠣ ꠉꠘꠤꠀ ꠚꠥꠠꠣꠘꠤ ꠎꠣꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV20_9","096_20_9","REV","20","9","9","ꠅꠃ ꠡꠝꠄ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠔꠣꠞꠣ ꠀꠡ꠆ꠔꠣ ꠖꠥꠘꠤꠀ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁ ꠉꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠞꠅꠀꠞ ꠎꠣꠉꠣ, ꠀꠟ꠆ꠟꠣꠞ ꠝꠣꠄꠀꠞ ꠐꠣꠃꠘꠞꠦ ꠉꠤꠀ ꠛꠦꠞꠤꠟꠤꠟ। ꠅꠁꠟꠦ ꠀꠍꠝꠣꠘ ꠕꠣꠇꠤ ꠀꠟ꠆ꠟꠣꠁ ꠀꠉꠥꠁꠘ ꠟꠣꠝꠤꠀ ꠁꠔꠣꠞꠦ ꠎꠣꠟꠣꠁꠟꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV20_10","096_20_10","REV","20","10","10","ꠀꠞ ꠎꠦ ꠁꠛꠟꠤꠍꠦ ꠄꠞꠣꠞꠦ ꠛꠦ-ꠙꠕꠤ ꠛꠣꠘꠣꠁꠍꠤꠟ, ꠔꠣꠞꠦ ꠗꠞꠤꠀ ꠎꠣꠟꠣꠁꠟ ꠉꠘ꠆ꠖꠇꠞ ꠀꠉꠥꠘꠤꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠟ। ꠢꠃ ꠎꠣꠘꠥꠀꠞ ꠀꠞ ꠜꠘ꠆ꠒ ꠘꠛꠤꠞꠦ ꠀꠉꠦꠃ ꠅꠃ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠍꠤꠟ। ꠢꠘꠅ ꠔꠣꠞꠣ ꠌꠤꠞꠇꠣꠟ ꠞꠁꠛꠣ, ꠀꠞ ꠖꠤꠘꠦ-ꠞꠣꠁꠔꠦ ꠎꠣꠟꠣ-ꠎꠘꠔ꠆ꠞꠘꠣꠞ ꠀꠎꠣꠛ ꠙꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV20_11","096_20_11","REV","20","11","11","ꠛꠣꠖꠦ ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠛꠠ ꠄꠇꠈꠣꠘ ꠗꠟꠣ ꠔꠈ꠆ꠔ, ꠅꠃ ꠔꠈ꠆ꠔꠅ ꠄꠇꠎꠘ ꠛꠅꠀꠔ ꠀꠍꠂꠘ। ꠔꠣꠘ ꠍꠣꠝꠘꠣ ꠕꠣꠇꠤ ꠀꠍꠝꠣꠘ ꠀꠞ ꠖꠥꠘꠤꠀ ꠜꠣꠉꠤ ꠉꠦꠟ, ꠇꠥꠘꠥꠈꠣꠘꠅ ꠄꠞꠣꠞ ꠎꠣꠉꠣ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV20_12","096_20_12","REV","20","12","12","ꠄꠞꠛꠣꠖꠦ ꠖꠦꠈꠟꠣꠝ, ꠢꠥꠞꠥ-ꠛꠠ ꠔꠣꠝꠣꠝ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠅꠃ ꠔꠈ꠆ꠔꠞ ꠍꠣꠝꠘꠦ ꠃꠛꠣꠁ ꠞꠁꠍꠂꠘ। ꠛꠣꠖꠦ ꠇꠄꠈꠣꠘ ꠈꠣꠔꠣ ꠈꠥꠟꠣ ꠅꠁꠟ, ꠄꠞꠛꠣꠖꠦ ꠀꠞꠅ ꠄꠇꠈꠣꠘ ꠈꠣꠔꠣ ꠈꠥꠟꠣ ꠅꠁꠟ, ꠁꠈꠣꠘꠞ ꠘꠣꠝ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠣꠔꠣ। ꠅꠃ ꠈꠣꠔꠣ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠢꠃ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟꠞ ꠎꠦꠔꠣ ꠀꠝꠟ-ꠘꠣꠝꠣ ꠟꠦꠈꠣ ꠅꠁꠍꠤꠟ, ꠢꠃ ꠀꠝꠟ ꠝꠣꠚꠤꠇ ꠔꠣꠞꠣꠞ ꠀꠈꠦꠞꠤ ꠛꠤꠌꠣꠞ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV20_13","096_20_13","REV","20","13","13","ꠖꠞꠤꠀꠞ ꠝꠣꠎꠦ ꠎꠔ ꠝꠥꠞ꠆ꠖꠣ ꠅꠇꠟ ꠀꠍꠟꠣ, ꠖꠞꠤꠀꠄ ꠄꠞꠣꠞ ꠟꠣꠡ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠟ। ꠀꠞ ꠝꠃꠔ ꠀꠞ ꠇꠄꠛꠞꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠝꠥꠞ꠆ꠖꠣꠁꠘ ꠀꠍꠟꠣ, ꠝꠃꠔ ꠀꠞ ꠇꠄꠛꠞꠦ ꠔꠣꠞꠣꠞꠦ ꠛꠣꠞ ꠇꠞꠤ ꠖꠤꠟ। ꠙꠞꠔꠦꠇ ꠎꠘꠞꠦ ꠔꠣꠞ ꠘꠤꠎꠞ ꠀꠝꠟ-ꠘꠣꠝꠣ ꠝꠣꠚꠤꠇ ꠛꠤꠌꠣꠞ ꠇꠞꠣ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV20_14","096_20_14","REV","20","14","14","ꠢꠦꠡꠦ ꠝꠃꠔ ꠀꠞ ꠇꠄꠛꠞꠞꠦꠅ ꠀꠉꠥꠘꠤꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠟ। ꠅꠃ ꠀꠉꠥꠘꠤꠞ ꠉꠣꠔꠅ ꠙꠠꠣꠃ ꠅꠁꠟ ꠖꠥꠍꠞꠣꠛꠣꠞ ꠝꠃꠔ ꠝꠣꠘꠤ, ꠀꠈꠦꠞꠤ ꠝꠃꠔ। ");
INSERT INTO syls_vpl VALUES ("RV20_15","096_20_15","REV","20","15","15","ꠎꠦꠞꠣꠞ ꠘꠣꠝ ꠢꠃ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠣꠔꠣꠔ ꠝꠤꠟꠟ ꠘꠣ, ꠔꠣꠞꠣꠞꠦꠃ ꠀꠉꠥꠘꠤꠞ ꠉꠣꠔꠅ ꠚꠣꠟꠣꠁꠟ ꠅꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV21_1","096_21_1","REV","21","1","1","ꠛꠣꠖꠦ ꠀꠝꠤ ꠄꠇꠈꠣꠘ ꠘꠄꠀ ꠀꠍꠝꠣꠘ ꠀꠞ ꠘꠄꠀ ꠎꠝꠤꠘ ꠖꠦꠈꠟꠣꠝ। ꠙꠄꠟꠣ ꠀꠍꠝꠣꠘ ꠀꠞ ꠙꠄꠟꠣ ꠎꠝꠤꠘ ꠝꠤꠟꠣꠁ ꠉꠦꠍꠦ, ꠇꠥꠘꠥ ꠖꠞꠤꠀꠅ ꠀꠞ ꠞꠁꠟ ꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV21_2","096_21_2","REV","21","2","2","ꠀꠝꠤ ꠖꠦꠈꠟꠣꠝ, ꠢꠃ ꠙꠛꠤꠔ꠆ꠞ ꠐꠣꠃꠘ, ꠝꠣꠘꠤ ꠘꠄꠀ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ। ꠁꠈꠣꠘ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠞ। ꠇꠥꠘꠥ ꠛꠤꠀꠞ ꠇꠁꠘꠣꠞꠦ ꠎꠦꠟꠣ ꠖꠣꠝꠣꠘ꠆ꠖꠞ ꠟꠣꠉꠤ ꠢꠣꠎꠣꠁꠟ ꠅꠄ, ꠅꠃ ꠐꠣꠃꠘꠞꠦꠅ ꠅꠟꠣ ꠡꠥꠘ꠆ꠖꠞ ꠇꠞꠤ ꠢꠣꠎꠣꠁꠟ ꠅꠁꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV21_3","096_21_3","REV","21","3","3","ꠛꠣꠖꠦ ꠀꠝꠤ ꠢꠥꠘꠟꠣꠝ, ꠢꠃ ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠔꠈ꠆ꠔꠅ ꠕꠣꠇꠤ ꠄꠇꠎꠘꠦ ꠎꠥꠞꠦ ꠎꠥꠞꠦ ꠇꠁꠞꠣ, “ꠅꠈꠘ ꠝꠣꠘꠡꠞ ꠝꠣꠎꠦ ꠞꠅꠀꠞ ꠟꠣꠉꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞ ꠎꠣꠉꠣ ꠅꠁꠍꠦ। ꠔꠣꠁꠘ ꠝꠣꠘꠡꠞ ꠟꠉꠦ ꠛꠡꠔ ꠇꠞꠛꠣ, ꠀꠞ ꠔꠣꠞꠣ ꠅꠁꠛꠣ ꠔꠣꠘ ꠛꠘ꠆ꠖꠣ। ꠔꠣꠁꠘ ꠡ꠆ꠛꠄꠅꠋ ꠔꠣꠞꠣꠞ ꠟꠉꠦ ꠞꠁꠛꠣ, ꠔꠣꠞꠣꠞ ꠀꠟ꠆ꠟꠣ ꠅꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV21_4","096_21_4","REV","21","4","4","ꠔꠣꠁꠘ ꠄꠞꠣꠞ ꠌꠈꠥꠞ ꠙꠣꠘꠤ ꠚꠥꠍꠤꠀ ꠖꠤꠛꠣ। ꠀꠞ ꠇꠥꠘꠥ ꠝꠞꠘ ꠅꠁꠔ ꠘꠣꠄ, ꠖꠥꠈ, ꠇꠣꠘ꠆ꠖꠘ, ꠇꠡ꠆ꠐ ꠀꠞ ꠞꠁꠔ ꠘꠣꠄ, ꠀꠉꠞ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠃ ꠡꠦꠡ ꠅꠁꠉꠦꠍꠦ।” ");
INSERT INTO syls_vpl VALUES ("RV21_5","096_21_5","REV","21","5","5","ꠔꠈ꠆ꠔꠅ ꠎꠦꠁꠘ ꠛꠅꠀꠔ ꠀꠍꠟꠣ ꠔꠣꠁꠘ ꠇꠁꠟꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠢꠇ꠆ꠇꠟꠔꠣꠞꠦ ꠘꠄꠀ ꠇꠞꠤ ꠙꠄꠖꠣ ꠇꠞꠤꠀꠞ।” ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠢꠤꠞꠛꠣꠞ ꠇꠁꠟꠣ, “ꠀꠝꠣꠞ ꠅꠃ ꠇꠕꠣꠈꠣꠘ ꠟꠦꠈꠅ, ꠇꠣꠞꠘ ꠁꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠣꠞ ꠟꠣꠈ ꠢꠣꠍꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV21_6","096_21_6","REV","21","6","6","ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠄꠅꠈꠣꠘ ꠇꠁꠟꠣ, “ꠡꠦꠡ ꠅꠁꠉꠦꠍꠦ। ꠀꠝꠤꠃ ꠀꠟꠤꠚ ꠀꠞ ꠁꠀ, ꠀꠃꠀꠟ ꠀꠞ ꠀꠈꠦꠞ। ꠢꠥꠘꠅ, ꠎꠣꠞ ꠙꠣꠘꠤꠞ ꠙꠤꠀꠍꠦ ꠗꠞꠍꠦ, ꠔꠣꠞꠦ ꠀꠝꠤ ꠀꠛꠦ-ꠢꠣꠄꠀꠔꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠙꠣꠘꠤꠞ ꠏꠞꠘꠣ ꠕꠣꠇꠤ ꠛꠤꠘꠣ ꠙꠄꠡꠣꠄ ꠙꠣꠘꠤ ꠖꠤꠝꠥ। ");
INSERT INTO syls_vpl VALUES ("RV21_7","096_21_7","REV","21","7","7","ꠎꠦ ꠎꠘ ꠎꠄꠁ ꠅꠁꠛ, ꠢꠦ ꠁꠔꠣ ꠢꠇꠟꠔꠣꠞ ꠅꠗꠤꠇꠣꠞ ꠙꠣꠁꠛ। ꠀꠝꠤ ꠅꠁꠝꠥ ꠔꠣꠞ ꠀꠟ꠆ꠟꠣ, ꠀꠞ ꠢꠦ ꠅꠁꠛ ꠀꠝꠣꠞ ꠙꠥꠔ। ");
INSERT INTO syls_vpl VALUES ("RV21_8","096_21_8","REV","21","8","8","ꠅꠁꠟꠦ ꠇꠣ-ꠙꠥꠞꠥꠡ, ꠛꠦꠁꠝꠣꠘ, ꠢꠣꠞꠣꠝꠈꠥꠞ, ꠈꠥꠘꠤ, ꠎꠤꠘꠣꠇꠥꠞ, ꠎꠣꠖꠥꠉꠤꠞ, ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠇꠞꠞꠣ, ꠀꠞ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣ ꠅꠇꠟ ꠎꠣꠟꠣꠁꠟ ꠀꠉꠥꠁꠘ ꠀꠞ ꠉꠘ꠆ꠖꠇꠞ ꠉꠣꠔꠅ ꠞꠁꠛꠣ। ꠄꠞ ꠘꠣꠝꠃ ꠅꠁꠟ ꠖꠥꠍꠞꠣꠛꠣꠞꠞ ꠝꠃꠔ।” ");
INSERT INTO syls_vpl VALUES ("RV21_9","096_21_9","REV","21","9","9","ꠢꠃ ꠎꠦ ꠡꠣꠔꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞ ꠀꠔꠅ ꠀꠈꠦꠞꠤ ꠡꠣꠔꠅ ꠉꠎꠛ ꠜꠞꠣ ꠡꠣꠔꠐꠣ ꠛꠣꠐꠤ ꠀꠍꠤꠟ, ꠄꠞꠣꠞ ꠝꠣꠎꠞ ꠄꠇꠎꠘꠦ ꠀꠝꠣꠞ ꠇꠣꠘ꠆ꠖꠣꠔ ꠀꠁꠀ ꠇꠁꠟꠣ, “ꠀꠅ, ꠀꠝꠤ ꠔꠥꠝꠣꠞꠦ ꠇꠁꠘꠣ-ꠛꠦꠐꠤ ꠖꠦꠈꠣꠁꠝꠥ, ꠝꠣꠘꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠛꠃꠞꠦ ꠖꠦꠈꠣꠁꠝꠥ।” ");
INSERT INTO syls_vpl VALUES ("RV21_10","096_21_10","REV","21","10","10","ꠛꠣꠖꠦ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠞꠥꠢꠣꠘꠤ ꠢꠣꠟꠔꠦ ꠀꠝꠣꠞꠦ ꠛꠠ ꠄꠇ ꠃꠌꠣ ꠙꠣꠠꠞ ꠃꠙꠞꠦ ꠟꠁꠀ ꠉꠦꠟꠣ। ꠘꠤꠀ ꠀꠟ꠆ꠟꠣꠞ ꠝꠢꠤꠝꠣꠄ ꠌꠇꠌꠇꠣ ꠎꠦ ꠙꠛꠤꠔ꠆ꠞ ꠎꠦꠞꠥꠎꠣꠟꠦꠝ ꠐꠣꠃꠘ, ꠛꠦꠢꠦꠡ꠆ꠔꠞ ꠝꠣꠎ ꠕꠣꠇꠤ ꠀꠞ ꠀꠟ꠆ꠟꠣꠞ ꠖꠞꠛꠣꠞꠅ ꠕꠣꠇꠤ ꠟꠣꠝꠤꠀ ꠀꠅꠀꠔ ꠀꠍꠤꠟ, ꠅꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠅꠔꠣ ꠖꠦꠈꠣꠁꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV21_11","096_21_11","REV","21","11","11","ꠁ ꠐꠣꠃꠘꠞ ꠞꠋ ꠈꠥꠛ ꠖꠣꠝꠤ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣꠞ ꠟꠣꠈꠣꠘ ꠌꠇꠌꠇꠣ, ꠚꠐꠤꠇꠞ ꠉ꠆ꠟꠣꠡꠞ ꠘꠝꠥꠘꠣꠄ ꠖꠣꠝꠤ ꠢꠤꠞꠣꠞ ꠟꠣꠈꠣꠘ। ");
INSERT INTO syls_vpl VALUES ("RV21_12","096_21_12","REV","21","12","12","ꠢꠃ ꠐꠣꠃꠘꠅ ꠛꠠ ꠄꠇꠈꠣꠘ ꠃꠌꠣ ꠅꠀꠟ ꠀꠍꠤꠟ, ꠅꠃ ꠅꠀꠟꠅ ꠛꠣꠞꠅꠈꠣꠘ ꠉꠦꠁꠐ ꠀꠍꠤꠟ, ꠛꠣꠞꠅ ꠉꠦꠁꠐꠅ ꠛꠣꠞꠅꠎꠘ ꠚꠤꠞꠤꠡ꠆ꠔꠣ ꠀꠍꠟꠣ। ꠅꠃ ꠉꠦꠁꠐꠞ ꠃꠙꠞꠦ ꠛꠘꠤ ꠁꠍꠞꠣꠁꠟꠞ ꠛꠣꠞꠅ ꠈꠣꠘ꠆ꠖꠣꠘꠞ ꠘꠣꠝ ꠟꠦꠈꠣ। ");
INSERT INTO syls_vpl VALUES ("RV21_13","096_21_13","REV","21","13","13","ꠁ ꠉꠦꠁꠐꠞ ꠔꠤꠘꠈꠣꠘ ꠙꠥꠛꠦꠖꠤ, ꠔꠤꠘꠈꠣꠘ ꠃꠔꠞꠦꠖꠤ, ꠔꠤꠘꠈꠣꠘ ꠖꠃꠇꠘꠦꠖꠤ ꠀꠞ ꠔꠤꠘꠈꠣꠘ ꠙꠁꠌꠝꠦꠖꠤ ꠀꠍꠤꠟ। ");
INSERT INTO syls_vpl VALUES ("RV21_14","096_21_14","REV","21","14","14","ꠁ ꠐꠣꠃꠘꠞ ꠅꠀꠟꠞ ꠛꠣꠞꠅꠐꠣ ꠙꠤꠟꠣꠞ ꠀꠍꠤꠟ, ꠁꠔꠣꠞ ꠃꠙꠞꠦ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠛꠣꠞꠅꠎꠘ ꠍꠣꠢꠣꠛꠤꠞ ꠛꠣꠞꠅꠈꠣꠘ ꠘꠣꠝ ꠟꠦꠈꠣ। ");
INSERT INTO syls_vpl VALUES ("RV21_15","096_21_15","REV","21","15","15","ꠀꠝꠣꠞ ꠟꠉꠦ ꠎꠦꠁꠘ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠣꠔ ꠀꠍꠟꠣ ꠔꠣꠘ ꠀꠔꠅ ꠡꠥꠘꠣꠞ ꠄꠇꠐꠣ ꠘꠟ ꠀꠍꠤꠟ, ꠎꠣꠔꠦ ꠔꠣꠁꠘ ꠅꠃ ꠐꠣꠃꠘ, ꠐꠣꠃꠘꠞ ꠉꠦꠁꠐ ꠀꠞ ꠅꠀꠟ ꠝꠣꠙꠤꠔꠣ ꠙꠣꠞꠂꠘ। ");
INSERT INTO syls_vpl VALUES ("RV21_16","096_21_16","REV","21","16","16","ꠁ ꠐꠣꠃꠘ ꠀꠍꠤꠟ ꠌꠣꠁꠞꠇꠥꠘꠤ ꠉꠥꠟ, ꠟꠣꠝ꠆ꠛꠣꠄ ꠀꠞ ꠚꠣꠠꠦ ꠡꠝꠣꠘ। ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠃ ꠘꠟꠖꠤ ꠐꠣꠃꠘꠈꠣꠘ ꠝꠣꠙꠤꠟꠦ, ꠁꠈꠣꠘ ꠟꠣꠝ꠆ꠛꠣ, ꠚꠣꠠ ꠀꠞ ꠃꠌꠣꠄ ꠅꠁꠟ ꠛꠣꠞꠅ ꠀꠎꠣꠞ ꠡ꠆ꠔꠣꠖꠤꠀ (ꠅꠘꠥꠝꠣꠘ ꠖꠦꠠ ꠀꠎꠣꠞ ꠝꠣꠁꠟ)। ");
INSERT INTO syls_vpl VALUES ("RV21_17","096_21_17","REV","21","17","17","ꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠅꠀꠟ ꠝꠣꠙꠤꠟꠣ, ꠁ ꠅꠀꠟ ꠀꠍꠤꠟ ꠄꠇ-ꠡ ꠌꠃꠌꠣꠟ꠆ꠟꠤꠡ ꠀꠔ ꠃꠌꠣ। ꠝꠣꠘꠡꠞ ꠀꠔꠞ ꠝꠣꠙꠞ ꠟꠣꠈꠣꠘ ꠁ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄꠅ ꠝꠣꠙꠤꠟꠣ। ");
INSERT INTO syls_vpl VALUES ("RV21_18","096_21_18","REV","21","18","18","ꠁ ꠅꠀꠟꠈꠣꠘ ꠢꠤꠞꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ, ꠀꠞ ꠁ ꠐꠣꠃꠘ ꠀꠍꠤꠟ ꠚꠐꠤꠇꠞ ꠉ꠆ꠟꠣꠡꠞ ꠟꠣꠈꠣꠘ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV21_19","096_21_19","REV","21","19","19","ꠐꠣꠃꠘꠞ ꠅꠀꠟꠞ ꠙꠤꠟꠣꠞ ꠅꠇꠟꠞ ꠝꠣꠎꠦ ꠖꠣꠝꠤ ꠖꠣꠝꠤ ꠝꠘꠤ-ꠝꠥꠇ꠆ꠔꠣ ꠟꠣꠉꠣꠁꠟ ꠀꠍꠤꠟ। ꠙꠄꠟꠣ ꠙꠤꠟꠣꠞ ꠢꠤꠞꠣꠞ, ꠖꠥꠍꠞꠣꠐꠣ ꠀꠇꠤꠇ ꠝꠘꠤꠞ, ꠔꠤꠘ ꠘꠝ꠆ꠛꠞꠐꠣ ꠔꠣꠝꠣ ꠝꠘꠤ, ꠌꠣꠁꠞ ꠘꠝ꠆ꠛꠞꠐꠣ ꠙꠣꠘ꠆ꠘꠣ ꠝꠘꠤ, ");
INSERT INTO syls_vpl VALUES ("RV21_20","096_21_20","REV","21","20","20","ꠙꠣꠌ ꠘꠝ꠆ꠛꠞꠐꠣ ꠡꠥꠞꠥꠎ ꠝꠘꠤ, ꠍꠄ ꠘꠝ꠆ꠛꠞꠐꠣ ꠁꠀꠇꠥꠔ ꠝꠘꠤ, ꠡꠣꠔ ꠘꠝ꠆ꠛꠞꠐꠣ ꠟꠤꠟ ꠝꠘꠤ, ꠀꠐ ꠘꠝ꠆ꠛꠞꠐꠣ ꠛꠂꠖꠥꠞ꠆ꠎ ꠝꠘꠤ, ꠘꠄ ꠘꠝ꠆ꠛꠞꠐꠣ ꠙꠤꠔ ꠝꠘꠤ, ꠖꠡ ꠘꠝ꠆ꠛꠞꠐꠣ ꠃꠙꠟ ꠝꠘꠤ, ꠄꠉꠣꠞꠅ ꠘꠝ꠆ꠛꠞꠐꠣ ꠚꠤꠞꠥꠎ ꠝꠘꠤ, ꠀꠞ ꠛꠣꠞꠅ ꠘꠝ꠆ꠛꠞꠐꠣ ꠙꠖ꠆ꠖꠞꠣꠉ ꠝꠘꠤ। ");
INSERT INTO syls_vpl VALUES ("RV21_21","096_21_21","REV","21","21","21","ꠛꠣꠞꠅꠈꠣꠘ ꠉꠦꠁꠐ ꠛꠣꠞꠅꠐꠣ ꠝꠥꠇ꠆ꠔꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ। ꠙꠞꠔꠦꠇ ꠉꠦꠁꠐ ꠀꠍꠤꠟ ꠄꠇꠅꠐꠣ ꠖꠣꠝꠤ ꠝꠥꠇ꠆ꠔꠣꠞ। ꠐꠣꠃꠘꠞ ꠞꠣꠡ꠆ꠔꠣ ꠀꠍꠤꠟ ꠚꠐꠤꠇꠞ ꠉ꠆ꠟꠣꠡꠞ ꠟꠣꠈꠣꠘ ꠈꠣꠐꠤ ꠡꠥꠘꠣꠖꠤ ꠛꠣꠘꠣꠁꠟ। ");
INSERT INTO syls_vpl VALUES ("RV21_22","096_21_22","REV","21","22","22","ꠁ ꠐꠣꠃꠘꠅ ꠀꠝꠤ ꠇꠥꠘꠥ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ ꠖꠦꠈꠟꠣꠝ ꠘꠣ, ꠡꠞ꠆ꠛ-ꠡꠇ꠆ꠔꠤꠝꠣꠘ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠃ ꠀꠍꠟꠣ ꠁꠘꠞ ꠄꠛꠣꠖꠔ ꠈꠣꠘꠣ। ");
INSERT INTO syls_vpl VALUES ("RV21_23","096_21_23","REV","21","23","23","ꠁ ꠐꠣꠃꠘꠞꠦ ꠚꠞ ꠇꠞꠣꠞ ꠟꠣꠉꠤ ꠇꠥꠘꠥ ꠌꠣꠘ-ꠡꠥꠞꠥꠎꠞ ꠎꠞꠥꠞ ꠘꠣꠁ। ꠀꠟ꠆ꠟꠣꠞ ꠘꠥꠞꠞ ꠝꠢꠤꠝꠣꠄ ꠚꠞ ꠖꠦꠄ, ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠃ ꠅꠁꠟꠣ ꠁꠘꠞ ꠛꠣꠔ꠆ꠔꠤ। ");
INSERT INTO syls_vpl VALUES ("RV21_24","096_21_24","REV","21","24","24","ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠥꠡ ꠅꠃ ꠘꠥꠞꠞ ꠚꠞꠦ ꠌꠟꠣ-ꠚꠤꠞꠣ ꠇꠞꠛꠣ, ꠖꠥꠘꠤꠀꠞ ꠛꠣꠖꠡꠣ ꠅꠇꠟꠦ ꠔꠣꠞꠣꠞ ꠎꠣꠇ-ꠎꠝꠇ ꠟꠁꠀ ꠅꠃ ꠐꠣꠃꠘꠅ ꠀꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV21_25","096_21_25","REV","21","25","25","ꠖꠤꠘꠞ ꠛꠣꠟꠣ ꠇꠥꠘꠥ ꠡꠝꠄꠃ ꠁ ꠐꠣꠃꠘꠞ ꠉꠦꠁꠐ ꠛꠘ꠆ꠖ ꠅꠁꠔ ꠘꠣꠄ, ꠀꠞ ꠢꠤꠘꠅ ꠇꠥꠘꠥ ꠞꠣꠁꠔ ꠅꠁꠔ ꠘꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV21_26","096_21_26","REV","21","26","26","ꠔꠣꠝꠣꠝ ꠎꠣꠔꠤꠞ ꠁꠎ꠆ꠎꠔ ꠀꠞ ꠉꠃꠞꠛ ꠅꠘꠅ ꠀꠘꠣ ꠅꠁꠛ। ");
INSERT INTO syls_vpl VALUES ("RV21_27","096_21_27","REV","21","27","27","ꠘꠣꠙꠣꠇ ꠇꠥꠘꠥ ꠌꠤꠎ, ꠢꠣꠞꠣꠝꠈꠥꠞ ꠛꠣ ꠝꠤꠍꠣ ꠝꠣꠔꠞꠣ ꠇꠥꠘꠥ ꠝꠣꠘꠥꠡ, ꠇꠥꠘꠥꠖꠤꠘꠅ ꠁꠘꠅ ꠢꠣꠝꠣꠁꠔ ꠙꠣꠞꠔ ꠘꠣꠄ। ꠈꠣꠟꠤ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠈꠣꠔꠣꠞ ꠝꠣꠎꠦ ꠎꠦꠞꠣꠞ ꠘꠣꠝ ꠟꠦꠈꠣ ꠀꠍꠦ, ꠔꠣꠞꠣꠃ ꠢꠣꠝꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV22_1","096_22_1","REV","22","1","1","ꠄꠞꠛꠣꠖꠦ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠀꠛꠦ-ꠢꠣꠄꠀꠔ, ꠝꠣꠘꠤ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠙꠣꠘꠤꠞ ꠉꠣꠋ ꠖꠦꠈꠣꠁꠟꠣ। ꠁꠇꠐꠣ ꠖꠦꠈꠔꠦ ꠌꠇꠌꠇꠣ ꠇꠣꠌꠞ ꠟꠣꠈꠣꠘ। ꠁꠐꠣ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠢꠃ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠔꠈ꠆ꠔꠞ ꠗꠣꠞꠅ ꠕꠣꠇꠤ ꠛꠣꠞ ꠅꠁꠀ, ");
INSERT INTO syls_vpl VALUES ("RV22_2","096_22_2","REV","22","2","2","ꠐꠣꠃꠘꠞ ꠛꠠ ꠉꠟ꠆ꠟꠤꠞ ꠝꠣꠎꠈꠣꠘꠦꠖꠤ ꠎꠣꠅꠀꠔ ꠀꠍꠤꠟ। ꠀꠞ ꠅꠃ ꠉꠣꠋꠉꠞ ꠖꠥꠁꠅ ꠙꠣꠞꠅ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠉꠣꠍ ꠀꠍꠤꠟ। ꠅꠃ ꠉꠣꠍꠣꠁꠘ꠆ꠔꠅ ꠛꠣꠞꠅ ꠎꠣꠔꠞ ꠚꠟ ꠗꠞꠦ। ꠙꠞꠔꠦꠇ ꠝꠣꠡꠦ ꠝꠣꠡꠦ ꠚꠟ ꠗꠞꠦ, ꠅꠃ ꠉꠣꠍꠞ ꠙꠣꠔꠣꠄ ꠢꠇꠟ ꠎꠣꠔꠤꠞ ꠝꠣꠘꠡꠞ ꠛꠦꠝꠣꠞ ꠡꠤꠚꠣ ꠅꠄ। ");
INSERT INTO syls_vpl VALUES ("RV22_3","096_22_3","REV","22","3","3","ꠇꠥꠘꠥꠎꠣꠔ ꠟꠣꠘ꠆ꠘꠔ ꠀꠞ ꠞꠁꠔ ꠘꠣꠄ। ꠀꠟ꠆ꠟꠣ ꠙꠣꠇ ꠀꠞ ꠝꠦꠠꠣ-ꠛꠣꠁꠌ꠆ꠌꠣꠞ ꠔꠈ꠆ꠔ ꠅꠃ ꠐꠣꠃꠘꠅ ꠞꠁꠛ, ꠀꠞ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠦ ꠔꠣꠘ ꠄꠛꠣꠖꠔ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV22_4","096_22_4","REV","22","4","4","ꠔꠣꠞꠣ ꠔꠣꠘ ꠙꠛꠤꠔ꠆ꠞ ꠝꠥꠈ ꠖꠦꠈꠛꠣ, ꠔꠣꠞꠣꠞ ꠇꠙꠣꠟꠅ ꠔꠣꠘ ꠘꠣꠝ ꠟꠦꠈꠣ ꠕꠣꠇꠛ। ");
INSERT INTO syls_vpl VALUES ("RV22_5","096_22_5","REV","22","5","5","ꠀꠞ ꠇꠥꠘꠥ ꠞꠣꠁꠔ ꠅꠁꠔ ꠘꠣꠄ, ꠔꠣꠞꠣꠞ ꠟꠣꠉꠤ ꠟꠦꠝꠞ ꠛꠣ ꠡꠥꠞꠥꠎꠞ ꠚꠞꠞ ꠎꠞꠥꠞ ꠅꠁꠔ ꠘꠣꠄ, ꠇꠣꠞꠘ ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖꠞ ꠘꠥꠞꠃ ꠅꠁꠛ ꠔꠣꠞꠣꠞ ꠚꠞ। ꠔꠣꠞꠣ ꠢꠞ-ꠢꠣꠝꠦꠡꠣ ꠌꠤꠞꠇꠣꠟ ꠗꠞꠤ ꠛꠣꠖꠡꠣꠁ ꠇꠞꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV22_6","096_22_6","REV","22","6","6","ꠛꠣꠖꠦ ꠢꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠁꠔꠣ ꠢꠇꠟꠔꠣ ꠄꠇꠤꠘ ꠇꠞꠣꠞ ꠟꠣꠈ ꠢꠣꠍꠣ। ꠀꠟ꠆ꠟꠣ ꠝꠣꠛꠥꠖ, ꠎꠦꠁꠘ ꠀꠉꠦ ꠔꠣꠘ ꠘꠛꠤ ꠅꠇꠟꠞ ꠝꠣꠎꠖꠤ ꠛꠣꠔꠌꠤꠔ ꠇꠞꠍꠂꠘ, ꠔꠣꠁꠘ ꠘꠤꠎꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠖꠤꠍꠂꠘ, ꠎꠣꠔꠦ ꠕꠥꠠꠣ ꠇꠄꠖꠤꠘꠞ ꠝꠣꠎꠦ ꠎꠦꠔꠣ ꠊꠐꠤꠛ, ꠅꠃ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠁꠔꠣ ꠔꠣꠘ ꠉꠥꠟꠣꠝ ꠅꠇꠟꠞꠦ ꠖꠦꠈꠣꠁꠘ।” ");
INSERT INTO syls_vpl VALUES ("RV22_7","096_22_7","REV","22","7","7","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠞꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠈꠥꠛ ꠎꠟꠖꠤꠃ ꠀꠁꠞꠣꠝ। ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠇꠤꠔꠣꠛꠞ ꠢꠇꠟ ꠀꠄꠀꠔꠞ ꠀꠉꠣꠝ ꠈꠛꠞ ꠀꠝꠟ ꠇꠞꠦ, ꠢꠦ-ꠃ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ।” ");
INSERT INTO syls_vpl VALUES ("RV22_8","096_22_8","REV","22","8","8","ꠔꠦ ꠁꠍꠣ ꠀꠟ-ꠝꠍꠤꠞ ꠍꠣꠢꠣꠛꠤ ꠀꠝꠤ ꠢꠣꠘ꠆ꠘꠣꠘꠦ ꠁꠔꠣ ꠖꠦꠈꠍꠤ ꠀꠞ ꠢꠥꠘꠍꠤ। ꠢꠇꠟꠔꠣ ꠢꠥꠘꠣ ꠀꠞ ꠖꠦꠈꠣꠞ ꠛꠣꠖꠦ, ꠎꠦ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠄ ꠀꠝꠣꠞꠦ ꠁꠔꠣ ꠖꠦꠈꠣꠁꠍꠂꠘ, ꠀꠝꠤ ꠔꠣꠘꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠣꠞ ꠘꠤꠅꠔꠦ ꠔꠣꠘ ꠙꠣꠅ-ꠅ ꠙꠠꠟꠣꠝ। ");
INSERT INTO syls_vpl VALUES ("RV22_9","096_22_9","REV","22","9","9","ꠅꠁꠟꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠘꠣ, ꠘꠣ! ꠔꠥꠝꠤ ꠀꠝꠣꠞꠦ ꠘꠣꠄ, ꠈꠣꠟꠤ ꠀꠟ꠆ꠟꠣ ꠙꠣꠇꠞꠦ ꠍꠁꠎꠖꠣ ꠇꠞꠅ। ꠀꠝꠤ ꠔ ꠈꠣꠟꠤ ꠔꠥꠝꠣꠞ ꠟꠣꠈꠣꠘ ꠉꠥꠟꠣꠝ, ꠔꠥꠝꠣꠞ ꠜꠣꠁꠀꠁꠘ ꠝꠣꠘꠤ ꠘꠛꠤ ꠅꠇꠟꠞ ꠟꠣꠈꠣꠘ ꠀꠞ ꠁ ꠇꠤꠔꠣꠛꠞ ꠢꠇꠟ ꠀꠄꠀꠔ ꠎꠦꠞꠣ ꠝꠣꠘꠦ, ꠔꠣꠞꠣꠞ ꠟꠣꠈꠣꠘꠃ ꠉꠥꠟꠣꠝ।” ");
INSERT INTO syls_vpl VALUES ("RV22_10","096_22_10","REV","22","10","10","ꠄꠞꠛꠣꠖꠦ ꠔꠣꠁꠘ ꠀꠝꠣꠞꠦ ꠇꠁꠟꠣ, “ꠅꠃ ꠇꠤꠔꠣꠛꠞ ꠇꠥꠘꠥ ꠀꠉꠣꠝ ꠈꠛꠞ ꠔꠥꠝꠤ ꠟꠥꠇꠣꠁꠀ ꠞꠣꠈꠤꠅ ꠘꠣ, ꠇꠣꠞꠘ ꠡꠝꠄ ꠊꠘꠣꠁꠀ ꠀꠁꠌ꠆ꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV22_11","096_22_11","REV","22","11","11","ꠎꠦꠉꠤꠄ ꠘꠣꠚꠞꠝꠣꠘꠤ ꠇꠞꠦꠞ, ꠢꠦ ꠅꠟꠣ ꠇꠞꠣꠔ ꠞꠃꠇ। ꠎꠦꠉꠥ ꠈꠛꠤꠍ, ꠁꠉꠥ ꠔꠣꠞ ꠈꠛꠤꠍꠤꠔ ꠞꠃꠇ। ꠀꠞ ꠙꠞꠦꠎꠉꠣꠞ ꠎꠘꠦ ꠙꠞꠦꠎꠉꠣꠞꠤ ꠇꠞꠣꠔ ꠞꠃꠇ, ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠎꠘ ꠙꠣꠇ-ꠙꠛꠤꠔ꠆ꠞ ꠞꠃꠇ।” ");
INSERT INTO syls_vpl VALUES ("RV22_12","096_22_12","REV","22","12","12","ꠢꠎꠞꠔ ꠁꠍꠣꠄ ꠇꠁꠞꠣ, “ꠢꠥꠘꠅ, ꠀꠝꠤ ꠈꠥꠛ ꠎꠟꠖꠤ ꠀꠁꠞꠣꠝ, ꠀꠞ ꠙꠞꠔꠦꠇ ꠝꠣꠘꠡꠞ ꠀꠝꠟ-ꠘꠣꠝꠣꠞ ꠙꠥꠞꠥꠡ꠆ꠇꠣꠞ ꠀꠝꠣꠞ ꠀꠔꠅ ꠀꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV22_13","096_22_13","REV","22","13","13","ꠀꠝꠤꠃ ꠀꠟꠤꠚ ꠀꠞ ꠁꠀ, ꠀꠃꠀꠟ ꠀꠞ ꠀꠈꠦꠞ, ꠡꠥꠞꠥ ꠀꠞ ꠡꠦꠡ। ");
INSERT INTO syls_vpl VALUES ("RV22_14","096_22_14","REV","22","14","14","“ꠔꠣꠞꠣꠃ ꠘꠦꠇ-ꠇꠙꠣꠟꠤ, ꠎꠦꠞꠣ ꠘꠤꠎꠞ ꠇꠣꠙꠠ-ꠌꠥꠙꠠ ꠗꠁꠀ ꠙꠞꠤꠡ꠆ꠇꠣꠞ ꠇꠞꠦ, ꠎꠣꠔꠦ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠉꠣꠍꠞ ꠚꠟ ꠈꠣꠅꠀꠞ ꠅꠗꠤꠇꠣꠞ ꠙꠣꠄ, ꠀꠞ ꠉꠦꠁꠐꠦꠖꠤ ꠉꠤꠀ ꠙꠛꠤꠔ꠆ꠞ ꠐꠣꠃꠘꠅ ꠢꠣꠝꠣꠄ। ");
INSERT INTO syls_vpl VALUES ("RV22_15","096_22_15","REV","22","15","15","ꠇꠥꠇꠞꠞ ꠟꠣꠈꠣꠘ ꠎꠊꠁꠘ꠆ꠘ ꠝꠣꠘꠥꠡ, ꠎꠣꠖꠥꠉꠤꠞ, ꠎꠤꠘꠣꠇꠥꠞ, ꠈꠥꠘꠤ, ꠝꠥꠞ꠆ꠔꠤꠙꠥꠎꠣ ꠇꠞꠞꠣ, ꠀꠞ ꠎꠦꠔꠣꠄ ꠝꠤꠍꠣ ꠝꠣꠔ ꠙꠍꠘ꠆ꠖ ꠇꠞꠦ, ꠝꠤꠍꠣꠞ ꠝꠣꠎꠦ ꠌꠟꠦ, ꠁꠔꠣ ꠢꠇ꠆ꠇꠟꠐꠤ ꠛꠣꠞꠦ ꠙꠠꠤ ꠞꠁꠍꠦ। ");
INSERT INTO syls_vpl VALUES ("RV22_16","096_22_16","REV","22","16","16","“ꠔꠦ ꠀꠝꠤ ꠁꠍꠣꠄ ꠀꠝꠣꠞ ꠚꠤꠞꠤꠡ꠆ꠔꠣꠞꠦ ꠙꠣꠑꠣꠁꠍꠤ, ꠎꠣꠔꠦ ꠄꠁꠘ ꠎꠝꠣꠔ ꠅꠇꠟꠞ ꠟꠣꠉꠤ ꠔꠥꠝꠞꠣꠞ ꠉꠦꠍꠦ ꠅꠔꠣ ꠢꠇꠟ ꠛꠦꠙꠣꠞꠦ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠦꠁꠘ। ꠀꠝꠤ ꠔ ꠛꠣꠖꠡꠣ ꠖꠣꠃꠖꠞ ꠈꠣꠘ꠆ꠖꠣꠘ ꠀꠞ ꠝꠥꠟ ꠎꠠ, ꠚꠎꠞꠞ ꠌꠇꠌꠇꠣ ꠡꠥꠇ-ꠔꠦꠞꠣ।” ");
INSERT INTO syls_vpl VALUES ("RV22_17","096_22_17","REV","22","17","17","ꠙꠣꠇ ꠞꠥꠢꠦ ꠀꠞ ꠇꠁꠘꠣꠄ ꠇꠁꠞꠣ, “ꠀꠅ।” ꠀꠞ ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠇꠕꠣ ꠢꠥꠘꠦꠞ, ꠢꠦ-ꠅ ꠇꠃꠇ, “ꠀꠅ।” ꠙꠣꠘꠤꠞ ꠙꠤꠀꠍꠦ ꠎꠣꠞꠦ ꠗꠞꠍꠦ, ꠢꠦ ꠀꠃꠇ। ꠎꠦ ꠎꠘꠦ ꠙꠣꠘꠤ ꠈꠣꠁꠔ ꠌꠣꠄ, ꠢꠦ ꠛꠤꠘꠣ ꠙꠄꠡꠣꠄ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠙꠣꠘꠤ ꠈꠣꠃꠇ। ");
INSERT INTO syls_vpl VALUES ("RV22_18","096_22_18","REV","22","18","18","ꠎꠦ ꠎꠘꠦ ꠅꠃ ꠇꠤꠔꠣꠛꠞ ꠢꠇꠟ ꠀꠉꠣꠝ ꠈꠛꠞ ꠢꠥꠘꠦ, ꠔꠣꠞ ꠉꠦꠍꠦ ꠀꠝꠤ ꠅꠃ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠀꠞ, ꠇꠦꠃ ꠎꠥꠖꠤ ꠅꠃ ꠀꠄꠀꠔ ꠅꠇꠟꠞ ꠟꠉꠦ ꠖꠥꠍꠞꠣ ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠠꠣꠄ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄꠅ ꠅꠃ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠢꠇꠟ ꠘꠝꠥꠘꠣꠞ ꠉꠎꠛ ꠔꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤꠔ ꠛꠣꠠꠣꠁꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV22_19","096_22_19","REV","22","19","19","ꠀꠞ ꠅꠃ ꠇꠤꠔꠣꠛꠞ ꠀꠄꠀꠔ ꠅꠇꠟ ꠕꠣꠇꠤ ꠇꠦꠃ ꠎꠥꠖꠤ ꠇꠥꠘ꠆ꠔꠣ ꠛꠣꠖ ꠖꠦꠄ, ꠔꠦ ꠀꠟ꠆ꠟꠣꠄꠅ ꠁ ꠇꠤꠔꠣꠛꠅ ꠟꠦꠈꠣ ꠎꠤꠘ꠆ꠖꠦꠉꠤ-ꠉꠣꠍ ꠀꠞ ꠙꠛꠤꠔ꠆ꠞ ꠐꠣꠃꠘꠞ ꠅꠗꠤꠇꠣꠞ, ꠔꠣꠞ ꠎꠤꠘ꠆ꠖꠦꠉꠤ ꠕꠣꠇꠤ ꠛꠣꠖ ꠖꠤꠛꠣ। ");
INSERT INTO syls_vpl VALUES ("RV22_20","096_22_20","REV","22","20","20","ꠅꠃ ꠛꠦꠙꠣꠞ ꠅꠇꠟ ꠟꠁꠀ ꠎꠦꠁꠘ ꠎꠛꠣꠘꠛꠘ꠆ꠖꠤ ꠖꠤꠞꠣ, ꠔꠣꠁꠘ ꠇꠁꠞꠣ, “ꠢꠣꠍꠣꠃ, ꠀꠝꠤ ꠈꠥꠛ ꠎꠟꠖꠤ ꠀꠁꠞꠣꠝ।” ꠀꠝꠤꠘ। ꠢꠎꠞꠔ ꠁꠍꠣ, ꠀꠙꠘꠦ ꠔꠡꠞꠤꠚ ꠀꠘꠃꠇ꠆ꠇꠣ। ");
INSERT INTO syls_vpl VALUES ("RV22_21","096_22_21","REV","22","21","21","ꠀꠟ꠆ꠟꠣꠞ ꠔꠣꠝꠣꠝ ꠙꠣꠇ ꠛꠘ꠆ꠖꠣ ꠅꠇꠟꠞ ꠃꠙꠞꠦ, ꠢꠎꠞꠔ ꠁꠍꠣꠞ ꠞꠢꠝꠔ ꠎꠣꠞꠤ ꠞꠃꠇ। ꠀꠝꠤꠘ॥ ꠈꠔꠝ॥");
ALTER TABLE syls_vpl ADD FULLTEXT(verseText);
UNLOCK TABLES;
